diff --git a/.github/actions/build_pyamplicol/action.yml b/.github/actions/build_pyamplicol/action.yml
new file mode 100644
index 0000000000..9024253c78
--- /dev/null
+++ b/.github/actions/build_pyamplicol/action.yml
@@ -0,0 +1,38 @@
+name: Build pyamplicol
+description: >
+  Build the pyamplicol install prefix once per commit with pyamplicol/install.py
+  and cache it (content-addressed on the pyamplicol package sources). Test jobs
+  restore the result with the install_pyamplicol action (they must `needs:` the
+  job that runs this action). Assumes the repository is already checked out.
+
+runs:
+  using: composite
+  steps:
+    # Must match the key computed by the install_pyamplicol action exactly.
+    - name: pyamplicol cache key
+      run: echo "PAC_PY=$(python3 -c 'import sys;print(f"{sys.version_info.major}{sys.version_info.minor}")')" >> $GITHUB_ENV
+      shell: bash
+
+    - name: Cache pyamplicol install
+      id: cache-pyamplicol
+      uses: actions/cache@v5
+      with:
+        path: pyamplicol/install
+        key: pyamplicol-${{ runner.os }}-py${{ env.PAC_PY }}-${{ hashFiles('pyamplicol/src/**', 'pyamplicol/rust/**', 'pyamplicol/build_backend/**', 'pyamplicol/Cargo.*', 'pyamplicol/pyproject.toml', 'pyamplicol/rust-toolchain.toml', 'pyamplicol/dependencies/*.toml') }}
+
+    # ~1.5 GB: one entry per dependency set, pyamplicol's crates rebuild on top.
+    - name: Cache Cargo build tree
+      if: steps.cache-pyamplicol.outputs.cache-hit != 'true'
+      uses: actions/cache@v5
+      with:
+        path: pyamplicol/build/cache
+        key: pyamplicol-cargo-${{ runner.os }}-${{ hashFiles('pyamplicol/Cargo.lock', 'pyamplicol/rust-toolchain.toml') }}
+
+    - name: Prepared models
+      if: steps.cache-pyamplicol.outputs.cache-hit != 'true'
+      uses: ./.github/actions/pyamplicol_prepared_models
+
+    - name: Build and install pyamplicol (only on cache miss)
+      if: steps.cache-pyamplicol.outputs.cache-hit != 'true'
+      run: python3 pyamplicol/install.py --source --yes
+      shell: bash
diff --git a/.github/actions/install_pyamplicol/action.yml b/.github/actions/install_pyamplicol/action.yml
new file mode 100644
index 0000000000..feb0a5e0a0
--- /dev/null
+++ b/.github/actions/install_pyamplicol/action.yml
@@ -0,0 +1,26 @@
+name: Install pyamplicol
+description: >
+  Make the pyamplicol install (built once per commit by a build_pyamplicol job)
+  available to the tests: restores the cached pyamplicol/install directory and
+  puts it on PYTHONPATH. It does NOT build; the build_pyamplicol job must run
+  first (use `needs:`).
+
+runs:
+  using: composite
+  steps:
+    # Must match the key computed by the build_pyamplicol action exactly.
+    - name: pyamplicol cache key
+      run: echo "PAC_PY=$(python3 -c 'import sys;print(f"{sys.version_info.major}{sys.version_info.minor}")')" >> $GITHUB_ENV
+      shell: bash
+
+    - name: Restore pyamplicol install
+      uses: actions/cache/restore@v5
+      with:
+        path: pyamplicol/install
+        key: pyamplicol-${{ runner.os }}-py${{ env.PAC_PY }}-${{ hashFiles('pyamplicol/src/**', 'pyamplicol/rust/**', 'pyamplicol/build_backend/**', 'pyamplicol/Cargo.*', 'pyamplicol/pyproject.toml', 'pyamplicol/rust-toolchain.toml', 'pyamplicol/dependencies/*.toml') }}
+        fail-on-cache-miss: true
+
+    # Prepended: in the MadGraph root, pyamplicol/ is the source directory.
+    - name: Put pyamplicol on PYTHONPATH
+      run: echo "PYTHONPATH=$GITHUB_WORKSPACE/pyamplicol/install:$PYTHONPATH" >> "$GITHUB_ENV"
+      shell: bash
diff --git a/.github/actions/pyamplicol_prepared_models/action.yml b/.github/actions/pyamplicol_prepared_models/action.yml
new file mode 100644
index 0000000000..0075f42f4a
--- /dev/null
+++ b/.github/actions/pyamplicol_prepared_models/action.yml
@@ -0,0 +1,39 @@
+name: pyAmpliCol prepared models
+description: >
+  Put the prepared-model packs into the pyamplicol source tree. They are not
+  tracked in Git: the archive of the matching (else latest) MadGraph release is
+  downloaded and validated against this source tree; when it is stale, the packs
+  are regenerated on this runner (bootstrap wheel + produce, about ten minutes).
+  Either way the archive ends up at pyamplicol/.artifacts/prepared-models/ for
+  jobs that publish or reuse it. Needs Python 3.11+ and, for a regeneration,
+  the pinned Rust toolchain and maturin.
+
+outputs:
+  regenerated:
+    description: "'true' when the released packs were stale and rebuilt here."
+    value: ${{ steps.packs.outputs.regenerated }}
+
+runs:
+  using: composite
+  steps:
+    - name: Fetch or regenerate the prepared models
+      id: packs
+      shell: bash
+      working-directory: pyamplicol
+      run: |
+        set -euo pipefail
+        archive_dir=.artifacts/prepared-models
+        tool=tools/release/prepared_models_archive.py
+        check='import sys; from pathlib import Path; sys.path.insert(0, "build_backend"); from prepared_models import stage_packaged_prepared_models as s; s(Path("."), "release")'
+        if python "$tool" fetch --version "$(sed -n 's/^version *= *//p' ../VERSION)" \
+              --output "$archive_dir" && python -I -c "$check"; then
+          echo "regenerated=false" >> "$GITHUB_OUTPUT"
+        else
+          echo "::notice::The released prepared models are stale for this source tree; regenerating them."
+          rustup toolchain install "$(sed -n 's/^channel *= *"\(.*\)"/\1/p' rust-toolchain.toml)" --profile minimal
+          python -m pip install "maturin==1.15.0" "packaging==26.3"
+          PYAMPLICOL_BUILD_MODE=release python "$tool" regenerate --work .artifacts/prepared-models-work
+          rm -rf "$archive_dir"
+          python "$tool" pack --output "$archive_dir"
+          echo "regenerated=true" >> "$GITHUB_OUTPUT"
+        fi
diff --git a/.github/scripts/import_pyamplicol.sh b/.github/scripts/import_pyamplicol.sh
new file mode 100755
index 0000000000..d46e49d42f
--- /dev/null
+++ b/.github/scripts/import_pyamplicol.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# Import (or re-sync) the history of github.com/MadGraphTeam/pyamplicol into
+# the pyamplicol/ subdirectory. The filter is deterministic, so re-running it
+# on a newer upstream main reproduces the SHAs of commits imported earlier and
+# a merge only brings in the new ones.
+#
+# Usage: .github/scripts/import_pyamplicol.sh [upstream-ref]
+# Leaves the filtered history in the local branch pyamplicol-import; merge it
+# with `git merge pyamplicol-import` (first import: --allow-unrelated-histories).
+# Requires git-filter-repo (set FILTER_REPO to override the command).
+set -euo pipefail
+
+UPSTREAM_URL=${UPSTREAM_URL:-https://github.com/MadGraphTeam/pyamplicol.git}
+REF=${1:-main}
+FILTER_REPO=${FILTER_REPO:-git-filter-repo}
+MG_ROOT=$(git rev-parse --show-toplevel)
+
+WORK=$(mktemp -d)
+trap 'rm -rf "$WORK"' EXIT
+
+git clone --quiet --no-local --single-branch --branch "$REF" "$UPSTREAM_URL" "$WORK/pyamplicol"
+cd "$WORK/pyamplicol"
+UPSTREAM_SHA=$(git rev-parse HEAD)
+
+# Prepared-model packs are rebuilt in CI and shipped as one release archive;
+# reports and papers are linked from the archived upstream repository.
+$FILTER_REPO --force \
+    --path-glob '*.pyamplicol-model' --invert-paths \
+    --path-glob '*.pdf' --invert-paths \
+    --to-subdirectory-filter pyamplicol
+
+git -C "$MG_ROOT" fetch --quiet --no-tags "$WORK/pyamplicol" "+HEAD:refs/heads/pyamplicol-import"
+echo "Imported $UPSTREAM_URL $REF at $UPSTREAM_SHA into branch pyamplicol-import"
diff --git a/.github/workflows/pyamplicol-eager-portability.yml b/.github/workflows/pyamplicol-eager-portability.yml
new file mode 100644
index 0000000000..a6dc57f6d6
--- /dev/null
+++ b/.github/workflows/pyamplicol-eager-portability.yml
@@ -0,0 +1,218 @@
+name: pyAmpliCol eager JIT pack architecture transfer
+
+# Ported from pyamplicol: packs produced on one architecture must work on the
+# others, which the installer relies on when it regenerates them locally.
+
+on:
+  pull_request:
+    paths:
+      - .github/workflows/pyamplicol-eager-portability.yml
+      - pyamplicol/Cargo.lock
+      - pyamplicol/Cargo.toml
+      - pyamplicol/build_backend/prepared_models.py
+      - pyamplicol/dependencies/release-lock.toml
+      - pyamplicol/pyproject.toml
+      - pyamplicol/rust/crates/rusticol-core/src/eager_runtime/**
+      - pyamplicol/rust/crates/rusticol-core/src/eager_runtime.rs
+      - pyamplicol/rust/crates/rusticol-core/src/eager_tables.rs
+      - pyamplicol/rust/crates/rusticol-core/src/engine/**
+      - pyamplicol/rust/crates/rusticol-core/src/engine.rs
+      - pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit.rs
+      - pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_plane.rs
+      - pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_direct.rs
+      - pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_eager_direct.rs
+      - pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_compiled_direct.rs
+      - pyamplicol/rust/crates/rusticol-core/src/lib.rs
+      - pyamplicol/rust/crates/rusticol-python/src/lib.rs
+      - pyamplicol/src/pyamplicol/_internal/physics/symbols.py
+      - pyamplicol/src/pyamplicol/_internal/versions.py
+      - pyamplicol/src/pyamplicol/config/**
+      - pyamplicol/src/pyamplicol/evaluators/symbolica*.py
+      - pyamplicol/src/pyamplicol/generation/**
+      - pyamplicol/src/pyamplicol/models/prepared*.py
+      - pyamplicol/src/pyamplicol/runtime/eager_exact/**
+      - pyamplicol/tools/ci/eager_portability*.py
+  push:
+    branches: [main]
+    paths:
+      - .github/workflows/pyamplicol-eager-portability.yml
+      - pyamplicol/Cargo.lock
+      - pyamplicol/Cargo.toml
+      - pyamplicol/build_backend/prepared_models.py
+      - pyamplicol/dependencies/release-lock.toml
+      - pyamplicol/pyproject.toml
+      - pyamplicol/rust/crates/rusticol-core/src/eager_runtime/**
+      - pyamplicol/rust/crates/rusticol-core/src/eager_runtime.rs
+      - pyamplicol/rust/crates/rusticol-core/src/eager_tables.rs
+      - pyamplicol/rust/crates/rusticol-core/src/engine/**
+      - pyamplicol/rust/crates/rusticol-core/src/engine.rs
+      - pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit.rs
+      - pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_plane.rs
+      - pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_direct.rs
+      - pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_eager_direct.rs
+      - pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_compiled_direct.rs
+      - pyamplicol/rust/crates/rusticol-core/src/lib.rs
+      - pyamplicol/rust/crates/rusticol-python/src/lib.rs
+      - pyamplicol/src/pyamplicol/_internal/physics/symbols.py
+      - pyamplicol/src/pyamplicol/_internal/versions.py
+      - pyamplicol/src/pyamplicol/config/**
+      - pyamplicol/src/pyamplicol/evaluators/symbolica*.py
+      - pyamplicol/src/pyamplicol/generation/**
+      - pyamplicol/src/pyamplicol/models/prepared*.py
+      - pyamplicol/src/pyamplicol/runtime/eager_exact/**
+      - pyamplicol/tools/ci/eager_portability*.py
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    working-directory: pyamplicol
+
+concurrency:
+  group: pyamplicol-eager-portability-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  produce-architecture-packs:
+    name: Produce prepared JIT pack (${{ matrix.target }})
+    runs-on: ${{ matrix.runner }}
+    concurrency:
+      group: "pyamplicol-symbolica-${{ startsWith(matrix.runner, 'macos-') && matrix.runner || format('{0}-{1}', matrix.runner, github.run_id) }}"
+      cancel-in-progress: false
+      queue: max
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-24.04
+            target: linux-x86-64
+            system: Linux
+            machine: x86_64
+            pack_architecture: x86_64
+          - runner: macos-15
+            target: macos-arm64
+            system: Darwin
+            machine: arm64
+            pack_architecture: aarch64
+    env:
+      PYAMPLICOL_BUILD_MODE: release
+      PYTHONDONTWRITEBYTECODE: "1"
+      SYMBOLICA_HIDE_BANNER: "1"
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: "3.11"
+          cache: pip
+          cache-dependency-path: |
+            pyamplicol/pyproject.toml
+            pyamplicol/dependencies/release-lock.toml
+            pyamplicol/dependencies/python-runtime-lock.toml
+      - uses: dtolnay/rust-toolchain@46511b1c83438f0dd37c02d843619ece5a4abb5b # 1.97.1
+      - name: Install pinned build tools
+        run: python -m pip install "maturin==1.15.0" "packaging==26.3"
+      - name: Build the non-publishable release bootstrap wheel
+        run: >-
+          python tools/ci/memory_watchdog.py --limit-gib 30 --
+          python tools/release/prepare_release_prepared_models.py
+          bootstrap-wheel .artifacts/release-prepared-bootstrap
+      - name: Install the isolated published-dependency runtime
+        run: |
+          python -m venv .venv
+          .venv/bin/python -m pip install .artifacts/release-prepared-bootstrap/pyamplicol-*.whl
+      - name: Produce host-labelled portable built-in JIT O2 packs
+        run: >-
+          .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 --
+          .venv/bin/python tools/ci/eager_portability.py produce
+          .artifacts/eager-portability-transfer/${{ matrix.pack_architecture }}
+          --python .venv/bin/python
+          --asset-mode release
+          --expected-system ${{ matrix.system }}
+          --expected-machine ${{ matrix.machine }}
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: pyamplicol-eager-jit-transfer-${{ matrix.pack_architecture }}
+          path: pyamplicol/.artifacts/eager-portability-transfer/${{ matrix.pack_architecture }}/
+          if-no-files-found: error
+          retention-days: 14
+
+  consume-matching-architecture-pack:
+    name: Consume portable pack (${{ matrix.target }})
+    needs: produce-architecture-packs
+    runs-on: ${{ matrix.runner }}
+    concurrency:
+      group: "pyamplicol-symbolica-${{ startsWith(matrix.runner, 'macos-') && matrix.runner || format('{0}-{1}', matrix.runner, github.run_id) }}"
+      cancel-in-progress: false
+      queue: max
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-24.04
+            target: linux-x86-64
+            system: Linux
+            machine: x86_64
+            pack_architecture: x86_64
+          - runner: macos-15-intel
+            target: macos-x86-64
+            system: Darwin
+            machine: x86_64
+            pack_architecture: x86_64
+          - runner: macos-15
+            target: macos-arm64
+            system: Darwin
+            machine: arm64
+            pack_architecture: aarch64
+    env:
+      PYAMPLICOL_BUILD_MODE: release
+      PYTHONDONTWRITEBYTECODE: "1"
+      SYMBOLICA_HIDE_BANNER: "1"
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: "3.11"
+          cache: pip
+          cache-dependency-path: |
+            pyamplicol/pyproject.toml
+            pyamplicol/dependencies/release-lock.toml
+            pyamplicol/dependencies/python-runtime-lock.toml
+      - uses: dtolnay/rust-toolchain@46511b1c83438f0dd37c02d843619ece5a4abb5b # 1.97.1
+      - uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        with:
+          name: pyamplicol-eager-jit-transfer-${{ matrix.pack_architecture }}
+          path: pyamplicol/.artifacts/eager-portability-transfer
+      - name: Install pinned build tools
+        run: python -m pip install "maturin==1.15.0" "packaging==26.3"
+      - name: Build the non-publishable release bootstrap wheel
+        run: >-
+          python tools/ci/memory_watchdog.py --limit-gib 30 --
+          python tools/release/prepare_release_prepared_models.py
+          bootstrap-wheel .artifacts/release-prepared-bootstrap
+      - name: Install the isolated published-dependency runtime
+        run: |
+          python -m venv .venv
+          .venv/bin/python -m pip install .artifacts/release-prepared-bootstrap/pyamplicol-*.whl
+      - name: Generate and evaluate from the portable pack
+        run: >-
+          .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 --
+          .venv/bin/python tools/ci/eager_portability.py consume
+          .artifacts/eager-portability-transfer
+          --python .venv/bin/python
+          --expected-system ${{ matrix.system }}
+          --expected-machine ${{ matrix.machine }}
+          --report .artifacts/eager-portability-results/${{ matrix.target }}.json
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: pyamplicol-eager-jit-result-${{ matrix.target }}
+          path: pyamplicol/.artifacts/eager-portability-results/${{ matrix.target }}.json
+          if-no-files-found: error
+          retention-days: 14
diff --git a/.github/workflows/pyamplicol.yml b/.github/workflows/pyamplicol.yml
new file mode 100644
index 0000000000..b847a4b4e9
--- /dev/null
+++ b/.github/workflows/pyamplicol.yml
@@ -0,0 +1,623 @@
+name: pyAmpliCol
+
+# Ported from the standalone pyamplicol repository (tests.yml and
+# release-artifacts.yml). Every job runs inside pyamplicol/.
+on:
+  push:
+    # All branches, no tags (see madspace.yml): release.yml gates on the run
+    # for the commit on main and then calls this workflow to build the wheels.
+    branches:
+      - '**'
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      full_matrix:
+        description: 'Also build and test the release sdist and wheels'
+        type: boolean
+        default: false
+  workflow_call:
+    inputs:
+      full_matrix:
+        description: 'Also build and test the release sdist and wheels'
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+
+concurrency:
+  group: pyamplicol-${{ github.ref }}-${{ github.event_name }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+defaults:
+  run:
+    working-directory: pyamplicol
+
+env:
+  PYTHONDONTWRITEBYTECODE: "1"
+  SYMBOLICA_HIDE_BANNER: "1"
+
+jobs:
+  # Skips the heavy jobs unless pyamplicol changed; a job, not `paths:`, so every
+  # commit still gets a (green) run for release.yml's CI gate.
+  changes:
+    runs-on: ubuntu-24.04
+    outputs:
+      pyamplicol: ${{ steps.diff.outputs.pyamplicol }}
+    defaults:
+      run:
+        working-directory: .
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - id: diff
+        env:
+          EVENT: ${{ github.event_name }}
+          PUSH_BEFORE: ${{ github.event.before }}
+          PR_BASE: ${{ github.event.pull_request.base.sha }}
+          # Release builds only build artifacts; main's run already tested them.
+          FULL_MATRIX: ${{ inputs.full_matrix && 'true' || 'false' }}
+        run: |
+          set -euo pipefail
+          if [[ "$FULL_MATRIX" == true ]]; then
+            echo "pyamplicol=false" | tee -a "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          case "$EVENT" in
+            push) base="$PUSH_BEFORE" ;;
+            pull_request) base="$PR_BASE" ;;
+            *) base="" ;;
+          esac
+          if [[ -z "$base" || "$base" =~ ^0+$ ]] || ! git cat-file -e "$base^{commit}" 2>/dev/null; then
+            changed=true
+          elif git diff --name-only "$base" HEAD \
+              | grep -qE '^(pyamplicol/|\.github/workflows/pyamplicol|\.github/actions/(pyamplicol|build_pyamplicol|install_pyamplicol)|VERSION$)'; then
+            changed=true
+          else
+            changed=false
+          fi
+          echo "pyamplicol=$changed" | tee -a "$GITHUB_OUTPUT"
+
+  python-compatibility:
+    name: Python ${{ matrix.python-version }} lightweight API
+    needs: changes
+    if: needs.changes.outputs.pyamplicol == 'true'
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+          cache-dependency-path: pyamplicol/pyproject.toml
+      - name: Install lightweight test dependency
+        run: python -m pip install "pytest>=8.3,<9"
+      - name: Check lightweight typed configuration API
+        env:
+          PYTHONPATH: ${{ github.workspace }}/pyamplicol/src
+        run: >-
+          python -m pytest
+          tests/unit/test_config_models.py
+          tests/unit/test_config_resolution.py
+          -q
+      - name: Check the CI memory watchdog
+        if: matrix.python-version == '3.11'
+        run: python -m pytest tests/unit/test_ci_memory_watchdog.py -q
+
+  source-contracts:
+    name: Python 3.11 source and release contracts
+    needs: changes
+    if: needs.changes.outputs.pyamplicol == 'true'
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+          cache: pip
+          cache-dependency-path: pyamplicol/pyproject.toml
+      - name: Install source-contract test dependency
+        run: python -m pip install "pytest>=8.3,<9"
+      - name: Prepared models
+        uses: ./.github/actions/pyamplicol_prepared_models
+      - name: Check the version follows the MadGraph VERSION file
+        run: python tools/release/sync_version.py --check
+      - name: Check public source, repository, and release contracts
+        env:
+          PYTHONPATH: ${{ github.workspace }}/pyamplicol/src
+        run: >-
+          python -m pytest
+          tests/unit/test_api_requests.py
+          tests/unit/test_cli_parser.py
+          tests/unit/test_deployment_harness.py
+          tests/unit/test_public_import_laziness.py
+          tests/unit/test_repository_policy.py
+          tests/unit/test_sdk_config.py
+          tests/unit/test_otf_cache.py
+          tests/release
+          --deselect
+          tests/unit/test_api_requests.py::test_public_compiled_model_uses_the_canonical_schema
+          -q
+
+  # Builds through the MadGraph installer and checks that Symbolica accepts the
+  # package library key; the install is cached for install_pyamplicol.
+  installer:
+    name: MadGraph installer and Symbolica library key
+    needs: changes
+    if: needs.changes.outputs.pyamplicol == 'true'
+    runs-on: ubuntu-24.04
+    defaults:
+      run:
+        working-directory: .
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+      - name: Build pyamplicol with install.py (checks the library key)
+        uses: ./.github/actions/build_pyamplicol
+      - name: Library key from the MadGraph root, as the [amplicol] worker sees it
+        run: |
+          python - <<'EOF'
+          import sys
+          sys.path.insert(0, ".")
+          from madgraph.iolibs.template_files.mg7 import bootstrap
+          bootstrap.ensure_pyamplicol(interactive=False)
+          bootstrap.check_pyamplicol_license()
+          assert bootstrap.check_pyamplicol_source_hash()
+          print("pyamplicol library key accepted; source hash matches")
+          EOF
+      - name: Warn before the library key expires
+        run: |
+          expiry=$(grep -o 'SU-[0-9]*-pyamplicol-[0-9.]*' pyamplicol/src/pyamplicol/__init__.py \
+            | sed 's/.*-//' | tr . -)
+          days=$(( ($(date -d "$expiry" +%s) - $(date +%s)) / 86400 ))
+          echo "pyamplicol's Symbolica library key expires on $expiry ($days days)."
+          if (( days < 90 )); then
+            echo "::warning::pyamplicol's Symbolica library key expires on $expiry; request a renewed key."
+          fi
+      - name: Symbolica is licensed outside the MadGraph root
+        env:
+          PYTHONPATH: ${{ github.workspace }}/pyamplicol/install
+        run: |
+          cd "$RUNNER_TEMP"
+          env -u SYMBOLICA_LICENSE python - <<'EOF'
+          import pyamplicol
+          from pyamplicol.licensing import detect_symbolica_license
+          state = detect_symbolica_license(suggest=False)
+          print(state)
+          assert state.licensed, "Symbolica runs in restricted mode"
+          EOF
+
+  release-runtime:
+    name: Published-dependency generation, runtime, and native SDK
+    needs: [changes, python-compatibility, source-contracts]
+    if: needs.changes.outputs.pyamplicol == 'true' && github.event_name != 'push'
+    runs-on: ubuntu-24.04
+    env:
+      CARGO_INCREMENTAL: "0"
+      PYAMPLICOL_BUILD_MODE: release
+      PYAMPLICOL_REQUIRE_NATIVE_TESTS: "1"
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+          cache: pip
+          cache-dependency-path: |
+            pyamplicol/pyproject.toml
+            pyamplicol/dependencies/release-lock.toml
+            pyamplicol/dependencies/contributor-lock.toml
+            pyamplicol/dependencies/python-runtime-lock.toml
+      - uses: dtolnay/rust-toolchain@1.97.1
+      - name: Cache Cargo downloads
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.cargo/registry/index
+            ~/.cargo/registry/cache
+            ~/.cargo/git/db
+          key: ${{ runner.os }}-cargo-1.97.1-${{ hashFiles('pyamplicol/Cargo.lock', 'pyamplicol/dependencies/contributor-lock.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-1.97.1-
+      - name: Install C++17 and Fortran 2008 toolchains
+        run: |
+          sudo apt-get update
+          sudo apt-get install --no-install-recommends -y g++ gfortran make
+          command -v c++
+          command -v gfortran
+          command -v make
+      - name: Prepared models
+        uses: ./.github/actions/pyamplicol_prepared_models
+      - name: Build and stage the published-dependency runtime (30 GiB RSS limit)
+        run: >-
+          python tools/ci/memory_watchdog.py --limit-gib 30 --
+          python dependencies/install_dependencies.py
+      - name: Run lightweight dependency, typing, and CI-tool checks
+        run: |
+          .venv/bin/python tools/release/check_dependencies.py
+          PYTHON="$PWD/.venv/bin/python" just typing
+          .venv/bin/python -m ruff check tools/ci tests/unit/test_ci_memory_watchdog.py
+      - name: Build and exercise native APIs and UMAMI shared providers (30 GiB RSS limit)
+        env:
+          RUST_BACKTRACE: "1"
+        run: >-
+          .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 --
+          .venv/bin/python -m pytest
+          tests/integration/test_multilanguage_api.py
+          tests/integration/test_correlated_native_sdk.py
+          tests/integration/test_otf_cache_native_sdk.py
+          tests/integration/test_umami_api.py
+          -q -s
+      - name: Run focused Python unit checks (30 GiB RSS limit)
+        run: |
+          .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 -- \
+            .venv/bin/python -m pytest \
+            tests/unit/test_api_requests.py \
+            tests/unit/test_api_bundle.py \
+            tests/unit/test_umami_metadata.py \
+            tests/unit/test_umami_semantics.py \
+            tests/unit/test_benchmarking.py \
+            tests/unit/test_adjoint_color_contraction.py \
+            tests/unit/test_adjoint_generation_scope.py \
+            tests/unit/test_adjoint_singlet_color_certificate.py \
+            tests/unit/test_fft_basis_strategy.py \
+            tests/unit/test_compiler_kernel_scale.py \
+            tests/unit/test_compiler_auxiliary_components.py \
+            tests/unit/test_heft_contact_trees.py \
+            tests/unit/test_sm_heft_model.py \
+            tests/unit/test_recurrence_numerical_current_warmup.py \
+            tests/unit/test_recurrence_exact_contracted_color.py \
+            tests/unit/test_recurrence_direct_intrinsics.py \
+            tests/unit/test_config_models.py \
+            tests/unit/test_config_resolution.py \
+            tests/unit/test_dag_model_independence.py \
+            tests/unit/test_exact_parameter_precision.py \
+            tests/unit/test_exact_color_weight.py \
+            tests/unit/test_exact_symbolic_propagators.py \
+            tests/unit/test_stage_exact_weights.py \
+            tests/unit/test_color_connection_catalogue.py \
+            tests/unit/test_color_connections.py \
+            tests/unit/test_color_correlator_matrices.py \
+            tests/unit/test_correlat*.py \
+            tests/unit/test_nlo_limit_study.py \
+            tests/unit/test_exact_vertex_normalization.py \
+            tests/unit/test_external_model_independence.py \
+            tests/unit/test_generation_config_provenance.py \
+            tests/unit/test_generation_execution_schema.py \
+            tests/unit/test_generation_stage_contract.py \
+            tests/unit/test_model_loading.py \
+            tests/unit/test_sdk_config.py \
+            tests/unit/test_selftest_fixture.py \
+            tests/unit/test_symbolica_exact.py \
+            -q
+      - name: Run eager prepared-model and runtime unit checks (30 GiB RSS limit)
+        run: >-
+          .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 --
+          .venv/bin/python -m pytest
+          tests/unit/test_eager_*.py
+          tests/unit/test_model_source_prepared_compile.py
+          tests/unit/test_packaged_prepared_model*.py
+          tests/unit/test_prepared_*.py
+          -q
+      - name: Run focused generation and runtime integration (30 GiB RSS limit)
+        # The restricted child must run first with an uninitialized parent.
+        run: |
+          .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 -- \
+            .venv/bin/python -m pytest tests/integration/test_spenso_restricted_mode.py -q
+          .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 -- \
+            .venv/bin/python -m pytest \
+            tests/integration/test_schema_v3_generation_runtime.py \
+            tests/integration/test_exact_precision_normalization.py \
+            tests/integration/test_sm_heft_backends.py \
+            tests/integration/test_heft_correlated_precision.py \
+            tests/integration/test_compiled_exact_color.py \
+            tests/integration/test_correlators.py \
+            tests/integration/test_correlator_colour_accuracy.py \
+            tests/integration/test_otf_cache.py \
+            tests/integration/test_adjoint_fft_runtime.py \
+            tests/integration/test_generalized_adjoint_fft_runtime.py \
+            tests/integration/test_recurrence_generation_runtime.py::test_ufo_sm_recurrence_refreshes_real_and_complex_derived_couplings \
+            -q
+      - name: Check Rust workspace (30 GiB RSS limit)
+        run: >-
+          .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 --
+          env PYTHON=$PWD/.venv/bin/python just rust-check
+      - name: Test Rust workspace (30 GiB RSS limit)
+        run: >-
+          .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 --
+          env PYTHON=$PWD/.venv/bin/python just rust-test
+      - name: Exercise installed release runtime and checkout-independent examples
+        run: |
+          .venv/bin/python -m pyamplicol self-test --json
+          .venv/bin/python -m pytest tests/integration/test_examples.py -q
+
+  # ---- Release artifacts (release.yml, or a manual run with full_matrix) ----
+
+  prepared-models:
+    name: Release prepared-model archive
+    if: inputs.full_matrix
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+      - name: Prepared models
+        uses: ./.github/actions/pyamplicol_prepared_models
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pyamplicol-prepared-models
+          path: pyamplicol/.artifacts/prepared-models/pyamplicol-prepared-models.tar.gz
+          if-no-files-found: error
+
+  release-source-preflight:
+    name: Focused release source preflight
+    needs: prepared-models
+    runs-on: ubuntu-24.04
+    env:
+      PYAMPLICOL_BUILD_MODE: release
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+          cache: pip
+      - uses: actions/download-artifact@v5
+        with:
+          name: pyamplicol-prepared-models
+          path: pyamplicol/.artifacts/prepared-models
+      - name: Unpack the prepared models
+        run: python tools/release/prepared_models_archive.py unpack .artifacts/prepared-models/pyamplicol-prepared-models.tar.gz
+      - name: Install focused source-test tools
+        run: python -m pip install "pytest>=8.3,<9" "ruff>=0.9,<1"
+      - name: Verify exact published dependency inputs
+        run: python tools/release/check_dependencies.py
+      - name: Run focused clean-checkout release tests
+        run: >-
+          python -m pytest
+          tests/release
+          tests/unit/test_dependency_gate.py
+          tests/unit/test_release_*.py
+          -q
+      - name: Lint release and build tooling
+        run: >-
+          ruff check
+          build_backend
+          tools/release
+          tests/release
+          tests/unit/test_dependency_gate.py
+          tests/unit/test_release_*.py
+
+  independent-physics-oracle:
+    name: Independent Fortran physics oracle
+    if: inputs.full_matrix
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+      - name: Install the independent oracle toolchain
+        run: |
+          sudo apt-get update
+          sudo apt-get install --no-install-recommends -y gfortran make
+          python -m pip install "jsonschema>=4.22,<5"
+      - name: Run independent Fortran physics comparison
+        run: |
+          set -euo pipefail
+          python tools/ci/memory_watchdog.py --limit-gib 30 -- \
+            python tools/developer/legacy_amplicol.py \
+            --prepare-checkout \
+            --fixture tests/fixtures/reference/physics-v2.json \
+            --jobs 2 >/dev/null
+
+  retained-sdist:
+    name: Build retained source distribution
+    needs: [release-source-preflight, independent-physics-oracle]
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+          cache: pip
+      - uses: dtolnay/rust-toolchain@1.97.1
+      - uses: actions/download-artifact@v5
+        with:
+          name: pyamplicol-prepared-models
+          path: pyamplicol/.artifacts/prepared-models
+      - name: Unpack the prepared models
+        run: python tools/release/prepared_models_archive.py unpack .artifacts/prepared-models/pyamplicol-prepared-models.tar.gz
+      - name: Install build tools
+        run: python -m pip install "build>=1.2,<2" "maturin==1.15.0"
+      - name: Build the one retained sdist
+        run: >-
+          python tools/ci/memory_watchdog.py --limit-gib 30 --
+          python tools/release/build_release_artifacts.py
+          --sdist-only
+          --output-dir .artifacts/release-source
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pyamplicol-retained-sdist
+          path: pyamplicol/.artifacts/release-source/
+          if-no-files-found: error
+
+  macos-wheels:
+    name: macOS release wheel and native deployment (${{ matrix.target }})
+    needs: retained-sdist
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: macos-15
+            target: macos-arm64
+          - runner: macos-15-intel
+            target: macos-x86_64
+    runs-on: ${{ matrix.runner }}
+    env:
+      MACOSX_DEPLOYMENT_TARGET: "11.0"
+      PYAMPLICOL_BUILD_MODE: release
+      RUSTUP_TOOLCHAIN: "1.97.1"
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/download-artifact@v5
+        with:
+          name: pyamplicol-retained-sdist
+          path: pyamplicol/.artifacts/retained
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+          cache: pip
+      - uses: dtolnay/rust-toolchain@1.97.1
+      - name: Install build and deployment tools
+        run: python -m pip install "build>=1.2,<2" "maturin==1.15.0" "twine>=6,<7"
+      - name: Build and audit from retained sdist
+        run: >-
+          python tools/ci/memory_watchdog.py --limit-gib 30 --
+          python tools/release/build_release_artifacts.py
+          --retained-sdist .artifacts/retained/pyamplicol-*.tar.gz
+          --output-dir .artifacts/platform
+      - name: Require C++17 and Fortran 2008 SDK toolchains
+        shell: bash
+        run: |
+          set -euo pipefail
+          command -v make
+          cxx="$(command -v c++)"
+          fc="$(command -v gfortran || true)"
+          if [[ -z "$fc" ]]; then
+            brew install gcc
+            prefix="$(brew --prefix gcc)"
+            for candidate in "$prefix/bin/gfortran" "$prefix"/bin/gfortran-*; do
+              if [[ -x "$candidate" ]]; then
+                fc="$candidate"
+                break
+              fi
+            done
+          fi
+          [[ -n "$fc" && -x "$fc" ]]
+          printf 'CXX=%s\n' "$cxx" >> "$GITHUB_ENV"
+          printf 'FC=%s\n' "$fc" >> "$GITHUB_ENV"
+      - name: Test installed wheel on CPython 3.11
+        run: >-
+          python tools/ci/memory_watchdog.py --limit-gib 30 --
+          python tools/release/test_deployment.py
+          --python "$(command -v python)"
+          --wheel .artifacts/platform/pyamplicol-*.whl
+          --no-build
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.14"
+      - name: Test installed abi3 wheel on CPython 3.14
+        run: >-
+          python tools/ci/memory_watchdog.py --limit-gib 30 --
+          python tools/release/test_deployment.py
+          --python "$(command -v python)"
+          --wheel .artifacts/platform/pyamplicol-*.whl
+          --abi3-smoke-only
+          --no-build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pyamplicol-release-${{ matrix.target }}
+          path: pyamplicol/.artifacts/platform/
+          if-no-files-found: error
+
+  manylinux-wheel:
+    name: manylinux release wheel and native deployment
+    needs: retained-sdist
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/download-artifact@v5
+        with:
+          name: pyamplicol-retained-sdist
+          path: pyamplicol/.artifacts/retained
+      - name: Build and deploy-test in manylinux_2_28 x86_64
+        run: |
+          docker run --rm \
+            -v "$PWD:/io" \
+            -w /io \
+            -e PYAMPLICOL_BUILD_MODE=release \
+            quay.io/pypa/manylinux_2_28_x86_64@sha256:b04887b645dde99b9e955aeae3ff4da414992d0bd88259f046295b56361c5614 \
+            /bin/bash -euxo pipefail -c '
+              git config --global --add safe.directory "*"
+              yum install -y gcc-c++ gcc-gfortran make
+              curl --proto "=https" --tlsv1.2 -sSf \
+                -o /tmp/rustup-init \
+                https://static.rust-lang.org/rustup/archive/1.28.2/x86_64-unknown-linux-gnu/rustup-init
+              echo "20a06e644b0d9bd2fbdbfd52d42540bdde820ea7df86e92e533c073da0cdd43c  /tmp/rustup-init" \
+                | sha256sum --check --strict
+              chmod +x /tmp/rustup-init
+              /tmp/rustup-init -y --profile minimal --default-toolchain 1.97.1
+              source "$HOME/.cargo/env"
+              export RUSTUP_TOOLCHAIN=1.97.1
+              PY311=/opt/python/cp311-cp311/bin/python
+              PY314=/opt/python/cp314-cp314/bin/python
+              "$PY311" -m pip install "build>=1.2,<2" "maturin==1.15.0" "twine>=6,<7"
+              "$PY311" tools/ci/memory_watchdog.py --limit-gib 30 -- \
+                "$PY311" tools/release/build_release_artifacts.py \
+                --retained-sdist .artifacts/retained/pyamplicol-*.tar.gz \
+                --output-dir .artifacts/platform
+              "$PY311" tools/ci/memory_watchdog.py --limit-gib 30 -- \
+                "$PY311" tools/release/test_deployment.py \
+                --python "$PY311" \
+                --wheel .artifacts/platform/pyamplicol-*.whl \
+                --no-build
+              "$PY311" tools/ci/memory_watchdog.py --limit-gib 30 -- \
+                "$PY311" tools/release/test_deployment.py \
+                --python "$PY314" \
+                --wheel .artifacts/platform/pyamplicol-*.whl \
+                --abi3-smoke-only \
+                --no-build
+            '
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pyamplicol-release-manylinux-x86_64
+          path: pyamplicol/.artifacts/platform/
+          if-no-files-found: error
+
+  validated-artifacts:
+    name: Collect validated release artifacts
+    needs: [retained-sdist, macos-wheels, manylinux-wheel]
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/download-artifact@v5
+        with:
+          pattern: pyamplicol-re*
+          path: pyamplicol/.artifacts/incoming
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+          cache: pip
+      - name: Install artifact validation tools
+        run: python -m pip install "twine>=6,<7"
+      - name: Audit and collect package files
+        run: >-
+          python tools/release/publish_dry_run.py
+          --artifact-dir .artifacts/incoming
+          --output-dir .artifacts/validated
+          --no-build
+          --require-all-targets
+          --skip-clean-install
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pyamplicol-validated-release
+          path: pyamplicol/.artifacts/validated/
+          if-no-files-found: error
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 52ed6efdec..25160316e2 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -2,8 +2,9 @@ name: Release
 
 # Fires once a GitHub Release is published (draft -> Publish release), never on
 # a tag push by itself. Checks that main's CI was green for the tagged commit,
-# publishes madspace to PyPI with the same version as the MadGraph release, and
-# attaches the MadGraph tarball to the release. If anything fails, the release
+# publishes madspace and pyamplicol to PyPI with the same version as the
+# MadGraph release, and attaches the MadGraph tarball and the pyamplicol
+# prepared-model archive to the release. If anything fails, the release
 # is reverted to draft so a half-published version never stays public.
 #
 # The test suites are deliberately NOT re-run here. Every commit on main is
@@ -89,6 +90,7 @@ jobs:
             .github/workflows/aloha.yml
             .github/workflows/check_xsec_processes_mg7.yml
             .github/workflows/madspace.yml
+            .github/workflows/pyamplicol.yml
 
   # Builds the wheels for every supported Python/platform. This one suite does
   # have to run at release time: the CI build on main only builds the
@@ -132,10 +134,45 @@ jobs:
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
 
+  # Builds and tests the pyamplicol sdist and wheels (and the prepared-model
+  # archive they contain), validated by pyamplicol's own release tooling.
+  pyamplicol:
+    needs: require_green_ci
+    uses: ./.github/workflows/pyamplicol.yml
+    with:
+      full_matrix: true
+
+  # Defined here for the same reason as publish_pypi; pyamplicol's PyPI trusted
+  # publisher names this workflow and the same "pypi" environment.
+  publish_pypi_pyamplicol:
+    name: Publish pyamplicol to PyPI
+    needs: [pyamplicol, publish_pypi]
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/pyamplicol
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+    steps:
+      - name: Download the validated dists
+        uses: actions/download-artifact@v5
+        with:
+          name: pyamplicol-validated-release
+          path: validated
+      - name: Keep only the package files
+        run: |
+          mkdir dist
+          find validated -name 'pyamplicol-*.whl' -exec cp {} dist/ \;
+          find validated -name 'pyamplicol-*.tar.gz' -exec cp {} dist/ \;
+          ls -l dist
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
   tarball:
     needs:
       - check_version
       - publish_pypi
+      - publish_pypi_pyamplicol
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v5
@@ -152,6 +189,21 @@ jobs:
           path: wheels
           merge-multiple: true
 
+      - name: Download the pyamplicol wheels built for this release
+        uses: actions/download-artifact@v5
+        with:
+          name: pyamplicol-validated-release
+          path: pyamplicol-validated
+
+      - name: Download the pyamplicol prepared-model archive
+        uses: actions/download-artifact@v5
+        with:
+          name: pyamplicol-prepared-models
+          path: dist
+
+      - name: Collect the pyamplicol wheel names
+        run: find pyamplicol-validated -name 'pyamplicol-*.whl' -exec cp {} wheels/ \;
+
       - name: Build the MadGraph tarball
         run: >
           python3 bin/create_release.py --version "${{ needs.check_version.outputs.version }}"
@@ -175,6 +227,14 @@ jobs:
           done
           test -d madspace/install/madspace
 
+          # Also checks that Symbolica accepts pyamplicol's library key.
+          for attempt in $(seq 10); do
+            python3 pyamplicol/install.py --bin -y && break
+            echo "attempt $attempt: pyamplicol==${{ needs.check_version.outputs.version }} not installable yet, retrying..."
+            sleep 15
+          done
+          test -d pyamplicol/install/pyamplicol
+
       - name: Sign the tarball with Sigstore
         uses: sigstore/gh-action-sigstore-python@v3.0.0
         with:
@@ -191,6 +251,8 @@ jobs:
       - require_green_ci
       - madspace
       - publish_pypi
+      - pyamplicol
+      - publish_pypi_pyamplicol
       - tarball
     # 'skipped' has to count as a failure here: a job whose own guard is false,
     # or one whose dependency was skipped, is neither failure() nor cancelled(),
diff --git a/.github/workflows/unittest.yml b/.github/workflows/unittest.yml
index 96923b1fb9..473e91a117 100644
--- a/.github/workflows/unittest.yml
+++ b/.github/workflows/unittest.yml
@@ -202,6 +202,15 @@ jobs:
             cd $GITHUB_WORKSPACE
             ./tests/test_manager.py test_madspace_install -t0
 
+      # ---- unittest_pyamplicol_install ----
+      # tests/unit_tests/various/test_pyamplicol_install.py: install.py (build
+      # stubbed), the version sync with VERSION and the source hash
+      - name: "unittest_pyamplicol_install: run the pyamplicol installer unit tests"
+        if: ${{ !cancelled() }}
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py test_pyamplicol_install -t0
+
       # ---- unittest_hwu ----
       # tests/unit_tests/various/test_mg7_hwu_output.py: the MADatLO.HwU an mg7
       # run writes, read back and overlaid on an aMC@NLO MADatNLO.HwU by
diff --git a/.gitignore b/.gitignore
index 28254be189..91e028ef0c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -84,6 +84,7 @@ docs/build/
 # per-class API pages written by docs/generate_api_pages.py
 docs/source/madspace/cpp/
 docs/source/madspace/python/
+docs/source/pyamplicol/
 tests/input_files/IOTestsComparison_BackUp/
 tests/input_files/IOTestsComparison/**/*.BackUp
 
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 530bd0877a..0c5413c5ce 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -46,3 +46,14 @@ repos:
       - id: clang-format
         types_or: [c++, c, cuda]
         files: ^madspace/
+  # --- pyamplicol: the same lint scope as its CI (pyamplicol.yml) -------------
+  # Run from pyamplicol/, so its own packages are first-party for isort.
+  - repo: local
+    hooks:
+      - id: pyamplicol-ruff
+        name: ruff (pyamplicol)
+        language: python
+        additional_dependencies: ["ruff==0.17.1"]
+        entry: bash -c 'cd pyamplicol && ruff check "${@#pyamplicol/}"' --
+        types: [python]
+        files: ^pyamplicol/(build_backend|tools/release|tools/ci|tests/release)/
diff --git a/README.md b/README.md
index d790154879..f26a6db42d 100644
--- a/README.md
+++ b/README.md
@@ -38,6 +38,10 @@ Python 3.12 or higher and a C++ compiler are required. The `madspace` library is
 installed automatically the first time you launch a run. To build it yourself instead,
 run `install madspace` from the MadGraph7 prompt.
 
+The `pyamplicol` package, the matrix-element generator of the `[amplicol]` backend, is
+installed in the same way with `install pyamplicol`. It lives in `pyamplicol/` and keeps
+its own license (0BSD, see `pyamplicol/LICENSE` and `pyamplicol/THIRD_PARTY_NOTICES.md`).
+
 ## First steps
 
 Type `tutorial` at the MadGraph7 prompt for a guided walkthrough of the commands.
diff --git a/bin/create_release.py b/bin/create_release.py
index b926fdda8b..6ee832c706 100755
--- a/bin/create_release.py
+++ b/bin/create_release.py
@@ -23,8 +23,8 @@
     python bin/create_release.py --version 0.2.0 --output dist/
 
 It performs the following actions:
-  1. Check that VERSION agrees with --version, and that madspace still derives
-     its version from it. (UpdateNotes.txt still tracks the legacy MG5_aMC@NLO
+  1. Check that VERSION agrees with --version, that madspace still derives
+     its version from it, and that pyamplicol's versions are synced to it. (UpdateNotes.txt still tracks the legacy MG5_aMC@NLO
      3.7.x series and is not part of this check.)
   2. git-archive the current HEAD into a clean MG7_v<version> directory
      (preserves the madgraph/VERSION symlink; ignores untracked/gitignored
@@ -128,8 +128,9 @@ def parse_info_file(filepath):
 
 
 def check_versions(version):
-    """Fail loudly if VERSION disagrees with the version being released, or if
-    madspace/pyproject.toml has stopped deriving its version from VERSION."""
+    """Fail loudly if VERSION disagrees with the version being released, if
+    madspace/pyproject.toml has stopped deriving its version from VERSION, or
+    if pyamplicol's literal (Cargo) versions are out of sync with VERSION."""
     errors = []
 
     mg_version = parse_info_file(pjoin(ROOT, 'VERSION')).get('version')
@@ -143,6 +144,13 @@ def check_versions(version):
             "madspace/pyproject.toml pins its own version instead of reading it "
             "from VERSION; madspace must be released in lockstep with MadGraph")
 
+    sync = subprocess.run(
+        [sys.executable, pjoin(ROOT, 'pyamplicol', 'tools', 'release', 'sync_version.py'),
+         '--check', '--version', version],
+        capture_output=True, text=True)
+    if sync.returncode:
+        errors.append(sync.stderr.strip() + "; run pyamplicol/tools/release/sync_version.py")
+
     if errors:
         for e in errors:
             print(f"ERROR: {e}", file=sys.stderr)
diff --git a/docs/requirements.txt b/docs/requirements.txt
index c4c8deb079..aff1220c44 100644
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -2,3 +2,4 @@ sphinx==9.0.4
 sphinx-autodoc-typehints==3.6.0
 breathe==4.36.0
 furo==2025.12.19
+myst-parser==5.0.0
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 541cbea840..164a6dbc0b 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -19,6 +19,30 @@
 # For the full list of built-in configuration values, see the documentation:
 # https://www.sphinx-doc.org/en/master/usage/configuration.html
 
+# pyamplicol/docs is copied (not symlinked: MyST resolves links from the real
+# path) into the gitignored source/pyamplicol.
+def _copy_pyamplicol_docs():
+    import shutil
+
+    here = os.path.dirname(os.path.abspath(__file__))
+    source = os.path.join(here, "..", "..", "pyamplicol", "docs")
+    target = os.path.join(here, "pyamplicol")
+    shutil.rmtree(target, ignore_errors=True)
+    jekyll_only = shutil.ignore_patterns(
+        "_config.yml", "_includes", "css", "results", "archive", "arxiv", ".*"
+    )
+
+    def ignore(directory, names):
+        # Only the report index is tracked; campaigns are local output.
+        if os.path.basename(directory) == "performance_reports":
+            return {name for name in names if name != "README.md"}
+        return jekyll_only(directory, names)
+
+    shutil.copytree(source, target, ignore=ignore)
+
+
+_copy_pyamplicol_docs()
+
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
@@ -60,8 +84,16 @@ def _read_version() -> str:
     # "sphinx.ext.linkcode",
     "sphinx_autodoc_typehints",
     "breathe",
+    "myst_parser",
 ]
 
+# The pyAmpliCol pages are Markdown.
+source_suffix = {".rst": "restructuredtext", ".md": "markdown"}
+myst_enable_extensions = ["dollarmath", "colon_fence"]
+myst_heading_anchors = 3
+# pyAmpliCol pages put an HTML banner above their first (H2) heading.
+suppress_warnings = ["myst.header"]
+
 # The docstrings generated from the Doxygen comments use Google-style "Args:"
 # blocks (see madspace/generate_docstrings.py); napoleon turns them into proper
 # parameter field lists. Keep the numpy parser off to avoid ambiguity.
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 3c597d70cb..f761b2752e 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -40,3 +40,17 @@ If you need a stable release, use the
    madspace/umami-api
    madspace/python-api
    madspace/cpp-api
+
+.. toctree::
+   :maxdepth: 1
+   :caption: pyAmpliCol
+   :hidden:
+
+   pyamplicol/README
+   pyamplicol/user/installation
+   pyamplicol/user/gentle-walkthrough
+   pyamplicol/user/configuration
+   pyamplicol/user/python-api
+   pyamplicol/user/profiling-and-benchmarking
+   pyamplicol/user/architecture-overview
+   pyamplicol/development/README
diff --git a/docs/source/installation.rst b/docs/source/installation.rst
index 462acbdf6a..2e9f7c0c77 100644
--- a/docs/source/installation.rst
+++ b/docs/source/installation.rst
@@ -13,3 +13,7 @@ Python 3.12 or higher and a C++ compiler are required. The ``madspace`` library
 installed automatically the first time you launch a run. To build it yourself instead,
 run ``install madspace`` from the MadGraph7 prompt, or see the
 :doc:`MadSpace installation instructions <madspace/installation>`.
+
+The ``pyamplicol`` package, used by the ``[amplicol]`` matrix-element backend, is
+installed in the same way with ``install pyamplicol``; see the
+:doc:`pyAmpliCol installation instructions <pyamplicol/user/installation>`.
diff --git a/madgraph/interface/madgraph_interface.py b/madgraph/interface/madgraph_interface.py
index 836112fc28..4e5f7547f9 100755
--- a/madgraph/interface/madgraph_interface.py
+++ b/madgraph/interface/madgraph_interface.py
@@ -606,6 +606,9 @@ def help_install(self):
         logger.info("     --source       Build from source (non-interactive).")
         logger.info("     -j N/--jobs=N  Parallel compilation jobs (source build;")
         logger.info("                    defaults to the 'nb_core' option).")
+        logger.info("     --system       Install into the active Python environment instead of madspace/install.")
+        logger.info("     --clean        Delete the build and install directories first (full rebuild).")
+        logger.info("     --docs         Generate API docstrings and .pyi stubs (source build, needs doxygen).")
         logger.info("     --cuda         Enable CUDA GPU backend (source build).")
         logger.info("     --hip          Enable HIP/ROCm GPU backend (source build).")
         logger.info("     --openblas     Build OpenBLAS from source (default on Linux/Windows, source build).")
@@ -616,6 +619,20 @@ def help_install(self):
         logger.info("     --no-debug     Optimized build, no debug symbols, Release (source build, default).")
         logger.info("     --cuda-arch=ARCHS  Semicolon-separated CUDA compute capabilities, e.g. 75;80;86.")
         logger.info("     --hip-arch=ARCHS   Semicolon-separated HIP architectures, e.g. gfx900;gfx906.")
+        logger.info(" ")
+        logger.info("   \"install pyamplicol [options]\"",'$MG:BOLD')
+        logger.info("   Install pyAmpliCol, the matrix-element generator of the [amplicol] backend.")
+        logger.info("   Without options an interactive installer is launched. Available options:")
+        logger.info("     -y/--yes       Re-install non-interactively using saved settings.")
+        logger.info("     --bin          Install pre-compiled package from PyPI (non-interactive;")
+        logger.info("                    only guaranteed to match this checkout in a release tarball).")
+        logger.info("     --source       Build from source (non-interactive; needs a Rust toolchain,")
+        logger.info("                    which is installed locally if rustup is not available).")
+        logger.info("     -j N/--jobs=N  Parallel compilation jobs (source build;")
+        logger.info("                    defaults to the 'nb_core' option).")
+        logger.info("     --system       Install into the active Python environment instead of pyamplicol/install.")
+        logger.info("     --clean        Delete the build and install directories first (full rebuild).")
+        logger.info("     --build-models Regenerate the prepared models instead of downloading them.")
 
     def help_display(self):
         logger.info("syntax: display " + "|".join(self._display_opts),'$MG:color:BLUE')
@@ -3665,7 +3682,8 @@ def complete_install(self, text, line, begidx, endidx):
         elif len(args) and args[0] == 'update':
             return self.list_completion(text, ['-f','--timeout='])
         elif len(args) >= 2 and args[1] == 'madspace':
-            options = ['-y', '--yes', '--bin', '--source',
+            options = ['-y', '--yes', '--bin', '--source', '-j', '--jobs=',
+                       '--system', '--clean', '--docs', '--no-docs',
                        '--cuda', '--no-cuda', '--hip', '--no-hip',
                        '--openblas', '--no-openblas',
                        '--simd', '--no-simd',
@@ -3675,6 +3693,13 @@ def complete_install(self, text, line, begidx, endidx):
                 if any(a.startswith(opt) for a in args[2:]):
                     options.remove(opt)
             return self.list_completion(text, options)
+        elif len(args) >= 2 and args[1] == 'pyamplicol':
+            options = ['-y', '--yes', '--bin', '--source', '-j', '--jobs=',
+                       '--system', '--clean', '--build-models']
+            for opt in options[:]:
+                if any(a.startswith(opt) for a in args[2:]):
+                    options.remove(opt)
+            return self.list_completion(text, options)
         elif len(args)>=2 and args[1] in self._advanced_install_opts:
             options = ['--keep_source','--logging=']
             if args[1]=='pythia8':
@@ -3729,7 +3754,8 @@ def _tutorial_opts(self):
     _import_formats = ['model_v4', 'model', 'proc_v4', 'command', 'banner']
     _install_opts = ['Delphes', 'ExRootAnalysis',
                      'update', 'Golem95', 'QCDLoop', 'maddm', 'maddump',
-                     'looptools', 'MadSTR', 'RunningCoupling', 'madspace']
+                     'looptools', 'MadSTR', 'RunningCoupling', 'madspace',
+                     'pyamplicol']
     
     # The targets below are installed using the HEPToolsInstaller.py script
     _advanced_install_opts = ['pythia8','zlib','boost','lhapdf6','lhapdf5','collier',
@@ -8393,8 +8419,8 @@ def do_install(self, line, paths=None, additional_options=[]):
         elif args[0] == 'looptools':
             self.install_reduction_library(force=True)
             return
-        elif args[0] == 'madspace':
-            install_script = pjoin(MG5DIR, 'madspace', 'install.py')
+        elif args[0] in ('madspace', 'pyamplicol'):
+            install_script = pjoin(MG5DIR, args[0], 'install.py')
             install_args = args[1:]
             # The source build compiles in parallel only if it is told how many
             # jobs it may use (see set_build_parallelism in install.py), so hand
diff --git a/madgraph/iolibs/template_files/mg7/bootstrap.py b/madgraph/iolibs/template_files/mg7/bootstrap.py
index 90fab5bcd4..416415d5bf 100644
--- a/madgraph/iolibs/template_files/mg7/bootstrap.py
+++ b/madgraph/iolibs/template_files/mg7/bootstrap.py
@@ -1,4 +1,4 @@
-"""One-off madspace bootstrap for the mg7 output.
+"""One-off madspace (and pyamplicol) bootstrap for the mg7 output.
 
 The mg7 launcher needs the compiled ``madspace`` package. A git checkout ships
 only the sources, so the first run has to build and install it. That bootstrap
@@ -19,6 +19,8 @@
 safe to do lazily.
 """
 
+import importlib
+import json
 import os
 import subprocess
 import sys
@@ -32,6 +34,8 @@
 MG_ROOT = Path(_mg_pkg.__file__).parents[1]
 MADSPACE_DIR = MG_ROOT / "madspace"
 INSTALL_DIR = MADSPACE_DIR / "install"
+PYAMPLICOL_DIR = MG_ROOT / "pyamplicol"
+PYAMPLICOL_INSTALL_DIR = PYAMPLICOL_DIR / "install"
 
 
 def madspace_is_installed() -> bool:
@@ -39,6 +43,43 @@ def madspace_is_installed() -> bool:
     return (INSTALL_DIR / "madspace").is_dir()
 
 
+def pyamplicol_is_installed() -> bool:
+    """True when a compiled pyamplicol is already available to import."""
+    return (PYAMPLICOL_INSTALL_DIR / "pyamplicol").is_dir()
+
+
+def _run_installer(name, source_dir, interactive, jobs) -> None:
+    """Run ``<source_dir>/install.py`` as the first-use bootstrap does."""
+    if interactive is None:
+        interactive = sys.stdin.isatty()
+    print()
+    print(f"You don't have {name} installed for this madgraph instance")
+    print(f"Running the {name} installation script")
+    print()
+
+    install_cmd = [sys.executable, str(source_dir / "install.py")]
+    # When the run is non-interactive (scripted / piped), install
+    # non-interactively with a source build and default options
+    # (--source --yes), and keep the installer away from our stdin (which
+    # may carry the run's scripted card-editing commands); when
+    # interactive, let it share the terminal so the user can answer.
+    install_stdin = None if interactive else subprocess.DEVNULL
+    if not interactive:
+        install_cmd += ["--source", "--yes"]
+    if jobs:
+        install_cmd += ["-j", str(jobs)]
+    # Expose madgraph on PYTHONPATH so the installer subprocess can import
+    # cmd.ask for its prompts.
+    install_env = os.environ.copy()
+    install_env["PYTHONPATH"] = os.pathsep.join(
+        [str(MG_ROOT)]
+        + ([install_env["PYTHONPATH"]] if install_env.get("PYTHONPATH") else [])
+    )
+    result = subprocess.run(install_cmd, env=install_env, stdin=install_stdin)
+    if result.returncode != 0:
+        raise RuntimeError(f"{name} installation failed — see output above")
+
+
 def ensure_madspace(interactive=None, jobs=None) -> None:
     """Install madspace if needed, then put it on ``sys.path``.
 
@@ -51,39 +92,96 @@ def ensure_madspace(interactive=None, jobs=None) -> None:
     (MG5's ``nb_core``); ``None`` lets the installer use every core.
     """
     if not madspace_is_installed():
-        if interactive is None:
-            interactive = sys.stdin.isatty()
-        print()
-        print("You don't have madspace installed for this madgraph instance")
-        print("Running the madspace installation script")
-        print()
-
-        install_cmd = [sys.executable, str(MADSPACE_DIR / "install.py")]
-        # When the run is non-interactive (scripted / piped), install
-        # non-interactively with a source build and default options
-        # (--source --yes), and keep the installer away from our stdin (which
-        # may carry the run's scripted card-editing commands); when
-        # interactive, let it share the terminal so the user can answer.
-        install_stdin = None if interactive else subprocess.DEVNULL
-        if not interactive:
-            install_cmd += ["--source", "--yes"]
-        if jobs:
-            install_cmd += ["-j", str(jobs)]
-        # Expose madgraph on PYTHONPATH so the installer subprocess can import
-        # cmd.ask for its prompts.
-        install_env = os.environ.copy()
-        install_env["PYTHONPATH"] = os.pathsep.join(
-            [str(MG_ROOT)]
-            + ([install_env["PYTHONPATH"]] if install_env.get("PYTHONPATH") else [])
-        )
-        result = subprocess.run(install_cmd, env=install_env, stdin=install_stdin)
-        if result.returncode != 0:
-            raise RuntimeError("madspace installation failed — see output above")
+        _run_installer("madspace", MADSPACE_DIR, interactive, jobs)
 
     if str(INSTALL_DIR) not in sys.path:
         sys.path.insert(0, str(INSTALL_DIR))
 
 
+def ensure_pyamplicol(interactive=None, jobs=None) -> None:
+    """Install pyamplicol if needed, then put it first on ``sys.path``.
+
+    Same arguments as :func:`ensure_madspace`. The install directory must come
+    before the MadGraph root: there ``pyamplicol/`` is the source directory,
+    which would otherwise be imported as an empty namespace package.
+    """
+    if not pyamplicol_is_installed():
+        _run_installer("pyamplicol", PYAMPLICOL_DIR, interactive, jobs)
+
+    while str(PYAMPLICOL_INSTALL_DIR) in sys.path:
+        sys.path.remove(str(PYAMPLICOL_INSTALL_DIR))
+    sys.path.insert(0, str(PYAMPLICOL_INSTALL_DIR))
+
+
+def check_pyamplicol_source_hash() -> bool:
+    """Warn if the installed pyamplicol was built from other sources.
+
+    Returns whether the hashes match. Must run after :func:`ensure_pyamplicol`.
+    """
+    try:
+        installed = importlib.import_module("pyamplicol._source_hash").SOURCE_HASH
+    except ImportError:
+        installed = None
+    source = subprocess.run(
+        [sys.executable, str(PYAMPLICOL_DIR / "source_hash.py")],
+        capture_output=True, text=True, check=True,
+    ).stdout.strip()
+    if installed == source:
+        return True
+    print()
+    print(
+        "\033[1m\033[31mWARNING\033[39m: pyamplicol source and installed package "
+        "are not compatible (source hash mismatch) — consider recompiling "
+        "pyamplicol (e.g. `install pyamplicol -y`)\033[0m"
+    )
+    print()
+    return False
+
+
+def check_pyamplicol_license(pythonpath=None) -> None:
+    """Fail unless Symbolica accepts pyamplicol's package-scoped library key.
+
+    The key is registered on ``import pyamplicol`` and only licenses calls made
+    from the ``pyamplicol`` package, so the check runs in a fresh process with
+    the same ``PYTHONPATH`` as the generation worker and without a personal
+    ``SYMBOLICA_LICENSE``. It also checks that the import resolves to the
+    installed package, not to the source directory.
+    """
+    env = os.environ.copy()
+    env.pop("SYMBOLICA_LICENSE", None)
+    env["PYTHONPATH"] = os.pathsep.join(pythonpath if pythonpath is not None else sys.path)
+    code = (
+        "import json, pyamplicol\n"
+        "from pyamplicol.licensing import detect_symbolica_license\n"
+        "print(json.dumps({'file': pyamplicol.__file__,\n"
+        "    'licensed': detect_symbolica_license(suggest=False).licensed}))\n"
+    )
+    result = subprocess.run(
+        [sys.executable, "-c", code], cwd=MG_ROOT, env=env,
+        capture_output=True, text=True,
+    )
+    try:
+        info = json.loads(result.stdout.strip().splitlines()[-1])
+    except (IndexError, ValueError):
+        # E.g. Symbolica refuses to start while this process already holds
+        # its per-user lock (symbolica imported here before the check).
+        raise RuntimeError(
+            "pyamplicol cannot be imported:\n" + result.stdout + result.stderr
+        ) from None
+    location = Path(info["file"]).resolve()
+    if (location.is_relative_to(PYAMPLICOL_DIR.resolve())
+            and not location.is_relative_to(PYAMPLICOL_INSTALL_DIR.resolve())):
+        raise RuntimeError(
+            f"pyamplicol resolves to its source directory ({PYAMPLICOL_DIR}), "
+            "not to an installed package"
+        )
+    if not info["licensed"]:
+        raise RuntimeError(
+            "Symbolica does not accept pyamplicol's library license key; "
+            "generation would run in Symbolica's restricted mode"
+        )
+
+
 def drop_install_path() -> None:
     """Take the madspace install directory back off ``sys.path``.
 
diff --git a/madspace/install.py b/madspace/install.py
index f21688e2b5..887104556a 100644
--- a/madspace/install.py
+++ b/madspace/install.py
@@ -577,7 +577,9 @@ def _release_wheel_available() -> bool:
 
     python_tag = f"cp{sys.version_info.major}{sys.version_info.minor}"
     return any(
-        python_tag in name and all(tag in name for tag in platform_tags)
+        name.startswith(f"{PACKAGE_NAME}-")
+        and python_tag in name
+        and all(tag in name for tag in platform_tags)
         for name in wheels.split(",")
     )
 
diff --git a/pyamplicol/.gitattributes b/pyamplicol/.gitattributes
new file mode 100644
index 0000000000..871c3b6b41
--- /dev/null
+++ b/pyamplicol/.gitattributes
@@ -0,0 +1,14 @@
+* text=auto
+*.json text eol=lf
+*.md text eol=lf
+*.py text eol=lf
+*.rs text eol=lf
+*.toml text eol=lf
+*.f90 text eol=lf
+*.h text eol=lf
+*.hpp text eol=lf
+*.pdf binary
+*.a binary
+*.bin binary
+dependencies/patches/** whitespace=-trailing-space,-space-before-tab
+licenses/rust/** -text whitespace=-trailing-space
diff --git a/pyamplicol/.gitignore b/pyamplicol/.gitignore
new file mode 100644
index 0000000000..ef7a14f629
--- /dev/null
+++ b/pyamplicol/.gitignore
@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: 0BSD
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Build products
+build/
+dist/
+target/
+wheelhouse/
+/FFT_FEATURE_RESOURCES/
+*.whl
+*.mod
+src/pyamplicol/_rusticol*.so
+src/pyamplicol/_rusticol*.dylib
+src/pyamplicol/_rusticol*.pyd
+.artifacts/
+# Temporary upstream dependency fixes stay local to this development branch.
+/TMP_FIXED_SYMJIT/
+/TMP_FIXED_SPENSO/
+/FUTURE_ufo_model_loader/
+/SPENSO_LATEST_SYMBOLICA_COMPATIBILITY_FIXES/
+/SYMJIT_FOLLOW_UP_FIXES/
+/DEPENDENCY_FIXES/
+/IMPLEMENTATION_DOCS/REFERENCES/
+/IMPLEMENTATION_DOCS/RESULTS/fft-scaling-study/raw/
+/IMPLEMENTATION_DOCS/RESULTS/fft-profiling/runs/
+/IMPLEMENTATION_DOCS/RESULTS/summary_plots_final.pdf
+/IMPLEMENTATION_DOCS/RESULTS/summary_plots_final_helicity_sum.pdf
+.cargo/config.toml
+
+# Retain local performance campaigns and generated reports outside Git. The
+# repository publishes only the report index and four selected PDF snapshots.
+/docs/performance_reports/*
+!/docs/performance_reports/README.md
+!/docs/performance_reports/macbook_M3_pyAmpliCol.pdf
+!/docs/performance_reports/EPYC_pyAmpliCol.pdf
+!/docs/performance_reports/summary_plots_final.pdf
+!/docs/performance_reports/summary_plots_final_helicity_sum.pdf
+/docs/arxiv/
+
+# Managed environments and deployment sandboxes
+.venv/
+venv/
+dependencies/.venv/
+dependencies/checkouts/
+dependencies/candidate-Cargo.lock
+dependencies/candidate-cargo-config.toml
+dependencies/install-state.json
+dependencies/wheelhouse/
+PYPI_DEPLOYMENT_TEST/
+
+# Generated SDK staging
+src/pyamplicol/_sdk/lib/
+src/pyamplicol/_sdk/include/
+src/pyamplicol/_sdk/fortran/
+src/pyamplicol/_sdk/link.json
+src/pyamplicol/_sdk/metadata.json
+src/pyamplicol/_sdk/sboms/
+src/pyamplicol/assets/selftest/*/
+!src/pyamplicol/assets/selftest/portable-64le/
+!src/pyamplicol/assets/selftest/portable-64le/**
+
+# Generated process and benchmark output
+outputs/
+.sass-cache/
+docs/_site/
+docs/.jekyll-cache/
+docs/.sass-cache/
+docs/.bundle/
+docs/.result_outputs/
+docs/**/results/*.lock
+docs/**/results/.coordination/
+docs/performance_reports/.*.init-*/
+docs/*.aux
+docs/*.bbl
+docs/*.bcf
+docs/*.blg
+docs/*.fdb_latexmk
+docs/*.fls
+docs/*.log
+docs/*.out
+docs/*.run.xml
+docs/*.synctex.gz
+docs/*.toc
+docs/**/*.aux
+docs/**/*.bbl
+docs/**/*.bcf
+docs/**/*.blg
+docs/**/*.fdb_latexmk
+docs/**/*.fls
+docs/**/*.log
+docs/**/*.out
+docs/**/*.run.xml
+docs/**/*.synctex.gz
+docs/**/*.toc
+
+# Local tooling state
+/tmp/
+.trash/
+.agent-work/
+.DS_Store
+
+# Prepared-model packs and metadata come from the release archive
+# (tools/release/prepared_models_archive.py), not from Git.
+src/pyamplicol/assets/prepared_models/*.metadata.json
+src/pyamplicol/assets/prepared_models/*.pyamplicol-model
+release_assets/prepared_models/*.metadata.json
+release_assets/prepared_models/*.pyamplicol-model
+
+# MadGraph7 installer
+/install/
+/install_settings.json
+src/pyamplicol/_source_hash.py
diff --git a/pyamplicol/AGENTS.md b/pyamplicol/AGENTS.md
new file mode 100644
index 0000000000..d487ef9522
--- /dev/null
+++ b/pyamplicol/AGENTS.md
@@ -0,0 +1,14 @@
+# Agent policy: keep development and release checks lean
+
+Release and dependency validation must be deliberately minimal. Complexity, cache invalidation, and wall time are costs, not signs of rigor.
+
+- Start with the smallest check that prevents a demonstrated failure. Do not add attestations, secondary manifests, duplicated hashes, pristine-tree proofs, repeated dependency scans, or extra provenance layers merely because they are possible.
+- Trust standard package-manager guarantees where they already cover the invariant: pinned Git revisions, lockfiles, archive checksums, and Cargo/pip resolution must not be reimplemented by repository-specific ceremony.
+- Keep identities narrowly scoped to inputs that can change the artifact they identify. Python, documentation, tests, reports, and staging metadata must not invalidate a native build; validation settings and provenance-only files must not change runtime artifact identity.
+- Check each invariant once, at the cheapest authoritative boundary, and reuse that result. Do not repeat fresh installs, builds, source scans, artifact audits, or platform matrices unless the changed code can affect them.
+- Prefer focused local tests plus one authoritative CI run. Do not run duplicate full suites or performance campaigns during ordinary finalization unless the user explicitly asks or a relevant performance-sensitive path changed.
+- Backward-compatibility machinery is opt-in, not automatic. This repository does not preserve old internal artifact formats unless the user explicitly requests it.
+- Before adding a release/authentication check, state the concrete failure it prevents, why an existing check is insufficient, and its expected runtime/cache cost. If that case cannot be made, do not add it.
+- When existing ceremony is encountered, simplify or remove it when safe. Never broaden validation as an incidental part of an unrelated change.
+
+Correctness, dependency integrity, and publishability remain required; the rule is to establish each with the least duplicated work and the smallest maintainable mechanism.
diff --git a/pyamplicol/Cargo.lock b/pyamplicol/Cargo.lock
new file mode 100644
index 0000000000..462274d773
--- /dev/null
+++ b/pyamplicol/Cargo.lock
@@ -0,0 +1,1531 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "getrandom 0.3.4",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e76a019e91224d279006ff972f1e984179a6e9feb050adba6ce8274aef23195"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "anyhow"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
+
+[[package]]
+name = "append-only-vec"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2114736faba96bcd79595c700d03183f61357b9fbce14852515e59f3bee4ed4a"
+
+[[package]]
+name = "approx"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "az"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be5eb007b7cacc6c660343e96f650fedf4b5a77512399eb952ca6642cf8d13f7"
+
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode-trait-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1f425dc6064b77d777fdecf6d1b374ae29e0be056b5ba8308a798d381e82632"
+dependencies = [
+ "bincode",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "brotli"
+version = "8.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cc91aac060a7a1e25823bdccbfb6af1875b88f17c6daac97894eed8207166b3"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a32acac15fe1967bc3986b2a6347dffc965602354ea6f450ad07e8bfd253583"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "bytemuck"
+version = "1.25.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "colored"
+version = "3.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01a7799fd6b852db0e61728dde9a204c423b44d689dbd432522543614b490e78"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "directories"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
+[[package]]
+name = "ed25519-compact"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f05391a505666bdf2b5d2626f41b7f0f49052b1e33cceac960eaa818008141da"
+
+[[package]]
+name = "either"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "flate2"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+ "zlib-rs",
+]
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
+name = "gmp-mpfr-sys"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7db155b537cb791b133341f99f68371d86ee7fa4c79aacfbc376d72d23c70531"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "graphica"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afa7211a7cfdba21893f634868e19459e5d1882e5957f98d7c084875a6e70ab6"
+dependencies = [
+ "ahash",
+ "dyn-clone",
+ "numerica",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hugepage-rs"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da5c9051569a6ff2f501fb927a7d994af9232e4bff255352811d7b87afc50603"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.1",
+]
+
+[[package]]
+name = "inventory"
+version = "0.3.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "libloading"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "754ca22de805bb5744484a5b151a9e1a8e837d5dc232c2d7d8c2e3492edc8b60"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "libredox"
+version = "0.1.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6480ccc157a1389bb2e4891b24751b0f798ba640d22386f23143fbcc89da195a"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "log"
+version = "0.4.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
+
+[[package]]
+name = "mach2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "matchers"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
+dependencies = [
+ "regex-automata",
+]
+
+[[package]]
+name = "matrixmultiply"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "ndarray"
+version = "0.17.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520080814a7a6b4a6e9070823bb24b4531daac8c4627e08ba5de8c5ef2f2752d"
+dependencies = [
+ "matrixmultiply",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "portable-atomic",
+ "portable-atomic-util",
+ "rawpointer",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "numerica"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd28aae6e022a7b5846a8ae40b2d41104f8d8cba38adbb02c0f7933f3ed7bb02"
+dependencies = [
+ "ahash",
+ "bincode",
+ "bincode-trait-derive",
+ "colored",
+ "dyn-clone",
+ "gmp-mpfr-sys",
+ "itertools",
+ "num-traits",
+ "rand",
+ "rand_core",
+ "rayon",
+ "rug",
+ "simba",
+ "smallvec",
+ "wide 1.7.1",
+ "xprec",
+]
+
+[[package]]
+name = "numpy"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a5b15d63a5ff39e378daed0e1340d3a5964703ea9712eb09a0dc66fade996f4"
+dependencies = [
+ "libc",
+ "ndarray",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "pyo3",
+ "pyo3-build-config",
+ "rustc-hash",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.29.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4688ddedf473e32662b9b067670129a8afb8c18e351482c70d62ba4a88171e8b"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.29.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f41027e41b4bd03f6e60f9f417fe24a6341a6bb744edd62b6f709f2a52ea30e9"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.29.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e591a95526fead067432c3b3a33fc74770b87b1e04e73671090d9c2055a2b327"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.29.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73225868fc1cd84eef2c3c230ddb91273bf1de46aeb8a4248da76d32a0924a1c"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.29.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "571575aa3749fa6216757dd47d2a3e7ef360f329a40f0666a9fbd14889024952"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "region"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6b6ebd13bc009aef9cd476c1310d49ac354d36e240cf1bd753290f3dc7199a7"
+dependencies = [
+ "bitflags",
+ "libc",
+ "mach2",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rug"
+version = "1.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07a8857882aec59d27254b02481c709327c13de6fad1da60bfc4f9783eaaa61e"
+dependencies = [
+ "az",
+ "gmp-mpfr-sys",
+ "libc",
+ "libm",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
+
+[[package]]
+name = "rusticol-capi"
+version = "0.2.1"
+dependencies = [
+ "rusticol-core",
+ "serde_json",
+]
+
+[[package]]
+name = "rusticol-core"
+version = "0.2.1"
+dependencies = [
+ "bincode",
+ "libc",
+ "libloading",
+ "num-complex",
+ "rayon",
+ "serde",
+ "serde_json",
+ "sha2",
+ "symbolica",
+ "symjit",
+ "thiserror",
+ "wide 1.7.1",
+]
+
+[[package]]
+name = "rusticol-python"
+version = "0.2.1"
+dependencies = [
+ "flate2",
+ "num-bigint",
+ "num-rational",
+ "num-traits",
+ "numpy",
+ "pyo3",
+ "pyo3-build-config",
+ "rusticol-core",
+ "serde_json",
+ "sha2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "safe_arch"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b02de82ddbe1b636e6170c21be622223aea188ef2e139be0a5b219ec215323"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "safe_arch"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42c6efa15875e6ecb39ca61fb0b0c1a40b84fac5a5ffe71eef7d1000c8eb3f5f"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "self_cell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ab42ca02749e120097e328d91d415325bdf43b1c72c4c8badf37375fe40a813"
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.5",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "simba"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c99284beb21666094ba2b75bbceda012e610f5479dfcc2d6e2426f53197ffd95"
+dependencies = [
+ "approx",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "wide 0.7.33",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
+
+[[package]]
+name = "smallvec"
+version = "1.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891"
+
+[[package]]
+name = "smartstring"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fb72c633efbaa2dd666986505016c32c3044395ceaf881518399d2f4127ee29"
+dependencies = [
+ "autocfg",
+ "static_assertions",
+ "version_check",
+]
+
+[[package]]
+name = "spec_math"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02ef091d4e8b981dbaa4cc17789d00b53d5d2c001ae689f14e6093f30c529036"
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "symbolica"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c060dc0a9613c88aadee7095109bf350e549067c9ecf7ea217064cdf3d439721"
+dependencies = [
+ "ahash",
+ "append-only-vec",
+ "bincode",
+ "bincode-trait-derive",
+ "brotli",
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "directories",
+ "dyn-clone",
+ "ed25519-compact",
+ "graphica",
+ "inventory",
+ "libloading",
+ "numerica",
+ "once_cell",
+ "rand",
+ "rayon",
+ "rug",
+ "self_cell",
+ "smallvec",
+ "smartstring",
+ "symjit",
+ "tinyjson",
+ "tracing",
+ "tracing-subscriber",
+ "wide 1.7.1",
+]
+
+[[package]]
+name = "symjit"
+version = "2.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37344a51408baa239bbaa771e40cd908686bffed4f4491ec6bc608e8d248c931"
+dependencies = [
+ "ahash",
+ "anyhow",
+ "hashbrown 0.16.1",
+ "hugepage-rs",
+ "lazy_static",
+ "libc",
+ "num-complex",
+ "num-rational",
+ "num-traits",
+ "rand",
+ "rayon",
+ "region",
+ "serde",
+ "serde_json",
+ "spec_math",
+ "toml",
+ "wasmtime-jit-icache-coherence",
+ "wide 1.7.1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "thiserror"
+version = "2.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.5",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad99c4c6d32803332c548b1af0540b357b3f5fc0be8f6c6bfe8b2e6ae784070"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "tinyjson"
+version = "2.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ab95735ea2c8fd51154d01e39cf13912a78071c2d89abc49a7ef102a7dd725a"
+
+[[package]]
+name = "toml"
+version = "1.1.6+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "920602543f0911ab71da12c50d59701da54c196d1a2bf5cb4b75667f137a406a"
+dependencies = [
+ "indexmap",
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.1.3+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d56353a2a665ad0f41a421187180aab746c8c325620617ad883a99a1cbe66d2"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex-automata",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+]
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "virtue"
+version = "0.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.4+wasi-0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasmtime-jit-icache-coherence"
+version = "34.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea6b740d1a35f2cebfe88e013ac8a4a84ff8dabc3a392df920abf554e871cf2"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "wide"
+version = "0.7.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce5da8ecb62bcd8ec8b7ea19f69a51275e91299be594ea5cc6ef7819e16cd03"
+dependencies = [
+ "bytemuck",
+ "safe_arch 0.7.4",
+]
+
+[[package]]
+name = "wide"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d920ac99c3c8edce110cb8d07dbb324d6d026011dce85b1e9355b70f0adacc4f"
+dependencies = [
+ "bytemuck",
+ "safe_arch 1.2.0",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winnow"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "xprec"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39a30f7277acb4ef10faeec631c7fbb0ff92355bea37e1b01a63f3803c78e319"
+dependencies = [
+ "approx",
+ "libm",
+ "num-traits",
+ "simba",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d35102a9f36d089ccae9e4c6802bc118be4487b80aaffc0ab4e0cf5ce92d2873"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c01f5ab44258da43cf276c74a2763db2ff3969c9c652c3f2de07041d0b2bc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "zlib-rs"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12"
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
diff --git a/pyamplicol/Cargo.toml b/pyamplicol/Cargo.toml
new file mode 100644
index 0000000000..dfda5eb881
--- /dev/null
+++ b/pyamplicol/Cargo.toml
@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: 0BSD
+
+[workspace]
+members = [
+  "rust/crates/rusticol-core",
+  "rust/crates/rusticol-python",
+  "rust/crates/rusticol-capi",
+]
+exclude = [
+  "TMP_FIXED_SYMJIT",
+  "TMP_FIXED_SPENSO",
+]
+resolver = "2"
+
+[workspace.package]
+version = "0.2.1"
+edition = "2024"
+rust-version = "1.89.0"
+license = "0BSD"
+authors = [
+  "Rikkert Frederix <rikkert.frederix@thep.lu.se>",
+  "Valentin Hirschi <valentin.hirschi@gmail.com>",
+  "Timea Vitos <timea.vitos@thep.lu.se>",
+]
+repository = "https://github.com/mg5amcnlo/pyamplicol"
+
+[workspace.dependencies]
+bincode = { version = "2.0", features = ["serde"] }
+flate2 = "1.1"
+libc = "0.2"
+numpy = "0.29"
+num-bigint = "0.4"
+num-rational = "0.4"
+num-traits = "0.2"
+pyo3 = { version = "0.29", features = ["abi3-py311"] }
+rayon = "1.10"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0", features = ["float_roundtrip", "raw_value"] }
+sha2 = "0.10"
+symbolica = { version = "=3.0.0", default-features = true, features = ["bincode"] }
+thiserror = "2.0"
+wide = "1.7"
+
+[profile.release]
+codegen-units = 1
+lto = "thin"
+opt-level = 3
+panic = "unwind"
+strip = "debuginfo"
diff --git a/pyamplicol/LICENSE b/pyamplicol/LICENSE
new file mode 100644
index 0000000000..2e88cb37b9
--- /dev/null
+++ b/pyamplicol/LICENSE
@@ -0,0 +1,14 @@
+BSD Zero Clause License
+
+Copyright (c) 2026 Rikkert Frederix, Valentin Hirschi, and Timea Vitos
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
diff --git a/pyamplicol/README.md b/pyamplicol/README.md
new file mode 100644
index 0000000000..fe501ea5ea
--- /dev/null
+++ b/pyamplicol/README.md
@@ -0,0 +1,389 @@
+<!-- SPDX-License-Identifier: 0BSD -->
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/MadGraphTeam/pyamplicol/main/docs/assets/pyamplicol_logo.png" alt="pyAmpliCol" width="760">
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/pyamplicol/"><img src="https://img.shields.io/pypi/v/pyamplicol.svg" alt="PyPI"></a>
+  <a href="https://pypi.org/project/pyamplicol/"><img src="https://img.shields.io/pypi/pyversions/pyamplicol.svg" alt="Python versions"></a>
+  <a href="https://madgraph.org/pyamplicol/"><img src="https://img.shields.io/badge/docs-User%20Guide-2f81f7.svg?logo=githubpages" alt="pyAmpliCol documentation"></a>
+  <a href="https://github.com/MadGraphTeam/pyamplicol/actions/workflows/tests.yml"><img src="https://github.com/MadGraphTeam/pyamplicol/actions/workflows/tests.yml/badge.svg" alt="Tests"></a>
+  <a href="https://github.com/MadGraphTeam/pyamplicol/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-0BSD-blue.svg" alt="License: 0BSD"></a>
+</p>
+
+<p align="center"><strong>Fast color-ordered scattering amplitudes from Python and native APIs.</strong></p>
+
+pyAmpliCol generates and evaluates color-ordered scattering amplitudes from
+built-in, JSON, or UFO models. It provides a typed Python API and CLI, fast
+Rust-backed execution, runtime helicity and color-flow selection, and generated
+Python, C11, C++17, Fortran 2008, and Rust 2021 interfaces.
+
+Explore the complete [pyAmpliCol documentation](https://madgraph.org/pyamplicol/)
+for guided workflows, API examples, technical reference, and release support.
+
+Opt-in [tree-level spin and colour correlations](docs/correlators.md) prepare
+named colour operators at generation and accept spin-contraction vectors at
+runtime. This opt-in path supports LC, NLC and full colour at generic
+connection order. `CorrelatorConfig.all_color(through_order=k)` prepares the
+complete, nonminimal tree-soft catalogue through any positive order `k`;
+`Runtime.available_color_correlations()` lists the generated operators.
+Catalogues grow rapidly with order. Multiple requests share amplitudes and
+accept batches of phase-space points. The `correlators` development branch
+also exposes these operations in the C, C++, Fortran and Rust SDKs with
+binary64 arithmetic; Python supports double-double and arbitrary precision.
+
+## Installation
+
+Install the release from PyPI:
+
+```console
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install pyamplicol
+```
+
+The binary wheels include the Rust runtime and native SDK; wheel users do not
+need a Rust compiler. pyAmpliCol has no LHAPDF dependency.
+
+Build the tagged 1.0.1 source snapshot with:
+
+```console
+git clone --branch v1.0.1 --depth 1 https://github.com/MadGraphTeam/pyamplicol.git
+cd pyamplicol
+python -m pip install .
+```
+
+A source build requires Python 3.11 or newer, Rust 1.89 or newer, and a C/C++
+toolchain. A Fortran compiler is required only for Fortran consumers.
+
+Contributor setup defaults to published Python dependencies from
+`pyproject.toml`, including Symbolica 3.0.0 and ufo-model-loader 1.0.0, and the
+release-mode native build with published SymJIT 2.26.4.
+Building a new release wheel requires a clean Git checkpoint and complete
+release assets; the dependency mode does not relax publication guards.
+
+```console
+nix develop  # optional on Nix/NixOS
+just dev-install
+PYTHON=.venv/bin/python just dev-test
+```
+
+The `just dev-install` native build can take several minutes. Use
+`--wheel-directory PATH` to avoid rebuilding an existing compatible wheel.
+For a dirty development checkout, use `--wheel-directory PATH` to reuse an
+already-built compatible release wheel, or `--dependencies-only` to install
+dependencies without building or staging the project; the latter leaves the
+existing native runtime untouched. An optional `--loader-wheel PATH` explicitly
+selects a local wheel for dependency development; normal setup uses PyPI.
+Editable installs are not used. `just dev-test` also includes a fresh release
+build and requires a clean checkpoint; dirty edits can use focused tests against
+the staged native runtime.
+Historical dependency-development machinery remains behind `--candidate`,
+but its pinned APIs are incompatible with the current tensor implementation.
+It needs updated, coherent upstream pins before use; use the published lane
+for current-source development and tests.
+
+Full installation details are in the
+[documentation](https://madgraph.org/pyamplicol/).
+
+## Quick start
+
+Copy the installed examples into an editable workspace:
+
+```console
+pyamplicol examples copy ./pyamplicol-examples --force
+cd pyamplicol-examples
+```
+
+Keep the Python environment containing pyAmpliCol activated while using the
+top-level CLI and Python examples, or invoke its executables by explicit path.
+For a copy below a source checkout prepared by `just dev-install`, generated
+artifact Python and native API drivers also find the nearest checkout `.venv`
+automatically; explicit SDK overrides and an active environment take
+precedence.
+
+The primary example generates a multiprocess `p p > Z j j` artifact from the
+packaged serialized Standard Model, then evaluates and profiles one concrete
+subprocess. It expands to eight candidates, one per side-permutation class;
+it stores the seven tree-level representatives and reports the omitted
+loop-induced `g g > Z g g` class. The card inherits the portable JIT
+O2 default, so its process artifact can be moved between supported 64-bit
+little-endian macOS arm64, macOS x86_64, and Linux x86_64 hosts:
+
+```console
+pyamplicol generate_pp_zjj_from_ufo_sm.toml
+pyamplicol evaluate_total.toml
+pyamplicol evaluate_resolved.toml
+pyamplicol benchmark.toml
+```
+
+For direct CLI use:
+
+```console
+pyamplicol generate "d d~ > z g" ./artifacts/builtin_ddbar_to_zg \
+  --model built-in-sm
+
+pyamplicol inspect ./artifacts/builtin_ddbar_to_zg
+```
+
+Process generation can also be steered directly from Python:
+
+```python
+from pyamplicol import GenerationConfig, Generator
+
+generator = Generator(GenerationConfig(workers=4))
+plan = generator.plan("d d~ > z g")  # Resolve without writing an artifact.
+result = generator.generate(
+    "d d~ > z g",
+    "artifacts/builtin_ddbar_to_zg",
+    mode="replace",
+)
+print(result.output)
+```
+
+The same runtime is available from Python:
+
+```python
+import json
+from pathlib import Path
+
+from pyamplicol import Runtime
+
+momenta = json.loads(Path("data/pp_zjj_momenta.json").read_text())
+runtime = Runtime.load("artifacts/pp_zjj", process="d d~ > g z g")
+total = runtime.evaluate(momenta)
+resolved = runtime.evaluate_resolved(momenta)
+assert resolved.total() == total
+```
+
+Concrete process expressions may reorder particles within the incoming side or
+within the outgoing side. Rusticol maps momenta, helicities, color flows, and
+resolved metadata to that requested order; particles never cross the `>`
+boundary. Stable process IDs remain available when more than one generated
+representative could match an expression.
+
+See the
+[examples guide](https://github.com/MadGraphTeam/pyamplicol/blob/main/examples/README.md)
+for complete cards, parameter updates, selector examples, and generated API
+drivers.
+
+## Models and execution
+
+pyAmpliCol supports:
+
+- the packaged built-in Standard Model;
+- packaged serialized JSON and trusted UFO examples;
+- user-supplied JSON or trusted UFO model paths;
+- leading-color, contracted next-to-leading-color, and contracted full-color
+  calculations;
+- recurrence, compiled-DAG, eager, and on-the-fly execution modes;
+- JIT, C++, and assembly evaluator backends where supported;
+- native binary64 execution without Symbolica computations, plus precision-controlled
+  Python evaluation when exact expressions are retained. On-the-fly execution
+  currently supports native binary64 only.
+
+Reusable artifacts preserve complete public helicity and color physics unless
+the request explicitly fixes selectors at generation time. Runtime calls can
+then select one flow or helicity globally or per phase-space point without
+regenerating the artifact. On-the-fly artifacts always keep selection at
+runtime and carry the complete contract in a compact query-local seed rather
+than materializing the full axes; `inspect` reports their physical census
+without constructing it.
+Recurrence, eager, and on-the-fly execution reuse the same prepared model
+kernel bundle.
+
+Contracted NLC/full-colour recurrence and on-the-fly execution automatically
+try exact `symmetric-group-fft` colour contraction with adaptive adjoint-basis
+selection, falling back to direct contraction when the FFT plan is unsupported.
+Select `--color-accuracy full` (or `nlc`) to use this default policy.
+Certified pure-gluon Yang–Mills trees and single-insertion HEFT use two-anchor
+DDM tensors: for `n` external gluons, `(n-2)!` ordered amplitudes replace the
+trace basis's `(n-1)!`. Quark processes retain fundamental chains or their
+products; uncertified adjoint processes retain trace tensors. The saved
+`fft_basis_selection` records the actual representation and its reason, so a
+fallback is not presented as a DDM reduction. Configuration defaults are
+`contraction = "auto"` and `fft_basis = "adjoint"`; LC, compiled/eager execution,
+and correlators retain direct contraction and the trace basis. Use
+`--color-contraction direct` to opt out, or `--fft trace` / `--fft adjoint` to
+force FFT with that basis and reject unsupported plans. In the benchmarked
+pure-gluon family the adjoint basis was faster than trace for six or more
+external gluons, by 3.9x per sample with 4x faster generation at ten gluons. See the
+[FFT configuration guide](docs/user/configuration.md#color-accuracy-and-lc-layout).
+FFT transforms certified permutation-orbit blocks and retains unsupported
+terms as exact direct residuals.
+
+Recurrence artifacts persist one helicity-parametric physical-colour
+schedule, its helicity-support masks, and precomputed per-helicity row groups;
+loading binds those groups once, so warmed evaluation does not rescan the
+masks. On-the-fly execution instead constructs and caches the requested family
+on first use, which is why that warm-up belongs to its plotted setup time.
+Completed OTF work can be retained between programs with `runtime.save(path)`
+and restored with `runtime.load_cache(path)` after loading the original process
+output. Python and every native SDK expose these operations; see the
+[small save/restore example](docs/user/runtime-and-selectors.md#saving-an-otf-warm-cache)
+and [native equivalents](docs/user/native-apis.md#saving-and-restoring-an-otf-cache).
+
+The public C ABI is version 1. Every generated artifact can include standalone
+Python, C11, C++17, Fortran 2008, and dependency-free Rust 2021 drivers backed
+by the wheel-owned static Rusticol SDK.
+
+## Profiling campaigns
+
+An installed wheel can populate a self-contained campaign workspace:
+
+```console
+pyamplicol profiling-campaign copy ./pyamplicol-profiling-campaign --force
+cd ./pyamplicol-profiling-campaign
+./steer_performance_campaign.py run \
+  --workers 1 --table matrix --process-id 1 --multiplicity 1 \
+  --color-approximation lc --generation-mode non-union-flow \
+  --generation-engine recurrence --model built_in
+```
+
+That deliberately small real campaign measures only the final-state-
+multiplicity-one `d d~ > Z` recurrence cell. Broader campaign selections are
+intended for dedicated profiling hosts. The
+[documentation](https://madgraph.org/pyamplicol/) covers selection,
+continuation, optional original-AmpliCol comparisons, artifact retention, and
+PDF generation.
+
+The source checkout also contains a thin orchestrator for the dedicated
+FullColor FFT comparison. It delegates generation and timing to the existing
+pyAmpliCol profiling commands and schedules independent measurement children:
+
+```console
+just dev-install --with-legacy-amplicol --with-reference-fft
+.venv/bin/python tools/fft_profiling/fft_profiling.py \
+  --multiplicities 2 3 4 5 \
+  --lines reference-fft amplicol pyamplicol-recurrence pyamplicol-otf madgraph \
+  --cores 8 --candidate-cores 1 \
+  --memory-limit-gib 30 --time-limit-seconds 3600 \
+  --amplicol-root /path/to/AmpliCol \
+  --reference-fft-root /path/to/AllGluonsMultipletFFT \
+  --madgraph-root /path/to/MG5_aMC \
+  --build-amplicol
+```
+
+`--multiplicities` adds the selected values to the persistent fill history and
+defaults to `2 ... 9`. `--lines` similarly adds any combination of
+`reference-fft`, `amplicol`, `pyamplicol-recurrence`, `pyamplicol-otf`, and
+`madgraph`; the two pyAmpliCol groups each schedule their direct and FFT
+companion curves together so they reuse the same generation lane. Dependencies
+are selected automatically.
+Repeating a command against the same output unions both selections, resumes
+unfinished cells, and skips completed cells;
+`--resume` is an explicit alias for that default. `--cores` is the total
+scheduler budget, while `--candidate-cores` is one candidate child's core
+claim and evaluator setting. The memory and time limits are strict per-child
+cutoffs. `--retry` reruns only failed/skipped cells in the active selection.
+`--overwrite` reruns every selected cell and replaces each old result only when
+that cell's worker is about to launch; queued or blocked cells retain their old
+results. Use `--output PATH` for an independent run directory. `--refresh`
+removes only that exact recognized output directory and restarts it, so a
+custom output also scopes the refresh; a path that does not exist simply starts
+cleanly. Without `--output`, fixed and summed
+workloads use separate `IMPLEMENTATION_DOCS/RESULTS/fft-profiling/runs/`
+directories named `cluster-fullcolor-n2-n9` and
+`cluster-fullcolor-helicity-sum-n2-n9`. Refresh also shares the persistent
+MadGraph cache-writer lock and refuses to delete a run while a standalone
+MadGraph profiler is using that cache.
+
+Add `--compare-helicity-sums` for the independent complete physical-helicity-
+sum workload. The fixed-helicity MadGraph lane selects the shared helicity
+through the generated `MATRIX(P,NHEL,IC)` entry point. The summed lane instead
+calls the generated `SMATRIX(P,ANS)` with `USERHEL=-1`; MadGraph applies its
+native IDEN normalization and may reuse its warmed `GOODHEL` pruning. Fixed-
+helicity and summed overlays carry distinct workload identities and cannot be
+mixed. `just dev-install` omits the developer-only AmpliCol and Reference FFT
+repositories unless they are requested with `--with-legacy-amplicol` and
+`--with-reference-fft`; either opt-in also installs the `fft-profiling` Python
+extra into `.venv`. Their profiler roots default to
+`dependencies/checkouts/legacy-amplicol` and
+`dependencies/checkouts/reference-fft`; `--build-amplicol` may build the
+AmpliCol probe once. Both paths can be overridden explicitly with
+`--amplicol-root` and `--reference-fft-root`. The MadGraph root defaults to
+`PYAMPLICOL_MADGRAPH_ROOT` or a recognized developer checkout and may be set
+explicitly with `--madgraph-root`.
+
+The published fixed-helicity MadGraph series currently has measured points
+through `n=5` for pure gluons and `n=6` for
+`d d~ > d d~ + gluons`. Pure-gluon `n=6` retains its measured resource cutoff;
+`n=7..9` are explicit protocol-scope not-applicable cells for both families.
+The independent helicity-sum MadGraph series has measured points for both
+families at `n=2..5`. Every admitted point passed the same-workload numerical
+gate before entering the PDFs.
+
+The rolling plot frontiers are per process and implementation, rather than a
+claim that every curve reaches the same `n`. Both fixed-helicity and helicity-
+sum OTF curves are requested only through final-state `n=6`; beyond that the
+publication protocol retains recurrence, AmpliCol, and Reference FFT where
+applicable. Within that frontier, cutoffs are annotated rather than hidden or
+interpolated. Pure-gluon OTF FFT reached the 3,600 s first-use runtime cap at
+`n=6` and retains its measured `n=5` point. The helicity-sum comparison extends
+the `d d~ > d d~ + gluons` curves through `n=6` using an authenticated isolated
+30 GiB extension. At that point every requested curve measured successfully.
+For OTF, direct and FFT setup took 1,725.8 s and 1,607.9 s, while warmed runtime
+was 5.321 and 3.759 ms/point respectively (a 1.416x FFT speedup). The measured
+peak RSS values were 1.17 and 1.22 GiB.
+
+The plotted *setup time* is deliberately method-specific. pyAmpliCol includes
+artifact generation, a fresh load, the first requested evaluation, and OTF
+family warm-up where applicable. Reference FFT includes its build,
+initialization, and first pass. AmpliCol includes process/color-object
+generation for the fixed workload, or process/raw-library generation and build
+plus the immutable snapshot for the summed workload. Warmed runtime is measured
+separately after those setup boundaries. Resource limits apply individually to
+each child. The retained isolated high-frontier extensions use a 30 GiB
+process-tree guard.
+
+After the first snapshot is published, rendering never waits for workers and
+uses the latest available data. Concurrent renders and refresh publication are
+serialized so an older render cannot replace a newer one:
+
+```console
+python tools/fft_profiling/fft_profiling.py --render
+python tools/fft_profiling/fft_profiling.py --render --compare-helicity-sums
+python tools/fft_profiling/fft_profiling.py --render --output /path/to/run
+```
+
+For a custom output, the saved manifest determines whether the workload is
+fixed-helicity or helicity-summed, so a render does not need to repeat
+`--compare-helicity-sums`. Default outputs still use that flag to select the
+helicity-sum workspace. Default outputs also refresh the corresponding
+canonical PDF; custom outputs keep their PDF inside the selected run directory.
+During a scan, the progress display reports the active cell, total live RSS,
+and occupied core slots.
+
+An older local MadGraph overlay that predates the node-fingerprint field may
+appear only in a nonterminal anytime render, only when its system, machine, and
+Python version match the current workstation. Such plots carry an explicit
+provenance note; the strict terminal publication merger still requires the
+complete host identity produced by a fresh profiler run.
+
+The public performance index retains four selected rendered snapshots. Raw
+JSON, generated tables, attempts, and campaign workspaces stay untracked:
+
+- [MacBook M3 report](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/macbook_M3_pyAmpliCol.pdf)
+- [AMD EPYC report](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/EPYC_pyAmpliCol.pdf)
+- [FullColor FFT selected-helicity snapshot](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/summary_plots_final.pdf)
+- [FullColor FFT helicity-sum snapshot](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/summary_plots_final_helicity_sum.pdf)
+
+These are manual measurement snapshots rather than release-CI results; raw
+campaign data remains local. The general host report format is reproducible
+from an installed package, while the FullColor FFT snapshots use the source-
+checkout orchestrator above.
+
+## Documentation
+
+Read the complete [pyAmpliCol documentation](https://madgraph.org/pyamplicol/).
+
+## Dependencies and license
+
+Release builds use pinned published dependencies plus SymJIT 2.25.0 from an
+immutable revision of the official
+[symjit-crate repository](https://github.com/siravan/symjit-crate).
+
+pyAmpliCol is distributed under the 0BSD license. Third-party components and
+model assets retain their own terms; see
+[THIRD_PARTY_NOTICES.md](https://github.com/MadGraphTeam/pyamplicol/blob/main/THIRD_PARTY_NOTICES.md).
diff --git a/pyamplicol/THIRD_PARTY_NOTICES.md b/pyamplicol/THIRD_PARTY_NOTICES.md
new file mode 100644
index 0000000000..5957f6a10f
--- /dev/null
+++ b/pyamplicol/THIRD_PARTY_NOTICES.md
@@ -0,0 +1,90 @@
+# Third-Party Notices
+
+pyAmpliCol and Rusticol source written for this project are licensed under the
+BSD Zero Clause License. That license does not replace the terms attached to
+third-party dependencies or bundled model data.
+
+## Symbolica
+
+pyAmpliCol uses Symbolica, including its idenso and spenso functionality.
+Symbolica is proprietary software. Its upstream terms state that copying or
+distribution of any part of the Symbolica code requires express prior
+permission:
+<https://symbolica.io/license/>.
+
+The pyAmpliCol project has express authorization from the Symbolica licensor
+to redistribute the Symbolica components required by pyAmpliCol's binary
+runtime. This project-specific permission does not authorize separate
+redistribution of Symbolica. Users remain responsible for obtaining the
+appropriate Symbolica use license. Attribution, upstream terms, and the scope
+of pyAmpliCol's redistribution permission are recorded in
+`licenses/Symbolica.txt`.
+
+Release artifacts must record the exact Symbolica package, Rust crate,
+serialization ABI, and source revision used to build them.
+
+## Developer-Only Legacy AmpliCol Oracle
+
+Contributors may opt into a pinned checkout of the original Fortran AmpliCol
+repository for independent numerical and performance validation. That checkout
+is not included in pyAmpliCol wheels or source distributions. The contributor
+metadata records that the pinned upstream revision contains no `LICENSE` or
+`COPYING` file. This observation is not a grant or a claim about the upstream
+source's terms. The developer setup uses the dedicated upstream branch
+`amplicol_with_patches`; no legacy-AmpliCol patch payload is
+shipped in pyAmpliCol release artifacts.
+
+## SymJIT
+
+SymJIT is a separate Rust dependency used by Symbolica's JIT functionality.
+The official `siravan/symjit-crate` 2.25.0 source pinned at
+`f1c193d301897149de6609f706297b0c97a4f018` is distributed under the MIT
+License, not the Symbolica proprietary license. Its copyright notice and
+complete MIT License are reproduced in `licenses/SymJIT.txt`.
+The generic unsafe raw P-kernel plane-descriptor callable was merged upstream
+in `siravan/symjit-crate#1`; it does not alter generated kernels.
+
+## Native Runtime Feature Boundary
+
+`Cargo.lock` records optional Symbolica, Rug/GMP, and Malachite dependencies
+used by developer-only arbitrary-precision Rust checks. The distributed
+`pyamplicol._rusticol` extension and `librusticol_capi.a` select the f64-only
+Rusticol closure and link SymJIT directly; they do not link Symbolica, Rug/GMP,
+or Malachite. Higher-precision Python evaluation loads the separately installed
+Symbolica Python package lazily and remains subject to Symbolica's terms.
+
+The native build and installed-wheel tests verify that the f64 C API archive
+does not depend on Python or the arbitrary-precision Symbolica runtime.
+
+## UFO Model Loader
+
+The `ufo-model-loader` dependency is maintained at
+<https://github.com/alphal00p/ufo_model_loader> and retains its own license.
+Release metadata pins the exact compatible published version.
+
+The loader is distributed under the MIT License. Its complete license is
+shipped with the bundled dependency provenance.
+
+## GammaLoop Model Assets
+
+The distribution includes Standard Model, scalar contact, and scalar-gravity
+UFO examples together with serialized JSON forms. Their source provenance,
+authors, generators, and applicable licenses are recorded in
+`src/pyamplicol/assets/models/PROVENANCE.toml`.
+
+Publishing is blocked if that provenance inventory is absent, incomplete, or
+does not match the packaged asset checksums.
+
+The model sources were distributed with GammaLoop. GammaLoop's upstream
+license says that there are no usage restrictions for GammaLoop; because that
+statement has no standard SPDX identifier, these assets use the local
+identifier `LicenseRef-GammaLoop-No-Restrictions`. The upstream text is
+reproduced in `licenses/GammaLoop.txt`, and its asset-specific scope is
+recorded in `licenses/GammaLoop-model-assets.txt`. The SM UFO identifies N.
+Christensen and C. Duhr as authors. The scalar and scalar-gravity models
+identify Valentin Hirschi as author and were generated with FeynRules 1.7.69.
+
+The SM UFO's optional `build_restrict.py` originates from
+MadGraph5_aMC@NLO. Its adapted University of Illinois/NCSA license is
+reproduced in `licenses/MadGraph5_aMCatNLO.txt`. Generated JSON forms retain
+the provenance and terms of their corresponding UFO source.
diff --git a/pyamplicol/build_backend/_pyamplicol_build.py b/pyamplicol/build_backend/_pyamplicol_build.py
new file mode 100644
index 0000000000..7d0970e3b3
--- /dev/null
+++ b/pyamplicol/build_backend/_pyamplicol_build.py
@@ -0,0 +1,2060 @@
+# SPDX-License-Identifier: 0BSD
+"""Read-only-source PEP 517 backend for pyAmpliCol."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib.metadata
+import importlib.util
+import json
+import os
+import re
+import runpy
+import shutil
+import stat
+import subprocess
+import sys
+import tomllib
+from collections.abc import Callable, Iterator, Mapping
+from contextlib import contextmanager
+from pathlib import Path, PurePosixPath
+from tempfile import TemporaryDirectory
+from typing import Any, TypeVar
+
+import maturin  # type: ignore[import-untyped]
+from native_build_identity import load_native_build_contract
+from native_build_identity import (
+    native_build_inputs_digest as _native_build_inputs_digest,
+)
+from package_version import (
+    canonical_package_version,
+    check_contributor_lock_consistency,
+)
+from prepared_models import (
+    discard_release_packaged_prepared_model_store,
+    project_release_packaged_prepared_model_store,
+    stage_packaged_prepared_models,
+)
+from sdk import build_sdk
+
+ROOT = Path(__file__).resolve().parents[1]
+_CONTRIBUTOR_LOCK = Path("dependencies/contributor-lock.toml")
+_RUNTIME_ARTIFACT_ID_PAYLOAD_ROLES = frozenset(
+    {
+        "compiled-model",
+        "evaluator-manifest",
+        "evaluator-state",
+        "model-parameters",
+        "runtime-physics",
+    }
+)
+_ARTIFACT_IDENTITY_CONTRACT = {
+    "kind": "pyamplicol-runtime-payload-identity",
+    "schema_version": 1,
+}
+
+
+def _require_artifact_identity_contract(manifest: Mapping[str, object]) -> None:
+    extensions = manifest.get("extensions")
+    if (
+        not isinstance(extensions, dict)
+        or extensions.get("artifact_identity") != _ARTIFACT_IDENTITY_CONTRACT
+    ):
+        raise RuntimeError(
+            "process artifact lacks the current identity contract; regenerate it"
+        )
+
+
+def _runtime_artifact_id(manifest: Mapping[str, object]) -> str:
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise RuntimeError("process artifact payload inventory is invalid")
+    records = [
+        dict(payload)
+        for payload in payloads
+        if isinstance(payload, dict)
+        and payload.get("role") in _RUNTIME_ARTIFACT_ID_PAYLOAD_ROLES
+    ]
+    records.sort(key=lambda payload: str(payload.get("path", "")))
+    canonical = (
+        json.dumps(
+            {
+                "kind": "pyamplicol-runtime-payload-identity",
+                "schema_version": 1,
+                "payloads": records,
+            },
+            sort_keys=True,
+            separators=(",", ":"),
+            allow_nan=False,
+        )
+        + "\n"
+    ).encode("utf-8")
+    return hashlib.sha256(canonical).hexdigest()
+
+
+ALLOWLIST = (
+    ".gitattributes",
+    "Cargo.lock",
+    "Cargo.toml",
+    "LICENSE",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md",
+    "build_backend",
+    "config",
+    "dependencies",
+    "docs",
+    "examples",
+    "justfile",
+    "licenses",
+    "pyproject.toml",
+    "release_assets",
+    "rust",
+    "rust-toolchain.toml",
+    "schemas",
+    "source_hash.py",
+    "src",
+    "tests",
+    "tools/ci/__init__.py",
+    "tools/ci/memory_watchdog.py",
+    "tools/developer",
+    "tools/fft_profiling",
+    "tools/performance_report",
+    "tools/release",
+    "tools/typing",
+)
+_PROFILING_CAMPAIGN_SOURCE = Path("src/pyamplicol/_profiling_campaign")
+_PROFILING_CAMPAIGN_REQUIRED_FILES = (
+    Path("README.md"),
+    Path("TABLE_FILLING.md"),
+    Path("build_pdf.py"),
+    Path("pyAmpliCol.tex"),
+    Path("report-workspace.json"),
+    Path("report_environment.json"),
+    Path("report_environment.tex"),
+    Path("result_tables.py"),
+    Path("result_validation_summary.tex"),
+    Path("steer_performance_campaign.py"),
+)
+_PROFILING_CAMPAIGN_GLOBS = (
+    "result_*_table.tex",
+    "section_*.tex",
+    "results/*.json",
+)
+_PROFILING_CAMPAIGN_FILE_COUNT = 69
+_RELEASE_BUILD_INFO_FIELDS = {
+    "publishable",
+    "schema_version",
+    "selftest_fixture_bootstrap",
+    "source_revision",
+    "version",
+}
+_PERFORMANCE_REPORT_REQUIRED_MODULES = {
+    "__init__.py",
+    "cli.py",
+    "manual_campaign.py",
+    "scheduler.py",
+}
+_LEGACY_ORACLE_REQUIRED_MODULES = {
+    "__init__.py",
+    "checkout.py",
+    "model.py",
+    "probe.py",
+}
+IGNORED_NAMES = {
+    "__pycache__",
+    ".agent-work",
+    ".artifacts",
+    ".coverage",
+    ".DS_Store",
+    ".git",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".trash",
+    ".venv",
+    "PYPI_DEPLOYMENT_TEST",
+    "build",
+    "checkouts",
+    "dist",
+    "htmlcov",
+    "wheelhouse",
+    "target",
+    "venv",
+}
+_EXCLUDED_TREES = (
+    Path("dependencies/patches"),
+    Path("docs/.result_outputs"),
+    Path("docs/archive"),
+    Path("outputs"),
+    _PROFILING_CAMPAIGN_SOURCE / "campaign_artifacts",
+    Path("src/pyamplicol/_sdk/fortran"),
+    Path("src/pyamplicol/_sdk/include"),
+    Path("src/pyamplicol/_sdk/lib"),
+)
+_EXCLUDED_PATHS = {
+    Path(".cargo/config.toml"),
+    Path("build_backend/python_lock.py"),
+    Path("dependencies/candidate-Cargo.lock"),
+    Path("dependencies/candidate-cargo-config.toml"),
+    Path("dependencies/contributor-lock.toml"),
+    Path("dependencies/install_dependencies.py"),
+    Path("dependencies/install-state.json"),
+    Path("dependencies/python-runtime-lock.toml"),
+    Path("dependencies/symbolica_patches.tar.gz"),
+    Path("src/pyamplicol/_sdk/link.json"),
+    Path("src/pyamplicol/_sdk/metadata.json"),
+}
+_IGNORED_SUFFIXES = (".mod", ".pyc", ".pyd", ".pyo", ".whl")
+_NATIVE_EXTENSION_SUFFIXES = (".dylib", ".pyd", ".so")
+_TEX_BUILD_SUFFIXES = (
+    ".aux",
+    ".bbl",
+    ".bcf",
+    ".blg",
+    ".fdb_latexmk",
+    ".fls",
+    ".log",
+    ".out",
+    ".run.xml",
+    ".synctex.gz",
+    ".toc",
+)
+# SymJIT Application v3 stores the program and MIR, then recompiles it in
+# Application::load. Its wire format uses native usize fields, so this template
+# is shared only by the release's 64-bit little-endian targets.
+_PORTABLE_SELFTEST_TEMPLATE = "portable-64le"
+_PORTABLE_SELFTEST_TARGETS = frozenset(
+    {
+        "aarch64-apple-darwin",
+        "x86_64-apple-darwin",
+        "x86_64-unknown-linux-gnu",
+    }
+)
+_SELFTEST_FIXTURE_BOOTSTRAP_CONTEXT = "build-current-candidate-site-v1"
+_RELEASE_PREPARED_MODEL_BOOTSTRAP_CONTEXT = "release-prepared-model-producer-v1"
+_INJECTION_ENVIRONMENT_NAMES = {
+    "AR",
+    "CARGO",
+    "C_INCLUDE_PATH",
+    "CC",
+    "CFLAGS",
+    "CPATH",
+    "CPLUS_INCLUDE_PATH",
+    "CXX",
+    "CXXFLAGS",
+    "DYLD_FALLBACK_LIBRARY_PATH",
+    "DYLD_INSERT_LIBRARIES",
+    "DYLD_LIBRARY_PATH",
+    "LD_LIBRARY_PATH",
+    "LDFLAGS",
+    "LIBRARY_PATH",
+    "MACOSX_DEPLOYMENT_TARGET",
+    "OBJC_INCLUDE_PATH",
+    "PKG_CONFIG_PATH",
+    "PYAMPLICOL_BUILD_CACHE_ROOT",
+    "PYAMPLICOL_BUILD_JOBS",
+    "PYAMPLICOL_BUILD_OVERLAY",
+    "PYAMPLICOL_CANDIDATE_CACHE_ROOT",
+    "PYAMPLICOL_NATIVE_BUILD_INPUTS_SHA256",
+    "PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP",
+    "PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP",
+    "PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP_CONTEXT",
+    "PYAMPLICOL_SDK_STAGING",
+    "PYTHONHOME",
+    "PYTHONPATH",
+    "RANLIB",
+    "SDKROOT",
+}
+_INJECTION_ENVIRONMENT_PREFIXES = (
+    "CARGO_",
+    "GIT_",
+    "MATURIN_",
+    "PYO3_",
+    "RUST",
+)
+_Result = TypeVar("_Result")
+_delegation_depth = 0
+
+
+def _prepared_model_bootstrap(mode: str) -> bool:
+    """Return whether this non-publishable build only bootstraps pack creation."""
+
+    value = os.environ.get("PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP", "0")
+    if value not in {"0", "1"}:
+        raise RuntimeError(
+            "PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP must be either '0' or '1'"
+        )
+    if value == "1" and mode != "candidate":
+        raise RuntimeError(
+            "prepared-model bootstrap is restricted to non-publishable candidate builds"
+        )
+    return value == "1"
+
+
+def _release_prepared_model_bootstrap(
+    mode: str,
+    context: str | None,
+) -> bool:
+    """Authorize only the dedicated release prepared-model producer."""
+
+    if context is None:
+        return False
+    if mode != "release":
+        raise RuntimeError(
+            "release prepared-model bootstrap requires release dependency mode"
+        )
+    if context != _RELEASE_PREPARED_MODEL_BOOTSTRAP_CONTEXT:
+        raise RuntimeError(
+            "release prepared-model bootstrap requires the explicit producer context"
+        )
+    return True
+
+
+def _selftest_fixture_bootstrap(
+    mode: str,
+    *,
+    explicit_context: bool = False,
+) -> bool:
+    """Authorize the one-time candidate used to regenerate the self-test fixture."""
+
+    value = os.environ.get("PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP", "0")
+    context = os.environ.get("PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP_CONTEXT")
+    if value not in {"0", "1"}:
+        raise RuntimeError(
+            "PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP must be either '0' or '1'"
+        )
+    if value == "0":
+        if context is not None:
+            raise RuntimeError(
+                "self-test fixture bootstrap context requires the bootstrap flag"
+            )
+        return False
+    if mode != "candidate":
+        raise RuntimeError(
+            "self-test fixture bootstrap is restricted to non-publishable "
+            "candidate builds"
+        )
+    if not explicit_context or context != _SELFTEST_FIXTURE_BOOTSTRAP_CONTEXT:
+        raise RuntimeError(
+            "self-test fixture bootstrap is restricted to the explicit "
+            "build-current-candidate-site context"
+        )
+    return True
+
+
+def _strip_prepared_model_payloads(overlay: Path) -> None:
+    """Remove stale bundles from a bootstrap wheel used only to create replacements."""
+
+    root = overlay / "src" / "pyamplicol" / "assets" / "prepared_models"
+    if not root.is_dir() or root.is_symlink():
+        raise RuntimeError("prepared-model bootstrap input has no safe asset directory")
+    for path in root.iterdir():
+        if path.name == "__init__.py":
+            continue
+        if path.is_symlink() or not path.is_file():
+            raise RuntimeError(
+                f"prepared-model bootstrap found an unsafe asset entry: {path.name}"
+            )
+        if path.suffix not in {".json", ".pyamplicol-model"}:
+            raise RuntimeError(
+                f"prepared-model bootstrap found an unexpected asset: {path.name}"
+            )
+        path.unlink()
+
+
+def _mark_selftest_fixture_bootstrap(
+    overlay: Path,
+    *,
+    prepared_model_recovery: bool = False,
+) -> None:
+    """Mark a regeneration-only build and remove its stale self-test fixture.
+
+    The standalone self-test recovery remains restricted to an exact clean
+    candidate revision. An explicit prepared-model recovery is necessarily
+    coupled to self-test regeneration, however, and may operate on a dirty
+    candidate checkout because its wheel is non-publishable and omits both
+    generated asset families.
+    """
+
+    path = overlay / "src" / "pyamplicol" / "_build_info.json"
+    try:
+        build_info = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise RuntimeError(
+            "self-test fixture bootstrap has no candidate build marker"
+        ) from error
+    if (
+        not isinstance(build_info, dict)
+        or build_info.get("schema_version") != 1
+        or build_info.get("publishable") is not False
+        or build_info.get("selftest_fixture_bootstrap") is not False
+    ):
+        raise RuntimeError(
+            "self-test fixture bootstrap requires an ordinary non-publishable "
+            "candidate marker"
+        )
+    source_revision = build_info.get("source_revision")
+    if prepared_model_recovery:
+        release_recovery = (
+            build_info.get("release_prepared_model_bootstrap") is True
+            and build_info.get("candidate_fingerprint") is None
+            and "source_revision" not in build_info
+        )
+        candidate_fingerprint = build_info.get("candidate_fingerprint")
+        candidate_recovery = (
+            build_info.get("release_prepared_model_bootstrap") is None
+            and isinstance(candidate_fingerprint, str)
+            and re.fullmatch(r"[0-9a-f]{12}", candidate_fingerprint) is not None
+            and "source_revision" in build_info
+            and (
+                source_revision is None
+                or (
+                    isinstance(source_revision, str)
+                    and re.fullmatch(r"[0-9a-f]{40}", source_revision) is not None
+                )
+            )
+        )
+        if not (candidate_recovery or release_recovery):
+            raise RuntimeError(
+                "prepared-model recovery requires a candidate or release "
+                "prepared-model bootstrap marker"
+            )
+    elif (
+        not isinstance(source_revision, str)
+        or re.fullmatch(r"[0-9a-f]{40}", source_revision) is None
+    ):
+        raise RuntimeError(
+            "self-test fixture bootstrap requires an exact clean source revision"
+        )
+    build_info["selftest_fixture_bootstrap"] = True
+    path.write_text(
+        json.dumps(build_info, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+
+    fixture_root = overlay / "src" / "pyamplicol" / "assets" / "selftest"
+    if not fixture_root.is_dir() or fixture_root.is_symlink():
+        raise RuntimeError(
+            "self-test fixture bootstrap input has no safe fixture directory"
+        )
+    entries = tuple(fixture_root.iterdir())
+    template = fixture_root / _PORTABLE_SELFTEST_TEMPLATE
+    if entries != (template,) or not template.is_dir() or template.is_symlink():
+        raise RuntimeError(
+            "self-test fixture bootstrap input has an unexpected fixture inventory"
+        )
+    shutil.rmtree(template)
+
+
+def _build_mode() -> str:
+    value = os.environ.get("PYAMPLICOL_BUILD_MODE", "release")
+    if value not in {"candidate", "release"}:
+        raise RuntimeError("PYAMPLICOL_BUILD_MODE must be 'candidate' or 'release'")
+    return value
+
+
+def _consume_host_wheel_setting(
+    config_settings: Mapping[str, Any] | None,
+) -> tuple[Mapping[str, Any] | None, bool]:
+    """Remove the backend-only, explicitly opt-in host wheel setting."""
+
+    if config_settings is None or "pyamplicol.host-wheel" not in config_settings:
+        return config_settings, False
+    settings = dict(config_settings)
+    value = settings.pop("pyamplicol.host-wheel")
+    if value not in ("true", "false"):
+        raise RuntimeError("pyamplicol.host-wheel must be 'true' or 'false'")
+    return settings, value == "true"
+
+
+def _release_wheel_config_settings(
+    config_settings: Mapping[str, Any] | None,
+) -> Mapping[str, Any] | None:
+    """Use release manylinux tags unless a host-only wheel was requested."""
+
+    if config_settings is not None and (
+        "maturin.build-args" in config_settings or "build-args" in config_settings
+    ):
+        raise RuntimeError(
+            "authenticated wheel builds do not accept caller-supplied Maturin "
+            "build arguments"
+        )
+    config_settings, host_wheel = _consume_host_wheel_setting(config_settings)
+    if sys.platform != "linux" or (_build_mode() != "release" and not host_wheel):
+        return config_settings
+    settings = dict(config_settings or {})
+    settings["maturin.build-args"] = [
+        "--compatibility",
+        "linux" if host_wheel else "manylinux_2_28",
+    ]
+    return settings
+
+
+def _check_dependencies(mode: str) -> None:
+    command = [
+        sys.executable,
+        "-I",
+        str(ROOT / "tools" / "release" / "check_dependencies.py"),
+    ]
+    if mode == "candidate":
+        command.append("--candidate")
+    subprocess.run(
+        command,
+        cwd=ROOT,
+        env=_clean_environment(),
+        check=True,
+    )
+
+
+def _is_excluded(relative: Path) -> bool:
+    if any(
+        part in IGNORED_NAMES or part.endswith(".egg-info") for part in relative.parts
+    ):
+        return True
+    if relative in _EXCLUDED_PATHS or any(
+        relative.is_relative_to(tree) for tree in _EXCLUDED_TREES
+    ):
+        return True
+    if relative.name.endswith(_IGNORED_SUFFIXES):
+        return True
+    if (
+        relative.parent == Path("src/pyamplicol")
+        and relative.name.startswith("_rusticol")
+        and relative.name.endswith(_NATIVE_EXTENSION_SUFFIXES)
+    ):
+        return True
+    report_source = relative.is_relative_to(Path("docs")) or relative.is_relative_to(
+        _PROFILING_CAMPAIGN_SOURCE
+    )
+    return report_source and relative.name.endswith(_TEX_BUILD_SUFFIXES)
+
+
+def _reject_symlinks(path: Path, relative: Path = Path()) -> None:
+    if relative.parts and _is_excluded(relative):
+        return
+    if path.is_symlink():
+        raise RuntimeError(f"build inputs may not be symlinks: {path}")
+    if path.is_dir():
+        for child in sorted(path.iterdir(), key=lambda item: item.name):
+            child_relative = relative / child.name
+            if _is_excluded(child_relative):
+                continue
+            _reject_symlinks(child, child_relative)
+
+
+def _copy_ignore(root: Path) -> Callable[[str, list[str]], set[str]]:
+    def ignore(directory: str, names: list[str]) -> set[str]:
+        relative = Path(directory).relative_to(root)
+        return {name for name in names if _is_excluded(relative / name)}
+
+    return ignore
+
+
+def _is_allowlisted(relative: Path) -> bool:
+    return any(
+        relative == Path(name) or Path(name) in relative.parents for name in ALLOWLIST
+    )
+
+
+# Inside MadGraph7 these come from the prepared-model release archive (see
+# tools/release/prepared_models_archive.py) and are not tracked by Git.
+_UNTRACKED_PREPARED_MODEL_DIRECTORIES = (
+    Path("src/pyamplicol/assets/prepared_models"),
+    Path("release_assets/prepared_models"),
+)
+_UNTRACKED_PREPARED_MODEL_SUFFIXES = (".metadata.json", ".pyamplicol-model")
+# Symlinks to files shared with the rest of MadGraph7; copied by content.
+_SHARED_SYMLINKS = frozenset(
+    {Path("src/pyamplicol/assets/api_templates/umami/umami.h")}
+)
+
+
+def _in_git_checkout() -> bool:
+    """Whether ROOT is a Git checkout, or a tracked subdirectory of one."""
+
+    if os.path.lexists(ROOT / ".git"):
+        return True
+    completed = subprocess.run(
+        ["git", "-C", str(ROOT), "ls-files", "--error-unmatch", "pyproject.toml"],
+        env=_clean_environment(),
+        check=False,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    return completed.returncode == 0
+
+
+def _local_build() -> bool:
+    """Opt-in MadGraph7 installer build from a dirty tree or release tarball."""
+
+    return os.environ.get("PYAMPLICOL_LOCAL_BUILD", "0") == "1"
+
+
+def _untracked_prepared_models() -> list[Path]:
+    files: list[Path] = []
+    for directory in _UNTRACKED_PREPARED_MODEL_DIRECTORIES:
+        if not (ROOT / directory).is_dir():
+            continue
+        for path in sorted((ROOT / directory).iterdir()):
+            if path.name.endswith(_UNTRACKED_PREPARED_MODEL_SUFFIXES):
+                files.append(directory / path.name)
+    return files
+
+
+def _git_inventory(*, build_inputs_only: bool = True) -> list[Path] | None:
+    if not _in_git_checkout():
+        return None
+    completed = subprocess.run(
+        ["git", "-C", str(ROOT), "ls-files", "--cached", "-z", "--"],
+        env=_clean_environment(),
+        check=True,
+        capture_output=True,
+    )
+    files = [Path(os.fsdecode(item)) for item in completed.stdout.split(b"\0") if item]
+    if not files:
+        history = subprocess.run(
+            ["git", "-C", str(ROOT), "rev-parse", "--verify", "HEAD"],
+            env=_clean_environment(),
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        if history.returncode != 0:
+            # An unpacked source archive and the initial no-history bootstrap have
+            # no tracked-file inventory. Their allowlisted archive bytes are the
+            # complete source contract.
+            return None
+    inventory: list[Path] = []
+    for relative in [*files, *_untracked_prepared_models()]:
+        if relative.is_absolute() or ".." in relative.parts:
+            raise RuntimeError(f"Git reported an unsafe build input: {relative}")
+        if not build_inputs_only or (
+            _is_allowlisted(relative) and not _is_excluded(relative)
+        ):
+            inventory.append(relative)
+    return sorted(set(inventory), key=lambda path: path.as_posix())
+
+
+def _archive_inventory() -> list[Path]:
+    inventory: list[Path] = []
+
+    def visit(directory: Path, relative: Path) -> None:
+        for child in sorted(directory.iterdir(), key=lambda item: item.name):
+            child_relative = relative / child.name
+            if _is_excluded(child_relative):
+                continue
+            if child.is_symlink() and child_relative not in _SHARED_SYMLINKS:
+                raise RuntimeError(f"build inputs may not be symlinks: {child}")
+            if child.is_dir():
+                visit(child, child_relative)
+            elif child.is_file():
+                inventory.append(child_relative)
+            else:
+                raise RuntimeError(f"build inputs must be regular files: {child}")
+
+    for name in ALLOWLIST:
+        relative = Path(name)
+        source = ROOT / relative
+        if _is_excluded(relative) or not os.path.lexists(source):
+            continue
+        if source.is_symlink():
+            raise RuntimeError(f"build inputs may not be symlinks: {source}")
+        if source.is_dir():
+            visit(source, relative)
+        elif source.is_file():
+            inventory.append(relative)
+        else:
+            raise RuntimeError(f"build inputs must be regular files: {source}")
+    return inventory
+
+
+def _reject_symlink_ancestors(path: Path) -> None:
+    relative = path.relative_to(ROOT)
+    current = ROOT
+    for part in relative.parts:
+        current /= part
+        try:
+            mode = current.lstat().st_mode
+        except FileNotFoundError:
+            return
+        if stat.S_ISLNK(mode) and current.relative_to(ROOT) not in _SHARED_SYMLINKS:
+            raise RuntimeError(f"build inputs may not be symlinks: {current}")
+
+
+def _copy_allowlisted_source(destination: Path) -> None:
+    destination.mkdir(parents=True)
+    inventory = _git_inventory()
+    if inventory is None:
+        inventory = _archive_inventory()
+    for relative in inventory:
+        source = ROOT / relative
+        _reject_symlink_ancestors(source)
+        shared = relative in _SHARED_SYMLINKS
+        try:
+            mode = (source.stat() if shared else source.lstat()).st_mode
+        except FileNotFoundError:
+            # A tracked deletion remains deleted in the overlay.
+            continue
+        if not stat.S_ISREG(mode):
+            raise RuntimeError(f"build inputs must be regular files: {source}")
+        target = destination / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target, follow_symlinks=shared)
+
+
+def _stage_source_hash(overlay: Path) -> None:
+    """Record the source hash that MadGraph7 compares with its source tree."""
+
+    compute = runpy.run_path(str(ROOT / "source_hash.py"))["compute_source_hash"]
+    target = overlay / "src" / "pyamplicol" / "_source_hash.py"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(f'SOURCE_HASH = "{compute(ROOT)}"\n', encoding="utf-8")
+
+
+def _stage_packaged_examples(overlay: Path) -> None:
+    source = overlay / "examples"
+    target = overlay / "src" / "pyamplicol" / "_examples"
+    if not source.is_dir():
+        raise RuntimeError("wheel build input has no examples directory")
+    if target.exists():
+        raise RuntimeError("wheel overlay already contains packaged examples")
+    shutil.copytree(source, target, ignore=_copy_ignore(overlay))
+
+
+def _profiling_campaign_inventory(source: Path) -> tuple[Path, ...]:
+    selected = set(_PROFILING_CAMPAIGN_REQUIRED_FILES)
+    for pattern in _PROFILING_CAMPAIGN_GLOBS:
+        selected.update(path.relative_to(source) for path in source.glob(pattern))
+    missing = tuple(
+        relative
+        for relative in _PROFILING_CAMPAIGN_REQUIRED_FILES
+        if not (source / relative).is_file()
+    )
+    if missing or len(selected) != _PROFILING_CAMPAIGN_FILE_COUNT:
+        detail = ", ".join(path.as_posix() for path in missing)
+        raise RuntimeError(
+            "wheel profiling campaign has an invalid inventory"
+            + (f": missing {detail}" if detail else "")
+        )
+    for relative in selected:
+        path = source / relative
+        if path.is_symlink() or not path.is_file():
+            raise RuntimeError(
+                f"wheel profiling campaign has an unsafe member: {relative}"
+            )
+    return tuple(sorted(selected, key=lambda path: path.as_posix()))
+
+
+def _stage_packaged_profiling_campaign(overlay: Path) -> None:
+    source = overlay / _PROFILING_CAMPAIGN_SOURCE
+    if not source.is_dir():
+        raise RuntimeError("wheel build input has no profiling campaign directory")
+    _profiling_campaign_inventory(source)
+
+    performance_source = overlay / "tools" / "performance_report"
+    watchdog_source = overlay / "tools" / "ci" / "memory_watchdog.py"
+    legacy_source = overlay / "tools" / "developer" / "legacy_amplicol.py"
+    oracle_source = overlay / "tools" / "developer" / "legacy_oracle"
+    runtime_target = overlay / "src" / "pyamplicol" / "_performance_report"
+    performance_modules = tuple(sorted(performance_source.glob("*.py")))
+    oracle_modules = tuple(sorted(oracle_source.glob("*.py")))
+    if (
+        not _PERFORMANCE_REPORT_REQUIRED_MODULES.issubset(
+            {path.name for path in performance_modules}
+        )
+        or not _LEGACY_ORACLE_REQUIRED_MODULES.issubset(
+            {path.name for path in oracle_modules}
+        )
+        or not watchdog_source.is_file()
+        or not legacy_source.is_file()
+    ):
+        raise RuntimeError("wheel build input has incomplete profiling runtime sources")
+    for path in (*performance_modules, watchdog_source, legacy_source, *oracle_modules):
+        if path.is_symlink() or not path.is_file():
+            raise RuntimeError(f"wheel profiling runtime has an unsafe member: {path}")
+    if runtime_target.exists():
+        raise RuntimeError("wheel overlay already contains a profiling runtime")
+    runtime_target.mkdir(parents=True)
+    for path in performance_modules:
+        shutil.copy2(path, runtime_target / path.name)
+    shutil.copy2(watchdog_source, runtime_target / "_memory_watchdog.py")
+    developer_target = runtime_target / "_developer"
+    developer_target.mkdir()
+    (developer_target / "__init__.py").write_text(
+        "# SPDX-License-Identifier: 0BSD\n",
+        encoding="utf-8",
+    )
+    shutil.copy2(legacy_source, developer_target / legacy_source.name)
+    oracle_target = developer_target / "legacy_oracle"
+    oracle_target.mkdir()
+    for path in oracle_modules:
+        shutil.copy2(path, oracle_target / path.name)
+
+
+def _stage_python_stub(overlay: Path) -> None:
+    source = (
+        overlay
+        / "rust"
+        / "crates"
+        / "rusticol-python"
+        / "stubs"
+        / "pyamplicol"
+        / "_rusticol.pyi"
+    )
+    target = overlay / "src" / "pyamplicol" / "_rusticol.pyi"
+    if not source.is_file():
+        raise RuntimeError("wheel build input has no maintained Rusticol stub")
+    if target.exists():
+        raise RuntimeError("wheel overlay already contains the Rusticol stub")
+    shutil.copy2(source, target)
+
+
+def _stage_runtime_resources(overlay: Path) -> None:
+    """Place wheel-owned schemas below the pyamplicol package namespace."""
+
+    package_assets = overlay / "src" / "pyamplicol" / "assets"
+    sources = {
+        overlay / "schemas" / "README.md": package_assets / "schemas" / "README.md",
+        overlay / "schemas" / "artifact-manifest-v3.schema.json": (
+            package_assets / "schemas" / "artifact-manifest-v3.schema.json"
+        ),
+        overlay / "schemas" / "runtime-physics-v1.schema.json": (
+            package_assets / "schemas" / "runtime-physics-v1.schema.json"
+        ),
+    }
+    for source, target in sources.items():
+        if not source.is_file():
+            raise RuntimeError(
+                f"wheel build input is missing runtime resource: {source}"
+            )
+        if target.exists():
+            raise RuntimeError(
+                f"wheel overlay already contains runtime resource: {target}"
+            )
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target)
+
+
+def _portable_selftest_validators(source_root: Path) -> tuple[Any, Any]:
+    """Load the dependency-free release contract from the source being built."""
+
+    source = source_root / "tools" / "release" / "prepare_selftest_fixture.py"
+    spec = importlib.util.spec_from_file_location(
+        "_pyamplicol_portable_selftest_contract",
+        source,
+    )
+    if spec is None or spec.loader is None:
+        raise RuntimeError("could not load the portable self-test contract")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    artifact_validator = getattr(
+        module,
+        "validate_portable_artifact_capabilities",
+        None,
+    )
+    execution_validator = getattr(
+        module,
+        "validate_portable_execution_manifest",
+        None,
+    )
+    if not callable(artifact_validator) or not callable(execution_validator):
+        raise RuntimeError("portable self-test contract has incomplete validators")
+    return artifact_validator, execution_validator
+
+
+def _validate_portable_selftest_executions(
+    fixture: Path,
+    manifest: Mapping[str, object],
+    *,
+    source_root: Path,
+) -> None:
+    """Fail the build before staging a legacy or partial compiled fixture."""
+
+    validate_artifact, validate_execution = _portable_selftest_validators(source_root)
+    validate_artifact(
+        manifest,
+        context="portable self-test artifact manifest",
+    )
+
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise RuntimeError("portable self-test payload inventory is invalid")
+    execution_payloads = [
+        payload
+        for payload in payloads
+        if isinstance(payload, dict)
+        and payload.get("role") == "evaluator-manifest"
+        and str(payload.get("path", "")).endswith("/execution.json")
+    ]
+    if not execution_payloads:
+        raise RuntimeError("portable self-test has no compiled execution manifest")
+
+    for payload in execution_payloads:
+        relative = payload.get("path")
+        if not isinstance(relative, str):
+            raise RuntimeError("portable self-test execution manifest has no path")
+        path = Path(relative)
+        if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts):
+            raise RuntimeError("portable self-test execution-manifest path is unsafe")
+        execution_path = fixture / "artifact" / path
+        try:
+            execution = json.loads(execution_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as error:
+            raise RuntimeError(
+                f"portable self-test execution manifest is invalid: {relative}"
+            ) from error
+        if not isinstance(execution, dict):
+            raise RuntimeError(
+                f"portable self-test execution manifest is invalid: {relative}"
+            )
+        validate_execution(
+            execution,
+            context=f"portable self-test execution manifest {relative}",
+        )
+
+
+def _stage_selftest_fixture(overlay: Path, target: str) -> None:
+    """Materialize the portable MIR fixture for the wheel's Rust target."""
+
+    if target not in _PORTABLE_SELFTEST_TARGETS:
+        raise RuntimeError(f"unsupported self-test target: {target}")
+
+    with (overlay / "Cargo.toml").open("rb") as stream:
+        cargo = tomllib.load(stream)
+    try:
+        cargo_version = cargo["workspace"]["package"]["version"]
+    except (KeyError, TypeError) as error:
+        raise RuntimeError("build overlay has no workspace package version") from error
+    if not isinstance(cargo_version, str) or not cargo_version:
+        raise RuntimeError("build overlay workspace package version is invalid")
+    package_version = cargo_version.replace("-dev.", ".dev")
+    fixture_root = overlay / "src" / "pyamplicol" / "assets" / "selftest"
+    if not fixture_root.is_dir():
+        raise RuntimeError("wheel build input has no portable self-test fixture")
+    template = fixture_root / _PORTABLE_SELFTEST_TEMPLATE
+    if not template.is_dir() or template.is_symlink():
+        raise RuntimeError("wheel build input has no portable 64-bit self-test fixture")
+    for candidate in fixture_root.iterdir():
+        if candidate == template:
+            continue
+        raise RuntimeError(f"unexpected source self-test fixture: {candidate}")
+    selected = fixture_root / target
+    shutil.copytree(template, selected, symlinks=False)
+    shutil.rmtree(template)
+    expected_path = selected / "expected.json"
+    try:
+        expected = json.loads(expected_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise RuntimeError(f"invalid self-test expectation: {expected_path}") from error
+    if (
+        not isinstance(expected, dict)
+        or expected.get("target") != _PORTABLE_SELFTEST_TEMPLATE
+        or expected.get("compatible_targets") != sorted(_PORTABLE_SELFTEST_TARGETS)
+        or expected.get("serialization")
+        != {
+            "endianness": "little",
+            "kind": "symjit-application-mir-v3",
+            "load_behavior": "recompile-mir-for-loading-host",
+            "source_optimization_level": 2,
+            "word_size_bits": 64,
+        }
+    ):
+        raise RuntimeError("portable self-test expectation is invalid")
+    expected["target"] = target
+    expected_path.write_text(
+        json.dumps(expected, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    path = selected / "artifact" / "artifact.json"
+    try:
+        manifest = json.loads(path.read_text(encoding="utf-8"))
+        _require_artifact_identity_contract(manifest)
+        manifest["producer"]["version"] = package_version
+        manifest["runtime"]["engine_version"] = package_version
+        producer_target = manifest["producer"]["target"]
+        if (
+            not isinstance(producer_target, dict)
+            or producer_target.get("triple") != _PORTABLE_SELFTEST_TEMPLATE
+        ):
+            raise RuntimeError("portable self-test producer target is invalid")
+        producer_target["triple"] = target
+        producer_target["cpu_features"] = []
+        payloads = manifest["payloads"]
+        if not isinstance(payloads, list):
+            raise RuntimeError("portable self-test payload inventory is invalid")
+        _validate_portable_selftest_executions(
+            selected,
+            manifest,
+            source_root=overlay,
+        )
+        evaluator_targets = 0
+        for payload in payloads:
+            if not isinstance(payload, dict):
+                raise RuntimeError("portable self-test payload entry is invalid")
+            payload_target = payload.get("target")
+            if payload_target is None:
+                continue
+            if (
+                not isinstance(payload_target, dict)
+                or payload_target.get("triple") != _PORTABLE_SELFTEST_TEMPLATE
+            ):
+                raise RuntimeError("portable self-test payload target is invalid")
+            payload_target["triple"] = target
+            payload_target["cpu_features"] = []
+            evaluator_targets += 1
+        if evaluator_targets == 0:
+            raise RuntimeError(
+                "portable self-test has no target-tagged evaluator state"
+            )
+        compiled_payloads = [
+            payload
+            for payload in payloads
+            if isinstance(payload, dict) and payload.get("role") == "compiled-model"
+        ]
+        if len(compiled_payloads) != 1:
+            raise RuntimeError("portable self-test must contain one compiled model")
+        compiled_payload = compiled_payloads[0]
+        compiled_relative = compiled_payload.get("path")
+        if not isinstance(compiled_relative, str):
+            raise RuntimeError("portable self-test compiled model has no path")
+        compiled_path = Path(compiled_relative)
+        if compiled_path.is_absolute() or any(
+            part in {"", ".", ".."} for part in compiled_path.parts
+        ):
+            raise RuntimeError("portable self-test compiled-model path is unsafe")
+        compiled_path = selected / "artifact" / compiled_path
+        compiled_model = json.loads(compiled_path.read_text(encoding="utf-8"))
+        if not isinstance(compiled_model, dict):
+            raise RuntimeError("portable self-test compiled model is invalid")
+        compiled_producer = compiled_model.get("producer")
+        if not isinstance(compiled_producer, dict):
+            raise RuntimeError("portable self-test compiled model is invalid")
+        compiled_producer["pyamplicol"] = package_version
+        compiled_data = (
+            json.dumps(
+                compiled_model,
+                sort_keys=True,
+                separators=(",", ":"),
+                allow_nan=False,
+            )
+            + "\n"
+        ).encode("utf-8")
+        compiled_path.write_bytes(compiled_data)
+        compiled_payload["sha256"] = hashlib.sha256(compiled_data).hexdigest()
+        compiled_payload["size_bytes"] = len(compiled_data)
+    except (KeyError, OSError, TypeError, json.JSONDecodeError) as error:
+        raise RuntimeError(f"invalid self-test artifact manifest: {path}") from error
+    manifest["artifact_id"] = _runtime_artifact_id(manifest)
+    path.write_text(
+        json.dumps(
+            manifest,
+            sort_keys=True,
+            separators=(",", ":"),
+            allow_nan=False,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def _mark_candidate(
+    overlay: Path,
+    base_version: str,
+    *,
+    native_build_inputs_sha256: str,
+) -> None:
+    if not (ROOT / _CONTRIBUTOR_LOCK).is_file():
+        raise RuntimeError("candidate build has no contributor dependency contract")
+    check_contributor_lock_consistency(ROOT)
+    candidate_lock, candidate_config, _installer_state = _candidate_inputs()
+    if re.fullmatch(r"[0-9a-f]{64}", native_build_inputs_sha256) is None:
+        raise RuntimeError("candidate build has an invalid native source identity")
+    candidate_fingerprint = native_build_inputs_sha256[:12]
+    cargo_version = f"{base_version}-dev.0+candidate.{candidate_fingerprint}"
+    python_version = cargo_version.replace("-dev.", ".dev")
+    shutil.copy2(candidate_lock, overlay / "Cargo.lock")
+    overlay_config = overlay / ".cargo" / "config.toml"
+    overlay_config.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(candidate_config, overlay_config)
+    _rewrite_candidate_dependency_requirements(overlay)
+    cargo = overlay / "Cargo.toml"
+    text = cargo.read_text(encoding="utf-8")
+    updated, count = re.subn(
+        rf'(?m)^version = "{re.escape(base_version)}"$',
+        f'version = "{cargo_version}"',
+        text,
+        count=1,
+    )
+    if count != 1:
+        raise RuntimeError("could not derive candidate version from Cargo.toml")
+    cargo.write_text(updated, encoding="utf-8")
+
+    lock = overlay / "Cargo.lock"
+    lock_text = lock.read_text(encoding="utf-8")
+    for package_name in (
+        "rusticol-capi",
+        "rusticol-core",
+        "rusticol-python",
+    ):
+        pattern = (
+            rf'(?m)(\[\[package\]\]\nname = "{package_name}"\n)'
+            rf'version = "{re.escape(base_version)}"'
+        )
+        lock_text, count = re.subn(
+            pattern,
+            rf'\g<1>version = "{cargo_version}"',
+            lock_text,
+            count=1,
+        )
+        if count != 1:
+            raise RuntimeError(
+                f"could not derive candidate lock entry for {package_name}"
+            )
+    lock.write_text(lock_text, encoding="utf-8")
+
+    package = overlay / "src" / "pyamplicol"
+    package.mkdir(parents=True, exist_ok=True)
+    source_revision = _clean_source_revision(allow_generated_report_outputs=True)
+    (package / "_build_info.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "candidate_fingerprint": candidate_fingerprint,
+                "native_build_inputs_sha256": native_build_inputs_sha256,
+                "selftest_fixture_bootstrap": False,
+                "source_checkout": str(ROOT.resolve()),
+                "source_revision": source_revision,
+                "version": python_version,
+            },
+            indent=2,
+            sort_keys=True,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def _mark_release_prepared_model_bootstrap(
+    overlay: Path,
+    base_version: str,
+    *,
+    native_build_inputs_sha256: str,
+) -> None:
+    """Mark a release-version wheel as regeneration-only and non-publishable."""
+
+    package = overlay / "src" / "pyamplicol"
+    package.mkdir(parents=True, exist_ok=True)
+    (package / "_build_info.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "candidate_fingerprint": None,
+                "native_build_inputs_sha256": native_build_inputs_sha256,
+                "release_prepared_model_bootstrap": True,
+                "selftest_fixture_bootstrap": False,
+                "source_checkout": str(ROOT.resolve()),
+                "version": base_version,
+            },
+            indent=2,
+            sort_keys=True,
+            allow_nan=False,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def _stage_release_build_info(overlay: Path, version: str) -> None:
+    """Create or retain the minimal provenance marker for a published release."""
+
+    path = overlay / "src" / "pyamplicol" / "_build_info.json"
+    if _local_build() and not path.exists():
+        revision = _clean_source_revision(allow_dirty=True) or "0" * 40
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(
+            json.dumps(
+                {
+                    "schema_version": 1,
+                    "publishable": True,
+                    "selftest_fixture_bootstrap": False,
+                    "source_revision": revision,
+                    "version": version,
+                },
+                indent=2,
+                sort_keys=True,
+                allow_nan=False,
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        return
+    if _in_git_checkout():
+        revision = _clean_source_revision()
+        if revision is None:
+            raise RuntimeError(
+                "publishable release artifacts require a clean Git source revision"
+            )
+        payload: dict[str, object] = {
+            "schema_version": 1,
+            "publishable": True,
+            "selftest_fixture_bootstrap": False,
+            "source_revision": revision,
+            "version": version,
+        }
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(
+            json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+            encoding="utf-8",
+        )
+        return
+
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise RuntimeError(
+            "release source archive has no retained build provenance"
+        ) from error
+    if (
+        not isinstance(payload, dict)
+        or set(payload) != _RELEASE_BUILD_INFO_FIELDS
+        or payload.get("schema_version") != 1
+        or payload.get("publishable") is not True
+        or payload.get("selftest_fixture_bootstrap") is not False
+        or payload.get("version") != version
+        or not isinstance(payload.get("source_revision"), str)
+        or re.fullmatch(r"[0-9a-f]{40}", payload["source_revision"]) is None
+    ):
+        raise RuntimeError("release source archive has invalid build provenance")
+
+
+def _generated_report_status_only(status: bytes) -> bool:
+    """Recognize only report outputs already excluded by campaign identity."""
+
+    records = status.split(b"\0")
+    if (
+        not records
+        or records[-1]
+        or not all(len(record) >= 4 and record[2:3] == b" " for record in records[:-1])
+    ):
+        return False
+    entries = tuple(
+        (record[:2], os.fsdecode(record[3:])) for record in records[:-1]
+    )
+    paths = tuple(path for _state, path in entries)
+    classifier_path = Path("tools/performance_report/source_identity.py")
+    if classifier_path.as_posix() in paths:
+        return False
+    try:
+        namespace = runpy.run_path(str(ROOT / classifier_path))
+        classifier = namespace.get("_generated_report_path")
+    except (OSError, RuntimeError, TypeError, ValueError):
+        return False
+    if not callable(classifier):
+        return False
+    try:
+        tracked = _git_inventory(build_inputs_only=False)
+        if tracked is None:
+            return False
+        copied_campaign_roots = _untracked_profiling_campaign_roots(
+            entries,
+            tracked=tracked,
+        )
+        return all(
+            classifier(path) is True
+            or (
+                state == b"??"
+                and any(
+                    len(PurePosixPath(path).parts) > len(root)
+                    and PurePosixPath(path).parts[: len(root)] == root
+                    for root in copied_campaign_roots
+                )
+            )
+            for state, path in entries
+        )
+    except (OSError, RuntimeError, TypeError, ValueError):
+        return False
+
+
+def _untracked_profiling_campaign_roots(
+    entries: tuple[tuple[bytes, str], ...],
+    *,
+    tracked: list[Path],
+) -> set[tuple[str, ...]]:
+    """Recognize roots of user-owned untracked copied report campaigns.
+
+    ``pyamplicol profiling-campaign copy`` is intentionally useful inside a
+    contributor checkout.  Its files are trusted steering inputs and outputs,
+    but the candidate overlay is built exclusively from Git-tracked inventory,
+    so they cannot alter its Python or native runtime.  This exception is
+    applied only to ``??`` status records; edits to tracked report sources
+    remain source dirt.
+    """
+
+    markers: dict[tuple[str, ...], set[str]] = {}
+    for state, value in entries:
+        path = PurePosixPath(value)
+        parts = path.parts
+        if (
+            state != b"??"
+            or path.is_absolute()
+            or len(parts) < 2
+            or any(part in {"", ".", ".."} for part in parts)
+            or parts[-1]
+            not in {"report-workspace.json", "steer_performance_campaign.py"}
+        ):
+            continue
+        markers.setdefault(parts[:-1], set()).add(parts[-1])
+    required = {"report-workspace.json", "steer_performance_campaign.py"}
+    tracked_parts = tuple(
+        PurePosixPath(path.as_posix()).parts for path in tracked
+    )
+    return {
+        root
+        for root, names in markers.items()
+        if required <= names
+        and not any(
+            len(parts) >= len(root) and parts[: len(root)] == root
+            for parts in tracked_parts
+        )
+    }
+
+
+def _clean_source_revision(
+    *,
+    allow_generated_report_outputs: bool = False,
+    allow_dirty: bool = False,
+) -> str | None:
+    """Return the exact source revision only for a clean Git checkout.
+
+    Candidate wheels remain useful for ordinary dirty-tree development, where
+    this field is ``null``. Strict reference capture rejects those wheels and
+    therefore cannot accidentally certify uncommitted or ambient source.
+    """
+
+    if not _in_git_checkout():
+        return None
+    environment = _clean_environment()
+    try:
+        prefix = subprocess.run(
+            ["git", "rev-parse", "--show-prefix"],
+            cwd=ROOT,
+            env=environment,
+            check=True,
+            capture_output=True,
+        ).stdout.strip()
+        # Only this project's subtree counts; paths are made ROOT-relative.
+        status = subprocess.run(
+            [
+                "git",
+                "status",
+                "--porcelain=v1",
+                "-z",
+                "--untracked-files=all",
+                "--no-renames",
+                "--",
+                ".",
+            ],
+            cwd=ROOT,
+            env=environment,
+            check=True,
+            capture_output=True,
+        ).stdout
+        status = b"\0".join(
+            record[:3] + record[3 + len(prefix) :]
+            if record[3:].startswith(prefix)
+            else record
+            for record in status.split(b"\0")
+        )
+        if status and not allow_dirty and (
+            not allow_generated_report_outputs
+            or not _generated_report_status_only(status)
+        ):
+            return None
+        revision = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            cwd=ROOT,
+            env=environment,
+            check=True,
+            capture_output=True,
+            text=True,
+        ).stdout.strip()
+    except (OSError, subprocess.CalledProcessError):
+        return None
+    return revision if re.fullmatch(r"[a-f0-9]{40}", revision) else None
+
+
+def _locked_package_version(lock_path: Path, package_name: str) -> str:
+    try:
+        with lock_path.open("rb") as stream:
+            payload = tomllib.load(stream)
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        raise RuntimeError(f"invalid candidate Cargo lock: {error}") from error
+    packages = payload.get("package") if isinstance(payload, dict) else None
+    matches = (
+        [package for package in packages if package.get("name") == package_name]
+        if isinstance(packages, list)
+        and all(isinstance(package, dict) for package in packages)
+        else []
+    )
+    if (
+        len(matches) != 1
+        or not isinstance(matches[0].get("version"), str)
+        or not matches[0]["version"]
+    ):
+        raise RuntimeError(
+            f"candidate Cargo lock must contain exactly one {package_name} package"
+        )
+    return str(matches[0]["version"])
+
+
+def _rewrite_candidate_dependency_requirements(overlay: Path) -> None:
+    """Use managed candidate native dependencies only in the build overlay."""
+
+    candidate_symbolica = _locked_package_version(
+        overlay / "Cargo.lock",
+        "symbolica",
+    )
+    manifest = overlay / "rust" / "crates" / "rusticol-core" / "Cargo.toml"
+    text = manifest.read_text(encoding="utf-8")
+    pattern = r'(?m)^(symbolica\s*=\s*\{\s*version\s*=\s*)"=[^"]+"'
+    text, count = re.subn(
+        pattern,
+        rf'\g<1>"={candidate_symbolica}"',
+        text,
+        count=1,
+    )
+    if count != 1:
+        raise RuntimeError(
+            "could not project rusticol-core Symbolica requirement from the "
+            "candidate Cargo lock"
+        )
+    manifest.write_text(text, encoding="utf-8")
+
+    with (overlay / "dependencies" / "release-lock.toml").open("rb") as stream:
+        release = tomllib.load(stream)
+    with (ROOT / _CONTRIBUTOR_LOCK).open("rb") as stream:
+        contributor = tomllib.load(stream)
+    python_manifest = overlay / "pyproject.toml"
+    python_text = python_manifest.read_text(encoding="utf-8")
+    published_python = str(release["symbolica"]["python_version"])
+    candidate_python = str(contributor["symbolica"]["candidate_version"])
+    python_text, count = re.subn(
+        rf'(?m)^(\s*"symbolica==){re.escape(published_python)}(",\s*)$',
+        rf"\g<1>{candidate_python}\g<2>",
+        python_text,
+        count=1,
+    )
+    if count != 1:
+        raise RuntimeError(
+            "could not project Python Symbolica requirement "
+            f"from {published_python} to candidate {candidate_python}"
+        )
+    python_manifest.write_text(python_text, encoding="utf-8")
+
+
+def _candidate_inputs() -> tuple[Path, Path, Path]:
+    lock = ROOT / "dependencies" / "candidate-Cargo.lock"
+    config = ROOT / "dependencies" / "candidate-cargo-config.toml"
+    state = ROOT / "dependencies" / "install-state.json"
+    missing = [path for path in (lock, config, state) if not path.is_file()]
+    if missing:
+        raise RuntimeError(
+            "candidate build inputs are missing; run 'just dev-install': "
+            + ", ".join(str(path) for path in missing)
+        )
+    return lock, config, state
+
+
+def _stage_cargo_inputs(
+    overlay: Path,
+    mode: str,
+    *,
+    native_build_inputs_sha256: str | None,
+) -> None:
+    """Apply managed path overrides only to contributor builds."""
+
+    if mode not in {"candidate", "release"}:
+        raise RuntimeError(f"unsupported Cargo input mode: {mode}")
+    lock = overlay / "Cargo.lock"
+    if not lock.is_file():
+        raise RuntimeError("build overlay has no canonical Cargo.lock")
+    config = overlay / ".cargo" / "config.toml"
+    if mode == "release":
+        if config.exists():
+            raise RuntimeError(
+                "release build overlay contains an ambient Cargo patch configuration"
+            )
+        return
+    if native_build_inputs_sha256 is None:
+        raise RuntimeError("candidate build has no native source identity")
+    _mark_candidate(
+        overlay,
+        canonical_package_version(overlay),
+        native_build_inputs_sha256=native_build_inputs_sha256,
+    )
+    if not config.is_file():
+        raise RuntimeError("candidate build overlay has no Cargo patch configuration")
+
+
+def _candidate_cache_root(mode: str) -> Path | None:
+    """Return the one opt-in, workspace-local contributor build cache."""
+
+    if mode != "candidate":
+        return None
+    raw = os.environ.get("PYAMPLICOL_CANDIDATE_CACHE_ROOT")
+    if raw is None:
+        return None
+    candidate = Path(raw).expanduser()
+    expected = ROOT / ".artifacts" / "dev-install"
+    if not candidate.is_absolute() or candidate.resolve(strict=False) != expected:
+        raise RuntimeError(
+            "PYAMPLICOL_CANDIDATE_CACHE_ROOT must be the workspace-local "
+            f"developer cache: {expected}"
+        )
+    candidate.mkdir(parents=True, exist_ok=True)
+    if candidate.is_symlink() or candidate.resolve(strict=True) != expected:
+        raise RuntimeError("candidate build cache may not use symbolic links")
+    return candidate
+
+
+def _local_cache_root() -> Path | None:
+    """Return the persistent build directory of a MadGraph7 installer build.
+
+    A fixed overlay and Cargo target directory keep rebuilds incremental.
+    """
+
+    if not _local_build():
+        return None
+    raw = os.environ.get("PYAMPLICOL_BUILD_CACHE_ROOT")
+    if raw is None:
+        return None
+    root = Path(raw).expanduser()
+    if not root.is_absolute():
+        raise RuntimeError("PYAMPLICOL_BUILD_CACHE_ROOT must be an absolute path")
+    root.mkdir(parents=True, exist_ok=True)
+    return root.resolve()
+
+
+@contextmanager
+def _candidate_cache_lock(cache_root: Path) -> Iterator[None]:
+    """Serialize refresh and use of the fixed contributor build overlay."""
+
+    try:
+        import fcntl
+    except ImportError as error:  # pragma: no cover - unsupported build host
+        raise RuntimeError("candidate build caching requires a POSIX host") from error
+    lock_path = cache_root / "project-build.lock"
+    if lock_path.is_symlink():
+        raise RuntimeError("candidate build cache lock may not be a symbolic link")
+    with lock_path.open("a+b") as stream:
+        fcntl.flock(stream.fileno(), fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            fcntl.flock(stream.fileno(), fcntl.LOCK_UN)
+
+
+def _populate_overlay(
+    source: Path,
+    mode: str,
+    *,
+    native_build_inputs_sha256: str | None,
+    release_prepared_model_bootstrap: bool,
+    project_release_prepared_models: bool,
+) -> None:
+    _copy_allowlisted_source(source)
+    if mode == "release" and project_release_prepared_models:
+        project_release_packaged_prepared_model_store(
+            source,
+            require_store=_in_git_checkout() or _local_build(),
+        )
+    else:
+        discard_release_packaged_prepared_model_store(source)
+    _stage_cargo_inputs(
+        source,
+        mode,
+        native_build_inputs_sha256=native_build_inputs_sha256,
+    )
+    if release_prepared_model_bootstrap:
+        if native_build_inputs_sha256 is None:
+            raise RuntimeError(
+                "release prepared-model bootstrap has no native source identity"
+            )
+        _mark_release_prepared_model_bootstrap(
+            source,
+            canonical_package_version(source),
+            native_build_inputs_sha256=native_build_inputs_sha256,
+        )
+
+
+@contextmanager
+def _overlay(
+    mode: str,
+    *,
+    release_prepared_model_bootstrap: bool = False,
+    project_release_prepared_models: bool = False,
+    temporary_directory: Path | None = None,
+    cargo_target_directory: Path | None = None,
+) -> Iterator[tuple[Path, Path]]:
+    native_build_inputs_sha256 = (
+        _native_build_inputs_digest(
+            ROOT,
+            normalize_release_cargo_lock=release_prepared_model_bootstrap,
+        )
+        if mode == "candidate" or release_prepared_model_bootstrap
+        else None
+    )
+    cache_root = (
+        _candidate_cache_root(mode) or _local_cache_root()
+        if temporary_directory is None and cargo_target_directory is None
+        else None
+    )
+    if cache_root is not None:
+        with _candidate_cache_lock(cache_root):
+            build_root = cache_root / "project-build"
+            source = build_root / "source"
+            target = cache_root / "cargo-target"
+            cargo_home = cache_root / "cargo-home"
+            for path in (build_root, source, target, cargo_home):
+                if path.is_symlink():
+                    raise RuntimeError(
+                        f"candidate build cache entry may not be a symlink: {path}"
+                    )
+            if source.exists():
+                if not source.is_dir():
+                    raise RuntimeError(
+                        "candidate build overlay path is not a directory"
+                    )
+                shutil.rmtree(source)
+            build_root.mkdir(parents=True, exist_ok=True)
+            _populate_overlay(
+                source,
+                mode,
+                native_build_inputs_sha256=native_build_inputs_sha256,
+                release_prepared_model_bootstrap=release_prepared_model_bootstrap,
+                project_release_prepared_models=project_release_prepared_models,
+            )
+            yield source, target
+        return
+
+    with TemporaryDirectory(
+        prefix="pyamplicol-build-",
+        dir=temporary_directory,
+    ) as temporary:
+        root = Path(temporary)
+        source = root / "source"
+        _populate_overlay(
+            source,
+            mode,
+            native_build_inputs_sha256=native_build_inputs_sha256,
+            release_prepared_model_bootstrap=release_prepared_model_bootstrap,
+            project_release_prepared_models=project_release_prepared_models,
+        )
+        yield (
+            source,
+            (
+                root / "cargo-target"
+                if cargo_target_directory is None
+                else cargo_target_directory
+            ),
+        )
+
+
+@contextmanager
+def _working_directory(path: Path) -> Iterator[None]:
+    previous = Path.cwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(previous)
+
+
+def _clean_environment(
+    updates: Mapping[str, str] | None = None,
+) -> dict[str, str]:
+    environment = {
+        name: value
+        for name, value in os.environ.items()
+        if name not in _INJECTION_ENVIRONMENT_NAMES
+        and not name.startswith(_INJECTION_ENVIRONMENT_PREFIXES)
+    }
+    # A project-local rustup (MadGraph7 installer) only selects where the
+    # pinned RUSTUP_TOOLCHAIN lives.
+    if "RUSTUP_HOME" in os.environ:
+        environment["RUSTUP_HOME"] = os.environ["RUSTUP_HOME"]
+    environment["PATH"] = _build_tool_path(os.environ.get("PATH", ""))
+    if updates:
+        environment.update(updates)
+    return environment
+
+
+def _macos_native_build_updates() -> dict[str, str]:
+    """Select Apple's system compilers for authenticated macOS builds.
+
+    An absolute ``CC`` also gives native build caches such as
+    ``gmp-mpfr-sys`` an unambiguous compiler identity.  Without it, that
+    crate keys its cache by the unresolved name ``gcc`` and can reuse output
+    produced earlier by a package-manager GNU compiler despite the clean
+    build PATH.
+    """
+
+    if sys.platform != "darwin":
+        return {}
+    macos = load_native_build_contract(ROOT)["macos"]
+    return {
+        "CC": str(macos["cc"]),
+        "CXX": str(macos["cxx"]),
+        "MACOSX_DEPLOYMENT_TARGET": str(macos["deployment-target"]),
+    }
+
+
+def _build_tool_path(inherited: str) -> str:
+    """Return a minimal build PATH that cannot select Homebrew/MacPorts tools."""
+
+    interpreter = Path(sys.executable)
+    # Keep the isolated build environment so Maturin's console script remains
+    # available, but never expose the base interpreter's package-manager bin.
+    # A venv Python may resolve into /opt/local or /opt/homebrew, where unrelated
+    # compiler wrappers would otherwise leak non-relocatable RPATHs into wheels.
+    directories: list[Path] = [interpreter.parent]
+    maturin_script = _maturin_console_script()
+    inherited_directories = {
+        Path(os.path.abspath(directory))
+        for directory in inherited.split(os.pathsep)
+        if directory
+    }
+    if maturin_script is not None and maturin_script.parent in inherited_directories:
+        directories.append(maturin_script.parent)
+    for executable in ("cargo", "rustc"):
+        located = shutil.which(executable, path=inherited)
+        if located is None:
+            raise RuntimeError(f"required build tool is unavailable: {executable}")
+        path = Path(located)
+        directories.append(path.parent)
+
+    system_directories = (
+        [Path(path) for path in ("/usr/bin", "/bin", "/usr/sbin", "/sbin")]
+        if os.name == "posix"
+        else []
+    )
+    directories.extend(system_directories)
+    tool_search_path = os.pathsep.join(
+        [*(str(path) for path in system_directories), inherited]
+    )
+    for executable in ("git", "cc", "clang", "ar", "ranlib", "nm"):
+        located = shutil.which(executable, path=tool_search_path)
+        if located is None:
+            continue
+        path = Path(located)
+        directories.append(path.parent)
+    if os.name != "posix":  # Keep unsupported Windows source hooks usable.
+        directories.extend(Path(path) for path in inherited.split(os.pathsep) if path)
+
+    unique: list[str] = []
+    seen: set[str] = set()
+    for directory in directories:
+        rendered = str(directory)
+        if rendered in seen or not directory.is_dir():
+            continue
+        seen.add(rendered)
+        unique.append(rendered)
+    return os.pathsep.join(unique)
+
+
+def _maturin_console_script() -> Path | None:
+    """Locate the console script belonging to the imported Maturin package."""
+
+    package = importlib.metadata.distribution("maturin")
+    for relative in package.files or ():
+        if relative.name not in {"maturin", "maturin.exe"}:
+            continue
+        candidate = Path(os.path.abspath(package.locate_file(relative)))
+        if candidate.is_file():
+            return candidate
+    # `pip install --target DIR` puts the script in DIR/bin, which its RECORD
+    # does not describe.
+    candidate = Path(maturin.__file__).resolve().parents[1] / "bin" / "maturin"
+    return candidate if candidate.is_file() else None
+
+
+def _pinned_rustup_toolchain() -> str:
+    """Return the repository-owned Rustup toolchain selection."""
+
+    path = ROOT / "rust-toolchain.toml"
+    try:
+        toolchain = tomllib.loads(path.read_text(encoding="utf-8"))["toolchain"]
+        channel = toolchain["channel"]
+    except (KeyError, OSError, TypeError, tomllib.TOMLDecodeError) as error:
+        raise RuntimeError(
+            f"invalid repository Rust toolchain contract: {path}"
+        ) from error
+    if not isinstance(channel, str) or not channel.strip():
+        raise RuntimeError(f"invalid repository Rust toolchain channel: {path}")
+    return channel
+
+
+def _rust_remap_flags(overlay: Path, target_dir: Path) -> str:
+    completed = subprocess.run(
+        ["rustc", "--print", "sysroot"],
+        check=True,
+        capture_output=True,
+        text=True,
+        env=_clean_environment({"RUSTUP_TOOLCHAIN": _pinned_rustup_toolchain()}),
+    )
+    sysroot = Path(completed.stdout.strip()).resolve()
+    remapping = load_native_build_contract(ROOT)["rust-path-remapping"]
+    mappings = {
+        (ROOT / "dependencies" / "checkouts").resolve(): (
+            str(remapping["candidate-checkouts"])
+        ),
+        ROOT.resolve(): str(remapping["checkout"]),
+        overlay.resolve(): str(remapping["source"]),
+        target_dir.parent.resolve(): str(remapping["build"]),
+        sysroot: str(remapping["sysroot"]),
+    }
+    flags = [
+        f"--remap-path-prefix={source}={destination}"
+        for source, destination in sorted(
+            mappings.items(), key=lambda item: len(str(item[0])), reverse=True
+        )
+    ]
+    return "\x1f".join(flags)
+
+
+@contextmanager
+def _environment(updates: Mapping[str, str]) -> Iterator[None]:
+    previous = dict(os.environ)
+    isolated = _clean_environment(updates)
+    os.environ.clear()
+    os.environ.update(isolated)
+    try:
+        yield
+    finally:
+        os.environ.clear()
+        os.environ.update(previous)
+
+
+@contextmanager
+def _delegating() -> Iterator[None]:
+    global _delegation_depth
+    if _delegation_depth or "PYAMPLICOL_BUILD_OVERLAY" in os.environ:
+        raise RuntimeError("recursive PEP 517 backend delegation is not permitted")
+    _delegation_depth += 1
+    try:
+        yield
+    finally:
+        _delegation_depth -= 1
+
+
+def _from_overlay(
+    operation: Callable[..., _Result],
+    *args: Any,
+    with_sdk: bool,
+    validate_prepared_models: bool = False,
+    retain_release_build_info: bool = False,
+    release_prepared_model_bootstrap_context: str | None = None,
+    **kwargs: Any,
+) -> _Result:
+    with _delegating():
+        mode = _build_mode()
+        prepared_model_bootstrap = _prepared_model_bootstrap(mode)
+        release_prepared_model_bootstrap = _release_prepared_model_bootstrap(
+            mode,
+            release_prepared_model_bootstrap_context,
+        )
+        # A raw environment escape is never sufficient for a PEP 517 build.
+        # Only the dedicated local regeneration helper supplies the explicit
+        # context accepted by this gate.
+        _selftest_fixture_bootstrap(mode)
+        _check_dependencies(mode)
+        if release_prepared_model_bootstrap:
+            overlay_context = _overlay(
+                mode,
+                release_prepared_model_bootstrap=True,
+            )
+        elif mode == "release":
+            overlay_context = _overlay(
+                mode,
+                project_release_prepared_models=True,
+            )
+        else:
+            overlay_context = _overlay(mode)
+        with overlay_context as (overlay, target_dir):
+            if retain_release_build_info and mode == "release":
+                _stage_release_build_info(
+                    overlay,
+                    canonical_package_version(overlay),
+                )
+            prepared_model_recovery = (
+                prepared_model_bootstrap or release_prepared_model_bootstrap
+            )
+            environment = {
+                "CARGO_HOME": str(target_dir.parent / "cargo-home"),
+                "CARGO_ENCODED_RUSTFLAGS": _rust_remap_flags(overlay, target_dir),
+                "CARGO_TARGET_DIR": str(target_dir),
+                "PYAMPLICOL_BUILD_OVERLAY": str(overlay),
+                "RUSTUP_TOOLCHAIN": _pinned_rustup_toolchain(),
+            }
+            jobs = os.environ.get("PYAMPLICOL_BUILD_JOBS")
+            if jobs:
+                environment["CARGO_BUILD_JOBS"] = jobs
+            build_info_path = overlay / "src" / "pyamplicol" / "_build_info.json"
+            if build_info_path.is_file():
+                try:
+                    build_info = json.loads(build_info_path.read_text(encoding="utf-8"))
+                    native_digest = build_info.get("native_build_inputs_sha256")
+                except (OSError, TypeError, ValueError) as error:
+                    raise RuntimeError(
+                        "build provenance could not be exported to Rust"
+                    ) from error
+                if native_digest is not None:
+                    if not isinstance(native_digest, str) or not native_digest:
+                        raise RuntimeError(
+                            "build provenance contains an invalid native identity"
+                        )
+                    environment["PYAMPLICOL_NATIVE_BUILD_INPUTS_SHA256"] = native_digest
+                else:
+                    environment["PYAMPLICOL_NATIVE_BUILD_INPUTS_SHA256"] = (
+                        _native_build_inputs_digest(
+                            ROOT,
+                            normalize_release_cargo_lock=mode == "release",
+                        )
+                    )
+            else:
+                environment["PYAMPLICOL_NATIVE_BUILD_INPUTS_SHA256"] = (
+                    _native_build_inputs_digest(
+                        ROOT,
+                        normalize_release_cargo_lock=mode == "release",
+                    )
+                )
+            environment.update(_macos_native_build_updates())
+            with _environment(environment), _working_directory(overlay):
+                if validate_prepared_models and not with_sdk:
+                    stage_packaged_prepared_models(overlay, mode)
+                if with_sdk:
+                    _stage_source_hash(overlay)
+                    _stage_packaged_examples(overlay)
+                    _stage_packaged_profiling_campaign(overlay)
+                    _stage_python_stub(overlay)
+                    _stage_runtime_resources(overlay)
+                    if prepared_model_recovery:
+                        _strip_prepared_model_payloads(overlay)
+                        _mark_selftest_fixture_bootstrap(
+                            overlay,
+                            prepared_model_recovery=True,
+                        )
+                    else:
+                        stage_packaged_prepared_models(overlay, mode)
+                    print(
+                        "* Building native C SDK (Cargo; cold builds can take "
+                        "several minutes)...",
+                        flush=True,
+                    )
+                    sdk = build_sdk(overlay, target_dir)
+                    print("* Native C SDK built.", flush=True)
+                    sdk_metadata = json.loads(
+                        (sdk / "metadata.json").read_text(encoding="utf-8")
+                    )
+                    if not prepared_model_recovery:
+                        _stage_selftest_fixture(
+                            overlay,
+                            str(sdk_metadata["target"]),
+                        )
+                    os.environ["PYAMPLICOL_SDK_STAGING"] = str(sdk)
+                return operation(*args, **kwargs)
+
+
+def build_wheel(
+    wheel_directory: str,
+    config_settings: Mapping[str, Any] | None = None,
+    metadata_directory: str | None = None,
+) -> str:
+    config_settings = _release_wheel_config_settings(config_settings)
+    filename = _from_overlay(
+        maturin.build_wheel,
+        wheel_directory,
+        config_settings,
+        metadata_directory,
+        with_sdk=True,
+        retain_release_build_info=True,
+    )
+    return filename
+
+
+def build_release_prepared_model_bootstrap_wheel(
+    wheel_directory: str,
+    *,
+    bootstrap_context: str,
+    config_settings: Mapping[str, Any] | None = None,
+) -> str:
+    """Build a release-version wheel usable only to regenerate prepared packs."""
+
+    config_settings = _release_wheel_config_settings(config_settings)
+    if sys.platform == "linux":
+        # This non-publishable wheel runs only on its producer, which need not
+        # be a manylinux image. The generated prepared packs remain portable.
+        config_settings = dict(config_settings or {})
+        config_settings["maturin.build-args"] = ["--compatibility", "linux"]
+    return _from_overlay(
+        maturin.build_wheel,
+        wheel_directory,
+        config_settings,
+        None,
+        with_sdk=True,
+        release_prepared_model_bootstrap_context=bootstrap_context,
+    )
+
+
+def build_sdist(
+    sdist_directory: str,
+    config_settings: Mapping[str, Any] | None = None,
+) -> str:
+    if _build_mode() == "candidate":
+        raise RuntimeError(
+            "candidate builds are wheel-only and cannot produce source distributions"
+        )
+    return _from_overlay(
+        maturin.build_sdist,
+        sdist_directory,
+        config_settings,
+        with_sdk=False,
+        validate_prepared_models=True,
+        retain_release_build_info=True,
+    )
+
+
+def get_requires_for_build_wheel(
+    config_settings: Mapping[str, Any] | None = None,
+) -> list[str]:
+    config_settings, _ = _consume_host_wheel_setting(config_settings)
+    return _from_overlay(
+        maturin.get_requires_for_build_wheel,
+        config_settings,
+        with_sdk=False,
+    )
+
+
+def get_requires_for_build_sdist(
+    config_settings: Mapping[str, Any] | None = None,
+) -> list[str]:
+    return _from_overlay(
+        maturin.get_requires_for_build_sdist,
+        config_settings,
+        with_sdk=False,
+    )
+
+
+def prepare_metadata_for_build_wheel(
+    metadata_directory: str,
+    config_settings: Mapping[str, Any] | None = None,
+) -> str:
+    config_settings, _ = _consume_host_wheel_setting(config_settings)
+    return _from_overlay(
+        maturin.prepare_metadata_for_build_wheel,
+        metadata_directory,
+        config_settings,
+        with_sdk=False,
+    )
diff --git a/pyamplicol/build_backend/native_build_identity.py b/pyamplicol/build_backend/native_build_identity.py
new file mode 100644
index 0000000000..8ce4ea47ba
--- /dev/null
+++ b/pyamplicol/build_backend/native_build_identity.py
@@ -0,0 +1,620 @@
+# SPDX-License-Identifier: 0BSD
+"""Canonical source identity for the native pyAmpliCol build."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import tomllib
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+_NATIVE_BUILD_IDENTITY_DOMAIN = b"pyamplicol-native-build-inputs-v2\0"
+_NATIVE_BUILD_INPUT_FILES = (
+    Path("Cargo.lock"),
+    Path("Cargo.toml"),
+    Path("pyproject.toml"),
+    Path("rust-toolchain.toml"),
+    Path("dependencies/candidate-Cargo.lock"),
+    Path("dependencies/candidate-cargo-config.toml"),
+    Path("dependencies/install-state.json"),
+)
+_NATIVE_BUILD_INPUT_TREES = (Path("rust"),)
+# Release sdists omit candidate-only resolution state.
+_RELEASE_OMITTED_NATIVE_BUILD_INPUTS = frozenset(
+    {
+        Path("dependencies/candidate-Cargo.lock"),
+        Path("dependencies/candidate-cargo-config.toml"),
+        Path("dependencies/install-state.json"),
+    }
+)
+_NATIVE_MATURIN_CONFIG_KEYS = frozenset(
+    {
+        "all-features",
+        "bindings",
+        "config",
+        "features",
+        "include-debuginfo",
+        "manifest-path",
+        "module-name",
+        "no-default-features",
+        "profile",
+        "rustc-args",
+        "strip",
+        "target",
+        "targets",
+        "unstable-flags",
+        "zig",
+    }
+)
+_NON_OUTPUT_MATURIN_CONFIG_KEYS = frozenset(
+    {
+        "editable-profile",
+        "frozen",
+        "locked",
+        "pgo-command",
+        "target-dir",
+        "use-base-python",
+    }
+)
+_PACKAGING_MATURIN_CONFIG_KEYS = frozenset(
+    {
+        "auditwheel",
+        "compatibility",
+        "data",
+        "exclude",
+        "generate-ci",
+        "generate-stubs",
+        "include",
+        "include-import-lib",
+        "manylinux",
+        "python-packages",
+        "python-source",
+        "sbom",
+        "sdist-generator",
+        "skip-auditwheel",
+        "compression-enable-large-file-support",
+        "compression-level",
+        "compression-method",
+        "sbom-include",
+    }
+)
+_NATIVE_BUILD_IGNORED_TREE_PARTS = frozenset({".artifacts", "__pycache__", "target"})
+# This explicit inventory contains only separately compiled test modules,
+# integration-test inputs, and Python/stub packaging files. Additions default
+# to native inputs. Mixed production files with inline #[cfg(test)] modules are
+# deliberately hashed at file granularity; stripping Rust syntax here would be
+# a second, incomplete compiler frontend.
+_NON_NATIVE_RUST_PATHS = frozenset(
+    {
+        Path("rust/crates/rusticol-capi/tests/eager_artifact.rs"),
+        Path("rust/crates/rusticol-capi/tests/runtime_selectors.rs"),
+        Path("rust/crates/rusticol-core/src/artifact_tests.rs"),
+        Path("rust/crates/rusticol-core/src/eager_layout_tests.rs"),
+        Path("rust/crates/rusticol-core/src/eager_lowering_v3_tests.rs"),
+        Path("rust/crates/rusticol-core/src/eager_plan_v3_pacbin_tests.rs"),
+        Path("rust/crates/rusticol-core/src/eager_runtime/plan_v3_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/contraction_metadata_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/eager_integration_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/eager_v3_manifest_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/quantum_number_flow_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/recurrence_integration_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/source_metadata_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine_tests.rs"),
+        Path("rust/crates/rusticol-core/src/metadata_tests.rs"),
+        Path("rust/crates/rusticol-core/src/pacbin_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_backend_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_codec_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_lowering_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_pacbin_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_plan_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_runtime_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/tests.rs"),
+        Path("rust/crates/rusticol-core/tests/direct_arena_workspace_allocations.rs"),
+        Path("rust/crates/rusticol-core/tests/eager_runtime.rs"),
+        Path(
+            "rust/crates/rusticol-core/tests/fixtures/on_the_fly_query_parity_v1.json"
+        ),
+        Path(
+            "rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_full_v2.json"
+        ),
+        Path(
+            "rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_lc.json"
+        ),
+        Path(
+            "rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_nlc.json"
+        ),
+        Path("rust/crates/rusticol-core/tests/generated_artifact_odd_tails.rs"),
+        Path("rust/crates/rusticol-core/tests/recurrence_direct_arena_allocations.rs"),
+        Path("rust/crates/rusticol-python/stubs/pyamplicol/__init__.pyi"),
+        Path("rust/crates/rusticol-python/stubs/pyamplicol/_rusticol.pyi"),
+        Path("rust/crates/rusticol-python/tests/pyrightconfig.json"),
+        Path("rust/crates/rusticol-python/tests/stub_contract.rs"),
+        Path("rust/crates/rusticol-python/tests/typing_consumer.py"),
+    }
+)
+_NATIVE_BUILD_CONTRACT_KEYS = frozenset(
+    {"macos", "rust-path-remapping", "schema-version", "sdk"}
+)
+_RUST_PATH_REMAP_KEYS = frozenset(
+    {"build", "candidate-checkouts", "checkout", "source", "sysroot"}
+)
+_MACOS_NATIVE_BUILD_KEYS = frozenset({"cc", "cxx", "deployment-target"})
+_SDK_NATIVE_BUILD_KEYS = frozenset({"package", "profile", "rustc-codegen-arguments"})
+_CANDIDATE_CARGO_CONFIG = Path("dependencies/candidate-cargo-config.toml")
+_CANDIDATE_INSTALL_STATE = Path("dependencies/install-state.json")
+_CANDIDATE_PATCH_TARGETS = {
+    "graphica": "dependencies/checkouts/symbolica/lib/graphica",
+    "numerica": "dependencies/checkouts/symbolica/lib/numerica",
+    "symbolica": "dependencies/checkouts/symbolica",
+    "symjit": "dependencies/checkouts/symjit",
+}
+_NATIVE_CANDIDATE_SOURCE_NAMES = frozenset({"symbolica", "symjit"})
+
+
+def _canonical_json_bytes(payload: Any) -> bytes:
+    try:
+        return (
+            json.dumps(
+                payload,
+                sort_keys=True,
+                separators=(",", ":"),
+                allow_nan=False,
+            )
+            + "\n"
+        ).encode("utf-8")
+    except (TypeError, ValueError) as error:
+        raise RuntimeError(
+            f"candidate native build identity is not canonical JSON: {error}"
+        ) from error
+
+
+def _native_build_contract(payload: Mapping[str, Any]) -> dict[str, Any]:
+    """Validate the one declarative contract consumed by native build code."""
+
+    tool = payload.get("tool")
+    pyamplicol = tool.get("pyamplicol") if isinstance(tool, Mapping) else None
+    contract = (
+        pyamplicol.get("native-build") if isinstance(pyamplicol, Mapping) else None
+    )
+    if not isinstance(contract, Mapping) or set(contract) != set(
+        _NATIVE_BUILD_CONTRACT_KEYS
+    ):
+        raise RuntimeError(
+            "native pyproject contract must contain exactly schema-version, "
+            "rust-path-remapping, macos, and sdk"
+        )
+    schema_version = contract.get("schema-version")
+    if (
+        not isinstance(schema_version, int)
+        or isinstance(schema_version, bool)
+        or schema_version != 1
+    ):
+        raise RuntimeError("native pyproject contract must use schema-version 1")
+
+    remapping = contract.get("rust-path-remapping")
+    if not isinstance(remapping, Mapping) or set(remapping) != set(
+        _RUST_PATH_REMAP_KEYS
+    ):
+        raise RuntimeError("native Rust path-remapping contract is incomplete")
+    canonical_remapping: dict[str, str] = {}
+    for key in sorted(_RUST_PATH_REMAP_KEYS):
+        value = remapping[key]
+        if not isinstance(value, str) or not value.startswith("/"):
+            raise RuntimeError(
+                f"native Rust path-remapping destination {key} must be absolute"
+            )
+        canonical_remapping[key] = value
+    if len(set(canonical_remapping.values())) != len(canonical_remapping):
+        raise RuntimeError("native Rust path-remapping destinations must be unique")
+
+    macos = contract.get("macos")
+    if not isinstance(macos, Mapping) or set(macos) != set(_MACOS_NATIVE_BUILD_KEYS):
+        raise RuntimeError("native macOS build contract is incomplete")
+    canonical_macos: dict[str, str] = {}
+    for key in sorted(_MACOS_NATIVE_BUILD_KEYS):
+        value = macos[key]
+        if not isinstance(value, str) or not value:
+            raise RuntimeError(f"native macOS build setting {key} is invalid")
+        canonical_macos[key] = value
+    if not canonical_macos["cc"].startswith("/") or not canonical_macos[
+        "cxx"
+    ].startswith("/"):
+        raise RuntimeError("native macOS compilers must be absolute paths")
+
+    sdk = contract.get("sdk")
+    if not isinstance(sdk, Mapping) or set(sdk) != set(_SDK_NATIVE_BUILD_KEYS):
+        raise RuntimeError("native SDK build contract is incomplete")
+    package = sdk.get("package")
+    profile = sdk.get("profile")
+    codegen = sdk.get("rustc-codegen-arguments")
+    if not isinstance(package, str) or not package:
+        raise RuntimeError("native SDK package must be a non-empty string")
+    if not isinstance(profile, str) or not profile:
+        raise RuntimeError("native SDK profile must be a non-empty string")
+    if (
+        not isinstance(codegen, list)
+        or not codegen
+        or any(not isinstance(value, str) or not value for value in codegen)
+    ):
+        raise RuntimeError("native SDK rustc codegen arguments must be strings")
+    return {
+        "macos": canonical_macos,
+        "rust-path-remapping": canonical_remapping,
+        "schema-version": 1,
+        "sdk": {
+            "package": package,
+            "profile": profile,
+            "rustc-codegen-arguments": list(codegen),
+        },
+    }
+
+
+def canonical_native_pyproject_bytes(data: bytes) -> bytes:
+    """Project only semantic inputs to the authenticated native build."""
+
+    try:
+        payload = tomllib.loads(data.decode("utf-8"))
+    except (UnicodeDecodeError, tomllib.TOMLDecodeError) as error:
+        raise RuntimeError(
+            f"invalid native pyproject configuration: {error}"
+        ) from error
+    build_system = payload.get("build-system")
+    requirements = (
+        build_system.get("requires") if isinstance(build_system, Mapping) else None
+    )
+    if not isinstance(requirements, list) or any(
+        not isinstance(requirement, str) for requirement in requirements
+    ):
+        raise RuntimeError("native pyproject build-system requires must be a list")
+    maturin_pins: list[str] = []
+    for requirement in requirements:
+        match = re.fullmatch(
+            r"\s*maturin\s*==\s*([0-9][A-Za-z0-9._+-]*)\s*",
+            requirement,
+            flags=re.IGNORECASE,
+        )
+        if match is not None:
+            maturin_pins.append(f"maturin=={match.group(1)}")
+        elif re.match(r"\s*maturin(?:\W|$)", requirement, flags=re.IGNORECASE):
+            raise RuntimeError(
+                "native Maturin build requirement must be exactly pinned"
+            )
+    if len(maturin_pins) != 1:
+        raise RuntimeError(
+            "native pyproject must contain exactly one pinned Maturin requirement"
+        )
+
+    tool = payload.get("tool")
+    maturin = tool.get("maturin") if isinstance(tool, Mapping) else None
+    if not isinstance(maturin, Mapping):
+        raise RuntimeError("native pyproject Maturin configuration must be a table")
+    classified = (
+        _NATIVE_MATURIN_CONFIG_KEYS
+        | _NON_OUTPUT_MATURIN_CONFIG_KEYS
+        | _PACKAGING_MATURIN_CONFIG_KEYS
+    )
+    unknown = set(maturin) - classified
+    if unknown:
+        rendered = ", ".join(sorted(str(key) for key in unknown))
+        raise RuntimeError(f"unclassified Maturin configuration: {rendered}")
+    return _canonical_json_bytes(
+        {
+            "build-system": {"requires": maturin_pins},
+            "tool": {
+                "maturin": {
+                    key: maturin[key]
+                    for key in sorted(_NATIVE_MATURIN_CONFIG_KEYS & set(maturin))
+                },
+                "pyamplicol": {"native-build": _native_build_contract(payload)},
+            },
+        }
+    )
+
+
+def load_native_build_contract(root: Path) -> dict[str, Any]:
+    """Load the canonical backend knobs from the hashed pyproject input."""
+
+    path = root / "pyproject.toml"
+    try:
+        payload = tomllib.loads(path.read_text(encoding="utf-8"))
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        raise RuntimeError(f"invalid native build contract: {path}: {error}") from error
+    return _native_build_contract(payload)
+
+
+def _canonical_checkout_path(raw: str) -> str:
+    normalized = raw.replace("\\", "/").rstrip("/")
+    if normalized in {"TMP_FIXED_SYMJIT", "./TMP_FIXED_SYMJIT"} or normalized.endswith(
+        "/TMP_FIXED_SYMJIT"
+    ):
+        return "TMP_FIXED_SYMJIT"
+    marker = "/dependencies/checkouts/"
+    if marker in normalized:
+        suffix = normalized.rsplit(marker, maxsplit=1)[1]
+        if suffix:
+            return f"dependencies/checkouts/{suffix}"
+    prefix = "dependencies/checkouts/"
+    if normalized.startswith(prefix) and len(normalized) > len(prefix):
+        return normalized
+    raise RuntimeError(
+        "candidate Cargo patch paths must resolve below dependencies/checkouts"
+    )
+
+
+def canonical_candidate_cargo_config_bytes(data: bytes) -> bytes:
+    """Return the exact path-independent candidate Cargo patch contract."""
+
+    try:
+        payload = tomllib.loads(data.decode("utf-8"))
+        patch = payload["patch"]
+        crates_io = patch["crates-io"]
+    except (
+        KeyError,
+        TypeError,
+        UnicodeDecodeError,
+        tomllib.TOMLDecodeError,
+    ) as error:
+        raise RuntimeError(f"invalid candidate Cargo config: {error}") from error
+    if (
+        not isinstance(payload, dict)
+        or set(payload) != {"patch"}
+        or not isinstance(patch, dict)
+        or set(patch) != {"crates-io"}
+        or not isinstance(crates_io, dict)
+        or not set(_CANDIDATE_PATCH_TARGETS).issubset(crates_io)
+    ):
+        raise RuntimeError(
+            "candidate Cargo config must contain the locked native crates.io "
+            "patch table"
+        )
+    canonical: dict[str, Any] = {"patch": {"crates-io": {}}}
+    canonical_patches = canonical["patch"]["crates-io"]
+    for name, expected in _CANDIDATE_PATCH_TARGETS.items():
+        entry = crates_io[name]
+        if (
+            not isinstance(entry, Mapping)
+            or set(entry) != {"path"}
+            or not isinstance(entry["path"], str)
+        ):
+            raise RuntimeError(
+                f"candidate Cargo patch {name} must contain exactly one path"
+            )
+        observed = _canonical_checkout_path(entry["path"])
+        if observed != expected and not (
+            name == "symjit" and observed == "TMP_FIXED_SYMJIT"
+        ):
+            raise RuntimeError(
+                f"candidate Cargo patch {name} must resolve to {expected}"
+            )
+        canonical_patches[name] = {"path": observed}
+    return _canonical_json_bytes(canonical)
+
+
+def _required_string(
+    payload: Mapping[str, Any],
+    key: str,
+    *,
+    description: str,
+) -> str:
+    value = payload.get(key)
+    if not isinstance(value, str) or not value:
+        raise RuntimeError(f"{description} {key} must be a non-empty string")
+    return value
+
+
+def _required_hex(
+    payload: Mapping[str, Any],
+    key: str,
+    *,
+    length: int,
+    description: str,
+) -> str:
+    value = _required_string(payload, key, description=description)
+    if len(value) != length or any(
+        character not in "0123456789abcdef" for character in value
+    ):
+        raise RuntimeError(
+            f"{description} {key} must be a lowercase {length}-digit hex value"
+        )
+    return value
+
+
+def _canonical_candidate_sources(raw_sources: Any) -> dict[str, dict[str, str]]:
+    if not isinstance(raw_sources, Mapping):
+        raise RuntimeError("candidate installer state sources must be an object")
+    source_names = set(raw_sources)
+    if any(not isinstance(name, str) or not name for name in source_names):
+        raise RuntimeError("candidate installer source names must be non-empty strings")
+    if not _NATIVE_CANDIDATE_SOURCE_NAMES.issubset(source_names):
+        raise RuntimeError(
+            "candidate installer state has an incomplete native source map"
+        )
+    sources: dict[str, dict[str, str]] = {}
+    for name in sorted(_NATIVE_CANDIDATE_SOURCE_NAMES):
+        raw_source = raw_sources[name]
+        description = f"candidate installer source {name}"
+        if not isinstance(raw_source, Mapping):
+            raise RuntimeError(f"{description} must be an object")
+        allowed_fields = {"url", "revision", "branch"}
+        required_fields = {"url", "revision"}
+        if not required_fields.issubset(raw_source) or not set(raw_source).issubset(
+            allowed_fields
+        ):
+            raise RuntimeError(
+                f"{description} must contain url/revision and optional branch only"
+            )
+        source = {
+            "url": _required_string(raw_source, "url", description=description),
+            "revision": _required_hex(
+                raw_source,
+                "revision",
+                length=40,
+                description=description,
+            ),
+        }
+        if "branch" in raw_source:
+            source["branch"] = _required_string(
+                raw_source,
+                "branch",
+                description=description,
+            )
+        sources[name] = source
+    return sources
+
+
+def canonical_candidate_install_state_bytes(
+    root: Path,
+    data: bytes,
+    *,
+    cargo_config_data: bytes,
+) -> bytes:
+    """Validate and canonicalize the minimal immutable-source install state."""
+
+    del root, cargo_config_data
+
+    try:
+        payload = json.loads(data)
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise RuntimeError(f"invalid candidate installer state: {error}") from error
+    schema_version = (
+        payload.get("schema_version") if isinstance(payload, dict) else None
+    )
+    if not isinstance(payload, dict) or set(payload) != {
+        "publishable",
+        "schema_version",
+        "sources",
+    }:
+        raise RuntimeError(
+            "candidate installer state must contain only schema_version, "
+            "publishable, and sources"
+        )
+    if (
+        not isinstance(schema_version, int)
+        or isinstance(schema_version, bool)
+        or schema_version != 1
+        or payload["publishable"] is not False
+    ):
+        raise RuntimeError(
+            "candidate installer state must be a non-publishable schema-1 object"
+        )
+    sources = _canonical_candidate_sources(payload["sources"])
+    return _canonical_json_bytes(
+        {
+            "publishable": False,
+            "schema_version": 1,
+            "sources": sources,
+        }
+    )
+
+
+def canonical_release_cargo_lock_bytes(root: Path, data: bytes) -> bytes:
+    """Return the ordinary immutable-Git Cargo lock without projection."""
+
+    del root
+    return data
+
+
+def _is_native_build_tree_input(root: Path, tree: Path, path: Path) -> bool:
+    if not path.is_file():
+        return False
+    tree_relative = path.relative_to(tree)
+    root_relative = path.relative_to(root)
+    return (
+        not _NATIVE_BUILD_IGNORED_TREE_PARTS.intersection(tree_relative.parts)
+        and root_relative not in _NON_NATIVE_RUST_PATHS
+    )
+
+
+def native_build_inputs_digest(
+    root: Path,
+    *,
+    normalize_release_cargo_lock: bool = False,
+) -> str:
+    """Hash every checked-out input that can change the native runtime build."""
+
+    candidate_config = root / _CANDIDATE_CARGO_CONFIG
+    candidate_state = root / _CANDIDATE_INSTALL_STATE
+    canonical_candidate_inputs: dict[Path, bytes] = {}
+    if not normalize_release_cargo_lock:
+        if candidate_config.is_file() != candidate_state.is_file():
+            raise RuntimeError(
+                "candidate native build identity requires both "
+                "candidate-cargo-config.toml and install-state.json"
+            )
+        if candidate_config.is_file():
+            cargo_config_data = candidate_config.read_bytes()
+            canonical_candidate_inputs[candidate_config] = (
+                canonical_candidate_cargo_config_bytes(cargo_config_data)
+            )
+            canonical_candidate_inputs[candidate_state] = (
+                canonical_candidate_install_state_bytes(
+                    root,
+                    candidate_state.read_bytes(),
+                    cargo_config_data=cargo_config_data,
+                )
+            )
+
+    paths = [
+        root / relative
+        for relative in _NATIVE_BUILD_INPUT_FILES
+        if not (
+            normalize_release_cargo_lock
+            and relative in _RELEASE_OMITTED_NATIVE_BUILD_INPUTS
+        )
+        and not (canonical_candidate_inputs and relative == Path("Cargo.lock"))
+    ]
+    # Local upstream fixes have no new Git revision. Include their compiler
+    # inputs in the existing cache key, but not their tests or documentation.
+    manifest = root / "Cargo.toml"
+    if manifest.is_file():
+        cargo = tomllib.loads(manifest.read_text(encoding="utf-8"))
+        local_symjit = cargo.get("patch", {}).get("crates-io", {}).get("symjit", {})
+        local_path = local_symjit.get("path")
+        if isinstance(local_path, str):
+            local_root = (root / local_path).resolve()
+            if local_root == (root / "TMP_FIXED_SYMJIT").resolve():
+                paths.extend(local_root / name for name in ("Cargo.toml", "build.rs"))
+                paths.extend(
+                    path for path in (local_root / "src").rglob("*") if path.is_file()
+                )
+    for relative in _NATIVE_BUILD_INPUT_TREES:
+        tree = root / relative
+        if not tree.is_dir():
+            continue
+        paths.extend(
+            path
+            for path in tree.rglob("*")
+            if _is_native_build_tree_input(root, tree, path)
+            and not (
+                normalize_release_cargo_lock
+                and path.relative_to(root) in _RELEASE_OMITTED_NATIVE_BUILD_INPUTS
+            )
+        )
+    digest = hashlib.sha256(_NATIVE_BUILD_IDENTITY_DOMAIN)
+    for path in sorted(set(paths)):
+        if not path.is_file():
+            continue
+        relative = path.relative_to(root).as_posix().encode("utf-8")
+        digest.update(len(relative).to_bytes(8, "little"))
+        digest.update(relative)
+        data = canonical_candidate_inputs.get(path, path.read_bytes())
+        if path == root / "pyproject.toml":
+            data = canonical_native_pyproject_bytes(data)
+        if normalize_release_cargo_lock and path == root / "Cargo.lock":
+            data = canonical_release_cargo_lock_bytes(root, data)
+        digest.update(len(data).to_bytes(8, "little"))
+        digest.update(data)
+    return digest.hexdigest()
+
+
+__all__ = [
+    "canonical_candidate_cargo_config_bytes",
+    "canonical_candidate_install_state_bytes",
+    "canonical_native_pyproject_bytes",
+    "canonical_release_cargo_lock_bytes",
+    "load_native_build_contract",
+    "native_build_inputs_digest",
+]
diff --git a/pyamplicol/build_backend/package_version.py b/pyamplicol/build_backend/package_version.py
new file mode 100644
index 0000000000..10d5e59373
--- /dev/null
+++ b/pyamplicol/build_backend/package_version.py
@@ -0,0 +1,123 @@
+# SPDX-License-Identifier: 0BSD
+"""Package-version checks sourced from the Cargo workspace manifest."""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Any
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    try:
+        with path.open("rb") as stream:
+            payload = tomllib.load(stream)
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        raise RuntimeError(
+            f"cannot read package version contract {path}: {error}"
+        ) from error
+    if not isinstance(payload, dict):
+        raise RuntimeError(f"package version contract {path} is not a TOML table")
+    return payload
+
+
+def _required_string(value: object, context: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise RuntimeError(f"{context} must be a nonempty string")
+    return value
+
+
+def canonical_package_version(root: Path) -> str:
+    """Return Cargo's package version after checking release-facing metadata."""
+
+    cargo = _load_toml(root / "Cargo.toml")
+    pyproject = _load_toml(root / "pyproject.toml")
+    release = _load_toml(root / "dependencies" / "release-lock.toml")
+    try:
+        cargo_version = _required_string(
+            cargo["workspace"]["package"]["version"],
+            "Cargo.toml [workspace.package].version",
+        )
+        project = pyproject["project"]
+        locked_version = _required_string(
+            release["project"]["version"],
+            "dependencies/release-lock.toml [project].version",
+        )
+    except (KeyError, TypeError) as error:
+        raise RuntimeError("package version contract is incomplete") from error
+
+    if not isinstance(project, dict):
+        raise RuntimeError("pyproject.toml [project] must be a table")
+    dynamic = project.get("dynamic")
+    if (
+        "version" in project
+        or not isinstance(dynamic, list)
+        or "version" not in dynamic
+    ):
+        raise RuntimeError(
+            "pyproject.toml must declare project.version as dynamic; "
+            "Cargo.toml [workspace.package].version is canonical"
+        )
+    if locked_version != cargo_version:
+        raise RuntimeError(
+            "package version mismatch: Cargo.toml declares "
+            f"{cargo_version!r}, but dependencies/release-lock.toml declares "
+            f"{locked_version!r}"
+        )
+    return cargo_version
+
+
+def check_contributor_lock_consistency(root: Path) -> None:
+    """Check dependency identities shared by release and contributor locks."""
+
+    release = _load_toml(root / "dependencies" / "release-lock.toml")
+    contributor = _load_toml(root / "dependencies" / "contributor-lock.toml")
+    try:
+        values = {
+            "release [abis]": _required_string(
+                release["abis"]["symbolica_serialization"],
+                "release-lock [abis].symbolica_serialization",
+            ),
+            "release [symbolica]": _required_string(
+                release["symbolica"]["serialization_abi"],
+                "release-lock [symbolica].serialization_abi",
+            ),
+            "contributor [abis]": _required_string(
+                contributor["abis"]["symbolica_serialization"],
+                "contributor-lock [abis].symbolica_serialization",
+            ),
+        }
+    except (KeyError, TypeError) as error:
+        raise RuntimeError(
+            "dependency lock compatibility contract is incomplete"
+        ) from error
+    if len(set(values.values())) != 1:
+        rendered = ", ".join(f"{name}={value!r}" for name, value in values.items())
+        raise RuntimeError(
+            "release and contributor dependency locks disagree on the Symbolica "
+            f"serialization ABI: {rendered}"
+        )
+
+    try:
+        plane_values = {
+            "release [abis]": _required_string(
+                release["abis"]["symjit_plane_application"],
+                "release-lock [abis].symjit_plane_application",
+            ),
+            "contributor [abis]": _required_string(
+                contributor["abis"]["symjit_plane_application"],
+                "contributor-lock [abis].symjit_plane_application",
+            ),
+        }
+    except (KeyError, TypeError) as error:
+        raise RuntimeError(
+            "dependency lock compatibility contract is incomplete"
+        ) from error
+    if len(set(plane_values.values())) != 1:
+        rendered = ", ".join(
+            f"{name}={value!r}" for name, value in plane_values.items()
+        )
+        raise RuntimeError(
+            "release and contributor dependency locks disagree on the SymJIT "
+            f"plane-application ABI: {rendered}"
+        )
diff --git a/pyamplicol/build_backend/prepared_models.py b/pyamplicol/build_backend/prepared_models.py
new file mode 100644
index 0000000000..a3b2e207f0
--- /dev/null
+++ b/pyamplicol/build_backend/prepared_models.py
@@ -0,0 +1,891 @@
+# SPDX-License-Identifier: 0BSD
+"""Validate source-owned prepared models before wheel staging."""
+
+from __future__ import annotations
+
+import ast
+import hashlib
+import importlib.util
+import json
+import os
+import shutil
+import sys
+import tomllib
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from types import ModuleType
+from typing import Any, cast
+
+_ASSET_DIRECTORY = Path("src/pyamplicol/assets/prepared_models")
+_RELEASE_STORE_CONTAINER = Path("release_assets")
+_RELEASE_STORE_DIRECTORY = _RELEASE_STORE_CONTAINER / "prepared_models"
+_EXPECTED_ARCHITECTURES = ("aarch64", "x86_64")
+_METADATA_KEYS = frozenset(
+    {
+        "backend",
+        "bundle",
+        "bundle_sha256",
+        "bundle_size",
+        "build_contract",
+        "dependencies",
+        "eager_kernel_abi",
+        "id",
+        "jit_optimization_level",
+        "kernel_count",
+        "model",
+        "prepared_model_bundle_schema",
+        "producer",
+        "schema_version",
+        "target",
+    }
+)
+_PRODUCER_KEYS = frozenset(
+    {
+        "compiled_model_schema",
+        "model_compiler_sha256",
+        "model_compiler_version",
+        "model_source_digest",
+        "package_version",
+    }
+)
+_DEFAULT_ID = "built-in-sm-jit-o2"
+_MODEL_SOURCE_BY_ID = {
+    _DEFAULT_ID: "built-in-sm",
+    "built-in-sm-heft-jit-o2": "built-in-sm-heft",
+}
+
+
+def _asset_names(identifier: str, architecture: str) -> tuple[str, str]:
+    stem = f"{identifier}-{architecture}"
+    return f"{stem}.metadata.json", f"{stem}.pyamplicol-model"
+
+
+_EXPECTED_FILES = frozenset(
+    (
+        "__init__.py",
+        *(
+            name
+            for identifier in _MODEL_SOURCE_BY_ID
+            for architecture in _EXPECTED_ARCHITECTURES
+            for name in _asset_names(identifier, architecture)
+        ),
+    )
+)
+_PROJECTED_RELEASE_STORE_FILES = _EXPECTED_FILES - {"__init__.py"}
+_EXPECTED_RELEASE_STORE_FILES = _PROJECTED_RELEASE_STORE_FILES | {"README.md"}
+
+
+def project_release_packaged_prepared_model_store(
+    overlay: Path,
+    *,
+    require_store: bool,
+) -> bool:
+    """Project source-owned release packs over candidate package assets."""
+
+    container = overlay / _RELEASE_STORE_CONTAINER
+    store = overlay / _RELEASE_STORE_DIRECTORY
+    if not os.path.lexists(container):
+        if require_store:
+            raise RuntimeError(
+                "release prepared-model source store is missing; generate and "
+                "commit both architecture pairs before building release artifacts"
+            )
+        return False
+    if container.is_symlink() or not container.is_dir():
+        raise RuntimeError("release prepared-model store container is unsafe")
+    container_entries = {path.name for path in container.iterdir()}
+    if container_entries != {"prepared_models"}:
+        raise RuntimeError(
+            "release prepared-model store container inventory is invalid"
+        )
+    if not store.is_dir() or store.is_symlink():
+        raise RuntimeError("release prepared-model source store is missing or unsafe")
+    store_entries = tuple(store.iterdir())
+    actual_files = {path.name for path in store_entries}
+    if actual_files != _EXPECTED_RELEASE_STORE_FILES:
+        missing = sorted(_EXPECTED_RELEASE_STORE_FILES - actual_files)
+        unexpected = sorted(actual_files - _EXPECTED_RELEASE_STORE_FILES)
+        details: list[str] = []
+        if missing:
+            details.append("missing: " + ", ".join(missing))
+        if unexpected:
+            details.append("unexpected: " + ", ".join(unexpected))
+        raise RuntimeError(
+            "release prepared-model source store inventory is invalid ("
+            + "; ".join(details)
+            + ")"
+        )
+    if any(path.is_symlink() or not path.is_file() for path in store_entries):
+        raise RuntimeError(
+            "release prepared-model source store entries must be regular files"
+        )
+    readme = store / "README.md"
+    if not readme.is_file() or readme.is_symlink():
+        raise RuntimeError("release prepared-model store README is unsafe")
+
+    package_assets = overlay / _ASSET_DIRECTORY
+    if not package_assets.is_dir() or package_assets.is_symlink():
+        raise RuntimeError("candidate prepared-model package assets are missing")
+    package_entries = tuple(package_assets.iterdir())
+    if {path.name for path in package_entries} != _EXPECTED_FILES:
+        raise RuntimeError(
+            "candidate prepared-model package asset inventory is invalid"
+        )
+    if any(path.is_symlink() or not path.is_file() for path in package_entries):
+        raise RuntimeError(
+            "candidate prepared-model package assets must be regular files"
+        )
+    for name in sorted(_PROJECTED_RELEASE_STORE_FILES):
+        shutil.copy2(store / name, package_assets / name)
+    shutil.rmtree(container)
+    return True
+
+
+def discard_release_packaged_prepared_model_store(overlay: Path) -> None:
+    """Remove the auxiliary store from a candidate or bootstrap overlay."""
+
+    container = overlay / _RELEASE_STORE_CONTAINER
+    if not os.path.lexists(container):
+        return
+    if container.is_symlink() or not container.is_dir():
+        raise RuntimeError("release prepared-model store container is unsafe")
+    shutil.rmtree(container)
+
+
+def stage_packaged_prepared_models(
+    overlay: Path,
+    mode: str,
+    *,
+    source_root: Path | None = None,
+) -> None:
+    """Fail closed unless the wheel-owned prepared model matches the overlay."""
+
+    if mode not in {"candidate", "release"}:
+        raise RuntimeError(f"unsupported prepared-model build mode: {mode}")
+    package_root = overlay / "src" / "pyamplicol"
+    asset_root = overlay / _ASSET_DIRECTORY
+    if not asset_root.is_dir() or asset_root.is_symlink():
+        raise RuntimeError("wheel build input has no packaged prepared-model assets")
+    actual_files = {path.name for path in asset_root.iterdir()}
+    unsafe = [path for path in asset_root.iterdir() if path.is_symlink()]
+    if unsafe:
+        raise RuntimeError(
+            "packaged prepared-model assets may not be symlinks: "
+            + ", ".join(str(path) for path in sorted(unsafe))
+        )
+    if actual_files != _EXPECTED_FILES:
+        missing = sorted(_EXPECTED_FILES - actual_files)
+        unexpected = sorted(actual_files - _EXPECTED_FILES)
+        details: list[str] = []
+        if missing:
+            details.append("missing: " + ", ".join(missing))
+        if unexpected:
+            details.append("unexpected: " + ", ".join(unexpected))
+        raise RuntimeError(
+            "packaged prepared-model asset set is invalid (" + "; ".join(details) + ")"
+        )
+
+    contract = _load_prepared_contract(package_root / "models" / "prepared.py")
+    for identifier, model_source in _MODEL_SOURCE_BY_ID.items():
+        for architecture in _EXPECTED_ARCHITECTURES:
+            metadata_name, expected_bundle_name = _asset_names(identifier, architecture)
+            metadata = _load_json(
+                asset_root / metadata_name,
+                f"{identifier} {architecture} prepared-model metadata",
+            )
+            _require_exact_keys(metadata, _METADATA_KEYS, "prepared-model metadata")
+            if metadata.get("schema_version") != 1:
+                raise RuntimeError(
+                    "unsupported packaged prepared-model metadata schema"
+                )
+            if (
+                metadata.get("id") != identifier
+                or metadata.get("model") != model_source
+            ):
+                raise RuntimeError("packaged prepared-model identity is invalid")
+            bundle_name = _required_string(metadata.get("bundle"), "metadata.bundle")
+            if bundle_name != expected_bundle_name:
+                raise RuntimeError("packaged prepared-model bundle name is invalid")
+            bundle_path = asset_root / bundle_name
+            if not bundle_path.is_file() or bundle_path.is_symlink():
+                raise RuntimeError(
+                    "packaged prepared-model bundle must be a regular file"
+                )
+            bundle_bytes = bundle_path.read_bytes()
+            if metadata.get("bundle_size") != len(bundle_bytes):
+                raise RuntimeError(
+                    "packaged prepared-model bundle size does not match metadata"
+                )
+            if (
+                metadata.get("bundle_sha256")
+                != hashlib.sha256(bundle_bytes).hexdigest()
+            ):
+                raise RuntimeError(
+                    "packaged prepared-model bundle SHA-256 does not match metadata"
+                )
+            try:
+                bundle = contract.load_prepared_model_bundle(bundle_path)
+            except Exception as error:
+                raise RuntimeError(
+                    f"packaged prepared-model bundle is invalid: {error}"
+                ) from error
+            _validate_bundle(
+                bundle,
+                metadata=metadata,
+                identifier=identifier,
+                model_source=model_source,
+                expected_target={
+                    "portable": True,
+                    "word_bits": 64,
+                    "endianness": "little",
+                    "target_triple": "symjit-storage-v3-portable",
+                    "cpu_features": [],
+                },
+                package_root=package_root,
+                overlay=overlay,
+                mode=mode,
+            )
+
+
+def write_candidate_packaged_prepared_model_asset(
+    overlay: Path,
+    bundle_path: Path,
+    output_directory: Path,
+    *,
+    architecture: str,
+    identifier: str = _DEFAULT_ID,
+) -> tuple[Path, Path]:
+    """Write one candidate source-ready architecture pack."""
+
+    return _write_packaged_prepared_model_asset(
+        overlay,
+        bundle_path,
+        output_directory,
+        architecture=architecture,
+        identifier=identifier,
+        mode="candidate",
+    )
+
+
+def write_release_packaged_prepared_model_asset(
+    overlay: Path,
+    bundle_path: Path,
+    output_directory: Path,
+    *,
+    architecture: str,
+    identifier: str = _DEFAULT_ID,
+) -> tuple[Path, Path]:
+    """Write one release source-ready architecture pack."""
+
+    return _write_packaged_prepared_model_asset(
+        overlay,
+        bundle_path,
+        output_directory,
+        architecture=architecture,
+        identifier=identifier,
+        mode="release",
+    )
+
+
+def _write_packaged_prepared_model_asset(
+    overlay: Path,
+    bundle_path: Path,
+    output_directory: Path,
+    *,
+    architecture: str,
+    identifier: str,
+    mode: str,
+) -> tuple[Path, Path]:
+    """Write one source-ready architecture pack and its derived metadata."""
+
+    if mode not in {"candidate", "release"}:
+        raise RuntimeError(f"unsupported prepared-model build mode: {mode}")
+    if architecture not in _EXPECTED_ARCHITECTURES:
+        raise RuntimeError(f"unsupported prepared-model architecture: {architecture}")
+    try:
+        model_source = _MODEL_SOURCE_BY_ID[identifier]
+    except KeyError as error:
+        choices = ", ".join(_MODEL_SOURCE_BY_ID)
+        raise RuntimeError(
+            f"unsupported packaged prepared-model identifier {identifier!r}; "
+            f"available: {choices}"
+        ) from error
+    package_root = overlay / "src" / "pyamplicol"
+    release_path = overlay / "dependencies" / "release-lock.toml"
+    with release_path.open("rb") as stream:
+        release = tomllib.load(stream)
+    contributor: Mapping[str, Any] | None = None
+    if mode == "candidate":
+        contributor_path = overlay / "dependencies" / "contributor-lock.toml"
+        with contributor_path.open("rb") as stream:
+            contributor = tomllib.load(stream)
+
+    contract = _load_prepared_contract(package_root / "models" / "prepared.py")
+    source_bundle = bundle_path.resolve(strict=True)
+    bundle_bytes = source_bundle.read_bytes()
+    try:
+        bundle = contract.load_prepared_model_bundle(source_bundle)
+    except Exception as error:
+        raise RuntimeError(f"prepared-model bundle is invalid: {error}") from error
+    pack = bundle.kernel_pack
+    expected_target = {
+        "portable": True,
+        "word_bits": 64,
+        "endianness": "little",
+        "target_triple": "symjit-storage-v3-portable",
+        "cpu_features": [],
+    }
+    if _plain_json(pack.target) != expected_target:
+        raise RuntimeError("prepared-model bundle target does not match architecture")
+    if bundle.backend != "jit" or pack.backend != "jit":
+        raise RuntimeError("packaged built-in prepared model must use JIT")
+    optimization = dict(pack.optimization_settings)
+    if optimization.get("jit_optimization_level") != 2:
+        raise RuntimeError("packaged built-in prepared model must use portable JIT O2")
+
+    compiled = dict(bundle.compiled_model)
+    compiled_producer = _mapping(compiled.get("producer"), "compiled_model.producer")
+    compiled_source = _mapping(compiled.get("source"), "compiled_model.source")
+    package_version = _required_string(
+        compiled_producer.get("pyamplicol"), "compiled_model producer version"
+    )
+    candidate_fingerprint: str | None = None
+    if mode == "candidate":
+        marker = "+candidate."
+        if marker not in package_version:
+            raise RuntimeError(
+                "source-ready prepared assets require a candidate bundle"
+            )
+        candidate_fingerprint = package_version.rsplit(marker, maxsplit=1)[1]
+        if len(candidate_fingerprint) != 12 or any(
+            character not in "0123456789abcdef" for character in candidate_fingerprint
+        ):
+            raise RuntimeError("prepared bundle has an invalid candidate fingerprint")
+    else:
+        release_version = _release_package_version(overlay, release)
+        if package_version != release_version:
+            raise RuntimeError(
+                "release prepared assets require the canonical package version "
+                f"{release_version!r}"
+            )
+    if pack.producer.get("version") != package_version:
+        raise RuntimeError("prepared kernel-pack package version is inconsistent")
+
+    compiled_schema = _literal_assignment(
+        package_root / "_internal" / "versions.py",
+        "COMPILED_MODEL_SCHEMA_VERSION",
+    )
+    model_compiler_version = _literal_assignment(
+        package_root / "models" / "loading.py", "MODEL_COMPILER_VERSION"
+    )
+    model_compiler_digest = _required_sha256(
+        compiled_producer.get("model_compiler_sha256"),
+        "compiled_model producer model_compiler_sha256",
+    )
+    source_digest = _built_in_source_digest(package_root, model_source)
+    expected_compiled = {
+        "compiled_model_schema_version": compiled_schema,
+        "model_compiler_version": model_compiler_version,
+    }
+    for key, expected in expected_compiled.items():
+        if compiled_producer.get(key) != expected:
+            raise RuntimeError(f"prepared compiled-model producer {key} is stale")
+    if compiled_source.get("kind") != model_source:
+        raise RuntimeError(f"prepared bundle does not contain the {model_source} model")
+    if compiled_source.get("digest") != source_digest:
+        raise RuntimeError("prepared bundle built-in model source digest is stale")
+    if pack.provenance.get("compiled_model_digest") != source_digest:
+        raise RuntimeError("prepared kernel-pack model source digest is stale")
+    pack_model_source = _mapping(
+        pack.provenance.get("model_source"),
+        "kernel_pack.provenance.model_source",
+    )
+    if (
+        pack_model_source.get("kind") != model_source
+        or pack_model_source.get("digest") != source_digest
+    ):
+        raise RuntimeError("prepared kernel-pack model source identity is stale")
+
+    if mode == "candidate":
+        assert contributor is not None
+        symbolica_version = str(contributor["symbolica"]["candidate_version"])
+        symjit_version = str(contributor["symjit"]["candidate_version"])
+    else:
+        symbolica_version = _cargo_package_version(overlay, "symbolica")
+        symjit_version = _symjit_version(overlay)
+    dependencies = {
+        "symbolica_serialization_abi": _literal_assignment(
+            package_root / "_internal" / "versions.py",
+            "SYMBOLICA_SERIALIZATION_ABI",
+        ),
+        "symbolica_version": symbolica_version,
+        "symjit_application_abi": _literal_assignment(
+            package_root / "_internal" / "versions.py",
+            "SYMJIT_APPLICATION_ABI",
+        ),
+        "symjit_plane_application_abi": _literal_assignment(
+            package_root / "_internal" / "versions.py",
+            "SYMJIT_PLANE_APPLICATION_ABI",
+        ),
+        "symjit_version": symjit_version,
+        "ufo_model_loader_version": release["ufo_model_loader"]["required_version"],
+    }
+    expected_pack_dependencies = {
+        "symbolica_serialization": dependencies["symbolica_serialization_abi"],
+        "symbolica_version": dependencies["symbolica_version"],
+        "symjit_application": dependencies["symjit_application_abi"],
+        "symjit_plane_application": dependencies["symjit_plane_application_abi"],
+    }
+    for key, expected in expected_pack_dependencies.items():
+        if pack.dependency_abis.get(key) != expected:
+            raise RuntimeError(f"prepared kernel-pack dependency {key} is stale")
+
+    metadata_name, bundle_name = _asset_names(identifier, architecture)
+    metadata: dict[str, object] = {
+        "backend": "jit",
+        "build_contract": {"mode": mode},
+        "bundle": bundle_name,
+        "bundle_sha256": hashlib.sha256(bundle_bytes).hexdigest(),
+        "bundle_size": len(bundle_bytes),
+        "dependencies": dependencies,
+        "eager_kernel_abi": _literal_assignment(
+            package_root / "models" / "prepared.py", "EAGER_KERNEL_ABI"
+        ),
+        "id": identifier,
+        "jit_optimization_level": 2,
+        "kernel_count": len(pack.kernels),
+        "model": model_source,
+        "prepared_model_bundle_schema": _literal_assignment(
+            package_root / "models" / "prepared.py",
+            "PREPARED_MODEL_BUNDLE_SCHEMA_VERSION",
+        ),
+        "producer": {
+            "compiled_model_schema": compiled_schema,
+            "model_compiler_sha256": model_compiler_digest,
+            "model_compiler_version": model_compiler_version,
+            "model_source_digest": source_digest,
+            "package_version": package_version,
+        },
+        "schema_version": 1,
+        "target": expected_target,
+    }
+
+    destination = output_directory.resolve(strict=False)
+    destination.mkdir(parents=True, exist_ok=True)
+    output_bundle = destination / bundle_name
+    output_metadata = destination / metadata_name
+    for path in (output_bundle, output_metadata):
+        if path.exists():
+            raise RuntimeError(f"source-ready prepared asset already exists: {path}")
+    temporary_bundle = output_bundle.with_name(f".{output_bundle.name}.tmp")
+    temporary_metadata = output_metadata.with_name(f".{output_metadata.name}.tmp")
+    temporary_bundle.write_bytes(bundle_bytes)
+    temporary_metadata.write_text(
+        json.dumps(metadata, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    temporary_bundle.replace(output_bundle)
+    temporary_metadata.replace(output_metadata)
+    return output_metadata, output_bundle
+
+
+def _validate_bundle(
+    bundle: Any,
+    *,
+    metadata: Mapping[str, object],
+    identifier: str,
+    model_source: str,
+    expected_target: Mapping[str, object],
+    package_root: Path,
+    overlay: Path,
+    mode: str,
+) -> None:
+    pack = bundle.kernel_pack
+    if bundle.backend != "jit" or metadata.get("backend") != "jit":
+        raise RuntimeError("packaged built-in prepared model must use the JIT backend")
+    if metadata.get("jit_optimization_level") != 2:
+        raise RuntimeError("packaged built-in prepared model must use portable JIT O2")
+    optimization = dict(pack.optimization_settings)
+    if (
+        optimization.get("backend") != "jit"
+        or optimization.get("jit_optimization_level") != 2
+    ):
+        raise RuntimeError(
+            "prepared kernel pack does not record portable JIT O2 settings"
+        )
+    target = _plain_json(pack.target)
+    if target != expected_target or metadata.get("target") != expected_target:
+        raise RuntimeError(
+            "packaged prepared model target does not match its architecture asset"
+        )
+    kernel_count = len(pack.kernels)
+    if metadata.get("kernel_count") != kernel_count or kernel_count == 0:
+        raise RuntimeError("packaged prepared-model kernel count is invalid")
+
+    eager_abi = _literal_assignment(
+        package_root / "models" / "prepared.py", "EAGER_KERNEL_ABI"
+    )
+    bundle_schema = _literal_assignment(
+        package_root / "models" / "prepared.py",
+        "PREPARED_MODEL_BUNDLE_SCHEMA_VERSION",
+    )
+    if metadata.get("eager_kernel_abi") != eager_abi:
+        raise RuntimeError("packaged prepared-model eager kernel ABI is stale")
+    if metadata.get("prepared_model_bundle_schema") != bundle_schema:
+        raise RuntimeError("packaged prepared-model container schema is stale")
+    if bundle.manifest.get("eager_kernel_abi") != eager_abi:
+        raise RuntimeError("prepared bundle declares an incompatible eager kernel ABI")
+    if bundle.manifest.get("schema_version") != bundle_schema:
+        raise RuntimeError("prepared bundle declares an incompatible container schema")
+
+    build_contract = _mapping(metadata.get("build_contract"), "metadata.build_contract")
+    _require_exact_keys(
+        build_contract,
+        frozenset({"mode"}),
+        "metadata.build_contract",
+    )
+    if build_contract.get("mode") != mode:
+        raise RuntimeError(
+            "packaged prepared model was built for "
+            f"{build_contract.get('mode')!r}, not the active {mode!r} dependency mode; "
+            "regenerate it with the active exact dependency lock"
+        )
+    compiled = dict(bundle.compiled_model)
+    producer = _mapping(compiled.get("producer"), "compiled_model.producer")
+    source = _mapping(compiled.get("source"), "compiled_model.source")
+    model = _mapping(compiled.get("model"), "compiled_model.model")
+    if model.get("name") != model_source or source.get("kind") != model_source:
+        raise RuntimeError(
+            f"packaged prepared model does not contain the {model_source} model"
+        )
+    if metadata.get("id") != identifier or metadata.get("model") != model_source:
+        raise RuntimeError("packaged prepared-model identity is invalid")
+
+    compiled_schema = _literal_assignment(
+        package_root / "_internal" / "versions.py",
+        "COMPILED_MODEL_SCHEMA_VERSION",
+    )
+    compiler_version = _literal_assignment(
+        package_root / "models" / "loading.py", "MODEL_COMPILER_VERSION"
+    )
+    packaged_producer = _mapping(metadata.get("producer"), "metadata.producer")
+    _require_exact_keys(
+        packaged_producer,
+        _PRODUCER_KEYS,
+        "metadata.producer",
+    )
+    model_source_digest = _built_in_source_digest(package_root, model_source)
+    # The producer source digest remains useful provenance, but it is not a
+    # compatibility boundary. Explicit schema and compiler versions carry
+    # that contract without forcing pack regeneration after harmless edits.
+    expected_producer = {
+        "compiled_model_schema": compiled_schema,
+        "model_compiler_version": compiler_version,
+        "model_source_digest": model_source_digest,
+    }
+    for key, expected in expected_producer.items():
+        if packaged_producer.get(key) != expected:
+            raise RuntimeError(
+                f"packaged prepared-model producer {key} is stale: "
+                f"expected {expected!r}, got {packaged_producer.get(key)!r}"
+            )
+    packaged_package_version = _required_string(
+        packaged_producer.get("package_version"),
+        "packaged prepared-model producer package_version",
+    )
+    if producer.get("compiled_model_schema_version") != compiled_schema:
+        raise RuntimeError("prepared compiled-model schema is stale")
+    if producer.get("model_compiler_version") != compiler_version:
+        raise RuntimeError("prepared model compiler version is stale")
+    if producer.get("pyamplicol") != packaged_package_version:
+        raise RuntimeError(
+            "prepared compiled-model package version disagrees with metadata"
+        )
+    if source.get("digest") != model_source_digest:
+        raise RuntimeError("prepared compiled-model source digest is stale")
+    if pack.producer.get("version") != packaged_package_version:
+        raise RuntimeError(
+            "prepared kernel-pack package version disagrees with metadata"
+        )
+    if pack.producer.get("compiled_model_schema") != compiled_schema:
+        raise RuntimeError("prepared kernel-pack compiled-model schema is stale")
+    if pack.producer.get("model_compiler_version") != compiler_version:
+        raise RuntimeError("prepared kernel-pack model compiler version is stale")
+    if pack.provenance.get("model_name") != model_source:
+        raise RuntimeError("prepared kernel-pack model provenance is invalid")
+    if pack.provenance.get("compiled_model_digest") != model_source_digest:
+        raise RuntimeError("prepared kernel-pack compiled-model digest is stale")
+    pack_model_source = _mapping(
+        pack.provenance.get("model_source"),
+        "kernel_pack.provenance.model_source",
+    )
+    if (
+        pack_model_source.get("kind") != model_source
+        or pack_model_source.get("digest") != model_source_digest
+    ):
+        raise RuntimeError("prepared kernel-pack model source identity is stale")
+
+    dependencies = _mapping(metadata.get("dependencies"), "metadata.dependencies")
+    _validate_dependency_contract(
+        dependencies,
+        pack_dependency_abis=pack.dependency_abis,
+        package_root=package_root,
+        overlay=overlay,
+        mode=mode,
+    )
+    for kernel in pack.kernels:
+        manifest = kernel.f64_evaluator_manifest
+        expected = {
+            "kind": "symjit-application-evaluator",
+            "backend": "jit",
+            "runtime_capability": "symjit.application.complex-f64.v1",
+            "application_abi": dependencies["symjit_application_abi"],
+            "compiler_type": "native",
+            "translation_mode": "indirect",
+            "optimization_level": 2,
+            "word_bits": 64,
+            "endianness": "little",
+            "required_defuns": (),
+        }
+        for key, expected_value in expected.items():
+            actual = manifest.get(key)
+            if key == "required_defuns" and isinstance(actual, Sequence):
+                actual = tuple(actual)
+            if actual != expected_value:
+                raise RuntimeError(
+                    f"prepared kernel {kernel.kernel_id} has incompatible {key}: "
+                    f"expected {expected_value!r}, got {actual!r}"
+                )
+
+
+def _validate_dependency_contract(
+    dependencies: Mapping[str, object],
+    *,
+    pack_dependency_abis: Mapping[str, object],
+    package_root: Path,
+    overlay: Path,
+    mode: str,
+) -> None:
+    with (overlay / "dependencies" / "release-lock.toml").open("rb") as stream:
+        release = tomllib.load(stream)
+    symbolica_version = release["symbolica"]["python_version"]
+    if mode == "candidate":
+        symbolica_version = _cargo_package_version(overlay, "symbolica")
+    expected = {
+        "symbolica_version": symbolica_version,
+        "ufo_model_loader_version": release["ufo_model_loader"]["required_version"],
+        "symjit_version": _symjit_version(overlay),
+        "symbolica_serialization_abi": _literal_assignment(
+            package_root / "_internal" / "versions.py",
+            "SYMBOLICA_SERIALIZATION_ABI",
+        ),
+        "symjit_application_abi": _literal_assignment(
+            package_root / "_internal" / "versions.py",
+            "SYMJIT_APPLICATION_ABI",
+        ),
+        "symjit_plane_application_abi": _literal_assignment(
+            package_root / "_internal" / "versions.py",
+            "SYMJIT_PLANE_APPLICATION_ABI",
+        ),
+    }
+    for key, value in expected.items():
+        if dependencies.get(key) != value:
+            raise RuntimeError(
+                f"packaged prepared-model dependency {key} is stale: "
+                f"expected {value!r}, got {dependencies.get(key)!r}"
+            )
+    pack_expected = {
+        "symbolica_version": expected["symbolica_version"],
+        "symbolica_serialization": expected["symbolica_serialization_abi"],
+        "symjit_application": expected["symjit_application_abi"],
+        "symjit_plane_application": expected["symjit_plane_application_abi"],
+    }
+    for key, value in pack_expected.items():
+        if pack_dependency_abis.get(key) != value:
+            raise RuntimeError(f"prepared kernel-pack dependency ABI {key} is stale")
+
+
+def _symjit_version(overlay: Path) -> str:
+    return _cargo_package_version(overlay, "symjit")
+
+
+def _release_package_version(
+    overlay: Path, release: Mapping[str, Any] | None = None
+) -> str:
+    if release is None:
+        with (overlay / "dependencies" / "release-lock.toml").open("rb") as stream:
+            release = tomllib.load(stream)
+    with (overlay / "Cargo.toml").open("rb") as stream:
+        cargo = tomllib.load(stream)
+    cargo_version = _required_string(
+        cargo["workspace"]["package"]["version"], "Cargo package version"
+    )
+    locked_version = _required_string(
+        release["project"]["version"], "release-lock project version"
+    )
+    if cargo_version != locked_version:
+        raise RuntimeError(
+            "release package version differs between Cargo.toml and release-lock.toml"
+        )
+    return cargo_version
+
+
+def _cargo_package_version(overlay: Path, package_name: str) -> str:
+    with (overlay / "Cargo.lock").open("rb") as stream:
+        cargo_lock = tomllib.load(stream)
+    packages = cargo_lock.get("package")
+    if not isinstance(packages, list):
+        raise RuntimeError("Cargo.lock has no package array")
+    matches = [
+        package.get("version")
+        for package in packages
+        if isinstance(package, dict) and package.get("name") == package_name
+    ]
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"Cargo.lock must contain exactly one {package_name} package"
+        )
+    return _required_string(matches[0], f"Cargo.lock {package_name} version")
+
+
+def _built_in_source_digest(
+    package_root: Path,
+    model_source: str = "built-in-sm",
+) -> str:
+    if model_source == "built-in-sm-heft":
+        return _sm_heft_source_digest(package_root)
+    if model_source != "built-in-sm":
+        raise RuntimeError(f"unsupported built-in model source {model_source!r}")
+    implementation = hashlib.sha256()
+    for path in sorted((package_root / "models" / "builtin").glob("*.py")):
+        implementation.update(path.name.encode("utf-8") + b"\0")
+        implementation.update(path.read_bytes())
+        implementation.update(b"\0")
+    digest = hashlib.sha256()
+    digest.update(b"built-in-sm\0")
+    digest.update(implementation.hexdigest().encode("ascii"))
+    return digest.hexdigest()
+
+
+def _sm_heft_source_digest(package_root: Path) -> str:
+    path = package_root / "_internal" / "sm_heft.py"
+    module_name = "_pyamplicol_build_sm_heft_source"
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"cannot load built-in scalar HEFT source from {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    try:
+        spec.loader.exec_module(module)
+        digest = module.source_digest()
+    finally:
+        sys.modules.pop(module_name, None)
+    return _required_sha256(digest, "built-in scalar HEFT source digest")
+
+
+def _literal_assignment(path: Path, name: str) -> str | int:
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    for node in tree.body:
+        if not isinstance(node, (ast.Assign, ast.AnnAssign)):
+            continue
+        targets = node.targets if isinstance(node, ast.Assign) else (node.target,)
+        if not any(
+            isinstance(target, ast.Name) and target.id == name for target in targets
+        ):
+            continue
+        value = ast.literal_eval(node.value)
+        if isinstance(value, bool) or not isinstance(value, (str, int)):
+            break
+        return value
+    raise RuntimeError(f"could not read literal {name} from {path}")
+
+
+def _load_prepared_contract(path: Path) -> ModuleType:
+    digest = hashlib.sha256(str(path).encode("utf-8")).hexdigest()[:16]
+    package_name = f"_pyamplicol_build_prepared_contract_{digest}"
+    models_package_name = f"{package_name}.models"
+    module_name = f"{models_package_name}.prepared"
+    package = ModuleType(package_name)
+    package.__package__ = package_name
+    package.__path__ = [str(path.parent.parent)]  # type: ignore[attr-defined]
+    models_package = ModuleType(models_package_name)
+    models_package.__package__ = models_package_name
+    models_package.__path__ = [str(path.parent)]  # type: ignore[attr-defined]
+    sys.modules[package_name] = package
+    sys.modules[models_package_name] = models_package
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    if spec is None or spec.loader is None:
+        sys.modules.pop(package_name, None)
+        raise RuntimeError(f"cannot load prepared-model contract from {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    try:
+        spec.loader.exec_module(module)
+    except Exception:
+        for name in tuple(sys.modules):
+            if name == package_name or name.startswith(f"{package_name}."):
+                sys.modules.pop(name, None)
+        raise
+    return module
+
+
+def _load_json(path: Path, context: str) -> dict[str, object]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise RuntimeError(f"cannot read {context} {path}: {error}") from error
+    if not isinstance(value, dict) or not all(isinstance(key, str) for key in value):
+        raise RuntimeError(f"{context} must be a JSON object")
+    return cast(dict[str, object], value)
+
+
+def _mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):
+        raise RuntimeError(f"{context} must be an object")
+    return cast(Mapping[str, object], value)
+
+
+def _required_string(value: object, context: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise RuntimeError(f"{context} must be a nonempty string")
+    return value
+
+
+def _required_sha256(value: object, context: str) -> str:
+    digest = _required_string(value, context)
+    if len(digest) != 64 or any(
+        character not in "0123456789abcdef" for character in digest
+    ):
+        raise RuntimeError(f"{context} must be a SHA-256 digest")
+    return digest
+
+
+def _require_exact_keys(
+    value: Mapping[str, object], expected: frozenset[str], context: str
+) -> None:
+    missing = expected - value.keys()
+    unknown = value.keys() - expected
+    if missing or unknown:
+        details: list[str] = []
+        if missing:
+            details.append("missing: " + ", ".join(sorted(missing)))
+        if unknown:
+            details.append("unknown: " + ", ".join(sorted(unknown)))
+        raise RuntimeError(f"{context} fields are invalid ({'; '.join(details)})")
+
+
+def _plain_json(value: object) -> object:
+    if isinstance(value, Mapping):
+        return {str(key): _plain_json(item) for key, item in value.items()}
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return [_plain_json(item) for item in value]
+    return value
+
+
+__all__ = [
+    "discard_release_packaged_prepared_model_store",
+    "project_release_packaged_prepared_model_store",
+    "stage_packaged_prepared_models",
+    "write_candidate_packaged_prepared_model_asset",
+    "write_release_packaged_prepared_model_asset",
+]
diff --git a/pyamplicol/build_backend/python_lock.py b/pyamplicol/build_backend/python_lock.py
new file mode 100644
index 0000000000..7d4de5d020
--- /dev/null
+++ b/pyamplicol/build_backend/python_lock.py
@@ -0,0 +1,194 @@
+# SPDX-License-Identifier: 0BSD
+"""Typed parser for the immutable Python runtime artifact lock."""
+
+from __future__ import annotations
+
+import re
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+_SHA256 = re.compile(r"[0-9a-f]{64}")
+_CANONICAL_NAME = re.compile(r"[-_.]+")
+
+
+def canonicalize_name(value: str) -> str:
+    """Return the normalized distribution name used by package indexes."""
+
+    return _CANONICAL_NAME.sub("-", value).lower()
+
+
+@dataclass(frozen=True, slots=True)
+class PythonArtifact:
+    """One published wheel admitted by the runtime dependency contract."""
+
+    filename: str
+    sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class PythonPackage:
+    """One exact package in the resolved runtime dependency graph."""
+
+    distribution: str
+    version: str
+    license: str
+    direct: bool
+    dependencies: tuple[str, ...]
+    artifacts: tuple[PythonArtifact, ...]
+
+    @property
+    def name(self) -> str:
+        return canonicalize_name(self.distribution)
+
+
+@dataclass(frozen=True, slots=True)
+class PythonRuntimeLock:
+    """Complete Python runtime graph and its admitted binary artifacts."""
+
+    requires_python: str
+    supported_python: tuple[str, ...]
+    packages: tuple[PythonPackage, ...]
+
+    @property
+    def by_name(self) -> dict[str, PythonPackage]:
+        return {package.name: package for package in self.packages}
+
+    @property
+    def direct_packages(self) -> tuple[PythonPackage, ...]:
+        return tuple(package for package in self.packages if package.direct)
+
+
+def _required_string(table: dict[str, object], key: str, context: str) -> str:
+    value = table.get(key)
+    if not isinstance(value, str) or not value:
+        raise ValueError(f"{context} requires a nonempty {key!r} string")
+    return value
+
+
+def _string_list(value: object, context: str) -> tuple[str, ...]:
+    if not isinstance(value, list) or not all(
+        isinstance(item, str) and item for item in value
+    ):
+        raise ValueError(f"{context} must be a list of nonempty strings")
+    result = tuple(value)
+    if len(result) != len(set(result)):
+        raise ValueError(f"{context} contains duplicate entries")
+    return result
+
+
+def _parse_artifacts(raw: object, context: str) -> tuple[PythonArtifact, ...]:
+    if raw is None:
+        return ()
+    if not isinstance(raw, list):
+        raise ValueError(f"{context}.artifacts must be an array of tables")
+    artifacts: list[PythonArtifact] = []
+    for index, item in enumerate(raw):
+        item_context = f"{context}.artifacts[{index}]"
+        if not isinstance(item, dict):
+            raise ValueError(f"{item_context} must be a table")
+        filename = _required_string(item, "filename", item_context)
+        digest = _required_string(item, "sha256", item_context)
+        if filename != Path(filename).name or not filename.endswith(".whl"):
+            raise ValueError(f"{item_context}.filename must be a plain wheel filename")
+        if _SHA256.fullmatch(digest) is None:
+            raise ValueError(f"{item_context}.sha256 must be a lowercase SHA-256")
+        artifacts.append(PythonArtifact(filename=filename, sha256=digest))
+    filenames = [artifact.filename for artifact in artifacts]
+    if filenames != sorted(filenames) or len(filenames) != len(set(filenames)):
+        raise ValueError(f"{context}.artifacts must be unique and filename-sorted")
+    return tuple(artifacts)
+
+
+def load_python_runtime_lock(path: Path) -> PythonRuntimeLock:
+    """Load and structurally validate a schema-v1 Python runtime lock."""
+
+    with path.open("rb") as stream:
+        payload = tomllib.load(stream)
+    if payload.get("schema_version") != 1:
+        raise ValueError(f"{path} must use schema_version = 1")
+    requires_python = _required_string(payload, "requires_python", str(path))
+    supported_python = _string_list(
+        payload.get("supported_python"), f"{path}.supported_python"
+    )
+    if supported_python != tuple(sorted(supported_python)):
+        raise ValueError(f"{path}.supported_python must be sorted")
+    raw_packages = payload.get("packages")
+    if not isinstance(raw_packages, list) or not raw_packages:
+        raise ValueError(f"{path}.packages must be a nonempty array of tables")
+
+    packages: list[PythonPackage] = []
+    for index, item in enumerate(raw_packages):
+        context = f"{path}.packages[{index}]"
+        if not isinstance(item, dict):
+            raise ValueError(f"{context} must be a table")
+        distribution = _required_string(item, "distribution", context)
+        version = _required_string(item, "version", context)
+        license_expression = _required_string(item, "license", context)
+        direct = item.get("direct")
+        if not isinstance(direct, bool):
+            raise ValueError(f"{context}.direct must be a boolean")
+        dependencies = tuple(
+            canonicalize_name(value)
+            for value in _string_list(
+                item.get("dependencies"), f"{context}.dependencies"
+            )
+        )
+        if dependencies != tuple(sorted(dependencies)):
+            raise ValueError(f"{context}.dependencies must be canonical and sorted")
+        package = PythonPackage(
+            distribution=distribution,
+            version=version,
+            license=license_expression,
+            direct=direct,
+            dependencies=dependencies,
+            artifacts=_parse_artifacts(item.get("artifacts"), context),
+        )
+        packages.append(package)
+
+    names = [package.name for package in packages]
+    if names != sorted(names) or len(names) != len(set(names)):
+        raise ValueError(f"{path}.packages must be unique and canonical-name-sorted")
+    by_name = {package.name: package for package in packages}
+    for package in packages:
+        missing = set(package.dependencies) - set(by_name)
+        if missing:
+            raise ValueError(
+                f"{path} package {package.name} references missing dependencies: "
+                f"{sorted(missing)}"
+            )
+        if package.name in package.dependencies:
+            raise ValueError(f"{path} package {package.name} depends on itself")
+
+    reachable: set[str] = set()
+    pending = [package.name for package in packages if package.direct]
+    while pending:
+        name = pending.pop()
+        if name in reachable:
+            continue
+        reachable.add(name)
+        pending.extend(by_name[name].dependencies)
+    if reachable != set(by_name):
+        raise ValueError(
+            f"{path} contains unreachable packages: {sorted(set(by_name) - reachable)}"
+        )
+
+    filenames = [
+        artifact.filename for package in packages for artifact in package.artifacts
+    ]
+    if len(filenames) != len(set(filenames)):
+        raise ValueError(f"{path} repeats a wheel filename across packages")
+    return PythonRuntimeLock(
+        requires_python=requires_python,
+        supported_python=supported_python,
+        packages=tuple(packages),
+    )
+
+
+__all__ = [
+    "PythonArtifact",
+    "PythonPackage",
+    "PythonRuntimeLock",
+    "canonicalize_name",
+    "load_python_runtime_lock",
+]
diff --git a/pyamplicol/build_backend/sdk.py b/pyamplicol/build_backend/sdk.py
new file mode 100644
index 0000000000..7182ed5fbf
--- /dev/null
+++ b/pyamplicol/build_backend/sdk.py
@@ -0,0 +1,569 @@
+# SPDX-License-Identifier: 0BSD
+"""Build, validate, and stage Rusticol's native SDK."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import tempfile
+import tomllib
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from native_build_identity import load_native_build_contract
+
+SDK_SOURCES = (
+    ("rust/crates/rusticol-capi/include/rusticol.h", "include/rusticol.h"),
+    ("rust/crates/rusticol-capi/include/rusticol.hpp", "include/rusticol.hpp"),
+    ("rust/crates/rusticol-capi/fortran/rusticol.f90", "fortran/rusticol.f90"),
+)
+RUST_SDK_SOURCE = "src/pyamplicol/_sdk/rust/rusticol.rs"
+RUST_SDK_WORKSPACE_MEMBER = "rust/crates/rusticol-capi"
+NATIVE_MARKER = "native-static-libs:"
+FORBIDDEN_UNDEFINED_SYMBOL_PREFIXES = (
+    "pyobject",
+    "pyexc_",
+    "pygilstate",
+    "pyerr_",
+    "pylong_",
+    "pyunicode_",
+    "pymem_",
+    "pytype_",
+    "pytuple_",
+    "pylist_",
+    "pydict_",
+    "pymodule_",
+    "pyimport_",
+    "pybytes_",
+    "pycapsule_",
+    "pyfloat_",
+    "pybool_",
+    "pythread_",
+    "py_",
+    "python",
+    "libpython",
+    "pyo3",
+    "numpy",
+)
+FORBIDDEN_BINARY_MARKERS = (
+    b"/opt/homebrew",
+    b"/opt/local",
+    b"/site-packages/",
+    b"/.venv/",
+    b"/venv/",
+    b"PREPARE_STANDALONE_PYAMPLICOL",
+    b"/pyAmpliCol/pyAmpliCol",
+)
+COMMON_LIBRARIES = {
+    "c",
+    "dl",
+    "m",
+    "pthread",
+    "resolv",
+    "rt",
+    "util",
+}
+MACOS_LIBRARIES = COMMON_LIBRARIES | {"System", "gcc_s", "iconv"}
+LINUX_LIBRARIES = COMMON_LIBRARIES | {"gcc_s"}
+MACOS_FRAMEWORKS = {
+    "CoreFoundation",
+    "IOKit",
+    "Security",
+    "SystemConfiguration",
+}
+
+
+def _host_target(root: Path) -> str:
+    completed = subprocess.run(
+        ["rustc", "-vV"],
+        cwd=root,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    for line in completed.stdout.splitlines():
+        if line.startswith("host: "):
+            return line.removeprefix("host: ").strip()
+    raise RuntimeError("rustc -vV did not report a host target")
+
+
+def _requested_target(host: str) -> str:
+    requested = (
+        os.environ.get("CARGO_BUILD_TARGET")
+        or os.environ.get("MATURIN_BUILD_TARGET")
+        or host
+    )
+    if requested != host:
+        raise RuntimeError(
+            "the native SDK bootstrap does not permit cross-target builds: "
+            f"host={host}, requested={requested}"
+        )
+    return requested
+
+
+def _cargo_messages(stdout: str) -> list[dict[str, Any]]:
+    messages: list[dict[str, Any]] = []
+    for line in stdout.splitlines():
+        if not line.strip():
+            continue
+        try:
+            payload = json.loads(line)
+        except json.JSONDecodeError as error:
+            raise RuntimeError(
+                f"cargo emitted non-JSON output before SDK validation: {line}"
+            ) from error
+        if not isinstance(payload, dict):
+            raise RuntimeError("cargo JSON messages must be objects")
+        messages.append(payload)
+    return messages
+
+
+def _cargo_fetch(root: Path, target_dir: Path, target: str) -> None:
+    completed = subprocess.run(
+        ["cargo", "fetch", "--locked", "--target", target],
+        cwd=root,
+        env=dict(os.environ, CARGO_TARGET_DIR=str(target_dir)),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        diagnostics = completed.stderr.strip() or completed.stdout.strip()
+        detail = f"\n{diagnostics}" if diagnostics else ""
+        raise RuntimeError(
+            f"cargo fetch failed with exit code {completed.returncode}{detail}"
+        )
+
+
+def _subprocess_excerpt(*streams: str, lines: int = 120) -> str:
+    output = "\n".join(stream.strip() for stream in streams if stream.strip())
+    if not output:
+        return ""
+    return "\n".join(output.splitlines()[-lines:])
+
+
+def _static_library(messages: list[dict[str, Any]]) -> Path:
+    candidates: list[Path] = []
+    for message in messages:
+        if message.get("reason") != "compiler-artifact":
+            continue
+        target = message.get("target")
+        if not isinstance(target, dict) or target.get("name") != "rusticol_capi":
+            continue
+        for filename in message.get("filenames", []):
+            path = Path(str(filename))
+            if path.suffix in {".a", ".lib"}:
+                candidates.append(path)
+    unique = sorted(set(candidates))
+    if len(unique) != 1:
+        raise RuntimeError(
+            "expected one rusticol-capi static archive, found "
+            + ", ".join(map(str, unique))
+        )
+    return unique[0]
+
+
+def _native_tokens(stderr: str) -> list[str]:
+    matches = [
+        line.split(NATIVE_MARKER, 1)[1].strip()
+        for line in stderr.splitlines()
+        if NATIVE_MARKER in line
+    ]
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"expected one rustc native-static-libs diagnostic, found {len(matches)}"
+        )
+    return shlex.split(matches[0])
+
+
+def _typed_link_arguments(tokens: list[str], target: str) -> dict[str, Any]:
+    libraries = MACOS_LIBRARIES if "apple-darwin" in target else LINUX_LIBRARIES
+    result: dict[str, Any] = {
+        "schema_version": 1,
+        "target": target,
+        "system_libraries": [],
+        "frameworks": [],
+    }
+    index = 0
+    while index < len(tokens):
+        token = tokens[index]
+        if token == "-framework":
+            if "apple-darwin" not in target or index + 1 >= len(tokens):
+                raise RuntimeError(f"invalid native framework token: {token}")
+            framework = tokens[index + 1]
+            if framework not in MACOS_FRAMEWORKS:
+                raise RuntimeError(f"native framework is not allowlisted: {framework}")
+            if framework not in result["frameworks"]:
+                result["frameworks"].append(framework)
+            index += 2
+            continue
+        if token.startswith("-l") and len(token) > 2:
+            library = token[2:]
+            if library not in libraries:
+                raise RuntimeError(
+                    f"native system library is not allowlisted: {library}"
+                )
+            # rustc may repeat native libraries contributed by more than one
+            # crate. Dynamic system libraries do not need repeated linker
+            # entries, so retain their first occurrence and its ordering.
+            if library not in result["system_libraries"]:
+                result["system_libraries"].append(library)
+            index += 1
+            continue
+        if (
+            token.startswith(("-L", "-Wl,"))
+            or "rpath" in token.lower()
+            or Path(token).is_absolute()
+        ):
+            raise RuntimeError(f"non-relocatable native link token: {token}")
+        raise RuntimeError(f"unsupported native link token: {token}")
+    return result
+
+
+def _scan_archive(path: Path) -> None:
+    """Reject embedded host paths that would make the SDK non-relocatable.
+
+    Python linkage is checked authoritatively by the undefined-symbol scan and
+    the standalone C link probe. Searching arbitrary compressed archive bytes
+    for short text such as ``pyo3`` produces ordinary random false positives.
+    """
+
+    archive_bytes = path.read_bytes()
+    lowered_archive = archive_bytes.lower()
+    for binary_marker in FORBIDDEN_BINARY_MARKERS:
+        if binary_marker.lower() in lowered_archive:
+            raise RuntimeError(
+                "Rusticol static archive embeds a non-relocatable path marker: "
+                f"{binary_marker.decode(errors='replace')}"
+            )
+
+
+def _scan_archive_symbols(path: Path) -> bool:
+    """Inspect undefined symbols when a compatible object reader is available.
+
+    Rust tracks upstream LLVM more closely than Apple's command-line tools. An
+    older ``nm`` can therefore reject a valid Rust archive before the platform
+    linker does. Returning ``False`` in that case delegates the authoritative
+    check to :func:`_validate_archive_linkage`; a successfully parsed table is
+    still checked for forbidden Python dependencies here.
+    """
+
+    candidates: list[str] = []
+    for candidate in (
+        os.environ.get("LLVM_NM"),
+        shutil.which("llvm-nm"),
+        shutil.which("nm"),
+    ):
+        if candidate and candidate not in candidates:
+            candidates.append(candidate)
+
+    for nm in candidates:
+        completed = subprocess.run(
+            [nm, "-u", str(path)],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        forbidden: list[str] = []
+        for line in completed.stdout.splitlines():
+            fields = line.split()
+            if len(fields) < 2 or fields[-2] not in {"U", "u", "W", "w", "V", "v"}:
+                continue
+            symbol = fields[-1]
+            normalized = symbol.removeprefix("_").lower()
+            if normalized.startswith(FORBIDDEN_UNDEFINED_SYMBOL_PREFIXES):
+                forbidden.append(symbol)
+        if forbidden:
+            raise RuntimeError(
+                "Rusticol static archive has undefined Python/PyO3/NumPy symbols: "
+                + ", ".join(sorted(set(forbidden)))
+            )
+        if completed.returncode == 0:
+            return True
+    return False
+
+
+def _native_c_compiler(target: str) -> list[str]:
+    configured = os.environ.get("CC")
+    if configured:
+        command = shlex.split(configured)
+        if command:
+            return command
+    names = ("clang", "cc") if "apple-darwin" in target else ("cc", "clang")
+    for name in names:
+        compiler = shutil.which(name)
+        if compiler:
+            return [compiler]
+    raise RuntimeError("a C compiler is required to validate the Rusticol SDK")
+
+
+def _c_api_exports(header: Path) -> tuple[str, ...]:
+    exports = tuple(
+        dict.fromkeys(
+            re.findall(
+                r"\b(rusticol_[a-z0-9_]+)\s*\(",
+                header.read_text(encoding="utf-8"),
+            )
+        )
+    )
+    if not exports or "rusticol_abi_version" not in exports:
+        raise RuntimeError(
+            f"Rusticol C header declares no complete public ABI: {header}"
+        )
+    return exports
+
+
+def _native_link_flags(link: Mapping[str, Any], target: str) -> list[str]:
+    if link.get("target") != target:
+        raise RuntimeError("Rusticol native link metadata targets the wrong platform")
+    flags: list[str] = []
+    libraries = link.get("system_libraries")
+    frameworks = link.get("frameworks")
+    if not isinstance(libraries, list) or not all(
+        isinstance(item, str) for item in libraries
+    ):
+        raise RuntimeError("Rusticol native system-library metadata is invalid")
+    if not isinstance(frameworks, list) or not all(
+        isinstance(item, str) for item in frameworks
+    ):
+        raise RuntimeError("Rusticol native framework metadata is invalid")
+    flags.extend(f"-l{library}" for library in libraries)
+    for framework in frameworks:
+        flags.extend(("-framework", framework))
+    return flags
+
+
+def _validate_archive_linkage(
+    archive: Path,
+    *,
+    header: Path,
+    link: Mapping[str, Any],
+    target: str,
+) -> None:
+    """Link and execute a probe that references every declared C ABI export."""
+
+    exports = _c_api_exports(header)
+    entries = ",\n".join(f"    (rusticol_probe_fn){name}" for name in exports)
+    source = f"""\
+#include <stdint.h>
+#include \"rusticol.h\"
+
+typedef void (*rusticol_probe_fn)(void);
+static rusticol_probe_fn volatile rusticol_api[] = {{
+{entries}
+}};
+
+int main(void) {{
+    uint32_t (*abi_version)(void) = (uint32_t (*)(void))rusticol_api[0];
+    return abi_version() == RUSTICOL_ABI_VERSION ? 0 : 1;
+}}
+"""
+    with tempfile.TemporaryDirectory(prefix="pyamplicol-sdk-link-") as temporary:
+        directory = Path(temporary)
+        probe_source = directory / "probe.c"
+        probe_binary = directory / "probe"
+        probe_source.write_text(source, encoding="utf-8")
+        command = [
+            *_native_c_compiler(target),
+            "-std=c11",
+            "-O0",
+            "-I",
+            str(header.parent),
+            str(probe_source),
+            str(archive),
+            *_native_link_flags(link, target),
+            "-o",
+            str(probe_binary),
+        ]
+        completed = subprocess.run(
+            command,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if completed.returncode != 0:
+            detail = (completed.stderr or completed.stdout).strip()
+            suffix = f": {detail}" if detail else ""
+            raise RuntimeError(
+                "Rusticol static archive failed the complete C ABI link probe" + suffix
+            )
+        completed = subprocess.run(
+            [str(probe_binary)],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if completed.returncode != 0:
+            detail = (completed.stderr or completed.stdout).strip()
+            suffix = f": {detail}" if detail else ""
+            raise RuntimeError(
+                "Rusticol static archive failed the C ABI execution probe" + suffix
+            )
+
+
+def _package_version(root: Path) -> str:
+    candidate = root / "src" / "pyamplicol" / "_build_info.json"
+    if candidate.is_file():
+        payload = json.loads(candidate.read_text(encoding="utf-8"))
+        version = payload.get("version")
+        if isinstance(version, str) and version:
+            return version
+        raise RuntimeError("candidate build information has no package version")
+    with (root / "Cargo.toml").open("rb") as stream:
+        payload = tomllib.load(stream)
+    version = payload.get("workspace", {}).get("package", {}).get("version")
+    if not isinstance(version, str) or not version:
+        raise RuntimeError("Cargo workspace has no package version")
+    return version
+
+
+def _ensure_sdk_workspace_member(root: Path) -> None:
+    """Restore the SDK crate that Maturin prunes from unpacked sdists."""
+
+    path = root / "Cargo.toml"
+    text = path.read_text(encoding="utf-8")
+    try:
+        members = tomllib.loads(text)["workspace"]["members"]
+    except (KeyError, TypeError, tomllib.TOMLDecodeError) as error:
+        raise RuntimeError("Cargo workspace member inventory is invalid") from error
+    if not isinstance(members, list) or not all(
+        isinstance(member, str) for member in members
+    ):
+        raise RuntimeError("Cargo workspace member inventory is invalid")
+    if RUST_SDK_WORKSPACE_MEMBER in members:
+        return
+    expected = [
+        "rust/crates/rusticol-core",
+        "rust/crates/rusticol-python",
+    ]
+    if (
+        members != expected
+        or not (root / RUST_SDK_WORKSPACE_MEMBER / "Cargo.toml").is_file()
+    ):
+        raise RuntimeError("Cargo workspace does not contain the Rusticol C SDK")
+
+    workspace = re.search(
+        r"(?ms)^\[workspace\]\s*\n(?P<body>.*?)(?=^\[|\Z)",
+        text,
+    )
+    if workspace is None:
+        raise RuntimeError("Cargo workspace member inventory is invalid")
+    body = workspace.group("body")
+    updated_body, count = re.subn(
+        r"(?ms)^(members\s*=\s*)\[.*?\]",
+        rf'\g<1>["{expected[0]}", "{expected[1]}", '
+        rf'"{RUST_SDK_WORKSPACE_MEMBER}"]',
+        body,
+        count=1,
+    )
+    if count != 1:
+        raise RuntimeError("Cargo workspace member inventory is invalid")
+    path.write_text(
+        text[: workspace.start("body")] + updated_body + text[workspace.end("body") :],
+        encoding="utf-8",
+    )
+
+
+def build_sdk(root: Path, target_dir: Path) -> Path:
+    _ensure_sdk_workspace_member(root)
+    host = _host_target(root)
+    target = _requested_target(host)
+    sdk_contract = load_native_build_contract(root)["sdk"]
+    profile = str(sdk_contract["profile"])
+    profile_arguments = (
+        ["--release"] if profile == "release" else ["--profile", profile]
+    )
+    environment = dict(os.environ, CARGO_TARGET_DIR=str(target_dir))
+    _cargo_fetch(root, target_dir, target)
+    completed = subprocess.run(
+        [
+            "cargo",
+            "rustc",
+            "--locked",
+            "--offline",
+            *profile_arguments,
+            "--package",
+            str(sdk_contract["package"]),
+            "--target",
+            target,
+            "--message-format=json-render-diagnostics",
+            "--",
+            "--print",
+            "native-static-libs",
+            *[str(value) for value in sdk_contract["rustc-codegen-arguments"]],
+        ],
+        cwd=root,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        detail = _subprocess_excerpt(completed.stdout, completed.stderr)
+        suffix = f"\n{detail}" if detail else ""
+        raise RuntimeError(
+            "Rusticol C SDK cargo build failed with exit code "
+            f"{completed.returncode}{suffix}"
+        )
+    messages = _cargo_messages(completed.stdout)
+    archive = _static_library(messages)
+    if not archive.is_file():
+        raise RuntimeError(f"cargo reported a missing static archive: {archive}")
+    link = _typed_link_arguments(_native_tokens(completed.stderr), target)
+    _scan_archive(archive)
+    _scan_archive_symbols(archive)
+    _validate_archive_linkage(
+        archive,
+        header=root / "rust/crates/rusticol-capi/include/rusticol.h",
+        link=link,
+        target=target,
+    )
+
+    staging = target_dir.parent / "wheel-data" / "_sdk"
+    if staging.is_symlink() or (staging.exists() and not staging.is_dir()):
+        raise RuntimeError(f"Rusticol SDK staging path is unsafe: {staging}")
+    if staging.exists():
+        shutil.rmtree(staging)
+    rust_source = root / RUST_SDK_SOURCE
+    if not rust_source.is_file():
+        raise RuntimeError(f"missing Rusticol SDK source: {rust_source}")
+    for source_name, destination_name in SDK_SOURCES:
+        source = root / source_name
+        if not source.is_file():
+            raise RuntimeError(f"missing Rusticol SDK source: {source}")
+        destination = staging / destination_name
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, destination)
+
+    archive_name = (
+        "rusticol_capi.lib" if archive.suffix == ".lib" else "librusticol_capi.a"
+    )
+    library = staging / "lib" / archive_name
+    library.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(archive, library)
+    (staging / "link.json").write_text(
+        json.dumps(link, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    (staging / "metadata.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "abi_version": 1,
+                "version": _package_version(root),
+                "target": target,
+                "archive": f"lib/{archive_name}",
+                "rust_source": "rust/rusticol.rs",
+            },
+            indent=2,
+            sort_keys=True,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    return staging
diff --git a/pyamplicol/dependencies/README.md b/pyamplicol/dependencies/README.md
new file mode 100644
index 0000000000..43ac0d267f
--- /dev/null
+++ b/pyamplicol/dependencies/README.md
@@ -0,0 +1,146 @@
+# Dependency Modes
+
+pyAmpliCol defaults to published runtime dependencies and release-mode native
+builds. Historical pinned-source candidate machinery is retained, but its
+upstream pins need a coherent update before use with the current tensor APIs.
+Release mode uses Symbolica **3.0.0** and SymJIT **2.26.4**. Historical candidate
+mode retains SymJIT **2.26.0**; version numbers alone do not establish Python API
+compatibility. Candidate builds do not
+relabel dependency versions or modify upstream source files.
+
+## Release Mode
+
+`just dev-install` uses pip to resolve the Python runtime dependencies declared
+in the root `pyproject.toml`, then replaces published Symbolica and
+ufo-model-loader without resolving dependencies again. This replaces older
+source candidates reporting the same version. The upcoming release requires
+ufo-model-loader 1.0.0, which is not yet published. Until publication, explicitly
+supply the locally built loader wheel for contributor validation:
+
+```console
+just dev-install --loader-wheel /path/to/ufo_model_loader-1.0.0-py3-none-any.whl
+PYTHON=.venv/bin/python just dev-test
+```
+
+The installer never chooses a local loader wheel automatically; `--loader-wheel`
+is an explicit dependency-development override. Native build and staging use
+the existing release-mode workflow. Building a new release wheel requires a
+clean Git checkpoint and complete release assets; published-dependency mode
+does not relax publication guards. For dirty development checkouts,
+`--wheel-directory PATH` reuses an already-built compatible release wheel, or
+`--dependencies-only` skips the project build and staging while leaving the
+existing native runtime untouched. `--no-build` also skips runtime dependency
+installation.
+Developer tools and explicitly requested optional references may still be
+set up with `--no-build`. No editable installation is used. `just dev-test`
+defaults to release mode and includes a fresh build, so it also requires a clean
+checkpoint. Dirty edits can use focused tests against the staged native runtime.
+The developer dashboard retains its pinned Ratatui 0.4.2 build and FFI checkout
+in both lanes; it is not a core runtime dependency.
+
+Release-equivalent builds use exact published versions. Canonical Cargo
+resolution uses the published Symbolica 3.0.0 and SymJIT 2.26.4 crates without
+source patches. `release-lock.toml` records those versions, and `Cargo.lock`
+records normal registry resolution and checksums. The
+ordinary locked Cargo build is the dependency check; no local dependency
+patches or release-only source projections are needed.
+
+Python Symbolica 3.0.0 is published on PyPI. The required ufo-model-loader 1.0.0
+entry has no published wheel recorded in `python-runtime-lock.toml` yet. After
+the loader is uploaded, record its official PyPI wheel metadata before running
+the final release gates. A local wheel is not a published runtime-lock artifact.
+Successful candidate builds do not establish release availability or make
+candidate artifacts publishable.
+
+Prepared models in `src/pyamplicol/assets/prepared_models` are the source-runtime
+inputs. Release pairs use the release-locked dependencies and also
+live in the source-only `release_assets/prepared_models` store and are regenerated
+through the manual `release-prepared-models.yml`
+workflow using `release-lock.toml` and canonical `Cargo.lock`. Its temporary
+bootstrap wheel is non-publishable and omits prepared models and the portable
+self-test fixture. The release overlay installs the release pairs at canonical
+package paths and removes the auxiliary store, so the retained sdist contains
+only release payloads. Prepared-pack compatibility uses model/compiler
+identities, storage and plane ABIs, target, and payload hashes—not a separate
+dependency checkout fingerprint.
+
+## Historical Candidate Mode (Opt-in)
+
+The retained `--candidate` dependency-development machinery selects managed
+checkouts under `dependencies/checkouts`, pinned by `contributor-lock.toml`.
+These historical pins are incompatible with the
+current tensor implementation and must be updated together before use; this
+is not a working current-source setup route. The retained pin table is:
+
+| Dependency | Upstream source | Revision |
+| --- | --- | --- |
+| Symbolica 3.0.0, including Numerica and Graphica | `symbolica-dev/symbolica`, `main` | `7b31114c7a77571aabacf96a311f27ef0f44d007` |
+| SymJIT 2.26.0 | `siravan/symjit-crate` | `530304a07d1be6d5abc80291aa5e92cf28ac5546` |
+| GammaLoop, including Spenso/Idenso/Vakint | `alphal00p/gammaloop`, `main` | `312cf6aaf4cd1414f6742ad87ce39922c497a0b6` |
+| symbolica-integrate 2.0.1 | `symbolica-dev/symbolica-integrate`, `main` | `716354a07f2660b38390c95702aa617d1f9472c7` |
+| ufo-model-loader 0.1.8 | `alphal00p/ufo_model_loader`, `main` | `70ddee6b416f8c8b340e0d087646d77095c5d24b` |
+
+The pinned Symbolica source declares 3.0.0, matching the loader's genuine
+`symbolica>=3.0` requirement. The loader lives at
+`dependencies/checkouts/ufo-model-loader`; no separate future-loader checkout
+is needed. The symbolica-community revision is recorded in
+`contributor-lock.toml`.
+
+The generated candidate Cargo overlay selects these upstream sources for both
+pyAmpliCol and the community extension without changing canonical release
+resolution. The installer configures the community build manifest with the
+managed source paths and Symbolica's matching allocator; upstream Rust source
+files remain unchanged. Rusticol enables Symbolica's
+`native_code_generation` feature. SymJIT supplies the standard P-kernel
+interface; Rusticol owns scheduling, factors, accumulation, fanout, and artifact
+binding. Its plane adapter uses actual row indices and identity output, with
+descriptor lifetime, alignment, aliasing, and mutability checked by the caller.
+
+Candidate mode is not for PyPI publication. Its retained test selector,
+`PYAMPLICOL_BUILD_MODE=candidate`, does not make the historical pins compatible.
+The retained build machinery uses the tracked prepared-model packs and
+portable self-test fixture; an explicitly requested bootstrap omits both and
+is non-publishable. Neither bootstrap nor `--update` repairs incompatible
+upstream pins: `--update` only moves managed checkouts to the recorded revisions.
+`--reset` archives managed state in the workspace-local `.trash` store before
+recreating it.
+
+## Optional Profiling References
+
+These opt-ins are independent of the historical candidate machinery.
+
+The original Fortran AmpliCol checkout is optional, developer-only, and used
+only as an independent validation and benchmarking reference. Enable it with
+`just dev-install --with-legacy-amplicol`. The pinned
+`amplicol_with_patches` branch removes the unnecessary LHAPDF
+link from its direct color probe, exposes complete recursion-kind diagnostics,
+and reports each LC contraction-row partition. This
+resolves the physical color component only for a genuinely single-flow case;
+multi-flow fixtures use the rows only to verify the complete per-helicity
+aggregate. None modifies
+amplitude physics. `just legacy-physics` builds that probe and checks the
+tracked low-multiplicity LC/NLC/full fixture, including every physical
+helicity and every independently resolvable color component, against the
+pinned Fortran implementation.
+
+The pinned upstream revision contains no `LICENSE` or `COPYING` file. That fact
+is recorded in contributor-only provenance, not the release dependency lock.
+The checkout and its developer-only branch are never redistributed in a wheel
+or sdist.
+
+The Reference FFT checkout is likewise developer-only and is used only by the
+FFT profiling and hardware-sensitive acceptance tools. Enable it with
+`just dev-install --with-reference-fft`, which clones the exact
+public `AllGluonsMultipletFFT` revision recorded in `contributor-lock.toml`
+into `dependencies/checkouts/reference-fft`. That repository keeps the
+upstream contraction implementation and adds the calibrated
+batch/helicity-sum benchmark interface plus a high-multiplicity roundoff guard.
+It is never redistributed in a wheel or sdist. Ordinary `just dev-install`
+runs omit both external references. Enable both for the complete FFT profiling
+toolchain with
+`just dev-install --with-legacy-amplicol --with-reference-fft`.
+Enabling either external profiling reference also installs the project-owned
+`fft-profiling` Python extra into `.venv`; no editable project reinstall is
+required or supported. When updating a source tree that already has the former
+Reference FFT checkout, add `--update`; the installer migrates its managed
+`origin` to the public repository before fetching the pinned revision.
diff --git a/pyamplicol/dependencies/contributor-lock.toml b/pyamplicol/dependencies/contributor-lock.toml
new file mode 100644
index 0000000000..e5eb168114
--- /dev/null
+++ b/pyamplicol/dependencies/contributor-lock.toml
@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: 0BSD
+# Source-checkout-only dependency inputs for non-publishable contributor builds.
+schema_version = 1
+
+[abis]
+symbolica_serialization = "symbolica-bincode2-v1"
+symjit_application = "symjit-application-storage-v3"
+symjit_plane_application = "pyamplicol-symjit-plane-application-v2"
+
+[symbolica]
+source_url = "https://github.com/symbolica-dev/symbolica.git"
+candidate_version = "3.0.0"
+candidate_revision = "7b31114c7a77571aabacf96a311f27ef0f44d007"
+community_url = "https://github.com/symbolica-dev/symbolica-community.git"
+community_revision = "98740d198fb6667c63c0de7cffd4328b5dca57b0"
+release_status = "merged-main-candidate"
+
+[gammaloop_candidate]
+source_url = "https://github.com/alphal00p/gammaloop.git"
+branch = "main"
+revision = "312cf6aaf4cd1414f6742ad87ce39922c497a0b6"
+release_status = "developer-build-input-only"
+
+[symjit]
+candidate_version = "2.26.0"
+repository = "https://github.com/siravan/symjit-crate.git"
+revision = "530304a07d1be6d5abc80291aa5e92cf28ac5546"
+
+[symbolica_integrate]
+source_url = "https://github.com/symbolica-dev/symbolica-integrate.git"
+# Unmodified upstream main with Symbolica 3.0 support.
+revision = "716354a07f2660b38390c95702aa617d1f9472c7"
+
+[ratatui]
+distribution = "ratatui"
+version = "0.4.2"
+source_url = "https://files.pythonhosted.org/packages/83/ef/61a985816192cd3ee50ad5570a72f1fc6d22b86047771d5b72a05bbdc3eb/ratatui-0.4.2.tar.gz"
+sdist_sha256 = "2778b066378f8e1629b4b5e1076f1957c8c439b45cdeaf51970d1949730bb0d5"
+ffi_repository = "https://github.com/holo-q/ratatui-ffi.git"
+ffi_revision = "7249c0bd1445c0c6ee76f3f24923eb35a1d931e0"
+release_status = "developer-build-input-only"
+license = "MIT"
+
+[ufo_model_loader]
+source_url = "https://github.com/alphal00p/ufo_model_loader.git"
+candidate_revision = "70ddee6b416f8c8b340e0d087646d77095c5d24b"
+latest_verified_published_version = "0.1.8"
+published_revision = "f5a9f8d2eaff76b99629fc3143952ca4f2425d55"
+wheel_sha256 = "b253942f0a356eacd5fd68b104cacf11039c2391a9ee963107f674fad54f01ef"
+release_status = "verified"
+license = "MIT"
+
+[legacy_amplicol]
+source_url = "git@github.com:rikkert-frederix/AmpliCol.git"
+branch = "amplicol_with_patches"
+revision = "dcb3efbcbe89c51969818cddf48113fba19ad763"
+reference_fixture_revision = "f3fdca35631c9405d28337a79cdab84994d8e414"
+release_status = "developer-only"
+license = "NOASSERTION"
+redistributed = false
+license_evidence = "No LICENSE or COPYING file exists at the pinned branch revision"
+
+[reference_fft]
+source_url = "https://github.com/rikkert-frederix/AllGluonsMultipletFFT.git"
+branch = "main"
+revision = "9c3cb4fb4658200884553bab796e85bd5e7fe7a9"
+release_status = "developer-only"
+license = "NOASSERTION"
+redistributed = false
diff --git a/pyamplicol/dependencies/install_dependencies.py b/pyamplicol/dependencies/install_dependencies.py
new file mode 100644
index 0000000000..6b815e5e59
--- /dev/null
+++ b/pyamplicol/dependencies/install_dependencies.py
@@ -0,0 +1,1473 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Create a contributor environment using published dependencies by default."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+import tomllib
+import urllib.request
+from collections.abc import Sequence
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+DEPENDENCIES = ROOT / "dependencies"
+PYPROJECT = ROOT / "pyproject.toml"
+RELEASE_LOCK = DEPENDENCIES / "release-lock.toml"
+CONTRIBUTOR_LOCK = DEPENDENCIES / "contributor-lock.toml"
+# Retained as the public constant used by older contributor-side callers.
+LOCK = RELEASE_LOCK
+PYTHON_LOCK = DEPENDENCIES / "python-runtime-lock.toml"
+CHECKOUTS = DEPENDENCIES / "checkouts"
+WHEELHOUSE = DEPENDENCIES / "wheelhouse"
+VENV = ROOT / ".venv"
+STATE = DEPENDENCIES / "install-state.json"
+CANDIDATE_LOCK = DEPENDENCIES / "candidate-Cargo.lock"
+CARGO_CONFIG = DEPENDENCIES / "candidate-cargo-config.toml"
+ARTIFACTS = ROOT / ".artifacts" / "candidate"
+RELEASE_ARTIFACTS = ROOT / ".artifacts" / "development-release"
+TRASH = ROOT / ".trash"
+
+sys.path.insert(0, str(ROOT / "build_backend"))
+from python_lock import load_python_runtime_lock  # noqa: E402
+
+_WORKSPACE_CRATES = frozenset(
+    {
+        "rusticol-capi",
+        "rusticol-core",
+        "rusticol-python",
+    }
+)
+_CANDIDATE_PATH_CRATES = frozenset(
+    {
+        "graphica",
+        "numerica",
+        "symbolica",
+        "symjit",
+    }
+)
+_CRATES_IO_SOURCE = "registry+https://github.com/rust-lang/crates.io-index"
+_SHA256_PATTERN = re.compile(r"[0-9a-f]{64}")
+
+
+class SetupError(RuntimeError):
+    """Contributor setup could not be completed safely."""
+
+
+@dataclass(frozen=True)
+class Source:
+    key: str
+    url: str
+    revision: str
+    branch: str | None = None
+
+    @property
+    def path(self) -> Path:
+        return CHECKOUTS / self.key
+
+
+class Runner:
+    def __init__(self, *, dry_run: bool) -> None:
+        self.dry_run = dry_run
+
+    def run(
+        self,
+        command: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path | None = None,
+        env: dict[str, str] | None = None,
+        capture: bool = False,
+        check: bool = True,
+    ) -> subprocess.CompletedProcess[str]:
+        rendered = [str(item) for item in command]
+        suffix = f"  # cwd={cwd}" if cwd else ""
+        print(f"$ {shlex.join(rendered)}{suffix}")
+        if self.dry_run:
+            return subprocess.CompletedProcess(rendered, 0, "", "")
+        completed = subprocess.run(
+            rendered,
+            cwd=cwd,
+            env=env,
+            text=True,
+            capture_output=capture,
+        )
+        if check and completed.returncode != 0:
+            if capture:
+                print(completed.stdout, end="")
+                print(completed.stderr, end="", file=sys.stderr)
+            raise SetupError(
+                f"command exited with {completed.returncode}: {shlex.join(rendered)}"
+            )
+        return completed
+
+
+def _load_lock(path: Path, description: str) -> dict[str, Any]:
+    with path.open("rb") as stream:
+        payload = tomllib.load(stream)
+    if payload.get("schema_version") != 1:
+        raise SetupError(f"unsupported {description} schema")
+    return payload
+
+
+def _release_lock() -> dict[str, Any]:
+    return _load_lock(RELEASE_LOCK, "dependency release-lock")
+
+
+def _contributor_lock() -> dict[str, Any]:
+    return _load_lock(CONTRIBUTOR_LOCK, "dependency contributor-lock")
+
+
+def _lock() -> dict[str, Any]:
+    """Return the contributor setup view without polluting release metadata."""
+
+    release = _release_lock()
+    contributor = _contributor_lock()
+    payload = dict(release)
+    for key, value in contributor.items():
+        if isinstance(value, dict) and isinstance(payload.get(key), dict):
+            merged = dict(payload[key])
+            merged.update(value)
+            payload[key] = merged
+        else:
+            payload[key] = value
+    return payload
+
+
+def _sources(
+    payload: dict[str, Any],
+    *,
+    with_legacy: bool,
+    with_reference_fft: bool,
+) -> tuple[Source, ...]:
+    symbolica = payload["symbolica"]
+    symjit = payload["symjit"]
+    gammaloop = payload["gammaloop_candidate"]
+    integrate = payload["symbolica_integrate"]
+    loader = payload["ufo_model_loader"]
+    overrides = _root_path_patches()
+    sources = [
+        Source(
+            "symbolica",
+            str(symbolica["source_url"]),
+            str(symbolica["candidate_revision"]),
+        ),
+        Source(
+            "symbolica-community",
+            str(symbolica["community_url"]),
+            str(symbolica["community_revision"]),
+        ),
+        Source(
+            "ufo-model-loader",
+            str(loader["source_url"]),
+            str(loader["candidate_revision"]),
+        ),
+    ]
+    if "symjit" not in overrides:
+        sources.insert(
+            0, Source("symjit", str(symjit["repository"]), str(symjit["revision"]))
+        )
+    if "spenso" not in overrides:
+        sources.append(
+            Source(
+                "gammaloop",
+                str(gammaloop["source_url"]),
+                str(gammaloop["revision"]),
+                str(gammaloop["branch"]),
+            )
+        )
+    if "symbolica-integrate" not in overrides:
+        sources.append(
+            Source(
+                "symbolica-integrate",
+                str(integrate["source_url"]),
+                str(integrate["revision"]),
+            )
+        )
+    sources.extend(
+        _developer_sources(
+            payload, with_legacy=with_legacy, with_reference_fft=with_reference_fft
+        )
+    )
+    return tuple(sources)
+
+
+def _developer_sources(
+    payload: dict[str, Any], *, with_legacy: bool, with_reference_fft: bool
+) -> tuple[Source, ...]:
+    """Keep dashboard tooling independent of the selected runtime dependencies."""
+
+    ratatui = payload["ratatui"]
+    return (
+        Source(
+            "ratatui-ffi", str(ratatui["ffi_repository"]), str(ratatui["ffi_revision"])
+        ),
+        *_reference_sources(
+            payload, with_legacy=with_legacy, with_reference_fft=with_reference_fft
+        ),
+    )
+
+
+def _reference_sources(
+    payload: dict[str, Any], *, with_legacy: bool, with_reference_fft: bool
+) -> tuple[Source, ...]:
+    sources: list[Source] = []
+    if with_legacy:
+        legacy = payload["legacy_amplicol"]
+        sources.append(
+            Source(
+                "legacy-amplicol",
+                str(legacy["source_url"]),
+                str(legacy["revision"]),
+                str(legacy["branch"]),
+            )
+        )
+    if with_reference_fft:
+        reference = payload["reference_fft"]
+        sources.append(
+            Source(
+                "reference-fft",
+                str(reference["source_url"]),
+                str(reference["revision"]),
+                str(reference["branch"]),
+            )
+        )
+    return tuple(sources)
+
+
+def _venv_python() -> Path:
+    return VENV / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+
+
+def _venv_environment() -> dict[str, str]:
+    environment = dict(os.environ)
+    environment.pop("PYTHONPATH", None)
+    environment.pop("PYTHONHOME", None)
+    environment["VIRTUAL_ENV"] = str(VENV)
+    binary = VENV / ("Scripts" if os.name == "nt" else "bin")
+    environment["PATH"] = str(binary) + os.pathsep + environment.get("PATH", "")
+    return environment
+
+
+def _require_tools() -> None:
+    missing = [name for name in ("cargo", "git", "rustc") if shutil.which(name) is None]
+    if missing:
+        raise SetupError("missing contributor tools: " + ", ".join(sorted(missing)))
+
+
+def _managed_trash_destination(name: str, *, workspace_root: Path) -> Path:
+    """Return one new recoverable destination inside workspace-local trash."""
+
+    relative = Path(name)
+    if (
+        relative.is_absolute()
+        or len(relative.parts) != 1
+        or relative.name in {"", ".", ".."}
+    ):
+        raise SetupError(f"invalid managed dependency trash entry: {name!r}")
+    if workspace_root.is_symlink() or TRASH.is_symlink():
+        raise SetupError(
+            "managed dependency workspace and trash must not be symbolic links: "
+            f"{workspace_root}, {TRASH}"
+        )
+    resolved_workspace = workspace_root.resolve(strict=False)
+    resolved_trash = TRASH.resolve(strict=False)
+    try:
+        resolved_trash.relative_to(resolved_workspace)
+    except ValueError as error:
+        raise SetupError(
+            f"managed dependency trash resolves outside the workspace: {TRASH}"
+        ) from error
+    destination = TRASH / relative
+    try:
+        destination.resolve(strict=False).relative_to(resolved_trash)
+    except ValueError as error:
+        raise SetupError(
+            f"managed dependency trash entry escapes its root: {destination}"
+        ) from error
+    if destination.exists() or destination.is_symlink():
+        raise SetupError(
+            f"managed dependency trash destination already exists: {destination}"
+        )
+    return destination
+
+
+def _archive_managed_state(runner: Runner) -> None:
+    managed = (
+        VENV,
+        CHECKOUTS,
+        WHEELHOUSE,
+        STATE,
+        CANDIDATE_LOCK,
+        CARGO_CONFIG,
+        ARTIFACTS,
+    )
+    present = [path for path in managed if path.exists() or path.is_symlink()]
+    if not present:
+        return
+    stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%S%fZ")
+    destination = _managed_trash_destination(
+        f"dependency-reset-{stamp}",
+        workspace_root=ROOT,
+    )
+    for path in present:
+        relative = path.relative_to(ROOT)
+        target = destination / relative
+        print(f"$ mv {shlex.quote(str(path))} {shlex.quote(str(target))}")
+        if runner.dry_run:
+            continue
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(path), str(target))
+
+
+def _git_head(runner: Runner, path: Path) -> str:
+    completed = runner.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=path,
+        capture=True,
+    )
+    return completed.stdout.strip()
+
+
+def _managed_checkout(name: str) -> Path:
+    """Return one exact managed checkout child that cannot escape by symlink."""
+
+    relative = Path(name)
+    if (
+        relative.is_absolute()
+        or len(relative.parts) != 1
+        or relative.name in {"", ".", ".."}
+    ):
+        raise SetupError(f"invalid managed dependency checkout name: {name!r}")
+    destination = CHECKOUTS / relative
+    workspace_anchor = CHECKOUTS.parent.parent
+    try:
+        for path in (
+            workspace_anchor,
+            CHECKOUTS.parent,
+            CHECKOUTS,
+            destination,
+        ):
+            if path.is_symlink():
+                raise SetupError(
+                    "managed dependency checkout path must not be a symbolic link: "
+                    f"{path}"
+                )
+        workspace_root = workspace_anchor.resolve(strict=False)
+        checkout_root = CHECKOUTS.resolve(strict=False)
+        resolved_destination = destination.resolve(strict=False)
+    except OSError as error:
+        raise SetupError(
+            f"could not validate managed checkout path {destination}: {error}"
+        ) from error
+    try:
+        checkout_root.relative_to(workspace_root)
+        resolved_relative = resolved_destination.relative_to(checkout_root)
+    except ValueError as error:
+        raise SetupError(
+            "managed dependency checkout resolves outside the workspace root: "
+            f"{destination}"
+        ) from error
+    if resolved_relative != relative:
+        raise SetupError(
+            "managed dependency path does not resolve to the expected checkout: "
+            f"{destination}"
+        )
+    return destination
+
+
+def _root_path_patches() -> dict[str, Path]:
+    """Read explicit contributor overrides from the ordinary Cargo manifest."""
+
+    with (ROOT / "Cargo.toml").open("rb") as stream:
+        patches = tomllib.load(stream).get("patch", {}).get("crates-io", {})
+    return {
+        name: (ROOT / specification["path"]).resolve()
+        for name, specification in patches.items()
+        if isinstance(specification, dict) and "path" in specification
+    }
+
+
+def _managed_symjit_checkout() -> Path:
+    """Use the explicit local SymJIT override, or the pinned managed checkout."""
+
+    return _root_path_patches().get("symjit") or _managed_checkout("symjit")
+
+
+def _checkout(runner: Runner, source: Source, *, update: bool) -> None:
+    destination = _managed_checkout(source.key)
+    if destination.exists() and not (destination / ".git").exists():
+        stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%S%fZ")
+        archived = _managed_trash_destination(
+            f"superseded-{source.key}-{stamp}",
+            workspace_root=ROOT,
+        )
+        print(f"$ mv {shlex.quote(str(destination))} {shlex.quote(str(archived))}")
+        if not runner.dry_run:
+            archived.parent.mkdir(parents=True, exist_ok=True)
+            shutil.move(str(destination), str(archived))
+    if not destination.exists():
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        clone_command = [
+            "git",
+            "clone",
+            "--filter=blob:none",
+        ]
+        if source.branch is not None:
+            clone_command.extend(["--branch", source.branch, "--single-branch"])
+        clone_command.extend(["--no-checkout", source.url, str(destination)])
+        runner.run(clone_command)
+        runner.run(
+            ["git", "checkout", "--detach", source.revision],
+            cwd=destination,
+        )
+        return
+    if runner.dry_run:
+        print(f"# verify {source.key} at {source.revision}")
+        return
+    head = _git_head(runner, destination)
+    if head == source.revision:
+        return
+    if not update:
+        raise SetupError(
+            f"{destination} is at {head}, expected {source.revision}; "
+            "rerun with --update or --reset"
+        )
+    # The pinned source URL may move while retaining the same managed checkout
+    # name.  Refresh origin before fetching so --update also migrates existing
+    # contributor checkouts away from an obsolete or private repository.
+    runner.run(
+        ["git", "remote", "set-url", "origin", source.url],
+        cwd=destination,
+    )
+    fetch_ref = source.branch or source.revision
+    runner.run(["git", "fetch", "origin", fetch_ref], cwd=destination)
+    runner.run(
+        ["git", "checkout", "--detach", source.revision],
+        cwd=destination,
+    )
+
+
+def _replace_section(text: str, name: str, body: str) -> str:
+    pattern = re.compile(rf"(?ms)^\[{re.escape(name)}\]\n.*?(?=^\[[^\n]+\]\n|\Z)")
+    replacement = f"[{name}]\n{body.strip()}\n\n"
+    if not pattern.search(text):
+        return text.rstrip() + "\n\n" + replacement
+    return pattern.sub(replacement, text, count=1)
+
+
+def _require_symjit_rlib_manifest(
+    path: Path,
+    *,
+    expected_version: str | None = None,
+) -> None:
+    """Require the immutable upstream manifest to expose an rlib library."""
+
+    try:
+        with path.open("rb") as stream:
+            manifest = tomllib.load(stream)
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        raise SetupError(
+            f"could not validate managed SymJIT manifest: {error}"
+        ) from error
+    package = manifest.get("package")
+    if not isinstance(package, dict) or package.get("name") != "symjit":
+        raise SetupError("managed SymJIT source has the wrong package identity")
+    if expected_version is not None and str(package.get("version")) != expected_version:
+        raise SetupError(
+            "managed SymJIT source has the wrong package version: "
+            f"expected {expected_version}, got {package.get('version')!r}"
+        )
+    library = manifest.get("lib")
+    if not isinstance(library, dict) or library.get("crate-type") != ["rlib"]:
+        raise SetupError("managed SymJIT source must expose an rlib-only library")
+
+
+def _configure_source_manifests(runner: Runner) -> None:
+    symjit = _managed_symjit_checkout()
+    symbolica = _managed_checkout("symbolica")
+    community = _managed_checkout("symbolica-community")
+    gammaloop = _managed_checkout("gammaloop")
+    overrides = _root_path_patches()
+    integrate = overrides.get("symbolica-integrate") or _managed_checkout(
+        "symbolica-integrate"
+    )
+    if runner.dry_run:
+        print("# configure community Cargo paths; leave dependency sources unchanged")
+        return
+    _require_symjit_rlib_manifest(
+        symjit / "Cargo.toml",
+        expected_version=str(_contributor_lock()["symjit"]["candidate_version"]),
+    )
+
+    paths = {
+        "graphica": symbolica / "lib" / "graphica",
+        "numerica": symbolica / "lib" / "numerica",
+        "symbolica": symbolica,
+        "symjit": symjit,
+        "symbolica-integrate": integrate,
+    }
+    paths.update(
+        (name, gammaloop / "crates" / name)
+        for name in (
+            "idenso",
+            "linnet",
+            "spenso",
+            "spenso-hep-lib",
+            "spenso-macros",
+            "spynso3",
+            "symbolica-utils",
+            "vakint",
+        )
+    )
+    paths.update(overrides)
+    quoted = {name: json.dumps(str(path.resolve())) for name, path in paths.items()}
+    dependencies = (
+        'example_extension = { path = "example_extension", default-features = false }\n'
+        f"idenso = {{ path = {quoted['idenso']}, default-features = false, "
+        'features = ["bincode", "python"] }\n'
+        f"spynso3 = {{ path = {quoted['spynso3']}, default-features = false }}\n"
+        f"symbolica = {{ path = {quoted['symbolica']}, default-features = false, "
+        'features = ["python_export"] }\n'
+        f"symbolica-integrate = {{ path = {quoted['symbolica-integrate']}, "
+        'default-features = false, features = ["compressed-step-metadata"] }\n'
+        'pyo3 = { version = "0.28" }\n'
+        'pyo3-stub-gen = { version = "0.17", optional = true, '
+        'default-features = false, features = ["numpy"] }\n'
+    )
+    native_dependencies = f"""
+vakint = {{ path = {quoted["vakint"]}, features = [
+    "symbolica_community_module",
+] }}
+# Follow Symbolica's allocator to avoid duplicate native mimalloc links.
+mimalloc = {{ package = "rustfs-mimalloc", version = "0.5.4", features = [
+    "local_dynamic_tls",
+] }}
+"""
+    patches = "\n".join(
+        f"{name} = {{ path = {path} }}" for name, path in quoted.items()
+    )
+    community_cargo = community / "Cargo.toml"
+    text = community_cargo.read_text(encoding="utf-8")
+    if not re.search(r"(?m)^\[workspace\]\s*$", text):
+        # Managed checkouts live below pyAmpliCol's workspace directory but are
+        # independent build inputs.  An explicit empty workspace prevents Cargo
+        # from adopting this package into the nearest ancestor workspace.
+        text = "[workspace]\n\n" + text
+    text = _replace_section(text, "dependencies", dependencies)
+    text = _replace_section(
+        text,
+        "target.'cfg(not(target_arch = \"wasm32\"))'.dependencies",
+        native_dependencies,
+    )
+    text = _replace_section(text, "patch.crates-io", patches)
+    text = _replace_section(
+        text,
+        'patch."https://github.com/symbolica-dev/symbolica"',
+        "\n".join(
+            f"{name} = {{ path = {quoted[name]} }}"
+            for name in ("symbolica", "numerica", "graphica")
+        ),
+    )
+    community_cargo.write_text(text.rstrip() + "\n", encoding="utf-8")
+
+    example = community / "example_extension" / "Cargo.toml"
+    text = example.read_text(encoding="utf-8")
+    text = re.sub(
+        r"(?m)^symbolica\s*=\s*\{[^\n]*\}\s*$",
+        f"symbolica = {{ path = {quoted['symbolica']}, default-features = false, "
+        'features = ["python_export"] }',
+        text,
+        count=1,
+    )
+    example.write_text(text.rstrip() + "\n", encoding="utf-8")
+
+
+def _configure_sources(runner: Runner) -> None:
+    _configure_source_manifests(runner)
+    community = _managed_checkout("symbolica-community")
+    if runner.dry_run:
+        print("# restore the upstream symbolica-community Cargo.lock")
+    else:
+        upstream_lock = runner.run(
+            ["git", "show", "HEAD:Cargo.lock"],
+            cwd=community,
+            capture=True,
+        ).stdout
+        (community / "Cargo.lock").write_text(upstream_lock, encoding="utf-8")
+    # Resolve source substitutions, retaining compatible upstream lock entries.
+    runner.run(
+        ["cargo", "metadata", "--format-version", "1"],
+        cwd=community,
+        capture=True,
+    )
+    runner.run(
+        ["cargo", "metadata", "--locked", "--format-version", "1"],
+        cwd=community,
+        capture=True,
+    )
+
+
+def _write_cargo_config(runner: Runner) -> None:
+    symjit = _managed_symjit_checkout()
+    symbolica = _managed_checkout("symbolica")
+    entries = {
+        "graphica": symbolica / "lib" / "graphica",
+        "numerica": symbolica / "lib" / "numerica",
+        "symbolica": symbolica,
+        "symjit": symjit,
+    }
+    entries.update(_root_path_patches())
+    text = ["# Generated by dependencies/install_dependencies.py", "[patch.crates-io]"]
+    text.extend(
+        f"{name} = {{ path = {json.dumps(str(path.resolve()))} }}"
+        for name, path in entries.items()
+    )
+    print(f"# write {CARGO_CONFIG}")
+    if runner.dry_run:
+        return
+    CARGO_CONFIG.parent.mkdir(parents=True, exist_ok=True)
+    CARGO_CONFIG.write_text("\n".join(text) + "\n", encoding="utf-8")
+
+
+def _cargo_lock_packages(path: Path) -> list[dict[str, Any]]:
+    try:
+        with path.open("rb") as stream:
+            payload = tomllib.load(stream)
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        raise SetupError(f"invalid Cargo lock file {path}: {error}") from error
+    packages = payload.get("package")
+    if payload.get("version") != 4 or not isinstance(packages, list):
+        raise SetupError(f"Cargo lock file {path} must use format version 4")
+    return packages
+
+
+def _validate_release_cargo_lock(path: Path) -> None:
+    """Require ordinary registry resolution for every non-workspace crate."""
+    invalid: list[str] = []
+    for package in _cargo_lock_packages(path):
+        name = str(package.get("name", "<unnamed>"))
+        source = package.get("source")
+        checksum = package.get("checksum")
+        if name in _WORKSPACE_CRATES and source is None and checksum is None:
+            continue
+        if source != _CRATES_IO_SOURCE:
+            invalid.append(f"{name} has an unexpected source {source!r}")
+            continue
+        if not isinstance(checksum, str) or _SHA256_PATTERN.fullmatch(checksum) is None:
+            invalid.append(f"{name} has no valid registry checksum")
+    if invalid:
+        raise SetupError(
+            "canonical Cargo.lock is not release-resolved; regenerate it "
+            "without the candidate Cargo patch configuration:\n  "
+            + "\n  ".join(invalid)
+        )
+
+
+def _validate_candidate_cargo_lock(path: Path) -> None:
+    """Require only the managed patch crates to use local path resolution."""
+
+    packages = _cargo_lock_packages(path)
+    local_names = {
+        str(package.get("name"))
+        for package in packages
+        if package.get("source") is None and package.get("checksum") is None
+    }
+    expected_local = _WORKSPACE_CRATES | _CANDIDATE_PATH_CRATES
+    missing = sorted(expected_local - local_names)
+    unexpected = sorted(local_names - expected_local)
+    invalid_registry: list[str] = []
+    for package in packages:
+        name = str(package.get("name", "<unnamed>"))
+        if name in expected_local:
+            continue
+        source = package.get("source")
+        checksum = package.get("checksum")
+        if (
+            source != _CRATES_IO_SOURCE
+            or not isinstance(checksum, str)
+            or _SHA256_PATTERN.fullmatch(checksum) is None
+        ):
+            invalid_registry.append(name)
+    if missing or unexpected or invalid_registry:
+        details = []
+        if missing:
+            details.append("missing local crates: " + ", ".join(missing))
+        if unexpected:
+            details.append("unexpected local crates: " + ", ".join(unexpected))
+        if invalid_registry:
+            details.append(
+                "invalid registry crates: " + ", ".join(sorted(invalid_registry))
+            )
+        raise SetupError("invalid candidate Cargo lock: " + "; ".join(details))
+
+
+def _write_candidate_lock(runner: Runner) -> None:
+    if runner.dry_run:
+        print(f"# resolve {CANDIDATE_LOCK} from canonical Cargo.lock")
+        return
+    release_lock = ROOT / "Cargo.lock"
+    release_lock_bytes = release_lock.read_bytes()
+    with tempfile.TemporaryDirectory(prefix="pyamplicol-candidate-lock-") as raw:
+        temporary = Path(raw)
+        shutil.copy2(ROOT / "Cargo.toml", temporary / "Cargo.toml")
+        shutil.copy2(release_lock, temporary / "Cargo.lock")
+        shutil.copytree(ROOT / "rust", temporary / "rust")
+        _rewrite_candidate_requirements(temporary)
+        config = temporary / ".cargo" / "config.toml"
+        config.parent.mkdir(parents=True)
+        shutil.copy2(CARGO_CONFIG, config)
+        # Resolving from the release lock preserves every unrelated registry
+        # version while replacing only the explicitly patched candidate crates.
+        runner.run(
+            ["cargo", "metadata", "--format-version", "1"],
+            cwd=temporary,
+            capture=True,
+        )
+        _validate_candidate_cargo_lock(temporary / "Cargo.lock")
+        runner.run(
+            ["cargo", "metadata", "--locked", "--format-version", "1"],
+            cwd=temporary,
+            capture=True,
+        )
+        shutil.copy2(temporary / "Cargo.lock", CANDIDATE_LOCK)
+    if release_lock.read_bytes() != release_lock_bytes:
+        raise SetupError("candidate lock generation modified canonical Cargo.lock")
+
+
+def _rewrite_candidate_requirements(root: Path) -> None:
+    """Project published release pins onto the pinned candidate sources."""
+
+    lock = _lock()
+    manifest = root / "rust" / "crates" / "rusticol-core" / "Cargo.toml"
+    text = manifest.read_text(encoding="utf-8")
+    projections = (
+        (
+            "symbolica",
+            str(lock["symbolica"]["rust_version"]),
+            str(lock["symbolica"]["candidate_version"]),
+        ),
+        (
+            "symjit",
+            str(lock["symjit"]["version"]),
+            str(lock["symjit"]["candidate_version"]),
+        ),
+    )
+    for dependency, published, candidate in projections:
+        pattern = (
+            rf"(?m)^({dependency}\s*=\s*\{{\s*version\s*=\s*)"
+            rf'"={re.escape(published)}"'
+        )
+        text, count = re.subn(pattern, rf'\g<1>"={candidate}"', text, count=1)
+        if count != 1:
+            raise SetupError(
+                f"could not project rusticol-core {dependency} requirement "
+                f"from {published} to candidate {candidate}"
+            )
+    manifest.write_text(text, encoding="utf-8")
+
+
+def _runtime_requirements_text() -> str:
+    runtime_lock = load_python_runtime_lock(PYTHON_LOCK)
+    excluded = {"symbolica", "ufo-model-loader"}
+    lines: list[str] = []
+    for package in runtime_lock.packages:
+        if package.name in excluded:
+            continue
+        if not package.artifacts:
+            raise SetupError(
+                f"locked runtime package {package.name} has no wheel artifacts"
+            )
+        lines.append(f"{package.distribution}=={package.version} \\")
+        for index, artifact in enumerate(package.artifacts):
+            continuation = " \\" if index < len(package.artifacts) - 1 else ""
+            lines.append(f"    --hash=sha256:{artifact.sha256}{continuation}")
+    return "\n".join(lines) + "\n"
+
+
+def _contributor_python_requirements(
+    *,
+    with_fft_profiling: bool = False,
+) -> tuple[str, ...]:
+    """Reuse the selected contributor requirements from ``pyproject.toml``."""
+
+    with PYPROJECT.open("rb") as stream:
+        project_file = tomllib.load(stream)
+    build_system = project_file.get("build-system")
+    project = project_file.get("project")
+    if not isinstance(build_system, dict) or not isinstance(project, dict):
+        raise SetupError("pyproject must define build-system and project tables")
+    optional = project.get("optional-dependencies")
+    if not isinstance(optional, dict):
+        raise SetupError("pyproject must define optional dependencies")
+
+    requirements: list[str] = []
+    selected = [
+        ("build-system.requires", build_system.get("requires")),
+        ("project.optional-dependencies.test", optional.get("test")),
+        ("project.optional-dependencies.docs", optional.get("docs")),
+    ]
+    if with_fft_profiling:
+        selected.append(
+            (
+                "project.optional-dependencies.fft-profiling",
+                optional.get("fft-profiling"),
+            )
+        )
+    for description, raw in selected:
+        if not isinstance(raw, list) or not all(
+            isinstance(item, str) and item for item in raw
+        ):
+            raise SetupError(f"pyproject {description} must be a string list")
+        requirements.extend(raw)
+    return tuple(dict.fromkeys(requirements))
+
+
+def _venv_bootstrap_python() -> Path:
+    """Return an interpreter that remains available if this venv is reset."""
+
+    base_executable = getattr(sys, "_base_executable", None)
+    if isinstance(base_executable, str) and base_executable:
+        return Path(base_executable)
+    return Path(sys.executable)
+
+
+def _ensure_venv(
+    runner: Runner, *, with_fft_profiling: bool, install_runtime: bool = True
+) -> None:
+    if not _venv_python().is_file():
+        runner.run([_venv_bootstrap_python(), "-m", "venv", VENV])
+    python = _venv_python()
+    if runner.dry_run:
+        print(f"# ensure pip is available in {VENV}")
+    else:
+        pip_probe = subprocess.run(
+            [python, "-m", "pip", "--version"],
+            env=_venv_environment(),
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+        if pip_probe.returncode != 0:
+            runner.run(
+                [python, "-m", "ensurepip", "--upgrade"],
+                env=_venv_environment(),
+            )
+    contributor_tools = [
+        "pip",
+        *_contributor_python_requirements(
+            with_fft_profiling=with_fft_profiling,
+        ),
+        "setuptools>=68,<81",
+    ]
+    runner.run(
+        [python, "-m", "pip", "install", "--upgrade", *contributor_tools],
+        env=_venv_environment(),
+    )
+    if not install_runtime:
+        return
+    requirements = _runtime_requirements_text()
+    if runner.dry_run:
+        print("# install the hash-locked non-candidate Python runtime closure")
+    else:
+        with tempfile.TemporaryDirectory(
+            prefix="pyamplicol-runtime-requirements-"
+        ) as raw_directory:
+            requirement_path = Path(raw_directory) / "requirements.txt"
+            requirement_path.write_text(requirements, encoding="utf-8")
+            runner.run(
+                [
+                    python,
+                    "-m",
+                    "pip",
+                    "install",
+                    "--upgrade",
+                    "--require-hashes",
+                    "--only-binary=:all:",
+                    "--no-deps",
+                    "--requirement",
+                    requirement_path,
+                ],
+                env=_venv_environment(),
+            )
+
+
+def _ensure_just(runner: Runner) -> None:
+    if shutil.which("just") is None:
+        runner.run(["cargo", "install", "just", "--locked"])
+
+
+def _single_wheel(directory: Path, prefix: str) -> Path:
+    candidates = sorted(directory.glob(f"{prefix}*.whl"))
+    if len(candidates) != 1:
+        raise SetupError(
+            f"expected one {prefix} wheel in {directory}, found {len(candidates)}"
+        )
+    return candidates[0]
+
+
+def _archive_candidate_wheels(directory: Path, prefix: str) -> None:
+    candidates = sorted(directory.glob(f"{prefix}*.whl"))
+    if not candidates:
+        return
+    stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%S%fZ")
+    destination = _managed_trash_destination(
+        f"candidate-wheel-refresh-{stamp}",
+        workspace_root=ROOT,
+    ) / directory.relative_to(ROOT)
+    destination.mkdir(parents=True, exist_ok=True)
+    for wheel in candidates:
+        shutil.move(str(wheel), str(destination / wheel.name))
+
+
+def _verify_candidate_python_dependencies(
+    runner: Runner,
+    payload: dict[str, Any],
+) -> None:
+    expected_version = str(payload["symbolica"]["candidate_version"])
+    probe = "\n".join(
+        (
+            "from importlib.metadata import version",
+            "import sys",
+            "import symbolica",
+            "from symbolica import Expression",
+            "try:",
+            "    from symbolica.community.tensor import "
+            "TensorExpression, TensorNetwork",
+            "    TensorExpression.dirac_gamma",
+            "    TensorExpression.color_t",
+            "    TensorExpression.color_f",
+            "    TensorExpression.simplify_algebra",
+            "except (ImportError, AttributeError) as error:",
+            "    raise SystemExit(",
+            '        "Historical candidate dependencies lack the current tensor API; "',
+            '        "update coherent upstream pins before using --candidate."',
+            "    ) from error",
+            'actual = version("symbolica")',
+            "if actual != sys.argv[1]:",
+            "    raise SystemExit(",
+            '        "symbolica version mismatch: expected %s, got %s"',
+            "        % (sys.argv[1], actual)",
+            "    )",
+        )
+    )
+    environment = dict(_venv_environment(), SYMBOLICA_HIDE_BANNER="1")
+    runner.run(
+        [_venv_python(), "-I", "-c", probe, expected_version],
+        env=environment,
+    )
+
+
+def _materialize_ratatui_sdist(
+    runner: Runner,
+    payload: dict[str, Any],
+) -> Path:
+    ratatui = payload["ratatui"]
+    version = str(ratatui["version"])
+    source_url = str(ratatui["source_url"])
+    expected_sha256 = str(ratatui["sdist_sha256"])
+    if _SHA256_PATTERN.fullmatch(expected_sha256) is None:
+        raise SetupError("contributor lock has no valid Ratatui sdist SHA-256")
+    destination = WHEELHOUSE / "ratatui" / f"ratatui-{version}.tar.gz"
+    if runner.dry_run:
+        print(
+            f"# download and verify Ratatui {version} from {source_url} "
+            f"at sha256:{expected_sha256}"
+        )
+        return destination
+    if destination.is_file():
+        actual_sha256 = hashlib.sha256(destination.read_bytes()).hexdigest()
+        if actual_sha256 != expected_sha256:
+            raise SetupError(
+                "cached Ratatui sdist digest mismatch: "
+                f"expected {expected_sha256}, got {actual_sha256}; "
+                "rerun with --reset"
+            )
+        return destination
+    if destination.exists():
+        raise SetupError(f"invalid managed Ratatui sdist at {destination}")
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(
+        prefix=f".ratatui-{version}-",
+        suffix=".tar.gz",
+        dir=destination.parent,
+        delete=False,
+    ) as temporary:
+        temporary_path = Path(temporary.name)
+        digest = hashlib.sha256()
+        try:
+            with urllib.request.urlopen(source_url) as response:
+                while block := response.read(1024 * 1024):
+                    digest.update(block)
+                    temporary.write(block)
+        except Exception:
+            temporary_path.unlink(missing_ok=True)
+            raise
+    actual_sha256 = digest.hexdigest()
+    if actual_sha256 != expected_sha256:
+        temporary_path.unlink(missing_ok=True)
+        raise SetupError(
+            "Ratatui sdist digest mismatch: "
+            f"expected {expected_sha256}, got {actual_sha256}"
+        )
+    os.replace(temporary_path, destination)
+    return destination
+
+
+def _build_ratatui_wheel(
+    runner: Runner,
+    payload: dict[str, Any],
+) -> None:
+    """Build the pinned contributor-only Ratatui wheel from pinned FFI source."""
+
+    ratatui = payload["ratatui"]
+    version = str(ratatui["version"])
+    ffi_revision = str(ratatui["ffi_revision"])
+    if re.fullmatch(r"[0-9a-f]{40}", ffi_revision) is None:
+        raise SetupError("contributor lock has no valid Ratatui FFI revision")
+    sdist = _materialize_ratatui_sdist(runner, payload)
+    python = _venv_python()
+    wheel_directory = WHEELHOUSE / "ratatui"
+    ffi_source = CHECKOUTS / "ratatui-ffi"
+    if not runner.dry_run:
+        if not ffi_source.is_dir():
+            raise SetupError(f"missing managed Ratatui FFI source at {ffi_source}")
+        _archive_candidate_wheels(wheel_directory, "ratatui")
+    with tempfile.TemporaryDirectory(
+        prefix="pyamplicol-ratatui-ffi-",
+    ) as temporary_name:
+        external_ffi_source = Path(temporary_name) / "ratatui-ffi"
+        if not runner.dry_run:
+            # A checkout nested below pyAmpliCol is discovered as part of its
+            # parent Cargo workspace.  Build from an exact external copy so
+            # ratatui-ffi remains its own workspace without editing either
+            # pinned source tree.
+            shutil.copytree(
+                ffi_source,
+                external_ffi_source,
+                ignore=shutil.ignore_patterns(".git", "target"),
+            )
+            # Contributor builds keep temporary outputs inside this checkout.
+            # Stop Cargo from treating the private copy as a pyAmpliCol member.
+            manifest = external_ffi_source / "Cargo.toml"
+            manifest_text = manifest.read_text(encoding="utf-8")
+            if "\n[workspace]" not in f"\n{manifest_text}":
+                manifest.write_text(
+                    manifest_text.rstrip() + "\n\n[workspace]\n",
+                    encoding="utf-8",
+                )
+        environment = dict(
+            _venv_environment(),
+            RATATUI_FFI_SRC=str(external_ffi_source.resolve()),
+            CARGO_TARGET_DIR=str((external_ffi_source / "target").resolve()),
+            # Keep the exact revision visible to the upstream build even though
+            # RATATUI_FFI_SRC takes precedence and prevents its fallback clone.
+            RATATUI_FFI_TAG=ffi_revision,
+        )
+        runner.run(
+            [
+                python,
+                "-m",
+                "pip",
+                "wheel",
+                "--no-deps",
+                "--no-build-isolation",
+                "--wheel-dir",
+                wheel_directory,
+                sdist,
+            ],
+            env=environment,
+        )
+    if runner.dry_run:
+        return
+    wheel = _single_wheel(wheel_directory, "ratatui")
+    runner.run(
+        [
+            python,
+            "-m",
+            "pip",
+            "install",
+            "--force-reinstall",
+            "--no-deps",
+            wheel,
+        ],
+        env=_venv_environment(),
+    )
+    probe = "\n".join(
+        (
+            "from importlib.metadata import version",
+            "import sys",
+            "import ratatui",
+            "import ratatui_py",
+            'actual = version("ratatui")',
+            "if actual != sys.argv[1]:",
+            "    raise SystemExit(",
+            '        "ratatui version mismatch: expected %s, got %s"',
+            "        % (sys.argv[1], actual)",
+            "    )",
+        )
+    )
+    runner.run(
+        [python, "-I", "-c", probe, version],
+        env=_venv_environment(),
+    )
+
+
+def _build_candidate_dependency_wheels(
+    runner: Runner,
+    payload: dict[str, Any],
+) -> None:
+    community = _managed_checkout("symbolica-community")
+    python = _venv_python()
+    environment = _venv_environment()
+    symbolica_wheels = WHEELHOUSE / "symbolica"
+    if not runner.dry_run:
+        symbolica_wheels.mkdir(parents=True, exist_ok=True)
+        _archive_candidate_wheels(symbolica_wheels, "symbolica")
+
+    runner.run(
+        [
+            python,
+            "-m",
+            "maturin",
+            "build",
+            "--release",
+            "--locked",
+            "--interpreter",
+            python,
+            "--out",
+            symbolica_wheels,
+        ],
+        cwd=community,
+        env=environment,
+    )
+    if not runner.dry_run:
+        runner.run(
+            [
+                python,
+                "-m",
+                "pip",
+                "install",
+                "--force-reinstall",
+                "--no-deps",
+                _single_wheel(symbolica_wheels, "symbolica"),
+            ],
+            env=environment,
+        )
+    loader_wheels = WHEELHOUSE / "ufo-model-loader"
+    if not runner.dry_run:
+        loader_wheels.mkdir(parents=True, exist_ok=True)
+        _archive_candidate_wheels(loader_wheels, "ufo_model_loader")
+    runner.run(
+        [
+            python,
+            "-m",
+            "pip",
+            "wheel",
+            "--no-deps",
+            "--wheel-dir",
+            loader_wheels,
+            _managed_checkout("ufo-model-loader"),
+        ],
+        env=environment,
+    )
+    if not runner.dry_run:
+        runner.run(
+            [
+                python,
+                "-m",
+                "pip",
+                "install",
+                "--force-reinstall",
+                "--no-deps",
+                _single_wheel(loader_wheels, "ufo_model_loader"),
+            ],
+            env=environment,
+        )
+        _verify_candidate_python_dependencies(runner, payload)
+    _build_ratatui_wheel(runner, payload)
+
+
+def _install_published_dependencies(
+    runner: Runner, *, loader_wheel: Path | None
+) -> None:
+    with PYPROJECT.open("rb") as stream:
+        requirements = tomllib.load(stream)["project"]["dependencies"]
+    loader_arguments = (
+        [str(loader_wheel.expanduser().resolve())] if loader_wheel else []
+    )
+    python = _venv_python()
+    environment = _venv_environment()
+    runner.run(
+        [python, "-m", "pip", "install", "--upgrade", *requirements, *loader_arguments],
+        env=environment,
+    )
+    # Historical candidate builds report the same version as the released wheel.
+    # Replace both published packages (or the explicit loader override) after
+    # resolving dependencies once, including same-version source candidates.
+    symbolica = next(item for item in requirements if item.startswith("symbolica=="))
+    loader = next(
+        item for item in requirements if item.startswith("ufo-model-loader==")
+    )
+    runner.run(
+        [
+            python,
+            "-m",
+            "pip",
+            "install",
+            "--force-reinstall",
+            "--no-deps",
+            "--only-binary=:all:",
+            symbolica,
+            *(loader_arguments or [loader]),
+        ],
+        env=environment,
+    )
+
+
+def _install_project_wheel(runner: Runner, directory: Path) -> None:
+    if not runner.dry_run:
+        runner.run(
+            [
+                _venv_python(),
+                "-m",
+                "pip",
+                "install",
+                "--force-reinstall",
+                "--no-deps",
+                _single_wheel(directory, "pyamplicol"),
+            ],
+            env=_venv_environment(),
+        )
+
+
+def _build_project_wheel(runner: Runner, *, mode: str) -> None:
+    python = _venv_python()
+    environment = _venv_environment()
+    project_wheels = ARTIFACTS if mode == "candidate" else RELEASE_ARTIFACTS
+    if not runner.dry_run:
+        project_wheels.mkdir(parents=True, exist_ok=True)
+
+    build_environment = dict(
+        environment,
+        PYAMPLICOL_BUILD_MODE=mode,
+    )
+    if not runner.dry_run:
+        _archive_candidate_wheels(project_wheels, "pyamplicol")
+    runner.run(
+        [
+            python,
+            "-m",
+            "build",
+            "--wheel",
+            "--no-isolation",
+            "--skip-dependency-check",
+            "--outdir",
+            project_wheels,
+            *(
+                ["--config-setting", "pyamplicol.host-wheel=true"]
+                if sys.platform == "linux"
+                else []
+            ),
+        ],
+        cwd=ROOT,
+        env=build_environment,
+    )
+    _install_project_wheel(runner, project_wheels)
+
+
+def _stage_project_runtime(runner: Runner, *, directory: Path, mode: str) -> None:
+    runner.run(
+        [
+            _venv_python(),
+            ROOT / "tools/developer/prepare_source_runtime.py",
+            "--wheel-directory",
+            directory,
+        ],
+        cwd=ROOT,
+        env=dict(_venv_environment(), PYAMPLICOL_BUILD_MODE=mode),
+    )
+
+
+def _write_state(
+    runner: Runner,
+    sources: tuple[Source, ...],
+) -> None:
+    source_checkouts = {source.key: _managed_checkout(source.key) for source in sources}
+    if runner.dry_run:
+        print(f"# write {STATE}")
+        return
+    selected_sources = list(sources)
+    overrides = _root_path_patches()
+    lock = _lock()
+    local_sources = (
+        (
+            "symjit",
+            "symjit",
+            str(lock["symjit"]["repository"]),
+            str(lock["symjit"]["revision"]),
+            None,
+        ),
+        (
+            "spenso",
+            "gammaloop",
+            str(lock["gammaloop_candidate"]["source_url"]),
+            str(lock["gammaloop_candidate"]["revision"]),
+            str(lock["gammaloop_candidate"]["branch"]),
+        ),
+        (
+            "symbolica-integrate",
+            "symbolica-integrate",
+            str(lock["symbolica_integrate"]["source_url"]),
+            str(lock["symbolica_integrate"]["revision"]),
+            None,
+        ),
+    )
+    for crate, key, url, revision, branch in local_sources:
+        if crate in overrides:
+            selected_sources.append(Source(key, url, revision, branch))
+            source_checkouts[key] = overrides[crate]
+    source_state: dict[str, dict[str, str]] = {}
+    for source in selected_sources:
+        checkout = source_checkouts[source.key]
+        head = _git_head(runner, checkout)
+        source_state[source.key] = {
+            "url": source.url,
+            "revision": head,
+        }
+        if source.branch is not None:
+            source_state[source.key]["branch"] = source.branch
+    state = {
+        "schema_version": 1,
+        "publishable": False,
+        "sources": source_state,
+    }
+    STATE.write_text(
+        json.dumps(state, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--candidate",
+        action="store_true",
+        help="historical dependency development; retained pins need an upstream update",
+    )
+    parser.add_argument(
+        "--loader-wheel",
+        type=Path,
+        help="explicit local ufo-model-loader wheel for dependency development",
+    )
+    parser.add_argument("--reset", action="store_true")
+    parser.add_argument("--update", action="store_true")
+    parser.add_argument(
+        "--with-legacy-amplicol",
+        action="store_true",
+        help=(
+            "clone the optional pinned original-AmpliCol reference and install "
+            "the FFT profiling Python extra"
+        ),
+    )
+    parser.add_argument(
+        "--with-reference-fft",
+        action="store_true",
+        help=(
+            "clone the optional pinned public FFT reference and install the FFT "
+            "profiling Python extra"
+        ),
+    )
+    build_mode = parser.add_mutually_exclusive_group()
+    build_mode.add_argument("--no-build", action="store_true")
+    build_mode.add_argument(
+        "--dependencies-only",
+        action="store_true",
+        help="install Python dependencies without building or staging pyamplicol",
+    )
+    build_mode.add_argument(
+        "--wheel-directory",
+        type=Path,
+        help="install and stage one existing pyamplicol wheel instead of rebuilding it",
+    )
+    parser.add_argument("--dry-run", action="store_true")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _parser()
+    args = parser.parse_args(argv)
+    mode = (
+        "candidate"
+        if args.candidate
+        else os.environ.get("PYAMPLICOL_BUILD_MODE", "release")
+    )
+    if mode not in {"candidate", "release"}:
+        parser.error("PYAMPLICOL_BUILD_MODE must be 'candidate' or 'release'")
+    if mode == "candidate" and args.loader_wheel is not None:
+        parser.error("--loader-wheel belongs to the published-dependency lane")
+    payload = _lock()
+    runner = Runner(dry_run=args.dry_run)
+    if args.reset:
+        _archive_managed_state(runner)
+    if not args.dry_run and (mode == "candidate" or not args.no_build):
+        _require_tools()
+    sources = (_sources if mode == "candidate" else _developer_sources)(
+        payload,
+        with_legacy=args.with_legacy_amplicol,
+        with_reference_fft=args.with_reference_fft,
+    )
+    _ensure_just(runner)
+    _ensure_venv(
+        runner,
+        with_fft_profiling=(args.with_legacy_amplicol or args.with_reference_fft),
+        install_runtime=mode == "candidate",
+    )
+    for source in sources:
+        _checkout(runner, source, update=args.update)
+    if mode == "candidate":
+        print(
+            "Historical source-candidate lane: retained pins require a coherent "
+            "upstream update for the current tensor API."
+        )
+        _configure_sources(runner)
+        _write_cargo_config(runner)
+        _write_candidate_lock(runner)
+        _write_state(runner, sources)
+    if not args.no_build:
+        if mode == "candidate":
+            _build_candidate_dependency_wheels(runner, payload)
+        else:
+            _install_published_dependencies(runner, loader_wheel=args.loader_wheel)
+            _build_ratatui_wheel(runner, payload)
+        if not args.dependencies_only:
+            directory = args.wheel_directory
+            if directory is None:
+                directory = ARTIFACTS if mode == "candidate" else RELEASE_ARTIFACTS
+                _build_project_wheel(runner, mode=mode)
+            else:
+                directory = directory.expanduser().resolve()
+                _install_project_wheel(runner, directory)
+            _stage_project_runtime(runner, directory=directory, mode=mode)
+    print(f"Contributor environment ready at {VENV}")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except SetupError as error:
+        print(f"error: {error}", file=sys.stderr)
+        raise SystemExit(2) from error
diff --git a/pyamplicol/dependencies/python-runtime-lock.toml b/pyamplicol/dependencies/python-runtime-lock.toml
new file mode 100644
index 0000000000..863b297161
--- /dev/null
+++ b/pyamplicol/dependencies/python-runtime-lock.toml
@@ -0,0 +1,233 @@
+# SPDX-License-Identifier: 0BSD
+# Exact Python runtime graph and admitted wheels for supported release targets.
+schema_version = 1
+requires_python = ">=3.11"
+supported_python = ["3.11", "3.12", "3.13", "3.14"]
+
+[[packages]]
+distribution = "colorama"
+version = "0.4.6"
+license = "BSD-3-Clause"
+direct = true
+dependencies = []
+
+  [[packages.artifacts]]
+  filename = "colorama-0.4.6-py2.py3-none-any.whl"
+  sha256 = "4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"
+
+[[packages]]
+distribution = "numpy"
+version = "2.4.6"
+license = "BSD-3-Clause AND 0BSD AND MIT AND Zlib AND CC0-1.0"
+direct = true
+dependencies = []
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl"
+  sha256 = "0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl"
+  sha256 = "110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl"
+  sha256 = "4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl"
+  sha256 = "8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl"
+  sha256 = "89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl"
+  sha256 = "001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl"
+  sha256 = "ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl"
+  sha256 = "3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl"
+  sha256 = "357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl"
+  sha256 = "90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl"
+  sha256 = "511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl"
+  sha256 = "bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl"
+  sha256 = "043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl"
+  sha256 = "6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl"
+  sha256 = "a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp314-cp314-macosx_10_15_x86_64.whl"
+  sha256 = "06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp314-cp314-macosx_11_0_arm64.whl"
+  sha256 = "38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp314-cp314-macosx_14_0_arm64.whl"
+  sha256 = "d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp314-cp314-macosx_14_0_x86_64.whl"
+  sha256 = "0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096"
+
+  [[packages.artifacts]]
+  filename = "numpy-2.4.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl"
+  sha256 = "a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8"
+
+[[packages]]
+distribution = "platformdirs"
+version = "4.12.2"
+license = "MIT"
+direct = true
+dependencies = []
+
+  [[packages.artifacts]]
+  filename = "platformdirs-4.12.2-py3-none-any.whl"
+  sha256 = "29dbf06d96c500bc6bdbce75fb0a14d63279c93b1842f97e72a135b33e856983"
+
+[[packages]]
+distribution = "prettytable"
+version = "3.18.0"
+license = "BSD-3-Clause"
+direct = true
+dependencies = ["wcwidth"]
+
+  [[packages.artifacts]]
+  filename = "prettytable-3.18.0-py3-none-any.whl"
+  sha256 = "b3346e0e6f79180833aebaac088ae926340586cf6d7d991b9eb125b65f72313a"
+
+[[packages]]
+distribution = "progressbar2"
+version = "4.6.0"
+license = "BSD-3-Clause"
+direct = true
+dependencies = ["python-utils"]
+
+  [[packages.artifacts]]
+  filename = "progressbar2-4.6.0-py3-none-any.whl"
+  sha256 = "2d78bdeb1debef92a39dd9042e0689542bd72d6e2f30b13432db371aa9d8ee4e"
+
+[[packages]]
+distribution = "python-utils"
+version = "4.1.0"
+license = "BSD-3-Clause"
+direct = false
+dependencies = ["typing-extensions"]
+
+  [[packages.artifacts]]
+  filename = "python_utils-4.1.0-py3-none-any.whl"
+  sha256 = "dd3c041dae1efc1323209a7598d3a4fe1a832d81be10a98846341af929a0119e"
+
+[[packages]]
+distribution = "six"
+version = "1.17.0"
+license = "MIT"
+direct = true
+dependencies = []
+
+  [[packages.artifacts]]
+  filename = "six-1.17.0-py2.py3-none-any.whl"
+  sha256 = "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274"
+
+[[packages]]
+distribution = "symbolica"
+version = "3.0.0"
+license = "LicenseRef-Symbolica-Proprietary"
+direct = true
+dependencies = []
+
+  [[packages.artifacts]]
+  filename = "symbolica-3.0.0-cp39-abi3-macosx_10_12_x86_64.whl"
+  sha256 = "b2ea03b9be72a3ebc3fa950d7380b09223084cb5554aa0877c59e12d7749c2a7"
+
+  [[packages.artifacts]]
+  filename = "symbolica-3.0.0-cp39-abi3-macosx_11_0_arm64.whl"
+  sha256 = "6b7414d8d06ac20c92460e0685c794d97afe976968b5fba5cc9562c471b2365d"
+
+  [[packages.artifacts]]
+  filename = "symbolica-3.0.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl"
+  sha256 = "a2977f78d8f40ce3206ba49850cf75f473785a32a9368e6115d059755a48d15e"
+
+[[packages]]
+distribution = "tomli-w"
+version = "1.2.0"
+license = "MIT"
+direct = true
+dependencies = []
+
+  [[packages.artifacts]]
+  filename = "tomli_w-1.2.0-py3-none-any.whl"
+  sha256 = "188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90"
+
+[[packages]]
+distribution = "typing-extensions"
+version = "4.16.0"
+license = "PSF-2.0"
+direct = false
+dependencies = []
+
+  [[packages.artifacts]]
+  filename = "typing_extensions-4.16.0-py3-none-any.whl"
+  sha256 = "481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8"
+
+[[packages]]
+distribution = "ufo-model-loader"
+version = "1.0.0"
+license = "MIT"
+direct = true
+dependencies = ["symbolica"]
+
+  [[packages.artifacts]]
+  filename = "ufo_model_loader-1.0.0-py3-none-any.whl"
+  sha256 = "4e2e807d6a0d16034a525f80f2a80f4fe17689f7955b27b1118b7595bd56a8eb"
+
+[[packages]]
+distribution = "wcwidth"
+version = "0.9.1"
+license = "MIT"
+direct = false
+dependencies = []
+
+  [[packages.artifacts]]
+  filename = "wcwidth-0.9.1-cp310-abi3-macosx_10_9_x86_64.whl"
+  sha256 = "10b00ba23482e352f874d2e8135e7ace9da838646c7dd800566246bbd46125ff"
+
+  [[packages.artifacts]]
+  filename = "wcwidth-0.9.1-cp310-abi3-macosx_11_0_arm64.whl"
+  sha256 = "40d936d72c9bdc10df43f93a8be502bc5024b487259139f66a328722c07f34a9"
+
+  [[packages.artifacts]]
+  filename = "wcwidth-0.9.1-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl"
+  sha256 = "747fb724223f417a17541a95a17c1dac3a8ef9a0cf41684950f0eab191a35f65"
+
+  [[packages.artifacts]]
+  filename = "wcwidth-0.9.1-py3-none-any.whl"
+  sha256 = "e0c3a1c45c5b9550c6919a4449e95f5b177f6e165786376981db8f1addae9b21"
diff --git a/pyamplicol/dependencies/release-lock.toml b/pyamplicol/dependencies/release-lock.toml
new file mode 100644
index 0000000000..cbbbc6739d
--- /dev/null
+++ b/pyamplicol/dependencies/release-lock.toml
@@ -0,0 +1,97 @@
+# SPDX-License-Identifier: 0BSD
+schema_version = 1
+
+[project]
+distribution = "pyamplicol"
+version = "0.2.1"
+python_requires = ">=3.11"
+wheel_abi = "cp311-abi3"
+license = "0BSD"
+
+[abis]
+python_api = 1
+toml = 1
+compiled_model = 9
+process_artifact = 3
+runtime_physics = 1
+c_abi = 1
+symbolica_serialization = "symbolica-bincode2-v1"
+symjit_application = "symjit-application-storage-v3"
+symjit_plane_application = "pyamplicol-symjit-plane-application-v2"
+prepared_model_bundle = 1
+prepared_kernel_variant = "pyamplicol-prepared-kernel-variant-v2"
+eager_kernel = "pyamplicol-eager-kernel-v1"
+eager_plan = "pyamplicol-eager-plan-v2"
+eager_selector_domains = "pyamplicol-eager-selector-domains-v1"
+
+[toolchain]
+just = "1.46.0"
+maturin = "1.15.0"
+packaging = "26.3"
+rust_minimum = "1.89.0"
+rust_toolchain = "1.97.1"
+rust_toolchain_action_sha = "46511b1c83438f0dd37c02d843619ece5a4abb5b"
+manylinux_image = "quay.io/pypa/manylinux_2_28_x86_64"
+manylinux_image_digest = "sha256:b04887b645dde99b9e955aeae3ff4da414992d0bd88259f046295b56361c5614"
+
+[[targets]]
+triple = "aarch64-apple-darwin"
+platform_tag = "macosx_11_0_arm64"
+
+[[targets]]
+triple = "x86_64-apple-darwin"
+platform_tag = "macosx_11_0_x86_64"
+
+[[targets]]
+triple = "x86_64-unknown-linux-gnu"
+platform_tag = "manylinux_2_28_x86_64"
+
+[[python_dependencies]]
+distribution = "colorama"
+version = "0.4.6"
+
+[[python_dependencies]]
+distribution = "numpy"
+version = "2.4.6"
+
+[[python_dependencies]]
+distribution = "platformdirs"
+version = "4.12.2"
+
+[[python_dependencies]]
+distribution = "prettytable"
+version = "3.18.0"
+
+[[python_dependencies]]
+distribution = "progressbar2"
+version = "4.6.0"
+
+[[python_dependencies]]
+distribution = "six"
+version = "1.17.0"
+
+[[python_dependencies]]
+distribution = "symbolica"
+version = "3.0.0"
+
+[[python_dependencies]]
+distribution = "tomli-w"
+version = "1.2.0"
+
+[[python_dependencies]]
+distribution = "ufo-model-loader"
+version = "1.0.0"
+
+[symbolica]
+python_distribution = "symbolica"
+python_version = "3.0.0"
+rust_crate = "symbolica"
+rust_version = "3.0.0"
+serialization_abi = "symbolica-bincode2-v1"
+
+[symjit]
+version = "2.26.4"
+
+[ufo_model_loader]
+python_distribution = "ufo-model-loader"
+required_version = "1.0.0"
diff --git a/pyamplicol/docs/README.md b/pyamplicol/docs/README.md
new file mode 100644
index 0000000000..1eff0c1fec
--- /dev/null
+++ b/pyamplicol/docs/README.md
@@ -0,0 +1,121 @@
+---
+title: "Home"
+nav_order: 1
+description: "Generate and evaluate color-ordered scattering amplitudes from Python and native APIs."
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+<p align="center">
+  <img src="https://raw.githubusercontent.com/MadGraphTeam/pyamplicol/main/docs/assets/pyamplicol_logo.png" alt="pyAmpliCol" width="680">
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/pyamplicol/"><img src="https://img.shields.io/pypi/v/pyamplicol.svg" alt="PyPI"></a>
+  <a href="https://pypi.org/project/pyamplicol/"><img src="https://img.shields.io/pypi/pyversions/pyamplicol.svg" alt="Python versions"></a>
+  <a href="https://github.com/MadGraphTeam/pyamplicol/actions/workflows/tests.yml"><img src="https://github.com/MadGraphTeam/pyamplicol/actions/workflows/tests.yml/badge.svg" alt="Tests"></a>
+  <a href="https://github.com/MadGraphTeam/pyamplicol/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-0BSD-blue.svg" alt="License: 0BSD"></a>
+</p>
+
+<p align="center"><strong>Fast color-ordered scattering amplitudes from Python and native APIs.</strong></p>
+
+pyAmpliCol generates portable process artifacts from built-in, JSON, and UFO
+models, then evaluates them through a fast Rust runtime. It supports a typed
+Python API and CLI, runtime helicity and color-flow selection, and generated
+Python, C11, C++17, Fortran 2008, and Rust 2021 interfaces.
+
+## Start here
+
+| I want to… | Read |
+| --- | --- |
+| follow a physicist-friendly, MadGraph-style walkthrough | [Get started: a gentle walkthrough](user/gentle-walkthrough.md) |
+| install pyAmpliCol and verify it | [Installation](user/installation.md) |
+| generate and evaluate my first process | [Quick Start](user/quick-start.md) |
+| choose a model, process, color approximation, or evaluator | [Configuration](user/configuration.md) and [Models and Processes](user/models-and-processes.md), including the packaged scalar HEFT workflow |
+| check whether my UFO model is supported | [UFO Model Coverage](user/ufo-model-coverage.md), the exact list of accepted, conditional and rejected model features |
+| call pyAmpliCol from Python | [Python API](user/python-api.md) |
+| prepare and evaluate tree-level spin and colour correlations | [Born Correlations](correlators.md) and [Correlation Conventions](correlator-conventions.md), LC/NLC/full colour and grouped Python evaluation |
+| use C, C++, Fortran, Rust, or generated Python drivers | [Native APIs](user/native-apis.md) |
+| build a UMAMI shared library or integrate with MadSpace | [UMAMI and MadSpace](user/umami-api.md) |
+| benchmark, reproduce, or view performance reports | [Profiling and Benchmarking](user/profiling-and-benchmarking.md), [FullColor FFT Profiling](user/fullcolor-fft-profiling.md), and [published performance reports](performance_reports/README.md) |
+| diagnose an error | [Troubleshooting](user/troubleshooting.md) |
+
+## Install and try it
+
+```console
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install pyamplicol
+pyamplicol self-test
+```
+
+Generate a small built-in Standard Model process and inspect the artifact:
+
+```console
+pyamplicol generate "d d~ > z" ./artifacts/ddbar_z \
+  --model built-in-sm
+pyamplicol inspect ./artifacts/ddbar_z
+```
+
+The generated process appears in the inspection table as:
+
+```text
++---------+-------------+------------------+-------+--------------+---------------+
+| default | stable ID   | concrete process | color | helicities  | color outputs |
++---------+-------------+------------------+-------+--------------+---------------+
+|    *    | d_dbar_to_z | d d~ > z         | lc    | 12 (6 eval.) | 1             |
++---------+-------------+------------------+-------+--------------+---------------+
+```
+
+The CLI uses color automatically on an interactive terminal; the plain capture
+above remains readable in logs and documentation.
+
+## One artifact, several interfaces
+
+```text
+model + process request
+          │
+          ▼
+generated process artifact
+          ├── Python Runtime
+          ├── C / C++ / Fortran / Rust APIs
+          ├── selectors and arbitrary precision
+          └── benchmarking and profiling
+```
+
+Ordinary Python evaluation uses the same runtime as the native interfaces:
+
+```python
+import math
+
+from pyamplicol import Runtime
+
+runtime = Runtime.load("artifacts/ddbar_z", process="d d~ > z")
+energy = 91.188 / 2.0
+momenta = [[
+    [energy, 0.0, 0.0, energy],
+    [energy, 0.0, 0.0, -energy],
+    [2.0 * energy, 0.0, 0.0, 0.0],
+]]
+value = runtime.evaluate(momenta)
+resolved = runtime.evaluate_resolved(momenta)
+for optimized, explicit in zip(value, resolved.total(), strict=True):
+    assert math.isclose(optimized.real, explicit.real, rel_tol=1e-12, abs_tol=1e-15)
+    assert math.isclose(optimized.imag, explicit.imag, rel_tol=1e-12, abs_tol=1e-15)
+```
+
+Process expressions may reorder particles within the incoming side or within
+the outgoing side. pyAmpliCol consistently permutes momenta, helicities, color
+flows, and resolved metadata; particles never cross the `>` boundary. See
+[Process Selection and Permutations](user/process-selection-and-permutations.md).
+
+## Explore the documentation
+
+- **Using pyAmpliCol:** [Examples Gallery](user/examples-gallery.md), [Command-Line Interface](user/command-line-interface.md), [Runtime and Selectors](user/runtime-and-selectors.md)
+- **Generation:** [Models and Processes](user/models-and-processes.md), including scalar HEFT, [Generation Modes and Evaluators](user/generation-modes-and-evaluators.md), and [Process Grouping](user/process-grouping.md) of subprocesses with equal matrix elements
+- **Guided workflows:** [LC workloads and execution modes](user/lc-workloads-and-execution-modes.md), [Profiling campaign: from measurements to the PDF](user/profiling-campaign-walkthrough.md), [FullColor FFT Profiling](user/fullcolor-fft-profiling.md)
+- **Deployment:** [Artifacts and Portability](user/artifacts-and-portability.md), [Release and Platform Support](user/release-and-support.md)
+- **Background:** [Architecture Overview](user/architecture-overview.md), [Symbolica and Licensing](user/symbolica-and-licensing.md)
+
+This site is the authoritative user documentation for the current `main`
+branch. [Release and Support](user/release-and-support.md) records the published
+platform and validation boundary, while public API stability is defined by the
+[API contract](development/API_CONTRACT.md).
diff --git a/pyamplicol/docs/_config.yml b/pyamplicol/docs/_config.yml
new file mode 100644
index 0000000000..f40a6eea7c
--- /dev/null
+++ b/pyamplicol/docs/_config.yml
@@ -0,0 +1,64 @@
+title: pyAmpliCol
+description: Fast color-ordered scattering amplitudes from Python and native APIs.
+url: https://madgraph.org
+baseurl: /pyamplicol
+repository: MadGraphTeam/pyamplicol
+permalink: pretty
+
+remote_theme: just-the-docs/just-the-docs@2ed4c0af735e95af5c0dcf7a605b07d903005b4e
+plugins:
+  - jekyll-remote-theme
+  - jekyll-include-cache
+  - jekyll-seo-tag
+  - jekyll-relative-links
+
+defaults:
+  - scope:
+      path: ""
+      type: pages
+    values:
+      layout: default
+      image: /assets/pyamplicol_social_preview.png
+
+logo: /assets/pyamplicol_logo.png
+color_scheme: light
+search_enabled: true
+search:
+  heading_level: 3
+  previews: 3
+  rel_url: true
+  focus_shortcut_key: "k"
+enable_copy_code_button: true
+heading_anchors: true
+nav_enabled: true
+back_to_top: true
+back_to_top_text: Back to top
+
+relative_links:
+  enabled: true
+  collections: true
+
+readme_index:
+  with_frontmatter: true
+
+aux_links:
+  Repository:
+    - https://github.com/MadGraphTeam/pyamplicol
+  PyPI:
+    - https://pypi.org/project/pyamplicol/
+aux_links_new_tab: true
+
+gh_edit_link: true
+gh_edit_link_text: Edit this page on GitHub
+gh_edit_repository: https://github.com/MadGraphTeam/pyamplicol
+gh_edit_branch: main
+gh_edit_source: docs
+gh_edit_view_mode: edit
+
+callouts:
+  tip:
+    title: Tip
+    color: blue
+  important:
+    title: Important
+    color: purple
diff --git a/pyamplicol/docs/_includes/head_custom.html b/pyamplicol/docs/_includes/head_custom.html
new file mode 100644
index 0000000000..18fe68a3cb
--- /dev/null
+++ b/pyamplicol/docs/_includes/head_custom.html
@@ -0,0 +1,3 @@
+<link rel="icon" type="image/png" href="{{ '/assets/pyamplicol_mark.png' | relative_url }}">
+<meta name="color-scheme" content="light dark">
+<link rel="stylesheet" href="{{ '/assets/css/just-the-docs-dark.css' | relative_url }}?v={{ site.github.build_revision | default: 'local' }}" media="(prefers-color-scheme: dark)">
diff --git a/pyamplicol/docs/_includes/nav_footer_custom.html b/pyamplicol/docs/_includes/nav_footer_custom.html
new file mode 100644
index 0000000000..bcf2a9f221
--- /dev/null
+++ b/pyamplicol/docs/_includes/nav_footer_custom.html
@@ -0,0 +1,7 @@
+<p>
+  <a href="https://github.com/MadGraphTeam/pyamplicol">Repository</a>
+  &middot;
+  <a href="https://pypi.org/project/pyamplicol/">PyPI</a>
+  &middot;
+  <a href="https://github.com/MadGraphTeam/pyamplicol/issues">Issues</a>
+</p>
diff --git a/pyamplicol/docs/assets/css/just-the-docs-dark.scss b/pyamplicol/docs/assets/css/just-the-docs-dark.scss
new file mode 100644
index 0000000000..32337442bb
--- /dev/null
+++ b/pyamplicol/docs/assets/css/just-the-docs-dark.scss
@@ -0,0 +1,9 @@
+---
+---
+{% include css/just-the-docs.scss.liquid color_scheme="dark" %}
+
+.site-logo,
+.main-content img[alt="pyAmpliCol"] {
+  filter: brightness(2) saturate(1.1)
+    drop-shadow(0 0 1px rgba(255, 255, 255, 0.65));
+}
diff --git a/pyamplicol/docs/assets/pyamplicol_logo.png b/pyamplicol/docs/assets/pyamplicol_logo.png
new file mode 100644
index 0000000000..1db60f8a02
Binary files /dev/null and b/pyamplicol/docs/assets/pyamplicol_logo.png differ
diff --git a/pyamplicol/docs/assets/pyamplicol_mark.png b/pyamplicol/docs/assets/pyamplicol_mark.png
new file mode 100644
index 0000000000..76bf07c51f
Binary files /dev/null and b/pyamplicol/docs/assets/pyamplicol_mark.png differ
diff --git a/pyamplicol/docs/assets/pyamplicol_social_preview.png b/pyamplicol/docs/assets/pyamplicol_social_preview.png
new file mode 100644
index 0000000000..dfa3a759fe
Binary files /dev/null and b/pyamplicol/docs/assets/pyamplicol_social_preview.png differ
diff --git a/pyamplicol/docs/correlator-conventions.md b/pyamplicol/docs/correlator-conventions.md
new file mode 100644
index 0000000000..fb8d79d271
--- /dev/null
+++ b/pyamplicol/docs/correlator-conventions.md
@@ -0,0 +1,426 @@
+---
+title: "Correlation Conventions"
+parent: "Python API"
+nav_order: 5
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Conventions for spin- and colour-correlated Born quantities
+
+This page connects the notation of the
+[MadNkLO colour-correlator note](https://github.com/MadGraphTeam/pyamplicol/blob/80aec6f706c409b2f8f6c793dff8d8f04b118f7d/IMPLEMENTATION_DOCS/REFERENCES/ColorCorrelators_MadNkLO.pdf)
+to pyAmpliCol's [correlated API](correlators.md). In particular, it makes the
+bra/ket convention explicit: pyAmpliCol contracts the **adjoint of the bra
+connection with the ket connection**, rather than adopting the note's
+oriented, non-conjugated product unchanged.
+
+The implementation gives LC, NLC and full-colour tree-level quantities,
+evaluated at physical `N_c=3`. The order of a colour connection (NLO, NNLO,
+N3LO) is independent of this colour approximation.
+
+## Amplitudes, basis tensors, and correlated matrices
+
+| Symbol | Meaning |
+| --- | --- |
+| `N_c = 3` | Number of colours, not the size of the colour basis |
+| `c, d = 1, ..., N_basis` | Labels of the retained colour-basis tensors |
+| `h` | External helicity configuration, or spectator helicities after spin replacement |
+| `C_c` | A colour tensor, including its external colour indices |
+| `A[h,c]` | The coherent, complex partial amplitude in the generated convention |
+| `S_B`, `S_K` | Ordered colour connections applied on the bra and ket side |
+| `N` | The ordinary overall normalization, including any factored common coupling, averaging, and identical-particle factors |
+
+With momenta and model parameters left implicit, the definitions are:
+
+```text
+|M_h>       = sum_c A[h,c] |C_c>
+K[B,K][c,d] = < S_B C_c | S_K C_d >
+R[B,K]     = N sum_(h,c,d) conj(A[h,c]) K[B,K][c,d] A[h,d]
+```
+
+The matrix includes the process's colour normalization factors. Its entries
+are evaluated exactly as complex rational numbers at generation. At runtime,
+`R[B,K]` is returned as a `CorrelatedValue` with decimal real and imaginary
+parts. The ID `"born"` uses empty connections, giving the usual colour metric
+`<C_c|C_d>`.
+
+Only spectator helicities are summed incoherently. Colour components are
+combined **before squaring**, retaining their interference. Separate squared
+flow/helicity components are therefore not sufficient to reconstruct a
+general colour or spin correlation: their relative phases have been lost.
+
+For two different connections, neither an individual colour matrix nor its
+answer is assumed real or symmetric. Interchanging the bra and ket gives
+the Hermitian-conjugate matrix and the complex-conjugate answer:
+
+```text
+K[K,B] = K[B,K]†
+R[K,B] = conj(R[B,K])
+```
+
+At full colour, identical connections give a squared norm. This distinction
+also explains why an ordered connection should not be interpreted as a
+positive squared matrix element in every case.
+
+## Colour accuracy
+
+The selected `color.accuracy` applies to the correlated contraction, while the
+complete generated amplitude basis is retained. Empty connections use the
+existing ordinary colour-accuracy convention. The inserted matrix is built
+with symbolic powers of `N_c` before its selected coefficients are evaluated
+at three colours. Amplitude coefficients and incoming averages remain at
+physical `N_c=3`: this is the inherited colour-matrix approximation, not a
+new strict expansion of every part of the matrix element.
+
+For a Born basis with `n_g` adjoints and `n_qbarq` fundamental pairs, and a
+connection containing `r` operations of which `s` are gluon-to-quark-pair
+splittings on either side, the common reference power is
+
+```text
+P = n_g + n_qbarq + r - s.
+```
+
+LC keeps powers at least `P`. For purely adjoint final colour space, NLC
+keeps powers at least `P-2`. With fundamental lines, NLC retains the exact
+coefficient of an entry if its highest nonzero power is at least `P-2`, as
+in the ordinary open-line approximation. Intervening odd powers are included.
+Full colour retains all terms. The threshold is common to related connections,
+not reset to each entry's leading nonzero term. Born-metric zeros are not used
+to discard connected entries, and intermediate splitting terms are not pruned.
+
+Coherence and Casimir tests at approximate colour accuracy compare terms
+through the retained order. Keeping exact admitted NLC coefficients can leave
+residuals below that order; it does not imply exact finite-`N_c` cancellation
+of those extra terms. Full-colour identities hold without that truncation.
+LC/NLC matrices are approximations and are not generally positive operators.
+
+## Colour charges, indices, and crossing
+
+We use Hermitian physical generators with
+`tr(t^a t^b) = T_R delta(a,b)`, `T_R = 1/2`, and
+`[t^a,t^b] = i f^(abc) t^c`. In **output, input** index order the charges are:
+
+| All-outgoing representation | Charge matrix for emitted gluon colour `a` |
+| --- | --- |
+| Quark, `3` | `t^a[out,in]` |
+| Antiquark, `3bar` | `-t^a[in,out]` |
+| Gluon, `8` | `-i f^(a,out,in)` |
+
+These conventions give `C_F = (N_c^2-1)/(2 N_c) = 4/3` and `C_A = N_c = 3`.
+Internally, some colour-ordered tensors use generators `tau = sqrt(2) t`;
+the correlated matrices include that conversion. Do not supply an extra
+factor of two or `sqrt(2)` at runtime.
+
+All colour charges use the all-outgoing convention: an incoming quark is an
+outgoing antiquark for the colour algebra, and vice versa. Leg **labels do not
+change**: they remain one-based in the generated public process order,
+including colourless particles. The caller supplies normal physical incoming
+momenta and must not add another colour-crossing sign.
+
+At NLO,
+
+```text
+B_ij = N sum_h <M_h | T_i . T_j | M_h>
+     = N sum_(h,a) <T_i^a M_h | T_j^a M_h>
+```
+
+is requested as `ColorCorrelator.dipole("Tij", i, j)`. This is the quantity
+multiplying soft eikonal factors in a factorized soft limit. pyAmpliCol does
+not include the eikonal factor, its soft-limit sign, or the associated
+`4 pi alpha_s` factor in `B_ij`. Diagonal entries are retained: their eikonal
+coefficients vanish for massless legs but need not vanish for massive legs.
+
+## Ordered connections and auxiliary labels
+
+A connection is a chronological tuple of operations. If its entries are
+`(E1, E2, ..., Em)`, its action on a ket is `S = Em ... E2 E1`:
+the **first tuple entry acts first**. The bra is adjointed afterwards.
+Operations on the same colour line generally do not commute.
+
+`EmitGluon(i, x)` keeps emitter `i` and adds an adjoint leg `x`.
+`SplitGluon(x, q, qbar)` removes an adjoint parent `x` and replaces it with
+a fundamental leg `q` and an antifundamental leg `qbar`, through
+`t^a[q,qbar]`. New labels must be fresh, including with respect to retired
+parents. Born labels are positive and one-based; we recommend reserving fresh
+negative labels for auxiliary partons, although the operation classes do not
+enforce that sign convention. Auxiliary partons have **no additional Born
+phase-space momenta**. A later operation may act on an auxiliary leg
+only after that leg has been introduced.
+
+The note's four connection classes have the following direct API counterparts:
+
+| Class in the note | Chronological pyAmpliCol operations |
+| --- | --- |
+| A: emissions from different Born lines | `(EmitGluon(i, -1), EmitGluon(j, -2))`, `i != j` |
+| B: successive emissions from one Born line | `(EmitGluon(i, -1), EmitGluon(i, -2))` |
+| C: an emitted gluon emits another gluon | `(EmitGluon(i, -1), EmitGluon(-1, -2))` |
+| D: an emitted gluon splits into a quark pair | `(EmitGluon(i, -1), SplitGluon(-1, -2, -3))` |
+
+The algebra also permits splitting an active Born gluon. The note's
+soft-connection class D instead starts with an already-emitted gluon which
+can itself become soft; algebraic support for a Born-leg splitting does not
+imply a soft singularity of that hard leg.
+
+Thus the note's emission triple `(i, x, i)` becomes `EmitGluon(i, x)`.
+For a quark-pair splitting, the API explicitly names the two daughter
+representations and uses fresh daughter labels; it does not reuse the
+parent label as one daughter. When translating a whole pair of connections,
+relabel their final partons consistently on both sides.
+
+Explicit declarations keep the ordered lists as supplied and use user-chosen
+**string IDs for the requested pair**. The automatic catalogue described below
+instead indexes canonical chronological histories. Neither form attaches
+multiplicities to the result. In particular, do not apply the note's
+descending-label sort to a chain whose next emitter has not yet been created.
+
+Both sides must have the same order, with no fixed upper bound, and
+finish with identical labelled colour representations. A gluon-only final
+colour space cannot be contracted with a quark-pair colour space. Invalid
+pairs are rejected rather than returned as physical zeroes. One-, two-, and
+three-step connections supply NLO, NNLO, and N3LO colour structures; this is
+not a claim to supply the kinematic ingredients of an N3LO calculation.
+
+## Automatic generic catalogue
+
+`CorrelatorConfig.all_color(through_order=k)` registers every compatible
+ordered pair through orders 1,...,k, together with the ordinary Born. This is
+the generic construction of section 2 of the MadNkLO note, not a list of
+dipole products. Its soft scope permits gluon emission from any active
+coloured leg and quark-pair splitting of auxiliary gluons, but not splitting
+hard Born gluons automatically. The latter operation remains available
+explicitly. Colour roles are crossed to the all-outgoing convention by the
+generator, separately for each process.
+
+Let `S_m` be the set of histories with m operations, starting with the identity
+at m=0. From every history, append each allowed operation on every active leg.
+Emitted gluons and the daughters of a quark-pair splitting are also active
+emitters. Each operation increases the number of final auxiliary partons by
+one. At order m, assign their labels in every possible way to `-1,...,-m`.
+Retired intermediate parents receive separate dummy labels below `-m`.
+
+The spanning argument is constructive. A leading tree-level QCD soft current
+is a sum of forests rooted on the hard coloured lines. Its quark-gluon and
+three-gluon colour vertices are precisely the two supported operations;
+four-gluon colour factors are sums of products of two structure constants
+and can be resolved into successive binary operations. A topological traversal
+of any such forest is therefore visited by the recursion, including multiple
+quark pairs and every assignment of the labelled soft partons. It follows that
+
+```text
+J_m^(0) = sum_alpha j_alpha S_alpha^(m)
+N sum_h <M_h | J_m^(0)† J_m^(0) | M_h>
+    = sum_(alpha,beta) conjugate(j_alpha) j_beta B_(alpha,beta)
+```
+
+where `B_(alpha,beta) = R[S_alpha,S_beta]` in the notation above,
+with the unresolved-spin sums included when forming the physical squared
+quantity. `N` is the common Born normalization defined above.
+Chronological colour construction does **not**
+assume strongly ordered soft energies: simultaneous-soft kinematics and
+contact terms belong to the coefficients `j_alpha`. Flavour factors and
+identical-fermion exchange signs also belong to the physical current.
+This proves coverage of tree-soft colour tensors, not provision of loop
+amplitudes or the kinematic ingredients of a complete fixed-order calculation.
+For the factorization of the leading soft current see
+[Catani and Cieri, section 2](https://doi.org/10.1140/epjc/s10052-022-10001-z);
+the appearance of colour quadrupoles beyond dipoles at three soft gluons is
+discussed by [Catani, Colferai and Torrini](https://arxiv.org/abs/1908.01616).
+
+Canonicalization removes only independent chronological interleavings and
+dummy-name choices. It preserves the order on each emitter line and every
+creation-before-use dependency. In contrast to a blind descending-label sort,
+the stored representative is always executable. Colour-conservation, Jacobi
+and sign-related redundancies are retained; a minimal basis is not required.
+Finally, pair **all** canonical histories of the same order with identical
+final labels and representations. Both directed orders and self-pairs remain.
+There are no numerical multiplicity factors on these individual entries.
+
+Final-label assignments are essential even across different creation orders.
+For example, these N3LO histories interfere in the same final space
+`q(-1), qbar(-2), g(-3)`:
+
+```python
+left = (
+    EmitGluon(1, -4), SplitGluon(-4, -1, -2), EmitGluon(-1, -3),
+)
+right = (
+    EmitGluon(1, -3), EmitGluon(1, -4), SplitGluon(-4, -1, -2),
+)
+```
+
+Number the sorted histories independently at each order, starting from zero.
+The pair of history indices `(i,j)` at order r has ID `N{r}LO/c{i}/c{j}`.
+These are local indices for a particular process catalogue, not universal
+operator numbers or hashes. The full typed chronological `bra` and `ket`
+records are stored with the ID; retired-label conventions do not require any
+additional momenta. The available metadata is returned by
+`runtime.available_color_correlations()`, including `"born"` at order zero.
+The caller can inspect, select and combine entries without parsing ID strings.
+
+No perturbative-order cap is imposed. Detailed physics tests cover NLO through
+N3LO, with higher-order Casimir and two-pair checks. Enumeration tests compare
+the NNLO classes A--D, preserve noncommuting histories, and verify N3LO
+cross-order creation histories and N4LO two-pair relabelling. For n coloured
+Born legs the NNLO catalogue has `(n*n + 3*n)**2 + 2*n*n` directed pairs:
+108 for two legs and 816 for four. At N3LO four legs already give 90,720 pairs;
+the full automatic option trades a larger output for not choosing a subset.
+
+## Translating the note's non-conjugated convention
+
+The note's sections 2.1-2.2 keep orientations in the connection labels and do
+not conjugate the second connection. Our definition is instead
+`<S_B M|S_K M>`. Although the NLO dipoles agree once index directions are
+matched, beyond NLO one must translate the adjoint, the order of charges,
+fundamental/antifundamental orientations, and final-parton labels together.
+Copying two legacy connection IDs is not a defined conversion.
+
+The quark-pair example is particularly useful. Let
+
+```python
+from pyamplicol import ColorCorrelator, EmitGluon, SplitGluon
+
+pair = (EmitGluon(1, -1), SplitGluon(-1, -2, -3))
+request = ColorCorrelator("pair-self", bra=pair, ket=pair)
+```
+
+The API's self-overlap is nonzero in general. At full colour, conjugation
+pairs a fundamental index with its antifundamental partner and gives
+
+```text
+sum_(q,qbar) conj(t^a[q,qbar]) t^b[q,qbar] = T_R delta(a,b)
+R[pair,pair] = T_R B_11
+```
+
+For a quark emitter this is `(1/2)(4/3) B = (2/3) B`; for a gluon emitter
+it is `(1/2)(3) B = (3/2) B`, where `B` is the full-colour Born result.
+For LC/NLC these identities apply through the retained colour order, rather
+than as exact finite-`N_c` equalities between differently truncated matrices.
+This is not the zero of the note's oriented `(D.1,D.1)` pairing: that pairing
+does not represent the same adjointed contraction. With the generator
+normalization above, the closed pair trace is `T_R delta(a,b)`, not
+`C_F delta(a,b)`.
+
+`SplitGluon` represents **one labelled quark flavour**. Neither a flavour sum
+`n_f`, additional powers of the strong coupling, unresolved phase space,
+kinematic splitting functions, nor unresolved-particle symmetry factors are
+included. These belong to the application using the correlated Born.
+
+## Products and anticommutators with a shared colour line
+
+The note's double-soft example contains an anticommutator
+`{A,B} = AB + BA`, with `A = T_2 . T_3` and `B = T_1 . T_2`.
+The shared leg 2 makes the order important. In the API's adjointed convention,
+one valid construction is:
+
+```python
+bra = (EmitGluon(3, -1), EmitGluon(1, -2))
+ab = ColorCorrelator(
+    "AB", bra=bra,
+    ket=(EmitGluon(2, -2), EmitGluon(2, -1)),
+)
+ba = ColorCorrelator(
+    "BA", bra=bra,
+    ket=(EmitGluon(2, -1), EmitGluon(2, -2)),
+)
+# Include ab and ba in CorrelatorConfig.color_correlations before generation.
+```
+
+For `AB`, the ket acts as `T_2^a T_2^b`; the bra adjoint supplies
+`T_1^b T_3^a`. Charges on different Born legs commute, giving
+`T_2^a T_3^a T_1^b T_2^b = AB`, with `a,b` summed. Swapping the
+ket operations gives `BA`, without commuting the charges on leg 2.
+
+After generating and loading a runtime containing these IDs:
+
+```python
+from pyamplicol import CorrelatedRequest
+
+values = runtime.evaluate_correlated_many(points, {
+    "AB": CorrelatedRequest(color_correlation="AB"),
+    "BA": CorrelatedRequest(color_correlation="BA"),
+})
+anticommutator = tuple(
+    (x.real + y.real, x.imag + y.imag)
+    for x, y in zip(values["AB"], values["BA"], strict=True)
+)
+```
+
+There is no factor of `1/2` in this definition of the anticommutator.
+When combining high-precision `Decimal` results, use a decimal context with
+at least the requested precision. More general connection products should
+likewise be built at the tensor level, not by multiplying two Born overlap
+matrices: a nonorthogonal colour basis has a nontrivial metric, and a Born
+basis need not remain closed under an insertion.
+
+## Colour-coherence checks
+
+For a full-colour, colour-conserving Born amplitude, the standard checks are
+
+```text
+sum_j B_ij = 0                       (sum includes j = i)
+B_ii = C_i B                         (C_i = C_F or C_A)
+sum_(j != i) B_ij = -C_i B
+```
+
+The sum runs over all coloured Born legs, with incoming charges already
+crossed. A nontrivial connected tensor also obeys colour conservation, but
+now the sum includes **all its current coloured legs**, including emitted
+gluons or daughter quarks, but excluding a parent removed by a splitting.
+This gives iterative checks at NNLO and N3LO.
+One should not expect an unweighted sum over every distinct higher-order
+connection to vanish: those entries describe different emission histories,
+and sometimes different final colour spaces.
+
+The note also groups histories in which only Born legs emit gluons, its
+"abelian-like" subset. If commuting histories are collapsed to one canonical
+representative, the missing ordering multiplicity must be restored. With
+`m` emissions and `n_i` emissions on Born leg `i`, preserving the order on
+each individual line, this multiplicity is `m! / product_i(n_i!)`.
+At NNLO it is 2 for two distinct emitters and 1 for two emissions from the
+same emitter; at N3LO the corresponding patterns give 6, 3, and 1.
+These weights describe such a canonicalized sum; the API does not multiply
+individual requested correlations by them. They apply only after identifying
+genuinely equivalent labelled contractions: charges on a shared line must
+not be commuted, and any relabelling of an auxiliary index must be made
+consistently across the whole bra/ket contraction.
+
+For example, interchanging `EmitGluon(i, -1)` with `EmitGluon(j, -2)`
+commutes when `i != j` and their labels are kept attached to the same emitters.
+Changing the assignment to `EmitGluon(j, -1)` and `EmitGluon(i, -2)` is a
+different labelled map. Preserve these assignments, or define a consistent
+symmetrization on both sides, before using a weighted higher-order coherence
+sum from the note.
+
+## Spin contractions and Ward identities
+
+External spin states and vector components are four-dimensional. The API
+does not supply a full `d = 4 - 2 epsilon` spin tensor or the
+epsilon-dependent polarization averages of conventional dimensional
+regularization.
+
+For a declared external vector leg, the setter replaces its source by the
+literal contravariant vector `(v0, vx, vy, vz)`, using metric `(+,-,-,-)`.
+There is no normalization or transverse projection. In schematic notation,
+if the amplitude is `v^mu M_mu`, the same vector on the ket and its complex
+conjugate on the bra form the rank-one spin contraction. Distinct vectors on
+several declared legs act jointly, not as a product of separate squared
+matrix elements.
+
+No extra average over the supplied vectors is introduced. Original incoming
+spin/colour averages are retained, and unreplaced helicities are summed.
+The usual two-polarization completeness sum recovers the unpolarized
+massless-vector result. Scaling a single vector by `z` scales the answer by
+`abs(z)**2`.
+
+For a massless gauge boson, replacing its polarization by its momentum tests
+the Ward identity with the other gauge legs in physical transverse states;
+several momentum replacements are also allowed if their joint class was
+declared. The vanishing is not guaranteed if another gauge leg is instead
+given an arbitrary non-transverse source. This is a literal nonzero momentum
+source, not its
+projection onto physical helicities. A massive vector instead satisfies the
+appropriate Goldstone relation; it is not subject to the same zero test.
+The setter currently exposes rank-one contractions, not independent bra/ket
+vectors or a general spin-density tensor.
+
+See [Born Correlations](correlators.md) for runnable generation/evaluation
+examples, vector batching, reset behaviour, and the exact execution scope.
diff --git a/pyamplicol/docs/correlators.md b/pyamplicol/docs/correlators.md
new file mode 100644
index 0000000000..8fd42856ce
--- /dev/null
+++ b/pyamplicol/docs/correlators.md
@@ -0,0 +1,481 @@
+---
+title: "Born Correlations"
+parent: "Python API"
+nav_order: 4
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Tree-level spin and colour correlations
+
+For the mathematical definitions, charge normalization, emission ordering,
+and translation of the original MadNkLO note, see
+[Correlation Conventions](correlator-conventions.md).
+
+Correlations are an explicit generation-time option. Declare the colour
+operators and allowed joint spin replacements once, then select an operator
+by ID and supply numerical spin vectors at runtime. This provides
+four-dimensional tree-level correlated Born quantities, with a generic
+construction of ordered colour connections at any finite perturbative order.
+It is not restricted to NLO or NNLO. This is **not** a complete subtraction implementation: no
+loop amplitudes, kinematic splitting kernels, integrated counterterms, or
+extra-dimensional spin components are supplied.
+
+The correlated path supports **LC, NLC and full colour** through Python and
+the native C/C++/Fortran/Rust SDKs, with the approximation selected at generation. It retains the
+complete colour basis and uses direct contraction. Ordinary uncorrelated
+generation and evaluation are unchanged.
+
+## Generate and evaluate
+
+This small example uses the built-in Standard Model and a new output directory:
+
+```python
+from pyamplicol import (
+    ColorCorrelator, CorrelatorConfig, Generator, ModelSource, Runtime,
+)
+from pyamplicol.config import ColorConfig, RunConfig
+
+declarations = CorrelatorConfig(
+    color_correlations=(ColorCorrelator.dipole("T13", 1, 3),),
+    spin_correlations=((3,), (3, 4)),
+)
+config = RunConfig(action="generate", color=ColorConfig(accuracy="full"))
+result = Generator(config).generate(
+    "g g > g g",
+    "artifacts/gg_correlated",
+    model=ModelSource.built_in_sm(),
+    correlators=declarations,
+)
+runtime = Runtime.load(result.output)
+point = (
+    (500, 0, 0, 500),
+    (500, 0, 0, -500),
+    (500, 300, 0, 400),
+    (500, -300, 0, -400),
+)
+
+# "born" is always included: the ordinary full-colour overlap.
+born = runtime.evaluate_correlated((point,), precision=40)[0]
+colour = runtime.evaluate_correlated(
+    (point,), color_correlation="T13", precision=40,
+)[0]
+
+# Replace leg 3's polarization by a literal transverse four-vector.
+runtime.set_spin_correlation_vectors({3: (0, 0, 1, 0)})
+spin = runtime.evaluate_correlated((point,), precision=40)[0]
+spin_colour = runtime.evaluate_correlated(
+    (point,), color_correlation="T13", precision=40,
+)[0]
+print(born.real, colour.real, spin.real, spin_colour.real, spin_colour.imag)
+runtime.set_spin_correlation_vectors(None)
+```
+
+Thus `"born"` with no replacement gives the ordinary helicity-summed Born;
+`"T13"` with no replacement gives a colour correlation; `"born"` with vectors
+gives a spin correlation; and `"T13"` with vectors gives both together.
+`helicities=None` sums all spectator helicities. A global `helicities=` selector
+can instead restrict the physical helicity IDs, as for ordinary evaluation.
+
+The result is a tuple of `CorrelatedValue` objects, one per phase-space point.
+Each has `real` and `imag` fields of type `Decimal`; `precision` specifies
+decimal digits and defaults to 16. `complex(value)` is convenient but converts
+to ordinary double precision. An ordered colour correlation can be complex:
+do not discard its imaginary part before forming the intended physical
+combination. All calls use the runtime's current model parameters and
+normalization settings.
+
+## Several requests and several phase-space points
+
+Use `evaluate_correlated_many` to share amplitudes between requested operators,
+instead of calling `evaluate_correlated` in a loop. Requests are named by the
+caller; several names can select the same generated colour ID with different
+spin vectors. For the generated example above:
+
+```python
+from pyamplicol import CorrelatedRequest
+
+points = (point, point)  # Replace with any batch of distinct physical points.
+requests = {
+    "born": CorrelatedRequest(color_correlation="born", spin_vectors={}),
+    "dipole_13": CorrelatedRequest(color_correlation="T13", spin_vectors={}),
+    "spin_3": CorrelatedRequest(
+        color_correlation="born", spin_vectors={3: (0, 0, 1, 0)}
+    ),
+    "dipole_13_spin_3": CorrelatedRequest(
+        color_correlation="T13", spin_vectors={3: (0, 0, 1, 0)}
+    ),
+}
+values = runtime.evaluate_correlated_many(points, requests, precision=40)
+
+# Axis 1 is the request name; axis 2 is the original phase-space point index.
+entry = values["dipole_13_spin_3"][1]  # Second point, this specific contraction.
+print(entry.real, entry.imag)          # Decimal, preserving complex correlations.
+all_points_for_dipole = values["dipole_13"]
+all_requests_at_second_point = {name: series[1] for name, series in values.items()}
+assert all(len(series) == len(points) for series in values.values())
+```
+
+The returned dictionary preserves request order and each tuple preserves input
+point order. No result axis is flattened or summed over the requested IDs.
+Spectator helicities are still summed, or restricted by the batch-global
+`helicities` selector; they are not a third returned axis. Per-point spin
+vectors use the same vector-batch notation as the setter below.
+
+`spin_vectors=None` (the default) inherits a snapshot of the current setter
+state. An explicit `{}` instead requests physical helicities, even when the
+setter holds vectors. Request-local vectors do not change that state. All
+requests are validated before evaluation; an unknown colour ID or invalid spin
+class does not partially update the runtime.
+
+For each distinct spin assignment the amplitudes are calculated once and
+shared by all its colour requests. Across assignments, existing evaluation
+stages with exactly unchanged inputs can also be reused. This is stage-level
+sharing, not construction of a full spin-density tensor. Its benefit depends
+on which stages depend on the changed vectors. Numerical caches are local to
+the call and streamed point by point; parameter or precision changes on later
+calls cannot reuse an earlier numerical result.
+
+The standalone [local NLO limit example](https://github.com/MadGraphTeam/pyamplicol/blob/main/examples/NLO_limits/nlo_limit_stability_tests.py)
+uses both axes: all required dipoles are requested together, with the whole
+approach to an unresolved limit supplied as a phase-space batch.
+
+## Spin vectors and joint classes
+
+Leg labels are one-based, in the generated public process order, and components
+are contravariant `(v0, vx, vy, vz)` with metric `(+,-,-,-)`. Values may be real
+or complex. A four-vector broadcasts to every point; a sequence of four-vectors
+provides one vector per point:
+
+```python
+runtime.set_spin_correlation_vectors({3: ((0, 0, 1, 0), (0, 0, 2j, 0))})
+batch = runtime.evaluate_correlated((point, point), precision=40)
+
+runtime.set_spin_correlation_vectors({3: (0, 0, 1, 0), 4: (0, 0, 1, 0)})
+joint = runtime.evaluate_correlated((point,), precision=40)[0]
+runtime.set_spin_correlation_vectors({})  # Reset; None is equivalent.
+```
+
+### Decimal inputs and double-double arithmetic
+
+Supply `Decimal` components directly when their digits matter. For a complex
+component, use a `(real, imaginary)` pair of `Decimal` values; constructing a
+Python `complex` first would round both parts to binary64. The setter and
+`CorrelatedRequest.spin_vectors` both preserve these inputs until evaluation:
+
+```python
+from decimal import Decimal
+from pyamplicol import CorrelatedRequest
+
+zero = Decimal(0)
+vector = (zero, zero, (
+    Decimal("1.0000000000000000000000001"),
+    Decimal("0.0000000000000000000000002"),
+), zero)
+runtime.set_spin_correlation_vectors({3: vector})
+arb = runtime.evaluate_correlated((point,), precision=80)
+dd = runtime.evaluate_correlated(
+    (point,), arithmetic="double-double", precision=31,
+)
+grouped = runtime.evaluate_correlated_many(
+    (point,), {"spin_dipole": CorrelatedRequest("T13", {3: vector})},
+    arithmetic="double-double", precision=31,
+)
+print(grouped["spin_dipole"][0].real)  # Decimal result, no float conversion.
+runtime.set_spin_correlation_vectors(None)
+```
+
+The default `arithmetic="arbitrary"` uses arbitrary-precision arithmetic at
+the requested decimal precision. `arithmetic="double-double"` explicitly
+selects genuine Symbolica DoubleFloat arithmetic for sources, retained
+evaluation stages, colour contraction and normalization; `precision` then
+controls output rounding and must not exceed 31 digits. Inputs finer than
+that are rounded when entering DoubleFloat, not when defining the vector.
+Both modes return `Decimal` real/imaginary parts. Supply `Decimal` momenta as
+well when kinematic input accuracy beyond binary64 is needed. Native SDK
+correlated calls are binary64 only; the Python arithmetic selection does not
+change their numerical type.
+
+The nonempty set of supplied legs must match a declared class **exactly**.
+Here `{3}` and `{3, 4}` are allowed, but `{4}` is not. Every declared leg must
+be a spin-1 source with four components. Batch lengths must match the number
+of evaluated points. State belongs to each `Runtime` instance; setters copy
+their inputs, and a failed setter leaves the previous vectors intact.
+
+Vectors replace the external source literally, including its temporal
+component. They are not normalized, projected onto helicity states, or
+conjugated on input; the existing source crossing phase is applied once.
+Use physical incoming/outgoing momenta in their normal public ordering, with
+no manual crossing of the supplied vectors. The same vector enters the
+amplitude and is conjugated through the bra, giving a rank-one spin
+contraction. Joint replacements contract the same amplitude with several
+vectors; they are not products of separate one-leg results. Independent
+bra/ket spin vectors and full spin-density tensors are not exposed.
+
+Each replaced leg counts once; spectator helicities are summed incoherently.
+The original incoming-spin and colour averages and identical-particle factors
+are retained, without an extra average over supplied vectors. Vector magnitude
+is preserved: scaling one vector by `z` scales the correlation by `abs(z)**2`.
+For a physical massless polarization choose `p.v = 0`; no such condition is
+enforced by the setter. Setting, for example, `{3: point[2]}` supplies a literal
+nonzero momentum vector for a Ward-identity check. Its vanishing is a
+massless gauge-boson statement, not a generic test for massive vectors.
+
+## Automatically register every colour correlation through N^kLO
+
+Use `CorrelatorConfig.all_color(through_order=k)` when the required subset is
+not known in advance. For example, this prepares every compatible pair of
+one- and two-operation tree-soft colour connections, including the Born:
+
+```python
+declarations = CorrelatorConfig.all_color(
+    through_order=2,  # 1: NLO; 2: through NNLO; 3: through N3LO; any k >= 1.
+    spin_correlations=((3,),),
+)
+config = RunConfig(action="generate", color=ColorConfig(accuracy="full"))
+result = Generator(config).generate(
+    "g g > g g", "artifacts/gg_all_correlations",
+    model=ModelSource.built_in_sm(), correlators=declarations,
+)
+runtime = Runtime.load(result.output)
+
+catalogue = runtime.available_color_correlations()
+for entry in catalogue:
+    print(entry.id, entry.order, entry.bra, entry.ket)
+
+# Every NNLO component, at every point, in one grouped call.
+requests = {
+    entry.id: CorrelatedRequest(entry.id, spin_vectors={})
+    for entry in catalogue if entry.order == 2
+}
+values = runtime.evaluate_correlated_many(points, requests, precision=40)
+first_id = next(iter(requests))
+print(values[first_id][0].real, values[first_id][0].imag)
+```
+
+Here `points` is a batch of four-leg phase-space points as above. The catalogue
+is specific to the selected process and includes `"born"` at order zero.
+Listing it loads the stored declarations and matrices but does not initialize
+amplitude evaluation. The ordinary `evaluate` path is unchanged.
+
+This is **not** a factory for products of dipoles. At each step every active
+coloured leg can emit; an emitted gluon can also split into a quark pair, and
+its daughters can radiate later. Every final unresolved-label assignment is
+included. The factory pairs all histories of the same order with identical
+labelled final representations, including both directed orders and self-pairs.
+It follows the note's soft-current construction: hard Born-gluon splitting is
+not included automatically, but remains available in explicit declarations.
+
+The recursion has no fixed order cap. Its complete, nonminimal catalogue grows
+rapidly with order and multiplicity; it can be much larger than a chosen
+subtraction basis. Chronology is the order of colour operations, **not** an
+assumption of strongly ordered soft energies. The kinematic current, flavour
+weights and identical-fermion exchange signs remain the caller's responsibility.
+See the [completeness argument and encoding](correlator-conventions.md#automatic-generic-catalogue).
+
+Automatic IDs have the form `N{r}LO/c{i}/c{j}`, with zero-based connection
+indices `i,j` in the sorted order-`r` catalogue. They are process-local labels,
+not universal operator names: inspect `bra` and `ket` to identify the physics.
+For manually declared operators, IDs remain arbitrary user-chosen strings.
+Both forms can be combined with
+`CorrelatorConfig(color_correlations=(...), all_color_through_order=k)`;
+the `N{r}LO/c{i}/c{j}` ID namespace is reserved when automatic registration
+is enabled, so conflicts are rejected before generation starts.
+
+The equivalent CLI declaration is simply:
+
+```json
+{"all_color_through_order": 3, "spin_correlations": [[3]]}
+```
+
+Pass this file to the existing `generate ... --correlators correlators.json`
+option. Expansion happens separately for each generated process, using its
+actual coloured leg labels and crossed representations.
+
+## Ordered colour connections
+
+`ColorCorrelator.dipole("T13", 1, 3)` prepares
+`<M | T_1 . T_3 | M>`. More general requests supply ordered `bra` and `ket`
+operations, with the same number of steps on each side and no fixed order cap:
+
+```python
+from pyamplicol import EmitGluon, SplitGluon
+
+cascade = (
+    EmitGluon(1, -1),       # Emitter, new gluon label.
+    SplitGluon(-1, -2, -3), # Parent gluon, new quark, new antiquark.
+    EmitGluon(-2, -4),      # A later step may act on an emitted leg.
+)
+request = ColorCorrelator("cascade", bra=cascade, ket=cascade)
+# Include request in color_correlations before generating the artifact.
+```
+
+For example, the following declares two- and three-step gluon connections with
+different emitters on the bra and ket:
+
+```python
+bra = (EmitGluon(1, -1), EmitGluon(2, -2), EmitGluon(-1, -3))
+ket = (EmitGluon(3, -1), EmitGluon(4, -2), EmitGluon(-2, -3))
+declarations = CorrelatorConfig(color_correlations=(
+    ColorCorrelator("double", bra=bra[:2], ket=ket[:2]),
+    ColorCorrelator("triple", bra=bra, ket=ket),
+    request,
+))
+result = Generator().generate(
+    "g g > g g", "artifacts/gg_higher_correlations",
+    model=ModelSource.built_in_sm(), correlators=declarations,
+)
+runtime = Runtime.load(result.output)
+double = runtime.evaluate_correlated((point,), color_correlation="double")[0]
+triple = runtime.evaluate_correlated((point,), color_correlation="triple")[0]
+```
+
+These two- and three-step connections supply NNLO and N3LO **colour
+structures**, respectively; the corresponding subtraction kinematics and
+splitting functions remain the caller's responsibility.
+
+Positive labels identify Born legs; fresh negative labels identify auxiliary
+particles. Both sides must have the same number of steps and finish with the
+same labelled colour representations. These are colour operations only:
+**do not add unresolved momenta** to the Born phase-space input. Prepare only
+the IDs you need; IDs must be unique and `"born"` is reserved.
+
+The convention is explicitly **bra-adjoint times ket**. For connected basis
+tensors, `K[c,d] = <C_bra,c | C_ket,d>` and the runtime computes
+`normalization * sum_h,c,d conjugate(A[h,c]) * K[c,d] * A[h,d]`.
+The full directed matrix is used, without assuming Hermiticity. Physical
+SU(3) generators satisfy `tr(t^a t^b) = delta(a,b)/2`; colour roles use the
+all-outgoing convention, with incoming fundamental representations crossed
+by generation. No additional crossing sign should be supplied by the caller.
+`SplitGluon` represents one labelled quark flavour with physical `T_R = 1/2`;
+no flavour sum (`n_f`), extra `g_s` factors, unresolved phase-space factors, or
+symmetry multiplicities are included automatically.
+Build higher connections from ordered operations, not by multiplying Born
+overlap matrices: those matrices are not action matrices in an orthonormal
+closed basis.
+
+## JSON and command line
+
+The equivalent declaration file `correlators.json` is:
+
+```json
+{
+  "color_correlations": [
+    {
+      "id": "T13",
+      "bra": [{"kind": "emit-gluon", "emitter": 1, "emitted": -1}],
+      "ket": [{"kind": "emit-gluon", "emitter": 3, "emitted": -1}]
+    }
+  ],
+  "spin_correlations": [[3], [3, 4]]
+}
+```
+
+```console
+pyamplicol generate 'g g > g g' artifacts/gg_correlated_cli \
+  --model built-in-sm --color-accuracy full --correlators correlators.json
+```
+
+`CorrelatorConfig.to_json_dict()` and `from_json_dict()` use this same schema.
+A splitting step uses `{"kind": "split-gluon", "parent": -1,
+"quark": -2, "antiquark": -3}`. The CLI option prepares the artifact;
+numerical vector setting and correlated evaluation use Python or the native
+SDKs rather than the CLI `evaluate` command.
+
+## Native correlated evaluations
+
+The `correlators` development branch provides binary64 correlated evaluation
+in C, C++, Fortran and standalone Rust. These entry points use RustiCol and do
+not load Python or Symbolica. Python's separate executor supports
+double-double and arbitrary precision. See [Native APIs](user/native-apis.md#correlated-born-evaluations)
+for the language-specific owned request types, catalogue enumeration, spin
+setter and result indexing.
+
+The complete native examples evaluate the Born overlap, a mixed
+adjoint/fundamental N3LO interference and its spin-correlated counterpart
+together over two points. Generate their input with:
+
+```python
+from pyamplicol import ColorCorrelator, CorrelatorConfig, EmitGluon
+from pyamplicol import Generator, ModelSource, ProcessSet
+from pyamplicol.config import ColorConfig, RunConfig
+
+alpha = (EmitGluon(2, -3), EmitGluon(-3, -1), EmitGluon(-3, -2))
+beta = (EmitGluon(1, -1), EmitGluon(3, -2), EmitGluon(4, -3))
+declarations = CorrelatorConfig(
+    color_correlations=(ColorCorrelator("cascade-interference", alpha, beta),),
+    spin_correlations=((5,),),
+)
+config = RunConfig(action="generate", color=ColorConfig(accuracy="full"))
+Generator(config).generate(
+    ProcessSet.from_expressions(("d d~ > d d~ g",), names=("dd_ddg",)),
+    "artifacts/native_correlated", model=ModelSource.built_in_sm(),
+    correlators=declarations,
+)
+```
+
+The auxiliary gluon emitted from leg 2 radiates twice in `alpha`; `beta`
+attaches three gluons to distinct quark or antiquark legs. Their final auxiliary colour
+labels match, so their overlap is the interference, not the square of either
+history. With the matching development SDK installed, run from the checkout:
+
+```console
+make -C examples/native correlated
+examples/native/correlated_cpp artifacts/native_correlated dd_ddg
+examples/native/correlated_fortran artifacts/native_correlated dd_ddg
+examples/native/correlated_rust artifacts/native_correlated dd_ddg
+examples/native/correlated_c artifacts/native_correlated dd_ddg
+```
+
+Each reports `VALUE request_index point_index real imaginary`, with zero-based
+indices and request order Born, colour interference, colour-plus-spin
+interference. The programs also demonstrate reading catalogue IDs and full
+histories, supplying default spin vectors, clearing them, and keeping ordinary
+evaluation unchanged. C/C++/Rust grouped result access is request then point;
+Fortran's natural array layout is `values(point,request)`.
+
+## Colour accuracy and execution scope
+
+| Requested quantity | Correlated support |
+| --- | --- |
+| Full colour | Exact SU(3) colour matrices, including interference |
+| Leading colour (LC) | Leading powers of the inserted colour matrix |
+| Next-to-leading colour (NLC) | Inherited first-subleading colour-matrix approximation |
+
+`color.accuracy` (CLI `--color-accuracy lc|nlc|full`) selects the correlated
+answer at generation. The ordinary default is LC; specify `full` explicitly
+for exact SU(3) contractions, as above. Passing `correlators=` still selects
+direct contraction and generic compiled amplitudes and disables unsupported
+reductions, recording those adjustments in the effective configuration.
+There is no runtime colour-accuracy or single-flow selector for either
+correlated method. Generate separate outputs to compare accuracies.
+
+The underlying amplitude output remains complete and full-colour. Ordinary
+`Runtime.evaluate` on it therefore evaluates that underlying full-colour
+process; use `evaluate_correlated(..., color_correlation="born")` for the
+Born result at the requested correlated accuracy. See
+[the colour-accuracy convention](correlator-conventions.md#colour-accuracy)
+for the inherited LC/NLC prescription and its retained-order checks.
+
+Correlated generation selects complete full-colour, direct, generic compiled
+amplitudes and disables helicity-specific zero/parity reductions and current
+reuse that would invalidate arbitrary source vectors. Python correlated
+evaluation uses a separate exact executor over retained Symbolica evaluator
+states. Native SDK correlated evaluation uses RustiCol's binary64 coherent
+amplitude executor. Both share amplitudes and unchanged stages between
+requests and contract the generation-time colour matrices directly; neither
+uses FFT or physical-helicity reductions for the correlated result.
+
+FFT, recurrence, on-the-fly execution, replay-based reductions, nonidentity
+process aliases/permutations, partial helicity/colour generation, and append
+mode are not supported by this correlation path. Existing artifacts without
+the explicit declaration cannot be upgraded merely by setting vectors.
+Ordinary generation and `Runtime.evaluate(...)` are unchanged; setting spin
+vectors affects only `evaluate_correlated(...)` and inherited requests in
+`evaluate_correlated_many(...)`.
+
+## References
+
+The [archived MadNkLO note](https://github.com/MadGraphTeam/pyamplicol/blob/80aec6f706c409b2f8f6c793dff8d8f04b118f7d/IMPLEMENTATION_DOCS/REFERENCES/ColorCorrelators_MadNkLO.pdf)
+and [MadNkLO source at revision 646a3db](https://github.com/madnklo/madnklo/tree/646a3db9c8efd7b4cb00e9d89b9197cd5394c01b)
+provide background. The note's oriented, non-conjugated connections are not
+the runtime's literal bra-adjoint/ket convention: translate adjoints,
+orientations, signs, and phases before comparing individual ordered entries.
diff --git a/pyamplicol/docs/development/API_CONTRACT.md b/pyamplicol/docs/development/API_CONTRACT.md
new file mode 100644
index 0000000000..65c6c92f1f
--- /dev/null
+++ b/pyamplicol/docs/development/API_CONTRACT.md
@@ -0,0 +1,357 @@
+---
+title: "Public API Contract"
+nav_order: 1
+parent: "Development Documentation"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Public API Contract
+
+This document is normative for Python API version 1. Implementations may add
+private helpers but may not widen the package-root export list without an API
+review.
+
+## Package-Root Exports
+
+`pyamplicol` exports:
+
+- Model and process types: `ModelSource`, `CompiledModel`, `CompiledModelInfo`,
+  `CompiledModelSource`, `CompiledModelCapabilities`,
+  `ModelCompilationIssue`, `ModelCompilationPhase`, `ProcessRequest`, and
+  `ProcessSet`.
+- Configuration: `RunConfig`, `GenerationConfig`, `EvaluationConfig`, and
+  `BenchmarkConfig`.
+- Correlation declarations: `CorrelatorConfig`, `ColorCorrelator`, `EmitGluon`,
+  and `SplitGluon`.
+- Services: `Generator`, `Runtime`, and `BenchmarkRunner`.
+- Results: `GenerationPlan`, `GenerationResult`, `BenchmarkResult`,
+  `BenchmarkStatistics`, `BenchmarkComponentTiming`, `BenchmarkStageTiming`,
+  `BenchmarkTimingBreakdown`, `BenchmarkProfileCounters`, `ProcessPhysics`, `ExternalParticle`,
+  `HelicityConfiguration`, `ColorComponent`, `ColorFlow`,
+  `ContractedColorComponent`, `PhysicsReduction`, `ReductionGroup`,
+  `ModelParameter`, `ResolvedEvaluation`, and `CorrelatedValue`.
+- Process metadata: `ProcessAlias`.
+- Helpers: `generate`, `load`, and `benchmark`.
+- Package metadata: `__version__`.
+- Errors: `PyAmpliColError`, `ConfigurationError`, `ModelError`,
+  `GenerationError`, `ArtifactError`, `CompatibilityError`,
+  `EvaluationError`, and `DependencyError`.
+
+No DAG, evaluator, stage, color-sector, Symbolica, or legacy-reference class is
+exported from the package root.
+
+## Model And Process Requests
+
+`ModelSource.built_in_sm()` identifies the built-in Standard Model.
+`ModelSource.from_path(path, restriction=None, simplify=True)` accepts a UFO
+directory, serialized JSON, or compiled-model file and records a resolved
+source kind without importing Symbolica.
+
+`ModelSource.compile(*, cache_dir=None, use_cache=True,
+require_supported=True, prepared_output=None, evaluator=None) -> CompiledModel`
+is the explicit public model compilation operation. `prepared_output` may also
+write a reusable prepared-model bundle using the supplied typed evaluator
+configuration. `CompiledModel` is an opaque immutable handle accepted by
+generation; compiler-owned expression and tensor IR remain private.
+`CompiledModel.info` exposes stable typed source, capability, parameter,
+diagnostic, and phase-timing records. Convenience properties mirror those
+records, while `write(path)` serializes the complete private payload and
+`write_parameter_card(path)` writes mutable external-parameter defaults.
+
+`ProcessRequest.parse(expression, *, name=None)` validates one process string.
+`ProcessSet` contains a non-empty tuple of uniquely named requests and
+explicit aliases. At runtime, stored aliases and uniquely inferred
+side-preserving permutations use the same Rusticol mapping; incoming and
+outgoing legs never cross the process boundary. Public physics, helicity,
+color-flow, reduction, and momentum ordering follow the requested expression,
+while internal representatives remain hidden.
+
+## Generation
+
+`Generator(config=None, progress=None)` accepts immutable typed configuration
+or a `ConfigResolution`, plus an optional typed progress sink. Passing the
+resolution preserves requested and effective TOML plus every clamp reason in
+the generated artifact.
+
+`Generator.plan(processes, *, model=None) -> GenerationPlan` is strictly
+non-writing: it creates no model-cache or output files, directories, locks, or
+temporary trees. It expands concrete processes and validates structural color
+coverage without compiling a model, process DAG, evaluator, or artifact. A
+built-in model, `CompiledModel`, or compiled-model file can always be planned.
+For a UFO/JSON `ModelSource`, planning may read a valid existing model-cache
+entry but never populates one; on a cache miss callers must first invoke
+`ModelSource.compile()` and pass the returned `CompiledModel`.
+
+Planning performs the same effective Symbolica license and resource resolution
+as generation. Restricted mode clamps generation workers and Symbolica cores
+to one. Licensed mode partitions the affinity-aware CPU budget after concrete
+process expansion. `GenerationPlan.requested_settings` and
+`GenerationPlan.effective_settings` retain both typed configurations, while
+`GenerationPlan.adjustments` contains typed `ConfigClamp` values with the
+requested value, effective value, path, and reason. `generate --dry-run` uses
+this operation and has identical non-writing behavior.
+
+`Generator.generate(processes, output, *, model=None, mode="error", correlators=None)
+-> GenerationResult` writes a transactional schema-v3 artifact. `mode` is
+`error`, `append`, or `replace`. Both `model` arguments accept a `ModelSource`,
+the canonical `CompiledModel`, or `None` for the configured/default source.
+
+`generate(processes, output, *, model=None, mode="error", config=None,
+progress=None, correlators=None)` is a convenience wrapper with the same
+generation semantics.
+
+### Correlation declarations
+
+`correlators=None` leaves ordinary generation unchanged. Passing
+`CorrelatorConfig(color_correlations=(), spin_correlations=(),
+all_color_through_order=None)` opts into tree-level correlated Born generation.
+This declaration is separate from `RunConfig` and is not an argument to
+`Generator.plan()`.
+
+`ColorCorrelator(id, bra=(), ket=())` names an ordered pair of colour
+connections; `ColorCorrelator.dipole(id, left_leg, right_leg)` requests
+`<M|T_left . T_right|M>`. Connection steps are `EmitGluon(emitter_label,
+emitted_label)` or `SplitGluon(parent_label, quark_label, antiquark_label)`.
+There is no fixed step-count cap; both sides have the same step count, and
+their final labelled colour representations must agree. Born legs use public
+one-based labels; emitted auxiliary labels must be fresh. Colour IDs must be
+unique; `"born"` is reserved and always supplies the ordinary overlap.
+`spin_correlations` declares the exact nonempty sets of four-component vector
+legs that may be replaced simultaneously. `CorrelatorConfig.to_json_dict()`
+and `from_json_dict()` implement the CLI declaration-file schema.
+
+`CorrelatorConfig.all_color(*, through_order, spin_correlations=())` accepts
+a positive integer order `k` and resolves a complete, nonminimal tree-soft
+catalogue at orders 1 through `k` separately for each process. Every active
+coloured leg can emit; only auxiliary gluons split automatically. All compatible
+directed bra/ket pairs are included, without numerical multiplicity or flavour
+weights. Catalogue size grows rapidly. IDs of the form `N{k}LO/c{i}/c{j}` are
+reserved when automatic generation is enabled; explicit requests may use other
+IDs alongside `all_color_through_order`.
+
+The correlation path applies the requested LC/NLC/full colour accuracy to
+the inserted matrices while generating complete full-colour amplitudes.
+It records `direct` contraction, `compiled` execution, and disabled numerical
+current reuse as configuration adjustments where needed. It preserves arbitrary vector-source dependence
+without helicity-specific parity/zero reductions or replay. Partial
+colour/helicity generation, nonidentity process permutations, and append mode
+are unsupported. A previously generated ordinary artifact cannot acquire this
+capability merely by setting spin vectors. See
+[Born Correlations](../correlators.md) for conventions and examples.
+
+## Runtime
+
+`Runtime.load(artifact, *, process=None, model_parameters=None,
+mute_warnings=False) -> Runtime` validates the schema and identity-contract
+marker, confined references, target, and ABI before loading executable state.
+Call `pyamplicol.artifacts.validate_payloads()` for an explicit full checksum
+audit.
+
+`Runtime.physics` returns `ProcessPhysics` with stable particles, physical
+helicity IDs, physical color-flow IDs, contraction metadata, coverage, and
+selector capabilities. LC advertises `("helicity", "color_flow")`; NLC/full
+advertise only `("helicity",)`. Their singleton contracted-color output axis is
+metadata, not a selectable color flow. For an on-the-fly runtime, requesting
+`physics` explicitly materializes the complete compact helicity and color-flow
+axes and retains that compatibility view until the runtime is released;
+`Runtime.clear()` does not discard it.
+
+`Runtime.artifact_id` returns the lowercase 64-hex manifest identity
+authenticated by the native loader. `Runtime.execution_mode` returns exactly
+`"compiled"`, `"eager"`, `"recurrence"`, or `"on-the-fly"` from authenticated
+runtime metadata. Both fail with `EvaluationError` when an injected backend
+cannot supply a valid identity.
+
+`Runtime.inspect() -> Mapping[str, object]` is the compact, observational
+inspection path implemented by the built-in backend. It returns the
+authenticated native metadata without opening `Runtime.physics`, together with
+the live on-the-fly retained-state census when applicable. The OTF metadata
+includes requested and host-effective query-construction thread counts, and its
+inspection advertises `supported_precisions == (16,)`. Inspection is an optional
+facade capability rather than a structural requirement of `RuntimeBackend`:
+keeping it and the identity properties outside the protocol's original minimum
+surface preserves compatibility with third-party backends.
+The OTF state reports `family_cache_policy == "last-family-only"` and
+`family_cache_limit == 1`; its semantic executor binding count is the exact
+current-family binding cardinality rather than an all-seen cumulative count.
+
+`Runtime.evaluate(momenta, *, helicities=None, color_flows=None,
+helicity_by_point=None, color_flow_by_point=None, precision=16)` returns one
+fully summed value per point. Global and per-point selectors are mutually
+exclusive within each selector dimension. Momenta have shape
+`(point, particle, [E, px, py, pz])`. On-the-fly execution currently supports
+only `precision=16` (native f64); every other precision fails before selector
+resolution or dense metadata access.
+
+`Runtime.warm_up(momenta, *, precision=16, helicities=None,
+color_flows=None, progress=None, n_cores=None) -> WarmUpResult` is available only for OTF
+runtimes. `momenta` must contain exactly one binary64 phase-space point. The
+operation transactionally constructs and retains the selected family, performs
+its first evaluation, and reports elapsed time, total/new query counts, cache
+reuse, and optional current/peak RSS. The optional `ProgressSink` observes
+process preparation, query-family construction, family finalization, and first
+evaluation. LC accepts helicity/flow selectors; contracted NLC/full accepts
+helicity selectors only.
+`n_cores` is a positive integer overriding the process's construction-worker
+setting for this call; `None` retains that setting. Booleans, nonintegers, and
+nonpositive counts are rejected. Query traces are constructed with bounded
+parallelism, then merged serially. The override is not persisted and does not
+change cache identity, family reuse, or later evaluation threading.
+
+`Runtime.save(path) -> None` and `Runtime.load_cache(path) -> None` are
+optional facade capabilities implemented by the native OTF backend. They
+write and restore the currently retained completed structural cache, including
+its selection and reduction mappings. Restoration requires a compatible
+loaded process, rebinds its prepared kernels, and preserves its current model
+parameters. Invalid snapshots leave the existing cache unchanged. Snapshots
+contain neither evaluated currents nor native addresses, and do not resume
+an unfinished construction. Ordinary non-OTF evaluation is unchanged.
+The Rust core and C/C++/Fortran/Rust SDKs expose the same operations.
+
+`Runtime.evaluate_resolved(momenta, *, helicities=None, color_flows=None,
+precision=16) -> ResolvedEvaluation` returns LC values with shape `(point,
+physical_helicity, physical_color_flow)` and NLC/full values with shape
+`(point, physical_helicity, 1)`. `ResolvedEvaluation.total()` must reproduce
+`evaluate()`.
+
+`Runtime.set_spin_correlation_vectors(vectors)` sets the numerical vectors for
+`evaluate_correlated()` and inherited requests in `evaluate_correlated_many()`.
+`vectors` maps public one-based leg labels to
+literal real or complex contravariant `(v0, vx, vy, vz)` vectors, or one such
+vector per evaluated point. Its nonempty key set must exactly match a declared
+spin class. Inputs are copied; invalid updates leave the old state intact.
+Vectors are neither normalized nor projected nor conjugated on input. `None`
+or `{}` restores ordinary helicity sources. These settings never change
+`evaluate()` or `evaluate_resolved()`.
+
+`Runtime.available_color_correlations() -> tuple[ColorCorrelator, ...]` lists
+the selected process's resolved operators, including `"born"`. Each record
+exposes `id`, `order`, `bra`, and `ket`. Listing reads and validates the stored
+catalogue without initializing the amplitude executor; original leg ordering
+and a correlation-enabled artifact are required.
+
+`Runtime.evaluate_correlated(momenta, *, color_correlation="born",
+helicities=None, precision=16, arithmetic="arbitrary") -> tuple[CorrelatedValue, ...]` selects a declared
+colour ID and returns one value per point using the current model parameters
+and spin vectors. Global helicity IDs or `HelicityConfiguration` records may
+be selected; LC-flow and per-point selectors are not arguments to this method.
+`CorrelatedValue.real` and `.imag` are `Decimal` values at the requested decimal
+precision; `complex(value)` converts to binary64. The full directed
+bra-adjoint/ket contraction may be complex. Each replaced spin leg counts
+once, spectator helicities are summed incoherently, and ordinary initial-state
+averages and identical-particle factors remain in place.
+
+`Runtime.evaluate_correlated_many(momenta, requests, *, helicities=None,
+precision=16, arithmetic="arbitrary") -> dict[str, tuple[CorrelatedValue, ...]]` accepts an ordered
+mapping of user result labels to `CorrelatedRequest` records. Each record has
+`color_correlation="born"` and `spin_vectors=None` defaults. `None` inherits a
+snapshot of the setter; `{}` explicitly selects physical helicities. Request
+vectors are copied and validated without changing setter state. Request labels
+are distinct from generated colour IDs, allowing several spin projections of
+one colour operator. The output preserves label order and input point order;
+`values[label][point_index].real` and `.imag` select a single component.
+Every series has `len(momenta)` entries. Spectator helicities are summed or
+selected globally, not an additional output axis.
+
+Both methods accept `arithmetic="double-double"` for genuine DoubleFloat
+arithmetic with at most 31 output digits (`precision=31`). Their default
+`"arbitrary"` retains arbitrary precision. Spin-vector real components may be
+`Decimal`; complex components may be `(Decimal(real), Decimal(imaginary))`
+pairs. Setter and request validation preserve their digits until conversion
+to the selected arithmetic, and results always use plain `Decimal` fields.
+
+Identical spin assignments share coherent amplitudes across colour IDs;
+unchanged complete stage inputs can share stage outputs across assignments.
+Numerical sharing is exact, signed-zero preserving, call-local and streamed
+point by point. There is no persistent numerical cache or full spin-response
+tensor. The underlying ordinary `evaluate()` remains full-colour; the
+correlated `"born"` request uses the chosen correlated accuracy.
+
+Python correlated evaluation uses the Symbolica-backed exact executor even
+at `precision=16`. The C/C++/Fortran/Rust SDKs provide a separate binary64
+RustiCol executor, catalogue enumeration, spin defaults and grouped requests.
+Both paths require an explicitly correlated artifact and its original leg
+ordering; both use the generation-time LC/NLC/full inserted colour matrices.
+Native results are complex and request-major, with point-major Fortran array
+access `values(point,request)`. Native APIs do not expose Python's arbitrary
+precision or double-double arithmetic. Recurrence, eager, on-the-fly and FFT
+correlated evaluation remain unsupported. See [Native APIs](../user/native-apis.md#correlated-born-evaluations)
+for the typed SDK request and spin-vector conventions.
+
+`Runtime.set_model_parameters(mapping)` validates the complete update before
+committing it. `set_model_parameter(name, value)` is a convenience wrapper.
+`mute_warnings()` and `unmute_warnings()` modify only that runtime handle.
+`Runtime.clear()` discards warmed OTF process/family/scratch state while
+retaining the loaded artifact, current model parameters, and any already
+materialized `physics` compatibility view. It is a no-op for recurrence,
+compiled, and eager ordinary execution state. If a correlated evaluator has
+been initialized, `clear()` additionally releases its loaded stage/amplitude
+evaluators while retaining declarations, colour matrices, and current spin
+vectors. The next correlated call reloads that state; use
+`set_spin_correlation_vectors(None)` to reset the vectors themselves.
+
+`load(...)` is an alias for `Runtime.load(...)`.
+
+## Benchmarking
+
+`BenchmarkRunner(config=None, progress=None).run(target, *, points=None)
+-> BenchmarkResult` accepts a runtime or artifact path. Results contain
+requested/effective configuration, sample count, wall time per point, pure
+evaluator time where available, uncertainty statistics, and environment
+provenance. When native profiling is available,
+`BenchmarkResult.timing_breakdown` contains typed top-level and internal timing
+attribution, per-stage timings, and `BenchmarkProfileCounters`. Internal
+leaf/backend/output-gather/remap attribution is non-additive: full-stage
+evaluator envelopes own leaf gathering, while composed selected-chunk
+input-pack envelopes own it. Movement and materialization counters are
+normalized per profiled point; backend-call and explicit allocation counters
+are normalized per runtime call. Compiled Direct-Arena engine/call counts and
+its input/current-output/amplitude-output boundary-byte counters are likewise
+normalized per runtime call. A valid fused Arena profile reports zero boundary
+traffic and enough Arena calls to cover every evaluator backend call.
+
+For on-the-fly execution, benchmarking snapshots the authenticated compact
+runtime-state census immediately before and after its separately timed first
+requested-workload evaluation, before configured warm-up runs. The environment
+records both immutable snapshots, whether the initial runtime was cold or
+already retained, and evidence that the first evaluation left a complete
+retained family. A missing, mismatched, partial, or malformed census fails
+closed. Other execution modes do not require this private census capability.
+
+`benchmark(...)` is the convenience wrapper.
+
+## Stability Rules
+
+All public dataclasses are frozen. Public collections are tuples or immutable
+mappings. Paths are accepted as `os.PathLike[str]` and returned as absolute
+`Path` objects only when they describe user-created files.
+
+Machine-readable methods return typed objects or documented JSON, never
+volatile dictionaries. JSON output writes only to stdout; diagnostics use
+logging/stderr.
+
+## Typing Gate
+
+`just typing` is the normative public Python typing gate and is also a
+dependency of `just check`. It runs strict mypy over an explicit source list:
+the package root, `pyamplicol.api`, the public configuration models/registry
+and `pyamplicol.config` facade, `pyamplicol.reporting`, and
+`pyamplicol.runtime`. Imported implementation modules are followed for type
+information with their diagnostics silenced; no public target uses
+`ignore_errors`.
+
+A second mypy pass stages a temporary installed-style package, including
+`py.typed` and the maintained `_rusticol.pyi`, then checks external consumers.
+Those consumers assert exact Generator, Runtime, configuration, protocol, and
+result types. Every name in the `__all__` lists of `pyamplicol` and its public
+`api`, `config`, `reporting`, and `runtime` facades is also rejected if it
+degrades to `Any`. The native consumer checks the maintained extension stub,
+and the metadata check compares that stub with the Rust binding export list
+without rebuilding Rust.
+
+This is intentionally not a project-wide strictness claim. Dynamic generation,
+model compilation, evaluator, color, artifact, CLI, and other private
+implementation modules are outside the source target. Bundled vendor UFO
+assets under `src/pyamplicol/assets/models/ufo/` and generated standalone API
+templates under `src/pyamplicol/assets/api_templates/` are explicitly
+excluded. Their exclusion does not weaken checks of the documented public
+signatures that expose their results.
diff --git a/pyamplicol/docs/development/ARCHITECTURE_DECISIONS.md b/pyamplicol/docs/development/ARCHITECTURE_DECISIONS.md
new file mode 100644
index 0000000000..288207fd1a
--- /dev/null
+++ b/pyamplicol/docs/development/ARCHITECTURE_DECISIONS.md
@@ -0,0 +1,123 @@
+---
+title: "Architecture Decisions"
+nav_order: 3
+parent: "Development Documentation"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Architecture Decisions
+
+## Standalone Repository
+
+`pyamplicol` is an independent repository and distribution. Build, runtime,
+tests, examples, and release tooling may use only files contained in the source
+checkout, source distribution, installed wheel, or explicitly downloaded
+dependencies. No installed path or generated artifact may depend on another
+checkout.
+
+The Python distribution is named `pyamplicol`. Rusticol is the runtime and
+native ABI name, not a second Python package.
+
+## Completion States
+
+**Candidate-complete** means source, API, physics, native SDK, wheel, source
+distribution, and isolated-install tests pass against pinned contributor
+inputs. Candidate package files are marked non-publishable.
+
+**Release-complete** additionally requires exact compatible published
+dependencies and the full supported-platform deployment matrix. Release mode
+never substitutes candidate state.
+
+## Model Boundary
+
+Serialized external JSON is the primary user path. Trusted UFO and JSON inputs
+compile into one canonical model IR before process planning. Model-owned
+symbols have deterministic namespaces; executable compiled expressions may not
+retain raw process-global UFO symbols.
+
+The hand-coded built-in SM is a compatibility model contained under
+`pyamplicol.models.builtin`. Its particle tables, aliases, synthetic fields,
+and optimized kernels must not define generic external-model behavior.
+
+Generic physics decisions use explicit model metadata: canonical species and
+anti-relations, signed-PDG orientation, spin/statistics, color representation,
+mass/width policy, propagator, source/crossing records, exact quantum numbers,
+and normalized color/Lorentz tensors. Absolute SM PDG values and particle names
+are interoperability labels, not generic taxonomy.
+
+Unsupported model features fail in preflight with structured diagnostics.
+Built-in optimizations are permitted only behind a proven applicability record
+and a model-independent fallback.
+
+## Processes And Artifacts
+
+One process request may expand into many concrete processes. Stable process
+names are artifact selectors and remain distinct from the output directory.
+Generic `p`/`j` behavior is model/config data. Every model-derived catalog also
+defines `all` from its propagating physical external states, excluding ghosts,
+Goldstones, and auxiliary/non-propagating records. The complete legacy alias
+table belongs only to the built-in compatibility model.
+
+Schema-v3 artifacts are transactionally written executable inputs. Their
+manifest verifies payload paths, digests, producer/runtime ABI, target, and
+required capabilities. These checks detect accidental mutation; trust in the
+artifact producer remains an external user decision.
+
+The optimized total and resolved evaluation are two views of one runtime plan.
+Resolved LC output retains physical color flows; NLC/full currently expose one
+contracted SU(3) color component per helicity.
+
+## Runtime And APIs
+
+Rusticol core is Python-independent. Boundary crates expose one PyO3 extension
+and C ABI v1. The wheel owns a header-only C++17 wrapper, Fortran 2008 module
+source, static C ABI archive, and target link metadata.
+
+Generation emits one root API bundle with Python, dependency-free Rust 2021,
+C++17, and Fortran 2008 drivers. All drivers support concrete-process
+selection, JSON and direct model-parameter updates, resolved evaluation, and
+explicit total comparison. Python supports precision-controlled evaluation;
+native APIs expose f64 only.
+
+Runtime parameter batches are atomic. Mutable handles are not concurrently
+reentrant; independent handles may run concurrently.
+
+## Symbolica Boundary
+
+Symbolica is imported lazily for model compilation, generation, and Python
+precision paths that require it. Effective license state comes from
+`symbolica.is_licensed()`.
+
+The default JIT artifact embeds a direct SymJIT f64 application. Rusticol loads
+that capability without importing Symbolica or requiring a Symbolica license.
+ASM/C++ artifacts and Python precision paths advertise their retained Symbolica
+runtime requirement explicitly.
+
+## Build And Release
+
+The PEP 517 backend and pinned Maturin build the Python extension and static SDK
+from one locked Rust workspace. `dependencies/release-lock.toml` describes exact
+published release inputs; contributor state is source-checkout-only and cannot
+enter release package files.
+
+Release validation uses standard package metadata, wheel `RECORD`, model and
+artifact payload digests where the formats require them, `twine check`, platform
+audits, clean installation, cross-language runtime tests, and PyPI Trusted
+Publishing. Publication consumes already validated wheels and one source
+distribution and performs no build.
+
+## Legacy Physics Parity Reference
+
+The legacy Fortran reference is developer-only. It is prepared as an isolated,
+pinned checkout by developer tooling, is never imported by the installed
+package, and is excluded from release package files. It provides a separately
+implemented legacy parity authority and performance baseline. Because it shares
+validation lineage and known defects with the current implementation, agreement
+does not establish independent physics correctness. Future full-colour,
+arbitrary-precision comparisons with MadGraph are required; agreement among
+APIs that share Rusticol validates the ABI only.
+
+## Supported Platforms
+
+Binary releases target macOS arm64, macOS x86_64, and manylinux x86_64 with
+`cp311-abi3`. Source installation may work elsewhere but is unsupported until
+the complete native and physics matrix passes there.
diff --git a/pyamplicol/docs/development/CONFIG_CONTRACT.md b/pyamplicol/docs/development/CONFIG_CONTRACT.md
new file mode 100644
index 0000000000..c568afb0ee
--- /dev/null
+++ b/pyamplicol/docs/development/CONFIG_CONTRACT.md
@@ -0,0 +1,302 @@
+---
+title: "Configuration Contract"
+nav_order: 2
+parent: "Development Documentation"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Configuration Contract
+
+TOML schema version 1 and the Python configuration dataclasses share one field
+registry. Unknown fields are errors. Paths are resolved relative to the card.
+
+Precedence is defaults, card, dedicated CLI flags, repeatable `--set`
+overrides in order, then recorded license/resource clamping.
+
+## Top Level
+
+- `schema_version: int = 1`
+- `action: generate | evaluate | benchmark | inspect | model-inspect |
+  model-compile | model-processes | group-processes`
+
+## Model
+
+- `source: str = "built-in-sm"`
+- `restriction: str | null`
+- `simplify: bool = true`
+- `cache: bool = true`
+- `cache_dir: path | null`
+
+## Process
+
+- `entries: list[{ expression: str, name: str | null }]`
+- `multiparticles: table[str, list[str]] = {}`
+- `flavor_scheme: int = 5`
+- `max_quark_lines: int | null`
+- `coupling_order_policy: minimal | explicit = minimal`
+- `max_coupling_orders: table[str, int] = {}`
+- `max_color_sectors: int | null`
+- `reference_color_order: list[int] = []`
+- `selected_color_sector_ids: list[int] = []`
+- `selected_source_helicities: table[int, int] = {}`
+- `flavor_blind: bool = false`
+- `consider_charge_conjugation: bool = true`
+- `only_unit_multiplier: bool = false`
+- `analyze_process_groups: none | numerical = none`
+
+Model defaults and this explicit table are merged by name. Every model supplies
+`all` for its declaration-ordered valid physical external states; an explicit
+`all` entry overrides it. Broad products such as `p p > all all` may expand
+combinatorially.
+
+The explicit color-sector, reference-order, and source-helicity controls are
+developer-facing generation constraints. Ordinary users should leave them at
+their defaults and use the runtime selectors below.
+
+The four process-group fields decide what `process-groups.json` records:
+`flavor_blind` generates one representative per flavour-relabelling class and
+records the others as unverified members; `analyze_process_groups = "numerical"`
+merges generated processes whose matrix elements agree numerically up to a
+rational factor, restricted to factor 1 by `only_unit_multiplier`.
+`consider_charge_conjugation` also admits charge-conjugate relations in both
+cases. The `group-processes` action reads `evaluation.artifact` and these
+fields; its CLI defaults `analyze_process_groups` to `numerical`.
+
+## Color
+
+- `accuracy: lc | nlc | full = lc`
+- `contraction: auto | direct | symmetric-group-fft = auto`
+- `fft_basis: trace | adjoint = adjoint`
+- `lc_flow_layout: topology-replay | all-flow-union = topology-replay`
+
+LC generation always includes complete physical flow coverage. Runtime flow
+selectors are configured under `evaluation` or `benchmark`; internal sector,
+topology, replay, and reference-order IDs are not configurable.
+
+`symmetric-group-fft` is an exact contracted-colour reducer for NLC/full
+recurrence and on-the-fly execution. It is rejected for LC, compiled, and eager
+execution when explicitly requested. The default `auto` tries FFT in the
+supported lanes, falling back to direct for unsupported process plans; LC,
+compiled/eager, and correlated generation use direct contraction and trace
+basis. Explicit `direct` opts out and ignores `fft_basis`.
+
+`fft_basis = "adjoint"` requests adaptive exact-basis selection with
+`contraction = "auto"` or `"symmetric-group-fft"`. Certified Yang–Mills trees and
+certified single-insertion scalar HEFT (`HIG = 1`) use two-anchor DDM; quark processes
+retain fundamental chains or their products, and uncertified adjoint domains
+retain trace tensors. Singlet domains have one trivial tensor. This does not
+add a JO primitive decomposition or assume identities for arbitrary models.
+Forced adjoint FFT remains unsupported for correlated generation.
+
+For `n` gluons, DDM retains `(n-2)!` ordered amplitudes instead of `(n-1)!`;
+its two-adjoint endpoint case is the single delta tensor. Saved
+`fft_basis_selection` contains `requested`, `actual_basis`, `name`, `reason`,
+`permutation_degree`, and `tensor_count`. `actual_basis` selects the metric
+implementation (`trace` or `adjoint`); `name` distinguishes DDM, fundamental
+chains/products, singlets, and trace tensors. Counts exclude open-line
+traversal aliases and do not assert linear independence at fixed `Nc`.
+
+The CLI `--fft {trace,adjoint}` sets both contraction and basis request without
+changing accuracy. Explicit FFT requests retain unsupported-plan errors;
+`--color-contraction symmetric-group-fft` uses adjoint by default.
+`ColorFFTBasis` and `ColorConfig` are public Python exports. Examples
+select the adaptive adjoint option explicitly without implying that every
+process has a smaller basis or faster runtime.
+
+## Generation
+
+- `output: path | null`
+- `mode: error | append | replace = error`
+- `workers: auto | int = auto`
+- `emit_api_bundle: bool = true`
+
+### Generation Validation
+
+- `enabled: bool = true`
+- `samples: int = 2`
+- `seed: int = 12345`
+- `relative_tolerance: float = 1e-12`
+- `absolute_tolerance: float = 1e-300`
+- `post_build_validation: bool = false`
+
+### Relation Discovery
+
+- `mode: off | diagnostic | certified-reuse = off`
+- `precision_digits: int >= 80 = 96`
+- `probe_count: int >= 2 = 4`
+- `verification_probe_count: int >= 2 = 4`
+- `relative_tolerance: float >= 0 = 1e-70`
+- `absolute_tolerance: float >= 0 = 1e-80`
+- `seed: int >= 0 = 1348026701`
+
+Candidate and independent verification probes are bounded and deterministic.
+Artifact writing always validates the schema, declared payloads, references,
+and digests. Optional post-build validation additionally re-opens the completed
+artifact and compares native binary64 optimized and resolved evaluation. It is
+off by default because that second runtime pass does not alter the artifact and
+can be disproportionately expensive for large resolved axes; enable it with
+`--post-build-validation` when an immediate runtime smoke is wanted. Its
+configured samples are independent of the 96-digit relation-discovery
+certification probes below.
+Exact binary64 term-vector or `ExactComplexRational` schedule proofs remain the
+preferred promotion path. When no exact structural proof exists,
+`certified-reuse` may apply equal, opposite, or zero-current reuse only after
+the independent current-value probes pass both configured tolerances and the
+complete certification input and mapping are persisted for replay. One warning
+is emitted per generated artifact when such proof-less mappings are applied.
+Malformed, non-finite, unstable, or stale evidence fails closed.
+
+The feature is off by default: its high-precision probes evaluate the complete
+current schedule several times at generation time, which dominates the build at
+high multiplicity. `mode = "certified-reuse"`—or the public
+`--numerical-current-reuse` flag—enables it for LC, NLC, and full colour, for
+compiled, eager, and recurrence generation using built-in or prepared
+external/UFO models, to search for additional equal, opposite, or zero-current
+reuse. The compact on-the-fly source projection does not run this configurable
+relation-discovery pass. `mode = "off"`—or `--no-numerical-current-reuse`—
+restates the default and never changes numerical results. Direct vertex-kernel
+equivalence remains model-certificate-owned.
+
+## Evaluator
+
+- `backend: jit | asm | cpp = jit`
+- `execution_mode: compiled | eager | recurrence | on-the-fly = recurrence`
+- `batch_size: int = 128`
+- `output_chunk_size: int | null = 512`
+- Stage-local parameter layout is mandatory and is not a public toggle.
+
+### Eager Execution
+
+- `point_tile_size: int = 1024`
+- `workspace_mib: int = 256` (soft batching target)
+
+Eager mode requires a prepared model bundle before DAG construction. A
+`built-in-sm` source resolves automatically to the wheel-owned portable
+`built-in-sm-jit-o2` pack; other models and built-in C++/ASM execution require
+an explicit prepared path. The prepared pack is
+authoritative for backend and code-shaping optimization settings. The runtime
+may reduce `point_tile_size` to approach the workspace target, but never
+increases it. The target does not reject a process whose minimum workspace
+is larger: at least one point is always allowed, with sufficient allocation.
+
+`.pyAmplicol-model.json` IR is architecture-independent. SymJIT application
+storage-v3 prepared packs use optimization level 2 and are portable across the
+supported `x86_64` and `aarch64` targets. Loading rebuilds executable code for
+the receiving CPU. Prepared-pack compilation forces O2 and records any
+requested-to-effective adjustment. C++ and ASM prepared packs remain
+target-native.
+
+### Recurrence Execution
+
+- `point_tile_size: int = 1024`
+- `workspace_mib: int = 256` (soft batching target)
+
+Recurrence is the global default. The runtime may reduce `point_tile_size` to
+approach the recurrence workspace target, but never increases it. Like eager
+execution, it allocates at least the workspace needed for one point, even when
+that exceeds the target. A strict total-memory limit belongs to an external
+watchdog, not to the generated process. Recurrence JIT
+kernels use the same portable prepared O2 contract as eager execution. A
+missing prepared pack fails closed; configuration resolution never falls back
+to compiled execution. Cards that require process-local compiled DAGs must set
+`execution_mode = "compiled"` explicitly.
+
+### On-The-Fly Execution
+
+On-the-fly execution requires a prepared model bundle and native `f64`
+precision. It stores a compact process seed and constructs recurrence schedules
+for the requested selector instead of materializing a process layout. LC does
+not materialize topology replay or all-flow union: static inspection exposes
+the physical helicity/color-flow census and the runtime supplies both selector
+families. NLC and full colour expose one contracted component, accept helicity
+selectors, and reject LC-flow selectors.
+
+`evaluator.optimization.cores` resolves to a positive requested
+query-construction thread count for this mode. It is not a numerical-runtime
+thread guarantee. LC numerical execution sizes its warmed family to the
+requested batch capacity. Contracted NLC/full execution applies the
+authenticated recurrence point tile. There is no on-the-fly-specific tile or
+workspace configuration section.
+
+### Evaluator Optimization
+
+- `horner_iterations: int = 10`
+- `cpe_iterations: int | null = null`
+- `cores: auto | int = auto`
+- `max_horner_variables: int = 1000`
+- `max_common_pair_cache_entries: int = 5000000`
+- `max_common_pair_distance: int = 1000`
+- `collect_factors: auto | bool = auto`
+
+For on-the-fly execution, only `cores` has a mode-specific runtime meaning;
+the prepared kernel pack remains authoritative for code-shaping optimization.
+
+### JIT
+
+- `optimization_level: 0 | 1 | 2 | 3 = 2`
+- `compress: AutoBool = "auto"` (compiled JIT O2 resolves to `true`; all other
+  modes/levels resolve to `false`; explicit booleans override the default)
+
+JIT artifacts embed direct SymJIT applications. The defaults above apply to
+process-local compiled DAG evaluators. Prepared JIT kernel packs used by eager,
+recurrence, and on-the-fly execution force optimization level 2 to preserve
+their cross-architecture storage contract.
+
+Compression can reduce generated code size but add runtime overhead. Auto
+selection remains in requested configuration; effective configuration records
+the resolved boolean. Explicit settings remain authoritative for newly
+compiled kernels; existing prepared packs retain their recorded setting.
+
+### C++
+
+- `optimization: str = "O3"`
+- `compiler: str | null`
+- `native_arch: bool = false`
+- `extra_flags: list[str] = []`
+
+Portable C++ generation is the default. Setting `native_arch = true` opts into
+host-native code and records Rusticol's canonical, sorted runtime CPU-feature set
+as an artifact requirement. Loaders reject that artifact before reading evaluator
+state on a target without every declared feature. Additional flags are restricted
+to the documented non-ISA allowlist; arbitrary `-march`, `-mcpu`, `-m*`, or target
+flags are rejected because they could introduce unrecorded requirements.
+Schema-v3 evaluator payload portability is currently defined for macOS arm64,
+macOS x86_64, and glibc Linux x86_64. Other targets are rejected explicitly.
+
+## Evaluation
+
+- `artifact: path | null`
+- `process: str | null`
+- `precision: int = 16`
+- `resolved: bool = false`
+- `helicity_ids: list[str] = []`
+- `color_flow_ids: list[str] = []`
+- `model_parameters: path | null`
+- `momenta: path | null`
+
+## Benchmark
+
+- `target_runtime: float = 10.0`
+- `batch_size: int = 128`
+- `precision: int = 16`
+- `warmup_runs: int = 2`
+- `minimum_samples: int = 5`
+- `helicity_ids: list[str] = []`
+- `color_flow_ids: list[str] = []`
+
+For LC profiling, empty benchmark selector lists resolve at runtime to the
+generated layout's optimized workload: one physical flow and the helicity sum
+for `topology-replay`, or all physical flows and one computed helicity for
+`all-flow-union`. Explicit subsets and selected-axis lists are preserved; a
+complete summed-axis list is normalized to equivalent omission. A valid
+non-hot shape emits at most one pre-loop warning per loaded process. Evaluation
+selector defaults remain the complete matrix element.
+
+## Output And Symbolica
+
+- `output.format: human | json = human` for typed API/config provenance. The
+  public CLI normalizes this to human tables unless `--json` is explicitly
+  present.
+- `output.color: auto | always | never = auto`
+- `output.progress: auto | tty | log | off = auto`
+- `output.log_level: debug | info | warning | error = info`
+- `symbolica.suggest_license: bool = true`
diff --git a/pyamplicol/docs/development/MODEL_ASSET_PROVENANCE.md b/pyamplicol/docs/development/MODEL_ASSET_PROVENANCE.md
new file mode 100644
index 0000000000..eeb46ca1dc
--- /dev/null
+++ b/pyamplicol/docs/development/MODEL_ASSET_PROVENANCE.md
@@ -0,0 +1,39 @@
+---
+title: "Model Asset Provenance"
+nav_order: 6
+parent: "Development Documentation"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Model Asset Provenance
+
+Package-owned model assets live in `src/pyamplicol/assets/models`. Their exact
+upstream revisions and file checksums are recorded next to the payloads in
+`PROVENANCE.toml` and `MANIFEST.sha256`; no duplicate top-level asset tree is
+used.
+
+| Asset | Origin | Intended notice | Port status |
+|---|---|---|---|
+| Built-in SM | Original pyAmpliCol model implementation | 0BSD | Eligible; code-backed implementation is ported separately |
+| SM UFO 1.3 | FeynRules UFO by N. Christensen and C. Duhr, distributed through GammaLoop | Preserve authorship, UFO/FeynRules provenance, and all upstream notices | Extracted and manifest-covered |
+| Scalar UFO | Model by Valentin Hirschi, generated with FeynRules 1.7.69 and distributed through GammaLoop | 0BSD for original model material; preserve generated UFO helper attribution | Extracted with deterministic static defaults |
+| Scalar-gravity UFO | Model by Valentin Hirschi, generated with FeynRules 1.7.69 and distributed through GammaLoop | 0BSD for original model material; preserve generated UFO helper attribution | Extracted with deterministic static defaults |
+| Serialized JSON | Deterministic `ufo-model-loader` serialization of the corresponding UFO | Same terms and provenance as source UFO; loader is MIT | Regenerated and manifest-covered |
+
+The SM UFO contains `build_restrict.py` from MadGraph5_aMC@NLO. Its license is
+included as `licenses/MadGraph5_aMCatNLO.txt`; model, GammaLoop, and loader
+provenance are recorded separately so generated JSON does not obscure the
+terms of its source UFO.
+
+The completed extraction:
+
+1. Inventories 66 payload files plus `PROVENANCE.toml` from the pinned source.
+2. Excludes caches, interpreter output, symlinks, and host paths.
+3. Freezes scalar model environment switches to their historical defaults.
+4. Regenerates JSON with `ufo-model-loader` 0.1.8 and records both source and
+   package hashes.
+5. Records each deterministic transformation in
+   `model-assets/TRANSFORMATIONS.md` and verifies all package payloads through
+   `MANIFEST.sha256`.
+
+Numerical UFO/JSON/compiled-model parity remains an integration gate owned by
+the model compiler rather than an asset-copying claim.
diff --git a/pyamplicol/docs/development/ON_THE_FLY_MODE_ARCHITECTURE.md b/pyamplicol/docs/development/ON_THE_FLY_MODE_ARCHITECTURE.md
new file mode 100644
index 0000000000..7a3d90e43b
--- /dev/null
+++ b/pyamplicol/docs/development/ON_THE_FLY_MODE_ARCHITECTURE.md
@@ -0,0 +1,334 @@
+---
+title: "On-the-fly mode architecture"
+nav_order: 8
+parent: "Development Documentation"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# On-the-fly Mode Architecture and Implementation Record
+
+## Status and scope
+
+This document records the architecture selected from the on-the-fly research
+prototypes based on source revision
+`a08feed4aacf39c00dfedaeedd3a82a9666f1565` and the production implementation
+that followed. The prototype commits are historical evidence, not code that
+was merged wholesale.
+
+On-the-fly execution is a distinct artifact and native runtime lane. Python
+produces a compact process source projection; Rust authenticates it against the
+prepared template/executor catalogs, builds and encodes the binary
+`OnTheFlyProcessSeedV1`, and decodes and validates that seed at load. The lane
+never constructs a `DirectRecurrencePlan`.
+
+For LC, the native runtime accepts one arbitrary requested Cartesian family of
+helicity ordinals times flow ordinals, subject to checked native `usize` sizes
+and available resources. That family may range from one selector pair to the
+complete all-helicity times all-flow product. Selected-flow/helicity-sum and
+all-flow/single-helicity are the two campaign workloads; they are not
+capability limits. NLC/full use an authenticated recurrence-v3 colour metric,
+evaluate only canonical structural-owner amplitudes, and expose one public
+`color:contracted` component rather than a selectable colour-flow axis.
+
+Cold preparation constructs transient selector-local traces and groups their
+operations into one executable family. Only the last successfully evaluated
+family is retained. The mode is integrated with generation, artifact loading
+and inspection, selected/resolved/total evaluation, `Runtime.clear()`,
+profiling, the CLI, explicit one-point warm-up progress, and the native SDKs.
+It is native-f64-only. Contracted NLC/full correctness is covered through the
+complete n<=4 acceptance catalog; their rapidly growing cold selector product
+is not claimed to be practical at high multiplicity.
+
+Numerical comparisons now include independent full-colour MadGraph targets at
+precision 200 and strict scale-only relative tolerance 1e-10. OTF full colour
+is replayed at native f64 against those frozen targets; OTF NLC is replayed
+against recurrence-p200 targets captured only after the full-colour lane was
+MadGraph-gated. Legacy-only evidence is not treated as independent authority.
+
+## Prototype evidence and dispositions
+
+| Research commit | Evidence | Production disposition |
+|---|---|---|
+| `ce8037749c97ae04bae6cec42161991754ee2078` | Algorithmic helicity and LC-flow codecs addressed one selector without cardinality-sized tables. | Retain the algorithms and fixtures. Production ordinals and Cartesian products are bounded by native `usize`. |
+| `4c9a1d6cedb082140c5b492171bd2fe7873b0f98` | A synthetic plain 8-byte VM was bitwise equal to its interpreter and used zero warm allocations; generic superinstructions were slower. | Historical only. Production executes grouped family rows and has no 8-byte VM. |
+| `84f2246f0de8f5d9e598eb76f2ff8e85bd0dbd36` | Ordered prefixes carry distinct color-ordered amplitudes. LC contraction was a diagonal second moment in the checked domains; coherent summation was wrong. | Reject shared-amplitude DP. Retain exact LC selector construction and diagonal reduction. |
+| `2312b1137c7e2f3d6bdf9064a902592c16bac58c` | Candidate A built a selected GenericDAG query without global color/projection/axis materialization. Retained n=5 cases agreed with a separate p32 recurrence path. | Port the selector-local construction to Rust. Treat p32 as historical regression evidence, not independent physics authority. |
+| `caa500dd7fa67a7e496238e63c6b823aab4b8dd6` | A demand-first memo used synthetic kernels and the wrong ownership boundary. | Reject the evaluator; retain only useful reverse-index ideas. |
+| `6b4f011d90d5262807d8316d73f28b106ea31fb9` | Candidate C explored a VM, byte-budgeted LRU, and ephemeral oversize plans. | Historical only. Production uses transactional `last-family-only` retention. |
+| `dc171ac357c2817465f20baf3ff0efa91086b53a` | Query-sized structural construction reached n=10 under the 30 GiB watchdog without building the full selector product. | Retain as historical scaling evidence, not a numerical or completion gate. |
+| `cf8de3820152be262bafc6f93e5af9a6f423b271` | Compact seeds retained crossed sources, pairing classes, coupling policy, source slots, and parity. | Adopt the seed concept; authenticate and build the production seed in Rust. |
+| `e71161cb656ed5eeaa69d18221735b242c60554d` | A prepared pool served compact plans, but the prototype used incomplete traces and hard-coded executor IDs. | Adopt the plan-independent pool seam; use authenticated semantic lookup and a process/lane-owned source binding. |
+
+The production implementation resolves the prototype-era gaps in complete LC
+family construction, semantic executor lookup, source-domain ownership, and
+the binary seed/load boundary. The VM/LRU proposal and its byte-accounting
+gates were not adopted.
+
+## Current production contract
+
+### Binary seed and execution manifest
+
+The Python projection contains process-owned source facts and policy inputs,
+but no recurrence DAG, color plan, public-flow table, or direct plan. Rust
+cross-checks it with the validated recurrence-template catalog, prepared
+direct-executor catalog, and prepared-kernel-pack identity before producing the
+PACBIN seed member.
+
+`OnTheFlyProcessSeedV1` stores exactly these classes of data:
+
+- process, compiled-model, recurrence-template-catalog,
+  prepared-kernel-pack, and direct-template-catalog digests;
+- the normalization semantic digest and convention, with seed construction
+  requiring the raw-amplitude normalization factor to be exact one;
+- source anchors: source/public slots, initial-state flag, LC color role,
+  statistics, optional pairing-contract digest, and all concrete source
+  states;
+- per-state public/source helicities, source/current template identities and
+  semantic digests, momentum sign, exact crossing phase, spin/chirality,
+  flavour and quantum flow, color-seed proof, wavefunction family,
+  particle/antiparticle/self-conjugate orientation, and optional prepared mass
+  slot;
+- the public-to-construction external permutation;
+- coupling-order policy, positive hierarchy weights, and optional explicit
+  user hard caps; and
+- species pairing classes with balanced fundamental/antifundamental endpoints,
+  plus the seed's semantic digest.
+
+The seed does not store enumerated public axes, selector census, reference
+color word, reflection policy, executable rows, or the runtime normalization
+factors. Those facts have different owners:
+
+- `execution.selector_policy` stores complete LC coverage, the optional
+  reference color word, whether trace reflections are folded, and the
+  authenticated physical helicity/flow census;
+- `execution.runtime_metadata.normalization` stores LC color, averaging,
+  identical-particle, global-coupling, and coupling-policy runtime factors;
+  the runtime metadata also carries parameters, external legs, masses, and the
+  decoded seed identity; and
+- the runtime container manifest owns the canonical PACBIN and seed-member
+  paths.
+
+The selector adapter derives axes from the decoded seed plus manifest policy.
+The normal load/evaluate/profile path does not materialize dense public axis
+records. Explicit `.physics` access may populate a separate metadata cache;
+that does not change the seed or native load contract.
+
+There is no fallback to ordinary recurrence construction. In particular, OTF
+must not call the global color-plan/projection/recurrence builders,
+`build_replay_targets`, `finish_program`, or any `DirectRecurrencePlan`
+constructor or loader.
+
+### Coupling policy and first cold warm-up
+
+The seed stores policy inputs, not always the effective runtime limits:
+
+- `Explicit` uses the seed's optional hard-cap vector directly and performs no
+  minimal-policy topology sweep.
+- `Minimal` performs a process-global cold topology sweep. The sweep erases
+  public helicity labels while retaining source support, state/spin, flavour
+  and quantum ancestry, exact LC color, and fermion-pairing lineage. Explicit
+  hard caps constrain that sweep. The hierarchy-minimal viable total orders
+  define the effective per-order envelope used by every subsequent query until
+  the process preparation is cleared.
+
+Grammar preparation and minimal-policy resolution happen on the first genuinely
+cold family preparation, not at artifact load or seed generation. Their result
+is process-wide and reused by subsequent families. `Runtime.clear()` removes
+the prepared grammar, effective policy, timing, families, and family semantic
+bindings, so the next cold evaluation recomputes this warm-up. Generation and
+warm-up therefore remain separately reportable timings.
+
+The cold sweep indexes parent currents by source-support size and visits only
+size-complementary pairs. Final closure additionally requires a singleton
+anchor. These filters preserve the original candidate order and exact colour,
+flavour and fermion-pairing checks; they avoid scanning pairs that cannot
+possibly form the requested current.
+
+### Selector family, transient traces, and retained rows
+
+The public selector adapter accepts arbitrary subsets of the helicity and flow
+axes. It checks the requested Cartesian product in `usize`, collects the
+selected indices/IDs and native-internal `DecodedLcQueryV1` requests during
+cold preparation, and preserves public order. Requesting both complete axes is
+supported by the contract, although it can be expensive.
+
+For each nonzero query, production constructs an
+`OnTheFlyStructuralTraceV1`. This is the transient cold IR: it carries
+query-local current/color identities, source/contribution/finalization/closure
+operations, momentum forms, exact factors, pairing owners, workspace layout,
+and structural proof. Prepared-executor parent order is authenticated and bound
+before lowering.
+
+The family builder consumes those traces, unions repeated currents, groups
+executor rows, and records amplitude destinations. Transient traces are then
+dropped; retained row groups keep the semantic keys and member bindings needed
+by the executor, while the retained-state census reports zero query-local
+traces. Structural-zero requests retain their public placement but need no
+executable destination.
+
+Family replacement is transactional. A candidate remains pending until its
+first successful evaluation; a failed candidate is discarded without evicting
+the last successful family. Successful promotion clears the old family and
+retains exactly one selection and family. An executable family has its row
+handle, destination map, and matching semantic bindings; a structural-zero
+family has none of those executable members. `Runtime.clear()` leaves all
+family-state counts at zero.
+
+Compactness means that the artifact/load boundary has no dense recurrence plan
+and that retained executable state belongs only to the requested Cartesian
+family. It does not promise memory independent of that family's size: an
+all-helicity times all-flow request may itself be large.
+
+Warmed momentum preparation traverses contiguous phase-space-point planes.
+Source bounds are checked once when the immutable family workspace is prepared;
+each point retains the original momentum-term summation order. Only active
+lanes are refreshed, with no warmed reallocation.
+
+### Completed-cache snapshots
+
+`NativeRuntime::save(path)` streams the completed retained OTF structure to a
+snapshot; `load_cache(path)` restores it against a matching loaded process.
+The Python facade and C/C++/Fortran/Rust SDKs expose the same operations and
+format. This is independent of explicit warm-up: an ordinary successful
+evaluation also leaves saveable state.
+Small usage examples are maintained in
+[Runtime and Selectors](../user/runtime-and-selectors.md#saving-an-otf-warm-cache)
+and [Native APIs](../user/native-apis.md#saving-and-restoring-an-otf-cache).
+
+The snapshot retains process preparation, grouped current rows, exact factors,
+momentum forms, semantic executor references, and the public-selection and
+amplitude-reduction mappings. Restoring the resolved coupling policy avoids
+repeating its process-global topology sweep. Prepared kernels are rebound
+from the original process output, while numeric workspaces are created afresh
+and the receiving runtime's parameters remain in effect. No machine addresses
+or evaluated currents are serialized. Successful restoration replaces the
+previous cache transactionally; rejection leaves it unchanged.
+
+Snapshot compatibility is tied to the existing process/seed/prepared-kernel
+identities and a snapshot format version. A saved family follows the same
+warmed execution path as one constructed in memory. The last-family retention
+policy is unchanged: this is neither a history of evicted selections nor a
+checkpoint of a partially constructed family.
+
+### Prepared executors, source binding, and checked resources
+
+The prepared executor pool is model/catalog-owned. At artifact load, source
+domains are derived once from the process seed and template catalog and bound
+to that pool. `OnTheFlySourceDomainBinding` is process/lane-owned and
+query-independent; it survives family replacement and `Runtime.clear()`.
+Family-specific semantic executor mappings are resolved and committed
+transactionally beside the grouped rows.
+
+Ownership order ensures grouped rows and resolved handles disappear before the
+process source binding, which in turn disappears before the model-level pool.
+Missing, ambiguous, or digest-mismatched semantic mappings fail closed.
+
+Claims about checked resources are intentionally narrow. Selector counts,
+Cartesian products, row/workspace offsets, and point/destination products use
+checked size arithmetic. Specific large growth points use fallible reservation,
+including seed/source projections, selector metadata caches, selected-family
+and trace vectors, retained-family slots, and point/amplitude scratch buffers.
+This is not a blanket claim that every Rust allocation is fallible.
+
+All expansion-prone development commands run under the 30 GiB process-tree
+watchdog.
+
+### Public surface and limitations
+
+OTF participates in the normal Python generation/load/runtime APIs, compact
+inspection, explicit one-point warm-up, selected/resolved/total evaluation,
+lifecycle clearing, benchmark/profile reporting, CLI workflows, and native
+Rust/C/C++/Fortran APIs. The profile path reports generation separately from
+generation plus first warm-up, and it records the native retained-family
+census.
+
+The runtime rejects non-f64 precision before expensive selector/physics work.
+LC exposes flow selection. Contracted NLC/full reject flow selectors, apply the
+authenticated colour factor exactly once, and reuse the same structural
+query-family executor. External UFO-SM evidence includes the complete bounded
+n<=4 acceptance catalog; this remains a bounded claim, not universal UFO
+correctness.
+
+## Original staged plan and dispositions (historical)
+
+The original plan separated a structural interpreter, an optional 8-byte VM,
+a bounded LRU, selector streaming, a compact artifact, and final public/UFO
+integration into successive gates. Its useful dispositions are:
+
+- the compact seed, transient structural trace, semantic lookup, distinct
+  artifact/lane, and LC diagonal reduction were adopted;
+- the 8-byte VM, general LRU, ephemeral oversize-plan policy, and exact cache
+  byte-accounting gates were not adopted;
+- the production family API permits any requested helicity×flow Cartesian
+  product and may collect its requests during cold preparation, so strict
+  one-selector-at-a-time streaming is not a current gate;
+- the old requirement for both compiled and recurrence authorities was
+  superseded by one designated legacy authority per cell; and
+- broad UFO, p32, and exact n=10 gates were superseded by the bounded current
+  evidence and completion scope below.
+
+The deleted prototype-era file map and detailed stage gates described planned
+filenames and sequencing, not the implemented contract. The source tree and
+the sections above are authoritative.
+
+## Validation evidence and completion scope
+
+Focused tests cover seed/manifest validation, selector order and checked
+products, source and semantic binding, transient trace construction, grouped
+family rows, structural zeros, transactional failure/promotion, parameter
+updates, `Runtime.clear()`, aliases/permutations, identical-fermion signs,
+multi-line pairing, LC diagonal reduction, compact inspection, CLI/profile
+workflows, and the generated C API. Built-in SM and the external JSON
+scalar/contact lifecycle have both been exercised.
+
+The live fail-fast n<=4 process-table campaign completed from native candidate
+`238a4ad`: all 66 OTF cells passed their matching recurrence authority, and all
+66 legacy AmpliCol timing baselines were available. The campaign produced 132
+fresh successful OTF/recurrence results, reused 66 independently rehashed
+AmpliCol results, and observed a maximum conditioned OTF/recurrence residual of
+`3.93e-15`. This establishes legacy LC parity, not independent physics
+correctness.
+
+The later contracted-colour acceptance suite covers the complete bounded
+n<=4 catalog. OTF full colour is replayed against frozen independent MadGraph
+targets produced at precision 200; OTF NLC is replayed against recurrence-p200
+targets admitted only after the matching full-colour lane passed its MadGraph
+gate. This is the current bounded NLC/full correctness claim.
+
+Retained selected-flow/helicity-sum high-multiplicity comparisons have passed:
+
+- n=5: process IDs 7, 8, 11, 13, and 15 against legacy AmpliCol;
+- n=6: process IDs 7, 8, 11, 13, and 15 against legacy AmpliCol, plus
+  four-quark-line process ID 14 against recurrence; and
+- n=7: process IDs 7, 11, 13, and 15 against legacy AmpliCol, plus
+  four-quark-line process ID 14 against recurrence.
+
+The process-ID-8 pure-gluon n=7 probe reached its one-hour timeout without a
+completed report. It is a bounded engineering probe, not a parity failure or
+completion gate.
+
+After required parity, scaling exploration and performance investigation each
+have a separate one-hour wall-clock cap. Scaling may attempt OTF-only n=8/n=9
+selected-flow/helicity-sum and bounded arbitrary-family feasibility under the
+30 GiB watchdog; those probes require no numerical authority. Performance uses
+batch size 128 and implements only obvious, generic, low-risk improvements
+found within the hour. The former 2x AmpliCol aspiration remains context, not a
+completion gate.
+
+## Original LC milestone definition of complete
+
+The LC OTF milestone is complete when:
+
+- the final live n<=4 campaign and designated bounded parity cells pass;
+- the relevant source-tree and installed-package tests, API/CLI/profile/native
+  lifecycle checks, and generated C API test pass;
+- the separate one-hour scaling and performance investigations conclude,
+  whether or not they find an improvement; and
+- the intentional dirty worktree is preserved and the implementation is
+  committed and pushed.
+
+That original LC-only milestone did not require a p32 comparison, n=10
+reproduction, 2x runtime ratio, NLC/full-color OTF, or repair of shared legacy
+physics bugs. The production scope has since added the bounded n<=4 contracted
+NLC/full capability and independent full-colour MadGraph gate described above;
+it still makes no high-multiplicity practicality claim for those families.
diff --git a/pyamplicol/docs/development/PACKAGING_CONTRACT.md b/pyamplicol/docs/development/PACKAGING_CONTRACT.md
new file mode 100644
index 0000000000..7896f2c1e2
--- /dev/null
+++ b/pyamplicol/docs/development/PACKAGING_CONTRACT.md
@@ -0,0 +1,218 @@
+---
+title: "Packaging Contract"
+nav_order: 4
+parent: "Development Documentation"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Packaging And Release Contract
+
+This document is normative for standalone pyAmpliCol package builds and
+publication.
+
+## Canonical Build
+
+- Distribution: `pyamplicol==0.4.1`, Python 3.11+, license `0BSD`.
+- Backend: the in-tree PEP 517 wrapper delegates to pinned Maturin.
+- Python extension: `pyamplicol._rusticol`, built from `rusticol-python` with
+  `abi3-py311`.
+- Native SDK: `rusticol-capi` links the Python-independent Rusticol core and
+  must contain no PyO3, NumPy, Python symbols, or Python linker dependency.
+- Version source: root Cargo workspace metadata. Installed Python obtains the
+  version from distribution metadata.
+- Rust resolution: the committed `Cargo.lock` is authoritative.
+
+Release builds use a temporary allowlisted source overlay and an external
+`CARGO_TARGET_DIR`. Opted-in contributor builds use a persistent
+workspace-local cache under `.artifacts/dev-install`; neither mode rewrites
+the source inputs.
+
+## Native Build Identity
+
+The native identity hashes the Rust/Cargo source closure, the pinned Rust and
+Maturin toolchains, effective native Maturin settings, and the declarative
+`tool.pyamplicol.native-build` contract. Python orchestration, distribution
+metadata, documentation, reports, staging paths, provenance-only locks, and an
+explicit inventory of wholly test-only Rust files are excluded. Candidate
+versions use the first twelve digits of this same digest; there is no parallel
+candidate fingerprint.
+
+Rust files that mix production code with inline `#[cfg(test)]` modules remain
+file-granular inputs. Avoiding that conservative invalidation requires moving
+the tests into an explicitly audited test-only module; the identity code does
+not attempt to parse or rewrite Rust source.
+
+## Dependency Modes
+
+Release mode reads `dependencies/release-lock.toml` and accepts exact published
+package/crate versions, including Symbolica 3.0.0 and SymJIT 2.26.4. Canonical
+`Cargo.lock` records standard crates.io resolution and checksums without source
+patches. Git, path, editable, floating, and candidate dependencies are forbidden.
+
+Candidate mode is available only from a full source checkout. It reads the
+repository-only contributor contract and produces explicitly non-publishable
+artifacts. Contributor dependency setup and local candidate inputs are excluded
+from release wheels and source distributions.
+
+Release and candidate Cargo resolution are physically separate. A release
+command must fail closed when exact published inputs are unavailable; it must
+never fall back to contributor state.
+
+## Release Prepared-Model Production
+
+Inside MadGraph7 neither the packs nor their metadata are tracked in Git. Each
+MadGraph7 release attaches one archive, `pyamplicol-prepared-models.tar.gz`,
+holding the metadata of every architecture pair and each distinct bundle once.
+`tools/release/prepared_models_archive.py fetch` downloads the archive of the
+matching release, else of the latest one, and writes the files into both
+directories below; `unpack` does the same for a local archive, `pack` creates
+one, and `regenerate` repeats the production described below on the current
+host. The installer and CI validate fetched packs against the source tree and
+regenerate them when they are stale. The release workflow attaches the archive
+its wheels were built with.
+
+The canonical package directory
+`src/pyamplicol/assets/prepared_models` remains candidate-owned in a source
+checkout. Contributor overlays and wheels use those files byte-for-byte and
+never consult release identity.
+
+Release-only source inputs live outside the Python package at
+`release_assets/prepared_models`. A normal release build from a Git checkout
+requires exactly the README and both architecture pairs in that directory. The
+build overlay replaces the four canonical candidate payload files with the
+release pairs, removes the auxiliary store, and then validates the projected
+package assets against the active release lock. Missing, mixed, candidate, or
+stale release packs are build errors; the PEP 517 interface has no release
+bypass. The auxiliary store is deliberately outside the native-build identity,
+so producing its packs cannot change the bootstrap runtime that produced them.
+
+When those source-owned packs must be regenerated, run
+`tools/release/prepared_models_archive.py regenerate` (CI does this through the
+`pyamplicol_prepared_models` action). Its dedicated backend entry
+point creates a temporary release-version bootstrap wheel with both package
+payloads and the auxiliary store removed. That wheel is explicitly marked
+`publishable: false` and
+`release_prepared_model_bootstrap: true`, requires an exact clean Git revision,
+and is rejected by the ordinary release artifact audit. It exists only long
+enough to run the architecture-local producer.
+
+The producer writes `mode: release`, an explicit null candidate fingerprint,
+the producing package version, and a source identity derived only from
+`dependencies/release-lock.toml` and canonical `Cargo.lock`. Producer version
+is provenance: a pack may be reused by a later patch release when its schema,
+compiler, model-source, dependency, and application ABI identities all match.
+The producer writes each pair below `release_assets/prepared_models`; the packs
+are portable, so the pair produced on one host is installed for both
+architectures. The `pyamplicol-eager-portability.yml` workflow checks that
+packs produced on one architecture work on the others.
+
+## Wheel Contents
+
+The wheel contains:
+
+- the typed Python package and one native extension;
+- model assets with their provenance and content manifest;
+- packaged examples, an empty profiling-campaign workspace, and
+  Python/C11/C++17/Fortran 2008/Rust 2021 API templates;
+- direct-JIT f64 self-test data;
+- license and third-party notice files;
+- the target-specific Rusticol C ABI archive, C/C++ headers, Fortran module
+  source, SDK configuration, and relative link metadata.
+
+The installed SDK layout is:
+
+```text
+pyamplicol/_sdk/
+  include/rusticol.h
+  include/rusticol.hpp
+  fortran/rusticol.f90
+  rust/rusticol.rs
+  lib/librusticol_capi.a
+  config.py
+  metadata.json
+  link.json
+```
+
+The backend captures one static archive from Cargo JSON messages, validates the
+complete C ABI, rejects non-relocatable link inputs, scans for Python-family
+symbols, and records only target-appropriate system libraries/frameworks.
+`rusticol-config` exposes typed C/C++ flags, Fortran source, Rust linker flags,
+and JSON metadata without a machine-specific build path.
+
+Wheel audits permit only the `pyamplicol/` package, one `.dist-info/` directory,
+and an optional platform repair directory. Standard wheel `RECORD` protects
+installed-file integrity. Model and process-artifact digests remain scoped to
+the package features that verify those payloads against accidental mutation.
+
+## Source Distribution
+
+One retained source distribution is the source of all release wheels. It must
+build with `python -m pip install .` using release-locked published
+packages/crates and contain:
+
+- Python/Rust/build sources and lockfiles;
+- schemas, tests, examples, user documentation, and release tooling;
+- the README, licenses, and third-party notices.
+
+The canonical package paths in the retained sdist contain only the validated
+release pairs. The auxiliary `release_assets` store and the candidate package
+payloads are absent, so building a wheel from that sdist validates and reuses
+the canonical release payload without a second projection.
+
+The sdist excludes dependency checkouts, contributor setup, local candidate
+inputs, the auxiliary release source store, generated process outputs, build
+products, caches, local environments, development histories, raw campaign
+data, and rendered report PDFs.
+
+`just sdist`, `just wheel-from-sdist`, and the PEP 517 hooks exercise the same
+backend. The sdist audit checks required members and forbidden source-checkout
+inputs before a wheel is retained.
+
+## Validation Matrix
+
+Release targets are:
+
+- macOS 11 arm64, `cp311-abi3`;
+- macOS 11 x86_64, `cp311-abi3`;
+- manylinux 2.28 x86_64, `cp311-abi3`.
+
+Each wheel receives the full installed-package deployment on CPython 3.11,
+without Rust in the consumer environment. That deployment includes:
+
+- `twine check` and platform/native-dependency audits;
+- import, CLI, direct-JIT f64 self-test, and packaged-example checks;
+- Python total/resolved runtime behavior with Symbolica imports blocked;
+- C11, C++17, Fortran 2008, and Rust 2021 f64 driver compilation/execution;
+- model-parameter card and direct UFO-parameter override behavior.
+
+CPython 3.14 receives a focused abi3 installation, import, metadata, and
+direct-runtime smoke test; it does not duplicate generation or the
+multilanguage SDK deployment. The independent Fortran physics oracle runs as a
+source-level release check. Performance campaigns are intentionally separate
+from release CI.
+
+Local entry points are:
+
+```console
+just source-gate
+just test-deployment
+just release-artifacts
+just publish-dry-run
+```
+
+`publish-dry-run` validates ordinary package files and prints the upload command
+without uploading anything.
+
+## Publishing
+
+The release inventory is exactly one source distribution and one wheel per
+supported target. Publication never rebuilds these files.
+
+The validated-artifact workflow is manually dispatched with read-only source
+permissions. A separate manual publishing workflow downloads the successful
+validated inventory, verifies the expected platforms and non-candidate version,
+and publishes through a protected TestPyPI or PyPI environment using OIDC
+Trusted Publishing. Only that final job receives `id-token: write`.
+
+Published releases reference one successful exact-source validated-artifact
+workflow run. Uploading its retained files is a separate manual action and
+never rebuilds them.
diff --git a/pyamplicol/docs/development/PHYSICS_EXTRACTION_CONTRACT.md b/pyamplicol/docs/development/PHYSICS_EXTRACTION_CONTRACT.md
new file mode 100644
index 0000000000..e74f7a4e20
--- /dev/null
+++ b/pyamplicol/docs/development/PHYSICS_EXTRACTION_CONTRACT.md
@@ -0,0 +1,175 @@
+---
+title: "Physics Extraction Contract"
+nav_order: 5
+parent: "Development Documentation"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Physics Extraction Contract
+
+This document records the first independent physics audit. It is normative
+for the behavior-preserving extraction from source revision
+`643bc6f99d7b2249af0a85204768df243e612411`.
+
+## Port Boundary
+
+Freeze numerical behavior before reorganizing:
+
+- color contraction and planning;
+- process IR, enumeration, and all-outgoing crossing;
+- current identity and DAG construction;
+- lowering, phase-space generation, stage compilation, and Symbolica
+  evaluator construction;
+- built-in model parameters and kernels;
+- UFO model IR, tensor projection, contact decomposition, and propagators.
+
+Rewrite the CLI, artifact writer, loader boundary, logging, reporting, model
+asset access, generated API bundle, and Python runtime facade around those
+locked contracts. Validation-only Fortran adapters and reference kernels stay
+under developer tooling and are excluded from distributions.
+
+The extraction initially preserves both Standard Model implementations. The
+built-in path still uses its hard-coded production model, while UFO/JSON uses
+the compiled external-model path. Converging those implementations is a
+later, separately validated refactor.
+
+## Required Invariants
+
+- UFO and serialized JSON pass through the same `ufo-model-loader` model and
+  produce identical restricted, wrapped-index, canonical, and compiled model
+  representations.
+- External filtering, particle/antiparticle crossing, external order,
+  helicity bases, Weyl projection, propagators, spin-2 polarizations, and
+  n-ary contact decomposition are preserved.
+- A contact coupling is applied exactly once.
+- `CurrentIndex` retains every physics identity field. Optimized and
+  unoptimized DAGs agree point by point.
+- LC flow, reflection, helicity, averaging, coupling, and identical-particle
+  weights are each applied exactly once.
+- NLC/full performs one coherent sparse color contraction, applies the
+  off-diagonal factor two exactly once, and never reapplies an LC color
+  factor.
+- Inconsistent helicity weights in a contraction group are errors. They must
+  never be silently averaged.
+- Unsupported colored representations are errors. They must never be treated
+  as singlets.
+- Final-state permutation reuse is validated against fully materialized
+  direct artifacts. It is not described as generic crossing reuse.
+- Resolved evaluation executes one DAG. LC exposes physical
+  `(point, helicity, flow)` values; NLC/full exposes one contracted color
+  component per helicity. Structural zeros remain exact and resolved members
+  sum to the compatibility total.
+- A color-singlet LC axis may have an empty ordered color word. Every nonempty
+  LC word contains exactly once every external label whose model-derived color
+  representation is non-singlet.
+
+## Model Determinism
+
+The historical scalar UFO modules read `UFO_SCALARS_MODEL_*` and
+`UFO_GRAVITY_MODEL_*` environment variables without including them in the
+compiled-model cache key. Standalone model loading must start from a sanitized
+environment. Any retained model option becomes a typed input included in
+canonical content, provenance, and cache identity. The historical undefined
+`N_POINT_INTERACTIONS` gravity branch must be removed or corrected before the
+asset is shipped.
+
+## Reference Ladder
+
+The first frozen fixture-v2 bundle contains:
+
+- `d d~ > z`, `d d~ > z g`, and `d d~ > z g g` in LC/NLC/full;
+- scalar contact `scalar_0 scalar_0 > scalar_0 scalar_0`;
+- spin-2 `scalar_0 scalar_0 > graviton graviton`.
+
+The built-in-SM `d d~ > z` and `d d~ > z g` rows are also replayed through
+the pinned Fortran AmpliCol color probe in LC, NLC, and full color. This
+independent check covers the summed matrix element and every recorded nonzero
+physical-helicity component. The probe is developer-only, links no LHAPDF,
+and is never imported or packaged by the installed distribution.
+
+The next declarative capture revision first completes all low-multiplicity
+classes before retaining any higher-multiplicity output. It adds `u d~ > w+`,
+`d d~ > e- e+`, mixed- and same-flavour two-quark-line scattering,
+`g g > g g`, and `g g > t t~` in LC/NLC/full. Built-in masses and exact
+Fortran process-row, matching-row, and colour-order counts are independent
+capture contracts. The massive top case includes a high-precision threshold
+point. These cases become release evidence only after a clean candidate built
+from the committed recipe regenerates all fixture and evidence documents.
+
+Before the model/generation milestone is accepted the ladder then expands to:
+
+- process-set `d d~ > z g` and `d d~ > z g g`;
+- `d d~ > t t~` and `g g > t t~ g` at the next multiplicity;
+- identical-vector/Higgs interference;
+- scalar contacts with two, three, and five final scalars;
+- scalar propagation with mass, width, and coupling variations;
+- two and three final gravitons;
+- reordered final states for permutation reuse.
+
+Use at least three distinct deterministic generic points and one quantified
+unstable high-precision point for each substantive row. Each point records
+the external masses used for its on-shell check, and capture validates both
+four-momentum conservation and mass shells. Cross-language agreement checks
+one Rust core; release physics additionally requires pinned Fortran, analytic
+scalar, exact-color, and independent spin-2 oracles.
+
+Fixture schema v2 must retain decimal-string expectations per point rather
+than round-tripping high-precision values through binary64. It records complete
+helicity and color axes, every structural zero, topology and coverage, the
+complete reduction-group partition, normalization inputs, model and dependency
+provenance, and the independent oracle used for each point. Arithmetic
+precision, serialization width, and independently certified digits are
+distinct metadata; stored values are never claimed beyond the supporting
+oracle's certified accuracy. Fast gates may select one generic point from the
+complete fixture, but substantive tracked cases cannot weaken their declared
+physical axes. Each case hash covers its model dependencies, exact points,
+process, and the complete transitive source chain of any process alias.
+Compiled-model identity hashes the canonical semantic payload and excludes only
+conversion-duration and phase-timing diagnostics, which naturally differ
+between otherwise identical color-accuracy builds.
+
+Completeness is not inferred from the emitted axes. Each process records the
+external UFO spin code, color representation, mass, and runtime label in model
+order. The strict reader reconstructs the physical helicity Cartesian product
+and the exact set of labels required in each LC word. Every normalized oracle
+record has a recomputable whole-record hash in addition to any raw-transcript
+digest. Each reduction plan has a separate canonical hash and must partition
+every nonzero physical helicity/color cell exactly once. The three fixture
+documents become readable only after the bundle-v1 hash manifest is published
+last.
+
+The pinned Fortran adapter follows these additional rules:
+
+- run probes in isolated temporary working directories so the dependency
+  checkout remains read-only;
+- prefer an exact ordered external-PDG row, and persist the selected group,
+  integral, row PDGs, color order, source permutation, and match count;
+- identify repeated-PDG legs with stable external IDs and compare every
+  physical helicity. A single-flow LC case may be resolved directly; for
+  multiple flows the row-wise quadratic-contraction partitions are diagnostic
+  only, so the independent Fortran evidence certifies the per-helicity
+  aggregate rather than mislabeling those rows as physical resolved cells;
+- require every resolved or helicity-aggregate observation of a structural
+  zero to be exactly zero, independent of numerical tolerances;
+- treat the probe's LC, NLC, and full outputs as cumulative contractions, not
+  additive components;
+- compare fresh compiler output numerically with the tracked tolerances while
+  keeping process identity, axes, command, dependency provenance, structural
+  zeros, and capture metadata exact;
+- do not require the legacy oracle for three-quark-line cases, which exceed
+  the pinned implementation's supported process class.
+
+The next independent built-in-SM ladder proceeds through `d d~ > z`,
+`u d~ > w+`, `d d~ > e+ e-`, `d d~ > u u~`, `g g > g g`,
+`g g > t t~`, and `d d~ > g g g`. The last case is the smallest planned
+check with genuinely distinct LC, NLC, and full contractions.
+
+## Known Pre-Port Limitations
+
+- Existing schema-v2 artifacts have unconfined paths, no payload hashes,
+  ambiguous serialized-state fallbacks, nontransactional writes, and Python
+  pickle diagnostics. They are rejected, not migrated.
+- Resolved topology replay is not proven in the reference runtime. Schema v3
+  must not claim that capability until direct expanded-versus-replayed
+  resolved values pass.
+- The old 180-case cache came from a dirty, older revision and contains
+  absolute paths. It is not a release fixture and will be regenerated.
diff --git a/pyamplicol/docs/development/README.md b/pyamplicol/docs/development/README.md
new file mode 100644
index 0000000000..59621a909b
--- /dev/null
+++ b/pyamplicol/docs/development/README.md
@@ -0,0 +1,76 @@
+---
+title: "Development Documentation"
+nav_order: 7
+has_children: true
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Development Documentation
+
+This directory contains the stable contracts and decisions that supplement the
+source and tests:
+
+- [`API_CONTRACT.md`](API_CONTRACT.md)
+- [`CONFIG_CONTRACT.md`](CONFIG_CONTRACT.md)
+- [`PACKAGING_CONTRACT.md`](PACKAGING_CONTRACT.md)
+- [`PHYSICS_EXTRACTION_CONTRACT.md`](PHYSICS_EXTRACTION_CONTRACT.md)
+- [`ARCHITECTURE_DECISIONS.md`](ARCHITECTURE_DECISIONS.md)
+- [`ON_THE_FLY_MODE_ARCHITECTURE.md`](ON_THE_FLY_MODE_ARCHITECTURE.md)
+- [`MODEL_ASSET_PROVENANCE.md`](MODEL_ASSET_PROVENANCE.md) and
+  [`model-assets/`](model-assets/README.md)
+
+Historical feature plans, audit trails, milestone ledgers, and duplicated
+machine-readable summaries are deliberately not maintained here. Current
+behavior is defined by the implementation, tests, and contracts above.
+The on-the-fly architecture page is retained because it records the current
+production contract and validation boundary; its historical dispositions are
+explicitly labelled as such.
+
+## Linux source-test wheels
+
+The contributor installer and `just source-runtime` build a host-compatible
+Linux wheel for local tests, rather than claiming compatibility with an older
+manylinux platform. They explicitly pass the backend setting
+`--config-setting pyamplicol.host-wheel=true` to `python -m build --wheel`.
+Published dependencies are unchanged. Normal release builds still target
+`manylinux_2_28` and must run in the appropriate build environment; a host wheel
+is not a substitute for the audited release artifact.
+
+## Focused SymJIT dependency tests
+
+The source checkout includes small opt-in numerical/compiler regressions in
+`tests/integration/test_symjit_upstream_regressions.py`. They require Python
+3.11+, pytest and Cargo, but no pyAmpliCol native build or Symbolica installation.
+They are separate from full process-generation and performance tests.
+The reproducer bundles in `SYMJIT_FOLLOW_UP_FIXES/` and `DEPENDENCY_FIXES/`
+are local, untracked inputs; retain or supply those directories before running
+this optional suite. They are not included in a fresh checkout.
+
+```sh
+# Published SymJIT 2.25.4; outstanding regressions fail rather than being xfailed.
+PYAMPLICOL_RUN_SYMJIT_REGRESSIONS=1 \
+  python3 -m pytest tests/integration/test_symjit_upstream_regressions.py -q
+
+# Evaluate a local SymJIT source checkout instead, without modifying it.
+PYAMPLICOL_RUN_SYMJIT_REGRESSIONS=1 \
+PYAMPLICOL_SYMJIT_SOURCE=/absolute/path/to/symjit \
+  python3 -m pytest tests/integration/test_symjit_upstream_regressions.py -q
+```
+
+`just symjit-regressions` runs the same suite. The source-selection environment
+variable is honoured by either command. ARM-specific tests are skipped on other
+architectures. The root `SYMJIT_FOLLOW_UP_FIXES/README.md` maps the checks to the
+reported defects and explains the relevant pyAmpliCol evaluation paths.
+
+<!-- Page hierarchy for the MadGraph7 (Sphinx) documentation. -->
+```{toctree}
+:hidden:
+
+API_CONTRACT
+CONFIG_CONTRACT
+ARCHITECTURE_DECISIONS
+PACKAGING_CONTRACT
+PHYSICS_EXTRACTION_CONTRACT
+MODEL_ASSET_PROVENANCE
+model-assets/README
+ON_THE_FLY_MODE_ARCHITECTURE
+```
diff --git a/pyamplicol/docs/development/model-assets/README.md b/pyamplicol/docs/development/model-assets/README.md
new file mode 100644
index 0000000000..201a8deaae
--- /dev/null
+++ b/pyamplicol/docs/development/model-assets/README.md
@@ -0,0 +1,99 @@
+---
+title: "Packaged Model Assets"
+nav_order: 7
+parent: "Development Documentation"
+has_children: true
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Packaged Model Assets
+
+This directory records the release classification for the model resources under
+`pyamplicol/assets/models`. The machine-readable authority is
+`PROVENANCE.toml` in that package directory; `MANIFEST.sha256` is the single
+content manifest.
+
+## Selection Boundary
+
+The external-model inventory starts from the 67 tracked files under
+`pyAmpliCol/src/pyamplicol/assets/models` at AmpliCol revision
+`643bc6f99d7b2249af0a85204768df243e612411`: one historical manifest and 66
+payload files. Only the 66 payload Git blobs were selected. The duplicate
+`pyAmpliCol/assets/models` tree, ignored files, caches, bytecode, and source
+working-tree contents were not used.
+
+The packaged release set contains complete UFO directories and loader JSON
+examples for `sm`, `scalars`, and `scalar_gravity`. The historical built-in SM
+is code-backed by `pyamplicol/models/builtin.py`; its exact baseline source and
+companion symbol-table hashes are recorded as the `built-in-sm` model entry in
+`PROVENANCE.toml`. No second serialization of that implementation was invented.
+
+## Deterministic Changes
+
+The scalar UFO uses the historical defaults of three scalar particles and
+contact valences three through ten. Host environment variables can no longer
+change those values. The scalar-gravity UFO similarly fixes three scalar
+particles and removes its unused interaction-option branch, which referenced
+an undefined variable when enabled.
+
+JSON models and restriction cards were regenerated with
+`ufo-model-loader==0.1.8` at revision
+`70ddee6b416f8c8b340e0d087646d77095c5d24b`. Full model serializations use
+`restriction="full"`, simplification enabled, and `JSONLook.VERBOSE`.
+`sm_wrapped_indices.json` additionally enables Lorentz-index wrapping. The
+tracked `scalars_2p_3p.json` variant is reserialized from its own canonical
+content and freezes `N_SCALARS=3` with contact valences two and three; it does
+not retain a runtime environment option.
+
+The current JSONs also include the numerical parameter and coupling defaults
+computed by the loader. Their symbolic expressions and model contents are
+unchanged; restriction cards and the frozen scalar variant retain their
+existing serialization when regeneration produces identical contents.
+
+Each JSON restriction card is a complete serialization of its matching UFO
+`restrict_*.dat` card. Zero-valued parameters are therefore explicit. A
+separately supplied sparse JSON card remains an override map: omitted entries
+retain the unrestricted model defaults and are never inferred to be zero.
+
+Every changed source and result hash is listed in
+[TRANSFORMATIONS.md](TRANSFORMATIONS.md) and in `PROVENANCE.toml`.
+
+## Redistribution Classification
+
+The applicable notices are the root `LICENSE`,
+`licenses/GammaLoop-model-assets.txt`, and
+`licenses/MadGraph5_aMCatNLO.txt`. The exact loader license is preserved at
+`licenses/model-assets/ufo-model-loader-MIT.txt`. The MadGraph notice applies
+specifically to `ufo/sm/build_restrict.py`. Loader-generated JSON retains the
+terms of its source model; the loader itself is MIT licensed.
+
+All primary source identities point to exact AmpliCol baseline Git objects.
+For additional traceability, each record compares that source blob with the
+same path at GammaLoop revision
+`db79edc84f6a1580decbcc4ede7ea0b1c79d9a08`. Twenty-eight of 66 baseline
+payload blobs match that pinned revision exactly. The other 38 are not claimed
+as exact GammaLoop-revision content; their exact provenance stops at the
+AmpliCol baseline while GammaLoop remains the documented distribution origin.
+
+Under the repository's existing notices this inventory is release-eligible,
+so no file is in `nonrelease/`. If a notice is withdrawn or found insufficient,
+the affected complete model set must move to an explicitly excluded
+`nonrelease/` directory and release tests must fail with that reason. Individual
+files must not be silently dropped from a UFO model.
+
+## Integrity Contract
+
+`MANIFEST.sha256` lists every packaged file below the model root except the
+manifest itself, including `PROVENANCE.toml`. Paths are sorted POSIX-relative
+paths. Release tests require exact set equality, SHA-256 agreement, no symlinks,
+no traversal or absolute-path references, complete UFO module sets, JSON
+parseability, and `importlib.resources` access.
+
+Raw UFO modules execute Python and must only be loaded from trusted sources.
+The serialized JSON forms are preferred for portable workflows.
+
+<!-- Page hierarchy for the MadGraph7 (Sphinx) documentation. -->
+```{toctree}
+:hidden:
+
+TRANSFORMATIONS
+```
diff --git a/pyamplicol/docs/development/model-assets/TRANSFORMATIONS.md b/pyamplicol/docs/development/model-assets/TRANSFORMATIONS.md
new file mode 100644
index 0000000000..390b98bacd
--- /dev/null
+++ b/pyamplicol/docs/development/model-assets/TRANSFORMATIONS.md
@@ -0,0 +1,63 @@
+---
+title: "Model Asset Transformations"
+nav_order: 1
+parent: "Packaged Model Assets"
+grand_parent: "Development Documentation"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Model Asset Transformations
+
+The source hash is the SHA-256 of the selected blob at AmpliCol revision
+`643bc6f99d7b2249af0a85204768df243e612411`. The package hash is the SHA-256
+after the named deterministic transformation. Files absent from this table are
+copied byte-for-byte and have equal source and package hashes in
+`PROVENANCE.toml`.
+
+| Package-relative path | Transformation | Source SHA-256 | Package SHA-256 |
+|---|---|---|---|
+| `json/scalar_gravity/restrict_default.json` | `loader-restriction-card-v1` | `78e536276cfa98a854ea9b418a6de9437da1e21ea258fcc57ba2b20a6a691900` | `78e536276cfa98a854ea9b418a6de9437da1e21ea258fcc57ba2b20a6a691900` |
+| `json/scalar_gravity/scalar_gravity.json` | `loader-ufo-full-v1` | `e303fd1c39eb39e7deca5b36099202074a9048da3dbf2a73baf1f43a31648173` | `3bfc81548466ffc464fa72a3469a9c0c8930970bf048c64c43aee13c8e83bd72` |
+| `json/scalars/restrict_default.json` | `loader-restriction-card-v1` | `31e30e8bdbdaf4753e361269fcd0294f7d7c82956c0afe66052dd527aa4b864a` | `ffe7759b8efcc86e6d12d3797c2e63a91c18c07de1bace6a51ee02144ecbf218` |
+| `json/scalars/scalars.json` | `loader-ufo-full-v1` | `6085cb3b1307bfdf7f3bb709ac1df9354b0cef8b1a3f6316f673fa069c9d9c85` | `ca27b8cc228cd03db57556fc1c40298865a75269bf2744bee8c59c013eb28df7` |
+| `json/scalars/scalars_2p_3p.json` | `loader-json-canonical-v1` | `ba4a928f4bf28975ca861c85106559a6d2747326572751eec3448bf67a5f763a` | `0a268a9fc959036e166367155ab2eeca5c52f76927a89245f8964b9b33b2a8b5` |
+| `json/sm/restrict_c_mass.json` | `loader-restriction-card-v1` | `6b191f6d0c45a6e91ea867079b1095e37fc4882df1c1380e70312890959dc7a6` | `014e93a779812d9af1d3886143cebc8fd911e92f5f970aee4dfffe01429651f5` |
+| `json/sm/restrict_ckm.json` | `loader-restriction-card-v1` | `57f3ffbd0a0784d433bb9b01211299f29dde1ddd0182ee0b1e4a87dc3f2b5c73` | `be8bdca54507167d8ae4b33d0b0b77808052cd841d6fabd26a3d99926d915b99` |
+| `json/sm/restrict_default.json` | `loader-restriction-card-v1` | `9d357d17c254595dbf612b66d6b531c982eefb71432835360bbfd8b21dcf454b` | `8fdd48a3624620c1a15bab602f43a41519038cf69d8fef6aeaaaf13a3f1846c1` |
+| `json/sm/restrict_lepton_masses.json` | `loader-restriction-card-v1` | `a22a9de56e536cd7c4e4bd4707f5f95d3255fb0dffd49d9567ec9a659576bb76` | `3d9fe3095907cef03f889bd95b9630a2f836d70244f1b450cfd5d2764913531b` |
+| `json/sm/restrict_no_b_mass.json` | `loader-restriction-card-v1` | `2ca10cc1e02b34f226db983da9a787659257003e6d84001204389e8aef03dfa5` | `82d2fbc06f9d0b7daaed56673912d920ca459f435e9083deed2f4b716c2f4a30` |
+| `json/sm/restrict_no_masses.json` | `loader-restriction-card-v1` | `9bc6bba7b940da83484e5f43346ba202333669aaca578dfa110ed3fbc17514b8` | `f925921df1b66f010cd6f8cd348b5f4728ba37678e0733d8618cef3f2b4e610e` |
+| `json/sm/restrict_no_tau_mass.json` | `loader-restriction-card-v1` | `7560d6890d7cd26532f28865fb8f4092ffcbf49c54fa7a16e921e6b08c3f43e3` | `a26603f4f3572309dc7ce2f23295d5a8aec61d2f3c42a017341245e459648478` |
+| `json/sm/restrict_no_widths.json` | `loader-restriction-card-v1` | `9002d18be203c34418a3966f7cedc5d20844c317c55906efca32f51a38f1f183` | `fdc03507f82a3d98571b97ba0ab34f712dc0eb02b101f8308b96c6ab8490c08c` |
+| `json/sm/restrict_zeromass_ckm.json` | `loader-restriction-card-v1` | `2173adc123ef202816d56e20772747f8a513ce9294635e099fdbe4832329944d` | `b8b4376c82f9486266283a383a0347ec42498296180d92249e2e7a772e1a7e1a` |
+| `json/sm/sm.json` | `sm-standard-ufo-spinor-order-v1` | `684f75c88c7faf6832e9e8122970ec5fe98b9cd30bc989b7f8e1818c327fe165` | `c1222e3b70b71804e5212e994a3b76e2f098f7fc3ba1693c9f9c65578d7e3e00` |
+| `json/sm/sm_wrapped_indices.json` | `sm-standard-ufo-spinor-order-v1` | `b4221a0985ad5c6987c325a75012a3231995c604e44ad543d0b1ead22eb19404` | `e1ee0059f3fc534c462e98c358249acbce0a711171fcbfe41720a9a1f24b2933` |
+| `ufo/sm/lorentz.py` | `sm-standard-ufo-spinor-order-v1` | `cd578c286b038dd3daae396ebd1515cf36d8089b63a1d20247d2b797054b162b` | `1f13e8b63e2ecf428e2875e14bc6901ce49952e1cf2b18ea9934c8d4264e3559` |
+| `ufo/scalar_gravity/parameters.py` | `scalar-gravity-static-defaults-v1` | `68de6a8ab6ecb1f358a13954be99597bb30665d1e195b7395f8faf405bd8657e` | `01b0477e0b0e352f968a6d1bfd1e9724c505adc6dd5c1d39dd08e9da97cd9f00` |
+| `ufo/scalars/parameters.py` | `scalar-static-defaults-v1` | `7620698c89ec9a87eb11177f682627e9a334222d42b378c18e111b866f7c3ad0` | `7b11a9b1d84126d31f58d5c4752ea0fe0921074bfcb338ecd6ef4d2ad7da89a7` |
+
+## Standard UFO Spinor Order
+
+The upstream SM Lorentz structures index each fermion pair in the reverse of
+the standard UFO order, e.g. `FFV1 = Gamma(3,1,2)` instead of MadGraph's
+`Gamma(3,2,1)`, and the importer compensated for it, which made standard UFO
+models wrong for off-shell fermion lines. `sm-standard-ufo-spinor-order-v1`
+swaps the two fermion legs in the spinor slots of `ufo/sm/lorentz.py` and of
+the serialized JSON structures, so that they match the MadGraph SM; the
+importer reads the standard order.
+
+## Serialized Model Shape
+
+The regenerated unrestricted JSON models have these stable counts:
+
+| File | Particles | Vertices | Couplings | Lorentz structures |
+|---|---:|---:|---:|---:|
+| `sm.json` | 43 | 153 | 108 | 22 |
+| `sm_wrapped_indices.json` | 43 | 153 | 108 | 22 |
+| `scalars.json` | 3 | 276 | 1 | 8 |
+| `scalars_2p_3p.json` | 3 | 16 | 1 | 2 |
+| `scalar_gravity.json` | 4 | 11 | 14 | 8 |
+
+The historical wrapped SM JSON contained default-restricted counts while its
+serialized restriction field was unset. Regeneration makes it a complete,
+unrestricted wrapped-index model, consistent with its package name and the
+complete-model release requirement.
diff --git a/pyamplicol/docs/performance_reports/README.md b/pyamplicol/docs/performance_reports/README.md
new file mode 100644
index 0000000000..cb8b9c8453
--- /dev/null
+++ b/pyamplicol/docs/performance_reports/README.md
@@ -0,0 +1,93 @@
+---
+title: "Performance Reports"
+nav_order: 2
+parent: "Profiling and Benchmarking"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Performance Reports
+
+See [FullColor FFT Profiling](../user/fullcolor-fft-profiling.md) for the
+source-checkout driver, cluster resource limits, incremental top-ups,
+targeted overwrite, and render-at-any-time workflow that produces the FFT
+snapshots below.
+
+The repository publishes four selected rendered snapshots from manual
+measurement campaigns:
+
+- [MacBook M3 report](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/macbook_M3_pyAmpliCol.pdf)
+- [AMD EPYC report](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/EPYC_pyAmpliCol.pdf)
+- [FullColor FFT selected-helicity snapshot](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/summary_plots_final.pdf)
+- [FullColor FFT helicity-sum snapshot](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/summary_plots_final_helicity_sum.pdf)
+
+The first two PDFs are general host reports. The FullColor FFT selected-
+helicity snapshot times one shared known-nonzero helicity from helicity-general
+artifacts; the helicity-sum snapshot times the complete physical helicity sum.
+Both snapshots include genuine same-workload MadGraph standalone series. The
+fixed series uses the generated helicity-general standalone and selects the
+shared helicity through `MATRIX(P,NHEL,IC)`; it currently measures pure gluons
+through `n=5` and `d d~ > d d~ + gluons` through `n=6`. The independent summed
+series measures both families at `n=2..5` through MadGraph's generated
+`SMATRIX(P,ANS)` entry point with `USERHEL=-1`, native IDEN normalization, and
+warmed `GOODHEL` pruning. It does not reuse the fixed-helicity timings.
+The FFT PDFs are rolling development snapshots, not claims that every
+final-state multiplicity through `n=9` has completed.
+
+Their frontiers are curve-specific. Both fixed-helicity and helicity-sum OTF
+curves are requested only through final-state `n=6`; beyond that the publication
+protocol retains recurrence, AmpliCol, and Reference FFT where applicable.
+Pure-gluon OTF FFT reached the 3,600 s first-use runtime cap at `n=6` and retains
+its measured `n=5` point. The helicity-sum snapshot extends
+`d d~ > d d~ + gluons` through `n=6`, where every requested curve measured.
+OTF direct and FFT setup took 1,725.8 s and 1,607.9 s; their warmed runtimes were
+5.321 and 3.759 ms/point (1.416x faster with FFT), at 1.17 and 1.22 GiB peak
+RSS. These isolated measurements used a 10-hour time limit and 30 GiB
+process-tree guard and retain their own per-cell provenance.
+
+The FFT plots use a deliberately method-specific *setup time*. pyAmpliCol
+includes artifact generation, a fresh load, the first requested evaluation,
+and OTF family warm-up where applicable. Reference FFT includes its build,
+initialization, and first pass. AmpliCol includes process/color-object
+generation for the fixed workload, or process/raw-library generation and build
+plus the immutable snapshot for the summed workload. Warmed runtime remains a
+separate measurement after those boundaries.
+
+These PDFs are measurement-host results, not release-CI results. Raw JSON,
+generated TeX, build workspaces, attempts, logs, locks, and coordination state
+remain untracked. The blank/reset JSON and TeX resources installed by
+pyAmpliCol are campaign templates, not published measurements.
+
+Create or reset a self-contained campaign from any installed wheel with:
+
+```console
+pyamplicol profiling-campaign copy ./pyamplicol-profiling-campaign --force
+./pyamplicol-profiling-campaign/steer_performance_campaign.py run \
+  --workers 1 --table matrix --process-id 1 --multiplicity 1 \
+  --color-approximation lc --generation-mode non-union-flow \
+  --generation-engine recurrence --model built_in \
+  --no-dependencies-added --no-dashboard
+./pyamplicol-profiling-campaign/steer_performance_campaign.py refresh-pdf
+```
+
+The run above is the supported quick installation check: it measures only the
+final-state-multiplicity-one `d d~ > Z` recurrence cell. Broader selections
+produce the same report format as the two general host PDFs. Re-running
+`refresh-pdf` directly reproduces the PDF from the campaign's current results;
+no repository report data is required.
+
+Runtime attempts, artifacts, locks, and coordination state live visibly in
+`pyamplicol-profiling-campaign/campaign_artifacts/`. Moving or renaming the
+whole campaign directory moves that state with it; campaigns with the same
+basename in different parents remain independent. Historical repository-global
+`.artifacts` state is intentionally ignored.
+
+`--force` replaces the managed template files and resets only
+`campaign_artifacts/`, the managed PDF and summary IDs, measurement lineage,
+and known LaTeX byproducts. It preserves unrelated destination files and the
+recorded local-AmpliCol checkout. Stop an active campaign before resetting it;
+an active controller makes the command fail without removing state.
+
+All pyAmpliCol backends use installed resources. Measuring the optional
+original-AmpliCol reference additionally requires
+`--original-amplicol PATH_TO_COMPLETE_CHECKOUT`; without that checkout only
+that backend is reported unavailable. pyAmpliCol and the supported patched
+comparison checkout have no LHAPDF dependency.
diff --git a/pyamplicol/docs/user/architecture-overview.md b/pyamplicol/docs/user/architecture-overview.md
new file mode 100644
index 0000000000..daf65ba6f7
--- /dev/null
+++ b/pyamplicol/docs/user/architecture-overview.md
@@ -0,0 +1,284 @@
+---
+title: "Architecture Overview"
+nav_order: 6
+has_children: true
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Architecture Overview
+
+pyAmpliCol turns a model plus one or more process requests into a standalone
+schema-v3 executable artifact. Python owns configuration, model compilation,
+process planning, and artifact generation. Rusticol owns artifact loading,
+physics-aware process selection, optimized f64 execution, profiling, and the
+native ABI.
+
+This page describes stable public boundaries rather than internal module names.
+
+```text
+CLI or typed Python API
+          │
+          ▼
+schema-v1 configuration → model IR and process expansion
+          │
+          ▼
+recurrence / compiled / eager generation
+          │
+          ▼
+schema-v3 process artifact → Rusticol runtime
+                                  ├── Python
+                                  ├── C11
+                                  ├── C++17
+                                  ├── Fortran 2008
+                                  └── Rust 2021
+```
+
+## User surfaces
+
+One typed configuration registry drives:
+
+- schema-v1 TOML cards;
+- dedicated CLI flags and `--set` overrides;
+- frozen Python configuration dataclasses.
+
+The public Python root exports model/process types, configuration, `Generator`,
+`Runtime`, `BenchmarkRunner`, typed results, convenience helpers, and documented
+errors. Generation DAGs, evaluator payloads, Symbolica objects, and artifact
+writer internals remain private.
+
+See [Command-Line Interface](command-line-interface.md), [Configuration](configuration.md),
+and [Python API](python-api.md).
+
+## Model boundary
+
+The primary portable user input is serialized JSON model IR. Trusted UFO and
+JSON sources compile into the same canonical representation before process
+planning. A compiled model records particle/anti-particle relations, spin and
+statistics, color representation, mass and width policy, propagators,
+interactions, exact quantum numbers, and normalized tensors.
+
+Two model products have different roles:
+
+- a portable compiled-model JSON contains model IR and exact expressions;
+- a `.pyamplicol-model` bundle adds one prepared local-kernel backend for
+  recurrence or eager execution.
+
+When higher-point interactions are split into smaller kernels, model compilation
+also reduces their internal auxiliary currents. It examines every consuming
+kernel and both input orientations: unused components are removed, while
+components with identical or opposite coefficient columns are replaced by the
+corresponding signed sum of producer components. These are exact symbolic
+relations valid for all model parameters, not numerical approximations.
+Physical currents and externally prescribed bases are unchanged. The reduced
+kernels are stored in the compiled/prepared model, so this work is not repeated
+at the first process evaluation.
+
+Symbolic current weights, propagator phases and projector fractions are kept
+exact during this construction. In particular, multiplying an exact coefficient
+by a complex unit does not round it to binary64. This preserves cancellations
+when the same process output is evaluated with double-double or arbitrary
+precision.
+
+The hand-written built-in Standard Model is a compatibility model. Its aliases
+and optimized kernels do not define generic UFO/JSON behavior. Unsupported
+model features fail during preflight with structured diagnostics rather than
+falling back to built-in assumptions.
+
+See [Models and Processes](models-and-processes.md).
+
+## Process planning and representative reuse
+
+A single multiparticle request may expand into many concrete processes.
+Generation retains one evaluator representative per equivalent incoming and
+outgoing permutation class when possible. Stable IDs select representatives;
+readable process expressions select a requested public ordering.
+
+Rusticol resolves a unique side-preserving permutation and remaps momenta,
+particles, helicities, LC flows, reductions, selectors, and resolved metadata
+centrally. No leg crosses `>`, and ambiguous matches fail with their candidate
+stable IDs.
+
+See [Process Selection and Permutations](process-selection-and-permutations.md).
+
+## Four generation lanes
+
+All lanes implement the same public process artifact and runtime result:
+
+- **recurrence** writes current-recursion schedules over prepared local
+  kernels;
+- **compiled** writes process-local stage evaluators;
+- **eager** writes compact DAG invocation tables over prepared local kernels;
+- **on-the-fly** writes a compact process seed and builds the selected query
+  family on first use.
+
+Reusable contracted recurrence artifacts also carry one all-helicity
+physical-colour plan and a compact per-helicity row-group dispatch. The
+support metadata is used only during cold selector binding; warmed execution
+runs the selected rows directly. On-the-fly does not carry that recurrence
+companion: it builds and retains the requested family from its compact seed.
+
+The evaluator backend is a separate dimension: JIT, C++, or assembly. The
+default direct JIT stores a SymJIT application. Prepared recurrence/eager/OTF
+JIT kernels use the portable O2 storage contract.
+
+LC exposes physical color flows; NLC/full expose one contracted color output
+per helicity. The optimized total and resolved tensor are two views of the same
+runtime plan, and `ResolvedEvaluation.total()` must reproduce the optimized
+total.
+
+See [Generation Modes and Evaluators](generation-modes-and-evaluators.md).
+
+## Schema-v3 artifact boundary
+
+A generated artifact is a transactional, standalone executable input. It
+contains:
+
+- model and process metadata;
+- physical helicity/color axes and reductions;
+- execution-mode plans;
+- evaluator or prepared-kernel payloads;
+- configuration and generation records;
+- optional generated API drivers;
+- deterministic validation kinematics.
+
+The manifest confines payload paths and binds the runtime ABI, target,
+capabilities, references, sizes, and required content digests. Normal runtime
+loading checks the schema, identity-contract marker, path confinement, target,
+and ABI at the cheapest authoritative boundary. An explicit full payload hash
+audit is available when wanted; it is not repeated on every normal load.
+
+Artifacts are executable and must come from a trusted producer. Internal
+consistency hashes do not establish publisher identity.
+
+Generated artifact formats intentionally have no automatic compatibility shim.
+An old identity contract or runtime ABI fails with regeneration guidance.
+
+See [Artifacts and Portability](artifacts-and-portability.md).
+
+## Rusticol runtime boundary
+
+Rusticol core is Python-independent. It:
+
+- loads and validates the selected artifact/process;
+- applies public process permutations;
+- owns the optimized f64 execution engines;
+- resolves global and per-point selectors;
+- exposes resolved physical metadata;
+- applies atomic model-parameter updates;
+- measures runtime and native attribution;
+- implements C ABI version 1.
+
+The PyO3 extension and C ABI are boundary layers over the same core. The wheel
+also owns a header-only C++ wrapper, a Fortran module source, a dependency-free
+safe Rust wrapper, the static C ABI archive, and target link metadata.
+
+One runtime handle has mutable parameter and warning state and is not
+concurrently reentrant. Independent handles may run concurrently.
+
+## Native SDK and generated APIs
+
+Binary wheels contain a target-specific static SDK discovered with
+`rusticol-config`. Generation can emit an `API/` bundle with Python, C11,
+C++17, Fortran 2008, and Rust 2021 standalone checks.
+
+All five drivers support:
+
+- process selection by stable ID or side-preserving expression;
+- bundled or user-supplied kinematics;
+- UFO-style JSON parameter cards and direct overrides;
+- resolved evaluation and explicit comparison with the optimized total.
+
+Python supports precision-controlled exact evaluation when retained expressions
+permit it. Native APIs expose f64 only.
+
+Opt-in [Born Correlations](../correlators.md) use a separate Python exact
+executor over retained Symbolica states, with full-colour direct compiled
+amplitudes. This includes requests at precision 16; the native ABI and generated
+standalone drivers remain ordinary total/resolved evaluation interfaces.
+
+See [Native APIs](native-apis.md).
+
+## Symbolica and SymJIT boundary
+
+Python package startup imports Symbolica and attempts to register the
+pyAmpliCol library key. While valid, that package license covers model
+compilation, generation, and Python higher-precision or correlated evaluation
+without requiring a personal user key. Synchronous registration failure leaves
+the personal-license and restricted-mode paths available. Generation queries
+Symbolica's effective license state and records resource clamps.
+
+The default JIT artifact embeds a direct SymJIT application. Rusticol loads and
+executes that f64 state without importing Symbolica or applying its generation-
+time license/resource policy. Compatible precompiled C++/ASM payloads are also
+Symbolica-independent at f64. Generating any of those payloads still uses
+Symbolica.
+
+See [Symbolica and Licensing](symbolica-and-licensing.md).
+
+## Portability model
+
+Portability is authenticated from the complete executable content:
+
+- compiled all-JIT O1/O2 artifacts may use the `portable-64le` target and
+  rebuild native code on a supported receiving host;
+- JIT O0/O3, C++, ASM, and explicitly native-architecture payloads remain
+  target-specific;
+- prepared JIT O2 bundles are portable across supported x86-64 and AArch64
+  release hosts;
+- a single target-specific execution leaf makes the whole artifact
+  target-specific.
+
+Loaders reject incompatible target or CPU-feature requirements before running
+the evaluator.
+
+## Build and release boundary
+
+One locked Rust workspace builds both the Python extension and static SDK. The
+source distribution carries the release build backend and exact release
+dependency contract; contributor dependency state is checkout-only and cannot
+be substituted into a release build.
+
+Release publication consumes already validated wheels and one source
+distribution. It does not rebuild during upload. The supported platform matrix
+and publication boundary are recorded in
+[Release and Support](release-and-support.md).
+
+See [Release and Support](release-and-support.md).
+
+## Independent physics reference
+
+The optional original-AmpliCol Fortran comparison is developer/campaign
+infrastructure, not an installed runtime dependency. It provides an independent
+numerical reference. Agreement among ordinary Python and native f64 APIs
+validates a shared ABI and wrapper contract, but those operations all call
+Rusticol and are therefore not independent physics implementations.
+
+## Design principles
+
+- Model-generic behavior comes from explicit model metadata, not hard-coded SM
+  particle numbers or names.
+- Unsupported capabilities fail explicitly.
+- Public inputs and outputs follow the user's selected particle ordering.
+- Configuration, Python results, and public metadata are typed and immutable.
+- Normal runtime checks each invariant once at its authoritative boundary.
+- Performance instrumentation must not redefine the ordinary evaluation path.
+- Artifacts are self-contained; installations do not depend on another source
+  checkout.
+
+## Deeper contracts
+
+The repository maintains concise normative contracts for contributors:
+
+- [Public API contract](../development/API_CONTRACT.md)
+- [Configuration contract](../development/CONFIG_CONTRACT.md)
+- [Architecture decisions](../development/ARCHITECTURE_DECISIONS.md)
+- [Packaging contract](../development/PACKAGING_CONTRACT.md)
+- [Physics extraction contract](../development/PHYSICS_EXTRACTION_CONTRACT.md)
+- [On-the-fly mode architecture](../development/ON_THE_FLY_MODE_ARCHITECTURE.md)
+
+<!-- Page hierarchy for the MadGraph7 (Sphinx) documentation. -->
+```{toctree}
+:hidden:
+
+symbolica-and-licensing
+```
diff --git a/pyamplicol/docs/user/artifacts-and-portability.md b/pyamplicol/docs/user/artifacts-and-portability.md
new file mode 100644
index 0000000000..bb060aba42
--- /dev/null
+++ b/pyamplicol/docs/user/artifacts-and-portability.md
@@ -0,0 +1,283 @@
+---
+title: "Artifacts and Portability"
+nav_order: 3
+parent: "Python API"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Artifacts and Portability
+
+pyAmpliCol separates model inputs, prepared model bundles, and generated
+process artifacts. Understanding that boundary makes deployment predictable:
+you can move the right object, know when native code is rebuilt, and avoid
+mistaking an internal digest for publisher authentication.
+
+## Three related but different objects
+
+| Object | Typical suffix/path | Purpose |
+| --- | --- | --- |
+| Compiled model IR | `.pyAmplicol-model.json` | Architecture-independent normalized model, expressions, particles, parameters, and capabilities. |
+| Prepared model bundle | `.pyamplicol-model` | Compiled model plus one prepared local-kernel backend for recurrence/eager/OTF generation. |
+| Process artifact | directory containing `artifact.json` | Standalone selected processes, physics metadata, evaluators/schedules, model-parameter state, and optional API bundle. |
+
+A raw JSON or UFO model can feed process-local **compiled** generation. The
+default **recurrence**, **eager**, and **on-the-fly** modes require a compatible
+prepared model bundle; the installed `built-in-sm` and `built-in-sm-heft`
+models are exceptions because wheels already ship their portable JIT O2 packs.
+
+See [Models and Processes](models-and-processes.md) and [Generation Modes and Evaluators](generation-modes-and-evaluators.md) for producing each
+object.
+
+An optional **OTF cache file**, written by `runtime.save(path)`, is different
+from all three: it retains completed current-construction work for the loaded
+process. Keep the original process directory, load it normally, then call
+`runtime.load_cache(path)`. The cache contains no evaluated currents or model
+parameter values and cannot be loaded as a standalone process output. Its
+compatibility follows the matching process output and cache format, rather
+than providing a separate portability guarantee. See the
+[small save/restore example](runtime-and-selectors.md#saving-an-otf-warm-cache).
+
+## Process-artifact layout
+
+A generated root resembles:
+
+```text
+artifacts/pp_zjj/
+  artifact.json
+  process-groups.json
+  evaluators.pacbin
+  model/
+  processes/
+    p_p_to_z_j_j_1/
+    p_p_to_z_j_j_2/
+    ...
+  API/
+    python/
+    c/
+    cpp/
+    fortran/
+    rust/
+```
+
+The exact payload set depends on execution mode, backend, color accuracy,
+coverage, and whether the API bundle is enabled. Do not infer the contract from
+filenames; `artifact.json` declares all runtime-bearing payloads and their
+roles.
+
+Inspect without loading executable evaluator state:
+
+```console
+pyamplicol inspect artifacts/pp_zjj
+pyamplicol inspect artifacts/pp_zjj --json
+```
+
+The inventory reports process IDs and aliases, target, execution mode,
+capabilities, selector coverage, physical and logical evaluator counts,
+payload sizes, and dependency metadata.
+
+## Artifact identity
+
+`runtime.artifact_id` is the lowercase SHA-256 identity of runtime-bearing
+payload records under the current schema-v3 identity contract. It deliberately
+excludes provenance that cannot change runtime behavior, such as requested and
+effective configuration records, validation momenta, timing, the
+`process-groups.json` map of subprocesses with equal matrix elements, and
+report-only metadata.
+
+```python
+from pyamplicol import Runtime
+
+runtime = Runtime.load("artifacts/pp_zjj", process="d d~ > g z g")
+print(runtime.artifact_id)
+```
+
+This content label answers “is this the same declared runtime payload?” It does
+**not** answer “who published this artifact?”
+
+Artifacts must explicitly carry the current identity-contract marker and
+runtime ABI. Old internal process-artifact formats are not automatically
+migrated; regenerate them with the current pyAmpliCol version.
+
+## Fast loading versus an explicit checksum audit
+
+Normal loading validates the inexpensive authoritative boundary:
+
+- JSON/schema and identity-contract shape;
+- confined relative paths and references;
+- process/runtime capability coherence;
+- target and CPU compatibility;
+- native runtime ABI.
+
+It intentionally does not rehash every payload. Rehashing a multi-gigabyte
+PACBIN file before every evaluation would duplicate work and can dominate
+startup without changing the artifact.
+
+When a full on-disk corruption audit is specifically wanted, request it once:
+
+```python
+from pyamplicol.artifacts import load_manifest, validate_payloads
+
+manifest = load_manifest("artifacts/pp_zjj")
+validate_payloads(manifest)
+```
+
+That explicit audit recomputes the manifest identity, sizes and SHA-256 hashes
+of declared payloads, executable bits, symlink/path constraints, and target
+compatibility.
+
+Artifact writing always validates the structure and declared payload records
+it creates. Optional post-build runtime validation is a different operation: it
+reopens the completed artifact and compares optimized and resolved f64
+evaluation. It is off by default because this second runtime pass does not
+modify the artifact and can become disproportionately expensive for large
+resolved axes. Enable it only when an immediate runtime smoke is valuable:
+
+```console
+pyamplicol generate --card run.toml --post-build-validation
+```
+
+The configured `generation.validation.samples` controls that optional reopened
+runtime smoke. It is independent of high-precision numerical-current relation
+certification performed during generation.
+
+## Portability matrix
+
+| Artifact/backend | Target metadata | Can move between supported x86-64 and arm64 hosts? |
+| --- | --- | --- |
+| Compiled all-JIT O1 or O2 process artifact | `portable-64le`, empty CPU-feature set | **Yes**, on supported 64-bit little-endian hosts. |
+| Eager/recurrence process artifact using a prepared JIT O2 pack | `portable-64le`, empty CPU-feature set | **Yes**, on supported 64-bit little-endian hosts. |
+| Prepared JIT O2 model bundle | portable SymJIT storage-v3 | **Yes**, between supported x86-64 and arm64 hosts. |
+| Compiled JIT O0 or O3 process artifact | concrete target, empty CPU-feature set | No; regenerate on the destination. |
+| C++ or ASM process artifact | concrete target; CPU features when native specialization is enabled | No; requires exact compatible target/features. |
+| C++ or ASM prepared bundle | target-native | No. |
+| Compiled model IR (`.json`) | architecture-independent | Yes; it contains no executable prepared backend. |
+
+For a portable compiled all-JIT artifact, Rusticol verifies that every
+executable leaf and nested selector path is O1 or O2 SymJIT. Eager and
+recurrence artifacts separately require a portable, exact-O2 prepared pack.
+In every case, a target-specific capability prevents the portable marker.
+Rusticol rebuilds executable code for the receiving CPU when the artifact is
+loaded.
+
+`portable-64le` is an executable portability claim, not a claim that benchmark
+results transfer between hosts. Profiling measurements and campaign currents
+remain host/profile-specific.
+
+## Why some JIT artifacts are still target-specific
+
+JIT O0/O3 may specialize code and metadata for the producing host. C++ and ASM
+artifacts contain target-native libraries. Their manifest records a concrete
+triple and required CPU features, and loading fails before executable state is
+opened if the destination is incompatible.
+
+For compiled mode, O1 and the default O2 are both portable choices. Prepared
+eager/recurrence packs use the exact-O2 portability contract. To maximize a
+specific machine's process-local performance with explicit O3, plan to
+generate and deploy on a matching target.
+
+## PACBIN evaluator containers
+
+JIT evaluator state is stored as indexed logical members in a single
+`evaluators.pacbin` container. Inspection distinguishes:
+
+- physical file count and on-disk size;
+- indexed evaluator member count;
+- logical unpacked evaluator size.
+
+It does not extract one filesystem object per evaluator.
+
+On Unix, runtime loading copies a PACBIN-backed artifact into anonymous memory,
+removes write access from that mapping, and parses it there. Replacing,
+truncating, or mutating the path afterward cannot change the running evaluator.
+Plan for virtual memory and RAM or swap approximately equal to the loaded
+PACBIN size for the handle's lifetime; no temporary filesystem space is
+required.
+
+Target-native C++/ASM evaluator libraries use an analogous executable snapshot
+root controlled by `PYAMPLICOL_NATIVE_SNAPSHOT_ROOT`. Its filesystem must
+permit executable mappings.
+
+## Prepared models and standalone process artifacts
+
+A prepared bundle is a **generation input**, not a runtime dependency of the
+resulting process artifact. Eager, recurrence, and OTF generation copy only the
+needed kernels plus their compact tables, schedules, or process seed into the
+process artifact. A machine that evaluates that artifact does not need the
+original `.pyamplicol-model` bundle.
+
+For example:
+
+```console
+pyamplicol model compile models/json/sm/sm.json \
+  models/ufo-sm-jit-o2.pyamplicol-model \
+  --backend jit --jit-optimization-level 2
+
+pyamplicol generate 'd d~ > z g g g' artifacts/ddbar_z3g_eager \
+  --model models/ufo-sm-jit-o2.pyamplicol-model \
+  --execution-mode eager
+```
+
+The second artifact is self-contained for supported runtime APIs.
+
+## Transactional writing and replacement
+
+Generation writes artifacts transactionally. The output mode is explicit:
+
+| Mode | Behavior |
+| --- | --- |
+| `error` | Refuse an existing output (default). |
+| `append` | Extend only under the supported compatible multiprocess contract. |
+| `replace` | Build a replacement and atomically install it. |
+
+Use a separate output for materially different configuration during
+experimentation. Avoid manually editing a sealed artifact: its declared size,
+digest, and semantic links will no longer match.
+
+The one supported in-place update is `pyamplicol group-processes`, which
+rewrites `process-groups.json` (payload role `process-groups`) and its record
+in `artifact.json` under the same lock that serializes generation. The artifact
+ID does not change. An append keeps the stored groups and adds the new
+subprocesses.
+
+## Copying and archiving
+
+Copy the **entire** artifact directory. Preserve ordinary file contents and
+executable bits; do not copy only `artifact.json` and selected payloads.
+
+```console
+rsync -a artifacts/pp_zjj/ remote:/srv/processes/pp_zjj/
+```
+
+After transfer, either load it normally (fast schema/target boundary) or run
+one explicit `validate_payloads()` audit when the transport channel warrants
+it. Do not add a full checksum pass to every runtime invocation.
+
+Process artifacts are trusted executable inputs. Direct SymJIT applications
+are lowered to native code, and C++/ASM artifacts contain native libraries.
+Generate them yourself or receive them through a channel you trust.
+
+## Campaign artifacts are a separate state layer
+
+A profiling campaign stores generated process artifacts, attempts, and current
+pointers below its own visible `campaign_artifacts/` root. Move the entire
+campaign directory to move that state. Do not transplant individual current
+pointer files between campaigns. See [Profiling Campaigns](profiling-campaigns.md).
+
+## Common compatibility failures
+
+| Message or symptom | Meaning | Next step |
+| --- | --- | --- |
+| Target triple mismatch | Target-native artifact moved to a different architecture/OS. | Regenerate there or use a portable JIT artifact: compiled O1/O2, or eager/recurrence with a prepared O2 pack. |
+| Required CPU feature unavailable | Artifact was specialized beyond the destination CPU. | Regenerate with compatible settings. |
+| Old identity contract / runtime ABI | Artifact predates the current internal format. | Regenerate; there is no compatibility shim. |
+| Payload size/digest mismatch during explicit audit | Files changed or transfer was incomplete. | Restore from a trusted source or regenerate. |
+| PACBIN load consumes substantial memory | Container is intentionally snapshotted into anonymous read-only memory. | Size deployment memory for the artifact or generate a smaller/specialized artifact. |
+
+See [Troubleshooting](troubleshooting.md) for environment and API-driver failures.
+
+## Related pages
+
+- [Runtime and Selectors](runtime-and-selectors.md) — load, select, and evaluate a process.
+- [Native APIs](native-apis.md) — consume the same artifact from five languages.
+- [Models and Processes](models-and-processes.md) — compiled and prepared model inputs.
+- [Release and Support](release-and-support.md) — validated wheel and source-distribution boundary.
+- [Packaging contract](../development/PACKAGING_CONTRACT.md).
diff --git a/pyamplicol/docs/user/command-line-interface.md b/pyamplicol/docs/user/command-line-interface.md
new file mode 100644
index 0000000000..c536673d71
--- /dev/null
+++ b/pyamplicol/docs/user/command-line-interface.md
@@ -0,0 +1,539 @@
+---
+title: "Command-Line Interface"
+nav_order: 5
+parent: "Configuration"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Command-Line Interface
+
+The `pyamplicol` command covers the complete user workflow: inspect or compile a
+model, plan or generate process artifacts, inspect their physics axes, evaluate
+phase-space points, and profile the optimized runtime. The same schema also
+drives the typed [Python API](python-api.md).
+
+> [!TIP]
+> Start with the four-card walkthrough in [Quick Start](quick-start.md). This page
+> is a command map, not a requirement to configure every available switch.
+
+## Command map
+
+| Command | Purpose | Typical use |
+| --- | --- | --- |
+| `generate` | Plan or write a process artifact | `pyamplicol generate "d d~ > z g" artifacts/builtin_ddbar_to_zg --model built-in-sm` |
+| `evaluate` | Evaluate totals or resolved components | `pyamplicol evaluate artifacts/builtin_ddbar_to_zg --momenta point.json` |
+| `profile` | Calibrate and measure the optimized total path | `pyamplicol profile artifacts/builtin_ddbar_to_zg --target-runtime 1` |
+| `benchmark` | Compatibility alias for `profile` | Existing cards use `action = "benchmark"` |
+| `inspect` | Show artifact and process metadata without running it | `pyamplicol inspect artifacts/builtin_ddbar_to_zg` |
+| `group-processes` | Find generated subprocesses with equal matrix elements | `pyamplicol group-processes artifacts/pp_jj` |
+| `model inspect` | Summarize a built-in, JSON, UFO, or compiled model | `pyamplicol model inspect models/json/sm/sm.json` |
+| `model compile` | Compile portable model IR or a prepared kernel bundle | See [Models and Processes](models-and-processes.md) |
+| `model processes` | Expand and inspect a process request without generating it | `pyamplicol model processes "p p > all all" --model built-in-sm` |
+| `config template` | Write the exhaustive schema-v1 TOML template | `pyamplicol config template run.toml` |
+| `config resolve` | Show requested and effective settings | `pyamplicol config resolve run.toml` |
+| `examples list` | List shipped card names, actions, and descriptions | `pyamplicol examples list` |
+| `examples copy` | Create an editable, self-contained example workspace | `pyamplicol examples copy ./pyamplicol-examples --force` |
+| `examples run` | Run one named packaged card in a private cache workspace | `pyamplicol examples run evaluate_total` |
+| `profiling-campaign copy` | Create a self-contained performance campaign | See [Profiling Campaigns](profiling-campaigns.md) |
+| `doctor` | Diagnose the installed runtime and SDK | `pyamplicol doctor` |
+| `self-test` | Run the installed-package smoke test | `pyamplicol self-test` |
+
+License-request helpers are documented in
+[Symbolica and Licensing](symbolica-and-licensing.md).
+
+Run `pyamplicol COMMAND --help` for the options accepted by a command. For the
+model family, place `--help` after the second verb, for example
+`pyamplicol model compile --help`.
+
+## Cards, direct options, and overrides
+
+There are three equivalent ways to supply configuration:
+
+1. a schema-v1 TOML card;
+2. dedicated command-line options;
+3. repeated `--set PATH=VALUE` overrides.
+
+Configuration precedence is:
+
+```text
+defaults < TOML card < dedicated CLI options < repeated --set overrides
+```
+
+Any license or resource clamp is applied last and reported in the effective
+configuration. Unknown fields are errors rather than silently ignored.
+
+Run a card directly:
+
+```console
+pyamplicol generate_pp_zjj_from_ufo_sm.toml
+```
+
+Use an explicit action when the same card supplies shared settings:
+
+```console
+pyamplicol generate --card qq_z6g_recurrence_jit_o2.toml
+pyamplicol profile --card qq_z6g_recurrence_jit_o2.toml
+```
+
+Override one leaf without editing the card:
+
+```console
+pyamplicol generate_pp_zjj_from_ufo_sm.toml \
+  --set generation.workers=2 \
+  --set generation.mode=replace
+```
+
+`--set` is deliberately repeatable and order-sensitive. For commonly used
+fields, prefer the readable dedicated form—for example `--workers 2`,
+`--execution-mode eager`, or `--color-accuracy nlc`.
+
+For the complete field reference, see [Configuration](configuration.md) or create
+an annotated local template:
+
+```console
+pyamplicol config template pyamplicol.toml
+```
+
+## Generate
+
+The shortest built-in-model command is:
+
+```console
+pyamplicol generate "d d~ > z g" artifacts/builtin_ddbar_to_zg \
+  --model built-in-sm
+```
+
+Useful generation options include:
+
+- `--process EXPRESSION` to add another request;
+- `--name NAME` to name a request;
+- `--multiparticle 'p=d,d~,g'` to define a multiparticle label;
+- `--flavor-scheme N` and `--max-quark-lines N` to constrain expansion;
+- `--flavor-blind` to generate one subprocess per flavour-relabelling class
+  (see [Group equivalent subprocesses](#group-equivalent-subprocesses));
+- `--analyze-process-groups {none,numerical}`, `--only-unit-multiplier`, and
+  `--[no-]consider-charge-conjugation` to search the generated subprocesses
+  for equal matrix elements;
+- `--color-accuracy {lc,nlc,full}`;
+- `--color-contraction {direct,symmetric-group-fft}`;
+- `--fft {trace,adjoint}` as a shorthand selecting symmetric-group FFT and its basis;
+- `--correlators FILE.json` to prepare named colour operators and allowed spin
+  replacements for the [Python and native correlated APIs](../correlators.md);
+- `--lc-flow-layout {topology-replay,all-flow-union}`;
+- `--execution-mode {recurrence,compiled,eager,on-the-fly}`;
+- `--backend {jit,asm,cpp}`;
+- `--workers auto|N`;
+- `--mode {error,append,replace}` or the `--force` shortcut for replacement;
+- `--no-emit-api-bundle` when standalone drivers are not wanted;
+- `--numerical-current-reuse` to search for certified numerical current
+  relations at generation time (off by default because the high-precision
+  probes are costly);
+- `--post-build-validation` for an optional immediate native total-versus-
+  resolved smoke after writing the artifact.
+
+Planning is non-writing:
+
+```console
+pyamplicol generate "p p > Z j j" artifacts/unused \
+  --model models/json/sm/sm.json \
+  --multiparticle 'p=d,d~,g' --multiparticle 'j=d,d~,g' \
+  --flavor-scheme 2 --max-quark-lines 2 \
+  --execution-mode compiled --dry-run
+```
+
+Adaptive `--fft adjoint` is the recommended starting point for exact FFT colour
+contraction. It selects certified DDM where valid and otherwise retains exact
+fundamental-chain or trace tensors. Select contracted colour and
+a supported execution lane (`recurrence` or `on-the-fly`) explicitly:
+
+```console
+pyamplicol generate "g g > g g g" artifacts/ggg_adjoint_fft \
+  --model built-in-sm --color-accuracy full \
+  --fft adjoint --execution-mode recurrence
+```
+
+Use `--execution-mode on-the-fly` for the compact OTF counterpart. The same
+option works for quark processes, using their existing fundamental chains:
+
+```console
+pyamplicol generate "d d~ > z g g" artifacts/quark_zgg_fft \
+  --model built-in-sm --color-accuracy full \
+  --fft adjoint --execution-mode recurrence
+```
+
+For a certified `n`-gluon tree, DDM fixes two gluon anchors and retains
+`(n-2)!` orderings instead of `(n-1)!`. Certified single-insertion HEFT also
+uses DDM: see `examples/builtin_sm_heft.toml`, which explicitly sets `HIG = 1`.
+Other interactions retain their exact trace representation; multi-quark-line
+processes retain fundamental-chain products, not a JO primitive basis.
+The saved `fft_basis_selection` states the requested and actual basis and the
+selection reason. `--fft trace` forces the original representation.
+Both requests preserve `full` or `nlc` accuracy; forced adjoint FFT rejects correlations.
+In the benchmarked pure-gluon family the adjoint basis was faster than trace
+for six or more external gluons (3.9x per sample and 4x faster generation at
+ten gluons); at lower multiplicity the two are comparable, so compare warmed
+evaluation and setup costs for other workloads.
+`--color-contraction symmetric-group-fft` remains valid and defaults to adjoint.
+Without an explicit contraction flag, NLC/full recurrence and on-the-fly
+generation automatically try adaptive adjoint FFT and fall back to direct if
+the FFT plan is unsupported. LC, compiled/eager, and correlated generation
+remain direct/trace. Use `--color-contraction direct` to opt out.
+Do not combine `--fft` and `--color-contraction`; use either spelling. Card
+settings are overridden by dedicated flags, then by ordered `--set` options
+as usual.
+
+For the dedicated direct/FFT/reference scaling scan, see
+[FullColor FFT Profiling](fullcolor-fft-profiling.md).
+
+`--dry-run` performs the operation exposed as `Generator.plan()`. It creates no
+artifact, output directory, or model-cache entry. A raw UFO or JSON source must
+already have a reusable compiled-model cache entry, or be compiled explicitly,
+because planning never compiles trusted model input as a side effect.
+
+See [Generation Modes and Evaluators](generation-modes-and-evaluators.md) before
+combining execution modes and prepared-model backends.
+
+### Correlated Born quantities
+
+The [Born Correlations guide](../correlators.md#json-and-command-line) gives the
+declaration format and complete runtime examples:
+
+```console
+pyamplicol generate 'g g > g g' artifacts/gg_correlated \
+  --model built-in-sm --color-accuracy full --correlators correlators.json
+```
+
+`--correlators` is a generation option, separate from the ordinary TOML colour
+settings. `--color-accuracy lc|nlc|full` selects the correlated approximation
+(the ordinary default is LC). Complete amplitudes are generated in all cases;
+direct contraction and generic compiled execution are selected, with those
+adjustments recorded in the effective configuration. Partial
+helicity/colour generation, append, and `--dry-run` are not supported on this
+path. Numerical spin-vector setting and correlated evaluation use
+`Runtime.set_spin_correlation_vectors(...)` and
+`Runtime.evaluate_correlated(...)` or `Runtime.evaluate_correlated_many(...)`
+in Python, or the corresponding [native SDK calls](native-apis.md#correlated-born-evaluations),
+not the CLI `evaluate` command.
+
+## Inspect and select a process
+
+List an artifact's stable process IDs and coverage:
+
+```console
+pyamplicol inspect artifacts/pp_zjj
+```
+
+Focus on one public process ordering:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --process 'd d~ > g z g'
+```
+
+The selector may be a stable process ID, an explicit alias ID, an exact stored
+expression, or a unique side-preserving permutation of one. See
+[Process Selection and Permutations](process-selection-and-permutations.md) for
+the ordering contract.
+
+Inspection does not execute evaluator state. Human output uses compact colored
+tables; machine output is available with `--json`.
+
+The `Process groups` section shows the artifact's
+[process-group map](process-grouping.md): an overview row, then one table of
+groups, each representative in bold followed by its members. Colours mark
+`generated` (green) and `routed` (cyan) members, `C` (magenta), factors other
+than 1 and warnings (yellow), and the basis of each relation. For example, for
+`p p > j j j j` generated with `--flavor-blind --analyze-process-groups
+numerical` (abridged):
+
+```text
+Process groups
+
++--------+--------------+-----------+--------+------------+-------------+------------------+-----------+----------+
+| groups | subprocesses | generated | routed | conjugated | factor != 1 | bases            | analyses  | warnings |
++--------+--------------+-----------+--------+------------+-------------+------------------+-----------+----------+
+|     23 |          486 |        23 |    463 |        140 |           0 | flavor-blind 463 | numerical |        0 |
++--------+--------------+-----------+--------+------------+-------------+------------------+-----------+----------+
+
++--------------------+---------------------------------------------------------------------------------------------+
+| representative     | members                                                                                     |
++--------------------+---------------------------------------------------------------------------------------------+
+| d d > d d d d~     |  4 routed    u u > u u u u~      s s > s s s s~      c c > c c c c~      b b > b b b b~     |
+| p_p_to_j_j_j_j_1   |  5 routed C  d~ d~ > d d~ d~ d~  u~ u~ > u u~ u~ u~  s~ s~ > s s~ s~ s~  c~ c~ > c c~ c~ c~ |
+| 10 subprocesses    |              b~ b~ > b b~ b~ b~                                                             |
++--------------------+---------------------------------------------------------------------------------------------+
+...
++--------------------+---------------------------------------------------------------------------------------------+
+
+routed: not generated, evaluated through its representative; C: charge-conjugated relation
+compact view of 486 subprocesses; IDs and leg permutations: --json; one group row by row: --process REPRESENTATIVE
+numerical analysis: 3 points, tolerance 1e-09
+```
+
+`routed` members are not generated and are evaluated through their
+representative; `C` marks a charge-conjugated relation. A map with at most 80
+subprocesses is listed one member per row, with its process ID, role, and
+basis, plus a factor column when a factor differs from 1, a `C` column when a
+relation is conjugated, a permutation column when a leg permutation is not the
+identity, and a `note` column with `[n]` references to the warnings printed
+below the table. Larger maps list each group's members as a grid of process
+strings, one block per relation; subprocesses alone in their group are listed
+as `ungrouped`. When every process is its own group, the section is the single
+line `Process groups: none; each of the N processes is its own group`. With
+`--process`, only the selected process's group is shown, so `--process
+REPRESENTATIVE` lists a large group member by member. A routed member has no
+runtime process of its own: without `--full-physics`, selecting it stops with
+an error that names its representative. `--json` reports the
+complete map under `process_groups`: `stored`, `analyses`, and per group the
+`representative_id`, `representative`, and `members` (`id`, `process`, `pdgs`,
+`initial_count`, `factor` as a fraction string, `permutation`, `conjugated`,
+`basis`, `generated`, `warning`).
+
+`--process MEMBER --full-physics` on a grouped process adds a `Process Group`
+table, and a `process_group` object to the JSON. For a member, it gives the
+representative, factor, conjugation and the leg permutation from the
+representative to the requested leg order; for a representative, the size of
+its group, and that permutation when the requested leg order is not the stored
+one:
+
+```text
++-----------------------------------------------------------------------------------------+
+|                                      Process Group                                      |
++----------------+------------------------------------------------------------------------+
+| field          | value                                                                  |
++----------------+------------------------------------------------------------------------+
+| role           | routed member: not generated, evaluated through the representative     |
+| representative | p_p_to_j_j_j_j_52  d u~ > d d d~ u~                                    |
+| factor         | 1                                                                      |
+| conjugated     | yes (C)                                                                |
+| permutation    | p = [1 0 4 5 3 2]: representative leg r takes the momentum of leg p[r] |
+| basis          | flavor-blind                                                           |
+| group          | 40 subprocesses: 1 generated, 39 routed, 20 conjugated                 |
++----------------+------------------------------------------------------------------------+
+```
+
+## Group equivalent subprocesses
+
+Every artifact records in `process-groups.json` which subprocesses share one
+matrix element, up to a rational factor and a leg permutation. By default each
+generated subprocess is its own group.
+
+`generate --flavor-blind` assumes that subprocesses related by a relabelling of
+flavours with equal spin, colour, mass, and width (and, unless
+`--no-consider-charge-conjugation`, by charge conjugation) are equal. Only one
+representative per class is generated; the others are recorded as its members
+and exported to UMAMI through the representative's runtime. The assumption is
+not verified: a warning names the members whose relabelling is not a symmetry
+of the model couplings, for example electroweak couplings of different quark
+flavours.
+
+Generation logs the outcome of this pre-grouping before any representative is
+generated:
+
+```text
+INFO pyamplicol.generation: Flavor-blind grouping: 486 subprocesses -> 23 generated representatives; 463 routed members (140 by charge conjugation); 0 relabelling warnings
+```
+
+The summary table printed at the end has a `process grouping` row, coloured
+like the `inspect` display, read from the written `process-groups.json`
+(abridged):
+
+```text
+| processes              | 23 requests                                                                              |
+| process grouping       | 486 subprocesses -> 23 groups: 23 generated, 463 routed                                  |
+|                        | 463 flavor-blind relations (140 charge-conjugated); 0 warnings                           |
+|                        | numerical analysis: 3 points, tolerance 1e-09                                            |
+```
+
+Its first line counts the subprocesses, groups, and generated and routed
+subprocesses; the second, the relations by basis, those that are
+charge-conjugated or have a factor other than 1, and the relabelling warnings;
+the last ones, each recorded numerical analysis. The `Generated Processes`
+table gains a `group` column: the size of each representative's group, or
+`member of REPRESENTATIVE` for a member generated in its own right, followed by
+its factor when it is not 1 and `C` when the relation is conjugated, as in
+`member of d_dbar_to_a_a (x16)`. When
+every subprocess is its own group, the column is omitted, and so is the row
+unless an analysis was recorded; the row then reads `no relation found; each of
+the N processes is its own group`.
+
+The numerical analysis compares generated subprocesses with equal external
+particle types at three random phase-space points and merges those whose
+resolved components agree up to one common rational factor:
+
+```console
+pyamplicol generate "p p > j j" artifacts/pp_jj --analyze-process-groups numerical
+pyamplicol group-processes artifacts/pp_jj --only-unit-multiplier
+```
+
+`group-processes` runs the numerical analysis (its default) on an existing
+artifact and rewrites `process-groups.json` in place; the artifact ID and the
+UMAMI export are unchanged. `--only-unit-multiplier` accepts only relations
+with factor 1. Subprocesses generated with a selected helicity or colour subset
+are never grouped numerically. [Process Grouping](process-grouping.md)
+describes the relations, the warnings and the file format in full.
+
+## Evaluate
+
+Evaluate a momenta file with optional parameter updates:
+
+```console
+pyamplicol evaluate artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --model-parameters data/model_parameters.json \
+  --momenta data/pp_zjj_momenta.json
+```
+
+Request all physical components rather than only the optimized sum:
+
+```console
+pyamplicol evaluate artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json \
+  --resolved
+```
+
+Global selectors may be repeated:
+
+```console
+pyamplicol evaluate artifacts/pp_zjj \
+  --process p_p_to_z_j_j_3 \
+  --helicity 'h:-1,+1,-1,+1,+1' \
+  --color-flow 1 \
+  --momenta data/pp_zjj_momenta.json
+```
+
+`--color-flow` accepts either a stable flow ID or the one-based ordinal shown
+by `inspect`. Flow selection is LC-only; NLC and full-color artifacts expose a
+contracted color output and accept helicity selection only. More examples are
+in [Runtime and Selectors](runtime-and-selectors.md).
+
+## Profile
+
+The profiler measures the same optimized total path as `Runtime.evaluate()`:
+
+```console
+pyamplicol profile artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json \
+  --target-runtime 1.0 \
+  --batch-size 128 \
+  --color-flow 1 \
+  --precision 16
+```
+
+It calibrates repetitions, keeps at least the requested independent sample
+count, and reports uncertainty. `Ctrl-C` during sampling preserves completed
+blocks and prints a result marked partial. See
+[Profiling and Benchmarking](profiling-and-benchmarking.md) for metric meanings
+and selector-aware profiling. If both profile selector axes are omitted, the
+stored LC layout supplies a deterministic optimized selector; explicit
+non-hot shapes are retained and produce at most one pre-loop warning per
+loaded process.
+
+## Models
+
+Inspect a trusted UFO directory without generating a process:
+
+```console
+pyamplicol model inspect models/ufo/sm
+```
+
+Compile portable model IR:
+
+```console
+pyamplicol model compile models/ufo/sm models/sm.pyAmplicol-model.json
+```
+
+Prepare a reusable JIT-O2 kernel bundle for eager or recurrence execution:
+
+```console
+pyamplicol model compile \
+  models/json/sm/sm.json models/ufo-sm-jit-o2.pyamplicol-model \
+  --backend jit --jit-optimization-level 2
+```
+
+Enumerate a broad request without writing a process artifact:
+
+```console
+pyamplicol model processes "p p > all all" \
+  --model built-in-sm --flavor-scheme 1 --max-quark-lines 0
+```
+
+The distinction between portable model IR and prepared kernel bundles is
+explained in [Models and Processes](models-and-processes.md).
+
+## Examples and installed workspaces
+
+List the available names before running one:
+
+```console
+pyamplicol examples list
+pyamplicol examples run generate_pp_zjj_from_ufo_sm
+```
+
+The list uses a colored table on a terminal. Add `--json` for stable,
+uncolored machine-readable output.
+
+`examples run` accepts the stem of a shipped `.toml` card. `all_options` is a
+reference template, not a runnable example. Unknown names fail with the full
+available-name list.
+
+For an editable and inspectable workspace, copying is usually clearer:
+
+```console
+pyamplicol examples copy ./pyamplicol-examples --force
+cd pyamplicol-examples
+pyamplicol generate_pp_zjj_from_ufo_sm.toml
+```
+
+See [Examples Gallery](examples-gallery.md) for the complete card inventory and
+recommended sequences.
+
+## Output, color, progress, and logging
+
+The common presentation options are:
+
+| Option | Values | Meaning |
+| --- | --- | --- |
+| `--json` | flag | Emit stable machine-readable stdout instead of the human-facing table |
+| `--color` | `auto`, `always`, `never` | Detect a terminal, force ANSI color, or disable it |
+| `--progress` | `auto`, `tty`, `log`, `off` | Select live bars, rate-limited log progress, or silence |
+| `--log-level` | `debug`, `info`, `warning`, `error` | Control diagnostic verbosity |
+
+JSON mode keeps stdout machine-readable; progress and diagnostics use stderr.
+This makes pipelines predictable:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --json > artifact.json
+```
+
+Use `--color always` only when the consumer understands ANSI escapes. The
+default `auto` mode produces colored terminal tables and plain redirected
+output.
+
+## Diagnostics
+
+Start with the two installed-package checks:
+
+```console
+pyamplicol doctor
+pyamplicol self-test
+```
+
+Then inspect the relevant artifact and effective configuration:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --json > inspect.json
+pyamplicol config resolve run.toml --json > config.json
+```
+
+For common failures and the information to include in a bug report, see
+[Troubleshooting](troubleshooting.md) and [Release and Support](release-and-support.md).
+
+## Next steps
+
+- [Configuration](configuration.md)
+- [Models and Processes](models-and-processes.md)
+- [Generation Modes and Evaluators](generation-modes-and-evaluators.md)
+- [Runtime and Selectors](runtime-and-selectors.md)
+- [Native APIs](native-apis.md)
diff --git a/pyamplicol/docs/user/configuration.md b/pyamplicol/docs/user/configuration.md
new file mode 100644
index 0000000000..786c117eef
--- /dev/null
+++ b/pyamplicol/docs/user/configuration.md
@@ -0,0 +1,568 @@
+---
+title: "Configuration"
+nav_order: 3
+has_children: true
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Configuration
+
+pyAmpliCol uses one typed configuration schema for TOML run cards, direct CLI
+options, and Python configuration classes. Unknown fields are rejected rather
+than ignored, with a nearest-field suggestion when a likely spelling exists.
+
+The complete field-by-field reference is the shipped
+[`examples/all_options.toml`](https://github.com/MadGraphTeam/pyamplicol/blob/main/examples/all_options.toml).
+This page focuses on practical configurations.
+
+## Minimal generation card
+
+```toml
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "d d~ > Z g", name = "ddbar_Zg" }]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/ddbar_Zg"
+```
+
+Run it with:
+
+```console
+pyamplicol run.toml
+```
+
+Equivalent direct command:
+
+```console
+pyamplicol generate 'd d~ > Z g' artifacts/ddbar_Zg \
+  --model built-in-sm --color-accuracy lc
+```
+
+## Configuration precedence
+
+Values are resolved in this order:
+
+1. schema defaults;
+2. TOML card values;
+3. dedicated command-line flags;
+4. repeated `--set section.field=value` overrides, from left to right;
+5. effective generation requirements and license/resource adjustments.
+
+For example:
+
+```console
+pyamplicol generate_pp_zjj_from_ufo_sm.toml \
+  --set generation.workers=2 \
+  --set generation.mode=replace
+```
+
+Requested and effective configurations are retained separately in generated
+artifact provenance. A restricted Symbolica environment may reduce effective
+generation resources without rewriting the requested card.
+
+Inspect resolution without running the action:
+
+```console
+pyamplicol config resolve generate_pp_zjj_from_ufo_sm.toml
+pyamplicol config resolve generate_pp_zjj_from_ufo_sm.toml --json
+```
+
+Create a commented template:
+
+```console
+pyamplicol config template run.toml
+```
+
+## Paths
+
+Paths in a TOML card are resolved relative to that card, including:
+
+- model sources;
+- artifact outputs and inputs;
+- model-parameter cards;
+- momenta files;
+- cache paths.
+
+This makes copied example workspaces movable. Direct CLI paths are resolved
+from the current working directory.
+
+Generation output policy is explicit:
+
+| `generation.mode` | Behavior |
+| --- | --- |
+| `error` | Default; refuse an existing destination. |
+| `replace` | Atomically replace the generated artifact. |
+| `append` | Add to an existing compatible artifact. |
+
+Use `replace` deliberately while iterating:
+
+```console
+pyamplicol generate --card run.toml --set generation.mode=replace
+```
+
+## External JSON or UFO model
+
+The primary example uses serialized JSON, which does not execute Python while
+loading:
+
+```toml
+[model]
+source = "models/json/sm/sm.json"
+restriction = "default"
+simplify = true
+cache = true
+```
+
+A trusted UFO directory uses the same field:
+
+```toml
+[model]
+source = "/absolute/path/to/MyUFO"
+restriction = "default"
+```
+
+UFO modules are Python code and execute during loading. See
+[Models and Processes](models-and-processes.md) before using an external model.
+
+## Processes and multiparticles
+
+One card may contain one inclusive multiparticle request or multiple named
+requests:
+
+```toml
+[process]
+entries = [
+  { expression = "p p > Z j j" },
+  { expression = "u u~ > Z g", name = "uubar_Zg" },
+]
+flavor_scheme = 2
+max_quark_lines = 2
+
+[process.multiparticles]
+p = ["d", "d~", "g"]
+j = ["d", "d~", "g"]
+```
+
+Every model provides the generic `all` multiparticle for valid propagating
+physical external particles. It excludes ghosts, Goldstones,
+non-propagating records, and auxiliary states. An explicit `all` entry replaces
+the default; other user labels are merged over model defaults.
+
+Broad products such as `p p > all all` can expand combinatorially. Prefer a
+narrow user-defined label for production scans.
+
+`flavor_scheme`, `max_quark_lines`, and coupling-order settings constrain that
+expansion. Coupling-order names come from the selected model: the generic
+engine treats them as model-defined filtering and scheduling data and does not
+assign arbitrary names fixed QCD or electroweak meanings.
+
+### Process groups
+
+Four `process` fields control which subprocesses are recorded as sharing one
+matrix element in the artifact's `process-groups.json`:
+
+```toml
+[process]
+flavor_blind = false                 # generate one subprocess per flavour class
+consider_charge_conjugation = true   # also relate charge-conjugate subprocesses
+only_unit_multiplier = false         # accept numerical relations only with factor 1
+analyze_process_groups = "none"      # or "numerical", run after generation
+```
+
+`flavor_blind` is an assumption, not a check: members whose flavour relabelling
+is not a symmetry of the model couplings are reported with a warning.
+`consider_charge_conjugation` matters only with `flavor_blind` or numerical
+analysis. See
+[Group equivalent subprocesses](command-line-interface.md#group-equivalent-subprocesses)
+for the CLI flags and the `group-processes` command, and
+[Process Grouping](process-grouping.md) for the full description.
+
+## Color accuracy and LC layout
+
+```toml
+[color]
+accuracy = "lc"                 # lc, nlc, or full
+contraction = "auto"            # auto, direct, or symmetric-group-fft
+fft_basis = "adjoint"           # trace or adjoint; used by FFT contraction
+lc_flow_layout = "topology-replay"
+```
+
+| Accuracy | Resolved color output |
+| --- | --- |
+| `lc` | One entry per physical leading-color flow. |
+| `nlc` | One contracted color entry per helicity. |
+| `full` | One contracted color entry per helicity. |
+
+LC offers two complete-coverage layouts:
+
+| Layout | Best suited to |
+| --- | --- |
+| `topology-replay` | Default: one selected flow with a helicity sum. |
+| `all-flow-union` | All flows with one selected helicity. |
+
+Both preserve all physical flows and helicities for runtime selection.
+`all-flow-union` is LC-only and is incompatible with generation-fixed or
+truncated color/helicity coverage.
+
+For contracted NLC/full output, `symmetric-group-fft` evaluates the same exact
+colour interference as `direct` while Fourier-transforming certified
+permutation orbits and retaining all other terms as direct residuals. It is
+available for `recurrence` and `on-the-fly`; compiled/eager execution and LC
+flows deliberately reject explicitly forced FFT.
+
+The default `contraction = "auto"` tries FFT for NLC/full recurrence and
+on-the-fly execution, falling back to direct contraction when an FFT plan is
+unsupported. LC, compiled/eager execution, and correlated generation use
+direct contraction and the trace basis. The effective configuration can retain
+`"auto"` until per-process selection.
+
+The default `fft_basis = "adjoint"` enables adaptive exact-basis selection.
+The requested option and the mathematical representation are
+distinct: generation chooses a certified Del Duca–Dixon–Maltoni (DDM) reduction
+where available, and otherwise keeps the exact representation appropriate to
+the process.
+
+| Process domain | Actual representation |
+| --- | --- |
+| Certified Yang–Mills trees | Two-anchor DDM half-ladders. |
+| Certified single-insertion scalar HEFT, with gluons and one Higgs | DDM half-ladders; the two-gluon case is the single delta tensor. Use explicit `HIG = 1`. |
+| One quark–antiquark line, with optional colour singlets | Fundamental chain, already fixing both quark endpoints. |
+| Multiple quark lines | Exact products of fundamental chains and all endpoint routings; not a Melia/Johansson–Ochirov primitive decomposition. |
+| Colour singlets only | The trivial singlet tensor. |
+| Adjoint interactions without a DDM certificate | Original trace tensors, without assuming amplitude identities. |
+
+For `n` external gluons, a certified DDM reduction retains `(n-2)!` ordered
+amplitudes instead of `(n-1)!`. Count only the gluons, not a colourless Higgs.
+This removes redundant orderings without changing colour accuracy. A quark
+process need not become smaller or faster: retaining its existing fundamental
+chains is a deliberate exact choice, not an adjoint reduction.
+
+Generation records `fft_basis_selection`, with `requested`, `actual_basis`,
+`name`, `reason`, `permutation_degree`, and `tensor_count`. For fundamental
+chains, `actual_basis = "trace"` identifies the existing metric implementation,
+while `name = "fundamental-chain"` or `"fundamental-chain-products"` identifies
+the tensors. The tensor count excludes traversal aliases and is not a rank
+claim at fixed `Nc`. Use these recorded fields when comparing artifacts.
+
+Explicit `fft_basis = "trace"` keeps the original FFT representation.
+`contraction = "direct"` opts out of FFT and ignores `fft_basis`. Explicit
+`contraction = "symmetric-group-fft"` forces FFT and retains errors for
+unsupported plans, LC, and compiled/eager execution. Forced adjoint FFT cannot
+be combined with correlated generation; correlations retain their separate
+direct contraction path.
+
+This is an exact contraction algorithm, not an approximation. Its speedup is
+process-dependent: a small certified symmetry subgroup or a residual-dominated
+contraction can make the FFT and direct curves scale similarly. Keep the
+direct result as the baseline when characterizing a new process family.
+For the adjoint basis, single-helicity full-colour recurrence benchmarks of
+`g g > (n-2) g` on one core showed it faster than trace for `n >= 6`: at
+`n = 10` it evaluated 3.9x faster per sample (57.8 versus 227 ms), generated
+4.2x faster and used 2.4x less memory during generation. Below `n = 6` the two
+bases are comparable, so compare setup and warmed runtime for other workloads. See
+[FullColor FFT Profiling](fullcolor-fft-profiling.md) for the resumable
+comparison driver and published snapshots.
+
+```toml
+[color]
+accuracy = "full"
+contraction = "symmetric-group-fft"
+fft_basis = "adjoint"  # for example, built-in-sm with g g > g g g
+
+[evaluator]
+execution_mode = "recurrence"
+```
+
+This example forces FFT. Omit `contraction` and `fft_basis` to use automatic
+adjoint selection with direct fallback. Use `execution_mode = "on-the-fly"`
+for the compact OTF lane. The matching forced-FFT CLI shorthand is
+`--fft adjoint --color-accuracy full`; `--fft trace` forces the original trace
+path. Both require an explicit NLC/full accuracy setting (on the command line
+or in the card). Use `--color-contraction direct` to opt out.
+
+## Execution mode and evaluator backend
+
+The accuracy, contraction, and execution choices on this page describe
+ordinary Born evaluation. [Born Correlations](../correlators.md) are a separate
+opt-in declaration: pass `CorrelatorConfig` as `correlators=` in Python or use
+`generate --correlators declaration.json`. There is no `[correlators]` TOML
+section. `color.accuracy` selects LC, NLC or full colour for the correlated
+matrix contraction; all three retain complete underlying amplitudes. The
+path records direct contraction, compiled execution, and numerical current
+reuse off. Conflicting requested settings
+are retained in provenance with those explicit adjustments.
+
+Correlated generation rejects partial colour/helicity coverage and append
+mode. Numerical spin vectors are supplied later through the Python runtime,
+not through the generation card or declaration file.
+
+```toml
+[evaluator]
+execution_mode = "compiled"     # recurrence, compiled, eager, on-the-fly
+backend = "jit"                 # jit, asm, cpp
+batch_size = 128
+
+[evaluator.jit]
+optimization_level = 2
+compress = "auto"               # true for compiled JIT O2; false for other modes/levels
+```
+
+### Execution modes
+
+| Mode | What is stored in the process artifact |
+| --- | --- |
+| `recurrence` | Compact current-recursion schedules over prepared local kernels. |
+| `compiled` | Process-wide stage evaluators compiled during generation. |
+| `eager` | Compact DAG invocation tables over prepared local kernels. |
+| `on-the-fly` | A compact process seed; the selected LC query family, or contracted NLC/full family, is constructed on first use. |
+
+`recurrence` is the default. Eager, recurrence, and on-the-fly require a
+compatible prepared `.pyamplicol-model` kernel pack; `built-in-sm` selects the
+packaged JIT O2 pack automatically. Raw JSON/UFO model IR normally uses
+`compiled` unless you first create a prepared bundle.
+
+Ordinary recurrence, compiled, and eager generation may fix
+`process.selected_color_sector_ids`, `process.selected_source_helicities`, or
+both at generation time when a deliberately specialized artifact is useful.
+Omit them to retain reusable runtime selectors. On-the-fly keeps selection at
+runtime instead: its last warmed family is retained until another selector is
+requested.
+
+For reusable contracted recurrence artifacts, generation persists one shared
+all-helicity physical-colour plan plus an exact per-helicity dispatch sidecar.
+Cold selector binding copies only the dependency-closed active row groups;
+warmed evaluation does not scan helicity-support masks. This companion belongs
+to recurrence execution. On-the-fly instead constructs the requested family
+from its compact process seed on first use and caches that family; compiled and
+eager artifacts retain their own execution layouts.
+
+On-the-fly is native binary64 only. LC retains physical flow and helicity
+selection without materializing either LC layout. NLC and full colour expose
+one contracted color component, accept helicity selection, and reject LC-flow
+selectors. Their cold family is correctness-oriented and may become
+impractical at high multiplicity. For on-the-fly generation,
+`evaluator.optimization.cores` requests query-construction workers for the cold
+warm-up; it does not make steady-state numerical evaluation use that many
+threads. See [Generation Modes and Evaluators](generation-modes-and-evaluators.md)
+for the distinct lifecycle of each mode.
+
+### Backends
+
+| Backend | Notes |
+| --- | --- |
+| `jit` | Default direct SymJIT application. Compiled O1/O2 artifacts are portable on supported 64-bit little-endian hosts; prepared packs use exact O2. |
+| `asm` | Target-native Symbolica assembly evaluator. |
+| `cpp` | Target-native generated C++ evaluator. |
+
+Explicit JIT O0/O3 and ASM/C++ artifacts remain target-native. See
+[Artifacts and Portability](artifacts-and-portability.md).
+
+## Generation validation
+
+```toml
+[generation.validation]
+enabled = true
+samples = 2
+seed = 12345
+relative_tolerance = 1e-12
+absolute_tolerance = 1e-300
+post_build_validation = false
+```
+
+Generation validation checks symbolic/numerical construction before
+publication. Structural artifact checks always run. The optional
+`post_build_validation` reopens the finished artifact and evaluates it again;
+it is disabled by default because its cost can dominate large process builds.
+Enable it when you explicitly want that additional runtime smoke:
+
+```console
+pyamplicol generate --card run.toml \
+  --set generation.validation.post_build_validation=true
+```
+
+## Numerical current reuse
+
+Certified current-relation reuse is an opt-in optimization. It is off by
+default because its high-precision probes are costly at generation time;
+enable it to search for additional reuse. It prefers exact
+structural proofs and may apply independently verified high-precision equal,
+opposite, or zero relations. The artifact records the evidence, tolerances,
+probe derivation, replay identity, and whether a structural proof was present.
+
+This configurable discovery pass applies to ordinary recurrence, compiled,
+and eager generation. On-the-fly uses its compact source projection instead
+and does not run relation discovery. Correlated generation always disables
+this pass to preserve arbitrary external vector-source dependence.
+
+`diagnostic` records deterministic candidates and their exact replay without
+changing the generated evaluator. `certified-reuse` may apply a relation only
+after its independent verification pass succeeds; it emits one warning when
+an applied relation has numerical evidence but no structural proof. Malformed,
+non-finite, unstable, or stale evidence fails closed and is never reused.
+
+Discovery and application are reported separately. For contracted NLC/full-colour
+recurrence, independently verified equal and zero-current relations can be
+applied even when the same pass also finds opposite-current relations. The
+opposite relations remain recorded but are not applied in that layout; their
+currents retain their original computation. Existing helicity/flow-selector
+restrictions still apply. No relation search is deferred to the first evaluation.
+
+Enable the search with:
+
+```console
+pyamplicol generate --card run.toml --numerical-current-reuse
+```
+
+Or in TOML:
+
+```toml
+[generation.relation_discovery]
+mode = "certified-reuse"        # off (default), diagnostic, certified-reuse
+```
+
+`--no-numerical-current-reuse` restates the default and overrides a card that
+enables the search.
+
+The exhaustive probe, precision, seed, and tolerance fields are documented in
+`all_options.toml`.
+
+## Evaluation card
+
+```toml
+schema_version = 1
+action = "evaluate"
+
+[evaluation]
+artifact = "artifacts/pp_zjj"
+process = "d d~ > g z g"
+precision = 16
+resolved = true
+model_parameters = "data/model_parameters.json"
+momenta = "data/pp_zjj_momenta.json"
+
+[output]
+format = "human"                # programmatic/config provenance default
+color = "auto"                  # auto, always, never
+progress = "off"                # auto, tty, log, off
+```
+
+`helicity_ids` and `color_flow_ids` may be added under `[evaluation]`. Empty
+lists mean complete retained coverage.
+
+The model-parameter card is a flat JSON object:
+
+```json
+{
+  "aS": 0.117,
+  "MZ": 91.1876,
+  "complex_parameter": [1.0, -0.25]
+}
+```
+
+Values must be finite real numbers or `[real, imaginary]` pairs. Direct
+parameter overrides are applied after the card and win atomically.
+
+## Profiling card
+
+Run cards retain `action = "benchmark"`; the preferred direct CLI spelling is
+`pyamplicol profile`:
+
+```toml
+action = "benchmark"
+
+[evaluation]
+artifact = "artifacts/pp_zjj"
+process = "d d~ > g z g"
+momenta = "data/pp_zjj_momenta.json"
+
+[benchmark]
+target_runtime = 1.0
+batch_size = 128
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+color_flow_ids = ["1"]
+```
+
+With both benchmark selector lists empty, LC profiling infers the stored
+layout's deterministic hot workload. Explicit subsets and selected-axis lists
+override that default; a complete summed-axis list is normalized to equivalent
+omission. A valid shape outside the optimized layout emits at most one pre-loop
+warning per loaded process.
+
+See [Runtime and Selectors](runtime-and-selectors.md) for evaluation and profiling
+semantics.
+
+## Output and progress
+
+```toml
+[output]
+format = "human"
+color = "auto"
+progress = "auto"
+log_level = "info"
+```
+
+- The `pyamplicol` CLI always produces aligned colored terminal tables unless
+  the invocation includes `--json`. The run-card `format` field remains part
+  of the typed configuration used by the Python API and recorded provenance;
+  it does not silently switch CLI stdout to JSON.
+- `pyamplicol ... --json` reserves standard output for stable, uncolored,
+  machine-readable data.
+- `auto` progress uses a TTY progress bar interactively and rate-limited log
+  messages otherwise.
+- `Ctrl-C` during profiling retains completed timing blocks and marks the result
+  partial.
+
+## Resolve configuration from Python
+
+```python
+from pathlib import Path
+
+from pyamplicol.config import resolve_config
+
+resolution = resolve_config(
+    {
+        "schema_version": 1,
+        "action": "generate",
+        "model": {"source": "models/json/sm/sm.json"},
+        "process": {"entries": [{"expression": "d d~ > z g"}]},
+        "generation": {"output": "artifacts/builtin_ddbar_to_zg"},
+    },
+    base_dir=Path("pyamplicol-examples"),
+    overrides=("generation.workers=2",),
+)
+print(resolution.effective.generation.output)
+```
+
+For a mapping, relative paths use `base_dir`; without it they use the current
+working directory. Values supplied through `--set` or `overrides=` use TOML
+syntax, so quote strings containing spaces.
+
+## Further reading
+
+- [Generation Modes and Evaluators](generation-modes-and-evaluators.md)
+- [LC workloads and execution modes](lc-workloads-and-execution-modes.md)
+- [Models and Processes](models-and-processes.md)
+- [Runtime and Selectors](runtime-and-selectors.md)
+- [Exhaustive current schema](https://github.com/MadGraphTeam/pyamplicol/blob/main/examples/all_options.toml)
+
+<!-- Page hierarchy for the MadGraph7 (Sphinx) documentation. -->
+```{toctree}
+:hidden:
+
+models-and-processes
+ufo-model-coverage
+process-selection-and-permutations
+process-grouping
+generation-modes-and-evaluators
+command-line-interface
+```
diff --git a/pyamplicol/docs/user/examples-gallery.md b/pyamplicol/docs/user/examples-gallery.md
new file mode 100644
index 0000000000..13b299f630
--- /dev/null
+++ b/pyamplicol/docs/user/examples-gallery.md
@@ -0,0 +1,340 @@
+---
+title: "Examples Gallery"
+nav_order: 2
+parent: "Installation"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Examples Gallery
+
+The wheel ships runnable TOML cards, Python programs, model/data resources, and
+native consumers. Copy them into an ordinary directory before experimenting:
+
+```console
+pyamplicol examples copy ./pyamplicol-examples --force
+cd pyamplicol-examples
+```
+
+Paths inside a card are resolved relative to that card, so the copied workspace
+can be moved without referring back to the installation.
+
+> [!IMPORTANT]
+> Keep the environment containing pyAmpliCol activated, or invoke its
+> executables by explicit path. Generated native drivers discover the SDK
+> through `rusticol-config` from that same environment.
+
+## See what is available
+
+```console
+pyamplicol examples list
+```
+
+The command prints a colored table with each card stem, action, and one-line
+description. Use `--json` when a script needs the same inventory as stable,
+uncolored machine-readable output:
+
+```console
+pyamplicol examples list --json
+```
+
+A card can also run in a versioned private cache workspace:
+
+```console
+pyamplicol examples run evaluate_total
+```
+
+`examples run` accepts the stem shown by `examples list`; it is not an
+arbitrary TOML path. Use the copied workspace when you want to edit cards,
+inspect artifacts, or run several related steps.
+
+## The four-command tour
+
+The primary sequence generates a portable multiprocess `p p > Z j j` artifact
+from the serialized UFO Standard Model, then evaluates and profiles one
+subprocess:
+
+```console
+pyamplicol generate_pp_zjj_from_ufo_sm.toml
+pyamplicol evaluate_total.toml
+pyamplicol evaluate_resolved.toml
+pyamplicol benchmark.toml
+```
+
+What each card demonstrates:
+
+| Card | Demonstration |
+| --- | --- |
+| `generate_pp_zjj_from_ufo_sm.toml` | JSON model input, multiparticle expansion, compiled JIT O2, API bundle |
+| `evaluate_total.toml` | Optimized total, model-parameter card, reordered process expression |
+| `evaluate_resolved.toml` | Physical helicity/LC-flow components and explicit sum |
+| `benchmark.toml` | One-second calibrated profile of the optimized total |
+
+The generation request finds eight candidates, one per side-permutation class,
+stores seven tree-level representatives, and reports the loop-induced
+`g g > Z g g` class as omitted. Evaluation selects the public
+ordering `d d~ > g z g`; the stored representative is reused automatically.
+
+The three result cards use colored human tables by default. Add `--json` for
+machine-readable stdout.
+
+## Run cards by topic
+
+| File | Purpose | Expected cost |
+| --- | --- | --- |
+| `generate_pp_zjj_from_ufo_sm.toml` | Primary portable multiprocess artifact | Short functional example |
+| `evaluate_total.toml` | Fully summed primary subprocess | Fast after generation |
+| `evaluate_resolved.toml` | Resolved helicity/color tensor | Fast after generation |
+| `benchmark.toml` | Short primary runtime profile | About the configured one-second target plus setup |
+| `builtin_sm_lc.toml` | Built-in SM recurrence JIT O2, LC | Small generation example |
+| `builtin_sm_nlc.toml` | Built-in SM recurrence JIT O2, contracted NLC | Small generation example |
+| `builtin_sm_full.toml` | Built-in SM compiled C++, contracted full color | Requires a C++ toolchain during generation |
+| `builtin_sm_adjoint_fft.toml` | Pure-gluon full color in the adjoint DDM FFT basis | Recurrence; also supports an on-the-fly override |
+| `builtin_sm_heft.toml` | Packaged scalar HEFT `g g > H g g`, one insertion, recurrence JIT O2 with adjoint DDM FFT | Small HEFT workflow; no external UFO required |
+| `builtin_sm_eager.toml` | Built-in SM eager execution with wheel-owned prepared kernels | Small eager example |
+| `builtin_sm_on_the_fly.toml` | Built-in SM compact OTF LC artifact | Small generation example; first selected family is built at runtime |
+| `otf_pp_zjj.toml` | `p p > Z j j` OTF generation, one-point warm-up, and profiling | Short guided OTF workflow |
+| `generate_pp_4j_flavor_blind.toml` | Flavour-blind `p p > j j j j` at `QED = 0`: 23 representatives for 486 subprocesses | About 30 seconds |
+| `inspect_pp_4j.toml` | Artifact summary and process-group map | Fast after generation |
+| `evaluate_pp_4j_member.toml` | Non-generated member `u~ g > u~ g g g` routed through its representative | Fast after generation |
+| `group_pp_4j.toml` | Numerical `group-processes` analysis of the representatives | About a second after generation |
+| `process_set_mixed_multiplicity.toml` | Named 2-to-2 and 2-to-3 processes in one artifact | Small multiprocess example |
+| `external_ufo_sm.toml` | Trusted UFO-directory loading | Imports trusted model Python |
+| `external_json_scalars.toml` | Repeated scalar particles and a contact model | Small external-JSON example |
+| `external_json_scalar_gravity.toml` | Proven massless spin-2 path | Small external-JSON example |
+| `qq_z6g_recurrence_jit_o2.toml` | `q q~ > Z + 6g`, recurrence prepared JIT O2 | Substantial |
+| `qq_z6g_compiled_jit_o3.toml` | Same process, compiled process-local JIT O3 | Substantial and host-specific |
+| `qq_z6g_eager_jit_o2.toml` | Same process, eager prepared JIT O2 | Substantial |
+| `benchmark_z6g_single_flow_helicity_sum.toml` | Reusable topology-replay selector workload | Substantial |
+| `benchmark_z6g_all_flows_single_helicity.toml` | Reusable all-flow-union selector workload | Substantial |
+| `benchmark_z6g_generation_specialized_flow_helicity_sum.toml` | Generation-selected flow baseline | Substantial |
+| `benchmark_z6g_generation_specialized_all_flows_single_helicity.toml` | Generation-selected helicity baseline | Substantial |
+| `all_options.toml` | Exhaustive commented schema reference | Reference only; not runnable via `examples run` |
+
+Use the primary Z+jet sequence, not a six-gluon card, as an installation smoke.
+
+## Packaged scalar HEFT
+
+Generate a full-colour Higgs-plus-two-gluon artifact without an external UFO:
+
+```console
+pyamplicol generate --card builtin_sm_heft.toml
+pyamplicol inspect artifacts/builtin_sm_heft
+```
+
+The card selects the packaged `built-in-sm-heft` model and explicitly limits
+the effective coupling order to `HIG = 1`. Recurrence uses the wheel-owned JIT
+O2 prepared kernels. See
+[Models and Processes](models-and-processes.md#built-in-scalar-heft-model) for
+the compiled, eager, on-the-fly, Python API, and trusted-UFO variants.
+
+## Process grouping with `p p > j j j j`
+
+Four cards show [process grouping](process-grouping.md) on the 486
+five-flavour subprocesses of pure-QCD `p p > j j j j` in the built-in SM:
+
+```console
+pyamplicol generate_pp_4j_flavor_blind.toml
+pyamplicol inspect_pp_4j.toml
+pyamplicol evaluate_pp_4j_member.toml
+pyamplicol group_pp_4j.toml
+```
+
+| Step | Equivalent command | Result |
+| --- | --- | --- |
+| Generate | `pyamplicol generate "p p > j j j j" artifacts/pp_4j_flavor_blind --model built-in-sm --flavor-blind --max-coupling-order QED=0` | 23 representatives at LC; 463 members, 140 of them conjugated, in `process-groups.json`; about 30 seconds |
+| Inspect | `pyamplicol inspect artifacts/pp_4j_flavor_blind` | Generated processes and the process-group map |
+| Evaluate a member | `pyamplicol evaluate artifacts/pp_4j_flavor_blind --process "u~ g > u~ g g g" --momenta data/pp_4j_momenta.json` | Routed through `d g > d g g g` with relabelling and charge conjugation |
+| Group numerically | `pyamplicol group-processes artifacts/pp_4j_flavor_blind` | No new relation: the 23 classes are distinct |
+
+`u~ g > u~ g g g` was never generated, yet its value agrees with a separately
+generated copy to about `1e-14`. Any of the 486 subprocesses, in any leg order
+within each side, can be selected in the same way, from the CLI, Python, or
+the generated API drivers. Flavour-blind generation assumes equal matrix
+elements within a class; see
+[When to use it](process-grouping.md#when-to-use-it) before using it with
+electroweak couplings.
+
+## Three materialized execution modes on one process
+
+The matched `Z + 6g` cards keep model, process, color accuracy, and LC layout
+fixed while changing the execution mode:
+
+```console
+pyamplicol generate --card qq_z6g_recurrence_jit_o2.toml
+pyamplicol profile  --card qq_z6g_recurrence_jit_o2.toml
+
+pyamplicol generate --card qq_z6g_compiled_jit_o3.toml
+pyamplicol profile  --card qq_z6g_compiled_jit_o3.toml
+
+pyamplicol generate --card qq_z6g_eager_jit_o2.toml
+pyamplicol profile  --card qq_z6g_eager_jit_o2.toml
+```
+
+Each writes a separate artifact. These are performance/acceptance workloads,
+not quick examples; generation can take significant time and memory.
+
+See [Generation Modes and Evaluators](generation-modes-and-evaluators.md) before
+interpreting their differences.
+
+## On-the-fly warm-up and profile
+
+The OTF `p p > Z j j` example keeps generation compact, explicitly warms one
+LC flow summed over helicities, and then profiles the retained workload:
+
+```console
+pyamplicol generate --card otf_pp_zjj.toml
+python python/otf_pp_zjj_warm_up.py
+pyamplicol profile --card otf_pp_zjj.toml
+```
+
+The Python warm-up takes exactly one double-precision phase-space point and
+draws live progress while the selected family is constructed. Its colored
+summary reports warm-up time, query counts, resident memory, and the matrix
+element. The independent profiler then measures the configured 128-point
+steady-state batch. See
+[LC workloads and execution modes](lc-workloads-and-execution-modes.md#the-otf-warm-state-lifecycle)
+for the cache lifecycle and native-language equivalents.
+
+Completed OTF preparation can also be retained between programs with
+`runtime.save(path)` and `runtime.load_cache(path)`. The
+[four-gluon save/restore example](runtime-and-selectors.md#saving-an-otf-warm-cache)
+shows generation, a complete input point, and a cache-reuse check; the
+[native examples](native-apis.md#saving-and-restoring-an-otf-cache) cover every SDK.
+
+## LC selector-layout examples
+
+The two reusable-selector cards retain complete helicity and physical-flow
+coverage:
+
+```console
+pyamplicol generate --card benchmark_z6g_single_flow_helicity_sum.toml
+pyamplicol profile  --card benchmark_z6g_single_flow_helicity_sum.toml
+
+pyamplicol generate --card benchmark_z6g_all_flows_single_helicity.toml
+pyamplicol profile  --card benchmark_z6g_all_flows_single_helicity.toml
+```
+
+The first uses default `topology-replay`, optimized for one selected flow and a
+helicity sum. The second uses `all-flow-union`, optimized for all flows at one
+selected helicity. Change selectors without regenerating:
+
+```console
+pyamplicol profile \
+  --card benchmark_z6g_single_flow_helicity_sum.toml \
+  --color-flow 2
+
+pyamplicol profile \
+  --card benchmark_z6g_all_flows_single_helicity.toml \
+  --helicity h:-1,+1,-1,+1,+1,-1,+1,-1,+1
+```
+
+## Typed Python generation
+
+Plan first, then generate:
+
+```console
+python python/typed_generation.py artifacts/pp_zjj_typed --plan-only
+python python/typed_generation.py artifacts/pp_zjj_typed
+```
+
+The script compiles the copied serialized model, constructs explicit `p` and
+`j` multiparticle definitions, and calls `Generator.plan()` or
+`Generator.generate()`. The generated artifact includes the same standalone API
+bundle as a CLI build.
+
+Evaluate through the typed runtime:
+
+```console
+python python/runtime_evaluation.py \
+  artifacts/pp_zjj data/pp_zjj_momenta.json \
+  --process 'd d~ > g z g' \
+  --parameters data/model_parameters.json \
+  --set-parameter aS=0.1165
+```
+
+The JSON result reports the resolved shape and flattened values, explicit
+resolved sum, optimized total, and selected physics-axis IDs.
+
+Profile the same process:
+
+```console
+python python/benchmark.py artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json
+```
+
+`python/external_models.py` demonstrates typed JSON and trusted-UFO
+`ModelSource` construction:
+
+```console
+python python/external_models.py models/json/sm/sm.json models/ufo/sm
+```
+
+## Generated five-language API bundle
+
+After the primary generation, run the same public process ordering in every
+generated driver:
+
+```console
+python artifacts/pp_zjj/API/python/check_standalone.py \
+  --process 'd d~ > g z g' --set-parameter aS 0.117 0 --json
+
+make -C artifacts/pp_zjj/API/c run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --json'
+
+make -C artifacts/pp_zjj/API/rust run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --precision 16 --json'
+
+make -C artifacts/pp_zjj/API/cpp run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --json'
+
+make -C artifacts/pp_zjj/API/fortran run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --json'
+```
+
+All drivers load one bundled point, evaluate every resolved component, sum
+those components, and compare the sum to the optimized total. They use the
+wheel-owned static Rusticol SDK discovered through `rusticol-config`.
+
+Every driver also accepts `--kinematics PATH` and `--model-parameters PATH`.
+The full shape, precision, ordering, and precedence rules are documented in
+[Native APIs](native-apis.md) and
+[Process Selection and Permutations](process-selection-and-permutations.md).
+
+## Hand-written C++ and Fortran consumers
+
+The `native/` directory shows SDK use independent of generated driver sources:
+
+```console
+make -C native
+native/runtime_cpp artifacts/pp_zjj p_p_to_z_j_j_3 \
+  data/model_parameters.json
+native/runtime_fortran artifacts/pp_zjj p_p_to_z_j_j_3 \
+  data/model_parameters.json
+```
+
+Both programs apply an `aS` override, evaluate one five-particle point, and
+verify that resolved components reproduce the total.
+
+## Modify an example safely
+
+Prefer a new output directory when changing execution mode, backend, color
+accuracy, or flow layout:
+
+```console
+pyamplicol generate \
+  --card benchmark_z6g_single_flow_helicity_sum.toml \
+  --execution-mode eager \
+  --set generation.output=artifacts/uubar_z6g_eager_experiment
+```
+
+Use `--set generation.mode=replace` only when you explicitly want to replace
+an existing artifact transactionally.
+
+## See also
+
+- [Quick Start](quick-start.md)
+- [Command-Line Interface](command-line-interface.md)
+- [Python API](python-api.md)
+- [Native APIs](native-apis.md)
+- [Profiling and Benchmarking](profiling-and-benchmarking.md)
diff --git a/pyamplicol/docs/user/fullcolor-fft-profiling.md b/pyamplicol/docs/user/fullcolor-fft-profiling.md
new file mode 100644
index 0000000000..f1ddc34aae
--- /dev/null
+++ b/pyamplicol/docs/user/fullcolor-fft-profiling.md
@@ -0,0 +1,277 @@
+---
+title: "FullColor FFT Profiling"
+nav_order: 3
+parent: "Profiling and Benchmarking"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# FullColor FFT Profiling
+
+The source checkout contains a thin, resumable orchestrator for comparing
+exact full-colour matrix-element implementations. It delegates physics
+generation, profiling, validation, plotting, and PDF assembly to the existing
+pyAmpliCol developer tools; the driver owns only selection, scheduling,
+per-child resource guards, and persistent progress.
+
+This workflow is distinct from selecting
+`color.contraction = "symmetric-group-fft"` in an ordinary generated artifact:
+
+- **symmetric-group FFT contraction** is a pyAmpliCol runtime algorithm for
+  exact NLC/full colour in recurrence and on-the-fly execution;
+- **Reference FFT** is the optional external `AllGluonsMultipletFFT` comparison
+  checkout;
+- **the profiling orchestrator** measures those implementations alongside
+  direct pyAmpliCol, original AmpliCol, and MadGraph where applicable.
+
+The orchestrator is source-checkout-only. It is intended for a workstation or
+cluster node with explicit CPU, memory, and wall-time budgets.
+
+For ordinary NLC/full recurrence or on-the-fly generation, the defaults
+`contraction="auto"` and `fft_basis="adjoint"` try exact FFT, with direct
+fallback for unsupported plans. Select `--color-accuracy full` to use this
+policy. This adaptively selects certified two-anchor DDM for pure Yang–Mills
+trees and single-insertion HEFT (`HIG = 1`), retains fundamental chains for
+quarks, and uses exact trace tensors where DDM is unproven. Compare the saved
+`fft_basis_selection` as well as the request: requesting adjoint does not imply
+that every process used DDM or gained a smaller basis. LC, compiled/eager
+execution, and correlators retain direct/trace. Use `--color-contraction direct`
+to opt out, or `--fft adjoint` / `--fft trace` to force FFT and retain errors
+for unsupported plans. Historical curves retain their saved basis settings
+and must not be relabelled. In the benchmarked pure-gluon family the
+adjoint basis was faster than trace for six or more external gluons; compare
+setup and warmed runtime separately for other workloads.
+
+## Prepare a profiling checkout
+
+Enter the repository's Nix environment when available, then request only the
+optional references needed by the scan:
+
+```console
+nix develop
+just dev-install --with-reference-fft --with-legacy-amplicol
+```
+
+`--with-reference-fft` clones the public
+`rikkert-frederix/AllGluonsMultipletFFT` revision pinned by pyAmpliCol.
+`--with-legacy-amplicol` clones the pinned original-AmpliCol comparison.
+Both are omitted by a default `just dev-install`; either opt-in also installs
+the PDF/plotting dependencies into `.venv`. If a managed Reference FFT checkout
+predates the public repository, add `--update` once so its `origin` is migrated.
+
+MadGraph is not installed by `dev-install`. Pass a complete installation root
+containing `bin/mg5_aMC` and `VERSION` with `--madgraph-root`.
+
+## Select process families and curves
+
+The scan has two independent process families:
+
+| Selector | Process family |
+| --- | --- |
+| `gg` | `g g > g g + gluons` |
+| `ddbar` | `d d~ > d d~ + gluons` |
+
+`--lines` accepts grouped comparison series:
+
+| Selector | Curves requested |
+| --- | --- |
+| `reference-fft` | External pure-gluon Reference FFT |
+| `amplicol` | Original AmpliCol |
+| `pyamplicol-recurrence` | pyAmpliCol recurrence direct and FFT |
+| `pyamplicol-otf` | pyAmpliCol on-the-fly direct and FFT |
+| `madgraph` | Same-host MadGraph standalone |
+
+For a targeted top-up, use a concrete pyAmpliCol line:
+`recurrence-direct`, `recurrence-fft`, `otf-direct`, or `otf-fft`.
+Required authority/baseline shards are added automatically. For example, a
+pyAmpliCol pure-gluon comparison may require Reference FFT, while a `ddbar`
+comparison may require original AmpliCol.
+
+## Small Reference FFT example
+
+This fills only Reference FFT for the pure-gluon family at final-state
+multiplicities 2, 3, and 4:
+
+```console
+.venv/bin/python tools/fft_profiling/fft_profiling.py \
+  --output /shared/path/fft-reference-gg \
+  --families gg --lines reference-fft \
+  --multiplicities 2 3 4 \
+  --cores 10 \
+  --memory-limit-gib 100 --time-limit-seconds 36000 \
+  --reference-fft-root "$PWD/dependencies/checkouts/reference-fft"
+```
+
+Use `--dry-run` first to print the deterministic plan without creating the
+output or starting workers.
+
+## Complete cluster scan
+
+The following command requests both process families, every grouped series,
+ten scheduler cores, a 100 GiB per-child memory guard, and a 10-hour per-cell
+time limit in one explicit output directory:
+
+```console
+.venv/bin/python tools/fft_profiling/fft_profiling.py \
+  --output /shared/path/pyamplicol-fft-profile \
+  --families gg ddbar \
+  --lines reference-fft amplicol pyamplicol-recurrence pyamplicol-otf madgraph \
+  --multiplicities 2 3 4 5 6 7 8 9 \
+  --cores 10 --candidate-cores 1 \
+  --memory-limit-gib 100 --time-limit-seconds 36000 \
+  --amplicol-root "$PWD/dependencies/checkouts/legacy-amplicol" \
+  --reference-fft-root "$PWD/dependencies/checkouts/reference-fft" \
+  --madgraph-root /shared/path/MG5_aMC \
+  --build-amplicol
+```
+
+`--build-amplicol` permits the first fixed-helicity AmpliCol shard to build its
+probe. It can remain on subsequent resumptions; an already valid probe is
+reused.
+
+Resource options have deliberately narrow meanings:
+
+- `--cores` is the total scheduler slot budget across active children;
+- `--candidate-cores` is one pyAmpliCol child's slot claim and exact
+  `evaluator.optimization.cores` setting;
+- `--memory-limit-gib` and `--time-limit-seconds` are strict per-child/per-cell
+  limits, not aggregate campaign limits;
+- the time limit covers generation/setup and runtime measurement;
+- `--target-seconds` controls calibrated runtime sampling after setup and is
+  not the cell cutoff.
+
+The progress headline reports the active cell, aggregate live RSS, and occupied
+core slots. A child crossing its own guard is terminated and retained as a
+cutoff result; other cells continue.
+
+## Fixed helicity and complete helicity sums
+
+The default workload evaluates one shared known-nonzero helicity from artifacts
+that retain general helicity coverage. Add `--compare-helicity-sums` for the
+independent complete physical-helicity sum:
+
+```console
+.venv/bin/python tools/fft_profiling/fft_profiling.py \
+  --output /shared/path/pyamplicol-fft-profile-helicity-sum \
+  --compare-helicity-sums \
+  --families gg ddbar \
+  --lines reference-fft amplicol pyamplicol-recurrence pyamplicol-otf madgraph \
+  --multiplicities 2 3 4 5 6 \
+  --cores 10 --candidate-cores 1 \
+  --memory-limit-gib 100 --time-limit-seconds 36000 \
+  --amplicol-root "$PWD/dependencies/checkouts/legacy-amplicol" \
+  --reference-fft-root "$PWD/dependencies/checkouts/reference-fft" \
+  --madgraph-root /shared/path/MG5_aMC
+```
+
+Fixed-helicity and helicity-sum measurements have different workload
+identities and must use separate output directories. MadGraph's summed lane
+uses its generated `SMATRIX(P,ANS)` entry point with `USERHEL=-1`; it does not
+reuse fixed-helicity measurements.
+
+## Resume, retry, overwrite, or refresh
+
+The default behavior is resumable and additive. Repeating a command with the
+same `--output`:
+
+- recovers unfinished prior requests;
+- skips completed cells;
+- adds newly selected families, lines, and multiplicities to the persistent
+  history;
+- refreshes plots as new completed evidence becomes available.
+
+`--resume` is an explicit alias for that default. More forceful choices are
+scoped to the current `--families`, `--lines`, and `--multiplicities`:
+
+| Option | Effect |
+| --- | --- |
+| `--retry` | Rerun selected failed or skipped cells. |
+| `--overwrite` | Rerun every selected cell; keep its old result until that worker actually starts. |
+| `--refresh` | Delete the exact recognized output workspace and restart it from scratch. |
+
+Use targeted overwrite to refine a measured subset without discarding the
+rest of the campaign:
+
+```console
+.venv/bin/python tools/fft_profiling/fft_profiling.py \
+  --output /shared/path/pyamplicol-fft-profile \
+  --families ddbar --lines otf-fft \
+  --multiplicities 6 --overwrite \
+  --cores 10 --memory-limit-gib 100 --time-limit-seconds 36000
+```
+
+`--refresh` is intentionally conservative: it refuses an unrecognized path and
+will not remove a workspace while a coordinated MadGraph writer is active.
+
+Inspect machine-readable progress without launching work:
+
+```console
+.venv/bin/python tools/fft_profiling/fft_profiling.py \
+  --status --output /shared/path/pyamplicol-fft-profile
+```
+
+## Render what is currently available
+
+The driver publishes immutable snapshots during a scan. Rendering freezes the
+latest already-published snapshot immediately and never waits for active
+workers:
+
+```console
+.venv/bin/python tools/fft_profiling/fft_profiling.py \
+  --render --output /shared/path/pyamplicol-fft-profile
+```
+
+For a custom output, the saved manifest determines whether the workload is
+fixed-helicity or helicity-summed; repeating `--compare-helicity-sums` is not
+required. The current PDF is written below:
+
+```text
+RUN/render/current/summary_plots_final.pdf
+RUN/render/current/summary_plots_final_helicity_sum.pdf
+```
+
+Only the filename matching the run's workload is produced. The same render
+contains six PNGs: setup time, warmed runtime, and peak RSS for each process
+family.
+
+Without a custom output, select the two canonical workspaces explicitly:
+
+```console
+.venv/bin/python tools/fft_profiling/fft_profiling.py --render
+.venv/bin/python tools/fft_profiling/fft_profiling.py \
+  --render --compare-helicity-sums
+```
+
+Generation selectors (`--lines`) decide what work enters the campaign. The
+render-only `--main-include-lines`, `--main-veto-lines`,
+`--ratio-include-lines`, and `--ratio-veto-lines` options only control which
+retained series appear in the main and ratio panels.
+
+## Interpret setup and warmed runtime
+
+The plotted *setup time* is method-specific:
+
+- pyAmpliCol includes artifact generation, fresh load, first requested
+  evaluation, and OTF family construction where applicable;
+- Reference FFT includes its build, initialization, and first pass;
+- AmpliCol includes its process/colour-object or raw-library preparation for
+  the selected workload.
+
+Warmed runtime is measured separately after those setup boundaries. The exact
+symmetric-group FFT is not guaranteed to beat direct contraction for every
+process: small certified permutation subgroups or large direct residuals can
+produce similar scaling.
+
+Published rolling snapshots:
+
+- [selected-helicity FullColor FFT PDF](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/summary_plots_final.pdf)
+- [complete-helicity-sum FullColor FFT PDF](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/summary_plots_final_helicity_sum.pdf)
+
+These are measurement-host results rather than release-CI benchmarks. Raw
+campaign workspaces remain local.
+
+## See also
+
+- [Configuration](configuration.md#color-accuracy-and-lc-layout) — enable exact FFT contraction in a generated artifact.
+- [Command-Line Interface](command-line-interface.md#generate) — direct generation example.
+- [Performance Reports](../performance_reports/README.md) — published frontiers and measurement boundaries.
+- [Installation](installation.md#contributor-installation) — optional profiling references.
diff --git a/pyamplicol/docs/user/generation-modes-and-evaluators.md b/pyamplicol/docs/user/generation-modes-and-evaluators.md
new file mode 100644
index 0000000000..6dbd2fb749
--- /dev/null
+++ b/pyamplicol/docs/user/generation-modes-and-evaluators.md
@@ -0,0 +1,449 @@
+---
+title: "Generation Modes and Evaluators"
+nav_order: 4
+parent: "Configuration"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Generation Modes and Evaluators
+
+For ordinary generation, pyAmpliCol makes two independent choices when it
+builds a process artifact:
+
+1. the **execution mode** describes how process-wide work is organized;
+2. the **evaluator backend** describes how local symbolic expressions become
+   executable numerical kernels.
+
+Keeping these axes separate makes it possible to compare algorithms without
+changing the model, process, color approximation, or public runtime API.
+
+## Choose an execution mode
+
+Set the mode in TOML:
+
+```toml
+[evaluator]
+execution_mode = "recurrence"
+backend = "jit"
+```
+
+or on the command line:
+
+```console
+pyamplicol generate "u u~ > Z g g" artifacts/uubar_zgg \
+  --model built-in-sm \
+  --execution-mode recurrence \
+  --backend jit
+```
+
+Ordinary recurrence, compiled, and eager can deliberately specialize generation
+to one or more flow IDs, helicity IDs, or both with
+`process.selected_color_sector_ids` and
+`process.selected_source_helicities`. This reduces the reusable coverage of
+the resulting artifact and is useful when the same narrow workload will be
+run repeatedly. Omit those fields when runtime selection is wanted.
+On-the-fly does not use generation-time specialization: `warm_up(...)` builds
+the runtime-selected family and retains only the most recently selected one.
+
+| Mode | What generation writes | Best starting point | Model requirement |
+| --- | --- | --- | --- |
+| `recurrence` | Compact current-recursion schedules over prepared local kernels | Default; scalable general-purpose generation and runtime | A compatible prepared model bundle |
+| `compiled` | Process-local stage DAG evaluators | Self-contained compiled processes and direct backend experiments | Portable model IR is sufficient |
+| `eager` | Compact process DAG invocation tables over prepared local kernels | Compare process DAG scheduling while reusing model kernels | A compatible prepared model bundle |
+| `on-the-fly` | A compact process seed; the requested query family is built on first use | High-multiplicity LC single-flow/helicity-sum work with an explicit cold warm-up | A compatible prepared model bundle |
+
+### Recurrence
+
+Recurrence is the global default. Generation writes compact current schedules
+and references only the prepared model kernels needed by the process. It is the
+recommended first choice for the wheel-owned built-in Standard Model:
+
+```console
+pyamplicol generate "u u~ > Z g g g" artifacts/uubar_z3g_recurrence \
+  --model built-in-sm
+```
+
+The installed wheel supplies portable JIT-O2 prepared bundles for both
+`built-in-sm` and `built-in-sm-heft`, so no explicit pack path is needed for
+either model. A raw external JSON or UFO model does not have prepared kernels;
+compile a `.pyamplicol-model` bundle first.
+
+Recurrence has two runtime tiling controls:
+
+```toml
+[evaluator.recurrence]
+point_tile_size = 1024
+workspace_mib = 256
+```
+
+`workspace_mib` is a soft batching target, not a memory limit. The runtime may
+reduce the effective point tile to approach this target, but always allocates
+the workspace needed to evaluate at least one point, even when that exceeds
+the target. It does not increase the requested tile. Use an external memory
+watchdog when a strict limit on total process memory is required.
+
+For topology replay, generation groups current-building operations with similar
+helicity coverage while keeping shared-input groups together. The row order is
+stored in the process output; selecting one helicity does not rebuild or
+optimise the currents. Momentum sums follow their stored term order across a
+batch of points. These arrangements retain the full generated helicity
+coverage and do not introduce an OTF-style first-call preparation step.
+For a selected helicity, a current buffer is not cleared separately when its
+first retained contribution already initializes it. Other selected schedules
+keep the required clears.
+
+Recurrence outputs generated with `color.contraction = "symmetric-group-fft"`
+also retain exact colour coefficients. Double-double and arbitrary-precision
+evaluation use a direct contraction of those coefficients, streamed from the
+compact FFT representation without constructing a dense matrix. This is an
+exact-precision fallback, not a higher-precision FFT, and can be substantially
+slower than the native binary64 path at high multiplicity.
+
+### Compiled
+
+Compiled mode lowers a process-wide DAG into evaluator stages while generating
+the artifact. It can start from portable compiled model IR and is therefore the
+primary shipped JSON-model example:
+
+```console
+pyamplicol generate_pp_zjj_from_ufo_sm.toml
+```
+
+That card compiles seven tree-level representatives for `p p > Z j j` using
+process-local JIT O2. The resulting all-JIT-O2 process artifact is portable
+across the supported 64-bit little-endian release platforms.
+
+Select compiled mode explicitly when overriding another card:
+
+```console
+pyamplicol generate --card qq_z6g_recurrence_jit_o2.toml \
+  --execution-mode compiled \
+  --set generation.output=artifacts/qq_z6g_compiled_override
+```
+
+Always use a different output when comparing modes; a process artifact is an
+immutable executable input, not a directory into which unrelated plans should
+be mixed.
+
+Generation also records which momentum sums the final compiled kernels use.
+Evaluation fills only those sums, directly across the point batch, without
+searching the expressions on the first call. The list covers every helicity
+retained by that compiled output, not just the first runtime selection.
+Source-wavefunction information is resolved once per source and point tile,
+using the current model parameters, and reused across the points in that tile.
+Changing masses or runtime source states therefore remains effective on the
+next evaluation without regenerating the process output.
+
+### Correlated Born generation
+
+Declaring [Born Correlations](../correlators.md) is an explicit exception to
+the independent mode/accuracy choices: the current path selects generic
+`compiled` amplitudes, a complete full-colour basis, and `direct` contraction.
+Requested LC/NLC/full accuracy selects the inserted colour matrices; requested
+settings are preserved alongside the effective generation adjustments.
+Recurrence, eager, OTF and FFT correlation executors are not implemented.
+
+Correlated generation retains complete source dependence without
+physical-helicity zero/parity reductions, replay, or numerical current reuse.
+Partial generation coverage and append mode are rejected. Correlated
+evaluation uses either the Python Symbolica-backed exact executor (including
+at `precision=16`) or the independent RustiCol binary64 executor exposed by
+the C/C++/Fortran/Rust SDKs. The ordinary native evaluation path remains
+available and unchanged. See the linked guide for declarations and runtime
+spin vectors.
+
+### Eager
+
+Eager mode writes compact DAG invocation tables and applies prepared local
+kernels directly at runtime:
+
+```console
+pyamplicol generate "u u~ > Z g g g" artifacts/uubar_z3g_eager \
+  --model built-in-sm \
+  --execution-mode eager
+```
+
+Its workspace controls mirror recurrence:
+
+```toml
+[evaluator.eager]
+point_tile_size = 1024
+workspace_mib = 256
+```
+
+An eager process artifact is standalone: it carries the referenced prepared
+kernels and compact invocation data. The model bundle used during generation
+is not needed to evaluate that artifact later.
+
+### On-the-fly
+
+On-the-fly (OTF) stores a compact process seed and the referenced prepared
+kernels instead of materializing a reusable process schedule during
+generation. The first explicit `warm_up(...)` or evaluation constructs the
+requested query family; later evaluations on the same loaded handle reuse it.
+Selecting a different family replaces the previous one.
+After construction completes, `runtime.save(path)` and
+`runtime.load_cache(path)` can carry that warm state between loaded runtimes
+without reconstructing its currents; see
+[Saving an OTF warm cache](runtime-and-selectors.md#saving-an-otf-warm-cache).
+
+This trade is designed around LC with one selected flow summed over all
+helicities. The same artifact can also build the all-flow sum for one selected
+helicity, so OTF does not use the materialized
+`topology-replay`/`all-flow-union` layout setting. Contracted NLC and full
+colour are available as low-multiplicity correctness capabilities, but their
+cold family can grow too quickly for practical high-multiplicity work.
+
+OTF evaluation is native binary64 only (`precision=16`) and requires a
+prepared model bundle; `built-in-sm` selects the wheel-owned JIT-O2 bundle.
+Plan its cold stage explicitly with exactly one phase-space point:
+
+```python
+result = runtime.warm_up(
+    (point,),
+    precision=16,
+    color_flows=(runtime.physics.color_flows[0],),
+    n_cores=4,
+    progress=progress,
+)
+```
+
+`n_cores` is an optional positive integer limiting parallel query construction
+for this call. Omit it to use `evaluator.optimization.cores` from generation.
+Cache merging and finalization remain serial; the override changes neither
+future evaluation threading nor cache identity. See the
+[warm-up contract](runtime-and-selectors.md#explicit-otf-warm-up) for details.
+
+The optional progress observer reports process preparation, query-family
+construction, family finalization, first evaluation, elapsed time, workers,
+and resident memory where available. `runtime.clear()` returns a Python OTF
+handle to cold state while retaining the loaded artifact and current model
+parameters. Native callers close and reload the handle. See
+[LC workloads and execution modes](lc-workloads-and-execution-modes.md#the-otf-warm-state-lifecycle)
+for the cache lifecycle and all five API spellings.
+
+## Choose an evaluator backend
+
+| Backend | Output | Portability and runtime |
+| --- | --- | --- |
+| `jit` | Direct SymJIT application | Compiled O1/O2 state can be portable; prepared packs use exact O2; f64 execution is Symbolica-independent |
+| `cpp` | Generated and compiled C++ evaluator library | Target-specific executable payload; f64 runtime is Symbolica-independent |
+| `asm` | Symbolica assembly evaluator library | Target-specific executable payload; f64 runtime is Symbolica-independent |
+
+### JIT
+
+The public JIT defaults are optimization level 2 with mode-aware compression:
+
+```toml
+[evaluator.jit]
+optimization_level = 2
+compress = "auto"
+```
+
+Prepared JIT kernel bundles used by recurrence, eager, and on-the-fly always
+use O2 because that is their cross-architecture storage contract. Process-local
+compiled JIT O1 and O2 artifacts are marked `portable-64le` only when every
+execution leaf is authenticated as compatible O1/O2 JIT state and no
+target-specific capability is present.
+
+Explicit JIT O0 or O3 remains available for host-specific experiments:
+
+```console
+pyamplicol generate --card qq_z6g_compiled_jit_o3.toml
+```
+
+Those artifacts are target-native. Copying one to another architecture is
+expected to fail compatibility checks rather than silently relower it.
+
+With `compress = "auto"`, compiled JIT O2 uses compression; recurrence, eager,
+on-the-fly, and other optimization levels leave it disabled. Explicit `true`
+and `false` settings override this default.
+
+Compression shares repeated arithmetic sequences, trading extra calls for
+smaller generated code. Either setting can be faster: larger evaluators can
+benefit from the smaller instruction footprint, while smaller ones can spend
+more time on those calls. Compare both settings with `profile` for an important
+workload. Enable or disable compression explicitly with `--jit-compress` or
+`--no-jit-compress`:
+
+```console
+pyamplicol generate ... --jit-compress
+```
+
+### C++
+
+C++ is a process-local compiled backend:
+
+```toml
+[evaluator]
+execution_mode = "compiled"
+backend = "cpp"
+
+[evaluator.cpp]
+optimization = "O3"
+native_arch = false
+```
+
+Portable C++ code generation is the default. `native_arch = true` opts into
+host-native instructions and records the required CPU features in the
+artifact. Loaders reject an incompatible target before reading executable
+state. Extra compiler flags use a restricted allowlist so an unrecorded ISA
+requirement cannot be introduced accidentally.
+
+### Assembly
+
+The assembly backend is also target-native and uses the same public Rusticol
+runtime surface. Like C++, it is primarily a compiled-mode backend. Generation
+requires Symbolica; f64 evaluation of the completed compatible artifact does
+not.
+
+## Prepared model bundles
+
+A JSON file such as `models/json/sm/sm.json` is portable model IR. It contains
+model structure and expressions but no ready local-kernel backend.
+
+A file ending in `.pyamplicol-model` is a prepared bundle: model IR, exact
+expressions, and one compiled local-kernel backend. Recurrence, eager, and
+on-the-fly require this prepared boundary.
+
+Prepare an external JIT-O2 bundle:
+
+```console
+pyamplicol model compile \
+  models/json/sm/sm.json models/ufo-sm-jit-o2.pyamplicol-model \
+  --backend jit \
+  --jit-optimization-level 2
+```
+
+Use it in recurrence or eager generation:
+
+```console
+pyamplicol generate "d d~ > z g g g" artifacts/ddbar_z3g_ufo \
+  --model models/ufo-sm-jit-o2.pyamplicol-model \
+  --execution-mode recurrence
+```
+
+A missing or incompatible pack fails explicitly; configuration never falls
+back from recurrence/eager/on-the-fly to compiled mode.
+
+## Color accuracy and LC flow layout
+
+For ordinary Born evaluation, execution mode is independent of color accuracy:
+
+| Accuracy | Runtime color axis |
+| --- | --- |
+| `lc` | One physical leading-color flow per resolved color entry |
+| `nlc` | One contracted color entry per helicity |
+| `full` | One contracted color entry per helicity |
+
+LC also has two complete-coverage layouts:
+
+| Layout | Optimized workload |
+| --- | --- |
+| `topology-replay` | Default: one runtime-selected flow, summed helicities |
+| `all-flow-union` | All flows, one runtime-selected helicity |
+
+Choose union flow explicitly:
+
+```console
+pyamplicol generate \
+  --card benchmark_z6g_single_flow_helicity_sum.toml \
+  --lc-flow-layout all-flow-union \
+  --set generation.output=artifacts/uubar_z6g_all_flow_union
+```
+
+Both layouts retain all physical LC flows and helicities and support runtime
+selectors. `all-flow-union` is LC-only and is incompatible with a
+generation-specialized flow/helicity request or truncated color coverage.
+OTF retains the same physical LC selector choices but constructs the requested
+family at runtime and therefore ignores this materialized-layout setting.
+
+## Validation and current reuse
+
+Generation has three distinct checks; they should not be confused:
+
+1. **Artifact writing** always validates the schema, confined references,
+   declared payload sizes, and digests.
+2. **Current relation discovery** uses deterministic high-precision probes and
+   independent verification to apply certified current reuse when structural
+   proof is unavailable, subject to the execution layout's
+   [application restrictions](configuration.md#numerical-current-reuse).
+3. **Post-build validation** optionally reopens the completed artifact and
+   compares native f64 optimized and resolved evaluation.
+
+Post-build validation is off by default because it does not change the written
+artifact and can be disproportionately expensive for large resolved axes.
+Enable it when an immediate runtime smoke is useful:
+
+```console
+pyamplicol generate ... --post-build-validation
+```
+
+Ordinary generation validation defaults to two deterministic samples. Current
+relation discovery is off by default because its high-precision probes are
+costly at generation time. Enable it to search for additional certified
+equal, opposite, or zero-current reuse in the generated schedule:
+
+```console
+pyamplicol generate ... --numerical-current-reuse
+```
+
+This changes optimization, not the expected physics result; the search may
+find nothing for a given process, in which case the schedule is unchanged.
+OTF uses its compact source projection and does not run the configurable
+relation-discovery pass. Correlated generation also disables this pass,
+regardless of the requested ordinary reuse setting.
+
+## Three matched examples
+
+The copied example workspace contains three cards for the same
+`u u~ > Z + 6g` LC topology-replay workload:
+
+```console
+pyamplicol generate --card qq_z6g_recurrence_jit_o2.toml
+pyamplicol profile  --card qq_z6g_recurrence_jit_o2.toml
+
+pyamplicol generate --card qq_z6g_compiled_jit_o3.toml
+pyamplicol profile  --card qq_z6g_compiled_jit_o3.toml
+
+pyamplicol generate --card qq_z6g_eager_jit_o2.toml
+pyamplicol profile  --card qq_z6g_eager_jit_o2.toml
+```
+
+These are intentionally explicit comparison cards: recurrence JIT O2, compiled
+JIT O3, and eager JIT O2. Generation and profiling can be substantial for six
+final-state gluons; use the primary Z+jet example for a quick functional
+check.
+
+The packaged OTF walkthrough uses `p p > Z j j`, an explicit one-point
+warm-up, and the same public profiler:
+
+```console
+pyamplicol generate --card otf_pp_zjj.toml
+python python/otf_pp_zjj_warm_up.py
+pyamplicol profile --card otf_pp_zjj.toml
+```
+
+## Decision guide
+
+| Goal | Suggested choice |
+| --- | --- |
+| First built-in-SM artifact | Recurrence + JIT O2 (defaults) |
+| Raw JSON/UFO model without a prepared pack | Compiled mode, or prepare a pack first |
+| Spin-/colour-correlated Born quantities | Declare correlations; LC/NLC/full, complete direct compiled generation, grouped Python exact or native binary64 evaluation |
+| Reuse prepared kernels with process tables | Eager + the pack's backend |
+| Keep a high-multiplicity LC artifact compact and repeatedly run one selected flow | On-the-fly + an explicit one-point warm-up |
+| Cross-architecture release-host movement | Compiled all-JIT O1/O2 artifact, or eager/recurrence with a prepared JIT O2 pack |
+| One-flow/helicity-sum LC runtime | `topology-replay` |
+| All-flow/single-helicity LC runtime | `all-flow-union` |
+| Host-specific performance experiment | Explicit compiled JIT O3, C++, ASM, or C++ `native_arch` |
+| Fast confidence after generation | Normal generation validation; enable post-build validation only when wanted |
+
+## See also
+
+- [Configuration](configuration.md)
+- [Models and Processes](models-and-processes.md)
+- [Artifacts and Portability](artifacts-and-portability.md)
+- [Profiling and Benchmarking](profiling-and-benchmarking.md)
+- [LC workloads and execution modes](lc-workloads-and-execution-modes.md)
+- [Symbolica and Licensing](symbolica-and-licensing.md)
diff --git a/pyamplicol/docs/user/gentle-walkthrough.md b/pyamplicol/docs/user/gentle-walkthrough.md
new file mode 100644
index 0000000000..a37d422ded
--- /dev/null
+++ b/pyamplicol/docs/user/gentle-walkthrough.md
@@ -0,0 +1,638 @@
+---
+title: "Get started: a gentle walkthrough"
+nav_order: 2.5
+has_children: true
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Get started: a gentle walkthrough
+
+This page is for physicists who are comfortable writing a MadGraph process such
+as `p p > Z j j`, but who may not want to learn software-packaging vocabulary
+before obtaining a matrix element. It follows one example from the model and
+process request to numerical evaluation, timing, Python, and the native
+languages used in event generators.
+
+pyAmpliCol generates and evaluates tree-level matrix elements. It does not
+replace the PDF convolution, phase-space integration, event generation,
+showering, or analysis parts of a Monte Carlo workflow. A useful first mental
+picture is:
+
+| In a MadGraph-style workflow | In pyAmpliCol |
+| --- | --- |
+| Import or choose a model | Select `built-in-sm`, a serialized JSON model, a trusted UFO directory, or a prepared model |
+| Define `p`, `j`, and other multiparticles | Fill `[process.multiparticles]` or pass `--multiparticle` |
+| `generate p p > z j j` | Put `p p > Z j j` in a run card or pass it to `pyamplicol generate` |
+| `output` | Generate a self-contained **process output directory** |
+| Choose one subprocess | Select a readable expression or its stable process ID |
+| Evaluate or time the matrix element | Use `evaluate`, `profile`, the Python API, or a native API |
+
+The process output directory is sometimes called an *artifact* in error
+messages and in the more technical documentation. On this page, “process
+output” means the same thing.
+
+## A five-minute `p p > Z j j` tour
+
+First activate the Python environment in which pyAmpliCol is installed. Copy
+the packaged examples into a directory you can edit:
+
+```console
+pyamplicol examples copy ./pyamplicol-examples
+cd pyamplicol-examples
+```
+
+The copy includes cards, momenta, Python examples, native examples, and the
+packaged model files. It is independent of the package installation, so it is
+safe to edit.
+
+Generate a leading-colour recurrence output for a small two-flavour definition
+of `p` and `j`:
+
+```console
+pyamplicol generate "p p > Z j j" artifacts/pp_zjj_recurrence \
+  --model built-in-sm \
+  --multiparticle 'p=d,d~,g' \
+  --multiparticle 'j=d,d~,g' \
+  --flavor-scheme 2 \
+  --max-quark-lines 2 \
+  --color-accuracy lc \
+  --execution-mode recurrence
+```
+
+Generation uses the protective `error` policy by default: if that output
+directory already exists, the command stops instead of overwriting it. Choose a
+new output name when repeating the tour, or use `--force` only when replacing
+the complete existing output is intentional.
+
+The wheel contains prepared Standard Model building blocks for this recurrence
+example. With these definitions, pyAmpliCol finds the ordered partonic channels,
+identifies channels related by incoming or outgoing permutations, and stores
+one reusable representative for each class. The loop-induced
+`g g > Z g g` channel has no tree-level Standard Model amplitude and is
+reported rather than generated.
+
+Here `p` and `j` are simply names for the particle lists supplied on the
+command line. They expand the inclusive request into separate partonic matrix
+elements; they do not apply PDFs or sum over incoming parton luminosities.
+`--color-accuracy lc` keeps the leading-colour result resolved into its physical
+flows. With no runtime selector, evaluation sums all those flows and all
+helicities.
+
+Now ask what was produced:
+
+```console
+pyamplicol inspect artifacts/pp_zjj_recurrence
+```
+
+The coloured tables list the model, runtime, concrete representatives, aliases,
+helicity and colour coverage, and the recurrence execution mode. Pick the
+representative with stable ID `p_p_to_z_j_j_3`, or use its readable requested
+ordering `d d~ > g z g`:
+
+```console
+pyamplicol inspect artifacts/pp_zjj_recurrence \
+  --process 'd d~ > g z g'
+```
+
+The documentation uses *selector* for one of these explicit choices: a process
+ID or expression, a helicity ID, or an LC flow ID. It is a choice, not a new
+physics object.
+
+Evaluate the supplied phase-space point. Its external legs are in exactly the
+order written in `--process`, and every four-vector is `[E, px, py, pz]`:
+
+```console
+pyamplicol evaluate artifacts/pp_zjj_recurrence \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json \
+  --precision 16
+```
+
+This returns the helicity- and colour-summed result. To see the components and
+their explicit sum, add `--resolved`:
+
+```console
+pyamplicol evaluate artifacts/pp_zjj_recurrence \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json \
+  --precision 16 \
+  --resolved
+```
+
+Finally, time the optimized summed path:
+
+```console
+pyamplicol profile artifacts/pp_zjj_recurrence \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json \
+  --batch-size 128 \
+  --target-runtime 1.0 \
+  --precision 16
+```
+
+The profile table records the selected process and selectors, batch size,
+independent timing blocks, wall time per point, and the native phase breakdown
+available for that execution mode. A 128-point profile batch is a throughput
+measurement; it does not mean that an on-the-fly warm-up should use 128 points.
+
+At this stage you have exercised the usual loop:
+
+```text
+choose model and process -> generate process output -> inspect -> evaluate -> profile
+```
+
+## The run card is a reusable set of choices
+
+Long commands are useful while exploring. A TOML run card is better when the
+same physics choices must be recorded and repeated. The recurrence command
+above corresponds to the following card, which you could save as
+`my_pp_zjj.toml`:
+
+```toml
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "p p > Z j j" }]
+flavor_scheme = 2
+max_quark_lines = 2
+
+[process.multiparticles]
+p = ["d", "d~", "g"]
+j = ["d", "d~", "g"]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/pp_zjj_recurrence_card"
+emit_api_bundle = true
+
+[evaluator]
+execution_mode = "recurrence"
+```
+
+Run a card directly:
+
+```console
+pyamplicol my_pp_zjj.toml
+```
+
+or name the action explicitly:
+
+```console
+pyamplicol generate --card my_pp_zjj.toml
+```
+
+These spellings use the same configuration. The first reads `action` from the
+card; the second says that this invocation is a generation action.
+
+The packaged `generate_pp_zjj_from_ufo_sm.toml` card demonstrates a related
+choice: it reads the serialized form of the UFO Standard Model and selects
+`compiled` execution. Raw JSON or UFO model data contains the physics rules but
+not the prepared recurrence building blocks, so that card deliberately builds
+process-wide compiled evaluators. See [Models and Processes](models-and-processes.md) when
+preparing recurrence, eager, or on-the-fly building blocks for another model.
+
+### Cards, named options, and `--set`
+
+Cards and command-line options use the same list of named settings (called the
+configuration schema). Values are applied in this order:
+
+1. pyAmpliCol defaults;
+2. values in the card;
+3. named command-line options such as `--workers 4`;
+4. repeated `--set dotted.path=value` options, from left to right;
+5. any unavoidable license or resource adjustment.
+
+Later entries win. For example, this uses two workers and writes to a fresh
+output without editing the packaged card:
+
+```console
+pyamplicol generate --card generate_pp_zjj_from_ufo_sm.toml \
+  --workers 4 \
+  --set generation.workers=2 \
+  --set generation.output=artifacts/pp_zjj_trial
+```
+
+The named option first requests four workers; the later `--set` changes that
+request to two. `--set` values follow TOML syntax. Numbers and booleans are
+written naturally; quote a string when it contains spaces.
+
+To see the complete interpretation without generating a process output, use:
+
+```console
+pyamplicol config resolve generate_pp_zjj_from_ufo_sm.toml \
+  --set generation.workers=2
+```
+
+The `requested` section shows the card after defaults and overrides. The
+`effective` section is the schema-valid configuration at this resolution step,
+and `adjustments` records any clamps supplied to that resolver. Generation may
+later apply constraints from a prepared model or the active Symbolica license;
+those requested/effective differences and their reasons are retained in the
+generated output and reported during the command. Use `config resolve` first
+when a card or override does not appear to select the value you expected, then
+read any adjustment reported by generation itself.
+
+Paths written in a card are interpreted relative to that card, not relative to
+the shell from which it is run. That is why the packaged cards continue to find
+their `models/`, `data/`, and `artifacts/` paths after the example directory is
+moved.
+
+The exhaustive field reference is `all_options.toml` in the copied workspace.
+The shorter explanation of colour, execution modes, and selectors is in
+[Configuration](configuration.md).
+
+## What is inside a process output?
+
+Think of `artifacts/pp_zjj_recurrence/` as a generated, self-contained matrix-
+element library for one model and a set of partonic processes. It contains:
+
+- the model identity, restriction, parameter catalogue, and configuration used
+  for generation;
+- a stable list of concrete process representatives and their aliases;
+- the helicity and colour information needed to interpret results;
+- executable evaluator data for the selected execution mode;
+- deterministic validation momenta; and
+- when `emit_api_bundle = true`, small Python, C, C++, Fortran, and Rust
+  standalone drivers under `API/`.
+
+It is a directory rather than one shared library because the metadata and
+physics axes are as important as the numerical code. You can move the whole
+directory and load it from another working directory. Do not move individual
+files out of it or edit them by hand.
+
+Process outputs are executable inputs, much like a compiled library. Only load
+one that you generated yourself or obtained from a source you trust. Normal
+loading validates its declared structure and compatibility. It is not a proof
+of who published it; the trust rules and optional all-file hash check are
+described in [Artifacts and Portability](artifacts-and-portability.md).
+
+### Representatives and aliases avoid duplicate work
+
+For the request `p p > Z j j`, several ordered channels differ only by a
+permutation of incoming legs, outgoing legs, or both. pyAmpliCol stores one
+representative evaluator where that equivalence is established. The other
+orders appear as aliases.
+
+You may therefore select either a stable ID:
+
+```console
+pyamplicol inspect artifacts/pp_zjj_recurrence \
+  --process p_p_to_z_j_j_3
+```
+
+or a readable ordering:
+
+```console
+pyamplicol inspect artifacts/pp_zjj_recurrence \
+  --process 'd d~ > g z g'
+```
+
+The runtime remaps momenta and result labels to the order you requested. An
+incoming particle never crosses the `>` sign to become outgoing, or vice versa.
+If a readable expression could refer to more than one representative,
+pyAmpliCol stops and prints the possible stable IDs instead of guessing.
+
+Stable IDs are convenient in production scripts because they do not depend on
+case or whitespace. Readable expressions are often clearer in a notebook.
+
+### What is shared between processes?
+
+A *current* here is an intermediate off-shell object built from a subset of the
+external legs—the same physical idea that appears in Berends–Giele-style
+recursion. Sharing is conservative:
+
+- Multiparticle aliases and side-preserving permutations use the same concrete
+  representative rather than duplicating its calculation.
+- In eager, recurrence, and on-the-fly outputs, the model's prepared numerical
+  building blocks are stored once and referenced by the processes that need
+  them. These are the reusable rules for constructing currents from vertices.
+- In recurrence mode, two process schedules are stored once only when an exact
+  process-to-process mapping proves that the complete current construction is
+  the same. A small per-process binding restores the external order, helicities,
+  and colour labels.
+- The model provenance, common configuration, dependencies, and parameter
+  definitions belong to the output as a whole.
+
+What is not shared by assumption is just as important. Unrelated subprocesses
+do not have their currents merged merely because some particle names coincide.
+Each genuine process retains its own external-state metadata, selector
+coverage, validation point, and process binding. Compiled mode has
+process-specific stage evaluators; eager mode has process-specific invocation
+tables; recurrence has a process binding to its recorded and checked schedule;
+and on-the-fly mode has a compact seed for each process.
+
+This is why adding several processes to one output can save model and schedule
+storage without changing the meaning of any individual matrix element.
+
+### Adding another process later
+
+The safest starting point is to put the complete process set in one
+`process.entries` list and generate it together. pyAmpliCol can also append a
+new process without exposing a half-written intermediate output when the
+existing mode permits it and the model, target, pyAmpliCol build, and generation
+settings are identical.
+
+The typed Python API makes the unchanging configuration explicit. This compact
+example creates a compiled output, then appends a second process:
+
+```python
+from pyamplicol import Generator
+from pyamplicol.config import (
+    Action,
+    EvaluatorConfig,
+    GenerationConfig,
+    RunConfig,
+)
+
+config = RunConfig(
+    action=Action.GENERATE,
+    generation=GenerationConfig(emit_api_bundle=True),
+    evaluator=EvaluatorConfig(execution_mode="compiled"),
+)
+generator = Generator(config)
+output = "artifacts/z_plus_jet"
+
+generator.generate("u u~ > Z g", output)
+generator.generate("d d~ > Z g", output, mode="append")
+```
+
+Append rejects a duplicate stable ID or a change of model, target, prepared
+model building blocks (called a kernel pack in technical messages),
+configuration, or producer identity before modifying the existing output.
+Current recurrence root schedules are immutable, so generate the full
+recurrence process set together instead of appending to it. If settings must
+change, write a new output or regenerate the complete set with explicit
+`replace` mode. The default `error` mode protects an existing directory from
+accidental replacement.
+
+Inspect the output after an append and keep the output directory together. The
+root `API/` bundle is regenerated to include validation points for the full
+process set.
+
+## Reading `inspect` as a physicist
+
+Start with the compact view:
+
+```console
+pyamplicol inspect artifacts/pp_zjj_recurrence
+```
+
+It reads metadata and does not instantiate every helicity/colour evaluator.
+The tables are intentionally more detailed than a MadGraph process list, but a
+first-time user only needs a few fields.
+
+### The `Artifact` table
+
+| Field | What to check |
+| --- | --- |
+| `path` | The process output you meant to open. |
+| `artifact type` | Usually a generated process set. “Artifact” means process output here. |
+| `artifact ID` | A content label for the files that affect evaluation; useful when recording exactly what was benchmarked. |
+| `producer` | The pyAmpliCol version that generated the output. |
+| `target` | `portable-64le` can be loaded on supported 64-bit little-endian hosts; an explicit machine triple or CPU feature list indicates a target-specific output. |
+| `model` | Model source and restriction. Check this before comparing physics results. |
+| `default process` | The process selected when a multiprocess output is loaded without an explicit selector. Production code should normally select one explicitly. |
+| `contents` | Number of stored representatives and aliases. |
+| `runtime` / `capabilities` | The native engine and features required from the installed runtime. |
+| `payloads` | Physical size and, for packed JIT data, the number and unpacked size of logical evaluators. |
+| `integrity` | The top-level file inventory (the manifest) and declared structure were accepted. This is not publisher authentication. |
+
+### The `Processes` and `Aliases` tables
+
+| Field | Physical meaning |
+| --- | --- |
+| `stable ID` | Durable selector for CLI, Python, and native calls. |
+| `concrete process` | External particles in the representative ordering. |
+| `color` | `lc`, contracted `nlc`, or contracted `full`. |
+| `helicities` | Physical configurations, with a smaller evaluated count in parentheses when certified reuse is active. |
+| `color outputs` | Physical LC flows; NLC/full expose one contracted colour result per helicity. |
+| `coverage (hel./color)` | `complete / complete` means selectors were not fixed during generation. A specialized output says which axis was restricted. |
+| `aliases` | Number of requested orderings mapped to this representative. |
+
+The separate `Aliases` table names each mapped ordering and the representative
+that evaluates it. This is the closest analogue to seeing the expanded
+subprocess list while also learning which entries reuse one evaluator.
+
+### The `Execution` table
+
+The most useful lines are:
+
+- `mode / backend`: recurrence, compiled, eager, or on-the-fly and the prepared
+  numerical backend, where applicable;
+- `LC flow layout`: whether a materialized LC output is arranged for one-flow
+  helicity sums (`topology-replay`) or all-flow single-helicity work
+  (`all-flow-union`);
+- `runtime selectors`: whether helicity and colour flow remain selectable;
+- `generation specialization` and `generation selection`: whether generation
+  fixed a particular flow, helicity assignment, or both;
+- `native profile phases`: which timing pieces can appear in `profile`; and
+- the requested/effective point tile and workspace, which matter for memory at
+  large batches.
+
+Recurrence rows and eager invocation counts are engineering descriptions of
+the same current construction; they are mainly useful when comparing output
+size or diagnosing performance. For an on-the-fly output, look instead for the
+physical helicity/flow census, query-construction threads, and `f64 only`
+(standard double precision). These describe what can be selected without
+forcing the complete high-multiplicity family to be built during inspection.
+
+For a physicist-oriented comparison of both LC layouts, all four execution
+modes, and the OTF warm-state lifecycle, continue with [LC workloads and
+execution modes](lc-workloads-and-execution-modes.md).
+
+Use a process selector to shorten the table:
+
+```console
+pyamplicol inspect artifacts/pp_zjj_recurrence \
+  --process p_p_to_z_j_j_3
+```
+
+The explicit full-physics view materializes complete helicity and colour
+metadata and may be very large:
+
+```console
+pyamplicol inspect artifacts/pp_zjj_recurrence \
+  --process p_p_to_z_j_j_3 \
+  --full-physics
+```
+
+Reserve it for a selected low-multiplicity process when the compact table is
+not enough.
+
+## Choose the interface that fits your calculation
+
+All interfaces load the same process output and use the same stable process and
+selector IDs. You do not generate a separate “Python version” and “Fortran
+version.”
+
+| Interface | A natural use |
+| --- | --- |
+| CLI | Generate, inspect, make one-off evaluations, compare settings, and profile. |
+| Typed Python API | Notebooks, scans, tests, parameter updates, and integration with Python phase-space code. |
+| C11 API | A small set of stable C functions for an existing C or mixed-language program. |
+| C++17 wrapper | Automatic lifetime management and `std::vector`-based evaluation. |
+| Fortran 2008 module | Monte Carlo and phenomenology codes written in Fortran. |
+| Rust 2021 wrapper | Ownership-checked access without an external Rust crate dependency. |
+
+### Typed Python
+
+The numerical part of the five-minute tour is only a few lines:
+
+```python
+import json
+from pathlib import Path
+
+from pyamplicol import Runtime
+
+points = json.loads(Path("data/pp_zjj_momenta.json").read_text())
+runtime = Runtime.load(
+    "artifacts/pp_zjj_recurrence",
+    process="d d~ > g z g",
+)
+
+print(runtime.physics.process)
+print(runtime.physics.helicity_ids[:2])
+print(runtime.physics.color_flow_ids[:2])
+print(runtime.evaluate(points, precision=16))
+```
+
+`runtime.physics` describes the selected process. Pass IDs from that object to
+`evaluate(..., helicities=..., color_flows=...)` to select components. LC
+accepts both kinds of selector; NLC and full colour are already contracted and
+therefore accept helicity selectors but not an LC flow selector.
+
+The packaged scripts show complete typed generation, parameter updates,
+resolved evaluation, and benchmarking:
+
+```console
+python python/typed_generation.py artifacts/pp_zjj_typed --plan-only
+python python/runtime_evaluation.py \
+  artifacts/pp_zjj_recurrence data/pp_zjj_momenta.json \
+  --process 'd d~ > g z g'
+```
+
+See [Runtime and Selectors](runtime-and-selectors.md) for point-wise selectors, exact precision, model
+parameters, resolved output shapes, and explicit on-the-fly `warm_up(...)`.
+
+### Generated Python, C, C++, Fortran, and Rust drivers
+
+Because the tour kept the default `emit_api_bundle = true`, the process output
+contains standalone examples for every supported language. Run them from the
+copied example workspace:
+
+```console
+python artifacts/pp_zjj_recurrence/API/python/check_standalone.py \
+  --process 'd d~ > g z g' --json
+
+make -C artifacts/pp_zjj_recurrence/API/c run \
+  ARGS='--process "d d~ > g z g" --json'
+
+make -C artifacts/pp_zjj_recurrence/API/cpp run \
+  ARGS='--process "d d~ > g z g" --json'
+
+make -C artifacts/pp_zjj_recurrence/API/fortran run \
+  ARGS='--process "d d~ > g z g" --json'
+
+make -C artifacts/pp_zjj_recurrence/API/rust run \
+  ARGS='--process "d d~ > g z g" --precision 16 --json'
+```
+
+With no `--kinematics` option, each driver uses the validation point stored in
+the output and remaps it to the requested leg order. The drivers compare the
+optimized total with the explicit sum of resolved components, so they are also
+a useful first check of a compiler and linker setup.
+
+The installed `rusticol-config` command supplies the include paths, static
+library, Fortran module source, and linker flags. Native calls use standard
+double precision, also called binary64 (`precision = 16`). Python can also use
+a retained higher-precision evaluator when that execution mode provides one;
+on-the-fly execution is double precision in all languages.
+
+For embedding rather than running the example drivers, start with
+[Native APIs](native-apis.md). It contains complete loading/evaluation examples,
+memory layout, compiler commands, model-parameter updates, selector arrays, and
+the cross-language on-the-fly warm-up callback.
+
+## Where on-the-fly mode fits
+
+Recurrence generated all reusable schedules before the first load. On-the-fly
+(OTF) instead stores a compact process description and constructs a selected
+family when it is first requested. Its practical focus is a leading-colour,
+single-flow calculation summed over helicities, especially as multiplicity
+grows.
+
+The packaged OTF walkthrough uses the same `p p > Z j j` process:
+
+```console
+pyamplicol generate --card otf_pp_zjj.toml
+python python/otf_pp_zjj_warm_up.py
+pyamplicol profile --card otf_pp_zjj.toml
+```
+
+The Python step calls `warm_up(...)` with exactly one double-precision
+phase-space point and one LC flow. Omitting the helicity selector requests the
+helicity sum. Its progress display reports query construction and live memory;
+the following table reports the selected flow, warm-up time, query counts,
+memory, and matrix element. The independent `profile` command then measures
+128-point throughput.
+
+You can keep completed preparation between programs: save it with
+`runtime.save("process.otf-cache")`, then load the original process output in
+the next program and call `runtime.load_cache("process.otf-cache")`. Continue
+with the same helicity/flow selectors to reuse the saved work. This is explicit
+API functionality, not an automatic cache shared by separate CLI commands.
+See the [small Python example](runtime-and-selectors.md#saving-an-otf-warm-cache)
+and [native SDK examples](native-apis.md#saving-and-restoring-an-otf-cache).
+
+OTF NLC and full-colour calculation are available for low multiplicity, but
+their contracted family grows rapidly and is not intended here as a
+high-multiplicity performance route. The detailed differences among recurrence,
+compiled, eager, and OTF are summarized in
+[Generation Modes and Evaluators](generation-modes-and-evaluators.md).
+
+## A practical checklist for a new calculation
+
+1. Copy the examples and make sure the five-minute tour works.
+2. Choose a trusted model. Prefer serialized JSON for reproducibility; treat a
+   UFO directory as executable Python input.
+3. Write the process and multiparticle definitions in a card. Start with a
+   narrow flavour scheme while testing.
+4. Choose colour accuracy and an execution mode. Recurrence is the general
+   prepared-model default; compiled accepts a model that has not had its local
+   numerical building blocks prepared; eager stores compact invocation tables
+   around those prepared building blocks; OTF is aimed at selected
+   double-precision workloads.
+5. Generate into a new output directory. Keep the default `error` policy until
+   replacement is intentional.
+6. Run compact `inspect`. Check the model, process, colour accuracy, coverage,
+   execution mode, and target before evaluating.
+7. Evaluate a known point and compare total with resolved output.
+8. Profile the exact helicity/flow workload and batch size your application
+   will use.
+9. Integrate the same output through Python or one native API. Select a process
+   explicitly in production code.
+10. Record the card, process selector, model parameters, and process-output ID
+    with physics results.
+
+From here, continue with [Configuration](configuration.md) for all run-card
+choices, [Models and Processes](models-and-processes.md) for UFO/JSON and multiprocess details,
+[Runtime and Selectors](runtime-and-selectors.md) for evaluation, and [Native APIs](native-apis.md) for
+language integration. To compare many validated process/mode combinations and
+turn the measurements into the report, follow the
+[profiling-campaign walkthrough](profiling-campaign-walkthrough.md). Every
+maintained packaged card and script is indexed in the
+[examples guide](https://github.com/MadGraphTeam/MadGraph7/blob/main/pyamplicol/examples/README.md).
+
+<!-- Page hierarchy for the MadGraph7 (Sphinx) documentation. -->
+```{toctree}
+:hidden:
+
+lc-workloads-and-execution-modes
+profiling-campaign-walkthrough
+```
diff --git a/pyamplicol/docs/user/installation.md b/pyamplicol/docs/user/installation.md
new file mode 100644
index 0000000000..b7949800dc
--- /dev/null
+++ b/pyamplicol/docs/user/installation.md
@@ -0,0 +1,302 @@
+---
+title: "Installation"
+nav_order: 2
+has_children: true
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Installation
+
+pyAmpliCol is distributed as a Python package with a Rust-backed runtime. For
+most users, installation is a normal `pip` operation: the published wheel
+already contains the Python extension and the Rusticol native SDK.
+
+> **Recommended path:** use Python 3.11 or newer in a fresh virtual
+> environment and install from PyPI.
+
+## Installation for MadGraph7
+
+pyAmpliCol is developed inside the
+[MadGraph7 repository](https://github.com/MadGraphTeam/MadGraph7) (in
+`pyamplicol/`) and released together with MadGraph7, with the same version
+number. MadGraph7 uses it for processes generated with the `[amplicol]`
+matrix-element backend. Its installer works like the madspace one: by default
+it installs into `pyamplicol/install` inside the MadGraph7 directory and leaves
+the active Python environment untouched.
+
+From the MadGraph7 command line:
+
+```console
+install pyamplicol
+```
+
+or directly:
+
+```console
+python pyamplicol/install.py            # interactive
+python pyamplicol/install.py --bin      # wheel from PyPI (release tarballs)
+python pyamplicol/install.py --source   # build from source
+```
+
+| Option | Meaning |
+| --- | --- |
+| `-y`, `--yes` | No prompts; reuse the previous install mode. |
+| `--bin` | Install the PyPI wheel of this MadGraph7 version. Offered by default in release tarballs on platforms with a wheel. |
+| `--source` | Build from source. |
+| `-j N` | Parallel compilation jobs (`install pyamplicol` passes the `nb_core` option). |
+| `--system` | Install into the active Python environment instead of `pyamplicol/install`. |
+| `--clean` | Delete `pyamplicol/build` and `pyamplicol/install` first. |
+| `--build-models` | Regenerate the prepared models instead of downloading them. |
+
+A source build needs a C/C++ toolchain and the Rust version pinned in
+`rust-toolchain.toml`. When `rustup` is not available, the installer installs
+it into `pyamplicol/build/rust`, without touching `~/.rustup` or `~/.cargo`.
+The Cargo build tree is kept in `pyamplicol/build`, so rebuilds after a source
+change are incremental.
+
+The prepared SM and SM+HEFT models shipped in the package are not stored in
+Git. The installer downloads them from the MadGraph7 release (the release of
+this version, else the latest one) and checks that they match the source tree.
+When they do not, for example after a change to the model compiler, it
+regenerates them locally, which takes one extra build. The same can be done by
+hand with `tools/release/prepared_models_archive.py fetch` or `regenerate`.
+
+After installing, the installer checks that Symbolica accepts pyAmpliCol's
+library key (see [Symbolica licensing](#symbolica-licensing)). MadGraph7 also
+warns when the installed package was built from different sources than the
+ones in `pyamplicol/`; reinstall with `install pyamplicol -y` in that case.
+
+## Install from PyPI
+
+### macOS and Linux
+
+```console
+python3 -m venv .venv
+. .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install pyamplicol
+```
+
+Verify the installation without generating a process:
+
+```console
+python -c 'import pyamplicol; print(pyamplicol.__version__)'
+pyamplicol doctor
+pyamplicol examples list
+```
+
+`pyamplicol doctor` reports the package, Python, runtime, platform, and
+Symbolica environment that pyAmpliCol can see. `examples list` confirms that
+the packaged run cards and data files are available.
+
+## Supported binary-wheel platforms
+
+The current release provides `cp311-abi3` wheels for Python 3.11 and newer on:
+
+| Platform | Architecture | Minimum deployment target |
+| --- | --- | --- |
+| macOS | Apple silicon (`arm64`) | macOS 11 |
+| macOS | Intel (`x86_64`) | macOS 11 |
+| Linux | `x86_64` | manylinux 2.28 |
+
+Wheel users do **not** need a Rust compiler. pyAmpliCol does not depend on
+LHAPDF.
+
+The generated C11, C++17, Fortran 2008, and Rust 2021 examples compile against
+the wheel-owned Rusticol SDK. Install the compiler only for the language you
+intend to use:
+
+- C/C++ compiler for C11 or C++17 consumers;
+- Fortran compiler for Fortran 2008 consumers;
+- Rust compiler for the standalone Rust driver.
+
+See [Native APIs](native-apis.md) for the generated driver workflow.
+
+## Create an editable examples workspace
+
+The examples are package resources. Copy them before editing or running them:
+
+```console
+pyamplicol examples copy ./pyamplicol-examples --force
+cd pyamplicol-examples
+```
+
+Paths inside the supplied TOML cards are relative to the card, so the copied
+workspace can be moved. Keep the environment containing pyAmpliCol activated,
+or invoke its executable by absolute path.
+
+Continue with [Quick Start](quick-start.md).
+
+## Install a tagged source release
+
+Use a tagged snapshot when your platform has no compatible wheel or when you
+need a source build:
+
+```console
+git clone --branch v0.2.1 --depth 1 \
+  https://github.com/MadGraphTeam/MadGraph7.git
+cd MadGraph7/pyamplicol
+python tools/release/prepared_models_archive.py fetch
+python -m pip install .
+```
+
+Inside MadGraph7, `python pyamplicol/install.py --source --system` does the
+same, including the prepared models.
+
+A source build requires:
+
+- Python 3.11 or newer;
+- Rust 1.89 or newer;
+- a C/C++ toolchain;
+- network access to the release-locked Python, Cargo, and SymJIT inputs.
+
+The repository-pinned CI toolchain may be newer than the minimum supported
+Rust version. A Fortran compiler remains optional unless you build a Fortran
+consumer.
+
+To build from the source distribution published on PyPI:
+
+```console
+python -m pip download --no-binary pyamplicol pyamplicol
+tar -xf pyamplicol-*.tar.gz
+cd pyamplicol-*/
+python -m pip install .
+```
+
+## Contributor installation
+
+For development from a checkout, `just dev-install` creates a repository-managed
+environment with published Python dependencies from `pyproject.toml`, including
+Symbolica 3.0.0 and ufo-model-loader 1.0.0, and the release-mode native build with
+published SymJIT 2.26.4. It does not use an editable installation. Building a new
+release wheel requires a clean Git checkpoint and complete release assets;
+published-dependency mode does not relax these publication guards.
+
+```console
+git clone https://github.com/MadGraphTeam/MadGraph7.git
+cd MadGraph7/pyamplicol
+python tools/release/prepared_models_archive.py fetch
+just dev-install
+PYTHON=.venv/bin/python just dev-test
+```
+
+Normal setup uses published PyPI dependencies. For dependency development,
+`--loader-wheel PATH` explicitly selects a local loader wheel; the installer
+does not search for one automatically.
+
+The native build can take several minutes. For a dirty development checkout, add
+`--wheel-directory PATH` to reuse an already-built compatible release wheel,
+or use `--dependencies-only` to install dependencies without building or
+staging pyAmpliCol, leaving the existing native runtime untouched.
+`--no-build` skips both runtime dependency installation and the project
+build/staging; developer tools and explicitly requested optional references
+may still be set up. `just dev-test` includes a fresh release build and therefore
+also requires a clean checkpoint; dirty edits can use focused Python tests
+against the staged compatible native runtime.
+
+On Nix or NixOS:
+
+```console
+nix develop
+just dev-install
+PYTHON=.venv/bin/python just dev-test
+```
+
+The Nix shell supplies Python, Rust, C/C++, Fortran, build libraries, and the
+documentation/PDF tools. `just dev-install` prepares the published-dependency
+environment in `.venv` and builds and stages the project in release mode.
+
+The original AmpliCol and Reference FFT repositories are optional profiling
+inputs and are omitted by default. Request either or both explicitly:
+
+```console
+just dev-install --with-legacy-amplicol --with-reference-fft
+```
+
+Either opt-in also installs the `fft-profiling` Python extra into `.venv`, so
+the profiling driver and PDF renderer are ready without reinstalling the
+project in editable mode.
+
+### Historical candidate mode (opt-in)
+
+The old pinned-source dependency machinery is retained behind `--candidate`,
+but its pinned APIs are incompatible with the current tensor implementation,
+even when the dependencies report the same version numbers. It needs updated,
+coherent upstream pins before use and is not a working current-source setup
+route. Its candidate wheels are non-publishable. Use the published dependency
+lane above; ordinary `just dev-test` uses release mode.
+
+## Symbolica licensing
+
+Generation and Python arbitrary-precision execution use Symbolica. The native
+binary64 runtime embedded in generated artifacts does not import Symbolica.
+pyAmpliCol attempts to register its package key at startup, including in
+spawned workers. A valid package key covers its Symbolica operations without a
+personal license. If registration fails synchronously, the existing personal
+license and restricted-mode paths remain available; restricted mode clamps
+generation to one worker and one Symbolica core.
+
+For details and the built-in personal license-request helpers, see
+[Symbolica and Licensing](symbolica-and-licensing.md).
+
+## Common installation issues
+
+### `No matching distribution found`
+
+Check your Python version and platform:
+
+```console
+python -VV
+python -c 'import platform; print(platform.system(), platform.machine())'
+```
+
+If no wheel matches, use the tagged source installation above.
+
+### `pyamplicol: command not found`
+
+Activate the environment where the package was installed:
+
+```console
+. .venv/bin/activate
+python -m pyamplicol --help
+```
+
+### Generated native driver cannot find `rusticol-config`
+
+The SDK discovery command belongs to the installed wheel. Activate that wheel's
+environment before invoking `make`, or set `RUSTICOL_CONFIG` to its executable:
+
+```console
+export RUSTICOL_CONFIG="$(python -c 'import sys; print(sys.prefix + "/bin/rusticol-config")')"
+make -C artifacts/pp_zjj/API/c run
+```
+
+### A contributor import says the candidate wheel is stale
+
+The local candidate no longer matches the native build inputs. The historical
+candidate pins are also incompatible with the current tensor implementation;
+rebuilding them is not a supported recovery route. Switch the same checkout to
+the default published-dependency environment:
+
+```console
+just dev-install
+```
+
+Do not work around this by mixing an extension from a different checkout.
+
+## Next steps
+
+- [Quick Start](quick-start.md) — generate, inspect, evaluate, and profile a process.
+- [Configuration](configuration.md) — run cards, overrides, color modes, and evaluators.
+- [Models and Processes](models-and-processes.md) — built-in, JSON, UFO, and prepared models.
+- [Troubleshooting](troubleshooting.md) — focused solutions for runtime and generation failures.
+
+The exact build and publication boundary is recorded in
+[Release and Support](release-and-support.md).
+
+<!-- Page hierarchy for the MadGraph7 (Sphinx) documentation. -->
+```{toctree}
+:hidden:
+
+quick-start
+examples-gallery
+```
diff --git a/pyamplicol/docs/user/lc-workloads-and-execution-modes.md b/pyamplicol/docs/user/lc-workloads-and-execution-modes.md
new file mode 100644
index 0000000000..542204dd65
--- /dev/null
+++ b/pyamplicol/docs/user/lc-workloads-and-execution-modes.md
@@ -0,0 +1,668 @@
+---
+title: "LC workloads and execution modes"
+nav_order: 1
+parent: "Get started: a gentle walkthrough"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# LC workloads and execution modes
+
+This page helps with two choices that are easy to mix up:
+
+1. **Which part of the leading-colour result will be evaluated most often?**
+   This determines the LC flow layout for a materialized process output.
+2. **When should pyAmpliCol construct the numerical representation?** This
+   determines the execution mode.
+
+Neither choice changes the requested physics. The LC flow layout reorganizes
+the same leading-colour components, while the execution mode reorganizes when
+the same current construction is prepared. Use [the gentle
+walkthrough](gentle-walkthrough.md) first if “process output,” “flow,” or
+“selector” is unfamiliar.
+
+Here are the few computing terms needed on this page:
+
+- A **process output** is the directory produced by `pyamplicol generate` for
+  one or more requested reactions. It plays roughly the role of a generated
+  standalone process directory in MadGraph: a later program loads it and
+  supplies phase-space points.
+- A **current** is an intermediate off-shell object in the recursive amplitude
+  construction. Reusing a current avoids recomputing the same substructure in
+  many diagrams.
+- A **materialized** output has already written the reusable current-building
+  plan to disk during generation. Recurrence, eager, and compiled outputs are
+  materialized in different forms. OTF instead writes a compact recipe and
+  constructs the requested plan after the output is loaded.
+- The **runtime** is the loaded numerical calculator, and a **selector** is a
+  request for particular helicity or colour-flow components. “Cache” below
+  simply means state retained in the runtime's memory for reuse. An OTF cache
+  can also be saved to a file, but that file supplements the original process
+  output rather than replacing it.
+
+## Two useful slices through an LC result
+
+At one phase-space point, imagine the leading-colour result as a rectangular
+table. Its rows are the physical helicity configurations \(h\), and its columns
+are the physical LC flows \(f\). A runtime request may sum either axis:
+
+| Workload | Quantity requested repeatedly | Typical physics use |
+| --- | --- | --- |
+| One flow, helicity sum | Fix one \(f\), sum every retained \(h\) | A flow-resolved calculation or a colour-flow sampling/integration step |
+| All flows, one helicity | Fix one \(h\), sum every retained \(f\) | A helicity-resolved calculation or repeated evaluations for sampled helicities |
+
+Asking for neither selector sums both axes. Asking for a set of IDs sums the
+selected subset. The two layouts below are performance arrangements for these
+requests; they do not add or remove LC terms when their coverage is complete.
+They optimize different physical outer loops: colour-flow sampling repeatedly
+needs a vertical slice of the table, whereas helicity sampling repeatedly needs
+a horizontal slice. Neither layout is universally faster.
+
+### `topology-replay`: one flow, summed helicities
+
+`topology-replay` is the default. It retains complete physical flow and
+helicity coverage, but arranges the generated construction so that the compact
+topology can be replayed for the requested flow. It is therefore the natural
+layout when each evaluation normally selects one flow and omits the helicity
+selector, meaning “sum all helicities.”
+
+The profiling campaign calls this same workload `non-union-flow`: currents for
+different physical flows are not first merged into one cross-flow plan. The
+public process-output setting remains `topology-replay`.
+
+Use it when:
+
+- a downstream colour sampler asks for one LC flow at a time;
+- the matrix element should remain reusable for another flow later; or
+- the main observable is a flow-resolved contribution summed over spin.
+
+The explicit card setting is:
+
+```toml
+[color]
+accuracy = "lc"
+lc_flow_layout = "topology-replay"
+```
+
+Because it is the default, omitting `lc_flow_layout` has the same effect. A
+direct generation override is:
+
+```console
+pyamplicol generate --card run.toml \
+  --color-accuracy lc \
+  --lc-flow-layout topology-replay
+```
+
+Once generated, select the first physical flow shown by `inspect` and sum all
+helicities by omitting `--helicity`:
+
+```console
+pyamplicol evaluate --card run.toml --color-flow 1
+pyamplicol profile --card run.toml --color-flow 1
+```
+
+CLI flow numbers are **one-based**. A stable flow ID printed by `inspect`, such
+as `flow:...`, may be used in place of `1`.
+
+### `all-flow-union`: all flows, one helicity
+
+`all-flow-union` retains the same complete axes, but builds one shared
+cross-flow recurrence. It is the complementary layout for repeatedly selecting
+one helicity and omitting the flow selector, meaning “sum all physical LC
+flows.”
+
+The profiling campaign calls this workload `union-flow`: it measures the
+cross-flow plan for one selected helicity. The public process-output setting is
+`all-flow-union`.
+
+Use it when:
+
+- a helicity sampler asks for one physical helicity at a time;
+- every LC flow is needed for each selected helicity; or
+- the main observable is a helicity-resolved LC result with colour summed.
+
+Set it in the card:
+
+```toml
+[color]
+accuracy = "lc"
+lc_flow_layout = "all-flow-union"
+```
+
+or override the card during generation:
+
+```console
+pyamplicol generate --card run.toml \
+  --color-accuracy lc \
+  --lc-flow-layout all-flow-union
+```
+
+Then select one stable helicity ID from `inspect` and omit `--color-flow`:
+
+```console
+pyamplicol evaluate --card run.toml \
+  --helicity 'h:-1,+1,-1,+1,-1'
+pyamplicol profile --card run.toml \
+  --helicity 'h:-1,+1,-1,+1,-1'
+```
+
+The displayed helicity length depends on the number of external particles, so
+copy an ID from the process output rather than copying the illustrative ID
+above into an unrelated process.
+
+`all-flow-union` is LC-only. It is available for recurrence, eager, and
+compiled outputs. OTF does not materialize either LC layout: the helicity and
+flow arguments in the first runtime request determine which family of currents
+is constructed in memory.
+
+### Pick the layout from the repeated workload
+
+For a complete materialized output, either layout can still evaluate all
+flows, all helicities, or a supported selected subset. “Optimized for” does not
+mean “only capable of.” It means that the current-building plan written during
+generation is organized around one common loop direction.
+
+| If most calls request... | Start with... |
+| --- | --- |
+| One flow and every helicity | `topology-replay` |
+| Every flow and one helicity | `all-flow-union` |
+| The completely summed LC result | Benchmark both layouts for the real process and batch size |
+| A mixture that changes during a run | Keep complete coverage, then profile the dominant request |
+
+The packaged cards provide a larger-multiplicity comparison without hiding
+the settings:
+
+```console
+pyamplicol examples copy ./pyamplicol-examples
+cd pyamplicol-examples
+pyamplicol generate --card benchmark_z6g_single_flow_helicity_sum.toml
+pyamplicol profile --card benchmark_z6g_single_flow_helicity_sum.toml
+pyamplicol generate --card benchmark_z6g_all_flows_single_helicity.toml
+pyamplicol profile --card benchmark_z6g_all_flows_single_helicity.toml
+```
+
+These are performance examples, so generation can take appreciably longer
+than the small `p p > Z j j` tour.
+
+## Runtime selection in Python and native programs
+
+For recurrence, eager, and compiled modes, the layout is fixed when the process
+output is generated. Python and native programs load that output and select
+physical IDs while evaluating points; they cannot rearrange its stored plan.
+OTF is the exception: its first selected request constructs the corresponding
+family after loading.
+
+### Typed Python
+
+The typed objects in `runtime.physics` avoid copying IDs by hand:
+
+```python
+from pyamplicol import Runtime
+
+runtime = Runtime.load("artifacts/pp_zjj", process="d d~ > g z g")
+flow = runtime.physics.color_flows[0]
+helicity = runtime.physics.helicities[0]
+
+# One physical flow, summed over every helicity.
+flow_values = runtime.evaluate(points, color_flows=(flow,), precision=16)
+
+# One physical helicity, summed over every LC flow.
+helicity_values = runtime.evaluate(points, helicities=(helicity,), precision=16)
+```
+
+Here `points` is a batch with shape
+`[point][external particle][E, px, py, pz]`. The same calls accept stable string
+IDs instead of the typed objects. The global selector arguments are sequences:
+passing one entry selects one component, passing several selects and sums that
+subset, and passing `None` sums the complete retained axis.
+
+Typed generation uses the same schema as a TOML card. For example, this is the
+complete choice of LC layout and execution mode in Python:
+
+```python
+from pyamplicol import Generator, ModelSource
+from pyamplicol.config import resolve_config
+
+settings = resolve_config(
+    {
+        "schema_version": 1,
+        "action": "generate",
+        "color": {
+            "accuracy": "lc",
+            "lc_flow_layout": "all-flow-union",
+        },
+        "evaluator": {"execution_mode": "recurrence"},
+    }
+)
+Generator(settings).generate(
+    "d d~ > g z g",
+    "artifacts/ddbar_to_zgg_union",
+    model=ModelSource.built_in_sm(),
+)
+```
+
+Replace `all-flow-union` by `topology-replay`, or `recurrence` by `compiled`,
+`eager`, or `on-the-fly` as described below. For OTF, omit
+`lc_flow_layout`: no materialized flow layout is used.
+
+### C11
+
+The C ABI uses a null pointer with a zero count for an unselected axis. Given
+stable `flow_id` and `helicity_id` strings, the two LC calls are:
+
+```c
+const char *one_flow[] = {flow_id};
+int status = rusticol_runtime_evaluate_selected_f64(
+    handle, momenta, momentum_count, point_count,
+    NULL, 0, one_flow, 1,
+    NULL, 0, NULL, 0,
+    values, point_count);
+
+const char *one_helicity[] = {helicity_id};
+status = rusticol_runtime_evaluate_selected_f64(
+    handle, momenta, momentum_count, point_count,
+    one_helicity, 1, NULL, 0,
+    NULL, 0, NULL, 0,
+    values, point_count);
+```
+
+The arguments after the global string IDs are optional per-point **zero-based**
+selector-index arrays. Do not supply both the global and per-point form for the
+same axis. End the handle lifetime with `rusticol_runtime_free(handle)`.
+
+### C++17
+
+The C++ wrapper uses empty vectors for an unselected axis:
+
+```cpp
+auto flow_values = runtime.evaluate_selected(
+    momenta, point_count, {}, {flow_id});
+auto helicity_values = runtime.evaluate_selected(
+    momenta, point_count, {helicity_id}, {});
+```
+
+The final two optional arguments, omitted here, are the per-point helicity and
+flow index vectors. The `rusticol::Runtime` destructor releases the handle.
+
+### Fortran 2008
+
+In the Fortran module, omit the optional axis that should be summed:
+
+```fortran
+character(len=128) :: flow_ids(1), helicity_ids(1)
+real(c_double), allocatable :: values(:)
+
+flow_ids(1) = flow_id
+call runtime%evaluate_selected(momenta, point_count, values, &
+    color_ids=flow_ids, ierr=ierr)
+
+helicity_ids(1) = helicity_id
+call runtime%evaluate_selected(momenta, point_count, values, &
+    helicity_ids=helicity_ids, ierr=ierr)
+```
+
+Use `call runtime%close()` when the loaded process is no longer needed.
+
+### Rust 2021
+
+The installed safe wrapper represents omitted axes with `Selectors::all()`:
+
+```rust
+let one_flow = Selectors::all().with_colors([flow_id]);
+let flow_values = runtime.evaluate_selected_f64(
+    &momenta, point_count, &one_flow, None, None,
+)?;
+
+let one_helicity = Selectors::all().with_helicities([helicity_id]);
+let helicity_values = runtime.evaluate_selected_f64(
+    &momenta, point_count, &one_helicity, None, None,
+)?;
+```
+
+The two `None` arguments are the optional per-point zero-based helicity and
+flow index slices. Dropping `runtime` releases the native handle.
+
+Complete load, error-handling, metadata, memory-layout, and compiler examples
+are in the [Native APIs guide](native-apis.md). Stable IDs can be read from that
+metadata or copied from `pyamplicol inspect`; do not infer IDs from their
+position except where the CLI explicitly accepts a one-based ordinal.
+
+## Generation specialization is not runtime selection
+
+Complete coverage gives one process output with reusable runtime selectors. A
+runtime selection chooses among components that are already represented by
+that output and can change from call to call. This is analogous to generating a
+general standalone process once and choosing the desired component during the
+event loop.
+
+Generation specialization instead permanently omits unneeded work while
+constructing a recurrence, eager, or compiled output. It can be valuable when
+a production run will use exactly one known flow or helicity, but that smaller
+output cannot later answer a different selection. The relevant card fields are:
+
+```toml
+[process]
+# Flow-specialized packaged example: u u~ > Z g g g g g g.
+reference_color_order = [2, 4, 5, 6, 7, 8, 9, 1, 3]
+selected_color_sector_ids = [0]
+```
+
+or, in the separate helicity-specialized card:
+
+```toml
+[process]
+# Helicity-specialized packaged example: u u~ > Z g g g g g g.
+selected_source_helicities = { "1" = -1, "2" = 1, "3" = -1, "4" = 1, "5" = -1, "6" = 1, "7" = -1, "8" = 1, "9" = -1 }
+```
+
+These are low-level generation inputs. `selected_color_sector_ids` are
+zero-based internal construction-sector IDs, not the one-based physical flow
+numbers accepted by `--color-flow`. A specialized-away flow or helicity cannot
+be restored by a later runtime call. Use the maintained
+`benchmark_z6g_generation_specialized_*.toml` cards as worked examples instead
+of guessing sector IDs or a reference order.
+
+For reusable compiled and eager outputs, do not combine generation
+specialization with `all-flow-union`; generation rejects that combination.
+Recurrence can encode a valid specialized union construction, but its excluded
+selectors are still absent, so it should be treated as an advanced,
+non-reusable output. `process.max_color_sectors` is incompatible with
+`all-flow-union` in every materialized mode.
+
+OTF takes the opposite approach: it rejects these generation-specialization
+fields and keeps a compact list of all physical selectors. The first warm-up or
+evaluation then constructs only the requested family in memory.
+
+## Four ways to organize the same calculation
+
+The execution mode is selected in `[evaluator]`:
+
+```toml
+[evaluator]
+execution_mode = "recurrence" # or compiled, eager, on-the-fly
+```
+
+or on the generation command line:
+
+```console
+pyamplicol generate --card run.toml --execution-mode recurrence
+```
+
+In the descriptions below, a **kernel** is a small compiled numerical routine
+for a model vertex or current operation. A **dependency graph** records which
+currents must be computed before others; the common abbreviation DAG means a
+directed acyclic graph. A **prepared model** is a reusable package of these
+model-specific kernels, prepared once and shared by several process outputs.
+
+| Mode | What generation stores | What happens after loading | Natural starting point |
+| --- | --- | --- | --- |
+| `recurrence` | An ordered recipe for building and combining currents | The loaded calculator follows that stored recipe for each batch | General-purpose default with a prepared model |
+| `compiled` | Machine-code stages compiled for the complete process graph | Those process-specific stages evaluate each batch | More generation work in exchange for the broadest process-wide optimization |
+| `eager` | A compact list of calls to prepared model kernels | The loaded calculator makes those calls directly | Usually the quickest materialized output to generate and load |
+| `on-the-fly` (OTF) | A compact process recipe, not a ready-to-run selected family | The first selected request constructs one family and retains it in memory | Compact LC output when one selected family dominates many later calls |
+
+The choice changes where work and storage occur, not the meaning of LC, NLC,
+or full colour. Results for the same supported physics selection should agree
+across modes within the stated numerical tolerance.
+
+### Recurrence
+
+Recurrence is the default and the closest stored representation to the
+physical current recursion. Generation writes a compact, checked schedule of
+which currents to build and in what order; numerical evaluation follows it
+through the model's prepared kernels. It supports LC, NLC, and full colour,
+reusable runtime selectors, and optional generation specialization. Large
+point batches are divided into smaller tiles so temporary memory stays bounded.
+
+Choose recurrence first when a prepared model is available and the process
+output should remain broadly reusable.
+
+### Compiled
+
+Compiled mode turns the complete process dependency graph into process-wide
+machine-code stages during generation. That costs more generation work and
+lets the compiler optimize across the broadest view of one process. Unlike
+recurrence, eager, and OTF, it can start directly from a machine-readable
+JSON/UFO model description without a separately prepared kernel package. It
+supports LC, NLC, full colour, reusable selectors when coverage is complete,
+and generation-specialized outputs.
+
+Choose it when process-local compilation is desirable, when comparing a
+specialized baseline, or when no prepared model bundle exists.
+
+### Eager
+
+Eager mode stores compact tables saying which prepared model kernel to call,
+with which inputs, and how to combine its result. It does less process-wide
+compilation and is usually the quickest materialized mode to generate and
+load. Like recurrence and compiled mode, it supports LC, NLC, full colour,
+complete runtime selection, and optional generation specialization.
+
+Choose it when fast materialized generation/load matters and a prepared model
+is available.
+
+### On-the-fly
+
+OTF stores a compact process recipe rather than a ready-to-run schedule for
+every selector. It still needs a prepared model. For LC it can express both
+physical request families: one flow summed over helicities, or all flows summed
+at one helicity. It does not use the `topology-replay`/`all-flow-union`
+generation setting because the first runtime request itself defines the family
+to build.
+
+OTF is native `f64` only (`precision=16`), meaning ordinary IEEE double
+precision. Its practical performance focus is LC with one selected flow and a
+helicity sum. Contracted NLC and full-colour families are available for
+low-multiplicity correctness work, but the initial construction grows rapidly
+and is not intended as a practical high-multiplicity route.
+
+The release acceptance suite exercises catalogued contracted NLC and
+full-colour OTF processes through `n <= 4` against recurrence or MadGraph as
+appropriate. That establishes the low-multiplicity correctness surface; it is
+not a claim that their cold construction is affordable at larger `n`.
+
+## The OTF warm-state lifecycle
+
+OTF moves a potentially expensive operation from generation to the first use
+of a selected family. Treat warm-up as part of job planning, not as a small
+extra numerical sample.
+
+A **family** here means one physical selection together with all currents
+needed to evaluate it repeatedly. For example, “flow 1, summed over all
+helicities” is one family, while “flow 2, summed over all helicities” is
+another. A family is structural: it says what to calculate, not what numerical
+value the matrix element takes at one phase-space point.
+
+### Cold, warm, replaced, and cleared
+
+One loaded OTF runtime follows this lifecycle:
+
+| Action | State afterwards |
+| --- | --- |
+| Load an OTF process | Cold: compact seed loaded, no selected family retained |
+| `warm_up` selection A | A is retained, and exactly one `f64` point has also been evaluated |
+| Evaluate selection A again | Reuses A's structural family; ordinary numerical execution remains |
+| Successfully warm or evaluate selection B | B replaces A; only the most recent selected family is retained |
+| Change model parameters, then evaluate the retained selection | The same structure is retained, and its numerical workspace is refreshed with the latest parameter values before execution |
+| `runtime.save(path)` | The completed retained cache is written to disk; the current handle is unchanged |
+| Load a matching process, then `runtime.load_cache(path)` | The saved family is restored without repeating current construction; numeric workspaces are initialized for the receiving handle |
+| Python `runtime.clear()` | Cold again while the process output and current model parameters remain loaded |
+| Close/free/drop the native handle | In-memory state is released; a later load starts cold unless a saved cache is explicitly restored |
+
+The in-memory family cache is **handle-local and last-family-only**. A handle
+is simply one loaded `Runtime` object (or its C/Fortran/Rust/C++ equivalent).
+A second `pyamplicol` CLI command starts a new process and loads a new handle,
+so it does not inherit warm state from the first command. Keep one Python or
+native runtime alive when same-selection reuse matters, or explicitly
+[save and restore its cache](runtime-and-selectors.md#saving-an-otf-warm-cache)
+between runs. A snapshot retains the current family, not previously evicted
+selections, and does not checkpoint an unfinished cold construction.
+
+For a small complete Python example, including generation and a check that no
+queries are rebuilt, see
+[Saving an OTF warm cache](runtime-and-selectors.md#saving-an-otf-warm-cache).
+The [native examples](native-apis.md#saving-and-restoring-an-otf-cache) show
+`save` and `load_cache` in C, C++, Fortran and Rust. Restore the cache before
+the first evaluation and use the same selectors as when it was saved.
+
+There is no public setting for retaining several OTF families: the most recent
+successful family replaces the previous one. `evaluator.optimization.cores`
+controls how many CPU workers may help with the initial construction; it does
+not change this one-family retention rule or promise that later numerical
+evaluation uses that many threads. `warm_up(..., n_cores=4)` overrides that
+construction setting for one call, without discarding an already-warm family
+or persisting the override in a saved cache. Query traces can be built in
+parallel, with a bounded number of temporary traces; their shared-cache merge
+and family finalization remain serial.
+
+### Explicit warm-up means exactly one binary64 point
+
+Python exposes the structural operation only on OTF runtimes:
+
+```python
+flow = runtime.physics.color_flows[0]
+one_point = (point,)
+
+result = runtime.warm_up(
+    one_point,
+    precision=16,
+    color_flows=(flow,),
+    n_cores=4,
+    progress=progress,
+)
+```
+
+The outer batch must contain exactly one phase-space point, and the precision
+must be `16` (native binary64). This point is genuinely evaluated after the
+family is prepared. Passing a 128-point profiling batch, or asking for higher
+precision, is rejected. A repeated `warm_up` for the same family reuses its
+structure but still performs the required one-point evaluation;
+`result.already_warm` and `result.warmed_query_count` distinguish reuse from a
+cold construction.
+
+The optional progress callback (a function called whenever progress changes)
+receives four stages:
+
+1. process preparation;
+2. query-family construction;
+3. family finalization; and
+4. the first one-point evaluation.
+
+Progress includes completed/total work, elapsed time, worker count, and current
+and peak resident memory (RAM physically held by the process) when the platform
+supplies them. Without a callback or Python progress display, progress
+reporting and its memory sampling are not enabled. The final first-evaluation
+notification occurs after the warmed state has been committed and is not
+cancellable.
+
+The packaged example supplies a coloured terminal progress display and result
+table:
+
+```console
+pyamplicol examples copy ./pyamplicol-examples
+cd ./pyamplicol-examples
+pyamplicol generate --card otf_pp_zjj.toml
+python python/otf_pp_zjj_warm_up.py --n-cores 4
+pyamplicol profile --card otf_pp_zjj.toml
+```
+
+The Python program keeps one runtime loaded across `warm_up` and the timed
+evaluations, so the expensive family construction is not accidentally repeated
+by a second process. The final CLI `profile` command is a separate benchmark
+run and therefore loads its own runtime; it is included to demonstrate the
+standard profiling interface, not to reuse the Python program's in-memory
+family.
+
+### The same warm-up in native languages
+
+All native interfaces use one flattened point in
+`[external particle][E, px, py, pz]` order and stable selector IDs. Omitting an
+axis sums it.
+
+In C, warm one flow and all helicities:
+
+```c
+const char *one_flow[] = {flow_id};
+RusticolWarmUpResult result = {0};
+int status = rusticol_runtime_warm_up_f64_with_cores(
+    handle, point, momentum_count,
+    NULL, 0, one_flow, 1,
+    2, report_progress, user_data, &result);
+```
+
+The callback has this signature and returns nonzero to continue:
+
+```c
+int report_progress(
+    const RusticolWarmUpProgressEvent *event,
+    void *user_data);
+```
+
+The wrappers preserve the same selector order:
+
+```cpp
+auto result = runtime.warm_up(point, {}, {flow_id}, report_progress, 2);
+```
+
+```fortran
+call runtime%warm_up(point, result, color_ids=flow_ids, &
+    progress_callback=report_progress, progress_user_data=user_data, ierr=ierr, n_cores=2)
+```
+
+```rust
+let selectors = Selectors::all().with_colors([flow_id]);
+let result = runtime.warm_up_f64(
+    &point, &selectors, Some(2), Some(&mut report_progress),
+)?;
+```
+
+These examples request up to two construction workers for this call only.
+Use zero in C/C++, omit `n_cores` in Fortran, or pass `None` in Rust to retain
+the process-output default. The original C `rusticol_runtime_warm_up_f64`
+entry point keeps its argument list without `n_cores` and selects that default.
+Explicit Fortran values below one and Rust
+`Some(0)` are rejected. The override neither changes evaluation defaults nor
+invalidates an existing warm family or saved structural cache.
+
+For all flows at one helicity, put one helicity ID in the helicity argument and
+leave the colour argument empty. Passing no callback is valid. C++ releases at
+destruction, Fortran exposes `runtime%close()`, Rust releases on `drop`, and C
+uses `rusticol_runtime_free(handle)`. The native wrappers do not expose
+Python's clear-without-unload convenience; close and reload to return to a
+fully cold native handle.
+
+### Model-parameter updates do not keep stale numbers
+
+`runtime.set_model_parameters(...)` updates the loaded runtime atomically. On
+the next warm-up or evaluation, an already retained OTF family refreshes its
+parameter-dependent workspace before executing. Merely changing a numerical
+model parameter does not require rebuilding the same structural selector
+family, and the old parameter values are not silently reused.
+
+Python `runtime.clear()` discards the OTF family, prepared process state, and
+temporary workspace while keeping the process output and the latest parameter
+values loaded. In recurrence, compiled, and eager modes, `clear()` is a no-op
+because they do not have the corresponding OTF family cache.
+
+## A practical decision sequence
+
+1. Decide the colour accuracy from the physics question: `lc`, `nlc`, or
+   `full`.
+2. For recurrence, eager, or compiled LC output, decide which slice is repeated
+   most often:
+   one-flow/helicity-sum suggests `topology-replay`; all-flow/one-helicity
+   suggests `all-flow-union`.
+3. Start with recurrence for a reusable prepared-model output. Use eager when
+   the time to generate and load a ready-to-run output is the priority, and
+   compiled when process-wide compilation or a raw JSON/UFO model is needed.
+4. Consider OTF when a compact process output and one dominant LC selection
+   outweigh an expensive first construction. Keep the same loaded runtime
+   alive so later calls reuse it.
+5. Keep generation coverage complete until a measured production workload
+   justifies a non-reusable specialized output.
+6. Profile the exact process, selector, parameters, batch size, and target
+   machine used by the application.
+
+See [Configuration](configuration.md#color-accuracy-and-lc-layout) for every card
+field, [Runtime and Selectors](runtime-and-selectors.md) for resolved output and
+per-point selectors, and the [Native APIs](native-apis.md) for complete
+buildable language examples.
diff --git a/pyamplicol/docs/user/models-and-processes.md b/pyamplicol/docs/user/models-and-processes.md
new file mode 100644
index 0000000000..c5c06bc9f0
--- /dev/null
+++ b/pyamplicol/docs/user/models-and-processes.md
@@ -0,0 +1,473 @@
+---
+title: "Models and Processes"
+nav_order: 1
+parent: "Configuration"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Models and Processes
+
+pyAmpliCol separates **model compilation** from **process generation**. A model
+describes particles, parameters, interactions, propagators, Lorentz structures,
+and color data. A process request selects external states and asks pyAmpliCol to
+construct the supported tree amplitudes and executable runtime artifact.
+
+## Model source choices
+
+| Source | Typical use | Executes Python while loading? |
+| --- | --- | --- |
+| `built-in-sm` | Fast Standard Model compatibility workflows and prepared recurrence/eager/OTF kernels | No |
+| `built-in-sm-heft` | Standard Model plus scalar Higgs-effective gluon interactions | No |
+| Serialized JSON | Recommended portable external-model input | No |
+| UFO directory | Trusted development input | **Yes** |
+| Compiled model JSON | Reuse normalized model IR | No |
+| `.pyamplicol-model` | Reuse model IR plus a prepared local-kernel backend | No |
+
+## Built-in Standard Model
+
+```toml
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "u u~ > g g", name = "uubar_gg" }]
+```
+
+Direct CLI:
+
+```console
+pyamplicol generate 'u u~ > g g' artifacts/uubar_gg \
+  --model built-in-sm
+```
+
+The built-in model selects the wheel-owned prepared JIT O2 bundle for default
+recurrence or eager execution. It also retains compatibility aliases that an
+arbitrary external model does not automatically inherit.
+
+## Built-in scalar HEFT model
+
+Select `built-in-sm-heft` for an independent model containing the packaged
+Standard Model plus the scalar Hgg, Hggg, and Hgggg effective interactions:
+
+```console
+pyamplicol model inspect built-in-sm-heft
+pyamplicol generate 'g g > H g g' artifacts/gg_hgg \
+  --model built-in-sm-heft \
+  --coupling-order-policy explicit --max-coupling-order HIG=1 \
+  --color-accuracy full --execution-mode recurrence
+pyamplicol inspect artifacts/gg_hgg
+```
+
+The equivalent packaged run card is `builtin_sm_heft.toml`:
+
+```toml
+[model]
+source = "built-in-sm-heft"
+
+[process]
+entries = [{ expression = "g g > H g g", name = "gg_hgg" }]
+coupling_order_policy = "explicit"
+max_coupling_orders = { HIG = 1 }
+```
+
+The model inherits the packaged SM parameter defaults, including `MH = 125`
+GeV, and has no runtime dependency on a UFO checkout. The effective coupling
+`GH` depends on model parameters (`G`, `vev`, `MH`, and `MT`), not event
+momenta; the momentum factors in the Hgg and Hggg Lorentz tensors are retained.
+Update those external inputs through a runtime parameter card rather than
+treating the derived `GH` as an independent input. The built-in selector uses
+its canonical default restriction and simplification policy.
+
+The wheel-owned portable JIT O2 pack makes `eager`, `recurrence`, and
+`on-the-fly` execution available directly from this selector. Compiled mode
+supports the `jit`, `asm`, and `cpp` evaluator backends. Explicitly prepared
+HEFT bundles can likewise use any of those backends. `builtin_sm_heft`,
+`sm-heft`, and `sm_heft` are accepted as configuration aliases.
+
+The canonical selector is also available through the typed API:
+
+```python
+from pyamplicol import Generator, ModelSource
+
+model = ModelSource.built_in_sm_heft()
+plan = Generator().plan("g g > H g g", model=model)
+print(plan.concrete_processes)
+```
+
+### Trusted external HEFT UFOs
+
+A trusted scalar-HEFT UFO directory can be supplied through the ordinary UFO
+path described below. Inspect it before starting process generation:
+
+```console
+pyamplicol model inspect /path/to/trusted/ScalarHEFT_UFO
+pyamplicol generate 'g g > H g g' artifacts/ufo_heft_hgg \
+  --model /path/to/trusted/ScalarHEFT_UFO \
+  --coupling-order-policy explicit --max-coupling-order HIG=1 \
+  --color-accuracy full --execution-mode compiled --backend jit
+```
+
+UFO modules execute Python while loading. pyAmpliCol recognizes the supported
+scalar one-/two-structure-constant contact families and rejects unsupported
+Lorentz, colour, or form-factor structures during model preflight; arbitrary
+HEFT UFOs are therefore not assumed compatible.
+The separately downloaded FeynRules HEFT UFO used by developer acceptance is
+not packaged, redistributed, or required at runtime. For portable user
+workflows, prefer `built-in-sm-heft`.
+
+## Serialized JSON model
+
+Serialized JSON is the recommended portable external-model form:
+
+```toml
+[model]
+source = "models/json/sm/sm.json"
+restriction = "default"
+```
+
+Copy the packaged JSON/UFO examples into an editable workspace:
+
+```console
+pyamplicol examples copy ./pyamplicol-examples --force
+cd pyamplicol-examples
+pyamplicol model inspect models/json/sm/sm.json
+```
+
+The wheel includes serialized `sm`, `scalars`, and `scalar_gravity` examples.
+They become ordinary filesystem paths under the copied workspace; no code needs
+to know the package installation directory.
+
+If only the packaged models are wanted, the copied
+`python/copy_packaged_models.py` helper can populate a separate empty model
+workspace:
+
+```console
+python python/copy_packaged_models.py ../pyamplicol-models
+```
+
+## Trusted UFO model
+
+A UFO directory uses the same source field:
+
+```toml
+[model]
+source = "/path/to/MyUFO"
+restriction = "default"
+
+[process]
+entries = [{ expression = "u u~ > z g" }]
+
+[generation]
+output = "artifacts/my_ufo_process"
+
+[evaluator]
+execution_mode = "compiled"
+backend = "jit"
+```
+
+> UFO modules are Python code and execute during loading. Only load a UFO model
+> from a source you trust. Serialize it for portable or automated workflows.
+
+In a TOML card, `restriction` is normally a loader name such as `default`,
+`no_widths`, or `none`. With the typed Python API, an explicit restriction file
+may be supplied. Relative typed-API restriction paths are resolved from the
+model directory; card names select the conventional `restrict_<name>.json` or
+`restrict_<name>.dat` file.
+
+## Model commands
+
+Inspect model capabilities and diagnostics:
+
+```console
+pyamplicol model inspect models/json/sm/sm.json --restriction default
+```
+
+Compile portable normalized model IR:
+
+```console
+pyamplicol model compile \
+  models/json/sm/sm.json models/sm.pyAmplicol-model.json \
+  --restriction default
+```
+
+Enumerate concrete processes without generating a process artifact:
+
+```console
+pyamplicol model processes 'p p > Z j j' \
+  --model models/sm.pyAmplicol-model.json \
+  --multiparticle 'p=d,d~,g' \
+  --multiparticle 'j=d,d~,g' \
+  --flavor-scheme 2 --max-quark-lines 2
+```
+
+Unsupported model features are reported during model preflight, before an
+expensive process build.
+
+## Prepared kernel bundles
+
+A file ending in `.pyamplicol-model` contains normalized model IR, exact
+expressions, and one prepared local-kernel backend. It enables recurrence,
+eager, or on-the-fly process generation without compiling each local kernel
+again.
+
+Create a JIT O2 prepared bundle:
+
+```console
+pyamplicol model compile \
+  models/json/sm/sm.json models/ufo-sm-jit-o2.pyamplicol-model \
+  --backend jit --jit-optimization-level 2
+```
+
+Use it for eager generation:
+
+```console
+pyamplicol generate 'd d~ > z g g g' artifacts/ddbar_z3g_eager \
+  --model models/ufo-sm-jit-o2.pyamplicol-model \
+  --execution-mode eager
+```
+
+The three prepared-kernel lanes store different process-level structures:
+eager writes compact invocation tables, recurrence writes compact current
+schedules, and on-the-fly writes a compact process seed from which the selected
+query-local recurrence family is built. Each completed process artifact carries
+the referenced kernels and is standalone; the source prepared bundle is not
+needed at runtime.
+
+At native `f64`, OTF supports LC helicity/flow selection and the singleton
+contracted color axis used by NLC and full colour. Contracted color rejects LC
+flow selectors and is intended as a low-multiplicity correctness capability,
+not a high-multiplicity practicality promise. OTF is binary64-only; eager and
+recurrence can retain the Symbolica-backed exact path when their artifact does.
+
+Prepared JIT state uses the exact-O2 portability contract across supported
+64-bit little-endian macOS and Linux hosts. Process-local compiled JIT O1 and
+O2 are also portable; C++/ASM and explicit O0/O3 JIT remain target-native. See
+[Artifacts and Portability](artifacts-and-portability.md).
+See [Generation Modes and Evaluators](generation-modes-and-evaluators.md) for
+the generation and warm-state trade-offs.
+
+## Typed model API
+
+```python
+from pyamplicol import ModelSource
+
+json_source = ModelSource.from_path("models/json/sm/sm.json")
+ufo_source = ModelSource.from_path(
+    "/path/to/MyUFO",
+    restriction="restrict_default.dat",
+)
+
+compiled = json_source.compile()
+print(compiled.name)
+print(compiled.capabilities.supported_color_accuracies)
+print(compiled.supported)
+
+compiled.write("models/sm.pyAmplicol-model.json")
+compiled.write_parameter_card("data/sm_parameters.json")
+```
+
+`CompiledModel` is an immutable public handle. Stable metadata is available
+through `compiled.info`; compiler-owned expression/tensor IR remains private.
+Compiled models are content-addressed by their source, restriction,
+compiler/schema versions, and normalization/tensor policies.
+
+See [Python API](python-api.md) for generation with a compiled handle.
+
+## Parameter restrictions and runtime cards
+
+Model compilation restrictions determine the model baked into the artifact.
+Mutable external UFO parameters may then be updated at runtime.
+
+A generated parameter card is a flat JSON mapping:
+
+```json
+{
+  "aS": 0.118,
+  "MZ": 91.1876,
+  "complex_parameter": [1.0, 0.0]
+}
+```
+
+Each value is a finite real number or `[real, imaginary]`. Apply it through the
+runtime CLI:
+
+```console
+pyamplicol evaluate artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --model-parameters data/model_parameters.json \
+  --momenta data/pp_zjj_momenta.json
+```
+
+The generated standalone API drivers also accept repeated
+`--set-parameter NAME REAL IMAG` options; those overrides are applied after the
+card and win over its values. The main `pyamplicol evaluate` command uses the
+`--model-parameters` card, while Python callers can use
+`Runtime.set_model_parameter()` or `Runtime.set_model_parameters()`. Updates
+are atomic: unknown, immutable, invalid, or non-finite input rejects the whole
+batch.
+
+## Process expressions
+
+A process has incoming and outgoing particles separated by `>`:
+
+```text
+d d~ > Z g g
+```
+
+Named requests provide stable IDs:
+
+```toml
+[process]
+entries = [
+  { expression = "u u~ > Z g", name = "uubar_Zg" },
+  { expression = "u u~ > Z g g", name = "uubar_Zgg" },
+]
+```
+
+Repetition syntax such as `3*scalar_0` is supported for particle names.
+
+## Multiparticles
+
+```toml
+[process]
+entries = [{ expression = "p p > Z j j" }]
+flavor_scheme = 2
+max_quark_lines = 2
+
+[process.multiparticles]
+p = ["d", "d~", "g"]
+j = ["d", "d~", "g"]
+```
+
+Every model supplies `all`, in declaration order, containing its valid
+propagating physical external states. Ghosts, Goldstones, non-propagating
+records, and auxiliary particles are excluded. User labels merge over defaults;
+an explicit `all` overrides the generic one.
+
+Example enumeration:
+
+```console
+pyamplicol model processes 'p p > all all' \
+  --model built-in-sm --flavor-scheme 1 --max-quark-lines 0
+```
+
+`all` is intentionally broad and may produce a combinatorial expansion for a
+large UFO model. Prefer a focused custom label when possible.
+
+With a UFO or other compiled model (and in `model processes`), expansion
+enumerates each side of `>` as a multiset of particles, so two candidates
+never differ only by an ordering within a side. Process IDs count these
+candidates, so they differ from those of earlier pyAmpliCol versions, which
+counted every ordered candidate: re-read them with `pyamplicol inspect` after
+regenerating. The built-in SM catalogue keeps its own ordered enumeration.
+When generating with a compiled model, candidates that violate an additive
+charge conserved by every model vertex are dropped before the colour and
+amplitude checks. The charges are derived from the vertex list itself: electric charge,
+and quark or lepton numbers per generation whenever the vertices conserve
+them (quark numbers reduce to baryon number with a non-diagonal CKM matrix).
+With the shipped serialized Standard Model (`sm.json`, default
+restriction) this leaves exactly the 385 tree-level subprocesses of
+`p p > j j j j`. `model processes` applies the same filter, but not the
+colour and amplitude checks. The built-in SM keeps its catalogue prefilters (`flavor_scheme`,
+`max_quark_lines`). See
+[Conserved charges in UFO expansion](process-grouping.md#conserved-charges-in-ufo-expansion).
+
+## Permutation-equivalent processes
+
+Multiprocess expansion stores one representative for candidates that differ
+only by reordering within the incoming side and/or within the outgoing side.
+At runtime, this is valid:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --process 'd d~ > g z g'
+```
+
+even when the representative is stored as `d d~ > Z g g`. Rusticol maps the
+public particle order centrally across momenta, particle metadata, helicities,
+LC flow words, selectors, reductions, and resolved values.
+
+Rules:
+
+- incoming particles may only permute with incoming particles;
+- outgoing particles may only permute with outgoing particles;
+- repeated identical particles use deterministic first-unused matching;
+- ambiguous representative matches fail with candidate stable IDs;
+- stable process and explicit alias IDs take precedence over inferred matching.
+
+The current [Born Correlations](../correlators.md) API is an exception: it
+requires the generated external-leg ordering and rejects nonidentity
+permutations. Declare spin and colour legs using that process's one-based
+labels; a declaration used for a process set must be valid for every generated
+member. Ordinary runtime permutation support is unchanged.
+
+## Flavour-blind generation
+
+`--flavor-blind` (`process.flavor_blind`) generates one subprocess per flavour
+class: subprocesses related by a relabelling of flavours with equal spin,
+colour, mass and width and, unless `--no-consider-charge-conjugation`, by
+charge conjugation. For the built-in SM, `p p > j j j j` at `flavor_scheme = 5`
+has 486 subprocesses, 33 flavour classes and 23 classes with charge
+conjugation.
+
+Process IDs are assigned before the classes are formed, so a generated
+representative has the same ID with or without the flag. The representative
+is the canonical member: smaller `|PDG|` first and particles before
+antiparticles, so `d d~ > g g` represents `u u~ > g g` and `d g > d g`
+represents `u~ g > u~ g`. The other members are not generated; they are
+recorded in `process-groups.json` with the leg permutation onto the
+representative. A subprocess with an explicit `ProcessAlias` keeps its own
+artifact entry.
+
+The equality is assumed, not verified. A member gets a warning, logged and
+stored with it, when its relation is not a symmetry of the model vertices
+that the representative is generated with: those within
+`max_coupling_orders` and, under the default `minimal` coupling-order policy,
+within the representative's minimal coupling-order envelope. A relabelling
+must map each such vertex onto one with the same structure and coupling;
+charge conjugation also requires every such vertex to couple fermions
+vector-like. Pure-QCD jet classes therefore pass, while `p p > z j` warns: the
+photon and Z couplings distinguish `u` from `d`, and the chiral Z coupling
+breaks charge conjugation. The check looks at vertices rather than diagrams
+and can warn about a relation that holds for the subprocess at hand.
+[Process Grouping](process-grouping.md) covers flavour classes, warnings and
+the numerical analysis in detail.
+
+## Tree-level support and omitted candidates
+
+Multiparticle expansion may find a syntactically valid process with no
+model-supported tree-level amplitude. pyAmpliCol reports and omits it rather
+than creating a zero or broken artifact. In the primary SM example,
+`g g > Z g g` is loop-induced and therefore omitted.
+
+This is distinct from an unsupported model feature: model preflight rejects
+unsupported theory structures with an actionable diagnostic.
+
+## Current generic UFO support
+
+The generic path covers the proven subset used by shipped tests and examples,
+including:
+
+- scalar, Dirac-like fermion, vector, and proven massless spin-2 paths;
+- SU(3) singlet, fundamental, antifundamental, and adjoint particles;
+- implemented identity, gamma/gamma5, projector, sigma, metric, and momentum
+  Lorentz structures;
+- trilinear kernels, color-singlet contact trees, and proof-gated colored
+  contacts;
+- LC flows and contracted NLC/full SU(3) calculations.
+
+These general model capabilities do not imply LC/NLC or every execution mode
+is available for correlations. The opt-in correlated Born path currently uses
+full SU(3), with singlet, fundamental, antifundamental, and adjoint colour
+representations, and generic compiled amplitudes. Spin replacements apply only
+to four-component vector sources, not fermion or spin-2 sources. Supported
+model preflight remains required; see [Born Correlations](../correlators.md)
+for the narrower execution and API scope.
+
+Preflight rejects Majorana/FNV fermions, spin 3/2, sextets, epsilon color
+tensors, multiple/non-SU(3) color groups, unknown form-factor functions,
+unsupported custom propagator tensors, and unproven general colored
+higher-point contacts. Massive spin-2 is experimental; the packaged massless
+`scalar_gravity` model is a tested path.
+
+The exact, code-derived list of every condition, rejection and diagnostic
+code is kept in [UFO Model Coverage](ufo-model-coverage.md). For the
+validated release boundary, see [Release and Support](release-and-support.md).
diff --git a/pyamplicol/docs/user/native-apis.md b/pyamplicol/docs/user/native-apis.md
new file mode 100644
index 0000000000..03e5879020
--- /dev/null
+++ b/pyamplicol/docs/user/native-apis.md
@@ -0,0 +1,677 @@
+---
+title: "Native APIs"
+nav_order: 2
+parent: "Python API"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Native APIs
+
+Every binary pyAmpliCol wheel includes a target-specific Rusticol SDK and every
+generated process artifact can include a ready-to-build API bundle. Python,
+C11, C++17, Fortran 2008, and Rust 2021 select and perform ordinary total/resolved
+evaluation of the same artifact through the same Rusticol core. C, C++,
+Fortran, and the standalone Rust interface share the public C ABI v1; Python
+uses the wheel's PyO3 binding for these native operations.
+
+For a shared matrix-element provider that can be loaded by MadSpace or linked
+into another executable, see [UMAMI and MadSpace](umami-api.md). Its generated
+`API/umami` Makefile builds `libumami.so` and a linked standalone driver using
+the same installed Rusticol SDK.
+
+`rusticol-config` (also available as `python -m rusticol_config`) only reads SDK
+paths, version and linker metadata. It does not initialize pyAmpliCol or
+Symbolica, so build-system queries can run alongside numerical evaluations.
+
+FFT basis is a generation-time choice, not a native runtime flag. Generation
+with `--color-accuracy full` or Python's `ColorConfig(accuracy="full")`
+automatically tries adaptive adjoint FFT for recurrence/on-the-fly execution,
+falling back to direct for unsupported FFT plans. Certified gluon trees and
+single-insertion HEFT use DDM; quark processes use fundamental chains, while
+uncertified interactions retain trace.
+The saved `fft_basis_selection` reports the actual representation and reason;
+the defaults are automatic contraction and adaptive adjoint selection.
+C, C++, Fortran and Rust load either generated artifact and use their existing
+total/resolved evaluation calls unchanged. Both FFT choices require NLC/full
+colour in recurrence or on-the-fly mode. Automatic LC, compiled/eager, and
+correlated generation use direct contraction and trace basis. Select
+`--color-contraction direct` to opt out; `--fft trace` or `--fft adjoint` forces
+FFT and retains unsupported-plan errors. Forced adjoint FFT rejects correlations.
+
+> **Prerequisites:** install a binary wheel as described in [Installation](installation.md),
+> activate that environment, and generate the primary artifact from
+> [Quick Start](quick-start.md). Native consumers need the corresponding language compiler;
+> they do **not** need a Rust compiler unless the consumer itself is Rust.
+
+## Correlated Born evaluations
+
+The C, C++, Fortran and standalone Rust SDKs expose the same generation-time
+colour catalogue, literal spin replacements and grouped correlated evaluations.
+These additions are on the `correlators` development branch; use its matching
+SDK and library, not an older installed release. Declare the operators with
+`Generator.generate(..., correlators=CorrelatorConfig(...))` or
+`generate ... --correlators FILE.json` as in [Born Correlations](../correlators.md).
+
+Native correlated evaluation is **binary64 only**, like the ordinary native
+SDK. It runs in RustiCol without Python or Symbolica. The separate Python
+correlated executor retains Symbolica-backed double-double and arbitrary
+precision; its `precision=16` path also uses that executor.
+
+LC, NLC and full colour are selected at generation for each inserted colour
+matrix, independently of connection order. The underlying amplitudes remain
+complete and full-colour: ordinary `evaluate`/`evaluate_resolved` still return
+that underlying process, while the correlated `"born"` request returns the
+Born result at the requested correlated accuracy. Spin defaults affect only
+correlated calls, never ordinary totals or resolved components.
+
+### Catalogue, grouped requests and result indices
+
+| Language | Catalogue | Grouped evaluation and component access |
+| --- | --- | --- |
+| C | `rusticol_runtime_color_correlation_count`, `_id`, `_catalogue_json` | `rusticol_runtime_evaluate_correlated_many_f64`; output offset `2*(request*point_count + point)` gives real then imaginary parts |
+| C++ | `runtime.color_correlation_ids()`, `.color_correlation_catalogue_json()` | `runtime.evaluate_correlated_many(...)`; `result(request, point)` is `std::complex<double>` |
+| Fortran | `runtime%color_correlation_ids()`, `%color_correlation_catalogue_json()` | `runtime%evaluate_correlated_many(...)`; `values(point, request)` is `complex(c_double_complex)` |
+| Rust | `runtime.color_correlation_ids()`, `.color_correlation_catalogue_json()` | `runtime.evaluate_correlated_many_f64(...)`; `result.get(request, point)` returns `Option<Complex64>` |
+
+The ID list and full JSON histories follow generation order, including
+`"born"`. C/C++/Rust indices are zero-based; Fortran array indices are
+one-based. Requests follow caller order and points follow input order.
+Different requests share amplitudes and unchanged spin-dependent stages in
+one call. All momenta use `[point][external particle][E,px,py,pz]`.
+
+For example, using the registered `"T13"` dipole from the correlation guide:
+
+```cpp
+// runtime and flattened momenta have already been prepared.
+std::vector<rusticol::SpinCorrelationVector> vectors{
+    {3, {{{0., 0., 1., 0.}}}}};
+std::vector<rusticol::SpinCorrelationVector> physical;
+auto values = runtime.evaluate_correlated_many(momenta, point_count, {
+    {"born", physical}, {"T13", physical}, {"T13", vectors},
+});
+std::complex<double> first_spin_dipole = values(2, 0);
+runtime.set_spin_correlation_vectors(vectors);
+auto inherited = runtime.evaluate_correlated(momenta, point_count, "T13");
+runtime.set_spin_correlation_vectors();  // Clear defaults.
+```
+
+```fortran
+type(rusticol_correlated_request) :: requests(2)
+complex(c_double_complex), allocatable :: values(:, :)
+! Unallocated spin_vectors inherits defaults; allocated size zero is physical.
+requests(1)%color_correlation = "born"
+allocate(requests(1)%spin_vectors(0), requests(2)%spin_vectors(1))
+requests(2)%color_correlation = "T13"
+requests(2)%spin_vectors(1)%leg = 3_c_size_t
+allocate(requests(2)%spin_vectors(1)%components(4, 1))
+requests(2)%spin_vectors(1)%components(:, 1) = cmplx([0,0,1,0], kind=c_double)
+call runtime%evaluate_correlated_many(momenta, point_count, requests, values)
+print *, values(1, 2)  ! First point, spin-correlated dipole.
+```
+
+```rust
+let mut physical = rusticol::CorrelatedRequest::new("born");
+physical.spin_vectors = Some(vec![]);
+let mut spin = rusticol::CorrelatedRequest::new("T13");
+spin.spin_vectors = Some(vec![rusticol::SpinCorrelationVector {
+    leg: 3,
+    components: vec![[rusticol::Complex64::new(0., 0.),
+                      rusticol::Complex64::new(0., 0.),
+                      rusticol::Complex64::new(1., 0.),
+                      rusticol::Complex64::new(0., 0.)]],
+}]);
+let values = runtime.evaluate_correlated_many_f64(
+    &momenta, point_count, &[physical, spin], &[])?;
+let first_spin_dipole = values.get(1, 0).unwrap();
+```
+
+Spin labels are **one-based public external legs** in every language. Supply
+one complex four-vector to broadcast, or one per momentum point. Fortran uses
+`components(4,points)`; C++ and Rust use a vector of complex four-vectors. The
+C representation explicitly interleaves real/imaginary doubles, avoiding any
+assumption about a language's complex-number memory layout. The nonempty set
+of replaced legs must match a declared spin class.
+
+A C request sets `use_default_spin_vectors=1` with zero explicit vectors to
+inherit the setter, or `0` to use its own vectors (zero means physical
+helicities). C++ uses `std::nullopt` versus an explicit vector; Rust uses
+`None` versus `Some(...)`; Fortran uses unallocated versus allocated
+`spin_vectors`. Setters copy their input, and empty setter input clears it.
+Optional helicity IDs select physical helicities of the unreplaced legs.
+
+Complete examples for the mixed adjoint/fundamental N3LO interference are in
+[`examples/native/correlated.c`](https://github.com/MadGraphTeam/pyamplicol/blob/correlators/examples/native/correlated.c),
+[`correlated.cpp`](https://github.com/MadGraphTeam/pyamplicol/blob/correlators/examples/native/correlated.cpp),
+[`correlated.f90`](https://github.com/MadGraphTeam/pyamplicol/blob/correlators/examples/native/correlated.f90), and
+[`correlated.rs`](https://github.com/MadGraphTeam/pyamplicol/blob/correlators/examples/native/correlated.rs).
+The [generation example](../correlators.md#native-correlated-evaluations)
+prepares their input. Build all four with `make -C examples/native correlated`;
+each executable accepts `ARTIFACT PROCESS`. The generated ordinary standalone
+drivers still demonstrate total/resolved evaluation, not correlations.
+
+## What the wheel provides
+
+The installed SDK is owned by the wheel:
+
+```text
+pyamplicol/_sdk/
+  include/rusticol.h
+  include/rusticol.hpp
+  rust/rusticol.rs
+  fortran/rusticol.f90
+  lib/librusticol_capi.a
+  config.py
+  metadata.json
+  link.json
+```
+
+`rusticol-config` validates this SDK and emits correctly quoted paths and
+target-specific link arguments:
+
+```console
+rusticol-config --abi-version
+rusticol-config --version
+rusticol-config --target
+rusticol-config --include-dir
+rusticol-config --library
+rusticol-config --fortran-source
+rusticol-config --rust-source
+rusticol-config --cflags
+rusticol-config --libs
+rusticol-config --rustflags
+rusticol-config --cargo-rustflags
+rusticol-config --json
+```
+
+For a 0.2.0 macOS arm64 release-candidate wheel, the first three commands print:
+
+```text
+1
+0.2.0
+aarch64-apple-darwin
+```
+
+The target naturally differs on Intel macOS and manylinux. The ABI remains 1.
+
+Run these commands from the environment that contains pyAmpliCol:
+
+```console
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install pyamplicol
+rusticol-config --json
+```
+
+If pyAmpliCol was invoked through an explicit path, either activate that
+environment or put its `bin` directory on `PATH`. An explicit
+`RUSTICOL_CONFIG=/path/to/rusticol-config` also works.
+
+In the source workflow, generated drivers below a checkout can find the nearest
+`.venv/bin/rusticol-config` created by `just dev-install`. This is a
+development convenience, not an embedded build-machine path.
+
+`--cflags`, `--libs`, and `--rustflags` emit shell-escaped argument streams.
+By contrast, `--cargo-rustflags` emits the same linker arguments using Cargo's
+unit-separator encoding for `CARGO_ENCODED_RUSTFLAGS`; it is not a shell
+argument stream. `--json` exposes typed arrays when a program should avoid
+parsing either textual form.
+
+## The generated API bundle
+
+With `generation.emit_api_bundle = true` (the default for ordinary
+generation), an artifact contains:
+
+```text
+artifacts/pp_zjj/API/
+  validation_points.dat
+  python/check_standalone.py
+  c/check_standalone.c
+  rust/check_standalone.rs
+  cpp/check_standalone.cpp
+  fortran/check_standalone.f90
+  umami/umami_driver.c
+  umami/metadata.json
+```
+
+The per-language Makefiles place binaries, objects, and Fortran modules in the
+sibling `artifacts/.pyamplicol-api-build/` directory. The integrity-checked
+artifact itself is not modified.
+
+The ordinary language drivers:
+
+- selects a process by stable ID or expression;
+- accepts an optional JSON kinematic point;
+- accepts a UFO-style JSON model-parameter card and direct overrides;
+- evaluates all resolved components and sums them explicitly;
+- compares the explicit sum with the optimized total;
+- prints either a human result or JSON.
+
+The [UMAMI driver](umami-api.md#generate-and-build) instead demonstrates the
+shared-library ABI and its channel/flavour selectors. Its Makefile places
+libraries and executables outside the artifact in the same way.
+
+## One process expression in all five languages
+
+The following commands deliberately request `d d~ > g z g`, even though its
+stored representative uses another outgoing order. Rusticol resolves the
+unique representative and permutes momenta, particles, helicities, color
+flows, reductions, and resolved output metadata consistently.
+
+```console
+python artifacts/pp_zjj/API/python/check_standalone.py \
+  --process 'd d~ > g z g' \
+  --set-parameter aS 0.117 0 \
+  --json
+
+make -C artifacts/pp_zjj/API/c run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --json'
+
+make -C artifacts/pp_zjj/API/rust run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --precision 16 --json'
+
+make -C artifacts/pp_zjj/API/cpp run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --json'
+
+make -C artifacts/pp_zjj/API/fortran run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --json'
+```
+
+No generated alias is required. Case and whitespace are normalized. Incoming
+legs may permute only among incoming legs; outgoing legs may permute only among
+outgoing legs. An ambiguous expression fails with the candidate stable IDs.
+
+The drivers also accept the representative stable ID:
+
+```console
+--process p_p_to_z_j_j_3
+```
+
+After loading, the API exposes the representative stable key and active
+representative-to-public permutation. The public process expression remains
+the ordering requested by the caller.
+
+The same selectors reach processes that a `--flavor-blind` generation listed
+in `process-groups.json` without generating them. Rusticol evaluates the
+representative, multiplies every matrix element by the member's exact factor,
+and, for a charge-conjugated member, reverses the LC flow words (and maps flow
+selectors back). Runtime metadata JSON reports `process_group_member_of`,
+`process_group_factor` (`{"numerator", "denominator"}`), and
+`charge_conjugated` in every language. The C ABI adds one getter:
+
+```c
+uint64_t numerator, denominator;
+int32_t conjugated;
+rusticol_runtime_process_group_relation(runtime, &numerator, &denominator, &conjugated);
+```
+
+Selections other than non-generated members report `1/1` and `0`. See
+[Process-group members](process-selection-and-permutations.md#process-group-members).
+
+## Custom kinematics
+
+All five drivers accept `--kinematics PATH`. The file contains exactly one
+point, either directly as `[external][4]` or inside a singleton batch
+`[[external][4]]`. Its leg order is the order written in `--process`.
+
+For `d d~ > g z g`, `my_sample_point.json` may be:
+
+```json
+[
+  ["250.0", "0", "0", "250.0"],
+  ["250.0", "0", "0", "-250.0"],
+  ["204.406", "204.406", "0", "0"],
+  ["91.188", "0", "0", "0"],
+  ["204.406", "-204.406", "0", "0"]
+]
+```
+
+Each vector is `[E, px, py, pz]`. Components may be JSON numbers or decimal
+strings. Multiple points, booleans, non-finite values, incorrect rank, or an
+incorrect particle count are rejected.
+
+```console
+python artifacts/pp_zjj/API/python/check_standalone.py \
+  --process 'd d~ > g z g' \
+  --kinematics my_sample_point.json \
+  --precision 80
+```
+
+When an artifact retains an exact evaluator, the Python driver keeps decimal
+strings as `Decimal` values at non-f64 precision without an intermediate f64
+round trip. Native drivers convert the same input to f64 and accept only
+precision 16. OTF artifacts are binary64-only through the Python driver too.
+
+When `--kinematics` is omitted, the bundled representative validation point is
+reordered into the public process order automatically.
+
+## Model-parameter cards and overrides
+
+`--model-parameters PATH` reads one flat JSON object. A real external value is
+a finite number; a complex external value is `[real, imaginary]`:
+
+```json
+{
+  "aS": 0.117,
+  "MZ": 91.188,
+  "complex_external_parameter": [1.0, -0.25]
+}
+```
+
+Apply the card, then override one entry:
+
+```console
+make -C artifacts/pp_zjj/API/cpp run \
+  ARGS='--process "d d~ > g z g" \
+        --model-parameters data/model_parameters.json \
+        --set-parameter aS 0.1165 0 --json'
+```
+
+Direct overrides are applied after the card and win atomically. Unknown,
+immutable, non-finite, or otherwise invalid entries reject the complete update.
+
+Compiled, eager, recurrence, and OTF artifacts use this same API surface when
+the bundle is emitted. Eager artifacts carry compact invocation tables,
+recurrence artifacts carry current schedules, and OTF artifacts carry the
+referenced prepared kernels plus a compact process seed. A native caller never
+needs the source `.pyamplicol-model` bundle used during generation.
+
+## OTF warm-up from native APIs
+
+OTF callers can make cold-path work explicit with
+`rusticol_runtime_warm_up_f64_with_cores` in C, `rusticol::Runtime::warm_up` in C++,
+`runtime%warm_up` in Fortran, or `Runtime::warm_up`/`warm_up_f64` in the safe
+Rust wrapper. Each call accepts exactly one flattened binary64 point and
+optional global helicity/color ID subsets, constructs and retains that family,
+and performs its first evaluation.
+
+In C the entry point is:
+
+```c
+const char *one_flow[] = {flow_id};
+RusticolWarmUpResult result = {0};
+int status = rusticol_runtime_warm_up_f64_with_cores(
+    handle, point, momentum_count,
+    NULL, 0, one_flow, 1,
+    2, report_progress, user_data, &result);
+```
+
+The construction-core override is per call: C takes `size_t n_cores` before
+the callback, with zero selecting the process-output default. The original
+`rusticol_runtime_warm_up_f64` keeps its signature without `n_cores` and uses
+that default. C++ takes a
+trailing `std::size_t n_cores = 0`; Fortran accepts optional integer `n_cores`
+and rejects an explicitly supplied value below one; Rust takes
+`Option<usize>` before the callback, with `None` selecting the default and
+`Some(0)` rejected. Positive values bound independent query-trace construction;
+shared-cache merging and family finalization remain serial. The override does
+not change later evaluation defaults or structural cache identity. Generated
+API bundles use these same SDKs; their standalone drivers retain ordinary lazy
+evaluation unless the caller explicitly invokes warm-up.
+
+The optional fixed-layout callback reports stage, completed and total query
+counts, elapsed time, construction workers, and current/peak RSS when the
+platform exposes it. Updates are throttled and callbacks run only on the
+coordinating caller thread. Returning zero from the C/Fortran callback, or
+`false` from the C++/Rust callback, cancels at the next pre-commit boundary;
+the final post-commit first-evaluation notification cannot be cancelled. With no
+observer, ordinary evaluation and warm-up perform no progress-callback or
+memory-sampling work.
+
+The cache belongs to one runtime handle and retains only the last selected
+family. Native wrappers do not expose Python's clear-without-unload
+convenience: close/free/drop and reload to start fully cold. See the
+[OTF lifecycle walkthrough](lc-workloads-and-execution-modes.md#the-otf-warm-state-lifecycle)
+for the corresponding C++, Fortran, and Rust call fragments.
+
+## Saving and restoring an OTF cache
+
+All native APIs can save the completed structural cache of an OTF handle and
+restore it into a handle loaded from the matching process output. The following
+fragments use an OTF output for `g g > g g` at `artifacts/otf_gg_gg`; the
+[Python example](runtime-and-selectors.md#saving-an-otf-warm-cache) gives the
+generation command and explicit four-vector input.
+Here `point` and `next_point` are two flattened binary64 phase-space points,
+each containing 16 components in `[particle][E,px,py,pz]` order. They are arrays
+in C/Fortran and vectors in C++/Rust. The first evaluation constructs the
+recursion; after reopening, the second reuses it at different momenta.
+
+In C, `check(status)` denotes the application's usual error handler: stop on
+a nonzero status and retrieve the message with `rusticol_last_error_message`.
+
+```c
+RusticolRuntimeHandle *runtime = NULL;
+double value;
+check(rusticol_runtime_load("artifacts/otf_gg_gg", NULL, NULL, &runtime));
+check(rusticol_runtime_evaluate_f64(runtime, point, 16, 1, &value, 1));
+check(rusticol_runtime_save(runtime, "gg.otf-cache"));
+check(rusticol_runtime_free(runtime));
+
+check(rusticol_runtime_load("artifacts/otf_gg_gg", NULL, NULL, &runtime));
+check(rusticol_runtime_load_cache(runtime, "gg.otf-cache"));
+check(rusticol_runtime_evaluate_f64(runtime, next_point, 16, 1, &value, 1));
+check(rusticol_runtime_free(runtime));
+```
+
+```cpp
+{
+    rusticol::Runtime runtime("artifacts/otf_gg_gg");
+    runtime.evaluate(point, 1);
+    runtime.save("gg.otf-cache");
+} // The original handle is closed.
+rusticol::Runtime restored("artifacts/otf_gg_gg");
+restored.load_cache("gg.otf-cache");
+auto values = restored.evaluate(next_point, 1);
+```
+
+```fortran
+! Within a procedure using iso_c_binding and the rusticol module:
+type(rusticol_runtime) :: runtime
+real(c_double), allocatable :: values(:)
+call runtime%load("artifacts/otf_gg_gg")
+call runtime%evaluate(point, 1_c_size_t, values)
+call runtime%save("gg.otf-cache")
+call runtime%close()
+
+call runtime%load("artifacts/otf_gg_gg")
+call runtime%load_cache("gg.otf-cache")
+call runtime%evaluate(next_point, 1_c_size_t, values)
+call runtime%close()
+```
+
+```rust
+{
+    let mut runtime = rusticol::Runtime::load("artifacts/otf_gg_gg", None, None)?;
+    runtime.evaluate_f64(&point, 1)?;
+    runtime.save("gg.otf-cache")?;
+} // The original handle is dropped.
+let mut restored = rusticol::Runtime::load("artifacts/otf_gg_gg", None, None)?;
+restored.load_cache("gg.otf-cache")?;
+let values = restored.evaluate_f64(&next_point, 1)?;
+```
+
+The reopening block can run in a later invocation of the application. Unlike
+the one-flow Python example, these examples use the default helicity/colour
+sum; selected evaluations and explicit
+`warm_up(...)` calls can be saved in exactly the same way. Reuse the same
+selectors after loading to benefit from the saved family. Fortran reports
+errors by stopping unless an optional `ierr=status` argument is supplied.
+
+The Rust core's `NativeRuntime` exposes the same `save` and `load_cache`
+methods as the dependency-free Rust SDK. C, C++, Fortran, Rust and Python
+use the same snapshot format, so a compatible runtime can restore a cache
+written through another API. Usual SDK status/exception handling applies.
+
+The snapshot covers the currently retained selection, including LC sums and
+contracted NLC/full-colour direct or FFT families. It stores structural rows
+and reduction mappings, not machine addresses or evaluated currents. Loading
+rebinds the original prepared kernels and allocates numeric workspaces;
+the receiving handle's model parameters remain unchanged. The same saved
+selection can then run at new phase-space points and batch sizes without
+reconstructing its currents. Selecting a different family still follows OTF's
+normal cache-replacement behavior. Non-OTF handles reject these operations.
+See [Runtime and Selectors](runtime-and-selectors.md#saving-an-otf-warm-cache)
+for the Python example and snapshot scope.
+
+## Selector support
+
+The C, C++, Fortran, and Rust total-evaluation entry points accept optional
+zero-based selector arrays with one entry per point. They map to the physical
+helicity and LC-flow order reported by runtime metadata.
+
+- Batch-global string-ID subsets and per-point selectors are mutually
+  exclusive on the same axis.
+- LC supports physical helicity and color-flow selection.
+- NLC/full supports helicity selection; color is contracted.
+- Rusticol groups equal per-point selectors for contiguous execution and
+  restores the original point order on output.
+- Rectangular resolved evaluation remains batch-global.
+
+The selector contract is consistent across compiled, eager, recurrence, and
+OTF artifacts; each lane applies its own internal planner. For OTF, LC exposes
+selectable flow families. NLC and full colour expose one contracted component
+and reject LC-flow selectors. Those contracted families are correctness
+capabilities without a high-multiplicity runtime-practicality promise.
+
+See [Runtime and Selectors](runtime-and-selectors.md) for the same behavior in Python.
+
+## C11
+
+The C header exposes C ABI v1 as an opaque runtime handle, typed status codes,
+metadata getters, parameter updates, warning access, explicit OTF warm-up,
+OTF cache save/restore, total evaluation, and resolved evaluation. Use
+`rusticol-config` rather than hard-coding include or library paths:
+
+```console
+eval "set -- $(rusticol-config --cflags) $(rusticol-config --libs)"
+cc -std=c11 my_runtime.c "$@" -o my_runtime
+```
+
+The shell `eval` converts the command's shell-escaped output into an argument
+vector and preserves SDK paths containing spaces.
+
+## C++17
+
+`rusticol.hpp` is a header-only RAII wrapper over C ABI v1. It exposes metadata,
+parameters, selectors, warnings, one-point OTF warm-up, cache save/restore,
+and total/resolved f64 evaluation:
+
+```cpp
+#include <rusticol.hpp>
+
+#include <iostream>
+#include <vector>
+
+int main() {
+    rusticol::Runtime runtime("artifacts/pp_zjj", "d d~ > g z g");
+    runtime.set_model_parameter("aS", 0.117);
+
+    std::vector<double> momenta = /* point-major [point][particle][4] */;
+    auto total = runtime.evaluate(momenta, 1);
+    auto resolved = runtime.evaluate_resolved(momenta, 1);
+
+    std::cout << total.at(0) << "\n";
+    std::cout << resolved.total().at(0) << "\n";
+}
+```
+
+Compile with:
+
+```console
+eval "set -- $(rusticol-config --cflags) $(rusticol-config --libs)"
+c++ -std=c++17 my_runtime.cpp "$@" -o my_runtime
+```
+
+## Fortran 2008
+
+The wheel ships portable module source rather than a compiler-specific `.mod`
+file:
+
+```console
+RUSTICOL_FORTRAN="$(rusticol-config --fortran-source)"
+eval "set -- $(rusticol-config --libs)"
+gfortran -std=f2008 "$RUSTICOL_FORTRAN" my_runtime.f90 "$@" -o my_runtime
+```
+
+`type(rusticol_runtime)` owns load/close, metadata, parameter, warning,
+one-point OTF warm-up, cache save/restore, and total/resolved f64 methods.
+Resolved Fortran storage is `(color, helicity, point)`, the column-major view
+of the C ABI sequence `(point, helicity, color)`.
+
+## Rust 2021
+
+`rusticol.rs` is a dependency-free safe wrapper over C ABI v1. It owns the
+handle, frees it on drop, exposes typed metadata, selectors, explicit
+one-point OTF warm-up and cache save/restore, and remains bound to its creating
+thread.
+
+The generated driver is compiled directly with `rustc`:
+
+```console
+make -C artifacts/pp_zjj/API/rust check_standalone
+make -C artifacts/pp_zjj/API/rust run \
+  ARGS='--process "d d~ > g z g" --precision 16 --json'
+```
+
+For a hand-written source:
+
+```console
+RUSTICOL_RUST_SOURCE="$(rusticol-config --rust-source)"
+eval "set -- $(rusticol-config --rustflags)"
+RUSTICOL_RUST_SOURCE="$RUSTICOL_RUST_SOURCE" \
+  rustc --edition=2021 my_runtime.rs -o my_runtime "$@"
+```
+
+`rust-script` is optional and is not a pyAmpliCol runtime requirement. The
+generated source includes its minimal Cargo header, so an installed
+`rust-script` can run it directly:
+
+```console
+RUSTICOL_RUST_SOURCE="$(rusticol-config --rust-source)" \
+  CARGO_ENCODED_RUSTFLAGS="$(rusticol-config --cargo-rustflags)" \
+  rust-script artifacts/pp_zjj/API/rust/check_standalone.rs -- \
+  --process 'd d~ > g z g' --precision 16 --json
+```
+
+The generated Makefile exposes the same path as:
+
+```console
+make -C artifacts/pp_zjj/API/rust run-script \
+  ARGS='--process "d d~ > g z g" --precision 16 --json'
+```
+
+## Runtime and precision boundary
+
+All native APIs use the Symbolica-independent f64 runtime:
+
+- direct JIT artifacts load the separate MIT-licensed SymJIT application;
+- eager and recurrence artifacts execute their prepared native schedules;
+- OTF artifacts construct a selected recurrence family from their compact seed
+  and then execute the artifact-local prepared kernels;
+- C++/ASM evaluator artifacts load only on a compatible target and CPU;
+- no native call imports Symbolica or performs a Symbolica license check.
+
+Python is the only standalone driver that can request Symbolica-backed exact
+precision when the artifact retains an exact evaluator. OTF does not retain
+that path and rejects non-f64 precision. See
+[Symbolica and Licensing](symbolica-and-licensing.md).
+The separate Python correlated API is also Symbolica-backed at precision 16;
+the native correlated entry points instead use the independent RustiCol
+binary64 executor described above.
+
+## Common setup failures
+
+| Symptom | Resolution |
+| --- | --- |
+| `ModuleNotFoundError: pyamplicol` | Run the Python driver with the environment's Python or activate that environment. |
+| `rusticol-config: command not found` | Activate the same environment, set `RUSTICOL_CONFIG`, or use the supported checkout-local `.venv` workflow. |
+| `rusticol.h` / `rusticol.hpp` not found | Do not invoke the compiler without the flags emitted by `rusticol-config`. |
+| Empty `RUSTICOL_RUST_SOURCE` or `RUSTICOL_FORTRAN` | Verify `rusticol-config --rust-source` / `--fortran-source` in the active environment. |
+| Target incompatibility | Use a portable JIT artifact (compiled O1/O2, or eager/recurrence/OTF from a prepared JIT O2 pack), or regenerate C++/ASM/O0/O3 on the destination target. |
+
+See [Troubleshooting](troubleshooting.md) for a fuller decision tree.
+
+## Related pages
+
+- [Examples Gallery](examples-gallery.md) — complete copied examples and generated API commands.
+- [Artifacts and Portability](artifacts-and-portability.md) — target rules and trusted-input boundary.
+- [Runtime and Selectors](runtime-and-selectors.md) — process ordering and selector semantics.
+- [Born Correlations](../correlators.md) — opt-in LC/NLC/full-colour correlations in Python and native SDKs.
diff --git a/pyamplicol/docs/user/process-grouping.md b/pyamplicol/docs/user/process-grouping.md
new file mode 100644
index 0000000000..89917daedd
--- /dev/null
+++ b/pyamplicol/docs/user/process-grouping.md
@@ -0,0 +1,803 @@
+---
+title: "Process Grouping"
+nav_order: 3.5
+parent: "Configuration"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Process grouping
+
+A multiprocess request such as `p p > j j j j` expands into many subprocesses,
+but many of them have the same matrix element once their legs are relabelled.
+In the built-in Standard Model with five massless flavours, the 486
+subprocesses of `p p > j j j j` fall into 23 classes. Within a class, all
+subprocesses are related by a permutation of quark flavours, and possibly by
+charge conjugation.
+pyAmpliCol records such relations in the artifact, can skip generating the
+redundant subprocesses, can find relations numerically, and exports the
+skipped subprocesses to UMAMI through their representative.
+
+| Mechanism | What it does | Status of the relation | Generated subprocesses |
+| --- | --- | --- | --- |
+| Every generation | Writes `process-groups.json`; each subprocess is its own group | Identity | All |
+| `--flavor-blind` | Keeps one representative per flavour class, records the others as its members | **Assumed**, with a warning when the model may break it | Representatives only |
+| `--analyze-process-groups numerical`, `pyamplicol group-processes` | Merges generated subprocesses whose resolved components agree up to a rational factor | Tested numerically at three points | All, unchanged |
+| UFO conserved-charge filter | Drops expansion candidates that cannot have a tree amplitude | Exact | Not applicable |
+
+The sections below define the relation, explain how candidate subprocesses
+and leg mappings are found, and describe each mechanism, the file format and
+the UMAMI export. A [worked example](#worked-example-p-p--j-j-j-j) with
+`p p > j j j j` closes the page.
+
+## The relation between two subprocesses
+
+A group has one **representative**, which is always a generated subprocess,
+and any number of **members**. Each member carries a relation to the
+representative:
+
+```text
+ME_member(p[0], ..., p[n-1]) = factor * ME_representative(q[0], ..., q[n-1])
+q[r] = p[permutation[r]]
+```
+
+- Legs are counted from 0 in the public order of the process expression,
+  incoming legs first. Momenta are four-vectors in that order.
+- `permutation[r]` is the member leg that plays the role of representative leg
+  `r`. This is the convention of `ProcessAlias.particle_permutation` and of
+  the UMAMI momentum permutation.
+- A permutation never moves a leg across `>`. It may exchange the two incoming
+  legs, as between `d g > d g` and `g u > u g`.
+- `factor` is a signed rational number whose numerator and denominator are at
+  most 99 in absolute value. `--flavor-blind` records factor 1; a
+  flavour-blind member gets another factor only when its group is later merged
+  numerically. A member that was not generated is evaluated through its
+  representative and must have a positive factor; a map that would give one a
+  non-positive factor is rejected when it is written.
+- `conjugated` marks a relation that includes charge conjugation (see
+  [Charge conjugation](#charge-conjugation)).
+- Helicities follow the legs: the member's helicity on leg `permutation[r]`
+  equals the representative's helicity on leg `r`. This also holds for
+  conjugated relations.
+
+For example, the relation between `u u~ > d u d~ u~` and its representative
+`d d~ > d u d~ u~` has permutation `[0, 1, 3, 2, 5, 4]`:
+
+```text
+ME(u u~ > d u d~ u~)(p0, p1, p2, p3, p4, p5)
+    = ME(d d~ > d u d~ u~)(p0, p1, p3, p2, p5, p4)
+```
+
+Representative leg 2 (the outgoing `d`) takes the momentum of member leg 3
+(the outgoing `u`), so the relabelling is `u <-> d`, applied to every leg.
+
+## Particle types
+
+A relabelling may only exchange particles that the dynamics cannot tell
+apart. pyAmpliCol summarises everything a relabelling must preserve in a
+**particle type**:
+
+| Component | Meaning |
+| --- | --- |
+| spin | `2S+1`: 1 for scalars, 2 for fermions, 3 for vectors |
+| colour | dimension of the SU(3) representation: 1, 3 or 8 (triplet and antitriplet are not distinguished) |
+| mass | the name of the mass parameter, or `ZERO` |
+| width | the name of the width parameter, or `ZERO` |
+| self-conjugate | whether the particle is its own antiparticle |
+
+A particle and its antiparticle share one type. Masses and widths are compared
+by **parameter name**, after compile-time resolution. A parameter that the
+model or its restriction fixes to zero at compile time counts as `ZERO`. Two
+different parameters with equal numerical values are never identified.
+
+Examples:
+
+- Built-in SM: `d`, `u`, `s`, `c` and `b` share one type (massless fermion
+  triplet), and the top quark has its own (`mass_6`, `width_6`).
+- Shipped `sm.json`, default restriction: `d`, `u`, `s` and `c` share one
+  type. The `b` quark (`MB`) and the top (`MT`, `WT`) each have their own.
+- In `sm.json`, the massless leptons `e-` and `mu-` and the three neutrinos all
+  have the same type (massless colour-singlet fermion), while `ta-` (`MTA`)
+  has its own. `W+` and `W-` share a type. The photon and the `Z` do not,
+  because the `Z` mass and width differ from `ZERO`.
+
+The sorted list of particle types of each side is the **coarse key** of a
+subprocess. Only subprocesses with equal coarse keys are ever compared.
+
+## Flavour profiles
+
+Equal types are necessary but not sufficient. The relabelling must also be
+**consistent**: a flavour must be renamed the same way on every leg where it
+appears. pyAmpliCol describes each flavour `f` of a subprocess by its
+**profile**, the four counts
+
+```text
+profile(f) = (initial particles, initial antiparticles,
+              final particles,   final antiparticles)
+```
+
+Self-conjugate particles are counted as particles. Two subprocesses are
+related by a type-preserving flavour relabelling exactly when they have the
+same number of incoming legs and the same multiset of `(type, profile)` pairs.
+
+### Why sorting by PDG code fails
+
+**A related pair that a positional pairing breaks.** Compare
+`u u~ > d u d~ u~` with `d d~ > d u d~ u~`:
+
+| Subprocess | profile of `u` | profile of `d` |
+| --- | --- | --- |
+| `u u~ > d u d~ u~` | (1, 1, 1, 1) | (0, 0, 1, 1) |
+| `d d~ > d u d~ u~` | (0, 0, 1, 1) | (1, 1, 1, 1) |
+
+The `(type, profile)` multisets agree, so the relabelling `u <-> d` relates
+the two. Ordering each side by type, then profile, then flavour, and pairing
+the ordered legs gives the permutation `[0, 1, 3, 2, 5, 4]` shown above.
+Sorting each side by signed PDG code instead pairs the incoming `u` with the
+incoming `d`, but the outgoing `u` with the outgoing `u`. No relabelling does
+that, and evaluating the representative at those momenta computes a different
+function.
+
+**An unrelated pair that a type-only comparison merges.** `d d~ > u u~` and
+`d d~ > d d~` have the same particle types on each side. The first has only
+the s-channel gluon exchange. The second also has the t-channel exchange and
+the interference between the two. Their profiles differ: in `d d~ > u u~`,
+`d` has `(1, 1, 0, 0)` and `u` has `(0, 0, 1, 1)`, while in `d d~ > d d~`, `d`
+has `(1, 1, 1, 1)`. `--flavor-blind` therefore never puts them in one class.
+
+When several flavours of a subprocess share a type and a profile (`s` and `c`
+in `d d~ > s c s~ c~`), each pairing of them is a valid leg mapping. The first
+mapping pairs them by increasing `|PDG|`. The numerical analysis tries at most
+24 such mappings, and at most 24 conjugated ones.
+
+## Charge conjugation
+
+Charge conjugation replaces every particle by its antiparticle, which
+exchanges the particle and antiparticle entries of each profile. With
+`--consider-charge-conjugation` (the default), two subprocesses are also
+related when one matches the conjugate of the other. Examples are
+`u~ g > u~ g g g` and `d g > d g g g`, or `d u~ > d u u~ u~` and
+`d u~ > d d d~ u~`. The relation is stored with `"conjugated": true`, and it
+means:
+
+- helicity values move with the legs **unchanged**: no helicity is flipped;
+- leading-colour (LC) flow words are relabelled and **reversed**, because
+  every quark line runs in the opposite direction.
+
+Charge conjugation with unchanged helicities is a symmetry of vector-like
+interactions such as QCD and QED. It is not a symmetry of chiral couplings
+such as those of the `W` and `Z`. Relations that also need a helicity flip
+(CP-type relations) are not pursued. For example, `u d~ > W+ a` and
+`d u~ > W- a` have equal helicity-summed matrix elements by CP, but their
+helicity components differ, so the numerical analysis never groups them.
+`--flavor-blind` does put them in one class, with a warning that a chiral
+electroweak vertex breaks charge conjugation.
+
+`--no-consider-charge-conjugation` (`process.consider_charge_conjugation =
+false`) disables conjugated relations. The setting only matters together with
+`--flavor-blind` or the numerical analysis.
+
+## Flavour-blind generation
+
+`--flavor-blind` (`process.flavor_blind = true`) states an **assumption**:
+every subprocess in a flavour class has the same matrix element as the class
+representative. A flavour class contains the subprocesses related by a
+type-preserving flavour relabelling and, unless
+`--no-consider-charge-conjugation`, by charge conjugation.
+
+Generation then proceeds as follows:
+
+1. The request is expanded and checked exactly as without the flag.
+   Subprocesses are named at this stage, so a generated subprocess has the
+   same process ID with or without `--flavor-blind`.
+2. The expanded subprocesses are partitioned into flavour classes. The
+   representative is the canonical member: it has the smallest `|PDG|`
+   codes, and particles come before antiparticles. For example, `d d~ > g g`
+   represents `u u~ > g g`, and `d g > d g` represents `u~ g > u~ g`.
+3. Only representatives are generated. Each other member is recorded in
+   `process-groups.json` with factor 1, basis `flavor-blind`,
+   `"generated": false`, and the leg permutation of the first flavour mapping.
+   A non-conjugated mapping is preferred; a conjugated one is used only when
+   no non-conjugated mapping exists.
+
+A subprocess with an explicit `ProcessAlias` keeps its own artifact entry and
+is not folded into a class.
+
+Generation logs the outcome of step 3 in one line, such as
+`Flavor-blind grouping: 486 subprocesses -> 23 generated representatives; 463
+routed members (140 by charge conjugation); 0 relabelling warnings`, and the
+summary table printed at the end has a `process grouping` row; see the
+[worked example](#worked-example-p-p--j-j-j-j).
+
+Members stay selectable. Every SDK (`Runtime.load(..., process=...)`,
+`pyamplicol evaluate --process`, `rusticol_runtime_load` and the C++, Fortran
+and Rust wrappers) resolves a member ID or expression, in any side order,
+through `process-groups.json` to its representative. The representative is
+evaluated at the permuted momenta and every output is multiplied by the
+recorded factor. Helicity and colour-flow IDs are reported in the member's leg
+order; for a conjugated member each LC flow word is reversed, and colour-flow
+selectors given in member IDs are translated back. See
+[Process-group members](process-selection-and-permutations.md#process-group-members).
+
+```python
+from pyamplicol import Runtime
+
+runtime = Runtime.load("artifacts/pp_4j_blind", process="d u~ > d u u~ u~")
+runtime.representative_process_key  # the generated representative
+runtime.process_group_factor  # Fraction(1, 1)
+runtime.charge_conjugated  # True for this member
+values = runtime.evaluate(points)  # points in the member's leg order
+```
+
+The UMAMI export applies this mapping automatically (see
+[UMAMI export](#umami-export-of-flavour-blind-members)).
+
+### Warnings
+
+The assumption is not verified. Generation checks whether each relation is a
+**symmetry of the model vertices that the representative is generated with**.
+A vertex is allowed when its coupling orders fit `max_coupling_orders` and,
+under the default `minimal` coupling-order policy, the representative's
+minimal coupling-order envelope. The check works as follows:
+
+- The relabelling is completed to a permutation of the model's particles.
+  Flavours that the relabelling moves but that occur in only one of the two
+  subprocesses are paired by particle type. Every
+  allowed vertex that the permutation moves must have an allowed image with
+  the same particles in the same order and the same structure and coupling.
+  For compiled (UFO or JSON) models, structure and coupling mean the Lorentz
+  and colour expressions and the resolved coupling. For the built-in SM, they
+  mean the vertex kind and its coupling.
+- A conjugated relation also requires that the conjugate of every allowed
+  vertex is allowed, and that no allowed vertex couples fermions chirally. A
+  Lorentz structure is chiral when exchanging its left- and right-handed
+  projectors changes it, or when it contains `gamma5`. A built-in electroweak
+  current is chiral when its left- and right-handed couplings differ.
+
+A member that fails the check gets a warning, stored as its `warning` field in
+`process-groups.json`. The warnings are also logged once on the
+`pyamplicol.generation` logger, with their count and up to three examples.
+For `pyamplicol generate "p p > z j" OUT --model built-in-sm --flavor-blind`:
+
+```text
+'u u~ > g z' assumed equal to 'd d~ > g z', but relabelling d->u, u->d changes
+the allowed vertex [d a d] (coupling orders: QCD<=1, QED<=1)
+
+'u~ g > u~ z' assumed equal to 'd g > d z', but relabelling d->u, u->d changes
+the allowed vertex [d a d] and charge conjugation is broken by the chiral
+allowed vertex [d z d] (coupling orders: QCD<=1, QED<=1)
+```
+
+The check inspects vertices, not diagrams, and completes the relabelling in
+one fixed way, so it can warn about a relation that holds. In the same run,
+`s s~ > g z` is equal to `d d~ > g z` at tree level, but it still warns:
+`d <-> s` alone moves the allowed `W` vertex `[d w+ u]`, although also
+exchanging `u <-> c` would restore it.
+
+### When to use it
+
+Equal matrix elements within a class are **your responsibility**. The flag is
+safe when the interactions that can appear are blind to the relabelled
+flavours. The typical case is pure-QCD jets with massless quarks under the
+default `minimal` coupling-order policy: `p p > j j`, `p p > j j j` and
+`p p > j j j j` produce no warnings.
+
+It is not safe when photons, `Z` or `W` bosons can couple to the relabelled
+flavours:
+
+- `p p > z j`, `p p > a j`, `p p > e+ e- j`: up- and down-type quarks have
+  different electric charges and `Z` couplings, and the chiral `Z` and `W`
+  couplings break charge conjugation;
+- jets with electroweak orders allowed explicitly, for example
+  `--coupling-order-policy explicit --max-coupling-order QED=2`;
+- requests that mix charged leptons and neutrinos: in massless-lepton models
+  they share a type, so `p p > e+ e-` and `p p > ve ve~` would fall into one
+  class.
+
+To check an assumption, generate the subprocesses in question without
+`--flavor-blind` and run the
+[numerical analysis](#numerical-analysis): it merges exactly the relations
+that hold. For example, with `u u~ > a a` and `d d~ > a a` it finds
+`ME(u u~ > a a) = 16 ME(d d~ > a a)`, the ratio `(Q_u / Q_d)^4` of the
+quark charges. `--flavor-blind` would have assumed factor 1.
+
+## Conserved charges in UFO expansion
+
+When generating with a UFO or other compiled model, a multiparticle request is
+expanded in four steps:
+
+1. Each side of `>` is filled as a **multiset** of particles, so two
+   candidates never differ only by an ordering within one side.
+2. Candidates that violate an **additive charge conserved by every vertex**
+   are dropped.
+3. The colour-readiness probe runs on the remaining candidates.
+4. Tree amplitudes are constructed. With `--flavor-blind`, the flavour classes
+   are formed just before this step.
+
+A conserved charge assigns a rational value to every particle, the opposite
+value to its antiparticle and zero to self-conjugate particles. The values on
+every vertex term sum to zero. The conserved charges are a basis of the
+rational nullspace of the vertex/particle incidence matrix, computed from the
+model's vertex list alone. No quantum numbers are hard-coded.
+
+Every vertex conserves these charges, so every tree graph does too. A
+candidate whose incoming and outgoing totals differ can have no tree
+amplitude, whatever the coupling orders. The filter therefore removes nothing
+that amplitude construction would have kept; it only drops early the
+candidates that would have failed later. A request with no candidate left is
+rejected with an error. For the shipped `sm.json`
+with its default restriction, the basis has nine charges, spanning electric
+charge, one quark number per generation (the CKM matrix is diagonal), one
+lepton number per generation and two ghost numbers. With a non-diagonal CKM
+matrix, the three quark numbers reduce to baryon number.
+
+The built-in SM keeps its own catalogue prefilters (`flavor_scheme`,
+`max_quark_lines`). `pyamplicol model processes` applies the same charge
+filter, but not the colour and amplitude checks. See
+[Models and Processes](models-and-processes.md#multiparticles)
+for the expansion syntax.
+
+## Numerical analysis
+
+`--analyze-process-groups numerical` (`process.analyze_process_groups =
+"numerical"`) runs after the artifact is written. `pyamplicol group-processes`
+runs the same analysis on an existing artifact. The analysis looks for
+relations among the **generated group representatives** and merges the
+groups it relates. Flavour-blind members are not analysed: they have no
+runtime process of their own, and loading one only evaluates its
+representative.
+
+### Procedure
+
+1. Representatives are visited in canonical order. Each one is compared with
+   the earlier representatives that kept their own group and have the same
+   coarse key and the same colour accuracy.
+2. The candidate leg mappings are, in order: the flavour-profile mappings,
+   then (with charge conjugation) the conjugated profile mappings, then a
+   fallback that pairs the legs of each side by type and signed PDG code.
+3. Three **phase-space points** are used, in f64. At each point, the model
+   inputs are varied independently and deterministically. Each mutable
+   parameter of kind `external` or `normalization`, other than a particle
+   mass or width, is multiplied by a factor in `[0.9, 1.1]`. The factor
+   depends only on the parameter name, the point and the seed, so both
+   processes of a comparison always see the same values. Couplings and other
+   derived parameters follow from the varied inputs. Masses and widths are
+   never varied. A derived mass, such as `MW` computed from `Gf`, `aEWM1` and
+   `MZ` in `sm.json`, is read back from the runtime after the variation.
+4. Each point is **on shell** for the resolved masses. It is generated in the
+   centre-of-mass frame with the beams along the z axis (massive beams are
+   supported), at `sqrt(s) = max(1000, 2 * threshold)` in the model's energy
+   unit. The threshold is the larger of the sum of the beam masses and the sum
+   of the final-state masses. The final state is a massive RAMBO point. A
+   `2 > 1` process uses `sqrt(s)` equal to the final mass, and a decay is
+   evaluated at rest.
+5. The representative is evaluated at its points, and the candidate member at
+   the permuted points `p[permutation[r]] = q[r]`. All surviving mappings are
+   evaluated in one batch per point.
+6. Every resolved component is compared through the mapping. At LC, a
+   component is a helicity configuration times a colour flow. Helicity values
+   are permuted. Flow words are relabelled, and reversed for a conjugated
+   mapping; they are compared as sets of open colour lines, or as one adjoint
+   trace up to cyclic rotation. At NLC and full colour, a component is a
+   helicity configuration times a contracted colour component.
+
+A mapping is accepted when one common ratio `member / representative`
+describes every component at all three points:
+
+| Quantity | Rule |
+| --- | --- |
+| zero components | below `1e-12` times the largest component at that point; a zero on one side must be a zero on the other |
+| agreement of a non-zero component | relative `1e-9`, never tighter than `1e-9 * 1e-4` times the largest component |
+| common ratio across points | relative `1e-9` |
+| a point that vanishes entirely on either side | no relation |
+| imaginary part of the ratio | at most `1e-9` of its modulus |
+| recorded factor | rational within `1e-9` relative, numerator and denominator at most 99 in absolute value |
+| `--only-unit-multiplier` | only factor 1 is accepted |
+| seed | `20260917`, recorded in the map |
+
+The search stops at the first earlier group and mapping that pass. The
+subprocess's group is then merged into that group with basis `numerical`.
+
+A representative is **skipped**, and stays its own group, in any of these
+cases:
+
+- it was generated with selected helicities (incomplete helicity coverage);
+- it was generated with selected colour flows or sectors;
+- its masses leave no on-shell phase space;
+- its runtime raises an error.
+
+Each skip is logged as a warning and listed in the summary.
+
+## The `group-processes` command
+
+```console
+pyamplicol group-processes ARTIFACT \
+  [--analyze-process-groups {none,numerical}] \
+  [--only-unit-multiplier] \
+  [--consider-charge-conjugation | --no-consider-charge-conjugation]
+```
+
+| Option | Default | Meaning |
+| --- | --- | --- |
+| `--analyze-process-groups` | `numerical` | `none` only writes the trivial map when the artifact has no `process-groups.json` |
+| `--only-unit-multiplier` | off | accept only new relations with factor 1 |
+| `--[no-]consider-charge-conjugation` | on | also try conjugated mappings |
+
+The `numerical` default belongs to the subcommand, and it takes precedence
+over a `--card` value. Pass `--analyze-process-groups none` or
+`--set process.analyze_process_groups=none` to change it. The schema default
+of `process.analyze_process_groups`, used by generation, remains `none`.
+
+The command reads the stored map, analyses its representatives, merges the
+new relations, and rewrites `process-groups.json` in place. The rewrite runs
+under the lock that also serializes generation and appends. The file's
+payload record in
+`artifact.json` is updated, but the artifact ID is unchanged, because the
+`process-groups` role is not part of the runtime identity. UMAMI files are
+never touched. The command prints a summary; add `--json` for
+machine-readable output. For the five subprocesses of the
+[file example](#the-process-groupsjson-file), generated without analysis:
+
+```console
+pyamplicol group-processes artifacts/grouping_demo --json
+```
+
+```json
+{
+  "analysis": "numerical",
+  "artifact": "/home/user/artifacts/grouping_demo",
+  "groups_after": 2,
+  "groups_before": 5,
+  "new_relations": [
+    {"conjugated": false, "factor": "16", "permutation": [0, 1, 2, 3],
+     "process": "u u~ > a a", "process_id": "u_ubar_to_a_a",
+     "representative": "d_dbar_to_a_a"},
+    {"conjugated": true, "factor": "1", "permutation": [0, 1, 2, 3],
+     "process": "d~ g > d~ g", "process_id": "dbar_g_to_dbar_g",
+     "representative": "d_g_to_d_g"},
+    {"conjugated": false, "factor": "1", "permutation": [1, 0, 2, 3],
+     "process": "g u > u g", "process_id": "g_u_to_u_g",
+     "representative": "d_g_to_d_g"}
+  ],
+  "processes_analysed": 5,
+  "skipped": []
+}
+```
+
+`representative` is the group the subprocess joined. A second run reports
+`groups_before: 2`, `processes_analysed: 2` and no new relation.
+
+When two groups merge, the canonically smaller representative stays. Every
+member of the absorbed group, including its flavour-blind members, is
+re-expressed through the new link:
+
+- factors multiply;
+- permutations compose;
+- the `conjugated` flags combine (two conjugations cancel);
+- the basis becomes the least verified of the two links, in the order
+  `identity`, `numerical`, `flavor-blind`;
+- a warning is kept.
+
+The analysis settings are appended to `analyses` unless an identical entry
+is already there. Rerunning with the same settings is deterministic and adds
+nothing. A later run with relaxed settings, for example without
+`--only-unit-multiplier`, can add relations.
+
+The Python equivalent is `pyamplicol.group_processes` (also available as
+`pyamplicol.api.group_processes`). It takes the same options as keyword
+arguments: `analysis="numerical"`, `only_unit_multiplier=False` and
+`consider_charge_conjugation=True`. See
+[Python API](python-api.md#group-equivalent-subprocesses).
+
+## The `process-groups.json` file
+
+Every generation lane (compiled, eager, recurrence, on-the-fly) writes
+`process-groups.json` at the artifact root, declared in `artifact.json` with
+payload role `process-groups` and media type `application/json`. Without
+`--flavor-blind` and without numerical analysis, each generated subprocess is
+its own group with factor 1. An append keeps the stored groups and adds the
+new subprocesses. A newly generated subprocess whose process ID matches an
+ungenerated flavour-blind member replaces that member and becomes its own
+group.
+
+The example below comes from
+
+```console
+pyamplicol generate "d d~ > a a" artifacts/grouping_demo --model built-in-sm \
+  --process "u u~ > a a" --process "d g > d g" --process "d~ g > d~ g" \
+  --process "g u > u g" --analyze-process-groups numerical
+```
+
+(lists are folded onto one line for readability):
+
+```json
+{
+  "kind": "pyamplicol-process-groups",
+  "schema_version": 1,
+  "analyses": [
+    {"variant": "numerical", "consider_charge_conjugation": true,
+     "only_unit_multiplier": false, "points": 3, "parameter_variation": 0.1,
+     "tolerance": 1e-09, "seed": 20260917}
+  ],
+  "groups": [
+    {
+      "representative": {"process_id": "d_dbar_to_a_a", "process": "d d~ > a a"},
+      "members": [
+        {"process_id": "d_dbar_to_a_a", "process": "d d~ > a a",
+         "pdgs": [1, -1, 22, 22], "initial_count": 2,
+         "factor": {"numerator": 1, "denominator": 1},
+         "permutation": [0, 1, 2, 3], "conjugated": false,
+         "basis": "identity", "generated": true},
+        {"process_id": "u_ubar_to_a_a", "process": "u u~ > a a",
+         "pdgs": [2, -2, 22, 22], "initial_count": 2,
+         "factor": {"numerator": 16, "denominator": 1},
+         "permutation": [0, 1, 2, 3], "conjugated": false,
+         "basis": "numerical", "generated": true}
+      ]
+    },
+    {
+      "representative": {"process_id": "d_g_to_d_g", "process": "d g > d g"},
+      "members": [
+        {"process_id": "d_g_to_d_g", "process": "d g > d g",
+         "pdgs": [1, 21, 1, 21], "initial_count": 2,
+         "factor": {"numerator": 1, "denominator": 1},
+         "permutation": [0, 1, 2, 3], "conjugated": false,
+         "basis": "identity", "generated": true},
+        {"process_id": "dbar_g_to_dbar_g", "process": "d~ g > d~ g",
+         "pdgs": [-1, 21, -1, 21], "initial_count": 2,
+         "factor": {"numerator": 1, "denominator": 1},
+         "permutation": [0, 1, 2, 3], "conjugated": true,
+         "basis": "numerical", "generated": true},
+        {"process_id": "g_u_to_u_g", "process": "g u > u g",
+         "pdgs": [21, 2, 2, 21], "initial_count": 2,
+         "factor": {"numerator": 1, "denominator": 1},
+         "permutation": [1, 0, 2, 3], "conjugated": false,
+         "basis": "numerical", "generated": true}
+      ]
+    }
+  ]
+}
+```
+
+Reading it:
+
+- `u u~ > a a` is 16 times `d d~ > a a` at equal momenta.
+- `d~ g > d~ g` is the charge conjugate of `d g > d g`, leg by leg.
+- `g u > u g` at `(p0, p1, p2, p3)` equals `d g > d g` at
+  `(p1, p0, p2, p3)`: representative leg 0, the incoming quark, takes the
+  momentum of member leg 1.
+- All five subprocesses remain generated: numerical grouping records
+  relations but removes nothing.
+
+| Field | Meaning |
+| --- | --- |
+| `kind`, `schema_version` | `pyamplicol-process-groups`, version 1 |
+| `analyses` | one entry per distinct numerical-analysis setting applied |
+| `groups` | sorted by representative process ID |
+| `representative` | process ID and expression of the group's generated representative |
+| `members` | the representative first (identity relation), then every member |
+| `pdgs`, `initial_count` | signed PDG codes in public leg order, number of incoming legs |
+| `factor` | `ME_member = factor * ME_representative`, as a reduced fraction |
+| `permutation` | `q[r] = p[permutation[r]]`, representative leg to member leg |
+| `conjugated` | the relation includes charge conjugation |
+| `basis` | `identity`, `flavor-blind` (assumed) or `numerical` (tested) |
+| `generated` | whether the member has its own runtime process in the artifact |
+| `warning` | present only for a flavour-blind relation that may not be a model symmetry |
+
+Every subprocess of the artifact appears exactly once as a generated member,
+and a representative is always generated.
+
+`pyamplicol inspect` shows the map in its `Process groups` section (colours
+omitted here). For the five subprocesses above:
+
+```text
+Process groups
+
++--------+--------------+-----------+--------+------------+-------------+-------------+-----------+----------+
+| groups | subprocesses | generated | routed | conjugated | factor != 1 | bases       | analyses  | warnings |
++--------+--------------+-----------+--------+------------+-------------+-------------+-----------+----------+
+|      2 |            5 |         5 |      0 |          1 |           1 | numerical 3 | numerical |        0 |
++--------+--------------+-----------+--------+------------+-------------+-------------+-----------+----------+
+
++---------------------+-------------+----------------+--------+---+-------------+-----------+
+| process ID          | process     | role           | factor | C | permutation | basis     |
++---------------------+-------------+----------------+--------+---+-------------+-----------+
+| d_dbar_to_a_a       | d d~ > a a  | representative |        |   |             |           |
+| `- u_ubar_to_a_a    | u u~ > a a  | generated      |     16 |   |             | numerical |
++---------------------+-------------+----------------+--------+---+-------------+-----------+
+| d_g_to_d_g          | d g > d g   | representative |        |   |             |           |
+| |- g_u_to_u_g       | g u > u g   | generated      |      1 |   | [1 0 2 3]   | numerical |
+| `- dbar_g_to_dbar_g | d~ g > d~ g | generated      |      1 | C |             | numerical |
++---------------------+-------------+----------------+--------+---+-------------+-----------+
+
+C: charge-conjugated relation; factor F: ME = F x ME(representative)
+permutation p: representative leg r takes the momentum of member leg p[r]
+numerical analysis: 3 points, tolerance 1e-09
+```
+
+A `generated` member has its own runtime process, and a `routed` member is
+evaluated through its representative. The permutation column is empty for the
+identity. The factor, `C` and permutation columns appear only when some member
+needs them, and a `note` column with `[n]` references to the warnings printed
+below the table appears when a member has a warning. Maps with more than 80
+subprocesses list each group's members as a grid of process strings instead;
+see [Inspect and select a process](command-line-interface.md#inspect-and-select-a-process).
+An artifact without grouping prints one line, `Process groups: none; each of
+the N processes is its own group`.
+
+The summary printed by this `generate` command reports the same map in its
+`process grouping` row, `5 subprocesses -> 2 groups: 5 generated, 0 routed`,
+followed by `3 numerical relations (1 charge-conjugated, 1 with factor != 1);
+0 warnings` and the analysis settings. Its `Generated Processes` table lists
+`u u~ > a a` as `member of d_dbar_to_a_a (x16)` and `d~ g > d~ g` as
+`member of d_g_to_d_g (C)`.
+
+## UMAMI export of flavour-blind members
+
+The UMAMI provider exports every flavour-blind member, although it has no
+runtime process:
+
+- A member adds flavour selectors that evaluate its **representative's
+  runtime**, with no `runtime_processes` row of its own. Its
+  `members[].runtime` names the representative.
+- The momentum permutation is the composition of the recorded relation with
+  the runtime ordering. It may exchange the incoming legs, but the selector
+  keeps the member's physical incoming PDG codes for the PDF weights, so this
+  is not a beam-exchange assumption.
+- A conjugated member uses the representative's colour flows reversed. Its
+  LHE colour tags and helicity labels are those of the member.
+- The member's factor (1 for flavour-blind relations) multiplies the runtime
+  factor.
+- Every provider exporting such members records an additional
+  `grouping.assumptions` entry:
+
+  ```text
+  flavor-blind matrix elements: ungenerated process-group members are
+  evaluated through their relabelled representative (assumed, not proven)
+  ```
+
+A member whose relabelling moves unequal masses between legs, or maps a
+restricted helicity selection onto a different set, is exported by a separate
+provider that loads the representative's runtime. Warnings stay in
+`process-groups.json`; they are not copied into the UMAMI metadata.
+Numerically grouped subprocesses are generated and keep their ordinary
+export; `group-processes` does not change the UMAMI files. See
+[UMAMI and MadSpace](umami-api.md#flavour-blind-members) for the selector
+layout.
+
+## Worked example: `p p > j j j j`
+
+Preview the flavour classes with a dry run, which prints the subprocesses
+that would be generated:
+
+```console
+pyamplicol generate "p p > j j j j" artifacts/pp_4j_blind \
+  --model built-in-sm --flavor-blind --dry-run
+```
+
+With the built-in SM at the default `flavor_scheme = 5`, the request has:
+
+| Setting | Generated subprocesses |
+| --- | --- |
+| no `--flavor-blind` | 486 |
+| `--flavor-blind --no-consider-charge-conjugation` | 33 |
+| `--flavor-blind` | 23 |
+
+Charge conjugation merges, for example, the `d~ d~` and `d~ g` initial
+states into the `d d` and `d g` classes, and `d u~ > d u u~ u~` into the
+class of `d u~ > d d d~ u~`. Generate the artifact and analyse the
+representatives in one step:
+
+```console
+pyamplicol generate "p p > j j j j" artifacts/pp_4j_blind \
+  --model built-in-sm --flavor-blind --analyze-process-groups numerical
+```
+
+Before generating, the command logs the flavour classes it found:
+
+```text
+INFO pyamplicol.generation: Flavor-blind grouping: 486 subprocesses -> 23 generated representatives; 463 routed members (140 by charge conjugation); 0 relabelling warnings
+```
+
+and its final summary reads the written map back (abridged, colours omitted):
+
+```text
+| processes              | 23 requests                                                                              |
+| process grouping       | 486 subprocesses -> 23 groups: 23 generated, 463 routed                                  |
+|                        | 463 flavor-blind relations (140 charge-conjugated); 0 warnings                           |
+|                        | numerical analysis: 3 points, tolerance 1e-09                                            |
+...
++--------------------+------------------+-----------------------------+
+| name               | process          | group                       |
++--------------------+------------------+-----------------------------+
+| p_p_to_j_j_j_j_1   | d d > d d d d~   | 10 subprocesses (9 routed)  |
+| p_p_to_j_j_j_j_2   | d d > d d u u~   | 40 subprocesses (39 routed) |
+...
+| p_p_to_j_j_j_j_486 | g g > g g g g    |                             |
++--------------------+------------------+-----------------------------+
+```
+
+The minimal coupling-order envelope is pure QCD, so no relation warns. The
+artifact contains 23 runtime processes, and `process-groups.json` has 23
+groups covering all 486 subprocesses: 463 flavour-blind members, 140 of them
+conjugated. The numerical analysis finds no further relation among the 23
+representatives. Some of the classes:
+
+| Representative | Process ID | Class size | Conjugated members | Incoming legs exchanged |
+| --- | --- | --- | --- | --- |
+| `d d~ > d u d~ u~` | `p_p_to_j_j_j_j_32` | 20 | 0 | 0 |
+| `d u > d u s s~` | `p_p_to_j_j_j_j_9` | 60 | 30 | 0 |
+| `d u~ > d d d~ u~` | `p_p_to_j_j_j_j_52` | 40 | 20 | 20 |
+| `d g > d g g g` | `p_p_to_j_j_j_j_81` | 10 | 5 | 0 |
+| `d d~ > g g g g` | `p_p_to_j_j_j_j_51` | 5 | 0 | 0 |
+| `g g > g g g g` | `p_p_to_j_j_j_j_486` | 1 | 0 | 0 |
+
+Three members illustrate the relations:
+
+| Member | Representative | `permutation` | `conjugated` |
+| --- | --- | --- | --- |
+| `u u~ > d u d~ u~` | `d d~ > d u d~ u~` | `[0, 1, 3, 2, 5, 4]` | false |
+| `d u~ > d u u~ u~` | `d u~ > d d d~ u~` | `[1, 0, 4, 5, 3, 2]` | true |
+| `u~ g > u~ g g g` | `d g > d g g g` | `[0, 1, 2, 3, 4, 5]` | true |
+
+The second relation exchanges the incoming legs and conjugates. Its
+representative leg 0, the incoming `d`, takes the momentum of member leg 1,
+the incoming `u~`, which conjugation and the relabelling `u <-> d` turn into a
+`d`. Loaded by its own expression, each of these three members agrees with a
+separately generated copy of the same subprocess to about `1e-14`.
+
+`pyamplicol inspect artifacts/pp_4j_blind` summarises the 23 classes and lists
+the members of each, grouped into non-conjugated and conjugated blocks, with
+`g g > g g g g` listed as `ungrouped`.
+`--process p_p_to_j_j_j_j_52` lists one class member by member, with
+permutations, and `--process 'd u~ > d u u~ u~' --full-physics` adds a
+`Process Group` table with that member's representative, factor, conjugation
+and permutation.
+
+The UMAMI provider in `API/umami` has 23 `runtime_processes` rows. Its
+`members` cover all 486 subprocess IDs, and its `grouping.assumptions` list
+contains the flavour-blind entry.
+
+To check the assumption itself, generate all 486 subprocesses without
+`--flavor-blind` and let the numerical analysis group them:
+
+```console
+pyamplicol generate "p p > j j j j" artifacts/pp_4j \
+  --model built-in-sm --analyze-process-groups numerical
+```
+
+This generates all 486 runtime processes, so it takes much longer. The
+analysis then finds the same 23 groups, with the same representatives,
+permutations and conjugation flags, all with factor 1, now with basis
+`numerical`.
+
+## Limitations
+
+- `--flavor-blind` is an assumption. Its warning comes from a per-vertex check
+  and can be raised for a relation that holds (see [Warnings](#warnings)).
+- A flavour-blind representative that later turns out to have no tree-level
+  amplitude is skipped as unsupported, and its members disappear with it. The
+  skip warning gives only their number, not their names.
+- A routed member uses its representative's model parameters, so its value
+  follows the representative's flavours. Changing a parameter that
+  distinguishes their flavours (a mass, width or Yukawa coupling) invalidates
+  the relation; generate the process explicitly if it must follow independent
+  parameter values.
+- Correlated evaluation through a member is supported only when the composed
+  permutation (relation and requested order) is the identity and the relation
+  is not conjugated; the factor is then applied. Other selections fail with an
+  error naming the member and its representative.
+- For conjugated members with several open quark lines, the reversed LC flow
+  IDs may list the open lines in another order than a separate generation of
+  the same subprocess would; values and flow selection agree.
+- The numerical analysis is a test at three f64 points, not a proof: two
+  matrix elements that agree at those points within `1e-9` are grouped.
+- The search covers only relations with a rational factor whose numerator
+  and denominator are at most 99, a leg permutation within each side, and
+  optional charge conjugation with unchanged helicities. It does not cover
+  CP-type relations or crossing between the initial and final states.
+- Subprocesses generated with selected helicities or colour flows are never
+  grouped numerically.
+- Relations are only searched between subprocesses with equal particle types
+  per side, so two different mass parameters with equal values are never
+  identified.
+- Numerical relations do not shrink the artifact or the UMAMI export: both
+  subprocesses stay generated.
diff --git a/pyamplicol/docs/user/process-selection-and-permutations.md b/pyamplicol/docs/user/process-selection-and-permutations.md
new file mode 100644
index 0000000000..6739b2a191
--- /dev/null
+++ b/pyamplicol/docs/user/process-selection-and-permutations.md
@@ -0,0 +1,342 @@
+---
+title: "Process Selection and Permutations"
+nav_order: 3
+parent: "Configuration"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Process Selection and Permutations
+
+pyAmpliCol separates two related operations:
+
+- **generation requests** decide which process representatives an artifact
+  contains;
+- **runtime selection** chooses one representative and the public particle
+  order in which the caller wants to use it.
+
+This lets one evaluator serve equivalent incoming and outgoing orderings
+without asking users to memorize generated alias names.
+
+## A representative is not an output directory
+
+An artifact may contain one process or many. Each retained concrete process
+has a stable ID, such as `p_p_to_z_j_j_3`; the artifact itself is still loaded
+from one directory:
+
+```console
+pyamplicol inspect artifacts/pp_zjj
+pyamplicol inspect artifacts/pp_zjj --process p_p_to_z_j_j_3
+```
+
+The same process can be selected with a readable expression:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --process 'd d~ > g z g'
+```
+
+Stable process IDs are selectors, not paths below `artifacts/pp_zjj`.
+
+## How a selector is resolved
+
+Rusticol applies a deterministic precedence order:
+
+1. stable process ID;
+2. explicit alias ID;
+3. exact stored process expression;
+4. exact explicit-alias expression;
+5. one unique permutation-equivalent expression;
+6. a process-group member that was not generated: its stable ID, its exact
+   expression, then one unique permutation-equivalent expression (see
+   [Process-group members](#process-group-members)).
+
+Case and whitespace in a process expression are normalized. At the
+permutation steps, the incoming and outgoing particle multisets are matched
+independently.
+
+For example, an artifact may store the representative ordering
+`d d~ > Z g g`, while the caller requests:
+
+```text
+d d~ > g z g
+```
+
+The outgoing multisets are equal, so the request selects the same evaluator and
+exposes the requested public ordering. No pre-generated alias is required.
+
+If more than one stored representative could match, selection fails and lists
+the candidate stable IDs. pyAmpliCol never silently picks an ambiguous process.
+
+## The side-preserving rule
+
+Permutations are allowed **within** each side of `>`:
+
+```text
+d d~ > Z g g   ->   d~ d > g Z g       allowed
+```
+
+A leg may never cross the process boundary:
+
+```text
+d d~ > Z g g   ->   d Z > d~ g g       not equivalent
+```
+
+Repeated identical particles are matched by a deterministic first-unused
+rule. This makes the mapping reproducible even when several `g` legs are
+indistinguishable by particle name.
+
+## What is remapped
+
+The selected ordering is not cosmetic. One representative-to-public
+permutation is applied centrally to:
+
+- input momenta and external-particle PDGs;
+- external-particle metadata and momentum slots;
+- helicity vectors, IDs, representatives, and selectors;
+- LC color-flow words, IDs, replay labels, and selectors;
+- reduction groups and resolved-output metadata;
+- bundled validation kinematics;
+- compiled, eager, recurrence, and on-the-fly f64 execution;
+- Python exact execution when retained expressions support it.
+
+Consequently, all public inputs and outputs describe the ordering written in
+the selector:
+
+```python
+from pyamplicol import Runtime
+
+runtime = Runtime.load("artifacts/pp_zjj", process="d d~ > g z g")
+print(runtime.physics.process)  # d d~ > g Z g
+print([particle.name for particle in runtime.physics.external_particles])
+```
+
+The process key continues to identify the representative evaluator. Generic
+permutation metadata records the active public mapping; explicit aliases also
+retain their alias identity.
+
+## Process-group members
+
+An artifact generated with `--flavor-blind` stores one representative per
+flavour class and lists the other processes of each class in its
+`process-groups.json` payload. Every listed process stays selectable by its
+stable ID or expression through `Runtime.load`, `pyamplicol evaluate`, and the
+C, C++, Fortran, and Rust APIs, even though it has no evaluator of its own.
+
+Rusticol reads `process-groups.json` only when no stored process ID, alias,
+or stored expression (exact or side-permuted) matches the selector, and
+verifies its declared size and SHA-256 first. A member relation states
+
+```text
+ME_member(p) = factor * ME_representative(q),   q[r] = p[permutation[r]]
+```
+
+with an exact rational `factor`. Selecting a member, possibly in yet another
+side order, therefore composes two permutations (requested order from member
+order, member order from representative order) and evaluates the
+representative with:
+
+- the composed permutation applied to momenta, helicities, LC flows,
+  reductions, and resolved metadata, exactly as for any permutation;
+- the member's own flavours, particle names, process ID, and expression in
+  `runtime.physics`;
+- every matrix element (totals, resolved helicity/flow components, selected
+  subsets, profiles, and exact `precision != 16` results) multiplied by
+  `factor`;
+- for a charge-conjugated member (`conjugated: true`), every LC color-flow
+  word mapped through the permutation and then reversed. Flow IDs follow the
+  reversed words, and color-flow selectors given in the member's labels map
+  back to the representative's. NLC/full contracted color is unaffected.
+  With several open quark lines, a reversed word may list the lines in
+  another order than a separate generation of the member would, as with any
+  permutation; read flow IDs from the loaded runtime.
+
+For instance, an artifact storing `u g > u g` answers `u~ g > u~ g`; its flow
+`flow:1,4,2,3` is the representative's `flow:3,2,4,1`:
+
+```python
+runtime = Runtime.load("artifacts/qg", process="u~ g > u~ g")
+print(runtime.representative_process_key)  # u_g_to_u_g
+print(runtime.external_permutation)  # composed representative -> public
+print(runtime.process_group_factor)  # Fraction(1, 1)
+print(runtime.charge_conjugated)  # True
+```
+
+Native APIs report the same relation in their runtime metadata JSON as
+`process_group_member_of`, `process_group_factor`, and `charge_conjugated`;
+the C API also provides `rusticol_runtime_process_group_relation`. A
+selection that is not a non-generated member reports factor `1/1`, no
+conjugation, and keeps the unchanged fast path. To list a member's helicity
+and flow IDs, run `pyamplicol inspect ARTIFACT --process MEMBER
+--full-physics`; the compact inventory lists generated processes only.
+
+A member uses its representative's model parameters, and its factor was
+established at generation time: changing a parameter that distinguishes the
+member's flavours from the representative's (a mass, width, or Yukawa
+coupling, for example) invalidates the relation. Generate such a process
+explicitly when it must follow independent parameter values.
+
+Born correlations through a member are available only when the composed
+permutation is the identity and the relation is not charge-conjugated; the
+factor is then applied. Other cases fail with a compatibility error naming
+the member and its representative: generate that process explicitly.
+
+## Kinematics follow the requested order
+
+Momenta always have shape:
+
+```text
+[point][external particle][E, px, py, pz]
+```
+
+The external-particle dimension follows `runtime.physics.external_particles`,
+which in turn follows the selected expression. For `d d~ > g z g`, a custom
+five-particle point is therefore ordered as:
+
+```json
+[
+  ["250.0", "0", "0", "250.0"],
+  ["250.0", "0", "0", "-250.0"],
+  ["204.406", "204.406", "0", "0"],
+  ["91.188", "0", "0", "0"],
+  ["204.406", "-204.406", "0", "0"]
+]
+```
+
+The first two rows are the incoming `d` and `d~`; the remaining rows are the
+outgoing `g`, `z`, and `g` in exactly that order.
+
+Generated standalone drivers accept the file with `--kinematics`:
+
+```console
+python artifacts/pp_zjj/API/python/check_standalone.py \
+  --process 'd d~ > g z g' \
+  --kinematics my_sample_point.json \
+  --precision 80
+```
+
+The file may contain one point as `[external][4]` or a singleton batch as
+`[[external][4]]`. Components may be JSON numbers or decimal strings. The
+Python exact path preserves decimal strings without an intermediate f64
+conversion; native drivers parse the same representation as f64. Booleans,
+non-finite values, multiple points, and incorrect shapes are rejected.
+
+When `--kinematics` is omitted, the bundled representative validation point is
+automatically reordered to the requested public expression.
+
+## Helicity and color selectors follow the requested order
+
+Always obtain stable IDs after selecting the desired process ordering:
+
+```python
+runtime = Runtime.load("artifacts/pp_zjj", process="d d~ > g z g")
+
+helicity = runtime.physics.helicity_ids[0]
+flow = runtime.physics.color_flow_ids[0]
+value = runtime.evaluate(
+    momenta,
+    helicities=[helicity],
+    color_flows=[flow],
+)
+```
+
+A helicity ID encodes values in the public external order. An LC flow word and
+its stable ID likewise use public leg labels. Reduction metadata points to the
+remapped public IDs, so `evaluate_resolved()` remains consistent with
+`evaluate()` after any permitted permutation.
+
+Color-flow selection is available only at LC. NLC and full-color artifacts
+have a contracted output axis and accept helicity selectors only. See
+[Runtime and Selectors](runtime-and-selectors.md).
+
+## Generation-time multiprocess expansion
+
+One request may expand through multiparticle labels:
+
+```toml
+[process]
+entries = [{ expression = "p p > Z j j" }]
+flavor_scheme = 2
+max_quark_lines = 2
+
+[process.multiparticles]
+p = ["d", "d~", "g"]
+j = ["d", "d~", "g"]
+```
+
+For the shipped serialized Standard Model this request produces eight
+candidates: each side is enumerated as a multiset, one candidate per
+incoming/outgoing permutation class, and candidates violating a charge
+conserved by every model vertex are dropped. Seven candidates have tree-level
+amplitudes and are stored. The remaining class, `g g > Z g g`, is loop-induced
+and is reported as unsupported at tree level rather than emitted as a zero
+process.
+
+Those seven evaluators cover all 18 ordered tree-level channels, including
+public orderings not stored as explicit aliases.
+
+With `--flavor-blind`, expansion keeps one representative per flavour class
+as well (see
+[Flavour-blind generation](models-and-processes.md#flavour-blind-generation)).
+The other members are not stored as processes, but they stay selectable:
+runtime selection routes a member ID or expression through
+`process-groups.json` to its representative (see
+[Process-group members](#process-group-members)), and UMAMI exports apply the
+same mapping.
+
+## The model-generic `all` label
+
+Every model supplies `all` as its declaration-ordered valid physical external
+states. It includes propagating, physical-spin particles and excludes ghosts,
+Goldstones, non-propagating records, and auxiliary states.
+
+User definitions merge over model defaults, so defining `p` or `j` leaves
+`all` available. Defining `all` explicitly replaces the default.
+
+Inspect a bounded built-in expansion before generating it:
+
+```console
+pyamplicol model processes "p p > all all" \
+  --model built-in-sm \
+  --flavor-scheme 1 \
+  --max-quark-lines 0
+```
+
+`all` products can expand combinatorially, especially for large UFO models.
+Use a narrower custom label for routine production work.
+
+## Explicit process sets and aliases in Python
+
+When stable names are useful, construct a `ProcessSet`:
+
+```python
+from pyamplicol import ProcessRequest, ProcessSet
+
+processes = ProcessSet(
+    requests=(
+        ProcessRequest.parse("u u~ > Z g", name="uubar_Zg"),
+        ProcessRequest.parse("u u~ > Z g g", name="uubar_Zgg"),
+    )
+)
+```
+
+Explicit `ProcessAlias` records remain available for named public interfaces,
+but ordinary callers do not need to enumerate every incoming or outgoing
+ordering. Runtime inference uses the same side-preserving mapping.
+
+## Failure guide
+
+| Message or symptom | Meaning | Action |
+| --- | --- | --- |
+| Several candidate stable IDs are listed | The expression is permutation-equivalent to more than one stored representative | Select the intended stable ID explicitly |
+| No process matches | The artifact does not contain the requested particle multisets, or a leg crossed `>` | Run `pyamplicol inspect ARTIFACT` and correct the request |
+| Several process-group member IDs are listed | The expression matches more than one non-generated member | Select the intended member ID explicitly |
+| `process-groups payload ... sha256` or size error | `process-groups.json` changed without its manifest record | Restore the original file, or regenerate the artifact |
+| Kinematics shape mismatch | The point does not have one four-vector per public external particle | Follow `runtime.physics.external_particles` or the `--process` order |
+| Unknown helicity or flow ID | The ID came from another ordering or process | Read IDs after loading the requested process ordering |
+| Color-flow selector rejected | The artifact is NLC/full, not LC | Select helicities only, or generate an LC artifact |
+
+## See also
+
+- [Models and Processes](models-and-processes.md)
+- [Runtime and Selectors](runtime-and-selectors.md)
+- [Native APIs](native-apis.md)
+- [Artifacts and Portability](artifacts-and-portability.md)
diff --git a/pyamplicol/docs/user/profiling-and-benchmarking.md b/pyamplicol/docs/user/profiling-and-benchmarking.md
new file mode 100644
index 0000000000..9d9040a2d5
--- /dev/null
+++ b/pyamplicol/docs/user/profiling-and-benchmarking.md
@@ -0,0 +1,334 @@
+---
+title: "Profiling and Benchmarking"
+nav_order: 5
+has_children: true
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Profiling and Benchmarking
+
+pyAmpliCol has three intentionally separate performance tools:
+
+- `pyamplicol profile` measures one generated artifact through the same
+  optimized total path as `Runtime.evaluate()`;
+- a copied [profiling campaign](profiling-campaigns.md) coordinates many model,
+  process, color, and execution-mode cells and renders comparison PDFs;
+- the source-checkout [FullColor FFT profiler](fullcolor-fft-profiling.md)
+  schedules resumable direct/FFT, reference, AmpliCol, and MadGraph comparison
+  cells under explicit per-child resource limits.
+
+Use the direct profiler for a focused runtime question. Use a copied campaign
+for a reproducible general matrix. Use the FullColor FFT driver for the
+dedicated exact-colour scaling comparison.
+
+## First profile
+
+From the copied example workspace, generate the primary artifact and profile
+one public process ordering:
+
+```console
+pyamplicol generate_pp_zjj_from_ufo_sm.toml
+
+pyamplicol profile artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json \
+  --target-runtime 1.0 \
+  --batch-size 128 \
+  --color-flow 1 \
+  --precision 16
+```
+
+The shipped shorthand card runs the same one-second workload:
+
+```console
+pyamplicol benchmark.toml
+```
+
+`benchmark` is a compatibility alias for `profile`; both direct commands
+accept the same options. TOML retains `action = "benchmark"`—there is no
+separate `action = "profile"` card value.
+
+## What is timed
+
+At precision 16, the headline wall timer starts inside Rusticol after Python
+has converted the input to the native momentum buffer. It covers the ordinary
+optimized core evaluation, including the selected engine's scheduling and
+reduction. This is the runtime shared by Python, C11, C++17, Fortran 2008, and
+Rust 2021 callers; it deliberately excludes Python/NumPy conversion overhead.
+
+The profiler separately runs a paired native-attribution pass over the same
+batch and repetition count. That pass explains where time was spent but never
+replaces the ordinary headline wall sample.
+
+The main rows mean:
+
+| Metric | Interpretation |
+| --- | --- |
+| `wall time` | Repeated ordinary native runtime calls, normalized per point |
+| `evaluator total` | Separately measured, minimally instrumented complete evaluator call |
+| `Profile wall (paired profiled pass)` | Wall time of the attribution-enabled paired pass |
+| `Native input pack` | Native-side input preparation after caller conversion |
+| engine-specific runtime rows | Exclusive or explicitly labeled lane attribution |
+| `Other Rusticol core` | Residual work closing the exclusive component sum against profile wall |
+
+For compiled Direct-Arena, the row otherwise represented by an orchestration
+counter is labeled **Direct-Arena runtime envelope**. It includes arena setup,
+generated kernel execution, reduction, normalization, and orchestration. It is
+not a kernel-only time. The current uninstrumented Direct-Arena hot path cannot
+derive a pure kernel duration from that bucket.
+
+Rows whose measured mean is exactly zero are omitted from the human timing
+breakdown, which keeps the table focused on work actually observed for the
+selected engine.
+
+OTF has one additional, separately reported preparation observation. Before
+configured warmups, the profiler snapshots the compact native runtime census,
+times exactly one requested-selector evaluation over the full benchmark batch,
+and authenticates that the family is retained. It labels whether the starting
+handle was cold or already retained. That observation is not a headline wall
+sample and is ineligible for ratios or acceptance. It is also distinct from an
+explicit public `warm_up(...)`, which always takes exactly one binary64 point,
+never a profiling batch.
+
+## Sampling and uncertainty
+
+The profiler performs configured warmups, estimates one evaluation cost, and
+calibrates:
+
+- the number of independent timed blocks;
+- repetitions within each block;
+- the batch of phase-space points used by every call.
+
+Fast evaluators receive more repetitions per block. Slow evaluators use fewer
+blocks while never dropping below `--minimum-samples`. A suspiciously slow
+first one-repetition calibration observation is confirmed once at the same
+repetition count so a transient busy-host outlier does not force an unusable
+sampling plan.
+
+The human report includes:
+
+- mean time per point;
+- sample standard deviation;
+- standard error of the mean;
+- relative standard error (`standard error / mean`);
+- sample and repetition counts;
+- target and measured cumulative timing;
+- process, mode, precision, batch, and selector workload.
+
+The uncertainty describes repeatability of the measured blocks on that host;
+it is not a physics uncertainty.
+
+Interrupting with `Ctrl-C` stops after the current complete block and still
+prints the usual tables from completed samples. The result is explicitly
+marked partial.
+
+## Selectors change the workload
+
+Profile selectors are runtime choices. They do not require regenerating an
+artifact that retained complete coverage:
+
+```console
+pyamplicol profile artifacts/qq_z6g_recurrence_jit_o2 \
+  --process 'u u~ > Z g g g g g g' \
+  --color-flow 2 \
+  --target-runtime 5
+```
+
+or select one helicity:
+
+```console
+pyamplicol profile artifacts/qq_z6g_recurrence_jit_o2 \
+  --helicity 'h:-1,+1,-1,+1,+1,-1,+1,-1,+1'
+```
+
+For LC, match the flow layout to the workload:
+
+| Workload | Preferred generated layout |
+| --- | --- |
+| One selected flow, all helicities | Default `topology-replay` |
+| All flows, one selected helicity | `all-flow-union` |
+
+When both profiling selector axes are omitted, pyAmpliCol chooses a
+deterministic hot workload for the stored layout: one computed flow for
+`topology-replay`, or one computed nonzero helicity for `all-flow-union`.
+Explicit subsets and selected-axis lists are preserved; a complete summed-axis
+list is normalized to equivalent omission. Any valid explicit shape outside
+the stored layout's optimized workload emits at most one warning per loaded
+process, before timing begins. This is a performance warning, not a correctness
+failure; both layouts preserve complete physical flow and helicity coverage.
+Ordinary unqualified evaluation still returns the complete matrix element.
+
+There is no `all` selector shorthand. A complete list on the layout's summed
+axis is equivalent to omission and still permits hot-selector inference; a
+complete list on its selected axis explicitly requests the broader all-entry
+workload. Repeat `--color-flow` or `--helicity` for the complete stable-ID list
+shown by `inspect`; in Python, pass `runtime.physics.color_ids` or
+`runtime.physics.helicity_ids`. See
+[Runtime and Selectors](runtime-and-selectors.md#omitted-selectors-and-requesting-every-entry)
+for complete examples.
+
+NLC/full artifacts have contracted color and reject flow selectors.
+
+## Native timing attribution
+
+When the selected f64 runtime exposes native profiling, the report can include:
+
+- input packing and crossing;
+- state preparation and clearing;
+- source and momentum setup;
+- model-parameter setup;
+- stage or amplitude input/evaluator/output work;
+- reduction, total materialization, and final output copies;
+- selector planning, gather, and scatter;
+- recurrence source, contribution, finalization, closure, and replay work;
+- OTF query-family recurrence-schedule work, separately labelled from both the
+  complete evaluator envelope and recurrence mode's static schedule;
+- eager initialization, gather, kernel calls, scatter, finalization, closure,
+  and copy-out;
+- per-stage timing where applicable.
+
+Some internal rows are **attribution**, not additional top-level time. For
+example, a full-stage evaluator envelope may already own its leaf-input gather.
+The report labels these paths so they are not added twice.
+
+`Other Rusticol core` is the residual between the paired profile wall and the
+exclusive component sum. A small nonzero value is ordinary unsplit bookkeeping;
+it should not be interpreted as hidden Python overhead because the timer is
+already inside Rusticol.
+
+## Native work counters
+
+The optional counter table makes a profile easier to interpret by reporting
+work volume as well as duration. Depending on the engine it can include:
+
+- input bytes and native container counts;
+- state, source, momentum, and model-parameter components;
+- stage/amplitude movement and backend calls;
+- reduction and materialized output values;
+- selector gather/scatter volume;
+- observed reusable-scratch capacity changes;
+- explicit native output allocations;
+- recurrence call and row counts;
+- Direct-Arena engine/call and boundary-byte counts.
+
+Movement and materialization are normalized per profiled point. Backend-call
+and allocation activity are normalized per runtime call.
+
+For the fused compiled Arena path, boundary input/current-output/amplitude-
+output bytes must be zero and Arena calls must cover evaluator backend calls.
+An invalid counter relationship is rejected rather than printed as a valid
+optimized profile.
+
+## Progress and machine-readable output
+
+On a terminal, `--progress auto` selects a colored live progress display with
+elapsed time, uncertainty, repetitions, and batch size. A redirected or
+non-interactive run uses rate-limited log messages instead.
+
+Choose explicitly when scripting:
+
+```console
+pyamplicol profile artifacts/pp_zjj --progress log
+pyamplicol profile artifacts/pp_zjj --progress off --json > profile.json
+```
+
+JSON mode reserves stdout for the machine-readable result; diagnostics stay on
+stderr.
+
+## Python API
+
+The typed API accepts either a loaded runtime or an artifact path:
+
+```python
+import json
+from pathlib import Path
+
+from pyamplicol import BenchmarkConfig, BenchmarkRunner, Runtime
+
+momenta = json.loads(Path("data/pp_zjj_momenta.json").read_text())
+runtime = Runtime.load("artifacts/pp_zjj", process="d d~ > g z g")
+runner = BenchmarkRunner(
+    BenchmarkConfig(
+        target_runtime=1.0,
+        batch_size=128,
+        precision=16,
+        warmup_runs=2,
+        minimum_samples=5,
+        color_flow_ids=("1",),
+    )
+)
+result = runner.run(runtime, points=momenta)
+
+print(result.wall_time_per_point)
+print(result.uncertainty.standard_error)
+print(result.repetitions_per_sample)
+```
+
+`BenchmarkResult.timing_breakdown` exposes typed component timings, stage
+timings, and counter summaries when the backend supplies them.
+
+Python may profile a higher-precision evaluator when the artifact retains one,
+but native component attribution is f64-only. A non-f64 run therefore reports
+wall timing rather than the Rusticol f64 breakdown. OTF rejects non-f64
+precision altogether. See [Python API](python-api.md) and
+[Symbolica and Licensing](symbolica-and-licensing.md).
+
+## Reproducible campaign reports
+
+To create an independent campaign workspace from an installed wheel:
+
+```console
+pyamplicol profiling-campaign copy ./pyamplicol-profiling-campaign --force
+cd pyamplicol-profiling-campaign
+./steer_performance_campaign.py run \
+  --workers 1 --table matrix --process-id 1 --multiplicity 1 \
+  --color-approximation lc --generation-mode non-union-flow \
+  --generation-engine recurrence --model built_in
+./steer_performance_campaign.py refresh-pdf
+```
+
+That intentionally small smoke measures only the final-state-multiplicity-one
+`d d~ > Z` recurrence cell. Broad campaign matrices belong on dedicated hosts.
+See [Profiling Campaigns](profiling-campaigns.md) for continuation, selective
+retry, artifact retention, optional original-AmpliCol comparison, and PDF
+section controls.
+
+The repository publishes two rendered manual snapshots:
+
+- [MacBook M3 report](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/macbook_M3_pyAmpliCol.pdf)
+- [AMD EPYC report](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/EPYC_pyAmpliCol.pdf)
+
+They are measurement-host results, not release-CI benchmarks. Raw attempts and
+campaign workspaces remain local.
+
+## Comparing results responsibly
+
+- Keep process, model, parameter card, momenta, color accuracy, flow layout,
+  mode, backend, precision, selectors, and batch size fixed.
+- Compare ordinary wall means with their standard errors; do not compare one
+  engine's internal component against another engine's complete wall time.
+- Treat very small relative standard errors on a busy host cautiously; repeat
+  the full profile if system conditions materially changed.
+- Use a fresh runtime after rebuilding an artifact.
+- Record the exact artifact and package version, but do not infer physics
+  independence from agreement among APIs that all call Rusticol.
+
+## See also
+
+- [Runtime and Selectors](runtime-and-selectors.md)
+- [Generation Modes and Evaluators](generation-modes-and-evaluators.md)
+- [LC workloads and execution modes](lc-workloads-and-execution-modes.md)
+- [Profiling Campaigns](profiling-campaigns.md)
+- [FullColor FFT Profiling](fullcolor-fft-profiling.md)
+- [Examples Gallery](examples-gallery.md)
+
+<!-- Page hierarchy for the MadGraph7 (Sphinx) documentation. -->
+```{toctree}
+:hidden:
+
+profiling-campaigns
+fullcolor-fft-profiling
+troubleshooting
+release-and-support
+../performance_reports/README
+```
diff --git a/pyamplicol/docs/user/profiling-campaign-walkthrough.md b/pyamplicol/docs/user/profiling-campaign-walkthrough.md
new file mode 100644
index 0000000000..9c7a9bc995
--- /dev/null
+++ b/pyamplicol/docs/user/profiling-campaign-walkthrough.md
@@ -0,0 +1,715 @@
+---
+title: "Profiling campaign: from measurements to the PDF"
+nav_order: 2
+parent: "Get started: a gentle walkthrough"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Profiling campaign: from measurements to the PDF
+
+The profiling campaign answers a practical physics-computing question: for a
+fixed process, multiplicity, colour treatment, and workload, which pyAmpliCol
+execution mode is both numerically validated and fastest on *this* machine?
+It also records how that result compares with original AmpliCol and, where
+appropriate, MadGraph.
+
+Think of a copied campaign as a self-contained electronic lab notebook. It
+contains the catalogue of measurements to make, the report sources, and a
+visible `campaign_artifacts/` directory in which every attempt and current
+result is recorded, together with bounded diagnostics and any process output
+that must be retained. The controller can stop and resume without turning a
+long scan into one fragile all-or-nothing job.
+
+The dashboard and report use a few precise words:
+
+| Word | Plain-language meaning |
+| --- | --- |
+| **cell** | One measurement question: one process, multiplicity, model, colour treatment, workload, and execution mode |
+| **controller** | The steering script that chooses cells, starts measurements, and records their outcome |
+| **worker** | One supervised operating-system process doing one cell at a time; a worker may itself be allowed several CPU cores |
+| **dependency** | Another cell whose numerical result is needed to validate the requested cell, such as recurrence or MadGraph |
+| **process output** | The generated directory that can later evaluate phase-space points, roughly like a MadGraph standalone-process directory; internal files may call it an `artifact` |
+| **current result** | The latest complete record that the next report will use, not a worker that happens to be running now |
+| **provenance** | The recorded origin of a number: source revision, settings, machine, phase-space point, and validation link |
+| **authenticated record** | A record whose identity and integrity fields the controller has checked; this is a data-integrity term, not a user login |
+| **precision lane** | One supported numerical route, such as `p16` (ordinary double precision) or `p200` (about 200 decimal digits); “lane” does not mean another physics approximation |
+
+A new attempt replaces a cell's current-result pointer only after the complete
+record has been written. An interrupted or half-written attempt therefore
+cannot silently become the number shown in the PDF.
+
+The campaign is deliberately broader than the ordinary `pyamplicol profile`
+command. `profile` times one process output that you already selected. The
+campaign generates many outputs, checks them against independent numerical
+references, profiles the accepted results under matched workloads, and fills
+the tables in `pyAmpliCol.pdf`.
+
+## Create an independent campaign workspace
+
+Start from an installed pyAmpliCol environment and copy the packaged template
+into a new or empty directory:
+
+```console
+pyamplicol profiling-campaign copy ./my-profiling-campaign
+cd ./my-profiling-campaign
+./steer_performance_campaign.py --help
+```
+
+The copied directory is the unit to archive or move. All measurement state
+stays below it; the controller does not consult an old repository-level
+`.artifacts` directory.
+
+Two optional external programs extend the comparisons:
+
+```console
+pyamplicol profiling-campaign copy ./my-full-campaign \
+  --local-amplicol /path/to/clean/original-AmpliCol-checkout \
+  --local-madgraph /path/to/MG5_aMC
+```
+
+- Original AmpliCol supplies a legacy numerical diagnostic and the performance
+  denominator in the “versus AmpliCol” tables. It is not a correctness
+  authority for pyAmpliCol. The checkout must be clean and complete and expose
+  the maintained profiling and colour-probe interface from PR #12.
+- MadGraph standalone supplies the independent full-colour reference for the
+  UFO Standard Model comparison views. The path must contain executable
+  `bin/mg5_aMC` and the standard `models/sm` UFO model.
+
+The saved paths are defaults for that copy. A later `run --original-amplicol
+PATH` or `run --madgraph PATH` overrides one invocation.
+
+The reset JSON and TeX tables shipped in a fresh copy are **templates**, not
+benchmark predictions. Their cells begin unmeasured or `N/A`; they are filled
+from results obtained on your machine. In particular, do not expect a reset
+copy to contain the example numbers shown later on this page.
+
+## First preview, then run a small real cell
+
+Before using substantial CPU time, preview the selected work:
+
+```console
+./steer_performance_campaign.py run \
+  --dry-run \
+  --table matrix \
+  --process-id 1 \
+  --multiplicity 1 \
+  --color-approximation lc \
+  --generation-mode non-union-flow \
+  --generation-engine recurrence \
+  --model built_in \
+  --no-dependencies-added
+```
+
+The preview separates the cells you requested from any prerequisite or
+numerical-reference cells that the controller would add. It also prints the
+public pyAmpliCol recipe corresponding to each runnable cell, explicitly
+labelling any pre-generation template or report-protocol exception.
+
+Remove `--dry-run` to perform the deliberately small installation smoke test:
+
+```console
+./steer_performance_campaign.py run \
+  --workers 1 \
+  --table matrix \
+  --process-id 1 \
+  --multiplicity 1 \
+  --color-approximation lc \
+  --generation-mode non-union-flow \
+  --generation-engine recurrence \
+  --model built_in \
+  --no-dependencies-added \
+  --no-dashboard
+```
+
+This measures only the recurrence cell for `d d~ > Z`, at final-state
+multiplicity one. It is an installation check, not a representative estimate
+of the time needed for a broad high-multiplicity campaign.
+
+Release wheels omit the optional terminal-dashboard component (implemented
+with Ratatui). Their campaigns continue **headlessly**, meaning without the
+interactive dashboard, as though `--no-dashboard` had been supplied. A
+contributor installation prepared with that optional component can show the
+live coloured dashboard.
+
+## Select the physics question, not individual shell jobs
+
+The campaign catalogue is a matrix: each axis describes part of the physics or
+measurement question, and their allowed combinations define the cells. Useful
+selector dimensions include:
+
+| Selector | What it chooses | Examples |
+| --- | --- | --- |
+| `--table` | A report surface | `matrix`, `matrix_best`, `z_table`, `reference`, `scalar`, or an exact dataset ID |
+| `--process-id` | One of the numbered process families | `1`, or a catalogue key or quoted process |
+| `--multiplicity` | Number of final-state particles, `n` | `3 4` |
+| `--color-approximation` | Colour treatment | `lc`, `nlc`, `full` |
+| `--generation-mode` | Physical workload/layout | `non-union-flow`, `union-flow`, `contracted` |
+| `--generation-engine` | Program or execution mode | `amplicol`, `recurrence`, `compiled`, `eager`, `on-the-fly` |
+| `--model` | Model preparation used by the cell | `built_in`, `sm_ufo` |
+| `--cell-id` / `--cell-id-file` | Exact canonical cells | IDs printed by `inspect` or the summary files |
+
+Multiple values within one selector are alternatives; different selector
+dimensions are combined. For example:
+
+```console
+./steer_performance_campaign.py run \
+  --dry-run \
+  --table matrix \
+  --multiplicity 3 4 \
+  --generation-engine recurrence compiled \
+  --model built_in sm_ufo
+```
+
+means “multiplicity 3 **or** 4, recurrence **or** compiled, and built-in
+**or** UFO-SM where those catalogue cells exist.” An omitted dimension means
+all of its applicable values. Use `--help` to see the exact current choices and
+aliases before scripting a large selection.
+
+The campaign names map to the physical LC calls as follows:
+
+| Campaign name | Repeated request | Generated layout in recurrence/eager/compiled |
+| --- | --- | --- |
+| `non-union-flow` | one selected flow, summed over all helicities | `topology-replay` |
+| `union-flow` | all flows, one selected helicity | `all-flow-union` |
+| `contracted` | the requested axes already summed/contracted | used for NLC and full-colour campaign cells |
+
+OTF accepts the same two LC requests, but does not write either layout during
+generation. Its first selected request constructs the needed family in memory.
+This is why “engine” and “generation mode” are separate selectors: the former
+chooses *when and how* currents are prepared, while the latter chooses *which
+physics workload* is timed.
+
+By default, the controller also schedules the numerical reference needed to
+accept each requested candidate. The dashboard calls such a prerequisite a
+dependency. `--no-dependencies-added` suppresses optional independent-reference
+cells, but never removes unavoidable model, process, or selector prerequisites.
+It is useful for a narrow smoke test; a publication campaign normally keeps
+those independent checks.
+
+### Resource controls
+
+The safe defaults are one worker, one core per worker, a one-hour
+generation/preparation limit, a one-hour whole-worker limit, a decimal 30 GB
+RAM cap for each supervised worker process tree, a 64 MiB cap for each watched
+attempt-output stream, and a 5 GiB free-disk reserve. The main controls are:
+
+```text
+--workers N
+--cores-per-worker N
+--amplicol-build-jobs N
+--generation-time-limit SECONDS
+--worker-wall-limit SECONDS
+--ram-limit BYTES
+--campaign-ram-limit BYTES
+--attempt-output-limit BYTES
+--minimum-free-disk BYTES
+--target-measurement-duration SECONDS
+--minimum-samples N
+--warmups N
+--batch-size N
+```
+
+`--cores-per-worker` controls pyAmpliCol generation and runtime construction.
+Original AmpliCol compilation has the separate `--amplicol-build-jobs` control,
+which defaults to 1 even when pyAmpliCol receives more cores. Keep that serial
+default for the maintained legacy checkout: its generator Make target is not
+parallel-safe.
+
+`--ram-limit` is a cap for each worker tree—the worker plus every compiler or
+external program it starts. The optional
+`--campaign-ram-limit` is an aggregate ceiling: the controller conservatively
+divides it by the requested worker count and uses the smaller of that share and
+the per-worker cap. For example, ten workers with both limits set to decimal
+30 GB receive at most 3 GB each, so they cannot collectively claim ten times
+30 GB:
+
+```console
+./steer_performance_campaign.py run \
+  --workers 10 --ram-limit 30000000000 \
+  --campaign-ram-limit 30000000000 \
+  --table matrix --multiplicity 1 2 3
+```
+
+The controller measures the worker and all of its descendants as one memory
+tree. It guards resident RAM (RSS), and on macOS also checks the operating
+system's physical-footprint measure and uses whichever is larger. This RAM
+guard does **not** limit bytes written to disk: a runaway external-program log
+can fill a volume while the process remains well below its RAM ceiling.
+`--attempt-output-limit` therefore stops a worker when any watched attempt log
+or output file crosses its per-file limit; the default is 64 MiB (67,108,864
+bytes). `--minimum-free-disk` stops it when free space on the campaign-artifact
+volume falls below the reserve; the default is 5 GiB (5,368,709,120 bytes).
+Both cases are recorded as explicit errors rather than being mistaken for
+physics or timing results.
+
+Increase parallelism only when the machine has enough RAM for that many
+independent worker trees. `--fail-fast` changes validation scheduling into
+multiplicity waves and stops after the first final non-success, including a
+required mismatch, error, timeout, or supervisor-confirmed resource cap. A
+legacy AmpliCol disagreement remains a diagnostic rather than a stopping
+condition because original AmpliCol is not a correctness authority.
+
+## What one campaign cell actually does
+
+For an ordinary successful cell, the controller:
+
+1. resolves the catalogue process, model, colour treatment, workload, and
+   execution mode;
+2. prepares reusable model data when needed;
+3. generates the process output and records generation time;
+4. evaluates a shared deterministic phase-space point;
+5. checks the resolved sum and the required cross-mode or MadGraph agreement;
+6. profiles the accepted workload in repeated timing chunks; and
+7. seals the attempt (marks the record complete and no longer editable) and
+   makes it the cell's current result in one replacement.
+
+Independent cells can run in parallel. Dependencies are explicit: for example,
+the matching recurrence result checks compiled and eager results, while
+MadGraph standalone supplies the independent full-colour reference for UFO-SM
+results. For LC OTF cells through `n <= 4`, the matching recurrence cell checks
+every resolved helicity/flow component, not only their final sum; no compiled
+output is generated merely to perform that check.
+
+The common deterministic point matters. A timing ratio is published only when
+the candidate and denominator are explicitly linked to the same phase-space
+point and the required validation has passed. This prevents a visually
+plausible ratio from accidentally joining unrelated measurements.
+
+## Watch, stop, and resume without losing completed work
+
+In the interactive dashboard, `Ctrl-C` stops the campaign safely. `Esc` first
+closes an open command drawer; otherwise it performs the same orderly stop. In
+headless mode, use `Ctrl-C`. The controller stops dispatch, terminates each
+supervised worker and any child programs with its configured grace period,
+preserves completed current results and compact interruption evidence, marks
+the campaign as no longer live, writes the summary IDs, and exits with the
+conventional interrupted status (code 130).
+
+There is no supported “hold” or in-memory pause command. To pause a long scan,
+stop it orderly and later run the same command again. Compatible successful
+results from the same source revision (code version) are reused automatically;
+a cell with no compatible successful current is attempted again. If an older
+successful current survived the interrupted attempt, the ordinary rerun reuses
+that result; add `--force-refresh` only when you intentionally require a fresh
+attempt. Historical results from another source revision participate only when
+you explicitly pass `--continue-across-revisions`. Use that option only after
+checking that the intervening edits cannot change the generated physics,
+validation, or measured runtime path—for example, a report-layout-only change.
+Each reused result still records its original revision, so the PDF's provenance
+remains auditable rather than pretending that every cell came from one commit.
+Resume and cross-revision reuse follow the sealed `current.json` and result
+records; they do not depend on retaining a compiler or external-program build
+workspace.
+
+With dashboard bindings installed, another terminal can take a read-only
+snapshot of the newest live campaign:
+
+```console
+./steer_performance_campaign.py \
+  dashboard-snapshot --live --width 160 --height 48
+```
+
+This reads a small status record; it cannot pause, resume, or stop the campaign.
+Use `--instance ID_OR_PREFIX` when several campaign invocations are active.
+Without the optional dashboard bindings, this subcommand explains how to
+install them rather than attaching to a wheel-owned headless run.
+
+### Replay failures or policy caps
+
+After normal completion or an orderly interrupt, `campaign_summary_ids/`
+contains one sorted text file per non-success status. Typical names include
+`error.txt`, `blocked_dependency.txt`, `validation_failed.txt`,
+`worker_timeout.txt`, `interrupted.txt`, and `unverified.txt`. Replay exact
+cells with:
+
+```console
+./steer_performance_campaign.py run \
+  --cell-id-file campaign_summary_ids/error.txt \
+                 campaign_summary_ids/validation_failed.txt \
+  --force-refresh
+```
+
+Replaying a blocked cell includes its required prerequisites. An unverified
+timing result is not a successful current; replay `unverified.txt` without
+`--force-refresh` once its authority is available.
+
+Alternatively, keep ordinary table/process selectors and filter them by their
+latest state:
+
+```console
+./steer_performance_campaign.py run \
+  --table matrix \
+  --generation-engine recurrence compiled \
+  --rerun-failed --rerun-capped
+```
+
+`--rerun-failed` selects unsuccessful outcomes that are not authenticated
+policy caps. `--rerun-capped` selects resource-policy caps. Together they take
+the union. Successful, static, and never-attempted cells are not direct retry
+targets. These retry flags cannot be combined with `--force-refresh`; a retry
+selection with no matches exits successfully and leaves the existing summary
+untouched.
+
+## What is retained as evidence
+
+The controller owns `campaign_artifacts/`. Here “artifact” means retained
+campaign evidence, not only a generated pyAmpliCol process output. A cell
+normally retains a tiny pointer to its current result and one or more uniquely
+named attempt directories. Depending on the cell, an attempt can contain:
+
+- a manifest (an inventory identifying the completed attempt);
+- `result.json` and `worker-result.json`;
+- a bounded `worker.log`, streamed progress events, and a phase timeline;
+- resource measurements and termination diagnostics; and
+- when retained, an `artifact/` payload containing the generated process output
+  or an external-reference workspace used for the measurement.
+
+Prepared models, reusable model data (“model caches”), live status data, and a
+temporary directory used while building the PDF (“publication staging”) also
+stay below the campaign directory. Treat their exact subdirectory names as
+controller internals; use `inspect`, the summary ID files, and the current
+result JSON rather than editing pointers by hand.
+
+The default is **compact retention**. The controller keeps the result,
+provenance, commands, progress and phase records, resource diagnostics, and
+bounded final log tails. It keeps a generated pyAmpliCol process output when a
+current result still needs it. For original AmpliCol it keeps the small
+selected-flow library needed for replay and self-contained structural evidence,
+but removes the disposable checkout/build workspace; disposable MadGraph and
+other build workspaces are likewise removed after their measurements are
+sealed. Heavy payloads from obsolete, failed, or cancelled attempts are also
+removed. The old `--cleanup-artifacts` spelling is still accepted, but now
+names this default policy rather than enabling a more aggressive one.
+
+When diagnosing an external generator, opt in to complete workspaces for that
+run with:
+
+```console
+./steer_performance_campaign.py run \
+  --retain-workspaces \
+  --workers 1 --table matrix --process-id 1 --multiplicity 1 \
+  --color-approximation lc --generation-mode non-union-flow \
+  --generation-engine recurrence --model built_in \
+  --no-dependencies-added --no-dashboard
+```
+
+`--retain-workspaces` can consume disk quickly and is intended for a bounded
+debugging session. It does not disable the attempt-output or minimum-free-disk
+guards. Without it, a failed or fail-fast-cancelled attempt still retains the
+compact diagnostics needed to understand and replay the cell, but not an
+unbounded partial workspace.
+
+Temporary PDF-building directories and “live” markers are not historical
+evidence. They are removed when their operation ends, whether it succeeds or
+fails. Do not prune the campaign with broad shell cleanup commands.
+
+### Reset or branch a campaign safely
+
+Use another `profiling-campaign copy` for an independent machine, compiler, or
+experimental branch. To reset one existing destination intentionally:
+
+```console
+pyamplicol profiling-campaign copy ./my-profiling-campaign --force
+```
+
+Stop its active controller first. `--force` overwrites the managed template
+files and resets only that destination's `campaign_artifacts/`, generated PDF,
+summary-ID directory, measurement lineage, and known LaTeX byproducts. It
+preserves unrelated files. It also preserves saved AmpliCol and MadGraph paths
+unless new `--local-amplicol` or `--local-madgraph` values are supplied.
+
+This narrow reset is the supported replacement for manually deleting a broad
+temporary directory or guessing which attempt files are safe to remove.
+
+## Turn current results into the report
+
+When the desired cells have finished, publish one internally consistent report
+snapshot:
+
+```console
+./steer_performance_campaign.py refresh-pdf
+```
+
+The controller first takes a stable snapshot—a read-only list of the complete
+current results that belong in this version of the report. It verifies their
+recorded origin and validation links, shows coloured progress, renders the JSON
+and table TeX in a fresh temporary directory, and runs LaTeX there. Only after
+all of that succeeds does it replace the published files and `pyAmpliCol.pdf`
+as one unit. A failed render therefore leaves the previous PDF in place.
+
+Unresolved LaTeX references and compilation errors are fatal. Overfull boxes
+are reported by interactive `refresh-pdf` so they can be reviewed. The final
+maintainer audit is stricter: it authenticates the current results and physics
+links, rebuilds the PDF, extracts its text, renders every page to an image, and
+compares both text and pixels. Thus `refresh-pdf` is the normal campaign-owner
+command; the release audit is the publication boundary rather than a second
+measurement campaign.
+
+Useful report-only controls are:
+
+```console
+./steer_performance_campaign.py refresh-pdf --list-sections
+./steer_performance_campaign.py refresh-pdf \
+  --remove-sections worked-zgg shared-current-dag
+./steer_performance_campaign.py refresh-pdf --quiet
+```
+
+Removing sections affects only that staged PDF. It does not remove source,
+measurements, result JSON, or table TeX; the next plain `refresh-pdf` restores
+the complete report.
+
+## Find the matrices and their evidence
+
+Open `pyAmpliCol.pdf` and go to **Standard-Model Process Matrices**. The
+“best measured mode versus AmpliCol” tables provide the compact overview. For
+each process, multiplicity, and LC workload, the renderer independently chooses
+the validated pyAmpliCol mode with the smallest measured wall time. It does not
+declare one universally best mode.
+
+The generated TeX files beside the PDF are useful when a cell is too dense on
+screen. For example, the LC overview is
+`result_matrix_best_builtin_sm_lc_table.tex`. The corresponding detailed raw
+tables are rendered from JSON caches below `results/`, such as
+`matrix_compiled_builtin_sm_lc.json` and `reference_amplicol_lc.json`.
+
+For a human-readable view of current coverage and status, including OTF, use:
+
+```console
+./steer_performance_campaign.py inspect \
+  --color-approximation lc \
+  --generation-engine recurrence compiled eager on-the-fly
+```
+
+Add `--json` for stable, uncoloured output suitable for scripts. Exact
+cell IDs in `inspect`, the current JSON, and `campaign_summary_ids/` connect a
+compact table status back to its retained attempt evidence. The PDF does not
+turn every timing into a clickable evidence link; the result record stores the
+source/settings (“provenance”), shared point, and validation-reference link.
+
+### Wall, evaluator, and recurrence clocks
+
+The report keeps several clocks separate instead of renaming whichever number
+is available:
+
+- **Runtime** is the broad physics task of evaluating already generated output
+  at phase-space points. The **evaluator** is the loaded numerical calculator
+  that performs it.
+- **Wall time** is elapsed real time observed around the complete timed call.
+  It is available across implementations and is therefore the primary number
+  used to choose the fastest validated mode.
+- **Evaluator total** is a separately recorded accumulated clock inside the
+  complete warmed evaluator. Comparing it with wall time helps reveal time
+  spent in wrappers or in choosing and calling the numerical routine; it is
+  not copied from wall time.
+- **Recurrence core** is the still narrower time spent replaying recurrence
+  schedules. It is useful for diagnosing recurrence itself, but it is not a
+  complete evaluator clock and is never relabelled or used as another mode's
+  denominator.
+
+The muted bracketed `xS` in a Best-vs-AmpliCol runtime cell first compares
+compatible internal clocks that each implementation explicitly assigns to
+numerical execution, excluding its documented surrounding work. If those are
+unavailable, the table may use its explicitly documented evaluator-total
+versus legacy-direct fallback. Either way `xS` is diagnostic. The coloured
+outer `xW` is always the wall-time ratio and remains the performance
+conclusion.
+
+`JIT` in row labels means “just-in-time”: numerical machine code is prepared
+automatically for the current environment. `O2` and `O3` name compiler
+optimization levels; they do not denote perturbative orders.
+
+### The Z-gluon ladder also includes OTF
+
+The built-in-SM and UFO-SM Z tables follow
+
+```text
+d d~ -> Z + (n-1)g
+```
+
+through increasing final-state multiplicity. For each `n`, their setup rows now
+include compiled variants, eager, recurrence, **and on-the-fly JIT O2**, beside
+the original-AmpliCol reference. The two column groups remain the same physical
+workloads used throughout the report: selected flow with a helicity sum, and
+all flows at one helicity.
+
+An OTF generation cell in these detailed Z tables is printed as:
+
+```text
+[G] G+W
+```
+
+Both numbers are absolute seconds. `G` is generation of the compact process
+recipe; `G+W` adds the first cold evaluation of the complete campaign batch for
+that workload. The muted brackets separate generation alone without hiding the
+construction cost moved to first use. This `W` is not the public
+single-point `Runtime.warm_up(...)` call: the campaign deliberately measures
+its complete profiling batch. The adjacent `wall` column is the ordinary warm
+wall time per point. The `eval` column is shown only when the mode supplied a
+separately authenticated warmed evaluator-total clock; `not exposed` does not
+mean that wall timing failed.
+
+## Read one real “Best vs AmpliCol” cell
+
+The following is the process-ID 1, `n = 2` cell from the current authoritative
+campaign rendered for this release. It is a worked notation example, **not** a
+performance promise for another machine, compiler, source revision, or model
+preparation:
+
+```text
+d d~ -> Z + (n-1)g  =  d d~ -> Z g
+```
+
+The LC table contains two aligned workloads in the fixed order
+**selected flow, helicity sum | all flows, one helicity**:
+
+| Table row | Original AmpliCol | Best validated pyAmpliCol mode |
+| --- | --- | --- |
+| generation `[s]` | `3.66 | 0.000217` | `(o) ([x1.52] x1.52) | [5.57] 5.57 (o)` |
+| runtime `[microseconds/point]` | `0.209 | 0.172` | `([x2.46] x2.51) | ([x0.888] x1.04)` |
+
+Here is every visible entry:
+
+- `3.66` seconds is original AmpliCol's selected-flow process-library
+  generation time.
+- `0.000217` seconds is original AmpliCol's direct all-flow setup time. This is
+  a different setup boundary from pyAmpliCol process generation.
+- `(o)` says that **on-the-fly JIT O2** had the smallest validated wall time
+  for that workload. The code is a label, not a ratio. The four possible codes
+  are `(r)`, `(c)`, `(e)`, and `(o)` for recurrence JIT O2, compiled JIT O3,
+  eager-DAG JIT O2, and on-the-fly JIT O2.
+- In `([x1.52] x1.52)`, the muted bracketed multiplier uses compact OTF
+  process-output generation `G` alone. The coloured outer multiplier uses
+  `G+W`, where `W` is construction and first evaluation of the selected family
+  on the complete campaign batch. Both are divided by the matching 3.66 s
+  AmpliCol library-generation time. They round to the same value here because
+  the stored `G` was about 5.565 s and `W` about 0.00362 s.
+- `[5.57] 5.57 (o)` is the all-flow OTF generation pair in absolute seconds:
+  muted `[G]` followed by `G+W`. It is intentionally not divided by
+  `0.000217`, because AmpliCol direct setup and pyAmpliCol process generation
+  are different operations.
+- `0.209 | 0.172` are original AmpliCol wall times in microseconds per point
+  for the selected-flow and all-flow workloads, respectively.
+- In `([x2.46] x2.51)`, the muted bracketed value compares the OTF
+  execution-attribution clock with AmpliCol's compatible direct-execution
+  clock. The coloured outer value independently compares wall time: about
+  0.526 microseconds per point divided by 0.209. The outer ratio is the primary
+  figure used to choose a winner; generation time is not.
+- Likewise, `([x0.888] x1.04)` contains the supplementary execution ratio and
+  the primary wall ratio for all flows at one helicity. The OTF wall time was
+  about 0.178 microseconds per point, versus about 0.172 for AmpliCol.
+
+Muted supplementary ratios help diagnose where time is spent, but they never
+replace the outer wall ratio. In OTF generation notation, `W` excludes process
+output loading and the conventional benchmark warm-up calls. It is also not
+the public `Runtime.warm_up(...)` contract, which accepts exactly one
+double-precision point for one selected family; the campaign times the first
+complete batch required by its profiling protocol.
+
+## Colours, `N/A`, caps, and failures
+
+For a candidate/baseline multiplier `x`:
+
+- green means `x < 1`: the candidate was faster;
+- orange means `1 <= x < 2`;
+- red means `x >= 2`.
+
+The colours describe timing ratios, not physics accuracy. Accuracy is a
+separate acceptance gate. An orange resource-cap token such as `>5h` or
+`>40GB` means a configured policy boundary was reached; a red failure or
+validation token means the measurement was not accepted. Muted `N/A` denotes
+an unavailable entry, while `not applicable` means the process family itself
+is not defined at that multiplicity. `not run` means it exists but was outside
+the measured scope. `static N/A` marks a catalogue limitation known without
+launching a worker, such as an original-AmpliCol surface outside its supported
+open-quark-line scope.
+
+A compact token such as `N out.[5d35ae]` is a shortened final status, not a
+number or speed ratio. Use `inspect` or the relevant file under
+`campaign_summary_ids/` to recover the exact cell ID and outcome. `not exposed`
+has a different meaning: the wall measurement succeeded, but that mode did not
+provide the separately recorded internal clock requested by the detailed
+table. It is not a missing or failed wall measurement.
+
+Unverified, capped, unsupported, and validation-failed candidates do not enter
+“best” selection or performance summaries. A successful but unlinked candidate
+can still be selected by its absolute wall time; it is displayed absolutely and
+is excluded from timing ratios, mode-mix counts, and ratio summaries.
+
+## Read the summary rows
+
+Below each multiplicity block, the **mode mix** counts selected-flow wall-time
+winners that also have the valid AmpliCol link needed for the generation
+summary. The current authoritative `n = 2` LC block shows:
+
+```text
+r:0 | c:2 | e:0 | o:4
+```
+
+Among the six eligible process families, no winner was recurrence, two were
+compiled, none was eager, and four were OTF. A zero is meaningful—it says that
+the mode was measured but did not win this particular group. The order is
+always `r | c | e | o`; it matches the four mode labels in the cells.
+
+Every five-number summary is ordered as:
+
+```text
+minimum | maximum | median | arithmetic mean | weighted mean
+```
+
+The weighted mean is framed in the PDF. It is the ratio of summed candidate
+time to summed baseline time, not the average of the individual ratios:
+
+```text
+weighted mean = sum(candidate times) / sum(baseline times)
+```
+
+For `n = 2`, the same rendered campaign snapshot displays:
+
+| Summary row | `min | max | median | mean | weighted` |
+| --- | --- |
+| generation, selected-flow workload | `x0.801 | x1.52 | x1.34 | x1.24 | x1.23` |
+| runtime, selected flow and helicity sum | `x2.00 | x4.12 | x2.46 | x2.89 | x2.65` |
+| runtime, all flows and one helicity | `x0.754 | x1.43 | x1.00 | x1.05 | x1.05` |
+
+The generation summary uses only the comparable selected-flow **primary**
+generation ratios; for an OTF winner this is `G+W`, not the muted `G`-only
+ratio. Absolute all-flow generation is omitted. Runtime summaries use only the
+primary wall ratios, not the muted supplementary ratios, and keep the two LC
+workloads on separate lines. Structurally inapplicable, resource-limited,
+unsupported, unverified, unlinked, and validation-failed cells are excluded.
+This Best-vs summary follows the selected winner's primary token; a fixed-engine
+OTF table instead keeps its generation summary as the diagnostic `G`-only
+quantity while displaying both `G` and `G+W` in each row.
+
+The minimum answers “what was the best individual ratio?”, the maximum the
+worst, the median the middle process, and the arithmetic mean treats every
+included process equally. The framed weighted mean gives processes with larger
+baseline times more influence, because it asks what would happen if the
+included candidate times and baseline times were each added together.
+
+## A campaign-owner checklist
+
+1. Copy a fresh workspace for each machine or measurement environment.
+2. Record external AmpliCol or MadGraph paths only when those comparisons are
+   required.
+3. Preview a narrow selector with `run --dry-run`.
+4. Confirm worker count, per-worker cores, wall-time limit, per-worker RAM cap,
+   any aggregate campaign RAM cap, attempt-output cap, and free-disk reserve
+   before broadening the scan.
+5. Stop with `Ctrl-C` or dashboard `Esc`; resume by repeating the command.
+6. Use `inspect` and `campaign_summary_ids/` to understand non-successes before
+   forcing a refresh.
+7. Use compact retention by default. Add `--retain-workspaces` only for a
+   deliberate, disk-bounded debugging run.
+8. Run `refresh-pdf` only after the desired current cells are in place.
+9. Read ratios together with workload, mode code, validation status, and the
+   machine/source identity; no timing number is universal.
+
+For the exact controller contract and all current options, see the packaged
+[campaign template README](https://github.com/MadGraphTeam/MadGraph7/blob/main/pyamplicol/src/pyamplicol/_profiling_campaign/README.md)
+and [table-filling reference](https://github.com/MadGraphTeam/MadGraph7/blob/main/pyamplicol/src/pyamplicol/_profiling_campaign/TABLE_FILLING.md).
+For the physical difference between the two LC workloads and the four
+pyAmpliCol execution modes, continue with
+[LC workloads and execution modes](lc-workloads-and-execution-modes.md). The
+ordinary one-output timing workflow remains documented in
+[Profiling and Benchmarking](profiling-and-benchmarking.md#what-is-timed).
diff --git a/pyamplicol/docs/user/profiling-campaigns.md b/pyamplicol/docs/user/profiling-campaigns.md
new file mode 100644
index 0000000000..6cdd69e5af
--- /dev/null
+++ b/pyamplicol/docs/user/profiling-campaigns.md
@@ -0,0 +1,367 @@
+---
+title: "Profiling Campaigns"
+nav_order: 1
+parent: "Profiling and Benchmarking"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Profiling Campaigns
+
+The profiling-campaign command creates a complete, movable measurement
+workspace from an installed pyAmpliCol wheel. It is intended for controlled
+generation/runtime comparisons and for reproducing the report format used by
+the published MacBook M3 and AMD EPYC PDFs.
+
+For a physicist-oriented end-to-end explanation of steering, interruption,
+retained evidence, PDF rendering, and every entry in a concrete “Best vs
+AmpliCol” matrix cell, follow
+[Profiling campaign: from measurements to the PDF](profiling-campaign-walkthrough.md).
+
+> A campaign can create very large artifacts and long-running workers. Start
+> with the single-cell smoke below. Broader multiplicities belong on a
+> dedicated measurement host.
+
+## Create a fresh campaign
+
+```console
+pyamplicol profiling-campaign copy ./pyamplicol-profiling-campaign --force
+cd ./pyamplicol-profiling-campaign
+./steer_performance_campaign.py --help
+```
+
+The copy is self-contained apart from the installed pyAmpliCol runtime. It
+contains the controller, report sources, blank/reset data, generated-table
+templates, and one visible state root:
+
+```text
+pyamplicol-profiling-campaign/
+  steer_performance_campaign.py
+  README.md
+  TABLE_FILLING.md
+  report-workspace.json
+  campaign_artifacts/
+    cells/
+    coordination/
+    manual-reproductions/
+    report-snapshot-builds/
+  results/
+  result_*.tex
+  pyAmpliCol.tex
+```
+
+All attempts, prepared artifacts, current pointers, logs, locks, leases, and
+reproduction state live below `campaign_artifacts/`. The controller does not
+consult an old checkout-level `.artifacts` directory.
+
+## A deliberately small real run
+
+This command measures only the final-state-multiplicity-one `d d~ > Z`
+recurrence cell:
+
+```console
+./steer_performance_campaign.py run \
+  --workers 1 \
+  --table matrix \
+  --process-id 1 \
+  --multiplicity 1 \
+  --color-approximation lc \
+  --generation-mode non-union-flow \
+  --generation-engine recurrence \
+  --model built_in
+```
+
+It is the recommended installed-wheel campaign smoke. Release wheels omit the
+optional Ratatui bindings, so the controller continues headlessly. A
+contributor checkout prepared with `just dev-install` can show the interactive
+dashboard.
+
+Preview a broader selection without launching workers:
+
+```console
+./steer_performance_campaign.py run \
+  --dry-run \
+  --table z_table \
+  --multiplicity 3 4 \
+  --model built_in sm_ufo
+```
+
+The dry run separates directly selected cells from dependency work and prints
+a public-CLI reproduction recipe for each runnable cell.
+
+## Selection and numerical-authority closure
+
+The campaign catalog has stable canonical cell IDs. Ordinary selectors choose
+direct work by table, process family, multiplicity, color approximation,
+generation mode, engine, model, and variant.
+
+By default, the controller recursively adds each selected cell's available
+active-source numerical-authority chain:
+
+```text
+original AmpliCol  →  recurrence  →  compiled / eager
+```
+
+Added cells are dependency-only work. Independent process/multiplicity cohorts
+remain parallel. Hard construction and selector/provider dependencies always
+block until available. A terminal optional authority releases its candidate:
+the candidate can still run, but a compiled/eager result without independent
+authority is retained as an explicit unverified timing diagnostic rather than
+published as a successful current.
+
+Use `--no-dependencies-added` only when you intentionally want to suppress
+this optional numerical-authority expansion. It never removes hard
+dependencies.
+
+## Original AmpliCol is optional
+
+All pyAmpliCol backends work without an original-AmpliCol checkout. The legacy
+backend is enabled only when selected as a reference.
+
+The supported input is a **clean, complete checkout** exposing the profiling
+probe sources and Make targets from
+[rikkert-frederix/AmpliCol PR #12](https://github.com/rikkert-frederix/AmpliCol/pull/12).
+It is not a single Fortran file and is not bundled in pyAmpliCol.
+
+Record a destination-local default while copying:
+
+```console
+pyamplicol profiling-campaign copy ./campaign \
+  --local-amplicol /path/to/clean/complete/AmpliCol-checkout
+```
+
+Or provide/override it for one run:
+
+```console
+./campaign/steer_performance_campaign.py run \
+  --original-amplicol /path/to/clean/complete/AmpliCol-checkout \
+  --generation-engine amplicol recurrence \
+  --table matrix --process-id 1 --multiplicity 1 \
+  --color-approximation lc --model built_in
+```
+
+The copy stores the chosen path in `.pyamplicol-original-amplicol`. A later
+`--force` reset preserves that pointer unless `--local-amplicol` explicitly
+replaces it. Without a configured checkout, a selection that does not include
+`amplicol` remains fully supported.
+
+## Reuse and source revisions
+
+Successful compatible currents are reused by default. The campaign's stored
+attempts are not erased merely because pyAmpliCol's source revision changes.
+
+Without `--continue-across-revisions`, planning and report operations use the
+active source cohort. With it, valid historical currents may remain in the
+campaign while new cells and dependencies are measured at the active revision:
+
+```console
+./steer_performance_campaign.py run \
+  --continue-across-revisions \
+  --workers 4 \
+  --table matrix \
+  --multiplicity 4 5 \
+  --generation-engine recurrence compiled eager \
+  --model built_in
+```
+
+This option reconciles compatible prior results; it does not reconstruct a
+deleted campaign. Historical numerical authorities needed by current-revision
+work are replanned at the active revision rather than silently reused across an
+unsafe authority boundary.
+
+The operations that actually reset managed state are
+`pyamplicol profiling-campaign copy DEST --force` and deliberate manual
+deletion. Stop every active controller before using `--force`.
+
+## Move or rename a campaign
+
+Move the complete directory, not selected result files:
+
+```console
+mv ./campaign-mac ./archive/macbook-M3-2026
+cd ./archive/macbook-M3-2026
+./steer_performance_campaign.py inspect
+```
+
+Portable current locators are interpreted relative to the campaign's new
+`campaign_artifacts/` root. Two campaign directories with the same basename in
+different parents do not share state.
+
+If a directory was renamed while a shell remained inside its old inode, start
+a new shell or `cd` through the new absolute path before launching the copied
+controller. The launcher checks logical and physical working directories and
+fails instead of reading an unintended campaign.
+
+## Dashboard and progress
+
+Contributor environments with Ratatui bindings display active worker lanes,
+direct/dependency work, completed/capped/error/unverified partitions, elapsed
+time, and compact terminal reasons.
+
+Capture a read-only view from another terminal:
+
+```console
+./steer_performance_campaign.py dashboard-snapshot --live \
+  --width 160 --height 48
+```
+
+The live snapshot reads only compact coordination leases. Use
+`--instance ID_OR_PREFIX` when more than one controller is active. Omit
+`--live` for the deterministic layout fixture.
+
+`Ctrl-C` or `Esc` stops dispatch, terminates supervised process trees,
+preserves completed currents, writes the summary-ID files, and restores the
+terminal.
+
+## Retry exactly what needs attention
+
+Every completed or orderly interrupted run replaces
+`campaign_summary_ids/` with one sorted text file per non-success status, for
+example:
+
+```text
+campaign_summary_ids/
+  blocked_dependency.txt
+  error.txt
+  unverified.txt
+  validation_failed.txt
+  worker_timeout.txt
+```
+
+Replay exact IDs:
+
+```console
+./steer_performance_campaign.py run \
+  --cell-id-file campaign_summary_ids/error.txt \
+                 campaign_summary_ids/validation_failed.txt \
+  --force-refresh
+```
+
+Or filter an ordinary selection by structured state:
+
+```console
+./steer_performance_campaign.py run \
+  --table z_table \
+  --generation-engine recurrence compiled \
+  --rerun-failed --rerun-capped \
+  --continue-across-revisions
+```
+
+- `--rerun-failed` selects latest terminal non-successes that are not
+  authenticated policy caps; unverified diagnostics are retryable here.
+- `--rerun-capped` selects authenticated memory/time/generation policy caps.
+- Combining them takes the union.
+- Successful, structural-static, and never-attempted cells are not direct
+  retry targets.
+- Normal hard and optional dependency closure still applies.
+- The selective flags conflict with `--force-refresh`.
+- No matches is a successful no-op and preserves the previous summary IDs.
+
+Replaying `blocked_dependency.txt` includes its prerequisites automatically.
+An `unverified.txt` replay does not require `--force-refresh`: unverified is
+not an authoritative successful current.
+
+## Attempt retention and cleanup
+
+Compact retention is the default. It keeps sealed results and current pointers,
+provenance, commands, progress/timeline evidence, bounded log tails, and outputs
+needed by currents or dependencies. Disposable copied AmpliCol, MadGraph, and
+build workspaces are removed after publication. Cross-revision reuse reads the
+sealed results rather than those workspaces.
+
+Pass `--retain-workspaces` only for a bounded debugging run that needs the full
+workspaces:
+
+```console
+./steer_performance_campaign.py run \
+  --retain-workspaces \
+  --table matrix --process-id 1 --multiplicity 1 \
+  --generation-engine recurrence --model built_in
+```
+
+`--cleanup-artifacts` remains accepted as a compatibility spelling for the
+default compact policy. Independently, `--attempt-output-limit` defaults to
+67,108,864 bytes (64 MiB) per watched output/log file and
+`--minimum-free-disk` reserves 5,368,709,120 bytes (5 GiB) on the artifact
+volume. These storage guards complement, but do not replace, process-tree RAM
+supervision.
+
+## Inspect and render
+
+Inspect coverage and AmpliCol-relative comparisons:
+
+```console
+./steer_performance_campaign.py inspect \
+  --color-approximation lc \
+  --generation-engine recurrence compiled
+```
+
+Refresh all tables and atomically replace the PDF from one coherent current
+snapshot:
+
+```console
+./steer_performance_campaign.py refresh-pdf
+```
+
+Interactive refresh displays a colored progress bar while current records are
+read and checked. It does not rescan every historical heavy artifact.
+
+List stable section IDs or omit sections from one PDF build:
+
+```console
+./steer_performance_campaign.py refresh-pdf --list-sections
+./steer_performance_campaign.py refresh-pdf \
+  --remove-sections worked-zgg shared-current-dag
+```
+
+Section omission changes only the staged PDF. Measurements, JSON caches, table
+TeX, and source remain; the next plain refresh restores the complete report.
+`--quiet` suppresses scan progress and live LaTeX output.
+
+The repository retains only two rendered report snapshots:
+
+- [MacBook M3 report](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/macbook_M3_pyAmpliCol.pdf)
+- [AMD EPYC report](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/EPYC_pyAmpliCol.pdf)
+
+Raw campaign results are intentionally not published in the repository. A
+fresh copied campaign contains everything needed to reproduce the report
+format directly.
+
+## What `--force` resets
+
+```console
+pyamplicol profiling-campaign copy DEST --force
+```
+
+replaces only managed template files and resets:
+
+- `DEST/campaign_artifacts/`;
+- the managed `pyAmpliCol.pdf`;
+- `campaign_summary_ids/`;
+- measurement lineage;
+- known pyAmpliCol LaTeX build byproducts.
+
+It preserves unrelated destination files, a legacy `DEST/.artifacts`
+directory (which is ignored), and the recorded original-AmpliCol pointer unless
+explicitly replaced. An active campaign makes reset fail without removing
+state.
+
+## Recommended operating habits
+
+1. Use one copied directory per host and campaign policy.
+2. Run `--dry-run` before a broad selection.
+3. Set worker and RAM limits for the actual host.
+4. Use `--continue-across-revisions` when intentionally extending a campaign
+   across source updates.
+5. Prefer selective retry flags over a broad force refresh.
+6. Keep compact attempts by default; use `--retain-workspaces` only for a
+   bounded debugging run.
+7. Never commit `campaign_artifacts/`, raw results, logs, locks, attempts, or
+   LaTeX auxiliary files.
+
+## Related pages
+
+- [Examples Gallery](examples-gallery.md) — ordinary generation/runtime examples.
+- [Profiling campaign walkthrough](profiling-campaign-walkthrough.md) — the campaign idea, retained evidence, PDF lifecycle, and matrix interpretation.
+- [Artifacts and Portability](artifacts-and-portability.md) — process-artifact portability and trust.
+- [Troubleshooting](troubleshooting.md) — campaign state, source revision, and dashboard issues.
+- [Packaged campaign guide](https://github.com/MadGraphTeam/pyamplicol/blob/main/src/pyamplicol/_profiling_campaign/TABLE_FILLING.md).
+- [Published report index](../performance_reports/README.md).
diff --git a/pyamplicol/docs/user/python-api.md b/pyamplicol/docs/user/python-api.md
new file mode 100644
index 0000000000..aadbcd9c36
--- /dev/null
+++ b/pyamplicol/docs/user/python-api.md
@@ -0,0 +1,620 @@
+---
+title: "Python API"
+nav_order: 4
+has_children: true
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Python API
+
+The public Python interface offers typed services for model compilation,
+process planning/generation, runtime evaluation, Born correlations, selectors,
+and profiling.
+Importing `pyamplicol` is lightweight: Symbolica and model tooling are loaded
+only when the requested operation needs them.
+
+```python
+import pyamplicol
+
+print(pyamplicol.__version__)
+```
+
+## Public service map
+
+| Service | Purpose |
+| --- | --- |
+| `ModelSource` | Resolve and compile built-in, JSON, UFO, compiled, or prepared models. |
+| `Generator` | Plan or generate schema-v3 process artifacts. |
+| `Runtime` | Load one concrete process and evaluate totals/resolved components. |
+| `CorrelatorConfig`, `ColorCorrelator` | Declare allowed spin replacements and named colour operators at generation. |
+| `CorrelatedValue` | A correlated result with `Decimal` real and imaginary parts. |
+| `BenchmarkRunner` | Profile an artifact or loaded runtime. |
+| `group_processes` | Group the subprocesses of an artifact with equal matrix elements. |
+| `generate`, `load`, `benchmark` | One-shot convenience functions. |
+
+The shipped scripts under
+[`examples/python/`](https://github.com/MadGraphTeam/pyamplicol/tree/main/examples/python)
+are complete runnable programs.
+
+## Plan and generate with the built-in model
+
+```python
+from pyamplicol import GenerationConfig, Generator, ModelSource
+
+generator = Generator(GenerationConfig(workers=2))
+model = ModelSource.built_in_sm()
+
+plan = generator.plan("d d~ > z g", model=model)
+for process in plan.concrete_processes:
+    print(process.name, process.expression)
+
+result = generator.generate(
+    "d d~ > z g",
+    "artifacts/builtin_ddbar_to_zg",
+    model=model,
+    mode="replace",
+)
+print(result.output)
+```
+
+`plan()` resolves the model/process/color/evaluator contract without writing a
+process artifact. `generate()` returns an immutable `GenerationResult` with the
+absolute output, stored process set, schema version, and file inventory.
+
+The packaged scalar HEFT model uses the same public selector:
+
+```python
+from pyamplicol import Generator, ModelSource
+
+heft = ModelSource.built_in_sm_heft()
+Generator().plan("g g > H g g", model=heft)
+```
+
+Use an explicit `HIG = 1` coupling-order limit in a resolved run configuration
+when generating the process; see [Models and Processes](models-and-processes.md#built-in-scalar-heft-model)
+and the packaged `builtin_sm_heft.toml` card.
+
+## Generate with adjoint FFT contraction
+
+The Python API uses the same `RunConfig` and `ColorConfig` fields as TOML and
+the CLI. Defaults `contraction="auto"` and `fft_basis="adjoint"` try adaptive
+exact FFT for NLC/full recurrence and on-the-fly execution, with direct fallback
+for unsupported FFT plans. This certified pure Yang–Mills example uses DDM:
+
+```python
+from pyamplicol import ColorConfig, Generator, ModelSource, RunConfig
+from pyamplicol.config import EvaluatorConfig
+
+config = RunConfig(
+    action="generate",
+    color=ColorConfig(accuracy="full"),
+    evaluator=EvaluatorConfig(execution_mode="recurrence"),
+)
+result = Generator(config).generate(
+    "g g > g g g",
+    "artifacts/ggg_adjoint_fft",
+    model=ModelSource.built_in_sm(),
+)
+```
+
+Select `accuracy="nlc"` for NLC contraction, or `execution_mode="on-the-fly"`
+for a compact OTF artifact. The effective configuration can retain `"auto"`
+until per-process selection. LC, compiled/eager execution, and `correlators=`
+use direct contraction and the trace basis under the automatic policy.
+
+Use `ColorConfig(accuracy="full", contraction="direct")` to opt out of FFT;
+direct contraction ignores `fft_basis`. To force FFT and retain errors for
+unsupported plans, set `contraction="symmetric-group-fft"`, optionally with
+`fft_basis="trace"` for the original representation. The string `"adjoint"`
+is equivalent to `ColorFFTBasis.ADJOINT` (imported from `pyamplicol`). Explicit
+FFT does not support compiled/eager modes or LC accuracy.
+
+For certified trees with `n` external gluons, DDM fixes two anchors and reduces
+the trace set from `(n-1)!` orderings to `(n-2)!`, representing the same amplitude.
+Certified single-insertion HEFT also uses DDM; specify explicit coupling orders
+with `HIG = 1`, as in `examples/builtin_sm_heft.toml`. Quark processes keep exact
+fundamental chains or their products, not a newly assumed JO primitive basis;
+uncertified adjoint interactions retain trace tensors. The saved
+`fft_basis_selection` reports `requested`, `actual_basis`, `name`, `reason`,
+`permutation_degree`, and `tensor_count`, making that choice explicit.
+Forced adjoint FFT cannot be combined with `correlators=`. Runtime totals,
+resolved helicities and native SDK evaluation calls are unchanged. No universal
+speedup is implied.
+In the benchmarked pure-gluon family the adjoint basis was faster than trace
+for six or more external gluons (3.9x per sample at ten gluons); benchmark
+other multiplicities and selector workloads.
+
+## Generate a named process set
+
+```python
+from pyamplicol import Generator, ModelSource, ProcessRequest, ProcessSet
+
+processes = ProcessSet(
+    requests=(
+        ProcessRequest.parse("u u~ > Z g", name="uubar_Zg"),
+        ProcessRequest.parse("u u~ > Z g g", name="uubar_Zgg"),
+    )
+)
+
+result = Generator().generate(
+    processes,
+    "artifacts/z_ladder",
+    model=ModelSource.built_in_sm(),
+    mode="replace",
+)
+```
+
+Process names must be unique. For custom aliases and crossing metadata, use
+`ProcessAlias`; runtime expression matching already handles unique
+side-preserving permutations automatically.
+The correlated reference path currently requires identity ordering; these
+permutation facilities apply to ordinary evaluation.
+
+## Compile and reuse an external model
+
+```python
+from pyamplicol import Generator, ModelSource
+
+source = ModelSource.from_path(
+    "models/json/sm/sm.json",
+    restriction="default",
+)
+model = source.compile()
+
+print(model.info.name)
+print(model.capabilities.supported_color_accuracies)
+print(model.supported)
+
+Generator().plan("d d~ > z g", model=model)
+```
+
+For a trusted UFO directory:
+
+```python
+source = ModelSource.from_path(
+    "/path/to/MyUFO",
+    restriction="restrict_default.dat",
+)
+model = source.compile()
+```
+
+UFO modules execute Python while loading. See
+[Models and Processes](models-and-processes.md) for trust, serialization, and
+prepared bundles.
+
+## Use a fully resolved run card
+
+For complex configuration, resolve the same schema used by the CLI and pass the
+result to `Generator`:
+
+```python
+from pyamplicol import Generator, ModelSource, ProcessRequest, ProcessSet
+from pyamplicol.config import resolve_config
+
+card = {
+    "schema_version": 1,
+    "action": "generate",
+    "model": {"source": "models/json/sm/sm.json", "restriction": "default"},
+    "process": {
+        "entries": [{"expression": "p p > Z j j"}],
+        "multiparticles": {"p": ["d", "d~", "g"], "j": ["d", "d~", "g"]},
+        "flavor_scheme": 2,
+        "max_quark_lines": 2,
+    },
+    "color": {"accuracy": "lc"},
+    "generation": {"output": "artifacts/pp_zjj", "mode": "replace"},
+    "evaluator": {"execution_mode": "compiled", "backend": "jit"},
+}
+
+resolution = resolve_config(card)
+model = ModelSource.from_config(resolution.effective.model).compile()
+processes = ProcessSet(
+    tuple(
+        ProcessRequest.parse(entry.expression, name=entry.name)
+        for entry in resolution.effective.process.entries
+    )
+)
+result = Generator(resolution).generate(
+    processes,
+    resolution.effective.generation.output,
+    model=model,
+    mode=resolution.effective.generation.mode,
+)
+```
+
+The complete maintained implementation is
+[`examples/python/typed_generation.py`](https://github.com/MadGraphTeam/pyamplicol/blob/main/examples/python/typed_generation.py).
+
+## Load a runtime
+
+```python
+from pyamplicol import Runtime
+
+runtime = Runtime.load(
+    "artifacts/pp_zjj",
+    process="d d~ > g z g",
+    model_parameters={"aS": 0.117, "MZ": 91.1876},
+)
+
+print(runtime.artifact_id)
+print(runtime.execution_mode)
+print(runtime.physics.process_id)
+print(runtime.physics.process)
+print(runtime.representative_process_key)
+print(runtime.external_permutation)
+```
+
+`process` may be a stable process ID, explicit alias ID, exact stored expression,
+or unique permutation-equivalent expression within each side. The loaded
+runtime exposes metadata in the requested public order.
+For correlated evaluation, load the stored process in its generated ordering;
+nonidentity aliases/permutations are not supported by that path yet.
+
+## Evaluate totals and resolved components
+
+```python
+import json
+import math
+from pathlib import Path
+
+points = json.loads(Path("data/pp_zjj_momenta.json").read_text())
+
+totals = runtime.evaluate(points)
+resolved = runtime.evaluate_resolved(points)
+
+print(resolved.helicity_ids)
+print(resolved.color_ids)
+for optimized, explicit in zip(totals, resolved.total(), strict=True):
+    assert math.isclose(optimized.real, explicit.real, rel_tol=1e-12, abs_tol=1e-15)
+    assert math.isclose(optimized.imag, explicit.imag, rel_tol=1e-12, abs_tol=1e-15)
+```
+
+Input shape is:
+
+```text
+(point, external particle, [E, px, py, pz])
+```
+
+At LC, resolved shape is `(point, helicity, color_flow)`. At NLC/full,
+the color dimension has length one because color is contracted.
+
+## Retain completed OTF preparation
+
+For an on-the-fly runtime, `runtime.save(path)` writes the completed cache
+left by evaluation or explicit warm-up. In a later program, load the original
+process output with `Runtime.load(...)`, then call `runtime.load_cache(path)`
+before evaluating with the same selectors. Both methods return `None`; the
+restored calculation accepts new momenta and batch sizes while retaining the
+receiving runtime's model parameters.
+
+See the [complete four-gluon example](runtime-and-selectors.md#saving-an-otf-warm-cache)
+for generation, saving and restoring, and a check that no queries are rebuilt.
+The cache supplements the original process output; it does not replace it or
+checkpoint an unfinished cold construction.
+
+## Evaluate Born correlations
+
+Correlations require an explicit `Generator.generate(..., correlators=...)`
+declaration. They support **LC, NLC and full colour**, through a separate Python
+direct, generic compiled exact executor. `color.accuracy` selects the correlated
+approximation. Supplying `correlators` retains complete underlying amplitudes
+and selects direct contraction and compiled generation. Ordinary generation
+and evaluation remain unchanged.
+
+```python
+from pyamplicol import (
+    ColorCorrelator, CorrelatorConfig, Generator, ModelSource, Runtime,
+)
+from pyamplicol.config import ColorConfig, RunConfig
+
+declarations = CorrelatorConfig(
+    color_correlations=(ColorCorrelator.dipole("T13", 1, 3),),
+    spin_correlations=((3,), (3, 4)),
+)
+generated = Generator(RunConfig(color=ColorConfig(accuracy="full"))).generate(
+    "g g > g g", "artifacts/gg_correlated",
+    model=ModelSource.built_in_sm(), correlators=declarations,
+)
+correlated_runtime = Runtime.load(generated.output)
+point = (
+    (500, 0, 0, 500), (500, 0, 0, -500),
+    (500, 300, 0, 400), (500, -300, 0, -400),
+)
+colour = correlated_runtime.evaluate_correlated(
+    (point,), color_correlation="T13", precision=40,
+)[0]
+correlated_runtime.set_spin_correlation_vectors({3: (0, 0, 1, 0)})
+spin_colour = correlated_runtime.evaluate_correlated(
+    (point,), color_correlation="T13", precision=40,
+)[0]
+print(spin_colour.real, spin_colour.imag)  # Decimal values, not a forced real part.
+correlated_runtime.set_spin_correlation_vectors(None)
+```
+
+Instead of explicit colour requests, use
+`CorrelatorConfig.all_color(through_order=k, spin_correlations=...)` before
+generation to prepare every compatible directed pair of tree-soft connections
+through any positive order `k`. The nonminimal catalogue includes emissions from
+emitted partons and splitting of auxiliary gluons, and grows rapidly with order.
+It adds no kinematic kernels, flavour sums or multiplicity weights. Inspect the
+operators actually stored for a selected process with:
+
+```python
+for entry in correlated_runtime.available_color_correlations():
+    print(entry.id, entry.order, entry.bra, entry.ket)
+```
+
+This includes `"born"` and reads the catalogue without initializing amplitude
+evaluation. See the [automatic catalogue guide](../correlators.md)
+for generation and grouped evaluation.
+
+`evaluate_correlated(momenta, *, color_correlation="born", helicities=None,
+precision=16, arithmetic="arbitrary")` returns one `CorrelatedValue` per point. The reserved ID
+`"born"` uses the Born metric at the requested colour accuracy; other IDs are the declared
+operators. Optional batch-global helicity selectors accept stable IDs or typed
+`HelicityConfiguration` objects. There is no colour-flow or per-point selector
+argument on this method. Normalization, initial-state averages, and
+identical-particle factors are retained, and runtime model-parameter updates
+also apply to correlations.
+
+For multiple combinations, `evaluate_correlated_many(points, requests)` takes
+a mapping from your result labels to `CorrelatedRequest(color_correlation=...,
+spin_vectors=...)`. Its result is a dictionary of tuples:
+`result[request_label][point_index].real` or `.imag` selects one contraction
+at one phase-space point. Label and point order are preserved. Identical spin
+assignments share their amplitudes across colour operators, and unchanged
+stages can be reused across different assignments. See the
+[two-axis example](../correlators.md#several-requests-and-several-phase-space-points)
+for request-centric and point-centric access. Ordinary `evaluate()` on the
+underlying correlated output remains full-colour; use the correlated `"born"`
+request when comparing its selected LC/NLC approximation.
+
+The spin-vector mapping uses one-based public leg labels. Each value is a
+literal real or complex `(v0, vx, vy, vz)` vector, broadcast across the batch,
+or one such vector per point. The nonempty key set must exactly match a
+declared spin class: this example permits `{3}` and `{3, 4}`, but not `{4}`.
+Vectors are neither normalized nor projected. They are copied into
+instance-local state; a failed setter preserves the previous state. `None` or
+`{}` resets to ordinary helicity sources; `clear()` releases warmed evaluators
+without resetting vectors. The setter affects `evaluate_correlated` and
+inherited requests in `evaluate_correlated_many`, not `evaluate` or
+`evaluate_resolved`.
+
+`Decimal` vector components retain their digits; a `(Decimal(real),
+Decimal(imaginary))` pair represents one complex component without first
+rounding it through Python's binary64 `complex`. For example:
+
+```python
+from decimal import Decimal
+
+zero = Decimal(0)
+correlated_runtime.set_spin_correlation_vectors({3: (
+    zero, zero,
+    (Decimal("1.0000000000000000000000001"), Decimal("2e-25")),
+    zero,
+)})
+arb = correlated_runtime.evaluate_correlated((point,), precision=80)
+dd = correlated_runtime.evaluate_correlated(
+    (point,), arithmetic="double-double", precision=31,
+)
+correlated_runtime.set_spin_correlation_vectors(None)
+```
+
+The default is arbitrary precision. Explicit `arithmetic="double-double"`
+uses genuine DoubleFloat arithmetic throughout sources, evaluation stages,
+normalization and reduction; at most 31 result digits are supported. The same
+keyword and Decimal vector syntax apply to `evaluate_correlated_many` and its
+explicit request vectors. See the [grouped precision example](../correlators.md#decimal-inputs-and-double-double-arithmetic).
+
+Artifacts without declarations, append generation, partial source coverage,
+FFT, eager/recurrence/OTF correlated execution, replay reductions, and
+nonidentity process permutations are not supported. Ordered `EmitGluon` and
+`SplitGluon` operations have no fixed order cap; generic NkLO colour-connection
+order is distinct from LC/NLC colour approximations and does not supply a
+complete higher-order subtraction calculation. See [Born Correlations](../correlators.md)
+for the bra-adjoint/ket convention, joint spin contractions, JSON declarations,
+Ward checks, and current limitations.
+
+The same generated colour catalogue and spin classes are available to the
+[C/C++/Fortran/Rust SDKs](native-apis.md#correlated-born-evaluations), whose
+correlated evaluation is binary64 and independent of Python/Symbolica.
+The Python methods described here retain their precision-controlled executor.
+
+## Select helicities and color flows
+
+Batch-global selectors accept stable IDs or the typed objects exposed by
+`runtime.physics`:
+
+```python
+selected = runtime.evaluate(
+    points,
+    helicities=[runtime.physics.helicities[0]],
+    color_flows=[runtime.physics.color_flows[0]],
+)
+```
+
+For one selector per point:
+
+```python
+mixed = runtime.evaluate(
+    points,
+    helicity_by_point=[
+        runtime.physics.helicity_ids[index % 2]
+        for index in range(len(points))
+    ],
+    color_flow_by_point=[
+        runtime.physics.color_flow_ids[(index // 2) % 2]
+        for index in range(len(points))
+    ],
+)
+```
+
+Batch-global and per-point selectors are mutually exclusive on the same axis.
+Per-point color selection is LC-only. Rusticol groups mixed selectors while
+returning values in original point order.
+
+See [Runtime and Selectors](runtime-and-selectors.md) for the complete selector
+contract.
+
+## Update model parameters
+
+```python
+runtime.set_model_parameters({"aS": 0.1165, "MZ": 91.1876})
+runtime.set_model_parameter("MT", 172.5)
+```
+
+Updates are atomic and refresh dependent derived parameters. Unknown,
+immutable, non-finite, or invalid values reject the entire update.
+
+`Runtime.load(..., model_parameters=...)` applies a complete mapping before the
+runtime is returned. Complex inputs may be represented as Python complex values.
+
+## Group equivalent subprocesses
+
+```python
+from pyamplicol.api import group_processes
+
+summary = group_processes("artifacts/pp_jj")
+for relation in summary["new_relations"]:
+    print(relation["process"], "=", relation["factor"], "x", relation["representative"])
+```
+
+`group_processes` evaluates each group representative stored in
+`process-groups.json` in f64 at three on-shell points, each with its own
+deterministic variation of up to 10% of the external and normalization model
+parameters other than masses and widths. Two subprocesses with the same
+external particle types are grouped when, through a leg permutation (and
+charge conjugation, unless `consider_charge_conjugation=False`), every
+resolved helicity and colour
+component of one is a common rational factor times the other's; numerator and
+denominator are at most 99 and `only_unit_multiplier=True` accepts only 1.
+Subprocesses generated with a selected helicity or colour subset are never
+grouped. The map is updated in place and rerunning adds nothing; the artifact
+ID and UMAMI files are unchanged. `analysis="none"` only writes the trivial map
+of an artifact that has none. This is the `pyamplicol group-processes`
+command; see [Process Grouping](process-grouping.md) for the details.
+
+## Precision
+
+```python
+f64 = runtime.evaluate(points, precision=16)
+high_precision = runtime.evaluate(points, precision=80)
+```
+
+For ordinary `evaluate` and `evaluate_resolved`, precision 16 uses the native
+Rusticol runtime without Symbolica computations. Package startup imports
+Symbolica to attempt registration of the pyAmpliCol library key; synchronous
+registration failures retain the personal-license and restricted-mode paths.
+Other positive precision requests load retained exact evaluator state when
+the artifact supports it.
+Decimal input preserves the supplied decimal digits;
+binary64 input cannot gain information merely by requesting more arithmetic
+precision.
+
+`evaluate_correlated` always uses retained Symbolica evaluator states through
+the separate Python exact executor, including at its default precision 16.
+Its default `arithmetic="arbitrary"` is distinct from the explicit
+`arithmetic="double-double", precision=31` mode; neither is selected by an
+ordinary native SDK precision flag.
+Its real and imaginary results remain `Decimal` values; `complex(value)` is an
+explicit conversion to ordinary double precision.
+
+Generated C/C++/Fortran/Rust standalone APIs support f64 (`precision=16`) only.
+
+## Profile from Python
+
+```python
+from pyamplicol import BenchmarkConfig, BenchmarkRunner
+
+config = BenchmarkConfig(
+    target_runtime=1.0,
+    batch_size=128,
+    precision=16,
+    warmup_runs=2,
+    minimum_samples=5,
+    color_flow_ids=("1",),
+)
+
+result = BenchmarkRunner(config).run(runtime, points=points)
+print(result.wall_time_per_point)
+print(result.evaluator_time_per_point)
+print(result.uncertainty.standard_error)
+print(result.uncertainty.relative_standard_error)
+```
+
+`BenchmarkResult` also contains calibrated repetitions, sample count,
+environment metadata, native timing breakdown, stage attribution, and work
+counters when the runtime exposes them.
+
+The runnable reference is
+[`examples/python/benchmark.py`](https://github.com/MadGraphTeam/pyamplicol/blob/main/examples/python/benchmark.py).
+
+## Convenience functions
+
+```python
+from pyamplicol import benchmark, generate, load
+
+generated = generate(
+    "d d~ > z g",
+    "artifacts/builtin_ddbar_to_zg",
+    model=ModelSource.built_in_sm(),
+    mode="replace",
+)
+runtime = load(generated.output)
+profile = benchmark(runtime, points=points)
+```
+
+The class-based services are preferable when reusing configuration, progress
+sinks, compiled models, or loaded runtimes.
+The one-shot `generate(...)` function also accepts the same
+`correlators=CorrelatorConfig(...)` keyword as `Generator.generate(...)`.
+
+## Errors
+
+All public failures derive from `PyAmpliColError`:
+
+```python
+from pyamplicol import EvaluationError, GenerationError, PyAmpliColError
+
+try:
+    runtime = Runtime.load("artifacts/pp_zjj", process="missing")
+except EvaluationError as error:
+    print(f"could not load runtime: {error}")
+```
+
+Useful subclasses include configuration, model, generation, artifact,
+compatibility, dependency, and evaluation errors. Catch the narrowest type you
+can handle; catch `PyAmpliColError` at an application boundary.
+
+## API design notes
+
+- Public result and metadata objects are immutable dataclasses or typed facades.
+- Artifact paths are normalized to absolute paths at service boundaries.
+- `Generator.generate(..., mode="error")` refuses an existing destination.
+- `Runtime` is bound to one selected process; load another instance for another
+  process in the same multiprocess artifact.
+- Process artifacts are trusted executable inputs. Normal loading validates the
+  schema, path confinement, references, target compatibility, and runtime ABI.
+- Use explicit payload validation only for an intentional whole-artifact
+  corruption audit; it is not required before every load.
+
+## Further reading
+
+- [Configuration](configuration.md)
+- [Generation Modes and Evaluators](generation-modes-and-evaluators.md)
+- [Runtime and Selectors](runtime-and-selectors.md)
+- [Born Correlations](../correlators.md)
+- [Correlation Conventions](../correlator-conventions.md)
+- [Artifacts and Portability](artifacts-and-portability.md)
+- [Native APIs](native-apis.md)
+
+<!-- Page hierarchy for the MadGraph7 (Sphinx) documentation. -->
+```{toctree}
+:hidden:
+
+runtime-and-selectors
+native-apis
+artifacts-and-portability
+umami-api
+../correlators
+../correlator-conventions
+```
diff --git a/pyamplicol/docs/user/quick-start.md b/pyamplicol/docs/user/quick-start.md
new file mode 100644
index 0000000000..4ffa5afc56
--- /dev/null
+++ b/pyamplicol/docs/user/quick-start.md
@@ -0,0 +1,213 @@
+---
+title: "Quick Start"
+nav_order: 1
+parent: "Installation"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Quick Start
+
+This tutorial follows the primary shipped example: generate a portable
+leading-color `p p > Z j j` artifact, select the concrete process
+`d d~ > g z g`, evaluate it, inspect its resolved components, and profile the
+same runtime path.
+
+## 1. Install and copy the examples
+
+```console
+python3 -m venv .venv
+. .venv/bin/activate
+python -m pip install pyamplicol
+
+pyamplicol examples copy ./pyamplicol-examples --force
+cd pyamplicol-examples
+```
+
+The copied directory is self-contained: it includes run cards, model resources,
+phase-space data, parameter cards, typed Python examples, and native driver
+sources.
+
+List the available packaged examples at any time:
+
+```console
+pyamplicol examples list
+pyamplicol examples run --help
+```
+
+## 2. Generate `p p > Z j j`
+
+```console
+pyamplicol generate_pp_zjj_from_ufo_sm.toml
+```
+
+The run card uses the packaged serialized UFO Standard Model, explicit
+two-flavor `p` and `j` multiparticles, leading color, and process-local compiled
+JIT O2 execution. The result is written to:
+
+```text
+artifacts/pp_zjj/
+```
+
+The inclusive request expands to ordered partonic candidates, merges candidates
+that differ only by a permutation within the incoming or outgoing side, and
+stores one representative per class. The loop-induced `g g > Z g g` candidate
+has no supported tree-level amplitude and is reported rather than generated.
+
+> Generation can take appreciably longer than evaluation because it constructs,
+> optimizes, validates, and serializes reusable evaluators.
+
+## 3. Inspect the artifact
+
+```console
+pyamplicol inspect artifacts/pp_zjj
+```
+
+The default terminal report uses colored tables for the artifact, model,
+runtime target, concrete processes, aliases, helicities, color flows, and
+payload inventory. Select one process for deeper physics metadata:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --process 'd d~ > g z g'
+```
+
+Machine-readable output is available without changing the artifact:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --json > inspection.json
+```
+
+## 4. Evaluate totals and resolved components
+
+```console
+pyamplicol evaluate_total.toml
+pyamplicol evaluate_resolved.toml
+```
+
+Both cards load `artifacts/pp_zjj`, apply the UFO parameter card in
+`data/model_parameters.json`, and read `data/pp_zjj_momenta.json`.
+
+- `evaluate_total.toml` calls the optimized fully summed runtime path.
+- `evaluate_resolved.toml` shows the physical helicity/color components and an
+  explicit per-point sum.
+
+The two totals agree. Nonzero matrix elements are displayed in scientific
+notation; exact zeros remain `0`. Add `--json` for scripts:
+
+```console
+pyamplicol evaluate_total.toml --json
+```
+
+## 5. Understand process ordering
+
+The artifact stores a representative process, but the runtime accepts a unique
+permutation within each side of the process arrow:
+
+```console
+pyamplicol evaluate artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json \
+  --model-parameters data/model_parameters.json
+```
+
+The input point is interpreted in the exact public ordering written in
+`--process`. Rusticol consistently remaps momenta, external-particle metadata,
+helicities, LC flows, selectors, reductions, and resolved outputs. No leg may
+cross `>`.
+
+If multiple stored representatives could match, selection fails with the
+candidate stable IDs instead of guessing. A stable ID such as
+`p_p_to_z_j_j_3` is always an unambiguous alternative.
+
+## 6. Profile the runtime
+
+```console
+pyamplicol benchmark.toml
+```
+
+This short profile uses the same optimized total path, a 128-point batch, two
+warmups, at least five measured blocks, and a one-second target. The human
+report separates headline wall/evaluator timing from native component
+attribution and work counters; rows with exactly zero measured time are omitted.
+
+The direct equivalent is:
+
+```console
+pyamplicol profile artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json \
+  --target-runtime 1.0 --batch-size 128 --color-flow 1 --precision 16
+```
+
+`pyamplicol benchmark` is a compatibility alias for `profile`.
+
+## 7. Use the Python runtime
+
+```python
+import json
+import math
+from pathlib import Path
+
+from pyamplicol import Runtime
+
+points = json.loads(Path("data/pp_zjj_momenta.json").read_text())
+runtime = Runtime.load(
+    "artifacts/pp_zjj",
+    process="d d~ > g z g",
+    model_parameters={"aS": 0.117},
+)
+
+total = runtime.evaluate(points)
+resolved = runtime.evaluate_resolved(points)
+
+print(runtime.physics.process)
+print(total[0])
+for optimized, explicit in zip(total, resolved.total(), strict=True):
+    assert math.isclose(optimized.real, explicit.real, rel_tol=1e-12, abs_tol=1e-15)
+    assert math.isclose(optimized.imag, explicit.imag, rel_tol=1e-12, abs_tol=1e-15)
+```
+
+The runtime exposes stable selector IDs:
+
+```python
+one_component = runtime.evaluate(
+    points,
+    helicities=[runtime.physics.helicity_ids[0]],
+    color_flows=[runtime.physics.color_flow_ids[0]],
+)
+```
+
+See [Python API](python-api.md) and [Runtime and Selectors](runtime-and-selectors.md)
+for typed results, per-point selectors, arbitrary precision, and benchmarking.
+
+## 8. Try a direct built-in-model command
+
+For a smaller single-process example:
+
+```console
+pyamplicol generate 'd d~ > z g' artifacts/builtin_ddbar_to_zg \
+  --model built-in-sm
+pyamplicol inspect artifacts/builtin_ddbar_to_zg
+```
+
+The built-in Standard Model automatically uses the wheel-owned prepared JIT O2
+kernel pack for the default recurrence execution mode.
+
+## 9. Try generated language APIs
+
+The generated `artifacts/pp_zjj/API/` tree contains standalone Python, C11,
+C++17, Fortran 2008, and Rust 2021 drivers. For example:
+
+```console
+python artifacts/pp_zjj/API/python/check_standalone.py \
+  --process 'd d~ > g z g' --set-parameter aS 0.117 0 --json
+```
+
+See [Native APIs](native-apis.md) for all five invocations, custom kinematics, and
+SDK discovery.
+
+## Where to go next
+
+- [Examples Gallery](examples-gallery.md) — choose another shipped card.
+- [Configuration](configuration.md) — adapt a TOML card or use direct CLI overrides.
+- [Models and Processes](models-and-processes.md) — load your own JSON/UFO model.
+- [Artifacts and Portability](artifacts-and-portability.md) — understand schema-v3 artifacts, portable compiled JIT O1/O2, and prepared O2 packs.
+- [Profiling Campaigns](profiling-campaigns.md) — run reproducible multi-process measurements.
diff --git a/pyamplicol/docs/user/release-and-support.md b/pyamplicol/docs/user/release-and-support.md
new file mode 100644
index 0000000000..5e419d31d2
--- /dev/null
+++ b/pyamplicol/docs/user/release-and-support.md
@@ -0,0 +1,300 @@
+---
+title: "Release and Support"
+nav_order: 5
+parent: "Profiling and Benchmarking"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Release and Support
+
+pyAmpliCol 1.0.0 is the software release accompanying the official arXiv
+publication, *pyAmpliCol: fast tree-level matrix elements*. Binary wheels and a
+source distribution are available on [PyPI](https://pypi.org/project/pyamplicol/).
+This page records the supported release boundary and explains how to report a
+problem.
+
+## Releases with MadGraph7
+
+pyAmpliCol is now developed in the
+[MadGraph7 repository](https://github.com/MadGraphTeam/MadGraph7/tree/main/pyamplicol)
+and released with MadGraph7: every MadGraph7 release publishes pyAmpliCol to
+PyPI with the same version number. These versions (0.2.x and later) sort below
+the standalone 1.0.x releases described below, so a plain
+`pip install pyamplicol` may still select 1.0.1; MadGraph7 always installs the
+exact matching version, `pyamplicol==<MadGraph7 version>`. Report problems in
+the [MadGraph7 issue tracker](https://github.com/MadGraphTeam/MadGraph7/issues).
+
+## Current release boundary
+
+Version `1.0.1` is represented by the immutable
+[`v1.0.1` source snapshot](https://github.com/MadGraphTeam/pyamplicol/tree/v1.0.1),
+the [GitHub release](https://github.com/MadGraphTeam/pyamplicol/releases/tag/v1.0.1),
+and [PyPI release](https://pypi.org/project/pyamplicol/1.0.1/). Its validated
+inventory is one source distribution and three `cp311-abi3` wheels:
+
+- macOS 11 or newer on Apple silicon;
+- macOS 11 or newer on x86-64;
+- manylinux 2.28 on x86-64.
+
+The [release workflow](https://github.com/MadGraphTeam/MadGraph7/actions/workflows/release.yml)
+installs each wheel into a clean CPython 3.11 environment and exercises the
+Python, C11, C++17, Fortran 2008, and Rust 2021 APIs. It also runs a CPython
+3.14 abi3 smoke test, source preflight, and independent Fortran physics oracle.
+Publication uploads these already validated files without rebuilding them.
+
+Version 1.0.1 uses published Symbolica 3.0.0, SymJIT 2.26.4 and
+ufo-model-loader 1.0.0, as recorded in the dependency lockfiles. No local
+dependency source patches or unpublished wheels are needed.
+
+## 1.0.1 release
+
+Version `1.0.1` adds process grouping for multiprocess outputs. Subprocesses
+with equal matrix elements are recorded in a new `process-groups.json`
+artifact payload, with their leg permutation, rational factor, and charge
+conjugation. `--flavor-blind` generates one representative per flavour
+class, optionally including charge conjugation, and every other flavour
+remains selectable from Python, the CLI, and the native SDKs, which route it
+to its representative. `--analyze-process-groups numerical` and
+`pyamplicol group-processes` find further relations numerically.
+`pyamplicol inspect` and the generation summary display the groups, and UMAMI
+exports flavour-blind members through their representative. UFO multiparticle
+expansion now enumerates multisets and drops candidates that violate a charge
+conserved by every vertex, which renumbers the process IDs of compiled-model
+multiprocess requests. Artifacts written by 1.0.1 declare the new payload and
+require a 1.0.1 runtime. See [Process Grouping](process-grouping.md).
+
+## 1.0.0 release
+
+Version `1.0.0` preserves exact model constants, colour weights, and
+normalization factors through higher-precision evaluation. It also corrects
+native evaluation and retains the exact next-to-leading-colour generation
+shortcut. The release keeps the same supported platforms and Python versions.
+Tensor algebra and prepared models have been updated for the published
+Symbolica 3.0.0 API, including exact complex constants in the SymJIT bridge.
+Equivalent exact and floating-point coefficients are again recognized when
+selecting optimized recurrence kernels, including in the bundled SM and HEFT models.
+Batched recurrence evaluations now fill the already allocated SIMD-aligned
+workspace, avoiding unnecessarily small batches at higher multiplicities.
+Completed on-the-fly caches can be saved and restored through Python and every
+native SDK, without reconstructing the retained currents. See
+[saving an OTF warm cache](runtime-and-selectors.md#saving-an-otf-warm-cache).
+Symbolica's package license removes the need for a personal key for pyAmpliCol
+use; personal-license and restricted-mode fallbacks remain available.
+Compiled JIT O2 generation selects compressed code by default.
+
+## 0.2.0 release
+
+Version `0.2.0` adds exact symmetric-group FFT full-colour contraction,
+helicity-parametric recurrence and on-the-fly scheduling, built-in SM+HEFT and
+trusted UFO HEFT support, and the resumable fixed-helicity/helicity-sum FFT
+profiling workflow with its final comparison reports.
+See the runnable [scalar HEFT workflow](models-and-processes.md#built-in-scalar-heft-model)
+and the [FullColor FFT profiling guide](fullcolor-fft-profiling.md).
+
+## 0.1.4 release
+
+Version `0.1.4` adds on-the-fly generation and its explicit one-point
+`warm_up(...)` lifecycle, while retaining compiled, eager, and recurrence
+generation. It also ships progress-aware warm-up entry points for the Python,
+C, C++, Fortran, and Rust APIs and the packaged `p p > Z j j` OTF example.
+
+## Install a release
+
+```console
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install pyamplicol
+```
+
+Binary wheels include the Rust runtime and native SDK. Wheel users do not need
+a Rust compiler. A C, C++, Fortran, or Rust compiler is required only when
+compiling a consumer in that language against the included SDK.
+
+Verify the environment with:
+
+```console
+pyamplicol doctor
+pyamplicol self-test
+```
+
+Then run the primary example from an editable copy:
+
+```console
+pyamplicol examples copy ./pyamplicol-examples --force
+cd pyamplicol-examples
+pyamplicol generate_pp_zjj_from_ufo_sm.toml
+pyamplicol evaluate_total.toml
+```
+
+See [Installation](installation.md) and [Quick Start](quick-start.md).
+
+## What a release contains
+
+The release set consists of:
+
+- one source distribution;
+- supported-platform `cp311-abi3` wheels;
+- the Python extension and target-specific static Rusticol SDK in each wheel;
+- packaged model resources, examples, profiling-campaign templates, and user
+  documentation required by installed workflows.
+
+Source installation may work elsewhere, but a platform is not advertised as
+supported until its installed Python and native API matrix has passed.
+
+Rendered performance PDFs are repository documents, not PyPI wheel payloads or
+release-CI benchmarks. Their links intentionally point to the current `main`
+branch:
+
+- [MacBook M3 report](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/macbook_M3_pyAmpliCol.pdf)
+- [AMD EPYC report](https://github.com/MadGraphTeam/pyamplicol/blob/main/docs/performance_reports/EPYC_pyAmpliCol.pdf)
+
+## How artifacts are validated and published
+
+The authoritative release workflow builds and tests the source distribution
+and platform wheels. Deployment tests install each wheel into a clean
+environment and exercise the installed Python runtime and native SDK consumers.
+
+Publication then selects that already validated artifact run and uploads its
+exact files through PyPI Trusted Publishing. Upload does not rebuild packages.
+This keeps the tested and published bytes identical without adding a second
+release build.
+
+GitHub workflow history is available under
+[Actions](https://github.com/MadGraphTeam/pyamplicol/actions), and tagged source
+snapshots under [Releases](https://github.com/MadGraphTeam/pyamplicol/releases).
+
+## Compatibility promises
+
+- The public Python API is versioned and documented in the repository's API
+  contract.
+- The native public boundary is C ABI version 1; C++, Fortran, and safe Rust
+  wrappers sit on that ABI.
+- Run cards use schema version 1 and reject unknown fields.
+- Current process artifacts use schema version 3 and the current runtime
+  identity/ABI contract.
+- Internal generated-artifact formats are not automatically migrated. An old
+  artifact that lacks the current contract fails with regeneration guidance.
+
+Regenerate process artifacts with the installed version when upgrading across
+an artifact-contract change. Do not edit a manifest or executable payload by
+hand.
+
+## Supported and intentionally separate components
+
+- pyAmpliCol has no LHAPDF dependency.
+- Symbolica is required for model compilation, generation, and Python exact
+  paths; the default compatible f64 JIT runtime executes through SymJIT without
+  importing Symbolica.
+- Original AmpliCol is optional campaign/developer comparison infrastructure,
+  not an installed-package runtime dependency.
+- Source contributor builds and release builds have separate dependency
+  boundaries. Contributor candidate wheels are deliberately non-publishable.
+
+See [Symbolica and Licensing](symbolica-and-licensing.md),
+[Profiling Campaigns](profiling-campaigns.md), and
+[Artifacts and Portability](artifacts-and-portability.md).
+
+## Report a problem
+
+Use [GitHub Issues](https://github.com/MadGraphTeam/pyamplicol/issues) for a
+reproducible bug, compatibility failure, or documentation gap. Search existing
+issues first.
+
+Include the smallest information that distinguishes the failure:
+
+1. exact pyAmpliCol version and installation method;
+2. operating system, architecture, and Python version;
+3. the command or short Python snippet;
+4. the complete error message;
+5. whether the model is built-in, JSON, compiled, prepared, or trusted UFO;
+6. execution mode, backend, color accuracy, and process expression;
+7. output from `pyamplicol doctor` when installation or SDK discovery is
+   involved.
+
+Useful read-only captures are:
+
+```console
+pyamplicol doctor --json > doctor.json
+pyamplicol inspect ARTIFACT --json > inspect.json
+pyamplicol config resolve RUN_CARD.toml --json > config.json
+```
+
+Review these files before attaching them. Do not publish private model data,
+license keys, cluster paths, credentials, or an artifact you are not permitted
+to redistribute.
+
+For a generated native-driver failure, also include:
+
+```console
+rusticol-config --version
+rusticol-config --target
+rusticol-config --json
+```
+
+For a numerical report, provide the smallest kinematic point and parameter card
+that reproduces it, the selected stable ID or process expression, precision,
+and selectors. State whether the optimized total and explicit resolved sum
+disagree.
+
+## Triage checklist
+
+Before filing, try the focused check matching the symptom:
+
+| Symptom | First check |
+| --- | --- |
+| CLI/import failure | `pyamplicol doctor` |
+| Installation/runtime smoke | `pyamplicol self-test` |
+| Native headers or linker flags missing | Activate the environment, then `rusticol-config --json` |
+| Artifact target/ABI rejection | `pyamplicol inspect ARTIFACT` and regenerate with the current release |
+| Process expression not found | Inspect stable IDs; see [Process Selection and Permutations](process-selection-and-permutations.md) |
+| Selector rejected | Inspect the selected process's helicity/color capabilities |
+| Raw UFO/JSON fails in recurrence/eager/OTF | Prepare a compatible `.pyamplicol-model` bundle, or choose compiled mode |
+| High-precision Python failure | Confirm Symbolica availability and license; f64 is `--precision 16` |
+| Profiling result is surprising | Keep process, layout, selectors, batch, and precision fixed; see [Profiling and Benchmarking](profiling-and-benchmarking.md) |
+
+More symptom-specific help is in [Troubleshooting](troubleshooting.md).
+
+## Feature requests
+
+A useful feature request explains:
+
+- the physics or deployment workflow;
+- why existing model, generation, runtime, or selector APIs are insufficient;
+- the smallest representative process/model;
+- expected public behavior, including error behavior;
+- platform or performance constraints.
+
+Avoid attaching a complete private project when a small public model/process
+can demonstrate the need.
+
+## Contributing a fix
+
+Contributor setup is documented in [Installation](installation.md).
+The repository policy favors focused tests for a demonstrated failure plus one
+authoritative CI path. Changes should not add redundant manifests, repeated
+hashing, dependency revalidation, or unrelated release ceremony.
+
+Public API changes require corresponding documentation and typing coverage.
+Runtime or artifact changes require proportionate native tests; documentation-
+only changes do not justify rebuilding the platform release matrix.
+
+## Security and artifact trust
+
+Process artifacts are executable inputs. JIT applications are lowered to
+native code at load time, and C++/ASM artifacts may contain native libraries.
+Manifest validation establishes internal consistency and path confinement, not
+publisher identity. Generate artifacts yourself or obtain them through a
+trusted channel.
+
+Do not post a suspected security vulnerability publicly before maintainers can
+assess it. Use the repository's available private security-reporting channel if
+enabled; otherwise contact the maintainers through the organization channels
+without including exploit details in a public issue.
+
+## Links
+
+- [PyPI](https://pypi.org/project/pyamplicol/)
+- [GitHub releases](https://github.com/MadGraphTeam/pyamplicol/releases)
+- [Issue tracker](https://github.com/MadGraphTeam/pyamplicol/issues)
+- [License](https://github.com/MadGraphTeam/pyamplicol/blob/main/LICENSE)
+- [Third-party notices](https://github.com/MadGraphTeam/pyamplicol/blob/main/THIRD_PARTY_NOTICES.md)
diff --git a/pyamplicol/docs/user/runtime-and-selectors.md b/pyamplicol/docs/user/runtime-and-selectors.md
new file mode 100644
index 0000000000..03a0fffec6
--- /dev/null
+++ b/pyamplicol/docs/user/runtime-and-selectors.md
@@ -0,0 +1,708 @@
+---
+title: "Runtime and Selectors"
+nav_order: 1
+parent: "Python API"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Runtime and Selectors
+
+pyAmpliCol process artifacts are designed to be evaluated after generation,
+without rebuilding the model or process DAG. The Python `Runtime` and all
+native APIs use the same RustiCol execution layer, process resolver, selector
+planner, model-parameter state, and numerical conventions for ordinary
+evaluations.
+
+[Born Correlations](../correlators.md) use an opt-in, separate Python evaluator.
+They accept generation-time colour-operator IDs and runtime spin vectors, not
+the ordinary LC flow selector. This path currently supports full-colour SU(3)
+only, and requires the original generated particle ordering (no nonidentity
+aliases or automatic permutations). A process-group member is accepted only
+with that ordering and without charge conjugation; its factor is applied.
+
+> **Start here:** follow [Quick Start](quick-start.md) to create the example workspace and
+> generate `artifacts/pp_zjj`. See [Generation Modes and Evaluators](generation-modes-and-evaluators.md) for the generation
+> side of the workflow and [Artifacts and Portability](artifacts-and-portability.md) before moving an
+> artifact between machines.
+
+## Inspect before loading
+
+Inspection reads the artifact inventory without loading executable evaluator
+state:
+
+```console
+pyamplicol inspect artifacts/pp_zjj
+```
+
+The human view is a colored set of tables covering the artifact, model,
+runtime target, concrete processes, crossing aliases, particle order,
+helicities, color coverage, payload sizes, and dependencies. Use JSON for a
+machine-readable inventory:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --json > pp_zjj-inventory.json
+```
+
+For one process, either a stable ID or a process expression is accepted:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --process p_p_to_z_j_j_3
+pyamplicol inspect artifacts/pp_zjj --process 'd d~ > g z g'
+```
+
+For an on-the-fly artifact, this compact inventory reports the physical
+selector census, requested query-construction workers, and binary64-only
+runtime without instantiating the runtime or enumerating a dense selector
+axis. That metadata-only view is the safe default at high multiplicity. Ask
+for the legacy fully materialized physics view only when its complete selector
+catalog is genuinely needed:
+
+```console
+pyamplicol inspect artifacts/otf_pp_zjj \
+  --process 'd d~ > g z g' --full-physics
+```
+
+`--full-physics` loads executable evaluator state and can be factorially large
+in the number of colored legs.
+
+## Load a process from Python
+
+```python
+from pyamplicol import Runtime
+
+runtime = Runtime.load(
+    "artifacts/pp_zjj",
+    process="d d~ > g z g",
+)
+
+print(runtime.execution_mode)  # compiled, eager, recurrence, or on-the-fly
+print(runtime.artifact_id)             # 64 lowercase hexadecimal characters
+print(runtime.physics.process)         # requested public particle order
+print(runtime.physics.external_particles)
+print(runtime.physics.helicity_ids)
+print(runtime.physics.color_flow_ids)
+```
+
+If an artifact contains only one process, `process=` may be omitted. For a
+multiprocess artifact, make the selection explicit so the chosen public
+particle order is obvious at the call site.
+
+## Process expressions and automatic permutations
+
+Selection is resolved in this order:
+
+1. stable process ID;
+2. explicit alias ID;
+3. exact stored process expression;
+4. exact stored alias expression;
+5. a unique permutation-equivalent expression.
+
+Incoming and outgoing particles are matched independently. A particle never
+crosses the `>` boundary. Repeated identical particles use deterministic
+first-unused matching. If several stored representatives would fit, loading
+fails and reports their stable IDs instead of guessing.
+
+For example, the representative `p_p_to_z_j_j_3` is stored for one ordering,
+but this is a valid public selection:
+
+```python
+runtime = Runtime.load(
+    "artifacts/pp_zjj",
+    process="d d~ > g z g",
+)
+```
+
+Rusticol then applies one central side-preserving permutation to all public
+axes:
+
+- input four-momenta and external PDGs;
+- external-particle metadata;
+- helicity IDs, vectors, representatives, and selectors;
+- leading-color flow words, IDs, replay labels, and selectors;
+- reduction groups and resolved output metadata;
+- compiled, eager, recurrence, on-the-fly, scalar/SIMD, and Python exact
+  execution.
+
+Consequently, momenta supplied to this runtime must follow `d, d~, g, z, g`,
+not the representative's internal order.
+
+A sixth step resolves processes that a `--flavor-blind` generation did not
+generate but listed in the artifact's process-group map. Such a member is
+evaluated by its representative at the composed permutation, with every
+matrix element multiplied by the member's exact factor. A charge-conjugated
+member reverses each LC flow word, so its flow IDs and selectors are the
+member's own:
+
+```python
+runtime = Runtime.load("artifacts/qg", process="u~ g > u~ g")
+print(runtime.representative_process_key)
+print(runtime.process_group_factor, runtime.charge_conjugated)
+```
+
+Every other selection reports `process_group_factor == 1` and
+`charge_conjugated is False`. See
+[Process-group members](process-selection-and-permutations.md#process-group-members).
+
+## Momenta
+
+Python accepts a batch with shape
+`(point, external particle, [E, px, py, pz])`. A single five-particle point is
+therefore wrapped in one outer batch dimension:
+
+```python
+momenta = [[
+    [500.0, 0.0, 0.0, 500.0],
+    [500.0, 0.0, 0.0, -500.0],
+    [462.6501613061637, 14.340107538562991,
+     155.76435943335707, -425.7484539710246],
+    [369.7738416261408, -17.479290785282917,
+     2.0064955613504103, 369.3550355960509],
+    [167.57599706769557, 3.1391832467199254,
+     -157.77085499470743, 56.3934183749737],
+]]
+```
+
+The fourth-vector convention is `[E, px, py, pz]`. The particle axis follows
+the expression passed to `Runtime.load()`.
+
+The CLI reads the same shape from JSON:
+
+```console
+pyamplicol evaluate artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json
+```
+
+## Model parameters
+
+Inspect mutable external parameters and their defaults before applying an
+update:
+
+```python
+for parameter in runtime.physics.model_parameters:
+    if parameter.mutable:
+        print(parameter.name, parameter.default_real)
+```
+
+Mutable external model parameters can be set while loading:
+
+```python
+runtime = Runtime.load(
+    "artifacts/pp_zjj",
+    process="d d~ > g z g",
+    model_parameters={"aS": 0.117, "MZ": 91.188},
+)
+```
+
+They can also be updated atomically later:
+
+```python
+runtime.set_model_parameters({"aS": 0.1165, "MZ": 91.1876})
+runtime.set_model_parameter("MT", 172.5)
+```
+
+Derived couplings and dependent parameters are refreshed before the update is
+committed. If any name is unknown or immutable, or any value is invalid or
+non-finite, the complete update is rejected.
+
+A parameter card is a flat JSON object matching a serialized UFO restriction:
+
+```json
+{
+  "aS": 0.117,
+  "MZ": 91.188,
+  "complex_external_parameter": [1.0, -0.25]
+}
+```
+
+The generated standalone API drivers apply card values first, then let repeated
+`--set-parameter NAME REAL IMAG` options override them. The main CLI accepts
+the card through `--model-parameters`; Python callers pass a mapping while
+loading or use the setters shown above. See
+[Models and Processes](models-and-processes.md) for model compilation and card
+production.
+
+## Total and resolved evaluation
+
+The optimized total returns one value per input point:
+
+```python
+total = runtime.evaluate(momenta)
+```
+
+The resolved path exposes the physical axes retained in the artifact:
+
+```python
+resolved = runtime.evaluate_resolved(momenta)
+
+for optimized, explicit in zip(total, resolved.total(), strict=True):
+    scale = max(1.0, abs(optimized))
+    assert abs(optimized - explicit) <= 1.0e-12 * scale
+
+print(resolved.shape)
+print(resolved.helicity_ids)
+print(resolved.color_flow_ids)
+```
+
+At leading color (LC), the resolved shape is `(point, helicity, physical
+color flow)`. At NLC and full color, color is contracted and the final axis has
+length one. That contracted singleton is output metadata, not a selectable LC
+flow.
+
+Human CLI output uses colored tables and scientific notation; add `--json` only
+when a machine-readable representation is wanted.
+
+## Batch-global selectors
+
+Stable IDs come from `runtime.physics`:
+
+```python
+helicity = runtime.physics.helicity_ids[0]
+flow = runtime.physics.color_flow_ids[0]
+
+selected_total = runtime.evaluate(
+    momenta,
+    helicities=[helicity],
+    color_flows=[flow],
+)
+
+selected_resolved = runtime.evaluate_resolved(
+    momenta,
+    helicities=[helicity],
+    color_flows=[flow],
+)
+```
+
+`--helicity` accepts a stable helicity ID. `--color-flow` accepts either a
+stable flow ID or a one-based advertised position; for example,
+`--color-flow 1` selects the first physical LC flow.
+
+Color-flow selection is LC-only. NLC/full accept helicity selectors and reject
+color-flow selectors.
+
+## Stay on the generated LC layout's optimized workload
+
+LC artifacts retain the layout chosen during generation. Runtime selectors do
+not switch an artifact from one layout to the other. Inspect the complete
+artifact first; its process-execution table includes an `LC flow layout` row:
+
+```console
+pyamplicol inspect artifacts/my_process
+```
+
+Then invoke `Runtime.evaluate()` with the selector pattern that matches that
+layout:
+
+| Generated LC layout | Supply | Deliberately omit | Optimized total computed per point |
+| --- | --- | --- | --- |
+| `topology-replay` (non-union) | exactly one color-flow ID | helicity selector | selected flow, summed over all physical helicities |
+| `all-flow-union` | exactly one helicity ID | color-flow selector | selected helicity, summed over all physical flows |
+
+For the default `topology-replay` layout:
+
+```python
+flow = runtime.physics.color_flow_ids[0]
+
+single_flow_helicity_sum = runtime.evaluate(
+    momenta,
+    color_flows=(flow,),
+    precision=16,
+)
+```
+
+The equivalent CLI call uses one stable flow ID, or the one-based position
+shown by `inspect`:
+
+```console
+pyamplicol evaluate artifacts/my_process \
+  --process 'd d~ > g z g' \
+  --momenta data/point.json \
+  --precision 16 \
+  --no-resolved \
+  --color-flow 1
+```
+
+For an artifact generated with `lc_flow_layout = "all-flow-union"`:
+
+```python
+helicity = next(
+    item
+    for item in runtime.physics.helicities
+    if item.computed and not item.structural_zero
+)
+
+all_flows_single_helicity = runtime.evaluate(
+    momenta,
+    helicities=(helicity,),
+    precision=16,
+)
+```
+
+The CLI form uses the stable helicity ID printed by `inspect`:
+
+```console
+pyamplicol evaluate artifacts/my_union_process \
+  --process 'd d~ > g z g' \
+  --momenta data/point.json \
+  --precision 16 \
+  --no-resolved \
+  --helicity 'h:-1,+1,-1,+1,+1'
+```
+
+For a mixed batch, `color_flow_by_point=(...)` with no helicity selector is the
+per-point form of the topology-replay workload;
+`helicity_by_point=(...)` with no color-flow selector is the per-point form of
+the all-flow-union workload.
+
+To sample one helicity and one LC flow from a helicity-generic output, select
+both axes at runtime:
+
+```python
+single_flow_single_helicity = runtime.evaluate(
+    momenta,
+    helicities=(helicity,),
+    color_flows=(flow,),
+    precision=16,
+)
+```
+
+With `topology-replay`, recurrence prepares and caches the current dependencies
+needed by the selected helicity and flow. Compiled evaluation selects the
+corresponding colour and helicity sub-schedules instead of computing an
+all-colour companion. The output still supports every generated helicity:
+changing the runtime selectors requires no regeneration. Shared currents and
+physical helicity/flow relabellings are preserved. Omitting the helicity
+selector retains the existing helicity-summed evaluation path.
+
+Use the same selectors with the public profiler to time the warmed, batched
+single-flow/single-helicity workload:
+
+```console
+pyamplicol profile artifacts/my_process \
+  --color-flow 1 --helicity 'h:-1,+1,-1,+1,+1' \
+  --batch-size 128 --precision 16
+```
+
+Other selector combinations remain valid when the output has the required
+coverage. Omitting the layout's required selector asks for a broader sum. Use
+`Runtime.evaluate()` at `precision=16` for the optimized native total;
+`evaluate_resolved()` and higher precision are diagnostic/exact paths rather
+than that benchmarked execution unit.
+
+These two stored layouts apply to recurrence, compiled, and eager artifacts.
+Those modes can also fix flow IDs, helicity IDs, or both during generation when
+a deliberately specialized artifact is preferable. OTF does not materialize a
+layout or use generation-time specialization: one compact artifact builds the
+family implied by the runtime selectors and retains only the last selected
+family. Its practical high-multiplicity target is one selected LC flow summed
+over all helicities. See
+[LC workloads and execution modes](lc-workloads-and-execution-modes.md) for the
+physical distinction and call signatures.
+
+### Omitted selectors and requesting every entry
+
+The meaning of omission depends on the operation:
+
+- `Runtime.evaluate(momenta)` omits both axes and therefore sums every retained
+  physical helicity and color flow: it is the complete matrix element.
+- Profiling with both selector lists empty asks pyAmpliCol to choose the stored
+  layout's deterministic hot workload described above.
+- A complete explicit list on the layout's summed axis is equivalent to
+  omission and still permits the optimized selector to be inferred. A subset
+  on that axis is preserved and prevents inference.
+- An explicit list on the layout's selected axis is always intentional. A
+  complete list there requests the broader all-entry workload rather than
+  being replaced by one inferred selector.
+
+There is deliberately no magic `all` selector token. To profile every member
+of an axis explicitly, pass the complete stable-ID tuple exposed by process
+metadata. For example, either of these requests the all-helicity/all-flow LC
+total while making the intent unambiguous to the profiler:
+
+```python
+from pyamplicol import BenchmarkConfig, BenchmarkRunner
+
+# Natural explicit-all spelling for a topology-replay artifact.
+topology_all = BenchmarkRunner(
+    BenchmarkConfig(color_flow_ids=runtime.physics.color_ids)
+).run(runtime, points=momenta)
+
+# Natural explicit-all spelling for an all-flow-union artifact.
+union_all = BenchmarkRunner(
+    BenchmarkConfig(helicity_ids=runtime.physics.helicity_ids)
+).run(runtime, points=momenta)
+```
+
+Those are valid broader workloads and consequently emit the non-hot warning.
+For CLI profiling, read the stable IDs from `pyamplicol inspect` and repeat the
+option once per entry, for example
+`--color-flow FLOW_1 --color-flow FLOW_2 ...` or
+`--helicity HELICITY_1 --helicity HELICITY_2 ...`. Color-flow one-based
+ordinals may be repeated instead of stable flow IDs. Supplying complete lists
+on both axes is also valid, but redundant. The complete list on the selected
+axis is the part that makes the all-entry profiling intent explicit.
+
+## One selector per point
+
+Complete-coverage artifacts may mix selectors inside one batch:
+
+```python
+mixed = runtime.evaluate(
+    momenta_batch,
+    color_flow_by_point=[
+        runtime.physics.color_flow_ids[i % 2]
+        for i in range(len(momenta_batch))
+    ],
+    helicity_by_point=[
+        runtime.physics.helicity_ids[(i // 2) % 2]
+        for i in range(len(momenta_batch))
+    ],
+)
+```
+
+Rusticol stably groups equal selectors to preserve contiguous SIMD work, then
+restores caller order. A batch-global selector and a per-point selector cannot
+be supplied on the same axis. Per-point selection is available for optimized
+totals; rectangular `evaluate_resolved()` uses batch-global axes.
+
+## Explicit OTF warm-up
+
+OTF exposes its cold structural work through `warm_up(...)`. The call accepts
+exactly one phase-space point at native binary64 precision and the same
+batch-global selectors as `evaluate(...)`:
+
+```python
+import sys
+
+from pyamplicol import Runtime
+from pyamplicol.reporting import close_progress_sink, progress_sink
+
+runtime = Runtime.load("artifacts/otf_pp_zjj", process="d d~ > g z g")
+point = points[0]  # one [external particle][E, px, py, pz] point
+flow = runtime.physics.color_flows[0]
+progress = progress_sink("auto", stream=sys.stderr, color=True)
+try:
+    result = runtime.warm_up(
+        (point,),
+        precision=16,
+        color_flows=(flow,),
+        n_cores=4,
+        progress=progress,
+    )
+finally:
+    close_progress_sink(progress)
+```
+
+Warm-up never uses the later profiling batch: passing 128 points, or any
+precision other than `16`, is rejected. It builds the selected query family,
+retains it on this runtime handle, and genuinely evaluates the supplied point.
+Repeating the same request reuses the family but still performs that required
+one-point evaluation. The returned `WarmUpResult` records elapsed time, total
+and newly built query counts, cache reuse, and sampled memory.
+
+The optional positive integer `n_cores` bounds the workers constructing query
+traces in parallel. Completed traces are merged into the shared cache serially;
+family finalization and the first evaluation also remain serial. More workers
+use additional temporary memory, and the speed-up depends on the selected
+family. Omit `n_cores` (or pass `None`) to use the process output's
+`evaluator.optimization.cores` setting. This override applies only to this
+warm-up call: it is not saved in the cache, does not change subsequent
+evaluation threading, and does not rebuild an already-warm family.
+
+The optional progress stream separates process preparation, query-family
+construction, family finalization, and first evaluation. It includes completed
+query counts, construction workers, and current/peak resident memory when the
+platform exposes them. With no observer, warm-up performs no progress callback
+or memory-sampling work.
+
+The cache is handle-local and last-family-only: successfully selecting another
+flow or helicity replaces the previously warmed family. LC accepts flow and
+helicity selectors; contracted NLC/full accepts helicity selectors only.
+`runtime.clear()` returns a Python OTF handle to cold state while keeping its
+artifact and current model parameters loaded. Closing/freeing a native handle
+releases all of its warm state. C, C++, Fortran, and Rust expose the same four
+stages through a fixed-layout optional callback; see
+[Native APIs](native-apis.md) and the complete
+[OTF lifecycle walkthrough](lc-workloads-and-execution-modes.md#the-otf-warm-state-lifecycle).
+
+## Saving an OTF warm cache
+
+`save(path)` writes the completed OTF cache; `load_cache(path)` restores it
+into a runtime loaded from the matching process output. Both return `None`.
+For a small example, generate a four-gluon process with generic helicity and
+flow coverage:
+
+```console
+pyamplicol generate "g g > g g" artifacts/otf_gg_gg \
+  --model built-in-sm --color-accuracy lc --execution-mode on-the-fly
+```
+
+Then warm one LC flow, summed over all helicities, and save it:
+
+```python
+from pyamplicol import Runtime
+
+point = (
+    (500.0, 0.0, 0.0, 500.0),
+    (500.0, 0.0, 0.0, -500.0),
+    (500.0, 300.0, 0.0, 400.0),
+    (500.0, -300.0, 0.0, -400.0),
+)
+runtime = Runtime.load("artifacts/otf_gg_gg")
+flow = runtime.physics.color_flows[0].id
+selection = {"color_flows": (flow,)}  # no helicity selector: sum helicities
+runtime.warm_up((point,), **selection)
+runtime.save("gg.otf-cache")
+
+# This can instead be done in a later Python session.
+restored = Runtime.load("artifacts/otf_gg_gg")
+restored.load_cache("gg.otf-cache")
+report = restored.warm_up((point,), **selection)
+assert report.already_warm and report.warmed_query_count == 0
+values = restored.evaluate((point, point), **selection)
+print(values)
+```
+
+The example repeats its point only to keep the two-point batch short; a later
+batch may contain different momenta. A successful ordinary `evaluate(...)`
+also leaves saveable state, so explicit `warm_up(...)` is optional. The extra
+warm-up after restoration above demonstrates cache reuse and can be omitted.
+Keep the same selectors when reusing the saved family: `load_cache` restores
+cached work, not new defaults for subsequent `evaluate` calls.
+
+Both methods are OTF-only. The same operations are available through the
+[native APIs](native-apis.md#saving-and-restoring-an-otf-cache).
+The snapshot contains the retained structural calculation, including its
+helicity/colour selection and reduction mappings. It supports selected LC
+requests, helicity/flow sums, and contracted NLC/full-colour families, with
+either direct colour contraction or FFT where the original process supports it.
+
+Restoration skips current construction and binds the saved schedule to the
+prepared kernels in the matching process output. It does not save evaluated
+currents, native pointers or numeric workspaces. New momenta and batch sizes
+are supported, and the receiving runtime keeps its current model parameters.
+The original process output is still required; the cache is not a standalone
+process export. Incompatible process outputs or snapshot formats are rejected
+without replacing the receiving runtime's existing cache.
+
+The cache path names a file (its parent directory must already exist). Saving
+again replaces that file; a failed save leaves any previous complete file
+intact. Empty caches and completed zero-valued selections are also saveable.
+
+Saving does not change the running handle or its warmed evaluation path.
+It saves the state currently retained, not a history of evicted selections.
+A different selection after restoration follows the usual OTF construction
+and replacement rules. This is a completed-state snapshot, not a checkpoint
+of an unfinished warm-up.
+
+## Precision
+
+For ordinary evaluation, `precision=16` uses the native f64 RustiCol runtime. Direct JIT artifacts load
+the separate MIT-licensed SymJIT runtime; compatible C++ and ASM artifacts load
+their native evaluator libraries. None of these f64 paths imports Symbolica or
+checks a Symbolica runtime license.
+
+The separate `evaluate_correlated` method uses retained Symbolica evaluator
+states at every requested precision, including 16; see
+[Born Correlations](../correlators.md).
+
+Python may request another positive decimal precision:
+
+```python
+high_precision = runtime.evaluate(momenta, precision=80)
+```
+
+This higher-precision path exists only when the artifact retains an exact
+evaluator. OTF artifacts are native-f64-only and reject every precision other
+than `16` in Python as well as in the native APIs.
+
+That path lazily loads retained Symbolica evaluator state and is therefore
+subject to Symbolica availability and licensing. Decimal inputs retain their
+digits. Values first supplied as binary64 do not acquire new physical
+information simply because a larger arithmetic precision is requested.
+Results are rounded to the requested decimal precision after guard-digit
+evaluation. Derived model parameters and couplings are reevaluated from their
+retained symbolic definitions at this precision, including constants such as
+pi. Coupling powers and combinatorial normalization factors are also evaluated
+in the requested arithmetic, rather than copied from the native f64 result.
+Generated full-colour and NLC contraction weights also retain their rational
+coefficients for higher-precision evaluation; native evaluation continues to
+use their binary64 values.
+This matters when subtracting matrix elements at different multiplicities.
+
+After updating from a version that rounded these definitions during generation,
+regenerate the prepared model and process output: increasing `precision` cannot
+repair coefficients already rounded in an older output. The prepared-model
+compiler version rejects incompatible bundled kernels. The public
+`precision=32` call uses guarded arbitrary precision, not a dedicated
+double-double runtime. See
+[Symbolica and Licensing](symbolica-and-licensing.md).
+
+Native C, C++, Fortran, and Rust APIs expose f64 only. Their shared SDK is
+covered in [Native APIs](native-apis.md).
+
+## Profiling one runtime
+
+Profile the same optimized total path used by `Runtime.evaluate()`:
+
+```console
+pyamplicol profile artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json \
+  --target-runtime 1.0 \
+  --batch-size 128 \
+  --color-flow 1 \
+  --precision 16
+```
+
+If both profiling selector axes are omitted, pyAmpliCol derives one
+deterministic selector matching the stored hot layout. Explicit subsets and
+selected-axis lists are preserved; a complete summed-axis list is normalized
+to equivalent omission as described above. A valid non-hot profile instead
+emits at most one pre-loop warning per loaded process. This profiling
+convenience does not change the complete-matrix-element default of
+`Runtime.evaluate()`.
+
+For OTF, the profiler first snapshots the compact native runtime census, times
+one requested-selector evaluation over the configured benchmark batch, and
+then authenticates that the family is retained before ordinary configured
+warmups begin. The result records whether the starting handle was cold or
+already warm. This implicit profiling preparation is distinct from the public
+one-point `warm_up(...)` API and is reported separately; neither preparation
+time nor configured warmups are folded into the steady-state wall samples.
+
+A retained structural-zero request intentionally has no amplitude destination,
+executor handle, semantic binding, or active family-union census. The profiler
+recognizes that as a valid retained state instead of inventing executable work.
+OTF native attribution labels the narrower recurrence-schedule core separately
+from the complete evaluator envelope and from recurrence mode's statically
+generated core.
+
+The headline wall time is sampled independently of the paired native
+attribution pass. `evaluator total` is a minimally instrumented complete
+evaluator call. Native component rows describe a separate profiled pass and
+must not be subtracted from that headline as though they were measured in one
+identical call. `pyamplicol benchmark` is a compatibility alias for `profile`.
+
+For controlled, multi-process comparisons and report generation, use
+[Profiling Campaigns](profiling-campaigns.md) instead.
+
+## Handle ownership and warnings
+
+Parameter and warning state belongs to one runtime handle. Do not invoke the
+same mutable handle concurrently. Independent handles may execute on separate
+threads.
+
+Artifacts are trusted executable inputs. Generate them yourself or obtain
+them through a trusted channel; content hashes establish internal consistency,
+not publisher identity. See [Artifacts and Portability](artifacts-and-portability.md) for the fast load
+boundary and optional explicit checksum audit.
+
+## Related pages
+
+- [Quick Start](quick-start.md) — generate and evaluate the primary example.
+- [Python API](python-api.md) — typed generation, model, and benchmark interfaces.
+- [Native APIs](native-apis.md) — C11, C++17, Fortran 2008, and Rust 2021.
+- [LC workloads and execution modes](lc-workloads-and-execution-modes.md) — LC
+  call shapes and the OTF warm-state lifecycle.
+- [Troubleshooting](troubleshooting.md) — missing artifacts, target mismatches, and stale source
+  environments.
diff --git a/pyamplicol/docs/user/symbolica-and-licensing.md b/pyamplicol/docs/user/symbolica-and-licensing.md
new file mode 100644
index 0000000000..7b70a189c9
--- /dev/null
+++ b/pyamplicol/docs/user/symbolica-and-licensing.md
@@ -0,0 +1,322 @@
+---
+title: "Symbolica and Licensing"
+nav_order: 1
+parent: "Architecture Overview"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Symbolica and Licensing
+
+pyAmpliCol uses Symbolica for symbolic model compilation and process
+generation, but its default f64 deployment path is deliberately separated from
+Symbolica's runtime. This page explains the technical boundary and summarizes
+where to read the authoritative license terms.
+
+> This page is a technical guide, not legal advice. Upstream license terms and
+> eligibility rules control. The complete notices distributed with pyAmpliCol
+> are in
+> [`THIRD_PARTY_NOTICES.md`](https://github.com/MadGraphTeam/pyamplicol/blob/main/THIRD_PARTY_NOTICES.md)
+> and the repository's `licenses/` directory.
+
+## Package license at startup
+
+Importing pyAmpliCol imports Symbolica and calls `symbolica.set_library_key()`
+with the key issued for the `pyamplicol` package, before any symbolic work.
+When that key is accepted and valid, users do not need a personal Symbolica
+license for calls made by pyAmpliCol, including parallel generation and
+evaluator optimization. Registration is also attempted when a spawned Python
+worker imports pyAmpliCol.
+
+```python
+import sys
+import pyamplicol
+
+print("symbolica" in sys.modules)  # True
+
+from pyamplicol.licensing import detect_symbolica_license
+print(detect_symbolica_license(suggest=False).licensed)  # Actual license state
+```
+
+If Symbolica is not installed, lightweight configuration and source tooling
+remain available; operations requiring Symbolica still report the missing
+dependency. Broken native extensions or other unexpected import errors are
+not suppressed.
+
+The key licenses calls within `pyamplicol`; it does not license unrelated
+Symbolica code in the user's program. Personal license environment variables
+are left unchanged. Model compilation and generation tooling remain lazy.
+
+If registration raises `ValueError` or `PermissionError`, or an older
+Symbolica lacks `set_library_key()`, import continues. Symbolica's public
+`is_licensed()` check then decides whether a valid personal license permits
+normal operation or restricted resources are needed; a nonempty
+`SYMBOLICA_LICENSE` alone is not proof of validity. Personal-license
+configuration and the existing license-request helpers remain available.
+
+This fallback covers synchronous registration failures, not all later
+revocations. Symbolica may terminate the process during asynchronous license
+verification; pyAmpliCol cannot catch that upstream termination and switch
+licenses in the same process.
+
+The startup import and registration temporarily suppress Symbolica's banner
+before CLI output policy is known, then restore the caller's banner setting.
+Normal reminder suppression and JSON output behavior remain unchanged.
+
+## Which operations need Symbolica?
+
+| Operation | Uses Symbolica? | Notes |
+| --- | --- | --- |
+| Import `pyamplicol` | Yes | Registers the package key; public exports remain lazy. |
+| Inspect an artifact | Startup only | Reads metadata and indexes only. |
+| Ordinary Python f64 evaluation (`precision=16`) | Startup only | Runs through Rusticol and the artifact's native evaluator. |
+| C11/C++17/Fortran 2008/Rust 2021 runtime | No | Ordinary and opt-in correlated APIs are f64-only. |
+| Direct JIT f64 load | Startup only in Python | Uses the separate MIT-licensed SymJIT runtime. |
+| Compatible C++/ASM evaluator load | Startup only in Python | Uses the artifact's target-native library. |
+| Compile a JSON/UFO model | Yes | Symbolic model construction. |
+| Generate a process artifact | Yes | Symbolic DAG/recurrence construction and evaluator production. |
+| Ordinary Python precision other than 16 | Yes | Lazily loads retained Symbolica evaluator state when supported. |
+| Python `evaluate_correlated(...)` | Yes | Uses retained Symbolica evaluator state at every precision, including 16. |
+
+The absence of a Symbolica runtime dependency for f64 evaluation does not
+change the terms governing Symbolica use during generation.
+
+## Direct-JIT f64 runtime
+
+The default JIT backend embeds a direct SymJIT application in the schema-v3
+artifact. Rusticol loads and lowers that application to native code without:
+
+- performing Symbolica computations (Python package startup registers the key);
+- reading `SYMBOLICA_LICENSE`;
+- applying Symbolica's generation-time worker clamp;
+- linking the arbitrary-precision Symbolica/Rug/Malachite closure into the
+  wheel's f64 native SDK.
+
+This is the deployment path shared by ordinary Python evaluation at precision
+16 and the C11, C++17, Fortran 2008, and Rust 2021 APIs.
+
+```python
+from pyamplicol import Runtime
+
+runtime = Runtime.load("artifacts/pp_zjj", process="d d~ > g z g")
+values = runtime.evaluate(momenta, precision=16)
+```
+
+Independent runtime handles can execute concurrently even when their artifact
+was generated under restricted Symbolica conditions. Do not call one mutable
+handle concurrently because its parameter and warning state is handle-local.
+
+See [Runtime and Selectors](runtime-and-selectors.md) and [Native APIs](native-apis.md).
+
+## Generation with a valid license
+
+pyAmpliCol calls `symbolica.is_licensed()` from inside the package to select
+its generation resources. This detects a valid registered package key even
+when `SYMBOLICA_LICENSE` is absent, or a valid personal license. A call from
+unrelated user code can still return `False`, because the package key is scoped
+to pyAmpliCol.
+
+With a valid license, automatic resource settings share one affinity-aware CPU
+budget:
+
+```toml
+[generation]
+workers = "auto"
+
+[evaluator.optimization]
+cores = "auto"
+```
+
+Concurrent process builds receive disjoint evaluator budgets. Explicit
+requests are clamped when their product exceeds the available budget, and the
+requested/effective difference is recorded in generation provenance.
+
+## Restricted generation
+
+Without a valid package or personal license, pyAmpliCol offers a
+license-request reminder. Users whose work is eligible under Symbolica's
+current terms can continue in restricted mode. Symbolica describes that mode
+as non-commercial, one instance, and one core per device; commercial work
+requires the applicable professional license path.
+
+pyAmpliCol enforces a technical clamp of one process worker and one Symbolica
+core and records why the requested configuration changed. That clamp does not
+grant eligibility or replace upstream terms.
+
+Suppress the request reminder and Symbolica startup banner when appropriate:
+
+```console
+pyamplicol generate_pp_zjj_from_ufo_sm.toml \
+  --no-symbolica-suggestion
+```
+
+or in a run card:
+
+```toml
+[symbolica]
+suggest_license = false
+```
+
+JSON CLI output suppresses the banner automatically so stdout remains valid
+machine-readable JSON.
+
+## Requesting a personal license
+
+Personal licenses remain useful if the package key is unavailable or for
+Symbolica work outside pyAmpliCol. Interactive helpers collect the fields,
+show a confirmation, and submit through Symbolica's Python API:
+
+```console
+pyamplicol request-symbolica-trial-license
+pyamplicol request-symbolica-hobbyist-license
+```
+
+Complete noninteractive requests require all fields and `--yes`:
+
+```console
+pyamplicol request-symbolica-trial-license \
+  --name "Ada Lovelace" \
+  --email ada@example.org \
+  --organization "Example Institute" \
+  --yes
+
+pyamplicol request-symbolica-hobbyist-license \
+  --name "Ada Lovelace" \
+  --email ada@example.org \
+  --yes
+```
+
+pyAmpliCol does not retain the submitted identity fields and does not print the
+returned key. Symbolica emails the issued key. Export it before generation:
+
+```console
+export SYMBOLICA_LICENSE='your-issued-key'
+```
+
+Consult the
+[official Symbolica installation and licensing guide](https://symbolica.io/docs/get_started.html)
+before choosing a request type.
+
+## Python exact precision
+
+Python may request positive decimal precision other than 16:
+
+```python
+exact = runtime.evaluate(momenta, precision=80)
+```
+
+This loads retained Symbolica evaluator state and requires the applicable
+Symbolica package/runtime authorization. Decimal-string inputs can preserve
+their source digits through the generated Python standalone driver:
+
+```console
+python artifacts/pp_zjj/API/python/check_standalone.py \
+  --process 'd d~ > g z g' \
+  --kinematics my_sample_point.json \
+  --precision 80
+```
+
+A binary64 value converted to higher precision gains trailing arithmetic
+digits, not additional physical input information. Use decimal strings in the
+kinematics JSON when input precision matters.
+
+Native C, C++, Fortran, and Rust callers reject precision other than 16.
+
+The Python [Born Correlations API](../correlators.md) uses the same retained
+Symbolica-state machinery through a separate exact executor at **all**
+requested precisions, including 16. The C/C++/Fortran/Rust correlated SDK calls
+instead use a separate RustiCol binary64 executor without importing or
+licensing Symbolica at runtime. Both contract the selected LC/NLC/full colour
+matrices prepared during generation, which still requires Symbolica.
+
+## SymJIT is a separate dependency
+
+SymJIT is the native JIT runtime used by Symbolica-generated applications. It
+is distributed under the MIT License, not under the Symbolica proprietary
+license. Release dependency metadata pins the official
+[`siravan/symjit-crate`](https://github.com/siravan/symjit-crate) source and an
+immutable revision.
+
+SymJIT compression shares repeated arithmetic sequences to reduce generated
+code size. The extra calls can increase evaluation time, but the smaller
+instruction footprint can make larger evaluators faster. Neither setting is
+universally faster; use `profile` to compare them for your workload.
+
+The default is `compress = "auto"`: compression is enabled for compiled JIT
+evaluators at optimization level O2 and disabled for other execution modes or
+optimization levels. Explicit `true` or `false` settings override that policy.
+To enable it explicitly:
+
+```toml
+[evaluator.jit]
+compress = true
+```
+
+The equivalent CLI option is:
+
+```console
+pyamplicol generate --card run.toml --jit-compress
+```
+
+Prepared model bundles bake their compression/backend choice into the kernel
+pack, so an incompatible request is adjusted to the prepared pack and reported
+in the effective configuration. To change that choice, regenerate the prepared
+model with `--jit-compress` or `--no-jit-compress`.
+
+## License and provenance map
+
+| Component | Role | License/provenance boundary |
+| --- | --- | --- |
+| pyAmpliCol and project Rusticol source | Public package/runtime implementation | BSD Zero Clause License (`0BSD`). |
+| Symbolica | Symbolic generation and Python exact runtime | Proprietary Symbolica Software License Agreement; project redistribution permission is documented separately. |
+| SymJIT | Native JIT application runtime | MIT License. |
+| UFO model loader | External UFO loading | MIT License. |
+| Bundled SM/scalar/scalar-gravity assets | Example/model data | Asset-specific provenance and reproduced terms in `PROVENANCE.toml` and `licenses/`. |
+| Optional original Fortran AmpliCol checkout | Independent campaign oracle | Not bundled in wheels or sdists; its upstream metadata/terms remain separate. |
+
+The pyAmpliCol project has express authorization from the Symbolica licensor to
+redistribute the Symbolica components required by pyAmpliCol's binary runtime.
+That project-specific permission is not a general grant to redistribute
+Symbolica separately. While valid, the embedded library key covers Symbolica
+calls within pyAmpliCol; other Symbolica use requires its own applicable
+authorization.
+
+Exact dependency versions and notices are included in release metadata and
+[`THIRD_PARTY_NOTICES.md`](https://github.com/MadGraphTeam/pyamplicol/blob/main/THIRD_PARTY_NOTICES.md).
+
+## Original AmpliCol is not a pyAmpliCol runtime dependency
+
+The optional original Fortran AmpliCol checkout is used only as an independent
+numerical/performance reference in [Profiling Campaigns](profiling-campaigns.md). It is not shipped
+in pyAmpliCol wheels or source distributions and is unnecessary for ordinary
+generation or evaluation.
+
+pyAmpliCol has no LHAPDF dependency. The supported campaign comparison checkout
+contains the profiling interface described in
+[rikkert-frederix/AmpliCol PR #12](https://github.com/rikkert-frederix/AmpliCol/pull/12).
+
+## Diagnose the active boundary
+
+```console
+pyamplicol doctor
+```
+
+The human output is colored and names Python, model assets, Rusticol extension,
+native SDK, Symbolica license status, and available compiler tools separately.
+Use JSON when attaching diagnostics to an issue:
+
+```console
+pyamplicol doctor --json
+```
+
+If ordinary or native correlated f64 evaluation fails, do not assume it is a Symbolica-license
+problem: first run `pyamplicol self-test` and inspect the artifact target. If
+generation, precision-80 evaluation, or Python correlated evaluation at any precision
+fails, then inspect the Symbolica check. See
+[Troubleshooting](troubleshooting.md).
+
+## Related pages
+
+- [Installation](installation.md) — wheel and source requirements.
+- [Generation Modes and Evaluators](generation-modes-and-evaluators.md) — where symbolic work occurs.
+- [Artifacts and Portability](artifacts-and-portability.md) — what the resulting f64 artifact carries.
+- [Born Correlations](../correlators.md) — Python exact and native binary64 correlation paths.
+- [Release and Support](release-and-support.md) — published dependency and validation boundary.
diff --git a/pyamplicol/docs/user/troubleshooting.md b/pyamplicol/docs/user/troubleshooting.md
new file mode 100644
index 0000000000..8d624f24fb
--- /dev/null
+++ b/pyamplicol/docs/user/troubleshooting.md
@@ -0,0 +1,411 @@
+---
+title: "Troubleshooting"
+nav_order: 4
+parent: "Profiling and Benchmarking"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# Troubleshooting
+
+This page starts with cheap, authoritative checks and then narrows common
+generation, runtime, native-SDK, and profiling-campaign failures. Avoid broad
+rebuilds until the failing boundary is known.
+
+## First checks
+
+Confirm which Python and installation are active:
+
+```console
+command -v python
+command -v pyamplicol
+python -c 'import pyamplicol; print(pyamplicol.__version__); print(pyamplicol.__file__)'
+```
+
+Inspect the installed environment and compiler tools:
+
+```console
+pyamplicol doctor
+```
+
+Run the packaged direct-runtime self-test:
+
+```console
+pyamplicol self-test
+```
+
+On a healthy 0.2.0 macOS arm64 release-candidate installation, the colored
+terminal tables report checks equivalent to this compact transcription:
+
+```text
+python          pass
+model-assets    pass   67 verified files
+rusticol-python pass   package 0.2.0, C ABI 1
+native-sdk      pass   aarch64-apple-darwin; ABI 1; librusticol_capi.a
+physics-f64     pass   d_dbar_to_z; shape (1, 12, 1); direct SymJIT
+```
+
+The Python version, target, paths, and package version naturally vary. A failure
+in one named check points to a much smaller subsystem than a full rebuild.
+
+## `ModuleNotFoundError: No module named 'pyamplicol'`
+
+The generated Python driver uses the interpreter that launches it. Activate
+the installed environment or invoke that environment's Python explicitly:
+
+```console
+. /path/to/venv/bin/activate
+python artifacts/pp_zjj/API/python/check_standalone.py \
+  --process 'd d~ > g z g' --json
+```
+
+or:
+
+```console
+/path/to/venv/bin/python \
+  artifacts/pp_zjj/API/python/check_standalone.py \
+  --process 'd d~ > g z g' --json
+```
+
+In the canonical source workflow, a copied workspace below a checkout can find
+the checkout's `.venv` created by `just dev-install`. A workspace elsewhere
+must use an active or explicit environment.
+
+## `rusticol-config: command not found`
+
+C, C++, Fortran, and Rust consumers discover their SDK through the installed
+environment:
+
+```console
+. /path/to/venv/bin/activate
+rusticol-config --json
+```
+
+An explicit override is also supported:
+
+```console
+export RUSTICOL_CONFIG=/path/to/venv/bin/rusticol-config
+make -C artifacts/pp_zjj/API/c run \
+  ARGS='--process "d d~ > g z g" --json'
+```
+
+Do not manually guess include, archive, framework, or system-library paths.
+If `rusticol.h`, `rusticol.hpp`, the Fortran module source, or
+`RUSTICOL_RUST_SOURCE` is missing, first check:
+
+```console
+rusticol-config --include-dir
+rusticol-config --library
+rusticol-config --fortran-source
+rusticol-config --rust-source
+```
+
+See [Native APIs](native-apis.md) for the complete environment contract.
+
+## `installed candidate wheel is stale for this checkout`
+
+Contributor imports bind the staged native extension to relevant checkout
+sources. If Rust/native inputs or the source revision changed, refresh the
+candidate once:
+
+```console
+just dev-install
+```
+
+Do not copy an extension from another worktree or disable this check. Published
+wheels do not use the checkout-candidate gate.
+
+## An example card cannot find its artifact
+
+Copied evaluation and benchmark cards use paths relative to the copied
+workspace. Generate their prerequisite first and run from that workspace:
+
+```console
+pyamplicol examples copy /tmp/pyamplicol-examples --force
+cd /tmp/pyamplicol-examples
+
+pyamplicol generate_pp_zjj_from_ufo_sm.toml
+pyamplicol evaluate_total.toml
+pyamplicol evaluate_resolved.toml
+pyamplicol benchmark.toml
+```
+
+Generating `qq_z6g_compiled_jit_o3.toml` creates a different artifact and does
+not satisfy `benchmark.toml`'s `artifacts/pp_zjj` prerequisite.
+
+List the packaged names and their actions before running one:
+
+```console
+pyamplicol examples list
+pyamplicol examples run --help
+```
+
+See [Examples Gallery](examples-gallery.md).
+
+## “no model-supported tree-level amplitudes”
+
+pyAmpliCol generates tree-level amplitudes. The primary `p p > Z j j`
+expansion encounters `g g > Z g g`, which is loop-induced in the Standard
+Model. It is reported and omitted while the supported tree-level channels are
+retained:
+
+```text
+Skipped 1 concrete subprocess with no model-supported tree-level amplitudes:
+p_p_to_z_j_j_8 (g g > Z g g)
+```
+
+That warning is expected for the inclusive example. A request containing only
+the loop-induced process has no supported representative and fails. Choose a
+tree-level process or a model that provides the required tree-level amplitude;
+pyAmpliCol is not silently performing a loop calculation.
+
+## Recurrence, eager, or OTF says a prepared model is missing
+
+Recurrence, eager, and OTF use prepared local kernels. A raw UFO directory,
+serialized model JSON, or compiled model IR is not itself a prepared kernel
+bundle.
+
+Either compile a prepared bundle:
+
+```console
+pyamplicol model compile models/json/sm/sm.json \
+  models/sm-jit-o2.pyamplicol-model \
+  --backend jit --jit-optimization-level 2
+```
+
+and use it:
+
+```console
+pyamplicol generate 'd d~ > z g g' artifacts/builtin_ddbar_to_zgg \
+  --model models/sm-jit-o2.pyamplicol-model \
+  --execution-mode recurrence
+```
+
+or select process-local compiled mode explicitly for raw/compiled model input:
+
+```console
+pyamplicol generate --card run.toml --execution-mode compiled
+```
+
+The installed `built-in-sm` source automatically selects its packaged JIT O2
+prepared bundle. There is no hidden recurrence-to-compiled fallback.
+
+## A process expression does not resolve
+
+Inspect the stored representatives:
+
+```console
+pyamplicol inspect artifacts/pp_zjj
+```
+
+The runtime permits a unique permutation within each side of `>`:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --process 'd d~ > g z g'
+```
+
+It does not move an incoming particle to the outgoing side. If several
+representatives have the same incoming/outgoing multisets, inference is
+ambiguous and the error lists their stable IDs. Select one of those IDs
+explicitly.
+
+## Wrong kinematic shape or ordering
+
+Runtime arrays have shape `(point, external particle, [E, px, py, pz])`.
+Standalone `--kinematics` files contain exactly one `[external][4]` point or a
+singleton batch around it. Legs follow the expression passed in `--process`,
+including inferred permutations.
+
+Use `runtime.physics.external_particles` or:
+
+```console
+pyamplicol inspect artifacts/pp_zjj --process 'd d~ > g z g'
+```
+
+to confirm public order. JSON booleans, non-finite values, multiple points, and
+wrong ranks are rejected. Decimal strings are preserved only by Python exact
+evaluation; native APIs convert to f64.
+
+## Color-flow selection is rejected
+
+Physical color-flow selection is an LC capability. NLC and full color are
+contracted and expose one output color slot per helicity, not a selectable LC
+flow.
+
+```python
+print(runtime.physics.selector_capabilities)
+print(runtime.physics.color_flow_ids)
+```
+
+Use only helicity selectors for NLC/full. See [Runtime and Selectors](runtime-and-selectors.md).
+
+## Target or CPU-feature incompatibility
+
+Inspect the target:
+
+```console
+pyamplicol inspect artifacts/my_process
+rusticol-config --target
+```
+
+Compiled all-JIT O1/O2 process artifacts report `portable-64le` and can move
+between supported x86-64 and arm64 little-endian hosts. Prepared eager and
+recurrence artifacts use the exact-O2 portable pack contract. JIT O0/O3, C++,
+and ASM artifacts are target-specific and may require particular CPU features.
+Regenerate a target-specific artifact on the destination, or use a portable
+JIT configuration. See [Artifacts and Portability](artifacts-and-portability.md).
+
+## Artifact loading or an explicit checksum audit fails
+
+Treat a size/digest/path mismatch as a changed or incomplete artifact. Do not
+edit `artifact.json` or payloads by hand. Restore the complete directory from a
+trusted channel or regenerate it.
+
+Normal runtime loading does not hash every payload. If you intentionally ran
+the explicit full audit, remember it may read very large PACBIN files once:
+
+```python
+from pyamplicol.artifacts import load_manifest, validate_payloads
+
+manifest = load_manifest("artifacts/my_process")
+validate_payloads(manifest)
+```
+
+Do not put this full rehash in every evaluation loop.
+
+## Generation appears to repeat expensive validation
+
+Generation-time validation remains enabled and checks construction as it is
+built. The separate **post-build** runtime reopen is off by default because it
+does not change the completed artifact and can be expensive for large resolved
+axes.
+
+Check the resolved card:
+
+```console
+pyamplicol config resolve run.toml
+```
+
+`generation.validation.post_build_validation` should be `false` unless you
+explicitly requested `--post-build-validation`. The sample count alone does not
+enable the reopened pass.
+
+## Symbolica license or restricted-mode messages
+
+Run:
+
+```console
+pyamplicol doctor
+```
+
+Importing pyAmpliCol and using direct f64 runtime evaluation do not import
+Symbolica. Model compilation and generation use Symbolica lazily. Without a
+valid license, eligible users may continue under Symbolica's current restricted
+terms, and pyAmpliCol clamps generation to one worker and one Symbolica core.
+
+Python precision other than 16 also loads retained Symbolica state. Native
+languages are f64-only and never perform a Symbolica license check. See
+[Symbolica and Licensing](symbolica-and-licensing.md).
+
+## A profiling campaign seems to have lost earlier results
+
+Running without `--continue-across-revisions` does **not** delete old attempts.
+It limits active planning to the current source cohort. To extend a campaign
+across source changes:
+
+```console
+./steer_performance_campaign.py run \
+  --continue-across-revisions \
+  ...ordinary selectors...
+```
+
+Compatible historical currents can then remain while new work uses the active
+revision. Numerical authorities required by new current-revision work are
+replanned safely.
+
+The command that resets state is:
+
+```console
+pyamplicol profiling-campaign copy DEST --force
+```
+
+It resets only managed state below that destination, and refuses while a
+campaign is active. See [Profiling Campaigns](profiling-campaigns.md).
+
+## The campaign reads the wrong directory after a rename
+
+All state is local to `DEST/campaign_artifacts/`. If a directory was renamed
+while the shell remained inside the old inode, the prompt may show a logical
+name that no longer matches the physical directory.
+
+```console
+pwd
+pwd -P
+```
+
+Start a new shell or `cd` through the campaign's current absolute path. Current
+launchers reject a stale logical/physical mismatch before opening state.
+
+Move the whole campaign directory; do not copy individual currents or
+coordination files.
+
+## A campaign reports `unverified`
+
+`unverified` is intentional for a compiled/eager timing measured without an
+independent successful recurrence or original-AmpliCol authority. It is not an
+OK current, is excluded from best-mode ratios/summaries, and is automatically
+retryable after authority becomes available.
+
+By default, ordinary selection adds the available authority closure. If you
+used `--no-dependencies-added`, rerun without it, or explicitly select the
+authority and candidate. Replay exact IDs from:
+
+```console
+./steer_performance_campaign.py run \
+  --cell-id-file campaign_summary_ids/unverified.txt
+```
+
+## A campaign is slow to render its PDF
+
+`refresh-pdf` scans compact current records and displays a colored progress
+bar. It does not need to hash or load every retained heavy attempt.
+
+```console
+./steer_performance_campaign.py refresh-pdf
+```
+
+Use `--quiet` only when progress and LaTeX output should be suppressed. If the
+scan is unexpectedly dominated by old payloads, confirm you are using the
+current copied controller and that state is below `campaign_artifacts/`, not a
+legacy campaign layout.
+
+## Memory use while loading a large JIT artifact
+
+PACBIN-backed runtimes snapshot the container into anonymous read-only memory.
+The handle therefore needs RAM or swap comparable to the PACBIN size for its
+lifetime. This protects a running evaluator from later path replacement or
+truncation.
+
+If that footprint is unsuitable, generate a smaller process set or a more
+specialized artifact. Do not assume the container will be lazily read from a
+mutable file.
+
+## Reporting a reproducible issue
+
+Include only the smallest evidence that identifies the failing boundary:
+
+```console
+python -c 'import pyamplicol; print(pyamplicol.__version__)'
+pyamplicol doctor --json
+pyamplicol inspect PATH_TO_ARTIFACT --json
+```
+
+Also include:
+
+- the exact command and run card;
+- host OS/architecture and Python version;
+- execution mode, backend, color accuracy, and target;
+- the complete error, not only its final status code;
+- for a campaign, the canonical cell ID and compact worker log/result path;
+- whether the artifact is reproducible from a public example.
+
+Do **not** upload proprietary UFO code, license keys, or an untrusted native
+artifact publicly. Open issues through [Release and Support](release-and-support.md).
diff --git a/pyamplicol/docs/user/ufo-model-coverage.md b/pyamplicol/docs/user/ufo-model-coverage.md
new file mode 100644
index 0000000000..ba27450c7c
--- /dev/null
+++ b/pyamplicol/docs/user/ufo-model-coverage.md
@@ -0,0 +1,235 @@
+---
+title: "UFO Model Coverage"
+nav_order: 2
+parent: "Configuration"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# UFO Model Coverage
+
+This page is the exact reference of what a generic UFO (or serialized JSON)
+model may contain for pyAmpliCol, what is accepted only under a condition, and
+what is rejected or ignored. Every row was derived from the code of
+pyAmpliCol 1.0.0 with ufo-model-loader 1.0.0 and Symbolica 3.0.0; the paper
+summarises it in one table. Read
+[Models and Processes](models-and-processes.md) first for the workflow, and
+use `pyamplicol model inspect <source>` to see the issues reported for your
+own model.
+
+Status words used below:
+
+| Status | Meaning |
+| --- | --- |
+| supported | accepted without further condition |
+| conditional | accepted when the stated condition holds, otherwise the stated diagnostic |
+| experimental | accepted, but the path is not validated against a reference |
+| rejected | refused with the stated diagnostic |
+| ignored | loads without error but never affects generated amplitudes |
+
+## Summary
+
+| Area | Supported | Rejected or restricted |
+| --- | --- | --- |
+| Input | UFO directories (trusted Python), serialized JSON, compiled IR files, prepared kernel bundles | anything else; ufo-model-loader older than 1.0.0 |
+| Fields | scalars, Dirac fermions, vectors, massless spin-2 (validated); massive spin-2 (experimental) | Majorana and fermion-number-violating fermions, spin 3/2, higher spins; ghosts and Goldstones only internally |
+| Colour | one SU(3) with 1, 3, 3̄, 8; external coloured legs are triplet fermions or octet vectors | sextets, other groups, N_c other than 3, d^abc, epsilon and sextet tensors |
+| Lorentz | Identity, Gamma, Gamma5, ProjM, ProjP, Sigma, Metric, P; PSlash in propagators | Epsilon, C, IdentityL, form factors, functions outside the registry |
+| Three-point vertices | any spins with colour 1, delta, T^a, f^abc | d^abc; one- and two-point terms are ignored |
+| Four-point vertices | colour-singlet (any Lorentz structure); the two-f gauge contact; HEFT Hggg | other coloured contacts (four-fermion operators, delta couplings, d^abc) |
+| Five-point and higher | colour-singlet contacts of any valence (tested to ten scalars); HEFT Hgggg | every other coloured contact |
+| Propagators | standard scalar, Dirac, vector and spin-2 kernels with fixed widths; custom UFO propagators that lower exactly | complex-mass scheme; gauge choices other than Feynman (massless) and unitary (massive) |
+| Parameters | external and internal, real or complex, the fixed function registry, restriction cards, runtime cards for external parameters | custom function bodies, epsilon-expanded values (finite part kept), counterterm vertices (dropped) |
+| Processes | 2 to N tree level, LC, NLC and full colour, FFT contraction in the trace or adjoint basis | loop-induced channels (omitted) |
+
+## Preflight diagnostic codes
+
+`pyamplicol model inspect` lists these codes; any error code makes the model
+unsupported for generation, warnings do not.
+
+| Code | Severity | Trigger |
+| --- | --- | --- |
+| `unsupported-spin` | error | a particle spin code outside -1, 1, 2, 3, 5 |
+| `unsupported-color-representation` | error | a particle colour code outside 1, 3, -3, 8 |
+| `majorana-fermion` | error | a spin-1/2 particle whose name equals its antiname |
+| `form-factors` | error | the model declares any form factor |
+| `function-arity` | error | a declared function with a registry name but a different argument count |
+| `unknown-functions` | error | a function name outside the registry and the UFO tensor heads in any parameter, coupling, propagator, Lorentz or colour expression |
+| `unsupported-contact-color-lowering` | error | a vertex with more than three legs whose colour structure could not be decomposed into contact kernels (reported after tensor lowering) |
+| `experimental-massive-spin-2` | warning | a spin-2 particle whose mass is not `ZERO` |
+
+Some rejections happen at model compilation rather than at preflight and
+carry a `ValueError` message instead of a code; they are marked below.
+
+## Sources and loading
+
+| Feature | Status | Condition and consequence |
+| --- | --- | --- |
+| Source kinds | supported | `built-in-sm`, `built-in-sm-heft`, a UFO directory containing `__init__.py`, a `.json` model in ufo-model-loader's schema, a compiled IR file `*.pyAmplicol-model.json`, or a prepared bundle `*.pyamplicol-model`. A directory without `__init__.py`, a missing path or unreadable JSON is a `ValueError`. |
+| Built-in selector spelling | conditional | Use `built-in-sm`; the `builtin_sm` spelling is accepted by the config resolver but not by the typed model layer. |
+| UFO Python execution | supported | A UFO directory is imported as Python with your privileges; only load trusted models and prefer the JSON form for automation. During the import the `UFO_SCALARS_MODEL_*` and `UFO_GRAVITY_MODEL_*` environment variables are hidden and no `.pyc` files are written. |
+| ufo-model-loader version | conditional | External UFO and JSON models require an installed release 1.0.0 or newer (development builds are refused with a `RuntimeError`); built-in models do not need it. |
+| Required UFO attributes | conditional | `all_orders`, `all_parameters`, `all_particles`, `all_lorentz`, `all_couplings` and `all_vertices` must exist; `all_propagators`, `all_functions`, `all_form_factors` and `all_CTparameters` are optional; objects of class `CTVertex` are dropped silently. |
+| Serialized JSON schema | conditional | The file must end in `.json` and provide `name`, `restriction`, `orders`, `parameters`, `particles`, `propagators`, `lorentz_structures`, `couplings` and `vertex_rules`. |
+| Loader errors | conditional | Errors raised inside ufo-model-loader (missing restriction file, external parameter without default, malformed JSON) surface as raw Python tracebacks, not as pyAmpliCol `ModelError` messages. |
+| Restriction selector | supported | `default` applies `restrict_default.dat` (UFO) or `restrict_default.json` (JSON) when present, otherwise the model defaults without zero-pruning; `none` applies no card; any other name needs `restrict_<name>.dat` or `.json`. |
+| Restriction file location | conditional | A restriction given as a path must be named `restrict_<name>.dat` (UFO, inside the model directory) or `restrict_<name>.json` (JSON, beside the model file); other names or locations are a `ValueError`. |
+| What a restriction changes | supported | A card sets external parameter values only; `.dat` cards are SLHA parameter cards, `.json` cards map names to `[re, im]`. With `simplify=true` (default) parameters set to zero become constants and the couplings and vertices they kill are pruned. |
+| Restrictions on built-in and precompiled sources | rejected | `restriction` and `simplify=false` apply only to UFO and JSON sources; built-in, compiled and prepared models refuse them. |
+| Compilation cache | conditional | Compiled models are cached under `$PYAMPLICOL_CACHE_DIR/models` (or the platform cache) keyed by source contents, options and toolchain. Editing a `restrict_*.json` beside a JSON model does not change the key: pass `--no-model-cache` or the file path after editing it. |
+| Dry run | conditional | `--dry-run` never compiles a UFO or JSON model; compile it or run `model inspect` first so the cache is populated. |
+| Compiled IR files | conditional | Tied to the exact pyAmpliCol, Symbolica and ufo-model-loader versions that wrote them; regenerate after any upgrade. |
+| Prepared bundles | conditional | Verified member by member (sizes and SHA-256) on every load; must match the current bundle schema and model-compiler version. |
+| Parameter card | supported | `CompiledModel.write_parameter_card()` writes the runtime-adjustable external parameters after the restriction as `{name: [re, im]}`; parameters fixed to zero by the restriction are absent and immutable. |
+| Model CLI | supported | `pyamplicol model inspect` loads even unsupported models and lists every issue; `model compile` and `model processes` refuse unsupported models. There is no separate preflight subcommand. |
+
+## Particles
+
+| Feature | Status | Condition and consequence |
+| --- | --- | --- |
+| Spin codes | supported | -1 (ghost), 1 (scalar), 2 (Dirac fermion), 3 (vector), 5 (spin-2); any other code is `unsupported-spin`. |
+| Spin 3/2 and higher | rejected | `unsupported-spin`; no downstream path exists. |
+| Scalars | supported | standard propagator i/(p^2 - m^2 + i m Gamma). |
+| Dirac fermions | supported | particle and antiparticle must be distinct; standard massive or massless Dirac propagator. |
+| Massless fermions | conditional | Treated as two-component Weyl spinors when the mass is literally `ZERO` or an internal parameter equal to zero and the propagator is the loader default; an external mass parameter that merely defaults to zero keeps four-component currents. |
+| Majorana fermions | rejected | `majorana-fermion` when name equals antiname; fermion-number-violating flow is not implemented. |
+| Vectors | supported | massless vectors get helicities -1, +1 and Feynman gauge; massive vectors get -1, 0, +1 and unitary gauge, decided from the restricted default mass at compile time. |
+| Massless spin-2 | supported | 16-component tensor, helicities -2 and +2 only, de Donder propagator; validated by the packaged scalar-gravity model. A model without its own spin-2 propagator must define the `dim` parameter used by the loader default. |
+| Massive spin-2 | experimental | accepted with `experimental-massive-spin-2`; the Fierz-Pauli propagator and five helicities are implemented but only the propagator projector is unit-tested; such a model must declare its own propagator because the loader has no default. |
+| Ghosts | ignored | any particle with a nonzero ghost number loads, but it can never be external, is excluded from every current, and has no propagator kernel. |
+| Spin -1 without ghost number | rejected | classified as a non-external auxiliary whose propagator has no contract; model preparation fails when it is needed. |
+| Colour codes | supported | 1, 3, -3, 8; anything else is `unsupported-color-representation`. Colour always means SU(3) with N_c = 3. |
+| Coloured external states | conditional | an external coloured leg must be a triplet or antitriplet fermion or an octet vector; coloured scalars, octet fermions and coloured tensors are refused when a process names them (`ValueError`). |
+| External-state eligibility | supported | a particle can be named in a process only if it has positive spin, zero ghost number, is not a Goldstone, is propagating and is not a compiler auxiliary; names resolve exactly, then case-insensitively when unique. |
+| Particle identity | supported | antiname must exist and be involutive, non-self-conjugate pairs use opposite-signed PDG codes, names and PDG codes are unique, self-conjugate particles are neutral. |
+| Mass | conditional | `ZERO` or a model parameter; the massless or massive class (helicities, gauge, Weyl projection) is fixed once at compile time from the restricted default and cannot be changed by a runtime card. |
+| Complex masses and widths | rejected | mass and width values must be real; there is no complex-mass scheme. |
+| Width | supported | `ZERO` or a parameter; enters only the fixed-width denominator of massive propagators and can be overridden at runtime. |
+| Goldstone bosons | conditional | must be propagating scalars; matched to the unique massive vector with identical colour, quantum numbers and mass and then absorbed into its unitary-gauge propagator; an ambiguous match is an error, an unmatched Goldstone stays an internal scalar. |
+| Propagating flag | supported | non-propagating particles cannot be external but are compiled normally. |
+| Electric charge | supported | recorded as a bookkeeping quantum number only; not used to check charge conservation. |
+| Other attributes | ignored | `texname`, `antitexname`, `line`, `counterterm`, `LeptonNumber` and `Y` never affect amplitudes. |
+| Custom propagator attribute | conditional | a particle whose propagator differs from the loader's Feynman default is used as written and loses the Weyl projection and Goldstone absorption. |
+
+## Parameters, couplings and functions
+
+| Feature | Status | Condition and consequence |
+| --- | --- | --- |
+| Parameter nature | supported | `external` (runtime input) or `internal` (substituted symbolically); the common `interal` typo is corrected; anything else fails in the loader. |
+| Parameter type | supported | `real` or `complex`; complex external parameters are set as `[re, im]`; a real parameter can never receive an imaginary part. |
+| External defaults | conditional | every external parameter needs a value in the UFO or in the selected restriction card. |
+| Expression syntax | conditional | standard UFO spellings only: `cmath.sqrt`, `cmath.pi` or `pi`, `cmath.sin/cos/asin/acos`, `complex(x, y)`, `complexconjugate`, `cond`, `Theta`, `reglog`, bare `exp`, `log`, `tan`, `atan`, and `**`; other `cmath.`, `math.` or `numpy.` calls fail to load. |
+| Scientific notation | rejected | a decimal mantissa with an exponent such as `1.5e-3` is mis-parsed by the loader; write `0.0015`, `15e-4` or a fraction. |
+| Rational exponents | supported | `x**0.5` is evaluated exactly as `x^(1/2)`. |
+| Parameter dependencies | supported | internal parameters may reference each other in any order; cycles are rejected. |
+| Function registry | conditional | one-argument `Theta`, `abs`, `acos`, `acosh`, `acsc`, `asec`, `asin`, `asinh`, `atan`, `atanh`, `complexconjugate`, `conj`, `cos`, `cosh`, `csc`, `exp`, `im`, `log`, `log10`, `re`, `reglog`, `reglogm`, `reglogp`, `sec`, `sin`, `sinh`, `sqrt`, `tan`, `tanh`; two-argument `complex`, `pow`; three-argument `cond`, `if`. Anything else is `unknown-functions`. |
+| Evaluable subset | conditional | `re`, `im`, `log10`, `pow`, `reglogp` and `reglogm` pass preflight but have no runtime evaluator and fail when a parameter that uses them is evaluated; all other registry functions compute. |
+| Declared functions | conditional | a declared `Function` is accepted only if it is a registry name with the registry arity; its body is ignored in favour of the built-in meaning (`function-arity` otherwise). |
+| Constants | conditional | `pi` stays exact until numerical evaluation and `complex(0, 1)` is the exact imaginary unit; a bare `I` symbol is not supported. |
+| Epsilon-expanded values | ignored | dictionary-valued parameters and couplings keep only the order-0 entry, with one loader warning. |
+| Counterterms and decays | ignored | counterterm parameters are ordinary parameters, `CTVertex` objects are dropped, the decays block is never read. |
+| Coupling records | supported | any expression in the parameters, any number of coupling-order names per coupling. |
+| Coupling matrix | supported | one row per colour structure and one column per Lorentz structure; `None` entries are skipped; each cell becomes its own term and pieces with different orders are counted separately. |
+| Coupling orders | conditional | `hierarchy` weights the minimal coupling-order policy; `expansion_order` is stored but has no effect; undeclared order names default to weight 1. |
+| Coupling-order policies | supported | `minimal` (default) keeps the lowest hierarchy-weighted order; `explicit` applies only `--max-coupling-order NAME=N`, and misspelled names are not detected. |
+| Runtime parameter cards | supported | flat JSON objects of finite real or `[re, im]` values via `--model-parameters`, `Runtime.load(model_parameters=...)` or `set_model_parameters`; an invalid batch leaves the runtime unchanged. |
+| Runtime mutability | conditional | only surviving external parameters are mutable; derived parameters and couplings are recomputed and read-only. In recurrence mode an external parameter that the process never uses may be rejected as not used. |
+| Masses and widths at runtime | conditional | external mass and width parameters can be varied, but a particle cannot switch between the massless and massive class without regenerating. |
+| Numerical precision | supported | model constants are kept exact in the compiled model; only user-supplied values are binary64. |
+
+## Lorentz structures and vertices
+
+| Feature | Status | Condition and consequence |
+| --- | --- | --- |
+| Normalized tensor heads | supported | `Identity(i, j)`, `Gamma(mu, i, j)`, `Gamma5(i, j)`, `ProjM(i, j)`, `ProjP(i, j)`, `Sigma(mu, nu, i, j)`, `Metric(mu, nu)`, `P(mu, k)` with the standard UFO argument conventions; `PSlash(i, j)` only in its two-argument propagator form. |
+| Other tensor heads | rejected | `Epsilon`, `EpsilonBar`, `C`, `IdentityL`, three-argument `PSlash` and any accepted head with a wrong arity fail model compilation with `ValueError: ... contains unsupported UFO tensors`. |
+| Form factors | rejected | `form-factors`. |
+| Sigma normalisation | experimental | expanded as (i/2)(gamma^mu gamma^nu - gamma^nu gamma^mu); vertices using `Sigma` have not been validated against a reference implementation. |
+| Chiral structures | supported | `ProjM`, `ProjP` and `Gamma5` are validated through the packaged Standard Model. |
+| Index conventions | conditional | 1-based leg indices, the `1000*component + leg` notation for spin-2 fields and negative dummy indices are supported; inconsistent indices are a `ValueError`. |
+| Several structures per vertex | supported | any number of colour and Lorentz structures through the coupling matrix. |
+| Three-point vertices | supported | any combination of scalars, Dirac fermions, vectors and spin-2 fields, momentum-dependent or not, with colour 1, delta, T^a or f^abc. |
+| One- and two-point terms | ignored | tadpole and two-point mixing vertices are dropped without a warning. |
+| Four-point colour-singlet contacts | supported | momentum-independent ones through the exact component-basis split; momentum-dependent ones through balanced contact trees. |
+| Four-point two-f gauge contacts | conditional | accepted when written as a numeric factor times `f(a, b, x) * f(x, c, d)` with one shared adjoint index and no momentum dependence; otherwise `unsupported-contact-color-lowering`. |
+| Other coloured four-point contacts | rejected | four-fermion operators, delta couplings to singlets, `d^abc` and single-f shapes outside the HEFT family give `unsupported-contact-color-lowering`. |
+| Higher-point colour-singlet contacts | supported | any valence, momentum-dependent or not, tested up to ten scalars and five-point spin-2 vertices. |
+| Scalar-HEFT contacts | conditional | four-point (8, 8, 8, 1) with colour exactly `f(i, j, k)` and five-point (8, 8, 8, 8, 1) with colour exactly `f(...) * f(...)` sharing one index, without a numeric prefactor in the colour string. |
+| Other coloured contacts with five or more legs | rejected | `unsupported-contact-color-lowering`. |
+| Four-fermion contacts | experimental | not gated at compile time but not validated; treat as unsupported. |
+| Counterterm and loop vertices | ignored | only tree vertices are used; `type` and `loop_particles` attributes are never read. |
+| Ghost vertices | ignored | compiled but never used. |
+| Custom propagator tensors | conditional | the vertex tensor heads plus `PSlash(i, j)`, `P(1)` and `P(1)^2` for the propagating momentum. |
+
+## Colour structures and colour accuracy
+
+| Feature | Status | Condition and consequence |
+| --- | --- | --- |
+| Colour group | rejected | one SU(3) with N_c = 3 only; a second group or SU(N) with N other than 3 is not representable. |
+| `1` | conditional | accepted for any valence when every leg is colour-neutral; on a vertex with coloured legs it is rejected. |
+| `Identity(i, j)` | conditional | both indices must point at coloured legs of dual (or equal adjoint) representations. |
+| `T(a, i, j)` | supported | adjoint, fundamental, antifundamental index order. |
+| `f(a, b, c)` | supported | three adjoint legs or dummies; a product of two `f` is the only coloured four-point structure. |
+| `d(a, b, c)` | rejected | recognised, then refused at compilation as an unsupported trilinear tensor or contact lowering. |
+| `Epsilon`, `EpsilonBar`, `K6`, `K6Bar`, `T6` | rejected | pass the preflight name check but fail model compilation with `ValueError: color expression contains unsupported UFO tensors`. |
+| Three-point projection | conditional | every three-point colour structure must be exactly proportional to 1, delta, T^a or f^abc with matching leg representations; the constant may be any number. |
+| Colour accuracies | supported | `lc`, `nlc` and `full` for any accepted model; the choice is a run-card setting. |
+| NLC and full colour weights | supported | exact for any number of quark lines; pure-gluon processes are exact up to 40 gluons. |
+| Colour-charge balance | conditional | after crossing, fundamental and antifundamental legs must balance; otherwise the process has no colour plan. |
+| Sector truncation | conditional | `process.max_color_sectors` produces a partial sum marked `selected` with direct contraction and is refused by on-the-fly, FFT and correlators. |
+| Colour-flow selectors | conditional | LC outputs only; NLC and full outputs return one contracted entry per helicity. |
+| `all-flow-union` layout | conditional | LC only, with complete coverage. |
+| FFT contraction | conditional | Default `contraction="auto"` tries FFT for `nlc` or `full` with `recurrence` or `on-the-fly`, falling back to direct contraction for unsupported plans. FFT needs at most ten permutable gluons whose colour sectors form complete permutation orbits. LC, compiled/eager execution, and correlators retain direct/trace; `--color-contraction direct` opts out. Explicit `--fft trace` or `--fft adjoint` forces FFT and retains unsupported-plan errors. |
+| Adjoint FFT selection | conditional | Default `fft_basis="adjoint"` adaptively uses DDM for certified Yang–Mills or single-insertion scalar HEFT (`HIG = 1`), fundamental chains/products for quarks, and trace tensors otherwise. Saved `fft_basis_selection` reports the actual representation; no universal DDM or speedup claim. Forced adjoint FFT with correlators is rejected; direct contraction ignores the FFT basis. |
+| Shared-trace optimisation | conditional | applied only to pure gauge-boson processes whose Yang-Mills structure the model certificate proves; results are exact either way. |
+| Correlators | conditional | representations 1, 3, -3, 8 from complete full-colour plans in compiled execution. |
+
+## Propagators and gauge
+
+| Feature | Status | Condition and consequence |
+| --- | --- | --- |
+| Default versus custom | supported | a UFO propagator counts as custom only if its expression differs from the loader's Feynman default for that particle. |
+| Massless vectors | supported | Feynman gauge -i g/p^2, fixed. |
+| Massive vectors | supported | unitary gauge with a fixed-width denominator; matched Goldstones are absorbed. |
+| Feynman-gauge massive vectors | not applicable | no such kernel exists; Goldstone exchange appears only if the UFO supplies a custom massive-vector propagator, which is then used verbatim. |
+| Massless spin-2 | supported | de Donder propagator with dimension parameter `dim` (default 4). |
+| Massive spin-2 | experimental | Fierz-Pauli propagator behind `experimental-massive-spin-2`. |
+| Widths | supported | fixed-width Breit-Wigner denominators only; zero widths are fine; complex masses are rejected. |
+| Mass class | conditional | fixed by the restriction used at generation; runtime cards change values within that form, and setting a massive particle's mass to zero at runtime is not guarded. |
+| Custom propagators | conditional | numerator and denominator must both be defined, use only the accepted tensors and registered functions, and lower exactly to the particle's component count; no gauge conversion is applied. |
+| Disabled shortcuts | conditional | a custom propagator switches off the Weyl projection, transverse Yang-Mills lowering, Fierz auxiliary currents, reflection certificates and Goldstone removal for that particle. |
+| Custom propagator coverage | conditional | plumbed through all execution modes but not exercised end to end by the test suite. |
+| Ghost propagators | ignored | none; ghosts never propagate in tree amplitudes. |
+| Non-propagating particles | conditional | excluded from external states but not from internal lines. |
+| Gauge selection | not applicable | no option selects a gauge; the UFO must supply its own propagator for another choice. |
+| Contact auxiliaries | supported | synthesized auxiliary currents carry no propagator and introduce no pole. |
+
+## Process-level scope with a generic model
+
+| Feature | Status | Condition and consequence |
+| --- | --- | --- |
+| Model inputs at generation | supported | any accepted source kind; restriction and simplification choices apply only when compiling from UFO or JSON. |
+| Preflight gate | rejected | a model with any error code cannot generate or enumerate processes. |
+| Process shape | supported | `a b > c d ...` with exactly two incoming and at least one outgoing particle; several requests may be joined with `\|`. |
+| Loop-induced channels | rejected | tree level only; a channel without tree amplitudes is skipped with a warning inside a multiparticle request and is an error when requested alone. |
+| Multiparticle labels | conditional | `all` always exists; `p` and `j` exist only when the model has massless triplet fermions or octet vectors; define your own labels otherwise. |
+| Repetition syntax | conditional | write `3*g`; the built-in shorthands `3g` and `[d g]` are not understood by generic expansion. |
+| `flavor_scheme` | ignored | no effect on generic models; use multiparticle labels instead. |
+| `max_quark_lines` | conditional | bounds the number of external quark-antiquark pairs per subprocess; channels above it are dropped like loop-induced ones. |
+| Permutation representatives | supported | one generated representative serves every reordering within the incoming and within the outgoing side. |
+| Basis reductions | conditional | trace-reflection folding and the shared single-trace basis are applied only to certified pure Yang-Mills gluon processes; the unreduced exact basis is used otherwise. |
+| Execution modes | conditional | `compiled` works from a raw UFO or JSON model; `recurrence` (default), `eager` and `on-the-fly` need a prepared bundle: `pyamplicol model compile MODEL out.pyamplicol-model --backend jit`. |
+| Prepared-bundle clamps | conditional | the bundle fixes the backend and code-shaping settings; differing run-card values are overridden with a warning. |
+| Backends | supported | `jit`, `asm`, `cpp` for compiled mode; only JIT artifacts support arbitrary precision. |
+| Precision | conditional | `precision=16` needs no Symbolica; higher precision needs the Symbolica package and a JIT-backed recurrence, compiled or eager artifact, never on-the-fly. |
+| Symbolica at generation | supported | generation from any model needs Symbolica; double-precision evaluation of a finished artifact does not. |
+| Helicity selectors | supported | any generated helicity, by stable ID, for every accuracy and mode. |
+| On-the-fly | conditional | keeps every selector for runtime, double precision only, one-point warm-up required. |
+| Correlated Born evaluations | conditional | compiled full-colour generation with complete coverage; spin replacements on vector legs only. |
+| Numerical current reuse | conditional | off by default; `--numerical-current-reuse` enables the certified search for compiled, eager and recurrence generation. |
+
+## Related pages
+
+- [Models and Processes](models-and-processes.md) for the model workflow and
+  the `model` commands.
+- [Configuration](configuration.md) for the run-card fields referenced above.
+- [Release and Support](release-and-support.md) for the validated release
+  boundary.
diff --git a/pyamplicol/docs/user/umami-api.md b/pyamplicol/docs/user/umami-api.md
new file mode 100644
index 0000000000..bd9297ac3e
--- /dev/null
+++ b/pyamplicol/docs/user/umami-api.md
@@ -0,0 +1,323 @@
+---
+title: "UMAMI and MadSpace"
+nav_order: 3
+parent: "Python API"
+---
+<!-- SPDX-License-Identifier: 0BSD -->
+# UMAMI and MadSpace
+
+The generated `API/umami` SDK exports a matrix-element shared library implementing
+the [Unified MAtrix eleMent Interface (UMAMI)](http://docs.madgraph.org/latest/madspace/umami-api.html).
+It lets a C/C++ executable or MadSpace evaluate a pyAmpliCol artifact through the
+same Rusticol runtime used by the other [native APIs](native-apis.md).
+The library needs no Python interpreter at evaluation time.
+
+This interface is being developed on the `umami` branch. Use that branch's
+matching generation code and installed native SDK; it is not present in an
+older released wheel.
+
+`git pull` updates the checkout, not a non-editable installed package. Check the
+Python interpreter and exporter actually being imported with:
+
+```console
+python -c "import sys; import pyamplicol.artifacts.umami as umami; print(sys.executable); print(umami.__file__)"
+```
+
+To rebuild and reinstall the current branch into `.venv`, run the repository's
+existing `just dev-install` workflow from a clean checkout. Python-only changes
+can instead use `env PYTHONPATH="$PWD/src" .venv/bin/python ...` from the repository
+root when a matching native runtime is already staged; they do not require a
+new Rusticol build. See the
+[example README](https://github.com/MadGraphTeam/pyamplicol/tree/umami/umami_example#updating-a-checkout-or-stale-environment)
+for complete commands.
+
+## Generate and build
+
+Ordinary generation includes the API bundle by default:
+
+```console
+pyamplicol generate 'g g > g g g' ./artifacts/gg_ggg \
+  --model built-in-sm --color-accuracy full
+make -C artifacts/gg_ggg/API/umami
+make -C artifacts/gg_ggg/API/umami run
+```
+
+The generated directory contains `umami.h`, the adapter and provider tables, a
+Makefile, `umami_driver.c`, `metadata.json`, and usage/licensing information.
+The Makefile obtains headers and native link arguments from the active
+pyAmpliCol environment:
+
+```console
+rusticol-config --cflags
+rusticol-config --libs
+```
+
+If necessary, select the installation and build directory explicitly:
+
+```console
+make -C /absolute/artifact/API/umami \
+  RUSTICOL_CONFIG=/absolute/venv/bin/rusticol-config \
+  BUILD_DIR=/absolute/build/umami
+/absolute/build/umami/umami_driver /absolute/artifact
+```
+
+The default build directory is the sibling
+`.pyamplicol-api-build/<artifact-name>/umami`, outside the immutable artifact.
+A single provider produces **`libumami.so`** and **`umami_driver`** on both Linux
+and macOS; the `.so` suffix is retained on macOS. Rusticol is statically included
+in the provider and its symbols are hidden. The standalone driver links only
+the UMAMI library, not another copy of Rusticol. It reads a saved validation
+point and prints the matrix element as JSON. Optional arguments select a
+zero-based channel and flavour:
+
+```console
+/absolute/build/umami/umami_driver /absolute/artifact 0 0
+```
+
+### Link your executable
+
+Include the generated `umami.h` and link your executable to the generated
+library. The generated Makefile and driver are complete examples. For a
+single-provider library and paths without shell quoting requirements:
+
+```sh
+# Linux: place the executable beside libumami.so.
+cc -I/absolute/artifact/API/umami my_driver.c \
+  -L/absolute/build/umami -lumami -Wl,-rpath,'$ORIGIN' \
+  -o /absolute/build/umami/my_driver
+
+# macOS: the filename remains libumami.so.
+cc -I/absolute/artifact/API/umami my_driver.c \
+  /absolute/build/umami/libumami.so -Wl,-rpath,@loader_path \
+  -o /absolute/build/umami/my_driver
+```
+
+Keep the executable and provider together when relocating them, and retain the
+whole generated artifact and any native evaluator dependencies. `rusticol-config`
+is needed to **build the provider**, not to add a second Rusticol library to its
+consumer. Distribute the generated `UMAMI_LICENSE` notice with the provider;
+the upstream public header retains its license, independently of the adapter's
+0BSD license.
+
+## Initialization, inputs and normalization
+
+This adapter intentionally gives `param_card_path` a different meaning from the
+usual UMAMI convention: pass the **absolute artifact-directory path**, not a
+parameter-card file.
+
+```c
+#include "umami.h"
+
+UmamiHandle handle = NULL;
+UmamiStatus status = umami_initialize(&handle, "/absolute/artifact");
+if (status != UMAMI_SUCCESS) {
+    /* Report the error; do not evaluate this handle. */
+}
+/* Evaluate using umami_matrix_element, then release the handle. */
+umami_free(handle);
+```
+
+Each handle starts from the saved model defaults and owns independent mutable
+state. Use a separate handle per thread. The provider checks that the loaded
+artifact matches the one used to generate its tables. Metadata is available before
+initialization because it is compiled into the library.
+
+Momenta have components `(E, px, py, pz)` and UMAMI's column-major layout:
+
+```text
+momenta[event + stride * (particle + particle_count * component)]
+```
+
+`count` events are evaluated beginning at `offset`, with
+`offset + count <= stride`. Scalar input and output arrays use the same event
+indices. Values outside the requested output slice are untouched. Inputs must
+be finite and indices valid. Check every returned `UmamiStatus`.
+
+| Input | Meaning |
+| --- | --- |
+| `UMAMI_IN_MOMENTA` | Required momenta in the physical external order from metadata. |
+| `UMAMI_IN_CHANNEL_INDEX` | Zero-based index into `channels`; defaults to zero. |
+| `UMAMI_IN_FLAVOR_INDEX` | Zero-based index into that channel's `processes`; defaults to zero. |
+| `UMAMI_IN_ALPHA_S` | Optional per-event strong coupling, only when the model supplies an unambiguous declaration. |
+| `UMAMI_IN_RANDOM_HELICITY` | A number in `[0,1)` selecting the returned helicity index with probability proportional to its contribution. |
+| `UMAMI_IN_HELICITY_INDEX` | Evaluates only this exported helicity, an index into the metadata `helicities`. |
+
+The matrix-element output sums the artifact's **available helicities**, unless
+`UMAMI_IN_HELICITY_INDEX` selects one of them. A
+generation restricted to one helicity is therefore not an unpolarized provider;
+consult `runtime_processes[].coverage` and `helicity_ids` in the metadata.
+The result already includes Rusticol's incoming spin/colour averaging and
+identical-final-state normalization. Do not apply these factors again.
+
+LC channels select additive physical colour contributions. NLC/full-colour
+channels return the already contracted colour result, not a separately sampled
+colour flow. In particular, the absence of an LHE colour-flow reference for a
+contracted result is intentional. Metadata integration multiplicities are
+**not** silently included in `UMAMI_OUT_MATRIX_ELEMENT`: the integrator applies
+them once when assembling physical contributions.
+
+The adapter reports supported and required inputs and supported outputs through
+`umami_supported_inputs`, `umami_required_inputs` and
+`umami_supported_outputs`. Besides matrix elements, it supplies informational
+helicity indices, and colour indices for LC only. Exported helicity indices
+refer to the metadata `helicities` table, with the values in the physical
+external order of the momenta, and the sampled index follows the helicity
+distribution of the contribution. Contracted-colour providers
+do not advertise a colour-flow count or colour-index output. Random colour
+selection,
+diagram-resolved outputs and GPU execution are currently unsupported. Query
+capabilities rather than assuming every UMAMI operation is implemented.
+
+### Parameters
+
+`umami_set_parameter` and `umami_get_parameter` use the model's parameter names.
+Updates use Rusticol's validated setter and refresh dependent parameters;
+immutable or invalid values are rejected. Event-wise αs overrides are temporary
+and restore the persistent handle value after evaluation.
+
+An αs input is advertised only for an explicit model mapping or a standard UFO
+external `SMINPUTS[3]` declaration. It is not guessed from particle names or
+coupling powers. The built-in demonstration model has no such declaration, so
+its integration uses the saved coupling defaults; a suitable UFO model can
+support the optional running-coupling workflow.
+
+`UMAMI_META_MASSES` contains the **saved default** external masses and is not
+handle-specific. An integrator using these fixed masses must not change mass
+parameters without also updating its kinematics and checking the grouping
+assumptions. Regenerating the provider at the desired masses is the simplest
+consistent workflow.
+
+## Providers and generated metadata
+
+UMAMI metadata is fixed for a library, so one library cannot transparently
+switch between incompatible external sizes or mass patterns. Compatible
+processes share a provider; otherwise the SDK emits `libumami_p0.so`,
+`libumami_p1.so`, and corresponding `umami_driver_p0`, etc. The root
+`metadata.json` is then a provider index pointing to
+`providers/p0/metadata.json`, etc. Select a matching library and metadata entry;
+do not sum alternative providers without checking their process selections.
+
+For example:
+
+```console
+make -C /absolute/artifact/API/umami run PROVIDER=p0
+```
+
+A provider's metadata contains:
+
+- `provider`: fixed external size, incoming count, masses, colour accuracy and
+  optional αs parameter.
+- `channels[].processes`: the channel/flavour selectors consumed by UMAMI, with
+  physical PDGs and integration weights referenced by `matrix_elements`.
+- `pdg_ids`, `color_orders`, `color_flows` and `helicities`: shared physical
+  configuration tables. Indices are zero-based and colour-flow references can
+  be absent for contracted colour.
+- `runtime` and `members`: the representative evaluator, certified momentum
+  permutations and covered physical contributions.
+- `grouping` and `runtime_processes`: the assumptions and available coverage
+  needed to interpret those contributions correctly.
+
+Physical incoming PDGs remain oriented for PDF evaluation. Aliases name the
+same computation; they are not automatically extra integrable contributions.
+Each exported contribution uses one phase-space ordering, rather than several
+alternative maps whose naive sum would double count it.
+
+## Automatic symmetry grouping
+
+UMAMI always applies proven computation reuse and integration grouping, including
+equivalent contributions with different physical final-state flavours. There is
+no grouping setting. Using the compact integration contributions assumes
+**permutation-invariant, flavour-blind cuts and observables**, as recorded in
+`grouping.assumptions`. The `grouping` object also reports physical and exported
+contribution counts; it has no mode selector.
+
+An exporter still accepting a `grouping` argument, or saved metadata containing
+`grouping.mode`, belongs to the older contract. The example scripts reject such
+metadata, and the orchestrator checks the installed exporter before optional
+integration imports. After updating the Python code, regenerate into a new
+`--output` directory without `--reuse` and build the matching shared library.
+Old JSON and `.so` pairs cannot be repaired by editing metadata counts or
+multiplicities: the provider tables are compiled into the library. The example
+reports actual channel, representative and physical-member counts from its
+metadata.
+
+Integration contributions are quotiented by permutations of identical
+final-state PDGs, using physical **oriented** colour topology and preserving
+the available helicity coverage. There is no additional reflection quotient or
+incoming-beam exchange. With complete LC coverage, `g g > g g g` therefore
+exports four representatives for its 24 physical colour contributions, with
+integration multiplicity six each. The full-colour result is already contracted:
+it remains one contribution, with no extra factorial
+multiplier. This integration multiplicity is distinct from Rusticol's existing
+identical-final-state normalization.
+
+Equivalence is derived from model expressions and generated computation, not
+equal default parameters, particle categories or a hard-coded Standard Model
+process list. Unproved relations remain separate, except for the explicit
+`--flavor-blind` assumption described below. Grouping never assumes equal
+PDFs, exchanges the two beams, or identifies unequal mass parameters.
+
+A representative's weighted integral reproduces its orbit
+**only under the recorded assumptions**, including cuts invariant under the
+recorded permutations and blind to final-state flavour. Multiplicity times a
+representative is not the pointwise sum at a given labelled momentum point.
+Metadata retains all physical `members` and their momentum mappings for
+pointwise reconstruction.
+Arbitrary labelled-leg or species-sensitive cuts require expanding those members
+and applying each cut to its physical contribution; they cannot be applied to
+the compact weighted representatives. Physical incoming PDGs and their PDF
+weights remain distinct. Grouping metadata does not change the native evaluator
+build identity.
+
+### Flavour-blind members
+
+With `--flavor-blind`, generation keeps one representative per flavour class
+and records the other processes as ungenerated members in
+`process-groups.json`. The provider still exports every member, without a
+`runtime_processes` row of its own: its selectors evaluate the representative's
+runtime through the recorded momentum permutation, and its `members[].runtime`
+names the representative. A member with the incoming PDGs of an existing
+selector evaluated identically becomes one more `matrix_elements` row of that
+selector, like other final-state flavours; otherwise it is a selector of its
+own.
+
+The permutation may exchange the incoming legs, as between `u g > u g` and
+`g u > u g`. This relabels the member's momenta explicitly and is not a beam
+exchange assumption: the selector keeps the member's physical incoming PDGs for
+its PDF weights. Members related by charge conjugation, such as `u~ g > u~ g`,
+use the representative's colour flows reversed, so their LHE colour tags and
+helicity labels are those of the member.
+
+The equality of these matrix elements is the user's `--flavor-blind`
+assumption, not a proof. Every provider exporting such members records it as an
+additional `grouping.assumptions` entry; `process-groups.json` keeps any
+warning issued when a relabelling is not a symmetry of the model. A member
+whose relabelling moves unequal masses, or maps a restricted helicity selection
+onto a different set, is exported by a separate provider that loads the
+representative's runtime. Processes grouped numerically were generated and keep
+their ordinary export. [Process Grouping](process-grouping.md) defines the
+flavour classes, the recorded relations and their warnings.
+
+## MadSpace example
+
+The repository's
+[`umami_example`](https://github.com/MadGraphTeam/pyamplicol/tree/umami/umami_example)
+contains close adaptations of AmpliCol's loading and integration examples. They
+use the real MadSpace matrix-element loader, phase-space mappings and
+differential cross section, with VEGAS from MadNIS. The default is a bounded
+partonic `g g > g g g` run for LC and full colour, with no PDF downloads:
+
+```console
+python -m pip install -r umami_example/requirements.txt
+python umami_example/run.py
+```
+
+The orchestrator generates both artifacts, compiles the libraries and linked
+drivers, checks batched UMAMI/native numerical agreement, and writes integrated
+cross sections with statistical uncertainties. It disables numerical
+current-relation discovery during generation. Optional PDF and neural-flow
+workflows, provider selection, cuts and all commands are explained in the
+example README. Those dependencies are not part of pyAmpliCol's core install.
+The integration example uses MadSpace's massless two-beam scattering flux and
+rejects massive incoming legs; this is a limitation of that example, not of the
+UMAMI provider.
diff --git a/pyamplicol/examples/NLO_limits/README.md b/pyamplicol/examples/NLO_limits/README.md
new file mode 100644
index 0000000000..0950318103
--- /dev/null
+++ b/pyamplicol/examples/NLO_limits/README.md
@@ -0,0 +1,144 @@
+# Local NLO limit stability
+
+`nlo_limit_stability_tests.py` is a standalone, serial example using the public
+batched correlation API. It compares the full-colour `g g > g g g g` real
+matrix element with correlated `g g > g g g` Born counterterms at 1 TeV and
+`alpha_s = 1/8`. It does not import the paper's study scripts.
+
+From a checkout with pyAmpliCol, Symbolica and Matplotlib available:
+
+```sh
+python examples/NLO_limits/nlo_limit_stability_tests.py --self-test
+python examples/NLO_limits/nlo_limit_stability_tests.py --prepare-only
+python examples/NLO_limits/nlo_limit_stability_tests.py --smoke \
+  --formats double double-double --oracle-precision 160 \
+  --output .artifacts/nlo-limits/smoke.json
+python examples/NLO_limits/nlo_limit_stability_tests.py
+python examples/NLO_limits/nlo_limit_stability_tests.py --render
+```
+
+Run the smoke test before the full scan. Evaluation and generation run under
+the repository's process-tree memory watchdog, with a **10 GiB** default limit;
+generation uses one worker and one optimization core. There are no native
+builds. Existing compatible process artifacts and completed result batches
+are reused. `--render` only reads retained results and creates the two-panel
+PDF/PNG. Defaults are under `.artifacts/nlo-limits`; `--artifact-dir`,
+`--output`, and `--plot` select different locations.
+
+The ordinary real process retains default certified current reuse and its
+normal compiled colour/helicity replay. Correlated Born generation disables
+those reductions to preserve the complete source basis. The isolated precision
+adapter covers the real process's exact colour-replay arithmetic as well as
+the correlated sources and contractions.
+
+`--formats`, `--limits`, and `--exponents` select a smaller scan. The reference
+defaults to 1200 decimal digits (`--oracle-precision`); a smaller smoke oracle
+is allowed when it exceeds every selected target precision. A checkpoint is saved
+after each completed format/limit batch. A failed real-emission batch is
+bisected diagnostically, retaining its valid points; this exceptional fallback
+is recorded in `real_batch`. Measured failures are preserved on resume unless
+`--retry-failed` is explicit. Ordinary successful evaluation is batched.
+Completing a scan requires successful oracle measurements for every requested
+point; missing or failed references cause a nonzero exit after checkpointing.
+Target-precision failures remain stability data, and `--render` remains
+available for partial results.
+Results record the Git revision, artifact IDs, batch call counts, and elapsed
+times. `--prepare-only` generates/reuses the two artifacts without starting a scan.
+
+## Named results, not scalar correlation loops
+
+For each approach-point batch the script makes one Born call containing all
+requested dipoles, the ordinary Born, and the literal spin projection:
+
+```python
+from pyamplicol import CorrelatedRequest
+
+requests = {
+    "born": CorrelatedRequest("born", spin_vectors={}),
+    "spin": CorrelatedRequest("born", spin_vectors={3: spin_vectors_by_point}),
+    "T13": CorrelatedRequest("T13", spin_vectors={}),
+    # The study also includes the other nine off-diagonal Born dipoles.
+}
+results = born.evaluate_correlated_many(born_points, requests, precision=1000)
+real_part = results["T13"][point_index].real
+imaginary_part = results["T13"][point_index].imag
+point_components = {name: values[point_index] for name, values in results.items()}
+```
+
+Every tuple follows the input phase-space-point order. Request labels such as
+`"spin"` are user-defined output names; `"born"` and `"T13"` inside each request
+are generation-time colour IDs. Empty `spin_vectors={}` explicitly requests
+ordinary physical helicities, independently of any setter state. The same
+fixed Born is repeated across the trajectory; the real process is evaluated
+as its own batch. Checkpointed components retain both decimal parts.
+
+## Counterterms and mappings
+
+The metric is `(+,-,-,-)`. The collinear trajectory uses the inverse final-final
+Catani--Seymour map at fixed `z=3/5`, with `kT=delta*1000 GeV`. One generic,
+rational transverse direction is used, **without azimuthal averaging**. With
+`e=k_perp/kT`, `a=z/(1-z)+(1-z)/z`, and `CA=3`,
+
+```text
+C_collinear = (8*pi*alpha_s/s_ij) * 2*CA * [a*B + 2*z*(1-z)*B(e)]
+```
+
+`B(e)` is the literal vector replacement on Born leg 3. A five-gluon Born is
+used so this test resolves nontrivial azimuthal spin interference. The smoke
+test checks that the selected spin projection is not simply `B/2`.
+
+The separate soft trajectory has `q=delta*r` along a fixed wide-angle null
+direction. An inverse-map recoil keeps the mapped Born fixed and all real
+momenta on shell. Using mapped Born momenta `P_a` consistently,
+
+```text
+C_soft = -8*pi*alpha_s * sum_(a<b) [(P_a.P_b)/((P_a.q)*(P_b.q)) * B_ab]
+```
+
+All five Born gluons enter the ten dipoles, including incoming legs. Their
+colour charges are already crossed; there is no additional incoming sign.
+Massless diagonal eikonal terms vanish. Public final-state symmetry factors
+are removed (`R=24*R_public`, every Born object is `6*B_public`), while the
+common initial-state spin/colour averages remain. No flux or phase-space
+Jacobian is included in this pointwise comparison.
+
+These are two isolated leading-power limit tests, **not a complete NLO
+subtraction scheme**. Do not add the two counterterms together over arbitrary
+phase space. Generically `R,C~delta^-2`, `C-R~delta^-1`, and `(C-R)/R~delta`;
+the unaveraged remainder need not approach a finite value. The divergent
+remainder is integrable with the unresolved phase-space measure.
+
+The formulae follow [Catani--Seymour, equations 5.3--5.6](https://arxiv.org/pdf/hep-ph/9605323)
+and [Catani--Grazzini, equations 7, 12 and 87--89](https://arxiv.org/pdf/hep-ph/9908523).
+See also [the correlation conventions](../../docs/correlator-conventions.md).
+
+## Arithmetic and plotted quantity
+
+The three curves use actual binary64, Symbolica DoubleFloat with 31 decimal
+digits retained through Python transfers, and guarded arbitrary precision
+with 1000 output digits. This is **not** a relabelling of public
+`precision=16`/`precision=32`: those correlated calls normally use guarded
+multiprecision. The study's isolated context temporarily substitutes scalar
+operations and stage precision in explicitly listed exact-runtime modules,
+then restores them. Real binary64 uses the ordinary native evaluator; its
+correlated Born uses the explicit `evaluate_complex` binary64 entry point for
+retained Symbolica kernels, not `evaluate_complex_with_prec(..., 16)`.
+DoubleFloat is used in the sources, kernels, normalization, colour reduction,
+counterterm and final subtraction. No public runtime defaults are changed.
+The constant pi is constructed accurately and rounded once into the target
+arithmetic. These adapters intentionally support the fixed built-in-SM study:
+an unexpected model-parameter expression derivation fails explicitly instead
+of silently performing part of a double-double calculation in multiprecision.
+
+Kinematics are constructed with guard digits before target-arithmetic
+rounding; no high-precision input passes through a Python float. The source
+`s_ij` is constructed before rounding, rather than recovered from a cancelled
+binary64 dot product. The reference uses the same unrounded source family,
+so the reported error includes input rounding, evaluation and subtraction.
+
+For `F=C-R`, the plots show
+`min(1, max(0, -log10(abs((F-F_reference)/F_reference))) / tracked_digits)`.
+Zero means no retained digits, not a zero matrix element. Failed targets get
+zero only when a valid reference exists; absent or zero-remainder references
+are not turned into false stability measurements. Each panel spans
+`-log10(delta)=1,...,15`; lines only connect evaluated points.
diff --git a/pyamplicol/examples/NLO_limits/nlo_limit_stability_tests.py b/pyamplicol/examples/NLO_limits/nlo_limit_stability_tests.py
new file mode 100644
index 0000000000..e0e2930887
--- /dev/null
+++ b/pyamplicol/examples/NLO_limits/nlo_limit_stability_tests.py
@@ -0,0 +1,1098 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Fixed-azimuth collinear and wide-angle soft NLO subtraction stability.
+
+Run --smoke first. No paper-directory imports or amplitude formulae are used.
+The low-precision adapters are confined to this serial study process; they
+do not change pyAmpliCol's ordinary precision policy. See README.md for the
+physics definition and why the unaveraged remainder need not be finite.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import json
+import math
+import subprocess
+import sys
+import time
+from contextlib import contextmanager
+from decimal import Decimal, localcontext
+from functools import lru_cache
+from itertools import combinations
+from pathlib import Path
+from typing import ClassVar
+
+ROOT = Path(__file__).resolve().parents[2]
+FORMATS = {
+    "double": (16, 53 * math.log10(2)),
+    "double-double": (32, 31.0),
+    "arbitrary-1000": (1000, 1000.0),
+}
+EXPRESSIONS = {"real": "g g > g g g g", "born": "g g > g g g"}
+DIPOLES = tuple(combinations(range(1, 6), 2))
+ALPHA_S = "0.125"
+STUDY = {
+    "version": 1,
+    "real": EXPRESSIONS["real"],
+    "born": EXPRESSIONS["born"],
+    "sqrt_s": "1000",
+    "alpha_s": ALPHA_S,
+    "z_collinear": "3/5",
+    "azimuth_cos_sin": ["3/5", "4/5"],
+    "normalization": "initial averaged; final symmetry removed: R*24, B*6",
+    "difference": "F=C-R, without azimuth averaging",
+    "soft_kernel_momenta": "mapped Born; crossed colour charges; no extra signs",
+    "relation_discovery": {"real": "certified-reuse", "born": "off"},
+}
+
+
+def transport(value):
+    """Decimal transport must not make Symbolica infer a smaller precision."""
+    value = Decimal(value)
+    with localcontext() as context:
+        context.prec = max(80, len(value.as_tuple().digits))
+        return Decimal(format(value, ".79E"))
+
+
+class Binary64(Decimal):
+    """Decimal-compatible transport; every scalar operation rounds to f64."""
+
+    @classmethod
+    def operation(cls, operation, *values):
+        args = [float(value) for value in values]
+        if operation == "identity":
+            result = args[0]
+        elif operation == "add":
+            result = args[0] + args[1]
+        elif operation == "sub":
+            result = args[0] - args[1]
+        elif operation == "mul":
+            result = args[0] * args[1]
+        elif operation == "div":
+            result = args[0] / args[1]
+        elif operation == "sqrt":
+            result = math.sqrt(args[0])
+        else:
+            raise ValueError(f"unknown arithmetic operation: {operation}")
+        if not math.isfinite(result):
+            raise ArithmeticError(f"non-finite binary64 {operation}")
+        return Decimal.__new__(cls, Decimal.from_float(result))
+
+    def __new__(cls, value=0):
+        if isinstance(value, cls):
+            return value
+        return cls.operation("identity", Decimal(value))
+
+    @classmethod
+    def from_float(cls, value):
+        return cls(Decimal.from_float(value))
+
+    def __add__(self, other):
+        return self.operation("add", self, other)
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        return self.operation("sub", self, other)
+
+    def __rsub__(self, other):
+        return self.operation("sub", other, self)
+
+    def __mul__(self, other):
+        return self.operation("mul", self, other)
+
+    __rmul__ = __mul__
+
+    def __truediv__(self, other):
+        return self.operation("div", self, other)
+
+    def __rtruediv__(self, other):
+        return self.operation("div", other, self)
+
+    def __neg__(self):
+        return Decimal.__new__(type(self), Decimal.copy_negate(self))
+
+    def __abs__(self):
+        return Decimal.__new__(type(self), Decimal.copy_abs(self))
+
+    def __pos__(self):
+        return self
+
+    def __pow__(self, exponent, modulo=None):
+        if modulo is not None or int(exponent) != exponent:
+            raise TypeError("study arithmetic supports integer powers only")
+        exponent = int(exponent)
+        if exponent < 0:
+            return type(self)(1) / self ** (-exponent)
+        result, factor = type(self)(1), self
+        while exponent:
+            if exponent & 1:
+                result *= factor
+            exponent >>= 1
+            if exponent:
+                factor *= factor
+        return result
+
+    def sqrt(self, context=None):
+        return self.operation("sqrt", self)
+
+
+class DoubleDouble(Binary64):
+    """Actual Symbolica DoubleFloat arithmetic, with 31-digit transport."""
+
+    evaluators: ClassVar[dict] = {}
+
+    @classmethod
+    def operation(cls, operation, *values):
+        if operation not in cls.evaluators:
+            from symbolica import E, S
+
+            expression, names = {
+                "identity": ("x", ["x"]),
+                "add": ("x+y", ["x", "y"]),
+                "sub": ("x-y", ["x", "y"]),
+                "mul": ("x*y", ["x", "y"]),
+                "div": ("x/y", ["x", "y"]),
+                "sqrt": ("sqrt(x)", ["x"]),
+            }[operation]
+            cls.evaluators[operation] = E(expression).evaluator(
+                [S(name) for name in names]
+            )
+        result = cls.evaluators[operation].evaluate_with_prec(
+            [transport(value) for value in values], 32
+        )[0]
+        if not result.is_finite():
+            raise ArithmeticError(f"non-finite double-double {operation}")
+        return Decimal.__new__(cls, result)
+
+
+@contextmanager
+def arithmetic(format_name, precision):
+    """Study-local, restored patches: sources, kernels, coefficients, reduction.
+
+    Explicit modules only, all imported before patching. This context must not
+    be used concurrently with another evaluator; the command is serial and
+    runs under its own guarded subprocess. Fresh runtimes are loaded inside it.
+    """
+    modules = [
+        importlib.import_module(f"pyamplicol.runtime.{name}")
+        for name in (
+            "_color_weight_exact",
+            "_normalization_exact",
+            "symbolica_exact",
+            "correlated_exact",
+            "correlations",
+            "_color_topology_exact",
+        )
+    ]
+    normalization = modules[1]
+    scalar = {"double": Binary64, "double-double": DoubleDouble}.get(
+        format_name, Decimal
+    )
+    patches = []
+    normalization._pi.cache_clear()
+
+    def working_precision(requested):
+        return precision
+
+    def upcast(value, requested):
+        return transport(value)
+
+    def study_pi(requested):
+        return target_pi(scalar, precision)
+
+    def unsupported_parameter_derivation(self, values, requested):
+        raise RuntimeError(
+            "This study's low-precision adapters require built-in SM kernels "
+            "without a derived model-parameter expression evaluator"
+        )
+
+    try:
+        if scalar is not Decimal:
+            for module in modules:
+                for name, value in list(vars(module).items()):
+                    replacement = None
+                    if value is Decimal:
+                        replacement = scalar
+                    elif type(value) is Decimal:
+                        replacement = scalar(value)
+                    elif name == "_working_precision":
+                        replacement = working_precision
+                    elif name == "_upcast_decimal":
+                        replacement = upcast
+                    if replacement is not None:
+                        patches.append((module, name, value))
+                        setattr(module, name, replacement)
+            patches.append((normalization, "_pi", normalization._pi))
+            normalization._pi = lru_cache(maxsize=1)(study_pi)
+            exact = modules[2]
+            expression_class = exact._ExactExpressionEvaluator
+            patches.append((expression_class, "evaluate", expression_class.evaluate))
+            expression_class.evaluate = unsupported_parameter_derivation
+            if scalar is Binary64:
+                evaluator_class = exact._ExactEvaluator
+                original_stage = evaluator_class._evaluate_prepared
+
+                def binary64_stage(self, values, requested):
+                    if self.evaluator is None:
+                        return original_stage(self, values, requested)
+                    # with_prec(...,16) uses arbitrary Float, NOT binary64.
+                    outputs = self.evaluator.evaluate_complex(
+                        [complex(float(real), float(imag)) for real, imag in values]
+                    )[0]
+                    return tuple(
+                        (Binary64(float(value.real)), Binary64(float(value.imag)))
+                        for value in outputs
+                    )
+
+                patches.append((evaluator_class, "_evaluate_prepared", original_stage))
+                evaluator_class._evaluate_prepared = binary64_stage
+        with localcontext() as context:
+            context.prec = precision + 8 if scalar is Decimal else 80
+            yield scalar
+    finally:
+        for module, name, value in reversed(patches):
+            setattr(module, name, value)
+        normalization._pi.cache_clear()
+
+
+def arithmetic_smoke(format_name, *, kernels=False):
+    """Reject f64/MP mislabeled as DD before generating any study process."""
+    scalar = {"double": Binary64, "double-double": DoubleDouble}[format_name]
+    tiny = "1e-20"
+    observed = (scalar(1) + scalar(tiny)) - scalar(1)
+    if format_name == "double":
+        assert observed == 0
+    else:
+        assert abs(Decimal(observed) / Decimal(tiny) - 1) < Decimal("1e-10")
+        assert (scalar(1) + scalar("1e-40")) - scalar(1) == 0
+    result = {"format": format_name, "one_plus_1e_20_minus_one": str(observed)}
+    if kernels:
+        from symbolica import E, S
+
+        from pyamplicol.runtime.symbolica_exact import _ExactEvaluator
+
+        evaluator = E("x+y").evaluator([S("x"), S("y")])
+        precision = FORMATS[format_name][0]
+        exact = _ExactEvaluator(input_len=2, evaluator=evaluator)
+        with arithmetic(format_name, precision):
+            observed_kernel = Decimal(
+                exact.evaluate(
+                    ((scalar(1), scalar(0)), (scalar(tiny), scalar(0))), precision
+                )[0][0]
+            )
+            halfway = exact.evaluate(
+                ((scalar(1), scalar(0)), (scalar(2.0**-53), scalar(0))), precision
+            )[0][0]
+            if format_name == "double":
+                assert halfway == 1, "complex stage is not binary64 ties-to-even"
+            else:
+                assert halfway > 1, "complex stage lost the DoubleFloat half-ulp"
+            result["complex_kernel_one_plus_half_ulp"] = str(halfway)
+        with localcontext() as context:
+            context.prec = 80
+            residual = observed_kernel - 1
+            if format_name == "double":
+                assert residual == 0, "complex stage is not binary64"
+            else:
+                assert abs(residual / Decimal(tiny) - 1) < Decimal("1e-10"), (
+                    "complex stage lost the DoubleFloat correction"
+                )
+        result["complex_kernel_one_plus_1e_20_minus_one"] = str(residual)
+    return result
+
+
+def dot(a, b):
+    return a[0] * b[0] - sum(x * y for x, y in zip(a[1:], b[1:], strict=True))
+
+
+def linear(*terms):
+    return [sum(scale * vector[mu] for scale, vector in terms) for mu in range(4)]
+
+
+def born_geometry():
+    """The paper's rational generic 1 TeV Born point and transverse basis."""
+    d, q = Decimal, Decimal(1000)
+    n = (d(2) / 3, d(1) / 3, d(2) / 3)
+    ta = (d(2) / 3, -d(2) / 3, -d(1) / 3)
+    tb = (d(1) / 3, d(2) / 3, -d(2) / 3)
+    incoming = [[q / 2, d(0), d(0), q / 2], [q / 2, d(0), d(0), -q / 2]]
+    parent = [4 * q / 9] + [4 * q * a / 9 for a in n]
+    spectator = [5 * q / 26] + [
+        q * (-3 * a / 26 + 2 * b / 13) for a, b in zip(n, tb, strict=True)
+    ]
+    untouched = [85 * q / 234] + [
+        q * (-77 * a / 234 - 2 * b / 13) for a, b in zip(n, tb, strict=True)
+    ]
+    e1 = [d(0), *ta]
+    e2 = [d(1) / 2] + [a / 2 + b for a, b in zip(n, tb, strict=True)]
+    return [*incoming, parent, spectator, untouched], e1, e2
+
+
+def constraint_checks(point):
+    q = Decimal(1000)
+    return {
+        "mass_shell_over_s": str(max(abs(dot(p, p)) for p in point) / q**2),
+        "conservation_over_Q": str(
+            max(
+                abs(point[0][mu] + point[1][mu] - sum(p[mu] for p in point[2:]))
+                for mu in range(4)
+            )
+            / q
+        ),
+        "positive_energies": all(p[0] > 0 for p in point),
+    }
+
+
+def forward_map(point):
+    pi, pj, pk = point[2:5]
+    ij, ik, jk = dot(pi, pj), dot(pi, pk), dot(pj, pk)
+    y = ij / (ij + ik + jk)
+    z = ik / (ik + jk)
+    mapped = [
+        *point[:2],
+        linear((1, pi), (1, pj), (-y / (1 - y), pk)),
+        linear((1 / (1 - y), pk)),
+        point[5],
+    ]
+    return mapped, y, z, 2 * ij
+
+
+def make_point(limit, exponent, digits=1280):
+    """One high-precision source point; no target arithmetic is used here."""
+    if limit not in {"collinear", "soft"} or exponent < 1 or digits < 16:
+        raise ValueError("invalid limit, exponent, or source precision")
+    with localcontext() as context:
+        context.prec = max(digits + 80, 2 * exponent + 80)
+        born, e1, e2 = born_geometry()
+        parent, spectator = born[2:4]
+        delta, q = Decimal(10) ** -exponent, Decimal(1000)
+        e = linear((Decimal(3) / 5, e1), (Decimal(4) / 5, e2))
+        if limit == "collinear":
+            z = Decimal(3) / 5
+            kt = delta * q
+            transverse = linear((kt, e))
+            y = kt**2 / (2 * z * (1 - z) * dot(parent, spectator))
+        else:
+            r = [q / 2] + [q * a / 2 for a in e1[1:]]
+            alpha = dot(r, spectator) / dot(parent, spectator)
+            beta = dot(r, parent) / dot(parent, spectator)
+            r_perp = linear((1, r), (-alpha, parent), (-beta, spectator))
+            z = 1 - delta * alpha
+            y = delta * beta / z
+            transverse = linear((-delta, r_perp))
+        if not (0 < z < 1 and 0 < y < 1):
+            raise ValueError("trajectory outside the physical inverse-map domain")
+        pi = linear((z, parent), (y * (1 - z), spectator), (1, transverse))
+        pj = linear((1 - z, parent), (y * z, spectator), (-1, transverse))
+        pk = linear((1 - y, spectator))
+        real = [*born[:2], pi, pj, pk, born[4]]
+        mapped, actual_y, actual_z, sij = forward_map(real)
+        checks = constraint_checks(real)
+        checks["mapped_born_over_Q"] = str(
+            max(
+                abs(a - b)
+                for p, r in zip(mapped, born, strict=True)
+                for a, b in zip(p, r, strict=True)
+            )
+            / q
+        )
+        checks["y_error"] = str(abs(actual_y - y))
+        checks["z_error"] = str(abs(actual_z - z))
+        with localcontext() as output:
+            output.prec = digits
+
+            def strings(vectors):
+                return [[str(+value) for value in p] for p in vectors]
+
+            return {
+                "limit": limit,
+                "exponent": exponent,
+                "delta": str(delta),
+                "real": strings(real),
+                "born": strings(born),
+                "spin": strings([e])[0],
+                "basis": strings([e1, e2]),
+                "s_ij": str(+sij),
+                "z": str(+z),
+                "y": str(+y),
+                "checks": checks,
+            }
+
+
+@lru_cache(maxsize=8)
+def target_pi(scalar, precision):
+    if scalar is Binary64:
+        return scalar(math.pi)
+    from symbolica import E
+
+    # Pi is a constant input, rounded once into the target arithmetic. Asking
+    # Expression.evaluate(...,32) would perform arbitrary, not DD, arithmetic.
+    working = 80 if scalar is DoubleDouble else precision + 8
+    return scalar(E("pi").evaluate({}, decimal_digit_precision=working)[0])
+
+
+def counterterm(source, values, scalar, pi):
+    """All inputs include public normalization; remove only final factorials."""
+    b = scalar(6) * scalar(values["born"].real)
+    prefactor = scalar(8) * pi * scalar(ALPHA_S)
+    if source["limit"] == "collinear":
+        z, sij = scalar(source["z"]), scalar(source["s_ij"])
+        spin = scalar(6) * scalar(values["spin"].real)
+        a = z / (scalar(1) - z) + (scalar(1) - z) / z
+        return (
+            prefactor
+            / sij
+            * scalar(6)
+            * (a * b + scalar(2) * z * (scalar(1) - z) * spin)
+        )
+    born = [[scalar(v) for v in p] for p in source["born"]]
+    soft = [scalar(v) for v in source["real"][3]]
+    total = scalar(0)
+    for a, b in DIPOLES:
+        pa, pb = born[a - 1], born[b - 1]
+        weight = dot(pa, pb) / (dot(pa, soft) * dot(pb, soft))
+        total += weight * scalar(6) * scalar(values[f"T{a}{b}"].real)
+    return -prefactor * total
+
+
+def declarations():
+    from pyamplicol import ColorCorrelator, CorrelatorConfig
+
+    return CorrelatorConfig(
+        color_correlations=tuple(
+            ColorCorrelator.dipole(f"T{a}{b}", a, b) for a, b in (*DIPOLES, (3, 3))
+        ),
+        spin_correlations=((3,),),
+    )
+
+
+def correlation_requests(sources, diagnostics=False):
+    from pyamplicol import CorrelatedRequest
+
+    requests = {
+        "born": CorrelatedRequest("born", spin_vectors={}),
+        "spin": CorrelatedRequest(
+            "born", spin_vectors={3: [source["spin"] for source in sources]}
+        ),
+        **{
+            f"T{a}{b}": CorrelatedRequest(f"T{a}{b}", spin_vectors={})
+            for a, b in DIPOLES
+        },
+    }
+    if diagnostics:
+        requests["T33"] = CorrelatedRequest("T33", spin_vectors={})
+        for name, key in (("basis1", 0), ("basis2", 1)):
+            requests[name] = CorrelatedRequest(
+                "born", spin_vectors={3: [source["basis"][key] for source in sources]}
+            )
+        requests["ward"] = CorrelatedRequest(
+            "born", spin_vectors={3: [source["born"][2] for source in sources]}
+        )
+    return requests
+
+
+def generate_artifacts(directory):
+    """One standard generation per missing output; never overwrite an artifact."""
+    import tomllib
+
+    from pyamplicol import Generator, ModelSource
+    from pyamplicol.config import (
+        ColorConfig,
+        EvaluatorConfig,
+        EvaluatorOptimizationConfig,
+        GenerationConfig,
+        RunConfig,
+    )
+
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="full", contraction="direct"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="compiled",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+        ),
+    )
+    paths = {name: directory / name for name in EXPRESSIONS}
+    identities = {}
+    for name, path in paths.items():
+        if not (path / "artifact.json").exists():
+            print(f"Generating {name}: {EXPRESSIONS[name]}", flush=True)
+            Generator(config).generate(
+                EXPRESSIONS[name],
+                path,
+                model=ModelSource.built_in_sm(),
+                correlators=declarations() if name == "born" else None,
+            )
+        manifest = json.loads((path / "artifact.json").read_text())
+        effective = tomllib.loads((path / "config" / "effective.toml").read_text())
+        if (
+            len(manifest["processes"]) != 1
+            or manifest["processes"][0]["expression"] != EXPRESSIONS[name]
+            or effective["color"]["accuracy"] != "full"
+            or effective["color"]["contraction"] != "direct"
+            or effective["evaluator"]["execution_mode"] != "compiled"
+            or effective["generation"]["relation_discovery"]["mode"]
+            != STUDY["relation_discovery"][name]
+        ):
+            raise ValueError(
+                f"Incompatible study artifact {path}; choose a fresh directory"
+            )
+        if name == "born":
+            catalogue = json.loads((path / "correlators.json").read_text())
+            expected = declarations().to_json_dict()
+            if (
+                catalogue["declarations"] != expected
+                or not catalogue.get("processes")
+                or any(
+                    process.get("declarations") != expected
+                    for process in catalogue["processes"].values()
+                )
+            ):
+                raise ValueError(
+                    f"Incompatible correlation declarations in {path}; "
+                    "choose a fresh artifact directory"
+                )
+        identities[name] = manifest["artifact_id"]
+    return paths, identities
+
+
+def evaluate_real_batch(runtime, sources, format_name, precision, scalar):
+    """Normal path: one batch. Bisect only after a genuine batch exception."""
+    points = [source["real"] for source in sources]
+    if format_name == "double":
+        points = [[[float(v) for v in p] for p in point] for point in points]
+    calls, errors = 0, {}
+
+    def run(batch, start):
+        nonlocal calls
+        calls += 1
+        try:
+            if format_name == "double":
+                values = runtime.evaluate(batch, precision=16)
+                result = [scalar(complex(value).real) for value in values]
+            else:
+                # Sum resolved DD values in DD, not an exact Decimal helper.
+                resolved = runtime.evaluate_resolved(batch, precision=precision)
+                result = [
+                    sum((scalar(v) for row in point for v in row), scalar(0))
+                    for point in resolved.values
+                ]
+            if len(result) != len(batch):
+                raise ValueError("real evaluator returned an inconsistent batch size")
+            for index, value in enumerate(result):
+                if not value.is_finite() or value <= 0:
+                    errors[start + index] = "non-finite or nonpositive real result"
+                    result[index] = None
+            return result
+        except Exception as exc:
+            if len(batch) == 1:
+                errors[start] = f"{type(exc).__name__}: {exc}"
+                return [None]
+            middle = len(batch) // 2
+            return run(batch[:middle], start) + run(batch[middle:], start + middle)
+
+    values = run(points, 0)
+    return values, {"calls": calls, "diagnostic_bisection": calls > 1, "errors": errors}
+
+
+def validate_correlations(values, precision):
+    """Dimensionless checks; no high-multiplicity real ME is needed here."""
+    with localcontext() as context:
+        context.prec = max(40, precision + 8)
+        b = Decimal(values["born"].real)
+        if b <= 0:
+            raise AssertionError("Born result must be positive")
+        tolerance = Decimal(10) ** (-min(20, max(8, precision - 6)))
+        checks = {
+            "completeness": abs(
+                (Decimal(values["basis1"].real) + Decimal(values["basis2"].real)) / b
+                - 1
+            ),
+            "ward": abs(Decimal(values["ward"].real) / (b * Decimal(1000) ** 2)),
+            "casimir": abs(Decimal(values["T33"].real) / b - 3),
+            "imaginary": max(abs(Decimal(v.imag)) for v in values.values()) / b,
+        }
+        for leg in range(1, 6):
+            others = [
+                tuple(sorted((leg, other))) for other in range(1, 6) if other != leg
+            ]
+            checks[f"coherence_{leg}"] = abs(
+                sum((Decimal(values[f"T{a}{b}"].real) for a, b in others), 3 * b) / b
+            )
+        if any(value > tolerance for value in checks.values()):
+            raise AssertionError(f"Born correlation checks failed: {checks}")
+        anisotropy = abs(Decimal(values["spin"].real) / b - Decimal("0.5"))
+        if anisotropy < Decimal("1e-8"):
+            raise AssertionError("chosen Born/vector does not resolve spin anisotropy")
+        return {
+            **{key: str(value) for key, value in checks.items()},
+            "spin_anisotropy": str(anisotropy),
+        }
+
+
+def evaluate_batch(paths, sources, format_name, precision, *, diagnostics=False):
+    from pyamplicol import Runtime
+
+    with arithmetic(format_name, precision) as scalar:
+        started = time.perf_counter()
+        real = Runtime.load(
+            paths["real"],
+            model_parameters={
+                "alpha_s": float(ALPHA_S),
+            },
+        )
+        born = Runtime.load(
+            paths["born"],
+            model_parameters={
+                "alpha_s": float(ALPHA_S),
+            },
+        )
+        requests = correlation_requests(sources, diagnostics=diagnostics)
+        loaded = time.perf_counter()
+        # One public call: every requested colour/spin contraction, every point.
+        results = born.evaluate_correlated_many(
+            [source["born"] for source in sources],
+            requests,
+            precision=precision,
+        )
+        correlated_done = time.perf_counter()
+        # Public named access: results["T13"][point_index].real / .imag.
+        real_values, real_diagnostics = evaluate_real_batch(
+            real,
+            sources,
+            format_name,
+            precision,
+            scalar,
+        )
+        real_done = time.perf_counter()
+        pi = target_pi(scalar, precision)
+        records = []
+        for index, (source, real_value) in enumerate(
+            zip(sources, real_values, strict=True)
+        ):
+            components = {name: values[index] for name, values in results.items()}
+            record = {
+                "limit": source["limit"],
+                "exponent": source["exponent"],
+                "format": format_name,
+                "precision": precision,
+                "delta": source["delta"],
+                "source_checks": source["checks"],
+                "correlations": {
+                    name: {"real": str(value.real), "imag": str(value.imag)}
+                    for name, value in components.items()
+                },
+                "real_batch": real_diagnostics,
+            }
+            if diagnostics:
+                record["correlation_checks"] = validate_correlations(
+                    components, precision
+                )
+            try:
+                if real_value is None:
+                    raise ArithmeticError(real_diagnostics["errors"][index])
+                r = scalar(24) * real_value
+                c = counterterm(source, components, scalar, pi)
+                f = c - r
+                if not all(value.is_finite() for value in (r, c, f)):
+                    raise ArithmeticError("non-finite subtraction")
+                record.update(
+                    {
+                        "status": "ok",
+                        "R": str(r),
+                        "C": str(c),
+                        "F": str(f),
+                        "C_over_R": str(c / r),
+                        "F_over_R": str(f / r),
+                    }
+                )
+                if source["limit"] == "collinear":
+                    z, sij = scalar(source["z"]), scalar(source["s_ij"])
+                    pgg = scalar(6) * (z / (1 - z) + (1 - z) / z + z * (1 - z))
+                    averaged = scalar(8) * pi * scalar(ALPHA_S) / sij * pgg
+                    averaged *= scalar(6) * scalar(components["born"].real)
+                    record["spin_averaged_control_over_R"] = str((averaged - r) / r)
+            except (ArithmeticError, ValueError) as exc:
+                record.update({"status": "failed", "error": str(exc)})
+            records.append(record)
+        batch = {
+            "point_count": len(sources),
+            "request_count": len(requests),
+            "public_correlated_many_calls": 1,
+            "public_real_calls": real_diagnostics["calls"],
+            "runtime_load_seconds": loaded - started,
+            "correlations_seconds": correlated_done - loaded,
+            "real_seconds": real_done - correlated_done,
+            "combination_seconds": time.perf_counter() - real_done,
+        }
+        for record in records:
+            record["batch"] = batch
+        # Adapter-specific caches cannot survive into the next format.
+        del born, real
+        return records
+
+
+def record_key(record):
+    return f"{record['limit']}:{record['format']}:{record['exponent']}"
+
+
+def pending_exponents(report, limit, format_name, exponents, *, retry_failed=False):
+    """A measured failure is data, not an implicit request for endless retries."""
+    return [
+        x
+        for x in exponents
+        if f"{limit}:{format_name}:{x}" not in report["records"]
+        or (
+            retry_failed
+            and report["records"][f"{limit}:{format_name}:{x}"]["status"] != "ok"
+        )
+    ]
+
+
+def git_revision():
+    try:
+        return subprocess.check_output(
+            ["git", "-C", str(ROOT), "rev-parse", "HEAD"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        ).strip()
+    except (OSError, subprocess.CalledProcessError):
+        return None
+
+
+def compare_records(record, reference):
+    if reference is None or reference.get("status") != "ok":
+        return {"reference_status": "missing"}
+    if record.get("status") != "ok":
+        return {"reference_status": "ok", "stable_digits": "0", "stable_fraction": 0.0}
+    with localcontext() as context:
+        context.prec = int(reference["precision"]) + 30
+        expected, observed = Decimal(reference["F"]), Decimal(record["F"])
+        if expected == 0:
+            return {"reference_status": "zero-remainder"}
+        error = abs((observed - expected) / expected)
+        tracked = Decimal(str(FORMATS[record["format"]][1]))
+        digits = (
+            tracked if error == 0 else min(tracked, max(Decimal(0), -error.log10()))
+        )
+        return {
+            "reference_status": "ok",
+            "epsilon_F": str(error),
+            "stable_digits": str(digits),
+            "stable_fraction": float(digits / tracked),
+        }
+
+
+def update_comparisons(report):
+    for record in report["records"].values():
+        if record["format"] != "oracle":
+            reference = report["records"].get(
+                f"{record['limit']}:oracle:{record['exponent']}"
+            )
+            record.update(compare_records(record, reference))
+
+
+def checkpoint(path, report):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(
+        json.dumps(report, indent=2, sort_keys=True, allow_nan=False) + "\n"
+    )
+    temporary.replace(path)
+
+
+def validate_factorization(report):
+    """Only the well-resolved oracle determines the physics convergence test."""
+    for limit in ("collinear", "soft"):
+        points = sorted(
+            (
+                r
+                for r in report["records"].values()
+                if r["limit"] == limit
+                and r["format"] == "oracle"
+                and r["status"] == "ok"
+            ),
+            key=lambda r: r["exponent"],
+        )
+        if len(points) < 2:
+            continue
+        errors = [abs(Decimal(point["F_over_R"])) for point in points]
+        if errors[-1] >= errors[0] / 3 or errors[-1] >= Decimal("0.01"):
+            raise AssertionError(f"{limit} counterterm does not converge: {errors}")
+
+
+def validate_requested_oracles(report, limits, exponents):
+    """A completed scan needs references; partial render-only requests do not."""
+    missing = [
+        key
+        for limit in limits
+        for exponent in exponents
+        if report["records"].get(key := f"{limit}:oracle:{exponent}", {}).get("status")
+        != "ok"
+    ]
+    if missing:
+        raise ValueError(
+            "Missing or failed requested oracle measurements: "
+            + ", ".join(missing)
+            + ". Checkpoints are retained; use --retry-failed to retry failures "
+            "or --render to redraw available results."
+        )
+
+
+def render(report, output):
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    styles = {
+        "double": ("Double precision", "#cc6600", "--", "o"),
+        "double-double": ("DoubleFloat (31 digits)", "#2767ad", "-.", "s"),
+        "arbitrary-1000": ("1000 decimal digits", "#23834a", "-", "D"),
+    }
+    plt.rcParams.update(
+        {
+            "font.family": "serif",
+            "font.serif": ["DejaVu Serif"],
+            "mathtext.fontset": "cm",
+            "font.size": 10,
+            "axes.labelsize": 11,
+            "axes.titlesize": 11,
+            "xtick.labelsize": 9,
+            "ytick.labelsize": 9,
+            "axes.linewidth": 0.7,
+            "pdf.fonttype": 42,
+            "ps.fonttype": 42,
+        }
+    )
+    figure, axes = plt.subplots(
+        1, 2, figsize=(10.5, 4), sharey=True, layout="constrained"
+    )
+    for axis, limit in zip(axes, ("collinear", "soft"), strict=True):
+        for name in FORMATS:
+            points = sorted(
+                (
+                    r
+                    for r in report["records"].values()
+                    if r["limit"] == limit
+                    and r["format"] == name
+                    and "stable_fraction" in r
+                    and 1 <= r["exponent"] <= 15
+                ),
+                key=lambda r: r["exponent"],
+            )
+            if points:
+                label, color, linestyle, marker = styles[name]
+                axis.plot(
+                    [p["exponent"] for p in points],
+                    [p["stable_fraction"] for p in points],
+                    color=color,
+                    linestyle=linestyle,
+                    label=label,
+                    marker=marker,
+                    markerfacecolor="white",
+                    markersize=3.4,
+                    linewidth=1.5,
+                    markeredgewidth=0.8,
+                )
+        axis.set(
+            title={"collinear": "Fixed-azimuth collinear", "soft": "Wide-angle soft"}[
+                limit
+            ],
+            xlabel=r"$-\log_{10}\delta$",
+            xlim=(0.8, 15.2),
+            ylim=(-0.012, 1.03),
+        )
+        axis.set_xticks(range(1, 16, 2))
+        axis.set_yticks([0, 0.2, 0.4, 0.6, 0.8, 1])
+        axis.grid(color="0.86", linewidth=0.45)
+        axis.tick_params(direction="in", top=True, right=True)
+    axes[0].set_ylabel("Stable-digit fraction")
+    axes[1].legend(
+        loc="center right",
+        bbox_to_anchor=(0.985, 0.54),
+        frameon=False,
+        fontsize=8.5,
+        handlelength=2.6,
+    )
+    output.parent.mkdir(parents=True, exist_ok=True)
+    figure.savefig(output.with_suffix(".pdf"))
+    figure.savefig(output.with_suffix(".png"), dpi=170)
+    plt.close(figure)
+
+
+def parser():
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument(
+        "--artifact-dir", type=Path, default=Path(".artifacts/nlo-limits")
+    )
+    result.add_argument(
+        "--output", type=Path, default=Path(".artifacts/nlo-limits/results.json")
+    )
+    result.add_argument(
+        "--formats", nargs="+", choices=tuple(FORMATS), default=list(FORMATS)
+    )
+    result.add_argument(
+        "--limits",
+        nargs="+",
+        choices=("collinear", "soft"),
+        default=["collinear", "soft"],
+    )
+    result.add_argument("--exponents", nargs="+", type=int, default=list(range(1, 16)))
+    result.add_argument("--oracle-precision", type=int, default=1200)
+    result.add_argument("--memory-limit-gib", type=float, default=10.0)
+    result.add_argument(
+        "--prepare-only",
+        action="store_true",
+        help="Generate/reuse process artifacts without evaluating the scan",
+    )
+    result.add_argument(
+        "--retry-failed",
+        action="store_true",
+        help="Explicitly retry measured failures; default preserves them",
+    )
+    result.add_argument(
+        "--smoke", action="store_true", help="Only x=2,3,4; check physics identities"
+    )
+    result.add_argument(
+        "--self-test", action="store_true", help="Kinematics only; no Symbolica"
+    )
+    result.add_argument(
+        "--render",
+        action="store_true",
+        help="Render retained JSON only; no evaluations",
+    )
+    result.add_argument(
+        "--plot", type=Path, help="PDF/PNG output stem; defaults next to results"
+    )
+    result.add_argument("--_guard-child", action="store_true", help=argparse.SUPPRESS)
+    return result
+
+
+def self_test():
+    for limit in ("collinear", "soft"):
+        for exponent in (1, 4, 15, 100):
+            source = make_point(limit, exponent, digits=300)
+            for key, value in source["checks"].items():
+                if key == "positive_energies":
+                    assert value
+                else:
+                    assert Decimal(value) < Decimal("1e-175"), (limit, exponent, key)
+    arithmetic_smoke("double")
+    print("Kinematics and binary64 arithmetic checks passed.")
+
+
+def main(argv=None):
+    arguments = list(sys.argv[1:] if argv is None else argv)
+    args = parser().parse_args(arguments)
+    if args.self_test:
+        self_test()
+        return 0
+    if args.render:
+        render(
+            json.loads(args.output.read_text()),
+            args.plot or args.output.with_suffix(""),
+        )
+        return 0
+    if (
+        args.oracle_precision <= max(FORMATS[name][0] for name in args.formats)
+        or min(args.exponents) < 1
+    ):
+        raise ValueError(
+            "oracle precision must exceed every selected target; "
+            "exponents must be positive"
+        )
+    if not math.isfinite(args.memory_limit_gib) or args.memory_limit_gib <= 0:
+        raise ValueError("a positive finite process-tree memory guard is required")
+    if not args._guard_child:
+        watchdog = ROOT / "tools" / "ci" / "memory_watchdog.py"
+        return subprocess.call(
+            [
+                sys.executable,
+                str(watchdog),
+                "--limit-gib",
+                str(args.memory_limit_gib),
+                "--",
+                sys.executable,
+                str(Path(__file__).resolve()),
+                *arguments,
+                "--_guard-child",
+            ]
+        )
+    if args.prepare_only:
+        started = time.perf_counter()
+        _, identities = generate_artifacts(args.artifact_dir)
+        print(
+            json.dumps(
+                {
+                    "artifacts": identities,
+                    "git_revision": git_revision(),
+                    "preparation_seconds": time.perf_counter() - started,
+                }
+            ),
+            flush=True,
+        )
+        return 0
+    arithmetic_checks = []
+    for name in args.formats:
+        if name in ("double", "double-double"):
+            check = arithmetic_smoke(name, kernels=True)
+            arithmetic_checks.append(check)
+            print(json.dumps(check), flush=True)
+    exponents = [2, 3, 4] if args.smoke else sorted(set(args.exponents))
+    report = {"study": STUDY, "oracle_precision": args.oracle_precision, "records": {}}
+    if args.output.exists():
+        report = json.loads(args.output.read_text())
+        if (
+            report["study"] != STUDY
+            or report["oracle_precision"] != args.oracle_precision
+        ):
+            raise ValueError(
+                "Existing report has a different study definition; choose --output"
+            )
+    report["arithmetic_checks"] = arithmetic_checks
+    report["git_revision"] = git_revision()
+    prepared = time.perf_counter()
+    paths, identities = generate_artifacts(args.artifact_dir)
+    report["preparation_seconds"] = time.perf_counter() - prepared
+    if report.get("artifacts", identities) != identities:
+        raise ValueError(
+            "Report belongs to different process artifacts; choose --output"
+        )
+    report["artifacts"] = identities
+    for name in ["oracle", *args.formats]:
+        precision = args.oracle_precision if name == "oracle" else FORMATS[name][0]
+        for limit in args.limits:
+            missing = pending_exponents(
+                report, limit, name, exponents, retry_failed=args.retry_failed
+            )
+            if not missing:
+                continue
+            print(f"Evaluating {limit}, {name}: x={missing}", flush=True)
+            sources = [
+                make_point(limit, x, digits=args.oracle_precision + 80) for x in missing
+            ]
+            records = evaluate_batch(
+                paths, sources, name, precision, diagnostics=args.smoke
+            )
+            for record in records:
+                record["git_revision"] = report["git_revision"]
+                report["records"][record_key(record)] = record
+            update_comparisons(report)
+            checkpoint(args.output, report)
+    validate_requested_oracles(report, args.limits, exponents)
+    validate_factorization(report)
+    render(report, args.plot or args.output.with_suffix(""))
+    print(f"Saved {args.output}", flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/examples/README.md b/pyamplicol/examples/README.md
new file mode 100644
index 0000000000..23c030c19f
--- /dev/null
+++ b/pyamplicol/examples/README.md
@@ -0,0 +1,499 @@
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Packaged Examples
+
+All TOML cards use schema version 1 and resolve paths relative to themselves.
+Create an editable workspace whose model/data assets are independent of the
+installation location with:
+
+```console
+pyamplicol examples copy ./pyamplicol-examples
+cd pyamplicol-examples
+```
+
+Keep the environment containing pyAmpliCol activated for top-level CLI and
+Python commands below, or invoke its executables by explicit path. Generated
+artifact API drivers additionally support the canonical source workflow: when
+the copied workspace is below a checkout containing `.venv` from
+`just dev-install`, the Python driver and C, C++, Fortran, and Rust Makefiles
+find that environment automatically. Explicit `RUSTICOL_CONFIG` and an active
+`PATH` still take precedence.
+
+The primary example uses the serialized external Standard Model and generates
+seven tree-level representatives for `p p > Z j j`. They cover all 18 ordered
+tree-level channels through automatic incoming/outgoing permutations.
+Expansion also finds `g g > Z g g`, which is loop-induced and therefore
+omitted:
+
+```console
+pyamplicol generate_pp_zjj_from_ufo_sm.toml
+pyamplicol evaluate_total.toml
+pyamplicol evaluate_resolved.toml
+pyamplicol benchmark.toml
+```
+
+`evaluate_total.toml` selects the concrete channel through the requested public
+ordering `d d~ > g z g`. Its representative stable ID is
+`p_p_to_z_j_j_3`. Its
+parameter card updates the genuine UFO external inputs `aS` and `MZ`.
+These three showcase cards print colorized terminal tables by default. Add
+`--json` when a machine-readable result is wanted instead.
+
+## Run Cards
+
+| File | Coverage |
+| --- | --- |
+| `generate_pp_zjj_from_ufo_sm.toml` | Generate a portable compiled-JIT-O2 multiprocess `p p > Z j j` artifact from the serialized UFO SM |
+| `evaluate_total.toml` | Optimized total for one `pp_zjj` subprocess |
+| `evaluate_resolved.toml` | Helicity/color-resolved evaluation and explicit sum |
+| `benchmark.toml` | Short topology-replay benchmark of the same subprocess at one selected flow |
+| `qq_z6g_recurrence_jit_o2.toml` | `u u~ > Z + 6g` through the default recurrence schedule and prepared JIT O2 kernels |
+| `qq_z6g_compiled_jit_o3.toml` | The same `Z + 6g` workload through process-local compiled-DAG JIT O3 execution |
+| `qq_z6g_eager_jit_o2.toml` | The same `Z + 6g` workload through eager-DAG execution and prepared JIT O2 kernels |
+| `benchmark_z6g_single_flow_helicity_sum.toml` | Profile the default topology-replay layout for runtime flow selection with a helicity sum in `u u~ > Z + 6g` |
+| `benchmark_z6g_all_flows_single_helicity.toml` | Profile the explicit all-flow-union layout for an all-flow sum at one runtime-selected helicity in `u u~ > Z + 6g` |
+| `benchmark_z6g_generation_specialized_flow_helicity_sum.toml` | Generation-specialized flow baseline for the reusable-selector comparison |
+| `benchmark_z6g_generation_specialized_all_flows_single_helicity.toml` | Generation-specialized helicity baseline for the reusable-selector comparison |
+| `process_set_mixed_multiplicity.toml` | Named UFO-SM 2-to-2 and 2-to-3 requests |
+| `external_ufo_sm.toml` | Trusted UFO execution path |
+| `external_json_scalars.toml` | Scalar contact model and repeated particles |
+| `external_json_scalar_gravity.toml` | Proven massless spin-2 model path |
+| `builtin_sm_lc.toml` | Built-in compatibility SM, default recurrence JIT O2, `u u~ > g g`, LC |
+| `builtin_sm_nlc.toml` | Built-in compatibility SM, default recurrence JIT O2, contracted NLC |
+| `builtin_sm_full.toml` | Built-in compatibility SM, explicit compiled C++, contracted full color |
+| `builtin_sm_adjoint_fft.toml` | Certified pure-gluon tree, recurrence full color in the adjoint DDM FFT basis |
+| `builtin_sm_heft.toml` | Packaged scalar HEFT `g g > H g g`, one insertion, recurrence JIT O2 with adjoint DDM FFT |
+| `builtin_sm_eager.toml` | Built-in SM LC generation using the wheel-owned prepared JIT O2 pack |
+| `builtin_sm_on_the_fly.toml` | Built-in SM LC generation as a compact on-the-fly seed using the same prepared JIT O2 pack |
+| `otf_pp_zjj.toml` | Generate compact OTF LC `p p > Z j j`, then profile one flow with a helicity sum |
+| `generate_pp_4j_flavor_blind.toml` | Flavour-blind built-in SM `p p > j j j j` at `QED = 0`, LC: 23 generated representatives for 486 subprocesses |
+| `inspect_pp_4j.toml` | Summary of that artifact, including its process-group map |
+| `evaluate_pp_4j_member.toml` | Evaluate the non-generated member `u~ g > u~ g g g` through its representative |
+| `group_pp_4j.toml` | Numerical `group-processes` analysis of the generated representatives |
+| `all_options.toml` | Every current schema field, active and commented |
+
+## Generate Pure Gluons With Adjoint FFT
+
+This is the primary FFT example for certified pure Yang–Mills trees; the card
+selects adjoint explicitly rather than relying on the trace configuration
+default.
+
+```console
+pyamplicol generate --card builtin_sm_adjoint_fft.toml
+pyamplicol inspect artifacts/builtin_sm_adjoint_fft
+```
+
+The card keeps the same amplitude in the two-anchor DDM basis: for its five
+external gluons, it retains `3!` ordered amplitudes instead of the trace
+basis's `4!`. To use the original trace FFT, pass `--fft trace`. Either basis
+also supports `--execution-mode on-the-fly`; choose a different output path
+when comparing artifacts. The adjoint request adaptively selects DDM for
+certified Yang–Mills and single-insertion HEFT trees, exact fundamental
+chains/products for quarks, and trace tensors otherwise. Inspect saved
+`fft_basis_selection` for the actual representation and selection reason.
+Correlated generation is not supported by this option. In the benchmarked pure-gluon
+family the adjoint basis was faster than trace for six or more external gluons
+(3.9x per sample at ten gluons); compare setup and warmed runtime for other
+workloads.
+The generated Python, C, C++, Fortran, and Rust drivers need no new runtime
+option to evaluate it.
+
+## Generate Scalar HEFT Higgs Plus Two Jets
+
+The scalar HEFT card uses the packaged `built-in-sm-heft` model, so it does not
+need an external UFO checkout:
+
+```console
+pyamplicol generate --card builtin_sm_heft.toml
+pyamplicol inspect artifacts/builtin_sm_heft
+```
+
+The explicit `HIG = 1` limit retains one effective Higgs-gluon insertion and
+allows the certified DDM colour reduction. The four gluons in this example
+have `2!` DDM orderings instead of `3!` trace orderings; the Higgs is not
+counted as a coloured leg. The artifact uses full-colour recurrence over the
+wheel-owned prepared JIT O2 kernels. Use `--fft trace` to compare the original
+representation, without assuming a speedup at every multiplicity. See the website's
+[Models and Processes](https://madgraph.org/pyamplicol/user/models-and-processes/)
+guide for execution-mode and trusted-UFO details.
+
+## Process Grouping With `p p > j j j j`
+
+With five massless quark flavours, `p p > j j j j` expands into 486
+subprocesses. In pure QCD they fall into 23 classes whose members share one
+matrix element, related by a relabelling of quark flavours, charge
+conjugation, and a reordering of the legs within each side. Four cards
+generate one representative per class, show the grouping, evaluate a
+subprocess that was never generated, and run the numerical analysis:
+
+```console
+pyamplicol generate_pp_4j_flavor_blind.toml
+pyamplicol inspect_pp_4j.toml
+pyamplicol evaluate_pp_4j_member.toml
+pyamplicol group_pp_4j.toml
+```
+
+The same steps run in the private `examples run` workspace with
+`pyamplicol examples run generate_pp_4j_flavor_blind`, then
+`inspect_pp_4j`, `evaluate_pp_4j_member`, and `group_pp_4j`.
+
+**Generate.** The card uses the built-in SM with its default five-flavour `p`
+and `j`, `process.max_coupling_orders = { QED = 0 }`, and LC recurrence over
+the wheel-owned JIT O2 kernels. `process.flavor_blind = true` generates only
+the 23 class representatives into `artifacts/pp_4j_flavor_blind`, which takes
+about 30 seconds on an Apple M3 Pro laptop. The other 463 subprocesses, 140
+of them related by charge conjugation, are recorded in
+`artifacts/pp_4j_flavor_blind/process-groups.json` as members of their class.
+Equal matrix elements within a class are assumed, not verified. They hold for
+massless pure-QCD jets, so this request produces no relabelling warning; with
+photon, `Z` or `W` couplings allowed, generation warns about the relations
+that may break. The card refuses an existing output; add
+`--set generation.mode=replace` to regenerate.
+
+**Inspect.** `inspect_pp_4j.toml` is equivalent to
+`pyamplicol inspect artifacts/pp_4j_flavor_blind`. After the 23 generated
+processes it shows the process-group map: a summary of the 486 subprocesses,
+then one row per representative with the members routed through it, the
+charge-conjugated ones marked `C`. Select a representative to list its group
+member by member, or a member with `--full-physics` to see how it is routed:
+
+```console
+pyamplicol inspect artifacts/pp_4j_flavor_blind --process 'd g > d g g g'
+pyamplicol inspect artifacts/pp_4j_flavor_blind \
+  --process 'u~ g > u~ g g g' --full-physics
+```
+
+**Evaluate a member.** `u~ g > u~ g g g` is not in the artifact. The runtime
+finds it in `process-groups.json` and evaluates its representative
+`d g > d g g g` (relabelling `u -> d` plus charge conjugation) at the
+correspondingly permuted momenta. `data/pp_4j_momenta.json` holds one massless
+2-to-4 point at `sqrt(s) = 1 TeV` in the member's leg order. The total,
+`7.271103230388e-08`, agrees with a separately generated
+`u~ g > u~ g g g` to about `1e-14` relative. Any of the 486 subprocesses, in
+any order of the legs within each side, can be selected the same way:
+
+```console
+pyamplicol evaluate_pp_4j_member.toml \
+  --set 'evaluation.process=u~ u > u~ u g g'
+pyamplicol evaluate --card evaluate_pp_4j_member.toml --resolved \
+  --helicity 'h:-1,-1,-1,-1,-1,-1'
+```
+
+The resolved table lists helicities and LC flows in the member's leg order;
+for a conjugated member each flow word is reversed. Without `--helicity` it
+lists all 64 helicities times 24 flows. Python selects members
+with `Runtime.load("artifacts/pp_4j_flavor_blind", process="u~ g > u~ g g g")`,
+whose `representative_process_key`, `process_group_factor` and
+`charge_conjugated` describe the routing. The generated API drivers accept
+the same selection, for example:
+
+```console
+python artifacts/pp_4j_flavor_blind/API/python/check_standalone.py \
+  --process 'u~ g > u~ g g g' --kinematics data/pp_4j_momenta.json --json
+```
+
+**Group numerically.** `group_pp_4j.toml` is equivalent to
+`pyamplicol group-processes artifacts/pp_4j_flavor_blind`. It compares the 23
+generated representatives at random points, merges those whose resolved
+values agree up to a rational factor, and rewrites `process-groups.json` in
+place. The card sets `process.analyze_process_groups = "numerical"` because
+run cards otherwise use the schema default `none`; the `group-processes`
+subcommand defaults to `numerical`. Here the analysis takes about a second
+and reports no new relation: the 23 classes are already distinct. To test
+the flavour-blind assumption itself, generate all 486 subprocesses without
+`flavor_blind` (much slower) and let the analysis rebuild the same 23 groups;
+see the [process grouping guide](https://madgraph.org/pyamplicol/user/process-grouping/).
+
+## Run `q q~ > Z + 6g` With Recurrence, Compiled, And Eager
+
+Each matched card generates and profiles the same complete-selector,
+topology-replay LC workload:
+
+```console
+pyamplicol generate --card qq_z6g_recurrence_jit_o2.toml
+pyamplicol profile --card qq_z6g_recurrence_jit_o2.toml
+
+pyamplicol generate --card qq_z6g_compiled_jit_o3.toml
+pyamplicol profile --card qq_z6g_compiled_jit_o3.toml
+
+pyamplicol generate --card qq_z6g_eager_jit_o2.toml
+pyamplicol profile --card qq_z6g_eager_jit_o2.toml
+```
+
+Recurrence JIT O2 is the default current-schedule lane, compiled JIT O3 builds
+process-local DAG evaluators, and eager-DAG JIT O2 applies prepared kernels to
+compact process tables. The explicit settings in these cards make the
+materialized-mode comparison stable if project defaults change again.
+
+## Generate A Compact On-The-Fly LC Artifact
+
+The dedicated OTF walkthrough expands `p p > Z j j`, loads the concrete
+ordering `d d~ > g z g`, warms one LC flow with a complete helicity sum, and
+then profiles the same selector workload:
+
+```console
+pyamplicol generate --card otf_pp_zjj.toml
+python python/otf_pp_zjj_warm_up.py
+pyamplicol profile --card otf_pp_zjj.toml
+```
+
+The Python step calls
+`Runtime.warm_up((point,), precision=16, color_flows=(flow,))`: its input is
+exactly one phase-space point, native `f64` is explicit, and omitting a
+helicity selector means sum every physical helicity. The standard terminal
+progress dashboard tracks query-family progress and live current/peak RSS.
+It is followed by a colored PrettyTable containing the selected stable flow
+ID, warm-up wall time, query counts, memory, and matrix element. Use
+`--color always` when capturing the ANSI-colored table through a pipe, or
+`--color-flow N` to choose another one-based physical flow.
+
+The `profile` command starts an independent runtime and prints pyAmpliCol's
+colored human benchmark tables. Its 128-point batches are throughput and
+benchmark-capacity measurements; they do not change the explicit
+`warm_up(...)` API's one-point contract.
+
+To reuse completed OTF preparation in another Python session or native program,
+call `runtime.save("process.otf-cache")` on the warmed handle. Load the same
+process output normally in the new program, then call
+`runtime.load_cache("process.otf-cache")` before evaluating with the same
+selectors. This is explicit API functionality: the separate CLI `profile`
+command above does not automatically read a saved cache. Small Python and
+C/C++/Fortran/Rust examples are in the online manual's
+[save/restore guide](https://madgraph.org/pyamplicol/user/runtime-and-selectors/#saving-an-otf-warm-cache)
+and [native API guide](https://madgraph.org/pyamplicol/user/native-apis/#saving-and-restoring-an-otf-cache).
+
+The smaller single-process card remains useful for quick inspection and a CLI
+profile without multiprocess expansion:
+
+```console
+pyamplicol generate --card builtin_sm_on_the_fly.toml
+pyamplicol inspect artifacts/builtin_sm_on_the_fly
+pyamplicol profile --card builtin_sm_on_the_fly.toml \
+  --color-flow 1 --batch-size 128 --target-runtime 5
+```
+
+The inspection reports the physical helicity/color-flow census without
+materializing either LC flow layout. The card's
+`evaluator.optimization.cores = 4` requests four query-construction threads; it
+does not promise four numerical-evaluation threads. Point-tile and workspace
+settings are not currently applied by this mode. The profile measures one
+runtime-selected LC flow with a helicity sum over 128-point batches. Generation
+requires the wheel-owned prepared JIT O2 bundle selected for the built-in
+model; the artifact carries the referenced kernels it needs at runtime.
+The walkthrough intentionally targets the practical OTF workload: LC,
+single-flow, helicity-sum execution at native `f64`. Contracted NLC and full
+color are available for low multiplicities but are not showcased here because
+their OTF construction cost grows quickly; higher-precision OTF execution is
+not available.
+
+## Reproduce The Z-Ladder Workloads
+
+These acceptance cards use two separately generated compiled-mode artifacts so
+their generation and profile logs remain independent. The first keeps the
+default `topology-replay` LC layout, selects flow ordinal `1` only at profile
+time, and sums all helicities. The second explicitly sets
+`color.lc_flow_layout = "all-flow-union"`, sums all flows, and selects one
+stable helicity ID only at profile time. The union shares currents across the
+physical flows and is optimized for this second workload.
+
+Both artifacts retain all physical LC flows and all physical helicities. Either
+can select any retained flow or helicity globally or per point at runtime;
+neither card fixes a selector at generation time. Generate and profile them
+independently:
+
+```console
+pyamplicol generate --card benchmark_z6g_single_flow_helicity_sum.toml
+pyamplicol profile --card benchmark_z6g_single_flow_helicity_sum.toml
+
+pyamplicol generate --card benchmark_z6g_all_flows_single_helicity.toml
+pyamplicol profile --card benchmark_z6g_all_flows_single_helicity.toml
+```
+
+Both profiles use native Rusticol wall timing, compressed JIT O3, 64-point
+batches, two warmups, at least five samples, and a twenty-second target. The
+cards use `u u~ > Z g g g g g g` as requested; the PDF's literal reference
+family uses `d d~ > Z + (n-1)g`, so replace `u u~` with `d d~` when reproducing
+that exact row rather than the equivalent up-quark topology.
+
+The runtime selector can be changed without regenerating. For example:
+
+```console
+pyamplicol profile \
+  --card benchmark_z6g_single_flow_helicity_sum.toml \
+  --color-flow 2
+
+pyamplicol profile \
+  --card benchmark_z6g_all_flows_single_helicity.toml \
+  --helicity h:-1,+1,-1,+1,+1,-1,+1,-1,+1
+```
+
+Python's `Runtime.evaluate(..., color_flow_by_point=..., helicity_by_point=...)`
+accepts one physical selector per phase-space point. Homogeneous, alternating,
+and randomized selector batches all use the same complete artifact.
+
+The layout is also a dedicated CLI option. For example, this creates a union
+artifact from the otherwise topology-replay card:
+
+```console
+pyamplicol generate \
+  --card benchmark_z6g_single_flow_helicity_sum.toml \
+  --lc-flow-layout all-flow-union \
+  --set generation.output=artifacts/uubar_z6g_all_flows_override
+```
+
+`topology-replay` remains the global default because it is optimized for a
+single runtime-selected flow with a helicity sum. `all-flow-union` is LC-only;
+configuration rejects it for NLC/full and for LC requests with a
+generation-selected color sector, a generation-selected helicity, or truncated
+color coverage.
+
+The execution mode can be overridden directly at invocation time. Use a
+different output so the eager artifact cannot collide with the compiled one:
+
+```console
+pyamplicol generate \
+  --card benchmark_z6g_single_flow_helicity_sum.toml \
+  --execution-mode eager \
+  --set generation.output=artifacts/uubar_z6g_single_flow_helicity_sum_eager
+```
+
+The eager override keeps the same complete reusable-selector contract and the
+card's LC flow layout. Eager generation and execution apply flow and helicity
+choices through Rusticol's selector schedule rather than generation-time
+specialization.
+
+`examples copy` also materializes wheel-owned `sm`, `scalars`, and
+`scalar_gravity` resources into `models/`. The included
+`python/copy_packaged_models.py` helper performs the resource-only operation for
+a separate workspace and refuses to merge into a non-empty destination unless
+`--force` is supplied. The public model API accepts filesystem paths, so no
+example relies on an installation directory.
+
+## Typed Python
+
+Plan or generate the primary process through the typed API:
+
+```console
+python python/typed_generation.py artifacts/pp_zjj_typed --plan-only
+python python/typed_generation.py artifacts/pp_zjj_typed
+```
+
+The script compiles the external JSON model before planning, carries explicit
+`p`/`j` definitions in the resolved configuration, and writes the same root
+API bundle as the CLI.
+
+Evaluate with a parameter card plus a direct override:
+
+```console
+python python/runtime_evaluation.py \
+  artifacts/pp_zjj data/pp_zjj_momenta.json \
+  --process 'd d~ > g z g' \
+  --parameters data/model_parameters.json \
+  --set-parameter aS=0.1165
+```
+
+The JSON output includes the resolved tensor `shape`, flattened row-major
+`values`, its explicit `resolved_sum`, and the optimized
+`compatibility_total`, in addition to the selected physics-axis IDs.
+
+Benchmark the selected process:
+
+```console
+python python/benchmark.py artifacts/pp_zjj \
+  --process 'd d~ > g z g' \
+  --momenta data/pp_zjj_momenta.json \
+  --color-flow 1
+```
+
+The compact OTF counterpart uses the same phase-space point but explicitly
+prepares just one LC flow before evaluating it:
+
+```console
+python python/otf_pp_zjj_warm_up.py
+```
+
+`python/external_models.py` demonstrates explicit JSON and trusted-UFO
+`ModelSource` construction:
+
+```console
+python python/external_models.py models/json/sm/sm.json models/ufo/sm
+```
+
+## Generated Python, C, Rust, C++, And Fortran
+
+Every generated artifact contains one `API/` bundle. All drivers select a
+process, accept JSON/direct model-parameter updates, evaluate resolved values,
+sum them, and compare with the optimized total:
+
+```console
+python artifacts/pp_zjj/API/python/check_standalone.py \
+  --process 'd d~ > g z g' --set-parameter aS 0.117 0 --json
+make -C artifacts/pp_zjj/API/c run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --json'
+make -C artifacts/pp_zjj/API/rust run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --precision 16 --json'
+make -C artifacts/pp_zjj/API/cpp run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --json'
+make -C artifacts/pp_zjj/API/fortran run \
+  ARGS='--process "d d~ > g z g" --set-parameter aS 0.117 0 --json'
+```
+
+The requested expression need not be a stored alias. Rusticol identifies a
+unique generated representative with the same incoming and outgoing particle
+multisets, then applies the side-preserving permutation to input momenta,
+helicity and LC-flow selectors, and resolved output metadata. Incoming and
+outgoing legs never cross `>`; an ambiguous match fails with the candidate
+stable process IDs.
+
+All five drivers also accept `--kinematics PATH`. The JSON file contains one
+point as `[external][4]`, or the same point wrapped as a singleton batch
+`[[external][4]]`, in the exact particle order written in `--process`. Each
+component may be a JSON number or a decimal string. Decimal strings avoid an
+f64 round trip in the arbitrary-precision Python driver; native drivers parse
+the same representation for f64. Multiple points, non-finite values, booleans,
+and mismatched shapes are rejected. Without this option the driver reorders
+the artifact's bundled validation point automatically.
+
+`--model-parameters data/model_parameters.json` applies a UFO-style flat JSON
+object before evaluation. Each mutable external parameter maps to a finite
+number or `[real, imaginary]`, matching a serialized UFO restriction card.
+Repeated `--set-parameter NAME REAL IMAG` options are applied afterward and
+therefore override the card atomically.
+
+In a copied workspace below a source checkout, this exact block works even in
+a later shell where `.venv` has not been activated. Artifacts generated by an
+older pyAmpliCol retain their older API files and must be regenerated once:
+
+```console
+../.venv/bin/pyamplicol generate_pp_zjj_from_ufo_sm.toml \
+  --set generation.mode=replace
+```
+
+The generated Rust source includes the wheel-owned safe wrapper located by
+`rusticol-config --rust-source` and is compiled directly with `rustc` plus
+`rusticol-config --rustflags`; no Rust crate dependency is needed. The Makefile
+also has an optional `run-script` target for separately installed
+`rust-script`, using `rusticol-config --cargo-rustflags`. C, Rust, C++, and
+Fortran support f64 (`--precision 16`) only. At f64, direct SymJIT,
+target-compatible ASM/C++, and eager JIT artifacts run without a Symbolica
+runtime. The Python driver also exposes precision-controlled Symbolica
+evaluation when exact expressions are available.
+
+## Hand-Written Native Examples
+
+`native/runtime.cpp`, `native/runtime.f90`, and `native/Makefile` consume only
+the SDK discovered from an installed wheel:
+
+```console
+make -C native
+native/runtime_cpp artifacts/pp_zjj p_p_to_z_j_j_3 \
+  data/model_parameters.json
+native/runtime_fortran artifacts/pp_zjj p_p_to_z_j_j_3 \
+  data/model_parameters.json
+```
+
+Both examples apply a direct `aS` override, evaluate the five-particle
+validation point, and verify that resolved components reproduce the total.
+
+Current release validation and upload status are listed in
+the [release and support guide](https://madgraph.org/pyamplicol/user/release-and-support/).
diff --git a/pyamplicol/examples/all_options.toml b/pyamplicol/examples/all_options.toml
new file mode 100644
index 0000000000..c0eb70f3a1
--- /dev/null
+++ b/pyamplicol/examples/all_options.toml
@@ -0,0 +1,268 @@
+# SPDX-License-Identifier: 0BSD
+# Exhaustive TOML schema-v1 reference. Every current registry leaf is active.
+# This card is for resolution/documentation, not as a recommended physics run.
+
+# action: Required command action. Choices are generate, evaluate, benchmark,
+# inspect, model-inspect, model-compile, model-processes, and group-processes.
+action = "generate"
+
+# schema_version: Configuration schema. The only current value is 1.
+schema_version = 1
+
+[model]
+# model.source: "built-in-sm", "built-in-sm-heft", or a UFO
+# directory/JSON/compiled-model path.
+source = "models/json/sm/sm.json"
+# model.restriction: Optional restriction name. Default is null, which applies
+# a model-provided default restriction when one exists.
+restriction = "default"
+# model.simplify: Simplify an external model while compiling. Default true.
+simplify = true
+# model.cache: Reuse the content-addressed compiled-model cache. Default true.
+cache = true
+# model.cache_dir: Optional cache directory. Default is platform-specific/null.
+cache_dir = "cache/models"
+
+[process]
+# process.entries: Typed process expressions with optional unique stable names.
+entries = [
+  { expression = "p p > Z j j" },
+]
+# process.flavor_scheme: Number of active quark flavors. Default 5.
+flavor_scheme = 2
+# process.max_quark_lines: Optional maximum quark-line count. Default null.
+max_quark_lines = 2
+# process.coupling_order_policy: "minimal" or "explicit". Default minimal.
+coupling_order_policy = "explicit"
+# The following four topology-extraction controls are unstable, developer-only
+# implementation details. Do not rely on them in production run cards.
+# process.max_color_sectors: Optional cap on generated color sectors. Default null.
+max_color_sectors = 32
+# process.reference_color_order: Optional external-leg ordering used to identify
+# a reference LC sector. Default is an empty list.
+reference_color_order = [1, 2, 3, 4, 5]
+# process.selected_color_sector_ids: Optional generated-sector subset. Default
+# is an empty list, which keeps every generated sector.
+selected_color_sector_ids = [0]
+# process.selected_source_helicities: Optional fixed source helicities keyed by
+# one-based external-leg label. Default is an empty table.
+selected_source_helicities = { "1" = -1, "2" = 1 }
+# process.flavor_blind: Generate one representative per flavour-relabelling
+# class and record the others as unverified members in process-groups.json.
+# Default false.
+flavor_blind = false
+# process.consider_charge_conjugation: Also relate processes by charge
+# conjugation for flavor_blind and numerical grouping. Default true.
+consider_charge_conjugation = true
+# process.only_unit_multiplier: Accept only numerical relations with factor 1.
+# Default false.
+only_unit_multiplier = false
+# process.analyze_process_groups: "none" or "numerical". After generation,
+# "numerical" compares generated processes at random points and records equal
+# matrix elements up to a rational factor. Default none.
+analyze_process_groups = "none"
+
+# process.multiparticles: User-defined particle-name expansions, merged over
+# model defaults. Every model supplies "all" for its valid propagating physical
+# external states (excluding ghosts, Goldstones, and auxiliary/non-propagating
+# records); an explicit all entry overrides that broad default.
+[process.multiparticles]
+p = ["d", "d~", "u", "u~", "g"]
+j = ["d", "d~", "u", "u~", "g"]
+
+# process.max_coupling_orders: Non-negative limits keyed by coupling-order name.
+[process.max_coupling_orders]
+QCD = 4
+QED = 2
+
+[color]
+# color.accuracy: "lc", "nlc", or "full". Default lc.
+accuracy = "lc"
+# color.contraction: "direct" or "symmetric-group-fft". Default direct.
+# The FFT method requires NLC/full with recurrence or on-the-fly execution.
+contraction = "direct"
+# color.fft_basis: "trace" or "adjoint". Default trace.
+# Adjoint adaptively selects certified DDM (Yang-Mills or single-insertion
+# HEFT), fundamental chains/products for quarks, or exact trace otherwise.
+# Saved fft_basis_selection reports the actual representation and reason.
+# It requires FFT contraction and does not support correlated generation.
+# The schema default shown here remains trace.
+fft_basis = "trace"
+# color.lc_flow_layout: "topology-replay" or "all-flow-union". Default
+# topology-replay. The all-flow union is LC-only and cannot be combined with
+# generation-selected or truncated color/helicity coverage.
+lc_flow_layout = "topology-replay"
+
+[generation]
+# generation.output: Optional artifact output path. Default null.
+output = "artifacts/pp_zjj_all_options"
+# generation.mode: "error", "append", or "replace". Default error.
+mode = "error"
+# generation.workers: Positive integer or "auto". Default auto.
+workers = "auto"
+# generation.emit_api_bundle: Emit Python/Rust/C/C++/Fortran/UMAMI API bundle. Default true.
+emit_api_bundle = true
+[generation.validation]
+# generation.validation.enabled: Run generation validation. Default true.
+enabled = true
+# generation.validation.samples: Positive sample count. Default 2.
+samples = 2
+# generation.validation.seed: Non-negative random seed. Default 12345.
+seed = 12345
+# generation.validation.relative_tolerance: Non-negative tolerance. Default 1e-12.
+relative_tolerance = 1e-12
+# generation.validation.absolute_tolerance: Non-negative tolerance. Default 1e-300.
+absolute_tolerance = 1e-300
+# generation.validation.post_build_validation: Re-open and numerically smoke-test
+# the built evaluator. Default false; structural artifact checks always run.
+post_build_validation = false
+
+[generation.relation_discovery]
+# generation.relation_discovery.mode: "off", "diagnostic", or
+# "certified-reuse". Exact proofs are preferred. Independently verified
+# equal, opposite, and zero currents may also be applied with persisted
+# numerical evidence and a warning. Default off, because the high-precision
+# probes are costly at generation time; set "certified-reuse" or pass
+# --numerical-current-reuse to search for additional reuse.
+mode = "off"
+# generation.relation_discovery.precision_digits: Decimal probe precision,
+# at least 80. Default 96.
+precision_digits = 96
+# generation.relation_discovery.probe_count: Deterministic candidate points,
+# at least 2. Default 4.
+probe_count = 4
+# generation.relation_discovery.verification_probe_count: Independent
+# verification points, at least 2. Default 4.
+verification_probe_count = 4
+# generation.relation_discovery.relative_tolerance: Non-negative verification
+# tolerance. Default 1e-70.
+relative_tolerance = 1e-70
+# generation.relation_discovery.absolute_tolerance: Non-negative verification
+# tolerance. Default 1e-80.
+absolute_tolerance = 1e-80
+# generation.relation_discovery.seed: Non-negative deterministic probe seed.
+# Default 1348026701.
+seed = 1348026701
+
+[evaluator]
+# evaluator.backend: "jit", "asm", or "cpp". Default jit.
+backend = "jit"
+# evaluator.execution_mode: "compiled", "eager", "recurrence", or
+# "on-the-fly". Default recurrence. Eager, recurrence, and on-the-fly
+# built-in-sm use the wheel-owned JIT O2 pack; other packs need an explicit
+# .pyamplicol-model source. On-the-fly supports LC and contracted NLC/full in
+# native f64.
+execution_mode = "compiled"
+# evaluator.batch_size: Positive evaluation batch size. Default 128.
+batch_size = 128
+# evaluator.output_chunk_size: Positive size or null. Default 512.
+output_chunk_size = 512
+
+[evaluator.eager]
+# evaluator.eager.point_tile_size: Maximum points per eager workspace tile.
+# The runtime reduces this automatically when required. Default 1024.
+# This eager section is not applied by on-the-fly execution.
+point_tile_size = 1024
+# evaluator.eager.workspace_mib: Batch workspace target. Default 256; grows as
+# needed to fit the minimum executable tile, rather than rejecting a process.
+workspace_mib = 256
+
+[evaluator.recurrence]
+# evaluator.recurrence.point_tile_size: Maximum points per recurrence workspace
+# tile. The runtime may reduce this automatically. Default 1024.
+# On-the-fly records this request as provenance but does not currently apply it.
+point_tile_size = 1024
+# evaluator.recurrence.workspace_mib: Batch workspace target; grows as needed
+# to fit the minimum executable tile, rather than rejecting a process.
+# Default 256. This target is not currently applied by on-the-fly execution.
+workspace_mib = 256
+
+[evaluator.optimization]
+# evaluator.optimization.horner_iterations: Non-negative count. Default 10.
+horner_iterations = 10
+# evaluator.optimization.cpe_iterations: Non-negative override. The field is
+# omitted by default so Symbolica selects its backend default; this card uses 0.
+cpe_iterations = 0
+# evaluator.optimization.cores: Positive integer or "auto". Default auto. In
+# on-the-fly mode this is the requested query-construction thread count, not a
+# numerical-evaluation thread guarantee.
+cores = "auto"
+# evaluator.optimization.max_horner_variables: Non-negative limit. Default 1000.
+max_horner_variables = 1000
+# evaluator.optimization.max_common_pair_cache_entries: Default 5000000.
+max_common_pair_cache_entries = 5000000
+# evaluator.optimization.max_common_pair_distance: Default 1000.
+max_common_pair_distance = 1000
+# evaluator.optimization.collect_factors: "auto", true, or false. Default auto.
+collect_factors = "auto"
+
+[evaluator.jit]
+# evaluator.jit.optimization_level: Integer 0 through 3. Default 2.
+optimization_level = 2
+# evaluator.jit.compress: Smaller generated code, potentially slower evaluation.
+# "auto" enables compiled JIT O2 only; true/false explicitly override the default.
+compress = "auto"
+
+[evaluator.cpp]
+# evaluator.cpp.optimization: Compiler optimization token. Default "O3".
+optimization = "O3"
+# evaluator.cpp.compiler: Optional compiler executable. Default null.
+compiler = "c++"
+# evaluator.cpp.native_arch: Opt into recorded host CPU requirements. Default false.
+native_arch = false
+# evaluator.cpp.extra_flags: Allowlisted non-ISA compiler arguments. Default empty.
+extra_flags = ["-fno-math-errno"]
+
+[evaluation]
+# evaluation.artifact: Optional schema-v3 artifact path. Default null.
+artifact = "artifacts/pp_zjj_all_options"
+# evaluation.process: Optional stable ID/alias, concrete expression, or unique
+# permutation within each side of a concrete process. Legs never cross ">".
+# Default null.
+process = "d d~ > g z g"
+# evaluation.precision: Positive decimal-digit request. Default 16.
+precision = 16
+# evaluation.resolved: Return physical resolved components. Default false.
+resolved = true
+# evaluation.helicity_ids: Stable physical helicity selectors. Default empty.
+helicity_ids = []
+# evaluation.color_flow_ids: Stable LC flow selectors. Default empty.
+color_flow_ids = []
+# evaluation.model_parameters: Optional flat UFO-style JSON parameter card.
+# Values are finite numbers or [real, imaginary] pairs. Direct parameter
+# overrides are applied afterward. Default null.
+model_parameters = "data/model_parameters.json"
+# evaluation.momenta: Optional JSON phase-space points path. Default null.
+momenta = "data/pp_zjj_momenta.json"
+
+[benchmark]
+# benchmark.target_runtime: Positive target duration in seconds. Default 10.0.
+target_runtime = 10.0
+# benchmark.batch_size: Positive benchmark batch size. Default 128.
+batch_size = 128
+# benchmark.precision: Positive decimal precision used by Python evaluation. Default 16.
+precision = 16
+# benchmark.warmup_runs: Non-negative warmup count. Default 2.
+warmup_runs = 2
+# benchmark.minimum_samples: Positive minimum measured samples. Default 5.
+minimum_samples = 5
+# benchmark.helicity_ids: Optional benchmark helicity selectors. With both
+# selector lists empty, profiling chooses the generated layout's hot workload.
+helicity_ids = []
+# benchmark.color_flow_ids: Optional benchmark LC flow selectors. With both
+# selector lists empty, profiling chooses the generated layout's hot workload.
+color_flow_ids = []
+
+[output]
+# output.format: typed API/config provenance default. The CLI uses --json.
+format = "human"
+# output.color: "auto", "always", or "never". Default auto.
+color = "auto"
+# output.progress: "auto", "tty", "log", or "off". Default auto.
+progress = "auto"
+# output.log_level: "debug", "info", "warning", or "error". Default info.
+log_level = "info"
+
+[symbolica]
+# symbolica.suggest_license: Show one restricted-mode license reminder. Default true.
+suggest_license = true
diff --git a/pyamplicol/examples/benchmark.toml b/pyamplicol/examples/benchmark.toml
new file mode 100644
index 0000000000..ad6b87cc24
--- /dev/null
+++ b/pyamplicol/examples/benchmark.toml
@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: 0BSD
+# Short benchmark of the optimized summed runtime path.
+
+schema_version = 1
+action = "benchmark"
+
+[evaluation]
+artifact = "artifacts/pp_zjj"
+process = "d d~ > g z g"
+momenta = "data/pp_zjj_momenta.json"
+
+[benchmark]
+target_runtime = 1.0
+batch_size = 128
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+helicity_ids = []
+# Topology-replay is optimized for one selected flow with the helicity sum.
+color_flow_ids = ["1"]
+
+[output]
+format = "human"
+color = "auto"
+progress = "log"
diff --git a/pyamplicol/examples/benchmark_z6g_all_flows_single_helicity.toml b/pyamplicol/examples/benchmark_z6g_all_flows_single_helicity.toml
new file mode 100644
index 0000000000..581b14be1e
--- /dev/null
+++ b/pyamplicol/examples/benchmark_z6g_all_flows_single_helicity.toml
@@ -0,0 +1,76 @@
+# SPDX-License-Identifier: 0BSD
+# Exercise the reusable compiled JIT O3 all-flows, single-helicity workload
+# with the explicit all-flow-union recurrence layout.
+#
+# From a copied examples directory, generate and profile with:
+#   pyamplicol generate --card benchmark_z6g_all_flows_single_helicity.toml
+#   pyamplicol profile --card benchmark_z6g_all_flows_single_helicity.toml
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+cache = true
+
+[process]
+entries = [
+  { expression = "u u~ > Z g g g g g g", name = "uubar_Z_6g" },
+]
+# No generation-time helicity selection is used: the artifact retains every
+# physical helicity and can select any helicity globally or per point at runtime.
+
+[color]
+accuracy = "lc"
+lc_flow_layout = "all-flow-union"
+
+[generation]
+output = "artifacts/uubar_z6g_all_flows_single_helicity"
+mode = "error"
+workers = 1
+emit_api_bundle = true
+
+[generation.validation]
+enabled = true
+samples = 10
+seed = 12345
+relative_tolerance = 1e-12
+absolute_tolerance = 1e-300
+post_build_validation = false
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
+batch_size = 64
+output_chunk_size = 512
+
+[evaluator.optimization]
+horner_iterations = 10
+cores = 1
+max_horner_variables = 1000
+max_common_pair_cache_entries = 5000000
+max_common_pair_distance = 1000
+collect_factors = "auto"
+
+[evaluator.jit]
+optimization_level = 3
+compress = false
+
+[evaluation]
+artifact = "artifacts/uubar_z6g_all_flows_single_helicity"
+process = "u u~ > Z g g g g g g"
+precision = 16
+
+[benchmark]
+target_runtime = 20.0
+batch_size = 64
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+helicity_ids = ["h:-1,+1,-1,+1,-1,+1,-1,+1,-1"]
+
+[output]
+format = "human"
+color = "auto"
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/benchmark_z6g_generation_specialized_all_flows_single_helicity.toml b/pyamplicol/examples/benchmark_z6g_generation_specialized_all_flows_single_helicity.toml
new file mode 100644
index 0000000000..a129cd668e
--- /dev/null
+++ b/pyamplicol/examples/benchmark_z6g_generation_specialized_all_flows_single_helicity.toml
@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: 0BSD
+# Exercise compiled JIT O3 with one source helicity fixed at generation time
+# and a complete LC-flow sum. This is the generation-specialized baseline for
+# the reusable runtime-helicity selector comparison documented in README.md.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+cache = true
+
+[process]
+entries = [
+  { expression = "u u~ > Z g g g g g g", name = "uubar_Z_6g" },
+]
+# Source labels are 1:u, 2:u~, 3:Z, and 4..9:the six gluons. Unlike the
+# reusable example, this card intentionally fixes one helicity assignment
+# during generation and cannot switch to another assignment at runtime.
+selected_source_helicities = { "1" = -1, "2" = 1, "3" = -1, "4" = 1, "5" = -1, "6" = 1, "7" = -1, "8" = 1, "9" = -1 }
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/uubar_z6g_generation_specialized_all_flows_single_helicity"
+mode = "error"
+workers = 1
+emit_api_bundle = true
+
+[generation.validation]
+enabled = true
+samples = 10
+seed = 12345
+relative_tolerance = 1e-12
+absolute_tolerance = 1e-300
+post_build_validation = false
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
+batch_size = 64
+output_chunk_size = 512
+
+[evaluator.optimization]
+horner_iterations = 10
+cores = 1
+max_horner_variables = 1000
+max_common_pair_cache_entries = 5000000
+max_common_pair_distance = 1000
+collect_factors = "auto"
+
+[evaluator.jit]
+optimization_level = 3
+compress = false
+
+[evaluation]
+artifact = "artifacts/uubar_z6g_generation_specialized_all_flows_single_helicity"
+process = "u u~ > Z g g g g g g"
+precision = 16
+
+[benchmark]
+target_runtime = 20.0
+batch_size = 64
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+helicity_ids = ["h:-1,+1,-1,+1,-1,+1,-1,+1,-1"]
+
+[output]
+format = "human"
+color = "auto"
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/benchmark_z6g_generation_specialized_flow_helicity_sum.toml b/pyamplicol/examples/benchmark_z6g_generation_specialized_flow_helicity_sum.toml
new file mode 100644
index 0000000000..3c3807c195
--- /dev/null
+++ b/pyamplicol/examples/benchmark_z6g_generation_specialized_flow_helicity_sum.toml
@@ -0,0 +1,75 @@
+# SPDX-License-Identifier: 0BSD
+# Exercise compiled JIT O3 with one LC flow fixed at generation time and a
+# complete helicity sum. This is the specialized baseline for the reusable
+# selector comparison documented in examples/README.md.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+cache = true
+
+[process]
+entries = [
+  { expression = "u u~ > Z g g g g g g", name = "uubar_Z_6g" },
+]
+# Source labels are 1:u, 2:u~, 3:Z, and 4..9:the six gluons. Unlike the
+# reusable examples, this card intentionally fixes one physical flow during
+# generation and must therefore be labeled as generation-specialized.
+reference_color_order = [2, 4, 5, 6, 7, 8, 9, 1, 3]
+selected_color_sector_ids = [0]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/uubar_z6g_generation_specialized_flow_helicity_sum"
+mode = "error"
+workers = 1
+emit_api_bundle = true
+
+[generation.validation]
+enabled = true
+samples = 10
+seed = 12345
+relative_tolerance = 1e-12
+absolute_tolerance = 1e-300
+post_build_validation = false
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
+batch_size = 64
+output_chunk_size = 512
+
+[evaluator.optimization]
+horner_iterations = 10
+cores = 1
+max_horner_variables = 1000
+max_common_pair_cache_entries = 5000000
+max_common_pair_distance = 1000
+collect_factors = "auto"
+
+[evaluator.jit]
+optimization_level = 3
+compress = false
+
+[evaluation]
+artifact = "artifacts/uubar_z6g_generation_specialized_flow_helicity_sum"
+process = "u u~ > Z g g g g g g"
+precision = 16
+
+[benchmark]
+target_runtime = 20.0
+batch_size = 64
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+color_flow_ids = ["1"]
+
+[output]
+format = "human"
+color = "auto"
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/benchmark_z6g_single_flow_helicity_sum.toml b/pyamplicol/examples/benchmark_z6g_single_flow_helicity_sum.toml
new file mode 100644
index 0000000000..a1816f7255
--- /dev/null
+++ b/pyamplicol/examples/benchmark_z6g_single_flow_helicity_sum.toml
@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: 0BSD
+# Exercise the reusable compiled JIT O3 single-flow, helicity-sum workload.
+#
+# From a copied examples directory, generate and profile with:
+#   pyamplicol generate --card benchmark_z6g_single_flow_helicity_sum.toml
+#   pyamplicol profile --card benchmark_z6g_single_flow_helicity_sum.toml
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+cache = true
+
+[process]
+entries = [
+  { expression = "u u~ > Z g g g g g g", name = "uubar_Z_6g" },
+]
+# No generation-time flow selection is used: the artifact retains every
+# physical LC flow and can select any flow globally or per point at runtime.
+
+[color]
+accuracy = "lc"
+# The default topology-replay layout is optimized for selecting one physical
+# flow at runtime while summing the retained helicities.
+
+[generation]
+output = "artifacts/uubar_z6g_single_flow_helicity_sum"
+mode = "error"
+workers = 1
+emit_api_bundle = true
+
+[generation.validation]
+enabled = true
+samples = 10
+seed = 12345
+relative_tolerance = 1e-12
+absolute_tolerance = 1e-300
+post_build_validation = false
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
+batch_size = 64
+output_chunk_size = 512
+
+[evaluator.optimization]
+horner_iterations = 10
+cores = 1
+max_horner_variables = 1000
+max_common_pair_cache_entries = 5000000
+max_common_pair_distance = 1000
+collect_factors = "auto"
+
+[evaluator.jit]
+optimization_level = 3
+compress = false
+
+[evaluation]
+artifact = "artifacts/uubar_z6g_single_flow_helicity_sum"
+process = "u u~ > Z g g g g g g"
+precision = 16
+
+[benchmark]
+target_runtime = 20.0
+batch_size = 64
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+# One-based ordinal 1 resolves to the first physical flow exposed by the
+# artifact. Stable flow IDs such as "flow:..." are accepted as well.
+color_flow_ids = ["1"]
+
+[output]
+format = "human"
+color = "auto"
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/builtin_sm_adjoint_fft.toml b/pyamplicol/examples/builtin_sm_adjoint_fft.toml
new file mode 100644
index 0000000000..390511ef36
--- /dev/null
+++ b/pyamplicol/examples/builtin_sm_adjoint_fft.toml
@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: 0BSD
+# Pure-gluon full-color generation in the two-anchor adjoint DDM FFT basis.
+# Primary FFT example for certified Yang-Mills trees; adjoint is explicit below.
+# Five gluons retain 3! ordered amplitudes instead of the trace basis's 4!.
+# This smaller basis does not guarantee a runtime speedup at every multiplicity.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "g g > g g g", name = "gg_ggg_adjoint_fft" }]
+
+[color]
+accuracy = "full"
+contraction = "symmetric-group-fft"
+fft_basis = "adjoint"
+
+[generation]
+output = "artifacts/builtin_sm_adjoint_fft"
+mode = "error"
+emit_api_bundle = true
+
+[evaluator]
+# Both recurrence and on-the-fly support trace and adjoint FFT contraction.
+execution_mode = "recurrence"
+
+[output]
+progress = "log"
diff --git a/pyamplicol/examples/builtin_sm_eager.toml b/pyamplicol/examples/builtin_sm_eager.toml
new file mode 100644
index 0000000000..cb5481f415
--- /dev/null
+++ b/pyamplicol/examples/builtin_sm_eager.toml
@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: 0BSD
+# Built-in Standard Model generation with prepared eager-DAG JIT O2 kernels.
+# Uses the wheel's automatically selected x86_64 or aarch64 prepared pack.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "d d~ > z g g", name = "eager_zgg" }]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/builtin_sm_eager"
+mode = "error"
+emit_api_bundle = true
+
+[evaluator]
+execution_mode = "eager"
+backend = "jit"
+batch_size = 128
+
+[evaluator.jit]
+optimization_level = 2
+compress = false
+
+[evaluator.eager]
+point_tile_size = 1024
+workspace_mib = 256
+
+[output]
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/builtin_sm_full.toml b/pyamplicol/examples/builtin_sm_full.toml
new file mode 100644
index 0000000000..11eb83738e
--- /dev/null
+++ b/pyamplicol/examples/builtin_sm_full.toml
@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: 0BSD
+# Built-in Standard Model generation with the full color contraction.
+# Resolved runtime output has one contracted color entry per helicity.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "u u~ > g g", name = "uubar_gg_full" }]
+
+[color]
+accuracy = "full"
+
+[generation]
+output = "artifacts/builtin_sm_full"
+mode = "error"
+emit_api_bundle = true
+
+[evaluator]
+backend = "cpp"
+# The C++ example intentionally selects process-local compiled execution;
+# the default recurrence mode uses the packaged portable JIT O2 kernel pack.
+execution_mode = "compiled"
+
+[evaluator.cpp]
+optimization = "O3"
+native_arch = false
+
+[output]
+progress = "log"
diff --git a/pyamplicol/examples/builtin_sm_heft.toml b/pyamplicol/examples/builtin_sm_heft.toml
new file mode 100644
index 0000000000..cf50b3d1c8
--- /dev/null
+++ b/pyamplicol/examples/builtin_sm_heft.toml
@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: 0BSD
+# Packaged scalar HEFT generation for g g > H g g at full colour.
+# Uses the wheel-owned prepared JIT O2 kernel bundle and recurrence schedule.
+# Explicit HIG=1 certifies a single insertion for adaptive adjoint DDM FFT.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm-heft"
+
+[process]
+entries = [{ expression = "g g > H g g", name = "gg_hgg" }]
+coupling_order_policy = "explicit"
+max_coupling_orders = { HIG = 1 }
+
+[color]
+accuracy = "full"
+contraction = "symmetric-group-fft"
+fft_basis = "adjoint"
+
+[generation]
+output = "artifacts/builtin_sm_heft"
+mode = "error"
+emit_api_bundle = true
+
+[evaluator]
+execution_mode = "recurrence"
+backend = "jit"
+
+[output]
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/builtin_sm_lc.toml b/pyamplicol/examples/builtin_sm_lc.toml
new file mode 100644
index 0000000000..647de0093b
--- /dev/null
+++ b/pyamplicol/examples/builtin_sm_lc.toml
@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: 0BSD
+# Built-in Standard Model generation at leading color with default recurrence.
+# Writes a transactional schema-v3 artifact and root API bundle.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "u u~ > g g", name = "uubar_gg" }]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/builtin_sm_lc"
+mode = "error"
+emit_api_bundle = true
+
+[evaluator]
+backend = "jit"
+batch_size = 128
+
+[evaluator.jit]
+optimization_level = 2
+compress = false
+
+[output]
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/builtin_sm_nlc.toml b/pyamplicol/examples/builtin_sm_nlc.toml
new file mode 100644
index 0000000000..7696f942ee
--- /dev/null
+++ b/pyamplicol/examples/builtin_sm_nlc.toml
@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: 0BSD
+# Built-in Standard Model default-recurrence generation with NLC contraction.
+# Resolved runtime output has one contracted color entry per helicity.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "u u~ > g g", name = "uubar_gg_nlc" }]
+
+[color]
+accuracy = "nlc"
+
+[generation]
+output = "artifacts/builtin_sm_nlc"
+mode = "error"
+emit_api_bundle = true
+
+[evaluator]
+backend = "jit"
+
+[evaluator.jit]
+optimization_level = 2
+compress = false
+
+[output]
+progress = "log"
diff --git a/pyamplicol/examples/builtin_sm_on_the_fly.toml b/pyamplicol/examples/builtin_sm_on_the_fly.toml
new file mode 100644
index 0000000000..6ac5a72932
--- /dev/null
+++ b/pyamplicol/examples/builtin_sm_on_the_fly.toml
@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: 0BSD
+# Built-in Standard Model LC generation with compact on-the-fly execution.
+# Uses the wheel-owned prepared JIT O2 kernel pack at native f64 precision.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "d d~ > z g g", name = "on_the_fly_zgg" }]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/builtin_sm_on_the_fly"
+mode = "error"
+emit_api_bundle = false
+
+[evaluator]
+execution_mode = "on-the-fly"
+backend = "jit"
+batch_size = 128
+
+[evaluator.optimization]
+# Query-construction request; numerical evaluation is not promised four threads.
+cores = 4
+
+[evaluator.jit]
+optimization_level = 2
+compress = false
+
+[output]
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/data/model_parameters.json b/pyamplicol/examples/data/model_parameters.json
new file mode 100644
index 0000000000..2f0fde26be
--- /dev/null
+++ b/pyamplicol/examples/data/model_parameters.json
@@ -0,0 +1,4 @@
+{
+  "aS": [0.117, 0.0],
+  "MZ": [91.188, 0.0]
+}
diff --git a/pyamplicol/examples/data/pp_4j_momenta.json b/pyamplicol/examples/data/pp_4j_momenta.json
new file mode 100644
index 0000000000..d771c8208f
--- /dev/null
+++ b/pyamplicol/examples/data/pp_4j_momenta.json
@@ -0,0 +1,10 @@
+[
+  [
+    [500.0, 0.0, 0.0, 500.0],
+    [500.0, 0.0, 0.0, -500.0],
+    [128.3787399982121, -71.23031764614652, 47.087854014801664, -95.86488791960448],
+    [334.43918837698175, 304.7133406265853, -93.4909089428669, 101.28573794704494],
+    [235.17705547671883, 1.8638452993958485, 234.86942331328228, 11.879709419251002],
+    [302.0050161480876, -235.34686827983452, -188.46636838521704, -17.30055944669148]
+  ]
+]
diff --git a/pyamplicol/examples/data/pp_zjj_momenta.json b/pyamplicol/examples/data/pp_zjj_momenta.json
new file mode 100644
index 0000000000..9674ef5dbe
--- /dev/null
+++ b/pyamplicol/examples/data/pp_zjj_momenta.json
@@ -0,0 +1,9 @@
+[
+  [
+    [500.0, 0.0, 0.0, 500.0],
+    [500.0, 0.0, 0.0, -500.0],
+    [369.7738416261408, -17.479290785282917, 2.0064955613504103, 369.3550355960509],
+    [462.6501613061637, 14.340107538562991, 155.76435943335707, -425.7484539710246],
+    [167.57599706769557, 3.1391832467199254, -157.77085499470743, 56.3934183749737]
+  ]
+]
diff --git a/pyamplicol/examples/evaluate_pp_4j_member.toml b/pyamplicol/examples/evaluate_pp_4j_member.toml
new file mode 100644
index 0000000000..7a244a00f0
--- /dev/null
+++ b/pyamplicol/examples/evaluate_pp_4j_member.toml
@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: 0BSD
+# Evaluate u~ g > u~ g g g, a flavour-blind member that was not generated.
+# It is routed through its representative d g > d g g g by the relabelling
+# u -> d plus charge conjugation, at momenta given in the member's leg order.
+
+schema_version = 1
+action = "evaluate"
+
+[evaluation]
+artifact = "artifacts/pp_4j_flavor_blind"
+# Any member of the 486 subprocesses, in any order within each side of ">",
+# is accepted, for example "g u~ > g g g u~" or "u~ u > u~ u g g".
+process = "u~ g > u~ g g g"
+precision = 16
+momenta = "data/pp_4j_momenta.json"
+
+[output]
+format = "human"
+color = "auto"
+progress = "off"
diff --git a/pyamplicol/examples/evaluate_resolved.toml b/pyamplicol/examples/evaluate_resolved.toml
new file mode 100644
index 0000000000..9ef91566b7
--- /dev/null
+++ b/pyamplicol/examples/evaluate_resolved.toml
@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: 0BSD
+# Helicity/color-resolved evaluation of one UFO-SM pp -> Zjj subprocess.
+# Empty selector arrays mean all physical IDs stored in the artifact.
+
+schema_version = 1
+action = "evaluate"
+
+[evaluation]
+artifact = "artifacts/pp_zjj"
+process = "d d~ > g z g"
+precision = 16
+resolved = true
+helicity_ids = []
+color_flow_ids = []
+model_parameters = "data/model_parameters.json"
+momenta = "data/pp_zjj_momenta.json"
+
+[output]
+format = "human"
+color = "auto"
+progress = "off"
diff --git a/pyamplicol/examples/evaluate_total.toml b/pyamplicol/examples/evaluate_total.toml
new file mode 100644
index 0000000000..5994536c57
--- /dev/null
+++ b/pyamplicol/examples/evaluate_total.toml
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: 0BSD
+# Fully summed evaluation of one UFO-SM pp -> Zjj subprocess.
+
+schema_version = 1
+action = "evaluate"
+
+[evaluation]
+artifact = "artifacts/pp_zjj"
+process = "d d~ > g z g"
+precision = 16
+resolved = false
+model_parameters = "data/model_parameters.json"
+momenta = "data/pp_zjj_momenta.json"
+
+[output]
+format = "human"
+color = "auto"
+progress = "off"
diff --git a/pyamplicol/examples/external_json_scalar_gravity.toml b/pyamplicol/examples/external_json_scalar_gravity.toml
new file mode 100644
index 0000000000..df648698d4
--- /dev/null
+++ b/pyamplicol/examples/external_json_scalar_gravity.toml
@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: 0BSD
+# Serialized spin-2 scalar-gravity model named "scalar_gravity".
+# `pyamplicol examples copy` materializes this model beside the card.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "models/json/scalar_gravity/scalar_gravity.json"
+simplify = true
+
+[process]
+entries = [
+  { expression = "scalar_0 scalar_0 > graviton graviton", name = "scalar_gravity_2to2" },
+  { expression = "scalar_0 scalar_0 > 3*graviton", name = "scalar_gravity_2to3" },
+]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/external_json_scalar_gravity"
+emit_api_bundle = true
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
diff --git a/pyamplicol/examples/external_json_scalars.toml b/pyamplicol/examples/external_json_scalars.toml
new file mode 100644
index 0000000000..46e94e1a8a
--- /dev/null
+++ b/pyamplicol/examples/external_json_scalars.toml
@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: 0BSD
+# Serialized scalar contact model named "scalars".
+# `pyamplicol examples copy` materializes this model beside the card.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "models/json/scalars/scalars.json"
+simplify = true
+
+[process]
+entries = [
+  { expression = "scalar_0 scalar_0 > scalar_0 scalar_0", name = "scalar_contact_2to2" },
+  { expression = "scalar_0 scalar_0 > 3*scalar_0", name = "scalar_contact_2to3" },
+]
+
+[process.max_coupling_orders]
+QED = 6
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/external_json_scalars"
+emit_api_bundle = true
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
diff --git a/pyamplicol/examples/external_ufo_sm.toml b/pyamplicol/examples/external_ufo_sm.toml
new file mode 100644
index 0000000000..128df42b65
--- /dev/null
+++ b/pyamplicol/examples/external_ufo_sm.toml
@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: 0BSD
+# Trusted external UFO model named "sm".
+# `pyamplicol examples copy` materializes models/ufo/sm beside this card.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "models/ufo/sm"
+restriction = "default"
+simplify = true
+cache = true
+
+[process]
+entries = [{ expression = "u u~ > Z g", name = "ufo_sm_uubar_Zg" }]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/external_ufo_sm"
+emit_api_bundle = true
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
diff --git a/pyamplicol/examples/generate_pp_4j_flavor_blind.toml b/pyamplicol/examples/generate_pp_4j_flavor_blind.toml
new file mode 100644
index 0000000000..8c6d3d193c
--- /dev/null
+++ b/pyamplicol/examples/generate_pp_4j_flavor_blind.toml
@@ -0,0 +1,44 @@
+# SPDX-License-Identifier: 0BSD
+# Flavour-blind built-in SM p p > j j j j at QED = 0 and leading color.
+# Generates 23 class representatives and records the other 463 of the 486
+# five-flavour subprocesses as callable members in process-groups.json.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "p p > j j j j" }]
+# Omitted flavor_scheme keeps the default five massless quark flavours; the
+# model's default p and j multiparticles contain all of them and the gluon.
+# One representative per flavour-relabelling class is generated. Equal matrix
+# elements within a class are assumed, not verified; they hold for pure-QCD
+# jets with massless quarks, so this request produces no relabelling warning.
+flavor_blind = true
+# Also relate classes by charge conjugation (the default): 23 instead of 33
+# representatives.
+consider_charge_conjugation = true
+
+[process.max_coupling_orders]
+# Pure QCD: no photon, Z, or W exchange between the quark lines.
+QED = 0
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/pp_4j_flavor_blind"
+mode = "error"
+emit_api_bundle = true
+
+[evaluator]
+# Omitted execution_mode uses recurrence over the wheel-owned prepared
+# JIT O2 kernels of the built-in model.
+backend = "jit"
+batch_size = 128
+
+[output]
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/generate_pp_zjj_from_ufo_sm.toml b/pyamplicol/examples/generate_pp_zjj_from_ufo_sm.toml
new file mode 100644
index 0000000000..fffb19506b
--- /dev/null
+++ b/pyamplicol/examples/generate_pp_zjj_from_ufo_sm.toml
@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: 0BSD
+# Generate p p > Z j j from the serialized form of the UFO Standard Model.
+# `pyamplicol examples copy` materializes models/json/sm beside this card.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "models/json/sm/sm.json"
+restriction = "default"
+simplify = true
+
+[process]
+entries = [{ expression = "p p > Z j j" }]
+flavor_scheme = 2
+max_quark_lines = 2
+
+[process.multiparticles]
+p = ["d", "d~", "g"]
+j = ["d", "d~", "g"]
+
+[color]
+accuracy = "lc"
+# Omitted lc_flow_layout defaults to non-union "topology-replay".
+# Set it to "all-flow-union" to generate the LC union-flow layout instead.
+
+[generation]
+output = "artifacts/pp_zjj"
+emit_api_bundle = true
+
+[evaluator]
+backend = "jit"
+# Raw portable model IR has no prepared recurrence pack. This example
+# intentionally demonstrates process-local compiled DAG generation.
+execution_mode = "compiled"
+
+[evaluator.jit]
+# Omitted optimization_level uses the portable JIT O2 default.
+compress = "auto"
diff --git a/pyamplicol/examples/group_pp_4j.toml b/pyamplicol/examples/group_pp_4j.toml
new file mode 100644
index 0000000000..85ae16213f
--- /dev/null
+++ b/pyamplicol/examples/group_pp_4j.toml
@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: 0BSD
+# Numerically group the generated representatives of the flavour-blind
+# p p > j j j j artifact and update its process-groups.json in place.
+
+schema_version = 1
+action = "group-processes"
+
+[process]
+# Run cards use the schema default "none"; request the numerical analysis.
+analyze_process_groups = "numerical"
+only_unit_multiplier = false
+consider_charge_conjugation = true
+
+[evaluation]
+artifact = "artifacts/pp_4j_flavor_blind"
+
+[output]
+format = "human"
+color = "auto"
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/inspect_pp_4j.toml b/pyamplicol/examples/inspect_pp_4j.toml
new file mode 100644
index 0000000000..8a1907c93b
--- /dev/null
+++ b/pyamplicol/examples/inspect_pp_4j.toml
@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: 0BSD
+# Summarize the flavour-blind p p > j j j j artifact: its 23 generated
+# representatives and the process-group map of all 486 subprocesses.
+
+schema_version = 1
+action = "inspect"
+
+[evaluation]
+artifact = "artifacts/pp_4j_flavor_blind"
+
+[output]
+format = "human"
+color = "auto"
+progress = "off"
diff --git a/pyamplicol/examples/native/Makefile b/pyamplicol/examples/native/Makefile
new file mode 100644
index 0000000000..faf6409869
--- /dev/null
+++ b/pyamplicol/examples/native/Makefile
@@ -0,0 +1,58 @@
+# SPDX-License-Identifier: 0BSD
+
+CC ?= cc
+CXX ?= c++
+RUSTC ?= rustc
+ifeq ($(origin FC), default)
+FC := gfortran
+endif
+FC ?= gfortran
+CFLAGS ?= -O2
+CXXFLAGS ?= -O2
+FFLAGS ?= -O2
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell \
+	if command -v "$(RUSTICOL_CONFIG)" >/dev/null 2>&1; then \
+		command -v "$(RUSTICOL_CONFIG)"; \
+	elif [ "$(RUSTICOL_CONFIG)" = rusticol-config ]; then \
+		directory="$(CURDIR)"; \
+		while [ "$$directory" != / ]; do \
+			candidate="$$directory/.venv/bin/rusticol-config"; \
+			if [ -x "$$candidate" ]; then printf '%s\n' "$$candidate"; break; fi; \
+			directory=$$(dirname "$$directory"); \
+		done; \
+	fi)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+
+RUSTICOL_CFLAGS := $(shell "$(RUSTICOL_CONFIG_PATH)" --cflags)
+RUSTICOL_LIBS := $(shell "$(RUSTICOL_CONFIG_PATH)" --libs)
+RUSTICOL_FORTRAN := $(shell "$(RUSTICOL_CONFIG_PATH)" --fortran-source)
+RUSTICOL_RUST := $(shell "$(RUSTICOL_CONFIG_PATH)" --rust-source)
+RUSTICOL_RUSTFLAGS := $(shell "$(RUSTICOL_CONFIG_PATH)" --rustflags)
+
+.PHONY: all correlated
+all: runtime_cpp runtime_fortran
+correlated: correlated_c correlated_cpp correlated_fortran correlated_rust
+
+runtime_cpp: runtime.cpp
+	$(CXX) $(CXXFLAGS) -std=c++17 $< $(RUSTICOL_CFLAGS) \
+		$(RUSTICOL_LIBS) -o $@
+
+runtime_fortran: runtime.f90
+	$(FC) $(FFLAGS) -std=f2008 "$(RUSTICOL_FORTRAN)" $< \
+		$(RUSTICOL_LIBS) -o $@
+
+correlated_c: correlated.c
+	$(CC) $(CFLAGS) -std=c11 $< $(RUSTICOL_CFLAGS) $(RUSTICOL_LIBS) -o $@
+
+correlated_cpp: correlated.cpp
+	$(CXX) $(CXXFLAGS) -std=c++17 $< $(RUSTICOL_CFLAGS) $(RUSTICOL_LIBS) -o $@
+
+correlated_fortran: correlated.f90
+	$(FC) $(FFLAGS) -std=f2008 "$(RUSTICOL_FORTRAN)" $< $(RUSTICOL_LIBS) -o $@
+
+correlated_rust: correlated.rs
+	RUSTICOL_RUST_SOURCE="$(RUSTICOL_RUST)" $(RUSTC) --edition=2021 \
+		-C opt-level=2 $< $(RUSTICOL_RUSTFLAGS) -o $@
diff --git a/pyamplicol/examples/native/correlated.c b/pyamplicol/examples/native/correlated.c
new file mode 100644
index 0000000000..b1c85ec714
--- /dev/null
+++ b/pyamplicol/examples/native/correlated.c
@@ -0,0 +1,120 @@
+/* SPDX-License-Identifier: 0BSD */
+/* Generate the d d~ > d d~ g example in the correlator guide first. */
+#include <rusticol.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static void check(int status) {
+    if (status != RUSTICOL_STATUS_OK) {
+        char error[2048];
+        size_t required = 0;
+        rusticol_last_error_message(error, sizeof error, &required);
+        fprintf(stderr, "Rusticol status %d: %s\n", status,
+                required <= sizeof error ? error : "error message too long");
+        exit(1);
+    }
+}
+
+static void same(double actual, double expected) {
+    if (fabs(actual - expected) > 1.e-12 * fmax(fabs(expected), 1.e-12)) {
+        fprintf(stderr, "mismatch: %.17g versus %.17g\n", actual, expected);
+        exit(1);
+    }
+}
+
+int main(int argc, char **argv) {
+    if (argc != 3) {
+        fprintf(stderr, "usage: correlated_c ARTIFACT PROCESS\n");
+        return 2;
+    }
+    RusticolRuntimeHandle *runtime = NULL;
+    check(rusticol_runtime_load(argv[1], argv[2], NULL, &runtime));
+    size_t count = 0, required = 0;
+    check(rusticol_runtime_color_correlation_count(runtime, &count));
+    int found_born = 0, found_interference = 0;
+    for (size_t index = 0; index < count; ++index) {
+        check(rusticol_runtime_color_correlation_id(runtime, index, NULL, 0, &required));
+        char *id = malloc(required);
+        if (!id) return 1;
+        check(rusticol_runtime_color_correlation_id(runtime, index, id, required, &required));
+        found_born |= strcmp(id, "born") == 0;
+        found_interference |= strcmp(id, "cascade-interference") == 0;
+        free(id);
+    }
+    if (!found_born || !found_interference) return 1;
+    check(rusticol_runtime_color_correlation_catalogue_json(runtime, NULL, 0, &required));
+    if (required < 2) return 1;
+
+    const double momenta[] = {
+        400,0,0,400, 400,0,0,-400,
+        300,300,0,0, 250,-150,200,0, 250,-150,-200,0,
+        400,0,0,400, 400,0,0,-400,
+        300,0,300,0, 250,200,-150,0, 250,-200,-150,0,
+    };
+    const double spin[] = {0,0, 0,0, 0,0, 1,0};
+    const RusticolSpinCorrelationVector vector = {5, 1, spin, 8};
+    const RusticolCorrelatedRequest requests[] = {
+        {"born", NULL, 0, 0},
+        {"cascade-interference", NULL, 0, 0},
+        {"cascade-interference", &vector, 1, 0},
+    };
+    double values[12], ordinary_before[2], ordinary_after[2];
+    check(rusticol_runtime_evaluate_f64(runtime, momenta, 40, 2, ordinary_before, 2));
+    check(rusticol_runtime_evaluate_correlated_many_f64(
+        runtime, momenta, 40, 2, requests, 3, NULL, 0, values, 12));
+    for (size_t request = 0; request < 3; ++request) {
+        for (size_t point = 0; point < 2; ++point) {
+            size_t index = 2 * (2 * request + point);
+            printf("VALUE %zu %zu %.17g %.17g\n", request, point,
+                   values[index], values[index + 1]);
+        }
+    }
+    check(rusticol_runtime_set_spin_correlation_vectors_f64(runtime, &vector, 1));
+    RusticolCorrelatedRequest inherited = {"cascade-interference", NULL, 0, 1};
+    double selected[4];
+    check(rusticol_runtime_evaluate_correlated_many_f64(
+        runtime, momenta, 40, 2, &inherited, 1, NULL, 0, selected, 4));
+    for (size_t index = 0; index < 4; ++index) same(selected[index], values[8 + index]);
+    check(rusticol_runtime_evaluate_f64(runtime, momenta, 40, 2, ordinary_after, 2));
+    for (size_t point = 0; point < 2; ++point) same(ordinary_after[point], ordinary_before[point]);
+    check(rusticol_runtime_set_spin_correlation_vectors_f64(runtime, NULL, 0));
+    check(rusticol_runtime_evaluate_correlated_many_f64(
+        runtime, momenta, 40, 2, &inherited, 1, NULL, 0, selected, 4));
+    for (size_t index = 0; index < 4; ++index) same(selected[index], values[4 + index]);
+    /* Per-point complex scaling: |i|^2=1 and |2|^2=4. */
+    const double scaled[] = {0,0, 0,0, 0,0, 0,1, 0,0, 0,0, 0,0, 2,0};
+    RusticolSpinCorrelationVector per_point = {5, 2, scaled, 16};
+    RusticolCorrelatedRequest varied = {"cascade-interference", &per_point, 1, 0};
+    check(rusticol_runtime_evaluate_correlated_many_f64(
+        runtime, momenta, 40, 2, &varied, 1, NULL, 0, selected, 4));
+    same(selected[0], values[8]);
+    same(selected[2], 4 * values[10]);
+    /* Ward identity: substitute the on-shell momentum on gluon leg 5. */
+    double longitudinal[16];
+    for (size_t point = 0; point < 2; ++point) {
+        for (size_t mu = 0; mu < 4; ++mu) {
+            longitudinal[8 * point + 2 * mu] = momenta[20 * point + 16 + mu];
+            longitudinal[8 * point + 2 * mu + 1] = 0;
+        }
+    }
+    per_point.components = longitudinal;
+    check(rusticol_runtime_evaluate_correlated_many_f64(
+        runtime, momenta, 40, 2, &varied, 1, NULL, 0, selected, 4));
+    for (size_t point = 0; point < 2; ++point) {
+        if (hypot(selected[2 * point], selected[2 * point + 1])
+            > 1.e-15 * 800 * 800 * fabs(values[2 * point])) return 1;
+    }
+    /* Errors do not partially overwrite the caller's output. */
+    selected[0] = 123;
+    if (rusticol_runtime_evaluate_correlated_many_f64(
+        runtime, momenta, 40, 2, requests, 3, NULL, 0, selected, 4)
+        != RUSTICOL_STATUS_BUFFER_TOO_SMALL || selected[0] != 123) return 1;
+    RusticolCorrelatedRequest missing = {"missing", NULL, 0, 0};
+    if (rusticol_runtime_evaluate_correlated_many_f64(
+        runtime, momenta, 40, 2, &missing, 1, NULL, 0, selected, 4)
+        == RUSTICOL_STATUS_OK || selected[0] != 123) return 1;
+    check(rusticol_runtime_free(runtime));
+    return 0;
+}
diff --git a/pyamplicol/examples/native/correlated.cpp b/pyamplicol/examples/native/correlated.cpp
new file mode 100644
index 0000000000..5ae95c409b
--- /dev/null
+++ b/pyamplicol/examples/native/correlated.cpp
@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: 0BSD
+// Generate d d~ > d d~ g with the E.3 "cascade-interference" insertion first.
+#include <rusticol.hpp>
+
+#include <algorithm>
+#include <iomanip>
+#include <iostream>
+
+int main(int argc, char **argv) {
+    if (argc != 3) {
+        std::cerr << "usage: correlated_cpp ARTIFACT PROCESS\n";
+        return 2;
+    }
+    try {
+        rusticol::Runtime runtime(argv[1], argv[2]);
+        const auto ids = runtime.color_correlation_ids();
+        for (const auto &id : {"born", "cascade-interference"}) {
+            if (std::find(ids.begin(), ids.end(), id) == ids.end()) {
+                throw std::runtime_error("required colour correlation is not registered");
+            }
+        }
+        if (runtime.color_correlation_catalogue_json().empty()) {
+            throw std::runtime_error("missing colour histories");
+        }
+        const std::vector<double> momenta{
+            400,0,0,400, 400,0,0,-400, 300,300,0,0, 250,-150,200,0, 250,-150,-200,0,
+            400,0,0,400, 400,0,0,-400, 300,0,300,0, 250,200,-150,0, 250,-200,-150,0,
+        };
+        const std::vector<rusticol::SpinCorrelationVector> spins{
+            {5, {{{0., 0., 0., 1.}}}}}, physical{};
+        const std::vector<rusticol::CorrelatedRequest> requests{
+            {"born", physical}, {"cascade-interference", physical},
+            {"cascade-interference", spins},
+        };
+        const auto ordinary = runtime.evaluate(momenta, 2);
+        const auto result = runtime.evaluate_correlated_many(momenta, 2, requests);
+        runtime.set_spin_correlation_vectors(spins);
+        const auto inherited = runtime.evaluate_correlated(momenta, 2, "cascade-interference");
+        const auto after = runtime.evaluate(momenta, 2);
+        runtime.set_spin_correlation_vectors();
+        const auto cleared = runtime.evaluate_correlated(momenta, 2, "cascade-interference");
+        const auto close = [](std::complex<double> a, std::complex<double> b) {
+            return std::abs(a - b) <= 1e-11 * std::max(1e-100, std::max(std::abs(a), std::abs(b)));
+        };
+        for (std::size_t point = 0; point < 2; ++point) {
+            if (!close(inherited[point], result(2, point)) ||
+                !close(cleared[point], result(1, point)) ||
+                ordinary[point] != after[point]) {
+                throw std::runtime_error("setter or ordinary-evaluation isolation check failed");
+            }
+        }
+        std::cout << std::setprecision(17);
+        for (std::size_t request = 0; request < requests.size(); ++request) {
+            for (std::size_t point = 0; point < 2; ++point) {
+                const auto value = result(request, point);
+                std::cout << "VALUE " << request << ' ' << point << ' '
+                          << value.real() << ' ' << value.imag() << '\n';
+            }
+        }
+    } catch (const std::exception &error) {
+        std::cerr << error.what() << '\n';
+        return 1;
+    }
+}
diff --git a/pyamplicol/examples/native/correlated.f90 b/pyamplicol/examples/native/correlated.f90
new file mode 100644
index 0000000000..7f4b57f6f0
--- /dev/null
+++ b/pyamplicol/examples/native/correlated.f90
@@ -0,0 +1,69 @@
+! SPDX-License-Identifier: 0BSD
+! Generate d d~ > d d~ g with the E.3 "cascade-interference" insertion first.
+program correlated_fortran
+  use, intrinsic :: iso_c_binding
+  use rusticol
+  implicit none
+  type(rusticol_runtime) :: runtime
+  type(rusticol_correlated_request) :: requests(3), inherited_request
+  type(rusticol_spin_correlation_vector) :: spins(1)
+  type(rusticol_string), allocatable :: ids(:)
+  character(len=4096) :: artifact, process_key
+  character(len=:), allocatable :: catalogue
+  real(c_double), target :: momenta(40)
+  real(c_double), allocatable :: ordinary(:), after(:)
+  complex(c_double_complex), allocatable :: values(:, :), inherited(:), cleared(:)
+  integer :: point, request, index
+  logical :: has_born, has_cascade
+
+  if (command_argument_count() /= 2) error stop "usage: correlated_fortran ARTIFACT PROCESS"
+  call get_command_argument(1, artifact)
+  call get_command_argument(2, process_key)
+  call runtime%load(trim(artifact), process_key=trim(process_key))
+  ids = runtime%color_correlation_ids()
+  has_born = .false.
+  has_cascade = .false.
+  do index = 1, size(ids)
+    has_born = has_born .or. ids(index)%value == "born"
+    has_cascade = has_cascade .or. ids(index)%value == "cascade-interference"
+  end do
+  if (.not. has_born .or. .not. has_cascade) error stop "required colour correlation is not registered"
+  catalogue = runtime%color_correlation_catalogue_json()
+  if (len(catalogue) == 0) error stop "missing colour histories"
+  momenta = real([ &
+      400,0,0,400, 400,0,0,-400, 300,300,0,0, 250,-150,200,0, 250,-150,-200,0, &
+      400,0,0,400, 400,0,0,-400, 300,0,300,0, 250,200,-150,0, 250,-200,-150,0 ], c_double)
+  spins(1)%leg = 5_c_size_t
+  allocate(spins(1)%components(4, 1))
+  spins(1)%components(:, 1) = cmplx([0, 0, 0, 1], kind=c_double)
+  requests(1)%color_correlation = "born"
+  requests(2)%color_correlation = "cascade-interference"
+  requests(3)%color_correlation = "cascade-interference"
+  allocate(requests(1)%spin_vectors(0), requests(2)%spin_vectors(0))
+  requests(3)%spin_vectors = spins
+  call runtime%evaluate(momenta, 2_c_size_t, ordinary)
+  call runtime%evaluate_correlated_many(momenta, 2_c_size_t, requests, values)
+  call runtime%set_spin_correlation_vectors(spins)
+  inherited_request%color_correlation = "cascade-interference"
+  call runtime%evaluate_correlated(momenta, 2_c_size_t, inherited_request, inherited)
+  call runtime%evaluate(momenta, 2_c_size_t, after)
+  if (any(ordinary /= after)) error stop "spin setter changed ordinary evaluation"
+  call runtime%set_spin_correlation_vectors()
+  call runtime%evaluate_correlated(momenta, 2_c_size_t, inherited_request, cleared)
+  do point = 1, 2
+    if (.not. close(inherited(point), values(point, 3))) error stop "default spin source mismatch"
+    if (.not. close(cleared(point), values(point, 2))) error stop "cleared spin source mismatch"
+  end do
+  do request = 1, size(requests)
+    do point = 1, 2
+      write(*, '(A,1X,I0,1X,I0,2(1X,ES25.17E3))') "VALUE", request - 1, point - 1, &
+          real(values(point, request), c_double), aimag(values(point, request))
+    end do
+  end do
+  call runtime%close()
+contains
+  logical function close(a, b)
+    complex(c_double_complex), intent(in) :: a, b
+    close = abs(a - b) <= 1e-11_c_double * max(1e-100_c_double, abs(a), abs(b))
+  end function close
+end program correlated_fortran
diff --git a/pyamplicol/examples/native/correlated.rs b/pyamplicol/examples/native/correlated.rs
new file mode 100644
index 0000000000..e2047c4031
--- /dev/null
+++ b/pyamplicol/examples/native/correlated.rs
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: 0BSD
+// Set RUSTICOL_RUST_SOURCE to `rusticol-config --json`'s rust_source when compiling.
+#[allow(dead_code)]
+mod rusticol {
+    include!(env!("RUSTICOL_RUST_SOURCE"));
+}
+
+use rusticol::{Complex64, CorrelatedRequest, Runtime, SpinCorrelationVector};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args = std::env::args().collect::<Vec<_>>();
+    if args.len() != 3 {
+        return Err("usage: correlated_rust ARTIFACT PROCESS".into());
+    }
+    let mut runtime = Runtime::load(&args[1], Some(&args[2]), None)?;
+    let ids = runtime.color_correlation_ids()?;
+    for id in ["born", "cascade-interference"] {
+        if !ids.iter().any(|item| item == id) {
+            return Err("required colour correlation is not registered".into());
+        }
+    }
+    assert!(!runtime.color_correlation_catalogue_json()?.is_empty());
+    let momenta = [
+        400., 0., 0., 400., 400., 0., 0., -400., 300., 300., 0., 0., 250., -150., 200., 0., 250.,
+        -150., -200., 0., 400., 0., 0., 400., 400., 0., 0., -400., 300., 0., 300., 0., 250., 200.,
+        -150., 0., 250., -200., -150., 0.,
+    ];
+    let spins = vec![SpinCorrelationVector {
+        leg: 5,
+        components: vec![[
+            Complex64::default(),
+            Complex64::default(),
+            Complex64::default(),
+            Complex64::new(1., 0.),
+        ]],
+    }];
+    let requests = [
+        CorrelatedRequest {
+            color_correlation: "born".into(),
+            spin_vectors: Some(vec![]),
+        },
+        CorrelatedRequest {
+            color_correlation: "cascade-interference".into(),
+            spin_vectors: Some(vec![]),
+        },
+        CorrelatedRequest {
+            color_correlation: "cascade-interference".into(),
+            spin_vectors: Some(spins.clone()),
+        },
+    ];
+    let ordinary = runtime.evaluate_f64(&momenta, 2)?;
+    let result = runtime.evaluate_correlated_many_f64(&momenta, 2, &requests, &[])?;
+    runtime.set_spin_correlation_vectors(&spins)?;
+    let default_request = CorrelatedRequest::new("cascade-interference");
+    let inherited = runtime.evaluate_correlated_f64(&momenta, 2, &default_request, &[])?;
+    assert_eq!(ordinary, runtime.evaluate_f64(&momenta, 2)?);
+    runtime.set_spin_correlation_vectors(&[])?;
+    let cleared = runtime.evaluate_correlated_f64(&momenta, 2, &default_request, &[])?;
+    let close = |a: Complex64, b: Complex64| {
+        (a.re - b.re).hypot(a.im - b.im)
+            <= 1e-11 * a.re.hypot(a.im).max(b.re.hypot(b.im)).max(1e-100)
+    };
+    for point in 0..2 {
+        assert!(close(inherited[point], result.get(2, point).unwrap()));
+        assert!(close(cleared[point], result.get(1, point).unwrap()));
+    }
+    for request in 0..requests.len() {
+        for point in 0..2 {
+            let value = result.get(request, point).unwrap();
+            println!(
+                "VALUE {request} {point} {:.17e} {:.17e}",
+                value.re, value.im
+            );
+        }
+    }
+    Ok(())
+}
diff --git a/pyamplicol/examples/native/runtime.cpp b/pyamplicol/examples/native/runtime.cpp
new file mode 100644
index 0000000000..c85c1ba16e
--- /dev/null
+++ b/pyamplicol/examples/native/runtime.cpp
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: 0BSD
+
+#include <rusticol.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+int main(int argc, char **argv) {
+    if (argc < 3 || argc > 4) {
+        std::cerr << "usage: runtime_cpp ARTIFACT PROCESS [PARAMETERS.json]\n";
+        return 2;
+    }
+
+    try {
+        rusticol::Runtime runtime(argv[1], argv[2]);
+        if (argc == 4) {
+            runtime.set_model_parameters_json(argv[3]);
+        }
+        runtime.set_model_parameter("aS", 0.117);
+
+        // The external-SM d d~ > Z g g subprocess p_p_to_z_j_j_3,
+        // flattened as
+        // [point][particle][E,px,py,pz].
+        const std::vector<double> momenta{
+            500.0, 0.0, 0.0, 500.0,
+            500.0, 0.0, 0.0, -500.0,
+            462.6501613061637, 14.340107538562991, 155.76435943335707,
+            -425.7484539710246,
+            369.7738416261408, -17.479290785282917, 2.0064955613504103,
+            369.3550355960509,
+            167.57599706769557, 3.1391832467199254, -157.77085499470743,
+            56.3934183749737,
+        };
+        constexpr std::size_t point_count = 1;
+        const auto totals = runtime.evaluate(momenta, point_count);
+        const auto resolved = runtime.evaluate_resolved(momenta, point_count);
+        const auto checked_totals = resolved.total();
+        const double scale = std::max(1.0, std::abs(totals.at(0)));
+        if (std::abs(totals.at(0) - checked_totals.at(0)) > 1.0e-12 * scale) {
+            std::cerr << "resolved components do not reproduce the total\n";
+            return 1;
+        }
+
+        std::cout << std::setprecision(17)
+                  << "process=" << runtime.process_key() << "\n"
+                  << "color_accuracy=" << runtime.color_accuracy() << "\n"
+                  << "total=" << totals.at(0) << "\n";
+    } catch (const std::exception &error) {
+        std::cerr << "Rusticol error: " << error.what() << "\n";
+        return 1;
+    }
+    return 0;
+}
diff --git a/pyamplicol/examples/native/runtime.f90 b/pyamplicol/examples/native/runtime.f90
new file mode 100644
index 0000000000..f30d5930d9
--- /dev/null
+++ b/pyamplicol/examples/native/runtime.f90
@@ -0,0 +1,56 @@
+! SPDX-License-Identifier: 0BSD
+
+program runtime_fortran
+  use, intrinsic :: iso_c_binding, only: c_double, c_size_t
+  use rusticol, only: rusticol_runtime
+  implicit none
+
+  type(rusticol_runtime) :: runtime
+  character(len=4096) :: artifact, process_key, parameters
+  real(c_double), target :: momenta(20)
+  real(c_double), allocatable :: totals(:), resolved(:, :, :)
+  real(c_double) :: checked_total, scale
+
+  if (command_argument_count() < 2 .or. command_argument_count() > 3) then
+    error stop "usage: runtime_fortran ARTIFACT PROCESS [PARAMETERS.json]"
+  end if
+  call get_command_argument(1, artifact)
+  call get_command_argument(2, process_key)
+  parameters = ""
+  if (command_argument_count() == 3) call get_command_argument(3, parameters)
+
+  if (len_trim(parameters) > 0) then
+    call runtime%load(trim(artifact), process_key=trim(process_key), &
+                      model_parameters=trim(parameters))
+  else
+    call runtime%load(trim(artifact), process_key=trim(process_key))
+  end if
+  call runtime%set_model_parameter( &
+      "aS", 0.117_c_double)
+
+  ! The external-SM d d~ > Z g g subprocess p_p_to_z_j_j_3,
+  ! flattened as
+  ! [point][particle][E,px,py,pz].
+  momenta = [ &
+      500.0_c_double, 0.0_c_double, 0.0_c_double, 500.0_c_double, &
+      500.0_c_double, 0.0_c_double, 0.0_c_double, -500.0_c_double, &
+      462.6501613061637_c_double, 14.340107538562991_c_double, &
+      155.76435943335707_c_double, -425.7484539710246_c_double, &
+      369.7738416261408_c_double, -17.479290785282917_c_double, &
+      2.0064955613504103_c_double, 369.3550355960509_c_double, &
+      167.57599706769557_c_double, 3.1391832467199254_c_double, &
+      -157.77085499470743_c_double, 56.3934183749737_c_double ]
+
+  call runtime%evaluate(momenta, 1_c_size_t, totals)
+  call runtime%evaluate_resolved(momenta, 1_c_size_t, resolved)
+  checked_total = sum(resolved(:, :, 1))
+  scale = max(1.0_c_double, abs(totals(1)))
+  if (abs(totals(1) - checked_total) > 1.0e-12_c_double * scale) then
+    error stop "resolved components do not reproduce the total"
+  end if
+
+  write(*, '(A)') "process=" // runtime%process_key()
+  write(*, '(A)') "color_accuracy=" // runtime%color_accuracy()
+  write(*, '(A,ES24.16)') "total=", totals(1)
+  call runtime%close()
+end program runtime_fortran
diff --git a/pyamplicol/examples/otf_pp_zjj.toml b/pyamplicol/examples/otf_pp_zjj.toml
new file mode 100644
index 0000000000..150e836119
--- /dev/null
+++ b/pyamplicol/examples/otf_pp_zjj.toml
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: 0BSD
+# Compact OTF LC example for p p > Z j j. The first explicit warm_up or
+# evaluation constructs only the selected flow with a complete helicity sum.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+
+[process]
+entries = [{ expression = "p p > Z j j" }]
+flavor_scheme = 2
+max_quark_lines = 2
+
+[process.multiparticles]
+p = ["d", "d~", "g"]
+j = ["d", "d~", "g"]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/otf_pp_zjj"
+mode = "error"
+emit_api_bundle = true
+
+[evaluator]
+execution_mode = "on-the-fly"
+backend = "jit"
+batch_size = 128
+
+[evaluator.optimization]
+# This controls cold query construction, not warmed numerical execution.
+cores = 4
+
+[evaluator.jit]
+optimization_level = 2
+compress = false
+
+[evaluation]
+artifact = "artifacts/otf_pp_zjj"
+process = "d d~ > g z g"
+momenta = "data/pp_zjj_momenta.json"
+precision = 16
+
+[benchmark]
+target_runtime = 2.0
+batch_size = 128
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+# CLI positions are one-based; this is one LC flow with a helicity sum.
+color_flow_ids = ["1"]
+
+[output]
+format = "human"
+color = "auto"
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/process_set_mixed_multiplicity.toml b/pyamplicol/examples/process_set_mixed_multiplicity.toml
new file mode 100644
index 0000000000..938d342df2
--- /dev/null
+++ b/pyamplicol/examples/process_set_mixed_multiplicity.toml
@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: 0BSD
+# One UFO-SM artifact containing 2-to-2 and 2-to-3 processes.
+# Generation can reuse proven final-state permutations within the set.
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "models/json/sm/sm.json"
+restriction = "default"
+
+[process]
+entries = [
+  { expression = "u u~ > Z g", name = "uubar_Zg" },
+  { expression = "u u~ > Z g g", name = "uubar_Zgg" },
+]
+flavor_scheme = 5
+max_quark_lines = 2
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/mixed_multiplicity"
+workers = "auto"
+emit_api_bundle = true
+
+[generation.validation]
+enabled = true
+samples = 3
+seed = 12345
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
+batch_size = 128
diff --git a/pyamplicol/examples/python/benchmark.py b/pyamplicol/examples/python/benchmark.py
new file mode 100644
index 0000000000..7f12ec429e
--- /dev/null
+++ b/pyamplicol/examples/python/benchmark.py
@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: 0BSD
+"""Benchmark an artifact through the typed service facade."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+from pyamplicol import BenchmarkConfig, BenchmarkRunner, Runtime
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("artifact", type=Path)
+    parser.add_argument("--process")
+    parser.add_argument("--momenta", type=Path)
+    parser.add_argument("--target-runtime", type=float, default=1.0)
+    parser.add_argument("--batch-size", type=int, default=128)
+    parser.add_argument("--precision", type=int, default=16)
+    parser.add_argument("--warmup-runs", type=int, default=2)
+    parser.add_argument("--minimum-samples", type=int, default=5)
+    parser.add_argument("--helicity", action="append")
+    parser.add_argument("--color-flow", action="append")
+    return parser
+
+
+def _read_points(path: Path | None) -> Any:
+    if path is None:
+        return None
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    config = BenchmarkConfig(
+        target_runtime=args.target_runtime,
+        batch_size=args.batch_size,
+        precision=args.precision,
+        warmup_runs=args.warmup_runs,
+        minimum_samples=args.minimum_samples,
+        helicity_ids=tuple(args.helicity or ()),
+        color_flow_ids=tuple(args.color_flow or ()),
+    )
+    runtime = Runtime.load(args.artifact, process=args.process)
+    result = BenchmarkRunner(config).run(
+        runtime,
+        points=_read_points(args.momenta),
+    )
+    print(
+        json.dumps(
+            {
+                "sample_count": result.sample_count,
+                "wall_time_per_point": result.wall_time_per_point,
+                "evaluator_time_per_point": result.evaluator_time_per_point,
+                "relative_standard_error": (result.uncertainty.relative_standard_error),
+                "environment": dict(result.environment),
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/examples/python/copy_packaged_models.py b/pyamplicol/examples/python/copy_packaged_models.py
new file mode 100644
index 0000000000..7118cec115
--- /dev/null
+++ b/pyamplicol/examples/python/copy_packaged_models.py
@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: 0BSD
+"""Copy pyAmpliCol's wheel-owned example models into an editable workspace."""
+
+from __future__ import annotations
+
+import argparse
+from importlib import resources
+from importlib.resources.abc import Traversable
+from pathlib import Path
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "destination",
+        type=Path,
+        nargs="?",
+        default=Path("models"),
+        help="destination directory (default: ./models)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="merge into a non-empty destination without removing other files",
+    )
+    return parser
+
+
+def _copy_resource_tree(source: Traversable, destination: Path) -> None:
+    destination.mkdir(parents=True, exist_ok=True)
+    for child in source.iterdir():
+        if child.name == "__pycache__":
+            continue
+        target = destination / child.name
+        if child.is_dir():
+            _copy_resource_tree(child, target)
+        elif child.is_file():
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_bytes(child.read_bytes())
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    destination = args.destination.expanduser().resolve(strict=False)
+    if destination.exists() and not destination.is_dir():
+        raise SystemExit(f"destination is not a directory: {destination}")
+    if destination.is_dir() and any(destination.iterdir()) and not args.force:
+        raise SystemExit(
+            f"destination is not empty: {destination}; pass --force to merge"
+        )
+
+    model_assets = resources.files("pyamplicol.assets").joinpath("models")
+    if not model_assets.is_dir():
+        raise SystemExit("installed pyAmpliCol package contains no model assets")
+    _copy_resource_tree(model_assets, destination)
+    print(destination)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/examples/python/external_models.py b/pyamplicol/examples/python/external_models.py
new file mode 100644
index 0000000000..74238ca0cb
--- /dev/null
+++ b/pyamplicol/examples/python/external_models.py
@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: 0BSD
+"""Resolve serialized-JSON and trusted-UFO Standard Model sources."""
+
+from __future__ import annotations
+
+import argparse
+
+from pyamplicol import ModelSource
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("sm_json", help="Path to the serialized SM JSON model")
+    parser.add_argument("sm_ufo", help="Path to a trusted UFO model named sm")
+    parser.add_argument("--ufo-restriction", default="restrict_default.dat")
+    return parser
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    sources = {
+        "sm-json": ModelSource.from_path(args.sm_json),
+        "sm-ufo": ModelSource.from_path(
+            args.sm_ufo,
+            restriction=args.ufo_restriction,
+        ),
+    }
+    for name, source in sources.items():
+        print(f"{name}: kind={source.kind} path={source.path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/examples/python/otf_pp_zjj_warm_up.py b/pyamplicol/examples/python/otf_pp_zjj_warm_up.py
new file mode 100644
index 0000000000..b80f76fd36
--- /dev/null
+++ b/pyamplicol/examples/python/otf_pp_zjj_warm_up.py
@@ -0,0 +1,209 @@
+# SPDX-License-Identifier: 0BSD
+"""Warm and evaluate one LC flow of the packaged OTF ``p p > Z j j`` example."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from colorama import Fore, Style, just_fix_windows_console
+from prettytable import HRuleStyle, PrettyTable
+
+from pyamplicol import ColorFlow, Runtime, WarmUpResult
+from pyamplicol.reporting import ProgressSink, close_progress_sink, progress_sink
+
+WORKSPACE = Path(__file__).resolve().parents[1]
+DEFAULT_ARTIFACT = WORKSPACE / "artifacts/otf_pp_zjj"
+DEFAULT_MOMENTA = WORKSPACE / "data/pp_zjj_momenta.json"
+DEFAULT_PROCESS = "d d~ > g z g"
+
+FourMomentum = tuple[float, float, float, float]
+PhaseSpacePoint = tuple[FourMomentum, ...]
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--artifact", type=Path, default=DEFAULT_ARTIFACT)
+    parser.add_argument("--momenta", type=Path, default=DEFAULT_MOMENTA)
+    parser.add_argument("--process", default=DEFAULT_PROCESS)
+    parser.add_argument(
+        "--n-cores",
+        type=int,
+        default=None,
+        metavar="N",
+        help="warm-up construction workers (default: process output setting)",
+    )
+    parser.add_argument(
+        "--color-flow",
+        type=int,
+        default=1,
+        metavar="N",
+        help="one-based physical LC flow ordinal (default: 1)",
+    )
+    parser.add_argument(
+        "--color",
+        choices=("auto", "always", "never"),
+        default="auto",
+        help="colored summary output (default: auto)",
+    )
+    return parser
+
+
+def _one_point(path: Path) -> PhaseSpacePoint:
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, list) or len(payload) != 1:
+        raise ValueError(
+            "the explicit OTF warm-up example requires exactly one phase-space point"
+        )
+    raw_point = payload[0]
+    if not isinstance(raw_point, list) or not raw_point:
+        raise ValueError("the phase-space point must contain external momenta")
+    point: list[FourMomentum] = []
+    for raw_momentum in raw_point:
+        if not isinstance(raw_momentum, list) or len(raw_momentum) != 4:
+            raise ValueError("each external momentum must contain four components")
+        if not all(
+            isinstance(component, (int, float)) and not isinstance(component, bool)
+            for component in raw_momentum
+        ):
+            raise ValueError("momentum components must be real numbers")
+        components = tuple(float(component) for component in raw_momentum)
+        point.append((components[0], components[1], components[2], components[3]))
+    return tuple(point)
+
+
+def _warm_and_evaluate(
+    runtime: Runtime,
+    point: PhaseSpacePoint,
+    flow: ColorFlow,
+    progress: ProgressSink,
+    n_cores: int | None = None,
+) -> tuple[WarmUpResult, complex]:
+    # The structural warm-up contract is deliberately one point in native f64.
+    # Omitting ``helicities`` requests the complete physical helicity sum.
+    one_point = (point,)
+    warmed = runtime.warm_up(
+        one_point,
+        precision=16,
+        color_flows=(flow,),
+        progress=progress,
+        n_cores=n_cores,
+    )
+    values = runtime.evaluate(one_point, precision=16, color_flows=(flow,))
+    if len(values) != 1:
+        raise RuntimeError("one-point evaluation returned an unexpected result shape")
+    return warmed, complex(values[0])
+
+
+def _paint(text: str, color: str, *, enabled: bool) -> str:
+    return f"{color}{text}{Style.RESET_ALL}" if enabled else text
+
+
+def _bytes_text(value: int | None) -> str:
+    if value is None:
+        return "unavailable"
+    units = ("B", "KiB", "MiB", "GiB")
+    scaled = float(value)
+    unit = units[0]
+    for unit in units:
+        if abs(scaled) < 1024.0 or unit == units[-1]:
+            break
+        scaled /= 1024.0
+    return f"{scaled:.2f} {unit}"
+
+
+def _value_text(value: complex) -> str:
+    if value.imag == 0.0:
+        return f"{value.real:.15e}"
+    return f"{value.real:.15e}{value.imag:+.15e}j"
+
+
+def _summary(
+    *,
+    runtime: Runtime,
+    flow: ColorFlow,
+    physical_helicity_count: int,
+    warmed: WarmUpResult,
+    value: complex,
+    color: bool,
+) -> str:
+    table = PrettyTable(("field", "value"))
+    table.title = _paint("OTF LC: one flow, helicity sum", Fore.CYAN, enabled=color)
+    table.align["field"] = "l"
+    table.align["value"] = "l"
+    table.hrules = HRuleStyle.FRAME
+    status = "already retained" if warmed.already_warm else "warmed now"
+    rows = (
+        ("process", runtime.physics.process, Fore.CYAN),
+        ("precision", "f64 (16 digits)", Fore.GREEN),
+        ("selected LC flow", f"{flow.index + 1}: {flow.id}", Fore.MAGENTA),
+        ("helicities", f"sum of {physical_helicity_count}", Fore.MAGENTA),
+        ("warm-up status", status, Fore.GREEN),
+        (
+            "queries",
+            f"{warmed.warmed_query_count} new / {warmed.query_count} selected",
+            Fore.YELLOW,
+        ),
+        ("warm-up wall", f"{warmed.elapsed_seconds:.3f} s", Fore.YELLOW),
+        ("current RSS", _bytes_text(warmed.current_rss_bytes), Fore.YELLOW),
+        ("peak RSS", _bytes_text(warmed.peak_rss_bytes), Fore.YELLOW),
+        ("matrix element", _value_text(value), Fore.GREEN),
+    )
+    for field, text, shade in rows:
+        table.add_row((field, _paint(text, shade, enabled=color)))
+    return table.get_string()
+
+
+def _uses_color(mode: str, stream: object) -> bool:
+    if mode == "always":
+        return True
+    if mode == "never":
+        return False
+    return bool(getattr(stream, "isatty", lambda: False)())
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    point = _one_point(args.momenta)
+    runtime = Runtime.load(args.artifact, process=args.process)
+    physics = runtime.physics
+    if runtime.execution_mode != "on-the-fly" or physics.color_accuracy != "lc":
+        raise RuntimeError("this example requires an on-the-fly LC artifact")
+    if args.color_flow < 1 or args.color_flow > len(physics.color_flows):
+        raise ValueError(
+            f"--color-flow must be in 1..{len(physics.color_flows)} for this process"
+        )
+    flow = physics.color_flows[args.color_flow - 1]
+
+    summary_color = _uses_color(args.color, sys.stdout)
+    progress_color = _uses_color(args.color, sys.stderr)
+    if summary_color or progress_color:
+        just_fix_windows_console()
+    sink = progress_sink(
+        "auto",
+        stream=sys.stderr,
+        color=progress_color,
+    )
+    try:
+        warmed, value = _warm_and_evaluate(runtime, point, flow, sink, args.n_cores)
+    finally:
+        close_progress_sink(sink)
+
+    print(
+        _summary(
+            runtime=runtime,
+            flow=flow,
+            physical_helicity_count=len(physics.helicities),
+            warmed=warmed,
+            value=value,
+            color=summary_color,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/examples/python/runtime_evaluation.py b/pyamplicol/examples/python/runtime_evaluation.py
new file mode 100644
index 0000000000..1cadf027c0
--- /dev/null
+++ b/pyamplicol/examples/python/runtime_evaluation.py
@@ -0,0 +1,105 @@
+# SPDX-License-Identifier: 0BSD
+"""Evaluate totals and resolved components through the public Runtime facade."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+from pyamplicol import Runtime
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("artifact", type=Path)
+    parser.add_argument("momenta", type=Path)
+    parser.add_argument("--process")
+    parser.add_argument("--parameters", type=Path)
+    parser.add_argument(
+        "--set-parameter",
+        action="append",
+        default=[],
+        metavar="NAME=VALUE",
+        help="apply a direct real or complex UFO-parameter override",
+    )
+    parser.add_argument("--helicity", action="append")
+    parser.add_argument("--color-flow", action="append")
+    return parser
+
+
+def _read_json(path: Path) -> Any:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _json_complex(value: complex) -> dict[str, float]:
+    return {"real": value.real, "imag": value.imag}
+
+
+def _flatten(values: Any) -> list[complex]:
+    if isinstance(values, (list, tuple)):
+        return [item for value in values for item in _flatten(value)]
+    return [complex(values)]
+
+
+def _parameter_overrides(values: list[str]) -> dict[str, complex]:
+    result: dict[str, complex] = {}
+    for value in values:
+        name, separator, raw = value.partition("=")
+        if not separator or not name or not raw:
+            raise SystemExit(f"invalid --set-parameter value: {value!r}")
+        try:
+            result[name] = complex(raw)
+        except ValueError as error:
+            raise SystemExit(f"invalid parameter value {raw!r}") from error
+    return result
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    parameters = _read_json(args.parameters) if args.parameters else None
+    momenta = _read_json(args.momenta)
+    runtime = Runtime.load(
+        args.artifact,
+        process=args.process,
+        model_parameters=parameters,
+    )
+    if overrides := _parameter_overrides(args.set_parameter):
+        runtime.set_model_parameters(overrides)
+    selectors = {
+        "helicities": args.helicity,
+        "color_flows": args.color_flow,
+    }
+    compatibility_totals = runtime.evaluate(momenta, **selectors)
+    resolved = runtime.evaluate_resolved(momenta, **selectors)
+    resolved_totals = resolved.total()
+    if len(compatibility_totals) != len(resolved_totals) or any(
+        not math.isclose(total.real, check.real, rel_tol=1e-12, abs_tol=1e-15)
+        or not math.isclose(total.imag, check.imag, rel_tol=1e-12, abs_tol=1e-15)
+        for total, check in zip(compatibility_totals, resolved_totals, strict=True)
+    ):
+        raise RuntimeError("resolved components do not reproduce summed values")
+
+    print(
+        json.dumps(
+            {
+                "color_accuracy": resolved.color_accuracy,
+                "helicity_ids": resolved.helicity_ids,
+                "color_flow_ids": resolved.color_flow_ids,
+                "shape": list(resolved.shape),
+                "values": [_json_complex(value) for value in _flatten(resolved.values)],
+                "resolved_sum": [_json_complex(value) for value in resolved_totals],
+                "compatibility_total": [
+                    _json_complex(value) for value in compatibility_totals
+                ],
+            },
+            indent=2,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/examples/python/typed_generation.py b/pyamplicol/examples/python/typed_generation.py
new file mode 100644
index 0000000000..b2c9b86b98
--- /dev/null
+++ b/pyamplicol/examples/python/typed_generation.py
@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: 0BSD
+"""Plan or generate the external-JSON pp -> Zjj example with typed services."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from pyamplicol import Generator, ModelSource, ProcessRequest, ProcessSet
+from pyamplicol.config import resolve_config
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("output", type=Path)
+    parser.add_argument(
+        "process",
+        nargs="*",
+        default=("p p > Z j j",),
+        help="quoted process expressions (default: 'p p > Z j j')",
+    )
+    parser.add_argument(
+        "--model",
+        default="models/json/sm/sm.json",
+        help="built-in-sm, a trusted UFO directory, or a model JSON path",
+    )
+    parser.add_argument("--restriction")
+    parser.add_argument(
+        "--multiparticle",
+        action="append",
+        default=["p=d,d~,g", "j=d,d~,g"],
+        metavar="NAME=ITEM[,ITEM...]",
+    )
+    parser.add_argument("--flavor-scheme", type=int, default=2)
+    parser.add_argument("--max-quark-lines", type=int, default=2)
+    parser.add_argument("--color-accuracy", choices=("lc", "nlc", "full"), default="lc")
+    parser.add_argument(
+        "--mode",
+        choices=("error", "append", "replace"),
+        default="error",
+    )
+    parser.add_argument("--plan-only", action="store_true")
+    return parser
+
+
+def _multiparticles(values: list[str]) -> dict[str, list[str]]:
+    result: dict[str, list[str]] = {}
+    for value in values:
+        name, separator, members = value.partition("=")
+        entries = [member.strip() for member in members.split(",") if member.strip()]
+        if not separator or not name or not entries:
+            raise SystemExit(f"invalid --multiparticle value: {value!r}")
+        result[name] = entries
+    return result
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    model_config: dict[str, object] = {"source": args.model}
+    if args.restriction is not None:
+        model_config["restriction"] = args.restriction
+    card = {
+        "schema_version": 1,
+        "action": "generate",
+        "model": model_config,
+        "process": {
+            "entries": [{"expression": expression} for expression in args.process],
+            "multiparticles": _multiparticles(args.multiparticle),
+            "flavor_scheme": args.flavor_scheme,
+            "max_quark_lines": args.max_quark_lines,
+        },
+        "color": {"accuracy": args.color_accuracy},
+        "generation": {"output": args.output, "mode": args.mode},
+        # Raw JSON/UFO model IR has no prepared recurrence-kernel bundle.
+        # Match the primary card by building process-local compiled JIT evaluators.
+        "evaluator": {
+            "backend": "jit",
+            "execution_mode": "compiled",
+            "jit": {"compress": True},
+        },
+    }
+    resolution = resolve_config(card)
+    config = resolution.effective
+    processes = ProcessSet(
+        tuple(
+            ProcessRequest.parse(entry.expression, name=entry.name)
+            for entry in config.process.entries
+        )
+    )
+    model_source = (
+        ModelSource.built_in_sm()
+        if args.model == "built-in-sm"
+        else ModelSource.from_path(
+            args.model,
+            restriction=args.restriction,
+            simplify=config.model.simplify,
+        )
+    )
+    model = model_source.compile(use_cache=config.model.cache)
+
+    generator = Generator(resolution)
+    plan = generator.plan(processes, model=model)
+    for process in plan.concrete_processes:
+        print(f"{process.name}: {process.expression}")
+    if args.plan_only:
+        return 0
+
+    result = generator.generate(
+        processes,
+        config.generation.output or args.output,
+        model=model,
+        mode=config.generation.mode,
+    )
+    print(result.output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/examples/qq_z6g_compiled_jit_o3.toml b/pyamplicol/examples/qq_z6g_compiled_jit_o3.toml
new file mode 100644
index 0000000000..b92258e0f2
--- /dev/null
+++ b/pyamplicol/examples/qq_z6g_compiled_jit_o3.toml
@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: 0BSD
+# q q~ > Z + 6g with process-local compiled-DAG JIT O3 execution.
+#
+#   pyamplicol generate --card qq_z6g_compiled_jit_o3.toml
+#   pyamplicol profile --card qq_z6g_compiled_jit_o3.toml
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+cache = true
+
+[process]
+entries = [
+  { expression = "u u~ > Z g g g g g g", name = "uubar_Z_6g_compiled" },
+]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/qq_z6g_compiled_jit_o3"
+mode = "error"
+workers = 1
+emit_api_bundle = true
+
+[generation.validation]
+enabled = true
+samples = 3
+seed = 12345
+relative_tolerance = 1e-12
+absolute_tolerance = 1e-300
+post_build_validation = false
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
+batch_size = 64
+output_chunk_size = 512
+
+[evaluator.jit]
+optimization_level = 3
+compress = false
+
+[evaluation]
+artifact = "artifacts/qq_z6g_compiled_jit_o3"
+process = "u u~ > Z g g g g g g"
+precision = 16
+
+[benchmark]
+target_runtime = 5.0
+batch_size = 64
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+color_flow_ids = ["1"]
+
+[output]
+format = "human"
+color = "auto"
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/qq_z6g_eager_jit_o2.toml b/pyamplicol/examples/qq_z6g_eager_jit_o2.toml
new file mode 100644
index 0000000000..57d5043e99
--- /dev/null
+++ b/pyamplicol/examples/qq_z6g_eager_jit_o2.toml
@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: 0BSD
+# q q~ > Z + 6g with eager-DAG execution and prepared JIT O2 kernels.
+#
+#   pyamplicol generate --card qq_z6g_eager_jit_o2.toml
+#   pyamplicol profile --card qq_z6g_eager_jit_o2.toml
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+cache = true
+
+[process]
+entries = [
+  { expression = "u u~ > Z g g g g g g", name = "uubar_Z_6g_eager" },
+]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/qq_z6g_eager_jit_o2"
+mode = "error"
+workers = 1
+emit_api_bundle = true
+
+[generation.validation]
+enabled = true
+samples = 3
+seed = 12345
+relative_tolerance = 1e-12
+absolute_tolerance = 1e-300
+post_build_validation = false
+
+[evaluator]
+backend = "jit"
+execution_mode = "eager"
+batch_size = 64
+output_chunk_size = 512
+
+[evaluator.jit]
+optimization_level = 2
+compress = false
+
+[evaluator.eager]
+point_tile_size = 1024
+workspace_mib = 256
+
+[evaluation]
+artifact = "artifacts/qq_z6g_eager_jit_o2"
+process = "u u~ > Z g g g g g g"
+precision = 16
+
+[benchmark]
+target_runtime = 5.0
+batch_size = 64
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+color_flow_ids = ["1"]
+
+[output]
+format = "human"
+color = "auto"
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/examples/qq_z6g_recurrence_jit_o2.toml b/pyamplicol/examples/qq_z6g_recurrence_jit_o2.toml
new file mode 100644
index 0000000000..86c521cd94
--- /dev/null
+++ b/pyamplicol/examples/qq_z6g_recurrence_jit_o2.toml
@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: 0BSD
+# q q~ > Z + 6g with the default recurrence schedule and prepared JIT O2 kernels.
+#
+#   pyamplicol generate --card qq_z6g_recurrence_jit_o2.toml
+#   pyamplicol profile --card qq_z6g_recurrence_jit_o2.toml
+
+schema_version = 1
+action = "generate"
+
+[model]
+source = "built-in-sm"
+cache = true
+
+[process]
+entries = [
+  { expression = "u u~ > Z g g g g g g", name = "uubar_Z_6g_recurrence" },
+]
+
+[color]
+accuracy = "lc"
+
+[generation]
+output = "artifacts/qq_z6g_recurrence_jit_o2"
+mode = "error"
+workers = 1
+emit_api_bundle = true
+
+[generation.validation]
+enabled = true
+samples = 3
+seed = 12345
+relative_tolerance = 1e-12
+absolute_tolerance = 1e-300
+post_build_validation = false
+
+[evaluator]
+backend = "jit"
+execution_mode = "recurrence"
+batch_size = 64
+output_chunk_size = 512
+
+[evaluator.jit]
+optimization_level = 2
+compress = false
+
+[evaluator.recurrence]
+point_tile_size = 1024
+workspace_mib = 256
+
+[evaluation]
+artifact = "artifacts/qq_z6g_recurrence_jit_o2"
+process = "u u~ > Z g g g g g g"
+precision = 16
+
+[benchmark]
+target_runtime = 5.0
+batch_size = 64
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+color_flow_ids = ["1"]
+
+[output]
+format = "human"
+color = "auto"
+progress = "auto"
+log_level = "info"
diff --git a/pyamplicol/flake.lock b/pyamplicol/flake.lock
new file mode 100644
index 0000000000..33a5783d09
--- /dev/null
+++ b/pyamplicol/flake.lock
@@ -0,0 +1,48 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1784120854,
+        "narHash": "sha256-KesHgItiZPgGX740axSiQLcIQ8D24MDqNpkKYWIek8k=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "753cc8a3a87467296ddd1fa93f0cc3e81120ee46",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1784216271,
+        "narHash": "sha256-bvaxxdk7mmMQ88AuXQGTUtk+PcUujHpgxqpryqTWvTU=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "1f69c7203034a4a974d7a4eac0f19b54af30804d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/pyamplicol/flake.nix b/pyamplicol/flake.nix
new file mode 100644
index 0000000000..48494f0259
--- /dev/null
+++ b/pyamplicol/flake.nix
@@ -0,0 +1,134 @@
+# SPDX-License-Identifier: 0BSD
+
+{
+  description = "pyAmpliCol contributor development environment";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    rust-overlay = {
+      url = "github:oxalica/rust-overlay";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+  };
+
+  outputs =
+    { nixpkgs, rust-overlay, ... }:
+    let
+      systems = [
+        "aarch64-darwin"
+        "aarch64-linux"
+        "x86_64-linux"
+      ];
+      forAllSystems = nixpkgs.lib.genAttrs systems;
+    in
+    {
+      devShells = forAllSystems (
+        system:
+        let
+          pkgs = import nixpkgs {
+            inherit system;
+            overlays = [ (import rust-overlay) ];
+          };
+          inherit (pkgs) lib stdenv;
+
+          rustToolchain = pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
+
+          # Keep the generic PEP 517 frontend for `just wheel`. Project, test,
+          # and candidate packages belong to the lock-controlled contributor venv.
+          python = pkgs.python311.withPackages (
+            pythonPackages: with pythonPackages; [
+              build
+              pip
+              setuptools
+              wheel
+            ]
+          );
+
+          nativeLibraries = with pkgs; [
+            gmp
+            libffi
+            libmpc
+            mpfr
+            openssl
+            stdenv.cc.cc.lib
+            zlib
+          ];
+
+          platformTools =
+            lib.optionals stdenv.isLinux [
+              pkgs.binutils
+              pkgs.lsof
+              pkgs.patchelf
+              pkgs.procps
+            ]
+            ++ lib.optionals stdenv.isDarwin [
+              pkgs.darwin.cctools
+              pkgs.libiconv
+            ];
+        in
+        {
+          default = pkgs.mkShell {
+            packages =
+              (with pkgs; [
+                bash
+                cacert
+                cmake
+                coreutils
+                curl
+                diffutils
+                file
+                findutils
+                gh
+                ghostscript
+                git
+                gnumake
+                gnugrep
+                gnused
+                gnutar
+                gfortran
+                gzip
+                just
+                jq
+                m4
+                ninja
+                openssh
+                patch
+                pkg-config
+                poppler-utils
+                python
+                ripgrep
+                rustToolchain
+                stdenv.cc
+                texliveFull
+                unzip
+                which
+                xz
+                zip
+                zstd
+              ])
+              ++ platformTools;
+
+            buildInputs = nativeLibraries;
+
+            PYAMPLICOL_DEV_PYTHON = ".venv/bin/python";
+            PIP_DISABLE_PIP_VERSION_CHECK = "1";
+            PYTHONNOUSERSITE = "1";
+
+            # These paths support native wheels and generated SDK consumers in
+            # a Nix shell without changing release-artifact link metadata.
+            LD_LIBRARY_PATH = lib.optionalString stdenv.isLinux (
+              lib.makeLibraryPath nativeLibraries
+            );
+            NIX_LD_LIBRARY_PATH = lib.optionalString stdenv.isLinux (
+              lib.makeLibraryPath nativeLibraries
+            );
+
+            shellHook = ''
+              echo "pyAmpliCol developer shell (Python 3.11, Rust 1.97.1, native SDK, TeX)"
+              echo "Run 'just dev-install' to create the pinned contributor environment."
+            '';
+          };
+        }
+      );
+    };
+}
diff --git a/pyamplicol/install.py b/pyamplicol/install.py
new file mode 100644
index 0000000000..40b82b2bb0
--- /dev/null
+++ b/pyamplicol/install.py
@@ -0,0 +1,479 @@
+#!/usr/bin/env python3
+"""Install pyamplicol either using pre-compiled binaries or built from source.
+
+The pre-compiled PyPI wheel (--bin) is only offered/defaulted-to in an
+official MadGraph release tarball, where it is guaranteed to match the
+bundled source; a plain git checkout always builds from source.
+
+Interactive usage (no arguments):  python install.py
+Non-interactive examples:
+  python install.py --bin
+  python install.py --source -j 8
+  python install.py --source --clean          # rebuild from scratch
+
+By default everything goes into install/ next to this script, so the active
+Python environment is left untouched. The source build needs a Rust
+toolchain: the version pinned in rust-toolchain.toml is taken from rustup
+when available, otherwise a project-local rustup is installed into build/.
+
+Rebuilds reuse the Cargo build tree in build/ and are therefore incremental.
+--clean deletes build/ and install/ first; the saved settings survive it.
+
+The prepared-model packs shipped in the package are taken from the archive
+attached to the MadGraph release (the matching one, else the latest). When
+they are stale for this source tree, or cannot be downloaded, they are
+regenerated locally (one extra build).
+"""
+
+import argparse
+import contextlib
+import json
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tempfile
+import tomllib
+import urllib.request
+from pathlib import Path
+
+SCRIPT_DIR = Path(__file__).parent.resolve()
+INSTALL_DIR = SCRIPT_DIR / "install"
+BUILD_DIR = SCRIPT_DIR / "build"
+SETTINGS_FILE = SCRIPT_DIR / "install_settings.json"
+RUST_DIR = BUILD_DIR / "rust"
+CACHE_DIR = BUILD_DIR / "cache"
+PREPARED_MODELS_DIR = BUILD_DIR / "prepared-models"
+RELEASE_TOOLS = SCRIPT_DIR / "tools" / "release"
+
+PACKAGE_NAME = "pyamplicol"
+RUSTUP_INIT_URL = "https://sh.rustup.rs"
+
+
+# Interactive helpers (same behaviour as madspace/install.py: prompts go
+# through MadGraph's cmd.ask when importable, else input()).
+
+_NONINTERACTIVE = (not sys.stdin.isatty()) or any(
+    a in ("-y", "--yes") for a in sys.argv[1:]
+)
+
+
+def _set_noninteractive(flag: bool) -> None:
+    global _NONINTERACTIVE
+    if flag:
+        _NONINTERACTIVE = True
+
+
+def ask_yes_no(prompt: str, default: bool = True) -> bool:
+    default_s = "y" if default else "n"
+    answer = None
+    try:
+        from madgraph.interface.extended_cmd import Cmd
+
+        answer = Cmd().ask(
+            prompt, default_s, choices=["y", "n"], timeout=0, force=_NONINTERACTIVE
+        )
+    except Exception:
+        if not _NONINTERACTIVE:
+            with contextlib.suppress(EOFError):
+                answer = input(f"{prompt} [{default_s}]: ").strip()
+    answer = (answer or default_s).strip().lower()
+    return answer in ("y", "yes") if answer in ("y", "yes", "n", "no") else default
+
+
+# Command execution
+
+
+def run(cmd: list, env: dict | None = None, cwd: Path = SCRIPT_DIR) -> None:
+    display = " ".join(str(c) for c in cmd)
+    print(f"\n$ {display}\n", flush=True)
+    result = subprocess.run(cmd, cwd=cwd, env=env)
+    if result.returncode != 0:
+        sys.exit(result.returncode)
+
+
+def default_jobs() -> int:
+    try:
+        return len(os.sched_getaffinity(0))
+    except AttributeError:
+        return os.cpu_count() or 1
+
+
+# Versions and release information
+
+
+def _pyamplicol_version() -> str:
+    """The MadGraph version, which pyamplicol is released in lockstep with."""
+    for line in (SCRIPT_DIR.parent / "VERSION").read_text().splitlines():
+        name, _, value = line.partition("=")
+        if name.strip() == "version":
+            return value.strip()
+    raise RuntimeError("no 'version' line in the MadGraph VERSION file")
+
+
+def _release_info() -> dict[str, str]:
+    """Parse input/.release, written into MadGraph release tarballs."""
+    marker = SCRIPT_DIR.parent / "input" / ".release"
+    if not marker.is_file():
+        return {}
+    info = {}
+    for line in marker.read_text().splitlines():
+        name, _, value = line.partition("=")
+        info[name.strip()] = value.strip()
+    return info
+
+
+def _release_wheel_available() -> bool:
+    """Whether input/.release lists a pyamplicol wheel for this platform.
+
+    The wheels are abi3 (cp311 and newer), so only the platform matters.
+    """
+    wheels = [
+        name
+        for name in _release_info().get("wheels", "").split(",")
+        if name.startswith(f"{PACKAGE_NAME}-")
+    ]
+    system, machine = platform.system(), platform.machine()
+    if system == "Linux" and machine in ("x86_64", "AMD64"):
+        platform_tags = ("manylinux", "x86_64")
+    elif system == "Darwin" and machine in ("arm64", "aarch64"):
+        platform_tags = ("macosx", "arm64")
+    elif system == "Darwin" and machine == "x86_64":
+        platform_tags = ("macosx", "x86_64")
+    else:
+        return False
+    return any(all(tag in name for tag in platform_tags) for name in wheels)
+
+
+def load_settings() -> dict:
+    try:
+        with open(SETTINGS_FILE) as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+
+def save_settings(settings: dict) -> None:
+    with open(SETTINGS_FILE, "w") as f:
+        json.dump(settings, f, indent=2)
+
+
+def clean_install_dirs() -> None:
+    for target in (BUILD_DIR, INSTALL_DIR):
+        if target.is_dir():
+            shutil.rmtree(target)
+            print(f"Removed {target}")
+
+
+# Rust toolchain
+
+
+def _pinned_toolchain() -> str:
+    with open(SCRIPT_DIR / "rust-toolchain.toml", "rb") as f:
+        return tomllib.load(f)["toolchain"]["channel"]
+
+
+def setup_rust(env: dict) -> dict:
+    """Make the pinned toolchain available through rustup and return env.
+
+    A rustup on PATH is used as is; otherwise a project-local one is installed
+    into build/rust, leaving ~/.rustup and ~/.cargo alone.
+    """
+    toolchain = _pinned_toolchain()
+    local_bin = RUST_DIR / "cargo" / "bin"
+    if (local_bin / "rustup").is_file():
+        rustup = local_bin / "rustup"
+    elif shutil.which("rustup", path=env.get("PATH")):
+        rustup = Path(shutil.which("rustup", path=env.get("PATH")))
+    else:
+        rustup = None
+
+    # The build sets its own CARGO_HOME; rustup itself needs the local one.
+    rust_env = env
+    if rustup is None or rustup.parent == local_bin:
+        env["RUSTUP_HOME"] = str(RUST_DIR / "rustup")
+        env["PATH"] = os.pathsep.join([str(local_bin), env.get("PATH", "")])
+        rust_env = dict(
+            env, CARGO_HOME=str(RUST_DIR / "cargo"), RUSTUP_INIT_SKIP_PATH_CHECK="yes"
+        )
+    if rustup is None:
+        print(f"\nNo rustup found; installing Rust {toolchain} into {RUST_DIR}")
+        RUST_DIR.mkdir(parents=True, exist_ok=True)
+        script = RUST_DIR / "rustup-init.sh"
+        with urllib.request.urlopen(RUSTUP_INIT_URL, timeout=120) as response:
+            script.write_bytes(response.read())
+        run(
+            [
+                "sh",
+                str(script),
+                "-y",
+                "--no-modify-path",
+                "--profile",
+                "minimal",
+                "--default-toolchain",
+                toolchain,
+            ],
+            env=rust_env,
+        )
+    else:
+        run(
+            [str(rustup), "toolchain", "install", toolchain, "--profile", "minimal"],
+            env=rust_env,
+        )
+    return env
+
+
+# Build
+
+
+def install_build_deps(env: dict, system: bool) -> dict:
+    with open(SCRIPT_DIR / "pyproject.toml", "rb") as f:
+        requires = tomllib.load(f)["build-system"]["requires"]
+    print("\nInstalling build dependencies...")
+    cmd = [sys.executable, "-m", "pip", "install", "--upgrade", *requires]
+    if not system:
+        cmd.append(f"--target={INSTALL_DIR}")
+    run(cmd, env=env)
+    if not system:
+        env["PYTHONPATH"] = os.pathsep.join(
+            p for p in (str(INSTALL_DIR), env.get("PYTHONPATH")) if p
+        )
+        # maturin's console script, needed by the build backend
+        env["PATH"] = os.pathsep.join([str(INSTALL_DIR / "bin"), env.get("PATH", "")])
+    return env
+
+
+def build_environment(jobs: int | None) -> dict:
+    env = os.environ.copy()
+    env["PYAMPLICOL_LOCAL_BUILD"] = "1"
+    env["PYAMPLICOL_BUILD_MODE"] = "release"
+    env["PYAMPLICOL_BUILD_CACHE_ROOT"] = str(CACHE_DIR)
+    jobs = default_jobs() if jobs is None or jobs <= 0 else jobs
+    env["PYAMPLICOL_BUILD_JOBS"] = str(jobs)
+    print(f"Compiling with {jobs} parallel job(s) (-j to change).")
+    return env
+
+
+def _prepared_models_stale(env: dict) -> str | None:
+    """Validate the unpacked prepared models against this source tree.
+
+    Returns None when they are usable, else the reason they are not.
+    """
+    check = (
+        "import sys; from pathlib import Path; "
+        f"sys.path.insert(0, {str(SCRIPT_DIR / 'build_backend')!r}); "
+        "from prepared_models import stage_packaged_prepared_models; "
+        f"stage_packaged_prepared_models(Path({str(SCRIPT_DIR)!r}), 'release')"
+    )
+    result = subprocess.run(
+        [sys.executable, "-c", check], env=env, capture_output=True, text=True
+    )
+    if result.returncode == 0:
+        return None
+    lines = (result.stderr or result.stdout).strip().splitlines()
+    return lines[-1] if lines else "validation failed"
+
+
+def fetch_prepared_models(env: dict) -> bool:
+    """Download and unpack the release archive; True if the packs are usable."""
+    archive_tool = RELEASE_TOOLS / "prepared_models_archive.py"
+    result = subprocess.run(
+        [
+            sys.executable,
+            str(archive_tool),
+            "fetch",
+            "--version",
+            _pyamplicol_version(),
+        ],
+        env=env,
+    )
+    if result.returncode != 0:
+        print("Could not download the prepared-model archive.")
+        return False
+    reason = _prepared_models_stale(env)
+    if reason is not None:
+        print(f"The released prepared models do not match this source tree: {reason}")
+        return False
+    return True
+
+
+def regenerate_prepared_models(env: dict) -> None:
+    """Build a bootstrap wheel and produce the prepared models with it."""
+    print("\nRegenerating the prepared models locally (one extra build)...")
+    PREPARED_MODELS_DIR.mkdir(parents=True, exist_ok=True)
+    run(
+        [
+            sys.executable,
+            str(RELEASE_TOOLS / "prepared_models_archive.py"),
+            "regenerate",
+            "--work",
+            str(PREPARED_MODELS_DIR),
+        ],
+        env=env,
+    )
+
+
+def check_license(target: Path | None) -> None:
+    """Fail unless pyamplicol's Symbolica library key is accepted."""
+    env = os.environ.copy()
+    env.pop("SYMBOLICA_LICENSE", None)
+    if target is not None:
+        env["PYTHONPATH"] = str(target)
+    code = (
+        "import json, pyamplicol; "
+        "from pyamplicol.licensing import detect_symbolica_license; "
+        "print(json.dumps({'file': pyamplicol.__file__, "
+        "'licensed': detect_symbolica_license(suggest=False).licensed}))"
+    )
+    # Run outside the MadGraph tree, where pyamplicol/ is a plain directory.
+    with tempfile.TemporaryDirectory() as cwd:
+        result = subprocess.run(
+            [sys.executable, "-I" if target is None else "-s", "-c", code],
+            cwd=cwd,
+            env=env,
+            capture_output=True,
+            text=True,
+        )
+    try:
+        info = json.loads(result.stdout.strip().splitlines()[-1])
+    except (IndexError, ValueError):
+        print(result.stdout + result.stderr)
+        sys.exit("ERROR: the installed pyamplicol cannot be imported.")
+    if target is not None and not Path(info["file"]).resolve().is_relative_to(target):
+        sys.exit(f"ERROR: imported pyamplicol from {info['file']}, not from {target}.")
+    if not info["licensed"]:
+        sys.exit(
+            "ERROR: Symbolica does not accept pyamplicol's library license key. "
+            "Model generation would run in Symbolica's restricted mode."
+        )
+    print("Symbolica license: pyamplicol library key accepted.")
+
+
+# Main
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    mode = parser.add_mutually_exclusive_group()
+    mode.add_argument(
+        "--bin",
+        action="store_true",
+        help="Install the pre-compiled package (default in release tarballs).",
+    )
+    mode.add_argument(
+        "--source", action="store_true", help="Build and install from source."
+    )
+    parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Non-interactive, no prompts: reuse the previous install mode, else "
+        "the default. Combine with --source/--bin to force the install mode.",
+    )
+    parser.add_argument(
+        "-j",
+        "--jobs",
+        type=int,
+        default=None,
+        metavar="N",
+        help="Number of parallel compilation jobs for the source build "
+        f"(default: every available core, {default_jobs()} here). MG5's "
+        "'nb_core' option is forwarded here by 'install pyamplicol'.",
+    )
+    parser.add_argument(
+        "--system",
+        action="store_true",
+        help="Install into the active Python environment instead of install/.",
+    )
+    parser.add_argument(
+        "--clean",
+        action="store_true",
+        help="Delete build/ and install/ first, for a rebuild from scratch. "
+        "The saved settings are kept.",
+    )
+    parser.add_argument(
+        "--build-models",
+        action="store_true",
+        help="Regenerate the prepared models locally instead of downloading them.",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = build_parser().parse_args(argv)
+    _set_noninteractive(args.yes)
+    saved = load_settings()
+    if args.clean:
+        clean_install_dirs()
+
+    release_version = _release_info().get("version")
+    is_release = release_version == _pyamplicol_version()
+    bin_available = is_release and _release_wheel_available()
+
+    if args.bin:
+        if not bin_available:
+            print(
+                "WARNING: no pyamplicol wheel was published for this platform; "
+                "--bin will likely fail."
+            )
+        from_source = False
+    elif args.source:
+        from_source = True
+    elif args.yes:
+        from_source = (
+            saved.get("mode", "bin" if bin_available else "source") == "source"
+        )
+    else:
+        print("Welcome to the pyAmpliCol installer")
+        from_source = not (
+            bin_available
+            and ask_yes_no(
+                "Install pre-compiled package? (recommended)",
+                default=saved.get("mode", "bin") != "source",
+            )
+        )
+
+    target = None if args.system else INSTALL_DIR
+    if not from_source:
+        cmd = [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            f"{PACKAGE_NAME}=={_pyamplicol_version()}",
+        ]
+        if target is not None:
+            cmd.append(f"--target={target}")
+        run(cmd)
+        save_settings({"mode": "bin"})
+    else:
+        env = build_environment(args.jobs)
+        env = setup_rust(env)
+        env = install_build_deps(env, args.system)
+        if args.build_models or not fetch_prepared_models(env):
+            regenerate_prepared_models(env)
+        cmd = [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            "--upgrade",
+            "--no-build-isolation",
+            # A wheel for this host only; manylinux tags need a manylinux container.
+            "--config-settings=pyamplicol.host-wheel=true",
+            ".",
+        ]
+        if target is not None:
+            cmd.append(f"--target={target}")
+        run(cmd, env=env)
+        save_settings({"mode": "source"})
+
+    check_license(target)
+    print(f"\nInstalled to: {target}" if target else "\nInstalled system-wide.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pyamplicol/justfile b/pyamplicol/justfile
new file mode 100644
index 0000000000..048d34f0c5
--- /dev/null
+++ b/pyamplicol/justfile
@@ -0,0 +1,191 @@
+set shell := ["bash", "-euo", "pipefail", "-c"]
+
+python := env_var_or_default("PYTHON", "python3")
+dev_python := env_var_or_default("PYAMPLICOL_DEV_PYTHON", ".venv/bin/python")
+build_mode := env_var_or_default("PYAMPLICOL_BUILD_MODE", "release")
+eager_builtin_pack := env_var_or_default("PYAMPLICOL_EAGER_BUILTIN_PACK", ".artifacts/eager-models/builtin-sm-jit-o3.pyamplicol-model")
+eager_ufo_pack := env_var_or_default("PYAMPLICOL_EAGER_UFO_SM_PACK", ".artifacts/eager-models/ufo-sm-jit-o3.pyamplicol-model")
+eager_ufo_source := env_var_or_default("PYAMPLICOL_EAGER_UFO_SM_SOURCE", "src/pyamplicol/assets/models/json/sm/sm.json")
+dev_cache := ".artifacts/dev-install"
+fft_performance_run_id := env_var_or_default("PYAMPLICOL_FFT_PERFORMANCE_RUN_ID", "manual")
+
+default:
+    @just --list
+
+_source-checkout:
+    @if ! git ls-files --error-unmatch pyproject.toml >/dev/null 2>&1 || [[ ! -f dependencies/contributor-lock.toml || ! -f dependencies/install_dependencies.py ]]; then \
+        printf '%s\n' "error: this command requires a full pyAmpliCol Git source checkout; contributor commands are unavailable from a release source distribution" >&2; \
+        exit 1; \
+    fi
+
+build:
+    PYAMPLICOL_BUILD_MODE={{build_mode}} {{python}} -m build --wheel
+
+typing:
+    PYTHONPATH="$PWD/src" {{python}} -m ruff check tools/typing tests/typing
+    PYTHONPATH="$PWD/src" {{python}} tools/typing/check_public_typing.py
+    PYTHONPATH="$PWD/src" {{python}} -m pytest tests/typing/test_typing_gate.py -q
+
+dependency-gate:
+    @if [ "{{build_mode}}" = candidate ]; then \
+        {{python}} tools/release/check_dependencies.py --candidate; \
+    else \
+        {{python}} tools/release/check_dependencies.py; \
+    fi
+
+python-unit:
+    PYTHONPATH="$PWD/src" {{python}} -m pytest tests/unit -q
+
+python-release:
+    PYTHONPATH="$PWD/src" {{python}} -m pytest tests/release -q
+
+python-integration:
+    # The restricted child needs a parent that has not imported Symbolica.
+    PYTHONPATH="$PWD/src" PYAMPLICOL_REQUIRE_NATIVE_TESTS=1 {{python}} -m pytest tests/integration/test_spenso_restricted_mode.py -q
+    PYTHONPATH="$PWD/src" PYAMPLICOL_REQUIRE_NATIVE_TESTS=1 {{python}} -m pytest tests/integration --ignore=tests/integration/test_spenso_restricted_mode.py -q
+
+# Focused compiler regressions only; no pyAmpliCol/Symbolica build is required.
+# Defaults to the release-lock SymJIT version; select a checkout with
+# PYAMPLICOL_SYMJIT_SOURCE=/absolute/path/to/symjit.
+symjit-regressions:
+    PYAMPLICOL_RUN_SYMJIT_REGRESSIONS=1 {{python}} -m pytest tests/integration/test_symjit_upstream_regressions.py -q
+
+python-physics:
+    PYTHONPATH="$PWD/src" PYAMPLICOL_REQUIRE_NATIVE_TESTS=1 {{python}} -m pytest tests/integration/test_schema_v3_generation_runtime.py tests/unit/test_reference_fixture_v2.py tests/unit/test_tracked_reference_fixture_v2.py tests/unit/test_color_contraction_safety.py -q
+
+# Explicit, fail-fast numerical authority gate. This is intentionally excluded
+# from the default suite because it generates fifteen catalog ProcessSets plus
+# four separate full-colour extra artifacts.
+numerical-acceptance: _source-checkout
+    PYTHONPATH="$PWD/src" PYAMPLICOL_RUN_NUMERICAL_ACCEPTANCE=1 PYAMPLICOL_REQUIRE_NATIVE_TESTS=1 {{dev_python}} tools/ci/memory_watchdog.py --limit-gib 30 -- {{dev_python}} -m pytest tests/integration/test_numerical_acceptance.py -q -x
+
+# Dedicated FFT process-table parity and frozen-MadGraph replay.
+# This expensive gate is absent from every default CI and release aggregate.
+fft-numerical-acceptance: _source-checkout
+    mkdir -p .artifacts/fft-acceptance-env/tmp .artifacts/fft-acceptance-env/cargo-home .artifacts/fft-acceptance-env/cargo-target .artifacts/fft-acceptance-env/pip-cache .artifacts/fft-acceptance-env/xdg-cache .artifacts/fft-acceptance-env/python-cache .artifacts/fft-numerical-acceptance
+    TMPDIR="$PWD/.artifacts/fft-acceptance-env/tmp" CARGO_HOME="$PWD/.artifacts/fft-acceptance-env/cargo-home" CARGO_TARGET_DIR="$PWD/.artifacts/fft-acceptance-env/cargo-target" CARGO_NET_OFFLINE=true PIP_CACHE_DIR="$PWD/.artifacts/fft-acceptance-env/pip-cache" PIP_NO_INDEX=1 XDG_CACHE_HOME="$PWD/.artifacts/fft-acceptance-env/xdg-cache" PYTHONPYCACHEPREFIX="$PWD/.artifacts/fft-acceptance-env/python-cache" PYTHONPATH="$PWD/src" PYAMPLICOL_REQUIRE_NATIVE_TESTS=1 {{dev_python}} tools/ci/memory_watchdog.py --limit-gib 30 -- {{dev_python}} tools/developer/fft_numerical_acceptance.py --output-root "$PWD/.artifacts/fft-numerical-acceptance"
+
+# Native same-host pure-gluon timing, RSS, and cold-to-ready comparison. Prepare
+# its reference with `just dev-install --with-reference-fft`; this gate is
+# deliberately excluded from default CI/release runs.
+fft-performance-acceptance: _source-checkout
+    mkdir -p .artifacts/fft-performance/env/tmp .artifacts/fft-performance/env/cargo-home .artifacts/fft-performance/env/cargo-target .artifacts/fft-performance/env/pip-cache .artifacts/fft-performance/env/xdg-cache .artifacts/fft-performance/env/python-cache
+    TMPDIR="$PWD/.artifacts/fft-performance/env/tmp" CARGO_HOME="$PWD/.artifacts/fft-performance/env/cargo-home" CARGO_TARGET_DIR="$PWD/.artifacts/fft-performance/env/cargo-target" CARGO_NET_OFFLINE=true PIP_CACHE_DIR="$PWD/.artifacts/fft-performance/env/pip-cache" PIP_NO_INDEX=1 XDG_CACHE_HOME="$PWD/.artifacts/fft-performance/env/xdg-cache" PYTHONPYCACHEPREFIX="$PWD/.artifacts/fft-performance/env/python-cache" PYTHONPATH="$PWD/src" PYAMPLICOL_REQUIRE_NATIVE_TESTS=1 {{dev_python}} tools/ci/memory_watchdog.py --limit-gib 30 -- {{dev_python}} tools/developer/fft_gluon_performance_acceptance.py --include-optional --run-id "{{fft_performance_run_id}}"
+
+# Reuse a current staged runtime, or build through the real backend and stage
+# ignored native runtime/SDK resources for source-tree tests.
+source-runtime:
+    PYAMPLICOL_BUILD_MODE={{build_mode}} {{python}} tools/developer/prepare_source_runtime.py --reuse-current
+
+# Developer-only independent Fortran oracle. Prepare its checkout with
+# `just dev-install --with-legacy-amplicol` first.
+legacy-physics: _source-checkout
+    {{python}} tools/developer/legacy_amplicol.py --jobs 5
+
+legacy-physics-verify: _source-checkout
+    {{python}} tools/developer/legacy_amplicol.py --fixture tests/fixtures/reference/physics-v2.json --jobs 5 --check-output tests/fixtures/reference/legacy-fortran-v2.json
+
+# Release-facing numerical comparison against the pinned independent Fortran
+# implementation. The CI job additionally applies a 30 GiB process limit.
+independent-physics-oracle: _source-checkout
+    {{python}} tools/developer/legacy_amplicol.py --prepare-checkout --fixture tests/fixtures/reference/physics-v2.json --jobs 2 >/dev/null
+
+installed-smoke:
+    PYTHONPATH="$PWD/src" {{python}} -m pyamplicol.selftest
+    PYTHONPATH="$PWD/src" {{python}} -m pyamplicol self-test --json
+    PYTHONPATH="$PWD/src" {{python}} -m pyamplicol examples list --json
+    PYTHONPATH="$PWD/src" PYAMPLICOL_EXAMPLE_CACHE="$PWD/.artifacts/source-gate-example" {{python}} -m pyamplicol examples run builtin_sm_lc --set generation.mode=replace --json
+
+rust-check:
+    {{python}} tools/release/run_cargo.py --mode {{build_mode}} -- fmt --all --check
+    {{python}} tools/release/run_cargo.py --mode {{build_mode}} -- clippy --workspace --all-targets --locked
+
+rust-test:
+    {{python}} tools/release/run_cargo.py --mode {{build_mode}} -- test --workspace --locked
+    {{python}} tools/release/run_cargo.py --mode {{build_mode}} -- test --locked -p rusticol-core --no-default-features --features f64-compiled native_role_exports_load_and_remain_callable_while_owners_move
+
+# Complete source gate used before any release artifact is retained.
+source-gate:
+    just dependency-gate
+    just source-runtime
+    just typing
+    just python-unit
+    just python-release
+    just python-integration
+    just python-physics
+    just rust-check
+    just rust-test
+    just installed-smoke
+
+check:
+    just typing
+    just dependency-gate
+    just python-unit
+    just rust-check
+
+test:
+    PYTHONPATH="$PWD/src" {{python}} -m pytest tests/integration/test_spenso_restricted_mode.py -q
+    PYTHONPATH="$PWD/src" {{python}} -m pytest --ignore=tests/integration/test_spenso_restricted_mode.py
+    just rust-test
+
+sdist:
+    PYAMPLICOL_BUILD_MODE={{build_mode}} {{python}} -m build --sdist
+
+wheel:
+    PYAMPLICOL_BUILD_MODE={{build_mode}} {{python}} -m build --wheel
+
+wheel-from-sdist:
+    {{python}} tools/release/build_from_sdist.py
+
+install-wheel PYTHON_ARG="":
+    @selected="{{PYTHON_ARG}}"; \
+    if [[ "$selected" == PYTHON=* ]]; then \
+        selected="$(printf '%s' "$selected" | cut -d= -f2-)"; \
+    fi; \
+    if [[ -z "$selected" ]]; then selected="{{python}}"; fi; \
+    {{python}} tools/release/install_wheel.py --python "$selected"
+
+# Install published dependencies and a release-mode source runtime. Historical
+# source candidates require --candidate; profiling references remain opt-in.
+dev-install *INSTALLER_ARGS: _source-checkout
+    mkdir -p {{dev_cache}}/tmp {{dev_cache}}/cargo-home {{dev_cache}}/cargo-target {{dev_cache}}/pip-cache {{dev_cache}}/xdg-cache {{dev_cache}}/python-cache
+    TMPDIR="$PWD/{{dev_cache}}/tmp" CARGO_HOME="$PWD/{{dev_cache}}/cargo-home" CARGO_TARGET_DIR="$PWD/{{dev_cache}}/cargo-target" PIP_CACHE_DIR="$PWD/{{dev_cache}}/pip-cache" XDG_CACHE_HOME="$PWD/{{dev_cache}}/xdg-cache" PYTHONPYCACHEPREFIX="$PWD/{{dev_cache}}/python-cache" PYAMPLICOL_CANDIDATE_CACHE_ROOT="$PWD/{{dev_cache}}" {{python}} dependencies/install_dependencies.py {{INSTALLER_ARGS}}
+
+# Report/campaign prerequisite. pyAmpliCol is not released yet, so this keeps
+# the explicit build entrypoint tied to the published-dependency environment.
+dev-build: _source-checkout
+    just dev-install
+    {{dev_python}} -c 'import pyamplicol; import pyamplicol.api'
+    {{dev_python}} src/pyamplicol/_profiling_campaign/result_tables.py validate
+
+dev-test: _source-checkout
+    PYTHON={{dev_python}} PYAMPLICOL_BUILD_MODE={{build_mode}} just source-gate
+    @if [ "{{build_mode}}" = candidate ]; then \
+        PYTHON={{dev_python}} PYAMPLICOL_BUILD_MODE=candidate just test-deployment-candidate; \
+    else \
+        PYTHON={{dev_python}} PYAMPLICOL_BUILD_MODE=release just test-deployment; \
+    fi
+
+# Bounded built-in-SM eager gate under the 30 GiB memory guard.
+eager-smoke: _source-checkout
+    {{dev_python}} tools/ci/memory_watchdog.py --limit-gib 30 -- {{dev_python}} tools/developer/eager_benchmark_matrix.py --suite smoke --models built-in --builtin-pack {{eager_builtin_pack}} --output-root .artifacts/eager-benchmark/smoke
+
+# Full built-in/UFO-SM eager milestone gate under the 30 GiB memory guard.
+eager-milestone: _source-checkout
+    {{dev_python}} tools/ci/memory_watchdog.py --limit-gib 30 -- {{dev_python}} tools/developer/eager_benchmark_matrix.py --suite milestone --models built-in,ufo-sm --builtin-pack {{eager_builtin_pack}} --ufo-source {{eager_ufo_source}} --ufo-pack {{eager_ufo_pack}} --output-root .artifacts/eager-benchmark/milestone
+
+test-deployment-candidate: _source-checkout
+    PYAMPLICOL_BUILD_MODE=candidate {{python}} tools/release/test_deployment.py --candidate
+
+test-deployment:
+    PYAMPLICOL_BUILD_MODE=release {{python}} tools/release/test_deployment.py
+
+release-artifacts: _source-checkout
+    PYAMPLICOL_BUILD_MODE=release just source-gate
+    just independent-physics-oracle
+    PYAMPLICOL_BUILD_MODE=release {{python}} tools/release/build_release_artifacts.py
+
+publish-dry-run: _source-checkout
+    PYAMPLICOL_BUILD_MODE=release just source-gate
+    just independent-physics-oracle
+    PYAMPLICOL_BUILD_MODE=release {{python}} tools/release/publish_dry_run.py
diff --git a/pyamplicol/licenses/GammaLoop-model-assets.txt b/pyamplicol/licenses/GammaLoop-model-assets.txt
new file mode 100644
index 0000000000..f931655be4
--- /dev/null
+++ b/pyamplicol/licenses/GammaLoop-model-assets.txt
@@ -0,0 +1,16 @@
+GammaLoop Model Asset License
+
+Local SPDX identifier: LicenseRef-GammaLoop-No-Restrictions
+
+The bundled UFO source models and their derived JSON forms were distributed
+as GammaLoop model assets. GammaLoop's accompanying LICENSE.md states:
+
+There are no usage restrictions for `GammaLoop`.
+
+The upstream license separately calls attention to Symbolica's license
+restrictions. Symbolica is not part of these model assets and its terms are
+recorded independently in licenses/Symbolica.txt.
+
+This notice applies only to the eligible GammaLoop-origin model assets listed
+in src/pyamplicol/assets/models/PROVENANCE.toml. Files carrying their own
+copyright or license notice retain that notice.
diff --git a/pyamplicol/licenses/GammaLoop.txt b/pyamplicol/licenses/GammaLoop.txt
new file mode 100644
index 0000000000..82d806ae99
--- /dev/null
+++ b/pyamplicol/licenses/GammaLoop.txt
@@ -0,0 +1,6 @@
+# Licence
+There are no usage restrictions for `GammaLoop`.
+
+However, note the license restrictions from
+[Symbolica](https://symbolica.io/license.html), which is a core dependency of
+`GammaLoop`.
diff --git a/pyamplicol/licenses/MadGraph5_aMCatNLO.txt b/pyamplicol/licenses/MadGraph5_aMCatNLO.txt
new file mode 100644
index 0000000000..df1774f377
--- /dev/null
+++ b/pyamplicol/licenses/MadGraph5_aMCatNLO.txt
@@ -0,0 +1,34 @@
+The MadGraph5_aMC@NLO software comes with the following Open Source License,
+adapted from the University of Illinois/NCSA license.
+
+Copyright (c) 2009, 2013, the MadTeam. All rights reserved.
+
+Developed by the "MadTeam", i.e. Johan ALWALL, Rikkert FREDERIX, Stefano
+FRIXIONE, Michel HERQUET, Valentin HIRSCHI, Fabio MALTONI, Olivier MATTELAER,
+Tim STELZER, Paolo TORRIELLI, and Marco ZARO.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+with the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimers.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimers in the documentation
+   and/or other materials provided with the distribution.
+3. Neither the name "MadTeam", the names of the authors, their institution,
+   nor the names of its contributors may be used to endorse or promote
+   products derived from this Software without specific prior written
+   permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS WITH THE SOFTWARE.
diff --git a/pyamplicol/licenses/SymJIT.txt b/pyamplicol/licenses/SymJIT.txt
new file mode 100644
index 0000000000..fbf10f96ad
--- /dev/null
+++ b/pyamplicol/licenses/SymJIT.txt
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 siravan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/Symbolica.txt b/pyamplicol/licenses/Symbolica.txt
new file mode 100644
index 0000000000..38b64bd583
--- /dev/null
+++ b/pyamplicol/licenses/Symbolica.txt
@@ -0,0 +1,42 @@
+Symbolica Proprietary Terms And Redistribution Permission
+
+SPDX identifier: LicenseRef-Symbolica-Proprietary
+
+Upstream terms reproduced from Symbolica 2.2.0 License.md
+
+# Symbolica licenses
+
+The source code of Symbolica is publicly available. It is not permitted to
+copy or distribute any part of the Symbolica code without express prior
+permission.
+
+Visit https://symbolica.io/license/ to read more about the license philosophy
+behind Symbolica or to acquire a license.
+
+## Hobbyist / student license
+
+For personal non-professional use of Symbolica, for example for studies or for
+a hobby, a free hobbyist license can be acquired.
+
+## Professional non-commercial license
+
+For professional non-commercial use of Symbolica, for example for work at an
+educational / research institute, you or your employer must acquire a
+professional non-commercial license.
+
+## Commercial license
+
+For professional commercial use of Symbolica, you or your employer must
+acquire a commercial license.
+
+Attribution And Project-Specific Permission
+
+Symbolica is developed by Ben Ruijl and contributors and is available from
+https://symbolica.io/ and https://github.com/symbolica-dev/symbolica.
+
+Express redistribution permission for pyAmpliCol: the pyAmpliCol project has
+express prior permission from the Symbolica licensor to redistribute the
+Symbolica components required by pyAmpliCol's binary runtime. This permission
+is specific to pyAmpliCol release artifacts. It does not grant recipients a
+general right to copy or distribute Symbolica separately, and it does not
+replace the use license appropriate to the recipient's circumstances.
diff --git a/pyamplicol/licenses/rust/ahash-0.8.12/LICENSE-APACHE b/pyamplicol/licenses/rust/ahash-0.8.12/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/ahash-0.8.12/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/ahash-0.8.12/LICENSE-MIT b/pyamplicol/licenses/rust/ahash-0.8.12/LICENSE-MIT
new file mode 100644
index 0000000000..cba20106dd
--- /dev/null
+++ b/pyamplicol/licenses/rust/ahash-0.8.12/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2018 Tom Kaitchuck
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/allocator-api2-0.2.21/LICENSE-APACHE b/pyamplicol/licenses/rust/allocator-api2-0.2.21/LICENSE-APACHE
new file mode 100644
index 0000000000..a2ce4d97c1
--- /dev/null
+++ b/pyamplicol/licenses/rust/allocator-api2-0.2.21/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/allocator-api2-0.2.21/LICENSE-MIT b/pyamplicol/licenses/rust/allocator-api2-0.2.21/LICENSE-MIT
new file mode 100644
index 0000000000..458723b374
--- /dev/null
+++ b/pyamplicol/licenses/rust/allocator-api2-0.2.21/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/anyhow-1.0.103/LICENSE-APACHE b/pyamplicol/licenses/rust/anyhow-1.0.103/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/anyhow-1.0.103/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/anyhow-1.0.103/LICENSE-MIT b/pyamplicol/licenses/rust/anyhow-1.0.103/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/anyhow-1.0.103/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/autocfg-1.5.1/LICENSE-APACHE b/pyamplicol/licenses/rust/autocfg-1.5.1/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/autocfg-1.5.1/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/autocfg-1.5.1/LICENSE-MIT b/pyamplicol/licenses/rust/autocfg-1.5.1/LICENSE-MIT
new file mode 100644
index 0000000000..44fbc4d8b9
--- /dev/null
+++ b/pyamplicol/licenses/rust/autocfg-1.5.1/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2018 Josh Stone
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/bincode-2.0.1/LICENSE.md b/pyamplicol/licenses/rust/bincode-2.0.1/LICENSE.md
new file mode 100644
index 0000000000..26b1f00a27
--- /dev/null
+++ b/pyamplicol/licenses/rust/bincode-2.0.1/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Ty Overby
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/bincode_derive-2.0.1/LICENSE.md b/pyamplicol/licenses/rust/bincode_derive-2.0.1/LICENSE.md
new file mode 100644
index 0000000000..26b1f00a27
--- /dev/null
+++ b/pyamplicol/licenses/rust/bincode_derive-2.0.1/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Ty Overby
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/bitflags-1.3.2/LICENSE-APACHE b/pyamplicol/licenses/rust/bitflags-1.3.2/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/bitflags-1.3.2/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/bitflags-1.3.2/LICENSE-MIT b/pyamplicol/licenses/rust/bitflags-1.3.2/LICENSE-MIT
new file mode 100644
index 0000000000..39d4bdb5ac
--- /dev/null
+++ b/pyamplicol/licenses/rust/bitflags-1.3.2/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/block-buffer-0.10.4/LICENSE-APACHE b/pyamplicol/licenses/rust/block-buffer-0.10.4/LICENSE-APACHE
new file mode 100644
index 0000000000..78173fa2e7
--- /dev/null
+++ b/pyamplicol/licenses/rust/block-buffer-0.10.4/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/block-buffer-0.10.4/LICENSE-MIT b/pyamplicol/licenses/rust/block-buffer-0.10.4/LICENSE-MIT
new file mode 100644
index 0000000000..502cee6e85
--- /dev/null
+++ b/pyamplicol/licenses/rust/block-buffer-0.10.4/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2018-2019 The RustCrypto Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/bytemuck-1.25.1/LICENSE-APACHE b/pyamplicol/licenses/rust/bytemuck-1.25.1/LICENSE-APACHE
new file mode 100644
index 0000000000..136d900456
--- /dev/null
+++ b/pyamplicol/licenses/rust/bytemuck-1.25.1/LICENSE-APACHE
@@ -0,0 +1,61 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+    1. Definitions.
+
+        "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+        "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+        "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+        "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+        "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+        "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+        "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+        "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+        "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+        "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+    2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+    3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+    4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+        (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
+        (b) You must cause any modified files to carry prominent notices stating that You changed the files; and
+        (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+        (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+        You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+    5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+    6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+    7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+    8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+    9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/bytemuck-1.25.1/LICENSE-MIT b/pyamplicol/licenses/rust/bytemuck-1.25.1/LICENSE-MIT
new file mode 100644
index 0000000000..164045faad
--- /dev/null
+++ b/pyamplicol/licenses/rust/bytemuck-1.25.1/LICENSE-MIT
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2019 Daniel "Lokathor" Gee.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/bytemuck-1.25.1/LICENSE-ZLIB b/pyamplicol/licenses/rust/bytemuck-1.25.1/LICENSE-ZLIB
new file mode 100644
index 0000000000..d70707c75a
--- /dev/null
+++ b/pyamplicol/licenses/rust/bytemuck-1.25.1/LICENSE-ZLIB
@@ -0,0 +1,11 @@
+Copyright (c) 2019 Daniel "Lokathor" Gee.
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
diff --git a/pyamplicol/licenses/rust/cfg-if-1.0.4/LICENSE-APACHE b/pyamplicol/licenses/rust/cfg-if-1.0.4/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/cfg-if-1.0.4/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/cfg-if-1.0.4/LICENSE-MIT b/pyamplicol/licenses/rust/cfg-if-1.0.4/LICENSE-MIT
new file mode 100644
index 0000000000..39e0ed6602
--- /dev/null
+++ b/pyamplicol/licenses/rust/cfg-if-1.0.4/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 Alex Crichton
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/cpufeatures-0.2.17/LICENSE-APACHE b/pyamplicol/licenses/rust/cpufeatures-0.2.17/LICENSE-APACHE
new file mode 100644
index 0000000000..78173fa2e7
--- /dev/null
+++ b/pyamplicol/licenses/rust/cpufeatures-0.2.17/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/cpufeatures-0.2.17/LICENSE-MIT b/pyamplicol/licenses/rust/cpufeatures-0.2.17/LICENSE-MIT
new file mode 100644
index 0000000000..0cd648f76b
--- /dev/null
+++ b/pyamplicol/licenses/rust/cpufeatures-0.2.17/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2020-2025 The RustCrypto Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/crossbeam-deque-0.8.7/LICENSE-APACHE b/pyamplicol/licenses/rust/crossbeam-deque-0.8.7/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/crossbeam-deque-0.8.7/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/crossbeam-deque-0.8.7/LICENSE-MIT b/pyamplicol/licenses/rust/crossbeam-deque-0.8.7/LICENSE-MIT
new file mode 100644
index 0000000000..068d491fd5
--- /dev/null
+++ b/pyamplicol/licenses/rust/crossbeam-deque-0.8.7/LICENSE-MIT
@@ -0,0 +1,27 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 The Crossbeam Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/crossbeam-epoch-0.9.20/LICENSE-APACHE b/pyamplicol/licenses/rust/crossbeam-epoch-0.9.20/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/crossbeam-epoch-0.9.20/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/crossbeam-epoch-0.9.20/LICENSE-MIT b/pyamplicol/licenses/rust/crossbeam-epoch-0.9.20/LICENSE-MIT
new file mode 100644
index 0000000000..068d491fd5
--- /dev/null
+++ b/pyamplicol/licenses/rust/crossbeam-epoch-0.9.20/LICENSE-MIT
@@ -0,0 +1,27 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 The Crossbeam Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/crossbeam-utils-0.8.22/LICENSE-APACHE b/pyamplicol/licenses/rust/crossbeam-utils-0.8.22/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/crossbeam-utils-0.8.22/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/crossbeam-utils-0.8.22/LICENSE-MIT b/pyamplicol/licenses/rust/crossbeam-utils-0.8.22/LICENSE-MIT
new file mode 100644
index 0000000000..068d491fd5
--- /dev/null
+++ b/pyamplicol/licenses/rust/crossbeam-utils-0.8.22/LICENSE-MIT
@@ -0,0 +1,27 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 The Crossbeam Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/crypto-common-0.1.7/LICENSE-APACHE b/pyamplicol/licenses/rust/crypto-common-0.1.7/LICENSE-APACHE
new file mode 100644
index 0000000000..78173fa2e7
--- /dev/null
+++ b/pyamplicol/licenses/rust/crypto-common-0.1.7/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/crypto-common-0.1.7/LICENSE-MIT b/pyamplicol/licenses/rust/crypto-common-0.1.7/LICENSE-MIT
new file mode 100644
index 0000000000..efb0b5f8b0
--- /dev/null
+++ b/pyamplicol/licenses/rust/crypto-common-0.1.7/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2021 RustCrypto Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/digest-0.10.7/LICENSE-APACHE b/pyamplicol/licenses/rust/digest-0.10.7/LICENSE-APACHE
new file mode 100644
index 0000000000..78173fa2e7
--- /dev/null
+++ b/pyamplicol/licenses/rust/digest-0.10.7/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/digest-0.10.7/LICENSE-MIT b/pyamplicol/licenses/rust/digest-0.10.7/LICENSE-MIT
new file mode 100644
index 0000000000..8dcb85b302
--- /dev/null
+++ b/pyamplicol/licenses/rust/digest-0.10.7/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2017 Artyom Pavlov
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/either-1.16.0/LICENSE-APACHE b/pyamplicol/licenses/rust/either-1.16.0/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/either-1.16.0/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/either-1.16.0/LICENSE-MIT b/pyamplicol/licenses/rust/either-1.16.0/LICENSE-MIT
new file mode 100644
index 0000000000..9203baa055
--- /dev/null
+++ b/pyamplicol/licenses/rust/either-1.16.0/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2015
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/equivalent-1.0.2/LICENSE-APACHE b/pyamplicol/licenses/rust/equivalent-1.0.2/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/equivalent-1.0.2/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/equivalent-1.0.2/LICENSE-MIT b/pyamplicol/licenses/rust/equivalent-1.0.2/LICENSE-MIT
new file mode 100644
index 0000000000..5ac40dae7f
--- /dev/null
+++ b/pyamplicol/licenses/rust/equivalent-1.0.2/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2016--2023
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/fixedbitset-0.5.7/LICENSE-APACHE b/pyamplicol/licenses/rust/fixedbitset-0.5.7/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/fixedbitset-0.5.7/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/fixedbitset-0.5.7/LICENSE-MIT b/pyamplicol/licenses/rust/fixedbitset-0.5.7/LICENSE-MIT
new file mode 100644
index 0000000000..327cc6174c
--- /dev/null
+++ b/pyamplicol/licenses/rust/fixedbitset-0.5.7/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2015-2017
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/foldhash-0.1.5/LICENSE b/pyamplicol/licenses/rust/foldhash-0.1.5/LICENSE
new file mode 100644
index 0000000000..2f65b0a366
--- /dev/null
+++ b/pyamplicol/licenses/rust/foldhash-0.1.5/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2024 Orson Peters
+
+This software is provided 'as-is', without any express or implied warranty. In
+no event will the authors be held liable for any damages arising from the use of
+this software.
+
+Permission is granted to anyone to use this software for any purpose, including
+commercial applications, and to alter it and redistribute it freely, subject to
+the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim
+    that you wrote the original software. If you use this software in a product,
+    an acknowledgment in the product documentation would be appreciated but is
+    not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
\ No newline at end of file
diff --git a/pyamplicol/licenses/rust/foldhash-0.2.0/LICENSE b/pyamplicol/licenses/rust/foldhash-0.2.0/LICENSE
new file mode 100644
index 0000000000..2f65b0a366
--- /dev/null
+++ b/pyamplicol/licenses/rust/foldhash-0.2.0/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2024 Orson Peters
+
+This software is provided 'as-is', without any express or implied warranty. In
+no event will the authors be held liable for any damages arising from the use of
+this software.
+
+Permission is granted to anyone to use this software for any purpose, including
+commercial applications, and to alter it and redistribute it freely, subject to
+the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim
+    that you wrote the original software. If you use this software in a product,
+    an acknowledgment in the product documentation would be appreciated but is
+    not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
\ No newline at end of file
diff --git a/pyamplicol/licenses/rust/generic-array-0.14.7/LICENSE b/pyamplicol/licenses/rust/generic-array-0.14.7/LICENSE
new file mode 100644
index 0000000000..6d318946df
--- /dev/null
+++ b/pyamplicol/licenses/rust/generic-array-0.14.7/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Bartłomiej Kamiński
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/pyamplicol/licenses/rust/getrandom-0.3.4/LICENSE-APACHE b/pyamplicol/licenses/rust/getrandom-0.3.4/LICENSE-APACHE
new file mode 100644
index 0000000000..17d74680f8
--- /dev/null
+++ b/pyamplicol/licenses/rust/getrandom-0.3.4/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     https://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/getrandom-0.3.4/LICENSE-MIT b/pyamplicol/licenses/rust/getrandom-0.3.4/LICENSE-MIT
new file mode 100644
index 0000000000..e54440a9e5
--- /dev/null
+++ b/pyamplicol/licenses/rust/getrandom-0.3.4/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright (c) 2018-2025 The rust-random Project Developers
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/hashbrown-0.15.5/LICENSE-APACHE b/pyamplicol/licenses/rust/hashbrown-0.15.5/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/hashbrown-0.15.5/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/hashbrown-0.15.5/LICENSE-MIT b/pyamplicol/licenses/rust/hashbrown-0.15.5/LICENSE-MIT
new file mode 100644
index 0000000000..5afc2a7b0a
--- /dev/null
+++ b/pyamplicol/licenses/rust/hashbrown-0.15.5/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2016 Amanieu d'Antras
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/hashbrown-0.16.1/LICENSE-APACHE b/pyamplicol/licenses/rust/hashbrown-0.16.1/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/hashbrown-0.16.1/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/hashbrown-0.16.1/LICENSE-MIT b/pyamplicol/licenses/rust/hashbrown-0.16.1/LICENSE-MIT
new file mode 100644
index 0000000000..5afc2a7b0a
--- /dev/null
+++ b/pyamplicol/licenses/rust/hashbrown-0.16.1/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2016 Amanieu d'Antras
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/hashbrown-0.17.1/LICENSE-APACHE b/pyamplicol/licenses/rust/hashbrown-0.17.1/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/hashbrown-0.17.1/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/hashbrown-0.17.1/LICENSE-MIT b/pyamplicol/licenses/rust/hashbrown-0.17.1/LICENSE-MIT
new file mode 100644
index 0000000000..5afc2a7b0a
--- /dev/null
+++ b/pyamplicol/licenses/rust/hashbrown-0.17.1/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2016 Amanieu d'Antras
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/heck-0.5.0/LICENSE-APACHE b/pyamplicol/licenses/rust/heck-0.5.0/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/heck-0.5.0/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/heck-0.5.0/LICENSE-MIT b/pyamplicol/licenses/rust/heck-0.5.0/LICENSE-MIT
new file mode 100644
index 0000000000..e69282e381
--- /dev/null
+++ b/pyamplicol/licenses/rust/heck-0.5.0/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2015 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/hugepage-rs-0.1.1/LICENSE-APACHE b/pyamplicol/licenses/rust/hugepage-rs-0.1.1/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/hugepage-rs-0.1.1/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/hugepage-rs-0.1.1/LICENSE-MIT b/pyamplicol/licenses/rust/hugepage-rs-0.1.1/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/hugepage-rs-0.1.1/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/indexmap-2.14.0/LICENSE-APACHE b/pyamplicol/licenses/rust/indexmap-2.14.0/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/indexmap-2.14.0/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/indexmap-2.14.0/LICENSE-MIT b/pyamplicol/licenses/rust/indexmap-2.14.0/LICENSE-MIT
new file mode 100644
index 0000000000..8b8181068b
--- /dev/null
+++ b/pyamplicol/licenses/rust/indexmap-2.14.0/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2016--2017
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/itoa-1.0.18/LICENSE-APACHE b/pyamplicol/licenses/rust/itoa-1.0.18/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/itoa-1.0.18/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/itoa-1.0.18/LICENSE-MIT b/pyamplicol/licenses/rust/itoa-1.0.18/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/itoa-1.0.18/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/lazy_static-1.5.0/LICENSE-APACHE b/pyamplicol/licenses/rust/lazy_static-1.5.0/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/lazy_static-1.5.0/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/lazy_static-1.5.0/LICENSE-MIT b/pyamplicol/licenses/rust/lazy_static-1.5.0/LICENSE-MIT
new file mode 100644
index 0000000000..25597d5838
--- /dev/null
+++ b/pyamplicol/licenses/rust/lazy_static-1.5.0/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2010 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/libc-0.2.186/LICENSE-APACHE b/pyamplicol/licenses/rust/libc-0.2.186/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/libc-0.2.186/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/libc-0.2.186/LICENSE-MIT b/pyamplicol/licenses/rust/libc-0.2.186/LICENSE-MIT
new file mode 100644
index 0000000000..f4095b2fa2
--- /dev/null
+++ b/pyamplicol/licenses/rust/libc-0.2.186/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/mach2-0.4.3/LICENSE-APACHE b/pyamplicol/licenses/rust/mach2-0.4.3/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/mach2-0.4.3/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/mach2-0.4.3/LICENSE-BSD b/pyamplicol/licenses/rust/mach2-0.4.3/LICENSE-BSD
new file mode 100644
index 0000000000..e02a2d2cfc
--- /dev/null
+++ b/pyamplicol/licenses/rust/mach2-0.4.3/LICENSE-BSD
@@ -0,0 +1,23 @@
+Copyright (c) 2019 Nick Fitzgerald, 2021 Yuki Okushi
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pyamplicol/licenses/rust/mach2-0.4.3/LICENSE-MIT b/pyamplicol/licenses/rust/mach2-0.4.3/LICENSE-MIT
new file mode 100644
index 0000000000..08bda86c65
--- /dev/null
+++ b/pyamplicol/licenses/rust/mach2-0.4.3/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2019 Nick Fitzgerald, 2021 Yuki Okushi
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/matrixmultiply-0.3.11/LICENSE-APACHE b/pyamplicol/licenses/rust/matrixmultiply-0.3.11/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/matrixmultiply-0.3.11/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/matrixmultiply-0.3.11/LICENSE-MIT b/pyamplicol/licenses/rust/matrixmultiply-0.3.11/LICENSE-MIT
new file mode 100644
index 0000000000..9015f77637
--- /dev/null
+++ b/pyamplicol/licenses/rust/matrixmultiply-0.3.11/LICENSE-MIT
@@ -0,0 +1,27 @@
+Copyright (c) 2016 - 2023 Ulrik Sverdrup "bluss"
+Copyirhgt (c) 2018 R. Janis Goldschmidt
+Copyright (c) 2021 DutchGhost [constparse.rs]
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/memchr-2.8.3/COPYING b/pyamplicol/licenses/rust/memchr-2.8.3/COPYING
new file mode 100644
index 0000000000..bb9c20a094
--- /dev/null
+++ b/pyamplicol/licenses/rust/memchr-2.8.3/COPYING
@@ -0,0 +1,3 @@
+This project is dual-licensed under the Unlicense and MIT licenses.
+
+You may use this code under the terms of either license.
diff --git a/pyamplicol/licenses/rust/memchr-2.8.3/LICENSE-MIT b/pyamplicol/licenses/rust/memchr-2.8.3/LICENSE-MIT
new file mode 100644
index 0000000000..3b0a5dc09c
--- /dev/null
+++ b/pyamplicol/licenses/rust/memchr-2.8.3/LICENSE-MIT
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Andrew Gallant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/memchr-2.8.3/UNLICENSE b/pyamplicol/licenses/rust/memchr-2.8.3/UNLICENSE
new file mode 100644
index 0000000000..68a49daad8
--- /dev/null
+++ b/pyamplicol/licenses/rust/memchr-2.8.3/UNLICENSE
@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>
diff --git a/pyamplicol/licenses/rust/ndarray-0.17.2/LICENSE-APACHE b/pyamplicol/licenses/rust/ndarray-0.17.2/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/ndarray-0.17.2/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/ndarray-0.17.2/LICENSE-MIT b/pyamplicol/licenses/rust/ndarray-0.17.2/LICENSE-MIT
new file mode 100644
index 0000000000..d0af99b046
--- /dev/null
+++ b/pyamplicol/licenses/rust/ndarray-0.17.2/LICENSE-MIT
@@ -0,0 +1,27 @@
+Copyright (c) 2015 - 2021 Ulrik Sverdrup "bluss",
+			  Jim Turner,
+			  and ndarray developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/num-complex-0.4.6/LICENSE-APACHE b/pyamplicol/licenses/rust/num-complex-0.4.6/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/num-complex-0.4.6/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/num-complex-0.4.6/LICENSE-MIT b/pyamplicol/licenses/rust/num-complex-0.4.6/LICENSE-MIT
new file mode 100644
index 0000000000..39d4bdb5ac
--- /dev/null
+++ b/pyamplicol/licenses/rust/num-complex-0.4.6/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/num-integer-0.1.46/LICENSE-APACHE b/pyamplicol/licenses/rust/num-integer-0.1.46/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/num-integer-0.1.46/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/num-integer-0.1.46/LICENSE-MIT b/pyamplicol/licenses/rust/num-integer-0.1.46/LICENSE-MIT
new file mode 100644
index 0000000000..39d4bdb5ac
--- /dev/null
+++ b/pyamplicol/licenses/rust/num-integer-0.1.46/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/num-traits-0.2.19/LICENSE-APACHE b/pyamplicol/licenses/rust/num-traits-0.2.19/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/num-traits-0.2.19/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/num-traits-0.2.19/LICENSE-MIT b/pyamplicol/licenses/rust/num-traits-0.2.19/LICENSE-MIT
new file mode 100644
index 0000000000..39d4bdb5ac
--- /dev/null
+++ b/pyamplicol/licenses/rust/num-traits-0.2.19/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/numpy-0.29.0/LICENSE b/pyamplicol/licenses/rust/numpy-0.29.0/LICENSE
new file mode 100644
index 0000000000..d5b45151c7
--- /dev/null
+++ b/pyamplicol/licenses/rust/numpy-0.29.0/LICENSE
@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2017, Toshiki Teramura
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pyamplicol/licenses/rust/once_cell-1.21.4/LICENSE-APACHE b/pyamplicol/licenses/rust/once_cell-1.21.4/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/once_cell-1.21.4/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/once_cell-1.21.4/LICENSE-MIT b/pyamplicol/licenses/rust/once_cell-1.21.4/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/once_cell-1.21.4/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/petgraph-0.8.3/LICENSE-APACHE b/pyamplicol/licenses/rust/petgraph-0.8.3/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/petgraph-0.8.3/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/petgraph-0.8.3/LICENSE-MIT b/pyamplicol/licenses/rust/petgraph-0.8.3/LICENSE-MIT
new file mode 100644
index 0000000000..9203baa055
--- /dev/null
+++ b/pyamplicol/licenses/rust/petgraph-0.8.3/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2015
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/petgraph-0.8.3/assets/images/LICENSE.md b/pyamplicol/licenses/rust/petgraph-0.8.3/assets/images/LICENSE.md
new file mode 100644
index 0000000000..ba81e5248f
--- /dev/null
+++ b/pyamplicol/licenses/rust/petgraph-0.8.3/assets/images/LICENSE.md
@@ -0,0 +1,7 @@
+Graphosaurus (c) by the petgraph project.
+
+Graphosaurus is licensed under a
+Creative Commons Attribution-ShareAlike 4.0 International License.
+
+You should have received a copy of the license along with this
+work.  If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
\ No newline at end of file
diff --git a/pyamplicol/licenses/rust/ppv-lite86-0.2.21/LICENSE-APACHE b/pyamplicol/licenses/rust/ppv-lite86-0.2.21/LICENSE-APACHE
new file mode 100644
index 0000000000..1eb3215354
--- /dev/null
+++ b/pyamplicol/licenses/rust/ppv-lite86-0.2.21/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright 2019 The CryptoCorrosion Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/ppv-lite86-0.2.21/LICENSE-MIT b/pyamplicol/licenses/rust/ppv-lite86-0.2.21/LICENSE-MIT
new file mode 100644
index 0000000000..d78c961bca
--- /dev/null
+++ b/pyamplicol/licenses/rust/ppv-lite86-0.2.21/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2019 The CryptoCorrosion Contributors
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/proc-macro2-1.0.106/LICENSE-APACHE b/pyamplicol/licenses/rust/proc-macro2-1.0.106/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/proc-macro2-1.0.106/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/proc-macro2-1.0.106/LICENSE-MIT b/pyamplicol/licenses/rust/proc-macro2-1.0.106/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/proc-macro2-1.0.106/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/pyo3-0.29.2/LICENSE-APACHE b/pyamplicol/licenses/rust/pyo3-0.29.2/LICENSE-APACHE
new file mode 100644
index 0000000000..72207b851d
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-0.29.2/LICENSE-APACHE
@@ -0,0 +1,178 @@
+Copyright (c) 2017-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/pyo3-0.29.2/LICENSE-MIT b/pyamplicol/licenses/rust/pyo3-0.29.2/LICENSE-MIT
new file mode 100644
index 0000000000..cd0ad009a8
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-0.29.2/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2023-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/pyo3-0.29.2/pyo3-runtime/LICENSE-APACHE b/pyamplicol/licenses/rust/pyo3-0.29.2/pyo3-runtime/LICENSE-APACHE
new file mode 100644
index 0000000000..72207b851d
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-0.29.2/pyo3-runtime/LICENSE-APACHE
@@ -0,0 +1,178 @@
+Copyright (c) 2017-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/pyo3-0.29.2/pyo3-runtime/LICENSE-MIT b/pyamplicol/licenses/rust/pyo3-0.29.2/pyo3-runtime/LICENSE-MIT
new file mode 100644
index 0000000000..cd0ad009a8
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-0.29.2/pyo3-runtime/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2023-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/pyo3-build-config-0.29.2/LICENSE-APACHE b/pyamplicol/licenses/rust/pyo3-build-config-0.29.2/LICENSE-APACHE
new file mode 100644
index 0000000000..72207b851d
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-build-config-0.29.2/LICENSE-APACHE
@@ -0,0 +1,178 @@
+Copyright (c) 2017-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/pyo3-build-config-0.29.2/LICENSE-MIT b/pyamplicol/licenses/rust/pyo3-build-config-0.29.2/LICENSE-MIT
new file mode 100644
index 0000000000..cd0ad009a8
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-build-config-0.29.2/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2023-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/pyo3-ffi-0.29.2/LICENSE-APACHE b/pyamplicol/licenses/rust/pyo3-ffi-0.29.2/LICENSE-APACHE
new file mode 100644
index 0000000000..72207b851d
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-ffi-0.29.2/LICENSE-APACHE
@@ -0,0 +1,178 @@
+Copyright (c) 2017-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/pyo3-ffi-0.29.2/LICENSE-MIT b/pyamplicol/licenses/rust/pyo3-ffi-0.29.2/LICENSE-MIT
new file mode 100644
index 0000000000..cd0ad009a8
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-ffi-0.29.2/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2023-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/pyo3-macros-0.29.2/LICENSE-APACHE b/pyamplicol/licenses/rust/pyo3-macros-0.29.2/LICENSE-APACHE
new file mode 100644
index 0000000000..72207b851d
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-macros-0.29.2/LICENSE-APACHE
@@ -0,0 +1,178 @@
+Copyright (c) 2017-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/pyo3-macros-0.29.2/LICENSE-MIT b/pyamplicol/licenses/rust/pyo3-macros-0.29.2/LICENSE-MIT
new file mode 100644
index 0000000000..cd0ad009a8
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-macros-0.29.2/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2023-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/pyo3-macros-backend-0.29.2/LICENSE-APACHE b/pyamplicol/licenses/rust/pyo3-macros-backend-0.29.2/LICENSE-APACHE
new file mode 100644
index 0000000000..72207b851d
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-macros-backend-0.29.2/LICENSE-APACHE
@@ -0,0 +1,178 @@
+Copyright (c) 2017-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/pyo3-macros-backend-0.29.2/LICENSE-MIT b/pyamplicol/licenses/rust/pyo3-macros-backend-0.29.2/LICENSE-MIT
new file mode 100644
index 0000000000..cd0ad009a8
--- /dev/null
+++ b/pyamplicol/licenses/rust/pyo3-macros-backend-0.29.2/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2023-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/quote-1.0.46/LICENSE-APACHE b/pyamplicol/licenses/rust/quote-1.0.46/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/quote-1.0.46/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/quote-1.0.46/LICENSE-MIT b/pyamplicol/licenses/rust/quote-1.0.46/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/quote-1.0.46/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/rand-0.9.5/COPYRIGHT b/pyamplicol/licenses/rust/rand-0.9.5/COPYRIGHT
new file mode 100644
index 0000000000..468d907caf
--- /dev/null
+++ b/pyamplicol/licenses/rust/rand-0.9.5/COPYRIGHT
@@ -0,0 +1,12 @@
+Copyrights in the Rand project are retained by their contributors. No
+copyright assignment is required to contribute to the Rand project.
+
+For full authorship information, see the version control history.
+
+Except as otherwise noted (below and/or in individual files), Rand is
+licensed under the Apache License, Version 2.0 <LICENSE-APACHE> or
+<http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+<LICENSE-MIT> or <http://opensource.org/licenses/MIT>, at your option.
+
+The Rand project includes code from the Rust project
+published under these same licenses.
diff --git a/pyamplicol/licenses/rust/rand-0.9.5/LICENSE-APACHE b/pyamplicol/licenses/rust/rand-0.9.5/LICENSE-APACHE
new file mode 100644
index 0000000000..494ad3bfdf
--- /dev/null
+++ b/pyamplicol/licenses/rust/rand-0.9.5/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     https://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/rand-0.9.5/LICENSE-MIT b/pyamplicol/licenses/rust/rand-0.9.5/LICENSE-MIT
new file mode 100644
index 0000000000..d93b5baf34
--- /dev/null
+++ b/pyamplicol/licenses/rust/rand-0.9.5/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright 2018 Developers of the Rand project
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/rand_chacha-0.9.0/COPYRIGHT b/pyamplicol/licenses/rust/rand_chacha-0.9.0/COPYRIGHT
new file mode 100644
index 0000000000..468d907caf
--- /dev/null
+++ b/pyamplicol/licenses/rust/rand_chacha-0.9.0/COPYRIGHT
@@ -0,0 +1,12 @@
+Copyrights in the Rand project are retained by their contributors. No
+copyright assignment is required to contribute to the Rand project.
+
+For full authorship information, see the version control history.
+
+Except as otherwise noted (below and/or in individual files), Rand is
+licensed under the Apache License, Version 2.0 <LICENSE-APACHE> or
+<http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+<LICENSE-MIT> or <http://opensource.org/licenses/MIT>, at your option.
+
+The Rand project includes code from the Rust project
+published under these same licenses.
diff --git a/pyamplicol/licenses/rust/rand_chacha-0.9.0/LICENSE-APACHE b/pyamplicol/licenses/rust/rand_chacha-0.9.0/LICENSE-APACHE
new file mode 100644
index 0000000000..494ad3bfdf
--- /dev/null
+++ b/pyamplicol/licenses/rust/rand_chacha-0.9.0/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     https://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/rand_chacha-0.9.0/LICENSE-MIT b/pyamplicol/licenses/rust/rand_chacha-0.9.0/LICENSE-MIT
new file mode 100644
index 0000000000..d93b5baf34
--- /dev/null
+++ b/pyamplicol/licenses/rust/rand_chacha-0.9.0/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright 2018 Developers of the Rand project
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/rand_core-0.9.5/COPYRIGHT b/pyamplicol/licenses/rust/rand_core-0.9.5/COPYRIGHT
new file mode 100644
index 0000000000..468d907caf
--- /dev/null
+++ b/pyamplicol/licenses/rust/rand_core-0.9.5/COPYRIGHT
@@ -0,0 +1,12 @@
+Copyrights in the Rand project are retained by their contributors. No
+copyright assignment is required to contribute to the Rand project.
+
+For full authorship information, see the version control history.
+
+Except as otherwise noted (below and/or in individual files), Rand is
+licensed under the Apache License, Version 2.0 <LICENSE-APACHE> or
+<http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+<LICENSE-MIT> or <http://opensource.org/licenses/MIT>, at your option.
+
+The Rand project includes code from the Rust project
+published under these same licenses.
diff --git a/pyamplicol/licenses/rust/rand_core-0.9.5/LICENSE-APACHE b/pyamplicol/licenses/rust/rand_core-0.9.5/LICENSE-APACHE
new file mode 100644
index 0000000000..455787c233
--- /dev/null
+++ b/pyamplicol/licenses/rust/rand_core-0.9.5/LICENSE-APACHE
@@ -0,0 +1,187 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     https://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
diff --git a/pyamplicol/licenses/rust/rand_core-0.9.5/LICENSE-MIT b/pyamplicol/licenses/rust/rand_core-0.9.5/LICENSE-MIT
new file mode 100644
index 0000000000..d93b5baf34
--- /dev/null
+++ b/pyamplicol/licenses/rust/rand_core-0.9.5/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright 2018 Developers of the Rand project
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/rawpointer-0.2.1/LICENSE-APACHE b/pyamplicol/licenses/rust/rawpointer-0.2.1/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/rawpointer-0.2.1/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/rawpointer-0.2.1/LICENSE-MIT b/pyamplicol/licenses/rust/rawpointer-0.2.1/LICENSE-MIT
new file mode 100644
index 0000000000..9203baa055
--- /dev/null
+++ b/pyamplicol/licenses/rust/rawpointer-0.2.1/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2015
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/rayon-1.12.0/LICENSE-APACHE b/pyamplicol/licenses/rust/rayon-1.12.0/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/rayon-1.12.0/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/rayon-1.12.0/LICENSE-MIT b/pyamplicol/licenses/rust/rayon-1.12.0/LICENSE-MIT
new file mode 100644
index 0000000000..25597d5838
--- /dev/null
+++ b/pyamplicol/licenses/rust/rayon-1.12.0/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2010 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/rayon-core-1.13.0/LICENSE-APACHE b/pyamplicol/licenses/rust/rayon-core-1.13.0/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/rayon-core-1.13.0/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/rayon-core-1.13.0/LICENSE-MIT b/pyamplicol/licenses/rust/rayon-core-1.13.0/LICENSE-MIT
new file mode 100644
index 0000000000..25597d5838
--- /dev/null
+++ b/pyamplicol/licenses/rust/rayon-core-1.13.0/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2010 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/region-3.0.2/LICENSE b/pyamplicol/licenses/rust/region-3.0.2/LICENSE
new file mode 100644
index 0000000000..6c34497dcc
--- /dev/null
+++ b/pyamplicol/licenses/rust/region-3.0.2/LICENSE
@@ -0,0 +1,25 @@
+Copyright (c) 2016 Elliott Linder
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/rustc-hash-2.1.3/LICENSE-APACHE b/pyamplicol/licenses/rust/rustc-hash-2.1.3/LICENSE-APACHE
new file mode 100644
index 0000000000..a7e77cb28d
--- /dev/null
+++ b/pyamplicol/licenses/rust/rustc-hash-2.1.3/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
\ No newline at end of file
diff --git a/pyamplicol/licenses/rust/rustc-hash-2.1.3/LICENSE-MIT b/pyamplicol/licenses/rust/rustc-hash-2.1.3/LICENSE-MIT
new file mode 100644
index 0000000000..468cd79a8f
--- /dev/null
+++ b/pyamplicol/licenses/rust/rustc-hash-2.1.3/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/pyamplicol/licenses/rust/safe_arch-1.0.0/LICENSE-APACHE.md b/pyamplicol/licenses/rust/safe_arch-1.0.0/LICENSE-APACHE.md
new file mode 100644
index 0000000000..136d900456
--- /dev/null
+++ b/pyamplicol/licenses/rust/safe_arch-1.0.0/LICENSE-APACHE.md
@@ -0,0 +1,61 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+    1. Definitions.
+
+        "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+        "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+        "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+        "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+        "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+        "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+        "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+        "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+        "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+        "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+    2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+    3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+    4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+        (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
+        (b) You must cause any modified files to carry prominent notices stating that You changed the files; and
+        (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+        (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+        You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+    5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+    6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+    7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+    8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+    9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/safe_arch-1.0.0/LICENSE-MIT.md b/pyamplicol/licenses/rust/safe_arch-1.0.0/LICENSE-MIT.md
new file mode 100644
index 0000000000..b61b394edd
--- /dev/null
+++ b/pyamplicol/licenses/rust/safe_arch-1.0.0/LICENSE-MIT.md
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2023 Daniel "Lokathor" Gee.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/safe_arch-1.0.0/LICENSE-ZLIB.md b/pyamplicol/licenses/rust/safe_arch-1.0.0/LICENSE-ZLIB.md
new file mode 100644
index 0000000000..4991f7b1df
--- /dev/null
+++ b/pyamplicol/licenses/rust/safe_arch-1.0.0/LICENSE-ZLIB.md
@@ -0,0 +1,11 @@
+Copyright (c) 2020 Daniel "Lokathor" Gee.
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
diff --git a/pyamplicol/licenses/rust/serde-1.0.228/LICENSE-APACHE b/pyamplicol/licenses/rust/serde-1.0.228/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/serde-1.0.228/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/serde-1.0.228/LICENSE-MIT b/pyamplicol/licenses/rust/serde-1.0.228/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/serde-1.0.228/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/serde_core-1.0.228/LICENSE-APACHE b/pyamplicol/licenses/rust/serde_core-1.0.228/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/serde_core-1.0.228/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/serde_core-1.0.228/LICENSE-MIT b/pyamplicol/licenses/rust/serde_core-1.0.228/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/serde_core-1.0.228/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/serde_derive-1.0.228/LICENSE-APACHE b/pyamplicol/licenses/rust/serde_derive-1.0.228/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/serde_derive-1.0.228/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/serde_derive-1.0.228/LICENSE-MIT b/pyamplicol/licenses/rust/serde_derive-1.0.228/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/serde_derive-1.0.228/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/serde_json-1.0.150/LICENSE-APACHE b/pyamplicol/licenses/rust/serde_json-1.0.150/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/serde_json-1.0.150/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/serde_json-1.0.150/LICENSE-MIT b/pyamplicol/licenses/rust/serde_json-1.0.150/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/serde_json-1.0.150/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/serde_spanned-1.1.1/LICENSE-APACHE b/pyamplicol/licenses/rust/serde_spanned-1.1.1/LICENSE-APACHE
new file mode 100644
index 0000000000..8f71f43fee
--- /dev/null
+++ b/pyamplicol/licenses/rust/serde_spanned-1.1.1/LICENSE-APACHE
@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
diff --git a/pyamplicol/licenses/rust/serde_spanned-1.1.1/LICENSE-MIT b/pyamplicol/licenses/rust/serde_spanned-1.1.1/LICENSE-MIT
new file mode 100644
index 0000000000..a2d01088b6
--- /dev/null
+++ b/pyamplicol/licenses/rust/serde_spanned-1.1.1/LICENSE-MIT
@@ -0,0 +1,19 @@
+Copyright (c) Individual contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/sha2-0.10.9/LICENSE-APACHE b/pyamplicol/licenses/rust/sha2-0.10.9/LICENSE-APACHE
new file mode 100644
index 0000000000..78173fa2e7
--- /dev/null
+++ b/pyamplicol/licenses/rust/sha2-0.10.9/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/sha2-0.10.9/LICENSE-MIT b/pyamplicol/licenses/rust/sha2-0.10.9/LICENSE-MIT
new file mode 100644
index 0000000000..66cf75563b
--- /dev/null
+++ b/pyamplicol/licenses/rust/sha2-0.10.9/LICENSE-MIT
@@ -0,0 +1,27 @@
+Copyright (c) 2006-2009 Graydon Hoare
+Copyright (c) 2009-2013 Mozilla Foundation
+Copyright (c) 2016 Artyom Pavlov
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/spec_math-0.1.6/LICENSE-APACHE b/pyamplicol/licenses/rust/spec_math-0.1.6/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/spec_math-0.1.6/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/spec_math-0.1.6/LICENSE-MIT b/pyamplicol/licenses/rust/spec_math-0.1.6/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/spec_math-0.1.6/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/symjit-2.22.0/LICENSE b/pyamplicol/licenses/rust/symjit-2.22.0/LICENSE
new file mode 100644
index 0000000000..fbf10f96ad
--- /dev/null
+++ b/pyamplicol/licenses/rust/symjit-2.22.0/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 siravan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/syn-2.0.119/LICENSE-APACHE b/pyamplicol/licenses/rust/syn-2.0.119/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/syn-2.0.119/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/syn-2.0.119/LICENSE-MIT b/pyamplicol/licenses/rust/syn-2.0.119/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/syn-2.0.119/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/target-lexicon-0.13.5/LICENSE b/pyamplicol/licenses/rust/target-lexicon-0.13.5/LICENSE
new file mode 100644
index 0000000000..f9d81955f4
--- /dev/null
+++ b/pyamplicol/licenses/rust/target-lexicon-0.13.5/LICENSE
@@ -0,0 +1,220 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+
+--- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.
+
diff --git a/pyamplicol/licenses/rust/thiserror-2.0.18/LICENSE-APACHE b/pyamplicol/licenses/rust/thiserror-2.0.18/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/thiserror-2.0.18/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/thiserror-2.0.18/LICENSE-MIT b/pyamplicol/licenses/rust/thiserror-2.0.18/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/thiserror-2.0.18/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/thiserror-impl-2.0.18/LICENSE-APACHE b/pyamplicol/licenses/rust/thiserror-impl-2.0.18/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/thiserror-impl-2.0.18/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/thiserror-impl-2.0.18/LICENSE-MIT b/pyamplicol/licenses/rust/thiserror-impl-2.0.18/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/thiserror-impl-2.0.18/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/toml-1.1.3+spec-1.1.0/LICENSE-APACHE b/pyamplicol/licenses/rust/toml-1.1.3+spec-1.1.0/LICENSE-APACHE
new file mode 100644
index 0000000000..8f71f43fee
--- /dev/null
+++ b/pyamplicol/licenses/rust/toml-1.1.3+spec-1.1.0/LICENSE-APACHE
@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
diff --git a/pyamplicol/licenses/rust/toml-1.1.3+spec-1.1.0/LICENSE-MIT b/pyamplicol/licenses/rust/toml-1.1.3+spec-1.1.0/LICENSE-MIT
new file mode 100644
index 0000000000..a2d01088b6
--- /dev/null
+++ b/pyamplicol/licenses/rust/toml-1.1.3+spec-1.1.0/LICENSE-MIT
@@ -0,0 +1,19 @@
+Copyright (c) Individual contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/toml_datetime-1.1.1+spec-1.1.0/LICENSE-APACHE b/pyamplicol/licenses/rust/toml_datetime-1.1.1+spec-1.1.0/LICENSE-APACHE
new file mode 100644
index 0000000000..8f71f43fee
--- /dev/null
+++ b/pyamplicol/licenses/rust/toml_datetime-1.1.1+spec-1.1.0/LICENSE-APACHE
@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
diff --git a/pyamplicol/licenses/rust/toml_datetime-1.1.1+spec-1.1.0/LICENSE-MIT b/pyamplicol/licenses/rust/toml_datetime-1.1.1+spec-1.1.0/LICENSE-MIT
new file mode 100644
index 0000000000..a2d01088b6
--- /dev/null
+++ b/pyamplicol/licenses/rust/toml_datetime-1.1.1+spec-1.1.0/LICENSE-MIT
@@ -0,0 +1,19 @@
+Copyright (c) Individual contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/toml_parser-1.1.2+spec-1.1.0/LICENSE-APACHE b/pyamplicol/licenses/rust/toml_parser-1.1.2+spec-1.1.0/LICENSE-APACHE
new file mode 100644
index 0000000000..8f71f43fee
--- /dev/null
+++ b/pyamplicol/licenses/rust/toml_parser-1.1.2+spec-1.1.0/LICENSE-APACHE
@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
diff --git a/pyamplicol/licenses/rust/toml_parser-1.1.2+spec-1.1.0/LICENSE-MIT b/pyamplicol/licenses/rust/toml_parser-1.1.2+spec-1.1.0/LICENSE-MIT
new file mode 100644
index 0000000000..a2d01088b6
--- /dev/null
+++ b/pyamplicol/licenses/rust/toml_parser-1.1.2+spec-1.1.0/LICENSE-MIT
@@ -0,0 +1,19 @@
+Copyright (c) Individual contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/toml_writer-1.1.2+spec-1.1.0/LICENSE-APACHE b/pyamplicol/licenses/rust/toml_writer-1.1.2+spec-1.1.0/LICENSE-APACHE
new file mode 100644
index 0000000000..8f71f43fee
--- /dev/null
+++ b/pyamplicol/licenses/rust/toml_writer-1.1.2+spec-1.1.0/LICENSE-APACHE
@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
diff --git a/pyamplicol/licenses/rust/toml_writer-1.1.2+spec-1.1.0/LICENSE-MIT b/pyamplicol/licenses/rust/toml_writer-1.1.2+spec-1.1.0/LICENSE-MIT
new file mode 100644
index 0000000000..a2d01088b6
--- /dev/null
+++ b/pyamplicol/licenses/rust/toml_writer-1.1.2+spec-1.1.0/LICENSE-MIT
@@ -0,0 +1,19 @@
+Copyright (c) Individual contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/typenum-1.20.1/LICENSE b/pyamplicol/licenses/rust/typenum-1.20.1/LICENSE
new file mode 100644
index 0000000000..364b7731ca
--- /dev/null
+++ b/pyamplicol/licenses/rust/typenum-1.20.1/LICENSE
@@ -0,0 +1 @@
+MIT OR Apache-2.0
\ No newline at end of file
diff --git a/pyamplicol/licenses/rust/typenum-1.20.1/LICENSE-APACHE b/pyamplicol/licenses/rust/typenum-1.20.1/LICENSE-APACHE
new file mode 100644
index 0000000000..4bf355c3e0
--- /dev/null
+++ b/pyamplicol/licenses/rust/typenum-1.20.1/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright 2014 Paho Lurie-Gregg
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
\ No newline at end of file
diff --git a/pyamplicol/licenses/rust/typenum-1.20.1/LICENSE-MIT b/pyamplicol/licenses/rust/typenum-1.20.1/LICENSE-MIT
new file mode 100644
index 0000000000..e567a4d280
--- /dev/null
+++ b/pyamplicol/licenses/rust/typenum-1.20.1/LICENSE-MIT
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Paho Lurie-Gregg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/unicode-ident-1.0.24/LICENSE-APACHE b/pyamplicol/licenses/rust/unicode-ident-1.0.24/LICENSE-APACHE
new file mode 100644
index 0000000000..1b5ec8b78e
--- /dev/null
+++ b/pyamplicol/licenses/rust/unicode-ident-1.0.24/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/pyamplicol/licenses/rust/unicode-ident-1.0.24/LICENSE-MIT b/pyamplicol/licenses/rust/unicode-ident-1.0.24/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/unicode-ident-1.0.24/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/unicode-ident-1.0.24/LICENSE-UNICODE b/pyamplicol/licenses/rust/unicode-ident-1.0.24/LICENSE-UNICODE
new file mode 100644
index 0000000000..11f2842a30
--- /dev/null
+++ b/pyamplicol/licenses/rust/unicode-ident-1.0.24/LICENSE-UNICODE
@@ -0,0 +1,39 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2023 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
diff --git a/pyamplicol/licenses/rust/unty-0.0.4/LICENSE-APACHE b/pyamplicol/licenses/rust/unty-0.0.4/LICENSE-APACHE
new file mode 100644
index 0000000000..28784f7584
--- /dev/null
+++ b/pyamplicol/licenses/rust/unty-0.0.4/LICENSE-APACHE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023 Bincode 
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/pyamplicol/licenses/rust/unty-0.0.4/LICENSE-MIT b/pyamplicol/licenses/rust/unty-0.0.4/LICENSE-MIT
new file mode 100644
index 0000000000..bfa1bb494f
--- /dev/null
+++ b/pyamplicol/licenses/rust/unty-0.0.4/LICENSE-MIT
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Bincode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/version_check-0.9.5/LICENSE-APACHE b/pyamplicol/licenses/rust/version_check-0.9.5/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/pyamplicol/licenses/rust/version_check-0.9.5/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/pyamplicol/licenses/rust/version_check-0.9.5/LICENSE-MIT b/pyamplicol/licenses/rust/version_check-0.9.5/LICENSE-MIT
new file mode 100644
index 0000000000..dfc0e73b19
--- /dev/null
+++ b/pyamplicol/licenses/rust/version_check-0.9.5/LICENSE-MIT
@@ -0,0 +1,19 @@
+The MIT License (MIT)
+Copyright (c) 2017-2018 Sergio Benitez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/virtue-0.0.18/LICENSE.md b/pyamplicol/licenses/rust/virtue-0.0.18/LICENSE.md
new file mode 100644
index 0000000000..4d5a490145
--- /dev/null
+++ b/pyamplicol/licenses/rust/virtue-0.0.18/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Victor Koenders
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/licenses/rust/wasmtime-jit-icache-coherence-34.0.2/LICENSE b/pyamplicol/licenses/rust/wasmtime-jit-icache-coherence-34.0.2/LICENSE
new file mode 100644
index 0000000000..f9d81955f4
--- /dev/null
+++ b/pyamplicol/licenses/rust/wasmtime-jit-icache-coherence-34.0.2/LICENSE
@@ -0,0 +1,220 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+
+--- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.
+
diff --git a/pyamplicol/licenses/rust/wide-1.5.0/LICENSE-ZLIB.md b/pyamplicol/licenses/rust/wide-1.5.0/LICENSE-ZLIB.md
new file mode 100644
index 0000000000..4991f7b1df
--- /dev/null
+++ b/pyamplicol/licenses/rust/wide-1.5.0/LICENSE-ZLIB.md
@@ -0,0 +1,11 @@
+Copyright (c) 2020 Daniel "Lokathor" Gee.
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
diff --git a/pyamplicol/licenses/rust/winnow-1.0.4/LICENSE-MIT b/pyamplicol/licenses/rust/winnow-1.0.4/LICENSE-MIT
new file mode 100644
index 0000000000..c9b44cb8aa
--- /dev/null
+++ b/pyamplicol/licenses/rust/winnow-1.0.4/LICENSE-MIT
@@ -0,0 +1,18 @@
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/rust/zerocopy-0.8.54/LICENSE-APACHE b/pyamplicol/licenses/rust/zerocopy-0.8.54/LICENSE-APACHE
new file mode 100644
index 0000000000..2dc22c12fa
--- /dev/null
+++ b/pyamplicol/licenses/rust/zerocopy-0.8.54/LICENSE-APACHE
@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023 The Fuchsia Authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
diff --git a/pyamplicol/licenses/rust/zerocopy-0.8.54/LICENSE-BSD b/pyamplicol/licenses/rust/zerocopy-0.8.54/LICENSE-BSD
new file mode 100644
index 0000000000..7ed244f42d
--- /dev/null
+++ b/pyamplicol/licenses/rust/zerocopy-0.8.54/LICENSE-BSD
@@ -0,0 +1,24 @@
+Copyright 2019 The Fuchsia Authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pyamplicol/licenses/rust/zerocopy-0.8.54/LICENSE-MIT b/pyamplicol/licenses/rust/zerocopy-0.8.54/LICENSE-MIT
new file mode 100644
index 0000000000..26e15216cd
--- /dev/null
+++ b/pyamplicol/licenses/rust/zerocopy-0.8.54/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright 2023 The Fuchsia Authors
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
diff --git a/pyamplicol/licenses/rust/zmij-1.0.23/LICENSE-MIT b/pyamplicol/licenses/rust/zmij-1.0.23/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/pyamplicol/licenses/rust/zmij-1.0.23/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/pyamplicol/licenses/ufo-model-loader.txt b/pyamplicol/licenses/ufo-model-loader.txt
new file mode 100644
index 0000000000..7a3ea73b49
--- /dev/null
+++ b/pyamplicol/licenses/ufo-model-loader.txt
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Valentin Hirschi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/pyamplicol/pyproject.toml b/pyamplicol/pyproject.toml
new file mode 100644
index 0000000000..ee39907fa0
--- /dev/null
+++ b/pyamplicol/pyproject.toml
@@ -0,0 +1,226 @@
+# SPDX-License-Identifier: 0BSD
+
+[build-system]
+requires = [
+  "maturin==1.15.0",
+  "packaging==26.3",
+]
+build-backend = "_pyamplicol_build"
+backend-path = ["build_backend"]
+
+[project]
+name = "pyamplicol"
+dynamic = ["version"]
+description = "Generator using current recursion to build fast color-ordered matrix-element evaluators"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "0BSD"
+license-files = [
+  "LICENSE",
+  "THIRD_PARTY_NOTICES.md",
+  "licenses/*",
+  "licenses/**/*",
+]
+authors = [
+  { name = "Rikkert Frederix", email = "rikkert.frederix@thep.lu.se" },
+  { name = "Valentin Hirschi", email = "valentin.hirschi@gmail.com" },
+  { name = "Timea Vitos", email = "timea.vitos@thep.lu.se" },
+]
+keywords = [
+  "high-energy physics",
+  "matrix elements",
+  "UFO",
+  "Symbolica",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: Zero-Clause BSD (0BSD)",
+  "Operating System :: MacOS :: MacOS X",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Rust",
+  "Topic :: Scientific/Engineering :: Physics",
+  "Typing :: Typed",
+]
+dependencies = [
+  "colorama==0.4.6",
+  "numpy==2.4.6",
+  "platformdirs==4.12.2",
+  "prettytable==3.18.0",
+  "progressbar2==4.6.0",
+  "six==1.17.0",
+  "symbolica==3.0.0",
+  "tomli-w==1.2.0",
+  "ufo-model-loader==1.0.0",
+]
+
+[project.optional-dependencies]
+test = [
+  "build>=1.2,<2",
+  "jsonschema>=4.22,<5",
+  "maturin==1.15.0",
+  "mypy>=1.13,<2",
+  "pytest>=8.3,<9",
+  "ruff>=0.9,<1",
+  "twine>=6,<7",
+  "wheel>=0.45,<1",
+]
+docs = [
+  "pypdf>=5,<6",
+]
+fft-profiling = [
+  "matplotlib==3.11.2",
+  "reportlab==4.5.1",
+]
+
+[project.scripts]
+pyamplicol = "pyamplicol.cli:main"
+rusticol-config = "rusticol_config:main"
+
+[project.urls]
+Homepage = "https://github.com/MadGraphTeam/pyamplicol"
+Documentation = "https://madgraph.org/pyamplicol/"
+Issues = "https://github.com/MadGraphTeam/pyamplicol/issues"
+Source = "https://github.com/MadGraphTeam/pyamplicol"
+
+[tool.maturin]
+manifest-path = "rust/crates/rusticol-python/Cargo.toml"
+python-source = "src"
+python-packages = ["pyamplicol", "rusticol_config"]
+module-name = "pyamplicol._rusticol"
+bindings = "pyo3"
+features = ["extension-module", "numpy"]
+locked = true
+strip = true
+compatibility = "manylinux_2_28"
+auditwheel = "repair"
+include = [
+  { path = "LICENSE", format = ["sdist"] },
+  { path = "licenses/**/*", format = ["sdist"] },
+  { path = "THIRD_PARTY_NOTICES.md", format = ["sdist"] },
+  { path = "README.md", format = ["sdist"] },
+  { path = "Cargo.lock", format = ["sdist"] },
+  { path = "Cargo.toml", format = ["sdist"] },
+  { path = "rust-toolchain.toml", format = ["sdist"] },
+  { path = "justfile", format = ["sdist"] },
+  { path = "build_backend/**/*", format = ["sdist"] },
+  { path = "dependencies/release-lock.toml", format = ["sdist"] },
+  { path = "docs/README.md", format = ["sdist"] },
+  { path = "docs/correlators.md", format = ["sdist"] },
+  { path = "docs/correlator-conventions.md", format = ["sdist"] },
+  { path = "docs/user/**/*", format = ["sdist"] },
+  { path = "examples/**/*", format = ["sdist"] },
+  { path = "rust/**/*", format = ["sdist"] },
+  { path = "schemas/**/*", format = ["sdist"] },
+  { path = "source_hash.py", format = ["sdist"] },
+  { path = "tests/**/*", format = ["sdist"] },
+  { path = "tools/ci/__init__.py", format = ["sdist"] },
+  { path = "tools/ci/memory_watchdog.py", format = ["sdist"] },
+  { path = "tools/developer/**/*", format = ["sdist"] },
+  { path = "tools/fft_profiling/**/*", format = ["sdist"] },
+  { path = "tools/performance_report/**/*", format = ["sdist"] },
+  { path = "tools/release/**/*", format = ["sdist"] },
+  { path = "tools/typing/**/*", format = ["sdist"] },
+  { path = "_sdk/**/*", from = "out-dir", to = "pyamplicol/", crate-name = "rusticol-python" },
+]
+exclude = [
+  "**/__pycache__/**",
+  "**/*.pyc",
+  "build_backend/python_lock.py",
+  "dependencies/checkouts/**",
+  "dependencies/contributor-lock.toml",
+  "dependencies/install_dependencies.py",
+  "dependencies/python-runtime-lock.toml",
+  ".pyamplicol-build-dependencies/**",
+  "flake.nix",
+  "outputs/**",
+  "PYPI_DEPLOYMENT_TEST/**",
+  "release_assets/**",
+  "target/**",
+]
+
+[tool.maturin.sbom]
+rust = false
+auditwheel = false
+
+[tool.pyamplicol.native-build]
+schema-version = 1
+
+[tool.pyamplicol.native-build.rust-path-remapping]
+candidate-checkouts = "/pyamplicol/dependencies"
+checkout = "/pyamplicol/checkout"
+source = "/pyamplicol/source"
+build = "/pyamplicol/build"
+sysroot = "/rust/sysroot"
+
+[tool.pyamplicol.native-build.macos]
+cc = "/usr/bin/clang"
+cxx = "/usr/bin/clang++"
+deployment-target = "11.0"
+
+[tool.pyamplicol.native-build.sdk]
+package = "rusticol-capi"
+profile = "release"
+# Fat LTO folds libstd into referenced static-library objects, which makes the
+# archive impossible to link from a Rust consumer on ELF without duplicate symbols.
+rustc-codegen-arguments = ["-C", "lto=off", "-C", "embed-bitcode=no"]
+
+[tool.pytest.ini_options]
+addopts = "-ra --import-mode=importlib"
+pythonpath = ["src"]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+exclude = [
+  "src/pyamplicol/assets/models/ufo/**",
+]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+mypy_path = "src"
+explicit_package_bases = true
+follow_imports = "silent"
+files = [
+  "src/pyamplicol/__init__.py",
+  "src/pyamplicol/api",
+  "src/pyamplicol/config/__init__.py",
+  "src/pyamplicol/config/errors.py",
+  "src/pyamplicol/config/models.py",
+  "src/pyamplicol/config/registry.py",
+  "src/pyamplicol/reporting",
+  "src/pyamplicol/runtime",
+  "tools/typing/check_public_typing.py",
+  "tests/typing/consumer_public_api.py",
+  "tests/typing/test_typing_gate.py",
+]
+exclude = [
+  "^src/pyamplicol/assets/models/ufo/",
+  "^src/pyamplicol/assets/api_templates/",
+]
+show_error_codes = true
+warn_unused_configs = true
+
+# Symbolica 3.0.0's FactorProjector overloads crash mypy 1.20.2. These
+# implementation-only tensor bindings are exercised by numerical tests;
+# keep checking all pyAmpliCol public types and the other Symbolica stubs.
+[[tool.mypy.overrides]]
+module = "symbolica.community.tensor"
+follow_imports = "skip"
+follow_imports_for_stubs = true
+
+[tool.coverage.run]
+source = ["pyamplicol"]
+
+[tool.coverage.report]
+show_missing = true
diff --git a/pyamplicol/release_assets/prepared_models/README.md b/pyamplicol/release_assets/prepared_models/README.md
new file mode 100644
index 0000000000..396ddc51e4
--- /dev/null
+++ b/pyamplicol/release_assets/prepared_models/README.md
@@ -0,0 +1,26 @@
+<!-- SPDX-License-Identifier: 0BSD -->
+
+# Release Prepared-Model Store
+
+This source-only directory owns the architecture-specific portable JIT O2
+prepared-model pairs for both `built-in-sm` and `built-in-sm-heft`. It is
+deliberately outside the Python package: contributor builds continue to use the
+candidate assets under `src/pyamplicol/assets/prepared_models`.
+
+Generate the release pairs with the manual `release-prepared-models.yml`
+workflow, then copy only these eight files from its architecture artifacts into
+this directory:
+
+- `built-in-sm-heft-jit-o2-aarch64.metadata.json`
+- `built-in-sm-heft-jit-o2-aarch64.pyamplicol-model`
+- `built-in-sm-heft-jit-o2-x86_64.metadata.json`
+- `built-in-sm-heft-jit-o2-x86_64.pyamplicol-model`
+- `built-in-sm-jit-o2-aarch64.metadata.json`
+- `built-in-sm-jit-o2-aarch64.pyamplicol-model`
+- `built-in-sm-jit-o2-x86_64.metadata.json`
+- `built-in-sm-jit-o2-x86_64.pyamplicol-model`
+
+Normal release builds fail until all eight files exist and match the active
+release lock. The build overlay projects them into the canonical package asset
+directory and removes this auxiliary store before creating a wheel or source
+distribution.
diff --git a/pyamplicol/run_fft_profiling_render.sh b/pyamplicol/run_fft_profiling_render.sh
new file mode 100755
index 0000000000..78060834df
--- /dev/null
+++ b/pyamplicol/run_fft_profiling_render.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ -z "${IN_NIX_SHELL:-}" && -z "${PYAMPLICOL_FFT_NO_NIX:-}" ]]; then
+  exec nix develop --quiet --command "$0" "$@"
+fi
+
+workspace_root="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"
+
+exec "$workspace_root/.venv/bin/python" \
+  "$workspace_root/tools/fft_profiling/fft_profiling.py" \
+  --output "$workspace_root/fft_profiling" \
+  --render \
+  "$@"
diff --git a/pyamplicol/rust-toolchain.toml b/pyamplicol/rust-toolchain.toml
new file mode 100644
index 0000000000..af72c57c0e
--- /dev/null
+++ b/pyamplicol/rust-toolchain.toml
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: 0BSD
+
+[toolchain]
+channel = "1.97.1"
+profile = "minimal"
+components = ["clippy", "rustfmt"]
diff --git a/pyamplicol/rust/crates/rusticol-capi/Cargo.toml b/pyamplicol/rust/crates/rusticol-capi/Cargo.toml
new file mode 100644
index 0000000000..a26b82216a
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-capi/Cargo.toml
@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: 0BSD
+
+[package]
+name = "rusticol-capi"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+build = "build.rs"
+
+[lib]
+name = "rusticol_capi"
+crate-type = ["staticlib", "rlib"]
+
+[dependencies]
+rusticol-core = { path = "../rusticol-core", default-features = false, features = ["f64-compiled", "f64-symjit"] }
+serde_json.workspace = true
diff --git a/pyamplicol/rust/crates/rusticol-capi/build.rs b/pyamplicol/rust/crates/rusticol-capi/build.rs
new file mode 100644
index 0000000000..c79273d76a
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-capi/build.rs
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+    let output = PathBuf::from(env::var_os("OUT_DIR").expect("OUT_DIR"));
+    let profile = env::var("PROFILE").expect("PROFILE");
+    let target = env::var("TARGET").expect("TARGET");
+    let payload = format!(
+        "{{\n  \"schema_version\": 1,\n  \"target\": \"{target}\",\n  \"profile\": \"{profile}\",\n  \"native_static_libs\": []\n}}\n"
+    );
+    fs::write(output.join("rusticol-link.json"), payload).expect("write link metadata");
+}
diff --git a/pyamplicol/rust/crates/rusticol-capi/fortran/rusticol.f90 b/pyamplicol/rust/crates/rusticol-capi/fortran/rusticol.f90
new file mode 100644
index 0000000000..7967400c7f
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-capi/fortran/rusticol.f90
@@ -0,0 +1,1430 @@
+! SPDX-License-Identifier: 0BSD
+
+module rusticol
+  use, intrinsic :: iso_c_binding
+  use, intrinsic :: iso_fortran_env, only: error_unit
+  implicit none
+  private
+
+  integer(c_int), parameter, public :: RUSTICOL_STATUS_OK = 0_c_int
+  integer(c_int), parameter, public :: RUSTICOL_STATUS_INVALID_ARGUMENT = 1_c_int
+  integer(c_int), parameter, public :: RUSTICOL_STATUS_BUFFER_TOO_SMALL = 2_c_int
+  integer(c_int), parameter, public :: RUSTICOL_STATUS_RUNTIME_ERROR = 3_c_int
+  integer(c_int), parameter, public :: RUSTICOL_STATUS_PANIC = 4_c_int
+
+  integer(c_int32_t), parameter, public :: RUSTICOL_WARM_UP_EVENT_START = 0_c_int32_t
+  integer(c_int32_t), parameter, public :: RUSTICOL_WARM_UP_EVENT_UPDATE = 1_c_int32_t
+  integer(c_int32_t), parameter, public :: RUSTICOL_WARM_UP_EVENT_END = 2_c_int32_t
+  integer(c_int32_t), parameter, public :: RUSTICOL_WARM_UP_STAGE_PROCESS_PREPARATION = &
+      0_c_int32_t
+  integer(c_int32_t), parameter, public :: RUSTICOL_WARM_UP_STAGE_QUERY_FAMILY = 1_c_int32_t
+  integer(c_int32_t), parameter, public :: RUSTICOL_WARM_UP_STAGE_FAMILY_FINALIZATION = &
+      2_c_int32_t
+  integer(c_int32_t), parameter, public :: RUSTICOL_WARM_UP_STAGE_FIRST_EVALUATION = &
+      3_c_int32_t
+
+  type, bind(C), public :: rusticol_warm_up_progress_event
+    integer(c_int32_t) :: schema_version
+    integer(c_int32_t) :: kind
+    integer(c_int32_t) :: stage
+    integer(c_int32_t) :: reserved
+    integer(c_int64_t) :: completed
+    integer(c_int64_t) :: total
+    real(c_double) :: elapsed_seconds
+    integer(c_int64_t) :: current_rss_bytes
+    integer(c_int64_t) :: peak_rss_bytes
+    integer(c_int64_t) :: workers
+    integer(c_int32_t) :: current_rss_available
+    integer(c_int32_t) :: peak_rss_available
+  end type rusticol_warm_up_progress_event
+
+  type, bind(C), public :: rusticol_warm_up_result
+    integer(c_int32_t) :: schema_version
+    integer(c_int32_t) :: reserved
+    real(c_double) :: elapsed_seconds
+    integer(c_int64_t) :: query_count
+    integer(c_int64_t) :: warmed_query_count
+    integer(c_int64_t) :: current_rss_bytes
+    integer(c_int64_t) :: peak_rss_bytes
+    integer(c_int32_t) :: current_rss_available
+    integer(c_int32_t) :: peak_rss_available
+    integer(c_int32_t) :: already_warm
+    integer(c_int32_t) :: first_evaluation_completed
+  end type rusticol_warm_up_result
+
+  type, public :: rusticol_string
+    character(len=:), allocatable :: value
+  end type rusticol_string
+
+  type, public :: rusticol_external_particle
+    integer(c_size_t) :: index = 0_c_size_t
+    integer(c_int32_t) :: pdg = 0_c_int32_t
+  end type rusticol_external_particle
+
+  type, public :: rusticol_helicity_configuration
+    character(len=:), allocatable :: id
+    integer(c_int32_t), allocatable :: helicities(:)
+  end type rusticol_helicity_configuration
+
+  type, public :: rusticol_color_component
+    character(len=:), allocatable :: id
+    character(len=:), allocatable :: kind
+    integer(c_size_t), allocatable :: word(:)
+  end type rusticol_color_component
+
+  type, public :: rusticol_model_parameter
+    character(len=:), allocatable :: name
+  end type rusticol_model_parameter
+
+  type, public :: rusticol_spin_correlation_vector
+    integer(c_size_t) :: leg = 0_c_size_t ! One-based public external leg.
+    ! (E,px,py,pz) by point; a single point broadcasts over the batch.
+    complex(c_double_complex), allocatable :: components(:, :)
+  end type rusticol_spin_correlation_vector
+
+  type, public :: rusticol_correlated_request
+    character(len=:), allocatable :: color_correlation ! Unallocated means "born".
+    ! Unallocated inherits the setter; allocated size zero uses physical helicities.
+    type(rusticol_spin_correlation_vector), allocatable :: spin_vectors(:)
+  end type rusticol_correlated_request
+
+  type, bind(C) :: c_spin_correlation_vector
+    integer(c_size_t) :: leg, point_count
+    type(c_ptr) :: components
+    integer(c_size_t) :: component_count
+  end type c_spin_correlation_vector
+
+  type, bind(C) :: c_correlated_request
+    type(c_ptr) :: color_correlation, spin_vectors
+    integer(c_size_t) :: spin_vector_count
+    integer(c_int32_t) :: use_default_spin_vectors
+  end type c_correlated_request
+
+  ! Explicit real/imaginary transport avoids assumptions about COMPLEX layout.
+  type :: spin_correlation_storage
+    real(c_double), allocatable :: components(:)
+    type(c_spin_correlation_vector), allocatable :: vectors(:)
+    character(kind=c_char), allocatable :: id(:)
+  end type spin_correlation_storage
+
+  type, public :: rusticol_runtime
+    private
+    type(c_ptr) :: handle = c_null_ptr
+  contains
+    final :: rusticol_finalize
+    procedure, public :: load => rusticol_load
+    procedure, public :: save => rusticol_save
+    procedure, public :: load_cache => rusticol_load_cache
+    procedure, public :: close => rusticol_close
+    procedure, public :: is_loaded => rusticol_is_loaded
+    procedure, public :: process => rusticol_process
+    procedure, public :: process_key => rusticol_process_key
+    procedure, public :: representative_process_key => rusticol_representative_process_key
+    procedure, public :: color_accuracy => rusticol_color_accuracy
+    procedure, public :: execution_mode => rusticol_execution_mode
+    procedure, public :: metadata_json => rusticol_metadata_json
+    procedure, public :: physics_json => rusticol_physics_json
+    procedure, public :: external_particles => rusticol_external_particles
+    procedure, public :: external_permutation => rusticol_external_permutation
+    procedure, public :: load_kinematics_json => rusticol_load_kinematics_json
+    procedure, public :: helicities => rusticol_helicities
+    procedure, public :: colors => rusticol_colors
+    procedure, public :: model_parameters => rusticol_model_parameters
+    procedure, public :: evaluate => rusticol_evaluate
+    procedure, public :: color_correlation_ids => rusticol_color_correlation_ids
+    procedure, public :: color_correlation_catalogue_json => rusticol_color_correlation_catalogue_json
+    procedure, public :: set_spin_correlation_vectors => rusticol_set_spin_correlation_vectors
+    procedure, public :: evaluate_correlated_many => rusticol_evaluate_correlated_many
+    procedure, public :: evaluate_correlated => rusticol_evaluate_correlated
+    procedure, public :: warm_up => rusticol_warm_up
+    procedure, public :: evaluate_selected => rusticol_evaluate_selected
+    procedure, public :: evaluate_resolved => rusticol_evaluate_resolved
+    procedure, public :: set_model_parameter => rusticol_set_model_parameter
+    procedure, public :: set_model_parameters => rusticol_set_model_parameters
+    procedure, public :: set_model_parameters_json => rusticol_set_model_parameters_json
+    procedure, public :: mute_warnings => rusticol_mute_warnings
+    procedure, public :: unmute_warnings => rusticol_unmute_warnings
+    procedure, public :: take_warnings_json => rusticol_take_warnings_json
+  end type rusticol_runtime
+
+  interface
+    function c_rusticol_abi_version() bind(C, name="rusticol_abi_version") result(version)
+      import :: c_int32_t
+      integer(c_int32_t) :: version
+    end function c_rusticol_abi_version
+
+    function c_rusticol_last_error_message(buffer, capacity, required) &
+        bind(C, name="rusticol_last_error_message") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_last_error_message
+
+    function c_rusticol_runtime_load(process_dir, process_key, model_parameters, output) &
+        bind(C, name="rusticol_runtime_load") result(status)
+      import :: c_ptr, c_int
+      type(c_ptr), value :: process_dir
+      type(c_ptr), value :: process_key
+      type(c_ptr), value :: model_parameters
+      type(c_ptr) :: output
+      integer(c_int) :: status
+    end function c_rusticol_runtime_load
+
+    function c_rusticol_runtime_free(handle) bind(C, name="rusticol_runtime_free") result(status)
+      import :: c_ptr, c_int
+      type(c_ptr), value :: handle
+      integer(c_int) :: status
+    end function c_rusticol_runtime_free
+
+    function c_rusticol_runtime_save(handle, path) bind(C, name="rusticol_runtime_save") result(status)
+      import :: c_ptr, c_int
+      type(c_ptr), value :: handle, path
+      integer(c_int) :: status
+    end function c_rusticol_runtime_save
+
+    function c_rusticol_runtime_load_cache(handle, path) &
+        bind(C, name="rusticol_runtime_load_cache") result(status)
+      import :: c_ptr, c_int
+      type(c_ptr), value :: handle, path
+      integer(c_int) :: status
+    end function c_rusticol_runtime_load_cache
+
+    function c_rusticol_runtime_metadata_json(handle, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_metadata_json") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_metadata_json
+
+    function c_rusticol_runtime_execution_mode(handle, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_execution_mode") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_execution_mode
+
+    function c_rusticol_runtime_physics_json(handle, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_physics_json") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_physics_json
+
+    function c_rusticol_runtime_process(handle, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_process") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_process
+
+    function c_rusticol_runtime_process_key(handle, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_process_key") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_process_key
+
+    function c_rusticol_runtime_representative_process_key(handle, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_representative_process_key") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_representative_process_key
+
+    function c_rusticol_runtime_color_accuracy(handle, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_color_accuracy") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_color_accuracy
+
+    function c_rusticol_runtime_external_count(handle, output) &
+        bind(C, name="rusticol_runtime_external_count") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle
+      integer(c_size_t) :: output
+      integer(c_int) :: status
+    end function c_rusticol_runtime_external_count
+
+    function c_rusticol_runtime_external_pdg(handle, index, output) &
+        bind(C, name="rusticol_runtime_external_pdg") result(status)
+      import :: c_ptr, c_size_t, c_int32_t, c_int
+      type(c_ptr), value :: handle
+      integer(c_size_t), value :: index
+      integer(c_int32_t) :: output
+      integer(c_int) :: status
+    end function c_rusticol_runtime_external_pdg
+
+    function c_rusticol_runtime_external_permutation(handle, output, capacity, required) &
+        bind(C, name="rusticol_runtime_external_permutation") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, output
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_external_permutation
+
+    function c_rusticol_runtime_load_kinematics_json(handle, path, output, capacity, required) &
+        bind(C, name="rusticol_runtime_load_kinematics_json") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, path, output
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_load_kinematics_json
+
+    function c_rusticol_runtime_helicity_count(handle, output) &
+        bind(C, name="rusticol_runtime_helicity_count") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle
+      integer(c_size_t) :: output
+      integer(c_int) :: status
+    end function c_rusticol_runtime_helicity_count
+
+    function c_rusticol_runtime_helicity_id(handle, index, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_helicity_id") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: index, capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_helicity_id
+
+    function c_rusticol_runtime_helicity_vector(handle, index, output, capacity, required) &
+        bind(C, name="rusticol_runtime_helicity_vector") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, output
+      integer(c_size_t), value :: index, capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_helicity_vector
+
+    function c_rusticol_runtime_color_count(handle, output) &
+        bind(C, name="rusticol_runtime_color_count") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle
+      integer(c_size_t) :: output
+      integer(c_int) :: status
+    end function c_rusticol_runtime_color_count
+
+    function c_rusticol_runtime_color_id(handle, index, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_color_id") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: index, capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_color_id
+
+    function c_rusticol_runtime_color_kind(handle, index, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_color_kind") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: index, capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_color_kind
+
+    function c_rusticol_runtime_color_word(handle, index, output, capacity, required) &
+        bind(C, name="rusticol_runtime_color_word") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, output
+      integer(c_size_t), value :: index, capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_color_word
+
+    function c_rusticol_runtime_model_parameter_count(handle, output) &
+        bind(C, name="rusticol_runtime_model_parameter_count") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle
+      integer(c_size_t) :: output
+      integer(c_int) :: status
+    end function c_rusticol_runtime_model_parameter_count
+
+    function c_rusticol_runtime_model_parameter_name(handle, index, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_model_parameter_name") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: index, capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_model_parameter_name
+
+    function c_rusticol_runtime_resolved_shape(handle, helicity_ids, helicity_count, &
+        color_ids, color_count, output_helicity_count, output_color_count) &
+        bind(C, name="rusticol_runtime_resolved_shape") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, helicity_ids, color_ids
+      integer(c_size_t), value :: helicity_count, color_count
+      integer(c_size_t) :: output_helicity_count, output_color_count
+      integer(c_int) :: status
+    end function c_rusticol_runtime_resolved_shape
+
+    function c_rusticol_runtime_warm_up_f64_with_cores(handle, momenta, momentum_count, &
+        helicity_ids, helicity_count, color_ids, color_count, n_cores, &
+        progress_callback, progress_user_data, output) &
+        bind(C, name="rusticol_runtime_warm_up_f64_with_cores") result(status)
+      import :: c_ptr, c_funptr, c_size_t, c_int, rusticol_warm_up_result
+      type(c_ptr), value :: handle, momenta, helicity_ids, color_ids
+      integer(c_size_t), value :: momentum_count, helicity_count, color_count, n_cores
+      type(c_funptr), value :: progress_callback
+      type(c_ptr), value :: progress_user_data
+      type(rusticol_warm_up_result) :: output
+      integer(c_int) :: status
+    end function c_rusticol_runtime_warm_up_f64_with_cores
+
+    function c_rusticol_color_correlation_count(handle, output) &
+        bind(C, name="rusticol_runtime_color_correlation_count") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle
+      integer(c_size_t) :: output
+      integer(c_int) :: status
+    end function c_rusticol_color_correlation_count
+
+    function c_rusticol_color_correlation_id(handle, index, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_color_correlation_id") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: index, capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_color_correlation_id
+
+    function c_rusticol_color_correlation_catalogue_json(handle, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_color_correlation_catalogue_json") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_color_correlation_catalogue_json
+
+    function c_rusticol_set_spin_correlation_vectors(handle, vectors, vector_count) &
+        bind(C, name="rusticol_runtime_set_spin_correlation_vectors_f64") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, vectors
+      integer(c_size_t), value :: vector_count
+      integer(c_int) :: status
+    end function c_rusticol_set_spin_correlation_vectors
+
+    function c_rusticol_evaluate_correlated_many(handle, momenta, momentum_count, point_count, &
+        requests, request_count, helicity_ids, helicity_count, output, output_capacity) &
+        bind(C, name="rusticol_runtime_evaluate_correlated_many_f64") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, momenta, requests, helicity_ids, output
+      integer(c_size_t), value :: momentum_count, point_count, request_count
+      integer(c_size_t), value :: helicity_count, output_capacity
+      integer(c_int) :: status
+    end function c_rusticol_evaluate_correlated_many
+
+    function c_rusticol_runtime_evaluate_f64(handle, momenta, momentum_count, point_count, &
+        output, output_capacity) bind(C, name="rusticol_runtime_evaluate_f64") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, momenta, output
+      integer(c_size_t), value :: momentum_count, point_count, output_capacity
+      integer(c_int) :: status
+    end function c_rusticol_runtime_evaluate_f64
+
+    function c_rusticol_runtime_evaluate_selected_f64(handle, momenta, momentum_count, &
+        point_count, helicity_ids, helicity_count, color_ids, color_count, &
+        helicity_by_point, helicity_by_point_count, color_flow_by_point, &
+        color_flow_by_point_count, &
+        output, output_capacity) bind(C, name="rusticol_runtime_evaluate_selected_f64") &
+        result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, momenta, helicity_ids, color_ids
+      type(c_ptr), value :: helicity_by_point, color_flow_by_point, output
+      integer(c_size_t), value :: momentum_count, point_count, helicity_count, color_count
+      integer(c_size_t), value :: helicity_by_point_count, color_flow_by_point_count
+      integer(c_size_t), value :: output_capacity
+      integer(c_int) :: status
+    end function c_rusticol_runtime_evaluate_selected_f64
+
+    function c_rusticol_runtime_evaluate_resolved_f64(handle, momenta, momentum_count, &
+        point_count, helicity_ids, helicity_count, color_ids, color_count, output, &
+        output_capacity, output_helicity_count, output_color_count) &
+        bind(C, name="rusticol_runtime_evaluate_resolved_f64") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, momenta, helicity_ids, color_ids, output
+      integer(c_size_t), value :: momentum_count, point_count, helicity_count, color_count
+      integer(c_size_t), value :: output_capacity
+      integer(c_size_t) :: output_helicity_count, output_color_count
+      integer(c_int) :: status
+    end function c_rusticol_runtime_evaluate_resolved_f64
+
+    function c_rusticol_runtime_set_model_parameter(handle, name, real, imaginary) &
+        bind(C, name="rusticol_runtime_set_model_parameter") result(status)
+      import :: c_ptr, c_double, c_int
+      type(c_ptr), value :: handle, name
+      real(c_double), value :: real, imaginary
+      integer(c_int) :: status
+    end function c_rusticol_runtime_set_model_parameter
+
+    function c_rusticol_runtime_set_model_parameters(handle, names, real, imaginary, count) &
+        bind(C, name="rusticol_runtime_set_model_parameters") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, names, real, imaginary
+      integer(c_size_t), value :: count
+      integer(c_int) :: status
+    end function c_rusticol_runtime_set_model_parameters
+
+    function c_rusticol_runtime_set_model_parameters_json(handle, path) &
+        bind(C, name="rusticol_runtime_set_model_parameters_json") result(status)
+      import :: c_ptr, c_int
+      type(c_ptr), value :: handle, path
+      integer(c_int) :: status
+    end function c_rusticol_runtime_set_model_parameters_json
+
+    function c_rusticol_runtime_mute_warnings(handle, muted) &
+        bind(C, name="rusticol_runtime_mute_warnings") result(status)
+      import :: c_ptr, c_int
+      type(c_ptr), value :: handle
+      integer(c_int), value :: muted
+      integer(c_int) :: status
+    end function c_rusticol_runtime_mute_warnings
+
+    function c_rusticol_runtime_take_warnings_json(handle, buffer, capacity, required) &
+        bind(C, name="rusticol_runtime_take_warnings_json") result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_rusticol_runtime_take_warnings_json
+  end interface
+
+  abstract interface
+    function rusticol_warm_up_progress_callback(event, user_data) bind(C) result(keep_going)
+      import :: rusticol_warm_up_progress_event, c_ptr, c_int
+      type(rusticol_warm_up_progress_event), intent(in) :: event
+      type(c_ptr), value :: user_data
+      integer(c_int) :: keep_going
+    end function rusticol_warm_up_progress_callback
+
+    function c_runtime_string_function(handle, buffer, capacity, required) result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_runtime_string_function
+
+    function c_runtime_indexed_string_function(handle, index, buffer, capacity, required) &
+        result(status)
+      import :: c_ptr, c_size_t, c_int
+      type(c_ptr), value :: handle, buffer
+      integer(c_size_t), value :: index, capacity
+      integer(c_size_t) :: required
+      integer(c_int) :: status
+    end function c_runtime_indexed_string_function
+  end interface
+
+  public :: rusticol_abi_version, rusticol_last_error, rusticol_warm_up_progress_callback
+
+contains
+
+  function rusticol_abi_version() result(version)
+    integer(c_int32_t) :: version
+    version = c_rusticol_abi_version()
+  end function rusticol_abi_version
+
+  subroutine build_c_string(value, buffer)
+    character(len=*), intent(in) :: value
+    character(kind=c_char), allocatable, target, intent(out) :: buffer(:)
+    integer :: index, length
+
+    length = len_trim(value)
+    allocate(buffer(length + 1))
+    do index = 1, length
+      buffer(index) = value(index:index)
+    end do
+    buffer(length + 1) = c_null_char
+  end subroutine build_c_string
+
+  function from_c_string(buffer) result(value)
+    character(kind=c_char), intent(in) :: buffer(:)
+    character(len=:), allocatable :: value
+    integer :: index, length
+
+    length = 0
+    do index = 1, size(buffer)
+      if (buffer(index) == c_null_char) exit
+      length = length + 1
+    end do
+    allocate(character(len=length) :: value)
+    do index = 1, length
+      value(index:index) = buffer(index)
+    end do
+  end function from_c_string
+
+  function rusticol_last_error() result(message)
+    character(len=:), allocatable :: message
+    character(kind=c_char), allocatable, target :: buffer(:)
+    integer(c_size_t) :: required
+    integer(c_int) :: status
+
+    required = 0_c_size_t
+    status = c_rusticol_last_error_message(c_null_ptr, 0_c_size_t, required)
+    if (status /= RUSTICOL_STATUS_OK .or. required == 0_c_size_t) then
+      message = "unknown Rusticol error"
+      return
+    end if
+    allocate(buffer(required))
+    status = c_rusticol_last_error_message(c_loc(buffer(1)), required, required)
+    if (status /= RUSTICOL_STATUS_OK) then
+      message = "could not retrieve Rusticol error"
+    else
+      message = from_c_string(buffer)
+    end if
+  end function rusticol_last_error
+
+  logical function status_ok(status, ierr)
+    integer(c_int), intent(in) :: status
+    integer(c_int), intent(out), optional :: ierr
+
+    if (present(ierr)) ierr = status
+    if (status /= RUSTICOL_STATUS_OK .and. .not. present(ierr)) then
+      write(error_unit, '(A)') rusticol_last_error()
+      error stop 1
+    end if
+    status_ok = status == RUSTICOL_STATUS_OK
+  end function status_ok
+
+  logical function argument_ok(condition, message, ierr)
+    logical, intent(in) :: condition
+    character(len=*), intent(in) :: message
+    integer(c_int), intent(out), optional :: ierr
+
+    argument_ok = condition
+    if (condition) return
+    if (present(ierr)) then
+      ierr = RUSTICOL_STATUS_INVALID_ARGUMENT
+    else
+      write(error_unit, '(A)') message
+      error stop 1
+    end if
+  end function argument_ok
+
+  subroutine rusticol_load(self, process_dir, process_key, model_parameters, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    character(len=*), intent(in) :: process_dir
+    character(len=*), intent(in), optional :: process_key, model_parameters
+    integer(c_int), intent(out), optional :: ierr
+    character(kind=c_char), allocatable, target :: dir_c(:), key_c(:), model_c(:)
+    type(c_ptr) :: key_ptr, model_ptr
+    integer(c_int) :: status
+
+    call self%close()
+    call build_c_string(process_dir, dir_c)
+    key_ptr = c_null_ptr
+    if (present(process_key)) then
+      if (len_trim(process_key) > 0) then
+        call build_c_string(process_key, key_c)
+        key_ptr = c_loc(key_c(1))
+      end if
+    end if
+    model_ptr = c_null_ptr
+    if (present(model_parameters)) then
+      if (len_trim(model_parameters) > 0) then
+        call build_c_string(model_parameters, model_c)
+        model_ptr = c_loc(model_c(1))
+      end if
+    end if
+    status = c_rusticol_runtime_load(c_loc(dir_c(1)), key_ptr, model_ptr, self%handle)
+    if (.not. status_ok(status, ierr)) self%handle = c_null_ptr
+  end subroutine rusticol_load
+
+  ! Save completed OTF cache entries; the generated process output is still required.
+  subroutine rusticol_save(self, path, ierr)
+    class(rusticol_runtime), intent(in) :: self
+    character(len=*), intent(in) :: path
+    integer(c_int), intent(out), optional :: ierr
+    character(kind=c_char), allocatable, target :: path_c(:)
+    integer(c_int) :: status
+
+    if (.not. argument_ok(index(path, achar(0)) == 0, "cache path contains a NUL byte", ierr)) return
+    call build_c_string(path, path_c)
+    status = c_rusticol_runtime_save(self%handle, c_loc(path_c(1)))
+    if (.not. status_ok(status, ierr)) return
+  end subroutine rusticol_save
+
+  ! Load a saved OTF cache into an already-loaded matching process output.
+  subroutine rusticol_load_cache(self, path, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    character(len=*), intent(in) :: path
+    integer(c_int), intent(out), optional :: ierr
+    character(kind=c_char), allocatable, target :: path_c(:)
+    integer(c_int) :: status
+
+    if (.not. argument_ok(index(path, achar(0)) == 0, "cache path contains a NUL byte", ierr)) return
+    call build_c_string(path, path_c)
+    status = c_rusticol_runtime_load_cache(self%handle, c_loc(path_c(1)))
+    if (.not. status_ok(status, ierr)) return
+  end subroutine rusticol_load_cache
+
+  subroutine rusticol_close(self)
+    class(rusticol_runtime), intent(inout) :: self
+    integer(c_int) :: status
+    if (c_associated(self%handle)) then
+      status = c_rusticol_runtime_free(self%handle)
+      self%handle = c_null_ptr
+    end if
+  end subroutine rusticol_close
+
+  subroutine rusticol_finalize(self)
+    type(rusticol_runtime), intent(inout) :: self
+    call self%close()
+  end subroutine rusticol_finalize
+
+  logical function rusticol_is_loaded(self)
+    class(rusticol_runtime), intent(in) :: self
+    rusticol_is_loaded = c_associated(self%handle)
+  end function rusticol_is_loaded
+
+  function runtime_string(self, function, ierr) result(value)
+    class(rusticol_runtime), intent(in) :: self
+    procedure(c_runtime_string_function) :: function
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    character(kind=c_char), allocatable, target :: buffer(:)
+    integer(c_size_t) :: required
+    integer(c_int) :: status
+
+    required = 0_c_size_t
+    status = function(self%handle, c_null_ptr, 0_c_size_t, required)
+    if (.not. status_ok(status, ierr)) then
+      value = ""
+      return
+    end if
+    allocate(buffer(required))
+    status = function(self%handle, c_loc(buffer(1)), required, required)
+    if (.not. status_ok(status, ierr)) then
+      value = ""
+      return
+    end if
+    value = from_c_string(buffer)
+  end function runtime_string
+
+  function indexed_runtime_string(self, index, function, ierr) result(value)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_size_t), intent(in) :: index
+    procedure(c_runtime_indexed_string_function) :: function
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    character(kind=c_char), allocatable, target :: buffer(:)
+    integer(c_size_t) :: required
+    integer(c_int) :: status
+
+    required = 0_c_size_t
+    status = function(self%handle, index, c_null_ptr, 0_c_size_t, required)
+    if (.not. status_ok(status, ierr)) then
+      value = ""
+      return
+    end if
+    allocate(buffer(required))
+    status = function(self%handle, index, c_loc(buffer(1)), required, required)
+    if (.not. status_ok(status, ierr)) then
+      value = ""
+      return
+    end if
+    value = from_c_string(buffer)
+  end function indexed_runtime_string
+
+  function rusticol_process(self, ierr) result(value)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    value = runtime_string(self, c_rusticol_runtime_process, ierr)
+  end function rusticol_process
+
+  function rusticol_process_key(self, ierr) result(value)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    value = runtime_string(self, c_rusticol_runtime_process_key, ierr)
+  end function rusticol_process_key
+
+  function rusticol_representative_process_key(self, ierr) result(value)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    value = runtime_string(self, c_rusticol_runtime_representative_process_key, ierr)
+  end function rusticol_representative_process_key
+
+  function rusticol_color_accuracy(self, ierr) result(value)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    value = runtime_string(self, c_rusticol_runtime_color_accuracy, ierr)
+  end function rusticol_color_accuracy
+
+  function rusticol_execution_mode(self, ierr) result(value)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    value = runtime_string(self, c_rusticol_runtime_execution_mode, ierr)
+  end function rusticol_execution_mode
+
+  function rusticol_metadata_json(self, ierr) result(value)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    value = runtime_string(self, c_rusticol_runtime_metadata_json, ierr)
+  end function rusticol_metadata_json
+
+  function rusticol_physics_json(self, ierr) result(value)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    value = runtime_string(self, c_rusticol_runtime_physics_json, ierr)
+  end function rusticol_physics_json
+
+  function rusticol_external_particles(self, ierr) result(particles)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    type(rusticol_external_particle), allocatable :: particles(:)
+    integer(c_size_t) :: count, index
+    integer(c_int) :: status
+
+    status = c_rusticol_runtime_external_count(self%handle, count)
+    if (.not. status_ok(status, ierr)) then
+      allocate(particles(0))
+      return
+    end if
+    allocate(particles(count))
+    do index = 1, count
+      particles(index)%index = index - 1
+      status = c_rusticol_runtime_external_pdg(self%handle, index - 1, particles(index)%pdg)
+      if (.not. status_ok(status, ierr)) return
+    end do
+  end function rusticol_external_particles
+
+  function rusticol_external_permutation(self, ierr) result(permutation)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    integer(c_size_t), allocatable, target :: permutation(:)
+    integer(c_size_t) :: required
+    integer(c_int) :: status
+
+    required = 0_c_size_t
+    status = c_rusticol_runtime_external_permutation( &
+        self%handle, c_null_ptr, 0_c_size_t, required)
+    if (.not. status_ok(status, ierr)) then
+      allocate(permutation(0))
+      return
+    end if
+    allocate(permutation(required))
+    if (required > 0) then
+      status = c_rusticol_runtime_external_permutation( &
+          self%handle, c_loc(permutation(1)), required, required)
+      if (.not. status_ok(status, ierr)) permutation = 0_c_size_t
+    end if
+  end function rusticol_external_permutation
+
+  subroutine rusticol_load_kinematics_json(self, path, momenta, ierr)
+    class(rusticol_runtime), intent(in) :: self
+    character(len=*), intent(in) :: path
+    real(c_double), allocatable, target, intent(out) :: momenta(:)
+    integer(c_int), intent(out), optional :: ierr
+    character(kind=c_char), allocatable, target :: path_c(:)
+    integer(c_size_t) :: required
+    integer(c_int) :: status
+
+    call build_c_string(path, path_c)
+    required = 0_c_size_t
+    status = c_rusticol_runtime_load_kinematics_json( &
+        self%handle, c_loc(path_c(1)), c_null_ptr, 0_c_size_t, required)
+    if (.not. status_ok(status, ierr)) then
+      allocate(momenta(0))
+      return
+    end if
+    allocate(momenta(required))
+    if (required > 0) then
+      status = c_rusticol_runtime_load_kinematics_json( &
+          self%handle, c_loc(path_c(1)), c_loc(momenta(1)), required, required)
+      if (.not. status_ok(status, ierr)) momenta = 0.0_c_double
+    end if
+  end subroutine rusticol_load_kinematics_json
+
+  function rusticol_helicities(self, ierr) result(items)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    type(rusticol_helicity_configuration), allocatable :: items(:)
+    integer(c_int32_t), allocatable, target :: helicity_values(:)
+    integer(c_size_t) :: count, index, required
+    integer(c_int) :: status
+
+    status = c_rusticol_runtime_helicity_count(self%handle, count)
+    if (.not. status_ok(status, ierr)) then
+      allocate(items(0))
+      return
+    end if
+    allocate(items(count))
+    do index = 1, count
+      items(index)%id = indexed_runtime_string( &
+          self, index - 1, c_rusticol_runtime_helicity_id, ierr)
+      required = 0_c_size_t
+      status = c_rusticol_runtime_helicity_vector( &
+          self%handle, index - 1, c_null_ptr, 0_c_size_t, required)
+      if (.not. status_ok(status, ierr)) return
+      allocate(helicity_values(required))
+      status = c_rusticol_runtime_helicity_vector( &
+          self%handle, index - 1, c_loc(helicity_values(1)), required, required)
+      if (.not. status_ok(status, ierr)) return
+      call move_alloc(helicity_values, items(index)%helicities)
+    end do
+  end function rusticol_helicities
+
+  function rusticol_colors(self, ierr) result(items)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    type(rusticol_color_component), allocatable :: items(:)
+    integer(c_size_t), allocatable, target :: word_values(:)
+    integer(c_size_t) :: count, index, required
+    integer(c_int) :: status
+
+    status = c_rusticol_runtime_color_count(self%handle, count)
+    if (.not. status_ok(status, ierr)) then
+      allocate(items(0))
+      return
+    end if
+    allocate(items(count))
+    do index = 1, count
+      items(index)%id = indexed_runtime_string(self, index - 1, c_rusticol_runtime_color_id, ierr)
+      items(index)%kind = indexed_runtime_string( &
+          self, index - 1, c_rusticol_runtime_color_kind, ierr)
+      required = 0_c_size_t
+      status = c_rusticol_runtime_color_word( &
+          self%handle, index - 1, c_null_ptr, 0_c_size_t, required)
+      if (.not. status_ok(status, ierr)) return
+      allocate(word_values(required))
+      if (required > 0) then
+        status = c_rusticol_runtime_color_word( &
+            self%handle, index - 1, c_loc(word_values(1)), required, required)
+        if (.not. status_ok(status, ierr)) return
+      end if
+      call move_alloc(word_values, items(index)%word)
+    end do
+  end function rusticol_colors
+
+  function rusticol_model_parameters(self, ierr) result(items)
+    class(rusticol_runtime), intent(in) :: self
+    integer(c_int), intent(out), optional :: ierr
+    type(rusticol_model_parameter), allocatable :: items(:)
+    integer(c_size_t) :: count, index
+    integer(c_int) :: status
+
+    status = c_rusticol_runtime_model_parameter_count(self%handle, count)
+    if (.not. status_ok(status, ierr)) then
+      allocate(items(0))
+      return
+    end if
+    allocate(items(count))
+    do index = 1, count
+      items(index)%name = indexed_runtime_string( &
+          self, index - 1, c_rusticol_runtime_model_parameter_name, ierr)
+    end do
+  end function rusticol_model_parameters
+
+  subroutine build_c_string_array(values, storage, pointers)
+    character(len=*), intent(in), optional :: values(:)
+    character(kind=c_char), allocatable, target, intent(out) :: storage(:, :)
+    type(c_ptr), allocatable, target, intent(out) :: pointers(:)
+    integer :: count, index, character_index, max_length
+
+    if (.not. present(values)) then
+      allocate(storage(1, 0), pointers(0))
+      return
+    end if
+    count = size(values)
+    if (count == 0) then
+      allocate(storage(1, 0), pointers(0))
+      return
+    end if
+    max_length = max(1, maxval(len_trim(values)))
+    allocate(storage(max_length + 1, count), pointers(count))
+    storage = c_null_char
+    do index = 1, count
+      do character_index = 1, len_trim(values(index))
+        storage(character_index, index) = values(index)(character_index:character_index)
+      end do
+      pointers(index) = c_loc(storage(1, index))
+    end do
+  end subroutine build_c_string_array
+
+  function rusticol_color_correlation_catalogue_json(self, ierr) result(value)
+    class(rusticol_runtime), intent(inout) :: self
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    value = runtime_string(self, c_rusticol_color_correlation_catalogue_json, ierr)
+  end function rusticol_color_correlation_catalogue_json
+
+  function rusticol_color_correlation_ids(self, ierr) result(items)
+    class(rusticol_runtime), intent(inout) :: self
+    integer(c_int), intent(out), optional :: ierr
+    type(rusticol_string), allocatable :: items(:)
+    integer(c_size_t) :: count, index
+    integer(c_int) :: status
+
+    status = c_rusticol_color_correlation_count(self%handle, count)
+    if (.not. status_ok(status, ierr)) then
+      allocate(items(0))
+      return
+    end if
+    allocate(items(count))
+    do index = 1, count
+      items(index)%value = indexed_runtime_string( &
+          self, index - 1, c_rusticol_color_correlation_id, status)
+      if (.not. status_ok(status, ierr)) return
+    end do
+  end function rusticol_color_correlation_ids
+
+  logical function build_spin_storage(input, storage, ierr) result(ok)
+    type(rusticol_spin_correlation_vector), intent(in) :: input(:)
+    type(spin_correlation_storage), intent(out), target :: storage
+    integer(c_int), intent(out), optional :: ierr
+    integer(c_size_t) :: total, count, offset, first, item, point, component
+
+    ok = .false.
+    total = 0_c_size_t
+    do item = 1, size(input, kind=c_size_t)
+      if (.not. argument_ok(allocated(input(item)%components), &
+          "Each spin vector requires allocated components(4,points)", ierr)) return
+      if (.not. argument_ok(size(input(item)%components, 1) == 4 .and. &
+          size(input(item)%components, 2) > 0, &
+          "Each spin vector requires components(4,points) with at least one point", ierr)) return
+      count = size(input(item)%components, 2, kind=c_size_t)
+      if (.not. argument_ok(count <= (huge(total) - total) / 8_c_size_t, &
+          "Spin-vector component count overflows", ierr)) return
+      total = total + 8_c_size_t * count
+    end do
+    allocate(storage%components(total), storage%vectors(size(input)))
+    offset = 1_c_size_t
+    do item = 1, size(input, kind=c_size_t)
+      first = offset
+      count = size(input(item)%components, 2, kind=c_size_t)
+      do point = 1, count
+        do component = 1, 4
+          storage%components(offset) = real(input(item)%components(component, point), c_double)
+          storage%components(offset + 1) = aimag(input(item)%components(component, point))
+          offset = offset + 2
+        end do
+      end do
+      storage%vectors(item) = c_spin_correlation_vector(input(item)%leg, count, &
+          c_loc(storage%components(first)), 8_c_size_t * count)
+    end do
+    if (present(ierr)) ierr = RUSTICOL_STATUS_OK
+    ok = .true.
+  end function build_spin_storage
+
+  subroutine rusticol_set_spin_correlation_vectors(self, vectors, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    type(rusticol_spin_correlation_vector), intent(in), optional :: vectors(:)
+    integer(c_int), intent(out), optional :: ierr
+    type(spin_correlation_storage), target :: storage
+    type(c_ptr) :: vector_pointer
+    integer(c_size_t) :: count
+    integer(c_int) :: status
+
+    vector_pointer = c_null_ptr
+    count = 0_c_size_t
+    if (present(vectors)) then
+      if (.not. build_spin_storage(vectors, storage, ierr)) return
+      count = size(storage%vectors, kind=c_size_t)
+      if (count > 0) vector_pointer = c_loc(storage%vectors(1))
+    end if
+    status = c_rusticol_set_spin_correlation_vectors(self%handle, vector_pointer, count)
+    if (.not. status_ok(status, ierr)) return
+  end subroutine rusticol_set_spin_correlation_vectors
+
+  subroutine rusticol_evaluate_correlated_many(self, momenta, point_count, requests, values, &
+      helicity_ids, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    real(c_double), intent(in), contiguous, target :: momenta(:)
+    integer(c_size_t), intent(in) :: point_count
+    type(rusticol_correlated_request), intent(in) :: requests(:)
+    ! values(point,request): Fortran ordering matches request-major C output.
+    complex(c_double_complex), allocatable, intent(out) :: values(:, :)
+    character(len=*), intent(in), optional :: helicity_ids(:)
+    integer(c_int), intent(out), optional :: ierr
+    type(spin_correlation_storage), allocatable, target :: storage(:)
+    type(c_correlated_request), allocatable, target :: raw_requests(:)
+    character(kind=c_char), allocatable, target :: helicity_storage(:, :)
+    type(c_ptr), allocatable, target :: helicity_pointers(:)
+    type(c_ptr) :: helicity_pointer
+    real(c_double), allocatable, target :: raw(:)
+    integer(c_size_t) :: request_count, index, point, offset, count
+    integer(c_int) :: status
+
+    allocate(values(0, 0))
+    request_count = size(requests, kind=c_size_t)
+    if (.not. argument_ok(point_count > 0 .and. request_count > 0 .and. size(momenta) > 0, &
+        "Correlated evaluation requires positive point, request and momentum counts", ierr)) return
+    if (.not. argument_ok(point_count <= huge(point_count) / 2_c_size_t / request_count, &
+        "Correlated output dimensions overflow", ierr)) return
+    allocate(storage(request_count), raw_requests(request_count))
+    do index = 1, request_count
+      if (allocated(requests(index)%color_correlation)) then
+        if (.not. argument_ok(scan(requests(index)%color_correlation, c_null_char) == 0, &
+            "Colour correlation ID contains a NUL byte", ierr)) return
+      end if
+      ! build_spin_storage initializes all storage fields, so assign the ID last.
+      raw_requests(index)%spin_vectors = c_null_ptr
+      raw_requests(index)%spin_vector_count = 0_c_size_t
+      raw_requests(index)%use_default_spin_vectors = 1_c_int32_t
+      if (allocated(requests(index)%spin_vectors)) then
+        if (.not. build_spin_storage(requests(index)%spin_vectors, storage(index), ierr)) return
+        count = size(storage(index)%vectors, kind=c_size_t)
+        raw_requests(index)%spin_vector_count = count
+        raw_requests(index)%use_default_spin_vectors = 0_c_int32_t
+        if (count > 0) raw_requests(index)%spin_vectors = c_loc(storage(index)%vectors(1))
+      end if
+      if (allocated(requests(index)%color_correlation)) then
+        call build_c_string(requests(index)%color_correlation, storage(index)%id)
+      else
+        call build_c_string("born", storage(index)%id)
+      end if
+      raw_requests(index)%color_correlation = c_loc(storage(index)%id(1))
+    end do
+    if (present(helicity_ids)) then
+      do index = 1, size(helicity_ids, kind=c_size_t)
+        if (.not. argument_ok(scan(helicity_ids(index), c_null_char) == 0, &
+            "Helicity ID contains a NUL byte", ierr)) return
+      end do
+    end if
+    call build_c_string_array(helicity_ids, helicity_storage, helicity_pointers)
+    helicity_pointer = c_null_ptr
+    if (size(helicity_pointers) > 0) helicity_pointer = c_loc(helicity_pointers(1))
+    allocate(raw(2_c_size_t * point_count * request_count))
+    status = c_rusticol_evaluate_correlated_many(self%handle, c_loc(momenta(1)), &
+        size(momenta, kind=c_size_t), point_count, c_loc(raw_requests(1)), request_count, &
+        helicity_pointer, size(helicity_pointers, kind=c_size_t), c_loc(raw(1)), &
+        size(raw, kind=c_size_t))
+    if (.not. status_ok(status, ierr)) return
+    deallocate(values)
+    allocate(values(point_count, request_count))
+    offset = 1_c_size_t
+    do index = 1, request_count
+      do point = 1, point_count
+        values(point, index) = cmplx(raw(offset), raw(offset + 1), kind=c_double)
+        offset = offset + 2
+      end do
+    end do
+  end subroutine rusticol_evaluate_correlated_many
+
+  subroutine rusticol_evaluate_correlated(self, momenta, point_count, request, values, helicity_ids, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    real(c_double), intent(in), contiguous, target :: momenta(:)
+    integer(c_size_t), intent(in) :: point_count
+    type(rusticol_correlated_request), intent(in) :: request
+    complex(c_double_complex), allocatable, intent(out) :: values(:)
+    character(len=*), intent(in), optional :: helicity_ids(:)
+    integer(c_int), intent(out), optional :: ierr
+    complex(c_double_complex), allocatable :: batch(:, :)
+
+    call self%evaluate_correlated_many(momenta, point_count, [request], batch, helicity_ids, ierr)
+    if (size(batch, 2) == 0) then
+      allocate(values(0))
+    else
+      values = batch(:, 1)
+    end if
+  end subroutine rusticol_evaluate_correlated
+
+  subroutine rusticol_evaluate(self, momenta, point_count, values, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    real(c_double), intent(in), target :: momenta(:)
+    integer(c_size_t), intent(in) :: point_count
+    real(c_double), allocatable, intent(out), target :: values(:)
+    integer(c_int), intent(out), optional :: ierr
+    integer(c_int) :: status
+
+    if (.not. argument_ok(point_count > 0_c_size_t .and. size(momenta) > 0, &
+        "Rusticol evaluation requires positive point and momentum counts", ierr)) then
+      allocate(values(0))
+      return
+    end if
+    allocate(values(point_count))
+    status = c_rusticol_runtime_evaluate_f64( &
+        self%handle, c_loc(momenta(1)), size(momenta, kind=c_size_t), point_count, &
+        c_loc(values(1)), size(values, kind=c_size_t))
+    if (.not. status_ok(status, ierr)) values = 0.0_c_double
+  end subroutine rusticol_evaluate
+
+  subroutine rusticol_warm_up(self, point, result, helicity_ids, color_ids, &
+      progress_callback, progress_user_data, ierr, n_cores)
+    class(rusticol_runtime), intent(inout) :: self
+    real(c_double), intent(in), target :: point(:)
+    type(rusticol_warm_up_result), intent(out) :: result
+    character(len=*), intent(in), optional :: helicity_ids(:), color_ids(:)
+    procedure(rusticol_warm_up_progress_callback), optional :: progress_callback
+    type(c_ptr), intent(in), optional :: progress_user_data
+    integer(c_int), intent(out), optional :: ierr
+    integer, intent(in), optional :: n_cores
+    character(kind=c_char), allocatable, target :: helicity_storage(:, :), color_storage(:, :)
+    type(c_ptr), allocatable, target :: helicity_pointers(:), color_pointers(:)
+    type(c_ptr) :: helicity_pointer, color_pointer, user_data_pointer
+    type(c_funptr) :: callback_pointer
+    integer(c_int) :: status
+    integer(c_size_t) :: construction_cores
+
+    result = rusticol_warm_up_result( &
+        0_c_int32_t, 0_c_int32_t, 0.0_c_double, 0_c_int64_t, 0_c_int64_t, &
+        0_c_int64_t, 0_c_int64_t, 0_c_int32_t, 0_c_int32_t, 0_c_int32_t, 0_c_int32_t)
+    if (.not. argument_ok(size(point) > 0, &
+        "Rusticol warm_up requires exactly one non-empty binary64 point", ierr)) return
+    construction_cores = 0_c_size_t
+    if (present(n_cores)) then
+      if (.not. argument_ok(n_cores > 0, "Rusticol warm_up n_cores must be positive", ierr)) return
+      construction_cores = int(n_cores, c_size_t)
+    end if
+
+    call build_c_string_array(helicity_ids, helicity_storage, helicity_pointers)
+    call build_c_string_array(color_ids, color_storage, color_pointers)
+    helicity_pointer = c_null_ptr
+    if (size(helicity_pointers) > 0) helicity_pointer = c_loc(helicity_pointers(1))
+    color_pointer = c_null_ptr
+    if (size(color_pointers) > 0) color_pointer = c_loc(color_pointers(1))
+
+    callback_pointer = c_null_funptr
+    if (present(progress_callback)) callback_pointer = c_funloc(progress_callback)
+    user_data_pointer = c_null_ptr
+    if (present(progress_user_data)) user_data_pointer = progress_user_data
+
+    status = c_rusticol_runtime_warm_up_f64_with_cores( &
+        self%handle, c_loc(point(1)), size(point, kind=c_size_t), &
+        helicity_pointer, size(helicity_pointers, kind=c_size_t), &
+        color_pointer, size(color_pointers, kind=c_size_t), &
+        construction_cores, callback_pointer, user_data_pointer, result)
+    if (.not. status_ok(status, ierr)) return
+  end subroutine rusticol_warm_up
+
+  subroutine rusticol_evaluate_selected(self, momenta, point_count, values, helicity_ids, &
+      color_ids, helicity_by_point, color_flow_by_point, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    real(c_double), intent(in), target :: momenta(:)
+    integer(c_size_t), intent(in) :: point_count
+    real(c_double), allocatable, intent(out), target :: values(:)
+    character(len=*), intent(in), optional :: helicity_ids(:), color_ids(:)
+    integer(c_int32_t), intent(in), optional, target :: helicity_by_point(:)
+    integer(c_int32_t), intent(in), optional, target :: color_flow_by_point(:)
+    integer(c_int), intent(out), optional :: ierr
+    character(kind=c_char), allocatable, target :: helicity_storage(:, :), color_storage(:, :)
+    type(c_ptr), allocatable, target :: helicity_pointers(:), color_pointers(:)
+    type(c_ptr) :: helicity_pointer, color_pointer
+    type(c_ptr) :: helicity_by_point_pointer, color_flow_by_point_pointer
+    integer(c_size_t) :: helicity_by_point_count, color_flow_by_point_count
+    logical :: has_helicity_ids, has_color_ids
+    integer(c_int) :: status
+
+    if (.not. argument_ok(point_count > 0_c_size_t .and. size(momenta) > 0, &
+        "Rusticol selected evaluation requires positive point and momentum counts", ierr)) then
+      allocate(values(0))
+      return
+    end if
+    has_helicity_ids = .false.
+    if (present(helicity_ids)) has_helicity_ids = size(helicity_ids) > 0
+    has_color_ids = .false.
+    if (present(color_ids)) has_color_ids = size(color_ids) > 0
+
+    helicity_by_point_count = 0_c_size_t
+    helicity_by_point_pointer = c_null_ptr
+    if (present(helicity_by_point)) then
+      helicity_by_point_count = size(helicity_by_point, kind=c_size_t)
+      if (.not. argument_ok(helicity_by_point_count == 0_c_size_t .or. &
+          helicity_by_point_count == point_count, &
+          "helicity_by_point must contain one zero-based selector per point", ierr)) then
+        allocate(values(0))
+        return
+      end if
+      if (.not. argument_ok(helicity_by_point_count == 0_c_size_t .or. &
+          all(helicity_by_point >= 0_c_int32_t), &
+          "helicity_by_point selectors must be nonnegative", ierr)) then
+        allocate(values(0))
+        return
+      end if
+      if (helicity_by_point_count > 0) helicity_by_point_pointer = c_loc(helicity_by_point(1))
+    end if
+
+    color_flow_by_point_count = 0_c_size_t
+    color_flow_by_point_pointer = c_null_ptr
+    if (present(color_flow_by_point)) then
+      color_flow_by_point_count = size(color_flow_by_point, kind=c_size_t)
+      if (.not. argument_ok(color_flow_by_point_count == 0_c_size_t .or. &
+          color_flow_by_point_count == point_count, &
+          "color_flow_by_point must contain one zero-based selector per point", ierr)) then
+        allocate(values(0))
+        return
+      end if
+      if (.not. argument_ok(color_flow_by_point_count == 0_c_size_t .or. &
+          all(color_flow_by_point >= 0_c_int32_t), &
+          "color_flow_by_point selectors must be nonnegative", ierr)) then
+        allocate(values(0))
+        return
+      end if
+      if (color_flow_by_point_count > 0) then
+        color_flow_by_point_pointer = c_loc(color_flow_by_point(1))
+      end if
+    end if
+
+    if (.not. argument_ok(.not. (has_helicity_ids .and. helicity_by_point_count > 0), &
+        "helicity_ids and helicity_by_point are mutually exclusive", ierr)) then
+      allocate(values(0))
+      return
+    end if
+    if (.not. argument_ok(.not. (has_color_ids .and. color_flow_by_point_count > 0), &
+        "color_ids and color_flow_by_point are mutually exclusive", ierr)) then
+      allocate(values(0))
+      return
+    end if
+
+    call build_c_string_array(helicity_ids, helicity_storage, helicity_pointers)
+    call build_c_string_array(color_ids, color_storage, color_pointers)
+    helicity_pointer = c_null_ptr
+    if (size(helicity_pointers) > 0) helicity_pointer = c_loc(helicity_pointers(1))
+    color_pointer = c_null_ptr
+    if (size(color_pointers) > 0) color_pointer = c_loc(color_pointers(1))
+
+    allocate(values(point_count))
+    status = c_rusticol_runtime_evaluate_selected_f64( &
+        self%handle, c_loc(momenta(1)), size(momenta, kind=c_size_t), point_count, &
+        helicity_pointer, size(helicity_pointers, kind=c_size_t), color_pointer, &
+        size(color_pointers, kind=c_size_t), helicity_by_point_pointer, &
+        helicity_by_point_count, color_flow_by_point_pointer, &
+        color_flow_by_point_count, &
+        c_loc(values(1)), size(values, kind=c_size_t))
+    if (.not. status_ok(status, ierr)) values = 0.0_c_double
+  end subroutine rusticol_evaluate_selected
+
+  subroutine rusticol_evaluate_resolved(self, momenta, point_count, values, helicity_ids, &
+      color_ids, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    real(c_double), intent(in), target :: momenta(:)
+    integer(c_size_t), intent(in) :: point_count
+    real(c_double), allocatable, intent(out), target :: values(:, :, :)
+    character(len=*), intent(in), optional :: helicity_ids(:), color_ids(:)
+    integer(c_int), intent(out), optional :: ierr
+    character(kind=c_char), allocatable, target :: helicity_storage(:, :), color_storage(:, :)
+    type(c_ptr), allocatable, target :: helicity_pointers(:), color_pointers(:)
+    type(c_ptr) :: helicity_pointer, color_pointer
+    integer(c_size_t) :: helicity_count, color_count
+    integer(c_int) :: status
+
+    if (.not. argument_ok(point_count > 0_c_size_t .and. size(momenta) > 0, &
+        "Rusticol resolved evaluation requires positive point and momentum counts", ierr)) then
+      allocate(values(0, 0, 0))
+      return
+    end if
+    call build_c_string_array(helicity_ids, helicity_storage, helicity_pointers)
+    call build_c_string_array(color_ids, color_storage, color_pointers)
+    helicity_pointer = c_null_ptr
+    if (size(helicity_pointers) > 0) helicity_pointer = c_loc(helicity_pointers(1))
+    color_pointer = c_null_ptr
+    if (size(color_pointers) > 0) color_pointer = c_loc(color_pointers(1))
+    status = c_rusticol_runtime_resolved_shape( &
+        self%handle, helicity_pointer, size(helicity_pointers, kind=c_size_t), &
+        color_pointer, size(color_pointers, kind=c_size_t), helicity_count, color_count)
+    if (.not. status_ok(status, ierr)) then
+      allocate(values(0, 0, 0))
+      return
+    end if
+    allocate(values(color_count, helicity_count, point_count))
+    status = c_rusticol_runtime_evaluate_resolved_f64( &
+        self%handle, c_loc(momenta(1)), size(momenta, kind=c_size_t), point_count, &
+        helicity_pointer, size(helicity_pointers, kind=c_size_t), color_pointer, &
+        size(color_pointers, kind=c_size_t), c_loc(values(1, 1, 1)), &
+        size(values, kind=c_size_t), helicity_count, color_count)
+    if (.not. status_ok(status, ierr)) values = 0.0_c_double
+  end subroutine rusticol_evaluate_resolved
+
+  subroutine rusticol_set_model_parameter(self, name, real, imaginary, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    character(len=*), intent(in) :: name
+    real(c_double), intent(in) :: real
+    real(c_double), intent(in), optional :: imaginary
+    integer(c_int), intent(out), optional :: ierr
+    character(kind=c_char), allocatable, target :: name_c(:)
+    real(c_double) :: imaginary_value
+    integer(c_int) :: status
+
+    imaginary_value = 0.0_c_double
+    if (present(imaginary)) imaginary_value = imaginary
+    call build_c_string(name, name_c)
+    status = c_rusticol_runtime_set_model_parameter( &
+        self%handle, c_loc(name_c(1)), real, imaginary_value)
+    if (.not. status_ok(status, ierr)) return
+  end subroutine rusticol_set_model_parameter
+
+  subroutine rusticol_set_model_parameters(self, names, real, imaginary, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    character(len=*), intent(in) :: names(:)
+    real(c_double), intent(in), target :: real(:), imaginary(:)
+    integer(c_int), intent(out), optional :: ierr
+    character(kind=c_char), allocatable, target :: storage(:, :)
+    type(c_ptr), allocatable, target :: pointers(:)
+    integer(c_int) :: status
+
+    if (.not. argument_ok(size(names) > 0 .and. size(names) == size(real) .and. &
+        size(names) == size(imaginary), &
+        "Rusticol model parameter arrays must be non-empty and have equal lengths", ierr)) then
+      return
+    end if
+    call build_c_string_array(names, storage, pointers)
+    status = c_rusticol_runtime_set_model_parameters( &
+        self%handle, c_loc(pointers(1)), c_loc(real(1)), c_loc(imaginary(1)), &
+        size(names, kind=c_size_t))
+    if (.not. status_ok(status, ierr)) return
+  end subroutine rusticol_set_model_parameters
+
+  subroutine rusticol_set_model_parameters_json(self, path, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    character(len=*), intent(in) :: path
+    integer(c_int), intent(out), optional :: ierr
+    character(kind=c_char), allocatable, target :: path_c(:)
+    integer(c_int) :: status
+
+    call build_c_string(path, path_c)
+    status = c_rusticol_runtime_set_model_parameters_json(self%handle, c_loc(path_c(1)))
+    if (.not. status_ok(status, ierr)) return
+  end subroutine rusticol_set_model_parameters_json
+
+  subroutine rusticol_mute_warnings(self, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    integer(c_int), intent(out), optional :: ierr
+    integer(c_int) :: status
+    status = c_rusticol_runtime_mute_warnings(self%handle, 1_c_int)
+    if (.not. status_ok(status, ierr)) return
+  end subroutine rusticol_mute_warnings
+
+  subroutine rusticol_unmute_warnings(self, ierr)
+    class(rusticol_runtime), intent(inout) :: self
+    integer(c_int), intent(out), optional :: ierr
+    integer(c_int) :: status
+    status = c_rusticol_runtime_mute_warnings(self%handle, 0_c_int)
+    if (.not. status_ok(status, ierr)) return
+  end subroutine rusticol_unmute_warnings
+
+  function rusticol_take_warnings_json(self, ierr) result(value)
+    class(rusticol_runtime), intent(inout) :: self
+    integer(c_int), intent(out), optional :: ierr
+    character(len=:), allocatable :: value
+    value = runtime_string(self, c_rusticol_runtime_take_warnings_json, ierr)
+  end function rusticol_take_warnings_json
+
+end module rusticol
diff --git a/pyamplicol/rust/crates/rusticol-capi/include/rusticol.h b/pyamplicol/rust/crates/rusticol-capi/include/rusticol.h
new file mode 100644
index 0000000000..36e08c40d1
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-capi/include/rusticol.h
@@ -0,0 +1,458 @@
+/* SPDX-License-Identifier: 0BSD */
+
+#ifndef RUSTICOL_H
+#define RUSTICOL_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RUSTICOL_ABI_VERSION 1u
+
+enum rusticol_status {
+    RUSTICOL_STATUS_OK = 0,
+    RUSTICOL_STATUS_INVALID_ARGUMENT = 1,
+    RUSTICOL_STATUS_BUFFER_TOO_SMALL = 2,
+    RUSTICOL_STATUS_RUNTIME_ERROR = 3,
+    RUSTICOL_STATUS_PANIC = 4
+};
+
+typedef struct RusticolRuntimeHandle RusticolRuntimeHandle;
+
+/* One literal complex spin source on a one-based public external leg.
+ * components use [point][E,px,py,pz][real,imag], with 8 doubles per point.
+ * point_count=1 broadcasts; otherwise it must match the evaluation batch.
+ * Values are copied by the setter and borrowed only during an evaluation.
+ */
+typedef struct RusticolSpinCorrelationVector {
+    size_t leg;
+    size_t point_count;
+    const double *components;
+    size_t component_count;
+} RusticolSpinCorrelationVector;
+
+/* A directed colour insertion, with optional spin replacements.
+ * use_default_spin_vectors=1 inherits the setter and requires an empty array;
+ * 0 uses this request's vectors (an empty array selects physical helicities).
+ */
+typedef struct RusticolCorrelatedRequest {
+    const char *color_correlation;
+    const RusticolSpinCorrelationVector *spin_vectors;
+    size_t spin_vector_count;
+    uint32_t use_default_spin_vectors;
+} RusticolCorrelatedRequest;
+
+enum rusticol_warm_up_event_kind {
+    RUSTICOL_WARM_UP_EVENT_START = 0,
+    RUSTICOL_WARM_UP_EVENT_UPDATE = 1,
+    RUSTICOL_WARM_UP_EVENT_END = 2
+};
+
+enum rusticol_warm_up_stage {
+    RUSTICOL_WARM_UP_STAGE_PROCESS_PREPARATION = 0,
+    RUSTICOL_WARM_UP_STAGE_QUERY_FAMILY = 1,
+    RUSTICOL_WARM_UP_STAGE_FAMILY_FINALIZATION = 2,
+    RUSTICOL_WARM_UP_STAGE_FIRST_EVALUATION = 3
+};
+
+/*
+ * Fixed-layout progress snapshot. RSS fields are meaningful only when their
+ * matching *_available field is nonzero. The event pointer is borrowed for
+ * the callback invocation only.
+ */
+typedef struct RusticolWarmUpProgressEvent {
+    uint32_t schema_version;
+    uint32_t kind;
+    uint32_t stage;
+    uint32_t reserved;
+    uint64_t completed;
+    uint64_t total;
+    double elapsed_seconds;
+    uint64_t current_rss_bytes;
+    uint64_t peak_rss_bytes;
+    uint64_t workers;
+    uint32_t current_rss_available;
+    uint32_t peak_rss_available;
+} RusticolWarmUpProgressEvent;
+
+typedef struct RusticolWarmUpResult {
+    uint32_t schema_version;
+    uint32_t reserved;
+    double elapsed_seconds;
+    uint64_t query_count;
+    uint64_t warmed_query_count;
+    uint64_t current_rss_bytes;
+    uint64_t peak_rss_bytes;
+    uint32_t current_rss_available;
+    uint32_t peak_rss_available;
+    uint32_t already_warm;
+    uint32_t first_evaluation_completed;
+} RusticolWarmUpResult;
+
+/* Return nonzero to continue, or zero to request cancellation. */
+typedef int (*RusticolWarmUpProgressCallback)(
+    const RusticolWarmUpProgressEvent *event,
+    void *user_data
+);
+
+/*
+ * A handle is mutable and must not be called concurrently. Independent handles
+ * may be used concurrently from separate threads.
+ *
+ * For string and variable-length metadata getters, callers may query the
+ * required capacity with a null buffer and zero capacity. String capacities
+ * include the trailing NUL. Query and short-buffer calls do not consume
+ * warning state; rusticol_runtime_take_warnings_json consumes warnings only
+ * after a successful copy.
+ */
+
+uint32_t rusticol_abi_version(void);
+int rusticol_supported_runtime_capabilities_json(
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_last_error_message(char *buffer, size_t capacity, size_t *required);
+
+/* process_key may be a stable process/alias ID or a concrete expression. */
+int rusticol_runtime_load(
+    const char *process_dir,
+    const char *process_key,
+    const char *model_parameters_path,
+    RusticolRuntimeHandle **output
+);
+int rusticol_runtime_free(RusticolRuntimeHandle *handle);
+
+/*
+ * Save/restore the completed, retained on-the-fly recursion cache. These calls
+ * apply only to on-the-fly runtimes; load_cache requires an already-loaded
+ * matching process output. The cache file does not replace that process output.
+ * Saving does not warm new selections and cannot checkpoint an in-progress call.
+ * A later evaluation may populate selections not present in the saved cache.
+ * path must be non-null, NUL-terminated UTF-8; relative paths use the working directory.
+ */
+int rusticol_runtime_save(const RusticolRuntimeHandle *handle, const char *path);
+int rusticol_runtime_load_cache(RusticolRuntimeHandle *handle, const char *path);
+
+/* Existing content identity of the loaded, authenticated artifact manifest. */
+int rusticol_runtime_artifact_id(
+    const RusticolRuntimeHandle *handle,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_runtime_metadata_json(
+    const RusticolRuntimeHandle *handle,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_runtime_execution_mode(
+    const RusticolRuntimeHandle *handle,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_runtime_physics_json(
+    const RusticolRuntimeHandle *handle,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_runtime_process(
+    const RusticolRuntimeHandle *handle,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_runtime_process_key(
+    const RusticolRuntimeHandle *handle,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_runtime_representative_process_key(
+    const RusticolRuntimeHandle *handle,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_runtime_color_accuracy(
+    const RusticolRuntimeHandle *handle,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+
+int rusticol_runtime_external_count(
+    const RusticolRuntimeHandle *handle,
+    size_t *output
+);
+int rusticol_runtime_external_pdg(
+    const RusticolRuntimeHandle *handle,
+    size_t index,
+    int32_t *output
+);
+/* Representative-index to public/requested-index external-leg permutation. */
+int rusticol_runtime_external_permutation(
+    const RusticolRuntimeHandle *handle,
+    size_t *output,
+    size_t capacity,
+    size_t *required
+);
+/* Exact relation of the selected process to the representative evaluating it:
+ * ME = numerator / denominator * ME_representative, with reversed LC color-flow
+ * words when conjugated is 1. Processes other than non-generated members of the
+ * artifact's process-group map report 1/1 and 0. */
+int rusticol_runtime_process_group_relation(
+    const RusticolRuntimeHandle *handle,
+    uint64_t *numerator,
+    uint64_t *denominator,
+    int32_t *conjugated
+);
+/* Load one public-order [external][4] JSON point into a flat f64 buffer. */
+int rusticol_runtime_load_kinematics_json(
+    const RusticolRuntimeHandle *handle,
+    const char *path,
+    double *output,
+    size_t capacity,
+    size_t *required
+);
+
+int rusticol_runtime_helicity_count(
+    const RusticolRuntimeHandle *handle,
+    size_t *output
+);
+int rusticol_runtime_helicity_id(
+    const RusticolRuntimeHandle *handle,
+    size_t index,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_runtime_helicity_vector(
+    const RusticolRuntimeHandle *handle,
+    size_t index,
+    int32_t *output,
+    size_t capacity,
+    size_t *required
+);
+
+int rusticol_runtime_color_count(
+    const RusticolRuntimeHandle *handle,
+    size_t *output
+);
+int rusticol_runtime_color_id(
+    const RusticolRuntimeHandle *handle,
+    size_t index,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_runtime_color_kind(
+    const RusticolRuntimeHandle *handle,
+    size_t index,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+int rusticol_runtime_color_word(
+    const RusticolRuntimeHandle *handle,
+    size_t index,
+    size_t *output,
+    size_t capacity,
+    size_t *required
+);
+
+int rusticol_runtime_model_parameter_count(
+    const RusticolRuntimeHandle *handle,
+    size_t *output
+);
+int rusticol_runtime_model_parameter_name(
+    const RusticolRuntimeHandle *handle,
+    size_t index,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+
+int rusticol_runtime_resolved_shape(
+    const RusticolRuntimeHandle *handle,
+    const char *const *helicity_ids,
+    size_t helicity_count,
+    const char *const *color_ids,
+    size_t color_count,
+    size_t *output_helicity_count,
+    size_t *output_color_count
+);
+
+/*
+ * Construct and retain one selected OTF query family, then evaluate exactly
+ * one binary64 point. Momenta use [external particle][E, px, py, pz]. Global
+ * selector IDs are optional; a null pointer with zero count sums that axis.
+ * Uses the process-output construction default.
+ * Progress callbacks run on this coordinating caller thread. The terminal
+ * FIRST_EVALUATION/END event is post-commit and cannot cancel the result.
+ */
+int rusticol_runtime_warm_up_f64(
+    RusticolRuntimeHandle *handle,
+    const double *momenta,
+    size_t momentum_count,
+    const char *const *helicity_ids,
+    size_t helicity_count,
+    const char *const *color_ids,
+    size_t color_count,
+    RusticolWarmUpProgressCallback progress_callback,
+    void *progress_user_data,
+    RusticolWarmUpResult *output
+);
+
+/* Same warm-up contract, with an explicit construction-core override.
+ * n_cores=0 uses the process-output default; a positive value overrides it
+ * for this call only, without changing evaluation or cache identity.
+ */
+int rusticol_runtime_warm_up_f64_with_cores(
+    RusticolRuntimeHandle *handle,
+    const double *momenta,
+    size_t momentum_count,
+    const char *const *helicity_ids,
+    size_t helicity_count,
+    const char *const *color_ids,
+    size_t color_count,
+    size_t n_cores,
+    RusticolWarmUpProgressCallback progress_callback,
+    void *progress_user_data,
+    RusticolWarmUpResult *output
+);
+
+/* Momenta use [point][external particle][E, px, py, pz]. */
+/* Correlation queries read the selected process's generation-time catalogue.
+ * They may lazily initialize correlated metadata, but do not evaluate an ME.
+ * String queries include the trailing NUL in required; NULL/0 queries size.
+ */
+int rusticol_runtime_color_correlation_count(
+    RusticolRuntimeHandle *handle, size_t *output
+);
+int rusticol_runtime_color_correlation_id(
+    RusticolRuntimeHandle *handle, size_t index,
+    char *buffer, size_t capacity, size_t *required
+);
+int rusticol_runtime_color_correlation_catalogue_json(
+    RusticolRuntimeHandle *handle, char *buffer, size_t capacity, size_t *required
+);
+
+/* Empty vectors clear defaults. Ordinary evaluations never use these values. */
+int rusticol_runtime_set_spin_correlation_vectors_f64(
+    RusticolRuntimeHandle *handle,
+    const RusticolSpinCorrelationVector *vectors, size_t vector_count
+);
+
+/* Grouped binary64 colour/spin insertions over a phase-space batch.
+ * output uses [request][point][real,imag], with capacity measured in doubles.
+ * helicity_ids optionally selects physical helicities of unreplaced legs.
+ * All request/input buffers are borrowed only for this call. Dimensions and
+ * selectors are validated before evaluation; output is written only on success.
+ */
+int rusticol_runtime_evaluate_correlated_many_f64(
+    RusticolRuntimeHandle *handle,
+    const double *momenta, size_t momentum_count, size_t point_count,
+    const RusticolCorrelatedRequest *requests, size_t request_count,
+    const char *const *helicity_ids, size_t helicity_count,
+    double *output, size_t output_capacity
+);
+
+/* Ordinary momenta use [point][external particle][E, px, py, pz]. */
+int rusticol_runtime_evaluate_f64(
+    RusticolRuntimeHandle *handle,
+    const double *momenta,
+    size_t momentum_count,
+    size_t point_count,
+    double *output,
+    size_t output_capacity
+);
+
+/*
+ * Evaluate one total per point with optional selectors. Global selectors are
+ * physical string IDs. Per-point selectors are zero-based physical indices and
+ * must have length point_count. Global and per-point selectors are mutually
+ * exclusive on the same axis. A null pointer with zero length omits that axis.
+ */
+int rusticol_runtime_evaluate_selected_f64(
+    RusticolRuntimeHandle *handle,
+    const double *momenta,
+    size_t momentum_count,
+    size_t point_count,
+    const char *const *helicity_ids,
+    size_t helicity_count,
+    const char *const *color_ids,
+    size_t color_count,
+    const uint32_t *helicity_by_point,
+    size_t helicity_by_point_count,
+    const uint32_t *color_flow_by_point,
+    size_t color_flow_by_point_count,
+    double *output,
+    size_t output_capacity
+);
+
+/* Resolved output uses [point][helicity][color]. */
+int rusticol_runtime_evaluate_resolved_f64(
+    RusticolRuntimeHandle *handle,
+    const double *momenta,
+    size_t momentum_count,
+    size_t point_count,
+    const char *const *helicity_ids,
+    size_t helicity_count,
+    const char *const *color_ids,
+    size_t color_count,
+    double *output,
+    size_t output_capacity,
+    size_t *output_helicity_count,
+    size_t *output_color_count
+);
+
+int rusticol_runtime_set_model_parameters(
+    RusticolRuntimeHandle *handle,
+    const char *const *names,
+    const double *real,
+    const double *imaginary,
+    size_t count
+);
+int rusticol_runtime_set_model_parameter(
+    RusticolRuntimeHandle *handle,
+    const char *name,
+    double real,
+    double imaginary
+);
+/* Read the current value (not its saved default), including derived parameters.
+ * Both output pointers must be non-null and writable for one double.
+ */
+int rusticol_runtime_get_model_parameter(
+    const RusticolRuntimeHandle *handle,
+    const char *name,
+    double *real,
+    double *imaginary
+);
+int rusticol_runtime_set_model_parameters_json(
+    RusticolRuntimeHandle *handle,
+    const char *path
+);
+
+int rusticol_runtime_mute_warnings(
+    RusticolRuntimeHandle *handle,
+    int muted
+);
+int rusticol_runtime_take_warnings_json(
+    RusticolRuntimeHandle *handle,
+    char *buffer,
+    size_t capacity,
+    size_t *required
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/pyamplicol/rust/crates/rusticol-capi/include/rusticol.hpp b/pyamplicol/rust/crates/rusticol-capi/include/rusticol.hpp
new file mode 100644
index 0000000000..d437af6e0d
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-capi/include/rusticol.hpp
@@ -0,0 +1,695 @@
+// SPDX-License-Identifier: 0BSD
+
+#ifndef RUSTICOL_HPP
+#define RUSTICOL_HPP
+
+#include "rusticol.h"
+
+#include <array>
+#include <cmath>
+#include <complex>
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <functional>
+#include <limits>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace rusticol {
+
+class Error : public std::runtime_error {
+public:
+    explicit Error(const std::string &message) : std::runtime_error(message) {}
+};
+
+inline std::string last_error() {
+    std::size_t required = 0;
+    rusticol_last_error_message(nullptr, 0, &required);
+    if (required == 0) {
+        return "unknown Rusticol error";
+    }
+    std::vector<char> buffer(required);
+    rusticol_last_error_message(buffer.data(), buffer.size(), &required);
+    return std::string(buffer.data());
+}
+
+inline void check(int status) {
+    if (status != RUSTICOL_STATUS_OK) {
+        throw Error(last_error());
+    }
+}
+
+inline std::string supported_runtime_capabilities_json() {
+    std::size_t required = 0;
+    check(rusticol_supported_runtime_capabilities_json(nullptr, 0, &required));
+    std::vector<char> buffer(required);
+    check(rusticol_supported_runtime_capabilities_json(
+        buffer.data(), buffer.size(), &required));
+    return std::string(buffer.data());
+}
+
+struct ExternalParticle {
+    std::size_t index{};
+    std::int32_t pdg{};
+};
+
+struct HelicityConfiguration {
+    std::string id;
+    std::vector<std::int32_t> helicities;
+};
+
+struct ColorComponent {
+    std::string id;
+    std::string kind;
+    std::vector<std::size_t> word;
+};
+
+struct ModelParameter {
+    std::string name;
+};
+
+struct SpinCorrelationVector {
+    std::size_t leg{};  // One-based public external leg.
+    // One four-vector broadcasts; otherwise supply one per momentum point.
+    std::vector<std::array<std::complex<double>, 4>> components;
+};
+
+struct CorrelatedRequest {
+    std::string color_correlation{"born"};
+    // nullopt inherits the setter; an empty vector selects physical helicities.
+    std::optional<std::vector<SpinCorrelationVector>> spin_vectors;
+};
+
+struct CorrelatedEvaluation {
+    std::vector<std::complex<double>> values;  // [request][point]
+    std::size_t request_count{};
+    std::size_t point_count{};
+
+    std::complex<double> operator()(std::size_t request, std::size_t point) const {
+        if (request >= request_count || point >= point_count) {
+            throw std::out_of_range("correlated Rusticol result index is out of range");
+        }
+        return values.at(request * point_count + point);
+    }
+};
+
+enum class WarmUpEventKind : std::uint32_t {
+    start = RUSTICOL_WARM_UP_EVENT_START,
+    update = RUSTICOL_WARM_UP_EVENT_UPDATE,
+    end = RUSTICOL_WARM_UP_EVENT_END,
+};
+
+enum class WarmUpStage : std::uint32_t {
+    process_preparation = RUSTICOL_WARM_UP_STAGE_PROCESS_PREPARATION,
+    query_family = RUSTICOL_WARM_UP_STAGE_QUERY_FAMILY,
+    family_finalization = RUSTICOL_WARM_UP_STAGE_FAMILY_FINALIZATION,
+    first_evaluation = RUSTICOL_WARM_UP_STAGE_FIRST_EVALUATION,
+};
+
+struct WarmUpProgress {
+    std::uint32_t schema_version{};
+    WarmUpEventKind kind{};
+    WarmUpStage stage{};
+    std::uint64_t completed{};
+    std::uint64_t total{};
+    double elapsed_seconds{};
+    std::uint64_t current_rss_bytes{};
+    std::uint64_t peak_rss_bytes{};
+    std::uint64_t workers{};
+    bool current_rss_available{};
+    bool peak_rss_available{};
+};
+
+struct WarmUpResult {
+    std::uint32_t schema_version{};
+    double elapsed_seconds{};
+    std::uint64_t query_count{};
+    std::uint64_t warmed_query_count{};
+    std::uint64_t current_rss_bytes{};
+    std::uint64_t peak_rss_bytes{};
+    bool current_rss_available{};
+    bool peak_rss_available{};
+    bool already_warm{};
+    bool first_evaluation_completed{};
+};
+
+namespace detail {
+
+struct SpinCorrelationStorage {
+    std::vector<std::vector<double>> components;
+    std::vector<RusticolSpinCorrelationVector> vectors;
+
+    explicit SpinCorrelationStorage(const std::vector<SpinCorrelationVector> &input) {
+        components.reserve(input.size());
+        vectors.reserve(input.size());
+        for (const auto &item : input) {
+            components.emplace_back();
+            auto &flat = components.back();
+            for (const auto &point : item.components) {
+                for (const auto &value : point) {
+                    flat.push_back(value.real());
+                    flat.push_back(value.imag());
+                }
+            }
+            vectors.push_back({item.leg, item.components.size(),
+                               flat.empty() ? nullptr : flat.data(), flat.size()});
+        }
+    }
+};
+
+inline WarmUpProgress warm_up_progress(const RusticolWarmUpProgressEvent &event) {
+    return {
+        event.schema_version,
+        static_cast<WarmUpEventKind>(event.kind),
+        static_cast<WarmUpStage>(event.stage),
+        event.completed,
+        event.total,
+        event.elapsed_seconds,
+        event.current_rss_bytes,
+        event.peak_rss_bytes,
+        event.workers,
+        event.current_rss_available != 0,
+        event.peak_rss_available != 0,
+    };
+}
+
+inline WarmUpResult warm_up_result(const RusticolWarmUpResult &result) {
+    return {
+        result.schema_version,
+        result.elapsed_seconds,
+        result.query_count,
+        result.warmed_query_count,
+        result.current_rss_bytes,
+        result.peak_rss_bytes,
+        result.current_rss_available != 0,
+        result.peak_rss_available != 0,
+        result.already_warm != 0,
+        result.first_evaluation_completed != 0,
+    };
+}
+
+struct WarmUpCallbackState {
+    const std::function<bool(const WarmUpProgress &)> *callback{};
+    std::exception_ptr exception;
+};
+
+inline int warm_up_progress_callback(
+    const RusticolWarmUpProgressEvent *event,
+    void *user_data) noexcept {
+    if (event == nullptr || user_data == nullptr) {
+        return 0;
+    }
+    auto &state = *static_cast<WarmUpCallbackState *>(user_data);
+    if (state.callback == nullptr) {
+        return 0;
+    }
+    try {
+        return (*state.callback)(warm_up_progress(*event)) ? 1 : 0;
+    } catch (...) {
+        const bool terminal =
+            event->kind == RUSTICOL_WARM_UP_EVENT_END &&
+            event->stage == RUSTICOL_WARM_UP_STAGE_FIRST_EVALUATION;
+        if (!terminal) {
+            state.exception = std::current_exception();
+            return 0;
+        }
+        // This event is emitted after the selected family and first evaluation
+        // have committed. Match the core contract by treating it as a
+        // non-cancellable notification.
+        return 1;
+    }
+}
+
+}  // namespace detail
+
+class ResolvedEvaluation {
+public:
+    std::vector<double> values;
+    std::size_t point_count{};
+    std::vector<HelicityConfiguration> helicities;
+    std::vector<ColorComponent> colors;
+
+    double operator()(std::size_t point, std::size_t helicity, std::size_t color) const {
+        if (point >= point_count || helicity >= helicities.size() || color >= colors.size()) {
+            throw std::out_of_range("resolved Rusticol result index is out of range");
+        }
+        return values[(point * helicities.size() + helicity) * colors.size() + color];
+    }
+
+    std::vector<double> total() const {
+        const std::size_t stride = helicities.size() * colors.size();
+        std::vector<double> totals(point_count, 0.0);
+        for (std::size_t point = 0; point < point_count; ++point) {
+            for (std::size_t component = 0; component < stride; ++component) {
+                totals[point] += values[point * stride + component];
+            }
+        }
+        return totals;
+    }
+};
+
+class Runtime {
+public:
+    Runtime(const std::string &process_dir,
+            const std::string &process_key = {},
+            const std::string &model_parameters = {}) {
+        RusticolRuntimeHandle *loaded = nullptr;
+        check(rusticol_runtime_load(
+            process_dir.c_str(),
+            process_key.empty() ? nullptr : process_key.c_str(),
+            model_parameters.empty() ? nullptr : model_parameters.c_str(),
+            &loaded));
+        handle_ = loaded;
+    }
+
+    ~Runtime() {
+        if (handle_ != nullptr) {
+            rusticol_runtime_free(handle_);
+        }
+    }
+
+    Runtime(const Runtime &) = delete;
+    Runtime &operator=(const Runtime &) = delete;
+
+    Runtime(Runtime &&other) noexcept : handle_(std::exchange(other.handle_, nullptr)) {}
+
+    Runtime &operator=(Runtime &&other) noexcept {
+        if (this != &other) {
+            if (handle_ != nullptr) {
+                rusticol_runtime_free(handle_);
+            }
+            handle_ = std::exchange(other.handle_, nullptr);
+        }
+        return *this;
+    }
+
+    // Save the completed, retained OTF cache, without warming new selections.
+    void save(const std::string &path) const {
+        if (path.find('\0') != std::string::npos) {
+            throw std::invalid_argument("cache path contains a NUL byte");
+        }
+        check(rusticol_runtime_save(handle_, path.c_str()));
+    }
+
+    // Restore an OTF cache after loading the matching process output normally.
+    void load_cache(const std::string &path) {
+        if (path.find('\0') != std::string::npos) {
+            throw std::invalid_argument("cache path contains a NUL byte");
+        }
+        check(rusticol_runtime_load_cache(handle_, path.c_str()));
+    }
+
+    std::string process() const { return get_string(rusticol_runtime_process); }
+    std::string process_key() const { return get_string(rusticol_runtime_process_key); }
+    std::string representative_process_key() const {
+        return get_string(rusticol_runtime_representative_process_key);
+    }
+    std::string color_accuracy() const { return get_string(rusticol_runtime_color_accuracy); }
+    std::string execution_mode() const { return get_string(rusticol_runtime_execution_mode); }
+    std::string metadata_json() const { return get_string(rusticol_runtime_metadata_json); }
+    std::string physics_json() const { return get_string(rusticol_runtime_physics_json); }
+
+    std::vector<ExternalParticle> external_particles() const {
+        std::size_t count = 0;
+        check(rusticol_runtime_external_count(handle_, &count));
+        std::vector<ExternalParticle> result;
+        result.reserve(count);
+        for (std::size_t index = 0; index < count; ++index) {
+            std::int32_t pdg = 0;
+            check(rusticol_runtime_external_pdg(handle_, index, &pdg));
+            result.push_back({index, pdg});
+        }
+        return result;
+    }
+
+    std::vector<std::size_t> external_permutation() const {
+        std::size_t required = 0;
+        check(rusticol_runtime_external_permutation(
+            handle_, nullptr, 0, &required));
+        std::vector<std::size_t> result(required);
+        if (required != 0) {
+            check(rusticol_runtime_external_permutation(
+                handle_, result.data(), result.size(), &required));
+        }
+        return result;
+    }
+
+    std::vector<double> load_kinematics_json(const std::string &path) const {
+        std::size_t required = 0;
+        check(rusticol_runtime_load_kinematics_json(
+            handle_, path.c_str(), nullptr, 0, &required));
+        std::vector<double> result(required);
+        if (required != 0) {
+            check(rusticol_runtime_load_kinematics_json(
+                handle_, path.c_str(), result.data(), result.size(), &required));
+        }
+        return result;
+    }
+
+    std::vector<HelicityConfiguration> helicities() const {
+        std::size_t count = 0;
+        check(rusticol_runtime_helicity_count(handle_, &count));
+        std::vector<HelicityConfiguration> result;
+        result.reserve(count);
+        for (std::size_t index = 0; index < count; ++index) {
+            std::size_t vector_size = 0;
+            check(rusticol_runtime_helicity_vector(handle_, index, nullptr, 0, &vector_size));
+            std::vector<std::int32_t> vector(vector_size);
+            check(rusticol_runtime_helicity_vector(
+                handle_, index, vector.data(), vector.size(), &vector_size));
+            result.push_back({get_indexed_string(rusticol_runtime_helicity_id, index), vector});
+        }
+        return result;
+    }
+
+    std::vector<ColorComponent> colors() const {
+        std::size_t count = 0;
+        check(rusticol_runtime_color_count(handle_, &count));
+        std::vector<ColorComponent> result;
+        result.reserve(count);
+        for (std::size_t index = 0; index < count; ++index) {
+            std::size_t word_size = 0;
+            check(rusticol_runtime_color_word(handle_, index, nullptr, 0, &word_size));
+            std::vector<std::size_t> word(word_size);
+            check(rusticol_runtime_color_word(
+                handle_, index, word.data(), word.size(), &word_size));
+            result.push_back({
+                get_indexed_string(rusticol_runtime_color_id, index),
+                get_indexed_string(rusticol_runtime_color_kind, index),
+                word,
+            });
+        }
+        return result;
+    }
+
+    std::vector<ModelParameter> model_parameters() const {
+        std::size_t count = 0;
+        check(rusticol_runtime_model_parameter_count(handle_, &count));
+        std::vector<ModelParameter> result;
+        result.reserve(count);
+        for (std::size_t index = 0; index < count; ++index) {
+            result.push_back({get_indexed_string(rusticol_runtime_model_parameter_name, index)});
+        }
+        return result;
+    }
+
+    std::vector<double> evaluate(const std::vector<double> &momenta,
+                                 std::size_t point_count) {
+        std::vector<double> values(point_count);
+        check(rusticol_runtime_evaluate_f64(
+            handle_, momenta.data(), momenta.size(), point_count, values.data(), values.size()));
+        return values;
+    }
+
+    std::string color_correlation_catalogue_json() {
+        return get_string_mut(rusticol_runtime_color_correlation_catalogue_json);
+    }
+
+    std::vector<std::string> color_correlation_ids() {
+        std::size_t count = 0;
+        check(rusticol_runtime_color_correlation_count(handle_, &count));
+        std::vector<std::string> result;
+        result.reserve(count);
+        for (std::size_t index = 0; index < count; ++index) {
+            std::size_t required = 0;
+            check(rusticol_runtime_color_correlation_id(handle_, index, nullptr, 0, &required));
+            std::vector<char> buffer(required);
+            check(rusticol_runtime_color_correlation_id(
+                handle_, index, buffer.data(), buffer.size(), &required));
+            result.emplace_back(buffer.data());
+        }
+        return result;
+    }
+
+    // Empty input clears defaults; this does not affect ordinary evaluate().
+    void set_spin_correlation_vectors(const std::vector<SpinCorrelationVector> &vectors = {}) {
+        const detail::SpinCorrelationStorage storage(vectors);
+        check(rusticol_runtime_set_spin_correlation_vectors_f64(
+            handle_, storage.vectors.empty() ? nullptr : storage.vectors.data(),
+            storage.vectors.size()));
+    }
+
+    CorrelatedEvaluation evaluate_correlated_many(
+        const std::vector<double> &momenta,
+        std::size_t point_count,
+        const std::vector<CorrelatedRequest> &requests,
+        const std::vector<std::string> &helicity_ids = {}) {
+        if (point_count == 0 || requests.empty() ||
+            point_count > std::numeric_limits<std::size_t>::max() / 2 / requests.size()) {
+            throw std::invalid_argument("invalid correlated result dimensions");
+        }
+        std::vector<detail::SpinCorrelationStorage> storage;
+        std::vector<RusticolCorrelatedRequest> raw_requests;
+        const std::vector<SpinCorrelationVector> physical_helicities;
+        storage.reserve(requests.size());
+        raw_requests.reserve(requests.size());
+        for (const auto &request : requests) {
+            if (request.color_correlation.find('\0') != std::string::npos) {
+                throw std::invalid_argument("colour correlation ID contains a NUL byte");
+            }
+            storage.emplace_back(request.spin_vectors ? *request.spin_vectors : physical_helicities);
+            const auto &vectors = storage.back().vectors;
+            raw_requests.push_back({request.color_correlation.c_str(),
+                                    vectors.empty() ? nullptr : vectors.data(), vectors.size(),
+                                    request.spin_vectors ? 0u : 1u});
+        }
+        for (const auto &id : helicity_ids) {
+            if (id.find('\0') != std::string::npos) {
+                throw std::invalid_argument("helicity ID contains a NUL byte");
+            }
+        }
+        const auto helicity_ptrs = c_string_pointers(helicity_ids);
+        std::vector<double> raw(requests.size() * point_count * 2);
+        check(rusticol_runtime_evaluate_correlated_many_f64(
+            handle_, momenta.data(), momenta.size(), point_count,
+            raw_requests.data(), raw_requests.size(),
+            helicity_ptrs.empty() ? nullptr : helicity_ptrs.data(), helicity_ptrs.size(),
+            raw.data(), raw.size()));
+        CorrelatedEvaluation result{{}, requests.size(), point_count};
+        result.values.reserve(raw.size() / 2);
+        for (std::size_t index = 0; index < raw.size(); index += 2) {
+            result.values.emplace_back(raw[index], raw[index + 1]);
+        }
+        return result;
+    }
+
+    std::vector<std::complex<double>> evaluate_correlated(
+        const std::vector<double> &momenta,
+        std::size_t point_count,
+        const std::string &color_correlation = "born",
+        const std::optional<std::vector<SpinCorrelationVector>> &spin_vectors = std::nullopt,
+        const std::vector<std::string> &helicity_ids = {}) {
+        return evaluate_correlated_many(
+            momenta, point_count, {{color_correlation, spin_vectors}}, helicity_ids).values;
+    }
+
+    WarmUpResult warm_up(
+        const std::vector<double> &point,
+        const std::vector<std::string> &helicity_ids = {},
+        const std::vector<std::string> &color_ids = {},
+        const std::function<bool(const WarmUpProgress &)> &progress = {},
+        std::size_t n_cores = 0) {
+        const auto helicity_ptrs = c_string_pointers(helicity_ids);
+        const auto color_ptrs = c_string_pointers(color_ids);
+        RusticolWarmUpResult result{};
+        detail::WarmUpCallbackState callback_state{progress ? &progress : nullptr, {}};
+        const int status = rusticol_runtime_warm_up_f64_with_cores(
+            handle_,
+            point.data(),
+            point.size(),
+            helicity_ptrs.empty() ? nullptr : helicity_ptrs.data(),
+            helicity_ptrs.size(),
+            color_ptrs.empty() ? nullptr : color_ptrs.data(),
+            color_ptrs.size(),
+            n_cores,
+            progress ? detail::warm_up_progress_callback : nullptr,
+            progress ? static_cast<void *>(&callback_state) : nullptr,
+            &result);
+        if (callback_state.exception) {
+            std::rethrow_exception(callback_state.exception);
+        }
+        check(status);
+        const auto converted = detail::warm_up_result(result);
+        if (converted.schema_version != 1 || !converted.first_evaluation_completed) {
+            throw Error("Rusticol returned an invalid successful warm-up result");
+        }
+        return converted;
+    }
+
+    std::vector<double> evaluate_selected(
+        const std::vector<double> &momenta,
+        std::size_t point_count,
+        const std::vector<std::string> &helicity_ids = {},
+        const std::vector<std::string> &color_ids = {},
+        const std::vector<std::uint32_t> &helicity_by_point = {},
+        const std::vector<std::uint32_t> &color_flow_by_point = {}) {
+        const auto helicity_ptrs = c_string_pointers(helicity_ids);
+        const auto color_ptrs = c_string_pointers(color_ids);
+        std::vector<double> values(point_count);
+        check(rusticol_runtime_evaluate_selected_f64(
+            handle_,
+            momenta.data(),
+            momenta.size(),
+            point_count,
+            helicity_ptrs.empty() ? nullptr : helicity_ptrs.data(),
+            helicity_ptrs.size(),
+            color_ptrs.empty() ? nullptr : color_ptrs.data(),
+            color_ptrs.size(),
+            helicity_by_point.empty() ? nullptr : helicity_by_point.data(),
+            helicity_by_point.size(),
+            color_flow_by_point.empty() ? nullptr : color_flow_by_point.data(),
+            color_flow_by_point.size(),
+            values.data(),
+            values.size()));
+        return values;
+    }
+
+    ResolvedEvaluation evaluate_resolved(
+        const std::vector<double> &momenta,
+        std::size_t point_count,
+        const std::vector<std::string> &helicity_ids = {},
+        const std::vector<std::string> &color_ids = {}) {
+        const auto helicity_ptrs = c_string_pointers(helicity_ids);
+        const auto color_ptrs = c_string_pointers(color_ids);
+        std::size_t helicity_count = 0;
+        std::size_t color_count = 0;
+        check(rusticol_runtime_resolved_shape(
+            handle_,
+            helicity_ptrs.empty() ? nullptr : helicity_ptrs.data(),
+            helicity_ptrs.size(),
+            color_ptrs.empty() ? nullptr : color_ptrs.data(),
+            color_ptrs.size(),
+            &helicity_count,
+            &color_count));
+        std::vector<double> values(point_count * helicity_count * color_count);
+        check(rusticol_runtime_evaluate_resolved_f64(
+            handle_,
+            momenta.data(),
+            momenta.size(),
+            point_count,
+            helicity_ptrs.empty() ? nullptr : helicity_ptrs.data(),
+            helicity_ptrs.size(),
+            color_ptrs.empty() ? nullptr : color_ptrs.data(),
+            color_ptrs.size(),
+            values.data(),
+            values.size(),
+            &helicity_count,
+            &color_count));
+
+        auto all_helicities = helicities();
+        auto all_colors = colors();
+        return {
+            std::move(values),
+            point_count,
+            select_helicities(all_helicities, helicity_ids),
+            select_colors(all_colors, color_ids),
+        };
+    }
+
+    void set_model_parameter(const std::string &name, double real, double imaginary = 0.0) {
+        check(rusticol_runtime_set_model_parameter(handle_, name.c_str(), real, imaginary));
+    }
+
+    void set_model_parameters(const std::vector<std::string> &names,
+                              const std::vector<double> &real,
+                              const std::vector<double> &imaginary) {
+        if (names.size() != real.size() || names.size() != imaginary.size()) {
+            throw std::invalid_argument("model parameter arrays have different lengths");
+        }
+        const auto pointers = c_string_pointers(names);
+        check(rusticol_runtime_set_model_parameters(
+            handle_, pointers.data(), real.data(), imaginary.data(), names.size()));
+    }
+
+    void set_model_parameters_json(const std::string &path) {
+        check(rusticol_runtime_set_model_parameters_json(handle_, path.c_str()));
+    }
+
+    void mute_warnings() { check(rusticol_runtime_mute_warnings(handle_, 1)); }
+    void unmute_warnings() { check(rusticol_runtime_mute_warnings(handle_, 0)); }
+    std::string take_warnings_json() {
+        return get_string_mut(rusticol_runtime_take_warnings_json);
+    }
+
+private:
+    using StringFunction = int (*)(const RusticolRuntimeHandle *, char *, std::size_t, std::size_t *);
+    using MutableStringFunction = int (*)(RusticolRuntimeHandle *, char *, std::size_t, std::size_t *);
+    using IndexedStringFunction = int (*)(const RusticolRuntimeHandle *, std::size_t, char *, std::size_t, std::size_t *);
+
+    std::string get_string(StringFunction function) const {
+        std::size_t required = 0;
+        check(function(handle_, nullptr, 0, &required));
+        std::vector<char> buffer(required);
+        check(function(handle_, buffer.data(), buffer.size(), &required));
+        return std::string(buffer.data());
+    }
+
+    std::string get_string_mut(MutableStringFunction function) {
+        std::size_t required = 0;
+        check(function(handle_, nullptr, 0, &required));
+        std::vector<char> buffer(required);
+        check(function(handle_, buffer.data(), buffer.size(), &required));
+        return std::string(buffer.data());
+    }
+
+    std::string get_indexed_string(IndexedStringFunction function, std::size_t index) const {
+        std::size_t required = 0;
+        check(function(handle_, index, nullptr, 0, &required));
+        std::vector<char> buffer(required);
+        check(function(handle_, index, buffer.data(), buffer.size(), &required));
+        return std::string(buffer.data());
+    }
+
+    static std::vector<const char *> c_string_pointers(const std::vector<std::string> &values) {
+        std::vector<const char *> pointers;
+        pointers.reserve(values.size());
+        for (const auto &value : values) {
+            pointers.push_back(value.c_str());
+        }
+        return pointers;
+    }
+
+    static std::vector<HelicityConfiguration> select_helicities(
+        const std::vector<HelicityConfiguration> &available,
+        const std::vector<std::string> &selected) {
+        if (selected.empty()) {
+            return available;
+        }
+        std::vector<HelicityConfiguration> result;
+        for (const auto &item : available) {
+            for (const auto &id : selected) {
+                if (item.id == id) {
+                    result.push_back(item);
+                }
+            }
+        }
+        return result;
+    }
+
+    static std::vector<ColorComponent> select_colors(
+        const std::vector<ColorComponent> &available,
+        const std::vector<std::string> &selected) {
+        if (selected.empty()) {
+            return available;
+        }
+        std::vector<ColorComponent> result;
+        for (const auto &item : available) {
+            for (const auto &id : selected) {
+                if (item.id == id) {
+                    result.push_back(item);
+                }
+            }
+        }
+        return result;
+    }
+
+    RusticolRuntimeHandle *handle_{};
+};
+
+}  // namespace rusticol
+
+#endif
diff --git a/pyamplicol/rust/crates/rusticol-capi/src/correlated.rs b/pyamplicol/rust/crates/rusticol-capi/src/correlated.rs
new file mode 100644
index 0000000000..caab0efe1f
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-capi/src/correlated.rs
@@ -0,0 +1,283 @@
+// SPDX-License-Identifier: 0BSD
+//! Additive correlated evaluation ABI. Ordinary calls do not enter this module.
+
+use super::*;
+
+unsafe fn read_spin_vectors(
+    vectors: *const RusticolSpinCorrelationVector,
+    count: usize,
+) -> AbiResult<NativeSpinCorrelationVectors> {
+    let mut result = NativeSpinCorrelationVectors::new();
+    if count == 0 {
+        return Ok(result);
+    }
+    if vectors.is_null() {
+        return Err(invalid("spin-vector array is null"));
+    }
+    // SAFETY: The caller supplies count readable records.
+    for vector in unsafe { slice::from_raw_parts(vectors, count) } {
+        if vector.leg == 0 || vector.point_count == 0 {
+            return Err(invalid("spin-vector leg and point count must be positive"));
+        }
+        let required = vector
+            .point_count
+            .checked_mul(8)
+            .ok_or_else(|| invalid("spin-vector size overflow"))?;
+        if vector.component_count != required {
+            return Err(invalid(
+                "spin-vector components must contain eight doubles per point",
+            ));
+        }
+        // SAFETY: This record's component buffer is readable for component_count doubles.
+        let flat = unsafe {
+            read_f64_slice(vector.components, vector.component_count, "spin components")
+        }?;
+        if flat.iter().any(|value| !value.is_finite()) {
+            return Err(invalid("spin-vector components must be finite"));
+        }
+        let points = flat
+            .chunks_exact(8)
+            .map(|point| std::array::from_fn(|mu| [point[2 * mu], point[2 * mu + 1]]))
+            .collect();
+        if result.insert(vector.leg, points).is_some() {
+            return Err(invalid("a spin-vector array repeats an external leg"));
+        }
+    }
+    Ok(result)
+}
+
+unsafe fn read_requests(
+    requests: *const RusticolCorrelatedRequest,
+    count: usize,
+) -> AbiResult<Vec<NativeCorrelatedRequest>> {
+    if count == 0 || requests.is_null() {
+        return Err(invalid(
+            "a correlated evaluation requires a nonempty request array",
+        ));
+    }
+    // SAFETY: The caller supplies count readable records and their nested buffers.
+    unsafe { slice::from_raw_parts(requests, count) }
+        .iter()
+        .map(|request| {
+            let identifier =
+                unsafe { required_c_string(request.color_correlation, "colour correlation ID") }?;
+            if identifier.is_empty() {
+                return Err(invalid("colour correlation ID must not be empty"));
+            }
+            let spin_vectors = match request.use_default_spin_vectors {
+                0 => Some(unsafe {
+                    read_spin_vectors(request.spin_vectors, request.spin_vector_count)
+                }?),
+                1 if request.spin_vector_count == 0 => None,
+                1 => {
+                    return Err(invalid(
+                        "inherited spin vectors require an empty explicit array",
+                    ));
+                }
+                _ => return Err(invalid("use_default_spin_vectors must be zero or one")),
+            };
+            Ok(NativeCorrelatedRequest {
+                color_correlation: identifier.to_owned(),
+                spin_vectors,
+            })
+        })
+        .collect()
+}
+
+/// Enumerate the selected process's generation-time correlation IDs.
+///
+/// # Safety
+/// handle must be live and exclusively accessible; output must be writable.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_color_correlation_count(
+    handle: *mut RusticolRuntimeHandle,
+    output: *mut size_t,
+) -> c_int {
+    guard(|| {
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let ids = handle.runtime.color_correlation_ids()?;
+        unsafe { write_size(ids.len(), output, "colour correlation count") }
+    })
+}
+
+/// Copy one correlation ID. NULL/zero buffer queries its NUL-inclusive size.
+///
+/// # Safety
+/// handle must be live/exclusive; required and buffer follow write_string's contract.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_color_correlation_id(
+    handle: *mut RusticolRuntimeHandle,
+    index: size_t,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    guard(|| {
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let ids = handle.runtime.color_correlation_ids()?;
+        let value = ids
+            .get(index)
+            .ok_or_else(|| invalid("colour correlation index out of range"))?;
+        unsafe { write_string(value, buffer, capacity, required) }
+    })
+}
+
+/// Copy the full ordered catalogue as JSON, including generation-time histories.
+///
+/// # Safety
+/// Pointer requirements match rusticol_runtime_color_correlation_id.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_color_correlation_catalogue_json(
+    handle: *mut RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    guard(|| {
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let value = handle.runtime.available_color_correlations_json()?;
+        unsafe { write_string(&value, buffer, capacity, required) }
+    })
+}
+
+/// Copy literal spin-vector defaults. An empty array clears them.
+///
+/// # Safety
+/// handle must be live/exclusive; vectors and nested component buffers must be readable.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_set_spin_correlation_vectors_f64(
+    handle: *mut RusticolRuntimeHandle,
+    vectors: *const RusticolSpinCorrelationVector,
+    vector_count: size_t,
+) -> c_int {
+    guard(|| {
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let vectors = unsafe { read_spin_vectors(vectors, vector_count) }?;
+        handle.runtime.set_spin_correlation_vectors_f64(vectors)?;
+        Ok(())
+    })
+}
+
+/// Evaluate grouped colour/spin requests; result doubles are [request][point][real,imag].
+///
+/// # Safety
+/// handle must be live/exclusive. All arrays must be readable for their stated counts;
+/// nested request/vector/string buffers must remain live. output must be writable for
+/// output_capacity doubles and must not overlap input buffers.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_evaluate_correlated_many_f64(
+    handle: *mut RusticolRuntimeHandle,
+    momenta: *const c_double,
+    momentum_count: size_t,
+    point_count: size_t,
+    requests: *const RusticolCorrelatedRequest,
+    request_count: size_t,
+    helicity_ids: *const *const c_char,
+    helicity_count: size_t,
+    output: *mut c_double,
+    output_capacity: size_t,
+) -> c_int {
+    guard(|| {
+        let required = request_count
+            .checked_mul(point_count)
+            .and_then(|n| n.checked_mul(2))
+            .ok_or_else(|| invalid("correlated result size overflow"))?;
+        if point_count == 0 || request_count == 0 {
+            return Err(invalid(
+                "correlated request and point counts must be positive",
+            ));
+        }
+        validate_f64_output(output, output_capacity, required, "correlated output")?;
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let momenta = unsafe { read_f64_slice(momenta, momentum_count, "momenta") }?;
+        let requests = unsafe { read_requests(requests, request_count) }?;
+        let helicities =
+            unsafe { read_selector_ids(helicity_ids, helicity_count, "helicity IDs") }?;
+        let values = handle.runtime.evaluate_correlated_many_f64(
+            momenta,
+            point_count,
+            &requests,
+            helicities.as_deref(),
+        )?;
+        if values.point_count != point_count
+            || values.request_count != request_count
+            || values.values.len().checked_mul(2) != Some(required)
+        {
+            return Err(abi_error(
+                RUSTICOL_STATUS_RUNTIME_ERROR,
+                "correlated runtime returned inconsistent dimensions",
+            ));
+        }
+        let flat: Vec<f64> = values.values.into_iter().flatten().collect();
+        unsafe { write_f64_slice(&flat, output, output_capacity, "correlated output") }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn spin_buffers_preserve_complex_layout_and_reject_duplicate_legs() {
+        let components = [1., 2., 3., 4., 5., 6., 7., 8.];
+        let vector = RusticolSpinCorrelationVector {
+            leg: 3,
+            point_count: 1,
+            components: components.as_ptr(),
+            component_count: 8,
+        };
+        let result = unsafe { read_spin_vectors(&vector, 1) }.ok().unwrap();
+        assert_eq!(result[&3], vec![[[1., 2.], [3., 4.], [5., 6.], [7., 8.]]]);
+        let duplicated = [vector, vector];
+        assert!(unsafe { read_spin_vectors(duplicated.as_ptr(), 2) }.is_err());
+        assert!(
+            unsafe { read_spin_vectors(ptr::null(), 0) }
+                .ok()
+                .unwrap()
+                .is_empty()
+        );
+        assert!(unsafe { read_spin_vectors(ptr::null(), 1) }.is_err());
+        let wrong = RusticolSpinCorrelationVector {
+            component_count: 7,
+            ..vector
+        };
+        assert!(unsafe { read_spin_vectors(&wrong, 1) }.is_err());
+    }
+
+    #[test]
+    fn requests_distinguish_defaults_from_physical_helicities() {
+        let request = RusticolCorrelatedRequest {
+            color_correlation: c"born".as_ptr(),
+            spin_vectors: ptr::null(),
+            spin_vector_count: 0,
+            use_default_spin_vectors: 1,
+        };
+        assert!(
+            unsafe { read_requests(&request, 1) }.ok().unwrap()[0]
+                .spin_vectors
+                .is_none()
+        );
+        let explicit = RusticolCorrelatedRequest {
+            use_default_spin_vectors: 0,
+            ..request
+        };
+        assert!(
+            unsafe { read_requests(&explicit, 1) }.ok().unwrap()[0]
+                .spin_vectors
+                .as_ref()
+                .unwrap()
+                .is_empty()
+        );
+        let invalid = RusticolCorrelatedRequest {
+            use_default_spin_vectors: 2,
+            ..request
+        };
+        assert!(unsafe { read_requests(&invalid, 1) }.is_err());
+        let mixed = RusticolCorrelatedRequest {
+            spin_vector_count: 1,
+            ..request
+        };
+        assert!(unsafe { read_requests(&mixed, 1) }.is_err());
+        assert!(unsafe { read_requests(ptr::null(), 0) }.is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-capi/src/lib.rs b/pyamplicol/rust/crates/rusticol-capi/src/lib.rs
new file mode 100644
index 0000000000..2997422086
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-capi/src/lib.rs
@@ -0,0 +1,1960 @@
+// SPDX-License-Identifier: 0BSD
+
+use rusticol_core::{
+    NativeCorrelatedRequest, NativeOnTheFlyWarmUpEvent, NativeOnTheFlyWarmUpEventKind,
+    NativeOnTheFlyWarmUpResult, NativeOnTheFlyWarmUpStage, NativeRuntime,
+    NativeSpinCorrelationVectors, RusticolError, RusticolErrorKind, supported_runtime_capabilities,
+};
+use std::any::Any;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::ffi::{CStr, CString, c_char, c_double, c_int, c_void};
+use std::panic::{AssertUnwindSafe, catch_unwind};
+use std::path::Path;
+use std::ptr;
+use std::slice;
+
+mod correlated;
+
+#[allow(non_camel_case_types)]
+type size_t = usize;
+
+pub const RUSTICOL_STATUS_OK: c_int = 0;
+pub const RUSTICOL_STATUS_INVALID_ARGUMENT: c_int = 1;
+pub const RUSTICOL_STATUS_BUFFER_TOO_SMALL: c_int = 2;
+pub const RUSTICOL_STATUS_RUNTIME_ERROR: c_int = 3;
+pub const RUSTICOL_STATUS_PANIC: c_int = 4;
+
+pub const RUSTICOL_WARM_UP_EVENT_START: u32 = 0;
+pub const RUSTICOL_WARM_UP_EVENT_UPDATE: u32 = 1;
+pub const RUSTICOL_WARM_UP_EVENT_END: u32 = 2;
+
+pub const RUSTICOL_WARM_UP_STAGE_PROCESS_PREPARATION: u32 = 0;
+pub const RUSTICOL_WARM_UP_STAGE_QUERY_FAMILY: u32 = 1;
+pub const RUSTICOL_WARM_UP_STAGE_FAMILY_FINALIZATION: u32 = 2;
+pub const RUSTICOL_WARM_UP_STAGE_FIRST_EVALUATION: u32 = 3;
+
+/// Fixed-layout progress snapshot passed to native warm-up observers.
+///
+/// `current_rss_bytes` and `peak_rss_bytes` are meaningful only when the
+/// corresponding `*_available` field is nonzero. The event is borrowed and is
+/// valid only for the duration of the callback.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct RusticolWarmUpProgressEvent {
+    pub schema_version: u32,
+    pub kind: u32,
+    pub stage: u32,
+    pub reserved: u32,
+    pub completed: u64,
+    pub total: u64,
+    pub elapsed_seconds: c_double,
+    pub current_rss_bytes: u64,
+    pub peak_rss_bytes: u64,
+    pub workers: u64,
+    pub current_rss_available: u32,
+    pub peak_rss_available: u32,
+}
+
+/// Fixed-layout result from one explicit binary64 on-the-fly warm-up.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct RusticolWarmUpResult {
+    pub schema_version: u32,
+    pub reserved: u32,
+    pub elapsed_seconds: c_double,
+    pub query_count: u64,
+    pub warmed_query_count: u64,
+    pub current_rss_bytes: u64,
+    pub peak_rss_bytes: u64,
+    pub current_rss_available: u32,
+    pub peak_rss_available: u32,
+    pub already_warm: u32,
+    pub first_evaluation_completed: u32,
+}
+
+/// Return nonzero to continue or zero to request cancellation.
+///
+/// The callback runs on the coordinating caller thread. The terminal
+/// first-evaluation `END` event is an informational post-commit notification;
+/// returning zero for that one event does not undo a completed warm-up.
+pub type RusticolWarmUpProgressCallback = Option<
+    unsafe extern "C" fn(
+        event: *const RusticolWarmUpProgressEvent,
+        user_data: *mut c_void,
+    ) -> c_int,
+>;
+
+pub struct RusticolRuntimeHandle {
+    runtime: NativeRuntime,
+}
+
+/// One borrowed literal complex spin-vector batch; see rusticol.h for layout.
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct RusticolSpinCorrelationVector {
+    pub leg: size_t,
+    pub point_count: size_t,
+    pub components: *const c_double,
+    pub component_count: size_t,
+}
+
+/// One ordered colour insertion and either explicit or inherited spin vectors.
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct RusticolCorrelatedRequest {
+    pub color_correlation: *const c_char,
+    pub spin_vectors: *const RusticolSpinCorrelationVector,
+    pub spin_vector_count: size_t,
+    pub use_default_spin_vectors: u32,
+}
+
+struct AbiError {
+    status: c_int,
+    message: String,
+}
+
+type AbiResult<T> = Result<T, AbiError>;
+
+impl From<RusticolError> for AbiError {
+    fn from(error: RusticolError) -> Self {
+        let status = match error.kind() {
+            RusticolErrorKind::InvalidArgument
+            | RusticolErrorKind::Selector
+            | RusticolErrorKind::ModelParameter
+            | RusticolErrorKind::UnsupportedPrecision => RUSTICOL_STATUS_INVALID_ARGUMENT,
+            _ => RUSTICOL_STATUS_RUNTIME_ERROR,
+        };
+        Self {
+            status,
+            message: error.to_string(),
+        }
+    }
+}
+
+thread_local! {
+    static LAST_ERROR: RefCell<CString> = RefCell::new(CString::new("").expect("empty CString"));
+}
+
+fn sanitize_c_string(message: impl AsRef<str>) -> CString {
+    let sanitized = message.as_ref().replace('\0', "\\0");
+    CString::new(sanitized)
+        .unwrap_or_else(|_| CString::new("Rusticol error").expect("literal CString"))
+}
+
+fn set_last_error(message: impl AsRef<str>) {
+    LAST_ERROR.with(|slot| *slot.borrow_mut() = sanitize_c_string(message));
+}
+
+fn guard(operation: impl FnOnce() -> AbiResult<()>) -> c_int {
+    finish_guard(catch_unwind(AssertUnwindSafe(operation)))
+}
+
+fn finish_guard(result: Result<AbiResult<()>, Box<dyn Any + Send>>) -> c_int {
+    match result {
+        Ok(Ok(())) => RUSTICOL_STATUS_OK,
+        Ok(Err(error)) => {
+            set_last_error(&error.message);
+            error.status
+        }
+        Err(payload) => {
+            let message = payload
+                .downcast_ref::<&str>()
+                .copied()
+                .or_else(|| payload.downcast_ref::<String>().map(String::as_str))
+                .unwrap_or("unknown Rust panic");
+            set_last_error(format!("Rusticol panic: {message}"));
+            RUSTICOL_STATUS_PANIC
+        }
+    }
+}
+
+fn abi_error(status: c_int, message: impl Into<String>) -> AbiError {
+    AbiError {
+        status,
+        message: message.into(),
+    }
+}
+
+fn invalid(message: impl Into<String>) -> AbiError {
+    abi_error(RUSTICOL_STATUS_INVALID_ARGUMENT, message)
+}
+
+fn buffer_too_small(message: impl Into<String>) -> AbiError {
+    abi_error(RUSTICOL_STATUS_BUFFER_TOO_SMALL, message)
+}
+
+unsafe fn required_handle<'a>(
+    handle: *const RusticolRuntimeHandle,
+) -> AbiResult<&'a RusticolRuntimeHandle> {
+    if handle.is_null() {
+        return Err(invalid("Rusticol runtime handle is null"));
+    }
+    // SAFETY: The caller promises that a non-null handle was returned by rusticol_runtime_load
+    // and remains alive for the duration of this call.
+    Ok(unsafe { &*handle })
+}
+
+unsafe fn required_handle_mut<'a>(
+    handle: *mut RusticolRuntimeHandle,
+) -> AbiResult<&'a mut RusticolRuntimeHandle> {
+    if handle.is_null() {
+        return Err(invalid("Rusticol runtime handle is null"));
+    }
+    // SAFETY: The ABI documents handles as mutable and non-concurrently callable.
+    Ok(unsafe { &mut *handle })
+}
+
+unsafe fn optional_c_string<'a>(value: *const c_char) -> AbiResult<Option<&'a str>> {
+    if value.is_null() {
+        return Ok(None);
+    }
+    // SAFETY: The caller supplies a NUL-terminated string for non-null pointers.
+    let value = unsafe { CStr::from_ptr(value) }
+        .to_str()
+        .map_err(|error| invalid(format!("C string is not valid UTF-8: {error}")))?;
+    Ok(Some(value))
+}
+
+unsafe fn required_c_string<'a>(value: *const c_char, name: &str) -> AbiResult<&'a str> {
+    unsafe { optional_c_string(value) }?.ok_or_else(|| invalid(format!("{name} is null")))
+}
+
+unsafe fn write_size(value: usize, output: *mut size_t, name: &str) -> AbiResult<()> {
+    if output.is_null() {
+        return Err(invalid(format!("{name} is null")));
+    }
+    // SAFETY: The caller supplies writable storage for one size_t.
+    unsafe { *output = value as size_t };
+    Ok(())
+}
+
+unsafe fn write_i32(value: i32, output: *mut i32, name: &str) -> AbiResult<()> {
+    if output.is_null() {
+        return Err(invalid(format!("{name} is null")));
+    }
+    // SAFETY: The caller supplies writable storage for one i32.
+    unsafe { *output = value };
+    Ok(())
+}
+
+unsafe fn write_string(
+    value: &str,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> AbiResult<()> {
+    let bytes = value.as_bytes();
+    let required_capacity = bytes
+        .len()
+        .checked_add(1)
+        .ok_or_else(|| invalid("string length overflow"))?;
+    unsafe { write_size(required_capacity, required, "required string capacity")? };
+    if buffer.is_null() {
+        if capacity == 0 {
+            return Ok(());
+        }
+        return Err(invalid("string output buffer is null"));
+    }
+    if capacity < required_capacity {
+        return Err(buffer_too_small(format!(
+            "string output buffer has capacity {capacity}, requires {required_capacity}"
+        )));
+    }
+    // SAFETY: Capacity was checked and the source does not overlap the caller's buffer.
+    unsafe {
+        ptr::copy_nonoverlapping(bytes.as_ptr(), buffer.cast::<u8>(), bytes.len());
+        *buffer.add(bytes.len()) = 0;
+    }
+    Ok(())
+}
+
+unsafe fn read_selector_ids(
+    values: *const *const c_char,
+    count: size_t,
+    name: &str,
+) -> AbiResult<Option<Vec<String>>> {
+    if count == 0 {
+        return Ok(None);
+    }
+    if values.is_null() {
+        return Err(invalid(format!("{name} array is null")));
+    }
+    // SAFETY: The caller supplies count string pointers.
+    let values = unsafe { slice::from_raw_parts(values, count) };
+    let mut result = Vec::with_capacity(count);
+    for (index, value) in values.iter().enumerate() {
+        result.push(unsafe { required_c_string(*value, &format!("{name}[{index}]")) }?.to_string());
+    }
+    Ok(Some(result))
+}
+
+unsafe fn read_f64_slice<'a>(
+    values: *const c_double,
+    count: size_t,
+    name: &str,
+) -> AbiResult<&'a [f64]> {
+    if count == 0 {
+        return Err(invalid(format!("{name} must not be empty")));
+    }
+    if values.is_null() {
+        return Err(invalid(format!("{name} is null")));
+    }
+    // SAFETY: The caller supplies count readable f64 values.
+    Ok(unsafe { slice::from_raw_parts(values, count) })
+}
+
+unsafe fn read_optional_u32_slice<'a>(
+    values: *const u32,
+    count: size_t,
+    expected_count: usize,
+    name: &str,
+) -> AbiResult<Option<&'a [u32]>> {
+    if count == 0 {
+        return Ok(None);
+    }
+    if values.is_null() {
+        return Err(invalid(format!("{name} is null")));
+    }
+    if count != expected_count {
+        return Err(invalid(format!(
+            "{name} has length {count}, expected {expected_count} (one selector per point)"
+        )));
+    }
+    // SAFETY: The caller supplies count readable u32 values.
+    Ok(Some(unsafe { slice::from_raw_parts(values, count) }))
+}
+
+unsafe fn write_f64_slice(
+    values: &[f64],
+    output: *mut c_double,
+    capacity: size_t,
+    name: &str,
+) -> AbiResult<()> {
+    if output.is_null() {
+        return Err(invalid(format!("{name} is null")));
+    }
+    if capacity < values.len() {
+        return Err(buffer_too_small(format!(
+            "{name} has capacity {capacity}, requires {}",
+            values.len()
+        )));
+    }
+    // SAFETY: Capacity was checked and the source cannot overlap the caller-owned output.
+    unsafe { ptr::copy_nonoverlapping(values.as_ptr(), output, values.len()) };
+    Ok(())
+}
+
+fn validate_f64_output(
+    output: *mut c_double,
+    capacity: size_t,
+    required: usize,
+    name: &str,
+) -> AbiResult<()> {
+    if output.is_null() {
+        return Err(invalid(format!("{name} is null")));
+    }
+    if capacity < required {
+        return Err(buffer_too_small(format!(
+            "{name} has capacity {capacity}, requires {required}"
+        )));
+    }
+    Ok(())
+}
+
+fn warm_up_event_kind(kind: NativeOnTheFlyWarmUpEventKind) -> u32 {
+    match kind {
+        NativeOnTheFlyWarmUpEventKind::Start => RUSTICOL_WARM_UP_EVENT_START,
+        NativeOnTheFlyWarmUpEventKind::Update => RUSTICOL_WARM_UP_EVENT_UPDATE,
+        NativeOnTheFlyWarmUpEventKind::End => RUSTICOL_WARM_UP_EVENT_END,
+    }
+}
+
+fn warm_up_stage(stage: NativeOnTheFlyWarmUpStage) -> u32 {
+    match stage {
+        NativeOnTheFlyWarmUpStage::ProcessPreparation => RUSTICOL_WARM_UP_STAGE_PROCESS_PREPARATION,
+        NativeOnTheFlyWarmUpStage::QueryFamily => RUSTICOL_WARM_UP_STAGE_QUERY_FAMILY,
+        NativeOnTheFlyWarmUpStage::FamilyFinalization => RUSTICOL_WARM_UP_STAGE_FAMILY_FINALIZATION,
+        NativeOnTheFlyWarmUpStage::FirstEvaluation => RUSTICOL_WARM_UP_STAGE_FIRST_EVALUATION,
+    }
+}
+
+fn warm_up_progress_event(event: &NativeOnTheFlyWarmUpEvent) -> RusticolWarmUpProgressEvent {
+    RusticolWarmUpProgressEvent {
+        schema_version: event.schema_version,
+        kind: warm_up_event_kind(event.kind),
+        stage: warm_up_stage(event.stage),
+        reserved: 0,
+        completed: event.completed,
+        total: event.total,
+        elapsed_seconds: event.elapsed_seconds,
+        current_rss_bytes: event.current_rss_bytes.unwrap_or_default(),
+        peak_rss_bytes: event.peak_rss_bytes.unwrap_or_default(),
+        workers: event.workers,
+        current_rss_available: u32::from(event.current_rss_bytes.is_some()),
+        peak_rss_available: u32::from(event.peak_rss_bytes.is_some()),
+    }
+}
+
+fn warm_up_result(result: NativeOnTheFlyWarmUpResult) -> RusticolWarmUpResult {
+    RusticolWarmUpResult {
+        schema_version: result.schema_version,
+        reserved: 0,
+        elapsed_seconds: result.elapsed_seconds,
+        query_count: result.query_count,
+        warmed_query_count: result.warmed_query_count,
+        current_rss_bytes: result.current_rss_bytes.unwrap_or_default(),
+        peak_rss_bytes: result.peak_rss_bytes.unwrap_or_default(),
+        current_rss_available: u32::from(result.current_rss_bytes.is_some()),
+        peak_rss_available: u32::from(result.peak_rss_bytes.is_some()),
+        already_warm: u32::from(result.already_warm),
+        first_evaluation_completed: u32::from(result.first_evaluation_completed),
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn rusticol_abi_version() -> u32 {
+    catch_unwind(|| NativeRuntime::ABI_VERSION).unwrap_or(0)
+}
+
+/// Returns the supported runtime capabilities as JSON.
+///
+/// # Safety
+///
+/// If non-null, `required` must be writable for one `size_t`. If non-null, `buffer` must be
+/// writable for `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_supported_runtime_capabilities_json(
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    guard(|| {
+        let json = serde_json::to_string(&supported_runtime_capabilities()).map_err(|error| {
+            AbiError::from(RusticolError::serialization(format!(
+                "could not serialize supported runtime capabilities: {error}"
+            )))
+        })?;
+        // SAFETY: Pointer validation and copying are performed by write_string.
+        unsafe { write_string(&json, buffer, capacity, required) }
+    })
+}
+
+/// Copies the calling thread's last Rusticol error message.
+///
+/// # Safety
+///
+/// If non-null, `required` must be writable for one `size_t`. If non-null, `buffer` must be
+/// writable for `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_last_error_message(
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    match catch_unwind(AssertUnwindSafe(|| {
+        LAST_ERROR.with(|slot| {
+            let value = slot.borrow();
+            // SAFETY: Pointer validation and copying are performed by write_string.
+            unsafe {
+                write_string(
+                    value.to_str().unwrap_or("Rusticol error"),
+                    buffer,
+                    capacity,
+                    required,
+                )
+            }
+        })
+    })) {
+        Ok(Ok(())) => RUSTICOL_STATUS_OK,
+        Ok(Err(error)) => {
+            set_last_error(&error.message);
+            error.status
+        }
+        Err(_) => {
+            set_last_error("Rusticol panic while retrieving the last error message");
+            RUSTICOL_STATUS_PANIC
+        }
+    }
+}
+
+/// Loads a Rusticol runtime and returns an owning opaque handle.
+///
+/// # Safety
+///
+/// Every non-null string pointer must reference a readable NUL-terminated string for the duration
+/// of the call. If non-null, `output` must be writable for one handle pointer. A handle returned
+/// through `output` must eventually be released exactly once with [`rusticol_runtime_free`].
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_load(
+    process_dir: *const c_char,
+    process_key: *const c_char,
+    model_parameters_path: *const c_char,
+    output: *mut *mut RusticolRuntimeHandle,
+) -> c_int {
+    guard(|| {
+        if output.is_null() {
+            return Err(invalid("runtime output handle is null"));
+        }
+        // SAFETY: The caller supplies writable handle storage.
+        unsafe { *output = ptr::null_mut() };
+        // SAFETY: String pointers follow the ABI contract; output is checked above.
+        let process_dir = unsafe { required_c_string(process_dir, "process_dir") }?;
+        let process_key = unsafe { optional_c_string(process_key) }?;
+        let model_parameters = unsafe { optional_c_string(model_parameters_path) }?;
+        let runtime =
+            NativeRuntime::load(process_dir, process_key, model_parameters.map(Path::new))?;
+        let boxed = Box::new(RusticolRuntimeHandle { runtime });
+        // SAFETY: output points to writable handle storage supplied by the caller.
+        unsafe { *output = Box::into_raw(boxed) };
+        Ok(())
+    })
+}
+
+/// Saves the completed, retained OTF recursion cache to a file.
+///
+/// # Safety
+///
+/// `handle` must be a live runtime handle, and `path` must reference a readable
+/// NUL-terminated UTF-8 string. No other call on this handle may overlap this call.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_save(
+    handle: *const RusticolRuntimeHandle,
+    path: *const c_char,
+) -> c_int {
+    guard(|| {
+        // SAFETY: The handle and string follow the ABI contract above.
+        let runtime = unsafe { required_handle(handle) }?;
+        let path = unsafe { required_c_string(path, "cache path") }?;
+        runtime.runtime.save(path)?;
+        Ok(())
+    })
+}
+
+/// Restores a saved OTF recursion cache into an already-loaded matching process.
+///
+/// # Safety
+///
+/// `handle` must be a live runtime handle, and `path` must reference a readable
+/// NUL-terminated UTF-8 string. No other call on this handle may overlap this call.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_load_cache(
+    handle: *mut RusticolRuntimeHandle,
+    path: *const c_char,
+) -> c_int {
+    guard(|| {
+        // SAFETY: The handle and string follow the ABI contract above.
+        let runtime = unsafe { required_handle_mut(handle) }?;
+        let path = unsafe { required_c_string(path, "cache path") }?;
+        runtime.runtime.load_cache(path)?;
+        Ok(())
+    })
+}
+
+/// Releases a Rusticol runtime handle.
+///
+/// # Safety
+///
+/// `handle` must be null or a live handle returned by [`rusticol_runtime_load`] that has not
+/// already been freed. No other access to a non-null handle may overlap this call.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_free(handle: *mut RusticolRuntimeHandle) -> c_int {
+    guard(|| {
+        if !handle.is_null() {
+            // SAFETY: The caller must free a live handle exactly once.
+            unsafe { drop(Box::from_raw(handle)) };
+        }
+        Ok(())
+    })
+}
+
+unsafe fn runtime_string(
+    handle: *const RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+    get: impl FnOnce(&NativeRuntime) -> AbiResult<String>,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Handle and output pointers are validated by helpers.
+        let handle = unsafe { required_handle(handle) }?;
+        let value = get(&handle.runtime)?;
+        unsafe { write_string(&value, buffer, capacity, required) }
+    })
+}
+
+/// Copies the existing content identity of the authenticated artifact manifest.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_artifact_id(
+    handle: *const RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            Ok(runtime.artifact_id().to_owned())
+        })
+    }
+}
+
+/// Copies the runtime metadata as JSON.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_metadata_json(
+    handle: *const RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            Ok(runtime.metadata_json()?)
+        })
+    }
+}
+
+/// Copies the runtime physics metadata as JSON.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_physics_json(
+    handle: *const RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            Ok(runtime.physics_json()?)
+        })
+    }
+}
+
+/// Copies the runtime process name.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_process(
+    handle: *const RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            Ok(runtime.metadata().process)
+        })
+    }
+}
+
+/// Copies the runtime process key.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_process_key(
+    handle: *const RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            Ok(runtime.metadata().process_key)
+        })
+    }
+}
+
+/// Copies the stable representative process key implementing this selection.
+///
+/// # Safety
+///
+/// Pointer requirements are identical to [`rusticol_runtime_process_key`].
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_representative_process_key(
+    handle: *const RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            Ok(runtime.metadata().representative_process_key)
+        })
+    }
+}
+
+/// Copies the runtime color-accuracy label.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_color_accuracy(
+    handle: *const RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            Ok(runtime.metadata().color_accuracy)
+        })
+    }
+}
+
+/// Writes the number of external particles.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `output` must be writable for one `size_t`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_external_count(
+    handle: *const RusticolRuntimeHandle,
+    output: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle(handle) }?;
+        unsafe { write_size(handle.runtime.external_count(), output, "external count") }
+    })
+}
+
+/// Copies the runtime execution mode (`compiled`, `eager`, or `recurrence`).
+///
+/// # Safety
+///
+/// `handle` must be a live handle returned by [`rusticol_runtime_load`]. If non-null,
+/// `required` must be writable for one `size_t`. If non-null, `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_execution_mode(
+    handle: *const RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: The ABI requires a live handle for this call.
+        let handle = unsafe { required_handle(handle) }?;
+        let execution_mode = handle.runtime.metadata().execution_mode;
+        // SAFETY: Pointer validation and copying are performed by write_string.
+        unsafe { write_string(&execution_mode, buffer, capacity, required) }
+    })
+}
+
+/// Writes the PDG identifier for one external particle.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `output` must be writable for one `i32`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_external_pdg(
+    handle: *const RusticolRuntimeHandle,
+    index: size_t,
+    output: *mut i32,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle(handle) }?;
+        let particles = handle.runtime.external_particles()?;
+        let particle = particles
+            .get(index)
+            .ok_or_else(|| invalid(format!("external particle index {index} is out of range")))?;
+        unsafe { write_i32(particle.pdg, output, "external PDG output") }
+    })
+}
+
+/// Copies the representative-index to public-index external permutation.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live. If non-null, `required` must be writable for one
+/// `size_t`; `output` must be writable for `capacity` `size_t` values. A null output is valid
+/// only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_external_permutation(
+    handle: *const RusticolRuntimeHandle,
+    output: *mut size_t,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle(handle) }?;
+        let permutation = handle.runtime.metadata().external_permutation;
+        unsafe { write_size(permutation.len(), required, "external permutation length")? };
+        if output.is_null() {
+            if capacity == 0 {
+                return Ok(());
+            }
+            return Err(invalid("external permutation output is null"));
+        }
+        if capacity < permutation.len() {
+            return Err(buffer_too_small(format!(
+                "external permutation capacity {capacity} is smaller than {}",
+                permutation.len()
+            )));
+        }
+        // SAFETY: Capacity was checked and usize matches C size_t.
+        unsafe { ptr::copy_nonoverlapping(permutation.as_ptr(), output, permutation.len()) };
+        Ok(())
+    })
+}
+
+/// Writes the exact factor and charge conjugation relating the selected process to the
+/// representative that evaluates it: `ME = numerator / denominator * ME_representative`.
+/// Selections other than non-generated process-group members report `1/1` and `0`.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live. Each output must be writable for one value.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_process_group_relation(
+    handle: *const RusticolRuntimeHandle,
+    numerator: *mut u64,
+    denominator: *mut u64,
+    conjugated: *mut i32,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle(handle) }?;
+        if numerator.is_null() || denominator.is_null() {
+            return Err(invalid("process-group factor output is null"));
+        }
+        let factor = handle.runtime.process_group_factor();
+        // SAFETY: The caller supplies writable storage for one u64 each.
+        unsafe {
+            *numerator = factor.numerator;
+            *denominator = factor.denominator;
+        }
+        unsafe {
+            write_i32(
+                i32::from(handle.runtime.charge_conjugated()),
+                conjugated,
+                "charge-conjugation output",
+            )
+        }
+    })
+}
+
+/// Loads one JSON kinematic point in public/requested external order.
+///
+/// # Safety
+///
+/// `path` must reference a readable NUL-terminated string. Other pointer requirements match
+/// [`rusticol_runtime_external_permutation`], with `output` containing f64 values.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_load_kinematics_json(
+    handle: *const RusticolRuntimeHandle,
+    path: *const c_char,
+    output: *mut c_double,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle(handle) }?;
+        let value_count = handle
+            .runtime
+            .external_count()
+            .checked_mul(4)
+            .ok_or_else(|| invalid("kinematics value count overflows size_t"))?;
+        unsafe { write_size(value_count, required, "kinematics value count")? };
+        if output.is_null() {
+            if capacity == 0 {
+                return Ok(());
+            }
+            return Err(invalid("kinematics output is null"));
+        }
+        if capacity < value_count {
+            return Err(buffer_too_small(format!(
+                "kinematics capacity {capacity} is smaller than {}",
+                value_count
+            )));
+        }
+        let path = unsafe { required_c_string(path, "kinematics path") }?;
+        let values = handle.runtime.load_kinematics_json(Path::new(path))?;
+        if values.len() != value_count {
+            return Err(invalid(format!(
+                "kinematics JSON contains {} values, expected {value_count}",
+                values.len()
+            )));
+        }
+        // SAFETY: Capacity was checked.
+        unsafe { ptr::copy_nonoverlapping(values.as_ptr(), output, value_count) };
+        Ok(())
+    })
+}
+
+/// Writes the number of helicity configurations.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `output` must be writable for one `size_t`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_helicity_count(
+    handle: *const RusticolRuntimeHandle,
+    output: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle(handle) }?;
+        unsafe { write_size(handle.runtime.helicities()?.len(), output, "helicity count") }
+    })
+}
+
+/// Copies a helicity identifier.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_helicity_id(
+    handle: *const RusticolRuntimeHandle,
+    index: size_t,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            runtime
+                .helicities()?
+                .get(index)
+                .map(|item| item.id.clone())
+                .ok_or_else(|| invalid(format!("helicity index {index} is out of range")))
+        })
+    }
+}
+
+/// Copies one helicity vector.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `output` must be writable for
+/// `capacity` `i32` values. A null `output` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_helicity_vector(
+    handle: *const RusticolRuntimeHandle,
+    index: size_t,
+    output: *mut i32,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle(handle) }?;
+        let helicities = handle.runtime.helicities()?;
+        let item = helicities
+            .get(index)
+            .ok_or_else(|| invalid(format!("helicity index {index} is out of range")))?;
+        unsafe { write_size(item.helicities.len(), required, "helicity vector length")? };
+        if output.is_null() {
+            if capacity == 0 {
+                return Ok(());
+            }
+            return Err(invalid("helicity vector output is null"));
+        }
+        if capacity < item.helicities.len() {
+            return Err(buffer_too_small(format!(
+                "helicity vector capacity {capacity} is smaller than {}",
+                item.helicities.len()
+            )));
+        }
+        // SAFETY: Capacity was checked.
+        unsafe {
+            ptr::copy_nonoverlapping(item.helicities.as_ptr(), output, item.helicities.len())
+        };
+        Ok(())
+    })
+}
+
+/// Writes the number of color components.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `output` must be writable for one `size_t`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_color_count(
+    handle: *const RusticolRuntimeHandle,
+    output: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle(handle) }?;
+        unsafe {
+            write_size(
+                handle.runtime.color_components()?.len(),
+                output,
+                "color count",
+            )
+        }
+    })
+}
+
+/// Copies a color-component identifier.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_color_id(
+    handle: *const RusticolRuntimeHandle,
+    index: size_t,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            runtime
+                .color_components()?
+                .get(index)
+                .map(|item| item.id.clone())
+                .ok_or_else(|| invalid(format!("color index {index} is out of range")))
+        })
+    }
+}
+
+/// Copies a color-component kind.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_color_kind(
+    handle: *const RusticolRuntimeHandle,
+    index: size_t,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            runtime
+                .color_components()?
+                .get(index)
+                .map(|item| item.kind.clone())
+                .ok_or_else(|| invalid(format!("color index {index} is out of range")))
+        })
+    }
+}
+
+/// Copies one color word.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `output` must be writable for
+/// `capacity` `size_t` values. A null `output` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_color_word(
+    handle: *const RusticolRuntimeHandle,
+    index: size_t,
+    output: *mut size_t,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle(handle) }?;
+        let colors = handle.runtime.color_components()?;
+        let item = colors
+            .get(index)
+            .ok_or_else(|| invalid(format!("color index {index} is out of range")))?;
+        unsafe { write_size(item.word.len(), required, "color word length")? };
+        if output.is_null() {
+            if capacity == 0 {
+                return Ok(());
+            }
+            return Err(invalid("color word output is null"));
+        }
+        if capacity < item.word.len() {
+            return Err(buffer_too_small(format!(
+                "color word capacity {capacity} is smaller than {}",
+                item.word.len()
+            )));
+        }
+        // SAFETY: Capacity was checked and usize matches C size_t.
+        unsafe { ptr::copy_nonoverlapping(item.word.as_ptr(), output, item.word.len()) };
+        Ok(())
+    })
+}
+
+/// Writes the number of model parameters.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `output` must be writable for one `size_t`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_model_parameter_count(
+    handle: *const RusticolRuntimeHandle,
+    output: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle(handle) }?;
+        unsafe {
+            write_size(
+                handle.runtime.model_parameters()?.len(),
+                output,
+                "model parameter count",
+            )
+        }
+    })
+}
+
+/// Copies a model-parameter name.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. If
+/// non-null, `required` must be writable for one `size_t`, and `buffer` must be writable for
+/// `capacity` bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_model_parameter_name(
+    handle: *const RusticolRuntimeHandle,
+    index: size_t,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    // SAFETY: The caller upholds this function's pointer contract.
+    unsafe {
+        runtime_string(handle, buffer, capacity, required, |runtime| {
+            runtime
+                .model_parameters()?
+                .get(index)
+                .map(|item| item.name.clone())
+                .ok_or_else(|| invalid(format!("model parameter index {index} is out of range")))
+        })
+    }
+}
+
+/// Writes the resolved helicity and color dimensions for a selector set.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and available for shared access during the call. For each
+/// nonzero selector count, the corresponding pointer must reference that many readable string
+/// pointers, and every non-null string pointer must reference a readable NUL-terminated string.
+/// Non-null output pointers must each be writable for one `size_t`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_resolved_shape(
+    handle: *const RusticolRuntimeHandle,
+    helicity_ids: *const *const c_char,
+    helicity_count: size_t,
+    color_ids: *const *const c_char,
+    color_count: size_t,
+    output_helicity_count: *mut size_t,
+    output_color_count: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers and arrays.
+        let handle = unsafe { required_handle(handle) }?;
+        let helicities =
+            unsafe { read_selector_ids(helicity_ids, helicity_count, "helicity ids") }?;
+        let colors = unsafe { read_selector_ids(color_ids, color_count, "color ids") }?;
+        let (helicity_count, color_count) = handle
+            .runtime
+            .resolved_shape(helicities.as_deref(), colors.as_deref())?;
+        unsafe {
+            write_size(
+                helicity_count,
+                output_helicity_count,
+                "resolved helicity count",
+            )?;
+            write_size(color_count, output_color_count, "resolved color count")
+        }
+    })
+}
+
+/// Warms one binary64 point using the process-output construction default.
+///
+/// This preserves the original C ABI and forwards to
+/// [`rusticol_runtime_warm_up_f64_with_cores`] with `n_cores=0`.
+///
+/// # Safety
+///
+/// The same pointer, storage, and callback requirements as
+/// [`rusticol_runtime_warm_up_f64_with_cores`] apply.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_warm_up_f64(
+    handle: *mut RusticolRuntimeHandle,
+    momenta: *const c_double,
+    momentum_count: size_t,
+    helicity_ids: *const *const c_char,
+    helicity_count: size_t,
+    color_ids: *const *const c_char,
+    color_count: size_t,
+    progress_callback: RusticolWarmUpProgressCallback,
+    progress_user_data: *mut c_void,
+    output: *mut RusticolWarmUpResult,
+) -> c_int {
+    // SAFETY: This forwards the caller's storage and callback unchanged.
+    unsafe {
+        rusticol_runtime_warm_up_f64_with_cores(
+            handle,
+            momenta,
+            momentum_count,
+            helicity_ids,
+            helicity_count,
+            color_ids,
+            color_count,
+            0,
+            progress_callback,
+            progress_user_data,
+            output,
+        )
+    }
+}
+
+/// Explicitly warms one binary64 point for an on-the-fly runtime selection.
+///
+/// This constructs and retains the selected OTF query family, performs exactly one evaluation,
+/// and returns a fixed-layout summary. Global selector arrays contain physical string IDs; an
+/// omitted selector axis is summed over every component retained by the artifact. Progress is
+/// reported only from the coordinating caller thread and is throttled by the core runtime.
+/// Returning zero from the callback requests cancellation at a cancellable cold-path boundary.
+/// The terminal first-evaluation `END` event is post-commit and informational.
+/// A zero `n_cores` uses the process-output construction default; a positive value overrides
+/// construction workers for this warm-up only, without changing evaluation or cache identity.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and exclusively accessible during the call. `momenta`
+/// must reference `momentum_count` readable `f64` values containing exactly one point in
+/// `[external particle][E, px, py, pz]` order. For each nonzero selector count, the corresponding
+/// pointer must reference that many readable NUL-terminated string pointers. `output` must be
+/// writable for one [`RusticolWarmUpResult`]. If supplied, `progress_callback` must remain callable
+/// for the duration of this function and may use `progress_user_data`; it must not call the same
+/// runtime handle recursively.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_warm_up_f64_with_cores(
+    handle: *mut RusticolRuntimeHandle,
+    momenta: *const c_double,
+    momentum_count: size_t,
+    helicity_ids: *const *const c_char,
+    helicity_count: size_t,
+    color_ids: *const *const c_char,
+    color_count: size_t,
+    n_cores: size_t,
+    progress_callback: RusticolWarmUpProgressCallback,
+    progress_user_data: *mut c_void,
+    output: *mut RusticolWarmUpResult,
+) -> c_int {
+    guard(|| {
+        if output.is_null() {
+            return Err(invalid("warm-up result output is null"));
+        }
+        // SAFETY: The caller supplies writable result storage. Initialize it before any
+        // fallible operation so failures never leave stale success data behind.
+        unsafe { *output = RusticolWarmUpResult::default() };
+
+        // SAFETY: Helpers validate the handle and all input arrays.
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let momenta = unsafe { read_f64_slice(momenta, momentum_count, "warm-up momenta") }?;
+        let helicities =
+            unsafe { read_selector_ids(helicity_ids, helicity_count, "helicity ids") }?;
+        let colors = unsafe { read_selector_ids(color_ids, color_count, "color ids") }?;
+        let n_cores = (n_cores != 0).then_some(n_cores);
+
+        let result = if let Some(callback) = progress_callback {
+            let mut observer = |event: &NativeOnTheFlyWarmUpEvent| {
+                let event = warm_up_progress_event(event);
+                // SAFETY: The caller guarantees that the callback and user-data pointer remain
+                // valid for this call. The borrowed event lives through the callback only.
+                Ok(unsafe { callback(&event, progress_user_data) } != 0)
+            };
+            handle.runtime.warm_up_f64(
+                momenta,
+                helicities.as_deref(),
+                colors.as_deref(),
+                n_cores,
+                Some(&mut observer),
+            )
+        } else {
+            handle.runtime.warm_up_f64(
+                momenta,
+                helicities.as_deref(),
+                colors.as_deref(),
+                n_cores,
+                None,
+            )
+        }
+        .map_err(AbiError::from)?;
+
+        // SAFETY: The non-null output was validated before invoking the runtime.
+        unsafe { *output = warm_up_result(result) };
+        Ok(())
+    })
+}
+
+/// Evaluates total f64 matrix elements for a batch of momentum points.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and exclusively accessible during the call. If non-null,
+/// `momenta` must reference `momentum_count` readable `f64` values and `output` must reference
+/// `output_capacity` writable `f64` values. The input and output regions must not overlap.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_evaluate_f64(
+    handle: *mut RusticolRuntimeHandle,
+    momenta: *const c_double,
+    momentum_count: size_t,
+    point_count: size_t,
+    output: *mut c_double,
+    output_capacity: size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate all pointers.
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let momenta = unsafe { read_f64_slice(momenta, momentum_count, "momenta") }?;
+        validate_f64_output(output, output_capacity, point_count, "total output")?;
+        // SAFETY: The output pointer is non-null and has at least point_count writable values.
+        // Restrict the mutable slice to the exact result prefix so excess caller capacity and
+        // trailing canaries remain untouched.
+        let output = unsafe { slice::from_raw_parts_mut(output, point_count) };
+        handle
+            .runtime
+            .evaluate_f64_into(momenta, point_count, output)
+            .map_err(AbiError::from)
+    })
+}
+
+/// Evaluates total f64 matrix elements with optional global or per-point selectors.
+///
+/// Global selector arrays contain physical helicity/color string IDs and retain subset/sum
+/// semantics. Per-point selector arrays contain zero-based physical-axis indices and must contain
+/// exactly one selector for every input point. Global and per-point selectors are mutually
+/// exclusive on the same axis. An omitted axis is summed over every component retained by the
+/// artifact.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and exclusively accessible during the call. `momenta` must
+/// reference `momentum_count` readable `f64` values and `output` must reference `output_capacity`
+/// writable `f64` values; those regions must not overlap. For each nonzero global selector count,
+/// the corresponding pointer must reference that many readable string pointers and each string
+/// must be NUL-terminated. For each nonzero per-point selector count, the corresponding pointer
+/// must reference exactly `point_count` readable `u32` values.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_evaluate_selected_f64(
+    handle: *mut RusticolRuntimeHandle,
+    momenta: *const c_double,
+    momentum_count: size_t,
+    point_count: size_t,
+    helicity_ids: *const *const c_char,
+    helicity_count: size_t,
+    color_ids: *const *const c_char,
+    color_count: size_t,
+    helicity_by_point: *const u32,
+    helicity_by_point_count: size_t,
+    color_flow_by_point: *const u32,
+    color_flow_by_point_count: size_t,
+    output: *mut c_double,
+    output_capacity: size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate all pointers and arrays.
+        let handle = unsafe { required_handle_mut(handle) }?;
+        if point_count == 0 {
+            return Err(invalid("point_count must be positive"));
+        }
+        let momenta = unsafe { read_f64_slice(momenta, momentum_count, "momenta") }?;
+        let helicities =
+            unsafe { read_selector_ids(helicity_ids, helicity_count, "helicity ids") }?;
+        let colors = unsafe { read_selector_ids(color_ids, color_count, "color ids") }?;
+        let helicity_by_point = unsafe {
+            read_optional_u32_slice(
+                helicity_by_point,
+                helicity_by_point_count,
+                point_count,
+                "helicity_by_point",
+            )
+        }?;
+        let color_flow_by_point = unsafe {
+            read_optional_u32_slice(
+                color_flow_by_point,
+                color_flow_by_point_count,
+                point_count,
+                "color_flow_by_point",
+            )
+        }?;
+        if helicities.is_some() && helicity_by_point.is_some() {
+            return Err(invalid(
+                "helicity ids and helicity_by_point are mutually exclusive",
+            ));
+        }
+        if colors.is_some() && color_flow_by_point.is_some() {
+            return Err(invalid(
+                "color ids and color_flow_by_point are mutually exclusive",
+            ));
+        }
+        validate_f64_output(output, output_capacity, point_count, "total output")?;
+        // SAFETY: The output pointer is non-null and has at least point_count writable values.
+        // Restrict the mutable slice to the exact result prefix so excess caller capacity and
+        // trailing canaries remain untouched.
+        let output = unsafe { slice::from_raw_parts_mut(output, point_count) };
+        handle
+            .runtime
+            .evaluate_f64_into_with_selectors(
+                momenta,
+                point_count,
+                helicities.as_deref(),
+                colors.as_deref(),
+                helicity_by_point,
+                color_flow_by_point,
+                output,
+            )
+            .map_err(AbiError::from)
+    })
+}
+
+/// Evaluates resolved f64 matrix elements for a batch of momentum points.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and exclusively accessible during the call. If non-null,
+/// `momenta` must reference `momentum_count` readable `f64` values and `output` must reference
+/// `output_capacity` writable `f64` values; those regions must not overlap. For each nonzero
+/// selector count, the corresponding pointer must reference that many readable string pointers,
+/// and every non-null string pointer must reference a readable NUL-terminated string. Non-null
+/// shape outputs must each be writable for one `size_t`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_evaluate_resolved_f64(
+    handle: *mut RusticolRuntimeHandle,
+    momenta: *const c_double,
+    momentum_count: size_t,
+    point_count: size_t,
+    helicity_ids: *const *const c_char,
+    helicity_count: size_t,
+    color_ids: *const *const c_char,
+    color_count: size_t,
+    output: *mut c_double,
+    output_capacity: size_t,
+    output_helicity_count: *mut size_t,
+    output_color_count: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate all pointers and arrays.
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let momenta = unsafe { read_f64_slice(momenta, momentum_count, "momenta") }?;
+        let helicities =
+            unsafe { read_selector_ids(helicity_ids, helicity_count, "helicity ids") }?;
+        let colors = unsafe { read_selector_ids(color_ids, color_count, "color ids") }?;
+        if output_helicity_count.is_null() {
+            return Err(invalid("resolved helicity count output is null"));
+        }
+        if output_color_count.is_null() {
+            return Err(invalid("resolved color count output is null"));
+        }
+        if point_count == 0 {
+            return Err(invalid("point_count must be positive"));
+        }
+        let (expected_helicity_count, expected_color_count) = handle
+            .runtime
+            .resolved_shape(helicities.as_deref(), colors.as_deref())?;
+        let required = point_count
+            .checked_mul(expected_helicity_count)
+            .and_then(|value| value.checked_mul(expected_color_count))
+            .ok_or_else(|| invalid("resolved output shape overflow"))?;
+        validate_f64_output(output, output_capacity, required, "resolved output")?;
+        let resolved = handle.runtime.evaluate_resolved_f64(
+            momenta,
+            point_count,
+            helicities.as_deref(),
+            colors.as_deref(),
+        )?;
+        let (_, helicity_count, color_count) = resolved.shape();
+        if helicity_count != expected_helicity_count || color_count != expected_color_count {
+            return Err(abi_error(
+                RUSTICOL_STATUS_RUNTIME_ERROR,
+                "resolved evaluation shape changed after buffer validation",
+            ));
+        }
+        unsafe {
+            write_size(
+                helicity_count,
+                output_helicity_count,
+                "resolved helicity count",
+            )?;
+            write_size(color_count, output_color_count, "resolved color count")?;
+            write_f64_slice(&resolved.values, output, output_capacity, "resolved output")
+        }
+    })
+}
+
+/// Updates multiple runtime model parameters atomically.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and exclusively accessible during the call. For nonzero
+/// `count`, `names` must reference `count` readable string pointers, every non-null string pointer
+/// must reference a readable NUL-terminated string, and `real` and `imaginary` must each reference
+/// `count` readable `f64` values.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_set_model_parameters(
+    handle: *mut RusticolRuntimeHandle,
+    names: *const *const c_char,
+    real: *const c_double,
+    imaginary: *const c_double,
+    count: size_t,
+) -> c_int {
+    guard(|| {
+        if count == 0 {
+            return Err(invalid("model parameter update must not be empty"));
+        }
+        // SAFETY: Helpers and explicit checks validate all pointers.
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let names = unsafe { read_selector_ids(names, count, "model parameter names") }?
+            .expect("positive count returns names");
+        let real = unsafe { read_f64_slice(real, count, "model parameter real values") }?;
+        let imaginary =
+            unsafe { read_f64_slice(imaginary, count, "model parameter imaginary values") }?;
+        let mut values = BTreeMap::new();
+        for index in 0..count {
+            if values
+                .insert(names[index].clone(), (real[index], imaginary[index]))
+                .is_some()
+            {
+                return Err(invalid(format!(
+                    "duplicate model parameter update {:?}",
+                    names[index]
+                )));
+            }
+        }
+        Ok(handle.runtime.set_model_parameters(&values)?)
+    })
+}
+
+/// Updates one runtime model parameter.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and exclusively accessible during the call. A non-null
+/// `name` must reference a readable NUL-terminated string for the duration of the call.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_set_model_parameter(
+    handle: *mut RusticolRuntimeHandle,
+    name: *const c_char,
+    real: c_double,
+    imaginary: c_double,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let name = unsafe { required_c_string(name, "model parameter name") }?;
+        Ok(handle.runtime.set_model_parameter(name, real, imaginary)?)
+    })
+}
+
+/// Reads a current runtime model parameter, including refreshed derived values.
+///
+/// # Safety
+///
+/// The handle must remain live and shared-accessible; name must be a readable
+/// NUL-terminated string. Both outputs must be writable for one double.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_get_model_parameter(
+    handle: *const RusticolRuntimeHandle,
+    name: *const c_char,
+    real: *mut c_double,
+    imaginary: *mut c_double,
+) -> c_int {
+    guard(|| {
+        if real.is_null() || imaginary.is_null() {
+            return Err(invalid("model parameter outputs must be non-null"));
+        }
+        // SAFETY: The helpers validate the pointer arguments.
+        let handle = unsafe { required_handle(handle) }?;
+        let name = unsafe { required_c_string(name, "model parameter name") }?;
+        let value = handle.runtime.model_parameter_value(name)?;
+        // SAFETY: Non-null output storage is guaranteed by the caller contract.
+        unsafe {
+            *real = value.0;
+            *imaginary = value.1;
+        }
+        Ok(())
+    })
+}
+
+/// Updates runtime model parameters from a JSON file.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and exclusively accessible during the call. A non-null
+/// `path` must reference a readable NUL-terminated string for the duration of the call.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_set_model_parameters_json(
+    handle: *mut RusticolRuntimeHandle,
+    path: *const c_char,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let path = unsafe { required_c_string(path, "model parameter JSON path") }?;
+        Ok(handle.runtime.set_model_parameters_json(Path::new(path))?)
+    })
+}
+
+/// Mutes or unmutes runtime warnings.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and exclusively accessible during the call.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_mute_warnings(
+    handle: *mut RusticolRuntimeHandle,
+    muted: c_int,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helper validates the handle.
+        let handle = unsafe { required_handle_mut(handle) }?;
+        if muted == 0 {
+            handle.runtime.unmute_warnings();
+        } else {
+            handle.runtime.mute_warnings();
+        }
+        Ok(())
+    })
+}
+
+/// Copies and consumes the runtime's pending warnings as JSON.
+///
+/// # Safety
+///
+/// A non-null `handle` must remain live and exclusively accessible during the call. If non-null,
+/// `required` must be writable for one `size_t`, and `buffer` must be writable for `capacity`
+/// bytes. A null `buffer` is valid only for a zero-capacity query.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rusticol_runtime_take_warnings_json(
+    handle: *mut RusticolRuntimeHandle,
+    buffer: *mut c_char,
+    capacity: size_t,
+    required: *mut size_t,
+) -> c_int {
+    guard(|| {
+        // SAFETY: Helpers validate pointers.
+        let handle = unsafe { required_handle_mut(handle) }?;
+        let json = handle.runtime.pending_warnings_json()?;
+        unsafe { write_string(&json, buffer, capacity, required)? };
+        if !buffer.is_null() {
+            handle.runtime.clear_pending_warnings();
+        }
+        Ok(())
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_abi_error_is_thread_local_and_nul_terminated() {
+        set_last_error("one\0two");
+        LAST_ERROR.with(|slot| {
+            assert_eq!(slot.borrow().to_str().unwrap(), "one\\0two");
+        });
+    }
+
+    #[test]
+    fn null_handle_is_reported_without_panicking() {
+        let mut count = 0;
+        // SAFETY: A null handle is explicitly accepted and reported as an ABI error.
+        let status = unsafe { rusticol_runtime_external_count(ptr::null(), &mut count) };
+        assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    }
+
+    #[test]
+    fn current_parameter_getter_rejects_null_outputs_without_writing() {
+        let name = CString::new("aS").unwrap();
+        let mut value = 42.0;
+        // SAFETY: Null arguments are explicitly validated, the other output is live.
+        let status = unsafe {
+            rusticol_runtime_get_model_parameter(
+                ptr::null(),
+                name.as_ptr(),
+                &mut value,
+                ptr::null_mut(),
+            )
+        };
+        assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+        assert_eq!(value, 42.0);
+    }
+
+    #[test]
+    fn short_string_buffer_has_a_distinct_status() {
+        set_last_error("a message larger than one byte");
+        let mut byte = 0_i8;
+        let mut required = 0;
+        // SAFETY: Both outputs point to writable storage of the declared capacity.
+        let status = unsafe { rusticol_last_error_message(&mut byte, 1, &mut required) };
+        assert_eq!(status, RUSTICOL_STATUS_BUFFER_TOO_SMALL);
+        assert!(required > 1);
+    }
+
+    #[test]
+    fn invalid_last_error_output_reports_invalid_argument() {
+        // SAFETY: Null outputs are explicitly accepted and reported as an ABI error.
+        let status = unsafe { rusticol_last_error_message(ptr::null_mut(), 0, ptr::null_mut()) };
+        assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    }
+
+    #[test]
+    fn null_string_buffer_is_only_valid_for_a_zero_capacity_query() {
+        let mut required = 0;
+        let query = unsafe { write_string("value", ptr::null_mut(), 0, &mut required) };
+        assert!(query.is_ok());
+        assert_eq!(required, 6);
+
+        let error = unsafe { write_string("value", ptr::null_mut(), 1, &mut required) }
+            .expect_err("nonzero null buffer must fail");
+        assert_eq!(error.status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    }
+
+    #[test]
+    fn f64_output_capacity_is_validated_before_copying() {
+        let values = [1.0, 2.0];
+        let mut output = [99.0];
+
+        let error = unsafe { write_f64_slice(&values, output.as_mut_ptr(), 1, "test output") }
+            .expect_err("short output must fail");
+
+        assert_eq!(error.status, RUSTICOL_STATUS_BUFFER_TOO_SMALL);
+        assert_eq!(output, [99.0]);
+    }
+
+    #[test]
+    fn failed_load_clears_the_output_handle() {
+        let path = CString::new("/path/that/does/not/exist").unwrap();
+        let mut output = usize::MAX as *mut RusticolRuntimeHandle;
+
+        // SAFETY: The path is NUL-terminated and output points to writable handle storage.
+        let status =
+            unsafe { rusticol_runtime_load(path.as_ptr(), ptr::null(), ptr::null(), &mut output) };
+
+        assert_eq!(status, RUSTICOL_STATUS_RUNTIME_ERROR);
+        assert!(output.is_null());
+    }
+
+    #[test]
+    fn cache_calls_reject_null_handles() {
+        let path = CString::new("cache.bin").unwrap();
+        // SAFETY: A null handle is explicitly validated by both entry points.
+        assert_eq!(
+            unsafe { rusticol_runtime_save(ptr::null(), path.as_ptr()) },
+            RUSTICOL_STATUS_INVALID_ARGUMENT
+        );
+        assert_eq!(
+            unsafe { rusticol_runtime_load_cache(ptr::null_mut(), path.as_ptr()) },
+            RUSTICOL_STATUS_INVALID_ARGUMENT
+        );
+    }
+
+    #[test]
+    fn static_c_api_advertises_all_symbolica_free_f64_capabilities() {
+        let mut required = 0;
+        // SAFETY: This is a zero-capacity query with writable required-size storage.
+        let status = unsafe {
+            rusticol_supported_runtime_capabilities_json(ptr::null_mut(), 0, &mut required)
+        };
+        assert_eq!(status, RUSTICOL_STATUS_OK);
+        assert!(required > 1);
+
+        let mut buffer = vec![0_i8; required];
+        // SAFETY: The output buffer and required-size storage are valid for the declared sizes.
+        let status = unsafe {
+            rusticol_supported_runtime_capabilities_json(
+                buffer.as_mut_ptr(),
+                buffer.len(),
+                &mut required,
+            )
+        };
+        assert_eq!(status, RUSTICOL_STATUS_OK);
+        let json = unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_str().unwrap();
+        assert_eq!(
+            serde_json::from_str::<Vec<String>>(json).unwrap(),
+            vec![
+                "compiled-plane-arena-v1".to_string(),
+                "eager-direct-arena-v1".to_string(),
+                "rusticol.color-contraction.symmetric-group-fft.v1".to_string(),
+                "rusticol.compiled.color-contraction-walsh-c2k.v1".to_string(),
+                "rusticol.compiled.color-contraction-walsh.v1".to_string(),
+                "rusticol.compiled.color-topology-lanes.v1".to_string(),
+                "rusticol.compiled.helicity-dual-lane.v1".to_string(),
+                "rusticol.compiled.helicity-primary-recurrence.v1".to_string(),
+                "rusticol.compiled.helicity-selector-union.v1".to_string(),
+                "rusticol.compiled.runtime-selectors.v1".to_string(),
+                "rusticol.eager-runtime-layout.complex-f64.v1".to_string(),
+                "rusticol.on-the-fly.complex-f64.v1".to_string(),
+                "rusticol.on-the-fly.contracted-color.v1".to_string(),
+                "rusticol.on-the-fly.lc-color.v1".to_string(),
+                "rusticol.recurrence-color.contracted.v1".to_string(),
+                "rusticol.recurrence-color.lc.v1".to_string(),
+                "rusticol.recurrence-direct-arena.complex-f64.v1".to_string(),
+                "rusticol.recurrence-helicity-selector-companion.v2".to_string(),
+                "symbolica.compiled-asm.complex-f64.v1".to_string(),
+                "symbolica.compiled-cpp.complex-f64.v1".to_string(),
+                "symjit.application.complex-f64.v1".to_string(),
+            ]
+        );
+    }
+
+    #[test]
+    fn native_argument_errors_map_to_the_c_argument_status() {
+        let error = AbiError::from(RusticolError::selector("bad selector"));
+        assert_eq!(error.status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    }
+
+    #[test]
+    fn warm_up_pods_preserve_schema_stage_memory_and_completion_state() {
+        assert_eq!(std::mem::size_of::<RusticolWarmUpProgressEvent>(), 72);
+        assert_eq!(std::mem::size_of::<RusticolWarmUpResult>(), 64);
+        let event = NativeOnTheFlyWarmUpEvent {
+            schema_version: 1,
+            kind: NativeOnTheFlyWarmUpEventKind::Update,
+            stage: NativeOnTheFlyWarmUpStage::QueryFamily,
+            completed: 7,
+            total: 11,
+            elapsed_seconds: 0.25,
+            current_rss_bytes: Some(1024),
+            peak_rss_bytes: None,
+            workers: 3,
+            message: Some("not copied across the fixed C ABI".to_string()),
+        };
+        let pod = warm_up_progress_event(&event);
+        assert_eq!(pod.schema_version, 1);
+        assert_eq!(pod.kind, RUSTICOL_WARM_UP_EVENT_UPDATE);
+        assert_eq!(pod.stage, RUSTICOL_WARM_UP_STAGE_QUERY_FAMILY);
+        assert_eq!((pod.completed, pod.total), (7, 11));
+        assert_eq!(pod.current_rss_bytes, 1024);
+        assert_eq!(pod.current_rss_available, 1);
+        assert_eq!(pod.peak_rss_bytes, 0);
+        assert_eq!(pod.peak_rss_available, 0);
+        assert_eq!(pod.workers, 3);
+
+        let result = warm_up_result(NativeOnTheFlyWarmUpResult {
+            schema_version: 1,
+            elapsed_seconds: 0.5,
+            query_count: 19,
+            warmed_query_count: 17,
+            current_rss_bytes: None,
+            peak_rss_bytes: Some(4096),
+            already_warm: false,
+            first_evaluation_completed: true,
+        });
+        assert_eq!((result.query_count, result.warmed_query_count), (19, 17));
+        assert_eq!(result.current_rss_available, 0);
+        assert_eq!(result.peak_rss_available, 1);
+        assert_eq!(result.peak_rss_bytes, 4096);
+        assert_eq!(result.already_warm, 0);
+        assert_eq!(result.first_evaluation_completed, 1);
+    }
+
+    #[test]
+    fn failed_warm_up_clears_result_before_validating_the_handle() {
+        let point = [0.0; 8];
+        let mut result = RusticolWarmUpResult {
+            schema_version: u32::MAX,
+            query_count: u64::MAX,
+            first_evaluation_completed: 1,
+            ..RusticolWarmUpResult::default()
+        };
+        // SAFETY: The point and result are valid; a null handle is deliberately rejected.
+        let status = unsafe {
+            rusticol_runtime_warm_up_f64(
+                ptr::null_mut(),
+                point.as_ptr(),
+                point.len(),
+                ptr::null(),
+                0,
+                ptr::null(),
+                0,
+                None,
+                ptr::null_mut(),
+                &mut result,
+            )
+        };
+        assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+        assert_eq!(result, RusticolWarmUpResult::default());
+    }
+
+    #[test]
+    fn panic_payloads_map_to_the_panic_status() {
+        let payload: Box<dyn Any + Send> = Box::new(String::from("contained test panic"));
+        let status = finish_guard(Err(payload));
+        assert_eq!(status, RUSTICOL_STATUS_PANIC);
+        LAST_ERROR.with(|slot| {
+            assert!(
+                slot.borrow()
+                    .to_str()
+                    .unwrap()
+                    .contains("contained test panic")
+            );
+        });
+    }
+
+    #[test]
+    fn guard_contains_panics_before_they_cross_the_c_boundary() {
+        let status = guard(|| -> AbiResult<()> { panic!("contained ABI panic") });
+
+        assert_eq!(status, RUSTICOL_STATUS_PANIC);
+        LAST_ERROR.with(|slot| {
+            assert!(
+                slot.borrow()
+                    .to_str()
+                    .unwrap()
+                    .contains("contained ABI panic")
+            );
+        });
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-capi/tests/eager_artifact.rs b/pyamplicol/rust/crates/rusticol-capi/tests/eager_artifact.rs
new file mode 100644
index 0000000000..37d00d6fe5
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-capi/tests/eager_artifact.rs
@@ -0,0 +1,320 @@
+// SPDX-License-Identifier: 0BSD
+
+use rusticol_capi::{
+    RUSTICOL_STATUS_OK, RusticolRuntimeHandle, rusticol_last_error_message,
+    rusticol_runtime_artifact_id, rusticol_runtime_color_id, rusticol_runtime_evaluate_f64,
+    rusticol_runtime_evaluate_resolved_f64, rusticol_runtime_execution_mode, rusticol_runtime_free,
+    rusticol_runtime_get_model_parameter, rusticol_runtime_helicity_id, rusticol_runtime_load,
+    rusticol_runtime_resolved_shape, rusticol_runtime_set_model_parameter,
+};
+use std::ffi::{CStr, CString, c_char};
+use std::path::Path;
+use std::ptr;
+
+fn last_error() -> String {
+    let mut required = 0;
+    // SAFETY: This is a zero-capacity query with writable required-size storage.
+    let status = unsafe { rusticol_last_error_message(ptr::null_mut(), 0, &mut required) };
+    if status != RUSTICOL_STATUS_OK || required == 0 {
+        return format!("could not query Rusticol error (status {status})");
+    }
+    let mut buffer = vec![0 as c_char; required];
+    // SAFETY: The output buffer has the queried capacity.
+    let status =
+        unsafe { rusticol_last_error_message(buffer.as_mut_ptr(), buffer.len(), &mut required) };
+    if status != RUSTICOL_STATUS_OK {
+        return format!("could not copy Rusticol error (status {status})");
+    }
+    // SAFETY: A successful Rusticol string getter always writes a trailing NUL.
+    unsafe { CStr::from_ptr(buffer.as_ptr()) }
+        .to_string_lossy()
+        .into_owned()
+}
+
+fn load_artifact(root: &Path) -> *mut RusticolRuntimeHandle {
+    let root = CString::new(root.to_string_lossy().as_bytes()).expect("artifact C path");
+    let mut handle: *mut RusticolRuntimeHandle = ptr::null_mut();
+    // SAFETY: The path and output handle storage remain valid for the call.
+    let status =
+        unsafe { rusticol_runtime_load(root.as_ptr(), ptr::null(), ptr::null(), &mut handle) };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert!(!handle.is_null());
+    handle
+}
+
+fn execution_mode(handle: *mut RusticolRuntimeHandle) -> String {
+    let mut required = 0;
+    // SAFETY: This is a zero-capacity query against a live handle.
+    let status =
+        unsafe { rusticol_runtime_execution_mode(handle, ptr::null_mut(), 0, &mut required) };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    let mut mode = vec![0 as c_char; required];
+    // SAFETY: The output buffer has the queried capacity and the handle remains live.
+    let status = unsafe {
+        rusticol_runtime_execution_mode(handle, mode.as_mut_ptr(), mode.len(), &mut required)
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    // SAFETY: A successful Rusticol string getter always writes a trailing NUL.
+    unsafe { CStr::from_ptr(mode.as_ptr()) }
+        .to_str()
+        .unwrap()
+        .to_owned()
+}
+
+fn indexed_string(
+    handle: *mut RusticolRuntimeHandle,
+    index: usize,
+    getter: unsafe extern "C" fn(
+        *const RusticolRuntimeHandle,
+        usize,
+        *mut c_char,
+        usize,
+        *mut usize,
+    ) -> i32,
+) -> CString {
+    let mut required = 0;
+    // SAFETY: This is a zero-capacity query against a live handle.
+    let status = unsafe { getter(handle, index, ptr::null_mut(), 0, &mut required) };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    let mut buffer = vec![0 as c_char; required];
+    // SAFETY: The output buffer has the queried capacity and the handle remains live.
+    let status = unsafe {
+        getter(
+            handle,
+            index,
+            buffer.as_mut_ptr(),
+            buffer.len(),
+            &mut required,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    // SAFETY: A successful Rusticol string getter always writes a trailing NUL.
+    unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_owned()
+}
+
+fn free_runtime(handle: *mut RusticolRuntimeHandle) {
+    // SAFETY: The handle is live and is consumed exactly once here.
+    assert_eq!(
+        unsafe { rusticol_runtime_free(handle) },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error()
+    );
+}
+
+#[test]
+fn generated_compiled_artifact_reports_compiled_execution_mode() {
+    let Some(root) = std::env::var_os("RUSTICOL_COMPILED_ARTIFACT") else {
+        return;
+    };
+    let handle = load_artifact(Path::new(&root));
+    assert_eq!(execution_mode(handle), "compiled");
+    free_runtime(handle);
+}
+
+#[test]
+fn generated_eager_artifact_loads_and_evaluates_through_the_c_abi() {
+    let Some(root) = std::env::var_os("RUSTICOL_EAGER_ARTIFACT") else {
+        return;
+    };
+    let root = Path::new(&root);
+    let manifest: serde_json::Value = serde_json::from_slice(
+        &std::fs::read(root.join("artifact.json")).expect("read eager artifact manifest"),
+    )
+    .expect("parse eager artifact manifest");
+    let process_id = manifest["default_process_id"]
+        .as_str()
+        .expect("eager artifact default process");
+    let validation: serde_json::Value = serde_json::from_slice(
+        &std::fs::read(
+            root.join("processes")
+                .join(process_id)
+                .join("validation-momenta.json"),
+        )
+        .expect("read eager validation momenta"),
+    )
+    .expect("parse eager validation momenta");
+    let momenta = validation["points"][0]
+        .as_array()
+        .expect("validation point")
+        .iter()
+        .flat_map(|leg| {
+            leg["momentum"]
+                .as_array()
+                .expect("validation momentum")
+                .iter()
+                .map(|value| {
+                    value
+                        .as_str()
+                        .expect("string momentum component")
+                        .parse::<f64>()
+                        .expect("f64 momentum component")
+                })
+        })
+        .collect::<Vec<_>>();
+
+    let handle = load_artifact(root);
+    assert_eq!(execution_mode(handle), "eager");
+
+    let mut required = 0;
+    // SAFETY: The handle is live and required-size storage is writable.
+    assert_eq!(
+        unsafe { rusticol_runtime_artifact_id(handle, ptr::null_mut(), 0, &mut required) },
+        RUSTICOL_STATUS_OK
+    );
+    let mut identity = vec![0 as c_char; required];
+    // SAFETY: The output buffer has exactly the queried capacity.
+    assert_eq!(
+        unsafe {
+            rusticol_runtime_artifact_id(
+                handle,
+                identity.as_mut_ptr(),
+                identity.len(),
+                &mut required,
+            )
+        },
+        RUSTICOL_STATUS_OK
+    );
+    // SAFETY: A successful string getter includes a trailing NUL.
+    let identity = unsafe { CStr::from_ptr(identity.as_ptr()) }
+        .to_str()
+        .unwrap();
+    assert_eq!(identity, manifest["artifact_id"].as_str().unwrap());
+
+    let mut output = [f64::NAN];
+    // SAFETY: Every input and output buffer remains live and has the declared length.
+    let status = unsafe {
+        rusticol_runtime_evaluate_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            1,
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert!(output[0].is_finite());
+
+    let mut helicity_count = 0;
+    let mut color_count = 0;
+    // SAFETY: Null selector arrays request complete coverage and shape outputs are writable.
+    let status = unsafe {
+        rusticol_runtime_resolved_shape(
+            handle,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            &mut helicity_count,
+            &mut color_count,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert!(helicity_count > 0);
+    assert!(color_count > 0);
+    let mut resolved = vec![f64::NAN; helicity_count * color_count];
+    // SAFETY: Every input, output, and shape buffer remains live and has the declared length.
+    let status = unsafe {
+        rusticol_runtime_evaluate_resolved_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            1,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            resolved.as_mut_ptr(),
+            resolved.len(),
+            &mut helicity_count,
+            &mut color_count,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert!(resolved.iter().all(|value| value.is_finite()));
+    let resolved_sum = resolved.iter().sum::<f64>();
+    let tolerance = 1.0e-15 + 1.0e-12 * output[0].abs();
+    assert!(
+        (resolved_sum - output[0]).abs() <= tolerance,
+        "resolved sum {resolved_sum:.17e} does not reproduce total {:.17e}",
+        output[0],
+    );
+
+    let helicity = indexed_string(handle, 0, rusticol_runtime_helicity_id);
+    let color = indexed_string(handle, 0, rusticol_runtime_color_id);
+    let helicity_ids = [helicity.as_ptr()];
+    let color_ids = [color.as_ptr()];
+    let mut selected_helicity_count = 0;
+    let mut selected_color_count = 0;
+    // SAFETY: Selector arrays and shape outputs remain valid for the call.
+    let status = unsafe {
+        rusticol_runtime_resolved_shape(
+            handle,
+            helicity_ids.as_ptr(),
+            helicity_ids.len(),
+            color_ids.as_ptr(),
+            color_ids.len(),
+            &mut selected_helicity_count,
+            &mut selected_color_count,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert_eq!((selected_helicity_count, selected_color_count), (1, 1));
+    let mut selected = [f64::NAN];
+    // SAFETY: Every input, selector, output, and shape buffer has the declared length.
+    let status = unsafe {
+        rusticol_runtime_evaluate_resolved_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            1,
+            helicity_ids.as_ptr(),
+            helicity_ids.len(),
+            color_ids.as_ptr(),
+            color_ids.len(),
+            selected.as_mut_ptr(),
+            selected.len(),
+            &mut selected_helicity_count,
+            &mut selected_color_count,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert!(selected[0].is_finite());
+
+    let baseline = output[0];
+    let parameter = CString::new("normalization.alpha_ew").unwrap();
+    // SAFETY: The parameter name and live runtime handle remain valid for the call.
+    let status =
+        unsafe { rusticol_runtime_set_model_parameter(handle, parameter.as_ptr(), 0.006, 0.0) };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    let mut current_real = f64::NAN;
+    let mut current_imaginary = f64::NAN;
+    // SAFETY: Both outputs and the parameter name remain live for this call.
+    let status = unsafe {
+        rusticol_runtime_get_model_parameter(
+            handle,
+            parameter.as_ptr(),
+            &mut current_real,
+            &mut current_imaginary,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert_eq!((current_real, current_imaginary), (0.006, 0.0));
+    // SAFETY: Every input and output buffer remains live and has the declared length.
+    let status = unsafe {
+        rusticol_runtime_evaluate_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            1,
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert!(output[0].is_finite());
+    assert_ne!(output[0], baseline);
+
+    free_runtime(handle);
+}
diff --git a/pyamplicol/rust/crates/rusticol-capi/tests/runtime_selectors.rs b/pyamplicol/rust/crates/rusticol-capi/tests/runtime_selectors.rs
new file mode 100644
index 0000000000..036c7f6287
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-capi/tests/runtime_selectors.rs
@@ -0,0 +1,1064 @@
+// SPDX-License-Identifier: 0BSD
+
+use rusticol_capi::{
+    RUSTICOL_STATUS_BUFFER_TOO_SMALL, RUSTICOL_STATUS_INVALID_ARGUMENT, RUSTICOL_STATUS_OK,
+    RUSTICOL_WARM_UP_EVENT_END, RUSTICOL_WARM_UP_STAGE_FIRST_EVALUATION, RusticolRuntimeHandle,
+    RusticolWarmUpProgressEvent, RusticolWarmUpResult, rusticol_last_error_message,
+    rusticol_runtime_color_count, rusticol_runtime_color_id, rusticol_runtime_evaluate_f64,
+    rusticol_runtime_evaluate_resolved_f64, rusticol_runtime_evaluate_selected_f64,
+    rusticol_runtime_free, rusticol_runtime_helicity_count, rusticol_runtime_helicity_id,
+    rusticol_runtime_load, rusticol_runtime_warm_up_f64, rusticol_runtime_warm_up_f64_with_cores,
+};
+use std::ffi::{CStr, CString, c_char, c_int, c_void};
+use std::path::{Path, PathBuf};
+use std::ptr;
+
+fn fixture_root() -> Option<PathBuf> {
+    std::env::var_os("RUSTICOL_SELECTOR_ARTIFACT").map(PathBuf::from)
+}
+
+fn contracted_fixture_root() -> Option<PathBuf> {
+    std::env::var_os("RUSTICOL_CONTRACTED_SELECTOR_ARTIFACT").map(PathBuf::from)
+}
+
+fn otf_fixture_root() -> Option<PathBuf> {
+    std::env::var_os("RUSTICOL_OTF_ARTIFACT").map(PathBuf::from)
+}
+
+fn last_error() -> String {
+    let mut required = 0;
+    // SAFETY: This is a zero-capacity query with writable required-size storage.
+    let status = unsafe { rusticol_last_error_message(ptr::null_mut(), 0, &mut required) };
+    if status != RUSTICOL_STATUS_OK || required == 0 {
+        return format!("could not query Rusticol error (status {status})");
+    }
+    let mut buffer = vec![0 as c_char; required];
+    // SAFETY: The output buffer has the queried capacity.
+    let status =
+        unsafe { rusticol_last_error_message(buffer.as_mut_ptr(), buffer.len(), &mut required) };
+    if status != RUSTICOL_STATUS_OK {
+        return format!("could not copy Rusticol error (status {status})");
+    }
+    // SAFETY: Successful Rusticol string getters write a trailing NUL.
+    unsafe { CStr::from_ptr(buffer.as_ptr()) }
+        .to_string_lossy()
+        .into_owned()
+}
+
+fn load_fixture(root: &Path) -> *mut RusticolRuntimeHandle {
+    let root = CString::new(root.to_string_lossy().as_bytes()).expect("fixture C path");
+    let mut handle = ptr::null_mut();
+    // SAFETY: The path and output handle storage remain valid for the call.
+    let status =
+        unsafe { rusticol_runtime_load(root.as_ptr(), ptr::null(), ptr::null(), &mut handle) };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert!(!handle.is_null());
+    handle
+}
+
+fn validation_momenta(root: &Path) -> Vec<f64> {
+    let manifest: serde_json::Value = serde_json::from_slice(
+        &std::fs::read(root.join("artifact.json")).expect("read artifact manifest"),
+    )
+    .expect("parse artifact manifest");
+    let process_id = manifest["default_process_id"]
+        .as_str()
+        .expect("default process id");
+    let payload: serde_json::Value = serde_json::from_slice(
+        &std::fs::read(
+            root.join("processes")
+                .join(process_id)
+                .join("validation-momenta.json"),
+        )
+        .expect("read validation momenta"),
+    )
+    .expect("parse validation momenta");
+    payload["points"][0]
+        .as_array()
+        .expect("validation point")
+        .iter()
+        .flat_map(|leg| {
+            leg["momentum"]
+                .as_array()
+                .expect("validation momentum")
+                .iter()
+                .map(|value| {
+                    value
+                        .as_str()
+                        .expect("string momentum component")
+                        .parse::<f64>()
+                        .expect("f64 momentum component")
+                })
+        })
+        .collect()
+}
+
+fn repeated_momenta(root: &Path, point_count: usize) -> Vec<f64> {
+    let point = validation_momenta(root);
+    point.repeat(point_count)
+}
+
+#[derive(Default)]
+struct WarmUpTrace {
+    event_count: usize,
+    saw_terminal_first_evaluation: bool,
+    max_workers: u64,
+}
+
+unsafe extern "C" fn record_warm_up_progress(
+    event: *const RusticolWarmUpProgressEvent,
+    user_data: *mut c_void,
+) -> c_int {
+    if event.is_null() || user_data.is_null() {
+        return 0;
+    }
+    // SAFETY: The test passes a live trace for this synchronous callback.
+    let trace = unsafe { &mut *user_data.cast::<WarmUpTrace>() };
+    // SAFETY: Rusticol supplies a borrowed event for the callback invocation.
+    let event = unsafe { &*event };
+    trace.event_count += 1;
+    trace.max_workers = trace.max_workers.max(event.workers);
+    trace.saw_terminal_first_evaluation |= event.kind == RUSTICOL_WARM_UP_EVENT_END
+        && event.stage == RUSTICOL_WARM_UP_STAGE_FIRST_EVALUATION;
+    1
+}
+
+fn physical_counts(handle: *mut RusticolRuntimeHandle) -> (usize, usize) {
+    let mut helicity_count = 0;
+    let mut color_count = 0;
+    // SAFETY: Both outputs are writable and the runtime handle remains live.
+    assert_eq!(
+        unsafe { rusticol_runtime_helicity_count(handle, &mut helicity_count) },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error(),
+    );
+    // SAFETY: Both outputs are writable and the runtime handle remains live.
+    assert_eq!(
+        unsafe { rusticol_runtime_color_count(handle, &mut color_count) },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error(),
+    );
+    (helicity_count, color_count)
+}
+
+fn helicity_id(handle: *mut RusticolRuntimeHandle, index: usize) -> CString {
+    let mut required = 0;
+    // SAFETY: This is a zero-capacity query against a live runtime.
+    assert_eq!(
+        unsafe { rusticol_runtime_helicity_id(handle, index, ptr::null_mut(), 0, &mut required) },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error(),
+    );
+    let mut buffer = vec![0 as c_char; required];
+    // SAFETY: The buffer has the queried capacity.
+    assert_eq!(
+        unsafe {
+            rusticol_runtime_helicity_id(
+                handle,
+                index,
+                buffer.as_mut_ptr(),
+                buffer.len(),
+                &mut required,
+            )
+        },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error(),
+    );
+    // SAFETY: A successful getter writes a trailing NUL.
+    unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_owned()
+}
+
+fn color_id(handle: *mut RusticolRuntimeHandle, index: usize) -> CString {
+    let mut required = 0;
+    // SAFETY: This is a zero-capacity query against a live runtime.
+    assert_eq!(
+        unsafe { rusticol_runtime_color_id(handle, index, ptr::null_mut(), 0, &mut required) },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error(),
+    );
+    let mut buffer = vec![0 as c_char; required];
+    // SAFETY: The buffer has the queried capacity.
+    assert_eq!(
+        unsafe {
+            rusticol_runtime_color_id(
+                handle,
+                index,
+                buffer.as_mut_ptr(),
+                buffer.len(),
+                &mut required,
+            )
+        },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error(),
+    );
+    // SAFETY: A successful getter writes a trailing NUL.
+    unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_owned()
+}
+
+fn resolved_values(
+    handle: *mut RusticolRuntimeHandle,
+    momenta: &[f64],
+    point_count: usize,
+    helicity_count: usize,
+    color_count: usize,
+) -> Vec<f64> {
+    let mut output_helicity_count = 0;
+    let mut output_color_count = 0;
+    let mut values = vec![f64::NAN; point_count * helicity_count * color_count];
+    // SAFETY: Every buffer remains live and has the declared length. Null selectors request all
+    // physical components.
+    let status = unsafe {
+        rusticol_runtime_evaluate_resolved_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            values.as_mut_ptr(),
+            values.len(),
+            &mut output_helicity_count,
+            &mut output_color_count,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert_eq!(output_helicity_count, helicity_count);
+    assert_eq!(output_color_count, color_count);
+    values
+}
+
+fn expected_component(
+    resolved: &[f64],
+    point: usize,
+    helicity: usize,
+    color: usize,
+    helicity_count: usize,
+    color_count: usize,
+) -> f64 {
+    resolved[(point * helicity_count + helicity) * color_count + color]
+}
+
+fn expected_selected_sum(
+    resolved: &[f64],
+    point: usize,
+    helicity: Option<usize>,
+    color: Option<usize>,
+    helicity_count: usize,
+    color_count: usize,
+) -> f64 {
+    (0..helicity_count)
+        .filter(|index| helicity.is_none_or(|selected| *index == selected))
+        .flat_map(|helicity_index| {
+            (0..color_count)
+                .filter(move |index| color.is_none_or(|selected| *index == selected))
+                .map(move |color_index| {
+                    expected_component(
+                        resolved,
+                        point,
+                        helicity_index,
+                        color_index,
+                        helicity_count,
+                        color_count,
+                    )
+                })
+        })
+        .sum()
+}
+
+#[test]
+fn direct_total_outputs_preserve_bits_canaries_and_capacity_errors() {
+    let Some(root) = fixture_root() else {
+        return;
+    };
+    let handle = load_fixture(&root);
+    let point_count = 4;
+    let momenta = repeated_momenta(&root, point_count);
+    let (helicity_count, color_count) = physical_counts(handle);
+    let resolved = resolved_values(handle, &momenta, point_count, helicity_count, color_count);
+    let leading_canary = f64::from_bits(0x7ff8_1234_5678_9abc);
+    let trailing_canary = f64::from_bits(0x7ff8_cafe_babe_f00d);
+
+    let mut totals = vec![f64::NAN; point_count + 2];
+    totals[0] = leading_canary;
+    totals[point_count + 1] = trailing_canary;
+    // SAFETY: The output pointer starts after the leading canary and has point_count + 1
+    // writable values; the runtime must write only the exact point_count-value prefix.
+    let status = unsafe {
+        rusticol_runtime_evaluate_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            totals.as_mut_ptr().add(1),
+            point_count + 1,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert_eq!(totals[0].to_bits(), leading_canary.to_bits());
+    assert_eq!(totals[point_count + 1].to_bits(), trailing_canary.to_bits());
+    for point in 0..point_count {
+        let expected =
+            expected_selected_sum(&resolved, point, None, None, helicity_count, color_count);
+        assert_eq!(totals[point + 1].to_bits(), expected.to_bits());
+    }
+
+    let mut selected = vec![f64::NAN; point_count + 2];
+    selected[0] = leading_canary;
+    selected[point_count + 1] = trailing_canary;
+    // SAFETY: All selector arrays are omitted and the output has one excess tail value.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            selected.as_mut_ptr().add(1),
+            point_count + 1,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert_eq!(selected[0].to_bits(), leading_canary.to_bits());
+    assert_eq!(
+        selected[point_count + 1].to_bits(),
+        trailing_canary.to_bits()
+    );
+    for point in 0..point_count {
+        assert_eq!(selected[point + 1].to_bits(), totals[point + 1].to_bits());
+    }
+
+    let short_sentinel = f64::from_bits(0x7ff8_dead_beef_0001);
+    let mut short_total = vec![short_sentinel; point_count + 2];
+    let unchanged_total = short_total.clone();
+    // SAFETY: The storage is writable, but its declared capacity is intentionally too short.
+    let status = unsafe {
+        rusticol_runtime_evaluate_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            short_total.as_mut_ptr().add(1),
+            point_count - 1,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_BUFFER_TOO_SMALL);
+    assert_eq!(
+        short_total
+            .iter()
+            .map(|value| value.to_bits())
+            .collect::<Vec<_>>(),
+        unchanged_total
+            .iter()
+            .map(|value| value.to_bits())
+            .collect::<Vec<_>>()
+    );
+
+    let mut short_selected = vec![short_sentinel; point_count + 2];
+    let unchanged_selected = short_selected.clone();
+    // SAFETY: The storage is writable, but its declared capacity is intentionally too short.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            short_selected.as_mut_ptr().add(1),
+            point_count - 1,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_BUFFER_TOO_SMALL);
+    assert_eq!(
+        short_selected
+            .iter()
+            .map(|value| value.to_bits())
+            .collect::<Vec<_>>(),
+        unchanged_selected
+            .iter()
+            .map(|value| value.to_bits())
+            .collect::<Vec<_>>()
+    );
+
+    // SAFETY: The handle is consumed exactly once after all evaluations finish.
+    assert_eq!(
+        unsafe { rusticol_runtime_free(handle) },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error(),
+    );
+}
+
+#[test]
+fn otf_warm_up_c_boundary_reports_progress_and_completes_one_f64_point() {
+    let Some(root) = otf_fixture_root() else {
+        return;
+    };
+    let handle = load_fixture(&root);
+    let point = validation_momenta(&root);
+    let mut trace = WarmUpTrace::default();
+    let mut result = RusticolWarmUpResult::default();
+
+    // SAFETY: Every pointer refers to live storage for this synchronous call;
+    // null selector arrays request the complete retained axes.
+    let status = unsafe {
+        rusticol_runtime_warm_up_f64_with_cores(
+            handle,
+            point.as_ptr(),
+            point.len(),
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            2,
+            Some(record_warm_up_progress),
+            (&mut trace as *mut WarmUpTrace).cast(),
+            &mut result,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert_eq!(result.schema_version, 1);
+    assert_eq!(result.first_evaluation_completed, 1);
+    assert!(result.query_count > 0);
+    assert!(result.warmed_query_count <= result.query_count);
+    assert!(trace.event_count >= 2);
+    assert!(trace.saw_terminal_first_evaluation);
+    assert!((1..=2).contains(&trace.max_workers));
+
+    // Changing construction cores back to the process-output default must
+    // reuse the same warm family instead of changing its cache identity.
+    let mut repeated = RusticolWarmUpResult::default();
+    // SAFETY: The handle, point, and result storage remain live.
+    let status = unsafe {
+        rusticol_runtime_warm_up_f64(
+            handle,
+            point.as_ptr(),
+            point.len(),
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            None,
+            ptr::null_mut(),
+            &mut repeated,
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert_eq!(repeated.already_warm, 1);
+    assert_eq!(repeated.warmed_query_count, 0);
+
+    let mut value = f64::NAN;
+    // SAFETY: The same exactly-one-point input and scalar output remain live.
+    let status = unsafe {
+        rusticol_runtime_evaluate_f64(handle, point.as_ptr(), point.len(), 1, &mut value, 1)
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    assert!(value.is_finite());
+
+    // SAFETY: The handle is consumed exactly once after warm-up and evaluation.
+    assert_eq!(unsafe { rusticol_runtime_free(handle) }, RUSTICOL_STATUS_OK);
+}
+
+#[test]
+fn homogeneous_and_alternating_per_point_selectors_match_resolved_components() {
+    let Some(root) = fixture_root() else {
+        return;
+    };
+    let handle = load_fixture(&root);
+    let point_count = 4;
+    let momenta = repeated_momenta(&root, point_count);
+    let (helicity_count, color_count) = physical_counts(handle);
+    assert!(
+        helicity_count >= 2,
+        "fixture must expose at least two helicities"
+    );
+    assert!(
+        color_count >= 2,
+        "fixture must expose at least two color flows"
+    );
+    let resolved = resolved_values(handle, &momenta, point_count, helicity_count, color_count);
+
+    let helicity = helicity_id(handle, 0);
+    let color = color_id(handle, 0);
+    let global_helicities = [helicity.as_ptr()];
+    let global_colors = [color.as_ptr()];
+    let mut global = vec![f64::NAN; point_count];
+    // SAFETY: All selector, momentum, and output arrays have their declared lengths.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            global_helicities.as_ptr(),
+            global_helicities.len(),
+            global_colors.as_ptr(),
+            global_colors.len(),
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            global.as_mut_ptr(),
+            global.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    for (point, value) in global.iter().enumerate() {
+        assert_eq!(
+            value.to_bits(),
+            expected_component(&resolved, point, 0, 0, helicity_count, color_count).to_bits(),
+        );
+    }
+
+    let mut global_helicity_only = vec![f64::NAN; point_count];
+    // SAFETY: All selector, momentum, and output arrays have their declared lengths.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            global_helicities.as_ptr(),
+            global_helicities.len(),
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            global_helicity_only.as_mut_ptr(),
+            global_helicity_only.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    for (point, value) in global_helicity_only.iter().enumerate() {
+        let expected =
+            expected_selected_sum(&resolved, point, Some(0), None, helicity_count, color_count);
+        assert_eq!(value.to_bits(), expected.to_bits());
+    }
+
+    let mut global_color_only = vec![f64::NAN; point_count];
+    // SAFETY: All selector, momentum, and output arrays have their declared lengths.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            global_colors.as_ptr(),
+            global_colors.len(),
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            global_color_only.as_mut_ptr(),
+            global_color_only.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    for (point, value) in global_color_only.iter().enumerate() {
+        let expected =
+            expected_selected_sum(&resolved, point, None, Some(0), helicity_count, color_count);
+        assert_eq!(value.to_bits(), expected.to_bits());
+    }
+
+    let homogeneous_helicities = vec![0_u32; point_count];
+    let homogeneous_colors = vec![0_u32; point_count];
+    let mut homogeneous = vec![f64::NAN; point_count];
+    // SAFETY: All selector, momentum, and output arrays have their declared lengths.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            homogeneous_helicities.as_ptr(),
+            homogeneous_helicities.len(),
+            homogeneous_colors.as_ptr(),
+            homogeneous_colors.len(),
+            homogeneous.as_mut_ptr(),
+            homogeneous.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    for (point, value) in homogeneous.iter().enumerate() {
+        assert_eq!(
+            value.to_bits(),
+            expected_component(&resolved, point, 0, 0, helicity_count, color_count).to_bits(),
+        );
+    }
+
+    let pooled_helicities = [0_u32, 0, 1, 1];
+    let pooled_colors = [1_u32, 1, 0, 0];
+    let mut pooled = vec![f64::NAN; point_count];
+    // SAFETY: All selector, momentum, and output arrays have their declared lengths.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            pooled_helicities.as_ptr(),
+            pooled_helicities.len(),
+            pooled_colors.as_ptr(),
+            pooled_colors.len(),
+            pooled.as_mut_ptr(),
+            pooled.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    for (point, value) in pooled.iter().enumerate() {
+        assert_eq!(
+            value.to_bits(),
+            expected_component(
+                &resolved,
+                point,
+                pooled_helicities[point] as usize,
+                pooled_colors[point] as usize,
+                helicity_count,
+                color_count,
+            )
+            .to_bits(),
+        );
+    }
+
+    let alternating_helicities = [0_u32, 1, 0, 1];
+    let alternating_colors = [1_u32, 0, 1, 0];
+    let mut alternating = vec![f64::NAN; point_count];
+    // SAFETY: All selector, momentum, and output arrays have their declared lengths.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            alternating_helicities.as_ptr(),
+            alternating_helicities.len(),
+            alternating_colors.as_ptr(),
+            alternating_colors.len(),
+            alternating.as_mut_ptr(),
+            alternating.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    for (point, value) in alternating.iter().enumerate() {
+        let helicity = alternating_helicities[point] as usize;
+        let color = alternating_colors[point] as usize;
+        assert_eq!(
+            value.to_bits(),
+            expected_component(
+                &resolved,
+                point,
+                helicity,
+                color,
+                helicity_count,
+                color_count,
+            )
+            .to_bits(),
+        );
+    }
+
+    // First four entries from a selector stream seeded with 0xC0FFEE.
+    let random_helicities = [0_u32, 0, 0, 1];
+    let random_colors = [1_u32, 1, 0, 1];
+    let mut seeded_random = vec![f64::NAN; point_count];
+    // SAFETY: All selector, momentum, and output arrays have their declared lengths.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            random_helicities.as_ptr(),
+            random_helicities.len(),
+            random_colors.as_ptr(),
+            random_colors.len(),
+            seeded_random.as_mut_ptr(),
+            seeded_random.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    for (point, value) in seeded_random.iter().enumerate() {
+        assert_eq!(
+            value.to_bits(),
+            expected_component(
+                &resolved,
+                point,
+                random_helicities[point] as usize,
+                random_colors[point] as usize,
+                helicity_count,
+                color_count,
+            )
+            .to_bits(),
+        );
+    }
+
+    let mut helicity_only = vec![f64::NAN; point_count];
+    // SAFETY: All selector, momentum, and output arrays have their declared lengths.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            alternating_helicities.as_ptr(),
+            alternating_helicities.len(),
+            ptr::null(),
+            0,
+            helicity_only.as_mut_ptr(),
+            helicity_only.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    for (point, value) in helicity_only.iter().enumerate() {
+        let expected = expected_selected_sum(
+            &resolved,
+            point,
+            Some(alternating_helicities[point] as usize),
+            None,
+            helicity_count,
+            color_count,
+        );
+        assert_eq!(value.to_bits(), expected.to_bits());
+    }
+
+    let mut color_only = vec![f64::NAN; point_count];
+    // SAFETY: All selector, momentum, and output arrays have their declared lengths.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            alternating_colors.as_ptr(),
+            alternating_colors.len(),
+            color_only.as_mut_ptr(),
+            color_only.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_OK, "{}", last_error());
+    for (point, value) in color_only.iter().enumerate() {
+        let expected = expected_selected_sum(
+            &resolved,
+            point,
+            None,
+            Some(alternating_colors[point] as usize),
+            helicity_count,
+            color_count,
+        );
+        assert_eq!(value.to_bits(), expected.to_bits());
+    }
+
+    // SAFETY: The handle is consumed exactly once after all evaluations finish.
+    assert_eq!(
+        unsafe { rusticol_runtime_free(handle) },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error(),
+    );
+}
+
+#[test]
+fn malformed_selector_buffers_fail_without_touching_output() {
+    let Some(root) = fixture_root() else {
+        return;
+    };
+    let handle = load_fixture(&root);
+    let point_count = 2;
+    let momenta = repeated_momenta(&root, point_count);
+    let valid = [0_u32, 0];
+    let mut output = [123.0, 456.0];
+
+    // SAFETY: A nonzero length with a null selector pointer is intentionally malformed.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            ptr::null(),
+            point_count,
+            ptr::null(),
+            0,
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    assert!(last_error().contains("helicity_by_point is null"));
+    assert_eq!(output, [123.0, 456.0]);
+
+    // SAFETY: The selector pointer is readable, but its declared length is intentionally short.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            valid.as_ptr(),
+            1,
+            ptr::null(),
+            0,
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    assert!(last_error().contains("expected 2"));
+    assert_eq!(output, [123.0, 456.0]);
+
+    let helicity = helicity_id(handle, 0);
+    let global_helicities = [helicity.as_ptr()];
+    // SAFETY: Buffers are valid, but the same selector axis is intentionally supplied twice.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            global_helicities.as_ptr(),
+            global_helicities.len(),
+            ptr::null(),
+            0,
+            valid.as_ptr(),
+            valid.len(),
+            ptr::null(),
+            0,
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    assert!(last_error().contains("mutually exclusive"));
+    assert_eq!(output, [123.0, 456.0]);
+
+    let color = color_id(handle, 0);
+    let global_colors = [color.as_ptr()];
+    // SAFETY: Buffers are valid, but the same color selector axis is supplied twice.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            global_colors.as_ptr(),
+            global_colors.len(),
+            ptr::null(),
+            0,
+            valid.as_ptr(),
+            valid.len(),
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    assert!(last_error().contains("mutually exclusive"));
+    assert_eq!(output, [123.0, 456.0]);
+
+    let out_of_range = [u32::MAX, u32::MAX];
+    // SAFETY: Buffers are valid; selector values are intentionally outside the physical domain.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            out_of_range.as_ptr(),
+            out_of_range.len(),
+            ptr::null(),
+            0,
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    assert!(last_error().contains("out of range"));
+    assert_eq!(output, [123.0, 456.0]);
+
+    // SAFETY: The color selector is readable, but its declared length is intentionally short.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            valid.as_ptr(),
+            1,
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    assert!(last_error().contains("expected 2"));
+    assert_eq!(output, [123.0, 456.0]);
+
+    // SAFETY: Buffers are valid; color selector values are outside the physical domain.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            out_of_range.as_ptr(),
+            out_of_range.len(),
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    assert!(last_error().contains("out of range"));
+    assert_eq!(output, [123.0, 456.0]);
+
+    // SAFETY: The handle is consumed exactly once after all error cases finish.
+    assert_eq!(
+        unsafe { rusticol_runtime_free(handle) },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error(),
+    );
+}
+
+#[test]
+fn contracted_color_rejects_global_and_per_point_flow_selectors() {
+    let Some(root) = contracted_fixture_root() else {
+        return;
+    };
+    let handle = load_fixture(&root);
+    let point_count = 2;
+    let momenta = repeated_momenta(&root, point_count);
+    let color = color_id(handle, 0);
+    let global_colors = [color.as_ptr()];
+    let point_colors = [0_u32, 0];
+    let mut output = [123.0, 456.0];
+
+    // SAFETY: Buffers are valid; a global physical-flow selection is intentionally requested
+    // from a contracted NLC/full color axis.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            global_colors.as_ptr(),
+            global_colors.len(),
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    assert!(last_error().contains("LC color-flow selection is unavailable"));
+    assert_eq!(output, [123.0, 456.0]);
+
+    // SAFETY: Buffers are valid; per-point physical-flow selection is intentionally requested
+    // from the same contracted color axis.
+    let status = unsafe {
+        rusticol_runtime_evaluate_selected_f64(
+            handle,
+            momenta.as_ptr(),
+            momenta.len(),
+            point_count,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            ptr::null(),
+            0,
+            point_colors.as_ptr(),
+            point_colors.len(),
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    assert_eq!(status, RUSTICOL_STATUS_INVALID_ARGUMENT);
+    assert!(last_error().contains("LC color-flow selection is unavailable"));
+    assert_eq!(output, [123.0, 456.0]);
+
+    // SAFETY: The handle is consumed exactly once after both rejection cases finish.
+    assert_eq!(
+        unsafe { rusticol_runtime_free(handle) },
+        RUSTICOL_STATUS_OK,
+        "{}",
+        last_error(),
+    );
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/Cargo.toml b/pyamplicol/rust/crates/rusticol-core/Cargo.toml
new file mode 100644
index 0000000000..e68cf17e2e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/Cargo.toml
@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: 0BSD
+
+[package]
+name = "rusticol-core"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+
+[features]
+default = ["f64-compiled", "f64-symjit"]
+f64-compiled = ["dep:libloading", "dep:num-complex", "dep:symjit"]
+f64-symjit = ["dep:num-complex", "dep:symjit"]
+# Unstable cross-crate bridge used only by the private PyO3 extension during
+# artifact generation. It is intentionally absent from the default feature set.
+python-generation-bridge = ["f64-symjit"]
+# Non-default parity seam for the private Python development harness.  This
+# feature is deliberately absent from production/default builds.
+on-the-fly-test-support = ["f64-symjit"]
+symbolica-runtime = ["dep:symbolica"]
+
+[dependencies]
+bincode.workspace = true
+libloading = { version = "0.9", optional = true }
+libc.workspace = true
+num-complex = { version = "0.4", optional = true }
+rayon.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sha2.workspace = true
+symbolica = { version = "=3.0.0", default-features = false, features = ["bincode", "integer-gmp", "float-mpfr", "native_code_generation"], optional = true }
+symjit = { version = "=2.26.4", default-features = false, optional = true }
+thiserror.workspace = true
+wide.workspace = true
diff --git a/pyamplicol/rust/crates/rusticol-core/src/artifact.rs b/pyamplicol/rust/crates/rusticol-core/src/artifact.rs
new file mode 100644
index 0000000000..d7b6d61a29
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/artifact.rs
@@ -0,0 +1,3928 @@
+// SPDX-License-Identifier: 0BSD
+
+use crate::pacbin::{PacbinMemberKind, PacbinReader};
+use crate::{
+    ARTIFACT_MANIFEST_FILE, C_ABI_VERSION, COMPILED_MODEL_SCHEMA_VERSION,
+    PROCESS_ARTIFACT_SCHEMA_VERSION, PYTHON_API_VERSION, RUNTIME_PHYSICS_SCHEMA_VERSION,
+    RuntimeCapability, RusticolError, RusticolResult, TOML_SCHEMA_VERSION,
+};
+use bincode::Decode;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use sha2::{Digest, Sha256};
+use std::borrow::Cow;
+use std::collections::{BTreeMap, BTreeSet};
+use std::fmt::Write as _;
+use std::fs::{self, File, OpenOptions};
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+#[cfg(feature = "f64-compiled")]
+use std::sync::Mutex;
+#[cfg(feature = "f64-compiled")]
+use std::sync::atomic::{AtomicU64, Ordering};
+#[cfg(feature = "f64-compiled")]
+use std::time::{SystemTime, UNIX_EPOCH};
+
+const ARTIFACT_IDENTITY_EXTENSION: &str = "artifact_identity";
+const ARTIFACT_IDENTITY_KIND: &str = "pyamplicol-runtime-payload-identity";
+const ARTIFACT_IDENTITY_SCHEMA_VERSION: u64 = 1;
+#[cfg(test)]
+const RUNTIME_IDENTITY_PAYLOAD_ROLES: [&str; 5] = [
+    "compiled-model",
+    "evaluator-manifest",
+    "evaluator-state",
+    "model-parameters",
+    "runtime-physics",
+];
+const EVALUATOR_PAYLOAD_CONTAINER_EXTENSION: &str = "evaluator_payload_container";
+const EVALUATOR_PAYLOAD_CONTAINER_KIND: &str = "pyamplicol-evaluator-payload-container";
+const EVALUATOR_PAYLOAD_CONTAINER_STORAGE_ABI: &str = "pacbin-v1";
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+const RECURRENCE_BOOTSTRAP_FILENAME: &str = "recurrence-bootstrap.bin";
+const SUPPORTED_ARTIFACT_TARGETS: [&str; 3] = [
+    "aarch64-apple-darwin",
+    "x86_64-apple-darwin",
+    "x86_64-unknown-linux-gnu",
+];
+
+pub(crate) const PORTABLE_64LE_ARTIFACT_TARGET: &str = "portable-64le";
+#[cfg(feature = "f64-compiled")]
+const NATIVE_LIBRARY_SNAPSHOT_ATTEMPTS: u64 = 128;
+#[cfg(feature = "f64-compiled")]
+static NEXT_NATIVE_LIBRARY_SNAPSHOT: AtomicU64 = AtomicU64::new(0);
+
+fn rusticol_package_version() -> &'static str {
+    option_env!("PYAMPLICOL_PACKAGE_VERSION").unwrap_or(env!("CARGO_PKG_VERSION"))
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum ArtifactKind {
+    PyamplicolProcess,
+    PyamplicolProcessSet,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(
+    any(feature = "python-generation-bridge", test),
+    derive(bincode::Encode)
+)]
+#[serde(deny_unknown_fields)]
+pub struct VersionSet {
+    pub python_api: u32,
+    pub toml: u32,
+    pub compiled_model: u32,
+    pub process_artifact: u32,
+    pub runtime_physics: u32,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub symbolica_serialization: Option<String>,
+    pub c_abi: u32,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(
+    any(feature = "python-generation-bridge", test),
+    derive(bincode::Encode)
+)]
+#[serde(deny_unknown_fields)]
+pub struct Target {
+    pub triple: String,
+    pub cpu_features: Vec<String>,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(
+    any(feature = "python-generation-bridge", test),
+    derive(bincode::Encode)
+)]
+#[serde(deny_unknown_fields)]
+pub struct Producer {
+    pub distribution: String,
+    pub version: String,
+    pub versions: VersionSet,
+    pub target: Target,
+    #[serde(default)]
+    pub git_revision: Option<String>,
+    #[serde(default)]
+    pub native_build_inputs_sha256: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum ModelSourceKind {
+    BuiltInSm,
+    BuiltInSmHeft,
+    Ufo,
+    UfoJson,
+    CompiledModel,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct ArtifactModel {
+    pub name: String,
+    pub source_kind: ModelSourceKind,
+    pub content_sha256: String,
+    pub compiled_schema_version: u32,
+    #[serde(default)]
+    pub restriction: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct ConfigurationAdjustment {
+    pub path: String,
+    pub reason: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct ArtifactConfiguration {
+    pub toml_schema_version: u32,
+    pub requested_path: String,
+    pub effective_path: String,
+    pub adjustments: Vec<ConfigurationAdjustment>,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(
+    any(feature = "python-generation-bridge", test),
+    derive(bincode::Encode)
+)]
+#[serde(deny_unknown_fields)]
+pub struct ProcessAlias {
+    pub id: String,
+    pub expression: String,
+    pub external_pdgs: Vec<i32>,
+    pub external_permutation: Vec<usize>,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(
+    any(feature = "python-generation-bridge", test),
+    derive(bincode::Encode)
+)]
+#[serde(deny_unknown_fields)]
+pub struct ArtifactProcess {
+    pub id: String,
+    pub expression: String,
+    pub color_accuracy: String,
+    pub external_pdgs: Vec<i32>,
+    pub physics_path: String,
+    pub required_runtime_capabilities: Vec<String>,
+    pub aliases: Vec<ProcessAlias>,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(
+    any(feature = "python-generation-bridge", test),
+    derive(bincode::Encode)
+)]
+#[serde(deny_unknown_fields)]
+pub struct ArtifactRuntime {
+    pub engine: String,
+    pub engine_version: String,
+    pub evaluator_manifest_path: String,
+    pub required_runtime_capabilities: Vec<String>,
+    #[serde(default)]
+    pub api_bundle_path: Option<String>,
+}
+
+#[derive(Clone, Copy, Debug, Decode, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
+#[cfg_attr(
+    any(feature = "python-generation-bridge", test),
+    derive(bincode::Encode)
+)]
+#[serde(rename_all = "kebab-case")]
+pub enum PayloadRole {
+    ConfigurationRequested,
+    ConfigurationEffective,
+    CompiledModel,
+    RuntimePhysics,
+    EvaluatorManifest,
+    EvaluatorState,
+    ModelParameters,
+    ValidationMomenta,
+    StructuralSourceProof,
+    ApiSource,
+    ApiBuildFile,
+    SdkMetadata,
+    ProcessGroups,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(
+    any(feature = "python-generation-bridge", test),
+    derive(bincode::Encode)
+)]
+#[serde(deny_unknown_fields)]
+pub struct Payload {
+    pub path: String,
+    pub role: PayloadRole,
+    pub media_type: String,
+    pub size_bytes: u64,
+    pub sha256: String,
+    pub executable: bool,
+    #[serde(default)]
+    pub target: Option<Target>,
+    #[serde(default)]
+    pub process_id: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct Dependency {
+    pub name: String,
+    pub version: String,
+    pub source: String,
+    pub license: String,
+    #[serde(default)]
+    pub content_sha256: Option<String>,
+    #[serde(default)]
+    pub revision: Option<String>,
+    #[serde(default)]
+    pub patch_sha256: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct ArtifactManifest {
+    pub schema_version: u32,
+    pub kind: ArtifactKind,
+    pub artifact_id: String,
+    pub created_utc: String,
+    pub producer: Producer,
+    pub model: ArtifactModel,
+    pub configuration: ArtifactConfiguration,
+    pub processes: Vec<ArtifactProcess>,
+    #[serde(default)]
+    pub default_process_id: Option<String>,
+    pub runtime: ArtifactRuntime,
+    pub payloads: Vec<Payload>,
+    pub dependencies: Vec<Dependency>,
+    pub extensions: BTreeMap<String, Value>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ArtifactSelection {
+    pub process: ArtifactProcess,
+    pub requested_id: String,
+    pub alias: Option<ProcessAlias>,
+    /// Canonical public process expression selected by the caller.
+    pub public_expression: String,
+    /// Public external-particle order selected by the caller.
+    pub external_pdgs: Vec<i32>,
+    /// Representative external index to public external index.
+    pub external_permutation: Vec<usize>,
+    /// Whether the permutation was inferred from a concrete expression rather
+    /// than persisted as an explicit artifact alias.
+    pub inferred_permutation: bool,
+    /// Present when the caller selected a process that was not generated and
+    /// is routed through `process-groups.json` to `process`.
+    pub process_group: Option<ProcessGroupRelation>,
+}
+
+impl ArtifactSelection {
+    /// Whether public metadata differs from the stored representative.
+    pub fn remaps_public_process(&self) -> bool {
+        self.alias.is_some() || self.inferred_permutation || self.process_group.is_some()
+    }
+}
+
+/// Relation of a selected process-group member to its generated representative:
+/// `ME_member(p) = numerator / denominator * ME_representative(q)` with
+/// `q[r] = p[external_permutation[r]]`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ProcessGroupRelation {
+    pub factor_numerator: u64,
+    pub factor_denominator: u64,
+    /// The relation includes global charge conjugation: public LC color-flow
+    /// words are the reversed words of the permuted representative.
+    pub conjugated: bool,
+    /// Member particle names in the public external order.
+    pub external_particles: Vec<String>,
+}
+
+impl ProcessGroupRelation {
+    pub fn has_unit_factor(&self) -> bool {
+        self.factor_numerator == self.factor_denominator
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct VerifiedArtifact {
+    root: PathBuf,
+    manifest_path: PathBuf,
+    manifest: ArtifactManifest,
+    payloads: Arc<BTreeMap<String, Payload>>,
+    evaluator_payload_container: Option<Arc<PacbinReader>>,
+    #[cfg(feature = "f64-compiled")]
+    native_library_cache: Arc<Mutex<BTreeMap<String, Arc<PinnedNativeLibrary>>>>,
+}
+
+/// Authenticated inputs for the narrow recurrence-only loading path.
+///
+/// The returned `VerifiedArtifact` owns the same checked payload inventory and
+/// evaluator container used by the generic loader.  Only the broad evaluator
+/// set and generation-oriented extension trees are skipped.
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+pub(crate) struct RecurrenceBootstrapArtifact {
+    pub(crate) artifact: VerifiedArtifact,
+    pub(crate) selection: ArtifactSelection,
+    pub(crate) ready_execution: crate::engine::RecurrenceReadyExecutionV1,
+    pub(crate) physics: crate::ProcessPhysics,
+    pub(crate) evaluator_payload_container: EvaluatorPayloadContainerExtension,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize)]
+#[cfg_attr(
+    any(feature = "python-generation-bridge", test),
+    derive(bincode::Encode)
+)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct EvaluatorPayloadContainerExtension {
+    pub(crate) kind: String,
+    pub(crate) schema_version: u32,
+    pub(crate) storage_abi: String,
+    pub(crate) path: String,
+    pub(crate) member_count: u64,
+    pub(crate) unpacked_size_bytes: u64,
+    pub(crate) index_sha256: String,
+}
+
+/// One evaluator payload resolved from a legacy loose file or a packed member.
+#[derive(Clone, Debug)]
+pub(crate) enum EvaluatorPayloadSource {
+    File(PathBuf),
+    AuthenticatedFile {
+        root: PathBuf,
+        payload: Payload,
+    },
+    Packed {
+        container: Arc<PacbinReader>,
+        logical_path: String,
+    },
+}
+
+/// A dynamic library loaded only from process-private snapshot bytes.
+///
+/// The original artifact path is retained solely for diagnostics. Symbol
+/// lookup always addresses `library`, which was opened from an authenticated
+/// private materialization that is unlinked immediately on Unix.
+pub(crate) struct PinnedNativeLibrary {
+    #[cfg(feature = "f64-compiled")]
+    library: Option<libloading::Library>,
+    display_path: PathBuf,
+    #[cfg(feature = "f64-compiled")]
+    temporary: Option<TemporaryNativeLibrary>,
+}
+
+impl std::fmt::Debug for PinnedNativeLibrary {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("PinnedNativeLibrary")
+            .field("display_path", &self.display_path)
+            .finish_non_exhaustive()
+    }
+}
+
+#[cfg(feature = "f64-compiled")]
+impl std::ops::Deref for PinnedNativeLibrary {
+    type Target = libloading::Library;
+
+    fn deref(&self) -> &Self::Target {
+        self.library
+            .as_ref()
+            .expect("pinned native library is live until Drop")
+    }
+}
+
+impl PinnedNativeLibrary {
+    #[cfg(feature = "f64-compiled")]
+    fn from_bytes(bytes: &[u8], display_path: PathBuf) -> RusticolResult<Arc<Self>> {
+        let mut failures = Vec::new();
+        for root in native_library_snapshot_roots() {
+            let temporary = match TemporaryNativeLibrary::create(bytes, &display_path, &root) {
+                Ok(temporary) => temporary,
+                Err(error) => {
+                    failures.push(format!("{}: {error}", root.display()));
+                    continue;
+                }
+            };
+            let library = match unsafe { libloading::Library::new(&temporary.path) } {
+                Ok(library) => library,
+                Err(error) => {
+                    failures.push(format!("{}: {error}", root.display()));
+                    continue;
+                }
+            };
+            #[cfg(unix)]
+            let temporary = {
+                temporary.remove_now()?;
+                None
+            };
+            #[cfg(not(unix))]
+            let temporary = Some(temporary);
+            return Ok(Arc::new(Self {
+                library: Some(library),
+                display_path,
+                temporary,
+            }));
+        }
+        Err(RusticolError::evaluation(format!(
+            "could not load authenticated native evaluator library {}; snapshot roots failed: {}. \
+             The snapshot filesystem must be writable and executable (not mounted noexec); set \
+             PYAMPLICOL_NATIVE_SNAPSHOT_ROOT to a private executable filesystem",
+            display_path.display(),
+            failures.join("; ")
+        )))
+    }
+
+    pub(crate) fn display_path(&self) -> &Path {
+        &self.display_path
+    }
+
+    #[cfg(all(test, feature = "f64-compiled"))]
+    pub(crate) fn from_test_path(path: &Path) -> RusticolResult<Arc<Self>> {
+        let bytes = fs::read(path).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not read native-library test fixture {}: {error}",
+                path.display()
+            ))
+        })?;
+        Self::from_bytes(&bytes, path.to_path_buf())
+    }
+}
+
+#[cfg(feature = "f64-compiled")]
+impl Drop for PinnedNativeLibrary {
+    fn drop(&mut self) {
+        // Windows does not permit removal while the library is loaded. Drop
+        // the handle first, then let the retained materialization guard clean
+        // up. Unix snapshots are already unlinked after successful dlopen.
+        drop(self.library.take());
+        drop(self.temporary.take());
+    }
+}
+
+#[cfg(feature = "f64-compiled")]
+struct TemporaryNativeLibrary {
+    directory: PathBuf,
+    path: PathBuf,
+    active: bool,
+}
+
+#[cfg(feature = "f64-compiled")]
+impl TemporaryNativeLibrary {
+    fn create(bytes: &[u8], display_path: &Path, root: &Path) -> RusticolResult<Self> {
+        if !root.is_dir() {
+            return Err(RusticolError::artifact(format!(
+                "native-library snapshot root {} is not a directory",
+                root.display()
+            )));
+        }
+        let suffix = display_path
+            .extension()
+            .and_then(|value| value.to_str())
+            .filter(|value| !value.is_empty())
+            .unwrap_or("bin");
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_nanos();
+        for _ in 0..NATIVE_LIBRARY_SNAPSHOT_ATTEMPTS {
+            let sequence = NEXT_NATIVE_LIBRARY_SNAPSHOT.fetch_add(1, Ordering::Relaxed);
+            let directory = root.join(format!(
+                ".pyamplicol-native-{}-{now}-{sequence}",
+                std::process::id()
+            ));
+            let mut builder = fs::DirBuilder::new();
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::DirBuilderExt as _;
+                builder.mode(0o700);
+            }
+            match builder.create(&directory) {
+                Ok(()) => {}
+                Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => continue,
+                Err(error) => {
+                    return Err(RusticolError::artifact(format!(
+                        "could not create private native-library snapshot directory {}: {error}",
+                        directory.display()
+                    )));
+                }
+            }
+            let path = directory.join(format!("payload.{suffix}"));
+            let result = (|| {
+                let mut options = OpenOptions::new();
+                options.create_new(true).write(true);
+                #[cfg(unix)]
+                {
+                    use std::os::unix::fs::OpenOptionsExt as _;
+                    options.mode(0o600);
+                }
+                let mut file = options.open(&path).map_err(|error| {
+                    RusticolError::artifact(format!(
+                        "could not create native-library snapshot {}: {error}",
+                        path.display()
+                    ))
+                })?;
+                file.write_all(bytes).map_err(|error| {
+                    RusticolError::artifact(format!(
+                        "could not write native-library snapshot {}: {error}",
+                        path.display()
+                    ))
+                })?;
+                file.flush().map_err(|error| {
+                    RusticolError::artifact(format!(
+                        "could not flush native-library snapshot {}: {error}",
+                        path.display()
+                    ))
+                })?;
+                drop(file);
+                #[cfg(unix)]
+                {
+                    use std::os::unix::fs::PermissionsExt as _;
+                    fs::set_permissions(&path, fs::Permissions::from_mode(0o500)).map_err(
+                        |error| {
+                            RusticolError::artifact(format!(
+                                "could not protect native-library snapshot {}: {error}",
+                                path.display()
+                            ))
+                        },
+                    )?;
+                }
+                Ok(Self {
+                    directory: directory.clone(),
+                    path: path.clone(),
+                    active: true,
+                })
+            })();
+            if result.is_err() {
+                let _ = fs::remove_file(&path);
+                let _ = fs::remove_dir(&directory);
+            }
+            return result;
+        }
+        Err(RusticolError::artifact(
+            "could not allocate a unique private native-library snapshot",
+        ))
+    }
+
+    #[cfg(unix)]
+    fn remove_now(mut self) -> RusticolResult<()> {
+        fs::remove_file(&self.path).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not unlink loaded native-library snapshot {}: {error}",
+                self.path.display()
+            ))
+        })?;
+        fs::remove_dir(&self.directory).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not remove native-library snapshot directory {}: {error}",
+                self.directory.display()
+            ))
+        })?;
+        self.active = false;
+        Ok(())
+    }
+}
+
+#[cfg(feature = "f64-compiled")]
+fn native_library_snapshot_roots() -> Vec<PathBuf> {
+    let mut roots = Vec::new();
+    if let Some(configured) =
+        std::env::var_os("PYAMPLICOL_NATIVE_SNAPSHOT_ROOT").filter(|value| !value.is_empty())
+    {
+        let configured = PathBuf::from(configured);
+        if !roots.contains(&configured) {
+            roots.push(configured);
+        }
+    }
+    let system = std::env::temp_dir();
+    if !roots.contains(&system) {
+        roots.push(system);
+    }
+    roots
+}
+
+#[cfg(feature = "f64-compiled")]
+impl Drop for TemporaryNativeLibrary {
+    fn drop(&mut self) {
+        if self.active {
+            let _ = fs::remove_file(&self.path);
+            let _ = fs::remove_dir(&self.directory);
+        }
+    }
+}
+
+impl EvaluatorPayloadSource {
+    pub(crate) fn read(&self) -> RusticolResult<Cow<'_, [u8]>> {
+        match self {
+            Self::File(path) => fs::read(path).map(Cow::Owned).map_err(|error| {
+                RusticolError::artifact(format!(
+                    "could not read evaluator payload {}: {error}",
+                    path.display()
+                ))
+            }),
+            Self::AuthenticatedFile { root, payload } => {
+                read_declared_payload(root, payload).map(Cow::Owned)
+            }
+            Self::Packed {
+                container,
+                logical_path,
+            } => container.member_bytes(logical_path).map(Cow::Borrowed),
+        }
+    }
+
+    pub(crate) fn display_name(&self) -> String {
+        match self {
+            Self::File(path) => path.display().to_string(),
+            Self::AuthenticatedFile { root, payload } => {
+                root.join(&payload.path).display().to_string()
+            }
+            Self::Packed { logical_path, .. } => format!("evaluators.pacbin:{logical_path}"),
+        }
+    }
+}
+
+/// A path-scoped resolver shared by compiled and eager evaluator loaders.
+#[derive(Clone, Debug)]
+pub(crate) struct EvaluatorPayloadStore {
+    artifact_root: PathBuf,
+    relative_root: PathBuf,
+    container: Option<Arc<PacbinReader>>,
+    payloads: Option<Arc<BTreeMap<String, Payload>>>,
+    #[cfg(feature = "f64-compiled")]
+    native_library_cache: Arc<Mutex<BTreeMap<String, Arc<PinnedNativeLibrary>>>>,
+}
+
+impl EvaluatorPayloadStore {
+    pub(crate) fn directory(root: &Path) -> Self {
+        Self {
+            artifact_root: root.to_path_buf(),
+            relative_root: root.to_path_buf(),
+            container: None,
+            payloads: None,
+            #[cfg(feature = "f64-compiled")]
+            native_library_cache: Arc::new(Mutex::new(BTreeMap::new())),
+        }
+    }
+
+    pub(crate) fn logical_path(&self, value: &str) -> RusticolResult<String> {
+        let relative = confined_evaluator_path(value)?;
+        artifact_logical_path(&self.artifact_root, &self.relative_root.join(relative))
+    }
+
+    pub(crate) fn source(&self, value: &str) -> RusticolResult<EvaluatorPayloadSource> {
+        let logical_path = self.logical_path(value)?;
+        let path = self.artifact_root.join(&logical_path);
+        if let Some(container) = &self.container
+            && container.member(&logical_path).is_ok()
+        {
+            return Ok(EvaluatorPayloadSource::Packed {
+                container: container.clone(),
+                logical_path,
+            });
+        }
+        if let Some(payloads) = &self.payloads {
+            let payload = payloads.get(&logical_path).ok_or_else(|| {
+                RusticolError::security(format!(
+                    "evaluator payload {logical_path:?} is not declared by the verified artifact"
+                ))
+            })?;
+            if payload.role != PayloadRole::EvaluatorState {
+                return Err(RusticolError::security(format!(
+                    "evaluator payload {logical_path:?} has role {:?}, expected evaluator-state",
+                    payload.role
+                )));
+            }
+            return Ok(EvaluatorPayloadSource::AuthenticatedFile {
+                root: self.artifact_root.clone(),
+                payload: payload.clone(),
+            });
+        }
+        Ok(EvaluatorPayloadSource::File(path))
+    }
+
+    pub(crate) fn packed_member_bytes(
+        &self,
+        value: &str,
+        expected_kind: PacbinMemberKind,
+    ) -> RusticolResult<&[u8]> {
+        let logical_path = self.logical_path(value)?;
+        let container = self.container.as_ref().ok_or_else(|| {
+            RusticolError::compatibility(format!(
+                "typed evaluator payload {logical_path:?} requires evaluators.pacbin storage"
+            ))
+        })?;
+        let member = container.member(&logical_path)?;
+        if member.kind() != expected_kind {
+            return Err(RusticolError::integrity(format!(
+                "evaluator payload {logical_path:?} has pacbin member kind {:?}, expected {:?}",
+                member.kind(),
+                expected_kind,
+            )));
+        }
+        container.member_bytes(&logical_path)
+    }
+
+    pub(crate) fn load_native_library(
+        &self,
+        value: &str,
+    ) -> RusticolResult<Arc<PinnedNativeLibrary>> {
+        #[cfg(not(feature = "f64-compiled"))]
+        {
+            let _ = value;
+            return Err(RusticolError::compatibility(
+                "native evaluator libraries require the f64-compiled feature",
+            ));
+        }
+        #[cfg(feature = "f64-compiled")]
+        {
+            let relative = confined_evaluator_path(value)?;
+            let path = self.relative_root.join(relative);
+            let logical_path = artifact_logical_path(&self.artifact_root, &path)?;
+            if let Some(library) = self
+                .native_library_cache
+                .lock()
+                .map_err(|_| {
+                    RusticolError::evaluation("native evaluator library cache is poisoned")
+                })?
+                .get(&logical_path)
+                .cloned()
+            {
+                return Ok(library);
+            }
+            let source = self.source(value)?;
+            if let EvaluatorPayloadSource::Packed { logical_path, .. } = &source {
+                return Err(RusticolError::compatibility(format!(
+                    "native evaluator library {logical_path:?} cannot be loaded from pacbin storage"
+                )));
+            }
+            let display_path = PathBuf::from(source.display_name());
+            let bytes = source.read()?;
+            let loaded = PinnedNativeLibrary::from_bytes(bytes.as_ref(), display_path)?;
+            let mut cache = self.native_library_cache.lock().map_err(|_| {
+                RusticolError::evaluation("native evaluator library cache is poisoned")
+            })?;
+            Ok(cache
+                .entry(logical_path)
+                .or_insert_with(|| Arc::clone(&loaded))
+                .clone())
+        }
+    }
+}
+
+impl VerifiedArtifact {
+    /// Try the authenticated recurrence-only bootstrap without materializing
+    /// broad generation/reporting extension trees.
+    ///
+    /// An absent conventional sidecar is not an error: callers may fall back
+    /// to the generic loader for artifacts produced before this optimization.
+    /// File presence opts a stable representative process into this compact
+    /// path; every subsequent failure is reported rather than falling back to
+    /// less constrained inputs.
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    pub(crate) fn try_open_recurrence_bootstrap(
+        path: impl AsRef<Path>,
+        requested_process: Option<&str>,
+    ) -> RusticolResult<Option<RecurrenceBootstrapArtifact>> {
+        // Explicit aliases and expressions retain the generic selector path.
+        // An omitted selector can use the image only when the conventional
+        // single-process tree contains exactly one stable-ID sidecar.
+        if requested_process.is_some_and(|process_id| {
+            validate_public_id(process_id, "requested process id").is_err()
+        }) {
+            return Ok(None);
+        }
+        let requested = path.as_ref();
+        reject_symlink_chain(requested)?;
+        let (root, manifest_path) = locate_manifest(requested)?;
+        reject_symlink_chain(&manifest_path)?;
+        let discovered_process_id = if requested_process.is_none() {
+            discover_single_recurrence_bootstrap_process(&root)?
+        } else {
+            None
+        };
+        let discovered_default = discovered_process_id.is_some();
+        let Some(process_id) = requested_process.or(discovered_process_id.as_deref()) else {
+            return Ok(None);
+        };
+        let bootstrap_path = format!("processes/{}/{}", process_id, RECURRENCE_BOOTSTRAP_FILENAME);
+        let bootstrap_file = root.join(&bootstrap_path);
+        let bootstrap_bytes = match read_bounded_recurrence_bootstrap(&root, &bootstrap_file)? {
+            None if discovered_default => {
+                return Err(RusticolError::integrity(format!(
+                    "discovered default recurrence bootstrap {bootstrap_path:?} disappeared before opening"
+                )));
+            }
+            None => return Ok(None),
+            Some(bytes) => bytes,
+        };
+        let decoded = crate::engine::decode_recurrence_bootstrap_image_v1(&bootstrap_bytes)?;
+        if decoded.process.id != process_id {
+            return Err(RusticolError::integrity(format!(
+                "recurrence bootstrap at {bootstrap_path:?} belongs to process {:?}",
+                decoded.process.id
+            )));
+        }
+        validate_recurrence_bootstrap_metadata(&decoded.producer, &decoded.runtime)?;
+
+        let bootstrap_size = u64::try_from(bootstrap_bytes.len()).map_err(|_| {
+            RusticolError::artifact("recurrence bootstrap size exceeds the u64 domain")
+        })?;
+        let bootstrap_payload = Payload {
+            path: bootstrap_path.clone(),
+            role: PayloadRole::EvaluatorState,
+            media_type: "application/octet-stream".to_string(),
+            size_bytes: bootstrap_size,
+            sha256: format!("{:x}", Sha256::digest(&bootstrap_bytes)),
+            executable: false,
+            target: Some(decoded.producer.target.clone()),
+            process_id: Some(process_id.to_string()),
+        };
+        let mut declared = decoded.payloads;
+        let mut insertion_index = declared.len();
+        let mut previous_path: Option<&str> = None;
+        for (index, payload) in declared.iter().enumerate() {
+            if previous_path.is_some_and(|previous| previous >= payload.path.as_str()) {
+                return Err(RusticolError::integrity(
+                    "recurrence bootstrap payload inventory must be strictly path-sorted",
+                ));
+            }
+            if payload.path == bootstrap_path {
+                return Err(RusticolError::integrity(format!(
+                    "recurrence bootstrap inventory illegally contains its own record {bootstrap_path:?}"
+                )));
+            }
+            if insertion_index == declared.len() && payload.path.as_str() > bootstrap_path.as_str()
+            {
+                insertion_index = index;
+            }
+            previous_path = Some(&payload.path);
+        }
+        declared.insert(insertion_index, bootstrap_payload);
+        let manifest_artifact_id = read_canonical_manifest_artifact_id(&manifest_path)?;
+        let computed_artifact_id = compute_payload_artifact_id(&declared)?;
+        if computed_artifact_id != manifest_artifact_id {
+            return Err(RusticolError::integrity(format!(
+                "recurrence bootstrap payload identity {computed_artifact_id} disagrees with artifact manifest identity {manifest_artifact_id}"
+            )));
+        }
+
+        let process = decoded.process;
+        validate_recurrence_bootstrap_process(&process)?;
+        let selection = representative_selection(&process);
+        let manifest = recurrence_bootstrap_manifest(
+            manifest_artifact_id,
+            decoded.producer,
+            decoded.runtime,
+            process,
+            declared,
+        );
+        let payloads = validated_payload_declarations(&manifest)?;
+        for payload in payloads.values() {
+            if let Some(target) = &payload.target {
+                validate_payload_target(&manifest.producer.target, target, &payload.path)?;
+                validate_target(target, &format!("payload {}", payload.path))?;
+            }
+        }
+        validate_recurrence_bootstrap_source_payload(
+            &payloads,
+            &decoded.execution_path,
+            &decoded.execution_sha256,
+            PayloadRole::EvaluatorManifest,
+            process_id,
+        )?;
+        validate_recurrence_bootstrap_source_payload(
+            &payloads,
+            &decoded.physics_path,
+            &decoded.physics_sha256,
+            PayloadRole::RuntimePhysics,
+            process_id,
+        )?;
+        if decoded.physics_path != selection.process.physics_path {
+            return Err(RusticolError::integrity(
+                "recurrence bootstrap physics path disagrees with the selected process",
+            ));
+        }
+        validate_evaluator_payload_container_declaration(
+            &decoded.evaluator_payload_container,
+            &payloads,
+        )?;
+        let artifact = Self {
+            root,
+            manifest_path,
+            manifest,
+            payloads: Arc::new(payloads),
+            // The process binding says whether this process has any JIT/native
+            // leaves.  Avoid opening and retaining the model-wide evaluator
+            // PACBIN for source/intrinsic-only recurrence processes.
+            evaluator_payload_container: None,
+            #[cfg(feature = "f64-compiled")]
+            native_library_cache: Arc::new(Mutex::new(BTreeMap::new())),
+        };
+        Ok(Some(RecurrenceBootstrapArtifact {
+            artifact,
+            selection,
+            ready_execution: decoded.ready_execution,
+            physics: decoded.physics,
+            evaluator_payload_container: decoded.evaluator_payload_container,
+        }))
+    }
+
+    /// Open a trusted artifact directory or a direct v3 manifest path.
+    ///
+    /// Schema, references, and confined paths are checked. Payload digests are
+    /// deliberately not recomputed on the normal runtime path.
+    pub fn open(path: impl AsRef<Path>) -> RusticolResult<Self> {
+        Self::open_with_manifest_preflight(path, |_| Ok(()))
+    }
+
+    pub(crate) fn open_with_manifest_preflight(
+        path: impl AsRef<Path>,
+        preflight: impl FnOnce(&ArtifactManifest) -> RusticolResult<()>,
+    ) -> RusticolResult<Self> {
+        let requested = path.as_ref();
+        reject_symlink_chain(requested)?;
+        let (root, manifest_path) = locate_manifest(requested)?;
+        reject_symlink_chain(&manifest_path)?;
+        let metadata = fs::metadata(&manifest_path).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not inspect artifact manifest {}: {error}",
+                manifest_path.display()
+            ))
+        })?;
+        if !metadata.is_file() {
+            return Err(RusticolError::security(format!(
+                "artifact manifest {} is not a regular file",
+                manifest_path.display()
+            )));
+        }
+        let bytes = fs::read(&manifest_path).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not read artifact manifest {}: {error}",
+                manifest_path.display()
+            ))
+        })?;
+        let header: Value = serde_json::from_slice(&bytes).map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not parse artifact manifest {} as JSON: {error}",
+                manifest_path.display()
+            ))
+        })?;
+        let schema_version = header
+            .get("schema_version")
+            .and_then(Value::as_u64)
+            .unwrap_or(0);
+        if matches!(schema_version, 1 | 2) {
+            return Err(RusticolError::compatibility(format!(
+                "process artifact schema v{schema_version} is unsupported and unsafe to migrate; regenerate it with `pyamplicol generate` to produce schema v3"
+            )));
+        }
+        if schema_version != u64::from(PROCESS_ARTIFACT_SCHEMA_VERSION) {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported process artifact schema {schema_version}; this runtime requires schema v{PROCESS_ARTIFACT_SCHEMA_VERSION}"
+            )));
+        }
+        validate_artifact_identity_header(&header)?;
+        reject_forbidden_nulls(&header)?;
+        let manifest: ArtifactManifest = serde_json::from_slice(&bytes).map_err(|error| {
+            RusticolError::serialization(format!(
+                "artifact manifest {} does not conform to schema v3: {error}",
+                manifest_path.display()
+            ))
+        })?;
+        validate_manifest(&manifest)?;
+        preflight(&manifest)?;
+
+        let payloads = validated_payload_declarations(&manifest)?;
+        validate_references(&manifest, &payloads)?;
+        let evaluator_payload_container =
+            load_evaluator_payload_container(&root, &manifest, &payloads)?;
+        let payloads = Arc::new(payloads);
+        Ok(Self {
+            root,
+            manifest_path,
+            manifest,
+            payloads,
+            evaluator_payload_container,
+            #[cfg(feature = "f64-compiled")]
+            native_library_cache: Arc::new(Mutex::new(BTreeMap::new())),
+        })
+    }
+
+    pub fn root(&self) -> &Path {
+        &self.root
+    }
+
+    pub fn manifest_path(&self) -> &Path {
+        &self.manifest_path
+    }
+
+    pub fn manifest(&self) -> &ArtifactManifest {
+        &self.manifest
+    }
+
+    /// Resolve a selector against the manifest, then against non-generated
+    /// members of the declared process-group map. The map is read only when
+    /// no stored process ID, alias, or stored expression (exact or
+    /// side-permuted) matches.
+    pub fn select_process(&self, requested: Option<&str>) -> RusticolResult<ArtifactSelection> {
+        self.manifest
+            .select_process_with_groups(requested, || self.process_groups())
+    }
+
+    fn process_groups(&self) -> RusticolResult<Option<ProcessGroups>> {
+        let mut declared = self
+            .payloads
+            .values()
+            .filter(|payload| payload.role == PayloadRole::ProcessGroups);
+        let Some(payload) = declared.next() else {
+            return Ok(None);
+        };
+        if declared.next().is_some() {
+            return Err(RusticolError::artifact(
+                "artifact declares more than one process-groups payload",
+            ));
+        }
+        let bytes = read_declared_payload(&self.root, payload)?;
+        if format!("{:x}", Sha256::digest(&bytes)) != payload.sha256 {
+            return Err(RusticolError::integrity(format!(
+                "process-groups payload {:?} does not match its declared sha256",
+                payload.path
+            )));
+        }
+        ProcessGroups::from_json(&bytes, &self.manifest).map(Some)
+    }
+
+    pub fn payload(&self, path: &str) -> RusticolResult<&Payload> {
+        self.payloads.get(path).ok_or_else(|| {
+            RusticolError::security(format!("artifact path {path:?} is not a declared payload"))
+        })
+    }
+
+    pub fn read_payload(&self, path: &str) -> RusticolResult<Vec<u8>> {
+        let payload = self.payload(path)?;
+        read_declared_payload(&self.root, payload)
+    }
+
+    /// Open one declared loose payload and pin the checked file description.
+    ///
+    /// Callers that stream or map a payload must authenticate this returned
+    /// file, rather than reopening `path`, so path replacement cannot change
+    /// the bytes between declaration checks and use.
+    pub(crate) fn open_payload_file(&self, path: &str) -> RusticolResult<File> {
+        let payload = self.payload(path)?;
+        open_checked_payload(&self.root, payload)
+    }
+
+    pub(crate) fn payload_path(&self, path: &str) -> RusticolResult<PathBuf> {
+        let payload = self.payload(path)?;
+        drop(open_checked_payload(&self.root, payload)?);
+        Ok(self.root.join(path))
+    }
+
+    pub(crate) fn evaluator_payload_store(
+        &self,
+        relative_root: &Path,
+    ) -> RusticolResult<EvaluatorPayloadStore> {
+        if !relative_root.starts_with(&self.root) {
+            return Err(RusticolError::security(
+                "evaluator payload root escapes the artifact root",
+            ));
+        }
+        Ok(EvaluatorPayloadStore {
+            artifact_root: self.root.clone(),
+            relative_root: relative_root.to_path_buf(),
+            container: self.evaluator_payload_container.clone(),
+            payloads: Some(self.payloads.clone()),
+            #[cfg(feature = "f64-compiled")]
+            native_library_cache: self.native_library_cache.clone(),
+        })
+    }
+
+    pub(crate) fn install_evaluator_payload_container(
+        &mut self,
+        extension: &EvaluatorPayloadContainerExtension,
+    ) -> RusticolResult<()> {
+        if self.evaluator_payload_container.is_none() {
+            self.evaluator_payload_container = Some(
+                load_evaluator_payload_container_extension(&self.root, extension, &self.payloads)?
+                    .ok_or_else(|| {
+                        RusticolError::internal(
+                            "declared evaluator payload container resolved to no reader",
+                        )
+                    })?,
+            );
+        }
+        Ok(())
+    }
+
+    pub(crate) fn has_evaluator_payload(&self, path: &str) -> RusticolResult<bool> {
+        if let Some(payload) = self.payloads.get(path) {
+            return Ok(payload.role == PayloadRole::EvaluatorState);
+        }
+        Ok(self
+            .evaluator_payload_container
+            .as_ref()
+            .is_some_and(|container| container.member(path).is_ok()))
+    }
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn validated_payload_declarations(
+    manifest: &ArtifactManifest,
+) -> RusticolResult<BTreeMap<String, Payload>> {
+    let mut payloads = BTreeMap::new();
+    let mut portable_paths = BTreeSet::new();
+    for payload in &manifest.payloads {
+        validate_payload_declaration(payload)?;
+        validate_relative_path(&payload.path, "payload path")?;
+        if payload.path == ARTIFACT_MANIFEST_FILE {
+            return Err(RusticolError::security(format!(
+                "{ARTIFACT_MANIFEST_FILE} is reserved for the artifact manifest"
+            )));
+        }
+        let portable = payload.path.to_ascii_lowercase();
+        if !portable_paths.insert(portable) {
+            return Err(RusticolError::security(format!(
+                "duplicate or case-colliding payload path {:?}",
+                payload.path
+            )));
+        }
+        if payloads
+            .insert(payload.path.clone(), payload.clone())
+            .is_some()
+        {
+            return Err(RusticolError::security(format!(
+                "duplicate payload path {:?}",
+                payload.path
+            )));
+        }
+    }
+    Ok(payloads)
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn read_bounded_recurrence_bootstrap(root: &Path, path: &Path) -> RusticolResult<Option<Vec<u8>>> {
+    reject_symlink_chain(path)?;
+    let metadata = match fs::symlink_metadata(path) {
+        Ok(metadata) => metadata,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+        Err(error) => {
+            return Err(RusticolError::artifact(format!(
+                "could not inspect recurrence bootstrap {}: {error}",
+                path.display()
+            )));
+        }
+    };
+    if metadata.file_type().is_symlink() || !metadata.is_file() {
+        return Err(RusticolError::security(format!(
+            "recurrence bootstrap {} must be a regular non-symlink file",
+            path.display()
+        )));
+    }
+    let size = usize::try_from(metadata.len()).map_err(|_| {
+        RusticolError::artifact("recurrence bootstrap size exceeds this platform's usize domain")
+    })?;
+    if size == 0 {
+        return Err(RusticolError::artifact(format!(
+            "recurrence bootstrap {} is empty",
+            path.display()
+        )));
+    }
+    #[cfg(unix)]
+    if metadata_is_executable(&metadata) {
+        return Err(RusticolError::security(format!(
+            "recurrence bootstrap {} must not be executable",
+            path.display()
+        )));
+    }
+    let canonical = path.canonicalize().map_err(|error| {
+        RusticolError::security(format!(
+            "could not resolve recurrence bootstrap {}: {error}",
+            path.display()
+        ))
+    })?;
+    if !canonical.starts_with(root) {
+        return Err(RusticolError::security(format!(
+            "recurrence bootstrap {} escapes the artifact root",
+            path.display()
+        )));
+    }
+    #[cfg(unix)]
+    let file = {
+        use std::os::unix::fs::OpenOptionsExt as _;
+        OpenOptions::new()
+            .read(true)
+            .custom_flags(libc::O_CLOEXEC | libc::O_NOFOLLOW)
+            .open(path)
+    };
+    #[cfg(not(unix))]
+    let file = OpenOptions::new().read(true).open(path);
+    let file = file.map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not open recurrence bootstrap {}: {error}",
+            path.display()
+        ))
+    })?;
+    let pinned = file.metadata().map_err(|error| {
+        RusticolError::security(format!(
+            "could not inspect opened recurrence bootstrap {}: {error}",
+            path.display()
+        ))
+    })?;
+    if !pinned.is_file() || pinned.len() != metadata.len() {
+        return Err(RusticolError::integrity(format!(
+            "recurrence bootstrap {} changed while being opened",
+            path.display()
+        )));
+    }
+    reject_symlink_chain(path)?;
+    let path_metadata = fs::symlink_metadata(path).map_err(|error| {
+        RusticolError::security(format!(
+            "could not re-inspect recurrence bootstrap {}: {error}",
+            path.display()
+        ))
+    })?;
+    if path_metadata.file_type().is_symlink() || !path_metadata.is_file() {
+        return Err(RusticolError::security(format!(
+            "recurrence bootstrap {} is not a regular non-symlink file",
+            path.display()
+        )));
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt as _;
+        if pinned.dev() != path_metadata.dev() || pinned.ino() != path_metadata.ino() {
+            return Err(RusticolError::security(format!(
+                "recurrence bootstrap {} was replaced while being opened",
+                path.display()
+            )));
+        }
+    }
+    let mut bytes = Vec::new();
+    bytes.try_reserve_exact(size).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not allocate {size} recurrence bootstrap bytes: {error}"
+        ))
+    })?;
+    // Read at most one byte beyond the pinned size. This detects a concurrent
+    // append without allowing a growing file to bypass the allocation bound.
+    let mut bounded = file.take(metadata.len().saturating_add(1));
+    bounded.read_to_end(&mut bytes).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not read recurrence bootstrap {}: {error}",
+            path.display()
+        ))
+    })?;
+    if bytes.len() != size {
+        return Err(RusticolError::integrity(format!(
+            "recurrence bootstrap {} changed while being read",
+            path.display()
+        )));
+    }
+    Ok(Some(bytes))
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn discover_single_recurrence_bootstrap_process(root: &Path) -> RusticolResult<Option<String>> {
+    let processes = root.join("processes");
+    let metadata = match fs::symlink_metadata(&processes) {
+        Ok(metadata) => metadata,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+        Err(error) => {
+            return Err(RusticolError::artifact(format!(
+                "could not inspect recurrence process root {}: {error}",
+                processes.display()
+            )));
+        }
+    };
+    if metadata.file_type().is_symlink() || !metadata.is_dir() {
+        return Err(RusticolError::security(format!(
+            "recurrence process root {} must be a regular non-symlink directory",
+            processes.display()
+        )));
+    }
+
+    let entries = fs::read_dir(&processes).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not enumerate recurrence process root {}: {error}",
+            processes.display()
+        ))
+    })?;
+    let mut selected: Option<String> = None;
+    for entry in entries {
+        let entry = entry.map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not enumerate recurrence process root {}: {error}",
+                processes.display()
+            ))
+        })?;
+        let Ok(process_id) = entry.file_name().into_string() else {
+            continue;
+        };
+        if validate_public_id(&process_id, "recurrence process directory").is_err() {
+            continue;
+        }
+        let file_type = entry.file_type().map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not inspect recurrence process directory {}: {error}",
+                entry.path().display()
+            ))
+        })?;
+        if file_type.is_symlink() {
+            return Err(RusticolError::security(format!(
+                "recurrence process directory {} must not be a symlink",
+                entry.path().display()
+            )));
+        }
+        if !file_type.is_dir() {
+            continue;
+        }
+        let sidecar = entry.path().join(RECURRENCE_BOOTSTRAP_FILENAME);
+        let sidecar_metadata = match fs::symlink_metadata(&sidecar) {
+            Ok(metadata) => metadata,
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => continue,
+            Err(error) => {
+                return Err(RusticolError::artifact(format!(
+                    "could not inspect recurrence bootstrap {}: {error}",
+                    sidecar.display()
+                )));
+            }
+        };
+        if sidecar_metadata.file_type().is_symlink() || !sidecar_metadata.is_file() {
+            return Err(RusticolError::security(format!(
+                "recurrence bootstrap {} must be a regular non-symlink file",
+                sidecar.display()
+            )));
+        }
+        if selected.replace(process_id).is_some() {
+            return Err(RusticolError::integrity(
+                "default recurrence bootstrap selection is ambiguous",
+            ));
+        }
+    }
+    Ok(selected)
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn read_canonical_manifest_artifact_id(path: &Path) -> RusticolResult<String> {
+    const PREFIX: &[u8] = b"{\"artifact_id\":\"";
+    const SUFFIX: &[u8] = b"\",";
+    let read_len = PREFIX.len() + 64 + SUFFIX.len();
+    #[cfg(unix)]
+    let file = {
+        use std::os::unix::fs::OpenOptionsExt as _;
+        OpenOptions::new()
+            .read(true)
+            .custom_flags(libc::O_CLOEXEC | libc::O_NOFOLLOW)
+            .open(path)
+    };
+    #[cfg(not(unix))]
+    let mut file = OpenOptions::new().read(true).open(path);
+    let mut file = file.map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not open artifact manifest {}: {error}",
+            path.display()
+        ))
+    })?;
+    if !file
+        .metadata()
+        .map_err(|error| {
+            RusticolError::security(format!(
+                "could not inspect artifact manifest {}: {error}",
+                path.display()
+            ))
+        })?
+        .is_file()
+    {
+        return Err(RusticolError::security(format!(
+            "artifact manifest {} is not a regular file",
+            path.display()
+        )));
+    }
+    let mut prefix = vec![0_u8; read_len];
+    file.read_exact(&mut prefix).map_err(|error| {
+        RusticolError::serialization(format!(
+            "artifact manifest {} has no canonical artifact-ID prefix: {error}",
+            path.display()
+        ))
+    })?;
+    let digest = &prefix[PREFIX.len()..PREFIX.len() + 64];
+    if !prefix.starts_with(PREFIX)
+        || &prefix[PREFIX.len() + 64..] != SUFFIX
+        || !digest
+            .iter()
+            .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f'))
+    {
+        return Err(RusticolError::integrity(format!(
+            "artifact manifest {} is not canonical at its artifact-ID prefix",
+            path.display()
+        )));
+    }
+    String::from_utf8(digest.to_vec()).map_err(|error| {
+        RusticolError::internal(format!(
+            "validated ASCII artifact ID was not UTF-8: {error}"
+        ))
+    })
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn compute_payload_artifact_id(payloads: &[Payload]) -> RusticolResult<String> {
+    let mut canonical = String::new();
+    canonical
+        .try_reserve(payloads.len().checked_mul(256).unwrap_or_default())
+        .map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not allocate recurrence artifact identity buffer: {error}"
+            ))
+        })?;
+    canonical.push_str("{\"kind\":\"pyamplicol-runtime-payload-identity\",\"payloads\":[");
+    let mut previous_path: Option<&str> = None;
+    let mut first = true;
+    for payload in payloads.iter().filter(|payload| {
+        matches!(
+            payload.role,
+            PayloadRole::CompiledModel
+                | PayloadRole::EvaluatorManifest
+                | PayloadRole::EvaluatorState
+                | PayloadRole::ModelParameters
+                | PayloadRole::RuntimePhysics
+        )
+    }) {
+        if previous_path.is_some_and(|previous| previous >= payload.path.as_str()) {
+            return Err(RusticolError::integrity(
+                "recurrence bootstrap payload inventory must be strictly path-sorted",
+            ));
+        }
+        previous_path = Some(&payload.path);
+        if !first {
+            canonical.push(',');
+        }
+        first = false;
+        canonical.push_str("{\"executable\":");
+        canonical.push_str(if payload.executable { "true" } else { "false" });
+        canonical.push_str(",\"media_type\":");
+        write_python_json_string(&payload.media_type, &mut canonical);
+        canonical.push_str(",\"path\":");
+        write_python_json_string(&payload.path, &mut canonical);
+        if let Some(process_id) = &payload.process_id {
+            canonical.push_str(",\"process_id\":");
+            write_python_json_string(process_id, &mut canonical);
+        }
+        canonical.push_str(",\"role\":");
+        write_python_json_string(payload_role_name(payload.role), &mut canonical);
+        canonical.push_str(",\"sha256\":");
+        write_python_json_string(&payload.sha256, &mut canonical);
+        canonical.push_str(",\"size_bytes\":");
+        let _ = write!(canonical, "{}", payload.size_bytes);
+        if let Some(target) = &payload.target {
+            canonical.push_str(",\"target\":{\"cpu_features\":[");
+            for (feature_index, feature) in target.cpu_features.iter().enumerate() {
+                if feature_index != 0 {
+                    canonical.push(',');
+                }
+                write_python_json_string(feature, &mut canonical);
+            }
+            canonical.push_str("],\"triple\":");
+            write_python_json_string(&target.triple, &mut canonical);
+            canonical.push('}');
+        }
+        canonical.push('}');
+    }
+    canonical.push_str("],\"schema_version\":1}\n");
+    Ok(format!("{:x}", Sha256::digest(canonical.as_bytes())))
+}
+
+fn payload_role_name(role: PayloadRole) -> &'static str {
+    match role {
+        PayloadRole::ConfigurationRequested => "configuration-requested",
+        PayloadRole::ConfigurationEffective => "configuration-effective",
+        PayloadRole::CompiledModel => "compiled-model",
+        PayloadRole::RuntimePhysics => "runtime-physics",
+        PayloadRole::EvaluatorManifest => "evaluator-manifest",
+        PayloadRole::EvaluatorState => "evaluator-state",
+        PayloadRole::ModelParameters => "model-parameters",
+        PayloadRole::ValidationMomenta => "validation-momenta",
+        PayloadRole::StructuralSourceProof => "structural-source-proof",
+        PayloadRole::ApiSource => "api-source",
+        PayloadRole::ApiBuildFile => "api-build-file",
+        PayloadRole::SdkMetadata => "sdk-metadata",
+        PayloadRole::ProcessGroups => "process-groups",
+    }
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn validate_recurrence_bootstrap_metadata(
+    producer: &Producer,
+    runtime: &ArtifactRuntime,
+) -> RusticolResult<()> {
+    if producer.distribution != "pyamplicol"
+        || runtime.engine != "rusticol"
+        || runtime.engine_version != producer.version
+        || !compatible_distribution_version(&producer.version)
+    {
+        return Err(RusticolError::compatibility(format!(
+            "recurrence bootstrap producer/runtime {}/{}/{} is incompatible with Rusticol {}",
+            producer.distribution,
+            producer.version,
+            runtime.engine_version,
+            rusticol_package_version()
+        )));
+    }
+    let versions = &producer.versions;
+    for (name, found, expected) in [
+        ("python API", versions.python_api, PYTHON_API_VERSION),
+        ("TOML", versions.toml, TOML_SCHEMA_VERSION),
+        (
+            "compiled model",
+            versions.compiled_model,
+            COMPILED_MODEL_SCHEMA_VERSION,
+        ),
+        (
+            "process artifact",
+            versions.process_artifact,
+            PROCESS_ARTIFACT_SCHEMA_VERSION,
+        ),
+        (
+            "runtime physics",
+            versions.runtime_physics,
+            RUNTIME_PHYSICS_SCHEMA_VERSION,
+        ),
+        ("C ABI", versions.c_abi, C_ABI_VERSION),
+    ] {
+        if found != expected {
+            return Err(RusticolError::compatibility(format!(
+                "recurrence bootstrap {name} version {found} is incompatible with {expected}"
+            )));
+        }
+    }
+    if let Some(revision) = &producer.git_revision
+        && (revision.len() != 40
+            || !revision
+                .bytes()
+                .all(|byte| byte.is_ascii_hexdigit() && !byte.is_ascii_uppercase()))
+    {
+        return Err(RusticolError::artifact(
+            "recurrence bootstrap producer git revision is not canonical",
+        ));
+    }
+    if let Some(identity) = &producer.native_build_inputs_sha256 {
+        validate_sha256(identity, "recurrence bootstrap native build identity")?;
+    }
+    validate_relative_path(
+        &runtime.evaluator_manifest_path,
+        "recurrence bootstrap evaluator manifest path",
+    )?;
+    if let Some(path) = &runtime.api_bundle_path {
+        validate_relative_path(path, "recurrence bootstrap API bundle path")?;
+    }
+    let capabilities = validate_runtime_capabilities(
+        &runtime.required_runtime_capabilities,
+        "recurrence bootstrap runtime capabilities",
+    )?;
+    validate_target(&producer.target, "recurrence bootstrap producer")?;
+    validate_portable_runtime_capabilities(&producer.target, &capabilities)
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn validate_recurrence_bootstrap_process(process: &ArtifactProcess) -> RusticolResult<()> {
+    validate_public_id(&process.id, "recurrence bootstrap process id")?;
+    if process.expression.is_empty()
+        || process.external_pdgs.len() < 3
+        || !matches!(process.color_accuracy.as_str(), "lc" | "nlc" | "full")
+    {
+        return Err(RusticolError::artifact(format!(
+            "recurrence bootstrap process {:?} has invalid public metadata",
+            process.id
+        )));
+    }
+    let expected_physics = format!("processes/{}/physics.json", process.id);
+    if process.physics_path != expected_physics {
+        return Err(RusticolError::security(format!(
+            "recurrence bootstrap process {:?} physics path must be {expected_physics:?}",
+            process.id
+        )));
+    }
+    validate_runtime_capabilities(
+        &process.required_runtime_capabilities,
+        "recurrence bootstrap process capabilities",
+    )?;
+    if process.aliases.is_empty() {
+        return Ok(());
+    }
+    let initial_count = parse_process_expression(&process.expression)
+        .map(|tokens| tokens.initial.len())
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "recurrence bootstrap process expression {:?} is invalid",
+                process.expression
+            ))
+        })?;
+    let mut aliases = BTreeSet::new();
+    for alias in &process.aliases {
+        validate_public_id(&alias.id, "recurrence bootstrap alias id")?;
+        if !aliases.insert(alias.id.as_str())
+            || alias.expression.is_empty()
+            || alias.external_pdgs.len() != process.external_pdgs.len()
+        {
+            return Err(RusticolError::artifact(format!(
+                "recurrence bootstrap alias {:?} is invalid",
+                alias.id
+            )));
+        }
+        validate_permutation(
+            &alias.external_permutation,
+            process.external_pdgs.len(),
+            &format!("alias {:?}", alias.id),
+        )?;
+        if !permutation_preserves_process_sides(&alias.external_permutation, initial_count) {
+            return Err(RusticolError::artifact(format!(
+                "recurrence bootstrap alias {:?} crosses process sides",
+                alias.id
+            )));
+        }
+    }
+    Ok(())
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn validate_recurrence_bootstrap_source_payload(
+    payloads: &BTreeMap<String, Payload>,
+    path: &str,
+    sha256: &str,
+    role: PayloadRole,
+    process_id: &str,
+) -> RusticolResult<()> {
+    let payload = payloads.get(path).ok_or_else(|| {
+        RusticolError::security(format!(
+            "recurrence bootstrap source {path:?} is not a declared payload"
+        ))
+    })?;
+    if payload.role != role
+        || payload.media_type != "application/json"
+        || payload.process_id.as_deref() != Some(process_id)
+        || payload.executable
+        || payload.sha256 != sha256
+    {
+        return Err(RusticolError::integrity(format!(
+            "recurrence bootstrap source {path:?} disagrees with its payload declaration"
+        )));
+    }
+    Ok(())
+}
+
+fn recurrence_bootstrap_manifest(
+    artifact_id: String,
+    producer: Producer,
+    runtime: ArtifactRuntime,
+    process: ArtifactProcess,
+    payloads: Vec<Payload>,
+) -> ArtifactManifest {
+    let process_id = process.id.clone();
+    ArtifactManifest {
+        schema_version: PROCESS_ARTIFACT_SCHEMA_VERSION,
+        kind: ArtifactKind::PyamplicolProcess,
+        artifact_id,
+        created_utc: "1970-01-01T00:00:00Z".to_string(),
+        producer,
+        model: ArtifactModel {
+            name: "recurrence-bootstrap".to_string(),
+            source_kind: ModelSourceKind::CompiledModel,
+            content_sha256: "0".repeat(64),
+            compiled_schema_version: COMPILED_MODEL_SCHEMA_VERSION,
+            restriction: None,
+        },
+        configuration: ArtifactConfiguration {
+            toml_schema_version: TOML_SCHEMA_VERSION,
+            requested_path: "config/requested.toml".to_string(),
+            effective_path: "config/effective.toml".to_string(),
+            adjustments: Vec::new(),
+        },
+        processes: vec![process],
+        default_process_id: Some(process_id),
+        runtime,
+        payloads,
+        dependencies: Vec::new(),
+        extensions: BTreeMap::new(),
+    }
+}
+
+/// Construct the same narrowly-scoped artifact view while generation still
+/// owns the private staging directory.  This is used only to lower the ready
+/// recipe through the authoritative PACBIN/binding loaders; the staging path
+/// itself is never serialized.
+#[cfg(feature = "python-generation-bridge")]
+pub(crate) fn open_staged_recurrence_bootstrap_artifact(
+    root: PathBuf,
+    producer: Producer,
+    runtime: ArtifactRuntime,
+    process: ArtifactProcess,
+    payloads: Vec<Payload>,
+    evaluator_payload_container: EvaluatorPayloadContainerExtension,
+) -> RusticolResult<VerifiedArtifact> {
+    let root = fs::canonicalize(&root).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not resolve recurrence bootstrap staging root {}: {error}",
+            root.display()
+        ))
+    })?;
+    if !root.is_dir() {
+        return Err(RusticolError::artifact(format!(
+            "recurrence bootstrap staging root {} is not a directory",
+            root.display()
+        )));
+    }
+    validate_recurrence_bootstrap_metadata(&producer, &runtime)?;
+    validate_recurrence_bootstrap_process(&process)?;
+    let manifest =
+        recurrence_bootstrap_manifest("0".repeat(64), producer, runtime, process, payloads);
+    let payloads = validated_payload_declarations(&manifest)?;
+    for payload in payloads.values() {
+        if let Some(target) = &payload.target {
+            validate_payload_target(&manifest.producer.target, target, &payload.path)?;
+            validate_target(target, &format!("payload {}", payload.path))?;
+        }
+    }
+    validate_evaluator_payload_container_declaration(&evaluator_payload_container, &payloads)?;
+    Ok(VerifiedArtifact {
+        manifest_path: root.join(ARTIFACT_MANIFEST_FILE),
+        root,
+        manifest,
+        payloads: Arc::new(payloads),
+        // Process-ready lowering reads only loose plan/binding/color payloads.
+        evaluator_payload_container: None,
+        #[cfg(feature = "f64-compiled")]
+        native_library_cache: Arc::new(Mutex::new(BTreeMap::new())),
+    })
+}
+
+fn load_evaluator_payload_container(
+    root: &Path,
+    manifest: &ArtifactManifest,
+    payloads: &BTreeMap<String, Payload>,
+) -> RusticolResult<Option<Arc<PacbinReader>>> {
+    let Some(raw) = manifest
+        .extensions
+        .get(EVALUATOR_PAYLOAD_CONTAINER_EXTENSION)
+    else {
+        return Ok(None);
+    };
+    let extension: EvaluatorPayloadContainerExtension = serde_json::from_value(raw.clone())
+        .map_err(|error| {
+            RusticolError::artifact(format!(
+                "artifact extension {EVALUATOR_PAYLOAD_CONTAINER_EXTENSION:?} is invalid: {error}"
+            ))
+        })?;
+    load_evaluator_payload_container_extension(root, &extension, payloads)
+}
+
+fn load_evaluator_payload_container_extension(
+    root: &Path,
+    extension: &EvaluatorPayloadContainerExtension,
+    payloads: &BTreeMap<String, Payload>,
+) -> RusticolResult<Option<Arc<PacbinReader>>> {
+    let payload = validate_evaluator_payload_container_declaration(extension, payloads)?;
+    let expected_payload_sha = parse_sha256(
+        &payload.sha256,
+        "evaluator payload container payload SHA-256",
+    )?;
+    let container_path = root.join(&extension.path);
+    let container_file = open_checked_payload(root, payload)?;
+    let reader = PacbinReader::open_file_with_sha256(
+        container_file,
+        &container_path,
+        &expected_payload_sha,
+    )?;
+    let index = reader.index();
+    if index.version() != 1
+        || u64::try_from(index.members().len()).unwrap_or(u64::MAX) != extension.member_count
+        || hex_digest(index.index_sha256()) != extension.index_sha256
+    {
+        return Err(RusticolError::integrity(
+            "evaluator payload container metadata disagrees with its authenticated index",
+        ));
+    }
+    let unpacked_size = index.members().iter().try_fold(0_u64, |total, member| {
+        total
+            .checked_add(member.length())
+            .ok_or_else(|| RusticolError::integrity("packed evaluator size exceeds u64"))
+    })?;
+    if unpacked_size != extension.unpacked_size_bytes {
+        return Err(RusticolError::integrity(
+            "evaluator payload container unpacked size disagrees with its index",
+        ));
+    }
+    for member in index.members() {
+        validate_relative_path(member.logical_path(), "packed evaluator logical path")?;
+        if payloads.contains_key(member.logical_path())
+            || member.logical_path() == extension.path
+            || !matches!(
+                member.kind(),
+                PacbinMemberKind::SymjitApplication
+                    | PacbinMemberKind::SymbolicaExactState
+                    | PacbinMemberKind::ColorContraction
+            )
+        {
+            return Err(RusticolError::integrity(format!(
+                "invalid packed evaluator member {:?}",
+                member.logical_path()
+            )));
+        }
+    }
+    Ok(Some(Arc::new(reader)))
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn validate_evaluator_payload_container_declaration<'a>(
+    extension: &EvaluatorPayloadContainerExtension,
+    payloads: &'a BTreeMap<String, Payload>,
+) -> RusticolResult<&'a Payload> {
+    if extension.kind != EVALUATOR_PAYLOAD_CONTAINER_KIND
+        || extension.schema_version != 1
+        || extension.storage_abi != EVALUATOR_PAYLOAD_CONTAINER_STORAGE_ABI
+    {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported evaluator payload container kind/version/ABI: {:?}/{}/{}",
+            extension.kind, extension.schema_version, extension.storage_abi
+        )));
+    }
+    validate_relative_path(&extension.path, "evaluator payload container path")?;
+    validate_sha256(
+        &extension.index_sha256,
+        "evaluator payload container index_sha256",
+    )?;
+    let payload = payloads.get(&extension.path).ok_or_else(|| {
+        RusticolError::security(format!(
+            "evaluator payload container {:?} is not a declared payload",
+            extension.path
+        ))
+    })?;
+    if payload.role != PayloadRole::EvaluatorState
+        || payload.media_type != "application/octet-stream"
+        || payload.process_id.is_some()
+    {
+        return Err(RusticolError::artifact(
+            "evaluator payload container must be a root evaluator-state octet-stream payload",
+        ));
+    }
+    parse_sha256(
+        &payload.sha256,
+        "evaluator payload container payload SHA-256",
+    )?;
+    Ok(payload)
+}
+
+fn confined_evaluator_path(value: &str) -> RusticolResult<&Path> {
+    let path = Path::new(value);
+    if value.is_empty()
+        || value.contains('\\')
+        || path.is_absolute()
+        || path
+            .components()
+            .any(|component| !matches!(component, std::path::Component::Normal(_)))
+    {
+        return Err(RusticolError::security(format!(
+            "evaluator payload path {value:?} is not a confined relative path"
+        )));
+    }
+    Ok(path)
+}
+
+fn artifact_logical_path(root: &Path, path: &Path) -> RusticolResult<String> {
+    let relative = path
+        .strip_prefix(root)
+        .map_err(|_| RusticolError::security("evaluator payload path escapes the artifact root"))?;
+    let logical = relative
+        .to_str()
+        .ok_or_else(|| RusticolError::security("evaluator payload path is not valid UTF-8"))?;
+    Ok(logical.replace(std::path::MAIN_SEPARATOR, "/"))
+}
+
+fn hex_digest(bytes: &[u8]) -> String {
+    let mut result = String::with_capacity(bytes.len() * 2);
+    for byte in bytes {
+        use std::fmt::Write as _;
+        let _ = write!(result, "{byte:02x}");
+    }
+    result
+}
+
+impl ArtifactManifest {
+    pub(crate) fn select_process(
+        &self,
+        requested: Option<&str>,
+    ) -> RusticolResult<ArtifactSelection> {
+        self.select_process_with_groups(requested, || Ok(None))
+    }
+
+    /// Resolve `requested` in precedence order. `groups` is called at most
+    /// once, and only after every stored process, alias, and side permutation
+    /// of their expressions failed to match.
+    pub(crate) fn select_process_with_groups(
+        &self,
+        requested: Option<&str>,
+        groups: impl FnOnce() -> RusticolResult<Option<ProcessGroups>>,
+    ) -> RusticolResult<ArtifactSelection> {
+        let selected_id = if let Some(requested) = requested {
+            requested
+        } else if let Some(default) = self.default_process_id.as_deref() {
+            default
+        } else if self.processes.len() == 1 {
+            self.processes[0].id.as_str()
+        } else {
+            return Err(RusticolError::selector(
+                "this process-set artifact has no default process; select a process or alias id",
+            ));
+        };
+        for process in &self.processes {
+            if process.id == selected_id {
+                return Ok(representative_selection(process));
+            }
+            if let Some(alias) = process.aliases.iter().find(|alias| alias.id == selected_id) {
+                return Ok(alias_selection(process, alias));
+            }
+        }
+
+        let requested_expression = normalize_process_expression(selected_id);
+        let mut process_expression_matches = self
+            .processes
+            .iter()
+            .filter(|process| {
+                normalize_process_expression(&process.expression) == requested_expression
+            })
+            .map(representative_selection)
+            .collect::<Vec<_>>();
+        match process_expression_matches.len() {
+            1 => {
+                return Ok(process_expression_matches
+                    .pop()
+                    .expect("one process expression match"));
+            }
+            count if count > 1 => {
+                let mut matching_ids = process_expression_matches
+                    .iter()
+                    .map(|selection| selection.requested_id.as_str())
+                    .collect::<Vec<_>>();
+                matching_ids.sort_unstable();
+                return Err(RusticolError::selector(format!(
+                    "process expression {selected_id:?} is ambiguous; select one of these stable ids: {}",
+                    matching_ids.join(", ")
+                )));
+            }
+            _ => {}
+        }
+        let mut alias_expression_matches = self
+            .processes
+            .iter()
+            .flat_map(|process| {
+                process
+                    .aliases
+                    .iter()
+                    .filter(|alias| {
+                        normalize_process_expression(&alias.expression) == requested_expression
+                    })
+                    .map(|alias| alias_selection(process, alias))
+            })
+            .collect::<Vec<_>>();
+        match alias_expression_matches.len() {
+            1 => {
+                return Ok(alias_expression_matches
+                    .pop()
+                    .expect("one alias expression match"));
+            }
+            count if count > 1 => {
+                let mut matching_ids = alias_expression_matches
+                    .iter()
+                    .map(|selection| selection.requested_id.as_str())
+                    .collect::<Vec<_>>();
+                matching_ids.sort_unstable();
+                return Err(RusticolError::selector(format!(
+                    "process expression {selected_id:?} is ambiguous; select one of these stable ids: {}",
+                    matching_ids.join(", ")
+                )));
+            }
+            _ => {}
+        }
+
+        let Some(requested_tokens) = parse_process_expression(selected_id) else {
+            if let Some(groups) = groups()?
+                && let Some(selection) = groups.select(self, selected_id, None)?
+            {
+                return Ok(selection);
+            }
+            if selected_id.contains('>') {
+                return Err(RusticolError::selector(format!(
+                    "concrete process expression {selected_id:?} must contain one '>' with at least one particle on each side"
+                )));
+            }
+            return Err(RusticolError::selector(format!(
+                "unknown process id or alias id {selected_id:?}"
+            )));
+        };
+        let mut permutation_matches = Vec::new();
+        let mut crossing_only_matches = Vec::new();
+        for process in &self.processes {
+            let Some(representative_tokens) = parse_process_expression(&process.expression) else {
+                continue;
+            };
+            if let Some(permutation) =
+                side_preserving_process_permutation(&representative_tokens, &requested_tokens)
+            {
+                let mut external_pdgs = vec![0; process.external_pdgs.len()];
+                for (representative_index, public_index) in permutation.iter().copied().enumerate()
+                {
+                    external_pdgs[public_index] = process.external_pdgs[representative_index];
+                }
+                permutation_matches.push(ArtifactSelection {
+                    process: process.clone(),
+                    // An inferred expression has no persisted alias identity;
+                    // retain the representative stable process id.
+                    requested_id: process.id.clone(),
+                    alias: None,
+                    public_expression: requested_tokens.canonical.clone(),
+                    external_pdgs,
+                    external_permutation: permutation,
+                    inferred_permutation: true,
+                    process_group: None,
+                });
+            } else if process_tokens_are_permutation_equivalent_ignoring_sides(
+                &representative_tokens,
+                &requested_tokens,
+            ) {
+                crossing_only_matches.push(process.id.as_str());
+            }
+        }
+        if permutation_matches.len() > 1 {
+            // Multiprocess artifacts commonly retain both incoming orderings
+            // of the same physical channel. Prefer the representative that
+            // already agrees with the requested ordering in the most slots;
+            // only genuinely tied representatives remain ambiguous.
+            let minimum_displacement = permutation_matches
+                .iter()
+                .map(|selection| permutation_displacement(&selection.external_permutation))
+                .min()
+                .expect("more than one permutation match");
+            permutation_matches.retain(|selection| {
+                permutation_displacement(&selection.external_permutation) == minimum_displacement
+            });
+        }
+        match permutation_matches.len() {
+            1 => return Ok(permutation_matches.pop().expect("one permutation match")),
+            count if count > 1 => {
+                let mut matching_ids = permutation_matches
+                    .iter()
+                    .map(|selection| selection.process.id.as_str())
+                    .collect::<Vec<_>>();
+                matching_ids.sort_unstable();
+                matching_ids.dedup();
+                return Err(RusticolError::selector(format!(
+                    "process expression {selected_id:?} is permutation-ambiguous; select one of these stable ids: {}",
+                    matching_ids.join(", ")
+                )));
+            }
+            _ => {}
+        }
+        if let Some(groups) = groups()?
+            && let Some(selection) = groups.select(self, selected_id, Some(&requested_tokens))?
+        {
+            return Ok(selection);
+        }
+        if !crossing_only_matches.is_empty() {
+            crossing_only_matches.sort_unstable();
+            crossing_only_matches.dedup();
+            return Err(RusticolError::selector(format!(
+                "process expression {selected_id:?} would move a particle across the '>' boundary; only permutations within the incoming and outgoing sides are supported (matching stable ids: {})",
+                crossing_only_matches.join(", ")
+            )));
+        }
+        Err(RusticolError::selector(format!(
+            "unknown process id, alias id, or concrete process expression {selected_id:?}"
+        )))
+    }
+}
+
+fn representative_selection(process: &ArtifactProcess) -> ArtifactSelection {
+    ArtifactSelection {
+        process: process.clone(),
+        requested_id: process.id.clone(),
+        alias: None,
+        public_expression: process.expression.clone(),
+        external_pdgs: process.external_pdgs.clone(),
+        external_permutation: (0..process.external_pdgs.len()).collect(),
+        inferred_permutation: false,
+        process_group: None,
+    }
+}
+
+fn alias_selection(process: &ArtifactProcess, alias: &ProcessAlias) -> ArtifactSelection {
+    ArtifactSelection {
+        process: process.clone(),
+        requested_id: alias.id.clone(),
+        alias: Some(alias.clone()),
+        public_expression: alias.expression.clone(),
+        external_pdgs: alias.external_pdgs.clone(),
+        external_permutation: alias.external_permutation.clone(),
+        inferred_permutation: false,
+        process_group: None,
+    }
+}
+
+#[derive(Clone, Debug)]
+struct ProcessExpressionTokens {
+    initial: Vec<String>,
+    final_state: Vec<String>,
+    canonical: String,
+}
+
+fn parse_process_expression(expression: &str) -> Option<ProcessExpressionTokens> {
+    let tokens = expression
+        .split_whitespace()
+        .map(str::to_lowercase)
+        .collect::<Vec<_>>();
+    let separators = tokens
+        .iter()
+        .enumerate()
+        .filter_map(|(index, token)| (token == ">").then_some(index))
+        .collect::<Vec<_>>();
+    let [separator] = separators.as_slice() else {
+        return None;
+    };
+    if *separator == 0 || *separator + 1 == tokens.len() {
+        return None;
+    }
+    let initial = tokens[..*separator].to_vec();
+    let final_state = tokens[*separator + 1..].to_vec();
+    Some(ProcessExpressionTokens {
+        canonical: format!("{} > {}", initial.join(" "), final_state.join(" ")),
+        initial,
+        final_state,
+    })
+}
+
+fn side_preserving_process_permutation(
+    representative: &ProcessExpressionTokens,
+    public: &ProcessExpressionTokens,
+) -> Option<Vec<usize>> {
+    if representative.initial.len() != public.initial.len()
+        || representative.final_state.len() != public.final_state.len()
+    {
+        return None;
+    }
+    let initial = deterministic_side_permutation(&representative.initial, &public.initial, 0)?;
+    let final_offset = representative.initial.len();
+    let final_state = deterministic_side_permutation(
+        &representative.final_state,
+        &public.final_state,
+        final_offset,
+    )?;
+    Some(initial.into_iter().chain(final_state).collect())
+}
+
+/// Match repeated particles deterministically by assigning each representative
+/// occurrence to the first still-unused equal public occurrence.
+fn deterministic_side_permutation(
+    representative: &[String],
+    public: &[String],
+    offset: usize,
+) -> Option<Vec<usize>> {
+    let mut used = vec![false; public.len()];
+    representative
+        .iter()
+        .map(|particle| {
+            let public_index = public.iter().enumerate().find_map(|(index, candidate)| {
+                (!used[index] && candidate == particle).then_some(index)
+            })?;
+            used[public_index] = true;
+            Some(offset + public_index)
+        })
+        .collect()
+}
+
+fn permutation_displacement(permutation: &[usize]) -> usize {
+    permutation
+        .iter()
+        .copied()
+        .enumerate()
+        .filter(|(representative_index, public_index)| representative_index != public_index)
+        .count()
+}
+
+fn process_tokens_are_permutation_equivalent_ignoring_sides(
+    representative: &ProcessExpressionTokens,
+    public: &ProcessExpressionTokens,
+) -> bool {
+    let mut representative = representative
+        .initial
+        .iter()
+        .chain(&representative.final_state)
+        .cloned()
+        .collect::<Vec<_>>();
+    let mut public = public
+        .initial
+        .iter()
+        .chain(&public.final_state)
+        .cloned()
+        .collect::<Vec<_>>();
+    representative.sort_unstable();
+    public.sort_unstable();
+    representative == public
+}
+
+fn normalize_process_expression(expression: &str) -> String {
+    expression
+        .split_whitespace()
+        .map(str::to_lowercase)
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+const PROCESS_GROUPS_KIND: &str = "pyamplicol-process-groups";
+const PROCESS_GROUPS_SCHEMA_VERSION: u64 = 1;
+
+// Unknown keys (`analyses`, `basis`, `warning`, ...) are ignored on purpose.
+#[derive(Deserialize)]
+struct ProcessGroupsDocument {
+    kind: String,
+    schema_version: u64,
+    groups: Vec<ProcessGroupRecord>,
+}
+
+#[derive(Deserialize)]
+struct ProcessGroupRecord {
+    representative: ProcessGroupRepresentativeRecord,
+    members: Vec<ProcessGroupMemberRecord>,
+}
+
+#[derive(Deserialize)]
+struct ProcessGroupRepresentativeRecord {
+    process_id: String,
+}
+
+#[derive(Deserialize)]
+struct ProcessGroupMemberRecord {
+    process_id: String,
+    process: String,
+    pdgs: Vec<i32>,
+    initial_count: usize,
+    factor: ProcessGroupFactorRecord,
+    permutation: Vec<usize>,
+    conjugated: bool,
+    generated: bool,
+}
+
+#[derive(Deserialize)]
+struct ProcessGroupFactorRecord {
+    numerator: i64,
+    denominator: i64,
+}
+
+/// The non-generated members of a validated `process-groups.json`.
+#[derive(Clone, Debug)]
+pub(crate) struct ProcessGroups {
+    members: Vec<ProcessGroupMember>,
+}
+
+#[derive(Clone, Debug)]
+struct ProcessGroupMember {
+    id: String,
+    expression: String,
+    tokens: ProcessExpressionTokens,
+    /// Particle names and PDGs in the member's own order.
+    particles: Vec<String>,
+    pdgs: Vec<i32>,
+    representative_id: String,
+    /// Representative external index to member external index.
+    permutation: Vec<usize>,
+    factor_numerator: u64,
+    factor_denominator: u64,
+    conjugated: bool,
+}
+
+impl ProcessGroups {
+    pub(crate) fn from_json(bytes: &[u8], manifest: &ArtifactManifest) -> RusticolResult<Self> {
+        let document: ProcessGroupsDocument = serde_json::from_slice(bytes).map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not parse the process-groups payload: {error}"
+            ))
+        })?;
+        if document.kind != PROCESS_GROUPS_KIND
+            || document.schema_version != PROCESS_GROUPS_SCHEMA_VERSION
+        {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported process-groups payload kind {:?} schema {}",
+                document.kind, document.schema_version
+            )));
+        }
+        let stored_ids = manifest
+            .processes
+            .iter()
+            .flat_map(|process| {
+                std::iter::once(process.id.as_str())
+                    .chain(process.aliases.iter().map(|alias| alias.id.as_str()))
+            })
+            .collect::<BTreeSet<_>>();
+        let mut member_ids = BTreeSet::new();
+        let mut members = Vec::new();
+        for group in document.groups {
+            let representative_id = group.representative.process_id;
+            let process = manifest
+                .processes
+                .iter()
+                .find(|process| process.id == representative_id)
+                .ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "process-group representative {representative_id:?} is not a stored process"
+                    ))
+                })?;
+            let count = process.external_pdgs.len();
+            let initial_count = parse_process_expression(&process.expression)
+                .map(|tokens| tokens.initial.len())
+                .ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "process {representative_id:?} has no incoming and outgoing particles"
+                    ))
+                })?;
+            let identity = group.members.first().is_some_and(|member| {
+                member.process_id == representative_id
+                    && member.generated
+                    && !member.conjugated
+                    && member.factor.numerator == member.factor.denominator
+                    && member.permutation.iter().copied().eq(0..count)
+            });
+            if !identity {
+                return Err(RusticolError::artifact(format!(
+                    "process group {representative_id:?} must list its representative first with the identity relation"
+                )));
+            }
+            for member in group.members {
+                let id = member.process_id;
+                validate_public_id(&id, "process-group member id")?;
+                if !member_ids.insert(id.clone()) {
+                    return Err(RusticolError::artifact(format!(
+                        "process-group member {id:?} is listed more than once"
+                    )));
+                }
+                if member.generated {
+                    if !manifest.processes.iter().any(|process| process.id == id) {
+                        return Err(RusticolError::artifact(format!(
+                            "generated process-group member {id:?} is not a stored process"
+                        )));
+                    }
+                    continue;
+                }
+                if stored_ids.contains(id.as_str()) {
+                    return Err(RusticolError::artifact(format!(
+                        "non-generated process-group member {id:?} reuses a stored process or alias id"
+                    )));
+                }
+                let tokens = parse_process_expression(&member.process)
+                    .filter(|tokens| {
+                        tokens.initial.len() == initial_count
+                            && tokens.initial.len() + tokens.final_state.len() == count
+                    })
+                    .ok_or_else(|| {
+                        RusticolError::artifact(format!(
+                            "process-group member {id:?} expression {:?} does not have the incoming and outgoing particle counts of {representative_id:?}",
+                            member.process
+                        ))
+                    })?;
+                if member.pdgs.len() != count || member.initial_count != initial_count {
+                    return Err(RusticolError::artifact(format!(
+                        "process-group member {id:?} PDGs or initial count disagree with {representative_id:?}"
+                    )));
+                }
+                validate_permutation(
+                    &member.permutation,
+                    count,
+                    &format!("process-group member {id:?}"),
+                )?;
+                if !permutation_preserves_process_sides(&member.permutation, initial_count) {
+                    return Err(RusticolError::artifact(format!(
+                        "process-group member {id:?} permutation moves a particle across the '>' boundary"
+                    )));
+                }
+                let (factor_numerator, factor_denominator) = positive_rational(
+                    member.factor.numerator,
+                    member.factor.denominator,
+                )
+                .ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "process-group member {id:?} factor {}/{} is not a positive rational",
+                        member.factor.numerator, member.factor.denominator
+                    ))
+                })?;
+                members.push(ProcessGroupMember {
+                    particles: member
+                        .process
+                        .split_whitespace()
+                        .filter(|token| *token != ">")
+                        .map(str::to_string)
+                        .collect(),
+                    id,
+                    expression: member.process,
+                    tokens,
+                    pdgs: member.pdgs,
+                    representative_id: representative_id.clone(),
+                    permutation: member.permutation,
+                    factor_numerator,
+                    factor_denominator,
+                    conjugated: member.conjugated,
+                });
+            }
+        }
+        Ok(Self { members })
+    }
+
+    /// Match a member by stable ID, exact expression, or side permutation of
+    /// its expression, mirroring the precedence used for stored processes.
+    fn select(
+        &self,
+        manifest: &ArtifactManifest,
+        selected_id: &str,
+        requested: Option<&ProcessExpressionTokens>,
+    ) -> RusticolResult<Option<ArtifactSelection>> {
+        if let Some(member) = self.members.iter().find(|member| member.id == selected_id) {
+            return member.selection(manifest, None).map(Some);
+        }
+        let Some(requested) = requested else {
+            return Ok(None);
+        };
+        let exact = self
+            .members
+            .iter()
+            .filter(|member| member.tokens.canonical == requested.canonical)
+            .collect::<Vec<_>>();
+        match exact.as_slice() {
+            [] => {}
+            [member] => return member.selection(manifest, None).map(Some),
+            _ => {
+                return Err(ambiguous_member_selection(
+                    selected_id,
+                    "is ambiguous",
+                    exact.iter().map(|member| member.id.as_str()),
+                ));
+            }
+        }
+        let mut matches = self
+            .members
+            .iter()
+            .filter_map(|member| {
+                side_preserving_process_permutation(&member.tokens, requested)
+                    .map(|permutation| (member, permutation))
+            })
+            .collect::<Vec<_>>();
+        if let Some(minimum) = matches
+            .iter()
+            .map(|(_, permutation)| permutation_displacement(permutation))
+            .min()
+        {
+            matches.retain(|(_, permutation)| permutation_displacement(permutation) == minimum);
+        }
+        match matches.as_slice() {
+            [] => Ok(None),
+            [(member, permutation)] => member
+                .selection(manifest, Some((permutation, &requested.canonical)))
+                .map(Some),
+            _ => Err(ambiguous_member_selection(
+                selected_id,
+                "is permutation-ambiguous",
+                matches.iter().map(|(member, _)| member.id.as_str()),
+            )),
+        }
+    }
+}
+
+impl ProcessGroupMember {
+    /// `public` is the member-index to public-index permutation and the
+    /// public expression of an inferred ordering; `None` keeps the member's.
+    fn selection(
+        &self,
+        manifest: &ArtifactManifest,
+        public: Option<(&[usize], &str)>,
+    ) -> RusticolResult<ArtifactSelection> {
+        let process = manifest
+            .processes
+            .iter()
+            .find(|process| process.id == self.representative_id)
+            .ok_or_else(|| {
+                RusticolError::internal("process-group representative left the manifest")
+            })?;
+        let count = self.pdgs.len();
+        let identity = (0..count).collect::<Vec<_>>();
+        let (member_to_public, public_expression) =
+            public.unwrap_or((&identity, self.expression.as_str()));
+        let mut external_pdgs = vec![0; count];
+        let mut particles = vec![String::new(); count];
+        for (member_index, public_index) in member_to_public.iter().copied().enumerate() {
+            external_pdgs[public_index] = self.pdgs[member_index];
+            particles[public_index].clone_from(&self.particles[member_index]);
+        }
+        Ok(ArtifactSelection {
+            process: process.clone(),
+            requested_id: self.id.clone(),
+            alias: None,
+            public_expression: public_expression.to_string(),
+            external_pdgs,
+            // Representative -> member -> public.
+            external_permutation: self
+                .permutation
+                .iter()
+                .map(|member_index| member_to_public[*member_index])
+                .collect(),
+            inferred_permutation: public.is_some(),
+            process_group: Some(ProcessGroupRelation {
+                factor_numerator: self.factor_numerator,
+                factor_denominator: self.factor_denominator,
+                conjugated: self.conjugated,
+                external_particles: particles,
+            }),
+        })
+    }
+}
+
+fn ambiguous_member_selection<'a>(
+    selected_id: &str,
+    problem: &str,
+    ids: impl Iterator<Item = &'a str>,
+) -> RusticolError {
+    let mut ids = ids.collect::<Vec<_>>();
+    ids.sort_unstable();
+    RusticolError::selector(format!(
+        "process expression {selected_id:?} {problem}; select one of these process-group member ids: {}",
+        ids.join(", ")
+    ))
+}
+
+/// Reduce `numerator / denominator` and return it when it is positive.
+fn positive_rational(numerator: i64, denominator: i64) -> Option<(u64, u64)> {
+    if numerator == 0 || denominator == 0 || (numerator < 0) != (denominator < 0) {
+        return None;
+    }
+    let (mut numerator, mut denominator) = (numerator.unsigned_abs(), denominator.unsigned_abs());
+    let (mut left, mut right) = (numerator, denominator);
+    while right != 0 {
+        (left, right) = (right, left % right);
+    }
+    numerator /= left;
+    denominator /= left;
+    Some((numerator, denominator))
+}
+
+#[cfg(test)]
+fn compute_artifact_id(manifest: &Value) -> RusticolResult<String> {
+    let payloads = manifest
+        .get("payloads")
+        .and_then(Value::as_array)
+        .ok_or_else(|| RusticolError::artifact("payloads must be an array"))?;
+    let mut runtime_records = Vec::new();
+    for (index, payload) in payloads.iter().enumerate() {
+        let role = payload.get("role").and_then(Value::as_str).ok_or_else(|| {
+            RusticolError::artifact(format!("payloads[{index}].role must be a non-empty string"))
+        })?;
+        if RUNTIME_IDENTITY_PAYLOAD_ROLES.contains(&role) {
+            runtime_records.push(payload.clone());
+        }
+    }
+    runtime_records.sort_by(|left, right| {
+        left.get("path")
+            .and_then(Value::as_str)
+            .unwrap_or_default()
+            .cmp(
+                right
+                    .get("path")
+                    .and_then(Value::as_str)
+                    .unwrap_or_default(),
+            )
+    });
+    let content = serde_json::json!({
+        "kind": "pyamplicol-runtime-payload-identity",
+        "schema_version": 1,
+        "payloads": runtime_records,
+    });
+    let mut canonical = String::new();
+    write_python_canonical_json(&content, &mut canonical)?;
+    canonical.push('\n');
+    Ok(format!("{:x}", Sha256::digest(canonical.as_bytes())))
+}
+
+#[cfg(test)]
+fn write_python_canonical_json(value: &Value, output: &mut String) -> RusticolResult<()> {
+    match value {
+        Value::Null => output.push_str("null"),
+        Value::Bool(true) => output.push_str("true"),
+        Value::Bool(false) => output.push_str("false"),
+        Value::Number(number) => output.push_str(&python_number(number)),
+        Value::String(value) => write_python_json_string(value, output),
+        Value::Array(values) => {
+            output.push('[');
+            for (index, value) in values.iter().enumerate() {
+                if index != 0 {
+                    output.push(',');
+                }
+                write_python_canonical_json(value, output)?;
+            }
+            output.push(']');
+        }
+        Value::Object(values) => {
+            output.push('{');
+            let mut keys = values.keys().collect::<Vec<_>>();
+            keys.sort_unstable();
+            for (index, key) in keys.iter().enumerate() {
+                if index != 0 {
+                    output.push(',');
+                }
+                write_python_json_string(key, output);
+                output.push(':');
+                write_python_canonical_json(&values[*key], output)?;
+            }
+            output.push('}');
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+fn python_number(number: &serde_json::Number) -> String {
+    let rendered = number.to_string();
+    let Some((mantissa, exponent)) = rendered.split_once('e') else {
+        return rendered;
+    };
+    let (sign, digits) = if let Some(digits) = exponent.strip_prefix('-') {
+        ('-', digits)
+    } else if let Some(digits) = exponent.strip_prefix('+') {
+        ('+', digits)
+    } else {
+        ('+', exponent)
+    };
+    format!("{mantissa}e{sign}{digits:0>2}")
+}
+
+fn write_python_json_string(value: &str, output: &mut String) {
+    output.push('"');
+    for character in value.chars() {
+        match character {
+            '"' => output.push_str("\\\""),
+            '\\' => output.push_str("\\\\"),
+            '\u{0008}' => output.push_str("\\b"),
+            '\u{000c}' => output.push_str("\\f"),
+            '\n' => output.push_str("\\n"),
+            '\r' => output.push_str("\\r"),
+            '\t' => output.push_str("\\t"),
+            '\u{0020}'..='\u{007e}' => output.push(character),
+            character if u32::from(character) <= 0xffff => {
+                let _ = write!(output, "\\u{:04x}", u32::from(character));
+            }
+            character => {
+                let scalar = u32::from(character) - 0x1_0000;
+                let high = 0xd800 + (scalar >> 10);
+                let low = 0xdc00 + (scalar & 0x3ff);
+                let _ = write!(output, "\\u{high:04x}\\u{low:04x}");
+            }
+        }
+    }
+    output.push('"');
+}
+
+fn reject_forbidden_nulls(manifest: &Value) -> RusticolResult<()> {
+    if manifest
+        .get("runtime")
+        .and_then(Value::as_object)
+        .is_some_and(|runtime| !runtime.contains_key("api_bundle_path"))
+    {
+        return Err(RusticolError::artifact(
+            "runtime.api_bundle_path is required and must be a relative path or null",
+        ));
+    }
+    for (collection, keys) in [
+        ("payloads", &["target", "process_id"] as &[&str]),
+        (
+            "dependencies",
+            &["content_sha256", "revision", "patch_sha256"] as &[&str],
+        ),
+    ] {
+        let Some(items) = manifest.get(collection).and_then(Value::as_array) else {
+            continue;
+        };
+        for (index, item) in items.iter().enumerate() {
+            for key in keys {
+                if item.get(*key).is_some_and(Value::is_null) {
+                    return Err(RusticolError::artifact(format!(
+                        "{collection}[{index}].{key} may be omitted but may not be null"
+                    )));
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn locate_manifest(requested: &Path) -> RusticolResult<(PathBuf, PathBuf)> {
+    let metadata = fs::metadata(requested).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not inspect artifact path {}: {error}",
+            requested.display()
+        ))
+    })?;
+    if metadata.is_file() {
+        if requested.file_name().and_then(|name| name.to_str()) != Some(ARTIFACT_MANIFEST_FILE) {
+            return Err(RusticolError::artifact(format!(
+                "artifact manifest must be named {ARTIFACT_MANIFEST_FILE}"
+            )));
+        }
+        let manifest = requested.canonicalize().map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not resolve artifact manifest {}: {error}",
+                requested.display()
+            ))
+        })?;
+        let root = manifest.parent().ok_or_else(|| {
+            RusticolError::artifact("artifact manifest has no containing directory")
+        })?;
+        return Ok((root.to_path_buf(), manifest));
+    }
+    if !metadata.is_dir() {
+        return Err(RusticolError::security(format!(
+            "artifact path {} is neither a regular file nor a directory",
+            requested.display()
+        )));
+    }
+    let root = requested.canonicalize().map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not resolve artifact directory {}: {error}",
+            requested.display()
+        ))
+    })?;
+    let manifest = root.join(ARTIFACT_MANIFEST_FILE);
+    if manifest.exists() {
+        Ok((root, manifest))
+    } else {
+        Err(RusticolError::artifact(format!(
+            "artifact directory does not contain {ARTIFACT_MANIFEST_FILE}"
+        )))
+    }
+}
+
+fn validate_manifest(manifest: &ArtifactManifest) -> RusticolResult<()> {
+    validate_sha256(&manifest.artifact_id, "artifact_id")?;
+    validate_datetime(&manifest.created_utc)?;
+    validate_artifact_identity_extension(&manifest.extensions)?;
+    if manifest.producer.distribution != "pyamplicol" {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported artifact producer {:?}; expected pyamplicol",
+            manifest.producer.distribution
+        )));
+    }
+    if !compatible_distribution_version(&manifest.producer.version)
+        || !compatible_distribution_version(&manifest.runtime.engine_version)
+    {
+        return Err(RusticolError::compatibility(format!(
+            "artifact producer/runtime version {}/{} is incompatible with Rusticol {}",
+            manifest.producer.version,
+            manifest.runtime.engine_version,
+            rusticol_package_version()
+        )));
+    }
+    let versions = &manifest.producer.versions;
+    let expected = [
+        ("python API", versions.python_api, PYTHON_API_VERSION),
+        ("TOML", versions.toml, TOML_SCHEMA_VERSION),
+        (
+            "compiled model",
+            versions.compiled_model,
+            COMPILED_MODEL_SCHEMA_VERSION,
+        ),
+        (
+            "process artifact",
+            versions.process_artifact,
+            PROCESS_ARTIFACT_SCHEMA_VERSION,
+        ),
+        (
+            "runtime physics",
+            versions.runtime_physics,
+            RUNTIME_PHYSICS_SCHEMA_VERSION,
+        ),
+        ("C ABI", versions.c_abi, C_ABI_VERSION),
+    ];
+    for (name, found, required) in expected {
+        if found != required {
+            return Err(RusticolError::compatibility(format!(
+                "artifact {name} version {found} is incompatible with required version {required}; regenerate the artifact"
+            )));
+        }
+    }
+    if manifest.runtime.engine != "rusticol" {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported runtime engine {:?}",
+            manifest.runtime.engine
+        )));
+    }
+    validate_target(&manifest.producer.target, "producer")?;
+    for payload in &manifest.payloads {
+        if let Some(target) = &payload.target {
+            validate_payload_target(&manifest.producer.target, target, &payload.path)?;
+            validate_target(target, &format!("payload {}", payload.path))?;
+        }
+    }
+    if let Some(revision) = &manifest.producer.git_revision
+        && (revision.len() != 40
+            || !revision
+                .bytes()
+                .all(|byte| byte.is_ascii_hexdigit() && !byte.is_ascii_uppercase()))
+    {
+        return Err(RusticolError::artifact(
+            "producer.git_revision must be 40 lowercase hexadecimal characters",
+        ));
+    }
+    if let Some(native_inputs) = &manifest.producer.native_build_inputs_sha256 {
+        validate_sha256(native_inputs, "producer.native_build_inputs_sha256")?;
+    }
+    validate_sha256(&manifest.model.content_sha256, "model content_sha256")?;
+    if manifest.model.name.is_empty()
+        || manifest
+            .model
+            .restriction
+            .as_ref()
+            .is_some_and(String::is_empty)
+    {
+        return Err(RusticolError::artifact(
+            "model name and any model restriction must be non-empty",
+        ));
+    }
+    if manifest.model.compiled_schema_version != COMPILED_MODEL_SCHEMA_VERSION {
+        return Err(RusticolError::compatibility(format!(
+            "compiled model schema {} is incompatible with required schema {}",
+            manifest.model.compiled_schema_version, COMPILED_MODEL_SCHEMA_VERSION
+        )));
+    }
+    if manifest.configuration.toml_schema_version != TOML_SCHEMA_VERSION {
+        return Err(RusticolError::compatibility(format!(
+            "configuration TOML schema {} is incompatible with required schema {}",
+            manifest.configuration.toml_schema_version, TOML_SCHEMA_VERSION
+        )));
+    }
+    validate_relative_path(
+        &manifest.configuration.requested_path,
+        "requested configuration path",
+    )?;
+    validate_relative_path(
+        &manifest.configuration.effective_path,
+        "effective configuration path",
+    )?;
+    for (index, adjustment) in manifest.configuration.adjustments.iter().enumerate() {
+        if adjustment.path.is_empty() || adjustment.reason.is_empty() {
+            return Err(RusticolError::artifact(format!(
+                "configuration adjustment {index} requires non-empty path and reason"
+            )));
+        }
+    }
+    validate_relative_path(
+        &manifest.runtime.evaluator_manifest_path,
+        "evaluator manifest path",
+    )?;
+    let runtime_capabilities = validate_runtime_capabilities(
+        &manifest.runtime.required_runtime_capabilities,
+        "runtime.required_runtime_capabilities",
+    )?;
+    if let Some(path) = &manifest.runtime.api_bundle_path {
+        validate_relative_path(path, "API bundle path")?;
+    }
+    if manifest.processes.is_empty() {
+        return Err(RusticolError::artifact(
+            "artifact must contain at least one process",
+        ));
+    }
+    match manifest.kind {
+        ArtifactKind::PyamplicolProcess if manifest.processes.len() != 1 => {
+            return Err(RusticolError::artifact(
+                "pyamplicol-process artifacts must contain exactly one process",
+            ));
+        }
+        _ => {}
+    }
+    let mut public_ids = BTreeSet::new();
+    let mut process_capabilities = BTreeSet::new();
+    for process in &manifest.processes {
+        validate_public_id(&process.id, "process id")?;
+        validate_relative_path(&process.physics_path, "runtime physics path")?;
+        let process_expression = parse_process_expression(&process.expression);
+        if process.expression.is_empty() || process.external_pdgs.len() < 3 {
+            return Err(RusticolError::artifact(format!(
+                "process {} has an empty expression or fewer than three external particles",
+                process.id
+            )));
+        }
+        let process_expression = process_expression.ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "process {:?} expression must contain one '>' with particles on both sides",
+                process.id
+            ))
+        })?;
+        if process_expression.initial.len() + process_expression.final_state.len()
+            != process.external_pdgs.len()
+        {
+            return Err(RusticolError::artifact(format!(
+                "process {:?} expression particle count does not match external_pdgs",
+                process.id
+            )));
+        }
+        if !matches!(process.color_accuracy.as_str(), "lc" | "nlc" | "full") {
+            return Err(RusticolError::artifact(format!(
+                "process {} has unsupported color accuracy {:?}",
+                process.id, process.color_accuracy
+            )));
+        }
+        process_capabilities.extend(validate_runtime_capabilities(
+            &process.required_runtime_capabilities,
+            &format!("process {:?}.required_runtime_capabilities", process.id),
+        )?);
+        if !public_ids.insert(&process.id) {
+            return Err(RusticolError::artifact(format!(
+                "duplicate public process id {:?}",
+                process.id
+            )));
+        }
+        for alias in &process.aliases {
+            validate_public_id(&alias.id, "process alias id")?;
+            if alias.expression.is_empty() || !public_ids.insert(&alias.id) {
+                return Err(RusticolError::artifact(format!(
+                    "duplicate or invalid process alias id {:?}",
+                    alias.id
+                )));
+            }
+            validate_permutation(
+                &alias.external_permutation,
+                process.external_pdgs.len(),
+                &format!("alias {:?}", alias.id),
+            )?;
+            let alias_expression =
+                parse_process_expression(&alias.expression).ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "alias {:?} expression must contain one '>' with particles on both sides",
+                        alias.id
+                    ))
+                })?;
+            if alias_expression.initial.len() != process_expression.initial.len()
+                || alias_expression.final_state.len() != process_expression.final_state.len()
+                || !permutation_preserves_process_sides(
+                    &alias.external_permutation,
+                    process_expression.initial.len(),
+                )
+            {
+                return Err(RusticolError::artifact(format!(
+                    "alias {:?} may only permute particles within the incoming and outgoing sides",
+                    alias.id
+                )));
+            }
+            let mut expected_external_pdgs = vec![0; process.external_pdgs.len()];
+            for (representative_index, alias_index) in
+                alias.external_permutation.iter().copied().enumerate()
+            {
+                expected_external_pdgs[alias_index] = process.external_pdgs[representative_index];
+            }
+            if alias.external_pdgs != expected_external_pdgs {
+                return Err(RusticolError::artifact(format!(
+                    "alias {:?} external_pdgs {:?} does not match external_permutation {:?}; expected {:?}",
+                    alias.id,
+                    alias.external_pdgs,
+                    alias.external_permutation,
+                    expected_external_pdgs,
+                )));
+            }
+        }
+    }
+    if runtime_capabilities != process_capabilities {
+        return Err(RusticolError::artifact(
+            "runtime.required_runtime_capabilities must equal the union of process capability declarations",
+        ));
+    }
+    validate_portable_runtime_capabilities(&manifest.producer.target, &runtime_capabilities)?;
+    if let Some(default) = &manifest.default_process_id
+        && !public_ids.contains(default)
+    {
+        return Err(RusticolError::artifact(format!(
+            "default process id {default:?} does not identify a process or alias"
+        )));
+    }
+    if manifest.payloads.is_empty() {
+        return Err(RusticolError::artifact(
+            "artifact must declare at least one payload",
+        ));
+    }
+    let mut dependencies = BTreeSet::new();
+    for dependency in &manifest.dependencies {
+        if dependency.name.is_empty()
+            || dependency.version.is_empty()
+            || dependency.source.is_empty()
+            || dependency.license.is_empty()
+            || !dependencies.insert(dependency.name.to_ascii_lowercase())
+        {
+            return Err(RusticolError::artifact(format!(
+                "invalid or duplicate dependency {:?}",
+                dependency.name
+            )));
+        }
+        for (name, value) in [
+            ("content_sha256", dependency.content_sha256.as_deref()),
+            ("patch_sha256", dependency.patch_sha256.as_deref()),
+        ] {
+            if let Some(value) = value {
+                validate_sha256(value, &format!("dependency {} {name}", dependency.name))?;
+            }
+        }
+        if dependency.revision.as_ref().is_some_and(String::is_empty) {
+            return Err(RusticolError::artifact(format!(
+                "dependency {} revision must be non-empty when present",
+                dependency.name
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_artifact_identity_extension(
+    extensions: &BTreeMap<String, Value>,
+) -> RusticolResult<()> {
+    let Some(policy) = extensions
+        .get(ARTIFACT_IDENTITY_EXTENSION)
+        .and_then(Value::as_object)
+    else {
+        return Err(RusticolError::compatibility(
+            "artifact predates the required runtime-payload identity contract; \
+             regenerate it with the current pyAmpliCol",
+        ));
+    };
+    let valid = policy.len() == 2
+        && policy.get("kind").and_then(Value::as_str) == Some(ARTIFACT_IDENTITY_KIND)
+        && policy.get("schema_version").and_then(Value::as_u64)
+            == Some(ARTIFACT_IDENTITY_SCHEMA_VERSION);
+    if !valid {
+        return Err(RusticolError::compatibility(
+            "artifact uses an unsupported artifact identity contract; \
+             regenerate it with the current pyAmpliCol",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_artifact_identity_header(manifest: &Value) -> RusticolResult<()> {
+    let Some(extensions) = manifest.get("extensions").and_then(Value::as_object) else {
+        return Err(RusticolError::compatibility(
+            "artifact predates the required runtime-payload identity contract; \
+             regenerate it with the current pyAmpliCol",
+        ));
+    };
+    let ordered = extensions
+        .iter()
+        .map(|(key, value)| (key.clone(), value.clone()))
+        .collect();
+    validate_artifact_identity_extension(&ordered)
+}
+
+fn compatible_distribution_version(version: &str) -> bool {
+    #[cfg(test)]
+    if std::env::var_os("RUSTICOL_TEST_ALLOW_VERSION_MISMATCH").is_some() {
+        return true;
+    }
+    canonical_distribution_version(version)
+        == canonical_distribution_version(rusticol_package_version())
+}
+
+fn canonical_distribution_version(version: &str) -> String {
+    let canonical = version.replace("-dev.", ".dev");
+    // Candidate build hashes identify native builds, not process formats.
+    // Explicit schema, ABI, and evaluator-storage versions are checked when
+    // loading the output; a runtime fix must not require process regeneration.
+    if let Some((base, fingerprint)) = canonical.split_once("+candidate.")
+        && base.contains(".dev")
+        && fingerprint.len() == 12
+        && fingerprint
+            .bytes()
+            .all(|byte| byte.is_ascii_hexdigit() && !byte.is_ascii_uppercase())
+    {
+        return base.to_owned();
+    }
+    canonical
+}
+
+fn validate_references(
+    manifest: &ArtifactManifest,
+    payloads: &BTreeMap<String, Payload>,
+) -> RusticolResult<()> {
+    let process_ids = manifest
+        .processes
+        .iter()
+        .map(|process| process.id.as_str())
+        .collect::<BTreeSet<_>>();
+    require_payload_role(
+        payloads,
+        &manifest.configuration.requested_path,
+        PayloadRole::ConfigurationRequested,
+        None,
+    )?;
+    require_payload_role(
+        payloads,
+        &manifest.configuration.effective_path,
+        PayloadRole::ConfigurationEffective,
+        None,
+    )?;
+    require_payload_role(
+        payloads,
+        &manifest.runtime.evaluator_manifest_path,
+        PayloadRole::EvaluatorManifest,
+        None,
+    )?;
+    for process in &manifest.processes {
+        require_payload_role(
+            payloads,
+            &process.physics_path,
+            PayloadRole::RuntimePhysics,
+            Some(&process.id),
+        )?;
+    }
+    for payload in payloads
+        .values()
+        .filter(|payload| payload.role == PayloadRole::StructuralSourceProof)
+    {
+        if let Some(process_id) = payload.process_id.as_deref()
+            && !process_ids.contains(process_id)
+        {
+            return Err(RusticolError::artifact(format!(
+                "structural-source-proof payload {:?} belongs to unknown process {process_id:?}",
+                payload.path
+            )));
+        }
+    }
+    if let Some(api_path) = &manifest.runtime.api_bundle_path {
+        let prefix = format!("{}/", api_path.trim_end_matches('/'));
+        if !payloads.keys().any(|path| path.starts_with(&prefix)) {
+            return Err(RusticolError::artifact(format!(
+                "API bundle path {api_path:?} contains no declared payload"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn require_payload_role(
+    payloads: &BTreeMap<String, Payload>,
+    path: &str,
+    role: PayloadRole,
+    process_id: Option<&str>,
+) -> RusticolResult<()> {
+    let payload = payloads.get(path).ok_or_else(|| {
+        RusticolError::security(format!(
+            "referenced artifact path {path:?} is not a declared payload"
+        ))
+    })?;
+    if payload.role != role {
+        return Err(RusticolError::security(format!(
+            "referenced payload {path:?} has role {:?}, expected {:?}",
+            payload.role, role
+        )));
+    }
+    if let (Some(expected), Some(found)) = (process_id, payload.process_id.as_deref())
+        && expected != found
+    {
+        return Err(RusticolError::artifact(format!(
+            "payload {path:?} belongs to process {found:?}, expected {expected:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn metadata_is_executable(metadata: &fs::Metadata) -> bool {
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        metadata.permissions().mode() & 0o111 != 0
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = metadata;
+        false
+    }
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn read_declared_payload(root: &Path, payload: &Payload) -> RusticolResult<Vec<u8>> {
+    validate_payload_declaration(payload)?;
+    let mut file = open_checked_payload(root, payload)?;
+    let expected_size = usize::try_from(payload.size_bytes).map_err(|_| {
+        RusticolError::artifact(format!(
+            "payload {:?} is too large for this platform",
+            payload.path
+        ))
+    })?;
+    let mut bytes = Vec::new();
+    bytes.try_reserve_exact(expected_size).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not allocate {} bytes for payload {:?}: {error}",
+            payload.size_bytes, payload.path
+        ))
+    })?;
+    file.read_to_end(&mut bytes).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not read payload {:?}: {error}",
+            payload.path
+        ))
+    })?;
+    if bytes.len() != expected_size {
+        return Err(RusticolError::integrity(format!(
+            "payload {:?} changed while being read: expected {} bytes, read {}",
+            payload.path,
+            payload.size_bytes,
+            bytes.len()
+        )));
+    }
+    Ok(bytes)
+}
+
+fn validate_payload_declaration(payload: &Payload) -> RusticolResult<()> {
+    validate_sha256(&payload.sha256, &format!("payload {} sha256", payload.path))?;
+    if payload.media_type.is_empty() {
+        return Err(RusticolError::artifact(format!(
+            "payload {:?} has an empty media type",
+            payload.path
+        )));
+    }
+    if let Some(process_id) = &payload.process_id {
+        validate_public_id(process_id, "payload process id")?;
+    }
+    if payload.role == PayloadRole::EvaluatorState && payload.target.is_none() {
+        return Err(RusticolError::artifact(format!(
+            "evaluator-state payload {:?} is missing required target metadata",
+            payload.path
+        )));
+    }
+    if payload.role == PayloadRole::StructuralSourceProof {
+        let process_id = payload.process_id.as_deref().ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "structural-source-proof payload {:?} is missing required process id",
+                payload.path
+            ))
+        })?;
+        let expected_path = format!("processes/{process_id}/structural-source-proof.json");
+        if payload.path != expected_path {
+            return Err(RusticolError::artifact(format!(
+                "structural-source-proof payload {:?} must use exact path {expected_path:?}",
+                payload.path
+            )));
+        }
+        if payload.media_type != "application/json" {
+            return Err(RusticolError::artifact(format!(
+                "structural-source-proof payload {:?} must use media type application/json",
+                payload.path
+            )));
+        }
+        if payload.target.is_some() {
+            return Err(RusticolError::artifact(format!(
+                "structural-source-proof payload {:?} may not declare target metadata",
+                payload.path
+            )));
+        }
+    }
+    if payload.executable
+        && !matches!(
+            payload.role,
+            PayloadRole::EvaluatorState | PayloadRole::ApiSource | PayloadRole::ApiBuildFile
+        )
+    {
+        return Err(RusticolError::security(format!(
+            "payload {:?} has role {:?}, which may not be executable",
+            payload.path, payload.role
+        )));
+    }
+    Ok(())
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn open_checked_payload(root: &Path, payload: &Payload) -> RusticolResult<File> {
+    let path = root.join(&payload.path);
+    reject_symlink_chain(&path)?;
+    let canonical = path.canonicalize().map_err(|error| {
+        RusticolError::security(format!(
+            "could not resolve payload {:?}: {error}",
+            payload.path
+        ))
+    })?;
+    if !canonical.starts_with(root) {
+        return Err(RusticolError::security(format!(
+            "payload {:?} escapes the artifact root",
+            payload.path
+        )));
+    }
+    #[cfg(unix)]
+    let file = {
+        use std::os::unix::fs::OpenOptionsExt as _;
+        OpenOptions::new()
+            .read(true)
+            .custom_flags(libc::O_CLOEXEC | libc::O_NOFOLLOW)
+            .open(&path)
+    };
+    #[cfg(not(unix))]
+    let file = OpenOptions::new().read(true).open(&path);
+    let file = file.map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not open payload {:?}: {error}",
+            payload.path
+        ))
+    })?;
+    let metadata = file.metadata().map_err(|error| {
+        RusticolError::security(format!(
+            "could not inspect payload {:?}: {error}",
+            payload.path
+        ))
+    })?;
+    if !metadata.is_file() {
+        return Err(RusticolError::security(format!(
+            "payload {:?} is not a regular file",
+            payload.path
+        )));
+    }
+    if metadata.len() != payload.size_bytes {
+        return Err(RusticolError::integrity(format!(
+            "payload {:?} has size {}, expected {}",
+            payload.path,
+            metadata.len(),
+            payload.size_bytes
+        )));
+    }
+    #[cfg(unix)]
+    {
+        let executable = metadata_is_executable(&metadata);
+        if executable != payload.executable {
+            return Err(RusticolError::security(format!(
+                "payload {:?} executable mode is {}, but the manifest declares {}",
+                payload.path, executable, payload.executable
+            )));
+        }
+    }
+    reject_symlink_chain(&path)?;
+    let path_metadata = fs::symlink_metadata(&path).map_err(|error| {
+        RusticolError::security(format!(
+            "could not re-inspect payload {:?}: {error}",
+            payload.path
+        ))
+    })?;
+    if path_metadata.file_type().is_symlink() || !path_metadata.file_type().is_file() {
+        return Err(RusticolError::security(format!(
+            "payload {:?} is not a regular non-symlink file",
+            payload.path
+        )));
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt as _;
+        if metadata.dev() != path_metadata.dev() || metadata.ino() != path_metadata.ino() {
+            return Err(RusticolError::security(format!(
+                "payload {:?} was replaced while being opened",
+                payload.path
+            )));
+        }
+    }
+    Ok(file)
+}
+
+fn validate_relative_path(value: &str, description: &str) -> RusticolResult<()> {
+    if value.is_empty()
+        || value.starts_with('/')
+        || value.ends_with('/')
+        || value.contains('\\')
+        || value.contains('\0')
+        || value
+            .split('/')
+            .any(|part| part.is_empty() || part == "." || part == "..")
+        || Path::new(value).is_absolute()
+    {
+        return Err(RusticolError::security(format!(
+            "{description} {value:?} is not a normalized confined relative path"
+        )));
+    }
+    Ok(())
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn reject_symlink_chain(path: &Path) -> RusticolResult<()> {
+    let mut ancestors = path.ancestors().collect::<Vec<_>>();
+    ancestors.reverse();
+    for ancestor in ancestors {
+        let Ok(metadata) = fs::symlink_metadata(ancestor) else {
+            continue;
+        };
+        if metadata.file_type().is_symlink() {
+            return Err(RusticolError::security(format!(
+                "artifact path {} contains a symlink at {}",
+                path.display(),
+                ancestor.display()
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_sha256(value: &str, description: &str) -> RusticolResult<()> {
+    if value.len() != 64
+        || !value
+            .bytes()
+            .all(|byte| byte.is_ascii_hexdigit() && !byte.is_ascii_uppercase())
+    {
+        return Err(RusticolError::artifact(format!(
+            "{description} must be 64 lowercase hexadecimal characters"
+        )));
+    }
+    Ok(())
+}
+
+fn parse_sha256(value: &str, description: &str) -> RusticolResult<[u8; 32]> {
+    validate_sha256(value, description)?;
+    let mut digest = [0_u8; 32];
+    for (index, pair) in value.as_bytes().chunks_exact(2).enumerate() {
+        digest[index] = (hex_nibble(pair[0]) << 4) | hex_nibble(pair[1]);
+    }
+    Ok(digest)
+}
+
+fn hex_nibble(value: u8) -> u8 {
+    match value {
+        b'0'..=b'9' => value - b'0',
+        b'a'..=b'f' => value - b'a' + 10,
+        _ => unreachable!("SHA-256 validation precedes hexadecimal decoding"),
+    }
+}
+
+fn validate_public_id(value: &str, description: &str) -> RusticolResult<()> {
+    let valid = !value.is_empty()
+        && value.len() <= 255
+        && value.bytes().enumerate().all(|(index, byte)| {
+            byte.is_ascii_alphanumeric()
+                || (index > 0 && matches!(byte, b'.' | b'_' | b':' | b'+' | b',' | b'~' | b'-'))
+        });
+    if !valid {
+        return Err(RusticolError::artifact(format!(
+            "invalid {description} {value:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_datetime(value: &str) -> RusticolResult<()> {
+    let bytes = value.as_bytes();
+    let digits = |start: usize, length: usize| -> Option<u32> {
+        let slice = bytes.get(start..start + length)?;
+        if !slice.iter().all(u8::is_ascii_digit) {
+            return None;
+        }
+        slice.iter().try_fold(0_u32, |value, digit| {
+            value.checked_mul(10)?.checked_add(u32::from(*digit - b'0'))
+        })
+    };
+    let year = digits(0, 4);
+    let month = digits(5, 2);
+    let day = digits(8, 2);
+    let hour = digits(11, 2);
+    let minute = digits(14, 2);
+    let second = digits(17, 2);
+    let date_valid = match (year, month, day) {
+        (Some(year), Some(month @ 1..=12), Some(day)) => {
+            let leap = year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
+            let maximum = match month {
+                2 if leap => 29,
+                2 => 28,
+                4 | 6 | 9 | 11 => 30,
+                _ => 31,
+            };
+            (1..=maximum).contains(&day)
+        }
+        _ => false,
+    };
+    let time_valid = matches!(hour, Some(0..=23))
+        && matches!(minute, Some(0..=59))
+        && matches!(second, Some(0..=60));
+    let separators_valid = bytes.get(4) == Some(&b'-')
+        && bytes.get(7) == Some(&b'-')
+        && matches!(bytes.get(10), Some(b'T' | b't'))
+        && bytes.get(13) == Some(&b':')
+        && bytes.get(16) == Some(&b':');
+    let mut offset = 19;
+    if bytes.get(offset) == Some(&b'.') {
+        offset += 1;
+        let fractional_start = offset;
+        while bytes.get(offset).is_some_and(u8::is_ascii_digit) {
+            offset += 1;
+        }
+        if offset == fractional_start {
+            offset = bytes.len() + 1;
+        }
+    }
+    let zone_valid = match bytes.get(offset) {
+        Some(b'Z' | b'z') => offset + 1 == bytes.len(),
+        Some(b'+' | b'-') => {
+            offset + 6 == bytes.len()
+                && bytes.get(offset + 3) == Some(&b':')
+                && matches!(digits(offset + 1, 2), Some(0..=23))
+                && matches!(digits(offset + 4, 2), Some(0..=59))
+        }
+        _ => false,
+    };
+    let valid = bytes.len() >= 20 && date_valid && time_valid && separators_valid && zone_valid;
+    if !valid {
+        return Err(RusticolError::artifact(format!(
+            "created_utc {value:?} is not an RFC 3339 date-time"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_permutation(values: &[usize], size: usize, owner: &str) -> RusticolResult<()> {
+    if values.len() != size {
+        return Err(RusticolError::artifact(format!(
+            "{owner} permutation has length {}, expected {size}",
+            values.len()
+        )));
+    }
+    let found = values.iter().copied().collect::<BTreeSet<_>>();
+    let expected = (0..size).collect::<BTreeSet<_>>();
+    if found != expected {
+        return Err(RusticolError::artifact(format!(
+            "{owner} permutation is not a complete zero-based permutation"
+        )));
+    }
+    Ok(())
+}
+
+fn permutation_preserves_process_sides(values: &[usize], initial_count: usize) -> bool {
+    values
+        .iter()
+        .copied()
+        .enumerate()
+        .all(|(representative_index, public_index)| {
+            (representative_index < initial_count) == (public_index < initial_count)
+        })
+}
+
+fn validate_runtime_capabilities(
+    values: &[String],
+    description: &str,
+) -> RusticolResult<BTreeSet<String>> {
+    if values.is_empty() {
+        return Err(RusticolError::artifact(format!(
+            "{description} must contain at least one capability"
+        )));
+    }
+    let capabilities = values.iter().cloned().collect::<BTreeSet<_>>();
+    if capabilities.len() != values.len() {
+        return Err(RusticolError::artifact(format!(
+            "{description} must not contain duplicates"
+        )));
+    }
+    if values.windows(2).any(|pair| pair[0] >= pair[1]) {
+        return Err(RusticolError::artifact(format!(
+            "{description} must be sorted"
+        )));
+    }
+    let known = [
+        RuntimeCapability::CompiledColorContractionWalshC2kV1,
+        RuntimeCapability::CompiledColorContractionWalshV1,
+        RuntimeCapability::CompiledColorTopologyLanesV1,
+        RuntimeCapability::CompiledHelicityDualLaneV1,
+        RuntimeCapability::CompiledHelicityPrimaryRecurrenceV1,
+        RuntimeCapability::CompiledHelicitySelectorUnionV1,
+        RuntimeCapability::CompiledPlaneArenaV1,
+        RuntimeCapability::CompiledRuntimeSelectorsV1,
+        RuntimeCapability::EagerDagComplexF64V1,
+        RuntimeCapability::EagerDirectArenaV1,
+        RuntimeCapability::EagerRuntimeLayoutComplexF64V1,
+        RuntimeCapability::EagerLcTopologyReplayComplexF64V1,
+        RuntimeCapability::RecurrenceRuntimeComplexF64V1,
+        RuntimeCapability::RecurrenceLcColorV1,
+        RuntimeCapability::RecurrenceContractedColorV1,
+        RuntimeCapability::RecurrenceHelicitySelectorCompanionV2,
+        RuntimeCapability::SymmetricGroupFftColorContractionV1,
+        RuntimeCapability::OnTheFlyRuntimeComplexF64V1,
+        RuntimeCapability::OnTheFlyContractedColorV1,
+        RuntimeCapability::OnTheFlyLcColorV1,
+        RuntimeCapability::SymjitApplicationComplexF64V1,
+        RuntimeCapability::SymbolicaLegacyJitContainerComplexF64V1,
+        RuntimeCapability::SymbolicaCompiledCppComplexF64V1,
+        RuntimeCapability::SymbolicaCompiledAsmComplexF64V1,
+    ]
+    .map(RuntimeCapability::as_str)
+    .into_iter()
+    .collect::<BTreeSet<_>>();
+    let unknown = capabilities
+        .iter()
+        .filter(|capability| !known.contains(capability.as_str()))
+        .cloned()
+        .collect::<Vec<_>>();
+    if !unknown.is_empty() {
+        return Err(RusticolError::artifact(format!(
+            "{description} contains unsupported capabilities: {}",
+            unknown.join(", ")
+        )));
+    }
+    Ok(capabilities)
+}
+
+fn validate_target(target: &Target, description: &str) -> RusticolResult<()> {
+    let current = current_target_triple();
+    if !SUPPORTED_ARTIFACT_TARGETS.contains(&current) {
+        return Err(RusticolError::compatibility(format!(
+            "Rusticol process artifacts are not supported on runtime target {current:?}"
+        )));
+    }
+    let required = normalized_cpu_features(target, description)?;
+    if target.triple == PORTABLE_64LE_ARTIFACT_TARGET {
+        if usize::BITS != 64 || !cfg!(target_endian = "little") {
+            return Err(RusticolError::compatibility(format!(
+                "{description} target {PORTABLE_64LE_ARTIFACT_TARGET:?} requires a 64-bit little-endian runtime"
+            )));
+        }
+        if !required.is_empty() {
+            return Err(RusticolError::compatibility(format!(
+                "{description} target {PORTABLE_64LE_ARTIFACT_TARGET:?} must not require CPU features"
+            )));
+        }
+        return Ok(());
+    }
+    if target.triple != current {
+        return Err(RusticolError::compatibility(format!(
+            "{description} target {:?} is incompatible with runtime target {current:?}",
+            target.triple
+        )));
+    }
+    let available = detected_cpu_features().into_iter().collect::<BTreeSet<_>>();
+    let unavailable = required.difference(&available).cloned().collect::<Vec<_>>();
+    if !unavailable.is_empty() {
+        return Err(RusticolError::compatibility(format!(
+            "{description} requires unavailable CPU features {unavailable:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_portable_runtime_capabilities(
+    target: &Target,
+    capabilities: &BTreeSet<String>,
+) -> RusticolResult<()> {
+    if target.triple != PORTABLE_64LE_ARTIFACT_TARGET {
+        return Ok(());
+    }
+    let forbidden = [
+        RuntimeCapability::SymbolicaLegacyJitContainerComplexF64V1.as_str(),
+        RuntimeCapability::SymbolicaCompiledCppComplexF64V1.as_str(),
+        RuntimeCapability::SymbolicaCompiledAsmComplexF64V1.as_str(),
+    ];
+    if forbidden
+        .iter()
+        .any(|capability| capabilities.contains(*capability))
+    {
+        return Err(RusticolError::compatibility(
+            "portable-64le process artifacts cannot contain C++, ASM, or legacy JIT evaluators; those evaluator families remain target-specific",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_payload_target(
+    producer: &Target,
+    payload: &Target,
+    payload_path: &str,
+) -> RusticolResult<()> {
+    if payload.triple != producer.triple {
+        return Err(RusticolError::compatibility(format!(
+            "payload {payload_path:?} target {:?} does not match producer target {:?}",
+            payload.triple, producer.triple
+        )));
+    }
+    let producer_features = normalized_cpu_features(producer, "producer")?;
+    let payload_features = normalized_cpu_features(payload, &format!("payload {payload_path}"))?;
+    if payload_features != producer_features {
+        return Err(RusticolError::compatibility(format!(
+            "payload {payload_path:?} CPU features {payload_features:?} do not match producer CPU features {producer_features:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn normalized_cpu_features(target: &Target, description: &str) -> RusticolResult<BTreeSet<String>> {
+    let mut features = BTreeSet::new();
+    let mut previous: Option<&str> = None;
+    for feature in &target.cpu_features {
+        let canonical = !feature.is_empty()
+            && feature.bytes().enumerate().all(|(index, byte)| {
+                byte.is_ascii_lowercase()
+                    || byte.is_ascii_digit()
+                    || (index > 0 && matches!(byte, b'.' | b'-'))
+            });
+        if !canonical {
+            return Err(RusticolError::artifact(format!(
+                "{description} target CPU feature {feature:?} is not a canonical feature ID"
+            )));
+        }
+        if previous.is_some_and(|value| value >= feature.as_str()) {
+            return Err(RusticolError::artifact(format!(
+                "{description} target CPU features must be sorted and unique"
+            )));
+        }
+        previous = Some(feature);
+        features.insert(feature.clone());
+    }
+    Ok(features)
+}
+
+/// Return the current Rusticol target and every CPU feature it can verify at runtime.
+///
+/// An empty feature list on an artifact means the architecture's baseline ISA. Native
+/// evaluator producers use this detected, canonical list as a conservative requirement.
+pub fn runtime_target_info() -> Target {
+    Target {
+        triple: current_target_triple().to_string(),
+        cpu_features: detected_cpu_features(),
+    }
+}
+
+fn current_target_triple() -> &'static str {
+    #[cfg(all(target_arch = "aarch64", target_os = "macos"))]
+    {
+        "aarch64-apple-darwin"
+    }
+    #[cfg(all(target_arch = "x86_64", target_os = "macos"))]
+    {
+        "x86_64-apple-darwin"
+    }
+    #[cfg(all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"))]
+    {
+        "x86_64-unknown-linux-gnu"
+    }
+    #[cfg(not(any(
+        all(target_arch = "aarch64", target_os = "macos"),
+        all(target_arch = "x86_64", target_os = "macos"),
+        all(target_arch = "x86_64", target_os = "linux", target_env = "gnu")
+    )))]
+    {
+        "unsupported-target"
+    }
+}
+
+fn detected_cpu_features() -> Vec<String> {
+    let mut features = Vec::new();
+    #[cfg(target_arch = "x86_64")]
+    {
+        let detected = [
+            ("adx", std::is_x86_feature_detected!("adx")),
+            ("aes", std::is_x86_feature_detected!("aes")),
+            ("avx", std::is_x86_feature_detected!("avx")),
+            ("avx2", std::is_x86_feature_detected!("avx2")),
+            ("avx512bf16", std::is_x86_feature_detected!("avx512bf16")),
+            (
+                "avx512bitalg",
+                std::is_x86_feature_detected!("avx512bitalg"),
+            ),
+            ("avx512bw", std::is_x86_feature_detected!("avx512bw")),
+            ("avx512cd", std::is_x86_feature_detected!("avx512cd")),
+            ("avx512dq", std::is_x86_feature_detected!("avx512dq")),
+            ("avx512f", std::is_x86_feature_detected!("avx512f")),
+            ("avx512ifma", std::is_x86_feature_detected!("avx512ifma")),
+            ("avx512vbmi", std::is_x86_feature_detected!("avx512vbmi")),
+            ("avx512vbmi2", std::is_x86_feature_detected!("avx512vbmi2")),
+            ("avx512vl", std::is_x86_feature_detected!("avx512vl")),
+            ("avx512vnni", std::is_x86_feature_detected!("avx512vnni")),
+            (
+                "avx512vpopcntdq",
+                std::is_x86_feature_detected!("avx512vpopcntdq"),
+            ),
+            ("bmi1", std::is_x86_feature_detected!("bmi1")),
+            ("bmi2", std::is_x86_feature_detected!("bmi2")),
+            ("cmpxchg16b", std::is_x86_feature_detected!("cmpxchg16b")),
+            ("f16c", std::is_x86_feature_detected!("f16c")),
+            ("fma", std::is_x86_feature_detected!("fma")),
+            ("fxsr", std::is_x86_feature_detected!("fxsr")),
+            ("gfni", std::is_x86_feature_detected!("gfni")),
+            ("lzcnt", std::is_x86_feature_detected!("lzcnt")),
+            ("movbe", std::is_x86_feature_detected!("movbe")),
+            ("pclmulqdq", std::is_x86_feature_detected!("pclmulqdq")),
+            ("popcnt", std::is_x86_feature_detected!("popcnt")),
+            ("rdrand", std::is_x86_feature_detected!("rdrand")),
+            ("rdseed", std::is_x86_feature_detected!("rdseed")),
+            ("rtm", std::is_x86_feature_detected!("rtm")),
+            ("sha", std::is_x86_feature_detected!("sha")),
+            ("sse", std::is_x86_feature_detected!("sse")),
+            ("sse2", std::is_x86_feature_detected!("sse2")),
+            ("sse3", std::is_x86_feature_detected!("sse3")),
+            ("sse4.1", std::is_x86_feature_detected!("sse4.1")),
+            ("sse4.2", std::is_x86_feature_detected!("sse4.2")),
+            ("ssse3", std::is_x86_feature_detected!("ssse3")),
+            ("vaes", std::is_x86_feature_detected!("vaes")),
+            ("vpclmulqdq", std::is_x86_feature_detected!("vpclmulqdq")),
+            ("xsave", std::is_x86_feature_detected!("xsave")),
+            ("xsavec", std::is_x86_feature_detected!("xsavec")),
+            ("xsaveopt", std::is_x86_feature_detected!("xsaveopt")),
+            ("xsaves", std::is_x86_feature_detected!("xsaves")),
+        ];
+        features.extend(
+            detected
+                .into_iter()
+                .filter(|(_, available)| *available)
+                .map(|(name, _)| name.to_string()),
+        );
+    }
+    #[cfg(target_arch = "aarch64")]
+    {
+        let detected = [
+            ("aes", std::arch::is_aarch64_feature_detected!("aes")),
+            ("bf16", std::arch::is_aarch64_feature_detected!("bf16")),
+            ("bti", std::arch::is_aarch64_feature_detected!("bti")),
+            ("crc", std::arch::is_aarch64_feature_detected!("crc")),
+            ("dit", std::arch::is_aarch64_feature_detected!("dit")),
+            (
+                "dotprod",
+                std::arch::is_aarch64_feature_detected!("dotprod"),
+            ),
+            ("dpb", std::arch::is_aarch64_feature_detected!("dpb")),
+            ("dpb2", std::arch::is_aarch64_feature_detected!("dpb2")),
+            ("f32mm", std::arch::is_aarch64_feature_detected!("f32mm")),
+            ("f64mm", std::arch::is_aarch64_feature_detected!("f64mm")),
+            ("fcma", std::arch::is_aarch64_feature_detected!("fcma")),
+            ("fhm", std::arch::is_aarch64_feature_detected!("fhm")),
+            ("flagm", std::arch::is_aarch64_feature_detected!("flagm")),
+            ("fp", std::arch::is_aarch64_feature_detected!("fp")),
+            ("fp16", std::arch::is_aarch64_feature_detected!("fp16")),
+            (
+                "frintts",
+                std::arch::is_aarch64_feature_detected!("frintts"),
+            ),
+            ("i8mm", std::arch::is_aarch64_feature_detected!("i8mm")),
+            ("jsconv", std::arch::is_aarch64_feature_detected!("jsconv")),
+            ("lse", std::arch::is_aarch64_feature_detected!("lse")),
+            ("lse2", std::arch::is_aarch64_feature_detected!("lse2")),
+            ("mte", std::arch::is_aarch64_feature_detected!("mte")),
+            ("neon", std::arch::is_aarch64_feature_detected!("neon")),
+            ("paca", std::arch::is_aarch64_feature_detected!("paca")),
+            ("pacg", std::arch::is_aarch64_feature_detected!("pacg")),
+            ("rand", std::arch::is_aarch64_feature_detected!("rand")),
+            ("rcpc", std::arch::is_aarch64_feature_detected!("rcpc")),
+            ("rcpc2", std::arch::is_aarch64_feature_detected!("rcpc2")),
+            ("rdm", std::arch::is_aarch64_feature_detected!("rdm")),
+            ("sb", std::arch::is_aarch64_feature_detected!("sb")),
+            ("sha2", std::arch::is_aarch64_feature_detected!("sha2")),
+            ("sha3", std::arch::is_aarch64_feature_detected!("sha3")),
+            ("sm4", std::arch::is_aarch64_feature_detected!("sm4")),
+            ("ssbs", std::arch::is_aarch64_feature_detected!("ssbs")),
+            ("sve", std::arch::is_aarch64_feature_detected!("sve")),
+            ("sve2", std::arch::is_aarch64_feature_detected!("sve2")),
+            (
+                "sve2-aes",
+                std::arch::is_aarch64_feature_detected!("sve2-aes"),
+            ),
+            (
+                "sve2-bitperm",
+                std::arch::is_aarch64_feature_detected!("sve2-bitperm"),
+            ),
+            (
+                "sve2-sha3",
+                std::arch::is_aarch64_feature_detected!("sve2-sha3"),
+            ),
+            (
+                "sve2-sm4",
+                std::arch::is_aarch64_feature_detected!("sve2-sm4"),
+            ),
+            ("tme", std::arch::is_aarch64_feature_detected!("tme")),
+        ];
+        features.extend(
+            detected
+                .into_iter()
+                .filter(|(_, available)| *available)
+                .map(|(name, _)| name.to_string()),
+        );
+    }
+    features.sort();
+    features
+}
+
+#[cfg(test)]
+#[path = "artifact_tests.rs"]
+pub(crate) mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/artifact_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/artifact_tests.rs
new file mode 100644
index 0000000000..2b852031ec
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/artifact_tests.rs
@@ -0,0 +1,3040 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::pacbin::{PacbinWriteMember, PacbinWriteOptions, write_pacbin_atomic};
+use serde_json::{Value, json};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+static TEST_ARTIFACT_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+#[test]
+fn walsh_color_contraction_is_a_known_artifact_capability() {
+    let capability = crate::engine::COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY.to_string();
+    let validated =
+        validate_runtime_capabilities(std::slice::from_ref(&capability), "test capabilities")
+            .expect("Walsh color-contraction capability");
+
+    assert_eq!(validated, BTreeSet::from([capability]));
+}
+
+#[test]
+fn c2k_walsh_color_contraction_is_a_known_artifact_capability() {
+    let capability = crate::engine::COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY.to_string();
+    let validated =
+        validate_runtime_capabilities(std::slice::from_ref(&capability), "test capabilities")
+            .expect("C2^k Walsh color-contraction capability");
+
+    assert_eq!(validated, BTreeSet::from([capability]));
+}
+
+#[test]
+fn compiled_plane_arena_is_a_known_artifact_capability() {
+    let capability = crate::engine::COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY.to_string();
+    let validated =
+        validate_runtime_capabilities(std::slice::from_ref(&capability), "test capabilities")
+            .expect("compiled plane-arena capability");
+
+    assert_eq!(validated, BTreeSet::from([capability]));
+}
+
+#[test]
+fn typed_compiled_color_member_is_required_and_kind_checked() {
+    let mut artifact = TestArtifact::new();
+    let destination = artifact.root.join("evaluators.pacbin");
+    let index = write_pacbin_atomic(
+        &destination,
+        vec![
+            PacbinWriteMember::from_bytes(
+                "processes/p0/compiled-color.pacrclr3",
+                PacbinMemberKind::ColorContraction,
+                b"color-payload",
+            )
+            .unwrap(),
+            PacbinWriteMember::from_bytes(
+                "processes/p0/wrong-kind.pacrclr3",
+                PacbinMemberKind::SymbolicaExactState,
+                b"wrong-kind",
+            )
+            .unwrap(),
+        ],
+        PacbinWriteOptions::default(),
+    )
+    .unwrap();
+    let container = fs::read(&destination).expect("read evaluator container");
+    add_test_payload(
+        &mut artifact,
+        "evaluators.pacbin",
+        "evaluator-state",
+        &container,
+        None,
+        true,
+    );
+    artifact.manifest["extensions"]["evaluator_payload_container"] = json!({
+        "kind": "pyamplicol-evaluator-payload-container",
+        "schema_version": 1,
+        "storage_abi": "pacbin-v1",
+        "path": "evaluators.pacbin",
+        "member_count": index.members().len(),
+        "unpacked_size_bytes": index.members().iter().map(|member| member.length()).sum::<u64>(),
+        "index_sha256": hex_digest(index.index_sha256()),
+    });
+    artifact.write_manifest();
+
+    let verified = VerifiedArtifact::open(&artifact.root).expect("typed color artifact");
+    let store = verified
+        .evaluator_payload_store(&artifact.root.join("processes/p0"))
+        .expect("process evaluator payload store");
+
+    assert_eq!(
+        store
+            .packed_member_bytes(
+                "compiled-color.pacrclr3",
+                PacbinMemberKind::ColorContraction,
+            )
+            .unwrap(),
+        b"color-payload",
+    );
+    let wrong_kind = store
+        .packed_member_bytes("wrong-kind.pacrclr3", PacbinMemberKind::ColorContraction)
+        .unwrap_err();
+    assert_eq!(wrong_kind.kind(), crate::RusticolErrorKind::Integrity);
+    assert!(wrong_kind.message().contains("member kind"));
+    let missing = store
+        .packed_member_bytes("missing.pacrclr3", PacbinMemberKind::ColorContraction)
+        .unwrap_err();
+    assert_eq!(missing.kind(), crate::RusticolErrorKind::InvalidArgument);
+    assert!(missing.message().contains("unknown pacbin member"));
+
+    let unpacked = EvaluatorPayloadStore::directory(&artifact.root);
+    let no_pack = unpacked
+        .packed_member_bytes(
+            "compiled-color.pacrclr3",
+            PacbinMemberKind::ColorContraction,
+        )
+        .unwrap_err();
+    assert_eq!(no_pack.kind(), crate::RusticolErrorKind::Compatibility);
+    assert!(no_pack.message().contains("requires evaluators.pacbin"));
+}
+
+#[cfg(feature = "f64-symjit")]
+const PYTHON_PACBIN_GOLDEN_HEX: &str = concat!(
+    "50414342494e000001004000000000004000000000000000c000000000000000",
+    "0200000000000000000000000000000000000000000000000000000000000000",
+    "6a69742d76310000000000000000000000000000000000000000000000000000",
+    "0000000000000000000000000000000000000000000000000000000000000000",
+    "65786163742d7374617465000000000000000000000000000000000000000000",
+    "0000000000000000000000000000000000000000000000000000000000000000",
+    "5041434944580000010020000000000002000000000000000000000000000000",
+    "0c0000000100000040000000000000000600000000000000e9a628134c31e4a5",
+    "7771ecd7a1dd51c5c5bc7daca10a2553c83f8af1652d2587612f6a69742e7379",
+    "6d6a6974000000000b0000000200000080000000000000000b00000000000000",
+    "a9f46d72eb6f1c7e5d62e97d3d8e67b80605aeba2df022a8a25b51ca3fc89805",
+    "7a2f65786163742e62696e0000000000504143454e4400000100400000000000",
+    "c0000000000000000200000000000000263b30eb85e5b2a82600201822438767",
+    "c5f66d9eecf2e08a0202383aafe0e3c1",
+);
+
+#[test]
+fn distribution_version_normalization_is_narrow() {
+    assert_eq!(
+        canonical_distribution_version("0.1.0-dev.0+candidate.0123"),
+        "0.1.0.dev0+candidate.0123"
+    );
+    assert_eq!(canonical_distribution_version("0.1.0"), "0.1.0");
+    assert_eq!(
+        canonical_distribution_version("0.2.1-dev.0+candidate.3112b2494ca7"),
+        canonical_distribution_version("0.2.1.dev0+candidate.42ec2237ad19")
+    );
+    for other in [
+        "0.2.1",
+        "0.2.2.dev0+candidate.3112b2494ca7",
+        "0.2.1.dev0+other.3112b2494ca7",
+    ] {
+        assert_ne!(
+            canonical_distribution_version("0.2.1.dev0+candidate.3112b2494ca7"),
+            canonical_distribution_version(other)
+        );
+    }
+    assert_ne!(
+        canonical_distribution_version("0.1.0-dev.0+candidate.0123"),
+        canonical_distribution_version("0.1.0-dev.0+candidate.4567")
+    );
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn compact_payload_identity_matches_the_python_canonical_contract() {
+    let artifact = TestArtifact::new();
+    let typed: ArtifactManifest =
+        serde_json::from_value(artifact.manifest.clone()).expect("typed artifact manifest");
+    assert_eq!(
+        compute_payload_artifact_id(&typed.payloads).expect("typed payload identity"),
+        artifact.manifest["artifact_id"]
+            .as_str()
+            .expect("manifest artifact ID")
+    );
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn default_recurrence_bootstrap_discovery_requires_exactly_one_stable_process() {
+    let artifact = TestArtifact::new();
+    let processes = artifact.root.join("processes");
+    fs::create_dir(&processes).expect("create process root");
+    assert_eq!(
+        discover_single_recurrence_bootstrap_process(&artifact.root).unwrap(),
+        None
+    );
+
+    let first = processes.join("p0");
+    fs::create_dir(&first).expect("create first process");
+    fs::write(first.join(RECURRENCE_BOOTSTRAP_FILENAME), b"image").expect("write first bootstrap");
+    assert_eq!(
+        discover_single_recurrence_bootstrap_process(&artifact.root).unwrap(),
+        Some("p0".to_string())
+    );
+
+    let second = processes.join("p1");
+    fs::create_dir(&second).expect("create second process");
+    fs::write(second.join(RECURRENCE_BOOTSTRAP_FILENAME), b"image")
+        .expect("write second bootstrap");
+    let error = discover_single_recurrence_bootstrap_process(&artifact.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("ambiguous"));
+}
+
+struct TestArtifact {
+    root: PathBuf,
+    manifest: Value,
+}
+
+impl TestArtifact {
+    fn new() -> Self {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("clock after epoch")
+            .as_nanos();
+        let temp_root = std::env::temp_dir()
+            .canonicalize()
+            .expect("canonical temporary directory");
+        let root = temp_root.join(format!(
+            "pyamplicol-rusticol-manifest-{}-{nonce}-{}",
+            std::process::id(),
+            TEST_ARTIFACT_COUNTER.fetch_add(1, Ordering::Relaxed)
+        ));
+        fs::create_dir(&root).expect("create test artifact");
+        let files = [
+            ("requested.toml", b"action = \"generate\"\n".as_slice()),
+            ("effective.toml", b"action = \"generate\"\n".as_slice()),
+            ("evaluator.json", b"{}".as_slice()),
+            ("physics.json", b"{}".as_slice()),
+        ];
+        let mut payloads = Vec::new();
+        for (path, bytes) in files {
+            fs::write(root.join(path), bytes).expect("write payload");
+            let role = match path {
+                "requested.toml" => "configuration-requested",
+                "effective.toml" => "configuration-effective",
+                "evaluator.json" => "evaluator-manifest",
+                "physics.json" => "runtime-physics",
+                _ => unreachable!(),
+            };
+            let mut payload = json!({
+                "path": path,
+                "role": role,
+                "media_type": "application/octet-stream",
+                "size_bytes": bytes.len(),
+                "sha256": sha256(bytes),
+                "executable": false,
+            });
+            if path == "physics.json" {
+                payload["process_id"] = json!("p0");
+            }
+            payloads.push(payload);
+        }
+        let manifest = json!({
+            "schema_version": 3,
+            "kind": "pyamplicol-process",
+            "artifact_id": "0".repeat(64),
+            "created_utc": "2026-07-15T00:00:00Z",
+            "producer": {
+                "distribution": "pyamplicol",
+                "version": env!("CARGO_PKG_VERSION"),
+                "versions": {
+                    "python_api": PYTHON_API_VERSION,
+                    "toml": TOML_SCHEMA_VERSION,
+                    "compiled_model": COMPILED_MODEL_SCHEMA_VERSION,
+                    "process_artifact": PROCESS_ARTIFACT_SCHEMA_VERSION,
+                    "runtime_physics": RUNTIME_PHYSICS_SCHEMA_VERSION,
+                    "symbolica_serialization": crate::SYMBOLICA_SERIALIZATION_ABI,
+                    "c_abi": C_ABI_VERSION,
+                },
+                "target": {"triple": current_target_triple(), "cpu_features": []},
+            },
+            "model": {
+                "name": "test-model",
+                "source_kind": "compiled-model",
+                "content_sha256": "1".repeat(64),
+                "compiled_schema_version": COMPILED_MODEL_SCHEMA_VERSION,
+            },
+            "configuration": {
+                "toml_schema_version": TOML_SCHEMA_VERSION,
+                "requested_path": "requested.toml",
+                "effective_path": "effective.toml",
+                "adjustments": [],
+            },
+            "processes": [{
+                "id": "p0",
+                "expression": "a b > c",
+                "color_accuracy": "lc",
+                "external_pdgs": [1, -1, 22],
+                "physics_path": "physics.json",
+                "required_runtime_capabilities": [
+                    "symjit.application.complex-f64.v1"
+                ],
+                "aliases": [],
+            }],
+            "default_process_id": "p0",
+            "runtime": {
+                "engine": "rusticol",
+                "engine_version": env!("CARGO_PKG_VERSION"),
+                "evaluator_manifest_path": "evaluator.json",
+                "required_runtime_capabilities": [
+                    "symjit.application.complex-f64.v1"
+                ],
+                "api_bundle_path": null,
+            },
+            "payloads": payloads,
+            "dependencies": [],
+            "extensions": {
+                "artifact_identity": {
+                    "kind": ARTIFACT_IDENTITY_KIND,
+                    "schema_version": ARTIFACT_IDENTITY_SCHEMA_VERSION,
+                },
+            },
+        });
+        let mut artifact = Self { root, manifest };
+        artifact.write_manifest();
+        artifact
+    }
+
+    fn write_manifest(&mut self) {
+        if self.manifest["schema_version"] == json!(PROCESS_ARTIFACT_SCHEMA_VERSION) {
+            self.manifest["artifact_id"] =
+                json!(compute_artifact_id(&self.manifest).expect("compute artifact identity"));
+        }
+        let mut bytes = String::new();
+        write_python_canonical_json(&self.manifest, &mut bytes)
+            .expect("serialize canonical manifest");
+        bytes.push('\n');
+        fs::write(self.root.join(ARTIFACT_MANIFEST_FILE), bytes).expect("write manifest");
+    }
+}
+
+impl Drop for TestArtifact {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.root);
+    }
+}
+
+fn sha256(bytes: &[u8]) -> String {
+    format!("{:x}", Sha256::digest(bytes))
+}
+
+fn add_structural_source_proof(artifact: &mut TestArtifact) {
+    let path = "processes/p0/structural-source-proof.json";
+    let bytes = br#"{"schema":"pyamplicol-generation-structural-source-proof-v1"}"#;
+    let output = artifact.root.join(path);
+    fs::create_dir_all(output.parent().expect("structural proof parent"))
+        .expect("create structural proof parent");
+    fs::write(output, bytes).expect("write structural proof");
+    artifact.manifest["payloads"]
+        .as_array_mut()
+        .expect("payload array")
+        .push(json!({
+            "path": path,
+            "role": "structural-source-proof",
+            "media_type": "application/json",
+            "size_bytes": bytes.len(),
+            "sha256": sha256(bytes),
+            "executable": false,
+            "process_id": "p0",
+        }));
+    artifact.write_manifest();
+}
+
+#[cfg(feature = "f64-symjit")]
+fn decode_hex(value: &str) -> Vec<u8> {
+    assert_eq!(value.len() % 2, 0);
+    value
+        .as_bytes()
+        .chunks_exact(2)
+        .map(|pair| {
+            let text = std::str::from_utf8(pair).expect("ASCII hex pair");
+            u8::from_str_radix(text, 16).expect("valid hex pair")
+        })
+        .collect()
+}
+
+fn add_test_payload(
+    artifact: &mut TestArtifact,
+    path: &str,
+    role: &str,
+    bytes: &[u8],
+    process_id: Option<&str>,
+    targeted: bool,
+) {
+    let output = artifact.root.join(path);
+    fs::create_dir_all(output.parent().expect("payload parent")).expect("create payload parent");
+    fs::write(&output, bytes).expect("write mixed-runtime payload");
+    let mut payload = json!({
+        "path": path,
+        "role": role,
+        "media_type": "application/octet-stream",
+        "size_bytes": bytes.len(),
+        "sha256": sha256(bytes),
+        "executable": false,
+    });
+    if let Some(process_id) = process_id {
+        payload["process_id"] = json!(process_id);
+    }
+    if targeted {
+        payload["target"] = json!({
+            "triple": current_target_triple(),
+            "cpu_features": [],
+        });
+    }
+    artifact.manifest["payloads"]
+        .as_array_mut()
+        .expect("payload array")
+        .push(payload);
+}
+
+#[cfg(feature = "f64-symjit")]
+fn replace_test_payload(artifact: &mut TestArtifact, path: &str, bytes: &[u8]) {
+    fs::write(artifact.root.join(path), bytes).expect("replace test payload");
+    let payload = artifact.manifest["payloads"]
+        .as_array_mut()
+        .expect("payload array")
+        .iter_mut()
+        .find(|payload| payload["path"] == path)
+        .expect("declared test payload");
+    payload["size_bytes"] = json!(bytes.len());
+    payload["sha256"] = json!(sha256(bytes));
+}
+
+#[cfg(feature = "f64-symjit")]
+fn add_test_evaluator_container(artifact: &mut TestArtifact) {
+    let bytes = decode_hex(PYTHON_PACBIN_GOLDEN_HEX);
+    add_test_payload(
+        artifact,
+        "evaluators.pacbin",
+        "evaluator-state",
+        &bytes,
+        None,
+        true,
+    );
+    artifact.manifest["extensions"]["evaluator_payload_container"] = json!({
+        "kind": "pyamplicol-evaluator-payload-container",
+        "schema_version": 1,
+        "storage_abi": "pacbin-v1",
+        "path": "evaluators.pacbin",
+        "member_count": 2,
+        "unpacked_size_bytes": 17,
+        "index_sha256": "263b30eb85e5b2a82600201822438767c5f66d9eecf2e08a0202383aafe0e3c1",
+    });
+    artifact.write_manifest();
+}
+
+#[cfg(feature = "f64-symjit")]
+const DIRECT_SYMJIT_PROGRAM: &str = r#"[[{"Add":[{"Out":0},[{"Param":0},{"Param":1}],0]}],1,[]]"#;
+
+#[cfg(feature = "f64-symjit")]
+fn direct_symjit_application_bytes(input_len: usize) -> Vec<u8> {
+    use symjit::{Compiler, CompilerType, Config, Storage};
+
+    let mut config = Config::new(CompilerType::Native, 0).expect("native SymJIT config");
+    config.set_complex(true);
+    config.set_symbolica(true);
+    config.set_opt_level(3);
+    config.set_simd(true);
+    let mut compiler = Compiler::with_config(config);
+    let application = compiler
+        .translate(DIRECT_SYMJIT_PROGRAM.to_string(), input_len)
+        .expect("translate direct SymJIT test application");
+    let mut bytes = Vec::new();
+    application
+        .save(&mut bytes)
+        .expect("serialize direct SymJIT test application");
+    bytes
+}
+
+#[cfg(feature = "f64-symjit")]
+fn direct_symjit_plane_application_bytes(input_len: usize) -> Vec<u8> {
+    crate::engine::compile_symbolica_program_to_plane_application_bytes(
+        DIRECT_SYMJIT_PROGRAM,
+        input_len,
+        1,
+        3,
+        false,
+    )
+    .expect("translate direct SymJIT test plane application")
+}
+
+#[cfg(feature = "f64-symjit")]
+pub(crate) fn minimal_runtime_physics(
+    process_id: &str,
+    process: &str,
+    final_particle: &str,
+) -> Value {
+    json!({
+        "schema_version": RUNTIME_PHYSICS_SCHEMA_VERSION,
+        "kind": "pyamplicol-resolved-physics",
+        "process_id": process_id,
+        "process": process,
+        "color_accuracy": "lc",
+        "coverage": {
+            "helicities": "complete",
+            "color": "complete",
+            "color_kind": "physical-lc-flows",
+            "structural_zero_helicity_count": 0,
+        },
+        "external_particles": [
+            {
+                "index": 0,
+                "label": 1,
+                "particle": "a",
+                "pdg": 1,
+                "role": "initial",
+                "momentum_slot": 0,
+                "momentum_components": ["E", "px", "py", "pz"],
+            },
+            {
+                "index": 1,
+                "label": 2,
+                "particle": "b",
+                "pdg": -1,
+                "role": "initial",
+                "momentum_slot": 1,
+                "momentum_components": ["E", "px", "py", "pz"],
+            },
+            {
+                "index": 2,
+                "label": 3,
+                "particle": final_particle,
+                "pdg": 22,
+                "role": "final",
+                "momentum_slot": 2,
+                "momentum_components": ["E", "px", "py", "pz"],
+            },
+        ],
+        "helicities": [{
+            "id": "h:+0,+0,+0",
+            "index": 0,
+            "values": [0, 0, 0],
+            "computed": true,
+            "structural_zero": false,
+            "representative_id": "h:+0,+0,+0",
+            "coefficient": 1.0,
+        }],
+        "color_components": [{
+            "kind": "lc-flow",
+            "id": "flow:singlet",
+            "index": 0,
+            "word": [],
+            "computed": true,
+            "representative_id": "flow:singlet",
+            "coefficient": 1.0,
+        }],
+        "reduction": {
+            "kind": "lc-diagonal",
+            "groups": [{
+                "id": "group:7",
+                "representative_helicity_id": "h:+0,+0,+0",
+                "representative_color_id": "flow:singlet",
+                "physical_helicity_ids": ["h:+0,+0,+0"],
+                "physical_color_ids": ["flow:singlet"],
+            }],
+        },
+        "model_parameters": [],
+        "selectors": {
+            "helicity": true,
+            "color_flow": true,
+            "contracted_color": false,
+        },
+        "extensions": {},
+    })
+}
+
+#[cfg(feature = "f64-symjit")]
+pub(crate) fn direct_evaluator_manifest(application_path: &str) -> Value {
+    json!({
+        "kind": "symjit-application-evaluator",
+        "runtime_capability": "symjit.application.complex-f64.v1",
+        "application_path": application_path,
+        "application_abi": crate::engine::SYMJIT_APPLICATION_STORAGE_ABI,
+        "input_len": 14,
+        "output_len": 1,
+        "element_layout": "complex-f64",
+        "batch_layout": "row-major",
+        "compiler_type": "native",
+        "translation_mode": "indirect",
+        "optimization_level": 3,
+        "word_bits": 64,
+        "endianness": "little",
+        "required_defuns": [],
+        "evaluator_state_path": null,
+        "evaluator_state_runtime_capability": null,
+    })
+}
+
+#[cfg(feature = "f64-symjit")]
+fn compiled_evaluator_manifest(library_path: &str, runtime_capability: &str) -> Value {
+    json!({
+        "kind": "compiled-complex-evaluator",
+        "runtime_capability": runtime_capability,
+        "function_name": "rusticol_test_evaluator",
+        "input_len": 14,
+        "output_len": 1,
+        "library_path": library_path,
+        "evaluator_state_path": null,
+        "number_type": "complex-f64",
+    })
+}
+
+#[cfg(feature = "f64-symjit")]
+pub(crate) fn minimal_execution_manifest(
+    process_id: &str,
+    process: &str,
+    capability: &str,
+    evaluator: Value,
+) -> Value {
+    let value_slot = |value_slot_id: usize, current_id: usize, component: usize| {
+        json!({
+            "value_slot_id": value_slot_id,
+            "current_id": current_id,
+            "variant": "source",
+            "component_start": component,
+            "component_stop": component + 1,
+            "dimension": 1,
+        })
+    };
+    let slot = |current_id: usize, component: usize| {
+        json!({
+            "current_id": current_id,
+            "component_start": component,
+            "component_stop": component + 1,
+            "dimension": 1,
+        })
+    };
+    let crossing_ir = || {
+        json!({
+            "momentum_transform": "negate-four-momentum",
+            "helicity_factor": 1,
+            "chirality_factor": 1,
+            "spin_state_factor": 1,
+            "phase": [1.0, 0.0],
+        })
+    };
+    let source_ir = |particle_id: i32, anti_particle_id: i32, orientation: &str| {
+        json!({
+            "identity": {
+                "canonical_id": format!("model:minimal:state:{particle_id}"),
+                "species_id": "model:minimal:species:1",
+                "anti_canonical_id": format!("model:minimal:state:{anti_particle_id}"),
+                "display_name": format!("state_{particle_id}"),
+                "anti_display_name": format!("state_{anti_particle_id}"),
+                "pdg_label": particle_id,
+                "anti_pdg_label": anti_particle_id,
+                "orientation": orientation,
+                "self_conjugate": false,
+            },
+            "statistics": "boson",
+            "wavefunction_family": "scalar",
+            "component_dimension": 1,
+            "states": [{"helicity": 0, "chirality": 0, "spin_state": 1}],
+            "crossing": crossing_ir(),
+            "basis": "scalar",
+            "mass_parameter": null,
+            "width_parameter": null,
+        })
+    };
+    let propagator_ir = |particle_id: i32, anti_particle_id: i32, orientation: &str| {
+        json!({
+            "identity": {
+                "canonical_id": format!("model:minimal:state:{particle_id}"),
+                "species_id": "model:minimal:species:1",
+                "anti_canonical_id": format!(
+                    "model:minimal:state:{anti_particle_id}"
+                ),
+                "display_name": format!("state_{particle_id}"),
+                "anti_display_name": format!("state_{anti_particle_id}"),
+                "pdg_label": particle_id,
+                "anti_pdg_label": anti_particle_id,
+                "orientation": orientation,
+                "self_conjugate": false,
+            },
+            "particle_id": particle_id,
+            "chirality": 0,
+            "kind": "scalar",
+            "backend": "test",
+            "basis": "scalar",
+            "applies_propagator": true,
+            "kernel": "test_scalar",
+            "full_tensor_network_ready": true,
+            "mass_class": "massless",
+            "gauge": null,
+            "numerator": "i",
+            "denominator": "momentum_squared-mass_squared+i*mass*width",
+            "mass_parameter": null,
+            "width_parameter": null,
+            "custom_source": null,
+            "auxiliary_policy": null,
+            "goldstone_policy": "not-applicable",
+            "description": "test scalar propagator",
+        })
+    };
+    let real_inputs = (2..14).collect::<Vec<_>>();
+    let current_storage = json!({
+        "component_count": 2,
+        "number_type": "complex",
+        "metadata_compacted": true,
+        "current_slots": [
+            {
+                "current_id": 0, "component_start": 0, "component_stop": 1,
+                "dimension": 1, "is_source": true, "particle_id": 1,
+                "external_mask": 1, "external_labels": [], "helicity_ancestry": null,
+                "chirality": 0, "spin_state": null, "flavour_flow": [],
+                "color_state": null, "momentum_mask": 1,
+                "auxiliary_kind": null
+            },
+            {
+                "current_id": 1, "component_start": 1, "component_stop": 2,
+                "dimension": 1, "is_source": true, "particle_id": -1,
+                "external_mask": 2, "external_labels": [], "helicity_ancestry": null,
+                "chirality": 0, "spin_state": null, "flavour_flow": [],
+                "color_state": null, "momentum_mask": 2,
+                "auxiliary_kind": null
+            }
+        ],
+    });
+    let value_storage = json!({
+        "component_count": 2,
+        "number_type": "complex",
+        "metadata_compacted": true,
+        "value_slots": [
+            {
+                "value_slot_id": 0, "current_id": 0, "variant": "source",
+                "component_start": 0, "component_stop": 1, "dimension": 1,
+                "current_component_start": 0, "current_component_stop": 1,
+                "is_source": true, "applies_propagator": false, "particle_id": 1,
+                "external_mask": 1, "external_labels": [], "momentum_mask": 1,
+                "chirality": 0,
+                "propagator": propagator_ir(1, -1, "particle")
+            },
+            {
+                "value_slot_id": 1, "current_id": 1, "variant": "source",
+                "component_start": 1, "component_stop": 2, "dimension": 1,
+                "current_component_start": 1, "current_component_stop": 2,
+                "is_source": true, "applies_propagator": false, "particle_id": -1,
+                "external_mask": 2, "external_labels": [], "momentum_mask": 2,
+                "chirality": 0,
+                "propagator": propagator_ir(-1, 1, "antiparticle")
+            }
+        ],
+    });
+    let source_fill = json!({
+        "source_count": 2,
+        "sources": [
+            {
+                "source_id": 0, "current_id": 0,
+                "current_component_start": 0, "current_component_stop": 1,
+                "value_slot": value_slot(0, 0, 0),
+                "source_parameter_start": 0, "source_parameter_stop": 1,
+                "leg_label": 1, "input_momentum_slot": 0, "side": "initial",
+                "crossing": "negate-incoming-momentum", "physical_pdg": 1, "outgoing_pdg": 1,
+                "particle_id": 1, "anti_particle_id": -1,
+                "source_kind": "external-wavefunction",
+                "wavefunction_kind": "scalar", "source_orientation": "particle",
+                "source_basis": "scalar", "source_ir": source_ir(1, -1, "particle"),
+                "applied_crossing": crossing_ir(),
+                "source_helicity": 0,
+                "chirality": 0, "spin_state": 1, "dimension": 1,
+                "helicity_ancestry": 1, "color_state": {}
+            },
+            {
+                "source_id": 1, "current_id": 1,
+                "current_component_start": 1, "current_component_stop": 2,
+                "value_slot": value_slot(1, 1, 1),
+                "source_parameter_start": 1, "source_parameter_stop": 2,
+                "leg_label": 2, "input_momentum_slot": 1, "side": "initial",
+                "crossing": "negate-incoming-momentum", "physical_pdg": -1, "outgoing_pdg": -1,
+                "particle_id": -1, "anti_particle_id": 1,
+                "source_kind": "external-wavefunction",
+                "wavefunction_kind": "scalar", "source_orientation": "antiparticle",
+                "source_basis": "scalar", "source_ir": source_ir(-1, 1, "antiparticle"),
+                "applied_crossing": crossing_ir(),
+                "source_helicity": 0,
+                "chirality": 0, "spin_state": 1, "dimension": 1,
+                "helicity_ancestry": 1, "color_state": {}
+            }
+        ],
+    });
+    let amplitude_stage = json!({
+        "stage_kind": "amplitude-roots",
+        "output_count": 1,
+        "color_contraction": null,
+        "roots": [{
+            "output_index": 0, "root_id": 0, "kind": "direct-contraction",
+            "left_current_id": 0, "right_current_id": 1,
+            "left_slot": slot(0, 0), "right_slot": slot(1, 1),
+            "left_value_slot": value_slot(0, 0, 0),
+            "right_value_slot": value_slot(1, 1, 1),
+            "vertex_kind": null, "vertex_particles": null,
+            "coupling": [1.0, 0.0], "color_weight": [1.0, 0.0],
+            "color_sector_id": 0, "contraction": "minimal-test",
+            "contraction_ir": {
+                "name": "minimal-test",
+                "left_basis": "scalar",
+                "right_basis": "scalar",
+                "coefficients": [[1.0, 0.0]],
+                "chirality_relation": "any",
+                "metric_signature": null
+            },
+            "coherent_group_id": 7, "helicity_weight": 1.0,
+            "all_sector_weight": 1.0
+        }],
+    });
+    let runtime_schema = json!({
+        "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+        "kind": "pyamplicol-runtime-execution-plan",
+        "process_key": process_id,
+        "process": process,
+        "external_particles": [
+            {"label": 1, "index": 0, "pdg": 1, "outgoing_pdg": 1, "role": "initial", "momentum_slot": 0},
+            {"label": 2, "index": 1, "pdg": -1, "outgoing_pdg": -1, "role": "initial", "momentum_slot": 1},
+            {"label": 3, "index": 2, "pdg": 22, "outgoing_pdg": 22, "role": "final", "momentum_slot": 2},
+        ],
+        "model": null,
+        "model_parameters": [],
+        "normalization": null,
+        "parameter_layout": {
+            "source_component_parameter_count": 2,
+            "momentum_parameter_count": 12,
+            "model_parameter_count": 0,
+            "parameter_count_if_flattened": 14,
+            "value_component_count": 2,
+            "source_components_complex": true,
+            "momentum_components_real": true,
+            "real_valued_inputs": real_inputs,
+        },
+        "current_storage": current_storage,
+        "value_storage": value_storage,
+        "source_fill": source_fill,
+        "momentum_slots": [
+            {"momentum_slot_id": 0, "momentum_mask": 1, "external_labels": [1], "component_start": 0, "component_stop": 4, "real_valued": true},
+            {"momentum_slot_id": 1, "momentum_mask": 2, "external_labels": [2], "component_start": 4, "component_stop": 8, "real_valued": true},
+            {"momentum_slot_id": 2, "momentum_mask": 4, "external_labels": [3], "component_start": 8, "component_stop": 12, "real_valued": true},
+        ],
+        "stages": [],
+        "amplitude_stage": amplitude_stage,
+    });
+    let serialized_amplitude = json!({
+        "stage_index": 0,
+        "stage_kind": "amplitude-roots",
+        "subset_size": null,
+        "evaluator_label": "minimal_amplitude",
+        "parameter_layout": "global-value-momentum",
+        "output_length": 1,
+        "output_slots": [{
+            "value_slot_id": -1,
+            "current_id": -1,
+            "variant": "amplitude-root",
+            "component_start": 0,
+            "component_stop": 1,
+            "output_start": 0,
+            "output_stop": 1,
+        }],
+        "input_value_slot_ids": [0, 1],
+        "output_value_slot_ids": [],
+        "interaction_ids": [],
+        "input_components": [],
+        "parameter_count": 14,
+        "value_parameter_count": 2,
+        "momentum_parameter_count": 12,
+        "model_parameter_count": 0,
+        "real_valued_inputs": (2..14).collect::<Vec<_>>(),
+        "expression_ready": true,
+        "blockers": [],
+        "evaluator": evaluator,
+    });
+    let compiled = json!({
+        "kind": "generic-dag-stage-blueprint",
+        "runtime_available": true,
+        "runtime_unavailable_message": null,
+        "model_parameter_evaluator": null,
+        "stage_evaluators": {
+            "kind": "generic-dag-stage-evaluator-artifacts",
+            "required_runtime_capabilities": [capability],
+            "runtime_available": true,
+            "runtime_unavailable_message": null,
+            "parameter_count": 14,
+            "value_parameter_count": 2,
+            "momentum_parameter_count": 12,
+            "model_parameter_count": 0,
+            "real_valued_inputs": (2..14).collect::<Vec<_>>(),
+            "parameter_layout": "global-value-momentum",
+            "stage_count": 1,
+            "stages": [],
+            "amplitude_stage": serialized_amplitude,
+        },
+    });
+    json!({
+        "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+        "kind": "pyamplicol-runtime-execution",
+        "required_runtime_capabilities": [capability],
+        "process": process,
+        "key": process_id,
+        "color_accuracy": "lc",
+        "external_pdg_order": [1, -1, 22],
+        "compiled": compiled,
+        "dag_summary": {
+            "current_count": 2,
+            "source_count": 2,
+            "interaction_count": 0,
+            "interaction_evaluation_count": 0,
+            "amplitude_root_count": 1,
+            "truncated": false,
+        },
+        "materialization_census": {
+            "abi": "pyamplicol-fully-resident-materialization-census-v1",
+            "basis": "immutable-fully-resident-compiled-dag",
+            "final": {
+                "current_count": 2,
+                "source_count": 2,
+                "interaction_count": 0,
+                "interaction_evaluation_count": 0,
+                "amplitude_root_count": 1,
+            },
+            "peak": {
+                "current_count": 2,
+                "source_count": 2,
+                "interaction_count": 0,
+                "interaction_evaluation_count": 0,
+                "amplitude_root_count": 1,
+            },
+            "final_equals_peak": true,
+        },
+        "runtime_schema": runtime_schema,
+    })
+}
+
+#[cfg(feature = "f64-symjit")]
+pub(crate) fn mock_helicity_materialization() -> Value {
+    json!({
+        "kind": "pyamplicol-helicity-recurrence",
+        "contract_version": 1,
+        "proof_algorithm": "canonical-source-transition-dependency-shape-v1",
+        "current_count": 2,
+        "amplitude_root_count": 1,
+        "proof_counts": {
+            "recurrence_class_count": 0,
+            "optimized_recurrence_class_count": 0,
+            "optimized_current_count": 0,
+            "residual_current_count": 2,
+            "amplitude_class_count": 0,
+            "optimized_amplitude_class_count": 0,
+            "residual_amplitude_count": 1,
+            "source_state_mapping_count": 0,
+            "physical_helicity_count": 2,
+            "structural_zero_helicity_count": 0,
+        },
+        "selector_domains": [
+            {"id": 0, "complete": true, "source_states": []},
+            {"id": 1, "complete": true, "source_states": []},
+        ],
+        "source_state_mappings": [],
+        "recurrence_classes": [],
+        "amplitude_classes": [],
+        "residual_current_ids": [0, 1],
+        "residual_root_ids": [0],
+        "structural_zero_selector_domain_ids": [],
+        "diagnostics": [],
+        "materialization": {
+            "kind": "pyamplicol-helicity-recurrence-materialization",
+            "contract_version": 1,
+            "strategy": "quotient",
+            "proof_current_count": 2,
+            "proof_root_count": 1,
+            "materialized_current_count": 2,
+            "materialized_root_count": 1,
+            "proof_to_materialized_current": [0, 1],
+            "source_routes": [],
+            "amplitude_routes": [],
+            "selector_schedules": [],
+        },
+    })
+}
+
+#[cfg(feature = "f64-symjit")]
+pub(crate) fn minimal_helicity_selector_lane_execution() -> Value {
+    const DIRECT: &str = "symjit.application.complex-f64.v1";
+    let mut execution = minimal_execution_manifest(
+        "p0",
+        "a b > c",
+        DIRECT,
+        direct_evaluator_manifest("evaluators/direct.symjit"),
+    );
+    let mut lane = execution.clone();
+    lane["physics_reduction"] = minimal_runtime_physics("p0", "a b > c", "c")["reduction"].clone();
+    execution["runtime_schema"]["helicity_recurrence"] = mock_helicity_materialization();
+    execution["required_runtime_capabilities"] = json!([
+        crate::engine::COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY,
+        crate::engine::COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY,
+        crate::engine::COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+        DIRECT,
+    ]);
+    execution["helicity_selector_executions"] = json!([{
+        "selector_domain_ids": [0, 1],
+        "execution": lane,
+    }]);
+    execution
+}
+
+#[cfg(feature = "f64-symjit")]
+fn helicity_selector_lane_artifact(execution: Value) -> TestArtifact {
+    const DIRECT: &str = "symjit.application.complex-f64.v1";
+    let mut artifact = TestArtifact::new();
+    let capabilities = json!([
+        crate::engine::COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY,
+        crate::engine::COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY,
+        crate::engine::COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+        DIRECT,
+    ]);
+    artifact.manifest["processes"][0]["required_runtime_capabilities"] = capabilities.clone();
+    artifact.manifest["runtime"]["required_runtime_capabilities"] = capabilities;
+    replace_test_payload(
+        &mut artifact,
+        "evaluator.json",
+        &serde_json::to_vec(&execution).expect("serialize execution fixture"),
+    );
+    replace_test_payload(
+        &mut artifact,
+        "physics.json",
+        &serde_json::to_vec(&minimal_runtime_physics("p0", "a b > c", "c"))
+            .expect("serialize physics fixture"),
+    );
+    add_test_payload(
+        &mut artifact,
+        "evaluators/direct.symjit",
+        "evaluator-state",
+        &direct_symjit_application_bytes(14),
+        Some("p0"),
+        true,
+    );
+    artifact.write_manifest();
+    artifact
+}
+
+#[cfg(feature = "f64-symjit")]
+fn helicity_selector_lane_load_error(execution: Value) -> crate::RusticolError {
+    let artifact = helicity_selector_lane_artifact(execution);
+    match crate::NativeRuntime::load(&artifact.root, Some("p0"), None) {
+        Ok(_) => panic!("invalid compiled helicity selector lane unexpectedly loaded"),
+        Err(error) => error,
+    }
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn compiled_helicity_selector_lanes_reject_duplicate_domains() {
+    let mut execution = minimal_helicity_selector_lane_execution();
+    let mut duplicate = execution["helicity_selector_executions"][0].clone();
+    duplicate["selector_domain_ids"] = json!([1]);
+    execution["helicity_selector_executions"]
+        .as_array_mut()
+        .unwrap()
+        .push(duplicate);
+
+    let error = helicity_selector_lane_load_error(execution);
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+    assert!(
+        error.to_string().contains("duplicate selector domain 1"),
+        "{error}"
+    );
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn compiled_helicity_selector_lanes_reject_unknown_domains() {
+    let mut execution = minimal_helicity_selector_lane_execution();
+    execution["helicity_selector_executions"][0]["selector_domain_ids"] = json!([2]);
+
+    let error = helicity_selector_lane_load_error(execution);
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+    assert!(
+        error.to_string().contains("unknown selector domain 2"),
+        "{error}"
+    );
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn compiled_helicity_selector_lanes_reject_nested_auxiliaries() {
+    for nested_field in ["helicity_sum_execution", "color_selector_executions"] {
+        let mut execution = minimal_helicity_selector_lane_execution();
+        let lane = &mut execution["helicity_selector_executions"][0]["execution"];
+        let nested = lane.clone();
+        lane[nested_field] = match nested_field {
+            "helicity_sum_execution" => nested,
+            _ => json!([{"materialized_sector_id": 0, "execution": nested}]),
+        };
+
+        let error = helicity_selector_lane_load_error(execution);
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+        assert!(
+            error.to_string().contains(
+                "helicity-selector execution contains an unsupported auxiliary execution"
+            ),
+            "{nested_field}: {error}"
+        );
+    }
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn parent_closure_helicity_selector_lane_rejects_nested_closure() {
+    let mut execution = minimal_helicity_selector_lane_execution();
+    let lane = &mut execution["helicity_selector_executions"][0]["execution"];
+    let nested = lane.clone();
+    lane["helicity_selector_executions"] =
+        json!([{"selector_domain_ids": [0], "execution": nested}]);
+
+    let error = helicity_selector_lane_load_error(execution);
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+    assert!(
+        error
+            .to_string()
+            .contains("only a nested-runtime helicity-selector execution"),
+        "{error}"
+    );
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn compiled_helicity_selector_lanes_reject_nested_materialization() {
+    let mut execution = minimal_helicity_selector_lane_execution();
+    execution["helicity_selector_executions"][0]["execution"]["runtime_schema"]["helicity_recurrence"] =
+        mock_helicity_materialization();
+
+    let error = helicity_selector_lane_load_error(execution);
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+    assert!(
+        error
+            .to_string()
+            .contains("cannot contain helicity materialization"),
+        "{error}"
+    );
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn nested_runtime_helicity_selector_lane_requires_materialization() {
+    let mut execution = minimal_helicity_selector_lane_execution();
+    execution["helicity_selector_executions"][0]["schedule_mode"] = json!("nested-runtime");
+
+    let error = helicity_selector_lane_load_error(execution);
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+    assert!(
+        error.to_string().contains(
+            "nested-runtime helicity-selector execution requires helicity materialization"
+        ),
+        "{error}"
+    );
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn compiled_helicity_selector_lanes_verify_nested_payloads() {
+    let mut execution = minimal_helicity_selector_lane_execution();
+    execution["helicity_selector_executions"][0]["execution"]["compiled"]["stage_evaluators"]["amplitude_stage"]
+        ["evaluator"]["application_path"] = json!("evaluators/undeclared-selector-lane.symjit");
+
+    let error = helicity_selector_lane_load_error(execution);
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Security, "{error}");
+    assert!(
+        error
+            .to_string()
+            .contains("undeclared-selector-lane.symjit"),
+        "{error}"
+    );
+}
+
+#[cfg(feature = "f64-symjit")]
+fn minimal_color_topology_lane_execution() -> Value {
+    const DIRECT: &str = "symjit.application.complex-f64.v1";
+    let mut execution = minimal_execution_manifest(
+        "p0",
+        "a b > c",
+        DIRECT,
+        direct_evaluator_manifest("evaluators/direct.symjit"),
+    );
+    let mut lane = execution.clone();
+    lane["physics_reduction"] = minimal_runtime_physics("p0", "a b > c", "c")["reduction"].clone();
+    execution["required_runtime_capabilities"] = json!([
+        crate::engine::COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY,
+        crate::engine::COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+        DIRECT,
+    ]);
+    execution["color_selector_executions"] = json!([{
+        "materialized_sector_id": 0,
+        "execution": lane,
+    }]);
+    execution
+}
+
+#[cfg(feature = "f64-symjit")]
+fn color_topology_lane_artifact(execution: Value) -> TestArtifact {
+    const DIRECT: &str = "symjit.application.complex-f64.v1";
+    let mut artifact = TestArtifact::new();
+    let capabilities = json!([
+        crate::engine::COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY,
+        crate::engine::COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+        DIRECT,
+    ]);
+    artifact.manifest["processes"][0]["required_runtime_capabilities"] = capabilities.clone();
+    artifact.manifest["runtime"]["required_runtime_capabilities"] = capabilities;
+    replace_test_payload(
+        &mut artifact,
+        "evaluator.json",
+        &serde_json::to_vec(&execution).expect("serialize execution fixture"),
+    );
+    replace_test_payload(
+        &mut artifact,
+        "physics.json",
+        &serde_json::to_vec(&minimal_runtime_physics("p0", "a b > c", "c"))
+            .expect("serialize physics fixture"),
+    );
+    add_test_payload(
+        &mut artifact,
+        "evaluators/direct.symjit",
+        "evaluator-state",
+        &direct_symjit_application_bytes(14),
+        Some("p0"),
+        true,
+    );
+    artifact.write_manifest();
+    artifact
+}
+
+#[cfg(feature = "f64-symjit")]
+fn color_topology_lane_load_error(execution: Value) -> crate::RusticolError {
+    let artifact = color_topology_lane_artifact(execution);
+    match crate::NativeRuntime::load(&artifact.root, Some("p0"), None) {
+        Ok(_) => panic!("invalid compiled color topology lane unexpectedly loaded"),
+        Err(error) => error,
+    }
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn compiled_color_topology_lane_rejects_duplicate_materialized_sector_ids() {
+    let mut execution = minimal_color_topology_lane_execution();
+    let duplicate = execution["color_selector_executions"][0].clone();
+    execution["color_selector_executions"]
+        .as_array_mut()
+        .unwrap()
+        .push(duplicate);
+
+    let error = color_topology_lane_load_error(execution);
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+    assert!(
+        error
+            .to_string()
+            .contains("duplicate materialized sector 0")
+    );
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn compiled_color_topology_lane_rejects_recursive_auxiliary_executions() {
+    for nested_field in [
+        "helicity_sum_execution",
+        "helicity_selector_executions",
+        "color_selector_executions",
+    ] {
+        let mut execution = minimal_color_topology_lane_execution();
+        let lane = &mut execution["color_selector_executions"][0]["execution"];
+        let nested = lane.clone();
+        lane[nested_field] = match nested_field {
+            "helicity_sum_execution" => nested,
+            "helicity_selector_executions" => {
+                json!([{"selector_domain_ids": [0], "execution": nested}])
+            }
+            _ => json!([{"materialized_sector_id": 1, "execution": nested}]),
+        };
+
+        let error = color_topology_lane_load_error(execution);
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+        assert!(
+            error
+                .to_string()
+                .contains("color-selector execution cannot contain auxiliary executions"),
+            "{nested_field}: {error}"
+        );
+    }
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn compiled_color_topology_lane_verifies_nested_evaluator_payloads() {
+    let mut execution = minimal_color_topology_lane_execution();
+    execution["color_selector_executions"][0]["execution"]["compiled"]["stage_evaluators"]["amplitude_stage"]
+        ["evaluator"]["application_path"] = json!("evaluators/undeclared-lane.symjit");
+
+    let error = color_topology_lane_load_error(execution);
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Security, "{error}");
+    assert!(
+        error.to_string().contains("undeclared-lane.symjit"),
+        "{error}"
+    );
+}
+
+#[cfg(feature = "f64-symjit")]
+fn mixed_backend_runtime_artifact() -> TestArtifact {
+    const DIRECT: &str = "symjit.application.complex-f64.v1";
+    const ARENA: &str = crate::engine::COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY;
+    const ASM: &str = "symbolica.compiled-asm.complex-f64.v1";
+    const CPP: &str = "symbolica.compiled-cpp.complex-f64.v1";
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["kind"] = json!("pyamplicol-process-set");
+    artifact.manifest["default_process_id"] = json!("direct");
+    artifact.manifest["processes"] = json!([
+        {
+            "id": "direct",
+            "expression": "a b > c",
+            "color_accuracy": "lc",
+            "external_pdgs": [1, -1, 22],
+            "physics_path": "processes/direct/physics.json",
+            "required_runtime_capabilities": [ARENA, DIRECT],
+            "aliases": [],
+        },
+        {
+            "id": "asm",
+            "expression": "a b > e",
+            "color_accuracy": "lc",
+            "external_pdgs": [1, -1, 22],
+            "physics_path": "processes/asm/physics.json",
+            "required_runtime_capabilities": [ASM],
+            "aliases": [],
+        },
+        {
+            "id": "cpp",
+            "expression": "a b > d",
+            "color_accuracy": "lc",
+            "external_pdgs": [1, -1, 22],
+            "physics_path": "processes/cpp/physics.json",
+            "required_runtime_capabilities": [CPP],
+            "aliases": [],
+        }
+    ]);
+    artifact.manifest["runtime"]["evaluator_manifest_path"] = json!("processes/evaluators.json");
+    artifact.manifest["runtime"]["required_runtime_capabilities"] =
+        json!([ARENA, ASM, CPP, DIRECT]);
+
+    let direct_application = direct_symjit_application_bytes(14);
+    let direct_plane_application = direct_symjit_plane_application_bytes(14);
+    let mut direct_execution = minimal_execution_manifest(
+        "direct",
+        "a b > c",
+        DIRECT,
+        direct_evaluator_manifest("evaluators/direct.symjit"),
+    );
+    direct_execution["compiled"]["momentum_slot_ids"] = json!([0, 1, 2]);
+    let input_binding = |parameter_index: usize| {
+        let (kind, source_id, component, global_component, real_valued) = if parameter_index < 2 {
+            ("value", parameter_index, 0, parameter_index, false)
+        } else {
+            (
+                "momentum",
+                (parameter_index - 2) / 4,
+                (parameter_index - 2) % 4,
+                parameter_index,
+                true,
+            )
+        };
+        json!({
+            "parameter_index": parameter_index,
+            "kind": kind,
+            "source_id": source_id,
+            "component": component,
+            "global_component": global_component,
+            "real_valued": real_valued,
+        })
+    };
+    let input_bindings = (0..14).map(input_binding).collect::<Vec<_>>();
+    let direct_stage = &mut direct_execution["compiled"]["stage_evaluators"]["amplitude_stage"];
+    direct_stage["parameter_layout"] = json!("stage-local-value-momentum");
+    direct_stage["input_components"] = json!(input_bindings);
+    direct_stage["evaluator"]["plane_application"] = json!({
+        "application_path": "evaluators/direct.plane.symjit",
+        "application_abi": crate::engine::SYMJIT_PLANE_APPLICATION_ABI,
+        "storage_abi": crate::engine::SYMJIT_APPLICATION_STORAGE_ABI,
+        "element_layout": "split-complex-plane-major",
+        "descriptor_order": "inputs-re-im-then-outputs-re-im",
+        "input_complex_count": 14,
+        "output_complex_count": 1,
+        "input_plane_count": 28,
+        "output_plane_count": 2,
+        "compiler_type": "native",
+        "translation_mode": "symbolica-structured-instructions",
+        "optimization_level": 3,
+        "simd": true,
+        "complex": true,
+        "fast_math": true,
+        "fast_complex": false,
+        "compression": false,
+        "threading": false,
+        "direct_arena": true,
+        "source_digest": sha256(DIRECT_SYMJIT_PROGRAM.as_bytes()),
+        "target": {
+            "word_bits": 64,
+            "endianness": "little",
+            "triple": "test-native",
+            "cpu_features": [],
+        },
+    });
+    direct_stage["evaluator"]["evaluator_state_path"] = json!("evaluators/direct.exact.symbolica");
+    direct_stage["evaluator"]["evaluator_state_runtime_capability"] =
+        json!(crate::engine::SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY);
+    direct_stage["compiled_plane_arena"] = json!({
+        "schema_version": 1,
+        "kind": "compiled-plane-arena-stage",
+        "application_abi": crate::engine::COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+        "source_application_abi": crate::engine::COMPILED_PLANE_SOURCE_APPLICATION_ABI,
+        "element_layout": "split-complex-component-major",
+        "output_operation": "overwrite",
+        "output_factor": "identity",
+        "input_output_aliasing": "forbidden",
+        "output_output_aliasing": "forbidden",
+        "input_bindings": (0..14).map(input_binding).collect::<Vec<_>>(),
+        "output_bindings": [{
+            "output_index": 0,
+            "arena": "amplitude",
+            "component": 0,
+        }],
+        "leaves": [{
+            "application_path": "evaluators/direct.plane.symjit",
+            "source_application_abi": crate::engine::COMPILED_PLANE_SOURCE_APPLICATION_ABI,
+            "optimization_level": 3,
+            "direct_codegen_optimization_level": 3,
+            "input_len": 14,
+            "output_len": 1,
+            "input_indices": (0..14).collect::<Vec<_>>(),
+            "output_start": 0,
+            "output_stop": 1,
+        }],
+    });
+    direct_execution["compiled"]["stage_evaluators"]["parameter_layout"] =
+        json!("stage-local-value-momentum");
+    direct_execution["compiled"]["stage_evaluators"]["parameter_count"] = json!(0);
+    direct_execution["compiled"]["stage_evaluators"]["value_parameter_count"] = json!(0);
+    direct_execution["compiled"]["stage_evaluators"]["momentum_parameter_count"] = json!(0);
+    direct_execution["compiled"]["stage_evaluators"]["model_parameter_count"] = json!(0);
+    direct_execution["compiled"]["stage_evaluators"]["real_valued_inputs"] = json!([]);
+    direct_execution["compiled"]["stage_evaluators"]["required_runtime_capabilities"] =
+        json!([ARENA, DIRECT]);
+    direct_execution["required_runtime_capabilities"] = json!([ARENA, DIRECT]);
+    let cpp_execution = minimal_execution_manifest(
+        "cpp",
+        "a b > d",
+        CPP,
+        compiled_evaluator_manifest("evaluators/fake-cpp.dylib", CPP),
+    );
+    let asm_execution = minimal_execution_manifest(
+        "asm",
+        "a b > e",
+        ASM,
+        compiled_evaluator_manifest("evaluators/fake-asm.dylib", ASM),
+    );
+    let execution_set = json!({
+        "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+        "kind": "pyamplicol-runtime-execution-set",
+        "required_runtime_capabilities": [ARENA, ASM, CPP, DIRECT],
+        "processes": [
+            {
+                "process_id": "direct",
+                "manifest_path": "direct/execution.json",
+                "required_runtime_capabilities": [ARENA, DIRECT]
+            },
+            {
+                "process_id": "asm",
+                "manifest_path": "asm/execution.json",
+                "required_runtime_capabilities": [ASM]
+            },
+            {
+                "process_id": "cpp",
+                "manifest_path": "cpp/execution.json",
+                "required_runtime_capabilities": [CPP]
+            }
+        ]
+    });
+    for (path, role, value, process_id) in [
+        (
+            "processes/evaluators.json",
+            "evaluator-manifest",
+            execution_set,
+            None,
+        ),
+        (
+            "processes/direct/execution.json",
+            "evaluator-manifest",
+            direct_execution,
+            Some("direct"),
+        ),
+        (
+            "processes/asm/execution.json",
+            "evaluator-manifest",
+            asm_execution,
+            Some("asm"),
+        ),
+        (
+            "processes/cpp/execution.json",
+            "evaluator-manifest",
+            cpp_execution,
+            Some("cpp"),
+        ),
+        (
+            "processes/direct/physics.json",
+            "runtime-physics",
+            minimal_runtime_physics("direct", "a b > c", "c"),
+            Some("direct"),
+        ),
+        (
+            "processes/asm/physics.json",
+            "runtime-physics",
+            minimal_runtime_physics("asm", "a b > e", "e"),
+            Some("asm"),
+        ),
+        (
+            "processes/cpp/physics.json",
+            "runtime-physics",
+            minimal_runtime_physics("cpp", "a b > d", "d"),
+            Some("cpp"),
+        ),
+    ] {
+        let bytes = serde_json::to_vec(&value).expect("serialize mixed-runtime JSON");
+        add_test_payload(&mut artifact, path, role, &bytes, process_id, false);
+    }
+    add_test_payload(
+        &mut artifact,
+        "processes/direct/evaluators/direct.symjit",
+        "evaluator-state",
+        &direct_application,
+        Some("direct"),
+        true,
+    );
+    add_test_payload(
+        &mut artifact,
+        "processes/direct/evaluators/direct.plane.symjit",
+        "evaluator-state",
+        &direct_plane_application,
+        Some("direct"),
+        true,
+    );
+    add_test_payload(
+        &mut artifact,
+        "processes/direct/evaluators/direct.exact.symbolica",
+        "evaluator-state",
+        b"deferred exact-evaluator test state",
+        Some("direct"),
+        true,
+    );
+    add_test_payload(
+        &mut artifact,
+        "processes/asm/evaluators/fake-asm.dylib",
+        "evaluator-state",
+        b"unselected fake ASM evaluator",
+        Some("asm"),
+        true,
+    );
+    add_test_payload(
+        &mut artifact,
+        "processes/cpp/evaluators/fake-cpp.dylib",
+        "evaluator-state",
+        b"unselected fake C++ evaluator",
+        Some("cpp"),
+        true,
+    );
+    artifact.write_manifest();
+    artifact
+}
+
+#[test]
+fn artifact_identity_tracks_only_runtime_payload_records() {
+    let mut value = json!({
+        "artifact_id": "0".repeat(64),
+        "created_utc": "2026-07-31T00:00:00Z",
+        "payloads": [
+            {
+                "path": "config/effective.toml",
+                "role": "configuration-effective",
+                "media_type": "application/toml",
+                "size_bytes": 1,
+                "sha256": "1".repeat(64),
+                "executable": false,
+            },
+            {
+                "path": "processes/p0/validation-momenta.json",
+                "role": "validation-momenta",
+                "media_type": "application/json",
+                "size_bytes": 1,
+                "sha256": "2".repeat(64),
+                "executable": false,
+            },
+            {
+                "path": "processes/p0/physics.json",
+                "role": "runtime-physics",
+                "media_type": "application/json",
+                "size_bytes": 1,
+                "sha256": "3".repeat(64),
+                "executable": false,
+                "process_id": "p0",
+            },
+        ],
+    });
+    let identity = compute_artifact_id(&value).unwrap();
+
+    value["created_utc"] = json!("2030-01-01T00:00:00Z");
+    value["payloads"][0]["sha256"] = json!("a".repeat(64));
+    value["payloads"][1]["sha256"] = json!("b".repeat(64));
+    assert_eq!(compute_artifact_id(&value).unwrap(), identity);
+
+    value["payloads"][2]["sha256"] = json!("c".repeat(64));
+    assert_ne!(compute_artifact_id(&value).unwrap(), identity);
+}
+
+#[test]
+fn valid_manifest_opens_trusted_payload_catalog() {
+    let artifact = TestArtifact::new();
+    let verified = VerifiedArtifact::open(&artifact.root).expect("valid artifact");
+
+    assert_eq!(verified.manifest().schema_version, 3);
+    assert_eq!(verified.select_process(None).unwrap().requested_id, "p0");
+    assert_eq!(
+        verified
+            .select_process(Some("  A   b  >  C "))
+            .expect("select process by case- and whitespace-normalized expression")
+            .requested_id,
+        "p0"
+    );
+}
+
+#[test]
+fn valid_manifest_larger_than_legacy_16_mib_guard_opens() {
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["extensions"]["large_valid_metadata"] = json!("x".repeat(16 * 1024 * 1024));
+    artifact.write_manifest();
+    let manifest_path = artifact.root.join(ARTIFACT_MANIFEST_FILE);
+    assert!(
+        fs::metadata(&manifest_path)
+            .expect("large manifest metadata")
+            .len()
+            > 16 * 1024 * 1024
+    );
+
+    let verified = VerifiedArtifact::open(&artifact.root).expect("large valid artifact manifest");
+    assert_eq!(
+        verified
+            .manifest()
+            .extensions
+            .get("large_valid_metadata")
+            .and_then(Value::as_str)
+            .map(str::len),
+        Some(16 * 1024 * 1024)
+    );
+}
+
+#[test]
+fn artifact_without_current_identity_contract_fails_closed() {
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["extensions"]
+        .as_object_mut()
+        .unwrap()
+        .remove(ARTIFACT_IDENTITY_EXTENSION);
+    artifact.write_manifest();
+
+    let error = VerifiedArtifact::open(&artifact.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+    assert!(error.to_string().contains("regenerate"));
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn verified_artifact_resolves_packed_evaluator_payloads() {
+    let mut artifact = TestArtifact::new();
+    add_test_evaluator_container(&mut artifact);
+
+    let verified = VerifiedArtifact::open(&artifact.root).expect("packed artifact");
+    assert!(verified.has_evaluator_payload("a/jit.symjit").unwrap());
+    assert!(verified.has_evaluator_payload("z/exact.bin").unwrap());
+    assert!(!verified.has_evaluator_payload("missing.symjit").unwrap());
+
+    let store = verified
+        .evaluator_payload_store(verified.root())
+        .expect("root evaluator store");
+    let application = store
+        .source("a/jit.symjit")
+        .expect("packed application source");
+    assert_eq!(application.read().unwrap().as_ref(), b"jit-v1");
+    assert_eq!(application.display_name(), "evaluators.pacbin:a/jit.symjit");
+    assert_eq!(
+        store
+            .source("z/exact.bin")
+            .expect("packed exact source")
+            .read()
+            .unwrap()
+            .as_ref(),
+        b"exact-state"
+    );
+}
+
+#[test]
+fn evaluator_payload_store_resolves_process_relative_paths_and_rejects_escape() {
+    let mut artifact = TestArtifact::new();
+    let declared = "processes/p0/on-the-fly-runtime.pacbin";
+    add_test_payload(
+        &mut artifact,
+        declared,
+        "evaluator-state",
+        b"authenticated on-the-fly container",
+        Some("p0"),
+        true,
+    );
+    artifact.write_manifest();
+
+    let verified = VerifiedArtifact::open(&artifact.root).expect("process payload artifact");
+    let process_root = verified.root().join("processes/p0");
+    let store = verified
+        .evaluator_payload_store(&process_root)
+        .expect("process evaluator store");
+    let logical = store
+        .logical_path("on-the-fly-runtime.pacbin")
+        .expect("process-relative payload path");
+    assert_eq!(logical, declared);
+    assert_eq!(verified.payload(&logical).unwrap().path, declared);
+
+    let error = store.logical_path("../escape.pacbin").unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Security);
+
+    let missing = store
+        .logical_path("missing.pacbin")
+        .expect("confined undeclared path");
+    let error = verified.payload(&missing).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Security);
+    assert!(
+        error.to_string().contains("not a declared payload"),
+        "{error}"
+    );
+}
+
+#[cfg(all(unix, feature = "f64-symjit"))]
+#[test]
+fn trusted_loose_evaluator_source_reads_replacement_bytes() {
+    let mut artifact = TestArtifact::new();
+    add_test_payload(
+        &mut artifact,
+        "loose.symjit",
+        "evaluator-state",
+        b"jit-v1",
+        Some("p0"),
+        true,
+    );
+    artifact.write_manifest();
+    let verified = VerifiedArtifact::open(&artifact.root).expect("loose evaluator artifact");
+    let source = verified
+        .evaluator_payload_store(verified.root())
+        .expect("verified evaluator store")
+        .source("loose.symjit")
+        .expect("loose evaluator source");
+    let replacement_path = artifact.root.join("loose.replacement");
+    fs::write(&replacement_path, b"bad-v1").expect("write replacement evaluator");
+    fs::rename(&replacement_path, artifact.root.join("loose.symjit"))
+        .expect("replace loose evaluator path");
+
+    assert_eq!(
+        source.read().expect("read trusted replacement").as_ref(),
+        b"bad-v1"
+    );
+}
+
+#[cfg(all(unix, feature = "f64-symjit"))]
+#[test]
+fn evaluator_container_replacement_after_validation_is_reauthenticated() {
+    let mut artifact = TestArtifact::new();
+    add_test_evaluator_container(&mut artifact);
+    let verified = VerifiedArtifact::open(&artifact.root).expect("packed artifact");
+    let container_path = artifact.root.join("evaluators.pacbin");
+    let replacement_path = artifact.root.join("evaluators.replacement");
+    let mut replacement = decode_hex(PYTHON_PACBIN_GOLDEN_HEX);
+    let payload_offset = replacement
+        .windows(b"jit-v1".len())
+        .position(|window| window == b"jit-v1")
+        .expect("golden JIT member");
+    replacement[payload_offset..payload_offset + b"jit-v1".len()].copy_from_slice(b"bad-v1");
+    fs::write(&replacement_path, replacement).expect("write replacement PACBIN");
+    fs::rename(&replacement_path, &container_path).expect("replace validated PACBIN path");
+
+    let error =
+        load_evaluator_payload_container(&verified.root, &verified.manifest, &verified.payloads)
+            .expect_err("replacement PACBIN bytes must not inherit prior validation");
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("payload digest mismatch"));
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn packed_evaluator_metadata_and_physical_collisions_are_rejected() {
+    let mut count_mismatch = TestArtifact::new();
+    add_test_evaluator_container(&mut count_mismatch);
+    count_mismatch.manifest["extensions"]["evaluator_payload_container"]["member_count"] = json!(3);
+    count_mismatch.write_manifest();
+    let error = VerifiedArtifact::open(&count_mismatch.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("metadata disagrees"));
+
+    let mut collision = TestArtifact::new();
+    add_test_evaluator_container(&mut collision);
+    add_test_payload(
+        &mut collision,
+        "a/jit.symjit",
+        "evaluator-state",
+        b"physical collision",
+        Some("p0"),
+        true,
+    );
+    collision.write_manifest();
+    let error = VerifiedArtifact::open(&collision.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    assert!(
+        error
+            .to_string()
+            .contains("invalid packed evaluator member")
+    );
+}
+
+#[test]
+fn ambiguous_process_expression_lists_stable_ids() {
+    let artifact = TestArtifact::new();
+    let verified = VerifiedArtifact::open(&artifact.root).expect("valid artifact");
+    let mut manifest = verified.manifest().clone();
+    let mut duplicate = manifest.processes[0].clone();
+    duplicate.id = "p1".to_string();
+    manifest.processes.push(duplicate);
+
+    let error = manifest
+        .select_process(Some("a b > c"))
+        .expect_err("duplicate expressions must be ambiguous");
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Selector);
+    assert!(error.to_string().contains("ambiguous"));
+    assert!(error.to_string().contains("p0, p1"));
+}
+
+#[test]
+fn direct_runtime_defers_symbolica_serialization_abi_validation() {
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["producer"]["versions"]["symbolica_serialization"] =
+        json!("a-future-symbolica-serialization-abi");
+    artifact.write_manifest();
+
+    let verified = VerifiedArtifact::open(&artifact.root)
+        .expect("outer artifact validation must not require an unused Symbolica serialization ABI");
+
+    assert_eq!(
+        verified
+            .manifest()
+            .producer
+            .versions
+            .symbolica_serialization,
+        Some("a-future-symbolica-serialization-abi".to_string())
+    );
+
+    let mut no_symbolica_abi = TestArtifact::new();
+    no_symbolica_abi.manifest["producer"]["versions"]
+        .as_object_mut()
+        .unwrap()
+        .remove("symbolica_serialization");
+    no_symbolica_abi.write_manifest();
+
+    let verified = VerifiedArtifact::open(&no_symbolica_abi.root)
+        .expect("direct f64 artifact must not require Symbolica ABI metadata");
+    assert_eq!(
+        verified
+            .manifest()
+            .producer
+            .versions
+            .symbolica_serialization,
+        None
+    );
+}
+
+#[test]
+fn artifact_identity_is_trusted_during_normal_loading() {
+    let artifact = TestArtifact::new();
+    let path = artifact.root.join(ARTIFACT_MANIFEST_FILE);
+    let mut manifest: Value =
+        serde_json::from_slice(&fs::read(&path).unwrap()).expect("parse fixture manifest");
+    manifest["model"]["name"] = json!("tampered-model");
+    fs::write(&path, serde_json::to_vec_pretty(&manifest).unwrap()).unwrap();
+
+    let opened = VerifiedArtifact::open(&artifact.root).expect("open trusted manifest");
+    assert_eq!(opened.manifest().model.name, "tampered-model");
+}
+
+#[test]
+fn unknown_nested_manifest_keys_are_rejected() {
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["producer"]["target"]["unexpected"] = json!(true);
+    artifact.write_manifest();
+
+    let error = VerifiedArtifact::open(&artifact.root).unwrap_err();
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Serialization);
+    assert!(error.to_string().contains("unknown field"));
+}
+
+#[test]
+fn only_canonical_artifact_filename_is_accepted() {
+    let artifact = TestArtifact::new();
+    let legacy = artifact.root.join("manifest.json");
+    fs::rename(artifact.root.join(ARTIFACT_MANIFEST_FILE), &legacy)
+        .expect("rename canonical manifest");
+
+    let directory_error = VerifiedArtifact::open(&artifact.root).unwrap_err();
+    let direct_error = VerifiedArtifact::open(&legacy).unwrap_err();
+
+    assert_eq!(directory_error.kind(), crate::RusticolErrorKind::Artifact);
+    assert_eq!(direct_error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(directory_error.to_string().contains("artifact.json"));
+    assert!(direct_error.to_string().contains("artifact.json"));
+}
+
+#[test]
+fn legacy_schema_reports_actionable_regeneration_error() {
+    let mut artifact = TestArtifact::new();
+    artifact.manifest = json!({"schema_version": 2, "kind": "legacy"});
+    artifact.write_manifest();
+
+    let error = VerifiedArtifact::open(&artifact.root).unwrap_err();
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+    assert!(error.to_string().contains("regenerate"));
+    assert!(error.to_string().contains("schema v3"));
+}
+
+#[test]
+fn traversal_and_duplicate_payload_paths_are_rejected() {
+    let mut traversal = TestArtifact::new();
+    traversal.manifest["payloads"][3]["path"] = json!("../physics.json");
+    traversal.write_manifest();
+    let error = VerifiedArtifact::open(&traversal.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Security);
+
+    let mut duplicate = TestArtifact::new();
+    duplicate.manifest["payloads"][1]["path"] = json!("requested.toml");
+    duplicate.write_manifest();
+    let error = VerifiedArtifact::open(&duplicate.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Security);
+    assert!(error.to_string().contains("duplicate"));
+}
+
+#[test]
+fn payload_size_is_checked_when_payload_is_read() {
+    let artifact = TestArtifact::new();
+    fs::write(artifact.root.join("physics.json"), b"tampered").unwrap();
+
+    let opened = VerifiedArtifact::open(&artifact.root).expect("open trusted manifest");
+    let error = opened.read_payload("physics.json").unwrap_err();
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("size"));
+}
+
+#[test]
+fn manifest_preflight_runs_without_payload_verification() {
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["processes"][0]["required_runtime_capabilities"] =
+        json!(["symbolica.compiled-cpp.complex-f64.v1"]);
+    artifact.manifest["runtime"]["required_runtime_capabilities"] =
+        json!(["symbolica.compiled-cpp.complex-f64.v1"]);
+    artifact.write_manifest();
+    fs::write(artifact.root.join("physics.json"), b"tampered").unwrap();
+
+    let error = VerifiedArtifact::open_with_manifest_preflight(&artifact.root, |manifest| {
+        assert_eq!(
+            manifest.runtime.required_runtime_capabilities,
+            ["symbolica.compiled-cpp.complex-f64.v1"]
+        );
+        Err(RusticolError::unsupported_runtime_capability(
+            &manifest.runtime.required_runtime_capabilities[0],
+            "test runtime supports direct SymJIT only",
+        ))
+    })
+    .unwrap_err();
+
+    assert_eq!(
+        error.kind(),
+        crate::RusticolErrorKind::UnsupportedRuntimeCapability
+    );
+}
+
+#[test]
+fn process_capabilities_are_strict_and_form_the_runtime_union() {
+    for (capabilities, message) in [
+        (json!([]), "at least one"),
+        (
+            json!([
+                "symjit.application.complex-f64.v1",
+                "symjit.application.complex-f64.v1"
+            ]),
+            "duplicates",
+        ),
+        (
+            json!([
+                "symjit.application.complex-f64.v1",
+                "symbolica.compiled-cpp.complex-f64.v1"
+            ]),
+            "sorted",
+        ),
+    ] {
+        let mut artifact = TestArtifact::new();
+        artifact.manifest["processes"][0]["required_runtime_capabilities"] = capabilities.clone();
+        artifact.manifest["runtime"]["required_runtime_capabilities"] = capabilities;
+        artifact.write_manifest();
+
+        let error = VerifiedArtifact::open(&artifact.root).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+        assert!(error.to_string().contains(message), "{error}");
+    }
+
+    let mut mismatch = TestArtifact::new();
+    mismatch.manifest["runtime"]["required_runtime_capabilities"] =
+        json!(["symbolica.compiled-cpp.complex-f64.v1"]);
+    mismatch.write_manifest();
+    let error = VerifiedArtifact::open(&mismatch.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("union"));
+
+    let mut mixed = TestArtifact::new();
+    mixed.manifest["kind"] = json!("pyamplicol-process-set");
+    mixed.manifest["processes"]
+        .as_array_mut()
+        .unwrap()
+        .push(json!({
+            "id": "p1",
+            "expression": "a b > d",
+            "color_accuracy": "lc",
+            "external_pdgs": [1, -1, 23],
+            "physics_path": "physics.json",
+            "required_runtime_capabilities": [
+                "symbolica.compiled-cpp.complex-f64.v1"
+            ],
+            "aliases": [],
+        }));
+    mixed.manifest["runtime"]["required_runtime_capabilities"] = json!([
+        "symbolica.compiled-cpp.complex-f64.v1",
+        "symjit.application.complex-f64.v1"
+    ]);
+    let parsed: ArtifactManifest =
+        serde_json::from_value(mixed.manifest.clone()).expect("parse mixed manifest");
+    validate_manifest(&parsed).expect("mixed process capability union validates");
+}
+
+#[test]
+fn on_the_fly_fft_capabilities_are_known_and_the_catalog_remains_closed() {
+    let capabilities = json!([
+        crate::engine::SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+        "rusticol.on-the-fly.complex-f64.v1",
+        "rusticol.on-the-fly.contracted-color.v1",
+        "rusticol.on-the-fly.lc-color.v1"
+    ]);
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["processes"][0]["required_runtime_capabilities"] = capabilities.clone();
+    artifact.manifest["runtime"]["required_runtime_capabilities"] = capabilities;
+    artifact.write_manifest();
+
+    VerifiedArtifact::open(&artifact.root)
+        .expect("on-the-fly capabilities pass outer artifact validation");
+
+    let unknown = json!(["rusticol.on-the-fly.unknown.v1"]);
+    artifact.manifest["processes"][0]["required_runtime_capabilities"] = unknown.clone();
+    artifact.manifest["runtime"]["required_runtime_capabilities"] = unknown;
+    artifact.write_manifest();
+
+    let error = VerifiedArtifact::open(&artifact.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(
+        error.to_string().contains("unsupported capabilities"),
+        "{error}"
+    );
+}
+
+#[test]
+fn recurrence_capabilities_are_part_of_the_outer_artifact_catalog() {
+    let capabilities = json!([
+        "rusticol.recurrence-color.lc.v1",
+        "rusticol.recurrence-direct-arena.complex-f64.v1"
+    ]);
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["processes"][0]["required_runtime_capabilities"] = capabilities.clone();
+    artifact.manifest["runtime"]["required_runtime_capabilities"] = capabilities;
+    artifact.write_manifest();
+
+    VerifiedArtifact::open(&artifact.root)
+        .expect("recurrence capabilities pass outer artifact validation");
+}
+
+#[cfg(all(
+    feature = "f64-symjit",
+    not(feature = "f64-compiled"),
+    not(feature = "symbolica-runtime")
+))]
+#[test]
+fn selected_unsupported_process_capability_preflights_before_payloads() {
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["processes"][0]["required_runtime_capabilities"] =
+        json!(["symbolica.compiled-cpp.complex-f64.v1"]);
+    artifact.manifest["runtime"]["required_runtime_capabilities"] =
+        json!(["symbolica.compiled-cpp.complex-f64.v1"]);
+    artifact.write_manifest();
+    fs::write(artifact.root.join("physics.json"), b"tampered").unwrap();
+
+    let error = match crate::NativeRuntime::load(&artifact.root, Some("p0"), None) {
+        Ok(_) => panic!("unsupported selected process unexpectedly loaded"),
+        Err(error) => error,
+    };
+
+    assert_eq!(
+        error.kind(),
+        crate::RusticolErrorKind::UnsupportedRuntimeCapability
+    );
+    assert!(error.to_string().contains("compiled-cpp"));
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn mixed_backend_process_set_loads_selected_direct_symjit_process() {
+    let artifact = mixed_backend_runtime_artifact();
+
+    let runtime = crate::NativeRuntime::load(&artifact.root, Some("direct"), None)
+        .expect("selected direct-SymJIT process loads despite unselected C++/ASM processes");
+
+    assert_eq!(runtime.metadata().process_key, "direct");
+    assert_eq!(runtime.metadata().external_pdg_order, vec![1, -1, 22]);
+}
+
+#[cfg(all(
+    feature = "f64-symjit",
+    not(feature = "f64-compiled"),
+    not(feature = "symbolica-runtime")
+))]
+#[test]
+fn mixed_backend_process_set_rejects_unsupported_selection_before_tampered_payload() {
+    let artifact = mixed_backend_runtime_artifact();
+    fs::write(
+        artifact.root.join("processes/direct/physics.json"),
+        b"tampered after manifest creation",
+    )
+    .unwrap();
+
+    for (process_id, capability) in [("asm", "compiled-asm"), ("cpp", "compiled-cpp")] {
+        let error = match crate::NativeRuntime::load(&artifact.root, Some(process_id), None) {
+            Ok(_) => panic!("unsupported selected {process_id} process unexpectedly loaded"),
+            Err(error) => error,
+        };
+
+        assert_eq!(
+            error.kind(),
+            crate::RusticolErrorKind::UnsupportedRuntimeCapability
+        );
+        assert!(error.to_string().contains(capability));
+    }
+}
+
+#[test]
+fn required_nullable_and_target_fields_remain_strict() {
+    let mut missing_nullable = TestArtifact::new();
+    missing_nullable.manifest["runtime"]
+        .as_object_mut()
+        .unwrap()
+        .remove("api_bundle_path");
+    missing_nullable.write_manifest();
+    let error = VerifiedArtifact::open(&missing_nullable.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("api_bundle_path"));
+
+    let mut missing_target = TestArtifact::new();
+    let state = b"serialized state";
+    fs::write(missing_target.root.join("state.bin"), state).unwrap();
+    missing_target.manifest["payloads"]
+        .as_array_mut()
+        .unwrap()
+        .push(json!({
+            "path": "state.bin",
+            "role": "evaluator-state",
+            "media_type": "application/octet-stream",
+            "size_bytes": state.len(),
+            "sha256": sha256(state),
+            "executable": false,
+        }));
+    missing_target.write_manifest();
+    let error = VerifiedArtifact::open(&missing_target.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("target"));
+}
+
+#[test]
+fn clean_source_structural_proof_payload_roundtrips_with_exact_declaration() {
+    let mut valid = TestArtifact::new();
+    valid.manifest["producer"]["git_revision"] = json!("a".repeat(40));
+    valid.manifest["producer"]["native_build_inputs_sha256"] = json!("b".repeat(64));
+    add_structural_source_proof(&mut valid);
+    let verified = VerifiedArtifact::open(&valid.root).expect("valid structural proof artifact");
+    assert_eq!(
+        verified.manifest.producer.git_revision.as_deref(),
+        Some("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+    );
+    assert_eq!(
+        verified
+            .manifest
+            .producer
+            .native_build_inputs_sha256
+            .as_deref(),
+        Some("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
+    );
+    let payload = verified
+        .payloads
+        .get("processes/p0/structural-source-proof.json")
+        .expect("verified structural proof payload");
+    assert_eq!(payload.role, PayloadRole::StructuralSourceProof);
+    assert_eq!(payload.media_type, "application/json");
+    assert_eq!(payload.process_id.as_deref(), Some("p0"));
+    assert!(payload.target.is_none());
+
+    for (field, value, message) in [
+        ("path", json!("structural-source-proof.json"), "exact path"),
+        (
+            "media_type",
+            json!("application/octet-stream"),
+            "media type",
+        ),
+        ("process_id", json!("missing"), "unknown process"),
+        (
+            "target",
+            json!({"triple": current_target_triple(), "cpu_features": []}),
+            "target metadata",
+        ),
+    ] {
+        let mut malformed = TestArtifact::new();
+        add_structural_source_proof(&mut malformed);
+        {
+            let payload = malformed.manifest["payloads"]
+                .as_array_mut()
+                .expect("payload array")
+                .last_mut()
+                .expect("structural proof payload");
+            payload[field] = value;
+            if field == "process_id" {
+                payload["path"] = json!("processes/missing/structural-source-proof.json");
+            }
+        }
+        if field == "process_id" {
+            let destination = malformed
+                .root
+                .join("processes/missing/structural-source-proof.json");
+            fs::create_dir_all(destination.parent().expect("structural proof parent"))
+                .expect("create structural proof parent");
+            fs::rename(
+                malformed
+                    .root
+                    .join("processes/p0/structural-source-proof.json"),
+                destination,
+            )
+            .expect("move structural proof to its exact declaration");
+        }
+        malformed.write_manifest();
+        let error = VerifiedArtifact::open(&malformed.root).unwrap_err();
+        assert!(
+            error.to_string().contains(message),
+            "{field} rejection did not mention {message:?}: {error}"
+        );
+    }
+
+    let mut missing_process = TestArtifact::new();
+    add_structural_source_proof(&mut missing_process);
+    missing_process.manifest["payloads"]
+        .as_array_mut()
+        .expect("payload array")
+        .last_mut()
+        .expect("structural proof payload")
+        .as_object_mut()
+        .expect("payload object")
+        .remove("process_id");
+    missing_process.write_manifest();
+    let error = VerifiedArtifact::open(&missing_process.root).unwrap_err();
+    assert!(error.to_string().contains("required process id"));
+
+    let mut malformed_native_identity = TestArtifact::new();
+    malformed_native_identity.manifest["producer"]["git_revision"] = json!("a".repeat(40));
+    malformed_native_identity.manifest["producer"]["native_build_inputs_sha256"] =
+        json!("not-a-sha256");
+    malformed_native_identity.write_manifest();
+    let error = VerifiedArtifact::open(&malformed_native_identity.root).unwrap_err();
+    assert!(
+        error
+            .to_string()
+            .contains("producer.native_build_inputs_sha256")
+    );
+
+    let mut native_identity_without_revision = TestArtifact::new();
+    native_identity_without_revision.manifest["producer"]["native_build_inputs_sha256"] =
+        json!("b".repeat(64));
+    native_identity_without_revision.write_manifest();
+    let verified = VerifiedArtifact::open(&native_identity_without_revision.root)
+        .expect("native build-input identity is valid without a source revision");
+    assert_eq!(verified.manifest.producer.git_revision, None);
+    assert_eq!(
+        verified
+            .manifest
+            .producer
+            .native_build_inputs_sha256
+            .as_deref(),
+        Some("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
+    );
+}
+
+#[test]
+fn producer_and_payload_cpu_features_are_checked() {
+    let mut unavailable = TestArtifact::new();
+    unavailable.manifest["producer"]["target"]["cpu_features"] =
+        json!(["definitely-not-a-real-cpu-feature"]);
+    unavailable.write_manifest();
+    fs::write(unavailable.root.join("physics.json"), b"tampered payload").unwrap();
+    let error = VerifiedArtifact::open(&unavailable.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+    assert!(error.to_string().contains("CPU feature"));
+
+    let mut mismatch = TestArtifact::new();
+    mismatch.manifest["payloads"][2]["target"] = json!({
+        "triple": current_target_triple(),
+        "cpu_features": ["baseline"],
+    });
+    mismatch.write_manifest();
+    let error = VerifiedArtifact::open(&mismatch.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+    assert!(
+        error
+            .to_string()
+            .contains("do not match producer CPU features")
+    );
+}
+
+#[test]
+fn portable_64le_target_accepts_only_feature_free_symjit_artifacts() {
+    let mut portable = TestArtifact::new();
+    portable.manifest["producer"]["target"] = json!({
+        "triple": PORTABLE_64LE_ARTIFACT_TARGET,
+        "cpu_features": [],
+    });
+    portable.write_manifest();
+    VerifiedArtifact::open(&portable.root).expect("portable O2 SymJIT target");
+
+    let mut feature_bound = TestArtifact::new();
+    feature_bound.manifest["producer"]["target"] = json!({
+        "triple": PORTABLE_64LE_ARTIFACT_TARGET,
+        "cpu_features": ["avx2"],
+    });
+    feature_bound.write_manifest();
+    let error = VerifiedArtifact::open(&feature_bound.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+    assert!(error.to_string().contains("must not require CPU features"));
+
+    for capability in [
+        RuntimeCapability::SymbolicaLegacyJitContainerComplexF64V1.as_str(),
+        RuntimeCapability::SymbolicaCompiledCppComplexF64V1.as_str(),
+        RuntimeCapability::SymbolicaCompiledAsmComplexF64V1.as_str(),
+    ] {
+        let mut target_specific = TestArtifact::new();
+        target_specific.manifest["producer"]["target"] = json!({
+            "triple": PORTABLE_64LE_ARTIFACT_TARGET,
+            "cpu_features": [],
+        });
+        target_specific.manifest["runtime"]["required_runtime_capabilities"] = json!([capability]);
+        target_specific.manifest["processes"][0]["required_runtime_capabilities"] =
+            json!([capability]);
+        target_specific.write_manifest();
+        let error = VerifiedArtifact::open(&target_specific.root).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.to_string().contains("remain target-specific"));
+    }
+
+    for capability in [
+        RuntimeCapability::EagerDirectArenaV1.as_str(),
+        RuntimeCapability::RecurrenceRuntimeComplexF64V1.as_str(),
+    ] {
+        let mut direct = TestArtifact::new();
+        direct.manifest["producer"]["target"] = json!({
+            "triple": PORTABLE_64LE_ARTIFACT_TARGET,
+            "cpu_features": [],
+        });
+        direct.manifest["runtime"]["required_runtime_capabilities"] = json!([capability]);
+        direct.manifest["processes"][0]["required_runtime_capabilities"] = json!([capability]);
+        direct.write_manifest();
+        VerifiedArtifact::open(&direct.root)
+            .expect("portable eager/recurrence outer capability is pack-authenticated later");
+    }
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn packaged_portable_64le_o2_artifact_loads_through_native_runtime() {
+    let source = PathBuf::from(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/../../../src/pyamplicol/assets/selftest/portable-64le/artifact"
+    ));
+    let mut staged = TestArtifact::new();
+    fs::remove_dir_all(&staged.root).expect("remove synthetic test artifact");
+    copy_test_artifact_tree(&source, &staged.root);
+    staged.manifest = serde_json::from_slice(
+        &fs::read(staged.root.join(ARTIFACT_MANIFEST_FILE)).expect("read portable manifest"),
+    )
+    .expect("parse portable manifest");
+    let source_artifact_id = staged.manifest["artifact_id"].clone();
+    staged.manifest["producer"]["version"] = json!(env!("CARGO_PKG_VERSION"));
+    staged.manifest["runtime"]["engine_version"] = json!(env!("CARGO_PKG_VERSION"));
+    staged.write_manifest();
+    assert_eq!(staged.manifest["artifact_id"], source_artifact_id);
+
+    let artifact =
+        VerifiedArtifact::open(&staged.root).expect("open staged portable source artifact");
+    assert_eq!(
+        artifact.manifest().producer.target.triple,
+        PORTABLE_64LE_ARTIFACT_TARGET
+    );
+
+    let runtime = crate::NativeRuntime::load(&staged.root, Some("d_dbar_to_z"), None)
+        .expect("load portable O2 artifact through the authoritative runtime");
+    assert_eq!(runtime.metadata().execution_mode, "compiled");
+}
+
+#[cfg(feature = "f64-symjit")]
+fn copy_test_artifact_tree(source: &Path, destination: &Path) {
+    fs::create_dir(destination).expect("create staged portable artifact");
+    for entry in fs::read_dir(source).expect("read portable artifact tree") {
+        let entry = entry.expect("read portable artifact entry");
+        let source_path = entry.path();
+        let destination_path = destination.join(entry.file_name());
+        let file_type = entry.file_type().expect("read portable artifact file type");
+        if file_type.is_dir() {
+            copy_test_artifact_tree(&source_path, &destination_path);
+        } else {
+            assert!(file_type.is_file(), "portable artifact contains a symlink");
+            fs::copy(&source_path, &destination_path).expect("copy portable artifact payload");
+        }
+    }
+}
+
+#[test]
+fn target_metadata_requires_canonical_sorted_cpu_features() {
+    let target = runtime_target_info();
+    assert_eq!(target.triple, current_target_triple());
+    assert!(target.cpu_features.windows(2).all(|pair| pair[0] < pair[1]));
+    validate_target(&target, "runtime target").expect("runtime target validates");
+
+    let mut unsorted = TestArtifact::new();
+    unsorted.manifest["producer"]["target"]["cpu_features"] = json!(["z-feature", "a-feature"]);
+    unsorted.write_manifest();
+    let error = VerifiedArtifact::open(&unsorted.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("sorted and unique"));
+
+    let mut noncanonical = TestArtifact::new();
+    noncanonical.manifest["producer"]["target"]["cpu_features"] = json!(["+avx2"]);
+    noncanonical.write_manifest();
+    let error = VerifiedArtifact::open(&noncanonical.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("canonical feature ID"));
+}
+
+#[test]
+fn malformed_timestamp_and_crossing_alias_are_rejected() {
+    let mut timestamp = TestArtifact::new();
+    timestamp.manifest["created_utc"] = json!("2026-02-30T25:00:00Z");
+    timestamp.write_manifest();
+    let error = VerifiedArtifact::open(&timestamp.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+
+    let mut alias = TestArtifact::new();
+    alias.manifest["processes"][0]["aliases"] = json!([{
+        "id": "alias0",
+        "expression": "b a > c",
+        "external_pdgs": [-1, 1, 22],
+        "external_permutation": [1, 0, 2],
+    }]);
+    alias.write_manifest();
+    VerifiedArtifact::open(&alias.root)
+        .expect("incoming particles may be permuted within their side");
+
+    alias.manifest["processes"][0]["aliases"] = json!([{
+        "id": "alias0",
+        "expression": "a c > b",
+        "external_pdgs": [1, 22, -1],
+        "external_permutation": [0, 2, 1],
+    }]);
+    alias.write_manifest();
+    let error = VerifiedArtifact::open(&alias.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("incoming and outgoing sides"));
+}
+
+#[test]
+fn concrete_process_expression_infers_a_deterministic_side_preserving_permutation() {
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["processes"][0]["expression"] = json!("d d~ > z g g");
+    artifact.manifest["processes"][0]["external_pdgs"] = json!([1, -1, 23, 21, 21]);
+    artifact.write_manifest();
+
+    let verified = VerifiedArtifact::open(&artifact.root).unwrap();
+    let selection = verified
+        .select_process(Some(" d~   d > g z g "))
+        .expect("unique permutation-equivalent expression");
+    assert_eq!(selection.requested_id, "p0");
+    assert!(selection.alias.is_none());
+    assert!(selection.inferred_permutation);
+    assert_eq!(selection.public_expression, "d~ d > g z g");
+    assert_eq!(selection.external_permutation, [1, 0, 3, 2, 4]);
+    assert_eq!(selection.external_pdgs, [-1, 1, 21, 23, 21]);
+
+    let crossing = verified.select_process(Some("d z > d~ g g")).unwrap_err();
+    assert_eq!(crossing.kind(), crate::RusticolErrorKind::Selector);
+    assert!(crossing.to_string().contains("across the '>' boundary"));
+}
+
+#[test]
+fn inferred_expression_prefers_the_least_reordered_representative() {
+    let artifact = TestArtifact::new();
+    let mut manifest: ArtifactManifest = serde_json::from_value(artifact.manifest.clone()).unwrap();
+    manifest.processes[0].expression = "d d~ > z g g".to_string();
+    manifest.processes[0].external_pdgs = vec![1, -1, 23, 21, 21];
+    let mut reversed = manifest.processes[0].clone();
+    reversed.id = "p1".to_string();
+    reversed.expression = "d~ d > z g g".to_string();
+    reversed.external_pdgs = vec![-1, 1, 23, 21, 21];
+    manifest.processes.push(reversed);
+
+    let forward = manifest.select_process(Some("d d~ > g z g")).unwrap();
+    assert_eq!(forward.process.id, "p0");
+    assert_eq!(forward.external_permutation, [0, 1, 3, 2, 4]);
+
+    let reversed = manifest.select_process(Some("d~ d > g z g")).unwrap();
+    assert_eq!(reversed.process.id, "p1");
+    assert_eq!(reversed.external_permutation, [0, 1, 3, 2, 4]);
+}
+
+#[test]
+fn exact_representative_expression_precedes_an_equal_alias_expression() {
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["processes"][0]["aliases"] = json!([{
+        "id": "same-expression-alias",
+        "expression": "a b > c",
+        "external_pdgs": [1, -1, 22],
+        "external_permutation": [0, 1, 2],
+    }]);
+    artifact.write_manifest();
+
+    let verified = VerifiedArtifact::open(&artifact.root).unwrap();
+    let selection = verified.select_process(Some("a b > c")).unwrap();
+
+    assert_eq!(selection.requested_id, "p0");
+    assert!(selection.alias.is_none());
+}
+
+#[test]
+fn inferred_process_expression_fails_on_multiple_representatives() {
+    let artifact = TestArtifact::new();
+    let mut manifest: ArtifactManifest = serde_json::from_value(artifact.manifest.clone()).unwrap();
+    manifest.processes[0].expression = "d d~ > z g g".to_string();
+    manifest.processes[0].external_pdgs = vec![1, -1, 23, 21, 21];
+    let mut duplicate = manifest.processes[0].clone();
+    duplicate.id = "p1".to_string();
+    manifest.processes.push(duplicate);
+
+    let error = manifest.select_process(Some("d d~ > g z g")).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Selector);
+    assert!(error.to_string().contains("permutation-ambiguous"));
+    assert!(error.to_string().contains("p0, p1"));
+}
+
+#[test]
+fn non_self_inverse_alias_pdg_order_is_verified() {
+    let mut valid = TestArtifact::new();
+    valid.manifest["processes"][0]["expression"] = json!("d d~ > z g a");
+    valid.manifest["processes"][0]["external_pdgs"] = json!([1, -1, 23, 21, 22]);
+    valid.manifest["processes"][0]["aliases"] = json!([{
+        "id": "cycled",
+        "expression": "d d~ > a z g",
+        "external_pdgs": [1, -1, 22, 23, 21],
+        "external_permutation": [0, 1, 3, 4, 2],
+    }]);
+    valid.write_manifest();
+
+    let verified = VerifiedArtifact::open(&valid.root).expect("valid three-cycle alias");
+    let selected = verified
+        .select_process(Some("cycled"))
+        .expect("select three-cycle alias");
+    assert_eq!(
+        selected.process.required_runtime_capabilities,
+        ["symjit.application.complex-f64.v1"]
+    );
+    assert_eq!(
+        selected.alias.expect("alias metadata").external_pdgs,
+        vec![1, -1, 22, 23, 21]
+    );
+    let selected_by_expression = verified
+        .select_process(Some("d   d~ > a z g"))
+        .expect("select three-cycle alias by expression");
+    assert_eq!(selected_by_expression.requested_id, "cycled");
+    assert_eq!(
+        selected_by_expression
+            .alias
+            .expect("alias metadata selected by expression")
+            .external_pdgs,
+        vec![1, -1, 22, 23, 21]
+    );
+
+    let mut inconsistent = TestArtifact::new();
+    inconsistent.manifest["processes"][0]["expression"] = json!("d d~ > z g a");
+    inconsistent.manifest["processes"][0]["external_pdgs"] = json!([1, -1, 23, 21, 22]);
+    inconsistent.manifest["processes"][0]["aliases"] = json!([{
+        "id": "cycled",
+        "expression": "d d~ > a z g",
+        "external_pdgs": [1, -1, 21, 23, 22],
+        "external_permutation": [0, 1, 3, 4, 2],
+    }]);
+    inconsistent.write_manifest();
+
+    let error = VerifiedArtifact::open(&inconsistent.root).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(
+        error
+            .to_string()
+            .contains("does not match external_permutation")
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn referenced_symlink_payload_is_rejected_when_read() {
+    use std::os::unix::fs::symlink;
+
+    let artifact = TestArtifact::new();
+    fs::rename(
+        artifact.root.join("physics.json"),
+        artifact.root.join("physics-target.json"),
+    )
+    .unwrap();
+    symlink("physics-target.json", artifact.root.join("physics.json")).unwrap();
+
+    let opened = VerifiedArtifact::open(&artifact.root).expect("open trusted manifest");
+    let error = opened.read_payload("physics.json").unwrap_err();
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Security);
+    assert!(error.to_string().contains("symlink"));
+}
+
+#[cfg(unix)]
+#[test]
+fn undeclared_tree_entries_are_ignored_for_trusted_artifacts() {
+    use std::os::unix::fs::{PermissionsExt, symlink};
+
+    let symlink_artifact = TestArtifact::new();
+    fs::create_dir(symlink_artifact.root.join("extra")).unwrap();
+    symlink(
+        "../physics.json",
+        symlink_artifact.root.join("extra/undeclared-link"),
+    )
+    .unwrap();
+    VerifiedArtifact::open(&symlink_artifact.root).expect("ignore undeclared symlink");
+
+    let executable_artifact = TestArtifact::new();
+    let executable = executable_artifact.root.join("undeclared-tool");
+    fs::write(&executable, b"#!/bin/sh\n").unwrap();
+    let mut permissions = fs::metadata(&executable).unwrap().permissions();
+    permissions.set_mode(0o755);
+    fs::set_permissions(&executable, permissions).unwrap();
+    VerifiedArtifact::open(&executable_artifact.root).expect("ignore undeclared executable");
+}
+
+fn process_group_member(
+    process_id: &str,
+    process: &str,
+    pdgs: Value,
+    permutation: Value,
+    factor: (i64, i64),
+    conjugated: bool,
+) -> Value {
+    json!({
+        "process_id": process_id,
+        "process": process,
+        "pdgs": pdgs,
+        "initial_count": 2,
+        "factor": {"numerator": factor.0, "denominator": factor.1},
+        "permutation": permutation,
+        "conjugated": conjugated,
+        "basis": "flavor-blind",
+        "generated": false,
+    })
+}
+
+fn process_groups_document(members: Vec<Value>) -> Value {
+    let mut all_members = vec![json!({
+        "process_id": "p0",
+        "process": "d d~ > a g",
+        "pdgs": [1, -1, 22, 21],
+        "initial_count": 2,
+        "factor": {"numerator": 1, "denominator": 1},
+        "permutation": [0, 1, 2, 3],
+        "conjugated": false,
+        "basis": "identity",
+        "generated": true,
+    })];
+    all_members.extend(members);
+    json!({
+        "kind": "pyamplicol-process-groups",
+        "schema_version": 1,
+        "analyses": [{"kind": "future-analysis", "anything": [1, 2]}],
+        "groups": [{
+            "representative": {"process_id": "p0", "process": "d d~ > a g"},
+            "members": all_members,
+        }],
+    })
+}
+
+fn process_group_artifact(document: &Value) -> TestArtifact {
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["processes"][0]["expression"] = json!("d d~ > a g");
+    artifact.manifest["processes"][0]["external_pdgs"] = json!([1, -1, 22, 21]);
+    let bytes = serde_json::to_vec_pretty(document).expect("serialize process groups");
+    add_test_payload(
+        &mut artifact,
+        "process-groups.json",
+        "process-groups",
+        &bytes,
+        None,
+        false,
+    );
+    artifact.write_manifest();
+    artifact
+}
+
+fn default_process_groups() -> Value {
+    process_groups_document(vec![
+        process_group_member(
+            "u_ubar_flipped",
+            "u~ u > a g",
+            json!([-2, 2, 22, 21]),
+            json!([1, 0, 2, 3]),
+            (8, 2),
+            false,
+        ),
+        json!({
+            "process_id": "s_sbar_conjugate",
+            "process": "s s~ > a g",
+            "pdgs": [3, -3, 22, 21],
+            "initial_count": 2,
+            "factor": {"numerator": 1, "denominator": 1},
+            "permutation": [1, 0, 2, 3],
+            "conjugated": true,
+            "basis": "numerical",
+            "generated": false,
+            "warning": "assumed, not verified",
+            "future_key": {"ignored": true},
+        }),
+    ])
+}
+
+#[test]
+fn process_group_members_route_to_their_representative() {
+    let artifact = process_group_artifact(&default_process_groups());
+    let verified = VerifiedArtifact::open(&artifact.root).unwrap();
+
+    let by_id = verified.select_process(Some("u_ubar_flipped")).unwrap();
+    assert_eq!(by_id.process.id, "p0");
+    assert_eq!(by_id.requested_id, "u_ubar_flipped");
+    assert!(by_id.alias.is_none());
+    assert!(!by_id.inferred_permutation);
+    assert!(by_id.remaps_public_process());
+    assert_eq!(by_id.public_expression, "u~ u > a g");
+    assert_eq!(by_id.external_pdgs, [-2, 2, 22, 21]);
+    assert_eq!(by_id.external_permutation, [1, 0, 2, 3]);
+    let relation = by_id
+        .process_group
+        .as_ref()
+        .expect("process-group relation");
+    assert_eq!(
+        (relation.factor_numerator, relation.factor_denominator),
+        (4, 1)
+    );
+    assert!(!relation.conjugated);
+    assert!(!relation.has_unit_factor());
+    assert_eq!(relation.external_particles, ["u~", "u", "a", "g"]);
+
+    let by_expression = verified.select_process(Some(" U~   u > A g ")).unwrap();
+    assert_eq!(by_expression.requested_id, "u_ubar_flipped");
+    assert_eq!(by_expression.external_permutation, [1, 0, 2, 3]);
+    assert!(!by_expression.inferred_permutation);
+
+    // Requested public order <- member order <- representative order.
+    let permuted = verified.select_process(Some("u~ u > g a")).unwrap();
+    assert_eq!(permuted.requested_id, "u_ubar_flipped");
+    assert!(permuted.inferred_permutation);
+    assert_eq!(permuted.public_expression, "u~ u > g a");
+    assert_eq!(permuted.external_pdgs, [-2, 2, 21, 22]);
+    assert_eq!(permuted.external_permutation, [1, 0, 3, 2]);
+    assert_eq!(
+        permuted.process_group.expect("relation").external_particles,
+        ["u~", "u", "g", "a"]
+    );
+
+    let swapped = verified.select_process(Some("u u~ > a g")).unwrap();
+    assert_eq!(swapped.external_permutation, [0, 1, 2, 3]);
+    assert_eq!(swapped.external_pdgs, [2, -2, 22, 21]);
+
+    let conjugate = verified.select_process(Some("s~ s > g a")).unwrap();
+    assert_eq!(conjugate.requested_id, "s_sbar_conjugate");
+    assert_eq!(conjugate.external_permutation, [0, 1, 3, 2]);
+    assert_eq!(conjugate.external_pdgs, [-3, 3, 21, 22]);
+    let relation = conjugate.process_group.expect("conjugate relation");
+    assert!(relation.conjugated);
+    assert!(relation.has_unit_factor());
+
+    // Stored processes keep precedence and never carry a relation.
+    let stored = verified.select_process(Some("d~ d > g a")).unwrap();
+    assert_eq!(stored.requested_id, "p0");
+    assert!(stored.process_group.is_none());
+    assert_eq!(stored.external_permutation, [1, 0, 3, 2]);
+
+    let unknown = verified.select_process(Some("c c~ > a g")).unwrap_err();
+    assert_eq!(unknown.kind(), crate::RusticolErrorKind::Selector);
+    let crossing = verified.select_process(Some("u~ a > u g")).unwrap_err();
+    assert_eq!(crossing.kind(), crate::RusticolErrorKind::Selector);
+}
+
+#[test]
+fn process_group_member_permutation_composes_through_member_order() {
+    // Three final-state legs make side permutations non-commuting, so only
+    // `public[member[r]]` puts the representative photon on the requested one.
+    let mut document = process_groups_document(vec![process_group_member(
+        "u_ubar_member",
+        "u~ u > g a g",
+        json!([-2, 2, 21, 22, 21]),
+        json!([1, 0, 3, 2, 4]),
+        (4, 1),
+        false,
+    )]);
+    document["groups"][0]["representative"]["process"] = json!("d d~ > a g g");
+    let representative = &mut document["groups"][0]["members"][0];
+    representative["process"] = json!("d d~ > a g g");
+    representative["pdgs"] = json!([1, -1, 22, 21, 21]);
+    representative["permutation"] = json!([0, 1, 2, 3, 4]);
+    let mut artifact = TestArtifact::new();
+    artifact.manifest["processes"][0]["expression"] = json!("d d~ > a g g");
+    artifact.manifest["processes"][0]["external_pdgs"] = json!([1, -1, 22, 21, 21]);
+    let bytes = serde_json::to_vec_pretty(&document).expect("serialize process groups");
+    add_test_payload(
+        &mut artifact,
+        "process-groups.json",
+        "process-groups",
+        &bytes,
+        None,
+        false,
+    );
+    artifact.write_manifest();
+    let verified = VerifiedArtifact::open(&artifact.root).unwrap();
+
+    let selection = verified.select_process(Some("u u~ > g g a")).unwrap();
+    assert_eq!(selection.requested_id, "u_ubar_member");
+    assert_eq!(selection.external_pdgs, [2, -2, 21, 21, 22]);
+    // Representative legs d, d~, a, g, g sit at requested u, u~, a, g, g.
+    assert_eq!(selection.external_permutation, [0, 1, 4, 2, 3]);
+}
+
+#[test]
+fn process_group_map_is_read_only_after_stored_selection_fails() {
+    let mut artifact = process_group_artifact(&default_process_groups());
+    fs::write(
+        artifact.root.join("process-groups.json"),
+        b"{\"tampered\": true}",
+    )
+    .expect("tamper process groups");
+    artifact.write_manifest();
+    let verified = VerifiedArtifact::open(&artifact.root).unwrap();
+
+    assert_eq!(
+        verified.select_process(Some("p0")).unwrap().requested_id,
+        "p0"
+    );
+    assert_eq!(
+        verified
+            .select_process(Some("d d~ > g a"))
+            .unwrap()
+            .requested_id,
+        "p0"
+    );
+    assert_eq!(verified.select_process(None).unwrap().requested_id, "p0");
+    let error = verified.select_process(Some("u_ubar_flipped")).unwrap_err();
+    assert!(matches!(
+        error.kind(),
+        crate::RusticolErrorKind::Integrity | crate::RusticolErrorKind::Artifact
+    ));
+}
+
+#[test]
+fn process_group_payload_digest_is_verified() {
+    let artifact = process_group_artifact(&default_process_groups());
+    let mut document = default_process_groups();
+    document["groups"][0]["members"][1]["factor"]["numerator"] = json!(9);
+    let mut bytes = serde_json::to_vec_pretty(&document).unwrap();
+    let declared = fs::metadata(artifact.root.join("process-groups.json"))
+        .unwrap()
+        .len() as usize;
+    bytes.resize(declared, b' ');
+    fs::write(artifact.root.join("process-groups.json"), &bytes).unwrap();
+
+    let verified = VerifiedArtifact::open(&artifact.root).unwrap();
+    let error = verified.select_process(Some("u_ubar_flipped")).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("sha256"));
+}
+
+#[test]
+fn invalid_process_group_maps_are_rejected() {
+    let member = |permutation: Value, factor: (i64, i64)| {
+        process_groups_document(vec![process_group_member(
+            "u_ubar",
+            "u u~ > a g",
+            json!([2, -2, 22, 21]),
+            permutation,
+            factor,
+            false,
+        )])
+    };
+    let mut wrong_representative = member(json!([0, 1, 2, 3]), (1, 1));
+    wrong_representative["groups"][0]["representative"]["process_id"] = json!("missing");
+    let mut representative_not_first = member(json!([0, 1, 2, 3]), (1, 1));
+    representative_not_first["groups"][0]["members"]
+        .as_array_mut()
+        .unwrap()
+        .reverse();
+    let mut reused_id = member(json!([0, 1, 2, 3]), (1, 1));
+    reused_id["groups"][0]["members"][1]["process_id"] = json!("p0");
+    let mut wrong_kind = member(json!([0, 1, 2, 3]), (1, 1));
+    wrong_kind["kind"] = json!("something-else");
+    let mut wrong_count = member(json!([0, 1, 2, 3]), (1, 1));
+    wrong_count["groups"][0]["members"][1]["process"] = json!("u > u~ a g");
+    let cases = [
+        (member(json!([2, 1, 0, 3]), (1, 1)), "'>' boundary"),
+        (member(json!([0, 0, 2, 3]), (1, 1)), "complete zero-based"),
+        (member(json!([0, 1, 2]), (1, 1)), "has length 3"),
+        (member(json!([0, 1, 2, 3]), (1, 0)), "positive rational"),
+        (member(json!([0, 1, 2, 3]), (-1, 2)), "positive rational"),
+        (wrong_representative, "not a stored process"),
+        (representative_not_first, "identity relation"),
+        (reused_id, "listed more than once"),
+        (wrong_kind, "unsupported process-groups payload"),
+        (wrong_count, "particle counts"),
+    ];
+    for (document, expected) in cases {
+        let artifact = process_group_artifact(&document);
+        let verified = VerifiedArtifact::open(&artifact.root).unwrap();
+        let error = verified.select_process(Some("u_ubar")).unwrap_err();
+        assert!(
+            error.to_string().contains(expected),
+            "{expected:?} not in {error}"
+        );
+    }
+
+    let mut collision = TestArtifact::new();
+    collision.manifest["processes"][0]["expression"] = json!("d d~ > a g");
+    collision.manifest["processes"][0]["external_pdgs"] = json!([1, -1, 22, 21]);
+    collision.manifest["processes"][0]["aliases"] = json!([{
+        "id": "u_ubar",
+        "expression": "d~ d > a g",
+        "external_pdgs": [-1, 1, 22, 21],
+        "external_permutation": [1, 0, 2, 3],
+    }]);
+    let bytes = serde_json::to_vec(&member(json!([0, 1, 2, 3]), (1, 1))).unwrap();
+    add_test_payload(
+        &mut collision,
+        "process-groups.json",
+        "process-groups",
+        &bytes,
+        None,
+        false,
+    );
+    collision.write_manifest();
+    let verified = VerifiedArtifact::open(&collision.root).unwrap();
+    let error = verified.select_process(Some("u u~ > a g")).unwrap_err();
+    assert!(
+        error
+            .to_string()
+            .contains("reuses a stored process or alias id")
+    );
+}
+
+#[test]
+fn ambiguous_process_group_member_expressions_list_member_ids() {
+    let document = process_groups_document(vec![
+        process_group_member(
+            "first",
+            "u u~ > a g",
+            json!([2, -2, 22, 21]),
+            json!([0, 1, 2, 3]),
+            (4, 1),
+            false,
+        ),
+        process_group_member(
+            "second",
+            "u u~ > a g",
+            json!([2, -2, 22, 21]),
+            json!([0, 1, 2, 3]),
+            (4, 1),
+            false,
+        ),
+    ]);
+    let artifact = process_group_artifact(&document);
+    let verified = VerifiedArtifact::open(&artifact.root).unwrap();
+    let error = verified.select_process(Some("u u~ > a g")).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Selector);
+    assert!(error.to_string().contains("first, second"));
+    assert_eq!(
+        verified
+            .select_process(Some("second"))
+            .unwrap()
+            .requested_id,
+        "second"
+    );
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/direct_arena/abi.rs b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/abi.rs
new file mode 100644
index 0000000000..7c28f854ad
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/abi.rs
@@ -0,0 +1,731 @@
+// SPDX-License-Identifier: 0BSD
+
+//! ABI-stable lane-neutral Direct-Arena views.
+
+use std::mem::{align_of, size_of};
+use std::ops::Range;
+
+use crate::{RusticolError, RusticolResult};
+
+use super::DIRECT_ARENA_ALIGNMENT;
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+/// Shape of one component-major, point-contiguous plane bundle.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct DirectPlaneShape {
+    scalar_len: u64,
+    point_stride: u32,
+}
+
+impl DirectPlaneShape {
+    pub fn new(scalar_len: u64, point_stride: u32, label: &str) -> RusticolResult<Self> {
+        if point_stride == 0 {
+            return Err(invalid(format!(
+                "direct {label} point stride must be positive"
+            )));
+        }
+        if !scalar_len.is_multiple_of(u64::from(point_stride)) {
+            return Err(invalid(format!(
+                "direct {label} scalar length {scalar_len} is not a whole number of \
+                 point-contiguous planes with stride {point_stride}"
+            )));
+        }
+        Ok(Self {
+            scalar_len,
+            point_stride,
+        })
+    }
+
+    pub const fn scalar_len(self) -> u64 {
+        self.scalar_len
+    }
+
+    pub const fn point_stride(self) -> u32 {
+        self.point_stride
+    }
+
+    pub fn component_count(self) -> RusticolResult<u32> {
+        u32::try_from(self.scalar_len / u64::from(self.point_stride))
+            .map_err(|_| invalid("direct plane component count exceeds u32"))
+    }
+
+    pub fn checked_scalar_index(
+        self,
+        component: u32,
+        point: u32,
+        label: &str,
+    ) -> RusticolResult<usize> {
+        if point >= self.point_stride {
+            return Err(invalid(format!(
+                "direct {label} point {point} exceeds stride {}",
+                self.point_stride
+            )));
+        }
+        if component >= self.component_count()? {
+            return Err(invalid(format!(
+                "direct {label} component {component} is out of bounds"
+            )));
+        }
+        let index = u64::from(component)
+            .checked_mul(u64::from(self.point_stride))
+            .and_then(|base| base.checked_add(u64::from(point)))
+            .ok_or_else(|| invalid(format!("direct {label} scalar index overflows u64")))?;
+        usize::try_from(index)
+            .map_err(|_| invalid(format!("direct {label} scalar index exceeds usize")))
+    }
+
+    pub fn checked_component_range(
+        self,
+        component_base: u32,
+        component_count: u32,
+        label: &str,
+    ) -> RusticolResult<Range<usize>> {
+        let component_stop = component_base
+            .checked_add(component_count)
+            .ok_or_else(|| invalid(format!("direct {label} component range overflows u32")))?;
+        if component_stop > self.component_count()? {
+            return Err(invalid(format!(
+                "direct {label} component range {component_base}..{component_stop} is out of bounds"
+            )));
+        }
+        let start = u64::from(component_base)
+            .checked_mul(u64::from(self.point_stride))
+            .ok_or_else(|| invalid(format!("direct {label} scalar range overflows u64")))?;
+        let stop = u64::from(component_stop)
+            .checked_mul(u64::from(self.point_stride))
+            .ok_or_else(|| invalid(format!("direct {label} scalar range overflows u64")))?;
+        Ok(usize::try_from(start)
+            .map_err(|_| invalid(format!("direct {label} scalar range exceeds usize")))?
+            ..usize::try_from(stop)
+                .map_err(|_| invalid(format!("direct {label} scalar range exceeds usize")))?)
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct DirectArenaView {
+    pub current_re: *mut f64,
+    pub current_im: *mut f64,
+    pub current_scalar_len: u64,
+    pub amplitude_re: *mut f64,
+    pub amplitude_im: *mut f64,
+    pub amplitude_scalar_len: u64,
+    /// Physical component-plane pitch, not the semantic active point count.
+    pub point_stride: u32,
+}
+
+impl DirectArenaView {
+    pub fn validate(self) -> RusticolResult<()> {
+        let _ = self.current_shape()?.component_count()?;
+        let _ = self.amplitude_shape()?.component_count()?;
+        if self.current_scalar_len != 0 || self.amplitude_scalar_len != 0 {
+            require_plane_stride_alignment(self.point_stride, "arena")?;
+        }
+        require_split_pair(
+            self.current_re,
+            self.current_im,
+            self.current_scalar_len,
+            "current",
+        )?;
+        require_split_pair(
+            self.amplitude_re,
+            self.amplitude_im,
+            self.amplitude_scalar_len,
+            "amplitude",
+        )?;
+        require_arena_alignment(
+            self.current_re.cast_const(),
+            self.current_scalar_len,
+            "current real",
+        )?;
+        require_arena_alignment(
+            self.current_im.cast_const(),
+            self.current_scalar_len,
+            "current imaginary",
+        )?;
+        require_arena_alignment(
+            self.amplitude_re.cast_const(),
+            self.amplitude_scalar_len,
+            "amplitude real",
+        )?;
+        require_arena_alignment(
+            self.amplitude_im.cast_const(),
+            self.amplitude_scalar_len,
+            "amplitude imaginary",
+        )?;
+        require_disjoint_ranges(&self.mutable_ranges()?)?;
+        Ok(())
+    }
+
+    pub fn current_shape(self) -> RusticolResult<DirectPlaneShape> {
+        DirectPlaneShape::new(self.current_scalar_len, self.point_stride, "current arena")
+    }
+
+    pub fn amplitude_shape(self) -> RusticolResult<DirectPlaneShape> {
+        DirectPlaneShape::new(
+            self.amplitude_scalar_len,
+            self.point_stride,
+            "amplitude arena",
+        )
+    }
+
+    fn mutable_ranges(self) -> RusticolResult<[Option<DeclaredRange>; 4]> {
+        Ok([
+            checked_pointer_range(
+                self.current_re.cast_const(),
+                self.current_scalar_len,
+                "current real",
+            )?,
+            checked_pointer_range(
+                self.current_im.cast_const(),
+                self.current_scalar_len,
+                "current imaginary",
+            )?,
+            checked_pointer_range(
+                self.amplitude_re.cast_const(),
+                self.amplitude_scalar_len,
+                "amplitude real",
+            )?,
+            checked_pointer_range(
+                self.amplitude_im.cast_const(),
+                self.amplitude_scalar_len,
+                "amplitude imaginary",
+            )?,
+        ])
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct DirectMomentumView {
+    pub values: *const f64,
+    pub scalar_len: u64,
+    pub form_count: u32,
+    pub lorentz_component_count: u16,
+    /// Physical component-plane pitch, shared with the arena view.
+    pub point_stride: u32,
+}
+
+impl DirectMomentumView {
+    pub fn validate(self) -> RusticolResult<()> {
+        if self.form_count == 0 || self.lorentz_component_count == 0 {
+            return Err(invalid("direct momentum view has an empty dimension"));
+        }
+        let required = u64::from(self.form_count)
+            .checked_mul(u64::from(self.lorentz_component_count))
+            .and_then(|planes| planes.checked_mul(u64::from(self.point_stride)))
+            .ok_or_else(|| invalid("direct momentum view dimensions overflow u64"))?;
+        let shape = DirectPlaneShape::new(self.scalar_len, self.point_stride, "momentum")?;
+        require_plane_stride_alignment(self.point_stride, "momentum")?;
+        if required != self.scalar_len {
+            return Err(invalid(format!(
+                "direct momentum view requires exactly {required} scalars but exposes {}",
+                self.scalar_len
+            )));
+        }
+        if self.values.is_null() {
+            return Err(invalid("direct momentum view has a null base"));
+        }
+        require_arena_alignment(self.values, self.scalar_len, "momentum")?;
+        if shape.component_count()?
+            != self
+                .form_count
+                .checked_mul(u32::from(self.lorentz_component_count))
+                .ok_or_else(|| invalid("direct momentum plane count overflows u32"))?
+        {
+            return Err(invalid("direct momentum plane shape is inconsistent"));
+        }
+        let _ = checked_pointer_range(self.values, self.scalar_len, "momentum")?;
+        Ok(())
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct DirectParameterView {
+    pub values_re: *const f64,
+    pub values_im: *const f64,
+    pub value_count: u32,
+}
+
+impl DirectParameterView {
+    pub fn validate(self) -> RusticolResult<()> {
+        require_split_pair(
+            self.values_re.cast_mut(),
+            self.values_im.cast_mut(),
+            u64::from(self.value_count),
+            "parameter",
+        )?;
+        require_disjoint_ranges(&[
+            checked_pointer_range(
+                self.values_re,
+                u64::from(self.value_count),
+                "parameter real",
+            )?,
+            checked_pointer_range(
+                self.values_im,
+                u64::from(self.value_count),
+                "parameter imaginary",
+            )?,
+        ])
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct DirectFactorView {
+    pub values_re: *const f64,
+    pub values_im: *const f64,
+    pub value_count: u32,
+}
+
+impl DirectFactorView {
+    pub fn validate(self) -> RusticolResult<()> {
+        require_split_pair(
+            self.values_re.cast_mut(),
+            self.values_im.cast_mut(),
+            u64::from(self.value_count),
+            "factor",
+        )?;
+        require_disjoint_ranges(&[
+            checked_pointer_range(self.values_re, u64::from(self.value_count), "factor real")?,
+            checked_pointer_range(
+                self.values_im,
+                u64::from(self.value_count),
+                "factor imaginary",
+            )?,
+        ])
+    }
+}
+
+/// Validate one complete direct-call descriptor bundle.
+///
+/// Read-only inputs may alias each other, but none may overlap a mutable arena.
+pub fn validate_direct_views(
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+) -> RusticolResult<()> {
+    arena.validate()?;
+    momenta.validate()?;
+    parameters.validate()?;
+    factors.validate()?;
+    if arena.point_stride != momenta.point_stride {
+        return Err(invalid(format!(
+            "direct arena pitch {} does not match momentum pitch {}",
+            arena.point_stride, momenta.point_stride
+        )));
+    }
+
+    let mutable_ranges = arena.mutable_ranges()?;
+    let read_only_ranges = [
+        checked_pointer_range(momenta.values, momenta.scalar_len, "momentum")?,
+        checked_pointer_range(
+            parameters.values_re,
+            u64::from(parameters.value_count),
+            "parameter real",
+        )?,
+        checked_pointer_range(
+            parameters.values_im,
+            u64::from(parameters.value_count),
+            "parameter imaginary",
+        )?,
+        checked_pointer_range(
+            factors.values_re,
+            u64::from(factors.value_count),
+            "factor real",
+        )?,
+        checked_pointer_range(
+            factors.values_im,
+            u64::from(factors.value_count),
+            "factor imaginary",
+        )?,
+    ];
+    for mutable in mutable_ranges.iter().flatten() {
+        for read_only in read_only_ranges.iter().flatten() {
+            if mutable.overlaps(*read_only) {
+                return Err(invalid(format!(
+                    "mutable direct {} range overlaps read-only direct {} range",
+                    mutable.label, read_only.label
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn require_split_pair(
+    values_re: *mut f64,
+    values_im: *mut f64,
+    scalar_len: u64,
+    label: &str,
+) -> RusticolResult<()> {
+    if scalar_len != 0 && (values_re.is_null() || values_im.is_null()) {
+        return Err(invalid(format!(
+            "nonempty direct {label} view has a null split base"
+        )));
+    }
+    Ok(())
+}
+
+fn require_arena_alignment(values: *const f64, scalar_len: u64, label: &str) -> RusticolResult<()> {
+    if scalar_len != 0 && !(values as usize).is_multiple_of(DIRECT_ARENA_ALIGNMENT) {
+        return Err(invalid(format!(
+            "direct {label} base is not {DIRECT_ARENA_ALIGNMENT}-byte aligned"
+        )));
+    }
+    Ok(())
+}
+
+fn require_plane_stride_alignment(point_stride: u32, label: &str) -> RusticolResult<()> {
+    // Packed singleton views are a separate, explicit ABI layout. Every
+    // other pitch must retain per-plane alignment for tiled SIMD execution.
+    if point_stride == 1 {
+        return Ok(());
+    }
+    let stride_bytes = usize::try_from(point_stride)
+        .ok()
+        .and_then(|stride| stride.checked_mul(size_of::<f64>()))
+        .ok_or_else(|| {
+            invalid(format!(
+                "direct {label} point stride byte count overflows usize"
+            ))
+        })?;
+    if !stride_bytes.is_multiple_of(DIRECT_ARENA_ALIGNMENT) {
+        return Err(invalid(format!(
+            "direct {label} point stride does not preserve {DIRECT_ARENA_ALIGNMENT}-byte plane alignment"
+        )));
+    }
+    Ok(())
+}
+
+#[derive(Clone, Copy, Debug)]
+struct DeclaredRange {
+    start: usize,
+    stop: usize,
+    label: &'static str,
+}
+
+impl DeclaredRange {
+    const fn overlaps(self, other: Self) -> bool {
+        self.start < other.stop && other.start < self.stop
+    }
+}
+
+fn checked_pointer_range(
+    values: *const f64,
+    scalar_len: u64,
+    label: &'static str,
+) -> RusticolResult<Option<DeclaredRange>> {
+    if scalar_len == 0 {
+        return Ok(None);
+    }
+    if values.is_null() {
+        return Err(invalid(format!(
+            "nonempty direct {label} range has a null base"
+        )));
+    }
+    let byte_len = usize::try_from(scalar_len)
+        .ok()
+        .and_then(|len| len.checked_mul(size_of::<f64>()))
+        .ok_or_else(|| invalid(format!("direct {label} byte length overflows usize")))?;
+    if byte_len > isize::MAX as usize {
+        return Err(invalid(format!(
+            "direct {label} byte length exceeds isize::MAX"
+        )));
+    }
+    let start = values as usize;
+    if !start.is_multiple_of(align_of::<f64>()) {
+        return Err(invalid(format!(
+            "direct {label} base is not binary64 aligned"
+        )));
+    }
+    let stop = start
+        .checked_add(byte_len)
+        .ok_or_else(|| invalid(format!("direct {label} address range overflows usize")))?;
+    Ok(Some(DeclaredRange { start, stop, label }))
+}
+
+fn require_disjoint_ranges(ranges: &[Option<DeclaredRange>]) -> RusticolResult<()> {
+    for (index, left) in ranges.iter().copied().enumerate() {
+        let Some(left) = left else {
+            continue;
+        };
+        for right in ranges[index + 1..].iter().copied().flatten() {
+            if left.overlaps(right) {
+                return Err(invalid(format!(
+                    "direct {} and {} ranges overlap",
+                    left.label, right.label
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::AlignedF64Buffer;
+    use super::*;
+
+    #[test]
+    fn component_major_shape_checks_projection() {
+        assert!(DirectPlaneShape::new(15, 8, "test").is_err());
+        let shape = DirectPlaneShape::new(24, 8, "test").unwrap();
+        assert_eq!(shape.component_count().unwrap(), 3);
+        assert_eq!(shape.checked_scalar_index(2, 7, "test").unwrap(), 23);
+        assert_eq!(shape.checked_component_range(1, 2, "test").unwrap(), 8..24);
+        assert!(shape.checked_scalar_index(3, 0, "test").is_err());
+        assert!(shape.checked_scalar_index(0, 8, "test").is_err());
+    }
+
+    #[test]
+    fn views_fail_closed_on_aliases_partial_planes_and_unaligned_pitch() {
+        let mut values_re = AlignedF64Buffer::zeroed(24, "test real").unwrap();
+        let mut values_im = AlignedF64Buffer::zeroed(24, "test imag").unwrap();
+        let alias = DirectArenaView {
+            current_re: values_re.as_mut_ptr(),
+            current_im: values_re.as_mut_ptr(),
+            current_scalar_len: 16,
+            amplitude_re: std::ptr::null_mut(),
+            amplitude_im: std::ptr::null_mut(),
+            amplitude_scalar_len: 0,
+            point_stride: 8,
+        };
+        assert!(alias.validate().is_err());
+        let partial = DirectArenaView {
+            current_re: values_re.as_mut_ptr(),
+            current_im: values_im.as_mut_ptr(),
+            current_scalar_len: 15,
+            amplitude_re: std::ptr::null_mut(),
+            amplitude_im: std::ptr::null_mut(),
+            amplitude_scalar_len: 0,
+            point_stride: 8,
+        };
+        assert!(partial.validate().is_err());
+        let bad_pitch = DirectArenaView {
+            current_re: values_re.as_mut_ptr(),
+            current_im: values_im.as_mut_ptr(),
+            current_scalar_len: 6,
+            amplitude_re: std::ptr::null_mut(),
+            amplitude_im: std::ptr::null_mut(),
+            amplitude_scalar_len: 0,
+            point_stride: 3,
+        };
+        assert!(bad_pitch.validate().is_err());
+    }
+
+    #[test]
+    fn packed_singleton_views_are_validated_as_an_explicit_layout() {
+        let mut current_re = AlignedF64Buffer::zeroed(2, "packed current real").unwrap();
+        let mut current_im = AlignedF64Buffer::zeroed(2, "packed current imag").unwrap();
+        DirectArenaView {
+            current_re: current_re.as_mut_ptr(),
+            current_im: current_im.as_mut_ptr(),
+            current_scalar_len: 2,
+            amplitude_re: std::ptr::null_mut(),
+            amplitude_im: std::ptr::null_mut(),
+            amplitude_scalar_len: 0,
+            point_stride: 1,
+        }
+        .validate()
+        .unwrap();
+    }
+
+    #[test]
+    fn complete_bundle_rejects_mutable_read_only_overlap() {
+        let mut current_re = AlignedF64Buffer::zeroed(24, "current real").unwrap();
+        let mut current_im = AlignedF64Buffer::zeroed(24, "current imag").unwrap();
+        let parameters_im = AlignedF64Buffer::zeroed(8, "parameter imag").unwrap();
+        let arena = DirectArenaView {
+            current_re: current_re.as_mut_ptr(),
+            current_im: current_im.as_mut_ptr(),
+            current_scalar_len: 16,
+            amplitude_re: std::ptr::null_mut(),
+            amplitude_im: std::ptr::null_mut(),
+            amplitude_scalar_len: 0,
+            point_stride: 8,
+        };
+        let momenta = DirectMomentumView {
+            values: unsafe { current_re.as_ptr().add(8) },
+            scalar_len: 8,
+            form_count: 1,
+            lorentz_component_count: 1,
+            point_stride: 8,
+        };
+        let parameters = DirectParameterView {
+            values_re: std::ptr::null(),
+            values_im: std::ptr::null(),
+            value_count: 0,
+        };
+        let factors = DirectFactorView {
+            values_re: parameters_im.as_ptr(),
+            values_im: parameters_im.as_ptr(),
+            value_count: 0,
+        };
+        assert!(validate_direct_views(arena, momenta, parameters, factors).is_err());
+    }
+
+    #[test]
+    fn partial_split_range_overlap_is_rejected() {
+        let mut values = AlignedF64Buffer::zeroed(40, "overlap").unwrap();
+        let overlap = DirectArenaView {
+            current_re: values.as_mut_ptr(),
+            current_im: unsafe { values.as_mut_ptr().add(8) },
+            current_scalar_len: 16,
+            amplitude_re: std::ptr::null_mut(),
+            amplitude_im: std::ptr::null_mut(),
+            amplitude_scalar_len: 0,
+            point_stride: 8,
+        };
+        assert!(overlap.validate().is_err());
+        let parameter_overlap = DirectParameterView {
+            values_re: values.as_ptr(),
+            values_im: unsafe { values.as_ptr().add(8) },
+            value_count: 16,
+        };
+        assert!(parameter_overlap.validate().is_err());
+    }
+
+    #[test]
+    fn read_only_inputs_may_share_authenticated_storage() {
+        let mut current_re = AlignedF64Buffer::zeroed(8, "current real").unwrap();
+        let mut current_im = AlignedF64Buffer::zeroed(8, "current imag").unwrap();
+        let momentum = AlignedF64Buffer::zeroed(8, "momentum").unwrap();
+        let shared_re = AlignedF64Buffer::zeroed(8, "shared real").unwrap();
+        let shared_im = AlignedF64Buffer::zeroed(8, "shared imag").unwrap();
+        let arena = DirectArenaView {
+            current_re: current_re.as_mut_ptr(),
+            current_im: current_im.as_mut_ptr(),
+            current_scalar_len: 8,
+            amplitude_re: std::ptr::null_mut(),
+            amplitude_im: std::ptr::null_mut(),
+            amplitude_scalar_len: 0,
+            point_stride: 8,
+        };
+        let momenta = DirectMomentumView {
+            values: momentum.as_ptr(),
+            scalar_len: 8,
+            form_count: 1,
+            lorentz_component_count: 1,
+            point_stride: 8,
+        };
+        let parameters = DirectParameterView {
+            values_re: shared_re.as_ptr(),
+            values_im: shared_im.as_ptr(),
+            value_count: 8,
+        };
+        let factors = DirectFactorView {
+            values_re: shared_re.as_ptr(),
+            values_im: shared_im.as_ptr(),
+            value_count: 8,
+        };
+        validate_direct_views(arena, momenta, parameters, factors).unwrap();
+    }
+
+    #[test]
+    fn empty_views_ignore_pointer_values_while_momentum_dimensions_are_exact() {
+        let unaligned = std::ptr::without_provenance::<f64>(3);
+        let empty = DirectArenaView {
+            current_re: unaligned.cast_mut(),
+            current_im: std::ptr::null_mut(),
+            current_scalar_len: 0,
+            amplitude_re: std::ptr::null_mut(),
+            amplitude_im: unaligned.cast_mut(),
+            amplitude_scalar_len: 0,
+            point_stride: 1,
+        };
+        empty.validate().unwrap();
+
+        let values = AlignedF64Buffer::zeroed(24, "momentum").unwrap();
+        let extra_plane = DirectMomentumView {
+            values: values.as_ptr(),
+            scalar_len: 24,
+            form_count: 2,
+            lorentz_component_count: 1,
+            point_stride: 8,
+        };
+        assert!(extra_plane.validate().is_err());
+        let partial = DirectMomentumView {
+            values: values.as_ptr(),
+            scalar_len: 15,
+            form_count: 2,
+            lorentz_component_count: 1,
+            point_stride: 8,
+        };
+        assert!(partial.validate().is_err());
+    }
+
+    #[test]
+    fn declared_pointer_range_overflow_fails_closed() {
+        let near_limit =
+            std::ptr::without_provenance::<f64>(usize::MAX - (DIRECT_ARENA_ALIGNMENT - 1));
+        assert!(checked_pointer_range(near_limit, 16, "overflow").is_err());
+        assert!(checked_pointer_range(near_limit, u64::MAX, "overflow").is_err());
+        let over_isize = (isize::MAX as usize / size_of::<f64>()) + 1;
+        assert!(
+            checked_pointer_range(
+                std::ptr::without_provenance::<f64>(DIRECT_ARENA_ALIGNMENT),
+                over_isize as u64,
+                "oversized",
+            )
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn split_read_only_views_require_binary64_alignment() {
+        let unaligned = std::ptr::without_provenance::<f64>(1);
+        let aligned = std::ptr::without_provenance::<f64>(DIRECT_ARENA_ALIGNMENT);
+        let parameters = DirectParameterView {
+            values_re: unaligned,
+            values_im: aligned,
+            value_count: 1,
+        };
+        assert!(parameters.validate().is_err());
+        let factors = DirectFactorView {
+            values_re: aligned,
+            values_im: unaligned,
+            value_count: 1,
+        };
+        assert!(factors.validate().is_err());
+    }
+
+    #[test]
+    fn complete_bundle_requires_one_shared_physical_pitch() {
+        let mut current_re = AlignedF64Buffer::zeroed(8, "current real").unwrap();
+        let mut current_im = AlignedF64Buffer::zeroed(8, "current imag").unwrap();
+        let momentum = AlignedF64Buffer::zeroed(16, "momentum").unwrap();
+        let arena = DirectArenaView {
+            current_re: current_re.as_mut_ptr(),
+            current_im: current_im.as_mut_ptr(),
+            current_scalar_len: 8,
+            amplitude_re: std::ptr::null_mut(),
+            amplitude_im: std::ptr::null_mut(),
+            amplitude_scalar_len: 0,
+            point_stride: 8,
+        };
+        let momenta = DirectMomentumView {
+            values: momentum.as_ptr(),
+            scalar_len: 16,
+            form_count: 1,
+            lorentz_component_count: 1,
+            point_stride: 16,
+        };
+        let parameters = DirectParameterView {
+            values_re: std::ptr::null(),
+            values_im: std::ptr::null(),
+            value_count: 0,
+        };
+        let factors = DirectFactorView {
+            values_re: std::ptr::null(),
+            values_im: std::ptr::null(),
+            value_count: 0,
+        };
+        assert!(validate_direct_views(arena, momenta, parameters, factors).is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/direct_arena/layout.rs b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/layout.rs
new file mode 100644
index 0000000000..d8cf8faf94
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/layout.rs
@@ -0,0 +1,503 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Deterministic variable-width interval allocation for arena planes.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use crate::{RusticolError, RusticolResult};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+/// Inclusive liveness interval and required component-plane width.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct DirectArenaInterval {
+    pub semantic_value_id: u32,
+    pub first_use: u64,
+    pub last_use: u64,
+    pub component_count: u32,
+}
+
+impl DirectArenaInterval {
+    pub fn new(
+        semantic_value_id: u32,
+        first_use: u64,
+        last_use: u64,
+        component_count: u32,
+    ) -> RusticolResult<Self> {
+        if first_use > last_use {
+            return Err(invalid(format!(
+                "direct-arena value {semantic_value_id} starts at {first_use} after its last use {last_use}"
+            )));
+        }
+        if component_count == 0 {
+            return Err(invalid(format!(
+                "direct-arena value {semantic_value_id} has no components"
+            )));
+        }
+        Ok(Self {
+            semantic_value_id,
+            first_use,
+            last_use,
+            component_count,
+        })
+    }
+}
+
+/// One semantic value's physical component range.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct DirectArenaAssignment {
+    pub semantic_value_id: u32,
+    pub component_base: u32,
+    pub component_count: u32,
+    pub first_use: u64,
+    pub last_use: u64,
+}
+
+impl DirectArenaAssignment {
+    pub fn component_stop(self) -> RusticolResult<u32> {
+        self.component_base
+            .checked_add(self.component_count)
+            .ok_or_else(|| invalid("direct-arena component range overflows u32"))
+    }
+}
+
+/// Deterministic interval-coloring result.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DirectArenaLayout {
+    assignments: Box<[DirectArenaAssignment]>,
+    component_count: u32,
+    total_semantic_components: u64,
+    reused_semantic_components: u64,
+}
+
+impl DirectArenaLayout {
+    pub fn assignments(&self) -> &[DirectArenaAssignment] {
+        &self.assignments
+    }
+
+    pub const fn component_count(&self) -> u32 {
+        self.component_count
+    }
+
+    pub const fn total_semantic_components(&self) -> u64 {
+        self.total_semantic_components
+    }
+
+    pub const fn reused_semantic_components(&self) -> u64 {
+        self.reused_semantic_components
+    }
+
+    pub fn assignment(&self, semantic_value_id: u32) -> Option<DirectArenaAssignment> {
+        self.assignments
+            .get(semantic_value_id as usize)
+            .copied()
+            .filter(|assignment| assignment.semantic_value_id == semantic_value_id)
+    }
+
+    pub fn validate(&self) -> RusticolResult<()> {
+        if self.assignments.is_empty() {
+            if self.component_count != 0
+                || self.total_semantic_components != 0
+                || self.reused_semantic_components != 0
+            {
+                return Err(invalid("empty direct-arena layout has nonempty accounting"));
+            }
+            return Ok(());
+        }
+
+        let mut semantic_components = 0_u64;
+        for (index, assignment) in self.assignments.iter().copied().enumerate() {
+            if assignment.semantic_value_id != index as u32 {
+                return Err(invalid(format!(
+                    "direct-arena assignment row {index} has semantic value ID {}",
+                    assignment.semantic_value_id
+                )));
+            }
+            if assignment.component_count == 0 || assignment.first_use > assignment.last_use {
+                return Err(invalid(format!(
+                    "direct-arena assignment {index} has invalid width or liveness"
+                )));
+            }
+            if assignment.component_stop()? > self.component_count {
+                return Err(invalid(format!(
+                    "direct-arena assignment {index} exceeds the physical arena"
+                )));
+            }
+            semantic_components = semantic_components
+                .checked_add(u64::from(assignment.component_count))
+                .ok_or_else(|| invalid("direct-arena semantic component count overflows u64"))?;
+        }
+        if semantic_components != self.total_semantic_components {
+            return Err(invalid(format!(
+                "direct-arena semantic component total {semantic_components} does not match recorded {}",
+                self.total_semantic_components
+            )));
+        }
+        if self
+            .total_semantic_components
+            .checked_sub(u64::from(self.component_count))
+            != Some(self.reused_semantic_components)
+        {
+            return Err(invalid(
+                "direct-arena reused component accounting is inconsistent",
+            ));
+        }
+
+        for (left_index, left) in self.assignments.iter().copied().enumerate() {
+            for right in self.assignments[left_index + 1..].iter().copied() {
+                let lifetimes_overlap =
+                    left.first_use <= right.last_use && right.first_use <= left.last_use;
+                let ranges_overlap = left.component_base < right.component_stop()?
+                    && right.component_base < left.component_stop()?;
+                if lifetimes_overlap && ranges_overlap {
+                    return Err(invalid(format!(
+                        "live direct-arena values {} and {} overlap physical components",
+                        left.semantic_value_id, right.semantic_value_id
+                    )));
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Default)]
+struct FreeRanges {
+    by_base: BTreeMap<u32, u32>,
+    by_size: BTreeSet<(u32, u32)>,
+}
+
+impl FreeRanges {
+    fn take_best_fit(&mut self, required: u32) -> RusticolResult<Option<(u32, u32)>> {
+        let Some(&(component_count, component_base)) = self.by_size.range((required, 0)..).next()
+        else {
+            return Ok(None);
+        };
+        self.remove(component_base, component_count)?;
+        Ok(Some((component_base, component_count)))
+    }
+
+    fn insert(&mut self, mut component_base: u32, mut component_count: u32) -> RusticolResult<()> {
+        if component_count == 0 {
+            return Err(invalid("cannot release an empty direct-arena range"));
+        }
+
+        if let Some((&previous_base, &previous_count)) =
+            self.by_base.range(..component_base).next_back()
+        {
+            let previous_stop = previous_base
+                .checked_add(previous_count)
+                .ok_or_else(|| invalid("direct-arena free range overflows u32"))?;
+            if previous_stop > component_base {
+                return Err(invalid("released direct-arena ranges overlap"));
+            }
+            if previous_stop == component_base {
+                self.remove(previous_base, previous_count)?;
+                component_base = previous_base;
+                component_count = component_count
+                    .checked_add(previous_count)
+                    .ok_or_else(|| invalid("direct-arena merged range overflows u32"))?;
+            }
+        }
+
+        let component_stop = component_base
+            .checked_add(component_count)
+            .ok_or_else(|| invalid("direct-arena free range overflows u32"))?;
+        if let Some((&next_base, &next_count)) = self.by_base.range(component_base..).next() {
+            if component_stop > next_base {
+                return Err(invalid("released direct-arena ranges overlap"));
+            }
+            if component_stop == next_base {
+                self.remove(next_base, next_count)?;
+                component_count = component_count
+                    .checked_add(next_count)
+                    .ok_or_else(|| invalid("direct-arena merged range overflows u32"))?;
+            }
+        }
+
+        if self
+            .by_base
+            .insert(component_base, component_count)
+            .is_some()
+            || !self.by_size.insert((component_count, component_base))
+        {
+            return Err(invalid("released direct-arena range repeats its base"));
+        }
+        Ok(())
+    }
+
+    fn remove(&mut self, component_base: u32, component_count: u32) -> RusticolResult<()> {
+        if self.by_base.remove(&component_base) != Some(component_count)
+            || !self.by_size.remove(&(component_count, component_base))
+        {
+            return Err(invalid("direct-arena free-range indexes disagree"));
+        }
+        Ok(())
+    }
+}
+
+/// Assign variable-width semantic intervals to reusable physical planes.
+///
+/// Inputs use dense semantic value IDs. Intervals are processed by
+/// `(first_use, semantic_value_id)`. The allocator releases ranges whose
+/// inclusive lifetime ended before the next value starts, then chooses the
+/// smallest fitting range with the lowest base as a deterministic tie-breaker.
+pub fn assign_direct_arena(intervals: &[DirectArenaInterval]) -> RusticolResult<DirectArenaLayout> {
+    if intervals.is_empty() {
+        return Ok(DirectArenaLayout {
+            assignments: Box::new([]),
+            component_count: 0,
+            total_semantic_components: 0,
+            reused_semantic_components: 0,
+        });
+    }
+
+    let mut ordered = intervals.to_vec();
+    ordered.sort_by_key(|interval| (interval.first_use, interval.semantic_value_id));
+    let mut releases = ordered.clone();
+    releases.sort_by_key(|interval| (interval.last_use, interval.semantic_value_id));
+    let mut seen = vec![false; intervals.len()];
+    for interval in &ordered {
+        let id = interval.semantic_value_id as usize;
+        if id >= seen.len() || seen[id] {
+            return Err(invalid(
+                "direct-arena semantic value IDs must be dense and unique",
+            ));
+        }
+        seen[id] = true;
+        if interval.component_count == 0 || interval.first_use > interval.last_use {
+            return Err(invalid(format!(
+                "direct-arena value {} has invalid width or liveness",
+                interval.semantic_value_id
+            )));
+        }
+    }
+    if seen.contains(&false) {
+        return Err(invalid(
+            "direct-arena semantic value IDs must cover zero through count minus one",
+        ));
+    }
+
+    let mut assignments = vec![None::<DirectArenaAssignment>; intervals.len()];
+    let mut next_release = 0;
+    let mut free = FreeRanges::default();
+    let mut arena_stop = 0_u32;
+    let mut total_semantic_components = 0_u64;
+
+    for interval in ordered {
+        while releases
+            .get(next_release)
+            .is_some_and(|released| released.last_use < interval.first_use)
+        {
+            let released = releases[next_release];
+            let assignment = assignments[released.semantic_value_id as usize].ok_or_else(|| {
+                invalid("direct-arena interval was released before it was assigned")
+            })?;
+            free.insert(assignment.component_base, assignment.component_count)?;
+            next_release += 1;
+        }
+
+        let (component_base, available_count) = free
+            .take_best_fit(interval.component_count)?
+            .unwrap_or((arena_stop, 0));
+
+        if available_count == 0 {
+            arena_stop = arena_stop
+                .checked_add(interval.component_count)
+                .ok_or_else(|| invalid("direct-arena physical component count exceeds u32"))?;
+        } else {
+            let remaining = available_count - interval.component_count;
+            if remaining != 0 {
+                free.insert(
+                    component_base
+                        .checked_add(interval.component_count)
+                        .ok_or_else(|| invalid("direct-arena free range overflows u32"))?,
+                    remaining,
+                )?;
+            }
+        }
+
+        let assignment = DirectArenaAssignment {
+            semantic_value_id: interval.semantic_value_id,
+            component_base,
+            component_count: interval.component_count,
+            first_use: interval.first_use,
+            last_use: interval.last_use,
+        };
+        assignments[interval.semantic_value_id as usize] = Some(assignment);
+        total_semantic_components = total_semantic_components
+            .checked_add(u64::from(interval.component_count))
+            .ok_or_else(|| invalid("direct-arena semantic component count exceeds u64"))?;
+    }
+
+    let assignments = assignments
+        .into_iter()
+        .enumerate()
+        .map(|(id, assignment)| {
+            assignment.ok_or_else(|| {
+                invalid(format!(
+                    "direct-arena value {id} was not assigned a physical range"
+                ))
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    Ok(DirectArenaLayout {
+        assignments: assignments.into_boxed_slice(),
+        component_count: arena_stop,
+        total_semantic_components,
+        reused_semantic_components: total_semantic_components - u64::from(arena_stop),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn interval(id: u32, first: u64, last: u64, count: u32) -> DirectArenaInterval {
+        DirectArenaInterval::new(id, first, last, count).unwrap()
+    }
+
+    fn assign_naively(intervals: &[DirectArenaInterval]) -> DirectArenaLayout {
+        let mut ordered = intervals.to_vec();
+        ordered.sort_by_key(|row| (row.first_use, row.semantic_value_id));
+        let mut assignments = vec![None::<DirectArenaAssignment>; intervals.len()];
+        let mut arena_stop = 0_u32;
+        let mut total_semantic_components = 0_u64;
+        for row in ordered {
+            let mut occupied = vec![false; arena_stop as usize];
+            for assignment in assignments.iter().flatten() {
+                if assignment.last_use < row.first_use {
+                    continue;
+                }
+                let stop = assignment.component_base + assignment.component_count;
+                occupied[assignment.component_base as usize..stop as usize].fill(true);
+            }
+            let mut best = None::<(u32, u32)>;
+            let mut cursor = 0usize;
+            while cursor < occupied.len() {
+                if occupied[cursor] {
+                    cursor += 1;
+                    continue;
+                }
+                let start = cursor;
+                while cursor < occupied.len() && !occupied[cursor] {
+                    cursor += 1;
+                }
+                let count = (cursor - start) as u32;
+                let candidate = (count, start as u32);
+                if count >= row.component_count && best.is_none_or(|current| candidate < current) {
+                    best = Some(candidate);
+                }
+            }
+            let component_base = best.map_or(arena_stop, |(_, base)| base);
+            if best.is_none() {
+                arena_stop += row.component_count;
+            }
+            assignments[row.semantic_value_id as usize] = Some(DirectArenaAssignment {
+                semantic_value_id: row.semantic_value_id,
+                component_base,
+                component_count: row.component_count,
+                first_use: row.first_use,
+                last_use: row.last_use,
+            });
+            total_semantic_components += u64::from(row.component_count);
+        }
+        DirectArenaLayout {
+            assignments: assignments.into_iter().map(Option::unwrap).collect(),
+            component_count: arena_stop,
+            total_semantic_components,
+            reused_semantic_components: total_semantic_components - u64::from(arena_stop),
+        }
+    }
+
+    #[test]
+    fn non_overlapping_values_reuse_the_same_range() {
+        let layout = assign_direct_arena(&[
+            interval(0, 0, 2, 4),
+            interval(1, 3, 5, 4),
+            interval(2, 6, 8, 4),
+        ])
+        .unwrap();
+        assert_eq!(layout.component_count(), 4);
+        assert_eq!(layout.total_semantic_components(), 12);
+        assert_eq!(layout.reused_semantic_components(), 8);
+        assert!(
+            layout
+                .assignments()
+                .iter()
+                .all(|row| row.component_base == 0)
+        );
+    }
+
+    #[test]
+    fn inclusive_lifetimes_do_not_reuse_at_the_same_event() {
+        let layout = assign_direct_arena(&[interval(0, 0, 3, 2), interval(1, 3, 4, 3)]).unwrap();
+        assert_eq!(layout.component_count(), 5);
+        assert_eq!(layout.assignment(0).unwrap().component_base, 0);
+        assert_eq!(layout.assignment(1).unwrap().component_base, 2);
+    }
+
+    #[test]
+    fn allocator_chooses_the_smallest_fitting_range_deterministically() {
+        let layout = assign_direct_arena(&[
+            interval(0, 0, 1, 8),
+            interval(1, 0, 5, 2),
+            interval(2, 0, 1, 3),
+            interval(3, 2, 4, 2),
+            interval(4, 2, 4, 7),
+        ])
+        .unwrap();
+        assert_eq!(layout.assignment(3).unwrap().component_base, 10);
+        assert_eq!(layout.assignment(4).unwrap().component_base, 0);
+        assert_eq!(layout.component_count(), 13);
+    }
+
+    #[test]
+    fn assignment_is_stable_for_unsorted_input() {
+        let intervals = [
+            interval(3, 8, 9, 2),
+            interval(0, 0, 3, 4),
+            interval(2, 4, 7, 3),
+            interval(1, 1, 2, 1),
+        ];
+        let expected = assign_direct_arena(&intervals).unwrap();
+        for _ in 0..32 {
+            assert_eq!(assign_direct_arena(&intervals).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn indexed_allocator_matches_naive_best_fit_oracle() {
+        for seed in 0..48_u32 {
+            let mut intervals = (0..32_u32)
+                .map(|id| {
+                    let first = u64::from((id * 7 + seed * 3) % 11);
+                    interval(
+                        id,
+                        first,
+                        first + u64::from((id * 5 + seed) % 6),
+                        1 + (id * 3 + seed * 5) % 7,
+                    )
+                })
+                .collect::<Vec<_>>();
+            let length = intervals.len();
+            intervals.rotate_left(seed as usize % length);
+            if seed % 2 != 0 {
+                intervals.reverse();
+            }
+            assert_eq!(
+                assign_direct_arena(&intervals).unwrap(),
+                assign_naively(&intervals)
+            );
+        }
+    }
+
+    #[test]
+    fn malformed_ids_and_component_overflow_fail_closed() {
+        assert!(assign_direct_arena(&[interval(1, 0, 1, 1)]).is_err());
+        assert!(assign_direct_arena(&[interval(0, 0, 1, 1), interval(0, 2, 3, 1)]).is_err());
+        assert!(assign_direct_arena(&[interval(0, 0, 1, u32::MAX), interval(1, 0, 1, 1)]).is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/direct_arena/mod.rs b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/mod.rs
new file mode 100644
index 0000000000..b128f0825e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/mod.rs
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Lane-neutral Direct-Arena building blocks.
+//!
+//! This module contains no recurrence-current, eager-row, or compiled-stage
+//! semantics. Each execution lane owns its authenticated plan, event schedule,
+//! selectors, reductions, and hot loop.
+
+mod abi;
+mod layout;
+mod profile;
+mod reduction;
+mod storage;
+
+pub use abi::{
+    DirectArenaView, DirectFactorView, DirectMomentumView, DirectParameterView, DirectPlaneShape,
+    validate_direct_views,
+};
+pub use layout::{
+    DirectArenaAssignment, DirectArenaInterval, DirectArenaLayout, assign_direct_arena,
+};
+pub use profile::{DirectArenaTrafficCounters, DirectArenaTrafficKind};
+pub use reduction::DirectAmplitudePlanes;
+pub use storage::{
+    AlignedF64Buffer, DIRECT_ARENA_ALIGNMENT, DIRECT_ARENA_LOCALITY_POINT_CAP,
+    DirectArenaAllocationCounters, DirectArenaWorkspace, DirectPointTile, DirectPointTiles,
+    checked_aligned_point_stride, checked_plane_scalar_len, clear_split_active_range,
+    deterministic_point_tile_size, deterministic_point_tile_size_with_cache_footprint,
+};
diff --git a/pyamplicol/rust/crates/rusticol-core/src/direct_arena/profile.rs b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/profile.rs
new file mode 100644
index 0000000000..3dd976960e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/profile.rs
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Lane-neutral direct-call and forbidden-materialization accounting.
+
+use crate::{RusticolError, RusticolResult};
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum DirectArenaTrafficKind {
+    PacketInput,
+    PacketOutput,
+    Gather,
+    Scatter,
+    Remap,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct DirectArenaTrafficCounters {
+    pub calls: u64,
+    pub rows: u64,
+    pub points: u64,
+    pub packet_input_bytes: u64,
+    pub packet_output_bytes: u64,
+    pub gather_bytes: u64,
+    pub scatter_bytes: u64,
+    pub remap_bytes: u64,
+}
+
+impl DirectArenaTrafficCounters {
+    pub fn record_call(&mut self, rows: u32, points: u32) {
+        self.calls = self.calls.saturating_add(1);
+        self.rows = self.rows.saturating_add(u64::from(rows));
+        self.points = self.points.saturating_add(u64::from(points));
+    }
+
+    pub fn record_traffic(&mut self, kind: DirectArenaTrafficKind, bytes: u64) {
+        let counter = match kind {
+            DirectArenaTrafficKind::PacketInput => &mut self.packet_input_bytes,
+            DirectArenaTrafficKind::PacketOutput => &mut self.packet_output_bytes,
+            DirectArenaTrafficKind::Gather => &mut self.gather_bytes,
+            DirectArenaTrafficKind::Scatter => &mut self.scatter_bytes,
+            DirectArenaTrafficKind::Remap => &mut self.remap_bytes,
+        };
+        *counter = counter.saturating_add(bytes);
+    }
+
+    pub fn validate_direct(&self) -> RusticolResult<()> {
+        if self.packet_input_bytes
+            | self.packet_output_bytes
+            | self.gather_bytes
+            | self.scatter_bytes
+            | self.remap_bytes
+            != 0
+        {
+            return Err(RusticolError::integrity(
+                "Direct-Arena execution recorded forbidden packet/gather/scatter/remap traffic",
+            ));
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn forbidden_traffic_fails_closed() {
+        let mut counters = DirectArenaTrafficCounters::default();
+        counters.record_call(7, 128);
+        assert!(counters.validate_direct().is_ok());
+        counters.record_traffic(DirectArenaTrafficKind::Gather, 8);
+        assert!(counters.validate_direct().is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/direct_arena/reduction.rs b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/reduction.rs
new file mode 100644
index 0000000000..8c382f7a7f
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/reduction.rs
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Borrowed split-complex amplitude planes for lane-neutral reductions.
+
+use std::mem::size_of;
+
+use crate::{RusticolError, RusticolResult};
+
+use super::{DIRECT_ARENA_ALIGNMENT, DirectPlaneShape};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+/// Read-only component-major amplitude planes for one active point tile.
+///
+/// Each component occupies `point_stride` consecutive scalars in both halves
+/// of the split-complex storage. Only `0..point_count` is semantically active;
+/// the remaining physical pitch is padding retained by the persistent arena.
+#[derive(Clone, Copy, Debug)]
+pub struct DirectAmplitudePlanes<'a> {
+    values_re: &'a [f64],
+    values_im: &'a [f64],
+    shape: DirectPlaneShape,
+    point_count: u32,
+}
+
+impl<'a> DirectAmplitudePlanes<'a> {
+    pub fn new(
+        values_re: &'a [f64],
+        values_im: &'a [f64],
+        point_stride: u32,
+        point_count: u32,
+    ) -> RusticolResult<Self> {
+        if values_re.len() != values_im.len() {
+            return Err(invalid(
+                "direct amplitude real and imaginary plane lengths disagree",
+            ));
+        }
+        if point_count == 0 || point_count > point_stride {
+            return Err(invalid(
+                "direct amplitude active point count is outside its physical pitch",
+            ));
+        }
+        let scalar_len = u64::try_from(values_re.len())
+            .map_err(|_| invalid("direct amplitude scalar length exceeds u64"))?;
+        let shape = DirectPlaneShape::new(scalar_len, point_stride, "amplitude reduction")?;
+        let alignment_scalars = u32::try_from(DIRECT_ARENA_ALIGNMENT / size_of::<f64>())
+            .map_err(|_| invalid("direct amplitude alignment exceeds u32"))?;
+        if !point_stride.is_multiple_of(alignment_scalars) {
+            return Err(invalid(
+                "direct amplitude point stride does not preserve per-plane alignment",
+            ));
+        }
+        for (values, label) in [(values_re, "real"), (values_im, "imaginary")] {
+            if values.is_empty()
+                || !(values.as_ptr() as usize).is_multiple_of(DIRECT_ARENA_ALIGNMENT)
+            {
+                return Err(invalid(format!(
+                    "direct amplitude {label} plane base is not 64-byte aligned"
+                )));
+            }
+        }
+        let _ = shape.component_count()?;
+        Ok(Self {
+            values_re,
+            values_im,
+            shape,
+            point_count,
+        })
+    }
+
+    pub const fn point_count(self) -> u32 {
+        self.point_count
+    }
+
+    pub const fn point_stride(self) -> u32 {
+        self.shape.point_stride()
+    }
+
+    pub fn component_count(self) -> RusticolResult<u32> {
+        self.shape.component_count()
+    }
+
+    /// Return one active plane without exposing its physical pitch padding.
+    ///
+    /// Callers validate the component catalog once before entering their hot
+    /// reduction loop. Keeping points contiguous here lets reducers traverse
+    /// terms/components outside and points inside without reconstructing
+    /// point-major rows.
+    #[allow(dead_code)]
+    #[inline(always)]
+    pub(crate) fn plane_unchecked(self, component: usize) -> (&'a [f64], &'a [f64]) {
+        debug_assert!(component < self.shape.component_count().unwrap_or(0) as usize);
+        let start = component * self.shape.point_stride() as usize;
+        let stop = start + self.point_count as usize;
+        (&self.values_re[start..stop], &self.values_im[start..stop])
+    }
+
+    #[inline(always)]
+    pub(crate) fn value_unchecked(self, component: usize, point: usize) -> (f64, f64) {
+        debug_assert!(component < self.shape.component_count().unwrap_or(0) as usize);
+        debug_assert!(point < self.point_count as usize);
+        let index = component * self.shape.point_stride() as usize + point;
+        (self.values_re[index], self.values_im[index])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::direct_arena::DirectArenaWorkspace;
+
+    #[test]
+    fn validates_alignment_pitch_and_active_tail() {
+        let mut workspace = DirectArenaWorkspace::new(0, 3, 129).unwrap();
+        workspace.begin_tile(127).unwrap();
+        let stride = workspace.point_stride();
+        let (values_re, values_im) = workspace.amplitude_slices();
+        let planes = DirectAmplitudePlanes::new(values_re, values_im, stride, 127).unwrap();
+        assert_eq!(planes.component_count().unwrap(), 3);
+        assert_eq!(planes.point_count(), 127);
+        assert_eq!(planes.point_stride(), 136);
+        let (plane_re, plane_im) = planes.plane_unchecked(1);
+        assert_eq!(plane_re.len(), 127);
+        assert_eq!(plane_im.len(), 127);
+        assert_eq!(plane_re.as_ptr(), values_re[136..].as_ptr());
+        assert_eq!(plane_im.as_ptr(), values_im[136..].as_ptr());
+        assert!(DirectAmplitudePlanes::new(values_re, values_im, stride, 137).is_err());
+        assert!(DirectAmplitudePlanes::new(&values_re[1..], &values_im[1..], stride, 1).is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/direct_arena/storage.rs b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/storage.rs
new file mode 100644
index 0000000000..a8b6320f27
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/direct_arena/storage.rs
@@ -0,0 +1,690 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Aligned storage and deterministic, shape-derived point tiling.
+
+use std::mem::size_of;
+
+use crate::{RusticolError, RusticolResult};
+
+use super::DirectArenaView;
+
+pub const DIRECT_ARENA_ALIGNMENT: usize = 64;
+const DIRECT_ARENA_ALIGNMENT_SCALARS: u32 = (DIRECT_ARENA_ALIGNMENT / size_of::<f64>()) as u32;
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+/// Binary64 storage exposing an exactly-sized 64-byte-aligned logical range.
+///
+/// The small alignment reserve belongs to the allocator and is intentionally
+/// outside any caller-authenticated logical workspace budget.
+pub struct AlignedF64Buffer {
+    storage: Vec<f64>,
+    start: usize,
+    len: usize,
+}
+
+impl AlignedF64Buffer {
+    pub fn zeroed(len: usize, label: &str) -> RusticolResult<Self> {
+        if len == 0 {
+            return Ok(Self {
+                storage: Vec::new(),
+                start: 0,
+                len: 0,
+            });
+        }
+        let alignment_values = DIRECT_ARENA_ALIGNMENT
+            .checked_div(size_of::<f64>())
+            .filter(|value| *value != 0)
+            .ok_or_else(|| invalid("arena alignment is invalid for binary64 storage"))?;
+        let storage_len = len
+            .checked_add(alignment_values - 1)
+            .ok_or_else(|| invalid(format!("{label} arena length overflows usize")))?;
+        let mut storage = Vec::new();
+        storage.try_reserve_exact(storage_len).map_err(|error| {
+            RusticolError::internal(format!(
+                "could not allocate Direct-Arena {label} storage: {error}"
+            ))
+        })?;
+        storage.resize(storage_len, 0.0);
+        let address = storage.as_ptr() as usize;
+        let byte_offset =
+            (DIRECT_ARENA_ALIGNMENT - address % DIRECT_ARENA_ALIGNMENT) % DIRECT_ARENA_ALIGNMENT;
+        if !byte_offset.is_multiple_of(size_of::<f64>()) {
+            return Err(RusticolError::internal(
+                "Direct-Arena allocation cannot provide binary64 alignment",
+            ));
+        }
+        let start = byte_offset / size_of::<f64>();
+        if start.checked_add(len).is_none_or(|end| end > storage.len()) {
+            return Err(RusticolError::internal(
+                "aligned Direct-Arena range exceeds its allocation",
+            ));
+        }
+        Ok(Self {
+            storage,
+            start,
+            len,
+        })
+    }
+
+    pub const fn len(&self) -> usize {
+        self.len
+    }
+
+    pub const fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    pub fn as_ptr(&self) -> *const f64 {
+        self.as_slice().as_ptr()
+    }
+
+    pub fn as_mut_ptr(&mut self) -> *mut f64 {
+        self.as_mut_slice().as_mut_ptr()
+    }
+
+    pub fn as_slice(&self) -> &[f64] {
+        &self.storage[self.start..self.start + self.len]
+    }
+
+    pub fn as_mut_slice(&mut self) -> &mut [f64] {
+        &mut self.storage[self.start..self.start + self.len]
+    }
+
+    pub fn allocation_counters(&self) -> DirectArenaAllocationCounters {
+        DirectArenaAllocationCounters {
+            allocation_requests: u64::from(!self.is_empty()),
+            requested_bytes: u64::try_from(self.storage.len().saturating_mul(size_of::<f64>()))
+                .unwrap_or(u64::MAX),
+        }
+    }
+}
+
+/// Logical allocation requests made for persistent Direct-Arena buffers.
+///
+/// `requested_bytes` describes the buffer lengths requested from `Vec`; an
+/// allocator may reserve more physical capacity. Use a counting allocator
+/// when actual allocator calls or resident bytes are required.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct DirectArenaAllocationCounters {
+    pub allocation_requests: u64,
+    pub requested_bytes: u64,
+}
+
+impl DirectArenaAllocationCounters {
+    pub fn checked_add(self, other: Self) -> RusticolResult<Self> {
+        Ok(Self {
+            allocation_requests: self
+                .allocation_requests
+                .checked_add(other.allocation_requests)
+                .ok_or_else(|| invalid("Direct-Arena allocation request count overflows u64"))?,
+            requested_bytes: self
+                .requested_bytes
+                .checked_add(other.requested_bytes)
+                .ok_or_else(|| invalid("Direct-Arena requested byte count overflows u64"))?,
+        })
+    }
+}
+
+/// Persistent split-complex current and amplitude storage for one lane.
+pub struct DirectArenaWorkspace {
+    current_re: AlignedF64Buffer,
+    current_im: AlignedF64Buffer,
+    amplitude_re: AlignedF64Buffer,
+    amplitude_im: AlignedF64Buffer,
+    current_plane_count: u32,
+    amplitude_plane_count: u32,
+    tile_capacity: u32,
+    point_stride: u32,
+    active_point_count: u32,
+    allocation_counters: DirectArenaAllocationCounters,
+}
+
+impl DirectArenaWorkspace {
+    pub fn new(
+        current_plane_count: u32,
+        amplitude_plane_count: u32,
+        tile_capacity: u32,
+    ) -> RusticolResult<Self> {
+        if tile_capacity == 0 {
+            return Err(invalid(
+                "Direct-Arena workspace tile capacity must be positive",
+            ));
+        }
+        let point_stride = checked_aligned_point_stride(tile_capacity)?;
+        Self::new_with_layout(
+            current_plane_count,
+            amplitude_plane_count,
+            tile_capacity,
+            point_stride,
+        )
+    }
+
+    /// Allocate the explicit packed layout used only for a proven-generic
+    /// singleton direct execution. Ordinary capacity-one workspaces remain
+    /// aligned through [`Self::new`].
+    pub(crate) fn new_packed_singleton(
+        current_plane_count: u32,
+        amplitude_plane_count: u32,
+    ) -> RusticolResult<Self> {
+        Self::new_with_layout(current_plane_count, amplitude_plane_count, 1, 1)
+    }
+
+    fn new_with_layout(
+        current_plane_count: u32,
+        amplitude_plane_count: u32,
+        tile_capacity: u32,
+        point_stride: u32,
+    ) -> RusticolResult<Self> {
+        let current_len =
+            checked_plane_scalar_len(current_plane_count, point_stride, "current arena")?;
+        let amplitude_len =
+            checked_plane_scalar_len(amplitude_plane_count, point_stride, "amplitude arena")?;
+        let current_re = AlignedF64Buffer::zeroed(current_len, "current real")?;
+        let current_im = AlignedF64Buffer::zeroed(current_len, "current imaginary")?;
+        let amplitude_re = AlignedF64Buffer::zeroed(amplitude_len, "amplitude real")?;
+        let amplitude_im = AlignedF64Buffer::zeroed(amplitude_len, "amplitude imaginary")?;
+        let allocation_counters = [&current_re, &current_im, &amplitude_re, &amplitude_im]
+            .into_iter()
+            .try_fold(DirectArenaAllocationCounters::default(), |total, buffer| {
+                total.checked_add(buffer.allocation_counters())
+            })?;
+        Ok(Self {
+            current_re,
+            current_im,
+            amplitude_re,
+            amplitude_im,
+            current_plane_count,
+            amplitude_plane_count,
+            tile_capacity,
+            point_stride,
+            active_point_count: 0,
+            allocation_counters,
+        })
+    }
+
+    pub const fn tile_capacity(&self) -> u32 {
+        self.tile_capacity
+    }
+
+    pub const fn point_stride(&self) -> u32 {
+        self.point_stride
+    }
+
+    pub const fn active_point_count(&self) -> u32 {
+        self.active_point_count
+    }
+
+    pub const fn allocation_counters(&self) -> DirectArenaAllocationCounters {
+        self.allocation_counters
+    }
+
+    pub fn current_slices(&self) -> (&[f64], &[f64]) {
+        (self.current_re.as_slice(), self.current_im.as_slice())
+    }
+
+    pub fn amplitude_slices(&self) -> (&[f64], &[f64]) {
+        (self.amplitude_re.as_slice(), self.amplitude_im.as_slice())
+    }
+
+    pub fn split_slices_mut(&mut self) -> (&mut [f64], &mut [f64], &mut [f64], &mut [f64]) {
+        (
+            self.current_re.as_mut_slice(),
+            self.current_im.as_mut_slice(),
+            self.amplitude_re.as_mut_slice(),
+            self.amplitude_im.as_mut_slice(),
+        )
+    }
+
+    /// Bind the persistent storage to one active tile without modifying it.
+    ///
+    /// The physical pitch and pointer identity remain stable across full and
+    /// tail tiles. Only `0..point_count` in each plane is semantically active.
+    pub fn begin_tile(&mut self, point_count: u32) -> RusticolResult<()> {
+        if point_count == 0 || point_count > self.tile_capacity {
+            return Err(invalid(format!(
+                "Direct-Arena workspace point count {point_count} is outside 1..={}",
+                self.tile_capacity
+            )));
+        }
+        self.active_point_count = point_count;
+        Ok(())
+    }
+
+    pub fn clear_current_active(
+        &mut self,
+        component_base: u32,
+        component_count: u32,
+    ) -> RusticolResult<()> {
+        clear_split_active_range(
+            self.current_re.as_mut_slice(),
+            self.current_im.as_mut_slice(),
+            self.current_plane_count,
+            self.point_stride,
+            self.active_point_count,
+            component_base,
+            component_count,
+            "current arena",
+        )
+    }
+
+    pub fn clear_amplitude_active(
+        &mut self,
+        component_base: u32,
+        component_count: u32,
+    ) -> RusticolResult<()> {
+        clear_split_active_range(
+            self.amplitude_re.as_mut_slice(),
+            self.amplitude_im.as_mut_slice(),
+            self.amplitude_plane_count,
+            self.point_stride,
+            self.active_point_count,
+            component_base,
+            component_count,
+            "amplitude arena",
+        )
+    }
+
+    pub fn view(&mut self) -> RusticolResult<DirectArenaView> {
+        if self.active_point_count == 0 {
+            return Err(invalid(
+                "Direct-Arena workspace view requires an active tile",
+            ));
+        }
+        let view = DirectArenaView {
+            current_re: self.current_re.as_mut_ptr(),
+            current_im: self.current_im.as_mut_ptr(),
+            current_scalar_len: u64::try_from(self.current_re.len())
+                .map_err(|_| invalid("current arena view length exceeds u64"))?,
+            amplitude_re: self.amplitude_re.as_mut_ptr(),
+            amplitude_im: self.amplitude_im.as_mut_ptr(),
+            amplitude_scalar_len: u64::try_from(self.amplitude_re.len())
+                .map_err(|_| invalid("amplitude arena view length exceeds u64"))?,
+            point_stride: self.point_stride,
+        };
+        view.validate()?;
+        Ok(view)
+    }
+
+    pub fn point_tiles(
+        &self,
+        requested_points: u32,
+        tile_points: u32,
+    ) -> RusticolResult<DirectPointTiles> {
+        if requested_points == 0 || tile_points == 0 || tile_points > self.tile_capacity {
+            return Err(invalid(format!(
+                "Direct-Arena point tiling requires positive counts and tile size at most {}",
+                self.tile_capacity
+            )));
+        }
+        Ok(DirectPointTiles {
+            next_point: 0,
+            requested_points,
+            tile_points,
+        })
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct DirectPointTile {
+    pub point_start: u32,
+    pub point_count: u32,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct DirectPointTiles {
+    next_point: u32,
+    requested_points: u32,
+    tile_points: u32,
+}
+
+impl Iterator for DirectPointTiles {
+    type Item = DirectPointTile;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.next_point == self.requested_points {
+            return None;
+        }
+        let point_count = (self.requested_points - self.next_point).min(self.tile_points);
+        let tile = DirectPointTile {
+            point_start: self.next_point,
+            point_count,
+        };
+        self.next_point += point_count;
+        Some(tile)
+    }
+}
+
+pub fn checked_aligned_point_stride(tile_capacity: u32) -> RusticolResult<u32> {
+    if DIRECT_ARENA_ALIGNMENT_SCALARS == 0 {
+        return Err(RusticolError::internal(
+            "Direct-Arena alignment is smaller than binary64 storage",
+        ));
+    }
+    let remainder = tile_capacity % DIRECT_ARENA_ALIGNMENT_SCALARS;
+    if remainder == 0 {
+        return Ok(tile_capacity);
+    }
+    tile_capacity
+        .checked_add(DIRECT_ARENA_ALIGNMENT_SCALARS - remainder)
+        .ok_or_else(|| invalid("aligned Direct-Arena point stride exceeds u32"))
+}
+
+/// Clear only active points in a validated contiguous split-complex plane range.
+#[allow(clippy::too_many_arguments)]
+pub fn clear_split_active_range(
+    values_re: &mut [f64],
+    values_im: &mut [f64],
+    plane_count: u32,
+    point_stride: u32,
+    active_point_count: u32,
+    component_base: u32,
+    component_count: u32,
+    label: &str,
+) -> RusticolResult<()> {
+    if active_point_count == 0 || active_point_count > point_stride {
+        return Err(invalid(format!(
+            "direct {label} clear requires an active count within its physical pitch"
+        )));
+    }
+    if component_count == 0 {
+        return Err(invalid(format!(
+            "direct {label} clear range must contain a component"
+        )));
+    }
+    let expected_len = checked_plane_scalar_len(plane_count, point_stride, label)?;
+    if values_re.len() != expected_len || values_im.len() != expected_len {
+        return Err(invalid(format!(
+            "direct {label} split storage has an inconsistent length"
+        )));
+    }
+    let component_stop = component_base
+        .checked_add(component_count)
+        .filter(|stop| *stop <= plane_count)
+        .ok_or_else(|| invalid(format!("direct {label} clear range is out of bounds")))?;
+    let point_stride = point_stride as usize;
+    let active_point_count = active_point_count as usize;
+    for component in component_base..component_stop {
+        let start = (component as usize)
+            .checked_mul(point_stride)
+            .ok_or_else(|| invalid(format!("direct {label} clear range overflows usize")))?;
+        let stop = start
+            .checked_add(active_point_count)
+            .ok_or_else(|| invalid(format!("direct {label} clear range overflows usize")))?;
+        values_re[start..stop].fill(0.0);
+        values_im[start..stop].fill(0.0);
+    }
+    Ok(())
+}
+
+pub fn checked_plane_scalar_len(
+    plane_count: u32,
+    point_stride: u32,
+    label: &str,
+) -> RusticolResult<usize> {
+    usize::try_from(plane_count)
+        .ok()
+        .and_then(|planes| planes.checked_mul(point_stride as usize))
+        .ok_or_else(|| invalid(format!("{label} length overflows usize")))
+}
+
+/// Portable upper bound for the physical point pitch of row-outer Direct-Arena lanes.
+///
+/// Table callables revisit their parent component planes for every row. A
+/// larger pitch spreads those planes farther apart and expands the live parent
+/// footprint even when the active point count is smaller than the allocated
+/// capacity. Keeping the pitch bounded preserves locality without consulting
+/// the host architecture or runtime timings. Lanes remain free to request a
+/// smaller tile or apply a smaller workspace target.
+pub const DIRECT_ARENA_LOCALITY_POINT_CAP: u32 = 64;
+
+/// Select a semantic tile capacity using its padded footprint.
+///
+/// `scalar_values_per_point` includes every physically pitched plane and both
+/// halves of split-complex planes. The workspace target excludes the
+/// allocator's small base-alignment reserve and grows to fit one aligned tile.
+/// It controls batching, not which processes can run. `cache_target_bytes`
+/// is a separate locality target; lanes may pass `usize::MAX` and apply their
+/// own cache heuristic.
+pub fn deterministic_point_tile_size(
+    requested_points: u32,
+    workspace_bytes: usize,
+    cache_target_bytes: usize,
+    scalar_values_per_point: usize,
+) -> RusticolResult<u32> {
+    deterministic_point_tile_size_with_cache_footprint(
+        requested_points,
+        workspace_bytes,
+        cache_target_bytes,
+        scalar_values_per_point,
+        scalar_values_per_point,
+    )
+}
+
+/// Select a semantic tile using distinct physical and cache-local footprints.
+///
+/// The workspace target uses `physical_scalar_values_per_point`, including
+/// the final aligned pitch. The cache target instead uses the maximum
+/// phase-local working set. Keeping
+/// the two inputs separate prevents cold persistent planes from shrinking a
+/// tile whose hot kernels touch only a bounded subset.
+pub fn deterministic_point_tile_size_with_cache_footprint(
+    requested_points: u32,
+    workspace_bytes: usize,
+    cache_target_bytes: usize,
+    physical_scalar_values_per_point: usize,
+    cache_scalar_values_per_point: usize,
+) -> RusticolResult<u32> {
+    if requested_points == 0
+        || physical_scalar_values_per_point == 0
+        || cache_scalar_values_per_point == 0
+    {
+        return Err(invalid(
+            "Direct-Arena tiling requires positive points and physical/cache per-point shapes",
+        ));
+    }
+    let physical_bytes_per_point = physical_scalar_values_per_point
+        .checked_mul(size_of::<f64>())
+        .ok_or_else(|| invalid("Direct-Arena per-point byte count overflows usize"))?;
+    let cache_bytes_per_point = cache_scalar_values_per_point
+        .checked_mul(size_of::<f64>())
+        .ok_or_else(|| invalid("Direct-Arena cache footprint overflows usize"))?;
+    let minimum_physical_bytes = physical_bytes_per_point
+        .checked_mul(DIRECT_ARENA_ALIGNMENT_SCALARS as usize)
+        .ok_or_else(|| invalid("minimum aligned Direct-Arena tile byte count overflows usize"))?;
+    let workspace_bytes = workspace_bytes.max(minimum_physical_bytes);
+    let largest_aligned_u32 = u32::MAX - u32::MAX % DIRECT_ARENA_ALIGNMENT_SCALARS;
+    let workspace_stride = (workspace_bytes / physical_bytes_per_point)
+        .min(largest_aligned_u32 as usize)
+        / DIRECT_ARENA_ALIGNMENT_SCALARS as usize
+        * DIRECT_ARENA_ALIGNMENT_SCALARS as usize;
+    let workspace_capacity = u32::try_from(workspace_stride)
+        .map_err(|_| invalid("aligned Direct-Arena workspace capacity exceeds u32"))?;
+    let cache_points =
+        greatest_power_of_two_not_exceeding((cache_target_bytes / cache_bytes_per_point).max(1));
+    let tile_capacity = requested_points
+        .min(workspace_capacity)
+        .min(u32::try_from(cache_points).unwrap_or(u32::MAX).max(1));
+    let point_stride = checked_aligned_point_stride(tile_capacity)?;
+    let physical_bytes = (point_stride as usize)
+        .checked_mul(physical_bytes_per_point)
+        .ok_or_else(|| invalid("padded Direct-Arena tile byte count overflows usize"))?;
+    if physical_bytes > workspace_bytes {
+        return Err(invalid(format!(
+            "padded Direct-Arena tile accounting mismatch: {physical_bytes} bytes \
+             exceeds derived workspace size {workspace_bytes}"
+        )));
+    }
+    Ok(tile_capacity)
+}
+
+fn greatest_power_of_two_not_exceeding(value: usize) -> usize {
+    if value == 0 {
+        return 1;
+    }
+    1_usize << (usize::BITS - 1 - value.leading_zeros())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn storage_and_each_physical_plane_are_aligned() {
+        let values = AlignedF64Buffer::zeroed(129, "test").unwrap();
+        assert_eq!(values.len(), 129);
+        assert_eq!((values.as_ptr() as usize) % DIRECT_ARENA_ALIGNMENT, 0);
+        for (capacity, stride) in [(1, 8), (7, 8), (127, 128), (129, 136)] {
+            let mut workspace = DirectArenaWorkspace::new(3, 2, capacity).unwrap();
+            assert_eq!(workspace.point_stride(), stride);
+            workspace.begin_tile(capacity).unwrap();
+            let view = workspace.view().unwrap();
+            for component in 0..3_usize {
+                assert_eq!(
+                    unsafe { view.current_re.add(component * stride as usize) } as usize
+                        % DIRECT_ARENA_ALIGNMENT,
+                    0
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn tiling_uses_padded_physical_workspace_target() {
+        assert_eq!(
+            deterministic_point_tile_size(129, 2064, usize::MAX, 2).unwrap(),
+            128
+        );
+        assert_eq!(
+            deterministic_point_tile_size(129, 2176, usize::MAX, 2).unwrap(),
+            129
+        );
+        assert_eq!(
+            deterministic_point_tile_size(129, 2175, usize::MAX, 2).unwrap(),
+            128
+        );
+        assert_eq!(
+            deterministic_point_tile_size(1, 127, usize::MAX, 2).unwrap(),
+            1
+        );
+        assert_eq!(
+            deterministic_point_tile_size(1, 128, usize::MAX, 2).unwrap(),
+            1
+        );
+    }
+
+    #[test]
+    fn tiling_separates_physical_and_cache_footprints() {
+        assert_eq!(
+            deterministic_point_tile_size_with_cache_footprint(32, 32 * 1024, 4 * 1024, 128, 8,)
+                .unwrap(),
+            32,
+            "cold physical planes must not consume the phase-local cache target"
+        );
+        assert_eq!(
+            deterministic_point_tile_size_with_cache_footprint(64, 16 * 1024, usize::MAX, 128, 1,)
+                .unwrap(),
+            16,
+            "the padded physical allocation controls the tile size"
+        );
+        assert_eq!(
+            deterministic_point_tile_size_with_cache_footprint(64, usize::MAX, 4 * 1024, 1, 128,)
+                .unwrap(),
+            4,
+            "the cache bound follows the phase-local footprint"
+        );
+        assert!(
+            deterministic_point_tile_size_with_cache_footprint(1, usize::MAX, usize::MAX, 1, 0,)
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn observed_large_minimum_pitch_can_exceed_the_workspace_target() {
+        const PHYSICAL_SCALARS_PER_POINT: usize = 4_249_960;
+        const REQUIRED_BYTES: usize = 271_997_440;
+
+        assert_eq!(
+            deterministic_point_tile_size_with_cache_footprint(
+                1024,
+                REQUIRED_BYTES,
+                4 * 1024 * 1024,
+                PHYSICAL_SCALARS_PER_POINT,
+                1,
+            )
+            .unwrap(),
+            8
+        );
+        assert_eq!(
+            deterministic_point_tile_size_with_cache_footprint(
+                1024,
+                REQUIRED_BYTES - 1,
+                4 * 1024 * 1024,
+                PHYSICAL_SCALARS_PER_POINT,
+                1,
+            )
+            .unwrap(),
+            8
+        );
+    }
+
+    #[test]
+    fn allocator_alignment_reserve_is_outside_the_logical_budget() {
+        assert_eq!(
+            deterministic_point_tile_size(1, 128, usize::MAX, 2).unwrap(),
+            1
+        );
+        let workspace = DirectArenaWorkspace::new(1, 0, 1).unwrap();
+        assert_eq!(workspace.point_stride(), 8);
+        assert_eq!(workspace.allocation_counters().allocation_requests, 2);
+        assert!(
+            workspace.allocation_counters().requested_bytes > 128,
+            "allocator-owned base-alignment reserve must not reduce logical capacity"
+        );
+    }
+
+    #[test]
+    fn packed_singleton_is_explicit_and_does_not_change_aligned_capacity_one() {
+        assert_eq!(
+            DirectArenaWorkspace::new(2, 1, 1).unwrap().point_stride(),
+            8
+        );
+        let packed = DirectArenaWorkspace::new_packed_singleton(2, 1).unwrap();
+        assert_eq!(packed.tile_capacity(), 1);
+        assert_eq!(packed.point_stride(), 1);
+        assert_eq!(packed.current_slices().0.len(), 2);
+        assert_eq!(packed.amplitude_slices().0.len(), 1);
+    }
+
+    #[test]
+    fn selective_clear_preserves_padding_and_other_planes() {
+        let mut workspace = DirectArenaWorkspace::new(2, 1, 9).unwrap();
+        workspace.begin_tile(9).unwrap();
+        {
+            let (current_re, current_im, amplitude_re, amplitude_im) = workspace.split_slices_mut();
+            current_re.fill(7.0);
+            current_im.fill(-7.0);
+            amplitude_re.fill(3.0);
+            amplitude_im.fill(-3.0);
+        }
+        workspace.begin_tile(7).unwrap();
+        workspace.clear_current_active(1, 1).unwrap();
+        workspace.clear_amplitude_active(0, 1).unwrap();
+        let stride = workspace.point_stride() as usize;
+        let (current_re, current_im) = workspace.current_slices();
+        assert!(current_re[..stride].iter().all(|value| *value == 7.0));
+        assert!(
+            current_re[stride..stride + 7]
+                .iter()
+                .all(|value| *value == 0.0)
+        );
+        assert_eq!(current_re[stride + 7], 7.0);
+        assert_eq!(current_im[stride + 7], -7.0);
+        let (amplitude_re, amplitude_im) = workspace.amplitude_slices();
+        assert!(amplitude_re[..7].iter().all(|value| *value == 0.0));
+        assert_eq!(amplitude_re[7], 3.0);
+        assert_eq!(amplitude_im[7], -3.0);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_layout.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_layout.rs
new file mode 100644
index 0000000000..e9a999b443
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_layout.rs
@@ -0,0 +1,370 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Fixed-width wire contracts for compact eager runtime artifacts.
+//!
+//! This module defines only the versioned storage foundation. Eager lowering
+//! and runtime loading are implemented separately and consume these validated
+//! little-endian sections.
+
+use crate::{RusticolError, RusticolResult};
+
+pub const EAGER_LOWERING_INPUT_ABI: &str = "pyamplicol-eager-lowering-input-v1";
+pub const EAGER_PLAN_ABI: &str = "pyamplicol-eager-plan-v3";
+pub const EAGER_RUNTIME_LAYOUT_ABI: &str = "pyamplicol-eager-runtime-layout-v1";
+pub const EAGER_RUNTIME_CAPABILITY: &str = "rusticol.eager-runtime-layout.complex-f64.v1";
+pub const EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY: &str = "eager-direct-arena-v1";
+pub const EAGER_DIRECT_SOURCE_APPLICATION_ABI: &str = "pyamplicol-symjit-plane-application-v2";
+pub const EAGER_NATIVE_DIRECT_TABLE_APPLICATION_ABI: &str =
+    "pyamplicol-eager-native-direct-table-v1";
+pub const EAGER_DIRECT_TABLE_DESCRIPTOR_ABI: &str = "pyamplicol-eager-plane-table-descriptor-v1";
+pub const EAGER_DIRECT_TABLE_BINDING_ABI: &str = "pyamplicol-eager-plane-table-binding-v2";
+pub const EAGER_RUNTIME_CONTAINER_KIND: &str = "pyamplicol-eager-runtime-container";
+pub const EAGER_RUNTIME_CONTAINER_SCHEMA: u16 = 1;
+pub const EAGER_SECTION_SCHEMA: u16 = 1;
+pub const EAGER_SECTION_HEADER_SIZE: usize = 64;
+pub const EAGER_SECTION_REFERENCE_SIZE: usize = 24;
+
+const SECTION_MAGIC: &[u8; 8] = b"PACERT\0\0";
+const SUPPORTED_FLAGS: u16 = 0;
+
+/// Stable section identifiers used by `eager-runtime.pacbin` members.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+#[repr(u16)]
+pub enum EagerSectionKind {
+    Metadata = 1,
+    CurrentLayout = 2,
+    ValueLayout = 3,
+    MomentumLayout = 4,
+    SourceFill = 5,
+    ParameterLayout = 6,
+    Stages = 7,
+    Couplings = 8,
+    Invocations = 9,
+    Attachments = 10,
+    Finalizations = 11,
+    Closures = 12,
+    SelectorDomains = 13,
+    SelectorMemberships = 14,
+    ReductionGroups = 15,
+    ReductionEntries = 16,
+    ExactFactors = 17,
+    InspectionSummary = 18,
+}
+
+impl EagerSectionKind {
+    fn parse(value: u16) -> RusticolResult<Self> {
+        match value {
+            1 => Ok(Self::Metadata),
+            2 => Ok(Self::CurrentLayout),
+            3 => Ok(Self::ValueLayout),
+            4 => Ok(Self::MomentumLayout),
+            5 => Ok(Self::SourceFill),
+            6 => Ok(Self::ParameterLayout),
+            7 => Ok(Self::Stages),
+            8 => Ok(Self::Couplings),
+            9 => Ok(Self::Invocations),
+            10 => Ok(Self::Attachments),
+            11 => Ok(Self::Finalizations),
+            12 => Ok(Self::Closures),
+            13 => Ok(Self::SelectorDomains),
+            14 => Ok(Self::SelectorMemberships),
+            15 => Ok(Self::ReductionGroups),
+            16 => Ok(Self::ReductionEntries),
+            17 => Ok(Self::ExactFactors),
+            18 => Ok(Self::InspectionSummary),
+            _ => Err(RusticolError::compatibility(format!(
+                "unknown eager runtime section kind: {value}"
+            ))),
+        }
+    }
+}
+
+/// Header preceding every fixed-width eager runtime section.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerSectionHeader {
+    kind: EagerSectionKind,
+    record_size: u32,
+    record_count: u64,
+    payload_length: u64,
+}
+
+impl EagerSectionHeader {
+    pub fn new(
+        kind: EagerSectionKind,
+        record_size: u32,
+        record_count: u64,
+    ) -> RusticolResult<Self> {
+        if record_size == 0 {
+            return Err(RusticolError::invalid_argument(
+                "eager section record size must be positive",
+            ));
+        }
+        let payload_length = u64::from(record_size)
+            .checked_mul(record_count)
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("eager section payload length exceeds u64")
+            })?;
+        Ok(Self {
+            kind,
+            record_size,
+            record_count,
+            payload_length,
+        })
+    }
+
+    pub fn kind(&self) -> EagerSectionKind {
+        self.kind
+    }
+
+    pub fn record_size(&self) -> u32 {
+        self.record_size
+    }
+
+    pub fn record_count(&self) -> u64 {
+        self.record_count
+    }
+
+    pub fn payload_length(&self) -> u64 {
+        self.payload_length
+    }
+
+    pub fn encode(&self) -> [u8; EAGER_SECTION_HEADER_SIZE] {
+        let mut bytes = [0_u8; EAGER_SECTION_HEADER_SIZE];
+        bytes[0..8].copy_from_slice(SECTION_MAGIC);
+        put_u16(&mut bytes, 8, EAGER_SECTION_SCHEMA);
+        put_u16(&mut bytes, 10, EAGER_SECTION_HEADER_SIZE as u16);
+        put_u16(&mut bytes, 12, self.kind as u16);
+        put_u16(&mut bytes, 14, SUPPORTED_FLAGS);
+        put_u32(&mut bytes, 16, self.record_size);
+        put_u64(&mut bytes, 24, self.record_count);
+        put_u64(&mut bytes, 32, EAGER_SECTION_HEADER_SIZE as u64);
+        put_u64(&mut bytes, 40, self.payload_length);
+        bytes
+    }
+
+    /// Decode and validate one complete section, returning its record payload.
+    pub fn decode(section: &[u8]) -> RusticolResult<(Self, &[u8])> {
+        if section.len() < EAGER_SECTION_HEADER_SIZE {
+            return Err(RusticolError::integrity(
+                "truncated eager runtime section header",
+            ));
+        }
+        let header = &section[..EAGER_SECTION_HEADER_SIZE];
+        if &header[0..8] != SECTION_MAGIC {
+            return Err(RusticolError::integrity(
+                "invalid eager runtime section magic",
+            ));
+        }
+        let schema = read_u16(header, 8, "eager section schema")?;
+        if schema != EAGER_SECTION_SCHEMA {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported eager runtime section schema: {schema}"
+            )));
+        }
+        let header_size = read_u16(header, 10, "eager section header size")?;
+        if usize::from(header_size) != EAGER_SECTION_HEADER_SIZE {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported eager runtime section header size: {header_size}"
+            )));
+        }
+        let kind = EagerSectionKind::parse(read_u16(header, 12, "eager section kind")?)?;
+        let flags = read_u16(header, 14, "eager section flags")?;
+        if flags != SUPPORTED_FLAGS {
+            return Err(RusticolError::compatibility(format!(
+                "unknown eager runtime section flags: {flags}"
+            )));
+        }
+        let record_size = read_u32(header, 16, "eager section record size")?;
+        if record_size == 0 {
+            return Err(RusticolError::integrity(
+                "eager section record size must be positive",
+            ));
+        }
+        if read_u32(header, 20, "eager section reserved field")? != 0
+            || header[48..64].iter().any(|value| *value != 0)
+        {
+            return Err(RusticolError::integrity(
+                "eager section reserved fields must be zero",
+            ));
+        }
+        let record_count = read_u64(header, 24, "eager section record count")?;
+        let payload_offset = read_u64(header, 32, "eager section payload offset")?;
+        if payload_offset != EAGER_SECTION_HEADER_SIZE as u64 {
+            return Err(RusticolError::integrity(
+                "eager section payload offset is not canonical",
+            ));
+        }
+        let payload_length = read_u64(header, 40, "eager section payload length")?;
+        let expected_payload_length = u64::from(record_size)
+            .checked_mul(record_count)
+            .ok_or_else(|| RusticolError::integrity("eager section payload length exceeds u64"))?;
+        if payload_length != expected_payload_length {
+            return Err(RusticolError::integrity(
+                "eager section payload length disagrees with record shape",
+            ));
+        }
+        let expected_total = payload_offset
+            .checked_add(payload_length)
+            .ok_or_else(|| RusticolError::integrity("eager section size exceeds u64"))?;
+        let actual_total = u64::try_from(section.len())
+            .map_err(|_| RusticolError::integrity("eager section size exceeds u64"))?;
+        if actual_total < expected_total {
+            return Err(RusticolError::integrity(
+                "truncated eager runtime section payload",
+            ));
+        }
+        if actual_total > expected_total {
+            return Err(RusticolError::integrity(
+                "eager runtime section has trailing bytes",
+            ));
+        }
+        let payload_start = usize::try_from(payload_offset).map_err(|_| {
+            RusticolError::integrity("eager section offset exceeds platform bounds")
+        })?;
+        Ok((
+            Self {
+                kind,
+                record_size,
+                record_count,
+                payload_length,
+            },
+            &section[payload_start..],
+        ))
+    }
+}
+
+/// Fixed-width reference to a contiguous record range in another section.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerSectionReference {
+    kind: EagerSectionKind,
+    start: u64,
+    count: u64,
+}
+
+impl EagerSectionReference {
+    pub fn new(kind: EagerSectionKind, start: u64, count: u64) -> RusticolResult<Self> {
+        start.checked_add(count).ok_or_else(|| {
+            RusticolError::invalid_argument("eager section reference exceeds u64")
+        })?;
+        Ok(Self { kind, start, count })
+    }
+
+    pub fn kind(&self) -> EagerSectionKind {
+        self.kind
+    }
+
+    pub fn start(&self) -> u64 {
+        self.start
+    }
+
+    pub fn count(&self) -> u64 {
+        self.count
+    }
+
+    pub fn encode(&self) -> [u8; EAGER_SECTION_REFERENCE_SIZE] {
+        let mut bytes = [0_u8; EAGER_SECTION_REFERENCE_SIZE];
+        put_u16(&mut bytes, 0, self.kind as u16);
+        put_u16(&mut bytes, 2, SUPPORTED_FLAGS);
+        put_u64(&mut bytes, 8, self.start);
+        put_u64(&mut bytes, 16, self.count);
+        bytes
+    }
+
+    pub fn decode(bytes: &[u8]) -> RusticolResult<Self> {
+        if bytes.len() < EAGER_SECTION_REFERENCE_SIZE {
+            return Err(RusticolError::integrity(
+                "truncated eager section reference",
+            ));
+        }
+        if bytes.len() > EAGER_SECTION_REFERENCE_SIZE {
+            return Err(RusticolError::integrity(
+                "eager section reference has trailing bytes",
+            ));
+        }
+        let kind = EagerSectionKind::parse(read_u16(bytes, 0, "eager reference kind")?)?;
+        let flags = read_u16(bytes, 2, "eager reference flags")?;
+        if flags != SUPPORTED_FLAGS {
+            return Err(RusticolError::compatibility(format!(
+                "unknown eager section reference flags: {flags}"
+            )));
+        }
+        if read_u32(bytes, 4, "eager reference reserved field")? != 0 {
+            return Err(RusticolError::integrity(
+                "eager section reference reserved field must be zero",
+            ));
+        }
+        let start = read_u64(bytes, 8, "eager reference start")?;
+        let count = read_u64(bytes, 16, "eager reference count")?;
+        Self::new(kind, start, count).map_err(|error| RusticolError::integrity(error.to_string()))
+    }
+
+    pub fn validate_against(&self, target: &EagerSectionHeader) -> RusticolResult<()> {
+        if self.kind != target.kind {
+            return Err(RusticolError::integrity(format!(
+                "eager section reference kind {:?} does not match target {:?}",
+                self.kind, target.kind
+            )));
+        }
+        let end = self
+            .start
+            .checked_add(self.count)
+            .ok_or_else(|| RusticolError::integrity("eager section reference exceeds u64"))?;
+        if self.start > target.record_count || end > target.record_count {
+            return Err(RusticolError::integrity(
+                "eager section reference exceeds target record bounds",
+            ));
+        }
+        Ok(())
+    }
+}
+
+fn read_u16(bytes: &[u8], offset: usize, label: &str) -> RusticolResult<u16> {
+    let value: [u8; 2] = checked_slice(bytes, offset, 2, label)?
+        .try_into()
+        .map_err(|_| RusticolError::integrity(format!("truncated {label}")))?;
+    Ok(u16::from_le_bytes(value))
+}
+
+fn read_u32(bytes: &[u8], offset: usize, label: &str) -> RusticolResult<u32> {
+    let value: [u8; 4] = checked_slice(bytes, offset, 4, label)?
+        .try_into()
+        .map_err(|_| RusticolError::integrity(format!("truncated {label}")))?;
+    Ok(u32::from_le_bytes(value))
+}
+
+fn read_u64(bytes: &[u8], offset: usize, label: &str) -> RusticolResult<u64> {
+    let value: [u8; 8] = checked_slice(bytes, offset, 8, label)?
+        .try_into()
+        .map_err(|_| RusticolError::integrity(format!("truncated {label}")))?;
+    Ok(u64::from_le_bytes(value))
+}
+
+fn checked_slice<'a>(
+    bytes: &'a [u8],
+    offset: usize,
+    length: usize,
+    label: &str,
+) -> RusticolResult<&'a [u8]> {
+    let end = offset
+        .checked_add(length)
+        .ok_or_else(|| RusticolError::integrity(format!("{label} range overflow")))?;
+    bytes
+        .get(offset..end)
+        .ok_or_else(|| RusticolError::integrity(format!("truncated {label}")))
+}
+
+fn put_u16(bytes: &mut [u8], offset: usize, value: u16) {
+    bytes[offset..offset + 2].copy_from_slice(&value.to_le_bytes());
+}
+
+fn put_u32(bytes: &mut [u8], offset: usize, value: u32) {
+    bytes[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
+}
+
+fn put_u64(bytes: &mut [u8], offset: usize, value: u64) {
+    bytes[offset..offset + 8].copy_from_slice(&value.to_le_bytes());
+}
+
+#[cfg(test)]
+#[path = "eager_layout_tests.rs"]
+mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_layout_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_layout_tests.rs
new file mode 100644
index 0000000000..e3ec767fb9
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_layout_tests.rs
@@ -0,0 +1,233 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::RusticolErrorKind;
+
+fn section(kind: EagerSectionKind, record_size: u32, record_count: u64) -> Vec<u8> {
+    let header = EagerSectionHeader::new(kind, record_size, record_count).unwrap();
+    let mut bytes = header.encode().to_vec();
+    bytes.resize(
+        EAGER_SECTION_HEADER_SIZE + header.payload_length() as usize,
+        0x5a,
+    );
+    bytes
+}
+
+fn assert_error(bytes: &[u8], kind: RusticolErrorKind, message: &str) {
+    let error = EagerSectionHeader::decode(bytes).unwrap_err();
+    assert_eq!(error.kind(), kind);
+    assert!(
+        error.to_string().contains(message),
+        "expected {:?} to contain {message:?}",
+        error.to_string()
+    );
+}
+
+#[test]
+fn public_contract_constants_are_stable() {
+    assert_eq!(
+        EAGER_LOWERING_INPUT_ABI,
+        "pyamplicol-eager-lowering-input-v1"
+    );
+    assert_eq!(EAGER_PLAN_ABI, "pyamplicol-eager-plan-v3");
+    assert_eq!(
+        EAGER_RUNTIME_LAYOUT_ABI,
+        "pyamplicol-eager-runtime-layout-v1"
+    );
+    assert_eq!(
+        EAGER_RUNTIME_CAPABILITY,
+        "rusticol.eager-runtime-layout.complex-f64.v1"
+    );
+    assert_eq!(
+        EAGER_RUNTIME_CONTAINER_KIND,
+        "pyamplicol-eager-runtime-container"
+    );
+    assert_eq!(EAGER_RUNTIME_CONTAINER_SCHEMA, 1);
+}
+
+#[test]
+fn section_header_is_deterministic_little_endian_and_round_trips() {
+    let bytes = section(EagerSectionKind::Invocations, 40, 3);
+    assert_eq!(&bytes[0..8], b"PACERT\0\0");
+    assert_eq!(&bytes[8..10], &1_u16.to_le_bytes());
+    assert_eq!(&bytes[10..12], &64_u16.to_le_bytes());
+    assert_eq!(&bytes[12..14], &9_u16.to_le_bytes());
+    assert_eq!(&bytes[16..20], &40_u32.to_le_bytes());
+    assert_eq!(&bytes[24..32], &3_u64.to_le_bytes());
+    assert_eq!(&bytes[32..40], &64_u64.to_le_bytes());
+    assert_eq!(&bytes[40..48], &120_u64.to_le_bytes());
+    let (header, payload) = EagerSectionHeader::decode(&bytes).unwrap();
+    assert_eq!(header.kind(), EagerSectionKind::Invocations);
+    assert_eq!(header.record_size(), 40);
+    assert_eq!(header.record_count(), 3);
+    assert_eq!(header.payload_length(), 120);
+    assert_eq!(payload, vec![0x5a; 120]);
+    assert_eq!(header.encode(), bytes[..EAGER_SECTION_HEADER_SIZE]);
+}
+
+#[test]
+fn zero_record_sections_are_valid_but_zero_width_and_overflow_are_rejected() {
+    let bytes = section(EagerSectionKind::Metadata, 16, 0);
+    let (header, payload) = EagerSectionHeader::decode(&bytes).unwrap();
+    assert_eq!(header.record_count(), 0);
+    assert!(payload.is_empty());
+
+    let zero = EagerSectionHeader::new(EagerSectionKind::Metadata, 0, 1).unwrap_err();
+    assert_eq!(zero.kind(), RusticolErrorKind::InvalidArgument);
+    assert!(zero.to_string().contains("record size"));
+    let overflow =
+        EagerSectionHeader::new(EagerSectionKind::Metadata, u32::MAX, u64::MAX).unwrap_err();
+    assert_eq!(overflow.kind(), RusticolErrorKind::InvalidArgument);
+    assert!(overflow.to_string().contains("exceeds u64"));
+}
+
+#[test]
+fn section_header_rejects_contract_corruption_and_noncanonical_lengths() {
+    let golden = section(EagerSectionKind::Attachments, 24, 2);
+    for (offset, replacement, kind, message) in [
+        (0, vec![b'X'], RusticolErrorKind::Integrity, "magic"),
+        (
+            8,
+            2_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "schema",
+        ),
+        (
+            10,
+            32_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "header size",
+        ),
+        (
+            12,
+            99_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "section kind",
+        ),
+        (
+            14,
+            1_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "flags",
+        ),
+        (
+            16,
+            0_u32.to_le_bytes().to_vec(),
+            RusticolErrorKind::Integrity,
+            "record size",
+        ),
+        (
+            20,
+            1_u32.to_le_bytes().to_vec(),
+            RusticolErrorKind::Integrity,
+            "reserved",
+        ),
+        (
+            32,
+            63_u64.to_le_bytes().to_vec(),
+            RusticolErrorKind::Integrity,
+            "payload offset",
+        ),
+        (
+            40,
+            47_u64.to_le_bytes().to_vec(),
+            RusticolErrorKind::Integrity,
+            "payload length",
+        ),
+    ] {
+        let mut bytes = golden.clone();
+        bytes[offset..offset + replacement.len()].copy_from_slice(&replacement);
+        assert_error(&bytes, kind, message);
+    }
+    let mut reserved = golden.clone();
+    reserved[63] = 1;
+    assert_error(&reserved, RusticolErrorKind::Integrity, "reserved fields");
+    assert_error(
+        &golden[..golden.len() - 1],
+        RusticolErrorKind::Integrity,
+        "truncated",
+    );
+    let mut trailing = golden;
+    trailing.push(0);
+    assert_error(&trailing, RusticolErrorKind::Integrity, "trailing bytes");
+}
+
+#[test]
+fn section_references_round_trip_and_validate_bounds_and_kind() {
+    let target = EagerSectionHeader::new(EagerSectionKind::Invocations, 40, 100).unwrap();
+    let reference = EagerSectionReference::new(EagerSectionKind::Invocations, 10, 20).unwrap();
+    let bytes = reference.encode();
+    assert_eq!(&bytes[0..2], &9_u16.to_le_bytes());
+    assert_eq!(&bytes[8..16], &10_u64.to_le_bytes());
+    assert_eq!(&bytes[16..24], &20_u64.to_le_bytes());
+    let decoded = EagerSectionReference::decode(&bytes).unwrap();
+    assert_eq!(decoded, reference);
+    decoded.validate_against(&target).unwrap();
+
+    EagerSectionReference::new(EagerSectionKind::Invocations, 100, 0)
+        .unwrap()
+        .validate_against(&target)
+        .unwrap();
+    let out_of_bounds = EagerSectionReference::new(EagerSectionKind::Invocations, 99, 2)
+        .unwrap()
+        .validate_against(&target)
+        .unwrap_err();
+    assert_eq!(out_of_bounds.kind(), RusticolErrorKind::Integrity);
+    assert!(out_of_bounds.to_string().contains("bounds"));
+    let wrong_kind = EagerSectionReference::new(EagerSectionKind::Closures, 0, 1)
+        .unwrap()
+        .validate_against(&target)
+        .unwrap_err();
+    assert_eq!(wrong_kind.kind(), RusticolErrorKind::Integrity);
+    assert!(wrong_kind.to_string().contains("does not match"));
+    let overflow =
+        EagerSectionReference::new(EagerSectionKind::Invocations, u64::MAX, 1).unwrap_err();
+    assert_eq!(overflow.kind(), RusticolErrorKind::InvalidArgument);
+}
+
+#[test]
+fn section_reference_rejects_corruption() {
+    let golden = EagerSectionReference::new(EagerSectionKind::Closures, 2, 3)
+        .unwrap()
+        .encode();
+    for (offset, replacement, kind, message) in [
+        (
+            0,
+            99_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "kind",
+        ),
+        (
+            2,
+            1_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "flags",
+        ),
+        (
+            4,
+            1_u32.to_le_bytes().to_vec(),
+            RusticolErrorKind::Integrity,
+            "reserved",
+        ),
+    ] {
+        let mut bytes = golden;
+        bytes[offset..offset + replacement.len()].copy_from_slice(&replacement);
+        let error = EagerSectionReference::decode(&bytes).unwrap_err();
+        assert_eq!(error.kind(), kind);
+        assert!(error.to_string().contains(message));
+    }
+    assert!(
+        EagerSectionReference::decode(&golden[..golden.len() - 1])
+            .unwrap_err()
+            .to_string()
+            .contains("truncated")
+    );
+    let mut trailing = golden.to_vec();
+    trailing.push(0);
+    assert!(
+        EagerSectionReference::decode(&trailing)
+            .unwrap_err()
+            .to_string()
+            .contains("trailing")
+    );
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_lowering_v3.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_lowering_v3.rs
new file mode 100644
index 0000000000..8c973d4d9e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_lowering_v3.rs
@@ -0,0 +1,4124 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Validated columnar input and deterministic lowering for eager plan v3.
+//!
+//! This module deliberately stops at an owned, fixed-width in-memory plan. It
+//! neither writes PACBIN nor replaces the plan-v2 execution runtime. The Python
+//! binding can borrow contiguous NumPy columns through the views below, build a
+//! validated owned input, release the GIL, and call [`lower_eager_plan_v3`].
+
+use crate::eager_layout::{
+    EAGER_LOWERING_INPUT_ABI, EAGER_PLAN_ABI, EagerSectionHeader, EagerSectionKind,
+};
+use crate::{MISSING_U32, RusticolError, RusticolResult};
+use std::cmp::Ordering;
+use std::collections::{BTreeMap, BTreeSet};
+
+const EXACT_SOURCE_BINARY64: u8 = 0;
+const EXACT_SOURCE_CANONICAL_IR: u8 = 1;
+const OUTPUT_FACTOR_NONE: u8 = 0;
+const OUTPUT_FACTOR_COUPLING_REAL: u8 = 1;
+const OUTPUT_FACTOR_COUPLING_IMAG: u8 = 2;
+
+const CURRENT_FLAG_SOURCE: u32 = 1 << 0;
+
+/// Complete, sorted table set defined by `pyamplicol-eager-lowering-input-v1`.
+///
+/// The binding supplies retained fragments for every table. Columns consumed
+/// by typed views may be omitted from a fragment; all other columns are copied
+/// bit-for-bit into the owned input and plan.
+pub const EAGER_LOWERING_V1_TABLE_NAMES: &[&str] = &[
+    "bitset_ranges",
+    "bitset_words",
+    "coherent_groups",
+    "color_contraction_entries",
+    "color_contraction_metadata",
+    "color_open_lines",
+    "color_plan_diagnostics",
+    "color_replay_contraction_component_groups",
+    "color_replay_contraction_entries",
+    "color_replay_contraction_metadata",
+    "color_replay_mappings",
+    "color_replay_metadata",
+    "color_replay_permutations",
+    "color_replay_physical_groups",
+    "color_replay_routes",
+    "color_sectors",
+    "color_selectors",
+    "contraction_coefficients",
+    "coupling_orders",
+    "couplings",
+    "currents",
+    "exact_factors",
+    "helicity_amplitude_classes",
+    "helicity_amplitude_member_domains",
+    "helicity_amplitude_members",
+    "helicity_domain_states",
+    "helicity_domains",
+    "helicity_materialization_metadata",
+    "helicity_materialized_amplitude_domains",
+    "helicity_materialized_amplitude_routes",
+    "helicity_materialized_current_map",
+    "helicity_materialized_schedules",
+    "helicity_materialized_source_routes",
+    "helicity_proof_diagnostics",
+    "helicity_proof_metadata",
+    "helicity_recurrence_classes",
+    "helicity_recurrence_members",
+    "helicity_residual_currents",
+    "helicity_residual_roots",
+    "helicity_selectors",
+    "helicity_source_mappings",
+    "helicity_structural_zero_domains",
+    "i32_sequence_ranges",
+    "i32_sequence_values",
+    "interaction_group_members",
+    "interaction_groups",
+    "interactions",
+    "lc_replay_diagnostics",
+    "lc_replay_members",
+    "lc_replay_metadata",
+    "lc_replay_partitions",
+    "lc_replay_permutations",
+    "lc_replay_residual_sectors",
+    "metadata",
+    "model_parameters",
+    "momentum_masks",
+    "quantum_flows",
+    "reduction_members",
+    "roots",
+    "selected_color_sectors",
+    "selected_source_helicities",
+    "sources",
+    "u32_sequence_ranges",
+    "u32_sequence_values",
+];
+
+/// Borrowed primitive storage for a retained column fragment.
+#[derive(Clone, Copy, Debug)]
+pub enum EagerPrimitiveColumnView<'a> {
+    U8(&'a [u8]),
+    U32(&'a [u32]),
+    U64(&'a [u64]),
+    I32(&'a [i32]),
+    F64(&'a [f64]),
+}
+
+impl EagerPrimitiveColumnView<'_> {
+    fn len(self) -> usize {
+        match self {
+            Self::U8(values) => values.len(),
+            Self::U32(values) => values.len(),
+            Self::U64(values) => values.len(),
+            Self::I32(values) => values.len(),
+            Self::F64(values) => values.len(),
+        }
+    }
+}
+
+/// One borrowed fixed-shape column not consumed by a typed lowering view.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerRetainedColumnView<'a> {
+    pub name: &'a str,
+    /// Number of primitive values per table row, including trailing shape.
+    pub elements_per_row: u32,
+    pub values: EagerPrimitiveColumnView<'a>,
+}
+
+/// Retained fragment for one source table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerRetainedTableView<'a> {
+    pub name: &'a str,
+    pub row_count: u64,
+    pub columns: &'a [EagerRetainedColumnView<'a>],
+}
+
+/// Owned primitive storage for retained metadata/proof columns.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum EagerOwnedPrimitiveColumn {
+    U8(Vec<u8>),
+    U32(Vec<u32>),
+    U64(Vec<u64>),
+    I32(Vec<i32>),
+    /// Raw IEEE-754 bits preserve signed zero exactly.
+    F64Bits(Vec<u64>),
+}
+
+impl EagerOwnedPrimitiveColumn {
+    pub fn element_count(&self) -> usize {
+        match self {
+            Self::U8(values) => values.len(),
+            Self::U32(values) => values.len(),
+            Self::U64(values) | Self::F64Bits(values) => values.len(),
+            Self::I32(values) => values.len(),
+        }
+    }
+}
+
+/// Owned retained column with a deterministic primitive shape.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EagerOwnedRetainedColumn {
+    name: Box<str>,
+    elements_per_row: u32,
+    values: EagerOwnedPrimitiveColumn,
+}
+
+impl EagerOwnedRetainedColumn {
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn elements_per_row(&self) -> u32 {
+        self.elements_per_row
+    }
+
+    pub fn values(&self) -> &EagerOwnedPrimitiveColumn {
+        &self.values
+    }
+}
+
+/// Owned retained table fragment carried unchanged into plan-v3.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EagerOwnedRetainedTable {
+    name: Box<str>,
+    row_count: u64,
+    columns: Vec<EagerOwnedRetainedColumn>,
+}
+
+impl EagerOwnedRetainedTable {
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn row_count(&self) -> u64 {
+        self.row_count
+    }
+
+    pub fn columns(&self) -> &[EagerOwnedRetainedColumn] {
+        &self.columns
+    }
+}
+
+/// Borrowed columns from the `currents` input table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerCurrentColumns<'a> {
+    pub id: &'a [u32],
+    pub dimension: &'a [u32],
+    pub is_source: &'a [u8],
+    pub momentum_mask_bitset_id: &'a [u32],
+    pub propagator_ir_id: &'a [u32],
+    pub propagator_kernel_id: &'a [u32],
+}
+
+/// Borrowed columns from the `sources` input table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerSourceColumns<'a> {
+    pub source_id: &'a [u32],
+    pub current_id: &'a [u32],
+    pub external_label: &'a [u32],
+    pub input_momentum_slot: &'a [u32],
+    pub source_ir_id: &'a [u32],
+    pub crossing_ir_id: &'a [u32],
+    pub crossing_factor_id: &'a [u32],
+    pub declared_state_index: &'a [u32],
+}
+
+/// Borrowed columns from the `interactions` input table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerInteractionColumns<'a> {
+    pub id: &'a [u32],
+    pub stage_subset_size: &'a [u32],
+    pub left_current_id: &'a [u32],
+    pub right_current_id: &'a [u32],
+    pub result_current_id: &'a [u32],
+    pub coupling_id: &'a [u32],
+    pub coupling_factor_id: &'a [u32],
+    pub color_factor_id: &'a [u32],
+    pub evaluation_factor_id: &'a [u32],
+    pub evaluation_group_id: &'a [u32],
+    pub full_tensor_network_ready: &'a [u8],
+    pub kernel_id: &'a [u32],
+    pub canonical_input_order: &'a [[u8; 2]],
+    pub kernel_normalization_factor_id: &'a [u32],
+    pub output_factor_source: &'a [u8],
+}
+
+/// Borrowed columns from the `roots` input table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerRootColumns<'a> {
+    pub id: &'a [u32],
+    pub left_current_id: &'a [u32],
+    pub right_current_id: &'a [u32],
+    pub color_factor_id: &'a [u32],
+    pub contraction_ir_id: &'a [u32],
+    pub coupling_id: &'a [u32],
+    pub coupling_factor_id: &'a [u32],
+    pub helicity_weight_factor_id: &'a [u32],
+    pub coherent_group_id: &'a [u32],
+    pub kernel_id: &'a [u32],
+    pub canonical_input_order: &'a [[u8; 2]],
+    pub kernel_normalization_factor_id: &'a [u32],
+    pub output_factor_source: &'a [u8],
+}
+
+/// Borrowed columns from `interaction_groups` and
+/// `interaction_group_members`.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerInteractionGroupColumns<'a> {
+    pub representative_interaction_id: &'a [u32],
+    pub member_start: &'a [u64],
+    pub member_count: &'a [u64],
+    pub member_interaction_id: &'a [u32],
+}
+
+/// Borrowed columns from the `momentum_masks` table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerMomentumMaskColumns<'a> {
+    pub slot_id: &'a [u32],
+    pub bitset_id: &'a [u32],
+}
+
+/// Borrowed arbitrary-width bitset catalog.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerBitsetColumns<'a> {
+    pub start: &'a [u64],
+    pub count: &'a [u64],
+    pub bit_count: &'a [u64],
+    pub words: &'a [u64],
+}
+
+/// Borrowed unsigned sequence catalog.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerU32SequenceColumns<'a> {
+    pub start: &'a [u64],
+    pub count: &'a [u64],
+    pub values: &'a [u32],
+}
+
+/// Borrowed signed sequence catalog.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerI32SequenceColumns<'a> {
+    pub start: &'a [u64],
+    pub count: &'a [u64],
+    pub values: &'a [i32],
+}
+
+/// Borrowed columns from the `exact_factors` table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerExactFactorColumns<'a> {
+    pub real: &'a [f64],
+    pub imaginary: &'a [f64],
+    pub canonical_string_id: &'a [u32],
+    pub exact_source: &'a [u8],
+    pub exact_ir_id: &'a [u32],
+    pub source_ir_id: &'a [u32],
+}
+
+/// Borrowed columns from the `couplings` table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerCouplingColumns<'a> {
+    pub constant_factor_id: &'a [u32],
+    pub parameter_name_ids_sequence_id: &'a [u32],
+}
+
+/// Borrowed columns from the `model_parameters` table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerModelParameterColumns<'a> {
+    pub name_string_id: &'a [u32],
+    pub kind_string_id: &'a [u32],
+    pub default_value: &'a [f64],
+    pub default_factor_id: &'a [u32],
+    pub runtime_name_string_id: &'a [u32],
+    pub complex_component: &'a [i32],
+    pub derived: &'a [u8],
+}
+
+/// Borrowed columns from the `contraction_coefficients` table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerContractionCoefficientColumns<'a> {
+    pub contraction_ir_id: &'a [u32],
+    pub component_index: &'a [u32],
+    pub factor_id: &'a [u32],
+}
+
+/// Borrowed columns from the `coherent_groups` table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerCoherentGroupColumns<'a> {
+    pub id: &'a [u32],
+    pub helicity_weight_factor_id: &'a [u32],
+    pub all_sector_weight_factor_id: &'a [u32],
+}
+
+/// Borrowed columns from the `helicity_selectors` table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerHelicitySelectorColumns<'a> {
+    pub values_sequence_id: &'a [u32],
+    pub representative_sequence_id: &'a [u32],
+    pub coefficient_factor_id: &'a [u32],
+    pub computed: &'a [u8],
+    pub structural_zero: &'a [u8],
+}
+
+/// Borrowed columns from the `color_selectors` table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerColorSelectorColumns<'a> {
+    pub word_sequence_id: &'a [u32],
+    pub representative_word_sequence_id: &'a [u32],
+    pub coefficient_factor_id: &'a [u32],
+    pub computed: &'a [u8],
+}
+
+/// Borrowed columns from the `reduction_members` table.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerReductionMemberColumns<'a> {
+    pub coherent_group_id: &'a [u32],
+    pub helicity_selector_id: &'a [u32],
+    pub color_selector_id: &'a [u32],
+}
+
+/// Scalar row from `color_contraction_metadata`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerColorContractionMetadata {
+    pub present: u8,
+    pub supported: u8,
+    pub group_count: u64,
+    pub includes_color_factor: u8,
+}
+
+/// Borrowed columns from `color_contraction_entries`.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerColorContractionEntryColumns<'a> {
+    pub left_group_id: &'a [u32],
+    pub right_group_id: &'a [u32],
+    pub weight_factor_id: &'a [u32],
+    pub symmetry_factor_id: &'a [u32],
+}
+
+/// Complete borrowed core view of `pyamplicol-eager-lowering-input-v1`.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerLoweringInputV1View<'a> {
+    pub abi: &'a str,
+    pub process_key: &'a str,
+    pub model_name: &'a str,
+    pub string_catalog: &'a [&'a str],
+    pub canonical_ir_catalog: &'a [&'a str],
+    pub semantic_limitations: &'a [&'a str],
+    /// Exact v1 table inventory with unconsumed columns retained by the writer.
+    pub retained_tables: &'a [EagerRetainedTableView<'a>],
+    /// Tables the binding cannot represent. Any entry makes construction fail.
+    pub unsupported_tables: &'a [&'a str],
+    pub currents: EagerCurrentColumns<'a>,
+    pub sources: EagerSourceColumns<'a>,
+    pub interactions: EagerInteractionColumns<'a>,
+    pub roots: EagerRootColumns<'a>,
+    pub interaction_groups: EagerInteractionGroupColumns<'a>,
+    pub momentum_masks: EagerMomentumMaskColumns<'a>,
+    pub bitsets: EagerBitsetColumns<'a>,
+    pub u32_sequences: EagerU32SequenceColumns<'a>,
+    pub i32_sequences: EagerI32SequenceColumns<'a>,
+    pub exact_factors: EagerExactFactorColumns<'a>,
+    pub couplings: EagerCouplingColumns<'a>,
+    pub model_parameters: EagerModelParameterColumns<'a>,
+    pub contraction_coefficients: EagerContractionCoefficientColumns<'a>,
+    pub coherent_groups: EagerCoherentGroupColumns<'a>,
+    pub helicity_selectors: EagerHelicitySelectorColumns<'a>,
+    pub color_selectors: EagerColorSelectorColumns<'a>,
+    pub reduction_members: EagerReductionMemberColumns<'a>,
+    pub color_contraction: EagerColorContractionMetadata,
+    pub color_contraction_entries: EagerColorContractionEntryColumns<'a>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputCurrent {
+    id: u32,
+    dimension: u32,
+    is_source: bool,
+    momentum_mask_bitset_id: u32,
+    propagator_ir_id: u32,
+    propagator_kernel_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputSource {
+    source_id: u32,
+    current_id: u32,
+    external_label: u32,
+    input_momentum_slot: u32,
+    source_ir_id: u32,
+    crossing_ir_id: u32,
+    crossing_factor_id: u32,
+    declared_state_index: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputInteraction {
+    id: u32,
+    stage_subset_size: u32,
+    left_current_id: u32,
+    right_current_id: u32,
+    result_current_id: u32,
+    coupling_id: u32,
+    coupling_factor_id: u32,
+    color_factor_id: u32,
+    evaluation_factor_id: u32,
+    evaluation_group_id: u32,
+    kernel_id: u32,
+    canonical_input_order: [u8; 2],
+    kernel_normalization_factor_id: u32,
+    output_factor_source: u8,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputRoot {
+    id: u32,
+    left_current_id: u32,
+    right_current_id: u32,
+    color_factor_id: u32,
+    contraction_ir_id: u32,
+    coupling_id: u32,
+    coupling_factor_id: u32,
+    helicity_weight_factor_id: u32,
+    coherent_group_id: u32,
+    kernel_id: u32,
+    canonical_input_order: [u8; 2],
+    kernel_normalization_factor_id: u32,
+    output_factor_source: u8,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputRange {
+    start: u64,
+    count: u64,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputInteractionGroup {
+    representative_interaction_id: u32,
+    members: InputRange,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputBitsetRange {
+    range: InputRange,
+    bit_count: u64,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputExactFactor {
+    real_bits: u64,
+    imaginary_bits: u64,
+    canonical_string_id: u32,
+    exact_source: u8,
+    exact_ir_id: u32,
+    source_ir_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputCoupling {
+    constant_factor_id: u32,
+    parameter_name_ids_sequence_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputModelParameter {
+    name_string_id: u32,
+    kind_string_id: u32,
+    default_bits: u64,
+    default_factor_id: u32,
+    runtime_name_string_id: u32,
+    complex_component: i32,
+    derived: bool,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputContractionCoefficient {
+    contraction_ir_id: u32,
+    component_index: u32,
+    factor_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputCoherentGroup {
+    id: u32,
+    helicity_weight_factor_id: u32,
+    all_sector_weight_factor_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputHelicitySelector {
+    values_sequence_id: u32,
+    representative_sequence_id: u32,
+    coefficient_factor_id: u32,
+    computed: bool,
+    structural_zero: bool,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputColorSelector {
+    word_sequence_id: u32,
+    representative_word_sequence_id: u32,
+    coefficient_factor_id: u32,
+    computed: bool,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputReductionMember {
+    coherent_group_id: u32,
+    helicity_selector_id: u32,
+    color_selector_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct InputColorContractionEntry {
+    left_group_id: u32,
+    right_group_id: u32,
+    weight_factor_id: u32,
+    symmetry_factor_id: u32,
+}
+
+/// Owned, fully validated core representation of the v1 lowering input.
+///
+/// Fields are private so an instance cannot be put back into an invalid state.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EagerLoweringInputV1 {
+    process_key: String,
+    model_name: String,
+    string_catalog: Vec<Box<str>>,
+    canonical_ir_catalog: Vec<Box<str>>,
+    semantic_limitations: Vec<Box<str>>,
+    retained_tables: Vec<EagerOwnedRetainedTable>,
+    string_count: u32,
+    canonical_ir_count: u32,
+    currents: Vec<InputCurrent>,
+    sources: Vec<InputSource>,
+    interactions: Vec<InputInteraction>,
+    roots: Vec<InputRoot>,
+    interaction_groups: Vec<InputInteractionGroup>,
+    interaction_group_members: Vec<u32>,
+    momentum_masks: Vec<(u32, u32)>,
+    bitset_ranges: Vec<InputBitsetRange>,
+    bitset_words: Vec<u64>,
+    u32_sequence_ranges: Vec<InputRange>,
+    u32_sequence_values: Vec<u32>,
+    i32_sequence_ranges: Vec<InputRange>,
+    i32_sequence_values: Vec<i32>,
+    exact_factors: Vec<InputExactFactor>,
+    couplings: Vec<InputCoupling>,
+    model_parameters: Vec<InputModelParameter>,
+    contraction_coefficients: Vec<InputContractionCoefficient>,
+    coherent_groups: Vec<InputCoherentGroup>,
+    helicity_selectors: Vec<InputHelicitySelector>,
+    color_selectors: Vec<InputColorSelector>,
+    reduction_members: Vec<InputReductionMember>,
+    color_contraction: EagerColorContractionMetadata,
+    color_contraction_entries: Vec<InputColorContractionEntry>,
+}
+
+impl EagerLoweringInputV1 {
+    /// Validate borrowed columns and copy them into a compact owned form.
+    ///
+    /// Bindings should construct the view directly over borrowed NumPy columns
+    /// while holding the GIL, then call this method exactly once. The returned
+    /// input owns every payload and may be lowered after releasing the GIL.
+    pub fn try_from_view(view: EagerLoweringInputV1View<'_>) -> RusticolResult<Self> {
+        if view.abi != EAGER_LOWERING_INPUT_ABI {
+            return Err(invalid(format!(
+                "unsupported eager lowering input ABI {:?}",
+                view.abi
+            )));
+        }
+        if view.process_key.is_empty() {
+            return Err(invalid("eager lowering process key must not be empty"));
+        }
+        if view.model_name.is_empty() {
+            return Err(invalid("eager lowering model name must not be empty"));
+        }
+        if view.semantic_limitations.is_empty() {
+            return Err(invalid(
+                "eager lowering exact-factor limitations must not be empty",
+            ));
+        }
+        if !view.unsupported_tables.is_empty() {
+            return Err(invalid(format!(
+                "eager lowering input contains unsupported tables: {}",
+                view.unsupported_tables.join(", ")
+            )));
+        }
+        let string_catalog = copy_string_catalog(view.string_catalog, "string catalog")?;
+        let canonical_ir_catalog =
+            copy_string_catalog(view.canonical_ir_catalog, "canonical IR catalog")?;
+        let semantic_limitations =
+            copy_string_list(view.semantic_limitations, "semantic limitations")?;
+        let retained_tables = copy_retained_tables(view.retained_tables)?;
+        let string_count = usize_u32(string_catalog.len(), "string catalog count")?;
+        let canonical_ir_count =
+            usize_u32(canonical_ir_catalog.len(), "canonical IR catalog count")?;
+
+        let current_count = equal_column_lengths(
+            "currents",
+            &[
+                ("id", view.currents.id.len()),
+                ("dimension", view.currents.dimension.len()),
+                ("is_source", view.currents.is_source.len()),
+                (
+                    "momentum_mask_bitset_id",
+                    view.currents.momentum_mask_bitset_id.len(),
+                ),
+                ("propagator_ir_id", view.currents.propagator_ir_id.len()),
+                (
+                    "propagator_kernel_id",
+                    view.currents.propagator_kernel_id.len(),
+                ),
+            ],
+        )?;
+        let mut currents = reserved(current_count, "currents")?;
+        for row in 0..current_count {
+            currents.push(InputCurrent {
+                id: view.currents.id[row],
+                dimension: view.currents.dimension[row],
+                is_source: bool_column(view.currents.is_source[row], "currents.is_source", row)?,
+                momentum_mask_bitset_id: view.currents.momentum_mask_bitset_id[row],
+                propagator_ir_id: view.currents.propagator_ir_id[row],
+                propagator_kernel_id: view.currents.propagator_kernel_id[row],
+            });
+        }
+
+        let source_count = equal_column_lengths(
+            "sources",
+            &[
+                ("source_id", view.sources.source_id.len()),
+                ("current_id", view.sources.current_id.len()),
+                ("external_label", view.sources.external_label.len()),
+                (
+                    "input_momentum_slot",
+                    view.sources.input_momentum_slot.len(),
+                ),
+                ("source_ir_id", view.sources.source_ir_id.len()),
+                ("crossing_ir_id", view.sources.crossing_ir_id.len()),
+                ("crossing_factor_id", view.sources.crossing_factor_id.len()),
+                (
+                    "declared_state_index",
+                    view.sources.declared_state_index.len(),
+                ),
+            ],
+        )?;
+        let mut sources = reserved(source_count, "sources")?;
+        for row in 0..source_count {
+            sources.push(InputSource {
+                source_id: view.sources.source_id[row],
+                current_id: view.sources.current_id[row],
+                external_label: view.sources.external_label[row],
+                input_momentum_slot: view.sources.input_momentum_slot[row],
+                source_ir_id: view.sources.source_ir_id[row],
+                crossing_ir_id: view.sources.crossing_ir_id[row],
+                crossing_factor_id: view.sources.crossing_factor_id[row],
+                declared_state_index: view.sources.declared_state_index[row],
+            });
+        }
+
+        let interaction_count = equal_column_lengths(
+            "interactions",
+            &[
+                ("id", view.interactions.id.len()),
+                (
+                    "stage_subset_size",
+                    view.interactions.stage_subset_size.len(),
+                ),
+                ("left_current_id", view.interactions.left_current_id.len()),
+                ("right_current_id", view.interactions.right_current_id.len()),
+                (
+                    "result_current_id",
+                    view.interactions.result_current_id.len(),
+                ),
+                ("coupling_id", view.interactions.coupling_id.len()),
+                (
+                    "coupling_factor_id",
+                    view.interactions.coupling_factor_id.len(),
+                ),
+                ("color_factor_id", view.interactions.color_factor_id.len()),
+                (
+                    "evaluation_factor_id",
+                    view.interactions.evaluation_factor_id.len(),
+                ),
+                (
+                    "evaluation_group_id",
+                    view.interactions.evaluation_group_id.len(),
+                ),
+                (
+                    "full_tensor_network_ready",
+                    view.interactions.full_tensor_network_ready.len(),
+                ),
+                ("kernel_id", view.interactions.kernel_id.len()),
+                (
+                    "canonical_input_order",
+                    view.interactions.canonical_input_order.len(),
+                ),
+                (
+                    "kernel_normalization_factor_id",
+                    view.interactions.kernel_normalization_factor_id.len(),
+                ),
+                (
+                    "output_factor_source",
+                    view.interactions.output_factor_source.len(),
+                ),
+            ],
+        )?;
+        let mut interactions = reserved(interaction_count, "interactions")?;
+        for row in 0..interaction_count {
+            if !bool_column(
+                view.interactions.full_tensor_network_ready[row],
+                "interactions.full_tensor_network_ready",
+                row,
+            )? {
+                return Err(invalid(format!(
+                    "interaction {row} is not ready for tensor-network lowering"
+                )));
+            }
+            interactions.push(InputInteraction {
+                id: view.interactions.id[row],
+                stage_subset_size: view.interactions.stage_subset_size[row],
+                left_current_id: view.interactions.left_current_id[row],
+                right_current_id: view.interactions.right_current_id[row],
+                result_current_id: view.interactions.result_current_id[row],
+                coupling_id: view.interactions.coupling_id[row],
+                coupling_factor_id: view.interactions.coupling_factor_id[row],
+                color_factor_id: view.interactions.color_factor_id[row],
+                evaluation_factor_id: view.interactions.evaluation_factor_id[row],
+                evaluation_group_id: view.interactions.evaluation_group_id[row],
+                kernel_id: view.interactions.kernel_id[row],
+                canonical_input_order: view.interactions.canonical_input_order[row],
+                kernel_normalization_factor_id: view.interactions.kernel_normalization_factor_id
+                    [row],
+                output_factor_source: view.interactions.output_factor_source[row],
+            });
+        }
+
+        let root_count = equal_column_lengths(
+            "roots",
+            &[
+                ("id", view.roots.id.len()),
+                ("left_current_id", view.roots.left_current_id.len()),
+                ("right_current_id", view.roots.right_current_id.len()),
+                ("color_factor_id", view.roots.color_factor_id.len()),
+                ("contraction_ir_id", view.roots.contraction_ir_id.len()),
+                ("coupling_id", view.roots.coupling_id.len()),
+                ("coupling_factor_id", view.roots.coupling_factor_id.len()),
+                (
+                    "helicity_weight_factor_id",
+                    view.roots.helicity_weight_factor_id.len(),
+                ),
+                ("coherent_group_id", view.roots.coherent_group_id.len()),
+                ("kernel_id", view.roots.kernel_id.len()),
+                (
+                    "canonical_input_order",
+                    view.roots.canonical_input_order.len(),
+                ),
+                (
+                    "kernel_normalization_factor_id",
+                    view.roots.kernel_normalization_factor_id.len(),
+                ),
+                (
+                    "output_factor_source",
+                    view.roots.output_factor_source.len(),
+                ),
+            ],
+        )?;
+        let mut roots = reserved(root_count, "roots")?;
+        for row in 0..root_count {
+            roots.push(InputRoot {
+                id: view.roots.id[row],
+                left_current_id: view.roots.left_current_id[row],
+                right_current_id: view.roots.right_current_id[row],
+                color_factor_id: view.roots.color_factor_id[row],
+                contraction_ir_id: view.roots.contraction_ir_id[row],
+                coupling_id: view.roots.coupling_id[row],
+                coupling_factor_id: view.roots.coupling_factor_id[row],
+                helicity_weight_factor_id: view.roots.helicity_weight_factor_id[row],
+                coherent_group_id: view.roots.coherent_group_id[row],
+                kernel_id: view.roots.kernel_id[row],
+                canonical_input_order: view.roots.canonical_input_order[row],
+                kernel_normalization_factor_id: view.roots.kernel_normalization_factor_id[row],
+                output_factor_source: view.roots.output_factor_source[row],
+            });
+        }
+
+        let group_count = equal_column_lengths(
+            "interaction_groups",
+            &[
+                (
+                    "representative_interaction_id",
+                    view.interaction_groups.representative_interaction_id.len(),
+                ),
+                ("member_start", view.interaction_groups.member_start.len()),
+                ("member_count", view.interaction_groups.member_count.len()),
+            ],
+        )?;
+        let mut interaction_groups = reserved(group_count, "interaction groups")?;
+        for row in 0..group_count {
+            interaction_groups.push(InputInteractionGroup {
+                representative_interaction_id: view
+                    .interaction_groups
+                    .representative_interaction_id[row],
+                members: InputRange {
+                    start: view.interaction_groups.member_start[row],
+                    count: view.interaction_groups.member_count[row],
+                },
+            });
+        }
+
+        let momentum_count = equal_column_lengths(
+            "momentum_masks",
+            &[
+                ("slot_id", view.momentum_masks.slot_id.len()),
+                ("bitset_id", view.momentum_masks.bitset_id.len()),
+            ],
+        )?;
+        let mut momentum_masks = reserved(momentum_count, "momentum masks")?;
+        momentum_masks.extend(
+            view.momentum_masks
+                .slot_id
+                .iter()
+                .copied()
+                .zip(view.momentum_masks.bitset_id.iter().copied()),
+        );
+
+        let bitset_count = equal_column_lengths(
+            "bitset_ranges",
+            &[
+                ("start", view.bitsets.start.len()),
+                ("count", view.bitsets.count.len()),
+                ("bit_count", view.bitsets.bit_count.len()),
+            ],
+        )?;
+        let mut bitset_ranges = reserved(bitset_count, "bitset ranges")?;
+        for row in 0..bitset_count {
+            bitset_ranges.push(InputBitsetRange {
+                range: InputRange {
+                    start: view.bitsets.start[row],
+                    count: view.bitsets.count[row],
+                },
+                bit_count: view.bitsets.bit_count[row],
+            });
+        }
+
+        let u32_sequence_count = equal_column_lengths(
+            "u32_sequence_ranges",
+            &[
+                ("start", view.u32_sequences.start.len()),
+                ("count", view.u32_sequences.count.len()),
+            ],
+        )?;
+        let mut u32_sequence_ranges = reserved(u32_sequence_count, "u32 sequences")?;
+        for row in 0..u32_sequence_count {
+            u32_sequence_ranges.push(InputRange {
+                start: view.u32_sequences.start[row],
+                count: view.u32_sequences.count[row],
+            });
+        }
+
+        let i32_sequence_count = equal_column_lengths(
+            "i32_sequence_ranges",
+            &[
+                ("start", view.i32_sequences.start.len()),
+                ("count", view.i32_sequences.count.len()),
+            ],
+        )?;
+        let mut i32_sequence_ranges = reserved(i32_sequence_count, "i32 sequences")?;
+        for row in 0..i32_sequence_count {
+            i32_sequence_ranges.push(InputRange {
+                start: view.i32_sequences.start[row],
+                count: view.i32_sequences.count[row],
+            });
+        }
+
+        let factor_count = equal_column_lengths(
+            "exact_factors",
+            &[
+                ("real", view.exact_factors.real.len()),
+                ("imaginary", view.exact_factors.imaginary.len()),
+                (
+                    "canonical_string_id",
+                    view.exact_factors.canonical_string_id.len(),
+                ),
+                ("exact_source", view.exact_factors.exact_source.len()),
+                ("exact_ir_id", view.exact_factors.exact_ir_id.len()),
+                ("source_ir_id", view.exact_factors.source_ir_id.len()),
+            ],
+        )?;
+        let mut exact_factors = reserved(factor_count, "exact factors")?;
+        for row in 0..factor_count {
+            let real = view.exact_factors.real[row];
+            let imaginary = view.exact_factors.imaginary[row];
+            if !real.is_finite() || !imaginary.is_finite() {
+                return Err(invalid(format!("exact factor {row} is not finite")));
+            }
+            exact_factors.push(InputExactFactor {
+                real_bits: real.to_bits(),
+                imaginary_bits: imaginary.to_bits(),
+                canonical_string_id: view.exact_factors.canonical_string_id[row],
+                exact_source: view.exact_factors.exact_source[row],
+                exact_ir_id: view.exact_factors.exact_ir_id[row],
+                source_ir_id: view.exact_factors.source_ir_id[row],
+            });
+        }
+
+        let coupling_count = equal_column_lengths(
+            "couplings",
+            &[
+                (
+                    "constant_factor_id",
+                    view.couplings.constant_factor_id.len(),
+                ),
+                (
+                    "parameter_name_ids_sequence_id",
+                    view.couplings.parameter_name_ids_sequence_id.len(),
+                ),
+            ],
+        )?;
+        let mut couplings = reserved(coupling_count, "couplings")?;
+        for row in 0..coupling_count {
+            couplings.push(InputCoupling {
+                constant_factor_id: view.couplings.constant_factor_id[row],
+                parameter_name_ids_sequence_id: view.couplings.parameter_name_ids_sequence_id[row],
+            });
+        }
+
+        let parameter_count = equal_column_lengths(
+            "model_parameters",
+            &[
+                ("name_string_id", view.model_parameters.name_string_id.len()),
+                ("kind_string_id", view.model_parameters.kind_string_id.len()),
+                ("default_value", view.model_parameters.default_value.len()),
+                (
+                    "default_factor_id",
+                    view.model_parameters.default_factor_id.len(),
+                ),
+                (
+                    "runtime_name_string_id",
+                    view.model_parameters.runtime_name_string_id.len(),
+                ),
+                (
+                    "complex_component",
+                    view.model_parameters.complex_component.len(),
+                ),
+                ("derived", view.model_parameters.derived.len()),
+            ],
+        )?;
+        let mut model_parameters = reserved(parameter_count, "model parameters")?;
+        for row in 0..parameter_count {
+            let default = view.model_parameters.default_value[row];
+            if !default.is_finite() {
+                return Err(invalid(format!(
+                    "model parameter {row} has a non-finite default"
+                )));
+            }
+            model_parameters.push(InputModelParameter {
+                name_string_id: view.model_parameters.name_string_id[row],
+                kind_string_id: view.model_parameters.kind_string_id[row],
+                default_bits: default.to_bits(),
+                default_factor_id: view.model_parameters.default_factor_id[row],
+                runtime_name_string_id: view.model_parameters.runtime_name_string_id[row],
+                complex_component: view.model_parameters.complex_component[row],
+                derived: bool_column(
+                    view.model_parameters.derived[row],
+                    "model_parameters.derived",
+                    row,
+                )?,
+            });
+        }
+
+        let coefficient_count = equal_column_lengths(
+            "contraction_coefficients",
+            &[
+                (
+                    "contraction_ir_id",
+                    view.contraction_coefficients.contraction_ir_id.len(),
+                ),
+                (
+                    "component_index",
+                    view.contraction_coefficients.component_index.len(),
+                ),
+                ("factor_id", view.contraction_coefficients.factor_id.len()),
+            ],
+        )?;
+        let mut contraction_coefficients = reserved(coefficient_count, "contraction coefficients")?;
+        for row in 0..coefficient_count {
+            contraction_coefficients.push(InputContractionCoefficient {
+                contraction_ir_id: view.contraction_coefficients.contraction_ir_id[row],
+                component_index: view.contraction_coefficients.component_index[row],
+                factor_id: view.contraction_coefficients.factor_id[row],
+            });
+        }
+
+        let coherent_count = equal_column_lengths(
+            "coherent_groups",
+            &[
+                ("id", view.coherent_groups.id.len()),
+                (
+                    "helicity_weight_factor_id",
+                    view.coherent_groups.helicity_weight_factor_id.len(),
+                ),
+                (
+                    "all_sector_weight_factor_id",
+                    view.coherent_groups.all_sector_weight_factor_id.len(),
+                ),
+            ],
+        )?;
+        let mut coherent_groups = reserved(coherent_count, "coherent groups")?;
+        for row in 0..coherent_count {
+            coherent_groups.push(InputCoherentGroup {
+                id: view.coherent_groups.id[row],
+                helicity_weight_factor_id: view.coherent_groups.helicity_weight_factor_id[row],
+                all_sector_weight_factor_id: view.coherent_groups.all_sector_weight_factor_id[row],
+            });
+        }
+
+        let helicity_selector_count = equal_column_lengths(
+            "helicity_selectors",
+            &[
+                (
+                    "values_sequence_id",
+                    view.helicity_selectors.values_sequence_id.len(),
+                ),
+                (
+                    "representative_sequence_id",
+                    view.helicity_selectors.representative_sequence_id.len(),
+                ),
+                (
+                    "coefficient_factor_id",
+                    view.helicity_selectors.coefficient_factor_id.len(),
+                ),
+                ("computed", view.helicity_selectors.computed.len()),
+                (
+                    "structural_zero",
+                    view.helicity_selectors.structural_zero.len(),
+                ),
+            ],
+        )?;
+        let mut helicity_selectors = reserved(helicity_selector_count, "helicity selectors")?;
+        for row in 0..helicity_selector_count {
+            helicity_selectors.push(InputHelicitySelector {
+                values_sequence_id: view.helicity_selectors.values_sequence_id[row],
+                representative_sequence_id: view.helicity_selectors.representative_sequence_id[row],
+                coefficient_factor_id: view.helicity_selectors.coefficient_factor_id[row],
+                computed: bool_column(
+                    view.helicity_selectors.computed[row],
+                    "helicity_selectors.computed",
+                    row,
+                )?,
+                structural_zero: bool_column(
+                    view.helicity_selectors.structural_zero[row],
+                    "helicity_selectors.structural_zero",
+                    row,
+                )?,
+            });
+        }
+
+        let color_selector_count = equal_column_lengths(
+            "color_selectors",
+            &[
+                (
+                    "word_sequence_id",
+                    view.color_selectors.word_sequence_id.len(),
+                ),
+                (
+                    "representative_word_sequence_id",
+                    view.color_selectors.representative_word_sequence_id.len(),
+                ),
+                (
+                    "coefficient_factor_id",
+                    view.color_selectors.coefficient_factor_id.len(),
+                ),
+                ("computed", view.color_selectors.computed.len()),
+            ],
+        )?;
+        let mut color_selectors = reserved(color_selector_count, "color selectors")?;
+        for row in 0..color_selector_count {
+            color_selectors.push(InputColorSelector {
+                word_sequence_id: view.color_selectors.word_sequence_id[row],
+                representative_word_sequence_id: view
+                    .color_selectors
+                    .representative_word_sequence_id[row],
+                coefficient_factor_id: view.color_selectors.coefficient_factor_id[row],
+                computed: bool_column(
+                    view.color_selectors.computed[row],
+                    "color_selectors.computed",
+                    row,
+                )?,
+            });
+        }
+
+        let reduction_count = equal_column_lengths(
+            "reduction_members",
+            &[
+                (
+                    "coherent_group_id",
+                    view.reduction_members.coherent_group_id.len(),
+                ),
+                (
+                    "helicity_selector_id",
+                    view.reduction_members.helicity_selector_id.len(),
+                ),
+                (
+                    "color_selector_id",
+                    view.reduction_members.color_selector_id.len(),
+                ),
+            ],
+        )?;
+        let mut reduction_members = reserved(reduction_count, "reduction members")?;
+        for row in 0..reduction_count {
+            reduction_members.push(InputReductionMember {
+                coherent_group_id: view.reduction_members.coherent_group_id[row],
+                helicity_selector_id: view.reduction_members.helicity_selector_id[row],
+                color_selector_id: view.reduction_members.color_selector_id[row],
+            });
+        }
+
+        let contraction_entry_count = equal_column_lengths(
+            "color_contraction_entries",
+            &[
+                (
+                    "left_group_id",
+                    view.color_contraction_entries.left_group_id.len(),
+                ),
+                (
+                    "right_group_id",
+                    view.color_contraction_entries.right_group_id.len(),
+                ),
+                (
+                    "weight_factor_id",
+                    view.color_contraction_entries.weight_factor_id.len(),
+                ),
+                (
+                    "symmetry_factor_id",
+                    view.color_contraction_entries.symmetry_factor_id.len(),
+                ),
+            ],
+        )?;
+        let mut color_contraction_entries =
+            reserved(contraction_entry_count, "color contraction entries")?;
+        for row in 0..contraction_entry_count {
+            color_contraction_entries.push(InputColorContractionEntry {
+                left_group_id: view.color_contraction_entries.left_group_id[row],
+                right_group_id: view.color_contraction_entries.right_group_id[row],
+                weight_factor_id: view.color_contraction_entries.weight_factor_id[row],
+                symmetry_factor_id: view.color_contraction_entries.symmetry_factor_id[row],
+            });
+        }
+
+        let input = Self {
+            process_key: view.process_key.to_owned(),
+            model_name: view.model_name.to_owned(),
+            string_catalog,
+            canonical_ir_catalog,
+            semantic_limitations,
+            retained_tables,
+            string_count,
+            canonical_ir_count,
+            currents,
+            sources,
+            interactions,
+            roots,
+            interaction_groups,
+            interaction_group_members: copy_slice(
+                view.interaction_groups.member_interaction_id,
+                "interaction group members",
+            )?,
+            momentum_masks,
+            bitset_ranges,
+            bitset_words: copy_slice(view.bitsets.words, "bitset words")?,
+            u32_sequence_ranges,
+            u32_sequence_values: copy_slice(view.u32_sequences.values, "u32 sequence values")?,
+            i32_sequence_ranges,
+            i32_sequence_values: copy_slice(view.i32_sequences.values, "i32 sequence values")?,
+            exact_factors,
+            couplings,
+            model_parameters,
+            contraction_coefficients,
+            coherent_groups,
+            helicity_selectors,
+            color_selectors,
+            reduction_members,
+            color_contraction: view.color_contraction,
+            color_contraction_entries,
+        };
+        input.validate()?;
+        Ok(input)
+    }
+
+    pub fn process_key(&self) -> &str {
+        &self.process_key
+    }
+
+    pub fn model_name(&self) -> &str {
+        &self.model_name
+    }
+
+    pub fn string_catalog(&self) -> &[Box<str>] {
+        &self.string_catalog
+    }
+
+    pub fn canonical_ir_catalog(&self) -> &[Box<str>] {
+        &self.canonical_ir_catalog
+    }
+
+    pub fn semantic_limitations(&self) -> &[Box<str>] {
+        &self.semantic_limitations
+    }
+
+    pub fn retained_tables(&self) -> &[EagerOwnedRetainedTable] {
+        &self.retained_tables
+    }
+
+    pub fn current_count(&self) -> usize {
+        self.currents.len()
+    }
+
+    pub fn interaction_count(&self) -> usize {
+        self.interactions.len()
+    }
+
+    pub fn root_count(&self) -> usize {
+        self.roots.len()
+    }
+
+    pub fn exact_factor_count(&self) -> usize {
+        self.exact_factors.len()
+    }
+
+    fn validate(&self) -> RusticolResult<()> {
+        validate_retained_table_counts(self)?;
+        if self.currents.is_empty() {
+            return Err(invalid("eager lowering input has no currents"));
+        }
+        if self.roots.is_empty() {
+            return Err(invalid("eager lowering input has no amplitude roots"));
+        }
+        validate_dense_ids(
+            self.currents.iter().map(|row| row.id),
+            self.currents.len(),
+            "current",
+        )?;
+        validate_dense_ids(
+            self.interactions.iter().map(|row| row.id),
+            self.interactions.len(),
+            "interaction",
+        )?;
+        validate_dense_ids(
+            self.roots.iter().map(|row| row.id),
+            self.roots.len(),
+            "root",
+        )?;
+        validate_dense_ids(
+            self.sources.iter().map(|row| row.source_id),
+            self.sources.len(),
+            "source",
+        )?;
+        validate_dense_ids(
+            self.coherent_groups.iter().map(|row| row.id),
+            self.coherent_groups.len(),
+            "coherent group",
+        )?;
+
+        validate_flat_ranges(
+            self.bitset_ranges.iter().map(|row| row.range),
+            self.bitset_words.len(),
+            "bitset catalog",
+        )?;
+        for (bitset_id, row) in self.bitset_ranges.iter().enumerate() {
+            let words = range_slice(&self.bitset_words, row.range, "bitset words")?;
+            let actual_count = words.iter().try_fold(0_u64, |total, word| {
+                total
+                    .checked_add(u64::from(word.count_ones()))
+                    .ok_or_else(|| {
+                        invalid(format!("bitset {bitset_id} population count exceeds u64"))
+                    })
+            })?;
+            if actual_count != row.bit_count {
+                return Err(invalid(format!(
+                    "bitset {bitset_id} declares {} set bits, found {actual_count}",
+                    row.bit_count
+                )));
+            }
+            if words.last().is_some_and(|word| *word == 0) {
+                return Err(invalid(format!(
+                    "bitset {bitset_id} has a noncanonical trailing zero word"
+                )));
+            }
+        }
+        validate_flat_ranges(
+            self.u32_sequence_ranges.iter().copied(),
+            self.u32_sequence_values.len(),
+            "u32 sequence catalog",
+        )?;
+        validate_flat_ranges(
+            self.i32_sequence_ranges.iter().copied(),
+            self.i32_sequence_values.len(),
+            "i32 sequence catalog",
+        )?;
+
+        let mut previous_momentum_bitset = None;
+        let mut momentum_by_bitset = vec![MISSING_U32; self.bitset_ranges.len()];
+        for (row, (slot_id, bitset_id)) in self.momentum_masks.iter().copied().enumerate() {
+            expect_dense_id(slot_id, row, "momentum slot")?;
+            let bitset_index = index(bitset_id, self.bitset_ranges.len(), "momentum bitset")?;
+            if momentum_by_bitset[bitset_index] != MISSING_U32 {
+                return Err(invalid(format!(
+                    "momentum bitset {bitset_id} is assigned more than once"
+                )));
+            }
+            if let Some(previous) = previous_momentum_bitset
+                && compare_bitsets(self, previous, bitset_id)? != Ordering::Less
+            {
+                return Err(invalid(
+                    "momentum masks must be unique and ordered by population then value",
+                ));
+            }
+            previous_momentum_bitset = Some(bitset_id);
+            momentum_by_bitset[bitset_index] = slot_id;
+        }
+
+        let mut source_seen = vec![false; self.currents.len()];
+        for source in &self.sources {
+            let current_index = index(source.current_id, self.currents.len(), "source current")?;
+            if !self.currents[current_index].is_source {
+                return Err(invalid(format!(
+                    "source {} references non-source current {}",
+                    source.source_id, source.current_id
+                )));
+            }
+            if std::mem::replace(&mut source_seen[current_index], true) {
+                return Err(invalid(format!(
+                    "source current {} is listed more than once",
+                    source.current_id
+                )));
+            }
+            required_index(source.source_ir_id, self.canonical_ir_count, "source IR")?;
+            required_index(
+                source.crossing_ir_id,
+                self.canonical_ir_count,
+                "source crossing IR",
+            )?;
+            required_index(
+                source.crossing_factor_id,
+                self.exact_factors.len(),
+                "source crossing factor",
+            )?;
+        }
+        for (current_id, current) in self.currents.iter().enumerate() {
+            if current.dimension == 0 {
+                return Err(invalid(format!("current {current_id} has zero dimension")));
+            }
+            required_index(
+                current.momentum_mask_bitset_id,
+                self.bitset_ranges.len(),
+                "current momentum bitset",
+            )?;
+            if momentum_by_bitset[current.momentum_mask_bitset_id as usize] == MISSING_U32 {
+                return Err(invalid(format!(
+                    "current {current_id} momentum bitset {} has no momentum slot",
+                    current.momentum_mask_bitset_id
+                )));
+            }
+            required_index(
+                current.propagator_ir_id,
+                self.canonical_ir_count,
+                "current propagator IR",
+            )?;
+            if current.is_source != source_seen[current_id] {
+                return Err(invalid(format!(
+                    "current {current_id} source flag disagrees with the source table"
+                )));
+            }
+        }
+
+        for (factor_id, factor) in self.exact_factors.iter().enumerate() {
+            required_index(
+                factor.canonical_string_id,
+                self.string_count,
+                "exact factor canonical string",
+            )?;
+            required_index(
+                factor.exact_ir_id,
+                self.canonical_ir_count,
+                "exact factor IR",
+            )?;
+            optional_index(
+                factor.source_ir_id,
+                self.canonical_ir_count,
+                "exact factor source IR",
+            )?;
+            if !matches!(
+                factor.exact_source,
+                EXACT_SOURCE_BINARY64 | EXACT_SOURCE_CANONICAL_IR
+            ) {
+                return Err(invalid(format!(
+                    "exact factor {factor_id} has unsupported provenance {}",
+                    factor.exact_source
+                )));
+            }
+        }
+
+        for (parameter_id, parameter) in self.model_parameters.iter().enumerate() {
+            required_index(
+                parameter.name_string_id,
+                self.string_count,
+                "parameter name",
+            )?;
+            required_index(
+                parameter.kind_string_id,
+                self.string_count,
+                "parameter kind",
+            )?;
+            optional_index(
+                parameter.runtime_name_string_id,
+                self.string_count,
+                "parameter runtime name",
+            )?;
+            let factor = required_row(
+                &self.exact_factors,
+                parameter.default_factor_id,
+                "parameter default factor",
+            )?;
+            if factor.real_bits != parameter.default_bits || !factor_is_real_zero(factor) {
+                return Err(invalid(format!(
+                    "model parameter {parameter_id} default disagrees with its exact factor"
+                )));
+            }
+            if !matches!(parameter.complex_component, -1..=1) {
+                return Err(invalid(format!(
+                    "model parameter {parameter_id} has invalid complex component {}",
+                    parameter.complex_component
+                )));
+            }
+            let _ = parameter.derived;
+        }
+
+        for (coupling_id, coupling) in self.couplings.iter().enumerate() {
+            required_index(
+                coupling.constant_factor_id,
+                self.exact_factors.len(),
+                "coupling constant factor",
+            )?;
+            let names = self.u32_sequence(coupling.parameter_name_ids_sequence_id)?;
+            if names.len() > 2 {
+                return Err(invalid(format!(
+                    "coupling {coupling_id} has more than two parameter names"
+                )));
+            }
+            for name in names.iter().copied().filter(|name| *name != MISSING_U32) {
+                required_index(name, self.string_count, "coupling parameter name")?;
+            }
+        }
+
+        let mut result_stage = vec![None; self.currents.len()];
+        for (interaction_id, interaction) in self.interactions.iter().enumerate() {
+            if interaction.stage_subset_size == 0 {
+                return Err(invalid(format!(
+                    "interaction {interaction_id} has zero stage subset size"
+                )));
+            }
+            let left = index(
+                interaction.left_current_id,
+                self.currents.len(),
+                "interaction left current",
+            )?;
+            let right = index(
+                interaction.right_current_id,
+                self.currents.len(),
+                "interaction right current",
+            )?;
+            let result = index(
+                interaction.result_current_id,
+                self.currents.len(),
+                "interaction result current",
+            )?;
+            if self.currents[result].is_source {
+                return Err(invalid(format!(
+                    "interaction {interaction_id} writes source current {result}"
+                )));
+            }
+            for input in [left, right] {
+                if !self.currents[input].is_source
+                    && result_stage[input]
+                        .is_some_and(|stage| stage >= interaction.stage_subset_size)
+                {
+                    return Err(invalid(format!(
+                        "interaction {interaction_id} does not follow DAG stage order"
+                    )));
+                }
+            }
+            match result_stage[result] {
+                Some(stage) if stage != interaction.stage_subset_size => {
+                    return Err(invalid(format!(
+                        "current {result} is produced in multiple stages"
+                    )));
+                }
+                None => result_stage[result] = Some(interaction.stage_subset_size),
+                _ => {}
+            }
+            required_index(
+                interaction.coupling_id,
+                self.couplings.len(),
+                "interaction coupling",
+            )?;
+            for (name, factor_id) in [
+                ("coupling", interaction.coupling_factor_id),
+                ("color", interaction.color_factor_id),
+                ("evaluation", interaction.evaluation_factor_id),
+                (
+                    "kernel normalization",
+                    interaction.kernel_normalization_factor_id,
+                ),
+            ] {
+                required_index(factor_id, self.exact_factors.len(), name)?;
+            }
+            if interaction.coupling_factor_id
+                != self.couplings[interaction.coupling_id as usize].constant_factor_id
+            {
+                return Err(invalid(format!(
+                    "interaction {interaction_id} coupling factor disagrees with coupling {}",
+                    interaction.coupling_id
+                )));
+            }
+            validate_kernel_transform(
+                interaction.kernel_id,
+                interaction.canonical_input_order,
+                interaction.output_factor_source,
+                false,
+                &format!("interaction {interaction_id}"),
+            )?;
+        }
+
+        for (current_id, current) in self.currents.iter().enumerate() {
+            if !current.is_source && result_stage[current_id].is_none() {
+                return Err(invalid(format!(
+                    "non-source current {current_id} has no producing interaction"
+                )));
+            }
+        }
+
+        validate_flat_ranges(
+            self.interaction_groups.iter().map(|row| row.members),
+            self.interaction_group_members.len(),
+            "interaction groups",
+        )?;
+        if self.interaction_group_members.len() != self.interactions.len() {
+            return Err(invalid(
+                "interaction groups must contain every interaction exactly once",
+            ));
+        }
+        let mut grouped = vec![false; self.interactions.len()];
+        for (group_id, group) in self.interaction_groups.iter().enumerate() {
+            if group.members.count == 0 {
+                return Err(invalid(format!("interaction group {group_id} is empty")));
+            }
+            let members = range_slice(
+                &self.interaction_group_members,
+                group.members,
+                "interaction group members",
+            )?;
+            if members[0] != group.representative_interaction_id {
+                return Err(invalid(format!(
+                    "interaction group {group_id} representative is not its first member"
+                )));
+            }
+            let representative = required_row(
+                &self.interactions,
+                group.representative_interaction_id,
+                "interaction group representative",
+            )?;
+            if representative.evaluation_group_id != group_id as u32 {
+                return Err(invalid(format!(
+                    "interaction group {group_id} representative has a different group ID"
+                )));
+            }
+            let representative_is_zero = factor_is_complex_zero(
+                &self.exact_factors[representative.evaluation_factor_id as usize],
+            );
+            let mut group_has_nonzero_member = false;
+            for member_id in members {
+                let member_index = index(*member_id, self.interactions.len(), "group member")?;
+                if std::mem::replace(&mut grouped[member_index], true) {
+                    return Err(invalid(format!(
+                        "interaction {member_id} appears in more than one group"
+                    )));
+                }
+                let member = &self.interactions[member_index];
+                group_has_nonzero_member |= !factor_is_complex_zero(
+                    &self.exact_factors[member.evaluation_factor_id as usize],
+                );
+                if member.evaluation_group_id != group_id as u32 {
+                    return Err(invalid(format!(
+                        "interaction {member_id} has group {}, expected {group_id}",
+                        member.evaluation_group_id
+                    )));
+                }
+                validate_group_signature(representative, member, group_id)?;
+            }
+            if representative_is_zero && group_has_nonzero_member {
+                return Err(invalid(format!(
+                    "interaction group {group_id} places a zero evaluation factor \
+                     before a live member"
+                )));
+            }
+        }
+        if grouped.iter().any(|seen| !seen) {
+            return Err(invalid("interaction group partition is incomplete"));
+        }
+
+        for (root_id, root) in self.roots.iter().enumerate() {
+            required_index(
+                root.left_current_id,
+                self.currents.len(),
+                "root left current",
+            )?;
+            required_index(
+                root.right_current_id,
+                self.currents.len(),
+                "root right current",
+            )?;
+            required_index(
+                root.color_factor_id,
+                self.exact_factors.len(),
+                "root color factor",
+            )?;
+            required_index(
+                root.contraction_ir_id,
+                self.canonical_ir_count,
+                "root contraction IR",
+            )?;
+            required_index(
+                root.coupling_factor_id,
+                self.exact_factors.len(),
+                "root coupling factor",
+            )?;
+            required_index(
+                root.helicity_weight_factor_id,
+                self.exact_factors.len(),
+                "root helicity weight",
+            )?;
+            required_index(
+                root.kernel_normalization_factor_id,
+                self.exact_factors.len(),
+                "root kernel normalization",
+            )?;
+            required_index(
+                root.coherent_group_id,
+                self.coherent_groups.len(),
+                "root coherent group",
+            )?;
+            if root.coupling_id != MISSING_U32 {
+                let coupling = required_row(&self.couplings, root.coupling_id, "root coupling")?;
+                if coupling.constant_factor_id != root.coupling_factor_id {
+                    return Err(invalid(format!(
+                        "root {root_id} coupling factor disagrees with coupling {}",
+                        root.coupling_id
+                    )));
+                }
+            }
+            validate_kernel_transform(
+                root.kernel_id,
+                root.canonical_input_order,
+                root.output_factor_source,
+                true,
+                &format!("root {root_id}"),
+            )?;
+        }
+
+        let mut previous_coefficient: Option<(u32, u32)> = None;
+        for (row, coefficient) in self.contraction_coefficients.iter().enumerate() {
+            required_index(
+                coefficient.contraction_ir_id,
+                self.canonical_ir_count,
+                "contraction coefficient IR",
+            )?;
+            required_index(
+                coefficient.factor_id,
+                self.exact_factors.len(),
+                "contraction coefficient factor",
+            )?;
+            match previous_coefficient {
+                Some((previous_ir, _)) if coefficient.contraction_ir_id < previous_ir => {
+                    return Err(invalid(format!(
+                        "contraction coefficient row {row} is not canonically ordered"
+                    )));
+                }
+                Some((previous_ir, previous_component))
+                    if coefficient.contraction_ir_id == previous_ir =>
+                {
+                    let expected_component =
+                        previous_component.checked_add(1).ok_or_else(|| {
+                            invalid(format!(
+                                "contraction IR {} component index exceeds u32",
+                                coefficient.contraction_ir_id
+                            ))
+                        })?;
+                    if coefficient.component_index != expected_component {
+                        return Err(invalid(format!(
+                            "contraction coefficient row {row} is not canonically ordered"
+                        )));
+                    }
+                }
+                _ if coefficient.component_index != 0 => {
+                    return Err(invalid(format!(
+                        "contraction IR {} starts at component {}",
+                        coefficient.contraction_ir_id, coefficient.component_index
+                    )));
+                }
+                _ => {}
+            }
+            previous_coefficient =
+                Some((coefficient.contraction_ir_id, coefficient.component_index));
+        }
+
+        for group in &self.coherent_groups {
+            required_index(
+                group.helicity_weight_factor_id,
+                self.exact_factors.len(),
+                "coherent-group helicity weight",
+            )?;
+            required_index(
+                group.all_sector_weight_factor_id,
+                self.exact_factors.len(),
+                "coherent-group all-sector weight",
+            )?;
+        }
+        for (selector_id, selector) in self.helicity_selectors.iter().enumerate() {
+            let values = self.i32_sequence(selector.values_sequence_id)?;
+            let representative = self.i32_sequence(selector.representative_sequence_id)?;
+            if values.len() != representative.len() {
+                return Err(invalid(format!(
+                    "helicity selector {selector_id} alias has a different width"
+                )));
+            }
+            required_index(
+                selector.coefficient_factor_id,
+                self.exact_factors.len(),
+                "helicity selector coefficient",
+            )?;
+            if selector.computed && selector.structural_zero {
+                return Err(invalid(format!(
+                    "helicity selector {selector_id} is both computed and structural zero"
+                )));
+            }
+            if selector.structural_zero
+                && !factor_is_complex_zero(
+                    &self.exact_factors[selector.coefficient_factor_id as usize],
+                )
+            {
+                return Err(invalid(format!(
+                    "structural-zero helicity selector {selector_id} has a nonzero coefficient"
+                )));
+            }
+        }
+        for (selector_id, selector) in self.color_selectors.iter().enumerate() {
+            let values = self.u32_sequence(selector.word_sequence_id)?;
+            let representative = self.u32_sequence(selector.representative_word_sequence_id)?;
+            if values.len() != representative.len() {
+                return Err(invalid(format!(
+                    "color selector {selector_id} alias has a different width"
+                )));
+            }
+            required_index(
+                selector.coefficient_factor_id,
+                self.exact_factors.len(),
+                "color selector coefficient",
+            )?;
+        }
+        let mut reduction_keys = BTreeSet::new();
+        let mut group_has_reduction = vec![false; self.coherent_groups.len()];
+        for member in &self.reduction_members {
+            let group = index(
+                member.coherent_group_id,
+                self.coherent_groups.len(),
+                "reduction coherent group",
+            )?;
+            required_index(
+                member.helicity_selector_id,
+                self.helicity_selectors.len(),
+                "reduction helicity selector",
+            )?;
+            required_index(
+                member.color_selector_id,
+                self.color_selectors.len(),
+                "reduction color selector",
+            )?;
+            if !reduction_keys.insert((
+                member.coherent_group_id,
+                member.helicity_selector_id,
+                member.color_selector_id,
+            )) {
+                return Err(invalid("duplicate selector reduction member"));
+            }
+            group_has_reduction[group] = true;
+        }
+        if group_has_reduction.iter().any(|present| !present) {
+            return Err(invalid("every coherent group must have reduction metadata"));
+        }
+
+        let contraction = self.color_contraction;
+        validate_bool_scalar(contraction.present, "color contraction present")?;
+        validate_bool_scalar(contraction.supported, "color contraction supported")?;
+        validate_bool_scalar(
+            contraction.includes_color_factor,
+            "color contraction includes-color-factor",
+        )?;
+        if contraction.present == 0 {
+            if !self.color_contraction_entries.is_empty() || contraction.group_count != 0 {
+                return Err(invalid(
+                    "absent color contraction has entries or a nonzero group count",
+                ));
+            }
+        } else {
+            if contraction.supported == 0 {
+                return Err(invalid("unsupported color contraction cannot be lowered"));
+            }
+            if contraction.group_count != self.coherent_groups.len() as u64 {
+                return Err(invalid(
+                    "color contraction group count disagrees with coherent groups",
+                ));
+            }
+            if self.color_contraction_entries.is_empty() {
+                return Err(invalid("present color contraction has no entries"));
+            }
+        }
+        for entry in &self.color_contraction_entries {
+            required_index(
+                entry.left_group_id,
+                self.coherent_groups.len(),
+                "color contraction left group",
+            )?;
+            required_index(
+                entry.right_group_id,
+                self.coherent_groups.len(),
+                "color contraction right group",
+            )?;
+            required_index(
+                entry.weight_factor_id,
+                self.exact_factors.len(),
+                "color contraction weight",
+            )?;
+            required_index(
+                entry.symmetry_factor_id,
+                self.exact_factors.len(),
+                "color contraction symmetry",
+            )?;
+        }
+        Ok(())
+    }
+
+    fn u32_sequence(&self, id: u32) -> RusticolResult<&[u32]> {
+        let range = required_row(&self.u32_sequence_ranges, id, "u32 sequence")?;
+        range_slice(&self.u32_sequence_values, *range, "u32 sequence values")
+    }
+
+    fn i32_sequence(&self, id: u32) -> RusticolResult<&[i32]> {
+        let range = required_row(&self.i32_sequence_ranges, id, "i32 sequence")?;
+        range_slice(&self.i32_sequence_values, *range, "i32 sequence values")
+    }
+}
+
+/// Value-slot role in the compact plan.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub enum EagerValueSlotKind {
+    Source = 1,
+    Unpropagated = 2,
+    Propagated = 3,
+}
+
+/// One logical current and its global component range.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanCurrentRow {
+    pub current_id: u32,
+    pub component_start: u64,
+    pub component_count: u32,
+    pub momentum_slot_id: u32,
+    pub flags: u32,
+}
+
+impl EagerPlanCurrentRow {
+    pub const ENCODED_LEN: u32 = 24;
+}
+
+/// One value slot and its global component range.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanValueRow {
+    pub value_slot_id: u32,
+    pub current_id: u32,
+    pub component_start: u64,
+    pub component_count: u32,
+    pub kind: EagerValueSlotKind,
+}
+
+impl EagerPlanValueRow {
+    pub const ENCODED_LEN: u32 = 24;
+}
+
+/// One canonical arbitrary-width momentum mask.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanMomentumRow {
+    pub momentum_slot_id: u32,
+    pub bitset_id: u32,
+    pub component_start: u64,
+    pub component_count: u32,
+}
+
+impl EagerPlanMomentumRow {
+    pub const ENCODED_LEN: u32 = 24;
+}
+
+/// Source initialization metadata retained for exact execution.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanSourceFillRow {
+    pub source_id: u32,
+    pub current_id: u32,
+    pub value_slot_id: u32,
+    pub external_label: u32,
+    pub input_momentum_slot: u32,
+    pub source_ir_id: u32,
+    pub crossing_ir_id: u32,
+    pub crossing_factor_id: u32,
+    pub declared_state_index: u32,
+}
+
+impl EagerPlanSourceFillRow {
+    pub const ENCODED_LEN: u32 = 40;
+}
+
+/// Model-parameter metadata for the compact parameter layout.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanParameterRow {
+    pub parameter_id: u32,
+    pub name_string_id: u32,
+    pub kind_string_id: u32,
+    pub default_factor_id: u32,
+    pub runtime_name_string_id: u32,
+    pub complex_component: i32,
+    pub flags: u32,
+}
+
+impl EagerPlanParameterRow {
+    pub const ENCODED_LEN: u32 = 32;
+}
+
+/// One stage and its contiguous ranges in the execution tables.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanStageRow {
+    pub stage_index: u32,
+    pub subset_size: u32,
+    pub invocation_start: u64,
+    pub invocation_count: u64,
+    pub attachment_start: u64,
+    pub attachment_count: u64,
+    pub finalization_start: u64,
+    pub finalization_count: u64,
+}
+
+impl EagerPlanStageRow {
+    pub const ENCODED_LEN: u32 = 56;
+}
+
+/// Runtime coupling with exact constant provenance and optional parameter slots.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanCouplingRow {
+    pub coupling_id: u32,
+    pub real_parameter_id: u32,
+    pub imaginary_parameter_id: u32,
+    pub constant_factor_id: u32,
+}
+
+impl EagerPlanCouplingRow {
+    pub const ENCODED_LEN: u32 = 16;
+}
+
+/// One prepared vertex invocation.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanInvocationRow {
+    pub evaluation_group_id: u32,
+    pub kernel_id: u32,
+    pub left_value_slot_id: u32,
+    pub right_value_slot_id: u32,
+    pub left_momentum_slot_id: u32,
+    pub right_momentum_slot_id: u32,
+    pub coupling_slot_id: u32,
+    pub output_factor_source: u8,
+    pub attachment_start: u64,
+    pub attachment_count: u64,
+    pub selector_domain_id: u32,
+}
+
+impl EagerPlanInvocationRow {
+    pub const ENCODED_LEN: u32 = 56;
+}
+
+/// One invocation fan-out attachment.
+///
+/// Its exact factor is `color * evaluation * normalization /
+/// representative_evaluation`. Keeping all four IDs avoids an irreversible
+/// f64 collapse during lowering.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanAttachmentRow {
+    pub interaction_id: u32,
+    pub result_current_id: u32,
+    pub color_factor_id: u32,
+    pub evaluation_factor_id: u32,
+    pub normalization_factor_id: u32,
+    pub representative_evaluation_factor_id: u32,
+    pub selector_domain_id: u32,
+}
+
+impl EagerPlanAttachmentRow {
+    pub const ENCODED_LEN: u32 = 28;
+}
+
+/// One current finalization and optional propagator application.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanFinalizationRow {
+    pub kernel_id: u32,
+    pub current_id: u32,
+    pub unpropagated_value_slot_id: u32,
+    pub propagated_value_slot_id: u32,
+    pub momentum_slot_id: u32,
+    pub unpropagated_selector_domain_id: u32,
+    pub propagated_selector_domain_id: u32,
+}
+
+impl EagerPlanFinalizationRow {
+    pub const ENCODED_LEN: u32 = 28;
+}
+
+/// One amplitude closure.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanClosureRow {
+    pub root_id: u32,
+    pub kernel_id: u32,
+    pub left_value_slot_id: u32,
+    pub right_value_slot_id: u32,
+    pub amplitude_index: u32,
+    pub coherent_group_id: u32,
+    pub coupling_slot_id: u32,
+    pub coupling_factor_id: u32,
+    pub output_factor_source: u8,
+    pub color_factor_id: u32,
+    pub normalization_factor_id: u32,
+    pub direct_coefficient_start: u64,
+    pub direct_coefficient_count: u64,
+    pub selector_domain_id: u32,
+}
+
+impl EagerPlanClosureRow {
+    pub const ENCODED_LEN: u32 = 64;
+}
+
+/// Exact coefficient for one direct closure component.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanDirectCoefficientRow {
+    pub contraction_ir_id: u32,
+    pub component_index: u32,
+    pub factor_id: u32,
+}
+
+/// One interned coherent-group selector domain.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanSelectorDomainRow {
+    pub member_start: u64,
+    pub member_count: u64,
+}
+
+impl EagerPlanSelectorDomainRow {
+    pub const ENCODED_LEN: u32 = 16;
+}
+
+/// Logical currents, kernel evaluations, and routes executed for one selector.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanActiveWorkCounts {
+    pub current_count: u64,
+    pub evaluation_count: u64,
+    pub attachment_count: u64,
+}
+
+/// Worst exact runtime work for each report selector axis.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanSelectorWorkSummary {
+    pub selected_flow_selector_count: u64,
+    pub selected_flow_worst: EagerPlanActiveWorkCounts,
+    pub all_flow_selector_count: u64,
+    pub all_flow_worst: EagerPlanActiveWorkCounts,
+    pub contracted: EagerPlanActiveWorkCounts,
+}
+
+/// Public helicity selector, including aliases and structural zeros.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanHelicitySelectorRow {
+    pub selector_id: u32,
+    pub values_sequence_id: u32,
+    pub representative_sequence_id: u32,
+    pub coefficient_factor_id: u32,
+    pub computed: u8,
+    pub structural_zero: u8,
+}
+
+/// Public color selector and representative alias.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanColorSelectorRow {
+    pub selector_id: u32,
+    pub word_sequence_id: u32,
+    pub representative_word_sequence_id: u32,
+    pub coefficient_factor_id: u32,
+    pub computed: u8,
+}
+
+/// One coherent reduction group and its flat entry ranges.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanReductionGroupRow {
+    pub coherent_group_id: u32,
+    pub amplitude_entry_start: u64,
+    pub amplitude_entry_count: u64,
+    pub selector_entry_start: u64,
+    pub selector_entry_count: u64,
+    pub helicity_weight_factor_id: u32,
+    pub all_sector_weight_factor_id: u32,
+}
+
+impl EagerPlanReductionGroupRow {
+    pub const ENCODED_LEN: u32 = 48;
+}
+
+/// Tagged fixed-width reduction entry kind.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum EagerPlanReductionEntryKind {
+    AmplitudeMember = 1,
+    SelectorMember = 2,
+    ColorContraction = 3,
+}
+
+/// Tagged fixed-width reduction entry.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanReductionEntryRow {
+    pub kind: EagerPlanReductionEntryKind,
+    pub owner_id: u32,
+    pub left_id: u32,
+    pub right_id: u32,
+    pub factor_id: u32,
+    pub auxiliary_factor_id: u32,
+}
+
+impl EagerPlanReductionEntryRow {
+    pub const ENCODED_LEN: u32 = 24;
+}
+
+/// Exact-factor catalog row with bit-exact binary64 fallback.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanExactFactorRow {
+    pub factor_id: u32,
+    pub real_bits: u64,
+    pub imaginary_bits: u64,
+    pub canonical_string_id: u32,
+    pub exact_source: u8,
+    pub exact_ir_id: u32,
+    pub source_ir_id: u32,
+}
+
+/// Canonical range into a flat fixed-width catalog.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanCatalogRangeRow {
+    pub start: u64,
+    pub count: u64,
+}
+
+impl EagerPlanCatalogRangeRow {
+    pub const ENCODED_LEN: u32 = 16;
+}
+
+impl EagerPlanExactFactorRow {
+    pub const ENCODED_LEN: u32 = 40;
+}
+
+/// A section shape ready to be wrapped by the common eager section header.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerPlanSectionShape {
+    pub kind: EagerSectionKind,
+    pub record_size: u32,
+    pub record_count: u64,
+}
+
+impl EagerPlanSectionShape {
+    pub fn header(self) -> RusticolResult<EagerSectionHeader> {
+        EagerSectionHeader::new(self.kind, self.record_size, self.record_count)
+    }
+}
+
+/// Flat, deterministic plan-v3 representation.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EagerPlanV3 {
+    process_key: String,
+    model_name: String,
+    string_catalog: Vec<Box<str>>,
+    canonical_ir_catalog: Vec<Box<str>>,
+    semantic_limitations: Vec<Box<str>>,
+    retained_tables: Vec<EagerOwnedRetainedTable>,
+    currents: Vec<EagerPlanCurrentRow>,
+    values: Vec<EagerPlanValueRow>,
+    momenta: Vec<EagerPlanMomentumRow>,
+    sources: Vec<EagerPlanSourceFillRow>,
+    parameters: Vec<EagerPlanParameterRow>,
+    stages: Vec<EagerPlanStageRow>,
+    couplings: Vec<EagerPlanCouplingRow>,
+    invocations: Vec<EagerPlanInvocationRow>,
+    attachments: Vec<EagerPlanAttachmentRow>,
+    finalizations: Vec<EagerPlanFinalizationRow>,
+    closures: Vec<EagerPlanClosureRow>,
+    direct_coefficients: Vec<EagerPlanDirectCoefficientRow>,
+    selector_domains: Vec<EagerPlanSelectorDomainRow>,
+    selector_memberships: Vec<u32>,
+    helicity_selectors: Vec<EagerPlanHelicitySelectorRow>,
+    color_selectors: Vec<EagerPlanColorSelectorRow>,
+    reduction_groups: Vec<EagerPlanReductionGroupRow>,
+    reduction_entries: Vec<EagerPlanReductionEntryRow>,
+    exact_factors: Vec<EagerPlanExactFactorRow>,
+    bitset_ranges: Vec<EagerPlanCatalogRangeRow>,
+    bitset_populations: Vec<u64>,
+    bitset_words: Vec<u64>,
+    u32_sequence_ranges: Vec<EagerPlanCatalogRangeRow>,
+    u32_sequence_values: Vec<u32>,
+    i32_sequence_ranges: Vec<EagerPlanCatalogRangeRow>,
+    i32_sequence_values: Vec<i32>,
+    color_contraction_entry_start: u64,
+    color_contraction_entry_count: u64,
+    current_component_count: u64,
+    value_component_count: u64,
+    momentum_component_count: u64,
+}
+
+macro_rules! plan_slice_getter {
+    ($name:ident, $field:ident, $row:ty) => {
+        pub fn $name(&self) -> &[$row] {
+            &self.$field
+        }
+    };
+}
+
+fn selector_domain_active(
+    plan: &EagerPlanV3,
+    domain_id: u32,
+    active_groups: &BTreeSet<u32>,
+) -> RusticolResult<bool> {
+    if domain_id == MISSING_U32 {
+        return Ok(true);
+    }
+    let domain = plan
+        .selector_domains
+        .get(domain_id as usize)
+        .ok_or_else(|| invalid("eager selector-work census references an unknown domain"))?;
+    let members = checked_usize_range(
+        domain.member_start,
+        domain.member_count,
+        plan.selector_memberships.len(),
+        "selector-work domain memberships",
+    )?;
+    Ok(plan.selector_memberships[members]
+        .iter()
+        .any(|member| active_groups.contains(member)))
+}
+
+fn active_selector_work(
+    plan: &EagerPlanV3,
+    active_groups: &BTreeSet<u32>,
+) -> RusticolResult<EagerPlanActiveWorkCounts> {
+    let mut currents = plan
+        .sources
+        .iter()
+        .map(|source| source.current_id)
+        .collect::<BTreeSet<_>>();
+    let mut evaluations = 0_u64;
+    let mut attachments_count = 0_u64;
+    for invocation in &plan.invocations {
+        if !selector_domain_active(plan, invocation.selector_domain_id, active_groups)? {
+            continue;
+        }
+        let attachments = checked_usize_range(
+            invocation.attachment_start,
+            invocation.attachment_count,
+            plan.attachments.len(),
+            "selector-work invocation attachments",
+        )?;
+        let mut invocation_active = false;
+        for attachment in &plan.attachments[attachments] {
+            if !selector_domain_active(plan, attachment.selector_domain_id, active_groups)? {
+                continue;
+            }
+            invocation_active = true;
+            currents.insert(attachment.result_current_id);
+            attachments_count = attachments_count
+                .checked_add(1)
+                .ok_or_else(|| invalid("selector-work attachment count exceeds u64"))?;
+        }
+        if invocation_active {
+            evaluations = evaluations
+                .checked_add(1)
+                .ok_or_else(|| invalid("selector-work evaluation count exceeds u64"))?;
+        }
+    }
+    Ok(EagerPlanActiveWorkCounts {
+        current_count: usize_u64(currents.len(), "selector-work current count")?,
+        evaluation_count: evaluations,
+        attachment_count: attachments_count,
+    })
+}
+
+fn worst_selector_work<'a>(
+    plan: &EagerPlanV3,
+    selectors: impl Iterator<Item = &'a BTreeSet<u32>>,
+    context: &str,
+) -> RusticolResult<EagerPlanActiveWorkCounts> {
+    let mut worst = None::<EagerPlanActiveWorkCounts>;
+    for groups in selectors {
+        let counts = active_selector_work(plan, groups)?;
+        worst = Some(match worst {
+            None => counts,
+            Some(previous) => EagerPlanActiveWorkCounts {
+                current_count: previous.current_count.max(counts.current_count),
+                evaluation_count: previous.evaluation_count.max(counts.evaluation_count),
+                attachment_count: previous.attachment_count.max(counts.attachment_count),
+            },
+        });
+    }
+    worst.ok_or_else(|| invalid(format!("eager selector-work census has no {context}")))
+}
+
+impl EagerPlanV3 {
+    pub fn abi(&self) -> &'static str {
+        EAGER_PLAN_ABI
+    }
+
+    pub fn process_key(&self) -> &str {
+        &self.process_key
+    }
+
+    pub fn model_name(&self) -> &str {
+        &self.model_name
+    }
+
+    pub fn string_catalog(&self) -> &[Box<str>] {
+        &self.string_catalog
+    }
+
+    pub fn canonical_ir_catalog(&self) -> &[Box<str>] {
+        &self.canonical_ir_catalog
+    }
+
+    pub fn semantic_limitations(&self) -> &[Box<str>] {
+        &self.semantic_limitations
+    }
+
+    pub fn retained_tables(&self) -> &[EagerOwnedRetainedTable] {
+        &self.retained_tables
+    }
+
+    plan_slice_getter!(currents, currents, EagerPlanCurrentRow);
+    plan_slice_getter!(values, values, EagerPlanValueRow);
+    plan_slice_getter!(momenta, momenta, EagerPlanMomentumRow);
+    plan_slice_getter!(sources, sources, EagerPlanSourceFillRow);
+    plan_slice_getter!(parameters, parameters, EagerPlanParameterRow);
+    plan_slice_getter!(stages, stages, EagerPlanStageRow);
+    plan_slice_getter!(couplings, couplings, EagerPlanCouplingRow);
+    plan_slice_getter!(invocations, invocations, EagerPlanInvocationRow);
+    plan_slice_getter!(attachments, attachments, EagerPlanAttachmentRow);
+    plan_slice_getter!(finalizations, finalizations, EagerPlanFinalizationRow);
+    plan_slice_getter!(closures, closures, EagerPlanClosureRow);
+    plan_slice_getter!(
+        direct_coefficients,
+        direct_coefficients,
+        EagerPlanDirectCoefficientRow
+    );
+    plan_slice_getter!(
+        selector_domains,
+        selector_domains,
+        EagerPlanSelectorDomainRow
+    );
+    plan_slice_getter!(
+        helicity_selectors,
+        helicity_selectors,
+        EagerPlanHelicitySelectorRow
+    );
+    plan_slice_getter!(color_selectors, color_selectors, EagerPlanColorSelectorRow);
+    plan_slice_getter!(
+        reduction_groups,
+        reduction_groups,
+        EagerPlanReductionGroupRow
+    );
+    plan_slice_getter!(
+        reduction_entries,
+        reduction_entries,
+        EagerPlanReductionEntryRow
+    );
+    plan_slice_getter!(exact_factors, exact_factors, EagerPlanExactFactorRow);
+
+    pub fn selector_memberships(&self) -> &[u32] {
+        &self.selector_memberships
+    }
+
+    /// Count the exact rows admitted by the same selector domains as runtime.
+    pub fn selector_work_summary(&self) -> RusticolResult<EagerPlanSelectorWorkSummary> {
+        let mut groups_by_helicity = BTreeMap::<u32, BTreeSet<u32>>::new();
+        let mut groups_by_color = BTreeMap::<u32, BTreeSet<u32>>::new();
+        for entry in &self.reduction_entries {
+            if entry.kind != EagerPlanReductionEntryKind::SelectorMember {
+                continue;
+            }
+            groups_by_helicity
+                .entry(entry.left_id)
+                .or_default()
+                .insert(entry.owner_id);
+            groups_by_color
+                .entry(entry.right_id)
+                .or_default()
+                .insert(entry.owner_id);
+        }
+        if groups_by_helicity.is_empty() || groups_by_color.is_empty() {
+            return Err(invalid(
+                "eager selector-work census has no physical selector memberships",
+            ));
+        }
+        let selected_flow_worst =
+            worst_selector_work(self, groups_by_color.values(), "color selector")?;
+        let all_flow_worst =
+            worst_selector_work(self, groups_by_helicity.values(), "helicity selector")?;
+        Ok(EagerPlanSelectorWorkSummary {
+            selected_flow_selector_count: usize_u64(
+                groups_by_color.len(),
+                "selected-flow selector count",
+            )?,
+            selected_flow_worst,
+            all_flow_selector_count: usize_u64(
+                groups_by_helicity.len(),
+                "all-flow selector count",
+            )?,
+            all_flow_worst,
+            contracted: EagerPlanActiveWorkCounts {
+                current_count: usize_u64(self.currents.len(), "contracted current count")?,
+                evaluation_count: usize_u64(self.invocations.len(), "contracted evaluation count")?,
+                attachment_count: usize_u64(self.attachments.len(), "contracted attachment count")?,
+            },
+        })
+    }
+
+    pub fn bitset_ranges(&self) -> &[EagerPlanCatalogRangeRow] {
+        &self.bitset_ranges
+    }
+
+    pub fn bitset_populations(&self) -> &[u64] {
+        &self.bitset_populations
+    }
+
+    pub fn bitset_words(&self) -> &[u64] {
+        &self.bitset_words
+    }
+
+    pub fn u32_sequence_ranges(&self) -> &[EagerPlanCatalogRangeRow] {
+        &self.u32_sequence_ranges
+    }
+
+    pub fn u32_sequence_values(&self) -> &[u32] {
+        &self.u32_sequence_values
+    }
+
+    pub fn i32_sequence_ranges(&self) -> &[EagerPlanCatalogRangeRow] {
+        &self.i32_sequence_ranges
+    }
+
+    pub fn i32_sequence_values(&self) -> &[i32] {
+        &self.i32_sequence_values
+    }
+
+    pub fn current_component_count(&self) -> u64 {
+        self.current_component_count
+    }
+
+    pub fn value_component_count(&self) -> u64 {
+        self.value_component_count
+    }
+
+    pub fn momentum_component_count(&self) -> u64 {
+        self.momentum_component_count
+    }
+
+    pub fn color_contraction_entry_range(&self) -> (u64, u64) {
+        (
+            self.color_contraction_entry_start,
+            self.color_contraction_entry_count,
+        )
+    }
+
+    pub fn section_shapes(&self) -> RusticolResult<Vec<EagerPlanSectionShape>> {
+        let mut shapes = reserved(17, "eager section shapes")?;
+        let mut add = |kind, record_size, count: usize| -> RusticolResult<()> {
+            shapes.push(EagerPlanSectionShape {
+                kind,
+                record_size,
+                record_count: usize_u64(count, "eager section record count")?,
+            });
+            Ok(())
+        };
+        add(EagerSectionKind::Metadata, 64, 1)?;
+        add(
+            EagerSectionKind::CurrentLayout,
+            EagerPlanCurrentRow::ENCODED_LEN,
+            self.currents.len(),
+        )?;
+        add(
+            EagerSectionKind::ValueLayout,
+            EagerPlanValueRow::ENCODED_LEN,
+            self.values.len(),
+        )?;
+        add(
+            EagerSectionKind::MomentumLayout,
+            EagerPlanMomentumRow::ENCODED_LEN,
+            self.momenta.len(),
+        )?;
+        add(
+            EagerSectionKind::SourceFill,
+            EagerPlanSourceFillRow::ENCODED_LEN,
+            self.sources.len(),
+        )?;
+        add(
+            EagerSectionKind::ParameterLayout,
+            EagerPlanParameterRow::ENCODED_LEN,
+            self.parameters.len(),
+        )?;
+        add(
+            EagerSectionKind::Stages,
+            EagerPlanStageRow::ENCODED_LEN,
+            self.stages.len(),
+        )?;
+        add(
+            EagerSectionKind::Couplings,
+            EagerPlanCouplingRow::ENCODED_LEN,
+            self.couplings.len(),
+        )?;
+        add(
+            EagerSectionKind::Invocations,
+            EagerPlanInvocationRow::ENCODED_LEN,
+            self.invocations.len(),
+        )?;
+        add(
+            EagerSectionKind::Attachments,
+            EagerPlanAttachmentRow::ENCODED_LEN,
+            self.attachments.len(),
+        )?;
+        add(
+            EagerSectionKind::Finalizations,
+            EagerPlanFinalizationRow::ENCODED_LEN,
+            self.finalizations.len(),
+        )?;
+        add(
+            EagerSectionKind::Closures,
+            EagerPlanClosureRow::ENCODED_LEN,
+            self.closures.len(),
+        )?;
+        add(
+            EagerSectionKind::SelectorDomains,
+            EagerPlanSelectorDomainRow::ENCODED_LEN,
+            self.selector_domains.len(),
+        )?;
+        add(
+            EagerSectionKind::SelectorMemberships,
+            4,
+            self.selector_memberships.len(),
+        )?;
+        add(
+            EagerSectionKind::ReductionGroups,
+            EagerPlanReductionGroupRow::ENCODED_LEN,
+            self.reduction_groups.len(),
+        )?;
+        add(
+            EagerSectionKind::ReductionEntries,
+            EagerPlanReductionEntryRow::ENCODED_LEN,
+            self.reduction_entries.len(),
+        )?;
+        add(
+            EagerSectionKind::ExactFactors,
+            EagerPlanExactFactorRow::ENCODED_LEN,
+            self.exact_factors.len(),
+        )?;
+        Ok(shapes)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct ValueSlots {
+    source: Option<u32>,
+    unpropagated: Option<u32>,
+    propagated: Option<u32>,
+    input: Option<u32>,
+}
+
+/// Deterministically lower one validated v1 input into a flat plan-v3.
+///
+/// The input is consumed so catalogs and retained column payloads move into the
+/// plan without a second allocation or copy.
+pub fn lower_eager_plan_v3(input: EagerLoweringInputV1) -> RusticolResult<EagerPlanV3> {
+    let (currents, current_component_count, momentum_by_bitset) = lower_currents(&input)?;
+    let (values, value_slots, value_component_count) = lower_values(&input)?;
+    let (momenta, momentum_component_count) = lower_momenta(&input)?;
+    let sources = lower_sources(&input, &value_slots)?;
+    let parameters = lower_parameters(&input)?;
+    let couplings = lower_couplings(&input)?;
+    let (stages, mut invocations, mut attachments, mut finalizations, producer_stage_by_current) =
+        lower_stages(&input, &value_slots, &momentum_by_bitset)?;
+    let (mut closures, direct_coefficients) = lower_closures(&input, &value_slots)?;
+    let (selector_domains, selector_memberships) = lower_selector_domains(
+        &stages,
+        &mut invocations,
+        &mut attachments,
+        &mut finalizations,
+        &mut closures,
+        values.len(),
+        input.currents.len(),
+    )?;
+    validate_stage_dependencies(&input, &producer_stage_by_current)?;
+    let helicity_selectors = lower_helicity_selectors(&input)?;
+    let color_selectors = lower_color_selectors(&input)?;
+    let (
+        reduction_groups,
+        reduction_entries,
+        color_contraction_entry_start,
+        color_contraction_entry_count,
+    ) = lower_reductions(&input)?;
+    let exact_factors = input
+        .exact_factors
+        .iter()
+        .enumerate()
+        .map(|(factor_id, factor)| {
+            Ok(EagerPlanExactFactorRow {
+                factor_id: usize_u32(factor_id, "exact factor ID")?,
+                real_bits: factor.real_bits,
+                imaginary_bits: factor.imaginary_bits,
+                canonical_string_id: factor.canonical_string_id,
+                exact_source: factor.exact_source,
+                exact_ir_id: factor.exact_ir_id,
+                source_ir_id: factor.source_ir_id,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let bitset_ranges = input
+        .bitset_ranges
+        .iter()
+        .map(|row| EagerPlanCatalogRangeRow {
+            start: row.range.start,
+            count: row.range.count,
+        })
+        .collect();
+    let bitset_populations = input
+        .bitset_ranges
+        .iter()
+        .map(|row| row.bit_count)
+        .collect();
+    let u32_sequence_ranges = input
+        .u32_sequence_ranges
+        .iter()
+        .map(|row| EagerPlanCatalogRangeRow {
+            start: row.start,
+            count: row.count,
+        })
+        .collect();
+    let i32_sequence_ranges = input
+        .i32_sequence_ranges
+        .iter()
+        .map(|row| EagerPlanCatalogRangeRow {
+            start: row.start,
+            count: row.count,
+        })
+        .collect();
+
+    Ok(EagerPlanV3 {
+        process_key: input.process_key,
+        model_name: input.model_name,
+        string_catalog: input.string_catalog,
+        canonical_ir_catalog: input.canonical_ir_catalog,
+        semantic_limitations: input.semantic_limitations,
+        retained_tables: input.retained_tables,
+        currents,
+        values,
+        momenta,
+        sources,
+        parameters,
+        stages,
+        couplings,
+        invocations,
+        attachments,
+        finalizations,
+        closures,
+        direct_coefficients,
+        selector_domains,
+        selector_memberships,
+        helicity_selectors,
+        color_selectors,
+        reduction_groups,
+        reduction_entries,
+        exact_factors,
+        bitset_ranges,
+        bitset_populations,
+        bitset_words: input.bitset_words,
+        u32_sequence_ranges,
+        u32_sequence_values: input.u32_sequence_values,
+        i32_sequence_ranges,
+        i32_sequence_values: input.i32_sequence_values,
+        color_contraction_entry_start,
+        color_contraction_entry_count,
+        current_component_count,
+        value_component_count,
+        momentum_component_count,
+    })
+}
+
+fn lower_currents(
+    input: &EagerLoweringInputV1,
+) -> RusticolResult<(Vec<EagerPlanCurrentRow>, u64, Vec<u32>)> {
+    let mut momentum_by_bitset = vec![MISSING_U32; input.bitset_ranges.len()];
+    for (slot_id, bitset_id) in &input.momentum_masks {
+        momentum_by_bitset[*bitset_id as usize] = *slot_id;
+    }
+    let mut rows = reserved(input.currents.len(), "current layout")?;
+    let mut component_start = 0_u64;
+    for current in &input.currents {
+        rows.push(EagerPlanCurrentRow {
+            current_id: current.id,
+            component_start,
+            component_count: current.dimension,
+            momentum_slot_id: momentum_by_bitset[current.momentum_mask_bitset_id as usize],
+            flags: if current.is_source {
+                CURRENT_FLAG_SOURCE
+            } else {
+                0
+            },
+        });
+        component_start = component_start
+            .checked_add(u64::from(current.dimension))
+            .ok_or_else(|| invalid("current component layout exceeds u64"))?;
+    }
+    Ok((rows, component_start, momentum_by_bitset))
+}
+
+fn lower_values(
+    input: &EagerLoweringInputV1,
+) -> RusticolResult<(Vec<EagerPlanValueRow>, Vec<ValueSlots>, u64)> {
+    let mut used_as_input = vec![false; input.currents.len()];
+    let mut used_as_root = vec![false; input.currents.len()];
+    for interaction in &input.interactions {
+        used_as_input[interaction.left_current_id as usize] = true;
+        used_as_input[interaction.right_current_id as usize] = true;
+    }
+    for root in &input.roots {
+        used_as_root[root.left_current_id as usize] = true;
+        used_as_root[root.right_current_id as usize] = true;
+    }
+
+    let capacity = input
+        .currents
+        .len()
+        .checked_mul(2)
+        .ok_or_else(|| invalid("value slot capacity exceeds usize"))?;
+    let mut rows = reserved(capacity, "value layout")?;
+    let mut slots = vec![ValueSlots::default(); input.currents.len()];
+    let mut component_start = 0_u64;
+    for current in &input.currents {
+        let current_index = current.id as usize;
+        if current.is_source {
+            let slot = push_value_row(
+                &mut rows,
+                current.id,
+                current.dimension,
+                EagerValueSlotKind::Source,
+                &mut component_start,
+            )?;
+            slots[current_index].source = Some(slot);
+            if used_as_input[current_index] {
+                slots[current_index].input = Some(slot);
+            }
+            continue;
+        }
+        let needs_propagated =
+            used_as_input[current_index] && current.propagator_kernel_id != MISSING_U32;
+        let needs_unpropagated = used_as_root[current_index] || !needs_propagated;
+        if needs_unpropagated {
+            slots[current_index].unpropagated = Some(push_value_row(
+                &mut rows,
+                current.id,
+                current.dimension,
+                EagerValueSlotKind::Unpropagated,
+                &mut component_start,
+            )?);
+        }
+        if needs_propagated {
+            slots[current_index].propagated = Some(push_value_row(
+                &mut rows,
+                current.id,
+                current.dimension,
+                EagerValueSlotKind::Propagated,
+                &mut component_start,
+            )?);
+        }
+        if used_as_input[current_index] {
+            slots[current_index].input = if needs_propagated {
+                slots[current_index].propagated
+            } else {
+                slots[current_index].unpropagated
+            };
+        }
+    }
+    Ok((rows, slots, component_start))
+}
+
+fn push_value_row(
+    rows: &mut Vec<EagerPlanValueRow>,
+    current_id: u32,
+    component_count: u32,
+    kind: EagerValueSlotKind,
+    component_start: &mut u64,
+) -> RusticolResult<u32> {
+    let value_slot_id = usize_u32(rows.len(), "value slot ID")?;
+    rows.push(EagerPlanValueRow {
+        value_slot_id,
+        current_id,
+        component_start: *component_start,
+        component_count,
+        kind,
+    });
+    *component_start = component_start
+        .checked_add(u64::from(component_count))
+        .ok_or_else(|| invalid("value component layout exceeds u64"))?;
+    Ok(value_slot_id)
+}
+
+fn lower_momenta(input: &EagerLoweringInputV1) -> RusticolResult<(Vec<EagerPlanMomentumRow>, u64)> {
+    let mut rows = reserved(input.momentum_masks.len(), "momentum layout")?;
+    let mut component_start = 0_u64;
+    for (slot_id, bitset_id) in &input.momentum_masks {
+        rows.push(EagerPlanMomentumRow {
+            momentum_slot_id: *slot_id,
+            bitset_id: *bitset_id,
+            component_start,
+            component_count: 4,
+        });
+        component_start = component_start
+            .checked_add(4)
+            .ok_or_else(|| invalid("momentum component layout exceeds u64"))?;
+    }
+    Ok((rows, component_start))
+}
+
+fn lower_sources(
+    input: &EagerLoweringInputV1,
+    value_slots: &[ValueSlots],
+) -> RusticolResult<Vec<EagerPlanSourceFillRow>> {
+    let mut rows = reserved(input.sources.len(), "source fill")?;
+    for source in &input.sources {
+        let value_slot_id = value_slots[source.current_id as usize]
+            .source
+            .ok_or_else(|| {
+                invalid(format!(
+                    "source {} has no source value slot",
+                    source.source_id
+                ))
+            })?;
+        rows.push(EagerPlanSourceFillRow {
+            source_id: source.source_id,
+            current_id: source.current_id,
+            value_slot_id,
+            external_label: source.external_label,
+            input_momentum_slot: source.input_momentum_slot,
+            source_ir_id: source.source_ir_id,
+            crossing_ir_id: source.crossing_ir_id,
+            crossing_factor_id: source.crossing_factor_id,
+            declared_state_index: source.declared_state_index,
+        });
+    }
+    Ok(rows)
+}
+
+fn lower_parameters(input: &EagerLoweringInputV1) -> RusticolResult<Vec<EagerPlanParameterRow>> {
+    let mut rows = reserved(input.model_parameters.len(), "parameter layout")?;
+    for (parameter_id, parameter) in input.model_parameters.iter().enumerate() {
+        rows.push(EagerPlanParameterRow {
+            parameter_id: usize_u32(parameter_id, "parameter ID")?,
+            name_string_id: parameter.name_string_id,
+            kind_string_id: parameter.kind_string_id,
+            default_factor_id: parameter.default_factor_id,
+            runtime_name_string_id: parameter.runtime_name_string_id,
+            complex_component: parameter.complex_component,
+            flags: u32::from(parameter.derived),
+        });
+    }
+    Ok(rows)
+}
+
+fn lower_couplings(input: &EagerLoweringInputV1) -> RusticolResult<Vec<EagerPlanCouplingRow>> {
+    let mut rows = reserved(input.couplings.len(), "coupling layout")?;
+    for (coupling_id, coupling) in input.couplings.iter().enumerate() {
+        let names = input.u32_sequence(coupling.parameter_name_ids_sequence_id)?;
+        let mut real = MISSING_U32;
+        let mut imaginary = MISSING_U32;
+        let first = names.first().copied().filter(|id| *id != MISSING_U32);
+        if let Some(logical_name) = first {
+            let logical: Vec<_> = input
+                .model_parameters
+                .iter()
+                .enumerate()
+                .filter(|(_, parameter)| parameter.runtime_name_string_id == logical_name)
+                .collect();
+            if !logical.is_empty() {
+                for (parameter_id, parameter) in logical {
+                    let parameter_id = usize_u32(parameter_id, "coupling parameter ID")?;
+                    match parameter.complex_component {
+                        0 if real == MISSING_U32 => real = parameter_id,
+                        1 if imaginary == MISSING_U32 => imaginary = parameter_id,
+                        _ => {
+                            return Err(invalid(format!(
+                                "coupling {coupling_id} has ambiguous logical parameter components"
+                            )));
+                        }
+                    }
+                }
+                if real == MISSING_U32 || imaginary == MISSING_U32 {
+                    return Err(invalid(format!(
+                        "coupling {coupling_id} logical parameter lacks real/imaginary slots"
+                    )));
+                }
+            }
+        }
+        if real == MISSING_U32 && imaginary == MISSING_U32 {
+            for (component, name) in names.iter().copied().enumerate() {
+                if name == MISSING_U32 {
+                    continue;
+                }
+                let matches = input
+                    .model_parameters
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, parameter)| parameter.name_string_id == name)
+                    .map(|(id, _)| id)
+                    .collect::<Vec<_>>();
+                if matches.len() != 1 {
+                    return Err(invalid(format!(
+                        "coupling {coupling_id} parameter name {name} is not unique"
+                    )));
+                }
+                let parameter_id = usize_u32(matches[0], "coupling parameter ID")?;
+                if component == 0 {
+                    real = parameter_id;
+                } else {
+                    imaginary = parameter_id;
+                }
+            }
+        }
+        rows.push(EagerPlanCouplingRow {
+            coupling_id: usize_u32(coupling_id, "coupling ID")?,
+            real_parameter_id: real,
+            imaginary_parameter_id: imaginary,
+            constant_factor_id: coupling.constant_factor_id,
+        });
+    }
+    Ok(rows)
+}
+
+type LoweredStages = (
+    Vec<EagerPlanStageRow>,
+    Vec<EagerPlanInvocationRow>,
+    Vec<EagerPlanAttachmentRow>,
+    Vec<EagerPlanFinalizationRow>,
+    Vec<u32>,
+);
+
+fn lower_stages(
+    input: &EagerLoweringInputV1,
+    value_slots: &[ValueSlots],
+    momentum_by_bitset: &[u32],
+) -> RusticolResult<LoweredStages> {
+    let stage_sizes = input
+        .interactions
+        .iter()
+        .map(|row| row.stage_subset_size)
+        .collect::<BTreeSet<_>>()
+        .into_iter()
+        .collect::<Vec<_>>();
+    let mut stage_position_by_size = BTreeMap::new();
+    for (position, subset_size) in stage_sizes.iter().copied().enumerate() {
+        stage_position_by_size.insert(subset_size, position);
+    }
+    let mut groups_by_stage = vec![Vec::new(); stage_sizes.len()];
+    for (group_id, group) in input.interaction_groups.iter().enumerate() {
+        let representative = &input.interactions[group.representative_interaction_id as usize];
+        let position = stage_position_by_size[&representative.stage_subset_size];
+        groups_by_stage[position].push(group_id);
+    }
+    let mut outputs_by_stage = vec![BTreeSet::new(); stage_sizes.len()];
+    let mut producer_stage_by_current = vec![MISSING_U32; input.currents.len()];
+    for interaction in &input.interactions {
+        let position = stage_position_by_size[&interaction.stage_subset_size];
+        outputs_by_stage[position].insert(interaction.result_current_id);
+        producer_stage_by_current[interaction.result_current_id as usize] =
+            usize_u32(position, "producer stage")?;
+    }
+
+    let mut stages = reserved(stage_sizes.len(), "stages")?;
+    let mut invocations = reserved(input.interaction_groups.len(), "invocations")?;
+    let mut attachments = reserved(input.interactions.len(), "attachments")?;
+    let finalization_capacity = outputs_by_stage.iter().map(BTreeSet::len).sum();
+    let mut finalizations = reserved(finalization_capacity, "finalizations")?;
+    for (stage_position, subset_size) in stage_sizes.iter().copied().enumerate() {
+        let invocation_start = usize_u64(invocations.len(), "invocation start")?;
+        let attachment_start = usize_u64(attachments.len(), "attachment start")?;
+        for group_id in &groups_by_stage[stage_position] {
+            let group = input.interaction_groups[*group_id];
+            let representative = input.interactions[group.representative_interaction_id as usize];
+            if factor_is_complex_zero(
+                &input.exact_factors[representative.evaluation_factor_id as usize],
+            ) {
+                continue;
+            }
+            let members = range_slice(
+                &input.interaction_group_members,
+                group.members,
+                "interaction group members",
+            )?;
+            let ordered_currents = match representative.canonical_input_order {
+                [0, 1] => [
+                    representative.left_current_id,
+                    representative.right_current_id,
+                ],
+                [1, 0] => [
+                    representative.right_current_id,
+                    representative.left_current_id,
+                ],
+                _ => unreachable!("validated canonical input order"),
+            };
+            let invocation_attachment_start_index = attachments.len();
+            let invocation_attachment_start = usize_u64(
+                invocation_attachment_start_index,
+                "invocation attachment start",
+            )?;
+            for member_id in members {
+                let member = input.interactions[*member_id as usize];
+                if factor_is_complex_zero(
+                    &input.exact_factors[member.evaluation_factor_id as usize],
+                ) {
+                    continue;
+                }
+                attachments.push(EagerPlanAttachmentRow {
+                    interaction_id: member.id,
+                    result_current_id: member.result_current_id,
+                    color_factor_id: member.color_factor_id,
+                    evaluation_factor_id: member.evaluation_factor_id,
+                    normalization_factor_id: representative.kernel_normalization_factor_id,
+                    representative_evaluation_factor_id: representative.evaluation_factor_id,
+                    selector_domain_id: MISSING_U32,
+                });
+            }
+            let invocation_attachment_count = usize_u64(
+                attachments.len() - invocation_attachment_start_index,
+                "invocation attachment count",
+            )?;
+            invocations.push(EagerPlanInvocationRow {
+                evaluation_group_id: *group_id as u32,
+                kernel_id: representative.kernel_id,
+                left_value_slot_id: value_slots[ordered_currents[0] as usize]
+                    .input
+                    .ok_or_else(|| invalid("invocation left current has no input value slot"))?,
+                right_value_slot_id: value_slots[ordered_currents[1] as usize]
+                    .input
+                    .ok_or_else(|| invalid("invocation right current has no input value slot"))?,
+                left_momentum_slot_id: momentum_by_bitset
+                    [input.currents[ordered_currents[0] as usize].momentum_mask_bitset_id as usize],
+                right_momentum_slot_id: momentum_by_bitset
+                    [input.currents[ordered_currents[1] as usize].momentum_mask_bitset_id as usize],
+                coupling_slot_id: representative.coupling_id,
+                output_factor_source: representative.output_factor_source,
+                attachment_start: invocation_attachment_start,
+                attachment_count: invocation_attachment_count,
+                selector_domain_id: MISSING_U32,
+            });
+        }
+        let finalization_start = usize_u64(finalizations.len(), "finalization start")?;
+        for current_id in &outputs_by_stage[stage_position] {
+            let current = input.currents[*current_id as usize];
+            let slots = value_slots[*current_id as usize];
+            if slots.unpropagated.is_none() && slots.propagated.is_none() {
+                return Err(invalid(format!(
+                    "stage output current {current_id} has no output value slot"
+                )));
+            }
+            if slots.propagated.is_some() && current.propagator_kernel_id == MISSING_U32 {
+                return Err(invalid(format!(
+                    "propagated current {current_id} has no prepared propagator kernel"
+                )));
+            }
+            finalizations.push(EagerPlanFinalizationRow {
+                kernel_id: if slots.propagated.is_some() {
+                    current.propagator_kernel_id
+                } else {
+                    MISSING_U32
+                },
+                current_id: *current_id,
+                unpropagated_value_slot_id: slots.unpropagated.unwrap_or(MISSING_U32),
+                propagated_value_slot_id: slots.propagated.unwrap_or(MISSING_U32),
+                momentum_slot_id: momentum_by_bitset[current.momentum_mask_bitset_id as usize],
+                unpropagated_selector_domain_id: MISSING_U32,
+                propagated_selector_domain_id: MISSING_U32,
+            });
+        }
+        stages.push(EagerPlanStageRow {
+            stage_index: usize_u32(stage_position + 1, "stage index")?,
+            subset_size,
+            invocation_start,
+            invocation_count: usize_u64(invocations.len(), "invocation stop")?
+                .checked_sub(invocation_start)
+                .ok_or_else(|| invalid("invocation range underflow"))?,
+            attachment_start,
+            attachment_count: usize_u64(attachments.len(), "attachment stop")?
+                .checked_sub(attachment_start)
+                .ok_or_else(|| invalid("attachment range underflow"))?,
+            finalization_start,
+            finalization_count: usize_u64(finalizations.len(), "finalization stop")?
+                .checked_sub(finalization_start)
+                .ok_or_else(|| invalid("finalization range underflow"))?,
+        });
+    }
+    Ok((
+        stages,
+        invocations,
+        attachments,
+        finalizations,
+        producer_stage_by_current,
+    ))
+}
+
+fn lower_closures(
+    input: &EagerLoweringInputV1,
+    value_slots: &[ValueSlots],
+) -> RusticolResult<(Vec<EagerPlanClosureRow>, Vec<EagerPlanDirectCoefficientRow>)> {
+    let mut coefficient_ranges = BTreeMap::<u32, InputRange>::new();
+    let mut coefficients = reserved(
+        input.contraction_coefficients.len(),
+        "direct closure coefficients",
+    )?;
+    let mut cursor = 0;
+    while cursor < input.contraction_coefficients.len() {
+        let ir_id = input.contraction_coefficients[cursor].contraction_ir_id;
+        let start = coefficients.len();
+        while cursor < input.contraction_coefficients.len()
+            && input.contraction_coefficients[cursor].contraction_ir_id == ir_id
+        {
+            let row = input.contraction_coefficients[cursor];
+            coefficients.push(EagerPlanDirectCoefficientRow {
+                contraction_ir_id: row.contraction_ir_id,
+                component_index: row.component_index,
+                factor_id: row.factor_id,
+            });
+            cursor += 1;
+        }
+        coefficient_ranges.insert(
+            ir_id,
+            InputRange {
+                start: usize_u64(start, "direct coefficient start")?,
+                count: usize_u64(coefficients.len() - start, "direct coefficient count")?,
+            },
+        );
+    }
+    let mut closures = reserved(input.roots.len(), "closures")?;
+    for root in &input.roots {
+        let unordered = [root.left_current_id, root.right_current_id];
+        let ordered = [
+            unordered[root.canonical_input_order[0] as usize],
+            unordered[root.canonical_input_order[1] as usize],
+        ];
+        let value_slot = |current_id: u32| -> RusticolResult<u32> {
+            let current = input.currents[current_id as usize];
+            let slots = value_slots[current_id as usize];
+            if current.is_source {
+                slots.source
+            } else {
+                slots.unpropagated
+            }
+            .ok_or_else(|| {
+                invalid(format!(
+                    "root current {current_id} has no amplitude value slot"
+                ))
+            })
+        };
+        let direct_range = if root.kernel_id == MISSING_U32 {
+            coefficient_ranges
+                .get(&root.contraction_ir_id)
+                .copied()
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "direct root {} has no contraction coefficients",
+                        root.id
+                    ))
+                })?
+        } else {
+            InputRange { start: 0, count: 0 }
+        };
+        closures.push(EagerPlanClosureRow {
+            root_id: root.id,
+            kernel_id: root.kernel_id,
+            left_value_slot_id: value_slot(ordered[0])?,
+            right_value_slot_id: value_slot(ordered[1])?,
+            amplitude_index: root.id,
+            coherent_group_id: root.coherent_group_id,
+            coupling_slot_id: root.coupling_id,
+            coupling_factor_id: root.coupling_factor_id,
+            output_factor_source: root.output_factor_source,
+            color_factor_id: root.color_factor_id,
+            normalization_factor_id: root.kernel_normalization_factor_id,
+            direct_coefficient_start: direct_range.start,
+            direct_coefficient_count: direct_range.count,
+            selector_domain_id: MISSING_U32,
+        });
+    }
+    Ok((closures, coefficients))
+}
+
+#[derive(Default)]
+struct DomainInterner {
+    by_members: BTreeMap<Vec<u32>, u32>,
+    members: Vec<Vec<u32>>,
+}
+
+impl DomainInterner {
+    fn intern(&mut self, members: &[u32]) -> RusticolResult<u32> {
+        if let Some(existing) = self.by_members.get(members) {
+            return Ok(*existing);
+        }
+        let id = usize_present_u32(self.members.len(), "selector domain ID")?;
+        let owned = copy_slice(members, "selector domain members")?;
+        self.by_members.insert(owned.clone(), id);
+        self.members.push(owned);
+        Ok(id)
+    }
+}
+
+fn lower_selector_domains(
+    stages: &[EagerPlanStageRow],
+    invocations: &mut [EagerPlanInvocationRow],
+    attachments: &mut [EagerPlanAttachmentRow],
+    finalizations: &mut [EagerPlanFinalizationRow],
+    closures: &mut [EagerPlanClosureRow],
+    value_count: usize,
+    current_count: usize,
+) -> RusticolResult<(Vec<EagerPlanSelectorDomainRow>, Vec<u32>)> {
+    let mut interner = DomainInterner::default();
+    let empty_domain = interner.intern(&[])?;
+    let mut value_domains = vec![Vec::<u32>::new(); value_count];
+    for closure in closures.iter_mut() {
+        let members = [closure.coherent_group_id];
+        closure.selector_domain_id = interner.intern(&members)?;
+        union_sorted_into(
+            &mut value_domains[closure.left_value_slot_id as usize],
+            &members,
+        )?;
+        union_sorted_into(
+            &mut value_domains[closure.right_value_slot_id as usize],
+            &members,
+        )?;
+    }
+
+    let mut current_domains = vec![Vec::<u32>::new(); current_count];
+    for stage in stages.iter().rev() {
+        let finalization_range = checked_usize_range(
+            stage.finalization_start,
+            stage.finalization_count,
+            finalizations.len(),
+            "stage finalizations",
+        )?;
+        for finalization in &mut finalizations[finalization_range.clone()] {
+            let unpropagated = if finalization.unpropagated_value_slot_id == MISSING_U32 {
+                Vec::new()
+            } else {
+                value_domains[finalization.unpropagated_value_slot_id as usize].clone()
+            };
+            let propagated = if finalization.propagated_value_slot_id == MISSING_U32 {
+                Vec::new()
+            } else {
+                value_domains[finalization.propagated_value_slot_id as usize].clone()
+            };
+            finalization.unpropagated_selector_domain_id = interner.intern(&unpropagated)?;
+            finalization.propagated_selector_domain_id = interner.intern(&propagated)?;
+            let mut current = unpropagated;
+            union_sorted_into(&mut current, &propagated)?;
+            current_domains[finalization.current_id as usize] = current;
+            if finalization.unpropagated_value_slot_id != MISSING_U32 {
+                value_domains[finalization.unpropagated_value_slot_id as usize].clear();
+            }
+            if finalization.propagated_value_slot_id != MISSING_U32 {
+                value_domains[finalization.propagated_value_slot_id as usize].clear();
+            }
+        }
+
+        let attachment_range = checked_usize_range(
+            stage.attachment_start,
+            stage.attachment_count,
+            attachments.len(),
+            "stage attachments",
+        )?;
+        for attachment in &mut attachments[attachment_range] {
+            attachment.selector_domain_id =
+                interner.intern(&current_domains[attachment.result_current_id as usize])?;
+        }
+
+        let invocation_range = checked_usize_range(
+            stage.invocation_start,
+            stage.invocation_count,
+            invocations.len(),
+            "stage invocations",
+        )?;
+        for invocation in &mut invocations[invocation_range] {
+            let range = checked_usize_range(
+                invocation.attachment_start,
+                invocation.attachment_count,
+                attachments.len(),
+                "invocation attachments",
+            )?;
+            let mut domain = Vec::new();
+            for attachment in &attachments[range] {
+                union_sorted_into(
+                    &mut domain,
+                    &current_domains[attachment.result_current_id as usize],
+                )?;
+            }
+            invocation.selector_domain_id = interner.intern(&domain)?;
+            union_sorted_into(
+                &mut value_domains[invocation.left_value_slot_id as usize],
+                &domain,
+            )?;
+            union_sorted_into(
+                &mut value_domains[invocation.right_value_slot_id as usize],
+                &domain,
+            )?;
+        }
+        for finalization in &finalizations[finalization_range] {
+            current_domains[finalization.current_id as usize].clear();
+        }
+    }
+
+    let mut order = (0..interner.members.len()).collect::<Vec<_>>();
+    order.sort_by(|left, right| {
+        compare_domain_members(&interner.members[*left], &interner.members[*right])
+    });
+    let mut remap = vec![0_u32; order.len()];
+    let mut domain_rows = reserved(order.len(), "selector domains")?;
+    let member_capacity = interner
+        .members
+        .iter()
+        .try_fold(0_usize, |total, members| total.checked_add(members.len()))
+        .ok_or_else(|| invalid("selector membership count exceeds usize"))?;
+    let mut memberships = reserved(member_capacity, "selector memberships")?;
+    for (final_id, provisional_id) in order.into_iter().enumerate() {
+        remap[provisional_id] = usize_present_u32(final_id, "final selector domain ID")?;
+        let members = &interner.members[provisional_id];
+        domain_rows.push(EagerPlanSelectorDomainRow {
+            member_start: usize_u64(memberships.len(), "selector member start")?,
+            member_count: usize_u64(members.len(), "selector member count")?,
+        });
+        memberships.extend_from_slice(members);
+    }
+    let remap_id = |id: &mut u32| {
+        debug_assert_ne!(*id, MISSING_U32);
+        *id = remap[*id as usize];
+    };
+    for row in invocations {
+        remap_id(&mut row.selector_domain_id);
+    }
+    for row in attachments {
+        remap_id(&mut row.selector_domain_id);
+    }
+    for row in finalizations {
+        remap_id(&mut row.unpropagated_selector_domain_id);
+        remap_id(&mut row.propagated_selector_domain_id);
+    }
+    for row in closures {
+        remap_id(&mut row.selector_domain_id);
+    }
+    let _ = empty_domain;
+    Ok((domain_rows, memberships))
+}
+
+fn lower_helicity_selectors(
+    input: &EagerLoweringInputV1,
+) -> RusticolResult<Vec<EagerPlanHelicitySelectorRow>> {
+    input
+        .helicity_selectors
+        .iter()
+        .enumerate()
+        .map(|(selector_id, row)| {
+            Ok(EagerPlanHelicitySelectorRow {
+                selector_id: usize_u32(selector_id, "helicity selector ID")?,
+                values_sequence_id: row.values_sequence_id,
+                representative_sequence_id: row.representative_sequence_id,
+                coefficient_factor_id: row.coefficient_factor_id,
+                computed: u8::from(row.computed),
+                structural_zero: u8::from(row.structural_zero),
+            })
+        })
+        .collect()
+}
+
+fn lower_color_selectors(
+    input: &EagerLoweringInputV1,
+) -> RusticolResult<Vec<EagerPlanColorSelectorRow>> {
+    input
+        .color_selectors
+        .iter()
+        .enumerate()
+        .map(|(selector_id, row)| {
+            Ok(EagerPlanColorSelectorRow {
+                selector_id: usize_u32(selector_id, "color selector ID")?,
+                word_sequence_id: row.word_sequence_id,
+                representative_word_sequence_id: row.representative_word_sequence_id,
+                coefficient_factor_id: row.coefficient_factor_id,
+                computed: u8::from(row.computed),
+            })
+        })
+        .collect()
+}
+
+type LoweredReductions = (
+    Vec<EagerPlanReductionGroupRow>,
+    Vec<EagerPlanReductionEntryRow>,
+    u64,
+    u64,
+);
+
+fn lower_reductions(input: &EagerLoweringInputV1) -> RusticolResult<LoweredReductions> {
+    let mut amplitudes_by_group = vec![Vec::new(); input.coherent_groups.len()];
+    for root in &input.roots {
+        amplitudes_by_group[root.coherent_group_id as usize].push(root.id);
+    }
+    if amplitudes_by_group.iter().any(Vec::is_empty) {
+        return Err(invalid("every coherent group must own an amplitude root"));
+    }
+    let mut selectors_by_group = vec![Vec::new(); input.coherent_groups.len()];
+    for member in &input.reduction_members {
+        selectors_by_group[member.coherent_group_id as usize].push(*member);
+    }
+    let base_entry_count = amplitudes_by_group
+        .iter()
+        .map(Vec::len)
+        .chain(selectors_by_group.iter().map(Vec::len))
+        .try_fold(0_usize, |total, count| total.checked_add(count))
+        .ok_or_else(|| invalid("reduction entry count exceeds usize"))?;
+    let contraction_count = if input.color_contraction.present != 0 {
+        input.color_contraction_entries.len()
+    } else {
+        input.coherent_groups.len()
+    };
+    let capacity = base_entry_count
+        .checked_add(contraction_count)
+        .ok_or_else(|| invalid("reduction entry count exceeds usize"))?;
+    let mut groups = reserved(input.coherent_groups.len(), "reduction groups")?;
+    let mut entries = reserved(capacity, "reduction entries")?;
+    for group in &input.coherent_groups {
+        let group_index = group.id as usize;
+        let amplitude_start = usize_u64(entries.len(), "amplitude reduction start")?;
+        for amplitude_id in &amplitudes_by_group[group_index] {
+            entries.push(EagerPlanReductionEntryRow {
+                kind: EagerPlanReductionEntryKind::AmplitudeMember,
+                owner_id: group.id,
+                left_id: *amplitude_id,
+                right_id: MISSING_U32,
+                factor_id: MISSING_U32,
+                auxiliary_factor_id: MISSING_U32,
+            });
+        }
+        let amplitude_count = usize_u64(
+            amplitudes_by_group[group_index].len(),
+            "amplitude reduction count",
+        )?;
+        let selector_start = usize_u64(entries.len(), "selector reduction start")?;
+        for selector in &selectors_by_group[group_index] {
+            entries.push(EagerPlanReductionEntryRow {
+                kind: EagerPlanReductionEntryKind::SelectorMember,
+                owner_id: group.id,
+                left_id: selector.helicity_selector_id,
+                right_id: selector.color_selector_id,
+                factor_id: MISSING_U32,
+                auxiliary_factor_id: MISSING_U32,
+            });
+        }
+        groups.push(EagerPlanReductionGroupRow {
+            coherent_group_id: group.id,
+            amplitude_entry_start: amplitude_start,
+            amplitude_entry_count: amplitude_count,
+            selector_entry_start: selector_start,
+            selector_entry_count: usize_u64(
+                selectors_by_group[group_index].len(),
+                "selector reduction count",
+            )?,
+            helicity_weight_factor_id: group.helicity_weight_factor_id,
+            all_sector_weight_factor_id: group.all_sector_weight_factor_id,
+        });
+    }
+    let contraction_start = usize_u64(entries.len(), "color contraction start")?;
+    if input.color_contraction.present != 0 {
+        for entry in &input.color_contraction_entries {
+            entries.push(EagerPlanReductionEntryRow {
+                kind: EagerPlanReductionEntryKind::ColorContraction,
+                owner_id: MISSING_U32,
+                left_id: entry.left_group_id,
+                right_id: entry.right_group_id,
+                factor_id: entry.weight_factor_id,
+                auxiliary_factor_id: entry.symmetry_factor_id,
+            });
+        }
+    } else {
+        for group in &input.coherent_groups {
+            entries.push(EagerPlanReductionEntryRow {
+                kind: EagerPlanReductionEntryKind::ColorContraction,
+                owner_id: MISSING_U32,
+                left_id: group.id,
+                right_id: group.id,
+                factor_id: group.all_sector_weight_factor_id,
+                auxiliary_factor_id: MISSING_U32,
+            });
+        }
+    }
+    let contraction_entry_count = usize_u64(entries.len(), "color contraction stop")?
+        .checked_sub(contraction_start)
+        .ok_or_else(|| invalid("color contraction range underflow"))?;
+    Ok((groups, entries, contraction_start, contraction_entry_count))
+}
+
+fn validate_stage_dependencies(
+    input: &EagerLoweringInputV1,
+    producer_stage_by_current: &[u32],
+) -> RusticolResult<()> {
+    let mut stage_by_size = BTreeMap::new();
+    for size in input
+        .interactions
+        .iter()
+        .map(|row| row.stage_subset_size)
+        .collect::<BTreeSet<_>>()
+    {
+        let index = usize_u32(stage_by_size.len(), "stage position")?;
+        stage_by_size.insert(size, index);
+    }
+    for interaction in &input.interactions {
+        let stage = stage_by_size[&interaction.stage_subset_size];
+        for current_id in [interaction.left_current_id, interaction.right_current_id] {
+            if !input.currents[current_id as usize].is_source
+                && producer_stage_by_current[current_id as usize] >= stage
+            {
+                return Err(invalid(format!(
+                    "interaction {} consumes current {current_id} before it is finalized",
+                    interaction.id
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_group_signature(
+    representative: &InputInteraction,
+    member: &InputInteraction,
+    group_id: usize,
+) -> RusticolResult<()> {
+    // Evaluation-group identity is the compiler's exact proof that these
+    // oriented interactions share one representative kernel evaluation. The
+    // attachment rows retain each member's factors and output contract. Only
+    // crossing a stage boundary would make the shared invocation unschedulable.
+    if representative.stage_subset_size != member.stage_subset_size {
+        return Err(invalid(format!(
+            "interaction group {group_id} crosses recursion stages"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_kernel_transform(
+    kernel_id: u32,
+    order: [u8; 2],
+    factor_source: u8,
+    kernel_optional: bool,
+    context: &str,
+) -> RusticolResult<()> {
+    if kernel_id == MISSING_U32 && !kernel_optional {
+        return Err(invalid(format!("{context} has no prepared kernel")));
+    }
+    if !matches!(order, [0, 1] | [1, 0]) {
+        return Err(invalid(format!(
+            "{context} canonical input order is not a permutation"
+        )));
+    }
+    if !matches!(
+        factor_source,
+        OUTPUT_FACTOR_NONE | OUTPUT_FACTOR_COUPLING_REAL | OUTPUT_FACTOR_COUPLING_IMAG
+    ) {
+        return Err(invalid(format!(
+            "{context} has unsupported output factor source {factor_source}"
+        )));
+    }
+    if kernel_id == MISSING_U32 && factor_source != OUTPUT_FACTOR_NONE {
+        return Err(invalid(format!(
+            "direct {context} cannot use a prepared-kernel output factor"
+        )));
+    }
+    Ok(())
+}
+
+fn compare_domain_members(left: &[u32], right: &[u32]) -> Ordering {
+    left.len()
+        .cmp(&right.len())
+        .then_with(|| left.iter().rev().cmp(right.iter().rev()))
+}
+
+fn union_sorted_into(target: &mut Vec<u32>, source: &[u32]) -> RusticolResult<()> {
+    if source.is_empty() {
+        return Ok(());
+    }
+    if target.is_empty() {
+        target
+            .try_reserve_exact(source.len())
+            .map_err(|error| invalid(format!("could not reserve selector domain: {error}")))?;
+        target.extend_from_slice(source);
+        return Ok(());
+    }
+    let capacity = target
+        .len()
+        .checked_add(source.len())
+        .ok_or_else(|| invalid("selector domain union exceeds usize"))?;
+    let mut merged = reserved(capacity, "selector domain union")?;
+    let (mut left, mut right) = (0, 0);
+    while left < target.len() || right < source.len() {
+        let value = match (target.get(left), source.get(right)) {
+            (Some(a), Some(b)) if a < b => {
+                left += 1;
+                *a
+            }
+            (Some(a), Some(b)) if b < a => {
+                right += 1;
+                *b
+            }
+            (Some(a), Some(_)) => {
+                left += 1;
+                right += 1;
+                *a
+            }
+            (Some(a), None) => {
+                left += 1;
+                *a
+            }
+            (None, Some(b)) => {
+                right += 1;
+                *b
+            }
+            (None, None) => break,
+        };
+        merged.push(value);
+    }
+    *target = merged;
+    Ok(())
+}
+
+fn compare_bitsets(
+    input: &EagerLoweringInputV1,
+    left_id: u32,
+    right_id: u32,
+) -> RusticolResult<Ordering> {
+    let left = required_row(&input.bitset_ranges, left_id, "left bitset")?;
+    let right = required_row(&input.bitset_ranges, right_id, "right bitset")?;
+    let by_population = left.bit_count.cmp(&right.bit_count);
+    if by_population != Ordering::Equal {
+        return Ok(by_population);
+    }
+    let left_words = range_slice(&input.bitset_words, left.range, "left bitset words")?;
+    let right_words = range_slice(&input.bitset_words, right.range, "right bitset words")?;
+    Ok(left_words
+        .len()
+        .cmp(&right_words.len())
+        .then_with(|| left_words.iter().rev().cmp(right_words.iter().rev())))
+}
+
+fn factor_is_complex_zero(factor: &InputExactFactor) -> bool {
+    f64::from_bits(factor.real_bits) == 0.0 && f64::from_bits(factor.imaginary_bits) == 0.0
+}
+
+fn factor_is_real_zero(factor: &InputExactFactor) -> bool {
+    f64::from_bits(factor.imaginary_bits) == 0.0
+}
+
+fn equal_column_lengths(context: &str, columns: &[(&str, usize)]) -> RusticolResult<usize> {
+    let expected = columns.first().map(|(_, length)| *length).unwrap_or(0);
+    for (name, length) in columns {
+        if *length != expected {
+            return Err(invalid(format!(
+                "{context}.{name} has {length} rows, expected {expected}"
+            )));
+        }
+    }
+    usize_u32(expected, &format!("{context} row count"))?;
+    Ok(expected)
+}
+
+fn bool_column(value: u8, context: &str, row: usize) -> RusticolResult<bool> {
+    validate_bool_scalar(value, &format!("{context}[{row}]"))?;
+    Ok(value != 0)
+}
+
+fn validate_bool_scalar(value: u8, context: &str) -> RusticolResult<()> {
+    if value > 1 {
+        return Err(invalid(format!("{context} must be zero or one")));
+    }
+    Ok(())
+}
+
+fn validate_dense_ids(
+    ids: impl Iterator<Item = u32>,
+    count: usize,
+    context: &str,
+) -> RusticolResult<()> {
+    for (expected, actual) in ids.enumerate() {
+        expect_dense_id(actual, expected, context)?;
+    }
+    usize_u32(count, &format!("{context} count"))?;
+    Ok(())
+}
+
+fn expect_dense_id(actual: u32, expected: usize, context: &str) -> RusticolResult<()> {
+    let expected = usize_u32(expected, &format!("{context} ID"))?;
+    if actual != expected {
+        return Err(invalid(format!(
+            "{context} IDs must be dense: found {actual}, expected {expected}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_flat_ranges(
+    ranges: impl Iterator<Item = InputRange>,
+    flat_len: usize,
+    context: &str,
+) -> RusticolResult<()> {
+    let mut cursor = 0_u64;
+    for (row, range) in ranges.enumerate() {
+        if range.start != cursor {
+            return Err(invalid(format!(
+                "{context} range {row} starts at {}, expected {cursor}",
+                range.start
+            )));
+        }
+        cursor = range
+            .start
+            .checked_add(range.count)
+            .ok_or_else(|| invalid(format!("{context} range {row} exceeds u64")))?;
+    }
+    if cursor != usize_u64(flat_len, &format!("{context} flat length"))? {
+        return Err(invalid(format!(
+            "{context} ranges cover {cursor} rows, expected {flat_len}"
+        )));
+    }
+    Ok(())
+}
+
+fn range_slice<'a, T>(
+    values: &'a [T],
+    range: InputRange,
+    context: &str,
+) -> RusticolResult<&'a [T]> {
+    let bounds = checked_usize_range(range.start, range.count, values.len(), context)?;
+    Ok(&values[bounds])
+}
+
+fn checked_usize_range(
+    start: u64,
+    count: u64,
+    length: usize,
+    context: &str,
+) -> RusticolResult<std::ops::Range<usize>> {
+    let end = start
+        .checked_add(count)
+        .ok_or_else(|| invalid(format!("{context} range exceeds u64")))?;
+    let start = usize::try_from(start)
+        .map_err(|_| invalid(format!("{context} start exceeds platform bounds")))?;
+    let end = usize::try_from(end)
+        .map_err(|_| invalid(format!("{context} end exceeds platform bounds")))?;
+    if start > length || end > length {
+        return Err(invalid(format!("{context} range exceeds table bounds")));
+    }
+    Ok(start..end)
+}
+
+fn required_row<'a, T>(values: &'a [T], id: u32, context: &str) -> RusticolResult<&'a T> {
+    let index = index(id, values.len(), context)?;
+    Ok(&values[index])
+}
+
+fn required_index(id: u32, count: impl TryInto<usize>, context: &str) -> RusticolResult<usize> {
+    let count = count
+        .try_into()
+        .map_err(|_| invalid(format!("{context} count exceeds platform bounds")))?;
+    index(id, count, context)
+}
+
+fn optional_index(id: u32, count: impl TryInto<usize>, context: &str) -> RusticolResult<()> {
+    if id != MISSING_U32 {
+        required_index(id, count, context)?;
+    }
+    Ok(())
+}
+
+fn index(id: u32, count: usize, context: &str) -> RusticolResult<usize> {
+    let index = usize::try_from(id)
+        .map_err(|_| invalid(format!("{context} ID {id} exceeds platform bounds")))?;
+    if index >= count {
+        return Err(invalid(format!(
+            "{context} ID {id} references an absent row (count {count})"
+        )));
+    }
+    Ok(index)
+}
+
+#[cfg(test)]
+fn count_u32(count: u64, context: &str) -> RusticolResult<u32> {
+    u32::try_from(count).map_err(|_| invalid(format!("{context} count exceeds u32")))
+}
+
+fn usize_u32(value: usize, context: &str) -> RusticolResult<u32> {
+    u32::try_from(value).map_err(|_| invalid(format!("{context} exceeds u32")))
+}
+
+fn usize_present_u32(value: usize, context: &str) -> RusticolResult<u32> {
+    let value = usize_u32(value, context)?;
+    if value == MISSING_U32 {
+        return Err(invalid(format!(
+            "{context} collides with the missing-ID sentinel"
+        )));
+    }
+    Ok(value)
+}
+
+fn usize_u64(value: usize, context: &str) -> RusticolResult<u64> {
+    u64::try_from(value).map_err(|_| invalid(format!("{context} exceeds u64")))
+}
+
+fn reserved<T>(capacity: usize, context: &str) -> RusticolResult<Vec<T>> {
+    let mut result = Vec::new();
+    result.try_reserve_exact(capacity).map_err(|error| {
+        invalid(format!(
+            "could not reserve {context} ({capacity} rows): {error}"
+        ))
+    })?;
+    Ok(result)
+}
+
+fn copy_slice<T: Copy>(values: &[T], context: &str) -> RusticolResult<Vec<T>> {
+    let mut result = reserved(values.len(), context)?;
+    result.extend_from_slice(values);
+    Ok(result)
+}
+
+fn copy_retained_tables(
+    tables: &[EagerRetainedTableView<'_>],
+) -> RusticolResult<Vec<EagerOwnedRetainedTable>> {
+    if tables.len() != EAGER_LOWERING_V1_TABLE_NAMES.len() {
+        return Err(invalid(format!(
+            "eager lowering retained table inventory has {} entries, expected {}",
+            tables.len(),
+            EAGER_LOWERING_V1_TABLE_NAMES.len()
+        )));
+    }
+    let mut owned_tables = reserved(tables.len(), "retained eager tables")?;
+    for (table_index, (table, expected_name)) in
+        tables.iter().zip(EAGER_LOWERING_V1_TABLE_NAMES).enumerate()
+    {
+        if table.name != *expected_name {
+            return Err(invalid(format!(
+                "eager lowering retained table {table_index} is {:?}, expected {:?}",
+                table.name, expected_name
+            )));
+        }
+        let row_count = usize::try_from(table.row_count).map_err(|_| {
+            invalid(format!(
+                "retained table {:?} row count exceeds platform bounds",
+                table.name
+            ))
+        })?;
+        usize_u32(
+            row_count,
+            &format!("retained table {:?} row count", table.name),
+        )?;
+        let mut seen_columns = BTreeSet::new();
+        let mut columns = reserved(table.columns.len(), "retained eager columns")?;
+        for (column_index, column) in table.columns.iter().enumerate() {
+            if column.name.is_empty() {
+                return Err(invalid(format!(
+                    "retained table {:?} column {column_index} has an empty name",
+                    table.name
+                )));
+            }
+            if !seen_columns.insert(column.name) {
+                return Err(invalid(format!(
+                    "retained table {:?} repeats column {:?}",
+                    table.name, column.name
+                )));
+            }
+            if column.elements_per_row == 0 {
+                return Err(invalid(format!(
+                    "retained column {}.{} has zero elements per row",
+                    table.name, column.name
+                )));
+            }
+            let expected_elements = table
+                .row_count
+                .checked_mul(u64::from(column.elements_per_row))
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "retained column {}.{} shape exceeds u64",
+                        table.name, column.name
+                    ))
+                })?;
+            if usize_u64(column.values.len(), "retained column element count")? != expected_elements
+            {
+                return Err(invalid(format!(
+                    "retained column {}.{} has {} elements, expected {expected_elements}",
+                    table.name,
+                    column.name,
+                    column.values.len()
+                )));
+            }
+            let values = match column.values {
+                EagerPrimitiveColumnView::U8(values) => {
+                    EagerOwnedPrimitiveColumn::U8(copy_slice(values, "retained u8 column")?)
+                }
+                EagerPrimitiveColumnView::U32(values) => {
+                    EagerOwnedPrimitiveColumn::U32(copy_slice(values, "retained u32 column")?)
+                }
+                EagerPrimitiveColumnView::U64(values) => {
+                    EagerOwnedPrimitiveColumn::U64(copy_slice(values, "retained u64 column")?)
+                }
+                EagerPrimitiveColumnView::I32(values) => {
+                    EagerOwnedPrimitiveColumn::I32(copy_slice(values, "retained i32 column")?)
+                }
+                EagerPrimitiveColumnView::F64(values) => {
+                    let mut bits = reserved(values.len(), "retained f64 column")?;
+                    for (row, value) in values.iter().copied().enumerate() {
+                        if !value.is_finite() {
+                            return Err(invalid(format!(
+                                "retained column {}.{} element {row} is not finite",
+                                table.name, column.name
+                            )));
+                        }
+                        bits.push(value.to_bits());
+                    }
+                    EagerOwnedPrimitiveColumn::F64Bits(bits)
+                }
+            };
+            columns.push(EagerOwnedRetainedColumn {
+                name: copy_boxed_str(column.name, "retained column name", column_index)?,
+                elements_per_row: column.elements_per_row,
+                values,
+            });
+        }
+        owned_tables.push(EagerOwnedRetainedTable {
+            name: copy_boxed_str(table.name, "retained table name", table_index)?,
+            row_count: table.row_count,
+            columns,
+        });
+    }
+    Ok(owned_tables)
+}
+
+fn validate_retained_table_counts(input: &EagerLoweringInputV1) -> RusticolResult<()> {
+    for table in &input.retained_tables {
+        let expected = match table.name() {
+            "bitset_ranges" => Some(input.bitset_ranges.len()),
+            "bitset_words" => Some(input.bitset_words.len()),
+            "coherent_groups" => Some(input.coherent_groups.len()),
+            "color_contraction_entries" => Some(input.color_contraction_entries.len()),
+            "color_contraction_metadata"
+            | "metadata"
+            | "lc_replay_metadata"
+            | "helicity_proof_metadata"
+            | "helicity_materialization_metadata" => Some(1),
+            "color_selectors" => Some(input.color_selectors.len()),
+            "contraction_coefficients" => Some(input.contraction_coefficients.len()),
+            "couplings" => Some(input.couplings.len()),
+            "currents" => Some(input.currents.len()),
+            "exact_factors" => Some(input.exact_factors.len()),
+            "helicity_selectors" => Some(input.helicity_selectors.len()),
+            "i32_sequence_ranges" => Some(input.i32_sequence_ranges.len()),
+            "i32_sequence_values" => Some(input.i32_sequence_values.len()),
+            "interaction_group_members" => Some(input.interaction_group_members.len()),
+            "interaction_groups" => Some(input.interaction_groups.len()),
+            "interactions" => Some(input.interactions.len()),
+            "model_parameters" => Some(input.model_parameters.len()),
+            "momentum_masks" => Some(input.momentum_masks.len()),
+            "reduction_members" => Some(input.reduction_members.len()),
+            "roots" => Some(input.roots.len()),
+            "sources" => Some(input.sources.len()),
+            "u32_sequence_ranges" => Some(input.u32_sequence_ranges.len()),
+            "u32_sequence_values" => Some(input.u32_sequence_values.len()),
+            _ => None,
+        };
+        if let Some(expected) = expected
+            && table.row_count != usize_u64(expected, "retained table expected row count")?
+        {
+            return Err(invalid(format!(
+                "retained table {:?} has {} rows, expected {expected}",
+                table.name(),
+                table.row_count
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn copy_string_catalog(values: &[&str], context: &str) -> RusticolResult<Vec<Box<str>>> {
+    let mut seen = BTreeSet::new();
+    for (index, value) in values.iter().copied().enumerate() {
+        if !seen.insert(value) {
+            return Err(invalid(format!(
+                "{context} contains duplicate value at row {index}"
+            )));
+        }
+    }
+    let mut result = reserved(values.len(), context)?;
+    for (index, value) in values.iter().copied().enumerate() {
+        result.push(copy_boxed_str(value, context, index)?);
+    }
+    Ok(result)
+}
+
+fn copy_string_list(values: &[&str], context: &str) -> RusticolResult<Vec<Box<str>>> {
+    let mut result = reserved(values.len(), context)?;
+    for (index, value) in values.iter().copied().enumerate() {
+        if value.is_empty() {
+            return Err(invalid(format!("{context} row {index} must not be empty")));
+        }
+        result.push(copy_boxed_str(value, context, index)?);
+    }
+    Ok(result)
+}
+
+fn copy_boxed_str(value: &str, context: &str, index: usize) -> RusticolResult<Box<str>> {
+    let mut owned = String::new();
+    owned.try_reserve_exact(value.len()).map_err(|error| {
+        invalid(format!(
+            "could not reserve {context} row {index} ({} bytes): {error}",
+            value.len()
+        ))
+    })?;
+    owned.push_str(value);
+    Ok(owned.into_boxed_str())
+}
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+#[cfg(test)]
+#[path = "eager_lowering_v3_tests.rs"]
+mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_lowering_v3_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_lowering_v3_tests.rs
new file mode 100644
index 0000000000..58e991aa3d
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_lowering_v3_tests.rs
@@ -0,0 +1,692 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::RusticolErrorKind;
+
+#[derive(Clone)]
+struct Fixture {
+    current_id: Vec<u32>,
+    current_dimension: Vec<u32>,
+    current_is_source: Vec<u8>,
+    current_momentum_bitset: Vec<u32>,
+    current_propagator_ir: Vec<u32>,
+    current_propagator_kernel: Vec<u32>,
+    source_id: Vec<u32>,
+    source_current: Vec<u32>,
+    source_external_label: Vec<u32>,
+    source_input_momentum: Vec<u32>,
+    source_ir: Vec<u32>,
+    source_crossing_ir: Vec<u32>,
+    source_crossing_factor: Vec<u32>,
+    source_state: Vec<u32>,
+    interaction_id: Vec<u32>,
+    interaction_stage_size: Vec<u32>,
+    interaction_left: Vec<u32>,
+    interaction_right: Vec<u32>,
+    interaction_result: Vec<u32>,
+    interaction_coupling: Vec<u32>,
+    interaction_coupling_factor: Vec<u32>,
+    interaction_color_factor: Vec<u32>,
+    interaction_evaluation_factor: Vec<u32>,
+    interaction_group: Vec<u32>,
+    interaction_ready: Vec<u8>,
+    interaction_kernel: Vec<u32>,
+    interaction_order: Vec<[u8; 2]>,
+    interaction_normalization: Vec<u32>,
+    interaction_output_factor: Vec<u8>,
+    root_id: Vec<u32>,
+    root_left: Vec<u32>,
+    root_right: Vec<u32>,
+    root_color_factor: Vec<u32>,
+    root_contraction_ir: Vec<u32>,
+    root_coupling: Vec<u32>,
+    root_coupling_factor: Vec<u32>,
+    root_helicity_weight: Vec<u32>,
+    root_group: Vec<u32>,
+    root_kernel: Vec<u32>,
+    root_order: Vec<[u8; 2]>,
+    root_normalization: Vec<u32>,
+    root_output_factor: Vec<u8>,
+    group_representative: Vec<u32>,
+    group_start: Vec<u64>,
+    group_count: Vec<u64>,
+    group_members: Vec<u32>,
+    momentum_slot: Vec<u32>,
+    momentum_bitset: Vec<u32>,
+    bitset_start: Vec<u64>,
+    bitset_count: Vec<u64>,
+    bitset_population: Vec<u64>,
+    bitset_words: Vec<u64>,
+    u32_sequence_start: Vec<u64>,
+    u32_sequence_count: Vec<u64>,
+    u32_sequence_values: Vec<u32>,
+    i32_sequence_start: Vec<u64>,
+    i32_sequence_count: Vec<u64>,
+    i32_sequence_values: Vec<i32>,
+    factor_real: Vec<f64>,
+    factor_imaginary: Vec<f64>,
+    factor_string: Vec<u32>,
+    factor_source: Vec<u8>,
+    factor_ir: Vec<u32>,
+    factor_source_ir: Vec<u32>,
+    coupling_factor: Vec<u32>,
+    coupling_names: Vec<u32>,
+    parameter_name: Vec<u32>,
+    parameter_kind: Vec<u32>,
+    parameter_default: Vec<f64>,
+    parameter_default_factor: Vec<u32>,
+    parameter_runtime_name: Vec<u32>,
+    parameter_component: Vec<i32>,
+    parameter_derived: Vec<u8>,
+    coefficient_ir: Vec<u32>,
+    coefficient_component: Vec<u32>,
+    coefficient_factor: Vec<u32>,
+    coherent_id: Vec<u32>,
+    coherent_helicity_weight: Vec<u32>,
+    coherent_all_weight: Vec<u32>,
+    helicity_values: Vec<u32>,
+    helicity_representative: Vec<u32>,
+    helicity_coefficient: Vec<u32>,
+    helicity_computed: Vec<u8>,
+    helicity_zero: Vec<u8>,
+    color_word: Vec<u32>,
+    color_representative: Vec<u32>,
+    color_coefficient: Vec<u32>,
+    color_computed: Vec<u8>,
+    reduction_group: Vec<u32>,
+    reduction_helicity: Vec<u32>,
+    reduction_color: Vec<u32>,
+    contraction_metadata: EagerColorContractionMetadata,
+    contraction_left: Vec<u32>,
+    contraction_right: Vec<u32>,
+    contraction_weight: Vec<u32>,
+    contraction_symmetry: Vec<u32>,
+    string_catalog: Vec<&'static str>,
+    ir_catalog: Vec<&'static str>,
+    semantic_limitations: Vec<&'static str>,
+}
+
+impl Fixture {
+    fn valid() -> Self {
+        Self {
+            current_id: vec![0, 1, 2, 3],
+            current_dimension: vec![1; 4],
+            current_is_source: vec![1, 1, 0, 0],
+            current_momentum_bitset: vec![0, 1, 2, 2],
+            current_propagator_ir: vec![0; 4],
+            current_propagator_kernel: vec![MISSING_U32, MISSING_U32, 30, MISSING_U32],
+            source_id: vec![0, 1],
+            source_current: vec![0, 1],
+            source_external_label: vec![1, 2],
+            source_input_momentum: vec![0, 1],
+            source_ir: vec![0, 0],
+            source_crossing_ir: vec![0, 0],
+            source_crossing_factor: vec![0, 0],
+            source_state: vec![0, 0],
+            interaction_id: vec![0, 1],
+            interaction_stage_size: vec![2, 3],
+            interaction_left: vec![0, 2],
+            interaction_right: vec![1, 1],
+            interaction_result: vec![2, 3],
+            interaction_coupling: vec![0, 0],
+            interaction_coupling_factor: vec![0, 0],
+            interaction_color_factor: vec![1, 1],
+            interaction_evaluation_factor: vec![0, 0],
+            interaction_group: vec![0, 1],
+            interaction_ready: vec![1, 1],
+            interaction_kernel: vec![10, 11],
+            interaction_order: vec![[0, 1], [1, 0]],
+            interaction_normalization: vec![0, 0],
+            interaction_output_factor: vec![0, 0],
+            root_id: vec![0],
+            root_left: vec![3],
+            root_right: vec![0],
+            root_color_factor: vec![1],
+            root_contraction_ir: vec![0],
+            root_coupling: vec![0],
+            root_coupling_factor: vec![0],
+            root_helicity_weight: vec![0],
+            root_group: vec![0],
+            root_kernel: vec![40],
+            root_order: vec![[0, 1]],
+            root_normalization: vec![0],
+            root_output_factor: vec![0],
+            group_representative: vec![0, 1],
+            group_start: vec![0, 1],
+            group_count: vec![1, 1],
+            group_members: vec![0, 1],
+            momentum_slot: vec![0, 1, 2],
+            momentum_bitset: vec![0, 1, 2],
+            bitset_start: vec![0, 1, 2],
+            bitset_count: vec![1, 1, 1],
+            bitset_population: vec![1, 1, 2],
+            bitset_words: vec![1, 2, 3],
+            u32_sequence_start: vec![0],
+            u32_sequence_count: vec![0],
+            u32_sequence_values: vec![],
+            i32_sequence_start: vec![0],
+            i32_sequence_count: vec![2],
+            i32_sequence_values: vec![-1, 1],
+            factor_real: vec![1.0, 2.0, -0.0],
+            factor_imaginary: vec![0.0; 3],
+            factor_string: vec![0, 1, 2],
+            factor_source: vec![0; 3],
+            factor_ir: vec![0, 1, 2],
+            factor_source_ir: vec![MISSING_U32; 3],
+            coupling_factor: vec![0],
+            coupling_names: vec![0],
+            parameter_name: vec![],
+            parameter_kind: vec![],
+            parameter_default: vec![],
+            parameter_default_factor: vec![],
+            parameter_runtime_name: vec![],
+            parameter_component: vec![],
+            parameter_derived: vec![],
+            coefficient_ir: vec![],
+            coefficient_component: vec![],
+            coefficient_factor: vec![],
+            coherent_id: vec![0],
+            coherent_helicity_weight: vec![0],
+            coherent_all_weight: vec![0],
+            helicity_values: vec![0, 0],
+            helicity_representative: vec![0, 0],
+            helicity_coefficient: vec![0, 2],
+            helicity_computed: vec![1, 0],
+            helicity_zero: vec![0, 1],
+            color_word: vec![0],
+            color_representative: vec![0],
+            color_coefficient: vec![0],
+            color_computed: vec![1],
+            reduction_group: vec![0],
+            reduction_helicity: vec![0],
+            reduction_color: vec![0],
+            contraction_metadata: EagerColorContractionMetadata {
+                present: 0,
+                supported: 0,
+                group_count: 0,
+                includes_color_factor: 0,
+            },
+            contraction_left: vec![],
+            contraction_right: vec![],
+            contraction_weight: vec![],
+            contraction_symmetry: vec![],
+            string_catalog: vec!["factor-0", "factor-1", "factor-2"],
+            ir_catalog: vec!["{\"id\":0}", "{\"id\":1}", "{\"id\":2}"],
+            semantic_limitations: vec!["binary64 source factors retain exact payload bits"],
+        }
+    }
+
+    fn retained_row_count(&self, name: &str) -> u64 {
+        match name {
+            "bitset_ranges" => self.bitset_start.len() as u64,
+            "bitset_words" => self.bitset_words.len() as u64,
+            "coherent_groups" => self.coherent_id.len() as u64,
+            "color_contraction_entries" => self.contraction_left.len() as u64,
+            "color_contraction_metadata"
+            | "metadata"
+            | "lc_replay_metadata"
+            | "helicity_proof_metadata"
+            | "helicity_materialization_metadata" => 1,
+            "color_selectors" => self.color_word.len() as u64,
+            "contraction_coefficients" => self.coefficient_ir.len() as u64,
+            "couplings" => self.coupling_factor.len() as u64,
+            "currents" => self.current_id.len() as u64,
+            "exact_factors" => self.factor_real.len() as u64,
+            "helicity_selectors" => self.helicity_values.len() as u64,
+            "i32_sequence_ranges" => self.i32_sequence_start.len() as u64,
+            "i32_sequence_values" => self.i32_sequence_values.len() as u64,
+            "interaction_group_members" => self.group_members.len() as u64,
+            "interaction_groups" => self.group_start.len() as u64,
+            "interactions" => self.interaction_id.len() as u64,
+            "model_parameters" => self.parameter_name.len() as u64,
+            "momentum_masks" => self.momentum_slot.len() as u64,
+            "reduction_members" => self.reduction_group.len() as u64,
+            "roots" => self.root_id.len() as u64,
+            "sources" => self.source_id.len() as u64,
+            "u32_sequence_ranges" => self.u32_sequence_start.len() as u64,
+            "u32_sequence_values" => self.u32_sequence_values.len() as u64,
+            _ => 0,
+        }
+    }
+
+    fn retained_views(&self) -> Vec<EagerRetainedTableView<'static>> {
+        EAGER_LOWERING_V1_TABLE_NAMES
+            .iter()
+            .map(|name| EagerRetainedTableView {
+                name,
+                row_count: self.retained_row_count(name),
+                columns: &[],
+            })
+            .collect()
+    }
+
+    fn view<'a>(
+        &'a self,
+        retained_tables: &'a [EagerRetainedTableView<'a>],
+    ) -> EagerLoweringInputV1View<'a> {
+        EagerLoweringInputV1View {
+            abi: EAGER_LOWERING_INPUT_ABI,
+            process_key: "fixture",
+            model_name: "fixture-model",
+            string_catalog: &self.string_catalog,
+            canonical_ir_catalog: &self.ir_catalog,
+            semantic_limitations: &self.semantic_limitations,
+            retained_tables,
+            unsupported_tables: &[],
+            currents: EagerCurrentColumns {
+                id: &self.current_id,
+                dimension: &self.current_dimension,
+                is_source: &self.current_is_source,
+                momentum_mask_bitset_id: &self.current_momentum_bitset,
+                propagator_ir_id: &self.current_propagator_ir,
+                propagator_kernel_id: &self.current_propagator_kernel,
+            },
+            sources: EagerSourceColumns {
+                source_id: &self.source_id,
+                current_id: &self.source_current,
+                external_label: &self.source_external_label,
+                input_momentum_slot: &self.source_input_momentum,
+                source_ir_id: &self.source_ir,
+                crossing_ir_id: &self.source_crossing_ir,
+                crossing_factor_id: &self.source_crossing_factor,
+                declared_state_index: &self.source_state,
+            },
+            interactions: EagerInteractionColumns {
+                id: &self.interaction_id,
+                stage_subset_size: &self.interaction_stage_size,
+                left_current_id: &self.interaction_left,
+                right_current_id: &self.interaction_right,
+                result_current_id: &self.interaction_result,
+                coupling_id: &self.interaction_coupling,
+                coupling_factor_id: &self.interaction_coupling_factor,
+                color_factor_id: &self.interaction_color_factor,
+                evaluation_factor_id: &self.interaction_evaluation_factor,
+                evaluation_group_id: &self.interaction_group,
+                full_tensor_network_ready: &self.interaction_ready,
+                kernel_id: &self.interaction_kernel,
+                canonical_input_order: &self.interaction_order,
+                kernel_normalization_factor_id: &self.interaction_normalization,
+                output_factor_source: &self.interaction_output_factor,
+            },
+            roots: EagerRootColumns {
+                id: &self.root_id,
+                left_current_id: &self.root_left,
+                right_current_id: &self.root_right,
+                color_factor_id: &self.root_color_factor,
+                contraction_ir_id: &self.root_contraction_ir,
+                coupling_id: &self.root_coupling,
+                coupling_factor_id: &self.root_coupling_factor,
+                helicity_weight_factor_id: &self.root_helicity_weight,
+                coherent_group_id: &self.root_group,
+                kernel_id: &self.root_kernel,
+                canonical_input_order: &self.root_order,
+                kernel_normalization_factor_id: &self.root_normalization,
+                output_factor_source: &self.root_output_factor,
+            },
+            interaction_groups: EagerInteractionGroupColumns {
+                representative_interaction_id: &self.group_representative,
+                member_start: &self.group_start,
+                member_count: &self.group_count,
+                member_interaction_id: &self.group_members,
+            },
+            momentum_masks: EagerMomentumMaskColumns {
+                slot_id: &self.momentum_slot,
+                bitset_id: &self.momentum_bitset,
+            },
+            bitsets: EagerBitsetColumns {
+                start: &self.bitset_start,
+                count: &self.bitset_count,
+                bit_count: &self.bitset_population,
+                words: &self.bitset_words,
+            },
+            u32_sequences: EagerU32SequenceColumns {
+                start: &self.u32_sequence_start,
+                count: &self.u32_sequence_count,
+                values: &self.u32_sequence_values,
+            },
+            i32_sequences: EagerI32SequenceColumns {
+                start: &self.i32_sequence_start,
+                count: &self.i32_sequence_count,
+                values: &self.i32_sequence_values,
+            },
+            exact_factors: EagerExactFactorColumns {
+                real: &self.factor_real,
+                imaginary: &self.factor_imaginary,
+                canonical_string_id: &self.factor_string,
+                exact_source: &self.factor_source,
+                exact_ir_id: &self.factor_ir,
+                source_ir_id: &self.factor_source_ir,
+            },
+            couplings: EagerCouplingColumns {
+                constant_factor_id: &self.coupling_factor,
+                parameter_name_ids_sequence_id: &self.coupling_names,
+            },
+            model_parameters: EagerModelParameterColumns {
+                name_string_id: &self.parameter_name,
+                kind_string_id: &self.parameter_kind,
+                default_value: &self.parameter_default,
+                default_factor_id: &self.parameter_default_factor,
+                runtime_name_string_id: &self.parameter_runtime_name,
+                complex_component: &self.parameter_component,
+                derived: &self.parameter_derived,
+            },
+            contraction_coefficients: EagerContractionCoefficientColumns {
+                contraction_ir_id: &self.coefficient_ir,
+                component_index: &self.coefficient_component,
+                factor_id: &self.coefficient_factor,
+            },
+            coherent_groups: EagerCoherentGroupColumns {
+                id: &self.coherent_id,
+                helicity_weight_factor_id: &self.coherent_helicity_weight,
+                all_sector_weight_factor_id: &self.coherent_all_weight,
+            },
+            helicity_selectors: EagerHelicitySelectorColumns {
+                values_sequence_id: &self.helicity_values,
+                representative_sequence_id: &self.helicity_representative,
+                coefficient_factor_id: &self.helicity_coefficient,
+                computed: &self.helicity_computed,
+                structural_zero: &self.helicity_zero,
+            },
+            color_selectors: EagerColorSelectorColumns {
+                word_sequence_id: &self.color_word,
+                representative_word_sequence_id: &self.color_representative,
+                coefficient_factor_id: &self.color_coefficient,
+                computed: &self.color_computed,
+            },
+            reduction_members: EagerReductionMemberColumns {
+                coherent_group_id: &self.reduction_group,
+                helicity_selector_id: &self.reduction_helicity,
+                color_selector_id: &self.reduction_color,
+            },
+            color_contraction: self.contraction_metadata,
+            color_contraction_entries: EagerColorContractionEntryColumns {
+                left_group_id: &self.contraction_left,
+                right_group_id: &self.contraction_right,
+                weight_factor_id: &self.contraction_weight,
+                symmetry_factor_id: &self.contraction_symmetry,
+            },
+        }
+    }
+
+    fn input(&self) -> EagerLoweringInputV1 {
+        let retained_tables = self.retained_views();
+        EagerLoweringInputV1::try_from_view(self.view(&retained_tables)).unwrap()
+    }
+}
+
+fn assert_invalid(fixture: &Fixture, message: &str) {
+    let retained_tables = fixture.retained_views();
+    let error = EagerLoweringInputV1::try_from_view(fixture.view(&retained_tables)).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+    assert!(
+        error.to_string().contains(message),
+        "expected {:?} to contain {message:?}",
+        error.to_string()
+    );
+}
+
+#[test]
+fn owned_input_and_lowering_preserve_semantics_and_exact_factor_ids() {
+    let input = Fixture::valid().input();
+    assert_eq!(input.process_key(), "fixture");
+    assert_eq!(input.model_name(), "fixture-model");
+    assert_eq!(input.string_catalog().len(), 3);
+    assert_eq!(input.canonical_ir_catalog().len(), 3);
+    assert_eq!(input.semantic_limitations().len(), 1);
+    assert_eq!(input.current_count(), 4);
+    assert_eq!(input.interaction_count(), 2);
+    assert_eq!(input.root_count(), 1);
+    assert_eq!(input.exact_factor_count(), 3);
+
+    let plan = lower_eager_plan_v3(input).unwrap();
+    assert_eq!(plan.abi(), "pyamplicol-eager-plan-v3");
+    assert_eq!(plan.current_component_count(), 4);
+    assert_eq!(plan.value_component_count(), 4);
+    assert_eq!(plan.momentum_component_count(), 12);
+    assert_eq!(plan.stages().len(), 2);
+    assert_eq!(plan.invocations().len(), 2);
+    assert_eq!(plan.attachments().len(), 2);
+    assert_eq!(plan.finalizations().len(), 2);
+    assert_eq!(plan.closures().len(), 1);
+    assert_eq!(
+        plan.selector_work_summary().unwrap(),
+        EagerPlanSelectorWorkSummary {
+            selected_flow_selector_count: 1,
+            selected_flow_worst: EagerPlanActiveWorkCounts {
+                current_count: 4,
+                evaluation_count: 2,
+                attachment_count: 2,
+            },
+            all_flow_selector_count: 1,
+            all_flow_worst: EagerPlanActiveWorkCounts {
+                current_count: 4,
+                evaluation_count: 2,
+                attachment_count: 2,
+            },
+            contracted: EagerPlanActiveWorkCounts {
+                current_count: 4,
+                evaluation_count: 2,
+                attachment_count: 2,
+            },
+        }
+    );
+
+    assert_eq!(
+        plan.values()
+            .iter()
+            .map(|row| (row.current_id, row.kind))
+            .collect::<Vec<_>>(),
+        vec![
+            (0, EagerValueSlotKind::Source),
+            (1, EagerValueSlotKind::Source),
+            (2, EagerValueSlotKind::Propagated),
+            (3, EagerValueSlotKind::Unpropagated),
+        ]
+    );
+    assert_eq!(plan.invocations()[1].left_value_slot_id, 1);
+    assert_eq!(plan.invocations()[1].right_value_slot_id, 2);
+    assert_eq!(plan.finalizations()[0].kernel_id, 30);
+    assert_eq!(plan.finalizations()[0].propagated_value_slot_id, 2);
+    assert_eq!(
+        plan.finalizations()[0].unpropagated_value_slot_id,
+        MISSING_U32
+    );
+
+    let attachment = plan.attachments()[0];
+    assert_eq!(attachment.color_factor_id, 1);
+    assert_eq!(attachment.evaluation_factor_id, 0);
+    assert_eq!(attachment.normalization_factor_id, 0);
+    assert_eq!(attachment.representative_evaluation_factor_id, 0);
+    assert_eq!(plan.exact_factors()[2].real_bits, (-0.0_f64).to_bits());
+
+    assert_eq!(
+        plan.selector_domains(),
+        &[
+            EagerPlanSelectorDomainRow {
+                member_start: 0,
+                member_count: 0,
+            },
+            EagerPlanSelectorDomainRow {
+                member_start: 0,
+                member_count: 1,
+            },
+        ]
+    );
+    assert_eq!(plan.selector_memberships(), &[0]);
+    assert_eq!(plan.closures()[0].selector_domain_id, 1);
+    assert_eq!(plan.helicity_selectors()[1].structural_zero, 1);
+
+    let group = plan.reduction_groups()[0];
+    assert_eq!(group.amplitude_entry_count, 1);
+    assert_eq!(group.selector_entry_count, 1);
+    assert_eq!(plan.reduction_entries().len(), 3);
+    assert_eq!(
+        plan.reduction_entries()[2],
+        EagerPlanReductionEntryRow {
+            kind: EagerPlanReductionEntryKind::ColorContraction,
+            owner_id: MISSING_U32,
+            left_id: 0,
+            right_id: 0,
+            factor_id: 0,
+            auxiliary_factor_id: MISSING_U32,
+        }
+    );
+    assert_eq!(plan.color_contraction_entry_range(), (2, 1));
+
+    let shapes = plan.section_shapes().unwrap();
+    assert_eq!(shapes.len(), 17);
+    for shape in shapes {
+        let header = shape.header().unwrap();
+        assert_eq!(header.kind(), shape.kind);
+        assert_eq!(header.record_size(), shape.record_size);
+        assert_eq!(header.record_count(), shape.record_count);
+    }
+}
+
+#[test]
+fn lowering_is_byte_order_and_hash_independent_deterministic() {
+    let input = Fixture::valid().input();
+    let first = lower_eager_plan_v3(input.clone()).unwrap();
+    let second = lower_eager_plan_v3(input).unwrap();
+    assert_eq!(first, second);
+}
+
+#[test]
+fn authenticated_zero_evaluation_groups_emit_no_runtime_invocation() {
+    let mut fixture = Fixture::valid();
+    fixture.interaction_evaluation_factor[0] = 2;
+
+    let plan = lower_eager_plan_v3(fixture.input()).unwrap();
+
+    assert_eq!(plan.stages().len(), 2);
+    assert_eq!(plan.invocations().len(), 1);
+    assert_eq!(plan.attachments().len(), 1);
+    assert_eq!(plan.finalizations().len(), 2);
+    assert_eq!(plan.invocations()[0].evaluation_group_id, 1);
+    assert_eq!(plan.attachments()[0].interaction_id, 1);
+}
+
+#[test]
+fn malformed_dense_and_cross_table_ids_fail_closed() {
+    let mut dense = Fixture::valid();
+    dense.current_id[2] = 99;
+    assert_invalid(&dense, "current IDs must be dense");
+
+    let mut reference = Fixture::valid();
+    reference.interaction_left[0] = 99;
+    assert_invalid(&reference, "interaction left current ID 99");
+
+    let mut factor = Fixture::valid();
+    factor.interaction_color_factor[0] = 99;
+    assert_invalid(&factor, "color ID 99");
+}
+
+#[test]
+fn malformed_group_partition_and_kernel_permutation_fail_closed() {
+    let mut group = Fixture::valid();
+    group.group_members[1] = 0;
+    assert_invalid(&group, "representative is not its first member");
+
+    let mut order = Fixture::valid();
+    order.interaction_order[0] = [0, 0];
+    assert_invalid(&order, "not a permutation");
+}
+
+#[test]
+fn equivalent_group_members_may_use_different_logical_current_ids() {
+    let input = Fixture::valid().input();
+    let representative = input.interactions[0];
+    let mut equivalent = representative;
+    equivalent.left_current_id = 2;
+    equivalent.right_current_id = 0;
+    validate_group_signature(&representative, &equivalent, 0).unwrap();
+
+    equivalent.kernel_id += 1;
+    equivalent.coupling_id += 1;
+    equivalent.canonical_input_order = [1, 0];
+    validate_group_signature(&representative, &equivalent, 0).unwrap();
+
+    equivalent.stage_subset_size += 1;
+    let error = validate_group_signature(&representative, &equivalent, 0).unwrap_err();
+    assert!(error.to_string().contains("crosses recursion stages"));
+}
+
+#[test]
+fn retained_table_inventory_and_payloads_are_fail_closed_and_bit_exact() {
+    let fixture = Fixture::valid();
+    let retained_value = [-0.0_f64];
+    let retained_columns = [EagerRetainedColumnView {
+        name: "probe",
+        elements_per_row: 1,
+        values: EagerPrimitiveColumnView::F64(&retained_value),
+    }];
+    let mut retained_tables = fixture.retained_views();
+    let metadata_index = EAGER_LOWERING_V1_TABLE_NAMES
+        .iter()
+        .position(|name| *name == "metadata")
+        .unwrap();
+    retained_tables[metadata_index] = EagerRetainedTableView {
+        name: "metadata",
+        row_count: 1,
+        columns: &retained_columns,
+    };
+    let input = EagerLoweringInputV1::try_from_view(fixture.view(&retained_tables)).unwrap();
+    let metadata = input.retained_tables()[metadata_index].clone();
+    assert_eq!(metadata.name(), "metadata");
+    assert_eq!(metadata.row_count(), 1);
+    assert_eq!(metadata.columns()[0].elements_per_row(), 1);
+    assert_eq!(
+        metadata.columns()[0].values(),
+        &EagerOwnedPrimitiveColumn::F64Bits(vec![(-0.0_f64).to_bits()])
+    );
+    let plan = lower_eager_plan_v3(input).unwrap();
+    assert_eq!(plan.retained_tables()[metadata_index], metadata);
+
+    let missing = &retained_tables[..retained_tables.len() - 1];
+    let error = EagerLoweringInputV1::try_from_view(fixture.view(missing)).unwrap_err();
+    assert!(error.to_string().contains("retained table inventory"));
+
+    let unsupported = ["future-proof-table"];
+    let mut view = fixture.view(&retained_tables);
+    view.unsupported_tables = &unsupported;
+    let error = EagerLoweringInputV1::try_from_view(view).unwrap_err();
+    assert!(error.to_string().contains("future-proof-table"));
+}
+
+#[test]
+fn forward_stage_dependency_is_rejected_during_lowering() {
+    let mut fixture = Fixture::valid();
+    fixture.interaction_left[0] = 3;
+    let input = fixture.input();
+    let error = lower_eager_plan_v3(input).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+    assert!(error.to_string().contains("before it is finalized"));
+}
+
+#[test]
+fn structural_zero_requires_an_exact_zero_factor() {
+    let mut fixture = Fixture::valid();
+    fixture.helicity_coefficient[1] = 1;
+    assert_invalid(&fixture, "structural-zero helicity selector");
+}
+
+#[test]
+fn checked_u32_and_u64_overflow_are_rejected() {
+    let error = count_u32(u64::from(u32::MAX) + 1, "string catalog").unwrap_err();
+    assert!(
+        error
+            .to_string()
+            .contains("string catalog count exceeds u32")
+    );
+
+    let mut ranges = Fixture::valid();
+    ranges.bitset_start = vec![0, u64::MAX, 0];
+    ranges.bitset_count = vec![u64::MAX, 1, 1];
+    assert_invalid(&ranges, "bitset catalog range 1 exceeds u64");
+
+    let error = checked_usize_range(u64::MAX, 1, 0, "overflow probe").unwrap_err();
+    assert!(error.to_string().contains("exceeds u64"));
+
+    let error = usize_present_u32(u32::MAX as usize, "selector domain ID").unwrap_err();
+    assert!(error.to_string().contains("missing-ID sentinel"));
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_plan_v3_pacbin.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_plan_v3_pacbin.rs
new file mode 100644
index 0000000000..5fa0b1bac2
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_plan_v3_pacbin.rs
@@ -0,0 +1,1570 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Deterministic, bounded-memory serialization for compact eager plan-v3.
+//!
+//! Every PACBIN member starts with an [`EagerSectionHeader`]. Fixed-width
+//! tables are encoded one row at a time, while string and retained-column
+//! catalogs are streamed from borrowed segments. The serializer therefore
+//! never materializes an aggregate eager runtime payload in memory.
+
+use crate::eager_layout::{
+    EAGER_LOWERING_INPUT_ABI, EAGER_PLAN_ABI, EAGER_RUNTIME_CAPABILITY,
+    EAGER_RUNTIME_CONTAINER_KIND, EAGER_RUNTIME_CONTAINER_SCHEMA, EAGER_RUNTIME_LAYOUT_ABI,
+    EAGER_SECTION_HEADER_SIZE, EagerSectionHeader, EagerSectionKind,
+};
+use crate::eager_lowering_v3::{
+    EagerOwnedPrimitiveColumn, EagerOwnedRetainedTable, EagerPlanAttachmentRow,
+    EagerPlanCatalogRangeRow, EagerPlanClosureRow, EagerPlanColorSelectorRow, EagerPlanCouplingRow,
+    EagerPlanCurrentRow, EagerPlanDirectCoefficientRow, EagerPlanExactFactorRow,
+    EagerPlanFinalizationRow, EagerPlanHelicitySelectorRow, EagerPlanInvocationRow,
+    EagerPlanMomentumRow, EagerPlanParameterRow, EagerPlanReductionEntryRow,
+    EagerPlanReductionGroupRow, EagerPlanSelectorDomainRow, EagerPlanSourceFillRow,
+    EagerPlanStageRow, EagerPlanV3, EagerPlanValueRow,
+};
+use crate::pacbin::{PacbinMemberKind, PacbinWriteMember, PacbinWriteOptions, write_pacbin_atomic};
+use crate::{RusticolError, RusticolResult};
+use sha2::{Digest, Sha256};
+use std::fs::File;
+use std::io::{self, Read};
+use std::path::Path;
+
+const SERIALIZATION_SCHEMA: u32 = 1;
+const METADATA_RECORD_SIZE: u32 = 224;
+const INSPECTION_RECORD_SIZE: u32 = 160;
+const RETAINED_TABLE_RECORD_SIZE: u32 = 40;
+const RETAINED_COLUMN_RECORD_SIZE: u32 = 40;
+const DIRECT_COEFFICIENT_RECORD_SIZE: u32 = 16;
+const HELICITY_SELECTOR_RECORD_SIZE: u32 = 24;
+const COLOR_SELECTOR_RECORD_SIZE: u32 = 24;
+const MAX_ENCODED_RECORD_SIZE: usize = METADATA_RECORD_SIZE as usize;
+const FILE_HASH_BUFFER_SIZE: usize = 1024 * 1024;
+
+const IDENTITY_LOWERING_ABI: u32 = 0;
+const IDENTITY_PLAN_ABI: u32 = 1;
+const IDENTITY_RUNTIME_LAYOUT_ABI: u32 = 2;
+const IDENTITY_RUNTIME_CAPABILITY: u32 = 3;
+const IDENTITY_CONTAINER_KIND: u32 = 4;
+const IDENTITY_PROCESS_KEY: u32 = 5;
+const IDENTITY_MODEL_NAME: u32 = 6;
+
+const RETAINED_U8: u8 = 1;
+const RETAINED_U32: u8 = 2;
+const RETAINED_U64: u8 = 3;
+const RETAINED_I32: u8 = 4;
+const RETAINED_F64_BITS: u8 = 5;
+
+/// Bounded publication metadata returned after the complete container is
+/// atomically installed.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EagerPlanV3PacbinMetadata {
+    pub member_count: u64,
+    pub unpacked_bytes: u64,
+    pub index_sha256: [u8; 32],
+    pub file_size: u64,
+    pub file_sha256: [u8; 32],
+}
+
+/// Atomically write one complete `eager-runtime.pacbin` from an eager plan-v3.
+pub fn write_eager_plan_v3_pacbin(
+    plan: &EagerPlanV3,
+    destination: impl AsRef<Path>,
+) -> RusticolResult<EagerPlanV3PacbinMetadata> {
+    let view = PlanView::from(plan);
+    write_plan_view(&view, destination.as_ref())
+}
+
+#[derive(Clone, Copy)]
+struct PlanView<'a> {
+    abi: &'a str,
+    process_key: &'a str,
+    model_name: &'a str,
+    string_catalog: &'a [Box<str>],
+    canonical_ir_catalog: &'a [Box<str>],
+    semantic_limitations: &'a [Box<str>],
+    retained_tables: &'a [EagerOwnedRetainedTable],
+    currents: &'a [EagerPlanCurrentRow],
+    values: &'a [EagerPlanValueRow],
+    momenta: &'a [EagerPlanMomentumRow],
+    sources: &'a [EagerPlanSourceFillRow],
+    parameters: &'a [EagerPlanParameterRow],
+    stages: &'a [EagerPlanStageRow],
+    couplings: &'a [EagerPlanCouplingRow],
+    invocations: &'a [EagerPlanInvocationRow],
+    attachments: &'a [EagerPlanAttachmentRow],
+    finalizations: &'a [EagerPlanFinalizationRow],
+    closures: &'a [EagerPlanClosureRow],
+    direct_coefficients: &'a [EagerPlanDirectCoefficientRow],
+    selector_domains: &'a [EagerPlanSelectorDomainRow],
+    selector_memberships: &'a [u32],
+    helicity_selectors: &'a [EagerPlanHelicitySelectorRow],
+    color_selectors: &'a [EagerPlanColorSelectorRow],
+    reduction_groups: &'a [EagerPlanReductionGroupRow],
+    reduction_entries: &'a [EagerPlanReductionEntryRow],
+    exact_factors: &'a [EagerPlanExactFactorRow],
+    bitset_ranges: &'a [EagerPlanCatalogRangeRow],
+    bitset_populations: &'a [u64],
+    bitset_words: &'a [u64],
+    u32_sequence_ranges: &'a [EagerPlanCatalogRangeRow],
+    u32_sequence_values: &'a [u32],
+    i32_sequence_ranges: &'a [EagerPlanCatalogRangeRow],
+    i32_sequence_values: &'a [i32],
+    current_component_count: u64,
+    value_component_count: u64,
+    momentum_component_count: u64,
+    color_contraction_entry_start: u64,
+    color_contraction_entry_count: u64,
+}
+
+impl<'a> From<&'a EagerPlanV3> for PlanView<'a> {
+    fn from(plan: &'a EagerPlanV3) -> Self {
+        let (color_contraction_entry_start, color_contraction_entry_count) =
+            plan.color_contraction_entry_range();
+        Self {
+            abi: plan.abi(),
+            process_key: plan.process_key(),
+            model_name: plan.model_name(),
+            string_catalog: plan.string_catalog(),
+            canonical_ir_catalog: plan.canonical_ir_catalog(),
+            semantic_limitations: plan.semantic_limitations(),
+            retained_tables: plan.retained_tables(),
+            currents: plan.currents(),
+            values: plan.values(),
+            momenta: plan.momenta(),
+            sources: plan.sources(),
+            parameters: plan.parameters(),
+            stages: plan.stages(),
+            couplings: plan.couplings(),
+            invocations: plan.invocations(),
+            attachments: plan.attachments(),
+            finalizations: plan.finalizations(),
+            closures: plan.closures(),
+            direct_coefficients: plan.direct_coefficients(),
+            selector_domains: plan.selector_domains(),
+            selector_memberships: plan.selector_memberships(),
+            helicity_selectors: plan.helicity_selectors(),
+            color_selectors: plan.color_selectors(),
+            reduction_groups: plan.reduction_groups(),
+            reduction_entries: plan.reduction_entries(),
+            exact_factors: plan.exact_factors(),
+            bitset_ranges: plan.bitset_ranges(),
+            bitset_populations: plan.bitset_populations(),
+            bitset_words: plan.bitset_words(),
+            u32_sequence_ranges: plan.u32_sequence_ranges(),
+            u32_sequence_values: plan.u32_sequence_values(),
+            i32_sequence_ranges: plan.i32_sequence_ranges(),
+            i32_sequence_values: plan.i32_sequence_values(),
+            current_component_count: plan.current_component_count(),
+            value_component_count: plan.value_component_count(),
+            momentum_component_count: plan.momentum_component_count(),
+            color_contraction_entry_start,
+            color_contraction_entry_count,
+        }
+    }
+}
+
+fn write_plan_view(
+    plan: &PlanView<'_>,
+    destination: &Path,
+) -> RusticolResult<EagerPlanV3PacbinMetadata> {
+    let context = SerializationContext::new(plan)?;
+    let mut sections = context.sections(plan)?;
+    let mut members = Vec::with_capacity(sections.len());
+    for section in &mut sections {
+        members.push(PacbinWriteMember::from_reader(
+            section.logical_path,
+            section.member_kind,
+            &mut section.reader,
+        )?);
+    }
+    let index = write_pacbin_atomic(destination, members, PacbinWriteOptions::default())?;
+    let unpacked_bytes = index.members().iter().try_fold(0_u64, |total, member| {
+        total.checked_add(member.length()).ok_or_else(|| {
+            RusticolError::serialization("eager PACBIN unpacked byte count exceeds u64")
+        })
+    })?;
+    let file_sha256 = hash_file(destination)?;
+    Ok(EagerPlanV3PacbinMetadata {
+        member_count: u64::try_from(index.members().len())
+            .map_err(|_| RusticolError::serialization("eager PACBIN member count exceeds u64"))?,
+        unpacked_bytes,
+        index_sha256: *index.index_sha256(),
+        file_size: index.file_size(),
+        file_sha256,
+    })
+}
+
+fn hash_file(path: &Path) -> RusticolResult<[u8; 32]> {
+    let mut file = File::open(path).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not open published eager PACBIN {} for hashing: {error}",
+            path.display()
+        ))
+    })?;
+    let mut digest = Sha256::new();
+    let mut buffer = vec![0_u8; FILE_HASH_BUFFER_SIZE];
+    loop {
+        let count = file.read(&mut buffer).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not hash published eager PACBIN {}: {error}",
+                path.display()
+            ))
+        })?;
+        if count == 0 {
+            break;
+        }
+        digest.update(&buffer[..count]);
+    }
+    Ok(digest.finalize().into())
+}
+
+struct SerializationContext<'a> {
+    identity: TextCatalog<'a>,
+    strings: TextCatalog<'a>,
+    exact_ir: TextCatalog<'a>,
+    limitations: TextCatalog<'a>,
+    retained: RetainedCatalog<'a>,
+    metadata: MetadataRecord,
+    inspection: InspectionRecord,
+}
+
+impl<'a> SerializationContext<'a> {
+    fn new(plan: &PlanView<'a>) -> RusticolResult<Self> {
+        if plan.abi != EAGER_PLAN_ABI {
+            return Err(RusticolError::compatibility(format!(
+                "cannot serialize unsupported eager plan ABI {:?}",
+                plan.abi
+            )));
+        }
+        let identity = TextCatalog::new([
+            EAGER_LOWERING_INPUT_ABI.as_bytes(),
+            plan.abi.as_bytes(),
+            EAGER_RUNTIME_LAYOUT_ABI.as_bytes(),
+            EAGER_RUNTIME_CAPABILITY.as_bytes(),
+            EAGER_RUNTIME_CONTAINER_KIND.as_bytes(),
+            plan.process_key.as_bytes(),
+            plan.model_name.as_bytes(),
+        ])?;
+        let retained = RetainedCatalog::new(plan.retained_tables)?;
+        let metadata = MetadataRecord::new(plan, &retained)?;
+        let inspection = InspectionRecord::new(plan)?;
+        Ok(Self {
+            identity,
+            strings: TextCatalog::new(plan.string_catalog.iter().map(|value| value.as_bytes()))?,
+            exact_ir: TextCatalog::new(
+                plan.canonical_ir_catalog
+                    .iter()
+                    .map(|value| value.as_bytes()),
+            )?,
+            limitations: TextCatalog::new(
+                plan.semantic_limitations
+                    .iter()
+                    .map(|value| value.as_bytes()),
+            )?,
+            retained,
+            metadata,
+            inspection,
+        })
+    }
+
+    fn sections<'b>(&'b self, plan: &'b PlanView<'a>) -> RusticolResult<Vec<NamedSection<'b>>>
+    where
+        'a: 'b,
+    {
+        let mut sections = Vec::with_capacity(48);
+        push_fixed(
+            &mut sections,
+            "metadata/core.bin",
+            PacbinMemberKind::EagerRuntimeMetadata,
+            EagerSectionKind::Metadata,
+            METADATA_RECORD_SIZE,
+            std::slice::from_ref(&self.metadata),
+            encode_metadata,
+        )?;
+        push_text_catalog(
+            &mut sections,
+            "metadata/identity",
+            EagerSectionKind::Metadata,
+            &self.identity,
+        )?;
+        push_text_catalog(
+            &mut sections,
+            "catalogs/strings",
+            EagerSectionKind::Metadata,
+            &self.strings,
+        )?;
+        push_text_catalog(
+            &mut sections,
+            "catalogs/exact-ir",
+            EagerSectionKind::Metadata,
+            &self.exact_ir,
+        )?;
+        push_text_catalog(
+            &mut sections,
+            "catalogs/semantic-limitations",
+            EagerSectionKind::Metadata,
+            &self.limitations,
+        )?;
+        self.retained.push_sections(&mut sections)?;
+
+        push_fixed_table(
+            &mut sections,
+            "tables/currents.bin",
+            EagerSectionKind::CurrentLayout,
+            EagerPlanCurrentRow::ENCODED_LEN,
+            plan.currents,
+            encode_current,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/values.bin",
+            EagerSectionKind::ValueLayout,
+            EagerPlanValueRow::ENCODED_LEN,
+            plan.values,
+            encode_value,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/momenta.bin",
+            EagerSectionKind::MomentumLayout,
+            EagerPlanMomentumRow::ENCODED_LEN,
+            plan.momenta,
+            encode_momentum,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/sources.bin",
+            EagerSectionKind::SourceFill,
+            EagerPlanSourceFillRow::ENCODED_LEN,
+            plan.sources,
+            encode_source,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/parameters.bin",
+            EagerSectionKind::ParameterLayout,
+            EagerPlanParameterRow::ENCODED_LEN,
+            plan.parameters,
+            encode_parameter,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/stages.bin",
+            EagerSectionKind::Stages,
+            EagerPlanStageRow::ENCODED_LEN,
+            plan.stages,
+            encode_stage,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/couplings.bin",
+            EagerSectionKind::Couplings,
+            EagerPlanCouplingRow::ENCODED_LEN,
+            plan.couplings,
+            encode_coupling,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/invocations.bin",
+            EagerSectionKind::Invocations,
+            EagerPlanInvocationRow::ENCODED_LEN,
+            plan.invocations,
+            encode_invocation,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/attachments.bin",
+            EagerSectionKind::Attachments,
+            EagerPlanAttachmentRow::ENCODED_LEN,
+            plan.attachments,
+            encode_attachment,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/finalizations.bin",
+            EagerSectionKind::Finalizations,
+            EagerPlanFinalizationRow::ENCODED_LEN,
+            plan.finalizations,
+            encode_finalization,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/closures.bin",
+            EagerSectionKind::Closures,
+            EagerPlanClosureRow::ENCODED_LEN,
+            plan.closures,
+            encode_closure,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "tables/direct-coefficients.bin",
+            EagerSectionKind::Closures,
+            DIRECT_COEFFICIENT_RECORD_SIZE,
+            plan.direct_coefficients,
+            encode_direct_coefficient,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "selectors/domains.bin",
+            EagerSectionKind::SelectorDomains,
+            EagerPlanSelectorDomainRow::ENCODED_LEN,
+            plan.selector_domains,
+            encode_selector_domain,
+        )?;
+        push_primitive(
+            &mut sections,
+            "selectors/memberships.bin",
+            EagerSectionKind::SelectorMemberships,
+            plan.selector_memberships,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "selectors/helicities.bin",
+            EagerSectionKind::SelectorDomains,
+            HELICITY_SELECTOR_RECORD_SIZE,
+            plan.helicity_selectors,
+            encode_helicity_selector,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "selectors/colors.bin",
+            EagerSectionKind::SelectorDomains,
+            COLOR_SELECTOR_RECORD_SIZE,
+            plan.color_selectors,
+            encode_color_selector,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "reductions/groups.bin",
+            EagerSectionKind::ReductionGroups,
+            EagerPlanReductionGroupRow::ENCODED_LEN,
+            plan.reduction_groups,
+            encode_reduction_group,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "reductions/entries.bin",
+            EagerSectionKind::ReductionEntries,
+            EagerPlanReductionEntryRow::ENCODED_LEN,
+            plan.reduction_entries,
+            encode_reduction_entry,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "catalogs/exact-factors.bin",
+            EagerSectionKind::ExactFactors,
+            EagerPlanExactFactorRow::ENCODED_LEN,
+            plan.exact_factors,
+            encode_exact_factor,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "catalogs/bitsets/ranges.bin",
+            EagerSectionKind::Metadata,
+            EagerPlanCatalogRangeRow::ENCODED_LEN,
+            plan.bitset_ranges,
+            encode_catalog_range,
+        )?;
+        push_primitive(
+            &mut sections,
+            "catalogs/bitsets/populations.bin",
+            EagerSectionKind::Metadata,
+            plan.bitset_populations,
+        )?;
+        push_primitive(
+            &mut sections,
+            "catalogs/bitsets/words.bin",
+            EagerSectionKind::Metadata,
+            plan.bitset_words,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "catalogs/u32-sequences/ranges.bin",
+            EagerSectionKind::Metadata,
+            EagerPlanCatalogRangeRow::ENCODED_LEN,
+            plan.u32_sequence_ranges,
+            encode_catalog_range,
+        )?;
+        push_primitive(
+            &mut sections,
+            "catalogs/u32-sequences/values.bin",
+            EagerSectionKind::Metadata,
+            plan.u32_sequence_values,
+        )?;
+        push_fixed_table(
+            &mut sections,
+            "catalogs/i32-sequences/ranges.bin",
+            EagerSectionKind::Metadata,
+            EagerPlanCatalogRangeRow::ENCODED_LEN,
+            plan.i32_sequence_ranges,
+            encode_catalog_range,
+        )?;
+        push_primitive(
+            &mut sections,
+            "catalogs/i32-sequences/values.bin",
+            EagerSectionKind::Metadata,
+            plan.i32_sequence_values,
+        )?;
+        push_fixed(
+            &mut sections,
+            "inspection/summary.bin",
+            PacbinMemberKind::EagerRuntimeMetadata,
+            EagerSectionKind::InspectionSummary,
+            INSPECTION_RECORD_SIZE,
+            std::slice::from_ref(&self.inspection),
+            encode_inspection,
+        )?;
+        Ok(sections)
+    }
+}
+
+#[derive(Clone, Copy)]
+struct MetadataRecord {
+    retained_column_count: u64,
+    current_component_count: u64,
+    value_component_count: u64,
+    momentum_component_count: u64,
+    color_contraction_entry_start: u64,
+    color_contraction_entry_count: u64,
+    string_count: u64,
+    exact_ir_count: u64,
+    limitation_count: u64,
+    retained_table_count: u64,
+    current_count: u64,
+    value_count: u64,
+    momentum_count: u64,
+    source_count: u64,
+    stage_count: u64,
+    invocation_count: u64,
+    closure_count: u64,
+    direct_coefficient_count: u64,
+    helicity_selector_count: u64,
+    color_selector_count: u64,
+    exact_factor_count: u64,
+}
+
+impl MetadataRecord {
+    fn new(plan: &PlanView<'_>, retained: &RetainedCatalog<'_>) -> RusticolResult<Self> {
+        Ok(Self {
+            retained_column_count: usize_u64(retained.columns.len(), "retained column count")?,
+            current_component_count: plan.current_component_count,
+            value_component_count: plan.value_component_count,
+            momentum_component_count: plan.momentum_component_count,
+            color_contraction_entry_start: plan.color_contraction_entry_start,
+            color_contraction_entry_count: plan.color_contraction_entry_count,
+            string_count: usize_u64(plan.string_catalog.len(), "string catalog count")?,
+            exact_ir_count: usize_u64(plan.canonical_ir_catalog.len(), "exact IR count")?,
+            limitation_count: usize_u64(
+                plan.semantic_limitations.len(),
+                "semantic limitation count",
+            )?,
+            retained_table_count: usize_u64(plan.retained_tables.len(), "retained table count")?,
+            current_count: usize_u64(plan.currents.len(), "current count")?,
+            value_count: usize_u64(plan.values.len(), "value count")?,
+            momentum_count: usize_u64(plan.momenta.len(), "momentum count")?,
+            source_count: usize_u64(plan.sources.len(), "source count")?,
+            stage_count: usize_u64(plan.stages.len(), "stage count")?,
+            invocation_count: usize_u64(plan.invocations.len(), "invocation count")?,
+            closure_count: usize_u64(plan.closures.len(), "closure count")?,
+            direct_coefficient_count: usize_u64(
+                plan.direct_coefficients.len(),
+                "direct coefficient count",
+            )?,
+            helicity_selector_count: usize_u64(
+                plan.helicity_selectors.len(),
+                "helicity selector count",
+            )?,
+            color_selector_count: usize_u64(plan.color_selectors.len(), "color selector count")?,
+            exact_factor_count: usize_u64(plan.exact_factors.len(), "exact factor count")?,
+        })
+    }
+}
+
+#[derive(Clone, Copy)]
+struct InspectionRecord {
+    counts: [u64; 20],
+}
+
+impl InspectionRecord {
+    fn new(plan: &PlanView<'_>) -> RusticolResult<Self> {
+        Ok(Self {
+            counts: [
+                usize_u64(plan.currents.len(), "inspection current count")?,
+                usize_u64(plan.values.len(), "inspection value count")?,
+                usize_u64(plan.momenta.len(), "inspection momentum count")?,
+                usize_u64(plan.sources.len(), "inspection source count")?,
+                usize_u64(plan.parameters.len(), "inspection parameter count")?,
+                usize_u64(plan.stages.len(), "inspection stage count")?,
+                usize_u64(plan.couplings.len(), "inspection coupling count")?,
+                usize_u64(plan.invocations.len(), "inspection invocation count")?,
+                usize_u64(plan.attachments.len(), "inspection attachment count")?,
+                usize_u64(plan.finalizations.len(), "inspection finalization count")?,
+                usize_u64(plan.closures.len(), "inspection closure count")?,
+                usize_u64(
+                    plan.direct_coefficients.len(),
+                    "inspection direct coefficient count",
+                )?,
+                usize_u64(
+                    plan.selector_domains.len(),
+                    "inspection selector domain count",
+                )?,
+                usize_u64(
+                    plan.selector_memberships.len(),
+                    "inspection selector membership count",
+                )?,
+                usize_u64(
+                    plan.helicity_selectors.len(),
+                    "inspection helicity selector count",
+                )?,
+                usize_u64(
+                    plan.color_selectors.len(),
+                    "inspection color selector count",
+                )?,
+                usize_u64(
+                    plan.reduction_groups.len(),
+                    "inspection reduction group count",
+                )?,
+                usize_u64(
+                    plan.reduction_entries.len(),
+                    "inspection reduction entry count",
+                )?,
+                usize_u64(plan.exact_factors.len(), "inspection exact factor count")?,
+                usize_u64(
+                    plan.retained_tables.len(),
+                    "inspection retained table count",
+                )?,
+            ],
+        })
+    }
+}
+
+struct TextCatalog<'a> {
+    ranges: Vec<EagerPlanCatalogRangeRow>,
+    segments: Vec<&'a [u8]>,
+    byte_count: u64,
+}
+
+impl<'a> TextCatalog<'a> {
+    fn new(values: impl IntoIterator<Item = &'a [u8]>) -> RusticolResult<Self> {
+        let values = values.into_iter();
+        let (minimum, _) = values.size_hint();
+        let mut ranges = Vec::with_capacity(minimum);
+        let mut segments = Vec::with_capacity(minimum);
+        let mut byte_count = 0_u64;
+        for value in values {
+            let count = usize_u64(value.len(), "text catalog entry length")?;
+            ranges.push(EagerPlanCatalogRangeRow {
+                start: byte_count,
+                count,
+            });
+            byte_count = byte_count.checked_add(count).ok_or_else(|| {
+                RusticolError::serialization("text catalog byte count exceeds u64")
+            })?;
+            segments.push(value);
+        }
+        Ok(Self {
+            ranges,
+            segments,
+            byte_count,
+        })
+    }
+}
+
+#[derive(Clone, Copy)]
+struct RetainedTableRecord {
+    table_id: u32,
+    name_id: u32,
+    row_count: u64,
+    column_start: u64,
+    column_count: u64,
+}
+
+#[derive(Clone, Copy)]
+struct RetainedColumnRecord {
+    table_id: u32,
+    column_id: u32,
+    name_id: u32,
+    primitive_kind: u8,
+    elements_per_row: u32,
+    value_start: u64,
+    value_count: u64,
+}
+
+struct RetainedCatalog<'a> {
+    names: TextCatalog<'a>,
+    tables: Vec<RetainedTableRecord>,
+    columns: Vec<RetainedColumnRecord>,
+    u8_segments: Vec<&'a [u8]>,
+    u32_segments: Vec<&'a [u32]>,
+    u64_segments: Vec<&'a [u64]>,
+    i32_segments: Vec<&'a [i32]>,
+    f64_bits_segments: Vec<&'a [u64]>,
+    u8_count: u64,
+    u32_count: u64,
+    u64_count: u64,
+    i32_count: u64,
+    f64_bits_count: u64,
+}
+
+impl<'a> RetainedCatalog<'a> {
+    fn new(tables: &'a [EagerOwnedRetainedTable]) -> RusticolResult<Self> {
+        let column_capacity = tables.iter().try_fold(0_usize, |total, table| {
+            total
+                .checked_add(table.columns().len())
+                .ok_or_else(|| RusticolError::serialization("retained column count exceeds usize"))
+        })?;
+        let names = TextCatalog::new(tables.iter().flat_map(|table| {
+            std::iter::once(table.name().as_bytes()).chain(
+                table
+                    .columns()
+                    .iter()
+                    .map(|column| column.name().as_bytes()),
+            )
+        }))?;
+        let mut records = Vec::with_capacity(tables.len());
+        let mut columns = Vec::with_capacity(column_capacity);
+        let mut u8_segments = Vec::new();
+        let mut u32_segments = Vec::new();
+        let mut u64_segments = Vec::new();
+        let mut i32_segments = Vec::new();
+        let mut f64_bits_segments = Vec::new();
+        let mut name_id = 0_u32;
+        let mut u8_count = 0_u64;
+        let mut u32_count = 0_u64;
+        let mut u64_count = 0_u64;
+        let mut i32_count = 0_u64;
+        let mut f64_bits_count = 0_u64;
+        for (table_index, table) in tables.iter().enumerate() {
+            let table_id = usize_u32(table_index, "retained table ID")?;
+            let column_start = usize_u64(columns.len(), "retained column start")?;
+            let table_name_id = name_id;
+            name_id = name_id
+                .checked_add(1)
+                .ok_or_else(|| RusticolError::serialization("retained name count exceeds u32"))?;
+            for (column_index, column) in table.columns().iter().enumerate() {
+                let column_id = usize_u32(column_index, "retained column ID")?;
+                let column_name_id = name_id;
+                name_id = name_id.checked_add(1).ok_or_else(|| {
+                    RusticolError::serialization("retained name count exceeds u32")
+                })?;
+                let (primitive_kind, value_start, value_count) = match column.values() {
+                    EagerOwnedPrimitiveColumn::U8(values) => {
+                        append_segment(&mut u8_segments, &mut u8_count, values, RETAINED_U8)?
+                    }
+                    EagerOwnedPrimitiveColumn::U32(values) => {
+                        append_segment(&mut u32_segments, &mut u32_count, values, RETAINED_U32)?
+                    }
+                    EagerOwnedPrimitiveColumn::U64(values) => {
+                        append_segment(&mut u64_segments, &mut u64_count, values, RETAINED_U64)?
+                    }
+                    EagerOwnedPrimitiveColumn::I32(values) => {
+                        append_segment(&mut i32_segments, &mut i32_count, values, RETAINED_I32)?
+                    }
+                    EagerOwnedPrimitiveColumn::F64Bits(values) => append_segment(
+                        &mut f64_bits_segments,
+                        &mut f64_bits_count,
+                        values,
+                        RETAINED_F64_BITS,
+                    )?,
+                };
+                columns.push(RetainedColumnRecord {
+                    table_id,
+                    column_id,
+                    name_id: column_name_id,
+                    primitive_kind,
+                    elements_per_row: column.elements_per_row(),
+                    value_start,
+                    value_count,
+                });
+            }
+            records.push(RetainedTableRecord {
+                table_id,
+                name_id: table_name_id,
+                row_count: table.row_count(),
+                column_start,
+                column_count: usize_u64(table.columns().len(), "retained table column count")?,
+            });
+        }
+        Ok(Self {
+            names,
+            tables: records,
+            columns,
+            u8_segments,
+            u32_segments,
+            u64_segments,
+            i32_segments,
+            f64_bits_segments,
+            u8_count,
+            u32_count,
+            u64_count,
+            i32_count,
+            f64_bits_count,
+        })
+    }
+
+    fn push_sections<'b>(&'b self, sections: &mut Vec<NamedSection<'b>>) -> RusticolResult<()> {
+        push_text_catalog(
+            sections,
+            "retained/names",
+            EagerSectionKind::Metadata,
+            &self.names,
+        )?;
+        push_fixed_table(
+            sections,
+            "retained/tables.bin",
+            EagerSectionKind::Metadata,
+            RETAINED_TABLE_RECORD_SIZE,
+            &self.tables,
+            encode_retained_table,
+        )?;
+        push_fixed_table(
+            sections,
+            "retained/columns.bin",
+            EagerSectionKind::Metadata,
+            RETAINED_COLUMN_RECORD_SIZE,
+            &self.columns,
+            encode_retained_column,
+        )?;
+        push_segmented_primitive(
+            sections,
+            "retained/values-u8.bin",
+            EagerSectionKind::Metadata,
+            &self.u8_segments,
+            self.u8_count,
+        )?;
+        push_segmented_primitive(
+            sections,
+            "retained/values-u32.bin",
+            EagerSectionKind::Metadata,
+            &self.u32_segments,
+            self.u32_count,
+        )?;
+        push_segmented_primitive(
+            sections,
+            "retained/values-u64.bin",
+            EagerSectionKind::Metadata,
+            &self.u64_segments,
+            self.u64_count,
+        )?;
+        push_segmented_primitive(
+            sections,
+            "retained/values-i32.bin",
+            EagerSectionKind::Metadata,
+            &self.i32_segments,
+            self.i32_count,
+        )?;
+        push_segmented_primitive(
+            sections,
+            "retained/values-f64-bits.bin",
+            EagerSectionKind::Metadata,
+            &self.f64_bits_segments,
+            self.f64_bits_count,
+        )?;
+        Ok(())
+    }
+}
+
+fn append_segment<'a, T>(
+    segments: &mut Vec<&'a [T]>,
+    total: &mut u64,
+    values: &'a [T],
+    primitive_kind: u8,
+) -> RusticolResult<(u8, u64, u64)> {
+    let start = *total;
+    let count = usize_u64(values.len(), "retained value count")?;
+    *total = total
+        .checked_add(count)
+        .ok_or_else(|| RusticolError::serialization("retained value count exceeds u64"))?;
+    segments.push(values);
+    Ok((primitive_kind, start, count))
+}
+
+fn usize_u64(value: usize, description: &str) -> RusticolResult<u64> {
+    u64::try_from(value)
+        .map_err(|_| RusticolError::serialization(format!("{description} exceeds u64")))
+}
+
+fn usize_u32(value: usize, description: &str) -> RusticolResult<u32> {
+    u32::try_from(value)
+        .map_err(|_| RusticolError::serialization(format!("{description} exceeds u32")))
+}
+
+struct NamedSection<'a> {
+    logical_path: &'static str,
+    member_kind: PacbinMemberKind,
+    reader: EagerSectionStream<'a>,
+}
+
+struct EagerSectionStream<'a> {
+    header: [u8; EAGER_SECTION_HEADER_SIZE],
+    header_position: usize,
+    payload: Box<dyn Read + 'a>,
+    payload_remaining: u64,
+}
+
+impl<'a> EagerSectionStream<'a> {
+    fn new(
+        kind: EagerSectionKind,
+        record_size: u32,
+        record_count: u64,
+        payload: impl Read + 'a,
+    ) -> RusticolResult<Self> {
+        let header = EagerSectionHeader::new(kind, record_size, record_count)?;
+        Ok(Self {
+            header: header.encode(),
+            header_position: 0,
+            payload: Box::new(payload),
+            payload_remaining: header.payload_length(),
+        })
+    }
+}
+
+impl Read for EagerSectionStream<'_> {
+    fn read(&mut self, output: &mut [u8]) -> io::Result<usize> {
+        if output.is_empty() {
+            return Ok(0);
+        }
+        let mut written = 0;
+        if self.header_position < self.header.len() {
+            let count = (self.header.len() - self.header_position).min(output.len());
+            output[..count]
+                .copy_from_slice(&self.header[self.header_position..self.header_position + count]);
+            self.header_position += count;
+            written += count;
+        }
+        if written == output.len() || self.payload_remaining == 0 {
+            return Ok(written);
+        }
+        let maximum = usize::try_from(self.payload_remaining)
+            .unwrap_or(usize::MAX)
+            .min(output.len() - written);
+        let count = self.payload.read(&mut output[written..written + maximum])?;
+        if count == 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::UnexpectedEof,
+                "eager section payload ended before its declared length",
+            ));
+        }
+        let count_u64 = u64::try_from(count)
+            .map_err(|_| io::Error::other("eager section read count exceeds u64"))?;
+        self.payload_remaining -= count_u64;
+        written += count;
+        Ok(written)
+    }
+}
+
+struct FixedRowsReader<'a, T> {
+    rows: &'a [T],
+    record_size: usize,
+    total_bytes: u64,
+    byte_position: u64,
+    encoder: fn(&T, &mut [u8]),
+    scratch: [u8; MAX_ENCODED_RECORD_SIZE],
+}
+
+impl<'a, T> FixedRowsReader<'a, T> {
+    fn new(rows: &'a [T], record_size: u32, encoder: fn(&T, &mut [u8])) -> RusticolResult<Self> {
+        let record_size_u64 = u64::from(record_size);
+        let record_size = usize::try_from(record_size).map_err(|_| {
+            RusticolError::serialization("eager record size exceeds platform usize")
+        })?;
+        if record_size == 0 || record_size > MAX_ENCODED_RECORD_SIZE {
+            return Err(RusticolError::serialization(format!(
+                "eager record size {record_size} exceeds streaming scratch bound {MAX_ENCODED_RECORD_SIZE}"
+            )));
+        }
+        let row_count = usize_u64(rows.len(), "fixed eager table row count")?;
+        let total_bytes = row_count
+            .checked_mul(record_size_u64)
+            .ok_or_else(|| RusticolError::serialization("fixed eager table size exceeds u64"))?;
+        Ok(Self {
+            rows,
+            record_size,
+            total_bytes,
+            byte_position: 0,
+            encoder,
+            scratch: [0; MAX_ENCODED_RECORD_SIZE],
+        })
+    }
+}
+
+impl<T> Read for FixedRowsReader<'_, T> {
+    fn read(&mut self, output: &mut [u8]) -> io::Result<usize> {
+        if self.byte_position >= self.total_bytes || output.is_empty() {
+            return Ok(0);
+        }
+        let mut written = 0;
+        while written < output.len() && self.byte_position < self.total_bytes {
+            let record_size_u64 = u64::try_from(self.record_size)
+                .map_err(|_| io::Error::other("eager record size exceeds u64"))?;
+            let row_index = usize::try_from(self.byte_position / record_size_u64)
+                .map_err(|_| io::Error::other("eager row index exceeds usize"))?;
+            let row_offset = usize::try_from(self.byte_position % record_size_u64)
+                .map_err(|_| io::Error::other("eager row offset exceeds usize"))?;
+            self.scratch[..self.record_size].fill(0);
+            (self.encoder)(&self.rows[row_index], &mut self.scratch[..self.record_size]);
+            let count = (self.record_size - row_offset).min(output.len() - written);
+            output[written..written + count]
+                .copy_from_slice(&self.scratch[row_offset..row_offset + count]);
+            written += count;
+            self.byte_position = self
+                .byte_position
+                .checked_add(
+                    u64::try_from(count)
+                        .map_err(|_| io::Error::other("eager read count exceeds u64"))?,
+                )
+                .ok_or_else(|| io::Error::other("eager byte position exceeds u64"))?;
+        }
+        Ok(written)
+    }
+}
+
+trait LittleEndianPrimitive: Copy {
+    const ENCODED_LEN: u32;
+    fn encode(self, output: &mut [u8]);
+}
+
+impl LittleEndianPrimitive for u8 {
+    const ENCODED_LEN: u32 = 1;
+
+    fn encode(self, output: &mut [u8]) {
+        output[0] = self;
+    }
+}
+
+impl LittleEndianPrimitive for u32 {
+    const ENCODED_LEN: u32 = 4;
+
+    fn encode(self, output: &mut [u8]) {
+        output.copy_from_slice(&self.to_le_bytes());
+    }
+}
+
+impl LittleEndianPrimitive for i32 {
+    const ENCODED_LEN: u32 = 4;
+
+    fn encode(self, output: &mut [u8]) {
+        output.copy_from_slice(&self.to_le_bytes());
+    }
+}
+
+impl LittleEndianPrimitive for u64 {
+    const ENCODED_LEN: u32 = 8;
+
+    fn encode(self, output: &mut [u8]) {
+        output.copy_from_slice(&self.to_le_bytes());
+    }
+}
+
+struct SegmentedPrimitiveReader<'a, T> {
+    segments: &'a [&'a [T]],
+    segment_index: usize,
+    value_index: usize,
+    pending: [u8; 8],
+    pending_position: usize,
+    pending_length: usize,
+}
+
+impl<'a, T> SegmentedPrimitiveReader<'a, T> {
+    fn new(segments: &'a [&'a [T]]) -> Self {
+        Self {
+            segments,
+            segment_index: 0,
+            value_index: 0,
+            pending: [0; 8],
+            pending_position: 0,
+            pending_length: 0,
+        }
+    }
+}
+
+impl<T: LittleEndianPrimitive> Read for SegmentedPrimitiveReader<'_, T> {
+    fn read(&mut self, output: &mut [u8]) -> io::Result<usize> {
+        if output.is_empty() {
+            return Ok(0);
+        }
+        let mut written = 0;
+        while written < output.len() {
+            if self.pending_position < self.pending_length {
+                let count =
+                    (self.pending_length - self.pending_position).min(output.len() - written);
+                output[written..written + count].copy_from_slice(
+                    &self.pending[self.pending_position..self.pending_position + count],
+                );
+                self.pending_position += count;
+                written += count;
+                continue;
+            }
+            while self.segment_index < self.segments.len()
+                && self.value_index == self.segments[self.segment_index].len()
+            {
+                self.segment_index += 1;
+                self.value_index = 0;
+            }
+            if self.segment_index == self.segments.len() {
+                break;
+            }
+            self.pending.fill(0);
+            let value = self.segments[self.segment_index][self.value_index];
+            value.encode(&mut self.pending[..T::ENCODED_LEN as usize]);
+            self.pending_position = 0;
+            self.pending_length = T::ENCODED_LEN as usize;
+            self.value_index += 1;
+        }
+        Ok(written)
+    }
+}
+
+fn push_fixed_table<'a, T>(
+    sections: &mut Vec<NamedSection<'a>>,
+    logical_path: &'static str,
+    section_kind: EagerSectionKind,
+    record_size: u32,
+    rows: &'a [T],
+    encoder: fn(&T, &mut [u8]),
+) -> RusticolResult<()> {
+    push_fixed(
+        sections,
+        logical_path,
+        PacbinMemberKind::EagerRuntimeTable,
+        section_kind,
+        record_size,
+        rows,
+        encoder,
+    )
+}
+
+fn push_fixed<'a, T>(
+    sections: &mut Vec<NamedSection<'a>>,
+    logical_path: &'static str,
+    member_kind: PacbinMemberKind,
+    section_kind: EagerSectionKind,
+    record_size: u32,
+    rows: &'a [T],
+    encoder: fn(&T, &mut [u8]),
+) -> RusticolResult<()> {
+    let count = usize_u64(rows.len(), "eager section row count")?;
+    sections.push(NamedSection {
+        logical_path,
+        member_kind,
+        reader: EagerSectionStream::new(
+            section_kind,
+            record_size,
+            count,
+            FixedRowsReader::new(rows, record_size, encoder)?,
+        )?,
+    });
+    Ok(())
+}
+
+fn push_primitive<'a, T: LittleEndianPrimitive + 'a>(
+    sections: &mut Vec<NamedSection<'a>>,
+    logical_path: &'static str,
+    section_kind: EagerSectionKind,
+    values: &'a [T],
+) -> RusticolResult<()> {
+    push_fixed(
+        sections,
+        logical_path,
+        PacbinMemberKind::EagerRuntimeTable,
+        section_kind,
+        T::ENCODED_LEN,
+        values,
+        encode_primitive::<T>,
+    )
+}
+
+fn encode_primitive<T: LittleEndianPrimitive>(value: &T, output: &mut [u8]) {
+    value.encode(output);
+}
+
+fn push_segmented_primitive<'a, T: LittleEndianPrimitive + 'a>(
+    sections: &mut Vec<NamedSection<'a>>,
+    logical_path: &'static str,
+    section_kind: EagerSectionKind,
+    segments: &'a [&'a [T]],
+    count: u64,
+) -> RusticolResult<()> {
+    let actual_count = segments.iter().try_fold(0_u64, |total, values| {
+        total
+            .checked_add(usize_u64(values.len(), "segmented primitive count")?)
+            .ok_or_else(|| RusticolError::serialization("segmented primitive count exceeds u64"))
+    })?;
+    if actual_count != count {
+        return Err(RusticolError::serialization(format!(
+            "segmented primitive count mismatch: declared {count}, encoded {actual_count}"
+        )));
+    }
+    sections.push(NamedSection {
+        logical_path,
+        member_kind: PacbinMemberKind::EagerRuntimeTable,
+        reader: EagerSectionStream::new(
+            section_kind,
+            T::ENCODED_LEN,
+            count,
+            SegmentedPrimitiveReader::new(segments),
+        )?,
+    });
+    Ok(())
+}
+
+fn push_text_catalog<'a>(
+    sections: &mut Vec<NamedSection<'a>>,
+    prefix: &'static str,
+    section_kind: EagerSectionKind,
+    catalog: &'a TextCatalog<'a>,
+) -> RusticolResult<()> {
+    let (ranges_path, bytes_path) = match prefix {
+        "metadata/identity" => (
+            "metadata/identity-ranges.bin",
+            "metadata/identity-bytes.bin",
+        ),
+        "catalogs/strings" => ("catalogs/strings/ranges.bin", "catalogs/strings/bytes.bin"),
+        "catalogs/exact-ir" => (
+            "catalogs/exact-ir/ranges.bin",
+            "catalogs/exact-ir/bytes.bin",
+        ),
+        "catalogs/semantic-limitations" => (
+            "catalogs/semantic-limitations/ranges.bin",
+            "catalogs/semantic-limitations/bytes.bin",
+        ),
+        "retained/names" => ("retained/name-ranges.bin", "retained/name-bytes.bin"),
+        _ => {
+            return Err(RusticolError::internal(format!(
+                "unknown eager text catalog prefix: {prefix}"
+            )));
+        }
+    };
+    push_fixed(
+        sections,
+        ranges_path,
+        PacbinMemberKind::EagerRuntimeMetadata,
+        section_kind,
+        EagerPlanCatalogRangeRow::ENCODED_LEN,
+        &catalog.ranges,
+        encode_catalog_range,
+    )?;
+    sections.push(NamedSection {
+        logical_path: bytes_path,
+        member_kind: PacbinMemberKind::EagerRuntimeMetadata,
+        reader: EagerSectionStream::new(
+            section_kind,
+            1,
+            catalog.byte_count,
+            SegmentedPrimitiveReader::new(&catalog.segments),
+        )?,
+    });
+    Ok(())
+}
+
+fn encode_metadata(row: &MetadataRecord, output: &mut [u8]) {
+    put_u32(output, 0, SERIALIZATION_SCHEMA);
+    put_u16(output, 4, EAGER_RUNTIME_CONTAINER_SCHEMA);
+    put_u32(output, 8, IDENTITY_LOWERING_ABI);
+    put_u32(output, 12, IDENTITY_PLAN_ABI);
+    put_u32(output, 16, IDENTITY_RUNTIME_LAYOUT_ABI);
+    put_u32(output, 20, IDENTITY_RUNTIME_CAPABILITY);
+    put_u32(output, 24, IDENTITY_CONTAINER_KIND);
+    put_u32(output, 28, IDENTITY_PROCESS_KEY);
+    put_u32(output, 32, IDENTITY_MODEL_NAME);
+    put_u32(output, 36, 7);
+    let values = [
+        row.retained_column_count,
+        row.current_component_count,
+        row.value_component_count,
+        row.momentum_component_count,
+        row.color_contraction_entry_start,
+        row.color_contraction_entry_count,
+        row.string_count,
+        row.exact_ir_count,
+        row.limitation_count,
+        row.retained_table_count,
+        row.current_count,
+        row.value_count,
+        row.momentum_count,
+        row.source_count,
+        row.stage_count,
+        row.invocation_count,
+        row.closure_count,
+        row.direct_coefficient_count,
+        row.helicity_selector_count,
+        row.color_selector_count,
+        row.exact_factor_count,
+    ];
+    for (index, value) in values.into_iter().enumerate() {
+        put_u64(output, 40 + index * 8, value);
+    }
+}
+
+fn encode_inspection(row: &InspectionRecord, output: &mut [u8]) {
+    for (index, value) in row.counts.into_iter().enumerate() {
+        put_u64(output, index * 8, value);
+    }
+}
+
+fn encode_retained_table(row: &RetainedTableRecord, output: &mut [u8]) {
+    put_u32(output, 0, row.table_id);
+    put_u32(output, 4, row.name_id);
+    put_u64(output, 8, row.row_count);
+    put_u64(output, 16, row.column_start);
+    put_u64(output, 24, row.column_count);
+}
+
+fn encode_retained_column(row: &RetainedColumnRecord, output: &mut [u8]) {
+    put_u32(output, 0, row.table_id);
+    put_u32(output, 4, row.column_id);
+    put_u32(output, 8, row.name_id);
+    put_u8(output, 12, row.primitive_kind);
+    put_u32(output, 16, row.elements_per_row);
+    put_u64(output, 24, row.value_start);
+    put_u64(output, 32, row.value_count);
+}
+
+fn encode_current(row: &EagerPlanCurrentRow, output: &mut [u8]) {
+    put_u32(output, 0, row.current_id);
+    put_u64(output, 4, row.component_start);
+    put_u32(output, 12, row.component_count);
+    put_u32(output, 16, row.momentum_slot_id);
+    put_u32(output, 20, row.flags);
+}
+
+fn encode_value(row: &EagerPlanValueRow, output: &mut [u8]) {
+    put_u32(output, 0, row.value_slot_id);
+    put_u32(output, 4, row.current_id);
+    put_u64(output, 8, row.component_start);
+    put_u32(output, 16, row.component_count);
+    put_u8(output, 20, row.kind as u8);
+}
+
+fn encode_momentum(row: &EagerPlanMomentumRow, output: &mut [u8]) {
+    put_u32(output, 0, row.momentum_slot_id);
+    put_u32(output, 4, row.bitset_id);
+    put_u64(output, 8, row.component_start);
+    put_u32(output, 16, row.component_count);
+}
+
+fn encode_source(row: &EagerPlanSourceFillRow, output: &mut [u8]) {
+    let values = [
+        row.source_id,
+        row.current_id,
+        row.value_slot_id,
+        row.external_label,
+        row.input_momentum_slot,
+        row.source_ir_id,
+        row.crossing_ir_id,
+        row.crossing_factor_id,
+        row.declared_state_index,
+    ];
+    put_u32_values(output, &values);
+}
+
+fn encode_parameter(row: &EagerPlanParameterRow, output: &mut [u8]) {
+    put_u32(output, 0, row.parameter_id);
+    put_u32(output, 4, row.name_string_id);
+    put_u32(output, 8, row.kind_string_id);
+    put_u32(output, 12, row.default_factor_id);
+    put_u32(output, 16, row.runtime_name_string_id);
+    put_i32(output, 20, row.complex_component);
+    put_u32(output, 24, row.flags);
+}
+
+fn encode_stage(row: &EagerPlanStageRow, output: &mut [u8]) {
+    put_u32(output, 0, row.stage_index);
+    put_u32(output, 4, row.subset_size);
+    let values = [
+        row.invocation_start,
+        row.invocation_count,
+        row.attachment_start,
+        row.attachment_count,
+        row.finalization_start,
+        row.finalization_count,
+    ];
+    for (index, value) in values.into_iter().enumerate() {
+        put_u64(output, 8 + index * 8, value);
+    }
+}
+
+fn encode_coupling(row: &EagerPlanCouplingRow, output: &mut [u8]) {
+    put_u32_values(
+        output,
+        &[
+            row.coupling_id,
+            row.real_parameter_id,
+            row.imaginary_parameter_id,
+            row.constant_factor_id,
+        ],
+    );
+}
+
+fn encode_invocation(row: &EagerPlanInvocationRow, output: &mut [u8]) {
+    put_u32_values(
+        output,
+        &[
+            row.evaluation_group_id,
+            row.kernel_id,
+            row.left_value_slot_id,
+            row.right_value_slot_id,
+            row.left_momentum_slot_id,
+            row.right_momentum_slot_id,
+            row.coupling_slot_id,
+        ],
+    );
+    put_u8(output, 28, row.output_factor_source);
+    put_u64(output, 32, row.attachment_start);
+    put_u64(output, 40, row.attachment_count);
+    put_u32(output, 48, row.selector_domain_id);
+}
+
+fn encode_attachment(row: &EagerPlanAttachmentRow, output: &mut [u8]) {
+    put_u32_values(
+        output,
+        &[
+            row.interaction_id,
+            row.result_current_id,
+            row.color_factor_id,
+            row.evaluation_factor_id,
+            row.normalization_factor_id,
+            row.representative_evaluation_factor_id,
+            row.selector_domain_id,
+        ],
+    );
+}
+
+fn encode_finalization(row: &EagerPlanFinalizationRow, output: &mut [u8]) {
+    put_u32_values(
+        output,
+        &[
+            row.kernel_id,
+            row.current_id,
+            row.unpropagated_value_slot_id,
+            row.propagated_value_slot_id,
+            row.momentum_slot_id,
+            row.unpropagated_selector_domain_id,
+            row.propagated_selector_domain_id,
+        ],
+    );
+}
+
+fn encode_closure(row: &EagerPlanClosureRow, output: &mut [u8]) {
+    put_u32_values(
+        output,
+        &[
+            row.root_id,
+            row.kernel_id,
+            row.left_value_slot_id,
+            row.right_value_slot_id,
+            row.amplitude_index,
+            row.coherent_group_id,
+            row.coupling_slot_id,
+            row.coupling_factor_id,
+        ],
+    );
+    put_u8(output, 32, row.output_factor_source);
+    put_u32(output, 36, row.color_factor_id);
+    put_u32(output, 40, row.normalization_factor_id);
+    put_u64(output, 44, row.direct_coefficient_start);
+    put_u64(output, 52, row.direct_coefficient_count);
+    put_u32(output, 60, row.selector_domain_id);
+}
+
+fn encode_direct_coefficient(row: &EagerPlanDirectCoefficientRow, output: &mut [u8]) {
+    put_u32_values(
+        output,
+        &[row.contraction_ir_id, row.component_index, row.factor_id],
+    );
+}
+
+fn encode_selector_domain(row: &EagerPlanSelectorDomainRow, output: &mut [u8]) {
+    put_u64(output, 0, row.member_start);
+    put_u64(output, 8, row.member_count);
+}
+
+fn encode_helicity_selector(row: &EagerPlanHelicitySelectorRow, output: &mut [u8]) {
+    put_u32_values(
+        output,
+        &[
+            row.selector_id,
+            row.values_sequence_id,
+            row.representative_sequence_id,
+            row.coefficient_factor_id,
+        ],
+    );
+    put_u8(output, 16, row.computed);
+    put_u8(output, 17, row.structural_zero);
+}
+
+fn encode_color_selector(row: &EagerPlanColorSelectorRow, output: &mut [u8]) {
+    put_u32_values(
+        output,
+        &[
+            row.selector_id,
+            row.word_sequence_id,
+            row.representative_word_sequence_id,
+            row.coefficient_factor_id,
+        ],
+    );
+    put_u8(output, 16, row.computed);
+}
+
+fn encode_reduction_group(row: &EagerPlanReductionGroupRow, output: &mut [u8]) {
+    put_u32(output, 0, row.coherent_group_id);
+    put_u64(output, 8, row.amplitude_entry_start);
+    put_u64(output, 16, row.amplitude_entry_count);
+    put_u64(output, 24, row.selector_entry_start);
+    put_u64(output, 32, row.selector_entry_count);
+    put_u32(output, 40, row.helicity_weight_factor_id);
+    put_u32(output, 44, row.all_sector_weight_factor_id);
+}
+
+fn encode_reduction_entry(row: &EagerPlanReductionEntryRow, output: &mut [u8]) {
+    put_u8(output, 0, row.kind as u8);
+    put_u32(output, 4, row.owner_id);
+    put_u32(output, 8, row.left_id);
+    put_u32(output, 12, row.right_id);
+    put_u32(output, 16, row.factor_id);
+    put_u32(output, 20, row.auxiliary_factor_id);
+}
+
+fn encode_exact_factor(row: &EagerPlanExactFactorRow, output: &mut [u8]) {
+    put_u32(output, 0, row.factor_id);
+    put_u64(output, 8, row.real_bits);
+    put_u64(output, 16, row.imaginary_bits);
+    put_u32(output, 24, row.canonical_string_id);
+    put_u8(output, 28, row.exact_source);
+    put_u32(output, 32, row.exact_ir_id);
+    put_u32(output, 36, row.source_ir_id);
+}
+
+fn encode_catalog_range(row: &EagerPlanCatalogRangeRow, output: &mut [u8]) {
+    put_u64(output, 0, row.start);
+    put_u64(output, 8, row.count);
+}
+
+fn put_u32_values(output: &mut [u8], values: &[u32]) {
+    for (index, value) in values.iter().copied().enumerate() {
+        put_u32(output, index * 4, value);
+    }
+}
+
+fn put_u8(output: &mut [u8], offset: usize, value: u8) {
+    output[offset] = value;
+}
+
+fn put_u16(output: &mut [u8], offset: usize, value: u16) {
+    output[offset..offset + 2].copy_from_slice(&value.to_le_bytes());
+}
+
+fn put_u32(output: &mut [u8], offset: usize, value: u32) {
+    output[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
+}
+
+fn put_i32(output: &mut [u8], offset: usize, value: i32) {
+    output[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
+}
+
+fn put_u64(output: &mut [u8], offset: usize, value: u64) {
+    output[offset..offset + 8].copy_from_slice(&value.to_le_bytes());
+}
+
+#[cfg(test)]
+#[path = "eager_plan_v3_pacbin_tests.rs"]
+mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_plan_v3_pacbin_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_plan_v3_pacbin_tests.rs
new file mode 100644
index 0000000000..1e9d22319b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_plan_v3_pacbin_tests.rs
@@ -0,0 +1,522 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::RusticolErrorKind;
+use crate::eager_lowering_v3::{EagerPlanReductionEntryKind, EagerValueSlotKind};
+use crate::pacbin::PacbinReader;
+use std::fs;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+static NEXT_DIRECTORY: AtomicU64 = AtomicU64::new(0);
+
+const EXPECTED_MEMBERS: &[&str] = &[
+    "catalogs/bitsets/populations.bin",
+    "catalogs/bitsets/ranges.bin",
+    "catalogs/bitsets/words.bin",
+    "catalogs/exact-factors.bin",
+    "catalogs/exact-ir/bytes.bin",
+    "catalogs/exact-ir/ranges.bin",
+    "catalogs/i32-sequences/ranges.bin",
+    "catalogs/i32-sequences/values.bin",
+    "catalogs/semantic-limitations/bytes.bin",
+    "catalogs/semantic-limitations/ranges.bin",
+    "catalogs/strings/bytes.bin",
+    "catalogs/strings/ranges.bin",
+    "catalogs/u32-sequences/ranges.bin",
+    "catalogs/u32-sequences/values.bin",
+    "inspection/summary.bin",
+    "metadata/core.bin",
+    "metadata/identity-bytes.bin",
+    "metadata/identity-ranges.bin",
+    "reductions/entries.bin",
+    "reductions/groups.bin",
+    "retained/columns.bin",
+    "retained/name-bytes.bin",
+    "retained/name-ranges.bin",
+    "retained/tables.bin",
+    "retained/values-f64-bits.bin",
+    "retained/values-i32.bin",
+    "retained/values-u32.bin",
+    "retained/values-u64.bin",
+    "retained/values-u8.bin",
+    "selectors/colors.bin",
+    "selectors/domains.bin",
+    "selectors/helicities.bin",
+    "selectors/memberships.bin",
+    "tables/attachments.bin",
+    "tables/closures.bin",
+    "tables/couplings.bin",
+    "tables/currents.bin",
+    "tables/direct-coefficients.bin",
+    "tables/finalizations.bin",
+    "tables/invocations.bin",
+    "tables/momenta.bin",
+    "tables/parameters.bin",
+    "tables/sources.bin",
+    "tables/stages.bin",
+    "tables/values.bin",
+];
+
+struct Fixture {
+    strings: Vec<Box<str>>,
+    exact_ir: Vec<Box<str>>,
+    limitations: Vec<Box<str>>,
+    retained: Vec<EagerOwnedRetainedTable>,
+    currents: Vec<EagerPlanCurrentRow>,
+    values: Vec<EagerPlanValueRow>,
+    momenta: Vec<EagerPlanMomentumRow>,
+    sources: Vec<EagerPlanSourceFillRow>,
+    parameters: Vec<EagerPlanParameterRow>,
+    stages: Vec<EagerPlanStageRow>,
+    couplings: Vec<EagerPlanCouplingRow>,
+    invocations: Vec<EagerPlanInvocationRow>,
+    attachments: Vec<EagerPlanAttachmentRow>,
+    finalizations: Vec<EagerPlanFinalizationRow>,
+    closures: Vec<EagerPlanClosureRow>,
+    direct_coefficients: Vec<EagerPlanDirectCoefficientRow>,
+    selector_domains: Vec<EagerPlanSelectorDomainRow>,
+    selector_memberships: Vec<u32>,
+    helicity_selectors: Vec<EagerPlanHelicitySelectorRow>,
+    color_selectors: Vec<EagerPlanColorSelectorRow>,
+    reduction_groups: Vec<EagerPlanReductionGroupRow>,
+    reduction_entries: Vec<EagerPlanReductionEntryRow>,
+    exact_factors: Vec<EagerPlanExactFactorRow>,
+    bitset_ranges: Vec<EagerPlanCatalogRangeRow>,
+    bitset_populations: Vec<u64>,
+    bitset_words: Vec<u64>,
+    u32_ranges: Vec<EagerPlanCatalogRangeRow>,
+    u32_values: Vec<u32>,
+    i32_ranges: Vec<EagerPlanCatalogRangeRow>,
+    i32_values: Vec<i32>,
+}
+
+impl Fixture {
+    fn populated() -> Self {
+        Self {
+            strings: vec!["one".into(), "two".into()],
+            exact_ir: vec!["{\"ir\":1}".into()],
+            limitations: vec!["exact limitation".into()],
+            retained: vec![],
+            currents: vec![EagerPlanCurrentRow {
+                current_id: 11,
+                component_start: 12,
+                component_count: 13,
+                momentum_slot_id: 14,
+                flags: 15,
+            }],
+            values: vec![EagerPlanValueRow {
+                value_slot_id: 21,
+                current_id: 22,
+                component_start: 23,
+                component_count: 24,
+                kind: EagerValueSlotKind::Propagated,
+            }],
+            momenta: vec![EagerPlanMomentumRow {
+                momentum_slot_id: 31,
+                bitset_id: 32,
+                component_start: 33,
+                component_count: 34,
+            }],
+            sources: vec![EagerPlanSourceFillRow {
+                source_id: 41,
+                current_id: 42,
+                value_slot_id: 43,
+                external_label: 44,
+                input_momentum_slot: 45,
+                source_ir_id: 46,
+                crossing_ir_id: 47,
+                crossing_factor_id: 48,
+                declared_state_index: 49,
+            }],
+            parameters: vec![EagerPlanParameterRow {
+                parameter_id: 51,
+                name_string_id: 52,
+                kind_string_id: 53,
+                default_factor_id: 54,
+                runtime_name_string_id: 55,
+                complex_component: -56,
+                flags: 57,
+            }],
+            stages: vec![EagerPlanStageRow {
+                stage_index: 61,
+                subset_size: 62,
+                invocation_start: 63,
+                invocation_count: 64,
+                attachment_start: 65,
+                attachment_count: 66,
+                finalization_start: 67,
+                finalization_count: 68,
+            }],
+            couplings: vec![EagerPlanCouplingRow {
+                coupling_id: 71,
+                real_parameter_id: 72,
+                imaginary_parameter_id: 73,
+                constant_factor_id: 74,
+            }],
+            invocations: vec![EagerPlanInvocationRow {
+                evaluation_group_id: 81,
+                kernel_id: 82,
+                left_value_slot_id: 83,
+                right_value_slot_id: 84,
+                left_momentum_slot_id: 85,
+                right_momentum_slot_id: 86,
+                coupling_slot_id: 87,
+                output_factor_source: 88,
+                attachment_start: 89,
+                attachment_count: 90,
+                selector_domain_id: 91,
+            }],
+            attachments: vec![EagerPlanAttachmentRow {
+                interaction_id: 101,
+                result_current_id: 102,
+                color_factor_id: 103,
+                evaluation_factor_id: 104,
+                normalization_factor_id: 105,
+                representative_evaluation_factor_id: 106,
+                selector_domain_id: 107,
+            }],
+            finalizations: vec![EagerPlanFinalizationRow {
+                kernel_id: 111,
+                current_id: 112,
+                unpropagated_value_slot_id: 113,
+                propagated_value_slot_id: 114,
+                momentum_slot_id: 115,
+                unpropagated_selector_domain_id: 116,
+                propagated_selector_domain_id: 117,
+            }],
+            closures: vec![EagerPlanClosureRow {
+                root_id: 121,
+                kernel_id: 122,
+                left_value_slot_id: 123,
+                right_value_slot_id: 124,
+                amplitude_index: 125,
+                coherent_group_id: 126,
+                coupling_slot_id: 127,
+                coupling_factor_id: 128,
+                output_factor_source: 129,
+                color_factor_id: 130,
+                normalization_factor_id: 131,
+                direct_coefficient_start: 132,
+                direct_coefficient_count: 133,
+                selector_domain_id: 134,
+            }],
+            direct_coefficients: vec![EagerPlanDirectCoefficientRow {
+                contraction_ir_id: 141,
+                component_index: 142,
+                factor_id: 143,
+            }],
+            selector_domains: vec![EagerPlanSelectorDomainRow {
+                member_start: 151,
+                member_count: 152,
+            }],
+            selector_memberships: vec![153],
+            helicity_selectors: vec![EagerPlanHelicitySelectorRow {
+                selector_id: 161,
+                values_sequence_id: 162,
+                representative_sequence_id: 163,
+                coefficient_factor_id: 164,
+                computed: 1,
+                structural_zero: 0,
+            }],
+            color_selectors: vec![EagerPlanColorSelectorRow {
+                selector_id: 171,
+                word_sequence_id: 172,
+                representative_word_sequence_id: 173,
+                coefficient_factor_id: 174,
+                computed: 1,
+            }],
+            reduction_groups: vec![EagerPlanReductionGroupRow {
+                coherent_group_id: 181,
+                amplitude_entry_start: 182,
+                amplitude_entry_count: 183,
+                selector_entry_start: 184,
+                selector_entry_count: 185,
+                helicity_weight_factor_id: 186,
+                all_sector_weight_factor_id: 187,
+            }],
+            reduction_entries: vec![EagerPlanReductionEntryRow {
+                kind: EagerPlanReductionEntryKind::ColorContraction,
+                owner_id: 191,
+                left_id: 192,
+                right_id: 193,
+                factor_id: 194,
+                auxiliary_factor_id: 195,
+            }],
+            exact_factors: vec![EagerPlanExactFactorRow {
+                factor_id: 201,
+                real_bits: (-0.0_f64).to_bits(),
+                imaginary_bits: 2.5_f64.to_bits(),
+                canonical_string_id: 202,
+                exact_source: 203,
+                exact_ir_id: 204,
+                source_ir_id: 205,
+            }],
+            bitset_ranges: vec![EagerPlanCatalogRangeRow {
+                start: 211,
+                count: 212,
+            }],
+            bitset_populations: vec![213],
+            bitset_words: vec![214],
+            u32_ranges: vec![EagerPlanCatalogRangeRow {
+                start: 221,
+                count: 222,
+            }],
+            u32_values: vec![223],
+            i32_ranges: vec![EagerPlanCatalogRangeRow {
+                start: 231,
+                count: 232,
+            }],
+            i32_values: vec![-233],
+        }
+    }
+
+    fn view(&self) -> PlanView<'_> {
+        PlanView {
+            abi: EAGER_PLAN_ABI,
+            process_key: "fixture-process",
+            model_name: "fixture-model",
+            string_catalog: &self.strings,
+            canonical_ir_catalog: &self.exact_ir,
+            semantic_limitations: &self.limitations,
+            retained_tables: &self.retained,
+            currents: &self.currents,
+            values: &self.values,
+            momenta: &self.momenta,
+            sources: &self.sources,
+            parameters: &self.parameters,
+            stages: &self.stages,
+            couplings: &self.couplings,
+            invocations: &self.invocations,
+            attachments: &self.attachments,
+            finalizations: &self.finalizations,
+            closures: &self.closures,
+            direct_coefficients: &self.direct_coefficients,
+            selector_domains: &self.selector_domains,
+            selector_memberships: &self.selector_memberships,
+            helicity_selectors: &self.helicity_selectors,
+            color_selectors: &self.color_selectors,
+            reduction_groups: &self.reduction_groups,
+            reduction_entries: &self.reduction_entries,
+            exact_factors: &self.exact_factors,
+            bitset_ranges: &self.bitset_ranges,
+            bitset_populations: &self.bitset_populations,
+            bitset_words: &self.bitset_words,
+            u32_sequence_ranges: &self.u32_ranges,
+            u32_sequence_values: &self.u32_values,
+            i32_sequence_ranges: &self.i32_ranges,
+            i32_sequence_values: &self.i32_values,
+            current_component_count: 301,
+            value_component_count: 302,
+            momentum_component_count: 303,
+            color_contraction_entry_start: 304,
+            color_contraction_entry_count: 305,
+        }
+    }
+}
+
+fn temporary_directory(label: &str) -> std::path::PathBuf {
+    let path = std::env::temp_dir().join(format!(
+        "rusticol-eager-v3-pacbin-{label}-{}-{}",
+        std::process::id(),
+        NEXT_DIRECTORY.fetch_add(1, Ordering::Relaxed)
+    ));
+    fs::create_dir(&path).unwrap();
+    path
+}
+
+fn u32_at(bytes: &[u8], offset: usize) -> u32 {
+    u32::from_le_bytes(bytes[offset..offset + 4].try_into().unwrap())
+}
+
+fn u64_at(bytes: &[u8], offset: usize) -> u64 {
+    u64::from_le_bytes(bytes[offset..offset + 8].try_into().unwrap())
+}
+
+fn section_payload<'a>(reader: &'a PacbinReader, path: &str) -> &'a [u8] {
+    let bytes = reader.member_bytes(path).unwrap();
+    let (_, payload) = EagerSectionHeader::decode(bytes).unwrap();
+    payload
+}
+
+#[test]
+fn eager_plan_v3_pacbin_is_byte_identical_and_metadata_is_bounded() {
+    let directory = temporary_directory("deterministic");
+    let first = directory.join("first.pacbin");
+    let second = directory.join("second.pacbin");
+    let fixture = Fixture::populated();
+    let first_metadata = write_plan_view(&fixture.view(), &first).unwrap();
+    let second_metadata = write_plan_view(&fixture.view(), &second).unwrap();
+    assert_eq!(fs::read(&first).unwrap(), fs::read(&second).unwrap());
+    assert_eq!(first_metadata, second_metadata);
+    assert_eq!(first_metadata.member_count, EXPECTED_MEMBERS.len() as u64);
+    assert_eq!(
+        first_metadata.file_size,
+        fs::metadata(&first).unwrap().len()
+    );
+    let expected_file_digest: [u8; 32] = Sha256::digest(fs::read(&first).unwrap()).into();
+    assert_eq!(first_metadata.file_sha256, expected_file_digest);
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn reader_authenticates_allowlisted_members_and_every_plan_field() {
+    let directory = temporary_directory("coverage");
+    let destination = directory.join("eager-runtime.pacbin");
+    let fixture = Fixture::populated();
+    write_plan_view(&fixture.view(), &destination).unwrap();
+    let reader = PacbinReader::open(&destination).unwrap();
+    reader.verify_payloads().unwrap();
+    let actual: Vec<_> = reader
+        .members()
+        .iter()
+        .map(|member| member.logical_path())
+        .collect();
+    assert_eq!(actual, EXPECTED_MEMBERS);
+    for member in reader.members() {
+        let expected_kind = if member.logical_path().starts_with("metadata/")
+            || member.logical_path().starts_with("inspection/")
+            || member.logical_path().ends_with("/bytes.bin")
+            || member.logical_path().ends_with("/ranges.bin")
+                && (member.logical_path().starts_with("catalogs/strings")
+                    || member.logical_path().starts_with("catalogs/exact-ir")
+                    || member
+                        .logical_path()
+                        .starts_with("catalogs/semantic-limitations"))
+            || member.logical_path().starts_with("retained/name-")
+        {
+            PacbinMemberKind::EagerRuntimeMetadata
+        } else {
+            PacbinMemberKind::EagerRuntimeTable
+        };
+        assert_eq!(member.kind(), expected_kind, "{}", member.logical_path());
+        let (header, payload) =
+            EagerSectionHeader::decode(reader.member_bytes(member.logical_path()).unwrap())
+                .unwrap();
+        assert_eq!(payload.len() as u64, header.payload_length());
+    }
+
+    let metadata = section_payload(&reader, "metadata/core.bin");
+    assert_eq!(u32_at(metadata, 0), SERIALIZATION_SCHEMA);
+    assert_eq!(u32_at(metadata, 8), IDENTITY_LOWERING_ABI);
+    assert_eq!(u32_at(metadata, 32), IDENTITY_MODEL_NAME);
+    assert_eq!(u64_at(metadata, 48), 301);
+    assert_eq!(u64_at(metadata, 56), 302);
+    assert_eq!(u64_at(metadata, 64), 303);
+    assert_eq!(u64_at(metadata, 72), 304);
+    assert_eq!(u64_at(metadata, 80), 305);
+
+    let current = section_payload(&reader, "tables/currents.bin");
+    assert_eq!(u32_at(current, 0), 11);
+    assert_eq!(u64_at(current, 4), 12);
+    assert_eq!(u32_at(current, 20), 15);
+    let closure = section_payload(&reader, "tables/closures.bin");
+    assert_eq!(u32_at(closure, 0), 121);
+    assert_eq!(u64_at(closure, 44), 132);
+    assert_eq!(u32_at(closure, 60), 134);
+    let direct = section_payload(&reader, "tables/direct-coefficients.bin");
+    assert_eq!(
+        (u32_at(direct, 0), u32_at(direct, 4), u32_at(direct, 8)),
+        (141, 142, 143)
+    );
+    let helicity = section_payload(&reader, "selectors/helicities.bin");
+    assert_eq!(
+        &helicity[..18],
+        &[161, 0, 0, 0, 162, 0, 0, 0, 163, 0, 0, 0, 164, 0, 0, 0, 1, 0]
+    );
+    let exact = section_payload(&reader, "catalogs/exact-factors.bin");
+    assert_eq!(u64_at(exact, 8), (-0.0_f64).to_bits());
+    assert_eq!(u64_at(exact, 16), 2.5_f64.to_bits());
+    assert_eq!(u32_at(exact, 36), 205);
+    let identity = section_payload(&reader, "metadata/identity-bytes.bin");
+    let identity_text = std::str::from_utf8(identity).unwrap();
+    assert!(identity_text.contains(EAGER_PLAN_ABI));
+    assert!(identity_text.contains("fixture-process"));
+    assert!(identity_text.contains("fixture-model"));
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn malformed_destination_preserves_existing_target_and_cleans_staging() {
+    let directory = temporary_directory("rollback");
+    let destination = directory.join("eager-runtime.pacbin");
+    fs::create_dir(&destination).unwrap();
+    fs::write(destination.join("sentinel"), b"keep").unwrap();
+    let fixture = Fixture::populated();
+    let error = write_plan_view(&fixture.view(), &destination).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert_eq!(fs::read(destination.join("sentinel")).unwrap(), b"keep");
+    let names: Vec<_> = fs::read_dir(&directory)
+        .unwrap()
+        .map(|entry| entry.unwrap().file_name())
+        .collect();
+    assert_eq!(
+        names,
+        vec![std::ffi::OsString::from("eager-runtime.pacbin")]
+    );
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn large_catalog_serialization_keeps_payload_independent_scratch() {
+    let directory = temporary_directory("bounded");
+    let destination = directory.join("eager-runtime.pacbin");
+    let mut fixture = Fixture::populated();
+    fixture.u32_values = vec![0x1234_5678; 1_000_000];
+    fixture.u32_ranges = vec![EagerPlanCatalogRangeRow {
+        start: 0,
+        count: fixture.u32_values.len() as u64,
+    }];
+    let metadata = write_plan_view(&fixture.view(), &destination).unwrap();
+    assert!(metadata.unpacked_bytes > 4_000_000);
+    assert_eq!(MAX_ENCODED_RECORD_SIZE, 224);
+    assert!(
+        std::mem::size_of::<FixedRowsReader<'_, EagerPlanCurrentRow>>()
+            < MAX_ENCODED_RECORD_SIZE + 128
+    );
+    assert!(
+        std::mem::size_of::<SegmentedPrimitiveReader<'_, u32>>() < 128,
+        "segmented reader must retain only cursors and one primitive"
+    );
+    let reader = PacbinReader::open(&destination).unwrap();
+    let values = section_payload(&reader, "catalogs/u32-sequences/values.bin");
+    assert_eq!(values.len(), 4_000_000);
+    assert_eq!(u32_at(values, values.len() - 4), 0x1234_5678);
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn retained_table_and_column_records_preserve_every_descriptor_field() {
+    let table = RetainedTableRecord {
+        table_id: 1,
+        name_id: 2,
+        row_count: 3,
+        column_start: 4,
+        column_count: 5,
+    };
+    let mut table_bytes = [0_u8; RETAINED_TABLE_RECORD_SIZE as usize];
+    encode_retained_table(&table, &mut table_bytes);
+    assert_eq!(u32_at(&table_bytes, 0), 1);
+    assert_eq!(u32_at(&table_bytes, 4), 2);
+    assert_eq!(u64_at(&table_bytes, 8), 3);
+    assert_eq!(u64_at(&table_bytes, 16), 4);
+    assert_eq!(u64_at(&table_bytes, 24), 5);
+
+    let column = RetainedColumnRecord {
+        table_id: 6,
+        column_id: 7,
+        name_id: 8,
+        primitive_kind: RETAINED_F64_BITS,
+        elements_per_row: 9,
+        value_start: 10,
+        value_count: 11,
+    };
+    let mut column_bytes = [0_u8; RETAINED_COLUMN_RECORD_SIZE as usize];
+    encode_retained_column(&column, &mut column_bytes);
+    assert_eq!(u32_at(&column_bytes, 0), 6);
+    assert_eq!(u32_at(&column_bytes, 4), 7);
+    assert_eq!(u32_at(&column_bytes, 8), 8);
+    assert_eq!(column_bytes[12], RETAINED_F64_BITS);
+    assert_eq!(u32_at(&column_bytes, 16), 9);
+    assert_eq!(u64_at(&column_bytes, 24), 10);
+    assert_eq!(u64_at(&column_bytes, 32), 11);
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_runtime.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime.rs
new file mode 100644
index 0000000000..2f8902c0aa
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime.rs
@@ -0,0 +1,242 @@
+// SPDX-License-Identifier: 0BSD
+
+use crate::{RusticolError, RusticolResult};
+use num_complex::Complex;
+use std::time::Duration;
+
+pub type EagerComplex64 = Complex<f64>;
+
+pub const DEFAULT_EAGER_POINT_TILE_SIZE: usize = 1024;
+pub const DEFAULT_EAGER_WORKSPACE_MIB: usize = 256;
+pub const EAGER_HOMOGENEOUS_LINEAR_CURRENT_PROOF: &str =
+    "prepared-kernel-homogeneous-complex-linear-current-v1";
+pub const EAGER_INDEPENDENT_BLOCK_SIZE: u32 = 4;
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub enum EagerKernelRole {
+    Vertex,
+    Finalization,
+    Closure,
+}
+
+/// One prepared evaluator input in its exact, deterministic parameter order.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub enum EagerKernelInput {
+    FirstCurrentComponent(u32),
+    SecondCurrentComponent(u32),
+    FirstMomentumComponent(u32),
+    SecondMomentumComponent(u32),
+    CouplingReal,
+    CouplingImag,
+    ModelParameter(u32),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EagerKernelSpec {
+    pub kernel_id: u32,
+    pub role: EagerKernelRole,
+    pub inputs: Vec<EagerKernelInput>,
+    pub output_component_count: u32,
+    pub homogeneous_linear_first_current: bool,
+    /// Prepared evaluator width for independent invocation blocks.
+    ///
+    /// A value greater than one is valid only for vertex kernels whose
+    /// prepared pack contains the correspondingly widened evaluator. The
+    /// scheduler retains the scalar evaluator for incomplete tails.
+    pub independent_block_size: u32,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EagerPlanDimensions {
+    pub value_slot_component_counts: Vec<u32>,
+    pub momentum_slot_component_counts: Vec<u32>,
+    pub current_component_counts: Vec<u32>,
+    pub parameter_count: u32,
+    pub amplitude_count: u32,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct EagerDirectClosureSpec {
+    pub closure_index: u32,
+    pub coefficients: Vec<EagerComplex64>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EagerReductionGroup {
+    pub coherent_group_id: u32,
+    pub amplitude_indices: Vec<u32>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct EagerReductionEntry {
+    pub left_group_index: u32,
+    pub right_group_index: u32,
+    pub coefficient: EagerComplex64,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct EagerPlanDefinition {
+    pub dimensions: EagerPlanDimensions,
+    pub kernels: Vec<EagerKernelSpec>,
+    pub direct_closures: Vec<EagerDirectClosureSpec>,
+    pub reduction_groups: Vec<EagerReductionGroup>,
+    pub reduction_entries: Vec<EagerReductionEntry>,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct EagerStagePayload<'a> {
+    pub stage_index: u32,
+    pub invocations: &'a [u8],
+    pub attachments: &'a [u8],
+    pub finalizations: &'a [u8],
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct EagerSelectorStagePayload<'a> {
+    pub stage_index: u32,
+    pub invocation_domains: &'a [u8],
+    pub attachment_domains: &'a [u8],
+    pub unpropagated_finalization_domains: &'a [u8],
+    pub propagated_finalization_domains: &'a [u8],
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct EagerSelectorPayloads<'a> {
+    pub domains: &'a [u8],
+    pub domain_group_ids: &'a [u8],
+    pub stages: &'a [EagerSelectorStagePayload<'a>],
+    pub closure_domains: &'a [u8],
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct EagerPlanPayloads<'a> {
+    pub couplings: &'a [u8],
+    pub stages: &'a [EagerStagePayload<'a>],
+    pub closures: &'a [u8],
+    pub selector_domains: Option<EagerSelectorPayloads<'a>>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerRuntimeOptions {
+    pub point_tile_size: usize,
+    /// Batch workspace target; one executable point may require more memory.
+    pub workspace_bytes: usize,
+}
+
+impl EagerRuntimeOptions {
+    pub fn from_mib(point_tile_size: usize, workspace_mib: usize) -> RusticolResult<Self> {
+        let workspace_bytes = workspace_mib.checked_mul(1024 * 1024).ok_or_else(|| {
+            RusticolError::invalid_argument("eager workspace size overflows bytes")
+        })?;
+        Ok(Self {
+            point_tile_size,
+            workspace_bytes,
+        })
+    }
+}
+
+impl Default for EagerRuntimeOptions {
+    fn default() -> Self {
+        Self {
+            point_tile_size: DEFAULT_EAGER_POINT_TILE_SIZE,
+            workspace_bytes: DEFAULT_EAGER_WORKSPACE_MIB * 1024 * 1024,
+        }
+    }
+}
+
+pub struct EagerKernelCall<'a> {
+    pub kernel_id: u32,
+    pub independent_block_size: u32,
+    pub lane_count: usize,
+    pub input_component_count: usize,
+    pub output_component_count: usize,
+    pub inputs: &'a [EagerComplex64],
+    pub outputs: &'a mut [EagerComplex64],
+}
+
+/// Evaluates row-major packets whose lanes are ordered by invocation, then point.
+///
+/// The scheduler sorts invocations stably by kernel id while loading a plan. Each packet
+/// therefore contains one kernel only; within that packet, all points for the first
+/// invocation precede all points for the next invocation. Input components follow the
+/// exact order in [`EagerKernelSpec::inputs`], so component `c` of lane `l` is stored at
+/// `l * input_component_count + c`. Outputs use the same lane-major row layout.
+pub trait EagerKernelBackend {
+    fn evaluate_batch(&mut self, call: EagerKernelCall<'_>) -> RusticolResult<()>;
+}
+
+/// Opt-in wall-clock accounting for one eager scheduler evaluation.
+///
+/// Every field is an aggregate over all point tiles. The phases are mutually
+/// exclusive, so [`Self::accounted`] can be compared directly with
+/// [`Self::total`]. Timer bookkeeping and validation account for the small
+/// unclassified remainder.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub(crate) struct EagerExecutionProfile {
+    pub(crate) initialize: Duration,
+    pub(crate) gather: Duration,
+    pub(crate) kernel_call: Duration,
+    pub(crate) invocation_scatter: Duration,
+    pub(crate) finalization: Duration,
+    pub(crate) closure: Duration,
+    pub(crate) reduction: Duration,
+    pub(crate) copy_out: Duration,
+    pub(crate) total: Duration,
+    pub(crate) backend_call_count: u64,
+    /// P-kernel output scratch reads and writes wholly inside the eager arena.
+    /// This is diagnostic traffic, never arena-boundary materialization.
+    pub(crate) internal_scratch_bytes: u64,
+    /// Point-independent coupling and parameter plane refreshes inside the
+    /// persistent eager arena. This is not arena-boundary traffic.
+    pub(crate) internal_broadcast_bytes: u64,
+}
+
+impl EagerExecutionProfile {
+    pub(crate) fn accounted(self) -> Duration {
+        self.initialize
+            + self.gather
+            + self.kernel_call
+            + self.invocation_scatter
+            + self.finalization
+            + self.closure
+            + self.reduction
+            + self.copy_out
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct EagerScheduleAuditRow {
+    pub(crate) stage_index: Option<u32>,
+    pub(crate) role: &'static str,
+    pub(crate) kernel_id: Option<u32>,
+    pub(crate) call_count: usize,
+    pub(crate) row_count: usize,
+    pub(crate) destination_count: usize,
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod direct_execution_arena;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod direct_invocation_arena;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+pub(crate) use direct_execution_arena::EagerDirectExecutionRuntime;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+pub(crate) use direct_invocation_arena::{
+    EagerDirectPreparedApplication, EagerDirectPreparedKernel,
+};
+#[cfg(all(test, any(feature = "f64-compiled", feature = "f64-symjit")))]
+pub(crate) use direct_invocation_arena::{
+    run_retained_multistage_oracle, select_retained_multistage_candidate,
+};
+mod execute;
+mod plan;
+mod plan_v3;
+mod profile;
+mod runtime;
+
+#[cfg(test)]
+mod plan_v3_tests;
+
+pub use plan::EagerExecutionPlan;
+pub(crate) use plan_v3::EagerPlanV3Sections;
+pub use runtime::EagerExecutionRuntime;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/direct_execution_arena.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/direct_execution_arena.rs
new file mode 100644
index 0000000000..7ff6959312
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/direct_execution_arena.rs
@@ -0,0 +1,3242 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Developer-gated whole-plan eager Direct-Arena execution.
+//!
+//! The packet scheduler remains an explicit validation oracle while this lane
+//! is gated. Production-selected direct execution never falls back to it:
+//! authenticated table callables consume persistent planes for every vertex,
+//! propagator, and kernel closure, while copies, direct contractions, and
+//! reductions operate on the same canonical storage.
+
+#![allow(dead_code)]
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::mem::size_of;
+use std::sync::Arc;
+use std::time::Instant;
+
+use crate::direct_arena::{DIRECT_ARENA_LOCALITY_POINT_CAP, DirectArenaLayout};
+use crate::engine::symjit_eager_direct::{
+    EAGER_DIRECT_SOURCE_APPLICATION_ABI, EAGER_DIRECT_TABLE_BINDING_ABI,
+    EAGER_DIRECT_TABLE_DESCRIPTOR_ABI, EagerDirectArenaPlaneBinding, EagerDirectTableRows,
+    EagerDirectTableWorkspace, LoadedSymjitEagerDirectTable,
+};
+use crate::{
+    EAGER_OUTPUT_FACTOR_COUPLING_IMAG, EAGER_OUTPUT_FACTOR_COUPLING_REAL, EAGER_OUTPUT_FACTOR_NONE,
+    MISSING_U32, RusticolError, RusticolResult,
+};
+
+use super::direct_invocation_arena::{
+    EagerDirectPreparedApplication, EagerDirectPreparedKernel, SemanticCatalog, assigned_component,
+    count_u32, derive_event_layout, invalid, push_u32, resolve_coupling, row_active,
+    validate_active_groups, validate_callable_identity, validate_component_buffer,
+};
+use super::execute::AccumulationFactor;
+use super::plan::{
+    ComponentRange, EagerExecutionPlan, EagerStagePlan, ScheduledClosure, ScheduledFinalization,
+    ScheduledInvocation,
+};
+use super::{
+    EagerComplex64, EagerKernelInput, EagerKernelRole, EagerPlanV3Sections, EagerRuntimeOptions,
+    EagerScheduleAuditRow,
+};
+
+struct DirectCall {
+    kernel_id: u32,
+    application: Arc<LoadedSymjitEagerDirectTable>,
+    rows: EagerDirectTableRows,
+}
+
+#[derive(Clone, Copy)]
+struct DirectFactorSpec {
+    factor: EagerComplex64,
+    coupling_slot_id: Option<u32>,
+    output_factor_source: u32,
+}
+
+#[derive(Clone, Copy)]
+struct DirectCopy {
+    source_component_base: u32,
+    destination_component_base: u32,
+    component_count: u32,
+}
+
+struct DirectStage {
+    stage_index: u32,
+    invocation_calls: Box<[DirectCall]>,
+    unpropagated_copies: Box<[DirectCopy]>,
+    finalization_calls: Box<[DirectCall]>,
+}
+
+struct DirectCoefficientClosure {
+    left_component_base: u32,
+    right_component_base: u32,
+    component_count: u32,
+    amplitude_index: u32,
+    factor: AccumulationFactor,
+    initializes_amplitude: bool,
+    coefficients: Box<[EagerComplex64]>,
+}
+
+struct DirectSchedule {
+    stages: Box<[DirectStage]>,
+    closure_calls: Box<[DirectCall]>,
+    direct_closures: Box<[DirectCoefficientClosure]>,
+    factor_specs: Box<[DirectFactorSpec]>,
+    active_amplitude_indices: Box<[usize]>,
+    active_reduction_group_indices: Box<[usize]>,
+    active_reduction_entry_indices: Box<[usize]>,
+    active_reduction_group_ids: Box<[u32]>,
+}
+
+struct SelectedSchedule {
+    active_groups: Box<[u32]>,
+    schedule: DirectSchedule,
+}
+
+#[derive(Clone, Copy)]
+struct PointWorkGroup {
+    schedule_index: Option<usize>,
+    point_start: usize,
+    point_count: usize,
+}
+
+#[derive(Default)]
+struct PointSelectedSchedules {
+    signature_offsets: Vec<usize>,
+    signature_groups: Vec<u32>,
+    point_work_group_ids: Vec<usize>,
+    grouped_point_indices: Vec<usize>,
+    cursors: Vec<usize>,
+    work_groups: Vec<PointWorkGroup>,
+    schedules: Vec<SelectedSchedule>,
+}
+
+/// Whole-plan eager Direct-Arena runtime.
+///
+/// Construction owns all lowered callables and immutable row tables. The
+/// warmed unprofiled methods mutate only persistent planes, factors, reduction
+/// scratch, and caller-provided outputs.
+pub(crate) struct EagerDirectExecutionRuntime {
+    plan: EagerExecutionPlan,
+    catalog: SemanticCatalog,
+    layout: DirectArenaLayout,
+    workspace: EagerDirectTableWorkspace,
+    applications: BTreeMap<u32, Arc<LoadedSymjitEagerDirectTable>>,
+    full_schedule: DirectSchedule,
+    selected_schedule: Option<SelectedSchedule>,
+    point_selected: PointSelectedSchedules,
+    initial_value_slots: Box<[u32]>,
+    value_ranges: Box<[ComponentRange]>,
+    momentum_ranges: Box<[ComponentRange]>,
+    reduction_groups: Vec<EagerComplex64>,
+    reduced_tile: Vec<f64>,
+    broadcast_parameter_bits: Box<[[u64; 2]]>,
+    broadcasts_initialized: bool,
+    shared_zero_plane_index: Option<u32>,
+    elide_structural_zero_fills: bool,
+    internal_broadcast_bytes: u64,
+    workspace_bytes: usize,
+}
+
+impl EagerDirectExecutionRuntime {
+    pub(crate) fn from_plan_v3_sections(
+        sections: EagerPlanV3Sections<'_>,
+        prepared: &[EagerDirectPreparedKernel<'_>],
+        options: EagerRuntimeOptions,
+    ) -> RusticolResult<Self> {
+        if options.point_tile_size == 0 {
+            return Err(invalid(
+                "eager direct whole-plan point tile size must be positive",
+            ));
+        }
+        let plan = EagerExecutionPlan::from_plan_v3_sections(sections)?;
+        let catalog = SemanticCatalog::new(sections)?;
+        let layout = derive_event_layout(sections, catalog, &plan)?;
+        let requested_tile = u32::try_from(options.point_tile_size)
+            .map_err(|_| invalid("eager direct point tile size exceeds u32"))?
+            .min(DIRECT_ARENA_LOCALITY_POINT_CAP);
+
+        let applications = load_applications(&plan, prepared)?;
+        let shared_zero_plane_index =
+            shared_zero_plane_index(sections, catalog, &layout, &applications)?;
+        let elide_structural_zero_fills = shared_zero_plane_index.is_some()
+            && applications
+                .values()
+                .all(|application| application.is_symjit());
+        let full_schedule = build_direct_schedule(
+            &plan,
+            catalog,
+            &layout,
+            &applications,
+            shared_zero_plane_index,
+            None,
+        )?;
+        let factor_capacity = full_schedule.factor_specs.len().max(1);
+        let (symjit_descriptor_capacity, symjit_scratch_plane_count) = applications
+            .values()
+            .filter_map(|application| application.symjit_workspace_shape())
+            .fold((0usize, 0usize), |maximum, shape| {
+                (maximum.0.max(shape.0), maximum.1.max(shape.1))
+            });
+        let broadcast_cache_bytes = plan
+            .parameter_count
+            .checked_mul(std::mem::size_of::<[u64; 2]>())
+            .ok_or_else(|| invalid("eager direct broadcast cache size overflows"))?;
+        let descriptor_bytes =
+            EagerDirectTableWorkspace::symjit_descriptor_storage_bytes(symjit_descriptor_capacity)?;
+        let factor_bytes = factor_capacity
+            .checked_mul(2 * size_of::<f64>())
+            .ok_or_else(|| invalid("eager direct factor workspace size overflows"))?;
+        let fixed_workspace_bytes = broadcast_cache_bytes
+            .checked_add(descriptor_bytes)
+            .and_then(|bytes| bytes.checked_add(factor_bytes))
+            .ok_or_else(|| invalid("eager direct fixed workspace size overflows"))?;
+        let arena_workspace_budget = options
+            .workspace_bytes
+            .saturating_sub(fixed_workspace_bytes);
+        let tile_capacity = direct_tile_capacity(
+            requested_tile,
+            arena_workspace_budget,
+            layout.component_count(),
+            count_u32(plan.amplitude_count, "amplitude planes")?,
+            count_u32(plan.reduction_groups.len(), "reduction groups")?,
+            symjit_scratch_plane_count,
+        )?;
+
+        let value_ranges = (0..sections.values.len())
+            .map(|id| plan.values.get(id as u32, "eager direct value"))
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        let momentum_ranges = (0..sections.momenta.len())
+            .map(|id| plan.momenta.get(id as u32, "eager direct momentum"))
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        let mut produced_values = vec![false; sections.values.len()];
+        for row in sections.finalizations {
+            for value in [row.unpropagated_value_slot_id, row.propagated_value_slot_id] {
+                if value != MISSING_U32 {
+                    produced_values[value as usize] = true;
+                }
+            }
+        }
+        let initial_value_slots = produced_values
+            .iter()
+            .enumerate()
+            .filter_map(|(id, produced)| (!produced).then_some(id as u32))
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+
+        let plane_bindings = plane_bindings(&layout, plan.amplitude_count)?;
+        let mut workspace = EagerDirectTableWorkspace::new(
+            layout.component_count(),
+            count_u32(plan.amplitude_count, "amplitude planes")?,
+            tile_capacity,
+            &plane_bindings,
+            shared_zero_plane_index,
+            Vec::new(),
+            vec![0.0; factor_capacity],
+            vec![0.0; factor_capacity],
+        )?;
+        workspace.begin_tile(tile_capacity)?;
+        validate_schedule_calls(
+            &full_schedule,
+            &mut workspace,
+            shared_zero_plane_index,
+            tile_capacity,
+        )?;
+
+        let stride = workspace.arena().point_stride() as usize;
+        let reduction_groups =
+            vec![EagerComplex64::new(0.0, 0.0); plan.reduction_groups.len() * stride];
+        let reduced_tile = vec![0.0; stride];
+        let broadcast_parameter_bits = vec![[0, 0]; plan.parameter_count].into_boxed_slice();
+        let workspace_bytes = direct_workspace_bytes(
+            &workspace,
+            reduction_groups.len(),
+            reduced_tile.len(),
+            factor_capacity,
+        )?
+        .checked_add(broadcast_cache_bytes)
+        .ok_or_else(|| invalid("eager direct workspace byte accounting overflows"))?;
+
+        Ok(Self {
+            plan,
+            catalog,
+            layout,
+            workspace,
+            applications,
+            full_schedule,
+            selected_schedule: None,
+            point_selected: PointSelectedSchedules::default(),
+            initial_value_slots,
+            value_ranges,
+            momentum_ranges,
+            reduction_groups,
+            reduced_tile,
+            broadcast_parameter_bits,
+            broadcasts_initialized: false,
+            shared_zero_plane_index,
+            elide_structural_zero_fills,
+            internal_broadcast_bytes: 0,
+            workspace_bytes,
+        })
+    }
+
+    pub(crate) fn plan(&self) -> &EagerExecutionPlan {
+        &self.plan
+    }
+
+    pub(crate) fn effective_point_tile_size(&self) -> usize {
+        self.workspace.arena().tile_capacity() as usize
+    }
+
+    pub(crate) const fn workspace_bytes(&self) -> usize {
+        self.workspace_bytes
+    }
+
+    pub(crate) const fn internal_scratch_bytes(&self) -> u64 {
+        self.workspace.internal_scratch_bytes()
+    }
+
+    pub(crate) const fn internal_broadcast_bytes(&self) -> u64 {
+        self.internal_broadcast_bytes
+    }
+
+    fn refresh_broadcast_planes(
+        &mut self,
+        model_parameters: &[EagerComplex64],
+    ) -> RusticolResult<()> {
+        fn parameter_changed(
+            cached: &[[u64; 2]],
+            parameters: &[EagerComplex64],
+            parameter: usize,
+        ) -> bool {
+            let value = parameters[parameter];
+            cached[parameter] != [value.re.to_bits(), value.im.to_bits()]
+        }
+
+        let initializing = !self.broadcasts_initialized;
+        if !initializing
+            && !(0..model_parameters.len()).any(|parameter| {
+                parameter_changed(&self.broadcast_parameter_bits, model_parameters, parameter)
+            })
+        {
+            return Ok(());
+        }
+
+        let stride = self.workspace.arena().point_stride() as usize;
+        let (real, imaginary, _, _) = self.workspace.split_arena_slices_mut();
+        let mut written_planes = 0_u64;
+        for (coupling_id, row) in self.plan.couplings.iter().copied().enumerate() {
+            let coupling_changed = initializing
+                || (row.real_parameter_id != MISSING_U32
+                    && parameter_changed(
+                        &self.broadcast_parameter_bits,
+                        model_parameters,
+                        row.real_parameter_id as usize,
+                    ))
+                || (row.imag_parameter_id != MISSING_U32
+                    && parameter_changed(
+                        &self.broadcast_parameter_bits,
+                        model_parameters,
+                        row.imag_parameter_id as usize,
+                    ));
+            if !coupling_changed {
+                continue;
+            }
+            let coupling = resolve_coupling(row, model_parameters);
+            let real_component = assigned_component(
+                &self.layout,
+                self.catalog
+                    .coupling_real(count_u32(coupling_id, "coupling")?)?,
+                0,
+            )?;
+            let imaginary_component = assigned_component(
+                &self.layout,
+                self.catalog
+                    .coupling_imag(count_u32(coupling_id, "coupling")?)?,
+                0,
+            )?;
+            if self.elide_structural_zero_fills {
+                fill_real_input_plane(real, stride, real_component, stride, coupling.re);
+                fill_real_input_plane(real, stride, imaginary_component, stride, coupling.im);
+                written_planes = written_planes.saturating_add(2);
+            } else {
+                fill_input_plane(
+                    real,
+                    imaginary,
+                    stride,
+                    real_component,
+                    stride,
+                    coupling.re,
+                    0.0,
+                );
+                fill_input_plane(
+                    real,
+                    imaginary,
+                    stride,
+                    imaginary_component,
+                    stride,
+                    coupling.im,
+                    0.0,
+                );
+                written_planes = written_planes.saturating_add(4);
+            }
+        }
+        for (parameter, value) in model_parameters.iter().copied().enumerate() {
+            if !initializing
+                && !parameter_changed(&self.broadcast_parameter_bits, model_parameters, parameter)
+            {
+                continue;
+            }
+            fill_input_plane(
+                real,
+                imaginary,
+                stride,
+                assigned_component(
+                    &self.layout,
+                    self.catalog
+                        .parameter(count_u32(parameter, "model parameter")?)?,
+                    0,
+                )?,
+                stride,
+                value.re,
+                value.im,
+            );
+            written_planes = written_planes.saturating_add(2);
+            self.broadcast_parameter_bits[parameter] = [value.re.to_bits(), value.im.to_bits()];
+        }
+        self.broadcasts_initialized = true;
+        self.internal_broadcast_bytes = self.internal_broadcast_bytes.saturating_add(
+            written_planes
+                .saturating_mul(stride as u64)
+                .saturating_mul(std::mem::size_of::<f64>() as u64),
+        );
+        Ok(())
+    }
+
+    /// Execute and reduce directly from arena amplitude planes without
+    /// materializing the amplitude matrix in caller memory.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_totals_into(
+        &mut self,
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        reduced: &mut [f64],
+    ) -> RusticolResult<()> {
+        validate_io(
+            &self.plan,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            None,
+            Some(reduced),
+        )?;
+        self.refresh_broadcast_planes(model_parameters)?;
+        let tile_capacity = self.effective_point_tile_size();
+        let mut tile_start = 0usize;
+        while tile_start < point_count {
+            let tile_points = tile_capacity.min(point_count - tile_start);
+            execute_contiguous_tile(
+                &self.plan,
+                self.catalog,
+                &self.layout,
+                &mut self.workspace,
+                &self.initial_value_slots,
+                &self.value_ranges,
+                &self.momentum_ranges,
+                self.elide_structural_zero_fills,
+                &self.full_schedule,
+                &mut self.reduction_groups,
+                point_count,
+                tile_start,
+                tile_points,
+                initial_values,
+                momenta,
+                model_parameters,
+            )?;
+            reduce_full_tile(
+                &self.plan,
+                &self.workspace,
+                &mut self.reduction_groups,
+                &mut self.reduced_tile,
+                tile_points,
+            );
+            reduced[tile_start..tile_start + tile_points]
+                .copy_from_slice(&self.reduced_tile[..tile_points]);
+            tile_start += tile_points;
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_into(
+        &mut self,
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        amplitudes: &mut [EagerComplex64],
+        reduced: &mut [f64],
+    ) -> RusticolResult<()> {
+        validate_io(
+            &self.plan,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            Some(amplitudes),
+            Some(reduced),
+        )?;
+        self.refresh_broadcast_planes(model_parameters)?;
+        let tile_capacity = self.effective_point_tile_size();
+        let mut tile_start = 0usize;
+        while tile_start < point_count {
+            let tile_points = tile_capacity.min(point_count - tile_start);
+            execute_contiguous_tile(
+                &self.plan,
+                self.catalog,
+                &self.layout,
+                &mut self.workspace,
+                &self.initial_value_slots,
+                &self.value_ranges,
+                &self.momentum_ranges,
+                self.elide_structural_zero_fills,
+                &self.full_schedule,
+                &mut self.reduction_groups,
+                point_count,
+                tile_start,
+                tile_points,
+                initial_values,
+                momenta,
+                model_parameters,
+            )?;
+            reduce_full_tile(
+                &self.plan,
+                &self.workspace,
+                &mut self.reduction_groups,
+                &mut self.reduced_tile,
+                tile_points,
+            );
+            copy_amplitude_tile(
+                &self.workspace,
+                0..self.plan.amplitude_count,
+                point_count,
+                tile_start,
+                tile_points,
+                amplitudes,
+            );
+            reduced[tile_start..tile_start + tile_points]
+                .copy_from_slice(&self.reduced_tile[..tile_points]);
+            tile_start += tile_points;
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_profile_into(
+        &mut self,
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        amplitudes: &mut [EagerComplex64],
+        reduced: &mut [f64],
+    ) -> RusticolResult<super::EagerExecutionProfile> {
+        validate_io(
+            &self.plan,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            Some(amplitudes),
+            Some(reduced),
+        )?;
+        let total_start = Instant::now();
+        let internal_scratch_before = self.workspace.internal_scratch_bytes();
+        let internal_broadcast_before = self.internal_broadcast_bytes;
+        let mut profile = super::EagerExecutionProfile::default();
+        let phase = Instant::now();
+        self.refresh_broadcast_planes(model_parameters)?;
+        profile.gather += phase.elapsed();
+        let tile_capacity = self.effective_point_tile_size();
+        let mut tile_start = 0usize;
+        while tile_start < point_count {
+            let tile_points = tile_capacity.min(point_count - tile_start);
+
+            let phase = Instant::now();
+            self.workspace
+                .begin_tile(count_u32(tile_points, "active point tile")?)?;
+            self.workspace
+                .clear_amplitude_active(0, count_u32(self.plan.amplitude_count, "amplitudes")?)?;
+            profile.initialize += phase.elapsed();
+
+            let phase = Instant::now();
+            fill_contiguous_tile_inputs(
+                &self.plan,
+                self.catalog,
+                &self.layout,
+                &mut self.workspace,
+                &self.initial_value_slots,
+                &self.value_ranges,
+                &self.momentum_ranges,
+                self.elide_structural_zero_fills,
+                point_count,
+                tile_start,
+                tile_points,
+                initial_values,
+                momenta,
+                model_parameters,
+            )?;
+            fill_schedule_factors(
+                &self.plan,
+                &self.full_schedule,
+                &mut self.workspace,
+                model_parameters,
+            )?;
+            profile.gather += phase.elapsed();
+
+            execute_schedule_profiled(
+                &self.full_schedule,
+                &mut self.workspace,
+                &mut self.reduction_groups,
+                count_u32(tile_points, "active point tile")?,
+                &mut profile,
+            )?;
+
+            let phase = Instant::now();
+            reduce_full_tile(
+                &self.plan,
+                &self.workspace,
+                &mut self.reduction_groups,
+                &mut self.reduced_tile,
+                tile_points,
+            );
+            profile.reduction += phase.elapsed();
+
+            let phase = Instant::now();
+            copy_amplitude_tile(
+                &self.workspace,
+                0..self.plan.amplitude_count,
+                point_count,
+                tile_start,
+                tile_points,
+                amplitudes,
+            );
+            reduced[tile_start..tile_start + tile_points]
+                .copy_from_slice(&self.reduced_tile[..tile_points]);
+            profile.copy_out += phase.elapsed();
+            tile_start += tile_points;
+        }
+        profile.total = total_start.elapsed();
+        profile.internal_scratch_bytes = self
+            .workspace
+            .internal_scratch_bytes()
+            .saturating_sub(internal_scratch_before);
+        profile.internal_broadcast_bytes = self
+            .internal_broadcast_bytes
+            .saturating_sub(internal_broadcast_before);
+        Ok(profile)
+    }
+
+    pub(crate) fn full_schedule_call_counts(&self) -> (u64, u64, u64) {
+        let mut calls = 0_u64;
+        let mut invocations = 0_u64;
+        let mut destinations = 0_u64;
+        for stage in &self.full_schedule.stages {
+            for call in stage
+                .invocation_calls
+                .iter()
+                .chain(stage.finalization_calls.iter())
+            {
+                calls += 1;
+                invocations += u64::from(call.rows.invocation_count());
+                destinations += u64::from(call.rows.attachment_count());
+            }
+        }
+        for call in &self.full_schedule.closure_calls {
+            calls += 1;
+            invocations += u64::from(call.rows.invocation_count());
+            destinations += u64::from(call.rows.attachment_count());
+        }
+        (calls, invocations, destinations)
+    }
+
+    pub(crate) fn schedule_audit(
+        &mut self,
+        active_groups: Option<&[u32]>,
+    ) -> RusticolResult<Vec<EagerScheduleAuditRow>> {
+        if let Some(groups) = active_groups {
+            self.prepare_selected_schedule(groups)?;
+        }
+        let schedule = if active_groups.is_some() {
+            &self
+                .selected_schedule
+                .as_ref()
+                .ok_or_else(|| RusticolError::internal("eager direct selected schedule is absent"))?
+                .schedule
+        } else {
+            &self.full_schedule
+        };
+        let mut rows = Vec::new();
+        for stage in &schedule.stages {
+            for call in &stage.invocation_calls {
+                rows.push(EagerScheduleAuditRow {
+                    stage_index: Some(stage.stage_index),
+                    role: "invocation",
+                    kernel_id: Some(call.kernel_id),
+                    call_count: 1,
+                    row_count: call.rows.invocation_count() as usize,
+                    destination_count: call.rows.attachment_count() as usize,
+                });
+            }
+            if !stage.unpropagated_copies.is_empty() {
+                rows.push(EagerScheduleAuditRow {
+                    stage_index: Some(stage.stage_index),
+                    role: "copy",
+                    kernel_id: None,
+                    call_count: 0,
+                    row_count: stage.unpropagated_copies.len(),
+                    destination_count: stage
+                        .unpropagated_copies
+                        .iter()
+                        .map(|copy| copy.component_count as usize)
+                        .sum(),
+                });
+            }
+            for call in &stage.finalization_calls {
+                rows.push(EagerScheduleAuditRow {
+                    stage_index: Some(stage.stage_index),
+                    role: "finalization",
+                    kernel_id: Some(call.kernel_id),
+                    call_count: 1,
+                    row_count: call.rows.invocation_count() as usize,
+                    destination_count: call.rows.attachment_count() as usize,
+                });
+            }
+        }
+        for call in &schedule.closure_calls {
+            rows.push(EagerScheduleAuditRow {
+                stage_index: None,
+                role: "closure",
+                kernel_id: Some(call.kernel_id),
+                call_count: 1,
+                row_count: call.rows.invocation_count() as usize,
+                destination_count: call.rows.attachment_count() as usize,
+            });
+        }
+        if !schedule.direct_closures.is_empty() {
+            rows.push(EagerScheduleAuditRow {
+                stage_index: None,
+                role: "direct-closure",
+                kernel_id: None,
+                call_count: 0,
+                row_count: schedule.direct_closures.len(),
+                destination_count: schedule.direct_closures.len(),
+            });
+        }
+        Ok(rows)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_selected_profile_into(
+        &mut self,
+        active_groups: &[u32],
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        amplitudes: &mut [EagerComplex64],
+    ) -> RusticolResult<super::EagerExecutionProfile> {
+        validate_io(
+            &self.plan,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            Some(amplitudes),
+            None,
+        )?;
+        let total_start = Instant::now();
+        let internal_scratch_before = self.workspace.internal_scratch_bytes();
+        let internal_broadcast_before = self.internal_broadcast_bytes;
+        let phase = Instant::now();
+        self.prepare_selected_schedule(active_groups)?;
+        self.refresh_broadcast_planes(model_parameters)?;
+        let mut profile = super::EagerExecutionProfile {
+            initialize: phase.elapsed(),
+            ..super::EagerExecutionProfile::default()
+        };
+        let selected = self
+            .selected_schedule
+            .as_ref()
+            .ok_or_else(|| RusticolError::internal("eager direct selected schedule is absent"))?;
+        let tile_capacity = self.effective_point_tile_size();
+        let mut tile_start = 0usize;
+        while tile_start < point_count {
+            let tile_points = tile_capacity.min(point_count - tile_start);
+
+            let phase = Instant::now();
+            self.workspace
+                .begin_tile(count_u32(tile_points, "active point tile")?)?;
+            self.workspace
+                .clear_amplitude_active(0, count_u32(self.plan.amplitude_count, "amplitudes")?)?;
+            profile.initialize += phase.elapsed();
+
+            let phase = Instant::now();
+            fill_contiguous_tile_inputs(
+                &self.plan,
+                self.catalog,
+                &self.layout,
+                &mut self.workspace,
+                &self.initial_value_slots,
+                &self.value_ranges,
+                &self.momentum_ranges,
+                self.elide_structural_zero_fills,
+                point_count,
+                tile_start,
+                tile_points,
+                initial_values,
+                momenta,
+                model_parameters,
+            )?;
+            fill_schedule_factors(
+                &self.plan,
+                &selected.schedule,
+                &mut self.workspace,
+                model_parameters,
+            )?;
+            profile.gather += phase.elapsed();
+
+            execute_schedule_profiled(
+                &selected.schedule,
+                &mut self.workspace,
+                &mut self.reduction_groups,
+                count_u32(tile_points, "active point tile")?,
+                &mut profile,
+            )?;
+
+            let phase = Instant::now();
+            copy_selected_amplitude_tile(
+                &self.workspace,
+                &selected.schedule.active_amplitude_indices,
+                point_count,
+                tile_start,
+                tile_points,
+                amplitudes,
+            );
+            profile.copy_out += phase.elapsed();
+            tile_start += tile_points;
+        }
+        profile.total = total_start.elapsed();
+        profile.internal_scratch_bytes = self
+            .workspace
+            .internal_scratch_bytes()
+            .saturating_sub(internal_scratch_before);
+        profile.internal_broadcast_bytes = self
+            .internal_broadcast_bytes
+            .saturating_sub(internal_broadcast_before);
+        Ok(profile)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_selected_active_amplitudes_into(
+        &mut self,
+        active_groups: &[u32],
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        amplitudes: &mut [EagerComplex64],
+    ) -> RusticolResult<()> {
+        validate_io(
+            &self.plan,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            Some(amplitudes),
+            None,
+        )?;
+        self.prepare_selected_schedule(active_groups)?;
+        self.refresh_broadcast_planes(model_parameters)?;
+        let selected = self
+            .selected_schedule
+            .as_ref()
+            .ok_or_else(|| RusticolError::internal("eager direct selected schedule is absent"))?;
+        let tile_capacity = self.workspace.arena().tile_capacity() as usize;
+        let mut tile_start = 0usize;
+        while tile_start < point_count {
+            let tile_points = tile_capacity.min(point_count - tile_start);
+            execute_contiguous_tile(
+                &self.plan,
+                self.catalog,
+                &self.layout,
+                &mut self.workspace,
+                &self.initial_value_slots,
+                &self.value_ranges,
+                &self.momentum_ranges,
+                self.elide_structural_zero_fills,
+                &selected.schedule,
+                &mut self.reduction_groups,
+                point_count,
+                tile_start,
+                tile_points,
+                initial_values,
+                momenta,
+                model_parameters,
+            )?;
+            copy_selected_amplitude_tile(
+                &self.workspace,
+                &selected.schedule.active_amplitude_indices,
+                point_count,
+                tile_start,
+                tile_points,
+                amplitudes,
+            );
+            tile_start += tile_points;
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_point_selected_group_sets_into(
+        &mut self,
+        group_offsets: &[usize],
+        active_groups: &[u32],
+        active_group_weights: &[f64],
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        reduced: &mut [f64],
+    ) -> RusticolResult<()> {
+        validate_io(
+            &self.plan,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            None,
+            Some(reduced),
+        )?;
+        validate_point_selectors(
+            &self.plan,
+            group_offsets,
+            active_groups,
+            active_group_weights,
+            point_count,
+        )?;
+        self.prepare_point_selected_schedules(group_offsets, active_groups)?;
+        self.refresh_broadcast_planes(model_parameters)?;
+        reduced.fill(0.0);
+
+        let tile_capacity = self.workspace.arena().tile_capacity() as usize;
+        for work in self.point_selected.work_groups.iter().copied() {
+            let Some(schedule_index) = work.schedule_index else {
+                continue;
+            };
+            let schedule = &self.point_selected.schedules[schedule_index].schedule;
+            let stop = work
+                .point_start
+                .checked_add(work.point_count)
+                .ok_or_else(|| invalid("eager direct point work range overflows"))?;
+            let points = self
+                .point_selected
+                .grouped_point_indices
+                .get(work.point_start..stop)
+                .ok_or_else(|| invalid("eager direct point work range is invalid"))?;
+            for point_tile in points.chunks(tile_capacity) {
+                execute_indexed_tile(
+                    &self.plan,
+                    self.catalog,
+                    &self.layout,
+                    &mut self.workspace,
+                    &self.initial_value_slots,
+                    &self.value_ranges,
+                    &self.momentum_ranges,
+                    self.elide_structural_zero_fills,
+                    schedule,
+                    &mut self.reduction_groups,
+                    point_count,
+                    point_tile,
+                    initial_values,
+                    momenta,
+                    model_parameters,
+                )?;
+                reduce_selected_indexed_tile(
+                    &self.plan,
+                    schedule,
+                    &self.workspace,
+                    &mut self.reduction_groups,
+                    &mut self.reduced_tile,
+                    group_offsets,
+                    active_groups,
+                    active_group_weights,
+                    point_tile,
+                )?;
+                for (tile_point, original_point) in point_tile.iter().copied().enumerate() {
+                    reduced[original_point] = self.reduced_tile[tile_point];
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn prepare_selected_schedule(&mut self, active_groups: &[u32]) -> RusticolResult<()> {
+        validate_active_groups(&self.plan, Some(active_groups))?;
+        if self
+            .selected_schedule
+            .as_ref()
+            .is_some_and(|selected| selected.active_groups.as_ref() == active_groups)
+        {
+            return Ok(());
+        }
+        let schedule = build_direct_schedule(
+            &self.plan,
+            self.catalog,
+            &self.layout,
+            &self.applications,
+            self.shared_zero_plane_index,
+            Some(active_groups),
+        )?;
+        let tile_capacity = self.workspace.arena().tile_capacity();
+        self.workspace.begin_tile(tile_capacity)?;
+        validate_schedule_calls(
+            &schedule,
+            &mut self.workspace,
+            self.shared_zero_plane_index,
+            tile_capacity,
+        )?;
+        self.selected_schedule = Some(SelectedSchedule {
+            active_groups: active_groups.into(),
+            schedule,
+        });
+        Ok(())
+    }
+
+    fn prepare_point_selected_schedules(
+        &mut self,
+        offsets: &[usize],
+        groups: &[u32],
+    ) -> RusticolResult<()> {
+        if self.point_selected.signature_offsets == offsets
+            && self.point_selected.signature_groups == groups
+        {
+            return Ok(());
+        }
+        self.point_selected.point_work_group_ids.clear();
+        self.point_selected.work_groups.clear();
+        self.point_selected
+            .point_work_group_ids
+            .try_reserve(offsets.len().saturating_sub(1))
+            .map_err(|error| {
+                invalid(format!(
+                    "could not reserve eager direct point selector work: {error}"
+                ))
+            })?;
+        for point in 0..offsets.len() - 1 {
+            let selected = &groups[offsets[point]..offsets[point + 1]];
+            let schedule_index = if selected.is_empty() {
+                None
+            } else if let Some(index) = self
+                .point_selected
+                .schedules
+                .iter()
+                .position(|cached| cached.active_groups.as_ref() == selected)
+            {
+                Some(index)
+            } else {
+                let schedule = build_direct_schedule(
+                    &self.plan,
+                    self.catalog,
+                    &self.layout,
+                    &self.applications,
+                    self.shared_zero_plane_index,
+                    Some(selected),
+                )?;
+                let tile_capacity = self.workspace.arena().tile_capacity();
+                self.workspace.begin_tile(tile_capacity)?;
+                validate_schedule_calls(
+                    &schedule,
+                    &mut self.workspace,
+                    self.shared_zero_plane_index,
+                    tile_capacity,
+                )?;
+                self.point_selected.schedules.push(SelectedSchedule {
+                    active_groups: selected.into(),
+                    schedule,
+                });
+                Some(self.point_selected.schedules.len() - 1)
+            };
+            let work_id = self
+                .point_selected
+                .work_groups
+                .iter()
+                .position(|work| work.schedule_index == schedule_index)
+                .unwrap_or_else(|| {
+                    self.point_selected.work_groups.push(PointWorkGroup {
+                        schedule_index,
+                        point_start: 0,
+                        point_count: 0,
+                    });
+                    self.point_selected.work_groups.len() - 1
+                });
+            self.point_selected.work_groups[work_id].point_count += 1;
+            self.point_selected.point_work_group_ids.push(work_id);
+        }
+        self.point_selected.cursors.clear();
+        let mut cursor = 0usize;
+        for work in &mut self.point_selected.work_groups {
+            work.point_start = cursor;
+            cursor = cursor
+                .checked_add(work.point_count)
+                .ok_or_else(|| invalid("eager direct grouped point count overflows"))?;
+            self.point_selected.cursors.push(work.point_start);
+        }
+        self.point_selected.grouped_point_indices.clear();
+        self.point_selected.grouped_point_indices.resize(cursor, 0);
+        for (point, work_id) in self
+            .point_selected
+            .point_work_group_ids
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            let target = self.point_selected.cursors[work_id];
+            self.point_selected.grouped_point_indices[target] = point;
+            self.point_selected.cursors[work_id] += 1;
+        }
+        self.point_selected.signature_offsets.clear();
+        self.point_selected
+            .signature_offsets
+            .extend_from_slice(offsets);
+        self.point_selected.signature_groups.clear();
+        self.point_selected
+            .signature_groups
+            .extend_from_slice(groups);
+        Ok(())
+    }
+}
+
+fn load_applications(
+    plan: &EagerExecutionPlan,
+    prepared: &[EagerDirectPreparedKernel<'_>],
+) -> RusticolResult<BTreeMap<u32, Arc<LoadedSymjitEagerDirectTable>>> {
+    let mut applications = BTreeMap::new();
+    for artifact in prepared {
+        if applications.contains_key(&artifact.kernel_id) {
+            return Err(RusticolError::integrity(format!(
+                "eager direct prepared catalog repeats kernel {}",
+                artifact.kernel_id
+            )));
+        }
+        let kernel = plan.kernels.get(&artifact.kernel_id).ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "eager direct prepared catalog references unknown kernel {}",
+                artifact.kernel_id
+            ))
+        })?;
+        validate_callable_identity(kernel, artifact)?;
+        let application = match &artifact.application {
+            EagerDirectPreparedApplication::Symjit {
+                source_application,
+                descriptor,
+                expected_optimization_level,
+                expected_compression,
+            } => LoadedSymjitEagerDirectTable::load_prepared_application_bytes(
+                source_application,
+                descriptor,
+                artifact.display_path.clone(),
+                EAGER_DIRECT_SOURCE_APPLICATION_ABI,
+                EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+                EAGER_DIRECT_TABLE_BINDING_ABI,
+                *expected_optimization_level,
+                *expected_compression,
+            )?,
+            EagerDirectPreparedApplication::Native {
+                library,
+                function_name,
+                source_application_abi,
+                invocation_stride,
+                attachment_stride,
+                target_triple,
+                evaluator_state_sha256,
+                simd_lane_width,
+            } => LoadedSymjitEagerDirectTable::load_native_application(
+                Arc::clone(library),
+                function_name,
+                artifact.display_path.clone(),
+                source_application_abi,
+                *invocation_stride,
+                *attachment_stride,
+                count_u32(artifact.inputs.len(), "native eager input width")?,
+                artifact.output_component_count,
+                target_triple,
+                evaluator_state_sha256,
+                *simd_lane_width,
+            )?,
+        };
+        applications.insert(artifact.kernel_id, Arc::new(application));
+    }
+    Ok(applications)
+}
+
+fn plane_bindings(
+    layout: &DirectArenaLayout,
+    amplitude_count: usize,
+) -> RusticolResult<Vec<EagerDirectArenaPlaneBinding>> {
+    let capacity = layout
+        .component_count()
+        .checked_add(count_u32(amplitude_count, "amplitude planes")?)
+        .and_then(|count| count.checked_mul(2))
+        .ok_or_else(|| invalid("eager direct plane catalog overflows"))?;
+    let mut bindings = Vec::new();
+    bindings
+        .try_reserve_exact(capacity as usize)
+        .map_err(|error| invalid(format!("could not reserve eager direct planes: {error}")))?;
+    for component in 0..layout.component_count() {
+        bindings.push(EagerDirectArenaPlaneBinding::CurrentReal(component));
+        bindings.push(EagerDirectArenaPlaneBinding::CurrentImag(component));
+    }
+    for amplitude in 0..count_u32(amplitude_count, "amplitude planes")? {
+        bindings.push(EagerDirectArenaPlaneBinding::AmplitudeReal(amplitude));
+        bindings.push(EagerDirectArenaPlaneBinding::AmplitudeImag(amplitude));
+    }
+    Ok(bindings)
+}
+
+/// Reuse one already-allocated, event-pinned imaginary plane as the structural
+/// zero required by real-only complex P-kernel inputs.
+///
+/// `derive_event_layout` pins momenta, couplings, and parameters through the
+/// final event. Momentum and split coupling semantics are real-only, so their
+/// imaginary halves are initialized to zero and are never legal destinations.
+/// No extra plane or artifact-ABI entry is required.
+fn shared_zero_plane_index(
+    sections: EagerPlanV3Sections<'_>,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    applications: &BTreeMap<u32, Arc<LoadedSymjitEagerDirectTable>>,
+) -> RusticolResult<Option<u32>> {
+    if !applications
+        .values()
+        .any(|application| application.is_symjit())
+    {
+        return Ok(None);
+    }
+    let physical_component = if let Some(momentum) = sections
+        .momenta
+        .iter()
+        .find(|momentum| momentum.component_count != 0)
+    {
+        Some(assigned_component(
+            layout,
+            catalog.momentum(momentum.momentum_slot_id)?,
+            0,
+        )?)
+    } else if let Some(coupling) = sections.couplings.first() {
+        Some(assigned_component(
+            layout,
+            catalog.coupling_real(coupling.coupling_id)?,
+            0,
+        )?)
+    } else {
+        None
+    };
+    physical_component
+        .map(|component| {
+            component
+                .checked_mul(2)
+                .and_then(|plane| plane.checked_add(1))
+                .ok_or_else(|| invalid("eager direct shared-zero plane id overflows"))
+        })
+        .transpose()
+}
+
+fn build_direct_schedule(
+    plan: &EagerExecutionPlan,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    applications: &BTreeMap<u32, Arc<LoadedSymjitEagerDirectTable>>,
+    shared_zero_plane_index: Option<u32>,
+    active_groups: Option<&[u32]>,
+) -> RusticolResult<DirectSchedule> {
+    validate_active_groups(plan, active_groups)?;
+    let mut factor_specs = Vec::new();
+    let mut stages = Vec::with_capacity(plan.stages.len());
+    for stage in &plan.stages {
+        stages.push(build_direct_stage(
+            plan,
+            stage,
+            catalog,
+            layout,
+            applications,
+            shared_zero_plane_index,
+            active_groups,
+            &mut factor_specs,
+        )?);
+    }
+    let (closure_calls, direct_closures) = build_direct_closures(
+        plan,
+        catalog,
+        layout,
+        applications,
+        shared_zero_plane_index,
+        active_groups,
+        &mut factor_specs,
+    )?;
+    let (
+        active_amplitude_indices,
+        active_reduction_group_indices,
+        active_reduction_entry_indices,
+        active_reduction_group_ids,
+    ) = selected_reduction_metadata(plan, active_groups);
+    Ok(DirectSchedule {
+        stages: stages.into_boxed_slice(),
+        closure_calls: closure_calls.into_boxed_slice(),
+        direct_closures: direct_closures.into_boxed_slice(),
+        factor_specs: factor_specs.into_boxed_slice(),
+        active_amplitude_indices: active_amplitude_indices.into_boxed_slice(),
+        active_reduction_group_indices: active_reduction_group_indices.into_boxed_slice(),
+        active_reduction_entry_indices: active_reduction_entry_indices.into_boxed_slice(),
+        active_reduction_group_ids: active_reduction_group_ids.into_boxed_slice(),
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_direct_stage(
+    plan: &EagerExecutionPlan,
+    stage: &EagerStagePlan,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    applications: &BTreeMap<u32, Arc<LoadedSymjitEagerDirectTable>>,
+    shared_zero_plane_index: Option<u32>,
+    active_groups: Option<&[u32]>,
+    factor_specs: &mut Vec<DirectFactorSpec>,
+) -> RusticolResult<DirectStage> {
+    let invocation_calls = build_invocation_calls(
+        plan,
+        stage,
+        catalog,
+        layout,
+        applications,
+        shared_zero_plane_index,
+        active_groups,
+        factor_specs,
+    )?;
+    let mut copies = Vec::new();
+    for copy in &stage.finalization_copies {
+        if !row_active(plan, copy.selector_domain_id, active_groups)? {
+            continue;
+        }
+        let (current_id, _) = stage_current_id(stage, copy.current)?;
+        let source = assigned_component(layout, catalog.current(current_id)?, 0)?;
+        let value_id = value_id_for_range(plan, copy.unpropagated)?;
+        let destination = assigned_component(layout, catalog.value(value_id)?, 0)?;
+        copies.push(DirectCopy {
+            source_component_base: source,
+            destination_component_base: destination,
+            component_count: count_u32(copy.current.len, "finalization copy width")?,
+        });
+    }
+    let finalization_calls = build_finalization_calls(
+        plan,
+        stage,
+        catalog,
+        layout,
+        applications,
+        shared_zero_plane_index,
+        active_groups,
+        factor_specs,
+    )?;
+    Ok(DirectStage {
+        stage_index: stage.stage_index,
+        invocation_calls: invocation_calls.into_boxed_slice(),
+        unpropagated_copies: copies.into_boxed_slice(),
+        finalization_calls: finalization_calls.into_boxed_slice(),
+    })
+}
+
+fn stage_current_id(
+    stage: &EagerStagePlan,
+    range: ComponentRange,
+) -> RusticolResult<(u32, ComponentRange)> {
+    stage
+        .finalizations
+        .iter()
+        .find(|item| item.current == range)
+        .map(|item| (item.row.current_id, item.current))
+        .or_else(|| {
+            stage.attachments.iter().find_map(|item| {
+                (item.current == range).then_some((item.row.result_current_id, item.current))
+            })
+        })
+        .ok_or_else(|| RusticolError::internal("eager direct stage lost a compact current range"))
+}
+
+fn value_id_for_range(plan: &EagerExecutionPlan, range: ComponentRange) -> RusticolResult<u32> {
+    plan.values
+        .id_for_range(range, "eager direct finalization value")
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_invocation_calls(
+    plan: &EagerExecutionPlan,
+    stage: &EagerStagePlan,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    applications: &BTreeMap<u32, Arc<LoadedSymjitEagerDirectTable>>,
+    shared_zero_plane_index: Option<u32>,
+    active_groups: Option<&[u32]>,
+    factor_specs: &mut Vec<DirectFactorSpec>,
+) -> RusticolResult<Vec<DirectCall>> {
+    let mut calls = Vec::new();
+    let mut written_currents = BTreeSet::new();
+    let mut cursor = 0usize;
+    while cursor < stage.invocations.len() {
+        let kernel_id = stage.invocations[cursor].row.kernel_id;
+        let stop = stage.invocations[cursor..]
+            .iter()
+            .position(|row| row.row.kernel_id != kernel_id)
+            .map_or(stage.invocations.len(), |offset| cursor + offset);
+        let kernel = plan.kernels.get(&kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!("eager direct schedule lost kernel {kernel_id}"))
+        })?;
+        let kernel_shared_zero_plane_index = shared_zero_plane_index.filter(|_| {
+            applications
+                .get(&kernel_id)
+                .is_some_and(|application| application.is_symjit())
+        });
+        let mut invocation_bytes = Vec::new();
+        let mut attachment_bytes = Vec::new();
+        let mut local_attachment_count = 0_u32;
+        for invocation in &stage.invocations[cursor..stop] {
+            if !row_active(plan, invocation.selector_domain_id, active_groups)? {
+                continue;
+            }
+            let retained = stage.attachments[invocation.attachment_range.clone()]
+                .iter()
+                .map(|attachment| row_active(plan, attachment.selector_domain_id, active_groups))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let active_attachment_count = retained.iter().filter(|active| **active).count();
+            if active_attachment_count == 0 {
+                continue;
+            }
+            encode_invocation_inputs(
+                &mut invocation_bytes,
+                invocation,
+                &kernel.inputs,
+                catalog,
+                layout,
+                kernel_shared_zero_plane_index,
+            )?;
+            push_u32(&mut invocation_bytes, local_attachment_count);
+            push_u32(
+                &mut invocation_bytes,
+                count_u32(active_attachment_count, "active invocation attachments")?,
+            );
+            for (attachment, active) in stage.attachments[invocation.attachment_range.clone()]
+                .iter()
+                .zip(retained)
+            {
+                if !active {
+                    continue;
+                }
+                encode_current_destination(
+                    &mut attachment_bytes,
+                    attachment.row.result_current_id,
+                    kernel.output_component_count,
+                    catalog,
+                    layout,
+                )?;
+                let factor_index = count_u32(factor_specs.len(), "eager direct factors")?;
+                factor_specs.push(DirectFactorSpec {
+                    factor: EagerComplex64::new(
+                        attachment.row.factor_real,
+                        attachment.row.factor_imag,
+                    ),
+                    coupling_slot_id: Some(invocation.row.coupling_slot_id),
+                    output_factor_source: invocation.row.output_factor_source,
+                });
+                push_u32(&mut attachment_bytes, factor_index);
+                push_u32(
+                    &mut attachment_bytes,
+                    u32::from(!written_currents.insert(attachment.row.result_current_id)),
+                );
+                local_attachment_count = local_attachment_count
+                    .checked_add(1)
+                    .ok_or_else(|| invalid("eager direct attachment count overflows"))?;
+            }
+        }
+        if !invocation_bytes.is_empty() {
+            calls.push(load_call(
+                applications,
+                kernel_id,
+                invocation_bytes,
+                attachment_bytes,
+            )?);
+        }
+        cursor = stop;
+    }
+    Ok(calls)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_finalization_calls(
+    plan: &EagerExecutionPlan,
+    stage: &EagerStagePlan,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    applications: &BTreeMap<u32, Arc<LoadedSymjitEagerDirectTable>>,
+    shared_zero_plane_index: Option<u32>,
+    active_groups: Option<&[u32]>,
+    factor_specs: &mut Vec<DirectFactorSpec>,
+) -> RusticolResult<Vec<DirectCall>> {
+    let mut calls = Vec::new();
+    let mut cursor = 0usize;
+    while cursor < stage.finalizations.len() {
+        let kernel_id = stage.finalizations[cursor].row.kernel_id;
+        let stop = stage.finalizations[cursor..]
+            .iter()
+            .position(|row| row.row.kernel_id != kernel_id)
+            .map_or(stage.finalizations.len(), |offset| cursor + offset);
+        let kernel = plan.kernels.get(&kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!("eager direct finalization lost kernel {kernel_id}"))
+        })?;
+        if kernel.role != EagerKernelRole::Finalization {
+            return Err(RusticolError::integrity(format!(
+                "eager direct finalization kernel {kernel_id} has role {:?}",
+                kernel.role
+            )));
+        }
+        let kernel_shared_zero_plane_index = shared_zero_plane_index.filter(|_| {
+            applications
+                .get(&kernel_id)
+                .is_some_and(|application| application.is_symjit())
+        });
+        let mut invocation_bytes = Vec::new();
+        let mut attachment_bytes = Vec::new();
+        let mut attachment_count = 0_u32;
+        for item in &stage.finalizations[cursor..stop] {
+            if !row_active(plan, item.selector_domain_id, active_groups)? {
+                continue;
+            }
+            encode_finalization_inputs(
+                &mut invocation_bytes,
+                item,
+                &kernel.inputs,
+                catalog,
+                layout,
+                kernel_shared_zero_plane_index,
+            )?;
+            push_u32(&mut invocation_bytes, attachment_count);
+            push_u32(&mut invocation_bytes, 1);
+            let propagated = item.propagated.ok_or_else(|| {
+                RusticolError::internal("eager direct finalization lost propagated output")
+            })?;
+            let value_id = value_id_for_range(plan, propagated)?;
+            encode_value_destination(
+                &mut attachment_bytes,
+                value_id,
+                kernel.output_component_count,
+                catalog,
+                layout,
+            )?;
+            let factor_index = count_u32(factor_specs.len(), "eager direct factors")?;
+            factor_specs.push(DirectFactorSpec {
+                factor: EagerComplex64::new(1.0, 0.0),
+                coupling_slot_id: None,
+                output_factor_source: EAGER_OUTPUT_FACTOR_NONE,
+            });
+            push_u32(&mut attachment_bytes, factor_index);
+            push_u32(&mut attachment_bytes, 0);
+            attachment_count = attachment_count
+                .checked_add(1)
+                .ok_or_else(|| invalid("eager direct finalization count overflows"))?;
+        }
+        if !invocation_bytes.is_empty() {
+            calls.push(load_call(
+                applications,
+                kernel_id,
+                invocation_bytes,
+                attachment_bytes,
+            )?);
+        }
+        cursor = stop;
+    }
+    Ok(calls)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_direct_closures(
+    plan: &EagerExecutionPlan,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    applications: &BTreeMap<u32, Arc<LoadedSymjitEagerDirectTable>>,
+    shared_zero_plane_index: Option<u32>,
+    active_groups: Option<&[u32]>,
+    factor_specs: &mut Vec<DirectFactorSpec>,
+) -> RusticolResult<(Vec<DirectCall>, Vec<DirectCoefficientClosure>)> {
+    let mut calls = Vec::new();
+    let mut written_amplitudes = BTreeSet::new();
+    let mut cursor = 0usize;
+    while cursor < plan.closures.len() {
+        let kernel_id = plan.closures[cursor].row.kernel_id;
+        let stop = plan.closures[cursor..]
+            .iter()
+            .position(|row| row.row.kernel_id != kernel_id)
+            .map_or(plan.closures.len(), |offset| cursor + offset);
+        let kernel = plan.kernels.get(&kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!("eager direct closure lost kernel {kernel_id}"))
+        })?;
+        if kernel.role != EagerKernelRole::Closure {
+            return Err(RusticolError::integrity(format!(
+                "eager direct closure kernel {kernel_id} has role {:?}",
+                kernel.role
+            )));
+        }
+        let kernel_shared_zero_plane_index = shared_zero_plane_index.filter(|_| {
+            applications
+                .get(&kernel_id)
+                .is_some_and(|application| application.is_symjit())
+        });
+        let mut invocation_bytes = Vec::new();
+        let mut attachment_bytes = Vec::new();
+        let mut attachment_count = 0_u32;
+        for item in &plan.closures[cursor..stop] {
+            if !row_active(plan, item.selector_domain_id, active_groups)? {
+                continue;
+            }
+            encode_closure_inputs(
+                &mut invocation_bytes,
+                item,
+                &kernel.inputs,
+                catalog,
+                layout,
+                kernel_shared_zero_plane_index,
+            )?;
+            push_u32(&mut invocation_bytes, attachment_count);
+            push_u32(&mut invocation_bytes, 1);
+            encode_amplitude_destination(
+                &mut attachment_bytes,
+                item.row.amplitude_index,
+                kernel.output_component_count,
+                layout,
+            )?;
+            let factor_index = count_u32(factor_specs.len(), "eager direct factors")?;
+            factor_specs.push(DirectFactorSpec {
+                factor: EagerComplex64::new(item.row.factor_real, item.row.factor_imag),
+                coupling_slot_id: Some(item.row.coupling_slot_id),
+                output_factor_source: item.row.output_factor_source,
+            });
+            push_u32(&mut attachment_bytes, factor_index);
+            push_u32(
+                &mut attachment_bytes,
+                u32::from(!written_amplitudes.insert(item.row.amplitude_index)),
+            );
+            attachment_count = attachment_count
+                .checked_add(1)
+                .ok_or_else(|| invalid("eager direct closure count overflows"))?;
+        }
+        if !invocation_bytes.is_empty() {
+            calls.push(load_call(
+                applications,
+                kernel_id,
+                invocation_bytes,
+                attachment_bytes,
+            )?);
+        }
+        cursor = stop;
+    }
+
+    let mut direct = Vec::new();
+    for item in &plan.direct_closures {
+        if !row_active(plan, item.selector_domain_id, active_groups)? {
+            continue;
+        }
+        let left_id = value_id_for_range(plan, item.left_values)?;
+        let right_id = value_id_for_range(plan, item.right_values)?;
+        direct.push(DirectCoefficientClosure {
+            left_component_base: assigned_component(layout, catalog.value(left_id)?, 0)?,
+            right_component_base: assigned_component(layout, catalog.value(right_id)?, 0)?,
+            component_count: count_u32(item.coefficients.len(), "direct closure width")?,
+            amplitude_index: item.row.amplitude_index,
+            factor: AccumulationFactor::from_parts(item.row.factor_real, item.row.factor_imag),
+            initializes_amplitude: written_amplitudes.insert(item.row.amplitude_index),
+            coefficients: item.coefficients.clone().into_boxed_slice(),
+        });
+    }
+    Ok((calls, direct))
+}
+
+fn load_call(
+    applications: &BTreeMap<u32, Arc<LoadedSymjitEagerDirectTable>>,
+    kernel_id: u32,
+    invocation_bytes: Vec<u8>,
+    attachment_bytes: Vec<u8>,
+) -> RusticolResult<DirectCall> {
+    let application = applications.get(&kernel_id).cloned().ok_or_else(|| {
+        RusticolError::compatibility(format!(
+            "eager direct execution has no prepared table callable for kernel {kernel_id}"
+        ))
+    })?;
+    let rows = application.load_rows(invocation_bytes, attachment_bytes)?;
+    Ok(DirectCall {
+        kernel_id,
+        application,
+        rows,
+    })
+}
+
+fn encode_invocation_inputs(
+    output: &mut Vec<u8>,
+    invocation: &ScheduledInvocation,
+    descriptors: &[EagerKernelInput],
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    shared_zero_plane_index: Option<u32>,
+) -> RusticolResult<()> {
+    encode_inputs(
+        output,
+        descriptors,
+        |descriptor| match descriptor {
+            EagerKernelInput::FirstCurrentComponent(component) => Ok((
+                catalog.value(invocation.row.left_value_slot_id)?,
+                *component,
+                false,
+            )),
+            EagerKernelInput::SecondCurrentComponent(component) => Ok((
+                catalog.value(invocation.row.right_value_slot_id)?,
+                *component,
+                false,
+            )),
+            EagerKernelInput::FirstMomentumComponent(component) => Ok((
+                catalog.momentum(invocation.row.left_momentum_slot_id)?,
+                *component,
+                true,
+            )),
+            EagerKernelInput::SecondMomentumComponent(component) => Ok((
+                catalog.momentum(invocation.row.right_momentum_slot_id)?,
+                *component,
+                true,
+            )),
+            EagerKernelInput::CouplingReal => Ok((
+                catalog.coupling_real(invocation.row.coupling_slot_id)?,
+                0,
+                true,
+            )),
+            EagerKernelInput::CouplingImag => Ok((
+                catalog.coupling_imag(invocation.row.coupling_slot_id)?,
+                0,
+                true,
+            )),
+            EagerKernelInput::ModelParameter(parameter) => {
+                Ok((catalog.parameter(*parameter)?, 0, false))
+            }
+        },
+        layout,
+        shared_zero_plane_index,
+    )
+}
+
+fn encode_finalization_inputs(
+    output: &mut Vec<u8>,
+    item: &ScheduledFinalization,
+    descriptors: &[EagerKernelInput],
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    shared_zero_plane_index: Option<u32>,
+) -> RusticolResult<()> {
+    encode_inputs(
+        output,
+        descriptors,
+        |descriptor| match descriptor {
+            EagerKernelInput::FirstCurrentComponent(component) => {
+                Ok((catalog.current(item.row.current_id)?, *component, false))
+            }
+            EagerKernelInput::FirstMomentumComponent(component) => Ok((
+                catalog.momentum(item.row.momentum_slot_id)?,
+                *component,
+                true,
+            )),
+            EagerKernelInput::ModelParameter(parameter) => {
+                Ok((catalog.parameter(*parameter)?, 0, false))
+            }
+            _ => Err(RusticolError::integrity(
+                "eager direct finalization has an invalid semantic input",
+            )),
+        },
+        layout,
+        shared_zero_plane_index,
+    )
+}
+
+fn encode_closure_inputs(
+    output: &mut Vec<u8>,
+    item: &ScheduledClosure,
+    descriptors: &[EagerKernelInput],
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    shared_zero_plane_index: Option<u32>,
+) -> RusticolResult<()> {
+    encode_inputs(
+        output,
+        descriptors,
+        |descriptor| match descriptor {
+            EagerKernelInput::FirstCurrentComponent(component) => Ok((
+                catalog.value(item.row.left_value_slot_id)?,
+                *component,
+                false,
+            )),
+            EagerKernelInput::SecondCurrentComponent(component) => Ok((
+                catalog.value(item.row.right_value_slot_id)?,
+                *component,
+                false,
+            )),
+            EagerKernelInput::CouplingReal => {
+                Ok((catalog.coupling_real(item.row.coupling_slot_id)?, 0, true))
+            }
+            EagerKernelInput::CouplingImag => {
+                Ok((catalog.coupling_imag(item.row.coupling_slot_id)?, 0, true))
+            }
+            EagerKernelInput::ModelParameter(parameter) => {
+                Ok((catalog.parameter(*parameter)?, 0, false))
+            }
+            _ => Err(RusticolError::integrity(
+                "eager direct closure has an invalid semantic input",
+            )),
+        },
+        layout,
+        shared_zero_plane_index,
+    )
+}
+
+fn encode_inputs(
+    output: &mut Vec<u8>,
+    descriptors: &[EagerKernelInput],
+    mut resolve: impl FnMut(&EagerKernelInput) -> RusticolResult<(u32, u32, bool)>,
+    layout: &DirectArenaLayout,
+    shared_zero_plane_index: Option<u32>,
+) -> RusticolResult<()> {
+    for descriptor in descriptors {
+        let (semantic, component, real_only) = resolve(descriptor)?;
+        let physical = assigned_component(layout, semantic, component)?;
+        if let Some(zero_plane) = shared_zero_plane_index.filter(|_| real_only) {
+            push_current_real_with_zero(output, physical, zero_plane)?;
+        } else {
+            push_current_plane_pair(output, physical)?;
+        }
+    }
+    Ok(())
+}
+
+fn encode_current_destination(
+    output: &mut Vec<u8>,
+    current_id: u32,
+    width: u32,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+) -> RusticolResult<()> {
+    let semantic = catalog.current(current_id)?;
+    for component in 0..width {
+        push_current_plane_pair(output, assigned_component(layout, semantic, component)?)?;
+    }
+    Ok(())
+}
+
+fn encode_value_destination(
+    output: &mut Vec<u8>,
+    value_id: u32,
+    width: u32,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+) -> RusticolResult<()> {
+    let semantic = catalog.value(value_id)?;
+    for component in 0..width {
+        push_current_plane_pair(output, assigned_component(layout, semantic, component)?)?;
+    }
+    Ok(())
+}
+
+fn encode_amplitude_destination(
+    output: &mut Vec<u8>,
+    amplitude_index: u32,
+    width: u32,
+    layout: &DirectArenaLayout,
+) -> RusticolResult<()> {
+    if width != 1 {
+        return Err(RusticolError::integrity(
+            "eager direct closure output width must be one",
+        ));
+    }
+    let base = layout
+        .component_count()
+        .checked_mul(2)
+        .and_then(|value| value.checked_add(amplitude_index.checked_mul(2)?))
+        .ok_or_else(|| invalid("eager direct amplitude plane id overflows"))?;
+    push_u32(output, base);
+    push_u32(
+        output,
+        base.checked_add(1)
+            .ok_or_else(|| invalid("eager direct amplitude plane id overflows"))?,
+    );
+    Ok(())
+}
+
+fn push_current_plane_pair(output: &mut Vec<u8>, component: u32) -> RusticolResult<()> {
+    let real = component
+        .checked_mul(2)
+        .ok_or_else(|| invalid("eager direct current plane id overflows"))?;
+    push_u32(output, real);
+    push_u32(
+        output,
+        real.checked_add(1)
+            .ok_or_else(|| invalid("eager direct current plane id overflows"))?,
+    );
+    Ok(())
+}
+
+fn push_current_real_with_zero(
+    output: &mut Vec<u8>,
+    component: u32,
+    zero_plane: u32,
+) -> RusticolResult<()> {
+    let real = component
+        .checked_mul(2)
+        .ok_or_else(|| invalid("eager direct current plane id overflows"))?;
+    push_u32(output, real);
+    push_u32(output, zero_plane);
+    Ok(())
+}
+
+#[allow(clippy::type_complexity)]
+fn selected_reduction_metadata(
+    plan: &EagerExecutionPlan,
+    active_groups: Option<&[u32]>,
+) -> (Vec<usize>, Vec<usize>, Vec<usize>, Vec<u32>) {
+    let group_active =
+        |group_id: u32| active_groups.is_none_or(|groups| groups.binary_search(&group_id).is_ok());
+    let active_reduction_group_indices = plan
+        .reduction_groups
+        .iter()
+        .enumerate()
+        .filter_map(|(index, group)| group_active(group.coherent_group_id).then_some(index))
+        .collect::<Vec<_>>();
+    let mut active_amplitude_indices = active_reduction_group_indices
+        .iter()
+        .flat_map(|index| {
+            plan.reduction_groups[*index]
+                .amplitude_indices
+                .iter()
+                .copied()
+        })
+        .map(|index| index as usize)
+        .collect::<Vec<_>>();
+    active_amplitude_indices.sort_unstable();
+    active_amplitude_indices.dedup();
+    let active_reduction_entry_indices = plan
+        .reduction_entries
+        .iter()
+        .enumerate()
+        .filter_map(|(index, entry)| {
+            let left = entry.left_group_index as usize;
+            let right = entry.right_group_index as usize;
+            (active_reduction_group_indices.binary_search(&left).is_ok()
+                && active_reduction_group_indices.binary_search(&right).is_ok())
+            .then_some(index)
+        })
+        .collect::<Vec<_>>();
+    let active_reduction_group_ids = active_reduction_group_indices
+        .iter()
+        .map(|index| plan.reduction_groups[*index].coherent_group_id)
+        .collect();
+    (
+        active_amplitude_indices,
+        active_reduction_group_indices,
+        active_reduction_entry_indices,
+        active_reduction_group_ids,
+    )
+}
+
+fn validate_schedule_calls(
+    schedule: &DirectSchedule,
+    workspace: &mut EagerDirectTableWorkspace,
+    shared_zero_plane_index: Option<u32>,
+    point_count: u32,
+) -> RusticolResult<()> {
+    if let Some(zero_component) = shared_zero_plane_index.map(|plane| plane / 2) {
+        for stage in &schedule.stages {
+            for copy in &stage.unpropagated_copies {
+                let destination_stop = copy
+                    .destination_component_base
+                    .checked_add(copy.component_count)
+                    .ok_or_else(|| invalid("eager direct copy destination range overflows"))?;
+                if (copy.destination_component_base..destination_stop).contains(&zero_component) {
+                    return Err(RusticolError::integrity(format!(
+                        "eager direct copy destination range {}..{destination_stop} overlaps \
+                         read-only shared-zero component {zero_component}",
+                        copy.destination_component_base
+                    )));
+                }
+            }
+        }
+    }
+    for stage in &schedule.stages {
+        for call in stage
+            .invocation_calls
+            .iter()
+            .chain(stage.finalization_calls.iter())
+        {
+            call.application
+                .validate_call(&call.rows, workspace, 0, point_count)?;
+        }
+    }
+    for call in &schedule.closure_calls {
+        call.application
+            .validate_call(&call.rows, workspace, 0, point_count)?;
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn execute_contiguous_tile(
+    plan: &EagerExecutionPlan,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    workspace: &mut EagerDirectTableWorkspace,
+    initial_value_slots: &[u32],
+    value_ranges: &[ComponentRange],
+    momentum_ranges: &[ComponentRange],
+    elide_structural_zero_fills: bool,
+    schedule: &DirectSchedule,
+    closure_scratch: &mut [EagerComplex64],
+    source_point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    initial_values: &[EagerComplex64],
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+) -> RusticolResult<()> {
+    execute_tile(
+        plan,
+        catalog,
+        layout,
+        workspace,
+        initial_value_slots,
+        value_ranges,
+        momentum_ranges,
+        elide_structural_zero_fills,
+        schedule,
+        closure_scratch,
+        source_point_count,
+        tile_points,
+        initial_values,
+        momenta,
+        model_parameters,
+        |point| tile_start + point,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn execute_indexed_tile(
+    plan: &EagerExecutionPlan,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    workspace: &mut EagerDirectTableWorkspace,
+    initial_value_slots: &[u32],
+    value_ranges: &[ComponentRange],
+    momentum_ranges: &[ComponentRange],
+    elide_structural_zero_fills: bool,
+    schedule: &DirectSchedule,
+    closure_scratch: &mut [EagerComplex64],
+    source_point_count: usize,
+    point_indices: &[usize],
+    initial_values: &[EagerComplex64],
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+) -> RusticolResult<()> {
+    execute_tile(
+        plan,
+        catalog,
+        layout,
+        workspace,
+        initial_value_slots,
+        value_ranges,
+        momentum_ranges,
+        elide_structural_zero_fills,
+        schedule,
+        closure_scratch,
+        source_point_count,
+        point_indices.len(),
+        initial_values,
+        momenta,
+        model_parameters,
+        |point| point_indices[point],
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn execute_tile(
+    plan: &EagerExecutionPlan,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    workspace: &mut EagerDirectTableWorkspace,
+    initial_value_slots: &[u32],
+    value_ranges: &[ComponentRange],
+    momentum_ranges: &[ComponentRange],
+    elide_structural_zero_fills: bool,
+    schedule: &DirectSchedule,
+    closure_scratch: &mut [EagerComplex64],
+    source_point_count: usize,
+    tile_points: usize,
+    initial_values: &[EagerComplex64],
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+    source_point: impl Fn(usize) -> usize,
+) -> RusticolResult<()> {
+    let point_count = count_u32(tile_points, "active point tile")?;
+    workspace.begin_tile(point_count)?;
+    workspace.clear_amplitude_active(0, count_u32(plan.amplitude_count, "amplitudes")?)?;
+    fill_tile_inputs(
+        plan,
+        catalog,
+        layout,
+        workspace,
+        initial_value_slots,
+        value_ranges,
+        momentum_ranges,
+        elide_structural_zero_fills,
+        source_point_count,
+        tile_points,
+        initial_values,
+        momenta,
+        model_parameters,
+        source_point,
+    )?;
+    fill_schedule_factors(plan, schedule, workspace, model_parameters)?;
+    execute_schedule(schedule, workspace, closure_scratch, point_count)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn fill_contiguous_tile_inputs(
+    plan: &EagerExecutionPlan,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    workspace: &mut EagerDirectTableWorkspace,
+    initial_value_slots: &[u32],
+    value_ranges: &[ComponentRange],
+    momentum_ranges: &[ComponentRange],
+    elide_structural_zero_fills: bool,
+    source_point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    initial_values: &[EagerComplex64],
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+) -> RusticolResult<()> {
+    fill_tile_inputs(
+        plan,
+        catalog,
+        layout,
+        workspace,
+        initial_value_slots,
+        value_ranges,
+        momentum_ranges,
+        elide_structural_zero_fills,
+        source_point_count,
+        tile_points,
+        initial_values,
+        momenta,
+        model_parameters,
+        |point| tile_start + point,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn fill_tile_inputs(
+    _plan: &EagerExecutionPlan,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+    workspace: &mut EagerDirectTableWorkspace,
+    initial_value_slots: &[u32],
+    value_ranges: &[ComponentRange],
+    momentum_ranges: &[ComponentRange],
+    elide_structural_zero_fills: bool,
+    source_point_count: usize,
+    tile_points: usize,
+    initial_values: &[EagerComplex64],
+    momenta: &[f64],
+    _model_parameters: &[EagerComplex64],
+    source_point: impl Fn(usize) -> usize,
+) -> RusticolResult<()> {
+    let stride = workspace.arena().point_stride() as usize;
+    {
+        let (real, imaginary, _, _) = workspace.split_arena_slices_mut();
+        for &slot in initial_value_slots {
+            let range = value_ranges[slot as usize];
+            let semantic = catalog.value(slot)?;
+            for component in 0..range.len {
+                let target = assigned_component(
+                    layout,
+                    semantic,
+                    count_u32(component, "initial value component")?,
+                )? as usize
+                    * stride;
+                let source = (range.start + component) * source_point_count;
+                for point in 0..tile_points {
+                    let value = initial_values[source + source_point(point)];
+                    real[target + point] = value.re;
+                    imaginary[target + point] = value.im;
+                }
+            }
+        }
+        for (slot, range) in momentum_ranges.iter().copied().enumerate() {
+            let semantic = catalog.momentum(count_u32(slot, "momentum slot")?)?;
+            for component in 0..range.len {
+                let target = assigned_component(
+                    layout,
+                    semantic,
+                    count_u32(component, "momentum component")?,
+                )? as usize
+                    * stride;
+                let source = (range.start + component) * source_point_count;
+                for point in 0..tile_points {
+                    real[target + point] = momenta[source + source_point(point)];
+                }
+                if !elide_structural_zero_fills {
+                    imaginary[target..target + tile_points].fill(0.0);
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn fill_input_plane(
+    real: &mut [f64],
+    imaginary: &mut [f64],
+    stride: usize,
+    component: u32,
+    points: usize,
+    value_re: f64,
+    value_im: f64,
+) {
+    let start = component as usize * stride;
+    real[start..start + points].fill(value_re);
+    imaginary[start..start + points].fill(value_im);
+}
+
+fn fill_real_input_plane(
+    real: &mut [f64],
+    stride: usize,
+    component: u32,
+    points: usize,
+    value: f64,
+) {
+    let start = component as usize * stride;
+    real[start..start + points].fill(value);
+}
+
+fn fill_schedule_factors(
+    plan: &EagerExecutionPlan,
+    schedule: &DirectSchedule,
+    workspace: &mut EagerDirectTableWorkspace,
+    model_parameters: &[EagerComplex64],
+) -> RusticolResult<()> {
+    let (factor_re, factor_im) = workspace.factors_mut();
+    if schedule.factor_specs.len() > factor_re.len() {
+        return Err(RusticolError::internal(
+            "eager direct selected factors exceed the persistent catalog",
+        ));
+    }
+    for (index, spec) in schedule.factor_specs.iter().copied().enumerate() {
+        let scale = if let Some(coupling_slot_id) = spec.coupling_slot_id {
+            let coupling = resolve_coupling(
+                *plan
+                    .couplings
+                    .get(coupling_slot_id as usize)
+                    .ok_or_else(|| {
+                        RusticolError::internal("eager direct factor lost its coupling")
+                    })?,
+                model_parameters,
+            );
+            match spec.output_factor_source {
+                EAGER_OUTPUT_FACTOR_NONE => 1.0,
+                EAGER_OUTPUT_FACTOR_COUPLING_REAL => coupling.re,
+                EAGER_OUTPUT_FACTOR_COUPLING_IMAG => coupling.im,
+                _ => {
+                    return Err(RusticolError::integrity(
+                        "eager direct factor has an invalid output-factor source",
+                    ));
+                }
+            }
+        } else {
+            if spec.output_factor_source != EAGER_OUTPUT_FACTOR_NONE {
+                return Err(RusticolError::integrity(
+                    "constant eager direct factor has a dynamic source",
+                ));
+            }
+            1.0
+        };
+        factor_re[index] = spec.factor.re * scale;
+        factor_im[index] = spec.factor.im * scale;
+    }
+    Ok(())
+}
+
+fn execute_schedule(
+    schedule: &DirectSchedule,
+    workspace: &mut EagerDirectTableWorkspace,
+    closure_scratch: &mut [EagerComplex64],
+    point_count: u32,
+) -> RusticolResult<()> {
+    for stage in &schedule.stages {
+        execute_calls(&stage.invocation_calls, workspace, point_count)?;
+        execute_copies(&stage.unpropagated_copies, workspace, point_count);
+        execute_calls(&stage.finalization_calls, workspace, point_count)?;
+    }
+    execute_calls(&schedule.closure_calls, workspace, point_count)?;
+    execute_direct_coefficient_closures(
+        &schedule.direct_closures,
+        workspace,
+        closure_scratch,
+        point_count as usize,
+    );
+    Ok(())
+}
+
+fn execute_schedule_profiled(
+    schedule: &DirectSchedule,
+    workspace: &mut EagerDirectTableWorkspace,
+    closure_scratch: &mut [EagerComplex64],
+    point_count: u32,
+    profile: &mut super::EagerExecutionProfile,
+) -> RusticolResult<()> {
+    for stage in &schedule.stages {
+        let phase = Instant::now();
+        execute_calls(&stage.invocation_calls, workspace, point_count)?;
+        profile.kernel_call += phase.elapsed();
+        profile.backend_call_count = profile
+            .backend_call_count
+            .saturating_add(stage.invocation_calls.len() as u64);
+
+        let phase = Instant::now();
+        execute_copies(&stage.unpropagated_copies, workspace, point_count);
+        profile.invocation_scatter += phase.elapsed();
+
+        let phase = Instant::now();
+        execute_calls(&stage.finalization_calls, workspace, point_count)?;
+        profile.finalization += phase.elapsed();
+        profile.backend_call_count = profile
+            .backend_call_count
+            .saturating_add(stage.finalization_calls.len() as u64);
+    }
+    let phase = Instant::now();
+    execute_calls(&schedule.closure_calls, workspace, point_count)?;
+    execute_direct_coefficient_closures(
+        &schedule.direct_closures,
+        workspace,
+        closure_scratch,
+        point_count as usize,
+    );
+    profile.closure += phase.elapsed();
+    profile.backend_call_count = profile
+        .backend_call_count
+        .saturating_add(schedule.closure_calls.len() as u64);
+    Ok(())
+}
+
+fn execute_calls(
+    calls: &[DirectCall],
+    workspace: &mut EagerDirectTableWorkspace,
+    point_count: u32,
+) -> RusticolResult<()> {
+    for call in calls {
+        // SAFETY: construction authenticated immutable rows, callable
+        // descriptors, plane catalogs, aliases, and the maximum point range.
+        unsafe {
+            call.application
+                .evaluate_validated_unchecked(&call.rows, workspace, 0, point_count)?;
+        }
+    }
+    Ok(())
+}
+
+fn execute_copies(
+    copies: &[DirectCopy],
+    workspace: &mut EagerDirectTableWorkspace,
+    point_count: u32,
+) {
+    let stride = workspace.arena().point_stride() as usize;
+    let points = point_count as usize;
+    let (real, imaginary, _, _) = workspace.split_arena_slices_mut();
+    for copy in copies {
+        for component in 0..copy.component_count as usize {
+            let source = (copy.source_component_base as usize + component) * stride;
+            let target = (copy.destination_component_base as usize + component) * stride;
+            for point in 0..points {
+                real[target + point] = real[source + point];
+                imaginary[target + point] = imaginary[source + point];
+            }
+        }
+    }
+}
+
+fn execute_direct_coefficient_closures(
+    closures: &[DirectCoefficientClosure],
+    workspace: &mut EagerDirectTableWorkspace,
+    contraction_scratch: &mut [EagerComplex64],
+    point_count: usize,
+) {
+    let stride = workspace.arena().point_stride() as usize;
+    debug_assert!(contraction_scratch.len() >= stride);
+    let (current_re, current_im, amplitude_re, amplitude_im) = workspace.split_arena_slices_mut();
+    for closure in closures {
+        let target = closure.amplitude_index as usize * stride;
+        contraction_scratch[..point_count].fill(EagerComplex64::new(0.0, 0.0));
+        // Component-outer, point-inner traversal keeps both source planes
+        // sequential. Each point still observes components in the original
+        // order, preserving its contraction summation semantics exactly.
+        for component in 0..closure.component_count as usize {
+            for (point, contraction) in contraction_scratch[..point_count].iter_mut().enumerate() {
+                let left = (closure.left_component_base as usize + component) * stride + point;
+                let right = (closure.right_component_base as usize + component) * stride + point;
+                *contraction += closure.coefficients[component]
+                    * EagerComplex64::new(current_re[left], current_im[left])
+                    * EagerComplex64::new(current_re[right], current_im[right]);
+            }
+        }
+        for (point, contraction) in contraction_scratch[..point_count]
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            let mut value =
+                EagerComplex64::new(amplitude_re[target + point], amplitude_im[target + point]);
+            if closure.initializes_amplitude {
+                closure.factor.assign(&mut value, contraction);
+            } else {
+                closure.factor.accumulate(&mut value, contraction);
+            }
+            amplitude_re[target + point] = value.re;
+            amplitude_im[target + point] = value.im;
+        }
+    }
+}
+
+fn reduce_full_tile(
+    plan: &EagerExecutionPlan,
+    workspace: &EagerDirectTableWorkspace,
+    groups: &mut [EagerComplex64],
+    reduced: &mut [f64],
+    point_count: usize,
+) {
+    let stride = workspace.arena().point_stride() as usize;
+    let (amplitude_re, amplitude_im) = workspace.arena().amplitude_slices();
+    for (group_index, group) in plan.reduction_groups.iter().enumerate() {
+        let target = group_index * stride;
+        let (first, remaining) = group
+            .amplitude_indices
+            .split_first()
+            .expect("validated eager reduction group");
+        let first_source = *first as usize * stride;
+        for point in 0..point_count {
+            groups[target + point] = EagerComplex64::new(
+                amplitude_re[first_source + point],
+                amplitude_im[first_source + point],
+            );
+        }
+        for amplitude in remaining {
+            let source = *amplitude as usize * stride;
+            for point in 0..point_count {
+                groups[target + point] +=
+                    EagerComplex64::new(amplitude_re[source + point], amplitude_im[source + point]);
+            }
+        }
+    }
+    let (first, remaining) = plan
+        .reduction_entries
+        .split_first()
+        .expect("validated eager reduction entries");
+    let left = first.left_group_index as usize * stride;
+    let right = first.right_group_index as usize * stride;
+    for point in 0..point_count {
+        reduced[point] =
+            (first.coefficient * groups[left + point] * groups[right + point].conj()).re;
+    }
+    for entry in remaining {
+        let left = entry.left_group_index as usize * stride;
+        let right = entry.right_group_index as usize * stride;
+        for point in 0..point_count {
+            reduced[point] +=
+                (entry.coefficient * groups[left + point] * groups[right + point].conj()).re;
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn reduce_selected_indexed_tile(
+    plan: &EagerExecutionPlan,
+    schedule: &DirectSchedule,
+    workspace: &EagerDirectTableWorkspace,
+    groups: &mut [EagerComplex64],
+    reduced: &mut [f64],
+    group_offsets: &[usize],
+    selected_groups: &[u32],
+    selected_group_weights: &[f64],
+    point_indices: &[usize],
+) -> RusticolResult<()> {
+    let stride = workspace.arena().point_stride() as usize;
+    let (amplitude_re, amplitude_im) = workspace.arena().amplitude_slices();
+    reduced[..point_indices.len()].fill(0.0);
+    for group_index in schedule.active_reduction_group_indices.iter().copied() {
+        let group = &plan.reduction_groups[group_index];
+        let target = group_index * stride;
+        let (first, remaining) = group
+            .amplitude_indices
+            .split_first()
+            .expect("validated eager reduction group");
+        let source = *first as usize * stride;
+        for point in 0..point_indices.len() {
+            groups[target + point] =
+                EagerComplex64::new(amplitude_re[source + point], amplitude_im[source + point]);
+        }
+        for amplitude in remaining {
+            let source = *amplitude as usize * stride;
+            for point in 0..point_indices.len() {
+                groups[target + point] +=
+                    EagerComplex64::new(amplitude_re[source + point], amplitude_im[source + point]);
+            }
+        }
+    }
+    for entry_index in schedule.active_reduction_entry_indices.iter().copied() {
+        let entry = &plan.reduction_entries[entry_index];
+        let left_group = entry.left_group_index as usize;
+        let right_group = entry.right_group_index as usize;
+        let left = left_group * stride;
+        let right = right_group * stride;
+        let left_position = schedule
+            .active_reduction_group_indices
+            .binary_search(&left_group)
+            .map_err(|_| RusticolError::internal("eager direct reduction lost left group"))?;
+        let right_position = schedule
+            .active_reduction_group_indices
+            .binary_search(&right_group)
+            .map_err(|_| RusticolError::internal("eager direct reduction lost right group"))?;
+        let left_id = schedule.active_reduction_group_ids[left_position];
+        let right_id = schedule.active_reduction_group_ids[right_position];
+        for (tile_point, original_point) in point_indices.iter().copied().enumerate() {
+            let selected =
+                &selected_groups[group_offsets[original_point]..group_offsets[original_point + 1]];
+            let left_weight = selected
+                .binary_search(&left_id)
+                .ok()
+                .map(|position| selected_group_weights[group_offsets[original_point] + position])
+                .ok_or_else(|| RusticolError::integrity("eager direct left weight is absent"))?;
+            let right_weight = selected
+                .binary_search(&right_id)
+                .ok()
+                .map(|position| selected_group_weights[group_offsets[original_point] + position])
+                .ok_or_else(|| RusticolError::integrity("eager direct right weight is absent"))?;
+            if left_weight.to_bits() != right_weight.to_bits() {
+                return Err(RusticolError::integrity(
+                    "eager direct selected contraction weights disagree",
+                ));
+            }
+            reduced[tile_point] += left_weight
+                * (entry.coefficient
+                    * groups[left + tile_point]
+                    * groups[right + tile_point].conj())
+                .re;
+        }
+    }
+    Ok(())
+}
+
+fn copy_amplitude_tile(
+    workspace: &EagerDirectTableWorkspace,
+    amplitudes: std::ops::Range<usize>,
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    output: &mut [EagerComplex64],
+) {
+    let stride = workspace.arena().point_stride() as usize;
+    let (real, imaginary) = workspace.arena().amplitude_slices();
+    for amplitude in amplitudes {
+        let source = amplitude * stride;
+        let target = amplitude * point_count + tile_start;
+        for point in 0..tile_points {
+            output[target + point] =
+                EagerComplex64::new(real[source + point], imaginary[source + point]);
+        }
+    }
+}
+
+fn copy_selected_amplitude_tile(
+    workspace: &EagerDirectTableWorkspace,
+    amplitude_indices: &[usize],
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    output: &mut [EagerComplex64],
+) {
+    let stride = workspace.arena().point_stride() as usize;
+    let (real, imaginary) = workspace.arena().amplitude_slices();
+    for amplitude in amplitude_indices {
+        let source = *amplitude * stride;
+        let target = *amplitude * point_count + tile_start;
+        for point in 0..tile_points {
+            output[target + point] =
+                EagerComplex64::new(real[source + point], imaginary[source + point]);
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn validate_io(
+    plan: &EagerExecutionPlan,
+    point_count: usize,
+    initial_values: &[EagerComplex64],
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+    amplitudes: Option<&[EagerComplex64]>,
+    reduced: Option<&[f64]>,
+) -> RusticolResult<()> {
+    if point_count == 0 {
+        return Err(invalid(
+            "eager direct evaluation requires at least one point",
+        ));
+    }
+    let points = count_u32(point_count, "point")?;
+    validate_component_buffer(
+        "initial values",
+        initial_values.len(),
+        plan.values.component_count,
+        points,
+    )?;
+    validate_component_buffer(
+        "momenta",
+        momenta.len(),
+        plan.momenta.component_count,
+        points,
+    )?;
+    if model_parameters.len() != plan.parameter_count
+        || model_parameters
+            .iter()
+            .any(|value| !value.re.is_finite() || !value.im.is_finite())
+    {
+        return Err(invalid(
+            "eager direct model parameters have an invalid shape or value",
+        ));
+    }
+    if let Some(amplitudes) = amplitudes {
+        let expected = plan
+            .amplitude_count
+            .checked_mul(point_count)
+            .ok_or_else(|| invalid("eager direct amplitude length overflows"))?;
+        if amplitudes.len() != expected {
+            return Err(invalid(format!(
+                "eager direct amplitudes have length {}, expected {expected}",
+                amplitudes.len()
+            )));
+        }
+    }
+    if reduced.is_some_and(|values| values.len() != point_count) {
+        return Err(invalid("eager direct reduced output has the wrong length"));
+    }
+    Ok(())
+}
+
+fn validate_point_selectors(
+    plan: &EagerExecutionPlan,
+    offsets: &[usize],
+    groups: &[u32],
+    weights: &[f64],
+    point_count: usize,
+) -> RusticolResult<()> {
+    if offsets.len() != point_count + 1
+        || offsets.first() != Some(&0)
+        || offsets.last() != Some(&groups.len())
+        || weights.len() != groups.len()
+        || offsets.windows(2).any(|pair| pair[0] > pair[1])
+    {
+        return Err(invalid("eager direct per-point selector shape is invalid"));
+    }
+    let known = plan.selector_domains.as_ref().ok_or_else(|| {
+        RusticolError::compatibility(
+            "eager direct per-point selectors require selector-domain metadata",
+        )
+    })?;
+    for point in 0..point_count {
+        let selected = &groups[offsets[point]..offsets[point + 1]];
+        if selected.windows(2).any(|pair| pair[0] >= pair[1]) {
+            return Err(invalid(format!(
+                "eager direct selector groups for point {point} are not sorted and unique"
+            )));
+        }
+        if let Some(unknown) = selected
+            .iter()
+            .find(|group| known.group_ids.binary_search(group).is_err())
+        {
+            return Err(invalid(format!(
+                "eager direct point {point} references unknown group {unknown}"
+            )));
+        }
+    }
+    if weights.iter().any(|weight| !weight.is_finite()) {
+        return Err(invalid("eager direct selector weights must be finite"));
+    }
+    Ok(())
+}
+
+fn direct_tile_capacity(
+    requested: u32,
+    workspace_bytes: usize,
+    current_planes: u32,
+    amplitude_planes: u32,
+    reduction_groups: u32,
+    symjit_scratch_planes: usize,
+) -> RusticolResult<u32> {
+    for candidate in (1..=requested).rev() {
+        let stride = crate::direct_arena::checked_aligned_point_stride(candidate)? as usize;
+        let scalar_planes = usize::try_from(
+            current_planes
+                .checked_add(amplitude_planes)
+                .and_then(|count| count.checked_mul(2))
+                .ok_or_else(|| invalid("eager direct workspace planes overflow"))?,
+        )
+        .map_err(|_| invalid("eager direct workspace plane count exceeds usize"))?
+        .checked_add(symjit_scratch_planes)
+        .ok_or_else(|| invalid("eager direct scratch plane count overflows"))?;
+        let bytes = scalar_planes
+            .checked_mul(stride)
+            .and_then(|count| count.checked_mul(size_of::<f64>()))
+            .and_then(|bytes| {
+                (reduction_groups as usize)
+                    .checked_mul(stride)
+                    .and_then(|count| count.checked_mul(size_of::<EagerComplex64>()))
+                    .and_then(|groups| bytes.checked_add(groups))
+            })
+            .and_then(|bytes| {
+                stride
+                    .checked_mul(size_of::<f64>())
+                    .and_then(|reduced| bytes.checked_add(reduced))
+            })
+            .ok_or_else(|| invalid("eager direct workspace size overflows"))?;
+        // The target may reduce batching, but must not reject a process whose
+        // minimum aligned tile is larger. Fill the already allocated pitch.
+        if bytes <= workspace_bytes
+            || candidate <= (crate::direct_arena::DIRECT_ARENA_ALIGNMENT / size_of::<f64>()) as u32
+        {
+            return Ok(candidate);
+        }
+    }
+    Err(invalid(
+        "eager Direct-Arena workspace cannot hold one active point",
+    ))
+}
+
+fn direct_workspace_bytes(
+    workspace: &EagerDirectTableWorkspace,
+    reduction_complex_count: usize,
+    reduced_count: usize,
+    factor_count: usize,
+) -> RusticolResult<usize> {
+    let symjit_workspace_bytes = workspace.symjit_workspace_bytes()?;
+    usize::try_from(workspace.arena().allocation_counters().requested_bytes)
+        .ok()
+        .and_then(|arena| {
+            reduction_complex_count
+                .checked_mul(size_of::<EagerComplex64>())
+                .and_then(|reduction| arena.checked_add(reduction))
+        })
+        .and_then(|bytes| {
+            reduced_count
+                .checked_mul(size_of::<f64>())
+                .and_then(|reduced| bytes.checked_add(reduced))
+        })
+        .and_then(|bytes| {
+            factor_count
+                .checked_mul(2 * size_of::<f64>())
+                .and_then(|factors| bytes.checked_add(factors))
+        })
+        .and_then(|bytes| bytes.checked_add(symjit_workspace_bytes))
+        .ok_or_else(|| invalid("eager direct workspace byte accounting overflows"))
+}
+
+#[cfg(all(test, feature = "f64-symjit", target_arch = "aarch64"))]
+mod tests {
+    use std::path::PathBuf;
+
+    use super::super::plan_v3_tests::Fixture;
+    use super::*;
+    use crate::engine::compile_symbolica_program_to_plane_application_bytes;
+    use crate::engine::count_allocations;
+    use crate::engine::symjit_eager_direct::eager_direct_descriptor_for_source_application_bytes;
+
+    fn source_and_descriptor() -> (Vec<u8>, Vec<u8>) {
+        let bytes = compile_symbolica_program_to_plane_application_bytes(
+            "([('add', ('temp', 0), [('param', 0), ('param', 1)], 0), \
+              ('assign', ('out', 0), ('temp', 0))], 3, [])",
+            3,
+            1,
+            2,
+            true,
+        )
+        .expect("compile eager whole-plan P-kernel");
+        let descriptor = eager_direct_descriptor_for_source_application_bytes(
+            &bytes,
+            3,
+            1,
+            std::path::Path::new("eager-whole-plan-test.symjit"),
+        )
+        .expect("encode table descriptor");
+        (bytes, descriptor)
+    }
+
+    fn runtime(fixture: &Fixture, source: &[u8], descriptor: &[u8]) -> EagerDirectExecutionRuntime {
+        runtime_with_point_tile(fixture, source, descriptor, 128)
+    }
+
+    fn runtime_with_point_tile(
+        fixture: &Fixture,
+        source: &[u8],
+        descriptor: &[u8],
+        point_tile_size: usize,
+    ) -> EagerDirectExecutionRuntime {
+        let inputs = [
+            EagerKernelInput::FirstCurrentComponent(0),
+            EagerKernelInput::SecondCurrentComponent(0),
+            EagerKernelInput::CouplingReal,
+        ];
+        let prepared = [
+            EagerDirectPreparedKernel {
+                kernel_id: 10,
+                role: EagerKernelRole::Vertex,
+                inputs: &inputs,
+                output_component_count: 1,
+                application: EagerDirectPreparedApplication::Symjit {
+                    source_application: source,
+                    descriptor,
+                    expected_optimization_level: 2,
+                    expected_compression: true,
+                },
+                display_path: PathBuf::from("whole-plan-vertex.symjit"),
+            },
+            EagerDirectPreparedKernel {
+                kernel_id: 11,
+                role: EagerKernelRole::Closure,
+                inputs: &inputs,
+                output_component_count: 1,
+                application: EagerDirectPreparedApplication::Symjit {
+                    source_application: source,
+                    descriptor,
+                    expected_optimization_level: 2,
+                    expected_compression: true,
+                },
+                display_path: PathBuf::from("whole-plan-closure.symjit"),
+            },
+        ];
+        EagerDirectExecutionRuntime::from_plan_v3_sections(
+            fixture.sections(),
+            &prepared,
+            EagerRuntimeOptions {
+                point_tile_size,
+                workspace_bytes: 16 * 1024 * 1024,
+            },
+        )
+        .expect("construct eager whole-plan Direct-Arena runtime")
+    }
+
+    fn inputs(points: usize) -> (Vec<EagerComplex64>, Vec<f64>) {
+        let mut values = vec![EagerComplex64::new(-91.0, 37.0); 3 * points];
+        for point in 0..points {
+            values[point] = EagerComplex64::new(1.0 + point as f64 / 8.0, -0.25 * point as f64);
+            values[points + point] =
+                EagerComplex64::new(3.0 + point as f64 / 4.0, 0.5 * point as f64);
+        }
+        let momenta = (0..12 * points).map(|index| index as f64 / 16.0).collect();
+        (values, momenta)
+    }
+
+    fn expected(values: &[EagerComplex64], points: usize, point: usize) -> (EagerComplex64, f64) {
+        let current = (values[point] + values[points + point]) * 15.0;
+        let amplitude = (current + values[point]) * 77.0;
+        let reduced = (EagerComplex64::new(221.0, 0.0) * amplitude * amplitude.conj()).re;
+        (amplitude, reduced)
+    }
+
+    fn assert_close(actual: f64, expected: f64, label: &str) {
+        let tolerance = 1.0e-15 + 1.0e-12 * actual.abs().max(expected.abs());
+        assert!(
+            (actual - expected).abs() <= tolerance,
+            "{label}: {actual:.17e} != {expected:.17e} (tolerance {tolerance:.3e})"
+        );
+    }
+
+    #[test]
+    fn whole_plan_preserves_all_required_tile_tails_and_empty_point_selectors() {
+        let fixture = Fixture::new();
+        let (source, descriptor) = source_and_descriptor();
+        let mut direct = runtime(&fixture, &source, &descriptor);
+        assert_eq!(direct.effective_point_tile_size(), 64);
+
+        for points in [1_usize, 7, 63, 64, 65, 127, 128, 129, 1023, 1024, 1025] {
+            let (values, momenta) = inputs(points);
+            let mut amplitudes = vec![EagerComplex64::new(-13.0, 29.0); points];
+            let mut reduced = vec![-1.0; points];
+            direct
+                .evaluate_into(
+                    points,
+                    &values,
+                    &momenta,
+                    &[],
+                    &mut amplitudes,
+                    &mut reduced,
+                )
+                .expect("evaluate eager whole-plan tail");
+            let mut totals_only = vec![-2.0; points];
+            direct
+                .evaluate_totals_into(points, &values, &momenta, &[], &mut totals_only)
+                .expect("evaluate eager totals-only tail");
+            for point in 0..points {
+                let (expected_amplitude, expected_reduced) = expected(&values, points, point);
+                assert_close(
+                    amplitudes[point].re,
+                    expected_amplitude.re,
+                    "amplitude real",
+                );
+                assert_close(
+                    amplitudes[point].im,
+                    expected_amplitude.im,
+                    "amplitude imaginary",
+                );
+                assert_close(reduced[point], expected_reduced, "reduced total");
+                assert_eq!(
+                    totals_only[point].to_bits(),
+                    reduced[point].to_bits(),
+                    "totals-only reduction order drifted at point {point}"
+                );
+            }
+        }
+
+        let points = 129;
+        let (values, momenta) = inputs(points);
+        let mut full_amplitudes = vec![EagerComplex64::new(0.0, 0.0); points];
+        let mut full_reduced = vec![0.0; points];
+        direct
+            .evaluate_into(
+                points,
+                &values,
+                &momenta,
+                &[],
+                &mut full_amplitudes,
+                &mut full_reduced,
+            )
+            .expect("evaluate full eager selector reference");
+        let profiled = direct
+            .evaluate_profile_into(
+                points,
+                &values,
+                &momenta,
+                &[],
+                &mut full_amplitudes,
+                &mut full_reduced,
+            )
+            .expect("profile full eager selector reference");
+        assert!(
+            profiled.internal_scratch_bytes > 0,
+            "profile must expose eager P-kernel scratch traffic separately"
+        );
+
+        let mut selected_amplitudes = vec![EagerComplex64::new(-13.0, 29.0); points];
+        direct
+            .evaluate_selected_active_amplitudes_into(
+                &[7],
+                points,
+                &values,
+                &momenta,
+                &[],
+                &mut selected_amplitudes,
+            )
+            .expect("evaluate selected eager amplitudes");
+        for (selected, full) in selected_amplitudes.iter().zip(&full_amplitudes) {
+            assert_close(selected.re, full.re, "selected amplitude real");
+            assert_close(selected.im, full.im, "selected amplitude imaginary");
+        }
+
+        let mut offsets = Vec::with_capacity(points + 1);
+        let mut groups = Vec::with_capacity(points / 2);
+        let mut weights = Vec::with_capacity(points / 2);
+        offsets.push(0);
+        for point in 0..points {
+            if point.is_multiple_of(2) {
+                groups.push(7);
+                weights.push(1.0);
+            }
+            offsets.push(groups.len());
+        }
+        let mut point_selected = vec![-1.0; points];
+        direct
+            .evaluate_point_selected_group_sets_into(
+                &offsets,
+                &groups,
+                &weights,
+                points,
+                &values,
+                &momenta,
+                &[],
+                &mut point_selected,
+            )
+            .expect("evaluate mixed empty/non-empty eager point selectors");
+        for point in 0..points {
+            let expected = if point.is_multiple_of(2) {
+                full_reduced[point]
+            } else {
+                0.0
+            };
+            assert_close(point_selected[point], expected, "point-selected total");
+        }
+    }
+
+    #[test]
+    fn whole_plan_preserves_requested_tiles_below_the_locality_cap() {
+        let fixture = Fixture::new();
+        let (source, descriptor) = source_and_descriptor();
+        let direct = runtime_with_point_tile(&fixture, &source, &descriptor, 32);
+        assert_eq!(direct.effective_point_tile_size(), 32);
+    }
+
+    #[test]
+    fn broadcast_planes_refresh_once_and_only_for_changed_parameters() {
+        let mut fixture = Fixture::new();
+        fixture.prepared_parameter_count = 1;
+        let (source, descriptor) = source_and_descriptor();
+        let mut direct = runtime(&fixture, &source, &descriptor);
+        let points = 7;
+        let (values, momenta) = inputs(points);
+        let mut amplitudes = vec![EagerComplex64::new(0.0, 0.0); points];
+        let mut reduced = vec![0.0; points];
+        let parameter = [EagerComplex64::new(2.0, -3.0)];
+
+        let first = direct
+            .evaluate_profile_into(
+                points,
+                &values,
+                &momenta,
+                &parameter,
+                &mut amplitudes,
+                &mut reduced,
+            )
+            .expect("initialize eager broadcast planes");
+        assert!(direct.elide_structural_zero_fills);
+        let zero_plane = direct
+            .shared_zero_plane_index
+            .expect("SymJIT eager execution must reserve a shared-zero plane");
+        assert_eq!(zero_plane % 2, 1);
+        let zero_component = (zero_plane / 2) as usize;
+        let point_stride = direct.workspace.arena().point_stride() as usize;
+        let (_, current_imaginary) = direct.workspace.arena().current_slices();
+        assert!(
+            current_imaginary[zero_component * point_stride..(zero_component + 1) * point_stride]
+                .iter()
+                .all(|value| *value == 0.0),
+            "shared-zero plane changed during eager execution"
+        );
+        let stride = direct.effective_point_tile_size() as u64;
+        assert_eq!(
+            first.internal_broadcast_bytes,
+            4 * stride * std::mem::size_of::<f64>() as u64,
+            "initial refresh must fill the two real coupling planes and the split-complex parameter"
+        );
+        for point in 0..points {
+            let (expected_amplitude, expected_reduced) = expected(&values, points, point);
+            assert_close(
+                amplitudes[point].re,
+                expected_amplitude.re,
+                "parameter-cache amplitude real",
+            );
+            assert_close(
+                amplitudes[point].im,
+                expected_amplitude.im,
+                "parameter-cache amplitude imaginary",
+            );
+            assert_close(
+                reduced[point],
+                expected_reduced,
+                "parameter-cache reduced total",
+            );
+        }
+
+        let unchanged = direct
+            .evaluate_profile_into(
+                points,
+                &values,
+                &momenta,
+                &parameter,
+                &mut amplitudes,
+                &mut reduced,
+            )
+            .expect("reuse eager broadcast planes");
+        assert_eq!(unchanged.internal_broadcast_bytes, 0);
+
+        let changed_parameter = [EagerComplex64::new(5.0, -3.0)];
+        let changed = direct
+            .evaluate_profile_into(
+                points,
+                &values,
+                &momenta,
+                &changed_parameter,
+                &mut amplitudes,
+                &mut reduced,
+            )
+            .expect("refresh changed eager parameter plane");
+        assert_eq!(
+            changed.internal_broadcast_bytes,
+            2 * stride * std::mem::size_of::<f64>() as u64,
+            "a changed unused parameter must not rewrite stationary coupling planes"
+        );
+
+        let (result, allocations, bytes) = count_allocations(|| {
+            direct.evaluate_into(
+                points,
+                &values,
+                &momenta,
+                &changed_parameter,
+                &mut amplitudes,
+                &mut reduced,
+            )
+        });
+        result.expect("repeat eager evaluation with cached parameter");
+        assert_eq!(
+            (allocations, bytes),
+            (0, 0),
+            "cached eager broadcast execution allocated"
+        );
+    }
+
+    #[test]
+    fn warmed_whole_plan_and_selector_caches_allocate_zero() {
+        let fixture = Fixture::new();
+        let (source, descriptor) = source_and_descriptor();
+        let mut direct = runtime(&fixture, &source, &descriptor);
+        let points = 129;
+        let (values, momenta) = inputs(points);
+        let mut amplitudes = vec![EagerComplex64::new(0.0, 0.0); points];
+        let mut reduced = vec![0.0; points];
+        direct
+            .evaluate_into(
+                points,
+                &values,
+                &momenta,
+                &[],
+                &mut amplitudes,
+                &mut reduced,
+            )
+            .expect("warm whole-plan execution");
+        let (result, allocations, bytes) = count_allocations(|| {
+            direct.evaluate_into(
+                points,
+                &values,
+                &momenta,
+                &[],
+                &mut amplitudes,
+                &mut reduced,
+            )
+        });
+        result.expect("repeat whole-plan execution");
+        assert_eq!(
+            (allocations, bytes),
+            (0, 0),
+            "warmed whole-plan execution allocated"
+        );
+
+        direct
+            .evaluate_totals_into(points, &values, &momenta, &[], &mut reduced)
+            .expect("warm totals-only execution");
+        let (result, allocations, bytes) = count_allocations(|| {
+            direct.evaluate_totals_into(points, &values, &momenta, &[], &mut reduced)
+        });
+        result.expect("repeat totals-only execution");
+        assert_eq!(
+            (allocations, bytes),
+            (0, 0),
+            "warmed totals-only execution allocated"
+        );
+
+        direct
+            .evaluate_selected_active_amplitudes_into(
+                &[7],
+                points,
+                &values,
+                &momenta,
+                &[],
+                &mut amplitudes,
+            )
+            .expect("warm global selector schedule");
+        let (result, allocations, bytes) = count_allocations(|| {
+            direct.evaluate_selected_active_amplitudes_into(
+                &[7],
+                points,
+                &values,
+                &momenta,
+                &[],
+                &mut amplitudes,
+            )
+        });
+        result.expect("repeat global selector schedule");
+        assert_eq!(
+            (allocations, bytes),
+            (0, 0),
+            "warmed global selector execution allocated"
+        );
+
+        let mut offsets = Vec::with_capacity(points + 1);
+        let mut groups = Vec::with_capacity(points);
+        let mut weights = Vec::with_capacity(points);
+        offsets.push(0);
+        for point in 0..points {
+            if !point.is_multiple_of(3) {
+                groups.push(7);
+                weights.push(1.0);
+            }
+            offsets.push(groups.len());
+        }
+        direct
+            .evaluate_point_selected_group_sets_into(
+                &offsets,
+                &groups,
+                &weights,
+                points,
+                &values,
+                &momenta,
+                &[],
+                &mut reduced,
+            )
+            .expect("warm per-point selector schedules");
+        let (result, allocations, bytes) = count_allocations(|| {
+            direct.evaluate_point_selected_group_sets_into(
+                &offsets,
+                &groups,
+                &weights,
+                points,
+                &values,
+                &momenta,
+                &[],
+                &mut reduced,
+            )
+        });
+        result.expect("repeat per-point selector schedules");
+        assert_eq!(
+            (allocations, bytes),
+            (0, 0),
+            "warmed per-point selector execution allocated"
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/direct_invocation_arena.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/direct_invocation_arena.rs
new file mode 100644
index 0000000000..bab98a4229
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/direct_invocation_arena.rs
@@ -0,0 +1,2364 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Developer-gated eager invocation/fanout Direct-Arena scheduler.
+//!
+//! This first scheduler slice deliberately stops at the stage boundary:
+//! finalization and closure remain independent eager events. Unlike the
+//! adapter-only ABI tests, this module consumes authenticated plan-v3 rows,
+//! derives their event lifetimes, allocates physical planes with the shared
+//! allocator, preserves selector pruning and invocation/fanout order, and
+//! executes real prepared SymJIT applications through immutable binding-v2
+//! tables.
+
+#![allow(dead_code)]
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use crate::artifact::PinnedNativeLibrary;
+use crate::direct_arena::{
+    DirectArenaInterval, DirectArenaLayout, DirectArenaTrafficCounters, assign_direct_arena,
+};
+use crate::engine::symjit_eager_direct::{
+    EAGER_DIRECT_SOURCE_APPLICATION_ABI, EAGER_DIRECT_TABLE_BINDING_ABI,
+    EAGER_DIRECT_TABLE_DESCRIPTOR_ABI, EagerDirectArenaPlaneBinding, EagerDirectTableRows,
+    EagerDirectTableWorkspace, LoadedSymjitEagerDirectTable,
+};
+use crate::{
+    EAGER_OUTPUT_FACTOR_COUPLING_IMAG, EAGER_OUTPUT_FACTOR_COUPLING_REAL, EAGER_OUTPUT_FACTOR_NONE,
+    MISSING_U32, RusticolError, RusticolResult,
+};
+
+use super::plan::{ComponentRange, EagerExecutionPlan, ScheduledAttachment, ScheduledInvocation};
+use super::{
+    EagerComplex64, EagerKernelInput, EagerKernelRole, EagerKernelSpec, EagerPlanV3Sections,
+};
+
+/// One prepared source application and its portable eager table descriptor.
+pub(crate) enum EagerDirectPreparedApplication<'a> {
+    Symjit {
+        source_application: &'a [u8],
+        descriptor: &'a [u8],
+        expected_optimization_level: u32,
+        expected_compression: bool,
+    },
+    Native {
+        library: &'a Arc<PinnedNativeLibrary>,
+        function_name: &'a str,
+        source_application_abi: &'a str,
+        invocation_stride: u32,
+        attachment_stride: u32,
+        target_triple: &'a str,
+        evaluator_state_sha256: &'a str,
+        simd_lane_width: u32,
+    },
+}
+
+pub(crate) struct EagerDirectPreparedKernel<'a> {
+    pub kernel_id: u32,
+    pub role: EagerKernelRole,
+    pub inputs: &'a [EagerKernelInput],
+    pub output_component_count: u32,
+    pub application: EagerDirectPreparedApplication<'a>,
+    pub display_path: PathBuf,
+}
+
+struct EagerDirectStageCall {
+    application: LoadedSymjitEagerDirectTable,
+    rows: EagerDirectTableRows,
+}
+
+#[derive(Clone, Copy)]
+struct FactorSpec {
+    factor: EagerComplex64,
+    coupling_slot_id: u32,
+    output_factor_source: u32,
+}
+
+#[derive(Clone, Copy)]
+pub(super) struct SemanticCatalog {
+    value_start: u32,
+    current_start: u32,
+    momentum_start: u32,
+    coupling_real_start: u32,
+    coupling_imag_start: u32,
+    parameter_start: u32,
+    semantic_count: u32,
+}
+
+impl SemanticCatalog {
+    pub(super) fn new(sections: EagerPlanV3Sections<'_>) -> RusticolResult<Self> {
+        let value_count = count_u32(sections.values.len(), "value slots")?;
+        let current_count = count_u32(sections.currents.len(), "currents")?;
+        let momentum_count = count_u32(sections.momenta.len(), "momentum slots")?;
+        let coupling_count = count_u32(sections.couplings.len(), "couplings")?;
+        let parameter_count = sections.prepared_parameter_count;
+        let value_start = 0;
+        let current_start = value_count;
+        let momentum_start = current_start
+            .checked_add(current_count)
+            .ok_or_else(|| invalid("eager direct semantic current range overflows"))?;
+        let coupling_real_start = momentum_start
+            .checked_add(momentum_count)
+            .ok_or_else(|| invalid("eager direct semantic momentum range overflows"))?;
+        let coupling_imag_start = coupling_real_start
+            .checked_add(coupling_count)
+            .ok_or_else(|| invalid("eager direct semantic coupling range overflows"))?;
+        let parameter_start = coupling_imag_start
+            .checked_add(coupling_count)
+            .ok_or_else(|| invalid("eager direct semantic coupling range overflows"))?;
+        let semantic_count = parameter_start
+            .checked_add(parameter_count)
+            .ok_or_else(|| invalid("eager direct semantic parameter range overflows"))?;
+        Ok(Self {
+            value_start,
+            current_start,
+            momentum_start,
+            coupling_real_start,
+            coupling_imag_start,
+            parameter_start,
+            semantic_count,
+        })
+    }
+
+    pub(super) fn value(self, id: u32) -> RusticolResult<u32> {
+        checked_semantic(self.value_start, id, self.current_start, "value")
+    }
+
+    pub(super) fn current(self, id: u32) -> RusticolResult<u32> {
+        checked_semantic(self.current_start, id, self.momentum_start, "current")
+    }
+
+    pub(super) fn momentum(self, id: u32) -> RusticolResult<u32> {
+        checked_semantic(
+            self.momentum_start,
+            id,
+            self.coupling_real_start,
+            "momentum",
+        )
+    }
+
+    pub(super) fn coupling_real(self, id: u32) -> RusticolResult<u32> {
+        checked_semantic(
+            self.coupling_real_start,
+            id,
+            self.coupling_imag_start,
+            "coupling-real",
+        )
+    }
+
+    pub(super) fn coupling_imag(self, id: u32) -> RusticolResult<u32> {
+        checked_semantic(
+            self.coupling_imag_start,
+            id,
+            self.parameter_start,
+            "coupling-imag",
+        )
+    }
+
+    pub(super) fn parameter(self, id: u32) -> RusticolResult<u32> {
+        checked_semantic(self.parameter_start, id, self.semantic_count, "parameter")
+    }
+}
+
+/// Real plan-v3 eager invocation/fanout prototype.
+///
+/// The production cutover will extend this envelope with finalization,
+/// closure, and reduction event executors. Keeping this type separate from
+/// [`super::EagerExecutionRuntime`] makes the temporary developer dual-run
+/// explicit and prevents a packet fallback from being mistaken for a direct
+/// lane.
+pub(crate) struct EagerDirectInvocationPrototype {
+    plan: EagerExecutionPlan,
+    catalog: SemanticCatalog,
+    layout: DirectArenaLayout,
+    workspace: EagerDirectTableWorkspace,
+    calls: Box<[EagerDirectStageCall]>,
+    factor_specs: Box<[FactorSpec]>,
+    initial_value_slots: Box<[u32]>,
+    value_ranges: Box<[ComponentRange]>,
+    momentum_ranges: Box<[ComponentRange]>,
+    traffic: DirectArenaTrafficCounters,
+}
+
+impl EagerDirectInvocationPrototype {
+    /// Construct one selector-specialized direct invocation schedule.
+    ///
+    /// `active_groups=None` retains every physical group. A sorted, unique
+    /// slice (including the empty slice) produces the same dependency-pruned
+    /// invocation and attachment order as the existing eager selector lane.
+    pub(crate) fn from_plan_v3_sections(
+        sections: EagerPlanV3Sections<'_>,
+        prepared: &[EagerDirectPreparedKernel<'_>],
+        active_groups: Option<&[u32]>,
+        tile_capacity: u32,
+    ) -> RusticolResult<Self> {
+        if tile_capacity == 0 {
+            return Err(invalid(
+                "eager direct invocation tile capacity must be positive",
+            ));
+        }
+        let plan = EagerExecutionPlan::from_plan_v3_sections(sections)?;
+        if plan.stages.len() != 1 {
+            return Err(RusticolError::compatibility(format!(
+                "the eager direct invocation prototype currently accepts one stage, found {}; \
+                 finalization and closure remain separate developer-oracle events",
+                plan.stages.len()
+            )));
+        }
+        Self::from_validated_plan_stage(
+            sections,
+            plan,
+            prepared,
+            active_groups,
+            tile_capacity,
+            0,
+            None,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn from_validated_plan_stage(
+        sections: EagerPlanV3Sections<'_>,
+        plan: EagerExecutionPlan,
+        prepared: &[EagerDirectPreparedKernel<'_>],
+        active_groups: Option<&[u32]>,
+        tile_capacity: u32,
+        stage_position: usize,
+        kernel_filter: Option<u32>,
+    ) -> RusticolResult<Self> {
+        validate_active_groups(&plan, active_groups)?;
+        let catalog = SemanticCatalog::new(sections)?;
+        let layout = derive_event_layout(sections, catalog, &plan)?;
+        let value_ranges = (0..sections.values.len())
+            .map(|id| plan.values.get(id as u32, "eager direct value"))
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        let momentum_ranges = (0..sections.momenta.len())
+            .map(|id| plan.momenta.get(id as u32, "eager direct momentum"))
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        let mut produced_values = vec![false; sections.values.len()];
+        for row in sections.finalizations {
+            for value in [row.unpropagated_value_slot_id, row.propagated_value_slot_id] {
+                if value != MISSING_U32 {
+                    produced_values[value as usize] = true;
+                }
+            }
+        }
+        let initial_value_slots = produced_values
+            .iter()
+            .enumerate()
+            .filter_map(|(id, produced)| (!produced).then_some(id as u32))
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+
+        let mut plane_bindings = Vec::new();
+        plane_bindings
+            .try_reserve_exact(layout.component_count() as usize * 2)
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not reserve eager direct plane bindings: {error}"
+                ))
+            })?;
+        for component in 0..layout.component_count() {
+            plane_bindings.push(EagerDirectArenaPlaneBinding::CurrentReal(component));
+            plane_bindings.push(EagerDirectArenaPlaneBinding::CurrentImag(component));
+        }
+
+        let stage = plan.stages.get(stage_position).ok_or_else(|| {
+            RusticolError::invalid_argument(format!(
+                "eager direct stage position {stage_position} is out of bounds"
+            ))
+        })?;
+        let mut applications = BTreeMap::new();
+        for artifact in prepared {
+            if applications.contains_key(&artifact.kernel_id) {
+                return Err(RusticolError::integrity(format!(
+                    "eager direct prepared catalog repeats kernel {}",
+                    artifact.kernel_id
+                )));
+            }
+            let kernel = plan.kernels.get(&artifact.kernel_id).ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "eager direct prepared catalog references unknown kernel {}",
+                    artifact.kernel_id
+                ))
+            })?;
+            validate_callable_identity(kernel, artifact)?;
+            let application = match &artifact.application {
+                EagerDirectPreparedApplication::Symjit {
+                    source_application,
+                    descriptor,
+                    expected_optimization_level,
+                    expected_compression,
+                } => LoadedSymjitEagerDirectTable::load_prepared_application_bytes(
+                    source_application,
+                    descriptor,
+                    artifact.display_path.clone(),
+                    EAGER_DIRECT_SOURCE_APPLICATION_ABI,
+                    EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+                    EAGER_DIRECT_TABLE_BINDING_ABI,
+                    *expected_optimization_level,
+                    *expected_compression,
+                )?,
+                EagerDirectPreparedApplication::Native {
+                    library,
+                    function_name,
+                    source_application_abi,
+                    invocation_stride,
+                    attachment_stride,
+                    target_triple,
+                    evaluator_state_sha256,
+                    simd_lane_width,
+                } => LoadedSymjitEagerDirectTable::load_native_application(
+                    Arc::clone(library),
+                    function_name,
+                    artifact.display_path.clone(),
+                    source_application_abi,
+                    *invocation_stride,
+                    *attachment_stride,
+                    count_u32(artifact.inputs.len(), "native eager input width")?,
+                    artifact.output_component_count,
+                    target_triple,
+                    evaluator_state_sha256,
+                    *simd_lane_width,
+                )?,
+            };
+            applications.insert(artifact.kernel_id, application);
+        }
+
+        let mut calls = Vec::new();
+        let mut factor_specs = Vec::new();
+        // Selector specialization changes which contribution is the first
+        // retained write to a current. Recompute overwrite/add semantics in
+        // exactly the retained, stable execution order rather than inheriting
+        // flags from the full schedule.
+        let mut selected_written_currents = BTreeSet::new();
+        let mut cursor = 0usize;
+        while cursor < stage.invocations.len() {
+            let kernel_id = stage.invocations[cursor].row.kernel_id;
+            let run_stop = stage.invocations[cursor..]
+                .iter()
+                .position(|row| row.row.kernel_id != kernel_id)
+                .map_or(stage.invocations.len(), |offset| cursor + offset);
+            if kernel_filter.is_some_and(|selected| selected != kernel_id) {
+                cursor = run_stop;
+                continue;
+            }
+            let kernel = plan.kernels.get(&kernel_id).ok_or_else(|| {
+                RusticolError::internal(format!("eager direct schedule lost kernel {kernel_id}"))
+            })?;
+            let mut invocation_bytes = Vec::new();
+            let mut attachment_bytes = Vec::new();
+            let mut local_attachment_count = 0_u32;
+            for invocation in &stage.invocations[cursor..run_stop] {
+                if !row_active(&plan, invocation.selector_domain_id, active_groups)? {
+                    continue;
+                }
+                let active_attachment_count = stage.attachments
+                    [invocation.attachment_range.clone()]
+                .iter()
+                .map(|attachment| row_active(&plan, attachment.selector_domain_id, active_groups))
+                .collect::<RusticolResult<Vec<_>>>()?
+                .into_iter()
+                .filter(|active| *active)
+                .count();
+                if active_attachment_count == 0 {
+                    continue;
+                }
+                encode_invocation_inputs(
+                    &mut invocation_bytes,
+                    invocation,
+                    &kernel.inputs,
+                    catalog,
+                    &layout,
+                )?;
+                push_u32(&mut invocation_bytes, local_attachment_count);
+                push_u32(
+                    &mut invocation_bytes,
+                    count_u32(active_attachment_count, "active attachments")?,
+                );
+                for attachment in &stage.attachments[invocation.attachment_range.clone()] {
+                    if !row_active(&plan, attachment.selector_domain_id, active_groups)? {
+                        continue;
+                    }
+                    encode_attachment_destinations(
+                        &mut attachment_bytes,
+                        attachment,
+                        kernel.output_component_count,
+                        catalog,
+                        &layout,
+                    )?;
+                    let factor_index = count_u32(factor_specs.len(), "direct factors")?;
+                    push_u32(&mut attachment_bytes, factor_index);
+                    push_u32(
+                        &mut attachment_bytes,
+                        retained_attachment_operation(
+                            &mut selected_written_currents,
+                            attachment.row.result_current_id,
+                        ),
+                    );
+                    factor_specs.push(FactorSpec {
+                        factor: EagerComplex64::new(
+                            attachment.row.factor_real,
+                            attachment.row.factor_imag,
+                        ),
+                        coupling_slot_id: invocation.row.coupling_slot_id,
+                        output_factor_source: invocation.row.output_factor_source,
+                    });
+                    local_attachment_count = local_attachment_count
+                        .checked_add(1)
+                        .ok_or_else(|| invalid("eager direct attachment count overflows"))?;
+                }
+            }
+            if !invocation_bytes.is_empty() {
+                let application = applications.remove(&kernel_id).ok_or_else(|| {
+                    RusticolError::compatibility(format!(
+                        "eager direct invocation schedule has no prepared table for kernel {kernel_id}"
+                    ))
+                })?;
+                let rows = application.load_rows(invocation_bytes, attachment_bytes)?;
+                calls.push(EagerDirectStageCall { application, rows });
+            }
+            cursor = run_stop;
+        }
+
+        let factor_len = factor_specs.len().max(1);
+        let mut workspace = EagerDirectTableWorkspace::new(
+            layout.component_count(),
+            count_u32(plan.amplitude_count, "amplitude planes")?,
+            tile_capacity,
+            &plane_bindings,
+            None,
+            Vec::new(),
+            vec![0.0; factor_len],
+            vec![0.0; factor_len],
+        )?;
+        workspace.begin_tile(tile_capacity)?;
+        for call in &calls {
+            call.application
+                .validate_call(&call.rows, &mut workspace, 0, tile_capacity)?;
+        }
+
+        Ok(Self {
+            plan,
+            catalog,
+            layout,
+            workspace,
+            calls: calls.into_boxed_slice(),
+            factor_specs: factor_specs.into_boxed_slice(),
+            initial_value_slots,
+            value_ranges,
+            momentum_ranges,
+            traffic: DirectArenaTrafficCounters::default(),
+        })
+    }
+
+    /// Extract one invocation-only stage slice from a fully validated
+    /// multistage plan for the retained-artifact oracle. This test-only entry
+    /// point does not relax the production constructor: finalization, closure,
+    /// and whole-plan multistage execution remain fail-closed.
+    #[cfg(test)]
+    pub(crate) fn from_multistage_stage_for_test(
+        sections: EagerPlanV3Sections<'_>,
+        prepared: &[EagerDirectPreparedKernel<'_>],
+        active_groups: Option<&[u32]>,
+        tile_capacity: u32,
+        stage_position: usize,
+        kernel_id: u32,
+    ) -> RusticolResult<Self> {
+        if tile_capacity == 0 {
+            return Err(invalid(
+                "eager direct invocation tile capacity must be positive",
+            ));
+        }
+        let plan = EagerExecutionPlan::from_plan_v3_sections(sections)?;
+        if plan.stages.len() < 2 {
+            return Err(RusticolError::compatibility(
+                "the retained-artifact stage oracle requires a genuine multistage eager plan",
+            ));
+        }
+        Self::from_validated_plan_stage(
+            sections,
+            plan,
+            prepared,
+            active_groups,
+            tile_capacity,
+            stage_position,
+            Some(kernel_id),
+        )
+    }
+
+    pub(crate) fn layout(&self) -> &DirectArenaLayout {
+        &self.layout
+    }
+
+    pub(crate) const fn traffic(&self) -> DirectArenaTrafficCounters {
+        self.traffic
+    }
+
+    pub(crate) fn current_value(
+        &self,
+        current_id: u32,
+        component: u32,
+        point: u32,
+    ) -> RusticolResult<EagerComplex64> {
+        if point >= self.workspace.arena().active_point_count() {
+            return Err(invalid(
+                "eager direct current point is outside the active tile",
+            ));
+        }
+        let semantic = self.catalog.current(current_id)?;
+        let physical = assigned_component(&self.layout, semantic, component)?;
+        let stride = self.workspace.arena().point_stride() as usize;
+        let index = physical as usize * stride + point as usize;
+        let (real, imaginary) = self.workspace.arena().current_slices();
+        Ok(EagerComplex64::new(real[index], imaginary[index]))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_invocations(
+        &mut self,
+        point_count: u32,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+    ) -> RusticolResult<()> {
+        if point_count == 0 || point_count > self.workspace.arena().tile_capacity() {
+            return Err(invalid(format!(
+                "eager direct invocation point count {point_count} is outside 1..={}",
+                self.workspace.arena().tile_capacity()
+            )));
+        }
+        validate_component_buffer(
+            "initial values",
+            initial_values.len(),
+            self.plan.values.component_count,
+            point_count,
+        )?;
+        validate_component_buffer(
+            "momenta",
+            momenta.len(),
+            self.plan.momenta.component_count,
+            point_count,
+        )?;
+        if model_parameters.len() != self.plan.parameter_count {
+            return Err(invalid(format!(
+                "eager direct model parameter count is {}, expected {}",
+                model_parameters.len(),
+                self.plan.parameter_count
+            )));
+        }
+        if model_parameters
+            .iter()
+            .any(|value| !value.re.is_finite() || !value.im.is_finite())
+        {
+            return Err(invalid("eager direct model parameters must be finite"));
+        }
+
+        self.workspace.begin_tile(point_count)?;
+        self.workspace
+            .clear_current_active(0, self.layout.component_count())?;
+        let stride = self.workspace.arena().point_stride() as usize;
+        let points = point_count as usize;
+        {
+            let (real, imaginary, _, _) = self.workspace.split_arena_slices_mut();
+            for &slot in &self.initial_value_slots {
+                let range = self.value_ranges[slot as usize];
+                let semantic = self.catalog.value(slot)?;
+                for component in 0..range.len {
+                    let physical = assigned_component(
+                        &self.layout,
+                        semantic,
+                        count_u32(component, "value component")?,
+                    )? as usize;
+                    let target = physical * stride;
+                    let source = (range.start + component) * points;
+                    for point in 0..points {
+                        let value = initial_values[source + point];
+                        real[target + point] = value.re;
+                        imaginary[target + point] = value.im;
+                    }
+                }
+            }
+            for (slot, range) in self.momentum_ranges.iter().copied().enumerate() {
+                let semantic = self.catalog.momentum(slot as u32)?;
+                for component in 0..range.len {
+                    let physical = assigned_component(
+                        &self.layout,
+                        semantic,
+                        count_u32(component, "momentum component")?,
+                    )? as usize;
+                    let target = physical * stride;
+                    let source = (range.start + component) * points;
+                    for point in 0..points {
+                        real[target + point] = momenta[source + point];
+                        imaginary[target + point] = 0.0;
+                    }
+                }
+            }
+            for (coupling_id, row) in self.plan.couplings.iter().copied().enumerate() {
+                let coupling = resolve_coupling(row, model_parameters);
+                fill_real_input_plane(
+                    real,
+                    imaginary,
+                    stride,
+                    assigned_component(
+                        &self.layout,
+                        self.catalog.coupling_real(coupling_id as u32)?,
+                        0,
+                    )?,
+                    points,
+                    coupling.re,
+                );
+                fill_real_input_plane(
+                    real,
+                    imaginary,
+                    stride,
+                    assigned_component(
+                        &self.layout,
+                        self.catalog.coupling_imag(coupling_id as u32)?,
+                        0,
+                    )?,
+                    points,
+                    coupling.im,
+                );
+            }
+            for (parameter_id, value) in model_parameters.iter().copied().enumerate() {
+                let physical = assigned_component(
+                    &self.layout,
+                    self.catalog.parameter(parameter_id as u32)?,
+                    0,
+                )? as usize;
+                let target = physical * stride;
+                real[target..target + points].fill(value.re);
+                imaginary[target..target + points].fill(value.im);
+            }
+        }
+        {
+            let (factor_re, factor_im) = self.workspace.factors_mut();
+            for (index, spec) in self.factor_specs.iter().copied().enumerate() {
+                let coupling = resolve_coupling(
+                    self.plan.couplings[spec.coupling_slot_id as usize],
+                    model_parameters,
+                );
+                let scale = match spec.output_factor_source {
+                    EAGER_OUTPUT_FACTOR_NONE => 1.0,
+                    EAGER_OUTPUT_FACTOR_COUPLING_REAL => coupling.re,
+                    EAGER_OUTPUT_FACTOR_COUPLING_IMAG => coupling.im,
+                    _ => {
+                        return Err(RusticolError::integrity(
+                            "eager direct factor references an invalid output-factor source",
+                        ));
+                    }
+                };
+                factor_re[index] = spec.factor.re * scale;
+                factor_im[index] = spec.factor.im * scale;
+            }
+        }
+        self.execute_preinitialized_invocations(point_count)
+    }
+
+    /// Execute immutable table rows after the caller has initialized the
+    /// arena and factor catalog for the active tile.
+    fn execute_preinitialized_invocations(&mut self, point_count: u32) -> RusticolResult<()> {
+        for call in &self.calls {
+            self.traffic
+                .record_call(call.rows.invocation_count(), point_count);
+            // SAFETY: constructor validation authenticates immutable rows,
+            // descriptors, plane catalogs, and aliases. This method changes
+            // only plane/factor contents and the checked active tail.
+            unsafe {
+                call.application.evaluate_validated_unchecked(
+                    &call.rows,
+                    &mut self.workspace,
+                    0,
+                    point_count,
+                )?;
+            }
+        }
+        self.traffic.validate_direct()?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct EagerDirectRetainedStageCandidate {
+    pub(crate) stage_position: usize,
+    pub(crate) stage_index: u32,
+    pub(crate) kernel_id: u32,
+    pub(crate) selector_group_id: u32,
+    pub(crate) full_invocation_count: usize,
+    pub(crate) full_attachment_count: usize,
+    pub(crate) selected_invocation_count: usize,
+    pub(crate) selected_attachment_count: usize,
+    pub(crate) distinct_destination_count: usize,
+}
+
+#[cfg(test)]
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct EagerDirectRetainedStageVariantEvidence {
+    pub(crate) invocation_count: usize,
+    pub(crate) attachment_count: usize,
+    pub(crate) comparison_count: usize,
+    pub(crate) bitwise_comparison_count: usize,
+    pub(crate) maximum_absolute_error: f64,
+    pub(crate) maximum_relative_error: f64,
+    pub(crate) direct_median_ns: f64,
+    pub(crate) direct_mad_ns: f64,
+    pub(crate) packet_median_ns: f64,
+    pub(crate) packet_mad_ns: f64,
+    pub(crate) direct_over_packet: f64,
+    pub(crate) direct_call_traffic: DirectArenaTrafficCounters,
+    pub(crate) arena_initialization_write_bytes: u64,
+    pub(crate) factor_fill_write_bytes: u64,
+    pub(crate) packet_input_materialization_bytes_per_call: u64,
+    pub(crate) packet_output_materialization_bytes_per_call: u64,
+    pub(crate) packet_scatter_bytes_per_call: u64,
+}
+
+#[cfg(test)]
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct EagerDirectRetainedStageEvidence {
+    pub(crate) candidate: EagerDirectRetainedStageCandidate,
+    pub(crate) full: EagerDirectRetainedStageVariantEvidence,
+    pub(crate) selected: EagerDirectRetainedStageVariantEvidence,
+}
+
+/// Pick a retained-artifact kernel run that proves both a genuine multi-row,
+/// multi-destination table and nontrivial runtime selector pruning.
+#[cfg(test)]
+pub(crate) fn select_retained_multistage_candidate(
+    sections: EagerPlanV3Sections<'_>,
+) -> RusticolResult<EagerDirectRetainedStageCandidate> {
+    let plan = EagerExecutionPlan::from_plan_v3_sections(sections)?;
+    if plan.stages.len() < 2 {
+        return Err(RusticolError::compatibility(
+            "the retained eager stage oracle requires a multistage plan",
+        ));
+    }
+    let selector = plan.selector_domains.as_ref().ok_or_else(|| {
+        RusticolError::compatibility(
+            "the retained eager stage oracle requires runtime selector domains",
+        )
+    })?;
+    let mut best = None;
+    for (stage_position, stage) in plan.stages.iter().enumerate() {
+        let mut cursor = 0;
+        while cursor < stage.invocations.len() {
+            let kernel_id = stage.invocations[cursor].row.kernel_id;
+            let stop = stage.invocations[cursor..]
+                .iter()
+                .position(|row| row.row.kernel_id != kernel_id)
+                .map_or(stage.invocations.len(), |offset| cursor + offset);
+            let run = &stage.invocations[cursor..stop];
+            let full_attachment_count = run
+                .iter()
+                .map(|invocation| invocation.attachment_range.len())
+                .sum::<usize>();
+            let distinct_destinations = run
+                .iter()
+                .flat_map(|invocation| {
+                    stage.attachments[invocation.attachment_range.clone()]
+                        .iter()
+                        .map(|attachment| attachment.row.result_current_id)
+                })
+                .collect::<BTreeSet<_>>();
+            if run.len() >= 2 && distinct_destinations.len() >= 2 {
+                for &group_id in &selector.group_ids {
+                    let groups = [group_id];
+                    let (selected_invocations, selected_attachments) =
+                        retained_run_counts(&plan, stage, run, Some(&groups))?;
+                    if selected_invocations == 0 || selected_invocations >= run.len() {
+                        continue;
+                    }
+                    let candidate = EagerDirectRetainedStageCandidate {
+                        stage_position,
+                        stage_index: stage.stage_index,
+                        kernel_id,
+                        selector_group_id: group_id,
+                        full_invocation_count: run.len(),
+                        full_attachment_count,
+                        selected_invocation_count: selected_invocations,
+                        selected_attachment_count: selected_attachments,
+                        distinct_destination_count: distinct_destinations.len(),
+                    };
+                    if best
+                        .as_ref()
+                        .is_none_or(|previous: &EagerDirectRetainedStageCandidate| {
+                            (
+                                candidate.full_invocation_count,
+                                candidate.distinct_destination_count,
+                                candidate.selected_invocation_count,
+                            ) > (
+                                previous.full_invocation_count,
+                                previous.distinct_destination_count,
+                                previous.selected_invocation_count,
+                            )
+                        })
+                    {
+                        best = Some(candidate);
+                    }
+                }
+            }
+            cursor = stop;
+        }
+    }
+    best.ok_or_else(|| {
+        RusticolError::compatibility(
+            "retained eager plan has no multi-row/multi-destination kernel run with nontrivial selector pruning",
+        )
+    })
+}
+
+#[cfg(test)]
+fn retained_run_counts(
+    plan: &EagerExecutionPlan,
+    stage: &super::plan::EagerStagePlan,
+    run: &[ScheduledInvocation],
+    active_groups: Option<&[u32]>,
+) -> RusticolResult<(usize, usize)> {
+    let mut invocations = 0;
+    let mut attachments = 0;
+    for invocation in run {
+        if !row_active(plan, invocation.selector_domain_id, active_groups)? {
+            continue;
+        }
+        let retained = stage.attachments[invocation.attachment_range.clone()]
+            .iter()
+            .map(|attachment| row_active(plan, attachment.selector_domain_id, active_groups))
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_iter()
+            .filter(|active| *active)
+            .count();
+        if retained != 0 {
+            invocations += 1;
+            attachments += retained;
+        }
+    }
+    Ok((invocations, attachments))
+}
+
+/// Execute one real retained multistage artifact's chosen invocation run
+/// through both the Direct-Arena table ABI and the established packet
+/// gather/evaluate/scatter implementation.
+#[cfg(test)]
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn run_retained_multistage_oracle<B: super::EagerKernelBackend>(
+    sections: EagerPlanV3Sections<'_>,
+    prepared: &[EagerDirectPreparedKernel<'_>],
+    candidate: EagerDirectRetainedStageCandidate,
+    backend: &mut B,
+    model_parameters: &[EagerComplex64],
+    point_count: u32,
+    sample_count: usize,
+    repetitions: usize,
+) -> RusticolResult<EagerDirectRetainedStageEvidence> {
+    if point_count == 0 || sample_count < 3 || sample_count.is_multiple_of(2) || repetitions == 0 {
+        return Err(invalid(
+            "retained eager stage oracle needs points, odd sample count >= 3, and repetitions",
+        ));
+    }
+    let selected_groups = [candidate.selector_group_id];
+    let full = run_retained_stage_variant(
+        sections,
+        prepared,
+        candidate,
+        backend,
+        model_parameters,
+        point_count,
+        sample_count,
+        repetitions,
+        None,
+    )?;
+    let selected = run_retained_stage_variant(
+        sections,
+        prepared,
+        candidate,
+        backend,
+        model_parameters,
+        point_count,
+        sample_count,
+        repetitions,
+        Some(&selected_groups),
+    )?;
+    if full.invocation_count != candidate.full_invocation_count
+        || full.attachment_count != candidate.full_attachment_count
+        || selected.invocation_count != candidate.selected_invocation_count
+        || selected.attachment_count != candidate.selected_attachment_count
+    {
+        return Err(RusticolError::internal(
+            "retained eager stage oracle selection counts changed after candidate selection",
+        ));
+    }
+    Ok(EagerDirectRetainedStageEvidence {
+        candidate,
+        full,
+        selected,
+    })
+}
+
+#[cfg(test)]
+#[allow(clippy::too_many_arguments)]
+fn run_retained_stage_variant<B: super::EagerKernelBackend>(
+    sections: EagerPlanV3Sections<'_>,
+    prepared: &[EagerDirectPreparedKernel<'_>],
+    candidate: EagerDirectRetainedStageCandidate,
+    backend: &mut B,
+    model_parameters: &[EagerComplex64],
+    point_count: u32,
+    sample_count: usize,
+    repetitions: usize,
+    active_groups: Option<&[u32]>,
+) -> RusticolResult<EagerDirectRetainedStageVariantEvidence> {
+    use std::hint::black_box;
+
+    use super::execute::execute_stage;
+    use super::plan::{EagerStagePlan, mark_initial_current_writes};
+    use super::runtime::{EagerWorkspace, KernelPacket, PacketRole, StageSchedule};
+
+    let packet_plan = EagerExecutionPlan::from_plan_v3_sections(sections)?;
+    let source_stage = packet_plan
+        .stages
+        .get(candidate.stage_position)
+        .ok_or_else(|| invalid("retained eager candidate stage is out of bounds"))?;
+    if source_stage.stage_index != candidate.stage_index {
+        return Err(RusticolError::internal(
+            "retained eager candidate stage identity changed",
+        ));
+    }
+    let kernel = packet_plan
+        .kernels
+        .get(&candidate.kernel_id)
+        .ok_or_else(|| invalid("retained eager candidate kernel is absent"))?;
+
+    let mut invocations = Vec::new();
+    let mut attachments = Vec::new();
+    for invocation in &source_stage.invocations {
+        if invocation.row.kernel_id != candidate.kernel_id
+            || !row_active(&packet_plan, invocation.selector_domain_id, active_groups)?
+        {
+            continue;
+        }
+        let attachment_start = attachments.len();
+        for attachment in &source_stage.attachments[invocation.attachment_range.clone()] {
+            if row_active(&packet_plan, attachment.selector_domain_id, active_groups)? {
+                attachments.push(*attachment);
+            }
+        }
+        if attachments.len() == attachment_start {
+            continue;
+        }
+        let mut retained = invocation.clone();
+        retained.attachment_range = attachment_start..attachments.len();
+        invocations.push(retained);
+    }
+    if invocations.is_empty() || attachments.is_empty() {
+        return Err(RusticolError::internal(
+            "retained eager stage variant unexpectedly has no work",
+        ));
+    }
+    let zero_current_ranges = mark_initial_current_writes(&invocations, &mut attachments, &[]);
+    let stage = EagerStagePlan {
+        stage_index: source_stage.stage_index,
+        current_component_count: source_stage.current_component_count,
+        invocations,
+        attachments,
+        finalization_copies: Vec::new(),
+        finalizations: Vec::new(),
+        zero_current_ranges,
+    };
+    let packet = KernelPacket {
+        role: PacketRole::Invocation,
+        kernel_id: candidate.kernel_id,
+        independent_block_size: 1,
+        item_range: 0..stage.invocations.len(),
+        input_components: kernel.inputs.len(),
+        output_components: kernel.output_component_count as usize,
+        linear_finalization: None,
+    };
+    let schedule = StageSchedule {
+        invocation_packets: vec![packet],
+        finalization_packets: Vec::new(),
+    };
+
+    let points = point_count as usize;
+    let values = deterministic_complex_components(packet_plan.values.component_count, points);
+    let momenta = deterministic_real_components(packet_plan.momenta.component_count, points);
+    let couplings = packet_plan
+        .couplings
+        .iter()
+        .copied()
+        .map(|row| resolve_coupling(row, model_parameters))
+        .collect::<Vec<_>>();
+    let packet_complex_count = stage
+        .invocations
+        .len()
+        .checked_mul(points)
+        .and_then(|lanes| {
+            kernel
+                .inputs
+                .len()
+                .checked_add(kernel.output_component_count as usize)
+                .and_then(|width| lanes.checked_mul(width))
+        })
+        .ok_or_else(|| invalid("retained eager packet workspace overflows"))?;
+    let mut packet_workspace = EagerWorkspace {
+        tile_capacity: points,
+        values: values.clone(),
+        currents: vec![
+            EagerComplex64::new(0.0, 0.0);
+            source_stage.current_component_count * points
+        ],
+        amplitudes: vec![EagerComplex64::new(0.0, 0.0); packet_plan.amplitude_count * points],
+        reduction_groups: vec![
+            EagerComplex64::new(0.0, 0.0);
+            packet_plan.reduction_groups.len() * points
+        ],
+        couplings,
+        reduced: vec![0.0; points],
+        packet: vec![EagerComplex64::new(0.0, 0.0); packet_complex_count],
+    };
+
+    let mut direct = EagerDirectInvocationPrototype::from_multistage_stage_for_test(
+        sections,
+        prepared,
+        active_groups,
+        point_count,
+        candidate.stage_position,
+        candidate.kernel_id,
+    )?;
+    initialize_all_retained_stage_inputs(
+        &mut direct,
+        &stage,
+        point_count,
+        &values,
+        &momenta,
+        model_parameters,
+    )?;
+    direct.execute_preinitialized_invocations(point_count)?;
+    execute_stage(
+        &stage,
+        &schedule,
+        &packet_plan.kernels,
+        &mut packet_workspace,
+        backend,
+        points,
+        0,
+        points,
+        &momenta,
+        model_parameters,
+    )?;
+    let mut comparison_count = 0;
+    let mut bitwise_comparison_count = 0;
+    let mut maximum_absolute_error = 0.0_f64;
+    let mut maximum_relative_error = 0.0_f64;
+    let mut compared = BTreeSet::new();
+    for attachment in &stage.attachments {
+        for component in 0..attachment.current.len {
+            if !compared.insert((attachment.row.result_current_id, component)) {
+                continue;
+            }
+            for point in 0..points {
+                let actual = direct.current_value(
+                    attachment.row.result_current_id,
+                    component as u32,
+                    point as u32,
+                )?;
+                let expected = packet_workspace.currents
+                    [(attachment.current.start + component) * points + point];
+                if (actual.re.to_bits(), actual.im.to_bits())
+                    == (expected.re.to_bits(), expected.im.to_bits())
+                {
+                    bitwise_comparison_count += 1;
+                } else {
+                    for (actual_part, expected_part) in
+                        [(actual.re, expected.re), (actual.im, expected.im)]
+                    {
+                        let absolute = (actual_part - expected_part).abs();
+                        let relative = absolute / expected_part.abs().max(f64::MIN_POSITIVE);
+                        maximum_absolute_error = maximum_absolute_error.max(absolute);
+                        maximum_relative_error = maximum_relative_error.max(relative);
+                        if absolute > 1.0e-15 + 1.0e-12 * expected_part.abs() {
+                            return Err(RusticolError::integrity(format!(
+                                "retained eager Direct-Arena stage differs from packet execution for \
+                                 current {} component {component} point {point}: \
+                                 {actual:?} != {expected:?}",
+                                attachment.row.result_current_id
+                            )));
+                        }
+                    }
+                }
+                comparison_count += 1;
+            }
+        }
+    }
+
+    let mut direct_samples = Vec::with_capacity(sample_count);
+    let mut packet_samples = Vec::with_capacity(sample_count);
+    for sample in 0..sample_count {
+        if sample.is_multiple_of(2) {
+            direct_samples.push(measure_repeated(repetitions, || {
+                direct.execute_preinitialized_invocations(point_count)
+            })?);
+            packet_samples.push(measure_repeated(repetitions, || {
+                execute_stage(
+                    &stage,
+                    &schedule,
+                    &packet_plan.kernels,
+                    &mut packet_workspace,
+                    backend,
+                    points,
+                    0,
+                    points,
+                    &momenta,
+                    model_parameters,
+                )
+            })?);
+        } else {
+            packet_samples.push(measure_repeated(repetitions, || {
+                execute_stage(
+                    &stage,
+                    &schedule,
+                    &packet_plan.kernels,
+                    &mut packet_workspace,
+                    backend,
+                    points,
+                    0,
+                    points,
+                    &momenta,
+                    model_parameters,
+                )
+            })?);
+            direct_samples.push(measure_repeated(repetitions, || {
+                direct.execute_preinitialized_invocations(point_count)
+            })?);
+        }
+    }
+    black_box(direct.current_value(stage.attachments[0].row.result_current_id, 0, 0)?);
+    black_box(packet_workspace.currents[stage.attachments[0].current.start * points]);
+    let (direct_median_ns, direct_mad_ns) = median_mad(&mut direct_samples);
+    let (packet_median_ns, packet_mad_ns) = median_mad(&mut packet_samples);
+    let direct_call_traffic = direct.traffic();
+    direct_call_traffic.validate_direct()?;
+
+    let used_value_components = stage
+        .invocations
+        .iter()
+        .flat_map(|invocation| {
+            [
+                invocation.row.left_value_slot_id,
+                invocation.row.right_value_slot_id,
+            ]
+        })
+        .collect::<BTreeSet<_>>()
+        .into_iter()
+        .map(|slot| direct.value_ranges[slot as usize].len as u64)
+        .sum::<u64>();
+    let arena_initialization_write_bytes = [
+        direct.layout.component_count() as u64,
+        used_value_components,
+        packet_plan.momenta.component_count as u64,
+        (packet_plan.couplings.len() as u64).saturating_mul(2),
+        packet_plan.parameter_count as u64,
+    ]
+    .into_iter()
+    .sum::<u64>()
+    .saturating_mul(u64::from(point_count))
+    .saturating_mul(16);
+    let factor_fill_write_bytes = (direct.factor_specs.len() as u64).saturating_mul(16);
+    let lane_count = (stage.invocations.len() as u64).saturating_mul(u64::from(point_count));
+    let packet_input_materialization_bytes_per_call = lane_count
+        .saturating_mul(kernel.inputs.len() as u64)
+        .saturating_mul(16);
+    let packet_output_materialization_bytes_per_call = lane_count
+        .saturating_mul(u64::from(kernel.output_component_count))
+        .saturating_mul(16);
+    let packet_scatter_bytes_per_call = (stage.attachments.len() as u64)
+        .saturating_mul(u64::from(point_count))
+        .saturating_mul(u64::from(kernel.output_component_count))
+        .saturating_mul(16);
+
+    Ok(EagerDirectRetainedStageVariantEvidence {
+        invocation_count: stage.invocations.len(),
+        attachment_count: stage.attachments.len(),
+        comparison_count,
+        bitwise_comparison_count,
+        maximum_absolute_error,
+        maximum_relative_error,
+        direct_median_ns,
+        direct_mad_ns,
+        packet_median_ns,
+        packet_mad_ns,
+        direct_over_packet: direct_median_ns / packet_median_ns,
+        direct_call_traffic,
+        arena_initialization_write_bytes,
+        factor_fill_write_bytes,
+        packet_input_materialization_bytes_per_call,
+        packet_output_materialization_bytes_per_call,
+        packet_scatter_bytes_per_call,
+    })
+}
+
+#[cfg(test)]
+fn deterministic_complex_components(components: usize, points: usize) -> Vec<EagerComplex64> {
+    (0..components)
+        .flat_map(|component| {
+            (0..points).map(move |point| {
+                let seed = (component * points + point + 1) as f64;
+                EagerComplex64::new(seed.mul_add(0.000_976_562_5, 0.25), -seed / 2048.0)
+            })
+        })
+        .collect()
+}
+
+#[cfg(test)]
+fn deterministic_real_components(components: usize, points: usize) -> Vec<f64> {
+    (0..components)
+        .flat_map(|component| {
+            (0..points).map(move |point| {
+                let seed = (component * points + point + 1) as f64;
+                seed.mul_add(0.001_953_125, 0.5)
+            })
+        })
+        .collect()
+}
+
+#[cfg(test)]
+fn initialize_all_retained_stage_inputs(
+    direct: &mut EagerDirectInvocationPrototype,
+    stage: &super::plan::EagerStagePlan,
+    point_count: u32,
+    values: &[EagerComplex64],
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+) -> RusticolResult<()> {
+    validate_component_buffer(
+        "retained-stage values",
+        values.len(),
+        direct.plan.values.component_count,
+        point_count,
+    )?;
+    validate_component_buffer(
+        "retained-stage momenta",
+        momenta.len(),
+        direct.plan.momenta.component_count,
+        point_count,
+    )?;
+    if model_parameters.len() != direct.plan.parameter_count {
+        return Err(invalid(
+            "retained-stage model parameter count does not match the plan",
+        ));
+    }
+    direct.workspace.begin_tile(point_count)?;
+    direct
+        .workspace
+        .clear_current_active(0, direct.layout.component_count())?;
+    let stride = direct.workspace.arena().point_stride() as usize;
+    let points = point_count as usize;
+    {
+        let (real, imaginary, _, _) = direct.workspace.split_arena_slices_mut();
+        let used_value_slots = stage
+            .invocations
+            .iter()
+            .flat_map(|invocation| {
+                [
+                    invocation.row.left_value_slot_id,
+                    invocation.row.right_value_slot_id,
+                ]
+            })
+            .collect::<BTreeSet<_>>();
+        for slot in used_value_slots {
+            let range = direct.value_ranges[slot as usize];
+            let semantic = direct.catalog.value(slot)?;
+            for component in 0..range.len {
+                let physical = assigned_component(
+                    &direct.layout,
+                    semantic,
+                    count_u32(component, "retained value component")?,
+                )? as usize;
+                let target = physical * stride;
+                let source = (range.start + component) * points;
+                for point in 0..points {
+                    let value = values[source + point];
+                    real[target + point] = value.re;
+                    imaginary[target + point] = value.im;
+                }
+            }
+        }
+        for (slot, range) in direct.momentum_ranges.iter().copied().enumerate() {
+            let semantic = direct.catalog.momentum(slot as u32)?;
+            for component in 0..range.len {
+                let physical = assigned_component(
+                    &direct.layout,
+                    semantic,
+                    count_u32(component, "retained momentum component")?,
+                )? as usize;
+                let target = physical * stride;
+                let source = (range.start + component) * points;
+                for point in 0..points {
+                    real[target + point] = momenta[source + point];
+                    imaginary[target + point] = 0.0;
+                }
+            }
+        }
+        for (coupling_id, row) in direct.plan.couplings.iter().copied().enumerate() {
+            let coupling = resolve_coupling(row, model_parameters);
+            fill_real_input_plane(
+                real,
+                imaginary,
+                stride,
+                assigned_component(
+                    &direct.layout,
+                    direct.catalog.coupling_real(coupling_id as u32)?,
+                    0,
+                )?,
+                points,
+                coupling.re,
+            );
+            fill_real_input_plane(
+                real,
+                imaginary,
+                stride,
+                assigned_component(
+                    &direct.layout,
+                    direct.catalog.coupling_imag(coupling_id as u32)?,
+                    0,
+                )?,
+                points,
+                coupling.im,
+            );
+        }
+        for (parameter_id, value) in model_parameters.iter().copied().enumerate() {
+            let physical = assigned_component(
+                &direct.layout,
+                direct.catalog.parameter(parameter_id as u32)?,
+                0,
+            )? as usize;
+            let target = physical * stride;
+            real[target..target + points].fill(value.re);
+            imaginary[target..target + points].fill(value.im);
+        }
+    }
+    {
+        let (factor_re, factor_im) = direct.workspace.factors_mut();
+        for (index, spec) in direct.factor_specs.iter().copied().enumerate() {
+            let coupling = resolve_coupling(
+                direct.plan.couplings[spec.coupling_slot_id as usize],
+                model_parameters,
+            );
+            let scale = match spec.output_factor_source {
+                EAGER_OUTPUT_FACTOR_NONE => 1.0,
+                EAGER_OUTPUT_FACTOR_COUPLING_REAL => coupling.re,
+                EAGER_OUTPUT_FACTOR_COUPLING_IMAG => coupling.im,
+                _ => {
+                    return Err(RusticolError::integrity(
+                        "retained eager factor has an invalid output-factor source",
+                    ));
+                }
+            };
+            factor_re[index] = spec.factor.re * scale;
+            factor_im[index] = spec.factor.im * scale;
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+fn measure_repeated(
+    repetitions: usize,
+    mut operation: impl FnMut() -> RusticolResult<()>,
+) -> RusticolResult<f64> {
+    use std::time::Instant;
+
+    let started = Instant::now();
+    for _ in 0..repetitions {
+        operation()?;
+    }
+    Ok(started.elapsed().as_nanos() as f64 / repetitions as f64)
+}
+
+#[cfg(test)]
+fn median_mad(values: &mut [f64]) -> (f64, f64) {
+    values.sort_by(f64::total_cmp);
+    let median = values[values.len() / 2];
+    let mut deviations = values
+        .iter()
+        .map(|value| (value - median).abs())
+        .collect::<Vec<_>>();
+    deviations.sort_by(f64::total_cmp);
+    (median, deviations[deviations.len() / 2])
+}
+
+pub(super) fn derive_event_layout(
+    sections: EagerPlanV3Sections<'_>,
+    catalog: SemanticCatalog,
+    plan: &EagerExecutionPlan,
+) -> RusticolResult<DirectArenaLayout> {
+    let count = catalog.semantic_count as usize;
+    let mut widths = vec![1_u32; count];
+    let mut first = vec![None::<u64>; count];
+    let mut last = vec![None::<u64>; count];
+
+    let mut produced_values = vec![false; sections.values.len()];
+    for row in sections.finalizations {
+        for value in [row.unpropagated_value_slot_id, row.propagated_value_slot_id] {
+            if value != MISSING_U32 {
+                produced_values[value as usize] = true;
+            }
+        }
+    }
+    for row in sections.values {
+        widths[catalog.value(row.value_slot_id)? as usize] = row.component_count;
+        if !produced_values[row.value_slot_id as usize] {
+            define_semantic(&mut first, &mut last, catalog.value(row.value_slot_id)?, 0)?;
+        }
+    }
+    for row in sections.currents {
+        widths[catalog.current(row.current_id)? as usize] = row.component_count;
+    }
+    for row in sections.momenta {
+        let id = catalog.momentum(row.momentum_slot_id)?;
+        widths[id as usize] = row.component_count;
+        define_semantic(&mut first, &mut last, id, 0)?;
+    }
+    for coupling in 0..sections.couplings.len() {
+        define_semantic(
+            &mut first,
+            &mut last,
+            catalog.coupling_real(coupling as u32)?,
+            0,
+        )?;
+        define_semantic(
+            &mut first,
+            &mut last,
+            catalog.coupling_imag(coupling as u32)?,
+            0,
+        )?;
+    }
+    for parameter in 0..sections.prepared_parameter_count {
+        define_semantic(&mut first, &mut last, catalog.parameter(parameter)?, 0)?;
+    }
+
+    let mut event = 1_u64;
+    for stage in &plan.stages {
+        // The validated plan has already applied the stable equal-kernel sort
+        // used by both packet and Direct-Arena execution. Liveness must follow
+        // this execution order rather than the producer table order.
+        for invocation in &stage.invocations {
+            let row = invocation.row;
+            use_semantic(
+                &first,
+                &mut last,
+                catalog.value(row.left_value_slot_id)?,
+                event,
+            )?;
+            use_semantic(
+                &first,
+                &mut last,
+                catalog.value(row.right_value_slot_id)?,
+                event,
+            )?;
+            use_semantic(
+                &first,
+                &mut last,
+                catalog.momentum(row.left_momentum_slot_id)?,
+                event,
+            )?;
+            use_semantic(
+                &first,
+                &mut last,
+                catalog.momentum(row.right_momentum_slot_id)?,
+                event,
+            )?;
+            use_semantic(
+                &first,
+                &mut last,
+                catalog.coupling_real(row.coupling_slot_id)?,
+                event,
+            )?;
+            use_semantic(
+                &first,
+                &mut last,
+                catalog.coupling_imag(row.coupling_slot_id)?,
+                event,
+            )?;
+            touch_kernel_parameters(
+                plan.kernels.get(&row.kernel_id),
+                catalog,
+                &first,
+                &mut last,
+                event,
+            )?;
+            for attachment in &stage.attachments[invocation.attachment_range.clone()] {
+                define_or_use_semantic(
+                    &mut first,
+                    &mut last,
+                    catalog.current(attachment.row.result_current_id)?,
+                    event,
+                )?;
+            }
+            event = event
+                .checked_add(1)
+                .ok_or_else(|| invalid("eager direct event index overflows"))?;
+        }
+
+        // Packet execution performs every unpropagated copy before any
+        // propagated finalization call. Sharing current/value planes therefore
+        // requires distinct events in precisely that order.
+        for copy in &stage.finalization_copies {
+            let current_id = stage_current_id_for_layout(stage, copy.current)?;
+            let value_id = plan
+                .values
+                .id_for_range(copy.unpropagated, "eager direct finalization copy")?;
+            use_semantic(&first, &mut last, catalog.current(current_id)?, event)?;
+            define_semantic(&mut first, &mut last, catalog.value(value_id)?, event)?;
+            event = event
+                .checked_add(1)
+                .ok_or_else(|| invalid("eager direct event index overflows"))?;
+        }
+        for item in &stage.finalizations {
+            let row = item.row;
+            use_semantic(&first, &mut last, catalog.current(row.current_id)?, event)?;
+            use_semantic(
+                &first,
+                &mut last,
+                catalog.momentum(row.momentum_slot_id)?,
+                event,
+            )?;
+            let propagated = item.propagated.ok_or_else(|| {
+                RusticolError::internal("eager direct finalization lost propagated output")
+            })?;
+            let value_id = plan
+                .values
+                .id_for_range(propagated, "eager direct propagated finalization")?;
+            define_semantic(&mut first, &mut last, catalog.value(value_id)?, event)?;
+            touch_kernel_parameters(
+                plan.kernels.get(&row.kernel_id),
+                catalog,
+                &first,
+                &mut last,
+                event,
+            )?;
+            event = event
+                .checked_add(1)
+                .ok_or_else(|| invalid("eager direct event index overflows"))?;
+        }
+    }
+    for closure in &plan.closures {
+        let row = closure.row;
+        use_semantic(
+            &first,
+            &mut last,
+            catalog.value(row.left_value_slot_id)?,
+            event,
+        )?;
+        use_semantic(
+            &first,
+            &mut last,
+            catalog.value(row.right_value_slot_id)?,
+            event,
+        )?;
+        if row.coupling_slot_id != MISSING_U32 {
+            use_semantic(
+                &first,
+                &mut last,
+                catalog.coupling_real(row.coupling_slot_id)?,
+                event,
+            )?;
+            use_semantic(
+                &first,
+                &mut last,
+                catalog.coupling_imag(row.coupling_slot_id)?,
+                event,
+            )?;
+        }
+        touch_kernel_parameters(
+            plan.kernels.get(&row.kernel_id),
+            catalog,
+            &first,
+            &mut last,
+            event,
+        )?;
+        event = event
+            .checked_add(1)
+            .ok_or_else(|| invalid("eager direct event index overflows"))?;
+    }
+    for closure in &plan.direct_closures {
+        use_semantic(
+            &first,
+            &mut last,
+            catalog.value(closure.row.left_value_slot_id)?,
+            event,
+        )?;
+        use_semantic(
+            &first,
+            &mut last,
+            catalog.value(closure.row.right_value_slot_id)?,
+            event,
+        )?;
+        event = event
+            .checked_add(1)
+            .ok_or_else(|| invalid("eager direct event index overflows"))?;
+    }
+    let final_event = event.saturating_sub(1);
+    for id in catalog.momentum_start..catalog.semantic_count {
+        if first[id as usize].is_some() {
+            last[id as usize] = Some(final_event);
+        }
+    }
+    let intervals = widths
+        .into_iter()
+        .enumerate()
+        .map(|(id, width)| {
+            let first_use = first[id].unwrap_or(0);
+            let last_use = last[id].unwrap_or(final_event).max(first_use);
+            DirectArenaInterval::new(id as u32, first_use, last_use, width)
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    assign_direct_arena(&intervals)
+}
+
+fn stage_current_id_for_layout(
+    stage: &super::plan::EagerStagePlan,
+    range: ComponentRange,
+) -> RusticolResult<u32> {
+    stage
+        .finalizations
+        .iter()
+        .find_map(|item| (item.current == range).then_some(item.row.current_id))
+        .or_else(|| {
+            stage
+                .attachments
+                .iter()
+                .find_map(|item| (item.current == range).then_some(item.row.result_current_id))
+        })
+        .ok_or_else(|| RusticolError::internal("eager direct liveness lost a stage current"))
+}
+
+fn touch_kernel_parameters(
+    kernel: Option<&super::EagerKernelSpec>,
+    catalog: SemanticCatalog,
+    first: &[Option<u64>],
+    last: &mut [Option<u64>],
+    event: u64,
+) -> RusticolResult<()> {
+    let Some(kernel) = kernel else {
+        return Ok(());
+    };
+    for input in &kernel.inputs {
+        if let EagerKernelInput::ModelParameter(parameter) = *input {
+            use_semantic(first, last, catalog.parameter(parameter)?, event)?;
+        }
+    }
+    Ok(())
+}
+
+fn encode_invocation_inputs(
+    output: &mut Vec<u8>,
+    invocation: &ScheduledInvocation,
+    descriptors: &[EagerKernelInput],
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+) -> RusticolResult<()> {
+    for descriptor in descriptors {
+        let (semantic, component) = match *descriptor {
+            EagerKernelInput::FirstCurrentComponent(component) => {
+                (catalog.value(invocation.row.left_value_slot_id)?, component)
+            }
+            EagerKernelInput::SecondCurrentComponent(component) => (
+                catalog.value(invocation.row.right_value_slot_id)?,
+                component,
+            ),
+            EagerKernelInput::FirstMomentumComponent(component) => (
+                catalog.momentum(invocation.row.left_momentum_slot_id)?,
+                component,
+            ),
+            EagerKernelInput::SecondMomentumComponent(component) => (
+                catalog.momentum(invocation.row.right_momentum_slot_id)?,
+                component,
+            ),
+            EagerKernelInput::CouplingReal => {
+                (catalog.coupling_real(invocation.row.coupling_slot_id)?, 0)
+            }
+            EagerKernelInput::CouplingImag => {
+                (catalog.coupling_imag(invocation.row.coupling_slot_id)?, 0)
+            }
+            EagerKernelInput::ModelParameter(parameter) => (catalog.parameter(parameter)?, 0),
+        };
+        let physical = assigned_component(layout, semantic, component)?;
+        push_u32(
+            output,
+            physical
+                .checked_mul(2)
+                .ok_or_else(|| invalid("eager direct plane catalog overflows"))?,
+        );
+        push_u32(
+            output,
+            physical
+                .checked_mul(2)
+                .and_then(|value| value.checked_add(1))
+                .ok_or_else(|| invalid("eager direct plane catalog overflows"))?,
+        );
+    }
+    Ok(())
+}
+
+fn encode_attachment_destinations(
+    output: &mut Vec<u8>,
+    attachment: &ScheduledAttachment,
+    output_component_count: u32,
+    catalog: SemanticCatalog,
+    layout: &DirectArenaLayout,
+) -> RusticolResult<()> {
+    if attachment.current.len != output_component_count as usize {
+        return Err(RusticolError::integrity(
+            "eager direct attachment width does not match its kernel output",
+        ));
+    }
+    let semantic = catalog.current(attachment.row.result_current_id)?;
+    for component in 0..output_component_count {
+        let physical = assigned_component(layout, semantic, component)?;
+        push_u32(
+            output,
+            physical
+                .checked_mul(2)
+                .ok_or_else(|| invalid("eager direct destination catalog overflows"))?,
+        );
+        push_u32(
+            output,
+            physical
+                .checked_mul(2)
+                .and_then(|value| value.checked_add(1))
+                .ok_or_else(|| invalid("eager direct destination catalog overflows"))?,
+        );
+    }
+    Ok(())
+}
+
+pub(super) fn row_active(
+    plan: &EagerExecutionPlan,
+    domain: Option<u32>,
+    active_groups: Option<&[u32]>,
+) -> RusticolResult<bool> {
+    let Some(active_groups) = active_groups else {
+        return Ok(true);
+    };
+    // An explicitly empty runtime selector is a structural zero, including
+    // for legacy/domain-less rows. It must never fall through to an
+    // unconditional row.
+    if active_groups.is_empty() {
+        return Ok(false);
+    }
+    let Some(domain) = domain else {
+        return Ok(true);
+    };
+    let selector = plan.selector_domains.as_ref().ok_or_else(|| {
+        RusticolError::integrity("eager direct selector row has no selector-domain plan")
+    })?;
+    let members = selector.memberships.get(domain as usize).ok_or_else(|| {
+        RusticolError::integrity("eager direct row references an unknown selector domain")
+    })?;
+    Ok(members
+        .iter()
+        .any(|member| active_groups.binary_search(member).is_ok()))
+}
+
+fn retained_attachment_operation(written_currents: &mut BTreeSet<u32>, current_id: u32) -> u32 {
+    u32::from(!written_currents.insert(current_id))
+}
+
+pub(super) fn validate_active_groups(
+    plan: &EagerExecutionPlan,
+    active_groups: Option<&[u32]>,
+) -> RusticolResult<()> {
+    let Some(active_groups) = active_groups else {
+        return Ok(());
+    };
+    if active_groups.windows(2).any(|pair| pair[0] >= pair[1]) {
+        return Err(invalid(
+            "eager direct active groups must be sorted and unique",
+        ));
+    }
+    let selector = plan.selector_domains.as_ref().ok_or_else(|| {
+        RusticolError::compatibility(
+            "eager direct selector specialization requires selector domains",
+        )
+    })?;
+    if let Some(unknown) = active_groups
+        .iter()
+        .find(|group| selector.group_ids.binary_search(group).is_err())
+    {
+        return Err(invalid(format!(
+            "eager direct selector references unknown group {unknown}"
+        )));
+    }
+    Ok(())
+}
+
+pub(super) fn validate_callable_identity(
+    kernel: &EagerKernelSpec,
+    prepared: &EagerDirectPreparedKernel<'_>,
+) -> RusticolResult<()> {
+    if prepared.role != kernel.role
+        || prepared.inputs != kernel.inputs
+        || prepared.output_component_count != kernel.output_component_count
+    {
+        return Err(RusticolError::integrity(format!(
+            "eager direct callable identity for kernel {} does not match its plan spec: \
+             role {:?}/{:?}, ordered inputs {:?}/{:?}, output width {}/{}",
+            kernel.kernel_id,
+            prepared.role,
+            kernel.role,
+            prepared.inputs,
+            kernel.inputs,
+            prepared.output_component_count,
+            kernel.output_component_count,
+        )));
+    }
+    Ok(())
+}
+
+pub(super) fn assigned_component(
+    layout: &DirectArenaLayout,
+    semantic: u32,
+    component: u32,
+) -> RusticolResult<u32> {
+    let assignment = layout.assignment(semantic).ok_or_else(|| {
+        RusticolError::integrity(format!(
+            "eager direct layout lost semantic value {semantic}"
+        ))
+    })?;
+    if component >= assignment.component_count {
+        return Err(RusticolError::integrity(format!(
+            "eager direct semantic value {semantic} component {component} is out of bounds"
+        )));
+    }
+    assignment
+        .component_base
+        .checked_add(component)
+        .ok_or_else(|| invalid("eager direct component assignment overflows"))
+}
+
+pub(super) fn resolve_coupling(
+    row: crate::EagerCouplingRow,
+    parameters: &[EagerComplex64],
+) -> EagerComplex64 {
+    let real = if row.real_parameter_id == MISSING_U32 {
+        row.constant_real
+    } else {
+        parameters[row.real_parameter_id as usize].re
+    };
+    let imaginary = if row.imag_parameter_id == MISSING_U32 {
+        row.constant_imag
+    } else {
+        parameters[row.imag_parameter_id as usize].re
+    };
+    EagerComplex64::new(real, imaginary)
+}
+
+fn fill_real_input_plane(
+    real: &mut [f64],
+    imaginary: &mut [f64],
+    stride: usize,
+    physical: u32,
+    points: usize,
+    value: f64,
+) {
+    let start = physical as usize * stride;
+    real[start..start + points].fill(value);
+    imaginary[start..start + points].fill(0.0);
+}
+
+fn define_semantic(
+    first: &mut [Option<u64>],
+    last: &mut [Option<u64>],
+    id: u32,
+    event: u64,
+) -> RusticolResult<()> {
+    let index = id as usize;
+    if first[index].replace(event).is_some() {
+        return Err(RusticolError::integrity(format!(
+            "eager direct semantic value {id} is defined more than once"
+        )));
+    }
+    last[index] = Some(event);
+    Ok(())
+}
+
+fn define_or_use_semantic(
+    first: &mut [Option<u64>],
+    last: &mut [Option<u64>],
+    id: u32,
+    event: u64,
+) -> RusticolResult<()> {
+    let index = id as usize;
+    if first[index].is_none() {
+        first[index] = Some(event);
+    }
+    last[index] = Some(event);
+    Ok(())
+}
+
+fn use_semantic(
+    first: &[Option<u64>],
+    last: &mut [Option<u64>],
+    id: u32,
+    event: u64,
+) -> RusticolResult<()> {
+    if first[id as usize].is_none() {
+        return Err(RusticolError::integrity(format!(
+            "eager direct semantic value {id} is used before definition"
+        )));
+    }
+    last[id as usize] = Some(event);
+    Ok(())
+}
+
+fn checked_semantic(start: u32, id: u32, stop: u32, label: &str) -> RusticolResult<u32> {
+    start
+        .checked_add(id)
+        .filter(|value| *value < stop)
+        .ok_or_else(|| invalid(format!("eager direct {label} id {id} is out of bounds")))
+}
+
+pub(super) fn validate_component_buffer(
+    label: &str,
+    actual: usize,
+    components: usize,
+    points: u32,
+) -> RusticolResult<()> {
+    let expected = components
+        .checked_mul(points as usize)
+        .ok_or_else(|| invalid(format!("eager direct {label} length overflows")))?;
+    if actual != expected {
+        return Err(invalid(format!(
+            "eager direct {label} has length {actual}, expected {expected}"
+        )));
+    }
+    Ok(())
+}
+
+fn row_range<'a, T>(rows: &'a [T], start: u64, count: u64, label: &str) -> RusticolResult<&'a [T]> {
+    let start = usize::try_from(start)
+        .map_err(|_| invalid(format!("eager direct {label} start exceeds usize")))?;
+    let count = usize::try_from(count)
+        .map_err(|_| invalid(format!("eager direct {label} count exceeds usize")))?;
+    let stop = start
+        .checked_add(count)
+        .ok_or_else(|| invalid(format!("eager direct {label} range overflows")))?;
+    rows.get(start..stop)
+        .ok_or_else(|| invalid(format!("eager direct {label} range is out of bounds")))
+}
+
+pub(super) fn count_u32(value: usize, label: &str) -> RusticolResult<u32> {
+    u32::try_from(value).map_err(|_| invalid(format!("eager direct {label} count exceeds u32")))
+}
+
+pub(super) fn push_u32(output: &mut Vec<u8>, value: u32) {
+    output.extend_from_slice(&value.to_le_bytes());
+}
+
+pub(super) fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+#[cfg(all(test, feature = "f64-symjit", target_arch = "aarch64"))]
+mod tests {
+    use std::hint::black_box;
+    use std::time::Instant;
+
+    use symjit::{Applet, Application, Compiler, Config, Expr};
+
+    use super::super::plan_v3_tests::Fixture;
+    use super::*;
+    use crate::engine::compile_symbolica_program_to_plane_application_bytes;
+    use crate::engine::count_allocations;
+    use crate::engine::symjit_eager_direct::eager_direct_descriptor_for_source_application_bytes;
+
+    fn source_application() -> Application {
+        let mut config = Config::default();
+        config.set_opt_level(2);
+        config.set_complex(true);
+        config.set_symbolica(true);
+        config.set_simd(true);
+        config.set_fast_complex(false);
+        let x = Expr::var("x");
+        let y = Expr::var("y");
+        let coupling = Expr::var("coupling");
+        Compiler::with_config(config)
+            .compile_params(&[], &[&x + &y], &[x, y, coupling])
+            .unwrap()
+    }
+
+    fn ordinary_applet() -> Applet {
+        let mut source = source_application();
+        source.prepare_simd();
+        source.seal().unwrap()
+    }
+
+    fn source_and_descriptor() -> (Vec<u8>, Vec<u8>) {
+        let bytes = compile_symbolica_program_to_plane_application_bytes(
+            "([('add', ('temp', 0), [('param', 0), ('param', 1)], 0), \
+              ('assign', ('out', 0), ('temp', 0))], 3, [])",
+            3,
+            1,
+            2,
+            true,
+        )
+        .unwrap();
+        let descriptor = eager_direct_descriptor_for_source_application_bytes(
+            &bytes,
+            3,
+            1,
+            std::path::Path::new("eager-invocation-test.symjit"),
+        )
+        .unwrap();
+        (bytes, descriptor)
+    }
+
+    fn fanout_fixture() -> Fixture {
+        let mut fixture = Fixture::new();
+        fixture.currents.push(crate::EagerPlanCurrentRow {
+            current_id: 3,
+            component_start: 3,
+            component_count: 1,
+            momentum_slot_id: 3,
+            flags: 0,
+        });
+        fixture.values.push(crate::EagerPlanValueRow {
+            value_slot_id: 3,
+            current_id: 3,
+            component_start: 3,
+            component_count: 1,
+            kind: crate::EagerValueSlotKind::Unpropagated,
+        });
+        fixture.momenta.push(crate::EagerPlanMomentumRow {
+            momentum_slot_id: 3,
+            bitset_id: 3,
+            component_start: 12,
+            component_count: 4,
+        });
+        let mut second_attachment = fixture.attachments[0];
+        second_attachment.result_current_id = 3;
+        fixture.attachments.push(second_attachment);
+        fixture.invocations[0].attachment_count = 2;
+        fixture.stages[0].attachment_count = 2;
+        fixture.stages[0].finalization_count = 2;
+        let mut second_finalization = fixture.finalizations[0];
+        second_finalization.current_id = 3;
+        second_finalization.unpropagated_value_slot_id = 3;
+        second_finalization.momentum_slot_id = 3;
+        fixture.finalizations.push(second_finalization);
+        let mut second_closure = fixture.closures[0];
+        second_closure.root_id = 1;
+        second_closure.left_value_slot_id = 3;
+        fixture.closures.push(second_closure);
+        fixture
+    }
+
+    fn inputs(points: usize) -> (Vec<EagerComplex64>, Vec<f64>) {
+        let mut values = vec![EagerComplex64::new(-91.0, 37.0); 4 * points];
+        for point in 0..points {
+            values[point] = EagerComplex64::new(1.0 + point as f64 / 8.0, -0.25 * point as f64);
+            values[points + point] =
+                EagerComplex64::new(3.0 + point as f64 / 4.0, 0.5 * point as f64);
+        }
+        let momenta = (0..16 * points).map(|index| index as f64 / 16.0).collect();
+        (values, momenta)
+    }
+
+    struct PacketOracle {
+        applet: Applet,
+        inputs: Vec<EagerComplex64>,
+        outputs: Vec<EagerComplex64>,
+        currents: Vec<EagerComplex64>,
+    }
+
+    impl PacketOracle {
+        fn new(capacity: usize) -> Self {
+            Self {
+                applet: ordinary_applet(),
+                inputs: vec![EagerComplex64::new(0.0, 0.0); 3 * capacity],
+                outputs: vec![EagerComplex64::new(0.0, 0.0); capacity],
+                currents: vec![EagerComplex64::new(0.0, 0.0); capacity],
+            }
+        }
+
+        fn evaluate(&mut self, points: usize, values: &[EagerComplex64]) {
+            for point in 0..points {
+                self.inputs[3 * point] = values[point];
+                self.inputs[3 * point + 1] = values[points + point];
+                self.inputs[3 * point + 2] = EagerComplex64::new(2.0, 3.0);
+            }
+            self.applet.evaluate_matrix(
+                &self.inputs[..3 * points],
+                &mut self.outputs[..points],
+                points,
+            );
+            for point in 0..points {
+                let contribution = self.outputs[point] * EagerComplex64::new(15.0, 0.0);
+                self.currents[point] = contribution;
+            }
+        }
+    }
+
+    fn prototype<'a>(
+        fixture: &Fixture,
+        source: &'a [u8],
+        descriptor: &'a [u8],
+        active_groups: Option<&[u32]>,
+    ) -> EagerDirectInvocationPrototype {
+        let inputs = [
+            EagerKernelInput::FirstCurrentComponent(0),
+            EagerKernelInput::SecondCurrentComponent(0),
+            EagerKernelInput::CouplingReal,
+        ];
+        let artifact = EagerDirectPreparedKernel {
+            kernel_id: 10,
+            role: EagerKernelRole::Vertex,
+            inputs: &inputs,
+            output_component_count: 1,
+            application: EagerDirectPreparedApplication::Symjit {
+                source_application: source,
+                descriptor,
+                expected_optimization_level: 2,
+                expected_compression: true,
+            },
+            display_path: PathBuf::from("real-plan-v3-eager-k10.symjit"),
+        };
+        EagerDirectInvocationPrototype::from_plan_v3_sections(
+            fixture.sections(),
+            &[artifact],
+            active_groups,
+            129,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn real_plan_v3_rows_match_packet_oracle_for_fanout_and_tails() {
+        let fixture = fanout_fixture();
+        let (source, descriptor) = source_and_descriptor();
+        let mut direct = prototype(&fixture, &source, &descriptor, None);
+        assert!(
+            direct.layout().reused_semantic_components() > 0,
+            "event-derived layout should reuse at least one dead semantic range"
+        );
+        let mut packet = PacketOracle::new(129);
+        for points in [7_usize, 127, 128, 129] {
+            let (values, momenta) = inputs(points);
+            direct
+                .evaluate_invocations(points as u32, &values, &momenta, &[])
+                .unwrap();
+            packet.evaluate(points, &values);
+            for (point, expected) in packet.currents[..points].iter().copied().enumerate() {
+                let actual = direct.current_value(2, 0, point as u32).unwrap();
+                assert_eq!(
+                    (actual.re.to_bits(), actual.im.to_bits()),
+                    (expected.re.to_bits(), expected.im.to_bits()),
+                    "point {point} at tail {points}"
+                );
+                let second = direct.current_value(3, 0, point as u32).unwrap();
+                assert_eq!(
+                    (second.re.to_bits(), second.im.to_bits()),
+                    (expected.re.to_bits(), expected.im.to_bits()),
+                    "second fanout destination at point {point} tail {points}"
+                );
+            }
+        }
+        let traffic = direct.traffic();
+        assert!(traffic.calls >= 4);
+        assert!(traffic.rows >= 4);
+        assert_eq!(
+            (
+                traffic.packet_input_bytes,
+                traffic.packet_output_bytes,
+                traffic.gather_bytes,
+                traffic.scatter_bytes,
+                traffic.remap_bytes,
+            ),
+            (0, 0, 0, 0, 0)
+        );
+    }
+
+    #[test]
+    fn empty_runtime_selector_is_a_structural_zero_without_a_table_call() {
+        let fixture = fanout_fixture();
+        let mut direct = EagerDirectInvocationPrototype::from_plan_v3_sections(
+            fixture.sections(),
+            &[],
+            Some(&[]),
+            129,
+        )
+        .unwrap();
+        let (values, momenta) = inputs(129);
+        direct
+            .evaluate_invocations(129, &values, &momenta, &[])
+            .unwrap();
+        for point in 0..129 {
+            let actual = direct.current_value(2, 0, point).unwrap();
+            assert_eq!((actual.re.to_bits(), actual.im.to_bits()), (0, 0));
+            let second = direct.current_value(3, 0, point).unwrap();
+            assert_eq!((second.re.to_bits(), second.im.to_bits()), (0, 0));
+        }
+        assert_eq!(direct.traffic().calls, 0);
+        direct.traffic().validate_direct().unwrap();
+    }
+
+    #[test]
+    fn empty_runtime_selector_prunes_domainless_rows_too() {
+        let fixture = fanout_fixture();
+        let plan = EagerExecutionPlan::from_plan_v3_sections(fixture.sections()).unwrap();
+        assert!(!row_active(&plan, None, Some(&[])).unwrap());
+        assert!(row_active(&plan, None, Some(&[7])).unwrap());
+    }
+
+    #[test]
+    fn selector_pruning_recomputes_first_retained_current_write() {
+        // The full schedule marked the first row as the initializer. Runtime
+        // selection prunes it and retains the second row, whose stale
+        // full-plan flag was "add".
+        let original_initializes = [true, false];
+        let retained = [false, true];
+        let mut written = BTreeSet::new();
+        let operations = original_initializes
+            .into_iter()
+            .zip(retained)
+            .filter(|&(_original, keep)| keep)
+            .map(|_| retained_attachment_operation(&mut written, 23))
+            .collect::<Vec<_>>();
+        assert_eq!(operations, [0], "first retained write must overwrite");
+
+        // Lock the bitwise reason this cannot reuse the stale flag: assigning
+        // -0 preserves its sign, while adding -0 to a cleared +0 loses it.
+        let contribution = -0.0_f64;
+        let mut recomputed = 0.0_f64;
+        if operations[0] == 0 {
+            recomputed = contribution;
+        } else {
+            recomputed += contribution;
+        }
+        let mut stale = 0.0_f64;
+        stale += contribution;
+        assert_eq!(recomputed.to_bits(), contribution.to_bits());
+        assert_ne!(stale.to_bits(), contribution.to_bits());
+    }
+
+    #[test]
+    fn matching_dimension_callable_with_wrong_semantic_identity_is_rejected() {
+        let fixture = fanout_fixture();
+        let (source, descriptor) = source_and_descriptor();
+        let wrong_inputs = [
+            EagerKernelInput::SecondCurrentComponent(0),
+            EagerKernelInput::FirstCurrentComponent(0),
+            EagerKernelInput::CouplingReal,
+        ];
+        let artifact = EagerDirectPreparedKernel {
+            kernel_id: 10,
+            role: EagerKernelRole::Vertex,
+            inputs: &wrong_inputs,
+            output_component_count: 1,
+            application: EagerDirectPreparedApplication::Symjit {
+                source_application: &source,
+                descriptor: &descriptor,
+                expected_optimization_level: 2,
+                expected_compression: true,
+            },
+            display_path: PathBuf::from("wrong-semantic-identity.symjit"),
+        };
+        let result = EagerDirectInvocationPrototype::from_plan_v3_sections(
+            fixture.sections(),
+            &[artifact],
+            None,
+            129,
+        );
+        let Err(error) = result else {
+            panic!("matching dimensions must not authenticate the wrong callable");
+        };
+        assert!(error.to_string().contains("callable identity"));
+        assert!(error.to_string().contains("ordered inputs"));
+    }
+
+    #[test]
+    fn warmed_real_plan_v3_invocation_slice_allocates_zero() {
+        let fixture = fanout_fixture();
+        let (source, descriptor) = source_and_descriptor();
+        let mut direct = prototype(&fixture, &source, &descriptor, None);
+        let (values, momenta) = inputs(129);
+        direct
+            .evaluate_invocations(129, &values, &momenta, &[])
+            .unwrap();
+        let (result, allocations, bytes) =
+            count_allocations(|| direct.evaluate_invocations(129, &values, &momenta, &[]));
+        result.unwrap();
+        assert_eq!((allocations, bytes), (0, 0));
+    }
+
+    #[test]
+    #[ignore = "local interleaved native timing evidence; no timing assertion"]
+    fn benchmark_real_plan_v3_direct_slice_against_packet_execution() {
+        const SAMPLES: usize = 9;
+        const REPETITIONS: usize = 10_000;
+        const POINTS: usize = 129;
+
+        let fixture = fanout_fixture();
+        let (source, descriptor) = source_and_descriptor();
+        let mut direct = prototype(&fixture, &source, &descriptor, None);
+        let (values, momenta) = inputs(POINTS);
+        let mut packet = PacketOracle::new(POINTS);
+        direct
+            .evaluate_invocations(POINTS as u32, &values, &momenta, &[])
+            .unwrap();
+        packet.evaluate(POINTS, &values);
+
+        let mut direct_ns = Vec::with_capacity(SAMPLES);
+        let mut packet_ns = Vec::with_capacity(SAMPLES);
+        for sample in 0..SAMPLES {
+            if sample.is_multiple_of(2) {
+                direct_ns.push(measure_direct(&mut direct, REPETITIONS));
+                packet_ns.push(measure_packet(&mut packet, &values, REPETITIONS));
+            } else {
+                packet_ns.push(measure_packet(&mut packet, &values, REPETITIONS));
+                direct_ns.push(measure_direct(&mut direct, REPETITIONS));
+            }
+        }
+        direct_ns.sort_by(f64::total_cmp);
+        packet_ns.sort_by(f64::total_cmp);
+        let direct_median = direct_ns[SAMPLES / 2];
+        let packet_median = packet_ns[SAMPLES / 2];
+        eprintln!(
+            "eager real-plan-v3 invocation benchmark: samples={SAMPLES} \
+             repetitions={REPETITIONS} points={POINTS} \
+             direct_median_ns/call={direct_median:.3} \
+             packet_median_ns/call={packet_median:.3} \
+             direct_over_packet={:.6}",
+            direct_median / packet_median
+        );
+    }
+
+    fn measure_direct(direct: &mut EagerDirectInvocationPrototype, repetitions: usize) -> f64 {
+        let started = Instant::now();
+        for _ in 0..repetitions {
+            direct.execute_preinitialized_invocations(129).unwrap();
+        }
+        black_box(direct.current_value(2, 0, 0).unwrap());
+        started.elapsed().as_nanos() as f64 / repetitions as f64
+    }
+
+    fn measure_packet(
+        packet: &mut PacketOracle,
+        values: &[EagerComplex64],
+        repetitions: usize,
+    ) -> f64 {
+        let started = Instant::now();
+        for _ in 0..repetitions {
+            packet.evaluate(129, values);
+        }
+        black_box(packet.currents[0]);
+        started.elapsed().as_nanos() as f64 / repetitions as f64
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/execute.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/execute.rs
new file mode 100644
index 0000000000..8678cd0a2f
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/execute.rs
@@ -0,0 +1,2440 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::plan::{
+    ClosureExecutionRows, ComponentRange, EagerExecutionPlan, EagerStagePlan, ScheduledAttachment,
+    ScheduledClosure, ScheduledDirectClosure, ScheduledFinalization, ScheduledInvocation,
+};
+use super::runtime::{
+    EagerWorkspace, KernelPacket, LinearFinalizationPacket, PacketRole, StageSchedule,
+};
+use super::{
+    EagerComplex64, EagerKernelBackend, EagerKernelCall, EagerKernelInput, EagerKernelSpec,
+};
+use crate::{
+    EAGER_OUTPUT_FACTOR_COUPLING_IMAG, EAGER_OUTPUT_FACTOR_COUPLING_REAL, EAGER_OUTPUT_FACTOR_NONE,
+    RusticolError, RusticolResult,
+};
+use std::collections::BTreeMap;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) enum AccumulationFactor {
+    One,
+    NegativeOne,
+    ImaginaryUnit,
+    NegativeImaginaryUnit,
+    Real(f64),
+    Imaginary(f64),
+    Generic(EagerComplex64),
+}
+
+impl AccumulationFactor {
+    #[inline]
+    pub(super) fn from_parts(real: f64, imag: f64) -> Self {
+        match (real, imag) {
+            (1.0, 0.0) => Self::One,
+            (-1.0, 0.0) => Self::NegativeOne,
+            (0.0, 1.0) => Self::ImaginaryUnit,
+            (0.0, -1.0) => Self::NegativeImaginaryUnit,
+            (_, 0.0) => Self::Real(real),
+            (0.0, _) => Self::Imaginary(imag),
+            _ => Self::Generic(EagerComplex64::new(real, imag)),
+        }
+    }
+
+    #[inline(always)]
+    pub(super) fn accumulate(self, target: &mut EagerComplex64, value: EagerComplex64) {
+        match self {
+            Self::One => *target += value,
+            Self::NegativeOne => *target -= value,
+            Self::ImaginaryUnit => {
+                target.re -= value.im;
+                target.im += value.re;
+            }
+            Self::NegativeImaginaryUnit => {
+                target.re += value.im;
+                target.im -= value.re;
+            }
+            Self::Real(factor) => {
+                target.re += factor * value.re;
+                target.im += factor * value.im;
+            }
+            Self::Imaginary(factor) => {
+                target.re -= factor * value.im;
+                target.im += factor * value.re;
+            }
+            Self::Generic(factor) => *target += factor * value,
+        }
+    }
+
+    #[inline(always)]
+    pub(super) fn assign(self, target: &mut EagerComplex64, value: EagerComplex64) {
+        *target = match self {
+            Self::One => value,
+            Self::NegativeOne => -value,
+            Self::ImaginaryUnit => EagerComplex64::new(-value.im, value.re),
+            Self::NegativeImaginaryUnit => EagerComplex64::new(value.im, -value.re),
+            Self::Real(factor) => EagerComplex64::new(factor * value.re, factor * value.im),
+            Self::Imaginary(factor) => EagerComplex64::new(-factor * value.im, factor * value.re),
+            Self::Generic(factor) => factor * value,
+        };
+    }
+
+    #[inline]
+    #[allow(clippy::too_many_arguments)]
+    fn scatter_strided(
+        self,
+        initializes: bool,
+        source: &[EagerComplex64],
+        source_start: usize,
+        source_stride: usize,
+        target: &mut [EagerComplex64],
+        target_start: usize,
+        count: usize,
+    ) {
+        debug_assert!(count == 0 || source_start + (count - 1) * source_stride < source.len());
+        debug_assert!(target_start + count <= target.len());
+        // Bounds are established above from validated packet/current ranges.
+        // Specializing the factor outside the point loop avoids repeated enum
+        // dispatch in the eager scatter hot path.
+        unsafe {
+            let mut source_ptr = source.as_ptr().add(source_start);
+            let mut target_ptr = target.as_mut_ptr().add(target_start);
+            macro_rules! scatter {
+                ($operation:expr) => {
+                    for _ in 0..count {
+                        let value = *source_ptr;
+                        $operation(&mut *target_ptr, value);
+                        source_ptr = source_ptr.add(source_stride);
+                        target_ptr = target_ptr.add(1);
+                    }
+                };
+            }
+            match (initializes, self) {
+                (true, Self::One) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = value
+                    })
+                }
+                (true, Self::NegativeOne) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = -value
+                    })
+                }
+                (true, Self::ImaginaryUnit) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = EagerComplex64::new(-value.im, value.re)
+                    })
+                }
+                (true, Self::NegativeImaginaryUnit) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = EagerComplex64::new(value.im, -value.re)
+                    })
+                }
+                (true, Self::Real(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = EagerComplex64::new(factor * value.re, factor * value.im)
+                    })
+                }
+                (true, Self::Imaginary(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = EagerComplex64::new(-factor * value.im, factor * value.re)
+                    })
+                }
+                (true, Self::Generic(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = factor * value
+                    })
+                }
+                (false, Self::One) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target += value
+                    })
+                }
+                (false, Self::NegativeOne) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target -= value
+                    })
+                }
+                (false, Self::ImaginaryUnit) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        target.re -= value.im;
+                        target.im += value.re;
+                    })
+                }
+                (false, Self::NegativeImaginaryUnit) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        target.re += value.im;
+                        target.im -= value.re;
+                    })
+                }
+                (false, Self::Real(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        target.re += factor * value.re;
+                        target.im += factor * value.im;
+                    })
+                }
+                (false, Self::Imaginary(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        target.re -= factor * value.im;
+                        target.im += factor * value.re;
+                    })
+                }
+                (false, Self::Generic(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target += factor * value
+                    })
+                }
+            }
+        }
+    }
+
+    #[inline]
+    #[allow(clippy::too_many_arguments)]
+    fn scatter_interleaved<const COMPONENTS: usize>(
+        self,
+        initializes: bool,
+        source: &[EagerComplex64],
+        source_start: usize,
+        target: &mut [EagerComplex64],
+        target_component_start: usize,
+        target_component_stride: usize,
+        count: usize,
+    ) {
+        self.scatter_interleaved_strided::<COMPONENTS>(
+            initializes,
+            source,
+            source_start,
+            COMPONENTS,
+            target,
+            target_component_start,
+            target_component_stride,
+            count,
+        );
+    }
+
+    #[inline]
+    #[allow(clippy::too_many_arguments)]
+    fn scatter_interleaved_strided<const COMPONENTS: usize>(
+        self,
+        initializes: bool,
+        source: &[EagerComplex64],
+        source_start: usize,
+        source_row_stride: usize,
+        target: &mut [EagerComplex64],
+        target_component_start: usize,
+        target_component_stride: usize,
+        count: usize,
+    ) {
+        debug_assert!(COMPONENTS > 0);
+        debug_assert!(source_row_stride >= COMPONENTS);
+        debug_assert!(
+            count == 0
+                || source_start + (count - 1) * source_row_stride + COMPONENTS <= source.len()
+        );
+        debug_assert!(
+            count == 0
+                || (target_component_start + COMPONENTS - 1) * target_component_stride + count
+                    <= target.len()
+        );
+        // SymJIT returns lane-major rows while eager current storage is
+        // component-major. Handle the common small output widths in one pass
+        // so source reads stay contiguous and each target component advances
+        // linearly.
+        unsafe {
+            let mut source_ptr = source.as_ptr().add(source_start);
+            let target_base = target.as_mut_ptr();
+            let mut target_ptrs = [target_base; COMPONENTS];
+            for (component, target_ptr) in target_ptrs.iter_mut().enumerate() {
+                *target_ptr =
+                    target_base.add((target_component_start + component) * target_component_stride);
+            }
+            macro_rules! scatter {
+                ($operation:expr) => {
+                    for _ in 0..count {
+                        for component in 0..COMPONENTS {
+                            let value = *source_ptr.add(component);
+                            $operation(&mut *target_ptrs[component], value);
+                            target_ptrs[component] = target_ptrs[component].add(1);
+                        }
+                        source_ptr = source_ptr.add(source_row_stride);
+                    }
+                };
+            }
+            match (initializes, self) {
+                (true, Self::One) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| *target = value)
+                }
+                (true, Self::NegativeOne) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| *target = -value)
+                }
+                (true, Self::ImaginaryUnit) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = EagerComplex64::new(-value.im, value.re)
+                    })
+                }
+                (true, Self::NegativeImaginaryUnit) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = EagerComplex64::new(value.im, -value.re)
+                    })
+                }
+                (true, Self::Real(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = EagerComplex64::new(factor * value.re, factor * value.im)
+                    })
+                }
+                (true, Self::Imaginary(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target = EagerComplex64::new(-factor * value.im, factor * value.re)
+                    })
+                }
+                (true, Self::Generic(factor)) => scatter!(
+                    |target: &mut EagerComplex64, value: EagerComplex64| *target = factor * value
+                ),
+                (false, Self::One) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| *target += value)
+                }
+                (false, Self::NegativeOne) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| *target -= value)
+                }
+                (false, Self::ImaginaryUnit) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        target.re -= value.im;
+                        target.im += value.re;
+                    })
+                }
+                (false, Self::NegativeImaginaryUnit) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        target.re += value.im;
+                        target.im -= value.re;
+                    })
+                }
+                (false, Self::Real(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        target.re += factor * value.re;
+                        target.im += factor * value.im;
+                    })
+                }
+                (false, Self::Imaginary(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        target.re -= factor * value.im;
+                        target.im += factor * value.re;
+                    })
+                }
+                (false, Self::Generic(factor)) => {
+                    scatter!(|target: &mut EagerComplex64, value: EagerComplex64| {
+                        *target += factor * value
+                    })
+                }
+            }
+        }
+    }
+}
+
+#[inline(always)]
+fn output_factor_scale(source: u32, coupling: EagerComplex64) -> f64 {
+    match source {
+        EAGER_OUTPUT_FACTOR_NONE => 1.0,
+        EAGER_OUTPUT_FACTOR_COUPLING_REAL => coupling.re,
+        EAGER_OUTPUT_FACTOR_COUPLING_IMAG => coupling.im,
+        _ => unreachable!("validated eager output factor source"),
+    }
+}
+
+pub(super) fn initialize_tile(
+    plan: &EagerExecutionPlan,
+    workspace: &mut EagerWorkspace,
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    initial_values: &[EagerComplex64],
+    zero_amplitude_indices: &[usize],
+) {
+    for range in &plan.initial_value_ranges {
+        for component in range.start..range.start + range.len {
+            let source = component * point_count + tile_start;
+            let target = component * workspace.tile_capacity;
+            workspace.values[target..target + tile_points]
+                .copy_from_slice(&initial_values[source..source + tile_points]);
+        }
+    }
+    for amplitude in zero_amplitude_indices {
+        let target = amplitude * workspace.tile_capacity;
+        workspace.amplitudes[target..target + tile_points].fill(EagerComplex64::new(0.0, 0.0));
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn execute_stage<B: EagerKernelBackend>(
+    stage: &EagerStagePlan,
+    schedule: &StageSchedule,
+    kernels: &BTreeMap<u32, EagerKernelSpec>,
+    workspace: &mut EagerWorkspace,
+    backend: &mut B,
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+) -> RusticolResult<()> {
+    for range in &stage.zero_current_ranges {
+        for component in range.start..range.start + range.len {
+            let target = component * workspace.tile_capacity;
+            workspace.currents[target..target + tile_points].fill(EagerComplex64::new(0.0, 0.0));
+        }
+    }
+    for packet in &schedule.invocation_packets {
+        debug_assert_eq!(packet.role, PacketRole::Invocation);
+        let items = &stage.invocations[packet.item_range.clone()];
+        let (lane_count, evaluator_input_components, evaluator_output_components) =
+            invocation_packet_shape(packet, items.len(), tile_points)?;
+        let input_len = evaluator_input_components * lane_count;
+        let output_len = evaluator_output_components * lane_count;
+        let (inputs, outputs) = packet_slices(&mut workspace.packet, input_len, output_len)?;
+        let kernel = kernels.get(&packet.kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!(
+                "eager schedule lost invocation kernel {}",
+                packet.kernel_id
+            ))
+        })?;
+        if packet.independent_block_size == 1 {
+            gather_invocations(
+                items,
+                &kernel.inputs,
+                inputs,
+                packet.input_components,
+                point_count,
+                tile_start,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.values,
+                momenta,
+                &workspace.couplings,
+                model_parameters,
+            );
+        } else {
+            gather_blocked_invocations(
+                items,
+                &kernel.inputs,
+                inputs,
+                packet.input_components,
+                packet.independent_block_size,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.values,
+            );
+        }
+        backend.evaluate_batch(EagerKernelCall {
+            kernel_id: packet.kernel_id,
+            independent_block_size: packet.independent_block_size as u32,
+            lane_count,
+            input_component_count: evaluator_input_components,
+            output_component_count: evaluator_output_components,
+            inputs,
+            outputs,
+        })?;
+        if packet.independent_block_size == 1 {
+            scatter_invocations(
+                items,
+                &stage.attachments,
+                outputs,
+                lane_count,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.couplings,
+                &mut workspace.currents,
+            );
+        } else {
+            scatter_blocked_invocations(
+                items,
+                &stage.attachments,
+                outputs,
+                packet.output_components,
+                packet.independent_block_size,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.couplings,
+                &mut workspace.currents,
+            );
+        }
+    }
+
+    for item in &stage.finalization_copies {
+        copy_component_range(
+            &workspace.currents,
+            item.current,
+            &mut workspace.values,
+            item.unpropagated,
+            workspace.tile_capacity,
+            tile_points,
+        );
+    }
+    for packet in &schedule.finalization_packets {
+        debug_assert_eq!(packet.role, PacketRole::Finalization);
+        let items = &stage.finalizations[packet.item_range.clone()];
+        let lane_count = packet
+            .linear_finalization
+            .as_ref()
+            .map_or(items.len(), LinearFinalizationPacket::lane_multiplier)
+            * tile_points;
+        let input_len = packet.input_components * lane_count;
+        let output_len = packet.output_components * lane_count;
+        let (inputs, outputs) = packet_slices(&mut workspace.packet, input_len, output_len)?;
+        let kernel = kernels.get(&packet.kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!(
+                "eager schedule lost finalization kernel {}",
+                packet.kernel_id
+            ))
+        })?;
+        if let Some(linear) = &packet.linear_finalization {
+            gather_linear_finalizations(
+                linear,
+                &kernel.inputs,
+                inputs,
+                packet.input_components,
+                point_count,
+                tile_start,
+                tile_points,
+                momenta,
+                model_parameters,
+            );
+        } else {
+            gather_finalizations(
+                items,
+                &kernel.inputs,
+                inputs,
+                packet.input_components,
+                point_count,
+                tile_start,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.currents,
+                momenta,
+                model_parameters,
+            );
+        }
+        backend.evaluate_batch(EagerKernelCall {
+            kernel_id: packet.kernel_id,
+            independent_block_size: 1,
+            lane_count,
+            input_component_count: packet.input_components,
+            output_component_count: packet.output_components,
+            inputs,
+            outputs,
+        })?;
+        if let Some(linear) = &packet.linear_finalization {
+            scatter_linear_finalizations(
+                items,
+                linear,
+                outputs,
+                lane_count,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.currents,
+                &mut workspace.values,
+            )?;
+        } else {
+            scatter_finalizations(
+                items,
+                outputs,
+                lane_count,
+                tile_points,
+                workspace.tile_capacity,
+                &mut workspace.values,
+            )?;
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn invocation_packet_shape(
+    packet: &KernelPacket,
+    item_count: usize,
+    tile_points: usize,
+) -> RusticolResult<(usize, usize, usize)> {
+    let block_size = packet.independent_block_size;
+    if block_size == 0 || !item_count.is_multiple_of(block_size) {
+        return Err(RusticolError::internal(
+            "eager invocation packet has an invalid independent block shape",
+        ));
+    }
+    let lane_count = item_count
+        .checked_div(block_size)
+        .and_then(|value| value.checked_mul(tile_points))
+        .ok_or_else(|| RusticolError::invalid_argument("eager invocation lanes overflow"))?;
+    let input_components = packet
+        .input_components
+        .checked_mul(block_size)
+        .ok_or_else(|| RusticolError::invalid_argument("eager blocked input width overflows"))?;
+    let output_components = packet
+        .output_components
+        .checked_mul(block_size)
+        .ok_or_else(|| RusticolError::invalid_argument("eager blocked output width overflows"))?;
+    Ok((lane_count, input_components, output_components))
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn gather_blocked_invocations(
+    items: &[ScheduledInvocation],
+    descriptors: &[EagerKernelInput],
+    inputs: &mut [EagerComplex64],
+    input_component_count: usize,
+    block_size: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    values: &[EagerComplex64],
+) {
+    debug_assert_eq!(block_size, super::EAGER_INDEPENDENT_BLOCK_SIZE as usize);
+    debug_assert_eq!(items.len() % block_size, 0);
+    debug_assert!(descriptors.iter().all(|descriptor| matches!(
+        descriptor,
+        EagerKernelInput::FirstCurrentComponent(_) | EagerKernelInput::SecondCurrentComponent(_)
+    )));
+    match input_component_count {
+        6 => gather_current_only_blocked::<6, 4>(
+            items,
+            descriptors,
+            inputs,
+            tile_points,
+            tile_capacity,
+            values,
+        ),
+        8 => gather_current_only_blocked::<8, 4>(
+            items,
+            descriptors,
+            inputs,
+            tile_points,
+            tile_capacity,
+            values,
+        ),
+        10 => gather_current_only_blocked::<10, 4>(
+            items,
+            descriptors,
+            inputs,
+            tile_points,
+            tile_capacity,
+            values,
+        ),
+        _ => gather_current_only_blocked_generic(
+            items,
+            descriptors,
+            inputs,
+            block_size,
+            tile_points,
+            tile_capacity,
+            values,
+        ),
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn gather_invocations(
+    items: &[ScheduledInvocation],
+    descriptors: &[EagerKernelInput],
+    inputs: &mut [EagerComplex64],
+    input_component_count: usize,
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    values: &[EagerComplex64],
+    momenta: &[f64],
+    couplings: &[EagerComplex64],
+    model_parameters: &[EagerComplex64],
+) {
+    if descriptors.iter().all(|descriptor| {
+        matches!(
+            descriptor,
+            EagerKernelInput::FirstCurrentComponent(_)
+                | EagerKernelInput::SecondCurrentComponent(_)
+        )
+    }) {
+        match input_component_count {
+            6 => {
+                gather_current_only_invocations::<6>(
+                    items,
+                    descriptors,
+                    inputs,
+                    tile_points,
+                    tile_capacity,
+                    values,
+                );
+                return;
+            }
+            8 => {
+                gather_current_only_invocations::<8>(
+                    items,
+                    descriptors,
+                    inputs,
+                    tile_points,
+                    tile_capacity,
+                    values,
+                );
+                return;
+            }
+            10 => {
+                gather_current_only_invocations::<10>(
+                    items,
+                    descriptors,
+                    inputs,
+                    tile_points,
+                    tile_capacity,
+                    values,
+                );
+                return;
+            }
+            _ => {}
+        }
+    }
+    for (item_index, item) in items.iter().enumerate() {
+        let lane_start = item_index * tile_points;
+        let coupling = couplings[item.row.coupling_slot_id as usize];
+        for (target_component, descriptor) in descriptors.iter().copied().enumerate() {
+            match descriptor {
+                EagerKernelInput::FirstCurrentComponent(component) => gather_complex_component(
+                    values,
+                    item.left_values,
+                    component,
+                    tile_capacity,
+                    0,
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                ),
+                EagerKernelInput::SecondCurrentComponent(component) => gather_complex_component(
+                    values,
+                    item.right_values,
+                    component,
+                    tile_capacity,
+                    0,
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                ),
+                EagerKernelInput::FirstMomentumComponent(component) => gather_real_component(
+                    momenta,
+                    item.left_momenta,
+                    component,
+                    point_count,
+                    tile_start,
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                ),
+                EagerKernelInput::SecondMomentumComponent(component) => gather_real_component(
+                    momenta,
+                    item.right_momenta,
+                    component,
+                    point_count,
+                    tile_start,
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                ),
+                EagerKernelInput::CouplingReal => fill_packet_component(
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                    EagerComplex64::new(coupling.re, 0.0),
+                ),
+                EagerKernelInput::CouplingImag => fill_packet_component(
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                    EagerComplex64::new(coupling.im, 0.0),
+                ),
+                EagerKernelInput::ModelParameter(parameter) => fill_packet_component(
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                    model_parameters[parameter as usize],
+                ),
+            }
+        }
+    }
+}
+
+fn gather_current_only_invocations<const COMPONENTS: usize>(
+    items: &[ScheduledInvocation],
+    descriptors: &[EagerKernelInput],
+    inputs: &mut [EagerComplex64],
+    tile_points: usize,
+    tile_capacity: usize,
+    values: &[EagerComplex64],
+) {
+    debug_assert_eq!(descriptors.len(), COMPONENTS);
+    debug_assert_eq!(inputs.len(), items.len() * tile_points * COMPONENTS);
+    for (item_index, item) in items.iter().enumerate() {
+        let mut source_starts = [0usize; COMPONENTS];
+        for (component, descriptor) in descriptors.iter().copied().enumerate() {
+            source_starts[component] = match descriptor {
+                EagerKernelInput::FirstCurrentComponent(source_component) => {
+                    debug_assert!((source_component as usize) < item.left_values.len);
+                    (item.left_values.start + source_component as usize) * tile_capacity
+                }
+                EagerKernelInput::SecondCurrentComponent(source_component) => {
+                    debug_assert!((source_component as usize) < item.right_values.len);
+                    (item.right_values.start + source_component as usize) * tile_capacity
+                }
+                _ => unreachable!("current-only eager gather descriptor"),
+            };
+            debug_assert!(source_starts[component] + tile_points <= values.len());
+        }
+        let target_start = item_index * tile_points * COMPONENTS;
+        debug_assert!(target_start + tile_points * COMPONENTS <= inputs.len());
+        // Read each component stream linearly while writing complete SymJIT
+        // input rows contiguously. Const arities let LLVM unroll the small
+        // inner transpose used by the dominant prepared vertex kernels.
+        unsafe {
+            let source_base = values.as_ptr();
+            let target_base = inputs.as_mut_ptr().add(target_start);
+            for point in 0..tile_points {
+                let target = target_base.add(point * COMPONENTS);
+                for (component, source_start) in source_starts.iter().copied().enumerate() {
+                    *target.add(component) = *source_base.add(source_start + point);
+                }
+            }
+        }
+    }
+}
+
+fn gather_current_only_blocked<const COMPONENTS: usize, const BLOCK_SIZE: usize>(
+    items: &[ScheduledInvocation],
+    descriptors: &[EagerKernelInput],
+    inputs: &mut [EagerComplex64],
+    tile_points: usize,
+    tile_capacity: usize,
+    values: &[EagerComplex64],
+) {
+    debug_assert_eq!(descriptors.len(), COMPONENTS);
+    debug_assert_eq!(items.len() % BLOCK_SIZE, 0);
+    debug_assert_eq!(inputs.len(), items.len() * tile_points * COMPONENTS);
+    for (block_index, block) in items.chunks_exact(BLOCK_SIZE).enumerate() {
+        let mut source_starts = [[0usize; COMPONENTS]; BLOCK_SIZE];
+        for (lane, item) in block.iter().enumerate() {
+            for (component, descriptor) in descriptors.iter().copied().enumerate() {
+                source_starts[lane][component] = match descriptor {
+                    EagerKernelInput::FirstCurrentComponent(source_component) => {
+                        debug_assert!((source_component as usize) < item.left_values.len);
+                        (item.left_values.start + source_component as usize) * tile_capacity
+                    }
+                    EagerKernelInput::SecondCurrentComponent(source_component) => {
+                        debug_assert!((source_component as usize) < item.right_values.len);
+                        (item.right_values.start + source_component as usize) * tile_capacity
+                    }
+                    _ => unreachable!("validated blocked current-only descriptor"),
+                };
+            }
+        }
+        let target_start = block_index * tile_points * BLOCK_SIZE * COMPONENTS;
+        unsafe {
+            let source_base = values.as_ptr();
+            let target_base = inputs.as_mut_ptr().add(target_start);
+            for point in 0..tile_points {
+                let target = target_base.add(point * BLOCK_SIZE * COMPONENTS);
+                for (lane, lane_starts) in source_starts.iter().enumerate() {
+                    let lane_target = target.add(lane * COMPONENTS);
+                    for (component, source_start) in lane_starts.iter().copied().enumerate() {
+                        *lane_target.add(component) = *source_base.add(source_start + point);
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn gather_current_only_blocked_generic(
+    items: &[ScheduledInvocation],
+    descriptors: &[EagerKernelInput],
+    inputs: &mut [EagerComplex64],
+    block_size: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    values: &[EagerComplex64],
+) {
+    let component_count = descriptors.len();
+    debug_assert_eq!(items.len() % block_size, 0);
+    debug_assert_eq!(inputs.len(), items.len() * tile_points * component_count);
+    for (block_index, block) in items.chunks_exact(block_size).enumerate() {
+        for point in 0..tile_points {
+            let target_row = (block_index * tile_points + point) * block_size * component_count;
+            for (lane, item) in block.iter().enumerate() {
+                let lane_target = target_row + lane * component_count;
+                for (component, descriptor) in descriptors.iter().copied().enumerate() {
+                    let (range, source_component) = match descriptor {
+                        EagerKernelInput::FirstCurrentComponent(source_component) => {
+                            (item.left_values, source_component)
+                        }
+                        EagerKernelInput::SecondCurrentComponent(source_component) => {
+                            (item.right_values, source_component)
+                        }
+                        _ => unreachable!("validated blocked current-only descriptor"),
+                    };
+                    inputs[lane_target + component] =
+                        values[(range.start + source_component as usize) * tile_capacity + point];
+                }
+            }
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn scatter_invocations(
+    items: &[ScheduledInvocation],
+    attachments: &[ScheduledAttachment],
+    outputs: &[EagerComplex64],
+    lane_count: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    couplings: &[EagerComplex64],
+    currents: &mut [EagerComplex64],
+) {
+    let output_components = outputs.len() / lane_count;
+    for (item_index, item) in items.iter().enumerate() {
+        let lane_start = item_index * tile_points;
+        let output_scale = output_factor_scale(
+            item.row.output_factor_source,
+            couplings[item.row.coupling_slot_id as usize],
+        );
+        let item_attachments = &attachments[item.attachment_range.clone()];
+        let source_start = lane_start * output_components;
+        let fused = match (item_attachments.len(), output_components) {
+            (2, 2) => scatter_signed_fanout::<2, 2>(
+                item_attachments,
+                outputs,
+                source_start,
+                output_scale,
+                currents,
+                tile_capacity,
+                tile_points,
+            ),
+            (2, 4) => scatter_signed_fanout::<4, 2>(
+                item_attachments,
+                outputs,
+                source_start,
+                output_scale,
+                currents,
+                tile_capacity,
+                tile_points,
+            ),
+            (2, 6) => scatter_signed_fanout::<6, 2>(
+                item_attachments,
+                outputs,
+                source_start,
+                output_scale,
+                currents,
+                tile_capacity,
+                tile_points,
+            ),
+            (4, 2) => scatter_signed_fanout::<2, 4>(
+                item_attachments,
+                outputs,
+                source_start,
+                output_scale,
+                currents,
+                tile_capacity,
+                tile_points,
+            ),
+            (4, 4) => scatter_signed_fanout::<4, 4>(
+                item_attachments,
+                outputs,
+                source_start,
+                output_scale,
+                currents,
+                tile_capacity,
+                tile_points,
+            ),
+            (4, 6) => scatter_signed_fanout::<6, 4>(
+                item_attachments,
+                outputs,
+                source_start,
+                output_scale,
+                currents,
+                tile_capacity,
+                tile_points,
+            ),
+            _ => false,
+        };
+        if fused {
+            continue;
+        }
+        for attachment in item_attachments {
+            let factor = AccumulationFactor::from_parts(
+                attachment.row.factor_real * output_scale,
+                attachment.row.factor_imag * output_scale,
+            );
+            debug_assert_eq!(attachment.current.len, output_components);
+            match output_components {
+                2 => {
+                    factor.scatter_interleaved::<2>(
+                        attachment.initializes_current,
+                        outputs,
+                        source_start,
+                        currents,
+                        attachment.current.start,
+                        tile_capacity,
+                        tile_points,
+                    );
+                    continue;
+                }
+                4 => {
+                    factor.scatter_interleaved::<4>(
+                        attachment.initializes_current,
+                        outputs,
+                        source_start,
+                        currents,
+                        attachment.current.start,
+                        tile_capacity,
+                        tile_points,
+                    );
+                    continue;
+                }
+                6 => {
+                    factor.scatter_interleaved::<6>(
+                        attachment.initializes_current,
+                        outputs,
+                        source_start,
+                        currents,
+                        attachment.current.start,
+                        tile_capacity,
+                        tile_points,
+                    );
+                    continue;
+                }
+                8 => {
+                    factor.scatter_interleaved::<8>(
+                        attachment.initializes_current,
+                        outputs,
+                        source_start,
+                        currents,
+                        attachment.current.start,
+                        tile_capacity,
+                        tile_points,
+                    );
+                    continue;
+                }
+                _ => {}
+            }
+            for component in 0..output_components {
+                let target = (attachment.current.start + component) * tile_capacity;
+                factor.scatter_strided(
+                    attachment.initializes_current,
+                    outputs,
+                    source_start + component,
+                    output_components,
+                    currents,
+                    target,
+                    tile_points,
+                );
+            }
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn scatter_blocked_invocations(
+    items: &[ScheduledInvocation],
+    attachments: &[ScheduledAttachment],
+    outputs: &[EagerComplex64],
+    output_components: usize,
+    block_size: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    couplings: &[EagerComplex64],
+    currents: &mut [EagerComplex64],
+) {
+    debug_assert_eq!(block_size, super::EAGER_INDEPENDENT_BLOCK_SIZE as usize);
+    debug_assert_eq!(items.len() % block_size, 0);
+    let source_row_stride = block_size * output_components;
+    debug_assert_eq!(
+        outputs.len(),
+        (items.len() / block_size) * tile_points * source_row_stride
+    );
+    for (item_index, item) in items.iter().enumerate() {
+        let block_index = item_index / block_size;
+        let lane_index = item_index % block_size;
+        let source_start =
+            block_index * tile_points * source_row_stride + lane_index * output_components;
+        let output_scale = output_factor_scale(
+            item.row.output_factor_source,
+            couplings[item.row.coupling_slot_id as usize],
+        );
+        for attachment in &attachments[item.attachment_range.clone()] {
+            let factor = AccumulationFactor::from_parts(
+                attachment.row.factor_real * output_scale,
+                attachment.row.factor_imag * output_scale,
+            );
+            debug_assert_eq!(attachment.current.len, output_components);
+            match output_components {
+                2 => factor.scatter_interleaved_strided::<2>(
+                    attachment.initializes_current,
+                    outputs,
+                    source_start,
+                    source_row_stride,
+                    currents,
+                    attachment.current.start,
+                    tile_capacity,
+                    tile_points,
+                ),
+                4 => factor.scatter_interleaved_strided::<4>(
+                    attachment.initializes_current,
+                    outputs,
+                    source_start,
+                    source_row_stride,
+                    currents,
+                    attachment.current.start,
+                    tile_capacity,
+                    tile_points,
+                ),
+                6 => factor.scatter_interleaved_strided::<6>(
+                    attachment.initializes_current,
+                    outputs,
+                    source_start,
+                    source_row_stride,
+                    currents,
+                    attachment.current.start,
+                    tile_capacity,
+                    tile_points,
+                ),
+                8 => factor.scatter_interleaved_strided::<8>(
+                    attachment.initializes_current,
+                    outputs,
+                    source_start,
+                    source_row_stride,
+                    currents,
+                    attachment.current.start,
+                    tile_capacity,
+                    tile_points,
+                ),
+                _ => {
+                    for component in 0..output_components {
+                        factor.scatter_strided(
+                            attachment.initializes_current,
+                            outputs,
+                            source_start + component,
+                            source_row_stride,
+                            currents,
+                            (attachment.current.start + component) * tile_capacity,
+                            tile_points,
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn scatter_signed_fanout<const COMPONENTS: usize, const FANOUT: usize>(
+    attachments: &[ScheduledAttachment],
+    outputs: &[EagerComplex64],
+    source_start: usize,
+    output_scale: f64,
+    currents: &mut [EagerComplex64],
+    tile_capacity: usize,
+    tile_points: usize,
+) -> bool {
+    let Ok(attachments) = <&[ScheduledAttachment; FANOUT]>::try_from(attachments) else {
+        return false;
+    };
+    let mut negative = [false; FANOUT];
+    for (index, attachment) in attachments.iter().enumerate() {
+        if attachment.row.factor_imag != 0.0
+            || (attachment.row.factor_real != 1.0 && attachment.row.factor_real != -1.0)
+        {
+            return false;
+        }
+        debug_assert_eq!(attachment.current.len, COMPONENTS);
+        negative[index] = attachment.row.factor_real == -1.0;
+    }
+    debug_assert!(source_start + tile_points * COMPONENTS <= outputs.len());
+    unsafe {
+        let target_base = currents.as_mut_ptr();
+        let mut target_ptrs = [[target_base; FANOUT]; COMPONENTS];
+        for (attachment_index, attachment) in attachments.iter().enumerate() {
+            for (component, component_targets) in target_ptrs.iter_mut().enumerate() {
+                component_targets[attachment_index] =
+                    target_base.add((attachment.current.start + component) * tile_capacity);
+            }
+        }
+        let mut source_ptr = outputs.as_ptr().add(source_start);
+        for _ in 0..tile_points {
+            for (component, component_targets) in target_ptrs.iter_mut().enumerate() {
+                let value = *source_ptr.add(component);
+                let scaled = match output_scale {
+                    1.0 => value,
+                    -1.0 => -value,
+                    scale => EagerComplex64::new(scale * value.re, scale * value.im),
+                };
+                for (attachment_index, target_ptr) in component_targets.iter_mut().enumerate() {
+                    let target = &mut **target_ptr;
+                    let contribution = if negative[attachment_index] {
+                        -scaled
+                    } else {
+                        scaled
+                    };
+                    if attachments[attachment_index].initializes_current {
+                        *target = contribution;
+                    } else {
+                        *target += contribution;
+                    }
+                    *target_ptr = target_ptr.add(1);
+                }
+            }
+            source_ptr = source_ptr.add(COMPONENTS);
+        }
+    }
+    true
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn gather_finalizations(
+    items: &[ScheduledFinalization],
+    descriptors: &[EagerKernelInput],
+    inputs: &mut [EagerComplex64],
+    input_component_count: usize,
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    currents: &[EagerComplex64],
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+) {
+    if descriptors.len() == input_component_count {
+        match input_component_count {
+            6 if finalization_inputs_are_current_momentum::<2>(descriptors) => {
+                gather_current_momentum_finalizations::<2, 6>(
+                    items,
+                    descriptors,
+                    inputs,
+                    point_count,
+                    tile_start,
+                    tile_points,
+                    tile_capacity,
+                    currents,
+                    momenta,
+                );
+                return;
+            }
+            8 if finalization_inputs_are_current_momentum::<4>(descriptors) => {
+                gather_current_momentum_finalizations::<4, 8>(
+                    items,
+                    descriptors,
+                    inputs,
+                    point_count,
+                    tile_start,
+                    tile_points,
+                    tile_capacity,
+                    currents,
+                    momenta,
+                );
+                return;
+            }
+            _ => {}
+        }
+    }
+    for (item_index, item) in items.iter().enumerate() {
+        let lane_start = item_index * tile_points;
+        for (target_component, descriptor) in descriptors.iter().copied().enumerate() {
+            match descriptor {
+                EagerKernelInput::FirstCurrentComponent(component) => gather_complex_component(
+                    currents,
+                    item.current,
+                    component,
+                    tile_capacity,
+                    0,
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                ),
+                EagerKernelInput::FirstMomentumComponent(component) => gather_real_component(
+                    momenta,
+                    item.momentum,
+                    component,
+                    point_count,
+                    tile_start,
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                ),
+                EagerKernelInput::ModelParameter(parameter) => fill_packet_component(
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                    model_parameters[parameter as usize],
+                ),
+                _ => unreachable!("validated eager finalization descriptor"),
+            }
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn gather_linear_finalizations(
+    linear: &LinearFinalizationPacket,
+    descriptors: &[EagerKernelInput],
+    inputs: &mut [EagerComplex64],
+    input_component_count: usize,
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+) {
+    debug_assert_eq!(descriptors.len(), input_component_count);
+    debug_assert_eq!(
+        inputs.len(),
+        linear.lane_multiplier() * tile_points * input_component_count
+    );
+    let basis_count = linear.current_components.len();
+    for (group_index, momentum) in linear.momentum_groups.iter().copied().enumerate() {
+        for basis_index in 0..basis_count {
+            let lane_start = (group_index * basis_count + basis_index) * tile_points;
+            for (target_component, descriptor) in descriptors.iter().copied().enumerate() {
+                match descriptor {
+                    EagerKernelInput::FirstCurrentComponent(component) => {
+                        let value = EagerComplex64::new(
+                            if linear.current_components[basis_index] == component {
+                                1.0
+                            } else {
+                                0.0
+                            },
+                            0.0,
+                        );
+                        fill_packet_component(
+                            inputs,
+                            target_component,
+                            input_component_count,
+                            lane_start,
+                            tile_points,
+                            value,
+                        );
+                    }
+                    EagerKernelInput::FirstMomentumComponent(component) => gather_real_component(
+                        momenta,
+                        momentum,
+                        component,
+                        point_count,
+                        tile_start,
+                        inputs,
+                        target_component,
+                        input_component_count,
+                        lane_start,
+                        tile_points,
+                    ),
+                    EagerKernelInput::ModelParameter(parameter) => fill_packet_component(
+                        inputs,
+                        target_component,
+                        input_component_count,
+                        lane_start,
+                        tile_points,
+                        model_parameters[parameter as usize],
+                    ),
+                    _ => unreachable!("validated eager finalization descriptor"),
+                }
+            }
+        }
+    }
+}
+
+fn finalization_inputs_are_current_momentum<const CURRENT_COMPONENTS: usize>(
+    descriptors: &[EagerKernelInput],
+) -> bool {
+    descriptors[..CURRENT_COMPONENTS]
+        .iter()
+        .all(|descriptor| matches!(descriptor, EagerKernelInput::FirstCurrentComponent(_)))
+        && descriptors[CURRENT_COMPONENTS..]
+            .iter()
+            .all(|descriptor| matches!(descriptor, EagerKernelInput::FirstMomentumComponent(_)))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn gather_current_momentum_finalizations<
+    const CURRENT_COMPONENTS: usize,
+    const COMPONENTS: usize,
+>(
+    items: &[ScheduledFinalization],
+    descriptors: &[EagerKernelInput],
+    inputs: &mut [EagerComplex64],
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    currents: &[EagerComplex64],
+    momenta: &[f64],
+) {
+    debug_assert_eq!(COMPONENTS, CURRENT_COMPONENTS + 4);
+    debug_assert_eq!(descriptors.len(), COMPONENTS);
+    debug_assert_eq!(inputs.len(), items.len() * tile_points * COMPONENTS);
+    for (item_index, item) in items.iter().enumerate() {
+        let mut current_starts = [0usize; CURRENT_COMPONENTS];
+        for (component, descriptor) in descriptors[..CURRENT_COMPONENTS]
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            let EagerKernelInput::FirstCurrentComponent(source_component) = descriptor else {
+                unreachable!("validated eager current/momentum finalization descriptor");
+            };
+            debug_assert!((source_component as usize) < item.current.len);
+            current_starts[component] =
+                (item.current.start + source_component as usize) * tile_capacity;
+        }
+        let mut momentum_starts = [0usize; 4];
+        for (component, descriptor) in descriptors[CURRENT_COMPONENTS..]
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            let EagerKernelInput::FirstMomentumComponent(source_component) = descriptor else {
+                unreachable!("validated eager current/momentum finalization descriptor");
+            };
+            debug_assert!((source_component as usize) < item.momentum.len);
+            momentum_starts[component] =
+                (item.momentum.start + source_component as usize) * point_count + tile_start;
+        }
+        let target_start = item_index * tile_points * COMPONENTS;
+        unsafe {
+            let current_base = currents.as_ptr();
+            let momentum_base = momenta.as_ptr();
+            let target_base = inputs.as_mut_ptr().add(target_start);
+            for point in 0..tile_points {
+                let target = target_base.add(point * COMPONENTS);
+                for (component, source_start) in current_starts.iter().copied().enumerate() {
+                    *target.add(component) = *current_base.add(source_start + point);
+                }
+                for (component, source_start) in momentum_starts.iter().copied().enumerate() {
+                    *target.add(CURRENT_COMPONENTS + component) =
+                        EagerComplex64::new(*momentum_base.add(source_start + point), 0.0);
+                }
+            }
+        }
+    }
+}
+
+pub(super) fn scatter_finalizations(
+    items: &[ScheduledFinalization],
+    outputs: &[EagerComplex64],
+    lane_count: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    values: &mut [EagerComplex64],
+) -> RusticolResult<()> {
+    let output_components = outputs.len() / lane_count;
+    for (item_index, item) in items.iter().enumerate() {
+        let lane_start = item_index * tile_points;
+        let Some(target) = item.propagated else {
+            return Err(RusticolError::internal(
+                "eager finalization schedule lost its propagated output",
+            ));
+        };
+        debug_assert_eq!(target.len, output_components);
+        let source_start = lane_start * output_components;
+        match output_components {
+            2 => {
+                AccumulationFactor::One.scatter_interleaved::<2>(
+                    true,
+                    outputs,
+                    source_start,
+                    values,
+                    target.start,
+                    tile_capacity,
+                    tile_points,
+                );
+                continue;
+            }
+            4 => {
+                AccumulationFactor::One.scatter_interleaved::<4>(
+                    true,
+                    outputs,
+                    source_start,
+                    values,
+                    target.start,
+                    tile_capacity,
+                    tile_points,
+                );
+                continue;
+            }
+            6 => {
+                AccumulationFactor::One.scatter_interleaved::<6>(
+                    true,
+                    outputs,
+                    source_start,
+                    values,
+                    target.start,
+                    tile_capacity,
+                    tile_points,
+                );
+                continue;
+            }
+            8 => {
+                AccumulationFactor::One.scatter_interleaved::<8>(
+                    true,
+                    outputs,
+                    source_start,
+                    values,
+                    target.start,
+                    tile_capacity,
+                    tile_points,
+                );
+                continue;
+            }
+            _ => {}
+        }
+        for component in 0..output_components {
+            let target_start = (target.start + component) * tile_capacity;
+            AccumulationFactor::One.scatter_strided(
+                true,
+                outputs,
+                source_start + component,
+                output_components,
+                values,
+                target_start,
+                tile_points,
+            );
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn scatter_linear_finalizations(
+    items: &[ScheduledFinalization],
+    linear: &LinearFinalizationPacket,
+    outputs: &[EagerComplex64],
+    lane_count: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    currents: &[EagerComplex64],
+    values: &mut [EagerComplex64],
+) -> RusticolResult<()> {
+    debug_assert_eq!(linear.item_group_indices.len(), items.len());
+    let output_components = outputs.len() / lane_count;
+    let basis_stride = linear.current_components.len();
+    for (item_index, item) in items.iter().enumerate() {
+        let Some(target) = item.propagated else {
+            return Err(RusticolError::internal(
+                "eager linear finalization lost its propagated output",
+            ));
+        };
+        debug_assert_eq!(target.len, output_components);
+        let group_start = linear.item_group_indices[item_index] * basis_stride * tile_points;
+        for output_component in 0..output_components {
+            let target_start = (target.start + output_component) * tile_capacity;
+            for (basis_index, source_component) in
+                linear.current_components.iter().copied().enumerate()
+            {
+                let basis_start = (group_start + basis_index * tile_points) * output_components
+                    + output_component;
+                let source_start = (item.current.start + source_component as usize) * tile_capacity;
+                if basis_index == 0 {
+                    for point in 0..tile_points {
+                        let coefficient = outputs[basis_start + point * output_components];
+                        values[target_start + point] = coefficient * currents[source_start + point];
+                    }
+                } else {
+                    for point in 0..tile_points {
+                        let coefficient = outputs[basis_start + point * output_components];
+                        values[target_start + point] +=
+                            coefficient * currents[source_start + point];
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn execute_closures<B: EagerKernelBackend>(
+    rows: ClosureExecutionRows<'_>,
+    packets: &[KernelPacket],
+    workspace: &mut EagerWorkspace,
+    backend: &mut B,
+    tile_points: usize,
+    model_parameters: &[EagerComplex64],
+) -> RusticolResult<()> {
+    for packet in packets {
+        debug_assert_eq!(packet.role, PacketRole::Closure);
+        let items = &rows.closures[packet.item_range.clone()];
+        let lane_count = items.len() * tile_points;
+        let input_len = packet.input_components * lane_count;
+        let output_len = packet.output_components * lane_count;
+        let (inputs, outputs) = packet_slices(&mut workspace.packet, input_len, output_len)?;
+        let kernel = rows.kernels.get(&packet.kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!(
+                "eager schedule lost closure kernel {}",
+                packet.kernel_id
+            ))
+        })?;
+        gather_closures(
+            items,
+            &kernel.inputs,
+            inputs,
+            packet.input_components,
+            tile_points,
+            workspace.tile_capacity,
+            &workspace.values,
+            &workspace.couplings,
+            model_parameters,
+        );
+        backend.evaluate_batch(EagerKernelCall {
+            kernel_id: packet.kernel_id,
+            independent_block_size: 1,
+            lane_count,
+            input_component_count: packet.input_components,
+            output_component_count: packet.output_components,
+            inputs,
+            outputs,
+        })?;
+        scatter_closures(
+            items,
+            outputs,
+            lane_count,
+            tile_points,
+            workspace.tile_capacity,
+            &workspace.couplings,
+            &mut workspace.amplitudes,
+        );
+    }
+    execute_direct_closures(
+        rows.direct_closures,
+        &workspace.values,
+        workspace.tile_capacity,
+        tile_points,
+        &mut workspace.amplitudes,
+    );
+    Ok(())
+}
+
+pub(super) fn copy_tile_amplitudes(
+    plan: &EagerExecutionPlan,
+    workspace: &EagerWorkspace,
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    amplitudes: &mut [EagerComplex64],
+) {
+    for amplitude in 0..plan.amplitude_count {
+        let source = amplitude * workspace.tile_capacity;
+        let target = amplitude * point_count + tile_start;
+        amplitudes[target..target + tile_points]
+            .copy_from_slice(&workspace.amplitudes[source..source + tile_points]);
+    }
+}
+
+pub(super) fn copy_selected_tile_amplitudes(
+    amplitude_indices: &[usize],
+    workspace: &EagerWorkspace,
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    amplitudes: &mut [EagerComplex64],
+) {
+    for amplitude in amplitude_indices {
+        let source = amplitude * workspace.tile_capacity;
+        let target = amplitude * point_count + tile_start;
+        amplitudes[target..target + tile_points]
+            .copy_from_slice(&workspace.amplitudes[source..source + tile_points]);
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn gather_closures(
+    items: &[ScheduledClosure],
+    descriptors: &[EagerKernelInput],
+    inputs: &mut [EagerComplex64],
+    input_component_count: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    values: &[EagerComplex64],
+    couplings: &[EagerComplex64],
+    model_parameters: &[EagerComplex64],
+) {
+    for (item_index, item) in items.iter().enumerate() {
+        let lane_start = item_index * tile_points;
+        let coupling = couplings[item.row.coupling_slot_id as usize];
+        for (target_component, descriptor) in descriptors.iter().copied().enumerate() {
+            match descriptor {
+                EagerKernelInput::FirstCurrentComponent(component) => gather_complex_component(
+                    values,
+                    item.left_values,
+                    component,
+                    tile_capacity,
+                    0,
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                ),
+                EagerKernelInput::SecondCurrentComponent(component) => gather_complex_component(
+                    values,
+                    item.right_values,
+                    component,
+                    tile_capacity,
+                    0,
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                ),
+                EagerKernelInput::CouplingReal => fill_packet_component(
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                    EagerComplex64::new(coupling.re, 0.0),
+                ),
+                EagerKernelInput::CouplingImag => fill_packet_component(
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                    EagerComplex64::new(coupling.im, 0.0),
+                ),
+                EagerKernelInput::ModelParameter(parameter) => fill_packet_component(
+                    inputs,
+                    target_component,
+                    input_component_count,
+                    lane_start,
+                    tile_points,
+                    model_parameters[parameter as usize],
+                ),
+                _ => unreachable!("validated eager closure descriptor"),
+            }
+        }
+    }
+}
+
+pub(super) fn scatter_closures(
+    items: &[ScheduledClosure],
+    outputs: &[EagerComplex64],
+    lane_count: usize,
+    tile_points: usize,
+    tile_capacity: usize,
+    couplings: &[EagerComplex64],
+    amplitudes: &mut [EagerComplex64],
+) {
+    let output_components = outputs.len() / lane_count;
+    for (item_index, item) in items.iter().enumerate() {
+        let lane_start = item_index * tile_points;
+        let output_scale = output_factor_scale(
+            item.row.output_factor_source,
+            couplings[item.row.coupling_slot_id as usize],
+        );
+        let factor = AccumulationFactor::from_parts(
+            item.row.factor_real * output_scale,
+            item.row.factor_imag * output_scale,
+        );
+        let target = item.row.amplitude_index as usize * tile_capacity;
+        factor.scatter_strided(
+            item.initializes_amplitude,
+            outputs,
+            lane_start * output_components,
+            output_components,
+            amplitudes,
+            target,
+            tile_points,
+        );
+    }
+}
+
+pub(super) fn execute_direct_closures(
+    closures: &[ScheduledDirectClosure],
+    values: &[EagerComplex64],
+    tile_capacity: usize,
+    tile_points: usize,
+    amplitudes: &mut [EagerComplex64],
+) {
+    for closure in closures {
+        let factor =
+            AccumulationFactor::from_parts(closure.row.factor_real, closure.row.factor_imag);
+        let target = closure.row.amplitude_index as usize * tile_capacity;
+        debug_assert_eq!(closure.left_values.len, closure.coefficients.len());
+        debug_assert_eq!(closure.right_values.len, closure.coefficients.len());
+        debug_assert!(target + tile_points <= amplitudes.len());
+        // Preserve the exact per-point contraction order while replacing two
+        // component-index multiplications per term with linear pointer walks.
+        // Direct closures are numerous for small complete-color workloads.
+        unsafe {
+            let left_base = values
+                .as_ptr()
+                .add(closure.left_values.start * tile_capacity);
+            let right_base = values
+                .as_ptr()
+                .add(closure.right_values.start * tile_capacity);
+            let mut target_ptr = amplitudes.as_mut_ptr().add(target);
+            for point in 0..tile_points {
+                let mut left_ptr = left_base.add(point);
+                let mut right_ptr = right_base.add(point);
+                let mut contraction = EagerComplex64::new(0.0, 0.0);
+                for coefficient in &closure.coefficients {
+                    contraction += *coefficient * *left_ptr * *right_ptr;
+                    left_ptr = left_ptr.add(tile_capacity);
+                    right_ptr = right_ptr.add(tile_capacity);
+                }
+                if closure.initializes_amplitude {
+                    factor.assign(&mut *target_ptr, contraction);
+                } else {
+                    factor.accumulate(&mut *target_ptr, contraction);
+                }
+                target_ptr = target_ptr.add(1);
+            }
+        }
+    }
+}
+
+pub(super) fn reduce_tile(
+    plan: &EagerExecutionPlan,
+    workspace: &mut EagerWorkspace,
+    tile_points: usize,
+) {
+    for (group_index, group) in plan.reduction_groups.iter().enumerate() {
+        let target = group_index * workspace.tile_capacity;
+        let (first_amplitude, remaining_amplitudes) = group
+            .amplitude_indices
+            .split_first()
+            .expect("validated eager reduction group is nonempty");
+        let first_source = *first_amplitude as usize * workspace.tile_capacity;
+        workspace.reduction_groups[target..target + tile_points]
+            .copy_from_slice(&workspace.amplitudes[first_source..first_source + tile_points]);
+        for amplitude_index in remaining_amplitudes {
+            let source = *amplitude_index as usize * workspace.tile_capacity;
+            for point in 0..tile_points {
+                workspace.reduction_groups[target + point] += workspace.amplitudes[source + point];
+            }
+        }
+    }
+    let (first_entry, remaining_entries) = plan
+        .reduction_entries
+        .split_first()
+        .expect("validated eager reduction table is nonempty");
+    let left = first_entry.left_group_index as usize * workspace.tile_capacity;
+    let right = first_entry.right_group_index as usize * workspace.tile_capacity;
+    for point in 0..tile_points {
+        let product = workspace.reduction_groups[left + point]
+            * workspace.reduction_groups[right + point].conj();
+        workspace.reduced[point] = (first_entry.coefficient * product).re;
+    }
+    for entry in remaining_entries {
+        let left = entry.left_group_index as usize * workspace.tile_capacity;
+        let right = entry.right_group_index as usize * workspace.tile_capacity;
+        for point in 0..tile_points {
+            let product = workspace.reduction_groups[left + point]
+                * workspace.reduction_groups[right + point].conj();
+            workspace.reduced[point] += (entry.coefficient * product).re;
+        }
+    }
+}
+
+pub(super) fn reduce_selected_tile(
+    plan: &EagerExecutionPlan,
+    active_group_indices: &[usize],
+    active_entry_indices: &[usize],
+    selected_group_weights: &[f64],
+    workspace: &mut EagerWorkspace,
+    tile_points: usize,
+) -> RusticolResult<()> {
+    if selected_group_weights.len() != active_group_indices.len() * tile_points {
+        return Err(RusticolError::invalid_argument(
+            "eager selected reduction group weights have an inconsistent shape",
+        ));
+    }
+    workspace.reduced[..tile_points].fill(0.0);
+    for group_index in active_group_indices {
+        let group = &plan.reduction_groups[*group_index];
+        let target = *group_index * workspace.tile_capacity;
+        let (first_amplitude, remaining_amplitudes) = group
+            .amplitude_indices
+            .split_first()
+            .expect("validated eager reduction group is nonempty");
+        let first_source = *first_amplitude as usize * workspace.tile_capacity;
+        workspace.reduction_groups[target..target + tile_points]
+            .copy_from_slice(&workspace.amplitudes[first_source..first_source + tile_points]);
+        for amplitude_index in remaining_amplitudes {
+            let source = *amplitude_index as usize * workspace.tile_capacity;
+            for point in 0..tile_points {
+                workspace.reduction_groups[target + point] += workspace.amplitudes[source + point];
+            }
+        }
+    }
+    for entry_index in active_entry_indices {
+        let entry = &plan.reduction_entries[*entry_index];
+        let left_group_index = entry.left_group_index as usize;
+        let right_group_index = entry.right_group_index as usize;
+        let left = left_group_index * workspace.tile_capacity;
+        let right = entry.right_group_index as usize * workspace.tile_capacity;
+        let left_position = active_group_indices
+            .binary_search(&left_group_index)
+            .map_err(|_| {
+                RusticolError::integrity(
+                    "eager selected reduction entry references an inactive left group",
+                )
+            })?;
+        let right_position = active_group_indices
+            .binary_search(&right_group_index)
+            .map_err(|_| {
+                RusticolError::integrity(
+                    "eager selected reduction entry references an inactive right group",
+                )
+            })?;
+        for point in 0..tile_points {
+            let weight = selected_group_weights[left_position * tile_points + point];
+            let right_weight = selected_group_weights[right_position * tile_points + point];
+            if weight.to_bits() != right_weight.to_bits() {
+                return Err(RusticolError::integrity(
+                    "eager selected contraction groups have inconsistent physical weights",
+                ));
+            }
+            let product = workspace.reduction_groups[left + point]
+                * workspace.reduction_groups[right + point].conj();
+            workspace.reduced[point] += weight * (entry.coefficient * product).re;
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn copy_tile_results(
+    plan: &EagerExecutionPlan,
+    workspace: &EagerWorkspace,
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    amplitudes: &mut [EagerComplex64],
+    reduced: &mut [f64],
+) {
+    copy_tile_amplitudes(
+        plan,
+        workspace,
+        point_count,
+        tile_start,
+        tile_points,
+        amplitudes,
+    );
+    reduced[tile_start..tile_start + tile_points]
+        .copy_from_slice(&workspace.reduced[..tile_points]);
+}
+
+fn packet_slices(
+    packet: &mut [EagerComplex64],
+    input_len: usize,
+    output_len: usize,
+) -> RusticolResult<(&mut [EagerComplex64], &mut [EagerComplex64])> {
+    let total = input_len
+        .checked_add(output_len)
+        .ok_or_else(|| RusticolError::internal("eager active packet size overflows"))?;
+    if total > packet.len() {
+        return Err(RusticolError::internal(format!(
+            "eager active packet needs {total} elements, workspace has {}",
+            packet.len()
+        )));
+    }
+    let active = &mut packet[..total];
+    Ok(active.split_at_mut(input_len))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn gather_complex_component(
+    source: &[EagerComplex64],
+    range: ComponentRange,
+    component: u32,
+    source_stride: usize,
+    source_point_start: usize,
+    target: &mut [EagerComplex64],
+    target_component: usize,
+    target_component_count: usize,
+    target_lane_start: usize,
+    point_count: usize,
+) {
+    let component = component as usize;
+    debug_assert!(component < range.len);
+    let source_start = (range.start + component) * source_stride + source_point_start;
+    let target_start = target_lane_start * target_component_count + target_component;
+    debug_assert!(source_start + point_count <= source.len());
+    debug_assert!(
+        point_count == 0
+            || target_start + (point_count - 1) * target_component_count < target.len()
+    );
+    // The plan validator and packet sizing above establish both bounds. Raw
+    // pointers avoid repeated checks and index multiplication in this hot
+    // component-major to row-major transpose.
+    unsafe {
+        let mut source_ptr = source.as_ptr().add(source_start);
+        let mut target_ptr = target.as_mut_ptr().add(target_start);
+        for _ in 0..point_count {
+            *target_ptr = *source_ptr;
+            source_ptr = source_ptr.add(1);
+            target_ptr = target_ptr.add(target_component_count);
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn gather_real_component(
+    source: &[f64],
+    range: ComponentRange,
+    component: u32,
+    source_stride: usize,
+    source_point_start: usize,
+    target: &mut [EagerComplex64],
+    target_component: usize,
+    target_component_count: usize,
+    target_lane_start: usize,
+    point_count: usize,
+) {
+    let component = component as usize;
+    debug_assert!(component < range.len);
+    let source_start = (range.start + component) * source_stride + source_point_start;
+    let target_start = target_lane_start * target_component_count + target_component;
+    debug_assert!(source_start + point_count <= source.len());
+    debug_assert!(
+        point_count == 0
+            || target_start + (point_count - 1) * target_component_count < target.len()
+    );
+    // Safety follows from the validated source range and active packet size.
+    unsafe {
+        let mut source_ptr = source.as_ptr().add(source_start);
+        let mut target_ptr = target.as_mut_ptr().add(target_start);
+        for _ in 0..point_count {
+            *target_ptr = EagerComplex64::new(*source_ptr, 0.0);
+            source_ptr = source_ptr.add(1);
+            target_ptr = target_ptr.add(target_component_count);
+        }
+    }
+}
+
+fn fill_packet_component(
+    target: &mut [EagerComplex64],
+    target_component: usize,
+    target_component_count: usize,
+    target_lane_start: usize,
+    point_count: usize,
+    value: EagerComplex64,
+) {
+    let target_start = target_lane_start * target_component_count + target_component;
+    debug_assert!(
+        point_count == 0
+            || target_start + (point_count - 1) * target_component_count < target.len()
+    );
+    // Safety follows from the active packet size established by packet_slices.
+    unsafe {
+        let mut target_ptr = target.as_mut_ptr().add(target_start);
+        for _ in 0..point_count {
+            *target_ptr = value;
+            target_ptr = target_ptr.add(target_component_count);
+        }
+    }
+}
+
+fn copy_component_range(
+    source: &[EagerComplex64],
+    source_range: ComponentRange,
+    target: &mut [EagerComplex64],
+    target_range: ComponentRange,
+    stride: usize,
+    point_count: usize,
+) {
+    debug_assert_eq!(source_range.len, target_range.len);
+    for component in 0..source_range.len {
+        let source_start = (source_range.start + component) * stride;
+        let target_start = (target_range.start + component) * stride;
+        target[target_start..target_start + point_count]
+            .copy_from_slice(&source[source_start..source_start + point_count]);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{EagerAttachmentRow, EagerFinalizationRow, EagerInvocationRow, MISSING_U32};
+
+    fn c64(real: f64, imag: f64) -> EagerComplex64 {
+        EagerComplex64::new(real, imag)
+    }
+
+    #[test]
+    fn packet_gather_uses_lane_major_component_rows() {
+        let complex_source = [
+            c64(1.0, 10.0),
+            c64(2.0, 20.0),
+            c64(3.0, 30.0),
+            c64(4.0, 40.0),
+            c64(5.0, 50.0),
+            c64(6.0, 60.0),
+        ];
+        let real_source = [11.0, 12.0, 13.0, 14.0, 15.0, 16.0];
+        let mut packet = vec![c64(0.0, 0.0); 4 * 3];
+
+        gather_complex_component(
+            &complex_source,
+            ComponentRange { start: 1, len: 1 },
+            0,
+            3,
+            0,
+            &mut packet,
+            1,
+            3,
+            1,
+            2,
+        );
+        gather_real_component(
+            &real_source,
+            ComponentRange { start: 0, len: 2 },
+            1,
+            3,
+            0,
+            &mut packet,
+            0,
+            3,
+            1,
+            2,
+        );
+        fill_packet_component(&mut packet, 2, 3, 1, 2, c64(-1.0, 2.0));
+
+        assert_eq!(
+            packet,
+            vec![
+                c64(0.0, 0.0),
+                c64(0.0, 0.0),
+                c64(0.0, 0.0),
+                c64(14.0, 0.0),
+                c64(4.0, 40.0),
+                c64(-1.0, 2.0),
+                c64(15.0, 0.0),
+                c64(5.0, 50.0),
+                c64(-1.0, 2.0),
+                c64(0.0, 0.0),
+                c64(0.0, 0.0),
+                c64(0.0, 0.0),
+            ]
+        );
+    }
+
+    #[test]
+    fn selected_amplitude_copy_leaves_inactive_slots_untouched() {
+        let workspace = EagerWorkspace {
+            tile_capacity: 3,
+            values: Vec::new(),
+            currents: Vec::new(),
+            amplitudes: vec![
+                c64(1.0, 0.0),
+                c64(2.0, 0.0),
+                c64(3.0, 0.0),
+                c64(10.0, 0.0),
+                c64(20.0, 0.0),
+                c64(30.0, 0.0),
+                c64(100.0, 0.0),
+                c64(200.0, 0.0),
+                c64(300.0, 0.0),
+            ],
+            reduction_groups: Vec::new(),
+            couplings: Vec::new(),
+            reduced: Vec::new(),
+            packet: Vec::new(),
+        };
+        let sentinel = c64(-99.0, 1.0);
+        let mut output = vec![sentinel; 3 * 5];
+
+        copy_selected_tile_amplitudes(&[1], &workspace, 5, 2, 2, &mut output);
+
+        assert!(output[..5].iter().all(|value| *value == sentinel));
+        assert_eq!(
+            output[5..10],
+            [sentinel, sentinel, c64(10.0, 0.0), c64(20.0, 0.0), sentinel]
+        );
+        assert!(output[10..].iter().all(|value| *value == sentinel));
+    }
+
+    #[test]
+    fn proven_linear_finalization_reuses_shared_momentum_dependence() {
+        let linear = LinearFinalizationPacket {
+            momentum_groups: vec![ComponentRange { start: 0, len: 1 }],
+            item_group_indices: vec![0, 0],
+            current_components: vec![0],
+        };
+        let descriptors = [
+            EagerKernelInput::FirstCurrentComponent(0),
+            EagerKernelInput::FirstMomentumComponent(0),
+            EagerKernelInput::ModelParameter(0),
+        ];
+        let mut inputs = vec![c64(0.0, 0.0); linear.lane_multiplier() * 2 * 3];
+        gather_linear_finalizations(
+            &linear,
+            &descriptors,
+            &mut inputs,
+            3,
+            2,
+            0,
+            2,
+            &[2.0, 3.0],
+            &[c64(5.0, 0.0)],
+        );
+        assert_eq!(
+            inputs,
+            [
+                c64(1.0, 0.0),
+                c64(2.0, 0.0),
+                c64(5.0, 0.0),
+                c64(1.0, 0.0),
+                c64(3.0, 0.0),
+                c64(5.0, 0.0),
+            ]
+        );
+
+        let rows = [
+            ScheduledFinalization {
+                row: EagerFinalizationRow {
+                    kernel_id: 1,
+                    current_id: 0,
+                    unpropagated_value_slot_id: MISSING_U32,
+                    propagated_value_slot_id: 0,
+                    momentum_slot_id: 0,
+                },
+                current: ComponentRange { start: 0, len: 1 },
+                propagated: Some(ComponentRange { start: 0, len: 1 }),
+                momentum: ComponentRange { start: 0, len: 1 },
+                selector_domain_id: None,
+            },
+            ScheduledFinalization {
+                row: EagerFinalizationRow {
+                    kernel_id: 1,
+                    current_id: 1,
+                    unpropagated_value_slot_id: MISSING_U32,
+                    propagated_value_slot_id: 1,
+                    momentum_slot_id: 0,
+                },
+                current: ComponentRange { start: 1, len: 1 },
+                propagated: Some(ComponentRange { start: 1, len: 1 }),
+                momentum: ComponentRange { start: 0, len: 1 },
+                selector_domain_id: None,
+            },
+        ];
+        // f(current, momentum, parameter) = current * (momentum + parameter).
+        let outputs = [c64(7.0, 0.0), c64(8.0, 0.0)];
+        let currents = [
+            c64(10.0, 0.0),
+            c64(20.0, 0.0),
+            c64(30.0, 0.0),
+            c64(40.0, 0.0),
+        ];
+        let mut values = vec![c64(0.0, 0.0); 4];
+        scatter_linear_finalizations(&rows, &linear, &outputs, 2, 2, 2, &currents, &mut values)
+            .unwrap();
+        assert_eq!(
+            values,
+            [
+                c64(70.0, 0.0),
+                c64(160.0, 0.0),
+                c64(210.0, 0.0),
+                c64(320.0, 0.0),
+            ]
+        );
+    }
+
+    #[test]
+    fn row_major_scatter_specializes_exact_unit_factors() {
+        let invocation = ScheduledInvocation {
+            row: EagerInvocationRow {
+                kernel_id: 0,
+                left_value_slot_id: 0,
+                right_value_slot_id: 0,
+                left_momentum_slot_id: 0,
+                right_momentum_slot_id: 0,
+                coupling_slot_id: 0,
+                output_factor_source: EAGER_OUTPUT_FACTOR_NONE,
+                attachment_start: 0,
+                attachment_count: 4,
+            },
+            left_values: ComponentRange { start: 0, len: 1 },
+            right_values: ComponentRange { start: 0, len: 1 },
+            left_momenta: ComponentRange { start: 0, len: 1 },
+            right_momenta: ComponentRange { start: 0, len: 1 },
+            attachment_range: 0..4,
+            selector_domain_id: None,
+        };
+        let factors = [(1.0, 0.0), (-1.0, 0.0), (0.0, 1.0), (0.0, -1.0)];
+        let attachments = factors
+            .into_iter()
+            .enumerate()
+            .map(|(index, (factor_real, factor_imag))| ScheduledAttachment {
+                row: EagerAttachmentRow {
+                    result_current_id: index as u32,
+                    factor_real,
+                    factor_imag,
+                },
+                current: ComponentRange {
+                    start: index * 2,
+                    len: 2,
+                },
+                selector_domain_id: None,
+                initializes_current: true,
+            })
+            .collect::<Vec<_>>();
+        let outputs = [c64(1.0, 2.0), c64(3.0, 4.0), c64(5.0, 6.0), c64(7.0, 8.0)];
+        let mut currents = vec![c64(0.0, 0.0); 8 * 2];
+
+        scatter_invocations(
+            &[invocation],
+            &attachments,
+            &outputs,
+            2,
+            2,
+            2,
+            &[c64(1.0, 0.0)],
+            &mut currents,
+        );
+
+        for (factor_index, (real, imag)) in factors.into_iter().enumerate() {
+            let factor = c64(real, imag);
+            for component in 0..2 {
+                for point in 0..2 {
+                    let expected = factor * outputs[point * 2 + component];
+                    let actual = currents[(factor_index * 2 + component) * 2 + point];
+                    assert_eq!(actual, expected);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn factor_specialization_keeps_generic_complex_fallback() {
+        let initial = c64(2.0, -3.0);
+        let value = c64(5.0, 7.0);
+        for (real, imag) in [
+            (1.0, 0.0),
+            (-1.0, 0.0),
+            (0.0, 1.0),
+            (0.0, -1.0),
+            (2.5, -0.75),
+        ] {
+            let mut actual = initial;
+            AccumulationFactor::from_parts(real, imag).accumulate(&mut actual, value);
+            assert_eq!(actual, initial + c64(real, imag) * value);
+        }
+    }
+
+    #[test]
+    fn signed_fanout_scales_once_and_preserves_accumulation_mode() {
+        let attachments = [
+            ScheduledAttachment {
+                row: EagerAttachmentRow {
+                    result_current_id: 0,
+                    factor_real: 1.0,
+                    factor_imag: 0.0,
+                },
+                current: ComponentRange { start: 0, len: 2 },
+                selector_domain_id: None,
+                initializes_current: true,
+            },
+            ScheduledAttachment {
+                row: EagerAttachmentRow {
+                    result_current_id: 1,
+                    factor_real: -1.0,
+                    factor_imag: 0.0,
+                },
+                current: ComponentRange { start: 2, len: 2 },
+                selector_domain_id: None,
+                initializes_current: false,
+            },
+        ];
+        let outputs = [c64(1.0, 2.0), c64(3.0, 4.0), c64(5.0, 6.0), c64(7.0, 8.0)];
+        let mut currents = vec![c64(0.0, 0.0); 8];
+        currents[4..].fill(c64(10.0, -10.0));
+
+        assert!(scatter_signed_fanout::<2, 2>(
+            &attachments,
+            &outputs,
+            0,
+            2.5,
+            &mut currents,
+            2,
+            2,
+        ));
+
+        assert_eq!(
+            currents,
+            [
+                c64(2.5, 5.0),
+                c64(12.5, 15.0),
+                c64(7.5, 10.0),
+                c64(17.5, 20.0),
+                c64(7.5, -15.0),
+                c64(-2.5, -25.0),
+                c64(2.5, -20.0),
+                c64(-7.5, -30.0),
+            ]
+        );
+    }
+
+    #[test]
+    fn invocation_output_factor_uses_live_coupling_component() {
+        let invocation = ScheduledInvocation {
+            row: EagerInvocationRow {
+                kernel_id: 0,
+                left_value_slot_id: 0,
+                right_value_slot_id: 0,
+                left_momentum_slot_id: 0,
+                right_momentum_slot_id: 0,
+                coupling_slot_id: 0,
+                output_factor_source: EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+                attachment_start: 0,
+                attachment_count: 1,
+            },
+            left_values: ComponentRange { start: 0, len: 1 },
+            right_values: ComponentRange { start: 0, len: 1 },
+            left_momenta: ComponentRange { start: 0, len: 1 },
+            right_momenta: ComponentRange { start: 0, len: 1 },
+            attachment_range: 0..1,
+            selector_domain_id: None,
+        };
+        let attachments = [ScheduledAttachment {
+            row: EagerAttachmentRow {
+                result_current_id: 0,
+                factor_real: 0.0,
+                factor_imag: 1.0,
+            },
+            current: ComponentRange { start: 0, len: 2 },
+            selector_domain_id: None,
+            initializes_current: true,
+        }];
+        let outputs = [c64(1.0, 2.0), c64(3.0, 4.0)];
+        let mut currents = vec![c64(0.0, 0.0); 2];
+
+        scatter_invocations(
+            &[invocation],
+            &attachments,
+            &outputs,
+            1,
+            1,
+            1,
+            &[c64(2.5, 7.0)],
+            &mut currents,
+        );
+
+        assert_eq!(currents, [c64(-5.0, 2.5), c64(-10.0, 7.5)]);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/plan.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/plan.rs
new file mode 100644
index 0000000000..680bb81096
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/plan.rs
@@ -0,0 +1,1531 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::{
+    EagerComplex64, EagerDirectClosureSpec, EagerKernelInput, EagerKernelRole, EagerKernelSpec,
+    EagerPlanDefinition, EagerPlanPayloads, EagerReductionEntry, EagerReductionGroup,
+    EagerSelectorPayloads, EagerStagePayload,
+};
+use crate::{
+    EAGER_OUTPUT_FACTOR_NONE, EagerAttachmentRow, EagerClosureRow, EagerCouplingRow,
+    EagerFinalizationRow, EagerInvocationRow, EagerSelectorDomainIdRow, EagerSelectorDomainRow,
+    EagerSelectorGroupRow, MISSING_U32, RusticolError, RusticolResult,
+};
+use std::collections::{BTreeMap, BTreeSet};
+use std::ops::Range;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) struct ComponentRange {
+    pub(super) start: usize,
+    pub(super) len: usize,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ComponentLayout {
+    slots: Vec<ComponentRange>,
+    pub(super) component_count: usize,
+}
+
+impl ComponentLayout {
+    pub(super) fn new(name: &str, component_counts: &[u32]) -> RusticolResult<Self> {
+        let mut slots = Vec::new();
+        slots
+            .try_reserve_exact(component_counts.len())
+            .map_err(|error| {
+                RusticolError::artifact(format!(
+                    "could not reserve eager {name} slot layout: {error}"
+                ))
+            })?;
+        let mut start = 0usize;
+        for (slot_id, count) in component_counts.iter().copied().enumerate() {
+            let len = usize::try_from(count).map_err(|_| {
+                RusticolError::artifact(format!(
+                    "eager {name} slot {slot_id} component count does not fit usize"
+                ))
+            })?;
+            if len == 0 {
+                return Err(RusticolError::artifact(format!(
+                    "eager {name} slot {slot_id} has zero components"
+                )));
+            }
+            slots.push(ComponentRange { start, len });
+            start = start.checked_add(len).ok_or_else(|| {
+                RusticolError::artifact(format!("eager {name} component layout overflows usize"))
+            })?;
+        }
+        Ok(Self {
+            slots,
+            component_count: start,
+        })
+    }
+
+    pub(super) fn get(&self, id: u32, context: &str) -> RusticolResult<ComponentRange> {
+        let index = usize::try_from(id).map_err(|_| {
+            RusticolError::artifact(format!("{context} id {id} does not fit usize"))
+        })?;
+        self.slots.get(index).copied().ok_or_else(|| {
+            RusticolError::artifact(format!("{context} references unknown slot {id}"))
+        })
+    }
+
+    pub(super) fn id_for_range(&self, range: ComponentRange, context: &str) -> RusticolResult<u32> {
+        self.slots
+            .iter()
+            .position(|candidate| *candidate == range)
+            .and_then(|id| u32::try_from(id).ok())
+            .ok_or_else(|| {
+                RusticolError::internal(format!(
+                    "{context} has no matching semantic component range"
+                ))
+            })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ScheduledInvocation {
+    pub(super) row: EagerInvocationRow,
+    pub(super) left_values: ComponentRange,
+    pub(super) right_values: ComponentRange,
+    pub(super) left_momenta: ComponentRange,
+    pub(super) right_momenta: ComponentRange,
+    pub(super) attachment_range: Range<usize>,
+    pub(super) selector_domain_id: Option<u32>,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(super) struct ScheduledAttachment {
+    pub(super) row: EagerAttachmentRow,
+    pub(super) current: ComponentRange,
+    pub(super) selector_domain_id: Option<u32>,
+    pub(super) initializes_current: bool,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(super) struct FinalizationCopy {
+    pub(super) current: ComponentRange,
+    pub(super) unpropagated: ComponentRange,
+    pub(super) selector_domain_id: Option<u32>,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ScheduledFinalization {
+    pub(super) row: EagerFinalizationRow,
+    pub(super) current: ComponentRange,
+    pub(super) propagated: Option<ComponentRange>,
+    pub(super) momentum: ComponentRange,
+    pub(super) selector_domain_id: Option<u32>,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ScheduledClosure {
+    pub(super) row: EagerClosureRow,
+    pub(super) left_values: ComponentRange,
+    pub(super) right_values: ComponentRange,
+    pub(super) selector_domain_id: Option<u32>,
+    pub(super) initializes_amplitude: bool,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ScheduledDirectClosure {
+    pub(super) row: EagerClosureRow,
+    pub(super) left_values: ComponentRange,
+    pub(super) right_values: ComponentRange,
+    pub(super) coefficients: Vec<EagerComplex64>,
+    pub(super) selector_domain_id: Option<u32>,
+    pub(super) initializes_amplitude: bool,
+}
+
+#[derive(Clone, Copy)]
+pub(super) struct ClosureExecutionRows<'a> {
+    pub(super) closures: &'a [ScheduledClosure],
+    pub(super) direct_closures: &'a [ScheduledDirectClosure],
+    pub(super) kernels: &'a BTreeMap<u32, EagerKernelSpec>,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct SelectorDomainPlan {
+    pub(super) memberships: Vec<Vec<u32>>,
+    pub(super) group_ids: Vec<u32>,
+}
+
+#[derive(Clone, Debug)]
+struct DecodedSelectorStage {
+    stage_index: u32,
+    invocation_domains: Vec<u32>,
+    attachment_domains: Vec<u32>,
+    unpropagated_finalization_domains: Vec<u32>,
+    propagated_finalization_domains: Vec<u32>,
+}
+
+#[derive(Clone, Debug)]
+struct DecodedSelectorPayload {
+    plan: SelectorDomainPlan,
+    stages: Vec<DecodedSelectorStage>,
+    closure_domains: Vec<u32>,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct EagerStagePlan {
+    pub(super) stage_index: u32,
+    pub(super) current_component_count: usize,
+    pub(super) invocations: Vec<ScheduledInvocation>,
+    pub(super) attachments: Vec<ScheduledAttachment>,
+    pub(super) finalization_copies: Vec<FinalizationCopy>,
+    pub(super) finalizations: Vec<ScheduledFinalization>,
+    pub(super) zero_current_ranges: Vec<ComponentRange>,
+}
+
+#[derive(Clone, Debug)]
+pub struct EagerExecutionPlan {
+    pub(super) values: ComponentLayout,
+    pub(super) momenta: ComponentLayout,
+    pub(super) currents: ComponentLayout,
+    pub(super) parameter_count: usize,
+    pub(super) amplitude_count: usize,
+    pub(super) kernels: BTreeMap<u32, EagerKernelSpec>,
+    pub(super) couplings: Vec<EagerCouplingRow>,
+    pub(super) stages: Vec<EagerStagePlan>,
+    pub(super) closures: Vec<ScheduledClosure>,
+    pub(super) direct_closures: Vec<ScheduledDirectClosure>,
+    pub(super) reduction_groups: Vec<EagerReductionGroup>,
+    pub(super) reduction_entries: Vec<EagerReductionEntry>,
+    pub(super) selector_domains: Option<SelectorDomainPlan>,
+    pub(super) initial_value_ranges: Vec<ComponentRange>,
+    pub(super) zero_amplitude_indices: Vec<usize>,
+}
+
+impl EagerExecutionPlan {
+    pub fn from_payloads(
+        definition: EagerPlanDefinition,
+        payloads: EagerPlanPayloads<'_>,
+    ) -> RusticolResult<Self> {
+        let values =
+            ComponentLayout::new("value", &definition.dimensions.value_slot_component_counts)?;
+        let momenta = ComponentLayout::new(
+            "momentum",
+            &definition.dimensions.momentum_slot_component_counts,
+        )?;
+        let currents =
+            ComponentLayout::new("current", &definition.dimensions.current_component_counts)?;
+        let parameter_count = usize::try_from(definition.dimensions.parameter_count)
+            .map_err(|_| RusticolError::artifact("eager parameter count does not fit usize"))?;
+        let amplitude_count = usize::try_from(definition.dimensions.amplitude_count)
+            .map_err(|_| RusticolError::artifact("eager amplitude count does not fit usize"))?;
+        if amplitude_count == 0 {
+            return Err(RusticolError::artifact(
+                "eager execution plan has no amplitude outputs",
+            ));
+        }
+
+        let kernels = validate_kernel_specs(&definition.kernels, parameter_count)?;
+        let couplings = EagerCouplingRow::decode_table(payloads.couplings)?;
+        validate_couplings(&couplings, parameter_count)?;
+        let selector_payload =
+            decode_selector_payloads(payloads.selector_domains, payloads.stages)?;
+
+        let mut stages = Vec::new();
+        stages
+            .try_reserve_exact(payloads.stages.len())
+            .map_err(|error| {
+                RusticolError::artifact(format!("could not reserve eager stages: {error}"))
+            })?;
+        let mut previous_stage = None;
+        let mut finalized_currents = BTreeSet::new();
+        let mut stored_value_slots = BTreeSet::new();
+        for (stage_position, payload) in payloads.stages.iter().enumerate() {
+            if previous_stage.is_some_and(|previous| payload.stage_index <= previous) {
+                return Err(RusticolError::artifact(
+                    "eager stage indices must be strictly increasing",
+                ));
+            }
+            previous_stage = Some(payload.stage_index);
+            stages.push(load_stage(
+                *payload,
+                selector_payload
+                    .as_ref()
+                    .map(|selector| &selector.stages[stage_position]),
+                selector_payload.as_ref().map(|selector| &selector.plan),
+                &values,
+                &momenta,
+                &currents,
+                &kernels,
+                couplings.len(),
+                parameter_count,
+                &mut finalized_currents,
+                &mut stored_value_slots,
+            )?);
+        }
+
+        let closure_rows = EagerClosureRow::decode_table(payloads.closures)?;
+        let closure_domains = selector_payload
+            .as_ref()
+            .map(|selector| selector.closure_domains.as_slice());
+        if closure_domains.is_some_and(|domains| domains.len() != closure_rows.len()) {
+            return Err(RusticolError::artifact(
+                "eager closure selector-domain count does not match the closure table",
+            ));
+        }
+        let (mut closures, mut direct_closures) = load_closures(
+            &closure_rows,
+            closure_domains,
+            &definition.direct_closures,
+            &values,
+            &kernels,
+            couplings.len(),
+            amplitude_count,
+            parameter_count,
+        )?;
+        validate_reduction_plan(
+            &definition.reduction_groups,
+            &definition.reduction_entries,
+            amplitude_count,
+        )?;
+        if let Some(selector) = selector_payload.as_ref() {
+            validate_selector_dependency_proof(
+                selector,
+                payloads.stages,
+                &closure_rows,
+                &definition.reduction_groups,
+                amplitude_count,
+            )?;
+        }
+
+        let initial_value_ranges = values
+            .slots
+            .iter()
+            .enumerate()
+            .filter_map(|(slot_id, range)| {
+                (!stored_value_slots.contains(&(slot_id as u32))).then_some(*range)
+            })
+            .collect();
+        let zero_amplitude_indices =
+            mark_initial_amplitude_writes(&mut closures, &mut direct_closures, amplitude_count);
+
+        Ok(Self {
+            values,
+            momenta,
+            currents,
+            parameter_count,
+            amplitude_count,
+            kernels,
+            couplings,
+            stages,
+            closures,
+            direct_closures,
+            reduction_groups: definition.reduction_groups,
+            reduction_entries: definition.reduction_entries,
+            selector_domains: selector_payload.map(|selector| selector.plan),
+            initial_value_ranges,
+            zero_amplitude_indices,
+        })
+    }
+
+    pub fn value_component_count(&self) -> usize {
+        self.values.component_count
+    }
+
+    pub fn momentum_component_count(&self) -> usize {
+        self.momenta.component_count
+    }
+
+    pub fn current_component_count(&self) -> usize {
+        self.currents.component_count
+    }
+
+    pub(super) fn current_workspace_component_count(&self) -> usize {
+        self.stages
+            .iter()
+            .map(|stage| stage.current_component_count)
+            .max()
+            .unwrap_or(0)
+    }
+
+    pub fn parameter_count(&self) -> usize {
+        self.parameter_count
+    }
+
+    pub fn amplitude_count(&self) -> usize {
+        self.amplitude_count
+    }
+
+    pub fn stage_count(&self) -> usize {
+        self.stages.len()
+    }
+
+    pub fn stage_indices(&self) -> impl ExactSizeIterator<Item = u32> + '_ {
+        self.stages.iter().map(|stage| stage.stage_index)
+    }
+
+    pub fn invocation_count(&self) -> usize {
+        self.stages
+            .iter()
+            .map(|stage| stage.invocations.len())
+            .sum()
+    }
+
+    pub fn attachment_count(&self) -> usize {
+        self.stages
+            .iter()
+            .map(|stage| stage.attachments.len())
+            .sum()
+    }
+
+    pub fn closure_count(&self) -> usize {
+        self.closures.len() + self.direct_closures.len()
+    }
+
+    pub fn reduction_group_count(&self) -> usize {
+        self.reduction_groups.len()
+    }
+
+    pub fn reduction_entry_count(&self) -> usize {
+        self.reduction_entries.len()
+    }
+
+    pub fn has_selector_domains(&self) -> bool {
+        self.selector_domains.is_some()
+    }
+
+    pub(crate) fn selector_group_ids(&self) -> Option<&[u32]> {
+        Some(&self.selector_domains.as_ref()?.group_ids)
+    }
+}
+
+fn decode_selector_payloads(
+    payloads: Option<EagerSelectorPayloads<'_>>,
+    execution_stages: &[EagerStagePayload<'_>],
+) -> RusticolResult<Option<DecodedSelectorPayload>> {
+    let Some(payloads) = payloads else {
+        return Ok(None);
+    };
+    if payloads.stages.len() != execution_stages.len() {
+        return Err(RusticolError::artifact(format!(
+            "eager selector domains cover {} stages, expected {}",
+            payloads.stages.len(),
+            execution_stages.len()
+        )));
+    }
+
+    let domain_rows = EagerSelectorDomainRow::decode_table(payloads.domains)?;
+    let group_rows = EagerSelectorGroupRow::decode_table(payloads.domain_group_ids)?;
+    if domain_rows.is_empty() {
+        return Err(RusticolError::artifact(
+            "eager selector-domain table is empty",
+        ));
+    }
+    let mut memberships = Vec::new();
+    memberships
+        .try_reserve_exact(domain_rows.len())
+        .map_err(|error| {
+            RusticolError::artifact(format!("could not reserve eager selector domains: {error}"))
+        })?;
+    let mut cursor = 0usize;
+    let mut unique_memberships = BTreeSet::new();
+    for (domain_id, row) in domain_rows.into_iter().enumerate() {
+        let start = usize::try_from(row.member_start).map_err(|_| {
+            RusticolError::artifact(format!(
+                "eager selector domain {domain_id} start does not fit usize"
+            ))
+        })?;
+        let count = usize::try_from(row.member_count).map_err(|_| {
+            RusticolError::artifact(format!(
+                "eager selector domain {domain_id} count does not fit usize"
+            ))
+        })?;
+        if start != cursor {
+            return Err(RusticolError::artifact(format!(
+                "eager selector domain {domain_id} starts at {start}, expected {cursor}"
+            )));
+        }
+        let stop = start.checked_add(count).ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "eager selector domain {domain_id} range overflows usize"
+            ))
+        })?;
+        if stop > group_rows.len() {
+            return Err(RusticolError::artifact(format!(
+                "eager selector domain {domain_id} exceeds its membership table"
+            )));
+        }
+        let members = group_rows[start..stop]
+            .iter()
+            .map(|row| row.coherent_group_id)
+            .collect::<Vec<_>>();
+        if members.windows(2).any(|pair| pair[0] >= pair[1]) {
+            return Err(RusticolError::artifact(format!(
+                "eager selector domain {domain_id} members are not sorted and unique"
+            )));
+        }
+        if !unique_memberships.insert(members.clone()) {
+            return Err(RusticolError::artifact(format!(
+                "eager selector domain {domain_id} duplicates an earlier membership"
+            )));
+        }
+        memberships.push(members);
+        cursor = stop;
+    }
+    if cursor != group_rows.len() {
+        return Err(RusticolError::artifact(
+            "eager selector domains do not cover their membership table",
+        ));
+    }
+    if !memberships.iter().any(Vec::is_empty) {
+        return Err(RusticolError::artifact(
+            "eager selector domains do not define the empty domain",
+        ));
+    }
+    let domain_count = memberships.len();
+    let mut group_ids = memberships
+        .iter()
+        .flat_map(|members| members.iter().copied())
+        .collect::<Vec<_>>();
+    group_ids.sort_unstable();
+    group_ids.dedup();
+
+    let mut stages = Vec::new();
+    stages
+        .try_reserve_exact(payloads.stages.len())
+        .map_err(|error| {
+            RusticolError::artifact(format!("could not reserve eager selector stages: {error}"))
+        })?;
+    for (position, (selector, execution)) in
+        payloads.stages.iter().zip(execution_stages).enumerate()
+    {
+        if selector.stage_index != execution.stage_index {
+            return Err(RusticolError::artifact(format!(
+                "eager selector stage {} at position {position} does not match execution stage {}",
+                selector.stage_index, execution.stage_index
+            )));
+        }
+        stages.push(DecodedSelectorStage {
+            stage_index: selector.stage_index,
+            invocation_domains: decode_domain_ids(
+                selector.invocation_domains,
+                domain_count,
+                "invocation",
+            )?,
+            attachment_domains: decode_domain_ids(
+                selector.attachment_domains,
+                domain_count,
+                "attachment",
+            )?,
+            unpropagated_finalization_domains: decode_domain_ids(
+                selector.unpropagated_finalization_domains,
+                domain_count,
+                "unpropagated finalization",
+            )?,
+            propagated_finalization_domains: decode_domain_ids(
+                selector.propagated_finalization_domains,
+                domain_count,
+                "propagated finalization",
+            )?,
+        });
+    }
+    let closure_domains = decode_domain_ids(payloads.closure_domains, domain_count, "closure")?;
+    Ok(Some(DecodedSelectorPayload {
+        plan: SelectorDomainPlan {
+            memberships,
+            group_ids,
+        },
+        stages,
+        closure_domains,
+    }))
+}
+
+fn decode_domain_ids(
+    payload: &[u8],
+    domain_count: usize,
+    context: &str,
+) -> RusticolResult<Vec<u32>> {
+    let rows = EagerSelectorDomainIdRow::decode_table(payload)?;
+    let mut result = Vec::with_capacity(rows.len());
+    for (index, row) in rows.into_iter().enumerate() {
+        if usize::try_from(row.domain_id)
+            .ok()
+            .is_none_or(|domain_id| domain_id >= domain_count)
+        {
+            return Err(RusticolError::artifact(format!(
+                "eager {context} selector row {index} references unknown domain {}",
+                row.domain_id
+            )));
+        }
+        result.push(row.domain_id);
+    }
+    Ok(result)
+}
+
+fn validate_selector_dependency_proof(
+    selector: &DecodedSelectorPayload,
+    stage_payloads: &[EagerStagePayload<'_>],
+    closures: &[EagerClosureRow],
+    reduction_groups: &[EagerReductionGroup],
+    amplitude_count: usize,
+) -> RusticolResult<()> {
+    let mut group_by_amplitude = vec![None; amplitude_count];
+    let known_groups = reduction_groups
+        .iter()
+        .map(|group| group.coherent_group_id)
+        .collect::<BTreeSet<_>>();
+    for group in reduction_groups {
+        for amplitude_index in &group.amplitude_indices {
+            let index = usize::try_from(*amplitude_index).map_err(|_| {
+                RusticolError::artifact("eager reduction amplitude index does not fit usize")
+            })?;
+            group_by_amplitude[index] = Some(group.coherent_group_id);
+        }
+    }
+    for members in &selector.plan.memberships {
+        if let Some(unknown) = members.iter().find(|group| !known_groups.contains(group)) {
+            return Err(RusticolError::artifact(format!(
+                "eager selector domain references unknown coherent group {unknown}"
+            )));
+        }
+    }
+
+    let mut value_domains = BTreeMap::<u32, BTreeSet<u32>>::new();
+    for (index, closure) in closures.iter().enumerate() {
+        let amplitude_index = required_index(
+            closure.amplitude_index,
+            amplitude_count,
+            "eager closure amplitude",
+        )?;
+        let group_id = group_by_amplitude[amplitude_index].ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "eager closure amplitude {amplitude_index} has no coherent group"
+            ))
+        })?;
+        let expected = BTreeSet::from([group_id]);
+        validate_selector_domain_members(
+            &selector.plan,
+            selector.closure_domains[index],
+            &expected,
+            &format!("eager closure {index}"),
+        )?;
+        value_domains
+            .entry(closure.left_value_slot_id)
+            .or_default()
+            .insert(group_id);
+        value_domains
+            .entry(closure.right_value_slot_id)
+            .or_default()
+            .insert(group_id);
+    }
+
+    for (payload, selector_stage) in stage_payloads.iter().zip(&selector.stages).rev() {
+        let invocations = EagerInvocationRow::decode_table(payload.invocations)?;
+        let attachments = EagerAttachmentRow::decode_table(payload.attachments)?;
+        let finalizations = EagerFinalizationRow::decode_table(payload.finalizations)?;
+        let mut current_domains = BTreeMap::<u32, BTreeSet<u32>>::new();
+
+        for (index, finalization) in finalizations.iter().enumerate() {
+            let unpropagated = if finalization.stores_unpropagated() {
+                value_domains
+                    .get(&finalization.unpropagated_value_slot_id)
+                    .cloned()
+                    .unwrap_or_default()
+            } else {
+                BTreeSet::new()
+            };
+            validate_selector_domain_members(
+                &selector.plan,
+                selector_stage.unpropagated_finalization_domains[index],
+                &unpropagated,
+                &format!(
+                    "eager stage {} unpropagated finalization {index}",
+                    payload.stage_index
+                ),
+            )?;
+            let propagated = if finalization.stores_propagated() {
+                value_domains
+                    .get(&finalization.propagated_value_slot_id)
+                    .cloned()
+                    .unwrap_or_default()
+            } else {
+                BTreeSet::new()
+            };
+            validate_selector_domain_members(
+                &selector.plan,
+                selector_stage.propagated_finalization_domains[index],
+                &propagated,
+                &format!(
+                    "eager stage {} propagated finalization {index}",
+                    payload.stage_index
+                ),
+            )?;
+            let mut current = unpropagated;
+            current.extend(propagated);
+            current_domains.insert(finalization.current_id, current);
+        }
+
+        let mut attachment_domains = Vec::with_capacity(attachments.len());
+        for (index, attachment) in attachments.iter().enumerate() {
+            let expected = current_domains
+                .get(&attachment.result_current_id)
+                .ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "eager stage {} attachment {index} has no finalized current",
+                        payload.stage_index
+                    ))
+                })?;
+            validate_selector_domain_members(
+                &selector.plan,
+                selector_stage.attachment_domains[index],
+                expected,
+                &format!("eager stage {} attachment {index}", payload.stage_index),
+            )?;
+            attachment_domains.push(expected.clone());
+        }
+
+        for (index, invocation) in invocations.iter().enumerate() {
+            let start = usize::try_from(invocation.attachment_start).map_err(|_| {
+                RusticolError::artifact("eager invocation attachment start does not fit usize")
+            })?;
+            let count = usize::try_from(invocation.attachment_count).map_err(|_| {
+                RusticolError::artifact("eager invocation attachment count does not fit usize")
+            })?;
+            let stop = start.checked_add(count).ok_or_else(|| {
+                RusticolError::artifact("eager invocation attachment range overflows usize")
+            })?;
+            let mut expected = BTreeSet::new();
+            for domain in attachment_domains.get(start..stop).ok_or_else(|| {
+                RusticolError::artifact("eager invocation attachment range exceeds its table")
+            })? {
+                expected.extend(domain);
+            }
+            validate_selector_domain_members(
+                &selector.plan,
+                selector_stage.invocation_domains[index],
+                &expected,
+                &format!("eager stage {} invocation {index}", payload.stage_index),
+            )?;
+            value_domains
+                .entry(invocation.left_value_slot_id)
+                .or_default()
+                .extend(&expected);
+            value_domains
+                .entry(invocation.right_value_slot_id)
+                .or_default()
+                .extend(expected);
+        }
+    }
+    Ok(())
+}
+
+fn validate_selector_domain_members(
+    plan: &SelectorDomainPlan,
+    domain_id: u32,
+    expected: &BTreeSet<u32>,
+    context: &str,
+) -> RusticolResult<()> {
+    let actual = plan
+        .memberships
+        .get(domain_id as usize)
+        .ok_or_else(|| RusticolError::internal("selector domain escaped payload validation"))?;
+    if !actual.iter().copied().eq(expected.iter().copied()) {
+        return Err(RusticolError::artifact(format!(
+            "{context} selector domain does not match its proven dependency closure"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_kernel_specs(
+    specs: &[EagerKernelSpec],
+    parameter_count: usize,
+) -> RusticolResult<BTreeMap<u32, EagerKernelSpec>> {
+    let mut kernels = BTreeMap::new();
+    for (index, spec) in specs.iter().cloned().enumerate() {
+        if spec.kernel_id == MISSING_U32 {
+            return Err(RusticolError::artifact(format!(
+                "eager kernel spec {index} uses the reserved missing id"
+            )));
+        }
+        if spec.inputs.is_empty() || spec.output_component_count == 0 {
+            return Err(RusticolError::artifact(format!(
+                "eager kernel {} has a zero input or output width",
+                spec.kernel_id
+            )));
+        }
+        if spec.independent_block_size != 1 {
+            if spec.independent_block_size != super::EAGER_INDEPENDENT_BLOCK_SIZE {
+                return Err(RusticolError::artifact(format!(
+                    "eager kernel {} has unsupported independent block size {}",
+                    spec.kernel_id, spec.independent_block_size
+                )));
+            }
+            if spec.role != EagerKernelRole::Vertex
+                || spec.inputs.iter().any(|input| {
+                    !matches!(
+                        input,
+                        EagerKernelInput::FirstCurrentComponent(_)
+                            | EagerKernelInput::SecondCurrentComponent(_)
+                    )
+                })
+            {
+                return Err(RusticolError::artifact(format!(
+                    "eager kernel {} applies an independent block to a non-current vertex contract",
+                    spec.kernel_id
+                )));
+            }
+        }
+        let mut unique_inputs = BTreeSet::new();
+        for input in &spec.inputs {
+            if !unique_inputs.insert(*input) {
+                return Err(RusticolError::artifact(format!(
+                    "eager kernel {} repeats input descriptor {input:?}",
+                    spec.kernel_id
+                )));
+            }
+            if let EagerKernelInput::ModelParameter(parameter_id) = input {
+                required_index(
+                    *parameter_id,
+                    parameter_count,
+                    &format!("eager kernel {} model parameter", spec.kernel_id),
+                )?;
+            }
+        }
+        let kernel_id = spec.kernel_id;
+        if kernels.insert(kernel_id, spec).is_some() {
+            return Err(RusticolError::artifact(format!(
+                "duplicate eager kernel id {kernel_id}"
+            )));
+        }
+    }
+    Ok(kernels)
+}
+
+fn validate_couplings(rows: &[EagerCouplingRow], parameter_count: usize) -> RusticolResult<()> {
+    for (index, row) in rows.iter().enumerate() {
+        validate_optional_index(
+            row.real_parameter_id,
+            parameter_count,
+            &format!("eager coupling {index} real parameter"),
+        )?;
+        validate_optional_index(
+            row.imag_parameter_id,
+            parameter_count,
+            &format!("eager coupling {index} imaginary parameter"),
+        )?;
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn load_stage(
+    payload: EagerStagePayload<'_>,
+    selector_stage: Option<&DecodedSelectorStage>,
+    selector_plan: Option<&SelectorDomainPlan>,
+    values: &ComponentLayout,
+    momenta: &ComponentLayout,
+    currents: &ComponentLayout,
+    kernels: &BTreeMap<u32, EagerKernelSpec>,
+    coupling_count: usize,
+    parameter_count: usize,
+    globally_finalized_currents: &mut BTreeSet<u32>,
+    globally_stored_value_slots: &mut BTreeSet<u32>,
+) -> RusticolResult<EagerStagePlan> {
+    let rows = EagerInvocationRow::decode_table(payload.invocations)?;
+    let attachments = EagerAttachmentRow::decode_table(payload.attachments)?;
+    let finalization_rows = EagerFinalizationRow::decode_table(payload.finalizations)?;
+    if let Some(selector) = selector_stage {
+        if selector.stage_index != payload.stage_index {
+            return Err(RusticolError::artifact(format!(
+                "eager selector stage {} does not match execution stage {}",
+                selector.stage_index, payload.stage_index
+            )));
+        }
+        for (kind, actual, expected) in [
+            ("invocation", selector.invocation_domains.len(), rows.len()),
+            (
+                "attachment",
+                selector.attachment_domains.len(),
+                attachments.len(),
+            ),
+            (
+                "unpropagated finalization",
+                selector.unpropagated_finalization_domains.len(),
+                finalization_rows.len(),
+            ),
+            (
+                "propagated finalization",
+                selector.propagated_finalization_domains.len(),
+                finalization_rows.len(),
+            ),
+        ] {
+            if actual != expected {
+                return Err(RusticolError::artifact(format!(
+                    "eager stage {} {kind} selector-domain count is {actual}, expected {expected}",
+                    payload.stage_index
+                )));
+            }
+        }
+    }
+    let mut invocations = Vec::new();
+    invocations.try_reserve_exact(rows.len()).map_err(|error| {
+        RusticolError::artifact(format!("could not reserve eager invocations: {error}"))
+    })?;
+    let mut attachment_cursor = 0usize;
+    let mut attached_currents = BTreeSet::new();
+    let mut scheduled_attachments = Vec::new();
+    scheduled_attachments
+        .try_reserve_exact(attachments.len())
+        .map_err(|error| {
+            RusticolError::artifact(format!("could not reserve eager attachments: {error}"))
+        })?;
+
+    for (index, row) in rows.into_iter().enumerate() {
+        let kernel = require_kernel(
+            kernels,
+            row.kernel_id,
+            EagerKernelRole::Vertex,
+            "invocation",
+        )?;
+        let left_values = values.get(row.left_value_slot_id, "eager invocation left value")?;
+        let right_values = values.get(row.right_value_slot_id, "eager invocation right value")?;
+        let left_momenta =
+            momenta.get(row.left_momentum_slot_id, "eager invocation left momentum")?;
+        let right_momenta = momenta.get(
+            row.right_momentum_slot_id,
+            "eager invocation right momentum",
+        )?;
+        let coupling_index = required_index(
+            row.coupling_slot_id,
+            coupling_count,
+            "eager invocation coupling",
+        )?;
+        let _ = coupling_index;
+        let attachment_start = usize::try_from(row.attachment_start).map_err(|_| {
+            RusticolError::artifact(format!(
+                "eager invocation {index} attachment start does not fit usize"
+            ))
+        })?;
+        let attachment_count = usize::try_from(row.attachment_count).map_err(|_| {
+            RusticolError::artifact(format!(
+                "eager invocation {index} attachment count does not fit usize"
+            ))
+        })?;
+        if attachment_count == 0 {
+            return Err(RusticolError::artifact(format!(
+                "eager invocation {index} has no attachments"
+            )));
+        }
+        if attachment_start != attachment_cursor {
+            return Err(RusticolError::artifact(format!(
+                "eager invocation {index} attachment range is not contiguous"
+            )));
+        }
+        let attachment_end = attachment_start
+            .checked_add(attachment_count)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "eager invocation {index} attachment range overflows usize"
+                ))
+            })?;
+        if attachment_end > attachments.len() {
+            return Err(RusticolError::artifact(format!(
+                "eager invocation {index} attachment range exceeds the table"
+            )));
+        }
+        validate_kernel_inputs(
+            kernel,
+            KernelInputBounds {
+                first_current: left_values.len,
+                second_current: right_values.len,
+                first_momentum: left_momenta.len,
+                second_momentum: right_momenta.len,
+                has_coupling: true,
+                parameter_count,
+            },
+        )?;
+        if let (Some(selector), Some(domains)) = (selector_stage, selector_plan) {
+            let expected_members = selector.attachment_domains[attachment_start..attachment_end]
+                .iter()
+                .flat_map(|domain_id| domains.memberships[*domain_id as usize].iter().copied())
+                .collect::<BTreeSet<_>>();
+            let invocation_members = domains.memberships
+                [selector.invocation_domains[index] as usize]
+                .iter()
+                .copied()
+                .collect::<BTreeSet<_>>();
+            if invocation_members != expected_members {
+                return Err(RusticolError::artifact(format!(
+                    "eager invocation {index} selector domain does not equal its attachment union"
+                )));
+            }
+        }
+        for (attachment_index, attachment) in attachments[attachment_start..attachment_end]
+            .iter()
+            .enumerate()
+        {
+            let attachment_index = attachment_start + attachment_index;
+            let current = currents.get(
+                attachment.result_current_id,
+                "eager attachment result current",
+            )?;
+            if current.len
+                != usize::try_from(kernel.output_component_count).map_err(|_| {
+                    RusticolError::artifact("eager kernel output width does not fit usize")
+                })?
+            {
+                return Err(RusticolError::artifact(format!(
+                    "eager invocation kernel {} output width does not match current {}",
+                    kernel.kernel_id, attachment.result_current_id
+                )));
+            }
+            attached_currents.insert(attachment.result_current_id);
+            scheduled_attachments.push(ScheduledAttachment {
+                row: *attachment,
+                current,
+                selector_domain_id: selector_stage
+                    .map(|selector| selector.attachment_domains[attachment_index]),
+                initializes_current: false,
+            });
+        }
+        invocations.push(ScheduledInvocation {
+            row,
+            left_values,
+            right_values,
+            left_momenta,
+            right_momenta,
+            attachment_range: attachment_start..attachment_end,
+            selector_domain_id: selector_stage.map(|selector| selector.invocation_domains[index]),
+        });
+        attachment_cursor = attachment_end;
+    }
+    if attachment_cursor != attachments.len() {
+        return Err(RusticolError::artifact(
+            "eager invocation ranges do not cover the attachment table",
+        ));
+    }
+
+    let mut finalizations = Vec::new();
+    let mut finalization_copies = Vec::new();
+    let mut stage_current_ranges = BTreeMap::new();
+    let mut current_component_count = 0usize;
+    finalizations
+        .try_reserve_exact(finalization_rows.len())
+        .map_err(|error| {
+            RusticolError::artifact(format!("could not reserve eager finalizations: {error}"))
+        })?;
+    let mut finalized_currents = BTreeSet::new();
+    for (index, row) in finalization_rows.into_iter().enumerate() {
+        if !finalized_currents.insert(row.current_id) {
+            return Err(RusticolError::artifact(format!(
+                "eager current {} is finalized more than once in stage {}",
+                row.current_id, payload.stage_index
+            )));
+        }
+        if !globally_finalized_currents.insert(row.current_id) {
+            return Err(RusticolError::artifact(format!(
+                "eager current {} is finalized in more than one stage",
+                row.current_id
+            )));
+        }
+        if row.unpropagated_value_slot_id != MISSING_U32
+            && row.unpropagated_value_slot_id == row.propagated_value_slot_id
+        {
+            return Err(RusticolError::artifact(format!(
+                "eager finalization {index} aliases propagated and unpropagated outputs"
+            )));
+        }
+        for value_slot_id in [row.unpropagated_value_slot_id, row.propagated_value_slot_id] {
+            if value_slot_id != MISSING_U32 && !globally_stored_value_slots.insert(value_slot_id) {
+                return Err(RusticolError::artifact(format!(
+                    "eager value slot {value_slot_id} is written by more than one finalization"
+                )));
+            }
+        }
+        let current = currents.get(row.current_id, "eager finalization current")?;
+        let local_current = ComponentRange {
+            start: current_component_count,
+            len: current.len,
+        };
+        current_component_count = current_component_count
+            .checked_add(current.len)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "eager stage {} current workspace overflows usize",
+                    payload.stage_index
+                ))
+            })?;
+        stage_current_ranges.insert(row.current_id, local_current);
+        let unpropagated = optional_component_range(
+            values,
+            row.unpropagated_value_slot_id,
+            "eager unpropagated value",
+        )?;
+        let propagated = optional_component_range(
+            values,
+            row.propagated_value_slot_id,
+            "eager propagated value",
+        )?;
+        if unpropagated.is_none() && propagated.is_none() {
+            return Err(RusticolError::artifact(format!(
+                "eager finalization {index} stores no current value"
+            )));
+        }
+        for output in [unpropagated, propagated].into_iter().flatten() {
+            if output.len != current.len {
+                return Err(RusticolError::artifact(format!(
+                    "eager finalization {index} output width does not match current width"
+                )));
+            }
+        }
+        let momentum = momenta.get(row.momentum_slot_id, "eager finalization momentum")?;
+        if let Some(unpropagated) = unpropagated {
+            let selector_domain_id =
+                selector_stage.map(|selector| selector.unpropagated_finalization_domains[index]);
+            finalization_copies.push(FinalizationCopy {
+                current: local_current,
+                unpropagated,
+                selector_domain_id,
+            });
+        } else if let (Some(selector), Some(domains)) = (selector_stage, selector_plan)
+            && !domains.memberships[selector.unpropagated_finalization_domains[index] as usize]
+                .is_empty()
+        {
+            return Err(RusticolError::artifact(format!(
+                "missing eager unpropagated output {index} has a nonempty selector domain"
+            )));
+        }
+        if row.applies_kernel() {
+            let kernel = require_kernel(
+                kernels,
+                row.kernel_id,
+                EagerKernelRole::Finalization,
+                "finalization",
+            )?;
+            if propagated.is_none() {
+                return Err(RusticolError::artifact(format!(
+                    "eager finalization {index} applies a kernel without a propagated output"
+                )));
+            }
+            validate_kernel_inputs(
+                kernel,
+                KernelInputBounds {
+                    first_current: current.len,
+                    second_current: 0,
+                    first_momentum: momentum.len,
+                    second_momentum: 0,
+                    has_coupling: false,
+                    parameter_count,
+                },
+            )?;
+            if usize::try_from(kernel.output_component_count).ok() != Some(current.len) {
+                return Err(RusticolError::artifact(format!(
+                    "eager finalization kernel {} output width does not match current width",
+                    kernel.kernel_id
+                )));
+            }
+            finalizations.push(ScheduledFinalization {
+                row,
+                current: local_current,
+                propagated,
+                momentum,
+                selector_domain_id: selector_stage
+                    .map(|selector| selector.propagated_finalization_domains[index]),
+            });
+        } else if propagated.is_some() {
+            return Err(RusticolError::artifact(format!(
+                "eager finalization {index} has a propagated output but no kernel"
+            )));
+        } else if let (Some(selector), Some(domains)) = (selector_stage, selector_plan)
+            && !domains.memberships[selector.propagated_finalization_domains[index] as usize]
+                .is_empty()
+        {
+            return Err(RusticolError::artifact(format!(
+                "missing eager propagated output {index} has a nonempty selector domain"
+            )));
+        }
+    }
+    if !attached_currents.is_subset(&finalized_currents) {
+        let missing = attached_currents
+            .difference(&finalized_currents)
+            .next()
+            .copied()
+            .unwrap_or(MISSING_U32);
+        return Err(RusticolError::artifact(format!(
+            "eager stage {} does not finalize attached current {missing}",
+            payload.stage_index
+        )));
+    }
+    if !finalized_currents.is_subset(&attached_currents) {
+        let unwritten = finalized_currents
+            .difference(&attached_currents)
+            .next()
+            .copied()
+            .unwrap_or(MISSING_U32);
+        return Err(RusticolError::artifact(format!(
+            "eager stage {} finalizes unwritten current {unwritten}",
+            payload.stage_index
+        )));
+    }
+
+    for attachment in &mut scheduled_attachments {
+        attachment.current = *stage_current_ranges
+            .get(&attachment.row.result_current_id)
+            .ok_or_else(|| {
+                RusticolError::internal(format!(
+                    "eager stage {} lost current {} while compacting its workspace",
+                    payload.stage_index, attachment.row.result_current_id
+                ))
+            })?;
+    }
+
+    // Stable sorting makes equal-kernel rows contiguous for packetization while
+    // preserving artifact order, which defines deterministic lane ordering.
+    invocations.sort_by_key(|item| item.row.kernel_id);
+    finalizations.sort_by_key(|item| item.row.kernel_id);
+    let zero_current_ranges =
+        mark_initial_current_writes(&invocations, &mut scheduled_attachments, &finalizations);
+    Ok(EagerStagePlan {
+        stage_index: payload.stage_index,
+        current_component_count,
+        invocations,
+        attachments: scheduled_attachments,
+        finalization_copies,
+        finalizations,
+        zero_current_ranges,
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn load_closures(
+    rows: &[EagerClosureRow],
+    selector_domain_ids: Option<&[u32]>,
+    direct_specs: &[EagerDirectClosureSpec],
+    values: &ComponentLayout,
+    kernels: &BTreeMap<u32, EagerKernelSpec>,
+    coupling_count: usize,
+    amplitude_count: usize,
+    parameter_count: usize,
+) -> RusticolResult<(Vec<ScheduledClosure>, Vec<ScheduledDirectClosure>)> {
+    let mut direct_by_index = BTreeMap::new();
+    for spec in direct_specs {
+        let index = usize::try_from(spec.closure_index).map_err(|_| {
+            RusticolError::artifact("eager direct closure index does not fit usize")
+        })?;
+        if spec.coefficients.is_empty() {
+            return Err(RusticolError::artifact(format!(
+                "eager direct closure {index} has no coefficients"
+            )));
+        }
+        if spec
+            .coefficients
+            .iter()
+            .any(|coefficient| !complex_is_finite(*coefficient))
+        {
+            return Err(RusticolError::artifact(format!(
+                "eager direct closure {index} has a non-finite coefficient"
+            )));
+        }
+        if direct_by_index.insert(index, spec).is_some() {
+            return Err(RusticolError::artifact(format!(
+                "duplicate eager direct closure specification {index}"
+            )));
+        }
+    }
+
+    let mut closures = Vec::new();
+    let mut direct_closures = Vec::new();
+    for (index, row) in rows.iter().copied().enumerate() {
+        let left_values = values.get(row.left_value_slot_id, "eager closure left value")?;
+        let right_values = values.get(row.right_value_slot_id, "eager closure right value")?;
+        required_index(
+            row.amplitude_index,
+            amplitude_count,
+            "eager closure amplitude",
+        )?;
+        if row.kernel_id == MISSING_U32 {
+            if row.coupling_slot_id != MISSING_U32 {
+                return Err(RusticolError::artifact(format!(
+                    "eager direct closure {index} unexpectedly references a coupling"
+                )));
+            }
+            if row.output_factor_source != EAGER_OUTPUT_FACTOR_NONE {
+                return Err(RusticolError::artifact(format!(
+                    "eager direct closure {index} has a dynamic output factor"
+                )));
+            }
+            let spec = direct_by_index.remove(&index).ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "eager direct closure {index} lacks contraction coefficients"
+                ))
+            })?;
+            if left_values.len != right_values.len || left_values.len != spec.coefficients.len() {
+                return Err(RusticolError::artifact(format!(
+                    "eager direct closure {index} component widths do not match"
+                )));
+            }
+            direct_closures.push(ScheduledDirectClosure {
+                row,
+                left_values,
+                right_values,
+                coefficients: spec.coefficients.clone(),
+                selector_domain_id: selector_domain_ids.map(|domains| domains[index]),
+                initializes_amplitude: false,
+            });
+            continue;
+        }
+        if direct_by_index.contains_key(&index) {
+            return Err(RusticolError::artifact(format!(
+                "eager kernel closure {index} has direct-contraction metadata"
+            )));
+        }
+        let kernel = require_kernel(kernels, row.kernel_id, EagerKernelRole::Closure, "closure")?;
+        required_index(
+            row.coupling_slot_id,
+            coupling_count,
+            "eager closure coupling",
+        )?;
+        validate_kernel_inputs(
+            kernel,
+            KernelInputBounds {
+                first_current: left_values.len,
+                second_current: right_values.len,
+                first_momentum: 0,
+                second_momentum: 0,
+                has_coupling: true,
+                parameter_count,
+            },
+        )?;
+        if kernel.output_component_count != 1 {
+            return Err(RusticolError::artifact(format!(
+                "eager closure kernel {} must produce one component",
+                kernel.kernel_id
+            )));
+        }
+        closures.push(ScheduledClosure {
+            row,
+            left_values,
+            right_values,
+            selector_domain_id: selector_domain_ids.map(|domains| domains[index]),
+            initializes_amplitude: false,
+        });
+    }
+    if let Some(index) = direct_by_index.keys().next() {
+        return Err(RusticolError::artifact(format!(
+            "eager direct closure specification {index} has no matching row"
+        )));
+    }
+    // Keep the same stable equal-kernel ordering contract as stage invocations.
+    closures.sort_by_key(|item| item.row.kernel_id);
+    Ok((closures, direct_closures))
+}
+
+pub(super) fn mark_initial_current_writes(
+    invocations: &[ScheduledInvocation],
+    attachments: &mut [ScheduledAttachment],
+    finalizations: &[ScheduledFinalization],
+) -> Vec<ComponentRange> {
+    let mut written = BTreeSet::new();
+    for invocation in invocations {
+        for attachment in &mut attachments[invocation.attachment_range.clone()] {
+            attachment.initializes_current = written.insert(attachment.row.result_current_id);
+        }
+    }
+    finalizations
+        .iter()
+        .filter_map(|item| (!written.contains(&item.row.current_id)).then_some(item.current))
+        .collect()
+}
+
+pub(super) fn mark_initial_amplitude_writes(
+    closures: &mut [ScheduledClosure],
+    direct_closures: &mut [ScheduledDirectClosure],
+    amplitude_count: usize,
+) -> Vec<usize> {
+    let mut written = BTreeSet::new();
+    for closure in closures {
+        closure.initializes_amplitude = written.insert(closure.row.amplitude_index);
+    }
+    for closure in direct_closures {
+        closure.initializes_amplitude = written.insert(closure.row.amplitude_index);
+    }
+    (0..amplitude_count)
+        .filter(|index| !written.contains(&(*index as u32)))
+        .collect()
+}
+
+fn validate_reduction_plan(
+    groups: &[EagerReductionGroup],
+    entries: &[EagerReductionEntry],
+    amplitude_count: usize,
+) -> RusticolResult<()> {
+    if groups.is_empty() || entries.is_empty() {
+        return Err(RusticolError::artifact(
+            "eager reduction requires nonempty groups and entries",
+        ));
+    }
+    let mut covered = BTreeSet::new();
+    let mut coherent_group_ids = BTreeSet::new();
+    for (group_index, group) in groups.iter().enumerate() {
+        if !coherent_group_ids.insert(group.coherent_group_id) {
+            return Err(RusticolError::artifact(format!(
+                "eager coherent reduction-group ID {} is duplicated",
+                group.coherent_group_id
+            )));
+        }
+        if group.amplitude_indices.is_empty() {
+            return Err(RusticolError::artifact(format!(
+                "eager reduction group {group_index} is empty"
+            )));
+        }
+        for amplitude_index in &group.amplitude_indices {
+            required_index(
+                *amplitude_index,
+                amplitude_count,
+                "eager reduction amplitude",
+            )?;
+            if !covered.insert(*amplitude_index) {
+                return Err(RusticolError::artifact(format!(
+                    "eager amplitude {amplitude_index} belongs to more than one reduction group"
+                )));
+            }
+        }
+    }
+    if covered.len() != amplitude_count {
+        return Err(RusticolError::artifact(format!(
+            "eager reduction groups cover {} of {amplitude_count} amplitudes",
+            covered.len()
+        )));
+    }
+    for (index, entry) in entries.iter().enumerate() {
+        required_index(
+            entry.left_group_index,
+            groups.len(),
+            "eager reduction left group",
+        )?;
+        required_index(
+            entry.right_group_index,
+            groups.len(),
+            "eager reduction right group",
+        )?;
+        if !complex_is_finite(entry.coefficient) {
+            return Err(RusticolError::artifact(format!(
+                "eager reduction entry {index} has a non-finite coefficient"
+            )));
+        }
+    }
+    Ok(())
+}
+
+#[derive(Clone, Copy)]
+struct KernelInputBounds {
+    first_current: usize,
+    second_current: usize,
+    first_momentum: usize,
+    second_momentum: usize,
+    has_coupling: bool,
+    parameter_count: usize,
+}
+
+fn validate_kernel_inputs(
+    kernel: &EagerKernelSpec,
+    bounds: KernelInputBounds,
+) -> RusticolResult<()> {
+    for input in &kernel.inputs {
+        let (allowed, index, count) = match *input {
+            EagerKernelInput::FirstCurrentComponent(index) => {
+                (true, Some(index), bounds.first_current)
+            }
+            EagerKernelInput::SecondCurrentComponent(index) => (
+                kernel.role != EagerKernelRole::Finalization,
+                Some(index),
+                bounds.second_current,
+            ),
+            EagerKernelInput::FirstMomentumComponent(index) => (
+                kernel.role != EagerKernelRole::Closure,
+                Some(index),
+                bounds.first_momentum,
+            ),
+            EagerKernelInput::SecondMomentumComponent(index) => (
+                kernel.role == EagerKernelRole::Vertex,
+                Some(index),
+                bounds.second_momentum,
+            ),
+            EagerKernelInput::CouplingReal | EagerKernelInput::CouplingImag => {
+                (bounds.has_coupling, None, 0)
+            }
+            EagerKernelInput::ModelParameter(index) => (true, Some(index), bounds.parameter_count),
+        };
+        if !allowed {
+            return Err(RusticolError::artifact(format!(
+                "eager {:?} kernel {} cannot use input descriptor {input:?}",
+                kernel.role, kernel.kernel_id
+            )));
+        }
+        if let Some(index) = index {
+            let index = usize::try_from(index).map_err(|_| {
+                RusticolError::artifact(format!(
+                    "eager kernel {} input descriptor {input:?} does not fit usize",
+                    kernel.kernel_id
+                ))
+            })?;
+            if index >= count {
+                return Err(RusticolError::artifact(format!(
+                    "eager kernel {} input descriptor {input:?} is outside 0..{count}",
+                    kernel.kernel_id
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn require_kernel<'a>(
+    kernels: &'a BTreeMap<u32, EagerKernelSpec>,
+    kernel_id: u32,
+    role: EagerKernelRole,
+    context: &str,
+) -> RusticolResult<&'a EagerKernelSpec> {
+    let kernel = kernels.get(&kernel_id).ok_or_else(|| {
+        RusticolError::artifact(format!(
+            "eager {context} references unknown kernel {kernel_id}"
+        ))
+    })?;
+    if kernel.role != role {
+        return Err(RusticolError::artifact(format!(
+            "eager {context} kernel {kernel_id} has role {:?}, expected {role:?}",
+            kernel.role
+        )));
+    }
+    Ok(kernel)
+}
+
+fn optional_component_range(
+    layout: &ComponentLayout,
+    id: u32,
+    context: &str,
+) -> RusticolResult<Option<ComponentRange>> {
+    if id == MISSING_U32 {
+        return Ok(None);
+    }
+    layout.get(id, context).map(Some)
+}
+
+fn validate_optional_index(id: u32, count: usize, context: &str) -> RusticolResult<()> {
+    if id == MISSING_U32 {
+        return Ok(());
+    }
+    required_index(id, count, context).map(|_| ())
+}
+
+fn required_index(id: u32, count: usize, context: &str) -> RusticolResult<usize> {
+    if id == MISSING_U32 {
+        return Err(RusticolError::artifact(format!(
+            "{context} uses the reserved missing id"
+        )));
+    }
+    let index = usize::try_from(id)
+        .map_err(|_| RusticolError::artifact(format!("{context} id does not fit usize")))?;
+    if index >= count {
+        return Err(RusticolError::artifact(format!(
+            "{context} index {index} is outside 0..{count}"
+        )));
+    }
+    Ok(index)
+}
+
+pub(super) fn complex_is_finite(value: EagerComplex64) -> bool {
+    value.re.is_finite() && value.im.is_finite()
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/plan_v3.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/plan_v3.rs
new file mode 100644
index 0000000000..5d98ea5c87
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/plan_v3.rs
@@ -0,0 +1,1794 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Direct plan-v3 fixed-row adapter for the eager f64 runtime.
+//!
+//! This module intentionally depends only on the public plan-v3 row model. It
+//! does not depend on PACBIN, manifests, engine loader types, JSON, or encoded
+//! plan-v2 tables.
+
+use super::plan::{
+    ComponentLayout, ComponentRange, EagerStagePlan, FinalizationCopy, ScheduledAttachment,
+    ScheduledClosure, ScheduledDirectClosure, ScheduledFinalization, ScheduledInvocation,
+    SelectorDomainPlan, mark_initial_amplitude_writes, mark_initial_current_writes,
+};
+use super::{
+    EAGER_INDEPENDENT_BLOCK_SIZE, EagerComplex64, EagerExecutionPlan, EagerKernelInput,
+    EagerKernelRole, EagerKernelSpec, EagerReductionEntry, EagerReductionGroup,
+};
+use crate::{
+    EAGER_OUTPUT_FACTOR_NONE, EagerAttachmentRow, EagerClosureRow, EagerCouplingRow,
+    EagerFinalizationRow, EagerInvocationRow, EagerPlanAttachmentRow, EagerPlanClosureRow,
+    EagerPlanCouplingRow, EagerPlanCurrentRow, EagerPlanDirectCoefficientRow,
+    EagerPlanExactFactorRow, EagerPlanFinalizationRow, EagerPlanInvocationRow,
+    EagerPlanMomentumRow, EagerPlanParameterRow, EagerPlanReductionEntryKind,
+    EagerPlanReductionEntryRow, EagerPlanReductionGroupRow, EagerPlanSelectorDomainRow,
+    EagerPlanStageRow, EagerPlanValueRow, EagerValueSlotKind, MISSING_U32, RusticolError,
+    RusticolResult,
+};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::fmt;
+
+/// Borrowed execution-relevant sections of a plan-v3 artifact.
+///
+/// Catalogs used only for source filling, public selector aliases, inspection,
+/// or exact provenance are deliberately absent. `exact_factors` retains the
+/// bit-exact binary64 values needed to materialize final f64 runtime factors.
+#[derive(Clone, Copy, Debug)]
+pub struct EagerPlanV3Sections<'a> {
+    pub kernels: &'a [EagerKernelSpec],
+    /// Final prepared-pack evaluator parameter width after runtime projection
+    /// and synthetic coupling-slot insertion.
+    pub prepared_parameter_count: u32,
+    pub currents: &'a [EagerPlanCurrentRow],
+    pub values: &'a [EagerPlanValueRow],
+    pub momenta: &'a [EagerPlanMomentumRow],
+    pub parameters: &'a [EagerPlanParameterRow],
+    pub stages: &'a [EagerPlanStageRow],
+    pub couplings: &'a [EagerPlanCouplingRow],
+    pub invocations: &'a [EagerPlanInvocationRow],
+    pub attachments: &'a [EagerPlanAttachmentRow],
+    pub finalizations: &'a [EagerPlanFinalizationRow],
+    pub closures: &'a [EagerPlanClosureRow],
+    pub direct_coefficients: &'a [EagerPlanDirectCoefficientRow],
+    pub selector_domains: &'a [EagerPlanSelectorDomainRow],
+    pub selector_memberships: &'a [u32],
+    pub reduction_groups: &'a [EagerPlanReductionGroupRow],
+    pub reduction_entries: &'a [EagerPlanReductionEntryRow],
+    pub exact_factors: &'a [EagerPlanExactFactorRow],
+    pub color_contraction_entry_start: u64,
+    pub color_contraction_entry_count: u64,
+}
+
+impl EagerPlanV3Sections<'_> {
+    pub fn to_owned(self) -> EagerOwnedPlanV3Sections {
+        EagerOwnedPlanV3Sections {
+            kernels: self.kernels.to_vec(),
+            prepared_parameter_count: self.prepared_parameter_count,
+            currents: self.currents.to_vec(),
+            values: self.values.to_vec(),
+            momenta: self.momenta.to_vec(),
+            parameters: self.parameters.to_vec(),
+            stages: self.stages.to_vec(),
+            couplings: self.couplings.to_vec(),
+            invocations: self.invocations.to_vec(),
+            attachments: self.attachments.to_vec(),
+            finalizations: self.finalizations.to_vec(),
+            closures: self.closures.to_vec(),
+            direct_coefficients: self.direct_coefficients.to_vec(),
+            selector_domains: self.selector_domains.to_vec(),
+            selector_memberships: self.selector_memberships.to_vec(),
+            reduction_groups: self.reduction_groups.to_vec(),
+            reduction_entries: self.reduction_entries.to_vec(),
+            exact_factors: self.exact_factors.to_vec(),
+            color_contraction_entry_start: self.color_contraction_entry_start,
+            color_contraction_entry_count: self.color_contraction_entry_count,
+        }
+    }
+}
+
+/// Owned counterpart of [`EagerPlanV3Sections`].
+#[derive(Clone, Debug, PartialEq)]
+pub struct EagerOwnedPlanV3Sections {
+    pub kernels: Vec<EagerKernelSpec>,
+    pub prepared_parameter_count: u32,
+    pub currents: Vec<EagerPlanCurrentRow>,
+    pub values: Vec<EagerPlanValueRow>,
+    pub momenta: Vec<EagerPlanMomentumRow>,
+    pub parameters: Vec<EagerPlanParameterRow>,
+    pub stages: Vec<EagerPlanStageRow>,
+    pub couplings: Vec<EagerPlanCouplingRow>,
+    pub invocations: Vec<EagerPlanInvocationRow>,
+    pub attachments: Vec<EagerPlanAttachmentRow>,
+    pub finalizations: Vec<EagerPlanFinalizationRow>,
+    pub closures: Vec<EagerPlanClosureRow>,
+    pub direct_coefficients: Vec<EagerPlanDirectCoefficientRow>,
+    pub selector_domains: Vec<EagerPlanSelectorDomainRow>,
+    pub selector_memberships: Vec<u32>,
+    pub reduction_groups: Vec<EagerPlanReductionGroupRow>,
+    pub reduction_entries: Vec<EagerPlanReductionEntryRow>,
+    pub exact_factors: Vec<EagerPlanExactFactorRow>,
+    pub color_contraction_entry_start: u64,
+    pub color_contraction_entry_count: u64,
+}
+
+impl EagerOwnedPlanV3Sections {
+    pub fn as_borrowed(&self) -> EagerPlanV3Sections<'_> {
+        EagerPlanV3Sections {
+            kernels: &self.kernels,
+            prepared_parameter_count: self.prepared_parameter_count,
+            currents: &self.currents,
+            values: &self.values,
+            momenta: &self.momenta,
+            parameters: &self.parameters,
+            stages: &self.stages,
+            couplings: &self.couplings,
+            invocations: &self.invocations,
+            attachments: &self.attachments,
+            finalizations: &self.finalizations,
+            closures: &self.closures,
+            direct_coefficients: &self.direct_coefficients,
+            selector_domains: &self.selector_domains,
+            selector_memberships: &self.selector_memberships,
+            reduction_groups: &self.reduction_groups,
+            reduction_entries: &self.reduction_entries,
+            exact_factors: &self.exact_factors,
+            color_contraction_entry_start: self.color_contraction_entry_start,
+            color_contraction_entry_count: self.color_contraction_entry_count,
+        }
+    }
+
+    pub fn into_execution_plan(self) -> RusticolResult<EagerExecutionPlan> {
+        EagerExecutionPlan::from_plan_v3_sections(self.as_borrowed())
+    }
+}
+
+impl EagerExecutionPlan {
+    /// Validate plan-v3 fixed rows and materialize final eager f64 semantics.
+    pub fn from_plan_v3_sections(input: EagerPlanV3Sections<'_>) -> RusticolResult<Self> {
+        PlanBuilder::new(input)?.build()
+    }
+}
+
+struct PlanBuilder<'a> {
+    input: EagerPlanV3Sections<'a>,
+    values: ComponentLayout,
+    momenta: ComponentLayout,
+    currents: ComponentLayout,
+    factors: Vec<EagerComplex64>,
+    kernels: BTreeMap<u32, EagerKernelSpec>,
+    parameter_count: usize,
+    amplitude_count: usize,
+    selector_plan: SelectorDomainPlan,
+}
+
+impl<'a> PlanBuilder<'a> {
+    fn new(input: EagerPlanV3Sections<'a>) -> RusticolResult<Self> {
+        let current_counts = validate_current_layout(input.currents)?;
+        let value_counts = validate_value_layout(input.values, input.currents)?;
+        let momentum_counts = validate_momentum_layout(input.momenta)?;
+        validate_dense_ids(
+            input.parameters.iter().map(|row| row.parameter_id),
+            "eager plan-v3 parameter",
+        )?;
+        let parameter_count = usize::try_from(input.prepared_parameter_count)
+            .map_err(|_| artifact("eager prepared parameter count does not fit usize"))?;
+        let factors = load_factors(input.exact_factors)?;
+        let kernels = validate_kernel_specs(input.kernels, parameter_count)?;
+        let amplitude_count = validate_amplitude_layout(input.closures)?;
+        let selector_plan = load_selector_plan(
+            input.selector_domains,
+            input.selector_memberships,
+            input.reduction_groups,
+        )?;
+        Ok(Self {
+            input,
+            values: ComponentLayout::new("value", &value_counts)?,
+            momenta: ComponentLayout::new("momentum", &momentum_counts)?,
+            currents: ComponentLayout::new("current", &current_counts)?,
+            factors,
+            kernels,
+            parameter_count,
+            amplitude_count,
+            selector_plan,
+        })
+    }
+
+    fn build(self) -> RusticolResult<EagerExecutionPlan> {
+        let couplings = self.load_couplings()?;
+        let (reduction_groups, reduction_entries) = self.load_reductions()?;
+        self.validate_selector_dependency_proof(&reduction_groups)?;
+        let (stages, stored_value_slots) = self.load_stages(couplings.len())?;
+        let (mut closures, mut direct_closures) = self.load_closures(couplings.len())?;
+
+        let mut initial_value_ranges = Vec::new();
+        for slot_id in 0..self.input.values.len() {
+            let slot_id = usize_u32(slot_id, "eager value slot")?;
+            if !stored_value_slots[slot_id as usize] {
+                initial_value_ranges.push(self.values.get(slot_id, "eager initial value")?);
+            }
+        }
+        let zero_amplitude_indices = mark_initial_amplitude_writes(
+            &mut closures,
+            &mut direct_closures,
+            self.amplitude_count,
+        );
+
+        Ok(EagerExecutionPlan {
+            values: self.values,
+            momenta: self.momenta,
+            currents: self.currents,
+            parameter_count: self.parameter_count,
+            amplitude_count: self.amplitude_count,
+            kernels: self.kernels,
+            couplings,
+            stages,
+            closures,
+            direct_closures,
+            reduction_groups,
+            reduction_entries,
+            selector_domains: Some(self.selector_plan),
+            initial_value_ranges,
+            zero_amplitude_indices,
+        })
+    }
+
+    fn load_couplings(&self) -> RusticolResult<Vec<EagerCouplingRow>> {
+        validate_dense_ids(
+            self.input.couplings.iter().map(|row| row.coupling_id),
+            "eager plan-v3 coupling",
+        )?;
+        self.input
+            .couplings
+            .iter()
+            .enumerate()
+            .map(|(index, row)| {
+                validate_optional_index(
+                    row.real_parameter_id,
+                    self.parameter_count,
+                    &format!("eager coupling {index} real parameter"),
+                )?;
+                validate_optional_index(
+                    row.imaginary_parameter_id,
+                    self.parameter_count,
+                    &format!("eager coupling {index} imaginary parameter"),
+                )?;
+                let constant = self.factor(row.constant_factor_id, "eager coupling constant")?;
+                Ok(EagerCouplingRow {
+                    real_parameter_id: row.real_parameter_id,
+                    imag_parameter_id: row.imaginary_parameter_id,
+                    constant_real: constant.re,
+                    constant_imag: constant.im,
+                })
+            })
+            .collect()
+    }
+
+    fn load_stages(
+        &self,
+        coupling_count: usize,
+    ) -> RusticolResult<(Vec<EagerStagePlan>, Vec<bool>)> {
+        validate_stage_ranges(
+            self.input.stages,
+            self.input.invocations.len(),
+            self.input.attachments.len(),
+            self.input.finalizations.len(),
+        )?;
+        let mut stages = Vec::with_capacity(self.input.stages.len());
+        let mut finalized_currents = vec![false; self.input.currents.len()];
+        let mut stored_value_slots = vec![false; self.input.values.len()];
+        let mut previous_stage = None;
+        for stage in self.input.stages {
+            if previous_stage.is_some_and(|previous| stage.stage_index <= previous) {
+                return Err(artifact("eager stage indices must be strictly increasing"));
+            }
+            previous_stage = Some(stage.stage_index);
+            stages.push(self.load_stage(
+                stage,
+                coupling_count,
+                &mut finalized_currents,
+                &mut stored_value_slots,
+            )?);
+        }
+        Ok((stages, stored_value_slots))
+    }
+
+    fn load_stage(
+        &self,
+        stage: &EagerPlanStageRow,
+        coupling_count: usize,
+        globally_finalized_currents: &mut [bool],
+        globally_stored_value_slots: &mut [bool],
+    ) -> RusticolResult<EagerStagePlan> {
+        let invocation_range = checked_range(
+            self.input.invocations,
+            stage.invocation_start,
+            stage.invocation_count,
+            "eager stage invocations",
+        )?;
+        let attachment_range = checked_range(
+            self.input.attachments,
+            stage.attachment_start,
+            stage.attachment_count,
+            "eager stage attachments",
+        )?;
+        let finalization_range = checked_range(
+            self.input.finalizations,
+            stage.finalization_start,
+            stage.finalization_count,
+            "eager stage finalizations",
+        )?;
+        let stage_attachment_start = usize_count(stage.attachment_start, "attachment start")?;
+
+        let mut invocations = Vec::with_capacity(invocation_range.len());
+        let mut attachments = Vec::with_capacity(attachment_range.len());
+        let mut attached_currents = vec![false; self.input.currents.len()];
+        let mut attachment_cursor = stage_attachment_start;
+        for (index, row) in invocation_range.iter().enumerate() {
+            let kernel = require_kernel(
+                &self.kernels,
+                row.kernel_id,
+                EagerKernelRole::Vertex,
+                "invocation",
+            )?;
+            let left_values = self
+                .values
+                .get(row.left_value_slot_id, "eager invocation left value")?;
+            let right_values = self
+                .values
+                .get(row.right_value_slot_id, "eager invocation right value")?;
+            let left_momenta = self
+                .momenta
+                .get(row.left_momentum_slot_id, "eager invocation left momentum")?;
+            let right_momenta = self.momenta.get(
+                row.right_momentum_slot_id,
+                "eager invocation right momentum",
+            )?;
+            required_index(
+                row.coupling_slot_id,
+                coupling_count,
+                "eager invocation coupling",
+            )?;
+            let output_factor_source = validate_output_factor(
+                row.output_factor_source,
+                row.coupling_slot_id,
+                "eager invocation",
+            )?;
+            validate_kernel_inputs(
+                kernel,
+                KernelInputBounds {
+                    first_current: left_values.len,
+                    second_current: right_values.len,
+                    first_momentum: left_momenta.len,
+                    second_momentum: right_momenta.len,
+                    has_coupling: true,
+                    parameter_count: self.parameter_count,
+                },
+            )?;
+            let global_start = usize_count(row.attachment_start, "invocation attachment start")?;
+            let count = usize_count(row.attachment_count, "invocation attachment count")?;
+            if count == 0 || global_start != attachment_cursor {
+                return Err(artifact(format!(
+                    "eager invocation {index} has an empty or noncontiguous attachment range"
+                )));
+            }
+            let global_stop = global_start
+                .checked_add(count)
+                .ok_or_else(|| artifact("eager invocation attachment range overflows usize"))?;
+            let stage_stop = stage_attachment_start
+                .checked_add(attachment_range.len())
+                .ok_or_else(|| artifact("eager stage attachment range overflows usize"))?;
+            if global_stop > stage_stop {
+                return Err(artifact(format!(
+                    "eager invocation {index} attachment range exceeds its stage"
+                )));
+            }
+            let local_start = global_start - stage_attachment_start;
+            let local_stop = global_stop - stage_attachment_start;
+            self.validate_domain_id(row.selector_domain_id, "eager invocation selector")?;
+            for (offset, attachment) in attachment_range[local_start..local_stop].iter().enumerate()
+            {
+                let current = self.currents.get(
+                    attachment.result_current_id,
+                    "eager attachment result current",
+                )?;
+                if usize::try_from(kernel.output_component_count).ok() != Some(current.len) {
+                    return Err(artifact(format!(
+                        "eager invocation kernel {} output width does not match current {}",
+                        kernel.kernel_id, attachment.result_current_id
+                    )));
+                }
+                let factor = self.attachment_factor(attachment)?;
+                self.validate_domain_id(
+                    attachment.selector_domain_id,
+                    "eager attachment selector",
+                )?;
+                attached_currents[attachment.result_current_id as usize] = true;
+                attachments.push(ScheduledAttachment {
+                    row: EagerAttachmentRow {
+                        result_current_id: attachment.result_current_id,
+                        factor_real: factor.re,
+                        factor_imag: factor.im,
+                    },
+                    current,
+                    selector_domain_id: Some(attachment.selector_domain_id),
+                    initializes_current: false,
+                });
+                let expected_position = local_start + offset;
+                if attachments.len() != expected_position + 1 {
+                    return Err(artifact("eager attachment ranges overlap"));
+                }
+            }
+            invocations.push(ScheduledInvocation {
+                row: EagerInvocationRow {
+                    kernel_id: row.kernel_id,
+                    left_value_slot_id: row.left_value_slot_id,
+                    right_value_slot_id: row.right_value_slot_id,
+                    left_momentum_slot_id: row.left_momentum_slot_id,
+                    right_momentum_slot_id: row.right_momentum_slot_id,
+                    coupling_slot_id: row.coupling_slot_id,
+                    output_factor_source,
+                    attachment_start: local_start as u64,
+                    attachment_count: count as u64,
+                },
+                left_values,
+                right_values,
+                left_momenta,
+                right_momenta,
+                attachment_range: local_start..local_stop,
+                selector_domain_id: Some(row.selector_domain_id),
+            });
+            attachment_cursor = global_stop;
+        }
+        if attachments.len() != attachment_range.len() {
+            return Err(artifact(
+                "eager invocation ranges do not cover the stage attachment table",
+            ));
+        }
+
+        let mut finalizations = Vec::new();
+        let mut finalization_copies = Vec::new();
+        let mut stage_current_ranges = vec![None; self.input.currents.len()];
+        let mut current_component_count = 0usize;
+        let mut stage_finalized_currents = vec![false; self.input.currents.len()];
+        for (index, row) in finalization_range.iter().enumerate() {
+            let current_index = required_index(
+                row.current_id,
+                self.input.currents.len(),
+                "eager finalization current",
+            )?;
+            if std::mem::replace(&mut stage_finalized_currents[current_index], true)
+                || std::mem::replace(&mut globally_finalized_currents[current_index], true)
+            {
+                return Err(artifact(format!(
+                    "eager current {} is finalized more than once",
+                    row.current_id
+                )));
+            }
+            if row.unpropagated_value_slot_id != MISSING_U32
+                && row.unpropagated_value_slot_id == row.propagated_value_slot_id
+            {
+                return Err(artifact(format!(
+                    "eager finalization {index} aliases its outputs"
+                )));
+            }
+            for value_slot_id in [row.unpropagated_value_slot_id, row.propagated_value_slot_id] {
+                if value_slot_id != MISSING_U32 {
+                    let value_index = required_index(
+                        value_slot_id,
+                        self.input.values.len(),
+                        "eager finalization value",
+                    )?;
+                    if std::mem::replace(&mut globally_stored_value_slots[value_index], true) {
+                        return Err(artifact(format!(
+                            "eager value slot {value_slot_id} is stored more than once"
+                        )));
+                    }
+                }
+            }
+            let global_current = self
+                .currents
+                .get(row.current_id, "eager finalization current")?;
+            let local_current = ComponentRange {
+                start: current_component_count,
+                len: global_current.len,
+            };
+            current_component_count = current_component_count
+                .checked_add(global_current.len)
+                .ok_or_else(|| artifact("eager stage current workspace overflows usize"))?;
+            stage_current_ranges[current_index] = Some(local_current);
+            let unpropagated = self.optional_value(
+                row.unpropagated_value_slot_id,
+                EagerValueSlotKind::Unpropagated,
+                "eager unpropagated finalization value",
+            )?;
+            let propagated = self.optional_value(
+                row.propagated_value_slot_id,
+                EagerValueSlotKind::Propagated,
+                "eager propagated finalization value",
+            )?;
+            if unpropagated.is_none() && propagated.is_none() {
+                return Err(artifact(format!(
+                    "eager finalization {index} stores no current value"
+                )));
+            }
+            for output in [unpropagated, propagated].into_iter().flatten() {
+                if output.len != local_current.len {
+                    return Err(artifact(format!(
+                        "eager finalization {index} output width does not match current width"
+                    )));
+                }
+            }
+            let momentum = self
+                .momenta
+                .get(row.momentum_slot_id, "eager finalization momentum")?;
+            self.validate_domain_id(
+                row.unpropagated_selector_domain_id,
+                "eager unpropagated finalization selector",
+            )?;
+            self.validate_domain_id(
+                row.propagated_selector_domain_id,
+                "eager propagated finalization selector",
+            )?;
+            if let Some(unpropagated) = unpropagated {
+                finalization_copies.push(FinalizationCopy {
+                    current: local_current,
+                    unpropagated,
+                    selector_domain_id: Some(row.unpropagated_selector_domain_id),
+                });
+            } else {
+                self.require_empty_domain(
+                    row.unpropagated_selector_domain_id,
+                    "missing eager unpropagated output",
+                )?;
+            }
+            if row.kernel_id == MISSING_U32 {
+                if propagated.is_some() {
+                    return Err(artifact(format!(
+                        "eager finalization {index} has a propagated output but no kernel"
+                    )));
+                }
+                self.require_empty_domain(
+                    row.propagated_selector_domain_id,
+                    "missing eager propagated output",
+                )?;
+            } else {
+                let kernel = require_kernel(
+                    &self.kernels,
+                    row.kernel_id,
+                    EagerKernelRole::Finalization,
+                    "finalization",
+                )?;
+                if propagated.is_none() {
+                    return Err(artifact(format!(
+                        "eager finalization {index} applies a kernel without an output"
+                    )));
+                }
+                validate_kernel_inputs(
+                    kernel,
+                    KernelInputBounds {
+                        first_current: local_current.len,
+                        second_current: 0,
+                        first_momentum: momentum.len,
+                        second_momentum: 0,
+                        has_coupling: false,
+                        parameter_count: self.parameter_count,
+                    },
+                )?;
+                if usize::try_from(kernel.output_component_count).ok() != Some(local_current.len) {
+                    return Err(artifact(format!(
+                        "eager finalization kernel {} output width does not match current width",
+                        kernel.kernel_id
+                    )));
+                }
+                finalizations.push(ScheduledFinalization {
+                    row: EagerFinalizationRow {
+                        kernel_id: row.kernel_id,
+                        current_id: row.current_id,
+                        unpropagated_value_slot_id: row.unpropagated_value_slot_id,
+                        propagated_value_slot_id: row.propagated_value_slot_id,
+                        momentum_slot_id: row.momentum_slot_id,
+                    },
+                    current: local_current,
+                    propagated,
+                    momentum,
+                    selector_domain_id: Some(row.propagated_selector_domain_id),
+                });
+            }
+        }
+        if attached_currents != stage_finalized_currents {
+            return Err(artifact(format!(
+                "eager stage {} attached and finalized current sets differ",
+                stage.stage_index
+            )));
+        }
+        for attachment in &mut attachments {
+            attachment.current = stage_current_ranges
+                .get(attachment.row.result_current_id as usize)
+                .and_then(|range| *range)
+                .ok_or_else(|| artifact("eager attachment has no stage-local current"))?;
+        }
+        invocations.sort_by_key(|item| item.row.kernel_id);
+        finalizations.sort_by_key(|item| item.row.kernel_id);
+        let zero_current_ranges =
+            mark_initial_current_writes(&invocations, &mut attachments, &finalizations);
+        Ok(EagerStagePlan {
+            stage_index: stage.stage_index,
+            current_component_count,
+            invocations,
+            attachments,
+            finalization_copies,
+            finalizations,
+            zero_current_ranges,
+        })
+    }
+
+    fn load_closures(
+        &self,
+        coupling_count: usize,
+    ) -> RusticolResult<(Vec<ScheduledClosure>, Vec<ScheduledDirectClosure>)> {
+        let mut closures = Vec::new();
+        let mut direct_closures = Vec::new();
+        for (index, row) in self.input.closures.iter().enumerate() {
+            let left_values = self
+                .values
+                .get(row.left_value_slot_id, "eager closure left value")?;
+            let right_values = self
+                .values
+                .get(row.right_value_slot_id, "eager closure right value")?;
+            required_index(
+                row.amplitude_index,
+                self.amplitude_count,
+                "eager closure amplitude",
+            )?;
+            self.validate_domain_id(row.selector_domain_id, "eager closure selector")?;
+            let color = self.factor(row.color_factor_id, "eager closure color factor")?;
+            self.factor(row.coupling_factor_id, "eager closure coupling factor")?;
+            self.factor(
+                row.normalization_factor_id,
+                "eager closure normalization factor",
+            )?;
+            let direct = checked_range(
+                self.input.direct_coefficients,
+                row.direct_coefficient_start,
+                row.direct_coefficient_count,
+                "eager direct closure coefficients",
+            )?;
+            if row.kernel_id == MISSING_U32 {
+                if row.coupling_slot_id != MISSING_U32
+                    || row.output_factor_source != EAGER_OUTPUT_FACTOR_NONE as u8
+                    || direct.is_empty()
+                {
+                    return Err(artifact(format!(
+                        "eager direct closure {index} has inconsistent kernel metadata"
+                    )));
+                }
+                if left_values.len != right_values.len || left_values.len != direct.len() {
+                    return Err(artifact(format!(
+                        "eager direct closure {index} component widths do not match"
+                    )));
+                }
+                let mut coefficients = Vec::with_capacity(direct.len());
+                for (component, coefficient) in direct.iter().enumerate() {
+                    if usize::try_from(coefficient.component_index).ok() != Some(component) {
+                        return Err(artifact(format!(
+                            "eager direct closure {index} coefficients are not component ordered"
+                        )));
+                    }
+                    coefficients.push(
+                        self.factor(coefficient.factor_id, "eager direct closure coefficient")?,
+                    );
+                }
+                direct_closures.push(ScheduledDirectClosure {
+                    row: EagerClosureRow {
+                        kernel_id: MISSING_U32,
+                        left_value_slot_id: row.left_value_slot_id,
+                        right_value_slot_id: row.right_value_slot_id,
+                        amplitude_index: row.amplitude_index,
+                        coupling_slot_id: MISSING_U32,
+                        output_factor_source: EAGER_OUTPUT_FACTOR_NONE,
+                        factor_real: color.re,
+                        factor_imag: color.im,
+                    },
+                    left_values,
+                    right_values,
+                    coefficients,
+                    selector_domain_id: Some(row.selector_domain_id),
+                    initializes_amplitude: false,
+                });
+                continue;
+            }
+            if !direct.is_empty() {
+                return Err(artifact(format!(
+                    "eager kernel closure {index} also has direct coefficients"
+                )));
+            }
+            let kernel = require_kernel(
+                &self.kernels,
+                row.kernel_id,
+                EagerKernelRole::Closure,
+                "closure",
+            )?;
+            required_index(
+                row.coupling_slot_id,
+                coupling_count,
+                "eager closure coupling",
+            )?;
+            self.validate_coupling_factor(row)?;
+            let output_factor_source = validate_output_factor(
+                row.output_factor_source,
+                row.coupling_slot_id,
+                "eager closure",
+            )?;
+            validate_kernel_inputs(
+                kernel,
+                KernelInputBounds {
+                    first_current: left_values.len,
+                    second_current: right_values.len,
+                    first_momentum: 0,
+                    second_momentum: 0,
+                    has_coupling: true,
+                    parameter_count: self.parameter_count,
+                },
+            )?;
+            if kernel.output_component_count != 1 {
+                return Err(artifact(format!(
+                    "eager closure kernel {} must produce one component",
+                    kernel.kernel_id
+                )));
+            }
+            // plan-v2 lowering multiplies color by prepared-kernel normalization.
+            let factor = color
+                * self.factor(
+                    row.normalization_factor_id,
+                    "eager closure normalization factor",
+                )?;
+            require_finite(factor, "eager closure combined factor")?;
+            closures.push(ScheduledClosure {
+                row: EagerClosureRow {
+                    kernel_id: row.kernel_id,
+                    left_value_slot_id: row.left_value_slot_id,
+                    right_value_slot_id: row.right_value_slot_id,
+                    amplitude_index: row.amplitude_index,
+                    coupling_slot_id: row.coupling_slot_id,
+                    output_factor_source,
+                    factor_real: factor.re,
+                    factor_imag: factor.im,
+                },
+                left_values,
+                right_values,
+                selector_domain_id: Some(row.selector_domain_id),
+                initializes_amplitude: false,
+            });
+        }
+        closures.sort_by_key(|item| item.row.kernel_id);
+        Ok((closures, direct_closures))
+    }
+
+    fn load_reductions(
+        &self,
+    ) -> RusticolResult<(Vec<EagerReductionGroup>, Vec<EagerReductionEntry>)> {
+        if self.input.reduction_groups.is_empty() {
+            return Err(artifact("eager reduction requires nonempty groups"));
+        }
+        let mut group_index_by_id = HashMap::with_capacity(self.input.reduction_groups.len());
+        let mut covered_entries = vec![false; self.input.reduction_entries.len()];
+        let mut covered_amplitudes = vec![false; self.amplitude_count];
+        let mut covered_amplitude_count = 0usize;
+        let mut groups = Vec::with_capacity(self.input.reduction_groups.len());
+        for (group_index, group) in self.input.reduction_groups.iter().enumerate() {
+            if group_index_by_id
+                .insert(group.coherent_group_id, group_index)
+                .is_some()
+            {
+                return Err(artifact(format!(
+                    "duplicate eager coherent group {}",
+                    group.coherent_group_id
+                )));
+            }
+            self.factor(
+                group.helicity_weight_factor_id,
+                "eager reduction helicity weight",
+            )?;
+            self.factor(
+                group.all_sector_weight_factor_id,
+                "eager reduction all-sector weight",
+            )?;
+            let amplitudes = self.reduction_owned_range(
+                group.amplitude_entry_start,
+                group.amplitude_entry_count,
+                EagerPlanReductionEntryKind::AmplitudeMember,
+                group.coherent_group_id,
+                &mut covered_entries,
+                "eager amplitude reduction entries",
+            )?;
+            if amplitudes.is_empty() {
+                return Err(artifact(format!(
+                    "eager reduction group {group_index} has no amplitudes"
+                )));
+            }
+            let mut amplitude_indices = Vec::with_capacity(amplitudes.len());
+            for entry in amplitudes {
+                let amplitude_index = required_index(
+                    entry.left_id,
+                    self.amplitude_count,
+                    "eager reduction amplitude",
+                )?;
+                if std::mem::replace(&mut covered_amplitudes[amplitude_index], true) {
+                    return Err(artifact(format!(
+                        "eager amplitude {} belongs to multiple groups",
+                        entry.left_id
+                    )));
+                }
+                covered_amplitude_count += 1;
+                amplitude_indices.push(entry.left_id);
+            }
+            self.reduction_owned_range(
+                group.selector_entry_start,
+                group.selector_entry_count,
+                EagerPlanReductionEntryKind::SelectorMember,
+                group.coherent_group_id,
+                &mut covered_entries,
+                "eager selector reduction entries",
+            )?;
+            groups.push(EagerReductionGroup {
+                coherent_group_id: group.coherent_group_id,
+                amplitude_indices,
+            });
+        }
+        if covered_amplitude_count != self.amplitude_count {
+            return Err(artifact(format!(
+                "eager reduction groups cover {} of {} amplitudes",
+                covered_amplitude_count, self.amplitude_count
+            )));
+        }
+        let contraction = checked_range(
+            self.input.reduction_entries,
+            self.input.color_contraction_entry_start,
+            self.input.color_contraction_entry_count,
+            "eager color contraction entries",
+        )?;
+        if contraction.is_empty() {
+            return Err(artifact("eager reduction requires contraction entries"));
+        }
+        let contraction_start = usize_count(
+            self.input.color_contraction_entry_start,
+            "eager color contraction start",
+        )?;
+        let mut entries = Vec::with_capacity(contraction.len());
+        for (offset, entry) in contraction.iter().enumerate() {
+            if entry.kind != EagerPlanReductionEntryKind::ColorContraction {
+                return Err(artifact(
+                    "eager color contraction range contains another entry kind",
+                ));
+            }
+            mark_covered(&mut covered_entries, contraction_start + offset)?;
+            let left_group_index = *group_index_by_id.get(&entry.left_id).ok_or_else(|| {
+                artifact(format!(
+                    "eager contraction references unknown left group {}",
+                    entry.left_id
+                ))
+            })?;
+            let right_group_index = *group_index_by_id.get(&entry.right_id).ok_or_else(|| {
+                artifact(format!(
+                    "eager contraction references unknown right group {}",
+                    entry.right_id
+                ))
+            })?;
+            let mut coefficient = self.factor(entry.factor_id, "eager color contraction factor")?;
+            if entry.auxiliary_factor_id != MISSING_U32 {
+                coefficient *= self.factor(
+                    entry.auxiliary_factor_id,
+                    "eager color contraction symmetry factor",
+                )?;
+            }
+            require_finite(coefficient, "eager color contraction coefficient")?;
+            entries.push(EagerReductionEntry {
+                left_group_index: usize_u32(left_group_index, "eager reduction group")?,
+                right_group_index: usize_u32(right_group_index, "eager reduction group")?,
+                coefficient,
+            });
+        }
+        if covered_entries.iter().any(|covered| !covered) {
+            return Err(artifact(
+                "eager reduction entry catalog contains unowned rows",
+            ));
+        }
+        Ok((groups, entries))
+    }
+
+    fn reduction_owned_range<'b>(
+        &self,
+        start: u64,
+        count: u64,
+        kind: EagerPlanReductionEntryKind,
+        owner_id: u32,
+        covered: &mut [bool],
+        context: &str,
+    ) -> RusticolResult<&'b [EagerPlanReductionEntryRow]>
+    where
+        'a: 'b,
+    {
+        let entries = checked_range(self.input.reduction_entries, start, count, context)?;
+        let start = usize_count(start, context)?;
+        for (offset, entry) in entries.iter().enumerate() {
+            if entry.kind != kind || entry.owner_id != owner_id {
+                return Err(artifact(format!("{context} have inconsistent tags/owners")));
+            }
+            mark_covered(covered, start + offset)?;
+        }
+        Ok(entries)
+    }
+
+    fn validate_selector_dependency_proof(
+        &self,
+        groups: &[EagerReductionGroup],
+    ) -> RusticolResult<()> {
+        let mut group_by_amplitude = vec![None; self.amplitude_count];
+        for group in groups {
+            for amplitude in &group.amplitude_indices {
+                group_by_amplitude[*amplitude as usize] = Some(group.coherent_group_id);
+            }
+        }
+        let mut proof = SelectorProofScratch::new(&self.selector_plan)?;
+        let mut value_domain_sources = vec![Vec::<u32>::new(); self.input.values.len()];
+        for (index, closure) in self.input.closures.iter().enumerate() {
+            let amplitude = required_index(
+                closure.amplitude_index,
+                self.amplitude_count,
+                "eager closure amplitude",
+            )?;
+            let group = group_by_amplitude[amplitude]
+                .ok_or_else(|| artifact("eager closure amplitude has no coherent group"))?;
+            if closure.coherent_group_id != group {
+                return Err(artifact(format!(
+                    "eager closure {index} coherent group disagrees with reduction ownership"
+                )));
+            }
+            proof.validate_singleton(
+                closure.selector_domain_id,
+                group,
+                ProofContext::closure(index),
+            )?;
+            push_value_domain_source(
+                &mut value_domain_sources,
+                closure.left_value_slot_id,
+                closure.selector_domain_id,
+                "eager closure left value",
+            )?;
+            push_value_domain_source(
+                &mut value_domain_sources,
+                closure.right_value_slot_id,
+                closure.selector_domain_id,
+                "eager closure right value",
+            )?;
+        }
+        for stage in self.input.stages.iter().rev() {
+            let invocations = checked_range(
+                self.input.invocations,
+                stage.invocation_start,
+                stage.invocation_count,
+                "eager selector stage invocations",
+            )?;
+            let attachments = checked_range(
+                self.input.attachments,
+                stage.attachment_start,
+                stage.attachment_count,
+                "eager selector stage attachments",
+            )?;
+            let finalizations = checked_range(
+                self.input.finalizations,
+                stage.finalization_start,
+                stage.finalization_count,
+                "eager selector stage finalizations",
+            )?;
+            let mut current_domain_sources = vec![None::<[u32; 2]>; self.input.currents.len()];
+            for (index, finalization) in finalizations.iter().enumerate() {
+                let unpropagated = domain_sources_for_optional_value(
+                    &value_domain_sources,
+                    finalization.unpropagated_value_slot_id,
+                    "eager unpropagated finalization value",
+                )?;
+                proof.validate_union(
+                    finalization.unpropagated_selector_domain_id,
+                    unpropagated.iter().copied(),
+                    ProofContext::stage(stage.stage_index, "unpropagated finalization", index),
+                )?;
+                let propagated = domain_sources_for_optional_value(
+                    &value_domain_sources,
+                    finalization.propagated_value_slot_id,
+                    "eager propagated finalization value",
+                )?;
+                proof.validate_union(
+                    finalization.propagated_selector_domain_id,
+                    propagated.iter().copied(),
+                    ProofContext::stage(stage.stage_index, "propagated finalization", index),
+                )?;
+                let current_index = required_index(
+                    finalization.current_id,
+                    current_domain_sources.len(),
+                    "eager selector finalization current",
+                )?;
+                current_domain_sources[current_index] = Some([
+                    finalization.unpropagated_selector_domain_id,
+                    finalization.propagated_selector_domain_id,
+                ]);
+            }
+            for (index, attachment) in attachments.iter().enumerate() {
+                let current_index = required_index(
+                    attachment.result_current_id,
+                    current_domain_sources.len(),
+                    "eager selector attachment current",
+                )?;
+                let sources = current_domain_sources
+                    .get(current_index)
+                    .and_then(|sources| *sources)
+                    .ok_or_else(|| {
+                        artifact(format!(
+                            "eager stage {} attachment {index} has no finalized current",
+                            stage.stage_index
+                        ))
+                    })?;
+                proof.validate_union(
+                    attachment.selector_domain_id,
+                    sources,
+                    ProofContext::stage(stage.stage_index, "attachment", index),
+                )?;
+            }
+            let stage_attachment_start =
+                usize_count(stage.attachment_start, "eager stage attachment start")?;
+            for (index, invocation) in invocations.iter().enumerate() {
+                let start = usize_count(
+                    invocation.attachment_start,
+                    "eager invocation attachment start",
+                )?;
+                let count = usize_count(
+                    invocation.attachment_count,
+                    "eager invocation attachment count",
+                )?;
+                if start < stage_attachment_start {
+                    return Err(artifact("eager invocation attachment precedes its stage"));
+                }
+                let local_start = start - stage_attachment_start;
+                let local_stop = local_start
+                    .checked_add(count)
+                    .ok_or_else(|| artifact("eager invocation attachment range overflows"))?;
+                let invocation_attachments =
+                    attachments.get(local_start..local_stop).ok_or_else(|| {
+                        artifact("eager invocation attachment range exceeds its stage")
+                    })?;
+                proof.validate_union(
+                    invocation.selector_domain_id,
+                    invocation_attachments
+                        .iter()
+                        .map(|attachment| attachment.selector_domain_id),
+                    ProofContext::stage(stage.stage_index, "invocation", index),
+                )?;
+                push_value_domain_source(
+                    &mut value_domain_sources,
+                    invocation.left_value_slot_id,
+                    invocation.selector_domain_id,
+                    "eager invocation left value",
+                )?;
+                push_value_domain_source(
+                    &mut value_domain_sources,
+                    invocation.right_value_slot_id,
+                    invocation.selector_domain_id,
+                    "eager invocation right value",
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    fn attachment_factor(&self, row: &EagerPlanAttachmentRow) -> RusticolResult<EagerComplex64> {
+        let color = self.factor(row.color_factor_id, "eager attachment color factor")?;
+        let evaluation = self.factor(
+            row.evaluation_factor_id,
+            "eager attachment evaluation factor",
+        )?;
+        let normalization = self.factor(
+            row.normalization_factor_id,
+            "eager attachment normalization factor",
+        )?;
+        let representative = self.factor(
+            row.representative_evaluation_factor_id,
+            "eager attachment representative factor",
+        )?;
+        if representative == EagerComplex64::new(0.0, 0.0) {
+            return Err(artifact(
+                "eager attachment representative evaluation factor is zero",
+            ));
+        }
+        // Match plan-v2 lowering: color * evaluation * (normalization / representative).
+        let factor = color * evaluation * (normalization / representative);
+        require_finite(factor, "eager attachment combined factor")?;
+        Ok(factor)
+    }
+
+    fn validate_coupling_factor(&self, closure: &EagerPlanClosureRow) -> RusticolResult<()> {
+        let coupling = self
+            .input
+            .couplings
+            .get(closure.coupling_slot_id as usize)
+            .ok_or_else(|| artifact("eager closure references unknown coupling"))?;
+        if coupling.constant_factor_id != closure.coupling_factor_id {
+            return Err(artifact(
+                "eager closure coupling factor disagrees with its coupling row",
+            ));
+        }
+        Ok(())
+    }
+
+    fn factor(&self, id: u32, context: &str) -> RusticolResult<EagerComplex64> {
+        let index = required_index(id, self.factors.len(), context)?;
+        Ok(self.factors[index])
+    }
+
+    fn optional_value(
+        &self,
+        id: u32,
+        expected_kind: EagerValueSlotKind,
+        context: &str,
+    ) -> RusticolResult<Option<ComponentRange>> {
+        if id == MISSING_U32 {
+            return Ok(None);
+        }
+        let index = required_index(id, self.input.values.len(), context)?;
+        if self.input.values[index].kind != expected_kind {
+            return Err(artifact(format!("{context} has the wrong value-slot kind")));
+        }
+        self.values.get(id, context).map(Some)
+    }
+
+    fn validate_domain_id(&self, id: u32, context: &str) -> RusticolResult<usize> {
+        required_index(id, self.selector_plan.memberships.len(), context)
+    }
+
+    fn require_empty_domain(&self, id: u32, context: &str) -> RusticolResult<()> {
+        let index = self.validate_domain_id(id, context)?;
+        if !self.selector_plan.memberships[index].is_empty() {
+            return Err(artifact(format!(
+                "{context} has a nonempty selector domain"
+            )));
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Copy)]
+struct ProofContext {
+    stage_index: Option<u32>,
+    kind: &'static str,
+    row_index: usize,
+}
+
+impl ProofContext {
+    fn closure(row_index: usize) -> Self {
+        Self {
+            stage_index: None,
+            kind: "closure",
+            row_index,
+        }
+    }
+
+    fn stage(stage_index: u32, kind: &'static str, row_index: usize) -> Self {
+        Self {
+            stage_index: Some(stage_index),
+            kind,
+            row_index,
+        }
+    }
+}
+
+impl fmt::Display for ProofContext {
+    fn fmt(&self, output: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(stage_index) = self.stage_index {
+            write!(
+                output,
+                "eager stage {stage_index} {} {}",
+                self.kind, self.row_index
+            )
+        } else {
+            write!(output, "eager {} {}", self.kind, self.row_index)
+        }
+    }
+}
+
+enum GroupIndex {
+    Dense,
+    Sparse(HashMap<u32, usize>),
+}
+
+impl GroupIndex {
+    fn resolve(&self, group_id: u32, group_count: usize) -> Option<usize> {
+        match self {
+            Self::Dense => usize::try_from(group_id)
+                .ok()
+                .filter(|index| *index < group_count),
+            Self::Sparse(indices) => indices.get(&group_id).copied(),
+        }
+    }
+}
+
+struct SelectorProofScratch<'a> {
+    memberships: &'a [Vec<u32>],
+    group_index: GroupIndex,
+    marks: Vec<u32>,
+    epoch: u32,
+}
+
+impl<'a> SelectorProofScratch<'a> {
+    fn new(plan: &'a SelectorDomainPlan) -> RusticolResult<Self> {
+        let dense = plan
+            .group_ids
+            .iter()
+            .enumerate()
+            .all(|(index, group_id)| usize::try_from(*group_id).ok() == Some(index));
+        let group_index = if dense {
+            GroupIndex::Dense
+        } else {
+            let mut indices = HashMap::with_capacity(plan.group_ids.len());
+            for (index, group_id) in plan.group_ids.iter().copied().enumerate() {
+                if indices.insert(group_id, index).is_some() {
+                    return Err(artifact("eager selector proof repeats coherent group IDs"));
+                }
+            }
+            GroupIndex::Sparse(indices)
+        };
+        Ok(Self {
+            memberships: &plan.memberships,
+            group_index,
+            marks: vec![0; plan.group_ids.len()],
+            epoch: 0,
+        })
+    }
+
+    fn validate_singleton(
+        &self,
+        domain_id: u32,
+        expected: u32,
+        context: ProofContext,
+    ) -> RusticolResult<()> {
+        let index = required_index(
+            domain_id,
+            self.memberships.len(),
+            "eager selector proof domain",
+        )?;
+        if self.memberships[index].as_slice() != [expected] {
+            return Err(artifact(format!(
+                "{context} selector domain does not match its dependency closure"
+            )));
+        }
+        Ok(())
+    }
+
+    fn validate_union(
+        &mut self,
+        domain_id: u32,
+        sources: impl IntoIterator<Item = u32>,
+        context: ProofContext,
+    ) -> RusticolResult<()> {
+        let target_index = required_index(
+            domain_id,
+            self.memberships.len(),
+            "eager selector proof target domain",
+        )?;
+        if self.epoch > u32::MAX - 2 {
+            self.marks.fill(0);
+            self.epoch = 2;
+        } else {
+            self.epoch += 2;
+        }
+        let expected_mark = self.epoch;
+        let covered_mark = expected_mark + 1;
+        let target = &self.memberships[target_index];
+        for group_id in target {
+            let group_index = self
+                .group_index
+                .resolve(*group_id, self.marks.len())
+                .ok_or_else(|| artifact("eager selector proof references an unknown group"))?;
+            self.marks[group_index] = expected_mark;
+        }
+
+        let mut covered = 0usize;
+        for source_id in sources {
+            let source_index = required_index(
+                source_id,
+                self.memberships.len(),
+                "eager selector proof source domain",
+            )?;
+            for group_id in &self.memberships[source_index] {
+                let group_index = self
+                    .group_index
+                    .resolve(*group_id, self.marks.len())
+                    .ok_or_else(|| artifact("eager selector proof references an unknown group"))?;
+                match self.marks[group_index] {
+                    mark if mark == expected_mark => {
+                        self.marks[group_index] = covered_mark;
+                        covered += 1;
+                    }
+                    mark if mark == covered_mark => {}
+                    _ => {
+                        return Err(artifact(format!(
+                            "{context} selector domain does not match its dependency closure"
+                        )));
+                    }
+                }
+            }
+        }
+        if covered != target.len() {
+            return Err(artifact(format!(
+                "{context} selector domain does not match its dependency closure"
+            )));
+        }
+        Ok(())
+    }
+}
+
+fn validate_current_layout(rows: &[EagerPlanCurrentRow]) -> RusticolResult<Vec<u32>> {
+    validate_component_rows(
+        rows.iter().enumerate().map(|(index, row)| {
+            if row.flags & !1 != 0 {
+                return Err(artifact(format!(
+                    "eager current {index} has unsupported flags"
+                )));
+            }
+            Ok((row.current_id, row.component_start, row.component_count))
+        }),
+        "current",
+    )
+}
+
+fn validate_value_layout(
+    rows: &[EagerPlanValueRow],
+    currents: &[EagerPlanCurrentRow],
+) -> RusticolResult<Vec<u32>> {
+    let counts = validate_component_rows(
+        rows.iter()
+            .map(|row| Ok((row.value_slot_id, row.component_start, row.component_count))),
+        "value",
+    )?;
+    for (index, row) in rows.iter().enumerate() {
+        let current = required_index(row.current_id, currents.len(), "eager value current")?;
+        if currents[current].component_count != row.component_count {
+            return Err(artifact(format!(
+                "eager value {index} width does not match current {}",
+                row.current_id
+            )));
+        }
+    }
+    Ok(counts)
+}
+
+fn validate_momentum_layout(rows: &[EagerPlanMomentumRow]) -> RusticolResult<Vec<u32>> {
+    validate_component_rows(
+        rows.iter().map(|row| {
+            Ok((
+                row.momentum_slot_id,
+                row.component_start,
+                row.component_count,
+            ))
+        }),
+        "momentum",
+    )
+}
+
+fn validate_component_rows(
+    rows: impl Iterator<Item = RusticolResult<(u32, u64, u32)>>,
+    name: &str,
+) -> RusticolResult<Vec<u32>> {
+    let mut counts = Vec::new();
+    let mut component_start = 0u64;
+    for (index, row) in rows.enumerate() {
+        let (id, start, count) = row?;
+        if usize::try_from(id).ok() != Some(index) {
+            return Err(artifact(format!("eager {name} IDs are not dense")));
+        }
+        if start != component_start || count == 0 {
+            return Err(artifact(format!(
+                "eager {name} {index} has a noncontiguous or empty component range"
+            )));
+        }
+        component_start = component_start
+            .checked_add(u64::from(count))
+            .ok_or_else(|| artifact(format!("eager {name} component range overflows")))?;
+        counts.push(count);
+    }
+    Ok(counts)
+}
+
+fn validate_amplitude_layout(rows: &[EagerPlanClosureRow]) -> RusticolResult<usize> {
+    validate_dense_ids(
+        rows.iter().map(|row| row.root_id),
+        "eager plan-v3 closure root",
+    )?;
+    if rows.is_empty() {
+        return Err(artifact("eager execution plan has no amplitude outputs"));
+    }
+    let amplitudes = rows
+        .iter()
+        .map(|row| row.amplitude_index)
+        .collect::<BTreeSet<_>>();
+    if amplitudes
+        .iter()
+        .copied()
+        .ne(0..usize_u32(amplitudes.len(), "eager amplitude count")?)
+    {
+        return Err(artifact("eager closure amplitude indices are not dense"));
+    }
+    Ok(amplitudes.len())
+}
+
+fn load_factors(rows: &[EagerPlanExactFactorRow]) -> RusticolResult<Vec<EagerComplex64>> {
+    validate_dense_ids(
+        rows.iter().map(|row| row.factor_id),
+        "eager plan-v3 exact factor",
+    )?;
+    rows.iter()
+        .enumerate()
+        .map(|(index, row)| {
+            if row.exact_source > 1 {
+                return Err(artifact(format!(
+                    "eager exact factor {index} has an unsupported source"
+                )));
+            }
+            let value = EagerComplex64::new(
+                f64::from_bits(row.real_bits),
+                f64::from_bits(row.imaginary_bits),
+            );
+            require_finite(value, &format!("eager exact factor {index}"))?;
+            Ok(value)
+        })
+        .collect()
+}
+
+fn load_selector_plan(
+    rows: &[EagerPlanSelectorDomainRow],
+    memberships: &[u32],
+    groups: &[EagerPlanReductionGroupRow],
+) -> RusticolResult<SelectorDomainPlan> {
+    if rows.is_empty() {
+        return Err(artifact("eager selector-domain table is empty"));
+    }
+    let mut known_groups = HashSet::with_capacity(groups.len());
+    let mut group_ids = Vec::with_capacity(groups.len());
+    for group in groups {
+        if !known_groups.insert(group.coherent_group_id) {
+            return Err(artifact("eager reduction groups repeat coherent group IDs"));
+        }
+        group_ids.push(group.coherent_group_id);
+    }
+    group_ids.sort_unstable();
+    let mut result = Vec::with_capacity(rows.len());
+    let mut cursor = 0usize;
+    let mut unique = HashSet::<&[u32]>::with_capacity(rows.len());
+    for (domain_id, row) in rows.iter().enumerate() {
+        let start = usize_count(row.member_start, "eager selector member start")?;
+        let count = usize_count(row.member_count, "eager selector member count")?;
+        if start != cursor {
+            return Err(artifact(format!(
+                "eager selector domain {domain_id} is not contiguous"
+            )));
+        }
+        let stop = start
+            .checked_add(count)
+            .ok_or_else(|| artifact("eager selector membership range overflows"))?;
+        let members = memberships
+            .get(start..stop)
+            .ok_or_else(|| artifact("eager selector domain exceeds its membership table"))?;
+        if members.windows(2).any(|pair| pair[0] >= pair[1]) {
+            return Err(artifact(format!(
+                "eager selector domain {domain_id} is not sorted and unique"
+            )));
+        }
+        if let Some(unknown) = members.iter().find(|member| !known_groups.contains(member)) {
+            return Err(artifact(format!(
+                "eager selector domain references unknown coherent group {unknown}"
+            )));
+        }
+        if !unique.insert(members) {
+            return Err(artifact(format!(
+                "eager selector domain {domain_id} duplicates an earlier domain"
+            )));
+        }
+        result.push(members.to_vec());
+        cursor = stop;
+    }
+    if cursor != memberships.len() || !result.iter().any(Vec::is_empty) {
+        return Err(artifact(
+            "eager selector domains do not exactly cover memberships and an empty domain",
+        ));
+    }
+    Ok(SelectorDomainPlan {
+        memberships: result,
+        group_ids,
+    })
+}
+
+fn validate_stage_ranges(
+    stages: &[EagerPlanStageRow],
+    invocation_count: usize,
+    attachment_count: usize,
+    finalization_count: usize,
+) -> RusticolResult<()> {
+    let mut invocations = 0u64;
+    let mut attachments = 0u64;
+    let mut finalizations = 0u64;
+    for (index, stage) in stages.iter().enumerate() {
+        if stage.invocation_start != invocations
+            || stage.attachment_start != attachments
+            || stage.finalization_start != finalizations
+        {
+            return Err(artifact(format!(
+                "eager stage {index} ranges are not contiguous"
+            )));
+        }
+        invocations = checked_add(
+            stage.invocation_start,
+            stage.invocation_count,
+            "invocations",
+        )?;
+        attachments = checked_add(
+            stage.attachment_start,
+            stage.attachment_count,
+            "attachments",
+        )?;
+        finalizations = checked_add(
+            stage.finalization_start,
+            stage.finalization_count,
+            "finalizations",
+        )?;
+    }
+    if usize::try_from(invocations).ok() != Some(invocation_count)
+        || usize::try_from(attachments).ok() != Some(attachment_count)
+        || usize::try_from(finalizations).ok() != Some(finalization_count)
+    {
+        return Err(artifact("eager stage ranges do not cover execution tables"));
+    }
+    Ok(())
+}
+
+fn validate_kernel_specs(
+    specs: &[EagerKernelSpec],
+    parameter_count: usize,
+) -> RusticolResult<BTreeMap<u32, EagerKernelSpec>> {
+    let mut kernels = BTreeMap::new();
+    for (index, spec) in specs.iter().cloned().enumerate() {
+        if spec.kernel_id == MISSING_U32
+            || spec.inputs.is_empty()
+            || spec.output_component_count == 0
+        {
+            return Err(artifact(format!("invalid eager kernel spec {index}")));
+        }
+        if spec.independent_block_size != 1
+            && (spec.independent_block_size != EAGER_INDEPENDENT_BLOCK_SIZE
+                || spec.role != EagerKernelRole::Vertex
+                || spec.inputs.iter().any(|input| {
+                    !matches!(
+                        input,
+                        EagerKernelInput::FirstCurrentComponent(_)
+                            | EagerKernelInput::SecondCurrentComponent(_)
+                    )
+                }))
+        {
+            return Err(artifact(format!(
+                "eager kernel {} has an invalid independent block contract",
+                spec.kernel_id
+            )));
+        }
+        let mut inputs = BTreeSet::new();
+        for input in &spec.inputs {
+            if !inputs.insert(*input) {
+                return Err(artifact(format!(
+                    "eager kernel {} repeats an input descriptor",
+                    spec.kernel_id
+                )));
+            }
+            if let EagerKernelInput::ModelParameter(parameter) = input {
+                required_index(
+                    *parameter,
+                    parameter_count,
+                    &format!("eager kernel {} model parameter", spec.kernel_id),
+                )?;
+            }
+        }
+        let kernel_id = spec.kernel_id;
+        if kernels.insert(kernel_id, spec).is_some() {
+            return Err(artifact(format!("duplicate eager kernel ID {kernel_id}")));
+        }
+    }
+    Ok(kernels)
+}
+
+#[derive(Clone, Copy)]
+struct KernelInputBounds {
+    first_current: usize,
+    second_current: usize,
+    first_momentum: usize,
+    second_momentum: usize,
+    has_coupling: bool,
+    parameter_count: usize,
+}
+
+fn validate_kernel_inputs(
+    kernel: &EagerKernelSpec,
+    bounds: KernelInputBounds,
+) -> RusticolResult<()> {
+    for input in &kernel.inputs {
+        let (allowed, index, count) = match *input {
+            EagerKernelInput::FirstCurrentComponent(index) => {
+                (true, Some(index), bounds.first_current)
+            }
+            EagerKernelInput::SecondCurrentComponent(index) => (
+                kernel.role != EagerKernelRole::Finalization,
+                Some(index),
+                bounds.second_current,
+            ),
+            EagerKernelInput::FirstMomentumComponent(index) => (
+                kernel.role != EagerKernelRole::Closure,
+                Some(index),
+                bounds.first_momentum,
+            ),
+            EagerKernelInput::SecondMomentumComponent(index) => (
+                kernel.role == EagerKernelRole::Vertex,
+                Some(index),
+                bounds.second_momentum,
+            ),
+            EagerKernelInput::CouplingReal | EagerKernelInput::CouplingImag => {
+                (bounds.has_coupling, None, 0)
+            }
+            EagerKernelInput::ModelParameter(index) => (true, Some(index), bounds.parameter_count),
+        };
+        if !allowed
+            || index.is_some_and(|index| {
+                usize::try_from(index)
+                    .ok()
+                    .is_none_or(|index| index >= count)
+            })
+        {
+            return Err(artifact(format!(
+                "eager {:?} kernel {} cannot use input descriptor {input:?}",
+                kernel.role, kernel.kernel_id
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn require_kernel<'a>(
+    kernels: &'a BTreeMap<u32, EagerKernelSpec>,
+    kernel_id: u32,
+    role: EagerKernelRole,
+    context: &str,
+) -> RusticolResult<&'a EagerKernelSpec> {
+    let kernel = kernels.get(&kernel_id).ok_or_else(|| {
+        artifact(format!(
+            "eager {context} references unknown kernel {kernel_id}"
+        ))
+    })?;
+    if kernel.role != role {
+        return Err(artifact(format!(
+            "eager {context} kernel {kernel_id} has role {:?}, expected {role:?}",
+            kernel.role
+        )));
+    }
+    Ok(kernel)
+}
+
+fn validate_output_factor(source: u8, coupling: u32, context: &str) -> RusticolResult<u32> {
+    let source = u32::from(source);
+    if source > 2 || (source != EAGER_OUTPUT_FACTOR_NONE && coupling == MISSING_U32) {
+        return Err(artifact(format!(
+            "{context} has an invalid output-factor source"
+        )));
+    }
+    Ok(source)
+}
+
+fn domain_sources_for_optional_value<'a>(
+    domains: &'a [Vec<u32>],
+    value_slot_id: u32,
+    context: &str,
+) -> RusticolResult<&'a [u32]> {
+    if value_slot_id == MISSING_U32 {
+        Ok(&[])
+    } else {
+        let index = required_index(value_slot_id, domains.len(), context)?;
+        Ok(&domains[index])
+    }
+}
+
+fn push_value_domain_source(
+    domains: &mut [Vec<u32>],
+    value_slot_id: u32,
+    domain_id: u32,
+    context: &str,
+) -> RusticolResult<()> {
+    let index = required_index(value_slot_id, domains.len(), context)?;
+    if domains[index].last().copied() != Some(domain_id) {
+        domains[index].push(domain_id);
+    }
+    Ok(())
+}
+
+fn validate_dense_ids(ids: impl Iterator<Item = u32>, context: &str) -> RusticolResult<()> {
+    for (index, id) in ids.enumerate() {
+        if usize::try_from(id).ok() != Some(index) {
+            return Err(artifact(format!("{context} IDs are not dense")));
+        }
+    }
+    Ok(())
+}
+
+fn validate_optional_index(id: u32, count: usize, context: &str) -> RusticolResult<()> {
+    if id == MISSING_U32 {
+        Ok(())
+    } else {
+        required_index(id, count, context).map(|_| ())
+    }
+}
+
+fn required_index(id: u32, count: usize, context: &str) -> RusticolResult<usize> {
+    if id == MISSING_U32 {
+        return Err(artifact(format!("{context} uses the reserved missing ID")));
+    }
+    let index =
+        usize::try_from(id).map_err(|_| artifact(format!("{context} index does not fit usize")))?;
+    if index >= count {
+        return Err(artifact(format!(
+            "{context} index {index} is outside 0..{count}"
+        )));
+    }
+    Ok(index)
+}
+
+fn checked_range<'a, T>(
+    values: &'a [T],
+    start: u64,
+    count: u64,
+    context: &str,
+) -> RusticolResult<&'a [T]> {
+    let start = usize_count(start, context)?;
+    let count = usize_count(count, context)?;
+    let stop = start
+        .checked_add(count)
+        .ok_or_else(|| artifact(format!("{context} range overflows usize")))?;
+    values
+        .get(start..stop)
+        .ok_or_else(|| artifact(format!("{context} range exceeds its table")))
+}
+
+fn mark_covered(covered: &mut [bool], index: usize) -> RusticolResult<()> {
+    let slot = covered
+        .get_mut(index)
+        .ok_or_else(|| artifact("eager reduction range exceeds its table"))?;
+    if std::mem::replace(slot, true) {
+        return Err(artifact("eager reduction entry belongs to multiple ranges"));
+    }
+    Ok(())
+}
+
+fn checked_add(start: u64, count: u64, context: &str) -> RusticolResult<u64> {
+    start
+        .checked_add(count)
+        .ok_or_else(|| artifact(format!("eager {context} range overflows u64")))
+}
+
+fn usize_count(value: u64, context: &str) -> RusticolResult<usize> {
+    usize::try_from(value).map_err(|_| artifact(format!("{context} does not fit usize")))
+}
+
+fn usize_u32(value: usize, context: &str) -> RusticolResult<u32> {
+    u32::try_from(value).map_err(|_| artifact(format!("{context} exceeds u32")))
+}
+
+fn require_finite(value: EagerComplex64, context: &str) -> RusticolResult<()> {
+    if !value.re.is_finite() || !value.im.is_finite() {
+        return Err(artifact(format!("{context} is not finite")));
+    }
+    Ok(())
+}
+
+fn artifact(message: impl Into<String>) -> RusticolError {
+    RusticolError::artifact(message)
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/plan_v3_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/plan_v3_tests.rs
new file mode 100644
index 0000000000..27254490d6
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/plan_v3_tests.rs
@@ -0,0 +1,350 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::plan_v3::{EagerOwnedPlanV3Sections, EagerPlanV3Sections};
+use super::{EagerExecutionPlan, EagerKernelInput, EagerKernelRole, EagerKernelSpec};
+use crate::{
+    EagerPlanAttachmentRow, EagerPlanClosureRow, EagerPlanCouplingRow, EagerPlanCurrentRow,
+    EagerPlanDirectCoefficientRow, EagerPlanExactFactorRow, EagerPlanFinalizationRow,
+    EagerPlanInvocationRow, EagerPlanMomentumRow, EagerPlanReductionEntryKind,
+    EagerPlanReductionEntryRow, EagerPlanReductionGroupRow, EagerPlanSelectorDomainRow,
+    EagerPlanStageRow, EagerPlanValueRow, EagerValueSlotKind, MISSING_U32,
+};
+
+#[derive(Clone)]
+pub(super) struct Fixture {
+    kernels: Vec<EagerKernelSpec>,
+    pub(super) prepared_parameter_count: u32,
+    pub(super) currents: Vec<EagerPlanCurrentRow>,
+    pub(super) values: Vec<EagerPlanValueRow>,
+    pub(super) momenta: Vec<EagerPlanMomentumRow>,
+    pub(super) stages: Vec<EagerPlanStageRow>,
+    couplings: Vec<EagerPlanCouplingRow>,
+    pub(super) invocations: Vec<EagerPlanInvocationRow>,
+    pub(super) attachments: Vec<EagerPlanAttachmentRow>,
+    pub(super) finalizations: Vec<EagerPlanFinalizationRow>,
+    pub(super) closures: Vec<EagerPlanClosureRow>,
+    direct_coefficients: Vec<EagerPlanDirectCoefficientRow>,
+    selector_domains: Vec<EagerPlanSelectorDomainRow>,
+    selector_memberships: Vec<u32>,
+    reduction_groups: Vec<EagerPlanReductionGroupRow>,
+    reduction_entries: Vec<EagerPlanReductionEntryRow>,
+    exact_factors: Vec<EagerPlanExactFactorRow>,
+}
+
+impl Fixture {
+    pub(super) fn new() -> Self {
+        let exact_factors = [
+            (1.0, 0.0),
+            (2.0, 3.0),
+            (2.0, 0.0),
+            (3.0, 0.0),
+            (5.0, 0.0),
+            (2.0, 0.0),
+            (7.0, 0.0),
+            (11.0, 0.0),
+            (13.0, 0.0),
+            (17.0, 0.0),
+            (19.0, 0.0),
+        ]
+        .into_iter()
+        .enumerate()
+        .map(|(factor_id, (real, imaginary))| EagerPlanExactFactorRow {
+            factor_id: factor_id as u32,
+            real_bits: f64::to_bits(real),
+            imaginary_bits: f64::to_bits(imaginary),
+            canonical_string_id: 0,
+            exact_source: 0,
+            exact_ir_id: MISSING_U32,
+            source_ir_id: MISSING_U32,
+        })
+        .collect();
+        Self {
+            kernels: vec![
+                EagerKernelSpec {
+                    kernel_id: 10,
+                    role: EagerKernelRole::Vertex,
+                    inputs: vec![
+                        EagerKernelInput::FirstCurrentComponent(0),
+                        EagerKernelInput::SecondCurrentComponent(0),
+                        EagerKernelInput::CouplingReal,
+                    ],
+                    output_component_count: 1,
+                    homogeneous_linear_first_current: false,
+                    independent_block_size: 1,
+                },
+                EagerKernelSpec {
+                    kernel_id: 11,
+                    role: EagerKernelRole::Closure,
+                    inputs: vec![
+                        EagerKernelInput::FirstCurrentComponent(0),
+                        EagerKernelInput::SecondCurrentComponent(0),
+                        EagerKernelInput::CouplingReal,
+                    ],
+                    output_component_count: 1,
+                    homogeneous_linear_first_current: false,
+                    independent_block_size: 1,
+                },
+            ],
+            prepared_parameter_count: 0,
+            currents: (0..3)
+                .map(|current_id| EagerPlanCurrentRow {
+                    current_id,
+                    component_start: u64::from(current_id),
+                    component_count: 1,
+                    momentum_slot_id: current_id,
+                    flags: u32::from(current_id < 2),
+                })
+                .collect(),
+            values: vec![
+                EagerPlanValueRow {
+                    value_slot_id: 0,
+                    current_id: 0,
+                    component_start: 0,
+                    component_count: 1,
+                    kind: EagerValueSlotKind::Source,
+                },
+                EagerPlanValueRow {
+                    value_slot_id: 1,
+                    current_id: 1,
+                    component_start: 1,
+                    component_count: 1,
+                    kind: EagerValueSlotKind::Source,
+                },
+                EagerPlanValueRow {
+                    value_slot_id: 2,
+                    current_id: 2,
+                    component_start: 2,
+                    component_count: 1,
+                    kind: EagerValueSlotKind::Unpropagated,
+                },
+            ],
+            momenta: (0..3)
+                .map(|momentum_slot_id| EagerPlanMomentumRow {
+                    momentum_slot_id,
+                    bitset_id: momentum_slot_id,
+                    component_start: u64::from(momentum_slot_id) * 4,
+                    component_count: 4,
+                })
+                .collect(),
+            stages: vec![EagerPlanStageRow {
+                stage_index: 1,
+                subset_size: 2,
+                invocation_start: 0,
+                invocation_count: 1,
+                attachment_start: 0,
+                attachment_count: 1,
+                finalization_start: 0,
+                finalization_count: 1,
+            }],
+            couplings: vec![EagerPlanCouplingRow {
+                coupling_id: 0,
+                real_parameter_id: MISSING_U32,
+                imaginary_parameter_id: MISSING_U32,
+                constant_factor_id: 1,
+            }],
+            invocations: vec![EagerPlanInvocationRow {
+                evaluation_group_id: 0,
+                kernel_id: 10,
+                left_value_slot_id: 0,
+                right_value_slot_id: 1,
+                left_momentum_slot_id: 0,
+                right_momentum_slot_id: 1,
+                coupling_slot_id: 0,
+                output_factor_source: 0,
+                attachment_start: 0,
+                attachment_count: 1,
+                selector_domain_id: 1,
+            }],
+            attachments: vec![EagerPlanAttachmentRow {
+                interaction_id: 0,
+                result_current_id: 2,
+                color_factor_id: 2,
+                evaluation_factor_id: 3,
+                normalization_factor_id: 4,
+                representative_evaluation_factor_id: 5,
+                selector_domain_id: 1,
+            }],
+            finalizations: vec![EagerPlanFinalizationRow {
+                kernel_id: MISSING_U32,
+                current_id: 2,
+                unpropagated_value_slot_id: 2,
+                propagated_value_slot_id: MISSING_U32,
+                momentum_slot_id: 2,
+                unpropagated_selector_domain_id: 1,
+                propagated_selector_domain_id: 0,
+            }],
+            closures: vec![EagerPlanClosureRow {
+                root_id: 0,
+                kernel_id: 11,
+                left_value_slot_id: 2,
+                right_value_slot_id: 0,
+                amplitude_index: 0,
+                coherent_group_id: 7,
+                coupling_slot_id: 0,
+                coupling_factor_id: 1,
+                output_factor_source: 0,
+                color_factor_id: 6,
+                normalization_factor_id: 7,
+                direct_coefficient_start: 0,
+                direct_coefficient_count: 0,
+                selector_domain_id: 1,
+            }],
+            direct_coefficients: Vec::new(),
+            selector_domains: vec![
+                EagerPlanSelectorDomainRow {
+                    member_start: 0,
+                    member_count: 0,
+                },
+                EagerPlanSelectorDomainRow {
+                    member_start: 0,
+                    member_count: 1,
+                },
+            ],
+            selector_memberships: vec![7],
+            reduction_groups: vec![EagerPlanReductionGroupRow {
+                coherent_group_id: 7,
+                amplitude_entry_start: 0,
+                amplitude_entry_count: 1,
+                selector_entry_start: 1,
+                selector_entry_count: 0,
+                helicity_weight_factor_id: 0,
+                all_sector_weight_factor_id: 0,
+            }],
+            reduction_entries: vec![
+                EagerPlanReductionEntryRow {
+                    kind: EagerPlanReductionEntryKind::AmplitudeMember,
+                    owner_id: 7,
+                    left_id: 0,
+                    right_id: MISSING_U32,
+                    factor_id: MISSING_U32,
+                    auxiliary_factor_id: MISSING_U32,
+                },
+                EagerPlanReductionEntryRow {
+                    kind: EagerPlanReductionEntryKind::ColorContraction,
+                    owner_id: MISSING_U32,
+                    left_id: 7,
+                    right_id: 7,
+                    factor_id: 8,
+                    auxiliary_factor_id: 9,
+                },
+            ],
+            exact_factors,
+        }
+    }
+
+    pub(super) fn sections(&self) -> EagerPlanV3Sections<'_> {
+        EagerPlanV3Sections {
+            kernels: &self.kernels,
+            prepared_parameter_count: self.prepared_parameter_count,
+            currents: &self.currents,
+            values: &self.values,
+            momenta: &self.momenta,
+            parameters: &[],
+            stages: &self.stages,
+            couplings: &self.couplings,
+            invocations: &self.invocations,
+            attachments: &self.attachments,
+            finalizations: &self.finalizations,
+            closures: &self.closures,
+            direct_coefficients: &self.direct_coefficients,
+            selector_domains: &self.selector_domains,
+            selector_memberships: &self.selector_memberships,
+            reduction_groups: &self.reduction_groups,
+            reduction_entries: &self.reduction_entries,
+            exact_factors: &self.exact_factors,
+            color_contraction_entry_start: 1,
+            color_contraction_entry_count: 1,
+        }
+    }
+}
+
+#[test]
+fn builds_final_f64_semantics_without_plan_v2_payloads() {
+    let fixture = Fixture::new();
+    let owned: EagerOwnedPlanV3Sections = fixture.sections().to_owned();
+    let plan = owned.into_execution_plan().unwrap();
+
+    assert_eq!(plan.value_component_count(), 3);
+    assert_eq!(plan.momentum_component_count(), 12);
+    assert_eq!(plan.current_component_count(), 3);
+    assert_eq!(plan.stage_indices().collect::<Vec<_>>(), vec![1]);
+    assert!(plan.has_selector_domains());
+    assert_eq!(plan.couplings[0].constant_real, 2.0);
+    assert_eq!(plan.couplings[0].constant_imag, 3.0);
+    assert_eq!(plan.stages[0].attachments[0].row.factor_real, 15.0);
+    assert_eq!(plan.stages[0].attachments[0].row.factor_imag, 0.0);
+    assert_eq!(plan.closures[0].row.factor_real, 77.0);
+    assert_eq!(plan.reduction_groups[0].amplitude_indices, vec![0]);
+    assert_eq!(plan.reduction_entries[0].coefficient.re, 221.0);
+    assert_eq!(plan.initial_value_ranges.len(), 2);
+}
+
+#[test]
+fn preserves_direct_closure_coefficients_and_color_factor() {
+    let mut fixture = Fixture::new();
+    fixture.closures[0].kernel_id = MISSING_U32;
+    fixture.closures[0].coupling_slot_id = MISSING_U32;
+    fixture.closures[0].direct_coefficient_count = 1;
+    fixture.direct_coefficients = vec![EagerPlanDirectCoefficientRow {
+        contraction_ir_id: 0,
+        component_index: 0,
+        factor_id: 10,
+    }];
+
+    let plan = EagerExecutionPlan::from_plan_v3_sections(fixture.sections()).unwrap();
+    assert!(plan.closures.is_empty());
+    assert_eq!(plan.direct_closures[0].row.factor_real, 7.0);
+    assert_eq!(plan.direct_closures[0].coefficients[0].re, 19.0);
+}
+
+#[test]
+fn prepared_parameter_domain_is_independent_of_decoded_parameter_rows() {
+    let mut fixture = Fixture::new();
+    fixture.prepared_parameter_count = 1;
+    fixture.couplings[0].real_parameter_id = 0;
+    fixture.kernels[0]
+        .inputs
+        .push(EagerKernelInput::ModelParameter(0));
+
+    let plan = EagerExecutionPlan::from_plan_v3_sections(fixture.sections()).unwrap();
+    assert_eq!(plan.parameter_count(), 1);
+    assert_eq!(plan.couplings[0].real_parameter_id, 0);
+
+    fixture.prepared_parameter_count = 0;
+    let error = EagerExecutionPlan::from_plan_v3_sections(fixture.sections()).unwrap_err();
+    assert!(error.to_string().contains("model parameter"));
+}
+
+#[test]
+fn rejects_prepared_kernel_role_mismatches() {
+    let mut fixture = Fixture::new();
+    fixture.kernels[0].role = EagerKernelRole::Closure;
+
+    let error = EagerExecutionPlan::from_plan_v3_sections(fixture.sections()).unwrap_err();
+    assert!(error.to_string().contains("expected Vertex"));
+}
+
+#[test]
+fn rejects_duplicate_selector_domains() {
+    let mut fixture = Fixture::new();
+    fixture.selector_domains.push(EagerPlanSelectorDomainRow {
+        member_start: 1,
+        member_count: 0,
+    });
+
+    let error = EagerExecutionPlan::from_plan_v3_sections(fixture.sections()).unwrap_err();
+    assert!(error.to_string().contains("duplicates an earlier domain"));
+}
+
+#[test]
+fn rejects_selector_union_missing_an_attachment_dependency() {
+    let mut fixture = Fixture::new();
+    fixture.invocations[0].selector_domain_id = 0;
+
+    let error = EagerExecutionPlan::from_plan_v3_sections(fixture.sections()).unwrap_err();
+    assert!(
+        error
+            .to_string()
+            .contains("selector domain does not match its dependency closure")
+    );
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/profile.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/profile.rs
new file mode 100644
index 0000000000..b32ada94b1
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/profile.rs
@@ -0,0 +1,342 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Instrumented eager execution used only by the explicit native profile path.
+//!
+//! The ordinary scheduler deliberately stays in `execute.rs` without timer
+//! branches or `Instant` calls. These routines mirror its row-major packet
+//! contract while placing timers exactly at the phase boundaries exposed to
+//! users.
+
+use super::plan::{ClosureExecutionRows, ComponentRange, EagerStagePlan};
+use super::runtime::{
+    EagerWorkspace, KernelPacket, LinearFinalizationPacket, PacketRole, StageSchedule,
+};
+use super::{
+    EagerComplex64, EagerExecutionProfile, EagerKernelBackend, EagerKernelCall, EagerKernelSpec,
+};
+use crate::{RusticolError, RusticolResult};
+use std::collections::BTreeMap;
+use std::time::Instant;
+
+#[allow(clippy::too_many_arguments)]
+#[allow(dead_code)] // Retained by the explicit packet-scheduler profiling oracle.
+pub(super) fn execute_stage_profiled<B: EagerKernelBackend>(
+    stage: &EagerStagePlan,
+    schedule: &StageSchedule,
+    kernels: &BTreeMap<u32, EagerKernelSpec>,
+    workspace: &mut EagerWorkspace,
+    backend: &mut B,
+    point_count: usize,
+    tile_start: usize,
+    tile_points: usize,
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+    profile: &mut EagerExecutionProfile,
+) -> RusticolResult<()> {
+    let clear_started = Instant::now();
+    for range in &stage.zero_current_ranges {
+        for component in range.start..range.start + range.len {
+            let target = component * workspace.tile_capacity;
+            workspace.currents[target..target + tile_points].fill(EagerComplex64::new(0.0, 0.0));
+        }
+    }
+    profile.invocation_scatter += clear_started.elapsed();
+    for packet in &schedule.invocation_packets {
+        debug_assert_eq!(packet.role, PacketRole::Invocation);
+        let items = &stage.invocations[packet.item_range.clone()];
+        let (lane_count, evaluator_input_components, evaluator_output_components) =
+            super::execute::invocation_packet_shape(packet, items.len(), tile_points)?;
+        let input_len = evaluator_input_components * lane_count;
+        let output_len = evaluator_output_components * lane_count;
+        let (inputs, outputs) = packet_slices(&mut workspace.packet, input_len, output_len)?;
+        let kernel = kernels.get(&packet.kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!(
+                "eager schedule lost invocation kernel {}",
+                packet.kernel_id
+            ))
+        })?;
+
+        let gather_started = Instant::now();
+        if packet.independent_block_size == 1 {
+            super::execute::gather_invocations(
+                items,
+                &kernel.inputs,
+                inputs,
+                packet.input_components,
+                point_count,
+                tile_start,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.values,
+                momenta,
+                &workspace.couplings,
+                model_parameters,
+            );
+        } else {
+            super::execute::gather_blocked_invocations(
+                items,
+                &kernel.inputs,
+                inputs,
+                packet.input_components,
+                packet.independent_block_size,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.values,
+            );
+        }
+        profile.gather += gather_started.elapsed();
+
+        let kernel_started = Instant::now();
+        backend.evaluate_batch(EagerKernelCall {
+            kernel_id: packet.kernel_id,
+            independent_block_size: packet.independent_block_size as u32,
+            lane_count,
+            input_component_count: evaluator_input_components,
+            output_component_count: evaluator_output_components,
+            inputs,
+            outputs,
+        })?;
+        profile.kernel_call += kernel_started.elapsed();
+        profile.backend_call_count = profile.backend_call_count.saturating_add(1);
+
+        let scatter_started = Instant::now();
+        if packet.independent_block_size == 1 {
+            super::execute::scatter_invocations(
+                items,
+                &stage.attachments,
+                outputs,
+                lane_count,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.couplings,
+                &mut workspace.currents,
+            );
+        } else {
+            super::execute::scatter_blocked_invocations(
+                items,
+                &stage.attachments,
+                outputs,
+                packet.output_components,
+                packet.independent_block_size,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.couplings,
+                &mut workspace.currents,
+            );
+        }
+        profile.invocation_scatter += scatter_started.elapsed();
+    }
+
+    let copies_started = Instant::now();
+    for item in &stage.finalization_copies {
+        copy_component_range(
+            &workspace.currents,
+            item.current,
+            &mut workspace.values,
+            item.unpropagated,
+            workspace.tile_capacity,
+            tile_points,
+        );
+    }
+    profile.finalization += copies_started.elapsed();
+
+    for packet in &schedule.finalization_packets {
+        debug_assert_eq!(packet.role, PacketRole::Finalization);
+        let items = &stage.finalizations[packet.item_range.clone()];
+        let lane_count = packet
+            .linear_finalization
+            .as_ref()
+            .map_or(items.len(), LinearFinalizationPacket::lane_multiplier)
+            * tile_points;
+        let input_len = packet.input_components * lane_count;
+        let output_len = packet.output_components * lane_count;
+        let (inputs, outputs) = packet_slices(&mut workspace.packet, input_len, output_len)?;
+        let kernel = kernels.get(&packet.kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!(
+                "eager schedule lost finalization kernel {}",
+                packet.kernel_id
+            ))
+        })?;
+
+        let gather_started = Instant::now();
+        if let Some(linear) = &packet.linear_finalization {
+            super::execute::gather_linear_finalizations(
+                linear,
+                &kernel.inputs,
+                inputs,
+                packet.input_components,
+                point_count,
+                tile_start,
+                tile_points,
+                momenta,
+                model_parameters,
+            );
+        } else {
+            super::execute::gather_finalizations(
+                items,
+                &kernel.inputs,
+                inputs,
+                packet.input_components,
+                point_count,
+                tile_start,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.currents,
+                momenta,
+                model_parameters,
+            );
+        }
+        profile.finalization += gather_started.elapsed();
+
+        let kernel_started = Instant::now();
+        backend.evaluate_batch(EagerKernelCall {
+            kernel_id: packet.kernel_id,
+            independent_block_size: 1,
+            lane_count,
+            input_component_count: packet.input_components,
+            output_component_count: packet.output_components,
+            inputs,
+            outputs,
+        })?;
+        profile.kernel_call += kernel_started.elapsed();
+        profile.backend_call_count = profile.backend_call_count.saturating_add(1);
+
+        let scatter_started = Instant::now();
+        if let Some(linear) = &packet.linear_finalization {
+            super::execute::scatter_linear_finalizations(
+                items,
+                linear,
+                outputs,
+                lane_count,
+                tile_points,
+                workspace.tile_capacity,
+                &workspace.currents,
+                &mut workspace.values,
+            )?;
+        } else {
+            super::execute::scatter_finalizations(
+                items,
+                outputs,
+                lane_count,
+                tile_points,
+                workspace.tile_capacity,
+                &mut workspace.values,
+            )?;
+        }
+        profile.finalization += scatter_started.elapsed();
+    }
+    Ok(())
+}
+
+#[allow(dead_code)] // Retained by the explicit packet-scheduler profiling oracle.
+pub(super) fn execute_closures_profiled<B: EagerKernelBackend>(
+    rows: ClosureExecutionRows<'_>,
+    packets: &[KernelPacket],
+    workspace: &mut EagerWorkspace,
+    backend: &mut B,
+    tile_points: usize,
+    model_parameters: &[EagerComplex64],
+    profile: &mut EagerExecutionProfile,
+) -> RusticolResult<()> {
+    for packet in packets {
+        debug_assert_eq!(packet.role, PacketRole::Closure);
+        let items = &rows.closures[packet.item_range.clone()];
+        let lane_count = items.len() * tile_points;
+        let input_len = packet.input_components * lane_count;
+        let output_len = packet.output_components * lane_count;
+        let (inputs, outputs) = packet_slices(&mut workspace.packet, input_len, output_len)?;
+        let kernel = rows.kernels.get(&packet.kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!(
+                "eager schedule lost closure kernel {}",
+                packet.kernel_id
+            ))
+        })?;
+
+        let gather_started = Instant::now();
+        super::execute::gather_closures(
+            items,
+            &kernel.inputs,
+            inputs,
+            packet.input_components,
+            tile_points,
+            workspace.tile_capacity,
+            &workspace.values,
+            &workspace.couplings,
+            model_parameters,
+        );
+        profile.closure += gather_started.elapsed();
+
+        let kernel_started = Instant::now();
+        backend.evaluate_batch(EagerKernelCall {
+            kernel_id: packet.kernel_id,
+            independent_block_size: 1,
+            lane_count,
+            input_component_count: packet.input_components,
+            output_component_count: packet.output_components,
+            inputs,
+            outputs,
+        })?;
+        profile.kernel_call += kernel_started.elapsed();
+        profile.backend_call_count = profile.backend_call_count.saturating_add(1);
+
+        let scatter_started = Instant::now();
+        super::execute::scatter_closures(
+            items,
+            outputs,
+            lane_count,
+            tile_points,
+            workspace.tile_capacity,
+            &workspace.couplings,
+            &mut workspace.amplitudes,
+        );
+        profile.closure += scatter_started.elapsed();
+    }
+
+    let direct_started = Instant::now();
+    super::execute::execute_direct_closures(
+        rows.direct_closures,
+        &workspace.values,
+        workspace.tile_capacity,
+        tile_points,
+        &mut workspace.amplitudes,
+    );
+    profile.closure += direct_started.elapsed();
+    Ok(())
+}
+
+#[allow(dead_code)] // Shared only by the retained profiled packet-scheduler path.
+fn packet_slices(
+    packet: &mut [EagerComplex64],
+    input_len: usize,
+    output_len: usize,
+) -> RusticolResult<(&mut [EagerComplex64], &mut [EagerComplex64])> {
+    let total = input_len
+        .checked_add(output_len)
+        .ok_or_else(|| RusticolError::internal("eager active packet size overflows"))?;
+    if total > packet.len() {
+        return Err(RusticolError::internal(format!(
+            "eager active packet needs {total} elements, workspace has {}",
+            packet.len()
+        )));
+    }
+    let active = &mut packet[..total];
+    Ok(active.split_at_mut(input_len))
+}
+
+#[allow(dead_code)] // Shared only by the retained profiled packet-scheduler path.
+fn copy_component_range(
+    source: &[EagerComplex64],
+    source_range: ComponentRange,
+    target: &mut [EagerComplex64],
+    target_range: ComponentRange,
+    stride: usize,
+    point_count: usize,
+) {
+    debug_assert_eq!(source_range.len, target_range.len);
+    for component in 0..source_range.len {
+        let source_start = (source_range.start + component) * stride;
+        let target_start = (target_range.start + component) * stride;
+        target[target_start..target_start + point_count]
+            .copy_from_slice(&source[source_start..source_start + point_count]);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/runtime.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/runtime.rs
new file mode 100644
index 0000000000..c77fc9238b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_runtime/runtime.rs
@@ -0,0 +1,2824 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::execute::{
+    copy_selected_tile_amplitudes, copy_tile_amplitudes, copy_tile_results, execute_closures,
+    execute_stage, initialize_tile, reduce_selected_tile, reduce_tile,
+};
+use super::plan::{
+    ClosureExecutionRows, ComponentRange, EagerExecutionPlan, EagerStagePlan, ScheduledClosure,
+    ScheduledDirectClosure, ScheduledFinalization, complex_is_finite,
+};
+use super::profile::{execute_closures_profiled, execute_stage_profiled};
+use super::{
+    EagerComplex64, EagerExecutionProfile, EagerKernelBackend, EagerKernelSpec,
+    EagerRuntimeOptions, EagerScheduleAuditRow,
+};
+use crate::{EagerCouplingRow, MISSING_U32, RusticolError, RusticolResult};
+use std::cmp::min;
+use std::collections::BTreeMap;
+use std::mem::size_of;
+use std::ops::Range;
+use std::time::Instant;
+
+// `workspace_bytes` controls batching, not the maximum process size. Keeping
+// one gather/evaluate/scatter packet cache-sized avoids turning otherwise
+// linear eager execution into a memory-bandwidth workload when many
+// invocations share one prepared kernel.
+const MAX_PACKET_BUFFER_BYTES: usize = 4 * 1024 * 1024;
+const MAX_PERSISTENT_TILE_BYTES: usize = 16 * 1024 * 1024;
+const PREFERRED_TILE_ALIGNMENT: usize = 8;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum PacketRole {
+    Invocation,
+    Finalization,
+    Closure,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct KernelPacket {
+    pub(super) role: PacketRole,
+    pub(super) kernel_id: u32,
+    pub(super) independent_block_size: usize,
+    pub(super) item_range: Range<usize>,
+    pub(super) input_components: usize,
+    pub(super) output_components: usize,
+    pub(super) linear_finalization: Option<LinearFinalizationPacket>,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct LinearFinalizationPacket {
+    pub(super) momentum_groups: Vec<ComponentRange>,
+    pub(super) item_group_indices: Vec<usize>,
+    pub(super) current_components: Vec<u32>,
+}
+
+impl LinearFinalizationPacket {
+    pub(super) fn lane_multiplier(&self) -> usize {
+        self.momentum_groups.len() * self.current_components.len()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct StageSchedule {
+    pub(super) invocation_packets: Vec<KernelPacket>,
+    pub(super) finalization_packets: Vec<KernelPacket>,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ExecutionSchedule {
+    pub(super) stages: Vec<StageSchedule>,
+    pub(super) closure_packets: Vec<KernelPacket>,
+    packet_buffer_len: usize,
+}
+
+#[derive(Clone, Debug)]
+struct SelectedExecution {
+    active_groups: Vec<u32>,
+    active_amplitude_indices: Vec<usize>,
+    active_reduction_group_indices: Vec<usize>,
+    active_reduction_group_ids: Vec<u32>,
+    active_reduction_entry_indices: Vec<usize>,
+    stages: Vec<EagerStagePlan>,
+    closures: Vec<ScheduledClosure>,
+    direct_closures: Vec<ScheduledDirectClosure>,
+    zero_amplitude_indices: Vec<usize>,
+    active_zero_amplitude_indices: Vec<usize>,
+    schedule: ExecutionSchedule,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct PointSelectorWorkGroup {
+    execution_index: Option<usize>,
+    point_start: usize,
+    point_count: usize,
+}
+
+#[derive(Debug, Default)]
+struct PointSelectedExecution {
+    signature_offsets: Vec<usize>,
+    signature_groups: Vec<u32>,
+    point_work_group_ids: Vec<usize>,
+    grouped_point_indices: Vec<usize>,
+    work_group_cursors: Vec<usize>,
+    work_groups: Vec<PointSelectorWorkGroup>,
+    executions: Vec<SelectedExecution>,
+    gathered_initial_values: Vec<EagerComplex64>,
+    gathered_momenta: Vec<f64>,
+    gathered_group_weights: Vec<f64>,
+}
+
+#[allow(dead_code)]
+enum PointSelectorInput<'a> {
+    OneGroupPerPoint(&'a [u32]),
+    GroupSets {
+        offsets: &'a [usize],
+        groups: &'a [u32],
+    },
+}
+
+impl PointSelectorInput<'_> {
+    fn point_count(&self) -> usize {
+        match self {
+            Self::OneGroupPerPoint(groups) => groups.len(),
+            Self::GroupSets { offsets, .. } => offsets.len().saturating_sub(1),
+        }
+    }
+
+    fn groups_for_point(&self, point: usize) -> &[u32] {
+        match self {
+            Self::OneGroupPerPoint(groups) => &groups[point..point + 1],
+            Self::GroupSets { offsets, groups } => &groups[offsets[point]..offsets[point + 1]],
+        }
+    }
+
+    fn group_offset_for_point(&self, point: usize) -> usize {
+        match self {
+            Self::OneGroupPerPoint(_) => point,
+            Self::GroupSets { offsets, .. } => offsets[point],
+        }
+    }
+
+    fn group_entry_count(&self) -> usize {
+        match self {
+            Self::OneGroupPerPoint(groups) => groups.len(),
+            Self::GroupSets { groups, .. } => groups.len(),
+        }
+    }
+
+    fn matches_signature(&self, signature_offsets: &[usize], signature_groups: &[u32]) -> bool {
+        match self {
+            Self::OneGroupPerPoint(groups) => {
+                signature_groups == *groups
+                    && signature_offsets.len() == groups.len() + 1
+                    && signature_offsets.iter().copied().eq(0..=groups.len())
+            }
+            Self::GroupSets { offsets, groups } => {
+                signature_offsets == *offsets && signature_groups == *groups
+            }
+        }
+    }
+
+    fn store_signature(&self, offsets: &mut Vec<usize>, groups: &mut Vec<u32>) {
+        offsets.clear();
+        groups.clear();
+        match self {
+            Self::OneGroupPerPoint(selected) => {
+                offsets.extend(0..=selected.len());
+                groups.extend_from_slice(selected);
+            }
+            Self::GroupSets {
+                offsets: selected_offsets,
+                groups: selected_groups,
+            } => {
+                offsets.extend_from_slice(selected_offsets);
+                groups.extend_from_slice(selected_groups);
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct EagerWorkspace {
+    pub(super) tile_capacity: usize,
+    pub(super) values: Vec<EagerComplex64>,
+    pub(super) currents: Vec<EagerComplex64>,
+    pub(super) amplitudes: Vec<EagerComplex64>,
+    pub(super) reduction_groups: Vec<EagerComplex64>,
+    pub(super) couplings: Vec<EagerComplex64>,
+    pub(super) reduced: Vec<f64>,
+    pub(super) packet: Vec<EagerComplex64>,
+}
+
+#[derive(Debug)]
+pub struct EagerExecutionRuntime {
+    plan: EagerExecutionPlan,
+    schedule: ExecutionSchedule,
+    workspace: EagerWorkspace,
+    workspace_bytes: usize,
+    packet_budget: usize,
+    selected: Option<SelectedExecution>,
+    point_selected: PointSelectedExecution,
+}
+
+impl EagerExecutionRuntime {
+    pub fn new(plan: EagerExecutionPlan, options: EagerRuntimeOptions) -> RusticolResult<Self> {
+        if options.point_tile_size == 0 {
+            return Err(RusticolError::invalid_argument(
+                "eager point tile size must be positive",
+            ));
+        }
+        let complex_bytes = size_of::<EagerComplex64>();
+        let static_bytes = plan
+            .couplings
+            .len()
+            .checked_mul(complex_bytes)
+            .ok_or_else(|| RusticolError::invalid_argument("eager coupling workspace overflows"))?;
+        let persistent_complex_components = plan
+            .values
+            .component_count
+            .checked_add(plan.current_workspace_component_count())
+            .and_then(|value| value.checked_add(plan.amplitude_count))
+            .and_then(|value| value.checked_add(plan.reduction_groups.len()))
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("eager persistent workspace overflows")
+            })?;
+        let persistent_bytes_per_point = persistent_complex_components
+            .checked_mul(complex_bytes)
+            .and_then(|value| value.checked_add(size_of::<f64>()))
+            .ok_or_else(|| RusticolError::invalid_argument("eager point workspace overflows"))?;
+        let largest_kernel_io = used_kernel_io_components(&plan)?;
+        let minimum_bytes_per_point = largest_kernel_io
+            .checked_mul(complex_bytes)
+            .and_then(|value| value.checked_add(persistent_bytes_per_point))
+            .ok_or_else(|| RusticolError::invalid_argument("eager packet workspace overflows"))?;
+        let dynamic_bytes = options
+            .workspace_bytes
+            .saturating_sub(static_bytes)
+            .max(minimum_bytes_per_point);
+        let workspace_maximum_tile = dynamic_bytes
+            .checked_div(minimum_bytes_per_point)
+            .unwrap_or(0);
+        let tile_capacity = effective_tile_capacity(
+            options.point_tile_size,
+            workspace_maximum_tile,
+            persistent_bytes_per_point,
+        );
+        let persistent_bytes = persistent_bytes_per_point
+            .checked_mul(tile_capacity)
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("eager persistent workspace overflows")
+            })?;
+        let packet_budget = dynamic_bytes
+            .checked_sub(persistent_bytes)
+            .ok_or_else(|| {
+                RusticolError::internal("eager workspace accounting lost its packet budget")
+            })?
+            .min(
+                MAX_PACKET_BUFFER_BYTES.max(
+                    largest_kernel_io
+                        .checked_mul(complex_bytes)
+                        .and_then(|bytes| bytes.checked_mul(tile_capacity))
+                        .ok_or_else(|| {
+                            RusticolError::invalid_argument("eager packet size overflows")
+                        })?,
+                ),
+            );
+        let schedule = build_schedule(&plan, tile_capacity, packet_budget)?;
+        let workspace = allocate_workspace(&plan, tile_capacity, schedule.packet_buffer_len)?;
+        let workspace_bytes = static_bytes
+            .checked_add(persistent_bytes)
+            .and_then(|value| {
+                schedule
+                    .packet_buffer_len
+                    .checked_mul(complex_bytes)
+                    .and_then(|packet| value.checked_add(packet))
+            })
+            .ok_or_else(|| RusticolError::invalid_argument("eager workspace size overflows"))?;
+        Ok(Self {
+            plan,
+            schedule,
+            workspace,
+            workspace_bytes,
+            packet_budget,
+            selected: None,
+            point_selected: PointSelectedExecution::default(),
+        })
+    }
+
+    pub fn plan(&self) -> &EagerExecutionPlan {
+        &self.plan
+    }
+
+    pub fn effective_point_tile_size(&self) -> usize {
+        self.workspace.tile_capacity
+    }
+
+    pub fn workspace_bytes(&self) -> usize {
+        self.workspace_bytes
+    }
+
+    pub fn packet_count(&self) -> usize {
+        self.schedule
+            .stages
+            .iter()
+            .map(|stage| stage.invocation_packets.len() + stage.finalization_packets.len())
+            .sum::<usize>()
+            + self.schedule.closure_packets.len()
+    }
+
+    #[allow(dead_code)] // Retained for the opt-in Direct-Arena/packet schedule oracle.
+    pub(crate) fn schedule_audit(
+        &mut self,
+        active_groups: Option<&[u32]>,
+    ) -> RusticolResult<Vec<EagerScheduleAuditRow>> {
+        if let Some(groups) = active_groups {
+            self.prepare_selected_execution(groups)?;
+        }
+        let (stages, closures, direct_closures, _, schedule) = selected_execution_rows(
+            &self.plan,
+            &self.schedule,
+            self.selected.as_ref(),
+            active_groups.is_some(),
+        );
+        let mut rows = Vec::new();
+        for (stage, stage_schedule) in stages.iter().zip(&schedule.stages) {
+            for packet in &stage_schedule.invocation_packets {
+                let items = &stage.invocations[packet.item_range.clone()];
+                rows.push(EagerScheduleAuditRow {
+                    stage_index: Some(stage.stage_index),
+                    role: "invocation",
+                    kernel_id: Some(packet.kernel_id),
+                    call_count: 1,
+                    row_count: items.len(),
+                    destination_count: items.iter().map(|item| item.attachment_range.len()).sum(),
+                });
+            }
+            if !stage.finalization_copies.is_empty() {
+                rows.push(EagerScheduleAuditRow {
+                    stage_index: Some(stage.stage_index),
+                    role: "copy",
+                    kernel_id: None,
+                    call_count: 0,
+                    row_count: stage.finalization_copies.len(),
+                    destination_count: stage
+                        .finalization_copies
+                        .iter()
+                        .map(|item| item.current.len)
+                        .sum(),
+                });
+            }
+            for packet in &stage_schedule.finalization_packets {
+                let items = &stage.finalizations[packet.item_range.clone()];
+                rows.push(EagerScheduleAuditRow {
+                    stage_index: Some(stage.stage_index),
+                    role: "finalization",
+                    kernel_id: Some(packet.kernel_id),
+                    call_count: 1,
+                    row_count: items.len(),
+                    destination_count: items.len(),
+                });
+            }
+        }
+        for packet in &schedule.closure_packets {
+            let items = &closures[packet.item_range.clone()];
+            rows.push(EagerScheduleAuditRow {
+                stage_index: None,
+                role: "closure",
+                kernel_id: Some(packet.kernel_id),
+                call_count: 1,
+                row_count: items.len(),
+                destination_count: items.len(),
+            });
+        }
+        if !direct_closures.is_empty() {
+            rows.push(EagerScheduleAuditRow {
+                stage_index: None,
+                role: "direct-closure",
+                kernel_id: None,
+                call_count: 0,
+                row_count: direct_closures.len(),
+                destination_count: direct_closures.len(),
+            });
+        }
+        Ok(rows)
+    }
+
+    pub fn selector_group_ids(&self) -> Option<Vec<u32>> {
+        let domains = self.plan.selector_domains.as_ref()?;
+        Some(domains.group_ids.clone())
+    }
+
+    /// Evaluates one already-resolved coherent selector group per logical point.
+    ///
+    /// This is an internal bridge for the native runtime selector planner. It
+    /// deliberately accepts coherent group IDs rather than public helicity or
+    /// colour labels; the engine resolves those labels before entering the
+    /// eager scheduler.
+    #[allow(clippy::too_many_arguments)]
+    #[allow(dead_code)]
+    pub(crate) fn evaluate_point_selected_groups_into<B: EagerKernelBackend>(
+        &mut self,
+        backend: &mut B,
+        groups_by_point: &[u32],
+        active_group_weights: &[f64],
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        reduced: &mut [f64],
+    ) -> RusticolResult<()> {
+        self.evaluate_point_selected_impl(
+            backend,
+            PointSelectorInput::OneGroupPerPoint(groups_by_point),
+            active_group_weights,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            reduced,
+        )
+    }
+
+    /// Evaluates one pre-resolved active coherent-group set per logical point.
+    ///
+    /// `group_offsets` has `point_count + 1` entries and slices
+    /// `active_groups`. Every non-empty set must be sorted and unique. Empty
+    /// sets are valid and represent a certified structural-zero selector.
+    #[allow(clippy::too_many_arguments)]
+    #[allow(dead_code)] // Retained as the order-preserving benchmark reference lane.
+    pub(crate) fn evaluate_point_selected_group_sets_into<B: EagerKernelBackend>(
+        &mut self,
+        backend: &mut B,
+        group_offsets: &[usize],
+        active_groups: &[u32],
+        active_group_weights: &[f64],
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        reduced: &mut [f64],
+    ) -> RusticolResult<()> {
+        self.evaluate_point_selected_impl(
+            backend,
+            PointSelectorInput::GroupSets {
+                offsets: group_offsets,
+                groups: active_groups,
+            },
+            active_group_weights,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            reduced,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn evaluate_point_selected_impl<B: EagerKernelBackend>(
+        &mut self,
+        backend: &mut B,
+        selectors: PointSelectorInput<'_>,
+        active_group_weights: &[f64],
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        reduced: &mut [f64],
+    ) -> RusticolResult<()> {
+        validate_point_selected_execution_buffers(
+            &self.plan,
+            &selectors,
+            active_group_weights,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            reduced,
+        )?;
+        validate_model_parameters(model_parameters)?;
+        self.prepare_point_selected_execution(&selectors)?;
+        resolve_couplings(
+            &self.plan.couplings,
+            model_parameters,
+            &mut self.workspace.couplings,
+        );
+        reduced.fill(0.0);
+
+        let Self {
+            plan,
+            workspace,
+            point_selected,
+            ..
+        } = self;
+        let PointSelectedExecution {
+            grouped_point_indices,
+            work_groups,
+            executions,
+            gathered_initial_values,
+            gathered_momenta,
+            gathered_group_weights,
+            ..
+        } = point_selected;
+        let tile_capacity = workspace.tile_capacity;
+        for work_group in work_groups.iter().copied() {
+            let Some(execution_index) = work_group.execution_index else {
+                continue;
+            };
+            let execution = executions.get(execution_index).ok_or_else(|| {
+                RusticolError::internal("eager point selector lost its cached execution")
+            })?;
+            let point_stop = work_group
+                .point_start
+                .checked_add(work_group.point_count)
+                .ok_or_else(|| RusticolError::internal("eager point work range overflows"))?;
+            let points = grouped_point_indices
+                .get(work_group.point_start..point_stop)
+                .ok_or_else(|| RusticolError::internal("eager point work range is invalid"))?;
+            for point_tile in points.chunks(tile_capacity) {
+                gather_point_components(
+                    initial_values,
+                    plan.values.component_count,
+                    point_count,
+                    point_tile,
+                    gathered_initial_values,
+                )?;
+                gather_point_components(
+                    momenta,
+                    plan.momenta.component_count,
+                    point_count,
+                    point_tile,
+                    gathered_momenta,
+                )?;
+                let tile_points = point_tile.len();
+                gather_selected_group_weights(
+                    &selectors,
+                    active_group_weights,
+                    &execution.active_reduction_group_ids,
+                    point_tile,
+                    gathered_group_weights,
+                )?;
+                initialize_tile(
+                    plan,
+                    workspace,
+                    tile_points,
+                    0,
+                    tile_points,
+                    gathered_initial_values,
+                    &execution.active_zero_amplitude_indices,
+                );
+                for (stage, stage_schedule) in
+                    execution.stages.iter().zip(&execution.schedule.stages)
+                {
+                    execute_stage(
+                        stage,
+                        stage_schedule,
+                        &plan.kernels,
+                        workspace,
+                        backend,
+                        tile_points,
+                        0,
+                        tile_points,
+                        gathered_momenta,
+                        model_parameters,
+                    )?;
+                }
+                execute_closures(
+                    ClosureExecutionRows {
+                        closures: &execution.closures,
+                        direct_closures: &execution.direct_closures,
+                        kernels: &plan.kernels,
+                    },
+                    &execution.schedule.closure_packets,
+                    workspace,
+                    backend,
+                    tile_points,
+                    model_parameters,
+                )?;
+                reduce_selected_tile(
+                    plan,
+                    &execution.active_reduction_group_indices,
+                    &execution.active_reduction_entry_indices,
+                    gathered_group_weights,
+                    workspace,
+                    tile_points,
+                )?;
+                for (tile_point, original_point) in point_tile.iter().copied().enumerate() {
+                    reduced[original_point] = workspace.reduced[tile_point];
+                }
+            }
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn evaluate_selected_amplitudes_into<B: EagerKernelBackend>(
+        &mut self,
+        backend: &mut B,
+        active_groups: &[u32],
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        amplitudes: &mut [EagerComplex64],
+    ) -> RusticolResult<()> {
+        self.evaluate_selected_amplitudes_impl(
+            backend,
+            active_groups,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            amplitudes,
+            false,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    #[allow(dead_code)] // Retained for the packet-scheduler selector oracle.
+    pub(crate) fn evaluate_selected_active_amplitudes_into<B: EagerKernelBackend>(
+        &mut self,
+        backend: &mut B,
+        active_groups: &[u32],
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        amplitudes: &mut [EagerComplex64],
+    ) -> RusticolResult<()> {
+        self.evaluate_selected_amplitudes_impl(
+            backend,
+            active_groups,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            amplitudes,
+            true,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn evaluate_selected_amplitudes_impl<B: EagerKernelBackend>(
+        &mut self,
+        backend: &mut B,
+        active_groups: &[u32],
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        amplitudes: &mut [EagerComplex64],
+        active_amplitudes_only: bool,
+    ) -> RusticolResult<()> {
+        validate_selected_execution_buffers(
+            &self.plan,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            amplitudes,
+        )?;
+        validate_model_parameters(model_parameters)?;
+        self.prepare_selected_execution(active_groups)?;
+        let (plan, full_schedule, selected, workspace) = (
+            &self.plan,
+            &self.schedule,
+            &self.selected,
+            &mut self.workspace,
+        );
+        resolve_couplings(&plan.couplings, model_parameters, &mut workspace.couplings);
+        let (stages, closures, direct_closures, zero_amplitudes, schedule) =
+            selected_execution_rows(
+                plan,
+                full_schedule,
+                selected.as_ref(),
+                active_amplitudes_only,
+            );
+        let active_amplitude_indices = selected
+            .as_ref()
+            .map(|selected| selected.active_amplitude_indices.as_slice());
+        let tile_capacity = workspace.tile_capacity;
+        let mut tile_start = 0usize;
+        while tile_start < point_count {
+            let tile_points = min(tile_capacity, point_count - tile_start);
+            initialize_tile(
+                plan,
+                workspace,
+                point_count,
+                tile_start,
+                tile_points,
+                initial_values,
+                zero_amplitudes,
+            );
+            for (stage, stage_schedule) in stages.iter().zip(&schedule.stages) {
+                execute_stage(
+                    stage,
+                    stage_schedule,
+                    &plan.kernels,
+                    workspace,
+                    backend,
+                    point_count,
+                    tile_start,
+                    tile_points,
+                    momenta,
+                    model_parameters,
+                )?;
+            }
+            execute_closures(
+                ClosureExecutionRows {
+                    closures,
+                    direct_closures,
+                    kernels: &plan.kernels,
+                },
+                &schedule.closure_packets,
+                workspace,
+                backend,
+                tile_points,
+                model_parameters,
+            )?;
+            if active_amplitudes_only {
+                copy_selected_tile_amplitudes(
+                    active_amplitude_indices.unwrap_or(&[]),
+                    workspace,
+                    point_count,
+                    tile_start,
+                    tile_points,
+                    amplitudes,
+                );
+            } else {
+                copy_tile_amplitudes(
+                    plan,
+                    workspace,
+                    point_count,
+                    tile_start,
+                    tile_points,
+                    amplitudes,
+                );
+            }
+            tile_start += tile_points;
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    #[allow(dead_code)] // Retained for the packet-scheduler profiling oracle.
+    pub(crate) fn evaluate_selected_amplitudes_profile_into<B: EagerKernelBackend>(
+        &mut self,
+        backend: &mut B,
+        active_groups: &[u32],
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        amplitudes: &mut [EagerComplex64],
+    ) -> RusticolResult<EagerExecutionProfile> {
+        validate_selected_execution_buffers(
+            &self.plan,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            amplitudes,
+        )?;
+        validate_model_parameters(model_parameters)?;
+        let total_started = Instant::now();
+        self.prepare_selected_execution(active_groups)?;
+        let (plan, full_schedule, selected, workspace) = (
+            &self.plan,
+            &self.schedule,
+            &self.selected,
+            &mut self.workspace,
+        );
+        let initialize_started = Instant::now();
+        resolve_couplings(&plan.couplings, model_parameters, &mut workspace.couplings);
+        let mut profile = EagerExecutionProfile {
+            initialize: initialize_started.elapsed(),
+            ..EagerExecutionProfile::default()
+        };
+        let (stages, closures, direct_closures, zero_amplitudes, schedule) =
+            selected_execution_rows(plan, full_schedule, selected.as_ref(), true);
+        let active_amplitude_indices = selected
+            .as_ref()
+            .map(|selected| selected.active_amplitude_indices.as_slice());
+        let tile_capacity = workspace.tile_capacity;
+        let mut tile_start = 0usize;
+        while tile_start < point_count {
+            let tile_points = min(tile_capacity, point_count - tile_start);
+            let initialize_started = Instant::now();
+            initialize_tile(
+                plan,
+                workspace,
+                point_count,
+                tile_start,
+                tile_points,
+                initial_values,
+                zero_amplitudes,
+            );
+            profile.initialize += initialize_started.elapsed();
+            for (stage, stage_schedule) in stages.iter().zip(&schedule.stages) {
+                execute_stage_profiled(
+                    stage,
+                    stage_schedule,
+                    &plan.kernels,
+                    workspace,
+                    backend,
+                    point_count,
+                    tile_start,
+                    tile_points,
+                    momenta,
+                    model_parameters,
+                    &mut profile,
+                )?;
+            }
+            execute_closures_profiled(
+                ClosureExecutionRows {
+                    closures,
+                    direct_closures,
+                    kernels: &plan.kernels,
+                },
+                &schedule.closure_packets,
+                workspace,
+                backend,
+                tile_points,
+                model_parameters,
+                &mut profile,
+            )?;
+            let copy_started = Instant::now();
+            copy_selected_tile_amplitudes(
+                active_amplitude_indices.unwrap_or(&[]),
+                workspace,
+                point_count,
+                tile_start,
+                tile_points,
+                amplitudes,
+            );
+            profile.copy_out += copy_started.elapsed();
+            tile_start += tile_points;
+        }
+        profile.total = total_started.elapsed();
+        Ok(profile)
+    }
+
+    fn prepare_selected_execution(&mut self, active_groups: &[u32]) -> RusticolResult<()> {
+        if active_groups.windows(2).any(|pair| pair[0] >= pair[1]) {
+            return Err(RusticolError::invalid_argument(
+                "eager active selector groups must be sorted and unique",
+            ));
+        }
+        if self.plan.selector_domains.is_none() {
+            self.selected = None;
+            return Ok(());
+        }
+        let selector_domains = self
+            .plan
+            .selector_domains
+            .as_ref()
+            .expect("selector domains were checked above");
+        if let Some(unknown) = active_groups
+            .iter()
+            .find(|group| selector_domains.group_ids.binary_search(group).is_err())
+        {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager selector references unknown coherent group {unknown}"
+            )));
+        }
+        if self
+            .selected
+            .as_ref()
+            .is_some_and(|selected| selected.active_groups == active_groups)
+        {
+            return Ok(());
+        }
+        self.selected = Some(build_selected_execution(
+            &self.plan,
+            active_groups,
+            self.workspace.tile_capacity,
+            self.packet_budget,
+        )?);
+        Ok(())
+    }
+
+    fn prepare_point_selected_execution(
+        &mut self,
+        selectors: &PointSelectorInput<'_>,
+    ) -> RusticolResult<()> {
+        if selectors.matches_signature(
+            &self.point_selected.signature_offsets,
+            &self.point_selected.signature_groups,
+        ) {
+            return Ok(());
+        }
+        let selector_domains = self.plan.selector_domains.as_ref().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "eager per-point selectors require selector-domain metadata",
+            )
+        })?;
+
+        self.point_selected.point_work_group_ids.clear();
+        self.point_selected.work_groups.clear();
+        self.point_selected
+            .point_work_group_ids
+            .try_reserve(selectors.point_count())
+            .map_err(|error| {
+                RusticolError::invalid_argument(format!(
+                    "could not reserve eager point selector work items: {error}"
+                ))
+            })?;
+
+        for point in 0..selectors.point_count() {
+            let groups = selectors.groups_for_point(point);
+            validate_point_group_set(groups, &selector_domains.group_ids, point)?;
+            let execution_index = if groups.is_empty() {
+                None
+            } else if let Some(index) = self
+                .point_selected
+                .executions
+                .iter()
+                .position(|execution| execution.active_groups == groups)
+            {
+                Some(index)
+            } else {
+                let execution = build_selected_execution(
+                    &self.plan,
+                    groups,
+                    self.workspace.tile_capacity,
+                    self.packet_budget,
+                )?;
+                self.point_selected.executions.push(execution);
+                Some(self.point_selected.executions.len() - 1)
+            };
+            let work_group_id = self
+                .point_selected
+                .work_groups
+                .iter()
+                .position(|work| work.execution_index == execution_index)
+                .unwrap_or_else(|| {
+                    self.point_selected
+                        .work_groups
+                        .push(PointSelectorWorkGroup {
+                            execution_index,
+                            point_start: 0,
+                            point_count: 0,
+                        });
+                    self.point_selected.work_groups.len() - 1
+                });
+            self.point_selected.work_groups[work_group_id].point_count += 1;
+            self.point_selected.point_work_group_ids.push(work_group_id);
+        }
+
+        let mut cursor = 0usize;
+        self.point_selected.work_group_cursors.clear();
+        self.point_selected
+            .work_group_cursors
+            .try_reserve(self.point_selected.work_groups.len())
+            .map_err(|error| {
+                RusticolError::invalid_argument(format!(
+                    "could not reserve eager point selector cursors: {error}"
+                ))
+            })?;
+        for work in &mut self.point_selected.work_groups {
+            work.point_start = cursor;
+            cursor = cursor.checked_add(work.point_count).ok_or_else(|| {
+                RusticolError::invalid_argument("eager point selector work range overflows")
+            })?;
+            self.point_selected
+                .work_group_cursors
+                .push(work.point_start);
+        }
+        self.point_selected.grouped_point_indices.clear();
+        self.point_selected
+            .grouped_point_indices
+            .try_reserve(cursor)
+            .map_err(|error| {
+                RusticolError::invalid_argument(format!(
+                    "could not reserve eager grouped point indices: {error}"
+                ))
+            })?;
+        self.point_selected.grouped_point_indices.resize(cursor, 0);
+        for (point, work_group_id) in self
+            .point_selected
+            .point_work_group_ids
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            let target = self.point_selected.work_group_cursors[work_group_id];
+            self.point_selected.grouped_point_indices[target] = point;
+            self.point_selected.work_group_cursors[work_group_id] += 1;
+        }
+        selectors.store_signature(
+            &mut self.point_selected.signature_offsets,
+            &mut self.point_selected.signature_groups,
+        );
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn evaluate_into<B: EagerKernelBackend>(
+        &mut self,
+        backend: &mut B,
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        amplitudes: &mut [EagerComplex64],
+        reduced: &mut [f64],
+    ) -> RusticolResult<()> {
+        validate_execution_buffers(
+            &self.plan,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            amplitudes,
+            reduced,
+        )?;
+        if model_parameters
+            .iter()
+            .any(|value| !complex_is_finite(*value))
+        {
+            return Err(RusticolError::invalid_argument(
+                "eager model parameters must be finite",
+            ));
+        }
+        resolve_couplings(
+            &self.plan.couplings,
+            model_parameters,
+            &mut self.workspace.couplings,
+        );
+        let tile_capacity = self.workspace.tile_capacity;
+        let mut tile_start = 0usize;
+        while tile_start < point_count {
+            let tile_points = min(tile_capacity, point_count - tile_start);
+            initialize_tile(
+                &self.plan,
+                &mut self.workspace,
+                point_count,
+                tile_start,
+                tile_points,
+                initial_values,
+                &self.plan.zero_amplitude_indices,
+            );
+            for (stage, schedule) in self.plan.stages.iter().zip(&self.schedule.stages) {
+                execute_stage(
+                    stage,
+                    schedule,
+                    &self.plan.kernels,
+                    &mut self.workspace,
+                    backend,
+                    point_count,
+                    tile_start,
+                    tile_points,
+                    momenta,
+                    model_parameters,
+                )?;
+            }
+            execute_closures(
+                ClosureExecutionRows {
+                    closures: &self.plan.closures,
+                    direct_closures: &self.plan.direct_closures,
+                    kernels: &self.plan.kernels,
+                },
+                &self.schedule.closure_packets,
+                &mut self.workspace,
+                backend,
+                tile_points,
+                model_parameters,
+            )?;
+            reduce_tile(&self.plan, &mut self.workspace, tile_points);
+            copy_tile_results(
+                &self.plan,
+                &self.workspace,
+                point_count,
+                tile_start,
+                tile_points,
+                amplitudes,
+                reduced,
+            );
+            tile_start += tile_points;
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    #[allow(dead_code)] // Retained for the packet-scheduler profiling oracle.
+    pub(crate) fn evaluate_profile_into<B: EagerKernelBackend>(
+        &mut self,
+        backend: &mut B,
+        point_count: usize,
+        initial_values: &[EagerComplex64],
+        momenta: &[f64],
+        model_parameters: &[EagerComplex64],
+        amplitudes: &mut [EagerComplex64],
+        reduced: &mut [f64],
+    ) -> RusticolResult<EagerExecutionProfile> {
+        validate_execution_buffers(
+            &self.plan,
+            point_count,
+            initial_values,
+            momenta,
+            model_parameters,
+            amplitudes,
+            reduced,
+        )?;
+        if model_parameters
+            .iter()
+            .any(|value| !complex_is_finite(*value))
+        {
+            return Err(RusticolError::invalid_argument(
+                "eager model parameters must be finite",
+            ));
+        }
+
+        let total_started = Instant::now();
+        let initialize_started = Instant::now();
+        resolve_couplings(
+            &self.plan.couplings,
+            model_parameters,
+            &mut self.workspace.couplings,
+        );
+        let mut profile = EagerExecutionProfile {
+            initialize: initialize_started.elapsed(),
+            ..EagerExecutionProfile::default()
+        };
+        let tile_capacity = self.workspace.tile_capacity;
+        let mut tile_start = 0usize;
+        while tile_start < point_count {
+            let tile_points = min(tile_capacity, point_count - tile_start);
+
+            let initialize_started = Instant::now();
+            initialize_tile(
+                &self.plan,
+                &mut self.workspace,
+                point_count,
+                tile_start,
+                tile_points,
+                initial_values,
+                &self.plan.zero_amplitude_indices,
+            );
+            profile.initialize += initialize_started.elapsed();
+
+            for (stage, schedule) in self.plan.stages.iter().zip(&self.schedule.stages) {
+                execute_stage_profiled(
+                    stage,
+                    schedule,
+                    &self.plan.kernels,
+                    &mut self.workspace,
+                    backend,
+                    point_count,
+                    tile_start,
+                    tile_points,
+                    momenta,
+                    model_parameters,
+                    &mut profile,
+                )?;
+            }
+            execute_closures_profiled(
+                ClosureExecutionRows {
+                    closures: &self.plan.closures,
+                    direct_closures: &self.plan.direct_closures,
+                    kernels: &self.plan.kernels,
+                },
+                &self.schedule.closure_packets,
+                &mut self.workspace,
+                backend,
+                tile_points,
+                model_parameters,
+                &mut profile,
+            )?;
+
+            let reduction_started = Instant::now();
+            reduce_tile(&self.plan, &mut self.workspace, tile_points);
+            profile.reduction += reduction_started.elapsed();
+
+            let copy_started = Instant::now();
+            copy_tile_results(
+                &self.plan,
+                &self.workspace,
+                point_count,
+                tile_start,
+                tile_points,
+                amplitudes,
+                reduced,
+            );
+            profile.copy_out += copy_started.elapsed();
+            tile_start += tile_points;
+        }
+        profile.total = total_started.elapsed();
+        debug_assert!(profile.accounted() <= profile.total);
+        Ok(profile)
+    }
+}
+
+fn effective_tile_capacity(
+    requested_tile: usize,
+    workspace_maximum_tile: usize,
+    persistent_bytes_per_point: usize,
+) -> usize {
+    let cache_maximum_tile = (MAX_PERSISTENT_TILE_BYTES / persistent_bytes_per_point).max(1);
+    let maximum_tile = workspace_maximum_tile.min(cache_maximum_tile);
+    let mut tile_capacity = min(requested_tile, maximum_tile);
+    if tile_capacity < requested_tile && tile_capacity >= PREFERRED_TILE_ALIGNMENT {
+        tile_capacity -= tile_capacity % PREFERRED_TILE_ALIGNMENT;
+    }
+    tile_capacity
+}
+
+fn used_kernel_io_components(plan: &EagerExecutionPlan) -> RusticolResult<usize> {
+    let mut largest = 0usize;
+    let mut record = |kernel_id: u32| -> RusticolResult<()> {
+        let kernel = plan.kernels.get(&kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!("eager schedule lost kernel {kernel_id}"))
+        })?;
+        let count = usize::try_from(kernel.output_component_count)
+            .ok()
+            .and_then(|output| kernel.inputs.len().checked_add(output))
+            .ok_or_else(|| RusticolError::artifact("eager kernel width overflows usize"))?;
+        largest = largest.max(count);
+        Ok(())
+    };
+    for stage in &plan.stages {
+        for item in &stage.invocations {
+            record(item.row.kernel_id)?;
+        }
+        for item in &stage.finalizations {
+            record(item.row.kernel_id)?;
+        }
+    }
+    for item in &plan.closures {
+        record(item.row.kernel_id)?;
+    }
+    Ok(largest.max(1))
+}
+
+fn build_schedule(
+    plan: &EagerExecutionPlan,
+    tile_capacity: usize,
+    packet_budget: usize,
+) -> RusticolResult<ExecutionSchedule> {
+    build_schedule_for_rows(
+        &plan.kernels,
+        &plan.stages,
+        &plan.closures,
+        tile_capacity,
+        packet_budget,
+    )
+}
+
+fn build_schedule_for_rows(
+    kernels: &BTreeMap<u32, EagerKernelSpec>,
+    stage_rows: &[EagerStagePlan],
+    closure_rows: &[ScheduledClosure],
+    tile_capacity: usize,
+    packet_budget: usize,
+) -> RusticolResult<ExecutionSchedule> {
+    let mut stages = Vec::new();
+    stages
+        .try_reserve_exact(stage_rows.len())
+        .map_err(|error| {
+            RusticolError::invalid_argument(format!("could not reserve eager schedule: {error}"))
+        })?;
+    let mut packet_buffer_len = 0usize;
+    for stage in stage_rows {
+        let invocation_packets = packetize(
+            PacketRole::Invocation,
+            &stage
+                .invocations
+                .iter()
+                .map(|item| item.row.kernel_id)
+                .collect::<Vec<_>>(),
+            kernels,
+            tile_capacity,
+            packet_budget,
+            &mut packet_buffer_len,
+        )?;
+        let finalization_ids = stage
+            .finalizations
+            .iter()
+            .map(|item| item.row.kernel_id)
+            .collect::<Vec<_>>();
+        let mut finalization_packets = packetize(
+            PacketRole::Finalization,
+            &finalization_ids,
+            kernels,
+            tile_capacity,
+            packet_budget,
+            &mut packet_buffer_len,
+        )?;
+        configure_linear_finalization_packets(
+            &mut finalization_packets,
+            &stage.finalizations,
+            kernels,
+        )?;
+        stages.push(StageSchedule {
+            invocation_packets,
+            finalization_packets,
+        });
+    }
+    let closure_ids = closure_rows
+        .iter()
+        .map(|item| item.row.kernel_id)
+        .collect::<Vec<_>>();
+    let closure_packets = packetize(
+        PacketRole::Closure,
+        &closure_ids,
+        kernels,
+        tile_capacity,
+        packet_budget,
+        &mut packet_buffer_len,
+    )?;
+    Ok(ExecutionSchedule {
+        stages,
+        closure_packets,
+        packet_buffer_len,
+    })
+}
+
+fn build_selected_execution(
+    plan: &EagerExecutionPlan,
+    active_groups: &[u32],
+    tile_capacity: usize,
+    packet_budget: usize,
+) -> RusticolResult<SelectedExecution> {
+    let domains = plan.selector_domains.as_ref().ok_or_else(|| {
+        RusticolError::internal("cannot build a selected eager plan without selector domains")
+    })?;
+    let domain_active = domains
+        .memberships
+        .iter()
+        .map(|members| {
+            members
+                .iter()
+                .any(|group| active_groups.binary_search(group).is_ok())
+        })
+        .collect::<Vec<_>>();
+    let active = |domain_id: Option<u32>| -> RusticolResult<bool> {
+        let Some(domain_id) = domain_id else {
+            return Ok(true);
+        };
+        domain_active
+            .get(domain_id as usize)
+            .copied()
+            .ok_or_else(|| RusticolError::internal("eager selector domain id escaped validation"))
+    };
+
+    let mut stages = Vec::with_capacity(plan.stages.len());
+    for stage in &plan.stages {
+        let mut invocations = Vec::new();
+        let mut attachments = Vec::new();
+        for invocation in &stage.invocations {
+            if !active(invocation.selector_domain_id)? {
+                continue;
+            }
+            let attachment_start = attachments.len();
+            for attachment in &stage.attachments[invocation.attachment_range.clone()] {
+                if active(attachment.selector_domain_id)? {
+                    attachments.push(*attachment);
+                }
+            }
+            let attachment_count = attachments.len() - attachment_start;
+            if attachment_count == 0 {
+                return Err(RusticolError::internal(
+                    "active eager invocation has no active attachment",
+                ));
+            }
+            let mut invocation = invocation.clone();
+            invocation.attachment_range = attachment_start..attachment_start + attachment_count;
+            invocations.push(invocation);
+        }
+        let mut finalization_copies = Vec::new();
+        for item in &stage.finalization_copies {
+            if active(item.selector_domain_id)? {
+                finalization_copies.push(*item);
+            }
+        }
+        let mut finalizations = Vec::new();
+        for item in &stage.finalizations {
+            if active(item.selector_domain_id)? {
+                finalizations.push(item.clone());
+            }
+        }
+        stages.push(EagerStagePlan {
+            stage_index: stage.stage_index,
+            current_component_count: stage.current_component_count,
+            invocations,
+            attachments,
+            finalization_copies,
+            finalizations,
+            zero_current_ranges: Vec::new(),
+        });
+    }
+    let mut closures = Vec::new();
+    for item in &plan.closures {
+        if active(item.selector_domain_id)? {
+            closures.push(item.clone());
+        }
+    }
+    let mut direct_closures = Vec::new();
+    for item in &plan.direct_closures {
+        if active(item.selector_domain_id)? {
+            direct_closures.push(item.clone());
+        }
+    }
+    for stage in &mut stages {
+        stage.zero_current_ranges = super::plan::mark_initial_current_writes(
+            &stage.invocations,
+            &mut stage.attachments,
+            &stage.finalizations,
+        );
+    }
+    let zero_amplitude_indices = super::plan::mark_initial_amplitude_writes(
+        &mut closures,
+        &mut direct_closures,
+        plan.amplitude_count,
+    );
+    let mut active_amplitude_indices = plan
+        .reduction_groups
+        .iter()
+        .filter(|group| {
+            active_groups
+                .binary_search(&group.coherent_group_id)
+                .is_ok()
+        })
+        .flat_map(|group| group.amplitude_indices.iter().copied())
+        .map(|index| index as usize)
+        .collect::<Vec<_>>();
+    active_amplitude_indices.sort_unstable();
+    active_amplitude_indices.dedup();
+    let active_reduction_group_indices = plan
+        .reduction_groups
+        .iter()
+        .enumerate()
+        .filter_map(|(index, group)| {
+            active_groups
+                .binary_search(&group.coherent_group_id)
+                .is_ok()
+                .then_some(index)
+        })
+        .collect::<Vec<_>>();
+    let active_reduction_entry_indices = plan
+        .reduction_entries
+        .iter()
+        .enumerate()
+        .filter_map(|(index, entry)| {
+            let left = entry.left_group_index as usize;
+            let right = entry.right_group_index as usize;
+            (active_reduction_group_indices.binary_search(&left).is_ok()
+                && active_reduction_group_indices.binary_search(&right).is_ok())
+            .then_some(index)
+        })
+        .collect::<Vec<_>>();
+    let active_reduction_group_ids = active_reduction_group_indices
+        .iter()
+        .map(|index| plan.reduction_groups[*index].coherent_group_id)
+        .collect();
+    let active_zero_amplitude_indices = zero_amplitude_indices
+        .iter()
+        .copied()
+        .filter(|index| active_amplitude_indices.binary_search(index).is_ok())
+        .collect::<Vec<_>>();
+    let schedule = build_schedule_for_rows(
+        &plan.kernels,
+        &stages,
+        &closures,
+        tile_capacity,
+        packet_budget,
+    )?;
+    Ok(SelectedExecution {
+        active_groups: active_groups.to_vec(),
+        active_amplitude_indices,
+        active_reduction_group_indices,
+        active_reduction_group_ids,
+        active_reduction_entry_indices,
+        stages,
+        closures,
+        direct_closures,
+        zero_amplitude_indices,
+        active_zero_amplitude_indices,
+        schedule,
+    })
+}
+
+fn selected_execution_rows<'a>(
+    plan: &'a EagerExecutionPlan,
+    full_schedule: &'a ExecutionSchedule,
+    selected: Option<&'a SelectedExecution>,
+    active_amplitudes_only: bool,
+) -> (
+    &'a [EagerStagePlan],
+    &'a [ScheduledClosure],
+    &'a [ScheduledDirectClosure],
+    &'a [usize],
+    &'a ExecutionSchedule,
+) {
+    if let Some(selected) = selected {
+        return (
+            &selected.stages,
+            &selected.closures,
+            &selected.direct_closures,
+            if active_amplitudes_only {
+                &selected.active_zero_amplitude_indices
+            } else {
+                &selected.zero_amplitude_indices
+            },
+            &selected.schedule,
+        );
+    }
+    (
+        &plan.stages,
+        &plan.closures,
+        &plan.direct_closures,
+        &plan.zero_amplitude_indices,
+        full_schedule,
+    )
+}
+
+fn packetize(
+    role: PacketRole,
+    kernel_ids: &[u32],
+    kernels: &BTreeMap<u32, EagerKernelSpec>,
+    tile_capacity: usize,
+    packet_budget: usize,
+    packet_buffer_len: &mut usize,
+) -> RusticolResult<Vec<KernelPacket>> {
+    // Plan loading stably sorts each role by kernel id. Packetization therefore
+    // scans contiguous equal-kernel runs and never needs a hot-loop dispatch map.
+    let mut packets = Vec::new();
+    let mut start = 0usize;
+    while start < kernel_ids.len() {
+        let kernel_id = kernel_ids[start];
+        let mut run_end = start + 1;
+        while run_end < kernel_ids.len() && kernel_ids[run_end] == kernel_id {
+            run_end += 1;
+        }
+        let kernel = kernels.get(&kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!("eager schedule lost kernel {kernel_id}"))
+        })?;
+        let input_components = kernel.inputs.len();
+        let output_components = usize::try_from(kernel.output_component_count)
+            .map_err(|_| RusticolError::artifact("eager kernel output width does not fit usize"))?;
+        let bytes_per_invocation = input_components
+            .checked_add(output_components)
+            .and_then(|value| value.checked_mul(tile_capacity))
+            .and_then(|value| value.checked_mul(size_of::<EagerComplex64>()))
+            .ok_or_else(|| RusticolError::invalid_argument("eager packet size overflows"))?;
+        let capacity = packet_budget.checked_div(bytes_per_invocation).unwrap_or(0);
+        if capacity == 0 {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager workspace cannot hold one kernel {kernel_id} packet"
+            )));
+        }
+        let requested_block_size = if role == PacketRole::Invocation {
+            usize::try_from(kernel.independent_block_size)
+                .map_err(|_| RusticolError::artifact("eager block size does not fit usize"))?
+        } else {
+            1
+        };
+        let block_size = if requested_block_size > 1 && capacity >= requested_block_size {
+            requested_block_size
+        } else {
+            1
+        };
+        let blocked_end = if block_size > 1 {
+            start + ((run_end - start) / block_size) * block_size
+        } else {
+            start
+        };
+        let mut packet_start = start;
+        let blocked_capacity = (capacity / block_size) * block_size;
+        while packet_start < blocked_end {
+            let packet_end = min(blocked_end, packet_start + blocked_capacity);
+            let invocation_count = packet_end - packet_start;
+            let elements = input_components
+                .checked_add(output_components)
+                .and_then(|value| value.checked_mul(invocation_count))
+                .and_then(|value| value.checked_mul(tile_capacity))
+                .ok_or_else(|| RusticolError::invalid_argument("eager packet size overflows"))?;
+            *packet_buffer_len = (*packet_buffer_len).max(elements);
+            packets.push(KernelPacket {
+                role,
+                kernel_id,
+                independent_block_size: block_size,
+                item_range: packet_start..packet_end,
+                input_components,
+                output_components,
+                linear_finalization: None,
+            });
+            packet_start = packet_end;
+        }
+        while packet_start < run_end {
+            let packet_end = min(run_end, packet_start + capacity);
+            let invocation_count = packet_end - packet_start;
+            let elements = input_components
+                .checked_add(output_components)
+                .and_then(|value| value.checked_mul(invocation_count))
+                .and_then(|value| value.checked_mul(tile_capacity))
+                .ok_or_else(|| RusticolError::invalid_argument("eager packet size overflows"))?;
+            *packet_buffer_len = (*packet_buffer_len).max(elements);
+            packets.push(KernelPacket {
+                role,
+                kernel_id,
+                independent_block_size: 1,
+                item_range: packet_start..packet_end,
+                input_components,
+                output_components,
+                linear_finalization: None,
+            });
+            packet_start = packet_end;
+        }
+        start = run_end;
+    }
+    Ok(packets)
+}
+
+fn configure_linear_finalization_packets(
+    packets: &mut [KernelPacket],
+    rows: &[ScheduledFinalization],
+    kernels: &BTreeMap<u32, EagerKernelSpec>,
+) -> RusticolResult<()> {
+    for packet in packets {
+        let items = &rows[packet.item_range.clone()];
+        let kernel = kernels.get(&packet.kernel_id).ok_or_else(|| {
+            RusticolError::internal(format!(
+                "eager schedule lost finalization kernel {}",
+                packet.kernel_id
+            ))
+        })?;
+        if !kernel.homogeneous_linear_first_current {
+            continue;
+        }
+        let current_components = kernel
+            .inputs
+            .iter()
+            .filter_map(|input| match input {
+                super::EagerKernelInput::FirstCurrentComponent(component) => Some(*component),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        if current_components.is_empty() {
+            continue;
+        }
+
+        let mut momentum_groups = Vec::<ComponentRange>::new();
+        let mut item_group_indices = Vec::with_capacity(items.len());
+        for item in items {
+            let group_index = momentum_groups
+                .iter()
+                .position(|momentum| *momentum == item.momentum)
+                .unwrap_or_else(|| {
+                    momentum_groups.push(item.momentum);
+                    momentum_groups.len() - 1
+                });
+            item_group_indices.push(group_index);
+        }
+        let lane_multiplier = momentum_groups
+            .len()
+            .checked_mul(current_components.len())
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("eager linear finalization overflows")
+            })?;
+        // Basis evaluation is useful only when shared momentum dependence
+        // reduces the number of backend lanes. Otherwise retain the direct
+        // prepared-kernel path and its simpler scatter.
+        if lane_multiplier >= items.len() {
+            continue;
+        }
+        packet.linear_finalization = Some(LinearFinalizationPacket {
+            momentum_groups,
+            item_group_indices,
+            current_components,
+        });
+    }
+    Ok(())
+}
+
+fn allocate_workspace(
+    plan: &EagerExecutionPlan,
+    tile_capacity: usize,
+    packet_buffer_len: usize,
+) -> RusticolResult<EagerWorkspace> {
+    Ok(EagerWorkspace {
+        tile_capacity,
+        values: zeroed_complex_workspace(plan.values.component_count, tile_capacity, "values")?,
+        currents: zeroed_complex_workspace(
+            plan.current_workspace_component_count(),
+            tile_capacity,
+            "currents",
+        )?,
+        amplitudes: zeroed_complex_workspace(plan.amplitude_count, tile_capacity, "amplitudes")?,
+        reduction_groups: zeroed_complex_workspace(
+            plan.reduction_groups.len(),
+            tile_capacity,
+            "reduction groups",
+        )?,
+        couplings: zeroed_complex_values(plan.couplings.len(), "couplings")?,
+        reduced: zeroed_real_values(tile_capacity, "reduction")?,
+        packet: zeroed_complex_values(packet_buffer_len, "packet")?,
+    })
+}
+
+fn zeroed_complex_workspace(
+    component_count: usize,
+    tile_capacity: usize,
+    name: &str,
+) -> RusticolResult<Vec<EagerComplex64>> {
+    let len = component_count.checked_mul(tile_capacity).ok_or_else(|| {
+        RusticolError::invalid_argument(format!("eager {name} workspace overflows"))
+    })?;
+    zeroed_complex_values(len, name)
+}
+
+fn zeroed_complex_values(len: usize, name: &str) -> RusticolResult<Vec<EagerComplex64>> {
+    let mut values = Vec::new();
+    values.try_reserve_exact(len).map_err(|error| {
+        RusticolError::invalid_argument(format!("could not reserve eager {name}: {error}"))
+    })?;
+    values.resize(len, EagerComplex64::new(0.0, 0.0));
+    Ok(values)
+}
+
+fn zeroed_real_values(len: usize, name: &str) -> RusticolResult<Vec<f64>> {
+    let mut values = Vec::new();
+    values.try_reserve_exact(len).map_err(|error| {
+        RusticolError::invalid_argument(format!("could not reserve eager {name}: {error}"))
+    })?;
+    values.resize(len, 0.0);
+    Ok(values)
+}
+
+fn validate_point_group_set(
+    groups: &[u32],
+    known_groups: &[u32],
+    point: usize,
+) -> RusticolResult<()> {
+    for pair in groups.windows(2) {
+        if pair[0] == pair[1] {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager per-point selector {point} duplicates coherent group {}",
+                pair[0]
+            )));
+        }
+        if pair[0] > pair[1] {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager per-point selector {point} groups must be sorted"
+            )));
+        }
+    }
+    if let Some(unknown) = groups
+        .iter()
+        .find(|group| known_groups.binary_search(group).is_err())
+    {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager per-point selector {point} references unknown coherent group {unknown}"
+        )));
+    }
+    Ok(())
+}
+
+fn gather_point_components<T: Copy>(
+    source: &[T],
+    component_count: usize,
+    point_count: usize,
+    point_indices: &[usize],
+    target: &mut Vec<T>,
+) -> RusticolResult<()> {
+    let target_len = component_count
+        .checked_mul(point_indices.len())
+        .ok_or_else(|| RusticolError::invalid_argument("eager point gather length overflows"))?;
+    if target_len == 0 {
+        target.clear();
+        return Ok(());
+    }
+    let fill = source.first().copied().ok_or_else(|| {
+        RusticolError::internal("eager nonempty point gather has an empty source buffer")
+    })?;
+    target.resize(target_len, fill);
+    for component in 0..component_count {
+        let source_start = component * point_count;
+        let target_start = component * point_indices.len();
+        for (target_point, source_point) in point_indices.iter().copied().enumerate() {
+            target[target_start + target_point] = source[source_start + source_point];
+        }
+    }
+    Ok(())
+}
+
+fn gather_selected_group_weights(
+    selectors: &PointSelectorInput<'_>,
+    active_group_weights: &[f64],
+    execution_groups: &[u32],
+    point_indices: &[usize],
+    target: &mut Vec<f64>,
+) -> RusticolResult<()> {
+    let target_len = execution_groups
+        .len()
+        .checked_mul(point_indices.len())
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("eager selected group weight gather overflows")
+        })?;
+    target.resize(target_len, 0.0);
+    for (group_position, group_id) in execution_groups.iter().copied().enumerate() {
+        let target_start = group_position * point_indices.len();
+        for (target_point, source_point) in point_indices.iter().copied().enumerate() {
+            let groups = selectors.groups_for_point(source_point);
+            let source_position = groups.binary_search(&group_id).map_err(|_| {
+                RusticolError::integrity(
+                    "eager grouped selector point is missing an execution group",
+                )
+            })?;
+            let source_index = selectors.group_offset_for_point(source_point) + source_position;
+            target[target_start + target_point] = active_group_weights[source_index];
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn validate_point_selected_execution_buffers(
+    plan: &EagerExecutionPlan,
+    selectors: &PointSelectorInput<'_>,
+    active_group_weights: &[f64],
+    point_count: usize,
+    initial_values: &[EagerComplex64],
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+    reduced: &[f64],
+) -> RusticolResult<()> {
+    if selectors.point_count() != point_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager per-point selector count is {}, expected {point_count}",
+            selectors.point_count()
+        )));
+    }
+    if active_group_weights.len() != selectors.group_entry_count() {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager active group weight count is {}, expected {}",
+            active_group_weights.len(),
+            selectors.group_entry_count(),
+        )));
+    }
+    if active_group_weights
+        .iter()
+        .any(|weight| !weight.is_finite() || *weight < 0.0)
+    {
+        return Err(RusticolError::invalid_argument(
+            "eager active group weights must be nonnegative and finite",
+        ));
+    }
+    if let PointSelectorInput::GroupSets { offsets, groups } = selectors {
+        if offsets.len() != point_count + 1 {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager per-point selector offsets have length {}, expected {}",
+                offsets.len(),
+                point_count + 1
+            )));
+        }
+        if offsets.first().copied() != Some(0) {
+            return Err(RusticolError::invalid_argument(
+                "eager per-point selector offsets must start at zero",
+            ));
+        }
+        if offsets.windows(2).any(|pair| pair[0] > pair[1]) {
+            return Err(RusticolError::invalid_argument(
+                "eager per-point selector offsets must be nondecreasing",
+            ));
+        }
+        if offsets.last().copied() != Some(groups.len()) {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager per-point selector offsets end at {}, expected {}",
+                offsets.last().copied().unwrap_or(0),
+                groups.len()
+            )));
+        }
+    }
+    validate_buffer_len(
+        "initial value",
+        initial_values.len(),
+        plan.values.component_count,
+        point_count,
+    )?;
+    validate_buffer_len(
+        "momentum",
+        momenta.len(),
+        plan.momenta.component_count,
+        point_count,
+    )?;
+    if model_parameters.len() != plan.parameter_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager model parameter buffer has length {}, expected {}",
+            model_parameters.len(),
+            plan.parameter_count
+        )));
+    }
+    if reduced.len() != point_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager reduced output has length {}, expected {point_count}",
+            reduced.len()
+        )));
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn validate_execution_buffers(
+    plan: &EagerExecutionPlan,
+    point_count: usize,
+    initial_values: &[EagerComplex64],
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+    amplitudes: &[EagerComplex64],
+    reduced: &[f64],
+) -> RusticolResult<()> {
+    validate_buffer_len(
+        "initial value",
+        initial_values.len(),
+        plan.values.component_count,
+        point_count,
+    )?;
+    validate_buffer_len(
+        "momentum",
+        momenta.len(),
+        plan.momenta.component_count,
+        point_count,
+    )?;
+    if model_parameters.len() != plan.parameter_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager model parameter buffer has length {}, expected {}",
+            model_parameters.len(),
+            plan.parameter_count
+        )));
+    }
+    validate_buffer_len(
+        "amplitude output",
+        amplitudes.len(),
+        plan.amplitude_count,
+        point_count,
+    )?;
+    if reduced.len() != point_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager reduced output has length {}, expected {point_count}",
+            reduced.len()
+        )));
+    }
+    Ok(())
+}
+
+fn validate_selected_execution_buffers(
+    plan: &EagerExecutionPlan,
+    point_count: usize,
+    initial_values: &[EagerComplex64],
+    momenta: &[f64],
+    model_parameters: &[EagerComplex64],
+    amplitudes: &[EagerComplex64],
+) -> RusticolResult<()> {
+    validate_buffer_len(
+        "initial value",
+        initial_values.len(),
+        plan.values.component_count,
+        point_count,
+    )?;
+    validate_buffer_len(
+        "momentum",
+        momenta.len(),
+        plan.momenta.component_count,
+        point_count,
+    )?;
+    if model_parameters.len() != plan.parameter_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager model parameter buffer has length {}, expected {}",
+            model_parameters.len(),
+            plan.parameter_count
+        )));
+    }
+    validate_buffer_len(
+        "amplitude output",
+        amplitudes.len(),
+        plan.amplitude_count,
+        point_count,
+    )
+}
+
+fn validate_model_parameters(parameters: &[EagerComplex64]) -> RusticolResult<()> {
+    if parameters.iter().any(|value| !complex_is_finite(*value)) {
+        return Err(RusticolError::invalid_argument(
+            "eager model parameters must be finite",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_buffer_len(
+    name: &str,
+    actual: usize,
+    component_count: usize,
+    point_count: usize,
+) -> RusticolResult<()> {
+    let expected = component_count.checked_mul(point_count).ok_or_else(|| {
+        RusticolError::invalid_argument(format!("eager {name} buffer length overflows"))
+    })?;
+    if actual != expected {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager {name} buffer has length {actual}, expected {expected}"
+        )));
+    }
+    Ok(())
+}
+
+fn resolve_couplings(
+    rows: &[EagerCouplingRow],
+    parameters: &[EagerComplex64],
+    output: &mut [EagerComplex64],
+) {
+    for (row, value) in rows.iter().zip(output) {
+        let real = if row.real_parameter_id == MISSING_U32 {
+            row.constant_real
+        } else {
+            parameters[row.real_parameter_id as usize].re
+        };
+        let imag = if row.imag_parameter_id == MISSING_U32 {
+            row.constant_imag
+        } else {
+            parameters[row.imag_parameter_id as usize].re
+        };
+        *value = EagerComplex64::new(real, imag);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        EagerAttachmentRow, EagerClosureRow, EagerCouplingRow, EagerDirectClosureSpec,
+        EagerFinalizationRow, EagerInvocationRow, EagerKernelInput, EagerKernelRole,
+        EagerPlanDefinition, EagerPlanDimensions, EagerPlanPayloads, EagerReductionEntry,
+        EagerReductionGroup, EagerSelectorDomainIdRow, EagerSelectorDomainRow,
+        EagerSelectorGroupRow, EagerSelectorPayloads, EagerSelectorStagePayload, EagerStagePayload,
+        MISSING_U32,
+    };
+
+    #[derive(Default)]
+    struct AddBackend;
+
+    impl EagerKernelBackend for AddBackend {
+        fn evaluate_batch(
+            &mut self,
+            call: super::super::EagerKernelCall<'_>,
+        ) -> RusticolResult<()> {
+            assert_eq!(call.kernel_id, 7);
+            assert_eq!(call.input_component_count, 3);
+            assert_eq!(call.output_component_count, 1);
+            for lane in 0..call.lane_count {
+                let row = lane * call.input_component_count;
+                call.outputs[lane] = call.inputs[row] + call.inputs[row + 1] + call.inputs[row + 2];
+            }
+            Ok(())
+        }
+    }
+
+    #[derive(Default)]
+    struct RecordingAddBackend {
+        lane_counts: Vec<usize>,
+    }
+
+    impl EagerKernelBackend for RecordingAddBackend {
+        fn evaluate_batch(
+            &mut self,
+            call: super::super::EagerKernelCall<'_>,
+        ) -> RusticolResult<()> {
+            assert_eq!(call.kernel_id, 7);
+            assert_eq!(call.input_component_count, 3);
+            assert_eq!(call.output_component_count, 1);
+            self.lane_counts.push(call.lane_count);
+            for lane in 0..call.lane_count {
+                let row = lane * call.input_component_count;
+                call.outputs[lane] = call.inputs[row] + call.inputs[row + 1] + call.inputs[row + 2];
+            }
+            Ok(())
+        }
+    }
+
+    fn selector_runtime() -> EagerExecutionRuntime {
+        let definition = EagerPlanDefinition {
+            dimensions: EagerPlanDimensions {
+                value_slot_component_counts: vec![1, 1, 1, 1],
+                momentum_slot_component_counts: vec![1],
+                current_component_counts: vec![1, 1],
+                parameter_count: 0,
+                amplitude_count: 2,
+            },
+            kernels: vec![EagerKernelSpec {
+                kernel_id: 7,
+                role: EagerKernelRole::Vertex,
+                inputs: vec![
+                    EagerKernelInput::FirstCurrentComponent(0),
+                    EagerKernelInput::SecondCurrentComponent(0),
+                    EagerKernelInput::FirstMomentumComponent(0),
+                ],
+                output_component_count: 1,
+                homogeneous_linear_first_current: false,
+                independent_block_size: 1,
+            }],
+            direct_closures: vec![
+                EagerDirectClosureSpec {
+                    closure_index: 0,
+                    coefficients: vec![EagerComplex64::new(1.0, 0.0)],
+                },
+                EagerDirectClosureSpec {
+                    closure_index: 1,
+                    coefficients: vec![EagerComplex64::new(1.0, 0.0)],
+                },
+            ],
+            reduction_groups: vec![
+                EagerReductionGroup {
+                    coherent_group_id: 10,
+                    amplitude_indices: vec![0],
+                },
+                EagerReductionGroup {
+                    coherent_group_id: 20,
+                    amplitude_indices: vec![1],
+                },
+            ],
+            reduction_entries: vec![
+                EagerReductionEntry {
+                    left_group_index: 0,
+                    right_group_index: 0,
+                    coefficient: EagerComplex64::new(2.0, 0.0),
+                },
+                EagerReductionEntry {
+                    left_group_index: 1,
+                    right_group_index: 1,
+                    coefficient: EagerComplex64::new(3.0, 0.0),
+                },
+            ],
+        };
+        let couplings = EagerCouplingRow::encode_table(&[EagerCouplingRow {
+            real_parameter_id: MISSING_U32,
+            imag_parameter_id: MISSING_U32,
+            constant_real: 1.0,
+            constant_imag: 0.0,
+        }])
+        .expect("coupling table");
+        let invocations = EagerInvocationRow::encode_table(&[
+            EagerInvocationRow {
+                kernel_id: 7,
+                left_value_slot_id: 0,
+                right_value_slot_id: 0,
+                left_momentum_slot_id: 0,
+                right_momentum_slot_id: 0,
+                coupling_slot_id: 0,
+                output_factor_source: crate::EAGER_OUTPUT_FACTOR_NONE,
+                attachment_start: 0,
+                attachment_count: 1,
+            },
+            EagerInvocationRow {
+                kernel_id: 7,
+                left_value_slot_id: 1,
+                right_value_slot_id: 1,
+                left_momentum_slot_id: 0,
+                right_momentum_slot_id: 0,
+                coupling_slot_id: 0,
+                output_factor_source: crate::EAGER_OUTPUT_FACTOR_NONE,
+                attachment_start: 1,
+                attachment_count: 1,
+            },
+        ])
+        .expect("invocation table");
+        let attachments = EagerAttachmentRow::encode_table(&[
+            EagerAttachmentRow {
+                result_current_id: 0,
+                factor_real: 1.0,
+                factor_imag: 0.0,
+            },
+            EagerAttachmentRow {
+                result_current_id: 1,
+                factor_real: 1.0,
+                factor_imag: 0.0,
+            },
+        ])
+        .expect("attachment table");
+        let finalizations = EagerFinalizationRow::encode_table(&[
+            EagerFinalizationRow {
+                kernel_id: MISSING_U32,
+                current_id: 0,
+                unpropagated_value_slot_id: 2,
+                propagated_value_slot_id: MISSING_U32,
+                momentum_slot_id: 0,
+            },
+            EagerFinalizationRow {
+                kernel_id: MISSING_U32,
+                current_id: 1,
+                unpropagated_value_slot_id: 3,
+                propagated_value_slot_id: MISSING_U32,
+                momentum_slot_id: 0,
+            },
+        ])
+        .expect("finalization table");
+        let closures = EagerClosureRow::encode_table(&[
+            EagerClosureRow {
+                kernel_id: MISSING_U32,
+                left_value_slot_id: 2,
+                right_value_slot_id: 0,
+                amplitude_index: 0,
+                coupling_slot_id: MISSING_U32,
+                output_factor_source: crate::EAGER_OUTPUT_FACTOR_NONE,
+                factor_real: 1.0,
+                factor_imag: 0.0,
+            },
+            EagerClosureRow {
+                kernel_id: MISSING_U32,
+                left_value_slot_id: 3,
+                right_value_slot_id: 0,
+                amplitude_index: 1,
+                coupling_slot_id: MISSING_U32,
+                output_factor_source: crate::EAGER_OUTPUT_FACTOR_NONE,
+                factor_real: 1.0,
+                factor_imag: 0.0,
+            },
+        ])
+        .expect("closure table");
+        let domains = EagerSelectorDomainRow::encode_table(&[
+            EagerSelectorDomainRow {
+                member_start: 0,
+                member_count: 0,
+            },
+            EagerSelectorDomainRow {
+                member_start: 0,
+                member_count: 1,
+            },
+            EagerSelectorDomainRow {
+                member_start: 1,
+                member_count: 1,
+            },
+        ])
+        .expect("selector domains");
+        let domain_group_ids = EagerSelectorGroupRow::encode_table(&[
+            EagerSelectorGroupRow {
+                coherent_group_id: 10,
+            },
+            EagerSelectorGroupRow {
+                coherent_group_id: 20,
+            },
+        ])
+        .expect("selector group ids");
+        let invocation_domains = EagerSelectorDomainIdRow::encode_table(&[
+            EagerSelectorDomainIdRow { domain_id: 1 },
+            EagerSelectorDomainIdRow { domain_id: 2 },
+        ])
+        .expect("invocation selector domains");
+        let attachment_domains = invocation_domains.clone();
+        let unpropagated_finalization_domains = invocation_domains.clone();
+        let propagated_finalization_domains = EagerSelectorDomainIdRow::encode_table(&[
+            EagerSelectorDomainIdRow { domain_id: 0 },
+            EagerSelectorDomainIdRow { domain_id: 0 },
+        ])
+        .expect("propagated selector domains");
+        let closure_domains = invocation_domains.clone();
+        let stage = EagerStagePayload {
+            stage_index: 1,
+            invocations: &invocations,
+            attachments: &attachments,
+            finalizations: &finalizations,
+        };
+        let selector_stage = EagerSelectorStagePayload {
+            stage_index: 1,
+            invocation_domains: &invocation_domains,
+            attachment_domains: &attachment_domains,
+            unpropagated_finalization_domains: &unpropagated_finalization_domains,
+            propagated_finalization_domains: &propagated_finalization_domains,
+        };
+        let plan = EagerExecutionPlan::from_payloads(
+            definition,
+            EagerPlanPayloads {
+                couplings: &couplings,
+                stages: &[stage],
+                closures: &closures,
+                selector_domains: Some(EagerSelectorPayloads {
+                    domains: &domains,
+                    domain_group_ids: &domain_group_ids,
+                    stages: &[selector_stage],
+                    closure_domains: &closure_domains,
+                }),
+            },
+        )
+        .expect("selector plan");
+        EagerExecutionRuntime::new(
+            plan,
+            EagerRuntimeOptions {
+                point_tile_size: 8,
+                workspace_bytes: 64 * 1024,
+            },
+        )
+        .expect("selector runtime")
+    }
+
+    fn selector_inputs() -> (Vec<EagerComplex64>, Vec<f64>) {
+        (
+            vec![
+                EagerComplex64::new(1.0, 0.0),
+                EagerComplex64::new(2.0, 0.0),
+                EagerComplex64::new(3.0, 0.0),
+                EagerComplex64::new(4.0, 0.0),
+                EagerComplex64::new(10.0, 0.0),
+                EagerComplex64::new(20.0, 0.0),
+                EagerComplex64::new(30.0, 0.0),
+                EagerComplex64::new(40.0, 0.0),
+                EagerComplex64::new(0.0, 0.0),
+                EagerComplex64::new(0.0, 0.0),
+                EagerComplex64::new(0.0, 0.0),
+                EagerComplex64::new(0.0, 0.0),
+                EagerComplex64::new(0.0, 0.0),
+                EagerComplex64::new(0.0, 0.0),
+                EagerComplex64::new(0.0, 0.0),
+                EagerComplex64::new(0.0, 0.0),
+            ],
+            vec![0.5, 1.0, 1.5, 2.0],
+        )
+    }
+
+    fn expected_selector_value(group: u32, point: usize) -> f64 {
+        let x = (point + 1) as f64;
+        let momentum = 0.5 * (point + 1) as f64;
+        match group {
+            10 => {
+                let amplitude = (2.0 * x + momentum) * x;
+                2.0 * amplitude * amplitude
+            }
+            20 => {
+                let y = 10.0 * (point + 1) as f64;
+                let amplitude = (2.0 * y + momentum) * x;
+                3.0 * amplitude * amplitude
+            }
+            _ => unreachable!("test selector group"),
+        }
+    }
+
+    fn profiled_runtime() -> EagerExecutionRuntime {
+        let definition = EagerPlanDefinition {
+            dimensions: EagerPlanDimensions {
+                value_slot_component_counts: vec![1, 1, 1],
+                momentum_slot_component_counts: vec![1],
+                current_component_counts: vec![1],
+                parameter_count: 0,
+                amplitude_count: 1,
+            },
+            kernels: vec![EagerKernelSpec {
+                kernel_id: 7,
+                role: EagerKernelRole::Vertex,
+                inputs: vec![
+                    EagerKernelInput::FirstCurrentComponent(0),
+                    EagerKernelInput::SecondCurrentComponent(0),
+                    EagerKernelInput::FirstMomentumComponent(0),
+                ],
+                output_component_count: 1,
+                homogeneous_linear_first_current: false,
+                independent_block_size: 1,
+            }],
+            direct_closures: vec![EagerDirectClosureSpec {
+                closure_index: 0,
+                coefficients: vec![EagerComplex64::new(1.0, 0.0)],
+            }],
+            reduction_groups: vec![EagerReductionGroup {
+                coherent_group_id: 0,
+                amplitude_indices: vec![0],
+            }],
+            reduction_entries: vec![EagerReductionEntry {
+                left_group_index: 0,
+                right_group_index: 0,
+                coefficient: EagerComplex64::new(1.0, 0.0),
+            }],
+        };
+        let couplings = EagerCouplingRow::encode_table(&[EagerCouplingRow {
+            real_parameter_id: MISSING_U32,
+            imag_parameter_id: MISSING_U32,
+            constant_real: 1.0,
+            constant_imag: 0.0,
+        }])
+        .expect("coupling table");
+        let invocations = EagerInvocationRow::encode_table(&[EagerInvocationRow {
+            kernel_id: 7,
+            left_value_slot_id: 0,
+            right_value_slot_id: 1,
+            left_momentum_slot_id: 0,
+            right_momentum_slot_id: 0,
+            coupling_slot_id: 0,
+            output_factor_source: crate::EAGER_OUTPUT_FACTOR_NONE,
+            attachment_start: 0,
+            attachment_count: 1,
+        }])
+        .expect("invocation table");
+        let attachments = EagerAttachmentRow::encode_table(&[EagerAttachmentRow {
+            result_current_id: 0,
+            factor_real: 1.0,
+            factor_imag: 0.0,
+        }])
+        .expect("attachment table");
+        let finalizations = EagerFinalizationRow::encode_table(&[EagerFinalizationRow {
+            kernel_id: MISSING_U32,
+            current_id: 0,
+            unpropagated_value_slot_id: 2,
+            propagated_value_slot_id: MISSING_U32,
+            momentum_slot_id: 0,
+        }])
+        .expect("finalization table");
+        let closures = EagerClosureRow::encode_table(&[EagerClosureRow {
+            kernel_id: MISSING_U32,
+            left_value_slot_id: 2,
+            right_value_slot_id: 0,
+            amplitude_index: 0,
+            coupling_slot_id: MISSING_U32,
+            output_factor_source: crate::EAGER_OUTPUT_FACTOR_NONE,
+            factor_real: 1.0,
+            factor_imag: 0.0,
+        }])
+        .expect("closure table");
+        let stage = EagerStagePayload {
+            stage_index: 1,
+            invocations: &invocations,
+            attachments: &attachments,
+            finalizations: &finalizations,
+        };
+        let plan = EagerExecutionPlan::from_payloads(
+            definition,
+            EagerPlanPayloads {
+                couplings: &couplings,
+                stages: &[stage],
+                closures: &closures,
+                selector_domains: None,
+            },
+        )
+        .expect("profile plan");
+        EagerExecutionRuntime::new(
+            plan,
+            EagerRuntimeOptions {
+                point_tile_size: 2,
+                workspace_bytes: 4096,
+            },
+        )
+        .expect("profile runtime")
+    }
+
+    #[test]
+    fn profiled_execution_matches_hot_path_and_accounts_for_every_phase() {
+        let point_count = 4;
+        let initial_values = [
+            EagerComplex64::new(1.0, 0.0),
+            EagerComplex64::new(2.0, 0.0),
+            EagerComplex64::new(3.0, 0.0),
+            EagerComplex64::new(4.0, 0.0),
+            EagerComplex64::new(10.0, 0.0),
+            EagerComplex64::new(20.0, 0.0),
+            EagerComplex64::new(30.0, 0.0),
+            EagerComplex64::new(40.0, 0.0),
+            EagerComplex64::new(0.0, 0.0),
+            EagerComplex64::new(0.0, 0.0),
+            EagerComplex64::new(0.0, 0.0),
+            EagerComplex64::new(0.0, 0.0),
+        ];
+        let momenta = [0.5, 1.0, 1.5, 2.0];
+        let mut hot = profiled_runtime();
+        let mut profiled = profiled_runtime();
+        let mut hot_amplitudes = vec![EagerComplex64::new(0.0, 0.0); point_count];
+        let mut hot_reduced = vec![0.0; point_count];
+        let mut profiled_amplitudes = hot_amplitudes.clone();
+        let mut profiled_reduced = hot_reduced.clone();
+
+        hot.evaluate_into(
+            &mut AddBackend,
+            point_count,
+            &initial_values,
+            &momenta,
+            &[],
+            &mut hot_amplitudes,
+            &mut hot_reduced,
+        )
+        .expect("hot eager execution");
+        let profile = profiled
+            .evaluate_profile_into(
+                &mut AddBackend,
+                point_count,
+                &initial_values,
+                &momenta,
+                &[],
+                &mut profiled_amplitudes,
+                &mut profiled_reduced,
+            )
+            .expect("profile eager execution");
+
+        assert_eq!(profiled_amplitudes, hot_amplitudes);
+        assert_eq!(profiled_reduced, hot_reduced);
+        assert!(!profile.initialize.is_zero());
+        assert!(!profile.gather.is_zero());
+        assert!(!profile.kernel_call.is_zero());
+        assert!(!profile.invocation_scatter.is_zero());
+        assert!(!profile.finalization.is_zero());
+        assert!(!profile.closure.is_zero());
+        assert!(!profile.reduction.is_zero());
+        assert!(!profile.copy_out.is_zero());
+        assert!(profile.accounted() <= profile.total);
+    }
+
+    #[test]
+    fn point_selectors_group_homogeneous_and_alternating_rows() {
+        let (initial_values, momenta) = selector_inputs();
+        let mut homogeneous = selector_runtime();
+        let mut homogeneous_backend = RecordingAddBackend::default();
+        let mut homogeneous_output = vec![0.0; 4];
+        homogeneous
+            .evaluate_point_selected_groups_into(
+                &mut homogeneous_backend,
+                &[10, 10, 10, 10],
+                &[1.0; 4],
+                4,
+                &initial_values,
+                &momenta,
+                &[],
+                &mut homogeneous_output,
+            )
+            .expect("homogeneous point-selected execution");
+        assert_eq!(homogeneous_backend.lane_counts, vec![4]);
+        assert_eq!(
+            homogeneous_output,
+            (0..4)
+                .map(|point| expected_selector_value(10, point))
+                .collect::<Vec<_>>()
+        );
+
+        let selectors = [10, 20, 10, 20];
+        let mut alternating = selector_runtime();
+        let mut alternating_backend = RecordingAddBackend::default();
+        let mut alternating_output = vec![0.0; 4];
+        alternating
+            .evaluate_point_selected_groups_into(
+                &mut alternating_backend,
+                &selectors,
+                &[1.0; 4],
+                4,
+                &initial_values,
+                &momenta,
+                &[],
+                &mut alternating_output,
+            )
+            .expect("alternating point-selected execution");
+        assert_eq!(alternating_backend.lane_counts, vec![2, 2]);
+        assert_eq!(
+            alternating_output,
+            selectors
+                .iter()
+                .copied()
+                .enumerate()
+                .map(|(point, group)| expected_selector_value(group, point))
+                .collect::<Vec<_>>()
+        );
+        assert!(
+            alternating
+                .point_selected
+                .executions
+                .iter()
+                .all(|execution| {
+                    execution.stages.len() == 1
+                        && execution.stages[0].invocations.len() == 1
+                        && execution.stages[0].finalization_copies.len() == 1
+                        && execution.direct_closures.len() == 1
+                })
+        );
+
+        let randomized_selectors = [20, 10, 10, 20];
+        let mut randomized = selector_runtime();
+        let mut randomized_backend = RecordingAddBackend::default();
+        let mut randomized_output = vec![0.0; 4];
+        randomized
+            .evaluate_point_selected_groups_into(
+                &mut randomized_backend,
+                &randomized_selectors,
+                &[1.0; 4],
+                4,
+                &initial_values,
+                &momenta,
+                &[],
+                &mut randomized_output,
+            )
+            .expect("randomized point-selected execution");
+        assert_eq!(randomized_backend.lane_counts, vec![2, 2]);
+        assert_eq!(
+            randomized_output,
+            randomized_selectors
+                .iter()
+                .copied()
+                .enumerate()
+                .map(|(point, group)| expected_selector_value(group, point))
+                .collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn point_selector_sets_preserve_reduction_weights_and_structural_zeros() {
+        let (initial_values, momenta) = selector_inputs();
+        let mut runtime = selector_runtime();
+        let mut backend = RecordingAddBackend::default();
+        let mut output = vec![-1.0; 4];
+        let active_group_weights = [0.5, 1.0, 2.0, 0.25];
+        // point 0 selects group 10, point 1 is a certified structural zero,
+        // point 2 selects both groups, and point 3 selects group 20.
+        runtime
+            .evaluate_point_selected_group_sets_into(
+                &mut backend,
+                &[0, 1, 1, 3, 4],
+                &[10, 10, 20, 20],
+                &active_group_weights,
+                4,
+                &initial_values,
+                &momenta,
+                &[],
+                &mut output,
+            )
+            .expect("point-selected active-set execution");
+        assert_eq!(output[0], 0.5 * expected_selector_value(10, 0));
+        assert_eq!(output[1], 0.0);
+        assert_eq!(
+            output[2],
+            expected_selector_value(10, 2) + 2.0 * expected_selector_value(20, 2)
+        );
+        assert_eq!(output[3], 0.25 * expected_selector_value(20, 3));
+        assert_eq!(backend.lane_counts, vec![1, 2, 1]);
+    }
+
+    #[test]
+    fn point_selector_validation_reports_lengths_unknown_groups_and_duplicates() {
+        let (initial_values, momenta) = selector_inputs();
+        let mut runtime = selector_runtime();
+        let mut backend = RecordingAddBackend::default();
+        let mut output = vec![0.0; 4];
+
+        let error = runtime
+            .evaluate_point_selected_groups_into(
+                &mut backend,
+                &[10, 20],
+                &[1.0; 4],
+                4,
+                &initial_values,
+                &momenta,
+                &[],
+                &mut output,
+            )
+            .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("selector count is 2, expected 4")
+        );
+
+        let error = runtime
+            .evaluate_point_selected_group_sets_into(
+                &mut backend,
+                &[0, 1, 2, 3, 4],
+                &[10, 20, 99, 10],
+                &[1.0; 4],
+                4,
+                &initial_values,
+                &momenta,
+                &[],
+                &mut output,
+            )
+            .unwrap_err();
+        assert!(error.to_string().contains("unknown coherent group 99"));
+
+        let error = runtime
+            .evaluate_point_selected_group_sets_into(
+                &mut backend,
+                &[0, 2, 2, 2, 2],
+                &[10, 10],
+                &[1.0; 2],
+                4,
+                &initial_values,
+                &momenta,
+                &[],
+                &mut output,
+            )
+            .unwrap_err();
+        assert!(error.to_string().contains("duplicates coherent group 10"));
+    }
+
+    #[test]
+    fn warmed_point_selector_execution_reuses_plans_and_buffers() {
+        let (initial_values, momenta) = selector_inputs();
+        let selectors = [10, 20, 10, 20];
+        let mut runtime = selector_runtime();
+        let mut backend = RecordingAddBackend::default();
+        let mut output = vec![0.0; 4];
+        runtime
+            .evaluate_point_selected_groups_into(
+                &mut backend,
+                &selectors,
+                &[1.0; 4],
+                4,
+                &initial_values,
+                &momenta,
+                &[],
+                &mut output,
+            )
+            .expect("warm point selector caches");
+        let fingerprint = [
+            runtime.point_selected.executions.len(),
+            runtime.point_selected.work_groups.len(),
+            runtime.point_selected.signature_offsets.as_ptr() as usize,
+            runtime.point_selected.signature_offsets.capacity(),
+            runtime.point_selected.signature_groups.as_ptr() as usize,
+            runtime.point_selected.signature_groups.capacity(),
+            runtime.point_selected.point_work_group_ids.as_ptr() as usize,
+            runtime.point_selected.point_work_group_ids.capacity(),
+            runtime.point_selected.grouped_point_indices.as_ptr() as usize,
+            runtime.point_selected.grouped_point_indices.capacity(),
+            runtime.point_selected.gathered_initial_values.as_ptr() as usize,
+            runtime.point_selected.gathered_initial_values.capacity(),
+            runtime.point_selected.gathered_momenta.as_ptr() as usize,
+            runtime.point_selected.gathered_momenta.capacity(),
+        ];
+
+        backend.lane_counts.clear();
+        output.fill(0.0);
+        runtime
+            .evaluate_point_selected_groups_into(
+                &mut backend,
+                &selectors,
+                &[1.0; 4],
+                4,
+                &initial_values,
+                &momenta,
+                &[],
+                &mut output,
+            )
+            .expect("reuse warmed point selector caches");
+        let repeated = [
+            runtime.point_selected.executions.len(),
+            runtime.point_selected.work_groups.len(),
+            runtime.point_selected.signature_offsets.as_ptr() as usize,
+            runtime.point_selected.signature_offsets.capacity(),
+            runtime.point_selected.signature_groups.as_ptr() as usize,
+            runtime.point_selected.signature_groups.capacity(),
+            runtime.point_selected.point_work_group_ids.as_ptr() as usize,
+            runtime.point_selected.point_work_group_ids.capacity(),
+            runtime.point_selected.grouped_point_indices.as_ptr() as usize,
+            runtime.point_selected.grouped_point_indices.capacity(),
+            runtime.point_selected.gathered_initial_values.as_ptr() as usize,
+            runtime.point_selected.gathered_initial_values.capacity(),
+            runtime.point_selected.gathered_momenta.as_ptr() as usize,
+            runtime.point_selected.gathered_momenta.capacity(),
+        ];
+        assert_eq!(repeated, fingerprint);
+        assert_eq!(backend.lane_counts, vec![2, 2]);
+    }
+
+    #[test]
+    fn effective_tile_uses_requested_size_as_an_upper_bound() {
+        assert_eq!(effective_tile_capacity(32, 4096, 63_240), 32);
+        assert_eq!(effective_tile_capacity(1024, 4096, 63_240), 264);
+        assert_eq!(effective_tile_capacity(1024, 4096, usize::MAX), 1);
+    }
+
+    #[test]
+    fn shared_linear_finalization_requires_an_exact_kernel_proof() {
+        let rows = [0_u32, 1_u32].map(|current_id| ScheduledFinalization {
+            row: EagerFinalizationRow {
+                kernel_id: 7,
+                current_id,
+                unpropagated_value_slot_id: MISSING_U32,
+                propagated_value_slot_id: current_id,
+                momentum_slot_id: 0,
+            },
+            current: ComponentRange {
+                start: current_id as usize,
+                len: 1,
+            },
+            propagated: Some(ComponentRange {
+                start: current_id as usize,
+                len: 1,
+            }),
+            momentum: ComponentRange { start: 0, len: 1 },
+            selector_domain_id: None,
+        });
+        let packet = KernelPacket {
+            role: PacketRole::Finalization,
+            kernel_id: 7,
+            independent_block_size: 1,
+            item_range: 0..2,
+            input_components: 2,
+            output_components: 1,
+            linear_finalization: None,
+        };
+        let kernel = |proved| EagerKernelSpec {
+            kernel_id: 7,
+            role: EagerKernelRole::Finalization,
+            inputs: vec![
+                EagerKernelInput::FirstCurrentComponent(0),
+                EagerKernelInput::FirstMomentumComponent(0),
+            ],
+            output_component_count: 1,
+            homogeneous_linear_first_current: proved,
+            independent_block_size: 1,
+        };
+
+        let mut packets = vec![packet.clone()];
+        configure_linear_finalization_packets(
+            &mut packets,
+            &rows,
+            &BTreeMap::from([(7, kernel(false))]),
+        )
+        .unwrap();
+        assert!(packets[0].linear_finalization.is_none());
+
+        configure_linear_finalization_packets(
+            &mut packets,
+            &rows,
+            &BTreeMap::from([(7, kernel(true))]),
+        )
+        .unwrap();
+        assert_eq!(
+            packets[0]
+                .linear_finalization
+                .as_ref()
+                .unwrap()
+                .lane_multiplier(),
+            1
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/eager_tables.rs b/pyamplicol/rust/crates/rusticol-core/src/eager_tables.rs
new file mode 100644
index 0000000000..6fd41c4f3b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/eager_tables.rs
@@ -0,0 +1,877 @@
+// SPDX-License-Identifier: 0BSD
+
+use crate::{RusticolError, RusticolResult};
+use std::mem::size_of;
+
+pub const EAGER_PLAN_ABI: &str = "pyamplicol-eager-plan-v2";
+pub const EAGER_KERNEL_ABI: &str = "pyamplicol-eager-kernel-v1";
+pub const EAGER_SELECTOR_DOMAINS_ABI: &str = "pyamplicol-eager-selector-domains-v1";
+pub const EAGER_RUNTIME_CAPABILITY: &str = "rusticol.eager-dag.complex-f64.v1";
+pub const EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY: &str =
+    "rusticol.eager-dag.lc-topology-replay.v1";
+pub const MISSING_U32: u32 = u32::MAX;
+pub const EAGER_OUTPUT_FACTOR_NONE: u32 = 0;
+pub const EAGER_OUTPUT_FACTOR_COUPLING_REAL: u32 = 1;
+pub const EAGER_OUTPUT_FACTOR_COUPLING_IMAG: u32 = 2;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct EagerInvocationRow {
+    pub kernel_id: u32,
+    pub left_value_slot_id: u32,
+    pub right_value_slot_id: u32,
+    pub left_momentum_slot_id: u32,
+    pub right_momentum_slot_id: u32,
+    pub coupling_slot_id: u32,
+    pub output_factor_source: u32,
+    pub attachment_start: u64,
+    pub attachment_count: u64,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct EagerAttachmentRow {
+    pub result_current_id: u32,
+    pub factor_real: f64,
+    pub factor_imag: f64,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct EagerCouplingRow {
+    pub real_parameter_id: u32,
+    pub imag_parameter_id: u32,
+    pub constant_real: f64,
+    pub constant_imag: f64,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct EagerFinalizationRow {
+    pub kernel_id: u32,
+    pub current_id: u32,
+    pub unpropagated_value_slot_id: u32,
+    pub propagated_value_slot_id: u32,
+    pub momentum_slot_id: u32,
+}
+
+impl EagerFinalizationRow {
+    pub fn applies_kernel(self) -> bool {
+        self.kernel_id != MISSING_U32
+    }
+
+    pub fn stores_unpropagated(self) -> bool {
+        self.unpropagated_value_slot_id != MISSING_U32
+    }
+
+    pub fn stores_propagated(self) -> bool {
+        self.propagated_value_slot_id != MISSING_U32
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct EagerClosureRow {
+    pub kernel_id: u32,
+    pub left_value_slot_id: u32,
+    pub right_value_slot_id: u32,
+    pub amplitude_index: u32,
+    pub coupling_slot_id: u32,
+    pub output_factor_source: u32,
+    pub factor_real: f64,
+    pub factor_imag: f64,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerSelectorDomainRow {
+    pub member_start: u64,
+    pub member_count: u64,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerSelectorGroupRow {
+    pub coherent_group_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EagerSelectorDomainIdRow {
+    pub domain_id: u32,
+}
+
+trait FixedWidthRow: Sized {
+    const NAME: &'static str;
+    const WIDTH: usize;
+
+    fn validate_for_encoding(&self, row_index: usize) -> RusticolResult<()>;
+    fn encode_into(&self, output: &mut Vec<u8>);
+    fn decode_from(bytes: &[u8], row_index: usize) -> RusticolResult<Self>;
+}
+
+macro_rules! impl_table_api {
+    ($row:ty) => {
+        impl $row {
+            pub const ENCODED_LEN: usize = <Self as FixedWidthRow>::WIDTH;
+
+            pub fn encode_table(rows: &[Self]) -> RusticolResult<Vec<u8>> {
+                encode_rows(rows)
+            }
+
+            pub fn decode_table(payload: &[u8]) -> RusticolResult<Vec<Self>> {
+                decode_rows(payload)
+            }
+        }
+    };
+}
+
+impl FixedWidthRow for EagerInvocationRow {
+    const NAME: &'static str = "invocation";
+    const WIDTH: usize = 7 * size_of::<u32>() + 2 * size_of::<u64>();
+
+    fn validate_for_encoding(&self, row_index: usize) -> RusticolResult<()> {
+        validate_output_factor_source_for_encoding(Self::NAME, row_index, self.output_factor_source)
+    }
+
+    fn encode_into(&self, output: &mut Vec<u8>) {
+        push_u32(output, self.kernel_id);
+        push_u32(output, self.left_value_slot_id);
+        push_u32(output, self.right_value_slot_id);
+        push_u32(output, self.left_momentum_slot_id);
+        push_u32(output, self.right_momentum_slot_id);
+        push_u32(output, self.coupling_slot_id);
+        push_u32(output, self.output_factor_source);
+        push_u64(output, self.attachment_start);
+        push_u64(output, self.attachment_count);
+    }
+
+    fn decode_from(bytes: &[u8], row_index: usize) -> RusticolResult<Self> {
+        let mut reader = RowReader::new(Self::NAME, row_index, bytes);
+        let row = Self {
+            kernel_id: reader.read_u32()?,
+            left_value_slot_id: reader.read_u32()?,
+            right_value_slot_id: reader.read_u32()?,
+            left_momentum_slot_id: reader.read_u32()?,
+            right_momentum_slot_id: reader.read_u32()?,
+            coupling_slot_id: reader.read_u32()?,
+            output_factor_source: reader.read_u32()?,
+            attachment_start: reader.read_u64()?,
+            attachment_count: reader.read_u64()?,
+        };
+        reader.finish()?;
+        validate_output_factor_source_from_payload(
+            Self::NAME,
+            row_index,
+            row.output_factor_source,
+        )?;
+        Ok(row)
+    }
+}
+
+impl FixedWidthRow for EagerAttachmentRow {
+    const NAME: &'static str = "attachment";
+    const WIDTH: usize = size_of::<u32>() + 2 * size_of::<f64>();
+
+    fn validate_for_encoding(&self, row_index: usize) -> RusticolResult<()> {
+        validate_finite_for_encoding(Self::NAME, row_index, "factor_real", self.factor_real)?;
+        validate_finite_for_encoding(Self::NAME, row_index, "factor_imag", self.factor_imag)
+    }
+
+    fn encode_into(&self, output: &mut Vec<u8>) {
+        push_u32(output, self.result_current_id);
+        push_f64(output, self.factor_real);
+        push_f64(output, self.factor_imag);
+    }
+
+    fn decode_from(bytes: &[u8], row_index: usize) -> RusticolResult<Self> {
+        let mut reader = RowReader::new(Self::NAME, row_index, bytes);
+        let row = Self {
+            result_current_id: reader.read_u32()?,
+            factor_real: reader.read_f64()?,
+            factor_imag: reader.read_f64()?,
+        };
+        reader.finish()?;
+        validate_finite_from_payload(Self::NAME, row_index, "factor_real", row.factor_real)?;
+        validate_finite_from_payload(Self::NAME, row_index, "factor_imag", row.factor_imag)?;
+        Ok(row)
+    }
+}
+
+impl FixedWidthRow for EagerCouplingRow {
+    const NAME: &'static str = "coupling";
+    const WIDTH: usize = 2 * size_of::<u32>() + 2 * size_of::<f64>();
+
+    fn validate_for_encoding(&self, row_index: usize) -> RusticolResult<()> {
+        validate_finite_for_encoding(Self::NAME, row_index, "constant_real", self.constant_real)?;
+        validate_finite_for_encoding(Self::NAME, row_index, "constant_imag", self.constant_imag)
+    }
+
+    fn encode_into(&self, output: &mut Vec<u8>) {
+        push_u32(output, self.real_parameter_id);
+        push_u32(output, self.imag_parameter_id);
+        push_f64(output, self.constant_real);
+        push_f64(output, self.constant_imag);
+    }
+
+    fn decode_from(bytes: &[u8], row_index: usize) -> RusticolResult<Self> {
+        let mut reader = RowReader::new(Self::NAME, row_index, bytes);
+        let row = Self {
+            real_parameter_id: reader.read_u32()?,
+            imag_parameter_id: reader.read_u32()?,
+            constant_real: reader.read_f64()?,
+            constant_imag: reader.read_f64()?,
+        };
+        reader.finish()?;
+        validate_finite_from_payload(Self::NAME, row_index, "constant_real", row.constant_real)?;
+        validate_finite_from_payload(Self::NAME, row_index, "constant_imag", row.constant_imag)?;
+        Ok(row)
+    }
+}
+
+impl FixedWidthRow for EagerFinalizationRow {
+    const NAME: &'static str = "finalization";
+    const WIDTH: usize = 5 * size_of::<u32>();
+
+    fn validate_for_encoding(&self, _row_index: usize) -> RusticolResult<()> {
+        Ok(())
+    }
+
+    fn encode_into(&self, output: &mut Vec<u8>) {
+        push_u32(output, self.kernel_id);
+        push_u32(output, self.current_id);
+        push_u32(output, self.unpropagated_value_slot_id);
+        push_u32(output, self.propagated_value_slot_id);
+        push_u32(output, self.momentum_slot_id);
+    }
+
+    fn decode_from(bytes: &[u8], row_index: usize) -> RusticolResult<Self> {
+        let mut reader = RowReader::new(Self::NAME, row_index, bytes);
+        let row = Self {
+            kernel_id: reader.read_u32()?,
+            current_id: reader.read_u32()?,
+            unpropagated_value_slot_id: reader.read_u32()?,
+            propagated_value_slot_id: reader.read_u32()?,
+            momentum_slot_id: reader.read_u32()?,
+        };
+        reader.finish()?;
+        Ok(row)
+    }
+}
+
+impl FixedWidthRow for EagerClosureRow {
+    const NAME: &'static str = "closure";
+    const WIDTH: usize = 6 * size_of::<u32>() + 2 * size_of::<f64>();
+
+    fn validate_for_encoding(&self, row_index: usize) -> RusticolResult<()> {
+        validate_output_factor_source_for_encoding(
+            Self::NAME,
+            row_index,
+            self.output_factor_source,
+        )?;
+        validate_finite_for_encoding(Self::NAME, row_index, "factor_real", self.factor_real)?;
+        validate_finite_for_encoding(Self::NAME, row_index, "factor_imag", self.factor_imag)
+    }
+
+    fn encode_into(&self, output: &mut Vec<u8>) {
+        push_u32(output, self.kernel_id);
+        push_u32(output, self.left_value_slot_id);
+        push_u32(output, self.right_value_slot_id);
+        push_u32(output, self.amplitude_index);
+        push_u32(output, self.coupling_slot_id);
+        push_u32(output, self.output_factor_source);
+        push_f64(output, self.factor_real);
+        push_f64(output, self.factor_imag);
+    }
+
+    fn decode_from(bytes: &[u8], row_index: usize) -> RusticolResult<Self> {
+        let mut reader = RowReader::new(Self::NAME, row_index, bytes);
+        let row = Self {
+            kernel_id: reader.read_u32()?,
+            left_value_slot_id: reader.read_u32()?,
+            right_value_slot_id: reader.read_u32()?,
+            amplitude_index: reader.read_u32()?,
+            coupling_slot_id: reader.read_u32()?,
+            output_factor_source: reader.read_u32()?,
+            factor_real: reader.read_f64()?,
+            factor_imag: reader.read_f64()?,
+        };
+        reader.finish()?;
+        validate_output_factor_source_from_payload(
+            Self::NAME,
+            row_index,
+            row.output_factor_source,
+        )?;
+        validate_finite_from_payload(Self::NAME, row_index, "factor_real", row.factor_real)?;
+        validate_finite_from_payload(Self::NAME, row_index, "factor_imag", row.factor_imag)?;
+        Ok(row)
+    }
+}
+
+impl FixedWidthRow for EagerSelectorDomainRow {
+    const NAME: &'static str = "selector-domain";
+    const WIDTH: usize = 2 * size_of::<u64>();
+
+    fn validate_for_encoding(&self, _row_index: usize) -> RusticolResult<()> {
+        Ok(())
+    }
+
+    fn encode_into(&self, output: &mut Vec<u8>) {
+        push_u64(output, self.member_start);
+        push_u64(output, self.member_count);
+    }
+
+    fn decode_from(bytes: &[u8], row_index: usize) -> RusticolResult<Self> {
+        let mut reader = RowReader::new(Self::NAME, row_index, bytes);
+        let row = Self {
+            member_start: reader.read_u64()?,
+            member_count: reader.read_u64()?,
+        };
+        reader.finish()?;
+        Ok(row)
+    }
+}
+
+impl FixedWidthRow for EagerSelectorGroupRow {
+    const NAME: &'static str = "selector-domain-group";
+    const WIDTH: usize = size_of::<u32>();
+
+    fn validate_for_encoding(&self, _row_index: usize) -> RusticolResult<()> {
+        Ok(())
+    }
+
+    fn encode_into(&self, output: &mut Vec<u8>) {
+        push_u32(output, self.coherent_group_id);
+    }
+
+    fn decode_from(bytes: &[u8], row_index: usize) -> RusticolResult<Self> {
+        let mut reader = RowReader::new(Self::NAME, row_index, bytes);
+        let row = Self {
+            coherent_group_id: reader.read_u32()?,
+        };
+        reader.finish()?;
+        Ok(row)
+    }
+}
+
+impl FixedWidthRow for EagerSelectorDomainIdRow {
+    const NAME: &'static str = "selector-domain-id";
+    const WIDTH: usize = size_of::<u32>();
+
+    fn validate_for_encoding(&self, _row_index: usize) -> RusticolResult<()> {
+        Ok(())
+    }
+
+    fn encode_into(&self, output: &mut Vec<u8>) {
+        push_u32(output, self.domain_id);
+    }
+
+    fn decode_from(bytes: &[u8], row_index: usize) -> RusticolResult<Self> {
+        let mut reader = RowReader::new(Self::NAME, row_index, bytes);
+        let row = Self {
+            domain_id: reader.read_u32()?,
+        };
+        reader.finish()?;
+        Ok(row)
+    }
+}
+
+impl_table_api!(EagerInvocationRow);
+impl_table_api!(EagerAttachmentRow);
+impl_table_api!(EagerCouplingRow);
+impl_table_api!(EagerFinalizationRow);
+impl_table_api!(EagerClosureRow);
+impl_table_api!(EagerSelectorDomainRow);
+impl_table_api!(EagerSelectorGroupRow);
+impl_table_api!(EagerSelectorDomainIdRow);
+
+fn encode_rows<Row: FixedWidthRow>(rows: &[Row]) -> RusticolResult<Vec<u8>> {
+    let byte_count = rows.len().checked_mul(Row::WIDTH).ok_or_else(|| {
+        RusticolError::invalid_argument(format!(
+            "eager {} table row count overflows its encoded length",
+            Row::NAME
+        ))
+    })?;
+    let mut output = Vec::new();
+    output.try_reserve_exact(byte_count).map_err(|error| {
+        RusticolError::invalid_argument(format!(
+            "could not reserve {byte_count} bytes for eager {} table: {error}",
+            Row::NAME
+        ))
+    })?;
+    for (row_index, row) in rows.iter().enumerate() {
+        row.validate_for_encoding(row_index)?;
+        row.encode_into(&mut output);
+    }
+    if output.len() != byte_count {
+        return Err(RusticolError::internal(format!(
+            "eager {} encoder produced {} bytes instead of {byte_count}",
+            Row::NAME,
+            output.len()
+        )));
+    }
+    Ok(output)
+}
+
+fn decode_rows<Row: FixedWidthRow>(payload: &[u8]) -> RusticolResult<Vec<Row>> {
+    if !payload.len().is_multiple_of(Row::WIDTH) {
+        return Err(RusticolError::artifact(format!(
+            "eager {} table has {} bytes, not a multiple of {}",
+            Row::NAME,
+            payload.len(),
+            Row::WIDTH
+        )));
+    }
+    let row_count = payload.len() / Row::WIDTH;
+    let expected_len = row_count.checked_mul(Row::WIDTH).ok_or_else(|| {
+        RusticolError::artifact(format!(
+            "eager {} table row count overflows its encoded length",
+            Row::NAME
+        ))
+    })?;
+    if expected_len != payload.len() {
+        return Err(RusticolError::artifact(format!(
+            "eager {} table length is inconsistent",
+            Row::NAME
+        )));
+    }
+
+    let mut rows = Vec::new();
+    rows.try_reserve_exact(row_count).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not reserve {row_count} eager {} rows: {error}",
+            Row::NAME
+        ))
+    })?;
+    for (row_index, bytes) in payload.chunks_exact(Row::WIDTH).enumerate() {
+        rows.push(Row::decode_from(bytes, row_index)?);
+    }
+    Ok(rows)
+}
+
+fn push_u32(output: &mut Vec<u8>, value: u32) {
+    output.extend_from_slice(&value.to_le_bytes());
+}
+
+fn push_u64(output: &mut Vec<u8>, value: u64) {
+    output.extend_from_slice(&value.to_le_bytes());
+}
+
+fn push_f64(output: &mut Vec<u8>, value: f64) {
+    output.extend_from_slice(&value.to_le_bytes());
+}
+
+fn output_factor_source_is_valid(source: u32) -> bool {
+    matches!(
+        source,
+        EAGER_OUTPUT_FACTOR_NONE
+            | EAGER_OUTPUT_FACTOR_COUPLING_REAL
+            | EAGER_OUTPUT_FACTOR_COUPLING_IMAG
+    )
+}
+
+fn validate_output_factor_source_for_encoding(
+    table: &str,
+    row_index: usize,
+    source: u32,
+) -> RusticolResult<()> {
+    if !output_factor_source_is_valid(source) {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager {table} row {row_index} has unsupported output factor source {source}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_output_factor_source_from_payload(
+    table: &str,
+    row_index: usize,
+    source: u32,
+) -> RusticolResult<()> {
+    if !output_factor_source_is_valid(source) {
+        return Err(RusticolError::artifact(format!(
+            "eager {table} row {row_index} has unsupported output factor source {source}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_finite_for_encoding(
+    table: &str,
+    row_index: usize,
+    field: &str,
+    value: f64,
+) -> RusticolResult<()> {
+    if !value.is_finite() {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager {table} row {row_index} has non-finite {field}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_finite_from_payload(
+    table: &str,
+    row_index: usize,
+    field: &str,
+    value: f64,
+) -> RusticolResult<()> {
+    if !value.is_finite() {
+        return Err(RusticolError::artifact(format!(
+            "eager {table} row {row_index} has non-finite {field}"
+        )));
+    }
+    Ok(())
+}
+
+struct RowReader<'a> {
+    table: &'static str,
+    row_index: usize,
+    bytes: &'a [u8],
+    offset: usize,
+}
+
+impl<'a> RowReader<'a> {
+    fn new(table: &'static str, row_index: usize, bytes: &'a [u8]) -> Self {
+        Self {
+            table,
+            row_index,
+            bytes,
+            offset: 0,
+        }
+    }
+
+    fn read_u32(&mut self) -> RusticolResult<u32> {
+        Ok(u32::from_le_bytes(self.read_array()?))
+    }
+
+    fn read_u64(&mut self) -> RusticolResult<u64> {
+        Ok(u64::from_le_bytes(self.read_array()?))
+    }
+
+    fn read_f64(&mut self) -> RusticolResult<f64> {
+        Ok(f64::from_le_bytes(self.read_array()?))
+    }
+
+    fn read_array<const N: usize>(&mut self) -> RusticolResult<[u8; N]> {
+        let end = self.offset.checked_add(N).ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "eager {} row {} byte offset overflow",
+                self.table, self.row_index
+            ))
+        })?;
+        let bytes = self.bytes.get(self.offset..end).ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "eager {} row {} is truncated at byte {}",
+                self.table, self.row_index, self.offset
+            ))
+        })?;
+        let value = bytes.try_into().map_err(|_| {
+            RusticolError::internal(format!(
+                "could not decode eager {} row {}",
+                self.table, self.row_index
+            ))
+        })?;
+        self.offset = end;
+        Ok(value)
+    }
+
+    fn finish(&self) -> RusticolResult<()> {
+        if self.offset != self.bytes.len() {
+            return Err(RusticolError::artifact(format!(
+                "eager {} row {} has {} trailing bytes",
+                self.table,
+                self.row_index,
+                self.bytes.len() - self.offset
+            )));
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::RusticolErrorKind;
+
+    #[test]
+    fn constants_match_python_contract() {
+        assert_eq!(EAGER_PLAN_ABI, "pyamplicol-eager-plan-v2");
+        assert_eq!(EAGER_KERNEL_ABI, "pyamplicol-eager-kernel-v1");
+        assert_eq!(
+            EAGER_RUNTIME_CAPABILITY,
+            "rusticol.eager-dag.complex-f64.v1"
+        );
+        assert_eq!(MISSING_U32, u32::MAX);
+    }
+
+    #[test]
+    fn invocation_matches_python_little_endian_fixture() {
+        let row = EagerInvocationRow {
+            kernel_id: 0x0102_0304,
+            left_value_slot_id: 0x1112_1314,
+            right_value_slot_id: 0x2122_2324,
+            left_momentum_slot_id: 0x3132_3334,
+            right_momentum_slot_id: 0x4142_4344,
+            coupling_slot_id: 0x5152_5354,
+            output_factor_source: EAGER_OUTPUT_FACTOR_COUPLING_IMAG,
+            attachment_start: 0x0102_0304_0506_0708,
+            attachment_count: 0x1112_1314_1516_1718,
+        };
+        let expected = [
+            0x04, 0x03, 0x02, 0x01, 0x14, 0x13, 0x12, 0x11, 0x24, 0x23, 0x22, 0x21, 0x34, 0x33,
+            0x32, 0x31, 0x44, 0x43, 0x42, 0x41, 0x54, 0x53, 0x52, 0x51, 0x02, 0x00, 0x00, 0x00,
+            0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13,
+            0x12, 0x11,
+        ];
+
+        assert_eq!(EagerInvocationRow::ENCODED_LEN, 44);
+        assert_eq!(EagerInvocationRow::encode_table(&[row]).unwrap(), expected);
+        assert_eq!(EagerInvocationRow::decode_table(&expected).unwrap(), [row]);
+    }
+
+    #[test]
+    fn attachment_matches_python_little_endian_fixture() {
+        let row = EagerAttachmentRow {
+            result_current_id: 0x0102_0304,
+            factor_real: 1.5,
+            factor_imag: -2.25,
+        };
+        let expected = [
+            0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x3f, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0xc0,
+        ];
+
+        assert_eq!(EagerAttachmentRow::ENCODED_LEN, 20);
+        assert_eq!(EagerAttachmentRow::encode_table(&[row]).unwrap(), expected);
+        assert_eq!(EagerAttachmentRow::decode_table(&expected).unwrap(), [row]);
+    }
+
+    #[test]
+    fn coupling_matches_python_little_endian_fixture() {
+        let row = EagerCouplingRow {
+            real_parameter_id: MISSING_U32,
+            imag_parameter_id: 0x0102_0304,
+            constant_real: 3.5,
+            constant_imag: -0.5,
+        };
+        let expected = [
+            0xff, 0xff, 0xff, 0xff, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0c, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xbf,
+        ];
+
+        assert_eq!(EagerCouplingRow::ENCODED_LEN, 24);
+        assert_eq!(EagerCouplingRow::encode_table(&[row]).unwrap(), expected);
+        assert_eq!(EagerCouplingRow::decode_table(&expected).unwrap(), [row]);
+    }
+
+    #[test]
+    fn finalization_matches_python_little_endian_fixture() {
+        let row = EagerFinalizationRow {
+            kernel_id: MISSING_U32,
+            current_id: 0x0102_0304,
+            unpropagated_value_slot_id: 0x1112_1314,
+            propagated_value_slot_id: MISSING_U32,
+            momentum_slot_id: 0x2122_2324,
+        };
+        let expected = [
+            0xff, 0xff, 0xff, 0xff, 0x04, 0x03, 0x02, 0x01, 0x14, 0x13, 0x12, 0x11, 0xff, 0xff,
+            0xff, 0xff, 0x24, 0x23, 0x22, 0x21,
+        ];
+
+        assert_eq!(EagerFinalizationRow::ENCODED_LEN, 20);
+        assert_eq!(
+            EagerFinalizationRow::encode_table(&[row]).unwrap(),
+            expected
+        );
+        assert_eq!(
+            EagerFinalizationRow::decode_table(&expected).unwrap(),
+            [row]
+        );
+        assert!(!row.applies_kernel());
+        assert!(row.stores_unpropagated());
+        assert!(!row.stores_propagated());
+    }
+
+    #[test]
+    fn closure_matches_python_little_endian_fixture() {
+        let row = EagerClosureRow {
+            kernel_id: 0x0102_0304,
+            left_value_slot_id: 0x1112_1314,
+            right_value_slot_id: 0x2122_2324,
+            amplitude_index: 0x3132_3334,
+            coupling_slot_id: 0x4142_4344,
+            output_factor_source: EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+            factor_real: 1.5,
+            factor_imag: -2.25,
+        };
+        let expected = [
+            0x04, 0x03, 0x02, 0x01, 0x14, 0x13, 0x12, 0x11, 0x24, 0x23, 0x22, 0x21, 0x34, 0x33,
+            0x32, 0x31, 0x44, 0x43, 0x42, 0x41, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xf8, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xc0,
+        ];
+
+        assert_eq!(EagerClosureRow::ENCODED_LEN, 40);
+        assert_eq!(EagerClosureRow::encode_table(&[row]).unwrap(), expected);
+        assert_eq!(EagerClosureRow::decode_table(&expected).unwrap(), [row]);
+    }
+
+    #[test]
+    fn round_trips_multiple_rows_and_boundary_values() {
+        let invocations = [
+            EagerInvocationRow {
+                kernel_id: 0,
+                left_value_slot_id: MISSING_U32,
+                right_value_slot_id: 0,
+                left_momentum_slot_id: MISSING_U32,
+                right_momentum_slot_id: 0,
+                coupling_slot_id: MISSING_U32,
+                output_factor_source: EAGER_OUTPUT_FACTOR_NONE,
+                attachment_start: 0,
+                attachment_count: u64::MAX,
+            },
+            EagerInvocationRow {
+                kernel_id: MISSING_U32,
+                left_value_slot_id: 0,
+                right_value_slot_id: MISSING_U32,
+                left_momentum_slot_id: 0,
+                right_momentum_slot_id: MISSING_U32,
+                coupling_slot_id: 0,
+                output_factor_source: EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+                attachment_start: u64::MAX,
+                attachment_count: 0,
+            },
+        ];
+        let attachments = [EagerAttachmentRow {
+            result_current_id: MISSING_U32,
+            factor_real: f64::MAX,
+            factor_imag: f64::MIN,
+        }];
+        let couplings = [EagerCouplingRow {
+            real_parameter_id: MISSING_U32,
+            imag_parameter_id: MISSING_U32,
+            constant_real: -0.0,
+            constant_imag: f64::MIN_POSITIVE,
+        }];
+        let finalizations = [EagerFinalizationRow {
+            kernel_id: MISSING_U32,
+            current_id: MISSING_U32,
+            unpropagated_value_slot_id: MISSING_U32,
+            propagated_value_slot_id: MISSING_U32,
+            momentum_slot_id: MISSING_U32,
+        }];
+        let closures = [EagerClosureRow {
+            kernel_id: MISSING_U32,
+            left_value_slot_id: MISSING_U32,
+            right_value_slot_id: MISSING_U32,
+            amplitude_index: MISSING_U32,
+            coupling_slot_id: MISSING_U32,
+            output_factor_source: EAGER_OUTPUT_FACTOR_NONE,
+            factor_real: f64::MIN_POSITIVE,
+            factor_imag: -0.0,
+        }];
+
+        assert_eq!(
+            EagerInvocationRow::decode_table(
+                &EagerInvocationRow::encode_table(&invocations).unwrap()
+            )
+            .unwrap(),
+            invocations
+        );
+        assert_eq!(
+            EagerAttachmentRow::decode_table(
+                &EagerAttachmentRow::encode_table(&attachments).unwrap()
+            )
+            .unwrap(),
+            attachments
+        );
+        assert_eq!(
+            EagerCouplingRow::decode_table(&EagerCouplingRow::encode_table(&couplings).unwrap())
+                .unwrap(),
+            couplings
+        );
+        assert_eq!(
+            EagerFinalizationRow::decode_table(
+                &EagerFinalizationRow::encode_table(&finalizations).unwrap()
+            )
+            .unwrap(),
+            finalizations
+        );
+        assert_eq!(
+            EagerClosureRow::decode_table(&EagerClosureRow::encode_table(&closures).unwrap())
+                .unwrap(),
+            closures
+        );
+    }
+
+    #[test]
+    fn empty_tables_round_trip() {
+        assert!(EagerInvocationRow::encode_table(&[]).unwrap().is_empty());
+        assert!(EagerInvocationRow::decode_table(&[]).unwrap().is_empty());
+        assert!(EagerCouplingRow::decode_table(&[]).unwrap().is_empty());
+    }
+
+    #[test]
+    fn truncated_payloads_are_artifact_errors() {
+        let cases = [
+            EagerInvocationRow::decode_table(&[0; EagerInvocationRow::ENCODED_LEN - 1])
+                .unwrap_err(),
+            EagerAttachmentRow::decode_table(&[0; EagerAttachmentRow::ENCODED_LEN - 1])
+                .unwrap_err(),
+            EagerCouplingRow::decode_table(&[0; EagerCouplingRow::ENCODED_LEN - 1]).unwrap_err(),
+            EagerFinalizationRow::decode_table(&[0; EagerFinalizationRow::ENCODED_LEN - 1])
+                .unwrap_err(),
+            EagerClosureRow::decode_table(&[0; EagerClosureRow::ENCODED_LEN - 1]).unwrap_err(),
+        ];
+
+        for error in cases {
+            assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+            assert!(error.to_string().contains("not a multiple"));
+        }
+    }
+
+    #[test]
+    fn non_finite_outgoing_factors_are_invalid_arguments() {
+        let attachment = EagerAttachmentRow {
+            result_current_id: 0,
+            factor_real: f64::NAN,
+            factor_imag: 0.0,
+        };
+        let coupling = EagerCouplingRow {
+            real_parameter_id: MISSING_U32,
+            imag_parameter_id: MISSING_U32,
+            constant_real: 0.0,
+            constant_imag: f64::INFINITY,
+        };
+        let closure = EagerClosureRow {
+            kernel_id: 0,
+            left_value_slot_id: 0,
+            right_value_slot_id: 0,
+            amplitude_index: 0,
+            coupling_slot_id: 0,
+            output_factor_source: EAGER_OUTPUT_FACTOR_NONE,
+            factor_real: f64::NEG_INFINITY,
+            factor_imag: 0.0,
+        };
+
+        for error in [
+            EagerAttachmentRow::encode_table(&[attachment]).unwrap_err(),
+            EagerCouplingRow::encode_table(&[coupling]).unwrap_err(),
+            EagerClosureRow::encode_table(&[closure]).unwrap_err(),
+        ] {
+            assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+            assert!(error.to_string().contains("non-finite"));
+        }
+    }
+
+    #[test]
+    fn non_finite_payload_factors_are_artifact_errors() {
+        let mut attachment = vec![0; EagerAttachmentRow::ENCODED_LEN];
+        attachment[4..12].copy_from_slice(&f64::INFINITY.to_le_bytes());
+        let mut coupling = vec![0; EagerCouplingRow::ENCODED_LEN];
+        coupling[8..16].copy_from_slice(&f64::NAN.to_le_bytes());
+        let mut closure = vec![0; EagerClosureRow::ENCODED_LEN];
+        closure[24..32].copy_from_slice(&f64::NEG_INFINITY.to_le_bytes());
+
+        for error in [
+            EagerAttachmentRow::decode_table(&attachment).unwrap_err(),
+            EagerCouplingRow::decode_table(&coupling).unwrap_err(),
+            EagerClosureRow::decode_table(&closure).unwrap_err(),
+        ] {
+            assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+            assert!(error.to_string().contains("non-finite"));
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine.rs b/pyamplicol/rust/crates/rusticol-core/src/engine.rs
new file mode 100644
index 0000000000..eaad9c6d30
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine.rs
@@ -0,0 +1,4875 @@
+// SPDX-License-Identifier: 0BSD
+
+#[cfg(not(feature = "symbolica-runtime"))]
+use num_complex::Complex;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::collections::{BTreeMap, BTreeSet};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+#[cfg(feature = "symbolica-runtime")]
+use symbolica::evaluate::JITCompiledEvaluator;
+#[cfg(feature = "symbolica-runtime")]
+use symbolica::prelude::{
+    BatchEvaluator, Complex, DoubleFloat, EvaluationDomain, ExpressionEvaluator, Float,
+    JITCompilationSettings, Rational, Real, RealLike,
+};
+
+#[cfg(feature = "symbolica-runtime")]
+use crate::artifact::EvaluatorPayloadSource;
+use crate::artifact::EvaluatorPayloadStore;
+use crate::{
+    ColorComponent as PhysicsColorComponentV1, PROCESS_ARTIFACT_SCHEMA_VERSION, PayloadRole,
+    ProcessPhysics as ProcessPhysicsV1, RusticolError, RusticolResult, VerifiedArtifact,
+};
+
+// Keep replay state within the useful cache working set. Larger batches make
+// stage-local gather/scatter substantially slower for high-flow LC workloads.
+const MAX_LC_TOPOLOGY_REPLAY_EXPANDED_POINTS: usize = 2048;
+const LC_SECTOR_SELECTOR_PARAMETER: &str = "runtime.lc_sector_id";
+const HELICITY_RECURRENCE_CONTRACT_VERSION: u32 = 1;
+const HELICITY_RECURRENCE_KIND: &str = "pyamplicol-helicity-recurrence";
+const HELICITY_RECURRENCE_PROOF_ALGORITHM: &str = "canonical-source-transition-dependency-shape-v1";
+const HELICITY_MATERIALIZATION_CONTRACT_VERSION: u32 = 1;
+const HELICITY_MATERIALIZATION_KIND: &str = "pyamplicol-helicity-recurrence-materialization";
+
+type LcTopologyReplayMappings = Vec<Vec<(usize, usize)>>;
+
+#[derive(Clone, Debug, Default)]
+struct LcTopologyReplayData {
+    mappings: LcTopologyReplayMappings,
+    routes: Vec<Vec<LcTopologyReplaySectorRoute>>,
+    materialized_sector_ids: BTreeSet<i64>,
+}
+
+#[derive(Clone, Debug)]
+struct LcTopologyReplaySectorRoute {
+    physical_sector_id: i64,
+    materialized_sector_id: i64,
+    weight: f64,
+    sign: i8,
+    amplitude_factor: [f64; 2],
+    residual: bool,
+}
+
+impl LcTopologyReplaySectorRoute {
+    fn squared_reduction_weight(&self) -> f64 {
+        // The replay sign is an amplitude-level relation.  LC resolved output
+        // is diagonal in the physical flow, so sign^2 = 1.  Multiplying the
+        // signed factor by the sign retains that convention explicitly.
+        self.amplitude_factor[0] * f64::from(self.sign)
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct LcMaterializedSector {
+    color_index: usize,
+    reduction_weight: f64,
+}
+
+#[derive(Clone, Debug)]
+struct LcResolvedReplayRoute {
+    source_index: usize,
+    target_index: usize,
+    weight: f64,
+}
+
+#[derive(Clone, Debug)]
+struct LcResolvedReplayEntry {
+    routes: Vec<LcResolvedReplayRoute>,
+}
+
+#[derive(Clone, Debug)]
+struct LcResolvedReplayPlan {
+    #[cfg(test)]
+    entries: Vec<LcResolvedReplayEntry>,
+    routes_by_target: Vec<Vec<LcResolvedReplayTargetRoute>>,
+    color_count: usize,
+}
+
+#[derive(Clone, Debug)]
+struct LcResolvedReplayTargetRoute {
+    mapping_index: usize,
+    source_index: usize,
+    weight: f64,
+}
+
+#[derive(Clone, Debug)]
+struct LcResolvedReplaySelection {
+    #[cfg(test)]
+    mapping_indices: Vec<usize>,
+    #[cfg(test)]
+    entries: Vec<LcResolvedReplayEntry>,
+    #[cfg(test)]
+    source_helicity_indices: Vec<Vec<usize>>,
+    #[cfg(test)]
+    source_color_indices: Vec<Vec<usize>>,
+    source_groups: Vec<LcResolvedReplaySourceGroup>,
+    helicity_indices: Vec<usize>,
+    color_indices: Vec<usize>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct LcResolvedReplaySelectionKey {
+    helicity_indices: Option<Vec<usize>>,
+    color_indices: Option<Vec<usize>>,
+}
+
+#[derive(Clone, Debug)]
+struct LcResolvedReplaySourceGroup {
+    mapping_indices: Vec<usize>,
+    entries: Vec<LcResolvedReplayEntry>,
+    helicity_ids: BTreeSet<String>,
+    color_ids: BTreeSet<String>,
+    materialized_sector_ids: Option<BTreeSet<i64>>,
+    direct_total_plan: Option<LcDirectTotalPlan>,
+    source_component_count: usize,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct LcDirectTotalPlan {
+    mapping_index: usize,
+    materialized_sector_id: i64,
+    scale: f64,
+}
+
+fn uniform_lc_replay_total_scale(
+    replay_entry: &LcResolvedReplayEntry,
+    source_component_count: usize,
+    target_component_count: usize,
+) -> Option<f64> {
+    if source_component_count == 0 {
+        return None;
+    }
+    let mut source_scales = vec![0.0; source_component_count];
+    for route in &replay_entry.routes {
+        if route.source_index >= source_component_count
+            || route.target_index >= target_component_count
+            || !route.weight.is_finite()
+        {
+            return None;
+        }
+        source_scales[route.source_index] += route.weight;
+    }
+    let scale = source_scales[0];
+    if !scale.is_finite() || source_scales[1..].iter().any(|value| *value != scale) {
+        return None;
+    }
+    Some(scale)
+}
+
+pub const SYMJIT_APPLICATION_RUNTIME_CAPABILITY: &str = "symjit.application.complex-f64.v1";
+pub const SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY: &str =
+    "symbolica.legacy-jit-container.complex-f64.v1";
+pub const SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY: &str = "symbolica.compiled-cpp.complex-f64.v1";
+pub const SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY: &str = "symbolica.compiled-asm.complex-f64.v1";
+pub const EAGER_DAG_RUNTIME_CAPABILITY: &str = crate::EAGER_RUNTIME_CAPABILITY;
+pub const EAGER_RUNTIME_LAYOUT_CAPABILITY: &str = crate::eager_layout::EAGER_RUNTIME_CAPABILITY;
+pub const EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY: &str =
+    crate::eager_layout::EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY;
+pub const EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY: &str =
+    crate::EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY;
+pub const RECURRENCE_RUNTIME_CAPABILITY: &str = crate::recurrence::RECURRENCE_RUNTIME_CAPABILITY;
+pub const RECURRENCE_LC_COLOR_RUNTIME_CAPABILITY: &str =
+    crate::recurrence::RECURRENCE_LC_COLOR_CAPABILITY;
+pub const RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY: &str =
+    crate::recurrence::RECURRENCE_CONTRACTED_COLOR_CAPABILITY;
+pub const RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY: &str =
+    "rusticol.recurrence-helicity-selector-companion.v2";
+pub const ON_THE_FLY_RUNTIME_CAPABILITY: &str = "rusticol.on-the-fly.complex-f64.v1";
+pub const ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY: &str =
+    "rusticol.on-the-fly.contracted-color.v1";
+pub const ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY: &str = "rusticol.on-the-fly.lc-color.v1";
+pub const SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY: &str =
+    "rusticol.color-contraction.symmetric-group-fft.v1";
+pub const COMPILED_RUNTIME_SELECTORS_CAPABILITY: &str = "rusticol.compiled.runtime-selectors.v1";
+pub const COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY: &str = "compiled-plane-arena-v1";
+pub const COMPILED_PLANE_DIRECT_APPLICATION_ABI: &str = "pyamplicol-compiled-plane-kernel-v2";
+pub const COMPILED_PLANE_SOURCE_APPLICATION_ABI: &str = "pyamplicol-symjit-plane-application-v2";
+pub const COMPILED_HELICITY_DUAL_LANE_CAPABILITY: &str = "rusticol.compiled.helicity-dual-lane.v1";
+pub const COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY: &str =
+    "rusticol.compiled.helicity-selector-union.v1";
+pub const COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY: &str =
+    "rusticol.compiled.helicity-primary-recurrence.v1";
+pub const COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY: &str =
+    "rusticol.compiled.color-contraction-walsh.v1";
+pub const COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY: &str =
+    "rusticol.compiled.color-contraction-walsh-c2k.v1";
+pub const COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY: &str =
+    "rusticol.compiled.color-topology-lanes.v1";
+pub const SYMJIT_APPLICATION_STORAGE_ABI: &str = "symjit-application-storage-v3";
+pub const SYMJIT_PLANE_APPLICATION_ABI: &str = "pyamplicol-symjit-plane-application-v2";
+
+#[doc(hidden)]
+pub fn preflight_prepared_kernel_pack(
+    manifest_path: &Path,
+    payload_root: &Path,
+) -> RusticolResult<usize> {
+    let bytes = fs::read(manifest_path).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not read prepared kernel pack {}: {error}",
+            manifest_path.display()
+        ))
+    })?;
+    let pack: PreparedKernelPackManifest = serde_json::from_slice(&bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse prepared kernel pack {}: {error}",
+            manifest_path.display()
+        ))
+    })?;
+    pack.validate()?;
+    PreparedEvaluatorBackend::preflight_all(&pack, payload_root)
+}
+
+#[cfg(feature = "f64-symjit")]
+pub fn eager_direct_descriptor_for_source_application_bytes(
+    source_bytes: &[u8],
+    input_complex_count: u32,
+    output_complex_count: u32,
+    display_path: &Path,
+) -> RusticolResult<Vec<u8>> {
+    evaluator::symjit_eager_direct::eager_direct_descriptor_for_source_application_bytes(
+        source_bytes,
+        input_complex_count,
+        output_complex_count,
+        display_path,
+    )
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum RuntimeCapability {
+    CompiledColorContractionWalshC2kV1,
+    CompiledColorContractionWalshV1,
+    CompiledColorTopologyLanesV1,
+    CompiledHelicityDualLaneV1,
+    CompiledHelicityPrimaryRecurrenceV1,
+    CompiledHelicitySelectorUnionV1,
+    CompiledPlaneArenaV1,
+    CompiledRuntimeSelectorsV1,
+    EagerDagComplexF64V1,
+    EagerDirectArenaV1,
+    EagerRuntimeLayoutComplexF64V1,
+    EagerLcTopologyReplayComplexF64V1,
+    RecurrenceRuntimeComplexF64V1,
+    RecurrenceLcColorV1,
+    RecurrenceContractedColorV1,
+    RecurrenceHelicitySelectorCompanionV2,
+    SymmetricGroupFftColorContractionV1,
+    OnTheFlyRuntimeComplexF64V1,
+    OnTheFlyContractedColorV1,
+    OnTheFlyLcColorV1,
+    SymjitApplicationComplexF64V1,
+    SymbolicaLegacyJitContainerComplexF64V1,
+    SymbolicaCompiledCppComplexF64V1,
+    SymbolicaCompiledAsmComplexF64V1,
+}
+
+impl RuntimeCapability {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::CompiledColorContractionWalshC2kV1 => {
+                COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY
+            }
+            Self::CompiledColorContractionWalshV1 => COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY,
+            Self::CompiledColorTopologyLanesV1 => COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY,
+            Self::CompiledHelicityDualLaneV1 => COMPILED_HELICITY_DUAL_LANE_CAPABILITY,
+            Self::CompiledHelicityPrimaryRecurrenceV1 => {
+                COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY
+            }
+            Self::CompiledHelicitySelectorUnionV1 => COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY,
+            Self::CompiledPlaneArenaV1 => COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+            Self::CompiledRuntimeSelectorsV1 => COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+            Self::EagerDagComplexF64V1 => EAGER_DAG_RUNTIME_CAPABILITY,
+            Self::EagerDirectArenaV1 => EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            Self::EagerRuntimeLayoutComplexF64V1 => EAGER_RUNTIME_LAYOUT_CAPABILITY,
+            Self::EagerLcTopologyReplayComplexF64V1 => EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY,
+            Self::RecurrenceRuntimeComplexF64V1 => RECURRENCE_RUNTIME_CAPABILITY,
+            Self::RecurrenceLcColorV1 => RECURRENCE_LC_COLOR_RUNTIME_CAPABILITY,
+            Self::RecurrenceContractedColorV1 => RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            Self::RecurrenceHelicitySelectorCompanionV2 => {
+                RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY
+            }
+            Self::SymmetricGroupFftColorContractionV1 => {
+                SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY
+            }
+            Self::OnTheFlyRuntimeComplexF64V1 => ON_THE_FLY_RUNTIME_CAPABILITY,
+            Self::OnTheFlyContractedColorV1 => ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            Self::OnTheFlyLcColorV1 => ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+            Self::SymjitApplicationComplexF64V1 => SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+            Self::SymbolicaLegacyJitContainerComplexF64V1 => {
+                SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY
+            }
+            Self::SymbolicaCompiledCppComplexF64V1 => SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY,
+            Self::SymbolicaCompiledAsmComplexF64V1 => SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY,
+        }
+    }
+}
+
+pub fn supported_runtime_capabilities() -> Vec<&'static str> {
+    let mut capabilities = vec![
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        COMPILED_HELICITY_DUAL_LANE_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        EAGER_RUNTIME_LAYOUT_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        RECURRENCE_RUNTIME_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        RECURRENCE_LC_COLOR_RUNTIME_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        ON_THE_FLY_RUNTIME_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+        #[cfg(feature = "f64-symjit")]
+        SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+        #[cfg(feature = "symbolica-runtime")]
+        SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+        #[cfg(feature = "f64-compiled")]
+        SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY,
+        #[cfg(feature = "f64-compiled")]
+        SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY,
+    ];
+    capabilities.sort_unstable();
+    capabilities
+}
+
+pub(crate) fn ensure_runtime_capabilities_supported<'a>(
+    capabilities: impl IntoIterator<Item = &'a str>,
+) -> RusticolResult<()> {
+    for capability in capabilities {
+        if !runtime_capability_is_supported(capability) {
+            let supported = supported_runtime_capabilities();
+            return Err(RusticolError::unsupported_runtime_capability(
+                capability,
+                format!("this Rusticol build supports {supported:?}"),
+            ));
+        }
+    }
+    Ok(())
+}
+
+/// Test one capability on the successful runtime-load path without allocating
+/// and sorting a complete capability set.  The public reporting helper above
+/// still returns the complete sorted list when diagnostics need it.
+fn runtime_capability_is_supported(capability: &str) -> bool {
+    match capability {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY
+        | COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY
+        | COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY
+        | COMPILED_HELICITY_DUAL_LANE_CAPABILITY
+        | COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY
+        | COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY
+        | COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY
+        | COMPILED_RUNTIME_SELECTORS_CAPABILITY
+        | EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY
+        | EAGER_RUNTIME_LAYOUT_CAPABILITY
+        | RECURRENCE_RUNTIME_CAPABILITY
+        | RECURRENCE_LC_COLOR_RUNTIME_CAPABILITY
+        | RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY
+        | RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY
+        | SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY
+        | ON_THE_FLY_RUNTIME_CAPABILITY
+        | ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY
+        | ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY => true,
+        #[cfg(feature = "f64-symjit")]
+        SYMJIT_APPLICATION_RUNTIME_CAPABILITY => true,
+        #[cfg(feature = "symbolica-runtime")]
+        SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY => true,
+        #[cfg(feature = "f64-compiled")]
+        SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY | SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY => {
+            true
+        }
+        _ => false,
+    }
+}
+
+#[derive(Clone, Debug, Deserialize)]
+struct ExecutionManifestHeader {
+    #[serde(default)]
+    schema_version: u32,
+    #[serde(default)]
+    kind: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ExecutionSetManifest {
+    schema_version: u32,
+    kind: String,
+    #[serde(default)]
+    required_runtime_capabilities: Vec<String>,
+    processes: Vec<ExecutionSetEntry>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ExecutionSetEntry {
+    process_id: String,
+    manifest_path: String,
+    #[serde(default)]
+    required_runtime_capabilities: Vec<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct InputCrossingMapEntry {
+    target_index: usize,
+    source_index: usize,
+    sign: f64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ExecutionManifest {
+    schema_version: u32,
+    kind: String,
+    #[serde(default)]
+    required_runtime_capabilities: Vec<String>,
+    process: String,
+    key: String,
+    color_accuracy: String,
+    external_pdg_order: Vec<i32>,
+    compiled: EvaluatorSetManifest,
+    dag_summary: ExecutionSummary,
+    materialization_census: ExecutionMaterializationCensus,
+    runtime_schema: ExecutionPlan,
+    #[serde(default)]
+    color_contraction_payload: Option<CompiledColorContractionPayloadManifest>,
+    #[serde(default)]
+    physics_reduction: Option<crate::Reduction>,
+    #[serde(default)]
+    helicity_sum_execution: Option<Box<ExecutionManifest>>,
+    #[serde(default)]
+    helicity_selector_executions: Vec<HelicitySelectorExecutionManifest>,
+    #[serde(default)]
+    color_selector_executions: Vec<ColorSelectorExecutionManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct CompiledColorContractionPayloadManifest {
+    path: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct HelicitySelectorExecutionManifest {
+    selector_domain_ids: Vec<usize>,
+    #[serde(default)]
+    schedule_mode: HelicitySelectorScheduleMode,
+    execution: Box<ExecutionManifest>,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+enum HelicitySelectorScheduleMode {
+    #[default]
+    ParentClosure,
+    NestedRuntime,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ColorSelectorExecutionManifest {
+    materialized_sector_id: i64,
+    execution: Box<ExecutionManifest>,
+}
+
+#[derive(Clone, Debug)]
+struct EvaluatorSetManifest {
+    kind: String,
+    runtime_available: bool,
+    runtime_unavailable_message: Option<String>,
+    lc_topology_replay: Option<LcTopologyReplayManifest>,
+    color_topology_replay: Option<ColorTopologyReplayManifest>,
+    model_parameter_evaluator: Option<GenericModelParameterEvaluatorManifest>,
+    stage_evaluators: Option<GenericStageEvaluatorArtifactsManifest>,
+    momentum_slot_ids: Option<Vec<usize>>,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct EvaluatorSetManifestWire {
+    kind: String,
+    runtime_available: bool,
+    runtime_unavailable_message: Option<String>,
+    #[serde(default)]
+    lc_topology_replay: Option<LcTopologyReplayManifest>,
+    #[serde(default)]
+    color_topology_replay: Option<ColorTopologyReplayManifest>,
+    // Current Python artifacts mirror this additive contract under `compiled`.
+    // Runtime loading uses the authoritative runtime_schema copy below.
+    #[serde(default)]
+    helicity_recurrence: Option<HelicityRecurrenceManifest>,
+    #[serde(default)]
+    model_parameter_evaluator: Option<GenericModelParameterEvaluatorManifest>,
+    stage_evaluators: Option<GenericStageEvaluatorArtifactsManifest>,
+    #[serde(default)]
+    momentum_slot_ids: Option<Vec<usize>>,
+}
+
+impl<'de> Deserialize<'de> for EvaluatorSetManifest {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let wire = EvaluatorSetManifestWire::deserialize(deserializer)?;
+        let _validated_additive_mirror = wire.helicity_recurrence;
+        Ok(Self {
+            kind: wire.kind,
+            runtime_available: wire.runtime_available,
+            runtime_unavailable_message: wire.runtime_unavailable_message,
+            lc_topology_replay: wire.lc_topology_replay,
+            color_topology_replay: wire.color_topology_replay,
+            model_parameter_evaluator: wire.model_parameter_evaluator,
+            stage_evaluators: wire.stage_evaluators,
+            momentum_slot_ids: wire.momentum_slot_ids,
+        })
+    }
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct ColorTopologyReplayManifest {
+    #[serde(default)]
+    enabled: bool,
+    #[serde(default)]
+    mode: String,
+    #[serde(default)]
+    contract_version: Option<u32>,
+    #[serde(default)]
+    color_accuracy: String,
+    #[serde(default)]
+    physical_sector_count: Option<usize>,
+    #[serde(default)]
+    replayed_sector_count: usize,
+    #[serde(default)]
+    materialized_sector_ids: Vec<i64>,
+    #[serde(default)]
+    residual_sector_ids: Vec<i64>,
+    #[serde(default)]
+    groups: Vec<LcTopologyReplayGroupManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericModelParameterEvaluatorManifest {
+    kind: String,
+    #[serde(default)]
+    required_runtime_capabilities: Vec<String>,
+    input_parameter_indices: Vec<usize>,
+    outputs: Vec<GenericDerivedParameterOutputManifest>,
+    evaluator: EvaluatorManifest,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericDerivedParameterOutputManifest {
+    runtime_name: String,
+    output_index: usize,
+    real_parameter_index: usize,
+    imag_parameter_index: Option<usize>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct LcTopologyReplayManifest {
+    #[serde(default)]
+    enabled: bool,
+    #[serde(default)]
+    mode: String,
+    #[serde(default)]
+    contract_version: Option<u32>,
+    #[serde(default)]
+    physical_sector_count: Option<usize>,
+    #[serde(default)]
+    replayed_sector_count: usize,
+    #[serde(default)]
+    materialized_sector_ids: Vec<i64>,
+    #[serde(default)]
+    residual_sector_ids: Vec<i64>,
+    #[serde(default)]
+    groups: Vec<LcTopologyReplayGroupManifest>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct LcTopologyReplayGroupManifest {
+    representative_sector_id: i64,
+    materialized_sector_id: i64,
+    #[serde(default)]
+    active_sector_ids: Vec<i64>,
+    #[serde(default)]
+    proof: Option<LcTopologyReplayProofManifest>,
+    #[serde(default)]
+    sector_permutations: Vec<LcTopologyReplaySectorPermutationManifest>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct LcTopologyReplayProofManifest {
+    #[serde(default)]
+    status: String,
+    #[serde(default)]
+    algorithm: Option<String>,
+    #[serde(default)]
+    digest: Option<String>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct LcTopologyReplaySectorPermutationManifest {
+    sector_id: i64,
+    #[serde(default = "default_lc_topology_replay_weight")]
+    weight: f64,
+    #[serde(default = "default_lc_topology_replay_sign")]
+    sign: i8,
+    #[serde(default)]
+    factor: Option<Vec<f64>>,
+    #[serde(default)]
+    label_permutation: Vec<LcTopologyReplayLabelPermutationManifest>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct LcTopologyReplayLabelPermutationManifest {
+    representative_label: usize,
+    sector_label: usize,
+}
+
+fn default_lc_topology_replay_weight() -> f64 {
+    1.0
+}
+
+fn default_lc_topology_replay_sign() -> i8 {
+    1
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityRecurrenceManifest {
+    kind: String,
+    contract_version: u32,
+    proof_algorithm: String,
+    current_count: usize,
+    amplitude_root_count: usize,
+    proof_counts: HelicityRecurrenceProofCountsManifest,
+    selector_domains: Vec<HelicitySelectorDomainManifest>,
+    source_state_mappings: Vec<HelicitySourceStateMappingManifest>,
+    recurrence_classes: Vec<HelicityRecurrenceClassManifest>,
+    amplitude_classes: Vec<HelicityAmplitudeReplayClassManifest>,
+    residual_current_ids: Vec<usize>,
+    residual_root_ids: Vec<usize>,
+    structural_zero_selector_domain_ids: Vec<usize>,
+    diagnostics: Vec<String>,
+    #[serde(default)]
+    materialization: Option<HelicityRecurrenceMaterializationManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityRecurrenceProofCountsManifest {
+    recurrence_class_count: usize,
+    optimized_recurrence_class_count: usize,
+    optimized_current_count: usize,
+    residual_current_count: usize,
+    amplitude_class_count: usize,
+    optimized_amplitude_class_count: usize,
+    residual_amplitude_count: usize,
+    source_state_mapping_count: usize,
+    physical_helicity_count: usize,
+    structural_zero_helicity_count: usize,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicitySelectorDomainManifest {
+    id: usize,
+    complete: bool,
+    source_states: Vec<HelicitySelectorSourceStateManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd)]
+#[serde(deny_unknown_fields)]
+struct HelicitySelectorSourceStateManifest {
+    external_label: usize,
+    helicity: i32,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityCurrentReplayMemberManifest {
+    current_id: usize,
+    selector_domain_id: usize,
+    factor: [f64; 2],
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityRecurrenceClassManifest {
+    class_id: String,
+    representative_current_id: usize,
+    external_labels: Vec<usize>,
+    source_class: bool,
+    members: Vec<HelicityCurrentReplayMemberManifest>,
+    proof: HelicityRecurrenceProofManifest,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityRecurrenceProofManifest {
+    status: String,
+    algorithm: String,
+    digest: String,
+    transition_contract_ids: Vec<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicitySourceStateMappingManifest {
+    current_id: usize,
+    external_label: usize,
+    helicity: i32,
+    chirality: i32,
+    spin_state: GenericSourceSpinStateManifest,
+    declared_state_index: usize,
+    selector_domain_id: usize,
+    recurrence_class_id: String,
+    representative_current_id: usize,
+    source_contract_digest: String,
+    factor: [f64; 2],
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityAmplitudeReplayMemberManifest {
+    root_id: usize,
+    selector_domain_ids: Vec<usize>,
+    factor: [f64; 2],
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityAmplitudeReplayClassManifest {
+    class_id: String,
+    representative_root_id: usize,
+    members: Vec<HelicityAmplitudeReplayMemberManifest>,
+    proof: HelicityRecurrenceProofManifest,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityRecurrenceMaterializationManifest {
+    kind: String,
+    contract_version: u32,
+    #[serde(default)]
+    strategy: HelicityMaterializationStrategy,
+    proof_current_count: usize,
+    proof_root_count: usize,
+    materialized_current_count: usize,
+    materialized_root_count: usize,
+    proof_to_materialized_current: Vec<usize>,
+    source_routes: Vec<HelicityMaterializedSourceRouteManifest>,
+    amplitude_routes: Vec<HelicityMaterializedAmplitudeRouteManifest>,
+    selector_schedules: Vec<HelicityMaterializedSelectorScheduleManifest>,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+enum HelicityMaterializationStrategy {
+    #[default]
+    Quotient,
+    RetainedProofGraph,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityMaterializedSourceRouteManifest {
+    materialized_current_id: usize,
+    external_label: usize,
+    helicity: i32,
+    chirality: i32,
+    spin_state: GenericSourceSpinStateManifest,
+    declared_state_index: usize,
+    selector_domain_id: usize,
+    factor: [f64; 2],
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityMaterializedAmplitudeRouteManifest {
+    materialized_root_id: usize,
+    selector_domain_ids: Vec<usize>,
+    factor: [f64; 2],
+    residual: bool,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct HelicityMaterializedSelectorScheduleManifest {
+    selector_domain_id: usize,
+    active_current_ids: Vec<usize>,
+    active_root_ids: Vec<usize>,
+    structural_zero: bool,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicityRecurrenceRuntime {
+    selector_domains: Vec<HelicitySelectorDomainRuntime>,
+    source_state_mappings: Vec<HelicitySourceStateMappingRuntime>,
+    recurrence_classes: Vec<HelicityRecurrenceClassRuntime>,
+    amplitude_classes: Vec<HelicityAmplitudeReplayClassRuntime>,
+    residual_current_ids: Vec<usize>,
+    residual_root_ids: Vec<usize>,
+    structural_zero_selector_domain_ids: Vec<usize>,
+    materialization: Option<HelicityRecurrenceMaterializationRuntime>,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicitySelectorDomainRuntime {
+    complete: bool,
+    source_states: Vec<(usize, i32)>,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicityCurrentReplayMemberRuntime {
+    current_id: usize,
+    selector_domain_id: usize,
+    factor: [f64; 2],
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicityRecurrenceClassRuntime {
+    representative_current_id: usize,
+    external_labels: Vec<usize>,
+    source_class: bool,
+    members: Vec<HelicityCurrentReplayMemberRuntime>,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicitySourceStateMappingRuntime {
+    current_id: usize,
+    external_index: usize,
+    helicity: i32,
+    chirality: i32,
+    spin_state: GenericSourceSpinStateManifest,
+    declared_state_index: usize,
+    selector_domain_id: usize,
+    recurrence_class_index: usize,
+    representative_current_id: usize,
+    factor: [f64; 2],
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicityAmplitudeReplayMemberRuntime {
+    root_id: usize,
+    selector_domain_ids: Vec<usize>,
+    factor: [f64; 2],
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicityAmplitudeReplayClassRuntime {
+    representative_root_id: usize,
+    members: Vec<HelicityAmplitudeReplayMemberRuntime>,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicityRecurrenceMaterializationRuntime {
+    strategy: HelicityMaterializationStrategy,
+    proof_to_materialized_current: Vec<usize>,
+    source_routes: Vec<HelicityMaterializedSourceRouteRuntime>,
+    amplitude_routes: Vec<HelicityMaterializedAmplitudeRouteRuntime>,
+    selector_schedules: Vec<HelicityMaterializedSelectorScheduleRuntime>,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicityMaterializedSourceRouteRuntime {
+    materialized_current_id: usize,
+    external_index: usize,
+    helicity: i32,
+    chirality: i32,
+    spin_state: GenericSourceSpinStateManifest,
+    declared_state_index: usize,
+    selector_domain_id: usize,
+    factor: [f64; 2],
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicityMaterializedAmplitudeRouteRuntime {
+    materialized_root_id: usize,
+    selector_domain_ids: Vec<usize>,
+    factor: [f64; 2],
+    residual: bool,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug)]
+struct HelicityMaterializedSelectorScheduleRuntime {
+    selector_domain_id: usize,
+    active_current_ids: Vec<usize>,
+    active_root_ids: Vec<usize>,
+    active_stage_chunk_indices: Vec<Vec<usize>>,
+    active_amplitude_chunk_indices: Vec<usize>,
+    structural_zero: bool,
+}
+
+#[derive(Clone, Debug)]
+struct CompiledColorSelectorSchedule {
+    active_stage_chunk_indices: Vec<Vec<usize>>,
+    active_amplitude_chunk_indices: Vec<usize>,
+}
+
+#[derive(Clone, Debug)]
+struct CompiledColorExecutionPlan {
+    schedules_by_materialized_sector: BTreeMap<i64, Arc<CompiledColorSelectorSchedule>>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericStageEvaluatorArtifactsManifest {
+    kind: String,
+    #[serde(default)]
+    required_runtime_capabilities: Vec<String>,
+    runtime_available: bool,
+    runtime_unavailable_message: Option<String>,
+    parameter_count: usize,
+    value_parameter_count: usize,
+    momentum_parameter_count: usize,
+    #[serde(default)]
+    model_parameter_count: usize,
+    real_valued_inputs: Vec<usize>,
+    parameter_layout: String,
+    stage_count: usize,
+    stages: Vec<GenericSerializedStageEvaluatorManifest>,
+    amplitude_stage: GenericSerializedStageEvaluatorManifest,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericSerializedStageEvaluatorManifest {
+    stage_index: usize,
+    stage_kind: String,
+    subset_size: Option<usize>,
+    evaluator_label: String,
+    parameter_layout: String,
+    output_length: usize,
+    output_slots: Vec<GenericStageOutputSlotManifest>,
+    input_value_slot_ids: Vec<usize>,
+    output_value_slot_ids: Vec<usize>,
+    interaction_ids: Vec<usize>,
+    #[serde(default)]
+    input_components: Vec<GenericStageInputComponentManifest>,
+    #[serde(default)]
+    parameter_count: usize,
+    #[serde(default)]
+    value_parameter_count: usize,
+    #[serde(default)]
+    momentum_parameter_count: usize,
+    #[serde(default)]
+    model_parameter_count: usize,
+    #[serde(default)]
+    real_valued_inputs: Vec<usize>,
+    expression_ready: bool,
+    blockers: Vec<String>,
+    evaluator: EvaluatorManifest,
+    #[serde(default)]
+    compiled_plane_arena: Option<CompiledPlaneArenaStageManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct CompiledPlaneArenaStageManifest {
+    schema_version: u32,
+    kind: String,
+    application_abi: String,
+    source_application_abi: String,
+    element_layout: String,
+    output_operation: String,
+    output_factor: String,
+    input_output_aliasing: String,
+    output_output_aliasing: String,
+    input_bindings: Vec<CompiledPlaneInputBindingManifest>,
+    output_bindings: Vec<CompiledPlaneOutputBindingManifest>,
+    leaves: Vec<CompiledPlaneLeafManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct CompiledPlaneInputBindingManifest {
+    parameter_index: usize,
+    kind: String,
+    source_id: usize,
+    component: usize,
+    global_component: usize,
+    #[serde(default)]
+    real_valued: bool,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct CompiledPlaneOutputBindingManifest {
+    output_index: usize,
+    arena: String,
+    component: usize,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct CompiledPlaneLeafManifest {
+    application_path: String,
+    source_application_abi: String,
+    optimization_level: u8,
+    direct_codegen_optimization_level: u8,
+    input_len: usize,
+    output_len: usize,
+    input_indices: Vec<usize>,
+    output_start: usize,
+    output_stop: usize,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericStageInputComponentManifest {
+    kind: String,
+    source_id: usize,
+    component: usize,
+    global_component: usize,
+    parameter_index: usize,
+    #[serde(default)]
+    real_valued: bool,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericStageOutputSlotManifest {
+    value_slot_id: isize,
+    current_id: isize,
+    variant: String,
+    component_start: usize,
+    component_stop: usize,
+    output_start: usize,
+    output_stop: usize,
+    #[serde(default)]
+    color_selector_domain_ids: Vec<i64>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ExecutionSummary {
+    current_count: usize,
+    source_count: usize,
+    interaction_count: usize,
+    interaction_evaluation_count: usize,
+    amplitude_root_count: usize,
+    truncated: bool,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ExecutionMaterializationCensus {
+    abi: String,
+    basis: String,
+    r#final: BTreeMap<String, usize>,
+    peak: BTreeMap<String, usize>,
+    final_equals_peak: bool,
+}
+
+impl ExecutionMaterializationCensus {
+    fn from_summary(summary: &ExecutionSummary) -> Self {
+        let counts = BTreeMap::from([
+            (
+                "amplitude_root_count".to_string(),
+                summary.amplitude_root_count,
+            ),
+            ("current_count".to_string(), summary.current_count),
+            ("interaction_count".to_string(), summary.interaction_count),
+            (
+                "interaction_evaluation_count".to_string(),
+                summary.interaction_evaluation_count,
+            ),
+            ("source_count".to_string(), summary.source_count),
+        ]);
+        Self {
+            abi: "pyamplicol-fully-resident-materialization-census-v1".to_string(),
+            basis: "immutable-fully-resident-compiled-dag".to_string(),
+            r#final: counts.clone(),
+            peak: counts,
+            final_equals_peak: true,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ExecutionPlan {
+    schema_version: u32,
+    kind: String,
+    process_key: String,
+    process: String,
+    external_particles: Vec<GenericExternalParticleManifest>,
+    #[serde(default)]
+    model: Option<GenericRuntimeModelManifest>,
+    #[serde(default)]
+    model_parameters: Vec<GenericRuntimeModelParameterManifest>,
+    #[serde(default)]
+    normalization: Option<GenericRuntimeNormalizationManifest>,
+    parameter_layout: GenericParameterLayoutManifest,
+    current_storage: GenericCurrentStorageManifest,
+    value_storage: GenericValueStorageManifest,
+    source_fill: GenericSourceFillManifest,
+    momentum_slots: Vec<GenericMomentumSlotManifest>,
+    stages: Vec<GenericStageManifest>,
+    amplitude_stage: GenericAmplitudeStageManifest,
+    #[serde(default)]
+    helicity_recurrence: Option<HelicityRecurrenceManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericExternalParticleManifest {
+    label: usize,
+    index: usize,
+    pdg: i32,
+    outgoing_pdg: i32,
+    role: String,
+    momentum_slot: usize,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericRuntimeModelManifest {
+    #[serde(default)]
+    particles: Vec<GenericRuntimeParticleManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct GenericRuntimeModelParameterManifest {
+    name: String,
+    kind: String,
+    parameter_index: usize,
+    #[serde(default)]
+    default: f64,
+    #[serde(default)]
+    pdg: Option<i32>,
+    #[serde(default)]
+    runtime_name: Option<String>,
+    #[serde(default)]
+    complex_component: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericRuntimeParticleManifest {
+    pdg: i32,
+    #[serde(default)]
+    mass: f64,
+    #[serde(default)]
+    mass_parameter: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericRuntimeNormalizationManifest {
+    #[serde(default = "default_one_f64")]
+    color_factor: f64,
+    #[serde(default = "default_one_f64")]
+    global_coupling_factor: f64,
+    #[serde(default = "default_one_f64")]
+    average_factor: f64,
+    #[serde(default = "default_one_f64")]
+    identical_factor: f64,
+    #[serde(default)]
+    qcd_coupling_power: usize,
+    #[serde(default)]
+    electroweak_coupling_power: usize,
+}
+
+fn default_one_f64() -> f64 {
+    1.0
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericParameterLayoutManifest {
+    source_component_parameter_count: usize,
+    momentum_parameter_count: usize,
+    #[serde(default)]
+    model_parameter_count: usize,
+    parameter_count_if_flattened: usize,
+    value_component_count: usize,
+    source_components_complex: bool,
+    momentum_components_real: bool,
+    real_valued_inputs: Vec<usize>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericCurrentStorageManifest {
+    component_count: usize,
+    number_type: String,
+    #[serde(default)]
+    metadata_compacted: bool,
+    current_slots: Vec<GenericCurrentSlotManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericCurrentSlotManifest {
+    current_id: usize,
+    component_start: usize,
+    component_stop: usize,
+    dimension: usize,
+    is_source: bool,
+    particle_id: i32,
+    external_mask: u64,
+    #[serde(default)]
+    external_labels: Vec<usize>,
+    #[serde(default)]
+    helicity_ancestry: Value,
+    chirality: i32,
+    #[serde(default)]
+    spin_state: Value,
+    #[serde(default)]
+    flavour_flow: Vec<i32>,
+    #[serde(default)]
+    color_state: Value,
+    momentum_mask: u64,
+    auxiliary_kind: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericValueStorageManifest {
+    component_count: usize,
+    number_type: String,
+    #[serde(default)]
+    metadata_compacted: bool,
+    value_slots: Vec<GenericValueSlotManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericValueSlotManifest {
+    value_slot_id: usize,
+    current_id: usize,
+    variant: String,
+    component_start: usize,
+    component_stop: usize,
+    dimension: usize,
+    current_component_start: usize,
+    current_component_stop: usize,
+    is_source: bool,
+    applies_propagator: bool,
+    particle_id: i32,
+    external_mask: u64,
+    #[serde(default)]
+    external_labels: Vec<usize>,
+    momentum_mask: u64,
+    chirality: i32,
+    propagator: GenericPropagatorIrManifest,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+enum GenericPropagatorKindManifest {
+    Identity,
+    Scalar,
+    WeylFermion,
+    DiracFermion,
+    Vector,
+    Spin2,
+    Custom,
+    Unsupported,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+enum GenericPropagatorMassClassManifest {
+    Massless,
+    Massive,
+    NotApplicable,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+enum GenericPropagatorGaugeManifest {
+    Feynman,
+    Unitary,
+    DeDonder,
+    FierzPauli,
+    ModelSupplied,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+enum GenericGoldstonePolicyManifest {
+    NotApplicable,
+    Absorbed,
+    Explicit,
+    ModelSupplied,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericPropagatorIrManifest {
+    identity: GenericParticleIdentityIrManifest,
+    particle_id: i32,
+    chirality: i32,
+    kind: GenericPropagatorKindManifest,
+    backend: String,
+    basis: String,
+    applies_propagator: bool,
+    kernel: String,
+    full_tensor_network_ready: bool,
+    mass_class: GenericPropagatorMassClassManifest,
+    gauge: Option<GenericPropagatorGaugeManifest>,
+    numerator: Option<String>,
+    denominator: Option<String>,
+    mass_parameter: Option<String>,
+    width_parameter: Option<String>,
+    custom_source: Option<String>,
+    auxiliary_policy: Option<String>,
+    goldstone_policy: GenericGoldstonePolicyManifest,
+    description: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericSourceFillManifest {
+    source_count: usize,
+    sources: Vec<GenericSourceRecordManifest>,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+enum GenericSourceOrientationManifest {
+    Particle,
+    Antiparticle,
+    SelfConjugate,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "lowercase")]
+enum GenericParticleStatisticsManifest {
+    Boson,
+    Fermion,
+    Ghost,
+    Auxiliary,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "lowercase")]
+enum GenericWavefunctionFamilyManifest {
+    Scalar,
+    Fermion,
+    Vector,
+    Spin2,
+    Ghost,
+    Auxiliary,
+}
+
+impl GenericWavefunctionFamilyManifest {
+    const fn as_str(self) -> &'static str {
+        match self {
+            Self::Scalar => "scalar",
+            Self::Fermion => "fermion",
+            Self::Vector => "vector",
+            Self::Spin2 => "spin2",
+            Self::Ghost => "ghost",
+            Self::Auxiliary => "auxiliary",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+enum GenericMomentumTransformManifest {
+    Identity,
+    NegateFourMomentum,
+}
+
+impl GenericMomentumTransformManifest {
+    const fn legacy_projection(self) -> &'static str {
+        match self {
+            Self::Identity => "identity",
+            Self::NegateFourMomentum => "negate-incoming-momentum",
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(untagged)]
+enum GenericSourceSpinStateManifest {
+    Scalar(i32),
+    Components(Vec<i32>),
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+struct GenericSourceStateIrManifest {
+    helicity: i32,
+    chirality: i32,
+    spin_state: GenericSourceSpinStateManifest,
+}
+
+impl GenericSourceStateIrManifest {
+    fn transformed(&self, crossing: &GenericCrossingIrManifest) -> Result<Self, &'static str> {
+        let helicity = self
+            .helicity
+            .checked_mul(crossing.helicity_factor)
+            .ok_or("source crossing overflows the helicity state")?;
+        let chirality = self
+            .chirality
+            .checked_mul(crossing.chirality_factor)
+            .ok_or("source crossing overflows the chirality state")?;
+        let spin_state = match (&self.spin_state, crossing.spin_state_factor) {
+            (state, 1) => state.clone(),
+            (GenericSourceSpinStateManifest::Scalar(state), factor) => {
+                GenericSourceSpinStateManifest::Scalar(
+                    state
+                        .checked_mul(factor)
+                        .ok_or("source crossing overflows the spin state")?,
+                )
+            }
+            (GenericSourceSpinStateManifest::Components(_), _) => {
+                return Err("crossing cannot multiply a structured source spin state");
+            }
+        };
+        Ok(Self {
+            helicity,
+            chirality,
+            spin_state,
+        })
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+struct GenericCrossingIrManifest {
+    momentum_transform: GenericMomentumTransformManifest,
+    helicity_factor: i32,
+    chirality_factor: i32,
+    spin_state_factor: i32,
+    phase: [f64; 2],
+}
+
+impl GenericCrossingIrManifest {
+    fn is_identity(&self) -> bool {
+        self.momentum_transform == GenericMomentumTransformManifest::Identity
+            && self.helicity_factor == 1
+            && self.chirality_factor == 1
+            && self.spin_state_factor == 1
+            && self.phase == [1.0, 0.0]
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+struct GenericParticleIdentityIrManifest {
+    canonical_id: String,
+    species_id: String,
+    anti_canonical_id: String,
+    display_name: String,
+    anti_display_name: String,
+    pdg_label: i32,
+    anti_pdg_label: i32,
+    orientation: GenericSourceOrientationManifest,
+    self_conjugate: bool,
+}
+
+fn deserialize_required_nullable_string<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    match Value::deserialize(deserializer)? {
+        Value::Null => Ok(None),
+        Value::String(value) => Ok(Some(value)),
+        _ => Err(<D::Error as serde::de::Error>::custom(
+            "expected a string or null",
+        )),
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+struct GenericSourceIrManifest {
+    identity: GenericParticleIdentityIrManifest,
+    statistics: GenericParticleStatisticsManifest,
+    wavefunction_family: GenericWavefunctionFamilyManifest,
+    component_dimension: usize,
+    states: Vec<GenericSourceStateIrManifest>,
+    crossing: GenericCrossingIrManifest,
+    basis: String,
+    #[serde(deserialize_with = "deserialize_required_nullable_string")]
+    mass_parameter: Option<String>,
+    #[serde(deserialize_with = "deserialize_required_nullable_string")]
+    width_parameter: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct GenericSourceRecordManifest {
+    source_id: usize,
+    current_id: usize,
+    current_component_start: usize,
+    current_component_stop: usize,
+    value_slot: GenericValueSlotRefManifest,
+    source_parameter_start: usize,
+    source_parameter_stop: usize,
+    leg_label: usize,
+    input_momentum_slot: usize,
+    side: String,
+    crossing: String,
+    physical_pdg: i32,
+    outgoing_pdg: i32,
+    particle_id: i32,
+    anti_particle_id: i32,
+    source_kind: String,
+    wavefunction_kind: String,
+    source_orientation: GenericSourceOrientationManifest,
+    source_basis: String,
+    source_ir: GenericSourceIrManifest,
+    applied_crossing: GenericCrossingIrManifest,
+    source_helicity: i32,
+    chirality: i32,
+    spin_state: Value,
+    dimension: usize,
+    helicity_ancestry: Value,
+    color_state: Value,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct GenericMomentumSlotManifest {
+    momentum_slot_id: usize,
+    momentum_mask: u64,
+    external_labels: Vec<usize>,
+    component_start: usize,
+    component_stop: usize,
+    real_valued: bool,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericStageManifest {
+    stage_index: usize,
+    stage_kind: String,
+    subset_size: usize,
+    input_current_ids: Vec<usize>,
+    output_current_ids: Vec<usize>,
+    input_value_slot_ids: Vec<usize>,
+    output_value_slot_ids: Vec<usize>,
+    interaction_count: usize,
+    #[serde(default)]
+    interactions_compacted: bool,
+    #[serde(default)]
+    interaction_ids: Vec<usize>,
+    #[serde(default)]
+    interactions: Vec<GenericInteractionManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericInteractionManifest {
+    interaction_id: usize,
+    vertex_kind: i32,
+    vertex_particles: Vec<i32>,
+    left_current_id: usize,
+    right_current_id: usize,
+    result_current_id: usize,
+    left_slot: GenericSlotRefManifest,
+    right_slot: GenericSlotRefManifest,
+    result_slot: GenericSlotRefManifest,
+    left_value_slot: GenericValueSlotRefManifest,
+    right_value_slot: GenericValueSlotRefManifest,
+    result_value_slots: Vec<GenericValueSlotRefManifest>,
+    result_requires_propagated_value: bool,
+    result_requires_unpropagated_value: bool,
+    momentum_slots: GenericInteractionMomentumSlotsManifest,
+    coupling: Vec<f64>,
+    color_weight: Vec<f64>,
+    accumulation: String,
+    lowering: GenericLoweringManifest,
+    full_tensor_network_ready: bool,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericLoweringManifest {
+    kind: i32,
+    backend: String,
+    tensor_names: Vec<String>,
+    expression_head: String,
+    full_tensor_network_ready: bool,
+    description: String,
+    kernel: String,
+    input_roles: Vec<String>,
+    output_role: String,
+    coupling_mode: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericInteractionMomentumSlotsManifest {
+    left: usize,
+    right: usize,
+    result: usize,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericSlotRefManifest {
+    current_id: usize,
+    component_start: usize,
+    component_stop: usize,
+    dimension: usize,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericAmplitudeStageManifest {
+    stage_kind: String,
+    output_count: usize,
+    #[serde(default)]
+    color_contraction: Option<GenericColorContractionManifest>,
+    #[serde(default)]
+    color_topology_replay: Option<GenericColorTopologyReplayAmplitudeManifest>,
+    roots: Vec<GenericAmplitudeRootManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericColorTopologyReplayAmplitudeManifest {
+    contract_version: u32,
+    physical_group_count: usize,
+    physical_groups: Vec<GenericColorTopologyReplayPhysicalGroupManifest>,
+    mappings: Vec<GenericColorTopologyReplayMappingManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericColorTopologyReplayPhysicalGroupManifest {
+    group_id: i64,
+    helicities: Vec<i32>,
+    color_sector_id: i64,
+    color_word: Vec<usize>,
+    helicity_weight: f64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericColorTopologyReplayMappingManifest {
+    label_permutation: Vec<LcTopologyReplayLabelPermutationManifest>,
+    group_routes: Vec<GenericColorTopologyReplayGroupRouteManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericColorTopologyReplayGroupRouteManifest {
+    source_group_id: i64,
+    target_group_id: i64,
+    factor: Vec<f64>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericColorContractionManifest {
+    supported: bool,
+    #[serde(default)]
+    reason: Option<String>,
+    group_count: usize,
+    #[serde(default)]
+    includes_color_factor: bool,
+    entries: Vec<GenericColorContractionEntryManifest>,
+    #[serde(default)]
+    repeated_block: Option<GenericRepeatedColorContractionBlockManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericColorContractionEntryManifest {
+    left_group_id: i64,
+    right_group_id: i64,
+    weight: Vec<f64>,
+    // Retained for Python arbitrary precision; native contraction keeps its f64 weight.
+    #[serde(default, rename = "exact_weight")]
+    _exact_weight: Option<[String; 4]>,
+    #[serde(default = "default_symmetry_factor")]
+    symmetry_factor: f64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericRepeatedColorContractionBlockManifest {
+    component_count: usize,
+    component_group_ids: Vec<i64>,
+    entries: Vec<GenericRepeatedColorContractionEntryManifest>,
+    #[serde(default)]
+    factorized_block: Option<GenericFactorizedColorContractionBlockManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(tag = "kind", deny_unknown_fields)]
+enum GenericFactorizedColorContractionBlockManifest {
+    #[serde(rename = "klein-four-walsh")]
+    KleinFourWalsh { cosets: Vec<[usize; 4]> },
+    #[serde(rename = "elementary-abelian-walsh")]
+    ElementaryAbelianWalsh {
+        rank: usize,
+        cosets: Vec<Vec<usize>>,
+    },
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericRepeatedColorContractionEntryManifest {
+    left_group_index: usize,
+    right_group_index: usize,
+    weight: Vec<f64>,
+    #[serde(default, rename = "exact_weight")]
+    _exact_weight: Option<[String; 4]>,
+    #[serde(default = "default_symmetry_factor")]
+    symmetry_factor: f64,
+}
+
+fn default_symmetry_factor() -> f64 {
+    1.0
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericAmplitudeRootManifest {
+    output_index: usize,
+    root_id: usize,
+    kind: String,
+    left_current_id: usize,
+    right_current_id: usize,
+    left_slot: GenericSlotRefManifest,
+    right_slot: GenericSlotRefManifest,
+    left_value_slot: GenericValueSlotRefManifest,
+    right_value_slot: GenericValueSlotRefManifest,
+    vertex_kind: Option<i32>,
+    vertex_particles: Option<Vec<i32>>,
+    coupling: Vec<f64>,
+    color_weight: Vec<f64>,
+    #[serde(default)]
+    color_sector_id: Option<i64>,
+    contraction: String,
+    contraction_ir: GenericContractionIrManifest,
+    coherent_group_id: Option<Value>,
+    helicity_weight: f64,
+    #[serde(default)]
+    all_sector_weight: Option<f64>,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "lowercase")]
+enum GenericContractionChiralityRelationManifest {
+    Any,
+    Equal,
+    Opposite,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct GenericContractionIrManifest {
+    name: String,
+    left_basis: String,
+    right_basis: String,
+    coefficients: Vec<[f64; 2]>,
+    chirality_relation: GenericContractionChiralityRelationManifest,
+    #[serde(deserialize_with = "deserialize_required_nullable_string")]
+    metric_signature: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct GenericValueSlotRefManifest {
+    value_slot_id: usize,
+    current_id: usize,
+    variant: String,
+    component_start: usize,
+    component_stop: usize,
+    dimension: usize,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct NativeCompiledDirectTargetManifest {
+    triple: String,
+    cpu_features: Vec<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct NativeCompiledDirectApplicationManifest {
+    application_abi: String,
+    function_name: String,
+    source_path: String,
+    library_path: String,
+    target: NativeCompiledDirectTargetManifest,
+    evaluator_state_sha256: String,
+    instruction_count: u32,
+    temporary_count: u32,
+    input_plane_count: u32,
+    scalar_input_count: u32,
+    output_plane_count: u32,
+    simd_lane_width: u32,
+    logical_stack_bytes: u32,
+    output_semantics: String,
+}
+
+impl NativeCompiledDirectApplicationManifest {
+    fn validate(
+        &self,
+        expected_function_name: &str,
+        input_len: usize,
+        output_len: usize,
+    ) -> RusticolResult<()> {
+        const APPLICATION_ABI: &str = "pyamplicol-native-compiled-direct-application-v1";
+        const OUTPUT_SEMANTICS: &str = "factor-free-overwrite";
+        const MAXIMUM_LOGICAL_STACK_BYTES: u32 = 64 * 1024;
+
+        if self.application_abi != APPLICATION_ABI {
+            return Err(RusticolError::compatibility(format!(
+                "native compiled DirectApplication declares ABI {:?}, expected {APPLICATION_ABI:?}",
+                self.application_abi
+            )));
+        }
+        if self.function_name != expected_function_name {
+            return Err(RusticolError::integrity(
+                "native compiled DirectApplication function identity does not match its evaluator",
+            ));
+        }
+        if self.source_path.is_empty()
+            || self.library_path.is_empty()
+            || self.source_path == self.library_path
+            || self.target.triple.is_empty()
+            || self.target.triple.contains('\0')
+        {
+            return Err(RusticolError::integrity(
+                "native compiled DirectApplication paths or target are invalid",
+            ));
+        }
+        if self
+            .target
+            .cpu_features
+            .windows(2)
+            .any(|pair| pair[0] >= pair[1])
+            || self
+                .target
+                .cpu_features
+                .iter()
+                .any(|feature| feature.is_empty() || feature.contains('\0'))
+        {
+            return Err(RusticolError::integrity(
+                "native compiled DirectApplication CPU features are not sorted and unique",
+            ));
+        }
+        if self.evaluator_state_sha256.len() != 64
+            || !self
+                .evaluator_state_sha256
+                .bytes()
+                .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+        {
+            return Err(RusticolError::integrity(
+                "native compiled DirectApplication evaluator-state digest is invalid",
+            ));
+        }
+        if self.instruction_count == 0
+            || self.input_plane_count == 0
+            || !matches!(self.simd_lane_width, 2 | 4)
+            || self.logical_stack_bytes == 0
+            || self.logical_stack_bytes > MAXIMUM_LOGICAL_STACK_BYTES
+            || self.output_semantics != OUTPUT_SEMANTICS
+        {
+            return Err(RusticolError::integrity(
+                "native compiled DirectApplication execution shape is invalid",
+            ));
+        }
+
+        let expected_output_planes = u32::try_from(output_len.checked_mul(2).ok_or_else(|| {
+            RusticolError::integrity("native compiled DirectApplication output shape overflows")
+        })?)
+        .map_err(|_| {
+            RusticolError::integrity("native compiled DirectApplication output shape exceeds u32")
+        })?;
+        if self.output_plane_count != expected_output_planes {
+            return Err(RusticolError::integrity(
+                "native compiled DirectApplication output planes do not match its evaluator",
+            ));
+        }
+
+        let descriptor_count = self
+            .input_plane_count
+            .checked_add(self.scalar_input_count)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "native compiled DirectApplication input descriptor count overflows",
+                )
+            })?;
+        let minimum_descriptors = u32::try_from(input_len).map_err(|_| {
+            RusticolError::integrity(
+                "native compiled DirectApplication logical input count exceeds u32",
+            )
+        })?;
+        let maximum_descriptors = minimum_descriptors.checked_mul(2).ok_or_else(|| {
+            RusticolError::integrity(
+                "native compiled DirectApplication maximum descriptor count overflows",
+            )
+        })?;
+        if descriptor_count < minimum_descriptors || descriptor_count > maximum_descriptors {
+            return Err(RusticolError::integrity(
+                "native compiled DirectApplication descriptors do not cover evaluator inputs",
+            ));
+        }
+
+        let expected_stack_bytes = self
+            .temporary_count
+            .checked_add(u32::try_from(output_len).map_err(|_| {
+                RusticolError::integrity(
+                    "native compiled DirectApplication output count exceeds u32",
+                )
+            })?)
+            .and_then(|count| count.checked_mul(2))
+            .and_then(|count| count.checked_mul(std::mem::size_of::<f64>() as u32))
+            .and_then(|bytes| bytes.checked_mul(self.simd_lane_width))
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "native compiled DirectApplication logical stack shape overflows",
+                )
+            })?;
+        if self.logical_stack_bytes != expected_stack_bytes {
+            return Err(RusticolError::integrity(
+                "native compiled DirectApplication logical stack metadata is inconsistent",
+            ));
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+#[serde(tag = "kind")]
+enum EvaluatorManifest {
+    #[serde(rename = "symjit-application-evaluator")]
+    SymjitApplication {
+        runtime_capability: String,
+        application_path: String,
+        application_abi: String,
+        input_len: usize,
+        output_len: usize,
+        element_layout: String,
+        batch_layout: String,
+        compiler_type: String,
+        translation_mode: String,
+        optimization_level: u8,
+        word_bits: u8,
+        endianness: String,
+        required_defuns: Vec<String>,
+        #[serde(default)]
+        plane_application: Option<SymjitPlaneApplicationManifest>,
+        evaluator_state_path: Option<String>,
+        evaluator_state_runtime_capability: Option<String>,
+    },
+    #[serde(rename = "jit-symbolica-evaluator")]
+    Jit {
+        runtime_capability: String,
+        input_len: usize,
+        output_len: usize,
+        evaluator_state_path: String,
+    },
+    #[serde(rename = "compiled-complex-evaluator")]
+    CompiledComplex {
+        runtime_capability: String,
+        function_name: String,
+        input_len: usize,
+        output_len: usize,
+        library_path: String,
+        evaluator_state_path: Option<String>,
+        number_type: String,
+        #[serde(default)]
+        native_direct_application: Option<NativeCompiledDirectApplicationManifest>,
+    },
+    #[serde(rename = "chunked-symbolica-evaluator")]
+    Chunked {
+        required_runtime_capabilities: Vec<String>,
+        #[serde(default)]
+        input_len: Option<usize>,
+        #[serde(default)]
+        chunk_input_indices: Option<Vec<Vec<usize>>>,
+        chunks: Vec<EvaluatorManifest>,
+    },
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct SymjitPlaneApplicationManifest {
+    application_path: String,
+    application_abi: String,
+    storage_abi: String,
+    element_layout: String,
+    descriptor_order: String,
+    input_complex_count: usize,
+    output_complex_count: usize,
+    input_plane_count: usize,
+    output_plane_count: usize,
+    compiler_type: String,
+    translation_mode: String,
+    optimization_level: u8,
+    simd: bool,
+    complex: bool,
+    fast_math: bool,
+    fast_complex: bool,
+    compression: bool,
+    threading: bool,
+    direct_arena: bool,
+    source_digest: String,
+    target: Value,
+}
+
+impl SymjitPlaneApplicationManifest {
+    fn validate(
+        &self,
+        input_complex_count: usize,
+        output_complex_count: usize,
+        optimization_level: u8,
+    ) -> RusticolResult<()> {
+        let expected_inputs = input_complex_count
+            .checked_mul(2)
+            .ok_or_else(|| RusticolError::integrity("SymJIT plane input count overflows usize"))?;
+        let expected_outputs = output_complex_count
+            .checked_mul(2)
+            .ok_or_else(|| RusticolError::integrity("SymJIT plane output count overflows usize"))?;
+        let digest_valid = self.source_digest.len() == 64
+            && self
+                .source_digest
+                .bytes()
+                .all(|value| value.is_ascii_hexdigit() && !value.is_ascii_uppercase());
+        if self.application_path.is_empty()
+            || self.application_abi != SYMJIT_PLANE_APPLICATION_ABI
+            || self.storage_abi != SYMJIT_APPLICATION_STORAGE_ABI
+            || self.element_layout != "split-complex-plane-major"
+            || self.descriptor_order != "inputs-re-im-then-outputs-re-im"
+            || self.input_complex_count != input_complex_count
+            || self.output_complex_count != output_complex_count
+            || self.input_plane_count != expected_inputs
+            || self.output_plane_count != expected_outputs
+            || self.compiler_type != "native"
+            || self.translation_mode != "symbolica-structured-instructions"
+            || self.optimization_level != optimization_level
+            || !self.simd
+            || !self.complex
+            || !self.fast_math
+            || self.fast_complex
+            || self.threading
+            || !self.direct_arena
+            || !digest_valid
+            || !valid_symjit_plane_target(&self.target)
+        {
+            return Err(RusticolError::compatibility(
+                "SymJIT plane application metadata is incompatible; regenerate the artifact",
+            ));
+        }
+        Ok(())
+    }
+}
+
+fn valid_symjit_plane_target(target: &Value) -> bool {
+    let Some(target) = target.as_object() else {
+        return false;
+    };
+    if target.keys().any(|key| {
+        !matches!(
+            key.as_str(),
+            "word_bits" | "endianness" | "triple" | "cpu_features"
+        )
+    }) || target.get("word_bits").and_then(Value::as_u64) != Some(64)
+        || target.get("endianness").and_then(Value::as_str) != Some("little")
+    {
+        return false;
+    }
+    if let Some(triple) = target.get("triple") {
+        let Some(triple) = triple.as_str() else {
+            return false;
+        };
+        if triple.is_empty() || triple.contains('\0') {
+            return false;
+        }
+    }
+    if let Some(features) = target.get("cpu_features") {
+        let Some(features) = features.as_array() else {
+            return false;
+        };
+        let mut previous: Option<&str> = None;
+        for feature in features {
+            let Some(feature) = feature.as_str() else {
+                return false;
+            };
+            if feature.is_empty()
+                || feature.contains('\0')
+                || previous.is_some_and(|previous| previous >= feature)
+            {
+                return false;
+            }
+            previous = Some(feature);
+        }
+    }
+    true
+}
+
+/// One leaf in the canonical evaluator preorder used by loading, selector
+/// coverage, and Direct-Arena lowering.
+///
+/// Keeping the composed root-input map and output range together prevents
+/// independently implemented flattening walks from silently assigning
+/// selector chunk indices to different leaves.
+struct EvaluatorLeafLayout<'a> {
+    evaluator: &'a EvaluatorManifest,
+    input_indices: Vec<usize>,
+    output_range: std::ops::Range<usize>,
+}
+
+impl EvaluatorManifest {
+    fn io_len(&self) -> RusticolResult<(usize, usize)> {
+        match self {
+            Self::SymjitApplication {
+                input_len,
+                output_len,
+                ..
+            }
+            | Self::Jit {
+                input_len,
+                output_len,
+                ..
+            } => Ok((*input_len, *output_len)),
+            Self::CompiledComplex {
+                function_name,
+                input_len,
+                output_len,
+                ..
+            } => {
+                if let Self::CompiledComplex {
+                    native_direct_application: Some(application),
+                    ..
+                } = self
+                {
+                    application.validate(function_name, *input_len, *output_len)?;
+                }
+                Ok((*input_len, *output_len))
+            }
+            Self::Chunked {
+                input_len,
+                chunk_input_indices,
+                chunks,
+                ..
+            } => {
+                if chunks.is_empty() {
+                    return Err(RusticolError::artifact(
+                        "generic serialized evaluator chunk list is empty",
+                    ));
+                }
+                let mut child_layouts = Vec::with_capacity(chunks.len());
+                let mut output_len = 0usize;
+                for chunk in chunks {
+                    let layout = chunk.io_len()?;
+                    output_len = output_len.checked_add(layout.1).ok_or_else(|| {
+                        RusticolError::artifact(
+                            "generic serialized evaluator output length overflows usize",
+                        )
+                    })?;
+                    child_layouts.push(layout);
+                }
+                match (input_len, chunk_input_indices) {
+                    (None, None) => {
+                        let parent_input_len = child_layouts[0].0;
+                        if child_layouts
+                            .iter()
+                            .any(|(child_input_len, _)| *child_input_len != parent_input_len)
+                        {
+                            return Err(RusticolError::artifact(
+                                "legacy chunked evaluator children have inconsistent input lengths",
+                            ));
+                        }
+                        Ok((parent_input_len, output_len))
+                    }
+                    (Some(parent_input_len), Some(input_indices)) => {
+                        if input_indices.len() != chunks.len() {
+                            return Err(RusticolError::artifact(
+                                "chunked evaluator input maps do not match evaluator chunks",
+                            ));
+                        }
+                        for (indices, (child_input_len, _)) in
+                            input_indices.iter().zip(&child_layouts)
+                        {
+                            if indices.len() != *child_input_len
+                                || indices.iter().any(|index| *index >= *parent_input_len)
+                                || indices.windows(2).any(|pair| pair[0] >= pair[1])
+                            {
+                                return Err(RusticolError::artifact(
+                                    "chunked evaluator input map is inconsistent with child inputs",
+                                ));
+                            }
+                        }
+                        Ok((*parent_input_len, output_len))
+                    }
+                    _ => Err(RusticolError::artifact(
+                        "chunked evaluator input metadata is incomplete",
+                    )),
+                }
+            }
+        }
+    }
+
+    fn leaf_layout(&self) -> RusticolResult<Vec<EvaluatorLeafLayout<'_>>> {
+        fn append_leaf_layouts<'a>(
+            evaluator: &'a EvaluatorManifest,
+            parent_inputs: &[usize],
+            output_cursor: &mut usize,
+            leaves: &mut Vec<EvaluatorLeafLayout<'a>>,
+        ) -> RusticolResult<()> {
+            match evaluator {
+                EvaluatorManifest::Chunked {
+                    input_len,
+                    chunk_input_indices,
+                    chunks,
+                    ..
+                } => {
+                    evaluator.io_len()?;
+                    if let Some(input_len) = input_len
+                        && *input_len != parent_inputs.len()
+                    {
+                        return Err(RusticolError::artifact(
+                            "chunked evaluator parent input mapping has an inconsistent length",
+                        ));
+                    }
+                    match chunk_input_indices {
+                        Some(chunk_inputs) => {
+                            for (chunk, indices) in chunks.iter().zip(chunk_inputs) {
+                                let mapped = indices
+                                    .iter()
+                                    .map(|index| {
+                                        parent_inputs.get(*index).copied().ok_or_else(|| {
+                                            RusticolError::artifact(
+                                                "chunked evaluator input map references an absent parent input",
+                                            )
+                                        })
+                                    })
+                                    .collect::<RusticolResult<Vec<_>>>()?;
+                                append_leaf_layouts(chunk, &mapped, output_cursor, leaves)?;
+                            }
+                        }
+                        None => {
+                            for chunk in chunks {
+                                append_leaf_layouts(chunk, parent_inputs, output_cursor, leaves)?;
+                            }
+                        }
+                    }
+                }
+                _ => {
+                    let (input_len, output_len) = evaluator.io_len()?;
+                    if input_len != parent_inputs.len() {
+                        return Err(RusticolError::artifact(
+                            "evaluator leaf input mapping has an inconsistent length",
+                        ));
+                    }
+                    if output_len == 0 {
+                        return Err(RusticolError::artifact(
+                            "evaluator leaf has an empty output range",
+                        ));
+                    }
+                    let output_stop = output_cursor.checked_add(output_len).ok_or_else(|| {
+                        RusticolError::artifact("evaluator leaf output range overflows usize")
+                    })?;
+                    leaves.push(EvaluatorLeafLayout {
+                        evaluator,
+                        input_indices: parent_inputs.to_vec(),
+                        output_range: *output_cursor..output_stop,
+                    });
+                    *output_cursor = output_stop;
+                }
+            }
+            Ok(())
+        }
+
+        let (root_input_len, root_output_len) = self.io_len()?;
+        let root_inputs = (0..root_input_len).collect::<Vec<_>>();
+        let mut output_cursor = 0;
+        let mut leaves = Vec::new();
+        append_leaf_layouts(self, &root_inputs, &mut output_cursor, &mut leaves)?;
+        if output_cursor != root_output_len {
+            return Err(RusticolError::artifact(
+                "evaluator leaf output ranges do not cover the root output",
+            ));
+        }
+        Ok(leaves)
+    }
+}
+
+struct EvaluatorGroup {
+    evaluators: Vec<LoadedEvaluator>,
+    input_len: usize,
+    input_mappings: Vec<Option<Vec<usize>>>,
+    input_mapping_spans: Vec<Vec<(usize, usize, usize)>>,
+    output_len: usize,
+    chunk_parameter_scratch_f64: Vec<Complex<f64>>,
+    chunk_scratch_f64: Vec<Complex<f64>>,
+    chunk_parameter_scratch_aosoa_f64: Vec<f64>,
+    chunk_scratch_aosoa_f64: Vec<f64>,
+    chunk_input_mapping_scratch: Vec<usize>,
+}
+
+// Evaluator groups already own these values behind a Vec allocation. Boxing
+// only the SymJIT variant would add an indirection to every hot kernel call.
+#[allow(clippy::large_enum_variant)]
+enum F64Evaluator {
+    #[cfg(feature = "symbolica-runtime")]
+    ExactOnly,
+    #[cfg(feature = "f64-symjit")]
+    SymjitApplication(SymjitApplicationEvaluator),
+    #[cfg(feature = "f64-compiled")]
+    Compiled(CompiledComplexF64Evaluator),
+    #[cfg(feature = "symbolica-runtime")]
+    Jit(JITCompiledEvaluator<Complex<f64>>),
+}
+
+struct LoadedEvaluator {
+    eval: F64Evaluator,
+    #[cfg(feature = "symbolica-runtime")]
+    exact_eval: Option<ExpressionEvaluator<Complex<Rational>>>,
+    #[cfg(feature = "symbolica-runtime")]
+    exact_eval_source: Option<EvaluatorPayloadSource>,
+    #[cfg(feature = "symbolica-runtime")]
+    double_eval: Option<ExpressionEvaluator<Complex<DoubleFloat>>>,
+    #[cfg(feature = "symbolica-runtime")]
+    arb_eval: Option<(u32, ExpressionEvaluator<Complex<Float>>)>,
+    input_len: usize,
+    output_len: usize,
+}
+
+#[cfg(feature = "symbolica-runtime")]
+trait RusticolHighPrecisionNumber:
+    Real + RealLike + From<f64> + PartialOrd + Clone + EvaluationDomain
+where
+    Complex<Self>: Real + EvaluationDomain,
+{
+    fn evaluate_loaded(
+        evaluator: &mut LoadedEvaluator,
+        params: &[Complex<Self>],
+        out: &mut [Complex<Self>],
+        binary_precision: Option<u32>,
+    ) -> RusticolResult<()>;
+}
+
+#[cfg(feature = "symbolica-runtime")]
+impl RusticolHighPrecisionNumber for DoubleFloat {
+    fn evaluate_loaded(
+        evaluator: &mut LoadedEvaluator,
+        params: &[Complex<Self>],
+        out: &mut [Complex<Self>],
+        _binary_precision: Option<u32>,
+    ) -> RusticolResult<()> {
+        if evaluator.double_eval.is_none() {
+            let exact = evaluator.exact_evaluator()?.clone();
+            evaluator.double_eval =
+                Some(exact.map_coeff(&|c| {
+                    Complex::new(DoubleFloat::from(&c.re), DoubleFloat::from(&c.im))
+                }));
+        }
+        evaluator
+            .double_eval
+            .as_mut()
+            .expect("double evaluator initialized")
+            .evaluate(params, out);
+        Ok(())
+    }
+}
+
+#[cfg(feature = "symbolica-runtime")]
+impl RusticolHighPrecisionNumber for Float {
+    fn evaluate_loaded(
+        evaluator: &mut LoadedEvaluator,
+        params: &[Complex<Self>],
+        out: &mut [Complex<Self>],
+        binary_precision: Option<u32>,
+    ) -> RusticolResult<()> {
+        let binary_precision = binary_precision.ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "arbitrary-precision evaluation needs a binary precision",
+            )
+        })?;
+        let rebuild = evaluator
+            .arb_eval
+            .as_ref()
+            .map(|(precision, _)| *precision != binary_precision)
+            .unwrap_or(true);
+        if rebuild {
+            let exact = evaluator.exact_evaluator()?.clone();
+            evaluator.arb_eval = Some((
+                binary_precision,
+                exact.map_coeff_with_prec(
+                    &|c| {
+                        Complex::new(
+                            c.re.to_multi_prec_float(binary_precision),
+                            c.im.to_multi_prec_float(binary_precision),
+                        )
+                    },
+                    binary_precision,
+                ),
+            ));
+        }
+        evaluator
+            .arb_eval
+            .as_mut()
+            .expect("arbitrary-precision evaluator initialized")
+            .1
+            .evaluate(params, out);
+        Ok(())
+    }
+}
+
+struct RawSumGroup {
+    id: i64,
+    indices: Vec<usize>,
+    weight: f64,
+    all_sector_weight: f64,
+    sector_ids: Vec<i64>,
+}
+
+struct ColorContractionRuntime {
+    group_count: usize,
+    entries: Vec<ColorContractionEntry>,
+    repeated_block: Option<RepeatedColorContractionBlock>,
+    symmetric_group: Option<CompiledSymmetricGroupColorContraction>,
+    group_scratch_f64: Vec<Complex<f64>>,
+}
+
+struct CompiledSymmetricGroupColorContraction {
+    plan: crate::recurrence::RecurrenceColorContraction,
+    ordered_group_indices: Vec<usize>,
+    workspace: Option<crate::recurrence::RuntimeSymmetricGroupColorWorkspace>,
+}
+
+#[derive(Clone, Copy)]
+struct ColorContractionEntry {
+    left_group_index: usize,
+    right_group_index: usize,
+    weight_re: f64,
+    weight_im: f64,
+    symmetry_factor: f64,
+}
+
+/// One color matrix shared by several disconnected contraction components.
+///
+/// Helicity-summed NLC/full-color plans contain one isomorphic color block per
+/// physical helicity. Keeping only one canonical block avoids streaming the
+/// same sparse matrix metadata once per helicity and lays out group values so
+/// that the repeated component dimension is contiguous.
+struct RepeatedColorContractionBlock {
+    component_count: usize,
+    component_group_indices: Vec<usize>,
+    singleton_output_indices: Option<Vec<usize>>,
+    entries: Vec<ColorContractionEntry>,
+    all_weights_real: bool,
+    walsh_block: Option<WalshColorContractionBlock>,
+    c2k_walsh_block: Option<C2kWalshColorContractionBlock>,
+}
+
+/// Four real symmetric blocks obtained from a normalized C2 x C2 Walsh basis.
+///
+/// The cosets map canonical local color groups to each four-point input
+/// transform. Entries address the transformed character/coset axis and retain
+/// a contiguous repeated-component dimension.
+struct WalshColorContractionBlock {
+    cosets: Vec<[usize; 4]>,
+    entries: Vec<ColorContractionEntry>,
+}
+
+/// Real symmetric blocks diagonalized in an unnormalized C2^k Walsh basis.
+///
+/// Each coset is ordered by the generator bitmask, so the group product is
+/// integer XOR. The transformed entries carry the single inverse-subgroup-order
+/// factor. Rank three uses a dedicated eight-point butterfly; higher ranks use
+/// the same in-place radix-two transform over reusable scratch.
+struct C2kWalshColorContractionBlock {
+    subgroup_order: usize,
+    cosets: Vec<Vec<usize>>,
+    entries: Vec<ColorContractionEntry>,
+}
+
+impl ColorContractionRuntime {
+    fn new(groups: &[RawSumGroup], entries: Vec<ColorContractionEntry>) -> Self {
+        let repeated_block = repeated_color_contraction_block(groups, &entries);
+        Self {
+            group_count: groups.len(),
+            entries,
+            repeated_block,
+            symmetric_group: None,
+            group_scratch_f64: Vec::new(),
+        }
+    }
+
+    fn from_repeated_block(
+        groups: &[RawSumGroup],
+        component_count: usize,
+        component_group_indices: Vec<usize>,
+        entries: Vec<ColorContractionEntry>,
+        walsh_block: Option<WalshColorContractionBlock>,
+        c2k_walsh_block: Option<C2kWalshColorContractionBlock>,
+    ) -> Self {
+        let singleton_output_indices = component_group_indices
+            .iter()
+            .map(
+                |group_index| match groups[*group_index].indices.as_slice() {
+                    [output_index] => Some(*output_index),
+                    _ => None,
+                },
+            )
+            .collect::<Option<Vec<_>>>();
+        let repeated_block = RepeatedColorContractionBlock {
+            component_count,
+            component_group_indices,
+            singleton_output_indices,
+            all_weights_real: entries.iter().all(|entry| entry.weight_im == 0.0),
+            entries,
+            walsh_block,
+            c2k_walsh_block,
+        };
+        Self {
+            group_count: groups.len(),
+            entries: Vec::new(),
+            repeated_block: Some(repeated_block),
+            symmetric_group: None,
+            group_scratch_f64: Vec::new(),
+        }
+    }
+
+    fn from_symmetric_group(
+        groups: &[RawSumGroup],
+        plan: crate::recurrence::RecurrenceColorContraction,
+        ordered_group_indices: Vec<usize>,
+    ) -> Self {
+        Self {
+            group_count: groups.len(),
+            entries: Vec::new(),
+            repeated_block: None,
+            symmetric_group: Some(CompiledSymmetricGroupColorContraction {
+                plan,
+                ordered_group_indices,
+                workspace: None,
+            }),
+            group_scratch_f64: Vec::new(),
+        }
+    }
+
+    const fn is_symmetric_group(&self) -> bool {
+        self.symmetric_group.is_some()
+    }
+
+    fn logical_entry_count(&self) -> RusticolResult<usize> {
+        if self.is_symmetric_group() {
+            return Err(RusticolError::compatibility(
+                "compiled symmetric-group FFT diagnostic contraction has no dense logical-entry view",
+            ));
+        }
+        if self.entries.is_empty() {
+            let Some(block) = self.repeated_block.as_ref() else {
+                return Ok(0);
+            };
+            block
+                .component_count
+                .checked_mul(block.entries.len())
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(
+                        "repeated colour contraction logical entry count overflows",
+                    )
+                })
+        } else {
+            Ok(self.entries.len())
+        }
+    }
+
+    fn logical_entries(&self) -> ColorContractionEntries<'_> {
+        if self.entries.is_empty()
+            && let Some(block) = self.repeated_block.as_ref()
+        {
+            return ColorContractionEntries::Repeated {
+                block,
+                component_index: 0,
+                entry_index: 0,
+            };
+        }
+        ColorContractionEntries::Expanded(self.entries.iter().copied())
+    }
+}
+
+enum ColorContractionEntries<'a> {
+    Expanded(std::iter::Copied<std::slice::Iter<'a, ColorContractionEntry>>),
+    Repeated {
+        block: &'a RepeatedColorContractionBlock,
+        component_index: usize,
+        entry_index: usize,
+    },
+}
+
+impl Iterator for ColorContractionEntries<'_> {
+    type Item = ColorContractionEntry;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            Self::Expanded(entries) => entries.next(),
+            Self::Repeated {
+                block,
+                component_index,
+                entry_index,
+            } => {
+                if *component_index >= block.component_count || block.entries.is_empty() {
+                    return None;
+                }
+                let entry = block.entries[*entry_index];
+                let component = *component_index;
+                let left_group_index = block.component_group_indices
+                    [entry.left_group_index * block.component_count + component];
+                let right_group_index = block.component_group_indices
+                    [entry.right_group_index * block.component_count + component];
+                *entry_index += 1;
+                if *entry_index == block.entries.len() {
+                    *entry_index = 0;
+                    *component_index += 1;
+                }
+                Some(ColorContractionEntry {
+                    left_group_index,
+                    right_group_index,
+                    ..entry
+                })
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+struct CanonicalColorContractionEntry {
+    left_group_index: usize,
+    right_group_index: usize,
+    weight_re_bits: u64,
+    weight_im_bits: u64,
+    symmetry_factor_bits: u64,
+}
+
+fn color_component_root(parent: &mut [usize], mut index: usize) -> usize {
+    while parent[index] != index {
+        parent[index] = parent[parent[index]];
+        index = parent[index];
+    }
+    index
+}
+
+fn repeated_color_contraction_block(
+    groups: &[RawSumGroup],
+    entries: &[ColorContractionEntry],
+) -> Option<RepeatedColorContractionBlock> {
+    if groups.len() < 2 || entries.is_empty() {
+        return None;
+    }
+
+    let mut parent = (0..groups.len()).collect::<Vec<_>>();
+    let mut component_size = vec![1usize; groups.len()];
+    for entry in entries {
+        let mut left = color_component_root(&mut parent, entry.left_group_index);
+        let mut right = color_component_root(&mut parent, entry.right_group_index);
+        if left == right {
+            continue;
+        }
+        if component_size[left] < component_size[right] {
+            std::mem::swap(&mut left, &mut right);
+        }
+        parent[right] = left;
+        component_size[left] += component_size[right];
+    }
+
+    let mut components_by_root = BTreeMap::<usize, Vec<usize>>::new();
+    for group_index in 0..groups.len() {
+        let root = color_component_root(&mut parent, group_index);
+        components_by_root
+            .entry(root)
+            .or_default()
+            .push(group_index);
+    }
+    let mut components = components_by_root.into_values().collect::<Vec<_>>();
+    components.sort_by_key(|component| component.iter().copied().min().unwrap_or(usize::MAX));
+    if components.len() < 2 {
+        return None;
+    }
+    let groups_per_component = components[0].len();
+    if groups_per_component == 0
+        || components
+            .iter()
+            .any(|component| component.len() != groups_per_component)
+    {
+        return None;
+    }
+
+    let component_maps = components
+        .iter()
+        .map(|component| {
+            let mut by_sector_signature = BTreeMap::<Vec<i64>, usize>::new();
+            for group_index in component {
+                let mut signature = groups[*group_index].sector_ids.clone();
+                signature.sort_unstable();
+                if by_sector_signature
+                    .insert(signature, *group_index)
+                    .is_some()
+                {
+                    return None;
+                }
+            }
+            Some(by_sector_signature)
+        })
+        .collect::<Option<Vec<_>>>()?;
+    let canonical_signatures = component_maps[0].keys().cloned().collect::<Vec<_>>();
+    if component_maps
+        .iter()
+        .skip(1)
+        .any(|component| component.keys().ne(canonical_signatures.iter()))
+    {
+        return None;
+    }
+
+    let mut component_index_by_group = vec![usize::MAX; groups.len()];
+    let mut local_index_by_group = vec![usize::MAX; groups.len()];
+    let mut component_group_indices = Vec::with_capacity(groups.len());
+    for (local_index, signature) in canonical_signatures.iter().enumerate() {
+        for (component_index, component) in component_maps.iter().enumerate() {
+            let group_index = component[signature];
+            component_index_by_group[group_index] = component_index;
+            local_index_by_group[group_index] = local_index;
+            component_group_indices.push(group_index);
+        }
+    }
+
+    let mut entries_by_component =
+        vec![Vec::<CanonicalColorContractionEntry>::new(); components.len()];
+    for entry in entries {
+        let component_index = component_index_by_group[entry.left_group_index];
+        if component_index == usize::MAX
+            || component_index != component_index_by_group[entry.right_group_index]
+        {
+            return None;
+        }
+        entries_by_component[component_index].push(CanonicalColorContractionEntry {
+            left_group_index: local_index_by_group[entry.left_group_index],
+            right_group_index: local_index_by_group[entry.right_group_index],
+            weight_re_bits: entry.weight_re.to_bits(),
+            weight_im_bits: entry.weight_im.to_bits(),
+            symmetry_factor_bits: entry.symmetry_factor.to_bits(),
+        });
+    }
+    for component_entries in &mut entries_by_component {
+        component_entries.sort_unstable();
+    }
+    if entries_by_component
+        .iter()
+        .skip(1)
+        .any(|component_entries| component_entries != &entries_by_component[0])
+    {
+        return None;
+    }
+
+    let entries = entries_by_component[0]
+        .iter()
+        .map(|entry| ColorContractionEntry {
+            left_group_index: entry.left_group_index,
+            right_group_index: entry.right_group_index,
+            weight_re: f64::from_bits(entry.weight_re_bits),
+            weight_im: f64::from_bits(entry.weight_im_bits),
+            symmetry_factor: f64::from_bits(entry.symmetry_factor_bits),
+        })
+        .collect::<Vec<_>>();
+    let singleton_output_indices = component_group_indices
+        .iter()
+        .map(
+            |group_index| match groups[*group_index].indices.as_slice() {
+                [output_index] => Some(*output_index),
+                _ => None,
+            },
+        )
+        .collect::<Option<Vec<_>>>();
+    Some(RepeatedColorContractionBlock {
+        component_count: components.len(),
+        component_group_indices,
+        singleton_output_indices,
+        all_weights_real: entries.iter().all(|entry| entry.weight_im == 0.0),
+        entries,
+        walsh_block: None,
+        c2k_walsh_block: None,
+    })
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct EvaluatorBatchProfile {
+    leaf_input_pack_s: f64,
+    legacy_evaluator_call_s: f64,
+    evaluator_call_s: f64,
+    output_gather_s: f64,
+    leaf_input_copy_component_count: u64,
+    output_gather_component_count: u64,
+    backend_call_count: u64,
+    scratch_reallocation_count: u64,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct StageEvaluationProfile {
+    input_pack_s: f64,
+    evaluator: EvaluatorBatchProfile,
+    output_assign_s: f64,
+    input_copy_component_count: u64,
+    output_assign_component_count: u64,
+    scratch_reallocation_count: u64,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct AmplitudeEvaluationProfile {
+    input_pack_s: f64,
+    evaluator: EvaluatorBatchProfile,
+    output_remap_s: f64,
+    input_copy_component_count: u64,
+    output_remap_component_count: u64,
+    scratch_reallocation_count: u64,
+}
+
+#[derive(Clone, Debug, Default)]
+struct RuntimeProfile {
+    orchestration_s: f64,
+    state_prepare_s: f64,
+    state_clear_s: f64,
+    source_fill_s: f64,
+    momentum_input_setup_s: f64,
+    momentum_setup_s: f64,
+    model_parameter_setup_s: f64,
+    stage_input_pack_s: f64,
+    stage_leaf_input_pack_s: f64,
+    stage_evaluator_call_s: f64,
+    stage_backend_call_s: f64,
+    stage_evaluator_output_gather_s: f64,
+    stage_evaluator_s: f64,
+    output_assign_s: f64,
+    amplitude_input_pack_s: f64,
+    amplitude_leaf_input_pack_s: f64,
+    amplitude_evaluator_call_s: f64,
+    amplitude_backend_call_s: f64,
+    amplitude_evaluator_output_gather_s: f64,
+    amplitude_output_remap_s: f64,
+    amplitude_evaluator_s: f64,
+    reduction_s: f64,
+    resolved_reduction_materialization_s: f64,
+    total_materialization_s: f64,
+    final_output_copy_s: f64,
+    total_s: f64,
+    stage_input_pack_by_stage_s: Vec<f64>,
+    stage_leaf_input_pack_by_stage_s: Vec<f64>,
+    stage_evaluator_call_by_stage_s: Vec<f64>,
+    stage_backend_call_by_stage_s: Vec<f64>,
+    stage_evaluator_output_gather_by_stage_s: Vec<f64>,
+    stage_output_assign_by_stage_s: Vec<f64>,
+    state_component_count: u64,
+    state_clear_component_count: u64,
+    source_component_count: u64,
+    momentum_component_count: u64,
+    model_parameter_component_count: u64,
+    stage_input_copy_component_count: u64,
+    stage_leaf_input_copy_component_count: u64,
+    stage_evaluator_output_gather_component_count: u64,
+    stage_output_assign_component_count: u64,
+    amplitude_input_copy_component_count: u64,
+    amplitude_leaf_input_copy_component_count: u64,
+    amplitude_evaluator_output_gather_component_count: u64,
+    amplitude_output_remap_component_count: u64,
+    evaluator_backend_call_count: u64,
+    compiled_direct_arena_engine_count: u64,
+    compiled_direct_arena_call_count: u64,
+    compiled_direct_arena_minimum_effective_tile_capacity: u64,
+    compiled_direct_arena_maximum_physical_scalar_values_per_point: u64,
+    compiled_direct_arena_maximum_hot_scalar_values_per_point: u64,
+    compiled_direct_arena_maximum_source_scalar_values_per_point: u64,
+    compiled_direct_arena_maximum_reduction_scalar_values_per_point: u64,
+    compiled_direct_arena_boundary_input_bytes: u64,
+    compiled_direct_arena_boundary_current_output_bytes: u64,
+    compiled_direct_arena_boundary_amplitude_output_bytes: u64,
+    /// Broadcast-plane refresh traffic internal to compiled P-kernels.
+    compiled_direct_arena_internal_broadcast_bytes: u64,
+    reduction_input_component_count: u64,
+    resolved_materialized_component_count: u64,
+    total_materialized_value_count: u64,
+    final_output_copy_value_count: u64,
+    scratch_reallocation_count: u64,
+    eager_initialize_s: f64,
+    eager_gather_s: f64,
+    eager_kernel_call_s: f64,
+    eager_invocation_scatter_s: f64,
+    eager_finalization_s: f64,
+    eager_scatter_finalization_s: f64,
+    eager_closure_s: f64,
+    eager_reduction_s: f64,
+    eager_copy_out_s: f64,
+    /// P-kernel scratch reads and writes wholly inside eager Direct-Arena execution.
+    eager_internal_scratch_bytes: u64,
+    /// Point-independent coupling and parameter refreshes wholly inside eager
+    /// Direct-Arena execution.
+    eager_internal_broadcast_bytes: u64,
+    recurrence_momentum_fill_s: f64,
+    recurrence_union_source_fill_s: f64,
+    /// Inclusive top-level recurrence schedule envelope. The role-specific
+    /// recurrence fields below are internal attribution and must not be added
+    /// to top-level accounting.
+    recurrence_schedule_s: f64,
+    recurrence_source_kernel_s: f64,
+    recurrence_contribution_kernel_s: f64,
+    recurrence_finalization_s: f64,
+    recurrence_closure_s: f64,
+    recurrence_replay_output_mapping_s: f64,
+    recurrence_momentum_scalar_value_count: u64,
+    recurrence_schedule_execution_count: u64,
+    recurrence_replay_schedule_execution_count: u64,
+    recurrence_union_schedule_execution_count: u64,
+    recurrence_union_source_row_count: u64,
+    recurrence_replay_output_value_count: u64,
+    recurrence_source_call_count: u64,
+    recurrence_source_row_count: u64,
+    recurrence_contribution_call_count: u64,
+    recurrence_contribution_row_count: u64,
+    recurrence_finalization_call_count: u64,
+    recurrence_finalization_row_count: u64,
+    recurrence_closure_call_count: u64,
+    recurrence_closure_row_count: u64,
+    /// Legacy recurrence Direct-Arena packet counters. These remain private
+    /// because they authenticate the generated-kernel boundary rather than
+    /// the public diagnostic profiler's input/output materialization.
+    recurrence_direct_packed_input_bytes: u64,
+    recurrence_direct_packed_output_bytes: u64,
+    recurrence_direct_scatter_bytes: u64,
+    /// Lane-neutral Direct-Arena traffic counters observed by recurrence.
+    recurrence_direct_packet_input_bytes: u64,
+    recurrence_direct_packet_output_bytes: u64,
+    recurrence_direct_gather_bytes: u64,
+    recurrence_direct_traffic_scatter_bytes: u64,
+    recurrence_direct_remap_bytes: u64,
+    /// P-kernel output scratch traffic entirely inside recurrence execution.
+    recurrence_internal_scratch_bytes: u64,
+    /// P-kernel broadcast-plane traffic entirely inside recurrence execution.
+    recurrence_internal_broadcast_bytes: u64,
+}
+
+// Saved SymJIT applications are native payloads and do not currently guarantee
+// Rust's AArch64 callee-saved FP registers. Keep elapsed values integer-backed
+// until the payload has returned, then use an opaque conversion boundary so
+// LLVM cannot retain an f64 across that call.
+#[inline(never)]
+fn profile_duration_seconds(duration: Duration) -> f64 {
+    std::hint::black_box(duration).as_secs_f64()
+}
+
+impl RuntimeProfile {
+    fn add_sector(&mut self, sector: &RuntimeProfile) {
+        self.orchestration_s += sector.orchestration_s;
+        self.state_prepare_s += sector.state_prepare_s;
+        self.state_clear_s += sector.state_clear_s;
+        self.source_fill_s += sector.source_fill_s;
+        self.momentum_input_setup_s += sector.momentum_input_setup_s;
+        self.momentum_setup_s += sector.momentum_setup_s;
+        self.model_parameter_setup_s += sector.model_parameter_setup_s;
+        self.stage_input_pack_s += sector.stage_input_pack_s;
+        self.stage_leaf_input_pack_s += sector.stage_leaf_input_pack_s;
+        self.stage_evaluator_call_s += sector.stage_evaluator_call_s;
+        self.stage_backend_call_s += sector.stage_backend_call_s;
+        self.stage_evaluator_output_gather_s += sector.stage_evaluator_output_gather_s;
+        self.stage_evaluator_s += sector.stage_evaluator_s;
+        self.output_assign_s += sector.output_assign_s;
+        self.amplitude_input_pack_s += sector.amplitude_input_pack_s;
+        self.amplitude_leaf_input_pack_s += sector.amplitude_leaf_input_pack_s;
+        self.amplitude_evaluator_call_s += sector.amplitude_evaluator_call_s;
+        self.amplitude_backend_call_s += sector.amplitude_backend_call_s;
+        self.amplitude_evaluator_output_gather_s += sector.amplitude_evaluator_output_gather_s;
+        self.amplitude_output_remap_s += sector.amplitude_output_remap_s;
+        self.amplitude_evaluator_s += sector.amplitude_evaluator_s;
+        self.reduction_s += sector.reduction_s;
+        self.resolved_reduction_materialization_s += sector.resolved_reduction_materialization_s;
+        self.total_materialization_s += sector.total_materialization_s;
+        self.final_output_copy_s += sector.final_output_copy_s;
+        self.state_component_count += sector.state_component_count;
+        self.state_clear_component_count += sector.state_clear_component_count;
+        self.source_component_count += sector.source_component_count;
+        self.momentum_component_count += sector.momentum_component_count;
+        self.model_parameter_component_count += sector.model_parameter_component_count;
+        self.stage_input_copy_component_count += sector.stage_input_copy_component_count;
+        self.stage_leaf_input_copy_component_count += sector.stage_leaf_input_copy_component_count;
+        self.stage_evaluator_output_gather_component_count +=
+            sector.stage_evaluator_output_gather_component_count;
+        self.stage_output_assign_component_count += sector.stage_output_assign_component_count;
+        self.amplitude_input_copy_component_count += sector.amplitude_input_copy_component_count;
+        self.amplitude_leaf_input_copy_component_count +=
+            sector.amplitude_leaf_input_copy_component_count;
+        self.amplitude_evaluator_output_gather_component_count +=
+            sector.amplitude_evaluator_output_gather_component_count;
+        self.amplitude_output_remap_component_count +=
+            sector.amplitude_output_remap_component_count;
+        self.evaluator_backend_call_count += sector.evaluator_backend_call_count;
+        self.compiled_direct_arena_engine_count += sector.compiled_direct_arena_engine_count;
+        self.compiled_direct_arena_call_count += sector.compiled_direct_arena_call_count;
+        self.compiled_direct_arena_minimum_effective_tile_capacity = match (
+            self.compiled_direct_arena_minimum_effective_tile_capacity,
+            sector.compiled_direct_arena_minimum_effective_tile_capacity,
+        ) {
+            (0, value) | (value, 0) => value,
+            (left, right) => left.min(right),
+        };
+        self.compiled_direct_arena_maximum_physical_scalar_values_per_point = self
+            .compiled_direct_arena_maximum_physical_scalar_values_per_point
+            .max(sector.compiled_direct_arena_maximum_physical_scalar_values_per_point);
+        self.compiled_direct_arena_maximum_hot_scalar_values_per_point = self
+            .compiled_direct_arena_maximum_hot_scalar_values_per_point
+            .max(sector.compiled_direct_arena_maximum_hot_scalar_values_per_point);
+        self.compiled_direct_arena_maximum_source_scalar_values_per_point = self
+            .compiled_direct_arena_maximum_source_scalar_values_per_point
+            .max(sector.compiled_direct_arena_maximum_source_scalar_values_per_point);
+        self.compiled_direct_arena_maximum_reduction_scalar_values_per_point = self
+            .compiled_direct_arena_maximum_reduction_scalar_values_per_point
+            .max(sector.compiled_direct_arena_maximum_reduction_scalar_values_per_point);
+        self.compiled_direct_arena_boundary_input_bytes +=
+            sector.compiled_direct_arena_boundary_input_bytes;
+        self.compiled_direct_arena_boundary_current_output_bytes +=
+            sector.compiled_direct_arena_boundary_current_output_bytes;
+        self.compiled_direct_arena_boundary_amplitude_output_bytes +=
+            sector.compiled_direct_arena_boundary_amplitude_output_bytes;
+        self.compiled_direct_arena_internal_broadcast_bytes +=
+            sector.compiled_direct_arena_internal_broadcast_bytes;
+        self.reduction_input_component_count += sector.reduction_input_component_count;
+        self.resolved_materialized_component_count += sector.resolved_materialized_component_count;
+        self.total_materialized_value_count += sector.total_materialized_value_count;
+        self.final_output_copy_value_count += sector.final_output_copy_value_count;
+        self.scratch_reallocation_count += sector.scratch_reallocation_count;
+        self.eager_initialize_s += sector.eager_initialize_s;
+        self.eager_gather_s += sector.eager_gather_s;
+        self.eager_kernel_call_s += sector.eager_kernel_call_s;
+        self.eager_invocation_scatter_s += sector.eager_invocation_scatter_s;
+        self.eager_finalization_s += sector.eager_finalization_s;
+        self.eager_scatter_finalization_s += sector.eager_scatter_finalization_s;
+        self.eager_closure_s += sector.eager_closure_s;
+        self.eager_reduction_s += sector.eager_reduction_s;
+        self.eager_copy_out_s += sector.eager_copy_out_s;
+        self.eager_internal_scratch_bytes += sector.eager_internal_scratch_bytes;
+        self.eager_internal_broadcast_bytes += sector.eager_internal_broadcast_bytes;
+        self.recurrence_momentum_fill_s += sector.recurrence_momentum_fill_s;
+        self.recurrence_union_source_fill_s += sector.recurrence_union_source_fill_s;
+        self.recurrence_schedule_s += sector.recurrence_schedule_s;
+        self.recurrence_source_kernel_s += sector.recurrence_source_kernel_s;
+        self.recurrence_contribution_kernel_s += sector.recurrence_contribution_kernel_s;
+        self.recurrence_finalization_s += sector.recurrence_finalization_s;
+        self.recurrence_closure_s += sector.recurrence_closure_s;
+        self.recurrence_replay_output_mapping_s += sector.recurrence_replay_output_mapping_s;
+        self.recurrence_momentum_scalar_value_count +=
+            sector.recurrence_momentum_scalar_value_count;
+        self.recurrence_schedule_execution_count += sector.recurrence_schedule_execution_count;
+        self.recurrence_replay_schedule_execution_count +=
+            sector.recurrence_replay_schedule_execution_count;
+        self.recurrence_union_schedule_execution_count +=
+            sector.recurrence_union_schedule_execution_count;
+        self.recurrence_union_source_row_count += sector.recurrence_union_source_row_count;
+        self.recurrence_replay_output_value_count += sector.recurrence_replay_output_value_count;
+        self.recurrence_source_call_count += sector.recurrence_source_call_count;
+        self.recurrence_source_row_count += sector.recurrence_source_row_count;
+        self.recurrence_contribution_call_count += sector.recurrence_contribution_call_count;
+        self.recurrence_contribution_row_count += sector.recurrence_contribution_row_count;
+        self.recurrence_finalization_call_count += sector.recurrence_finalization_call_count;
+        self.recurrence_finalization_row_count += sector.recurrence_finalization_row_count;
+        self.recurrence_closure_call_count += sector.recurrence_closure_call_count;
+        self.recurrence_closure_row_count += sector.recurrence_closure_row_count;
+        self.recurrence_direct_packed_input_bytes += sector.recurrence_direct_packed_input_bytes;
+        self.recurrence_direct_packed_output_bytes += sector.recurrence_direct_packed_output_bytes;
+        self.recurrence_direct_scatter_bytes += sector.recurrence_direct_scatter_bytes;
+        self.recurrence_direct_packet_input_bytes += sector.recurrence_direct_packet_input_bytes;
+        self.recurrence_direct_packet_output_bytes += sector.recurrence_direct_packet_output_bytes;
+        self.recurrence_direct_gather_bytes += sector.recurrence_direct_gather_bytes;
+        self.recurrence_direct_traffic_scatter_bytes +=
+            sector.recurrence_direct_traffic_scatter_bytes;
+        self.recurrence_direct_remap_bytes += sector.recurrence_direct_remap_bytes;
+        self.recurrence_internal_scratch_bytes += sector.recurrence_internal_scratch_bytes;
+        self.recurrence_internal_broadcast_bytes += sector.recurrence_internal_broadcast_bytes;
+        add_profile_vector(
+            &mut self.stage_input_pack_by_stage_s,
+            &sector.stage_input_pack_by_stage_s,
+        );
+        add_profile_vector(
+            &mut self.stage_leaf_input_pack_by_stage_s,
+            &sector.stage_leaf_input_pack_by_stage_s,
+        );
+        add_profile_vector(
+            &mut self.stage_evaluator_call_by_stage_s,
+            &sector.stage_evaluator_call_by_stage_s,
+        );
+        add_profile_vector(
+            &mut self.stage_backend_call_by_stage_s,
+            &sector.stage_backend_call_by_stage_s,
+        );
+        add_profile_vector(
+            &mut self.stage_evaluator_output_gather_by_stage_s,
+            &sector.stage_evaluator_output_gather_by_stage_s,
+        );
+        add_profile_vector(
+            &mut self.stage_output_assign_by_stage_s,
+            &sector.stage_output_assign_by_stage_s,
+        );
+    }
+
+    fn validate_recurrence_direct_boundary_traffic(&self) -> RusticolResult<()> {
+        if self.recurrence_direct_packed_input_bytes
+            | self.recurrence_direct_packed_output_bytes
+            | self.recurrence_direct_scatter_bytes
+            != 0
+        {
+            return Err(RusticolError::integrity(
+                "recurrence Direct-Arena execution recorded legacy pack/scatter boundary traffic",
+            ));
+        }
+        if self.recurrence_direct_packet_input_bytes
+            | self.recurrence_direct_packet_output_bytes
+            | self.recurrence_direct_gather_bytes
+            | self.recurrence_direct_traffic_scatter_bytes
+            | self.recurrence_direct_remap_bytes
+            != 0
+        {
+            return Err(RusticolError::integrity(
+                "recurrence Direct-Arena execution recorded packet/gather/scatter/remap traffic",
+            ));
+        }
+        Ok(())
+    }
+}
+
+fn add_profile_vector(target: &mut Vec<f64>, source: &[f64]) {
+    if target.len() < source.len() {
+        target.resize(source.len(), 0.0);
+    }
+    for (index, value) in source.iter().enumerate() {
+        target[index] += value;
+    }
+}
+
+struct ExecutionRuntime {
+    process: String,
+    key: String,
+    color_accuracy: String,
+    external_pdg_order: Vec<i32>,
+    external_count: usize,
+    parameter_count: usize,
+    value_parameter_count: usize,
+    momentum_parameter_count: usize,
+    current_count: usize,
+    source_count: usize,
+    interaction_count: usize,
+    stage_count: usize,
+    amplitude_output_count: usize,
+    lc_topology_replay_enabled: bool,
+    lc_topology_replay_mappings: Arc<LcTopologyReplayMappings>,
+    lc_topology_replay_public_mappings: LcTopologyReplayMappings,
+    lc_topology_replay_routes: Vec<Vec<LcTopologyReplaySectorRoute>>,
+    lc_topology_replay_materialized_sector_ids: BTreeSet<i64>,
+    lc_resolved_replay_plan: Option<Arc<LcResolvedReplayPlan>>,
+    lc_resolved_replay_selection_cache:
+        Option<(LcResolvedReplaySelectionKey, Arc<LcResolvedReplaySelection>)>,
+    lc_replay_flat_momenta_scratch: Vec<f64>,
+    lc_replay_target_components_scratch: Vec<f64>,
+    color_topology_replay_enabled: bool,
+    color_topology_replay_mappings: Arc<LcTopologyReplayMappings>,
+    color_replay_flat_momenta_scratch: Vec<f64>,
+    #[allow(dead_code)] // Loaded now and consumed by the subsequent selector-execution milestone.
+    helicity_recurrence: Option<HelicityRecurrenceRuntime>,
+    compiled_helicity_execution_plan: Option<CompiledHelicityExecutionPlan>,
+    compiled_color_execution_plan: Option<CompiledColorExecutionPlan>,
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    compiled_direct_runtime: Option<compiled_direct_prototype::CompiledDirectEnginePrototype>,
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    compiled_direct_color_schedules:
+        BTreeMap<i64, compiled_direct_prototype::CompiledDirectValidatedSchedule>,
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    compiled_direct_helicity_schedules:
+        BTreeMap<usize, compiled_direct_prototype::CompiledDirectValidatedSchedule>,
+    helicity_sum_runtime: Option<Box<ExecutionRuntime>>,
+    // Lane runtimes are large recursive owners; boxing keeps their addresses stable and avoids
+    // moving them when this selector index grows.
+    #[allow(clippy::vec_box)]
+    helicity_selector_runtimes: Vec<Box<ExecutionRuntime>>,
+    helicity_selector_runtime_schedule_modes: Vec<HelicitySelectorScheduleMode>,
+    helicity_selector_lane_by_domain: BTreeMap<usize, usize>,
+    color_selector_runtimes: BTreeMap<i64, Box<ExecutionRuntime>>,
+    runtime_unavailable_message: Option<String>,
+    sources: Vec<GenericSourceRecordManifest>,
+    // Iterable fill list, not indexed by canonical momentum-slot ID. Compiled
+    // lanes retain only generated live slots, with their global offsets intact.
+    momentum_slots: Vec<GenericMomentumSlotManifest>,
+    external_is_initial: Vec<bool>,
+    particle_masses: BTreeMap<i32, f64>,
+    particle_mass_parameter_names: BTreeMap<i32, String>,
+    normalization_factor: f64,
+    normalization_color_factor: f64,
+    normalization_average_factor: f64,
+    normalization_identical_factor: f64,
+    normalization_qcd_coupling_power: usize,
+    normalization_electroweak_coupling_power: usize,
+    model_parameters: Vec<GenericRuntimeModelParameterManifest>,
+    model_parameter_name_to_index: BTreeMap<String, usize>,
+    model_parameter_runtime_slots: BTreeMap<String, RuntimeParameterSlots>,
+    model_parameter_values_f64: Vec<f64>,
+    model_parameter_evaluator: Option<ModelParameterEvaluatorRuntime>,
+    physics_reduction_override: Option<crate::Reduction>,
+    physics: Option<Arc<PhysicsRuntime>>,
+    stages: Option<Vec<StageRuntime>>,
+    amplitude_stage: Option<AmplitudeRuntime>,
+    state_scratch_f64: Vec<Complex<f64>>,
+    state_scratch_f64_requires_clear: bool,
+    values_scratch_f64: Vec<f64>,
+}
+
+#[derive(Clone)]
+struct PhysicsRuntime {
+    binding_id: u64,
+    manifest: ProcessPhysicsV1,
+    helicity_index_by_id: BTreeMap<String, usize>,
+    helicity_members_by_representative: Vec<Vec<usize>>,
+    color_index_by_id: BTreeMap<String, usize>,
+    reduction_by_group_id: BTreeMap<i64, crate::ReductionGroup>,
+    numeric_reduction_by_group_id: BTreeMap<i64, NumericReductionGroup>,
+}
+
+#[derive(Clone)]
+struct NumericReductionGroup {
+    physical_helicity_indices: Vec<usize>,
+    helicity_membership: Vec<bool>,
+    normalized_helicity_weights: Vec<(usize, f64)>,
+    normalized_color_weights: Vec<(usize, f64)>,
+    normalized_member_weights: Vec<(usize, usize, f64)>,
+}
+
+impl NumericReductionGroup {
+    #[inline(always)]
+    fn contains_helicity(&self, helicity_index: usize) -> bool {
+        self.helicity_membership
+            .get(helicity_index)
+            .copied()
+            .unwrap_or(false)
+    }
+}
+
+#[derive(Clone, Debug)]
+struct ResolvedValues<T> {
+    values: Vec<T>,
+    point_count: usize,
+    helicity_indices: Vec<usize>,
+    color_indices: Vec<usize>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct NativeRuntimeMetadata {
+    pub abi_version: u32,
+    pub schema_version: u32,
+    pub execution_mode: String,
+    pub prepared_backend: Option<String>,
+    pub eager_effective_point_tile_size: Option<usize>,
+    pub eager_workspace_bytes: Option<usize>,
+    pub on_the_fly_requested_query_construction_threads: Option<usize>,
+    pub on_the_fly_effective_query_construction_threads: Option<usize>,
+    pub compiled_direct_minimum_effective_tile_capacity: Option<usize>,
+    pub compiled_direct_maximum_physical_scalar_values_per_point: Option<usize>,
+    pub compiled_direct_maximum_hot_scalar_values_per_point: Option<usize>,
+    pub compiled_direct_maximum_source_scalar_values_per_point: Option<usize>,
+    pub compiled_direct_maximum_reduction_scalar_values_per_point: Option<usize>,
+    pub process: String,
+    pub process_key: String,
+    pub representative_process: String,
+    pub representative_process_key: String,
+    /// Full representative-index to public-index external permutation.
+    pub external_permutation: Vec<usize>,
+    /// Representative process key when a stored or inferred permutation is active.
+    pub permutation_alias_of: Option<String>,
+    pub final_state_permutation_alias_of: Option<String>,
+    /// Representative process key when the selected process was not generated
+    /// and is routed through the artifact's process-group map.
+    pub process_group_member_of: Option<String>,
+    /// Exact factor applied to every representative matrix element.
+    pub process_group_factor: NativeRationalFactor,
+    /// Whether the selected process is the charge conjugate of its
+    /// representative; public LC color-flow words are then reversed.
+    pub charge_conjugated: bool,
+    pub color_accuracy: String,
+    pub external_pdg_order: Vec<i32>,
+    pub external_count: usize,
+    pub current_count: usize,
+    pub source_count: usize,
+    pub interaction_count: usize,
+    pub stage_count: usize,
+    pub amplitude_output_count: usize,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
+pub struct NativeRationalFactor {
+    pub numerator: u64,
+    pub denominator: u64,
+}
+
+/// Public relabelling of a process-group member evaluated by its representative.
+#[derive(Clone, Debug)]
+struct ProcessGroupRouting {
+    representative_process_key: String,
+    factor: NativeRationalFactor,
+    conjugated: bool,
+}
+
+/// Prepared batch-global selectors for allocation-free recurrence evaluation.
+///
+/// Selector resolution and validation may allocate while this handle is
+/// created. Reusing it with
+/// [`NativeRuntime::evaluate_f64_into_with_recurrence_selector_plan`] borrows
+/// the retained selector sets and caller-owned input/output storage.
+#[derive(Clone, Debug)]
+pub struct NativeRecurrenceSelectorPlan {
+    artifact_root: PathBuf,
+    process_key: String,
+    external_permutation: Vec<usize>,
+    selected_helicities: Option<BTreeSet<String>>,
+    selected_colors: Option<BTreeSet<String>>,
+}
+
+impl NativeRecurrenceSelectorPlan {
+    fn ensure_matches(&self, runtime: &NativeRuntime) -> RusticolResult<()> {
+        if self.artifact_root != runtime.root
+            || self.process_key != runtime.process_key
+            || self.external_permutation != runtime.external_permutation
+        {
+            return Err(RusticolError::selector(
+                "recurrence selector plan belongs to a different artifact, process, or external ordering",
+            ));
+        }
+        Ok(())
+    }
+}
+
+/// Exact-required sections decoded lazily from one authenticated eager plan-v3
+/// artifact. This bridge is intentionally private to pyAmpliCol's Python exact
+/// executor; f64 execution never constructs it.
+#[derive(Debug)]
+pub struct NativeEagerExactSections {
+    pub process_id: String,
+    pub exact_schema: Value,
+    pub reduction_groups: Value,
+    pub selector_group_ids: Vec<u32>,
+    pub selector_domains: Vec<Vec<u32>>,
+    pub couplings: Vec<NativeEagerExactCoupling>,
+    pub stages: Vec<NativeEagerExactStage>,
+    pub invocations: Vec<NativeEagerExactInvocation>,
+    pub attachments: Vec<NativeEagerExactAttachment>,
+    pub finalizations: Vec<NativeEagerExactFinalization>,
+    pub closures: Vec<NativeEagerExactClosure>,
+}
+
+#[derive(Debug)]
+pub struct NativeEagerExactCoupling {
+    pub real_parameter_id: u32,
+    pub imaginary_parameter_id: u32,
+    pub constant_real: String,
+    pub constant_imaginary: String,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct NativeEagerExactStage {
+    pub stage_index: u32,
+    pub invocation_start: u64,
+    pub invocation_count: u64,
+    pub attachment_start: u64,
+    pub attachment_count: u64,
+    pub finalization_start: u64,
+    pub finalization_count: u64,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct NativeEagerExactInvocation {
+    pub kernel_id: u32,
+    pub left_value_slot_id: u32,
+    pub right_value_slot_id: u32,
+    pub left_momentum_slot_id: u32,
+    pub right_momentum_slot_id: u32,
+    pub coupling_slot_id: u32,
+    pub output_factor_source: u8,
+    pub attachment_start: u64,
+    pub attachment_count: u64,
+    pub selector_domain_id: u32,
+}
+
+#[derive(Debug)]
+pub struct NativeEagerExactAttachment {
+    pub result_current_id: u32,
+    pub factor_numerators: Vec<[String; 2]>,
+    pub factor_denominator: Option<[String; 2]>,
+    pub selector_domain_id: u32,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct NativeEagerExactFinalization {
+    pub kernel_id: u32,
+    pub current_id: u32,
+    pub unpropagated_value_slot_id: u32,
+    pub propagated_value_slot_id: u32,
+    pub momentum_slot_id: u32,
+    pub unpropagated_selector_domain_id: u32,
+    pub propagated_selector_domain_id: u32,
+}
+
+#[derive(Debug)]
+pub struct NativeEagerExactClosure {
+    pub kernel_id: u32,
+    pub left_value_slot_id: u32,
+    pub right_value_slot_id: u32,
+    pub amplitude_index: u32,
+    pub coupling_slot_id: u32,
+    pub output_factor_source: u8,
+    pub factor_numerators: Vec<[String; 2]>,
+    pub factor_denominator: Option<[String; 2]>,
+    pub direct_coefficients: Option<Vec<[String; 2]>>,
+    pub coherent_group_id: u32,
+    pub selector_domain_id: u32,
+}
+
+/// Exact-required sections decoded from one authenticated recurrence plan-v2
+/// artifact. Python consumes these immutable rows with the retained exact
+/// evaluator payloads; the Direct-Arena f64 runtime never constructs them.
+#[derive(Debug)]
+pub struct NativeRecurrenceExactSections {
+    pub process_id: String,
+    pub strategy: String,
+    pub semantic_digest: String,
+    pub runtime_layout_digest: String,
+    pub current_arena_components: u32,
+    pub amplitude_destination_count: u32,
+    pub parameter_value_count: u32,
+    pub external_source_count: u32,
+    pub currents: Vec<crate::recurrence::DirectCurrentDescriptor>,
+    pub sources: Vec<crate::recurrence::DirectSourceRow>,
+    pub contributions: Vec<crate::recurrence::DirectContributionRow>,
+    pub finalizations: Vec<crate::recurrence::DirectFinalizationRow>,
+    pub closures: Vec<crate::recurrence::DirectClosureRow>,
+    pub row_groups: Vec<crate::recurrence::DirectRowGroupDescriptor>,
+    pub momentum_forms: Vec<crate::recurrence::DirectMomentumFormDescriptor>,
+    pub momentum_terms: Vec<crate::recurrence::DirectMomentumTerm>,
+    pub replay_targets: Vec<crate::recurrence::DirectReplayTargetDescriptor>,
+    pub source_permutations: Vec<u32>,
+    pub replay_momentum_signs: Vec<i32>,
+    pub replay_helicity_map: Vec<u32>,
+    pub amplitude_destinations: Vec<crate::recurrence::DirectAmplitudeDestinationDescriptor>,
+    pub resolved_helicities: Vec<crate::recurrence::DirectResolvedHelicityDescriptor>,
+    pub public_helicities: Vec<i32>,
+    pub source_state_assignments: Vec<crate::recurrence::DirectSourceStateAssignment>,
+    pub source_dispatch_variants: Vec<crate::recurrence::DirectSourceDispatchVariantDescriptor>,
+    pub source_embeddings: Vec<crate::recurrence::DirectSourceEmbeddingRow>,
+    pub source_projections: Vec<crate::recurrence::DirectSourceProjectionRow>,
+    pub resolved_source_selections: Vec<crate::recurrence::DirectResolvedSourceSelection>,
+    pub exact_factors: Vec<NativeRecurrenceExactFactor>,
+    pub public_flow_ids: Vec<u32>,
+    pub executors: Vec<NativeRecurrenceExactExecutor>,
+}
+
+#[derive(Debug)]
+pub struct NativeRecurrenceExactFactor {
+    pub real_numerator: String,
+    pub real_denominator: String,
+    pub imaginary_numerator: String,
+    pub imaginary_denominator: String,
+}
+
+#[derive(Clone, Debug)]
+pub struct NativeRecurrenceExactExecutor {
+    pub direct_executor_id: u32,
+    pub role: String,
+    pub destination_operation: String,
+    pub parent_component_counts: Vec<u32>,
+    pub destination_component_count: u32,
+    pub momentum_operand_count: u32,
+    pub prepared_kernel_id: Option<u32>,
+    pub runtime_template: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct NativeRuntimeProfile {
+    pub native_input_pack_s: f64,
+    pub native_input_crossing_s: f64,
+    pub orchestration_s: f64,
+    pub state_prepare_s: f64,
+    pub state_clear_s: f64,
+    pub source_fill_s: f64,
+    /// Exclusive momentum-input setup. Unlike `momentum_setup_s`, this does
+    /// not include model-parameter setup.
+    pub momentum_input_setup_s: f64,
+    /// Backward-compatible aggregate of momentum-input and model-parameter
+    /// setup.
+    pub momentum_setup_s: f64,
+    pub model_parameter_setup_s: f64,
+    /// Top-level stage input envelope. In composed selected-chunk paths this
+    /// owns the leaf gather; in full-stage paths it owns only the parent
+    /// stage-input gather.
+    pub stage_input_pack_s: f64,
+    /// Internal attribution. This is owned by `stage_input_pack_s` for
+    /// composed selected-chunk paths and by `stage_evaluator_call_s` for
+    /// full-stage paths, so it must not be added to the top-level sum.
+    pub stage_leaf_input_pack_s: f64,
+    /// Top-level evaluator envelope. This includes leaf gathering for
+    /// full-stage paths and excludes it for composed selected-chunk paths.
+    pub stage_evaluator_call_s: f64,
+    pub stage_backend_call_s: f64,
+    pub stage_evaluator_output_gather_s: f64,
+    pub stage_evaluator_s: f64,
+    pub output_assign_s: f64,
+    /// Top-level amplitude input envelope. In composed selected-chunk paths
+    /// this owns the amplitude leaf gather.
+    pub amplitude_input_pack_s: f64,
+    /// Internal attribution owned either by `amplitude_input_pack_s` or
+    /// `amplitude_evaluator_call_s`; never an additional top-level phase.
+    pub amplitude_leaf_input_pack_s: f64,
+    /// Top-level amplitude evaluator envelope. Full-stage paths include leaf
+    /// gathering; composed selected-chunk paths exclude it.
+    pub amplitude_evaluator_call_s: f64,
+    pub amplitude_backend_call_s: f64,
+    pub amplitude_evaluator_output_gather_s: f64,
+    pub amplitude_output_remap_s: f64,
+    pub amplitude_evaluator_s: f64,
+    pub reduction_s: f64,
+    /// Inclusive attribution: the resolved-result construction occurs inside
+    /// `reduction_s` and must not be added to exclusive top-level phases.
+    pub resolved_reduction_materialization_s: f64,
+    pub total_materialization_s: f64,
+    pub final_output_copy_s: f64,
+    pub total_s: f64,
+    pub stage_input_pack_by_stage_s: Vec<f64>,
+    pub stage_leaf_input_pack_by_stage_s: Vec<f64>,
+    pub stage_evaluator_call_by_stage_s: Vec<f64>,
+    pub stage_backend_call_by_stage_s: Vec<f64>,
+    pub stage_evaluator_output_gather_by_stage_s: Vec<f64>,
+    pub stage_output_assign_by_stage_s: Vec<f64>,
+    pub eager_initialize_s: f64,
+    pub eager_gather_s: f64,
+    pub eager_kernel_call_s: f64,
+    pub eager_invocation_scatter_s: f64,
+    pub eager_finalization_s: f64,
+    pub eager_scatter_finalization_s: f64,
+    pub eager_closure_s: f64,
+    pub eager_reduction_s: f64,
+    pub eager_copy_out_s: f64,
+    pub recurrence_momentum_fill_s: f64,
+    pub recurrence_union_source_fill_s: f64,
+    /// Inclusive top-level recurrence schedule envelope.
+    pub recurrence_schedule_s: f64,
+    /// Internal attribution owned by `recurrence_schedule_s`.
+    pub recurrence_source_kernel_s: f64,
+    /// Internal attribution owned by `recurrence_schedule_s`.
+    pub recurrence_contribution_kernel_s: f64,
+    /// Internal attribution owned by `recurrence_schedule_s`.
+    pub recurrence_finalization_s: f64,
+    /// Internal attribution owned by `recurrence_schedule_s`.
+    pub recurrence_closure_s: f64,
+    pub recurrence_replay_output_mapping_s: f64,
+    pub recurrence_momentum_scalar_value_count: u64,
+    pub recurrence_schedule_execution_count: u64,
+    pub recurrence_replay_schedule_execution_count: u64,
+    pub recurrence_union_schedule_execution_count: u64,
+    pub recurrence_union_source_row_count: u64,
+    pub recurrence_replay_output_value_count: u64,
+    pub recurrence_source_call_count: u64,
+    pub recurrence_source_row_count: u64,
+    pub recurrence_contribution_call_count: u64,
+    pub recurrence_contribution_row_count: u64,
+    pub recurrence_finalization_call_count: u64,
+    pub recurrence_finalization_row_count: u64,
+    pub recurrence_closure_call_count: u64,
+    pub recurrence_closure_row_count: u64,
+    pub selector_planner_s: f64,
+    pub selector_gather_s: f64,
+    pub selector_scatter_s: f64,
+    pub selector_plan_kind: String,
+    pub selector_group_sizes: Vec<usize>,
+    pub selector_reordered_point_count: usize,
+    pub selector_simd_lane_width: usize,
+    pub selector_simd_occupancy: f64,
+    pub native_input_component_count: u64,
+    pub native_input_pack_bytes: u64,
+    pub native_input_crossing_bytes: u64,
+    /// Explicit nested native-input containers allocated for this call.
+    pub native_input_container_allocation_count: u64,
+    pub state_component_count: u64,
+    pub state_clear_component_count: u64,
+    pub source_component_count: u64,
+    pub momentum_component_count: u64,
+    pub model_parameter_component_count: u64,
+    pub stage_input_copy_component_count: u64,
+    pub stage_leaf_input_copy_component_count: u64,
+    pub stage_evaluator_output_gather_component_count: u64,
+    pub stage_output_assign_component_count: u64,
+    pub amplitude_input_copy_component_count: u64,
+    pub amplitude_leaf_input_copy_component_count: u64,
+    pub amplitude_evaluator_output_gather_component_count: u64,
+    pub amplitude_output_remap_component_count: u64,
+    pub evaluator_backend_call_count: u64,
+    /// Number of compiled Direct-Arena engines authenticated for this profile.
+    pub compiled_direct_arena_engine_count: u64,
+    /// Calls observed directly on compiled Direct-Arena evaluator leaves.
+    pub compiled_direct_arena_call_count: u64,
+    /// Minimum effective tile across the compiled Direct engine fleet.
+    pub compiled_direct_arena_minimum_effective_tile_capacity: u64,
+    /// Maximum authenticated physical scalar-plane footprint per point.
+    pub compiled_direct_arena_maximum_physical_scalar_values_per_point: u64,
+    /// Maximum phase-local cache footprint per point.
+    pub compiled_direct_arena_maximum_hot_scalar_values_per_point: u64,
+    pub compiled_direct_arena_maximum_source_scalar_values_per_point: u64,
+    pub compiled_direct_arena_maximum_reduction_scalar_values_per_point: u64,
+    /// Developer-adapter traffic is forbidden in the production Arena lane.
+    pub compiled_direct_arena_boundary_input_bytes: u64,
+    pub compiled_direct_arena_boundary_current_output_bytes: u64,
+    pub compiled_direct_arena_boundary_amplitude_output_bytes: u64,
+    pub reduction_input_component_count: u64,
+    pub selector_gather_point_count: u64,
+    pub selector_gather_bytes: u64,
+    pub selector_scatter_value_count: u64,
+    pub resolved_materialized_component_count: u64,
+    pub total_materialized_value_count: u64,
+    pub final_output_copy_value_count: u64,
+    /// Capacity-changing reallocations observed in instrumented reusable hot
+    /// buffers. This is intentionally not a process-wide allocation count.
+    pub observed_scratch_reallocation_count: u64,
+    /// Explicit final native output vector allocated for this call.
+    pub native_output_allocation_count: u64,
+}
+
+impl From<RuntimeProfile> for NativeRuntimeProfile {
+    fn from(profile: RuntimeProfile) -> Self {
+        Self {
+            native_input_pack_s: 0.0,
+            native_input_crossing_s: 0.0,
+            orchestration_s: profile.orchestration_s,
+            state_prepare_s: profile.state_prepare_s,
+            state_clear_s: profile.state_clear_s,
+            source_fill_s: profile.source_fill_s,
+            momentum_input_setup_s: profile.momentum_input_setup_s,
+            momentum_setup_s: profile.momentum_setup_s,
+            model_parameter_setup_s: profile.model_parameter_setup_s,
+            stage_input_pack_s: profile.stage_input_pack_s,
+            stage_leaf_input_pack_s: profile.stage_leaf_input_pack_s,
+            stage_evaluator_call_s: profile.stage_evaluator_call_s,
+            stage_backend_call_s: profile.stage_backend_call_s,
+            stage_evaluator_output_gather_s: profile.stage_evaluator_output_gather_s,
+            stage_evaluator_s: profile.stage_evaluator_s,
+            output_assign_s: profile.output_assign_s,
+            amplitude_input_pack_s: profile.amplitude_input_pack_s,
+            amplitude_leaf_input_pack_s: profile.amplitude_leaf_input_pack_s,
+            amplitude_evaluator_call_s: profile.amplitude_evaluator_call_s,
+            amplitude_backend_call_s: profile.amplitude_backend_call_s,
+            amplitude_evaluator_output_gather_s: profile.amplitude_evaluator_output_gather_s,
+            amplitude_output_remap_s: profile.amplitude_output_remap_s,
+            amplitude_evaluator_s: profile.amplitude_evaluator_s,
+            reduction_s: profile.reduction_s,
+            resolved_reduction_materialization_s: profile.resolved_reduction_materialization_s,
+            total_materialization_s: profile.total_materialization_s,
+            final_output_copy_s: profile.final_output_copy_s,
+            total_s: profile.total_s,
+            stage_input_pack_by_stage_s: profile.stage_input_pack_by_stage_s,
+            stage_leaf_input_pack_by_stage_s: profile.stage_leaf_input_pack_by_stage_s,
+            stage_evaluator_call_by_stage_s: profile.stage_evaluator_call_by_stage_s,
+            stage_backend_call_by_stage_s: profile.stage_backend_call_by_stage_s,
+            stage_evaluator_output_gather_by_stage_s: profile
+                .stage_evaluator_output_gather_by_stage_s,
+            stage_output_assign_by_stage_s: profile.stage_output_assign_by_stage_s,
+            eager_initialize_s: profile.eager_initialize_s,
+            eager_gather_s: profile.eager_gather_s,
+            eager_kernel_call_s: profile.eager_kernel_call_s,
+            eager_invocation_scatter_s: profile.eager_invocation_scatter_s,
+            eager_finalization_s: profile.eager_finalization_s,
+            eager_scatter_finalization_s: profile.eager_scatter_finalization_s,
+            eager_closure_s: profile.eager_closure_s,
+            eager_reduction_s: profile.eager_reduction_s,
+            eager_copy_out_s: profile.eager_copy_out_s,
+            recurrence_momentum_fill_s: profile.recurrence_momentum_fill_s,
+            recurrence_union_source_fill_s: profile.recurrence_union_source_fill_s,
+            recurrence_schedule_s: profile.recurrence_schedule_s,
+            recurrence_source_kernel_s: profile.recurrence_source_kernel_s,
+            recurrence_contribution_kernel_s: profile.recurrence_contribution_kernel_s,
+            recurrence_finalization_s: profile.recurrence_finalization_s,
+            recurrence_closure_s: profile.recurrence_closure_s,
+            recurrence_replay_output_mapping_s: profile.recurrence_replay_output_mapping_s,
+            recurrence_momentum_scalar_value_count: profile.recurrence_momentum_scalar_value_count,
+            recurrence_schedule_execution_count: profile.recurrence_schedule_execution_count,
+            recurrence_replay_schedule_execution_count: profile
+                .recurrence_replay_schedule_execution_count,
+            recurrence_union_schedule_execution_count: profile
+                .recurrence_union_schedule_execution_count,
+            recurrence_union_source_row_count: profile.recurrence_union_source_row_count,
+            recurrence_replay_output_value_count: profile.recurrence_replay_output_value_count,
+            recurrence_source_call_count: profile.recurrence_source_call_count,
+            recurrence_source_row_count: profile.recurrence_source_row_count,
+            recurrence_contribution_call_count: profile.recurrence_contribution_call_count,
+            recurrence_contribution_row_count: profile.recurrence_contribution_row_count,
+            recurrence_finalization_call_count: profile.recurrence_finalization_call_count,
+            recurrence_finalization_row_count: profile.recurrence_finalization_row_count,
+            recurrence_closure_call_count: profile.recurrence_closure_call_count,
+            recurrence_closure_row_count: profile.recurrence_closure_row_count,
+            selector_planner_s: 0.0,
+            selector_gather_s: 0.0,
+            selector_scatter_s: 0.0,
+            selector_plan_kind: "none".to_string(),
+            selector_group_sizes: Vec::new(),
+            selector_reordered_point_count: 0,
+            selector_simd_lane_width: 1,
+            selector_simd_occupancy: 1.0,
+            native_input_component_count: 0,
+            native_input_pack_bytes: 0,
+            native_input_crossing_bytes: 0,
+            native_input_container_allocation_count: 0,
+            state_component_count: profile.state_component_count,
+            state_clear_component_count: profile.state_clear_component_count,
+            source_component_count: profile.source_component_count,
+            momentum_component_count: profile.momentum_component_count,
+            model_parameter_component_count: profile.model_parameter_component_count,
+            stage_input_copy_component_count: profile.stage_input_copy_component_count,
+            stage_leaf_input_copy_component_count: profile.stage_leaf_input_copy_component_count,
+            stage_evaluator_output_gather_component_count: profile
+                .stage_evaluator_output_gather_component_count,
+            stage_output_assign_component_count: profile.stage_output_assign_component_count,
+            amplitude_input_copy_component_count: profile.amplitude_input_copy_component_count,
+            amplitude_leaf_input_copy_component_count: profile
+                .amplitude_leaf_input_copy_component_count,
+            amplitude_evaluator_output_gather_component_count: profile
+                .amplitude_evaluator_output_gather_component_count,
+            amplitude_output_remap_component_count: profile.amplitude_output_remap_component_count,
+            evaluator_backend_call_count: profile.evaluator_backend_call_count,
+            compiled_direct_arena_engine_count: profile.compiled_direct_arena_engine_count,
+            compiled_direct_arena_call_count: profile.compiled_direct_arena_call_count,
+            compiled_direct_arena_minimum_effective_tile_capacity: profile
+                .compiled_direct_arena_minimum_effective_tile_capacity,
+            compiled_direct_arena_maximum_physical_scalar_values_per_point: profile
+                .compiled_direct_arena_maximum_physical_scalar_values_per_point,
+            compiled_direct_arena_maximum_hot_scalar_values_per_point: profile
+                .compiled_direct_arena_maximum_hot_scalar_values_per_point,
+            compiled_direct_arena_maximum_source_scalar_values_per_point: profile
+                .compiled_direct_arena_maximum_source_scalar_values_per_point,
+            compiled_direct_arena_maximum_reduction_scalar_values_per_point: profile
+                .compiled_direct_arena_maximum_reduction_scalar_values_per_point,
+            compiled_direct_arena_boundary_input_bytes: profile
+                .compiled_direct_arena_boundary_input_bytes,
+            compiled_direct_arena_boundary_current_output_bytes: profile
+                .compiled_direct_arena_boundary_current_output_bytes,
+            compiled_direct_arena_boundary_amplitude_output_bytes: profile
+                .compiled_direct_arena_boundary_amplitude_output_bytes,
+            reduction_input_component_count: profile.reduction_input_component_count,
+            selector_gather_point_count: 0,
+            selector_gather_bytes: 0,
+            selector_scatter_value_count: 0,
+            resolved_materialized_component_count: profile.resolved_materialized_component_count,
+            total_materialized_value_count: profile.total_materialized_value_count,
+            final_output_copy_value_count: profile.final_output_copy_value_count,
+            observed_scratch_reallocation_count: profile.scratch_reallocation_count,
+            native_output_allocation_count: 0,
+        }
+    }
+}
+
+impl NativeRuntimeProfile {
+    fn validate_eager_top_level_accounting(&self) -> RusticolResult<()> {
+        self.validate_top_level_accounting(true)
+    }
+
+    fn validate_compiled_top_level_accounting(&self) -> RusticolResult<()> {
+        self.validate_top_level_accounting(false)
+    }
+
+    fn validate_recurrence_top_level_accounting(&self) -> RusticolResult<()> {
+        let phases = [
+            ("native input pack", self.native_input_pack_s),
+            ("native input crossing", self.native_input_crossing_s),
+            ("runtime orchestration", self.orchestration_s),
+            ("state preparation", self.state_prepare_s),
+            ("state clearing", self.state_clear_s),
+            ("source preparation", self.source_fill_s),
+            ("external momentum flatten", self.momentum_input_setup_s),
+            ("model parameter setup", self.model_parameter_setup_s),
+            (
+                "recurrence momentum-form fill",
+                self.recurrence_momentum_fill_s,
+            ),
+            (
+                "recurrence union source fill",
+                self.recurrence_union_source_fill_s,
+            ),
+            ("inclusive recurrence schedule", self.recurrence_schedule_s),
+            (
+                "recurrence replay output mapping",
+                self.recurrence_replay_output_mapping_s,
+            ),
+            ("reduction", self.reduction_s),
+            ("total materialization", self.total_materialization_s),
+            ("final output copy", self.final_output_copy_s),
+            ("selector planning", self.selector_planner_s),
+            ("selector gather", self.selector_gather_s),
+            ("selector scatter", self.selector_scatter_s),
+        ];
+        self.validate_exclusive_phases(&phases)?;
+
+        let schedule_attribution = [
+            ("source kernels", self.recurrence_source_kernel_s),
+            (
+                "contribution kernels",
+                self.recurrence_contribution_kernel_s,
+            ),
+            ("current finalization", self.recurrence_finalization_s),
+            ("amplitude closure", self.recurrence_closure_s),
+        ];
+        for (label, value) in &schedule_attribution {
+            if !value.is_finite() || *value < 0.0 {
+                return Err(RusticolError::internal(format!(
+                    "native recurrence profile has invalid {label} time {value:.9e}s"
+                )));
+            }
+        }
+        let attributed = schedule_attribution
+            .iter()
+            .map(|(_, value)| value)
+            .sum::<f64>();
+        let tolerance = 1.0e-9_f64.max(self.recurrence_schedule_s * 1.0e-12);
+        if attributed > self.recurrence_schedule_s + tolerance {
+            return Err(RusticolError::internal(format!(
+                "native recurrence schedule sub-attribution accounts for {attributed:.9e}s, exceeding inclusive recurrence schedule time {schedule:.9e}s",
+                schedule = self.recurrence_schedule_s,
+            )));
+        }
+        Ok(())
+    }
+
+    fn validate_exclusive_phases(&self, phases: &[(&str, f64)]) -> RusticolResult<()> {
+        if !self.total_s.is_finite() || self.total_s < 0.0 {
+            return Err(RusticolError::internal(format!(
+                "native profile has invalid wall time {:.9e}s",
+                self.total_s,
+            )));
+        }
+        for (label, value) in phases {
+            if !value.is_finite() || *value < 0.0 {
+                return Err(RusticolError::internal(format!(
+                    "native profile has invalid {label} time {value:.9e}s"
+                )));
+            }
+        }
+        let accounted = phases.iter().map(|(_, value)| value).sum::<f64>();
+        let tolerance = 1.0e-9_f64.max(self.total_s * 1.0e-12);
+        if accounted > self.total_s + tolerance {
+            return Err(RusticolError::internal(format!(
+                "native profile exclusive top-level phases account for {accounted:.9e}s, exceeding wall time {wall:.9e}s",
+                wall = self.total_s,
+            )));
+        }
+        Ok(())
+    }
+
+    fn validate_top_level_accounting(&self, eager: bool) -> RusticolResult<()> {
+        let mut phases = vec![
+            ("native input pack", self.native_input_pack_s),
+            ("native input crossing", self.native_input_crossing_s),
+            ("runtime orchestration", self.orchestration_s),
+            ("state preparation", self.state_prepare_s),
+            ("state clearing", self.state_clear_s),
+            ("source fill", self.source_fill_s),
+            ("momentum input setup", self.momentum_input_setup_s),
+            ("model parameter setup", self.model_parameter_setup_s),
+        ];
+        if eager {
+            phases.push(("inclusive eager execution", self.stage_evaluator_call_s));
+        } else {
+            phases.extend([
+                ("stage input pack", self.stage_input_pack_s),
+                ("stage evaluator calls", self.stage_evaluator_call_s),
+                ("stage output assignment", self.output_assign_s),
+                ("amplitude input pack", self.amplitude_input_pack_s),
+                ("amplitude evaluator calls", self.amplitude_evaluator_call_s),
+                ("reduction", self.reduction_s),
+            ]);
+        }
+        phases.extend([
+            ("total materialization", self.total_materialization_s),
+            ("final output copy", self.final_output_copy_s),
+            ("selector planning", self.selector_planner_s),
+            ("selector gather", self.selector_gather_s),
+            ("selector scatter", self.selector_scatter_s),
+        ]);
+        self.validate_exclusive_phases(&phases)
+    }
+
+    #[inline(never)]
+    fn accumulate(&mut self, other: &Self) {
+        self.native_input_pack_s += other.native_input_pack_s;
+        self.native_input_crossing_s += other.native_input_crossing_s;
+        self.orchestration_s += other.orchestration_s;
+        self.state_prepare_s += other.state_prepare_s;
+        self.state_clear_s += other.state_clear_s;
+        self.source_fill_s += other.source_fill_s;
+        self.momentum_input_setup_s += other.momentum_input_setup_s;
+        self.momentum_setup_s += other.momentum_setup_s;
+        self.model_parameter_setup_s += other.model_parameter_setup_s;
+        self.stage_input_pack_s += other.stage_input_pack_s;
+        self.stage_leaf_input_pack_s += other.stage_leaf_input_pack_s;
+        self.stage_evaluator_call_s += other.stage_evaluator_call_s;
+        self.stage_backend_call_s += other.stage_backend_call_s;
+        self.stage_evaluator_output_gather_s += other.stage_evaluator_output_gather_s;
+        self.stage_evaluator_s += other.stage_evaluator_s;
+        self.output_assign_s += other.output_assign_s;
+        self.amplitude_input_pack_s += other.amplitude_input_pack_s;
+        self.amplitude_leaf_input_pack_s += other.amplitude_leaf_input_pack_s;
+        self.amplitude_evaluator_call_s += other.amplitude_evaluator_call_s;
+        self.amplitude_backend_call_s += other.amplitude_backend_call_s;
+        self.amplitude_evaluator_output_gather_s += other.amplitude_evaluator_output_gather_s;
+        self.amplitude_output_remap_s += other.amplitude_output_remap_s;
+        self.amplitude_evaluator_s += other.amplitude_evaluator_s;
+        self.reduction_s += other.reduction_s;
+        self.resolved_reduction_materialization_s += other.resolved_reduction_materialization_s;
+        self.total_materialization_s += other.total_materialization_s;
+        self.final_output_copy_s += other.final_output_copy_s;
+        self.total_s += other.total_s;
+        accumulate_profile_stages(
+            &mut self.stage_input_pack_by_stage_s,
+            &other.stage_input_pack_by_stage_s,
+        );
+        accumulate_profile_stages(
+            &mut self.stage_leaf_input_pack_by_stage_s,
+            &other.stage_leaf_input_pack_by_stage_s,
+        );
+        accumulate_profile_stages(
+            &mut self.stage_evaluator_call_by_stage_s,
+            &other.stage_evaluator_call_by_stage_s,
+        );
+        accumulate_profile_stages(
+            &mut self.stage_backend_call_by_stage_s,
+            &other.stage_backend_call_by_stage_s,
+        );
+        accumulate_profile_stages(
+            &mut self.stage_evaluator_output_gather_by_stage_s,
+            &other.stage_evaluator_output_gather_by_stage_s,
+        );
+        accumulate_profile_stages(
+            &mut self.stage_output_assign_by_stage_s,
+            &other.stage_output_assign_by_stage_s,
+        );
+        self.eager_initialize_s += other.eager_initialize_s;
+        self.eager_gather_s += other.eager_gather_s;
+        self.eager_kernel_call_s += other.eager_kernel_call_s;
+        self.eager_invocation_scatter_s += other.eager_invocation_scatter_s;
+        self.eager_finalization_s += other.eager_finalization_s;
+        self.eager_scatter_finalization_s += other.eager_scatter_finalization_s;
+        self.eager_closure_s += other.eager_closure_s;
+        self.eager_reduction_s += other.eager_reduction_s;
+        self.eager_copy_out_s += other.eager_copy_out_s;
+        self.recurrence_momentum_fill_s += other.recurrence_momentum_fill_s;
+        self.recurrence_union_source_fill_s += other.recurrence_union_source_fill_s;
+        self.recurrence_schedule_s += other.recurrence_schedule_s;
+        self.recurrence_source_kernel_s += other.recurrence_source_kernel_s;
+        self.recurrence_contribution_kernel_s += other.recurrence_contribution_kernel_s;
+        self.recurrence_finalization_s += other.recurrence_finalization_s;
+        self.recurrence_closure_s += other.recurrence_closure_s;
+        self.recurrence_replay_output_mapping_s += other.recurrence_replay_output_mapping_s;
+        self.recurrence_momentum_scalar_value_count += other.recurrence_momentum_scalar_value_count;
+        self.recurrence_schedule_execution_count += other.recurrence_schedule_execution_count;
+        self.recurrence_replay_schedule_execution_count +=
+            other.recurrence_replay_schedule_execution_count;
+        self.recurrence_union_schedule_execution_count +=
+            other.recurrence_union_schedule_execution_count;
+        self.recurrence_union_source_row_count += other.recurrence_union_source_row_count;
+        self.recurrence_replay_output_value_count += other.recurrence_replay_output_value_count;
+        self.recurrence_source_call_count += other.recurrence_source_call_count;
+        self.recurrence_source_row_count += other.recurrence_source_row_count;
+        self.recurrence_contribution_call_count += other.recurrence_contribution_call_count;
+        self.recurrence_contribution_row_count += other.recurrence_contribution_row_count;
+        self.recurrence_finalization_call_count += other.recurrence_finalization_call_count;
+        self.recurrence_finalization_row_count += other.recurrence_finalization_row_count;
+        self.recurrence_closure_call_count += other.recurrence_closure_call_count;
+        self.recurrence_closure_row_count += other.recurrence_closure_row_count;
+        self.selector_planner_s += other.selector_planner_s;
+        self.selector_gather_s += other.selector_gather_s;
+        self.selector_scatter_s += other.selector_scatter_s;
+        self.native_input_component_count += other.native_input_component_count;
+        self.native_input_pack_bytes += other.native_input_pack_bytes;
+        self.native_input_crossing_bytes += other.native_input_crossing_bytes;
+        self.native_input_container_allocation_count +=
+            other.native_input_container_allocation_count;
+        self.state_component_count += other.state_component_count;
+        self.state_clear_component_count += other.state_clear_component_count;
+        self.source_component_count += other.source_component_count;
+        self.momentum_component_count += other.momentum_component_count;
+        self.model_parameter_component_count += other.model_parameter_component_count;
+        self.stage_input_copy_component_count += other.stage_input_copy_component_count;
+        self.stage_leaf_input_copy_component_count += other.stage_leaf_input_copy_component_count;
+        self.stage_evaluator_output_gather_component_count +=
+            other.stage_evaluator_output_gather_component_count;
+        self.stage_output_assign_component_count += other.stage_output_assign_component_count;
+        self.amplitude_input_copy_component_count += other.amplitude_input_copy_component_count;
+        self.amplitude_leaf_input_copy_component_count +=
+            other.amplitude_leaf_input_copy_component_count;
+        self.amplitude_evaluator_output_gather_component_count +=
+            other.amplitude_evaluator_output_gather_component_count;
+        self.amplitude_output_remap_component_count += other.amplitude_output_remap_component_count;
+        self.evaluator_backend_call_count += other.evaluator_backend_call_count;
+        self.compiled_direct_arena_engine_count += other.compiled_direct_arena_engine_count;
+        self.compiled_direct_arena_call_count += other.compiled_direct_arena_call_count;
+        self.compiled_direct_arena_minimum_effective_tile_capacity = match (
+            self.compiled_direct_arena_minimum_effective_tile_capacity,
+            other.compiled_direct_arena_minimum_effective_tile_capacity,
+        ) {
+            (0, value) | (value, 0) => value,
+            (left, right) => left.min(right),
+        };
+        self.compiled_direct_arena_maximum_physical_scalar_values_per_point = self
+            .compiled_direct_arena_maximum_physical_scalar_values_per_point
+            .max(other.compiled_direct_arena_maximum_physical_scalar_values_per_point);
+        self.compiled_direct_arena_maximum_hot_scalar_values_per_point = self
+            .compiled_direct_arena_maximum_hot_scalar_values_per_point
+            .max(other.compiled_direct_arena_maximum_hot_scalar_values_per_point);
+        self.compiled_direct_arena_maximum_source_scalar_values_per_point = self
+            .compiled_direct_arena_maximum_source_scalar_values_per_point
+            .max(other.compiled_direct_arena_maximum_source_scalar_values_per_point);
+        self.compiled_direct_arena_maximum_reduction_scalar_values_per_point = self
+            .compiled_direct_arena_maximum_reduction_scalar_values_per_point
+            .max(other.compiled_direct_arena_maximum_reduction_scalar_values_per_point);
+        self.compiled_direct_arena_boundary_input_bytes +=
+            other.compiled_direct_arena_boundary_input_bytes;
+        self.compiled_direct_arena_boundary_current_output_bytes +=
+            other.compiled_direct_arena_boundary_current_output_bytes;
+        self.compiled_direct_arena_boundary_amplitude_output_bytes +=
+            other.compiled_direct_arena_boundary_amplitude_output_bytes;
+        self.reduction_input_component_count += other.reduction_input_component_count;
+        self.selector_gather_point_count += other.selector_gather_point_count;
+        self.selector_gather_bytes += other.selector_gather_bytes;
+        self.selector_scatter_value_count += other.selector_scatter_value_count;
+        self.resolved_materialized_component_count += other.resolved_materialized_component_count;
+        self.total_materialized_value_count += other.total_materialized_value_count;
+        self.final_output_copy_value_count += other.final_output_copy_value_count;
+        self.observed_scratch_reallocation_count += other.observed_scratch_reallocation_count;
+        self.native_output_allocation_count += other.native_output_allocation_count;
+        if self.selector_plan_kind == "none" && other.selector_plan_kind != "none" {
+            self.selector_plan_kind
+                .clone_from(&other.selector_plan_kind);
+            self.selector_group_sizes
+                .clone_from(&other.selector_group_sizes);
+            self.selector_reordered_point_count = other.selector_reordered_point_count;
+            self.selector_simd_lane_width = other.selector_simd_lane_width;
+            self.selector_simd_occupancy = other.selector_simd_occupancy;
+        }
+    }
+}
+
+fn accumulate_profile_stages(target: &mut Vec<f64>, source: &[f64]) {
+    if target.len() < source.len() {
+        target.resize(source.len(), 0.0);
+    }
+    for (target, source) in target.iter_mut().zip(source) {
+        *target += source;
+    }
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct NativeProfiledEvaluation {
+    pub values: Vec<f64>,
+    pub profile: NativeRuntimeProfile,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct NativeResolvedEvaluation {
+    /// Row-major storage with layout `[point][helicity][color]`.
+    pub values: Vec<f64>,
+    pub point_count: usize,
+    pub helicity_ids: Vec<String>,
+    pub color_ids: Vec<String>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct NativeDecimalEvaluation {
+    pub values: Vec<String>,
+    pub decimal_digits: u32,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct NativeDecimalResolvedEvaluation {
+    /// Row-major storage with layout `[point][helicity][color]`.
+    pub values: Vec<String>,
+    pub totals: Vec<String>,
+    pub point_count: usize,
+    pub helicity_ids: Vec<String>,
+    pub color_ids: Vec<String>,
+    pub decimal_digits: u32,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct NativeExternalParticle {
+    pub label: usize,
+    pub index: usize,
+    pub side: String,
+    pub role: String,
+    pub particle: String,
+    pub outgoing_particle: String,
+    pub pdg: i32,
+    pub outgoing_pdg: i32,
+    pub particle_class: String,
+    pub momentum_slot: usize,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct NativeHelicityConfiguration {
+    pub id: String,
+    pub index: usize,
+    pub helicities: Vec<i32>,
+    pub representative_id: String,
+    pub computed: bool,
+    pub structural_zero: bool,
+    pub coefficient: f64,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct NativeColorComponent {
+    pub id: String,
+    pub index: usize,
+    pub kind: String,
+    pub word: Vec<usize>,
+    pub representative_id: String,
+    pub computed: bool,
+    pub coefficient: f64,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct NativeModelParameter {
+    pub name: String,
+    pub kind: String,
+    pub parameter_index: usize,
+    pub default: f64,
+    pub default_imaginary: f64,
+    pub mutable: bool,
+}
+
+impl NativeResolvedEvaluation {
+    pub fn shape(&self) -> (usize, usize, usize) {
+        (
+            self.point_count,
+            self.helicity_ids.len(),
+            self.color_ids.len(),
+        )
+    }
+
+    pub fn totals(&self) -> Vec<f64> {
+        let component_count = self.helicity_ids.len() * self.color_ids.len();
+        self.values
+            .chunks(component_count)
+            .map(|point| point.iter().sum())
+            .collect()
+    }
+}
+
+impl NativeDecimalResolvedEvaluation {
+    pub fn shape(&self) -> (usize, usize, usize) {
+        (
+            self.point_count,
+            self.helicity_ids.len(),
+            self.color_ids.len(),
+        )
+    }
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[derive(Clone, Debug)]
+#[doc(hidden)]
+pub struct NativeOnTheFlyCurrentProbeV1 {
+    pub semantic_digest: String,
+    pub component_count: u32,
+    /// Point-major, then component-major split-complex values.
+    pub values: Vec<[f64; 2]>,
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[derive(Clone, Debug)]
+#[doc(hidden)]
+pub struct NativeOnTheFlyFamilyQueryProbeV1 {
+    pub selected_public_flow_id: u32,
+    pub public_helicities: Vec<i32>,
+    pub query_digest: String,
+    pub raw_amplitudes: Vec<[f64; 2]>,
+    pub normalized_values: Vec<f64>,
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[derive(Clone, Debug)]
+#[doc(hidden)]
+pub struct NativeOnTheFlyFamilyProbeV1 {
+    pub queries: Vec<NativeOnTheFlyFamilyQueryProbeV1>,
+    pub census: crate::recurrence::OnTheFlyQueryFamilyCensusV1,
+    pub execution_cache_hit: bool,
+    pub execution_source_calls: u32,
+    pub execution_source_rows: u32,
+    pub execution_contribution_calls: u32,
+    pub execution_contribution_rows: u32,
+    pub execution_finalization_calls: u32,
+    pub execution_finalization_rows: u32,
+    pub execution_closure_calls: u32,
+    pub execution_closure_rows: u32,
+    pub cold_prepare_seconds: f64,
+    pub benchmark_warmup_repetitions: u32,
+    pub benchmark_repetitions: u32,
+    pub benchmark_elapsed_seconds: Option<f64>,
+    pub benchmark_seconds_per_point: Option<f64>,
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[derive(Clone, Debug)]
+#[doc(hidden)]
+pub struct NativeOnTheFlyArtifactProbeV1 {
+    pub artifact_id: String,
+    pub process_id: String,
+    pub seed_digest: String,
+    pub query_digest: String,
+    pub trace_digest: String,
+    pub point_count: u32,
+    pub raw_amplitudes: Vec<[f64; 2]>,
+    pub normalized_values: Vec<f64>,
+    pub query_family: Option<NativeOnTheFlyFamilyProbeV1>,
+    pub normalization_factor: f64,
+    pub currents: Vec<NativeOnTheFlyCurrentProbeV1>,
+    pub projection_enabled: bool,
+    pub projection_applied: bool,
+    pub projection_counts: [[u32; 3]; 2],
+    pub work_census_basis: String,
+    pub logical_current_count: u32,
+    pub resident_current_count: u32,
+    pub resident_current_component_count: u32,
+    pub source_operation_count: u32,
+    pub contribution_operation_count: u32,
+    pub finalization_operation_count: u32,
+    pub closure_operation_count: u32,
+    pub total_kernel_application_count: u32,
+    pub semantic_executor_binding_count: u32,
+    pub distinct_prepared_executor_count: u32,
+    pub trace_build_count: u32,
+    pub trace_cache_hit_count: u32,
+    pub momentum_fill_count: u32,
+    pub benchmark_warmup_repetitions: u32,
+    pub benchmark_repetitions: u32,
+    pub benchmark_elapsed_seconds: Option<f64>,
+    pub benchmark_seconds_per_point: Option<f64>,
+    pub direct_plan_load_attempts: u32,
+    pub direct_plan_decode_attempts: u32,
+    pub direct_plan_materialization_attempts: u32,
+    pub established_builder_attempts: u32,
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[derive(Clone, Debug)]
+#[doc(hidden)]
+pub struct NativeOnTheFlyExecutionComponentV1 {
+    pub dependency_depth: u32,
+    pub semantic_digest: String,
+    pub component: u32,
+    pub on_the_fly: [f64; 2],
+    pub recurrence: [f64; 2],
+    pub on_the_fly_bits: [u64; 2],
+    pub recurrence_bits: [u64; 2],
+    pub absolute_delta: [f64; 2],
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[derive(Clone, Debug)]
+#[doc(hidden)]
+pub struct NativeOnTheFlyExecutionDiagnosticV1 {
+    pub on_the_fly_artifact_id: String,
+    pub on_the_fly_process_id: String,
+    pub recurrence_artifact_id: String,
+    pub recurrence_process_id: String,
+    pub seed_digest: String,
+    pub query_digest: String,
+    pub trace_digest: String,
+    pub direct_plan_semantic_digest: String,
+    pub direct_runtime_layout_digest: String,
+    pub public_flow_id: u32,
+    pub representative_flow_id: u32,
+    pub public_helicities: Vec<i32>,
+    pub public_direct_helicity_id: u32,
+    pub representative_direct_helicity_id: u32,
+    pub replay_phase: [f64; 2],
+    pub replay_multiplicity: u32,
+    pub replay_scale: [f64; 2],
+    pub on_the_fly_public_amplitude: [f64; 2],
+    pub recurrence_representative_amplitude: [f64; 2],
+    pub recurrence_public_amplitude: [f64; 2],
+    pub amplitude_absolute_delta: [f64; 2],
+    pub current_components: Vec<NativeOnTheFlyExecutionComponentV1>,
+    pub first_raw_bit_difference: Option<usize>,
+    pub raw_bit_difference_count: u32,
+    pub compared_current_count: u32,
+    pub excluded_direct_current_count: u32,
+}
+
+/// Python-independent schema-v3 process runtime.
+///
+/// The input momentum layout is `[point][external particle][E, px, py, pz]`.
+/// Instances are mutable and must not be called concurrently; independent
+/// instances can be used from separate threads.
+pub struct NativeRuntime {
+    root: PathBuf,
+    artifact_id: String,
+    runtime: ExecutionRuntime,
+    execution_lane: NativeExecutionLane,
+    process: String,
+    process_key: String,
+    representative_process_id: String,
+    external_permutation: Vec<usize>,
+    input_crossing_map: Option<Vec<InputCrossingMapEntry>>,
+    permutation_alias_of: Option<String>,
+    final_state_permutation_alias_of: Option<String>,
+    // Absent for stored processes, aliases, and permutations of either.
+    process_group: Option<Box<ProcessGroupRouting>>,
+    physics_v1: native_runtime::LazyProcessPhysicsV1,
+    warnings_muted: bool,
+    warned_kinds: BTreeSet<String>,
+    pending_warnings: Vec<String>,
+    point_selector_scratch: PointSelectorExecutionScratch,
+    selector_simd_lane_width: usize,
+    // Cold, opt-in metadata and vector defaults; ordinary evaluation never reads it.
+    correlated: Option<correlated::CorrelatedRuntime>,
+}
+
+enum NativeExecutionLane {
+    Compiled,
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    Eager(Box<EagerNativeRuntime>),
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    Recurrence(Box<RecurrenceNativeRuntime>),
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    OnTheFly(Box<native_runtime::OnTheFlyExecutionRuntime>),
+}
+
+impl NativeExecutionLane {
+    #[cfg(feature = "symbolica-runtime")]
+    const fn is_eager(&self) -> bool {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            matches!(self, Self::Eager(_))
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            false
+        }
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    const fn is_recurrence(&self) -> bool {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            matches!(self, Self::Recurrence(_))
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            false
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct RuntimeParameterSlots {
+    real: usize,
+    imaginary: Option<usize>,
+}
+
+struct ModelParameterEvaluatorRuntime {
+    input_parameter_indices: Vec<usize>,
+    outputs: Vec<GenericDerivedParameterOutputManifest>,
+    evaluator: EvaluatorGroup,
+}
+
+struct StageRuntime {
+    outputs: Vec<(usize, usize)>,
+    output_spans: Vec<(usize, usize, usize)>,
+    chunk_outputs: Vec<Vec<(usize, usize)>>,
+    chunk_output_spans: Vec<Vec<(usize, usize, usize)>>,
+    input_components: Option<Vec<usize>>,
+    input_spans: Vec<(usize, usize, usize)>,
+    parameter_scratch_f64: Vec<Complex<f64>>,
+    output_scratch_f64: Vec<Complex<f64>>,
+    evaluator: EvaluatorGroup,
+}
+
+#[derive(Default)]
+struct RoutedReductionScratch {
+    helicity_indices: Vec<usize>,
+    color_indices: Vec<usize>,
+    helicity_positions: Vec<Option<usize>>,
+    color_positions: Vec<Option<usize>>,
+    selected_member_weights: Vec<(usize, usize, f64)>,
+    selected_member_weight_ranges: Vec<std::ops::Range<usize>>,
+    direct_group_re: Vec<f64>,
+    direct_group_im: Vec<f64>,
+    direct_source_components: Vec<f64>,
+    direct_target_components: Vec<f64>,
+    direct_totals: Vec<f64>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct MaterializedHelicityDirectTotalPlanKey {
+    physics_binding_id: u64,
+    helicity_index: usize,
+    root_factor_bits: Vec<(usize, [u64; 2])>,
+    color_indices: Vec<usize>,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct MaterializedHelicityDirectTotalRoot {
+    output_index: usize,
+    factor: Complex<f64>,
+}
+
+#[derive(Clone, Debug)]
+struct MaterializedHelicityDirectTotalGroup {
+    root_range: std::ops::Range<usize>,
+    all_sector_weight: f64,
+    identity_output_index: Option<usize>,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct MaterializedHelicityDirectTotalColorGroup {
+    group_index: usize,
+    weight: f64,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct MaterializedHelicityDirectTotalContractionEntry {
+    left_group_index: usize,
+    right_group_index: usize,
+    weight_re: f64,
+    weight_im: f64,
+    symmetry_factor: f64,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct MaterializedHelicityDirectDefaultPlanCacheEntry {
+    physics_binding_id: u64,
+    helicity_index: usize,
+    plan_index: usize,
+}
+
+#[derive(Clone, Debug)]
+enum MaterializedHelicityDirectTotalReduction {
+    Lc {
+        color_group_ranges: Vec<std::ops::Range<usize>>,
+        color_groups: Vec<MaterializedHelicityDirectTotalColorGroup>,
+    },
+    Contracted {
+        entries: Vec<MaterializedHelicityDirectTotalContractionEntry>,
+    },
+}
+
+#[derive(Clone, Debug)]
+struct MaterializedHelicityDirectTotalPlan {
+    key: MaterializedHelicityDirectTotalPlanKey,
+    roots: Vec<MaterializedHelicityDirectTotalRoot>,
+    groups: Vec<MaterializedHelicityDirectTotalGroup>,
+    reduction: MaterializedHelicityDirectTotalReduction,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+struct CompiledDirectRoutedReductionFootprint {
+    maximum_source_component_count: usize,
+    maximum_target_component_count: usize,
+}
+
+impl CompiledDirectRoutedReductionFootprint {
+    fn merge(self, other: Self) -> Self {
+        Self {
+            maximum_source_component_count: self
+                .maximum_source_component_count
+                .max(other.maximum_source_component_count),
+            maximum_target_component_count: self
+                .maximum_target_component_count
+                .max(other.maximum_target_component_count),
+        }
+    }
+
+    const fn is_empty(self) -> bool {
+        self.maximum_source_component_count == 0 && self.maximum_target_component_count == 0
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum CompiledDirectReducerKind {
+    Plain,
+    Coherent,
+    Contracted { group_count: usize },
+    SymmetricGroup { workspace_scalars_per_lane: usize },
+    ColorTopologyReplay { physical_group_count: usize },
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+enum CompiledDirectReductionFootprint {
+    /// The maximum reducer working set was derived entirely from authenticated
+    /// amplitude, physics, and replay metadata.
+    Authenticated { hot_scalar_values_per_point: usize },
+    /// A future/legacy execution shape did not expose enough static metadata.
+    /// Production Direct tiling must fail closed to one point.
+    #[default]
+    Unauthenticated,
+}
+
+impl CompiledDirectReductionFootprint {
+    fn authenticated(
+        kind: CompiledDirectReducerKind,
+        maximum_group_component_count: usize,
+        maximum_resolved_component_count: usize,
+        routed: CompiledDirectRoutedReductionFootprint,
+    ) -> RusticolResult<Self> {
+        let maximum_group_plane_scalars = maximum_group_component_count
+            .max(1)
+            .checked_mul(2)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "compiled Direct-Arena reduction group footprint overflows",
+                )
+            })?;
+        let (amplitude_input_scalars, reducer_workspace_scalars, supports_resolved) = match kind {
+            CompiledDirectReducerKind::Plain => (2, 0, false),
+            CompiledDirectReducerKind::Coherent => (maximum_group_plane_scalars, 2, true),
+            CompiledDirectReducerKind::Contracted { group_count } => (
+                maximum_group_plane_scalars,
+                group_count.checked_mul(2).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "compiled Direct-Arena contracted reduction footprint overflows",
+                    )
+                })?,
+                true,
+            ),
+            CompiledDirectReducerKind::SymmetricGroup {
+                workspace_scalars_per_lane,
+            } => (
+                maximum_group_plane_scalars,
+                workspace_scalars_per_lane,
+                false,
+            ),
+            CompiledDirectReducerKind::ColorTopologyReplay {
+                physical_group_count,
+            } => (
+                maximum_group_plane_scalars,
+                physical_group_count.checked_mul(2).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "compiled Direct-Arena topology-replay footprint overflows",
+                    )
+                })?,
+                true,
+            ),
+        };
+        // One real total plane is live in every reducer. Reducer storage is a
+        // cache-local working-set estimate only; none of it belongs to the
+        // Direct workspace batching target.
+        let total_phase = amplitude_input_scalars
+            .checked_add(reducer_workspace_scalars)
+            .and_then(|value| value.checked_add(1))
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "compiled Direct-Arena total-reduction footprint overflows",
+                )
+            })?;
+        let resolved_phase = if supports_resolved {
+            total_phase
+                .checked_add(maximum_resolved_component_count)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "compiled Direct-Arena resolved-reduction footprint overflows",
+                    )
+                })?
+        } else {
+            total_phase
+        };
+        let routed_phase = if routed.is_empty() {
+            0
+        } else {
+            // Routed reducers materialize a split-complex group, one real
+            // totals plane, and authenticated source/target component planes.
+            // The target may be owned by an outer public-batch replay, but its
+            // tile slice is still part of the phase-local cache working set.
+            amplitude_input_scalars
+                .checked_add(2)
+                .and_then(|value| value.checked_add(1))
+                .and_then(|value| value.checked_add(routed.maximum_source_component_count))
+                .and_then(|value| value.checked_add(routed.maximum_target_component_count))
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "compiled Direct-Arena routed-reduction footprint overflows",
+                    )
+                })?
+        };
+        Ok(Self::Authenticated {
+            hot_scalar_values_per_point: total_phase.max(resolved_phase).max(routed_phase),
+        })
+    }
+
+    const fn hot_scalar_values_per_point(self) -> Option<usize> {
+        match self {
+            Self::Authenticated {
+                hot_scalar_values_per_point,
+            } => Some(hot_scalar_values_per_point),
+            Self::Unauthenticated => None,
+        }
+    }
+}
+
+struct AmplitudeRuntime {
+    output_length: usize,
+    raw_sum_weights: Vec<f64>,
+    raw_sum_all_sector_weights: Vec<f64>,
+    raw_sum_color_sector_ids: Vec<Option<i64>>,
+    raw_sum_groups: Vec<RawSumGroup>,
+    has_coherent_groups: bool,
+    color_contraction: Option<ColorContractionRuntime>,
+    color_topology_replay: Option<ColorTopologyReplayAmplitudeRuntime>,
+    input_components: Option<Vec<usize>>,
+    input_spans: Vec<(usize, usize, usize)>,
+    parameter_scratch_f64: Vec<Complex<f64>>,
+    evaluator_output_scratch_f64: Vec<Complex<f64>>,
+    output_scratch_f64: Vec<Complex<f64>>,
+    resolved_source_row_scratch_f64: Vec<f64>,
+    resolved_target_row_scratch_f64: Vec<f64>,
+    routed_reduction_scratch: RoutedReductionScratch,
+    materialized_helicity_direct_total_plans: Vec<MaterializedHelicityDirectTotalPlan>,
+    materialized_helicity_direct_total_plan_capacity: usize,
+    materialized_helicity_direct_total_next_replacement: usize,
+    materialized_helicity_direct_default_plan_by_selector_domain:
+        Vec<Option<MaterializedHelicityDirectDefaultPlanCacheEntry>>,
+    evaluator_output_order: Option<Vec<usize>>,
+    evaluator: Option<EvaluatorGroup>,
+}
+
+struct ColorTopologyReplayAmplitudeRuntime {
+    mappings: Vec<ColorTopologyReplayAmplitudeMapping>,
+    physical_groups: Vec<RawSumGroup>,
+    physical_group_helicities: Vec<Vec<i32>>,
+    color_contraction: Option<ColorContractionRuntime>,
+    unit_weights: Vec<f64>,
+    no_sector_ids: Vec<Option<i64>>,
+    physical_group_scratch_f64: Vec<Complex<f64>>,
+    covered_groups: Vec<bool>,
+}
+
+struct ColorTopologyReplayAmplitudeMapping {
+    label_permutation: Vec<(usize, usize)>,
+    group_routes: Vec<ColorTopologyReplayAmplitudeGroupRoute>,
+}
+
+struct ColorTopologyReplayAmplitudeGroupRoute {
+    source_group_index: usize,
+    target_group_index: usize,
+    factor: Complex<f64>,
+}
+
+mod runtime_load;
+use runtime_load::*;
+
+mod model_parameters;
+use model_parameters::*;
+
+mod evaluation;
+use evaluation::resolved_f64_totals;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod compiled_direct_prototype;
+mod helicity_lane;
+use helicity_lane::*;
+mod momentum;
+use momentum::*;
+mod sources;
+
+mod validation;
+use validation::*;
+
+mod correlated;
+mod native_runtime;
+pub use correlated::{
+    NativeCorrelatedEvaluation, NativeCorrelatedRequest, NativeSpinCorrelationVectors,
+};
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod on_the_fly_warm_up;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+pub use on_the_fly_warm_up::{
+    NativeOnTheFlyWarmUpEvent, NativeOnTheFlyWarmUpEventKind, NativeOnTheFlyWarmUpObserver,
+    NativeOnTheFlyWarmUpResult, NativeOnTheFlyWarmUpStage,
+};
+
+mod artifact_load;
+use artifact_load::*;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod eager_backend;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use eager_backend::*;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod recurrence_backend;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod recurrence_lane;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use recurrence_lane::*;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod recurrence_load;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use recurrence_load::*;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+pub(crate) mod recurrence_manifest;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use recurrence_manifest::*;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod recurrence_bootstrap;
+#[cfg(feature = "python-generation-bridge")]
+pub(crate) use recurrence_bootstrap::build_recurrence_bootstrap_image_v1;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+pub(crate) use recurrence_bootstrap::{
+    RecurrenceReadyExecutionV1, decode_recurrence_bootstrap_image_v1,
+};
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod recurrence_bootstrap_physics;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use recurrence_bootstrap_physics::*;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod recurrence_process_pack;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod on_the_fly_lane;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod on_the_fly_load;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod on_the_fly_manifest;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod on_the_fly_public_metadata;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod on_the_fly_selectors;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[allow(dead_code)]
+mod eager_manifest;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use eager_manifest::*;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod eager_v3_common;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod eager_v3_decode;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod eager_v3_load;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod eager_v3_manifest;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[allow(dead_code)]
+mod eager_load;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use eager_load::*;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod eager_lane;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use eager_lane::*;
+
+mod physics;
+
+mod point_selectors;
+use point_selectors::*;
+
+#[path = "evaluator.rs"]
+mod evaluator;
+#[cfg(all(
+    test,
+    feature = "f64-compiled",
+    not(feature = "f64-symjit"),
+    any(target_os = "linux", target_os = "macos")
+))]
+pub(crate) use evaluator::native_direct::tests::count_allocations;
+pub(crate) use evaluator::recurrence_closure_direct::execute_closure_reduce_rows;
+pub(crate) use evaluator::recurrence_intrinsic_direct::execute_interaction_terminal_closures;
+#[cfg(all(test, feature = "f64-symjit"))]
+pub(crate) use evaluator::symjit_direct::tests::count_allocations;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+pub(crate) use evaluator::symjit_eager_direct;
+#[cfg(any(test, feature = "python-generation-bridge"))]
+pub(crate) use evaluator::symjit_plane::compile_symbolica_program_to_plane_application_bytes;
+use evaluator::*;
+
+#[path = "wavefunctions.rs"]
+mod wavefunctions;
+use wavefunctions::*;
+
+#[cfg(test)]
+#[path = "engine_tests.rs"]
+mod tests;
+
+#[cfg(test)]
+#[path = "engine/source_metadata_tests.rs"]
+mod source_metadata_tests;
+
+#[cfg(test)]
+#[path = "engine/quantum_number_flow_tests.rs"]
+mod quantum_number_flow_tests;
+
+#[cfg(test)]
+#[path = "engine/contraction_metadata_tests.rs"]
+mod contraction_metadata_tests;
+
+#[cfg(all(test, any(feature = "f64-compiled", feature = "f64-symjit")))]
+#[path = "engine/eager_integration_tests.rs"]
+mod eager_integration_tests;
+
+#[cfg(all(test, any(feature = "f64-compiled", feature = "f64-symjit")))]
+#[path = "engine/recurrence_integration_tests.rs"]
+mod recurrence_integration_tests;
+
+#[cfg(all(test, any(feature = "f64-compiled", feature = "f64-symjit")))]
+#[path = "engine/eager_v3_manifest_tests.rs"]
+mod eager_v3_manifest_tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/artifact_load.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/artifact_load.rs
new file mode 100644
index 0000000000..91d7f36e48
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/artifact_load.rs
@@ -0,0 +1,1126 @@
+// SPDX-License-Identifier: 0BSD
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use super::eager_v3_manifest::{EagerV3ExecutionManifest, parse_eager_v3_execution_manifest};
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use super::on_the_fly_manifest::{
+    ON_THE_FLY_EXECUTION_KIND, OnTheFlyExecutionManifest, parse_on_the_fly_execution_manifest,
+};
+use super::*;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use crate::recurrence::RECURRENCE_RUNTIME_KIND;
+use std::borrow::Cow;
+
+pub(super) enum LoadedExecutionManifest {
+    Compiled(Box<ExecutionManifest>),
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    EagerV3(Box<EagerV3ExecutionManifest>),
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    Recurrence(Box<RecurrenceExecutionManifest>),
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    OnTheFly(Box<OnTheFlyExecutionManifest>),
+}
+
+impl LoadedExecutionManifest {
+    fn key(&self) -> &str {
+        match self {
+            Self::Compiled(value) => &value.key,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::EagerV3(value) => &value.key,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::Recurrence(value) => &value.key,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::OnTheFly(value) => &value.key,
+        }
+    }
+
+    fn process(&self) -> &str {
+        match self {
+            Self::Compiled(value) => &value.process,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::EagerV3(value) => &value.process,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::Recurrence(value) => &value.process,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::OnTheFly(value) => &value.process,
+        }
+    }
+
+    fn color_accuracy(&self) -> &str {
+        match self {
+            Self::Compiled(value) => &value.color_accuracy,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::EagerV3(value) => &value.color_accuracy,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::Recurrence(value) => &value.color_accuracy,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::OnTheFly(value) => &value.color_accuracy,
+        }
+    }
+
+    fn external_pdg_order(&self) -> &[i32] {
+        match self {
+            Self::Compiled(value) => &value.external_pdg_order,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::EagerV3(value) => &value.external_pdg_order,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::Recurrence(value) => &value.external_pdg_order,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::OnTheFly(value) => &value.external_pdg_order,
+        }
+    }
+
+    fn required_runtime_capabilities(&self) -> &[String] {
+        match self {
+            Self::Compiled(value) => &value.required_runtime_capabilities,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::EagerV3(value) => &value.required_runtime_capabilities,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::Recurrence(value) => &value.required_runtime_capabilities,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::OnTheFly(value) => &value.required_runtime_capabilities,
+        }
+    }
+
+    fn validate_portable_execution(&self) -> RusticolResult<()> {
+        match self {
+            Self::Compiled(value) => validate_compiled_portable_jit(value).map(|_| ()),
+            // Eager and recurrence loaders authenticate their prepared backend,
+            // portable flag, target marker, and exact O2 level while loading
+            // the kernel pack. Their compact execution headers intentionally do
+            // not duplicate that backend identity.
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            Self::EagerV3(_) | Self::Recurrence(_) | Self::OnTheFly(_) => Ok(()),
+        }
+    }
+}
+
+pub(super) fn load_verified_evaluator(
+    artifact: &VerifiedArtifact,
+    selection: &crate::ArtifactSelection,
+) -> RusticolResult<(LoadedExecutionManifest, PathBuf)> {
+    let root_manifest_path = &artifact.manifest().runtime.evaluator_manifest_path;
+    if artifact.payload(root_manifest_path)?.role != PayloadRole::EvaluatorManifest {
+        return Err(RusticolError::security(format!(
+            "runtime evaluator path {root_manifest_path:?} is not an evaluator-manifest payload"
+        )));
+    }
+    let bytes = artifact.read_payload(root_manifest_path)?;
+    let header: ExecutionManifestHeader = serde_json::from_slice(&bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse evaluator manifest {root_manifest_path:?}: {error}"
+        ))
+    })?;
+    if matches!(header.schema_version, 1 | 2) {
+        return Err(RusticolError::compatibility(format!(
+            "internal evaluator schema v{} is unsupported and unsafe to migrate; regenerate the artifact with `pyamplicol generate`",
+            header.schema_version
+        )));
+    }
+    if header.schema_version != PROCESS_ARTIFACT_SCHEMA_VERSION {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported internal evaluator schema {}; this runtime requires schema v{}",
+            header.schema_version, PROCESS_ARTIFACT_SCHEMA_VERSION
+        )));
+    }
+    if header.kind == "pyamplicol-runtime-execution"
+        || header.kind == "pyamplicol-runtime-eager-execution"
+        || header.kind == RECURRENCE_RUNTIME_KIND
+        || header.kind == ON_THE_FLY_EXECUTION_KIND
+    {
+        if artifact.manifest().processes.len() != 1 {
+            return Err(RusticolError::integrity(
+                "a direct execution manifest cannot represent multiple outer processes",
+            ));
+        }
+        let outer = &artifact.manifest().processes[0];
+        let manifest = parse_execution_payload_variant(&bytes, root_manifest_path, outer)?;
+        if manifest.key() != outer.id
+            || manifest.process() != outer.expression
+            || manifest.color_accuracy() != outer.color_accuracy
+            || manifest.external_pdg_order() != outer.external_pdgs
+        {
+            return Err(RusticolError::integrity(format!(
+                "execution manifest {root_manifest_path:?} does not match outer process {:?}",
+                outer.id
+            )));
+        }
+        validate_capability_list_match(
+            &artifact.manifest().runtime.required_runtime_capabilities,
+            manifest.required_runtime_capabilities(),
+            "outer runtime and direct execution manifest",
+        )?;
+        validate_capability_list_match(
+            &outer.required_runtime_capabilities,
+            manifest.required_runtime_capabilities(),
+            "outer process and direct execution manifest",
+        )?;
+        validate_portable_execution_contract(artifact, &manifest)?;
+        let path = artifact.payload_path(root_manifest_path)?;
+        let root = path.parent().ok_or_else(|| {
+            RusticolError::artifact("evaluator manifest has no containing directory")
+        })?;
+        validate_loaded_execution_references(artifact, root, &manifest)?;
+        return Ok((manifest, root.to_path_buf()));
+    }
+    if header.kind != "pyamplicol-runtime-execution-set" {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported internal evaluator manifest kind {:?}",
+            header.kind
+        )));
+    }
+    let process_set: ExecutionSetManifest = serde_json::from_slice(&bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse evaluator process-set manifest {root_manifest_path:?}: {error}"
+        ))
+    })?;
+    if process_set.schema_version != PROCESS_ARTIFACT_SCHEMA_VERSION
+        || process_set.kind != "pyamplicol-runtime-execution-set"
+        || process_set.processes.is_empty()
+    {
+        return Err(RusticolError::compatibility(
+            "invalid schema-v3 execution-set manifest; regenerate the artifact",
+        ));
+    }
+    let mut process_ids = BTreeSet::new();
+    let mut manifest_paths = BTreeSet::new();
+    let mut entry_capabilities = BTreeSet::new();
+    for entry in &process_set.processes {
+        if !process_ids.insert(entry.process_id.as_str()) {
+            return Err(RusticolError::integrity(format!(
+                "execution-set manifest contains duplicate process id {:?}",
+                entry.process_id
+            )));
+        }
+        let path = execution_manifest_path(root_manifest_path, &entry.manifest_path)?;
+        if !manifest_paths.insert(path.to_ascii_lowercase()) {
+            return Err(RusticolError::integrity(format!(
+                "execution-set manifest reuses manifest path {path:?}"
+            )));
+        }
+        if artifact.payload(&path)?.role != PayloadRole::EvaluatorManifest {
+            return Err(RusticolError::security(format!(
+                "internal evaluator path {path:?} is not an evaluator-manifest payload"
+            )));
+        }
+        let capabilities = entry
+            .required_runtime_capabilities
+            .iter()
+            .cloned()
+            .collect::<BTreeSet<_>>();
+        if capabilities.len() != entry.required_runtime_capabilities.len() {
+            return Err(RusticolError::integrity(format!(
+                "execution-set entry {:?} contains duplicate runtime capabilities",
+                entry.process_id
+            )));
+        }
+        entry_capabilities.extend(capabilities);
+    }
+    validate_capability_set_match(
+        &process_set.required_runtime_capabilities,
+        &entry_capabilities,
+        "execution-set manifest",
+    )?;
+    validate_capability_list_match(
+        &artifact.manifest().runtime.required_runtime_capabilities,
+        &process_set.required_runtime_capabilities,
+        "outer runtime and execution-set manifest",
+    )?;
+    let outer_process_ids = artifact
+        .manifest()
+        .processes
+        .iter()
+        .map(|process| process.id.as_str())
+        .collect::<BTreeSet<_>>();
+    if process_ids != outer_process_ids {
+        return Err(RusticolError::integrity(
+            "execution-set process ids do not exactly match the outer schema-v3 manifest",
+        ));
+    }
+
+    let mut selected = None;
+    for entry in &process_set.processes {
+        let manifest_path = execution_manifest_path(root_manifest_path, &entry.manifest_path)?;
+        let bytes = artifact.read_payload(&manifest_path)?;
+        let outer = artifact
+            .manifest()
+            .processes
+            .iter()
+            .find(|process| process.id == entry.process_id)
+            .expect("execution-set ids were matched to outer processes");
+        let manifest = parse_execution_payload_variant(&bytes, &manifest_path, outer)?;
+        validate_capability_list_match(
+            &outer.required_runtime_capabilities,
+            &entry.required_runtime_capabilities,
+            &format!(
+                "outer process {:?} and execution-set entry",
+                entry.process_id
+            ),
+        )?;
+        if manifest.key() != outer.id
+            || manifest.process() != outer.expression
+            || manifest.color_accuracy() != outer.color_accuracy
+            || manifest.external_pdg_order() != outer.external_pdgs
+        {
+            return Err(RusticolError::integrity(format!(
+                "execution manifest {manifest_path:?} does not match outer process {:?}",
+                outer.id
+            )));
+        }
+        validate_capability_list_match(
+            &entry.required_runtime_capabilities,
+            manifest.required_runtime_capabilities(),
+            &format!("execution-set entry {:?}", entry.process_id),
+        )?;
+        validate_portable_execution_contract(artifact, &manifest)?;
+        let path = artifact.payload_path(&manifest_path)?;
+        let evaluator_root = path.parent().ok_or_else(|| {
+            RusticolError::artifact("evaluator manifest has no containing directory")
+        })?;
+        validate_loaded_execution_references(artifact, evaluator_root, &manifest)?;
+        if entry.process_id == selection.process.id {
+            selected = Some((manifest, evaluator_root.to_path_buf()));
+        }
+    }
+    selected.ok_or_else(|| {
+        RusticolError::integrity(format!(
+            "execution set does not contain selected outer process {:?}",
+            selection.process.id
+        ))
+    })
+}
+
+fn validate_portable_execution_contract(
+    artifact: &VerifiedArtifact,
+    manifest: &LoadedExecutionManifest,
+) -> RusticolResult<()> {
+    if artifact.manifest().producer.target.triple == crate::artifact::PORTABLE_64LE_ARTIFACT_TARGET
+    {
+        manifest.validate_portable_execution()?;
+    }
+    Ok(())
+}
+
+fn validate_compiled_portable_jit(manifest: &ExecutionManifest) -> RusticolResult<usize> {
+    let mut leaf_count = 0usize;
+    if let Some(model_parameters) = &manifest.compiled.model_parameter_evaluator {
+        leaf_count = leaf_count
+            .checked_add(model_parameters.evaluator.validate_portable_jit()?)
+            .ok_or_else(|| RusticolError::integrity("portable evaluator leaf count overflows"))?;
+    }
+    if let Some(stages) = &manifest.compiled.stage_evaluators {
+        for stage in stages
+            .stages
+            .iter()
+            .chain(std::iter::once(&stages.amplitude_stage))
+        {
+            leaf_count = leaf_count
+                .checked_add(stage.evaluator.validate_portable_jit()?)
+                .ok_or_else(|| {
+                    RusticolError::integrity("portable evaluator leaf count overflows")
+                })?;
+            if stage.compiled_plane_arena.as_ref().is_some_and(|arena| {
+                arena
+                    .leaves
+                    .iter()
+                    .any(|leaf| !matches!(leaf.optimization_level, 1 | 2))
+            }) {
+                return Err(nonportable_compiled_evaluator_error());
+            }
+        }
+    }
+    for nested in manifest
+        .helicity_sum_execution
+        .iter()
+        .map(Box::as_ref)
+        .chain(
+            manifest
+                .helicity_selector_executions
+                .iter()
+                .map(|record| record.execution.as_ref()),
+        )
+        .chain(
+            manifest
+                .color_selector_executions
+                .iter()
+                .map(|record| record.execution.as_ref()),
+        )
+    {
+        leaf_count = leaf_count
+            .checked_add(validate_compiled_portable_jit(nested)?)
+            .ok_or_else(|| RusticolError::integrity("portable evaluator leaf count overflows"))?;
+    }
+    if leaf_count == 0 && manifest.compiled.runtime_available {
+        return Err(nonportable_compiled_evaluator_error());
+    }
+    Ok(leaf_count)
+}
+
+impl EvaluatorManifest {
+    fn validate_portable_jit(&self) -> RusticolResult<usize> {
+        match self {
+            Self::SymjitApplication {
+                optimization_level,
+                plane_application,
+                ..
+            } if matches!(*optimization_level, 1 | 2)
+                && plane_application
+                    .as_ref()
+                    .is_none_or(|application| matches!(application.optimization_level, 1 | 2)) =>
+            {
+                Ok(1)
+            }
+            Self::Chunked { chunks, .. } => chunks.iter().try_fold(0usize, |count, chunk| {
+                count
+                    .checked_add(chunk.validate_portable_jit()?)
+                    .ok_or_else(|| {
+                        RusticolError::integrity("portable evaluator leaf count overflows")
+                    })
+            }),
+            _ => Err(nonportable_compiled_evaluator_error()),
+        }
+    }
+}
+
+fn nonportable_compiled_evaluator_error() -> RusticolError {
+    RusticolError::compatibility(
+        "portable-64le compiled artifacts require only canonical O1/O2 SymJIT evaluators; O0, O3, C++, ASM, and legacy JIT evaluators remain target-specific",
+    )
+}
+
+pub(super) fn validate_capability_list_match(
+    left: &[String],
+    right: &[String],
+    context: &str,
+) -> RusticolResult<()> {
+    // Artifact and execution validators require canonical sorted capability
+    // lists.  Preserve the order-insensitive fallback for other callers while
+    // keeping the ordinary authenticated load path allocation-free.
+    if left == right
+        && left.windows(2).all(|pair| pair[0] < pair[1])
+        && right.windows(2).all(|pair| pair[0] < pair[1])
+    {
+        return Ok(());
+    }
+    let right_set = right.iter().cloned().collect::<BTreeSet<_>>();
+    if right_set.len() != right.len() {
+        return Err(RusticolError::integrity(format!(
+            "{context} contains duplicate runtime capabilities"
+        )));
+    }
+    validate_capability_set_match(left, &right_set, context)
+}
+
+fn validate_capability_set_match(
+    declared: &[String],
+    actual: &BTreeSet<String>,
+    context: &str,
+) -> RusticolResult<()> {
+    let declared_set = declared.iter().cloned().collect::<BTreeSet<_>>();
+    if declared_set.len() != declared.len() || &declared_set != actual {
+        return Err(RusticolError::integrity(format!(
+            "{context} runtime capabilities {declared:?} do not match {actual:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn parse_execution_payload(bytes: &[u8], path: &str) -> RusticolResult<ExecutionManifest> {
+    let header: ExecutionManifestHeader = serde_json::from_slice(bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse evaluator manifest {path:?}: {error}"
+        ))
+    })?;
+    if matches!(header.schema_version, 1 | 2) {
+        return Err(RusticolError::compatibility(format!(
+            "internal evaluator schema v{} is unsupported and unsafe to migrate; regenerate the artifact with `pyamplicol generate`",
+            header.schema_version
+        )));
+    }
+    if header.schema_version != PROCESS_ARTIFACT_SCHEMA_VERSION {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported internal evaluator schema {}; this runtime requires schema v{}",
+            header.schema_version, PROCESS_ARTIFACT_SCHEMA_VERSION
+        )));
+    }
+    if header.kind != "pyamplicol-runtime-execution" {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported internal evaluator manifest kind {:?}",
+            header.kind
+        )));
+    }
+    serde_json::from_slice(bytes).map_err(|error| execution_manifest_parse_error(path, error))
+}
+
+fn parse_execution_payload_variant(
+    bytes: &[u8],
+    path: &str,
+    outer: &crate::ArtifactProcess,
+) -> RusticolResult<LoadedExecutionManifest> {
+    let header: ExecutionManifestHeader = serde_json::from_slice(bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse evaluator manifest {path:?}: {error}"
+        ))
+    })?;
+    match header.kind.as_str() {
+        "pyamplicol-runtime-execution" => parse_execution_payload(bytes, path)
+            .map(Box::new)
+            .map(LoadedExecutionManifest::Compiled),
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        EAGER_EXECUTION_KIND => parse_eager_v3_execution_manifest(bytes, outer)
+            .map(Box::new)
+            .map(LoadedExecutionManifest::EagerV3),
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        RECURRENCE_RUNTIME_KIND => parse_recurrence_execution_manifest(bytes, path, outer)
+            .map(Box::new)
+            .map(LoadedExecutionManifest::Recurrence),
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        ON_THE_FLY_EXECUTION_KIND => parse_on_the_fly_execution_manifest(bytes, outer)
+            .map(Box::new)
+            .map(LoadedExecutionManifest::OnTheFly),
+        _ => Err(RusticolError::compatibility(format!(
+            "unsupported internal evaluator manifest kind {:?}",
+            header.kind
+        ))),
+    }
+}
+
+fn validate_loaded_execution_references(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &LoadedExecutionManifest,
+) -> RusticolResult<()> {
+    match manifest {
+        LoadedExecutionManifest::Compiled(manifest) => {
+            validate_evaluator_payload_references(artifact, evaluator_root, manifest)
+        }
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        LoadedExecutionManifest::EagerV3(manifest) => {
+            let relative_root = evaluator_root.strip_prefix(artifact.root()).map_err(|_| {
+                RusticolError::security("eager plan-v3 root escapes the verified artifact")
+            })?;
+            let relative = relative_root.join(&manifest.plan.runtime_container.path);
+            let relative = relative.to_str().ok_or_else(|| {
+                RusticolError::security("eager plan-v3 container path is not valid UTF-8")
+            })?;
+            if artifact.payload(relative)?.role != PayloadRole::EvaluatorState {
+                return Err(RusticolError::security(
+                    "eager plan-v3 runtime container is not an evaluator-state payload",
+                ));
+            }
+            Ok(())
+        }
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        LoadedExecutionManifest::Recurrence(manifest) => {
+            let schedule = artifact.payload(&manifest.plan.runtime_schedule.path)?;
+            if schedule.role != PayloadRole::EvaluatorState || schedule.process_id.is_some() {
+                return Err(RusticolError::security(
+                    "recurrence root schedule is not an unbound evaluator-state payload",
+                ));
+            }
+            let relative_root = evaluator_root.strip_prefix(artifact.root()).map_err(|_| {
+                RusticolError::security("recurrence process root escapes the verified artifact")
+            })?;
+            let binding = relative_root.join(&manifest.plan.process_binding.path);
+            let binding = binding.to_str().ok_or_else(|| {
+                RusticolError::security("recurrence process-binding path is not valid UTF-8")
+            })?;
+            let binding = artifact.payload(binding)?;
+            if binding.role != PayloadRole::EvaluatorState
+                || binding.process_id.as_deref() != Some(manifest.key.as_str())
+            {
+                return Err(RusticolError::security(
+                    "recurrence process binding is not owned by its process",
+                ));
+            }
+            Ok(())
+        }
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        LoadedExecutionManifest::OnTheFly(manifest) => {
+            let relative_root = evaluator_root.strip_prefix(artifact.root()).map_err(|_| {
+                RusticolError::security("on-the-fly process root escapes the verified artifact")
+            })?;
+            let relative = relative_root.join(&manifest.runtime_container.path);
+            let relative = relative.to_str().ok_or_else(|| {
+                RusticolError::security("on-the-fly container path is not valid UTF-8")
+            })?;
+            let payload = artifact.payload(relative)?;
+            if payload.role != PayloadRole::EvaluatorState
+                || payload.process_id.as_deref() != Some(manifest.key.as_str())
+            {
+                return Err(RusticolError::security(
+                    "on-the-fly runtime container is not owned evaluator state",
+                ));
+            }
+            Ok(())
+        }
+    }
+}
+
+pub(super) fn execution_manifest_parse_error(
+    path: &str,
+    error: serde_json::Error,
+) -> RusticolError {
+    let detail = error.to_string();
+    if ["source_ir", "applied_crossing", "source_basis"]
+        .iter()
+        .any(|field| detail.contains(&format!("missing field `{field}`")))
+    {
+        return RusticolError::compatibility(format!(
+            "schema-v3 evaluator manifest {path:?} predates typed source metadata; regenerate the artifact with `pyamplicol generate`"
+        ));
+    }
+    if detail.contains("missing field `contraction_ir`") {
+        return RusticolError::compatibility(format!(
+            "schema-v3 evaluator manifest {path:?} predates typed amplitude-contraction metadata; regenerate the artifact with `pyamplicol generate`"
+        ));
+    }
+    RusticolError::serialization(format!(
+        "could not parse schema-v3 evaluator manifest {path:?}: {detail}"
+    ))
+}
+
+pub(super) fn execution_manifest_path(
+    parent_manifest: &str,
+    entry_path: &str,
+) -> RusticolResult<String> {
+    let base = Path::new(parent_manifest)
+        .parent()
+        .unwrap_or_else(|| Path::new(""));
+    let entry = confined_internal_path(entry_path, "evaluator process path")?;
+    let path = base.join(entry);
+    path.to_str()
+        .map(str::to_string)
+        .ok_or_else(|| RusticolError::security("evaluator process path is not valid UTF-8"))
+}
+
+pub(super) fn validate_evaluator_payload_references(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &ExecutionManifest,
+) -> RusticolResult<()> {
+    let relative_root = evaluator_root.strip_prefix(artifact.root()).map_err(|_| {
+        RusticolError::security("evaluator root escapes the verified artifact root")
+    })?;
+    if let Some(parameters) = &manifest.compiled.model_parameter_evaluator {
+        validate_evaluator_reference(artifact, relative_root, &parameters.evaluator)?;
+    }
+    if let Some(stages) = &manifest.compiled.stage_evaluators {
+        for stage in &stages.stages {
+            validate_evaluator_reference(artifact, relative_root, &stage.evaluator)?;
+        }
+        validate_evaluator_reference(artifact, relative_root, &stages.amplitude_stage.evaluator)?;
+    }
+    if let Some(sum_manifest) = manifest.helicity_sum_execution.as_deref() {
+        validate_evaluator_payload_references(artifact, evaluator_root, sum_manifest)?;
+    }
+    for record in &manifest.helicity_selector_executions {
+        validate_evaluator_payload_references(artifact, evaluator_root, record.execution.as_ref())?;
+    }
+    for record in &manifest.color_selector_executions {
+        validate_evaluator_payload_references(artifact, evaluator_root, record.execution.as_ref())?;
+    }
+    Ok(())
+}
+
+pub(super) fn validate_evaluator_reference(
+    artifact: &VerifiedArtifact,
+    relative_root: &Path,
+    evaluator: &EvaluatorManifest,
+) -> RusticolResult<()> {
+    match evaluator {
+        EvaluatorManifest::SymjitApplication {
+            application_path,
+            plane_application,
+            evaluator_state_path,
+            ..
+        } => {
+            validate_evaluator_state_path(artifact, relative_root, application_path)?;
+            if let Some(plane) = plane_application {
+                validate_evaluator_state_path(artifact, relative_root, &plane.application_path)?;
+            }
+            if let Some(path) = evaluator_state_path {
+                validate_evaluator_state_path(artifact, relative_root, path)?;
+            }
+            Ok(())
+        }
+        EvaluatorManifest::Jit {
+            evaluator_state_path,
+            ..
+        } => validate_evaluator_state_path(artifact, relative_root, evaluator_state_path),
+        EvaluatorManifest::CompiledComplex {
+            function_name,
+            input_len,
+            output_len,
+            library_path,
+            evaluator_state_path,
+            native_direct_application,
+            ..
+        } => {
+            validate_evaluator_state_path(artifact, relative_root, library_path)?;
+            if let Some(path) = evaluator_state_path {
+                validate_evaluator_state_path(artifact, relative_root, path)?;
+            }
+            if let Some(application) = native_direct_application {
+                application.validate(function_name, *input_len, *output_len)?;
+                validate_evaluator_state_path(artifact, relative_root, &application.source_path)?;
+                validate_evaluator_state_path(artifact, relative_root, &application.library_path)?;
+            }
+            Ok(())
+        }
+        EvaluatorManifest::Chunked { chunks, .. } => {
+            for chunk in chunks {
+                validate_evaluator_reference(artifact, relative_root, chunk)?;
+            }
+            Ok(())
+        }
+    }
+}
+
+pub(super) fn validate_evaluator_state_path(
+    artifact: &VerifiedArtifact,
+    relative_root: &Path,
+    value: &str,
+) -> RusticolResult<()> {
+    let path = relative_root.join(confined_internal_path(value, "evaluator-state path")?);
+    let path = path
+        .to_str()
+        .ok_or_else(|| RusticolError::security("evaluator-state path is not valid UTF-8"))?;
+    if artifact.has_evaluator_payload(path)? {
+        Ok(())
+    } else {
+        Err(RusticolError::security(format!(
+            "evaluator reference {path:?} is not a declared loose or packed evaluator payload"
+        )))
+    }
+}
+
+pub(super) fn confined_internal_path<'a>(
+    value: &'a str,
+    description: &str,
+) -> RusticolResult<&'a Path> {
+    let path = Path::new(value);
+    if value.is_empty()
+        || value.contains('\\')
+        || path.is_absolute()
+        || path
+            .components()
+            .any(|component| !matches!(component, std::path::Component::Normal(_)))
+    {
+        return Err(RusticolError::security(format!(
+            "{description} {value:?} is not a confined relative path"
+        )));
+    }
+    Ok(path)
+}
+
+pub(super) fn parse_reduction_group_id(value: &str) -> RusticolResult<i64> {
+    value
+        .parse::<i64>()
+        .or_else(|_| value.rsplit(':').next().unwrap_or(value).parse::<i64>())
+        .map_err(|_| {
+            RusticolError::artifact(format!(
+                "reduction group id {value:?} does not contain the evaluator's numeric group id"
+            ))
+        })
+}
+
+pub(super) fn apply_process_permutation_metadata(
+    mut physics: ProcessPhysicsV1,
+    selection: &crate::ArtifactSelection,
+) -> RusticolResult<ProcessPhysicsV1> {
+    physics.validate()?;
+    let permutation = &selection.external_permutation;
+    let particle_count = physics.external_particles.len();
+    if permutation.len() != particle_count
+        || selection.external_pdgs.len() != particle_count
+        || permutation.iter().copied().collect::<BTreeSet<_>>()
+            != (0..particle_count).collect::<BTreeSet<_>>()
+    {
+        return Err(RusticolError::integrity(format!(
+            "process selection {:?} does not define a complete particle permutation and PDG order",
+            selection.public_expression
+        )));
+    }
+    if permutation
+        .iter()
+        .copied()
+        .enumerate()
+        .any(|(representative_index, public_index)| {
+            physics.external_particles[representative_index].role
+                != physics.external_particles[public_index].role
+        })
+    {
+        return Err(RusticolError::compatibility(format!(
+            "process selection {:?} moves a particle across the incoming/outgoing boundary",
+            selection.public_expression
+        )));
+    }
+    let mut expected_alias_pdgs = vec![0; particle_count];
+    for (representative_index, alias_index) in permutation.iter().copied().enumerate() {
+        expected_alias_pdgs[alias_index] = physics.external_particles[representative_index].pdg;
+    }
+    // A process-group member keeps the representative flavours here; they
+    // are relabelled by `apply_process_group_metadata`.
+    if selection.process_group.is_none() && selection.external_pdgs != expected_alias_pdgs {
+        return Err(RusticolError::integrity(format!(
+            "process selection {:?} PDG order {:?} does not match the representative physics payload and permutation; expected {:?}",
+            selection.public_expression, selection.external_pdgs, expected_alias_pdgs
+        )));
+    }
+
+    let mut particles = vec![None; particle_count];
+    for (representative_index, alias_index) in permutation.iter().copied().enumerate() {
+        let mut particle = physics.external_particles[representative_index].clone();
+        particle.index = alias_index;
+        particle.label = alias_index + 1;
+        particle.momentum_slot = alias_index;
+        particles[alias_index] = Some(particle);
+    }
+    physics.external_particles = particles
+        .into_iter()
+        .map(|particle| particle.expect("validated permutation is complete"))
+        .collect();
+
+    let mut helicity_id_map = BTreeMap::new();
+    let mut helicity_updates = Vec::with_capacity(physics.helicities.len());
+    for helicity in &physics.helicities {
+        let mut alias_values = vec![0; particle_count];
+        for (representative_index, alias_index) in permutation.iter().copied().enumerate() {
+            alias_values[alias_index] = helicity.values[representative_index];
+        }
+        let alias_id = canonical_helicity_id(&alias_values);
+        helicity_id_map.insert(helicity.id.clone(), alias_id.clone());
+        helicity_updates.push((alias_values, alias_id));
+    }
+    for (helicity, (values, id)) in physics.helicities.iter_mut().zip(helicity_updates) {
+        let representative_id = remapped_alias_id(
+            &helicity_id_map,
+            &helicity.representative_id,
+            "helicity representative",
+        )?;
+        helicity.values = values;
+        helicity.id = id;
+        helicity.representative_id = representative_id;
+    }
+
+    let mut color_id_map = BTreeMap::new();
+    let mut color_updates = Vec::with_capacity(physics.color_components.len());
+    for color in &physics.color_components {
+        match color {
+            PhysicsColorComponentV1::LcFlow(flow) => {
+                let alias_word = flow
+                    .word
+                    .iter()
+                    .map(|label| {
+                        let representative_index = label.checked_sub(1).ok_or_else(|| {
+                            RusticolError::artifact("LC color-flow labels must be one-based")
+                        })?;
+                        let alias_index =
+                            permutation.get(representative_index).ok_or_else(|| {
+                                RusticolError::artifact(
+                                    "LC color-flow label exceeds alias permutation",
+                                )
+                            })?;
+                        Ok(alias_index + 1)
+                    })
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                let alias_id = canonical_color_id(&alias_word);
+                color_id_map.insert(flow.id.clone(), alias_id.clone());
+                color_updates.push((Some(alias_word), alias_id));
+            }
+            PhysicsColorComponentV1::ContractedColor(color) => {
+                color_id_map.insert(color.id.clone(), color.id.clone());
+                color_updates.push((None, color.id.clone()));
+            }
+        }
+    }
+    for (color, (word, id)) in physics.color_components.iter_mut().zip(color_updates) {
+        match color {
+            PhysicsColorComponentV1::LcFlow(flow) => {
+                let representative_id = remapped_alias_id(
+                    &color_id_map,
+                    &flow.representative_id,
+                    "color representative",
+                )?;
+                flow.word = word.expect("LC color update includes a word");
+                flow.id = id;
+                flow.representative_id = representative_id;
+            }
+            PhysicsColorComponentV1::ContractedColor(color) => {
+                if word.is_some() {
+                    return Err(RusticolError::integrity(
+                        "contracted color alias update unexpectedly contains an LC word",
+                    ));
+                }
+                color.id = id;
+            }
+        }
+    }
+
+    for group in &mut physics.reduction.groups {
+        let representative_helicity_id = group.representative_helicity_id.clone();
+        let representative_color_id = group.representative_color_id.clone();
+        group.representative_helicity_id = remapped_alias_id(
+            &helicity_id_map,
+            &representative_helicity_id,
+            "reduction representative helicity",
+        )?;
+        group.representative_color_id = remapped_alias_id(
+            &color_id_map,
+            &representative_color_id,
+            "reduction representative color",
+        )?;
+        for id in &mut group.physical_helicity_ids {
+            *id = remapped_alias_id(&helicity_id_map, id, "reduction physical helicity")?;
+        }
+        for id in &mut group.physical_color_ids {
+            *id = remapped_alias_id(&color_id_map, id, "reduction physical color")?;
+        }
+    }
+
+    physics.process_id = selection.requested_id.clone();
+    physics.process = selection.public_expression.clone();
+    if physics
+        .external_particles
+        .iter()
+        .map(|particle| particle.pdg)
+        .ne(expected_alias_pdgs.iter().copied())
+    {
+        return Err(RusticolError::integrity(format!(
+            "process selection {:?} external particle metadata does not match its public PDG order",
+            selection.public_expression
+        )));
+    }
+    physics.validate()?;
+    Ok(physics)
+}
+
+/// Relabel public metadata of a selected process-group member.
+///
+/// `physics` is the representative metadata already remapped to the public
+/// order by [`apply_process_permutation_metadata`]; the execution lanes keep
+/// using it. The returned copy carries the member's flavours and, for a
+/// charge-conjugated relation, reversed LC words whose IDs map to the
+/// execution IDs through [`charge_conjugate_color_id`].
+pub(super) fn apply_process_group_metadata(
+    physics: &ProcessPhysicsV1,
+    selection: &crate::ArtifactSelection,
+) -> RusticolResult<ProcessPhysicsV1> {
+    let mut physics = physics.clone();
+    let Some(group) = &selection.process_group else {
+        return Ok(physics);
+    };
+    if group.external_particles.len() != physics.external_particles.len()
+        || selection.external_pdgs.len() != physics.external_particles.len()
+    {
+        return Err(RusticolError::integrity(format!(
+            "process-group member {:?} does not have one flavour per external particle",
+            selection.requested_id
+        )));
+    }
+    for ((particle, name), pdg) in physics
+        .external_particles
+        .iter_mut()
+        .zip(&group.external_particles)
+        .zip(&selection.external_pdgs)
+    {
+        particle.particle.clone_from(name);
+        particle.pdg = *pdg;
+    }
+    if group.conjugated {
+        let conjugate = |id: &mut String| *id = charge_conjugate_color_id(id).into_owned();
+        for color in &mut physics.color_components {
+            if let PhysicsColorComponentV1::LcFlow(flow) = color {
+                flow.word.reverse();
+                conjugate(&mut flow.id);
+                conjugate(&mut flow.representative_id);
+            }
+        }
+        for reduction in &mut physics.reduction.groups {
+            conjugate(&mut reduction.representative_color_id);
+            reduction.physical_color_ids.iter_mut().for_each(conjugate);
+        }
+    }
+    physics.validate()?;
+    Ok(physics)
+}
+
+/// Map an LC color-flow ID through global charge conjugation, which reverses
+/// the flow word. The map is an involution; other IDs are unchanged.
+pub(super) fn charge_conjugate_color_id(id: &str) -> Cow<'_, str> {
+    match id.strip_prefix("flow:") {
+        Some(word) if word != "singlet" && word.contains(',') => Cow::Owned(format!(
+            "flow:{}",
+            word.rsplit(',').collect::<Vec<_>>().join(",")
+        )),
+        _ => Cow::Borrowed(id),
+    }
+}
+
+fn canonical_helicity_id(values: &[i32]) -> String {
+    format!(
+        "h:{}",
+        values
+            .iter()
+            .map(|value| format!("{value:+}"))
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}
+
+fn canonical_color_id(word: &[usize]) -> String {
+    if word.is_empty() {
+        return "flow:singlet".to_string();
+    }
+    format!(
+        "flow:{}",
+        word.iter()
+            .map(usize::to_string)
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}
+
+fn remapped_alias_id(
+    ids: &BTreeMap<String, String>,
+    representative_id: &str,
+    description: &str,
+) -> RusticolResult<String> {
+    ids.get(representative_id).cloned().ok_or_else(|| {
+        RusticolError::integrity(format!(
+            "{description} {representative_id:?} is absent from alias remapping"
+        ))
+    })
+}
+
+pub(super) fn selector_set(
+    ids: Option<&[String]>,
+    kind: &str,
+) -> Result<Option<BTreeSet<String>>, RusticolError> {
+    let Some(ids) = ids else {
+        return Ok(None);
+    };
+    if ids.is_empty() {
+        return Err(RusticolError::selector(format!(
+            "resolved {kind} selection must not be empty"
+        )));
+    }
+    let selected = ids.iter().cloned().collect::<BTreeSet<_>>();
+    if selected.len() != ids.len() {
+        return Err(RusticolError::selector(format!(
+            "resolved {kind} selection contains duplicate ids"
+        )));
+    }
+    Ok(Some(selected))
+}
+
+#[cfg(test)]
+mod portable_execution_tests {
+    use super::*;
+
+    fn portable_fixture_value() -> Value {
+        serde_json::from_slice(include_bytes!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/../../../src/pyamplicol/assets/selftest/portable-64le/artifact/processes/",
+            "d_dbar_to_z/execution.json"
+        )))
+        .expect("parse portable compiled execution fixture")
+    }
+
+    fn portable_fixture() -> ExecutionManifest {
+        serde_json::from_value(portable_fixture_value())
+            .expect("decode portable compiled execution fixture")
+    }
+
+    fn replace_symjit_optimization_level(value: &mut Value, level: u8) {
+        match value {
+            Value::Array(values) => {
+                for value in values {
+                    replace_symjit_optimization_level(value, level);
+                }
+            }
+            Value::Object(object) => {
+                if object.get("kind").and_then(Value::as_str)
+                    == Some("symjit-application-evaluator")
+                {
+                    object.insert("optimization_level".to_string(), level.into());
+                    if let Some(plane) = object
+                        .get_mut("plane_application")
+                        .and_then(Value::as_object_mut)
+                    {
+                        plane.insert("optimization_level".to_string(), level.into());
+                    }
+                }
+                if let Some(leaves) = object.get_mut("leaves").and_then(Value::as_array_mut) {
+                    for leaf in leaves {
+                        if let Some(leaf) = leaf.as_object_mut()
+                            && leaf.contains_key("optimization_level")
+                        {
+                            leaf.insert("optimization_level".to_string(), level.into());
+                        }
+                    }
+                }
+                for value in object.values_mut() {
+                    replace_symjit_optimization_level(value, level);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn compiled_portable_contract_accepts_o1_o2_and_rejects_o0_o3() {
+        validate_compiled_portable_jit(&portable_fixture())
+            .expect("canonical O2 fixture is portable");
+
+        let fixture = portable_fixture_value();
+        let mut o1 = fixture.clone();
+        replace_symjit_optimization_level(&mut o1, 1);
+        let o1: ExecutionManifest = serde_json::from_value(o1).expect("parse modified O1 fixture");
+        validate_compiled_portable_jit(&o1).expect("canonical O1 fixture is portable");
+
+        for level in [0, 3] {
+            let mut value = fixture.clone();
+            replace_symjit_optimization_level(&mut value, level);
+            let manifest: ExecutionManifest =
+                serde_json::from_value(value).expect("parse modified fixture");
+            let error = validate_compiled_portable_jit(&manifest).unwrap_err();
+            assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+            assert!(error.to_string().contains("O0, O3, C++, ASM"));
+        }
+    }
+}
+
+#[cfg(all(test, any(feature = "f64-compiled", feature = "f64-symjit")))]
+mod recurrence_dispatch_tests {
+    use super::*;
+
+    #[test]
+    fn generic_execution_dispatch_accepts_the_strict_recurrence_manifest() {
+        let value = super::super::recurrence_manifest::tests::manifest();
+        let outer = super::super::recurrence_manifest::tests::outer();
+        let bytes = serde_json::to_vec(&value).unwrap();
+
+        let parsed =
+            parse_execution_payload_variant(&bytes, "processes/x_to_x/execution.json", &outer)
+                .unwrap();
+
+        let LoadedExecutionManifest::Recurrence(manifest) = parsed else {
+            panic!("recurrence execution kind was dispatched to another manifest parser");
+        };
+        assert_eq!(manifest.key, outer.id);
+        assert_eq!(manifest.process, outer.expression);
+        assert_eq!(
+            manifest.required_runtime_capabilities,
+            outer.required_runtime_capabilities
+        );
+        ensure_runtime_capabilities_supported(
+            manifest
+                .required_runtime_capabilities
+                .iter()
+                .map(String::as_str),
+        )
+        .unwrap();
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/compiled_direct_prototype.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/compiled_direct_prototype.rs
new file mode 100644
index 0000000000..b532dabfbc
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/compiled_direct_prototype.rs
@@ -0,0 +1,5782 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Production compiled Direct-Arena execution.
+//!
+//! This module consumes the existing stage/chunk manifests, lowers each
+//! already-fused SymJIT O3 leaf to DirectApplication v3 at load time, and
+//! executes the unchanged leaf schedule against persistent component-major
+//! planes. Canonical manifest component IDs are cold-bound to a stage-granular
+//! physical layout: values with disjoint whole-stage lifetimes may reuse a
+//! plane while every Arena-v1 stage retains its no-alias contract.
+
+#![allow(dead_code)]
+
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
+
+#[cfg(feature = "f64-symjit")]
+use std::path::PathBuf;
+use std::ptr;
+
+#[cfg(feature = "f64-compiled")]
+use super::evaluator::native_compiled_direct::{
+    BoundNativeCompiledDirectStage, LoadedNativeCompiledDirectStage,
+    NativeCompiledDirectArenaPlane, NativeCompiledDirectOutputBinding,
+    NativeCompiledDirectPlaneBinding, NativeCompiledDirectScalarBinding,
+};
+#[cfg(feature = "f64-symjit")]
+use super::evaluator::symjit_compiled_direct::{
+    BoundSymjitCompiledDirectStage, CompiledDirectArenaPlane, CompiledDirectOutputBinding,
+    CompiledDirectPlaneBinding, CompiledDirectScalarBinding, CompiledDirectSourceInputBinding,
+    LoadedSymjitCompiledDirectStage,
+};
+#[cfg(feature = "f64-symjit")]
+use super::evaluator::{SymjitApplicationMetadata, validate_manifest_metadata};
+use super::sources::{ResolvedSourceWavefunction, RuntimeSourceState};
+use super::*;
+#[cfg(test)]
+use crate::direct_arena::checked_aligned_point_stride;
+use crate::direct_arena::{
+    AlignedF64Buffer, DirectAmplitudePlanes, DirectArenaAllocationCounters,
+    DirectArenaTrafficCounters, DirectArenaWorkspace, DirectMomentumView, DirectParameterView,
+    deterministic_point_tile_size_with_cache_footprint,
+};
+
+// Fused applications repeatedly traverse many split-complex parent/output
+// planes. Keeping a small, fixed power-of-two point tile preserves that
+// cross-stage locality on both cache-rich and cache-poor CPUs without an
+// online host-specific tuner.
+const COMPILED_DIRECT_LOCALITY_POINT_CAP: u32 = 32;
+const COMPILED_DIRECT_CACHE_TARGET_BYTES: usize = 4 * 1024 * 1024;
+
+fn compiled_direct_cache_target_bytes() -> usize {
+    #[cfg(test)]
+    if let Some(value) = std::env::var_os("RUSTICOL_TEST_COMPILED_DIRECT_CACHE_TARGET_BYTES") {
+        let value = value
+            .to_str()
+            .expect("compiled Direct test cache target must be UTF-8");
+        if value == "hard-budget" {
+            return usize::MAX;
+        }
+        return value
+            .parse()
+            .expect("compiled Direct test cache target must be bytes or hard-budget");
+    }
+    COMPILED_DIRECT_CACHE_TARGET_BYTES
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct CompiledDirectPrototypeTraffic {
+    /// Direct source-wavefunction writes into canonical current planes.
+    pub(crate) source_fill_bytes: u64,
+    /// Direct crossed-momentum writes into canonical momentum planes.
+    pub(crate) momentum_fill_bytes: u64,
+    /// Point-independent model-scalar writes.
+    pub(crate) parameter_fill_bytes: u64,
+    /// Internal persistent P-kernel broadcast-plane refresh traffic.
+    pub(crate) scalar_broadcast_fill_bytes: u64,
+    /// Stale-safety clears of amplitude planes not overwritten by a schedule.
+    pub(crate) amplitude_clear_bytes: u64,
+    /// Developer-oracle row-major to arena boundary traffic.
+    pub(crate) boundary_input_bytes: u64,
+    /// Explicit developer-only current extraction traffic.
+    pub(crate) boundary_current_output_bytes: u64,
+    /// Explicit developer-only amplitude extraction traffic.
+    pub(crate) boundary_amplitude_output_bytes: u64,
+    /// Hot compiled-leaf calls. Its forbidden traffic byte fields must remain
+    /// zero even though call/row/point counts advance structurally.
+    pub(crate) leaf: DirectArenaTrafficCounters,
+}
+
+#[derive(Clone, Debug)]
+struct DirectLeafPlan {
+    input_current_components: Box<[usize]>,
+    output_current_components: Box<[usize]>,
+    output_amplitude_components: Box<[usize]>,
+    scalar_values_per_point: usize,
+    persistent_scalar_values_per_point: usize,
+}
+
+/// Call-local memo for correlated spin assignments at identical momenta and
+/// model parameters. It is never read or allocated by ordinary evaluation.
+#[derive(Default)]
+pub(crate) struct CorrelatedStageMemo {
+    leaves: Vec<Option<CorrelatedLeafMemo>>,
+    #[cfg(test)]
+    reused_leaves: usize,
+}
+
+struct CorrelatedLeafMemo {
+    inputs: Vec<u64>,
+    current_outputs: Vec<[f64; 2]>,
+    amplitude_outputs: Vec<[f64; 2]>,
+}
+
+// Leaves are cold-built and kept inline to avoid a separate allocation and
+// indirection for each warmed stage call.
+#[allow(clippy::large_enum_variant)]
+enum LoadedCompiledDirectLeaf {
+    #[cfg(feature = "f64-symjit")]
+    Symjit(LoadedSymjitCompiledDirectStage),
+    #[cfg(feature = "f64-compiled")]
+    Native(LoadedNativeCompiledDirectStage),
+}
+
+#[allow(clippy::large_enum_variant)]
+enum BoundCompiledDirectLeaf {
+    #[cfg(feature = "f64-symjit")]
+    Symjit(BoundSymjitCompiledDirectStage),
+    #[cfg(feature = "f64-compiled")]
+    Native(BoundNativeCompiledDirectStage),
+}
+
+impl LoadedCompiledDirectLeaf {
+    fn persistent_scalar_values_per_point(&self) -> usize {
+        match self {
+            #[cfg(feature = "f64-symjit")]
+            Self::Symjit(leaf) => leaf.broadcast_plane_count(),
+            #[cfg(feature = "f64-compiled")]
+            Self::Native(_) => 0,
+        }
+    }
+
+    unsafe fn bind(
+        self,
+        arena: crate::direct_arena::DirectArenaView,
+        momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+        _zero_plane: &AlignedF64Buffer,
+        current_component_map: &[u32],
+    ) -> RusticolResult<BoundCompiledDirectLeaf> {
+        match self {
+            #[cfg(feature = "f64-symjit")]
+            Self::Symjit(leaf) => {
+                // SAFETY: forwarded from the engine's fixed-allocation bind.
+                unsafe {
+                    leaf.bind_with_current_map(
+                        arena,
+                        momenta,
+                        parameters,
+                        _zero_plane,
+                        current_component_map,
+                    )
+                }
+                .map(BoundCompiledDirectLeaf::Symjit)
+            }
+            #[cfg(feature = "f64-compiled")]
+            Self::Native(leaf) => {
+                // SAFETY: forwarded from the engine's fixed-allocation bind.
+                unsafe {
+                    leaf.bind_with_current_map(arena, momenta, parameters, current_component_map)
+                }
+                .map(BoundCompiledDirectLeaf::Native)
+            }
+        }
+    }
+}
+
+impl BoundCompiledDirectLeaf {
+    fn allocation_counters(&self) -> DirectArenaAllocationCounters {
+        match self {
+            #[cfg(feature = "f64-symjit")]
+            Self::Symjit(leaf) => leaf.allocation_counters(),
+            #[cfg(feature = "f64-compiled")]
+            Self::Native(_) => DirectArenaAllocationCounters::default(),
+        }
+    }
+
+    fn evaluate(&mut self, point_start: u32, point_count: u32) -> RusticolResult<u64> {
+        match self {
+            #[cfg(feature = "f64-symjit")]
+            Self::Symjit(leaf) => leaf.evaluate(point_start, point_count),
+            #[cfg(feature = "f64-compiled")]
+            Self::Native(leaf) => {
+                leaf.evaluate(point_start, point_count)?;
+                Ok(0)
+            }
+        }
+    }
+}
+
+struct LoadedStage {
+    leaves: Vec<LoadedCompiledDirectLeaf>,
+    leaf_plans: Vec<DirectLeafPlan>,
+}
+
+struct BoundStage {
+    leaves: Vec<BoundCompiledDirectLeaf>,
+    leaf_plans: Vec<DirectLeafPlan>,
+}
+
+const UNMAPPED_CURRENT_COMPONENT: u32 = u32::MAX;
+
+#[derive(Clone, Debug)]
+struct CompiledDirectCurrentLayout {
+    canonical_to_physical: Box<[u32]>,
+    physical_component_count: u32,
+    live_component_count: usize,
+}
+
+impl CompiledDirectCurrentLayout {
+    fn identity(canonical_component_count: usize) -> RusticolResult<Self> {
+        let physical_component_count = u32::try_from(canonical_component_count).map_err(|_| {
+            RusticolError::integrity("compiled Direct-Arena current plane count exceeds u32")
+        })?;
+        Ok(Self {
+            canonical_to_physical: (0..physical_component_count)
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            physical_component_count,
+            live_component_count: canonical_component_count,
+        })
+    }
+
+    fn physical_component(&self, canonical_component: usize) -> RusticolResult<u32> {
+        self.canonical_to_physical
+            .get(canonical_component)
+            .copied()
+            .filter(|component| *component != UNMAPPED_CURRENT_COMPONENT)
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "compiled Direct-Arena canonical current component {canonical_component} has \
+                     no physical liveness assignment"
+                ))
+            })
+    }
+
+    fn physical_map(&self) -> &[u32] {
+        &self.canonical_to_physical
+    }
+
+    fn is_identity(&self) -> bool {
+        self.live_component_count == self.canonical_to_physical.len()
+            && self.physical_component_count as usize == self.canonical_to_physical.len()
+            && self
+                .canonical_to_physical
+                .iter()
+                .copied()
+                .enumerate()
+                .all(|(canonical, physical)| physical as usize == canonical)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum CompiledDirectCurrentLayoutPolicy {
+    Identity { tile_capacity: u32 },
+    StageLivenessProduction,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct CompiledDirectTileSizing {
+    pub(crate) effective_tile_capacity: usize,
+    pub(crate) reduction_tile_capacity: usize,
+    pub(crate) physical_scalar_values_per_point: usize,
+    pub(crate) persistent_scalar_values_per_point: usize,
+    pub(crate) hot_scalar_values_per_point: usize,
+    execution_scalar_values_per_point: usize,
+    pub(crate) source_scalar_values_per_point: usize,
+    pub(crate) reduction_scalar_values_per_point: usize,
+}
+
+impl CompiledDirectTileSizing {
+    fn reduction_tile_capacity_for_footprint(
+        self,
+        reduction_footprint: CompiledDirectReductionFootprint,
+    ) -> RusticolResult<usize> {
+        let Some(reduction_scalars) = reduction_footprint.hot_scalar_values_per_point() else {
+            return Ok(self.reduction_tile_capacity);
+        };
+        // A selected routed total only touches its selected source/target
+        // components. The all-selector footprint remains the default for
+        // other reducers. Never exceed the already allocated execution tile:
+        // this changes cache locality, not the arena's allocation bound.
+        let capacity = u32::try_from(self.effective_tile_capacity).map_err(|_| {
+            RusticolError::integrity("compiled Direct-Arena tile capacity exceeds u32")
+        })?;
+        Ok(deterministic_point_tile_size_with_cache_footprint(
+            capacity,
+            usize::MAX,
+            compiled_direct_cache_target_bytes(),
+            self.physical_scalar_values_per_point,
+            self.execution_scalar_values_per_point
+                .max(reduction_scalars),
+        )? as usize)
+    }
+}
+
+trait DirectStagePlan {
+    fn leaf_plans(&self) -> &[DirectLeafPlan];
+}
+
+impl DirectStagePlan for LoadedStage {
+    fn leaf_plans(&self) -> &[DirectLeafPlan] {
+        &self.leaf_plans
+    }
+}
+
+impl DirectStagePlan for BoundStage {
+    fn leaf_plans(&self) -> &[DirectLeafPlan] {
+        &self.leaf_plans
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn compiled_direct_tile_sizing(
+    stages: &[LoadedStage],
+    amplitude: &LoadedStage,
+    current_layout: &CompiledDirectCurrentLayout,
+    source_components: &[usize],
+    momentum_component_count: usize,
+    amplitude_component_count: usize,
+    reduction_footprint: CompiledDirectReductionFootprint,
+    layout_policy: CompiledDirectCurrentLayoutPolicy,
+) -> RusticolResult<CompiledDirectTileSizing> {
+    let persistent_scalar_values_per_point = stages
+        .iter()
+        .flat_map(|stage| stage.leaf_plans.iter())
+        .chain(amplitude.leaf_plans.iter())
+        .try_fold(0usize, |total, leaf| {
+            total
+                .checked_add(leaf.persistent_scalar_values_per_point)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "compiled Direct-Arena persistent scalar footprint overflows",
+                    )
+                })
+        })?;
+    let physical_scalar_values_per_point = usize::try_from(current_layout.physical_component_count)
+        .ok()
+        .and_then(|value| value.checked_mul(2))
+        .and_then(|value| value.checked_add(momentum_component_count))
+        .and_then(|value| {
+            amplitude_component_count
+                .checked_mul(2)
+                .and_then(|amplitudes| value.checked_add(amplitudes))
+        })
+        // The shared zero plane is point-pitched even though every leaf
+        // aliases the same immutable storage.
+        .and_then(|value| value.checked_add(1))
+        .and_then(|value| value.checked_add(persistent_scalar_values_per_point))
+        .ok_or_else(|| {
+            RusticolError::integrity("compiled Direct-Arena physical per-point shape overflows")
+        })?;
+    let source_scalar_values_per_point = source_components
+        .len()
+        .checked_mul(2)
+        .and_then(|value| value.checked_add(momentum_component_count))
+        .and_then(|value| value.checked_add(1))
+        .ok_or_else(|| {
+            RusticolError::integrity("compiled Direct-Arena source working set overflows")
+        })?;
+    let maximum_leaf_scalar_values_per_point = stages
+        .iter()
+        .flat_map(|stage| stage.leaf_plans.iter())
+        .chain(amplitude.leaf_plans.iter())
+        .map(|leaf| leaf.scalar_values_per_point)
+        .max()
+        .ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled Direct-Arena production schedule has no evaluator leaves",
+            )
+        })?;
+    let authenticated_reduction_scalar_values_per_point =
+        reduction_footprint.hot_scalar_values_per_point();
+    let execution_scalar_values_per_point =
+        maximum_leaf_scalar_values_per_point.max(source_scalar_values_per_point);
+    let hot_scalar_values_per_point = execution_scalar_values_per_point
+        .max(authenticated_reduction_scalar_values_per_point.unwrap_or(0));
+    let (effective_tile_capacity, reduction_tile_capacity) = match layout_policy {
+        // This developer/test contract remains exact: the adaptive locality
+        // policy does not change it.
+        CompiledDirectCurrentLayoutPolicy::Identity { tile_capacity } => {
+            let capacity = usize::try_from(tile_capacity).map_err(|_| {
+                RusticolError::integrity("compiled Direct-Arena identity tile exceeds usize")
+            })?;
+            (capacity, capacity)
+        }
+        CompiledDirectCurrentLayoutPolicy::StageLivenessProduction => {
+            if authenticated_reduction_scalar_values_per_point.is_none() {
+                // Adaptive production tiling is only valid when every
+                // reducer reachable from this engine has a static footprint.
+                // Still route the one-point fallback through the common
+                // selector so its padded physical allocation remains checked.
+                let capacity = deterministic_point_tile_size_with_cache_footprint(
+                    1,
+                    usize::MAX,
+                    usize::MAX,
+                    physical_scalar_values_per_point,
+                    hot_scalar_values_per_point,
+                )? as usize;
+                (capacity, capacity)
+            } else {
+                let execution_capacity = deterministic_point_tile_size_with_cache_footprint(
+                    COMPILED_DIRECT_LOCALITY_POINT_CAP,
+                    usize::MAX,
+                    compiled_direct_cache_target_bytes(),
+                    physical_scalar_values_per_point,
+                    execution_scalar_values_per_point,
+                )? as usize;
+                let reduction_capacity = deterministic_point_tile_size_with_cache_footprint(
+                    COMPILED_DIRECT_LOCALITY_POINT_CAP,
+                    usize::MAX,
+                    compiled_direct_cache_target_bytes(),
+                    physical_scalar_values_per_point,
+                    hot_scalar_values_per_point,
+                )? as usize;
+                (execution_capacity, reduction_capacity)
+            }
+        }
+    };
+    Ok(CompiledDirectTileSizing {
+        effective_tile_capacity,
+        reduction_tile_capacity,
+        physical_scalar_values_per_point,
+        persistent_scalar_values_per_point,
+        hot_scalar_values_per_point,
+        execution_scalar_values_per_point,
+        source_scalar_values_per_point,
+        reduction_scalar_values_per_point: authenticated_reduction_scalar_values_per_point
+            .unwrap_or(0),
+    })
+}
+
+/// Cold-bound canonical preorder leaf schedule.
+///
+/// Fields remain private so arbitrary caller indices cannot bypass the
+/// production runtime coverage validation that creates selector schedules.
+pub(crate) struct CompiledDirectValidatedSchedule {
+    active_stage_leaves: Box<[Box<[usize]>]>,
+    active_amplitude_leaves: Box<[usize]>,
+    inactive_amplitude_components: Box<[usize]>,
+}
+
+/// Persistent prototype executor for one compiled schedule.
+///
+/// The descriptor objects contain pointers into the boxed arena and aligned
+/// side buffers. Those allocations never resize or move after construction.
+pub(crate) struct CompiledDirectEnginePrototype {
+    // Bound descriptors must drop before the allocations they address. Rust
+    // drops fields in declaration order, so keep these owners first.
+    stages: Vec<BoundStage>,
+    amplitude: BoundStage,
+    arena: Box<DirectArenaWorkspace>,
+    momenta: Box<AlignedF64Buffer>,
+    parameter_re: Box<AlignedF64Buffer>,
+    parameter_im: Box<AlignedF64Buffer>,
+    zero_plane: Box<AlignedF64Buffer>,
+    full_schedule: CompiledDirectValidatedSchedule,
+    helicity_color_schedules:
+        BTreeMap<usize, BTreeMap<BTreeSet<i64>, Arc<CompiledDirectValidatedSchedule>>>,
+    source_components: Box<[usize]>,
+    default_source_states: Box<[GenericSourceStateIrManifest]>,
+    source_wavefunction_scratch: Vec<Complex<f64>>,
+    current_layout: CompiledDirectCurrentLayout,
+    tile_sizing: CompiledDirectTileSizing,
+    value_component_count: usize,
+    momentum_component_count: usize,
+    model_parameter_count: usize,
+    amplitude_component_count: usize,
+    traffic: CompiledDirectPrototypeTraffic,
+    allocation_counters: DirectArenaAllocationCounters,
+}
+
+impl CompiledDirectEnginePrototype {
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn load(
+        stages: &[GenericSerializedStageEvaluatorManifest],
+        amplitude: &GenericSerializedStageEvaluatorManifest,
+        payloads: &EvaluatorPayloadStore,
+        source_components: &[usize],
+        source_scratch_len: usize,
+        value_component_count: usize,
+        momentum_component_count: usize,
+        model_parameter_count: usize,
+        amplitude_component_count: usize,
+        tile_capacity: u32,
+    ) -> RusticolResult<Self> {
+        Self::load_with_current_layout_policy(
+            stages,
+            amplitude,
+            payloads,
+            source_components,
+            source_scratch_len,
+            value_component_count,
+            momentum_component_count,
+            model_parameter_count,
+            amplitude_component_count,
+            CompiledDirectReductionFootprint::default(),
+            CompiledDirectCurrentLayoutPolicy::Identity { tile_capacity },
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn load_with_current_layout_policy(
+        stages: &[GenericSerializedStageEvaluatorManifest],
+        amplitude: &GenericSerializedStageEvaluatorManifest,
+        payloads: &EvaluatorPayloadStore,
+        source_components: &[usize],
+        source_scratch_len: usize,
+        value_component_count: usize,
+        momentum_component_count: usize,
+        model_parameter_count: usize,
+        amplitude_component_count: usize,
+        reduction_footprint: CompiledDirectReductionFootprint,
+        layout_policy: CompiledDirectCurrentLayoutPolicy,
+    ) -> RusticolResult<Self> {
+        if value_component_count == 0 || amplitude_component_count == 0 {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena prototype requires current and amplitude planes",
+            ));
+        }
+        if !momentum_component_count.is_multiple_of(4) {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena momentum component count must be a multiple of four",
+            ));
+        }
+        if source_components.is_empty() || source_scratch_len == 0 {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena requires canonical source-component ownership",
+            ));
+        }
+        let mut previous_source = None;
+        for &component in source_components {
+            if component >= value_component_count
+                || previous_source.is_some_and(|previous| previous >= component)
+            {
+                return Err(RusticolError::integrity(
+                    "compiled Direct-Arena source components are not sorted, unique, and in bounds",
+                ));
+            }
+            previous_source = Some(component);
+        }
+        let structural_zero_components =
+            canonical_structural_zero_components(stages, source_components, value_component_count)?;
+        let loaded_stages = stages
+            .iter()
+            .map(|stage| {
+                load_stage(
+                    stage,
+                    false,
+                    payloads,
+                    value_component_count,
+                    momentum_component_count,
+                    amplitude_component_count,
+                    &structural_zero_components,
+                )
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let loaded_amplitude = load_stage(
+            amplitude,
+            true,
+            payloads,
+            value_component_count,
+            momentum_component_count,
+            amplitude_component_count,
+            &structural_zero_components,
+        )?;
+
+        let full_stage_leaves = loaded_stages
+            .iter()
+            .map(|stage| (0..stage.leaves.len()).collect::<Vec<_>>())
+            .collect::<Vec<_>>();
+        let full_amplitude_leaves = (0..loaded_amplitude.leaves.len()).collect::<Vec<_>>();
+        let full_schedule = validate_schedule(
+            &loaded_stages,
+            &loaded_amplitude,
+            value_component_count,
+            source_components,
+            amplitude_component_count,
+            &full_stage_leaves,
+            &full_amplitude_leaves,
+        )?;
+        let current_layout = match layout_policy {
+            CompiledDirectCurrentLayoutPolicy::Identity { .. } => {
+                CompiledDirectCurrentLayout::identity(value_component_count)?
+            }
+            CompiledDirectCurrentLayoutPolicy::StageLivenessProduction => {
+                derive_stage_current_layout(
+                    &loaded_stages,
+                    &loaded_amplitude,
+                    source_components,
+                    value_component_count,
+                )?
+            }
+        };
+        let tile_sizing = compiled_direct_tile_sizing(
+            &loaded_stages,
+            &loaded_amplitude,
+            &current_layout,
+            source_components,
+            momentum_component_count,
+            amplitude_component_count,
+            reduction_footprint,
+            layout_policy,
+        )?;
+        let tile_capacity = u32::try_from(tile_sizing.effective_tile_capacity).map_err(|_| {
+            RusticolError::integrity("compiled Direct-Arena tile capacity exceeds u32")
+        })?;
+        let mut arena = Box::new(DirectArenaWorkspace::new(
+            current_layout.physical_component_count,
+            u32::try_from(amplitude_component_count).map_err(|_| {
+                RusticolError::integrity("compiled Direct-Arena amplitude plane count exceeds u32")
+            })?,
+            tile_capacity,
+        )?);
+        arena.begin_tile(tile_capacity)?;
+        let stride = arena.point_stride() as usize;
+        let momenta_len = momentum_component_count
+            .checked_mul(stride)
+            .ok_or_else(|| RusticolError::integrity("compiled momentum arena length overflows"))?;
+        let mut momenta = Box::new(AlignedF64Buffer::zeroed(
+            momenta_len,
+            "compiled prototype momenta",
+        )?);
+        let mut parameter_re = Box::new(AlignedF64Buffer::zeroed(
+            model_parameter_count,
+            "compiled prototype parameter real",
+        )?);
+        let mut parameter_im = Box::new(AlignedF64Buffer::zeroed(
+            model_parameter_count,
+            "compiled prototype parameter imaginary",
+        )?);
+        let zero_plane = Box::new(AlignedF64Buffer::zeroed(
+            stride,
+            "compiled prototype shared zero plane",
+        )?);
+
+        let arena_view = arena.view()?;
+        let momentum_view = DirectMomentumView {
+            values: momenta.as_mut_ptr(),
+            scalar_len: momenta.len() as u64,
+            form_count: u32::try_from(momentum_component_count / 4).map_err(|_| {
+                RusticolError::integrity("compiled momentum form count exceeds u32")
+            })?,
+            lorentz_component_count: 4,
+            point_stride: arena_view.point_stride,
+        };
+        let parameter_view = DirectParameterView {
+            values_re: if parameter_re.is_empty() {
+                ptr::null()
+            } else {
+                parameter_re.as_mut_ptr()
+            },
+            values_im: if parameter_im.is_empty() {
+                ptr::null()
+            } else {
+                parameter_im.as_mut_ptr()
+            },
+            value_count: u32::try_from(model_parameter_count).map_err(|_| {
+                RusticolError::integrity("compiled model parameter count exceeds u32")
+            })?,
+        };
+
+        // SAFETY: arena and side buffers are fixed-size heap allocations owned
+        // by the returned executor. No field resizes them, and evaluate methods
+        // require exclusive access to the executor.
+        let bind_stage = |loaded: LoadedStage| -> RusticolResult<BoundStage> {
+            Ok(BoundStage {
+                leaves: loaded
+                    .leaves
+                    .into_iter()
+                    .map(|leaf| unsafe {
+                        leaf.bind(
+                            arena_view,
+                            momentum_view,
+                            parameter_view,
+                            &zero_plane,
+                            current_layout.physical_map(),
+                        )
+                    })
+                    .collect::<RusticolResult<Vec<_>>>()?,
+                leaf_plans: loaded.leaf_plans,
+            })
+        };
+        let stages = loaded_stages
+            .into_iter()
+            .map(bind_stage)
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let amplitude = bind_stage(loaded_amplitude)?;
+        let allocation_counters = [
+            arena.allocation_counters(),
+            momenta.allocation_counters(),
+            parameter_re.allocation_counters(),
+            parameter_im.allocation_counters(),
+            zero_plane.allocation_counters(),
+            DirectArenaAllocationCounters {
+                allocation_requests: 1,
+                requested_bytes: u64::try_from(
+                    source_scratch_len.saturating_mul(std::mem::size_of::<Complex<f64>>()),
+                )
+                .unwrap_or(u64::MAX),
+            },
+        ]
+        .into_iter()
+        .try_fold(
+            DirectArenaAllocationCounters::default(),
+            |total, counters| total.checked_add(counters),
+        )?;
+        let allocation_counters = stages
+            .iter()
+            .flat_map(|stage| stage.leaves.iter())
+            .chain(amplitude.leaves.iter())
+            .try_fold(allocation_counters, |total, leaf| {
+                total.checked_add(leaf.allocation_counters())
+            })?;
+
+        Ok(Self {
+            stages,
+            amplitude,
+            arena,
+            momenta,
+            parameter_re,
+            parameter_im,
+            zero_plane,
+            full_schedule,
+            helicity_color_schedules: BTreeMap::new(),
+            source_components: source_components.to_vec().into_boxed_slice(),
+            default_source_states: Box::new([]),
+            source_wavefunction_scratch: vec![c64(0.0, 0.0); source_scratch_len],
+            current_layout,
+            tile_sizing,
+            value_component_count,
+            momentum_component_count,
+            model_parameter_count,
+            amplitude_component_count,
+            traffic: CompiledDirectPrototypeTraffic::default(),
+            allocation_counters,
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn load_production(
+        stages: &[GenericSerializedStageEvaluatorManifest],
+        amplitude: &GenericSerializedStageEvaluatorManifest,
+        payloads: &EvaluatorPayloadStore,
+        sources: &[GenericSourceRecordManifest],
+        value_component_count: usize,
+        momentum_component_count: usize,
+        model_parameter_count: usize,
+        amplitude_component_count: usize,
+        reduction_footprint: CompiledDirectReductionFootprint,
+    ) -> RusticolResult<Self> {
+        let (source_components, source_scratch_len) =
+            canonical_source_layout(sources, value_component_count)?;
+        let mut direct = Self::load_with_current_layout_policy(
+            stages,
+            amplitude,
+            payloads,
+            &source_components,
+            source_scratch_len,
+            value_component_count,
+            momentum_component_count,
+            model_parameter_count,
+            amplitude_component_count,
+            reduction_footprint,
+            CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+        )?;
+        direct.default_source_states = sources
+            .iter()
+            .map(ExecutionRuntime::default_runtime_source_state)
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        Ok(direct)
+    }
+
+    pub(crate) const fn traffic(&self) -> CompiledDirectPrototypeTraffic {
+        self.traffic
+    }
+
+    pub(crate) const fn allocation_counters(&self) -> DirectArenaAllocationCounters {
+        self.allocation_counters
+    }
+
+    pub(crate) const fn tile_capacity(&self) -> usize {
+        self.arena.tile_capacity() as usize
+    }
+
+    pub(crate) const fn reduction_tile_capacity(&self) -> usize {
+        self.tile_sizing.reduction_tile_capacity
+    }
+
+    pub(crate) fn reduction_tile_capacity_for_footprint(
+        &self,
+        reduction_footprint: CompiledDirectReductionFootprint,
+    ) -> RusticolResult<usize> {
+        self.tile_sizing
+            .reduction_tile_capacity_for_footprint(reduction_footprint)
+    }
+
+    pub(crate) const fn tile_sizing(&self) -> CompiledDirectTileSizing {
+        self.tile_sizing
+    }
+
+    /// Fill one active tile directly from the public borrowed momentum view
+    /// and immutable runtime metadata. No point-major global state exists.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn begin_tile_from_inputs(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        sources: &[GenericSourceRecordManifest],
+        source_states: Option<&[RuntimeSourceState]>,
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        momentum_slots: &[GenericMomentumSlotManifest],
+        external_is_initial: &[bool],
+        model_parameter_values: &[f64],
+    ) -> RusticolResult<()> {
+        let point_count = batch.point_count();
+        if point_count == 0 || point_count > self.tile_capacity() {
+            return Err(RusticolError::invalid_argument(format!(
+                "compiled Direct-Arena input tile has {point_count} points, expected 1..={}",
+                self.tile_capacity()
+            )));
+        }
+        if batch.external_count() != external_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "compiled Direct-Arena input has {} external legs, expected {external_count}",
+                batch.external_count()
+            )));
+        }
+        if let Some(states) = source_states
+            && states.len() != sources.len()
+        {
+            return Err(RusticolError::invalid_argument(format!(
+                "compiled Direct-Arena source-state count {} does not match source count {}",
+                states.len(),
+                sources.len()
+            )));
+        }
+        if source_states.is_none() && self.default_source_states.len() != sources.len() {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena default source-state count {} does not match source count {}",
+                self.default_source_states.len(),
+                sources.len()
+            )));
+        }
+        if model_parameter_values.len() != self.model_parameter_count {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena model-scalar count {} does not match {}",
+                model_parameter_values.len(),
+                self.model_parameter_count
+            )));
+        }
+
+        self.arena
+            .begin_tile(u32::try_from(point_count).map_err(|_| {
+                RusticolError::invalid_argument("compiled Direct-Arena point count exceeds u32")
+            })?)?;
+        let stride = self.arena.point_stride() as usize;
+        {
+            let (current_re, current_im, _, _) = self.arena.split_slices_mut();
+            let scratch = &mut self.source_wavefunction_scratch;
+            for (source_index, source) in sources.iter().enumerate() {
+                let start = source.value_slot.component_start;
+                let stop = source.value_slot.component_stop;
+                let dimension = stop.checked_sub(start).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "compiled Direct-Arena source component range underflows",
+                    )
+                })?;
+                if dimension == 0 || stop > self.value_component_count || dimension > scratch.len()
+                {
+                    return Err(RusticolError::integrity(format!(
+                        "compiled Direct-Arena source {} has an invalid component range",
+                        source.source_id
+                    )));
+                }
+                // Load-time current-layout validation covers every source;
+                // the physical mapping is immutable across tiles.
+                let physical_components = &self.current_layout.physical_map()[start..stop];
+                let runtime_state = source_states.map(|states| &states[source_index]);
+                let factor = runtime_state.map_or(c64(1.0, 0.0), |state| state.factor);
+                if factor == c64(0.0, 0.0) {
+                    for &component in physical_components {
+                        let target = component as usize * stride;
+                        current_re[target..target + point_count].fill(0.0);
+                        current_im[target..target + point_count].fill(0.0);
+                    }
+                    continue;
+                }
+                let state = runtime_state.map_or_else(
+                    || &self.default_source_states[source_index],
+                    |state| &state.state,
+                );
+                let output = &mut scratch[..dimension];
+                let wavefunction = ResolvedSourceWavefunction::new(
+                    source,
+                    state,
+                    external_count,
+                    particle_masses,
+                    dimension,
+                )?;
+                for point_index in 0..point_count {
+                    let point = batch.point(point_index);
+                    wavefunction.write(&point, output)?;
+                    if factor != c64(1.0, 0.0) {
+                        for value in output.iter_mut() {
+                            *value *= factor;
+                        }
+                    }
+                    for (&component, value) in physical_components.iter().zip(output.iter()) {
+                        let target = component as usize * stride + point_index;
+                        current_re[target] = value.re;
+                        current_im[target] = value.im;
+                    }
+                }
+            }
+        }
+
+        fill_compiled_momentum_planes(
+            batch,
+            momentum_slots,
+            external_is_initial,
+            self.momentum_component_count,
+            stride,
+            self.momenta.as_mut_slice(),
+        )?;
+        for (index, value) in model_parameter_values.iter().copied().enumerate() {
+            self.parameter_re.as_mut_slice()[index] = value;
+            self.parameter_im.as_mut_slice()[index] = 0.0;
+        }
+
+        self.traffic.source_fill_bytes = self.traffic.source_fill_bytes.saturating_add(
+            point_count
+                .saturating_mul(self.source_components.len())
+                .saturating_mul(2 * std::mem::size_of::<f64>()) as u64,
+        );
+        self.traffic.momentum_fill_bytes = self.traffic.momentum_fill_bytes.saturating_add(
+            point_count
+                .saturating_mul(momentum_slots.len().saturating_mul(4))
+                .saturating_mul(std::mem::size_of::<f64>()) as u64,
+        );
+        self.traffic.parameter_fill_bytes = self.traffic.parameter_fill_bytes.saturating_add(
+            self.model_parameter_count
+                .saturating_mul(2 * std::mem::size_of::<f64>()) as u64,
+        );
+        Ok(())
+    }
+
+    /// Transpose the outer row-major state once at the engine boundary.
+    ///
+    /// This is not leaf gather traffic: every compiled leaf subsequently
+    /// consumes and produces the authoritative arena planes directly.
+    pub(crate) fn begin_tile_from_state(
+        &mut self,
+        point_count: usize,
+        global_parameter_count: usize,
+        state: &[Complex<f64>],
+    ) -> RusticolResult<()> {
+        if !self.current_layout.is_identity() {
+            return Err(RusticolError::invalid_argument(
+                "compiled Direct-Arena full-state developer input requires an identity current \
+                 layout",
+            ));
+        }
+        if point_count == 0
+            || point_count > self.arena.tile_capacity() as usize
+            || state.len() != point_count.saturating_mul(global_parameter_count)
+        {
+            return Err(RusticolError::invalid_argument(
+                "compiled Direct-Arena prototype state shape is invalid",
+            ));
+        }
+        let required_parameters = self
+            .value_component_count
+            .checked_add(self.momentum_component_count)
+            .and_then(|value| value.checked_add(self.model_parameter_count))
+            .ok_or_else(|| RusticolError::integrity("compiled parameter layout overflows"))?;
+        if global_parameter_count < required_parameters {
+            return Err(RusticolError::invalid_argument(
+                "compiled Direct-Arena prototype state omits required parameters",
+            ));
+        }
+
+        self.arena.begin_tile(point_count as u32)?;
+        let stride = self.arena.point_stride() as usize;
+        {
+            let (current_re, current_im, amplitude_re, amplitude_im) =
+                self.arena.split_slices_mut();
+            for component in 0..self.value_component_count {
+                let plane = component * stride;
+                for point in 0..point_count {
+                    let value = state[point * global_parameter_count + component];
+                    current_re[plane + point] = value.re;
+                    current_im[plane + point] = value.im;
+                }
+            }
+            for component in 0..self.amplitude_component_count {
+                let plane = component * stride;
+                amplitude_re[plane..plane + point_count].fill(0.0);
+                amplitude_im[plane..plane + point_count].fill(0.0);
+            }
+        }
+        let momentum_start = self.value_component_count;
+        for component in 0..self.momentum_component_count {
+            let plane = component * stride;
+            for point in 0..point_count {
+                self.momenta.as_mut_slice()[plane + point] =
+                    state[point * global_parameter_count + momentum_start + component].re;
+            }
+        }
+        let parameter_start = momentum_start + self.momentum_component_count;
+        if self.model_parameter_count != 0 {
+            for index in 0..self.model_parameter_count {
+                let value = state[parameter_start + index];
+                self.parameter_re.as_mut_slice()[index] = value.re;
+                self.parameter_im.as_mut_slice()[index] = value.im;
+                for point in 1..point_count {
+                    if state[point * global_parameter_count + parameter_start + index] != value {
+                        return Err(RusticolError::invalid_argument(
+                            "compiled Direct-Arena model parameters vary across a point tile",
+                        ));
+                    }
+                }
+            }
+        }
+        let input_scalars = point_count
+            .checked_mul(
+                self.value_component_count
+                    .checked_mul(2)
+                    .and_then(|value| value.checked_add(self.momentum_component_count))
+                    .ok_or_else(|| {
+                        RusticolError::integrity("compiled boundary input traffic overflows")
+                    })?,
+            )
+            .and_then(|value| value.checked_add(self.model_parameter_count.saturating_mul(2)))
+            .and_then(|value| value.checked_mul(std::mem::size_of::<f64>()))
+            .ok_or_else(|| RusticolError::integrity("compiled boundary input bytes overflow"))?;
+        self.traffic.boundary_input_bytes = self
+            .traffic
+            .boundary_input_bytes
+            .saturating_add(input_scalars as u64);
+        Ok(())
+    }
+
+    /// Test-only row-major source boundary for the production liveness layout.
+    ///
+    /// A liveness arena cannot represent arbitrary intermediate values at one
+    /// instant. It can, however, be initialized exactly like production by
+    /// clearing every physical plane and scattering only canonical sources.
+    #[cfg(test)]
+    fn begin_tile_from_state_sources_for_test(
+        &mut self,
+        point_count: usize,
+        global_parameter_count: usize,
+        state: &[Complex<f64>],
+    ) -> RusticolResult<()> {
+        if point_count == 0
+            || point_count > self.arena.tile_capacity() as usize
+            || state.len() != point_count.saturating_mul(global_parameter_count)
+        {
+            return Err(RusticolError::invalid_argument(
+                "compiled Direct-Arena production test state shape is invalid",
+            ));
+        }
+        let required_parameters = self
+            .value_component_count
+            .checked_add(self.momentum_component_count)
+            .and_then(|value| value.checked_add(self.model_parameter_count))
+            .ok_or_else(|| RusticolError::integrity("compiled parameter layout overflows"))?;
+        if global_parameter_count < required_parameters {
+            return Err(RusticolError::invalid_argument(
+                "compiled Direct-Arena production test state omits required parameters",
+            ));
+        }
+        self.arena.begin_tile(point_count as u32)?;
+        self.arena
+            .clear_current_active(0, self.current_layout.physical_component_count)?;
+        self.arena
+            .clear_amplitude_active(0, self.amplitude_component_count as u32)?;
+        let stride = self.arena.point_stride() as usize;
+        {
+            let (current_re, current_im, _, _) = self.arena.split_slices_mut();
+            for canonical_component in self.source_components.iter().copied() {
+                let physical_component =
+                    self.current_layout
+                        .physical_component(canonical_component)? as usize;
+                let plane = physical_component * stride;
+                for point in 0..point_count {
+                    let value = state[point * global_parameter_count + canonical_component];
+                    current_re[plane + point] = value.re;
+                    current_im[plane + point] = value.im;
+                }
+            }
+        }
+        let momentum_start = self.value_component_count;
+        for component in 0..self.momentum_component_count {
+            let plane = component * stride;
+            for point in 0..point_count {
+                self.momenta.as_mut_slice()[plane + point] =
+                    state[point * global_parameter_count + momentum_start + component].re;
+            }
+        }
+        let parameter_start = momentum_start + self.momentum_component_count;
+        for index in 0..self.model_parameter_count {
+            let value = state[parameter_start + index];
+            self.parameter_re.as_mut_slice()[index] = value.re;
+            self.parameter_im.as_mut_slice()[index] = value.im;
+            for point in 1..point_count {
+                if state[point * global_parameter_count + parameter_start + index] != value {
+                    return Err(RusticolError::invalid_argument(
+                        "compiled Direct-Arena model parameters vary across a production test tile",
+                    ));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Execute the existing full schedule. No input packet, gather, output
+    /// scatter, remap, or allocation occurs in this method.
+    pub(crate) fn evaluate_all(&mut self, point_count: usize) -> RusticolResult<()> {
+        evaluate_validated_schedule(
+            &mut self.stages,
+            &mut self.amplitude,
+            &self.full_schedule,
+            point_count_u32(point_count, self.arena.active_point_count())?,
+            &mut self.traffic,
+        )
+    }
+
+    /// Replace every retained source slot of a declared leg by the literal
+    /// public vector. Apply only the same SourceIR crossing phase as ordinary
+    /// wavefunctions; no projection, normalization or conjugation is applied.
+    pub(crate) fn replace_correlated_sources(
+        &mut self,
+        sources: &[GenericSourceRecordManifest],
+        vectors: &correlated::NativeSpinCorrelationVectors,
+        point_start: usize,
+        point_count: usize,
+    ) -> RusticolResult<()> {
+        point_count_u32(point_count, self.arena.active_point_count())?;
+        let stride = self.arena.point_stride() as usize;
+        let (re, im, _, _) = self.arena.split_slices_mut();
+        for source in sources {
+            let Some(batch) = vectors.get(&source.leg_label) else {
+                continue;
+            };
+            let [pr, pi] = source.applied_crossing.phase;
+            // Traverse Lorentz components in arena order, not the outer batch
+            // axis: each point below selects its own vector (or broadcasts it).
+            #[allow(clippy::needless_range_loop)]
+            for component in 0..4 {
+                let physical = self
+                    .current_layout
+                    .physical_component(source.value_slot.component_start + component)?
+                    as usize;
+                for point in 0..point_count {
+                    let [vr, vi] = batch[if batch.len() == 1 {
+                        0
+                    } else {
+                        point_start + point
+                    }][component];
+                    re[physical * stride + point] = vr * pr - vi * pi;
+                    im[physical * stride + point] = vr * pi + vi * pr;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Reuse a leaf only when all of its current inputs are bit-identical.
+    /// Momenta and model parameters must stay fixed for the memo's lifetime;
+    /// the correlated caller creates a fresh memo for each point tile. Saved
+    /// outputs are restored because the production arena reuses dead slots.
+    pub(crate) fn evaluate_correlated_reusing(
+        &mut self,
+        point_count: usize,
+        memo: &mut CorrelatedStageMemo,
+    ) -> RusticolResult<()> {
+        let count = point_count_u32(point_count, self.arena.active_point_count())?;
+        let leaf_count = self
+            .stages
+            .iter()
+            .map(|stage| stage.leaves.len())
+            .sum::<usize>()
+            + self.amplitude.leaves.len();
+        if memo.leaves.is_empty() {
+            memo.leaves.resize_with(leaf_count, || None);
+        }
+        if memo.leaves.len() != leaf_count {
+            return Err(RusticolError::internal(
+                "correlated stage memo belongs to a different compiled plan",
+            ));
+        }
+        let stride = self.arena.point_stride() as usize;
+        let mut index = 0;
+        for stage in self
+            .stages
+            .iter_mut()
+            .chain(std::iter::once(&mut self.amplitude))
+        {
+            for (leaf, plan) in stage.leaves.iter_mut().zip(&stage.leaf_plans) {
+                let input_components = plan
+                    .input_current_components
+                    .iter()
+                    .map(|&component| self.current_layout.physical_component(component))
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                let output_components = plan
+                    .output_current_components
+                    .iter()
+                    .map(|&component| self.current_layout.physical_component(component))
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                let (re, im) = self.arena.current_slices();
+                let inputs: Vec<_> = input_components
+                    .iter()
+                    .flat_map(|&component| {
+                        (0..point_count).flat_map(move |point| {
+                            [
+                                re[component as usize * stride + point].to_bits(),
+                                im[component as usize * stride + point].to_bits(),
+                            ]
+                        })
+                    })
+                    .collect();
+                if let Some(saved) = &memo.leaves[index]
+                    && saved.inputs == inputs
+                {
+                    #[cfg(test)]
+                    {
+                        memo.reused_leaves += 1;
+                    }
+                    let (re, im, ar, ai) = self.arena.split_slices_mut();
+                    for (position, &component) in output_components.iter().enumerate() {
+                        for point in 0..point_count {
+                            let value = saved.current_outputs[position * point_count + point];
+                            re[component as usize * stride + point] = value[0];
+                            im[component as usize * stride + point] = value[1];
+                        }
+                    }
+                    for (position, &component) in
+                        plan.output_amplitude_components.iter().enumerate()
+                    {
+                        for point in 0..point_count {
+                            let value = saved.amplitude_outputs[position * point_count + point];
+                            ar[component * stride + point] = value[0];
+                            ai[component * stride + point] = value[1];
+                        }
+                    }
+                } else {
+                    leaf.evaluate(0, count)?;
+                    let (re, im) = self.arena.current_slices();
+                    let current_outputs = output_components
+                        .iter()
+                        .flat_map(|&component| {
+                            (0..point_count).map(move |point| {
+                                [
+                                    re[component as usize * stride + point],
+                                    im[component as usize * stride + point],
+                                ]
+                            })
+                        })
+                        .collect();
+                    let (re, im) = self.arena.amplitude_slices();
+                    let amplitude_outputs = plan
+                        .output_amplitude_components
+                        .iter()
+                        .flat_map(|&component| {
+                            (0..point_count).map(move |point| {
+                                [
+                                    re[component * stride + point],
+                                    im[component * stride + point],
+                                ]
+                            })
+                        })
+                        .collect();
+                    memo.leaves[index] = Some(CorrelatedLeafMemo {
+                        inputs,
+                        current_outputs,
+                        amplitude_outputs,
+                    });
+                }
+                index += 1;
+            }
+        }
+        Ok(())
+    }
+
+    /// Bind an already producer-validated compiled color schedule to this
+    /// concrete direct plan. This remains cold-path validation: hot execution
+    /// accepts only the opaque returned schedule.
+    pub(crate) fn bind_color_schedule(
+        &self,
+        schedule: &CompiledColorSelectorSchedule,
+    ) -> RusticolResult<CompiledDirectValidatedSchedule> {
+        validate_schedule(
+            &self.stages,
+            &self.amplitude,
+            self.value_component_count,
+            &self.source_components,
+            self.amplitude_component_count,
+            &schedule.active_stage_chunk_indices,
+            &schedule.active_amplitude_chunk_indices,
+        )
+    }
+
+    /// Bind an already producer-validated compiled helicity schedule to this
+    /// concrete direct plan.
+    pub(crate) fn bind_helicity_schedule(
+        &self,
+        schedule: &CompiledHelicitySelectorSchedule,
+    ) -> RusticolResult<CompiledDirectValidatedSchedule> {
+        validate_schedule(
+            &self.stages,
+            &self.amplitude,
+            self.value_component_count,
+            &self.source_components,
+            self.amplitude_component_count,
+            &schedule.active_stage_chunk_indices,
+            &schedule.active_amplitude_chunk_indices,
+        )
+    }
+
+    /// Reuse the closure common to a helicity and a union of requested colours.
+    /// Binding is done once per selection, never per tile or phase-space point.
+    pub(crate) fn bind_helicity_color_schedule(
+        &mut self,
+        selector_domain_id: usize,
+        helicity: &CompiledDirectValidatedSchedule,
+        selected_sector_ids: &BTreeSet<i64>,
+        color_schedules: &BTreeMap<i64, CompiledDirectValidatedSchedule>,
+    ) -> RusticolResult<Arc<CompiledDirectValidatedSchedule>> {
+        if let Some(schedule) = self
+            .helicity_color_schedules
+            .get(&selector_domain_id)
+            .and_then(|colors| colors.get(selected_sector_ids))
+        {
+            return Ok(Arc::clone(schedule));
+        }
+        if selected_sector_ids.is_empty() {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena colour selection is empty",
+            ));
+        }
+        let colors = selected_sector_ids
+            .iter()
+            .map(|id| {
+                color_schedules.get(id).ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "compiled Direct-Arena colour schedule {id} is missing"
+                    ))
+                })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let (stages, amplitude) = intersect_helicity_color_schedules(helicity, &colors)?;
+        let schedule = Arc::new(validate_schedule(
+            &self.stages,
+            &self.amplitude,
+            self.value_component_count,
+            &self.source_components,
+            self.amplitude_component_count,
+            &stages,
+            &amplitude,
+        )?);
+        self.helicity_color_schedules
+            .entry(selector_domain_id)
+            .or_default()
+            .insert(selected_sector_ids.clone(), Arc::clone(&schedule));
+        Ok(schedule)
+    }
+
+    /// Execute a cold-bound canonical preorder leaf schedule.
+    pub(crate) fn evaluate_validated(
+        &mut self,
+        point_count: usize,
+        schedule: &CompiledDirectValidatedSchedule,
+    ) -> RusticolResult<()> {
+        self.clear_inactive_amplitude_components(schedule)?;
+        evaluate_validated_schedule(
+            &mut self.stages,
+            &mut self.amplitude,
+            schedule,
+            point_count_u32(point_count, self.arena.active_point_count())?,
+            &mut self.traffic,
+        )
+    }
+
+    /// Execute an authenticated materialized-helicity schedule without
+    /// clearing amplitude planes outside its active root closure.
+    ///
+    /// Materialized-helicity reducers consume only roots carried by the same
+    /// authenticated selector schedule. Inactive planes may therefore retain
+    /// values from an earlier tile and must not impose an all-helicity memory
+    /// pass on a singleton-helicity execution.
+    pub(crate) fn evaluate_validated_materialized_helicity(
+        &mut self,
+        point_count: usize,
+        schedule: &CompiledDirectValidatedSchedule,
+    ) -> RusticolResult<()> {
+        evaluate_validated_schedule(
+            &mut self.stages,
+            &mut self.amplitude,
+            schedule,
+            point_count_u32(point_count, self.arena.active_point_count())?,
+            &mut self.traffic,
+        )
+    }
+
+    fn clear_inactive_amplitude_components(
+        &mut self,
+        schedule: &CompiledDirectValidatedSchedule,
+    ) -> RusticolResult<()> {
+        let mut cursor = 0;
+        while cursor < schedule.inactive_amplitude_components.len() {
+            let start = schedule.inactive_amplitude_components[cursor];
+            let mut stop = start + 1;
+            cursor += 1;
+            while cursor < schedule.inactive_amplitude_components.len()
+                && schedule.inactive_amplitude_components[cursor] == stop
+            {
+                stop += 1;
+                cursor += 1;
+            }
+            self.arena.clear_amplitude_active(
+                u32::try_from(start).map_err(|_| {
+                    RusticolError::integrity("compiled amplitude clear start exceeds u32")
+                })?,
+                u32::try_from(stop - start).map_err(|_| {
+                    RusticolError::integrity("compiled amplitude clear length exceeds u32")
+                })?,
+            )?;
+            self.traffic.amplitude_clear_bytes = self.traffic.amplitude_clear_bytes.saturating_add(
+                (stop - start)
+                    .saturating_mul(self.arena.active_point_count() as usize)
+                    .saturating_mul(2 * std::mem::size_of::<f64>()) as u64,
+            );
+        }
+        Ok(())
+    }
+
+    pub(crate) fn copy_current_to_state(
+        &mut self,
+        point_count: usize,
+        global_parameter_count: usize,
+        state: &mut [Complex<f64>],
+    ) -> RusticolResult<()> {
+        if !self.current_layout.is_identity() {
+            return Err(RusticolError::invalid_argument(
+                "compiled Direct-Arena full-state developer output requires an identity current \
+                 layout",
+            ));
+        }
+        if state.len() != point_count.saturating_mul(global_parameter_count) {
+            return Err(RusticolError::invalid_argument(
+                "compiled Direct-Arena output state shape is invalid",
+            ));
+        }
+        let stride = self.arena.point_stride() as usize;
+        let (current_re, current_im) = self.arena.current_slices();
+        for component in 0..self.value_component_count {
+            let plane = component * stride;
+            for point in 0..point_count {
+                state[point * global_parameter_count + component] =
+                    Complex::new(current_re[plane + point], current_im[plane + point]);
+            }
+        }
+        self.traffic.boundary_current_output_bytes =
+            self.traffic.boundary_current_output_bytes.saturating_add(
+                point_count
+                    .saturating_mul(self.value_component_count)
+                    .saturating_mul(2 * std::mem::size_of::<f64>()) as u64,
+            );
+        Ok(())
+    }
+
+    /// Borrow the canonical split-complex planes directly for the plane-native
+    /// reducer. No amplitude packing or traffic accounting is involved.
+    pub(crate) fn amplitude_planes(&self) -> RusticolResult<DirectAmplitudePlanes<'_>> {
+        let (amplitude_re, amplitude_im) = self.arena.amplitude_slices();
+        DirectAmplitudePlanes::new(
+            amplitude_re,
+            amplitude_im,
+            self.arena.point_stride(),
+            self.arena.active_point_count(),
+        )
+    }
+
+    /// Explicit developer-only AoS extraction, excluded from measured leaf and
+    /// plane-native reduction paths.
+    pub(crate) fn extract_amplitudes_row_major(
+        &mut self,
+        point_count: usize,
+        output: &mut [Complex<f64>],
+    ) -> RusticolResult<()> {
+        if output.len() != point_count.saturating_mul(self.amplitude_component_count) {
+            return Err(RusticolError::invalid_argument(
+                "compiled Direct-Arena amplitude output shape is invalid",
+            ));
+        }
+        let stride = self.arena.point_stride() as usize;
+        let (amplitude_re, amplitude_im) = self.arena.amplitude_slices();
+        for component in 0..self.amplitude_component_count {
+            let plane = component * stride;
+            for point in 0..point_count {
+                output[point * self.amplitude_component_count + component] =
+                    Complex::new(amplitude_re[plane + point], amplitude_im[plane + point]);
+            }
+        }
+        self.traffic.boundary_amplitude_output_bytes =
+            self.traffic.boundary_amplitude_output_bytes.saturating_add(
+                point_count
+                    .saturating_mul(self.amplitude_component_count)
+                    .saturating_mul(2 * std::mem::size_of::<f64>()) as u64,
+            );
+        Ok(())
+    }
+}
+
+#[cfg(feature = "f64-symjit")]
+pub(crate) fn compiled_direct_symjit_supported(
+    evaluators: &GenericStageEvaluatorArtifactsManifest,
+) -> RusticolResult<bool> {
+    for stage in evaluators
+        .stages
+        .iter()
+        .chain(std::iter::once(&evaluators.amplitude_stage))
+    {
+        for leaf in stage.evaluator.leaf_layout()? {
+            if !matches!(leaf.evaluator, EvaluatorManifest::SymjitApplication { .. }) {
+                return Ok(false);
+            }
+        }
+    }
+    Ok(true)
+}
+
+/// Execute the momentum sums already recorded in the process output. Only
+/// the point loop is transposed: label order, crossings and the initial
+/// positive-zero addition remain identical to the scalar implementation.
+fn fill_compiled_momentum_planes(
+    batch: F64MomentumBatchView<'_>,
+    slots: &[GenericMomentumSlotManifest],
+    external_is_initial: &[bool],
+    component_count: usize,
+    stride: usize,
+    momenta: &mut [f64],
+) -> RusticolResult<()> {
+    let point_count = batch.point_count();
+    if stride < point_count || component_count.checked_mul(stride) != Some(momenta.len()) {
+        return Err(RusticolError::integrity(
+            "compiled Direct-Arena momentum plane shape is invalid",
+        ));
+    }
+    for slot in slots {
+        if slot.component_stop.checked_sub(slot.component_start) != Some(4)
+            || slot.component_stop > component_count
+        {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena momentum slot {} has an invalid component range",
+                slot.momentum_slot_id
+            )));
+        }
+        if slot.external_labels.is_empty() {
+            for component in slot.component_start..slot.component_stop {
+                let start = component * stride;
+                momenta[start..start + point_count].fill(0.0);
+            }
+            continue;
+        }
+        if point_count == 1 {
+            // A singleton has no point-plane loop to vectorize. Read all four
+            // components and resolve its public crossing once per term, as in
+            // the original scalar accumulator, after static slot pruning.
+            let point = batch.point(0);
+            let mut value = [0.0; 4];
+            for &label in &slot.external_labels {
+                let (external_index, sign) = compiled_momentum_term(
+                    label,
+                    slot.momentum_slot_id,
+                    batch.external_count(),
+                    external_is_initial,
+                )?;
+                let momentum = point
+                    .momentum(external_index)
+                    .ok_or_else(|| RusticolError::integrity("compiled momentum input is absent"))?;
+                for (sum, component) in value.iter_mut().zip(momentum) {
+                    *sum += sign * component;
+                }
+            }
+            for (component, value) in value.into_iter().enumerate() {
+                momenta[(slot.component_start + component) * stride] = value;
+            }
+            continue;
+        }
+        for (term, label) in slot.external_labels.iter().enumerate() {
+            let (external_index, sign) = compiled_momentum_term(
+                *label,
+                slot.momentum_slot_id,
+                batch.external_count(),
+                external_is_initial,
+            )?;
+            for component in 0..4 {
+                let start = (slot.component_start + component) * stride;
+                let output = &mut momenta[start..start + point_count];
+                if term == 0 {
+                    // Avoid a separate zero-fill pass, especially for the
+                    // common single-external-momentum slots.
+                    batch.accumulate_component_into::<false>(
+                        external_index,
+                        component,
+                        sign,
+                        output,
+                    )?;
+                } else {
+                    batch.accumulate_component_into::<true>(
+                        external_index,
+                        component,
+                        sign,
+                        output,
+                    )?;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[inline]
+fn compiled_momentum_term(
+    label: usize,
+    momentum_slot_id: usize,
+    external_count: usize,
+    external_is_initial: &[bool],
+) -> RusticolResult<(usize, f64)> {
+    let external_index = label.checked_sub(1).ok_or_else(|| {
+        RusticolError::integrity("compiled Direct-Arena momentum labels are one-based")
+    })?;
+    if external_index >= external_count {
+        return Err(RusticolError::integrity(format!(
+            "compiled Direct-Arena momentum slot {momentum_slot_id} references absent external leg {label}"
+        )));
+    }
+    let sign = if *external_is_initial.get(external_index).ok_or_else(|| {
+        RusticolError::integrity("compiled Direct-Arena external-side metadata is incomplete")
+    })? {
+        -1.0
+    } else {
+        1.0
+    };
+    Ok((external_index, sign))
+}
+
+fn canonical_source_layout(
+    sources: &[GenericSourceRecordManifest],
+    value_component_count: usize,
+) -> RusticolResult<(Vec<usize>, usize)> {
+    if sources.is_empty() {
+        return Err(RusticolError::integrity(
+            "compiled Direct-Arena runtime schema has no sources",
+        ));
+    }
+    let mut source_components = Vec::new();
+    let mut max_dimension = 0usize;
+    for (source_index, source) in sources.iter().enumerate() {
+        if source.source_id != source_index
+            || source.value_slot.current_id != source.current_id
+            || source.value_slot.component_start != source.current_component_start
+            || source.value_slot.component_stop != source.current_component_stop
+        {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena source {source_index} does not preserve canonical current ownership"
+            )));
+        }
+        let start = source.value_slot.component_start;
+        let stop = source.value_slot.component_stop;
+        let dimension = stop
+            .checked_sub(start)
+            .filter(|value| *value != 0)
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "compiled Direct-Arena source {source_index} has an empty or reversed range"
+                ))
+            })?;
+        if stop > value_component_count || dimension != source.dimension {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena source {source_index} exceeds canonical current storage"
+            )));
+        }
+        source_components.extend(start..stop);
+        max_dimension = max_dimension.max(dimension);
+    }
+    if source_components
+        .windows(2)
+        .any(|window| window[0] >= window[1])
+    {
+        return Err(RusticolError::integrity(
+            "compiled Direct-Arena source component ownership overlaps or is unordered",
+        ));
+    }
+    Ok((source_components, max_dimension))
+}
+
+fn canonical_structural_zero_components(
+    stages: &[GenericSerializedStageEvaluatorManifest],
+    source_components: &[usize],
+    value_component_count: usize,
+) -> RusticolResult<BTreeSet<usize>> {
+    let sources = source_components.iter().copied().collect::<BTreeSet<_>>();
+    let mut produced = BTreeSet::new();
+    for stage in stages {
+        for slot in &stage.output_slots {
+            let output_len = slot
+                .output_stop
+                .checked_sub(slot.output_start)
+                .ok_or_else(|| {
+                    RusticolError::integrity("compiled Direct-Arena output slot range underflows")
+                })?;
+            if slot.component_stop.checked_sub(slot.component_start) != Some(output_len)
+                || slot.component_stop > value_component_count
+            {
+                return Err(RusticolError::integrity(format!(
+                    "compiled Direct-Arena stage {:?} has an invalid canonical output range",
+                    stage.evaluator_label
+                )));
+            }
+            for component in slot.component_start..slot.component_stop {
+                if sources.contains(&component) {
+                    return Err(RusticolError::integrity(format!(
+                        "compiled Direct-Arena stage {:?} writes canonical source component \
+                         {component}",
+                        stage.evaluator_label
+                    )));
+                }
+                produced.insert(component);
+            }
+        }
+    }
+    Ok((0..value_component_count)
+        .filter(|component| !sources.contains(component) && !produced.contains(component))
+        .collect())
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct CompiledDirectCurrentLifetime {
+    canonical_component: usize,
+    first_event: u64,
+    last_event: u64,
+}
+
+fn derive_stage_current_layout(
+    stages: &[LoadedStage],
+    amplitude: &LoadedStage,
+    source_components: &[usize],
+    canonical_component_count: usize,
+) -> RusticolResult<CompiledDirectCurrentLayout> {
+    let mut first_events = vec![None; canonical_component_count];
+    let mut last_events = vec![None; canonical_component_count];
+    for &component in source_components {
+        define_current_component(
+            &mut first_events,
+            &mut last_events,
+            component,
+            0,
+            "source fill",
+        )?;
+    }
+
+    for (stage_index, stage) in stages.iter().enumerate() {
+        let event = u64::try_from(stage_index)
+            .ok()
+            .and_then(|value| value.checked_add(1))
+            .ok_or_else(|| {
+                RusticolError::integrity("compiled Direct-Arena stage-liveness event exceeds u64")
+            })?;
+        for leaf in &stage.leaf_plans {
+            for &component in &leaf.input_current_components {
+                use_current_component(
+                    &first_events,
+                    &mut last_events,
+                    component,
+                    event,
+                    "current stage input",
+                )?;
+            }
+        }
+        // Arena-v1 declares no input/output or output/output aliasing for the
+        // complete fused stage, not merely for one leaf. Give every output the
+        // same inclusive definition event so the allocator preserves that
+        // whole-stage contract.
+        for leaf in &stage.leaf_plans {
+            for &component in &leaf.output_current_components {
+                define_current_component(
+                    &mut first_events,
+                    &mut last_events,
+                    component,
+                    event,
+                    "current stage output",
+                )?;
+            }
+        }
+    }
+
+    let amplitude_event = u64::try_from(stages.len())
+        .ok()
+        .and_then(|value| value.checked_add(1))
+        .ok_or_else(|| {
+            RusticolError::integrity("compiled Direct-Arena amplitude-liveness event exceeds u64")
+        })?;
+    for leaf in &amplitude.leaf_plans {
+        for &component in &leaf.input_current_components {
+            use_current_component(
+                &first_events,
+                &mut last_events,
+                component,
+                amplitude_event,
+                "amplitude stage input",
+            )?;
+        }
+    }
+
+    let mut lifetimes = first_events
+        .into_iter()
+        .zip(last_events)
+        .enumerate()
+        .filter_map(|(canonical_component, (first_event, last_event))| {
+            first_event.map(|first_event| {
+                last_event
+                    .map(|last_event| CompiledDirectCurrentLifetime {
+                        canonical_component,
+                        first_event,
+                        last_event,
+                    })
+                    .ok_or_else(|| {
+                        RusticolError::integrity(format!(
+                            "compiled Direct-Arena current component {canonical_component} has a \
+                             definition but no lifetime end"
+                        ))
+                    })
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    if lifetimes.is_empty() {
+        return Err(RusticolError::integrity(
+            "compiled Direct-Arena stage liveness has no live current components",
+        ));
+    }
+    lifetimes.sort_unstable_by_key(|lifetime| (lifetime.first_event, lifetime.canonical_component));
+
+    // Unit-width interval coloring in O(N log N). At every definition event,
+    // release only ranges whose inclusive lifetime ended strictly earlier and
+    // deterministically reuse the lowest free physical plane.
+    let mut active = BinaryHeap::<Reverse<(u64, u32)>>::new();
+    let mut free = BinaryHeap::<Reverse<u32>>::new();
+    let mut next_physical = 0_u32;
+    let mut canonical_to_physical = vec![UNMAPPED_CURRENT_COMPONENT; canonical_component_count];
+    for lifetime in &lifetimes {
+        while let Some(Reverse((last_event, physical_component))) = active.peek().copied() {
+            if last_event >= lifetime.first_event {
+                break;
+            }
+            active.pop();
+            free.push(Reverse(physical_component));
+        }
+        let physical_component = if let Some(Reverse(component)) = free.pop() {
+            component
+        } else {
+            let component = next_physical;
+            next_physical = next_physical.checked_add(1).ok_or_else(|| {
+                RusticolError::integrity(
+                    "compiled Direct-Arena physical current plane count exceeds u32",
+                )
+            })?;
+            component
+        };
+        canonical_to_physical[lifetime.canonical_component] = physical_component;
+        active.push(Reverse((lifetime.last_event, physical_component)));
+    }
+
+    let layout = CompiledDirectCurrentLayout {
+        canonical_to_physical: canonical_to_physical.into_boxed_slice(),
+        physical_component_count: next_physical,
+        live_component_count: lifetimes.len(),
+    };
+    validate_compiled_current_layout(&layout, &lifetimes, stages, amplitude)?;
+    Ok(layout)
+}
+
+fn define_current_component(
+    first_events: &mut [Option<u64>],
+    last_events: &mut [Option<u64>],
+    component: usize,
+    event: u64,
+    context: &str,
+) -> RusticolResult<()> {
+    let first = first_events.get_mut(component).ok_or_else(|| {
+        RusticolError::integrity(format!(
+            "compiled Direct-Arena {context} component {component} is out of bounds"
+        ))
+    })?;
+    let last = last_events.get_mut(component).ok_or_else(|| {
+        RusticolError::integrity(format!(
+            "compiled Direct-Arena {context} component {component} is out of bounds"
+        ))
+    })?;
+    if first.replace(event).is_some() || last.replace(event).is_some() {
+        return Err(RusticolError::integrity(format!(
+            "compiled Direct-Arena {context} component {component} has multiple producers"
+        )));
+    }
+    Ok(())
+}
+
+fn use_current_component(
+    first_events: &[Option<u64>],
+    last_events: &mut [Option<u64>],
+    component: usize,
+    event: u64,
+    context: &str,
+) -> RusticolResult<()> {
+    let first = first_events
+        .get(component)
+        .copied()
+        .flatten()
+        .ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "compiled Direct-Arena {context} component {component} is absent or used before \
+                 its producer"
+            ))
+        })?;
+    if first > event {
+        return Err(RusticolError::integrity(format!(
+            "compiled Direct-Arena {context} component {component} precedes its producer"
+        )));
+    }
+    let last = last_events.get_mut(component).ok_or_else(|| {
+        RusticolError::integrity(format!(
+            "compiled Direct-Arena {context} component {component} is out of bounds"
+        ))
+    })?;
+    *last = Some(last.unwrap_or(first).max(event));
+    Ok(())
+}
+
+fn validate_compiled_current_layout(
+    layout: &CompiledDirectCurrentLayout,
+    lifetimes: &[CompiledDirectCurrentLifetime],
+    stages: &[LoadedStage],
+    amplitude: &LoadedStage,
+) -> RusticolResult<()> {
+    if layout.physical_component_count == 0
+        || layout.live_component_count != lifetimes.len()
+        || layout.canonical_to_physical.is_empty()
+    {
+        return Err(RusticolError::integrity(
+            "compiled Direct-Arena current-liveness accounting is inconsistent",
+        ));
+    }
+    let mut physical_chains =
+        vec![Vec::<CompiledDirectCurrentLifetime>::new(); layout.physical_component_count as usize];
+    for lifetime in lifetimes {
+        if lifetime.first_event > lifetime.last_event {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena current component {} has a reversed lifetime",
+                lifetime.canonical_component
+            )));
+        }
+        let physical = layout.physical_component(lifetime.canonical_component)?;
+        physical_chains
+            .get_mut(physical as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "compiled Direct-Arena liveness assignment exceeds physical storage",
+                )
+            })?
+            .push(*lifetime);
+    }
+    for chain in &mut physical_chains {
+        chain.sort_unstable_by_key(|lifetime| (lifetime.first_event, lifetime.canonical_component));
+        for pair in chain.windows(2) {
+            if pair[0].last_event >= pair[1].first_event {
+                return Err(RusticolError::integrity(format!(
+                    "compiled Direct-Arena live current components {} and {} alias physical plane",
+                    pair[0].canonical_component, pair[1].canonical_component
+                )));
+            }
+        }
+    }
+    for (stage_index, stage) in stages.iter().enumerate() {
+        validate_stage_physical_aliases(
+            layout,
+            stage,
+            &format!("compiled Direct-Arena stage {stage_index}"),
+        )?;
+    }
+    validate_stage_physical_aliases(layout, amplitude, "compiled Direct-Arena amplitude stage")?;
+    Ok(())
+}
+
+fn validate_stage_physical_aliases(
+    layout: &CompiledDirectCurrentLayout,
+    stage: &LoadedStage,
+    context: &str,
+) -> RusticolResult<()> {
+    let mut canonical_inputs = BTreeSet::new();
+    let mut canonical_outputs = BTreeSet::new();
+    for leaf in &stage.leaf_plans {
+        for &component in &leaf.input_current_components {
+            canonical_inputs.insert(component);
+        }
+        for &component in &leaf.output_current_components {
+            if !canonical_outputs.insert(component) {
+                return Err(RusticolError::integrity(format!(
+                    "{context} repeats an output current component"
+                )));
+            }
+        }
+    }
+    let mut inputs = BTreeSet::new();
+    for component in canonical_inputs {
+        if !inputs.insert(layout.physical_component(component)?) {
+            return Err(RusticolError::integrity(format!(
+                "{context} aliases distinct live input current components"
+            )));
+        }
+    }
+    let mut outputs = BTreeSet::new();
+    for component in canonical_outputs {
+        if !outputs.insert(layout.physical_component(component)?) {
+            return Err(RusticolError::integrity(format!(
+                "{context} aliases distinct output current components"
+            )));
+        }
+    }
+    if inputs.iter().any(|component| outputs.contains(component)) {
+        return Err(RusticolError::integrity(format!(
+            "{context} aliases an input and output current component"
+        )));
+    }
+    Ok(())
+}
+
+fn point_count_u32(point_count: usize, active: u32) -> RusticolResult<u32> {
+    let point_count = u32::try_from(point_count)
+        .map_err(|_| RusticolError::invalid_argument("compiled point count exceeds u32"))?;
+    if point_count == 0 || point_count != active {
+        return Err(RusticolError::invalid_argument(
+            "compiled Direct-Arena point count does not match the active tile",
+        ));
+    }
+    Ok(point_count)
+}
+
+fn evaluate_bound_stage_leaves(
+    stage: &mut BoundStage,
+    point_count: u32,
+    selected: &[usize],
+    traffic: &mut CompiledDirectPrototypeTraffic,
+) -> RusticolResult<()> {
+    for &leaf_index in selected {
+        let broadcast_bytes = stage.leaves[leaf_index].evaluate(0, point_count)?;
+        traffic.scalar_broadcast_fill_bytes = traffic
+            .scalar_broadcast_fill_bytes
+            .checked_add(broadcast_bytes)
+            .ok_or_else(|| {
+                RusticolError::internal("compiled scalar broadcast traffic counter overflows u64")
+            })?;
+        traffic.leaf.record_call(1, point_count);
+    }
+    Ok(())
+}
+
+fn intersect_helicity_color_schedules(
+    helicity: &CompiledDirectValidatedSchedule,
+    colors: &[&CompiledDirectValidatedSchedule],
+) -> RusticolResult<(Vec<Vec<usize>>, Vec<usize>)> {
+    if colors
+        .iter()
+        .any(|color| color.active_stage_leaves.len() != helicity.active_stage_leaves.len())
+    {
+        return Err(RusticolError::integrity(
+            "compiled Direct-Arena selector schedules have different stage counts",
+        ));
+    }
+    let intersect = |selected: &[usize], union: BTreeSet<usize>| {
+        selected
+            .iter()
+            .copied()
+            .filter(|id| union.contains(id))
+            .collect()
+    };
+    let stages = helicity
+        .active_stage_leaves
+        .iter()
+        .enumerate()
+        .map(|(index, leaves)| {
+            intersect(
+                leaves,
+                colors
+                    .iter()
+                    .flat_map(|color| color.active_stage_leaves[index].iter().copied())
+                    .collect(),
+            )
+        })
+        .collect();
+    let amplitude = intersect(
+        &helicity.active_amplitude_leaves,
+        colors
+            .iter()
+            .flat_map(|color| color.active_amplitude_leaves.iter().copied())
+            .collect(),
+    );
+    Ok((stages, amplitude))
+}
+
+fn validate_schedule<S: DirectStagePlan>(
+    stages: &[S],
+    amplitude: &S,
+    value_component_count: usize,
+    source_components: &[usize],
+    amplitude_component_count: usize,
+    active_stage_leaves: &[Vec<usize>],
+    active_amplitude_leaves: &[usize],
+) -> RusticolResult<CompiledDirectValidatedSchedule> {
+    if active_stage_leaves.len() != stages.len() {
+        return Err(RusticolError::integrity(
+            "compiled Direct-Arena schedule has the wrong stage count",
+        ));
+    }
+    let mut produced = BTreeSet::new();
+    for (stage_index, stage) in stages.iter().enumerate() {
+        for (leaf_index, leaf) in stage.leaf_plans().iter().enumerate() {
+            for &component in &leaf.output_current_components {
+                if !produced.insert(component) {
+                    return Err(RusticolError::integrity(format!(
+                        "compiled Direct-Arena stage {stage_index} leaf {leaf_index} duplicates \
+                         producer for current component {component}"
+                    )));
+                }
+            }
+        }
+    }
+    let declared_sources = source_components.iter().copied().collect::<BTreeSet<_>>();
+    if declared_sources.len() != source_components.len()
+        || declared_sources
+            .iter()
+            .any(|component| *component >= value_component_count || produced.contains(component))
+    {
+        return Err(RusticolError::integrity(
+            "compiled Direct-Arena source ownership aliases or exceeds produced current storage",
+        ));
+    }
+    // Value storage is a stable global numbering space and can contain
+    // components omitted by closure pruning. Such holes are neither sources
+    // nor produced values. They are valid only while no selected leaf reads
+    // them; the ordered prerequisite checks below enforce that invariant.
+    let mut available = declared_sources;
+    let mut validated_stages = Vec::with_capacity(stages.len());
+    for (stage_index, (stage, selected)) in stages.iter().zip(active_stage_leaves).enumerate() {
+        validate_sorted_leaf_indices(
+            selected,
+            stage.leaf_plans().len(),
+            &format!("compiled Direct-Arena stage {stage_index} schedule"),
+        )?;
+        let mut stage_outputs = BTreeSet::new();
+        for &leaf_index in selected {
+            let leaf = &stage.leaf_plans()[leaf_index];
+            let missing = leaf
+                .input_current_components
+                .iter()
+                .copied()
+                .filter(|component| !available.contains(component))
+                .collect::<Vec<_>>();
+            if !missing.is_empty() {
+                return Err(RusticolError::integrity(format!(
+                    "compiled Direct-Arena stage {stage_index} leaf {leaf_index} is missing \
+                     prerequisite current components {missing:?}"
+                )));
+            }
+            stage_outputs.extend(leaf.output_current_components.iter().copied());
+        }
+        available.extend(stage_outputs);
+        validated_stages.push(selected.clone().into_boxed_slice());
+    }
+    validate_sorted_leaf_indices(
+        active_amplitude_leaves,
+        amplitude.leaf_plans().len(),
+        "compiled Direct-Arena amplitude schedule",
+    )?;
+    let mut selected_amplitudes = BTreeSet::new();
+    for &leaf_index in active_amplitude_leaves {
+        let leaf = &amplitude.leaf_plans()[leaf_index];
+        let missing = leaf
+            .input_current_components
+            .iter()
+            .copied()
+            .filter(|component| !available.contains(component))
+            .collect::<Vec<_>>();
+        if !missing.is_empty() {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena amplitude leaf {leaf_index} is missing prerequisite \
+                 current components {missing:?}"
+            )));
+        }
+        selected_amplitudes.extend(leaf.output_amplitude_components.iter().copied());
+    }
+    if selected_amplitudes
+        .iter()
+        .any(|component| *component >= amplitude_component_count)
+    {
+        return Err(RusticolError::integrity(
+            "compiled Direct-Arena amplitude schedule exceeds canonical output planes",
+        ));
+    }
+    let inactive_amplitude_components = (0..amplitude_component_count)
+        .filter(|component| !selected_amplitudes.contains(component))
+        .collect::<Vec<_>>()
+        .into_boxed_slice();
+    Ok(CompiledDirectValidatedSchedule {
+        active_stage_leaves: validated_stages.into_boxed_slice(),
+        active_amplitude_leaves: active_amplitude_leaves.to_vec().into_boxed_slice(),
+        inactive_amplitude_components,
+    })
+}
+
+fn validate_sorted_leaf_indices(
+    selected: &[usize],
+    leaf_count: usize,
+    label: &str,
+) -> RusticolResult<()> {
+    let mut previous = None;
+    for &index in selected {
+        if index >= leaf_count || previous.is_some_and(|value| value >= index) {
+            return Err(RusticolError::integrity(format!(
+                "{label} is not sorted, unique, and in bounds"
+            )));
+        }
+        previous = Some(index);
+    }
+    Ok(())
+}
+
+fn evaluate_validated_schedule(
+    stages: &mut [BoundStage],
+    amplitude: &mut BoundStage,
+    schedule: &CompiledDirectValidatedSchedule,
+    point_count: u32,
+    traffic: &mut CompiledDirectPrototypeTraffic,
+) -> RusticolResult<()> {
+    for (stage, selected) in stages.iter_mut().zip(&schedule.active_stage_leaves) {
+        evaluate_bound_stage_leaves(stage, point_count, selected, traffic)?;
+    }
+    evaluate_bound_stage_leaves(
+        amplitude,
+        point_count,
+        &schedule.active_amplitude_leaves,
+        traffic,
+    )?;
+    traffic.leaf.validate_direct()
+}
+
+fn load_stage(
+    stage: &GenericSerializedStageEvaluatorManifest,
+    is_amplitude: bool,
+    payloads: &EvaluatorPayloadStore,
+    value_component_count: usize,
+    momentum_component_count: usize,
+    amplitude_component_count: usize,
+    structural_zero_components: &BTreeSet<usize>,
+) -> RusticolResult<LoadedStage> {
+    let direct = stage.compiled_plane_arena.as_ref().ok_or_else(|| {
+        RusticolError::integrity(format!(
+            "compiled Direct-Arena stage {:?} has no serialized plane bindings",
+            stage.evaluator_label
+        ))
+    })?;
+    if stage.parameter_layout != "stage-local-value-momentum"
+        || direct.input_bindings.len() != stage.parameter_count
+    {
+        return Err(RusticolError::compatibility(format!(
+            "compiled Direct-Arena stage {:?} requires complete serialized input bindings",
+            stage.evaluator_label
+        )));
+    }
+    let mut components = vec![None; stage.parameter_count];
+    for component in &direct.input_bindings {
+        if component.parameter_index >= components.len()
+            || components[component.parameter_index]
+                .replace(component)
+                .is_some()
+        {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena stage {:?} has invalid serialized input bindings",
+                stage.evaluator_label
+            )));
+        }
+    }
+    if components.iter().any(Option::is_none) {
+        return Err(RusticolError::integrity(format!(
+            "compiled Direct-Arena stage {:?} has incomplete serialized input bindings",
+            stage.evaluator_label
+        )));
+    }
+
+    let output_limit = if is_amplitude {
+        amplitude_component_count
+    } else {
+        value_component_count
+    };
+    let mut output_components = vec![None; stage.output_length];
+    let mut seen_output_components = BTreeSet::new();
+    let expected_arena = if is_amplitude { "amplitude" } else { "current" };
+    for binding in &direct.output_bindings {
+        if binding.output_index >= output_components.len()
+            || binding.component >= output_limit
+            || binding.arena != expected_arena
+        {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena stage {:?} has an invalid serialized output binding",
+                stage.evaluator_label
+            )));
+        }
+        if !seen_output_components.insert(binding.component) {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena stage {:?} aliases output component {}",
+                stage.evaluator_label, binding.component
+            )));
+        }
+        if output_components[binding.output_index]
+            .replace(binding)
+            .is_some()
+        {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena stage {:?} has duplicate serialized output indices",
+                stage.evaluator_label
+            )));
+        }
+    }
+    if output_components.iter().any(Option::is_none) {
+        return Err(RusticolError::integrity(format!(
+            "compiled Direct-Arena stage {:?} does not cover every output",
+            stage.evaluator_label
+        )));
+    }
+    if is_amplitude
+        && (stage.output_length != amplitude_component_count
+            || seen_output_components.len() != amplitude_component_count
+            || seen_output_components
+                .iter()
+                .copied()
+                .ne(0..amplitude_component_count))
+    {
+        return Err(RusticolError::integrity(format!(
+            "compiled Direct-Arena amplitude stage {:?} is not a complete canonical output \
+             permutation",
+            stage.evaluator_label
+        )));
+    }
+
+    let leaf_layout = stage.evaluator.leaf_layout()?;
+    let mut loaded = Vec::with_capacity(leaf_layout.len());
+    let mut leaf_plans = Vec::with_capacity(leaf_layout.len());
+    let mut output_cursor = 0usize;
+    for (leaf_index, leaf) in leaf_layout.into_iter().enumerate() {
+        let (input_len, output_len) = leaf.evaluator.io_len()?;
+        let direct_leaf = direct.leaves.get(leaf_index).ok_or_else(|| {
+            RusticolError::integrity("compiled plane-arena leaf bindings are incomplete")
+        })?;
+        let direct_input_indices = direct_leaf.input_indices.as_slice();
+        let direct_output_range = direct_leaf.output_start..direct_leaf.output_stop;
+        let direct_input_len = direct_leaf.input_len;
+        let direct_output_len = direct_leaf.output_len;
+        if direct_input_indices.len() != direct_input_len {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena stage {:?} leaf input map has the wrong length",
+                stage.evaluator_label
+            )));
+        }
+        if direct_input_len != input_len
+            || direct_output_len != output_len
+            || direct_input_indices != leaf.input_indices
+            || direct_output_range != leaf.output_range
+        {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena stage {:?} leaf bindings disagree with canonical layout",
+                stage.evaluator_label
+            )));
+        }
+        if direct_output_range.start != output_cursor
+            || direct_output_range.end
+                != output_cursor
+                    .checked_add(direct_output_len)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "compiled Direct-Arena leaf output range overflows",
+                        )
+                    })?
+            || direct_output_range.end > output_components.len()
+        {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena canonical leaf output range disagrees with the stage",
+            ));
+        }
+        let output_stop = direct_output_range.end;
+        let scalar_values_per_point = direct_input_len
+            .checked_add(direct_output_len)
+            .and_then(|value| value.checked_mul(2))
+            .ok_or_else(|| {
+                RusticolError::integrity("compiled Direct-Arena leaf-local footprint overflows")
+            })?;
+
+        let mut input_currents = BTreeSet::new();
+        let mut input_components = Vec::with_capacity(direct_input_len);
+        for &parameter_index in direct_input_indices {
+            let component = components
+                .get(parameter_index)
+                .and_then(|value| *value)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "compiled Direct-Arena leaf references an absent stage input",
+                    )
+                })?;
+            if component.kind == "value"
+                && !structural_zero_components.contains(&component.global_component)
+            {
+                input_currents.insert(component.global_component);
+            }
+            input_components.push(component);
+        }
+        let canonical_outputs = output_components[output_cursor..output_stop]
+            .iter()
+            .map(|value| value.expect("output coverage validated"))
+            .collect::<Vec<_>>();
+
+        let loaded_leaf = match leaf.evaluator {
+            #[cfg(feature = "f64-symjit")]
+            EvaluatorManifest::SymjitApplication {
+                runtime_capability,
+                application_abi,
+                element_layout,
+                batch_layout,
+                compiler_type,
+                translation_mode,
+                optimization_level,
+                word_bits,
+                endianness,
+                required_defuns,
+                plane_application,
+                ..
+            } => {
+                if *optimization_level > 3 {
+                    return Err(RusticolError::compatibility(
+                        "compiled-plane-arena-v1 supports compiled JIT optimization levels 0 \
+                         through 3",
+                    ));
+                }
+                validate_manifest_metadata(&SymjitApplicationMetadata {
+                    runtime_capability,
+                    application_abi,
+                    input_len,
+                    output_len,
+                    element_layout,
+                    batch_layout,
+                    compiler_type,
+                    translation_mode,
+                    optimization_level: *optimization_level,
+                    word_bits: *word_bits,
+                    endianness,
+                    required_defuns,
+                })?;
+                let plane_application = plane_application.as_ref().ok_or_else(|| {
+                    RusticolError::compatibility(
+                        "compiled SymJIT leaf predates the standard plane \
+                         application ABI; regenerate the artifact",
+                    )
+                })?;
+                plane_application.validate(input_len, output_len, *optimization_level)?;
+                if direct_leaf.application_path != plane_application.application_path
+                    || direct_leaf.source_application_abi != plane_application.application_abi
+                    || direct_leaf.source_application_abi != direct.source_application_abi
+                    || direct.source_application_abi != SYMJIT_PLANE_APPLICATION_ABI
+                    || direct.application_abi != COMPILED_PLANE_DIRECT_APPLICATION_ABI
+                    || direct_leaf.optimization_level != *optimization_level
+                    || direct_leaf.direct_codegen_optimization_level != *optimization_level
+                {
+                    return Err(RusticolError::integrity(
+                        "compiled SymJIT Direct-Arena leaf identity is inconsistent",
+                    ));
+                }
+                let mut source_inputs = Vec::with_capacity(direct_input_len * 2);
+                let mut plane_bindings = Vec::new();
+                let mut scalar_bindings = Vec::new();
+                for component in &input_components {
+                    append_component_bindings(
+                        component,
+                        value_component_count,
+                        momentum_component_count,
+                        structural_zero_components,
+                        &mut source_inputs,
+                        &mut plane_bindings,
+                        &mut scalar_bindings,
+                    )?;
+                }
+                let outputs = symjit_output_bindings(&canonical_outputs)?;
+                let source = payloads.source(&plane_application.application_path)?;
+                let bytes = source.read()?;
+                LoadedCompiledDirectLeaf::Symjit(
+                    LoadedSymjitCompiledDirectStage::load_source_bytes(
+                        bytes.as_ref(),
+                        PathBuf::from(source.display_name()),
+                        &direct_leaf.source_application_abi,
+                        direct_leaf.optimization_level,
+                        plane_application.compression,
+                        source_inputs,
+                        plane_bindings,
+                        scalar_bindings,
+                        outputs,
+                    )?,
+                )
+            }
+            #[cfg(feature = "f64-compiled")]
+            EvaluatorManifest::CompiledComplex {
+                runtime_capability,
+                function_name,
+                number_type,
+                native_direct_application: Some(application),
+                ..
+            } => {
+                if !matches!(
+                    runtime_capability.as_str(),
+                    SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY
+                        | SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY
+                ) || number_type != "complex"
+                {
+                    return Err(RusticolError::compatibility(
+                        "compiled native Direct-Arena leaf has an incompatible backend",
+                    ));
+                }
+                application.validate(function_name, input_len, output_len)?;
+                if direct_leaf.optimization_level != 3
+                    || direct_leaf.direct_codegen_optimization_level != 3
+                    || direct_leaf.application_path != application.library_path
+                    || direct_leaf.source_application_abi != application.application_abi
+                    || direct.source_application_abi != application.application_abi
+                    || direct.application_abi != application.application_abi
+                {
+                    return Err(RusticolError::integrity(
+                        "compiled native Direct-Arena leaf identity is inconsistent",
+                    ));
+                }
+                let mut plane_bindings = Vec::new();
+                let mut scalar_bindings = Vec::new();
+                for component in &input_components {
+                    append_native_component_bindings(
+                        component,
+                        value_component_count,
+                        momentum_component_count,
+                        structural_zero_components,
+                        &mut plane_bindings,
+                        &mut scalar_bindings,
+                    )?;
+                }
+                let outputs = native_output_bindings(&canonical_outputs)?;
+                let library = payloads.load_native_library(&application.library_path)?;
+                LoadedCompiledDirectLeaf::Native(LoadedNativeCompiledDirectStage::load(
+                    library,
+                    function_name,
+                    &application.application_abi,
+                    plane_bindings,
+                    scalar_bindings,
+                    outputs,
+                )?)
+            }
+            #[cfg(feature = "f64-compiled")]
+            EvaluatorManifest::CompiledComplex {
+                native_direct_application: None,
+                ..
+            } => {
+                return Err(RusticolError::compatibility(
+                    "compiled native Direct-Arena leaf has no plane-native DirectApplication; \
+                     regenerate the artifact",
+                ));
+            }
+            _ => {
+                return Err(RusticolError::compatibility(format!(
+                    "compiled Direct-Arena stage {:?} contains an unsupported leaf",
+                    stage.evaluator_label
+                )));
+            }
+        };
+        let persistent_scalar_values_per_point = loaded_leaf.persistent_scalar_values_per_point();
+        loaded.push(loaded_leaf);
+        leaf_plans.push(DirectLeafPlan {
+            input_current_components: input_currents
+                .into_iter()
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            output_current_components: if is_amplitude {
+                Box::new([])
+            } else {
+                output_components[output_cursor..output_stop]
+                    .iter()
+                    .map(|value| value.expect("output coverage validated").component)
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice()
+            },
+            output_amplitude_components: if is_amplitude {
+                output_components[output_cursor..output_stop]
+                    .iter()
+                    .map(|value| value.expect("output coverage validated").component)
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice()
+            } else {
+                Box::new([])
+            },
+            scalar_values_per_point,
+            persistent_scalar_values_per_point,
+        });
+        output_cursor = output_stop;
+    }
+    if output_cursor != stage.output_length {
+        return Err(RusticolError::integrity(format!(
+            "compiled Direct-Arena stage {:?} leaf outputs do not cover the stage",
+            stage.evaluator_label
+        )));
+    }
+    Ok(LoadedStage {
+        leaves: loaded,
+        leaf_plans,
+    })
+}
+
+#[cfg(feature = "f64-symjit")]
+fn symjit_output_bindings(
+    outputs: &[&CompiledPlaneOutputBindingManifest],
+) -> RusticolResult<Vec<CompiledDirectOutputBinding>> {
+    let mut bindings = Vec::with_capacity(outputs.len() * 2);
+    for output in outputs {
+        let component = u32::try_from(output.component)
+            .map_err(|_| RusticolError::integrity("compiled output plane index exceeds u32"))?;
+        let plane = |imaginary| match output.arena.as_str() {
+            "current" => Ok(CompiledDirectArenaPlane::Current {
+                component,
+                imaginary,
+            }),
+            "amplitude" => Ok(CompiledDirectArenaPlane::Amplitude {
+                component,
+                imaginary,
+            }),
+            _ => Err(RusticolError::integrity(
+                "compiled output binding names an unsupported arena",
+            )),
+        };
+        bindings.push(CompiledDirectOutputBinding(plane(false)?));
+        bindings.push(CompiledDirectOutputBinding(plane(true)?));
+    }
+    Ok(bindings)
+}
+
+#[cfg(feature = "f64-compiled")]
+fn native_output_bindings(
+    outputs: &[&CompiledPlaneOutputBindingManifest],
+) -> RusticolResult<Vec<NativeCompiledDirectOutputBinding>> {
+    let mut bindings = Vec::with_capacity(outputs.len() * 2);
+    for output in outputs {
+        let component = u32::try_from(output.component)
+            .map_err(|_| RusticolError::integrity("compiled output plane index exceeds u32"))?;
+        let plane = |imaginary| match output.arena.as_str() {
+            "current" => Ok(NativeCompiledDirectArenaPlane::Current {
+                component,
+                imaginary,
+            }),
+            "amplitude" => Ok(NativeCompiledDirectArenaPlane::Amplitude {
+                component,
+                imaginary,
+            }),
+            _ => Err(RusticolError::integrity(
+                "compiled output binding names an unsupported arena",
+            )),
+        };
+        bindings.push(NativeCompiledDirectOutputBinding(plane(false)?));
+        bindings.push(NativeCompiledDirectOutputBinding(plane(true)?));
+    }
+    Ok(bindings)
+}
+
+#[cfg(feature = "f64-compiled")]
+fn append_native_component_bindings(
+    component: &CompiledPlaneInputBindingManifest,
+    value_component_count: usize,
+    momentum_component_count: usize,
+    structural_zero_components: &BTreeSet<usize>,
+    planes: &mut Vec<NativeCompiledDirectPlaneBinding>,
+    scalars: &mut Vec<NativeCompiledDirectScalarBinding>,
+) -> RusticolResult<()> {
+    match component.kind.as_str() {
+        "value" => {
+            if component.global_component >= value_component_count {
+                return Err(RusticolError::integrity(
+                    "compiled Direct-Arena value input is outside current planes",
+                ));
+            }
+            if structural_zero_components.contains(&component.global_component) {
+                planes.push(NativeCompiledDirectPlaneBinding::Zero);
+                if !component.real_valued {
+                    planes.push(NativeCompiledDirectPlaneBinding::Zero);
+                }
+                return Ok(());
+            }
+            let current = |imaginary| {
+                NativeCompiledDirectPlaneBinding::Arena(NativeCompiledDirectArenaPlane::Current {
+                    component: component.global_component as u32,
+                    imaginary,
+                })
+            };
+            planes.push(current(false));
+            if !component.real_valued {
+                planes.push(current(true));
+            }
+        }
+        "momentum" => {
+            let local = component
+                .global_component
+                .checked_sub(value_component_count)
+                .filter(|index| *index < momentum_component_count)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "compiled Direct-Arena momentum input is outside momentum planes",
+                    )
+                })?;
+            planes.push(NativeCompiledDirectPlaneBinding::Momentum {
+                form: u32::try_from(local / 4)
+                    .map_err(|_| RusticolError::integrity("compiled momentum form exceeds u32"))?,
+                lorentz_component: (local % 4) as u16,
+            });
+            if !component.real_valued {
+                planes.push(NativeCompiledDirectPlaneBinding::Zero);
+            }
+        }
+        "model_parameter" => {
+            let index = u32::try_from(component.source_id).map_err(|_| {
+                RusticolError::integrity("compiled model parameter index exceeds u32")
+            })?;
+            scalars.push(NativeCompiledDirectScalarBinding::Parameter {
+                index,
+                imaginary: false,
+            });
+            if !component.real_valued {
+                scalars.push(NativeCompiledDirectScalarBinding::Parameter {
+                    index,
+                    imaginary: true,
+                });
+            }
+        }
+        kind => {
+            return Err(RusticolError::compatibility(format!(
+                "compiled Direct-Arena does not support input kind {kind:?}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+#[cfg(feature = "f64-symjit")]
+fn append_component_bindings(
+    component: &CompiledPlaneInputBindingManifest,
+    value_component_count: usize,
+    momentum_component_count: usize,
+    structural_zero_components: &BTreeSet<usize>,
+    source_inputs: &mut Vec<CompiledDirectSourceInputBinding>,
+    planes: &mut Vec<CompiledDirectPlaneBinding>,
+    scalars: &mut Vec<CompiledDirectScalarBinding>,
+) -> RusticolResult<()> {
+    fn push_plane(
+        source_inputs: &mut Vec<CompiledDirectSourceInputBinding>,
+        planes: &mut Vec<CompiledDirectPlaneBinding>,
+        binding: CompiledDirectPlaneBinding,
+    ) -> RusticolResult<()> {
+        let index = u32::try_from(planes.len()).map_err(|_| {
+            RusticolError::integrity("compiled Direct-Arena plane binding count exceeds u32")
+        })?;
+        source_inputs.push(CompiledDirectSourceInputBinding::Plane(index));
+        planes.push(binding);
+        Ok(())
+    }
+    fn push_scalar(
+        source_inputs: &mut Vec<CompiledDirectSourceInputBinding>,
+        scalars: &mut Vec<CompiledDirectScalarBinding>,
+        binding: CompiledDirectScalarBinding,
+    ) -> RusticolResult<()> {
+        let index = u32::try_from(scalars.len()).map_err(|_| {
+            RusticolError::integrity("compiled Direct-Arena scalar binding count exceeds u32")
+        })?;
+        source_inputs.push(CompiledDirectSourceInputBinding::Scalar(index));
+        scalars.push(binding);
+        Ok(())
+    }
+
+    match component.kind.as_str() {
+        "value" => {
+            if component.global_component >= value_component_count {
+                return Err(RusticolError::integrity(
+                    "compiled Direct-Arena value input is outside current planes",
+                ));
+            }
+            if structural_zero_components.contains(&component.global_component) {
+                push_plane(source_inputs, planes, CompiledDirectPlaneBinding::Zero)?;
+                push_plane(source_inputs, planes, CompiledDirectPlaneBinding::Zero)?;
+                return Ok(());
+            }
+            let current = |imaginary| {
+                CompiledDirectPlaneBinding::Arena(CompiledDirectArenaPlane::Current {
+                    component: component.global_component as u32,
+                    imaginary,
+                })
+            };
+            push_plane(source_inputs, planes, current(false))?;
+            push_plane(source_inputs, planes, current(true))?;
+        }
+        "momentum" => {
+            let local = component
+                .global_component
+                .checked_sub(value_component_count)
+                .filter(|index| *index < momentum_component_count)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "compiled Direct-Arena momentum input is outside momentum planes",
+                    )
+                })?;
+            push_plane(
+                source_inputs,
+                planes,
+                CompiledDirectPlaneBinding::Momentum {
+                    form: u32::try_from(local / 4).map_err(|_| {
+                        RusticolError::integrity("compiled momentum form exceeds u32")
+                    })?,
+                    lorentz_component: (local % 4) as u16,
+                },
+            )?;
+            push_plane(source_inputs, planes, CompiledDirectPlaneBinding::Zero)?;
+        }
+        "model_parameter" => {
+            let index = u32::try_from(component.source_id).map_err(|_| {
+                RusticolError::integrity("compiled model parameter index exceeds u32")
+            })?;
+            push_scalar(
+                source_inputs,
+                scalars,
+                CompiledDirectScalarBinding::Parameter {
+                    index,
+                    imaginary: false,
+                },
+            )?;
+            push_scalar(
+                source_inputs,
+                scalars,
+                CompiledDirectScalarBinding::Parameter {
+                    index,
+                    imaginary: true,
+                },
+            )?;
+        }
+        kind => {
+            return Err(RusticolError::compatibility(format!(
+                "compiled Direct-Arena does not support input kind {kind:?}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+#[cfg(all(test, feature = "f64-symjit"))]
+mod tests {
+    fn momentum_slot(start: usize, labels: &[usize]) -> GenericMomentumSlotManifest {
+        GenericMomentumSlotManifest {
+            momentum_slot_id: start / 4,
+            momentum_mask: 0,
+            external_labels: labels.to_vec(),
+            component_start: start,
+            component_stop: start + 4,
+            real_valued: true,
+        }
+    }
+
+    #[test]
+    fn compiled_momentum_planes_preserve_scalar_order_crossing_and_partial_tiles() {
+        let nested = (0..19)
+            .map(|point| {
+                let offset = point as f64;
+                vec![
+                    [1e16, -0.0, 3.0 + offset, -1e16],
+                    [-1e16, 0.0, 5.0 - offset, 1.0],
+                    [1.0, -0.0, -7.0, 1e16],
+                ]
+            })
+            .collect::<Vec<_>>();
+        let flat = nested
+            .iter()
+            .flatten()
+            .flatten()
+            .copied()
+            .collect::<Vec<_>>();
+        let crossing = [
+            InputCrossingMapEntry {
+                target_index: 0,
+                source_index: 2,
+                sign: -1.0,
+            },
+            InputCrossingMapEntry {
+                target_index: 1,
+                source_index: 0,
+                sign: 1.0,
+            },
+            InputCrossingMapEntry {
+                target_index: 2,
+                source_index: 1,
+                sign: -1.0,
+            },
+        ];
+        let views = [
+            F64MomentumBatchView::from_nested(&nested, 3).unwrap(),
+            F64MomentumBatchView::from_contiguous_prevalidated(&flat, 19, 3, None).unwrap(),
+            F64MomentumBatchView::from_contiguous_prevalidated(&flat, 19, 3, Some(&crossing))
+                .unwrap(),
+        ];
+        let slots = [
+            momentum_slot(0, &[1]),
+            momentum_slot(4, &[3, 1, 2]),
+            momentum_slot(8, &[3, 2, 1, 3]),
+            momentum_slot(16, &[]),
+        ];
+        let initial = [true, false, true];
+        let stride = 24;
+        let mut actual = vec![23.0_f64; 20 * stride];
+        let pointer = actual.as_ptr();
+        for view in views {
+            for count in [1, 17, 3, 1] {
+                let batch = view.subview(1, 1 + count).unwrap();
+                let mut expected = actual.clone();
+                for slot in &slots {
+                    for point_index in 0..count {
+                        let point = batch.point(point_index);
+                        let mut momentum = [0.0; 4];
+                        for &label in &slot.external_labels {
+                            let external = label - 1;
+                            let sign = if initial[external] { -1.0 } else { 1.0 };
+                            for (target, value) in
+                                momentum.iter_mut().zip(point.momentum(external).unwrap())
+                            {
+                                *target += sign * value;
+                            }
+                        }
+                        for (component, value) in momentum.into_iter().enumerate() {
+                            expected[(slot.component_start + component) * stride + point_index] =
+                                value;
+                        }
+                    }
+                }
+                fill_compiled_momentum_planes(batch, &slots, &initial, 20, stride, &mut actual)
+                    .unwrap();
+                assert_eq!(actual.as_ptr(), pointer);
+                for (&actual, expected) in actual.iter().zip(expected) {
+                    assert_eq!(actual.to_bits(), expected.to_bits());
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn compiled_momentum_planes_reject_invalid_generated_ranges_and_labels() {
+        let values = [0.0; 24];
+        let batch =
+            F64MomentumBatchView::from_contiguous_prevalidated(&values, 2, 3, None).unwrap();
+        let mut output = [0.0; 32];
+        let valid = momentum_slot(0, &[1]);
+        for slot in [
+            momentum_slot(8, &[1]),
+            momentum_slot(0, &[0]),
+            momentum_slot(0, &[4]),
+            GenericMomentumSlotManifest {
+                component_stop: 3,
+                ..valid.clone()
+            },
+            GenericMomentumSlotManifest {
+                component_stop: 0,
+                component_start: 4,
+                ..valid.clone()
+            },
+        ] {
+            for input in [batch, batch.subview(0, 1).unwrap()] {
+                assert!(
+                    fill_compiled_momentum_planes(
+                        input,
+                        std::slice::from_ref(&slot),
+                        &[true; 3],
+                        8,
+                        4,
+                        &mut output,
+                    )
+                    .is_err()
+                );
+            }
+        }
+        assert!(
+            fill_compiled_momentum_planes(
+                batch,
+                std::slice::from_ref(&valid),
+                &[],
+                8,
+                4,
+                &mut output,
+            )
+            .is_err()
+        );
+        assert!(
+            fill_compiled_momentum_planes(
+                batch,
+                std::slice::from_ref(&valid),
+                &[true; 3],
+                8,
+                4,
+                &mut output[..31],
+            )
+            .is_err()
+        );
+        assert!(
+            fill_compiled_momentum_planes(batch, &[valid], &[true; 3], 8, 1, &mut output[..8],)
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn joint_selection_intersects_helicity_with_union_of_colors_in_leaf_order() {
+        let schedule =
+            |stages: Vec<Vec<usize>>, amplitudes: Vec<usize>| CompiledDirectValidatedSchedule {
+                active_stage_leaves: stages.into_iter().map(Vec::into_boxed_slice).collect(),
+                active_amplitude_leaves: amplitudes.into_boxed_slice(),
+                inactive_amplitude_components: Box::new([]),
+            };
+        let helicity = schedule(vec![vec![0, 1, 3], vec![0, 2]], vec![1, 2, 4]);
+        let first_color = schedule(vec![vec![0, 2], vec![0]], vec![1, 3]);
+        let second_color = schedule(vec![vec![0, 3], vec![1, 2]], vec![2, 3]);
+        let (stages, amplitudes) =
+            intersect_helicity_color_schedules(&helicity, &[&first_color, &second_color]).unwrap();
+        assert_eq!(stages, vec![vec![0, 3], vec![0, 2]]);
+        assert_eq!(amplitudes, vec![1, 2]);
+        let wrong_stages = schedule(vec![], vec![]);
+        assert!(intersect_helicity_color_schedules(&helicity, &[&wrong_stages]).is_err());
+    }
+    use super::super::evaluator::count_test_allocations;
+    use super::*;
+    use sha2::{Digest, Sha256};
+    use std::fs;
+    use std::process::Command;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use std::time::Instant;
+    use symjit::{Compiler, Config, Expr, Storage};
+
+    static TEST_DIRECTORY_ID: AtomicU64 = AtomicU64::new(0);
+
+    fn liveness_leaf(inputs: &[usize], outputs: &[usize]) -> DirectLeafPlan {
+        DirectLeafPlan {
+            input_current_components: inputs.to_vec().into_boxed_slice(),
+            output_current_components: outputs.to_vec().into_boxed_slice(),
+            output_amplitude_components: Box::new([]),
+            scalar_values_per_point: 1,
+            persistent_scalar_values_per_point: 0,
+        }
+    }
+
+    fn liveness_stage(leaves: Vec<DirectLeafPlan>) -> LoadedStage {
+        LoadedStage {
+            leaves: Vec::new(),
+            leaf_plans: leaves,
+        }
+    }
+
+    #[test]
+    fn stage_liveness_reuses_only_strictly_dead_current_planes() {
+        let stages = vec![
+            liveness_stage(vec![liveness_leaf(&[0], &[1])]),
+            liveness_stage(vec![liveness_leaf(&[1], &[2])]),
+        ];
+        let amplitude = liveness_stage(vec![liveness_leaf(&[2], &[])]);
+        let expected = derive_stage_current_layout(&stages, &amplitude, &[0], 5).unwrap();
+
+        assert_eq!(expected.physical_component_count, 2);
+        assert_eq!(expected.live_component_count, 3);
+        assert_eq!(expected.physical_component(0).unwrap(), 0);
+        assert_eq!(expected.physical_component(1).unwrap(), 1);
+        assert_eq!(expected.physical_component(2).unwrap(), 0);
+        assert_eq!(
+            expected.canonical_to_physical[3..],
+            [UNMAPPED_CURRENT_COMPONENT, UNMAPPED_CURRENT_COMPONENT]
+        );
+        for _ in 0..32 {
+            let actual = derive_stage_current_layout(&stages, &amplitude, &[0], 5).unwrap();
+            assert_eq!(actual.canonical_to_physical, expected.canonical_to_physical);
+            assert_eq!(
+                actual.physical_component_count,
+                expected.physical_component_count
+            );
+        }
+    }
+
+    #[test]
+    fn stage_liveness_preserves_arena_v1_whole_stage_no_aliasing() {
+        let stages = vec![
+            liveness_stage(vec![liveness_leaf(&[0], &[1]), liveness_leaf(&[0], &[2])]),
+            liveness_stage(vec![liveness_leaf(&[1, 2], &[3])]),
+        ];
+        let amplitude = liveness_stage(vec![liveness_leaf(&[3], &[])]);
+        let layout = derive_stage_current_layout(&stages, &amplitude, &[0], 4).unwrap();
+
+        let first_stage_planes = [0, 1, 2]
+            .into_iter()
+            .map(|component| layout.physical_component(component).unwrap())
+            .collect::<BTreeSet<_>>();
+        assert_eq!(
+            first_stage_planes.len(),
+            3,
+            "same-stage input and every output must remain disjoint"
+        );
+        assert_ne!(
+            layout.physical_component(1).unwrap(),
+            layout.physical_component(2).unwrap(),
+            "outputs from separate leaves still share the fused-stage no-alias contract"
+        );
+    }
+
+    #[test]
+    fn stage_liveness_rejects_a_current_use_without_a_producer() {
+        let stages = vec![liveness_stage(vec![liveness_leaf(&[1], &[2])])];
+        let amplitude = liveness_stage(vec![liveness_leaf(&[2], &[])]);
+        let error = derive_stage_current_layout(&stages, &amplitude, &[0], 3).unwrap_err();
+        assert!(error.message().contains("used before its producer"));
+    }
+
+    fn test_payload_directory() -> PathBuf {
+        let target = std::env::var_os("CARGO_TARGET_DIR")
+            .map(PathBuf::from)
+            .unwrap_or_else(|| PathBuf::from("target"));
+        target.join(format!(
+            "compiled-direct-engine-test-{}-{}",
+            std::process::id(),
+            TEST_DIRECTORY_ID.fetch_add(1, Ordering::Relaxed)
+        ))
+    }
+
+    fn source_application(inputs: &[Expr], outputs: &[Expr]) -> Vec<u8> {
+        let mut config = Config::default();
+        config.set_opt_level(3);
+        config.set_complex(true);
+        config.set_symbolica(true);
+        config.set_simd(true);
+        config.set_fast_complex(false);
+        config.set_compress(true);
+        let application = Compiler::with_config(config)
+            .compile_params(&[], outputs, inputs)
+            .unwrap();
+        assert_eq!(application.count_states, 0);
+        assert_eq!(application.count_params, inputs.len() * 2);
+        assert_eq!(application.count_obs, outputs.len() * 2);
+        let mut bytes = Vec::new();
+        application.save(&mut bytes).unwrap();
+        bytes
+    }
+
+    fn evaluator(
+        path: &str,
+        plane_path: &str,
+        plane_program: &str,
+        input_len: usize,
+        output_len: usize,
+    ) -> EvaluatorManifest {
+        EvaluatorManifest::SymjitApplication {
+            runtime_capability: SYMJIT_APPLICATION_RUNTIME_CAPABILITY.to_string(),
+            application_path: path.to_string(),
+            application_abi: SYMJIT_APPLICATION_STORAGE_ABI.to_string(),
+            input_len,
+            output_len,
+            element_layout: "complex-f64".to_string(),
+            batch_layout: "row-major".to_string(),
+            compiler_type: "native".to_string(),
+            translation_mode: "indirect".to_string(),
+            optimization_level: 3,
+            word_bits: 64,
+            endianness: "little".to_string(),
+            required_defuns: Vec::new(),
+            plane_application: Some(SymjitPlaneApplicationManifest {
+                application_path: plane_path.to_string(),
+                application_abi: SYMJIT_PLANE_APPLICATION_ABI.to_string(),
+                storage_abi: SYMJIT_APPLICATION_STORAGE_ABI.to_string(),
+                element_layout: "split-complex-plane-major".to_string(),
+                descriptor_order: "inputs-re-im-then-outputs-re-im".to_string(),
+                input_complex_count: input_len,
+                output_complex_count: output_len,
+                input_plane_count: input_len * 2,
+                output_plane_count: output_len * 2,
+                compiler_type: "native".to_string(),
+                translation_mode: "symbolica-structured-instructions".to_string(),
+                optimization_level: 3,
+                simd: true,
+                complex: true,
+                fast_math: true,
+                fast_complex: false,
+                compression: true,
+                threading: false,
+                direct_arena: true,
+                source_digest: format!("{:x}", Sha256::digest(plane_program.as_bytes())),
+                target: serde_json::json!({
+                    "word_bits": 64,
+                    "endianness": "little",
+                    "triple": "test-native",
+                    "cpu_features": [],
+                }),
+            }),
+            evaluator_state_path: None,
+            evaluator_state_runtime_capability: None,
+        }
+    }
+
+    fn native_direct_fixture() -> (PathBuf, String) {
+        let directory = test_payload_directory();
+        fs::create_dir_all(&directory).unwrap();
+        let source = directory.join("native_direct_leaf.cpp");
+        let library_name = if cfg!(target_os = "macos") {
+            "libnative_direct_leaf.dylib"
+        } else {
+            "libnative_direct_leaf.so"
+        };
+        let library = directory.join(library_name);
+        fs::write(
+            &source,
+            r#"#include <cstdint>
+struct Metadata {
+  std::uint32_t abi_version;
+  std::uint32_t struct_size;
+  std::uint32_t flags;
+  std::uint32_t input_plane_count;
+  std::uint32_t scalar_input_count;
+  std::uint32_t output_plane_count;
+  std::uint32_t simd_lane_width;
+  std::uint32_t reserved;
+};
+struct InputPlane { const double* values; };
+struct OutputPlane { double* values; };
+struct Scalar { const double* value; };
+extern "C" Metadata native_direct_leaf_direct_application_v1_metadata() noexcept {
+  return Metadata{1u, sizeof(Metadata), 63u, 2u, 0u, 2u, 2u, 0u};
+}
+extern "C" int native_direct_leaf_direct_application_v1(
+    const InputPlane* inputs, std::uint32_t input_count,
+    const Scalar*, std::uint32_t scalar_count,
+    const OutputPlane* outputs, std::uint32_t output_count,
+    std::uint32_t point_start, std::uint32_t point_count) noexcept {
+  if (inputs == nullptr || outputs == nullptr || input_count != 2u ||
+      scalar_count != 0u || output_count != 2u || point_count == 0u) return 2;
+  for (std::uint32_t offset = 0; offset < point_count; ++offset) {
+    const std::uint32_t point = point_start + offset;
+    outputs[0].values[point] = 2.0 * inputs[0].values[point];
+    outputs[1].values[point] = 2.0 * inputs[1].values[point];
+  }
+  return 0;
+}
+"#,
+        )
+        .unwrap();
+        let compiler = std::env::var("CXX").unwrap_or_else(|_| "c++".to_string());
+        let mut command = Command::new(compiler);
+        command.args(["-std=c++17", "-O3"]);
+        if cfg!(target_os = "macos") {
+            command.arg("-dynamiclib");
+        } else {
+            command.args(["-shared", "-fPIC"]);
+        }
+        let output = command
+            .arg(&source)
+            .arg("-o")
+            .arg(&library)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "could not compile native plane fixture: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        (directory, library_name.to_string())
+    }
+
+    fn native_evaluator(library_path: &str, runtime_capability: &str) -> EvaluatorManifest {
+        EvaluatorManifest::CompiledComplex {
+            runtime_capability: runtime_capability.to_string(),
+            function_name: "native_direct_leaf".to_string(),
+            input_len: 1,
+            output_len: 1,
+            library_path: "absent-dense-library".to_string(),
+            evaluator_state_path: None,
+            number_type: "complex".to_string(),
+            native_direct_application: Some(NativeCompiledDirectApplicationManifest {
+                application_abi:
+                    super::super::evaluator::native_compiled_direct::
+                        NATIVE_COMPILED_DIRECT_APPLICATION_ABI
+                        .to_string(),
+                function_name: "native_direct_leaf".to_string(),
+                source_path: "native_direct_leaf.cpp".to_string(),
+                library_path: library_path.to_string(),
+                target: NativeCompiledDirectTargetManifest {
+                    triple: crate::runtime_target_info().triple,
+                    cpu_features: Vec::new(),
+                },
+                evaluator_state_sha256: "a".repeat(64),
+                instruction_count: 1,
+                temporary_count: 0,
+                input_plane_count: 2,
+                scalar_input_count: 0,
+                output_plane_count: 2,
+                simd_lane_width: 2,
+                logical_stack_bytes: 32,
+                output_semantics: "factor-free-overwrite".to_string(),
+            }),
+        }
+    }
+
+    fn input_component(
+        kind: &str,
+        source_id: usize,
+        component: usize,
+        global_component: usize,
+        parameter_index: usize,
+        real_valued: bool,
+    ) -> GenericStageInputComponentManifest {
+        GenericStageInputComponentManifest {
+            kind: kind.to_string(),
+            source_id,
+            component,
+            global_component,
+            parameter_index,
+            real_valued,
+        }
+    }
+
+    fn output_slot(
+        component: usize,
+        current_id: isize,
+        output_column: usize,
+    ) -> GenericStageOutputSlotManifest {
+        GenericStageOutputSlotManifest {
+            value_slot_id: current_id,
+            current_id,
+            variant: "test".to_string(),
+            component_start: component,
+            component_stop: component + 1,
+            output_start: output_column,
+            output_stop: output_column + 1,
+            color_selector_domain_ids: Vec::new(),
+        }
+    }
+
+    fn stage_manifest(
+        label: &str,
+        inputs: Vec<GenericStageInputComponentManifest>,
+        output_components: &[usize],
+        evaluator: EvaluatorManifest,
+        amplitude: bool,
+    ) -> GenericSerializedStageEvaluatorManifest {
+        let leaf_layout = evaluator.leaf_layout().unwrap();
+        let mut direct_application_abi = None;
+        let mut direct_source_abi = None;
+        let direct_leaves = leaf_layout
+            .iter()
+            .map(|leaf| {
+                let (application_path, application_abi, optimization_level, input_len, output_len) =
+                    match leaf.evaluator {
+                        EvaluatorManifest::SymjitApplication {
+                            plane_application: Some(plane_application),
+                            optimization_level,
+                            input_len,
+                            output_len,
+                            ..
+                        } => (
+                            &plane_application.application_path,
+                            &plane_application.application_abi,
+                            *optimization_level,
+                            *input_len,
+                            *output_len,
+                        ),
+                        EvaluatorManifest::CompiledComplex {
+                            input_len,
+                            output_len,
+                            native_direct_application: Some(application),
+                            ..
+                        } => (
+                            &application.library_path,
+                            &application.application_abi,
+                            3,
+                            *input_len,
+                            *output_len,
+                        ),
+                        _ => panic!("compiled Direct-Arena test leaf must be direct-capable"),
+                    };
+                if let Some(expected) = direct_source_abi.as_ref() {
+                    assert_eq!(expected, application_abi);
+                } else {
+                    direct_source_abi = Some(application_abi.clone());
+                };
+                if direct_application_abi.is_none() {
+                    direct_application_abi =
+                        Some(if application_abi == SYMJIT_PLANE_APPLICATION_ABI {
+                            COMPILED_PLANE_DIRECT_APPLICATION_ABI.to_string()
+                        } else {
+                            application_abi.clone()
+                        });
+                }
+                CompiledPlaneLeafManifest {
+                    application_path: application_path.clone(),
+                    source_application_abi: application_abi.clone(),
+                    optimization_level,
+                    direct_codegen_optimization_level: optimization_level,
+                    input_len,
+                    output_len,
+                    input_indices: leaf.input_indices.clone(),
+                    output_start: leaf.output_range.start,
+                    output_stop: leaf.output_range.end,
+                }
+            })
+            .collect();
+        let direct_inputs = inputs
+            .iter()
+            .map(|input| CompiledPlaneInputBindingManifest {
+                parameter_index: input.parameter_index,
+                kind: input.kind.clone(),
+                source_id: input.source_id,
+                component: input.component,
+                global_component: input.global_component,
+                real_valued: input.real_valued,
+            })
+            .collect();
+        let direct_outputs = output_components
+            .iter()
+            .copied()
+            .enumerate()
+            .map(
+                |(output_index, component)| CompiledPlaneOutputBindingManifest {
+                    output_index,
+                    arena: if amplitude { "amplitude" } else { "current" }.to_string(),
+                    component,
+                },
+            )
+            .collect();
+        let compiled_plane_arena = Some(CompiledPlaneArenaStageManifest {
+            schema_version: 1,
+            kind: "compiled-plane-arena-stage".to_string(),
+            application_abi: direct_application_abi.unwrap(),
+            source_application_abi: direct_source_abi.unwrap(),
+            element_layout: "split-complex-component-major".to_string(),
+            output_operation: "overwrite".to_string(),
+            output_factor: "identity".to_string(),
+            input_output_aliasing: "forbidden".to_string(),
+            output_output_aliasing: "forbidden".to_string(),
+            input_bindings: direct_inputs,
+            output_bindings: direct_outputs,
+            leaves: direct_leaves,
+        });
+        let value_parameter_count = inputs.iter().filter(|item| item.kind == "value").count();
+        let momentum_parameter_count = inputs.iter().filter(|item| item.kind == "momentum").count();
+        let model_parameter_count = inputs
+            .iter()
+            .filter(|item| item.kind == "model_parameter")
+            .count();
+        let real_valued_inputs = inputs
+            .iter()
+            .filter_map(|item| item.real_valued.then_some(item.parameter_index))
+            .collect();
+        GenericSerializedStageEvaluatorManifest {
+            stage_index: usize::from(amplitude),
+            stage_kind: if amplitude {
+                "amplitude".to_string()
+            } else {
+                "interaction".to_string()
+            },
+            subset_size: None,
+            evaluator_label: label.to_string(),
+            parameter_layout: "stage-local-value-momentum".to_string(),
+            output_length: output_components.len(),
+            output_slots: output_components
+                .iter()
+                .copied()
+                .enumerate()
+                .map(|(column, component)| {
+                    output_slot(
+                        component,
+                        if amplitude { -1 } else { component as isize },
+                        column,
+                    )
+                })
+                .collect(),
+            input_value_slot_ids: Vec::new(),
+            output_value_slot_ids: Vec::new(),
+            interaction_ids: Vec::new(),
+            parameter_count: inputs.len(),
+            input_components: inputs,
+            value_parameter_count,
+            momentum_parameter_count,
+            model_parameter_count,
+            real_valued_inputs,
+            expression_ready: true,
+            blockers: Vec::new(),
+            evaluator,
+            compiled_plane_arena,
+        }
+    }
+
+    fn assert_close(actual: Complex<f64>, expected: Complex<f64>) {
+        let expected_norm = expected.re.hypot(expected.im);
+        let delta = actual - expected;
+        let delta_norm = delta.re.hypot(delta.im);
+        let tolerance = 1.0e-15 + 1.0e-12 * expected_norm;
+        assert!(
+            delta_norm <= tolerance,
+            "actual={actual:?} expected={expected:?} tolerance={tolerance}"
+        );
+    }
+
+    fn assert_close_real(actual: f64, expected: f64, context: &str) {
+        let tolerance = 1.0e-15 + 1.0e-12 * actual.abs().max(expected.abs());
+        assert!(
+            (actual - expected).abs() <= tolerance,
+            "{context}: actual={actual:.17e} expected={expected:.17e} tolerance={tolerance:.17e}"
+        );
+    }
+
+    #[test]
+    fn cpp_and_asm_native_leaves_execute_only_through_canonical_planes() {
+        let (payload_root, library_name) = native_direct_fixture();
+        let payloads = EvaluatorPayloadStore::directory(&payload_root);
+        for runtime_capability in [
+            SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY,
+            SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY,
+        ] {
+            let amplitude = stage_manifest(
+                runtime_capability,
+                vec![input_component("value", 0, 0, 0, 0, false)],
+                &[0],
+                native_evaluator(&library_name, runtime_capability),
+                true,
+            );
+            let mut direct = CompiledDirectEnginePrototype::load(
+                &[],
+                &amplitude,
+                &payloads,
+                &[0],
+                1,
+                1,
+                4,
+                0,
+                1,
+                129,
+            )
+            .unwrap();
+            let input = (0..129)
+                .map(|point| Complex::new(point as f64 + 0.25, 0.5 - point as f64))
+                .collect::<Vec<_>>();
+            let state = input
+                .iter()
+                .flat_map(|value| {
+                    [
+                        *value,
+                        Complex::new(0.0, 0.0),
+                        Complex::new(0.0, 0.0),
+                        Complex::new(0.0, 0.0),
+                        Complex::new(0.0, 0.0),
+                    ]
+                })
+                .collect::<Vec<_>>();
+            direct.begin_tile_from_state(129, 5, &state).unwrap();
+            direct.evaluate_all(129).unwrap();
+            let mut output = vec![Complex::new(0.0, 0.0); 129];
+            direct
+                .extract_amplitudes_row_major(129, &mut output)
+                .unwrap();
+            for (actual, input) in output.into_iter().zip(&input) {
+                assert_eq!(actual, *input * 2.0);
+            }
+            assert_eq!(direct.traffic().leaf.calls, 1);
+            direct.traffic().leaf.validate_direct().unwrap();
+        }
+        fs::remove_dir_all(payload_root).unwrap();
+    }
+
+    fn disable_compiled_direct_recursive(runtime: &mut ExecutionRuntime) {
+        runtime.compiled_direct_runtime = None;
+        runtime.compiled_direct_color_schedules.clear();
+        runtime.compiled_direct_helicity_schedules.clear();
+        if let Some(sum_runtime) = runtime.helicity_sum_runtime.as_deref_mut() {
+            disable_compiled_direct_recursive(sum_runtime);
+        }
+        for selector_runtime in &mut runtime.helicity_selector_runtimes {
+            disable_compiled_direct_recursive(selector_runtime);
+        }
+        for selector_runtime in runtime.color_selector_runtimes.values_mut() {
+            disable_compiled_direct_recursive(selector_runtime);
+        }
+    }
+
+    fn compiled_direct_runtime_summary(runtime: &ExecutionRuntime) -> (usize, u64, u64, usize) {
+        let (mut engine_count, mut requested_bytes, mut hot_calls, mut minimum_tile_capacity) =
+            (0usize, 0u64, 0u64, usize::MAX);
+        if let Some(direct) = runtime.compiled_direct_runtime.as_ref() {
+            engine_count += 1;
+            requested_bytes =
+                requested_bytes.saturating_add(direct.allocation_counters().requested_bytes);
+            hot_calls = hot_calls.saturating_add(direct.traffic().leaf.calls);
+            minimum_tile_capacity = minimum_tile_capacity.min(direct.tile_capacity());
+            direct
+                .traffic()
+                .leaf
+                .validate_direct()
+                .expect("production compiled leaf traffic remains direct");
+            assert_eq!(direct.traffic().boundary_input_bytes, 0);
+            assert_eq!(direct.traffic().boundary_current_output_bytes, 0);
+            assert_eq!(direct.traffic().boundary_amplitude_output_bytes, 0);
+        }
+        let children = runtime
+            .helicity_sum_runtime
+            .iter()
+            .map(Box::as_ref)
+            .chain(runtime.helicity_selector_runtimes.iter().map(Box::as_ref))
+            .chain(runtime.color_selector_runtimes.values().map(Box::as_ref));
+        for child in children {
+            let (child_engines, child_bytes, child_calls, child_tile) =
+                compiled_direct_runtime_summary(child);
+            engine_count += child_engines;
+            requested_bytes = requested_bytes.saturating_add(child_bytes);
+            hot_calls = hot_calls.saturating_add(child_calls);
+            minimum_tile_capacity = minimum_tile_capacity.min(child_tile);
+        }
+        (
+            engine_count,
+            requested_bytes,
+            hot_calls,
+            minimum_tile_capacity,
+        )
+    }
+
+    fn assert_compiled_direct_tile_geometry(runtime: &ExecutionRuntime) {
+        if let Some(direct) = runtime.compiled_direct_runtime.as_ref() {
+            let sizing = direct.tile_sizing();
+            let stride = direct.arena.point_stride() as usize;
+            let logical_tile_bytes = stride
+                .checked_mul(sizing.physical_scalar_values_per_point)
+                .and_then(|value| value.checked_mul(std::mem::size_of::<f64>()))
+                .expect("retained Direct logical tile bytes fit usize");
+            assert!(logical_tile_bytes > 0);
+            if sizing.reduction_scalar_values_per_point == 0 {
+                assert_eq!(
+                    sizing.effective_tile_capacity, 1,
+                    "unauthenticated retained reducer did not fail closed"
+                );
+            }
+        }
+        let children = runtime
+            .helicity_sum_runtime
+            .iter()
+            .map(Box::as_ref)
+            .chain(runtime.helicity_selector_runtimes.iter().map(Box::as_ref))
+            .chain(runtime.color_selector_runtimes.values().map(Box::as_ref));
+        for child in children {
+            assert_compiled_direct_tile_geometry(child);
+        }
+    }
+
+    fn retained_validation_point(runtime: &NativeRuntime) -> Vec<f64> {
+        let path = runtime
+            .root()
+            .join("processes")
+            .join(&runtime.metadata().representative_process_key)
+            .join("validation-momenta.json");
+        let validation: serde_json::Value =
+            serde_json::from_slice(&fs::read(&path).expect("read retained validation momenta"))
+                .expect("parse retained validation momenta");
+        validation["points"][0]
+            .as_array()
+            .expect("one retained validation point")
+            .iter()
+            .flat_map(|leg| {
+                leg["momentum"]
+                    .as_array()
+                    .expect("four retained momentum components")
+                    .iter()
+                    .map(|value| {
+                        value
+                            .as_str()
+                            .expect("decimal retained momentum string")
+                            .parse::<f64>()
+                            .expect("retained f64 momentum")
+                    })
+            })
+            .collect()
+    }
+
+    #[test]
+    fn compiled_direct_reducer_shapes_are_statically_authenticated() {
+        let routed = CompiledDirectRoutedReductionFootprint::default();
+        let hot =
+            |kind, maximum_group_component_count, maximum_resolved_component_count, routed| {
+                CompiledDirectReductionFootprint::authenticated(
+                    kind,
+                    maximum_group_component_count,
+                    maximum_resolved_component_count,
+                    routed,
+                )
+                .unwrap()
+                .hot_scalar_values_per_point()
+                .unwrap()
+            };
+        assert_eq!(hot(CompiledDirectReducerKind::Plain, 1, 0, routed), 3);
+        assert_eq!(hot(CompiledDirectReducerKind::Coherent, 5, 7, routed), 20);
+        assert_eq!(
+            hot(
+                CompiledDirectReducerKind::Contracted { group_count: 11 },
+                5,
+                7,
+                routed,
+            ),
+            40
+        );
+        assert_eq!(
+            hot(
+                CompiledDirectReducerKind::ColorTopologyReplay {
+                    physical_group_count: 13,
+                },
+                5,
+                7,
+                routed,
+            ),
+            44
+        );
+        assert_eq!(
+            hot(
+                CompiledDirectReducerKind::Coherent,
+                5,
+                7,
+                CompiledDirectRoutedReductionFootprint {
+                    maximum_source_component_count: 512,
+                    maximum_target_component_count: 1,
+                },
+            ),
+            526,
+            "authenticated replay source components can dominate the reducer"
+        );
+        assert_eq!(
+            hot(
+                CompiledDirectReducerKind::Coherent,
+                5,
+                7,
+                CompiledDirectRoutedReductionFootprint {
+                    maximum_source_component_count: 1,
+                    maximum_target_component_count: 1_024,
+                },
+            ),
+            1_038,
+            "authenticated replay target components can dominate the reducer"
+        );
+    }
+
+    #[test]
+    fn selected_routed_reduction_tile_uses_actual_components_within_allocated_capacity() {
+        let mut leaf = liveness_leaf(&[0], &[1]);
+        leaf.scalar_values_per_point = 4_320;
+        let stages = vec![liveness_stage(vec![leaf])];
+        let amplitude = liveness_stage(vec![liveness_leaf(&[1], &[])]);
+        let layout = CompiledDirectCurrentLayout::identity(100_000).unwrap();
+        let sizing = compiled_direct_tile_sizing(
+            &stages,
+            &amplitude,
+            &layout,
+            &[0, 1, 2, 3],
+            24,
+            32,
+            CompiledDirectReductionFootprint::Authenticated {
+                hot_scalar_values_per_point: 188_167,
+            },
+            CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+        )
+        .unwrap();
+        assert_eq!(sizing.effective_tile_capacity, 32);
+        assert_eq!(sizing.reduction_tile_capacity, 2);
+        let selected_footprint = |source, target| {
+            CompiledDirectReductionFootprint::authenticated(
+                CompiledDirectReducerKind::Coherent,
+                1,
+                0,
+                CompiledDirectRoutedReductionFootprint {
+                    maximum_source_component_count: source,
+                    maximum_target_component_count: target,
+                },
+            )
+            .unwrap()
+        };
+        assert_eq!(
+            sizing
+                .reduction_tile_capacity_for_footprint(selected_footprint(64, 512))
+                .unwrap(),
+            32,
+            "one selected flow must not inherit the full color-axis working set"
+        );
+        assert_eq!(
+            sizing
+                .reduction_tile_capacity_for_footprint(selected_footprint(64, 100_000))
+                .unwrap(),
+            4,
+            "a genuinely large selected target still limits cache locality"
+        );
+        assert_eq!(
+            sizing
+                .reduction_tile_capacity_for_footprint(selected_footprint(100_000, 64))
+                .unwrap(),
+            4,
+            "selected source scratch is included as well as target scratch"
+        );
+        let smaller_allocation = CompiledDirectTileSizing {
+            effective_tile_capacity: 8,
+            ..sizing
+        };
+        assert_eq!(
+            smaller_allocation
+                .reduction_tile_capacity_for_footprint(selected_footprint(1, 1))
+                .unwrap(),
+            8,
+            "selected reduction must not enlarge the already allocated arena"
+        );
+        assert_eq!(
+            sizing
+                .reduction_tile_capacity_for_footprint(
+                    CompiledDirectReductionFootprint::Unauthenticated,
+                )
+                .unwrap(),
+            sizing.reduction_tile_capacity,
+            "unknown reducer shapes retain the existing conservative capacity"
+        );
+    }
+
+    #[test]
+    fn compiled_direct_tile_policy_uses_authenticated_phase_local_footprints() {
+        let mut leaf = liveness_leaf(&[0], &[1]);
+        leaf.scalar_values_per_point = 4_320;
+        leaf.persistent_scalar_values_per_point = 17;
+        let stages = vec![liveness_stage(vec![leaf])];
+        let amplitude = liveness_stage(vec![liveness_leaf(&[1], &[])]);
+        let layout = CompiledDirectCurrentLayout::identity(100_000).unwrap();
+        let reduction = CompiledDirectReductionFootprint::Authenticated {
+            hot_scalar_values_per_point: 4_096,
+        };
+        let expected = compiled_direct_tile_sizing(
+            &stages,
+            &amplitude,
+            &layout,
+            &[0, 1, 2, 3],
+            24,
+            8_192,
+            reduction,
+            CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+        )
+        .unwrap();
+        assert_eq!(expected.effective_tile_capacity, 32);
+        assert_eq!(expected.hot_scalar_values_per_point, 4_320);
+        assert_eq!(expected.source_scalar_values_per_point, 33);
+        assert_eq!(expected.reduction_scalar_values_per_point, 4_096);
+        assert_eq!(expected.persistent_scalar_values_per_point, 17);
+        assert_eq!(
+            expected.physical_scalar_values_per_point,
+            200_000 + 24 + 16_384 + 1 + 17,
+            "the hard footprint includes every persistent point-pitched scalar plane"
+        );
+        let expected_stride =
+            checked_aligned_point_stride(expected.effective_tile_capacity as u32).unwrap();
+        let expected_direct_bytes = expected_stride as usize
+            * expected.physical_scalar_values_per_point
+            * std::mem::size_of::<f64>();
+        assert!(
+            expected_direct_bytes > COMPILED_DIRECT_CACHE_TARGET_BYTES,
+            "the soft cache target must not reject a larger physical arena"
+        );
+        for _ in 0..32 {
+            assert_eq!(
+                compiled_direct_tile_sizing(
+                    &stages,
+                    &amplitude,
+                    &layout,
+                    &[0, 1, 2, 3],
+                    24,
+                    8_192,
+                    reduction,
+                    CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+                )
+                .unwrap(),
+                expected,
+                "authenticated sizing must be deterministic"
+            );
+        }
+
+        let many_sources = (0..20_000).collect::<Vec<_>>();
+        let source_limited = compiled_direct_tile_sizing(
+            &stages,
+            &amplitude,
+            &layout,
+            &many_sources,
+            24,
+            1,
+            CompiledDirectReductionFootprint::authenticated(
+                CompiledDirectReducerKind::Plain,
+                1,
+                0,
+                CompiledDirectRoutedReductionFootprint::default(),
+            )
+            .unwrap(),
+            CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+        )
+        .unwrap();
+        assert_eq!(source_limited.source_scalar_values_per_point, 40_025);
+        assert_eq!(source_limited.hot_scalar_values_per_point, 40_025);
+        assert_eq!(
+            source_limited.effective_tile_capacity, 8,
+            "authenticated source preparation can be the cache-limiting phase"
+        );
+
+        let large_reduction = CompiledDirectReductionFootprint::Authenticated {
+            hot_scalar_values_per_point: 32_768,
+        };
+        let reduction_limited = compiled_direct_tile_sizing(
+            &stages,
+            &amplitude,
+            &layout,
+            &[0],
+            4,
+            1,
+            large_reduction,
+            CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+        )
+        .unwrap();
+        assert_eq!(
+            reduction_limited.effective_tile_capacity, 32,
+            "a cold resolved-reduction shape must not fragment total evaluation"
+        );
+        assert_eq!(
+            reduction_limited.reduction_tile_capacity, 16,
+            "resolved and routed reductions retain their smaller cache-local tile"
+        );
+
+        let hard_limited_layout = CompiledDirectCurrentLayout::identity(1_000_000).unwrap();
+        assert_eq!(
+            compiled_direct_tile_sizing(
+                &stages,
+                &amplitude,
+                &hard_limited_layout,
+                &[0],
+                4,
+                1,
+                CompiledDirectReductionFootprint::authenticated(
+                    CompiledDirectReducerKind::Plain,
+                    1,
+                    0,
+                    CompiledDirectRoutedReductionFootprint::default(),
+                )
+                .unwrap(),
+                CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+            )
+            .unwrap()
+            .effective_tile_capacity,
+            32,
+            "large physical arenas retain the locality-limited tile"
+        );
+        let hard_limited = compiled_direct_tile_sizing(
+            &stages,
+            &amplitude,
+            &hard_limited_layout,
+            &[0],
+            4,
+            1,
+            CompiledDirectReductionFootprint::authenticated(
+                CompiledDirectReducerKind::Plain,
+                1,
+                0,
+                CompiledDirectRoutedReductionFootprint::default(),
+            )
+            .unwrap(),
+            CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+        )
+        .unwrap();
+        let hard_stride =
+            checked_aligned_point_stride(hard_limited.effective_tile_capacity as u32).unwrap();
+        let hard_direct_bytes = hard_stride as usize
+            * hard_limited.physical_scalar_values_per_point
+            * std::mem::size_of::<f64>();
+        assert!(
+            hard_direct_bytes > 256 * 1024 * 1024,
+            "the regression geometry must exceed the removed fixed workspace bound"
+        );
+        assert_eq!(
+            compiled_direct_tile_sizing(
+                &stages,
+                &amplitude,
+                &layout,
+                &[0],
+                4,
+                1,
+                CompiledDirectReductionFootprint::Unauthenticated,
+                CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+            )
+            .unwrap()
+            .effective_tile_capacity,
+            1,
+            "production adaptive tiling fails closed without a static reducer footprint"
+        );
+        let unauthenticated_over_budget_layout = CompiledDirectCurrentLayout {
+            canonical_to_physical: vec![0].into_boxed_slice(),
+            physical_component_count: 2_100_000,
+            live_component_count: 1,
+        };
+        assert_eq!(
+            compiled_direct_tile_sizing(
+                &stages,
+                &amplitude,
+                &unauthenticated_over_budget_layout,
+                &[0],
+                4,
+                1,
+                CompiledDirectReductionFootprint::Unauthenticated,
+                CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+            )
+            .unwrap()
+            .effective_tile_capacity,
+            1,
+            "the unauthenticated fallback remains one point without a fixed byte ceiling"
+        );
+        assert_eq!(
+            compiled_direct_tile_sizing(
+                &stages,
+                &amplitude,
+                &hard_limited_layout,
+                &[0],
+                4,
+                1,
+                CompiledDirectReductionFootprint::default(),
+                CompiledDirectCurrentLayoutPolicy::Identity { tile_capacity: 129 },
+            )
+            .unwrap()
+            .effective_tile_capacity,
+            129,
+            "explicit developer/test identity capacity remains exact"
+        );
+    }
+
+    #[test]
+    fn manifest_driven_engine_matches_row_major_compiled_stages_at_all_tail_boundaries() {
+        const VALUE_COMPONENTS: usize = 4;
+        const MOMENTUM_COMPONENTS: usize = 4;
+        const MODEL_PARAMETERS: usize = 1;
+        const GLOBAL_PARAMETERS: usize = VALUE_COMPONENTS + MOMENTUM_COMPONENTS + MODEL_PARAMETERS;
+        const PRODUCT_PROGRAM: &str =
+            "([('mul', ('out', 0), [('param', 0), ('param', 1)], 0)], 2, [])";
+        const SHIFTED_PROGRAM: &str =
+            "([('add', ('out', 0), [('param', 0), ('param', 1)], 0)], 2, [])";
+
+        let payload_root = test_payload_directory();
+        fs::create_dir_all(&payload_root).unwrap();
+        let x = Expr::var("x");
+        let energy = Expr::var("energy");
+        let coupling = Expr::var("coupling");
+        let product = &x * &energy;
+        let shifted = &x + &coupling;
+        let product_bytes =
+            source_application(&[x.clone(), energy.clone()], std::slice::from_ref(&product));
+        let shifted_bytes = source_application(
+            &[x.clone(), coupling.clone()],
+            std::slice::from_ref(&shifted),
+        );
+        fs::write(payload_root.join("product.symjit"), &product_bytes).unwrap();
+        fs::write(payload_root.join("shifted.symjit"), &shifted_bytes).unwrap();
+        let left = Expr::var("left");
+        let right = Expr::var("right");
+        let amplitude_value = &left * &right;
+        let amplitude_bytes =
+            source_application(&[left, right], std::slice::from_ref(&amplitude_value));
+        fs::write(payload_root.join("amplitude.symjit"), &amplitude_bytes).unwrap();
+        for (path, program) in [
+            ("product.plane.symjit", PRODUCT_PROGRAM),
+            ("shifted.plane.symjit", SHIFTED_PROGRAM),
+            ("amplitude.plane.symjit", PRODUCT_PROGRAM),
+        ] {
+            fs::write(
+                payload_root.join(path),
+                compile_symbolica_program_to_plane_application_bytes(program, 2, 1, 3, true)
+                    .unwrap(),
+            )
+            .unwrap();
+        }
+
+        let chunked = EvaluatorManifest::Chunked {
+            required_runtime_capabilities: vec![SYMJIT_APPLICATION_RUNTIME_CAPABILITY.to_string()],
+            input_len: Some(3),
+            chunk_input_indices: Some(vec![vec![0, 1], vec![0, 2]]),
+            chunks: vec![
+                evaluator(
+                    "product.symjit",
+                    "product.plane.symjit",
+                    PRODUCT_PROGRAM,
+                    2,
+                    1,
+                ),
+                evaluator(
+                    "shifted.symjit",
+                    "shifted.plane.symjit",
+                    SHIFTED_PROGRAM,
+                    2,
+                    1,
+                ),
+            ],
+        };
+        let stage = stage_manifest(
+            "real-fused-stage",
+            vec![
+                input_component("value", 0, 0, 0, 0, false),
+                input_component("momentum", 0, 0, VALUE_COMPONENTS, 1, true),
+                input_component(
+                    "model_parameter",
+                    0,
+                    0,
+                    VALUE_COMPONENTS + MOMENTUM_COMPONENTS,
+                    2,
+                    true,
+                ),
+            ],
+            &[1, 2],
+            chunked,
+            false,
+        );
+        let amplitude = stage_manifest(
+            "real-amplitude-stage",
+            vec![
+                input_component("value", 1, 0, 1, 0, false),
+                input_component("value", 2, 0, 2, 1, false),
+            ],
+            &[0],
+            evaluator(
+                "amplitude.symjit",
+                "amplitude.plane.symjit",
+                PRODUCT_PROGRAM,
+                2,
+                1,
+            ),
+            true,
+        );
+        let legacy_amplitude = stage_manifest(
+            "legacy-amplitude-stage",
+            vec![
+                input_component("value", 1, 0, 1, 0, false),
+                input_component("value", 2, 0, 2, 1, false),
+            ],
+            &[3],
+            evaluator(
+                "amplitude.symjit",
+                "amplitude.plane.symjit",
+                PRODUCT_PROGRAM,
+                2,
+                1,
+            ),
+            false,
+        );
+        let payloads = EvaluatorPayloadStore::directory(&payload_root);
+        let mut legacy_stage = StageRuntime::load(&stage, &payloads).unwrap();
+        let mut legacy_amplitude_stage = StageRuntime::load(&legacy_amplitude, &payloads).unwrap();
+        let mut direct = CompiledDirectEnginePrototype::load(
+            std::slice::from_ref(&stage),
+            &amplitude,
+            &payloads,
+            &[0],
+            1,
+            VALUE_COMPONENTS,
+            MOMENTUM_COMPONENTS,
+            MODEL_PARAMETERS,
+            1,
+            129,
+        )
+        .unwrap();
+        let existing_selector = CompiledColorSelectorSchedule {
+            active_stage_chunk_indices: vec![vec![0, 1]],
+            active_amplitude_chunk_indices: vec![0],
+        };
+        let direct_selector = direct.bind_color_schedule(&existing_selector).unwrap();
+        let color_schedules =
+            BTreeMap::from([(7, direct.bind_color_schedule(&existing_selector).unwrap())]);
+        let selected_colors = BTreeSet::from([7]);
+        let joint = direct
+            .bind_helicity_color_schedule(11, &direct_selector, &selected_colors, &color_schedules)
+            .unwrap();
+        let cached = direct
+            .bind_helicity_color_schedule(11, &direct_selector, &selected_colors, &color_schedules)
+            .unwrap();
+        assert!(Arc::ptr_eq(&joint, &cached));
+        assert_eq!(
+            joint.active_stage_leaves,
+            direct_selector.active_stage_leaves
+        );
+        assert_eq!(
+            joint.active_amplitude_leaves,
+            direct_selector.active_amplitude_leaves
+        );
+        assert!(
+            direct
+                .bind_helicity_color_schedule(
+                    11,
+                    &direct_selector,
+                    &BTreeSet::new(),
+                    &color_schedules,
+                )
+                .is_err()
+        );
+        assert!(
+            direct
+                .bind_helicity_color_schedule(
+                    11,
+                    &direct_selector,
+                    &BTreeSet::from([8]),
+                    &color_schedules,
+                )
+                .is_err()
+        );
+        let initial_state = |point_count: usize| {
+            let mut initial = vec![Complex::new(0.0, 0.0); point_count * GLOBAL_PARAMETERS];
+            for point in 0..point_count {
+                let row = point * GLOBAL_PARAMETERS;
+                initial[row] =
+                    Complex::new(0.25 + point as f64 / 128.0, -0.5 + point as f64 / 512.0);
+                initial[row + VALUE_COMPONENTS] = Complex::new(20.0 + point as f64 / 64.0, 0.0);
+                initial[row + VALUE_COMPONENTS + MOMENTUM_COMPONENTS] = Complex::new(1.25, 0.0);
+            }
+            initial
+        };
+
+        for point_count in [7_usize, 127, 128, 129] {
+            let initial = initial_state(point_count);
+
+            let mut legacy = initial.clone();
+            legacy_stage
+                .evaluate_f64_into_state(point_count, GLOBAL_PARAMETERS, &mut legacy)
+                .unwrap();
+            legacy_amplitude_stage
+                .evaluate_f64_into_state(point_count, GLOBAL_PARAMETERS, &mut legacy)
+                .unwrap();
+
+            direct
+                .begin_tile_from_state(point_count, GLOBAL_PARAMETERS, &initial)
+                .unwrap();
+            direct
+                .evaluate_validated(point_count, &direct_selector)
+                .unwrap();
+            let (allocation_result, allocations, allocated_bytes) =
+                count_test_allocations(|| direct.evaluate_validated(point_count, &direct_selector));
+            allocation_result.unwrap();
+            assert_eq!(allocations, 0, "warmed direct engine call allocated");
+            assert_eq!(
+                allocated_bytes, 0,
+                "warmed direct engine call allocated bytes"
+            );
+            let traffic_before_extract = direct.traffic();
+            assert!(traffic_before_extract.boundary_input_bytes > 0);
+            assert!(traffic_before_extract.leaf.calls > 0);
+            assert!(traffic_before_extract.leaf.points > 0);
+            traffic_before_extract.leaf.validate_direct().unwrap();
+            let planes = direct.amplitude_planes().unwrap();
+            assert_eq!(planes.component_count().unwrap(), 1);
+            assert_eq!(planes.point_count(), point_count as u32);
+
+            let mut direct_state = initial.clone();
+            direct
+                .copy_current_to_state(point_count, GLOBAL_PARAMETERS, &mut direct_state)
+                .unwrap();
+            let mut direct_amplitude = vec![Complex::new(f64::NAN, f64::NAN); point_count];
+            direct
+                .extract_amplitudes_row_major(point_count, &mut direct_amplitude)
+                .unwrap();
+            let traffic_after_extract = direct.traffic();
+            assert_eq!(
+                traffic_after_extract.boundary_current_output_bytes
+                    - traffic_before_extract.boundary_current_output_bytes,
+                (point_count * VALUE_COMPONENTS * 2 * std::mem::size_of::<f64>()) as u64
+            );
+            assert_eq!(
+                traffic_after_extract.boundary_amplitude_output_bytes
+                    - traffic_before_extract.boundary_amplitude_output_bytes,
+                (point_count * 2 * std::mem::size_of::<f64>()) as u64
+            );
+            traffic_after_extract.leaf.validate_direct().unwrap();
+            for (point, direct_value) in direct_amplitude.iter().enumerate() {
+                let row = point * GLOBAL_PARAMETERS;
+                assert_close(direct_state[row + 1], legacy[row + 1]);
+                assert_close(direct_state[row + 2], legacy[row + 2]);
+                assert_close(*direct_value, legacy[row + 3]);
+            }
+
+            // Correlated memo reuse must restore overwritten planes, and a
+            // genuinely changed source must invalidate the dependent leaves.
+            let mut memo = CorrelatedStageMemo::default();
+            for repeat in 0..3 {
+                let mut correlated_state = initial.clone();
+                if repeat == 2 {
+                    correlated_state[0] += Complex::new(0.125, -0.25);
+                }
+                direct
+                    .begin_tile_from_state(point_count, GLOBAL_PARAMETERS, &correlated_state)
+                    .unwrap();
+                direct
+                    .evaluate_correlated_reusing(point_count, &mut memo)
+                    .unwrap();
+                let mut correlated_amplitude = vec![Complex::new(0.0, 0.0); point_count];
+                direct
+                    .extract_amplitudes_row_major(point_count, &mut correlated_amplitude)
+                    .unwrap();
+                legacy_stage
+                    .evaluate_f64_into_state(point_count, GLOBAL_PARAMETERS, &mut correlated_state)
+                    .unwrap();
+                legacy_amplitude_stage
+                    .evaluate_f64_into_state(point_count, GLOBAL_PARAMETERS, &mut correlated_state)
+                    .unwrap();
+                for (point, value) in correlated_amplitude.iter().enumerate() {
+                    assert_close(*value, correlated_state[point * GLOBAL_PARAMETERS + 3]);
+                }
+                if repeat == 1 {
+                    assert_eq!(memo.reused_leaves, 3);
+                }
+                if repeat == 2 {
+                    assert_eq!(
+                        memo.reused_leaves, 3,
+                        "changed current inputs must invalidate the leaf"
+                    );
+                }
+            }
+
+            if point_count == 129 {
+                const SAMPLES: usize = 7;
+                const REPEATS: usize = 2_000;
+                let mut direct_ns = [0_u128; SAMPLES];
+                let mut legacy_ns = [0_u128; SAMPLES];
+                for sample in 0..SAMPLES {
+                    let mut time_direct = || {
+                        let start = Instant::now();
+                        for _ in 0..REPEATS {
+                            direct
+                                .evaluate_validated(point_count, &direct_selector)
+                                .unwrap();
+                        }
+                        start.elapsed().as_nanos() / REPEATS as u128
+                    };
+                    let mut time_legacy = || {
+                        let start = Instant::now();
+                        for _ in 0..REPEATS {
+                            legacy_stage
+                                .evaluate_f64_into_state(
+                                    point_count,
+                                    GLOBAL_PARAMETERS,
+                                    &mut legacy,
+                                )
+                                .unwrap();
+                            legacy_amplitude_stage
+                                .evaluate_f64_into_state(
+                                    point_count,
+                                    GLOBAL_PARAMETERS,
+                                    &mut legacy,
+                                )
+                                .unwrap();
+                        }
+                        start.elapsed().as_nanos() / REPEATS as u128
+                    };
+                    if sample.is_multiple_of(2) {
+                        direct_ns[sample] = time_direct();
+                        legacy_ns[sample] = time_legacy();
+                    } else {
+                        legacy_ns[sample] = time_legacy();
+                        direct_ns[sample] = time_direct();
+                    }
+                    let direct_planes = direct.amplitude_planes().unwrap();
+                    std::hint::black_box((&legacy, direct_planes));
+                }
+                direct_ns.sort_unstable();
+                legacy_ns.sort_unstable();
+                let direct_median = direct_ns[SAMPLES / 2];
+                let legacy_median = legacy_ns[SAMPLES / 2];
+                eprintln!(
+                    "compiled-direct-engine-prototype points={point_count} samples={SAMPLES} \
+                     repeats={REPEATS} direct_ns={direct_ns:?} legacy_ns={legacy_ns:?} \
+                     direct_median_ns={direct_median} legacy_median_ns={legacy_median} \
+                     speedup={:.6}",
+                    legacy_median as f64 / direct_median as f64
+                );
+            }
+        }
+
+        let mut tiled_direct = CompiledDirectEnginePrototype::load_with_current_layout_policy(
+            std::slice::from_ref(&stage),
+            &amplitude,
+            &payloads,
+            &[0],
+            1,
+            VALUE_COMPONENTS,
+            MOMENTUM_COMPONENTS,
+            MODEL_PARAMETERS,
+            1,
+            CompiledDirectReductionFootprint::authenticated(
+                CompiledDirectReducerKind::Plain,
+                1,
+                0,
+                CompiledDirectRoutedReductionFootprint::default(),
+            )
+            .unwrap(),
+            CompiledDirectCurrentLayoutPolicy::StageLivenessProduction,
+        )
+        .unwrap();
+        let production_tile = tiled_direct.tile_capacity();
+        assert_eq!(production_tile, 32);
+        let tiled_selector = tiled_direct
+            .bind_color_schedule(&existing_selector)
+            .unwrap();
+        for point_count in [
+            1_usize,
+            production_tile - 1,
+            production_tile,
+            production_tile + 1,
+            production_tile * 2 + 1,
+            production_tile * 4 + 1,
+        ] {
+            let initial = initial_state(point_count);
+            let mut legacy = initial.clone();
+            legacy_stage
+                .evaluate_f64_into_state(point_count, GLOBAL_PARAMETERS, &mut legacy)
+                .unwrap();
+            legacy_amplitude_stage
+                .evaluate_f64_into_state(point_count, GLOBAL_PARAMETERS, &mut legacy)
+                .unwrap();
+            let mut tiled_amplitudes = vec![Complex::new(f64::NAN, f64::NAN); point_count];
+            let tiles = tiled_direct
+                .arena
+                .point_tiles(point_count as u32, tiled_direct.tile_capacity() as u32)
+                .unwrap();
+            for tile in tiles {
+                let point_start = tile.point_start as usize;
+                let tile_points = tile.point_count as usize;
+                let point_stop = point_start + tile_points;
+                tiled_direct
+                    .begin_tile_from_state_sources_for_test(
+                        tile_points,
+                        GLOBAL_PARAMETERS,
+                        &initial[point_start * GLOBAL_PARAMETERS..point_stop * GLOBAL_PARAMETERS],
+                    )
+                    .unwrap();
+                tiled_direct
+                    .evaluate_validated(tile_points, &tiled_selector)
+                    .unwrap();
+                tiled_direct
+                    .extract_amplitudes_row_major(
+                        tile_points,
+                        &mut tiled_amplitudes[point_start..point_stop],
+                    )
+                    .unwrap();
+            }
+            for (point, actual) in tiled_amplitudes.iter().copied().enumerate() {
+                assert_close(actual, legacy[point * GLOBAL_PARAMETERS + 3]);
+            }
+        }
+
+        direct
+            .begin_tile_from_state(
+                7,
+                GLOBAL_PARAMETERS,
+                &vec![Complex::new(0.0, 0.0); 7 * GLOBAL_PARAMETERS],
+            )
+            .unwrap();
+        direct
+            .evaluate_validated(7, &direct_selector)
+            .expect("runtime-validated selector schedule must execute");
+        let duplicate = CompiledColorSelectorSchedule {
+            active_stage_chunk_indices: vec![vec![0, 0]],
+            active_amplitude_chunk_indices: vec![0],
+        };
+        assert!(direct.bind_color_schedule(&duplicate).is_err());
+        let missing_prerequisite = CompiledColorSelectorSchedule {
+            active_stage_chunk_indices: vec![Vec::new()],
+            active_amplitude_chunk_indices: vec![0],
+        };
+        assert!(direct.bind_color_schedule(&missing_prerequisite).is_err());
+    }
+
+    #[test]
+    fn retained_compiled_o3_artifact_sizing_is_independently_deterministic() {
+        let Some(root) = std::env::var_os("RUSTICOL_COMPILED_DIRECT_ARTIFACT") else {
+            return;
+        };
+        let root = PathBuf::from(root);
+        let first =
+            NativeRuntime::load(&root, None, None).expect("load first retained Direct runtime");
+        let second =
+            NativeRuntime::load(&root, None, None).expect("load second retained Direct runtime");
+        let first_summary = compiled_direct_runtime_summary(&first.runtime);
+        let second_summary = compiled_direct_runtime_summary(&second.runtime);
+        assert_eq!(
+            first_summary, second_summary,
+            "independent loads derived different nested Direct configurations"
+        );
+        assert!(
+            first_summary.0 > 0,
+            "retained sizing fixture has no Direct engine"
+        );
+        assert_eq!(
+            first.metadata_json().unwrap(),
+            second.metadata_json().unwrap(),
+            "independent loads reported different nested Direct provenance"
+        );
+        assert_compiled_direct_tile_geometry(&first.runtime);
+        assert_compiled_direct_tile_geometry(&second.runtime);
+        eprintln!(
+            "retained-compiled-direct-sizing engines={} requested_bytes={} \
+             minimum_tile={} metadata={}",
+            first_summary.0,
+            first_summary.1,
+            first_summary.3,
+            first.metadata_json().unwrap()
+        );
+    }
+
+    #[test]
+    fn retained_compiled_o3_artifact_dual_runs_canonical_leaf_schedule() {
+        let Some(root) = std::env::var_os("RUSTICOL_COMPILED_DIRECT_ARTIFACT") else {
+            return;
+        };
+        let artifact = VerifiedArtifact::open(PathBuf::from(root))
+            .expect("open retained compiled Direct-Arena artifact");
+        let selection = artifact
+            .select_process(None)
+            .expect("select retained process");
+        let (loaded, evaluator_root) =
+            load_verified_evaluator(&artifact, &selection).expect("load retained manifest");
+        let LoadedExecutionManifest::Compiled(execution) = loaded else {
+            panic!("retained Direct-Arena fixture is not a compiled execution");
+        };
+        let stages = execution
+            .compiled
+            .stage_evaluators
+            .as_ref()
+            .expect("retained compiled execution has generic stages");
+        let payloads = artifact
+            .evaluator_payload_store(&evaluator_root)
+            .expect("open retained evaluator payloads");
+        let layout = &execution.runtime_schema.parameter_layout;
+        let value_component_count = layout.value_component_count;
+        let momentum_component_count = layout.momentum_parameter_count;
+        let model_parameter_count = layout.model_parameter_count;
+        let amplitude_component_count = stages.amplitude_stage.output_length;
+
+        let mut legacy_stages = stages
+            .stages
+            .iter()
+            .map(|stage| StageRuntime::load(stage, &payloads))
+            .collect::<RusticolResult<Vec<_>>>()
+            .expect("load retained row-major stages");
+        let mut legacy_amplitude = AmplitudeRuntime::load(
+            &execution.runtime_schema.amplitude_stage,
+            &stages.amplitude_stage,
+            &payloads,
+        )
+        .expect("load retained row-major amplitude stage");
+        let (source_components, source_scratch_len) = canonical_source_layout(
+            &execution.runtime_schema.source_fill.sources,
+            value_component_count,
+        )
+        .expect("derive retained canonical sources");
+        let mut direct = CompiledDirectEnginePrototype::load(
+            &stages.stages,
+            &stages.amplitude_stage,
+            &payloads,
+            &source_components,
+            source_scratch_len,
+            value_component_count,
+            momentum_component_count,
+            model_parameter_count,
+            amplitude_component_count,
+            129,
+        )
+        .expect("lower retained compiled O3 stages");
+
+        let color_plan = build_compiled_color_execution_plan(
+            stages,
+            &execution.runtime_schema,
+            &BTreeSet::new(),
+        )
+        .expect("validate retained selector coverage")
+        .expect("retained LC artifact has selector coverage");
+        let (_, retained_schedule) = color_plan
+            .schedules_by_materialized_sector
+            .iter()
+            .next()
+            .expect("retained LC artifact has a materialized sector");
+        let direct_schedule = direct
+            .bind_color_schedule(retained_schedule)
+            .expect("bind production-validated retained selector schedule");
+
+        let parameter_count =
+            value_component_count + momentum_component_count + model_parameter_count;
+        for point_count in [7_usize, 127, 128, 129] {
+            let mut initial = vec![Complex::new(0.0, 0.0); point_count * parameter_count];
+            for point in 0..point_count {
+                let row = point * parameter_count;
+                for component in 0..value_component_count {
+                    initial[row + component] = Complex::new(
+                        0.25 + component as f64 / 97.0 + point as f64 / 4096.0,
+                        -0.125 + component as f64 / 211.0 - point as f64 / 8192.0,
+                    );
+                }
+                for component in 0..momentum_component_count {
+                    initial[row + value_component_count + component] =
+                        Complex::new(2.0 + component as f64 / 17.0 + point as f64 / 1024.0, 0.0);
+                }
+                for component in 0..model_parameter_count {
+                    initial[row + value_component_count + momentum_component_count + component] =
+                        Complex::new(0.75 + component as f64 / 31.0, 0.0);
+                }
+            }
+
+            let mut legacy = initial.clone();
+            for (stage_index, stage) in legacy_stages.iter_mut().enumerate() {
+                stage
+                    .evaluate_active_chunks_f64_into_state(
+                        point_count,
+                        parameter_count,
+                        &mut legacy,
+                        &retained_schedule.active_stage_chunk_indices[stage_index],
+                    )
+                    .expect("evaluate retained selected row-major stage");
+            }
+            legacy_amplitude
+                .evaluate_active_chunks_f64_into_scratch(
+                    point_count,
+                    &legacy,
+                    &retained_schedule.active_amplitude_chunk_indices,
+                )
+                .expect("evaluate retained selected row-major amplitude stage");
+
+            direct
+                .begin_tile_from_state(point_count, parameter_count, &initial)
+                .expect("transpose retained tile");
+            direct
+                .evaluate_validated(point_count, &direct_schedule)
+                .expect("evaluate retained Direct-Arena selector schedule");
+            let (result, allocations, allocated_bytes) =
+                count_test_allocations(|| direct.evaluate_validated(point_count, &direct_schedule));
+            result.expect("repeat retained Direct-Arena selector schedule");
+            assert_eq!(allocations, 0, "retained warmed direct call allocated");
+            assert_eq!(
+                allocated_bytes, 0,
+                "retained warmed direct call allocated bytes"
+            );
+            direct.traffic().leaf.validate_direct().unwrap();
+
+            let mut direct_amplitudes =
+                vec![Complex::new(f64::NAN, f64::NAN); point_count * amplitude_component_count];
+            direct
+                .extract_amplitudes_row_major(point_count, &mut direct_amplitudes)
+                .expect("extract retained amplitudes for oracle comparison");
+            assert_eq!(
+                legacy_amplitude.output_scratch_f64.len(),
+                direct_amplitudes.len()
+            );
+            for (direct_value, legacy_value) in direct_amplitudes
+                .iter()
+                .copied()
+                .zip(legacy_amplitude.output_scratch_f64.iter().copied())
+            {
+                assert_close(direct_value, legacy_value);
+            }
+
+            if point_count == 129 {
+                const SAMPLES: usize = 7;
+                const REPEATS: usize = 200;
+                let mut direct_ns = [0_u128; SAMPLES];
+                let mut legacy_ns = [0_u128; SAMPLES];
+                for sample in 0..SAMPLES {
+                    let mut time_direct = || {
+                        let start = Instant::now();
+                        for _ in 0..REPEATS {
+                            direct
+                                .evaluate_validated(point_count, &direct_schedule)
+                                .unwrap();
+                        }
+                        start.elapsed().as_nanos() / REPEATS as u128
+                    };
+                    let mut time_legacy = || {
+                        let start = Instant::now();
+                        for _ in 0..REPEATS {
+                            for (stage_index, stage) in legacy_stages.iter_mut().enumerate() {
+                                stage
+                                    .evaluate_active_chunks_f64_into_state(
+                                        point_count,
+                                        parameter_count,
+                                        &mut legacy,
+                                        &retained_schedule.active_stage_chunk_indices[stage_index],
+                                    )
+                                    .unwrap();
+                            }
+                            legacy_amplitude
+                                .evaluate_active_chunks_f64_into_scratch(
+                                    point_count,
+                                    &legacy,
+                                    &retained_schedule.active_amplitude_chunk_indices,
+                                )
+                                .unwrap();
+                        }
+                        start.elapsed().as_nanos() / REPEATS as u128
+                    };
+                    if sample.is_multiple_of(2) {
+                        direct_ns[sample] = time_direct();
+                        legacy_ns[sample] = time_legacy();
+                    } else {
+                        legacy_ns[sample] = time_legacy();
+                        direct_ns[sample] = time_direct();
+                    }
+                    std::hint::black_box((
+                        direct.amplitude_planes().unwrap(),
+                        &legacy_amplitude.output_scratch_f64,
+                    ));
+                }
+                direct_ns.sort_unstable();
+                legacy_ns.sort_unstable();
+                let direct_median = direct_ns[SAMPLES / 2];
+                let legacy_median = legacy_ns[SAMPLES / 2];
+                eprintln!(
+                    "retained-compiled-direct points={point_count} samples={SAMPLES} \
+                     repeats={REPEATS} direct_ns={direct_ns:?} legacy_ns={legacy_ns:?} \
+                     direct_median_ns={direct_median} legacy_median_ns={legacy_median} \
+                     speedup={:.6}",
+                    legacy_median as f64 / direct_median as f64
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn retained_compiled_o3_artifact_native_runtime_direct_matches_legacy_contract() {
+        let Some(root) = std::env::var_os("RUSTICOL_COMPILED_DIRECT_ARTIFACT") else {
+            return;
+        };
+        let root = PathBuf::from(root);
+        let mut direct = NativeRuntime::load(&root, None, None)
+            .expect("load retained production Direct runtime");
+        let mut legacy =
+            NativeRuntime::load(&root, None, None).expect("load retained legacy oracle runtime");
+        assert_eq!(
+            compiled_direct_runtime_summary(&direct.runtime),
+            compiled_direct_runtime_summary(&legacy.runtime),
+            "independent loads must derive the same nested Direct configuration"
+        );
+        assert_eq!(
+            direct.metadata_json().unwrap(),
+            legacy.metadata_json().unwrap(),
+            "independent loads must report deterministic nested Direct provenance"
+        );
+        disable_compiled_direct_recursive(&mut legacy.runtime);
+
+        let (engine_count, requested_bytes, _, minimum_tile_capacity) =
+            compiled_direct_runtime_summary(&direct.runtime);
+        assert!(engine_count > 0, "retained runtime has one Direct engine");
+        assert!(requested_bytes > 0, "retained Direct arenas own storage");
+        assert!(
+            minimum_tile_capacity > 0,
+            "retained Direct engines have a nonzero tile"
+        );
+        eprintln!(
+            "retained-compiled-direct-production engines={engine_count} \
+             requested_bytes={requested_bytes} minimum_tile_capacity={minimum_tile_capacity}"
+        );
+        let metadata = direct.metadata();
+        assert_eq!(
+            metadata.compiled_direct_minimum_effective_tile_capacity,
+            Some(minimum_tile_capacity)
+        );
+        assert!(
+            metadata
+                .compiled_direct_maximum_physical_scalar_values_per_point
+                .is_some_and(|value| value > 0)
+        );
+        assert!(
+            metadata
+                .compiled_direct_maximum_hot_scalar_values_per_point
+                .is_some_and(|value| value > 0)
+        );
+        assert!(
+            metadata
+                .compiled_direct_maximum_source_scalar_values_per_point
+                .is_some_and(|value| value > 0)
+        );
+        assert!(
+            metadata
+                .compiled_direct_maximum_reduction_scalar_values_per_point
+                .is_some_and(|value| value > 0)
+        );
+        assert_eq!(
+            direct.metadata_json().unwrap(),
+            direct.metadata_json().unwrap(),
+            "compiled Direct effective configuration provenance must be deterministic"
+        );
+
+        let point = retained_validation_point(&direct);
+        for point_count in [1usize, 7, 63, 64, 65, 127, 128, 129, 1023, 1024, 1025] {
+            let momenta = point.repeat(point_count);
+            let mut direct_values = vec![f64::NAN; point_count];
+            let mut legacy_values = vec![f64::NAN; point_count];
+            direct
+                .evaluate_f64_into(&momenta, point_count, &mut direct_values)
+                .expect("evaluate retained production Direct totals");
+            legacy
+                .evaluate_f64_into(&momenta, point_count, &mut legacy_values)
+                .expect("evaluate retained legacy totals");
+            for (point_index, (direct_value, legacy_value)) in direct_values
+                .iter()
+                .copied()
+                .zip(legacy_values.iter().copied())
+                .enumerate()
+            {
+                assert_close_real(
+                    direct_value,
+                    legacy_value,
+                    &format!("unselected total point={point_index} count={point_count}"),
+                );
+            }
+        }
+
+        let helicities = direct.helicities().expect("retained helicity metadata");
+        let computed_helicities = helicities
+            .iter()
+            .filter(|helicity| helicity.computed && !helicity.structural_zero)
+            .collect::<Vec<_>>();
+        assert!(
+            !computed_helicities.is_empty(),
+            "retained artifact has one nonzero computed helicity"
+        );
+        let selected_helicity = computed_helicities[0].id.clone();
+        let colors = direct.color_components().expect("retained color metadata");
+        assert!(!colors.is_empty(), "retained artifact has one color");
+        // Prefer a non-representative physical flow so the test exercises a
+        // real topology-label permutation rather than only the identity map.
+        let selected_color = colors
+            .last()
+            .expect("retained artifact has one color")
+            .id
+            .clone();
+
+        let selector_points = 129usize;
+        let selector_momenta = point.repeat(selector_points);
+        let mut selector_cases = vec![(
+            "all-flows-single-helicity",
+            Some(std::slice::from_ref(&selected_helicity)),
+            None,
+        )];
+        if direct.metadata().color_accuracy == "lc" {
+            selector_cases.push((
+                "single-flow-helicity-sum",
+                None,
+                Some(std::slice::from_ref(&selected_color)),
+            ));
+        }
+        for (label, selected_helicities, selected_colors) in selector_cases {
+            let direct_values = direct
+                .evaluate_f64_with_selectors(
+                    &selector_momenta,
+                    selector_points,
+                    selected_helicities,
+                    selected_colors,
+                    None,
+                    None,
+                )
+                .expect("evaluate retained Direct global selector");
+            let legacy_values = legacy
+                .evaluate_f64_with_selectors(
+                    &selector_momenta,
+                    selector_points,
+                    selected_helicities,
+                    selected_colors,
+                    None,
+                    None,
+                )
+                .expect("evaluate retained legacy global selector");
+            let resolved = direct
+                .evaluate_resolved_f64(
+                    &selector_momenta,
+                    selector_points,
+                    selected_helicities,
+                    selected_colors,
+                )
+                .expect("resolve retained Direct global selector");
+            let resolved_totals = resolved.totals();
+            for point_index in 0..selector_points {
+                assert_close_real(
+                    direct_values[point_index],
+                    legacy_values[point_index],
+                    &format!("{label} direct/legacy point={point_index}"),
+                );
+                assert_close_real(
+                    direct_values[point_index],
+                    resolved_totals[point_index],
+                    &format!("{label} total/resolved point={point_index}"),
+                );
+            }
+        }
+
+        let compiled_symmetric_group = direct
+            .runtime
+            .amplitude_stage
+            .as_ref()
+            .and_then(|amplitude| amplitude.color_contraction.as_ref())
+            .is_some_and(ColorContractionRuntime::is_symmetric_group);
+        if helicities.len() == 1
+            && direct.metadata().color_accuracy == "full"
+            && !compiled_symmetric_group
+        {
+            let sole_helicity = [selected_helicity.clone()];
+            let explicit_total = direct
+                .evaluate_f64_with_selectors(
+                    &selector_momenta,
+                    selector_points,
+                    Some(&sole_helicity),
+                    None,
+                    None,
+                    None,
+                )
+                .expect("evaluate selected FullColour explicit sole-helicity total");
+            let unselected_total = direct
+                .evaluate_f64(&selector_momenta, selector_points)
+                .expect("evaluate selected FullColour implicit sole-helicity total");
+            let resolved = direct
+                .evaluate_resolved_f64(
+                    &selector_momenta,
+                    selector_points,
+                    Some(&sole_helicity),
+                    None,
+                )
+                .expect("resolve selected FullColour sole-helicity values");
+            assert_eq!(resolved.helicity_ids.as_slice(), sole_helicity.as_slice());
+            assert_eq!(resolved.color_ids.len(), 1);
+            assert_eq!(resolved.point_count, selector_points);
+            assert_eq!(resolved.values.len(), selector_points);
+            let resolved_total = resolved.totals();
+            for (point_index, ((explicit, unselected), resolved)) in explicit_total
+                .iter()
+                .copied()
+                .zip(unselected_total.iter().copied())
+                .zip(resolved_total.iter().copied())
+                .enumerate()
+            {
+                assert_close_real(
+                    explicit,
+                    unselected,
+                    &format!("sole-helicity explicit/unselected total point={point_index}"),
+                );
+                assert_close_real(
+                    explicit,
+                    resolved,
+                    &format!("sole-helicity total/resolved point={point_index}"),
+                );
+            }
+
+            let sole_helicity_index =
+                u32::try_from(helicities[0].index).expect("sole public helicity index fits u32");
+            let helicity_by_point = vec![sole_helicity_index; selector_points];
+            let mut per_point_total = vec![f64::NAN; selector_points];
+            direct
+                .evaluate_f64_into_with_selectors(
+                    &selector_momenta,
+                    selector_points,
+                    None,
+                    None,
+                    Some(&helicity_by_point),
+                    None,
+                    &mut per_point_total,
+                )
+                .expect("warm selected FullColour per-point sole-helicity total");
+            let (result, allocations, allocated_bytes) = count_test_allocations(|| {
+                direct.evaluate_f64_into_with_selectors(
+                    &selector_momenta,
+                    selector_points,
+                    None,
+                    None,
+                    Some(&helicity_by_point),
+                    None,
+                    &mut per_point_total,
+                )
+            });
+            result.expect("repeat selected FullColour per-point sole-helicity total");
+            assert_eq!(allocations, 0, "warmed sole-helicity total allocated");
+            assert_eq!(
+                allocated_bytes, 0,
+                "warmed sole-helicity total allocated bytes"
+            );
+            for (point_index, (per_point, explicit)) in per_point_total
+                .iter()
+                .copied()
+                .zip(explicit_total.iter().copied())
+                .enumerate()
+            {
+                assert_close_real(
+                    per_point,
+                    explicit,
+                    &format!("sole-helicity per-point/global total point={point_index}"),
+                );
+            }
+        }
+
+        if direct.runtime.lc_topology_replay_enabled {
+            let selector_batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                &selector_momenta,
+                selector_points,
+                direct.runtime.external_count,
+                direct.input_crossing_map.as_deref(),
+            )
+            .expect("borrow retained selector batch");
+            for (label, selected_helicities, selected_colors) in [
+                ("all-components", None, None),
+                (
+                    "all-flows-single-helicity",
+                    Some(BTreeSet::from([selected_helicity.clone()])),
+                    None,
+                ),
+            ] {
+                let mut candidate_values = vec![f64::NAN; selector_points];
+                let mut oracle_values = vec![f64::NAN; selector_points];
+                direct
+                    .runtime
+                    .run_f64_selected_into_unprofiled(
+                        selector_batch,
+                        selected_helicities.as_ref(),
+                        selected_colors.as_ref(),
+                        &mut candidate_values,
+                    )
+                    .expect("evaluate allocation-free replay candidate");
+                direct
+                    .runtime
+                    .run_f64_selected_into_resolved_replay_oracle(
+                        selector_batch,
+                        selected_helicities.as_ref(),
+                        selected_colors.as_ref(),
+                        &mut oracle_values,
+                    )
+                    .expect("evaluate resolved replay oracle");
+                for (point_index, (candidate_value, oracle_value)) in candidate_values
+                    .iter()
+                    .copied()
+                    .zip(oracle_values.iter().copied())
+                    .enumerate()
+                {
+                    assert_close_real(
+                        candidate_value,
+                        oracle_value,
+                        &format!("{label} replay candidate/oracle point={point_index}"),
+                    );
+                }
+            }
+        }
+
+        if direct.metadata().color_accuracy == "lc"
+            && computed_helicities.len() >= 2
+            && colors.len() >= 2
+        {
+            let point_count = 129usize;
+            let momenta = point.repeat(point_count);
+            let helicity_by_point = (0..point_count)
+                .map(|point_index| {
+                    computed_helicities[point_index % 2]
+                        .index
+                        .try_into()
+                        .expect("physical helicity index fits u32")
+                })
+                .collect::<Vec<u32>>();
+            let color_by_point = (0..point_count)
+                .map(|point_index| {
+                    colors[point_index % 2]
+                        .index
+                        .try_into()
+                        .expect("physical color index fits u32")
+                })
+                .collect::<Vec<u32>>();
+            let direct_values = direct
+                .evaluate_f64_with_selectors(
+                    &momenta,
+                    point_count,
+                    None,
+                    None,
+                    Some(&helicity_by_point),
+                    Some(&color_by_point),
+                )
+                .expect("evaluate retained Direct per-point selectors");
+            let legacy_values = legacy
+                .evaluate_f64_with_selectors(
+                    &momenta,
+                    point_count,
+                    None,
+                    None,
+                    Some(&helicity_by_point),
+                    Some(&color_by_point),
+                )
+                .expect("evaluate retained legacy per-point selectors");
+            for (point_index, (direct_value, legacy_value)) in direct_values
+                .iter()
+                .copied()
+                .zip(legacy_values.iter().copied())
+                .enumerate()
+            {
+                assert_close_real(
+                    direct_value,
+                    legacy_value,
+                    &format!("per-point selector point={point_index}"),
+                );
+            }
+        }
+
+        let parameters = direct
+            .model_parameters()
+            .expect("retained model parameter metadata");
+        if let Some(parameter) = parameters.iter().find(|parameter| parameter.mutable) {
+            let changed_real = if parameter.default == 0.0 {
+                0.125
+            } else {
+                parameter.default * 1.01
+            };
+            direct
+                .set_model_parameter(&parameter.name, changed_real, parameter.default_imaginary)
+                .expect("update retained Direct parameter");
+            legacy
+                .set_model_parameter(&parameter.name, changed_real, parameter.default_imaginary)
+                .expect("update retained legacy parameter");
+            let direct_changed = direct
+                .evaluate_f64(&point, 1)
+                .expect("evaluate retained Direct changed parameter");
+            let legacy_changed = legacy
+                .evaluate_f64(&point, 1)
+                .expect("evaluate retained legacy changed parameter");
+            assert_close_real(
+                direct_changed[0],
+                legacy_changed[0],
+                "changed model parameter",
+            );
+            direct
+                .set_model_parameter(
+                    &parameter.name,
+                    parameter.default,
+                    parameter.default_imaginary,
+                )
+                .expect("restore retained Direct parameter");
+            legacy
+                .set_model_parameter(
+                    &parameter.name,
+                    parameter.default,
+                    parameter.default_imaginary,
+                )
+                .expect("restore retained legacy parameter");
+        }
+
+        if !cfg!(debug_assertions) {
+            let mut workloads = vec![
+                ("all-components", None, None),
+                (
+                    "all-flows-single-helicity",
+                    Some(vec![selected_helicity.clone()]),
+                    None,
+                ),
+            ];
+            if direct.metadata().color_accuracy == "lc" {
+                workloads.push((
+                    "single-flow-helicity-sum",
+                    None,
+                    Some(vec![selected_color.clone()]),
+                ));
+            }
+            for point_count in [128usize, 1024] {
+                let momenta = point.repeat(point_count);
+                let repeats = if point_count == 128 { 32 } else { 8 };
+                for (label, helicities, colors) in &workloads {
+                    let mut direct_output = vec![f64::NAN; point_count];
+                    let mut legacy_output = vec![f64::NAN; point_count];
+                    direct
+                        .evaluate_f64_into_with_selectors(
+                            &momenta,
+                            point_count,
+                            helicities.as_deref(),
+                            colors.as_deref(),
+                            None,
+                            None,
+                            &mut direct_output,
+                        )
+                        .expect("warm retained Direct timing workload");
+                    legacy
+                        .evaluate_f64_into_with_selectors(
+                            &momenta,
+                            point_count,
+                            helicities.as_deref(),
+                            colors.as_deref(),
+                            None,
+                            None,
+                            &mut legacy_output,
+                        )
+                        .expect("warm retained legacy timing workload");
+                    let mut direct_samples = [0u128; 7];
+                    let mut legacy_samples = [0u128; 7];
+                    for sample in 0usize..7 {
+                        let mut time_direct = || {
+                            let start = Instant::now();
+                            for _ in 0..repeats {
+                                direct
+                                    .evaluate_f64_into_with_selectors(
+                                        &momenta,
+                                        point_count,
+                                        helicities.as_deref(),
+                                        colors.as_deref(),
+                                        None,
+                                        None,
+                                        &mut direct_output,
+                                    )
+                                    .expect("time retained Direct workload");
+                            }
+                            start.elapsed().as_nanos() / repeats
+                        };
+                        let mut time_legacy = || {
+                            let start = Instant::now();
+                            for _ in 0..repeats {
+                                legacy
+                                    .evaluate_f64_into_with_selectors(
+                                        &momenta,
+                                        point_count,
+                                        helicities.as_deref(),
+                                        colors.as_deref(),
+                                        None,
+                                        None,
+                                        &mut legacy_output,
+                                    )
+                                    .expect("time retained legacy workload");
+                            }
+                            start.elapsed().as_nanos() / repeats
+                        };
+                        if sample.is_multiple_of(2) {
+                            direct_samples[sample] = time_direct();
+                            legacy_samples[sample] = time_legacy();
+                        } else {
+                            legacy_samples[sample] = time_legacy();
+                            direct_samples[sample] = time_direct();
+                        }
+                        std::hint::black_box((&direct_output, &legacy_output));
+                    }
+                    direct_samples.sort_unstable();
+                    legacy_samples.sort_unstable();
+                    let direct_median = direct_samples[3];
+                    let legacy_median = legacy_samples[3];
+                    eprintln!(
+                        "retained-compiled-direct-wall color_accuracy={} workload={label} \
+                         points={point_count} samples=7 repeats={repeats} \
+                         direct_samples_ns={direct_samples:?} \
+                         legacy_samples_ns={legacy_samples:?} \
+                         direct_median_ns={direct_median} legacy_median_ns={legacy_median} \
+                         direct_ns_per_point={:.3} legacy_ns_per_point={:.3} speedup={:.6}",
+                        direct.metadata().color_accuracy,
+                        direct_median as f64 / point_count as f64,
+                        legacy_median as f64 / point_count as f64,
+                        legacy_median as f64 / direct_median as f64,
+                    );
+                }
+            }
+        }
+
+        if !cfg!(debug_assertions)
+            && std::env::var_os("RUSTICOL_TEST_BENCHMARK_COMPILED_REPLAY_TOTALS").is_some()
+            && direct.metadata().color_accuracy == "lc"
+        {
+            let selected_helicity_set = BTreeSet::from([selected_helicity.clone()]);
+            for point_count in [128usize, 1024] {
+                let momenta = point.repeat(point_count);
+                let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                    &momenta,
+                    point_count,
+                    direct.runtime.external_count,
+                    direct.input_crossing_map.as_deref(),
+                )
+                .expect("borrow retained replay timing batch");
+                let repeats = if point_count == 128 { 64 } else { 8 };
+                for (label, helicities) in [
+                    ("all-components", None),
+                    ("all-flows-single-helicity", Some(&selected_helicity_set)),
+                ] {
+                    let mut candidate_output = vec![f64::NAN; point_count];
+                    let mut oracle_output = vec![f64::NAN; point_count];
+                    direct
+                        .runtime
+                        .run_f64_selected_into_unprofiled(
+                            batch,
+                            helicities,
+                            None,
+                            &mut candidate_output,
+                        )
+                        .expect("warm allocation-free replay candidate");
+                    direct
+                        .runtime
+                        .run_f64_selected_into_resolved_replay_oracle(
+                            batch,
+                            helicities,
+                            None,
+                            &mut oracle_output,
+                        )
+                        .expect("warm resolved replay oracle");
+                    let mut candidate_samples = [0u128; 7];
+                    let mut oracle_samples = [0u128; 7];
+                    for sample in 0usize..7 {
+                        if sample.is_multiple_of(2) {
+                            let start = Instant::now();
+                            for _ in 0..repeats {
+                                direct
+                                    .runtime
+                                    .run_f64_selected_into_unprofiled(
+                                        batch,
+                                        helicities,
+                                        None,
+                                        &mut candidate_output,
+                                    )
+                                    .expect("time allocation-free replay candidate");
+                            }
+                            candidate_samples[sample] = start.elapsed().as_nanos() / repeats;
+                            let start = Instant::now();
+                            for _ in 0..repeats {
+                                direct
+                                    .runtime
+                                    .run_f64_selected_into_resolved_replay_oracle(
+                                        batch,
+                                        helicities,
+                                        None,
+                                        &mut oracle_output,
+                                    )
+                                    .expect("time resolved replay oracle");
+                            }
+                            oracle_samples[sample] = start.elapsed().as_nanos() / repeats;
+                        } else {
+                            let start = Instant::now();
+                            for _ in 0..repeats {
+                                direct
+                                    .runtime
+                                    .run_f64_selected_into_resolved_replay_oracle(
+                                        batch,
+                                        helicities,
+                                        None,
+                                        &mut oracle_output,
+                                    )
+                                    .expect("time resolved replay oracle");
+                            }
+                            oracle_samples[sample] = start.elapsed().as_nanos() / repeats;
+                            let start = Instant::now();
+                            for _ in 0..repeats {
+                                direct
+                                    .runtime
+                                    .run_f64_selected_into_unprofiled(
+                                        batch,
+                                        helicities,
+                                        None,
+                                        &mut candidate_output,
+                                    )
+                                    .expect("time allocation-free replay candidate");
+                            }
+                            candidate_samples[sample] = start.elapsed().as_nanos() / repeats;
+                        }
+                        std::hint::black_box((&candidate_output, &oracle_output));
+                    }
+                    candidate_samples.sort_unstable();
+                    oracle_samples.sort_unstable();
+                    let candidate_median = candidate_samples[3];
+                    let oracle_median = oracle_samples[3];
+                    let mut candidate_deviations =
+                        candidate_samples.map(|value| value.abs_diff(candidate_median));
+                    let mut oracle_deviations =
+                        oracle_samples.map(|value| value.abs_diff(oracle_median));
+                    candidate_deviations.sort_unstable();
+                    oracle_deviations.sort_unstable();
+                    eprintln!(
+                        "retained-compiled-replay-wall workload={label} points={point_count} \
+                         samples=7 repeats={repeats} candidate_samples_ns={candidate_samples:?} \
+                         oracle_samples_ns={oracle_samples:?} \
+                         candidate_median_ns={candidate_median} \
+                         candidate_mad_ns={} oracle_median_ns={oracle_median} oracle_mad_ns={} \
+                         candidate_ns_per_point={:.3} oracle_ns_per_point={:.3} speedup={:.6}",
+                        candidate_deviations[3],
+                        oracle_deviations[3],
+                        candidate_median as f64 / point_count as f64,
+                        oracle_median as f64 / point_count as f64,
+                        oracle_median as f64 / candidate_median as f64,
+                    );
+                }
+            }
+        }
+
+        let allocation_points = 128usize;
+        let allocation_momenta = point.repeat(allocation_points);
+        let mut allocation_output = vec![f64::NAN; allocation_points];
+        direct
+            .evaluate_f64_into(
+                &allocation_momenta,
+                allocation_points,
+                &mut allocation_output,
+            )
+            .expect("warm retained Direct evaluate-into");
+        let (result, allocations, allocated_bytes) = count_test_allocations(|| {
+            direct.evaluate_f64_into(
+                &allocation_momenta,
+                allocation_points,
+                &mut allocation_output,
+            )
+        });
+        result.expect("repeat retained Direct evaluate-into");
+        eprintln!(
+            "retained-compiled-direct-public-allocation allocations={allocations} \
+             allocated_bytes={allocated_bytes}"
+        );
+        assert_eq!(
+            allocations, 0,
+            "warmed public compiled Direct evaluation allocated"
+        );
+        assert_eq!(
+            allocated_bytes, 0,
+            "warmed public compiled Direct evaluation allocated bytes"
+        );
+        let arena_profile = direct
+            .evaluate_f64_arena_profile_repeated(
+                &allocation_momenta,
+                allocation_points,
+                3,
+                None,
+                None,
+            )
+            .expect("profile warmed retained Direct evaluate-into boundary");
+        assert_eq!(arena_profile.values.len(), allocation_points);
+        for (point_index, (profiled, expected)) in arena_profile
+            .values
+            .iter()
+            .copied()
+            .zip(&allocation_output)
+            .enumerate()
+        {
+            assert_close_real(
+                profiled,
+                *expected,
+                &format!("warmed retained Direct profile point={point_index}"),
+            );
+        }
+        assert_eq!(
+            arena_profile
+                .profile
+                .native_input_container_allocation_count,
+            0
+        );
+        assert_eq!(arena_profile.profile.native_output_allocation_count, 0);
+        assert_eq!(arena_profile.profile.observed_scratch_reallocation_count, 0);
+        assert!(
+            arena_profile.profile.compiled_direct_arena_engine_count > 0,
+            "warmed Direct profile did not authenticate an Arena engine"
+        );
+        assert_eq!(
+            arena_profile.profile.compiled_direct_arena_call_count,
+            arena_profile.profile.evaluator_backend_call_count,
+        );
+        assert!(
+            arena_profile.profile.compiled_direct_arena_call_count > 0,
+            "warmed Direct profile observed no evaluator calls"
+        );
+        assert_eq!(
+            arena_profile
+                .profile
+                .compiled_direct_arena_minimum_effective_tile_capacity,
+            metadata
+                .compiled_direct_minimum_effective_tile_capacity
+                .unwrap() as u64
+        );
+        assert_eq!(
+            arena_profile
+                .profile
+                .compiled_direct_arena_maximum_physical_scalar_values_per_point,
+            metadata
+                .compiled_direct_maximum_physical_scalar_values_per_point
+                .unwrap() as u64
+        );
+        assert_eq!(
+            arena_profile
+                .profile
+                .compiled_direct_arena_maximum_hot_scalar_values_per_point,
+            metadata
+                .compiled_direct_maximum_hot_scalar_values_per_point
+                .unwrap() as u64
+        );
+        assert_eq!(
+            arena_profile
+                .profile
+                .compiled_direct_arena_maximum_source_scalar_values_per_point,
+            metadata
+                .compiled_direct_maximum_source_scalar_values_per_point
+                .unwrap() as u64
+        );
+        assert_eq!(
+            arena_profile
+                .profile
+                .compiled_direct_arena_maximum_reduction_scalar_values_per_point,
+            metadata
+                .compiled_direct_maximum_reduction_scalar_values_per_point
+                .unwrap() as u64
+        );
+
+        let allocation_batch = F64MomentumBatchView::from_contiguous_prevalidated(
+            &allocation_momenta,
+            allocation_points,
+            direct.runtime.external_count,
+            direct.input_crossing_map.as_deref(),
+        )
+        .expect("borrow retained allocation batch");
+        direct
+            .runtime
+            .run_f64_selected_into_unprofiled(allocation_batch, None, None, &mut allocation_output)
+            .expect("warm retained Direct runtime");
+        let (result, runtime_allocations, runtime_allocated_bytes) = count_test_allocations(|| {
+            direct.runtime.run_f64_selected_into_unprofiled(
+                allocation_batch,
+                None,
+                None,
+                &mut allocation_output,
+            )
+        });
+        result.expect("repeat retained Direct runtime");
+        eprintln!(
+            "retained-compiled-direct-runtime-allocation allocations={runtime_allocations} \
+             allocated_bytes={runtime_allocated_bytes}"
+        );
+        assert_eq!(
+            runtime_allocations, 0,
+            "warmed compiled Direct runtime allocated"
+        );
+        assert_eq!(
+            runtime_allocated_bytes, 0,
+            "warmed compiled Direct runtime allocated bytes"
+        );
+
+        let selected_color_ids = [selected_color.clone()];
+        let selected_helicity_ids = [selected_helicity.clone()];
+        let selected_colors = BTreeSet::from([selected_color]);
+        let selected_helicities = BTreeSet::from([selected_helicity]);
+        let mut allocation_cases = vec![("selected-helicity", Some(&selected_helicities), None)];
+        if direct.metadata().color_accuracy == "lc" {
+            allocation_cases.push(("selected-flow", None, Some(&selected_colors)));
+        }
+        for (allocation_label, allocation_helicities, allocation_colors) in allocation_cases {
+            direct
+                .runtime
+                .run_f64_selected_into_unprofiled(
+                    allocation_batch,
+                    allocation_helicities,
+                    allocation_colors,
+                    &mut allocation_output,
+                )
+                .expect("warm retained Direct selected runtime");
+            let (result, selected_allocations, selected_allocated_bytes) =
+                count_test_allocations(|| {
+                    direct.runtime.run_f64_selected_into_unprofiled(
+                        allocation_batch,
+                        allocation_helicities,
+                        allocation_colors,
+                        &mut allocation_output,
+                    )
+                });
+            result.expect("repeat retained Direct selected runtime");
+            eprintln!(
+                "retained-compiled-direct-{allocation_label}-allocation \
+                 allocations={selected_allocations} allocated_bytes={selected_allocated_bytes}"
+            );
+            assert_eq!(
+                selected_allocations, 0,
+                "warmed selected Direct arena execution allocated"
+            );
+            assert_eq!(
+                selected_allocated_bytes, 0,
+                "warmed selected Direct arena execution allocated bytes"
+            );
+        }
+        let mut profile_cases = vec![(
+            "selected-helicity",
+            Some(selected_helicity_ids.as_slice()),
+            None,
+        )];
+        if direct.metadata().color_accuracy == "lc" {
+            profile_cases.push(("selected-flow", None, Some(selected_color_ids.as_slice())));
+        }
+        for (label, helicities, colors) in profile_cases {
+            direct
+                .evaluate_f64_into_with_selectors(
+                    &allocation_momenta,
+                    allocation_points,
+                    helicities,
+                    colors,
+                    None,
+                    None,
+                    &mut allocation_output,
+                )
+                .unwrap_or_else(|error| panic!("evaluate retained Direct {label} oracle: {error}"));
+            let selected_profile = direct
+                .evaluate_f64_arena_profile_repeated(
+                    &allocation_momenta,
+                    allocation_points,
+                    3,
+                    helicities,
+                    colors,
+                )
+                .unwrap_or_else(|error| panic!("profile retained Direct {label}: {error}"));
+            for (point_index, (profiled, expected)) in selected_profile
+                .values
+                .iter()
+                .copied()
+                .zip(&allocation_output)
+                .enumerate()
+            {
+                assert_close_real(
+                    profiled,
+                    *expected,
+                    &format!("profiled retained Direct {label} point={point_index}"),
+                );
+            }
+            assert_eq!(
+                selected_profile
+                    .profile
+                    .native_input_container_allocation_count,
+                0,
+                "profiled retained Direct {label} input allocations"
+            );
+            assert_eq!(
+                selected_profile.profile.native_output_allocation_count, 0,
+                "profiled retained Direct {label} output allocations"
+            );
+            assert_eq!(
+                selected_profile.profile.observed_scratch_reallocation_count, 0,
+                "profiled retained Direct {label} scratch reallocations"
+            );
+        }
+
+        let (engine_count, requested_bytes, hot_calls, minimum_tile_capacity) =
+            compiled_direct_runtime_summary(&direct.runtime);
+        assert!(hot_calls > 0, "retained production Direct leaves executed");
+        eprintln!(
+            "retained-compiled-direct-production-final engines={engine_count} \
+             requested_bytes={requested_bytes} hot_calls={hot_calls} \
+             minimum_tile_capacity={minimum_tile_capacity}"
+        );
+    }
+
+    #[test]
+    fn retained_compiled_replay_totals_quick_contract() {
+        let Some(root) = std::env::var_os("RUSTICOL_TEST_COMPILED_REPLAY_QUICK_ARTIFACT") else {
+            return;
+        };
+        let mut runtime =
+            NativeRuntime::load(PathBuf::from(root), None, None).expect("load replay artifact");
+        assert_eq!(
+            runtime.metadata().color_accuracy,
+            "lc",
+            "quick replay contract requires LC"
+        );
+        let point = retained_validation_point(&runtime);
+        let helicities = runtime.helicities().expect("retained helicity metadata");
+        let selected_helicity = helicities
+            .iter()
+            .find(|helicity| helicity.computed && !helicity.structural_zero)
+            .expect("retained artifact has a nonzero computed helicity")
+            .id
+            .clone();
+        let colors = runtime.color_components().expect("retained color metadata");
+        let selected_color = colors
+            .last()
+            .expect("retained artifact has one physical color")
+            .id
+            .clone();
+        let selected_helicities = BTreeSet::from([selected_helicity]);
+        let selected_colors = BTreeSet::from([selected_color]);
+
+        let parity_points = 7usize;
+        let parity_momenta = point.repeat(parity_points);
+        let parity_batch = F64MomentumBatchView::from_contiguous_prevalidated(
+            &parity_momenta,
+            parity_points,
+            runtime.runtime.external_count,
+            runtime.input_crossing_map.as_deref(),
+        )
+        .expect("borrow replay parity batch");
+        for (label, helicities, colors) in [
+            ("all-components", None, None),
+            (
+                "all-flows-single-helicity",
+                Some(&selected_helicities),
+                None,
+            ),
+            ("single-flow-helicity-sum", None, Some(&selected_colors)),
+        ] {
+            let mut candidate = vec![f64::NAN; parity_points];
+            let mut oracle = vec![f64::NAN; parity_points];
+            runtime
+                .runtime
+                .run_f64_selected_into_unprofiled(parity_batch, helicities, colors, &mut candidate)
+                .expect("evaluate allocation-free replay candidate");
+            runtime
+                .runtime
+                .run_f64_selected_into_resolved_replay_oracle(
+                    parity_batch,
+                    helicities,
+                    colors,
+                    &mut oracle,
+                )
+                .expect("evaluate resolved replay oracle");
+            for (point_index, (candidate, oracle)) in
+                candidate.iter().copied().zip(oracle).enumerate()
+            {
+                assert_close_real(
+                    candidate,
+                    oracle,
+                    &format!("{label} quick replay point={point_index}"),
+                );
+            }
+        }
+
+        let allocation_points = 128usize;
+        let allocation_momenta = point.repeat(allocation_points);
+        let allocation_batch = F64MomentumBatchView::from_contiguous_prevalidated(
+            &allocation_momenta,
+            allocation_points,
+            runtime.runtime.external_count,
+            runtime.input_crossing_map.as_deref(),
+        )
+        .expect("borrow replay allocation batch");
+        let mut output = vec![f64::NAN; allocation_points];
+        for (label, helicities, colors) in [
+            ("all-components", None, None),
+            (
+                "all-flows-single-helicity",
+                Some(&selected_helicities),
+                None,
+            ),
+            ("single-flow-helicity-sum", None, Some(&selected_colors)),
+        ] {
+            runtime
+                .runtime
+                .run_f64_selected_into_unprofiled(allocation_batch, helicities, colors, &mut output)
+                .expect("warm replay allocation workload");
+            let (result, allocations, allocated_bytes) = count_test_allocations(|| {
+                runtime.runtime.run_f64_selected_into_unprofiled(
+                    allocation_batch,
+                    helicities,
+                    colors,
+                    &mut output,
+                )
+            });
+            result.expect("repeat replay allocation workload");
+            eprintln!(
+                "retained-compiled-replay-quick-allocation workload={label} \
+                 allocations={allocations} allocated_bytes={allocated_bytes}"
+            );
+            assert_eq!(allocations, 0, "warmed replay workload {label} allocated");
+            assert_eq!(
+                allocated_bytes, 0,
+                "warmed replay workload {label} allocated bytes"
+            );
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/contraction_metadata_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/contraction_metadata_tests.rs
new file mode 100644
index 0000000000..418d451636
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/contraction_metadata_tests.rs
@@ -0,0 +1,388 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use serde_json::{Value, json};
+
+fn contraction_value() -> Value {
+    json!({
+        "name": "weyl",
+        "left_basis": "weyl-chiral",
+        "right_basis": "weyl-chiral",
+        "coefficients": [[1.0, 0.0], [1.0, 0.0]],
+        "chirality_relation": "opposite",
+        "metric_signature": null,
+    })
+}
+
+fn slot(current_id: usize, start: usize) -> Value {
+    json!({
+        "current_id": current_id,
+        "component_start": start,
+        "component_stop": start + 2,
+        "dimension": 2,
+    })
+}
+
+fn value_slot(value_slot_id: usize, current_id: usize, start: usize) -> Value {
+    json!({
+        "value_slot_id": value_slot_id,
+        "current_id": current_id,
+        "variant": "source",
+        "component_start": start,
+        "component_stop": start + 2,
+        "dimension": 2,
+    })
+}
+
+fn root_value() -> Value {
+    json!({
+        "output_index": 0,
+        "root_id": 0,
+        "kind": "direct-contraction",
+        "left_current_id": 0,
+        "right_current_id": 1,
+        "left_slot": slot(0, 0),
+        "right_slot": slot(1, 2),
+        "left_value_slot": value_slot(0, 0, 0),
+        "right_value_slot": value_slot(1, 1, 2),
+        "vertex_kind": null,
+        "vertex_particles": null,
+        "coupling": [1.0, 0.0],
+        "color_weight": [1.0, 0.0],
+        "color_sector_id": 0,
+        "contraction": "weyl",
+        "contraction_ir": contraction_value(),
+        "coherent_group_id": 0,
+        "helicity_weight": 1.0,
+        "all_sector_weight": 1.0,
+    })
+}
+
+fn current_storage() -> GenericCurrentStorageManifest {
+    serde_json::from_value(json!({
+        "component_count": 4,
+        "number_type": "complex",
+        "metadata_compacted": true,
+        "current_slots": [
+            {
+                "current_id": 0,
+                "component_start": 0,
+                "component_stop": 2,
+                "dimension": 2,
+                "is_source": true,
+                "particle_id": 1,
+                "external_mask": 1,
+                "external_labels": [1],
+                "helicity_ancestry": 1,
+                "chirality": 1,
+                "spin_state": 1,
+                "flavour_flow": [],
+                "color_state": {},
+                "momentum_mask": 1,
+                "auxiliary_kind": null
+            },
+            {
+                "current_id": 1,
+                "component_start": 2,
+                "component_stop": 4,
+                "dimension": 2,
+                "is_source": true,
+                "particle_id": -1,
+                "external_mask": 2,
+                "external_labels": [2],
+                "helicity_ancestry": 1,
+                "chirality": -1,
+                "spin_state": -1,
+                "flavour_flow": [],
+                "color_state": {},
+                "momentum_mask": 2,
+                "auxiliary_kind": null
+            }
+        ]
+    }))
+    .expect("current storage")
+}
+
+fn propagator(particle_id: i32, anti_particle_id: i32, orientation: &str) -> Value {
+    json!({
+        "identity": {
+            "canonical_id": format!("model:test:state:{particle_id}"),
+            "species_id": "model:test:species:fermion",
+            "anti_canonical_id": format!("model:test:state:{anti_particle_id}"),
+            "display_name": format!("state_{particle_id}"),
+            "anti_display_name": format!("state_{anti_particle_id}"),
+            "pdg_label": particle_id,
+            "anti_pdg_label": anti_particle_id,
+            "orientation": orientation,
+            "self_conjugate": false
+        },
+        "particle_id": particle_id,
+        "chirality": if particle_id > 0 { 1 } else { -1 },
+        "kind": "weyl-fermion",
+        "backend": "spenso",
+        "basis": "weyl-chiral",
+        "applies_propagator": true,
+        "kernel": "test-weyl",
+        "full_tensor_network_ready": true,
+        "mass_class": "massless",
+        "gauge": null,
+        "numerator": "test",
+        "denominator": "test",
+        "mass_parameter": null,
+        "width_parameter": null,
+        "custom_source": null,
+        "auxiliary_policy": null,
+        "goldstone_policy": "not-applicable",
+        "description": "test"
+    })
+}
+
+fn stored_value_slot(
+    value_slot_id: usize,
+    current_id: usize,
+    start: usize,
+    particle_id: i32,
+) -> Value {
+    json!({
+        "value_slot_id": value_slot_id,
+        "current_id": current_id,
+        "variant": "source",
+        "component_start": start,
+        "component_stop": start + 2,
+        "dimension": 2,
+        "current_component_start": start,
+        "current_component_stop": start + 2,
+        "is_source": true,
+        "applies_propagator": false,
+        "particle_id": particle_id,
+        "external_mask": 1_u64 << current_id,
+        "external_labels": [current_id + 1],
+        "momentum_mask": 1_u64 << current_id,
+        "chirality": if particle_id > 0 { 1 } else { -1 },
+        "propagator": propagator(
+            particle_id,
+            -particle_id,
+            if particle_id > 0 { "particle" } else { "antiparticle" },
+        )
+    })
+}
+
+fn value_storage() -> GenericValueStorageManifest {
+    serde_json::from_value(json!({
+        "component_count": 4,
+        "number_type": "complex",
+        "metadata_compacted": true,
+        "value_slots": [
+            stored_value_slot(0, 0, 0, 1),
+            stored_value_slot(1, 1, 2, -1)
+        ]
+    }))
+    .expect("value storage")
+}
+
+fn root() -> GenericAmplitudeRootManifest {
+    serde_json::from_value(root_value()).expect("amplitude root")
+}
+
+#[test]
+fn contraction_ir_requires_strict_complete_metadata() {
+    let parsed: GenericContractionIrManifest =
+        serde_json::from_value(contraction_value()).expect("ContractionIR");
+    assert_eq!(parsed.coefficients.len(), 2);
+
+    let mut missing_nullable = contraction_value();
+    missing_nullable
+        .as_object_mut()
+        .expect("contraction object")
+        .remove("metric_signature");
+    let error =
+        serde_json::from_value::<GenericContractionIrManifest>(missing_nullable).unwrap_err();
+    assert!(error.to_string().contains("metric_signature"));
+
+    let mut malformed_pair = contraction_value();
+    malformed_pair["coefficients"] = json!([[1.0], [1.0, 0.0]]);
+    assert!(serde_json::from_value::<GenericContractionIrManifest>(malformed_pair).is_err());
+
+    let mut unknown = contraction_value();
+    unknown["inferred_from_dimension"] = json!(true);
+    let error = serde_json::from_value::<GenericContractionIrManifest>(unknown).unwrap_err();
+    assert!(error.to_string().contains("unknown field"));
+}
+
+#[test]
+fn pre_contraction_ir_schema_v3_reports_actionable_regeneration_error() {
+    let mut missing = root_value();
+    missing
+        .as_object_mut()
+        .expect("root object")
+        .remove("contraction_ir");
+    let parse_error = serde_json::from_value::<GenericAmplitudeRootManifest>(missing).unwrap_err();
+
+    let error = execution_manifest_parse_error("processes/example/execution.json", parse_error);
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+    assert!(
+        error
+            .to_string()
+            .contains("typed amplitude-contraction metadata")
+    );
+    assert!(error.to_string().contains("regenerate"));
+}
+
+#[test]
+fn direct_contraction_ir_matches_projection_slots_and_chirality() {
+    let currents = current_storage();
+    let values = value_storage();
+    validate_amplitude_contraction(0, &root(), &currents, &values)
+        .expect("valid typed contraction");
+
+    let mut projection_mismatch = root();
+    projection_mismatch.contraction = "display-only-mismatch".to_string();
+    assert!(
+        validate_amplitude_contraction(0, &projection_mismatch, &currents, &values)
+            .unwrap_err()
+            .to_string()
+            .contains("projection")
+    );
+
+    let mut basis_mismatch = root();
+    basis_mismatch.contraction_ir.left_basis = "dirac".to_string();
+    assert!(
+        validate_amplitude_contraction(0, &basis_mismatch, &currents, &values)
+            .unwrap_err()
+            .to_string()
+            .contains("value slots")
+    );
+
+    let mut dimension_mismatch = root();
+    dimension_mismatch.contraction_ir.coefficients.pop();
+    assert!(
+        validate_amplitude_contraction(0, &dimension_mismatch, &currents, &values)
+            .unwrap_err()
+            .to_string()
+            .contains("value slots")
+    );
+
+    let mut chirality_mismatch = root();
+    chirality_mismatch.contraction_ir.chirality_relation =
+        GenericContractionChiralityRelationManifest::Equal;
+    assert!(
+        validate_amplitude_contraction(0, &chirality_mismatch, &currents, &values)
+            .unwrap_err()
+            .to_string()
+            .contains("chirality relation")
+    );
+}
+
+#[test]
+fn contraction_ir_rejects_nonfinite_zero_and_invalid_vertex_projection() {
+    let currents = current_storage();
+    let values = value_storage();
+
+    let mut nonfinite = root();
+    nonfinite.contraction_ir.coefficients[0][0] = f64::NAN;
+    assert!(
+        validate_amplitude_contraction(0, &nonfinite, &currents, &values)
+            .unwrap_err()
+            .to_string()
+            .contains("invalid typed contraction")
+    );
+
+    let mut zero = root();
+    zero.contraction_ir.coefficients = vec![[0.0, 0.0], [0.0, 0.0]];
+    assert!(
+        validate_amplitude_contraction(0, &zero, &currents, &values)
+            .unwrap_err()
+            .to_string()
+            .contains("invalid typed contraction")
+    );
+
+    let mut vertex = root();
+    vertex.kind = "vertex-closure".to_string();
+    vertex.vertex_kind = Some(1);
+    vertex.vertex_particles = Some(vec![1, -1, 25]);
+    vertex.contraction = "scalar".to_string();
+    vertex.contraction_ir = serde_json::from_value(json!({
+        "name": "scalar",
+        "left_basis": "scalar",
+        "right_basis": "scalar",
+        "coefficients": [[1.0, 0.0]],
+        "chirality_relation": "any",
+        "metric_signature": null
+    }))
+    .expect("scalar projection");
+    validate_amplitude_contraction(0, &vertex, &currents, &values)
+        .expect("valid scalar projection");
+
+    vertex.contraction_ir.right_basis = "lorentz-vector".to_string();
+    assert!(
+        validate_amplitude_contraction(0, &vertex, &currents, &values)
+            .unwrap_err()
+            .to_string()
+            .contains("scalar projection")
+    );
+}
+
+#[test]
+fn amplitude_slots_match_storage_and_extreme_chiralities_are_safe() {
+    let currents = current_storage();
+    let valid_root = root();
+    validate_slot_ref(&valid_root.left_slot, 0, &currents).expect("matching current slot");
+
+    let mut mismatched = valid_root.left_slot;
+    mismatched.component_start += 1;
+    mismatched.component_stop += 1;
+    assert!(
+        validate_slot_ref(&mismatched, 0, &currents)
+            .unwrap_err()
+            .to_string()
+            .contains("does not match current storage")
+    );
+
+    assert!(!valid_current_chirality(i32::MIN));
+    assert!(!contraction_chiralities_match(
+        GenericContractionChiralityRelationManifest::Opposite,
+        0,
+        i32::MIN,
+    ));
+}
+
+#[test]
+fn amplitude_root_kind_is_discriminated_and_matches_current_particles() {
+    let currents = current_storage();
+    let direct = root();
+    validate_amplitude_root_kind(0, &direct, &currents).expect("direct contraction");
+
+    let mut stale_direct = root();
+    stale_direct.vertex_kind = Some(1);
+    stale_direct.vertex_particles = Some(vec![1, -1, 25]);
+    assert!(
+        validate_amplitude_root_kind(0, &stale_direct, &currents)
+            .unwrap_err()
+            .to_string()
+            .contains("carries vertex metadata")
+    );
+
+    let mut vertex = root();
+    vertex.kind = "vertex-closure".to_string();
+    vertex.vertex_kind = Some(1);
+    vertex.vertex_particles = Some(vec![1, -1, 25]);
+    validate_amplitude_root_kind(0, &vertex, &currents).expect("matching vertex closure");
+
+    vertex.vertex_kind = Some(-1);
+    assert!(
+        validate_amplitude_root_kind(0, &vertex, &currents)
+            .unwrap_err()
+            .to_string()
+            .contains("invalid vertex kind")
+    );
+
+    vertex.vertex_kind = Some(1);
+    vertex.vertex_particles = Some(vec![-1, 1, 25]);
+    assert!(
+        validate_amplitude_root_kind(0, &vertex, &currents)
+            .unwrap_err()
+            .to_string()
+            .contains("does not match its input currents")
+    );
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/correlated.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/correlated.rs
new file mode 100644
index 0000000000..84fe838504
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/correlated.rs
@@ -0,0 +1,852 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Opt-in coherent Born correlations. Ordinary reductions never enter this lane.
+
+use super::*;
+
+/// One literal complex four-vector broadcasts; otherwise supply one per point.
+pub type NativeSpinCorrelationVectors = BTreeMap<usize, Vec<[[f64; 2]; 4]>>;
+
+#[derive(Clone, Debug)]
+pub struct NativeCorrelatedRequest {
+    pub color_correlation: String,
+    /// None inherits the runtime setter; an empty map restores physical sources.
+    pub spin_vectors: Option<NativeSpinCorrelationVectors>,
+}
+
+impl Default for NativeCorrelatedRequest {
+    fn default() -> Self {
+        Self {
+            color_correlation: "born".into(),
+            spin_vectors: None,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct NativeCorrelatedEvaluation {
+    pub point_count: usize,
+    pub request_count: usize,
+    /// Request-major: values[request * point_count + point].
+    pub values: Vec<[f64; 2]>,
+}
+
+#[derive(Deserialize)]
+struct Catalogue {
+    schema_version: u32,
+    complete_source_basis: bool,
+    processes: BTreeMap<String, ProcessCatalogue>,
+}
+
+#[derive(Deserialize)]
+struct ProcessCatalogue {
+    declarations: Declarations,
+    spin_legs: Vec<usize>,
+    matrices: Vec<MatrixRecord>,
+    coherent_groups: Vec<GroupRecord>,
+}
+
+#[derive(Deserialize)]
+struct Declarations {
+    color_correlations: Vec<Declaration>,
+    spin_correlations: Vec<Vec<usize>>,
+}
+
+#[derive(Deserialize)]
+struct Declaration {
+    id: String,
+    bra: Vec<Value>,
+    ket: Vec<Value>,
+}
+
+#[derive(Deserialize)]
+struct GroupRecord {
+    group_id: i64,
+    helicities: Vec<i32>,
+    color_sector_id: i64,
+    color_word: Vec<i64>,
+}
+
+#[derive(Deserialize)]
+struct MatrixRecord {
+    id: String,
+    order: usize,
+    bra: Vec<Value>,
+    ket: Vec<Value>,
+    convention: String,
+    color_accuracy: String,
+    output_legs: Value,
+    sector_ids: Vec<i64>,
+    storage: String,
+    includes_color_factor: bool,
+    entries: Vec<EntryRecord>,
+}
+
+#[derive(Deserialize)]
+struct EntryRecord {
+    left_sector_id: i64,
+    right_sector_id: i64,
+    weight: WeightRecord,
+}
+
+#[derive(Deserialize)]
+struct WeightRecord {
+    real: [Value; 2],
+    imag: [Value; 2],
+}
+
+struct Matrix {
+    id: String,
+    sectors: BTreeSet<i64>,
+    entries: Vec<(i64, i64, [f64; 2])>,
+}
+
+struct Group {
+    helicity_id: String,
+    helicities: Vec<i32>,
+    sector: i64,
+    roots: Vec<usize>,
+}
+
+pub(super) struct CorrelatedRuntime {
+    catalogue_json: String,
+    matrices: Vec<Matrix>,
+    spin_classes: BTreeSet<Vec<usize>>,
+    known_helicities: BTreeSet<String>,
+    groups: Vec<Group>,
+    vectors: NativeSpinCorrelationVectors,
+}
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+fn malformed(message: impl Into<String>) -> RusticolError {
+    RusticolError::integrity(format!(
+        "invalid correlated process output: {}",
+        message.into()
+    ))
+}
+
+fn validate_catalogue_artifact_id(loaded: &str, reopened: &str) -> RusticolResult<()> {
+    if loaded != reopened {
+        return Err(malformed(
+            "process output changed since the runtime was loaded; reload the runtime before correlated evaluation",
+        ));
+    }
+    Ok(())
+}
+
+fn rational_f64(parts: &[Value; 2]) -> RusticolResult<f64> {
+    let integer = |value: &Value| -> RusticolResult<f64> {
+        let text = match value {
+            Value::String(text) => text.clone(),
+            Value::Number(number) if number.is_i64() || number.is_u64() => number.to_string(),
+            _ => return Err(malformed("matrix coefficient is not an integer")),
+        };
+        let digits = text.strip_prefix('-').unwrap_or(&text);
+        if digits.is_empty() || !digits.bytes().all(|value| value.is_ascii_digit()) {
+            return Err(malformed("matrix coefficient is not an integer"));
+        }
+        text.parse::<f64>()
+            .ok()
+            .filter(|value| value.is_finite())
+            .ok_or_else(|| malformed("matrix coefficient exceeds binary64 range"))
+    };
+    let denominator = integer(&parts[1])?;
+    if denominator == 0.0 {
+        return Err(malformed("zero matrix denominator"));
+    }
+    let value = integer(&parts[0])? / denominator;
+    if !value.is_finite() {
+        return Err(malformed("matrix coefficient exceeds binary64 range"));
+    }
+    Ok(value)
+}
+
+impl CorrelatedRuntime {
+    fn load(native: &NativeRuntime) -> RusticolResult<Self> {
+        let identity = native
+            .external_permutation
+            .iter()
+            .copied()
+            .eq(0..native.runtime.external_count);
+        if let Some(group) = native.process_group.as_deref()
+            && (group.conjugated || !identity)
+        {
+            return Err(RusticolError::compatibility(format!(
+                "correlated evaluation of process-group member {:?} through its representative {:?} is available only for an identity leg order without charge conjugation; generate the process explicitly",
+                native.process_key, group.representative_process_key
+            )));
+        }
+        if !matches!(native.execution_lane, NativeExecutionLane::Compiled) || !identity {
+            return Err(RusticolError::compatibility(
+                "correlations require compiled process output with identity external ordering",
+            ));
+        }
+        let artifact = VerifiedArtifact::open(&native.root)?;
+        validate_catalogue_artifact_id(&native.artifact_id, &artifact.manifest().artifact_id)?;
+        let extension = artifact
+            .manifest()
+            .extensions
+            .get("correlators")
+            .ok_or_else(|| {
+                RusticolError::compatibility("correlations must be declared at generation")
+            })?;
+        if extension.get("schema_version").and_then(Value::as_u64) != Some(1) {
+            return Err(malformed("unsupported catalogue version"));
+        }
+        let path = extension
+            .get("path")
+            .and_then(Value::as_str)
+            .ok_or_else(|| malformed("missing catalogue path"))?;
+        let mut payload: Catalogue = serde_json::from_slice(&artifact.read_payload(path)?)
+            .map_err(|error| malformed(format!("catalogue: {error}")))?;
+        if payload.schema_version != 1 || !payload.complete_source_basis {
+            return Err(malformed("correlations require a complete source basis"));
+        }
+        let process = payload
+            .processes
+            .remove(&native.representative_process_id)
+            .ok_or_else(|| malformed("selected process is absent from catalogue"))?;
+        Self::from_process(process, &native.runtime, native.process_physics()?)
+    }
+
+    fn from_process(
+        process: ProcessCatalogue,
+        runtime: &ExecutionRuntime,
+        physics: &ProcessPhysicsV1,
+    ) -> RusticolResult<Self> {
+        if runtime.lc_topology_replay_enabled
+            || runtime.color_topology_replay_enabled
+            || runtime.helicity_recurrence.is_some()
+            || runtime.helicity_sum_runtime.is_some()
+        {
+            return Err(malformed(
+                "correlated amplitudes must not use physical-helicity reductions",
+            ));
+        }
+        let spin_classes: BTreeSet<_> =
+            process.declarations.spin_correlations.into_iter().collect();
+        let mut spin_legs = BTreeSet::new();
+        for class in &spin_classes {
+            if class.is_empty()
+                || class.windows(2).any(|pair| pair[0] >= pair[1])
+                || class
+                    .iter()
+                    .any(|&leg| leg == 0 || leg > runtime.external_count)
+            {
+                return Err(malformed("invalid joint spin-correlation class"));
+            }
+            spin_legs.extend(class.iter().copied());
+        }
+        if spin_legs.iter().copied().collect::<Vec<_>>() != process.spin_legs {
+            return Err(malformed("inconsistent declared spin legs"));
+        }
+        for leg in spin_legs {
+            let sources: Vec<_> = runtime
+                .sources
+                .iter()
+                .filter(|source| source.leg_label == leg)
+                .collect();
+            if sources.is_empty()
+                || sources.iter().any(|source| {
+                    !matches!(
+                        source.source_ir.wavefunction_family,
+                        GenericWavefunctionFamilyManifest::Vector
+                    ) || source.source_ir.component_dimension != 4
+                        || source
+                            .value_slot
+                            .component_stop
+                            .checked_sub(source.value_slot.component_start)
+                            != Some(4)
+                })
+            {
+                return Err(malformed(
+                    "spin correlation requires retained four-component vector sources",
+                ));
+            }
+        }
+        let mut declarations = BTreeMap::from([("born".to_owned(), (Vec::new(), Vec::new()))]);
+        for declaration in process.declarations.color_correlations {
+            if declaration.id.is_empty()
+                || declarations
+                    .insert(declaration.id, (declaration.bra, declaration.ket))
+                    .is_some()
+            {
+                return Err(malformed("repeated correlation declaration"));
+            }
+        }
+        let mut matrices = Vec::new();
+        let mut catalogue = Vec::new();
+        for matrix in process.matrices {
+            if matrix.convention != "su3-literal-tau-physical-charge-all-outgoing-v1"
+                || !["lc", "nlc", "full"].contains(&matrix.color_accuracy.as_str())
+                || matrix.storage != "sparse-directed"
+                || !matrix.includes_color_factor
+                || matrix.order != matrix.bra.len()
+                || matrix.order != matrix.ket.len()
+                || declarations.remove(&matrix.id) != Some((matrix.bra.clone(), matrix.ket.clone()))
+            {
+                return Err(malformed("unsupported or inconsistent colour matrix"));
+            }
+            let sectors: BTreeSet<_> = matrix.sector_ids.iter().copied().collect();
+            if sectors.is_empty()
+                || sectors.len() != matrix.sector_ids.len()
+                || sectors.iter().any(|&id| id < 0)
+            {
+                return Err(malformed("invalid matrix sector IDs"));
+            }
+            let mut pairs = BTreeSet::new();
+            let mut entries = Vec::new();
+            for entry in matrix.entries {
+                if !sectors.contains(&entry.left_sector_id)
+                    || !sectors.contains(&entry.right_sector_id)
+                    || !pairs.insert((entry.left_sector_id, entry.right_sector_id))
+                {
+                    return Err(malformed("invalid or repeated matrix entry"));
+                }
+                entries.push((
+                    entry.left_sector_id,
+                    entry.right_sector_id,
+                    [
+                        rational_f64(&entry.weight.real)?,
+                        rational_f64(&entry.weight.imag)?,
+                    ],
+                ));
+            }
+            catalogue.push(serde_json::json!({"id":matrix.id,"order":matrix.order,"bra":matrix.bra,"ket":matrix.ket,
+                "color_accuracy":matrix.color_accuracy,"output_legs":matrix.output_legs,"sector_ids":matrix.sector_ids}));
+            matrices.push(Matrix {
+                id: matrix.id,
+                sectors,
+                entries,
+            });
+        }
+        if !declarations.is_empty() {
+            return Err(malformed("missing colour matrices"));
+        }
+        let mut known_helicities = BTreeSet::new();
+        let mut helicities = BTreeMap::new();
+        let mut computed = BTreeSet::new();
+        for helicity in &physics.helicities {
+            if helicity.id != helicity.representative_id
+                || helicity.values.len() != runtime.external_count
+                || helicity.computed == helicity.structural_zero
+                || helicity.coefficient != if helicity.computed { 1.0 } else { 0.0 }
+                || !known_helicities.insert(helicity.id.clone())
+                || helicities
+                    .insert(helicity.values.clone(), helicity.id.clone())
+                    .is_some()
+            {
+                return Err(malformed(
+                    "correlations require complete unquotiented helicities",
+                ));
+            }
+            if helicity.computed {
+                computed.insert(helicity.id.clone());
+            }
+        }
+        let amplitude = runtime
+            .amplitude_stage
+            .as_ref()
+            .ok_or_else(|| malformed("missing amplitude stage"))?;
+        if amplitude
+            .raw_sum_weights
+            .iter()
+            .any(|&weight| weight != 1.0)
+            || amplitude
+                .raw_sum_all_sector_weights
+                .iter()
+                .any(|&weight| weight != 1.0)
+        {
+            return Err(malformed("correlated roots have folded weights"));
+        }
+        let raw: BTreeMap<_, _> = amplitude
+            .raw_sum_groups
+            .iter()
+            .map(|group| (group.id, group))
+            .collect();
+        let mut seen = BTreeSet::new();
+        let mut roots = BTreeSet::new();
+        let mut groups: Vec<Group> = Vec::new();
+        let mut physical = BTreeMap::new();
+        let mut words = BTreeMap::new();
+        for record in process.coherent_groups {
+            let helicity_id = helicities
+                .get(&record.helicities)
+                .filter(|id| computed.contains(*id))
+                .ok_or_else(|| malformed("unknown coherent helicity"))?;
+            let group = raw
+                .get(&record.group_id)
+                .ok_or_else(|| malformed("unknown coherent group"))?;
+            if !seen.insert(record.group_id)
+                || group.weight != 1.0
+                || group.all_sector_weight != 1.0
+            {
+                return Err(malformed("repeated or folded coherent group"));
+            }
+            if group
+                .indices
+                .iter()
+                .any(|&index| index >= runtime.amplitude_output_count || !roots.insert(index))
+            {
+                return Err(malformed("invalid coherent root mapping"));
+            }
+            let key = (record.helicities.clone(), record.color_sector_id);
+            let position = if let Some(&position) = physical.get(&key) {
+                if words.get(&key) != Some(&record.color_word) {
+                    return Err(malformed("inconsistent coherent colour word"));
+                }
+                position
+            } else {
+                let position = groups.len();
+                physical.insert(key.clone(), position);
+                words.insert(key, record.color_word);
+                groups.push(Group {
+                    helicity_id: helicity_id.clone(),
+                    helicities: record.helicities,
+                    sector: record.color_sector_id,
+                    roots: Vec::new(),
+                });
+                position
+            };
+            groups[position].roots.extend(group.indices.iter().copied());
+        }
+        if seen.len() != raw.len()
+            || roots.len() != runtime.amplitude_output_count
+            || groups
+                .iter()
+                .map(|group| group.helicity_id.clone())
+                .collect::<BTreeSet<_>>()
+                != computed
+        {
+            return Err(malformed("incomplete coherent amplitude coverage"));
+        }
+        let mut basis: BTreeMap<&str, BTreeSet<i64>> = BTreeMap::new();
+        for group in &groups {
+            basis
+                .entry(&group.helicity_id)
+                .or_default()
+                .insert(group.sector);
+        }
+        if matrices
+            .iter()
+            .any(|matrix| basis.values().any(|sectors| sectors != &matrix.sectors))
+        {
+            return Err(malformed(
+                "coherent groups do not cover the colour matrices",
+            ));
+        }
+        let catalogue_json =
+            serde_json::to_string(&catalogue).map_err(|error| malformed(error.to_string()))?;
+        Ok(Self {
+            catalogue_json,
+            matrices,
+            spin_classes,
+            known_helicities,
+            groups,
+            vectors: BTreeMap::new(),
+        })
+    }
+
+    fn validate_vectors(
+        &self,
+        vectors: &NativeSpinCorrelationVectors,
+        point_count: Option<usize>,
+    ) -> RusticolResult<()> {
+        let legs: Vec<_> = vectors.keys().copied().collect();
+        if !legs.is_empty() && !self.spin_classes.contains(&legs) {
+            return Err(invalid(
+                "this joint spin-correlation class was not declared at generation",
+            ));
+        }
+        for batch in vectors.values() {
+            if batch.is_empty()
+                || point_count.is_some_and(|count| batch.len() != 1 && batch.len() != count)
+                || batch
+                    .iter()
+                    .flatten()
+                    .flatten()
+                    .any(|value| !value.is_finite())
+            {
+                return Err(invalid(
+                    "spin vectors must be finite, with one vector or one per phase-space point",
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    fn selected_groups(
+        &self,
+        ids: Option<&[String]>,
+        vectors: &NativeSpinCorrelationVectors,
+    ) -> Vec<usize> {
+        let selected = |group: &Group| ids.is_none_or(|ids| ids.contains(&group.helicity_id));
+        let spectator = |group: &Group| {
+            group
+                .helicities
+                .iter()
+                .enumerate()
+                .filter(|(leg, _)| !vectors.contains_key(&(leg + 1)))
+                .map(|(_, &value)| value)
+                .collect::<Vec<_>>()
+        };
+        let mut representatives: BTreeMap<Vec<i32>, &Vec<i32>> = BTreeMap::new();
+        for group in self.groups.iter().filter(|group| selected(group)) {
+            representatives
+                .entry(spectator(group))
+                .and_modify(|values| {
+                    if group.helicities < **values {
+                        *values = &group.helicities;
+                    }
+                })
+                .or_insert(&group.helicities);
+        }
+        self.groups
+            .iter()
+            .enumerate()
+            .filter(|(_, group)| {
+                selected(group)
+                    && representatives.get(&spectator(group)) == Some(&&group.helicities)
+            })
+            .map(|(index, _)| index)
+            .collect()
+    }
+}
+
+impl NativeRuntime {
+    fn ensure_correlated(&mut self) -> RusticolResult<()> {
+        if self.correlated.is_none() {
+            self.correlated = Some(CorrelatedRuntime::load(self)?);
+        }
+        Ok(())
+    }
+
+    pub fn available_color_correlations_json(&mut self) -> RusticolResult<String> {
+        self.ensure_correlated()?;
+        Ok(self
+            .correlated
+            .as_ref()
+            .expect("initialized")
+            .catalogue_json
+            .clone())
+    }
+
+    pub fn color_correlation_ids(&mut self) -> RusticolResult<Vec<String>> {
+        self.ensure_correlated()?;
+        Ok(self
+            .correlated
+            .as_ref()
+            .expect("initialized")
+            .matrices
+            .iter()
+            .map(|matrix| matrix.id.clone())
+            .collect())
+    }
+
+    pub fn set_spin_correlation_vectors_f64(
+        &mut self,
+        vectors: NativeSpinCorrelationVectors,
+    ) -> RusticolResult<()> {
+        self.ensure_correlated()?;
+        let correlated = self.correlated.as_mut().expect("initialized");
+        correlated.validate_vectors(&vectors, None)?;
+        correlated.vectors = vectors;
+        Ok(())
+    }
+
+    /// Evaluate all requested complex bilinears, sharing each spin assignment's amplitudes.
+    pub fn evaluate_correlated_many_f64(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        requests: &[NativeCorrelatedRequest],
+        helicity_ids: Option<&[String]>,
+    ) -> RusticolResult<NativeCorrelatedEvaluation> {
+        self.ensure_correlated()?;
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            let mut evaluation = evaluate_many(self, momenta, point_count, requests, helicity_ids)?;
+            self.apply_process_group_factor(evaluation.values.as_flattened_mut());
+            Ok(evaluation)
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            let _ = (momenta, point_count, requests, helicity_ids);
+            Err(RusticolError::compatibility(
+                "native correlations require binary64 compiled-stage support",
+            ))
+        }
+    }
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn evaluate_many(
+    native: &mut NativeRuntime,
+    momenta: &[f64],
+    point_count: usize,
+    requests: &[NativeCorrelatedRequest],
+    helicity_ids: Option<&[String]>,
+) -> RusticolResult<NativeCorrelatedEvaluation> {
+    let expected = point_count
+        .checked_mul(native.runtime.external_count)
+        .and_then(|n| n.checked_mul(4));
+    if point_count == 0
+        || expected != Some(momenta.len())
+        || momenta.iter().any(|value| !value.is_finite())
+    {
+        return Err(invalid(
+            "correlated momenta must be finite with shape [point][external leg][4]",
+        ));
+    }
+    let correlated = native.correlated.as_ref().expect("initialized");
+    if helicity_ids.is_some_and(|ids| {
+        ids.iter()
+            .any(|id| !correlated.known_helicities.contains(id))
+    }) {
+        return Err(invalid("unknown correlated helicity ID"));
+    }
+    let size = point_count
+        .checked_mul(requests.len())
+        .ok_or_else(|| invalid("correlated result shape overflow"))?;
+    let mut assignments: Vec<&NativeSpinCorrelationVectors> = Vec::new();
+    let mut keys = BTreeMap::new();
+    let mut routes = Vec::new();
+    for request in requests {
+        let matrix = correlated
+            .matrices
+            .iter()
+            .position(|matrix| matrix.id == request.color_correlation)
+            .ok_or_else(|| {
+                invalid(format!(
+                    "unknown colour correlation ID {:?}",
+                    request.color_correlation
+                ))
+            })?;
+        let vectors = request.spin_vectors.as_ref().unwrap_or(&correlated.vectors);
+        correlated.validate_vectors(vectors, Some(point_count))?;
+        // Canonicalize broadcast and per-point forms; preserve signed zero.
+        let key: Vec<_> = vectors
+            .iter()
+            .map(|(&leg, batch)| {
+                (
+                    leg,
+                    (0..point_count)
+                        .flat_map(|point| {
+                            batch[if batch.len() == 1 { 0 } else { point }]
+                                .into_iter()
+                                .flatten()
+                                .map(f64::to_bits)
+                        })
+                        .collect::<Vec<_>>(),
+                )
+            })
+            .collect();
+        let assignment = *keys.entry(key).or_insert_with(|| {
+            assignments.push(vectors);
+            assignments.len() - 1
+        });
+        routes.push((assignment, matrix));
+    }
+    let mut values = vec![[0.0; 2]; size];
+    if requests.is_empty() {
+        return Ok(NativeCorrelatedEvaluation {
+            point_count,
+            request_count: 0,
+            values,
+        });
+    }
+    let selected: Vec<_> = assignments
+        .iter()
+        .map(|vectors| correlated.selected_groups(helicity_ids, vectors))
+        .collect();
+    let runtime = &mut native.runtime;
+    let direct = runtime.compiled_direct_runtime.as_mut().ok_or_else(|| {
+        RusticolError::compatibility(
+            "native correlations require retained generic Direct-Arena compiled stages",
+        )
+    })?;
+    let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+        momenta,
+        point_count,
+        runtime.external_count,
+        None,
+    )?;
+    let mut point_start = 0;
+    while point_start < point_count {
+        let point_stop = (point_start + direct.tile_capacity()).min(point_count);
+        let count = point_stop - point_start;
+        // Memo lifetime is exactly one point tile: momenta and parameters cannot change.
+        let mut memo = compiled_direct_prototype::CorrelatedStageMemo::default();
+        for (assignment, vectors) in assignments.iter().enumerate() {
+            direct.begin_tile_from_inputs(
+                batch.subview(point_start, point_stop)?,
+                &runtime.sources,
+                None,
+                runtime.external_count,
+                &runtime.particle_masses,
+                &runtime.momentum_slots,
+                &runtime.external_is_initial,
+                &runtime.model_parameter_values_f64,
+            )?;
+            direct.replace_correlated_sources(&runtime.sources, vectors, point_start, count)?;
+            if assignments.len() > 1 {
+                direct.evaluate_correlated_reusing(count, &mut memo)?;
+            } else {
+                direct.evaluate_all(count)?;
+            }
+            let planes = direct.amplitude_planes()?;
+            let mut amplitudes = vec![[0.0; 2]; selected[assignment].len() * count];
+            let mut by_helicity: BTreeMap<&str, BTreeMap<i64, usize>> = BTreeMap::new();
+            for (position, &index) in selected[assignment].iter().enumerate() {
+                let group = &correlated.groups[index];
+                by_helicity
+                    .entry(&group.helicity_id)
+                    .or_default()
+                    .insert(group.sector, position);
+                for &root in &group.roots {
+                    let (re, im) = planes.plane_unchecked(root);
+                    for point in 0..count {
+                        amplitudes[position * count + point][0] += re[point];
+                        amplitudes[position * count + point][1] += im[point];
+                    }
+                }
+            }
+            for (request, &(_, matrix)) in routes
+                .iter()
+                .enumerate()
+                .filter(|(_, (id, _))| *id == assignment)
+            {
+                for sectors in by_helicity.values() {
+                    for &(left, right, weight) in &correlated.matrices[matrix].entries {
+                        let a = sectors[&left] * count;
+                        let b = sectors[&right] * count;
+                        for point in 0..count {
+                            let [ar, ai] = amplitudes[a + point];
+                            let [br, bi] = amplitudes[b + point];
+                            let wr = ar * weight[0] + ai * weight[1];
+                            let wi = ar * weight[1] - ai * weight[0];
+                            let value = &mut values[request * point_count + point_start + point];
+                            value[0] += wr * br - wi * bi;
+                            value[1] += wr * bi + wi * br;
+                        }
+                    }
+                }
+                for value in &mut values
+                    [request * point_count + point_start..request * point_count + point_stop]
+                {
+                    value[0] *= runtime.normalization_factor;
+                    value[1] *= runtime.normalization_factor;
+                }
+            }
+        }
+        point_start = point_stop;
+    }
+    Ok(NativeCorrelatedEvaluation {
+        point_count,
+        request_count: requests.len(),
+        values,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lazy_catalogue_cannot_bind_to_replaced_process_output() {
+        assert!(validate_catalogue_artifact_id("loaded-output", "loaded-output").is_ok());
+        assert!(validate_catalogue_artifact_id("loaded-output", "replacement-output").is_err());
+    }
+
+    #[test]
+    fn exact_weights_reject_lossy_or_nonfinite_encodings() {
+        assert_eq!(
+            rational_f64(&[Value::from("-3"), Value::from("2")]).unwrap(),
+            -1.5
+        );
+        for parts in [
+            [Value::from("1e2"), Value::from(1)],
+            [Value::from(1.2), Value::from(1)],
+            [Value::from(1), Value::from(0)],
+        ] {
+            assert!(rational_f64(&parts).is_err());
+        }
+    }
+
+    #[test]
+    fn spin_validation_is_joint_finite_and_shape_checked() {
+        let runtime = CorrelatedRuntime {
+            catalogue_json: "[]".into(),
+            matrices: vec![],
+            spin_classes: BTreeSet::from([vec![3], vec![3, 4]]),
+            known_helicities: BTreeSet::new(),
+            groups: vec![],
+            vectors: BTreeMap::new(),
+        };
+        let vector = [[1.0, 0.0]; 4];
+        assert!(
+            runtime
+                .validate_vectors(&BTreeMap::from([(3, vec![vector])]), Some(2))
+                .is_ok()
+        );
+        assert!(
+            runtime
+                .validate_vectors(&BTreeMap::from([(4, vec![vector])]), Some(2))
+                .is_err()
+        );
+        assert!(
+            runtime
+                .validate_vectors(&BTreeMap::from([(3, vec![vector; 3])]), Some(2))
+                .is_err()
+        );
+        assert!(
+            runtime
+                .validate_vectors(&BTreeMap::from([(3, vec![[[f64::NAN, 0.0]; 4]])]), None)
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn spin_replacements_select_one_placeholder_and_sum_spectators() {
+        let mut runtime = CorrelatedRuntime {
+            catalogue_json: "[]".into(),
+            matrices: vec![],
+            spin_classes: BTreeSet::from([vec![1]]),
+            known_helicities: BTreeSet::new(),
+            groups: vec![],
+            vectors: BTreeMap::new(),
+        };
+        for h1 in [-1, 1] {
+            for h2 in [-1, 1] {
+                for sector in [0, 2] {
+                    runtime.groups.push(Group {
+                        helicity_id: format!("{h1},{h2}"),
+                        helicities: vec![h1, h2],
+                        sector,
+                        roots: vec![],
+                    });
+                }
+            }
+        }
+        assert_eq!(runtime.selected_groups(None, &BTreeMap::new()).len(), 8);
+        let vectors = BTreeMap::from([(1, vec![[[0.0, 0.0]; 4]])]);
+        let selected = runtime.selected_groups(None, &vectors);
+        assert_eq!(selected.len(), 4);
+        assert!(
+            selected
+                .iter()
+                .all(|&index| runtime.groups[index].helicities[0] == -1)
+        );
+        let ids = vec!["1,-1".to_owned()];
+        let selected = runtime.selected_groups(Some(&ids), &vectors);
+        assert_eq!(selected.len(), 2);
+        assert!(
+            selected
+                .iter()
+                .all(|&index| runtime.groups[index].helicities == [1, -1])
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/eager_backend.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_backend.rs
new file mode 100644
index 0000000000..8992a841d4
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_backend.rs
@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::{EagerKernelBackend, EagerKernelCall};
+
+pub(super) struct PreparedEvaluatorBackend {
+    kernels: BTreeMap<(u32, u32), PreparedEvaluatorKernel>,
+}
+
+struct PreparedEvaluatorKernel {
+    evaluator: EvaluatorGroup,
+    #[cfg(feature = "symbolica-runtime")]
+    input_scratch: Vec<Complex<f64>>,
+    output_scratch: Vec<Complex<f64>>,
+}
+
+impl PreparedEvaluatorBackend {
+    pub(super) fn load(
+        pack: &PreparedKernelPackManifest,
+        payload_root: &Path,
+    ) -> RusticolResult<Self> {
+        let payloads = EvaluatorPayloadStore::directory(payload_root);
+        Self::load_from_store(pack, &payloads)
+    }
+
+    pub(super) fn load_from_store(
+        pack: &PreparedKernelPackManifest,
+        payloads: &EvaluatorPayloadStore,
+    ) -> RusticolResult<Self> {
+        let expected_capability = match pack.backend.as_str() {
+            "jit" => SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+            "asm" => SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY,
+            "cpp" => SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY,
+            other => {
+                return Err(RusticolError::artifact(format!(
+                    "unsupported prepared backend {other:?}"
+                )));
+            }
+        };
+        let mut kernels = BTreeMap::new();
+        for kernel in &pack.kernels {
+            if kernel.contract_kind == "model-parameter" {
+                continue;
+            }
+            let evaluator_manifest = kernel.runtime_evaluator_manifest()?;
+            let actual = evaluator_runtime_capabilities(&evaluator_manifest)?;
+            if actual != BTreeSet::from([expected_capability.to_string()]) {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel {} backend {:?} declares evaluator capabilities {actual:?}",
+                    kernel.kernel_id, pack.backend
+                )));
+            }
+            ensure_evaluator_capabilities_supported(&evaluator_manifest)?;
+            let (input_len, output_len) = evaluator_manifest.io_len()?;
+            if input_len != kernel.input_arity
+                || output_len != usize::try_from(kernel.output_arity).unwrap_or(usize::MAX)
+            {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel {} evaluator I/O ({input_len}, {output_len}) does not match ({}, {})",
+                    kernel.kernel_id, kernel.input_arity, kernel.output_arity
+                )));
+            }
+            let evaluator = EvaluatorGroup::load_from_store(&evaluator_manifest, payloads)?;
+            if kernels
+                .insert(
+                    (kernel.kernel_id, 1),
+                    PreparedEvaluatorKernel {
+                        evaluator,
+                        #[cfg(feature = "symbolica-runtime")]
+                        input_scratch: Vec::new(),
+                        output_scratch: Vec::new(),
+                    },
+                )
+                .is_some()
+            {
+                return Err(RusticolError::integrity(format!(
+                    "prepared evaluator backend repeats kernel {}",
+                    kernel.kernel_id
+                )));
+            }
+        }
+        for variant in &pack.kernel_variants {
+            let evaluator_manifest = variant.runtime_evaluator_manifest()?;
+            let actual = evaluator_runtime_capabilities(&evaluator_manifest)?;
+            if actual != BTreeSet::from([SYMJIT_APPLICATION_RUNTIME_CAPABILITY.to_string()]) {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel {} block variant declares evaluator capabilities {actual:?}",
+                    variant.base_kernel_id
+                )));
+            }
+            ensure_evaluator_capabilities_supported(&evaluator_manifest)?;
+            let (input_len, output_len) = evaluator_manifest.io_len()?;
+            if input_len != variant.input_arity || output_len != variant.output_arity {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel {} block evaluator I/O ({input_len}, {output_len}) does not match ({}, {})",
+                    variant.base_kernel_id, variant.input_arity, variant.output_arity
+                )));
+            }
+            let evaluator = EvaluatorGroup::load_from_store(&evaluator_manifest, payloads)?;
+            if kernels
+                .insert(
+                    (variant.base_kernel_id, variant.block_size),
+                    PreparedEvaluatorKernel {
+                        evaluator,
+                        #[cfg(feature = "symbolica-runtime")]
+                        input_scratch: Vec::new(),
+                        output_scratch: Vec::new(),
+                    },
+                )
+                .is_some()
+            {
+                return Err(RusticolError::integrity(format!(
+                    "prepared evaluator backend repeats kernel {} block size {}",
+                    variant.base_kernel_id, variant.block_size
+                )));
+            }
+        }
+        Ok(Self { kernels })
+    }
+
+    pub(super) fn preflight_all(
+        pack: &PreparedKernelPackManifest,
+        payload_root: &Path,
+    ) -> RusticolResult<usize> {
+        let backend = Self::load(pack, payload_root)?;
+        let mut loaded = backend.kernels.len();
+        for kernel in &pack.kernels {
+            if kernel.contract_kind != "model-parameter" {
+                continue;
+            }
+            let evaluator_manifest = kernel.runtime_evaluator_manifest()?;
+            ensure_evaluator_capabilities_supported(&evaluator_manifest)?;
+            let (input_len, output_len) = evaluator_manifest.io_len()?;
+            if input_len != kernel.input_arity
+                || output_len != usize::try_from(kernel.output_arity).unwrap_or(usize::MAX)
+            {
+                return Err(RusticolError::integrity(format!(
+                    "prepared model-parameter kernel {} evaluator I/O ({input_len}, {output_len}) does not match ({}, {})",
+                    kernel.kernel_id, kernel.input_arity, kernel.output_arity
+                )));
+            }
+            let _evaluator = EvaluatorGroup::load(&evaluator_manifest, payload_root)?;
+            loaded += 1;
+        }
+        Ok(loaded)
+    }
+}
+
+impl EagerKernelBackend for PreparedEvaluatorBackend {
+    fn evaluate_batch(&mut self, call: EagerKernelCall<'_>) -> RusticolResult<()> {
+        let kernel = self
+            .kernels
+            .get_mut(&(call.kernel_id, call.independent_block_size))
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "eager plan references unloaded prepared kernel {} block size {}",
+                    call.kernel_id, call.independent_block_size
+                ))
+            })?;
+        if call.input_component_count != kernel.evaluator.input_len
+            || call.output_component_count != kernel.evaluator.output_len
+        {
+            return Err(RusticolError::integrity(format!(
+                "eager call for kernel {} has I/O ({}, {}), expected ({}, {})",
+                call.kernel_id,
+                call.input_component_count,
+                call.output_component_count,
+                kernel.evaluator.input_len,
+                kernel.evaluator.output_len,
+            )));
+        }
+        let input_len = call
+            .lane_count
+            .checked_mul(call.input_component_count)
+            .ok_or_else(|| RusticolError::invalid_argument("eager input packet overflows"))?;
+        let output_len = call
+            .lane_count
+            .checked_mul(call.output_component_count)
+            .ok_or_else(|| RusticolError::invalid_argument("eager output packet overflows"))?;
+        if call.inputs.len() != input_len || call.outputs.len() != output_len {
+            return Err(RusticolError::internal(
+                "eager scheduler passed an inconsistent kernel packet",
+            ));
+        }
+
+        // Prepared eager kernels normally contain one evaluator with the exact
+        // kernel input order. Keep that hot path entirely borrowed: EagerComplex64
+        // is the same Complex<f64> representation consumed by every f64 backend.
+        // Chunked/mapped manifests remain supported through EvaluatorGroup's
+        // reusable fallback scratch.
+        #[cfg(not(feature = "symbolica-runtime"))]
+        if kernel.evaluator.evaluators.len() == 1
+            && kernel.evaluator.input_mappings[0].is_none()
+            && kernel.evaluator.evaluators[0].output_len == kernel.evaluator.output_len
+        {
+            return kernel.evaluator.evaluators[0].evaluate_f64_batch(
+                call.lane_count,
+                call.inputs,
+                call.outputs,
+            );
+        }
+
+        #[cfg(feature = "symbolica-runtime")]
+        let evaluator_inputs = {
+            kernel
+                .input_scratch
+                .resize(input_len, Complex::new(0.0, 0.0));
+            for (target, source) in kernel.input_scratch.iter_mut().zip(call.inputs.iter()) {
+                *target = Complex::new(source.re, source.im);
+            }
+            kernel.input_scratch.as_slice()
+        };
+        #[cfg(not(feature = "symbolica-runtime"))]
+        let evaluator_inputs = call.inputs;
+
+        kernel.evaluator.evaluate_batch_into_padded_simd_tail(
+            call.lane_count,
+            evaluator_inputs,
+            &mut kernel.output_scratch,
+        )?;
+        if kernel.output_scratch.len() != output_len {
+            return Err(RusticolError::internal(
+                "prepared evaluator returned an inconsistent output packet",
+            ));
+        }
+        #[cfg(feature = "symbolica-runtime")]
+        for (target, source) in call.outputs.iter_mut().zip(kernel.output_scratch.iter()) {
+            *target = crate::EagerComplex64::new(source.re, source.im);
+        }
+        #[cfg(not(feature = "symbolica-runtime"))]
+        call.outputs.copy_from_slice(&kernel.output_scratch);
+        Ok(())
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/eager_integration_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_integration_tests.rs
new file mode 100644
index 0000000000..da10e058f4
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_integration_tests.rs
@@ -0,0 +1,1885 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::{
+    EAGER_KERNEL_ABI, EagerClosureRow, EagerCouplingRow, EagerExecutionPlan, EagerExecutionRuntime,
+    EagerKernelInput, EagerKernelRole, EagerKernelSpec, EagerPlanDefinition, EagerPlanDimensions,
+    EagerPlanPayloads, EagerReductionEntry, EagerReductionGroup, EagerRuntimeOptions, MISSING_U32,
+};
+use serde_json::json;
+
+const TEST_SYMJIT_APPLICATION_ABI: &str = "symjit-application-storage-v3";
+const TEST_SYMJIT_PLANE_APPLICATION_ABI: &str = "pyamplicol-symjit-plane-application-v2";
+const TEST_PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL: u64 = 2;
+const TEST_PREPARED_JIT_PORTABLE_TARGET: &str = "symjit-storage-v3-portable";
+
+#[test]
+fn eager_color_topology_replay_preserves_amplitude_major_batches() {
+    let materialized_groups = [
+        RawSumGroup {
+            id: 10,
+            indices: vec![0, 1],
+            weight: 1.0,
+            all_sector_weight: 1.0,
+            sector_ids: vec![0],
+        },
+        RawSumGroup {
+            id: 20,
+            indices: vec![2],
+            weight: 1.0,
+            all_sector_weight: 1.0,
+            sector_ids: vec![1],
+        },
+    ];
+    let replay = serde_json::from_value(json!({
+        "contract_version": 1,
+        "physical_group_count": 2,
+        "physical_groups": [
+            {"group_id": 0, "helicities": [1, -1], "color_sector_id": 0,
+             "color_word": [1, 2], "helicity_weight": 1.0},
+            {"group_id": 1, "helicities": [1, -1], "color_sector_id": 1,
+             "color_word": [2, 1], "helicity_weight": 1.0},
+        ],
+        "mappings": [{"label_permutation": [], "group_routes": [
+            {"source_group_id": 10, "target_group_id": 0, "factor": [1.0, 0.0]},
+            {"source_group_id": 20, "target_group_id": 1, "factor": [0.0, 1.0]},
+        ]}],
+    }))
+    .expect("color topology replay fixture");
+    let contraction = serde_json::from_value(json!({
+        "supported": true,
+        "group_count": 2,
+        "includes_color_factor": true,
+        "entries": [
+            {"left_group_id": 0, "right_group_id": 0, "weight": [2.0, 0.0]},
+            {"left_group_id": 1, "right_group_id": 1, "weight": [3.0, 0.0]},
+            {"left_group_id": 0, "right_group_id": 1, "weight": [1.0, 0.0],
+             "symmetry_factor": 2.0},
+        ],
+    }))
+    .expect("color contraction fixture");
+    let mut reducer = AmplitudeRuntime::color_topology_replay_reducer(
+        3,
+        &materialized_groups,
+        &replay,
+        &contraction,
+    )
+    .expect("color topology replay reducer");
+
+    // Include repeated and distinct points, and a batch crossing the normal
+    // eager point-tile boundary. Each amplitude occupies one point plane.
+    for point_count in [1, 2, 3, 65] {
+        let value = |amplitude: usize, point: usize| {
+            let point = (point / 2) as f64;
+            crate::EagerComplex64::new(1.0 + amplitude as f64 * 3.0 + point, point - 2.0)
+        };
+        let amplitudes = (0..3)
+            .flat_map(|amplitude| (0..point_count).map(move |point| value(amplitude, point)))
+            .collect::<Vec<_>>();
+        reducer.begin_color_topology_replay(point_count).unwrap();
+        reducer
+            .gather_color_topology_replay_eager_amplitudes(&amplitudes, point_count, 0)
+            .unwrap();
+        let mut totals = vec![0.0; point_count];
+        reducer
+            .reduce_color_topology_replay_f64_into(point_count, &mut totals)
+            .unwrap();
+        for (point, total) in totals.iter().copied().enumerate() {
+            let left = value(0, point) + value(1, point);
+            let right = value(2, point) * crate::EagerComplex64::new(0.0, 1.0);
+            let expected =
+                (2.0 * left * left.conj() + 3.0 * right * right.conj() + 2.0 * left * right.conj())
+                    .re;
+            assert_eq!(total, expected, "batch {point_count}, point {point}");
+        }
+    }
+}
+
+fn symjit_manifest(application_path: &str, exact_state_path: &str, input_len: usize) -> Value {
+    let plane_application_path = application_path.strip_suffix(".symjit").map_or_else(
+        || format!("{application_path}.plane.symjit"),
+        |stem| format!("{stem}.plane.symjit"),
+    );
+    json!({
+        "kind": "symjit-application-evaluator",
+        "runtime_capability": SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+        "backend": "jit",
+        "label": "prepared_test_kernel",
+        "application_path": application_path,
+        "application_abi": TEST_SYMJIT_APPLICATION_ABI,
+        "plane_application": {
+            "application_path": plane_application_path,
+            "application_abi": TEST_SYMJIT_PLANE_APPLICATION_ABI,
+            "storage_abi": TEST_SYMJIT_APPLICATION_ABI,
+            "element_layout": "split-complex-plane-major",
+            "descriptor_order": "inputs-re-im-then-outputs-re-im",
+            "input_complex_count": input_len,
+            "output_complex_count": 1,
+            "input_plane_count": 2 * input_len,
+            "output_plane_count": 2,
+            "compiler_type": "native",
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": TEST_PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+            "simd": true,
+            "complex": true,
+            "fast_math": true,
+            "fast_complex": false,
+            "compression": false,
+            "threading": false,
+            "direct_arena": true,
+            "source_digest": "0".repeat(64),
+            "target": {
+                "word_bits": 64,
+                "endianness": "little",
+            },
+        },
+        "input_len": input_len,
+        "output_len": 1,
+        "element_layout": "complex-f64",
+        "batch_layout": "row-major",
+        "compiler_type": "native",
+        "translation_mode": "indirect",
+        "optimization_level": TEST_PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+        "word_bits": 64,
+        "endianness": "little",
+        "required_defuns": [],
+        "evaluator_state_path": exact_state_path,
+        "evaluator_state_runtime_capability": SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+        "settings": {
+            "jit_optimization_level": TEST_PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+        },
+        "build_timing": {"jit_materialize_s": 0.0},
+    })
+}
+
+fn compiled_manifest(runtime_capability: &str, exact_state_path: &str, input_len: usize) -> Value {
+    json!({
+        "kind": "compiled-complex-evaluator",
+        "runtime_capability": runtime_capability,
+        "backend": "compiled-complex",
+        "function_name": "prepared_test_kernel",
+        "library_path": "kernels/7/library-0",
+        "source_path": "kernels/7/source-0.cpp",
+        "input_len": input_len,
+        "output_len": 1,
+        "number_type": "complex-f64",
+        "evaluator_state_path": exact_state_path,
+        "settings": {"optimization_level": "o3"},
+        "build_timing": {"compile_s": 0.0},
+        "direct_table": {
+            "capability": crate::eager_layout::EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            "source_application_abi":
+                crate::eager_layout::EAGER_NATIVE_DIRECT_TABLE_APPLICATION_ABI,
+            "descriptor_abi": crate::eager_layout::EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+            "binding_abi": crate::eager_layout::EAGER_DIRECT_TABLE_BINDING_ABI,
+            "library_path": "kernels/7/library-0",
+            "function_name": "pyamplicol_eager_direct_table_k00000007_v1",
+            "evaluator_state_sha256": "b".repeat(64),
+            "input_complex_count": input_len,
+            "output_complex_count": 1,
+            "invocation_stride": (2 * input_len + 2) * 4,
+            "attachment_stride": 16,
+            "simd_lane_width": 2,
+            "instruction_count": 1,
+            "temporary_count": 0,
+        },
+    })
+}
+
+fn input(role: &str, component: u32) -> PreparedKernelInputManifest {
+    PreparedKernelInputManifest {
+        role: role.to_string(),
+        component,
+        symbol: format!("pyamplicol::test::{role}::{component}"),
+        model_parameter_name: None,
+        model_parameter_index: None,
+    }
+}
+
+fn model_parameter_input(name: &str, index: u32) -> PreparedKernelInputManifest {
+    PreparedKernelInputManifest {
+        role: "model-parameter".to_string(),
+        component: 0,
+        symbol: format!("pyamplicol::test::model-parameter::{name}"),
+        model_parameter_name: Some(name.to_string()),
+        model_parameter_index: Some(index),
+    }
+}
+
+fn kernel(
+    kernel_id: u32,
+    contract_kind: &str,
+    inputs: Vec<PreparedKernelInputManifest>,
+    application_path: &str,
+) -> PreparedKernelManifest {
+    let input_arity = inputs.len();
+    let exact_evaluator_state_path = format!("kernels/{kernel_id}/exact.bin");
+    PreparedKernelManifest {
+        kernel_id,
+        contract_kind: contract_kind.to_string(),
+        canonical_signature: format!("test-kernel-{kernel_id}"),
+        input_arity,
+        output_arity: 1,
+        input_layout: (0..input_arity)
+            .map(|index| format!("input-{index}"))
+            .collect(),
+        input_contracts: inputs,
+        output_layout: vec!["output-0".to_string()],
+        exact_expressions: vec!["test-expression".to_string()],
+        proof_classes: Vec::new(),
+        f64_evaluator_manifest: symjit_manifest(
+            application_path,
+            &exact_evaluator_state_path,
+            input_arity,
+        ),
+        exact_evaluator_state_path,
+    }
+}
+
+fn add_direct_table_manifest(kernel: &mut PreparedKernelManifest) {
+    kernel
+        .f64_evaluator_manifest
+        .as_object_mut()
+        .expect("test evaluator object")
+        .insert(
+            "direct_table".to_string(),
+            json!({
+                "capability": crate::eager_layout::EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+                "source_application_abi":
+                    crate::eager_layout::EAGER_DIRECT_SOURCE_APPLICATION_ABI,
+                "descriptor_abi": crate::eager_layout::EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+                "binding_abi": crate::eager_layout::EAGER_DIRECT_TABLE_BINDING_ABI,
+                "descriptor_path": format!(
+                    "kernels/{}/eager-direct-table-descriptor-v1.bin",
+                    kernel.kernel_id
+                ),
+                "descriptor_size_bytes": 128,
+                "descriptor_sha256": "a".repeat(64),
+                "input_complex_count": kernel.input_arity,
+                "output_complex_count": kernel.output_arity,
+            }),
+        );
+}
+
+#[test]
+fn eager_direct_table_manifest_is_explicit_and_fail_closed() {
+    let mut prepared = kernel(
+        50,
+        "closure",
+        vec![input("left-current", 0)],
+        "kernels/50/application.symjit",
+    );
+    let missing = prepared
+        .eager_direct_table_manifest()
+        .expect_err("pre-arena kernel must fail");
+    assert!(missing.to_string().contains("regenerate"));
+
+    add_direct_table_manifest(&mut prepared);
+    let direct = prepared
+        .eager_direct_table_manifest()
+        .expect("valid direct table metadata");
+    assert_eq!(direct.input_complex_count, 1);
+    assert_eq!(direct.output_complex_count, 1);
+    assert_eq!(direct.descriptor_size_bytes, Some(128));
+
+    let large_descriptor_size = (1_u64 << 30) + 1;
+    prepared.f64_evaluator_manifest["direct_table"]["descriptor_size_bytes"] =
+        json!(large_descriptor_size);
+    let direct = prepared
+        .eager_direct_table_manifest()
+        .expect("large writer-representable DirectTable descriptor metadata must remain valid");
+    assert_eq!(direct.descriptor_size_bytes, Some(large_descriptor_size));
+
+    let mut predecessor = prepared.clone();
+    predecessor.f64_evaluator_manifest["direct_table"]["descriptor_abi"] =
+        json!(["symjit-direct-table-", "descriptor-v1"].concat());
+    predecessor.f64_evaluator_manifest["direct_table"]["binding_abi"] =
+        json!(["symjit-direct-table-", "binding-v1"].concat());
+    let error = predecessor
+        .eager_direct_table_manifest()
+        .expect_err("predecessor DirectTable ABI must fail closed");
+    assert!(error.to_string().contains("regenerate"));
+
+    for (field, value) in [
+        ("capability", json!("wrong-capability")),
+        ("descriptor_abi", json!("wrong-descriptor-abi")),
+        ("binding_abi", json!("wrong-binding-abi")),
+        ("descriptor_size_bytes", json!(0)),
+        ("descriptor_sha256", json!("A".repeat(64))),
+        ("input_complex_count", json!(2)),
+    ] {
+        let mut malformed = prepared.clone();
+        malformed.f64_evaluator_manifest["direct_table"][field] = value;
+        assert!(
+            malformed.eager_direct_table_manifest().is_err(),
+            "malformed DirectTable field {field} must fail"
+        );
+    }
+}
+
+fn filtered_pack(kernels: Vec<PreparedKernelManifest>) -> PreparedKernelPackManifest {
+    PreparedKernelPackManifest {
+        eager_kernel_abi: EAGER_KERNEL_ABI.to_string(),
+        backend: "jit".to_string(),
+        optimization_settings: json!({
+            "jit_optimization_level": TEST_PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+        }),
+        producer: json!({"distribution": "pyamplicol", "version": "test"}),
+        dependency_abis: json!({
+            "symjit_application": TEST_SYMJIT_APPLICATION_ABI,
+            "symjit_plane_application": TEST_SYMJIT_PLANE_APPLICATION_ABI,
+        }),
+        provenance: json!({"compiled_model_digest": "test"}),
+        target: PreparedKernelTargetManifest {
+            portable: true,
+            word_bits: 64,
+            endianness: "little".to_string(),
+            target_triple: TEST_PREPARED_JIT_PORTABLE_TARGET.to_string(),
+            cpu_features: Vec::new(),
+        },
+        resolver_manifest: json!({
+            "abi": "pyamplicol-prepared-kernel-catalog-v1",
+            "model_name": "test-model",
+            "model_parameter_kernel_id": null,
+            "propagator_bindings": [
+                {"key": {"particle_id": 22, "chirality": 0}, "applies_propagator": false, "kernel_id": null}
+            ],
+            "vertex_bindings": [],
+            "closure_bindings": []
+        }),
+        kernels,
+        kernel_variants: Vec::new(),
+        recurrence_template: None,
+        recurrence_direct_template: None,
+    }
+}
+
+#[test]
+fn eager_parameter_projection_uses_active_and_derivation_dependencies_only() {
+    let pack = filtered_pack(vec![
+        kernel(
+            7,
+            "vertex",
+            vec![model_parameter_input("alpha", 3)],
+            "kernels/7/application.symjit",
+        ),
+        kernel(
+            8,
+            "propagator",
+            vec![model_parameter_input("MW", 40)],
+            "kernels/8/application.symjit",
+        ),
+        kernel(
+            9,
+            "model-parameter",
+            vec![model_parameter_input("Gf", 100)],
+            "kernels/9/application.symjit",
+        ),
+    ]);
+    let indices = super::eager_load::prepared_parameter_indices(&pack, &BTreeSet::from([7]), true)
+        .expect("project process-local prepared parameters");
+
+    assert_eq!(
+        indices,
+        BTreeMap::from([("Gf".to_string(), 100), ("alpha".to_string(), 3)])
+    );
+    assert!(!indices.contains_key("MW"));
+
+    let indices_without_derived =
+        super::eager_load::prepared_parameter_indices(&pack, &BTreeSet::from([7]), false)
+            .expect("omit unused derivation inputs");
+    assert_eq!(
+        indices_without_derived,
+        BTreeMap::from([("alpha".to_string(), 3)])
+    );
+
+    let runtime_parameters = [GenericRuntimeModelParameterManifest {
+        name: "alpha".to_string(),
+        kind: "external_parameter".to_string(),
+        parameter_index: 0,
+        default: 1.0,
+        pdg: None,
+        runtime_name: None,
+        complex_component: None,
+    }];
+    let payloads = EvaluatorPayloadStore::directory(Path::new("."));
+    let (projection, _, evaluator) = super::eager_load::prepare_eager_parameter_state(
+        &pack,
+        &BTreeSet::from([7]),
+        &runtime_parameters,
+        &[],
+        &payloads,
+    )
+    .expect("an unused derivation kernel must not load or impose its inputs");
+    assert_eq!(projection.parameter_count, 4);
+    assert!(evaluator.is_none());
+}
+
+#[test]
+fn eager_parameter_projection_preserves_full_pack_parameter_integrity() {
+    let pack = filtered_pack(vec![
+        kernel(
+            7,
+            "vertex",
+            vec![model_parameter_input("alpha", 3)],
+            "kernels/7/application.symjit",
+        ),
+        kernel(
+            8,
+            "propagator",
+            vec![model_parameter_input("MW", 40)],
+            "kernels/8/application.symjit",
+        ),
+        kernel(
+            9,
+            "closure",
+            vec![model_parameter_input("MW", 41)],
+            "kernels/9/application.symjit",
+        ),
+    ]);
+
+    let error = super::eager_load::prepared_parameter_indices(&pack, &BTreeSet::from([7]), false)
+        .expect_err("inactive contracts must still share one authenticated namespace");
+    assert!(error.to_string().contains("conflicting stable indices"));
+}
+
+#[test]
+fn eager_parameter_projection_ignores_inactive_missing_runtime_dependencies_but_not_active_ones() {
+    let pack = filtered_pack(vec![
+        kernel(
+            7,
+            "vertex",
+            vec![model_parameter_input("alpha", 3)],
+            "kernels/7/application.symjit",
+        ),
+        kernel(
+            8,
+            "propagator",
+            vec![model_parameter_input("MW", 40)],
+            "kernels/8/application.symjit",
+        ),
+    ]);
+    let runtime_parameters = vec![GenericRuntimeModelParameterManifest {
+        name: "alpha".to_string(),
+        kind: "external_parameter".to_string(),
+        parameter_index: 0,
+        default: 1.0,
+        pdg: None,
+        runtime_name: None,
+        complex_component: None,
+    }];
+    let payloads = EvaluatorPayloadStore::directory(Path::new("."));
+
+    let (projection, _, evaluator) = super::eager_load::prepare_eager_parameter_state(
+        &pack,
+        &BTreeSet::from([7]),
+        &runtime_parameters,
+        &[],
+        &payloads,
+    )
+    .expect("inactive prepared dependencies do not belong to this process");
+    assert_eq!(projection.parameter_count, 4);
+    assert_eq!(projection.entries.len(), 1);
+    assert_eq!(projection.entries[0].prepared_index, 3);
+    assert_eq!(projection.entries[0].runtime_real_index, 0);
+    assert!(evaluator.is_none());
+
+    let error = match super::eager_load::prepare_eager_parameter_state(
+        &pack,
+        &BTreeSet::from([8]),
+        &runtime_parameters,
+        &[],
+        &payloads,
+    ) {
+        Ok(_) => panic!("an active prepared dependency must exist in the runtime schema"),
+        Err(error) => error,
+    };
+    assert!(
+        error
+            .to_string()
+            .contains("prepared parameter \"MW\" is absent")
+    );
+}
+
+fn portable_outer_target() -> crate::Target {
+    crate::Target {
+        triple: crate::artifact::PORTABLE_64LE_ARTIFACT_TARGET.to_string(),
+        cpu_features: Vec::new(),
+    }
+}
+
+fn portable_jit_pack_for_outer_target_test() -> PreparedKernelPackManifest {
+    filtered_pack(vec![kernel(
+        50,
+        "closure",
+        vec![input("left-current", 0)],
+        "kernels/50/application.symjit",
+    )])
+}
+
+fn assert_portable_outer_pack_boundary(
+    validate: impl Fn(&crate::Target, &PreparedKernelPackManifest) -> RusticolResult<()>,
+    context: &str,
+) {
+    let target = portable_outer_target();
+    let jit = portable_jit_pack_for_outer_target_test();
+    jit.validate().expect("valid portable O2 JIT pack");
+    validate(&target, &jit).unwrap_or_else(|error| {
+        panic!("portable O2 JIT pack must satisfy {context} outer target: {error}")
+    });
+
+    for (backend, capability) in [
+        ("cpp", SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY),
+        ("asm", SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY),
+    ] {
+        let native = compiled_pack(backend, capability);
+        native
+            .validate()
+            .unwrap_or_else(|error| panic!("valid native {backend} pack: {error}"));
+        let error = validate(&target, &native)
+            .expect_err("portable outer artifact must reject a native prepared pack");
+        assert!(error.to_string().contains("portable O2 SymJIT"));
+        assert!(error.to_string().contains(context));
+    }
+}
+
+#[test]
+fn eager_portable_outer_target_requires_o2_jit_pack() {
+    assert_portable_outer_pack_boundary(
+        super::eager_v3_load::validate_eager_prepared_pack_outer_target,
+        "eager",
+    );
+}
+
+#[test]
+fn recurrence_portable_outer_target_requires_o2_jit_pack() {
+    assert_portable_outer_pack_boundary(
+        super::recurrence_load::validate_recurrence_prepared_pack_outer_target,
+        "recurrence",
+    );
+}
+
+#[test]
+fn prepared_jit_pack_rejects_nonportable_target_before_loading_payloads() {
+    let mut pack = filtered_pack(vec![kernel(
+        50,
+        "closure",
+        vec![input("left-current", 0)],
+        "kernels/50/missing.symjit",
+    )]);
+    let other = if std::env::consts::ARCH == "aarch64" {
+        "x86_64"
+    } else {
+        "aarch64"
+    };
+    pack.target.portable = false;
+    pack.target.target_triple = format!("symjit-storage-v3-{other}");
+
+    let error = pack
+        .validate()
+        .expect_err("nonportable prepared JIT pack must fail");
+    assert!(error.to_string().contains("expected portable target"));
+}
+
+#[test]
+fn prepared_jit_pack_requires_plane_application_dependency_abi() {
+    let mut pack = filtered_pack(vec![kernel(
+        50,
+        "closure",
+        vec![input("left-current", 0)],
+        "kernels/50/missing.symjit",
+    )]);
+    pack.dependency_abis
+        .as_object_mut()
+        .expect("test dependency ABI object")
+        .remove("symjit_plane_application");
+
+    let error = pack
+        .validate()
+        .expect_err("prepared JIT pack without plane application ABI must fail");
+    assert!(error.to_string().contains("plane-application ABI"));
+}
+
+#[test]
+fn raw_prepared_jit_manifest_projects_plane_without_direct_table() {
+    let mut pack = filtered_pack(vec![kernel(
+        50,
+        "closure",
+        vec![input("left-current", 0)],
+        "kernels/50/application.symjit",
+    )]);
+    pack.validate()
+        .expect("raw prepared JIT pack with a plane application");
+    assert!(
+        pack.kernels[0]
+            .extra_evaluator_payload_paths()
+            .expect("raw JIT extra payload paths")
+            .is_empty(),
+        "a raw prepared JIT pack has no process-stage DirectTable payload"
+    );
+
+    let runtime = pack.kernels[0]
+        .runtime_evaluator_manifest()
+        .expect("project raw prepared evaluator");
+    let EvaluatorManifest::SymjitApplication {
+        plane_application: Some(plane),
+        ..
+    } = runtime
+    else {
+        panic!("raw prepared evaluator must retain its plane application");
+    };
+    assert_eq!(
+        plane.application_path,
+        "kernels/50/application.plane.symjit"
+    );
+
+    add_direct_table_manifest(&mut pack.kernels[0]);
+    let runtime = pack.kernels[0]
+        .runtime_evaluator_manifest()
+        .expect("project process-stage prepared evaluator");
+    assert!(matches!(
+        runtime,
+        EvaluatorManifest::SymjitApplication {
+            plane_application: Some(_),
+            ..
+        }
+    ));
+    assert_eq!(
+        pack.kernels[0]
+            .extra_evaluator_payload_paths()
+            .expect("process-stage extra payload paths"),
+        ["kernels/50/eager-direct-table-descriptor-v1.bin"]
+    );
+}
+
+#[test]
+fn prepared_jit_plane_application_is_fail_closed() {
+    let pack = filtered_pack(vec![kernel(
+        50,
+        "closure",
+        vec![input("left-current", 0)],
+        "kernels/50/application.symjit",
+    )]);
+
+    let mut missing = pack.clone();
+    missing.kernels[0]
+        .f64_evaluator_manifest
+        .as_object_mut()
+        .expect("test evaluator object")
+        .remove("plane_application");
+    let error = missing
+        .validate()
+        .expect_err("missing plane application must fail");
+    assert!(error.to_string().contains("regenerate"));
+
+    for (field, value) in [
+        ("application_abi", json!("wrong-plane-abi")),
+        ("input_plane_count", json!(3)),
+        ("target", Value::Null),
+    ] {
+        let mut malformed = pack.clone();
+        malformed.kernels[0].f64_evaluator_manifest["plane_application"][field] = value;
+        let error = malformed
+            .validate()
+            .expect_err("malformed plane application must fail");
+        assert!(
+            error.to_string().contains("regenerate"),
+            "malformed plane field {field} must include regeneration guidance: {error}"
+        );
+    }
+}
+
+fn compiled_pack(backend: &str, runtime_capability: &str) -> PreparedKernelPackManifest {
+    let exact_evaluator_state_path = "kernels/7/exact.bin".to_string();
+    let kernel = PreparedKernelManifest {
+        kernel_id: 7,
+        contract_kind: "vertex".to_string(),
+        canonical_signature: format!("test-{backend}-kernel"),
+        input_arity: 1,
+        output_arity: 1,
+        input_layout: vec!["input-0".to_string()],
+        input_contracts: vec![input("left-current", 0)],
+        output_layout: vec!["output-0".to_string()],
+        exact_expressions: vec!["test-expression".to_string()],
+        proof_classes: Vec::new(),
+        f64_evaluator_manifest: compiled_manifest(
+            runtime_capability,
+            &exact_evaluator_state_path,
+            1,
+        ),
+        exact_evaluator_state_path,
+    };
+    let target = crate::runtime_target_info();
+    PreparedKernelPackManifest {
+        eager_kernel_abi: EAGER_KERNEL_ABI.to_string(),
+        backend: backend.to_string(),
+        optimization_settings: json!({"optimization_level": "o3"}),
+        producer: json!({"distribution": "pyamplicol", "version": "test"}),
+        dependency_abis: json!({"compiled_complex": "test"}),
+        provenance: json!({"compiled_model_digest": "test"}),
+        target: PreparedKernelTargetManifest {
+            portable: false,
+            word_bits: 64,
+            endianness: "little".to_string(),
+            target_triple: target.triple,
+            cpu_features: target.cpu_features,
+        },
+        resolver_manifest: json!({
+            "abi": "pyamplicol-prepared-kernel-catalog-v1",
+            "model_name": "test-model",
+            "model_parameter_kernel_id": null,
+            "propagator_bindings": [],
+            "vertex_bindings": [],
+            "closure_bindings": []
+        }),
+        kernels: vec![kernel],
+        kernel_variants: Vec::new(),
+        recurrence_template: None,
+        recurrence_direct_template: None,
+    }
+}
+
+#[test]
+fn runtime_options_are_positive_and_use_checked_platform_sizes() {
+    let options = EagerRuntimeOptionsManifest {
+        point_tile_size: 1024,
+        workspace_mib: 256,
+    }
+    .validate()
+    .expect("valid eager runtime options");
+    assert_eq!(options.point_tile_size, 1024);
+    assert_eq!(options.workspace_bytes, 256 * 1024 * 1024);
+
+    let above_old_reader_ceilings = EagerRuntimeOptionsManifest {
+        point_tile_size: 1_048_577,
+        workspace_mib: 4097,
+    }
+    .validate()
+    .expect("writer-valid eager runtime options above old reader ceilings");
+    assert_eq!(above_old_reader_ceilings.point_tile_size, 1_048_577);
+    assert_eq!(
+        above_old_reader_ceilings.workspace_bytes,
+        4097 * 1024 * 1024
+    );
+
+    for invalid in [
+        EagerRuntimeOptionsManifest {
+            point_tile_size: 0,
+            workspace_mib: 256,
+        },
+        EagerRuntimeOptionsManifest {
+            point_tile_size: 1024,
+            workspace_mib: 0,
+        },
+    ] {
+        assert!(invalid.validate().is_err());
+    }
+}
+
+#[test]
+fn filtered_pack_accepts_only_referenced_kernel_ids_and_preserves_input_order() {
+    let pack = filtered_pack(vec![
+        kernel(
+            7,
+            "propagator",
+            vec![input("current", 0), input("momentum", 3)],
+            "kernels/7/application.symjit",
+        ),
+        kernel(
+            78,
+            "vertex",
+            vec![
+                input("right-current", 1),
+                input("left-current", 0),
+                input("right-momentum", 2),
+                input("coupling-imag", 0),
+            ],
+            "kernels/78/application.symjit",
+        ),
+    ]);
+    pack.validate().expect("filtered prepared pack");
+
+    let specs = pack.kernel_specs().expect("prepared kernel specs");
+    assert_eq!(
+        specs.iter().map(|spec| spec.kernel_id).collect::<Vec<_>>(),
+        [7, 78]
+    );
+    assert_eq!(specs[0].role, EagerKernelRole::Finalization);
+    assert_eq!(
+        specs[1].inputs,
+        vec![
+            EagerKernelInput::SecondCurrentComponent(1),
+            EagerKernelInput::FirstCurrentComponent(0),
+            EagerKernelInput::SecondMomentumComponent(2),
+            EagerKernelInput::CouplingImag,
+        ]
+    );
+}
+
+#[test]
+fn prepared_pack_schema_requires_an_explicit_kernel_abi() {
+    let missing = json!({
+        "backend": "jit",
+        "optimization_settings": {"jit_optimization_level": 3},
+        "producer": {"distribution": "pyamplicol"},
+        "dependency_abis": {"symjit_application": "test"},
+        "provenance": {"compiled_model_digest": "test"},
+        "target": {
+            "portable": true,
+            "word_bits": 64,
+            "endianness": "little",
+            "target_triple": "portable-symjit-mir",
+            "cpu_features": []
+        },
+        "resolver_manifest": {"abi": "pyamplicol-prepared-kernel-catalog-v1"},
+        "kernels": []
+    });
+    assert!(serde_json::from_value::<PreparedKernelPackManifest>(missing.clone()).is_err());
+
+    let mut unknown = missing;
+    unknown["eager_kernel_abi"] = json!(EAGER_KERNEL_ABI);
+    unknown["unexpected"] = json!(true);
+    assert!(serde_json::from_value::<PreparedKernelPackManifest>(unknown).is_err());
+}
+
+#[test]
+fn compiled_prepared_backends_validate_runtime_identity_tuples() {
+    compiled_pack("asm", SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY)
+        .validate()
+        .expect("ASM prepared evaluator tuple");
+    compiled_pack("cpp", SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY)
+        .validate()
+        .expect("C++ prepared evaluator tuple");
+
+    let mut wrong_backend = compiled_pack("asm", SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY);
+    wrong_backend.kernels[0]
+        .f64_evaluator_manifest
+        .as_object_mut()
+        .expect("compiled evaluator object")
+        .insert("backend".to_string(), json!("asm"));
+    assert!(wrong_backend.validate().is_err());
+
+    let wrong_capability = compiled_pack("asm", SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY);
+    assert!(wrong_capability.validate().is_err());
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn prepared_symjit_backend_executes_a_filtered_eager_plan() {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use symjit::{Compiler, CompilerType, Config, Storage};
+
+    static NEXT_DIRECTORY: AtomicU64 = AtomicU64::new(0);
+    let root = std::env::temp_dir().join(format!(
+        "rusticol-eager-backend-{}-{}",
+        std::process::id(),
+        NEXT_DIRECTORY.fetch_add(1, Ordering::Relaxed)
+    ));
+    fs::create_dir_all(root.join("kernels/50")).expect("create prepared-kernel test root");
+
+    let mut config = Config::new(CompilerType::Native, 0).expect("native SymJIT config");
+    config.set_complex(true);
+    config.set_symbolica(true);
+    config.set_opt_level(TEST_PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL as u8);
+    config.set_simd(true);
+    let mut compiler = Compiler::with_config(config);
+    let instructions = r#"[[{"Add":[{"Out":0},[{"Param":0},{"Param":1}],0]}],1,[]]"#;
+    let application = compiler
+        .translate(instructions.to_string(), 2)
+        .expect("translate prepared test application");
+    let mut application_bytes = Vec::new();
+    application
+        .save(&mut application_bytes)
+        .expect("serialize prepared test application");
+    fs::write(
+        root.join("kernels/50/application.symjit"),
+        application_bytes,
+    )
+    .expect("write prepared test application");
+    let plane_application_bytes =
+        crate::engine::compile_symbolica_program_to_plane_application_bytes(
+            instructions,
+            2,
+            1,
+            TEST_PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL as u8,
+            false,
+        )
+        .expect("compile prepared test plane application");
+    fs::write(
+        root.join("kernels/50/application.plane.symjit"),
+        plane_application_bytes,
+    )
+    .expect("write prepared test plane application");
+
+    let pack = filtered_pack(vec![kernel(
+        50,
+        "closure",
+        vec![input("left-current", 0), input("right-current", 0)],
+        "kernels/50/application.symjit",
+    )]);
+    pack.validate().expect("valid filtered test pack");
+    assert_eq!(
+        PreparedEvaluatorBackend::preflight_all(&pack, &root)
+            .expect("preflight raw prepared JIT pack without a DirectTable"),
+        1
+    );
+    let mut backend = PreparedEvaluatorBackend::load(&pack, &root)
+        .expect("load prepared SymJIT evaluator backend");
+    let definition = EagerPlanDefinition {
+        dimensions: EagerPlanDimensions {
+            value_slot_component_counts: vec![1, 1],
+            momentum_slot_component_counts: Vec::new(),
+            current_component_counts: Vec::new(),
+            parameter_count: 0,
+            amplitude_count: 1,
+        },
+        kernels: vec![EagerKernelSpec {
+            kernel_id: 50,
+            role: EagerKernelRole::Closure,
+            inputs: vec![
+                EagerKernelInput::FirstCurrentComponent(0),
+                EagerKernelInput::SecondCurrentComponent(0),
+            ],
+            output_component_count: 1,
+            homogeneous_linear_first_current: false,
+            independent_block_size: 1,
+        }],
+        direct_closures: Vec::new(),
+        reduction_groups: vec![EagerReductionGroup {
+            coherent_group_id: 0,
+            amplitude_indices: vec![0],
+        }],
+        reduction_entries: vec![EagerReductionEntry {
+            left_group_index: 0,
+            right_group_index: 0,
+            coefficient: crate::EagerComplex64::new(1.0, 0.0),
+        }],
+    };
+    let coupling_bytes = EagerCouplingRow::encode_table(&[EagerCouplingRow {
+        real_parameter_id: MISSING_U32,
+        imag_parameter_id: MISSING_U32,
+        constant_real: 1.0,
+        constant_imag: 0.0,
+    }])
+    .expect("encode eager coupling table");
+    let closure_bytes = EagerClosureRow::encode_table(&[EagerClosureRow {
+        kernel_id: 50,
+        left_value_slot_id: 0,
+        right_value_slot_id: 1,
+        amplitude_index: 0,
+        coupling_slot_id: 0,
+        output_factor_source: crate::EAGER_OUTPUT_FACTOR_NONE,
+        factor_real: 1.0,
+        factor_imag: 0.0,
+    }])
+    .expect("encode eager closure table");
+    let plan = EagerExecutionPlan::from_payloads(
+        definition,
+        EagerPlanPayloads {
+            couplings: &coupling_bytes,
+            stages: &[],
+            closures: &closure_bytes,
+            selector_domains: None,
+        },
+    )
+    .expect("build eager test plan");
+    let mut runtime = EagerExecutionRuntime::new(
+        plan,
+        EagerRuntimeOptions {
+            point_tile_size: 2,
+            workspace_bytes: 4096,
+        },
+    )
+    .expect("build eager test runtime");
+    let values = [
+        crate::EagerComplex64::new(1.0, 0.0),
+        crate::EagerComplex64::new(2.0, 0.0),
+        crate::EagerComplex64::new(3.0, 0.0),
+        crate::EagerComplex64::new(10.0, 0.0),
+        crate::EagerComplex64::new(20.0, 0.0),
+        crate::EagerComplex64::new(30.0, 0.0),
+    ];
+    let mut amplitudes = [crate::EagerComplex64::new(0.0, 0.0); 3];
+    let mut reduced = [0.0; 3];
+    runtime
+        .evaluate_into(
+            &mut backend,
+            3,
+            &values,
+            &[],
+            &[],
+            &mut amplitudes,
+            &mut reduced,
+        )
+        .expect("evaluate prepared eager plan");
+    assert_eq!(
+        amplitudes,
+        [
+            crate::EagerComplex64::new(11.0, 0.0),
+            crate::EagerComplex64::new(22.0, 0.0),
+            crate::EagerComplex64::new(33.0, 0.0),
+        ]
+    );
+    assert_eq!(reduced, [121.0, 484.0, 1089.0]);
+
+    amplitudes.fill(crate::EagerComplex64::new(0.0, 0.0));
+    reduced.fill(0.0);
+    let profile = runtime
+        .evaluate_profile_into(
+            &mut backend,
+            3,
+            &values,
+            &[],
+            &[],
+            &mut amplitudes,
+            &mut reduced,
+        )
+        .expect("profile prepared eager plan");
+    assert_eq!(
+        amplitudes,
+        [
+            crate::EagerComplex64::new(11.0, 0.0),
+            crate::EagerComplex64::new(22.0, 0.0),
+            crate::EagerComplex64::new(33.0, 0.0),
+        ]
+    );
+    assert_eq!(reduced, [121.0, 484.0, 1089.0]);
+    assert!(!profile.total.is_zero());
+    assert!(!profile.initialize.is_zero());
+    assert!(!profile.kernel_call.is_zero());
+    assert!(!profile.closure.is_zero());
+    assert!(!profile.reduction.is_zero());
+    assert!(!profile.copy_out.is_zero());
+    assert!(profile.accounted() <= profile.total);
+
+    let _ = fs::remove_dir_all(root);
+}
+
+#[cfg(all(feature = "f64-symjit", target_arch = "aarch64"))]
+#[test]
+#[ignore = "retained real-artifact Direct-Arena stage oracle and interleaved timing evidence"]
+fn retained_ddbar_z3g_multistage_invocations_match_packet_execution() {
+    use crate::eager_runtime::{
+        EagerDirectPreparedKernel, EagerPlanV3Sections, run_retained_multistage_oracle,
+        select_retained_multistage_candidate,
+    };
+    const ARTIFACT_ENV: &str = "PYAMPLICOL_EAGER_DIRECT_REAL_ARTIFACT";
+    const PROCESS_ID: &str = "d_dbar_to_z_g_g_g";
+    const POINTS: u32 = 129;
+    const SAMPLES: usize = 7;
+    const REPETITIONS: usize = 100;
+
+    let root = std::env::var_os(ARTIFACT_ENV)
+        .map(PathBuf::from)
+        .expect("set PYAMPLICOL_EAGER_DIRECT_REAL_ARTIFACT to the retained eager artifact");
+    let native = NativeRuntime::load(&root, Some(PROCESS_ID), None)
+        .expect("load retained eager artifact through the production runtime");
+    let artifact = VerifiedArtifact::open(&root).expect("verify retained eager artifact");
+    let selection = artifact
+        .select_process(Some(PROCESS_ID))
+        .expect("select retained eager process");
+    let (loaded, evaluator_root) =
+        load_verified_evaluator(&artifact, &selection).expect("load eager execution manifest");
+    let LoadedExecutionManifest::EagerV3(manifest) = loaded else {
+        panic!("retained artifact is not eager plan-v3");
+    };
+    let pack = super::eager_v3_load::load_eager_v3_prepared_pack(&artifact, &manifest)
+        .expect("load retained prepared kernel pack");
+    let container = super::eager_v3_load::open_verified_eager_v3_runtime_container(
+        &artifact,
+        &evaluator_root,
+        &manifest,
+    )
+    .expect("open retained eager runtime container");
+    let decoded =
+        super::eager_v3_decode::decode_eager_v3_runtime(&container, &manifest, &pack.manifest)
+            .expect("decode retained eager plan-v3");
+    let payloads = artifact
+        .evaluator_payload_store(&pack.payload_root)
+        .expect("open retained evaluator payload store");
+    let (projection, couplings, _model_parameter_evaluator) =
+        super::eager_v3_load::prepare_plan_v3_parameter_state(
+            &pack.manifest,
+            &decoded,
+            &native.runtime.model_parameters,
+            &payloads,
+        )
+        .expect("prepare retained eager parameter projection");
+    let prepared_parameter_count =
+        u32::try_from(projection.parameter_count).expect("prepared parameter count fits u32");
+    let sections = EagerPlanV3Sections {
+        kernels: &decoded.kernel_specs,
+        prepared_parameter_count,
+        currents: &decoded.currents,
+        values: &decoded.values,
+        momenta: &decoded.momenta,
+        parameters: &decoded.parameters,
+        stages: &decoded.stages,
+        couplings: &couplings,
+        invocations: &decoded.invocations,
+        attachments: &decoded.attachments,
+        finalizations: &decoded.finalizations,
+        closures: &decoded.closures,
+        direct_coefficients: &decoded.direct_coefficients,
+        selector_domains: &decoded.selector_domains,
+        selector_memberships: &decoded.selector_memberships,
+        reduction_groups: &decoded.reduction_groups,
+        reduction_entries: &decoded.reduction_entries,
+        exact_factors: &decoded.exact_factors,
+        color_contraction_entry_start: decoded.color_contraction_entry_start,
+        color_contraction_entry_count: decoded.color_contraction_entry_count,
+    };
+    let candidate =
+        select_retained_multistage_candidate(sections).expect("select genuine retained stage run");
+    let kernel = decoded
+        .kernel_specs
+        .iter()
+        .find(|kernel| kernel.kernel_id == candidate.kernel_id)
+        .expect("candidate kernel spec");
+    let kernel_manifest = pack
+        .manifest
+        .kernels
+        .iter()
+        .find(|kernel| kernel.kernel_id == candidate.kernel_id)
+        .expect("candidate prepared kernel manifest");
+    let plane_application = kernel_manifest
+        .f64_evaluator_manifest
+        .get("plane_application")
+        .and_then(Value::as_object)
+        .expect("candidate SymJIT plane application metadata");
+    let application_path = plane_application
+        .get("application_path")
+        .and_then(Value::as_str)
+        .expect("candidate SymJIT plane application path");
+    let application_source = payloads
+        .source(application_path)
+        .expect("resolve candidate SymJIT application");
+    let source_bytes = application_source
+        .read()
+        .expect("read candidate SymJIT application")
+        .into_owned();
+    let descriptor = symjit_eager_direct::eager_direct_descriptor_for_source_application_bytes(
+        &source_bytes,
+        u32::try_from(kernel.inputs.len()).expect("candidate input width fits u32"),
+        kernel.output_component_count,
+        Path::new(&application_source.display_name()),
+    )
+    .expect("encode retained eager table descriptor");
+    let prepared = EagerDirectPreparedKernel {
+        kernel_id: candidate.kernel_id,
+        role: kernel.role,
+        inputs: &kernel.inputs,
+        output_component_count: kernel.output_component_count,
+        application: crate::eager_runtime::EagerDirectPreparedApplication::Symjit {
+            source_application: &source_bytes,
+            descriptor: &descriptor,
+            expected_optimization_level: 2,
+            expected_compression: false,
+        },
+        display_path: PathBuf::from(application_source.display_name()),
+    };
+
+    let mut scalar_pack = pack.manifest.clone();
+    scalar_pack
+        .kernels
+        .retain(|entry| entry.kernel_id == candidate.kernel_id);
+    scalar_pack.kernel_variants.clear();
+    let mut backend = PreparedEvaluatorBackend::load_from_store(&scalar_pack, &payloads)
+        .expect("load retained scalar packet oracle");
+    let mut model_parameters =
+        vec![crate::EagerComplex64::new(0.0, 0.0); projection.parameter_count];
+    for entry in &projection.entries {
+        let real = native.runtime.model_parameter_values_f64[entry.runtime_real_index];
+        let imaginary = entry
+            .runtime_imaginary_index
+            .map(|index| native.runtime.model_parameter_values_f64[index])
+            .unwrap_or(0.0);
+        model_parameters[entry.prepared_index] = crate::EagerComplex64::new(real, imaginary);
+    }
+
+    let evidence = run_retained_multistage_oracle(
+        sections,
+        &[prepared],
+        candidate,
+        &mut backend,
+        &model_parameters,
+        POINTS,
+        SAMPLES,
+        REPETITIONS,
+    )
+    .expect("retained Direct-Arena stage must match actual packet execution");
+    for variant in [evidence.full, evidence.selected] {
+        variant
+            .direct_call_traffic
+            .validate_direct()
+            .expect("direct invocation slice has no forbidden materialization traffic");
+        assert!(variant.comparison_count > 0);
+    }
+    eprintln!(
+        "retained eager Direct-Arena stage oracle: artifact={} process={} \
+         stage_position={} stage_index={} kernel_id={} selector_group={} points={} \
+         full_rows={}/{} destinations={} comparisons={} bitwise={}/{} \
+         full_max_abs={:.6e} full_max_rel={:.6e} \
+         full_direct_ns={:.3} full_direct_mad_ns={:.3} \
+         full_packet_ns={:.3} full_packet_mad_ns={:.3} full_ratio={:.6} \
+         full_init_write_bytes={} full_factor_fill_bytes={} \
+         full_packet_input_bytes/call={} full_packet_output_bytes/call={} \
+         full_packet_scatter_bytes/call={} \
+         selected_rows={}/{} comparisons={} bitwise={}/{} \
+         selected_max_abs={:.6e} selected_max_rel={:.6e} \
+         selected_direct_ns={:.3} selected_direct_mad_ns={:.3} \
+         selected_packet_ns={:.3} selected_packet_mad_ns={:.3} selected_ratio={:.6} \
+         selected_init_write_bytes={} selected_factor_fill_bytes={} \
+         selected_packet_input_bytes/call={} selected_packet_output_bytes/call={} \
+         selected_packet_scatter_bytes/call={} \
+         direct_call_traffic_full={:?} direct_call_traffic_selected={:?}",
+        root.display(),
+        PROCESS_ID,
+        evidence.candidate.stage_position,
+        evidence.candidate.stage_index,
+        evidence.candidate.kernel_id,
+        evidence.candidate.selector_group_id,
+        POINTS,
+        evidence.full.invocation_count,
+        evidence.full.attachment_count,
+        evidence.candidate.distinct_destination_count,
+        evidence.full.comparison_count,
+        evidence.full.bitwise_comparison_count,
+        evidence.full.comparison_count,
+        evidence.full.maximum_absolute_error,
+        evidence.full.maximum_relative_error,
+        evidence.full.direct_median_ns,
+        evidence.full.direct_mad_ns,
+        evidence.full.packet_median_ns,
+        evidence.full.packet_mad_ns,
+        evidence.full.direct_over_packet,
+        evidence.full.arena_initialization_write_bytes,
+        evidence.full.factor_fill_write_bytes,
+        evidence.full.packet_input_materialization_bytes_per_call,
+        evidence.full.packet_output_materialization_bytes_per_call,
+        evidence.full.packet_scatter_bytes_per_call,
+        evidence.selected.invocation_count,
+        evidence.selected.attachment_count,
+        evidence.selected.comparison_count,
+        evidence.selected.bitwise_comparison_count,
+        evidence.selected.comparison_count,
+        evidence.selected.maximum_absolute_error,
+        evidence.selected.maximum_relative_error,
+        evidence.selected.direct_median_ns,
+        evidence.selected.direct_mad_ns,
+        evidence.selected.packet_median_ns,
+        evidence.selected.packet_mad_ns,
+        evidence.selected.direct_over_packet,
+        evidence.selected.arena_initialization_write_bytes,
+        evidence.selected.factor_fill_write_bytes,
+        evidence
+            .selected
+            .packet_input_materialization_bytes_per_call,
+        evidence
+            .selected
+            .packet_output_materialization_bytes_per_call,
+        evidence.selected.packet_scatter_bytes_per_call,
+        evidence.full.direct_call_traffic,
+        evidence.selected.direct_call_traffic,
+    );
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn generated_eager_artifact_loads_when_fixture_is_supplied() {
+    let Some(root) = std::env::var_os("RUSTICOL_EAGER_ARTIFACT") else {
+        return;
+    };
+    let mut runtime = NativeRuntime::load(PathBuf::from(root), None, None)
+        .expect("load generated eager artifact through NativeRuntime");
+    assert_eq!(runtime.metadata().execution_mode, "eager");
+    assert!(matches!(
+        runtime.metadata().prepared_backend.as_deref(),
+        Some("jit" | "asm" | "cpp")
+    ));
+    let validation_path = runtime
+        .root()
+        .join("processes")
+        .join(&runtime.metadata().representative_process_key)
+        .join("validation-momenta.json");
+    let validation: Value =
+        serde_json::from_slice(&fs::read(&validation_path).expect("read eager validation momenta"))
+            .expect("parse eager validation momenta");
+    let momenta = validation["points"][0]
+        .as_array()
+        .expect("one eager validation point")
+        .iter()
+        .flat_map(|leg| {
+            leg["momentum"]
+                .as_array()
+                .expect("four momentum components")
+                .iter()
+                .map(|value| {
+                    value
+                        .as_str()
+                        .expect("decimal momentum string")
+                        .parse::<f64>()
+                        .expect("f64 validation momentum")
+                })
+        })
+        .collect::<Vec<_>>();
+    let values = runtime
+        .evaluate_f64(&momenta, 1)
+        .expect("evaluate generated eager artifact");
+    assert_eq!(values.len(), 1);
+    assert!(values[0].is_finite());
+
+    let resolved = runtime
+        .evaluate_resolved_f64(&momenta, 1, None, None)
+        .expect("resolve generated eager artifact");
+    let resolved_total = resolved.totals()[0];
+    assert_close_f64(resolved_total, values[0], "eager resolved sum");
+
+    let selected_helicity = runtime
+        .helicities()
+        .expect("eager helicity metadata")
+        .into_iter()
+        .find(|helicity| helicity.computed)
+        .expect("one computed helicity")
+        .id;
+    let selected_color = runtime
+        .color_ids()
+        .expect("eager color metadata")
+        .into_iter()
+        .next()
+        .expect("one color component");
+    let selected_colors =
+        (runtime.metadata().color_accuracy == "lc").then(|| std::slice::from_ref(&selected_color));
+    let selected = runtime
+        .evaluate_resolved_f64(
+            &momenta,
+            1,
+            Some(std::slice::from_ref(&selected_helicity)),
+            selected_colors,
+        )
+        .expect("select eager resolved component");
+    assert_eq!(selected.shape(), (1, 1, 1));
+    assert!(selected.values[0].is_finite());
+
+    let selector_point_count = 4;
+    let selector_momenta = momenta.repeat(selector_point_count);
+    let all_components = runtime
+        .evaluate_resolved_f64(&selector_momenta, selector_point_count, None, None)
+        .expect("resolve eager selector fixture");
+    let helicity_count = all_components.helicity_ids.len();
+    let color_count = all_components.color_ids.len();
+    assert!(helicity_count >= 2, "selector fixture needs two helicities");
+    assert!(
+        color_count >= 1,
+        "selector fixture needs one color component"
+    );
+    let helicity_by_point = [0_u32, 1, 0, 1];
+    let color_by_point = [0_u32; 4];
+    let color_by_point =
+        (runtime.metadata().color_accuracy == "lc").then_some(color_by_point.as_slice());
+    let selected_by_point = runtime
+        .evaluate_f64_with_selectors(
+            &selector_momenta,
+            selector_point_count,
+            None,
+            None,
+            Some(&helicity_by_point),
+            color_by_point,
+        )
+        .expect("evaluate eager per-point selectors");
+    for point_index in 0..selector_point_count {
+        let expected_index =
+            (point_index * helicity_count + helicity_by_point[point_index] as usize) * color_count;
+        assert_close_f64(
+            selected_by_point[point_index],
+            all_components.values[expected_index],
+            "eager per-point selector",
+        );
+    }
+
+    {
+        for tail in [1_usize, 7, 63, 64, 65, 127, 128, 129, 1023, 1024, 1025] {
+            let tail_momenta = momenta.repeat(tail);
+            let tail_values = runtime
+                .evaluate_f64(&tail_momenta, tail)
+                .expect("evaluate required eager Direct-Arena tail");
+            for value in tail_values {
+                assert_close_f64(value, values[0], "eager Direct-Arena repeated-point tail");
+            }
+        }
+
+        for tail in [129_usize, 1025] {
+            let tail_momenta = momenta.repeat(tail);
+            let helicity_by_point = (0..tail)
+                .map(|point| (point % helicity_count.min(2)) as u32)
+                .collect::<Vec<_>>();
+            let color_by_point =
+                (runtime.metadata().color_accuracy == "lc").then(|| vec![0_u32; tail]);
+            let selected_tail = runtime
+                .evaluate_f64_with_selectors(
+                    &tail_momenta,
+                    tail,
+                    None,
+                    None,
+                    Some(&helicity_by_point),
+                    color_by_point.as_deref(),
+                )
+                .expect("evaluate required eager Direct-Arena selector tail");
+            for (point, value) in selected_tail.into_iter().enumerate() {
+                let expected_index = helicity_by_point[point] as usize * color_count;
+                let expected = if color_by_point.is_some() {
+                    resolved.values[expected_index]
+                } else {
+                    resolved.values[expected_index..expected_index + color_count]
+                        .iter()
+                        .sum()
+                };
+                assert_close_f64(value, expected, "eager Direct-Arena selector tail");
+            }
+        }
+    }
+
+    if let Some(compiled_root) = std::env::var_os("RUSTICOL_COMPILED_ARTIFACT") {
+        let mut compiled = NativeRuntime::load(PathBuf::from(compiled_root), None, None)
+            .expect("load matching compiled artifact");
+        let compiled_values = compiled
+            .evaluate_f64(&momenta, 1)
+            .expect("evaluate matching compiled artifact");
+        assert_close_f64(values[0], compiled_values[0], "eager/compiled total");
+        let compiled_resolved = compiled
+            .evaluate_resolved_f64(&momenta, 1, None, None)
+            .expect("resolve matching compiled artifact");
+        assert_eq!(resolved.helicity_ids, compiled_resolved.helicity_ids);
+        assert_eq!(resolved.color_ids, compiled_resolved.color_ids);
+        assert_eq!(resolved.values.len(), compiled_resolved.values.len());
+        for (eager, compiled) in resolved.values.iter().zip(&compiled_resolved.values) {
+            assert_close_f64(*eager, *compiled, "eager/compiled resolved component");
+        }
+    }
+
+    let parameters = runtime.model_parameters().expect("eager model parameters");
+    let candidates = if let Some(parameter) = parameters
+        .iter()
+        .find(|parameter| parameter.name == "aEWM1")
+    {
+        vec![(
+            BTreeMap::from([(parameter.name.clone(), (parameter.default * 1.05, 0.0))]),
+            BTreeMap::from([(
+                parameter.name.clone(),
+                (parameter.default, parameter.default_imaginary),
+            )]),
+        )]
+    } else {
+        let mut groups = BTreeMap::<String, Vec<(String, f64, f64)>>::new();
+        for parameter in parameters
+            .iter()
+            .filter(|parameter| parameter.mutable && parameter.name.starts_with("coupling."))
+        {
+            let prefix = parameter
+                .name
+                .split_once(".component_")
+                .map(|(prefix, _)| prefix.to_string())
+                .expect("coupling component suffix");
+            groups.entry(prefix).or_default().push((
+                parameter.name.clone(),
+                parameter.default,
+                parameter.default_imaginary,
+            ));
+        }
+        groups
+            .into_values()
+            .map(|selected| {
+                let changed = selected
+                    .iter()
+                    .map(|(name, _, _)| (name.clone(), (0.0, 0.0)))
+                    .collect();
+                let restored = selected
+                    .iter()
+                    .map(|(name, real, imaginary)| (name.clone(), (*real, *imaginary)))
+                    .collect();
+                (changed, restored)
+            })
+            .collect::<Vec<_>>()
+    };
+    assert!(!candidates.is_empty(), "one mutable eager parameter group");
+    let mut observed_parameter_effect = false;
+    for (changed, restored) in candidates {
+        runtime
+            .set_model_parameters(&changed)
+            .expect("update eager model parameters atomically");
+        let changed_value = runtime
+            .evaluate_f64(&momenta, 1)
+            .expect("evaluate updated eager parameters")[0];
+        runtime
+            .set_model_parameters(&restored)
+            .expect("restore eager model parameters atomically");
+        let restored_value = runtime
+            .evaluate_f64(&momenta, 1)
+            .expect("evaluate restored eager parameters")[0];
+        assert_eq!(restored_value.to_bits(), values[0].to_bits());
+        if changed_value.to_bits() != values[0].to_bits() {
+            observed_parameter_effect = true;
+            break;
+        }
+    }
+    assert!(
+        observed_parameter_effect,
+        "one eager parameter affects output"
+    );
+
+    if parameters.iter().any(|parameter| parameter.name == "aEWM1")
+        && parameters.iter().any(|parameter| parameter.name == "MZ")
+    {
+        let before_failed_derivation = runtime
+            .exact_runtime_state_json()
+            .expect("eager state before failed derivation");
+        assert!(runtime.set_model_parameter("MZ", 0.0, 0.0).is_err());
+        assert_eq!(
+            runtime
+                .exact_runtime_state_json()
+                .expect("eager state after failed derivation"),
+            before_failed_derivation
+        );
+    }
+
+    if let Some(parameter) = parameters.iter().find(|parameter| !parameter.mutable) {
+        let before_derived_update = runtime
+            .exact_runtime_state_json()
+            .expect("eager parameter state before derived update");
+        assert!(
+            runtime
+                .set_model_parameter(
+                    &parameter.name,
+                    parameter.default,
+                    parameter.default_imaginary,
+                )
+                .is_err()
+        );
+        assert_eq!(
+            runtime
+                .exact_runtime_state_json()
+                .expect("eager parameter state after derived update"),
+            before_derived_update
+        );
+    }
+
+    let before_failed_update = runtime
+        .exact_runtime_state_json()
+        .expect("eager parameter state before failed update");
+    assert!(
+        runtime
+            .set_model_parameter("not-a-model-parameter", 1.0, 0.0)
+            .is_err()
+    );
+    assert_eq!(
+        runtime
+            .exact_runtime_state_json()
+            .expect("eager parameter state after failed update"),
+        before_failed_update
+    );
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn retained_sparse_group_eager_artifact_decodes_when_fixture_is_supplied() {
+    let Some(root) = std::env::var_os("RUSTICOL_EAGER_SPARSE_GROUP_ARTIFACT") else {
+        return;
+    };
+    let root = PathBuf::from(root);
+    let _native = NativeRuntime::load(&root, None, None)
+        .expect("load retained zero-first-group eager artifact through NativeRuntime");
+    let artifact = VerifiedArtifact::open(&root).expect("verify retained eager artifact");
+    let selection = artifact
+        .select_process(None)
+        .expect("select retained eager process");
+    let (loaded, evaluator_root) =
+        load_verified_evaluator(&artifact, &selection).expect("load eager execution manifest");
+    let LoadedExecutionManifest::EagerV3(manifest) = loaded else {
+        panic!("retained artifact is not eager plan-v3");
+    };
+    let pack = super::eager_v3_load::load_eager_v3_prepared_pack(&artifact, &manifest)
+        .expect("load retained prepared kernel pack");
+    let container = super::eager_v3_load::open_verified_eager_v3_runtime_container(
+        &artifact,
+        &evaluator_root,
+        &manifest,
+    )
+    .expect("open retained eager runtime container");
+    let decoded =
+        super::eager_v3_decode::decode_eager_v3_runtime(&container, &manifest, &pack.manifest)
+            .expect("decode retained zero-first-group eager plan-v3");
+    let group_ids = decoded
+        .invocations
+        .iter()
+        .map(|row| row.evaluation_group_id)
+        .collect::<Vec<_>>();
+    assert!(group_ids.windows(2).all(|pair| pair[0] < pair[1]));
+    assert!(
+        group_ids
+            .windows(2)
+            .any(|pair| pair[1] > pair[0].saturating_add(1)),
+        "retained eager failure fixture must contain a pruned group gap: {group_ids:?}"
+    );
+}
+
+#[cfg(all(
+    any(feature = "f64-compiled", feature = "f64-symjit"),
+    any(target_os = "linux", target_os = "macos")
+))]
+#[test]
+fn generated_eager_native_into_is_warmed_allocation_free_when_fixture_is_supplied() {
+    let Some(root) = std::env::var_os("RUSTICOL_EAGER_ARTIFACT") else {
+        return;
+    };
+    let mut runtime = NativeRuntime::load(PathBuf::from(root), None, None)
+        .expect("load generated eager allocation fixture");
+    let validation_path = runtime
+        .root()
+        .join("processes")
+        .join(&runtime.metadata().representative_process_key)
+        .join("validation-momenta.json");
+    let validation: Value =
+        serde_json::from_slice(&fs::read(&validation_path).expect("read eager validation momenta"))
+            .expect("parse eager validation momenta");
+    let point = validation["points"][0]
+        .as_array()
+        .expect("one eager validation point")
+        .iter()
+        .flat_map(|leg| {
+            leg["momentum"]
+                .as_array()
+                .expect("four momentum components")
+                .iter()
+                .map(|value| {
+                    value
+                        .as_str()
+                        .expect("decimal momentum string")
+                        .parse::<f64>()
+                        .expect("f64 validation momentum")
+                })
+        })
+        .collect::<Vec<_>>();
+    let point_count = 129usize;
+    let momenta = point.repeat(point_count);
+    let mut output = vec![-1.0; point_count];
+
+    runtime
+        .evaluate_f64_into(&momenta, point_count, &mut output)
+        .expect("warm eager borrowed-input totals");
+    let (result, allocations, bytes) =
+        count_allocations(|| runtime.evaluate_f64_into(&momenta, point_count, &mut output));
+    result.expect("repeat eager borrowed-input totals");
+    assert_eq!(
+        (allocations, bytes),
+        (0, 0),
+        "warmed eager borrowed-input totals allocated"
+    );
+    let arena_profile = runtime
+        .evaluate_f64_arena_profile_repeated(&momenta, point_count, 3, None, None)
+        .expect("profile warmed eager borrowed-input totals");
+    assert_eq!(arena_profile.values, output);
+    assert_eq!(
+        arena_profile
+            .profile
+            .native_input_container_allocation_count,
+        0
+    );
+    assert_eq!(arena_profile.profile.native_output_allocation_count, 0);
+    assert_eq!(arena_profile.profile.observed_scratch_reallocation_count, 0);
+    assert_eq!(
+        arena_profile.profile.native_input_component_count,
+        u64::try_from(momenta.len() * 3).expect("profile input count"),
+    );
+
+    let selected_helicity = runtime
+        .helicities()
+        .expect("eager helicity metadata")
+        .into_iter()
+        .find(|helicity| helicity.computed)
+        .expect("one computed eager helicity")
+        .id;
+    let selected_helicities = [selected_helicity];
+    let selected_colors = (runtime.metadata().color_accuracy == "lc").then(|| {
+        [runtime
+            .color_ids()
+            .expect("eager color metadata")
+            .into_iter()
+            .next()
+            .expect("one eager color")]
+    });
+    runtime
+        .evaluate_f64_into_with_selectors(
+            &momenta,
+            point_count,
+            Some(&selected_helicities),
+            selected_colors.as_ref().map(|ids| ids.as_slice()),
+            None,
+            None,
+            &mut output,
+        )
+        .expect("warm eager global selectors");
+    let (result, allocations, bytes) = count_allocations(|| {
+        runtime.evaluate_f64_into_with_selectors(
+            &momenta,
+            point_count,
+            Some(&selected_helicities),
+            selected_colors.as_ref().map(|ids| ids.as_slice()),
+            None,
+            None,
+            &mut output,
+        )
+    });
+    result.expect("repeat eager global selectors");
+    assert_eq!(
+        (allocations, bytes),
+        (0, 0),
+        "warmed eager global selectors allocated"
+    );
+    let mut profile_cases = vec![(
+        "selected-helicity",
+        Some(selected_helicities.as_slice()),
+        None,
+    )];
+    if let Some(ids) = selected_colors.as_ref() {
+        profile_cases.push(("selected-flow", None, Some(ids.as_slice())));
+    }
+    for (label, helicities, colors) in profile_cases {
+        runtime
+            .evaluate_f64_into_with_selectors(
+                &momenta,
+                point_count,
+                helicities,
+                colors,
+                None,
+                None,
+                &mut output,
+            )
+            .unwrap_or_else(|error| panic!("evaluate eager {label} oracle: {error}"));
+        let selected_profile = runtime
+            .evaluate_f64_arena_profile_repeated(&momenta, point_count, 3, helicities, colors)
+            .unwrap_or_else(|error| panic!("profile eager {label}: {error}"));
+        assert_eq!(
+            selected_profile.values, output,
+            "profiled eager {label} values"
+        );
+        assert_eq!(
+            selected_profile
+                .profile
+                .native_input_container_allocation_count,
+            0,
+            "profiled eager {label} input allocations"
+        );
+        assert_eq!(
+            selected_profile.profile.native_output_allocation_count, 0,
+            "profiled eager {label} output allocations"
+        );
+        assert_eq!(
+            selected_profile.profile.observed_scratch_reallocation_count, 0,
+            "profiled eager {label} scratch reallocations"
+        );
+    }
+
+    let helicity_count = runtime
+        .helicities()
+        .expect("eager helicity metadata")
+        .len()
+        .min(2);
+    let helicity_by_point = (0..point_count)
+        .map(|point| (point % helicity_count) as u32)
+        .collect::<Vec<_>>();
+    let color_by_point =
+        (runtime.metadata().color_accuracy == "lc").then(|| vec![0_u32; point_count]);
+    runtime
+        .evaluate_f64_into_with_selectors(
+            &momenta,
+            point_count,
+            None,
+            None,
+            Some(&helicity_by_point),
+            color_by_point.as_deref(),
+            &mut output,
+        )
+        .expect("warm eager alternating selectors");
+    let (result, allocations, bytes) = count_allocations(|| {
+        runtime.evaluate_f64_into_with_selectors(
+            &momenta,
+            point_count,
+            None,
+            None,
+            Some(&helicity_by_point),
+            color_by_point.as_deref(),
+            &mut output,
+        )
+    });
+    result.expect("repeat eager alternating selectors");
+    assert_eq!(
+        (allocations, bytes),
+        (0, 0),
+        "warmed eager alternating selectors allocated"
+    );
+
+    runtime
+        .evaluate_resolved_f64(&momenta, point_count, None, None)
+        .expect("warm eager borrowed-input resolved values");
+    let (resolved, allocations, bytes) =
+        count_allocations(|| runtime.evaluate_resolved_f64(&momenta, point_count, None, None));
+    let resolved = resolved.expect("repeat eager borrowed-input resolved values");
+    let result_owned_allocation_bound = resolved.helicity_ids.len() + resolved.color_ids.len() + 12;
+    assert!(
+        allocations <= result_owned_allocation_bound,
+        "warmed eager resolved path retained point-sized input containers: \
+         allocations={allocations} bytes={bytes} result_bound={result_owned_allocation_bound}"
+    );
+    assert_eq!(resolved.point_count, point_count);
+    assert_eq!(
+        resolved.values.len(),
+        point_count * resolved.helicity_ids.len() * resolved.color_ids.len()
+    );
+
+    runtime
+        .evaluate_resolved_f64(
+            &momenta,
+            point_count,
+            Some(&selected_helicities),
+            selected_colors.as_ref().map(|ids| ids.as_slice()),
+        )
+        .expect("warm eager selected borrowed-input resolved values");
+    let (selected_resolved, allocations, bytes) = count_allocations(|| {
+        runtime.evaluate_resolved_f64(
+            &momenta,
+            point_count,
+            Some(&selected_helicities),
+            selected_colors.as_ref().map(|ids| ids.as_slice()),
+        )
+    });
+    let selected_resolved =
+        selected_resolved.expect("repeat eager selected borrowed-input resolved values");
+    let result_owned_allocation_bound =
+        selected_resolved.helicity_ids.len() + selected_resolved.color_ids.len() + 12;
+    assert!(
+        allocations <= result_owned_allocation_bound,
+        "warmed selected eager resolved path retained point-sized input containers: \
+         allocations={allocations} bytes={bytes} result_bound={result_owned_allocation_bound}"
+    );
+    assert_eq!(selected_resolved.point_count, point_count);
+    assert_eq!(
+        selected_resolved.values.len(),
+        point_count * selected_resolved.helicity_ids.len() * selected_resolved.color_ids.len()
+    );
+
+    let mut sentinel = [37.0_f64, 41.0];
+    assert!(
+        runtime
+            .evaluate_f64_into(&momenta, point_count, &mut sentinel)
+            .is_err()
+    );
+    assert_eq!(sentinel, [37.0, 41.0]);
+}
+
+fn assert_close_f64(actual: f64, expected: f64, context: &str) {
+    let tolerance = 1.0e-15 + 1.0e-12 * expected.abs();
+    assert!(
+        (actual - expected).abs() <= tolerance,
+        "{context}: {actual:.17e} != {expected:.17e} (tolerance {tolerance:.3e})"
+    );
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/eager_lane.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_lane.rs
new file mode 100644
index 0000000000..99e13bcf26
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_lane.rs
@@ -0,0 +1,2899 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::evaluation::accumulate_selected_lc_replay_resolved_f64;
+use super::*;
+
+#[derive(Clone, Copy, Debug)]
+pub(super) struct EagerParameterProjectionEntry {
+    pub(super) prepared_index: usize,
+    pub(super) runtime_real_index: usize,
+    pub(super) runtime_imaginary_index: Option<usize>,
+}
+
+#[derive(Debug)]
+pub(super) struct EagerParameterProjection {
+    pub(super) parameter_count: usize,
+    pub(super) entries: Vec<EagerParameterProjectionEntry>,
+}
+
+#[allow(dead_code)] // Includes the order-preserving per-point benchmark reference buffers.
+pub(super) struct EagerNativeRuntime {
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    direct_scheduler: Option<crate::eager_runtime::EagerDirectExecutionRuntime>,
+    backend_name: String,
+    amplitude_count: usize,
+    has_selector_domains: bool,
+    effective_point_tile_size: usize,
+    workspace_bytes: usize,
+    parameter_projection: EagerParameterProjection,
+    raw_sum_groups: Vec<RawSumGroup>,
+    lc_resolved_replay_plan: Option<Arc<LcResolvedReplayPlan>>,
+    lc_resolved_replay_selection_cache:
+        Vec<(LcResolvedReplaySelectionKey, Arc<LcResolvedReplaySelection>)>,
+    lc_replay_expanded_batch: Vec<Vec<[f64; 4]>>,
+    lc_replay_seen_labels: Vec<bool>,
+    lc_replay_flat_momenta: Vec<f64>,
+    lc_replay_materialized_values: Vec<f64>,
+    lc_replay_target_components: Vec<f64>,
+    color_topology_replay: Option<AmplitudeRuntime>,
+    color_contraction: Option<ColorContractionRuntime>,
+    initial_values: Vec<crate::EagerComplex64>,
+    momenta: Vec<f64>,
+    model_parameters: Vec<crate::EagerComplex64>,
+    amplitudes: Vec<crate::EagerComplex64>,
+    color_group_scratch: Vec<crate::EagerComplex64>,
+    reduced: Vec<f64>,
+    selected_groups: Vec<u32>,
+    point_selector_offsets: Vec<usize>,
+    point_selector_groups: Vec<u32>,
+    point_selector_group_weights: Vec<f64>,
+    point_selector_members: Option<Vec<Vec<(usize, usize, f64)>>>,
+    point_selector_pairs: Vec<(u32, f64)>,
+    selected_helicity_indices: Vec<usize>,
+    selected_color_indices: Vec<usize>,
+    helicity_position_scratch: Vec<Option<usize>>,
+    color_position_scratch: Vec<Option<usize>>,
+    helicity_weights_scratch: Vec<(usize, f64)>,
+    right_helicity_weights_scratch: Vec<(usize, f64)>,
+    member_weights_scratch: Vec<(usize, usize, f64)>,
+    source_schedule: Option<EagerSourceSchedule>,
+    source_wavefunction_scratch: Vec<Complex<f64>>,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct EagerSourceKey {
+    source_kind: String,
+    leg_label: usize,
+    family: u8,
+    dimension: usize,
+    pdg_label: i32,
+    anti_pdg_label: i32,
+    orientation: u8,
+    momentum_transform: u8,
+    phase_real: u64,
+    phase_imaginary: u64,
+    source_helicity: i32,
+    chirality: i32,
+}
+
+#[derive(Debug)]
+struct EagerSourceClass {
+    representative_index: usize,
+    target_component_starts: Vec<usize>,
+    dimension: usize,
+}
+
+#[derive(Debug)]
+struct EagerSourceSchedule {
+    classes: Vec<EagerSourceClass>,
+    maximum_dimension: usize,
+}
+
+impl EagerNativeRuntime {
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    pub(super) fn new_direct(
+        scheduler: crate::eager_runtime::EagerDirectExecutionRuntime,
+        backend_name: String,
+        parameter_projection: EagerParameterProjection,
+        raw_sum_groups: Vec<RawSumGroup>,
+        color_contraction: Option<ColorContractionRuntime>,
+        color_topology_replay: Option<AmplitudeRuntime>,
+    ) -> Self {
+        let amplitude_count = scheduler.plan().amplitude_count();
+        let has_selector_domains = scheduler.plan().has_selector_domains();
+        let effective_point_tile_size = scheduler.effective_point_tile_size();
+        let workspace_bytes = scheduler.workspace_bytes();
+        Self {
+            direct_scheduler: Some(scheduler),
+            backend_name,
+            amplitude_count,
+            has_selector_domains,
+            effective_point_tile_size,
+            workspace_bytes,
+            parameter_projection,
+            raw_sum_groups,
+            lc_resolved_replay_plan: None,
+            lc_resolved_replay_selection_cache: Vec::new(),
+            lc_replay_expanded_batch: Vec::new(),
+            lc_replay_seen_labels: Vec::new(),
+            lc_replay_flat_momenta: Vec::new(),
+            lc_replay_materialized_values: Vec::new(),
+            lc_replay_target_components: Vec::new(),
+            color_topology_replay,
+            color_contraction,
+            initial_values: Vec::new(),
+            momenta: Vec::new(),
+            model_parameters: Vec::new(),
+            amplitudes: Vec::new(),
+            color_group_scratch: Vec::new(),
+            reduced: Vec::new(),
+            selected_groups: Vec::new(),
+            point_selector_offsets: Vec::new(),
+            point_selector_groups: Vec::new(),
+            point_selector_group_weights: Vec::new(),
+            point_selector_members: None,
+            point_selector_pairs: Vec::new(),
+            selected_helicity_indices: Vec::new(),
+            selected_color_indices: Vec::new(),
+            helicity_position_scratch: Vec::new(),
+            color_position_scratch: Vec::new(),
+            helicity_weights_scratch: Vec::new(),
+            right_helicity_weights_scratch: Vec::new(),
+            member_weights_scratch: Vec::new(),
+            source_schedule: None,
+            source_wavefunction_scratch: Vec::new(),
+        }
+    }
+
+    fn execute_full_scheduler(&mut self, point_count: usize) -> RusticolResult<()> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            self.direct_scheduler
+                .as_mut()
+                .ok_or_else(|| {
+                    RusticolError::internal(
+                        "production eager runtime has no Direct-Arena scheduler",
+                    )
+                })?
+                .evaluate_into(
+                    point_count,
+                    &self.initial_values,
+                    &self.momenta,
+                    &self.model_parameters,
+                    &mut self.amplitudes,
+                    &mut self.reduced,
+                )
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            let _ = point_count;
+            Err(RusticolError::compatibility(
+                "eager-direct-arena-v1 requires the f64-compiled or f64-symjit feature; regenerate or load \
+                 this artifact with a Direct-Arena-capable runtime",
+            ))
+        }
+    }
+
+    fn execute_full_totals_scheduler(&mut self, point_count: usize) -> RusticolResult<()> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            self.direct_scheduler
+                .as_mut()
+                .ok_or_else(|| {
+                    RusticolError::internal(
+                        "production eager runtime has no Direct-Arena scheduler",
+                    )
+                })?
+                .evaluate_totals_into(
+                    point_count,
+                    &self.initial_values,
+                    &self.momenta,
+                    &self.model_parameters,
+                    &mut self.reduced,
+                )
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            let _ = point_count;
+            Err(RusticolError::compatibility(
+                "eager-direct-arena-v1 requires the f64-compiled or f64-symjit feature; regenerate or load \
+                 this artifact with a Direct-Arena-capable runtime",
+            ))
+        }
+    }
+
+    fn execute_selected_scheduler(
+        &mut self,
+        active_groups: &[u32],
+        point_count: usize,
+    ) -> RusticolResult<()> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            self.direct_scheduler
+                .as_mut()
+                .ok_or_else(|| {
+                    RusticolError::internal(
+                        "production eager runtime has no Direct-Arena scheduler",
+                    )
+                })?
+                .evaluate_selected_active_amplitudes_into(
+                    active_groups,
+                    point_count,
+                    &self.initial_values,
+                    &self.momenta,
+                    &self.model_parameters,
+                    &mut self.amplitudes,
+                )
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            let _ = (active_groups, point_count);
+            Err(RusticolError::compatibility(
+                "eager-direct-arena-v1 requires the f64-compiled or f64-symjit feature; regenerate or load \
+                 this artifact with a Direct-Arena-capable runtime",
+            ))
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn execute_point_selected_scheduler(
+        &mut self,
+        group_offsets: &[usize],
+        active_groups: &[u32],
+        active_group_weights: &[f64],
+        point_count: usize,
+        reduced: &mut [f64],
+    ) -> RusticolResult<()> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            self.direct_scheduler
+                .as_mut()
+                .ok_or_else(|| {
+                    RusticolError::internal(
+                        "production eager runtime has no Direct-Arena scheduler",
+                    )
+                })?
+                .evaluate_point_selected_group_sets_into(
+                    group_offsets,
+                    active_groups,
+                    active_group_weights,
+                    point_count,
+                    &self.initial_values,
+                    &self.momenta,
+                    &self.model_parameters,
+                    reduced,
+                )
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            let _ = (
+                group_offsets,
+                active_groups,
+                active_group_weights,
+                point_count,
+                reduced,
+            );
+            Err(RusticolError::compatibility(
+                "eager-direct-arena-v1 requires the f64-compiled or f64-symjit feature; regenerate or load \
+                 this artifact with a Direct-Arena-capable runtime",
+            ))
+        }
+    }
+
+    fn execute_profile_scheduler(
+        &mut self,
+        active_groups: Option<&[u32]>,
+        point_count: usize,
+    ) -> RusticolResult<crate::eager_runtime::EagerExecutionProfile> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            let scheduler = self.direct_scheduler.as_mut().ok_or_else(|| {
+                RusticolError::internal("production eager runtime has no Direct-Arena scheduler")
+            })?;
+            if let Some(active_groups) = active_groups {
+                scheduler.evaluate_selected_profile_into(
+                    active_groups,
+                    point_count,
+                    &self.initial_values,
+                    &self.momenta,
+                    &self.model_parameters,
+                    &mut self.amplitudes,
+                )
+            } else {
+                scheduler.evaluate_profile_into(
+                    point_count,
+                    &self.initial_values,
+                    &self.momenta,
+                    &self.model_parameters,
+                    &mut self.amplitudes,
+                    &mut self.reduced,
+                )
+            }
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            let _ = (active_groups, point_count);
+            Err(RusticolError::compatibility(
+                "eager-direct-arena-v1 requires the f64-compiled or f64-symjit feature; regenerate or load \
+                 this artifact with a Direct-Arena-capable runtime",
+            ))
+        }
+    }
+
+    fn direct_internal_scratch_bytes(&self) -> u64 {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            self.direct_scheduler
+                .as_ref()
+                .map_or(0, |scheduler| scheduler.internal_scratch_bytes())
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            0
+        }
+    }
+
+    fn direct_internal_broadcast_bytes(&self) -> u64 {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            self.direct_scheduler
+                .as_ref()
+                .map_or(0, |scheduler| scheduler.internal_broadcast_bytes())
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            0
+        }
+    }
+
+    pub(super) fn backend_name(&self) -> &str {
+        &self.backend_name
+    }
+
+    pub(super) fn effective_point_tile_size(&self) -> usize {
+        self.effective_point_tile_size
+    }
+
+    pub(super) fn workspace_bytes(&self) -> usize {
+        self.workspace_bytes
+    }
+
+    /// Execute the warmed eager Direct-Arena lane from a borrowed flat input.
+    ///
+    /// This is the ordinary native timing boundary: it performs no phase
+    /// clocks, nested momentum materialization, resolved-value construction,
+    /// or result allocation.
+    pub(super) fn run_f64_view_into_unprofiled(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let point_count = batch.point_count();
+        if output.len() != point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager evaluation output has length {}, expected {point_count}",
+                output.len()
+            )));
+        }
+        if common.color_topology_replay_enabled {
+            return self.run_f64_view_with_color_topology_replay_into_unprofiled(
+                common, batch, None, None, output,
+            );
+        }
+        if common.lc_topology_replay_enabled {
+            return self.run_f64_view_with_lc_topology_replay_into_unprofiled(
+                common, batch, None, None, output,
+            );
+        }
+        prepare_eager_inputs_view(
+            common,
+            batch,
+            &mut self.initial_values,
+            &mut self.momenta,
+            &mut self.source_schedule,
+            &mut self.source_wavefunction_scratch,
+        )?;
+        project_model_parameters(
+            &self.parameter_projection,
+            &common.model_parameter_values_f64,
+            &mut self.model_parameters,
+        )?;
+        self.reduced.resize(point_count, 0.0);
+        self.execute_full_totals_scheduler(point_count)?;
+        for (target, value) in output.iter_mut().zip(&self.reduced) {
+            *target = common.normalization_factor * *value;
+        }
+        Ok(())
+    }
+
+    /// Execute public global selectors directly into caller-sized totals.
+    ///
+    /// The selector weights feed the plane-native eager reducer, so LC,
+    /// compact NLC, and full-colour contractions avoid materializing the
+    /// resolved `(point, helicity, colour)` tensor.
+    pub(super) fn run_f64_view_selected_into_unprofiled(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let point_count = batch.point_count();
+        if output.len() != point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager evaluation output has length {}, expected {point_count}",
+                output.len()
+            )));
+        }
+        if selected_helicity_ids.is_none() && selected_color_ids.is_none() {
+            return self.run_f64_view_into_unprofiled(common, batch, output);
+        }
+        if common.color_topology_replay_enabled {
+            return self.run_f64_view_with_color_topology_replay_into_unprofiled(
+                common,
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                output,
+            );
+        }
+        if common.lc_topology_replay_enabled {
+            return self.run_f64_view_with_lc_topology_replay_into_unprofiled(
+                common,
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                output,
+            );
+        }
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("selected eager evaluation requires physics metadata")
+        })?;
+        if self.point_selector_members.is_none() {
+            self.point_selector_members = Some(build_eager_selector_members(
+                &self.raw_sum_groups,
+                self.color_contraction.is_some(),
+                &physics,
+            )?);
+        }
+        fill_eager_group_sets_by_point(
+            &self.raw_sum_groups,
+            self.point_selector_members
+                .as_deref()
+                .expect("selector members initialized"),
+            &physics,
+            point_count,
+            selected_helicity_ids,
+            selected_color_ids,
+            None,
+            None,
+            &mut self.point_selector_offsets,
+            &mut self.point_selector_groups,
+            &mut self.point_selector_group_weights,
+            &mut self.point_selector_pairs,
+            &mut self.selected_helicity_indices,
+            &mut self.selected_color_indices,
+        )?;
+        prepare_eager_inputs_view(
+            common,
+            batch,
+            &mut self.initial_values,
+            &mut self.momenta,
+            &mut self.source_schedule,
+            &mut self.source_wavefunction_scratch,
+        )?;
+        project_model_parameters(
+            &self.parameter_projection,
+            &common.model_parameter_values_f64,
+            &mut self.model_parameters,
+        )?;
+
+        // Keep caller output untouched if validation or execution fails.
+        let offsets = std::mem::take(&mut self.point_selector_offsets);
+        let groups = std::mem::take(&mut self.point_selector_groups);
+        let group_weights = std::mem::take(&mut self.point_selector_group_weights);
+        let mut reduced = std::mem::take(&mut self.reduced);
+        reduced.resize(point_count, 0.0);
+        let result = self.execute_point_selected_scheduler(
+            &offsets,
+            &groups,
+            &group_weights,
+            point_count,
+            &mut reduced,
+        );
+        self.point_selector_offsets = offsets;
+        self.point_selector_groups = groups;
+        self.point_selector_group_weights = group_weights;
+        self.reduced = reduced;
+        result?;
+        for (target, value) in output.iter_mut().zip(&self.reduced) {
+            *target = common.normalization_factor * *value;
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn run_resolved_f64_view_materialized_into_unprofiled(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut Vec<f64>,
+    ) -> RusticolResult<()> {
+        let point_count = batch.point_count();
+        prepare_eager_inputs_view(
+            common,
+            batch,
+            &mut self.initial_values,
+            &mut self.momenta,
+            &mut self.source_schedule,
+            &mut self.source_wavefunction_scratch,
+        )?;
+        project_model_parameters(
+            &self.parameter_projection,
+            &common.model_parameter_values_f64,
+            &mut self.model_parameters,
+        )?;
+        let amplitude_len = point_count
+            .checked_mul(self.amplitude_count)
+            .ok_or_else(|| RusticolError::invalid_argument("eager amplitudes overflow"))?;
+        self.amplitudes
+            .resize(amplitude_len, crate::EagerComplex64::new(0.0, 0.0));
+        self.reduced.resize(point_count, 0.0);
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("resolved eager evaluation requires physics metadata")
+        })?;
+        let has_selected_groups = if self.has_selector_domains
+            && (selected_helicity_ids.is_some() || selected_color_ids.is_some())
+        {
+            fill_selected_eager_group_ids(
+                &self.raw_sum_groups,
+                &physics,
+                selected_helicity_ids,
+                selected_color_ids,
+                &mut self.selected_groups,
+            )?;
+            true
+        } else {
+            false
+        };
+        if has_selected_groups {
+            let selected_groups = std::mem::take(&mut self.selected_groups);
+            let result = self.execute_selected_scheduler(&selected_groups, point_count);
+            self.selected_groups = selected_groups;
+            result?;
+        } else {
+            self.execute_full_scheduler(point_count)?;
+        }
+        reduce_eager_amplitudes_resolved_into(
+            &self.amplitudes,
+            point_count,
+            &self.raw_sum_groups,
+            self.color_contraction.as_mut(),
+            &mut self.color_group_scratch,
+            &physics,
+            common.normalization_factor,
+            selected_helicity_ids,
+            selected_color_ids,
+            output,
+            &mut self.selected_helicity_indices,
+            &mut self.selected_color_indices,
+            &mut self.helicity_position_scratch,
+            &mut self.color_position_scratch,
+            &mut self.helicity_weights_scratch,
+            &mut self.right_helicity_weights_scratch,
+            &mut self.member_weights_scratch,
+        )
+    }
+
+    /// Resolve eager components directly from a borrowed momentum view.
+    ///
+    /// The returned value and public-axis vectors are the only result-owned
+    /// allocations. Input crossing, eager source preparation, and topology
+    /// replay all consume the borrowed flat view without constructing nested
+    /// point or momentum containers.
+    pub(super) fn run_resolved_f64_view_unprofiled(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let point_count = batch.point_count();
+        let mut values = Vec::new();
+        if common.color_topology_replay_enabled {
+            return self.run_resolved_f64_view_with_color_topology_replay_unprofiled(
+                common,
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        if common.lc_topology_replay_enabled {
+            let selection = self.run_resolved_f64_view_with_lc_topology_replay_into_unprofiled(
+                common,
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                &mut values,
+            )?;
+            return Ok(ResolvedValues {
+                values,
+                point_count,
+                helicity_indices: selection.helicity_indices.clone(),
+                color_indices: selection.color_indices.clone(),
+            });
+        }
+        self.run_resolved_f64_view_materialized_into_unprofiled(
+            common,
+            batch,
+            selected_helicity_ids,
+            selected_color_ids,
+            &mut values,
+        )?;
+        Ok(ResolvedValues {
+            values,
+            point_count,
+            helicity_indices: self.selected_helicity_indices.clone(),
+            color_indices: self.selected_color_indices.clone(),
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn run_f64_view_with_color_topology_replay_into_unprofiled(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let resolved = self.run_resolved_f64_view_with_color_topology_replay_unprofiled(
+            common,
+            batch,
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        if output.len() != resolved.point_count {
+            return Err(RusticolError::invalid_argument(
+                "eager color replay output has an invalid point count",
+            ));
+        }
+        let component_count = resolved.helicity_indices.len() * resolved.color_indices.len();
+        if component_count == 0 {
+            output.fill(0.0);
+        } else {
+            for (target, components) in output
+                .iter_mut()
+                .zip(resolved.values.chunks_exact(component_count))
+            {
+                *target = components.iter().sum();
+            }
+        }
+        Ok(())
+    }
+
+    fn run_resolved_f64_view_with_color_topology_replay_unprofiled(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let point_count = batch.point_count();
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact(
+                "eager color topology replay requires resolved physics metadata",
+            )
+        })?;
+        let mappings = Arc::clone(&common.color_topology_replay_mappings);
+        let mut replay = self.color_topology_replay.take().ok_or_else(|| {
+            RusticolError::integrity("eager color topology replay has no amplitude gather runtime")
+        })?;
+        let mut flat_momenta = std::mem::take(&mut self.lc_replay_flat_momenta);
+        let result = (|| {
+            replay.begin_color_topology_replay(point_count)?;
+            for mapping_index in 0..mappings.len() {
+                let evaluation_view = if mappings[mapping_index].is_empty() {
+                    batch
+                } else {
+                    fill_lc_replay_expanded_flat_from_view(
+                        &mut flat_momenta,
+                        batch,
+                        common.external_count,
+                        &[mapping_index],
+                        &mappings,
+                    )?;
+                    F64MomentumBatchView::from_contiguous_prevalidated(
+                        &flat_momenta,
+                        point_count,
+                        common.external_count,
+                        None,
+                    )?
+                };
+                prepare_eager_inputs_view(
+                    common,
+                    evaluation_view,
+                    &mut self.initial_values,
+                    &mut self.momenta,
+                    &mut self.source_schedule,
+                    &mut self.source_wavefunction_scratch,
+                )?;
+                project_model_parameters(
+                    &self.parameter_projection,
+                    &common.model_parameter_values_f64,
+                    &mut self.model_parameters,
+                )?;
+                self.amplitudes.resize(
+                    point_count
+                        .checked_mul(self.amplitude_count)
+                        .ok_or_else(|| {
+                            RusticolError::invalid_argument(
+                                "eager color replay amplitudes overflow",
+                            )
+                        })?,
+                    crate::EagerComplex64::new(0.0, 0.0),
+                );
+                self.reduced.resize(point_count, 0.0);
+                self.execute_full_scheduler(point_count)?;
+                replay.gather_color_topology_replay_eager_amplitudes(
+                    &self.amplitudes,
+                    point_count,
+                    mapping_index,
+                )?;
+            }
+            replay.reduce_color_topology_replay_f64_resolved(
+                point_count,
+                &physics,
+                common.normalization_factor,
+                selected_helicity_ids,
+                selected_color_ids,
+            )
+        })();
+        self.lc_replay_flat_momenta = flat_momenta;
+        self.color_topology_replay = Some(replay);
+        result
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn run_resolved_f64_view_with_lc_topology_replay_into_unprofiled(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut Vec<f64>,
+    ) -> RusticolResult<Arc<LcResolvedReplaySelection>> {
+        let point_count = batch.point_count();
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("eager LC topology replay requires resolved physics metadata")
+        })?;
+        let replay_plan = if let Some(plan) = &self.lc_resolved_replay_plan {
+            Arc::clone(plan)
+        } else {
+            let materialized_sector_by_id =
+                common.lc_materialized_sectors_by_id_from_groups(&physics, &self.raw_sum_groups)?;
+            let plan = Arc::new(physics.lc_resolved_replay_plan(
+                &common.lc_topology_replay_public_mappings,
+                &common.lc_topology_replay_routes,
+                &materialized_sector_by_id,
+            )?);
+            self.lc_resolved_replay_plan = Some(Arc::clone(&plan));
+            plan
+        };
+        let selection = if let Some((_, selection)) = self
+            .lc_resolved_replay_selection_cache
+            .iter()
+            .find(|(key, _)| {
+                lc_replay_selection_key_matches(
+                    key,
+                    &physics,
+                    selected_helicity_ids,
+                    selected_color_ids,
+                )
+            }) {
+            Arc::clone(selection)
+        } else {
+            let selection_key = physics
+                .lc_resolved_replay_selection_key(selected_helicity_ids, selected_color_ids)?;
+            let selection = Arc::new(
+                physics
+                    .select_lc_resolved_replay_plan_for_key(replay_plan.as_ref(), &selection_key)?,
+            );
+            self.lc_resolved_replay_selection_cache
+                .push((selection_key, Arc::clone(&selection)));
+            selection
+        };
+        let target_component_count = selection
+            .helicity_indices
+            .len()
+            .checked_mul(selection.color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved eager shape overflows"))?;
+        let target_scalar_count = point_count
+            .checked_mul(target_component_count)
+            .ok_or_else(|| RusticolError::invalid_argument("resolved eager shape overflows"))?;
+        output.resize(target_scalar_count, 0.0);
+        output.fill(0.0);
+        if target_component_count == 0 {
+            return Ok(selection);
+        }
+
+        let mappings = Arc::clone(&common.lc_topology_replay_mappings);
+        let mappings_per_chunk = replay_mappings_per_expanded_batch(point_count);
+        let mut flat_momenta = std::mem::take(&mut self.lc_replay_flat_momenta);
+        let mut materialized_values = std::mem::take(&mut self.lc_replay_materialized_values);
+        let result = (|| {
+            for source_group in &selection.source_groups {
+                for chunk_start in
+                    (0..source_group.mapping_indices.len()).step_by(mappings_per_chunk)
+                {
+                    let chunk_end = usize::min(
+                        chunk_start + mappings_per_chunk,
+                        source_group.mapping_indices.len(),
+                    );
+                    let mapping_indices = &source_group.mapping_indices[chunk_start..chunk_end];
+                    let entry_chunk = &source_group.entries[chunk_start..chunk_end];
+                    let identity_mapping =
+                        mapping_indices.len() == 1 && mappings[mapping_indices[0]].is_empty();
+                    let evaluation_view = if identity_mapping {
+                        batch
+                    } else {
+                        fill_lc_replay_expanded_flat_from_view(
+                            &mut flat_momenta,
+                            batch,
+                            common.external_count,
+                            mapping_indices,
+                            &mappings,
+                        )?;
+                        F64MomentumBatchView::from_contiguous_prevalidated(
+                            &flat_momenta,
+                            point_count * mapping_indices.len(),
+                            common.external_count,
+                            None,
+                        )?
+                    };
+                    self.run_resolved_f64_view_materialized_into_unprofiled(
+                        common,
+                        evaluation_view,
+                        Some(&source_group.helicity_ids),
+                        Some(&source_group.color_ids),
+                        &mut materialized_values,
+                    )?;
+                    accumulate_selected_lc_replay_values_f64(
+                        output,
+                        point_count,
+                        &materialized_values,
+                        entry_chunk,
+                        source_group.source_component_count,
+                        target_component_count,
+                    )?;
+                }
+            }
+            Ok(())
+        })();
+        self.lc_replay_flat_momenta = flat_momenta;
+        self.lc_replay_materialized_values = materialized_values;
+        result?;
+        Ok(selection)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn run_f64_view_with_lc_topology_replay_into_unprofiled(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let point_count = batch.point_count();
+        if output.len() != point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager topology-replay output has length {}, expected {point_count}",
+                output.len()
+            )));
+        }
+        let mut target_components = std::mem::take(&mut self.lc_replay_target_components);
+        let result = self.run_resolved_f64_view_with_lc_topology_replay_into_unprofiled(
+            common,
+            batch,
+            selected_helicity_ids,
+            selected_color_ids,
+            &mut target_components,
+        );
+        if let Ok(selection) = &result {
+            let target_component_count =
+                selection.helicity_indices.len() * selection.color_indices.len();
+            if target_component_count == 0 {
+                output.fill(0.0);
+            } else {
+                for (target, components) in output
+                    .iter_mut()
+                    .zip(target_components.chunks_exact(target_component_count))
+                {
+                    *target = components.iter().sum();
+                }
+            }
+        }
+        self.lc_replay_target_components = target_components;
+        result.map(|_| ())
+    }
+
+    #[allow(dead_code)] // Retained as the row-major eager benchmark oracle.
+    pub(super) fn run_f64(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        if common.color_topology_replay_enabled {
+            let (resolved, profile) =
+                self.run_resolved_f64_with_color_topology_replay(common, batch, None, None, false)?;
+            return Ok((sum_eager_resolved(&resolved), profile));
+        }
+        if common.lc_topology_replay_enabled {
+            let (resolved, profile) =
+                self.run_resolved_f64_with_lc_topology_replay(common, batch, None, None, false)?;
+            return Ok((sum_eager_resolved(&resolved), profile));
+        }
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "eager evaluation requires at least one point",
+            ));
+        }
+        let total_start = Instant::now();
+        let point_count = batch.len();
+        let (source_fill, momentum_setup) = prepare_eager_inputs(
+            common,
+            batch,
+            &mut self.initial_values,
+            &mut self.momenta,
+            &mut self.source_schedule,
+            &mut self.source_wavefunction_scratch,
+        )?;
+        project_model_parameters(
+            &self.parameter_projection,
+            &common.model_parameter_values_f64,
+            &mut self.model_parameters,
+        )?;
+        let amplitude_len = point_count
+            .checked_mul(self.amplitude_count)
+            .ok_or_else(|| RusticolError::invalid_argument("eager amplitudes overflow"))?;
+        self.amplitudes
+            .resize(amplitude_len, crate::EagerComplex64::new(0.0, 0.0));
+        self.reduced.resize(point_count, 0.0);
+
+        let execute_start = Instant::now();
+        self.execute_full_scheduler(point_count)?;
+        let execute_s = execute_start.elapsed().as_secs_f64();
+        for value in &mut self.reduced {
+            *value *= common.normalization_factor;
+        }
+        let values = self.reduced.clone();
+        Ok((
+            values,
+            RuntimeProfile {
+                source_fill_s: profile_duration_seconds(source_fill),
+                momentum_input_setup_s: profile_duration_seconds(momentum_setup),
+                momentum_setup_s: profile_duration_seconds(momentum_setup),
+                stage_evaluator_call_s: execute_s,
+                stage_evaluator_s: execute_s,
+                total_s: total_start.elapsed().as_secs_f64(),
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    #[allow(dead_code)] // Retained as the order-preserving benchmark reference lane.
+    pub(super) fn run_f64_by_point_selectors(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        helicity_by_point: Option<&[u32]>,
+        color_by_point: Option<&[u32]>,
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        if common.lc_topology_replay_enabled || common.color_topology_replay_enabled {
+            return Err(RusticolError::integrity(
+                "eager topology-replay per-point selectors must use the shared partition planner",
+            ));
+        }
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("per-point eager selection requires physics metadata")
+        })?;
+        if self.point_selector_members.is_none() {
+            self.point_selector_members = Some(build_eager_selector_members(
+                &self.raw_sum_groups,
+                self.color_contraction.is_some(),
+                &physics,
+            )?);
+        }
+        fill_eager_group_sets_by_point(
+            &self.raw_sum_groups,
+            self.point_selector_members
+                .as_deref()
+                .expect("selector members initialized"),
+            &physics,
+            batch.len(),
+            selected_helicity_ids,
+            selected_color_ids,
+            helicity_by_point,
+            color_by_point,
+            &mut self.point_selector_offsets,
+            &mut self.point_selector_groups,
+            &mut self.point_selector_group_weights,
+            &mut self.point_selector_pairs,
+            &mut self.selected_helicity_indices,
+            &mut self.selected_color_indices,
+        )?;
+        let offsets = std::mem::take(&mut self.point_selector_offsets);
+        let groups = std::mem::take(&mut self.point_selector_groups);
+        let group_weights = std::mem::take(&mut self.point_selector_group_weights);
+        let mut reduced = std::mem::take(&mut self.reduced);
+        reduced.resize(batch.len(), 0.0);
+        let result = self.run_coherent_group_sets_by_point_f64_into(
+            common,
+            batch,
+            &offsets,
+            &groups,
+            &group_weights,
+            &mut reduced,
+        );
+        self.point_selector_offsets = offsets;
+        self.point_selector_groups = groups;
+        self.point_selector_group_weights = group_weights;
+        self.reduced = reduced;
+        let profile = result?;
+        Ok((self.reduced.clone(), profile))
+    }
+
+    #[allow(dead_code)] // Retained as the order-preserving benchmark reference lane.
+    pub(super) fn run_coherent_group_sets_by_point_f64_into(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        group_offsets: &[usize],
+        active_groups: &[u32],
+        active_group_weights: &[f64],
+        reduced: &mut [f64],
+    ) -> RusticolResult<RuntimeProfile> {
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "eager evaluation requires at least one point",
+            ));
+        }
+        if reduced.len() != batch.len() {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager per-point selector output has length {}, expected {}",
+                reduced.len(),
+                batch.len()
+            )));
+        }
+        let total_start = Instant::now();
+        let point_count = batch.len();
+        let (source_fill, momentum_setup) = prepare_eager_inputs(
+            common,
+            batch,
+            &mut self.initial_values,
+            &mut self.momenta,
+            &mut self.source_schedule,
+            &mut self.source_wavefunction_scratch,
+        )?;
+        project_model_parameters(
+            &self.parameter_projection,
+            &common.model_parameter_values_f64,
+            &mut self.model_parameters,
+        )?;
+        let execute_start = Instant::now();
+        self.execute_point_selected_scheduler(
+            group_offsets,
+            active_groups,
+            active_group_weights,
+            point_count,
+            reduced,
+        )?;
+        let execute_s = execute_start.elapsed().as_secs_f64();
+        for value in reduced {
+            *value *= common.normalization_factor;
+        }
+        Ok(RuntimeProfile {
+            source_fill_s: profile_duration_seconds(source_fill),
+            momentum_input_setup_s: profile_duration_seconds(momentum_setup),
+            momentum_setup_s: profile_duration_seconds(momentum_setup),
+            stage_evaluator_call_s: execute_s,
+            stage_evaluator_s: execute_s,
+            total_s: total_start.elapsed().as_secs_f64(),
+            ..RuntimeProfile::default()
+        })
+    }
+
+    pub(super) fn run_f64_profile(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        if common.color_topology_replay_enabled {
+            let (resolved, profile) =
+                self.run_resolved_f64_with_color_topology_replay(common, batch, None, None, true)?;
+            return Ok((sum_eager_resolved(&resolved), profile));
+        }
+        if common.lc_topology_replay_enabled {
+            let (resolved, profile) =
+                self.run_resolved_f64_with_lc_topology_replay(common, batch, None, None, true)?;
+            return Ok((sum_eager_resolved(&resolved), profile));
+        }
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "eager evaluation requires at least one point",
+            ));
+        }
+        let total_start = Instant::now();
+        let point_count = batch.len();
+        let (source_fill, momentum_setup) = prepare_eager_inputs(
+            common,
+            batch,
+            &mut self.initial_values,
+            &mut self.momenta,
+            &mut self.source_schedule,
+            &mut self.source_wavefunction_scratch,
+        )?;
+        project_model_parameters(
+            &self.parameter_projection,
+            &common.model_parameter_values_f64,
+            &mut self.model_parameters,
+        )?;
+        let amplitude_len = point_count
+            .checked_mul(self.amplitude_count)
+            .ok_or_else(|| RusticolError::invalid_argument("eager amplitudes overflow"))?;
+        self.amplitudes
+            .resize(amplitude_len, crate::EagerComplex64::new(0.0, 0.0));
+        self.reduced.resize(point_count, 0.0);
+
+        let eager = self.execute_profile_scheduler(None, point_count)?;
+        validate_eager_profile_accounting(&eager)?;
+        for value in &mut self.reduced {
+            *value *= common.normalization_factor;
+        }
+        let values = self.reduced.clone();
+        Ok((
+            values,
+            RuntimeProfile {
+                source_fill_s: profile_duration_seconds(source_fill),
+                momentum_input_setup_s: profile_duration_seconds(momentum_setup),
+                momentum_setup_s: profile_duration_seconds(momentum_setup),
+                stage_evaluator_call_s: eager.total.as_secs_f64(),
+                stage_evaluator_s: eager.total.as_secs_f64(),
+                reduction_s: eager.reduction.as_secs_f64(),
+                total_s: total_start.elapsed().as_secs_f64(),
+                eager_initialize_s: eager.initialize.as_secs_f64(),
+                eager_gather_s: eager.gather.as_secs_f64(),
+                eager_kernel_call_s: eager.kernel_call.as_secs_f64(),
+                eager_invocation_scatter_s: eager.invocation_scatter.as_secs_f64(),
+                eager_finalization_s: eager.finalization.as_secs_f64(),
+                eager_scatter_finalization_s: (eager.invocation_scatter + eager.finalization)
+                    .as_secs_f64(),
+                eager_closure_s: eager.closure.as_secs_f64(),
+                eager_reduction_s: eager.reduction.as_secs_f64(),
+                eager_copy_out_s: eager.copy_out.as_secs_f64(),
+                eager_internal_scratch_bytes: eager.internal_scratch_bytes,
+                eager_internal_broadcast_bytes: eager.internal_broadcast_bytes,
+                evaluator_backend_call_count: eager.backend_call_count,
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+
+    #[allow(dead_code)] // Retained as the row-major eager resolved-value oracle.
+    pub(super) fn run_resolved_f64(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        if common.color_topology_replay_enabled {
+            return self.run_resolved_f64_with_color_topology_replay(
+                common,
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                false,
+            );
+        }
+        if common.lc_topology_replay_enabled {
+            return self.run_resolved_f64_with_lc_topology_replay(
+                common,
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                false,
+            );
+        }
+        self.run_resolved_f64_materialized(common, batch, selected_helicity_ids, selected_color_ids)
+    }
+
+    fn run_resolved_f64_materialized(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "eager evaluation requires at least one point",
+            ));
+        }
+        let total_start = Instant::now();
+        let point_count = batch.len();
+        let (source_fill, momentum_setup) = prepare_eager_inputs(
+            common,
+            batch,
+            &mut self.initial_values,
+            &mut self.momenta,
+            &mut self.source_schedule,
+            &mut self.source_wavefunction_scratch,
+        )?;
+        project_model_parameters(
+            &self.parameter_projection,
+            &common.model_parameter_values_f64,
+            &mut self.model_parameters,
+        )?;
+        let amplitude_len = point_count
+            .checked_mul(self.amplitude_count)
+            .ok_or_else(|| RusticolError::invalid_argument("eager amplitudes overflow"))?;
+        self.amplitudes
+            .resize(amplitude_len, crate::EagerComplex64::new(0.0, 0.0));
+        self.reduced.resize(point_count, 0.0);
+
+        let physics = common.physics.as_ref().ok_or_else(|| {
+            RusticolError::artifact("resolved eager evaluation requires physics metadata")
+        })?;
+        let has_selected_groups = if self.has_selector_domains
+            && (selected_helicity_ids.is_some() || selected_color_ids.is_some())
+        {
+            fill_selected_eager_group_ids(
+                &self.raw_sum_groups,
+                physics,
+                selected_helicity_ids,
+                selected_color_ids,
+                &mut self.selected_groups,
+            )?;
+            true
+        } else {
+            false
+        };
+        let execute_start = Instant::now();
+        if has_selected_groups {
+            let selected_groups = std::mem::take(&mut self.selected_groups);
+            let result = self.execute_selected_scheduler(&selected_groups, point_count);
+            self.selected_groups = selected_groups;
+            result?;
+        } else {
+            self.execute_full_scheduler(point_count)?;
+        }
+        let execute_s = execute_start.elapsed().as_secs_f64();
+        let reduction_start = Instant::now();
+        let resolved = reduce_eager_amplitudes_resolved(
+            &self.amplitudes,
+            point_count,
+            &self.raw_sum_groups,
+            self.color_contraction.as_mut(),
+            &mut self.color_group_scratch,
+            physics,
+            common.normalization_factor,
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        let reduction_s = reduction_start.elapsed().as_secs_f64();
+        Ok((
+            resolved,
+            RuntimeProfile {
+                source_fill_s: profile_duration_seconds(source_fill),
+                momentum_input_setup_s: profile_duration_seconds(momentum_setup),
+                momentum_setup_s: profile_duration_seconds(momentum_setup),
+                stage_evaluator_call_s: execute_s,
+                stage_evaluator_s: execute_s,
+                reduction_s,
+                total_s: total_start.elapsed().as_secs_f64(),
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+
+    pub(super) fn run_resolved_f64_profile(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        if common.color_topology_replay_enabled {
+            return self.run_resolved_f64_with_color_topology_replay(
+                common,
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                true,
+            );
+        }
+        if common.lc_topology_replay_enabled {
+            return self.run_resolved_f64_with_lc_topology_replay(
+                common,
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                true,
+            );
+        }
+        self.run_resolved_f64_profile_materialized(
+            common,
+            batch,
+            selected_helicity_ids,
+            selected_color_ids,
+        )
+    }
+
+    fn run_resolved_f64_profile_materialized(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "eager evaluation requires at least one point",
+            ));
+        }
+        let total_start = Instant::now();
+        let point_count = batch.len();
+        let (source_fill, momentum_setup) = prepare_eager_inputs(
+            common,
+            batch,
+            &mut self.initial_values,
+            &mut self.momenta,
+            &mut self.source_schedule,
+            &mut self.source_wavefunction_scratch,
+        )?;
+        project_model_parameters(
+            &self.parameter_projection,
+            &common.model_parameter_values_f64,
+            &mut self.model_parameters,
+        )?;
+        let amplitude_len = point_count
+            .checked_mul(self.amplitude_count)
+            .ok_or_else(|| RusticolError::invalid_argument("eager amplitudes overflow"))?;
+        self.amplitudes
+            .resize(amplitude_len, crate::EagerComplex64::new(0.0, 0.0));
+        self.reduced.resize(point_count, 0.0);
+
+        let physics = common.physics.as_ref().ok_or_else(|| {
+            RusticolError::artifact("resolved eager evaluation requires physics metadata")
+        })?;
+        let has_selected_groups = if self.has_selector_domains
+            && (selected_helicity_ids.is_some() || selected_color_ids.is_some())
+        {
+            fill_selected_eager_group_ids(
+                &self.raw_sum_groups,
+                physics,
+                selected_helicity_ids,
+                selected_color_ids,
+                &mut self.selected_groups,
+            )?;
+            true
+        } else {
+            false
+        };
+        let eager = if has_selected_groups {
+            let selected_groups = std::mem::take(&mut self.selected_groups);
+            let result = self.execute_profile_scheduler(Some(&selected_groups), point_count);
+            self.selected_groups = selected_groups;
+            result?
+        } else {
+            self.execute_profile_scheduler(None, point_count)?
+        };
+        validate_eager_profile_accounting(&eager)?;
+        let reduction_start = Instant::now();
+        let resolved = reduce_eager_amplitudes_resolved(
+            &self.amplitudes,
+            point_count,
+            &self.raw_sum_groups,
+            self.color_contraction.as_mut(),
+            &mut self.color_group_scratch,
+            physics,
+            common.normalization_factor,
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        let resolved_reduction = reduction_start.elapsed();
+        let eager_execution = eager.total + resolved_reduction;
+        let reduction = eager.reduction + resolved_reduction;
+        Ok((
+            resolved,
+            RuntimeProfile {
+                source_fill_s: profile_duration_seconds(source_fill),
+                momentum_input_setup_s: profile_duration_seconds(momentum_setup),
+                momentum_setup_s: profile_duration_seconds(momentum_setup),
+                stage_evaluator_call_s: eager_execution.as_secs_f64(),
+                stage_evaluator_s: eager_execution.as_secs_f64(),
+                reduction_s: reduction.as_secs_f64(),
+                total_s: total_start.elapsed().as_secs_f64(),
+                eager_initialize_s: eager.initialize.as_secs_f64(),
+                eager_gather_s: eager.gather.as_secs_f64(),
+                eager_kernel_call_s: eager.kernel_call.as_secs_f64(),
+                eager_invocation_scatter_s: eager.invocation_scatter.as_secs_f64(),
+                eager_finalization_s: eager.finalization.as_secs_f64(),
+                eager_scatter_finalization_s: (eager.invocation_scatter + eager.finalization)
+                    .as_secs_f64(),
+                eager_closure_s: eager.closure.as_secs_f64(),
+                eager_reduction_s: reduction.as_secs_f64(),
+                eager_copy_out_s: eager.copy_out.as_secs_f64(),
+                eager_internal_scratch_bytes: eager.internal_scratch_bytes,
+                eager_internal_broadcast_bytes: eager.internal_broadcast_bytes,
+                evaluator_backend_call_count: eager.backend_call_count,
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn run_resolved_f64_with_color_topology_replay(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        _profiled: bool,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "eager color topology replay requires at least one point",
+            ));
+        }
+        let total_start = Instant::now();
+        let eager_internal_scratch_before = self.direct_internal_scratch_bytes();
+        let eager_internal_broadcast_before = self.direct_internal_broadcast_bytes();
+        let point_count = batch.len();
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact(
+                "eager color topology replay requires resolved physics metadata",
+            )
+        })?;
+        let mappings = Arc::clone(&common.color_topology_replay_mappings);
+        let mut replay = self.color_topology_replay.take().ok_or_else(|| {
+            RusticolError::integrity("eager color topology replay has no amplitude gather runtime")
+        })?;
+        let mut expanded_batch = std::mem::take(&mut self.lc_replay_expanded_batch);
+        let mut seen_labels = std::mem::take(&mut self.lc_replay_seen_labels);
+        let result = (|| {
+            replay.begin_color_topology_replay(point_count)?;
+            let mut source_fill_s = 0.0;
+            let mut momentum_setup_s = 0.0;
+            let mut evaluator_s = 0.0;
+            for mapping_index in 0..mappings.len() {
+                let evaluation_batch = if mappings[mapping_index].is_empty() {
+                    batch
+                } else {
+                    let expanded_len = fill_lc_replay_expanded_batch(
+                        &mut expanded_batch,
+                        &mut seen_labels,
+                        batch,
+                        common.external_count,
+                        &[mapping_index],
+                        &mappings,
+                    )?;
+                    &expanded_batch[..expanded_len]
+                };
+                let (source_fill, momentum_setup) = prepare_eager_inputs(
+                    common,
+                    evaluation_batch,
+                    &mut self.initial_values,
+                    &mut self.momenta,
+                    &mut self.source_schedule,
+                    &mut self.source_wavefunction_scratch,
+                )?;
+                source_fill_s += profile_duration_seconds(source_fill);
+                momentum_setup_s += profile_duration_seconds(momentum_setup);
+                project_model_parameters(
+                    &self.parameter_projection,
+                    &common.model_parameter_values_f64,
+                    &mut self.model_parameters,
+                )?;
+                self.amplitudes.resize(
+                    point_count
+                        .checked_mul(self.amplitude_count)
+                        .ok_or_else(|| {
+                            RusticolError::invalid_argument(
+                                "eager color replay amplitudes overflow",
+                            )
+                        })?,
+                    crate::EagerComplex64::new(0.0, 0.0),
+                );
+                self.reduced.resize(point_count, 0.0);
+                let evaluator_start = Instant::now();
+                self.execute_full_scheduler(point_count)?;
+                evaluator_s += evaluator_start.elapsed().as_secs_f64();
+                replay.gather_color_topology_replay_eager_amplitudes(
+                    &self.amplitudes,
+                    point_count,
+                    mapping_index,
+                )?;
+            }
+            let reduction_start = Instant::now();
+            let resolved = replay.reduce_color_topology_replay_f64_resolved(
+                point_count,
+                &physics,
+                common.normalization_factor,
+                selected_helicity_ids,
+                selected_color_ids,
+            )?;
+            let reduction_s = reduction_start.elapsed().as_secs_f64();
+            let eager_internal_scratch_bytes = self
+                .direct_internal_scratch_bytes()
+                .saturating_sub(eager_internal_scratch_before);
+            let eager_internal_broadcast_bytes = self
+                .direct_internal_broadcast_bytes()
+                .saturating_sub(eager_internal_broadcast_before);
+            Ok((
+                resolved,
+                RuntimeProfile {
+                    source_fill_s,
+                    momentum_input_setup_s: momentum_setup_s,
+                    momentum_setup_s,
+                    stage_evaluator_call_s: evaluator_s,
+                    stage_evaluator_s: evaluator_s,
+                    reduction_s,
+                    eager_reduction_s: reduction_s,
+                    eager_internal_scratch_bytes,
+                    eager_internal_broadcast_bytes,
+                    total_s: total_start.elapsed().as_secs_f64(),
+                    evaluator_backend_call_count: u64::try_from(mappings.len()).map_err(|_| {
+                        RusticolError::invalid_argument(
+                            "eager color replay mapping count exceeds u64",
+                        )
+                    })?,
+                    ..RuntimeProfile::default()
+                },
+            ))
+        })();
+        self.lc_replay_expanded_batch = expanded_batch;
+        self.lc_replay_seen_labels = seen_labels;
+        self.color_topology_replay = Some(replay);
+        result
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn run_resolved_f64_with_lc_topology_replay(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        profiled: bool,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "eager evaluation requires at least one point",
+            ));
+        }
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("eager LC topology replay requires resolved physics metadata")
+        })?;
+        let replay_plan = if let Some(plan) = &self.lc_resolved_replay_plan {
+            Arc::clone(plan)
+        } else {
+            let materialized_sector_by_id =
+                common.lc_materialized_sectors_by_id_from_groups(&physics, &self.raw_sum_groups)?;
+            let plan = Arc::new(physics.lc_resolved_replay_plan(
+                &common.lc_topology_replay_public_mappings,
+                &common.lc_topology_replay_routes,
+                &materialized_sector_by_id,
+            )?);
+            self.lc_resolved_replay_plan = Some(Arc::clone(&plan));
+            plan
+        };
+        let selection_key =
+            physics.lc_resolved_replay_selection_key(selected_helicity_ids, selected_color_ids)?;
+        let selection = if let Some((_, selection)) = self
+            .lc_resolved_replay_selection_cache
+            .iter()
+            .find(|(key, _)| key == &selection_key)
+        {
+            Arc::clone(selection)
+        } else {
+            let selection = Arc::new(
+                physics
+                    .select_lc_resolved_replay_plan_for_key(replay_plan.as_ref(), &selection_key)?,
+            );
+            self.lc_resolved_replay_selection_cache
+                .push((selection_key, Arc::clone(&selection)));
+            selection
+        };
+        let total_start = Instant::now();
+        let point_count = batch.len();
+        let component_count = selection.helicity_indices.len() * selection.color_indices.len();
+        let mut values = vec![0.0; point_count * component_count];
+        // Saved SymJIT applications do not currently guarantee Rust's AArch64
+        // callee-saved FP registers. Keep profile state produced by one call
+        // in memory until all calls have completed instead of retaining f64
+        // accumulators across the next kernel invocation.
+        let mut sector_profiles = Vec::new();
+        let mappings = common.lc_topology_replay_mappings.clone();
+        let mappings_per_chunk = replay_mappings_per_expanded_batch(point_count);
+        let mut expanded_batch = std::mem::take(&mut self.lc_replay_expanded_batch);
+        let mut seen_labels = std::mem::take(&mut self.lc_replay_seen_labels);
+        let result = (|| {
+            for source_group in &selection.source_groups {
+                for chunk_start in
+                    (0..source_group.mapping_indices.len()).step_by(mappings_per_chunk)
+                {
+                    let chunk_end = usize::min(
+                        chunk_start + mappings_per_chunk,
+                        source_group.mapping_indices.len(),
+                    );
+                    let mapping_indices = &source_group.mapping_indices[chunk_start..chunk_end];
+                    let entry_chunk = &source_group.entries[chunk_start..chunk_end];
+                    let identity_mapping =
+                        mapping_indices.len() == 1 && mappings[mapping_indices[0]].is_empty();
+                    let evaluation_batch = if identity_mapping {
+                        batch
+                    } else {
+                        let expanded_len = fill_lc_replay_expanded_batch(
+                            &mut expanded_batch,
+                            &mut seen_labels,
+                            batch,
+                            common.external_count,
+                            mapping_indices,
+                            &mappings,
+                        )?;
+                        &expanded_batch[..expanded_len]
+                    };
+                    let (materialized, sector_profile) = if profiled {
+                        self.run_resolved_f64_profile_materialized(
+                            common,
+                            evaluation_batch,
+                            Some(&source_group.helicity_ids),
+                            Some(&source_group.color_ids),
+                        )?
+                    } else {
+                        self.run_resolved_f64_materialized(
+                            common,
+                            evaluation_batch,
+                            Some(&source_group.helicity_ids),
+                            Some(&source_group.color_ids),
+                        )?
+                    };
+                    let reduction_start = Instant::now();
+                    accumulate_selected_lc_replay_resolved_f64(
+                        &mut values,
+                        point_count,
+                        &materialized,
+                        entry_chunk,
+                        source_group.source_component_count,
+                        component_count,
+                    )?;
+                    sector_profiles.push((sector_profile, reduction_start.elapsed()));
+                }
+            }
+            let mut profile = RuntimeProfile::default();
+            for (sector_profile, replay_reduction) in &sector_profiles {
+                profile.add_sector(sector_profile);
+                let replay_reduction_s = profile_duration_seconds(*replay_reduction);
+                profile.stage_evaluator_call_s += replay_reduction_s;
+                profile.stage_evaluator_s += replay_reduction_s;
+                profile.reduction_s += replay_reduction_s;
+                profile.eager_reduction_s += replay_reduction_s;
+            }
+            profile.total_s = total_start.elapsed().as_secs_f64();
+            Ok((
+                ResolvedValues {
+                    values,
+                    point_count,
+                    helicity_indices: selection.helicity_indices.clone(),
+                    color_indices: selection.color_indices.clone(),
+                },
+                profile,
+            ))
+        })();
+        self.lc_replay_expanded_batch = expanded_batch;
+        self.lc_replay_seen_labels = seen_labels;
+        result
+    }
+}
+
+fn fill_lc_replay_expanded_batch(
+    target: &mut Vec<Vec<[f64; 4]>>,
+    seen_labels: &mut Vec<bool>,
+    batch: &[Vec<[f64; 4]>],
+    expected_legs: usize,
+    mapping_indices: &[usize],
+    mappings: &[Vec<(usize, usize)>],
+) -> RusticolResult<usize> {
+    let required_rows = batch
+        .len()
+        .checked_mul(mapping_indices.len())
+        .ok_or_else(|| RusticolError::invalid_argument("LC topology replay batch overflows"))?;
+    if target.len() < required_rows {
+        target.resize_with(required_rows, Vec::new);
+    }
+    seen_labels.resize(expected_legs, false);
+    let mut target_row = 0;
+    for mapping_index in mapping_indices {
+        let mapping = mappings.get(*mapping_index).ok_or_else(|| {
+            RusticolError::integrity("LC topology replay references an unknown mapping")
+        })?;
+        seen_labels.fill(false);
+        for (representative_index, sector_index) in mapping {
+            if *representative_index >= expected_legs || *sector_index >= expected_legs {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay label permutation references an out-of-range external leg",
+                ));
+            }
+            if seen_labels[*representative_index] {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay label permutation contains a duplicate representative label",
+                ));
+            }
+            seen_labels[*representative_index] = true;
+        }
+        for point in batch {
+            if point.len() != expected_legs {
+                return Err(RusticolError::invalid_argument(format!(
+                    "LC topology replay point has {} external legs, expected {expected_legs}",
+                    point.len(),
+                )));
+            }
+            let mapped = &mut target[target_row];
+            mapped.clear();
+            mapped.extend_from_slice(point);
+            for (representative_index, sector_index) in mapping {
+                mapped[*representative_index] = point[*sector_index];
+            }
+            target_row += 1;
+        }
+    }
+    Ok(required_rows)
+}
+
+fn sum_eager_resolved(resolved: &ResolvedValues<f64>) -> Vec<f64> {
+    let component_count = resolved.helicity_indices.len() * resolved.color_indices.len();
+    if component_count == 0 {
+        return vec![0.0; resolved.point_count];
+    }
+    resolved
+        .values
+        .chunks_exact(component_count)
+        .map(|components| components.iter().sum())
+        .collect()
+}
+
+fn fill_selected_eager_group_ids(
+    groups: &[RawSumGroup],
+    physics: &PhysicsRuntime,
+    selected_helicity_ids: Option<&BTreeSet<String>>,
+    selected_color_ids: Option<&BTreeSet<String>>,
+    active: &mut Vec<u32>,
+) -> RusticolResult<()> {
+    let intersects = |members: &[String], selected: Option<&BTreeSet<String>>| {
+        selected.is_none_or(|selected| members.iter().any(|id| selected.contains(id)))
+    };
+    active.clear();
+    active.try_reserve_exact(groups.len()).map_err(|error| {
+        RusticolError::invalid_argument(format!(
+            "could not reserve eager active selector groups: {error}"
+        ))
+    })?;
+    for group in groups {
+        let reduction = physics
+            .reduction_by_group_id
+            .get(&group.id)
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "resolved eager metadata is missing coherent group {}",
+                    group.id
+                ))
+            })?;
+        if intersects(&reduction.physical_helicity_ids, selected_helicity_ids)
+            && intersects(&reduction.physical_color_ids, selected_color_ids)
+        {
+            active.push(u32::try_from(group.id).map_err(|_| {
+                RusticolError::integrity(format!(
+                    "eager coherent group {} does not fit the selector-domain ABI",
+                    group.id
+                ))
+            })?);
+        }
+    }
+    active.sort_unstable();
+    active.dedup();
+    Ok(())
+}
+
+#[allow(dead_code)] // Used by the order-preserving benchmark reference lane.
+fn build_eager_selector_members(
+    groups: &[RawSumGroup],
+    contracted_color: bool,
+    physics: &PhysicsRuntime,
+) -> RusticolResult<Vec<Vec<(usize, usize, f64)>>> {
+    groups
+        .iter()
+        .map(|group| {
+            let reduction = physics
+                .reduction_by_group_id
+                .get(&group.id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "resolved eager metadata is missing coherent group {}",
+                        group.id
+                    ))
+                })?;
+            if contracted_color {
+                physics
+                    .normalized_helicity_weights(reduction)
+                    .map(|members| {
+                        members
+                            .into_iter()
+                            .map(|(helicity, weight)| (helicity, 0, weight))
+                            .collect()
+                    })
+            } else {
+                physics.normalized_member_weights(reduction)
+            }
+        })
+        .collect()
+}
+
+#[allow(clippy::too_many_arguments)]
+#[allow(dead_code)] // Used by the order-preserving benchmark reference lane.
+fn fill_eager_group_sets_by_point(
+    groups: &[RawSumGroup],
+    selector_members: &[Vec<(usize, usize, f64)>],
+    physics: &PhysicsRuntime,
+    point_count: usize,
+    selected_helicity_ids: Option<&BTreeSet<String>>,
+    selected_color_ids: Option<&BTreeSet<String>>,
+    helicity_by_point: Option<&[u32]>,
+    color_by_point: Option<&[u32]>,
+    offsets: &mut Vec<usize>,
+    active_groups: &mut Vec<u32>,
+    active_group_weights: &mut Vec<f64>,
+    point_pairs: &mut Vec<(u32, f64)>,
+    selected_helicity_indices: &mut Vec<usize>,
+    selected_color_indices: &mut Vec<usize>,
+) -> RusticolResult<()> {
+    if selector_members.len() != groups.len() {
+        return Err(RusticolError::integrity(
+            "eager selector memberships do not match coherent groups",
+        ));
+    }
+    physics.selected_helicity_indices_into(selected_helicity_ids, selected_helicity_indices)?;
+    physics.selected_color_indices_into(selected_color_ids, selected_color_indices)?;
+    let helicity_matches = |index: usize, point: usize| {
+        helicity_by_point
+            .map(|values| values[point] as usize == index)
+            .unwrap_or_else(|| selected_helicity_indices.binary_search(&index).is_ok())
+    };
+    let color_matches = |index: usize, point: usize| {
+        color_by_point
+            .map(|values| values[point] as usize == index)
+            .unwrap_or_else(|| selected_color_indices.binary_search(&index).is_ok())
+    };
+
+    offsets.clear();
+    active_groups.clear();
+    active_group_weights.clear();
+    offsets.try_reserve(point_count + 1).map_err(|error| {
+        RusticolError::invalid_argument(format!(
+            "could not reserve eager selector offsets: {error}"
+        ))
+    })?;
+    offsets.push(0);
+    point_pairs.clear();
+    point_pairs.try_reserve(groups.len()).map_err(|error| {
+        RusticolError::invalid_argument(format!(
+            "could not reserve eager selector group scratch: {error}"
+        ))
+    })?;
+    for point in 0..point_count {
+        point_pairs.clear();
+        for (group, members) in groups.iter().zip(selector_members) {
+            let weight = members
+                .iter()
+                .filter(|(helicity, color, _)| {
+                    helicity_matches(*helicity, point) && color_matches(*color, point)
+                })
+                .map(|(_, _, weight)| *weight)
+                .sum::<f64>();
+            if weight == 0.0 {
+                continue;
+            }
+            let group_id = u32::try_from(group.id).map_err(|_| {
+                RusticolError::integrity(format!(
+                    "eager coherent group {} does not fit the selector-domain ABI",
+                    group.id
+                ))
+            })?;
+            point_pairs.push((group_id, weight));
+        }
+        point_pairs.sort_unstable_by_key(|(group_id, _)| *group_id);
+        if point_pairs.windows(2).any(|pair| pair[0].0 == pair[1].0) {
+            return Err(RusticolError::integrity(
+                "eager physical selector maps duplicate coherent groups",
+            ));
+        }
+        active_groups.extend(point_pairs.iter().map(|(group_id, _)| *group_id));
+        active_group_weights.extend(point_pairs.iter().map(|(_, weight)| *weight));
+        offsets.push(active_groups.len());
+    }
+    Ok(())
+}
+
+fn project_model_parameters(
+    projection: &EagerParameterProjection,
+    runtime_parameters: &[f64],
+    output: &mut Vec<crate::EagerComplex64>,
+) -> RusticolResult<()> {
+    output.resize(
+        projection.parameter_count,
+        crate::EagerComplex64::new(0.0, 0.0),
+    );
+    output.fill(crate::EagerComplex64::new(0.0, 0.0));
+    for entry in &projection.entries {
+        let real = runtime_parameters
+            .get(entry.runtime_real_index)
+            .copied()
+            .ok_or_else(|| {
+                RusticolError::integrity("eager parameter projection has an invalid real slot")
+            })?;
+        let imaginary = entry
+            .runtime_imaginary_index
+            .map(|index| {
+                runtime_parameters.get(index).copied().ok_or_else(|| {
+                    RusticolError::integrity(
+                        "eager parameter projection has an invalid imaginary slot",
+                    )
+                })
+            })
+            .transpose()?
+            .unwrap_or(0.0);
+        output[entry.prepared_index] = crate::EagerComplex64::new(real, imaginary);
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn reduce_eager_amplitudes_resolved_into(
+    amplitudes: &[crate::EagerComplex64],
+    point_count: usize,
+    groups: &[RawSumGroup],
+    contraction: Option<&mut ColorContractionRuntime>,
+    color_group_scratch: &mut Vec<crate::EagerComplex64>,
+    physics: &PhysicsRuntime,
+    normalization_factor: f64,
+    selected_helicity_ids: Option<&BTreeSet<String>>,
+    selected_color_ids: Option<&BTreeSet<String>>,
+    values: &mut Vec<f64>,
+    helicity_indices: &mut Vec<usize>,
+    color_indices: &mut Vec<usize>,
+    helicity_position: &mut Vec<Option<usize>>,
+    color_position: &mut Vec<Option<usize>>,
+    helicity_weights: &mut Vec<(usize, f64)>,
+    right_helicity_weights: &mut Vec<(usize, f64)>,
+    member_weights: &mut Vec<(usize, usize, f64)>,
+) -> RusticolResult<()> {
+    physics.selected_helicity_indices_into(selected_helicity_ids, helicity_indices)?;
+    physics.selected_color_indices_into(selected_color_ids, color_indices)?;
+    let selected_component_count = helicity_indices
+        .len()
+        .checked_mul(color_indices.len())
+        .ok_or_else(|| RusticolError::invalid_argument("resolved eager shape overflows"))?;
+    let value_count = point_count
+        .checked_mul(selected_component_count)
+        .ok_or_else(|| RusticolError::invalid_argument("resolved eager shape overflows"))?;
+    values.resize(value_count, 0.0);
+    values.fill(0.0);
+
+    let amplitude_count = groups
+        .iter()
+        .flat_map(|group| group.indices.iter().copied())
+        .max()
+        .map(|value| value + 1)
+        .unwrap_or(0);
+    let expected_amplitudes = point_count
+        .checked_mul(amplitude_count)
+        .ok_or_else(|| RusticolError::invalid_argument("eager amplitude shape overflows"))?;
+    if amplitudes.len() != expected_amplitudes {
+        return Err(RusticolError::integrity(format!(
+            "eager amplitude buffer has length {}, expected {expected_amplitudes}",
+            amplitudes.len(),
+        )));
+    }
+
+    helicity_position.resize(physics.manifest.helicities.len(), None);
+    helicity_position.fill(None);
+    for (position, index) in helicity_indices.iter().copied().enumerate() {
+        let slot = helicity_position.get_mut(index).ok_or_else(|| {
+            RusticolError::integrity("resolved eager helicity index is out of range")
+        })?;
+        *slot = Some(position);
+    }
+    color_position.resize(physics.manifest.color_components.len(), None);
+    color_position.fill(None);
+    for (position, index) in color_indices.iter().copied().enumerate() {
+        let slot = color_position.get_mut(index).ok_or_else(|| {
+            RusticolError::integrity("resolved eager color index is out of range")
+        })?;
+        *slot = Some(position);
+    }
+
+    if let Some(contraction) = contraction {
+        if !physics.has_contracted_color_axis()
+            || physics.manifest.color_components.len() != 1
+            || contraction.group_count != groups.len()
+        {
+            return Err(RusticolError::integrity(
+                "resolved eager color contraction does not match physics metadata",
+            ));
+        }
+        let Some(selected_color_position) = color_position.first().copied().flatten() else {
+            return Ok(());
+        };
+        color_group_scratch.resize(
+            point_count * groups.len(),
+            crate::EagerComplex64::new(0.0, 0.0),
+        );
+        for (group_index, group) in groups.iter().enumerate() {
+            for point in 0..point_count {
+                let sum = group
+                    .indices
+                    .iter()
+                    .fold(crate::EagerComplex64::new(0.0, 0.0), |sum, index| {
+                        sum + amplitudes[*index * point_count + point]
+                    });
+                color_group_scratch[group_index * point_count + point] = sum;
+            }
+        }
+        for entry in contraction.logical_entries() {
+            let left_group = &groups[entry.left_group_index];
+            let right_group = &groups[entry.right_group_index];
+            let left_reduction = physics
+                .reduction_by_group_id
+                .get(&left_group.id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "resolved eager metadata is missing coherent group {}",
+                        left_group.id
+                    ))
+                })?;
+            let right_reduction = physics
+                .reduction_by_group_id
+                .get(&right_group.id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "resolved eager metadata is missing coherent group {}",
+                        right_group.id
+                    ))
+                })?;
+            if left_reduction.physical_helicity_ids != right_reduction.physical_helicity_ids {
+                return Err(RusticolError::integrity(
+                    "resolved eager color contraction mixes distinct physical helicities",
+                ));
+            }
+            physics.normalized_helicity_weights_into(left_reduction, helicity_weights)?;
+            physics.normalized_helicity_weights_into(right_reduction, right_helicity_weights)?;
+            if helicity_weights.len() != right_helicity_weights.len()
+                || helicity_weights
+                    .iter()
+                    .zip(right_helicity_weights.iter())
+                    .any(|((left_index, left_weight), (right_index, right_weight))| {
+                        left_index != right_index || left_weight.to_bits() != right_weight.to_bits()
+                    })
+            {
+                return Err(RusticolError::integrity(
+                    "resolved eager color groups have inconsistent helicity weights",
+                ));
+            }
+            for point in 0..point_count {
+                let left = color_group_scratch[entry.left_group_index * point_count + point];
+                let right = color_group_scratch[entry.right_group_index * point_count + point];
+                let product = left * right.conj();
+                let contribution = normalization_factor
+                    * entry.symmetry_factor
+                    * (entry.weight_re * product.re - entry.weight_im * product.im);
+                for (helicity_index, weight) in helicity_weights.iter().copied() {
+                    let Some(selected_helicity_position) = helicity_position[helicity_index] else {
+                        continue;
+                    };
+                    let index = point * selected_component_count
+                        + selected_helicity_position * color_indices.len()
+                        + selected_color_position;
+                    values[index] += contribution * weight;
+                }
+            }
+        }
+    } else {
+        for group in groups {
+            let reduction = physics
+                .reduction_by_group_id
+                .get(&group.id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "resolved eager metadata is missing coherent group {}",
+                        group.id
+                    ))
+                })?;
+            physics.normalized_member_weights_into(reduction, member_weights)?;
+            for point in 0..point_count {
+                let sum = group
+                    .indices
+                    .iter()
+                    .fold(crate::EagerComplex64::new(0.0, 0.0), |sum, index| {
+                        sum + amplitudes[*index * point_count + point]
+                    });
+                let contribution = normalization_factor
+                    * group.all_sector_weight
+                    * (sum.re * sum.re + sum.im * sum.im);
+                for (helicity_index, color_index, weight) in member_weights.iter().copied() {
+                    let Some(selected_helicity_position) = helicity_position[helicity_index] else {
+                        continue;
+                    };
+                    let Some(selected_color_position) = color_position[color_index] else {
+                        continue;
+                    };
+                    let index = point * selected_component_count
+                        + selected_helicity_position * color_indices.len()
+                        + selected_color_position;
+                    values[index] += contribution * weight;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn accumulate_selected_lc_replay_values_f64(
+    target: &mut [f64],
+    point_count: usize,
+    materialized_values: &[f64],
+    replay_entries: &[LcResolvedReplayEntry],
+    source_component_count: usize,
+    target_component_count: usize,
+) -> RusticolResult<()> {
+    let source_scalar_count = point_count
+        .checked_mul(replay_entries.len())
+        .and_then(|count| count.checked_mul(source_component_count))
+        .ok_or_else(|| RusticolError::invalid_argument("LC replay source shape overflows"))?;
+    if materialized_values.len() != source_scalar_count {
+        return Err(RusticolError::integrity(format!(
+            "LC topology replay materialized values have length {}, expected {source_scalar_count}",
+            materialized_values.len()
+        )));
+    }
+    let target_scalar_count = point_count
+        .checked_mul(target_component_count)
+        .ok_or_else(|| RusticolError::invalid_argument("LC replay target shape overflows"))?;
+    if target.len() != target_scalar_count {
+        return Err(RusticolError::integrity(format!(
+            "LC topology replay target has length {}, expected {target_scalar_count}",
+            target.len()
+        )));
+    }
+    for (entry_index, entry) in replay_entries.iter().enumerate() {
+        for point_index in 0..point_count {
+            let source_row = (entry_index * point_count + point_index) * source_component_count;
+            let target_row = point_index * target_component_count;
+            for route in &entry.routes {
+                if route.source_index >= source_component_count
+                    || route.target_index >= target_component_count
+                {
+                    return Err(RusticolError::integrity(
+                        "LC topology replay selected route is out of bounds",
+                    ));
+                }
+                target[target_row + route.target_index] +=
+                    route.weight * materialized_values[source_row + route.source_index];
+            }
+        }
+    }
+    Ok(())
+}
+
+fn lc_replay_selection_key_matches(
+    key: &LcResolvedReplaySelectionKey,
+    physics: &PhysicsRuntime,
+    selected_helicity_ids: Option<&BTreeSet<String>>,
+    selected_color_ids: Option<&BTreeSet<String>>,
+) -> bool {
+    let helicities_match = match (&key.helicity_indices, selected_helicity_ids) {
+        (None, None) => true,
+        (Some(indices), Some(ids)) if indices.len() == ids.len() => indices.iter().all(|index| {
+            physics
+                .manifest
+                .helicities
+                .get(*index)
+                .is_some_and(|helicity| ids.contains(&helicity.id))
+        }),
+        _ => false,
+    };
+    let colors_match = match (&key.color_indices, selected_color_ids) {
+        (None, None) => true,
+        (Some(indices), Some(ids)) if indices.len() == ids.len() => indices.iter().all(|index| {
+            physics
+                .manifest
+                .color_components
+                .get(*index)
+                .is_some_and(|color| ids.contains(color.id()))
+        }),
+        _ => false,
+    };
+    helicities_match && colors_match
+}
+
+fn fill_lc_replay_expanded_flat_from_view(
+    target: &mut Vec<f64>,
+    batch: F64MomentumBatchView<'_>,
+    expected_legs: usize,
+    mapping_indices: &[usize],
+    mappings: &[Vec<(usize, usize)>],
+) -> RusticolResult<()> {
+    if batch.external_count() != expected_legs {
+        return Err(RusticolError::invalid_argument(format!(
+            "LC topology replay input has {} external legs, expected {expected_legs}",
+            batch.external_count()
+        )));
+    }
+    let values_per_point = expected_legs
+        .checked_mul(4)
+        .ok_or_else(|| RusticolError::invalid_argument("LC topology replay batch overflows"))?;
+    let row_count = batch
+        .point_count()
+        .checked_mul(mapping_indices.len())
+        .ok_or_else(|| RusticolError::invalid_argument("LC topology replay batch overflows"))?;
+    let scalar_count = row_count
+        .checked_mul(values_per_point)
+        .ok_or_else(|| RusticolError::invalid_argument("LC topology replay batch overflows"))?;
+    target.resize(scalar_count, 0.0);
+    let mut target_row = 0usize;
+    for mapping_index in mapping_indices {
+        let mapping = mappings.get(*mapping_index).ok_or_else(|| {
+            RusticolError::integrity("LC topology replay references an unknown mapping")
+        })?;
+        for (position, (representative_index, sector_index)) in mapping.iter().enumerate() {
+            if *representative_index >= expected_legs || *sector_index >= expected_legs {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay label permutation references an out-of-range external leg",
+                ));
+            }
+            if mapping[..position]
+                .iter()
+                .any(|(previous, _)| previous == representative_index)
+            {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay label permutation contains a duplicate representative label",
+                ));
+            }
+        }
+        for point_index in 0..batch.point_count() {
+            let point = batch.point(point_index);
+            let row_start = target_row * values_per_point;
+            for external_index in 0..expected_legs {
+                let momentum = point.momentum(external_index).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "validated momentum view is missing an external leg during topology replay",
+                    )
+                })?;
+                let start = row_start + external_index * 4;
+                target[start..start + 4].copy_from_slice(&momentum);
+            }
+            for (representative_index, sector_index) in mapping {
+                let momentum = point.momentum(*sector_index).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "validated momentum view is missing a permuted external leg",
+                    )
+                })?;
+                let start = row_start + representative_index * 4;
+                target[start..start + 4].copy_from_slice(&momentum);
+            }
+            target_row += 1;
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn reduce_eager_amplitudes_resolved(
+    amplitudes: &[crate::EagerComplex64],
+    point_count: usize,
+    groups: &[RawSumGroup],
+    contraction: Option<&mut ColorContractionRuntime>,
+    color_group_scratch: &mut Vec<crate::EagerComplex64>,
+    physics: &PhysicsRuntime,
+    normalization_factor: f64,
+    selected_helicity_ids: Option<&BTreeSet<String>>,
+    selected_color_ids: Option<&BTreeSet<String>>,
+) -> RusticolResult<ResolvedValues<f64>> {
+    let helicity_indices = physics.selected_helicity_indices(selected_helicity_ids)?;
+    let color_indices = physics.selected_color_indices(selected_color_ids)?;
+    let selected_component_count = helicity_indices
+        .len()
+        .checked_mul(color_indices.len())
+        .ok_or_else(|| RusticolError::invalid_argument("resolved eager shape overflows"))?;
+    let mut values = vec![0.0; point_count * selected_component_count];
+    let amplitude_count = groups
+        .iter()
+        .flat_map(|group| group.indices.iter().copied())
+        .max()
+        .map(|value| value + 1)
+        .unwrap_or(0);
+    if amplitudes.len() != point_count * amplitude_count {
+        return Err(RusticolError::integrity(format!(
+            "eager amplitude buffer has length {}, expected {}",
+            amplitudes.len(),
+            point_count * amplitude_count,
+        )));
+    }
+    let helicity_position = selected_position_map(
+        physics.manifest.helicities.len(),
+        &helicity_indices,
+        "helicity",
+    )?;
+    let color_position = selected_position_map(
+        physics.manifest.color_components.len(),
+        &color_indices,
+        "color",
+    )?;
+
+    if let Some(contraction) = contraction {
+        if !physics.has_contracted_color_axis()
+            || physics.manifest.color_components.len() != 1
+            || contraction.group_count != groups.len()
+        {
+            return Err(RusticolError::integrity(
+                "resolved eager color contraction does not match physics metadata",
+            ));
+        }
+        let Some(selected_color_position) = color_position[0] else {
+            return Ok(ResolvedValues {
+                values,
+                point_count,
+                helicity_indices,
+                color_indices,
+            });
+        };
+        color_group_scratch.resize(
+            point_count * groups.len(),
+            crate::EagerComplex64::new(0.0, 0.0),
+        );
+        for (group_index, group) in groups.iter().enumerate() {
+            for point in 0..point_count {
+                let sum = group
+                    .indices
+                    .iter()
+                    .fold(crate::EagerComplex64::new(0.0, 0.0), |sum, index| {
+                        sum + amplitudes[*index * point_count + point]
+                    });
+                color_group_scratch[group_index * point_count + point] = sum;
+            }
+        }
+        for entry in contraction.logical_entries() {
+            let left_group = &groups[entry.left_group_index];
+            let right_group = &groups[entry.right_group_index];
+            let left_reduction = physics
+                .reduction_by_group_id
+                .get(&left_group.id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "resolved eager metadata is missing coherent group {}",
+                        left_group.id
+                    ))
+                })?;
+            let right_reduction = physics
+                .reduction_by_group_id
+                .get(&right_group.id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "resolved eager metadata is missing coherent group {}",
+                        right_group.id
+                    ))
+                })?;
+            if left_reduction.physical_helicity_ids != right_reduction.physical_helicity_ids {
+                return Err(RusticolError::integrity(
+                    "resolved eager color contraction mixes distinct physical helicities",
+                ));
+            }
+            let left_weights = physics.normalized_helicity_weights(left_reduction)?;
+            let right_weights = physics.normalized_helicity_weights(right_reduction)?;
+            if left_weights.len() != right_weights.len()
+                || left_weights.iter().zip(&right_weights).any(
+                    |((left_index, left_weight), (right_index, right_weight))| {
+                        left_index != right_index || left_weight.to_bits() != right_weight.to_bits()
+                    },
+                )
+            {
+                return Err(RusticolError::integrity(
+                    "resolved eager color groups have inconsistent helicity weights",
+                ));
+            }
+            let selected_weights = left_weights
+                .into_iter()
+                .filter_map(|(index, weight)| {
+                    helicity_position[index].map(|position| (position, weight))
+                })
+                .collect::<Vec<_>>();
+            if selected_weights.is_empty() {
+                continue;
+            }
+            for point in 0..point_count {
+                let left = color_group_scratch[entry.left_group_index * point_count + point];
+                let right = color_group_scratch[entry.right_group_index * point_count + point];
+                let product = left * right.conj();
+                let contribution = normalization_factor
+                    * entry.symmetry_factor
+                    * (entry.weight_re * product.re - entry.weight_im * product.im);
+                for (helicity_position, weight) in &selected_weights {
+                    let index = point * selected_component_count
+                        + *helicity_position * color_indices.len()
+                        + selected_color_position;
+                    values[index] += contribution * *weight;
+                }
+            }
+        }
+    } else {
+        for group in groups {
+            let reduction = physics
+                .reduction_by_group_id
+                .get(&group.id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "resolved eager metadata is missing coherent group {}",
+                        group.id
+                    ))
+                })?;
+            let selected_members = physics
+                .normalized_member_weights(reduction)?
+                .into_iter()
+                .filter_map(|(helicity_index, color_index, weight)| {
+                    Some((
+                        helicity_position[helicity_index]?,
+                        color_position[color_index]?,
+                        weight,
+                    ))
+                })
+                .collect::<Vec<_>>();
+            if selected_members.is_empty() {
+                continue;
+            }
+            for point in 0..point_count {
+                let sum = group
+                    .indices
+                    .iter()
+                    .fold(crate::EagerComplex64::new(0.0, 0.0), |sum, index| {
+                        sum + amplitudes[*index * point_count + point]
+                    });
+                let contribution = normalization_factor
+                    * group.all_sector_weight
+                    * (sum.re * sum.re + sum.im * sum.im);
+                for (helicity_position, color_position, weight) in &selected_members {
+                    let index = point * selected_component_count
+                        + *helicity_position * color_indices.len()
+                        + *color_position;
+                    values[index] += contribution * *weight;
+                }
+            }
+        }
+    }
+
+    Ok(ResolvedValues {
+        values,
+        point_count,
+        helicity_indices,
+        color_indices,
+    })
+}
+
+fn selected_position_map(
+    physical_count: usize,
+    selected: &[usize],
+    kind: &str,
+) -> RusticolResult<Vec<Option<usize>>> {
+    let mut positions = vec![None; physical_count];
+    for (position, index) in selected.iter().copied().enumerate() {
+        let slot = positions.get_mut(index).ok_or_else(|| {
+            RusticolError::integrity(format!("resolved eager {kind} index is out of range"))
+        })?;
+        *slot = Some(position);
+    }
+    Ok(positions)
+}
+
+fn prepare_eager_inputs_view(
+    common: &mut ExecutionRuntime,
+    batch: F64MomentumBatchView<'_>,
+    initial_values: &mut Vec<crate::EagerComplex64>,
+    momenta: &mut Vec<f64>,
+    source_schedule: &mut Option<EagerSourceSchedule>,
+    source_wavefunction_scratch: &mut Vec<Complex<f64>>,
+) -> RusticolResult<()> {
+    if batch.external_count() != common.external_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "eager momentum input has {} external legs, expected {}",
+            batch.external_count(),
+            common.external_count
+        )));
+    }
+    let point_count = batch.point_count();
+    let value_len = point_count
+        .checked_mul(common.value_parameter_count)
+        .ok_or_else(|| RusticolError::invalid_argument("eager value input overflows"))?;
+    let momentum_len = point_count
+        .checked_mul(common.momentum_parameter_count)
+        .ok_or_else(|| RusticolError::invalid_argument("eager momentum input overflows"))?;
+    initial_values.resize(value_len, crate::EagerComplex64::new(0.0, 0.0));
+    momenta.resize(momentum_len, 0.0);
+
+    if source_schedule.is_none() {
+        *source_schedule = Some(build_eager_source_schedule(
+            &common.sources,
+            common.value_parameter_count,
+        )?);
+    }
+    let source_schedule = source_schedule
+        .as_ref()
+        .expect("eager source schedule was initialized above");
+    source_wavefunction_scratch.resize(source_schedule.maximum_dimension, Complex::new(0.0, 0.0));
+
+    for point_index in 0..point_count {
+        let point = batch.point(point_index);
+        for class in &source_schedule.classes {
+            let source = &common.sources[class.representative_index];
+            let wavefunction = &mut source_wavefunction_scratch[..class.dimension];
+            ExecutionRuntime::write_source_wavefunction(
+                source,
+                common.external_count,
+                &common.particle_masses,
+                &point,
+                wavefunction,
+            )?;
+            for target_start in &class.target_component_starts {
+                for (component, value) in wavefunction.iter().enumerate() {
+                    initial_values[(target_start + component) * point_count + point_index] =
+                        crate::EagerComplex64::new(value.re, value.im);
+                }
+            }
+        }
+    }
+
+    for point_index in 0..point_count {
+        let point = batch.point(point_index);
+        for slot in &common.momentum_slots {
+            let start = slot.component_start;
+            let stop = slot.component_stop;
+            if stop > common.momentum_parameter_count || stop < start || stop - start != 4 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic momentum slot {} has an invalid component range",
+                    slot.momentum_slot_id
+                )));
+            }
+            let mut momentum = [0.0; 4];
+            for label in &slot.external_labels {
+                let index = label.checked_sub(1).ok_or_else(|| {
+                    RusticolError::invalid_argument("generic momentum labels are one-based")
+                })?;
+                if index >= common.external_count || index >= common.external_is_initial.len() {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "generic momentum slot {} refers to unknown external label {}",
+                        slot.momentum_slot_id, label
+                    )));
+                }
+                let source_momentum = point.momentum(index).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "validated eager momentum view is missing an external leg",
+                    )
+                })?;
+                let sign = if common.external_is_initial[index] {
+                    -1.0
+                } else {
+                    1.0
+                };
+                for (output, input) in momentum.iter_mut().zip(source_momentum) {
+                    *output += sign * input;
+                }
+            }
+            for (component, value) in momentum.into_iter().enumerate() {
+                momenta[(start + component) * point_count + point_index] = value;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn prepare_eager_inputs(
+    common: &mut ExecutionRuntime,
+    batch: &[Vec<[f64; 4]>],
+    initial_values: &mut Vec<crate::EagerComplex64>,
+    momenta: &mut Vec<f64>,
+    source_schedule: &mut Option<EagerSourceSchedule>,
+    source_wavefunction_scratch: &mut Vec<Complex<f64>>,
+) -> RusticolResult<(Duration, Duration)> {
+    let point_count = batch.len();
+    let value_len = point_count
+        .checked_mul(common.value_parameter_count)
+        .ok_or_else(|| RusticolError::invalid_argument("eager value input overflows"))?;
+    let momentum_len = point_count
+        .checked_mul(common.momentum_parameter_count)
+        .ok_or_else(|| RusticolError::invalid_argument("eager momentum input overflows"))?;
+    initial_values.resize(value_len, crate::EagerComplex64::new(0.0, 0.0));
+    momenta.resize(momentum_len, 0.0);
+
+    if source_schedule.is_none() {
+        *source_schedule = Some(build_eager_source_schedule(
+            &common.sources,
+            common.value_parameter_count,
+        )?);
+    }
+    let source_schedule = source_schedule
+        .as_ref()
+        .expect("eager source schedule was initialized above");
+    source_wavefunction_scratch.resize(source_schedule.maximum_dimension, Complex::new(0.0, 0.0));
+
+    let source_started = Instant::now();
+    for (point_index, point) in batch.iter().enumerate() {
+        for class in &source_schedule.classes {
+            let source = &common.sources[class.representative_index];
+            let wavefunction = &mut source_wavefunction_scratch[..class.dimension];
+            ExecutionRuntime::write_source_wavefunction(
+                source,
+                common.external_count,
+                &common.particle_masses,
+                point,
+                wavefunction,
+            )?;
+            for target_start in &class.target_component_starts {
+                for (component, value) in wavefunction.iter().enumerate() {
+                    initial_values[(target_start + component) * point_count + point_index] =
+                        crate::EagerComplex64::new(value.re, value.im);
+                }
+            }
+        }
+    }
+    let source_fill = source_started.elapsed();
+
+    let momentum_started = Instant::now();
+    for (point_index, point) in batch.iter().enumerate() {
+        for slot in &common.momentum_slots {
+            let start = slot.component_start;
+            let stop = slot.component_stop;
+            if stop > common.momentum_parameter_count || stop < start || stop - start != 4 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic momentum slot {} has an invalid component range",
+                    slot.momentum_slot_id
+                )));
+            }
+            let mut momentum = [0.0; 4];
+            for label in &slot.external_labels {
+                let index = label.checked_sub(1).ok_or_else(|| {
+                    RusticolError::invalid_argument("generic momentum labels are one-based")
+                })?;
+                if index >= common.external_count || index >= common.external_is_initial.len() {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "generic momentum slot {} refers to unknown external label {}",
+                        slot.momentum_slot_id, label
+                    )));
+                }
+                let sign = if common.external_is_initial[index] {
+                    -1.0
+                } else {
+                    1.0
+                };
+                for (output, input) in momentum.iter_mut().zip(&point[index]) {
+                    *output += sign * input;
+                }
+            }
+            for (component, value) in momentum.into_iter().enumerate() {
+                momenta[(start + component) * point_count + point_index] = value;
+            }
+        }
+    }
+    Ok((source_fill, momentum_started.elapsed()))
+}
+
+fn build_eager_source_schedule(
+    sources: &[GenericSourceRecordManifest],
+    value_component_count: usize,
+) -> RusticolResult<EagerSourceSchedule> {
+    let mut class_by_key: BTreeMap<EagerSourceKey, usize> = BTreeMap::new();
+    let mut classes: Vec<EagerSourceClass> = Vec::new();
+    let mut maximum_dimension = 0usize;
+    for (source_index, source) in sources.iter().enumerate() {
+        let start = source.value_slot.component_start;
+        let stop = source.value_slot.component_stop;
+        if stop > value_component_count || stop < start || stop - start != source.dimension {
+            return Err(RusticolError::artifact(format!(
+                "eager source {} has an invalid value-slot range",
+                source.source_id
+            )));
+        }
+        let key = eager_source_key(source);
+        if let Some(class_index) = class_by_key.get(&key).copied() {
+            let class = &mut classes[class_index];
+            if class.dimension != source.dimension {
+                return Err(RusticolError::internal(
+                    "equivalent eager sources have inconsistent dimensions",
+                ));
+            }
+            class.target_component_starts.push(start);
+        } else {
+            let class_index = classes.len();
+            class_by_key.insert(key, class_index);
+            classes.push(EagerSourceClass {
+                representative_index: source_index,
+                target_component_starts: vec![start],
+                dimension: source.dimension,
+            });
+        }
+        maximum_dimension = maximum_dimension.max(source.dimension);
+    }
+    Ok(EagerSourceSchedule {
+        classes,
+        maximum_dimension,
+    })
+}
+
+fn eager_source_key(source: &GenericSourceRecordManifest) -> EagerSourceKey {
+    EagerSourceKey {
+        source_kind: source.source_kind.clone(),
+        leg_label: source.leg_label,
+        family: match source.source_ir.wavefunction_family {
+            GenericWavefunctionFamilyManifest::Scalar => 0,
+            GenericWavefunctionFamilyManifest::Fermion => 1,
+            GenericWavefunctionFamilyManifest::Vector => 2,
+            GenericWavefunctionFamilyManifest::Spin2 => 3,
+            GenericWavefunctionFamilyManifest::Ghost => 4,
+            GenericWavefunctionFamilyManifest::Auxiliary => 5,
+        },
+        dimension: source.source_ir.component_dimension,
+        pdg_label: source.source_ir.identity.pdg_label,
+        anti_pdg_label: source.source_ir.identity.anti_pdg_label,
+        orientation: match source.source_ir.identity.orientation {
+            GenericSourceOrientationManifest::Particle => 0,
+            GenericSourceOrientationManifest::Antiparticle => 1,
+            GenericSourceOrientationManifest::SelfConjugate => 2,
+        },
+        momentum_transform: match source.applied_crossing.momentum_transform {
+            GenericMomentumTransformManifest::Identity => 0,
+            GenericMomentumTransformManifest::NegateFourMomentum => 1,
+        },
+        phase_real: source.applied_crossing.phase[0].to_bits(),
+        phase_imaginary: source.applied_crossing.phase[1].to_bits(),
+        source_helicity: source.source_helicity,
+        chirality: source.chirality,
+    }
+}
+
+fn validate_eager_profile_accounting(
+    profile: &crate::eager_runtime::EagerExecutionProfile,
+) -> RusticolResult<()> {
+    let accounted = profile.accounted();
+    let tolerance = Duration::from_nanos(1);
+    if accounted > profile.total.saturating_add(tolerance) {
+        return Err(RusticolError::internal(format!(
+            "eager runtime profile phases account for {accounted_s:.9e}s, exceeding the aggregate {total_s:.9e}s: {profile:?}",
+            accounted_s = accounted.as_secs_f64(),
+            total_s = profile.total.as_secs_f64(),
+        )));
+    }
+    Ok(())
+}
+
+#[inline(always)]
+#[cfg(test)]
+fn store_complex_row_component_major(
+    row: &[Complex<f64>],
+    point_index: usize,
+    point_count: usize,
+    output: &mut [crate::EagerComplex64],
+) {
+    debug_assert!(point_index < point_count);
+    debug_assert_eq!(output.len(), row.len() * point_count);
+    for (component, value) in row.iter().enumerate() {
+        output[component * point_count + point_index] =
+            crate::EagerComplex64::new(value.re, value.im);
+    }
+}
+
+#[inline(always)]
+#[cfg(test)]
+fn store_real_row_component_major(
+    row: &[Complex<f64>],
+    point_index: usize,
+    point_count: usize,
+    output: &mut [f64],
+) -> RusticolResult<()> {
+    debug_assert!(point_index < point_count);
+    debug_assert_eq!(output.len(), row.len() * point_count);
+    for (component, value) in row.iter().enumerate() {
+        if value.im != 0.0 {
+            return Err(RusticolError::internal(
+                "eager momentum setup produced an imaginary component",
+            ));
+        }
+        output[component * point_count + point_index] = value.re;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn eager_input_rows_are_stored_component_major() {
+        let point_count = 2;
+        let mut complex = vec![crate::EagerComplex64::new(0.0, 0.0); 6];
+        let mut real = vec![0.0; 6];
+        for (point, values) in [
+            [
+                Complex::new(1.0, -1.0),
+                Complex::new(2.0, -2.0),
+                Complex::new(3.0, -3.0),
+            ],
+            [
+                Complex::new(4.0, -4.0),
+                Complex::new(5.0, -5.0),
+                Complex::new(6.0, -6.0),
+            ],
+        ]
+        .iter()
+        .enumerate()
+        {
+            store_complex_row_component_major(values, point, point_count, &mut complex);
+            let real_values = values.map(|value| Complex::new(value.re, 0.0));
+            store_real_row_component_major(&real_values, point, point_count, &mut real).unwrap();
+        }
+        assert_eq!(
+            complex,
+            [
+                crate::EagerComplex64::new(1.0, -1.0),
+                crate::EagerComplex64::new(4.0, -4.0),
+                crate::EagerComplex64::new(2.0, -2.0),
+                crate::EagerComplex64::new(5.0, -5.0),
+                crate::EagerComplex64::new(3.0, -3.0),
+                crate::EagerComplex64::new(6.0, -6.0),
+            ]
+        );
+        assert_eq!(real, [1.0, 4.0, 2.0, 5.0, 3.0, 6.0]);
+    }
+
+    #[test]
+    fn eager_real_input_rejects_imaginary_components() {
+        let error = store_real_row_component_major(&[Complex::new(1.0, 1.0)], 0, 1, &mut [0.0])
+            .unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Internal);
+    }
+
+    #[test]
+    fn eager_profile_rejects_impossible_phase_totals() {
+        let valid = crate::eager_runtime::EagerExecutionProfile {
+            initialize: Duration::from_millis(2),
+            gather: Duration::from_millis(3),
+            kernel_call: Duration::from_millis(4),
+            total: Duration::from_millis(10),
+            ..crate::eager_runtime::EagerExecutionProfile::default()
+        };
+        validate_eager_profile_accounting(&valid).unwrap();
+
+        let impossible = crate::eager_runtime::EagerExecutionProfile {
+            invocation_scatter: Duration::from_millis(20),
+            total: Duration::from_millis(10),
+            ..crate::eager_runtime::EagerExecutionProfile::default()
+        };
+        let error = validate_eager_profile_accounting(&impossible).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Internal);
+        assert!(error.to_string().contains("exceeding the aggregate"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/eager_load.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_load.rs
new file mode 100644
index 0000000000..184f41bfed
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_load.rs
@@ -0,0 +1,368 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::EagerCouplingRow;
+
+#[derive(Clone, Copy, Debug)]
+struct RuntimeLogicalParameterSlots {
+    real: usize,
+    imaginary: Option<usize>,
+}
+
+pub(super) fn prepare_eager_parameter_state(
+    pack: &PreparedKernelPackManifest,
+    active_kernel_ids: &BTreeSet<u32>,
+    runtime_parameters: &[GenericRuntimeModelParameterManifest],
+    coupling_bytes: &[u8],
+    payloads: &EvaluatorPayloadStore,
+) -> RusticolResult<(
+    EagerParameterProjection,
+    Vec<u8>,
+    Option<ModelParameterEvaluatorRuntime>,
+)> {
+    let logical_slots = eager_runtime_logical_parameter_slots(runtime_parameters)?;
+    let has_derived_parameters = runtime_parameters
+        .iter()
+        .any(|parameter| parameter.kind == "derived_parameter_component");
+    let canonical_indices =
+        prepared_parameter_indices(pack, active_kernel_ids, has_derived_parameters)?;
+    let mut entries = Vec::with_capacity(canonical_indices.len());
+    let mut base_parameter_count = 0usize;
+    for (name, prepared_index) in &canonical_indices {
+        let slots = logical_slots.get(name).ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "prepared parameter {name:?} is absent from the process runtime schema"
+            ))
+        })?;
+        entries.push(EagerParameterProjectionEntry {
+            prepared_index: *prepared_index,
+            runtime_real_index: slots.real,
+            runtime_imaginary_index: slots.imaginary,
+        });
+        base_parameter_count = base_parameter_count.max(prepared_index + 1);
+    }
+
+    let mut couplings = EagerCouplingRow::decode_table(coupling_bytes)?;
+    let mut synthetic_by_runtime_index = BTreeMap::new();
+    for row in &mut couplings {
+        for parameter_id in [&mut row.real_parameter_id, &mut row.imag_parameter_id] {
+            if *parameter_id == crate::MISSING_U32 {
+                continue;
+            }
+            let runtime_index = usize::try_from(*parameter_id).map_err(|_| {
+                RusticolError::artifact("eager coupling parameter index does not fit usize")
+            })?;
+            if runtime_index >= runtime_parameters.len() {
+                return Err(RusticolError::integrity(format!(
+                    "eager coupling references runtime parameter {runtime_index}, but only {} exist",
+                    runtime_parameters.len()
+                )));
+            }
+            let prepared_index = if let Some(index) = synthetic_by_runtime_index.get(&runtime_index)
+            {
+                *index
+            } else {
+                let index = base_parameter_count
+                    .checked_add(synthetic_by_runtime_index.len())
+                    .ok_or_else(|| {
+                        RusticolError::artifact("eager synthetic coupling parameters overflow")
+                    })?;
+                synthetic_by_runtime_index.insert(runtime_index, index);
+                entries.push(EagerParameterProjectionEntry {
+                    prepared_index: index,
+                    runtime_real_index: runtime_index,
+                    runtime_imaginary_index: None,
+                });
+                index
+            };
+            *parameter_id = u32::try_from(prepared_index).map_err(|_| {
+                RusticolError::artifact("eager synthetic coupling parameter exceeds u32")
+            })?;
+        }
+    }
+    let parameter_count = base_parameter_count
+        .checked_add(synthetic_by_runtime_index.len())
+        .ok_or_else(|| RusticolError::artifact("eager prepared parameter count overflows"))?;
+    entries.sort_unstable_by_key(|entry| entry.prepared_index);
+    let model_parameter_evaluator = load_prepared_model_parameter_evaluator(
+        pack,
+        runtime_parameters,
+        &logical_slots,
+        payloads,
+    )?;
+    Ok((
+        EagerParameterProjection {
+            parameter_count,
+            entries,
+        },
+        EagerCouplingRow::encode_table(&couplings)?,
+        model_parameter_evaluator,
+    ))
+}
+
+fn eager_runtime_logical_parameter_slots(
+    runtime_parameters: &[GenericRuntimeModelParameterManifest],
+) -> RusticolResult<BTreeMap<String, RuntimeLogicalParameterSlots>> {
+    let mut direct = BTreeMap::new();
+    let mut complex = BTreeMap::<String, (Option<usize>, Option<usize>)>::new();
+    for parameter in runtime_parameters {
+        if let Some(runtime_name) = &parameter.runtime_name {
+            let slots = complex.entry(runtime_name.clone()).or_default();
+            let target = match parameter.complex_component.as_deref() {
+                Some("real") => &mut slots.0,
+                Some("imag") => &mut slots.1,
+                other => {
+                    return Err(RusticolError::integrity(format!(
+                        "eager runtime parameter {runtime_name:?} has invalid component {other:?}"
+                    )));
+                }
+            };
+            if target.replace(parameter.parameter_index).is_some() {
+                return Err(RusticolError::integrity(format!(
+                    "eager runtime parameter {runtime_name:?} repeats a complex component"
+                )));
+            }
+        } else if direct
+            .insert(
+                parameter.name.clone(),
+                RuntimeLogicalParameterSlots {
+                    real: parameter.parameter_index,
+                    imaginary: None,
+                },
+            )
+            .is_some()
+        {
+            return Err(RusticolError::integrity(format!(
+                "eager runtime parameter {:?} is duplicated",
+                parameter.name
+            )));
+        }
+    }
+    for (name, (real, imaginary)) in complex {
+        let real = real.ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "eager complex runtime parameter {name:?} lacks a real component"
+            ))
+        })?;
+        if direct
+            .insert(
+                name.clone(),
+                RuntimeLogicalParameterSlots { real, imaginary },
+            )
+            .is_some()
+        {
+            return Err(RusticolError::integrity(format!(
+                "eager runtime parameter {name:?} has conflicting scalar and complex records"
+            )));
+        }
+    }
+    Ok(direct)
+}
+
+pub(super) fn prepared_parameter_indices(
+    pack: &PreparedKernelPackManifest,
+    active_kernel_ids: &BTreeSet<u32>,
+    include_derivation_inputs: bool,
+) -> RusticolResult<BTreeMap<String, usize>> {
+    // Validate the stable parameter namespace across the complete authenticated
+    // pack before projecting it to this process.  An inactive kernel must not
+    // weaken pack integrity, but neither may it impose runtime dependencies on
+    // a process that never invokes it.
+    let all_indices = all_prepared_parameter_indices(pack)?;
+    let mut selected_names = BTreeSet::new();
+    let mut unresolved_active_ids = active_kernel_ids.clone();
+    for kernel in &pack.kernels {
+        let is_active = active_kernel_ids.contains(&kernel.kernel_id);
+        if is_active {
+            unresolved_active_ids.remove(&kernel.kernel_id);
+        }
+        if !is_active && (!include_derivation_inputs || kernel.contract_kind != "model-parameter") {
+            continue;
+        }
+        for input in &kernel.input_contracts {
+            if input.role != "model-parameter" {
+                continue;
+            }
+            let name = input.model_parameter_name.as_ref().ok_or_else(|| {
+                RusticolError::integrity("prepared model-parameter input lacks its name")
+            })?;
+            selected_names.insert(name.clone());
+        }
+    }
+    if let Some(kernel_id) = unresolved_active_ids.first() {
+        return Err(RusticolError::integrity(format!(
+            "active prepared kernel {kernel_id} is absent from the authenticated kernel pack"
+        )));
+    }
+    Ok(all_indices
+        .into_iter()
+        .filter(|(name, _)| selected_names.contains(name))
+        .collect())
+}
+
+fn all_prepared_parameter_indices(
+    pack: &PreparedKernelPackManifest,
+) -> RusticolResult<BTreeMap<String, usize>> {
+    let mut by_name = BTreeMap::new();
+    let mut by_index = BTreeMap::new();
+    for kernel in &pack.kernels {
+        for input in &kernel.input_contracts {
+            if input.role != "model-parameter" {
+                continue;
+            }
+            let name = input.model_parameter_name.as_ref().ok_or_else(|| {
+                RusticolError::integrity("prepared model-parameter input lacks its name")
+            })?;
+            let index = usize::try_from(input.model_parameter_index.ok_or_else(|| {
+                RusticolError::integrity("prepared model-parameter input lacks its stable index")
+            })?)
+            .map_err(|_| RusticolError::artifact("prepared parameter index does not fit usize"))?;
+            if by_name
+                .insert(name.clone(), index)
+                .is_some_and(|old| old != index)
+            {
+                return Err(RusticolError::integrity(format!(
+                    "prepared parameter {name:?} has conflicting stable indices"
+                )));
+            }
+            if by_index
+                .insert(index, name.clone())
+                .is_some_and(|old| old != *name)
+            {
+                return Err(RusticolError::integrity(format!(
+                    "prepared parameter index {index} names multiple parameters"
+                )));
+            }
+        }
+    }
+    Ok(by_name)
+}
+
+fn load_prepared_model_parameter_evaluator(
+    pack: &PreparedKernelPackManifest,
+    runtime_parameters: &[GenericRuntimeModelParameterManifest],
+    logical_slots: &BTreeMap<String, RuntimeLogicalParameterSlots>,
+    payloads: &EvaluatorPayloadStore,
+) -> RusticolResult<Option<ModelParameterEvaluatorRuntime>> {
+    let mut kernels = pack
+        .kernels
+        .iter()
+        .filter(|kernel| kernel.contract_kind == "model-parameter");
+    let kernel = kernels.next();
+    if kernels.next().is_some() {
+        return Err(RusticolError::integrity(
+            "prepared kernel pack contains multiple model-parameter kernels",
+        ));
+    }
+    let derived_names = runtime_parameters
+        .iter()
+        .filter(|parameter| parameter.kind == "derived_parameter_component")
+        .map(|parameter| {
+            parameter
+                .runtime_name
+                .clone()
+                .unwrap_or_else(|| parameter.name.clone())
+        })
+        .collect::<BTreeSet<_>>();
+    if derived_names.is_empty() {
+        return Ok(None);
+    }
+    let Some(kernel) = kernel else {
+        return Err(RusticolError::integrity(
+            "eager runtime schema contains derived parameters but its prepared pack has no derivation kernel",
+        ));
+    };
+
+    let mut input_parameter_indices = Vec::with_capacity(kernel.input_contracts.len());
+    for input in &kernel.input_contracts {
+        let name = input.model_parameter_name.as_ref().ok_or_else(|| {
+            RusticolError::integrity("prepared derivation input lacks its parameter name")
+        })?;
+        let slots = logical_slots.get(name).ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "prepared derivation input {name:?} is absent from the runtime schema"
+            ))
+        })?;
+        if slots.imaginary.is_some() {
+            return Err(RusticolError::compatibility(format!(
+                "prepared derivation input {name:?} is complex, but runtime schema v3 derivation inputs are scalar"
+            )));
+        }
+        input_parameter_indices.push(slots.real);
+    }
+
+    let output_index_by_name = kernel
+        .output_layout
+        .iter()
+        .enumerate()
+        .map(|(index, value)| {
+            let name = value.strip_prefix("model-parameter:").ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "prepared derivation output layout {value:?} is invalid"
+                ))
+            })?;
+            Ok((name.to_string(), index))
+        })
+        .collect::<RusticolResult<BTreeMap<_, _>>>()?;
+    let mut outputs = Vec::with_capacity(derived_names.len());
+    for name in derived_names {
+        let slots = logical_slots.get(&name).ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "derived runtime parameter {name:?} has no logical slots"
+            ))
+        })?;
+        let output_index = *output_index_by_name.get(&name).ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "prepared derivation kernel does not output runtime parameter {name:?}"
+            ))
+        })?;
+        outputs.push(GenericDerivedParameterOutputManifest {
+            runtime_name: name,
+            output_index,
+            real_parameter_index: slots.real,
+            imag_parameter_index: slots.imaginary,
+        });
+    }
+    let evaluator_manifest = kernel.runtime_evaluator_manifest()?;
+    let evaluator = EvaluatorGroup::load_from_store(&evaluator_manifest, payloads)?;
+    Ok(Some(ModelParameterEvaluatorRuntime {
+        input_parameter_indices,
+        outputs,
+        evaluator,
+    }))
+}
+
+pub(super) fn load_prepared_model_parameter_evaluator_for_runtime(
+    pack: &PreparedKernelPackManifest,
+    runtime_parameters: &[GenericRuntimeModelParameterManifest],
+    payloads: &EvaluatorPayloadStore,
+) -> RusticolResult<Option<ModelParameterEvaluatorRuntime>> {
+    let logical_slots = eager_runtime_logical_parameter_slots(runtime_parameters)?;
+    load_prepared_model_parameter_evaluator(pack, runtime_parameters, &logical_slots, payloads)
+}
+
+pub(super) fn validate_prepared_kernel_references(
+    artifact: &VerifiedArtifact,
+    payload_root: &Path,
+    pack: &PreparedKernelPackManifest,
+) -> RusticolResult<()> {
+    let relative_root = payload_root.strip_prefix(artifact.root()).map_err(|_| {
+        RusticolError::security("prepared kernel payload root escapes the verified artifact")
+    })?;
+    for kernel in &pack.kernels {
+        validate_evaluator_state_path(artifact, relative_root, &kernel.exact_evaluator_state_path)?;
+        let evaluator = kernel.runtime_evaluator_manifest()?;
+        validate_evaluator_reference(artifact, relative_root, &evaluator)?;
+        for path in kernel.extra_evaluator_payload_paths()? {
+            validate_evaluator_state_path(artifact, relative_root, path)?;
+        }
+    }
+    for variant in &pack.kernel_variants {
+        let evaluator = variant.runtime_evaluator_manifest()?;
+        validate_evaluator_reference(artifact, relative_root, &evaluator)?;
+        for path in variant.extra_evaluator_payload_paths()? {
+            validate_evaluator_state_path(artifact, relative_root, path)?;
+        }
+    }
+    Ok(())
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/eager_manifest.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_manifest.rs
new file mode 100644
index 0000000000..9e55eae53d
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_manifest.rs
@@ -0,0 +1,2438 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::evaluator::recurrence_intrinsic_direct::{
+    FEYNMAN_VECTOR_PROPAGATOR_TEMPLATE, RecurrenceContributionIntrinsicKind,
+    WEYL_PROPAGATOR_NEGATIVE_TEMPLATE, WEYL_PROPAGATOR_POSITIVE_TEMPLATE,
+};
+use super::*;
+use crate::{
+    EAGER_HOMOGENEOUS_LINEAR_CURRENT_PROOF, EAGER_INDEPENDENT_BLOCK_SIZE, EAGER_KERNEL_ABI,
+    EAGER_PLAN_ABI, EAGER_SELECTOR_DOMAINS_ABI, EagerDirectClosureSpec, EagerKernelInput,
+    EagerKernelRole, EagerKernelSpec, EagerPlanDefinition, EagerPlanDimensions,
+    EagerReductionEntry, EagerReductionGroup,
+};
+use serde_json::value::RawValue;
+use sha2::{Digest, Sha256};
+use std::fmt::Write as _;
+
+pub(super) const EAGER_EXECUTION_KIND: &str = "pyamplicol-runtime-eager-execution";
+const PREPARED_KERNEL_VARIANT_ABI: &str = "pyamplicol-prepared-kernel-variant-v2";
+const PREPARED_INDEPENDENT_BLOCK_VARIANT_ID: &str = "independent-block-4";
+const PREPARED_INDEPENDENT_BLOCK_PROOF: &str = "prepared-kernel-independent-current-block-v1";
+const SYMJIT_APPLICATION_STORAGE_V3_ABI: &str = "symjit-application-storage-v3";
+const PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL: u64 = 2;
+const PREPARED_JIT_PORTABLE_TARGET: &str = "symjit-storage-v3-portable";
+const RECURRENCE_DIRECT_TEMPLATE_ABI_V1: &str = "pyamplicol-recurrence-direct-template-v1";
+const RECURRENCE_DIRECT_BACKEND_ABI_V1: &str = "rusticol.recurrence-direct-backend.v1";
+const RECURRENCE_DIRECT_CANONICALIZATION_ABI_V1: &str = "pyamplicol-canonical-json-v1";
+const RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI_V2: &str = "pyamplicol-recurrence-plane-binding-v2";
+const SYMJIT_PLANE_APPLICATION_V2_ABI: &str = "pyamplicol-symjit-plane-application-v2";
+const NATIVE_DIRECT_APPLICATION_V1_ABI: &str = "pyamplicol-recurrence-native-direct-library-v1";
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerExecutionManifest {
+    pub(super) schema_version: u32,
+    pub(super) kind: String,
+    #[serde(default)]
+    pub(super) required_runtime_capabilities: Vec<String>,
+    pub(super) process: String,
+    pub(super) key: String,
+    pub(super) color_accuracy: String,
+    pub(super) external_pdg_order: Vec<i32>,
+    pub(super) eager_plan_abi: String,
+    pub(super) kernel_pack: EagerKernelPackReferenceManifest,
+    pub(super) runtime_options: EagerRuntimeOptionsManifest,
+    #[serde(default)]
+    pub(super) lc_topology_replay: Option<LcTopologyReplayManifest>,
+    pub(super) plan: EagerPlanManifest,
+    pub(super) dag_summary: ExecutionSummary,
+    pub(super) runtime_schema: ExecutionPlan,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerKernelPackReferenceManifest {
+    pub(super) manifest_path: String,
+    pub(super) payload_root: String,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerRuntimeOptionsManifest {
+    pub(super) point_tile_size: usize,
+    pub(super) workspace_mib: usize,
+}
+
+impl EagerRuntimeOptionsManifest {
+    pub(super) fn validate(self) -> RusticolResult<crate::EagerRuntimeOptions> {
+        if self.point_tile_size == 0 {
+            return Err(RusticolError::artifact(
+                "eager point_tile_size must be positive",
+            ));
+        }
+        if self.workspace_mib == 0 {
+            return Err(RusticolError::artifact(
+                "eager workspace_mib must be positive",
+            ));
+        }
+        crate::EagerRuntimeOptions::from_mib(self.point_tile_size, self.workspace_mib)
+    }
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerPlanManifest {
+    pub(super) kind: String,
+    pub(super) eager_plan_abi: String,
+    #[serde(default)]
+    pub(super) required_runtime_capabilities: Vec<String>,
+    pub(super) process_key: String,
+    pub(super) couplings: EagerTableManifest,
+    pub(super) stages: Vec<EagerStageTablesManifest>,
+    pub(super) closures: EagerTableManifest,
+    #[serde(default)]
+    pub(super) selector_closures: Option<EagerSelectorDomainsManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerStageTablesManifest {
+    pub(super) stage_index: u32,
+    pub(super) subset_size: usize,
+    pub(super) invocations: EagerTableManifest,
+    pub(super) attachments: EagerTableManifest,
+    pub(super) finalizations: EagerTableManifest,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerSelectorDomainsManifest {
+    pub(super) abi: String,
+    pub(super) domains: EagerTableManifest,
+    pub(super) domain_group_ids: EagerTableManifest,
+    pub(super) stages: Vec<EagerSelectorStageManifest>,
+    pub(super) closure_domains: EagerTableManifest,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerSelectorStageManifest {
+    pub(super) stage_index: u32,
+    pub(super) invocation_domains: EagerTableManifest,
+    pub(super) attachment_domains: EagerTableManifest,
+    pub(super) unpropagated_finalization_domains: EagerTableManifest,
+    pub(super) propagated_finalization_domains: EagerTableManifest,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerTableManifest {
+    pub(super) path: String,
+    pub(super) count: usize,
+    pub(super) row_size: usize,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct PreparedKernelPackManifest {
+    pub(super) eager_kernel_abi: String,
+    pub(super) backend: String,
+    pub(super) optimization_settings: Value,
+    pub(super) producer: Value,
+    pub(super) dependency_abis: Value,
+    pub(super) provenance: Value,
+    pub(super) target: PreparedKernelTargetManifest,
+    pub(super) resolver_manifest: Value,
+    pub(super) kernels: Vec<PreparedKernelManifest>,
+    #[serde(default)]
+    pub(super) kernel_variants: Vec<PreparedKernelVariantManifest>,
+    #[serde(default)]
+    pub(super) recurrence_template: Option<Box<RawValue>>,
+    #[serde(default)]
+    pub(super) recurrence_direct_template: Option<Box<RawValue>>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct PreparedKernelTargetManifest {
+    pub(super) portable: bool,
+    pub(super) word_bits: u8,
+    pub(super) endianness: String,
+    pub(super) target_triple: String,
+    #[serde(default)]
+    pub(super) cpu_features: Vec<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct PreparedKernelManifest {
+    pub(super) kernel_id: u32,
+    pub(super) contract_kind: String,
+    pub(super) canonical_signature: String,
+    pub(super) input_arity: usize,
+    pub(super) output_arity: u32,
+    pub(super) input_layout: Vec<String>,
+    pub(super) input_contracts: Vec<PreparedKernelInputManifest>,
+    pub(super) output_layout: Vec<String>,
+    pub(super) exact_expressions: Vec<String>,
+    #[serde(default)]
+    pub(super) proof_classes: Vec<String>,
+    pub(super) exact_evaluator_state_path: String,
+    pub(super) f64_evaluator_manifest: Value,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerDirectTableManifest {
+    pub(super) capability: String,
+    pub(super) source_application_abi: String,
+    pub(super) descriptor_abi: String,
+    pub(super) binding_abi: String,
+    #[serde(default)]
+    pub(super) descriptor_path: Option<String>,
+    #[serde(default)]
+    pub(super) descriptor_size_bytes: Option<u64>,
+    #[serde(default)]
+    pub(super) descriptor_sha256: Option<String>,
+    #[serde(default)]
+    pub(super) library_path: Option<String>,
+    #[serde(default)]
+    pub(super) function_name: Option<String>,
+    #[serde(default)]
+    pub(super) evaluator_state_sha256: Option<String>,
+    #[serde(default)]
+    pub(super) invocation_stride: Option<u32>,
+    #[serde(default)]
+    pub(super) attachment_stride: Option<u32>,
+    #[serde(default)]
+    pub(super) simd_lane_width: Option<u32>,
+    #[serde(default)]
+    pub(super) instruction_count: Option<u32>,
+    #[serde(default)]
+    pub(super) temporary_count: Option<u32>,
+    pub(super) input_complex_count: u32,
+    pub(super) output_complex_count: u32,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct PreparedKernelVariantManifest {
+    pub(super) variant_id: String,
+    pub(super) variant_abi: String,
+    pub(super) kind: String,
+    pub(super) block_size: u32,
+    pub(super) lane_layout: String,
+    pub(super) base_kernel_id: u32,
+    pub(super) base_canonical_signature: String,
+    pub(super) base_expression_digest: String,
+    pub(super) base_input_contract_digest: String,
+    pub(super) base_output_contract_digest: String,
+    pub(super) backend: String,
+    pub(super) optimization_settings_digest: String,
+    pub(super) input_arity: usize,
+    pub(super) output_arity: usize,
+    pub(super) input_lane_stride: usize,
+    pub(super) output_lane_stride: usize,
+    pub(super) input_layout: Vec<String>,
+    pub(super) output_layout: Vec<String>,
+    pub(super) f64_evaluator_manifest: Value,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct PreparedKernelInputManifest {
+    pub(super) role: String,
+    pub(super) component: u32,
+    pub(super) symbol: String,
+    pub(super) model_parameter_name: Option<String>,
+    pub(super) model_parameter_index: Option<u32>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceDirectTemplateCatalogManifest {
+    pub(super) abi: String,
+    pub(super) backend_abi: String,
+    pub(super) canonicalization_abi: String,
+    pub(super) backend: String,
+    pub(super) target_triple: String,
+    pub(super) portable: bool,
+    pub(super) optimization_level: u32,
+    pub(super) compiled_model_digest: String,
+    pub(super) recurrence_template_catalog_digest: String,
+    pub(super) prepared_kernel_pack_digest: String,
+    pub(super) prepared_kernel_contract_digest: String,
+    pub(super) prepared_kernel_payload_digest: String,
+    pub(super) optimization_settings_digest: String,
+    pub(super) templates: Vec<RecurrenceDirectTemplateManifest>,
+    pub(super) catalog_digest: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceDirectTemplateManifest {
+    pub(super) abi: String,
+    pub(super) template_id: String,
+    pub(super) direct_executor_id: u32,
+    pub(super) evaluator_binding_id: u32,
+    pub(super) evaluator_resolver_key: String,
+    pub(super) role: String,
+    pub(super) parent_arity: u32,
+    pub(super) parent_component_counts: Vec<u32>,
+    pub(super) destination_component_count: u32,
+    pub(super) momentum_operand_count: u32,
+    pub(super) destination_operation: String,
+    pub(super) coupling_slot_count: u32,
+    pub(super) parameter_slot_count: u32,
+    pub(super) semantic_template_ids: Vec<String>,
+    pub(super) exact_expression_digest: String,
+    pub(super) payload_binding: RecurrenceDirectPayloadBindingManifest,
+    pub(super) backend: String,
+    pub(super) target_triple: String,
+    pub(super) portable: bool,
+    pub(super) optimization_level: u32,
+    pub(super) alignment_bytes: u32,
+    pub(super) simd_axis: String,
+    pub(super) destination_aliasing: bool,
+    pub(super) semantic_digest: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceDirectPayloadBindingManifest {
+    pub(super) abi: String,
+    pub(super) kind: String,
+    pub(super) payload_digest: String,
+    pub(super) prepared_kernel_id: Option<u32>,
+    pub(super) runtime_template: Option<String>,
+    pub(super) payload_paths: Vec<String>,
+    pub(super) source_application_path: Option<String>,
+    pub(super) source_application_sha256: Option<String>,
+    pub(super) source_application_abi: Option<String>,
+    pub(super) direct_application_abi: Option<String>,
+    pub(super) native_entry_point: Option<String>,
+    pub(super) role: Option<String>,
+    pub(super) destination_operation: Option<String>,
+    pub(super) exact_factor_scalar_slots: Vec<u32>,
+    pub(super) state_plane_indices: Vec<u32>,
+    pub(super) parameter_bindings: Vec<RecurrenceDirectParameterBindingManifest>,
+    pub(super) input_plane_count: u32,
+    pub(super) scalar_input_count: u32,
+    pub(super) output_alias_inputs: Vec<u32>,
+    pub(super) contribution_parent_permutation: Vec<u8>,
+    pub(super) input_plane_projections: Vec<RecurrenceDirectPlaneProjectionManifest>,
+    pub(super) scalar_projections: Vec<RecurrenceDirectScalarProjectionManifest>,
+    pub(super) intrinsic_contract_digest: Option<String>,
+    pub(super) prepared_template_semantic_digest: Option<String>,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
+pub(super) enum RecurrenceDirectParameterBindingManifest {
+    Plane { index: u32 },
+    Scalar { index: u32 },
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
+pub(super) enum RecurrenceDirectPlaneProjectionManifest {
+    ParentCurrent {
+        parent: u8,
+        component: u16,
+        imaginary: bool,
+    },
+    Momentum {
+        operand: u8,
+        lorentz_component: u16,
+    },
+    DestinationCurrent {
+        component: u16,
+        imaginary: bool,
+    },
+    DestinationAmplitude {
+        component: u16,
+        imaginary: bool,
+    },
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
+pub(super) enum RecurrenceDirectScalarProjectionManifest {
+    ExactFactor {
+        imaginary: bool,
+    },
+    Parameter {
+        index: u32,
+        imaginary: bool,
+    },
+    Literal {
+        value: f64,
+    },
+    #[serde(rename = "intrinsic-scale-v1")]
+    IntrinsicScale {
+        constant_real_bits: u64,
+        constant_imag_bits: u64,
+        parameter_index: Option<u32>,
+    },
+}
+
+impl EagerExecutionManifest {
+    pub(super) fn validate_header(&self) -> RusticolResult<()> {
+        if self.schema_version != PROCESS_ARTIFACT_SCHEMA_VERSION
+            || self.kind != EAGER_EXECUTION_KIND
+        {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported eager execution kind {:?} schema {}; regenerate the artifact",
+                self.kind, self.schema_version
+            )));
+        }
+        if self.eager_plan_abi != EAGER_PLAN_ABI
+            || self.plan.eager_plan_abi != EAGER_PLAN_ABI
+            || self.plan.kind != EAGER_EXECUTION_KIND
+        {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported eager plan ABI {:?}",
+                self.eager_plan_abi
+            )));
+        }
+        if self.plan.process_key != self.key {
+            return Err(RusticolError::integrity(
+                "eager plan process key does not match its execution manifest",
+            ));
+        }
+        if let Some(selector) = &self.plan.selector_closures {
+            if selector.abi != EAGER_SELECTOR_DOMAINS_ABI {
+                return Err(RusticolError::compatibility(format!(
+                    "unsupported eager selector-domain ABI {:?}",
+                    selector.abi
+                )));
+            }
+            if selector.stages.len() != self.plan.stages.len() {
+                return Err(RusticolError::integrity(
+                    "eager selector domains do not cover every execution stage",
+                ));
+            }
+            for (selector_stage, execution_stage) in selector.stages.iter().zip(&self.plan.stages) {
+                if selector_stage.stage_index != execution_stage.stage_index {
+                    return Err(RusticolError::integrity(
+                        "eager selector-domain stage index mismatch",
+                    ));
+                }
+            }
+        }
+        validate_capability_list_match(
+            &self.required_runtime_capabilities,
+            &self.plan.required_runtime_capabilities,
+            "eager execution and plan",
+        )?;
+        let expected_capabilities = if self.lc_topology_replay.is_some() {
+            vec![
+                EAGER_DAG_RUNTIME_CAPABILITY.to_string(),
+                EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY.to_string(),
+            ]
+        } else {
+            vec![EAGER_DAG_RUNTIME_CAPABILITY.to_string()]
+        };
+        if self.required_runtime_capabilities != expected_capabilities {
+            return Err(RusticolError::compatibility(
+                "eager execution runtime capabilities do not match its topology-replay contract",
+            ));
+        }
+        self.runtime_options.validate()?;
+        Ok(())
+    }
+
+    pub(super) fn compiled_metadata_manifest(&self) -> ExecutionManifest {
+        let materialization_census =
+            ExecutionMaterializationCensus::from_summary(&self.dag_summary);
+        ExecutionManifest {
+            schema_version: self.schema_version,
+            kind: "pyamplicol-runtime-execution".to_string(),
+            required_runtime_capabilities: Vec::new(),
+            process: self.process.clone(),
+            key: self.key.clone(),
+            color_accuracy: self.color_accuracy.clone(),
+            external_pdg_order: self.external_pdg_order.clone(),
+            compiled: EvaluatorSetManifest {
+                kind: "eager-runtime-metadata".to_string(),
+                runtime_available: true,
+                runtime_unavailable_message: None,
+                lc_topology_replay: self.lc_topology_replay.clone(),
+                color_topology_replay: None,
+                model_parameter_evaluator: None,
+                stage_evaluators: None,
+                momentum_slot_ids: None,
+            },
+            dag_summary: self.dag_summary.clone(),
+            materialization_census,
+            runtime_schema: self.runtime_schema.clone(),
+            color_contraction_payload: None,
+            physics_reduction: None,
+            helicity_sum_execution: None,
+            helicity_selector_executions: Vec::new(),
+            color_selector_executions: Vec::new(),
+        }
+    }
+
+    pub(super) fn plan_definition(
+        &self,
+        pack: &PreparedKernelPackManifest,
+        prepared_parameter_count: u32,
+    ) -> RusticolResult<EagerPlanDefinition> {
+        let dimensions = EagerPlanDimensions {
+            value_slot_component_counts: contiguous_value_slot_widths(&self.runtime_schema)?,
+            momentum_slot_component_counts: contiguous_momentum_slot_widths(&self.runtime_schema)?,
+            current_component_counts: contiguous_current_slot_widths(&self.runtime_schema)?,
+            parameter_count: prepared_parameter_count,
+            amplitude_count: u32::try_from(self.runtime_schema.amplitude_stage.output_count)
+                .map_err(|_| RusticolError::artifact("eager amplitude count exceeds u32"))?,
+        };
+        let kernels = pack.kernel_specs()?;
+        let direct_closures = self.direct_closure_specs()?;
+        let (reduction_groups, reduction_entries) = self.reduction_plan()?;
+        Ok(EagerPlanDefinition {
+            dimensions,
+            kernels,
+            direct_closures,
+            reduction_groups,
+            reduction_entries,
+        })
+    }
+
+    fn direct_closure_specs(&self) -> RusticolResult<Vec<EagerDirectClosureSpec>> {
+        self.runtime_schema
+            .amplitude_stage
+            .roots
+            .iter()
+            .enumerate()
+            .filter(|(_, root)| root.kind == "direct-contraction")
+            .map(|(index, root)| {
+                let coefficients = root
+                    .contraction_ir
+                    .coefficients
+                    .iter()
+                    .map(|value| crate::EagerComplex64::new(value[0], value[1]))
+                    .collect();
+                Ok(EagerDirectClosureSpec {
+                    closure_index: u32::try_from(index).map_err(|_| {
+                        RusticolError::artifact("eager direct closure index exceeds u32")
+                    })?,
+                    coefficients,
+                })
+            })
+            .collect()
+    }
+
+    fn reduction_plan(
+        &self,
+    ) -> RusticolResult<(Vec<EagerReductionGroup>, Vec<EagerReductionEntry>)> {
+        let (groups, contraction) = self.raw_reduction_runtime()?;
+        let reduction_groups = groups
+            .iter()
+            .map(|group| {
+                Ok(EagerReductionGroup {
+                    coherent_group_id: u32::try_from(group.id).map_err(|_| {
+                        RusticolError::artifact("eager coherent reduction-group ID exceeds u32")
+                    })?,
+                    amplitude_indices: group
+                        .indices
+                        .iter()
+                        .map(|index| {
+                            u32::try_from(*index).map_err(|_| {
+                                RusticolError::artifact(
+                                    "eager reduction amplitude index exceeds u32",
+                                )
+                            })
+                        })
+                        .collect::<RusticolResult<Vec<_>>>()?,
+                })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let mut entries = Vec::new();
+        if let Some(contraction) = contraction {
+            entries
+                .try_reserve_exact(contraction.logical_entry_count()?)
+                .map_err(|error| {
+                    RusticolError::artifact(format!(
+                        "cannot reserve eager color-contraction entries: {error}"
+                    ))
+                })?;
+            for entry in contraction.logical_entries() {
+                let coefficient = crate::EagerComplex64::new(entry.weight_re, entry.weight_im)
+                    * entry.symmetry_factor;
+                entries.push(EagerReductionEntry {
+                    left_group_index: u32::try_from(entry.left_group_index).map_err(|_| {
+                        RusticolError::artifact(
+                            "eager color-contraction left group index exceeds u32",
+                        )
+                    })?,
+                    right_group_index: u32::try_from(entry.right_group_index).map_err(|_| {
+                        RusticolError::artifact(
+                            "eager color-contraction right group index exceeds u32",
+                        )
+                    })?,
+                    coefficient,
+                });
+            }
+        } else {
+            entries.try_reserve_exact(groups.len()).map_err(|error| {
+                RusticolError::artifact(format!(
+                    "cannot reserve eager diagonal reduction entries: {error}"
+                ))
+            })?;
+            for (group_index, group) in groups.iter().enumerate() {
+                let group_index = u32::try_from(group_index)
+                    .map_err(|_| RusticolError::artifact("eager reduction group exceeds u32"))?;
+                entries.push(EagerReductionEntry {
+                    left_group_index: group_index,
+                    right_group_index: group_index,
+                    coefficient: crate::EagerComplex64::new(group.all_sector_weight, 0.0),
+                });
+            }
+        }
+        Ok((reduction_groups, entries))
+    }
+
+    pub(super) fn raw_reduction_runtime(
+        &self,
+    ) -> RusticolResult<(Vec<RawSumGroup>, Option<ColorContractionRuntime>)> {
+        let roots = &self.runtime_schema.amplitude_stage.roots;
+        let output_count = self.runtime_schema.amplitude_stage.output_count;
+        let weights = roots
+            .iter()
+            .map(|root| root.helicity_weight)
+            .collect::<Vec<_>>();
+        let all_sector_weights = roots
+            .iter()
+            .map(|root| root.all_sector_weight.unwrap_or(root.helicity_weight))
+            .collect::<Vec<_>>();
+        let color_sector_ids = roots
+            .iter()
+            .map(|root| root.color_sector_id)
+            .collect::<Vec<_>>();
+        let group_ids = roots
+            .iter()
+            .map(generic_root_group_id)
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let groups = build_raw_sum_groups(
+            output_count,
+            &weights,
+            &all_sector_weights,
+            &group_ids,
+            &color_sector_ids,
+        )?;
+        let contraction = build_color_contraction_runtime(
+            self.runtime_schema
+                .amplitude_stage
+                .color_contraction
+                .as_ref(),
+            &groups,
+        )?;
+        Ok((groups, contraction))
+    }
+}
+
+impl PreparedKernelPackManifest {
+    pub(super) fn validate(&self) -> RusticolResult<()> {
+        if self.eager_kernel_abi != EAGER_KERNEL_ABI {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported eager kernel ABI {:?}",
+                self.eager_kernel_abi
+            )));
+        }
+        if !matches!(self.backend.as_str(), "jit" | "asm" | "cpp") {
+            return Err(RusticolError::artifact(format!(
+                "unsupported prepared backend {:?}",
+                self.backend
+            )));
+        }
+        for (name, value) in [
+            ("optimization_settings", &self.optimization_settings),
+            ("producer", &self.producer),
+            ("dependency_abis", &self.dependency_abis),
+            ("provenance", &self.provenance),
+            ("resolver_manifest", &self.resolver_manifest),
+        ] {
+            if value.as_object().is_none_or(|mapping| mapping.is_empty()) {
+                return Err(RusticolError::artifact(format!(
+                    "prepared kernel pack {name} must be a nonempty object"
+                )));
+            }
+        }
+        if self.resolver_manifest.get("abi").and_then(Value::as_str)
+            != Some("pyamplicol-prepared-kernel-catalog-v1")
+        {
+            return Err(RusticolError::compatibility(
+                "prepared kernel resolver manifest has an unsupported ABI",
+            ));
+        }
+        if self.kernels.is_empty() {
+            return Err(RusticolError::artifact("prepared kernel pack is empty"));
+        }
+        if self.target.word_bits != 64 || self.target.endianness != "little" {
+            return Err(RusticolError::compatibility(
+                "prepared eager kernels require a 64-bit little-endian target",
+            ));
+        }
+        if self
+            .target
+            .cpu_features
+            .windows(2)
+            .any(|pair| pair[0] >= pair[1])
+        {
+            return Err(RusticolError::integrity(
+                "prepared target CPU features must be sorted and unique",
+            ));
+        }
+        if self.backend == "jit" {
+            match std::env::consts::ARCH {
+                "aarch64" | "x86_64" => {}
+                other => {
+                    return Err(RusticolError::compatibility(format!(
+                        "prepared JIT kernels do not support host architecture {other:?}"
+                    )));
+                }
+            }
+            if self
+                .dependency_abis
+                .get("symjit_application")
+                .and_then(Value::as_str)
+                != Some(SYMJIT_APPLICATION_STORAGE_V3_ABI)
+            {
+                return Err(RusticolError::compatibility(
+                    "prepared JIT kernels declare an unsupported SymJIT application ABI",
+                ));
+            }
+            if self
+                .dependency_abis
+                .get("symjit_plane_application")
+                .and_then(Value::as_str)
+                != Some(SYMJIT_PLANE_APPLICATION_V2_ABI)
+            {
+                return Err(RusticolError::compatibility(
+                    "prepared JIT kernels declare an unsupported SymJIT plane-application ABI; regenerate the prepared model",
+                ));
+            }
+            if !self.target.portable
+                || self.target.target_triple != PREPARED_JIT_PORTABLE_TARGET
+                || !self.target.cpu_features.is_empty()
+            {
+                return Err(RusticolError::compatibility(format!(
+                    "prepared JIT kernels target {:?}, expected portable target {:?}",
+                    self.target.target_triple, PREPARED_JIT_PORTABLE_TARGET,
+                )));
+            }
+            if self
+                .optimization_settings
+                .get("jit_optimization_level")
+                .and_then(Value::as_u64)
+                != Some(PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL)
+            {
+                return Err(RusticolError::compatibility(format!(
+                    "prepared JIT kernels must use portable SymJIT optimization level {}",
+                    PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+                )));
+            }
+        } else {
+            let host = crate::runtime_target_info();
+            let host_features = host.cpu_features.into_iter().collect::<BTreeSet<_>>();
+            if self.target.portable
+                || self.target.target_triple != host.triple
+                || self
+                    .target
+                    .cpu_features
+                    .iter()
+                    .any(|feature| !host_features.contains(feature))
+            {
+                return Err(RusticolError::compatibility(format!(
+                    "prepared {} kernels target {:?} with features {:?}, incompatible with host {:?}",
+                    self.backend, self.target.target_triple, self.target.cpu_features, host.triple,
+                )));
+            }
+        }
+        let mut ids = BTreeSet::new();
+        let mut signatures = BTreeSet::new();
+        for kernel in &self.kernels {
+            if !ids.insert(kernel.kernel_id) {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel pack repeats kernel id {}",
+                    kernel.kernel_id
+                )));
+            }
+            if kernel.canonical_signature.is_empty()
+                || !signatures.insert(kernel.canonical_signature.as_str())
+            {
+                return Err(RusticolError::integrity(
+                    "prepared kernel signatures must be nonempty and unique",
+                ));
+            }
+            if kernel.input_arity != kernel.input_contracts.len()
+                || kernel.input_arity != kernel.input_layout.len()
+                || usize::try_from(kernel.output_arity).ok() != Some(kernel.output_layout.len())
+                || usize::try_from(kernel.output_arity).ok() != Some(kernel.exact_expressions.len())
+            {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel {} has inconsistent input/output arities",
+                    kernel.kernel_id
+                )));
+            }
+            if kernel.exact_evaluator_state_path.is_empty() {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel {} lacks exact evaluator state",
+                    kernel.kernel_id
+                )));
+            }
+            if kernel
+                .proof_classes
+                .windows(2)
+                .any(|pair| pair[0] >= pair[1])
+            {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel {} proof classes must be sorted and unique",
+                    kernel.kernel_id
+                )));
+            }
+            if kernel
+                .proof_classes
+                .iter()
+                .any(|proof| proof == EAGER_HOMOGENEOUS_LINEAR_CURRENT_PROOF)
+                && kernel.contract_kind != "propagator"
+            {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel {} applies a current-linearity proof to {:?}",
+                    kernel.kernel_id, kernel.contract_kind
+                )));
+            }
+            if kernel
+                .proof_classes
+                .iter()
+                .any(|proof| proof == PREPARED_INDEPENDENT_BLOCK_PROOF)
+                && (kernel.contract_kind != "vertex"
+                    || kernel.input_contracts.iter().any(|input| {
+                        !matches!(input.role.as_str(), "left-current" | "right-current")
+                    }))
+            {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel {} applies an independent-block proof to a non-current vertex",
+                    kernel.kernel_id
+                )));
+            }
+            kernel.validate_evaluator_metadata(self)?;
+        }
+        if self.backend != "jit" && !self.kernel_variants.is_empty() {
+            return Err(RusticolError::integrity(
+                "prepared C++/ASM packs cannot contain JIT block variants",
+            ));
+        }
+        let kernels_by_id = self
+            .kernels
+            .iter()
+            .map(|kernel| (kernel.kernel_id, kernel))
+            .collect::<BTreeMap<_, _>>();
+        let mut variant_keys = BTreeSet::new();
+        let mut variant_bases = BTreeSet::new();
+        for variant in &self.kernel_variants {
+            if !variant_keys.insert((variant.base_kernel_id, variant.variant_id.as_str())) {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel pack repeats variant {:?} for kernel {}",
+                    variant.variant_id, variant.base_kernel_id
+                )));
+            }
+            if !variant_bases.insert(variant.base_kernel_id) {
+                return Err(RusticolError::integrity(format!(
+                    "prepared kernel {} has more than one block variant",
+                    variant.base_kernel_id
+                )));
+            }
+            let base = kernels_by_id.get(&variant.base_kernel_id).ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "prepared variant {:?} references missing kernel {}",
+                    variant.variant_id, variant.base_kernel_id
+                ))
+            })?;
+            variant.validate(self, base)?;
+        }
+        Ok(())
+    }
+
+    /// Parse and authenticate the optional Direct-Arena recurrence companion.
+    ///
+    /// Eager execution deliberately does not require this companion. Recurrence
+    /// loading calls this method with the digests authenticated by its process
+    /// manifest and plan before resolving any executable payload.
+    pub(super) fn recurrence_direct_template_catalog(
+        &self,
+        expected_prepared_pack_digest: &str,
+        expected_catalog_digest: &str,
+    ) -> RusticolResult<RecurrenceDirectTemplateCatalogManifest> {
+        let raw = self.recurrence_direct_template.as_ref().ok_or_else(|| {
+            RusticolError::compatibility(
+                "prepared model has no Direct-Arena recurrence template catalog; recompile the model",
+            )
+        })?;
+        self.parse_recurrence_direct_template_catalog(
+            raw.get(),
+            expected_prepared_pack_digest,
+            expected_catalog_digest,
+        )
+    }
+
+    pub(super) fn take_recurrence_direct_template_catalog(
+        &mut self,
+        expected_prepared_pack_digest: &str,
+        expected_catalog_digest: &str,
+    ) -> RusticolResult<RecurrenceDirectTemplateCatalogManifest> {
+        let raw = self.recurrence_direct_template.take().ok_or_else(|| {
+            RusticolError::compatibility(
+                "prepared model has no Direct-Arena recurrence template catalog; recompile the model",
+            )
+        })?;
+        self.parse_recurrence_direct_template_catalog(
+            raw.get(),
+            expected_prepared_pack_digest,
+            expected_catalog_digest,
+        )
+    }
+
+    fn parse_recurrence_direct_template_catalog(
+        &self,
+        raw: &str,
+        expected_prepared_pack_digest: &str,
+        expected_catalog_digest: &str,
+    ) -> RusticolResult<RecurrenceDirectTemplateCatalogManifest> {
+        let raw: Value = serde_json::from_str(raw).map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not parse prepared Direct-Arena recurrence template catalog: {error}"
+            ))
+        })?;
+        let catalog =
+            RecurrenceDirectTemplateCatalogManifest::deserialize(&raw).map_err(|error| {
+                RusticolError::serialization(format!(
+                    "could not parse prepared Direct-Arena recurrence template catalog: {error}"
+                ))
+            })?;
+        catalog.validate(
+            &raw,
+            self,
+            expected_prepared_pack_digest,
+            expected_catalog_digest,
+        )?;
+        Ok(catalog)
+    }
+
+    pub(super) fn kernel_specs(&self) -> RusticolResult<Vec<EagerKernelSpec>> {
+        let block_sizes = self
+            .kernel_variants
+            .iter()
+            .map(|variant| (variant.base_kernel_id, variant.block_size))
+            .collect::<BTreeMap<_, _>>();
+        self.kernels
+            .iter()
+            .filter(|kernel| kernel.contract_kind != "model-parameter")
+            .map(|kernel| {
+                let role = match kernel.contract_kind.as_str() {
+                    "vertex" => EagerKernelRole::Vertex,
+                    "propagator" => EagerKernelRole::Finalization,
+                    "closure" => EagerKernelRole::Closure,
+                    other => {
+                        return Err(RusticolError::artifact(format!(
+                            "unsupported prepared kernel contract kind {other:?}"
+                        )));
+                    }
+                };
+                let inputs = kernel
+                    .input_contracts
+                    .iter()
+                    .map(PreparedKernelInputManifest::to_eager_input)
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                Ok(EagerKernelSpec {
+                    kernel_id: kernel.kernel_id,
+                    role,
+                    inputs,
+                    output_component_count: kernel.output_arity,
+                    homogeneous_linear_first_current: kernel
+                        .proof_classes
+                        .iter()
+                        .any(|proof| proof == EAGER_HOMOGENEOUS_LINEAR_CURRENT_PROOF),
+                    independent_block_size: block_sizes
+                        .get(&kernel.kernel_id)
+                        .copied()
+                        .unwrap_or(1),
+                })
+            })
+            .collect()
+    }
+
+    pub(super) fn validate_portable_process_artifact_target(
+        &self,
+        outer_target: &crate::Target,
+        context: &str,
+    ) -> RusticolResult<()> {
+        if outer_target.triple != crate::artifact::PORTABLE_64LE_ARTIFACT_TARGET {
+            return Ok(());
+        }
+        let optimization_level = self
+            .optimization_settings
+            .get("jit_optimization_level")
+            .and_then(Value::as_u64);
+        if !outer_target.cpu_features.is_empty()
+            || self.backend != "jit"
+            || !self.target.portable
+            || self.target.target_triple != PREPARED_JIT_PORTABLE_TARGET
+            || !self.target.cpu_features.is_empty()
+            || optimization_level != Some(PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL)
+        {
+            return Err(RusticolError::compatibility(format!(
+                "portable-64le {context} artifacts require an authenticated portable O2 SymJIT prepared kernel pack; C++ and ASM packs remain target-specific"
+            )));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceDirectTemplateCatalogManifest {
+    fn validate(
+        &self,
+        raw: &Value,
+        pack: &PreparedKernelPackManifest,
+        expected_prepared_pack_digest: &str,
+        expected_catalog_digest: &str,
+    ) -> RusticolResult<()> {
+        if self.abi != RECURRENCE_DIRECT_TEMPLATE_ABI_V1
+            || self.backend_abi != RECURRENCE_DIRECT_BACKEND_ABI_V1
+            || self.canonicalization_abi != RECURRENCE_DIRECT_CANONICALIZATION_ABI_V1
+        {
+            return Err(RusticolError::compatibility(
+                "prepared Direct-Arena recurrence catalog has an unsupported ABI",
+            ));
+        }
+        validate_sha256_text(&self.catalog_digest, "Direct-Arena catalog digest")?;
+        validate_sha256_text(
+            &self.prepared_kernel_pack_digest,
+            "Direct-Arena prepared-pack digest",
+        )?;
+        for (name, digest) in [
+            ("compiled-model", self.compiled_model_digest.as_str()),
+            (
+                "recurrence-template catalog",
+                self.recurrence_template_catalog_digest.as_str(),
+            ),
+            (
+                "prepared-kernel contract",
+                self.prepared_kernel_contract_digest.as_str(),
+            ),
+            (
+                "prepared-kernel payload",
+                self.prepared_kernel_payload_digest.as_str(),
+            ),
+            (
+                "optimization-settings",
+                self.optimization_settings_digest.as_str(),
+            ),
+        ] {
+            validate_sha256_text(digest, &format!("Direct-Arena {name} digest"))?;
+        }
+        if self.catalog_digest != expected_catalog_digest
+            || self.prepared_kernel_pack_digest != expected_prepared_pack_digest
+        {
+            return Err(RusticolError::integrity(
+                "prepared Direct-Arena catalog identity does not match the recurrence artifact",
+            ));
+        }
+        if pack
+            .provenance
+            .get("prepared_kernel_pack_digest")
+            .and_then(Value::as_str)
+            != Some(expected_prepared_pack_digest)
+            || pack
+                .provenance
+                .get("direct_template_catalog_digest")
+                .and_then(Value::as_str)
+                != Some(expected_catalog_digest)
+        {
+            return Err(RusticolError::integrity(
+                "prepared kernel-pack provenance does not authenticate the Direct-Arena catalog",
+            ));
+        }
+        if self.backend != pack.backend
+            || self.target_triple != pack.target.target_triple
+            || self.portable != pack.target.portable
+        {
+            return Err(RusticolError::integrity(
+                "Direct-Arena catalog backend or target does not match its prepared kernel pack",
+            ));
+        }
+        if self.backend == "jit" {
+            if !self.portable
+                || self.optimization_level != PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL as u32
+                || self.target_triple != PREPARED_JIT_PORTABLE_TARGET
+            {
+                return Err(RusticolError::compatibility(
+                    "Direct-Arena JIT templates require portable SymJIT O2 applications",
+                ));
+            }
+        } else if self.portable {
+            return Err(RusticolError::compatibility(
+                "Direct-Arena C++/ASM templates must be target-native",
+            ));
+        }
+        let mut semantic = raw.clone();
+        semantic
+            .as_object_mut()
+            .ok_or_else(|| RusticolError::artifact("Direct-Arena catalog must be an object"))?
+            .remove("catalog_digest");
+        if canonical_json_digest_exact(&semantic)? != self.catalog_digest {
+            return Err(RusticolError::integrity(
+                "Direct-Arena catalog digest does not match its canonical metadata",
+            ));
+        }
+        if self.templates.is_empty() {
+            return Err(RusticolError::artifact(
+                "Direct-Arena template catalog is empty",
+            ));
+        }
+        let raw_templates = raw
+            .get("templates")
+            .and_then(Value::as_array)
+            .ok_or_else(|| RusticolError::artifact("Direct-Arena templates must be an array"))?;
+        if raw_templates.len() != self.templates.len() {
+            return Err(RusticolError::integrity(
+                "Direct-Arena template count changed while parsing",
+            ));
+        }
+        let kernels = pack
+            .kernels
+            .iter()
+            .map(|kernel| (kernel.kernel_id, kernel))
+            .collect::<BTreeMap<_, _>>();
+        let mut template_ids = BTreeSet::new();
+        let mut binding_keys = BTreeSet::new();
+        for (expected_id, (template, raw_template)) in
+            self.templates.iter().zip(raw_templates).enumerate()
+        {
+            if template.direct_executor_id as usize != expected_id {
+                return Err(RusticolError::integrity(
+                    "Direct-Arena executor IDs must be dense and zero-based",
+                ));
+            }
+            if !template_ids.insert(template.template_id.as_str())
+                || !binding_keys.insert((template.role.as_str(), template.evaluator_binding_id))
+            {
+                return Err(RusticolError::integrity(
+                    "Direct-Arena template IDs and semantic binding keys must be unique",
+                ));
+            }
+            template.validate(raw_template, self, &kernels)?;
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceDirectTemplateManifest {
+    fn validate(
+        &self,
+        raw: &Value,
+        catalog: &RecurrenceDirectTemplateCatalogManifest,
+        kernels: &BTreeMap<u32, &PreparedKernelManifest>,
+    ) -> RusticolResult<()> {
+        if self.abi != RECURRENCE_DIRECT_TEMPLATE_ABI_V1
+            || self.backend != catalog.backend
+            || self.target_triple != catalog.target_triple
+            || self.portable != catalog.portable
+            || self.optimization_level != catalog.optimization_level
+        {
+            return Err(RusticolError::integrity(
+                "Direct-Arena template policy does not match its catalog",
+            ));
+        }
+        if self.template_id.is_empty()
+            || self.evaluator_resolver_key.is_empty()
+            || self.semantic_template_ids.is_empty()
+            || self.parent_arity as usize != self.parent_component_counts.len()
+            || self.parent_component_counts.contains(&0)
+            || self.destination_component_count == 0
+            || self.alignment_bytes == 0
+            || !self.alignment_bytes.is_power_of_two()
+            || self.simd_axis != "points-contiguous"
+        {
+            return Err(RusticolError::artifact(
+                "Direct-Arena template has an invalid shape or SIMD contract",
+            ));
+        }
+        if self
+            .semantic_template_ids
+            .windows(2)
+            .any(|pair| pair[0] >= pair[1])
+        {
+            return Err(RusticolError::integrity(
+                "Direct-Arena semantic template IDs must be sorted and unique",
+            ));
+        }
+        validate_sha256_text(
+            &self.exact_expression_digest,
+            "Direct-Arena exact-expression digest",
+        )?;
+        validate_sha256_text(&self.semantic_digest, "Direct-Arena template digest")?;
+        let expected_operation = expected_direct_operation(&self.role)?;
+        if self.destination_operation != expected_operation
+            || self.destination_aliasing != (self.role == "finalization")
+        {
+            return Err(RusticolError::integrity(
+                "Direct-Arena destination operation or aliasing does not match its role",
+            ));
+        }
+        self.payload_binding
+            .validate(self, raw.get("payload_binding"), kernels)
+    }
+}
+
+impl RecurrenceDirectPayloadBindingManifest {
+    fn validate(
+        &self,
+        template: &RecurrenceDirectTemplateManifest,
+        raw: Option<&Value>,
+        kernels: &BTreeMap<u32, &PreparedKernelManifest>,
+    ) -> RusticolResult<()> {
+        if self.abi != RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI_V2 {
+            return Err(RusticolError::compatibility(format!(
+                "Direct-Arena payload binding ABI {:?} is unsupported; regenerate the prepared model with this pyAmpliCol version",
+                self.abi
+            )));
+        }
+        validate_sha256_text(&self.payload_digest, "Direct-Arena payload digest")?;
+        if !matches!(
+            self.contribution_parent_permutation.as_slice(),
+            [0, 1] | [1, 0]
+        ) || (self.contribution_parent_permutation.as_slice() != [0, 1]
+            && !(self.kind == "rusticol-intrinsic" && template.role == "contribution"))
+        {
+            return Err(RusticolError::integrity(
+                "Direct-Arena payload binding has an invalid parent permutation",
+            ));
+        }
+        match self.kind.as_str() {
+            "rusticol-intrinsic" => {
+                let runtime_template = self.runtime_template.as_deref().ok_or_else(|| {
+                    RusticolError::artifact("Direct-Arena intrinsic has no runtime template")
+                })?;
+                let prepared_metadata_present = self.prepared_kernel_id.is_some()
+                    || !self.payload_paths.is_empty()
+                    || self.source_application_path.is_some()
+                    || self.source_application_sha256.is_some()
+                    || self.source_application_abi.is_some()
+                    || self.direct_application_abi.is_some()
+                    || self.native_entry_point.is_some()
+                    || !self.exact_factor_scalar_slots.is_empty()
+                    || !self.state_plane_indices.is_empty()
+                    || !self.parameter_bindings.is_empty()
+                    || self.input_plane_count != 0
+                    || !self.output_alias_inputs.is_empty()
+                    || !self.input_plane_projections.is_empty()
+                    || self.prepared_template_semantic_digest.is_some();
+                if prepared_metadata_present {
+                    return Err(RusticolError::integrity(
+                        "Rusticol Direct-Arena intrinsics carry prepared-call metadata",
+                    ));
+                }
+                if template.role == "contribution" {
+                    if self.role.as_deref() != Some("contribution")
+                        || self.destination_operation.as_deref() != Some("add")
+                        || self.scalar_input_count != 1
+                        || self.scalar_projections.len() != 1
+                        || !matches!(
+                            self.scalar_projections.first(),
+                            Some(RecurrenceDirectScalarProjectionManifest::IntrinsicScale { .. })
+                        )
+                    {
+                        return Err(RusticolError::integrity(
+                            "Direct-Arena contribution intrinsic metadata is inconsistent",
+                        ));
+                    }
+                    validate_sha256_text(
+                        self.intrinsic_contract_digest
+                            .as_deref()
+                            .unwrap_or_default(),
+                        "Direct-Arena intrinsic contract digest",
+                    )?;
+                    RecurrenceContributionIntrinsicKind::from_runtime_template(runtime_template)?;
+                } else if self.role.is_some()
+                    || self.destination_operation.is_some()
+                    || self.scalar_input_count != 0
+                    || !self.scalar_projections.is_empty()
+                    || self.intrinsic_contract_digest.is_some()
+                {
+                    return Err(RusticolError::integrity(
+                        "non-contribution Direct-Arena intrinsic carries contribution metadata",
+                    ));
+                } else if !match template.role.as_str() {
+                    "source" => runtime_template.starts_with("rusticol.source-fill."),
+                    "finalization" => matches!(
+                        runtime_template,
+                        "rusticol.identity-finalize-in-place.v1"
+                            | WEYL_PROPAGATOR_POSITIVE_TEMPLATE
+                            | WEYL_PROPAGATOR_NEGATIVE_TEMPLATE
+                            | FEYNMAN_VECTOR_PROPAGATOR_TEMPLATE
+                    ),
+                    "closure" => runtime_template.starts_with("rusticol.closure-reduce.v1:"),
+                    _ => false,
+                } {
+                    return Err(RusticolError::compatibility(format!(
+                        "unsupported Direct-Arena intrinsic {runtime_template:?} for role {:?}",
+                        template.role
+                    )));
+                }
+            }
+            "prepared-direct-call" => {
+                if self.runtime_template.is_some()
+                    || self.intrinsic_contract_digest.is_some()
+                    || self.role.as_deref() != Some(template.role.as_str())
+                    || self.destination_operation.as_deref()
+                        != Some(template.destination_operation.as_str())
+                    || self.exact_factor_scalar_slots != [0, 1]
+                    || self.input_plane_count as usize != self.input_plane_projections.len()
+                    || self.scalar_input_count as usize != self.scalar_projections.len()
+                {
+                    return Err(RusticolError::integrity(
+                        "prepared Direct-Arena callable metadata is inconsistent",
+                    ));
+                }
+                let kernel_id = self.prepared_kernel_id.ok_or_else(|| {
+                    RusticolError::artifact("prepared Direct-Arena callable has no kernel ID")
+                })?;
+                let kernel = kernels.get(&kernel_id).ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "Direct-Arena callable references absent prepared kernel {kernel_id}"
+                    ))
+                })?;
+                let source_path = self.source_application_path.as_deref().ok_or_else(|| {
+                    RusticolError::artifact("Direct-Arena callable has no source application")
+                })?;
+                if self.payload_paths.len() != 1 || self.payload_paths[0] != source_path {
+                    return Err(RusticolError::integrity(
+                        "Direct-Arena callable must reference exactly its source application",
+                    ));
+                }
+                validate_sha256_text(
+                    self.source_application_sha256
+                        .as_deref()
+                        .unwrap_or_default(),
+                    "Direct-Arena source application digest",
+                )?;
+                validate_sha256_text(
+                    self.prepared_template_semantic_digest
+                        .as_deref()
+                        .unwrap_or_default(),
+                    "Direct-Arena prepared-template digest",
+                )?;
+                let evaluator = kernel.f64_evaluator_manifest.as_object().ok_or_else(|| {
+                    RusticolError::artifact("prepared kernel evaluator metadata is not an object")
+                })?;
+                match template.backend.as_str() {
+                    "jit" => {
+                        let plane = evaluator
+                            .get("plane_application")
+                            .and_then(Value::as_object)
+                            .ok_or_else(|| {
+                                RusticolError::artifact(
+                                    "prepared JIT kernel has no SymJIT plane application",
+                                )
+                            })?;
+                        if self.direct_application_abi.as_deref()
+                            != Some(SYMJIT_PLANE_APPLICATION_V2_ABI)
+                            || self.source_application_abi.as_deref()
+                                != Some(SYMJIT_PLANE_APPLICATION_V2_ABI)
+                            || self.native_entry_point.is_some()
+                            || plane.get("application_path").and_then(Value::as_str)
+                                != Some(source_path)
+                            || plane.get("application_abi").and_then(Value::as_str)
+                                != self.source_application_abi.as_deref()
+                            || plane.get("storage_abi").and_then(Value::as_str)
+                                != Some(SYMJIT_APPLICATION_STORAGE_V3_ABI)
+                            || plane.get("optimization_level").and_then(Value::as_u64)
+                                != Some(PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL)
+                            || !self.state_plane_indices.is_empty()
+                            || !self.parameter_bindings.len().is_multiple_of(2)
+                            || !self.output_alias_inputs.len().is_multiple_of(2)
+                        {
+                            return Err(RusticolError::integrity(
+                                "Direct-Arena callable source does not match its portable O2 SymJIT plane kernel",
+                            ));
+                        }
+                    }
+                    backend @ ("cpp" | "asm") => {
+                        let expected_source_abi = match backend {
+                            "cpp" => SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY,
+                            "asm" => SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY,
+                            _ => unreachable!("native Direct-Arena backend was matched above"),
+                        };
+                        let expected_entry_point = format!(
+                            "pyamplicol_recurrence_direct_{}_k{kernel_id:08x}_v1",
+                            template.role
+                        );
+                        if self.direct_application_abi.as_deref()
+                            != Some(NATIVE_DIRECT_APPLICATION_V1_ABI)
+                            || self.source_application_abi.as_deref() != Some(expected_source_abi)
+                            || self.native_entry_point.as_deref()
+                                != Some(expected_entry_point.as_str())
+                            || evaluator.get("kind").and_then(Value::as_str)
+                                != Some("compiled-complex-evaluator")
+                            || evaluator.get("library_path").and_then(Value::as_str)
+                                != Some(source_path)
+                        {
+                            return Err(RusticolError::integrity(
+                                "Direct-Arena callable source does not match its target-native prepared kernel",
+                            ));
+                        }
+                    }
+                    other => {
+                        return Err(RusticolError::compatibility(format!(
+                            "unsupported Direct-Arena prepared-call backend {other:?}"
+                        )));
+                    }
+                }
+                if self
+                    .state_plane_indices
+                    .iter()
+                    .chain(&self.output_alias_inputs)
+                    .any(|index| *index >= self.input_plane_count)
+                {
+                    return Err(RusticolError::integrity(
+                        "Direct-Arena callable plane metadata is out of bounds",
+                    ));
+                }
+                for binding in &self.parameter_bindings {
+                    let (index, limit) = match *binding {
+                        RecurrenceDirectParameterBindingManifest::Plane { index } => {
+                            (index, self.input_plane_count)
+                        }
+                        RecurrenceDirectParameterBindingManifest::Scalar { index } => {
+                            (index, self.scalar_input_count)
+                        }
+                    };
+                    if index >= limit {
+                        return Err(RusticolError::integrity(
+                            "Direct-Arena parameter binding is out of bounds",
+                        ));
+                    }
+                }
+                for projection in &self.input_plane_projections {
+                    let valid = match *projection {
+                        RecurrenceDirectPlaneProjectionManifest::ParentCurrent {
+                            parent,
+                            component,
+                            ..
+                        } => template
+                            .parent_component_counts
+                            .get(parent as usize)
+                            .is_some_and(|count| u32::from(component) < *count),
+                        RecurrenceDirectPlaneProjectionManifest::Momentum {
+                            operand,
+                            lorentz_component,
+                        } => {
+                            u32::from(operand) < template.momentum_operand_count
+                                && lorentz_component < 4
+                        }
+                        RecurrenceDirectPlaneProjectionManifest::DestinationCurrent {
+                            component,
+                            ..
+                        }
+                        | RecurrenceDirectPlaneProjectionManifest::DestinationAmplitude {
+                            component,
+                            ..
+                        } => u32::from(component) < template.destination_component_count,
+                    };
+                    if !valid {
+                        return Err(RusticolError::integrity(
+                            "Direct-Arena input-plane projection is outside its template shape",
+                        ));
+                    }
+                }
+                if !matches!(
+                    self.scalar_projections.first(),
+                    Some(RecurrenceDirectScalarProjectionManifest::ExactFactor {
+                        imaginary: false
+                    })
+                ) || !matches!(
+                    self.scalar_projections.get(1),
+                    Some(RecurrenceDirectScalarProjectionManifest::ExactFactor { imaginary: true })
+                ) {
+                    return Err(RusticolError::integrity(
+                        "Direct-Arena scalar slots 0 and 1 must project the exact complex factor",
+                    ));
+                }
+                let _raw = raw.ok_or_else(|| {
+                    RusticolError::artifact("Direct-Arena payload binding is absent")
+                })?;
+            }
+            "pending-direct-call-abi" => {
+                return Err(RusticolError::compatibility(
+                    "prepared Direct-Arena callable is not executable; recompile with a supported backend",
+                ));
+            }
+            other => {
+                return Err(RusticolError::compatibility(format!(
+                    "unsupported Direct-Arena payload binding kind {other:?}"
+                )));
+            }
+        }
+        Ok(())
+    }
+}
+
+fn expected_direct_operation(role: &str) -> RusticolResult<&'static str> {
+    match role {
+        "source" => Ok("initialize"),
+        "contribution" => Ok("add"),
+        "finalization" => Ok("finalize-in-place"),
+        "closure" => Ok("closure-add"),
+        other => Err(RusticolError::compatibility(format!(
+            "unsupported Direct-Arena executor role {other:?}"
+        ))),
+    }
+}
+
+fn validate_sha256_text(value: &str, label: &str) -> RusticolResult<()> {
+    if value.len() != 64
+        || !value
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+    {
+        return Err(RusticolError::artifact(format!(
+            "{label} must be a lowercase SHA-256 digest"
+        )));
+    }
+    Ok(())
+}
+
+impl PreparedKernelManifest {
+    pub(super) fn runtime_evaluator_manifest(&self) -> RusticolResult<EvaluatorManifest> {
+        let object = self.f64_evaluator_manifest.as_object().ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "prepared kernel {} f64 evaluator manifest must be an object",
+                self.kernel_id
+            ))
+        })?;
+        let kind = object.get("kind").and_then(Value::as_str).ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "prepared kernel {} f64 evaluator kind must be a nonempty string",
+                self.kernel_id
+            ))
+        })?;
+        let metadata_fields: &[&str] = match kind {
+            "symjit-application-evaluator" => &[
+                "backend",
+                "label",
+                "settings",
+                "build_timing",
+                "direct_table",
+            ],
+            "compiled-complex-evaluator" => &[
+                "backend",
+                "settings",
+                "source_path",
+                "build_timing",
+                "direct_table",
+            ],
+            other => {
+                return Err(RusticolError::compatibility(format!(
+                    "prepared kernel {} has unsupported f64 evaluator kind {other:?}",
+                    self.kernel_id
+                )));
+            }
+        };
+        validate_prepared_evaluator_keys(self.kernel_id, kind, object)?;
+        let mut runtime = object.clone();
+        for field in metadata_fields {
+            runtime.remove(*field);
+        }
+        serde_json::from_value(Value::Object(runtime)).map_err(|error| {
+            RusticolError::serialization(format!(
+                "prepared kernel {} has invalid runtime evaluator metadata: {error}",
+                self.kernel_id
+            ))
+        })
+    }
+
+    pub(super) fn extra_evaluator_payload_paths(&self) -> RusticolResult<Vec<&str>> {
+        let object = self.f64_evaluator_manifest.as_object().ok_or_else(|| {
+            RusticolError::artifact("prepared f64 evaluator manifest must be an object")
+        })?;
+        match object.get("kind").and_then(Value::as_str) {
+            Some("symjit-application-evaluator") => {
+                let Some(direct) = object.get("direct_table") else {
+                    return Ok(Vec::new());
+                };
+                let direct = direct.as_object().ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "prepared kernel {} DirectTable metadata must be an object",
+                        self.kernel_id
+                    ))
+                })?;
+                if let Some(path) = direct.get("descriptor_path") {
+                    Ok(vec![path.as_str().ok_or_else(|| {
+                        RusticolError::artifact(format!(
+                            "prepared kernel {} DirectTable descriptor path must be text",
+                            self.kernel_id
+                        ))
+                    })?])
+                } else if let Some(path) = direct.get("library_path") {
+                    Ok(vec![path.as_str().ok_or_else(|| {
+                        RusticolError::artifact(format!(
+                            "prepared kernel {} DirectTable library path must be text",
+                            self.kernel_id
+                        ))
+                    })?])
+                } else {
+                    Err(RusticolError::artifact(format!(
+                        "prepared kernel {} DirectTable has no payload path",
+                        self.kernel_id
+                    )))
+                }
+            }
+            Some("compiled-complex-evaluator") => {
+                let direct = object.get("direct_table").and_then(Value::as_object);
+                let mut paths = vec![required_nonempty_string(
+                    object,
+                    "source_path",
+                    self.kernel_id,
+                )?];
+                if let Some(direct) = direct {
+                    paths.push(required_nonempty_string(
+                        direct,
+                        "library_path",
+                        self.kernel_id,
+                    )?);
+                }
+                Ok(paths)
+            }
+            _ => Err(RusticolError::compatibility(format!(
+                "prepared kernel {} has an unsupported f64 evaluator kind",
+                self.kernel_id
+            ))),
+        }
+    }
+
+    pub(super) fn eager_direct_table_manifest(&self) -> RusticolResult<EagerDirectTableManifest> {
+        let object = self.f64_evaluator_manifest.as_object().ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "prepared kernel {} f64 evaluator manifest must be an object",
+                self.kernel_id
+            ))
+        })?;
+        let raw = object.get("direct_table").ok_or_else(|| {
+            RusticolError::compatibility(format!(
+                "prepared eager kernel {} predates {:?}; regenerate the artifact with the \
+                 current `pyamplicol generate`",
+                self.kernel_id,
+                crate::eager_layout::EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            ))
+        })?;
+        let direct: EagerDirectTableManifest =
+            serde_json::from_value(raw.clone()).map_err(|error| {
+                RusticolError::serialization(format!(
+                    "prepared eager kernel {} has invalid DirectTable metadata: {error}",
+                    self.kernel_id
+                ))
+            })?;
+        if direct.capability != crate::eager_layout::EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY
+            || !matches!(
+                direct.source_application_abi.as_str(),
+                crate::eager_layout::EAGER_DIRECT_SOURCE_APPLICATION_ABI
+                    | crate::eager_layout::EAGER_NATIVE_DIRECT_TABLE_APPLICATION_ABI
+            )
+            || direct.descriptor_abi != crate::eager_layout::EAGER_DIRECT_TABLE_DESCRIPTOR_ABI
+            || direct.binding_abi != crate::eager_layout::EAGER_DIRECT_TABLE_BINDING_ABI
+        {
+            return Err(RusticolError::compatibility(format!(
+                "prepared eager kernel {} has an unsupported DirectTable ABI contract; \
+                 regenerate the artifact with the current `pyamplicol generate`",
+                self.kernel_id
+            )));
+        }
+        match direct.source_application_abi.as_str() {
+            crate::eager_layout::EAGER_DIRECT_SOURCE_APPLICATION_ABI => {
+                if direct.descriptor_path.as_deref().is_none_or(str::is_empty) {
+                    return Err(RusticolError::artifact(format!(
+                        "prepared eager kernel {} DirectTable descriptor path is empty",
+                        self.kernel_id
+                    )));
+                }
+                let size = direct.descriptor_size_bytes.unwrap_or(0);
+                if size == 0 {
+                    return Err(RusticolError::artifact(format!(
+                        "prepared eager kernel {} DirectTable descriptor must not be empty",
+                        self.kernel_id
+                    )));
+                }
+                validate_sha256_text(
+                    direct.descriptor_sha256.as_deref().unwrap_or_default(),
+                    "eager DirectTable descriptor digest",
+                )?;
+            }
+            crate::eager_layout::EAGER_NATIVE_DIRECT_TABLE_APPLICATION_ABI => {
+                if direct.library_path.as_deref().is_none_or(str::is_empty)
+                    || direct.function_name.as_deref().is_none_or(str::is_empty)
+                    || direct.invocation_stride.unwrap_or(0) == 0
+                    || direct.attachment_stride.unwrap_or(0) == 0
+                    || !matches!(direct.simd_lane_width, Some(2 | 4))
+                {
+                    return Err(RusticolError::artifact(format!(
+                        "prepared eager kernel {} native DirectTable metadata is incomplete",
+                        self.kernel_id
+                    )));
+                }
+                validate_sha256_text(
+                    direct.evaluator_state_sha256.as_deref().unwrap_or_default(),
+                    "eager native DirectTable evaluator-state digest",
+                )?;
+            }
+            _ => unreachable!("source ABI admitted above"),
+        }
+        if usize::try_from(direct.input_complex_count).ok() != Some(self.input_arity)
+            || direct.output_complex_count != self.output_arity
+        {
+            return Err(RusticolError::integrity(format!(
+                "prepared eager kernel {} DirectTable I/O ({}, {}) does not match ({}, {})",
+                self.kernel_id,
+                direct.input_complex_count,
+                direct.output_complex_count,
+                self.input_arity,
+                self.output_arity,
+            )));
+        }
+        Ok(direct)
+    }
+
+    fn validate_evaluator_metadata(&self, pack: &PreparedKernelPackManifest) -> RusticolResult<()> {
+        let object = self.f64_evaluator_manifest.as_object().ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "prepared kernel {} f64 evaluator manifest must be an object",
+                self.kernel_id
+            ))
+        })?;
+        let kind = required_nonempty_string(object, "kind", self.kernel_id)?;
+        let backend = required_nonempty_string(object, "backend", self.kernel_id)?;
+        let (expected_kind, expected_backend, expected_capability) = match pack.backend.as_str() {
+            "jit" => (
+                "symjit-application-evaluator",
+                "jit",
+                SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+            ),
+            "asm" => (
+                "compiled-complex-evaluator",
+                "compiled-complex",
+                SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY,
+            ),
+            "cpp" => (
+                "compiled-complex-evaluator",
+                "compiled-complex",
+                SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY,
+            ),
+            _ => unreachable!("prepared pack backend validated before its kernels"),
+        };
+        if kind != expected_kind || backend != expected_backend {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} evaluator ({kind:?}, {backend:?}) does not match pack backend {:?}, expected ({expected_kind:?}, {expected_backend:?})",
+                self.kernel_id, pack.backend,
+            )));
+        }
+        let settings = object.get("settings").ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "prepared kernel {} evaluator lacks settings metadata",
+                self.kernel_id
+            ))
+        })?;
+        if settings != &pack.optimization_settings {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} evaluator settings do not match its pack",
+                self.kernel_id
+            )));
+        }
+        let build_timing = object
+            .get("build_timing")
+            .and_then(Value::as_object)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "prepared kernel {} evaluator build_timing must be an object",
+                    self.kernel_id
+                ))
+            })?;
+        if build_timing.values().any(|value| {
+            value
+                .as_f64()
+                .is_none_or(|seconds| !seconds.is_finite() || seconds < 0.0)
+        }) {
+            return Err(RusticolError::artifact(format!(
+                "prepared kernel {} evaluator build timings must be finite nonnegative numbers",
+                self.kernel_id
+            )));
+        }
+        if kind == "symjit-application-evaluator" {
+            validate_prepared_symjit_plane_application(
+                self.kernel_id,
+                object,
+                self.input_arity,
+                usize::try_from(self.output_arity).unwrap_or(usize::MAX),
+                PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL as u8,
+            )?;
+        }
+        let runtime = self.runtime_evaluator_manifest()?;
+        let capabilities = evaluator_runtime_capabilities(&runtime)?;
+        if capabilities != BTreeSet::from([expected_capability.to_string()]) {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} pack backend {:?} declares evaluator capabilities {capabilities:?}, expected {expected_capability:?}",
+                self.kernel_id, pack.backend,
+            )));
+        }
+        let (input_len, output_len) = runtime.io_len()?;
+        if input_len != self.input_arity
+            || output_len != usize::try_from(self.output_arity).unwrap_or(usize::MAX)
+        {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} evaluator I/O ({input_len}, {output_len}) does not match ({}, {})",
+                self.kernel_id, self.input_arity, self.output_arity
+            )));
+        }
+        match kind {
+            "symjit-application-evaluator" => {
+                if pack.backend != "jit" {
+                    return Err(RusticolError::integrity(format!(
+                        "prepared kernel {} uses SymJIT under backend {:?}",
+                        self.kernel_id, pack.backend
+                    )));
+                }
+                if required_nonempty_string(object, "label", self.kernel_id)?.is_empty() {
+                    return Err(RusticolError::artifact("prepared evaluator label is empty"));
+                }
+                let application_abi =
+                    required_nonempty_string(object, "application_abi", self.kernel_id)?;
+                if pack
+                    .dependency_abis
+                    .get("symjit_application")
+                    .and_then(Value::as_str)
+                    != Some(application_abi)
+                {
+                    return Err(RusticolError::compatibility(format!(
+                        "prepared kernel {} SymJIT application ABI does not match its pack",
+                        self.kernel_id
+                    )));
+                }
+                if object.get("optimization_level").and_then(Value::as_u64)
+                    != Some(PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL)
+                {
+                    return Err(RusticolError::compatibility(format!(
+                        "prepared kernel {} must use portable SymJIT optimization level {}",
+                        self.kernel_id, PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+                    )));
+                }
+                if object.contains_key("direct_table") {
+                    let direct = self.eager_direct_table_manifest()?;
+                    let plane = object
+                        .get("plane_application")
+                        .and_then(Value::as_object)
+                        .ok_or_else(|| {
+                            RusticolError::compatibility(format!(
+                                "prepared eager JIT kernel {} predates the SymJIT plane-application ABI; regenerate the prepared model",
+                                self.kernel_id
+                            ))
+                        })?;
+                    if direct.source_application_abi
+                        != crate::eager_layout::EAGER_DIRECT_SOURCE_APPLICATION_ABI
+                        || plane.get("application_abi").and_then(Value::as_str)
+                            != Some(crate::eager_layout::EAGER_DIRECT_SOURCE_APPLICATION_ABI)
+                        || plane.get("storage_abi").and_then(Value::as_str)
+                            != Some(SYMJIT_APPLICATION_STORAGE_V3_ABI)
+                        || plane
+                            .get("application_path")
+                            .and_then(Value::as_str)
+                            .is_none_or(str::is_empty)
+                        || plane.get("input_complex_count").and_then(Value::as_u64)
+                            != u64::try_from(self.input_arity).ok()
+                        || plane.get("output_complex_count").and_then(Value::as_u64)
+                            != Some(u64::from(self.output_arity))
+                        || plane.get("optimization_level").and_then(Value::as_u64)
+                            != Some(PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL)
+                    {
+                        return Err(RusticolError::compatibility(format!(
+                            "prepared eager JIT kernel {} has an incompatible SymJIT plane application",
+                            self.kernel_id
+                        )));
+                    }
+                }
+            }
+            "compiled-complex-evaluator" => {
+                if !matches!(pack.backend.as_str(), "asm" | "cpp") {
+                    return Err(RusticolError::integrity(format!(
+                        "prepared kernel {} uses a compiled evaluator under backend {:?}",
+                        self.kernel_id, pack.backend
+                    )));
+                }
+                required_nonempty_string(object, "source_path", self.kernel_id)?;
+                let direct = self.eager_direct_table_manifest()?;
+                if direct.source_application_abi
+                    != crate::eager_layout::EAGER_NATIVE_DIRECT_TABLE_APPLICATION_ABI
+                {
+                    return Err(RusticolError::compatibility(format!(
+                        "prepared native kernel {} does not provide a native eager DirectTable",
+                        self.kernel_id
+                    )));
+                }
+            }
+            _ => unreachable!("runtime evaluator projection validated the kind"),
+        }
+        if object.get("evaluator_state_path").and_then(Value::as_str)
+            != Some(self.exact_evaluator_state_path.as_str())
+        {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} exact evaluator state does not match its f64 evaluator fallback",
+                self.kernel_id
+            )));
+        }
+        Ok(())
+    }
+}
+
+impl PreparedKernelVariantManifest {
+    pub(super) fn runtime_evaluator_manifest(&self) -> RusticolResult<EvaluatorManifest> {
+        let object = self.f64_evaluator_manifest.as_object().ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "prepared kernel {} variant {:?} evaluator manifest must be an object",
+                self.base_kernel_id, self.variant_id
+            ))
+        })?;
+        let kind = object.get("kind").and_then(Value::as_str).ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "prepared kernel {} variant {:?} evaluator kind must be a nonempty string",
+                self.base_kernel_id, self.variant_id
+            ))
+        })?;
+        if kind != "symjit-application-evaluator" {
+            return Err(RusticolError::compatibility(format!(
+                "prepared kernel {} variant {:?} has unsupported evaluator kind {kind:?}",
+                self.base_kernel_id, self.variant_id
+            )));
+        }
+        validate_prepared_evaluator_keys(self.base_kernel_id, kind, object)?;
+        let mut runtime = object.clone();
+        for field in ["backend", "label", "settings", "build_timing"] {
+            runtime.remove(field);
+        }
+        serde_json::from_value(Value::Object(runtime)).map_err(|error| {
+            RusticolError::serialization(format!(
+                "prepared kernel {} variant {:?} has invalid runtime evaluator metadata: {error}",
+                self.base_kernel_id, self.variant_id
+            ))
+        })
+    }
+
+    pub(super) fn extra_evaluator_payload_paths(&self) -> RusticolResult<Vec<&str>> {
+        let object = self.f64_evaluator_manifest.as_object().ok_or_else(|| {
+            RusticolError::artifact("prepared block evaluator manifest must be an object")
+        })?;
+        if object.get("kind").and_then(Value::as_str) != Some("symjit-application-evaluator") {
+            return Err(RusticolError::compatibility(format!(
+                "prepared kernel {} variant {:?} has an unsupported evaluator kind",
+                self.base_kernel_id, self.variant_id
+            )));
+        }
+        Ok(Vec::new())
+    }
+
+    fn validate(
+        &self,
+        pack: &PreparedKernelPackManifest,
+        base: &PreparedKernelManifest,
+    ) -> RusticolResult<()> {
+        if self.variant_abi != PREPARED_KERNEL_VARIANT_ABI
+            || self.variant_id != PREPARED_INDEPENDENT_BLOCK_VARIANT_ID
+            || self.kind != "independent-block"
+            || self.block_size != EAGER_INDEPENDENT_BLOCK_SIZE
+            || self.lane_layout != "lane-major"
+        {
+            return Err(RusticolError::compatibility(format!(
+                "prepared kernel {} has unsupported block variant metadata; \
+                 regenerate the artifact with the current `pyamplicol generate`",
+                self.base_kernel_id
+            )));
+        }
+        if pack.backend != "jit" || self.backend != pack.backend {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} block variant backend does not match its JIT pack",
+                self.base_kernel_id
+            )));
+        }
+        if base.contract_kind != "vertex"
+            || !base
+                .proof_classes
+                .iter()
+                .any(|proof| proof == PREPARED_INDEPENDENT_BLOCK_PROOF)
+            || base
+                .input_contracts
+                .iter()
+                .any(|input| !matches!(input.role.as_str(), "left-current" | "right-current"))
+        {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} block variant lacks its current-only vertex proof",
+                self.base_kernel_id
+            )));
+        }
+        if self.base_canonical_signature != base.canonical_signature
+            || self.input_lane_stride != base.input_arity
+            || self.output_lane_stride != usize::try_from(base.output_arity).unwrap_or(usize::MAX)
+            || self.input_arity != self.input_lane_stride * self.block_size as usize
+            || self.output_arity != self.output_lane_stride * self.block_size as usize
+        {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} block variant does not match its scalar arities",
+                self.base_kernel_id
+            )));
+        }
+        let expected_input_layout = (0..self.block_size)
+            .flat_map(|lane| {
+                base.input_layout
+                    .iter()
+                    .map(move |item| format!("lane:{lane}:{item}"))
+            })
+            .collect::<Vec<_>>();
+        let expected_output_layout = (0..self.block_size)
+            .flat_map(|lane| {
+                base.output_layout
+                    .iter()
+                    .map(move |item| format!("lane:{lane}:{item}"))
+            })
+            .collect::<Vec<_>>();
+        if self.input_layout != expected_input_layout
+            || self.output_layout != expected_output_layout
+        {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} block variant has an incompatible lane layout",
+                self.base_kernel_id
+            )));
+        }
+        let input_contracts = base
+            .input_contracts
+            .iter()
+            .map(|input| {
+                serde_json::json!({
+                    "role": input.role,
+                    "component": input.component,
+                    "symbol": input.symbol,
+                    "model_parameter_name": input.model_parameter_name,
+                    "model_parameter_index": input.model_parameter_index,
+                })
+            })
+            .collect::<Vec<_>>();
+        let expected_expression_digest = canonical_json_digest(&serde_json::json!({
+            "exact_expressions": base.exact_expressions,
+        }))?;
+        let expected_input_digest = canonical_json_digest(&serde_json::json!({
+            "input_arity": base.input_arity,
+            "input_layout": base.input_layout,
+            "input_contracts": input_contracts,
+        }))?;
+        let expected_output_digest = canonical_json_digest(&serde_json::json!({
+            "output_arity": base.output_arity,
+            "output_layout": base.output_layout,
+        }))?;
+        let expected_optimization_digest = canonical_json_digest(&pack.optimization_settings)?;
+        if self.base_expression_digest != expected_expression_digest
+            || self.base_input_contract_digest != expected_input_digest
+            || self.base_output_contract_digest != expected_output_digest
+            || self.optimization_settings_digest != expected_optimization_digest
+        {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} block variant digest does not match its scalar contract",
+                self.base_kernel_id
+            )));
+        }
+
+        let object = self.f64_evaluator_manifest.as_object().ok_or_else(|| {
+            RusticolError::artifact("prepared block evaluator manifest must be an object")
+        })?;
+        if required_nonempty_string(object, "kind", self.base_kernel_id)?
+            != "symjit-application-evaluator"
+            || required_nonempty_string(object, "backend", self.base_kernel_id)? != "jit"
+            || object.get("settings") != Some(&pack.optimization_settings)
+        {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} block evaluator does not match its JIT pack",
+                self.base_kernel_id
+            )));
+        }
+        if object.get("optimization_level").and_then(Value::as_u64)
+            != Some(PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL)
+        {
+            return Err(RusticolError::compatibility(format!(
+                "prepared kernel {} block evaluator must use portable SymJIT optimization level {}",
+                self.base_kernel_id, PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+            )));
+        }
+        let build_timing = object
+            .get("build_timing")
+            .and_then(Value::as_object)
+            .ok_or_else(|| {
+                RusticolError::artifact("prepared block build_timing must be an object")
+            })?;
+        if build_timing.values().any(|value| {
+            value
+                .as_f64()
+                .is_none_or(|seconds| !seconds.is_finite() || seconds < 0.0)
+        }) {
+            return Err(RusticolError::artifact(
+                "prepared block build timings must be finite nonnegative numbers",
+            ));
+        }
+        required_nonempty_string(object, "label", self.base_kernel_id)?;
+        required_nonempty_string(object, "evaluator_state_path", self.base_kernel_id)?;
+        validate_prepared_symjit_plane_application(
+            self.base_kernel_id,
+            object,
+            self.input_arity,
+            self.output_arity,
+            PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL as u8,
+        )?;
+        let application_abi =
+            required_nonempty_string(object, "application_abi", self.base_kernel_id)?;
+        if pack
+            .dependency_abis
+            .get("symjit_application")
+            .and_then(Value::as_str)
+            != Some(application_abi)
+        {
+            return Err(RusticolError::compatibility(format!(
+                "prepared kernel {} block evaluator SymJIT ABI does not match its pack",
+                self.base_kernel_id
+            )));
+        }
+        let runtime = self.runtime_evaluator_manifest()?;
+        if evaluator_runtime_capabilities(&runtime)?
+            != BTreeSet::from([SYMJIT_APPLICATION_RUNTIME_CAPABILITY.to_string()])
+        {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} block evaluator has incompatible capabilities",
+                self.base_kernel_id
+            )));
+        }
+        let (input_len, output_len) = runtime.io_len()?;
+        if input_len != self.input_arity || output_len != self.output_arity {
+            return Err(RusticolError::integrity(format!(
+                "prepared kernel {} block evaluator I/O ({input_len}, {output_len}) does not match ({}, {})",
+                self.base_kernel_id, self.input_arity, self.output_arity
+            )));
+        }
+        Ok(())
+    }
+}
+
+fn canonical_json_digest(value: &Value) -> RusticolResult<String> {
+    let mut canonical = String::new();
+    write_canonical_json(value, &mut canonical)?;
+    canonical.push('\n');
+    Ok(format!("{:x}", Sha256::digest(canonical.as_bytes())))
+}
+
+fn canonical_json_digest_exact(value: &Value) -> RusticolResult<String> {
+    let mut canonical = String::new();
+    write_canonical_json(value, &mut canonical)?;
+    Ok(format!("{:x}", Sha256::digest(canonical.as_bytes())))
+}
+
+fn write_canonical_json(value: &Value, output: &mut String) -> RusticolResult<()> {
+    match value {
+        Value::Null => output.push_str("null"),
+        Value::Bool(value) => output.push_str(if *value { "true" } else { "false" }),
+        Value::Number(value) => output.push_str(&python_json_number(value)),
+        Value::String(value) => write_ascii_json_string(value, output),
+        Value::Array(values) => {
+            output.push('[');
+            for (index, value) in values.iter().enumerate() {
+                if index != 0 {
+                    output.push(',');
+                }
+                write_canonical_json(value, output)?;
+            }
+            output.push(']');
+        }
+        Value::Object(values) => {
+            output.push('{');
+            let mut keys = values.keys().collect::<Vec<_>>();
+            keys.sort_unstable();
+            for (index, key) in keys.iter().enumerate() {
+                if index != 0 {
+                    output.push(',');
+                }
+                write_ascii_json_string(key, output);
+                output.push(':');
+                write_canonical_json(&values[*key], output)?;
+            }
+            output.push('}');
+        }
+    }
+    Ok(())
+}
+
+fn python_json_number(number: &serde_json::Number) -> String {
+    let rendered = number.to_string();
+    let Some((mantissa, exponent)) = rendered.split_once('e') else {
+        return rendered;
+    };
+    let (sign, digits) = if let Some(digits) = exponent.strip_prefix('-') {
+        ('-', digits)
+    } else if let Some(digits) = exponent.strip_prefix('+') {
+        ('+', digits)
+    } else {
+        ('+', exponent)
+    };
+    format!("{mantissa}e{sign}{digits:0>2}")
+}
+
+fn write_ascii_json_string(value: &str, output: &mut String) {
+    output.push('"');
+    for character in value.chars() {
+        match character {
+            '"' => output.push_str("\\\""),
+            '\\' => output.push_str("\\\\"),
+            '\u{0008}' => output.push_str("\\b"),
+            '\u{000c}' => output.push_str("\\f"),
+            '\n' => output.push_str("\\n"),
+            '\r' => output.push_str("\\r"),
+            '\t' => output.push_str("\\t"),
+            '\u{0020}'..='\u{007e}' => output.push(character),
+            character if u32::from(character) <= 0xffff => {
+                let _ = write!(output, "\\u{:04x}", u32::from(character));
+            }
+            character => {
+                let scalar = u32::from(character) - 0x1_0000;
+                let high = 0xd800 + (scalar >> 10);
+                let low = 0xdc00 + (scalar & 0x3ff);
+                let _ = write!(output, "\\u{high:04x}\\u{low:04x}");
+            }
+        }
+    }
+    output.push('"');
+}
+
+fn validate_prepared_evaluator_keys(
+    kernel_id: u32,
+    kind: &str,
+    object: &serde_json::Map<String, Value>,
+) -> RusticolResult<()> {
+    if kind == "symjit-application-evaluator" && !object.contains_key("plane_application") {
+        return Err(RusticolError::compatibility(format!(
+            "prepared JIT kernel {kernel_id} predates the SymJIT plane-application ABI; \
+             regenerate the prepared model"
+        )));
+    }
+    let expected = match kind {
+        "symjit-application-evaluator" => [
+            "application_abi",
+            "application_path",
+            "backend",
+            "batch_layout",
+            "build_timing",
+            "compiler_type",
+            "direct_table",
+            "element_layout",
+            "endianness",
+            "evaluator_state_path",
+            "evaluator_state_runtime_capability",
+            "input_len",
+            "kind",
+            "label",
+            "optimization_level",
+            "output_len",
+            "plane_application",
+            "required_defuns",
+            "runtime_capability",
+            "settings",
+            "translation_mode",
+            "word_bits",
+        ]
+        .as_slice(),
+        "compiled-complex-evaluator" => [
+            "backend",
+            "build_timing",
+            "direct_table",
+            "evaluator_state_path",
+            "function_name",
+            "input_len",
+            "kind",
+            "library_path",
+            "number_type",
+            "output_len",
+            "runtime_capability",
+            "settings",
+            "source_path",
+        ]
+        .as_slice(),
+        _ => {
+            return Err(RusticolError::compatibility(format!(
+                "prepared kernel {kernel_id} has unsupported evaluator kind {kind:?}"
+            )));
+        }
+    };
+    let actual = object.keys().map(String::as_str).collect::<BTreeSet<_>>();
+    let expected = expected.iter().copied().collect::<BTreeSet<_>>();
+    let expected_without_direct = expected
+        .iter()
+        .copied()
+        .filter(|field| *field != "direct_table")
+        .collect::<BTreeSet<_>>();
+    if actual != expected && actual != expected_without_direct {
+        return Err(RusticolError::artifact(format!(
+            "prepared kernel {kernel_id} evaluator fields {actual:?} do not match {expected:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_prepared_symjit_plane_application(
+    kernel_id: u32,
+    object: &serde_json::Map<String, Value>,
+    input_len: usize,
+    output_len: usize,
+    optimization_level: u8,
+) -> RusticolResult<()> {
+    let raw = object.get("plane_application").ok_or_else(|| {
+        RusticolError::compatibility(format!(
+            "prepared JIT kernel {kernel_id} predates the SymJIT plane-application ABI; \
+             regenerate the prepared model"
+        ))
+    })?;
+    let plane: SymjitPlaneApplicationManifest =
+        serde_json::from_value(raw.clone()).map_err(|error| {
+            RusticolError::compatibility(format!(
+                "prepared JIT kernel {kernel_id} has invalid SymJIT plane-application metadata; \
+                 regenerate the prepared model: {error}"
+            ))
+        })?;
+    plane.validate(input_len, output_len, optimization_level)
+}
+
+fn required_nonempty_string<'a>(
+    object: &'a serde_json::Map<String, Value>,
+    field: &str,
+    kernel_id: u32,
+) -> RusticolResult<&'a str> {
+    object
+        .get(field)
+        .and_then(Value::as_str)
+        .filter(|value| !value.is_empty())
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "prepared kernel {kernel_id} evaluator field {field:?} must be a nonempty string"
+            ))
+        })
+}
+
+impl PreparedKernelInputManifest {
+    fn to_eager_input(&self) -> RusticolResult<EagerKernelInput> {
+        if self.symbol.is_empty() {
+            return Err(RusticolError::integrity(
+                "prepared kernel input symbol must be nonempty",
+            ));
+        }
+        let input = match self.role.as_str() {
+            "left-current" => EagerKernelInput::FirstCurrentComponent(self.component),
+            "right-current" => EagerKernelInput::SecondCurrentComponent(self.component),
+            "left-momentum" => EagerKernelInput::FirstMomentumComponent(self.component),
+            "right-momentum" => EagerKernelInput::SecondMomentumComponent(self.component),
+            "current" => EagerKernelInput::FirstCurrentComponent(self.component),
+            "momentum" => EagerKernelInput::FirstMomentumComponent(self.component),
+            "coupling-real" => EagerKernelInput::CouplingReal,
+            "coupling-imag" => EagerKernelInput::CouplingImag,
+            "model-parameter" => {
+                EagerKernelInput::ModelParameter(self.model_parameter_index.ok_or_else(|| {
+                    RusticolError::integrity(
+                        "prepared model-parameter input lacks its stable index",
+                    )
+                })?)
+            }
+            other => {
+                return Err(RusticolError::artifact(format!(
+                    "unsupported prepared kernel input role {other:?}"
+                )));
+            }
+        };
+        if self.role == "model-parameter" {
+            if self
+                .model_parameter_name
+                .as_deref()
+                .unwrap_or("")
+                .is_empty()
+            {
+                return Err(RusticolError::integrity(
+                    "prepared model-parameter input lacks its name",
+                ));
+            }
+        } else if self.model_parameter_name.is_some() || self.model_parameter_index.is_some() {
+            return Err(RusticolError::integrity(
+                "only prepared model-parameter inputs may carry parameter metadata",
+            ));
+        }
+        Ok(input)
+    }
+}
+
+fn contiguous_value_slot_widths(plan: &ExecutionPlan) -> RusticolResult<Vec<u32>> {
+    let pairs = plan
+        .value_storage
+        .value_slots
+        .iter()
+        .map(|slot| (slot.value_slot_id, slot.dimension))
+        .collect::<Vec<_>>();
+    contiguous_widths("value", pairs)
+}
+
+fn contiguous_momentum_slot_widths(plan: &ExecutionPlan) -> RusticolResult<Vec<u32>> {
+    let pairs = plan
+        .momentum_slots
+        .iter()
+        .map(|slot| {
+            let width = slot
+                .component_stop
+                .checked_sub(slot.component_start)
+                .ok_or_else(|| {
+                    RusticolError::artifact("eager momentum slot has an inverted component range")
+                })?;
+            Ok((slot.momentum_slot_id, width))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    contiguous_widths("momentum", pairs)
+}
+
+fn contiguous_current_slot_widths(plan: &ExecutionPlan) -> RusticolResult<Vec<u32>> {
+    let pairs = plan
+        .current_storage
+        .current_slots
+        .iter()
+        .map(|slot| (slot.current_id, slot.dimension))
+        .collect::<Vec<_>>();
+    contiguous_widths("current", pairs)
+}
+
+fn contiguous_widths(name: &str, mut pairs: Vec<(usize, usize)>) -> RusticolResult<Vec<u32>> {
+    pairs.sort_unstable_by_key(|(id, _)| *id);
+    if pairs
+        .iter()
+        .enumerate()
+        .any(|(expected, (id, _))| expected != *id)
+    {
+        return Err(RusticolError::artifact(format!(
+            "eager {name} slot ids must be contiguous from zero"
+        )));
+    }
+    pairs
+        .into_iter()
+        .map(|(id, width)| {
+            if width == 0 {
+                return Err(RusticolError::artifact(format!(
+                    "eager {name} slot {id} has zero width"
+                )));
+            }
+            u32::try_from(width)
+                .map_err(|_| RusticolError::artifact(format!("eager {name} width exceeds u32")))
+        })
+        .collect()
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_common.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_common.rs
new file mode 100644
index 0000000000..47ca1c869b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_common.rs
@@ -0,0 +1,1826 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Checked construction of the common f64 state used by eager plan-v3.
+//!
+//! This adapter deliberately reads the compact typed plan, retained columns,
+//! and canonical IR directly. It does not recreate the expanded
+//! `runtime_schema` representation.
+
+use super::eager_v3_decode::{
+    DecodedEagerPrimitiveColumn, DecodedEagerRetainedTable, DecodedEagerRuntimeV3,
+};
+use super::eager_v3_manifest::EagerV3ExecutionManifest;
+use super::*;
+use serde::Deserialize;
+use serde_json::{Value, json};
+
+const MISSING_I32: i32 = i32::MIN;
+
+/// Validated fields that differ between eager artifacts while the compiled
+/// lane state remains empty.
+pub(super) struct EagerV3CommonParts {
+    process: String,
+    key: String,
+    color_accuracy: String,
+    external_pdg_order: Vec<i32>,
+    external_count: usize,
+    parameter_count: usize,
+    value_parameter_count: usize,
+    momentum_parameter_count: usize,
+    current_count: usize,
+    source_count: usize,
+    interaction_count: usize,
+    stage_count: usize,
+    amplitude_output_count: usize,
+    sources: Vec<GenericSourceRecordManifest>,
+    momentum_slots: Vec<GenericMomentumSlotManifest>,
+    external_is_initial: Vec<bool>,
+    particle_masses: BTreeMap<i32, f64>,
+    particle_mass_parameter_names: BTreeMap<i32, String>,
+    normalization_factor: f64,
+    normalization_color_factor: f64,
+    normalization_average_factor: f64,
+    normalization_identical_factor: f64,
+    normalization_qcd_coupling_power: usize,
+    normalization_electroweak_coupling_power: usize,
+    lc_topology_replay: Option<LcTopologyReplayManifest>,
+    lc_topology_replay_data: LcTopologyReplayData,
+    color_topology_replay: Option<ColorTopologyReplayManifest>,
+    color_topology_replay_data: LcTopologyReplayData,
+    model_parameters: Vec<GenericRuntimeModelParameterManifest>,
+    model_parameter_name_to_index: BTreeMap<String, usize>,
+    model_parameter_runtime_slots: BTreeMap<String, RuntimeParameterSlots>,
+    model_parameter_values_f64: Vec<f64>,
+    physics: Arc<PhysicsRuntime>,
+}
+
+/// One-line integration entry point for the plan-v3 loader.
+pub(super) fn build_eager_v3_common_runtime(
+    decoded: &DecodedEagerRuntimeV3,
+    manifest: &EagerV3ExecutionManifest,
+    physics: ProcessPhysicsV1,
+) -> RusticolResult<ExecutionRuntime> {
+    EagerV3CommonParts::checked(decoded, manifest, physics).map(EagerV3CommonParts::into_runtime)
+}
+
+/// Build the bounded schema fragment required by the lazy Python exact lane.
+///
+/// This deliberately omits compiled-stage metadata and all high-cardinality
+/// proof tables. Those remain authenticated in PACBIN and are exposed through
+/// the dedicated exact row bridge only when non-f64 execution is requested.
+pub(super) fn build_eager_v3_exact_schema(
+    decoded: &DecodedEagerRuntimeV3,
+    manifest: &EagerV3ExecutionManifest,
+    physics: ProcessPhysicsV1,
+    amplitude_stage: Value,
+) -> RusticolResult<Value> {
+    EagerV3CommonParts::checked(decoded, manifest, physics)?
+        .into_exact_schema(decoded, amplitude_stage)
+}
+
+impl EagerV3CommonParts {
+    fn checked(
+        decoded: &DecodedEagerRuntimeV3,
+        manifest: &EagerV3ExecutionManifest,
+        physics: ProcessPhysicsV1,
+    ) -> RusticolResult<Self> {
+        validate_identity(decoded, manifest, &physics)?;
+        let retained = RetainedTables::new(&decoded.retained_tables);
+        let metadata = retained.table("metadata")?;
+        let normalization_ir_id = retained.scalar_u32(metadata, "normalization_ir_id")?;
+        let normalization: CanonicalNormalization =
+            canonical_ir(decoded, normalization_ir_id, "runtime normalization")?;
+        normalization.validate()?;
+        let lc_topology_replay = build_lc_topology_replay_manifest(decoded, &retained)?;
+        let lc_topology_replay_data =
+            super::runtime_load::build_lc_topology_replay_data(lc_topology_replay.as_ref())?;
+        let color_topology_replay =
+            build_color_topology_replay_manifest(decoded, &retained, &manifest.color_accuracy)?;
+        let color_topology_replay_data = super::runtime_load::build_color_topology_replay_data(
+            color_topology_replay.as_ref(),
+            &manifest.color_accuracy,
+        )?;
+
+        let model_parameters = build_model_parameters(decoded, &retained)?;
+        validate_physics_parameters(&model_parameters, &physics)?;
+        let model_parameter_values_f64 = model_parameters
+            .iter()
+            .map(|parameter| parameter.default)
+            .collect::<Vec<_>>();
+        let model_parameter_name_to_index = model_parameters
+            .iter()
+            .map(|parameter| (parameter.name.clone(), parameter.parameter_index))
+            .collect::<BTreeMap<_, _>>();
+        if model_parameter_name_to_index.len() != model_parameters.len() {
+            return Err(integrity("eager model-parameter names are not unique"));
+        }
+        let model_parameter_runtime_slots = runtime_parameter_slots(&model_parameters)?;
+        let (mut particle_masses, mut particle_mass_parameter_names) =
+            direct_particle_masses(&model_parameters)?;
+
+        let momentum_slots = build_momentum_slots(decoded, physics.external_particles.len())?;
+        let sources = build_sources(
+            decoded,
+            &retained,
+            &physics,
+            &model_parameter_runtime_slots,
+            &model_parameter_values_f64,
+            &mut particle_masses,
+            &mut particle_mass_parameter_names,
+        )?;
+        let value_parameter_count = component_count(&decoded.values, "value")?;
+        let momentum_parameter_count = component_count(&decoded.momenta, "momentum")?;
+        let parameter_count = value_parameter_count
+            .checked_add(momentum_parameter_count)
+            .and_then(|count| count.checked_add(model_parameters.len()))
+            .ok_or_else(|| RusticolError::artifact("eager common parameter count overflows"))?;
+
+        // Contracted-color reductions already carry the color contraction.
+        let color_factor = if physics.color_accuracy.as_str() == "lc" {
+            normalization.color_factor
+        } else {
+            1.0
+        };
+        let normalization_factor = color_factor * normalization.global_coupling_factor
+            / (normalization.average_factor * normalization.identical_factor);
+        if !normalization_factor.is_finite() {
+            return Err(integrity("eager runtime normalization is not finite"));
+        }
+        let physics = Arc::new(PhysicsRuntime::new(physics)?);
+
+        Ok(Self {
+            process: manifest.process.clone(),
+            key: manifest.key.clone(),
+            color_accuracy: manifest.color_accuracy.clone(),
+            external_pdg_order: manifest.external_pdg_order.clone(),
+            external_count: manifest.external_pdg_order.len(),
+            parameter_count,
+            value_parameter_count,
+            momentum_parameter_count,
+            current_count: decoded.currents.len(),
+            source_count: decoded.sources.len(),
+            interaction_count: usize_count(
+                manifest.dag_summary.interaction_count,
+                "interaction count",
+            )?,
+            stage_count: decoded.stages.len(),
+            amplitude_output_count: usize::try_from(decoded.dimensions.amplitude_count)
+                .map_err(|_| RusticolError::artifact("eager amplitude count exceeds usize"))?,
+            sources,
+            momentum_slots,
+            external_is_initial: physics
+                .manifest
+                .external_particles
+                .iter()
+                .map(|particle| particle.role == crate::ParticleRole::Initial)
+                .collect(),
+            particle_masses,
+            particle_mass_parameter_names,
+            normalization_factor,
+            normalization_color_factor: color_factor,
+            normalization_average_factor: normalization.average_factor,
+            normalization_identical_factor: normalization.identical_factor,
+            normalization_qcd_coupling_power: normalization.qcd_coupling_power,
+            normalization_electroweak_coupling_power: normalization.electroweak_coupling_power,
+            lc_topology_replay,
+            lc_topology_replay_data,
+            color_topology_replay,
+            color_topology_replay_data,
+            model_parameters,
+            model_parameter_name_to_index,
+            model_parameter_runtime_slots,
+            model_parameter_values_f64,
+            physics,
+        })
+    }
+
+    fn into_runtime(self) -> ExecutionRuntime {
+        let topology_replay_mappings = self.lc_topology_replay_data.mappings;
+        let topology_replay_public_mappings = topology_replay_mappings.clone();
+        let color_topology_replay_mappings = self.color_topology_replay_data.mappings;
+        ExecutionRuntime {
+            process: self.process,
+            key: self.key,
+            color_accuracy: self.color_accuracy,
+            external_pdg_order: self.external_pdg_order,
+            external_count: self.external_count,
+            parameter_count: self.parameter_count,
+            value_parameter_count: self.value_parameter_count,
+            momentum_parameter_count: self.momentum_parameter_count,
+            current_count: self.current_count,
+            source_count: self.source_count,
+            interaction_count: self.interaction_count,
+            stage_count: self.stage_count,
+            amplitude_output_count: self.amplitude_output_count,
+            lc_topology_replay_enabled: !topology_replay_mappings.is_empty(),
+            lc_topology_replay_mappings: Arc::new(topology_replay_mappings),
+            lc_topology_replay_public_mappings: topology_replay_public_mappings,
+            lc_topology_replay_routes: self.lc_topology_replay_data.routes,
+            lc_topology_replay_materialized_sector_ids: self
+                .lc_topology_replay_data
+                .materialized_sector_ids,
+            lc_resolved_replay_plan: None,
+            lc_resolved_replay_selection_cache: None,
+            lc_replay_flat_momenta_scratch: Vec::new(),
+            lc_replay_target_components_scratch: Vec::new(),
+            color_topology_replay_enabled: !color_topology_replay_mappings.is_empty(),
+            color_topology_replay_mappings: Arc::new(color_topology_replay_mappings),
+            color_replay_flat_momenta_scratch: Vec::new(),
+            helicity_recurrence: None,
+            compiled_helicity_execution_plan: None,
+            compiled_color_execution_plan: None,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            compiled_direct_runtime: None,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            compiled_direct_color_schedules: BTreeMap::new(),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            compiled_direct_helicity_schedules: BTreeMap::new(),
+            helicity_sum_runtime: None,
+            helicity_selector_runtimes: Vec::new(),
+            helicity_selector_runtime_schedule_modes: Vec::new(),
+            helicity_selector_lane_by_domain: BTreeMap::new(),
+            color_selector_runtimes: BTreeMap::new(),
+            runtime_unavailable_message: None,
+            sources: self.sources,
+            momentum_slots: self.momentum_slots,
+            external_is_initial: self.external_is_initial,
+            particle_masses: self.particle_masses,
+            particle_mass_parameter_names: self.particle_mass_parameter_names,
+            normalization_factor: self.normalization_factor,
+            normalization_color_factor: self.normalization_color_factor,
+            normalization_average_factor: self.normalization_average_factor,
+            normalization_identical_factor: self.normalization_identical_factor,
+            normalization_qcd_coupling_power: self.normalization_qcd_coupling_power,
+            normalization_electroweak_coupling_power: self.normalization_electroweak_coupling_power,
+            model_parameters: self.model_parameters,
+            model_parameter_name_to_index: self.model_parameter_name_to_index,
+            model_parameter_runtime_slots: self.model_parameter_runtime_slots,
+            model_parameter_values_f64: self.model_parameter_values_f64,
+            model_parameter_evaluator: None,
+            physics_reduction_override: None,
+            physics: Some(self.physics),
+            stages: None,
+            amplitude_stage: None,
+            state_scratch_f64: Vec::new(),
+            state_scratch_f64_requires_clear: false,
+            values_scratch_f64: Vec::new(),
+        }
+    }
+
+    fn into_exact_schema(
+        self,
+        decoded: &DecodedEagerRuntimeV3,
+        amplitude_stage: Value,
+    ) -> RusticolResult<Value> {
+        let source_current_ids = self
+            .sources
+            .iter()
+            .map(|source| source.current_id)
+            .collect::<BTreeSet<_>>();
+        let current_component_count = decoded
+            .dimensions
+            .current_component_counts
+            .iter()
+            .try_fold(0_usize, |total, count| {
+                total
+                    .checked_add(*count as usize)
+                    .ok_or_else(|| RusticolError::artifact("eager exact current layout overflows"))
+            })?;
+        let current_slots = decoded
+            .currents
+            .iter()
+            .map(|row| {
+                let start = usize_count(row.component_start, "exact current component start")?;
+                let dimension = row.component_count as usize;
+                Ok(json!({
+                    "current_id": row.current_id,
+                    "component_start": start,
+                    "component_stop": start + dimension,
+                    "dimension": dimension,
+                    "is_source": source_current_ids.contains(&(row.current_id as usize)),
+                }))
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let value_slots = decoded
+            .values
+            .iter()
+            .map(|row| {
+                let start = usize_count(row.component_start, "exact value component start")?;
+                let dimension = row.component_count as usize;
+                let variant = match row.kind {
+                    crate::eager_lowering_v3::EagerValueSlotKind::Source => "source",
+                    crate::eager_lowering_v3::EagerValueSlotKind::Unpropagated => "unpropagated",
+                    crate::eager_lowering_v3::EagerValueSlotKind::Propagated => "propagated",
+                };
+                Ok(json!({
+                    "value_slot_id": row.value_slot_id,
+                    "current_id": row.current_id,
+                    "variant": variant,
+                    "component_start": start,
+                    "component_stop": start + dimension,
+                    "dimension": dimension,
+                }))
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let external_particles = self
+            .physics
+            .manifest
+            .external_particles
+            .iter()
+            .map(|particle| {
+                json!({
+                    "label": particle.label,
+                    "index": particle.index,
+                    "pdg": particle.pdg,
+                    "role": match particle.role {
+                        crate::ParticleRole::Initial => "initial",
+                        crate::ParticleRole::Final => "final",
+                    },
+                    "momentum_slot": particle.momentum_slot,
+                })
+            })
+            .collect::<Vec<_>>();
+        let model_particles = self
+            .particle_masses
+            .iter()
+            .map(|(pdg, mass)| {
+                json!({
+                    "pdg": pdg,
+                    "mass": mass,
+                    "mass_parameter": self.particle_mass_parameter_names.get(pdg),
+                })
+            })
+            .collect::<Vec<_>>();
+        let flattened_parameter_count = self
+            .value_parameter_count
+            .checked_add(self.momentum_parameter_count)
+            .and_then(|count| count.checked_add(self.model_parameters.len()))
+            .ok_or_else(|| RusticolError::artifact("eager exact parameter layout overflows"))?;
+
+        Ok(json!({
+            "kind": "pyamplicol-eager-exact-schema-v1",
+            "parameter_layout": {
+                "value_component_count": self.value_parameter_count,
+                "momentum_parameter_count": self.momentum_parameter_count,
+                "model_parameter_count": self.model_parameters.len(),
+                "parameter_count_if_flattened": flattened_parameter_count,
+            },
+            "current_storage": {
+                "component_count": current_component_count,
+                "current_slots": current_slots,
+            },
+            "value_storage": {
+                "component_count": self.value_parameter_count,
+                "value_slots": value_slots,
+            },
+            "momentum_slots": self.momentum_slots,
+            "external_particles": external_particles,
+            "model": {"particles": model_particles},
+            "model_parameters": self.model_parameters,
+            "source_fill": {
+                "source_count": self.sources.len(),
+                "sources": self.sources,
+            },
+            "lc_topology_replay": self.lc_topology_replay,
+            "color_topology_replay": self.color_topology_replay,
+            "amplitude_stage": amplitude_stage,
+        }))
+    }
+}
+
+fn build_lc_topology_replay_manifest(
+    decoded: &DecodedEagerRuntimeV3,
+    retained: &RetainedTables<'_>,
+) -> RusticolResult<Option<LcTopologyReplayManifest>> {
+    build_topology_replay_manifest(decoded, retained, 1)
+}
+
+fn build_color_topology_replay_manifest(
+    decoded: &DecodedEagerRuntimeV3,
+    retained: &RetainedTables<'_>,
+    color_accuracy: &str,
+) -> RusticolResult<Option<ColorTopologyReplayManifest>> {
+    let Some(compatibility) = build_topology_replay_manifest(decoded, retained, 2)? else {
+        return Ok(None);
+    };
+    Ok(Some(ColorTopologyReplayManifest {
+        enabled: compatibility.enabled,
+        mode: compatibility.mode,
+        contract_version: Some(3),
+        color_accuracy: color_accuracy.to_string(),
+        physical_sector_count: compatibility.physical_sector_count,
+        replayed_sector_count: compatibility.replayed_sector_count,
+        materialized_sector_ids: compatibility.materialized_sector_ids,
+        residual_sector_ids: compatibility.residual_sector_ids,
+        groups: compatibility.groups,
+    }))
+}
+
+pub(super) fn load_eager_color_topology_replay_manifests(
+    decoded: &DecodedEagerRuntimeV3,
+    include_exact_weights: bool,
+) -> RusticolResult<
+    Option<(
+        GenericColorTopologyReplayAmplitudeManifest,
+        GenericColorContractionManifest,
+    )>,
+> {
+    let retained = RetainedTables::new(&decoded.retained_tables);
+    let metadata = retained.table("color_replay_metadata")?;
+    let present = retained.scalar_u8(metadata, "present")?;
+    let contract_version = retained.scalar_u32(metadata, "contract_version")?;
+    let physical_group_count = usize_count(
+        retained.scalar_u64(metadata, "physical_group_count")?,
+        "physical group count",
+    )?;
+    let mapping_count = usize_count(
+        retained.scalar_u64(metadata, "mapping_count")?,
+        "mapping count",
+    )?;
+    let groups = retained.table("color_replay_physical_groups")?;
+    let mappings = retained.table("color_replay_mappings")?;
+    let permutations = retained.table("color_replay_permutations")?;
+    let routes = retained.table("color_replay_routes")?;
+    let contraction_metadata = retained.table("color_replay_contraction_metadata")?;
+    let contraction_component_groups =
+        retained.table("color_replay_contraction_component_groups")?;
+    let contraction_entries = retained.table("color_replay_contraction_entries")?;
+    if present == 0 {
+        if contract_version != 0
+            || physical_group_count != 0
+            || mapping_count != 0
+            || groups.row_count != 0
+            || mappings.row_count != 0
+            || permutations.row_count != 0
+            || routes.row_count != 0
+            || retained.scalar_u8(contraction_metadata, "present")? != 0
+            || retained.scalar_u64(contraction_metadata, "group_count")? != 0
+            || retained.scalar_u8(contraction_metadata, "repeated")? != 0
+            || retained.scalar_u64(contraction_metadata, "component_count")? != 0
+            || contraction_component_groups.row_count != 0
+            || contraction_entries.row_count != 0
+        {
+            return Err(integrity(
+                "absent eager color replay contains retained payload rows",
+            ));
+        }
+        return Ok(None);
+    }
+    let contraction_repeated = retained.scalar_u8(contraction_metadata, "repeated")?;
+    let contraction_component_count = usize_count(
+        retained.scalar_u64(contraction_metadata, "component_count")?,
+        "color replay contraction component count",
+    )?;
+    if present != 1
+        || contract_version != 1
+        || physical_group_count == 0
+        || groups.row_count as usize != physical_group_count
+        || mappings.row_count as usize != mapping_count
+        || mapping_count == 0
+        || retained.scalar_u8(contraction_metadata, "present")? != 1
+        || retained.scalar_u64(contraction_metadata, "group_count")? != physical_group_count as u64
+        || retained.scalar_u8(contraction_metadata, "includes_color_factor")? != 1
+        || contraction_repeated > 1
+        || (contraction_repeated == 0
+            && (contraction_component_count != 0 || contraction_component_groups.row_count != 0))
+        || (contraction_repeated == 1
+            && (contraction_component_count < 2
+                || contraction_component_groups.row_count as usize != physical_group_count))
+    {
+        return Err(integrity(
+            "eager color replay amplitude metadata is inconsistent",
+        ));
+    }
+
+    let group_ids = retained.u32_column(groups, "group_id", 1)?;
+    let sector_ids = retained.u32_column(groups, "color_sector_id", 1)?;
+    let word_ids = retained.u32_column(groups, "color_word_sequence_id", 1)?;
+    let helicity_ids = retained.u32_column(groups, "helicity_values_sequence_id", 1)?;
+    let helicity_weight_ids = retained.u32_column(groups, "helicity_weight_factor_id", 1)?;
+    let physical_groups = (0..physical_group_count)
+        .map(|index| {
+            let helicity_weight =
+                eager_exact_real_factor(decoded, helicity_weight_ids[index], "helicity weight")?;
+            Ok(GenericColorTopologyReplayPhysicalGroupManifest {
+                group_id: i64::from(group_ids[index]),
+                helicities: i32_sequence(decoded, helicity_ids[index])?,
+                color_sector_id: i64::from(sector_ids[index]),
+                color_word: u32_sequence(decoded, word_ids[index], "color replay word")?
+                    .into_iter()
+                    .map(|value| value as usize)
+                    .collect(),
+                helicity_weight,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let permutation_starts = retained.u64_column(mappings, "permutation_start", 1)?;
+    let permutation_counts = retained.u64_column(mappings, "permutation_count", 1)?;
+    let route_starts = retained.u64_column(mappings, "route_start", 1)?;
+    let route_counts = retained.u64_column(mappings, "route_count", 1)?;
+    let representative_labels = retained.u32_column(permutations, "representative_label", 1)?;
+    let sector_labels = retained.u32_column(permutations, "sector_label", 1)?;
+    let source_group_ids = retained.u32_column(routes, "source_group_id", 1)?;
+    let target_group_ids = retained.u32_column(routes, "target_group_id", 1)?;
+    let route_factor_ids = retained.u32_column(routes, "factor_id", 1)?;
+    let mut permutation_cursor = 0usize;
+    let mut route_cursor = 0usize;
+    let mut replay_mappings = Vec::with_capacity(mapping_count);
+    for index in 0..mapping_count {
+        let permutation_start =
+            usize_count(permutation_starts[index], "color replay permutation start")?;
+        let permutation_count =
+            usize_count(permutation_counts[index], "color replay permutation count")?;
+        let route_start = usize_count(route_starts[index], "color replay route start")?;
+        let route_count = usize_count(route_counts[index], "color replay route count")?;
+        if permutation_start != permutation_cursor || route_start != route_cursor {
+            return Err(integrity(
+                "eager color replay mappings are not canonical and contiguous",
+            ));
+        }
+        let permutation_stop = permutation_start
+            .checked_add(permutation_count)
+            .ok_or_else(|| RusticolError::artifact("color replay permutation range overflows"))?;
+        let route_stop = route_start
+            .checked_add(route_count)
+            .ok_or_else(|| RusticolError::artifact("color replay route range overflows"))?;
+        if permutation_stop > permutations.row_count as usize
+            || route_stop > routes.row_count as usize
+        {
+            return Err(integrity(
+                "eager color replay mapping range is out of bounds",
+            ));
+        }
+        replay_mappings.push(GenericColorTopologyReplayMappingManifest {
+            label_permutation: (permutation_start..permutation_stop)
+                .map(|row| LcTopologyReplayLabelPermutationManifest {
+                    representative_label: representative_labels[row] as usize,
+                    sector_label: sector_labels[row] as usize,
+                })
+                .collect(),
+            group_routes: (route_start..route_stop)
+                .map(|row| {
+                    Ok(GenericColorTopologyReplayGroupRouteManifest {
+                        source_group_id: i64::from(source_group_ids[row]),
+                        target_group_id: i64::from(target_group_ids[row]),
+                        factor: eager_exact_factor(decoded, route_factor_ids[row], "route factor")?,
+                    })
+                })
+                .collect::<RusticolResult<Vec<_>>>()?,
+        });
+        permutation_cursor = permutation_stop;
+        route_cursor = route_stop;
+    }
+    if permutation_cursor != permutations.row_count as usize
+        || route_cursor != routes.row_count as usize
+    {
+        return Err(integrity(
+            "eager color replay retained tables contain unreachable rows",
+        ));
+    }
+
+    let left_ids = retained.u32_column(contraction_entries, "left_group_id", 1)?;
+    let right_ids = retained.u32_column(contraction_entries, "right_group_id", 1)?;
+    let left_indices = retained.u32_column(contraction_entries, "left_group_index", 1)?;
+    let right_indices = retained.u32_column(contraction_entries, "right_group_index", 1)?;
+    let weight_ids = retained.u32_column(contraction_entries, "weight_factor_id", 1)?;
+    let symmetry_ids = retained.u32_column(contraction_entries, "symmetry_factor_id", 1)?;
+    if contraction_entries.row_count == 0 {
+        return Err(integrity(
+            "eager color replay physical contraction is empty",
+        ));
+    }
+    let (entries, repeated_block) = if contraction_repeated == 0 {
+        if left_indices
+            .iter()
+            .chain(right_indices.iter())
+            .any(|value| *value != u32::MAX)
+        {
+            return Err(integrity(
+                "expanded eager color replay contraction contains local indices",
+            ));
+        }
+        (
+            (0..contraction_entries.row_count as usize)
+                .map(|index| {
+                    Ok(GenericColorContractionEntryManifest {
+                        _exact_weight: if include_exact_weights {
+                            eager_exact_color_weight(decoded, weight_ids[index])?
+                        } else {
+                            None
+                        },
+                        left_group_id: i64::from(left_ids[index]),
+                        right_group_id: i64::from(right_ids[index]),
+                        weight: eager_exact_factor(
+                            decoded,
+                            weight_ids[index],
+                            "contraction weight",
+                        )?,
+                        symmetry_factor: eager_exact_real_factor(
+                            decoded,
+                            symmetry_ids[index],
+                            "contraction symmetry",
+                        )?,
+                    })
+                })
+                .collect::<RusticolResult<Vec<_>>>()?,
+            None,
+        )
+    } else {
+        if left_ids
+            .iter()
+            .chain(right_ids.iter())
+            .any(|value| *value != u32::MAX)
+        {
+            return Err(integrity(
+                "repeated eager color replay contraction contains physical group IDs",
+            ));
+        }
+        let component_group_ids = retained
+            .u32_column(contraction_component_groups, "group_id", 1)?
+            .iter()
+            .map(|value| i64::from(*value))
+            .collect();
+        let repeated_entries = (0..contraction_entries.row_count as usize)
+            .map(|index| {
+                Ok(GenericRepeatedColorContractionEntryManifest {
+                    _exact_weight: if include_exact_weights {
+                        eager_exact_color_weight(decoded, weight_ids[index])?
+                    } else {
+                        None
+                    },
+                    left_group_index: left_indices[index] as usize,
+                    right_group_index: right_indices[index] as usize,
+                    weight: eager_exact_factor(decoded, weight_ids[index], "contraction weight")?,
+                    symmetry_factor: eager_exact_real_factor(
+                        decoded,
+                        symmetry_ids[index],
+                        "contraction symmetry",
+                    )?,
+                })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        (
+            Vec::new(),
+            Some(GenericRepeatedColorContractionBlockManifest {
+                component_count: contraction_component_count,
+                component_group_ids,
+                entries: repeated_entries,
+                factorized_block: None,
+            }),
+        )
+    };
+    let amplitude_manifest = GenericColorTopologyReplayAmplitudeManifest {
+        contract_version,
+        physical_group_count,
+        physical_groups,
+        mappings: replay_mappings,
+    };
+    let contraction_manifest = GenericColorContractionManifest {
+        supported: true,
+        reason: None,
+        group_count: physical_group_count,
+        includes_color_factor: true,
+        entries,
+        repeated_block,
+    };
+    Ok(Some((amplitude_manifest, contraction_manifest)))
+}
+
+pub(super) fn build_eager_color_topology_replay_amplitude_runtime(
+    decoded: &DecodedEagerRuntimeV3,
+    materialized_groups: &[RawSumGroup],
+    output_count: usize,
+) -> RusticolResult<Option<AmplitudeRuntime>> {
+    let Some((amplitude_manifest, contraction_manifest)) =
+        load_eager_color_topology_replay_manifests(decoded, false)?
+    else {
+        return Ok(None);
+    };
+    AmplitudeRuntime::color_topology_replay_reducer(
+        output_count,
+        materialized_groups,
+        &amplitude_manifest,
+        &contraction_manifest,
+    )
+    .map(Some)
+}
+
+pub(super) fn eager_exact_color_weight(
+    decoded: &DecodedEagerRuntimeV3,
+    factor_id: u32,
+) -> RusticolResult<Option<[String; 4]>> {
+    let factor = decoded
+        .exact_factors
+        .get(factor_id as usize)
+        .ok_or_else(|| integrity("eager exact colour weight is absent"))?;
+    if factor.exact_source != 1 {
+        return Ok(None);
+    }
+    let raw = decoded
+        .exact_ir
+        .get(factor.exact_ir_id as usize)
+        .ok_or_else(|| integrity("eager exact colour weight source is absent"))?;
+    let payload: serde_json::Value = serde_json::from_str(raw)
+        .map_err(|error| integrity(format!("invalid exact colour weight source: {error}")))?;
+    let source = &payload["source"];
+    if source["kind"] != "rational-complex" {
+        return Ok(None);
+    }
+    serde_json::from_value(source["value"].clone())
+        .map(Some)
+        .map_err(|error| integrity(format!("invalid rational colour weight: {error}")))
+}
+
+fn eager_exact_factor(
+    decoded: &DecodedEagerRuntimeV3,
+    factor_id: u32,
+    context: &str,
+) -> RusticolResult<Vec<f64>> {
+    let factor = decoded
+        .exact_factors
+        .get(factor_id as usize)
+        .ok_or_else(|| integrity(format!("eager color replay {context} is absent")))?;
+    let real = f64::from_bits(factor.real_bits);
+    let imaginary = f64::from_bits(factor.imaginary_bits);
+    if !real.is_finite() || !imaginary.is_finite() {
+        return Err(integrity(format!(
+            "eager color replay {context} is not finite"
+        )));
+    }
+    Ok(vec![real, imaginary])
+}
+
+fn eager_exact_real_factor(
+    decoded: &DecodedEagerRuntimeV3,
+    factor_id: u32,
+    context: &str,
+) -> RusticolResult<f64> {
+    let factor = eager_exact_factor(decoded, factor_id, context)?;
+    if factor[1] != 0.0 {
+        return Err(integrity(format!(
+            "eager color replay {context} is not real"
+        )));
+    }
+    Ok(factor[0])
+}
+
+fn build_topology_replay_manifest(
+    decoded: &DecodedEagerRuntimeV3,
+    retained: &RetainedTables<'_>,
+    expected_kind: u8,
+) -> RusticolResult<Option<LcTopologyReplayManifest>> {
+    let metadata = retained.table("lc_replay_metadata")?;
+    let present = retained.scalar_u8(metadata, "present")?;
+    let replay_kind = retained.scalar_u8(metadata, "replay_kind")?;
+    let physical_sequence_id = retained.scalar_u32(metadata, "physical_sector_ids_sequence_id")?;
+    let materialized_sequence_id =
+        retained.scalar_u32(metadata, "materialized_sector_ids_sequence_id")?;
+    let partitions = retained.table("lc_replay_partitions")?;
+    let members = retained.table("lc_replay_members")?;
+    let permutations = retained.table("lc_replay_permutations")?;
+    let residuals = retained.table("lc_replay_residual_sectors")?;
+    if present == 0 {
+        if replay_kind != 0 {
+            return Err(integrity(
+                "absent eager topology replay has a nonzero replay kind",
+            ));
+        }
+        if physical_sequence_id != crate::MISSING_U32
+            || materialized_sequence_id != crate::MISSING_U32
+            || partitions.row_count != 0
+            || members.row_count != 0
+            || permutations.row_count != 0
+            || residuals.row_count != 0
+        {
+            return Err(integrity(
+                "absent eager LC topology replay has retained payload rows",
+            ));
+        }
+        return Ok(None);
+    }
+    if replay_kind != expected_kind {
+        if replay_kind == 1 || replay_kind == 2 {
+            return Ok(None);
+        }
+        return Err(integrity(
+            "eager topology replay has an unknown replay kind",
+        ));
+    }
+    if present != 1
+        || physical_sequence_id == crate::MISSING_U32
+        || materialized_sequence_id == crate::MISSING_U32
+    {
+        return Err(integrity(
+            "eager LC topology replay metadata has an invalid presence contract",
+        ));
+    }
+
+    let physical_sector_ids = u32_sequence(decoded, physical_sequence_id, "LC physical sectors")?;
+    let materialized_sector_ids =
+        u32_sequence(decoded, materialized_sequence_id, "LC materialized sectors")?;
+    let representative_sector_ids =
+        retained.u32_column(partitions, "representative_sector_id", 1)?;
+    let partition_materialized_sector_ids =
+        retained.u32_column(partitions, "materialized_sector_id", 1)?;
+    let member_starts = retained.u64_column(partitions, "member_start", 1)?;
+    let member_counts = retained.u64_column(partitions, "member_count", 1)?;
+    let proof_algorithm_ids = retained.u32_column(partitions, "proof_algorithm_string_id", 1)?;
+    let proof_digest_ids = retained.u32_column(partitions, "proof_digest_string_id", 1)?;
+
+    let member_sector_ids = retained.u32_column(members, "sector_id", 1)?;
+    let member_factor_ids = retained.u32_column(members, "factor_id", 1)?;
+    let member_signs = retained.i32_column(members, "sign", 1)?;
+    let permutation_starts = retained.u64_column(members, "permutation_start", 1)?;
+    let permutation_counts = retained.u64_column(members, "permutation_count", 1)?;
+    let representative_labels = retained.u32_column(permutations, "representative_label", 1)?;
+    let sector_labels = retained.u32_column(permutations, "sector_label", 1)?;
+    let residual_sector_ids = retained.u32_column(residuals, "sector_id", 1)?;
+
+    let mut groups = Vec::with_capacity(partitions.row_count as usize);
+    let mut member_cursor = 0_usize;
+    let mut permutation_cursor = 0_usize;
+    for partition_index in 0..partitions.row_count as usize {
+        let member_start = usize_count(member_starts[partition_index], "LC replay member start")?;
+        let member_count = usize_count(member_counts[partition_index], "LC replay member count")?;
+        if member_start != member_cursor {
+            return Err(integrity(
+                "eager LC replay partition members are not canonical and contiguous",
+            ));
+        }
+        let member_stop = member_start
+            .checked_add(member_count)
+            .ok_or_else(|| RusticolError::artifact("LC replay member range overflows"))?;
+        if member_stop > members.row_count as usize {
+            return Err(integrity("eager LC replay member range is out of bounds"));
+        }
+        let mut active_sector_ids = Vec::with_capacity(member_count);
+        let mut sector_permutations = Vec::with_capacity(member_count);
+        for member_index in member_start..member_stop {
+            let permutation_start = usize_count(
+                permutation_starts[member_index],
+                "LC replay permutation start",
+            )?;
+            let permutation_count = usize_count(
+                permutation_counts[member_index],
+                "LC replay permutation count",
+            )?;
+            if permutation_start != permutation_cursor {
+                return Err(integrity(
+                    "eager LC replay permutations are not canonical and contiguous",
+                ));
+            }
+            let permutation_stop = permutation_start
+                .checked_add(permutation_count)
+                .ok_or_else(|| RusticolError::artifact("LC replay permutation range overflows"))?;
+            if permutation_stop > permutations.row_count as usize {
+                return Err(integrity(
+                    "eager LC replay permutation range is out of bounds",
+                ));
+            }
+            let sign = i8::try_from(member_signs[member_index])
+                .map_err(|_| integrity("eager LC replay sign does not fit i8"))?;
+            let factor = decoded
+                .exact_factors
+                .get(member_factor_ids[member_index] as usize)
+                .ok_or_else(|| integrity("eager LC replay factor is absent"))?;
+            let amplitude_factor = [
+                f64::from_bits(factor.real_bits),
+                f64::from_bits(factor.imaginary_bits),
+            ];
+            let weight = amplitude_factor[0] * f64::from(sign);
+            let label_permutation = (permutation_start..permutation_stop)
+                .map(|index| LcTopologyReplayLabelPermutationManifest {
+                    representative_label: representative_labels[index] as usize,
+                    sector_label: sector_labels[index] as usize,
+                })
+                .collect();
+            let sector_id = i64::from(member_sector_ids[member_index]);
+            active_sector_ids.push(sector_id);
+            sector_permutations.push(LcTopologyReplaySectorPermutationManifest {
+                sector_id,
+                weight,
+                sign,
+                factor: Some(amplitude_factor.to_vec()),
+                label_permutation,
+            });
+            permutation_cursor = permutation_stop;
+        }
+        groups.push(LcTopologyReplayGroupManifest {
+            representative_sector_id: i64::from(representative_sector_ids[partition_index]),
+            materialized_sector_id: i64::from(partition_materialized_sector_ids[partition_index]),
+            active_sector_ids,
+            proof: Some(LcTopologyReplayProofManifest {
+                status: "proven".to_string(),
+                algorithm: Some(
+                    string(
+                        decoded,
+                        proof_algorithm_ids[partition_index],
+                        "LC replay proof algorithm",
+                    )?
+                    .to_string(),
+                ),
+                digest: Some(
+                    string(
+                        decoded,
+                        proof_digest_ids[partition_index],
+                        "LC replay proof digest",
+                    )?
+                    .to_string(),
+                ),
+            }),
+            sector_permutations,
+        });
+        member_cursor = member_stop;
+    }
+    if member_cursor != members.row_count as usize
+        || permutation_cursor != permutations.row_count as usize
+    {
+        return Err(integrity(
+            "eager LC replay retained tables contain unreachable rows",
+        ));
+    }
+
+    Ok(Some(LcTopologyReplayManifest {
+        enabled: true,
+        mode: "external-label-permutation".to_string(),
+        contract_version: Some(2),
+        physical_sector_count: Some(physical_sector_ids.len()),
+        replayed_sector_count: members.row_count as usize,
+        materialized_sector_ids: materialized_sector_ids.into_iter().map(i64::from).collect(),
+        residual_sector_ids: residual_sector_ids.iter().copied().map(i64::from).collect(),
+        groups,
+    }))
+}
+
+fn validate_identity(
+    decoded: &DecodedEagerRuntimeV3,
+    manifest: &EagerV3ExecutionManifest,
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<()> {
+    physics.validate()?;
+    if decoded.process_key.as_ref() != manifest.key
+        || physics.process_id != manifest.key
+        || physics.process != manifest.process
+        || physics.color_accuracy.as_str() != manifest.color_accuracy
+        || physics.external_particles.len() != manifest.external_pdg_order.len()
+        || physics
+            .external_particles
+            .iter()
+            .map(|particle| particle.pdg)
+            .ne(manifest.external_pdg_order.iter().copied())
+    {
+        return Err(integrity(
+            "eager plan-v3 identity does not match its manifest and resolved physics",
+        ));
+    }
+    if decoded.currents.len() != usize_count(manifest.dag_summary.current_count, "current count")?
+        || decoded.sources.len() != usize_count(manifest.dag_summary.source_count, "source count")?
+        || decoded.closures.is_empty()
+    {
+        return Err(integrity(
+            "eager plan-v3 decoded counts do not match its DAG summary",
+        ));
+    }
+    Ok(())
+}
+
+fn build_model_parameters(
+    decoded: &DecodedEagerRuntimeV3,
+    retained: &RetainedTables<'_>,
+) -> RusticolResult<Vec<GenericRuntimeModelParameterManifest>> {
+    let table = retained.table("model_parameters")?;
+    let pdgs = retained.i32_column(table, "pdg", 1)?;
+    if pdgs.len() != decoded.parameters.len() {
+        return Err(integrity(
+            "retained model-parameter PDGs have the wrong row count",
+        ));
+    }
+    decoded
+        .parameters
+        .iter()
+        .zip(pdgs)
+        .map(|(row, pdg)| {
+            let index = usize::try_from(row.parameter_id)
+                .map_err(|_| RusticolError::artifact("parameter ID exceeds usize"))?;
+            let factor = decoded
+                .exact_factors
+                .get(row.default_factor_id as usize)
+                .ok_or_else(|| integrity("parameter default factor is absent"))?;
+            let default = f64::from_bits(factor.real_bits);
+            let imaginary = f64::from_bits(factor.imaginary_bits);
+            if !default.is_finite() || imaginary != 0.0 {
+                return Err(integrity(
+                    "eager model-parameter default is not finite and real",
+                ));
+            }
+            Ok(GenericRuntimeModelParameterManifest {
+                name: string(decoded, row.name_string_id, "parameter name")?.to_owned(),
+                kind: string(decoded, row.kind_string_id, "parameter kind")?.to_owned(),
+                parameter_index: index,
+                default,
+                pdg: (*pdg != MISSING_I32).then_some(*pdg),
+                runtime_name: optional_string(decoded, row.runtime_name_string_id)?
+                    .map(str::to_owned),
+                complex_component: match row.complex_component {
+                    -1 => None,
+                    0 => Some("real".to_owned()),
+                    1 => Some("imag".to_owned()),
+                    _ => return Err(integrity("invalid eager parameter complex component")),
+                },
+            })
+        })
+        .collect()
+}
+
+fn runtime_parameter_slots(
+    parameters: &[GenericRuntimeModelParameterManifest],
+) -> RusticolResult<BTreeMap<String, RuntimeParameterSlots>> {
+    let mut result = BTreeMap::new();
+    let mut complex = BTreeMap::<String, (Option<usize>, Option<usize>)>::new();
+    for parameter in parameters {
+        if let Some(name) = &parameter.runtime_name {
+            let slots = complex.entry(name.clone()).or_default();
+            let slot = match parameter.complex_component.as_deref() {
+                Some("real") => &mut slots.0,
+                Some("imag") => &mut slots.1,
+                _ => {
+                    return Err(integrity(
+                        "complex eager parameter lacks component metadata",
+                    ));
+                }
+            };
+            if slot.replace(parameter.parameter_index).is_some() {
+                return Err(integrity("duplicate eager complex parameter component"));
+            }
+        } else if result
+            .insert(
+                parameter.name.clone(),
+                RuntimeParameterSlots {
+                    real: parameter.parameter_index,
+                    imaginary: None,
+                },
+            )
+            .is_some()
+        {
+            return Err(integrity("duplicate eager scalar parameter"));
+        }
+    }
+    for (name, (real, imaginary)) in complex {
+        let real = real.ok_or_else(|| integrity("complex eager parameter lacks a real slot"))?;
+        if result
+            .insert(name, RuntimeParameterSlots { real, imaginary })
+            .is_some()
+        {
+            return Err(integrity("conflicting eager logical parameter"));
+        }
+    }
+    Ok(result)
+}
+
+fn direct_particle_masses(
+    parameters: &[GenericRuntimeModelParameterManifest],
+) -> RusticolResult<(BTreeMap<i32, f64>, BTreeMap<i32, String>)> {
+    let mut masses = BTreeMap::new();
+    let mut names = BTreeMap::new();
+    for parameter in parameters {
+        if parameter.kind != "particle_mass" {
+            continue;
+        }
+        let pdg = parameter
+            .pdg
+            .ok_or_else(|| integrity("particle-mass parameter lacks a retained PDG"))?;
+        if parameter.default < 0.0
+            || masses.insert(pdg, parameter.default).is_some()
+            || names.insert(pdg, parameter.name.clone()).is_some()
+        {
+            return Err(integrity("invalid or duplicate particle-mass parameter"));
+        }
+    }
+    Ok((masses, names))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_sources(
+    decoded: &DecodedEagerRuntimeV3,
+    retained: &RetainedTables<'_>,
+    physics: &ProcessPhysicsV1,
+    runtime_slots: &BTreeMap<String, RuntimeParameterSlots>,
+    parameter_values: &[f64],
+    particle_masses: &mut BTreeMap<i32, f64>,
+    mass_names: &mut BTreeMap<i32, String>,
+) -> RusticolResult<Vec<GenericSourceRecordManifest>> {
+    let currents = retained.table("currents")?;
+    let particle_ids = retained.i32_column(currents, "particle_id", 1)?;
+    let source_labels = retained.u32_column(currents, "source_leg_label", 1)?;
+    let source_helicities = retained.i32_column(currents, "source_helicity", 1)?;
+    let chiralities = retained.i32_column(currents, "chirality", 1)?;
+    let spin_state_ids = retained.u32_column(currents, "spin_state_sequence_id", 1)?;
+    let ancestry_ids = retained.u32_column(currents, "helicity_ancestry_bitset_id", 1)?;
+    for column in [
+        particle_ids.len(),
+        source_labels.len(),
+        source_helicities.len(),
+        chiralities.len(),
+        spin_state_ids.len(),
+        ancestry_ids.len(),
+    ] {
+        if column != decoded.currents.len() {
+            return Err(integrity(
+                "retained current metadata has the wrong row count",
+            ));
+        }
+    }
+
+    let mut source_parameter_start = 0usize;
+    let mut source_ir_by_momentum_slot = BTreeMap::new();
+    let mut source_ir_by_canonical_id = BTreeMap::new();
+    decoded
+        .sources
+        .iter()
+        .enumerate()
+        .map(|(index, row)| {
+            let current_index = row.current_id as usize;
+            let current = decoded
+                .currents
+                .get(current_index)
+                .ok_or_else(|| integrity("eager source current is absent"))?;
+            let value = decoded
+                .values
+                .get(row.value_slot_id as usize)
+                .ok_or_else(|| integrity("eager source value slot is absent"))?;
+            let particle = physics
+                .external_particles
+                .get(row.input_momentum_slot as usize)
+                .ok_or_else(|| integrity("eager source external particle is absent"))?;
+            let source_ir: GenericSourceIrManifest =
+                canonical_ir(decoded, row.source_ir_id, "source IR")?;
+            let applied_crossing: GenericCrossingIrManifest =
+                canonical_ir(decoded, row.crossing_ir_id, "source crossing IR")?;
+            let declared = source_ir
+                .states
+                .get(row.declared_state_index as usize)
+                .ok_or_else(|| integrity("eager source declared state is absent"))?;
+            let state = declared
+                .transformed(&applied_crossing)
+                .map_err(|message| integrity(format!("invalid eager source state: {message}")))?;
+            let crossing_factor = decoded
+                .exact_factors
+                .get(row.crossing_factor_id as usize)
+                .ok_or_else(|| integrity("eager source crossing factor is absent"))?;
+            if crossing_factor.real_bits != applied_crossing.phase[0].to_bits()
+                || crossing_factor.imaginary_bits != applied_crossing.phase[1].to_bits()
+            {
+                return Err(integrity(
+                    "eager source crossing factor disagrees with its IR",
+                ));
+            }
+            let expected_outgoing = match particle.role {
+                crate::ParticleRole::Initial => source_ir.identity.anti_pdg_label,
+                crate::ParticleRole::Final => source_ir.identity.pdg_label,
+            };
+            if particle.label != row.external_label as usize
+                || particle.momentum_slot != row.input_momentum_slot as usize
+                || particle.pdg != expected_outgoing
+                || particle_ids[current_index] != source_ir.identity.pdg_label
+                || source_labels[current_index] != row.external_label
+                || source_helicities[current_index] != state.helicity
+                || chiralities[current_index] != state.chirality
+                || current.component_count as usize != source_ir.component_dimension
+                || value.component_count != current.component_count
+                || value.current_id != row.current_id
+            {
+                return Err(integrity(
+                    "eager source metadata is internally inconsistent",
+                ));
+            }
+            let retained_spin = i32_sequence(decoded, spin_state_ids[current_index])?;
+            let expected_spin = match &state.spin_state {
+                GenericSourceSpinStateManifest::Scalar(value) => vec![*value],
+                GenericSourceSpinStateManifest::Components(values) => values.clone(),
+            };
+            if retained_spin != expected_spin {
+                return Err(integrity(
+                    "eager source spin state disagrees with retained metadata",
+                ));
+            }
+            bind_source_mass(
+                &source_ir,
+                runtime_slots,
+                parameter_values,
+                particle_masses,
+                mass_names,
+            )?;
+            let dimension = source_ir.component_dimension;
+            let current_start = usize_count(current.component_start, "source current start")?;
+            let value_start = usize_count(value.component_start, "source value start")?;
+            let source_parameter_stop = source_parameter_start
+                .checked_add(dimension)
+                .ok_or_else(|| RusticolError::artifact("source parameter layout overflows"))?;
+            let side = match particle.role {
+                crate::ParticleRole::Initial => "initial",
+                crate::ParticleRole::Final => "final",
+            };
+            let source = GenericSourceRecordManifest {
+                source_id: index,
+                current_id: current_index,
+                current_component_start: current_start,
+                current_component_stop: current_start + dimension,
+                value_slot: GenericValueSlotRefManifest {
+                    value_slot_id: row.value_slot_id as usize,
+                    current_id: current_index,
+                    variant: "source".to_owned(),
+                    component_start: value_start,
+                    component_stop: value_start + dimension,
+                    dimension,
+                },
+                source_parameter_start,
+                source_parameter_stop,
+                leg_label: row.external_label as usize,
+                input_momentum_slot: row.input_momentum_slot as usize,
+                side: side.to_owned(),
+                crossing: applied_crossing
+                    .momentum_transform
+                    .legacy_projection()
+                    .to_owned(),
+                physical_pdg: particle.pdg,
+                outgoing_pdg: source_ir.identity.pdg_label,
+                particle_id: source_ir.identity.pdg_label,
+                anti_particle_id: source_ir.identity.anti_pdg_label,
+                source_kind: "external-wavefunction".to_owned(),
+                wavefunction_kind: source_ir.wavefunction_family.as_str().to_owned(),
+                source_orientation: source_ir.identity.orientation,
+                source_basis: source_ir.basis.clone(),
+                source_ir,
+                applied_crossing,
+                source_helicity: state.helicity,
+                chirality: state.chirality,
+                spin_state: spin_state_value(&state.spin_state),
+                dimension,
+                helicity_ancestry: Value::String(bitset_decimal(
+                    decoded,
+                    ancestry_ids[current_index],
+                )?),
+                color_state: json!({"accuracy": manifest_color_accuracy(physics)}),
+            };
+            super::validation::validate_source_wavefunction_metadata(index, &source)?;
+            super::validation::validate_consistent_source_ir(
+                &mut source_ir_by_momentum_slot,
+                &mut source_ir_by_canonical_id,
+                index,
+                &source,
+            )?;
+            source_parameter_start = source_parameter_stop;
+            Ok(source)
+        })
+        .collect()
+}
+
+fn bind_source_mass(
+    source_ir: &GenericSourceIrManifest,
+    runtime_slots: &BTreeMap<String, RuntimeParameterSlots>,
+    parameter_values: &[f64],
+    particle_masses: &mut BTreeMap<i32, f64>,
+    mass_names: &mut BTreeMap<i32, String>,
+) -> RusticolResult<()> {
+    let Some(name) = source_ir.mass_parameter.as_ref() else {
+        return Ok(());
+    };
+    let slots = runtime_slots.get(name).ok_or_else(|| {
+        integrity(format!(
+            "massive eager source references unbound mass parameter {name:?}"
+        ))
+    })?;
+    if slots
+        .imaginary
+        .and_then(|index| parameter_values.get(index))
+        .is_some_and(|value| *value != 0.0)
+    {
+        return Err(integrity(
+            "eager source mass parameter has a nonzero imaginary component",
+        ));
+    }
+    let mass = *parameter_values
+        .get(slots.real)
+        .ok_or_else(|| integrity("eager source mass parameter slot is absent"))?;
+    if !mass.is_finite() || mass < 0.0 {
+        return Err(integrity("eager source mass parameter is invalid"));
+    }
+    for pdg in [
+        source_ir.identity.pdg_label,
+        source_ir.identity.anti_pdg_label,
+    ] {
+        if particle_masses
+            .insert(pdg, mass)
+            .is_some_and(|previous| previous.to_bits() != mass.to_bits())
+            || mass_names
+                .insert(pdg, name.clone())
+                .is_some_and(|previous| previous != *name)
+        {
+            return Err(integrity("eager source has conflicting mass bindings"));
+        }
+    }
+    Ok(())
+}
+
+fn build_momentum_slots(
+    decoded: &DecodedEagerRuntimeV3,
+    external_count: usize,
+) -> RusticolResult<Vec<GenericMomentumSlotManifest>> {
+    decoded
+        .momenta
+        .iter()
+        .map(|row| {
+            if row.component_count != 4 {
+                return Err(integrity(
+                    "eager momentum slot does not contain four components",
+                ));
+            }
+            let external_labels = bitset_labels(decoded, row.bitset_id, external_count)?;
+            if external_labels.is_empty() {
+                return Err(integrity("eager momentum slot has an empty external mask"));
+            }
+            let start = usize_count(row.component_start, "momentum component start")?;
+            Ok(GenericMomentumSlotManifest {
+                momentum_slot_id: row.momentum_slot_id as usize,
+                momentum_mask: bitset_u64(decoded, row.bitset_id)?,
+                external_labels,
+                component_start: start,
+                component_stop: start + 4,
+                real_valued: true,
+            })
+        })
+        .collect()
+}
+
+fn validate_physics_parameters(
+    runtime: &[GenericRuntimeModelParameterManifest],
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<()> {
+    let mut projected = BTreeMap::<String, (crate::ParameterKind, f64, f64)>::new();
+    for parameter in runtime {
+        let name = parameter
+            .runtime_name
+            .as_ref()
+            .unwrap_or(&parameter.name)
+            .clone();
+        let kind = public_parameter_kind(&parameter.kind)?;
+        let entry = projected.entry(name).or_insert((kind, 0.0, 0.0));
+        if entry.0 != kind {
+            return Err(integrity("eager logical parameter has inconsistent kinds"));
+        }
+        match parameter.complex_component.as_deref() {
+            Some("imag") => entry.2 = parameter.default,
+            _ => entry.1 = parameter.default,
+        }
+    }
+    if projected.len() != physics.model_parameters.len() {
+        return Err(integrity(
+            "eager runtime and resolved physics parameter counts disagree",
+        ));
+    }
+    for parameter in &physics.model_parameters {
+        let Some((kind, real, imaginary)) = projected.get(&parameter.name) else {
+            return Err(integrity(
+                "resolved physics parameter is absent from eager runtime",
+            ));
+        };
+        if *kind != parameter.kind
+            || real.to_bits() != parameter.default_real.to_bits()
+            || imaginary.to_bits() != parameter.default_imaginary.to_bits()
+        {
+            return Err(integrity(format!(
+                "eager runtime parameter {:?} disagrees with resolved physics: \
+                 runtime kind={kind:?} defaults=({:#018x},{:#018x}), \
+                 physics kind={:?} defaults=({:#018x},{:#018x})",
+                parameter.name,
+                real.to_bits(),
+                imaginary.to_bits(),
+                parameter.kind,
+                parameter.default_real.to_bits(),
+                parameter.default_imaginary.to_bits(),
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn public_parameter_kind(kind: &str) -> RusticolResult<crate::ParameterKind> {
+    match kind {
+        "normalization" => Ok(crate::ParameterKind::Normalization),
+        "particle_mass" => Ok(crate::ParameterKind::Mass),
+        "particle_width" => Ok(crate::ParameterKind::Width),
+        "coupling_component" => Ok(crate::ParameterKind::Coupling),
+        "external_parameter" | "external_parameter_component" => Ok(crate::ParameterKind::External),
+        "derived_parameter_component" => Ok(crate::ParameterKind::Derived),
+        _ => Err(RusticolError::compatibility(format!(
+            "unsupported eager model-parameter kind {kind:?}"
+        ))),
+    }
+}
+
+#[derive(Deserialize)]
+struct CanonicalNormalization {
+    #[serde(default = "one")]
+    color_factor: f64,
+    #[serde(default = "one")]
+    global_coupling_factor: f64,
+    #[serde(default = "one")]
+    average_factor: f64,
+    #[serde(default = "one")]
+    identical_factor: f64,
+    #[serde(default)]
+    qcd_coupling_power: usize,
+    #[serde(default)]
+    electroweak_coupling_power: usize,
+}
+
+impl CanonicalNormalization {
+    fn validate(&self) -> RusticolResult<()> {
+        if !self.color_factor.is_finite()
+            || !self.global_coupling_factor.is_finite()
+            || !self.average_factor.is_finite()
+            || !self.identical_factor.is_finite()
+            || self.average_factor <= 0.0
+            || self.identical_factor <= 0.0
+        {
+            return Err(integrity("invalid eager runtime normalization IR"));
+        }
+        Ok(())
+    }
+}
+
+fn one() -> f64 {
+    1.0
+}
+
+struct RetainedTables<'a> {
+    tables: &'a [DecodedEagerRetainedTable],
+}
+
+impl<'a> RetainedTables<'a> {
+    fn new(tables: &'a [DecodedEagerRetainedTable]) -> Self {
+        Self { tables }
+    }
+
+    fn table(&self, name: &str) -> RusticolResult<&'a DecodedEagerRetainedTable> {
+        let mut matches = self
+            .tables
+            .iter()
+            .filter(|table| table.name.as_ref() == name);
+        let table = matches
+            .next()
+            .ok_or_else(|| integrity(format!("retained eager table {name:?} is absent")))?;
+        if matches.next().is_some() {
+            return Err(integrity(format!(
+                "retained eager table {name:?} is duplicated"
+            )));
+        }
+        Ok(table)
+    }
+
+    fn scalar_u32(&self, table: &DecodedEagerRetainedTable, name: &str) -> RusticolResult<u32> {
+        let values = self.u32_column(table, name, 1)?;
+        if table.row_count != 1 || values.len() != 1 {
+            return Err(integrity(format!(
+                "retained eager scalar {}.{name} has the wrong shape",
+                table.name
+            )));
+        }
+        Ok(values[0])
+    }
+
+    fn scalar_u8(&self, table: &DecodedEagerRetainedTable, name: &str) -> RusticolResult<u8> {
+        let values = self.u8_column(table, name, 1)?;
+        if table.row_count != 1 || values.len() != 1 {
+            return Err(integrity(format!(
+                "retained eager scalar {}.{name} has the wrong shape",
+                table.name
+            )));
+        }
+        Ok(values[0])
+    }
+
+    fn scalar_u64(&self, table: &DecodedEagerRetainedTable, name: &str) -> RusticolResult<u64> {
+        let values = self.u64_column(table, name, 1)?;
+        if table.row_count != 1 || values.len() != 1 {
+            return Err(integrity(format!(
+                "retained eager scalar {}.{name} has the wrong shape",
+                table.name
+            )));
+        }
+        Ok(values[0])
+    }
+
+    fn u8_column(
+        &self,
+        table: &'a DecodedEagerRetainedTable,
+        name: &str,
+        elements_per_row: u32,
+    ) -> RusticolResult<&'a [u8]> {
+        let column = retained_column(table, name, elements_per_row)?;
+        match &column.values {
+            DecodedEagerPrimitiveColumn::U8(values) => Ok(values),
+            _ => Err(integrity(format!(
+                "retained eager column {}.{name} is not u8",
+                table.name
+            ))),
+        }
+    }
+
+    fn u32_column(
+        &self,
+        table: &'a DecodedEagerRetainedTable,
+        name: &str,
+        elements_per_row: u32,
+    ) -> RusticolResult<&'a [u32]> {
+        let column = retained_column(table, name, elements_per_row)?;
+        match &column.values {
+            DecodedEagerPrimitiveColumn::U32(values) => Ok(values),
+            _ => Err(integrity(format!(
+                "retained eager column {}.{name} is not u32",
+                table.name
+            ))),
+        }
+    }
+
+    fn i32_column(
+        &self,
+        table: &'a DecodedEagerRetainedTable,
+        name: &str,
+        elements_per_row: u32,
+    ) -> RusticolResult<&'a [i32]> {
+        let column = retained_column(table, name, elements_per_row)?;
+        match &column.values {
+            DecodedEagerPrimitiveColumn::I32(values) => Ok(values),
+            _ => Err(integrity(format!(
+                "retained eager column {}.{name} is not i32",
+                table.name
+            ))),
+        }
+    }
+
+    fn u64_column(
+        &self,
+        table: &'a DecodedEagerRetainedTable,
+        name: &str,
+        elements_per_row: u32,
+    ) -> RusticolResult<&'a [u64]> {
+        let column = retained_column(table, name, elements_per_row)?;
+        match &column.values {
+            DecodedEagerPrimitiveColumn::U64(values) => Ok(values),
+            _ => Err(integrity(format!(
+                "retained eager column {}.{name} is not u64",
+                table.name
+            ))),
+        }
+    }
+}
+
+fn retained_column<'a>(
+    table: &'a DecodedEagerRetainedTable,
+    name: &str,
+    elements_per_row: u32,
+) -> RusticolResult<&'a super::eager_v3_decode::DecodedEagerRetainedColumn> {
+    let mut matches = table
+        .columns
+        .iter()
+        .filter(|column| column.name.as_ref() == name);
+    let column = matches.next().ok_or_else(|| {
+        integrity(format!(
+            "retained eager column {}.{name} is absent",
+            table.name
+        ))
+    })?;
+    if matches.next().is_some() || column.elements_per_row != elements_per_row {
+        return Err(integrity(format!(
+            "retained eager column {}.{name} has a non-canonical shape",
+            table.name
+        )));
+    }
+    Ok(column)
+}
+
+fn canonical_ir<T: for<'de> Deserialize<'de>>(
+    decoded: &DecodedEagerRuntimeV3,
+    id: u32,
+    context: &str,
+) -> RusticolResult<T> {
+    let payload = decoded
+        .exact_ir
+        .get(id as usize)
+        .ok_or_else(|| integrity(format!("{context} references absent canonical IR {id}")))?;
+    serde_json::from_str(payload).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse eager {context} canonical IR {id}: {error}"
+        ))
+    })
+}
+
+fn string<'a>(
+    decoded: &'a DecodedEagerRuntimeV3,
+    id: u32,
+    context: &str,
+) -> RusticolResult<&'a str> {
+    decoded
+        .strings
+        .get(id as usize)
+        .map(AsRef::as_ref)
+        .ok_or_else(|| integrity(format!("{context} string {id} is absent")))
+}
+
+fn optional_string(decoded: &DecodedEagerRuntimeV3, id: u32) -> RusticolResult<Option<&str>> {
+    if id == crate::MISSING_U32 {
+        Ok(None)
+    } else {
+        string(decoded, id, "optional parameter").map(Some)
+    }
+}
+
+fn i32_sequence(decoded: &DecodedEagerRuntimeV3, id: u32) -> RusticolResult<Vec<i32>> {
+    let range = decoded
+        .i32_sequence_ranges
+        .get(id as usize)
+        .ok_or_else(|| integrity("retained current references absent i32 sequence"))?;
+    checked_catalog_range(
+        &decoded.i32_sequence_values,
+        range.start,
+        range.count,
+        "i32 sequence",
+    )
+    .map(<[i32]>::to_vec)
+}
+
+fn u32_sequence(
+    decoded: &DecodedEagerRuntimeV3,
+    id: u32,
+    context: &str,
+) -> RusticolResult<Vec<u32>> {
+    let range = decoded
+        .u32_sequence_ranges
+        .get(id as usize)
+        .ok_or_else(|| integrity(format!("eager metadata references absent {context}")))?;
+    checked_catalog_range(
+        &decoded.u32_sequence_values,
+        range.start,
+        range.count,
+        context,
+    )
+    .map(<[u32]>::to_vec)
+}
+
+fn bitset_words(decoded: &DecodedEagerRuntimeV3, id: u32) -> RusticolResult<&[u64]> {
+    let range = decoded
+        .bitset_ranges
+        .get(id as usize)
+        .ok_or_else(|| integrity("eager metadata references absent bitset"))?;
+    checked_catalog_range(&decoded.bitset_words, range.start, range.count, "bitset")
+}
+
+fn bitset_u64(decoded: &DecodedEagerRuntimeV3, id: u32) -> RusticolResult<u64> {
+    let words = bitset_words(decoded, id)?;
+    if words.iter().skip(1).any(|word| *word != 0) {
+        return Err(RusticolError::compatibility(
+            "eager momentum metadata cannot project a bitset wider than 64 bits",
+        ));
+    }
+    Ok(words.first().copied().unwrap_or(0))
+}
+
+fn bitset_decimal(decoded: &DecodedEagerRuntimeV3, id: u32) -> RusticolResult<String> {
+    Ok(bitset_words_decimal(bitset_words(decoded, id)?))
+}
+
+fn bitset_words_decimal(words: &[u64]) -> String {
+    const BASE: u128 = 1_000_000_000;
+    const WORD_RADIX: u128 = 1_u128 << 64;
+
+    let mut decimal_limbs = vec![0_u32];
+    for word in words.iter().rev().copied() {
+        let mut carry = u128::from(word);
+        for limb in &mut decimal_limbs {
+            let value = u128::from(*limb) * WORD_RADIX + carry;
+            *limb = (value % BASE) as u32;
+            carry = value / BASE;
+        }
+        while carry != 0 {
+            decimal_limbs.push((carry % BASE) as u32);
+            carry /= BASE;
+        }
+    }
+
+    let mut limbs = decimal_limbs.iter().rev();
+    let mut result = limbs.next().copied().unwrap_or(0).to_string();
+    for limb in limbs {
+        use std::fmt::Write as _;
+        write!(&mut result, "{limb:09}").expect("writing to a string cannot fail");
+    }
+    result
+}
+
+fn bitset_labels(
+    decoded: &DecodedEagerRuntimeV3,
+    id: u32,
+    external_count: usize,
+) -> RusticolResult<Vec<usize>> {
+    let mut labels = Vec::new();
+    for (word_index, word) in bitset_words(decoded, id)?.iter().copied().enumerate() {
+        for bit in 0..64 {
+            if word & (1_u64 << bit) == 0 {
+                continue;
+            }
+            let index = word_index
+                .checked_mul(64)
+                .and_then(|start| start.checked_add(bit))
+                .ok_or_else(|| RusticolError::artifact("eager momentum label overflows"))?;
+            if index >= external_count {
+                return Err(integrity(
+                    "eager momentum mask exceeds the external-particle count",
+                ));
+            }
+            labels.push(index + 1);
+        }
+    }
+    Ok(labels)
+}
+
+fn checked_catalog_range<'a, T>(
+    values: &'a [T],
+    start: u64,
+    count: u64,
+    context: &str,
+) -> RusticolResult<&'a [T]> {
+    let start = usize_count(start, context)?;
+    let count = usize_count(count, context)?;
+    let stop = start
+        .checked_add(count)
+        .ok_or_else(|| RusticolError::artifact(format!("eager {context} range overflows")))?;
+    values
+        .get(start..stop)
+        .ok_or_else(|| integrity(format!("eager {context} range is out of bounds")))
+}
+
+fn component_count<T>(rows: &[T], context: &str) -> RusticolResult<usize>
+where
+    T: ComponentRow,
+{
+    rows.iter().try_fold(0usize, |total, row| {
+        total
+            .checked_add(row.component_count() as usize)
+            .ok_or_else(|| RusticolError::artifact(format!("eager {context} layout overflows")))
+    })
+}
+
+trait ComponentRow {
+    fn component_count(&self) -> u32;
+}
+
+impl ComponentRow for crate::eager_lowering_v3::EagerPlanValueRow {
+    fn component_count(&self) -> u32 {
+        self.component_count
+    }
+}
+
+impl ComponentRow for crate::eager_lowering_v3::EagerPlanMomentumRow {
+    fn component_count(&self) -> u32 {
+        self.component_count
+    }
+}
+
+fn spin_state_value(state: &GenericSourceSpinStateManifest) -> Value {
+    match state {
+        GenericSourceSpinStateManifest::Scalar(value) => Value::from(*value),
+        GenericSourceSpinStateManifest::Components(values) => json!(values),
+    }
+}
+
+fn manifest_color_accuracy(physics: &ProcessPhysicsV1) -> &'static str {
+    match physics.color_accuracy {
+        crate::ColorAccuracy::Lc => "lc",
+        crate::ColorAccuracy::Nlc => "nlc",
+        crate::ColorAccuracy::Full => "full",
+    }
+}
+
+fn usize_count(value: u64, context: &str) -> RusticolResult<usize> {
+    usize::try_from(value)
+        .map_err(|_| RusticolError::artifact(format!("eager {context} exceeds usize")))
+}
+
+fn integrity(message: impl Into<String>) -> RusticolError {
+    RusticolError::integrity(message.into())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::bitset_words_decimal;
+
+    #[test]
+    fn arbitrary_width_bitsets_project_to_decimal_strings() {
+        assert_eq!(bitset_words_decimal(&[]), "0");
+        assert_eq!(bitset_words_decimal(&[1]), "1");
+        assert_eq!(bitset_words_decimal(&[u64::MAX]), "18446744073709551615");
+        assert_eq!(bitset_words_decimal(&[0, 1]), "18446744073709551616");
+        assert_eq!(bitset_words_decimal(&[1, 2]), "36893488147419103233");
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_decode.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_decode.rs
new file mode 100644
index 0000000000..f5bd5d3532
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_decode.rs
@@ -0,0 +1,3271 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Compact decoder for authenticated eager plan-v3 PACBIN containers.
+//!
+//! The decoder borrows each PACBIN member while checking its fixed-width wire
+//! contract, then allocates only the final typed runtime/exact structures.  It
+//! deliberately does not recreate the former expanded JSON `runtime_schema`.
+
+use super::eager_manifest::PreparedKernelPackManifest;
+use super::eager_v3_manifest::EagerV3ExecutionManifest;
+use crate::eager_layout::{
+    EAGER_LOWERING_INPUT_ABI, EAGER_PLAN_ABI, EAGER_RUNTIME_CAPABILITY,
+    EAGER_RUNTIME_CONTAINER_KIND, EAGER_RUNTIME_CONTAINER_SCHEMA, EAGER_RUNTIME_LAYOUT_ABI,
+    EagerSectionHeader, EagerSectionKind,
+};
+use crate::eager_lowering_v3::{
+    EagerPlanAttachmentRow, EagerPlanCatalogRangeRow, EagerPlanClosureRow,
+    EagerPlanColorSelectorRow, EagerPlanCouplingRow, EagerPlanCurrentRow,
+    EagerPlanDirectCoefficientRow, EagerPlanExactFactorRow, EagerPlanFinalizationRow,
+    EagerPlanHelicitySelectorRow, EagerPlanInvocationRow, EagerPlanMomentumRow,
+    EagerPlanParameterRow, EagerPlanReductionEntryKind, EagerPlanReductionEntryRow,
+    EagerPlanReductionGroupRow, EagerPlanSelectorDomainRow, EagerPlanSourceFillRow,
+    EagerPlanStageRow, EagerPlanValueRow, EagerValueSlotKind,
+};
+use crate::eager_runtime::{EagerKernelRole, EagerKernelSpec, EagerPlanDimensions};
+use crate::pacbin::PacbinReader;
+use crate::{MISSING_U32, RusticolError, RusticolResult};
+use std::collections::{BTreeMap, BTreeSet, HashSet};
+
+const SERIALIZATION_SCHEMA: u32 = 1;
+const METADATA_RECORD_SIZE: u32 = 224;
+const INSPECTION_RECORD_SIZE: u32 = 160;
+const RETAINED_TABLE_RECORD_SIZE: u32 = 40;
+const RETAINED_COLUMN_RECORD_SIZE: u32 = 40;
+const DIRECT_COEFFICIENT_RECORD_SIZE: u32 = 16;
+const HELICITY_SELECTOR_RECORD_SIZE: u32 = 24;
+const COLOR_SELECTOR_RECORD_SIZE: u32 = 24;
+
+const RETAINED_U8: u8 = 1;
+const RETAINED_U32: u8 = 2;
+const RETAINED_U64: u8 = 3;
+const RETAINED_I32: u8 = 4;
+const RETAINED_F64_BITS: u8 = 5;
+
+const IDENTITY_PROCESS_KEY: usize = 5;
+const IDENTITY_MODEL_NAME: usize = 6;
+const IDENTITY_COUNT: usize = 7;
+
+/// One retained primitive column used by exact execution and inspection.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) enum DecodedEagerPrimitiveColumn {
+    U8(Vec<u8>),
+    U32(Vec<u32>),
+    U64(Vec<u64>),
+    I32(Vec<i32>),
+    /// Raw binary64 bits preserve signed zero and NaN payloads.
+    F64Bits(Vec<u64>),
+    /// Authenticated and shape-validated retained data not needed by f64 load.
+    ValidatedOnly {
+        len: usize,
+    },
+}
+
+impl DecodedEagerPrimitiveColumn {
+    fn len(&self) -> usize {
+        match self {
+            Self::U8(values) => values.len(),
+            Self::U32(values) => values.len(),
+            Self::U64(values) | Self::F64Bits(values) => values.len(),
+            Self::I32(values) => values.len(),
+            Self::ValidatedOnly { len } => *len,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct DecodedEagerRetainedColumn {
+    pub(super) name: Box<str>,
+    pub(super) elements_per_row: u32,
+    pub(super) values: DecodedEagerPrimitiveColumn,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct DecodedEagerRetainedTable {
+    pub(super) name: Box<str>,
+    pub(super) row_count: u64,
+    pub(super) columns: Vec<DecodedEagerRetainedColumn>,
+}
+
+/// Final compact owned form consumed by the plan-v3 runtime adapter.
+#[derive(Clone, Debug, PartialEq)]
+pub(super) struct DecodedEagerRuntimeV3 {
+    pub(super) process_key: Box<str>,
+    pub(super) model_name: Box<str>,
+    pub(super) runtime_options: DecodedEagerRuntimeOptions,
+    pub(super) dimensions: EagerPlanDimensions,
+    pub(super) kernel_specs: Vec<EagerKernelSpec>,
+    pub(super) strings: Vec<Box<str>>,
+    pub(super) exact_ir: Vec<Box<str>>,
+    pub(super) semantic_limitations: Vec<Box<str>>,
+    pub(super) retained_tables: Vec<DecodedEagerRetainedTable>,
+    pub(super) currents: Vec<EagerPlanCurrentRow>,
+    pub(super) values: Vec<EagerPlanValueRow>,
+    pub(super) momenta: Vec<EagerPlanMomentumRow>,
+    pub(super) sources: Vec<EagerPlanSourceFillRow>,
+    pub(super) parameters: Vec<EagerPlanParameterRow>,
+    pub(super) stages: Vec<EagerPlanStageRow>,
+    pub(super) couplings: Vec<EagerPlanCouplingRow>,
+    pub(super) invocations: Vec<EagerPlanInvocationRow>,
+    pub(super) attachments: Vec<EagerPlanAttachmentRow>,
+    pub(super) finalizations: Vec<EagerPlanFinalizationRow>,
+    pub(super) closures: Vec<EagerPlanClosureRow>,
+    pub(super) direct_coefficients: Vec<EagerPlanDirectCoefficientRow>,
+    pub(super) selector_domains: Vec<EagerPlanSelectorDomainRow>,
+    pub(super) selector_memberships: Vec<u32>,
+    pub(super) helicity_selectors: Vec<EagerPlanHelicitySelectorRow>,
+    pub(super) color_selectors: Vec<EagerPlanColorSelectorRow>,
+    pub(super) reduction_groups: Vec<EagerPlanReductionGroupRow>,
+    pub(super) reduction_entries: Vec<EagerPlanReductionEntryRow>,
+    pub(super) exact_factors: Vec<EagerPlanExactFactorRow>,
+    pub(super) bitset_ranges: Vec<EagerPlanCatalogRangeRow>,
+    pub(super) bitset_populations: Vec<u64>,
+    pub(super) bitset_words: Vec<u64>,
+    pub(super) u32_sequence_ranges: Vec<EagerPlanCatalogRangeRow>,
+    pub(super) u32_sequence_values: Vec<u32>,
+    pub(super) i32_sequence_ranges: Vec<EagerPlanCatalogRangeRow>,
+    pub(super) i32_sequence_values: Vec<i32>,
+    pub(super) color_contraction_entry_start: u64,
+    pub(super) color_contraction_entry_count: u64,
+}
+
+/// Reduction-only owned form used to hydrate compact public physics metadata.
+///
+/// The enclosing PACBIN has already been authenticated in full. This view
+/// materializes only reduction rows, selector rows, and selector-referenced
+/// sequence values; all unrelated runtime tables and global sequence-catalog
+/// entries are limited to borrowed fixed-width validation.
+#[derive(Debug)]
+pub(super) struct DecodedEagerReductionGroupsV3 {
+    pub(super) helicity_selectors: Vec<EagerPlanHelicitySelectorRow>,
+    pub(super) color_selectors: Vec<EagerPlanColorSelectorRow>,
+    pub(super) reduction_groups: Vec<EagerPlanReductionGroupRow>,
+    pub(super) reduction_entries: Vec<EagerPlanReductionEntryRow>,
+    pub(super) helicity_sequences: BTreeMap<u32, Vec<i32>>,
+    pub(super) color_sequences: BTreeMap<u32, Vec<u32>>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) struct DecodedEagerRuntimeOptions {
+    pub(super) point_tile_size: usize,
+    pub(super) workspace_bytes: usize,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct Metadata {
+    retained_column_count: u64,
+    current_component_count: u64,
+    value_component_count: u64,
+    momentum_component_count: u64,
+    color_contraction_entry_start: u64,
+    color_contraction_entry_count: u64,
+    string_count: u64,
+    exact_ir_count: u64,
+    limitation_count: u64,
+    retained_table_count: u64,
+    current_count: u64,
+    value_count: u64,
+    momentum_count: u64,
+    source_count: u64,
+    stage_count: u64,
+    invocation_count: u64,
+    closure_count: u64,
+    direct_coefficient_count: u64,
+    helicity_selector_count: u64,
+    color_selector_count: u64,
+    exact_factor_count: u64,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct RetainedTableRecord {
+    table_id: u32,
+    name_id: u32,
+    row_count: u64,
+    column_start: u64,
+    column_count: u64,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct RetainedColumnRecord {
+    table_id: u32,
+    column_id: u32,
+    name_id: u32,
+    primitive_kind: u8,
+    elements_per_row: u32,
+    value_start: u64,
+    value_count: u64,
+}
+
+struct RetainedPrimitiveSections<'a> {
+    u8_values: DecodedSection<'a>,
+    u32_values: DecodedSection<'a>,
+    u64_values: DecodedSection<'a>,
+    i32_values: DecodedSection<'a>,
+    f64_values: DecodedSection<'a>,
+}
+
+#[derive(Clone, Copy)]
+struct CountedPlanSection {
+    path: &'static str,
+    kind: EagerSectionKind,
+    record_size: u32,
+}
+
+const COUNTED_PLAN_SECTIONS: [CountedPlanSection; 20] = [
+    CountedPlanSection {
+        path: "tables/currents.bin",
+        kind: EagerSectionKind::CurrentLayout,
+        record_size: EagerPlanCurrentRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/values.bin",
+        kind: EagerSectionKind::ValueLayout,
+        record_size: EagerPlanValueRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/momenta.bin",
+        kind: EagerSectionKind::MomentumLayout,
+        record_size: EagerPlanMomentumRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/sources.bin",
+        kind: EagerSectionKind::SourceFill,
+        record_size: EagerPlanSourceFillRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/parameters.bin",
+        kind: EagerSectionKind::ParameterLayout,
+        record_size: EagerPlanParameterRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/stages.bin",
+        kind: EagerSectionKind::Stages,
+        record_size: EagerPlanStageRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/couplings.bin",
+        kind: EagerSectionKind::Couplings,
+        record_size: EagerPlanCouplingRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/invocations.bin",
+        kind: EagerSectionKind::Invocations,
+        record_size: EagerPlanInvocationRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/attachments.bin",
+        kind: EagerSectionKind::Attachments,
+        record_size: EagerPlanAttachmentRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/finalizations.bin",
+        kind: EagerSectionKind::Finalizations,
+        record_size: EagerPlanFinalizationRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/closures.bin",
+        kind: EagerSectionKind::Closures,
+        record_size: EagerPlanClosureRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "tables/direct-coefficients.bin",
+        kind: EagerSectionKind::Closures,
+        record_size: DIRECT_COEFFICIENT_RECORD_SIZE,
+    },
+    CountedPlanSection {
+        path: "selectors/domains.bin",
+        kind: EagerSectionKind::SelectorDomains,
+        record_size: EagerPlanSelectorDomainRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "selectors/memberships.bin",
+        kind: EagerSectionKind::SelectorMemberships,
+        record_size: 4,
+    },
+    CountedPlanSection {
+        path: "selectors/helicities.bin",
+        kind: EagerSectionKind::SelectorDomains,
+        record_size: HELICITY_SELECTOR_RECORD_SIZE,
+    },
+    CountedPlanSection {
+        path: "selectors/colors.bin",
+        kind: EagerSectionKind::SelectorDomains,
+        record_size: COLOR_SELECTOR_RECORD_SIZE,
+    },
+    CountedPlanSection {
+        path: "reductions/groups.bin",
+        kind: EagerSectionKind::ReductionGroups,
+        record_size: EagerPlanReductionGroupRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "reductions/entries.bin",
+        kind: EagerSectionKind::ReductionEntries,
+        record_size: EagerPlanReductionEntryRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "catalogs/exact-factors.bin",
+        kind: EagerSectionKind::ExactFactors,
+        record_size: EagerPlanExactFactorRow::ENCODED_LEN,
+    },
+    CountedPlanSection {
+        path: "retained/tables.bin",
+        kind: EagerSectionKind::Metadata,
+        record_size: RETAINED_TABLE_RECORD_SIZE,
+    },
+];
+
+/// Decode only the authenticated rows required to hydrate native reduction
+/// groups. Runtime-sized DAG tables are never converted into Rust rows.
+pub(super) fn decode_eager_v3_reduction_groups(
+    reader: &PacbinReader,
+    manifest: &EagerV3ExecutionManifest,
+) -> RusticolResult<DecodedEagerReductionGroupsV3> {
+    let metadata = decode_metadata(reader)?;
+    let inspection = decode_inspection(reader)?;
+    let identity = decode_text_catalog(reader, "metadata/identity", EagerSectionKind::Metadata)?;
+    validate_identity(&identity, manifest)?;
+    validate_reduction_plan_metadata(reader, manifest, metadata, &inspection)?;
+
+    let helicity_selectors = decode_helicity_selectors(reader)?;
+    let color_selectors = decode_color_selectors(reader)?;
+    let reduction_groups = decode_reduction_groups(reader)?;
+    let reduction_entries = decode_reduction_entries(reader)?;
+    check_count(
+        "reduction-only helicity selector",
+        helicity_selectors.len(),
+        inspection[14],
+    )?;
+    check_count(
+        "reduction-only color selector",
+        color_selectors.len(),
+        inspection[15],
+    )?;
+    check_count(
+        "reduction-only reduction group",
+        reduction_groups.len(),
+        inspection[16],
+    )?;
+    check_count(
+        "reduction-only reduction entry",
+        reduction_entries.len(),
+        inspection[17],
+    )?;
+
+    let helicity_sequence_ids = helicity_selectors
+        .iter()
+        .flat_map(|row| [row.values_sequence_id, row.representative_sequence_id])
+        .collect::<BTreeSet<_>>();
+    let color_sequence_ids = color_selectors
+        .iter()
+        .flat_map(|row| [row.word_sequence_id, row.representative_word_sequence_id])
+        .collect::<BTreeSet<_>>();
+    let helicity_sequences = decode_referenced_sequences(
+        reader,
+        "catalogs/i32-sequences/ranges.bin",
+        "catalogs/i32-sequences/values.bin",
+        &helicity_sequence_ids,
+        "helicity i32 sequence",
+        |row| read_i32(row, 0),
+    )?;
+    let color_sequences = decode_referenced_sequences(
+        reader,
+        "catalogs/u32-sequences/ranges.bin",
+        "catalogs/u32-sequences/values.bin",
+        &color_sequence_ids,
+        "color u32 sequence",
+        |row| read_u32(row, 0),
+    )?;
+    validate_reduction_subset_semantics(
+        metadata,
+        inspection[18],
+        &helicity_selectors,
+        &color_selectors,
+        &reduction_groups,
+        &reduction_entries,
+        &helicity_sequences,
+        &color_sequences,
+    )?;
+
+    Ok(DecodedEagerReductionGroupsV3 {
+        helicity_selectors,
+        color_selectors,
+        reduction_groups,
+        reduction_entries,
+        helicity_sequences,
+        color_sequences,
+    })
+}
+
+/// Decode one already authenticated/preflighted eager plan-v3 container.
+///
+/// `pack` must be the validated prepared pack referenced by the execution
+/// manifest.  The decoder resolves its final kernel specs and rejects every
+/// plan reference whose prepared-kernel role is incompatible.
+pub(super) fn decode_eager_v3_runtime(
+    reader: &PacbinReader,
+    manifest: &EagerV3ExecutionManifest,
+    pack: &PreparedKernelPackManifest,
+) -> RusticolResult<DecodedEagerRuntimeV3> {
+    let metadata = decode_metadata(reader)?;
+    let inspection = decode_inspection(reader)?;
+    let identity = decode_text_catalog(reader, "metadata/identity", EagerSectionKind::Metadata)?;
+    validate_identity(&identity, manifest)?;
+
+    let strings = decode_text_catalog(reader, "catalogs/strings", EagerSectionKind::Metadata)?;
+    let exact_ir = decode_text_catalog(reader, "catalogs/exact-ir", EagerSectionKind::Metadata)?;
+    let semantic_limitations = decode_text_catalog(
+        reader,
+        "catalogs/semantic-limitations",
+        EagerSectionKind::Metadata,
+    )?;
+    check_count("string catalog", strings.len(), metadata.string_count)?;
+    check_count("exact IR catalog", exact_ir.len(), metadata.exact_ir_count)?;
+    check_count(
+        "semantic limitation catalog",
+        semantic_limitations.len(),
+        metadata.limitation_count,
+    )?;
+
+    let retained_tables = decode_retained_tables(reader)?;
+    check_count(
+        "retained table catalog",
+        retained_tables.len(),
+        metadata.retained_table_count,
+    )?;
+    let retained_column_count = retained_tables.iter().try_fold(0_usize, |total, table| {
+        total
+            .checked_add(table.columns.len())
+            .ok_or_else(|| RusticolError::artifact("decoded retained column count exceeds usize"))
+    })?;
+    check_count(
+        "retained column catalog",
+        retained_column_count,
+        metadata.retained_column_count,
+    )?;
+
+    let currents = decode_currents(reader)?;
+    let values = decode_values(reader)?;
+    let momenta = decode_momenta(reader)?;
+    let sources = decode_sources(reader)?;
+    let parameters = decode_parameters(reader)?;
+    let stages = decode_stages(reader)?;
+    let couplings = decode_couplings(reader)?;
+    let invocations = decode_invocations(reader)?;
+    let attachments = decode_attachments(reader)?;
+    let finalizations = decode_finalizations(reader)?;
+    let closures = decode_closures(reader)?;
+    let direct_coefficients = decode_direct_coefficients(reader)?;
+    let selector_domains = decode_selector_domains(reader)?;
+    let selector_memberships = decode_u32_section(
+        reader,
+        "selectors/memberships.bin",
+        EagerSectionKind::SelectorMemberships,
+    )?;
+    let helicity_selectors = decode_helicity_selectors(reader)?;
+    let color_selectors = decode_color_selectors(reader)?;
+    let reduction_groups = decode_reduction_groups(reader)?;
+    let reduction_entries = decode_reduction_entries(reader)?;
+    let exact_factors = decode_exact_factors(reader)?;
+    let bitset_ranges = decode_catalog_ranges(reader, "catalogs/bitsets/ranges.bin")?;
+    let bitset_populations = decode_u64_section(
+        reader,
+        "catalogs/bitsets/populations.bin",
+        EagerSectionKind::Metadata,
+    )?;
+    let bitset_words = decode_u64_section(
+        reader,
+        "catalogs/bitsets/words.bin",
+        EagerSectionKind::Metadata,
+    )?;
+    let u32_sequence_ranges = decode_catalog_ranges(reader, "catalogs/u32-sequences/ranges.bin")?;
+    let u32_sequence_values = decode_u32_section(
+        reader,
+        "catalogs/u32-sequences/values.bin",
+        EagerSectionKind::Metadata,
+    )?;
+    let i32_sequence_ranges = decode_catalog_ranges(reader, "catalogs/i32-sequences/ranges.bin")?;
+    let i32_sequence_values = decode_i32_section(
+        reader,
+        "catalogs/i32-sequences/values.bin",
+        EagerSectionKind::Metadata,
+    )?;
+
+    validate_declared_counts(
+        manifest,
+        metadata,
+        &inspection,
+        &currents,
+        &values,
+        &momenta,
+        &sources,
+        &parameters,
+        &stages,
+        &couplings,
+        &invocations,
+        &attachments,
+        &finalizations,
+        &closures,
+        &direct_coefficients,
+        &selector_domains,
+        &selector_memberships,
+        &helicity_selectors,
+        &color_selectors,
+        &reduction_groups,
+        &reduction_entries,
+        &exact_factors,
+        retained_tables.len(),
+    )?;
+
+    validate_catalog_ranges("bitset", &bitset_ranges, bitset_words.len())?;
+    if bitset_ranges.len() != bitset_populations.len() {
+        return Err(integrity(
+            "bitset range and population catalogs have different lengths",
+        ));
+    }
+    for (index, (range, expected)) in bitset_ranges.iter().zip(&bitset_populations).enumerate() {
+        let words = checked_range(&bitset_words, range.start, range.count, "bitset words")?;
+        let actual = words
+            .iter()
+            .map(|word| u64::from(word.count_ones()))
+            .sum::<u64>();
+        if actual != *expected {
+            return Err(integrity(format!(
+                "bitset {index} population {expected} does not match its {actual} set bits"
+            )));
+        }
+    }
+    validate_catalog_ranges(
+        "u32 sequence",
+        &u32_sequence_ranges,
+        u32_sequence_values.len(),
+    )?;
+    validate_catalog_ranges(
+        "i32 sequence",
+        &i32_sequence_ranges,
+        i32_sequence_values.len(),
+    )?;
+
+    let mut kernel_specs = pack.kernel_specs()?;
+    validate_semantics(
+        metadata,
+        manifest.dag_summary.interaction_count,
+        &currents,
+        &values,
+        &momenta,
+        &sources,
+        &parameters,
+        &stages,
+        &couplings,
+        &invocations,
+        &attachments,
+        &finalizations,
+        &closures,
+        &direct_coefficients,
+        &selector_domains,
+        &selector_memberships,
+        &helicity_selectors,
+        &color_selectors,
+        &reduction_groups,
+        &reduction_entries,
+        &exact_factors,
+        &bitset_ranges,
+        &u32_sequence_ranges,
+        &i32_sequence_ranges,
+        &strings,
+        &exact_ir,
+        &kernel_specs,
+    )?;
+    let active_kernel_ids = active_kernel_ids(
+        invocations.iter().map(|row| row.kernel_id),
+        finalizations.iter().map(|row| row.kernel_id),
+        closures.iter().map(|row| row.kernel_id),
+    );
+    kernel_specs.retain(|kernel| active_kernel_ids.contains(&kernel.kernel_id));
+
+    let amplitude_count = closures
+        .iter()
+        .map(|row| row.amplitude_index)
+        .max()
+        .map_or(Ok(0_u32), |maximum| {
+            maximum
+                .checked_add(1)
+                .ok_or_else(|| RusticolError::artifact("eager amplitude count exceeds u32"))
+        })?;
+    if amplitude_count == 0 {
+        return Err(integrity("eager plan-v3 has no amplitude closures"));
+    }
+    let dimensions = EagerPlanDimensions {
+        value_slot_component_counts: values.iter().map(|row| row.component_count).collect(),
+        momentum_slot_component_counts: momenta.iter().map(|row| row.component_count).collect(),
+        current_component_counts: currents.iter().map(|row| row.component_count).collect(),
+        parameter_count: usize_u32(parameters.len(), "parameter count")?,
+        amplitude_count,
+    };
+    let workspace_mib = usize::try_from(manifest.runtime_options.workspace_mib)
+        .map_err(|_| RusticolError::artifact("eager workspace MiB does not fit usize"))?;
+    let workspace_bytes = workspace_mib
+        .checked_mul(1024 * 1024)
+        .ok_or_else(|| RusticolError::artifact("eager workspace byte count exceeds usize"))?;
+
+    Ok(DecodedEagerRuntimeV3 {
+        process_key: identity[IDENTITY_PROCESS_KEY].clone(),
+        model_name: identity[IDENTITY_MODEL_NAME].clone(),
+        runtime_options: DecodedEagerRuntimeOptions {
+            point_tile_size: usize::try_from(manifest.runtime_options.point_tile_size)
+                .map_err(|_| RusticolError::artifact("eager point tile size does not fit usize"))?,
+            workspace_bytes,
+        },
+        dimensions,
+        kernel_specs,
+        strings,
+        exact_ir,
+        semantic_limitations,
+        retained_tables,
+        currents,
+        values,
+        momenta,
+        sources,
+        parameters,
+        stages,
+        couplings,
+        invocations,
+        attachments,
+        finalizations,
+        closures,
+        direct_coefficients,
+        selector_domains,
+        selector_memberships,
+        helicity_selectors,
+        color_selectors,
+        reduction_groups,
+        reduction_entries,
+        exact_factors,
+        bitset_ranges,
+        bitset_populations,
+        bitset_words,
+        u32_sequence_ranges,
+        u32_sequence_values,
+        i32_sequence_ranges,
+        i32_sequence_values,
+        color_contraction_entry_start: metadata.color_contraction_entry_start,
+        color_contraction_entry_count: metadata.color_contraction_entry_count,
+    })
+}
+
+fn active_kernel_ids(
+    invocation_ids: impl IntoIterator<Item = u32>,
+    finalization_ids: impl IntoIterator<Item = u32>,
+    closure_ids: impl IntoIterator<Item = u32>,
+) -> BTreeSet<u32> {
+    invocation_ids
+        .into_iter()
+        .chain(finalization_ids)
+        .chain(closure_ids)
+        .filter(|kernel_id| *kernel_id != MISSING_U32)
+        .collect()
+}
+
+fn decode_metadata(reader: &PacbinReader) -> RusticolResult<Metadata> {
+    let section = section(
+        reader,
+        "metadata/core.bin",
+        EagerSectionKind::Metadata,
+        METADATA_RECORD_SIZE,
+    )?;
+    require_count(&section, 1, "eager metadata")?;
+    let row = section.payload;
+    if read_u32(row, 0)? != SERIALIZATION_SCHEMA
+        || read_u16(row, 4)? != EAGER_RUNTIME_CONTAINER_SCHEMA
+    {
+        return Err(RusticolError::compatibility(
+            "unsupported eager plan-v3 serialization schema",
+        ));
+    }
+    require_zero(row, 6, 8, "metadata reserved bytes")?;
+    let identity_ids = [
+        read_u32(row, 8)?,
+        read_u32(row, 12)?,
+        read_u32(row, 16)?,
+        read_u32(row, 20)?,
+        read_u32(row, 24)?,
+        read_u32(row, 28)?,
+        read_u32(row, 32)?,
+    ];
+    if identity_ids != [0, 1, 2, 3, 4, 5, 6] || read_u32(row, 36)? != 7 {
+        return Err(integrity(
+            "eager metadata identity catalog mapping is not canonical",
+        ));
+    }
+    let mut values = [0_u64; 21];
+    for (index, value) in values.iter_mut().enumerate() {
+        *value = read_u64(row, 40 + index * 8)?;
+    }
+    require_zero(row, 208, 224, "metadata trailing reserved bytes")?;
+    Ok(Metadata {
+        retained_column_count: values[0],
+        current_component_count: values[1],
+        value_component_count: values[2],
+        momentum_component_count: values[3],
+        color_contraction_entry_start: values[4],
+        color_contraction_entry_count: values[5],
+        string_count: values[6],
+        exact_ir_count: values[7],
+        limitation_count: values[8],
+        retained_table_count: values[9],
+        current_count: values[10],
+        value_count: values[11],
+        momentum_count: values[12],
+        source_count: values[13],
+        stage_count: values[14],
+        invocation_count: values[15],
+        closure_count: values[16],
+        direct_coefficient_count: values[17],
+        helicity_selector_count: values[18],
+        color_selector_count: values[19],
+        exact_factor_count: values[20],
+    })
+}
+
+fn decode_inspection(reader: &PacbinReader) -> RusticolResult<[u64; 20]> {
+    let section = section(
+        reader,
+        "inspection/summary.bin",
+        EagerSectionKind::InspectionSummary,
+        INSPECTION_RECORD_SIZE,
+    )?;
+    require_count(&section, 1, "eager inspection summary")?;
+    let mut values = [0_u64; 20];
+    for (index, value) in values.iter_mut().enumerate() {
+        *value = read_u64(section.payload, index * 8)?;
+    }
+    Ok(values)
+}
+
+fn validate_identity(
+    identity: &[Box<str>],
+    manifest: &EagerV3ExecutionManifest,
+) -> RusticolResult<()> {
+    if identity.len() != IDENTITY_COUNT {
+        return Err(integrity(
+            "eager identity catalog must contain exactly seven entries",
+        ));
+    }
+    let expected = [
+        EAGER_LOWERING_INPUT_ABI,
+        EAGER_PLAN_ABI,
+        EAGER_RUNTIME_LAYOUT_ABI,
+        EAGER_RUNTIME_CAPABILITY,
+        EAGER_RUNTIME_CONTAINER_KIND,
+        manifest.key.as_str(),
+        manifest.plan.inspection_summary.model_name.as_str(),
+    ];
+    for (index, expected) in expected.into_iter().enumerate() {
+        if identity[index].as_ref() != expected {
+            return Err(integrity(format!(
+                "eager identity entry {index} does not match its manifest contract"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn decode_text_catalog(
+    reader: &PacbinReader,
+    base: &str,
+    kind: EagerSectionKind,
+) -> RusticolResult<Vec<Box<str>>> {
+    let (ranges_path, bytes_path) = match base {
+        "metadata/identity" | "retained/name" => {
+            (format!("{base}-ranges.bin"), format!("{base}-bytes.bin"))
+        }
+        _ => (format!("{base}/ranges.bin"), format!("{base}/bytes.bin")),
+    };
+    let ranges = decode_catalog_ranges(reader, &ranges_path)?;
+    let bytes = section(reader, &bytes_path, kind, 1)?;
+    validate_catalog_ranges(base, &ranges, bytes.payload.len())?;
+    let mut result = Vec::new();
+    reserve(&mut result, ranges.len(), base)?;
+    for range in ranges {
+        let value = checked_range(bytes.payload, range.start, range.count, base)?;
+        let text = std::str::from_utf8(value).map_err(|error| {
+            RusticolError::integrity(format!("{base} contains invalid UTF-8: {error}"))
+        })?;
+        result.push(Box::<str>::from(text));
+    }
+    Ok(result)
+}
+
+fn decode_retained_tables(reader: &PacbinReader) -> RusticolResult<Vec<DecodedEagerRetainedTable>> {
+    let names = decode_text_catalog(reader, "retained/name", EagerSectionKind::Metadata)?;
+    let tables = decode_rows(
+        reader,
+        "retained/tables.bin",
+        EagerSectionKind::Metadata,
+        RETAINED_TABLE_RECORD_SIZE,
+        |row| {
+            require_zero(row, 32, 40, "retained table padding")?;
+            Ok(RetainedTableRecord {
+                table_id: read_u32(row, 0)?,
+                name_id: read_u32(row, 4)?,
+                row_count: read_u64(row, 8)?,
+                column_start: read_u64(row, 16)?,
+                column_count: read_u64(row, 24)?,
+            })
+        },
+    )?;
+    let columns = decode_rows(
+        reader,
+        "retained/columns.bin",
+        EagerSectionKind::Metadata,
+        RETAINED_COLUMN_RECORD_SIZE,
+        |row| {
+            require_zero(row, 13, 16, "retained column padding")?;
+            require_zero(row, 20, 24, "retained column padding")?;
+            Ok(RetainedColumnRecord {
+                table_id: read_u32(row, 0)?,
+                column_id: read_u32(row, 4)?,
+                name_id: read_u32(row, 8)?,
+                primitive_kind: read_u8(row, 12)?,
+                elements_per_row: read_u32(row, 16)?,
+                value_start: read_u64(row, 24)?,
+                value_count: read_u64(row, 32)?,
+            })
+        },
+    )?;
+    let primitive_sections = RetainedPrimitiveSections {
+        u8_values: section(
+            reader,
+            "retained/values-u8.bin",
+            EagerSectionKind::Metadata,
+            1,
+        )?,
+        u32_values: section(
+            reader,
+            "retained/values-u32.bin",
+            EagerSectionKind::Metadata,
+            4,
+        )?,
+        u64_values: section(
+            reader,
+            "retained/values-u64.bin",
+            EagerSectionKind::Metadata,
+            8,
+        )?,
+        i32_values: section(
+            reader,
+            "retained/values-i32.bin",
+            EagerSectionKind::Metadata,
+            4,
+        )?,
+        f64_values: section(
+            reader,
+            "retained/values-f64-bits.bin",
+            EagerSectionKind::Metadata,
+            8,
+        )?,
+    };
+
+    let mut primitive_cursors = BTreeMap::from([
+        (RETAINED_U8, 0_u64),
+        (RETAINED_U32, 0),
+        (RETAINED_U64, 0),
+        (RETAINED_I32, 0),
+        (RETAINED_F64_BITS, 0),
+    ]);
+    let mut result = Vec::new();
+    reserve(&mut result, tables.len(), "retained tables")?;
+    let mut column_cursor = 0_u64;
+    let mut name_cursor = 0_u32;
+    for (table_index, table) in tables.iter().enumerate() {
+        if table.table_id != usize_u32(table_index, "retained table ID")?
+            || table.column_start != column_cursor
+            || table.name_id != name_cursor
+        {
+            return Err(integrity(
+                "retained table descriptors are not canonical and contiguous",
+            ));
+        }
+        let table_columns = checked_range(
+            &columns,
+            table.column_start,
+            table.column_count,
+            "retained table columns",
+        )?;
+        let mut decoded_columns = Vec::new();
+        reserve(
+            &mut decoded_columns,
+            table_columns.len(),
+            "retained table columns",
+        )?;
+        name_cursor = name_cursor
+            .checked_add(1)
+            .ok_or_else(|| RusticolError::artifact("retained name count exceeds u32"))?;
+        let table_name: Box<str> =
+            required_catalog(&names, table.name_id, "retained table name")?.into();
+        for (column_index, column) in table_columns.iter().enumerate() {
+            if column.table_id != table.table_id
+                || column.column_id != usize_u32(column_index, "retained column ID")?
+                || column.name_id != name_cursor
+                || column.elements_per_row == 0
+            {
+                return Err(integrity("retained column descriptor is not canonical"));
+            }
+            let expected_count = table
+                .row_count
+                .checked_mul(u64::from(column.elements_per_row))
+                .ok_or_else(|| RusticolError::artifact("retained column shape exceeds u64"))?;
+            if expected_count != column.value_count {
+                return Err(integrity(
+                    "retained column shape does not match its value count",
+                ));
+            }
+            let cursor = primitive_cursors
+                .get_mut(&column.primitive_kind)
+                .ok_or_else(|| {
+                    RusticolError::compatibility(format!(
+                        "unknown retained primitive kind {}",
+                        column.primitive_kind
+                    ))
+                })?;
+            if column.value_start != *cursor {
+                return Err(integrity("retained primitive ranges are not contiguous"));
+            }
+            let column_name: Box<str> =
+                required_catalog(&names, column.name_id, "retained column name")?.into();
+            let values = decode_retained_column_values(
+                &primitive_sections,
+                column,
+                retained_column_is_runtime_required(&table_name, &column_name),
+            )?;
+            if values.len() != usize_count(column.value_count, "retained value count")? {
+                return Err(integrity(
+                    "retained decoded value count changed unexpectedly",
+                ));
+            }
+            decoded_columns.push(DecodedEagerRetainedColumn {
+                name: column_name,
+                elements_per_row: column.elements_per_row,
+                values,
+            });
+            *cursor = cursor
+                .checked_add(column.value_count)
+                .ok_or_else(|| RusticolError::artifact("retained primitive cursor exceeds u64"))?;
+            name_cursor = name_cursor
+                .checked_add(1)
+                .ok_or_else(|| RusticolError::artifact("retained name count exceeds u32"))?;
+        }
+        column_cursor = column_cursor
+            .checked_add(table.column_count)
+            .ok_or_else(|| RusticolError::artifact("retained column cursor exceeds u64"))?;
+        result.push(DecodedEagerRetainedTable {
+            name: table_name,
+            row_count: table.row_count,
+            columns: decoded_columns,
+        });
+    }
+    if usize_count(column_cursor, "retained column cursor")? != columns.len()
+        || usize::try_from(name_cursor).ok() != Some(names.len())
+        || primitive_cursors[&RETAINED_U8] != primitive_sections.u8_values.count
+        || primitive_cursors[&RETAINED_U32] != primitive_sections.u32_values.count
+        || primitive_cursors[&RETAINED_U64] != primitive_sections.u64_values.count
+        || primitive_cursors[&RETAINED_I32] != primitive_sections.i32_values.count
+        || primitive_cursors[&RETAINED_F64_BITS] != primitive_sections.f64_values.count
+    {
+        return Err(integrity(
+            "retained catalogs contain unreachable trailing data",
+        ));
+    }
+    Ok(result)
+}
+
+fn retained_column_is_runtime_required(table: &str, column: &str) -> bool {
+    if table.starts_with("lc_replay_") || table.starts_with("color_replay_") {
+        return true;
+    }
+    matches!(
+        (table, column),
+        ("metadata", "normalization_ir_id")
+            | ("coherent_groups", "color_sector_id")
+            | ("model_parameters", "pdg")
+            | ("currents", "particle_id")
+            | ("currents", "source_leg_label")
+            | ("currents", "source_helicity")
+            | ("currents", "chirality")
+            | ("currents", "spin_state_sequence_id")
+            | ("currents", "helicity_ancestry_bitset_id")
+    )
+}
+
+fn decode_retained_column_values(
+    sections: &RetainedPrimitiveSections<'_>,
+    column: &RetainedColumnRecord,
+    materialize: bool,
+) -> RusticolResult<DecodedEagerPrimitiveColumn> {
+    let (section, width, context) = match column.primitive_kind {
+        RETAINED_U8 => (&sections.u8_values, 1_usize, "retained u8"),
+        RETAINED_U32 => (&sections.u32_values, 4, "retained u32"),
+        RETAINED_U64 => (&sections.u64_values, 8, "retained u64"),
+        RETAINED_I32 => (&sections.i32_values, 4, "retained i32"),
+        RETAINED_F64_BITS => (&sections.f64_values, 8, "retained f64 bits"),
+        _ => unreachable!("primitive kind checked before retained-value decoding"),
+    };
+    let end = column
+        .value_start
+        .checked_add(column.value_count)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} range exceeds u64")))?;
+    if end > section.count {
+        return Err(integrity(format!(
+            "{context} range exceeds its primitive catalog"
+        )));
+    }
+    let count = usize_count(column.value_count, context)?;
+    if !materialize {
+        return Ok(DecodedEagerPrimitiveColumn::ValidatedOnly { len: count });
+    }
+    let start = usize_count(column.value_start, context)?;
+    let byte_start = start
+        .checked_mul(width)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} byte offset exceeds usize")))?;
+    let byte_count = count
+        .checked_mul(width)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} byte count exceeds usize")))?;
+    let byte_end = byte_start
+        .checked_add(byte_count)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} byte range exceeds usize")))?;
+    let payload = section.payload.get(byte_start..byte_end).ok_or_else(|| {
+        integrity(format!(
+            "{context} byte range exceeds its primitive payload"
+        ))
+    })?;
+    match column.primitive_kind {
+        RETAINED_U8 => Ok(DecodedEagerPrimitiveColumn::U8(payload.to_vec())),
+        RETAINED_U32 => Ok(DecodedEagerPrimitiveColumn::U32(decode_primitive_rows(
+            payload,
+            width,
+            count,
+            context,
+            |row| read_u32(row, 0),
+        )?)),
+        RETAINED_U64 => Ok(DecodedEagerPrimitiveColumn::U64(decode_primitive_rows(
+            payload,
+            width,
+            count,
+            context,
+            |row| read_u64(row, 0),
+        )?)),
+        RETAINED_I32 => Ok(DecodedEagerPrimitiveColumn::I32(decode_primitive_rows(
+            payload,
+            width,
+            count,
+            context,
+            |row| read_i32(row, 0),
+        )?)),
+        RETAINED_F64_BITS => Ok(DecodedEagerPrimitiveColumn::F64Bits(decode_primitive_rows(
+            payload,
+            width,
+            count,
+            context,
+            |row| read_u64(row, 0),
+        )?)),
+        _ => unreachable!("primitive kind checked before retained-value materialization"),
+    }
+}
+
+fn decode_primitive_rows<T>(
+    payload: &[u8],
+    width: usize,
+    count: usize,
+    context: &str,
+    mut decode: impl FnMut(&[u8]) -> RusticolResult<T>,
+) -> RusticolResult<Vec<T>> {
+    let mut values = Vec::new();
+    reserve(&mut values, count, context)?;
+    for row in payload.chunks_exact(width) {
+        values.push(decode(row)?);
+    }
+    if values.len() != count {
+        return Err(integrity(format!(
+            "{context} decoded row count changed unexpectedly"
+        )));
+    }
+    Ok(values)
+}
+
+fn decode_currents(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanCurrentRow>> {
+    decode_rows(
+        reader,
+        "tables/currents.bin",
+        EagerSectionKind::CurrentLayout,
+        EagerPlanCurrentRow::ENCODED_LEN,
+        |row| {
+            Ok(EagerPlanCurrentRow {
+                current_id: read_u32(row, 0)?,
+                component_start: read_u64(row, 4)?,
+                component_count: read_u32(row, 12)?,
+                momentum_slot_id: read_u32(row, 16)?,
+                flags: read_u32(row, 20)?,
+            })
+        },
+    )
+}
+
+fn decode_values(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanValueRow>> {
+    decode_rows(
+        reader,
+        "tables/values.bin",
+        EagerSectionKind::ValueLayout,
+        EagerPlanValueRow::ENCODED_LEN,
+        |row| {
+            require_zero(row, 21, 24, "value row padding")?;
+            let kind = match read_u8(row, 20)? {
+                1 => EagerValueSlotKind::Source,
+                2 => EagerValueSlotKind::Unpropagated,
+                3 => EagerValueSlotKind::Propagated,
+                value => {
+                    return Err(RusticolError::compatibility(format!(
+                        "unknown eager value-slot kind {value}"
+                    )));
+                }
+            };
+            Ok(EagerPlanValueRow {
+                value_slot_id: read_u32(row, 0)?,
+                current_id: read_u32(row, 4)?,
+                component_start: read_u64(row, 8)?,
+                component_count: read_u32(row, 16)?,
+                kind,
+            })
+        },
+    )
+}
+
+fn decode_momenta(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanMomentumRow>> {
+    decode_rows(
+        reader,
+        "tables/momenta.bin",
+        EagerSectionKind::MomentumLayout,
+        EagerPlanMomentumRow::ENCODED_LEN,
+        |row| {
+            require_zero(row, 20, 24, "momentum row padding")?;
+            Ok(EagerPlanMomentumRow {
+                momentum_slot_id: read_u32(row, 0)?,
+                bitset_id: read_u32(row, 4)?,
+                component_start: read_u64(row, 8)?,
+                component_count: read_u32(row, 16)?,
+            })
+        },
+    )
+}
+
+fn decode_sources(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanSourceFillRow>> {
+    decode_rows(
+        reader,
+        "tables/sources.bin",
+        EagerSectionKind::SourceFill,
+        EagerPlanSourceFillRow::ENCODED_LEN,
+        |row| {
+            require_zero(row, 36, 40, "source row padding")?;
+            Ok(EagerPlanSourceFillRow {
+                source_id: read_u32(row, 0)?,
+                current_id: read_u32(row, 4)?,
+                value_slot_id: read_u32(row, 8)?,
+                external_label: read_u32(row, 12)?,
+                input_momentum_slot: read_u32(row, 16)?,
+                source_ir_id: read_u32(row, 20)?,
+                crossing_ir_id: read_u32(row, 24)?,
+                crossing_factor_id: read_u32(row, 28)?,
+                declared_state_index: read_u32(row, 32)?,
+            })
+        },
+    )
+}
+
+fn decode_parameters(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanParameterRow>> {
+    decode_rows(
+        reader,
+        "tables/parameters.bin",
+        EagerSectionKind::ParameterLayout,
+        EagerPlanParameterRow::ENCODED_LEN,
+        |row| {
+            require_zero(row, 28, 32, "parameter row padding")?;
+            Ok(EagerPlanParameterRow {
+                parameter_id: read_u32(row, 0)?,
+                name_string_id: read_u32(row, 4)?,
+                kind_string_id: read_u32(row, 8)?,
+                default_factor_id: read_u32(row, 12)?,
+                runtime_name_string_id: read_u32(row, 16)?,
+                complex_component: read_i32(row, 20)?,
+                flags: read_u32(row, 24)?,
+            })
+        },
+    )
+}
+
+fn decode_stages(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanStageRow>> {
+    decode_rows(
+        reader,
+        "tables/stages.bin",
+        EagerSectionKind::Stages,
+        EagerPlanStageRow::ENCODED_LEN,
+        |row| {
+            Ok(EagerPlanStageRow {
+                stage_index: read_u32(row, 0)?,
+                subset_size: read_u32(row, 4)?,
+                invocation_start: read_u64(row, 8)?,
+                invocation_count: read_u64(row, 16)?,
+                attachment_start: read_u64(row, 24)?,
+                attachment_count: read_u64(row, 32)?,
+                finalization_start: read_u64(row, 40)?,
+                finalization_count: read_u64(row, 48)?,
+            })
+        },
+    )
+}
+
+fn decode_couplings(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanCouplingRow>> {
+    decode_rows(
+        reader,
+        "tables/couplings.bin",
+        EagerSectionKind::Couplings,
+        EagerPlanCouplingRow::ENCODED_LEN,
+        |row| {
+            Ok(EagerPlanCouplingRow {
+                coupling_id: read_u32(row, 0)?,
+                real_parameter_id: read_u32(row, 4)?,
+                imaginary_parameter_id: read_u32(row, 8)?,
+                constant_factor_id: read_u32(row, 12)?,
+            })
+        },
+    )
+}
+
+fn decode_invocations(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanInvocationRow>> {
+    decode_rows(
+        reader,
+        "tables/invocations.bin",
+        EagerSectionKind::Invocations,
+        EagerPlanInvocationRow::ENCODED_LEN,
+        |row| {
+            require_zero(row, 29, 32, "invocation row padding")?;
+            require_zero(row, 52, 56, "invocation row padding")?;
+            Ok(EagerPlanInvocationRow {
+                evaluation_group_id: read_u32(row, 0)?,
+                kernel_id: read_u32(row, 4)?,
+                left_value_slot_id: read_u32(row, 8)?,
+                right_value_slot_id: read_u32(row, 12)?,
+                left_momentum_slot_id: read_u32(row, 16)?,
+                right_momentum_slot_id: read_u32(row, 20)?,
+                coupling_slot_id: read_u32(row, 24)?,
+                output_factor_source: read_u8(row, 28)?,
+                attachment_start: read_u64(row, 32)?,
+                attachment_count: read_u64(row, 40)?,
+                selector_domain_id: read_u32(row, 48)?,
+            })
+        },
+    )
+}
+
+fn decode_attachments(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanAttachmentRow>> {
+    decode_rows(
+        reader,
+        "tables/attachments.bin",
+        EagerSectionKind::Attachments,
+        EagerPlanAttachmentRow::ENCODED_LEN,
+        |row| {
+            Ok(EagerPlanAttachmentRow {
+                interaction_id: read_u32(row, 0)?,
+                result_current_id: read_u32(row, 4)?,
+                color_factor_id: read_u32(row, 8)?,
+                evaluation_factor_id: read_u32(row, 12)?,
+                normalization_factor_id: read_u32(row, 16)?,
+                representative_evaluation_factor_id: read_u32(row, 20)?,
+                selector_domain_id: read_u32(row, 24)?,
+            })
+        },
+    )
+}
+
+fn decode_finalizations(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanFinalizationRow>> {
+    decode_rows(
+        reader,
+        "tables/finalizations.bin",
+        EagerSectionKind::Finalizations,
+        EagerPlanFinalizationRow::ENCODED_LEN,
+        |row| {
+            Ok(EagerPlanFinalizationRow {
+                kernel_id: read_u32(row, 0)?,
+                current_id: read_u32(row, 4)?,
+                unpropagated_value_slot_id: read_u32(row, 8)?,
+                propagated_value_slot_id: read_u32(row, 12)?,
+                momentum_slot_id: read_u32(row, 16)?,
+                unpropagated_selector_domain_id: read_u32(row, 20)?,
+                propagated_selector_domain_id: read_u32(row, 24)?,
+            })
+        },
+    )
+}
+
+fn decode_closures(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanClosureRow>> {
+    decode_rows(
+        reader,
+        "tables/closures.bin",
+        EagerSectionKind::Closures,
+        EagerPlanClosureRow::ENCODED_LEN,
+        |row| {
+            require_zero(row, 33, 36, "closure row padding")?;
+            Ok(EagerPlanClosureRow {
+                root_id: read_u32(row, 0)?,
+                kernel_id: read_u32(row, 4)?,
+                left_value_slot_id: read_u32(row, 8)?,
+                right_value_slot_id: read_u32(row, 12)?,
+                amplitude_index: read_u32(row, 16)?,
+                coherent_group_id: read_u32(row, 20)?,
+                coupling_slot_id: read_u32(row, 24)?,
+                coupling_factor_id: read_u32(row, 28)?,
+                output_factor_source: read_u8(row, 32)?,
+                color_factor_id: read_u32(row, 36)?,
+                normalization_factor_id: read_u32(row, 40)?,
+                direct_coefficient_start: read_u64(row, 44)?,
+                direct_coefficient_count: read_u64(row, 52)?,
+                selector_domain_id: read_u32(row, 60)?,
+            })
+        },
+    )
+}
+
+fn decode_direct_coefficients(
+    reader: &PacbinReader,
+) -> RusticolResult<Vec<EagerPlanDirectCoefficientRow>> {
+    decode_rows(
+        reader,
+        "tables/direct-coefficients.bin",
+        EagerSectionKind::Closures,
+        DIRECT_COEFFICIENT_RECORD_SIZE,
+        |row| {
+            require_zero(row, 12, 16, "direct coefficient row padding")?;
+            Ok(EagerPlanDirectCoefficientRow {
+                contraction_ir_id: read_u32(row, 0)?,
+                component_index: read_u32(row, 4)?,
+                factor_id: read_u32(row, 8)?,
+            })
+        },
+    )
+}
+
+fn decode_selector_domains(
+    reader: &PacbinReader,
+) -> RusticolResult<Vec<EagerPlanSelectorDomainRow>> {
+    decode_rows(
+        reader,
+        "selectors/domains.bin",
+        EagerSectionKind::SelectorDomains,
+        EagerPlanSelectorDomainRow::ENCODED_LEN,
+        |row| {
+            Ok(EagerPlanSelectorDomainRow {
+                member_start: read_u64(row, 0)?,
+                member_count: read_u64(row, 8)?,
+            })
+        },
+    )
+}
+
+fn decode_helicity_selectors(
+    reader: &PacbinReader,
+) -> RusticolResult<Vec<EagerPlanHelicitySelectorRow>> {
+    decode_rows(
+        reader,
+        "selectors/helicities.bin",
+        EagerSectionKind::SelectorDomains,
+        HELICITY_SELECTOR_RECORD_SIZE,
+        |row| {
+            require_zero(row, 18, 24, "helicity selector padding")?;
+            Ok(EagerPlanHelicitySelectorRow {
+                selector_id: read_u32(row, 0)?,
+                values_sequence_id: read_u32(row, 4)?,
+                representative_sequence_id: read_u32(row, 8)?,
+                coefficient_factor_id: read_u32(row, 12)?,
+                computed: read_bool(row, 16, "helicity computed flag")?,
+                structural_zero: read_bool(row, 17, "helicity structural-zero flag")?,
+            })
+        },
+    )
+}
+
+fn decode_color_selectors(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanColorSelectorRow>> {
+    decode_rows(
+        reader,
+        "selectors/colors.bin",
+        EagerSectionKind::SelectorDomains,
+        COLOR_SELECTOR_RECORD_SIZE,
+        |row| {
+            require_zero(row, 17, 24, "color selector padding")?;
+            Ok(EagerPlanColorSelectorRow {
+                selector_id: read_u32(row, 0)?,
+                word_sequence_id: read_u32(row, 4)?,
+                representative_word_sequence_id: read_u32(row, 8)?,
+                coefficient_factor_id: read_u32(row, 12)?,
+                computed: read_bool(row, 16, "color computed flag")?,
+            })
+        },
+    )
+}
+
+fn decode_reduction_groups(
+    reader: &PacbinReader,
+) -> RusticolResult<Vec<EagerPlanReductionGroupRow>> {
+    decode_rows(
+        reader,
+        "reductions/groups.bin",
+        EagerSectionKind::ReductionGroups,
+        EagerPlanReductionGroupRow::ENCODED_LEN,
+        |row| {
+            require_zero(row, 4, 8, "reduction group padding")?;
+            Ok(EagerPlanReductionGroupRow {
+                coherent_group_id: read_u32(row, 0)?,
+                amplitude_entry_start: read_u64(row, 8)?,
+                amplitude_entry_count: read_u64(row, 16)?,
+                selector_entry_start: read_u64(row, 24)?,
+                selector_entry_count: read_u64(row, 32)?,
+                helicity_weight_factor_id: read_u32(row, 40)?,
+                all_sector_weight_factor_id: read_u32(row, 44)?,
+            })
+        },
+    )
+}
+
+fn decode_reduction_entries(
+    reader: &PacbinReader,
+) -> RusticolResult<Vec<EagerPlanReductionEntryRow>> {
+    decode_rows(
+        reader,
+        "reductions/entries.bin",
+        EagerSectionKind::ReductionEntries,
+        EagerPlanReductionEntryRow::ENCODED_LEN,
+        |row| {
+            require_zero(row, 1, 4, "reduction entry padding")?;
+            let kind = match read_u8(row, 0)? {
+                1 => EagerPlanReductionEntryKind::AmplitudeMember,
+                2 => EagerPlanReductionEntryKind::SelectorMember,
+                3 => EagerPlanReductionEntryKind::ColorContraction,
+                value => {
+                    return Err(RusticolError::compatibility(format!(
+                        "unknown eager reduction entry kind {value}"
+                    )));
+                }
+            };
+            Ok(EagerPlanReductionEntryRow {
+                kind,
+                owner_id: read_u32(row, 4)?,
+                left_id: read_u32(row, 8)?,
+                right_id: read_u32(row, 12)?,
+                factor_id: read_u32(row, 16)?,
+                auxiliary_factor_id: read_u32(row, 20)?,
+            })
+        },
+    )
+}
+
+fn decode_exact_factors(reader: &PacbinReader) -> RusticolResult<Vec<EagerPlanExactFactorRow>> {
+    decode_rows(
+        reader,
+        "catalogs/exact-factors.bin",
+        EagerSectionKind::ExactFactors,
+        EagerPlanExactFactorRow::ENCODED_LEN,
+        |row| {
+            require_zero(row, 4, 8, "exact factor padding")?;
+            require_zero(row, 29, 32, "exact factor padding")?;
+            let exact_source = read_u8(row, 28)?;
+            if exact_source > 1 {
+                return Err(RusticolError::compatibility(format!(
+                    "unknown exact-factor source {exact_source}"
+                )));
+            }
+            Ok(EagerPlanExactFactorRow {
+                factor_id: read_u32(row, 0)?,
+                real_bits: read_u64(row, 8)?,
+                imaginary_bits: read_u64(row, 16)?,
+                canonical_string_id: read_u32(row, 24)?,
+                exact_source,
+                exact_ir_id: read_u32(row, 32)?,
+                source_ir_id: read_u32(row, 36)?,
+            })
+        },
+    )
+}
+
+fn decode_catalog_ranges(
+    reader: &PacbinReader,
+    path: &str,
+) -> RusticolResult<Vec<EagerPlanCatalogRangeRow>> {
+    decode_rows(
+        reader,
+        path,
+        EagerSectionKind::Metadata,
+        EagerPlanCatalogRangeRow::ENCODED_LEN,
+        |row| {
+            Ok(EagerPlanCatalogRangeRow {
+                start: read_u64(row, 0)?,
+                count: read_u64(row, 8)?,
+            })
+        },
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn validate_declared_counts(
+    manifest: &EagerV3ExecutionManifest,
+    metadata: Metadata,
+    inspection: &[u64; 20],
+    currents: &[EagerPlanCurrentRow],
+    values: &[EagerPlanValueRow],
+    momenta: &[EagerPlanMomentumRow],
+    sources: &[EagerPlanSourceFillRow],
+    parameters: &[EagerPlanParameterRow],
+    stages: &[EagerPlanStageRow],
+    couplings: &[EagerPlanCouplingRow],
+    invocations: &[EagerPlanInvocationRow],
+    attachments: &[EagerPlanAttachmentRow],
+    finalizations: &[EagerPlanFinalizationRow],
+    closures: &[EagerPlanClosureRow],
+    direct_coefficients: &[EagerPlanDirectCoefficientRow],
+    selector_domains: &[EagerPlanSelectorDomainRow],
+    selector_memberships: &[u32],
+    helicity_selectors: &[EagerPlanHelicitySelectorRow],
+    color_selectors: &[EagerPlanColorSelectorRow],
+    reduction_groups: &[EagerPlanReductionGroupRow],
+    reduction_entries: &[EagerPlanReductionEntryRow],
+    exact_factors: &[EagerPlanExactFactorRow],
+    retained_table_count: usize,
+) -> RusticolResult<()> {
+    let actual = [
+        currents.len(),
+        values.len(),
+        momenta.len(),
+        sources.len(),
+        parameters.len(),
+        stages.len(),
+        couplings.len(),
+        invocations.len(),
+        attachments.len(),
+        finalizations.len(),
+        closures.len(),
+        direct_coefficients.len(),
+        selector_domains.len(),
+        selector_memberships.len(),
+        helicity_selectors.len(),
+        color_selectors.len(),
+        reduction_groups.len(),
+        reduction_entries.len(),
+        exact_factors.len(),
+        retained_table_count,
+    ];
+    for (index, (actual, declared)) in actual.into_iter().zip(inspection).enumerate() {
+        check_count(&format!("inspection field {index}"), actual, *declared)?;
+    }
+    let metadata_counts = [
+        ("metadata currents", currents.len(), metadata.current_count),
+        ("metadata values", values.len(), metadata.value_count),
+        ("metadata momenta", momenta.len(), metadata.momentum_count),
+        ("metadata sources", sources.len(), metadata.source_count),
+        ("metadata stages", stages.len(), metadata.stage_count),
+        (
+            "metadata invocations",
+            invocations.len(),
+            metadata.invocation_count,
+        ),
+        ("metadata closures", closures.len(), metadata.closure_count),
+        (
+            "metadata direct coefficients",
+            direct_coefficients.len(),
+            metadata.direct_coefficient_count,
+        ),
+        (
+            "metadata helicity selectors",
+            helicity_selectors.len(),
+            metadata.helicity_selector_count,
+        ),
+        (
+            "metadata color selectors",
+            color_selectors.len(),
+            metadata.color_selector_count,
+        ),
+        (
+            "metadata exact factors",
+            exact_factors.len(),
+            metadata.exact_factor_count,
+        ),
+    ];
+    for (name, actual, declared) in metadata_counts {
+        check_count(name, actual, declared)?;
+    }
+    let summary = &manifest.plan.inspection_summary;
+    let manifest_counts = [
+        summary.current_count,
+        summary.value_count,
+        summary.momentum_count,
+        summary.source_count,
+        summary.parameter_count,
+        summary.stage_count,
+        summary.coupling_count,
+        summary.invocation_count,
+        summary.attachment_count,
+        summary.finalization_count,
+        summary.closure_count,
+        summary.selector_domain_count,
+        summary.reduction_group_count,
+        summary.reduction_entry_count,
+        summary.retained_table_count,
+    ];
+    let inspection_indices = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 16, 17, 19];
+    for (manifest_count, index) in manifest_counts.into_iter().zip(inspection_indices) {
+        if manifest_count != inspection[index] {
+            return Err(integrity(format!(
+                "execution-manifest inspection count disagrees with PACBIN field {index}"
+            )));
+        }
+    }
+    if summary.current_component_count != metadata.current_component_count
+        || summary.value_component_count != metadata.value_component_count
+        || summary.momentum_component_count != metadata.momentum_component_count
+    {
+        return Err(integrity(
+            "execution-manifest component counts disagree with PACBIN metadata",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_reduction_plan_metadata(
+    reader: &PacbinReader,
+    manifest: &EagerV3ExecutionManifest,
+    metadata: Metadata,
+    inspection: &[u64; 20],
+) -> RusticolResult<()> {
+    // The complete container was authenticated before this decoder was
+    // entered. Inspect the canonical shape/count header of every plan table
+    // without touching or allocating its payload rows.
+    for (index, expected) in COUNTED_PLAN_SECTIONS.iter().enumerate() {
+        let actual = section(reader, expected.path, expected.kind, expected.record_size)?.count;
+        if actual != inspection[index] {
+            return Err(integrity(format!(
+                "reduction-only plan section {:?} has {actual} rows, inspection field {index} declares {}",
+                expected.path, inspection[index]
+            )));
+        }
+    }
+
+    for (path, declared, context) in [
+        (
+            "catalogs/strings/ranges.bin",
+            metadata.string_count,
+            "string catalog",
+        ),
+        (
+            "catalogs/exact-ir/ranges.bin",
+            metadata.exact_ir_count,
+            "exact IR catalog",
+        ),
+        (
+            "catalogs/semantic-limitations/ranges.bin",
+            metadata.limitation_count,
+            "semantic limitation catalog",
+        ),
+        (
+            "retained/columns.bin",
+            metadata.retained_column_count,
+            "retained column catalog",
+        ),
+    ] {
+        let record_size = if path == "retained/columns.bin" {
+            RETAINED_COLUMN_RECORD_SIZE
+        } else {
+            EagerPlanCatalogRangeRow::ENCODED_LEN
+        };
+        let actual = section(reader, path, EagerSectionKind::Metadata, record_size)?.count;
+        if actual != declared {
+            return Err(integrity(format!(
+                "reduction-only {context} has {actual} rows, metadata declares {declared}"
+            )));
+        }
+    }
+
+    let metadata_counts = [
+        ("currents", metadata.current_count, inspection[0]),
+        ("values", metadata.value_count, inspection[1]),
+        ("momenta", metadata.momentum_count, inspection[2]),
+        ("sources", metadata.source_count, inspection[3]),
+        ("stages", metadata.stage_count, inspection[5]),
+        ("invocations", metadata.invocation_count, inspection[7]),
+        ("closures", metadata.closure_count, inspection[10]),
+        (
+            "direct coefficients",
+            metadata.direct_coefficient_count,
+            inspection[11],
+        ),
+        (
+            "helicity selectors",
+            metadata.helicity_selector_count,
+            inspection[14],
+        ),
+        (
+            "color selectors",
+            metadata.color_selector_count,
+            inspection[15],
+        ),
+        ("exact factors", metadata.exact_factor_count, inspection[18]),
+        (
+            "retained tables",
+            metadata.retained_table_count,
+            inspection[19],
+        ),
+    ];
+    for (context, declared, actual) in metadata_counts {
+        if declared != actual {
+            return Err(integrity(format!(
+                "reduction-only metadata {context} count {declared} disagrees with inspection count {actual}"
+            )));
+        }
+    }
+
+    let summary = &manifest.plan.inspection_summary;
+    let manifest_counts = [
+        summary.current_count,
+        summary.value_count,
+        summary.momentum_count,
+        summary.source_count,
+        summary.parameter_count,
+        summary.stage_count,
+        summary.coupling_count,
+        summary.invocation_count,
+        summary.attachment_count,
+        summary.finalization_count,
+        summary.closure_count,
+        summary.selector_domain_count,
+        summary.reduction_group_count,
+        summary.reduction_entry_count,
+        summary.retained_table_count,
+    ];
+    let inspection_indices = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 16, 17, 19];
+    for (manifest_count, index) in manifest_counts.into_iter().zip(inspection_indices) {
+        if manifest_count != inspection[index] {
+            return Err(integrity(format!(
+                "execution-manifest inspection count disagrees with PACBIN field {index}"
+            )));
+        }
+    }
+    if summary.current_component_count != metadata.current_component_count
+        || summary.value_component_count != metadata.value_component_count
+        || summary.momentum_component_count != metadata.momentum_component_count
+    {
+        return Err(integrity(
+            "execution-manifest component counts disagree with PACBIN metadata",
+        ));
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn validate_reduction_subset_semantics(
+    metadata: Metadata,
+    exact_factor_count: u64,
+    helicity_selectors: &[EagerPlanHelicitySelectorRow],
+    color_selectors: &[EagerPlanColorSelectorRow],
+    reduction_groups: &[EagerPlanReductionGroupRow],
+    reduction_entries: &[EagerPlanReductionEntryRow],
+    helicity_sequences: &BTreeMap<u32, Vec<i32>>,
+    color_sequences: &BTreeMap<u32, Vec<u32>>,
+) -> RusticolResult<()> {
+    validate_dense_ids(
+        helicity_selectors.iter().map(|row| row.selector_id),
+        "helicity selector",
+    )?;
+    for row in helicity_selectors {
+        required_projected_sequence(
+            helicity_sequences,
+            row.values_sequence_id,
+            "helicity values sequence",
+        )?;
+        required_projected_sequence(
+            helicity_sequences,
+            row.representative_sequence_id,
+            "helicity representative sequence",
+        )?;
+        required_declared_index(
+            row.coefficient_factor_id,
+            exact_factor_count,
+            "helicity coefficient factor",
+        )?;
+    }
+
+    validate_dense_ids(
+        color_selectors.iter().map(|row| row.selector_id),
+        "color selector",
+    )?;
+    for row in color_selectors {
+        required_projected_sequence(color_sequences, row.word_sequence_id, "color word sequence")?;
+        required_projected_sequence(
+            color_sequences,
+            row.representative_word_sequence_id,
+            "color representative sequence",
+        )?;
+        required_declared_index(
+            row.coefficient_factor_id,
+            exact_factor_count,
+            "color coefficient factor",
+        )?;
+    }
+
+    let known_groups = reduction_groups
+        .iter()
+        .map(|group| group.coherent_group_id)
+        .collect::<HashSet<_>>();
+    if known_groups.len() != reduction_groups.len() {
+        return Err(integrity("reduction groups repeat coherent-group IDs"));
+    }
+    let mut covered = Vec::new();
+    reserve(
+        &mut covered,
+        reduction_entries.len(),
+        "reduction entry coverage",
+    )?;
+    covered.resize(reduction_entries.len(), false);
+    for group in reduction_groups {
+        for (start, count, expected_kind, context) in [
+            (
+                group.amplitude_entry_start,
+                group.amplitude_entry_count,
+                EagerPlanReductionEntryKind::AmplitudeMember,
+                "amplitude reduction entries",
+            ),
+            (
+                group.selector_entry_start,
+                group.selector_entry_count,
+                EagerPlanReductionEntryKind::SelectorMember,
+                "selector reduction entries",
+            ),
+        ] {
+            let entries = checked_range(reduction_entries, start, count, context)?;
+            let start = usize_count(start, context)?;
+            for (offset, entry) in entries.iter().enumerate() {
+                if entry.kind != expected_kind || entry.owner_id != group.coherent_group_id {
+                    return Err(integrity(format!(
+                        "{context} have inconsistent tags/owners"
+                    )));
+                }
+                if entry.kind == EagerPlanReductionEntryKind::SelectorMember {
+                    required_index(
+                        entry.left_id,
+                        helicity_selectors.len(),
+                        "reduction helicity selector",
+                    )?;
+                    required_index(
+                        entry.right_id,
+                        color_selectors.len(),
+                        "reduction color selector",
+                    )?;
+                }
+                covered[start + offset] = true;
+            }
+        }
+        required_declared_index(
+            group.helicity_weight_factor_id,
+            exact_factor_count,
+            "reduction helicity weight",
+        )?;
+        required_declared_index(
+            group.all_sector_weight_factor_id,
+            exact_factor_count,
+            "reduction all-sector weight",
+        )?;
+    }
+
+    let contraction = checked_range(
+        reduction_entries,
+        metadata.color_contraction_entry_start,
+        metadata.color_contraction_entry_count,
+        "color contraction entries",
+    )?;
+    let contraction_start = usize_count(
+        metadata.color_contraction_entry_start,
+        "color contraction entry start",
+    )?;
+    for (offset, entry) in contraction.iter().enumerate() {
+        if entry.kind != EagerPlanReductionEntryKind::ColorContraction {
+            return Err(integrity(
+                "color contraction range contains another entry kind",
+            ));
+        }
+        covered[contraction_start + offset] = true;
+        if !known_groups.contains(&entry.left_id) || !known_groups.contains(&entry.right_id) {
+            return Err(integrity(
+                "color contraction references an unknown coherent group",
+            ));
+        }
+        required_declared_index(
+            entry.factor_id,
+            exact_factor_count,
+            "color contraction factor",
+        )?;
+        optional_declared_index(
+            entry.auxiliary_factor_id,
+            exact_factor_count,
+            "color contraction symmetry factor",
+        )?;
+    }
+    if covered.iter().any(|covered| !covered) {
+        return Err(integrity("reduction entry catalog contains unowned rows"));
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn validate_semantics(
+    metadata: Metadata,
+    invocation_group_upper_bound: u64,
+    currents: &[EagerPlanCurrentRow],
+    values: &[EagerPlanValueRow],
+    momenta: &[EagerPlanMomentumRow],
+    sources: &[EagerPlanSourceFillRow],
+    parameters: &[EagerPlanParameterRow],
+    stages: &[EagerPlanStageRow],
+    couplings: &[EagerPlanCouplingRow],
+    invocations: &[EagerPlanInvocationRow],
+    attachments: &[EagerPlanAttachmentRow],
+    finalizations: &[EagerPlanFinalizationRow],
+    closures: &[EagerPlanClosureRow],
+    direct_coefficients: &[EagerPlanDirectCoefficientRow],
+    selector_domains: &[EagerPlanSelectorDomainRow],
+    selector_memberships: &[u32],
+    helicity_selectors: &[EagerPlanHelicitySelectorRow],
+    color_selectors: &[EagerPlanColorSelectorRow],
+    reduction_groups: &[EagerPlanReductionGroupRow],
+    reduction_entries: &[EagerPlanReductionEntryRow],
+    exact_factors: &[EagerPlanExactFactorRow],
+    bitset_ranges: &[EagerPlanCatalogRangeRow],
+    u32_sequence_ranges: &[EagerPlanCatalogRangeRow],
+    i32_sequence_ranges: &[EagerPlanCatalogRangeRow],
+    strings: &[Box<str>],
+    exact_ir: &[Box<str>],
+    kernel_specs: &[EagerKernelSpec],
+) -> RusticolResult<()> {
+    validate_component_layout(
+        "current",
+        currents.iter().enumerate().map(|(index, row)| {
+            (
+                index,
+                row.current_id,
+                row.component_start,
+                row.component_count,
+            )
+        }),
+        metadata.current_component_count,
+    )?;
+    validate_component_layout(
+        "value",
+        values.iter().enumerate().map(|(index, row)| {
+            (
+                index,
+                row.value_slot_id,
+                row.component_start,
+                row.component_count,
+            )
+        }),
+        metadata.value_component_count,
+    )?;
+    validate_component_layout(
+        "momentum",
+        momenta.iter().enumerate().map(|(index, row)| {
+            (
+                index,
+                row.momentum_slot_id,
+                row.component_start,
+                row.component_count,
+            )
+        }),
+        metadata.momentum_component_count,
+    )?;
+    for row in currents {
+        required_index(row.momentum_slot_id, momenta.len(), "current momentum slot")?;
+        if row.flags & !1 != 0 {
+            return Err(RusticolError::compatibility("unknown eager current flags"));
+        }
+    }
+    for row in values {
+        let current = required_index(row.current_id, currents.len(), "value current")?;
+        if currents[current].component_count != row.component_count {
+            return Err(integrity("value/current component counts disagree"));
+        }
+    }
+    for row in momenta {
+        required_index(row.bitset_id, bitset_ranges.len(), "momentum bitset")?;
+    }
+    validate_dense_ids(sources.iter().map(|row| row.source_id), "source")?;
+    for row in sources {
+        let current = required_index(row.current_id, currents.len(), "source current")?;
+        let value = required_index(row.value_slot_id, values.len(), "source value slot")?;
+        required_index(
+            row.input_momentum_slot,
+            momenta.len(),
+            "source input momentum",
+        )?;
+        required_index(row.source_ir_id, exact_ir.len(), "source exact IR")?;
+        required_index(row.crossing_ir_id, exact_ir.len(), "source crossing IR")?;
+        required_index(
+            row.crossing_factor_id,
+            exact_factors.len(),
+            "source crossing factor",
+        )?;
+        if currents[current].flags & 1 == 0 || values[value].kind != EagerValueSlotKind::Source {
+            return Err(integrity(
+                "source row does not reference source current/value slots",
+            ));
+        }
+    }
+    validate_dense_ids(parameters.iter().map(|row| row.parameter_id), "parameter")?;
+    for row in parameters {
+        required_index(row.name_string_id, strings.len(), "parameter name")?;
+        required_index(row.kind_string_id, strings.len(), "parameter kind")?;
+        optional_index(
+            row.runtime_name_string_id,
+            strings.len(),
+            "parameter runtime name",
+        )?;
+        required_index(
+            row.default_factor_id,
+            exact_factors.len(),
+            "parameter default factor",
+        )?;
+        if !(-1..=1).contains(&row.complex_component) || row.flags & !1 != 0 {
+            return Err(RusticolError::compatibility(
+                "unsupported eager parameter component or flags",
+            ));
+        }
+    }
+    validate_stages(
+        stages,
+        invocations.len(),
+        attachments.len(),
+        finalizations.len(),
+    )?;
+    validate_dense_ids(couplings.iter().map(|row| row.coupling_id), "coupling")?;
+    for row in couplings {
+        optional_index(
+            row.real_parameter_id,
+            parameters.len(),
+            "coupling real parameter",
+        )?;
+        optional_index(
+            row.imaginary_parameter_id,
+            parameters.len(),
+            "coupling imaginary parameter",
+        )?;
+        required_index(
+            row.constant_factor_id,
+            exact_factors.len(),
+            "coupling constant factor",
+        )?;
+    }
+
+    let kernels = kernel_specs
+        .iter()
+        .map(|kernel| (kernel.kernel_id, kernel.role))
+        .collect::<BTreeMap<_, _>>();
+    if kernels.len() != kernel_specs.len() {
+        return Err(integrity("prepared kernel specs repeat a kernel ID"));
+    }
+    validate_ordered_sparse_ids(
+        invocations.iter().map(|row| row.evaluation_group_id),
+        invocation_group_upper_bound,
+        "invocation evaluation group",
+    )?;
+    for row in invocations {
+        require_kernel(&kernels, row.kernel_id, EagerKernelRole::Vertex)?;
+        required_index(
+            row.left_value_slot_id,
+            values.len(),
+            "invocation left value",
+        )?;
+        required_index(
+            row.right_value_slot_id,
+            values.len(),
+            "invocation right value",
+        )?;
+        required_index(
+            row.left_momentum_slot_id,
+            momenta.len(),
+            "invocation left momentum",
+        )?;
+        required_index(
+            row.right_momentum_slot_id,
+            momenta.len(),
+            "invocation right momentum",
+        )?;
+        optional_index(row.coupling_slot_id, couplings.len(), "invocation coupling")?;
+        validate_output_factor(row.output_factor_source, row.coupling_slot_id)?;
+        checked_range(
+            attachments,
+            row.attachment_start,
+            row.attachment_count,
+            "invocation attachments",
+        )?;
+        required_index(
+            row.selector_domain_id,
+            selector_domains.len(),
+            "invocation selector",
+        )?;
+    }
+    for row in attachments {
+        required_index(
+            row.result_current_id,
+            currents.len(),
+            "attachment result current",
+        )?;
+        for (factor, context) in [
+            (row.color_factor_id, "attachment color factor"),
+            (row.evaluation_factor_id, "attachment evaluation factor"),
+            (
+                row.normalization_factor_id,
+                "attachment normalization factor",
+            ),
+            (
+                row.representative_evaluation_factor_id,
+                "attachment representative factor",
+            ),
+        ] {
+            required_index(factor, exact_factors.len(), context)?;
+        }
+        required_index(
+            row.selector_domain_id,
+            selector_domains.len(),
+            "attachment selector",
+        )?;
+    }
+    for row in finalizations {
+        required_index(row.current_id, currents.len(), "finalization current")?;
+        optional_index(
+            row.unpropagated_value_slot_id,
+            values.len(),
+            "finalization unpropagated value",
+        )?;
+        optional_index(
+            row.propagated_value_slot_id,
+            values.len(),
+            "finalization propagated value",
+        )?;
+        required_index(row.momentum_slot_id, momenta.len(), "finalization momentum")?;
+        required_index(
+            row.unpropagated_selector_domain_id,
+            selector_domains.len(),
+            "finalization unpropagated selector",
+        )?;
+        required_index(
+            row.propagated_selector_domain_id,
+            selector_domains.len(),
+            "finalization propagated selector",
+        )?;
+        if row.kernel_id == MISSING_U32 {
+            if row.propagated_value_slot_id != MISSING_U32 {
+                return Err(integrity("propagated finalization lacks a prepared kernel"));
+            }
+        } else {
+            require_kernel(&kernels, row.kernel_id, EagerKernelRole::Finalization)?;
+        }
+    }
+    validate_dense_ids(closures.iter().map(|row| row.root_id), "closure root")?;
+    let mut amplitudes = BTreeSet::new();
+    for row in closures {
+        required_index(row.left_value_slot_id, values.len(), "closure left value")?;
+        required_index(row.right_value_slot_id, values.len(), "closure right value")?;
+        amplitudes.insert(row.amplitude_index);
+        optional_index(row.coupling_slot_id, couplings.len(), "closure coupling")?;
+        for (factor, context) in [
+            (row.coupling_factor_id, "closure coupling factor"),
+            (row.color_factor_id, "closure color factor"),
+            (row.normalization_factor_id, "closure normalization factor"),
+        ] {
+            required_index(factor, exact_factors.len(), context)?;
+        }
+        validate_output_factor(row.output_factor_source, row.coupling_slot_id)?;
+        let direct = checked_range(
+            direct_coefficients,
+            row.direct_coefficient_start,
+            row.direct_coefficient_count,
+            "closure direct coefficients",
+        )?;
+        if row.kernel_id == MISSING_U32 {
+            if direct.is_empty() {
+                return Err(integrity("direct eager closure has no coefficients"));
+            }
+        } else {
+            require_kernel(&kernels, row.kernel_id, EagerKernelRole::Closure)?;
+            if !direct.is_empty() {
+                return Err(integrity(
+                    "prepared eager closure also has direct coefficients",
+                ));
+            }
+        }
+        required_index(
+            row.selector_domain_id,
+            selector_domains.len(),
+            "closure selector",
+        )?;
+    }
+    if amplitudes
+        .iter()
+        .copied()
+        .ne(0..usize_u32(amplitudes.len(), "amplitude count")?)
+    {
+        return Err(integrity("closure amplitude indices are not dense"));
+    }
+    for row in direct_coefficients {
+        required_index(
+            row.contraction_ir_id,
+            exact_ir.len(),
+            "direct coefficient IR",
+        )?;
+        required_index(
+            row.factor_id,
+            exact_factors.len(),
+            "direct coefficient factor",
+        )?;
+    }
+
+    let known_groups = reduction_groups
+        .iter()
+        .map(|group| group.coherent_group_id)
+        .collect::<HashSet<_>>();
+    if known_groups.len() != reduction_groups.len() {
+        return Err(integrity("reduction groups repeat coherent-group IDs"));
+    }
+    let mut selector_cursor = 0_u64;
+    for domain in selector_domains {
+        if domain.member_start != selector_cursor {
+            return Err(integrity("selector-domain ranges are not contiguous"));
+        }
+        selector_cursor = checked_add(
+            domain.member_start,
+            domain.member_count,
+            "selector-domain memberships",
+        )?;
+    }
+    if selector_cursor != usize_u64(selector_memberships.len(), "selector memberships")? {
+        return Err(integrity(
+            "selector-domain ranges do not cover the membership catalog",
+        ));
+    }
+    for member in selector_memberships {
+        if !known_groups.contains(member) {
+            return Err(integrity(
+                "selector domain references an unknown coherent group",
+            ));
+        }
+    }
+    validate_dense_ids(
+        helicity_selectors.iter().map(|row| row.selector_id),
+        "helicity selector",
+    )?;
+    for row in helicity_selectors {
+        required_index(
+            row.values_sequence_id,
+            i32_sequence_ranges.len(),
+            "helicity values sequence",
+        )?;
+        required_index(
+            row.representative_sequence_id,
+            i32_sequence_ranges.len(),
+            "helicity representative sequence",
+        )?;
+        required_index(
+            row.coefficient_factor_id,
+            exact_factors.len(),
+            "helicity coefficient factor",
+        )?;
+    }
+    validate_dense_ids(
+        color_selectors.iter().map(|row| row.selector_id),
+        "color selector",
+    )?;
+    for row in color_selectors {
+        required_index(
+            row.word_sequence_id,
+            u32_sequence_ranges.len(),
+            "color word sequence",
+        )?;
+        required_index(
+            row.representative_word_sequence_id,
+            u32_sequence_ranges.len(),
+            "color representative sequence",
+        )?;
+        required_index(
+            row.coefficient_factor_id,
+            exact_factors.len(),
+            "color coefficient factor",
+        )?;
+    }
+
+    let mut covered = vec![false; reduction_entries.len()];
+    for group in reduction_groups {
+        for (start, count, expected_kind, context) in [
+            (
+                group.amplitude_entry_start,
+                group.amplitude_entry_count,
+                EagerPlanReductionEntryKind::AmplitudeMember,
+                "amplitude reduction entries",
+            ),
+            (
+                group.selector_entry_start,
+                group.selector_entry_count,
+                EagerPlanReductionEntryKind::SelectorMember,
+                "selector reduction entries",
+            ),
+        ] {
+            let entries = checked_range(reduction_entries, start, count, context)?;
+            let start = usize_count(start, context)?;
+            for (offset, entry) in entries.iter().enumerate() {
+                if entry.kind != expected_kind || entry.owner_id != group.coherent_group_id {
+                    return Err(integrity(format!(
+                        "{context} have inconsistent tags/owners"
+                    )));
+                }
+                covered[start + offset] = true;
+            }
+        }
+        required_index(
+            group.helicity_weight_factor_id,
+            exact_factors.len(),
+            "reduction helicity weight",
+        )?;
+        required_index(
+            group.all_sector_weight_factor_id,
+            exact_factors.len(),
+            "reduction all-sector weight",
+        )?;
+    }
+    let contraction = checked_range(
+        reduction_entries,
+        metadata.color_contraction_entry_start,
+        metadata.color_contraction_entry_count,
+        "color contraction entries",
+    )?;
+    let contraction_start = usize_count(
+        metadata.color_contraction_entry_start,
+        "color contraction entry start",
+    )?;
+    for (offset, entry) in contraction.iter().enumerate() {
+        if entry.kind != EagerPlanReductionEntryKind::ColorContraction {
+            return Err(integrity(
+                "color contraction range contains another entry kind",
+            ));
+        }
+        covered[contraction_start + offset] = true;
+        if !known_groups.contains(&entry.left_id) || !known_groups.contains(&entry.right_id) {
+            return Err(integrity(
+                "color contraction references an unknown coherent group",
+            ));
+        }
+        required_index(
+            entry.factor_id,
+            exact_factors.len(),
+            "color contraction factor",
+        )?;
+        optional_index(
+            entry.auxiliary_factor_id,
+            exact_factors.len(),
+            "color contraction symmetry factor",
+        )?;
+    }
+    if covered.iter().any(|covered| !covered) {
+        return Err(integrity("reduction entry catalog contains unowned rows"));
+    }
+
+    validate_dense_ids(
+        exact_factors.iter().map(|row| row.factor_id),
+        "exact factor",
+    )?;
+    for row in exact_factors {
+        required_index(
+            row.canonical_string_id,
+            strings.len(),
+            "exact factor canonical string",
+        )?;
+        optional_index(row.exact_ir_id, exact_ir.len(), "exact factor IR")?;
+        optional_index(row.source_ir_id, exact_ir.len(), "exact factor source IR")?;
+    }
+    Ok(())
+}
+
+fn validate_stages(
+    stages: &[EagerPlanStageRow],
+    invocation_count: usize,
+    attachment_count: usize,
+    finalization_count: usize,
+) -> RusticolResult<()> {
+    let mut invocations = 0_u64;
+    let mut attachments = 0_u64;
+    let mut finalizations = 0_u64;
+    let mut previous_subset = 0_u32;
+    for (index, stage) in stages.iter().enumerate() {
+        if stage.stage_index != usize_u32(index + 1, "stage index")?
+            || stage.subset_size <= previous_subset
+            || stage.invocation_start != invocations
+            || stage.attachment_start != attachments
+            || stage.finalization_start != finalizations
+        {
+            return Err(integrity(
+                "eager stage descriptors are not canonical and contiguous",
+            ));
+        }
+        invocations = checked_add(
+            stage.invocation_start,
+            stage.invocation_count,
+            "stage invocations",
+        )?;
+        attachments = checked_add(
+            stage.attachment_start,
+            stage.attachment_count,
+            "stage attachments",
+        )?;
+        finalizations = checked_add(
+            stage.finalization_start,
+            stage.finalization_count,
+            "stage finalizations",
+        )?;
+        previous_subset = stage.subset_size;
+    }
+    if invocations != usize_u64(invocation_count, "invocations")?
+        || attachments != usize_u64(attachment_count, "attachments")?
+        || finalizations != usize_u64(finalization_count, "finalizations")?
+    {
+        return Err(integrity(
+            "eager stage ranges do not cover their complete tables",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_output_factor(source: u8, coupling_id: u32) -> RusticolResult<()> {
+    if source > 2 || (coupling_id == MISSING_U32 && source != 0) {
+        return Err(RusticolError::compatibility(
+            "unsupported eager output-factor source",
+        ));
+    }
+    Ok(())
+}
+
+fn require_kernel(
+    kernels: &BTreeMap<u32, EagerKernelRole>,
+    id: u32,
+    expected: EagerKernelRole,
+) -> RusticolResult<()> {
+    match kernels.get(&id) {
+        Some(actual) if *actual == expected => Ok(()),
+        Some(actual) => Err(integrity(format!(
+            "prepared kernel {id} has role {actual:?}, expected {expected:?}"
+        ))),
+        None => Err(integrity(format!(
+            "eager plan references missing prepared kernel {id}"
+        ))),
+    }
+}
+
+fn validate_component_layout(
+    name: &str,
+    rows: impl Iterator<Item = (usize, u32, u64, u32)>,
+    declared_components: u64,
+) -> RusticolResult<()> {
+    let mut cursor = 0_u64;
+    for (index, id, start, count) in rows {
+        if id != usize_u32(index, &format!("{name} ID"))? || start != cursor || count == 0 {
+            return Err(integrity(format!(
+                "{name} component layout is not dense and contiguous"
+            )));
+        }
+        cursor = cursor
+            .checked_add(u64::from(count))
+            .ok_or_else(|| RusticolError::artifact(format!("{name} components exceed u64")))?;
+    }
+    if cursor != declared_components {
+        return Err(integrity(format!(
+            "{name} component layout total disagrees with metadata"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_dense_ids(ids: impl Iterator<Item = u32>, context: &str) -> RusticolResult<()> {
+    for (index, id) in ids.enumerate() {
+        if id != usize_u32(index, &format!("{context} ID"))? {
+            return Err(integrity(format!("{context} IDs are not dense")));
+        }
+    }
+    Ok(())
+}
+
+fn validate_ordered_sparse_ids(
+    ids: impl Iterator<Item = u32>,
+    exclusive_upper_bound: u64,
+    context: &str,
+) -> RusticolResult<()> {
+    let mut previous = None;
+    for id in ids {
+        if id == MISSING_U32 || u64::from(id) >= exclusive_upper_bound {
+            return Err(integrity(format!(
+                "{context} ID {id} is outside its authenticated domain"
+            )));
+        }
+        if previous.is_some_and(|previous| id <= previous) {
+            return Err(integrity(format!(
+                "{context} IDs are not strictly increasing and unique"
+            )));
+        }
+        previous = Some(id);
+    }
+    Ok(())
+}
+
+fn validate_catalog_ranges(
+    context: &str,
+    ranges: &[EagerPlanCatalogRangeRow],
+    value_count: usize,
+) -> RusticolResult<()> {
+    let mut cursor = 0_u64;
+    for range in ranges {
+        if range.start != cursor {
+            return Err(integrity(format!("{context} ranges are not contiguous")));
+        }
+        cursor = checked_add(range.start, range.count, context)?;
+    }
+    if cursor != usize_u64(value_count, context)? {
+        return Err(integrity(format!(
+            "{context} ranges do not cover their value catalog"
+        )));
+    }
+    Ok(())
+}
+
+struct DecodedSection<'a> {
+    count: u64,
+    payload: &'a [u8],
+}
+
+fn decode_referenced_sequences<T>(
+    reader: &PacbinReader,
+    ranges_path: &str,
+    values_path: &str,
+    referenced_ids: &BTreeSet<u32>,
+    context: &str,
+    decode: impl FnMut(&[u8]) -> RusticolResult<T>,
+) -> RusticolResult<BTreeMap<u32, Vec<T>>> {
+    let ranges = section(
+        reader,
+        ranges_path,
+        EagerSectionKind::Metadata,
+        EagerPlanCatalogRangeRow::ENCODED_LEN,
+    )?;
+    let values = section(reader, values_path, EagerSectionKind::Metadata, 4)?;
+    project_referenced_sequences(&ranges, &values, referenced_ids, context, decode)
+}
+
+/// Validate the complete borrowed range catalog, then own only the values
+/// reachable from `referenced_ids`.
+fn project_referenced_sequences<T>(
+    ranges: &DecodedSection<'_>,
+    values: &DecodedSection<'_>,
+    referenced_ids: &BTreeSet<u32>,
+    context: &str,
+    mut decode: impl FnMut(&[u8]) -> RusticolResult<T>,
+) -> RusticolResult<BTreeMap<u32, Vec<T>>> {
+    let range_width = usize::try_from(EagerPlanCatalogRangeRow::ENCODED_LEN)
+        .map_err(|_| RusticolError::artifact(format!("{context} range width exceeds usize")))?;
+    let value_width = 4_usize;
+    let range_count = usize_count(ranges.count, context)?;
+    if ranges.payload.chunks_exact(range_width).len() != range_count {
+        return Err(integrity(format!(
+            "{context} range row count changed unexpectedly"
+        )));
+    }
+
+    // Authentication covers every byte before this point. This streaming pass
+    // additionally checks that even unreferenced ranges have canonical,
+    // gap-free coverage without allocating their rows.
+    let mut cursor = 0_u64;
+    for row in ranges.payload.chunks_exact(range_width) {
+        let start = read_u64(row, 0)?;
+        let count = read_u64(row, 8)?;
+        if start != cursor {
+            return Err(integrity(format!("{context} ranges are not contiguous")));
+        }
+        cursor = checked_add(start, count, context)?;
+    }
+    if cursor != values.count {
+        return Err(integrity(format!(
+            "{context} ranges do not cover their value catalog"
+        )));
+    }
+
+    let mut projected = BTreeMap::new();
+    for &sequence_id in referenced_ids {
+        required_declared_index(sequence_id, ranges.count, context)?;
+        let sequence_index = usize::try_from(sequence_id)
+            .map_err(|_| RusticolError::artifact(format!("{context} ID exceeds usize")))?;
+        let range_start = sequence_index
+            .checked_mul(range_width)
+            .ok_or_else(|| RusticolError::artifact(format!("{context} range offset overflows")))?;
+        let range_stop = range_start
+            .checked_add(range_width)
+            .ok_or_else(|| RusticolError::artifact(format!("{context} range offset overflows")))?;
+        let range = ranges.payload.get(range_start..range_stop).ok_or_else(|| {
+            integrity(format!(
+                "{context} {sequence_id} range row is out of bounds"
+            ))
+        })?;
+        let start = usize_count(read_u64(range, 0)?, context)?;
+        let count = usize_count(read_u64(range, 8)?, context)?;
+        let stop = start
+            .checked_add(count)
+            .ok_or_else(|| RusticolError::artifact(format!("{context} range exceeds usize")))?;
+        let byte_start = start
+            .checked_mul(value_width)
+            .ok_or_else(|| RusticolError::artifact(format!("{context} byte range overflows")))?;
+        let byte_stop = stop
+            .checked_mul(value_width)
+            .ok_or_else(|| RusticolError::artifact(format!("{context} byte range overflows")))?;
+        let encoded = values.payload.get(byte_start..byte_stop).ok_or_else(|| {
+            integrity(format!(
+                "{context} {sequence_id} value range is out of bounds"
+            ))
+        })?;
+
+        let mut sequence = Vec::new();
+        reserve(&mut sequence, count, context)?;
+        for row in encoded.chunks_exact(value_width) {
+            sequence.push(decode(row)?);
+        }
+        if sequence.len() != count {
+            return Err(integrity(format!(
+                "{context} {sequence_id} decoded length changed unexpectedly"
+            )));
+        }
+        projected.insert(sequence_id, sequence);
+    }
+    Ok(projected)
+}
+
+fn section<'a>(
+    reader: &'a PacbinReader,
+    path: &str,
+    kind: EagerSectionKind,
+    record_size: u32,
+) -> RusticolResult<DecodedSection<'a>> {
+    let bytes = reader.member_bytes(path)?;
+    let (header, payload) = EagerSectionHeader::decode(bytes)?;
+    if header.kind() != kind || header.record_size() != record_size {
+        return Err(RusticolError::compatibility(format!(
+            "eager PACBIN member {path:?} has shape ({:?}, {}), expected ({kind:?}, {record_size})",
+            header.kind(),
+            header.record_size(),
+        )));
+    }
+    Ok(DecodedSection {
+        count: header.record_count(),
+        payload,
+    })
+}
+
+fn decode_rows<T>(
+    reader: &PacbinReader,
+    path: &str,
+    kind: EagerSectionKind,
+    record_size: u32,
+    mut decode: impl FnMut(&[u8]) -> RusticolResult<T>,
+) -> RusticolResult<Vec<T>> {
+    let section = section(reader, path, kind, record_size)?;
+    let count = usize_count(section.count, path)?;
+    let width = usize::try_from(record_size)
+        .map_err(|_| RusticolError::artifact(format!("{path} record size does not fit usize")))?;
+    let mut result = Vec::new();
+    reserve(&mut result, count, path)?;
+    for row in section.payload.chunks_exact(width) {
+        result.push(decode(row)?);
+    }
+    if result.len() != count {
+        return Err(integrity(format!(
+            "{path} decoded row count changed unexpectedly"
+        )));
+    }
+    Ok(result)
+}
+
+fn decode_u32_section(
+    reader: &PacbinReader,
+    path: &str,
+    kind: EagerSectionKind,
+) -> RusticolResult<Vec<u32>> {
+    decode_rows(reader, path, kind, 4, |row| read_u32(row, 0))
+}
+
+fn decode_i32_section(
+    reader: &PacbinReader,
+    path: &str,
+    kind: EagerSectionKind,
+) -> RusticolResult<Vec<i32>> {
+    decode_rows(reader, path, kind, 4, |row| read_i32(row, 0))
+}
+
+fn decode_u64_section(
+    reader: &PacbinReader,
+    path: &str,
+    kind: EagerSectionKind,
+) -> RusticolResult<Vec<u64>> {
+    decode_rows(reader, path, kind, 8, |row| read_u64(row, 0))
+}
+
+fn read_bool(row: &[u8], offset: usize, context: &str) -> RusticolResult<u8> {
+    let value = read_u8(row, offset)?;
+    if value > 1 {
+        return Err(integrity(format!(
+            "{context} must be encoded as zero or one"
+        )));
+    }
+    Ok(value)
+}
+
+fn read_u8(bytes: &[u8], offset: usize) -> RusticolResult<u8> {
+    bytes
+        .get(offset)
+        .copied()
+        .ok_or_else(|| integrity("truncated eager fixed-width record"))
+}
+
+fn read_u16(bytes: &[u8], offset: usize) -> RusticolResult<u16> {
+    Ok(u16::from_le_bytes(read_array(bytes, offset)?))
+}
+
+fn read_u32(bytes: &[u8], offset: usize) -> RusticolResult<u32> {
+    Ok(u32::from_le_bytes(read_array(bytes, offset)?))
+}
+
+fn read_i32(bytes: &[u8], offset: usize) -> RusticolResult<i32> {
+    Ok(i32::from_le_bytes(read_array(bytes, offset)?))
+}
+
+fn read_u64(bytes: &[u8], offset: usize) -> RusticolResult<u64> {
+    Ok(u64::from_le_bytes(read_array(bytes, offset)?))
+}
+
+fn read_array<const N: usize>(bytes: &[u8], offset: usize) -> RusticolResult<[u8; N]> {
+    let end = offset
+        .checked_add(N)
+        .ok_or_else(|| integrity("eager fixed-width record offset overflow"))?;
+    bytes
+        .get(offset..end)
+        .ok_or_else(|| integrity("truncated eager fixed-width record"))?
+        .try_into()
+        .map_err(|_| integrity("truncated eager fixed-width record"))
+}
+
+fn require_zero(bytes: &[u8], start: usize, end: usize, context: &str) -> RusticolResult<()> {
+    if bytes
+        .get(start..end)
+        .ok_or_else(|| integrity(format!("truncated {context}")))?
+        .iter()
+        .any(|value| *value != 0)
+    {
+        return Err(integrity(format!("{context} must be zero")));
+    }
+    Ok(())
+}
+
+fn require_count(section: &DecodedSection<'_>, expected: u64, context: &str) -> RusticolResult<()> {
+    if section.count != expected {
+        return Err(integrity(format!(
+            "{context} has {} records, expected {expected}",
+            section.count
+        )));
+    }
+    Ok(())
+}
+
+fn required_catalog<'a>(values: &'a [Box<str>], id: u32, context: &str) -> RusticolResult<&'a str> {
+    values
+        .get(required_index(id, values.len(), context)?)
+        .map(Box::as_ref)
+        .ok_or_else(|| integrity(format!("{context} is out of range")))
+}
+
+fn required_index(id: u32, length: usize, context: &str) -> RusticolResult<usize> {
+    let index = usize::try_from(id)
+        .map_err(|_| RusticolError::artifact(format!("{context} does not fit usize")))?;
+    if index >= length {
+        return Err(integrity(format!(
+            "{context} {id} is outside a catalog of length {length}"
+        )));
+    }
+    Ok(index)
+}
+
+fn required_declared_index(id: u32, length: u64, context: &str) -> RusticolResult<()> {
+    if u64::from(id) >= length {
+        return Err(integrity(format!(
+            "{context} {id} is outside a catalog of length {length}"
+        )));
+    }
+    Ok(())
+}
+
+fn required_projected_sequence<'a, T>(
+    sequences: &'a BTreeMap<u32, Vec<T>>,
+    id: u32,
+    context: &str,
+) -> RusticolResult<&'a [T]> {
+    sequences.get(&id).map(Vec::as_slice).ok_or_else(|| {
+        integrity(format!(
+            "{context} {id} is absent from the referenced catalog projection"
+        ))
+    })
+}
+
+fn optional_index(id: u32, length: usize, context: &str) -> RusticolResult<()> {
+    if id != MISSING_U32 {
+        required_index(id, length, context)?;
+    }
+    Ok(())
+}
+
+fn optional_declared_index(id: u32, length: u64, context: &str) -> RusticolResult<()> {
+    if id != MISSING_U32 {
+        required_declared_index(id, length, context)?;
+    }
+    Ok(())
+}
+
+fn checked_range<'a, T>(
+    values: &'a [T],
+    start: u64,
+    count: u64,
+    context: &str,
+) -> RusticolResult<&'a [T]> {
+    let start = usize_count(start, context)?;
+    let count = usize_count(count, context)?;
+    let end = start
+        .checked_add(count)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} range exceeds usize")))?;
+    values.get(start..end).ok_or_else(|| {
+        integrity(format!(
+            "{context} range {start}..{end} exceeds length {}",
+            values.len()
+        ))
+    })
+}
+
+fn checked_add(start: u64, count: u64, context: &str) -> RusticolResult<u64> {
+    start
+        .checked_add(count)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} range exceeds u64")))
+}
+
+fn check_count(context: &str, actual: usize, declared: u64) -> RusticolResult<()> {
+    if usize_u64(actual, context)? != declared {
+        return Err(integrity(format!(
+            "{context} count {actual} does not match declared count {declared}"
+        )));
+    }
+    Ok(())
+}
+
+fn usize_count(value: u64, context: &str) -> RusticolResult<usize> {
+    usize::try_from(value)
+        .map_err(|_| RusticolError::artifact(format!("{context} count does not fit usize")))
+}
+
+fn usize_u32(value: usize, context: &str) -> RusticolResult<u32> {
+    u32::try_from(value).map_err(|_| RusticolError::artifact(format!("{context} exceeds u32")))
+}
+
+fn usize_u64(value: usize, context: &str) -> RusticolResult<u64> {
+    u64::try_from(value).map_err(|_| RusticolError::artifact(format!("{context} exceeds u64")))
+}
+
+fn reserve<T>(values: &mut Vec<T>, count: usize, context: &str) -> RusticolResult<()> {
+    values.try_reserve_exact(count).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not reserve {context} ({count} rows): {error}"
+        ))
+    })
+}
+
+fn integrity(message: impl Into<String>) -> RusticolError {
+    RusticolError::integrity(message.into())
+}
+
+#[cfg(test)]
+mod reduction_subset_tests {
+    use super::*;
+    use crate::pacbin::{
+        PacbinMemberKind, PacbinReader, PacbinWriteMember, PacbinWriteOptions, write_pacbin_atomic,
+    };
+    use std::fs;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    static NEXT_INVOCATION_FIXTURE: AtomicU64 = AtomicU64::new(0);
+
+    fn invocation(evaluation_group_id: u32) -> EagerPlanInvocationRow {
+        EagerPlanInvocationRow {
+            evaluation_group_id,
+            kernel_id: 0,
+            left_value_slot_id: 0,
+            right_value_slot_id: 0,
+            left_momentum_slot_id: 0,
+            right_momentum_slot_id: 0,
+            coupling_slot_id: 0,
+            output_factor_source: 0,
+            attachment_start: 0,
+            attachment_count: 1,
+            selector_domain_id: MISSING_U32,
+        }
+    }
+
+    fn put_u32(row: &mut [u8], offset: usize, value: u32) {
+        row[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
+    }
+
+    fn put_u64(row: &mut [u8], offset: usize, value: u64) {
+        row[offset..offset + 8].copy_from_slice(&value.to_le_bytes());
+    }
+
+    fn decode_invocation_fixture(
+        rows: &[EagerPlanInvocationRow],
+        corrupt_padding: bool,
+    ) -> RusticolResult<Vec<EagerPlanInvocationRow>> {
+        let mut bytes = EagerSectionHeader::new(
+            EagerSectionKind::Invocations,
+            EagerPlanInvocationRow::ENCODED_LEN,
+            rows.len() as u64,
+        )?
+        .encode()
+        .to_vec();
+        for (index, source) in rows.iter().enumerate() {
+            let mut row = [0_u8; EagerPlanInvocationRow::ENCODED_LEN as usize];
+            for (offset, value) in [
+                source.evaluation_group_id,
+                source.kernel_id,
+                source.left_value_slot_id,
+                source.right_value_slot_id,
+                source.left_momentum_slot_id,
+                source.right_momentum_slot_id,
+                source.coupling_slot_id,
+            ]
+            .into_iter()
+            .enumerate()
+            {
+                put_u32(&mut row, offset * 4, value);
+            }
+            row[28] = source.output_factor_source;
+            put_u64(&mut row, 32, source.attachment_start);
+            put_u64(&mut row, 40, source.attachment_count);
+            put_u32(&mut row, 48, source.selector_domain_id);
+            if corrupt_padding && index == 0 {
+                row[29] = 1;
+            }
+            bytes.extend_from_slice(&row);
+        }
+
+        let root = std::env::temp_dir().join(format!(
+            "rusticol-eager-sparse-invocations-{}-{}",
+            std::process::id(),
+            NEXT_INVOCATION_FIXTURE.fetch_add(1, Ordering::Relaxed),
+        ));
+        fs::create_dir(&root).map_err(|error| {
+            RusticolError::artifact(format!("could not create test directory: {error}"))
+        })?;
+        let path = root.join("invocations.pacbin");
+        let member = PacbinWriteMember::from_bytes(
+            "tables/invocations.bin",
+            PacbinMemberKind::EagerRuntimeTable,
+            &bytes,
+        )?;
+        write_pacbin_atomic(&path, [member], PacbinWriteOptions::default())?;
+        let reader = PacbinReader::open(&path)?;
+        let decoded = decode_invocations(&reader);
+        drop(reader);
+        let _ = fs::remove_dir_all(root);
+        decoded
+    }
+
+    fn metadata() -> Metadata {
+        Metadata {
+            retained_column_count: 0,
+            current_component_count: 0,
+            value_component_count: 0,
+            momentum_component_count: 0,
+            color_contraction_entry_start: 2,
+            color_contraction_entry_count: 1,
+            string_count: 0,
+            exact_ir_count: 0,
+            limitation_count: 0,
+            retained_table_count: 0,
+            current_count: 0,
+            value_count: 0,
+            momentum_count: 0,
+            source_count: 0,
+            stage_count: 0,
+            invocation_count: 0,
+            closure_count: 0,
+            direct_coefficient_count: 0,
+            helicity_selector_count: 1,
+            color_selector_count: 1,
+            exact_factor_count: 2,
+        }
+    }
+
+    fn color_selectors() -> Vec<EagerPlanColorSelectorRow> {
+        vec![EagerPlanColorSelectorRow {
+            selector_id: 0,
+            word_sequence_id: 0,
+            representative_word_sequence_id: 0,
+            coefficient_factor_id: 0,
+            computed: 1,
+        }]
+    }
+
+    fn helicity_selectors() -> Vec<EagerPlanHelicitySelectorRow> {
+        vec![EagerPlanHelicitySelectorRow {
+            selector_id: 0,
+            values_sequence_id: 0,
+            representative_sequence_id: 0,
+            coefficient_factor_id: 0,
+            computed: 1,
+            structural_zero: 0,
+        }]
+    }
+
+    fn groups() -> Vec<EagerPlanReductionGroupRow> {
+        vec![EagerPlanReductionGroupRow {
+            coherent_group_id: 7,
+            amplitude_entry_start: 0,
+            amplitude_entry_count: 1,
+            selector_entry_start: 1,
+            selector_entry_count: 1,
+            helicity_weight_factor_id: 0,
+            all_sector_weight_factor_id: 1,
+        }]
+    }
+
+    fn entries() -> Vec<EagerPlanReductionEntryRow> {
+        vec![
+            EagerPlanReductionEntryRow {
+                kind: EagerPlanReductionEntryKind::AmplitudeMember,
+                owner_id: 7,
+                left_id: 0,
+                right_id: MISSING_U32,
+                factor_id: MISSING_U32,
+                auxiliary_factor_id: MISSING_U32,
+            },
+            EagerPlanReductionEntryRow {
+                kind: EagerPlanReductionEntryKind::SelectorMember,
+                owner_id: 7,
+                left_id: 0,
+                right_id: 0,
+                factor_id: MISSING_U32,
+                auxiliary_factor_id: MISSING_U32,
+            },
+            EagerPlanReductionEntryRow {
+                kind: EagerPlanReductionEntryKind::ColorContraction,
+                owner_id: MISSING_U32,
+                left_id: 7,
+                right_id: 7,
+                factor_id: 1,
+                auxiliary_factor_id: MISSING_U32,
+            },
+        ]
+    }
+
+    fn validate(entries: &[EagerPlanReductionEntryRow]) -> RusticolResult<()> {
+        validate_reduction_subset_semantics(
+            metadata(),
+            2,
+            &helicity_selectors(),
+            &color_selectors(),
+            &groups(),
+            entries,
+            &BTreeMap::from([(0, vec![1, -1, 1])]),
+            &BTreeMap::from([(0, vec![1, 2])]),
+        )
+    }
+
+    #[test]
+    fn bounded_reduction_semantics_accept_canonical_partition() {
+        validate(&entries()).expect("canonical reduction subset");
+    }
+
+    #[test]
+    fn active_kernel_census_uses_invocations_and_non_sentinel_terminal_rows() {
+        assert_eq!(
+            active_kernel_ids([7, 7], [MISSING_U32, 9], [11, MISSING_U32]),
+            BTreeSet::from([7, 9, 11])
+        );
+    }
+
+    #[test]
+    fn pacbin_decode_accepts_sparse_invocation_groups_after_zero_first_group() {
+        let decoded = decode_invocation_fixture(&[invocation(1), invocation(3)], false)
+            .expect("decode authenticated sparse invocation rows");
+        assert_eq!(
+            decoded
+                .iter()
+                .map(|row| row.evaluation_group_id)
+                .collect::<Vec<_>>(),
+            [1, 3]
+        );
+        validate_ordered_sparse_ids(
+            decoded.iter().map(|row| row.evaluation_group_id),
+            4,
+            "invocation evaluation group",
+        )
+        .expect("zero-first-group pruning retains authenticated sparse IDs");
+    }
+
+    #[test]
+    fn sparse_invocation_group_ids_reject_duplicates_order_and_domain_escape() {
+        for (ids, message) in [
+            (&[1_u32, 1][..], "strictly increasing and unique"),
+            (&[2_u32, 1][..], "strictly increasing and unique"),
+            (&[1_u32, 4][..], "outside its authenticated domain"),
+            (&[MISSING_U32][..], "outside its authenticated domain"),
+        ] {
+            let rows = ids.iter().copied().map(invocation).collect::<Vec<_>>();
+            let decoded = decode_invocation_fixture(&rows, false)
+                .expect("fixed-width invocation rows remain decodable");
+            let error = validate_ordered_sparse_ids(
+                decoded.iter().map(|row| row.evaluation_group_id),
+                4,
+                "invocation evaluation group",
+            )
+            .expect_err("malformed sparse group IDs must fail closed");
+            assert!(error.to_string().contains(message), "{error}");
+        }
+    }
+
+    #[test]
+    fn pacbin_invocation_padding_mutation_fails_closed() {
+        let error = decode_invocation_fixture(&[invocation(1)], true)
+            .expect_err("mutated invocation padding must fail closed");
+        assert!(
+            error
+                .to_string()
+                .contains("invocation row padding must be zero"),
+            "{error}"
+        );
+    }
+
+    #[test]
+    fn bounded_reduction_semantics_reject_corrupt_selector_and_coverage() {
+        let mut wrong_owner = entries();
+        wrong_owner[1].owner_id = 8;
+        assert!(
+            validate(&wrong_owner)
+                .unwrap_err()
+                .to_string()
+                .contains("inconsistent tags/owners")
+        );
+
+        let mut wrong_color = entries();
+        wrong_color[1].right_id = 1;
+        assert!(
+            validate(&wrong_color)
+                .unwrap_err()
+                .to_string()
+                .contains("reduction color selector")
+        );
+
+        let mut unowned = entries();
+        unowned.push(EagerPlanReductionEntryRow {
+            kind: EagerPlanReductionEntryKind::AmplitudeMember,
+            owner_id: 7,
+            left_id: 1,
+            right_id: MISSING_U32,
+            factor_id: MISSING_U32,
+            auxiliary_factor_id: MISSING_U32,
+        });
+        assert!(
+            validate(&unowned)
+                .unwrap_err()
+                .to_string()
+                .contains("unowned rows")
+        );
+    }
+
+    #[test]
+    fn large_irrelevant_catalog_projects_only_referenced_values() {
+        use std::cell::Cell;
+
+        let catalog_size = 250_000_u32;
+        let mut range_bytes = Vec::with_capacity(catalog_size as usize * 16);
+        let mut value_bytes = Vec::with_capacity(catalog_size as usize * 4);
+        for id in 0..catalog_size {
+            range_bytes.extend_from_slice(&u64::from(id).to_le_bytes());
+            range_bytes.extend_from_slice(&1_u64.to_le_bytes());
+            value_bytes.extend_from_slice(&id.to_le_bytes());
+        }
+        let ranges = DecodedSection {
+            count: u64::from(catalog_size),
+            payload: &range_bytes,
+        };
+        let values = DecodedSection {
+            count: u64::from(catalog_size),
+            payload: &value_bytes,
+        };
+        let last = catalog_size - 3;
+        let referenced = BTreeSet::from([7, last]);
+        let decoded_value_count = Cell::new(0_usize);
+
+        let projected = project_referenced_sequences(
+            &ranges,
+            &values,
+            &referenced,
+            "bounded test sequence",
+            |row| {
+                decoded_value_count.set(decoded_value_count.get() + 1);
+                read_u32(row, 0)
+            },
+        )
+        .expect("project referenced catalog");
+
+        assert_eq!(projected.len(), 2);
+        assert_eq!(projected.values().map(Vec::len).sum::<usize>(), 2);
+        assert_eq!(decoded_value_count.get(), 2);
+        assert_eq!(projected[&7], [7]);
+        assert_eq!(projected[&last], [last]);
+    }
+
+    #[test]
+    fn referenced_projection_validates_unreferenced_range_rows() {
+        let mut range_bytes = Vec::new();
+        for (start, count) in [(0_u64, 1_u64), (9, 1), (2, 1)] {
+            range_bytes.extend_from_slice(&start.to_le_bytes());
+            range_bytes.extend_from_slice(&count.to_le_bytes());
+        }
+        let value_bytes = [0_u32, 1, 2]
+            .into_iter()
+            .flat_map(u32::to_le_bytes)
+            .collect::<Vec<_>>();
+        let ranges = DecodedSection {
+            count: 3,
+            payload: &range_bytes,
+        };
+        let values = DecodedSection {
+            count: 3,
+            payload: &value_bytes,
+        };
+
+        let error = project_referenced_sequences(
+            &ranges,
+            &values,
+            &BTreeSet::from([0]),
+            "authenticated sequence",
+            |row| read_u32(row, 0),
+        )
+        .unwrap_err();
+
+        assert!(error.to_string().contains("ranges are not contiguous"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_load.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_load.rs
new file mode 100644
index 0000000000..18b93bc9cf
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_load.rs
@@ -0,0 +1,2167 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Native loader for compact eager plan-v3 artifacts.
+
+use super::eager_manifest::PreparedKernelPackManifest;
+use super::eager_v3_decode::DecodedEagerRuntimeV3;
+use super::eager_v3_manifest::EagerV3ExecutionManifest;
+use super::*;
+use crate::eager_runtime::EagerPlanV3Sections;
+use crate::{
+    EagerCouplingRow, EagerPlanCouplingRow, EagerPlanReductionEntryKind, EagerRuntimeOptions,
+    MISSING_U32,
+};
+use serde::Deserialize;
+use serde_json::json;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+use sha2::{Digest, Sha256};
+
+const NATIVE_REDUCTION_GROUPS_EXTENSION_KEY: &str = "native_reduction_groups";
+const NATIVE_REDUCTION_GROUPS_KIND: &str = "pyamplicol-eager-plan-v3-reduction-groups";
+const NATIVE_REDUCTION_GROUPS_SCHEMA_VERSION: u32 = 1;
+const NATIVE_REDUCTION_GROUPS_STORAGE_ABI: &str = "pacbin-v1";
+const NATIVE_REDUCTION_GROUPS_RUNTIME_LAYOUT_ABI: &str = "pyamplicol-eager-runtime-layout-v1";
+const NATIVE_REDUCTION_GROUPS_CONTAINER_PATH: &str = "eager-runtime.pacbin";
+const NATIVE_REDUCTION_GROUPS_GROUP_MEMBER: &str = "reductions/groups.bin";
+const NATIVE_REDUCTION_GROUPS_ENTRY_MEMBER: &str = "reductions/entries.bin";
+
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct NativeReductionGroupsDescriptor {
+    kind: String,
+    schema_version: u32,
+    storage_abi: String,
+    runtime_layout_abi: String,
+    container_path: String,
+    group_member: String,
+    entry_member: String,
+    group_count: u64,
+}
+
+pub(super) struct EagerV3PreparedPack {
+    pub(super) manifest: PreparedKernelPackManifest,
+    pub(super) payload_root: PathBuf,
+}
+
+pub(super) struct LoadedEagerV3Runtime {
+    pub(super) common: ExecutionRuntime,
+    pub(super) lane: EagerNativeRuntime,
+}
+
+pub(super) fn load_eager_v3_prepared_pack(
+    artifact: &VerifiedArtifact,
+    manifest: &EagerV3ExecutionManifest,
+) -> RusticolResult<EagerV3PreparedPack> {
+    let manifest_path = confined_internal_path(
+        &manifest.kernel_pack.manifest_path,
+        "eager plan-v3 prepared kernel-pack manifest path",
+    )?;
+    let manifest_path = manifest_path.to_str().ok_or_else(|| {
+        RusticolError::security("prepared kernel-pack manifest path is not valid UTF-8")
+    })?;
+    if artifact.payload(manifest_path)?.role != PayloadRole::EvaluatorManifest {
+        return Err(RusticolError::security(format!(
+            "prepared kernel-pack path {manifest_path:?} is not an evaluator-manifest payload"
+        )));
+    }
+    let bytes = artifact.read_payload(manifest_path)?;
+    let pack: PreparedKernelPackManifest = serde_json::from_slice(&bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse prepared kernel pack {manifest_path:?}: {error}"
+        ))
+    })?;
+    pack.validate()?;
+    validate_eager_prepared_pack_outer_target(&artifact.manifest().producer.target, &pack)?;
+    let payload_root = confined_internal_path(
+        &manifest.kernel_pack.payload_root,
+        "eager plan-v3 prepared kernel payload root",
+    )?;
+    let payload_root = artifact.root().join(payload_root);
+    validate_prepared_kernel_references(artifact, &payload_root, &pack)?;
+    Ok(EagerV3PreparedPack {
+        manifest: pack,
+        payload_root,
+    })
+}
+
+pub(super) fn validate_eager_prepared_pack_outer_target(
+    outer_target: &crate::Target,
+    pack: &PreparedKernelPackManifest,
+) -> RusticolResult<()> {
+    pack.validate_portable_process_artifact_target(outer_target, "eager")
+}
+
+pub(super) fn load_eager_v3_native_runtime(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &EagerV3ExecutionManifest,
+    physics: &mut ProcessPhysicsV1,
+) -> RusticolResult<LoadedEagerV3Runtime> {
+    let pack = load_eager_v3_prepared_pack(artifact, manifest)?;
+    let container = open_verified_eager_v3_runtime_container(artifact, evaluator_root, manifest)?;
+    let decoded =
+        super::eager_v3_decode::decode_eager_v3_runtime(&container, manifest, &pack.manifest)?;
+    let color_selector_ids = native_color_selector_ids(
+        &decoded.color_selectors,
+        &decoded.u32_sequence_ranges,
+        &decoded.u32_sequence_values,
+        physics,
+    )?;
+    hydrate_native_reduction_groups(
+        physics,
+        &decoded.reduction_groups,
+        &decoded.reduction_entries,
+        &color_selector_ids,
+    )?;
+    let mut common =
+        super::eager_v3_common::build_eager_v3_common_runtime(&decoded, manifest, physics.clone())?;
+
+    let kernel_payloads = artifact.evaluator_payload_store(&pack.payload_root)?;
+    let (parameter_projection, couplings, model_parameter_evaluator) =
+        prepare_plan_v3_parameter_state(
+            &pack.manifest,
+            &decoded,
+            &common.model_parameters,
+            &kernel_payloads,
+        )?;
+    common.model_parameter_evaluator = model_parameter_evaluator;
+    common.refresh_derived_model_parameters()?;
+
+    let prepared_parameter_count = u32::try_from(parameter_projection.parameter_count)
+        .map_err(|_| RusticolError::artifact("prepared parameter count exceeds u32"))?;
+    let sections = EagerPlanV3Sections {
+        kernels: &decoded.kernel_specs,
+        prepared_parameter_count,
+        currents: &decoded.currents,
+        values: &decoded.values,
+        momenta: &decoded.momenta,
+        parameters: &decoded.parameters,
+        stages: &decoded.stages,
+        couplings: &couplings,
+        invocations: &decoded.invocations,
+        attachments: &decoded.attachments,
+        finalizations: &decoded.finalizations,
+        closures: &decoded.closures,
+        direct_coefficients: &decoded.direct_coefficients,
+        selector_domains: &decoded.selector_domains,
+        selector_memberships: &decoded.selector_memberships,
+        reduction_groups: &decoded.reduction_groups,
+        reduction_entries: &decoded.reduction_entries,
+        exact_factors: &decoded.exact_factors,
+        color_contraction_entry_start: decoded.color_contraction_entry_start,
+        color_contraction_entry_count: decoded.color_contraction_entry_count,
+    };
+    let runtime_options = EagerRuntimeOptions {
+        point_tile_size: decoded.runtime_options.point_tile_size,
+        workspace_bytes: decoded.runtime_options.workspace_bytes,
+    };
+    #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+    {
+        let _ = (sections, runtime_options, parameter_projection);
+        return Err(RusticolError::compatibility(
+            "this artifact requires eager-direct-arena-v1, which is unavailable without the \
+             f64-compiled/f64-symjit features; use a Direct-Arena-capable runtime",
+        ));
+    }
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    {
+        let direct = load_eager_v3_direct_scheduler(
+            &pack.manifest,
+            &kernel_payloads,
+            &decoded,
+            sections,
+            runtime_options,
+        )?;
+        let (raw_sum_groups, color_contraction) = reduction_runtime(&decoded, manifest)?;
+        let color_topology_replay =
+            super::eager_v3_common::build_eager_color_topology_replay_amplitude_runtime(
+                &decoded,
+                &raw_sum_groups,
+                usize::try_from(decoded.dimensions.amplitude_count)
+                    .map_err(|_| RusticolError::artifact("eager amplitude count exceeds usize"))?,
+            )?;
+        if common.color_topology_replay_enabled != color_topology_replay.is_some() {
+            return Err(RusticolError::integrity(
+                "eager color replay proof and amplitude gather disagree",
+            ));
+        }
+        if let Some(replay) = color_topology_replay.as_ref()
+            && replay.color_topology_replay_mappings().as_deref()
+                != Some(common.color_topology_replay_mappings.as_slice())
+        {
+            return Err(RusticolError::integrity(
+                "eager color replay proof mappings do not match amplitude gather mappings",
+            ));
+        }
+        if let Some(selector_group_ids) = direct.plan().selector_group_ids() {
+            let known_group_ids = raw_sum_groups
+                .iter()
+                .map(|group| {
+                    u32::try_from(group.id).map_err(|_| {
+                        RusticolError::integrity(format!(
+                            "eager coherent group {} does not fit the selector-domain ABI",
+                            group.id
+                        ))
+                    })
+                })
+                .collect::<RusticolResult<BTreeSet<_>>>()?;
+            if let Some(unknown) = selector_group_ids
+                .iter()
+                .find(|group_id| !known_group_ids.contains(group_id))
+            {
+                return Err(RusticolError::integrity(format!(
+                    "eager selector domains reference unknown coherent group {unknown}"
+                )));
+            }
+        }
+        let lane = EagerNativeRuntime::new_direct(
+            direct,
+            pack.manifest.backend,
+            parameter_projection,
+            raw_sum_groups,
+            color_contraction,
+            color_topology_replay,
+        );
+        Ok(LoadedEagerV3Runtime { common, lane })
+    }
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn load_eager_v3_direct_scheduler(
+    pack: &PreparedKernelPackManifest,
+    payloads: &EvaluatorPayloadStore,
+    decoded: &DecodedEagerRuntimeV3,
+    sections: EagerPlanV3Sections<'_>,
+    options: EagerRuntimeOptions,
+) -> RusticolResult<crate::eager_runtime::EagerDirectExecutionRuntime> {
+    match pack.backend.as_str() {
+        "jit" => {
+            #[cfg(not(feature = "f64-symjit"))]
+            return Err(RusticolError::compatibility(
+                "eager Direct-Arena JIT execution requires the f64-symjit feature",
+            ));
+        }
+        "cpp" | "asm" => {
+            #[cfg(not(feature = "f64-compiled"))]
+            return Err(RusticolError::compatibility(
+                "eager Direct-Arena C++/ASM execution requires the f64-compiled feature",
+            ));
+        }
+        other => {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported eager Direct-Arena prepared backend {other:?}"
+            )));
+        }
+    }
+
+    struct OwnedPrepared {
+        kernel_id: u32,
+        role: crate::EagerKernelRole,
+        inputs: Vec<crate::EagerKernelInput>,
+        output_component_count: u32,
+        application: OwnedPreparedApplication,
+        display_path: PathBuf,
+    }
+
+    enum OwnedPreparedApplication {
+        Symjit {
+            source: Vec<u8>,
+            descriptor: Vec<u8>,
+            expected_optimization_level: u32,
+            expected_compression: bool,
+        },
+        Native {
+            library: Arc<crate::artifact::PinnedNativeLibrary>,
+            function_name: String,
+            source_application_abi: String,
+            invocation_stride: u32,
+            attachment_stride: u32,
+            target_triple: String,
+            evaluator_state_sha256: String,
+            simd_lane_width: u32,
+        },
+    }
+
+    let mut owned = Vec::with_capacity(decoded.kernel_specs.len());
+    for kernel in &decoded.kernel_specs {
+        let manifest = pack
+            .kernels
+            .iter()
+            .find(|candidate| candidate.kernel_id == kernel.kernel_id)
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "eager Direct-Arena kernel {} has no prepared manifest",
+                    kernel.kernel_id
+                ))
+            })?;
+        let direct = manifest.eager_direct_table_manifest()?;
+        let (application, display_path) = match pack.backend.as_str() {
+            "jit" => {
+                if direct.source_application_abi
+                    != crate::eager_layout::EAGER_DIRECT_SOURCE_APPLICATION_ABI
+                {
+                    return Err(RusticolError::compatibility(format!(
+                        "eager Direct-Arena JIT kernel {} has a native source ABI",
+                        kernel.kernel_id
+                    )));
+                }
+                let plane_application = manifest
+                    .f64_evaluator_manifest
+                    .get("plane_application")
+                    .and_then(serde_json::Value::as_object)
+                    .ok_or_else(|| {
+                        RusticolError::compatibility(format!(
+                            "eager Direct-Arena kernel {} has no SymJIT plane application",
+                            kernel.kernel_id
+                        ))
+                    })?;
+                let application_path = plane_application
+                    .get("application_path")
+                    .and_then(serde_json::Value::as_str)
+                    .ok_or_else(|| {
+                        RusticolError::artifact(format!(
+                            "eager Direct-Arena kernel {} has no plane-application path",
+                            kernel.kernel_id
+                        ))
+                    })?;
+                let expected_optimization_level = plane_application
+                    .get("optimization_level")
+                    .and_then(serde_json::Value::as_u64)
+                    .and_then(|level| u32::try_from(level).ok())
+                    .ok_or_else(|| {
+                        RusticolError::compatibility(format!(
+                            "eager Direct-Arena kernel {} has no authenticated SymJIT \
+                             optimization level; regenerate the prepared model",
+                            kernel.kernel_id
+                        ))
+                    })?;
+                let expected_compression = plane_application
+                    .get("compression")
+                    .and_then(serde_json::Value::as_bool)
+                    .ok_or_else(|| {
+                        RusticolError::compatibility(format!(
+                            "eager Direct-Arena kernel {} has no authenticated SymJIT \
+                             compression setting; regenerate the prepared model",
+                            kernel.kernel_id
+                        ))
+                    })?;
+                if plane_application
+                    .get("application_abi")
+                    .and_then(serde_json::Value::as_str)
+                    != Some(crate::eager_layout::EAGER_DIRECT_SOURCE_APPLICATION_ABI)
+                {
+                    return Err(RusticolError::compatibility(format!(
+                        "eager Direct-Arena kernel {} has an incompatible plane-application ABI",
+                        kernel.kernel_id
+                    )));
+                }
+                let source = payloads.source(application_path)?;
+                let source_bytes = source.read()?.into_owned();
+                let display_path = PathBuf::from(source.display_name());
+                let descriptor_path = direct.descriptor_path.as_deref().ok_or_else(|| {
+                    RusticolError::artifact("eager JIT DirectTable has no descriptor path")
+                })?;
+                let descriptor_source = payloads.source(descriptor_path)?;
+                let descriptor = descriptor_source.read()?.into_owned();
+                if u64::try_from(descriptor.len()).ok() != direct.descriptor_size_bytes {
+                    return Err(RusticolError::integrity(format!(
+                        "eager DirectTable descriptor for kernel {} has size {}, expected {:?}",
+                        kernel.kernel_id,
+                        descriptor.len(),
+                        direct.descriptor_size_bytes,
+                    )));
+                }
+                let actual_descriptor_sha = format!("{:x}", Sha256::digest(&descriptor));
+                if Some(actual_descriptor_sha.as_str()) != direct.descriptor_sha256.as_deref() {
+                    return Err(RusticolError::integrity(format!(
+                        "eager DirectTable descriptor digest mismatch for kernel {}",
+                        kernel.kernel_id
+                    )));
+                }
+                (
+                    OwnedPreparedApplication::Symjit {
+                        source: source_bytes,
+                        descriptor,
+                        expected_optimization_level,
+                        expected_compression,
+                    },
+                    display_path,
+                )
+            }
+            "cpp" | "asm" => {
+                if direct.source_application_abi
+                    != crate::eager_layout::EAGER_NATIVE_DIRECT_TABLE_APPLICATION_ABI
+                {
+                    return Err(RusticolError::compatibility(format!(
+                        "eager Direct-Arena native kernel {} has a JIT source ABI",
+                        kernel.kernel_id
+                    )));
+                }
+                let library_path = direct.library_path.as_deref().ok_or_else(|| {
+                    RusticolError::artifact("eager native DirectTable has no library path")
+                })?;
+                let library = payloads.load_native_library(library_path)?;
+                let display_path = library.display_path().to_path_buf();
+                let function_name = direct.function_name.clone().ok_or_else(|| {
+                    RusticolError::artifact("eager native DirectTable has no function name")
+                })?;
+                let expected =
+                    format!("pyamplicol_eager_direct_table_k{:08x}_v1", kernel.kernel_id);
+                if function_name != expected {
+                    return Err(RusticolError::integrity(format!(
+                        "eager native DirectTable kernel {} exports {function_name:?}, expected {expected:?}",
+                        kernel.kernel_id
+                    )));
+                }
+                let expected_state_sha =
+                    direct.evaluator_state_sha256.as_deref().ok_or_else(|| {
+                        RusticolError::artifact(
+                            "eager native DirectTable has no evaluator-state digest",
+                        )
+                    })?;
+                let exact_state = payloads.source(&manifest.exact_evaluator_state_path)?;
+                let exact_state_bytes = exact_state.read()?;
+                let actual_state_sha = format!("{:x}", Sha256::digest(exact_state_bytes.as_ref()));
+                if actual_state_sha != expected_state_sha {
+                    return Err(RusticolError::integrity(format!(
+                        "eager native DirectTable evaluator-state digest mismatch for kernel {}",
+                        kernel.kernel_id
+                    )));
+                }
+                (
+                    OwnedPreparedApplication::Native {
+                        library,
+                        function_name,
+                        source_application_abi: direct.source_application_abi.clone(),
+                        invocation_stride: direct.invocation_stride.unwrap_or(0),
+                        attachment_stride: direct.attachment_stride.unwrap_or(0),
+                        target_triple: pack.target.target_triple.clone(),
+                        evaluator_state_sha256: direct
+                            .evaluator_state_sha256
+                            .clone()
+                            .unwrap_or_default(),
+                        simd_lane_width: direct.simd_lane_width.unwrap_or(0),
+                    },
+                    display_path,
+                )
+            }
+            _ => unreachable!("prepared backend validated"),
+        };
+        if direct.input_complex_count
+            != count_u32_for_direct(kernel.inputs.len(), "kernel input width")?
+            || direct.output_complex_count != kernel.output_component_count
+        {
+            return Err(RusticolError::integrity(format!(
+                "eager DirectTable descriptor binding width mismatch for kernel {}",
+                kernel.kernel_id
+            )));
+        }
+        owned.push(OwnedPrepared {
+            kernel_id: kernel.kernel_id,
+            role: kernel.role,
+            inputs: kernel.inputs.clone(),
+            output_component_count: kernel.output_component_count,
+            application,
+            display_path,
+        });
+    }
+    let prepared = owned
+        .iter()
+        .map(|kernel| {
+            let application = match &kernel.application {
+                OwnedPreparedApplication::Symjit {
+                    source,
+                    descriptor,
+                    expected_optimization_level,
+                    expected_compression,
+                } => crate::eager_runtime::EagerDirectPreparedApplication::Symjit {
+                    source_application: source,
+                    descriptor,
+                    expected_optimization_level: *expected_optimization_level,
+                    expected_compression: *expected_compression,
+                },
+                OwnedPreparedApplication::Native {
+                    library,
+                    function_name,
+                    source_application_abi,
+                    invocation_stride,
+                    attachment_stride,
+                    target_triple,
+                    evaluator_state_sha256,
+                    simd_lane_width,
+                } => crate::eager_runtime::EagerDirectPreparedApplication::Native {
+                    library,
+                    function_name,
+                    source_application_abi,
+                    invocation_stride: *invocation_stride,
+                    attachment_stride: *attachment_stride,
+                    target_triple,
+                    evaluator_state_sha256,
+                    simd_lane_width: *simd_lane_width,
+                },
+            };
+            crate::eager_runtime::EagerDirectPreparedKernel {
+                kernel_id: kernel.kernel_id,
+                role: kernel.role,
+                inputs: &kernel.inputs,
+                output_component_count: kernel.output_component_count,
+                application,
+                display_path: kernel.display_path.clone(),
+            }
+        })
+        .collect::<Vec<_>>();
+    crate::eager_runtime::EagerDirectExecutionRuntime::from_plan_v3_sections(
+        sections, &prepared, options,
+    )
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn count_u32_for_direct(value: usize, label: &str) -> RusticolResult<u32> {
+    u32::try_from(value)
+        .map_err(|_| RusticolError::invalid_argument(format!("eager direct {label} exceeds u32")))
+}
+
+pub(super) fn load_eager_v3_exact_sections(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &EagerV3ExecutionManifest,
+    physics: &mut ProcessPhysicsV1,
+) -> RusticolResult<NativeEagerExactSections> {
+    let pack = load_eager_v3_prepared_pack(artifact, manifest)?;
+    let container = open_verified_eager_v3_runtime_container(artifact, evaluator_root, manifest)?;
+    let decoded =
+        super::eager_v3_decode::decode_eager_v3_runtime(&container, manifest, &pack.manifest)?;
+    let color_selector_ids = native_color_selector_ids(
+        &decoded.color_selectors,
+        &decoded.u32_sequence_ranges,
+        &decoded.u32_sequence_values,
+        physics,
+    )?;
+    hydrate_native_reduction_groups(
+        physics,
+        &decoded.reduction_groups,
+        &decoded.reduction_entries,
+        &color_selector_ids,
+    )?;
+
+    let amplitude_stage = exact_amplitude_stage(&decoded, manifest)?;
+    let exact_schema = super::eager_v3_common::build_eager_v3_exact_schema(
+        &decoded,
+        manifest,
+        physics.clone(),
+        amplitude_stage,
+    )?;
+    let reduction_groups = serde_json::to_value(&physics.reduction.groups).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not serialize compact eager exact reduction groups: {error}"
+        ))
+    })?;
+    let selector_group_ids = decoded
+        .reduction_groups
+        .iter()
+        .map(|group| group.coherent_group_id)
+        .collect::<Vec<_>>();
+    let selector_domains = decoded
+        .selector_domains
+        .iter()
+        .map(|domain| {
+            Ok(table_range(
+                &decoded.selector_memberships,
+                domain.member_start,
+                domain.member_count,
+                "selector-domain members",
+            )?
+            .to_vec())
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let couplings = decoded
+        .couplings
+        .iter()
+        .map(|row| {
+            let [constant_real, constant_imaginary] =
+                exact_factor_pair(&decoded, row.constant_factor_id, "coupling")?;
+            Ok(NativeEagerExactCoupling {
+                real_parameter_id: row.real_parameter_id,
+                imaginary_parameter_id: row.imaginary_parameter_id,
+                constant_real,
+                constant_imaginary,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let stages = decoded
+        .stages
+        .iter()
+        .map(|row| NativeEagerExactStage {
+            stage_index: row.stage_index,
+            invocation_start: row.invocation_start,
+            invocation_count: row.invocation_count,
+            attachment_start: row.attachment_start,
+            attachment_count: row.attachment_count,
+            finalization_start: row.finalization_start,
+            finalization_count: row.finalization_count,
+        })
+        .collect();
+    let invocations = decoded
+        .invocations
+        .iter()
+        .map(|row| NativeEagerExactInvocation {
+            kernel_id: row.kernel_id,
+            left_value_slot_id: row.left_value_slot_id,
+            right_value_slot_id: row.right_value_slot_id,
+            left_momentum_slot_id: row.left_momentum_slot_id,
+            right_momentum_slot_id: row.right_momentum_slot_id,
+            coupling_slot_id: row.coupling_slot_id,
+            output_factor_source: row.output_factor_source,
+            attachment_start: row.attachment_start,
+            attachment_count: row.attachment_count,
+            selector_domain_id: row.selector_domain_id,
+        })
+        .collect();
+    let attachments = decoded
+        .attachments
+        .iter()
+        .map(|row| {
+            let representative = exact_factor(
+                &decoded,
+                row.representative_evaluation_factor_id,
+                "attachment representative",
+            )?;
+            if representative == Complex::new(0.0, 0.0) {
+                return Err(RusticolError::integrity(
+                    "eager exact attachment representative factor is zero",
+                ));
+            }
+            Ok(NativeEagerExactAttachment {
+                result_current_id: row.result_current_id,
+                factor_numerators: vec![
+                    exact_factor_pair(&decoded, row.color_factor_id, "attachment color")?,
+                    exact_factor_pair(&decoded, row.evaluation_factor_id, "attachment evaluation")?,
+                    exact_factor_pair(
+                        &decoded,
+                        row.normalization_factor_id,
+                        "attachment normalization",
+                    )?,
+                ],
+                factor_denominator: Some(exact_factor_pair(
+                    &decoded,
+                    row.representative_evaluation_factor_id,
+                    "attachment representative",
+                )?),
+                selector_domain_id: row.selector_domain_id,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let finalizations = decoded
+        .finalizations
+        .iter()
+        .map(|row| NativeEagerExactFinalization {
+            kernel_id: row.kernel_id,
+            current_id: row.current_id,
+            unpropagated_value_slot_id: row.unpropagated_value_slot_id,
+            propagated_value_slot_id: row.propagated_value_slot_id,
+            momentum_slot_id: row.momentum_slot_id,
+            unpropagated_selector_domain_id: row.unpropagated_selector_domain_id,
+            propagated_selector_domain_id: row.propagated_selector_domain_id,
+        })
+        .collect();
+    let closures = decoded
+        .closures
+        .iter()
+        .map(|row| exact_closure(&decoded, row))
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    Ok(NativeEagerExactSections {
+        process_id: manifest.key.clone(),
+        exact_schema,
+        reduction_groups,
+        selector_group_ids,
+        selector_domains,
+        couplings,
+        stages,
+        invocations,
+        attachments,
+        finalizations,
+        closures,
+    })
+}
+
+pub(super) fn load_eager_v3_reduction_groups(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &EagerV3ExecutionManifest,
+    physics: &mut ProcessPhysicsV1,
+) -> RusticolResult<Value> {
+    // Keep full artifact/container authentication, prepared-pack validation,
+    // and plan identity/count cross-checks, but materialize only the
+    // O(reduction) rows needed for public reduction groups. In particular,
+    // runtime-sized currents/stages/invocations/attachments/finalizations/
+    // closures remain borrowed PACBIN payloads and are never converted.
+    let pack = load_eager_v3_prepared_pack(artifact, manifest)?;
+    drop(pack);
+    let container = open_verified_eager_v3_runtime_container(artifact, evaluator_root, manifest)?;
+    let decoded = super::eager_v3_decode::decode_eager_v3_reduction_groups(&container, manifest)?;
+    validate_native_helicity_selectors(
+        &decoded.helicity_selectors,
+        &decoded.helicity_sequences,
+        physics,
+    )?;
+    let color_selector_ids = native_projected_color_selector_ids(
+        &decoded.color_selectors,
+        &decoded.color_sequences,
+        physics,
+    )?;
+    hydrate_native_reduction_groups(
+        physics,
+        &decoded.reduction_groups,
+        &decoded.reduction_entries,
+        &color_selector_ids,
+    )?;
+    serde_json::to_value(&physics.reduction.groups).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not serialize compact eager reduction groups: {error}"
+        ))
+    })
+}
+
+fn exact_amplitude_stage(
+    decoded: &DecodedEagerRuntimeV3,
+    manifest: &EagerV3ExecutionManifest,
+) -> RusticolResult<Value> {
+    let color_sector_by_group = coherent_group_color_sector_ids(decoded)?;
+    let group_weights = decoded
+        .reduction_groups
+        .iter()
+        .map(|group| {
+            exact_real_factor(decoded, group.helicity_weight_factor_id, "helicity weight")?;
+            exact_real_factor(
+                decoded,
+                group.all_sector_weight_factor_id,
+                "all-sector weight",
+            )?;
+            Ok((
+                group.coherent_group_id,
+                (
+                    group.helicity_weight_factor_id,
+                    group.all_sector_weight_factor_id,
+                ),
+            ))
+        })
+        .collect::<RusticolResult<BTreeMap<_, _>>>()?;
+    let roots = decoded
+        .closures
+        .iter()
+        .map(|root| {
+            let (helicity_weight_id, all_sector_weight_id) = group_weights
+                .get(&root.coherent_group_id)
+                .ok_or_else(|| {
+                RusticolError::integrity("eager exact closure references an unknown coherent group")
+            })?;
+            Ok(json!({
+                "output_index": root.amplitude_index,
+                "root_id": root.root_id,
+                "kind": if root.kernel_id == MISSING_U32 {
+                    "direct-contraction"
+                } else {
+                    "kernel-closure"
+                },
+                "coherent_group_id": root.coherent_group_id,
+                "color_sector_id": color_sector_by_group
+                    .get(&root.coherent_group_id)
+                    .copied()
+                    .ok_or_else(|| RusticolError::integrity(
+                        "eager exact closure references an unknown coherent-group color sector"
+                    ))?,
+                "helicity_weight": exact_real_factor_number(decoded, *helicity_weight_id, "helicity weight")?,
+                "all_sector_weight": exact_real_factor_number(decoded, *all_sector_weight_id, "all-sector weight")?,
+            }))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let materialized_color_contraction = if manifest.color_accuracy == "lc" {
+        Value::Null
+    } else {
+        let entries = reduction_range(
+            &decoded.reduction_entries,
+            decoded.color_contraction_entry_start,
+            decoded.color_contraction_entry_count,
+            "exact color contraction",
+        )?
+        .iter()
+        .map(|row| {
+            if row.kind != EagerPlanReductionEntryKind::ColorContraction {
+                return Err(RusticolError::integrity(
+                    "eager exact color-contraction range contains another entry kind",
+                ));
+            }
+            let weight = exact_factor_pair(decoded, row.factor_id, "color-contraction weight")?;
+            let symmetry = if row.auxiliary_factor_id == MISSING_U32 {
+                exact_number(1.0)
+            } else {
+                exact_real_factor_number(decoded, row.auxiliary_factor_id, "color symmetry factor")?
+            };
+            Ok(json!({
+                "left_group_id": row.left_id,
+                "right_group_id": row.right_id,
+                "weight": weight,
+                "exact_weight": super::eager_v3_common::eager_exact_color_weight(decoded, row.factor_id)?,
+                "symmetry_factor": symmetry,
+            }))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+        json!({"entries": entries})
+    };
+    let (color_topology_replay, color_contraction) =
+        if let Some((replay, contraction)) = exact_color_topology_replay(decoded)? {
+            (replay, contraction)
+        } else {
+            (Value::Null, materialized_color_contraction)
+        };
+    Ok(json!({
+        "stage_kind": "amplitude-roots",
+        "output_count": decoded.dimensions.amplitude_count,
+        "roots": roots,
+        "color_contraction": color_contraction,
+        "color_topology_replay": color_topology_replay,
+    }))
+}
+
+fn exact_color_topology_replay(
+    decoded: &DecodedEagerRuntimeV3,
+) -> RusticolResult<Option<(Value, Value)>> {
+    let Some((replay, contraction)) =
+        super::eager_v3_common::load_eager_color_topology_replay_manifests(decoded, true)?
+    else {
+        return Ok(None);
+    };
+    let physical_groups = replay
+        .physical_groups
+        .iter()
+        .map(|group| {
+            if !group.helicity_weight.is_finite() || group.helicity_weight <= 0.0 {
+                return Err(RusticolError::integrity(
+                    "eager exact color replay helicity weight is invalid",
+                ));
+            }
+            Ok(json!({
+                "group_id": group.group_id,
+                "helicities": group.helicities,
+                "color_sector_id": group.color_sector_id,
+                "color_word": group.color_word,
+                "helicity_weight": exact_number(group.helicity_weight),
+            }))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let mappings = replay
+        .mappings
+        .iter()
+        .map(|mapping| {
+            let routes = mapping
+                .group_routes
+                .iter()
+                .map(|route| {
+                    Ok(json!({
+                        "source_group_id": route.source_group_id,
+                        "target_group_id": route.target_group_id,
+                        "factor": exact_f64_pair(&route.factor, "color replay route")?,
+                    }))
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(json!({
+                "label_permutation": mapping.label_permutation,
+                "group_routes": routes,
+            }))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let entries = contraction
+        .entries
+        .iter()
+        .map(|entry| {
+            if !entry.symmetry_factor.is_finite() {
+                return Err(RusticolError::integrity(
+                    "eager exact color replay symmetry factor is invalid",
+                ));
+            }
+            Ok(json!({
+                "left_group_id": entry.left_group_id,
+                "right_group_id": entry.right_group_id,
+                "weight": exact_f64_pair(&entry.weight, "color replay contraction")?,
+                "exact_weight": entry._exact_weight,
+                "symmetry_factor": exact_number(entry.symmetry_factor),
+            }))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let repeated_block = contraction
+        .repeated_block
+        .as_ref()
+        .map(|block| {
+            let entries = block
+                .entries
+                .iter()
+                .map(|entry| {
+                    if !entry.symmetry_factor.is_finite() {
+                        return Err(RusticolError::integrity(
+                            "eager exact repeated color symmetry factor is invalid",
+                        ));
+                    }
+                    Ok(json!({
+                        "left_group_index": entry.left_group_index,
+                        "right_group_index": entry.right_group_index,
+                        "weight": exact_f64_pair(
+                            &entry.weight,
+                            "repeated color replay contraction",
+                        )?,
+                        "exact_weight": entry._exact_weight,
+                        "symmetry_factor": exact_number(entry.symmetry_factor),
+                    }))
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(json!({
+                "component_count": block.component_count,
+                "component_group_ids": block.component_group_ids,
+                "entries": entries,
+            }))
+        })
+        .transpose()?;
+    let replay = json!({
+        "contract_version": replay.contract_version,
+        "physical_group_count": replay.physical_group_count,
+        "physical_groups": physical_groups,
+        "mappings": mappings,
+    });
+    let contraction = json!({
+        "supported": contraction.supported,
+        "reason": contraction.reason,
+        "group_count": contraction.group_count,
+        "includes_color_factor": contraction.includes_color_factor,
+        "entries": entries,
+        "repeated_block": repeated_block,
+    });
+    Ok(Some((replay, contraction)))
+}
+
+fn exact_f64_pair(values: &[f64], context: &str) -> RusticolResult<[String; 2]> {
+    let [real, imaginary] = values else {
+        return Err(RusticolError::integrity(format!(
+            "eager exact {context} factor is not complex data"
+        )));
+    };
+    if !real.is_finite() || !imaginary.is_finite() {
+        return Err(RusticolError::integrity(format!(
+            "eager exact {context} factor is not finite"
+        )));
+    }
+    Ok([exact_number(*real), exact_number(*imaginary)])
+}
+
+fn coherent_group_color_sector_ids(
+    decoded: &DecodedEagerRuntimeV3,
+) -> RusticolResult<BTreeMap<u32, u32>> {
+    let table = decoded
+        .retained_tables
+        .iter()
+        .find(|table| table.name.as_ref() == "coherent_groups")
+        .ok_or_else(|| RusticolError::integrity("eager coherent-group table is absent"))?;
+    let column = table
+        .columns
+        .iter()
+        .find(|column| column.name.as_ref() == "color_sector_id")
+        .ok_or_else(|| {
+            RusticolError::integrity("eager coherent-group color-sector column is absent")
+        })?;
+    if column.elements_per_row != 1 {
+        return Err(RusticolError::integrity(
+            "eager coherent-group color-sector column is not scalar",
+        ));
+    }
+    let super::eager_v3_decode::DecodedEagerPrimitiveColumn::U32(color_sector_ids) = &column.values
+    else {
+        return Err(RusticolError::integrity(
+            "eager coherent-group color-sector column has the wrong primitive type",
+        ));
+    };
+    if color_sector_ids.len() != decoded.reduction_groups.len()
+        || color_sector_ids.len()
+            != usize::try_from(table.row_count).map_err(|_| {
+                RusticolError::artifact("eager coherent-group row count exceeds usize")
+            })?
+    {
+        return Err(RusticolError::integrity(
+            "eager coherent-group color-sector coverage is inconsistent",
+        ));
+    }
+    decoded
+        .reduction_groups
+        .iter()
+        .zip(color_sector_ids)
+        .map(|(group, sector_id)| Ok((group.coherent_group_id, *sector_id)))
+        .collect()
+}
+
+fn exact_closure(
+    decoded: &DecodedEagerRuntimeV3,
+    row: &crate::EagerPlanClosureRow,
+) -> RusticolResult<NativeEagerExactClosure> {
+    let color = exact_factor_pair(decoded, row.color_factor_id, "closure color")?;
+    let (factor_numerators, direct_coefficients) = if row.kernel_id == MISSING_U32 {
+        let coefficients = table_range(
+            &decoded.direct_coefficients,
+            row.direct_coefficient_start,
+            row.direct_coefficient_count,
+            "direct closure coefficients",
+        )?
+        .iter()
+        .enumerate()
+        .map(|(component, coefficient)| {
+            if coefficient.component_index as usize != component {
+                return Err(RusticolError::integrity(
+                    "eager exact direct coefficients are not component ordered",
+                ));
+            }
+            exact_factor_pair(decoded, coefficient.factor_id, "direct coefficient")
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+        (vec![color], Some(coefficients))
+    } else {
+        (
+            vec![
+                color,
+                exact_factor_pair(
+                    decoded,
+                    row.normalization_factor_id,
+                    "closure normalization",
+                )?,
+            ],
+            None,
+        )
+    };
+    Ok(NativeEagerExactClosure {
+        kernel_id: row.kernel_id,
+        left_value_slot_id: row.left_value_slot_id,
+        right_value_slot_id: row.right_value_slot_id,
+        amplitude_index: row.amplitude_index,
+        coupling_slot_id: row.coupling_slot_id,
+        output_factor_source: row.output_factor_source,
+        factor_numerators,
+        factor_denominator: None,
+        direct_coefficients,
+        coherent_group_id: row.coherent_group_id,
+        selector_domain_id: row.selector_domain_id,
+    })
+}
+
+fn exact_number(value: f64) -> String {
+    format!("binary64:{:016x}", value.to_bits())
+}
+
+fn exact_factor_pair(
+    decoded: &DecodedEagerRuntimeV3,
+    factor_id: u32,
+    context: &str,
+) -> RusticolResult<[String; 2]> {
+    let factor = decoded
+        .exact_factors
+        .get(factor_id as usize)
+        .ok_or_else(|| RusticolError::integrity(format!("eager {context} factor is absent")))?;
+    let value = exact_factor(decoded, factor_id, context)?;
+    if !value.re.is_finite() || !value.im.is_finite() {
+        return Err(RusticolError::integrity(format!(
+            "eager {context} factor is not finite"
+        )));
+    }
+    Ok([
+        format!("binary64:{:016x}", factor.real_bits),
+        format!("binary64:{:016x}", factor.imaginary_bits),
+    ])
+}
+
+fn exact_real_factor_number(
+    decoded: &DecodedEagerRuntimeV3,
+    factor_id: u32,
+    context: &str,
+) -> RusticolResult<String> {
+    exact_real_factor(decoded, factor_id, context)?;
+    Ok(exact_factor_pair(decoded, factor_id, context)?[0].clone())
+}
+
+pub(super) fn reject_native_reduction_groups_for_compiled(
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<()> {
+    if physics
+        .extensions
+        .contains_key(NATIVE_REDUCTION_GROUPS_EXTENSION_KEY)
+    {
+        return Err(RusticolError::compatibility(
+            "compact PACBIN-backed reduction groups require eager plan-v3 execution; regenerate this compiled artifact",
+        ));
+    }
+    Ok(())
+}
+
+fn hydrate_native_reduction_groups(
+    physics: &mut ProcessPhysicsV1,
+    groups: &[crate::EagerPlanReductionGroupRow],
+    entries: &[crate::EagerPlanReductionEntryRow],
+    color_selector_ids: &[String],
+) -> RusticolResult<()> {
+    let Some(value) = physics
+        .extensions
+        .get(NATIVE_REDUCTION_GROUPS_EXTENSION_KEY)
+    else {
+        return Ok(());
+    };
+    if !physics.reduction.groups.is_empty() {
+        return Err(RusticolError::integrity(
+            "compact native reduction metadata may not duplicate expanded reduction groups",
+        ));
+    }
+    let descriptor: NativeReductionGroupsDescriptor = serde_json::from_value(value.clone())
+        .map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not parse compact native reduction descriptor: {error}"
+            ))
+        })?;
+    descriptor.validate()?;
+    let declared_group_count = usize::try_from(descriptor.group_count).map_err(|_| {
+        RusticolError::artifact("compact native reduction group count exceeds usize")
+    })?;
+    if declared_group_count != groups.len() {
+        return Err(RusticolError::integrity(format!(
+            "compact native reduction descriptor declares {declared_group_count} groups, PACBIN contains {}",
+            groups.len()
+        )));
+    }
+
+    let mut hydrated = Vec::with_capacity(groups.len());
+    let mut seen_group_ids = BTreeSet::new();
+    for group in groups {
+        if !seen_group_ids.insert(group.coherent_group_id) {
+            return Err(RusticolError::integrity(format!(
+                "compact native reduction metadata contains duplicate coherent group {}",
+                group.coherent_group_id
+            )));
+        }
+        let selectors = reduction_range(
+            entries,
+            group.selector_entry_start,
+            group.selector_entry_count,
+            "selector members",
+        )?;
+        let representative = selectors.first().ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "compact native reduction group {} has no selector members",
+                group.coherent_group_id
+            ))
+        })?;
+
+        let mut physical_helicity_ids = Vec::new();
+        let mut physical_color_ids = Vec::new();
+        let mut seen_helicities = BTreeSet::new();
+        let mut seen_colors = BTreeSet::new();
+        for selector in selectors {
+            if selector.kind != EagerPlanReductionEntryKind::SelectorMember
+                || selector.owner_id != group.coherent_group_id
+            {
+                return Err(RusticolError::integrity(format!(
+                    "compact native reduction group {} contains an invalid selector member",
+                    group.coherent_group_id
+                )));
+            }
+            let helicity_index = usize::try_from(selector.left_id).map_err(|_| {
+                RusticolError::artifact("compact native helicity selector ID exceeds usize")
+            })?;
+            let color_index = usize::try_from(selector.right_id).map_err(|_| {
+                RusticolError::artifact("compact native color selector ID exceeds usize")
+            })?;
+            let helicity = physics.helicities.get(helicity_index).ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "compact native reduction group {} references unknown helicity selector {}",
+                    group.coherent_group_id, selector.left_id
+                ))
+            })?;
+            let color_id = color_selector_ids.get(color_index).ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "compact native reduction group {} references unknown color selector {}",
+                    group.coherent_group_id, selector.right_id
+                ))
+            })?;
+            if seen_helicities.insert(selector.left_id) {
+                physical_helicity_ids.push(helicity.id.clone());
+            }
+            if seen_colors.insert(selector.right_id) {
+                physical_color_ids.push(color_id.clone());
+            }
+        }
+
+        let representative_helicity_id = physics
+            .helicities
+            .get(representative.left_id as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity("compact native representative helicity is absent")
+            })?
+            .id
+            .clone();
+        let representative_color_id = color_selector_ids
+            .get(representative.right_id as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity("compact native representative color is absent")
+            })?
+            .clone();
+        hydrated.push(crate::ReductionGroup {
+            id: format!("reduction:{}", group.coherent_group_id),
+            representative_helicity_id,
+            representative_color_id,
+            physical_helicity_ids,
+            physical_color_ids,
+        });
+    }
+    physics.reduction.groups = hydrated;
+    physics.validate()?;
+    Ok(())
+}
+
+fn native_color_selector_ids(
+    color_selectors: &[crate::EagerPlanColorSelectorRow],
+    u32_sequence_ranges: &[crate::EagerPlanCatalogRangeRow],
+    u32_sequence_values: &[u32],
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<Vec<String>> {
+    let catalog = native_color_selector_catalog(physics)?;
+    color_selectors
+        .iter()
+        .map(|selector| {
+            let word = eager_u32_sequence(
+                u32_sequence_ranges,
+                u32_sequence_values,
+                selector.word_sequence_id,
+                "color selector word",
+            )?;
+            let representative_word = eager_u32_sequence(
+                u32_sequence_ranges,
+                u32_sequence_values,
+                selector.representative_word_sequence_id,
+                "color selector representative word",
+            )?;
+            resolve_native_color_selector_id(
+                &catalog,
+                word,
+                representative_word,
+                selector.computed != 0,
+            )
+        })
+        .collect()
+}
+
+fn validate_native_helicity_selectors(
+    helicity_selectors: &[crate::EagerPlanHelicitySelectorRow],
+    helicity_sequences: &BTreeMap<u32, Vec<i32>>,
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<()> {
+    if helicity_selectors.len() != physics.helicities.len() {
+        return Err(RusticolError::integrity(format!(
+            "compact native plan contains {} helicity selectors, public physics contains {}",
+            helicity_selectors.len(),
+            physics.helicities.len()
+        )));
+    }
+    let helicity_by_id = physics
+        .helicities
+        .iter()
+        .map(|helicity| (helicity.id.as_str(), helicity))
+        .collect::<BTreeMap<_, _>>();
+
+    for (index, selector) in helicity_selectors.iter().enumerate() {
+        let expected_id = u32::try_from(index).map_err(|_| {
+            RusticolError::artifact("compact native helicity selector count exceeds u32")
+        })?;
+        if selector.selector_id != expected_id {
+            return Err(RusticolError::integrity(
+                "compact native helicity selector IDs are not dense",
+            ));
+        }
+        let helicity = &physics.helicities[index];
+        let values = projected_sequence(
+            helicity_sequences,
+            selector.values_sequence_id,
+            "helicity selector values",
+        )?;
+        if values != helicity.values.as_slice() {
+            return Err(RusticolError::integrity(format!(
+                "compact native helicity selector {} values disagree with public helicity {:?}",
+                selector.selector_id, helicity.id
+            )));
+        }
+        let representative = helicity_by_id
+            .get(helicity.representative_id.as_str())
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "public helicity {:?} references unknown representative {:?}",
+                    helicity.id, helicity.representative_id
+                ))
+            })?;
+        let representative_values = projected_sequence(
+            helicity_sequences,
+            selector.representative_sequence_id,
+            "helicity selector representative",
+        )?;
+        if representative_values != representative.values.as_slice() {
+            return Err(RusticolError::integrity(format!(
+                "compact native helicity selector {} representative disagrees with public representative {:?}",
+                selector.selector_id, representative.id
+            )));
+        }
+        if (selector.computed != 0) != helicity.computed
+            || (selector.structural_zero != 0) != helicity.structural_zero
+        {
+            return Err(RusticolError::integrity(format!(
+                "compact native helicity selector {} flags disagree with public helicity {:?}",
+                selector.selector_id, helicity.id
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn native_projected_color_selector_ids(
+    color_selectors: &[crate::EagerPlanColorSelectorRow],
+    color_sequences: &BTreeMap<u32, Vec<u32>>,
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<Vec<String>> {
+    let catalog = native_color_selector_catalog(physics)?;
+    color_selectors
+        .iter()
+        .map(|selector| {
+            let word = projected_sequence(
+                color_sequences,
+                selector.word_sequence_id,
+                "color selector word",
+            )?;
+            let representative_word = projected_sequence(
+                color_sequences,
+                selector.representative_word_sequence_id,
+                "color selector representative word",
+            )?;
+            resolve_native_color_selector_id(
+                &catalog,
+                word,
+                representative_word,
+                selector.computed != 0,
+            )
+        })
+        .collect()
+}
+
+fn projected_sequence<'a, T>(
+    sequences: &'a BTreeMap<u32, Vec<T>>,
+    sequence_id: u32,
+    context: &str,
+) -> RusticolResult<&'a [T]> {
+    sequences
+        .get(&sequence_id)
+        .map(Vec::as_slice)
+        .ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "compact native {context} references unknown projected sequence {sequence_id}"
+            ))
+        })
+}
+
+fn eager_u32_sequence<'a>(
+    ranges: &'a [crate::EagerPlanCatalogRangeRow],
+    values: &'a [u32],
+    sequence_id: u32,
+    context: &str,
+) -> RusticolResult<&'a [u32]> {
+    let range = ranges.get(sequence_id as usize).ok_or_else(|| {
+        RusticolError::integrity(format!(
+            "compact native {context} references unknown sequence {sequence_id}"
+        ))
+    })?;
+    let start = usize::try_from(range.start).map_err(|_| {
+        RusticolError::artifact(format!("compact native {context} start exceeds usize"))
+    })?;
+    let count = usize::try_from(range.count).map_err(|_| {
+        RusticolError::artifact(format!("compact native {context} count exceeds usize"))
+    })?;
+    let stop = start.checked_add(count).ok_or_else(|| {
+        RusticolError::artifact(format!("compact native {context} range overflows"))
+    })?;
+    values.get(start..stop).ok_or_else(|| {
+        RusticolError::integrity(format!("compact native {context} range is out of bounds"))
+    })
+}
+
+type NativeColorSelectorCatalog = BTreeMap<Vec<u32>, (String, Vec<u32>, bool)>;
+
+fn native_color_selector_catalog(
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<NativeColorSelectorCatalog> {
+    let by_id = physics
+        .color_components
+        .iter()
+        .map(|component| (component.id(), component))
+        .collect::<BTreeMap<_, _>>();
+    let mut result = BTreeMap::new();
+    for component in &physics.color_components {
+        let (word, representative_word, computed) = match component {
+            crate::ColorComponent::LcFlow(flow) => {
+                let representative =
+                    by_id.get(flow.representative_id.as_str()).ok_or_else(|| {
+                        RusticolError::integrity(format!(
+                            "compact native color selector {:?} has no representative",
+                            flow.id
+                        ))
+                    })?;
+                let crate::ColorComponent::LcFlow(representative) = representative else {
+                    return Err(RusticolError::integrity(format!(
+                        "compact native LC color selector {:?} has a contracted representative",
+                        flow.id
+                    )));
+                };
+                (
+                    u32_color_word(&flow.word, &flow.id)?,
+                    u32_color_word(&representative.word, &representative.id)?,
+                    flow.computed,
+                )
+            }
+            crate::ColorComponent::ContractedColor(_) => (Vec::new(), Vec::new(), true),
+        };
+        if result
+            .insert(
+                word.clone(),
+                (component.id().to_string(), representative_word, computed),
+            )
+            .is_some()
+        {
+            return Err(RusticolError::integrity(format!(
+                "public physics contains duplicate color word {word:?}"
+            )));
+        }
+    }
+    Ok(result)
+}
+
+fn u32_color_word(word: &[usize], color_id: &str) -> RusticolResult<Vec<u32>> {
+    word.iter()
+        .copied()
+        .map(|label| {
+            u32::try_from(label).map_err(|_| {
+                RusticolError::artifact(format!(
+                    "public color component {color_id:?} contains a label exceeding u32"
+                ))
+            })
+        })
+        .collect()
+}
+
+fn resolve_native_color_selector_id(
+    catalog: &NativeColorSelectorCatalog,
+    word: &[u32],
+    representative_word: &[u32],
+    computed: bool,
+) -> RusticolResult<String> {
+    let (id, expected_representative, expected_computed) = catalog.get(word).ok_or_else(|| {
+        RusticolError::integrity(format!(
+            "compact native color selector word {word:?} is absent from public physics"
+        ))
+    })?;
+    if *expected_computed != computed || expected_representative != representative_word {
+        return Err(RusticolError::integrity(format!(
+            "compact native color selector {id:?} is inconsistent with public physics"
+        )));
+    }
+    Ok(id.clone())
+}
+
+impl NativeReductionGroupsDescriptor {
+    fn validate(&self) -> RusticolResult<()> {
+        let valid = self.kind == NATIVE_REDUCTION_GROUPS_KIND
+            && self.schema_version == NATIVE_REDUCTION_GROUPS_SCHEMA_VERSION
+            && self.storage_abi == NATIVE_REDUCTION_GROUPS_STORAGE_ABI
+            && self.runtime_layout_abi == NATIVE_REDUCTION_GROUPS_RUNTIME_LAYOUT_ABI
+            && self.container_path == NATIVE_REDUCTION_GROUPS_CONTAINER_PATH
+            && self.group_member == NATIVE_REDUCTION_GROUPS_GROUP_MEMBER
+            && self.entry_member == NATIVE_REDUCTION_GROUPS_ENTRY_MEMBER;
+        if !valid {
+            return Err(RusticolError::compatibility(
+                "unsupported compact native reduction descriptor; regenerate the eager artifact",
+            ));
+        }
+        Ok(())
+    }
+}
+
+pub(super) fn open_verified_eager_v3_runtime_container(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &EagerV3ExecutionManifest,
+) -> RusticolResult<crate::pacbin::PacbinReader> {
+    let container = &manifest.plan.runtime_container;
+    let path = evaluator_root.join(&container.path);
+    let relative = path.strip_prefix(artifact.root()).map_err(|_| {
+        RusticolError::security("eager runtime container escapes the verified artifact root")
+    })?;
+    let mut parts = Vec::new();
+    for component in relative.components() {
+        let std::path::Component::Normal(part) = component else {
+            return Err(RusticolError::security(
+                "eager runtime container path is not canonical",
+            ));
+        };
+        parts.push(part.to_str().ok_or_else(|| {
+            RusticolError::security("eager runtime container path is not valid UTF-8")
+        })?);
+    }
+    let logical_path = parts.join("/");
+    let payload = artifact.payload(&logical_path)?;
+    if payload.role != crate::PayloadRole::EvaluatorState
+        || payload.media_type != "application/octet-stream"
+        || payload.process_id.as_deref() != Some(manifest.key.as_str())
+        || payload.executable
+    {
+        return Err(RusticolError::integrity(
+            "eager runtime container has an invalid outer payload declaration",
+        ));
+    }
+    if payload.size_bytes != container.size_bytes || payload.sha256 != container.sha256 {
+        return Err(RusticolError::integrity(
+            "eager runtime container metadata disagrees with its authenticated outer payload",
+        ));
+    }
+    let container_file = artifact.open_payload_file(&logical_path)?;
+    super::eager_v3_manifest::open_eager_v3_runtime_container(container_file, &path, manifest)
+}
+
+pub(super) fn prepare_plan_v3_parameter_state(
+    pack: &PreparedKernelPackManifest,
+    decoded: &DecodedEagerRuntimeV3,
+    runtime_parameters: &[GenericRuntimeModelParameterManifest],
+    payloads: &EvaluatorPayloadStore,
+) -> RusticolResult<(
+    EagerParameterProjection,
+    Vec<EagerPlanCouplingRow>,
+    Option<ModelParameterEvaluatorRuntime>,
+)> {
+    let legacy_rows = decoded
+        .couplings
+        .iter()
+        .map(|row| {
+            let constant = exact_factor(decoded, row.constant_factor_id, "coupling constant")?;
+            Ok(EagerCouplingRow {
+                real_parameter_id: row.real_parameter_id,
+                imag_parameter_id: row.imaginary_parameter_id,
+                constant_real: constant.re,
+                constant_imag: constant.im,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let encoded = EagerCouplingRow::encode_table(&legacy_rows)?;
+    let active_kernel_ids = decoded
+        .kernel_specs
+        .iter()
+        .map(|kernel| kernel.kernel_id)
+        .collect::<BTreeSet<_>>();
+    let (projection, remapped, evaluator) = super::eager_load::prepare_eager_parameter_state(
+        pack,
+        &active_kernel_ids,
+        runtime_parameters,
+        &encoded,
+        payloads,
+    )?;
+    let remapped = EagerCouplingRow::decode_table(&remapped)?;
+    if remapped.len() != decoded.couplings.len() {
+        return Err(RusticolError::integrity(
+            "projected eager coupling count changed",
+        ));
+    }
+    let couplings = decoded
+        .couplings
+        .iter()
+        .zip(remapped)
+        .map(|(source, projected)| EagerPlanCouplingRow {
+            coupling_id: source.coupling_id,
+            real_parameter_id: projected.real_parameter_id,
+            imaginary_parameter_id: projected.imag_parameter_id,
+            constant_factor_id: source.constant_factor_id,
+        })
+        .collect();
+    Ok((projection, couplings, evaluator))
+}
+
+fn reduction_runtime(
+    decoded: &DecodedEagerRuntimeV3,
+    manifest: &EagerV3ExecutionManifest,
+) -> RusticolResult<(Vec<RawSumGroup>, Option<ColorContractionRuntime>)> {
+    let color_sector_by_group = (manifest.color_accuracy == "lc")
+        .then(|| coherent_group_color_sector_ids(decoded))
+        .transpose()?;
+    let mut groups = Vec::with_capacity(decoded.reduction_groups.len());
+    for group in &decoded.reduction_groups {
+        let amplitudes = reduction_range(
+            &decoded.reduction_entries,
+            group.amplitude_entry_start,
+            group.amplitude_entry_count,
+            "amplitude members",
+        )?;
+        let selectors = reduction_range(
+            &decoded.reduction_entries,
+            group.selector_entry_start,
+            group.selector_entry_count,
+            "selector members",
+        )?;
+        if amplitudes
+            .iter()
+            .any(|entry| entry.kind != EagerPlanReductionEntryKind::AmplitudeMember)
+            || selectors
+                .iter()
+                .any(|entry| entry.kind != EagerPlanReductionEntryKind::SelectorMember)
+        {
+            return Err(RusticolError::integrity(
+                "eager reduction group range has inconsistent entry kinds",
+            ));
+        }
+        let weight =
+            exact_real_factor(decoded, group.helicity_weight_factor_id, "helicity weight")?;
+        let all_sector_weight = exact_real_factor(
+            decoded,
+            group.all_sector_weight_factor_id,
+            "all-sector weight",
+        )?;
+        // Selector IDs index the sorted public color axis. Replay uses the
+        // original color-plan sector identity retained by each coherent group.
+        let sector_ids = eager_raw_sum_sector_ids(
+            manifest.color_accuracy.as_str(),
+            group.coherent_group_id,
+            color_sector_by_group.as_ref(),
+        )?;
+        groups.push(RawSumGroup {
+            id: i64::from(group.coherent_group_id),
+            indices: amplitudes
+                .iter()
+                .map(|entry| entry.left_id as usize)
+                .collect(),
+            weight,
+            all_sector_weight,
+            sector_ids,
+        });
+    }
+    if manifest.color_accuracy == "lc" {
+        return Ok((groups, None));
+    }
+    let group_index_by_id = groups
+        .iter()
+        .enumerate()
+        .map(|(index, group)| (group.id, index))
+        .collect::<BTreeMap<_, _>>();
+    let contraction_rows = reduction_range(
+        &decoded.reduction_entries,
+        decoded.color_contraction_entry_start,
+        decoded.color_contraction_entry_count,
+        "color contraction",
+    )?;
+    let mut entries = Vec::with_capacity(contraction_rows.len());
+    for row in contraction_rows {
+        if row.kind != EagerPlanReductionEntryKind::ColorContraction {
+            return Err(RusticolError::integrity(
+                "eager color-contraction range contains another entry kind",
+            ));
+        }
+        let left_id = i64::from(row.left_id);
+        let right_id = i64::from(row.right_id);
+        let coefficient = exact_factor(decoded, row.factor_id, "color-contraction weight")?;
+        let symmetry_factor = if row.auxiliary_factor_id == MISSING_U32 {
+            1.0
+        } else {
+            exact_real_factor(decoded, row.auxiliary_factor_id, "color symmetry factor")?
+        };
+        entries.push(ColorContractionEntry {
+            left_group_index: *group_index_by_id.get(&left_id).ok_or_else(|| {
+                RusticolError::integrity("color contraction references an unknown left group")
+            })?,
+            right_group_index: *group_index_by_id.get(&right_id).ok_or_else(|| {
+                RusticolError::integrity("color contraction references an unknown right group")
+            })?,
+            weight_re: coefficient.re,
+            weight_im: coefficient.im,
+            symmetry_factor,
+        });
+    }
+    let contraction = ColorContractionRuntime::new(&groups, entries);
+    Ok((groups, Some(contraction)))
+}
+
+fn eager_raw_sum_sector_ids(
+    color_accuracy: &str,
+    coherent_group_id: u32,
+    color_sector_by_group: Option<&BTreeMap<u32, u32>>,
+) -> RusticolResult<Vec<i64>> {
+    if color_accuracy != "lc" {
+        return Ok(Vec::new());
+    }
+    let sector_id = color_sector_by_group
+        .and_then(|sectors| sectors.get(&coherent_group_id))
+        .copied()
+        .ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "eager LC coherent group {coherent_group_id} has no color-sector identity"
+            ))
+        })?;
+    Ok(vec![i64::from(sector_id)])
+}
+
+fn exact_factor(
+    decoded: &DecodedEagerRuntimeV3,
+    factor_id: u32,
+    context: &str,
+) -> RusticolResult<Complex<f64>> {
+    let factor = decoded
+        .exact_factors
+        .get(factor_id as usize)
+        .ok_or_else(|| RusticolError::integrity(format!("eager {context} factor is absent")))?;
+    let value = Complex::new(
+        f64::from_bits(factor.real_bits),
+        f64::from_bits(factor.imaginary_bits),
+    );
+    if !value.re.is_finite() || !value.im.is_finite() {
+        return Err(RusticolError::integrity(format!(
+            "eager {context} factor is not finite"
+        )));
+    }
+    Ok(value)
+}
+
+fn exact_real_factor(
+    decoded: &DecodedEagerRuntimeV3,
+    factor_id: u32,
+    context: &str,
+) -> RusticolResult<f64> {
+    let value = exact_factor(decoded, factor_id, context)?;
+    if value.im != 0.0 {
+        return Err(RusticolError::integrity(format!(
+            "eager {context} factor is not real"
+        )));
+    }
+    Ok(value.re)
+}
+
+fn reduction_range<'a>(
+    entries: &'a [crate::EagerPlanReductionEntryRow],
+    start: u64,
+    count: u64,
+    context: &str,
+) -> RusticolResult<&'a [crate::EagerPlanReductionEntryRow]> {
+    table_range(entries, start, count, context)
+}
+
+fn table_range<'a, T>(
+    entries: &'a [T],
+    start: u64,
+    count: u64,
+    context: &str,
+) -> RusticolResult<&'a [T]> {
+    let start = usize::try_from(start)
+        .map_err(|_| RusticolError::artifact(format!("eager {context} start exceeds usize")))?;
+    let count = usize::try_from(count)
+        .map_err(|_| RusticolError::artifact(format!("eager {context} count exceeds usize")))?;
+    let stop = start
+        .checked_add(count)
+        .ok_or_else(|| RusticolError::artifact(format!("eager {context} range overflows")))?;
+    entries
+        .get(start..stop)
+        .ok_or_else(|| RusticolError::integrity(format!("eager {context} range is out of bounds")))
+}
+
+#[cfg(test)]
+mod compact_reduction_tests {
+    use super::*;
+    use crate::{
+        ColorAccuracy, ColorComponent, ContractedColor, Coverage, ExternalParticle, Helicity,
+        LcColorFlow, ParticleRole, Reduction, ReductionKind, SelectorCapabilities,
+    };
+    use serde_json::json;
+
+    fn compact_physics() -> ProcessPhysicsV1 {
+        ProcessPhysicsV1 {
+            schema_version: crate::RUNTIME_PHYSICS_SCHEMA_VERSION,
+            kind: "pyamplicol-resolved-physics".to_string(),
+            process_id: "p0".to_string(),
+            process: "a b > c".to_string(),
+            color_accuracy: ColorAccuracy::Full,
+            coverage: Coverage {
+                helicities: "complete".to_string(),
+                color: "contracted".to_string(),
+                color_kind: "contracted-color".to_string(),
+                structural_zero_helicity_count: 0,
+            },
+            external_particles: (0..3)
+                .map(|index| ExternalParticle {
+                    index,
+                    label: index + 1,
+                    particle: format!("particle-{index}"),
+                    pdg: index as i32 + 1,
+                    role: if index < 2 {
+                        ParticleRole::Initial
+                    } else {
+                        ParticleRole::Final
+                    },
+                    momentum_slot: index,
+                    momentum_components: [
+                        "E".to_string(),
+                        "px".to_string(),
+                        "py".to_string(),
+                        "pz".to_string(),
+                    ],
+                })
+                .collect(),
+            helicities: vec![
+                Helicity {
+                    id: "helicity:0".to_string(),
+                    index: 0,
+                    values: vec![1, -1, 1],
+                    computed: true,
+                    structural_zero: false,
+                    representative_id: "helicity:0".to_string(),
+                    coefficient: 1.0,
+                },
+                Helicity {
+                    id: "helicity:1".to_string(),
+                    index: 1,
+                    values: vec![-1, 1, -1],
+                    computed: true,
+                    structural_zero: false,
+                    representative_id: "helicity:1".to_string(),
+                    coefficient: 1.0,
+                },
+            ],
+            color_components: vec![ColorComponent::ContractedColor(ContractedColor {
+                id: "contracted".to_string(),
+                index: 0,
+                description: "coherent contracted color".to_string(),
+            })],
+            reduction: Reduction {
+                kind: ReductionKind::ContractedColor,
+                groups: Vec::new(),
+            },
+            model_parameters: Vec::new(),
+            selectors: SelectorCapabilities {
+                helicity: true,
+                color_flow: false,
+                contracted_color: false,
+            },
+            extensions: BTreeMap::from([(
+                NATIVE_REDUCTION_GROUPS_EXTENSION_KEY.to_string(),
+                json!({
+                    "kind": NATIVE_REDUCTION_GROUPS_KIND,
+                    "schema_version": NATIVE_REDUCTION_GROUPS_SCHEMA_VERSION,
+                    "storage_abi": NATIVE_REDUCTION_GROUPS_STORAGE_ABI,
+                    "runtime_layout_abi": NATIVE_REDUCTION_GROUPS_RUNTIME_LAYOUT_ABI,
+                    "container_path": NATIVE_REDUCTION_GROUPS_CONTAINER_PATH,
+                    "group_member": NATIVE_REDUCTION_GROUPS_GROUP_MEMBER,
+                    "entry_member": NATIVE_REDUCTION_GROUPS_ENTRY_MEMBER,
+                    "group_count": 1,
+                }),
+            )]),
+        }
+    }
+
+    fn group() -> crate::EagerPlanReductionGroupRow {
+        crate::EagerPlanReductionGroupRow {
+            coherent_group_id: 7,
+            amplitude_entry_start: 0,
+            amplitude_entry_count: 0,
+            selector_entry_start: 0,
+            selector_entry_count: 3,
+            helicity_weight_factor_id: 0,
+            all_sector_weight_factor_id: 0,
+        }
+    }
+
+    fn helicity_selectors() -> Vec<crate::EagerPlanHelicitySelectorRow> {
+        vec![
+            crate::EagerPlanHelicitySelectorRow {
+                selector_id: 0,
+                values_sequence_id: 0,
+                representative_sequence_id: 0,
+                coefficient_factor_id: 0,
+                computed: 1,
+                structural_zero: 0,
+            },
+            crate::EagerPlanHelicitySelectorRow {
+                selector_id: 1,
+                values_sequence_id: 1,
+                representative_sequence_id: 1,
+                coefficient_factor_id: 0,
+                computed: 1,
+                structural_zero: 0,
+            },
+        ]
+    }
+
+    fn helicity_sequences() -> BTreeMap<u32, Vec<i32>> {
+        BTreeMap::from([(0, vec![1, -1, 1]), (1, vec![-1, 1, -1])])
+    }
+
+    fn selector(
+        owner_id: u32,
+        helicity_id: u32,
+        color_id: u32,
+    ) -> crate::EagerPlanReductionEntryRow {
+        crate::EagerPlanReductionEntryRow {
+            kind: EagerPlanReductionEntryKind::SelectorMember,
+            owner_id,
+            left_id: helicity_id,
+            right_id: color_id,
+            factor_id: MISSING_U32,
+            auxiliary_factor_id: MISSING_U32,
+        }
+    }
+
+    #[test]
+    fn authenticates_compact_helicity_selectors_against_public_metadata() {
+        validate_native_helicity_selectors(
+            &helicity_selectors(),
+            &helicity_sequences(),
+            &compact_physics(),
+        )
+        .expect("matching compact/public helicities");
+    }
+
+    #[test]
+    fn corrupted_compact_helicity_values_fail_public_metadata_differential() {
+        let mut sequences = helicity_sequences();
+        sequences.insert(1, vec![1, 1, 1]);
+
+        let error = validate_native_helicity_selectors(
+            &helicity_selectors(),
+            &sequences,
+            &compact_physics(),
+        )
+        .unwrap_err();
+
+        assert!(error.to_string().contains("values disagree"));
+    }
+
+    #[test]
+    fn corrupted_compact_helicity_representative_fails_public_metadata_differential() {
+        let mut physics = compact_physics();
+        physics.helicities[1].computed = false;
+        physics.helicities[1].representative_id = "helicity:0".to_string();
+        let mut selectors = helicity_selectors();
+        selectors[1].computed = 0;
+        selectors[1].representative_sequence_id = 0;
+        validate_native_helicity_selectors(&selectors, &helicity_sequences(), &physics)
+            .expect("matching alias representative");
+
+        selectors[1].representative_sequence_id = 1;
+        let error = validate_native_helicity_selectors(&selectors, &helicity_sequences(), &physics)
+            .unwrap_err();
+
+        assert!(error.to_string().contains("representative disagrees"));
+    }
+
+    #[test]
+    fn corrupted_compact_helicity_id_and_flags_fail_public_metadata_differential() {
+        let mut selectors = helicity_selectors();
+        selectors[1].selector_id = 7;
+        let id_error = validate_native_helicity_selectors(
+            &selectors,
+            &helicity_sequences(),
+            &compact_physics(),
+        )
+        .unwrap_err();
+        assert!(id_error.to_string().contains("IDs are not dense"));
+
+        let mut selectors = helicity_selectors();
+        selectors[1].structural_zero = 1;
+        let flag_error = validate_native_helicity_selectors(
+            &selectors,
+            &helicity_sequences(),
+            &compact_physics(),
+        )
+        .unwrap_err();
+        assert!(flag_error.to_string().contains("flags disagree"));
+    }
+
+    #[test]
+    fn hydrates_groups_from_selector_rows_in_first_seen_order() {
+        let mut physics = compact_physics();
+        let entries = [selector(7, 0, 0), selector(7, 1, 0), selector(7, 0, 0)];
+
+        hydrate_native_reduction_groups(
+            &mut physics,
+            &[group()],
+            &entries,
+            &["contracted".to_string()],
+        )
+        .unwrap();
+
+        let hydrated = &physics.reduction.groups[0];
+        assert_eq!(hydrated.id, "reduction:7");
+        assert_eq!(hydrated.representative_helicity_id, "helicity:0");
+        assert_eq!(hydrated.representative_color_id, "contracted");
+        assert_eq!(hydrated.physical_helicity_ids, ["helicity:0", "helicity:1"]);
+        assert_eq!(hydrated.physical_color_ids, ["contracted"]);
+    }
+
+    #[test]
+    fn resolves_lc_selectors_by_numeric_word_instead_of_public_string_order() {
+        let mut physics = compact_physics();
+        physics.color_accuracy = ColorAccuracy::Lc;
+        physics.coverage.color = "complete".to_string();
+        physics.coverage.color_kind = "physical-lc-flows".to_string();
+        physics.reduction.kind = ReductionKind::LcDiagonal;
+        physics.selectors.color_flow = true;
+        physics.external_particles = (0..10)
+            .map(|index| ExternalParticle {
+                index,
+                label: index + 1,
+                particle: format!("particle-{index}"),
+                pdg: index as i32 + 1,
+                role: if index < 2 {
+                    ParticleRole::Initial
+                } else {
+                    ParticleRole::Final
+                },
+                momentum_slot: index,
+                momentum_components: [
+                    "E".to_string(),
+                    "px".to_string(),
+                    "py".to_string(),
+                    "pz".to_string(),
+                ],
+            })
+            .collect();
+        physics.helicities[0].values = vec![1; 10];
+        physics.helicities[1].values = vec![-1; 10];
+        physics.color_components = vec![
+            ColorComponent::LcFlow(LcColorFlow {
+                id: "flow:2,10,7,8,9,1".to_string(),
+                index: 0,
+                word: vec![2, 10, 7, 8, 9, 1],
+                computed: false,
+                representative_id: "flow:2,7,8,9,10,1".to_string(),
+                coefficient: 1.0,
+            }),
+            ColorComponent::LcFlow(LcColorFlow {
+                id: "flow:2,7,8,9,10,1".to_string(),
+                index: 1,
+                word: vec![2, 7, 8, 9, 10, 1],
+                computed: true,
+                representative_id: "flow:2,7,8,9,10,1".to_string(),
+                coefficient: 1.0,
+            }),
+        ];
+
+        let catalog = native_color_selector_catalog(&physics).unwrap();
+        let computed = resolve_native_color_selector_id(
+            &catalog,
+            &[2, 7, 8, 9, 10, 1],
+            &[2, 7, 8, 9, 10, 1],
+            true,
+        )
+        .unwrap();
+        let alias = resolve_native_color_selector_id(
+            &catalog,
+            &[2, 10, 7, 8, 9, 1],
+            &[2, 7, 8, 9, 10, 1],
+            false,
+        )
+        .unwrap();
+        assert_eq!(computed, "flow:2,7,8,9,10,1");
+        assert_eq!(alias, "flow:2,10,7,8,9,1");
+
+        let entries = [selector(7, 0, 0), selector(7, 1, 1), selector(7, 0, 0)];
+        hydrate_native_reduction_groups(&mut physics, &[group()], &entries, &[computed, alias])
+            .unwrap();
+        let hydrated = &physics.reduction.groups[0];
+        assert_eq!(hydrated.representative_color_id, "flow:2,7,8,9,10,1");
+        assert_eq!(
+            hydrated.physical_color_ids,
+            ["flow:2,7,8,9,10,1", "flow:2,10,7,8,9,1"]
+        );
+    }
+
+    #[test]
+    fn rejects_descriptor_group_count_mismatch() {
+        let mut physics = compact_physics();
+        physics
+            .extensions
+            .get_mut(NATIVE_REDUCTION_GROUPS_EXTENSION_KEY)
+            .unwrap()["group_count"] = json!(2);
+
+        let error =
+            hydrate_native_reduction_groups(&mut physics, &[group()], &[], &["contracted".into()])
+                .unwrap_err();
+
+        assert!(error.to_string().contains("declares 2 groups"));
+    }
+
+    #[test]
+    fn rejects_unknown_descriptor_contract() {
+        let mut physics = compact_physics();
+        physics
+            .extensions
+            .get_mut(NATIVE_REDUCTION_GROUPS_EXTENSION_KEY)
+            .unwrap()["storage_abi"] = json!("pacbin-v0");
+
+        let error =
+            hydrate_native_reduction_groups(&mut physics, &[group()], &[], &["contracted".into()])
+                .unwrap_err();
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.to_string().contains("regenerate"));
+    }
+
+    #[test]
+    fn rejects_selector_owner_and_axis_mismatches() {
+        let mut physics = compact_physics();
+        let owner_error = hydrate_native_reduction_groups(
+            &mut physics,
+            &[group()],
+            &[selector(6, 0, 0), selector(6, 1, 0), selector(6, 0, 0)],
+            &["contracted".into()],
+        )
+        .unwrap_err();
+        assert!(owner_error.to_string().contains("invalid selector member"));
+
+        let mut physics = compact_physics();
+        let axis_error = hydrate_native_reduction_groups(
+            &mut physics,
+            &[group()],
+            &[selector(7, 99, 0), selector(7, 0, 0), selector(7, 0, 0)],
+            &["contracted".into()],
+        )
+        .unwrap_err();
+        assert!(
+            axis_error
+                .to_string()
+                .contains("unknown helicity selector 99")
+        );
+    }
+
+    #[test]
+    fn lc_raw_sum_uses_retained_color_plan_sector_identity() {
+        let sectors = BTreeMap::from([(7, 1)]);
+
+        assert_eq!(
+            eager_raw_sum_sector_ids("lc", 7, Some(&sectors)).unwrap(),
+            vec![1]
+        );
+        assert!(eager_raw_sum_sector_ids("lc", 8, Some(&sectors)).is_err());
+        assert!(
+            eager_raw_sum_sector_ids("full", 7, None)
+                .unwrap()
+                .is_empty()
+        );
+    }
+
+    #[test]
+    fn compiled_lane_rejects_native_reduction_marker() {
+        let physics = compact_physics();
+
+        let error = reject_native_reduction_groups_for_compiled(&physics).unwrap_err();
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.to_string().contains("require eager plan-v3"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_manifest.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_manifest.rs
new file mode 100644
index 0000000000..cad7957c3d
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_manifest.rs
@@ -0,0 +1,749 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Bounded execution-manifest and container preflight for eager plan-v3.
+//!
+//! This module deliberately stops before decoding an `EagerExecutionPlan`.
+//! It authenticates the small JSON summary and the complete PACBIN container,
+//! then returns the mapped reader to the compact runtime loader.
+
+use crate::eager_layout::{
+    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY, EAGER_LOWERING_INPUT_ABI, EAGER_PLAN_ABI,
+    EAGER_RUNTIME_CAPABILITY, EAGER_RUNTIME_CONTAINER_KIND, EAGER_RUNTIME_CONTAINER_SCHEMA,
+    EAGER_RUNTIME_LAYOUT_ABI, EagerSectionHeader, EagerSectionKind,
+};
+use crate::pacbin::{PacbinMemberKind, PacbinReader};
+use crate::{ArtifactProcess, PROCESS_ARTIFACT_SCHEMA_VERSION, RusticolError, RusticolResult};
+use serde::Deserialize;
+use std::collections::{BTreeMap, BTreeSet};
+use std::fs::File;
+use std::path::Path;
+
+pub(super) const EAGER_EXECUTION_KIND: &str = "pyamplicol-runtime-eager-execution";
+pub(super) const EAGER_RUNTIME_STORAGE_ABI: &str = "pacbin-v1";
+pub(super) const EAGER_RUNTIME_CONTAINER_PATH: &str = "eager-runtime.pacbin";
+pub(super) const EAGER_KERNEL_PACK_MANIFEST_PATH: &str = "model/eager-kernel-pack.json";
+pub(super) const EAGER_KERNEL_PAYLOAD_ROOT: &str = "model/eager-kernels";
+const LEGACY_EAGER_PLAN_ABI: &str = "pyamplicol-eager-plan-v2";
+const LEGACY_EAGER_RUNTIME_CAPABILITY: &str = "rusticol.eager-dag.complex-f64.v1";
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerV3ExecutionManifest {
+    pub(super) schema_version: u32,
+    pub(super) kind: String,
+    pub(super) required_runtime_capabilities: Vec<String>,
+    pub(super) process: String,
+    pub(super) key: String,
+    pub(super) color_accuracy: String,
+    pub(super) external_pdg_order: Vec<i32>,
+    pub(super) eager_plan_abi: String,
+    pub(super) kernel_pack: EagerV3KernelPackReference,
+    pub(super) runtime_options: EagerV3RuntimeOptions,
+    pub(super) plan: EagerV3PlanSummary,
+    pub(super) dag_summary: EagerV3DagSummary,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerV3KernelPackReference {
+    pub(super) manifest_path: String,
+    pub(super) payload_root: String,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerV3RuntimeOptions {
+    pub(super) point_tile_size: u64,
+    pub(super) workspace_mib: u64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerV3PlanSummary {
+    pub(super) kind: String,
+    pub(super) eager_plan_abi: String,
+    pub(super) lowering_input_abi: String,
+    pub(super) lowering_input_sha256: String,
+    pub(super) runtime_layout_abi: String,
+    pub(super) required_runtime_capabilities: Vec<String>,
+    pub(super) runtime_container: EagerV3RuntimeContainer,
+    pub(super) inspection_summary: EagerV3InspectionSummary,
+    pub(super) materialization_census: EagerV3MaterializationCensus,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerV3RuntimeContainer {
+    pub(super) kind: String,
+    pub(super) schema_version: u16,
+    pub(super) storage_abi: String,
+    pub(super) path: String,
+    pub(super) size_bytes: u64,
+    pub(super) sha256: String,
+    pub(super) member_count: u64,
+    pub(super) unpacked_size_bytes: u64,
+    pub(super) index_sha256: String,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerV3DagSummary {
+    pub(super) current_count: u64,
+    pub(super) source_count: u64,
+    pub(super) interaction_count: u64,
+    pub(super) interaction_evaluation_count: u64,
+    pub(super) amplitude_root_count: u64,
+    pub(super) truncated: bool,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerV3MaterializationCensus {
+    pub(super) abi: String,
+    pub(super) basis: String,
+    pub(super) r#final: BTreeMap<String, u64>,
+    pub(super) peak: BTreeMap<String, u64>,
+    pub(super) final_equals_peak: bool,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerV3InspectionSummary {
+    pub(super) execution_mode: String,
+    pub(super) eager_plan_abi: String,
+    pub(super) runtime_layout_abi: String,
+    pub(super) process_id: String,
+    pub(super) model_name: String,
+    pub(super) current_count: u64,
+    pub(super) value_count: u64,
+    pub(super) momentum_count: u64,
+    pub(super) source_count: u64,
+    pub(super) parameter_count: u64,
+    pub(super) stage_count: u64,
+    pub(super) coupling_count: u64,
+    pub(super) invocation_count: u64,
+    pub(super) attachment_count: u64,
+    pub(super) finalization_count: u64,
+    pub(super) closure_count: u64,
+    pub(super) selector_domain_count: u64,
+    pub(super) reduction_group_count: u64,
+    pub(super) reduction_entry_count: u64,
+    pub(super) retained_table_count: u64,
+    pub(super) current_component_count: u64,
+    pub(super) value_component_count: u64,
+    pub(super) momentum_component_count: u64,
+    #[serde(default)]
+    pub(super) selector_work: Option<EagerV3SelectorWork>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct EagerV3SelectorWork {
+    pub(super) abi: String,
+    pub(super) selected_flow_selector_count: u64,
+    pub(super) selected_flow_current_count: u64,
+    pub(super) selected_flow_evaluation_count: u64,
+    pub(super) selected_flow_attachment_count: u64,
+    pub(super) all_flow_selector_count: u64,
+    pub(super) all_flow_current_count: u64,
+    pub(super) all_flow_evaluation_count: u64,
+    pub(super) all_flow_attachment_count: u64,
+    pub(super) contracted_current_count: u64,
+    pub(super) contracted_evaluation_count: u64,
+    pub(super) contracted_attachment_count: u64,
+}
+
+impl EagerV3ExecutionManifest {
+    fn validate(&self, outer: &ArtifactProcess) -> RusticolResult<()> {
+        if self.schema_version != PROCESS_ARTIFACT_SCHEMA_VERSION
+            || self.kind != EAGER_EXECUTION_KIND
+        {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported eager execution kind {:?} schema {}; regenerate the artifact",
+                self.kind, self.schema_version
+            )));
+        }
+        if self.process != outer.expression
+            || self.key != outer.id
+            || self.color_accuracy != outer.color_accuracy
+            || self.external_pdg_order != outer.external_pdgs
+        {
+            return Err(RusticolError::integrity(format!(
+                "eager plan-v3 execution manifest does not match outer process {:?}",
+                outer.id
+            )));
+        }
+        validate_direct_capabilities(
+            &self.required_runtime_capabilities,
+            "eager execution manifest",
+        )?;
+        validate_direct_capabilities(&outer.required_runtime_capabilities, "outer eager process")?;
+        if self.eager_plan_abi != EAGER_PLAN_ABI {
+            return Err(unsupported_abi("eager plan", &self.eager_plan_abi));
+        }
+        if self.kernel_pack.manifest_path != EAGER_KERNEL_PACK_MANIFEST_PATH
+            || self.kernel_pack.payload_root != EAGER_KERNEL_PAYLOAD_ROOT
+        {
+            return Err(RusticolError::security(
+                "eager plan-v3 kernel-pack paths are not canonical",
+            ));
+        }
+        self.runtime_options.validate()?;
+        self.plan.validate(&self.key)?;
+        self.dag_summary.validate()?;
+        self.plan
+            .materialization_census
+            .validate(&self.plan.inspection_summary, &self.dag_summary)?;
+        if self.plan.inspection_summary.current_count != self.dag_summary.current_count
+            || self.plan.inspection_summary.source_count != self.dag_summary.source_count
+            || self.plan.inspection_summary.invocation_count
+                != self.dag_summary.interaction_evaluation_count
+        {
+            return Err(RusticolError::integrity(
+                "eager plan-v3 inspection counts disagree with the DAG summary",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl EagerV3RuntimeOptions {
+    fn validate(self) -> RusticolResult<()> {
+        if self.point_tile_size == 0 {
+            return Err(RusticolError::artifact(
+                "eager point_tile_size must be positive",
+            ));
+        }
+        if self.workspace_mib == 0 {
+            return Err(RusticolError::artifact(
+                "eager workspace_mib must be positive",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl EagerV3PlanSummary {
+    fn validate(&self, process_key: &str) -> RusticolResult<()> {
+        if self.kind != EAGER_EXECUTION_KIND {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported eager plan kind {:?}",
+                self.kind
+            )));
+        }
+        if self.eager_plan_abi != EAGER_PLAN_ABI {
+            return Err(unsupported_abi("nested eager plan", &self.eager_plan_abi));
+        }
+        if self.lowering_input_abi != EAGER_LOWERING_INPUT_ABI {
+            return Err(unsupported_abi(
+                "eager lowering input",
+                &self.lowering_input_abi,
+            ));
+        }
+        if self.runtime_layout_abi != EAGER_RUNTIME_LAYOUT_ABI {
+            return Err(unsupported_abi(
+                "eager runtime layout",
+                &self.runtime_layout_abi,
+            ));
+        }
+        parse_sha256(&self.lowering_input_sha256, "eager lowering input")?;
+        validate_direct_capabilities(&self.required_runtime_capabilities, "nested eager plan")?;
+        self.runtime_container.validate()?;
+        self.inspection_summary.validate(process_key)?;
+        Ok(())
+    }
+}
+
+impl EagerV3RuntimeContainer {
+    fn validate(&self) -> RusticolResult<()> {
+        if self.kind != EAGER_RUNTIME_CONTAINER_KIND {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported eager runtime container kind {:?}",
+                self.kind
+            )));
+        }
+        if self.schema_version != EAGER_RUNTIME_CONTAINER_SCHEMA {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported eager runtime container schema {}",
+                self.schema_version
+            )));
+        }
+        if self.storage_abi != EAGER_RUNTIME_STORAGE_ABI {
+            return Err(unsupported_abi("eager runtime storage", &self.storage_abi));
+        }
+        if self.path != EAGER_RUNTIME_CONTAINER_PATH {
+            return Err(RusticolError::security(
+                "eager runtime container path must be exactly eager-runtime.pacbin",
+            ));
+        }
+        if self.member_count != EXPECTED_EAGER_MEMBERS.len() as u64 {
+            return Err(RusticolError::integrity(format!(
+                "eager runtime container must declare exactly {} members",
+                EXPECTED_EAGER_MEMBERS.len()
+            )));
+        }
+        if self.size_bytes == 0 {
+            return Err(RusticolError::artifact(
+                "eager runtime container must not be empty",
+            ));
+        }
+        if self.unpacked_size_bytes == 0 || self.unpacked_size_bytes > self.size_bytes {
+            return Err(RusticolError::artifact(
+                "eager runtime unpacked size must be nonzero and not exceed the container size",
+            ));
+        }
+        parse_sha256(&self.sha256, "eager runtime container")?;
+        parse_sha256(&self.index_sha256, "eager runtime index")?;
+        Ok(())
+    }
+}
+
+impl EagerV3DagSummary {
+    fn validate(self) -> RusticolResult<()> {
+        validate_counts(
+            "eager DAG summary",
+            &[
+                self.current_count,
+                self.source_count,
+                self.interaction_count,
+                self.interaction_evaluation_count,
+                self.amplitude_root_count,
+            ],
+        )?;
+        if self.interaction_evaluation_count > self.interaction_count {
+            return Err(RusticolError::integrity(
+                "eager DAG interaction-evaluation count exceeds its interaction count",
+            ));
+        }
+        if self.truncated {
+            return Err(RusticolError::compatibility(
+                "truncated DAGs cannot be loaded as eager plan-v3 artifacts",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl EagerV3MaterializationCensus {
+    fn validate(
+        &self,
+        inspection: &EagerV3InspectionSummary,
+        dag: &EagerV3DagSummary,
+    ) -> RusticolResult<()> {
+        if self.abi != "pyamplicol-fully-resident-materialization-census-v1"
+            || self.basis != "immutable-fully-resident-eager-plan"
+        {
+            return Err(RusticolError::compatibility(
+                "eager materialization census ABI or basis is unsupported",
+            ));
+        }
+        let expected = BTreeMap::from([
+            ("amplitude_root_count".to_string(), dag.amplitude_root_count),
+            ("attachment_count".to_string(), inspection.attachment_count),
+            ("closure_count".to_string(), inspection.closure_count),
+            ("current_count".to_string(), dag.current_count),
+            (
+                "finalization_count".to_string(),
+                inspection.finalization_count,
+            ),
+            ("interaction_count".to_string(), dag.interaction_count),
+            ("invocation_count".to_string(), inspection.invocation_count),
+            ("source_count".to_string(), dag.source_count),
+        ]);
+        validate_counts(
+            "eager materialization census",
+            &self.r#final.values().copied().collect::<Vec<_>>(),
+        )?;
+        validate_counts(
+            "eager materialization census peak",
+            &self.peak.values().copied().collect::<Vec<_>>(),
+        )?;
+        if !self.final_equals_peak || self.r#final != expected || self.peak != expected {
+            return Err(RusticolError::integrity(
+                "eager materialization census disagrees with the persisted plan",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl EagerV3InspectionSummary {
+    fn validate(&self, process_key: &str) -> RusticolResult<()> {
+        if self.execution_mode != "eager"
+            || self.eager_plan_abi != EAGER_PLAN_ABI
+            || self.runtime_layout_abi != EAGER_RUNTIME_LAYOUT_ABI
+        {
+            return Err(RusticolError::compatibility(
+                "eager inspection summary ABI does not match plan-v3",
+            ));
+        }
+        if self.process_id != process_key {
+            return Err(RusticolError::integrity(
+                "eager inspection process id does not match its execution manifest",
+            ));
+        }
+        if self.model_name.is_empty() {
+            return Err(RusticolError::artifact(
+                "eager inspection model name must not be empty",
+            ));
+        }
+        validate_counts(
+            "eager inspection summary",
+            &[
+                self.current_count,
+                self.value_count,
+                self.momentum_count,
+                self.source_count,
+                self.parameter_count,
+                self.stage_count,
+                self.coupling_count,
+                self.invocation_count,
+                self.attachment_count,
+                self.finalization_count,
+                self.closure_count,
+                self.selector_domain_count,
+                self.reduction_group_count,
+                self.reduction_entry_count,
+                self.retained_table_count,
+                self.current_component_count,
+                self.value_component_count,
+                self.momentum_component_count,
+            ],
+        )?;
+        if let Some(selector_work) = &self.selector_work {
+            selector_work.validate(self)?;
+        }
+        Ok(())
+    }
+}
+
+impl EagerV3SelectorWork {
+    fn validate(&self, summary: &EagerV3InspectionSummary) -> RusticolResult<()> {
+        if self.abi != "pyamplicol-eager-selector-work-v1" {
+            return Err(RusticolError::compatibility(
+                "eager selector-work summary ABI is unsupported",
+            ));
+        }
+        validate_counts(
+            "eager selector-work summary",
+            &[
+                self.selected_flow_selector_count,
+                self.selected_flow_current_count,
+                self.selected_flow_evaluation_count,
+                self.selected_flow_attachment_count,
+                self.all_flow_selector_count,
+                self.all_flow_current_count,
+                self.all_flow_evaluation_count,
+                self.all_flow_attachment_count,
+                self.contracted_current_count,
+                self.contracted_evaluation_count,
+                self.contracted_attachment_count,
+            ],
+        )?;
+        if self.selected_flow_current_count > summary.current_count
+            || self.all_flow_current_count > summary.current_count
+            || self.contracted_current_count != summary.current_count
+            || self.selected_flow_evaluation_count > summary.invocation_count
+            || self.all_flow_evaluation_count > summary.invocation_count
+            || self.contracted_evaluation_count != summary.invocation_count
+            || self.selected_flow_attachment_count > summary.attachment_count
+            || self.all_flow_attachment_count > summary.attachment_count
+            || self.contracted_attachment_count != summary.attachment_count
+        {
+            return Err(RusticolError::integrity(
+                "eager selector-work counts exceed or disagree with the persisted plan",
+            ));
+        }
+        Ok(())
+    }
+}
+
+/// Parse and validate one eager plan-v3 `execution.json`.
+///
+/// Legacy plan-v2 markers are detected before full
+/// JSON deserialization, avoiding traversal of an expanded `runtime_schema`.
+pub(super) fn parse_eager_v3_execution_manifest(
+    bytes: &[u8],
+    outer: &ArtifactProcess,
+) -> RusticolResult<EagerV3ExecutionManifest> {
+    reject_legacy_eager_manifest(bytes)?;
+    let manifest: EagerV3ExecutionManifest = serde_json::from_slice(bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse eager plan-v3 execution manifest: {error}"
+        ))
+    })?;
+    manifest.validate(outer)?;
+    Ok(manifest)
+}
+
+/// Open, authenticate, and structurally preflight `eager-runtime.pacbin`.
+pub(super) fn open_eager_v3_runtime_container(
+    container_file: File,
+    display_path: &Path,
+    manifest: &EagerV3ExecutionManifest,
+) -> RusticolResult<PacbinReader> {
+    manifest.plan.runtime_container.validate()?;
+    let container = &manifest.plan.runtime_container;
+    // A complete container digest authenticates every indexed member. Hashing
+    // and parsing use the exact checked file description supplied by the
+    // verified artifact, avoiding a path-replacement race.
+    // PACBIN still validates its index, canonical layout, and boundaries.
+    let expected_file_sha = parse_sha256(&container.sha256, "eager runtime container")?;
+    let reader =
+        PacbinReader::open_file_with_sha256(container_file, display_path, &expected_file_sha)?;
+    let index = reader.index();
+    let mapped_size = u64::try_from(reader.container_size())
+        .map_err(|_| RusticolError::integrity("eager runtime PACBIN size exceeds u64"))?;
+    if index.file_size() != container.size_bytes || mapped_size != container.size_bytes {
+        return Err(RusticolError::integrity(
+            "eager runtime PACBIN size does not match execution manifest",
+        ));
+    }
+    let expected_index_sha = parse_sha256(&container.index_sha256, "eager runtime index")?;
+    if index.index_sha256() != &expected_index_sha {
+        return Err(RusticolError::integrity(
+            "eager runtime PACBIN index digest mismatch",
+        ));
+    }
+    if index.members().len() as u64 != container.member_count {
+        return Err(RusticolError::integrity(
+            "eager runtime PACBIN member count does not match execution manifest",
+        ));
+    }
+
+    let mut seen = BTreeSet::new();
+    let mut unpacked_size = 0_u64;
+    for member in reader.members() {
+        let expected = expected_member(member.logical_path()).ok_or_else(|| {
+            RusticolError::security(format!(
+                "unexpected eager runtime PACBIN member path {:?}",
+                member.logical_path()
+            ))
+        })?;
+        if member.kind() != expected.member_kind {
+            return Err(RusticolError::integrity(format!(
+                "eager runtime PACBIN member {:?} has kind {:?}, expected {:?}",
+                member.logical_path(),
+                member.kind(),
+                expected.member_kind
+            )));
+        }
+        let (header, _) = EagerSectionHeader::decode(reader.member_bytes(member.logical_path())?)?;
+        if header.kind() != expected.section_kind {
+            return Err(RusticolError::integrity(format!(
+                "eager runtime PACBIN member {:?} has section kind {:?}, expected {:?}",
+                member.logical_path(),
+                header.kind(),
+                expected.section_kind
+            )));
+        }
+        unpacked_size = unpacked_size.checked_add(member.length()).ok_or_else(|| {
+            RusticolError::integrity("eager runtime PACBIN unpacked size exceeds u64")
+        })?;
+        seen.insert(member.logical_path());
+    }
+    if seen.len() != EXPECTED_EAGER_MEMBERS.len()
+        || EXPECTED_EAGER_MEMBERS
+            .iter()
+            .any(|expected| !seen.contains(expected.path))
+    {
+        return Err(RusticolError::integrity(
+            "eager runtime PACBIN is missing a required member",
+        ));
+    }
+    if unpacked_size != container.unpacked_size_bytes {
+        return Err(RusticolError::integrity(
+            "eager runtime PACBIN unpacked size does not match execution manifest",
+        ));
+    }
+    Ok(reader)
+}
+
+fn reject_legacy_eager_manifest(bytes: &[u8]) -> RusticolResult<()> {
+    if contains_bytes(bytes, LEGACY_EAGER_PLAN_ABI.as_bytes())
+        || contains_bytes(bytes, LEGACY_EAGER_RUNTIME_CAPABILITY.as_bytes())
+    {
+        return Err(RusticolError::compatibility(
+            "legacy eager plan-v2 artifacts are unsupported by the compact eager runtime; regenerate the artifact with `pyamplicol generate`",
+        ));
+    }
+    Ok(())
+}
+
+fn contains_bytes(haystack: &[u8], needle: &[u8]) -> bool {
+    !needle.is_empty()
+        && haystack
+            .windows(needle.len())
+            .any(|window| window == needle)
+}
+
+fn validate_direct_capabilities(capabilities: &[String], context: &str) -> RusticolResult<()> {
+    if capabilities == [EAGER_RUNTIME_CAPABILITY] {
+        return Err(RusticolError::compatibility(format!(
+            "{context} predates {EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY:?}; regenerate the eager \
+             artifact with the current `pyamplicol generate` before loading it"
+        )));
+    }
+    if capabilities
+        != [
+            EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            EAGER_RUNTIME_CAPABILITY,
+        ]
+    {
+        return Err(RusticolError::compatibility(format!(
+            "{context} must require exactly {:?}",
+            [
+                EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+                EAGER_RUNTIME_CAPABILITY,
+            ]
+        )));
+    }
+    Ok(())
+}
+
+fn validate_counts(context: &str, counts: &[u64]) -> RusticolResult<()> {
+    if counts.iter().any(|count| usize::try_from(*count).is_err()) {
+        return Err(RusticolError::artifact(format!(
+            "{context} count exceeds the platform index domain"
+        )));
+    }
+    Ok(())
+}
+
+fn unsupported_abi(context: &str, value: &str) -> RusticolError {
+    RusticolError::compatibility(format!("unsupported {context} ABI {value:?}"))
+}
+
+fn parse_sha256(value: &str, context: &str) -> RusticolResult<[u8; 32]> {
+    if value.len() != 64
+        || value
+            .as_bytes()
+            .iter()
+            .any(|byte| !matches!(byte, b'0'..=b'9' | b'a'..=b'f'))
+    {
+        return Err(RusticolError::artifact(format!(
+            "{context} SHA-256 must be 64 lowercase hexadecimal characters"
+        )));
+    }
+    let mut digest = [0_u8; 32];
+    for (index, pair) in value.as_bytes().chunks_exact(2).enumerate() {
+        digest[index] = (hex_nibble(pair[0]) << 4) | hex_nibble(pair[1]);
+    }
+    Ok(digest)
+}
+
+fn hex_nibble(value: u8) -> u8 {
+    match value {
+        b'0'..=b'9' => value - b'0',
+        b'a'..=b'f' => value - b'a' + 10,
+        _ => unreachable!("digest validation precedes hexadecimal decoding"),
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(super) struct ExpectedEagerMember {
+    pub(super) path: &'static str,
+    pub(super) member_kind: PacbinMemberKind,
+    pub(super) section_kind: EagerSectionKind,
+}
+
+const fn metadata(path: &'static str, section_kind: EagerSectionKind) -> ExpectedEagerMember {
+    ExpectedEagerMember {
+        path,
+        member_kind: PacbinMemberKind::EagerRuntimeMetadata,
+        section_kind,
+    }
+}
+
+const fn table(path: &'static str, section_kind: EagerSectionKind) -> ExpectedEagerMember {
+    ExpectedEagerMember {
+        path,
+        member_kind: PacbinMemberKind::EagerRuntimeTable,
+        section_kind,
+    }
+}
+
+pub(super) const EXPECTED_EAGER_MEMBERS: &[ExpectedEagerMember] = &[
+    table(
+        "catalogs/bitsets/populations.bin",
+        EagerSectionKind::Metadata,
+    ),
+    table("catalogs/bitsets/ranges.bin", EagerSectionKind::Metadata),
+    table("catalogs/bitsets/words.bin", EagerSectionKind::Metadata),
+    table("catalogs/exact-factors.bin", EagerSectionKind::ExactFactors),
+    metadata("catalogs/exact-ir/bytes.bin", EagerSectionKind::Metadata),
+    metadata("catalogs/exact-ir/ranges.bin", EagerSectionKind::Metadata),
+    table(
+        "catalogs/i32-sequences/ranges.bin",
+        EagerSectionKind::Metadata,
+    ),
+    table(
+        "catalogs/i32-sequences/values.bin",
+        EagerSectionKind::Metadata,
+    ),
+    metadata(
+        "catalogs/semantic-limitations/bytes.bin",
+        EagerSectionKind::Metadata,
+    ),
+    metadata(
+        "catalogs/semantic-limitations/ranges.bin",
+        EagerSectionKind::Metadata,
+    ),
+    metadata("catalogs/strings/bytes.bin", EagerSectionKind::Metadata),
+    metadata("catalogs/strings/ranges.bin", EagerSectionKind::Metadata),
+    table(
+        "catalogs/u32-sequences/ranges.bin",
+        EagerSectionKind::Metadata,
+    ),
+    table(
+        "catalogs/u32-sequences/values.bin",
+        EagerSectionKind::Metadata,
+    ),
+    metadata(
+        "inspection/summary.bin",
+        EagerSectionKind::InspectionSummary,
+    ),
+    metadata("metadata/core.bin", EagerSectionKind::Metadata),
+    metadata("metadata/identity-bytes.bin", EagerSectionKind::Metadata),
+    metadata("metadata/identity-ranges.bin", EagerSectionKind::Metadata),
+    table("reductions/entries.bin", EagerSectionKind::ReductionEntries),
+    table("reductions/groups.bin", EagerSectionKind::ReductionGroups),
+    table("retained/columns.bin", EagerSectionKind::Metadata),
+    metadata("retained/name-bytes.bin", EagerSectionKind::Metadata),
+    metadata("retained/name-ranges.bin", EagerSectionKind::Metadata),
+    table("retained/tables.bin", EagerSectionKind::Metadata),
+    table("retained/values-f64-bits.bin", EagerSectionKind::Metadata),
+    table("retained/values-i32.bin", EagerSectionKind::Metadata),
+    table("retained/values-u32.bin", EagerSectionKind::Metadata),
+    table("retained/values-u64.bin", EagerSectionKind::Metadata),
+    table("retained/values-u8.bin", EagerSectionKind::Metadata),
+    table("selectors/colors.bin", EagerSectionKind::SelectorDomains),
+    table("selectors/domains.bin", EagerSectionKind::SelectorDomains),
+    table(
+        "selectors/helicities.bin",
+        EagerSectionKind::SelectorDomains,
+    ),
+    table(
+        "selectors/memberships.bin",
+        EagerSectionKind::SelectorMemberships,
+    ),
+    table("tables/attachments.bin", EagerSectionKind::Attachments),
+    table("tables/closures.bin", EagerSectionKind::Closures),
+    table("tables/couplings.bin", EagerSectionKind::Couplings),
+    table("tables/currents.bin", EagerSectionKind::CurrentLayout),
+    table("tables/direct-coefficients.bin", EagerSectionKind::Closures),
+    table("tables/finalizations.bin", EagerSectionKind::Finalizations),
+    table("tables/invocations.bin", EagerSectionKind::Invocations),
+    table("tables/momenta.bin", EagerSectionKind::MomentumLayout),
+    table("tables/parameters.bin", EagerSectionKind::ParameterLayout),
+    table("tables/sources.bin", EagerSectionKind::SourceFill),
+    table("tables/stages.bin", EagerSectionKind::Stages),
+    table("tables/values.bin", EagerSectionKind::ValueLayout),
+];
+
+fn expected_member(path: &str) -> Option<&'static ExpectedEagerMember> {
+    EXPECTED_EAGER_MEMBERS
+        .binary_search_by_key(&path, |member| member.path)
+        .ok()
+        .map(|index| &EXPECTED_EAGER_MEMBERS[index])
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_manifest_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_manifest_tests.rs
new file mode 100644
index 0000000000..01268d852f
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/eager_v3_manifest_tests.rs
@@ -0,0 +1,704 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::eager_v3_manifest::*;
+use crate::eager_layout::{
+    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY, EAGER_LOWERING_INPUT_ABI, EAGER_PLAN_ABI,
+    EAGER_RUNTIME_CAPABILITY, EAGER_RUNTIME_CONTAINER_KIND, EAGER_RUNTIME_CONTAINER_SCHEMA,
+    EAGER_RUNTIME_LAYOUT_ABI, EAGER_SECTION_HEADER_SIZE, EagerSectionHeader, EagerSectionKind,
+};
+use crate::pacbin::{PacbinReader, PacbinWriteMember, PacbinWriteOptions, write_pacbin_atomic};
+use crate::{ArtifactProcess, PROCESS_ARTIFACT_SCHEMA_VERSION, RusticolErrorKind};
+use serde_json::{Value, json};
+use sha2::{Digest, Sha256};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+
+static NEXT_DIRECTORY: AtomicU64 = AtomicU64::new(0);
+
+struct Fixture {
+    root: PathBuf,
+    outer: ArtifactProcess,
+    manifest: Value,
+}
+
+impl Fixture {
+    fn new() -> Self {
+        let root = temporary_directory();
+        fs::create_dir_all(&root).unwrap();
+        let metadata = write_container(&root, None, None);
+        let outer = outer_process();
+        let manifest = manifest_value(&outer, &metadata);
+        Self {
+            root,
+            outer,
+            manifest,
+        }
+    }
+
+    fn parse(&self) -> crate::RusticolResult<EagerV3ExecutionManifest> {
+        parse_eager_v3_execution_manifest(&serde_json::to_vec(&self.manifest).unwrap(), &self.outer)
+    }
+}
+
+impl Drop for Fixture {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.root);
+    }
+}
+
+fn open_fixture_runtime_container(
+    root: &Path,
+    manifest: &EagerV3ExecutionManifest,
+) -> crate::RusticolResult<PacbinReader> {
+    let path = root.join(EAGER_RUNTIME_CONTAINER_PATH);
+    #[cfg(unix)]
+    let file = {
+        use std::os::unix::fs::OpenOptionsExt as _;
+        fs::OpenOptions::new()
+            .read(true)
+            .custom_flags(libc::O_CLOEXEC | libc::O_NOFOLLOW)
+            .open(&path)
+    };
+    #[cfg(not(unix))]
+    let file = fs::File::open(&path);
+    let file = file.map_err(|error| {
+        crate::RusticolError::security(format!(
+            "could not open eager runtime container {}: {error}",
+            path.display()
+        ))
+    })?;
+    open_eager_v3_runtime_container(file, &path, manifest)
+}
+
+#[derive(Clone)]
+struct ContainerMetadata {
+    size_bytes: u64,
+    sha256: String,
+    member_count: u64,
+    unpacked_size_bytes: u64,
+    index_sha256: String,
+}
+
+#[test]
+fn valid_manifest_and_container_preflight() {
+    let fixture = Fixture::new();
+    let manifest = fixture.parse().unwrap();
+    let reader = open_fixture_runtime_container(&fixture.root, &manifest).unwrap();
+    assert_eq!(reader.members().len(), EXPECTED_EAGER_MEMBERS.len());
+}
+
+#[cfg(unix)]
+#[test]
+fn opened_runtime_container_does_not_reopen_a_replaced_path() {
+    let fixture = Fixture::new();
+    let manifest = fixture.parse().unwrap();
+    let path = fixture.root.join(EAGER_RUNTIME_CONTAINER_PATH);
+    let displaced = fixture.root.join("authenticated-runtime.pacbin");
+    let file = fs::File::open(&path).unwrap();
+    fs::rename(&path, &displaced).unwrap();
+    fs::write(&path, b"replacement bytes").unwrap();
+
+    let reader = open_eager_v3_runtime_container(file, &path, &manifest).unwrap();
+    assert_eq!(reader.members().len(), EXPECTED_EAGER_MEMBERS.len());
+}
+
+#[test]
+fn outer_process_identity_must_match() {
+    for (field, value) in [
+        ("schema_version", json!(4)),
+        ("kind", json!("wrong-kind")),
+        ("process", json!("g g > g g")),
+        ("key", json!("wrong-key")),
+        ("color_accuracy", json!("lc")),
+        ("external_pdg_order", json!([21, 21, 21, 21])),
+    ] {
+        let mut fixture = Fixture::new();
+        fixture.manifest[field] = value;
+        let error = fixture.parse().unwrap_err();
+        assert!(
+            matches!(
+                error.kind(),
+                RusticolErrorKind::Compatibility | RusticolErrorKind::Integrity
+            ),
+            "field {field}: {error}"
+        );
+    }
+}
+
+#[test]
+fn every_plan_abi_and_capability_mismatch_fails_closed() {
+    let mutations: &[(&[&str], Value)] = &[
+        (&["eager_plan_abi"], json!("pyamplicol-eager-plan-v999")),
+        (
+            &["plan", "eager_plan_abi"],
+            json!("pyamplicol-eager-plan-v999"),
+        ),
+        (
+            &["plan", "lowering_input_abi"],
+            json!("pyamplicol-eager-lowering-input-v999"),
+        ),
+        (
+            &["plan", "runtime_layout_abi"],
+            json!("pyamplicol-eager-runtime-layout-v999"),
+        ),
+        (
+            &["required_runtime_capabilities"],
+            json!(["rusticol.eager-dag.complex-f64.v1"]),
+        ),
+        (
+            &["plan", "required_runtime_capabilities"],
+            json!(["rusticol.eager-runtime-layout.complex-f64.v2"]),
+        ),
+    ];
+    for (path, replacement) in mutations {
+        let mut fixture = Fixture::new();
+        set_value(&mut fixture.manifest, path, replacement.clone());
+        let error = fixture.parse().unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Compatibility, "{path:?}");
+    }
+
+    let mut fixture = Fixture::new();
+    fixture.outer.required_runtime_capabilities = vec!["wrong-capability".to_string()];
+    assert_eq!(
+        fixture.parse().unwrap_err().kind(),
+        RusticolErrorKind::Compatibility
+    );
+}
+
+#[test]
+fn pre_arena_plan_v3_has_actionable_regeneration_error() {
+    let mut fixture = Fixture::new();
+    let legacy = json!([EAGER_RUNTIME_CAPABILITY]);
+    fixture.manifest["required_runtime_capabilities"] = legacy.clone();
+    fixture.manifest["plan"]["required_runtime_capabilities"] = legacy;
+    fixture.outer.required_runtime_capabilities = vec![EAGER_RUNTIME_CAPABILITY.to_string()];
+    let error = fixture.parse().unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Compatibility);
+    assert!(error.to_string().contains("predates"));
+    assert!(error.to_string().contains("pyamplicol generate"));
+}
+
+#[test]
+fn container_contract_mismatches_fail_closed() {
+    let mutations: &[(&[&str], Value)] = &[
+        (
+            &["plan", "runtime_container", "kind"],
+            json!("wrong-container"),
+        ),
+        (&["plan", "runtime_container", "schema_version"], json!(2)),
+        (
+            &["plan", "runtime_container", "storage_abi"],
+            json!("pacbin-v2"),
+        ),
+        (
+            &["plan", "runtime_container", "path"],
+            json!("other.pacbin"),
+        ),
+        (&["plan", "runtime_container", "size_bytes"], json!(0)),
+        (
+            &["plan", "runtime_container", "sha256"],
+            json!("A".repeat(64)),
+        ),
+        (&["plan", "runtime_container", "member_count"], json!(44)),
+        (
+            &["plan", "runtime_container", "unpacked_size_bytes"],
+            json!(0),
+        ),
+        (
+            &["plan", "runtime_container", "unpacked_size_bytes"],
+            json!(u64::MAX),
+        ),
+        (
+            &["plan", "runtime_container", "index_sha256"],
+            json!("A".repeat(64)),
+        ),
+    ];
+    for (path, replacement) in mutations {
+        let mut fixture = Fixture::new();
+        set_value(&mut fixture.manifest, path, replacement.clone());
+        assert!(
+            fixture.parse().is_err(),
+            "mutation unexpectedly passed: {path:?}"
+        );
+    }
+}
+
+#[test]
+fn large_writer_representable_container_metadata_is_accepted() {
+    let mut fixture = Fixture::new();
+    let size_bytes = 1_u64 << 40;
+    fixture.manifest["plan"]["runtime_container"]["size_bytes"] = json!(size_bytes);
+    fixture.manifest["plan"]["runtime_container"]["unpacked_size_bytes"] = json!(size_bytes - 4096);
+
+    fixture.parse().unwrap();
+}
+
+#[test]
+fn long_writer_valid_model_name_is_accepted() {
+    let mut fixture = Fixture::new();
+    fixture.manifest["plan"]["inspection_summary"]["model_name"] =
+        json!("m".repeat(1024 * 1024 + 1));
+
+    fixture.parse().unwrap();
+
+    fixture.manifest["plan"]["inspection_summary"]["model_name"] = json!("");
+    assert!(fixture.parse().is_err());
+}
+
+#[test]
+fn runtime_options_require_positive_values_and_summary_relationships_hold() {
+    let mutations: &[(&[&str], Value)] = &[
+        (&["runtime_options", "point_tile_size"], json!(0)),
+        (&["runtime_options", "workspace_mib"], json!(0)),
+        (&["dag_summary", "interaction_count"], json!(1_u64 << 49)),
+        (
+            &["dag_summary", "interaction_evaluation_count"],
+            json!(1_u64 << 49),
+        ),
+        (
+            &["plan", "inspection_summary", "invocation_count"],
+            json!(1_u64 << 49),
+        ),
+        (
+            &[
+                "plan",
+                "inspection_summary",
+                "selector_work",
+                "selected_flow_current_count",
+            ],
+            json!(12),
+        ),
+        (
+            &[
+                "plan",
+                "inspection_summary",
+                "selector_work",
+                "contracted_attachment_count",
+            ],
+            json!(18),
+        ),
+    ];
+    for (path, replacement) in mutations {
+        let mut fixture = Fixture::new();
+        set_value(&mut fixture.manifest, path, replacement.clone());
+        assert!(
+            fixture.parse().is_err(),
+            "mutation unexpectedly passed: {path:?}"
+        );
+    }
+}
+
+#[test]
+fn runtime_options_accept_writer_valid_values_above_old_reader_ceilings() {
+    let mut fixture = Fixture::new();
+    fixture.manifest["runtime_options"]["point_tile_size"] = json!(1_048_577);
+    fixture.manifest["runtime_options"]["workspace_mib"] = json!(4097);
+
+    fixture.parse().unwrap();
+}
+
+#[test]
+fn interaction_evaluation_count_matches_the_persisted_plan() {
+    let mut fixture = Fixture::new();
+    fixture.manifest["dag_summary"]["interaction_evaluation_count"] = json!(24);
+    let error = fixture.parse().unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("exceeds"));
+
+    let mut fixture = Fixture::new();
+    fixture.manifest["dag_summary"]["interaction_evaluation_count"] = json!(16);
+    let error = fixture.parse().unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("disagree"));
+}
+
+#[test]
+fn materialization_census_matches_the_persisted_plan() {
+    for (path, replacement) in [
+        (
+            &["plan", "materialization_census", "basis"][..],
+            json!("dynamic"),
+        ),
+        (
+            &[
+                "plan",
+                "materialization_census",
+                "final",
+                "invocation_count",
+            ][..],
+            json!(16),
+        ),
+        (
+            &["plan", "materialization_census", "final_equals_peak"][..],
+            json!(false),
+        ),
+    ] {
+        let mut fixture = Fixture::new();
+        set_value(&mut fixture.manifest, path, replacement);
+        assert!(fixture.parse().is_err(), "{path:?}");
+    }
+}
+
+#[test]
+fn traversal_and_unknown_fields_are_rejected_during_manifest_parse() {
+    let mut fixture = Fixture::new();
+    fixture.manifest["plan"]["runtime_container"]["path"] = json!("../eager-runtime.pacbin");
+    assert_eq!(
+        fixture.parse().unwrap_err().kind(),
+        RusticolErrorKind::Security
+    );
+
+    let mut fixture = Fixture::new();
+    fixture.manifest["plan"]["runtime_container"]["extra"] = json!(1);
+    assert_eq!(
+        fixture.parse().unwrap_err().kind(),
+        RusticolErrorKind::Serialization
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn symlinked_runtime_container_is_rejected() {
+    use std::os::unix::fs::symlink;
+
+    let fixture = Fixture::new();
+    let manifest = fixture.parse().unwrap();
+    let path = fixture.root.join(EAGER_RUNTIME_CONTAINER_PATH);
+    let target = fixture.root.join("target.pacbin");
+    fs::rename(&path, &target).unwrap();
+    symlink(&target, &path).unwrap();
+    let error = open_fixture_runtime_container(&fixture.root, &manifest).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Security);
+}
+
+#[test]
+fn payload_digest_mismatch_is_rejected_before_container_use() {
+    let mut fixture = Fixture::new();
+    fixture.manifest["plan"]["runtime_container"]["sha256"] = json!("0".repeat(64));
+    let manifest = fixture.parse().unwrap();
+    let error = open_fixture_runtime_container(&fixture.root, &manifest).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("payload digest mismatch"));
+}
+
+#[test]
+fn index_and_unpacked_metadata_must_match_container() {
+    for (field, value) in [
+        ("index_sha256", json!("0".repeat(64))),
+        ("unpacked_size_bytes", json!(1)),
+    ] {
+        let mut fixture = Fixture::new();
+        fixture.manifest["plan"]["runtime_container"][field] = value;
+        let manifest = fixture.parse().unwrap();
+        let error = open_fixture_runtime_container(&fixture.root, &manifest).unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Integrity, "{field}");
+    }
+
+    let mut fixture = Fixture::new();
+    let declared = fixture.manifest["plan"]["runtime_container"]["size_bytes"]
+        .as_u64()
+        .unwrap();
+    fixture.manifest["plan"]["runtime_container"]["size_bytes"] = json!(declared + 1);
+    let manifest = fixture.parse().unwrap();
+    assert_eq!(
+        open_fixture_runtime_container(&fixture.root, &manifest)
+            .unwrap_err()
+            .kind(),
+        RusticolErrorKind::Integrity
+    );
+}
+
+#[test]
+fn incorrect_section_kind_is_rejected() {
+    let mut fixture = Fixture::new();
+    let metadata = write_container_with_section_override(
+        &fixture.root,
+        "tables/values.bin",
+        EagerSectionKind::CurrentLayout,
+    );
+    fixture.manifest = manifest_value(&fixture.outer, &metadata);
+    let manifest = fixture.parse().unwrap();
+    let error = open_fixture_runtime_container(&fixture.root, &manifest).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("section kind"));
+}
+
+#[test]
+fn unexpected_member_path_is_rejected() {
+    let mut fixture = Fixture::new();
+    let metadata = write_container(
+        &fixture.root,
+        Some(("tables/values.bin", "tables/unexpected.bin")),
+        None,
+    );
+    fixture.manifest = manifest_value(&fixture.outer, &metadata);
+    let manifest = fixture.parse().unwrap();
+    let error = open_fixture_runtime_container(&fixture.root, &manifest).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Security);
+    assert!(error.to_string().contains("unexpected"));
+}
+
+#[test]
+fn incorrect_member_kind_is_rejected() {
+    let mut fixture = Fixture::new();
+    let metadata = write_container(
+        &fixture.root,
+        None,
+        Some((
+            "tables/values.bin",
+            crate::pacbin::PacbinMemberKind::EagerRuntimeMetadata,
+        )),
+    );
+    fixture.manifest = manifest_value(&fixture.outer, &metadata);
+    let manifest = fixture.parse().unwrap();
+    let error = open_fixture_runtime_container(&fixture.root, &manifest).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("has kind"));
+}
+
+#[test]
+fn legacy_plan_v2_reports_regeneration_before_large_manifest_parse() {
+    let outer = outer_process();
+    let mut bytes = br#"{"eager_plan_abi":"pyamplicol-eager-plan-v2","kind":"pyamplicol-runtime-eager-execution","runtime_schema":"#
+        .to_vec();
+    bytes.extend(std::iter::repeat_n(b'x', 2 * 1024 * 1024));
+    bytes.extend_from_slice(br#""}"#);
+    let error = parse_eager_v3_execution_manifest(&bytes, &outer).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Compatibility);
+    assert!(error.to_string().contains("regenerate"));
+    assert!(error.to_string().contains("plan-v2"));
+}
+
+fn outer_process() -> ArtifactProcess {
+    ArtifactProcess {
+        id: "d_dbar_to_z_g".to_string(),
+        expression: "d d~ > z g".to_string(),
+        color_accuracy: "full".to_string(),
+        external_pdgs: vec![1, -1, 23, 21],
+        physics_path: "physics.json".to_string(),
+        required_runtime_capabilities: direct_capabilities(),
+        aliases: Vec::new(),
+    }
+}
+
+fn manifest_value(outer: &ArtifactProcess, metadata: &ContainerMetadata) -> Value {
+    let capabilities = json!(direct_capabilities());
+    json!({
+        "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+        "kind": EAGER_EXECUTION_KIND,
+        "required_runtime_capabilities": capabilities,
+        "process": outer.expression,
+        "key": outer.id,
+        "color_accuracy": outer.color_accuracy,
+        "external_pdg_order": outer.external_pdgs,
+        "eager_plan_abi": EAGER_PLAN_ABI,
+        "kernel_pack": {
+            "manifest_path": EAGER_KERNEL_PACK_MANIFEST_PATH,
+            "payload_root": EAGER_KERNEL_PAYLOAD_ROOT,
+        },
+        "runtime_options": {"point_tile_size": 1024, "workspace_mib": 256},
+        "plan": {
+            "kind": EAGER_EXECUTION_KIND,
+            "eager_plan_abi": EAGER_PLAN_ABI,
+            "lowering_input_abi": EAGER_LOWERING_INPUT_ABI,
+            "lowering_input_sha256": "1".repeat(64),
+            "runtime_layout_abi": EAGER_RUNTIME_LAYOUT_ABI,
+            "required_runtime_capabilities": capabilities,
+            "runtime_container": {
+                "kind": EAGER_RUNTIME_CONTAINER_KIND,
+                "schema_version": EAGER_RUNTIME_CONTAINER_SCHEMA,
+                "storage_abi": EAGER_RUNTIME_STORAGE_ABI,
+                "path": EAGER_RUNTIME_CONTAINER_PATH,
+                "size_bytes": metadata.size_bytes,
+                "sha256": metadata.sha256,
+                "member_count": metadata.member_count,
+                "unpacked_size_bytes": metadata.unpacked_size_bytes,
+                "index_sha256": metadata.index_sha256,
+            },
+            "inspection_summary": inspection_summary(outer),
+            "materialization_census": materialization_census(),
+        },
+        "dag_summary": {
+            "current_count": 11,
+            "source_count": 4,
+            "interaction_count": 23,
+            "interaction_evaluation_count": 17,
+            "amplitude_root_count": 5,
+            "truncated": false,
+        },
+    })
+}
+
+fn materialization_census() -> Value {
+    let counts = json!({
+        "source_count": 4,
+        "current_count": 11,
+        "interaction_count": 23,
+        "amplitude_root_count": 5,
+        "invocation_count": 17,
+        "attachment_count": 19,
+        "closure_count": 5,
+        "finalization_count": 11,
+    });
+    json!({
+        "abi": "pyamplicol-fully-resident-materialization-census-v1",
+        "basis": "immutable-fully-resident-eager-plan",
+        "final": counts.clone(),
+        "peak": counts,
+        "final_equals_peak": true,
+    })
+}
+
+fn direct_capabilities() -> Vec<String> {
+    vec![
+        EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY.to_string(),
+        EAGER_RUNTIME_CAPABILITY.to_string(),
+    ]
+}
+
+fn inspection_summary(outer: &ArtifactProcess) -> Value {
+    json!({
+        "execution_mode": "eager",
+        "eager_plan_abi": EAGER_PLAN_ABI,
+        "runtime_layout_abi": EAGER_RUNTIME_LAYOUT_ABI,
+        "process_id": outer.id,
+        "model_name": "built-in-sm",
+        "current_count": 11,
+        "value_count": 12,
+        "momentum_count": 13,
+        "source_count": 4,
+        "parameter_count": 5,
+        "stage_count": 3,
+        "coupling_count": 7,
+        "invocation_count": 17,
+        "attachment_count": 19,
+        "finalization_count": 11,
+        "closure_count": 5,
+        "selector_domain_count": 2,
+        "reduction_group_count": 3,
+        "reduction_entry_count": 9,
+        "retained_table_count": 21,
+        "current_component_count": 31,
+        "value_component_count": 37,
+        "momentum_component_count": 41,
+        "selector_work": {
+            "abi": "pyamplicol-eager-selector-work-v1",
+            "selected_flow_selector_count": 3,
+            "selected_flow_current_count": 7,
+            "selected_flow_evaluation_count": 9,
+            "selected_flow_attachment_count": 9,
+            "all_flow_selector_count": 5,
+            "all_flow_current_count": 8,
+            "all_flow_evaluation_count": 10,
+            "all_flow_attachment_count": 10,
+            "contracted_current_count": 11,
+            "contracted_evaluation_count": 17,
+            "contracted_attachment_count": 19,
+        },
+    })
+}
+
+fn write_container(
+    root: &Path,
+    path_override: Option<(&str, &str)>,
+    kind_override: Option<(&str, crate::pacbin::PacbinMemberKind)>,
+) -> ContainerMetadata {
+    let mut payloads = Vec::with_capacity(EXPECTED_EAGER_MEMBERS.len());
+    for expected in EXPECTED_EAGER_MEMBERS {
+        payloads.push(
+            EagerSectionHeader::new(expected.section_kind, 1, 0)
+                .unwrap()
+                .encode()
+                .to_vec(),
+        );
+    }
+    assert!(
+        payloads
+            .iter()
+            .all(|payload| payload.len() == EAGER_SECTION_HEADER_SIZE)
+    );
+    let mut members = Vec::with_capacity(EXPECTED_EAGER_MEMBERS.len());
+    for (expected, payload) in EXPECTED_EAGER_MEMBERS.iter().zip(&payloads) {
+        let path = path_override
+            .filter(|(original, _)| *original == expected.path)
+            .map_or(expected.path, |(_, replacement)| replacement);
+        let kind = kind_override
+            .filter(|(original, _)| *original == expected.path)
+            .map_or(expected.member_kind, |(_, replacement)| replacement);
+        members.push(PacbinWriteMember::from_bytes(path, kind, payload).unwrap());
+    }
+    let path = root.join(EAGER_RUNTIME_CONTAINER_PATH);
+    let index = write_pacbin_atomic(&path, members, PacbinWriteOptions::default()).unwrap();
+    let bytes = fs::read(&path).unwrap();
+    ContainerMetadata {
+        size_bytes: bytes.len() as u64,
+        sha256: hex_sha256(&bytes),
+        member_count: index.members().len() as u64,
+        unpacked_size_bytes: index.members().iter().map(|member| member.length()).sum(),
+        index_sha256: hex_bytes(index.index_sha256()),
+    }
+}
+
+fn write_container_with_section_override(
+    root: &Path,
+    override_path: &str,
+    override_kind: EagerSectionKind,
+) -> ContainerMetadata {
+    let mut payloads = Vec::with_capacity(EXPECTED_EAGER_MEMBERS.len());
+    for expected in EXPECTED_EAGER_MEMBERS {
+        let section_kind = if expected.path == override_path {
+            override_kind
+        } else {
+            expected.section_kind
+        };
+        payloads.push(
+            EagerSectionHeader::new(section_kind, 1, 0)
+                .unwrap()
+                .encode()
+                .to_vec(),
+        );
+    }
+    let members: Vec<_> = EXPECTED_EAGER_MEMBERS
+        .iter()
+        .zip(&payloads)
+        .map(|(expected, payload)| {
+            PacbinWriteMember::from_bytes(expected.path, expected.member_kind, payload).unwrap()
+        })
+        .collect();
+    let path = root.join(EAGER_RUNTIME_CONTAINER_PATH);
+    let index = write_pacbin_atomic(&path, members, PacbinWriteOptions::default()).unwrap();
+    let bytes = fs::read(&path).unwrap();
+    ContainerMetadata {
+        size_bytes: bytes.len() as u64,
+        sha256: hex_sha256(&bytes),
+        member_count: index.members().len() as u64,
+        unpacked_size_bytes: index.members().iter().map(|member| member.length()).sum(),
+        index_sha256: hex_bytes(index.index_sha256()),
+    }
+}
+
+fn set_value(root: &mut Value, path: &[&str], replacement: Value) {
+    let (last, parents) = path.split_last().unwrap();
+    let mut current = root;
+    for name in parents {
+        current = &mut current[*name];
+    }
+    current[*last] = replacement;
+}
+
+fn hex_sha256(bytes: &[u8]) -> String {
+    hex_bytes(&Sha256::digest(bytes))
+}
+
+fn hex_bytes(bytes: &[u8]) -> String {
+    bytes.iter().map(|byte| format!("{byte:02x}")).collect()
+}
+
+fn temporary_directory() -> PathBuf {
+    let sequence = NEXT_DIRECTORY.fetch_add(1, Ordering::Relaxed);
+    std::env::temp_dir().join(format!(
+        "rusticol-eager-v3-manifest-{}-{sequence}",
+        std::process::id()
+    ))
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/evaluation.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/evaluation.rs
new file mode 100644
index 0000000000..7bb044cdc1
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/evaluation.rs
@@ -0,0 +1,3250 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn evaluate_direct_color_schedule(
+    direct: &mut compiled_direct_prototype::CompiledDirectEnginePrototype,
+    schedules: &BTreeMap<i64, compiled_direct_prototype::CompiledDirectValidatedSchedule>,
+    selected_color_sector_ids: Option<&BTreeSet<i64>>,
+    point_count: usize,
+) -> RusticolResult<()> {
+    let Some(selected) = selected_color_sector_ids else {
+        return direct.evaluate_all(point_count);
+    };
+    if selected.is_empty() {
+        return Err(RusticolError::invalid_argument(
+            "compiled Direct-Arena color selection cannot be empty",
+        ));
+    }
+    if selected.len() == 1 {
+        let sector_id = *selected
+            .iter()
+            .next()
+            .expect("singleton color selection checked");
+        let schedule = schedules.get(&sector_id).ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "compiled Direct-Arena has no cold-bound schedule for materialized sector {sector_id}"
+            ))
+        })?;
+        return direct.evaluate_validated(point_count, schedule);
+    }
+    for sector_id in selected {
+        if !schedules.contains_key(sector_id) {
+            return Err(RusticolError::integrity(format!(
+                "compiled Direct-Arena has no cold-bound schedule for materialized sector {sector_id}"
+            )));
+        }
+    }
+    // A multi-sector union is uncommon and has no exponential subset cache.
+    // Executing the full authenticated schedule preserves semantics without a
+    // hot-path allocation; the reducer still selects exactly the requested
+    // materialized sectors.
+    direct.evaluate_all(point_count)
+}
+
+impl ExecutionRuntime {
+    fn has_compiled_symmetric_group_diagnostic(&self) -> bool {
+        self.amplitude_stage.as_ref().is_some_and(|amplitude| {
+            amplitude
+                .color_contraction
+                .as_ref()
+                .is_some_and(ColorContractionRuntime::is_symmetric_group)
+        })
+    }
+
+    fn compiled_symmetric_group_unsupported(&self, operation: &str) -> RusticolError {
+        RusticolError::compatibility(format!(
+            "compiled symmetric-group FFT diagnostic does not support {operation}; use unselected f64 total evaluation"
+        ))
+    }
+
+    fn use_helicity_sum_runtime_for_selection(
+        &self,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+    ) -> bool {
+        self.helicity_sum_runtime.is_some()
+            && (selected_helicity_ids.is_none()
+                || self
+                    .physics
+                    .as_ref()
+                    .is_some_and(|physics| physics.has_contracted_color_axis()))
+    }
+
+    pub(super) fn set_lc_sector_selector(&mut self, sector_id: Option<i64>) -> Option<f64> {
+        let index = *self
+            .model_parameter_name_to_index
+            .get(LC_SECTOR_SELECTOR_PARAMETER)?;
+        let previous = *self.model_parameter_values_f64.get(index)?;
+        if let Some(value) = self.model_parameter_values_f64.get_mut(index) {
+            *value = sector_id.map(|id| id as f64).unwrap_or(-1.0);
+        }
+        Some(previous)
+    }
+
+    pub(super) fn restore_lc_sector_selector(&mut self, previous: Option<f64>) {
+        let Some(previous) = previous else {
+            return;
+        };
+        let Some(index) = self
+            .model_parameter_name_to_index
+            .get(LC_SECTOR_SELECTOR_PARAMETER)
+            .copied()
+        else {
+            return;
+        };
+        if let Some(value) = self.model_parameter_values_f64.get_mut(index) {
+            *value = previous;
+        }
+    }
+
+    #[allow(dead_code)] // Allocating compatibility wrapper around the into lane.
+    pub(super) fn run_f64_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+    ) -> RusticolResult<Vec<f64>> {
+        let mut output = vec![0.0; batch.point_count()];
+        self.run_f64_into_unprofiled(batch, &mut output)?;
+        Ok(output)
+    }
+
+    pub(super) fn run_f64_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        self.run_f64_selected_into_unprofiled(batch, None, None, output)
+    }
+
+    /// Test-only oracle retaining the pre-optimization resolved topology-replay
+    /// path while using the same loaded compiled Direct engines.
+    #[cfg(test)]
+    pub(super) fn run_f64_selected_into_resolved_replay_oracle(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        if output.len() != batch.point_count() {
+            return Err(RusticolError::invalid_argument(format!(
+                "evaluation output has length {}, expected {}",
+                output.len(),
+                batch.point_count()
+            )));
+        }
+        if selected_helicity_ids.is_none()
+            && let Some(sum_runtime) = self.helicity_sum_runtime.as_mut()
+        {
+            return sum_runtime.run_f64_selected_into_resolved_replay_oracle(
+                batch,
+                None,
+                selected_color_ids,
+                output,
+            );
+        }
+        if !self.lc_topology_replay_enabled {
+            return Err(RusticolError::invalid_argument(
+                "resolved topology-replay oracle requires an LC replay runtime",
+            ));
+        }
+        let resolved = self.run_resolved_f64_with_lc_topology_replay_unprofiled(
+            batch,
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        write_resolved_f64_totals(&resolved, output)
+    }
+
+    pub(super) fn run_f64_selected_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        if output.len() != batch.point_count() {
+            return Err(RusticolError::invalid_argument(format!(
+                "evaluation output has length {}, expected {}",
+                output.len(),
+                batch.point_count()
+            )));
+        }
+        if self.has_compiled_symmetric_group_diagnostic()
+            && (selected_helicity_ids.is_some() || selected_color_ids.is_some())
+        {
+            return Err(self.compiled_symmetric_group_unsupported("runtime selectors"));
+        }
+        let (selected_helicity_ids, selected_color_ids) =
+            self.physics
+                .as_ref()
+                .map_or((selected_helicity_ids, selected_color_ids), |physics| {
+                    (
+                        physics.canonical_total_helicity_selector(selected_helicity_ids),
+                        physics.canonical_total_color_selector(selected_color_ids),
+                    )
+                });
+        if self.has_safe_singleton_helicity_execution(selected_helicity_ids, selected_color_ids)?
+            && self.try_run_f64_with_helicity_recurrence_into_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                output,
+            )?
+        {
+            return Ok(());
+        }
+        if self.use_helicity_sum_runtime_for_selection(selected_helicity_ids)
+            && let Some(sum_runtime) = self.helicity_sum_runtime.as_mut()
+        {
+            return sum_runtime.run_f64_selected_into_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                output,
+            );
+        }
+        if self.color_topology_replay_enabled {
+            if selected_helicity_ids.is_some() || selected_color_ids.is_some() {
+                let resolved = self.run_resolved_f64_with_color_topology_replay_unprofiled(
+                    batch,
+                    selected_helicity_ids,
+                    selected_color_ids,
+                )?;
+                return write_resolved_f64_totals(&resolved, output);
+            }
+            return self.run_f64_with_color_topology_replay_into_unprofiled(batch, output);
+        }
+        if self.lc_topology_replay_enabled {
+            if selected_color_ids.is_some_and(|ids| ids.len() == 1)
+                && self.try_run_f64_with_single_lc_topology_replay_into_unprofiled(
+                    batch,
+                    selected_helicity_ids,
+                    selected_color_ids,
+                    output,
+                )?
+            {
+                return Ok(());
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            if self.try_run_f64_with_lc_topology_replay_totals_into_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                output,
+            )? {
+                return Ok(());
+            }
+            let resolved = self.run_resolved_f64_with_lc_topology_replay_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            )?;
+            return write_resolved_f64_totals(&resolved, output);
+        }
+        if self.has_compiled_helicity_execution_plan() {
+            if self.try_run_f64_with_helicity_recurrence_into_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                output,
+            )? {
+                return Ok(());
+            }
+            let resolved = self.run_resolved_f64_with_helicity_recurrence_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                None,
+            )?;
+            return write_resolved_f64_totals(&resolved, output);
+        }
+        if selected_helicity_ids.is_some() || selected_color_ids.is_some() {
+            let resolved =
+                self.run_resolved_f64_unprofiled(batch, selected_helicity_ids, selected_color_ids)?;
+            return write_resolved_f64_totals(&resolved, output);
+        }
+        let previous = self.set_lc_sector_selector(None);
+        let result = self.run_f64_materialized_selected_into_unprofiled(batch, None, output);
+        self.restore_lc_sector_selector(previous);
+        result
+    }
+
+    pub(super) fn run_resolved_f64_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        if self.has_compiled_symmetric_group_diagnostic() {
+            return Err(self.compiled_symmetric_group_unsupported("resolved evaluation"));
+        }
+        if self.has_safe_singleton_helicity_execution(selected_helicity_ids, selected_color_ids)? {
+            return self.run_resolved_f64_with_helicity_recurrence_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                None,
+            );
+        }
+        if self.use_helicity_sum_runtime_for_selection(selected_helicity_ids)
+            && let Some(sum_runtime) = self.helicity_sum_runtime.as_mut()
+        {
+            return sum_runtime.run_resolved_f64_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        if self.color_topology_replay_enabled {
+            return self.run_resolved_f64_with_color_topology_replay_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        if self.lc_topology_replay_enabled {
+            return self.run_resolved_f64_with_lc_topology_replay_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        if self.has_compiled_helicity_execution_plan() {
+            return self.run_resolved_f64_with_helicity_recurrence_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                None,
+            );
+        }
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let selected_color_lane = if selected_color_ids.is_some_and(|ids| ids.len() == 1) {
+            self.lc_materialized_sector_ids_for_color_ids(
+                physics.as_ref(),
+                selected_color_ids.expect("singleton selection checked"),
+            )?
+            .into_iter()
+            .next()
+        } else {
+            None
+        };
+        if let Some(sector_id) = selected_color_lane
+            && let Some(selector_runtime) = self.color_selector_runtimes.get_mut(&sector_id)
+        {
+            return selector_runtime.run_resolved_f64_unprofiled(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if self.compiled_direct_runtime.is_some() {
+            return self.run_f64_materialized_selected_direct_resolved_unprofiled(
+                batch,
+                &physics,
+                selected_helicity_ids,
+                selected_color_ids,
+                None,
+            );
+        }
+        self.run_f64_materialized_selected_for_resolved_unprofiled(batch, None)?;
+        self.amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked")
+            .reduce_scratch_f64_resolved(
+                batch.point_count(),
+                &physics,
+                self.normalization_factor,
+                selected_helicity_ids,
+                selected_color_ids,
+            )
+    }
+
+    fn run_f64_with_color_topology_replay_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        if output.len() != batch.point_count() {
+            return Err(RusticolError::invalid_argument(
+                "color topology replay output shape is inconsistent",
+            ));
+        }
+        let mappings = Arc::clone(&self.color_topology_replay_mappings);
+        self.amplitude_stage
+            .as_mut()
+            .ok_or_else(|| {
+                RusticolError::integrity("color topology replay has no executable amplitude stage")
+            })?
+            .begin_color_topology_replay(batch.point_count())?;
+        let mut flat_momenta = std::mem::take(&mut self.color_replay_flat_momenta_scratch);
+        let result = (|| {
+            for (mapping_index, mapping) in mappings.iter().enumerate() {
+                let evaluation_view = if mapping.is_empty() {
+                    batch
+                } else {
+                    apply_lc_topology_label_permutation_from_view_into_flat(
+                        batch,
+                        self.external_count,
+                        mapping,
+                        &mut flat_momenta,
+                    )?;
+                    F64MomentumBatchView::from_contiguous_prevalidated(
+                        &flat_momenta,
+                        batch.point_count(),
+                        self.external_count,
+                        None,
+                    )?
+                };
+                self.evaluate_color_topology_replay_mapping_unprofiled(
+                    evaluation_view,
+                    mapping_index,
+                )?;
+            }
+            self.amplitude_stage
+                .as_mut()
+                .expect("color topology replay amplitude stage preflighted")
+                .reduce_color_topology_replay_f64_into(batch.point_count(), output)?;
+            if self.normalization_factor != 1.0 {
+                for value in output {
+                    *value *= self.normalization_factor;
+                }
+            }
+            Ok(())
+        })();
+        self.color_replay_flat_momenta_scratch = flat_momenta;
+        result
+    }
+
+    fn run_resolved_f64_with_color_topology_replay_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("color topology replay requires resolved physics metadata")
+        })?;
+        let mappings = Arc::clone(&self.color_topology_replay_mappings);
+        self.amplitude_stage
+            .as_mut()
+            .ok_or_else(|| {
+                RusticolError::integrity("color topology replay has no executable amplitude stage")
+            })?
+            .begin_color_topology_replay(batch.point_count())?;
+        let mut flat_momenta = std::mem::take(&mut self.color_replay_flat_momenta_scratch);
+        let result = (|| {
+            for (mapping_index, mapping) in mappings.iter().enumerate() {
+                let evaluation_view = if mapping.is_empty() {
+                    batch
+                } else {
+                    apply_lc_topology_label_permutation_from_view_into_flat(
+                        batch,
+                        self.external_count,
+                        mapping,
+                        &mut flat_momenta,
+                    )?;
+                    F64MomentumBatchView::from_contiguous_prevalidated(
+                        &flat_momenta,
+                        batch.point_count(),
+                        self.external_count,
+                        None,
+                    )?
+                };
+                self.evaluate_color_topology_replay_mapping_unprofiled(
+                    evaluation_view,
+                    mapping_index,
+                )?;
+            }
+            self.amplitude_stage
+                .as_mut()
+                .expect("color topology replay amplitude stage preflighted")
+                .reduce_color_topology_replay_f64_resolved(
+                    batch.point_count(),
+                    &physics,
+                    self.normalization_factor,
+                    selected_helicity_ids,
+                    selected_color_ids,
+                )
+        })();
+        self.color_replay_flat_momenta_scratch = flat_momenta;
+        result
+    }
+
+    fn evaluate_color_topology_replay_mapping_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        mapping_index: usize,
+    ) -> RusticolResult<()> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if self.compiled_direct_runtime.is_some() {
+            let Self {
+                compiled_direct_runtime: Some(direct),
+                sources,
+                external_count,
+                particle_masses,
+                momentum_slots,
+                external_is_initial,
+                model_parameter_values_f64,
+                amplitude_stage: Some(amplitude),
+                ..
+            } = self
+            else {
+                return Err(RusticolError::integrity(
+                    "compiled color replay selected an incomplete Direct-Arena runtime",
+                ));
+            };
+            let tile_capacity = direct.tile_capacity();
+            let mut point_start = 0usize;
+            while point_start < batch.point_count() {
+                let point_stop = (point_start + tile_capacity).min(batch.point_count());
+                let tile = batch.subview(point_start, point_stop)?;
+                direct.begin_tile_from_inputs(
+                    tile,
+                    sources,
+                    None,
+                    *external_count,
+                    particle_masses,
+                    momentum_slots,
+                    external_is_initial,
+                    model_parameter_values_f64,
+                )?;
+                direct.evaluate_all(point_stop - point_start)?;
+                amplitude.gather_color_topology_replay_planes(
+                    direct.amplitude_planes()?,
+                    point_start,
+                    mapping_index,
+                )?;
+                point_start = point_stop;
+            }
+            return Ok(());
+        }
+        self.run_f64_materialized_selected_for_resolved_unprofiled(batch, None)?;
+        self.amplitude_stage
+            .as_mut()
+            .expect("color topology replay amplitude stage checked")
+            .gather_color_topology_replay_mapping(batch.point_count(), mapping_index)
+    }
+
+    fn run_resolved_f64_with_lc_topology_replay_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let replay_plan = self.cached_lc_resolved_replay_plan(&physics)?;
+        let selection = self.cached_lc_resolved_replay_selection(
+            &physics,
+            replay_plan.as_ref(),
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        let n_points = batch.point_count();
+        let component_count = selection.helicity_indices.len() * selection.color_indices.len();
+        let mut full_values = vec![0.0; n_points * component_count];
+        let mappings = self.lc_topology_replay_mappings.clone();
+        let mappings_per_chunk = replay_mappings_per_expanded_batch(n_points);
+        for source_group in &selection.source_groups {
+            let materialized_sector_ids =
+                self.lc_materialized_sector_ids_for_color_ids(&physics, &source_group.color_ids)?;
+            for chunk_start in (0..source_group.mapping_indices.len()).step_by(mappings_per_chunk) {
+                let chunk_end = usize::min(
+                    chunk_start + mappings_per_chunk,
+                    source_group.mapping_indices.len(),
+                );
+                let mapping_chunk = source_group.mapping_indices[chunk_start..chunk_end]
+                    .iter()
+                    .map(|mapping_index| mappings[*mapping_index].clone())
+                    .collect::<Vec<_>>();
+                let entry_chunk = &source_group.entries[chunk_start..chunk_end];
+                let expanded_batch = if mapping_chunk.len() == 1 && mapping_chunk[0].is_empty() {
+                    None
+                } else {
+                    Some(apply_lc_topology_label_permutations_from_view(
+                        batch,
+                        self.external_count,
+                        &mapping_chunk,
+                    )?)
+                };
+                let evaluation_view = if let Some(expanded_batch) = expanded_batch.as_deref() {
+                    F64MomentumBatchView::from_nested(expanded_batch, self.external_count)?
+                } else {
+                    batch
+                };
+                let selected_lane_id = (materialized_sector_ids.len() == 1)
+                    .then(|| materialized_sector_ids.iter().next().copied())
+                    .flatten();
+                let materialized = if self.has_compiled_helicity_execution_plan()
+                    && selected_helicity_ids.is_some()
+                {
+                    self.run_resolved_f64_with_helicity_recurrence_unprofiled(
+                        evaluation_view,
+                        Some(&source_group.helicity_ids),
+                        Some(&source_group.color_ids),
+                        Some(&materialized_sector_ids),
+                    )?
+                } else if let Some(selector_runtime) = selected_lane_id
+                    .and_then(|sector_id| self.color_selector_runtimes.get_mut(&sector_id))
+                {
+                    selector_runtime.run_resolved_f64_unprofiled(
+                        evaluation_view,
+                        Some(&source_group.helicity_ids),
+                        Some(&source_group.color_ids),
+                    )?
+                } else {
+                    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                    if self.compiled_direct_runtime.is_some() {
+                        self.run_f64_materialized_selected_direct_resolved_unprofiled(
+                            evaluation_view,
+                            &physics,
+                            Some(&source_group.helicity_ids),
+                            Some(&source_group.color_ids),
+                            Some(&materialized_sector_ids),
+                        )?
+                    } else {
+                        self.run_f64_materialized_selected_for_resolved_unprofiled(
+                            evaluation_view,
+                            Some(&materialized_sector_ids),
+                        )?;
+                        self.amplitude_stage
+                            .as_mut()
+                            .expect("generic amplitude stage checked")
+                            .reduce_scratch_f64_resolved(
+                                evaluation_view.point_count(),
+                                &physics,
+                                self.normalization_factor,
+                                Some(&source_group.helicity_ids),
+                                Some(&source_group.color_ids),
+                            )?
+                    }
+                    #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+                    {
+                        self.run_f64_materialized_selected_for_resolved_unprofiled(
+                            evaluation_view,
+                            Some(&materialized_sector_ids),
+                        )?;
+                        self.amplitude_stage
+                            .as_mut()
+                            .expect("generic amplitude stage checked")
+                            .reduce_scratch_f64_resolved(
+                                evaluation_view.point_count(),
+                                &physics,
+                                self.normalization_factor,
+                                Some(&source_group.helicity_ids),
+                                Some(&source_group.color_ids),
+                            )?
+                    }
+                };
+                accumulate_selected_lc_replay_resolved_f64(
+                    &mut full_values,
+                    n_points,
+                    &materialized,
+                    entry_chunk,
+                    source_group.source_component_count,
+                    component_count,
+                )?;
+            }
+        }
+        Ok(ResolvedValues {
+            values: full_values,
+            point_count: n_points,
+            helicity_indices: selection.helicity_indices.clone(),
+            color_indices: selection.color_indices.clone(),
+        })
+    }
+
+    /// Execute the dominant complete-layout selector shape without resolved
+    /// batch tensors: one requested public flow, replayed by one topology
+    /// mapping through one fused-helicity materialized-flow lane.
+    ///
+    /// Multiple mappings or recursive execution plans retain the resolved
+    /// fallback because their target cells must survive across evaluations to
+    /// preserve exact accumulation order.
+    fn try_run_f64_with_single_lc_topology_replay_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<bool> {
+        // A fused colour lane computes the complete helicity axis. With an
+        // explicit helicity selection, retain the parent's pruned schedule
+        // and map the selected physical flow before executing it instead.
+        if selected_helicity_ids.is_some() && self.has_compiled_helicity_execution_plan() {
+            return Ok(false);
+        }
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let replay_plan = self.cached_lc_resolved_replay_plan(&physics)?;
+        let selection = self.cached_lc_resolved_replay_selection(
+            &physics,
+            replay_plan.as_ref(),
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        let [source_group] = selection.source_groups.as_slice() else {
+            return Ok(false);
+        };
+        let [mapping_index] = source_group.mapping_indices.as_slice() else {
+            return Ok(false);
+        };
+        let [replay_entry] = source_group.entries.as_slice() else {
+            return Ok(false);
+        };
+        let materialized_sector_ids =
+            source_group
+                .materialized_sector_ids
+                .as_ref()
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "LC topology replay selection is missing its materialized-sector cache",
+                    )
+                })?;
+        if materialized_sector_ids.len() != 1 {
+            return Ok(false);
+        }
+        let materialized_sector_id = *materialized_sector_ids
+            .iter()
+            .next()
+            .expect("singleton materialized sector checked");
+        let Some(selector_runtime) = self.color_selector_runtimes.get(&materialized_sector_id)
+        else {
+            return Ok(false);
+        };
+        if selector_runtime.helicity_sum_runtime.is_some()
+            || selector_runtime.lc_topology_replay_enabled
+            || selector_runtime.has_compiled_helicity_execution_plan()
+            || selector_runtime
+                .amplitude_stage
+                .as_ref()
+                .is_none_or(|amplitude| amplitude.color_contraction.is_some())
+        {
+            return Ok(false);
+        }
+
+        let target_component_count = selection
+            .helicity_indices
+            .len()
+            .checked_mul(selection.color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        let mappings = Arc::clone(&self.lc_topology_replay_mappings);
+        let mapping = mappings.get(*mapping_index).ok_or_else(|| {
+            RusticolError::integrity("LC topology replay selection references an unknown mapping")
+        })?;
+        let mut flat_momenta = std::mem::take(&mut self.lc_replay_flat_momenta_scratch);
+        let result = (|| {
+            let evaluation_view = if mapping.is_empty() {
+                batch
+            } else {
+                apply_lc_topology_label_permutation_from_view_into_flat(
+                    batch,
+                    self.external_count,
+                    mapping,
+                    &mut flat_momenta,
+                )?;
+                F64MomentumBatchView::from_contiguous_prevalidated(
+                    &flat_momenta,
+                    batch.point_count(),
+                    self.external_count,
+                    None,
+                )?
+            };
+            if let Some(direct_plan) = source_group.direct_total_plan {
+                if direct_plan.mapping_index != *mapping_index
+                    || direct_plan.materialized_sector_id != materialized_sector_id
+                {
+                    return Err(RusticolError::integrity(
+                        "LC topology replay direct-total plan disagrees with its selected source",
+                    ));
+                }
+                self.color_selector_runtimes
+                    .get_mut(&materialized_sector_id)
+                    .expect("selector lane checked above")
+                    .run_f64_into_unprofiled(evaluation_view, output)?;
+                if direct_plan.scale != 1.0 {
+                    for value in output {
+                        *value *= direct_plan.scale;
+                    }
+                }
+                return Ok(true);
+            }
+            self.color_selector_runtimes
+                .get_mut(&materialized_sector_id)
+                .expect("selector lane checked above")
+                .run_f64_routed_materialized_into_unprofiled(
+                    evaluation_view,
+                    Some(&source_group.helicity_ids),
+                    Some(&source_group.color_ids),
+                    replay_entry,
+                    source_group.source_component_count,
+                    target_component_count,
+                    output,
+                )?;
+            Ok(true)
+        })();
+        self.lc_replay_flat_momenta_scratch = flat_momenta;
+        result
+    }
+
+    /// Execute arbitrary LC topology-replay totals through compiled arena
+    /// planes without constructing expanded nested momenta or `ResolvedValues`.
+    ///
+    /// One mapping is streamed at a time. Persistent point-major target
+    /// components retain the resolved contract's mapping accumulation and
+    /// final H-major/C-minor fold exactly.
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    fn try_run_f64_with_lc_topology_replay_totals_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<bool> {
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let replay_plan = self.cached_lc_resolved_replay_plan(&physics)?;
+        let selection = self.cached_lc_resolved_replay_selection(
+            &physics,
+            replay_plan.as_ref(),
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        let mappings = Arc::clone(&self.lc_topology_replay_mappings);
+        let target_component_count = selection
+            .helicity_indices
+            .len()
+            .checked_mul(selection.color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        let target_scalar_count = batch
+            .point_count()
+            .checked_mul(target_component_count)
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+
+        // Preflight every source before touching output, so unsupported
+        // configurations can retain the resolved compatibility path.
+        for source_group in &selection.source_groups {
+            if source_group.mapping_indices.len() != source_group.entries.len() {
+                return Err(RusticolError::integrity(
+                    "LC topology replay source has inconsistent mappings and routes",
+                ));
+            }
+            let materialized_sector_ids = source_group
+                .materialized_sector_ids
+                .as_ref()
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "LC topology replay selection is missing its materialized-sector cache",
+                    )
+                })?;
+            if self.has_compiled_helicity_execution_plan() && selected_helicity_ids.is_some() {
+                if self.compiled_direct_runtime.is_none()
+                    || source_group.helicity_ids.len() != 1
+                    || materialized_sector_ids.is_empty()
+                {
+                    return Ok(false);
+                }
+                continue;
+            }
+            let direct_selector_lane = (materialized_sector_ids.len() == 1)
+                .then(|| materialized_sector_ids.iter().next().copied())
+                .flatten()
+                .and_then(|sector_id| self.color_selector_runtimes.get(&sector_id))
+                .is_some_and(|runtime| runtime.compiled_direct_runtime.is_some());
+            if !direct_selector_lane && self.compiled_direct_runtime.is_none() {
+                return Ok(false);
+            }
+        }
+
+        let mut flat_momenta = std::mem::take(&mut self.lc_replay_flat_momenta_scratch);
+        let mut target_components = std::mem::take(&mut self.lc_replay_target_components_scratch);
+        target_components.resize(target_scalar_count, 0.0);
+        target_components.fill(0.0);
+        let result = (|| {
+            for source_group in &selection.source_groups {
+                let materialized_sector_ids = source_group
+                    .materialized_sector_ids
+                    .as_ref()
+                    .expect("topology-replay source cache preflighted");
+                for (mapping_index, replay_entry) in source_group
+                    .mapping_indices
+                    .iter()
+                    .copied()
+                    .zip(&source_group.entries)
+                {
+                    let mapping = mappings.get(mapping_index).ok_or_else(|| {
+                        RusticolError::integrity(
+                            "LC topology replay selection references an unknown mapping",
+                        )
+                    })?;
+                    let evaluation_view = if mapping.is_empty() {
+                        batch
+                    } else {
+                        apply_lc_topology_label_permutation_from_view_into_flat(
+                            batch,
+                            self.external_count,
+                            mapping,
+                            &mut flat_momenta,
+                        )?;
+                        F64MomentumBatchView::from_contiguous_prevalidated(
+                            &flat_momenta,
+                            batch.point_count(),
+                            self.external_count,
+                            None,
+                        )?
+                    };
+
+                    if self.has_compiled_helicity_execution_plan()
+                        && selected_helicity_ids.is_some()
+                    {
+                        self.run_f64_materialized_helicity_direct_routed_components_add_unprofiled(
+                            evaluation_view,
+                            &physics,
+                            &source_group.helicity_ids,
+                            Some(&source_group.color_ids),
+                            materialized_sector_ids,
+                            replay_entry,
+                            source_group.source_component_count,
+                            target_component_count,
+                            batch.point_count(),
+                            &mut target_components,
+                        )?;
+                        continue;
+                    }
+
+                    let selected_lane_id = (materialized_sector_ids.len() == 1)
+                        .then(|| materialized_sector_ids.iter().next().copied())
+                        .flatten()
+                        .filter(|sector_id| {
+                            self.color_selector_runtimes
+                                .get(sector_id)
+                                .is_some_and(|runtime| runtime.compiled_direct_runtime.is_some())
+                        });
+                    if let Some(sector_id) = selected_lane_id {
+                        self.color_selector_runtimes
+                            .get_mut(&sector_id)
+                            .expect("direct selector lane preflighted")
+                            .run_f64_routed_materialized_direct_components_add_unprofiled(
+                                evaluation_view,
+                                Some(&source_group.helicity_ids),
+                                Some(&source_group.color_ids),
+                                None,
+                                replay_entry,
+                                source_group.source_component_count,
+                                target_component_count,
+                                batch.point_count(),
+                                &mut target_components,
+                            )?;
+                    } else {
+                        self.run_f64_routed_materialized_direct_components_add_unprofiled(
+                            evaluation_view,
+                            Some(&source_group.helicity_ids),
+                            Some(&source_group.color_ids),
+                            Some(materialized_sector_ids),
+                            replay_entry,
+                            source_group.source_component_count,
+                            target_component_count,
+                            batch.point_count(),
+                            &mut target_components,
+                        )?;
+                    }
+                }
+            }
+            for (target, components) in output
+                .iter_mut()
+                .zip(target_components.chunks_exact(target_component_count))
+            {
+                *target = components.iter().sum();
+            }
+            Ok(true)
+        })();
+        self.lc_replay_flat_momenta_scratch = flat_momenta;
+        self.lc_replay_target_components_scratch = target_components;
+        result
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn run_f64_routed_materialized_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        replay_entry: &LcResolvedReplayEntry,
+        source_component_count: usize,
+        target_component_count: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        if self.helicity_sum_runtime.is_some()
+            || self.lc_topology_replay_enabled
+            || self.has_compiled_helicity_execution_plan()
+        {
+            return Err(RusticolError::integrity(
+                "routed direct totals require a materialized leaf execution lane",
+            ));
+        }
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if self.compiled_direct_runtime.is_some() {
+            return self.run_f64_routed_materialized_direct_into_unprofiled(
+                batch,
+                &physics,
+                selected_helicity_ids,
+                selected_color_ids,
+                replay_entry,
+                source_component_count,
+                target_component_count,
+                output,
+            );
+        }
+        self.run_f64_materialized_selected_for_resolved_unprofiled(batch, None)?;
+        self.amplitude_stage
+            .as_mut()
+            .expect("materialized leaf amplitude stage checked")
+            .reduce_scratch_f64_routed_totals_into(
+                batch.point_count(),
+                &physics,
+                self.normalization_factor,
+                selected_helicity_ids,
+                selected_color_ids,
+                replay_entry,
+                source_component_count,
+                target_component_count,
+                output,
+            )
+    }
+
+    #[allow(dead_code)] // Allocating compatibility wrapper around the into lane.
+    fn run_f64_materialized_selected_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<Vec<f64>> {
+        let mut output = vec![0.0; batch.point_count()];
+        self.run_f64_materialized_selected_into_unprofiled(
+            batch,
+            selected_color_sector_ids,
+            &mut output,
+        )?;
+        Ok(output)
+    }
+
+    fn run_f64_materialized_selected_for_resolved_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<()> {
+        self.evaluate_f64_materialized_selected_unprofiled(batch, selected_color_sector_ids)
+    }
+
+    fn run_f64_materialized_selected_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if self.compiled_direct_runtime.is_some() {
+            return self.run_f64_materialized_selected_direct_into_unprofiled(
+                batch,
+                selected_color_sector_ids,
+                output,
+            );
+        }
+        let n_points = batch.point_count();
+        if output.len() != n_points {
+            return Err(RusticolError::invalid_argument(format!(
+                "evaluation output has length {}, expected {n_points}",
+                output.len()
+            )));
+        }
+        self.evaluate_f64_materialized_selected_unprofiled(batch, selected_color_sector_ids)?;
+        self.amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked")
+            .reduce_scratch_f64_into_selected_slice(n_points, output, selected_color_sector_ids)?;
+        for value in output {
+            *value *= self.normalization_factor;
+        }
+        Ok(())
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    fn run_f64_materialized_selected_direct_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let point_count = batch.point_count();
+        if output.len() != point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "evaluation output has length {}, expected {point_count}",
+                output.len()
+            )));
+        }
+        let Self {
+            compiled_direct_runtime: Some(direct),
+            compiled_direct_color_schedules,
+            sources,
+            external_count,
+            particle_masses,
+            momentum_slots,
+            external_is_initial,
+            model_parameter_values_f64,
+            amplitude_stage: Some(amplitude),
+            normalization_factor,
+            ..
+        } = self
+        else {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena execution was selected without a complete runtime",
+            ));
+        };
+        let tile_capacity = if amplitude
+            .color_contraction
+            .as_ref()
+            .is_some_and(ColorContractionRuntime::is_symmetric_group)
+        {
+            direct.reduction_tile_capacity()
+        } else {
+            direct.tile_capacity()
+        };
+        let mut point_start = 0usize;
+        while point_start < point_count {
+            let point_stop = (point_start + tile_capacity).min(point_count);
+            let tile = batch.subview(point_start, point_stop)?;
+            direct.begin_tile_from_inputs(
+                tile,
+                sources,
+                None,
+                *external_count,
+                particle_masses,
+                momentum_slots,
+                external_is_initial,
+                model_parameter_values_f64,
+            )?;
+            evaluate_direct_color_schedule(
+                direct,
+                compiled_direct_color_schedules,
+                selected_color_sector_ids,
+                point_stop - point_start,
+            )?;
+            let planes = direct.amplitude_planes()?;
+            amplitude.reduce_planes_f64_into_selected_slice(
+                planes,
+                &mut output[point_start..point_stop],
+                selected_color_sector_ids,
+            )?;
+            if *normalization_factor != 1.0 {
+                for value in &mut output[point_start..point_stop] {
+                    *value *= *normalization_factor;
+                }
+            }
+            point_start = point_stop;
+        }
+        Ok(())
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[allow(clippy::too_many_arguments)]
+    fn run_f64_materialized_selected_direct_resolved_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        physics: &PhysicsRuntime,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let point_count = batch.point_count();
+        let helicity_indices = physics.selected_helicity_indices(selected_helicity_ids)?;
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        let component_count = helicity_indices
+            .len()
+            .checked_mul(color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        let mut values = vec![0.0; point_count * component_count];
+        let Self {
+            compiled_direct_runtime: Some(direct),
+            compiled_direct_color_schedules,
+            sources,
+            external_count,
+            particle_masses,
+            momentum_slots,
+            external_is_initial,
+            model_parameter_values_f64,
+            amplitude_stage: Some(amplitude),
+            normalization_factor,
+            ..
+        } = self
+        else {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena resolved execution was selected without a complete runtime",
+            ));
+        };
+        let tile_capacity = direct.reduction_tile_capacity();
+        let mut point_start = 0usize;
+        while point_start < point_count {
+            let point_stop = (point_start + tile_capacity).min(point_count);
+            let tile = batch.subview(point_start, point_stop)?;
+            direct.begin_tile_from_inputs(
+                tile,
+                sources,
+                None,
+                *external_count,
+                particle_masses,
+                momentum_slots,
+                external_is_initial,
+                model_parameter_values_f64,
+            )?;
+            evaluate_direct_color_schedule(
+                direct,
+                compiled_direct_color_schedules,
+                selected_color_sector_ids,
+                point_stop - point_start,
+            )?;
+            let resolved = amplitude.reduce_planes_f64_resolved(
+                direct.amplitude_planes()?,
+                physics,
+                *normalization_factor,
+                selected_helicity_ids,
+                selected_color_ids,
+            )?;
+            if resolved.helicity_indices != helicity_indices
+                || resolved.color_indices != color_indices
+                || resolved.point_count != point_stop - point_start
+            {
+                return Err(RusticolError::integrity(
+                    "compiled Direct-Arena reducer returned an inconsistent resolved shape",
+                ));
+            }
+            for tile_point in 0..resolved.point_count {
+                let source = tile_point * component_count;
+                let target = (point_start + tile_point) * component_count;
+                values[target..target + component_count]
+                    .copy_from_slice(&resolved.values[source..source + component_count]);
+            }
+            point_start = point_stop;
+        }
+        Ok(ResolvedValues {
+            values,
+            point_count,
+            helicity_indices,
+            color_indices,
+        })
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[allow(clippy::too_many_arguments)]
+    fn run_f64_routed_materialized_direct_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        physics: &PhysicsRuntime,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        replay_entry: &LcResolvedReplayEntry,
+        source_component_count: usize,
+        target_component_count: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let point_count = batch.point_count();
+        if output.len() != point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "routed evaluation output has length {}, expected {point_count}",
+                output.len()
+            )));
+        }
+        let Self {
+            compiled_direct_runtime: Some(direct),
+            sources,
+            external_count,
+            particle_masses,
+            momentum_slots,
+            external_is_initial,
+            model_parameter_values_f64,
+            amplitude_stage: Some(amplitude),
+            normalization_factor,
+            ..
+        } = self
+        else {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena routed execution was selected without a complete runtime",
+            ));
+        };
+        // This leaf is reached by a single selected LC flow. Size its routed
+        // scratch from the actual selected component axes, not the parent
+        // runtime's worst-case complete helicity/color Cartesian product.
+        let reduction_footprint = amplitude.compiled_direct_reduction_footprint(
+            0,
+            CompiledDirectRoutedReductionFootprint {
+                maximum_source_component_count: source_component_count,
+                maximum_target_component_count: target_component_count,
+            },
+        )?;
+        let tile_capacity = direct.reduction_tile_capacity_for_footprint(reduction_footprint)?;
+        let mut point_start = 0usize;
+        while point_start < point_count {
+            let point_stop = (point_start + tile_capacity).min(point_count);
+            let tile = batch.subview(point_start, point_stop)?;
+            direct.begin_tile_from_inputs(
+                tile,
+                sources,
+                None,
+                *external_count,
+                particle_masses,
+                momentum_slots,
+                external_is_initial,
+                model_parameter_values_f64,
+            )?;
+            direct.evaluate_all(point_stop - point_start)?;
+            amplitude.reduce_planes_f64_routed_totals_into(
+                direct.amplitude_planes()?,
+                physics,
+                *normalization_factor,
+                selected_helicity_ids,
+                selected_color_ids,
+                replay_entry,
+                source_component_count,
+                target_component_count,
+                &mut output[point_start..point_stop],
+            )?;
+            point_start = point_stop;
+        }
+        Ok(())
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[allow(clippy::too_many_arguments)]
+    fn run_f64_routed_materialized_direct_components_add_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+        replay_entry: &LcResolvedReplayEntry,
+        source_component_count: usize,
+        target_component_count: usize,
+        target_point_count: usize,
+        target_components: &mut [f64],
+    ) -> RusticolResult<()> {
+        let point_count = batch.point_count();
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let Self {
+            compiled_direct_runtime: Some(direct),
+            compiled_direct_color_schedules,
+            sources,
+            external_count,
+            particle_masses,
+            momentum_slots,
+            external_is_initial,
+            model_parameter_values_f64,
+            amplitude_stage: Some(amplitude),
+            normalization_factor,
+            ..
+        } = self
+        else {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena routed execution was selected without a complete runtime",
+            ));
+        };
+        let tile_capacity = direct.reduction_tile_capacity();
+        let mut point_start = 0usize;
+        while point_start < point_count {
+            let point_stop = (point_start + tile_capacity).min(point_count);
+            let tile = batch.subview(point_start, point_stop)?;
+            direct.begin_tile_from_inputs(
+                tile,
+                sources,
+                None,
+                *external_count,
+                particle_masses,
+                momentum_slots,
+                external_is_initial,
+                model_parameter_values_f64,
+            )?;
+            evaluate_direct_color_schedule(
+                direct,
+                compiled_direct_color_schedules,
+                selected_color_sector_ids,
+                point_stop - point_start,
+            )?;
+            amplitude.reduce_planes_f64_routed_components_add_into(
+                direct.amplitude_planes()?,
+                &physics,
+                *normalization_factor,
+                selected_helicity_ids,
+                selected_color_ids,
+                replay_entry,
+                source_component_count,
+                target_component_count,
+                target_point_count,
+                point_start,
+                target_components,
+            )?;
+            point_start = point_stop;
+        }
+        Ok(())
+    }
+
+    fn evaluate_f64_materialized_selected_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<()> {
+        if self.stages.is_none() || self.amplitude_stage.is_none() {
+            return Err(self.execution_unavailable_error());
+        }
+        let n_points = batch.point_count();
+        let color_schedule = selected_color_sector_ids
+            .map(|sector_ids| self.compiled_color_selector_schedule(sector_ids))
+            .transpose()?
+            .flatten();
+        let state_len = n_points * self.parameter_count;
+        self.state_scratch_f64.resize(state_len, c64(0.0, 0.0));
+        if self.state_scratch_f64_requires_clear {
+            self.state_scratch_f64.fill(c64(0.0, 0.0));
+        }
+        self.state_scratch_f64_requires_clear = true;
+        let state = &mut self.state_scratch_f64;
+        let model_parameter_start = self.value_parameter_count + self.momentum_parameter_count;
+        for row in 0..n_points {
+            let point = batch.point(row);
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_sources_row(
+                &self.sources,
+                self.external_count,
+                &self.particle_masses,
+                row_state,
+                &point,
+            )?;
+        }
+        for row in 0..n_points {
+            let point = batch.point(row);
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_momenta_row(
+                &self.momentum_slots,
+                self.value_parameter_count,
+                self.external_count,
+                &self.external_is_initial,
+                row_state,
+                &point,
+            )?;
+        }
+        for row in 0..n_points {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_model_parameters_row(
+                model_parameter_start,
+                &self.model_parameter_values_f64,
+                row_state,
+            )?;
+        }
+        for (stage_index, stage) in self
+            .stages
+            .as_mut()
+            .expect("generic stages checked")
+            .iter_mut()
+            .enumerate()
+        {
+            if let Some(schedule) = color_schedule.as_ref() {
+                stage.evaluate_active_chunks_f64_into_state(
+                    n_points,
+                    self.parameter_count,
+                    state.as_mut_slice(),
+                    &schedule.active_stage_chunk_indices[stage_index],
+                )?;
+            } else {
+                stage.evaluate_f64_into_state(
+                    n_points,
+                    self.parameter_count,
+                    state.as_mut_slice(),
+                )?;
+            }
+        }
+        if let Some(schedule) = color_schedule.as_ref() {
+            self.amplitude_stage
+                .as_mut()
+                .expect("generic amplitude stage checked")
+                .evaluate_active_chunks_f64_into_scratch(
+                    n_points,
+                    state.as_slice(),
+                    &schedule.active_amplitude_chunk_indices,
+                )?;
+        } else {
+            self.amplitude_stage
+                .as_mut()
+                .expect("generic amplitude stage checked")
+                .evaluate_f64_into_scratch(n_points, state.as_slice())?;
+        }
+        self.state_scratch_f64_requires_clear = color_schedule.is_some();
+        Ok(())
+    }
+
+    pub(super) fn run_f64(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        if let Some(sum_runtime) = self.helicity_sum_runtime.as_mut() {
+            return sum_runtime.run_f64(batch);
+        }
+        if self.color_topology_replay_enabled {
+            return self.run_f64_with_color_topology_replay(batch);
+        }
+        if self.lc_topology_replay_enabled {
+            return self.run_f64_with_lc_topology_replay(batch);
+        }
+        if self.has_compiled_helicity_execution_plan() {
+            let (resolved, mut profile) =
+                self.run_resolved_f64_with_helicity_recurrence(batch, None, None, None)?;
+            let materialization_start = Instant::now();
+            let values = resolved_f64_totals(&resolved)?;
+            profile.total_materialization_s += materialization_start.elapsed().as_secs_f64();
+            profile.total_materialized_value_count += values.len() as u64;
+            return Ok((values, profile));
+        }
+        self.run_f64_selected(batch, None)
+    }
+
+    pub(super) fn run_f64_selected_totals(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        if self.has_compiled_symmetric_group_diagnostic()
+            && (selected_helicity_ids.is_some() || selected_color_ids.is_some())
+        {
+            return Err(self.compiled_symmetric_group_unsupported("runtime selectors"));
+        }
+        let (selected_helicity_ids, selected_color_ids) =
+            self.physics
+                .as_ref()
+                .map_or((selected_helicity_ids, selected_color_ids), |physics| {
+                    (
+                        physics.canonical_total_helicity_selector(selected_helicity_ids),
+                        physics.canonical_total_color_selector(selected_color_ids),
+                    )
+                });
+        if self.has_safe_singleton_helicity_execution(selected_helicity_ids, selected_color_ids)? {
+            let (resolved, mut profile) = self.run_resolved_f64_with_helicity_recurrence(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                None,
+            )?;
+            let materialization_start = Instant::now();
+            let values = resolved_f64_totals(&resolved)?;
+            profile.total_materialization_s += materialization_start.elapsed().as_secs_f64();
+            profile.total_materialized_value_count += values.len() as u64;
+            return Ok((values, profile));
+        }
+        if self.use_helicity_sum_runtime_for_selection(selected_helicity_ids)
+            && let Some(sum_runtime) = self.helicity_sum_runtime.as_mut()
+        {
+            return sum_runtime.run_f64_selected_totals(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        if self.color_topology_replay_enabled {
+            let (resolved, mut profile) = self.run_resolved_f64_with_color_topology_replay(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            )?;
+            let materialization_start = Instant::now();
+            let values = resolved_f64_totals(&resolved)?;
+            profile.total_materialization_s += materialization_start.elapsed().as_secs_f64();
+            profile.total_materialized_value_count += values.len() as u64;
+            return Ok((values, profile));
+        }
+        if self.lc_topology_replay_enabled
+            && selected_color_ids.is_some_and(|ids| ids.len() == 1)
+            && let Some(result) = self.try_run_f64_with_single_lc_topology_replay(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            )?
+        {
+            return Ok(result);
+        }
+        let (resolved, mut profile) =
+            self.run_resolved_f64(batch, selected_helicity_ids, selected_color_ids)?;
+        let materialization_start = Instant::now();
+        let values = resolved_f64_totals(&resolved)?;
+        profile.total_materialization_s += materialization_start.elapsed().as_secs_f64();
+        profile.total_materialized_value_count += values.len() as u64;
+        Ok((values, profile))
+    }
+
+    fn try_run_f64_with_single_lc_topology_replay(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<Option<(Vec<f64>, RuntimeProfile)>> {
+        let total_start = Instant::now();
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let replay_plan = self.cached_lc_resolved_replay_plan(&physics)?;
+        let selection = self.cached_lc_resolved_replay_selection(
+            &physics,
+            replay_plan.as_ref(),
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        let [source_group] = selection.source_groups.as_slice() else {
+            return Ok(None);
+        };
+        let [mapping_index] = source_group.mapping_indices.as_slice() else {
+            return Ok(None);
+        };
+        let [_replay_entry] = source_group.entries.as_slice() else {
+            return Ok(None);
+        };
+        let Some(direct_plan) = source_group.direct_total_plan else {
+            return Ok(None);
+        };
+        let materialized_sector_ids =
+            source_group
+                .materialized_sector_ids
+                .as_ref()
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "LC topology replay selection is missing its materialized-sector cache",
+                    )
+                })?;
+        if materialized_sector_ids.len() != 1 {
+            return Ok(None);
+        }
+        let materialized_sector_id = *materialized_sector_ids
+            .iter()
+            .next()
+            .expect("singleton materialized sector checked");
+        if direct_plan.mapping_index != *mapping_index
+            || direct_plan.materialized_sector_id != materialized_sector_id
+        {
+            return Err(RusticolError::integrity(
+                "LC topology replay direct-total plan disagrees with its selected source",
+            ));
+        }
+        let Some(selector_runtime) = self.color_selector_runtimes.get(&materialized_sector_id)
+        else {
+            return Ok(None);
+        };
+        if selected_helicity_ids.is_some()
+            || selector_runtime.helicity_sum_runtime.is_some()
+            || selector_runtime.lc_topology_replay_enabled
+            || selector_runtime.has_compiled_helicity_execution_plan()
+            || selector_runtime
+                .amplitude_stage
+                .as_ref()
+                .is_none_or(|amplitude| amplitude.color_contraction.is_some())
+        {
+            return Ok(None);
+        }
+        let mapping = self
+            .lc_topology_replay_mappings
+            .get(*mapping_index)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "LC topology replay selection references an unknown mapping",
+                )
+            })?;
+        let expanded_batch = if mapping.is_empty() {
+            None
+        } else {
+            Some(apply_lc_topology_label_permutations(
+                batch,
+                self.external_count,
+                std::slice::from_ref(mapping),
+            )?)
+        };
+        let evaluation_batch = expanded_batch.as_deref().unwrap_or(batch);
+        let (mut values, mut profile) = self
+            .color_selector_runtimes
+            .get_mut(&materialized_sector_id)
+            .expect("selector lane checked above")
+            .run_f64(evaluation_batch)?;
+        if direct_plan.scale != 1.0 {
+            for value in &mut values {
+                *value *= direct_plan.scale;
+            }
+        }
+        let total_s = total_start.elapsed().as_secs_f64();
+        profile.orchestration_s += (total_s - profile.total_s).max(0.0);
+        profile.total_s = total_s;
+        Ok(Some((values, profile)))
+    }
+
+    pub(super) fn run_resolved_f64(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        if self.has_safe_singleton_helicity_execution(selected_helicity_ids, selected_color_ids)? {
+            return self.run_resolved_f64_with_helicity_recurrence(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                None,
+            );
+        }
+        if self.use_helicity_sum_runtime_for_selection(selected_helicity_ids)
+            && let Some(sum_runtime) = self.helicity_sum_runtime.as_mut()
+        {
+            return sum_runtime.run_resolved_f64(batch, selected_helicity_ids, selected_color_ids);
+        }
+        if self.color_topology_replay_enabled {
+            return self.run_resolved_f64_with_color_topology_replay(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        if self.lc_topology_replay_enabled {
+            // A target-flow helicity generally maps to a different source
+            // helicity in the materialized topology.  Always compose runtime
+            // helicity selection through the replay plan, even when a nested
+            // selector lane can evaluate the primary topology directly.
+            return self.run_resolved_f64_with_lc_topology_replay(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        if self.has_compiled_helicity_execution_plan() {
+            return self.run_resolved_f64_with_helicity_recurrence(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+                None,
+            );
+        }
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let selected_color_lane = if selected_color_ids.is_some_and(|ids| ids.len() == 1) {
+            self.lc_materialized_sector_ids_for_color_ids(
+                physics.as_ref(),
+                selected_color_ids.expect("singleton selection checked"),
+            )?
+            .into_iter()
+            .next()
+        } else {
+            None
+        };
+        if let Some(sector_id) = selected_color_lane
+            && let Some(selector_runtime) = self.color_selector_runtimes.get_mut(&sector_id)
+        {
+            return selector_runtime.run_resolved_f64(
+                batch,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        let (_summed, mut profile) = self.run_f64_materialized(batch)?;
+        let resolved_reduction_start = Instant::now();
+        let resolved = self
+            .amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked")
+            .reduce_scratch_f64_resolved(
+                batch.len(),
+                &physics,
+                self.normalization_factor,
+                selected_helicity_ids,
+                selected_color_ids,
+            )?;
+        let resolved_reduction_s = resolved_reduction_start.elapsed().as_secs_f64();
+        profile.reduction_s += resolved_reduction_s;
+        profile.resolved_reduction_materialization_s += resolved_reduction_s;
+        profile.resolved_materialized_component_count += resolved.values.len() as u64;
+        Ok((resolved, profile))
+    }
+
+    fn run_resolved_f64_with_lc_topology_replay(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let replay_plan = self.cached_lc_resolved_replay_plan(&physics)?;
+        let selection = self.cached_lc_resolved_replay_selection(
+            &physics,
+            replay_plan.as_ref(),
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        let total_start = Instant::now();
+        let initial_orchestration_start = Instant::now();
+        let n_points = batch.len();
+        let component_count = selection.helicity_indices.len() * selection.color_indices.len();
+        let mut full_values = vec![0.0; n_points * component_count];
+        let mut sector_profiles = Vec::new();
+        let mut replay_reduction_elapsed = Duration::ZERO;
+        let mappings = self.lc_topology_replay_mappings.clone();
+        let mappings_per_chunk = replay_mappings_per_expanded_batch(n_points);
+        let mut replay_orchestration_elapsed = initial_orchestration_start.elapsed();
+        for source_group in &selection.source_groups {
+            let group_orchestration_start = Instant::now();
+            let materialized_sector_ids =
+                self.lc_materialized_sector_ids_for_color_ids(&physics, &source_group.color_ids)?;
+            replay_orchestration_elapsed += group_orchestration_start.elapsed();
+            for chunk_start in (0..source_group.mapping_indices.len()).step_by(mappings_per_chunk) {
+                let chunk_orchestration_start = Instant::now();
+                let chunk_end = usize::min(
+                    chunk_start + mappings_per_chunk,
+                    source_group.mapping_indices.len(),
+                );
+                let mapping_chunk = source_group.mapping_indices[chunk_start..chunk_end]
+                    .iter()
+                    .map(|mapping_index| mappings[*mapping_index].clone())
+                    .collect::<Vec<_>>();
+                let entry_chunk = &source_group.entries[chunk_start..chunk_end];
+                let expanded_batch = if mapping_chunk.len() == 1 && mapping_chunk[0].is_empty() {
+                    None
+                } else {
+                    Some(apply_lc_topology_label_permutations(
+                        batch,
+                        self.external_count,
+                        &mapping_chunk,
+                    )?)
+                };
+                let evaluation_batch = expanded_batch.as_deref().unwrap_or(batch);
+                let selected_lane_id = (materialized_sector_ids.len() == 1)
+                    .then(|| materialized_sector_ids.iter().next().copied())
+                    .flatten();
+                replay_orchestration_elapsed += chunk_orchestration_start.elapsed();
+                let (materialized, sector_profile) = if self.has_compiled_helicity_execution_plan()
+                    && selected_helicity_ids.is_some()
+                {
+                    self.run_resolved_f64_with_helicity_recurrence(
+                        evaluation_batch,
+                        Some(&source_group.helicity_ids),
+                        Some(&source_group.color_ids),
+                        Some(&materialized_sector_ids),
+                    )?
+                } else if let Some(selector_runtime) = selected_lane_id
+                    .and_then(|sector_id| self.color_selector_runtimes.get_mut(&sector_id))
+                {
+                    selector_runtime.run_resolved_f64(
+                        evaluation_batch,
+                        Some(&source_group.helicity_ids),
+                        Some(&source_group.color_ids),
+                    )?
+                } else {
+                    let (_expanded_totals, mut sector_profile) = self
+                        .run_f64_materialized_selected(
+                            evaluation_batch,
+                            Some(&materialized_sector_ids),
+                        )?;
+                    let resolved_reduction_start = Instant::now();
+                    let materialized = self
+                        .amplitude_stage
+                        .as_mut()
+                        .expect("generic amplitude stage checked")
+                        .reduce_scratch_f64_resolved(
+                            evaluation_batch.len(),
+                            &physics,
+                            self.normalization_factor,
+                            Some(&source_group.helicity_ids),
+                            Some(&source_group.color_ids),
+                        )?;
+                    let resolved_reduction_s = resolved_reduction_start.elapsed().as_secs_f64();
+                    sector_profile.reduction_s += resolved_reduction_s;
+                    sector_profile.resolved_reduction_materialization_s += resolved_reduction_s;
+                    sector_profile.resolved_materialized_component_count +=
+                        materialized.values.len() as u64;
+                    (materialized, sector_profile)
+                };
+                let reduction_start = Instant::now();
+                accumulate_selected_lc_replay_resolved_f64(
+                    &mut full_values,
+                    n_points,
+                    &materialized,
+                    entry_chunk,
+                    source_group.source_component_count,
+                    component_count,
+                )?;
+                replay_reduction_elapsed += reduction_start.elapsed();
+                let post_reduction_orchestration_start = Instant::now();
+                sector_profiles.push(sector_profile);
+                replay_orchestration_elapsed += post_reduction_orchestration_start.elapsed();
+            }
+        }
+        let profile_fold_start = Instant::now();
+        let mut profile = RuntimeProfile::default();
+        for sector_profile in &sector_profiles {
+            profile.add_sector(sector_profile);
+        }
+        replay_orchestration_elapsed += profile_fold_start.elapsed();
+        profile.orchestration_s += profile_duration_seconds(replay_orchestration_elapsed);
+        profile.reduction_s += profile_duration_seconds(replay_reduction_elapsed);
+        profile.total_s = total_start.elapsed().as_secs_f64();
+        Ok((
+            ResolvedValues {
+                values: full_values,
+                point_count: n_points,
+                helicity_indices: selection.helicity_indices.clone(),
+                color_indices: selection.color_indices.clone(),
+            },
+            profile,
+        ))
+    }
+
+    pub(super) fn run_f64_selected(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        if self.has_compiled_symmetric_group_diagnostic() && selected_color_sector_ids.is_some() {
+            return Err(self.compiled_symmetric_group_unsupported("runtime selectors"));
+        }
+        if let Some(sum_runtime) = self.helicity_sum_runtime.as_mut() {
+            return sum_runtime.run_f64_selected(batch, selected_color_sector_ids);
+        }
+        if self.color_topology_replay_enabled {
+            if selected_color_sector_ids.is_some() {
+                return Err(RusticolError::selector(
+                    "contracted-color topology replay does not expose physical sector selection",
+                ));
+            }
+            return self.run_f64_with_color_topology_replay(batch);
+        }
+        if self.lc_topology_replay_enabled {
+            if selected_color_sector_ids.is_some() {
+                return Err(RusticolError::invalid_argument(
+                    "LC color-sector runtime selection is not available for topology-replay artifacts",
+                ));
+            }
+            return self.run_f64_with_lc_topology_replay(batch);
+        }
+        let Some(selected) = selected_color_sector_ids else {
+            let previous = self.set_lc_sector_selector(None);
+            let result = self.run_f64_materialized_selected(batch, None);
+            self.restore_lc_sector_selector(previous);
+            return result;
+        };
+        if selected.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "LC color-sector runtime selection requires at least one sector id",
+            ));
+        }
+        if selected.len() == 1
+            && let Some(selector_runtime) = selected
+                .iter()
+                .next()
+                .and_then(|sector_id| self.color_selector_runtimes.get_mut(sector_id))
+        {
+            return selector_runtime.run_f64_materialized(batch);
+        }
+        if !self
+            .model_parameter_name_to_index
+            .contains_key(LC_SECTOR_SELECTOR_PARAMETER)
+        {
+            return self.run_f64_materialized_selected(batch, Some(selected));
+        }
+        let total_start = Instant::now();
+        let n_points = batch.len();
+        let mut values = vec![0.0; n_points];
+        let mut sector_profiles = Vec::with_capacity(selected.len());
+        let previous = self.set_lc_sector_selector(None);
+        let result = (|| {
+            for sector_id in selected {
+                self.set_lc_sector_selector(Some(*sector_id));
+                let mut singleton = BTreeSet::new();
+                singleton.insert(*sector_id);
+                let (sector_values, sector_profile) =
+                    self.run_f64_materialized_selected(batch, Some(&singleton))?;
+                for (value, sector_value) in values.iter_mut().zip(sector_values) {
+                    *value += sector_value;
+                }
+                sector_profiles.push(sector_profile);
+            }
+            let mut profile = RuntimeProfile::default();
+            for sector_profile in &sector_profiles {
+                profile.add_sector(sector_profile);
+            }
+            profile.total_s = total_start.elapsed().as_secs_f64();
+            Ok((values, profile))
+        })();
+        self.restore_lc_sector_selector(previous);
+        result
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn run_double(
+        &mut self,
+        batch: &[Vec<[DoubleFloat; 4]>],
+    ) -> RusticolResult<(Vec<DoubleFloat>, RuntimeProfile)> {
+        if self.has_compiled_symmetric_group_diagnostic() {
+            return Err(
+                self.compiled_symmetric_group_unsupported("exact/high-precision evaluation")
+            );
+        }
+        if let Some(sum_runtime) = self.helicity_sum_runtime.as_mut() {
+            return sum_runtime.run_double(batch);
+        }
+        if self.color_topology_replay_enabled {
+            return Err(RusticolError::invalid_argument(
+                "compiled/eager contracted-color topology replay currently exposes f64; use the exact recurrence lane for precision certification",
+            ));
+        }
+        if self.lc_topology_replay_enabled {
+            return self.run_generic_with_lc_topology_replay(batch, None);
+        }
+        if self.has_compiled_helicity_execution_plan() {
+            return self.run_generic_with_helicity_recurrence(batch, None);
+        }
+        self.run_generic_materialized(batch, None)
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn run_float(
+        &mut self,
+        batch: &[Vec<[Float; 4]>],
+        binary_precision: u32,
+    ) -> RusticolResult<(Vec<Float>, RuntimeProfile)> {
+        if self.has_compiled_symmetric_group_diagnostic() {
+            return Err(
+                self.compiled_symmetric_group_unsupported("exact/high-precision evaluation")
+            );
+        }
+        if let Some(sum_runtime) = self.helicity_sum_runtime.as_mut() {
+            return sum_runtime.run_float(batch, binary_precision);
+        }
+        if self.color_topology_replay_enabled {
+            return Err(RusticolError::invalid_argument(
+                "compiled/eager contracted-color topology replay currently exposes f64; use the exact recurrence lane for precision certification",
+            ));
+        }
+        if self.lc_topology_replay_enabled {
+            return self.run_generic_with_lc_topology_replay(batch, Some(binary_precision));
+        }
+        if self.has_compiled_helicity_execution_plan() {
+            return self.run_generic_with_helicity_recurrence(batch, Some(binary_precision));
+        }
+        self.run_generic_materialized(batch, Some(binary_precision))
+    }
+
+    pub(super) fn run_f64_with_lc_topology_replay(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        let (resolved, profile) =
+            self.run_resolved_f64_with_lc_topology_replay(batch, None, None)?;
+        let mut profile = profile;
+        let materialization_start = Instant::now();
+        let values = resolved_f64_totals(&resolved)?;
+        profile.total_materialization_s += materialization_start.elapsed().as_secs_f64();
+        profile.total_materialized_value_count += values.len() as u64;
+        Ok((values, profile))
+    }
+
+    pub(super) fn run_f64_with_color_topology_replay(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        let total_start = Instant::now();
+        let view = F64MomentumBatchView::from_nested(batch, self.external_count)?;
+        let mut values = vec![0.0; batch.len()];
+        self.run_f64_with_color_topology_replay_into_unprofiled(view, &mut values)?;
+        let total_s = total_start.elapsed().as_secs_f64();
+        Ok((
+            values,
+            RuntimeProfile {
+                total_s,
+                total_materialized_value_count: batch.len() as u64,
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+
+    fn run_resolved_f64_with_color_topology_replay(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        let total_start = Instant::now();
+        let view = F64MomentumBatchView::from_nested(batch, self.external_count)?;
+        let resolved = self.run_resolved_f64_with_color_topology_replay_unprofiled(
+            view,
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        let total_s = total_start.elapsed().as_secs_f64();
+        Ok((
+            resolved,
+            RuntimeProfile {
+                total_s,
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+
+    pub(super) fn run_f64_materialized(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        self.run_f64_materialized_selected(batch, None)
+    }
+
+    pub(super) fn run_f64_materialized_selected(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        if self.stages.is_none() || self.amplitude_stage.is_none() {
+            return Err(self.execution_unavailable_error());
+        }
+        let total_start = Instant::now();
+        let n_points = batch.len();
+        let state_prepare_start = Instant::now();
+        let color_schedule = selected_color_sector_ids
+            .map(|sector_ids| self.compiled_color_selector_schedule(sector_ids))
+            .transpose()?
+            .flatten();
+        let state_len = n_points * self.parameter_count;
+        let state_capacity = self.state_scratch_f64.capacity();
+        self.state_scratch_f64.resize(state_len, c64(0.0, 0.0));
+        let state_prepare_elapsed = state_prepare_start.elapsed();
+        let mut scratch_reallocation_count =
+            u64::from(self.state_scratch_f64.capacity() != state_capacity);
+        let clear_start = Instant::now();
+        let mut state_clear_component_count = 0;
+        if self.state_scratch_f64_requires_clear {
+            self.state_scratch_f64.fill(c64(0.0, 0.0));
+            state_clear_component_count = state_len as u64;
+        }
+        let state_clear_elapsed = clear_start.elapsed();
+        // Keep this conservative while execution is in progress: an evaluator
+        // error can leave a partially written state. A complete schedule clears
+        // the flag below; selector-pruned schedules deliberately leave it set.
+        self.state_scratch_f64_requires_clear = true;
+        let state = &mut self.state_scratch_f64;
+        let sources = &self.sources;
+        let momentum_slots = &self.momentum_slots;
+        let external_count = self.external_count;
+        let external_is_initial = &self.external_is_initial;
+        let particle_masses = &self.particle_masses;
+        let value_parameter_count = self.value_parameter_count;
+        let model_parameter_start = self.value_parameter_count + self.momentum_parameter_count;
+        let model_parameter_values = &self.model_parameter_values_f64;
+        let source_start = Instant::now();
+        for (row, point) in batch.iter().enumerate() {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_sources_row(sources, external_count, particle_masses, row_state, point)?;
+        }
+        let source_fill_elapsed = source_start.elapsed();
+
+        let momentum_start = Instant::now();
+        for (row, point) in batch.iter().enumerate() {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_momenta_row(
+                momentum_slots,
+                value_parameter_count,
+                external_count,
+                external_is_initial,
+                row_state,
+                point,
+            )?;
+        }
+        let momentum_setup_elapsed = momentum_start.elapsed();
+
+        let model_parameter_start_time = Instant::now();
+        for row in 0..n_points {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_model_parameters_row(
+                model_parameter_start,
+                model_parameter_values,
+                row_state,
+            )?;
+        }
+        let model_parameter_setup_elapsed = model_parameter_start_time.elapsed();
+        let mut stage_profiles = Vec::new();
+        let mut stage_input_pack_by_stage_s = Vec::new();
+        let mut stage_leaf_input_pack_by_stage_s = Vec::new();
+        let mut stage_evaluator_call_by_stage_s = Vec::new();
+        let mut stage_backend_call_by_stage_s = Vec::new();
+        let mut stage_evaluator_output_gather_by_stage_s = Vec::new();
+        let mut stage_output_assign_by_stage_s = Vec::new();
+        for (stage_index, stage) in self
+            .stages
+            .as_mut()
+            .expect("generic stages checked")
+            .iter_mut()
+            .enumerate()
+        {
+            let stage_profile = if let Some(schedule) = color_schedule.as_ref() {
+                stage.evaluate_active_chunks_f64_into_state_profile(
+                    n_points,
+                    self.parameter_count,
+                    state.as_mut_slice(),
+                    &schedule.active_stage_chunk_indices[stage_index],
+                )?
+            } else {
+                stage.evaluate_f64_into_state_profile(
+                    n_points,
+                    self.parameter_count,
+                    state.as_mut_slice(),
+                )?
+            };
+            stage_input_pack_by_stage_s.push(stage_profile.input_pack_s);
+            stage_leaf_input_pack_by_stage_s.push(stage_profile.evaluator.leaf_input_pack_s);
+            stage_evaluator_call_by_stage_s.push(stage_profile.evaluator.legacy_evaluator_call_s);
+            stage_backend_call_by_stage_s.push(stage_profile.evaluator.evaluator_call_s);
+            stage_evaluator_output_gather_by_stage_s.push(stage_profile.evaluator.output_gather_s);
+            stage_output_assign_by_stage_s.push(stage_profile.output_assign_s);
+            stage_profiles.push(stage_profile);
+        }
+
+        let amplitude_profile = if let Some(schedule) = color_schedule.as_ref() {
+            self.amplitude_stage
+                .as_mut()
+                .expect("generic amplitude stage checked")
+                .evaluate_active_chunks_f64_into_scratch_profile(
+                    n_points,
+                    state.as_slice(),
+                    &schedule.active_amplitude_chunk_indices,
+                )?
+        } else {
+            self.amplitude_stage
+                .as_mut()
+                .expect("generic amplitude stage checked")
+                .evaluate_f64_into_scratch_profile(n_points, state.as_slice())?
+        };
+        let amplitude_input_pack_s = amplitude_profile.input_pack_s;
+        let amplitude_evaluator_call_s =
+            amplitude_profile.evaluator.legacy_evaluator_call_s + amplitude_profile.output_remap_s;
+        let amplitude_evaluator_s = amplitude_input_pack_s + amplitude_evaluator_call_s;
+
+        let reduction_start = Instant::now();
+        let values_capacity = self.values_scratch_f64.capacity();
+        self.amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked")
+            .reduce_scratch_f64_into_selected(
+                n_points,
+                &mut self.values_scratch_f64,
+                selected_color_sector_ids,
+            )?;
+        for value in &mut self.values_scratch_f64 {
+            *value *= self.normalization_factor;
+        }
+        let reduction_s = reduction_start.elapsed().as_secs_f64();
+        scratch_reallocation_count +=
+            u64::from(self.values_scratch_f64.capacity() != values_capacity);
+        self.state_scratch_f64_requires_clear = color_schedule.is_some();
+        let stage_input_pack_s = stage_input_pack_by_stage_s.iter().sum::<f64>();
+        let stage_evaluator_call_s = stage_evaluator_call_by_stage_s.iter().sum::<f64>();
+        let stage_evaluator_s = stage_input_pack_s + stage_evaluator_call_s;
+        let output_assign_s = stage_output_assign_by_stage_s.iter().sum::<f64>();
+        let final_output_copy_start = Instant::now();
+        let values = self.values_scratch_f64.clone();
+        let final_output_copy_s = final_output_copy_start.elapsed().as_secs_f64();
+        Ok((
+            values,
+            RuntimeProfile {
+                source_fill_s: profile_duration_seconds(source_fill_elapsed),
+                state_prepare_s: profile_duration_seconds(state_prepare_elapsed),
+                state_clear_s: profile_duration_seconds(state_clear_elapsed),
+                momentum_input_setup_s: profile_duration_seconds(momentum_setup_elapsed),
+                momentum_setup_s: profile_duration_seconds(
+                    momentum_setup_elapsed + model_parameter_setup_elapsed,
+                ),
+                model_parameter_setup_s: profile_duration_seconds(model_parameter_setup_elapsed),
+                stage_input_pack_s,
+                stage_leaf_input_pack_s: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.leaf_input_pack_s)
+                    .sum(),
+                stage_evaluator_call_s,
+                stage_backend_call_s: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.evaluator_call_s)
+                    .sum(),
+                stage_evaluator_output_gather_s: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.output_gather_s)
+                    .sum(),
+                stage_evaluator_s,
+                output_assign_s,
+                amplitude_input_pack_s,
+                amplitude_leaf_input_pack_s: amplitude_profile.evaluator.leaf_input_pack_s,
+                amplitude_evaluator_call_s,
+                amplitude_backend_call_s: amplitude_profile.evaluator.evaluator_call_s,
+                amplitude_evaluator_output_gather_s: amplitude_profile.evaluator.output_gather_s,
+                amplitude_output_remap_s: amplitude_profile.output_remap_s,
+                amplitude_evaluator_s,
+                reduction_s,
+                total_s: total_start.elapsed().as_secs_f64(),
+                stage_input_pack_by_stage_s,
+                stage_leaf_input_pack_by_stage_s,
+                stage_evaluator_call_by_stage_s,
+                stage_backend_call_by_stage_s,
+                stage_evaluator_output_gather_by_stage_s,
+                stage_output_assign_by_stage_s,
+                state_component_count: state_len as u64,
+                state_clear_component_count,
+                source_component_count: (n_points * self.source_count) as u64,
+                momentum_component_count: (n_points * self.momentum_parameter_count) as u64,
+                model_parameter_component_count: (n_points * model_parameter_values.len()) as u64,
+                stage_input_copy_component_count: stage_profiles
+                    .iter()
+                    .map(|profile| profile.input_copy_component_count)
+                    .sum(),
+                stage_leaf_input_copy_component_count: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.leaf_input_copy_component_count)
+                    .sum(),
+                stage_evaluator_output_gather_component_count: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.output_gather_component_count)
+                    .sum(),
+                stage_output_assign_component_count: stage_profiles
+                    .iter()
+                    .map(|profile| profile.output_assign_component_count)
+                    .sum(),
+                amplitude_input_copy_component_count: amplitude_profile.input_copy_component_count,
+                amplitude_leaf_input_copy_component_count: amplitude_profile
+                    .evaluator
+                    .leaf_input_copy_component_count,
+                amplitude_evaluator_output_gather_component_count: amplitude_profile
+                    .evaluator
+                    .output_gather_component_count,
+                amplitude_output_remap_component_count: amplitude_profile
+                    .output_remap_component_count,
+                evaluator_backend_call_count: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.backend_call_count)
+                    .sum::<u64>()
+                    + amplitude_profile.evaluator.backend_call_count,
+                reduction_input_component_count: (n_points
+                    * self
+                        .amplitude_stage
+                        .as_ref()
+                        .expect("generic amplitude stage checked")
+                        .output_length) as u64,
+                total_materialized_value_count: n_points as u64,
+                final_output_copy_s,
+                final_output_copy_value_count: self.values_scratch_f64.len() as u64,
+                scratch_reallocation_count: scratch_reallocation_count
+                    + stage_profiles
+                        .iter()
+                        .map(|profile| {
+                            profile.scratch_reallocation_count
+                                + profile.evaluator.scratch_reallocation_count
+                        })
+                        .sum::<u64>()
+                    + amplitude_profile.scratch_reallocation_count
+                    + amplitude_profile.evaluator.scratch_reallocation_count,
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn run_generic_with_lc_topology_replay<T>(
+        &mut self,
+        batch: &[Vec<[T; 4]>],
+        binary_precision: Option<u32>,
+    ) -> RusticolResult<(Vec<T>, RuntimeProfile)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let (resolved, profile) =
+            self.run_resolved_generic_with_lc_topology_replay(batch, binary_precision, None, None)?;
+        let component_count = resolved.helicity_indices.len() * resolved.color_indices.len();
+        let values = resolved
+            .values
+            .chunks_exact(component_count)
+            .map(|components| {
+                components
+                    .iter()
+                    .cloned()
+                    .fold(T::new_zero(), |sum, value| sum + value)
+            })
+            .collect();
+        Ok((values, profile))
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    fn run_generic_with_helicity_recurrence<T>(
+        &mut self,
+        batch: &[Vec<[T; 4]>],
+        binary_precision: Option<u32>,
+    ) -> RusticolResult<(Vec<T>, RuntimeProfile)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let (resolved, profile) = self.run_resolved_generic_with_helicity_recurrence(
+            batch,
+            binary_precision,
+            None,
+            None,
+            None,
+        )?;
+        let component_count = resolved.helicity_indices.len() * resolved.color_indices.len();
+        let values = resolved
+            .values
+            .chunks_exact(component_count)
+            .map(|components| {
+                components
+                    .iter()
+                    .cloned()
+                    .fold(T::new_zero(), |sum, value| sum + value)
+            })
+            .collect();
+        Ok((values, profile))
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn run_generic_materialized<T>(
+        &mut self,
+        batch: &[Vec<[T; 4]>],
+        binary_precision: Option<u32>,
+    ) -> RusticolResult<(Vec<T>, RuntimeProfile)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        if self.stages.is_none() || self.amplitude_stage.is_none() {
+            return Err(self.execution_unavailable_error());
+        }
+        let total_start = Instant::now();
+        let n_points = batch.len();
+        let mut state = vec![complex_zero::<T>(); n_points * self.parameter_count];
+        let sources = &self.sources;
+        let momentum_slots = &self.momentum_slots;
+        let external_count = self.external_count;
+        let external_is_initial = &self.external_is_initial;
+        let particle_masses = &self.particle_masses;
+        let value_parameter_count = self.value_parameter_count;
+        let model_parameter_start = self.value_parameter_count + self.momentum_parameter_count;
+        let model_parameter_values = &self.model_parameter_values_f64;
+
+        let source_start = Instant::now();
+        for (row, point) in batch.iter().enumerate() {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_sources_row_generic(
+                sources,
+                external_count,
+                particle_masses,
+                row_state,
+                point,
+            )?;
+        }
+        let source_fill_elapsed = source_start.elapsed();
+
+        let momentum_start = Instant::now();
+        for (row, point) in batch.iter().enumerate() {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_momenta_row_generic(
+                momentum_slots,
+                value_parameter_count,
+                external_count,
+                external_is_initial,
+                row_state,
+                point,
+            )?;
+        }
+        let momentum_setup_elapsed = momentum_start.elapsed();
+
+        let model_parameter_start_time = Instant::now();
+        for row in 0..n_points {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_model_parameters_row_generic(
+                model_parameter_start,
+                model_parameter_values,
+                row_state,
+            )?;
+        }
+        let model_parameter_setup_elapsed = model_parameter_start_time.elapsed();
+
+        let mut stage_input_pack_s = 0.0;
+        let mut stage_evaluator_call_s = 0.0;
+        let mut stage_evaluator_s = 0.0;
+        let mut output_assign_s = 0.0;
+        let mut stage_input_pack_by_stage_s = Vec::new();
+        let mut stage_evaluator_call_by_stage_s = Vec::new();
+        let mut stage_output_assign_by_stage_s = Vec::new();
+        for stage in self.stages.as_mut().expect("generic stages checked") {
+            let (pack_s, eval_s, assign_s) = stage.evaluate_generic_into_state(
+                n_points,
+                self.parameter_count,
+                state.as_mut_slice(),
+                binary_precision,
+            )?;
+            stage_input_pack_s += pack_s;
+            stage_evaluator_call_s += eval_s;
+            stage_evaluator_s += pack_s + eval_s;
+            output_assign_s += assign_s;
+            stage_input_pack_by_stage_s.push(pack_s);
+            stage_evaluator_call_by_stage_s.push(eval_s);
+            stage_output_assign_by_stage_s.push(assign_s);
+        }
+
+        let (raw_sums, amplitude_input_pack_s, amplitude_evaluator_call_s) = self
+            .amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked")
+            .evaluate_raw_sums_generic(n_points, state.as_slice(), binary_precision)?;
+        let amplitude_evaluator_s = amplitude_input_pack_s + amplitude_evaluator_call_s;
+
+        let reduction_start = Instant::now();
+        let factor = T::from(self.normalization_factor);
+        let values = raw_sums
+            .into_iter()
+            .map(|value| value * factor.clone())
+            .collect::<Vec<_>>();
+        let reduction_s = reduction_start.elapsed().as_secs_f64();
+        Ok((
+            values,
+            RuntimeProfile {
+                source_fill_s: profile_duration_seconds(source_fill_elapsed),
+                momentum_input_setup_s: profile_duration_seconds(momentum_setup_elapsed),
+                momentum_setup_s: profile_duration_seconds(
+                    momentum_setup_elapsed + model_parameter_setup_elapsed,
+                ),
+                model_parameter_setup_s: profile_duration_seconds(model_parameter_setup_elapsed),
+                stage_input_pack_s,
+                stage_evaluator_call_s,
+                stage_evaluator_s,
+                output_assign_s,
+                amplitude_input_pack_s,
+                amplitude_evaluator_call_s,
+                amplitude_evaluator_s,
+                reduction_s,
+                total_s: total_start.elapsed().as_secs_f64(),
+                stage_input_pack_by_stage_s,
+                stage_evaluator_call_by_stage_s,
+                stage_output_assign_by_stage_s,
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn run_resolved_generic<T>(
+        &mut self,
+        batch: &[Vec<[T; 4]>],
+        binary_precision: Option<u32>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<T>, RuntimeProfile)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        if self.has_compiled_symmetric_group_diagnostic() {
+            return Err(self
+                .compiled_symmetric_group_unsupported("resolved exact/high-precision evaluation"));
+        }
+        if self.has_safe_singleton_helicity_execution(selected_helicity_ids, selected_color_ids)? {
+            return self.run_resolved_generic_with_helicity_recurrence(
+                batch,
+                binary_precision,
+                selected_helicity_ids,
+                selected_color_ids,
+                None,
+            );
+        }
+        if self.use_helicity_sum_runtime_for_selection(selected_helicity_ids)
+            && let Some(sum_runtime) = self.helicity_sum_runtime.as_mut()
+        {
+            return sum_runtime.run_resolved_generic(
+                batch,
+                binary_precision,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        if self.lc_topology_replay_enabled {
+            return self.run_resolved_generic_with_lc_topology_replay(
+                batch,
+                binary_precision,
+                selected_helicity_ids,
+                selected_color_ids,
+            );
+        }
+        if self.has_compiled_helicity_execution_plan() {
+            return self.run_resolved_generic_with_helicity_recurrence(
+                batch,
+                binary_precision,
+                selected_helicity_ids,
+                selected_color_ids,
+                None,
+            );
+        }
+        self.run_resolved_generic_materialized(
+            batch,
+            binary_precision,
+            selected_helicity_ids,
+            selected_color_ids,
+        )
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    fn run_resolved_generic_with_lc_topology_replay<T>(
+        &mut self,
+        batch: &[Vec<[T; 4]>],
+        binary_precision: Option<u32>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<T>, RuntimeProfile)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let replay_plan = self.cached_lc_resolved_replay_plan(&physics)?;
+        let selection = self.cached_lc_resolved_replay_selection(
+            &physics,
+            replay_plan.as_ref(),
+            selected_helicity_ids,
+            selected_color_ids,
+        )?;
+        let total_start = Instant::now();
+        let initial_orchestration_start = Instant::now();
+        let n_points = batch.len();
+        let component_count = selection.helicity_indices.len() * selection.color_indices.len();
+        let mut full_values = vec![T::new_zero(); n_points * component_count];
+        let mut sector_profiles = Vec::new();
+        let mut replay_reduction_elapsed = Duration::ZERO;
+        let mappings = self.lc_topology_replay_mappings.clone();
+        let mappings_per_chunk = replay_mappings_per_expanded_batch(n_points);
+        let mut replay_orchestration_elapsed = initial_orchestration_start.elapsed();
+        for source_group in &selection.source_groups {
+            for chunk_start in (0..source_group.mapping_indices.len()).step_by(mappings_per_chunk) {
+                let chunk_orchestration_start = Instant::now();
+                let chunk_end = usize::min(
+                    chunk_start + mappings_per_chunk,
+                    source_group.mapping_indices.len(),
+                );
+                let mapping_chunk = source_group.mapping_indices[chunk_start..chunk_end]
+                    .iter()
+                    .map(|mapping_index| mappings[*mapping_index].clone())
+                    .collect::<Vec<_>>();
+                let entry_chunk = &source_group.entries[chunk_start..chunk_end];
+                let expanded_batch = if mapping_chunk.len() == 1 && mapping_chunk[0].is_empty() {
+                    None
+                } else {
+                    Some(apply_lc_topology_label_permutations_generic(
+                        batch,
+                        self.external_count,
+                        &mapping_chunk,
+                    )?)
+                };
+                let evaluation_batch = expanded_batch.as_deref().unwrap_or(batch);
+                replay_orchestration_elapsed += chunk_orchestration_start.elapsed();
+                let (materialized, sector_profile) = if self.has_compiled_helicity_execution_plan()
+                    && selected_helicity_ids.is_some()
+                {
+                    self.run_resolved_generic_with_helicity_recurrence(
+                        evaluation_batch,
+                        binary_precision,
+                        Some(&source_group.helicity_ids),
+                        Some(&source_group.color_ids),
+                        source_group.materialized_sector_ids.as_ref(),
+                    )?
+                } else {
+                    self.run_resolved_generic_materialized(
+                        evaluation_batch,
+                        binary_precision,
+                        Some(&source_group.helicity_ids),
+                        Some(&source_group.color_ids),
+                    )?
+                };
+                let reduction_start = Instant::now();
+                accumulate_selected_lc_replay_resolved_generic(
+                    &mut full_values,
+                    n_points,
+                    &materialized,
+                    entry_chunk,
+                    source_group.source_component_count,
+                    component_count,
+                )?;
+                replay_reduction_elapsed += reduction_start.elapsed();
+                let post_reduction_orchestration_start = Instant::now();
+                sector_profiles.push(sector_profile);
+                replay_orchestration_elapsed += post_reduction_orchestration_start.elapsed();
+            }
+        }
+        let profile_fold_start = Instant::now();
+        let mut profile = RuntimeProfile::default();
+        for sector_profile in &sector_profiles {
+            profile.add_sector(sector_profile);
+        }
+        replay_orchestration_elapsed += profile_fold_start.elapsed();
+        profile.orchestration_s += profile_duration_seconds(replay_orchestration_elapsed);
+        profile.reduction_s += profile_duration_seconds(replay_reduction_elapsed);
+        profile.total_s = total_start.elapsed().as_secs_f64();
+        Ok((
+            ResolvedValues {
+                values: full_values,
+                point_count: n_points,
+                helicity_indices: selection.helicity_indices.clone(),
+                color_indices: selection.color_indices.clone(),
+            },
+            profile,
+        ))
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    fn run_resolved_generic_materialized<T>(
+        &mut self,
+        batch: &[Vec<[T; 4]>],
+        binary_precision: Option<u32>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<T>, RuntimeProfile)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        if self.stages.is_none() || self.amplitude_stage.is_none() {
+            return Err(self.execution_unavailable_error());
+        }
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let total_start = Instant::now();
+        let n_points = batch.len();
+        let mut state = vec![complex_zero::<T>(); n_points * self.parameter_count];
+        let sources = &self.sources;
+        let momentum_slots = &self.momentum_slots;
+        let external_count = self.external_count;
+        let external_is_initial = &self.external_is_initial;
+        let particle_masses = &self.particle_masses;
+        let value_parameter_count = self.value_parameter_count;
+        let model_parameter_start = self.value_parameter_count + self.momentum_parameter_count;
+        let model_parameter_values = &self.model_parameter_values_f64;
+
+        let source_start = Instant::now();
+        for (row, point) in batch.iter().enumerate() {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_sources_row_generic(
+                sources,
+                external_count,
+                particle_masses,
+                row_state,
+                point,
+            )?;
+        }
+        let source_fill_elapsed = source_start.elapsed();
+
+        let momentum_start = Instant::now();
+        for (row, point) in batch.iter().enumerate() {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_momenta_row_generic(
+                momentum_slots,
+                value_parameter_count,
+                external_count,
+                external_is_initial,
+                row_state,
+                point,
+            )?;
+        }
+        let momentum_setup_elapsed = momentum_start.elapsed();
+
+        let model_parameter_start_time = Instant::now();
+        for row in 0..n_points {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_model_parameters_row_generic(
+                model_parameter_start,
+                model_parameter_values,
+                row_state,
+            )?;
+        }
+        let model_parameter_setup_elapsed = model_parameter_start_time.elapsed();
+
+        let mut stage_input_pack_s = 0.0;
+        let mut stage_evaluator_call_s = 0.0;
+        let mut stage_evaluator_s = 0.0;
+        let mut output_assign_s = 0.0;
+        let mut stage_input_pack_by_stage_s = Vec::new();
+        let mut stage_evaluator_call_by_stage_s = Vec::new();
+        let mut stage_output_assign_by_stage_s = Vec::new();
+        for stage in self.stages.as_mut().expect("generic stages checked") {
+            let (pack_s, eval_s, assign_s) = stage.evaluate_generic_into_state(
+                n_points,
+                self.parameter_count,
+                state.as_mut_slice(),
+                binary_precision,
+            )?;
+            stage_input_pack_s += pack_s;
+            stage_evaluator_call_s += eval_s;
+            stage_evaluator_s += pack_s + eval_s;
+            output_assign_s += assign_s;
+            stage_input_pack_by_stage_s.push(pack_s);
+            stage_evaluator_call_by_stage_s.push(eval_s);
+            stage_output_assign_by_stage_s.push(assign_s);
+        }
+
+        let reduction_start = Instant::now();
+        let (resolved, amplitude_input_pack_s, amplitude_evaluator_call_s) = self
+            .amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked")
+            .evaluate_resolved_generic(
+                n_points,
+                state.as_slice(),
+                binary_precision,
+                &physics,
+                self.normalization_factor,
+                selected_helicity_ids,
+                selected_color_ids,
+            )?;
+        let reduction_s = reduction_start.elapsed().as_secs_f64();
+        let amplitude_evaluator_s = amplitude_input_pack_s + amplitude_evaluator_call_s;
+        Ok((
+            resolved,
+            RuntimeProfile {
+                source_fill_s: profile_duration_seconds(source_fill_elapsed),
+                momentum_input_setup_s: profile_duration_seconds(momentum_setup_elapsed),
+                momentum_setup_s: profile_duration_seconds(
+                    momentum_setup_elapsed + model_parameter_setup_elapsed,
+                ),
+                model_parameter_setup_s: profile_duration_seconds(model_parameter_setup_elapsed),
+                stage_input_pack_s,
+                stage_evaluator_call_s,
+                stage_evaluator_s,
+                output_assign_s,
+                amplitude_input_pack_s,
+                amplitude_evaluator_call_s,
+                amplitude_evaluator_s,
+                reduction_s,
+                total_s: total_start.elapsed().as_secs_f64(),
+                stage_input_pack_by_stage_s,
+                stage_evaluator_call_by_stage_s,
+                stage_output_assign_by_stage_s,
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+}
+
+pub(super) fn write_resolved_f64_totals(
+    resolved: &ResolvedValues<f64>,
+    output: &mut [f64],
+) -> RusticolResult<()> {
+    if output.len() != resolved.point_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "evaluation output has length {}, expected {}",
+            output.len(),
+            resolved.point_count
+        )));
+    }
+    let component_count = resolved
+        .helicity_indices
+        .len()
+        .checked_mul(resolved.color_indices.len())
+        .ok_or_else(|| RusticolError::integrity("resolved component shape overflows usize"))?;
+    let expected_value_count = resolved
+        .point_count
+        .checked_mul(component_count)
+        .ok_or_else(|| RusticolError::integrity("resolved value shape overflows usize"))?;
+    if resolved.values.len() != expected_value_count {
+        return Err(RusticolError::integrity(
+            "resolved evaluation has an inconsistent component buffer length",
+        ));
+    }
+    if component_count == 0 {
+        output.fill(0.0);
+        return Ok(());
+    }
+    for (target, components) in output
+        .iter_mut()
+        .zip(resolved.values.chunks_exact(component_count))
+    {
+        *target = components.iter().sum();
+    }
+    Ok(())
+}
+
+pub(super) fn resolved_f64_totals(resolved: &ResolvedValues<f64>) -> RusticolResult<Vec<f64>> {
+    let mut output = vec![0.0; resolved.point_count];
+    write_resolved_f64_totals(resolved, &mut output)?;
+    Ok(output)
+}
+
+pub(super) fn accumulate_selected_lc_replay_resolved_f64(
+    target: &mut [f64],
+    point_count: usize,
+    materialized: &ResolvedValues<f64>,
+    replay_entries: &[LcResolvedReplayEntry],
+    source_component_count: usize,
+    target_component_count: usize,
+) -> RusticolResult<()> {
+    validate_materialized_replay_shape(
+        materialized,
+        point_count,
+        replay_entries.len(),
+        source_component_count,
+    )?;
+    if target.len() != point_count * target_component_count {
+        return Err(RusticolError::invalid_argument(
+            "LC topology replay target has an inconsistent resolved shape",
+        ));
+    }
+    for (entry_index, entry) in replay_entries.iter().enumerate() {
+        for point_index in 0..point_count {
+            let source_row = (entry_index * point_count + point_index) * source_component_count;
+            let target_row = point_index * target_component_count;
+            for route in &entry.routes {
+                if route.source_index >= source_component_count
+                    || route.target_index >= target_component_count
+                {
+                    return Err(RusticolError::integrity(
+                        "LC topology replay selected route is out of bounds",
+                    ));
+                }
+                target[target_row + route.target_index] +=
+                    route.weight * materialized.values[source_row + route.source_index];
+            }
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+pub(super) fn accumulate_lc_replay_resolved_f64(
+    target: &mut [f64],
+    point_count: usize,
+    materialized: &ResolvedValues<f64>,
+    replay_entries: &[LcResolvedReplayEntry],
+    component_count: usize,
+) -> RusticolResult<()> {
+    accumulate_selected_lc_replay_resolved_f64(
+        target,
+        point_count,
+        materialized,
+        replay_entries,
+        component_count,
+        component_count,
+    )
+}
+
+#[cfg(feature = "symbolica-runtime")]
+fn accumulate_selected_lc_replay_resolved_generic<T>(
+    target: &mut [T],
+    point_count: usize,
+    materialized: &ResolvedValues<T>,
+    replay_entries: &[LcResolvedReplayEntry],
+    source_component_count: usize,
+    target_component_count: usize,
+) -> RusticolResult<()>
+where
+    T: RusticolHighPrecisionNumber,
+    Complex<T>: Real + EvaluationDomain,
+{
+    validate_materialized_replay_shape(
+        materialized,
+        point_count,
+        replay_entries.len(),
+        source_component_count,
+    )?;
+    if target.len() != point_count * target_component_count {
+        return Err(RusticolError::invalid_argument(
+            "LC topology replay target has an inconsistent resolved shape",
+        ));
+    }
+    for (entry_index, entry) in replay_entries.iter().enumerate() {
+        for point_index in 0..point_count {
+            let source_row = (entry_index * point_count + point_index) * source_component_count;
+            let target_row = point_index * target_component_count;
+            for route in &entry.routes {
+                if route.source_index >= source_component_count
+                    || route.target_index >= target_component_count
+                {
+                    return Err(RusticolError::integrity(
+                        "LC topology replay selected route is out of bounds",
+                    ));
+                }
+                target[target_row + route.target_index] +=
+                    materialized.values[source_row + route.source_index].clone()
+                        * T::from(route.weight);
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_materialized_replay_shape<T>(
+    materialized: &ResolvedValues<T>,
+    point_count: usize,
+    replay_count: usize,
+    component_count: usize,
+) -> RusticolResult<()> {
+    let expected_points = point_count.checked_mul(replay_count).ok_or_else(|| {
+        RusticolError::invalid_argument("LC topology replay point count overflowed")
+    })?;
+    let expected_values = expected_points
+        .checked_mul(component_count)
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("LC topology replay resolved shape overflowed")
+        })?;
+    if materialized.point_count != expected_points
+        || materialized.values.len() != expected_values
+        || materialized.helicity_indices.len() * materialized.color_indices.len() != component_count
+    {
+        return Err(RusticolError::invalid_argument(
+            "materialized LC topology replay result has an inconsistent resolved shape",
+        ));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+pub(super) fn select_resolved_values<T: Clone>(
+    full_values: Vec<T>,
+    point_count: usize,
+    physics: &PhysicsRuntime,
+    selected_helicity_ids: Option<&BTreeSet<String>>,
+    selected_color_ids: Option<&BTreeSet<String>>,
+) -> RusticolResult<ResolvedValues<T>> {
+    let helicity_count = physics.manifest.helicities.len();
+    let color_count = physics.manifest.color_components.len();
+    if full_values.len() != point_count * helicity_count * color_count {
+        return Err(RusticolError::invalid_argument(
+            "resolved LC topology replay result has an inconsistent public shape",
+        ));
+    }
+    let helicity_indices = physics.selected_helicity_indices(selected_helicity_ids)?;
+    let color_indices = physics.selected_color_indices(selected_color_ids)?;
+    let mut values = Vec::with_capacity(point_count * helicity_indices.len() * color_indices.len());
+    for point_index in 0..point_count {
+        for helicity_index in &helicity_indices {
+            for color_index in &color_indices {
+                values.push(
+                    full_values[(point_index * helicity_count + *helicity_index) * color_count
+                        + *color_index]
+                        .clone(),
+                );
+            }
+        }
+    }
+    Ok(ResolvedValues {
+        values,
+        point_count,
+        helicity_indices,
+        color_indices,
+    })
+}
+
+#[cfg(test)]
+mod selected_replay_tests {
+    use super::*;
+
+    #[test]
+    fn recognizes_only_ordered_uniform_replay_totals() {
+        let entry = LcResolvedReplayEntry {
+            routes: vec![
+                LcResolvedReplayRoute {
+                    source_index: 0,
+                    target_index: 1,
+                    weight: 0.5,
+                },
+                LcResolvedReplayRoute {
+                    source_index: 1,
+                    target_index: 0,
+                    weight: 0.5,
+                },
+            ],
+        };
+        assert_eq!(uniform_lc_replay_total_scale(&entry, 2, 2), Some(0.5));
+
+        let mut nonuniform = entry.clone();
+        nonuniform.routes[1].weight = 1.0;
+        assert_eq!(uniform_lc_replay_total_scale(&nonuniform, 2, 2), None);
+
+        let mut reordered = entry.clone();
+        reordered.routes.swap(0, 1);
+        assert_eq!(uniform_lc_replay_total_scale(&reordered, 2, 2), Some(0.5));
+
+        let mut out_of_bounds = entry;
+        out_of_bounds.routes[1].target_index = 2;
+        assert_eq!(uniform_lc_replay_total_scale(&out_of_bounds, 2, 2), None);
+    }
+
+    #[test]
+    fn resolved_totals_validate_nonempty_and_empty_component_shapes() {
+        let resolved = ResolvedValues {
+            values: vec![1.0, 2.0, 3.0, 4.0],
+            point_count: 2,
+            helicity_indices: vec![0],
+            color_indices: vec![0, 1],
+        };
+        assert_eq!(resolved_f64_totals(&resolved).unwrap(), vec![3.0, 7.0]);
+
+        let mut truncated = resolved.clone();
+        truncated.values.pop();
+        assert!(
+            resolved_f64_totals(&truncated)
+                .unwrap_err()
+                .to_string()
+                .contains("inconsistent component buffer length")
+        );
+
+        let empty_axis = ResolvedValues {
+            values: Vec::new(),
+            point_count: 2,
+            helicity_indices: Vec::new(),
+            color_indices: vec![0],
+        };
+        assert_eq!(resolved_f64_totals(&empty_axis).unwrap(), vec![0.0, 0.0]);
+
+        let mut malformed_empty_axis = empty_axis;
+        malformed_empty_axis.values.push(1.0);
+        assert!(
+            resolved_f64_totals(&malformed_empty_axis)
+                .unwrap_err()
+                .to_string()
+                .contains("inconsistent component buffer length")
+        );
+    }
+
+    #[test]
+    fn accumulates_selected_routes_without_materializing_public_axis() {
+        let materialized = ResolvedValues {
+            values: vec![
+                0.0, 2.0, 0.0, 0.0, // mapping 0, point 0
+                0.0, 3.0, 0.0, 0.0, // mapping 0, point 1
+                0.0, 0.0, 0.0, 5.0, // mapping 1, point 0
+                0.0, 0.0, 0.0, 7.0, // mapping 1, point 1
+            ],
+            point_count: 4,
+            helicity_indices: vec![0, 1],
+            color_indices: vec![0, 1],
+        };
+        let entries = vec![
+            LcResolvedReplayEntry {
+                routes: vec![LcResolvedReplayRoute {
+                    source_index: 1,
+                    target_index: 0,
+                    weight: 1.0,
+                }],
+            },
+            LcResolvedReplayEntry {
+                routes: vec![LcResolvedReplayRoute {
+                    source_index: 3,
+                    target_index: 0,
+                    weight: 2.0,
+                }],
+            },
+        ];
+        let mut selected = vec![0.0; 2];
+        accumulate_selected_lc_replay_resolved_f64(&mut selected, 2, &materialized, &entries, 4, 1)
+            .expect("selected replay accumulation");
+        assert_eq!(selected, vec![12.0, 17.0]);
+    }
+
+    #[test]
+    fn accumulates_two_replay_groups_and_one_residual_exactly_once() {
+        let materialized = ResolvedValues {
+            values: vec![
+                10.0, 0.0, 20.0, 0.0, 30.0, // identity mapping
+                11.0, 0.0, 21.0, 0.0, 31.0, // shared swap mapping
+            ],
+            point_count: 2,
+            helicity_indices: vec![0],
+            color_indices: vec![0, 1, 2, 3, 4],
+        };
+        let entries = vec![
+            LcResolvedReplayEntry {
+                routes: vec![
+                    LcResolvedReplayRoute {
+                        source_index: 0,
+                        target_index: 0,
+                        weight: 1.0,
+                    },
+                    LcResolvedReplayRoute {
+                        source_index: 2,
+                        target_index: 2,
+                        weight: 1.0,
+                    },
+                    LcResolvedReplayRoute {
+                        source_index: 4,
+                        target_index: 4,
+                        weight: 1.0,
+                    },
+                ],
+            },
+            LcResolvedReplayEntry {
+                routes: vec![
+                    LcResolvedReplayRoute {
+                        source_index: 0,
+                        target_index: 1,
+                        weight: 1.0,
+                    },
+                    LcResolvedReplayRoute {
+                        source_index: 2,
+                        target_index: 3,
+                        weight: 1.0,
+                    },
+                ],
+            },
+        ];
+        let mut target = vec![0.0; 5];
+
+        accumulate_selected_lc_replay_resolved_f64(&mut target, 1, &materialized, &entries, 5, 5)
+            .unwrap();
+
+        assert_eq!(target, vec![10.0, 11.0, 20.0, 21.0, 30.0]);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/helicity_lane.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/helicity_lane.rs
new file mode 100644
index 0000000000..9cd87b04d8
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/helicity_lane.rs
@@ -0,0 +1,2373 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::sources::RuntimeSourceState;
+use super::*;
+
+#[derive(Clone, Debug)]
+pub(super) struct CompiledHelicitySelectorSchedule {
+    pub(super) selector_domain_id: usize,
+    pub(super) physical_helicity_index: usize,
+    selected_helicity_ids: BTreeSet<String>,
+    pub(super) source_states: Vec<RuntimeSourceState>,
+    pub(super) active_stage_chunk_indices: Vec<Vec<usize>>,
+    pub(super) active_amplitude_chunk_indices: Vec<usize>,
+    pub(super) root_factors: Vec<Option<Complex<f64>>>,
+    pub(super) structural_zero: bool,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct CompiledHelicityExecutionPlan {
+    schedules_by_physical_helicity: Vec<Option<Arc<CompiledHelicitySelectorSchedule>>>,
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn bind_direct_helicity_color_schedule(
+    direct: &mut compiled_direct_prototype::CompiledDirectEnginePrototype,
+    helicity_schedules: &BTreeMap<
+        usize,
+        compiled_direct_prototype::CompiledDirectValidatedSchedule,
+    >,
+    color_schedules: &BTreeMap<i64, compiled_direct_prototype::CompiledDirectValidatedSchedule>,
+    schedule: &CompiledHelicitySelectorSchedule,
+    selected: Option<&BTreeSet<i64>>,
+) -> RusticolResult<Option<Arc<compiled_direct_prototype::CompiledDirectValidatedSchedule>>> {
+    let Some(selected) = selected else {
+        return Ok(None);
+    };
+    if selected.is_empty() {
+        return Err(RusticolError::invalid_argument(
+            "compiled Direct-Arena materialized-sector selection cannot be empty",
+        ));
+    }
+    let helicity = helicity_schedules
+        .get(&schedule.selector_domain_id)
+        .ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "compiled Direct-Arena has no cold-bound helicity schedule for selector domain {}",
+                schedule.selector_domain_id
+            ))
+        })?;
+    direct
+        .bind_helicity_color_schedule(
+            schedule.selector_domain_id,
+            helicity,
+            selected,
+            color_schedules,
+        )
+        .map(Some)
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn evaluate_direct_helicity_schedule(
+    direct: &mut compiled_direct_prototype::CompiledDirectEnginePrototype,
+    schedules: &BTreeMap<usize, compiled_direct_prototype::CompiledDirectValidatedSchedule>,
+    schedule: &CompiledHelicitySelectorSchedule,
+    color_schedule: Option<&compiled_direct_prototype::CompiledDirectValidatedSchedule>,
+    execute_union: bool,
+    point_count: usize,
+) -> RusticolResult<()> {
+    if execute_union {
+        return direct.evaluate_all(point_count);
+    }
+    let direct_schedule = color_schedule
+        .or_else(|| schedules.get(&schedule.selector_domain_id))
+        .ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "compiled Direct-Arena has no cold-bound helicity schedule for selector domain {}",
+                schedule.selector_domain_id
+            ))
+        })?;
+    direct.evaluate_validated_materialized_helicity(point_count, direct_schedule)
+}
+
+impl ExecutionRuntime {
+    fn supports_materialized_helicity_totals(&self) -> bool {
+        let Some(amplitude) = self.amplitude_stage.as_ref() else {
+            return false;
+        };
+        if amplitude.color_contraction.is_none() {
+            return true;
+        }
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            self.compiled_direct_runtime.is_some()
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        {
+            false
+        }
+    }
+
+    pub(super) fn initialize_compiled_helicity_execution_plan(
+        &mut self,
+        public_label_permutation: Option<&[usize]>,
+    ) -> RusticolResult<()> {
+        if let Some(sum_runtime) = self.helicity_sum_runtime.as_mut() {
+            sum_runtime.initialize_compiled_helicity_execution_plan(public_label_permutation)?;
+        }
+        for selector_runtime in &mut self.helicity_selector_runtimes {
+            selector_runtime
+                .initialize_compiled_helicity_execution_plan(public_label_permutation)?;
+        }
+        let Some(recurrence) = self.helicity_recurrence.as_ref() else {
+            self.compiled_helicity_execution_plan = None;
+            return Ok(());
+        };
+        let Some(materialization) = recurrence.materialization.as_ref() else {
+            self.compiled_helicity_execution_plan = None;
+            return Ok(());
+        };
+        let physics = self.physics.as_ref().ok_or_else(|| {
+            RusticolError::artifact(
+                "helicity recurrence materialization requires resolved physics metadata",
+            )
+        })?;
+        if self.stages.is_none() || self.amplitude_stage.is_none() {
+            return Err(self.execution_unavailable_error());
+        }
+
+        let mut schedules_by_physical_helicity = vec![None; physics.manifest.helicities.len()];
+        let mut schedule_by_domain = vec![None; recurrence.selector_domains.len()];
+        let mut physical_helicity_by_domain = vec![None; recurrence.selector_domains.len()];
+        for schedule in &materialization.selector_schedules {
+            let domain = recurrence
+                .selector_domains
+                .get(schedule.selector_domain_id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "helicity schedule references unknown selector domain {}",
+                        schedule.selector_domain_id
+                    ))
+                })?;
+            if !domain.complete {
+                return Err(RusticolError::integrity(format!(
+                    "helicity schedule domain {} is not complete",
+                    schedule.selector_domain_id
+                )));
+            }
+            let physical_helicity_index =
+                physical_helicity_index_for_domain(physics, domain, public_label_permutation)?;
+            if physical_helicity_by_domain[schedule.selector_domain_id]
+                .replace(physical_helicity_index)
+                .is_some()
+            {
+                return Err(RusticolError::integrity(format!(
+                    "helicity selector domain {} has multiple recurrence schedules",
+                    schedule.selector_domain_id
+                )));
+            }
+
+            let source_states = if schedule.structural_zero {
+                Vec::new()
+            } else {
+                build_materialized_source_states(
+                    &self.sources,
+                    &recurrence.selector_domains,
+                    &materialization.source_routes,
+                    domain,
+                    &schedule.active_current_ids,
+                )?
+            };
+            let root_factors = materialized_root_factors_for_domain(
+                self.amplitude_output_count,
+                &materialization.amplitude_routes,
+                schedule,
+            )?;
+            schedule_by_domain[schedule.selector_domain_id] =
+                Some(Arc::new(CompiledHelicitySelectorSchedule {
+                    selector_domain_id: schedule.selector_domain_id,
+                    physical_helicity_index,
+                    selected_helicity_ids: BTreeSet::from([physics.manifest.helicities
+                        [physical_helicity_index]
+                        .id
+                        .clone()]),
+                    source_states,
+                    active_stage_chunk_indices: schedule.active_stage_chunk_indices.clone(),
+                    active_amplitude_chunk_indices: schedule.active_amplitude_chunk_indices.clone(),
+                    root_factors,
+                    structural_zero: schedule.structural_zero,
+                }));
+        }
+        let execution_domain_by_domain = helicity_execution_domain_by_domain(
+            recurrence.selector_domains.len(),
+            &materialization.amplitude_routes,
+        )?;
+        for (domain_id, execution_candidate) in schedule_by_domain.iter().enumerate() {
+            if execution_candidate.is_none() {
+                continue;
+            }
+            let physical_helicity_index =
+                physical_helicity_by_domain[domain_id].ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "helicity selector domain {domain_id} has no physical-helicity mapping"
+                    ))
+                })?;
+            let execution_domain_id = execution_domain_by_domain[domain_id];
+            let execution_schedule = schedule_by_domain
+                .get(execution_domain_id)
+                .and_then(Option::as_ref)
+                .cloned()
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "helicity selector domain {domain_id} maps to absent execution domain {execution_domain_id}"
+                    ))
+                })?;
+            if schedules_by_physical_helicity[physical_helicity_index]
+                .replace(execution_schedule)
+                .is_some()
+            {
+                return Err(RusticolError::integrity(format!(
+                    "physical helicity {} has multiple recurrence schedules",
+                    physics.manifest.helicities[physical_helicity_index].id
+                )));
+            }
+        }
+        if schedules_by_physical_helicity.iter().any(Option::is_none) {
+            return Err(RusticolError::integrity(
+                "helicity recurrence schedules do not cover every physical helicity",
+            ));
+        }
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            let mut direct_schedules = BTreeMap::new();
+            if let Some(direct) = self.compiled_direct_runtime.as_ref() {
+                for schedule in schedules_by_physical_helicity.iter().flatten() {
+                    if schedule.structural_zero
+                        || direct_schedules.contains_key(&schedule.selector_domain_id)
+                    {
+                        continue;
+                    }
+                    direct_schedules.insert(
+                        schedule.selector_domain_id,
+                        direct.bind_helicity_schedule(schedule.as_ref())?,
+                    );
+                }
+            }
+            self.compiled_direct_helicity_schedules = direct_schedules;
+        }
+        self.compiled_helicity_execution_plan = Some(CompiledHelicityExecutionPlan {
+            schedules_by_physical_helicity,
+        });
+        Ok(())
+    }
+
+    pub(super) fn has_compiled_helicity_execution_plan(&self) -> bool {
+        self.compiled_helicity_execution_plan.is_some()
+    }
+
+    /// Whether a singleton physical-helicity request can bypass a compact
+    /// helicity-sum/topology-replay execution without losing physical colour.
+    ///
+    /// A nested runtime owns a complete non-replay colour DAG. When a proper
+    /// subset of LC flows is requested, prefer the compact topology replay:
+    /// that path maps both the flow and its helicity to the representative.
+    /// The complete-colour nested runtime remains useful for all-flow calls.
+    /// A local materialized schedule is safe only when this runtime is itself
+    /// not a replay representative. Parent closures are deliberately not
+    /// considered here: replay-backed closures bypass the physical topology
+    /// contraction.
+    pub(super) fn has_safe_singleton_helicity_execution(
+        &self,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<bool> {
+        let Some(selected_helicity_ids) = selected_helicity_ids else {
+            return Ok(false);
+        };
+        if selected_helicity_ids.len() != 1 {
+            return Ok(false);
+        }
+        let Some(plan) = self.compiled_helicity_execution_plan.as_ref() else {
+            return Ok(false);
+        };
+        let physics = self.physics.as_ref().ok_or_else(|| {
+            RusticolError::artifact(
+                "helicity recurrence materialization requires resolved physics metadata",
+            )
+        })?;
+        let selected_helicity_id = selected_helicity_ids
+            .iter()
+            .next()
+            .expect("singleton helicity selection checked");
+        let helicity_index = *physics
+            .helicity_index_by_id
+            .get(selected_helicity_id)
+            .ok_or_else(|| {
+                RusticolError::selector(format!(
+                    "unknown resolved helicity id {selected_helicity_id:?}"
+                ))
+            })?;
+        let schedule = plan
+            .schedules_by_physical_helicity
+            .get(helicity_index)
+            .and_then(Option::as_ref)
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "physical helicity {} has no compiled recurrence schedule",
+                    physics.manifest.helicities[helicity_index].id
+                ))
+            })?;
+        if schedule.structural_zero {
+            return Ok(true);
+        }
+        if self.lc_topology_replay_enabled
+            && !physics.has_contracted_color_axis()
+            && physics
+                .canonical_total_color_selector(selected_color_ids)
+                .is_some()
+        {
+            return Ok(false);
+        }
+        if self
+            .helicity_selector_lane_by_domain
+            .get(&schedule.selector_domain_id)
+            .and_then(|lane_index| {
+                self.helicity_selector_runtime_schedule_modes
+                    .get(*lane_index)
+            })
+            == Some(&HelicitySelectorScheduleMode::NestedRuntime)
+        {
+            return Ok(true);
+        }
+        Ok(!self.color_topology_replay_enabled && !self.lc_topology_replay_enabled)
+    }
+
+    pub(super) fn compiled_color_selector_schedule(
+        &self,
+        materialized_sector_ids: &BTreeSet<i64>,
+    ) -> RusticolResult<Option<CompiledColorSelectorSchedule>> {
+        let Some(plan) = self.compiled_color_execution_plan.as_ref() else {
+            return Ok(None);
+        };
+        if materialized_sector_ids.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "compiled color selection requires at least one materialized sector",
+            ));
+        }
+        let mut active_stage_chunks = vec![BTreeSet::new(); self.stage_count];
+        let mut active_amplitude_chunks = BTreeSet::new();
+        for sector_id in materialized_sector_ids {
+            let schedule = plan
+                .schedules_by_materialized_sector
+                .get(sector_id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "compiled color selector has no schedule for materialized sector {sector_id}"
+                    ))
+                })?;
+            if schedule.active_stage_chunk_indices.len() != active_stage_chunks.len() {
+                return Err(RusticolError::integrity(format!(
+                    "compiled color selector sector {sector_id} has inconsistent stage coverage"
+                )));
+            }
+            for (target, source) in active_stage_chunks
+                .iter_mut()
+                .zip(&schedule.active_stage_chunk_indices)
+            {
+                target.extend(source.iter().copied());
+            }
+            active_amplitude_chunks.extend(schedule.active_amplitude_chunk_indices.iter().copied());
+        }
+        Ok(Some(CompiledColorSelectorSchedule {
+            active_stage_chunk_indices: active_stage_chunks
+                .into_iter()
+                .map(|indices| indices.into_iter().collect())
+                .collect(),
+            active_amplitude_chunk_indices: active_amplitude_chunks.into_iter().collect(),
+        }))
+    }
+
+    /// Direct totals lane for the common runtime selector shape: one physical
+    /// helicity and any manifest-ordered subset of diagonal LC colours.
+    ///
+    /// Broader helicity sums retain the resolved fallback because adding a
+    /// pre-summed colour row to a previous helicity would change the flattened
+    /// H-major/C-minor floating-point fold.
+    pub(super) fn try_run_f64_with_helicity_recurrence_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<bool> {
+        if output.len() != batch.point_count() {
+            return Err(RusticolError::invalid_argument(format!(
+                "evaluation output has length {}, expected {}",
+                output.len(),
+                batch.point_count()
+            )));
+        }
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::artifact(
+                "helicity recurrence materialization requires resolved physics metadata",
+            )
+        })?;
+        let Some(selected_helicity_ids) = selected_helicity_ids else {
+            return Ok(false);
+        };
+        if selected_helicity_ids.len() != 1 {
+            return Ok(false);
+        }
+        let selected_helicity_id = selected_helicity_ids
+            .iter()
+            .next()
+            .expect("singleton helicity selection checked");
+        let helicity_index = *physics
+            .helicity_index_by_id
+            .get(selected_helicity_id)
+            .ok_or_else(|| {
+                RusticolError::selector(format!(
+                    "unknown resolved helicity id {selected_helicity_id:?}"
+                ))
+            })?;
+        if let Some(selected_color_ids) = selected_color_ids {
+            for id in selected_color_ids {
+                if !physics.color_index_by_id.contains_key(id) {
+                    return Err(RusticolError::selector(format!(
+                        "unknown resolved color component id {id:?}"
+                    )));
+                }
+            }
+        }
+        let schedule = self
+            .compiled_helicity_execution_plan
+            .as_ref()
+            .and_then(|plan| {
+                plan.schedules_by_physical_helicity
+                    .get(helicity_index)
+                    .and_then(Option::as_ref)
+            })
+            .cloned()
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "physical helicity {} has no compiled recurrence schedule",
+                    physics.manifest.helicities[helicity_index].id
+                ))
+            })?;
+        output.fill(0.0);
+        if schedule.structural_zero {
+            return Ok(true);
+        }
+
+        let selector_lane_index = self
+            .helicity_selector_lane_by_domain
+            .get(&schedule.selector_domain_id)
+            .copied()
+            .filter(|lane_index| {
+                self.helicity_selector_runtime_schedule_modes
+                    .get(*lane_index)
+                    .is_some_and(|schedule_mode| {
+                        *schedule_mode == HelicitySelectorScheduleMode::NestedRuntime
+                            || (*schedule_mode == HelicitySelectorScheduleMode::ParentClosure
+                                && selected_color_ids.is_none()
+                                && !physics.has_contracted_color_axis()
+                                && !self.color_topology_replay_enabled
+                                && !self.lc_topology_replay_enabled)
+                    })
+            });
+        if let Some(lane_index) = selector_lane_index {
+            let schedule_mode = self
+                .helicity_selector_runtime_schedule_modes
+                .get(lane_index)
+                .copied()
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "helicity selector domain {} maps to missing schedule mode for lane {lane_index}",
+                        schedule.selector_domain_id
+                    ))
+                })?;
+            let selector_runtime = self
+                .helicity_selector_runtimes
+                .get_mut(lane_index)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "helicity selector domain {} maps to missing execution lane {lane_index}",
+                        schedule.selector_domain_id
+                    ))
+                })?;
+            match schedule_mode {
+                HelicitySelectorScheduleMode::ParentClosure => {
+                    if !selector_runtime.supports_materialized_helicity_totals() {
+                        return Ok(false);
+                    }
+                    selector_runtime.run_f64_materialized_helicity_schedule_add_into_unprofiled(
+                        batch, &physics, None, None, &schedule, true, output,
+                    )?;
+                }
+                HelicitySelectorScheduleMode::NestedRuntime => {
+                    selector_runtime.run_f64_selected_into_unprofiled(
+                        batch,
+                        Some(&schedule.selected_helicity_ids),
+                        selected_color_ids,
+                        output,
+                    )?;
+                }
+            }
+            return Ok(true);
+        }
+
+        if self.color_topology_replay_enabled || self.lc_topology_replay_enabled {
+            return Ok(false);
+        }
+        if !self.supports_materialized_helicity_totals() {
+            return Ok(false);
+        }
+        self.run_f64_materialized_helicity_schedule_add_into_unprofiled(
+            batch,
+            &physics,
+            selected_color_ids,
+            None,
+            &schedule,
+            false,
+            output,
+        )?;
+        Ok(true)
+    }
+
+    pub(super) fn run_resolved_f64_with_helicity_recurrence_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_materialized_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::artifact(
+                "helicity recurrence materialization requires resolved physics metadata",
+            )
+        })?;
+        let helicity_indices = physics.selected_helicity_indices(selected_helicity_ids)?;
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        let point_count = batch.point_count();
+        let component_count = helicity_indices
+            .len()
+            .checked_mul(color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        let mut values = vec![0.0; point_count * component_count];
+        for (helicity_position, helicity_index) in helicity_indices.iter().copied().enumerate() {
+            let schedule = self
+                .compiled_helicity_execution_plan
+                .as_ref()
+                .and_then(|plan| {
+                    plan.schedules_by_physical_helicity
+                        .get(helicity_index)
+                        .and_then(Option::as_ref)
+                })
+                .cloned()
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "physical helicity {} has no compiled recurrence schedule",
+                        physics.manifest.helicities[helicity_index].id
+                    ))
+                })?;
+            if schedule.structural_zero {
+                continue;
+            }
+            let selector_lane_index = self
+                .helicity_selector_lane_by_domain
+                .get(&schedule.selector_domain_id)
+                .copied()
+                .filter(|lane_index| {
+                    self.helicity_selector_runtime_schedule_modes
+                        .get(*lane_index)
+                        .is_some_and(|schedule_mode| {
+                            (*schedule_mode == HelicitySelectorScheduleMode::NestedRuntime
+                                && selected_materialized_sector_ids.is_none())
+                                || (*schedule_mode == HelicitySelectorScheduleMode::ParentClosure
+                                    && selected_color_ids.is_none()
+                                    && selected_materialized_sector_ids.is_none()
+                                    && !physics.has_contracted_color_axis()
+                                    && !self.color_topology_replay_enabled
+                                    && !self.lc_topology_replay_enabled)
+                        })
+                });
+            let mut selected = if let Some(lane_index) = selector_lane_index {
+                let schedule_mode = self
+                    .helicity_selector_runtime_schedule_modes
+                    .get(lane_index)
+                    .copied()
+                    .ok_or_else(|| {
+                        RusticolError::integrity(format!(
+                            "helicity selector domain {} maps to missing schedule mode for lane {lane_index}",
+                            schedule.selector_domain_id
+                        ))
+                    })?;
+                let selector_runtime = self
+                    .helicity_selector_runtimes
+                    .get_mut(lane_index)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(format!(
+                            "helicity selector domain {} maps to missing execution lane {lane_index}",
+                            schedule.selector_domain_id
+                        ))
+                    })?;
+                match schedule_mode {
+                    HelicitySelectorScheduleMode::ParentClosure => selector_runtime
+                        .run_f64_materialized_helicity_schedule_unprofiled(
+                            batch, &physics, None, None, &schedule, true,
+                        )?,
+                    HelicitySelectorScheduleMode::NestedRuntime => {
+                        let selected_helicity = BTreeSet::from([physics.manifest.helicities
+                            [schedule.physical_helicity_index]
+                            .id
+                            .clone()]);
+                        selector_runtime.run_resolved_f64_unprofiled(
+                            batch,
+                            Some(&selected_helicity),
+                            selected_color_ids,
+                        )?
+                    }
+                }
+            } else {
+                if self.color_topology_replay_enabled
+                    || (self.lc_topology_replay_enabled
+                        && selected_materialized_sector_ids.is_none())
+                {
+                    return Err(RusticolError::integrity(
+                        "topology-replay runtime cannot execute its representative materialized helicity schedule directly",
+                    ));
+                }
+                self.run_f64_materialized_helicity_schedule_unprofiled(
+                    batch,
+                    &physics,
+                    selected_color_ids,
+                    selected_materialized_sector_ids,
+                    &schedule,
+                    false,
+                )?
+            };
+            if selected.helicity_indices != [schedule.physical_helicity_index]
+                || selected.color_indices != color_indices
+                || selected.point_count != point_count
+            {
+                return Err(RusticolError::integrity(
+                    "materialized helicity schedule returned an inconsistent resolved shape",
+                ));
+            }
+            selected.helicity_indices[0] = helicity_index;
+            if helicity_indices.len() == 1 {
+                return Ok(selected);
+            }
+            for point_index in 0..point_count {
+                let source_start = point_index * color_indices.len();
+                let target_start =
+                    point_index * component_count + helicity_position * color_indices.len();
+                values[target_start..target_start + color_indices.len()].copy_from_slice(
+                    &selected.values[source_start..source_start + color_indices.len()],
+                );
+            }
+        }
+        Ok(ResolvedValues {
+            values,
+            point_count,
+            helicity_indices,
+            color_indices,
+        })
+    }
+
+    fn run_f64_materialized_helicity_schedule_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        physics: &PhysicsRuntime,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_materialized_sector_ids: Option<&BTreeSet<i64>>,
+        schedule: &CompiledHelicitySelectorSchedule,
+        execute_union: bool,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if self.compiled_direct_runtime.is_some() {
+            return self.run_f64_materialized_helicity_direct_resolved_unprofiled(
+                batch,
+                physics,
+                selected_color_ids,
+                selected_materialized_sector_ids,
+                schedule,
+                execute_union,
+            );
+        }
+        self.evaluate_f64_materialized_helicity_schedule_unprofiled(
+            batch,
+            selected_materialized_sector_ids,
+            schedule,
+            execute_union,
+        )?;
+        self.amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked")
+            .reduce_scratch_f64_for_materialized_helicity(
+                batch.point_count(),
+                physics,
+                self.normalization_factor,
+                schedule.physical_helicity_index,
+                &schedule.root_factors,
+                selected_color_ids,
+            )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn run_f64_materialized_helicity_schedule_add_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        physics: &PhysicsRuntime,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_materialized_sector_ids: Option<&BTreeSet<i64>>,
+        schedule: &CompiledHelicitySelectorSchedule,
+        execute_union: bool,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if self.compiled_direct_runtime.is_some() {
+            return self.run_f64_materialized_helicity_direct_add_into_unprofiled(
+                batch,
+                physics,
+                selected_color_ids,
+                selected_materialized_sector_ids,
+                schedule,
+                execute_union,
+                output,
+            );
+        }
+        self.evaluate_f64_materialized_helicity_schedule_unprofiled(
+            batch,
+            selected_materialized_sector_ids,
+            schedule,
+            execute_union,
+        )?;
+        self.amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked")
+            .reduce_scratch_f64_for_materialized_helicity_add_into(
+                batch.point_count(),
+                physics,
+                self.normalization_factor,
+                schedule.physical_helicity_index,
+                &schedule.root_factors,
+                selected_color_ids,
+                output,
+            )
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[allow(clippy::too_many_arguments)]
+    fn run_f64_materialized_helicity_direct_resolved_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        physics: &PhysicsRuntime,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_materialized_sector_ids: Option<&BTreeSet<i64>>,
+        schedule: &CompiledHelicitySelectorSchedule,
+        execute_union: bool,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        let point_count = batch.point_count();
+        let mut values = vec![0.0; point_count * color_indices.len()];
+        let Self {
+            compiled_direct_runtime: Some(direct),
+            compiled_direct_color_schedules,
+            compiled_direct_helicity_schedules,
+            sources,
+            external_count,
+            particle_masses,
+            momentum_slots,
+            external_is_initial,
+            model_parameter_values_f64,
+            amplitude_stage: Some(amplitude),
+            normalization_factor,
+            ..
+        } = self
+        else {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena helicity execution was selected without a complete runtime",
+            ));
+        };
+        let color_schedule = bind_direct_helicity_color_schedule(
+            direct,
+            compiled_direct_helicity_schedules,
+            compiled_direct_color_schedules,
+            schedule,
+            selected_materialized_sector_ids,
+        )?;
+        let tile_capacity = direct.reduction_tile_capacity();
+        let mut point_start = 0usize;
+        while point_start < point_count {
+            let point_stop = (point_start + tile_capacity).min(point_count);
+            direct.begin_tile_from_inputs(
+                batch.subview(point_start, point_stop)?,
+                sources,
+                Some(&schedule.source_states),
+                *external_count,
+                particle_masses,
+                momentum_slots,
+                external_is_initial,
+                model_parameter_values_f64,
+            )?;
+            evaluate_direct_helicity_schedule(
+                direct,
+                compiled_direct_helicity_schedules,
+                schedule,
+                color_schedule.as_deref(),
+                execute_union,
+                point_stop - point_start,
+            )?;
+            let resolved = amplitude.reduce_planes_f64_for_materialized_helicity(
+                direct.amplitude_planes()?,
+                physics,
+                *normalization_factor,
+                schedule.physical_helicity_index,
+                &schedule.root_factors,
+                selected_color_ids,
+            )?;
+            if resolved.helicity_indices != [schedule.physical_helicity_index]
+                || resolved.color_indices != color_indices
+                || resolved.point_count != point_stop - point_start
+            {
+                return Err(RusticolError::integrity(
+                    "compiled Direct-Arena materialized-helicity reducer returned an inconsistent shape",
+                ));
+            }
+            for tile_point in 0..resolved.point_count {
+                let source = tile_point * color_indices.len();
+                let target = (point_start + tile_point) * color_indices.len();
+                values[target..target + color_indices.len()]
+                    .copy_from_slice(&resolved.values[source..source + color_indices.len()]);
+            }
+            point_start = point_stop;
+        }
+        Ok(ResolvedValues {
+            values,
+            point_count,
+            helicity_indices: vec![schedule.physical_helicity_index],
+            color_indices,
+        })
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[allow(clippy::too_many_arguments)]
+    fn run_f64_materialized_helicity_direct_add_into_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        physics: &PhysicsRuntime,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_materialized_sector_ids: Option<&BTreeSet<i64>>,
+        schedule: &CompiledHelicitySelectorSchedule,
+        execute_union: bool,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let point_count = batch.point_count();
+        if output.len() != point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "materialized-helicity output has length {}, expected {point_count}",
+                output.len()
+            )));
+        }
+        let Self {
+            compiled_direct_runtime: Some(direct),
+            compiled_direct_color_schedules,
+            compiled_direct_helicity_schedules,
+            sources,
+            external_count,
+            particle_masses,
+            momentum_slots,
+            external_is_initial,
+            model_parameter_values_f64,
+            amplitude_stage: Some(amplitude),
+            normalization_factor,
+            ..
+        } = self
+        else {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena helicity totals were selected without a complete runtime",
+            ));
+        };
+        let color_schedule = bind_direct_helicity_color_schedule(
+            direct,
+            compiled_direct_helicity_schedules,
+            compiled_direct_color_schedules,
+            schedule,
+            selected_materialized_sector_ids,
+        )?;
+        let direct_total_plan = amplitude.bind_default_materialized_helicity_direct_total_plan(
+            schedule.selector_domain_id,
+            physics,
+            schedule.physical_helicity_index,
+            &schedule.root_factors,
+            selected_color_ids,
+        )?;
+        let tile_capacity = direct.tile_capacity();
+        let mut point_start = 0usize;
+        while point_start < point_count {
+            let point_stop = (point_start + tile_capacity).min(point_count);
+            direct.begin_tile_from_inputs(
+                batch.subview(point_start, point_stop)?,
+                sources,
+                Some(&schedule.source_states),
+                *external_count,
+                particle_masses,
+                momentum_slots,
+                external_is_initial,
+                model_parameter_values_f64,
+            )?;
+            evaluate_direct_helicity_schedule(
+                direct,
+                compiled_direct_helicity_schedules,
+                schedule,
+                color_schedule.as_deref(),
+                execute_union,
+                point_stop - point_start,
+            )?;
+            amplitude.reduce_planes_f64_for_materialized_helicity_plan_add_into(
+                direct.amplitude_planes()?,
+                *normalization_factor,
+                direct_total_plan,
+                &mut output[point_start..point_stop],
+            )?;
+            point_start = point_stop;
+        }
+        Ok(())
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn run_f64_materialized_helicity_direct_routed_components_add_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        physics: &PhysicsRuntime,
+        selected_helicity_ids: &BTreeSet<String>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_materialized_sector_ids: &BTreeSet<i64>,
+        replay_entry: &LcResolvedReplayEntry,
+        source_component_count: usize,
+        target_component_count: usize,
+        target_point_count: usize,
+        target_components: &mut [f64],
+    ) -> RusticolResult<()> {
+        if selected_helicity_ids.len() != 1 {
+            return Err(RusticolError::integrity(
+                "routed materialized-helicity execution requires one source helicity",
+            ));
+        }
+        let selected_helicity_id = selected_helicity_ids
+            .iter()
+            .next()
+            .expect("singleton source helicity checked");
+        let helicity_index = *physics
+            .helicity_index_by_id
+            .get(selected_helicity_id)
+            .ok_or_else(|| {
+                RusticolError::selector(format!(
+                    "unknown resolved helicity id {selected_helicity_id:?}"
+                ))
+            })?;
+        let schedule = self
+            .compiled_helicity_execution_plan
+            .as_ref()
+            .and_then(|plan| {
+                plan.schedules_by_physical_helicity
+                    .get(helicity_index)
+                    .and_then(Option::as_ref)
+            })
+            .cloned()
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "physical helicity {} has no compiled recurrence schedule",
+                    physics.manifest.helicities[helicity_index].id
+                ))
+            })?;
+        if schedule.structural_zero {
+            return Ok(());
+        }
+        let point_count = batch.point_count();
+        let Self {
+            compiled_direct_runtime: Some(direct),
+            compiled_direct_color_schedules,
+            compiled_direct_helicity_schedules,
+            sources,
+            external_count,
+            particle_masses,
+            momentum_slots,
+            external_is_initial,
+            model_parameter_values_f64,
+            amplitude_stage: Some(amplitude),
+            normalization_factor,
+            ..
+        } = self
+        else {
+            return Err(RusticolError::integrity(
+                "compiled Direct-Arena routed helicity execution was selected without a complete runtime",
+            ));
+        };
+        let color_schedule = bind_direct_helicity_color_schedule(
+            direct,
+            compiled_direct_helicity_schedules,
+            compiled_direct_color_schedules,
+            schedule.as_ref(),
+            Some(selected_materialized_sector_ids),
+        )?;
+        // A selected helicity/flow uses only these routed components. The
+        // complete-axis footprint can otherwise shrink even a singleton to
+        // one point per tile, despite the already allocated SIMD capacity.
+        let reduction_footprint = amplitude.compiled_direct_reduction_footprint(
+            0,
+            CompiledDirectRoutedReductionFootprint {
+                maximum_source_component_count: source_component_count,
+                maximum_target_component_count: target_component_count,
+            },
+        )?;
+        let tile_capacity = direct.reduction_tile_capacity_for_footprint(reduction_footprint)?;
+        let mut point_start = 0usize;
+        while point_start < point_count {
+            let point_stop = (point_start + tile_capacity).min(point_count);
+            direct.begin_tile_from_inputs(
+                batch.subview(point_start, point_stop)?,
+                sources,
+                Some(&schedule.source_states),
+                *external_count,
+                particle_masses,
+                momentum_slots,
+                external_is_initial,
+                model_parameter_values_f64,
+            )?;
+            evaluate_direct_helicity_schedule(
+                direct,
+                compiled_direct_helicity_schedules,
+                schedule.as_ref(),
+                color_schedule.as_deref(),
+                false,
+                point_stop - point_start,
+            )?;
+            amplitude.reduce_planes_f64_for_materialized_helicity_routed_components_add_into(
+                direct.amplitude_planes()?,
+                physics,
+                *normalization_factor,
+                schedule.physical_helicity_index,
+                &schedule.root_factors,
+                selected_color_ids,
+                replay_entry,
+                source_component_count,
+                target_component_count,
+                target_point_count,
+                point_start,
+                target_components,
+            )?;
+            point_start = point_stop;
+        }
+        Ok(())
+    }
+
+    fn evaluate_f64_materialized_helicity_schedule_unprofiled(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_materialized_sector_ids: Option<&BTreeSet<i64>>,
+        schedule: &CompiledHelicitySelectorSchedule,
+        execute_union: bool,
+    ) -> RusticolResult<()> {
+        if self.stages.is_none() || self.amplitude_stage.is_none() {
+            return Err(self.execution_unavailable_error());
+        }
+        let point_count = batch.point_count();
+        let color_schedule = selected_materialized_sector_ids
+            .map(|sector_ids| self.compiled_color_selector_schedule(sector_ids))
+            .transpose()?
+            .flatten();
+        let state_len = point_count
+            .checked_mul(self.parameter_count)
+            .ok_or_else(|| RusticolError::invalid_argument("runtime state length overflows"))?;
+        self.state_scratch_f64.resize(state_len, c64(0.0, 0.0));
+        self.state_scratch_f64_requires_clear = true;
+        let state = &mut self.state_scratch_f64;
+        let model_parameter_start = self.value_parameter_count + self.momentum_parameter_count;
+        for row in 0..point_count {
+            let point = batch.point(row);
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_sources_row_with_states(
+                &self.sources,
+                &schedule.source_states,
+                self.external_count,
+                &self.particle_masses,
+                row_state,
+                &point,
+            )?;
+        }
+        for row in 0..point_count {
+            let point = batch.point(row);
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_momenta_row(
+                &self.momentum_slots,
+                self.value_parameter_count,
+                self.external_count,
+                &self.external_is_initial,
+                row_state,
+                &point,
+            )?;
+        }
+        for row in 0..point_count {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_model_parameters_row(
+                model_parameter_start,
+                &self.model_parameter_values_f64,
+                row_state,
+            )?;
+        }
+        let stages = self.stages.as_mut().expect("generic stages checked");
+        if schedule.active_stage_chunk_indices.len() != stages.len() {
+            return Err(RusticolError::integrity(format!(
+                "helicity schedule {} has {} stage closures, expected {}",
+                schedule.selector_domain_id,
+                schedule.active_stage_chunk_indices.len(),
+                stages.len()
+            )));
+        }
+        for (stage_index, (stage, active_chunks)) in stages
+            .iter_mut()
+            .zip(&schedule.active_stage_chunk_indices)
+            .enumerate()
+        {
+            if execute_union {
+                stage.evaluate_f64_into_state(
+                    point_count,
+                    self.parameter_count,
+                    state.as_mut_slice(),
+                )?;
+            } else {
+                let combined_chunks;
+                let active_chunks = if let Some(color_schedule) = color_schedule.as_ref() {
+                    combined_chunks = intersect_sorted_chunk_indices(
+                        active_chunks,
+                        &color_schedule.active_stage_chunk_indices[stage_index],
+                    );
+                    &combined_chunks
+                } else {
+                    active_chunks
+                };
+                stage.evaluate_active_chunks_f64_into_state(
+                    point_count,
+                    self.parameter_count,
+                    state.as_mut_slice(),
+                    active_chunks,
+                )?;
+            }
+        }
+        let combined_amplitude_chunks;
+        let active_amplitude_chunks = if let Some(color_schedule) = color_schedule.as_ref() {
+            combined_amplitude_chunks = intersect_sorted_chunk_indices(
+                &schedule.active_amplitude_chunk_indices,
+                &color_schedule.active_amplitude_chunk_indices,
+            );
+            &combined_amplitude_chunks
+        } else {
+            &schedule.active_amplitude_chunk_indices
+        };
+        let amplitude = self
+            .amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked");
+        if execute_union {
+            amplitude.evaluate_f64_into_scratch(point_count, state.as_slice())?;
+        } else {
+            amplitude.evaluate_active_chunks_f64_into_scratch(
+                point_count,
+                state.as_slice(),
+                active_amplitude_chunks,
+            )?;
+        }
+        Ok(())
+    }
+
+    pub(super) fn run_resolved_f64_with_helicity_recurrence(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_materialized_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        let total_start = Instant::now();
+        let initial_orchestration_start = Instant::now();
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::artifact(
+                "helicity recurrence materialization requires resolved physics metadata",
+            )
+        })?;
+        let helicity_indices = physics.selected_helicity_indices(selected_helicity_ids)?;
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        let point_count = batch.len();
+        let component_count = helicity_indices
+            .len()
+            .checked_mul(color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        let mut values = vec![0.0; point_count * component_count];
+        let mut schedule_profiles = Vec::with_capacity(helicity_indices.len());
+        let mut orchestration_elapsed = initial_orchestration_start.elapsed();
+        for (helicity_position, helicity_index) in helicity_indices.iter().copied().enumerate() {
+            let orchestration_start = Instant::now();
+            let schedule = self
+                .compiled_helicity_execution_plan
+                .as_ref()
+                .and_then(|plan| {
+                    plan.schedules_by_physical_helicity
+                        .get(helicity_index)
+                        .and_then(Option::as_ref)
+                })
+                .cloned()
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "physical helicity {} has no compiled recurrence schedule",
+                        physics.manifest.helicities[helicity_index].id
+                    ))
+                })?;
+            if schedule.structural_zero {
+                orchestration_elapsed += orchestration_start.elapsed();
+                continue;
+            }
+            let selector_lane_index = self
+                .helicity_selector_lane_by_domain
+                .get(&schedule.selector_domain_id)
+                .copied()
+                .filter(|lane_index| {
+                    // A nested union understands public color IDs, but not a
+                    // topology-replay group's parent materialized-sector
+                    // restriction. Use the parent schedule for those groups.
+                    self.helicity_selector_runtime_schedule_modes
+                        .get(*lane_index)
+                        .is_some_and(|schedule_mode| {
+                            (*schedule_mode == HelicitySelectorScheduleMode::NestedRuntime
+                                && selected_materialized_sector_ids.is_none())
+                                || (*schedule_mode == HelicitySelectorScheduleMode::ParentClosure
+                                    && selected_color_ids.is_none()
+                                    && selected_materialized_sector_ids.is_none()
+                                    && !physics.has_contracted_color_axis()
+                                    && !self.color_topology_replay_enabled
+                                    && !self.lc_topology_replay_enabled)
+                        })
+                });
+            orchestration_elapsed += orchestration_start.elapsed();
+            let (mut selected, schedule_profile) = if let Some(lane_index) = selector_lane_index {
+                let schedule_mode = self
+                    .helicity_selector_runtime_schedule_modes
+                    .get(lane_index)
+                    .copied()
+                    .ok_or_else(|| {
+                        RusticolError::integrity(format!(
+                            "helicity selector domain {} maps to missing schedule mode for lane {lane_index}",
+                            schedule.selector_domain_id
+                        ))
+                    })?;
+                let selector_runtime = self
+                    .helicity_selector_runtimes
+                    .get_mut(lane_index)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(format!(
+                            "helicity selector domain {} maps to missing execution lane {lane_index}",
+                            schedule.selector_domain_id
+                        ))
+                    })?;
+                match schedule_mode {
+                    HelicitySelectorScheduleMode::ParentClosure => selector_runtime
+                        .run_f64_materialized_helicity_schedule(
+                            batch, &physics, None, None, &schedule, true,
+                        )?,
+                    HelicitySelectorScheduleMode::NestedRuntime => {
+                        let selected_helicity = BTreeSet::from([physics.manifest.helicities
+                            [schedule.physical_helicity_index]
+                            .id
+                            .clone()]);
+                        selector_runtime.run_resolved_f64(
+                            batch,
+                            Some(&selected_helicity),
+                            selected_color_ids,
+                        )?
+                    }
+                }
+            } else {
+                if self.color_topology_replay_enabled
+                    || (self.lc_topology_replay_enabled
+                        && selected_materialized_sector_ids.is_none())
+                {
+                    return Err(RusticolError::integrity(
+                        "topology-replay runtime cannot execute its representative materialized helicity schedule directly",
+                    ));
+                }
+                self.run_f64_materialized_helicity_schedule(
+                    batch,
+                    &physics,
+                    selected_color_ids,
+                    selected_materialized_sector_ids,
+                    &schedule,
+                    false,
+                )?
+            };
+            let post_execution_start = Instant::now();
+            if selected.helicity_indices != [schedule.physical_helicity_index]
+                || selected.color_indices != color_indices
+                || selected.point_count != point_count
+            {
+                return Err(RusticolError::integrity(
+                    "materialized helicity schedule returned an inconsistent resolved shape",
+                ));
+            }
+            selected.helicity_indices[0] = helicity_index;
+            if helicity_indices.len() == 1 {
+                let mut selected_profile = schedule_profile;
+                orchestration_elapsed += post_execution_start.elapsed();
+                selected_profile.orchestration_s += profile_duration_seconds(orchestration_elapsed);
+                selected_profile.total_s = total_start.elapsed().as_secs_f64();
+                return Ok((selected, selected_profile));
+            }
+            for point_index in 0..point_count {
+                let source_start = point_index * color_indices.len();
+                let target_start =
+                    point_index * component_count + helicity_position * color_indices.len();
+                values[target_start..target_start + color_indices.len()].copy_from_slice(
+                    &selected.values[source_start..source_start + color_indices.len()],
+                );
+            }
+            schedule_profiles.push(schedule_profile);
+            orchestration_elapsed += post_execution_start.elapsed();
+        }
+        let mut profile = RuntimeProfile::default();
+        for schedule_profile in &schedule_profiles {
+            profile.add_sector(schedule_profile);
+        }
+        profile.orchestration_s += profile_duration_seconds(orchestration_elapsed);
+        profile.total_s = total_start.elapsed().as_secs_f64();
+        Ok((
+            ResolvedValues {
+                values,
+                point_count,
+                helicity_indices,
+                color_indices,
+            },
+            profile,
+        ))
+    }
+
+    fn run_f64_materialized_helicity_schedule(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        physics: &PhysicsRuntime,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_materialized_sector_ids: Option<&BTreeSet<i64>>,
+        schedule: &CompiledHelicitySelectorSchedule,
+        execute_union: bool,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        if self.stages.is_none() || self.amplitude_stage.is_none() {
+            return Err(self.execution_unavailable_error());
+        }
+        let total_start = Instant::now();
+        let point_count = batch.len();
+        let state_prepare_start = Instant::now();
+        let color_schedule = selected_materialized_sector_ids
+            .map(|sector_ids| self.compiled_color_selector_schedule(sector_ids))
+            .transpose()?
+            .flatten();
+        let state_len = point_count
+            .checked_mul(self.parameter_count)
+            .ok_or_else(|| RusticolError::invalid_argument("runtime state length overflows"))?;
+        let state_capacity = self.state_scratch_f64.capacity();
+        self.state_scratch_f64.resize(state_len, c64(0.0, 0.0));
+        let state_prepare_elapsed = state_prepare_start.elapsed();
+        let mut scratch_reallocation_count =
+            u64::from(self.state_scratch_f64.capacity() != state_capacity);
+        // Every source, momentum, model parameter, and recursive value read by
+        // this exact closure is overwritten below.  Inactive parent-layout
+        // slots are never read, so clearing the full reusable state would only
+        // add a parent-size memory pass to a selector-specialized execution.
+        // A later full execution still clears untouched slots once.
+        self.state_scratch_f64_requires_clear = true;
+        let state = &mut self.state_scratch_f64;
+        let model_parameter_start = self.value_parameter_count + self.momentum_parameter_count;
+
+        let source_start = Instant::now();
+        for (row, point) in batch.iter().enumerate() {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_sources_row_with_states(
+                &self.sources,
+                &schedule.source_states,
+                self.external_count,
+                &self.particle_masses,
+                row_state,
+                point,
+            )?;
+        }
+        let source_fill_elapsed = source_start.elapsed();
+
+        let momentum_start = Instant::now();
+        for (row, point) in batch.iter().enumerate() {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_momenta_row(
+                &self.momentum_slots,
+                self.value_parameter_count,
+                self.external_count,
+                &self.external_is_initial,
+                row_state,
+                point,
+            )?;
+        }
+        let momentum_setup_elapsed = momentum_start.elapsed();
+
+        let model_parameter_start_time = Instant::now();
+        for row in 0..point_count {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_model_parameters_row(
+                model_parameter_start,
+                &self.model_parameter_values_f64,
+                row_state,
+            )?;
+        }
+        let model_parameter_setup_elapsed = model_parameter_start_time.elapsed();
+
+        let stages = self.stages.as_mut().expect("generic stages checked");
+        if schedule.active_stage_chunk_indices.len() != stages.len() {
+            return Err(RusticolError::integrity(format!(
+                "helicity schedule {} has {} stage closures, expected {}",
+                schedule.selector_domain_id,
+                schedule.active_stage_chunk_indices.len(),
+                stages.len()
+            )));
+        }
+        let mut stage_profiles = Vec::with_capacity(stages.len());
+        let mut stage_input_pack_by_stage_s = Vec::with_capacity(stages.len());
+        let mut stage_leaf_input_pack_by_stage_s = Vec::with_capacity(stages.len());
+        let mut stage_evaluator_call_by_stage_s = Vec::with_capacity(stages.len());
+        let mut stage_backend_call_by_stage_s = Vec::with_capacity(stages.len());
+        let mut stage_evaluator_output_gather_by_stage_s = Vec::with_capacity(stages.len());
+        let mut stage_output_assign_by_stage_s = Vec::with_capacity(stages.len());
+        for (stage_index, (stage, active_chunks)) in stages
+            .iter_mut()
+            .zip(&schedule.active_stage_chunk_indices)
+            .enumerate()
+        {
+            let stage_profile = if execute_union {
+                stage.evaluate_f64_into_state_profile(
+                    point_count,
+                    self.parameter_count,
+                    state.as_mut_slice(),
+                )?
+            } else {
+                let combined_chunks;
+                let active_chunks = if let Some(color_schedule) = color_schedule.as_ref() {
+                    combined_chunks = intersect_sorted_chunk_indices(
+                        active_chunks,
+                        &color_schedule.active_stage_chunk_indices[stage_index],
+                    );
+                    &combined_chunks
+                } else {
+                    active_chunks
+                };
+                stage.evaluate_active_chunks_f64_into_state_profile(
+                    point_count,
+                    self.parameter_count,
+                    state.as_mut_slice(),
+                    active_chunks,
+                )?
+            };
+            stage_input_pack_by_stage_s.push(stage_profile.input_pack_s);
+            stage_leaf_input_pack_by_stage_s.push(stage_profile.evaluator.leaf_input_pack_s);
+            stage_evaluator_call_by_stage_s.push(stage_profile.evaluator.legacy_evaluator_call_s);
+            stage_backend_call_by_stage_s.push(stage_profile.evaluator.evaluator_call_s);
+            stage_evaluator_output_gather_by_stage_s.push(stage_profile.evaluator.output_gather_s);
+            stage_output_assign_by_stage_s.push(stage_profile.output_assign_s);
+            stage_profiles.push(stage_profile);
+        }
+
+        let combined_amplitude_chunks;
+        let active_amplitude_chunks = if let Some(color_schedule) = color_schedule.as_ref() {
+            combined_amplitude_chunks = intersect_sorted_chunk_indices(
+                &schedule.active_amplitude_chunk_indices,
+                &color_schedule.active_amplitude_chunk_indices,
+            );
+            &combined_amplitude_chunks
+        } else {
+            &schedule.active_amplitude_chunk_indices
+        };
+        let amplitude = self
+            .amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked");
+        let amplitude_profile = if execute_union {
+            amplitude.evaluate_f64_into_scratch_profile(point_count, state.as_slice())?
+        } else {
+            amplitude.evaluate_active_chunks_f64_into_scratch_profile(
+                point_count,
+                state.as_slice(),
+                active_amplitude_chunks,
+            )?
+        };
+        let amplitude_output_length = amplitude.output_length;
+        let amplitude_input_pack_s = amplitude_profile.input_pack_s;
+        let amplitude_evaluator_call_s =
+            amplitude_profile.evaluator.legacy_evaluator_call_s + amplitude_profile.output_remap_s;
+        let reduction_start = Instant::now();
+        let resolved = self
+            .amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked")
+            .reduce_scratch_f64_for_materialized_helicity(
+                point_count,
+                physics,
+                self.normalization_factor,
+                schedule.physical_helicity_index,
+                &schedule.root_factors,
+                selected_color_ids,
+            )?;
+        let reduction_s = reduction_start.elapsed().as_secs_f64();
+        let resolved_materialized_component_count = resolved.values.len() as u64;
+        let stage_input_pack_s = stage_input_pack_by_stage_s.iter().sum::<f64>();
+        let stage_evaluator_call_s = stage_evaluator_call_by_stage_s.iter().sum::<f64>();
+        let output_assign_s = stage_output_assign_by_stage_s.iter().sum::<f64>();
+        scratch_reallocation_count += stage_profiles
+            .iter()
+            .map(|profile| {
+                profile.scratch_reallocation_count + profile.evaluator.scratch_reallocation_count
+            })
+            .sum::<u64>()
+            + amplitude_profile.scratch_reallocation_count
+            + amplitude_profile.evaluator.scratch_reallocation_count;
+        Ok((
+            resolved,
+            RuntimeProfile {
+                state_prepare_s: profile_duration_seconds(state_prepare_elapsed),
+                source_fill_s: profile_duration_seconds(source_fill_elapsed),
+                momentum_input_setup_s: profile_duration_seconds(momentum_setup_elapsed),
+                momentum_setup_s: profile_duration_seconds(
+                    momentum_setup_elapsed + model_parameter_setup_elapsed,
+                ),
+                model_parameter_setup_s: profile_duration_seconds(model_parameter_setup_elapsed),
+                stage_input_pack_s,
+                stage_leaf_input_pack_s: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.leaf_input_pack_s)
+                    .sum(),
+                stage_evaluator_call_s,
+                stage_backend_call_s: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.evaluator_call_s)
+                    .sum(),
+                stage_evaluator_output_gather_s: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.output_gather_s)
+                    .sum(),
+                stage_evaluator_s: stage_input_pack_s + stage_evaluator_call_s,
+                output_assign_s,
+                amplitude_input_pack_s,
+                amplitude_leaf_input_pack_s: amplitude_profile.evaluator.leaf_input_pack_s,
+                amplitude_evaluator_call_s,
+                amplitude_backend_call_s: amplitude_profile.evaluator.evaluator_call_s,
+                amplitude_evaluator_output_gather_s: amplitude_profile.evaluator.output_gather_s,
+                amplitude_output_remap_s: amplitude_profile.output_remap_s,
+                amplitude_evaluator_s: amplitude_input_pack_s + amplitude_evaluator_call_s,
+                reduction_s,
+                resolved_reduction_materialization_s: reduction_s,
+                total_s: total_start.elapsed().as_secs_f64(),
+                stage_input_pack_by_stage_s,
+                stage_leaf_input_pack_by_stage_s,
+                stage_evaluator_call_by_stage_s,
+                stage_backend_call_by_stage_s,
+                stage_evaluator_output_gather_by_stage_s,
+                stage_output_assign_by_stage_s,
+                state_component_count: state_len as u64,
+                source_component_count: (point_count * schedule.source_states.len()) as u64,
+                momentum_component_count: (point_count * self.momentum_parameter_count) as u64,
+                model_parameter_component_count: (point_count
+                    * self.model_parameter_values_f64.len())
+                    as u64,
+                stage_input_copy_component_count: stage_profiles
+                    .iter()
+                    .map(|profile| profile.input_copy_component_count)
+                    .sum(),
+                stage_leaf_input_copy_component_count: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.leaf_input_copy_component_count)
+                    .sum(),
+                stage_evaluator_output_gather_component_count: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.output_gather_component_count)
+                    .sum(),
+                stage_output_assign_component_count: stage_profiles
+                    .iter()
+                    .map(|profile| profile.output_assign_component_count)
+                    .sum(),
+                amplitude_input_copy_component_count: amplitude_profile.input_copy_component_count,
+                amplitude_leaf_input_copy_component_count: amplitude_profile
+                    .evaluator
+                    .leaf_input_copy_component_count,
+                amplitude_evaluator_output_gather_component_count: amplitude_profile
+                    .evaluator
+                    .output_gather_component_count,
+                amplitude_output_remap_component_count: amplitude_profile
+                    .output_remap_component_count,
+                evaluator_backend_call_count: stage_profiles
+                    .iter()
+                    .map(|profile| profile.evaluator.backend_call_count)
+                    .sum::<u64>()
+                    + amplitude_profile.evaluator.backend_call_count,
+                reduction_input_component_count: (point_count * amplitude_output_length) as u64,
+                resolved_materialized_component_count,
+                scratch_reallocation_count,
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn run_resolved_generic_with_helicity_recurrence<T>(
+        &mut self,
+        batch: &[Vec<[T; 4]>],
+        binary_precision: Option<u32>,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_materialized_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<(ResolvedValues<T>, RuntimeProfile)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let total_start = Instant::now();
+        let physics = self.physics.clone().ok_or_else(|| {
+            RusticolError::artifact(
+                "helicity recurrence materialization requires resolved physics metadata",
+            )
+        })?;
+        let helicity_indices = physics.selected_helicity_indices(selected_helicity_ids)?;
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        let point_count = batch.len();
+        let component_count = helicity_indices
+            .len()
+            .checked_mul(color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        let mut values = vec![T::new_zero(); point_count * component_count];
+        let mut schedule_profiles = Vec::with_capacity(helicity_indices.len());
+
+        for (helicity_position, helicity_index) in helicity_indices.iter().copied().enumerate() {
+            let schedule = self
+                .compiled_helicity_execution_plan
+                .as_ref()
+                .and_then(|plan| {
+                    plan.schedules_by_physical_helicity
+                        .get(helicity_index)
+                        .and_then(Option::as_ref)
+                })
+                .cloned()
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "physical helicity {} has no compiled recurrence schedule",
+                        physics.manifest.helicities[helicity_index].id
+                    ))
+                })?;
+            if schedule.structural_zero {
+                continue;
+            }
+            let nested_lane_index = self
+                .helicity_selector_lane_by_domain
+                .get(&schedule.selector_domain_id)
+                .copied()
+                .filter(|lane_index| {
+                    selected_materialized_sector_ids.is_none()
+                        && self
+                            .helicity_selector_runtime_schedule_modes
+                            .get(*lane_index)
+                            == Some(&HelicitySelectorScheduleMode::NestedRuntime)
+                });
+            let (mut selected, schedule_profile) = if let Some(lane_index) = nested_lane_index {
+                let selected_helicity = BTreeSet::from([physics.manifest.helicities
+                    [schedule.physical_helicity_index]
+                    .id
+                    .clone()]);
+                self.helicity_selector_runtimes
+                    .get_mut(lane_index)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(format!(
+                            "helicity selector domain {} maps to missing exact execution lane {lane_index}",
+                            schedule.selector_domain_id
+                        ))
+                    })?
+                    .run_resolved_generic(
+                        batch,
+                        binary_precision,
+                        Some(&selected_helicity),
+                        selected_color_ids,
+                    )?
+            } else {
+                self.run_generic_materialized_helicity_schedule(
+                    batch,
+                    binary_precision,
+                    &physics,
+                    selected_color_ids,
+                    selected_materialized_sector_ids,
+                    &schedule,
+                )?
+            };
+            if selected.helicity_indices != [schedule.physical_helicity_index]
+                || selected.color_indices != color_indices
+                || selected.point_count != point_count
+            {
+                return Err(RusticolError::integrity(
+                    "materialized helicity schedule returned an inconsistent resolved shape",
+                ));
+            }
+            selected.helicity_indices[0] = helicity_index;
+            for point_index in 0..point_count {
+                let source_start = point_index * color_indices.len();
+                let target_start =
+                    point_index * component_count + helicity_position * color_indices.len();
+                values[target_start..target_start + color_indices.len()].clone_from_slice(
+                    &selected.values[source_start..source_start + color_indices.len()],
+                );
+            }
+            schedule_profiles.push(schedule_profile);
+        }
+        let mut profile = RuntimeProfile::default();
+        for schedule_profile in &schedule_profiles {
+            profile.add_sector(schedule_profile);
+        }
+        profile.total_s = total_start.elapsed().as_secs_f64();
+        Ok((
+            ResolvedValues {
+                values,
+                point_count,
+                helicity_indices,
+                color_indices,
+            },
+            profile,
+        ))
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    fn run_generic_materialized_helicity_schedule<T>(
+        &mut self,
+        batch: &[Vec<[T; 4]>],
+        binary_precision: Option<u32>,
+        physics: &PhysicsRuntime,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        selected_materialized_sector_ids: Option<&BTreeSet<i64>>,
+        schedule: &CompiledHelicitySelectorSchedule,
+    ) -> RusticolResult<(ResolvedValues<T>, RuntimeProfile)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        if self.stages.is_none() || self.amplitude_stage.is_none() {
+            return Err(self.execution_unavailable_error());
+        }
+        let total_start = Instant::now();
+        let point_count = batch.len();
+        let color_schedule = selected_materialized_sector_ids
+            .map(|sector_ids| self.compiled_color_selector_schedule(sector_ids))
+            .transpose()?
+            .flatten();
+        let state_len = point_count
+            .checked_mul(self.parameter_count)
+            .ok_or_else(|| RusticolError::invalid_argument("runtime state length overflows"))?;
+        let mut state = vec![complex_zero::<T>(); state_len];
+        let model_parameter_start = self.value_parameter_count + self.momentum_parameter_count;
+
+        let source_start = Instant::now();
+        for (row, point) in batch.iter().enumerate() {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_sources_row_generic_with_states(
+                &self.sources,
+                &schedule.source_states,
+                self.external_count,
+                &self.particle_masses,
+                row_state,
+                point,
+            )?;
+        }
+        let source_fill_elapsed = source_start.elapsed();
+
+        let momentum_start = Instant::now();
+        for (row, point) in batch.iter().enumerate() {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_momenta_row_generic(
+                &self.momentum_slots,
+                self.value_parameter_count,
+                self.external_count,
+                &self.external_is_initial,
+                row_state,
+                point,
+            )?;
+        }
+        let momentum_setup_elapsed = momentum_start.elapsed();
+
+        let model_parameter_start_time = Instant::now();
+        for row in 0..point_count {
+            let row_state =
+                &mut state[row * self.parameter_count..(row + 1) * self.parameter_count];
+            Self::fill_model_parameters_row_generic(
+                model_parameter_start,
+                &self.model_parameter_values_f64,
+                row_state,
+            )?;
+        }
+        let model_parameter_setup_elapsed = model_parameter_start_time.elapsed();
+
+        let stages = self.stages.as_mut().expect("generic stages checked");
+        if schedule.active_stage_chunk_indices.len() != stages.len() {
+            return Err(RusticolError::integrity(format!(
+                "helicity schedule {} has {} stage closures, expected {}",
+                schedule.selector_domain_id,
+                schedule.active_stage_chunk_indices.len(),
+                stages.len()
+            )));
+        }
+        // The same certified closure applies independently of precision.
+        // Follow its chunks after intersecting the mapped colour selection.
+        let mut stage_input_pack_by_stage_s = Vec::with_capacity(stages.len());
+        let mut stage_evaluator_call_by_stage_s = Vec::with_capacity(stages.len());
+        let mut stage_output_assign_by_stage_s = Vec::with_capacity(stages.len());
+        for (stage_index, (stage, active_chunks)) in stages
+            .iter_mut()
+            .zip(&schedule.active_stage_chunk_indices)
+            .enumerate()
+        {
+            let combined_chunks;
+            let active_chunks = if let Some(color_schedule) = color_schedule.as_ref() {
+                combined_chunks = intersect_sorted_chunk_indices(
+                    active_chunks,
+                    &color_schedule.active_stage_chunk_indices[stage_index],
+                );
+                &combined_chunks
+            } else {
+                active_chunks
+            };
+            let (pack_s, eval_s, assign_s) = stage.evaluate_selected_chunks_generic_into_state(
+                point_count,
+                self.parameter_count,
+                state.as_mut_slice(),
+                binary_precision,
+                Some(active_chunks),
+            )?;
+            stage_input_pack_by_stage_s.push(pack_s);
+            stage_evaluator_call_by_stage_s.push(eval_s);
+            stage_output_assign_by_stage_s.push(assign_s);
+        }
+
+        let combined_amplitude_chunks;
+        let active_amplitude_chunks = if let Some(color_schedule) = color_schedule.as_ref() {
+            combined_amplitude_chunks = intersect_sorted_chunk_indices(
+                &schedule.active_amplitude_chunk_indices,
+                &color_schedule.active_amplitude_chunk_indices,
+            );
+            &combined_amplitude_chunks
+        } else {
+            &schedule.active_amplitude_chunk_indices
+        };
+        let (resolved, amplitude_input_pack_s, amplitude_evaluator_call_s, reduction_s) = self
+            .amplitude_stage
+            .as_mut()
+            .expect("generic amplitude stage checked")
+            .evaluate_materialized_helicity_generic(
+                point_count,
+                state.as_slice(),
+                binary_precision,
+                physics,
+                self.normalization_factor,
+                schedule.physical_helicity_index,
+                &schedule.root_factors,
+                selected_color_ids,
+                active_amplitude_chunks,
+            )?;
+        let stage_input_pack_s = stage_input_pack_by_stage_s.iter().sum::<f64>();
+        let stage_evaluator_call_s = stage_evaluator_call_by_stage_s.iter().sum::<f64>();
+        let output_assign_s = stage_output_assign_by_stage_s.iter().sum::<f64>();
+        Ok((
+            resolved,
+            RuntimeProfile {
+                source_fill_s: profile_duration_seconds(source_fill_elapsed),
+                momentum_input_setup_s: profile_duration_seconds(momentum_setup_elapsed),
+                momentum_setup_s: profile_duration_seconds(
+                    momentum_setup_elapsed + model_parameter_setup_elapsed,
+                ),
+                model_parameter_setup_s: profile_duration_seconds(model_parameter_setup_elapsed),
+                stage_input_pack_s,
+                stage_evaluator_call_s,
+                stage_evaluator_s: stage_input_pack_s + stage_evaluator_call_s,
+                output_assign_s,
+                amplitude_input_pack_s,
+                amplitude_evaluator_call_s,
+                amplitude_evaluator_s: amplitude_input_pack_s + amplitude_evaluator_call_s,
+                reduction_s,
+                total_s: total_start.elapsed().as_secs_f64(),
+                stage_input_pack_by_stage_s,
+                stage_evaluator_call_by_stage_s,
+                stage_output_assign_by_stage_s,
+                ..RuntimeProfile::default()
+            },
+        ))
+    }
+}
+
+fn intersect_sorted_chunk_indices(left: &[usize], right: &[usize]) -> Vec<usize> {
+    let mut result = Vec::with_capacity(left.len().min(right.len()));
+    let (mut left_index, mut right_index) = (0, 0);
+    while left_index < left.len() && right_index < right.len() {
+        match left[left_index].cmp(&right[right_index]) {
+            std::cmp::Ordering::Less => left_index += 1,
+            std::cmp::Ordering::Greater => right_index += 1,
+            std::cmp::Ordering::Equal => {
+                result.push(left[left_index]);
+                left_index += 1;
+                right_index += 1;
+            }
+        }
+    }
+    result
+}
+
+fn physical_helicity_index_for_domain(
+    physics: &PhysicsRuntime,
+    domain: &HelicitySelectorDomainRuntime,
+    public_label_permutation: Option<&[usize]>,
+) -> RusticolResult<usize> {
+    let external_count = physics
+        .manifest
+        .helicities
+        .first()
+        .map(|helicity| helicity.values.len())
+        .ok_or_else(|| RusticolError::artifact("physics metadata has no helicity axis"))?;
+    let mut values = vec![None; external_count];
+    for (external_index, helicity) in &domain.source_states {
+        let value = values.get_mut(*external_index).ok_or_else(|| {
+            RusticolError::integrity("helicity selector domain has a stale external label")
+        })?;
+        if value.replace(*helicity).is_some() {
+            return Err(RusticolError::integrity(
+                "helicity selector domain repeats an external label",
+            ));
+        }
+    }
+    let mut values = values
+        .into_iter()
+        .collect::<Option<Vec<_>>>()
+        .ok_or_else(|| RusticolError::integrity("helicity selector domain is incomplete"))?;
+    if let Some(permutation) = public_label_permutation {
+        values = permute_representative_helicity_to_public_alias(&values, permutation)?;
+    }
+    physics
+        .manifest
+        .helicities
+        .iter()
+        .position(|helicity| helicity.values == values)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "helicity selector domain {values:?} has no physical metadata entry"
+            ))
+        })
+}
+
+fn permute_representative_helicity_to_public_alias(
+    representative: &[i32],
+    permutation: &[usize],
+) -> RusticolResult<Vec<i32>> {
+    if permutation.len() != representative.len()
+        || permutation.iter().copied().collect::<BTreeSet<_>>()
+            != (0..representative.len()).collect::<BTreeSet<_>>()
+    {
+        return Err(RusticolError::integrity(
+            "process alias does not define a complete helicity-label permutation",
+        ));
+    }
+    let mut public = vec![0; representative.len()];
+    for (representative_index, public_index) in permutation.iter().copied().enumerate() {
+        public[public_index] = representative[representative_index];
+    }
+    Ok(public)
+}
+
+fn build_materialized_source_states(
+    sources: &[GenericSourceRecordManifest],
+    selector_domains: &[HelicitySelectorDomainRuntime],
+    source_routes: &[HelicityMaterializedSourceRouteRuntime],
+    complete_domain: &HelicitySelectorDomainRuntime,
+    active_current_ids: &[usize],
+) -> RusticolResult<Vec<RuntimeSourceState>> {
+    let active_current_ids = active_current_ids.iter().copied().collect::<BTreeSet<_>>();
+    let state_by_external = complete_domain
+        .source_states
+        .iter()
+        .copied()
+        .collect::<BTreeMap<_, _>>();
+    let mut states = Vec::with_capacity(sources.len());
+    for source in sources {
+        if !active_current_ids.contains(&source.current_id) {
+            states.push(ExecutionRuntime::inactive_runtime_source_state(source)?);
+            continue;
+        }
+        let external_index = source
+            .leg_label
+            .checked_sub(1)
+            .ok_or_else(|| RusticolError::integrity("runtime source labels must be one-based"))?;
+        let selected_helicity = state_by_external.get(&external_index).ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "active materialized source {} has no state in its complete helicity domain",
+                source.source_id
+            ))
+        })?;
+        let mut matching = source_routes.iter().filter(|route| {
+            route.materialized_current_id == source.current_id
+                && route.external_index == external_index
+                && route.helicity == *selected_helicity
+                && selector_domains
+                    .get(route.selector_domain_id)
+                    .is_some_and(|domain| {
+                        domain
+                            .source_states
+                            .iter()
+                            .all(|state| complete_domain.source_states.contains(state))
+                    })
+        });
+        let route = matching.next();
+        if matching.next().is_some() {
+            return Err(RusticolError::artifact(format!(
+                "active materialized source {} has multiple routes for helicity {}",
+                source.source_id, selected_helicity
+            )));
+        }
+        states.push(if let Some(route) = route {
+            ExecutionRuntime::runtime_source_state(
+                source,
+                route.declared_state_index,
+                c64(route.factor[0], route.factor[1]),
+            )?
+        } else {
+            let declared_state_index =
+                ExecutionRuntime::runtime_source_state_index_for_helicity(
+                    source,
+                    *selected_helicity,
+                )?
+                .ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "active materialized source {} has neither a recurrence route nor a declared state for helicity {}",
+                        source.source_id, selected_helicity
+                    ))
+                })?;
+            ExecutionRuntime::runtime_source_state(
+                source,
+                declared_state_index,
+                c64(1.0, 0.0),
+            )?
+        });
+    }
+    Ok(states)
+}
+
+fn materialized_root_factors_for_domain(
+    root_count: usize,
+    routes: &[HelicityMaterializedAmplitudeRouteRuntime],
+    schedule: &HelicityMaterializedSelectorScheduleRuntime,
+) -> RusticolResult<Vec<Option<Complex<f64>>>> {
+    let active_roots = schedule
+        .active_root_ids
+        .iter()
+        .copied()
+        .collect::<BTreeSet<_>>();
+    let mut factors = vec![None; root_count];
+    for route in routes {
+        if !route
+            .selector_domain_ids
+            .contains(&schedule.selector_domain_id)
+        {
+            continue;
+        }
+        let factor = c64(route.factor[0], route.factor[1]);
+        let target = factors.get_mut(route.materialized_root_id).ok_or_else(|| {
+            RusticolError::integrity("helicity amplitude route has a stale materialized root")
+        })?;
+        if target.replace(factor).is_some() {
+            return Err(RusticolError::artifact(format!(
+                "materialized amplitude root {} has multiple routes for selector domain {}",
+                route.materialized_root_id, schedule.selector_domain_id
+            )));
+        }
+    }
+    let routed_roots = factors
+        .iter()
+        .enumerate()
+        .filter_map(|(index, factor)| factor.as_ref().map(|_| index))
+        .collect::<BTreeSet<_>>();
+    if routed_roots != active_roots {
+        return Err(RusticolError::artifact(format!(
+            "selector domain {} amplitude routes do not match its active-root closure",
+            schedule.selector_domain_id
+        )));
+    }
+    Ok(factors)
+}
+
+fn helicity_execution_domain_by_domain(
+    domain_count: usize,
+    routes: &[HelicityMaterializedAmplitudeRouteRuntime],
+) -> RusticolResult<Vec<usize>> {
+    // The producer orders each proven route as its retained source state
+    // followed by synthetic global-flip aliases. Execute aliases through the
+    // retained source route and relabel the resolved result for the caller.
+    let mut execution_domain_by_domain = (0..domain_count).collect::<Vec<_>>();
+    let mut primary_domains = BTreeSet::new();
+    for route in routes {
+        let Some((&primary_domain, replay_domains)) = route.selector_domain_ids.split_first()
+        else {
+            return Err(RusticolError::artifact(
+                "helicity materialized amplitude route has no selector domains",
+            ));
+        };
+        if primary_domain >= domain_count {
+            return Err(RusticolError::integrity(format!(
+                "helicity amplitude route references stale primary domain {primary_domain}"
+            )));
+        }
+        primary_domains.insert(primary_domain);
+        for replay_domain in replay_domains {
+            if *replay_domain >= domain_count {
+                return Err(RusticolError::integrity(format!(
+                    "helicity amplitude route references stale replay domain {replay_domain}"
+                )));
+            }
+            let previous = execution_domain_by_domain[*replay_domain];
+            if previous != *replay_domain && previous != primary_domain {
+                return Err(RusticolError::artifact(format!(
+                    "helicity replay domain {replay_domain} maps to inconsistent execution domains {previous} and {primary_domain}"
+                )));
+            }
+            execution_domain_by_domain[*replay_domain] = primary_domain;
+        }
+    }
+    for primary_domain in primary_domains {
+        let execution_domain = execution_domain_by_domain[primary_domain];
+        if execution_domain != primary_domain {
+            return Err(RusticolError::artifact(format!(
+                "helicity selector domain {primary_domain} is both a primary and replay-only domain"
+            )));
+        }
+    }
+    Ok(execution_domain_by_domain)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn runtime_with_singleton_helicity_schedule(
+        structural_zero: bool,
+    ) -> (ExecutionRuntime, BTreeSet<String>) {
+        let mut runtime = super::super::tests::empty_generic_runtime();
+        let physics = Arc::new(super::super::tests::test_physics_runtime("full"));
+        let selected_helicity_id = physics.manifest.helicities[0].id.clone();
+        let selected_helicity_ids = BTreeSet::from([selected_helicity_id.clone()]);
+        runtime.physics = Some(physics);
+        runtime.compiled_helicity_execution_plan = Some(CompiledHelicityExecutionPlan {
+            schedules_by_physical_helicity: vec![
+                Some(Arc::new(CompiledHelicitySelectorSchedule {
+                    selector_domain_id: 0,
+                    physical_helicity_index: 0,
+                    selected_helicity_ids: BTreeSet::from([selected_helicity_id]),
+                    source_states: Vec::new(),
+                    active_stage_chunk_indices: Vec::new(),
+                    active_amplitude_chunk_indices: Vec::new(),
+                    root_factors: Vec::new(),
+                    structural_zero,
+                })),
+                None,
+            ],
+        });
+        (runtime, selected_helicity_ids)
+    }
+
+    #[test]
+    fn representative_helicity_is_permuted_into_public_alias_order() {
+        let values =
+            permute_representative_helicity_to_public_alias(&[1, -1, 0, -1, 1], &[0, 1, 3, 4, 2])
+                .unwrap();
+        assert_eq!(values, vec![1, -1, 1, 0, -1]);
+    }
+
+    #[test]
+    fn invalid_public_alias_permutation_is_rejected() {
+        let error =
+            permute_representative_helicity_to_public_alias(&[1, -1, 0], &[0, 1, 1]).unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("complete helicity-label permutation")
+        );
+    }
+
+    #[test]
+    fn global_flip_domains_execute_their_retained_partner_routes() {
+        let routes = vec![
+            HelicityMaterializedAmplitudeRouteRuntime {
+                materialized_root_id: 0,
+                selector_domain_ids: vec![2, 7],
+                factor: [1.0, 0.0],
+                residual: false,
+            },
+            HelicityMaterializedAmplitudeRouteRuntime {
+                materialized_root_id: 1,
+                selector_domain_ids: vec![3, 6],
+                factor: [1.0, 0.0],
+                residual: false,
+            },
+        ];
+
+        let execution = helicity_execution_domain_by_domain(8, &routes).unwrap();
+
+        assert_eq!(execution[2], 2);
+        assert_eq!(execution[7], 2);
+        assert_eq!(execution[3], 3);
+        assert_eq!(execution[6], 3);
+    }
+
+    #[test]
+    fn replay_owners_only_bypass_the_helicity_sum_through_nested_physical_runtimes() {
+        let (mut runtime, selected_helicity_ids) = runtime_with_singleton_helicity_schedule(false);
+        assert!(
+            runtime
+                .has_safe_singleton_helicity_execution(Some(&selected_helicity_ids), None)
+                .unwrap()
+        );
+
+        runtime.color_topology_replay_enabled = true;
+        assert!(
+            !runtime
+                .has_safe_singleton_helicity_execution(Some(&selected_helicity_ids), None)
+                .unwrap()
+        );
+
+        runtime
+            .helicity_selector_runtimes
+            .push(Box::new(super::super::tests::empty_generic_runtime()));
+        runtime
+            .helicity_selector_runtime_schedule_modes
+            .push(HelicitySelectorScheduleMode::NestedRuntime);
+        runtime.helicity_selector_lane_by_domain.insert(0, 0);
+        assert!(
+            runtime
+                .has_safe_singleton_helicity_execution(Some(&selected_helicity_ids), None)
+                .unwrap()
+        );
+
+        runtime.helicity_selector_runtime_schedule_modes[0] =
+            HelicitySelectorScheduleMode::ParentClosure;
+        assert!(
+            !runtime
+                .has_safe_singleton_helicity_execution(Some(&selected_helicity_ids), None)
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn structural_zero_singletons_are_safe_without_physical_replay() {
+        let (mut runtime, selected_helicity_ids) = runtime_with_singleton_helicity_schedule(true);
+        runtime.color_topology_replay_enabled = true;
+
+        assert!(
+            runtime
+                .has_safe_singleton_helicity_execution(Some(&selected_helicity_ids), None)
+                .unwrap()
+        );
+        assert!(
+            !runtime
+                .has_safe_singleton_helicity_execution(None, None)
+                .unwrap()
+        );
+        assert!(
+            !runtime
+                .has_safe_singleton_helicity_execution(
+                    Some(&BTreeSet::from([
+                        "hel:+-".to_string(),
+                        "hel:-+".to_string(),
+                    ])),
+                    None,
+                )
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn selected_lc_flows_keep_their_compact_replay_even_with_a_helicity_companion() {
+        let (mut runtime, selected_helicity_ids) = runtime_with_singleton_helicity_schedule(false);
+        runtime.physics = Some(Arc::new(super::super::tests::test_physics_runtime("lc")));
+        runtime.lc_topology_replay_enabled = true;
+        runtime
+            .helicity_selector_runtimes
+            .push(Box::new(super::super::tests::empty_generic_runtime()));
+        runtime
+            .helicity_selector_runtime_schedule_modes
+            .push(HelicitySelectorScheduleMode::NestedRuntime);
+        runtime.helicity_selector_lane_by_domain.insert(0, 0);
+
+        // Both the computed flow and a nontrivial replay alias must be mapped
+        // before selecting the helicity; neither belongs to the all-flow lane.
+        for flow_id in ["flow:0", "flow:1"] {
+            assert!(
+                !runtime
+                    .has_safe_singleton_helicity_execution(
+                        Some(&selected_helicity_ids),
+                        Some(&BTreeSet::from([flow_id.to_string()])),
+                    )
+                    .unwrap()
+            );
+        }
+        assert!(
+            runtime
+                .has_safe_singleton_helicity_execution(Some(&selected_helicity_ids), None)
+                .unwrap()
+        );
+        assert!(
+            runtime
+                .has_safe_singleton_helicity_execution(
+                    Some(&selected_helicity_ids),
+                    Some(&BTreeSet::from([
+                        "flow:0".to_string(),
+                        "flow:1".to_string()
+                    ])),
+                )
+                .unwrap()
+        );
+        assert!(
+            !runtime
+                .has_safe_singleton_helicity_execution(
+                    None,
+                    Some(&BTreeSet::from(["flow:0".to_string()])),
+                )
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn contracted_color_and_structural_zero_requests_keep_the_singleton_shortcut() {
+        for accuracy in ["full", "nlc"] {
+            let (mut runtime, selected_helicity_ids) =
+                runtime_with_singleton_helicity_schedule(false);
+            runtime.physics = Some(Arc::new(super::super::tests::test_physics_runtime(
+                accuracy,
+            )));
+            assert!(
+                runtime
+                    .has_safe_singleton_helicity_execution(
+                        Some(&selected_helicity_ids),
+                        Some(&BTreeSet::from(["contracted".to_string()])),
+                    )
+                    .unwrap()
+            );
+        }
+
+        let (mut runtime, selected_helicity_ids) = runtime_with_singleton_helicity_schedule(true);
+        runtime.physics = Some(Arc::new(super::super::tests::test_physics_runtime("lc")));
+        runtime.lc_topology_replay_enabled = true;
+        assert!(
+            runtime
+                .has_safe_singleton_helicity_execution(
+                    Some(&selected_helicity_ids),
+                    Some(&BTreeSet::from(["flow:1".to_string()])),
+                )
+                .unwrap()
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/model_parameters.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/model_parameters.rs
new file mode 100644
index 0000000000..0fe9425744
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/model_parameters.rs
@@ -0,0 +1,384 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+struct RuntimeParameterStateSnapshot {
+    values: Vec<f64>,
+    particle_masses: BTreeMap<i32, f64>,
+    normalization_factor: f64,
+    helicity_sum: Option<Box<RuntimeParameterStateSnapshot>>,
+    helicity_selectors: Vec<RuntimeParameterStateSnapshot>,
+    color_selectors: BTreeMap<i64, RuntimeParameterStateSnapshot>,
+}
+
+pub(super) fn parse_complex_parameter_overrides(
+    text: &str,
+    path: &Path,
+) -> RusticolResult<BTreeMap<String, (f64, f64)>> {
+    let value = serde_json::from_str::<Value>(text).map_err(|err| {
+        RusticolError::invalid_argument(format!(
+            "could not parse model-parameter JSON {}: {err}",
+            path.display()
+        ))
+    })?;
+    let object = value.as_object().ok_or_else(|| {
+        RusticolError::invalid_argument(format!(
+            "model-parameter JSON {} must contain an object",
+            path.display()
+        ))
+    })?;
+    let mut overrides = BTreeMap::new();
+    for (name, value) in object {
+        let (real, imaginary) = if let Some(real) = value.as_f64() {
+            (real, 0.0)
+        } else {
+            let components = value.as_array().ok_or_else(|| {
+                RusticolError::invalid_argument(format!(
+                    "model-parameter JSON entry {name:?} must be a real number or [real, imaginary]"
+                ))
+            })?;
+            if components.len() != 2 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "model-parameter JSON entry {name:?} must have exactly two components"
+                )));
+            }
+            let real = components[0].as_f64().ok_or_else(|| {
+                RusticolError::invalid_argument(format!(
+                    "model-parameter JSON entry {name:?} has a non-numeric real component"
+                ))
+            })?;
+            let imaginary = components[1].as_f64().ok_or_else(|| {
+                RusticolError::invalid_argument(format!(
+                    "model-parameter JSON entry {name:?} has a non-numeric imaginary component"
+                ))
+            })?;
+            (real, imaginary)
+        };
+        if !real.is_finite() || !imaginary.is_finite() {
+            return Err(RusticolError::invalid_argument(format!(
+                "model-parameter JSON entry {name:?} must contain finite values"
+            )));
+        }
+        overrides.insert(name.clone(), (real, imaginary));
+    }
+    Ok(overrides)
+}
+
+impl ExecutionRuntime {
+    pub(super) fn current_model_parameter_value(&self, name: &str) -> RusticolResult<(f64, f64)> {
+        let mut real = None;
+        let mut imaginary = 0.0;
+        for parameter in &self.model_parameters {
+            if parameter.runtime_name.as_deref().unwrap_or(&parameter.name) != name {
+                continue;
+            }
+            let value = self
+                .model_parameter_values_f64
+                .get(parameter.parameter_index)
+                .copied()
+                .ok_or_else(|| RusticolError::integrity("model-parameter value slot is absent"))?;
+            match parameter.complex_component.as_deref() {
+                Some("imag") => imaginary = value,
+                Some("real") | None => real = Some(value),
+                Some(_) => return Err(RusticolError::integrity("invalid parameter component")),
+            }
+        }
+        real.map(|value| (value, imaginary)).ok_or_else(|| {
+            RusticolError::model_parameter(format!("model parameter {name:?} has no runtime value"))
+        })
+    }
+
+    pub(super) fn apply_model_parameter_overrides(
+        &mut self,
+        overrides: &BTreeMap<String, (f64, f64)>,
+    ) -> RusticolResult<()> {
+        let snapshot = self.parameter_state_snapshot();
+        if let Err(error) = self.apply_model_parameter_overrides_recursive(overrides) {
+            self.restore_parameter_state(snapshot);
+            return Err(error);
+        }
+        Ok(())
+    }
+
+    fn apply_model_parameter_overrides_recursive(
+        &mut self,
+        overrides: &BTreeMap<String, (f64, f64)>,
+    ) -> RusticolResult<()> {
+        self.apply_model_parameter_overrides_local(overrides)?;
+        if let Some(sum_runtime) = self.helicity_sum_runtime.as_mut() {
+            sum_runtime.apply_model_parameter_overrides_recursive(overrides)?;
+        }
+        for selector_runtime in &mut self.helicity_selector_runtimes {
+            selector_runtime.apply_model_parameter_overrides_recursive(overrides)?;
+        }
+        for selector_runtime in self.color_selector_runtimes.values_mut() {
+            selector_runtime.apply_model_parameter_overrides_recursive(overrides)?;
+        }
+        Ok(())
+    }
+
+    fn parameter_state_snapshot(&self) -> RuntimeParameterStateSnapshot {
+        RuntimeParameterStateSnapshot {
+            values: self.model_parameter_values_f64.clone(),
+            particle_masses: self.particle_masses.clone(),
+            normalization_factor: self.normalization_factor,
+            helicity_sum: self
+                .helicity_sum_runtime
+                .as_deref()
+                .map(ExecutionRuntime::parameter_state_snapshot)
+                .map(Box::new),
+            helicity_selectors: self
+                .helicity_selector_runtimes
+                .iter()
+                .map(|runtime| runtime.parameter_state_snapshot())
+                .collect(),
+            color_selectors: self
+                .color_selector_runtimes
+                .iter()
+                .map(|(sector_id, runtime)| (*sector_id, runtime.parameter_state_snapshot()))
+                .collect(),
+        }
+    }
+
+    fn restore_parameter_state(&mut self, snapshot: RuntimeParameterStateSnapshot) {
+        self.model_parameter_values_f64 = snapshot.values;
+        self.particle_masses = snapshot.particle_masses;
+        self.normalization_factor = snapshot.normalization_factor;
+        if let (Some(runtime), Some(snapshot)) =
+            (self.helicity_sum_runtime.as_mut(), snapshot.helicity_sum)
+        {
+            runtime.restore_parameter_state(*snapshot);
+        }
+        for (runtime, lane_snapshot) in self
+            .helicity_selector_runtimes
+            .iter_mut()
+            .zip(snapshot.helicity_selectors)
+        {
+            runtime.restore_parameter_state(lane_snapshot);
+        }
+        for (sector_id, lane_snapshot) in snapshot.color_selectors {
+            if let Some(runtime) = self.color_selector_runtimes.get_mut(&sector_id) {
+                runtime.restore_parameter_state(lane_snapshot);
+            }
+        }
+    }
+
+    fn apply_model_parameter_overrides_local(
+        &mut self,
+        overrides: &BTreeMap<String, (f64, f64)>,
+    ) -> RusticolResult<()> {
+        let mut proposed = self.model_parameter_values_f64.clone();
+        for (name, (real, imaginary)) in overrides {
+            if self.model_parameters.iter().any(|parameter| {
+                parameter.kind == "derived_parameter_component"
+                    && parameter.runtime_name.as_deref().unwrap_or(&parameter.name) == name
+            }) {
+                return Err(RusticolError::invalid_argument(format!(
+                    "derived model parameter {name:?} is immutable",
+                )));
+            }
+            let Some(slots) = self.model_parameter_runtime_slots.get(name).copied() else {
+                return Err(RusticolError::invalid_argument(format!(
+                    "model-parameter override {name:?} is not used by process {}",
+                    self.process
+                )));
+            };
+            if slots.real >= self.model_parameter_values_f64.len()
+                || !real.is_finite()
+                || !imaginary.is_finite()
+            {
+                return Err(RusticolError::invalid_argument(format!(
+                    "model-parameter override {name:?} has invalid value [{real}, {imaginary}]",
+                )));
+            }
+            proposed[slots.real] = *real;
+            if let Some(index) = slots.imaginary {
+                if index >= self.model_parameter_values_f64.len() {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "model-parameter override {name:?} has an invalid imaginary slot"
+                    )));
+                }
+                proposed[index] = *imaginary;
+            } else if *imaginary != 0.0 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "real model parameter {name:?} cannot receive a nonzero imaginary component"
+                )));
+            }
+        }
+        refresh_derived_model_parameter_values(
+            self.model_parameter_evaluator.as_mut(),
+            &mut proposed,
+        )?;
+        let proposed_masses = self.particle_mass_parameters_for(&proposed);
+        validate_particle_mass_class_stability(&self.particle_masses, &proposed_masses)?;
+        self.model_parameter_values_f64 = proposed;
+        self.particle_masses = proposed_masses;
+        self.refresh_normalization_factor();
+        Ok(())
+    }
+
+    pub(super) fn refresh_derived_model_parameters(&mut self) -> RusticolResult<()> {
+        refresh_derived_model_parameter_values(
+            self.model_parameter_evaluator.as_mut(),
+            &mut self.model_parameter_values_f64,
+        )
+    }
+
+    fn particle_mass_parameters_for(&self, values: &[f64]) -> BTreeMap<i32, f64> {
+        let mut particle_masses = self.particle_masses.clone();
+        for parameter in &self.model_parameters {
+            if parameter.kind == "particle_mass"
+                && let Some(pdg) = parameter.pdg
+                && let Some(value) = values.get(parameter.parameter_index)
+            {
+                particle_masses.insert(pdg, *value);
+            }
+        }
+        for (pdg, name) in &self.particle_mass_parameter_names {
+            let Some(slots) = self.model_parameter_runtime_slots.get(name) else {
+                continue;
+            };
+            if let Some(value) = values.get(slots.real) {
+                particle_masses.insert(*pdg, *value);
+            }
+        }
+        particle_masses
+    }
+
+    pub(super) fn refresh_normalization_factor(&mut self) {
+        let alpha_s = self
+            .model_parameter_name_to_index
+            .get("normalization.alpha_s_me_check")
+            .and_then(|index| self.model_parameter_values_f64.get(*index))
+            .copied();
+        let alpha_ew = self
+            .model_parameter_name_to_index
+            .get("normalization.alpha_ew")
+            .and_then(|index| self.model_parameter_values_f64.get(*index))
+            .copied();
+        let mut global_coupling_factor = 1.0;
+        if self.normalization_qcd_coupling_power > 0 {
+            let Some(alpha_s) = alpha_s else {
+                return;
+            };
+            global_coupling_factor *= (4.0 * std::f64::consts::PI * alpha_s)
+                .powi(self.normalization_qcd_coupling_power as i32);
+        }
+        if self.normalization_electroweak_coupling_power > 0 {
+            let Some(alpha_ew) = alpha_ew else {
+                return;
+            };
+            global_coupling_factor *= (2.0 * 4.0 * std::f64::consts::PI * alpha_ew)
+                .powi(self.normalization_electroweak_coupling_power as i32);
+        }
+        self.normalization_factor = self.normalization_color_factor * global_coupling_factor
+            / (self.normalization_average_factor * self.normalization_identical_factor);
+    }
+}
+
+pub(super) fn refresh_derived_model_parameter_values(
+    runtime: Option<&mut ModelParameterEvaluatorRuntime>,
+    values: &mut [f64],
+) -> RusticolResult<()> {
+    let Some(runtime) = runtime else {
+        return Ok(());
+    };
+    let parameters = runtime
+        .input_parameter_indices
+        .iter()
+        .map(|index| {
+            values
+                .get(*index)
+                .copied()
+                .map(|value| c64(value, 0.0))
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(format!(
+                        "model-parameter evaluator input index {index} is out of range"
+                    ))
+                })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let evaluated = runtime.evaluator.evaluate_single_row(&parameters)?;
+    for output in &runtime.outputs {
+        let value = evaluated.get(output.output_index).ok_or_else(|| {
+            RusticolError::invalid_argument(format!(
+                "model-parameter evaluator output {} for {:?} is absent",
+                output.output_index, output.runtime_name
+            ))
+        })?;
+        let Some(real) = values.get_mut(output.real_parameter_index) else {
+            return Err(RusticolError::invalid_argument(format!(
+                "derived model-parameter real slot {} is out of range",
+                output.real_parameter_index
+            )));
+        };
+        *real = value.re;
+        if let Some(index) = output.imag_parameter_index {
+            let imaginary = values.get_mut(index).ok_or_else(|| {
+                RusticolError::invalid_argument(format!(
+                    "derived model-parameter imaginary slot {index} is out of range"
+                ))
+            })?;
+            *imaginary = value.im;
+        }
+    }
+    Ok(())
+}
+
+fn validate_particle_mass_class_stability(
+    previous: &BTreeMap<i32, f64>,
+    proposed: &BTreeMap<i32, f64>,
+) -> RusticolResult<()> {
+    for (pdg, previous_mass) in previous {
+        let Some(proposed_mass) = proposed.get(pdg) else {
+            continue;
+        };
+        if (*previous_mass == 0.0) != (*proposed_mass == 0.0) {
+            return Err(RusticolError::invalid_argument(format!(
+                "model-parameter update changes particle {pdg} from a {} to a {} mass class; regenerate the process artifact for that mass class",
+                if *previous_mass == 0.0 {
+                    "massless"
+                } else {
+                    "massive"
+                },
+                if *proposed_mass == 0.0 {
+                    "massless"
+                } else {
+                    "massive"
+                },
+            )));
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod parameter_json_tests {
+    use super::parse_complex_parameter_overrides;
+    use std::path::Path;
+
+    #[test]
+    fn parameter_json_accepts_real_scalars_and_complex_pairs() {
+        let parsed = parse_complex_parameter_overrides(
+            r#"{"aS": 0.117, "complex": [2.5, -0.25]}"#,
+            Path::new("parameters.json"),
+        )
+        .expect("parameter card should parse");
+
+        assert_eq!(parsed.get("aS"), Some(&(0.117, 0.0)));
+        assert_eq!(parsed.get("complex"), Some(&(2.5, -0.25)));
+    }
+
+    #[test]
+    fn parameter_json_rejects_non_numeric_values() {
+        let error =
+            parse_complex_parameter_overrides(r#"{"aS": "0.117"}"#, Path::new("parameters.json"))
+                .expect_err("string parameter must fail");
+
+        assert!(
+            error
+                .to_string()
+                .contains("must be a real number or [real, imaginary]")
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/momentum.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/momentum.rs
new file mode 100644
index 0000000000..e87fc15448
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/momentum.rs
@@ -0,0 +1,498 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+#[derive(Clone, Copy)]
+enum F64MomentumBatchStorage<'a> {
+    Contiguous(&'a [f64]),
+    Nested(&'a [Vec<[f64; 4]>]),
+}
+
+/// Borrowed row-major momentum input used by the ordinary f64 lane.
+///
+/// Contiguous inputs have layout `[point][external][E, px, py, pz]`.  An
+/// optional crossing lookup is validated and normalized when the runtime is
+/// loaded, so individual momentum reads need no allocation or map search.
+#[derive(Clone, Copy)]
+pub(super) struct F64MomentumBatchView<'a> {
+    storage: F64MomentumBatchStorage<'a>,
+    point_count: usize,
+    external_count: usize,
+    crossing_lookup: Option<&'a [InputCrossingMapEntry]>,
+}
+
+#[derive(Clone, Copy)]
+pub(super) enum F64MomentumPointView<'a> {
+    ContiguousIdentity {
+        values: &'a [f64],
+        external_count: usize,
+    },
+    ContiguousCrossed {
+        values: &'a [f64],
+        external_count: usize,
+        crossing_lookup: &'a [InputCrossingMapEntry],
+    },
+    Nested(&'a [[f64; 4]]),
+}
+
+pub(super) trait F64MomentumPoint {
+    fn momentum(&self, external_index: usize) -> Option<[f64; 4]>;
+}
+
+impl F64MomentumPoint for F64MomentumPointView<'_> {
+    #[inline(always)]
+    fn momentum(&self, external_index: usize) -> Option<[f64; 4]> {
+        match self {
+            Self::ContiguousIdentity {
+                values,
+                external_count,
+            } => {
+                if external_index >= *external_count {
+                    return None;
+                }
+                let start = external_index * 4;
+                Some([
+                    values[start],
+                    values[start + 1],
+                    values[start + 2],
+                    values[start + 3],
+                ])
+            }
+            Self::ContiguousCrossed {
+                values,
+                external_count,
+                crossing_lookup,
+            } => {
+                if external_index >= *external_count {
+                    return None;
+                }
+                let entry = &crossing_lookup[external_index];
+                debug_assert_eq!(entry.target_index, external_index);
+                let start = entry.source_index * 4;
+                Some([
+                    entry.sign * values[start],
+                    entry.sign * values[start + 1],
+                    entry.sign * values[start + 2],
+                    entry.sign * values[start + 3],
+                ])
+            }
+            Self::Nested(values) => values.get(external_index).copied(),
+        }
+    }
+}
+
+impl F64MomentumPoint for [[f64; 4]] {
+    #[inline(always)]
+    fn momentum(&self, external_index: usize) -> Option<[f64; 4]> {
+        self.get(external_index).copied()
+    }
+}
+
+impl F64MomentumPoint for Vec<[f64; 4]> {
+    #[inline(always)]
+    fn momentum(&self, external_index: usize) -> Option<[f64; 4]> {
+        self.get(external_index).copied()
+    }
+}
+
+impl<const N: usize> F64MomentumPoint for [[f64; 4]; N] {
+    #[inline(always)]
+    fn momentum(&self, external_index: usize) -> Option<[f64; 4]> {
+        self.get(external_index).copied()
+    }
+}
+
+impl<'a> F64MomentumBatchView<'a> {
+    pub(super) fn from_contiguous_prevalidated(
+        values: &'a [f64],
+        point_count: usize,
+        external_count: usize,
+        crossing_lookup: Option<&'a [InputCrossingMapEntry]>,
+    ) -> RusticolResult<Self> {
+        if point_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "point_count must be positive",
+            ));
+        }
+        let values_per_point = external_count
+            .checked_mul(4)
+            .ok_or_else(|| RusticolError::invalid_argument("momentum shape overflow"))?;
+        let expected = point_count
+            .checked_mul(values_per_point)
+            .ok_or_else(|| RusticolError::invalid_argument("momentum shape overflow"))?;
+        if values.len() != expected {
+            return Err(RusticolError::invalid_argument(format!(
+                "momenta contain {} values, expected {expected} for shape ({point_count}, {external_count}, 4)",
+                values.len()
+            )));
+        }
+        if crossing_lookup.is_some_and(|lookup| lookup.len() != external_count) {
+            return Err(RusticolError::integrity(
+                "prevalidated input crossing lookup has an inconsistent length",
+            ));
+        }
+        Ok(Self {
+            storage: F64MomentumBatchStorage::Contiguous(values),
+            point_count,
+            external_count,
+            crossing_lookup,
+        })
+    }
+
+    pub(super) fn from_nested(
+        values: &'a [Vec<[f64; 4]>],
+        external_count: usize,
+    ) -> RusticolResult<Self> {
+        if values.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "point_count must be positive",
+            ));
+        }
+        if let Some(point) = values.iter().find(|point| point.len() != external_count) {
+            return Err(RusticolError::invalid_argument(format!(
+                "momentum point contains {} external legs, expected {external_count}",
+                point.len()
+            )));
+        }
+        Ok(Self {
+            storage: F64MomentumBatchStorage::Nested(values),
+            point_count: values.len(),
+            external_count,
+            crossing_lookup: None,
+        })
+    }
+
+    pub(super) fn point_count(self) -> usize {
+        self.point_count
+    }
+
+    pub(super) fn external_count(self) -> usize {
+        self.external_count
+    }
+
+    /// Execute one term of an already-generated momentum sum into a point
+    /// plane. Resolve the public input layout and crossing once per term, not
+    /// once per point. `ADD = false` starts the sum with the same positive
+    /// zero as the scalar momentum accumulator, including for signed zeros.
+    #[inline]
+    pub(super) fn accumulate_component_into<const ADD: bool>(
+        self,
+        external_index: usize,
+        component: usize,
+        coefficient: f64,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        if external_index >= self.external_count
+            || component >= 4
+            || output.len() != self.point_count
+        {
+            return Err(RusticolError::integrity(
+                "momentum component plane has an invalid input or output range",
+            ));
+        }
+        #[inline(always)]
+        fn store<const ADD: bool>(output: &mut f64, coefficient: f64, value: f64) {
+            let previous = if ADD { *output } else { 0.0 };
+            *output = previous + coefficient * value;
+        }
+        match self.storage {
+            F64MomentumBatchStorage::Contiguous(values) => {
+                let point_stride = self.external_count * 4;
+                if let Some(crossing) = self.crossing_lookup {
+                    let entry = &crossing[external_index];
+                    let input_start = entry.source_index * 4 + component;
+                    for (target, &value) in output
+                        .iter_mut()
+                        .zip(values[input_start..].iter().step_by(point_stride))
+                    {
+                        // Keep both multiplications in their scalar order;
+                        // do not combine the crossing and sum coefficients.
+                        store::<ADD>(target, coefficient, entry.sign * value);
+                    }
+                } else {
+                    let input_start = external_index * 4 + component;
+                    for (target, &value) in output
+                        .iter_mut()
+                        .zip(values[input_start..].iter().step_by(point_stride))
+                    {
+                        store::<ADD>(target, coefficient, value);
+                    }
+                }
+            }
+            F64MomentumBatchStorage::Nested(values) => {
+                for (target, point) in output.iter_mut().zip(values) {
+                    store::<ADD>(target, coefficient, point[external_index][component]);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    #[inline(always)]
+    pub(super) fn point(self, point_index: usize) -> F64MomentumPointView<'a> {
+        assert!(point_index < self.point_count);
+        match self.storage {
+            F64MomentumBatchStorage::Contiguous(values) => {
+                let values_per_point = self.external_count * 4;
+                let start = point_index * values_per_point;
+                let values = &values[start..start + values_per_point];
+                match self.crossing_lookup {
+                    Some(crossing_lookup) => F64MomentumPointView::ContiguousCrossed {
+                        values,
+                        external_count: self.external_count,
+                        crossing_lookup,
+                    },
+                    None => F64MomentumPointView::ContiguousIdentity {
+                        values,
+                        external_count: self.external_count,
+                    },
+                }
+            }
+            F64MomentumBatchStorage::Nested(values) => {
+                F64MomentumPointView::Nested(values[point_index].as_slice())
+            }
+        }
+    }
+
+    pub(super) fn subview(self, start: usize, end: usize) -> RusticolResult<Self> {
+        if start >= end || end > self.point_count {
+            return Err(RusticolError::invalid_argument(
+                "momentum batch subview has an invalid point range",
+            ));
+        }
+        match self.storage {
+            F64MomentumBatchStorage::Contiguous(values) => {
+                let values_per_point = self.external_count * 4;
+                Self::from_contiguous_prevalidated(
+                    &values[start * values_per_point..end * values_per_point],
+                    end - start,
+                    self.external_count,
+                    self.crossing_lookup,
+                )
+            }
+            F64MomentumBatchStorage::Nested(values) => {
+                Self::from_nested(&values[start..end], self.external_count)
+            }
+        }
+    }
+
+    pub(super) fn materialize_nested(self) -> Vec<Vec<[f64; 4]>> {
+        (0..self.point_count)
+            .map(|point_index| {
+                let point = self.point(point_index);
+                (0..self.external_count)
+                    .map(|external_index| {
+                        point
+                            .momentum(external_index)
+                            .expect("validated momentum view covers every external leg")
+                    })
+                    .collect()
+            })
+            .collect()
+    }
+}
+
+pub(super) fn prevalidate_input_crossing_lookup(
+    expected_legs: usize,
+    input_crossing_map: Option<Vec<InputCrossingMapEntry>>,
+) -> RusticolResult<Option<Vec<InputCrossingMapEntry>>> {
+    let Some(mut map) = input_crossing_map else {
+        return Ok(None);
+    };
+    if map.len() != expected_legs {
+        return Err(RusticolError::invalid_argument(format!(
+            "input crossing map has {} entries, expected {expected_legs}",
+            map.len()
+        )));
+    }
+    map.sort_unstable_by_key(|entry| entry.target_index);
+    for (target_index, entry) in map.iter().enumerate() {
+        if entry.target_index != target_index || entry.source_index >= expected_legs {
+            return Err(RusticolError::invalid_argument(
+                "input crossing map is not a complete in-range target lookup",
+            ));
+        }
+    }
+    Ok(Some(map))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn contiguous_view_matches_materialized_crossing_and_subviews() {
+        let values = [
+            1.0, 2.0, 3.0, 4.0, 10.0, 20.0, 30.0, 40.0, 100.0, 200.0, 300.0, 400.0, 5.0, 6.0, 7.0,
+            8.0, 50.0, 60.0, 70.0, 80.0, 500.0, 600.0, 700.0, 800.0,
+        ];
+        let lookup = prevalidate_input_crossing_lookup(
+            3,
+            Some(vec![
+                InputCrossingMapEntry {
+                    target_index: 2,
+                    source_index: 0,
+                    sign: -1.0,
+                },
+                InputCrossingMapEntry {
+                    target_index: 0,
+                    source_index: 2,
+                    sign: 1.0,
+                },
+                InputCrossingMapEntry {
+                    target_index: 1,
+                    source_index: 1,
+                    sign: 1.0,
+                },
+            ]),
+        )
+        .unwrap()
+        .unwrap();
+        let view = F64MomentumBatchView::from_contiguous_prevalidated(&values, 2, 3, Some(&lookup))
+            .unwrap();
+        let nested = vec![
+            vec![
+                [1.0, 2.0, 3.0, 4.0],
+                [10.0, 20.0, 30.0, 40.0],
+                [100.0, 200.0, 300.0, 400.0],
+            ],
+            vec![
+                [5.0, 6.0, 7.0, 8.0],
+                [50.0, 60.0, 70.0, 80.0],
+                [500.0, 600.0, 700.0, 800.0],
+            ],
+        ];
+        let expected = apply_input_crossing_map(nested, 3, Some(&lookup)).unwrap();
+
+        assert_eq!(view.materialize_nested(), expected);
+        assert_eq!(
+            view.point(0).momentum(0),
+            Some([100.0, 200.0, 300.0, 400.0])
+        );
+        assert_eq!(view.point(0).momentum(2), Some([-1.0, -2.0, -3.0, -4.0]));
+        assert_eq!(
+            view.subview(1, 2).unwrap().materialize_nested(),
+            expected[1..]
+        );
+    }
+
+    #[test]
+    fn contiguous_view_rejects_invalid_shapes() {
+        assert!(F64MomentumBatchView::from_contiguous_prevalidated(&[], 0, 2, None).is_err());
+        assert!(F64MomentumBatchView::from_contiguous_prevalidated(&[0.0; 7], 1, 2, None).is_err());
+    }
+
+    #[test]
+    fn component_plane_accumulation_matches_scalar_bits_for_every_layout() {
+        let numbers = [
+            0.0,
+            -0.0,
+            1.0,
+            -1.0,
+            f64::MAX,
+            f64::MIN_POSITIVE,
+            1e16,
+            -1e16,
+        ];
+        let nested = (0..19)
+            .map(|point| {
+                (0..3)
+                    .map(|external| {
+                        std::array::from_fn(|component| {
+                            numbers[(point + external * 3 + component) % numbers.len()]
+                        })
+                    })
+                    .collect::<Vec<[f64; 4]>>()
+            })
+            .collect::<Vec<_>>();
+        let flat = nested
+            .iter()
+            .flatten()
+            .flatten()
+            .copied()
+            .collect::<Vec<_>>();
+        let crossing = [
+            InputCrossingMapEntry {
+                target_index: 0,
+                source_index: 2,
+                sign: 2.0,
+            },
+            InputCrossingMapEntry {
+                target_index: 1,
+                source_index: 0,
+                sign: -1.0,
+            },
+            InputCrossingMapEntry {
+                target_index: 2,
+                source_index: 1,
+                sign: 0.5,
+            },
+        ];
+        let views = [
+            F64MomentumBatchView::from_nested(&nested, 3).unwrap(),
+            F64MomentumBatchView::from_contiguous_prevalidated(&flat, 19, 3, None).unwrap(),
+            F64MomentumBatchView::from_contiguous_prevalidated(&flat, 19, 3, Some(&crossing))
+                .unwrap(),
+        ];
+        for view in views {
+            for count in [1, 3, 17] {
+                let batch = view.subview(1, 1 + count).unwrap();
+                for external in 0..3 {
+                    for component in 0..4 {
+                        for coefficient in [1.0, -1.0, 0.25, -0.0] {
+                            let mut output = vec![23.0; count + 5];
+                            let pointer = output.as_ptr();
+                            batch
+                                .accumulate_component_into::<false>(
+                                    external,
+                                    component,
+                                    coefficient,
+                                    &mut output[..count],
+                                )
+                                .unwrap();
+                            for (point, &actual) in output[..count].iter().enumerate() {
+                                let value =
+                                    batch.point(point).momentum(external).unwrap()[component];
+                                let expected = 0.0 + coefficient * value;
+                                assert_eq!(actual.to_bits(), expected.to_bits());
+                            }
+                            let previous = output[..count].to_vec();
+                            batch
+                                .accumulate_component_into::<true>(
+                                    external,
+                                    component,
+                                    coefficient,
+                                    &mut output[..count],
+                                )
+                                .unwrap();
+                            for (point, &actual) in output[..count].iter().enumerate() {
+                                let value =
+                                    batch.point(point).momentum(external).unwrap()[component];
+                                let expected = previous[point] + coefficient * value;
+                                assert_eq!(actual.to_bits(), expected.to_bits());
+                            }
+                            assert_eq!(output.as_ptr(), pointer);
+                            assert!(output[count..].iter().all(|&value| value == 23.0));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn component_plane_accumulation_rejects_invalid_ranges() {
+        let values = [0.0; 12];
+        let batch =
+            F64MomentumBatchView::from_contiguous_prevalidated(&values, 1, 3, None).unwrap();
+        for (external, component, len) in [(3, 0, 1), (0, 4, 1), (0, 0, 0), (0, 0, 2)] {
+            let mut output = vec![23.0; len];
+            assert!(
+                batch
+                    .accumulate_component_into::<false>(external, component, 1.0, &mut output,)
+                    .is_err()
+            );
+            assert!(output.iter().all(|&value| value == 23.0));
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/native_runtime.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/native_runtime.rs
new file mode 100644
index 0000000000..40c931f570
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/native_runtime.rs
@@ -0,0 +1,5168 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+use std::borrow::Cow;
+use std::sync::OnceLock;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[path = "on_the_fly_cache.rs"]
+mod cache;
+
+enum DeferredProcessPhysicsV1 {
+    #[expect(
+        dead_code,
+        reason = "retained for the lazy dense-metadata compatibility path"
+    )]
+    Dense {
+        artifact: Box<VerifiedArtifact>,
+        selection: crate::ArtifactSelection,
+    },
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    OnTheFly {
+        metadata: super::on_the_fly_public_metadata::OnTheFlyPublicMetadataV1,
+        selectors: super::on_the_fly_selectors::OnTheFlyCompactSelectorAdapterV1,
+        selection: Box<crate::ArtifactSelection>,
+    },
+}
+
+/// Dense public process metadata is deliberately not part of ordinary
+/// on-the-fly load/evaluation. Existing explicit metadata accessors retain
+/// their API and initialize this cell on first use.
+pub(super) struct LazyProcessPhysicsV1 {
+    value: OnceLock<RusticolResult<ProcessPhysicsV1>>,
+    deferred: Option<DeferredProcessPhysicsV1>,
+}
+
+impl LazyProcessPhysicsV1 {
+    pub(super) fn loaded(value: ProcessPhysicsV1) -> Self {
+        let cell = OnceLock::new();
+        cell.set(Ok(value))
+            .expect("fresh process-physics cell must be empty");
+        Self {
+            value: cell,
+            deferred: None,
+        }
+    }
+
+    #[cfg(test)]
+    pub(super) const fn unavailable() -> Self {
+        Self {
+            value: OnceLock::new(),
+            deferred: None,
+        }
+    }
+
+    #[expect(
+        dead_code,
+        reason = "retained for the lazy dense-metadata compatibility path"
+    )]
+    fn deferred(artifact: VerifiedArtifact, selection: crate::ArtifactSelection) -> Self {
+        Self {
+            value: OnceLock::new(),
+            deferred: Some(DeferredProcessPhysicsV1::Dense {
+                artifact: Box::new(artifact),
+                selection,
+            }),
+        }
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    pub(super) fn deferred_on_the_fly(
+        metadata: super::on_the_fly_public_metadata::OnTheFlyPublicMetadataV1,
+        selectors: super::on_the_fly_selectors::OnTheFlyCompactSelectorAdapterV1,
+        selection: crate::ArtifactSelection,
+    ) -> Self {
+        Self {
+            value: OnceLock::new(),
+            deferred: Some(DeferredProcessPhysicsV1::OnTheFly {
+                metadata,
+                selectors,
+                selection: Box::new(selection),
+            }),
+        }
+    }
+
+    pub(super) fn get(&self) -> RusticolResult<&ProcessPhysicsV1> {
+        let result = self.value.get_or_init(|| {
+            let deferred = self.deferred.as_ref().ok_or_else(|| {
+                RusticolError::internal("process-physics cell has no value or deferred source")
+            })?;
+            match deferred {
+                DeferredProcessPhysicsV1::Dense {
+                    artifact,
+                    selection,
+                } => {
+                    let bytes = artifact.read_payload(&selection.process.physics_path)?;
+                    let physics =
+                        ProcessPhysicsV1::from_json(&bytes, &selection.process.physics_path)?;
+                    validate_representative_physics(&physics, selection)?;
+                    public_process_physics(physics, selection)
+                }
+                #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                DeferredProcessPhysicsV1::OnTheFly {
+                    metadata,
+                    selectors,
+                    selection,
+                } => {
+                    let physics = metadata.synthesize(selectors)?;
+                    validate_representative_physics(&physics, selection)?;
+                    public_process_physics(physics, selection)
+                }
+            }
+        });
+        result.as_ref().map_err(Clone::clone)
+    }
+}
+
+/// Public metadata of `selection`: the representative physics remapped to the
+/// requested order and, for a process-group member, relabelled as the member.
+fn public_process_physics(
+    physics: ProcessPhysicsV1,
+    selection: &crate::ArtifactSelection,
+) -> RusticolResult<ProcessPhysicsV1> {
+    if !selection.remaps_public_process() {
+        return Ok(physics);
+    }
+    let physics = apply_process_permutation_metadata(physics, selection)?;
+    if selection.process_group.is_some() {
+        apply_process_group_metadata(&physics, selection)
+    } else {
+        Ok(physics)
+    }
+}
+
+fn process_group_routing(
+    selection: &crate::ArtifactSelection,
+    representative_key: &str,
+) -> Option<Box<ProcessGroupRouting>> {
+    selection.process_group.as_ref().map(|group| {
+        Box::new(ProcessGroupRouting {
+            representative_process_key: representative_key.to_string(),
+            factor: NativeRationalFactor {
+                numerator: group.factor_numerator,
+                denominator: group.factor_denominator,
+            },
+            conjugated: group.conjugated,
+        })
+    })
+}
+
+fn validate_representative_physics(
+    physics: &ProcessPhysicsV1,
+    selection: &crate::ArtifactSelection,
+) -> RusticolResult<()> {
+    if physics.process_id != selection.process.id
+        || physics.process != selection.process.expression
+        || physics.color_accuracy.as_str() != selection.process.color_accuracy
+        || physics
+            .external_particles
+            .iter()
+            .map(|particle| particle.pdg)
+            .ne(selection.process.external_pdgs.iter().copied())
+    {
+        return Err(RusticolError::integrity(format!(
+            "runtime physics payload {:?} does not match process {:?}",
+            selection.process.physics_path, selection.process.id
+        )));
+    }
+    Ok(())
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[derive(Clone, Debug, Eq, PartialEq, bincode::Encode, bincode::Decode)]
+struct OnTheFlySelectionIdentityV1 {
+    helicity_ordinals: Option<Box<[usize]>>,
+    color_ordinals: Option<Box<[usize]>>,
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+impl OnTheFlySelectionIdentityV1 {
+    fn from_slices(helicity_ordinals: Option<&[usize]>, color_ordinals: Option<&[usize]>) -> Self {
+        Self {
+            helicity_ordinals: helicity_ordinals.map(|values| values.to_vec().into_boxed_slice()),
+            color_ordinals: color_ordinals.map(|values| values.to_vec().into_boxed_slice()),
+        }
+    }
+
+    fn selected_axis_matches(
+        ordinals: Option<&[usize]>,
+        prepared_ids: &[String],
+        selected_ids: Option<&BTreeSet<String>>,
+    ) -> bool {
+        match (ordinals, selected_ids) {
+            (None, None) => true,
+            (Some(_), Some(selected)) => {
+                prepared_ids.len() == selected.len()
+                    && prepared_ids.iter().all(|id| selected.contains(id))
+            }
+            _ => false,
+        }
+    }
+
+    fn matches_fixed_selection(
+        &self,
+        prepared_helicity_ids: &[String],
+        prepared_color_ids: &[String],
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> bool {
+        Self::selected_axis_matches(
+            self.helicity_ordinals.as_deref(),
+            prepared_helicity_ids,
+            selected_helicities,
+        ) && Self::selected_axis_matches(
+            self.color_ordinals.as_deref(),
+            prepared_color_ids,
+            selected_colors,
+        )
+    }
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[derive(Debug)]
+struct OnTheFlyPreparedSelectionV1 {
+    identity: OnTheFlySelectionIdentityV1,
+    helicity_indices: Box<[usize]>,
+    color_indices: Box<[usize]>,
+    helicity_ids: Box<[String]>,
+    color_ids: Box<[String]>,
+    query_count: usize,
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+struct OnTheFlyWarmUpPreparedSelectionV1 {
+    helicity_count: usize,
+    color_count: usize,
+    query_count: usize,
+    already_warm: bool,
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+enum OnTheFlyReductionV1 {
+    Lc,
+    Contracted(Box<super::on_the_fly_load::LoadedOnTheFlyColorContractionV1>),
+}
+
+type OnTheFlySelectedOrdinalsV1 = (Option<Box<[usize]>>, Option<Box<[usize]>>);
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+pub(super) struct OnTheFlyExecutionRuntime {
+    lane: super::on_the_fly_lane::OnTheFlyNativeRuntime,
+    selectors: super::on_the_fly_selectors::OnTheFlyCompactSelectorAdapterV1,
+    reduction: OnTheFlyReductionV1,
+    prepared_selections: Vec<OnTheFlyPreparedSelectionV1>,
+    last_prepared_selection: Option<usize>,
+    pending_prepared_selection: Option<OnTheFlyPreparedSelectionV1>,
+    point_major_scratch: Vec<f64>,
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+impl OnTheFlyExecutionRuntime {
+    pub(super) fn new(
+        lane: super::on_the_fly_lane::OnTheFlyNativeRuntime,
+        selectors: super::on_the_fly_selectors::OnTheFlyCompactSelectorAdapterV1,
+        color_contraction: Option<super::on_the_fly_load::LoadedOnTheFlyColorContractionV1>,
+    ) -> Self {
+        Self {
+            lane,
+            selectors,
+            reduction: color_contraction.map_or(OnTheFlyReductionV1::Lc, |plan| {
+                OnTheFlyReductionV1::Contracted(Box::new(plan))
+            }),
+            prepared_selections: Vec::new(),
+            last_prepared_selection: None,
+            pending_prepared_selection: None,
+            point_major_scratch: Vec::new(),
+        }
+    }
+
+    pub(super) fn clear(&mut self) -> RusticolResult<()> {
+        self.lane.clear()?;
+        self.pending_prepared_selection = None;
+        self.prepared_selections.clear();
+        self.last_prepared_selection = None;
+        self.point_major_scratch = Vec::new();
+        Ok(())
+    }
+
+    fn uses_contracted_color(&self) -> bool {
+        matches!(&self.reduction, OnTheFlyReductionV1::Contracted(_))
+    }
+
+    fn public_selector_counts(&self) -> RusticolResult<(usize, usize)> {
+        let selection = self.selectors.selection(self.lane.seed(), None, None)?;
+        Ok((
+            selection.helicity_count(),
+            if self.uses_contracted_color() {
+                1
+            } else {
+                selection.color_count()
+            },
+        ))
+    }
+
+    #[cfg(test)]
+    pub(super) fn retained_family_count(&self) -> usize {
+        self.lane.retained_family_count()
+    }
+
+    #[cfg(test)]
+    pub(super) fn retained_selection_count(&self) -> usize {
+        self.prepared_selections.len()
+    }
+
+    #[cfg(test)]
+    pub(super) fn pending_family_count(&self) -> usize {
+        self.lane.pending_family_count()
+    }
+
+    #[cfg(test)]
+    pub(super) fn fail_contracted_execution_at_for_test(&mut self, attempt: Option<usize>) {
+        self.lane.fail_contracted_execution_at_for_test(attempt);
+    }
+
+    #[cfg(test)]
+    pub(super) const fn contracted_max_live_query_outcomes_for_test(&self) -> usize {
+        self.lane.contracted_max_live_query_outcomes_for_test()
+    }
+
+    #[cfg(test)]
+    pub(super) fn semantic_executor_binding_count(&self) -> RusticolResult<u32> {
+        self.lane.semantic_executor_binding_count()
+    }
+
+    #[cfg(test)]
+    pub(super) fn active_family_prepared_census(
+        &self,
+    ) -> Option<crate::recurrence::on_the_fly::OnTheFlyQueryFamilyCensusV1> {
+        self.lane.prepared_census()
+    }
+
+    #[cfg(test)]
+    pub(super) fn point_major_scratch_state(&self) -> (usize, usize) {
+        (
+            self.point_major_scratch.len(),
+            self.point_major_scratch.capacity(),
+        )
+    }
+
+    /// Private read-only production introspection of retained compact state.
+    pub(super) fn state_census(&self, process_id: &str) -> RusticolResult<Value> {
+        let retained = self.lane.retained_state_census();
+        let active_family_union_census = self.lane.prepared_census().map(|census| {
+            serde_json::json!({
+                "basis": "shared-query-family-union-v1",
+                "scope": "active-family-union",
+                "query_count": census.query_count,
+                "union_unique_current_count": census.union_unique_current_count,
+                "union_unique_current_component_count": (
+                    census.union_unique_current_component_count
+                ),
+                "union_source_rows": census.union_source_rows,
+                "union_contribution_rows": census.union_contribution_rows,
+                "union_finalization_rows": census.union_finalization_rows,
+                "union_closure_rows": census.union_closure_rows,
+                "union_amplitude_destination_count": (
+                    census.union_amplitude_destination_count
+                ),
+                "union_source_executor_call_groups": (
+                    census.union_source_executor_call_groups
+                ),
+                "union_contribution_executor_call_groups": (
+                    census.union_contribution_executor_call_groups
+                ),
+                "union_finalization_executor_call_groups": (
+                    census.union_finalization_executor_call_groups
+                ),
+                "union_closure_executor_call_groups": (
+                    census.union_closure_executor_call_groups
+                ),
+            })
+        });
+        Ok(serde_json::json!({
+            "kind": "rusticol-on-the-fly-runtime-state-census-v1",
+            "process_id": process_id,
+            "family_cache_policy": "last-family-only",
+            "family_cache_limit": 1,
+            "process_preparation_count": self.lane.process_preparation_count(),
+            "retained_family_count": retained.family_count,
+            "pending_family_count": self.lane.pending_family_count(),
+            "retained_selection_count": self.prepared_selections.len(),
+            "retained_request_count": retained.request_count,
+            "retained_amplitude_destination_count": retained.amplitude_destination_count,
+            "retained_executor_handle_count": retained.executor_handle_count,
+            "retained_query_local_trace_count": retained.query_local_trace_count,
+            "retained_embedded_lookup_key_count": retained.embedded_lookup_key_count,
+            "semantic_executor_binding_count": self.lane.semantic_executor_binding_count()?,
+            "active_family_union_census": active_family_union_census,
+        }))
+    }
+
+    fn fill_point_major(&mut self, batch: F64MomentumBatchView<'_>) -> RusticolResult<usize> {
+        let required = batch
+            .point_count()
+            .checked_mul(batch.external_count())
+            .and_then(|value| value.checked_mul(4))
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("on-the-fly momentum shape exceeds usize")
+            })?;
+        if self.point_major_scratch.len() < required {
+            self.point_major_scratch
+                .try_reserve_exact(required - self.point_major_scratch.len())
+                .map_err(|error| {
+                    RusticolError::invalid_argument(format!(
+                        "on-the-fly point-major workspace allocation failed: {error}"
+                    ))
+                })?;
+            self.point_major_scratch.resize(required, 0.0);
+        }
+        for point_index in 0..batch.point_count() {
+            let point = batch.point(point_index);
+            for external_index in 0..batch.external_count() {
+                let momentum = point.momentum(external_index).ok_or_else(|| {
+                    RusticolError::integrity("on-the-fly momentum view omits an external leg")
+                })?;
+                let start = (point_index * batch.external_count() + external_index) * 4;
+                self.point_major_scratch[start..start + 4].copy_from_slice(&momentum);
+            }
+        }
+        Ok(required)
+    }
+
+    fn prepare_selection(
+        &mut self,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        point_count: usize,
+    ) -> RusticolResult<(usize, usize)> {
+        if matches!(&self.reduction, OnTheFlyReductionV1::Contracted(_))
+            && selected_colors.is_some()
+        {
+            return Err(RusticolError::selector(
+                "on-the-fly contracted color does not expose a color selector",
+            ));
+        }
+        if let Some(shape) =
+            self.reuse_fixed_selection(selected_helicities, selected_colors, point_count)?
+        {
+            return Ok(shape);
+        }
+        let (helicity_ordinals, color_ordinals) = match &self.reduction {
+            OnTheFlyReductionV1::Lc => self
+                .selectors
+                .selected_ordinals(selected_helicities, selected_colors)?,
+            OnTheFlyReductionV1::Contracted(_) => {
+                let (helicity_ordinals, _) = self
+                    .selectors
+                    .selected_ordinals(selected_helicities, None)?;
+                (helicity_ordinals, None)
+            }
+        };
+        self.prepare_selection_identity(
+            OnTheFlySelectionIdentityV1 {
+                helicity_ordinals,
+                color_ordinals,
+            },
+            point_count,
+        )
+    }
+
+    /// Reuse the last committed fixed public selection before reparsing its
+    /// string IDs.  The prepared public IDs already authenticate the exact
+    /// selector set, while the identity's `Option` markers distinguish an
+    /// omitted (sum-all) axis from an explicit complete-axis selection.
+    /// Matching therefore borrows both sets and allocates nothing on the
+    /// warmed ordinary-evaluation path.
+    fn reuse_fixed_selection(
+        &mut self,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        point_count: usize,
+    ) -> RusticolResult<Option<(usize, usize)>> {
+        let pending_matches = self
+            .pending_prepared_selection
+            .as_ref()
+            .is_some_and(|prepared| {
+                prepared.identity.matches_fixed_selection(
+                    &prepared.helicity_ids,
+                    &prepared.color_ids,
+                    selected_helicities,
+                    selected_colors,
+                )
+            });
+        let committed_index = self
+            .pending_prepared_selection
+            .is_none()
+            .then_some(self.last_prepared_selection)
+            .flatten()
+            .filter(|index| {
+                self.prepared_selections
+                    .get(*index)
+                    .is_some_and(|prepared| {
+                        prepared.identity.matches_fixed_selection(
+                            &prepared.helicity_ids,
+                            &prepared.color_ids,
+                            selected_helicities,
+                            selected_colors,
+                        )
+                    })
+            });
+        if !pending_matches && committed_index.is_none() {
+            return Ok(None);
+        }
+        let family_point_capacity = self.family_point_capacity(point_count)?;
+        self.reuse_current_queries(family_point_capacity)?;
+        let prepared = if pending_matches {
+            self.pending_prepared_selection
+                .as_ref()
+                .expect("matching pending on-the-fly selection disappeared")
+        } else {
+            &self.prepared_selections
+                [committed_index.expect("matching committed selection disappeared")]
+        };
+        Ok(Some((
+            prepared.helicity_indices.len(),
+            prepared.color_indices.len(),
+        )))
+    }
+
+    fn prepare_selection_from_ordinals(
+        &mut self,
+        helicity_ordinals: Option<&[usize]>,
+        color_ordinals: Option<&[usize]>,
+        point_count: usize,
+    ) -> RusticolResult<(usize, usize)> {
+        if matches!(&self.reduction, OnTheFlyReductionV1::Contracted(_)) && color_ordinals.is_some()
+        {
+            return Err(RusticolError::selector(
+                "on-the-fly contracted color does not expose per-point color ordinals",
+            ));
+        }
+        self.prepare_selection_identity(
+            OnTheFlySelectionIdentityV1::from_slices(helicity_ordinals, color_ordinals),
+            point_count,
+        )
+    }
+
+    fn prepare_selection_for_warm_up(
+        &mut self,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        query_construction_threads: usize,
+        progress: &mut super::on_the_fly_warm_up::OnTheFlyWarmUpProgress<'_>,
+    ) -> RusticolResult<OnTheFlyWarmUpPreparedSelectionV1> {
+        if self.uses_contracted_color() && selected_colors.is_some() {
+            return Err(RusticolError::selector(
+                "on-the-fly contracted color does not expose a color selector",
+            ));
+        }
+        let (helicity_ordinals, color_ordinals) = match &self.reduction {
+            OnTheFlyReductionV1::Lc => self
+                .selectors
+                .selected_ordinals(selected_helicities, selected_colors)?,
+            OnTheFlyReductionV1::Contracted(_) => {
+                let (helicity_ordinals, _) = self
+                    .selectors
+                    .selected_ordinals(selected_helicities, None)?;
+                (helicity_ordinals, None)
+            }
+        };
+        self.prepare_selection_identity_impl(
+            OnTheFlySelectionIdentityV1 {
+                helicity_ordinals,
+                color_ordinals,
+            },
+            1,
+            Some(query_construction_threads),
+            Some(progress),
+        )
+    }
+
+    fn prepare_selection_identity(
+        &mut self,
+        identity: OnTheFlySelectionIdentityV1,
+        point_count: usize,
+    ) -> RusticolResult<(usize, usize)> {
+        let prepared = self.prepare_selection_identity_impl(identity, point_count, None, None)?;
+        Ok((prepared.helicity_count, prepared.color_count))
+    }
+
+    fn prepare_selection_identity_impl(
+        &mut self,
+        identity: OnTheFlySelectionIdentityV1,
+        point_count: usize,
+        query_construction_threads: Option<usize>,
+        mut progress: Option<&mut super::on_the_fly_warm_up::OnTheFlyWarmUpProgress<'_>>,
+    ) -> RusticolResult<OnTheFlyWarmUpPreparedSelectionV1> {
+        let family_point_capacity = self.family_point_capacity(point_count)?;
+        if self
+            .pending_prepared_selection
+            .as_ref()
+            .is_some_and(|prepared| prepared.identity == identity)
+        {
+            self.reuse_current_queries(family_point_capacity)?;
+            let prepared = self
+                .pending_prepared_selection
+                .as_ref()
+                .expect("matching pending on-the-fly selection disappeared");
+            if let Some(progress) = progress.as_deref_mut() {
+                self.lane
+                    .report_reused_family_for_warm_up(prepared.query_count, progress)?;
+            }
+            return Ok(OnTheFlyWarmUpPreparedSelectionV1 {
+                helicity_count: prepared.helicity_indices.len(),
+                color_count: prepared.color_indices.len(),
+                query_count: prepared.query_count,
+                already_warm: false,
+            });
+        }
+        self.discard_pending_selection()?;
+        if let Some(index) = self.last_prepared_selection.filter(|index| {
+            self.prepared_selections
+                .get(*index)
+                .is_some_and(|prepared| prepared.identity == identity)
+        }) {
+            self.reuse_current_queries(family_point_capacity)?;
+            let prepared = &self.prepared_selections[index];
+            if let Some(progress) = progress.as_deref_mut() {
+                self.lane
+                    .report_reused_family_for_warm_up(prepared.query_count, progress)?;
+            }
+            return Ok(OnTheFlyWarmUpPreparedSelectionV1 {
+                helicity_count: prepared.helicity_indices.len(),
+                color_count: prepared.color_indices.len(),
+                query_count: prepared.query_count,
+                already_warm: true,
+            });
+        }
+
+        if self.prepared_selections.capacity() == 0 {
+            self.prepared_selections
+                .try_reserve_exact(1)
+                .map_err(|error| {
+                    RusticolError::invalid_argument(format!(
+                        "on-the-fly prepared-selection allocation failed: {error}"
+                    ))
+                })?;
+        }
+        let selection = self.selectors.selection_from_ordinals(
+            self.lane.seed(),
+            identity.helicity_ordinals.as_deref(),
+            identity.color_ordinals.as_deref(),
+        )?;
+        let helicity_count = selection.helicity_count();
+        let helicity_indices = (0..helicity_count)
+            .map(|position| selection.helicity_ordinal_at(position))
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let helicity_ids = (0..helicity_count)
+            .map(|position| selection.helicity_id_at(position))
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let (color_count, color_indices, color_ids, query_count) = match &self.reduction {
+            OnTheFlyReductionV1::Lc => {
+                let color_count = selection.color_count();
+                let color_indices = (0..color_count)
+                    .map(|position| selection.color_ordinal_at(position))
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                let color_ids = (0..color_count)
+                    .map(|position| selection.color_id_at(position))
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                let requests = selection.iter().collect::<RusticolResult<Vec<_>>>()?;
+                if let Some(progress) = progress {
+                    self.lane.prepare_lc_queries_for_warm_up(
+                        &requests,
+                        family_point_capacity,
+                        query_construction_threads.expect("warm-up worker count is absent"),
+                        progress,
+                    )?;
+                } else {
+                    self.lane
+                        .prepare_lc_queries(&requests, family_point_capacity)?;
+                }
+                let query_count = requests.len();
+                (color_count, color_indices, color_ids, query_count)
+            }
+            OnTheFlyReductionV1::Contracted(plan) => {
+                if identity.color_ordinals.is_some() {
+                    return Err(RusticolError::selector(
+                        "on-the-fly contracted color selection is unavailable",
+                    ));
+                }
+                let structural_color_count = plan.destination_by_owner_ordinal.len();
+                if structural_color_count != self.selectors.color_count() {
+                    return Err(RusticolError::integrity(
+                        "on-the-fly contracted owner basis disagrees with compact structural selectors",
+                    ));
+                }
+                if let Some(progress) = progress {
+                    self.lane.prepare_contracted_queries_for_warm_up(
+                        &self.selectors,
+                        &helicity_indices,
+                        structural_color_count,
+                        &plan.destination_by_owner_ordinal,
+                        family_point_capacity,
+                        query_construction_threads.expect("warm-up worker count is absent"),
+                        progress,
+                    )?;
+                } else {
+                    self.lane.prepare_contracted_queries(
+                        &self.selectors,
+                        &helicity_indices,
+                        structural_color_count,
+                        &plan.destination_by_owner_ordinal,
+                        family_point_capacity,
+                    )?;
+                }
+                let query_count = helicity_indices
+                    .len()
+                    .checked_mul(structural_color_count)
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(
+                            "on-the-fly contracted query count exceeds usize",
+                        )
+                    })?;
+                (
+                    1,
+                    vec![0],
+                    vec!["color:contracted".to_string()],
+                    query_count,
+                )
+            }
+        };
+        self.pending_prepared_selection = Some(OnTheFlyPreparedSelectionV1 {
+            identity,
+            helicity_indices: helicity_indices.into_boxed_slice(),
+            color_indices: color_indices.into_boxed_slice(),
+            helicity_ids: helicity_ids.into_boxed_slice(),
+            color_ids: color_ids.into_boxed_slice(),
+            query_count,
+        });
+        Ok(OnTheFlyWarmUpPreparedSelectionV1 {
+            helicity_count,
+            color_count,
+            query_count,
+            already_warm: false,
+        })
+    }
+
+    fn family_point_capacity(&self, point_count: usize) -> RusticolResult<u32> {
+        let point_capacity = u32::try_from(point_count)
+            .map_err(|_| RusticolError::invalid_argument("on-the-fly point count exceeds u32"))?;
+        match &self.reduction {
+            OnTheFlyReductionV1::Lc => Ok(point_capacity),
+            OnTheFlyReductionV1::Contracted(plan) => {
+                u32::try_from(point_count.min(plan.point_tile_size)).map_err(|_| {
+                    RusticolError::invalid_argument("on-the-fly contracted point tile exceeds u32")
+                })
+            }
+        }
+    }
+
+    fn current_prepared_selection(&self) -> RusticolResult<&OnTheFlyPreparedSelectionV1> {
+        self.pending_prepared_selection
+            .as_ref()
+            .or_else(|| {
+                self.last_prepared_selection
+                    .and_then(|index| self.prepared_selections.get(index))
+            })
+            .ok_or_else(|| RusticolError::internal("on-the-fly selection was not retained"))
+    }
+
+    fn discard_pending_selection(&mut self) -> RusticolResult<()> {
+        let aborting_prepared_contracted_selection = self.pending_prepared_selection.is_some()
+            && matches!(&self.reduction, OnTheFlyReductionV1::Contracted(_));
+        if aborting_prepared_contracted_selection {
+            // A successful earlier tile commits the executor family before
+            // the wrapper commits its public selection.  If a later tile
+            // fails, retaining either the old wrapper identity or the new
+            // executor family would make the two caches disagree. Clear the
+            // wrapper side even if native row-table invalidation itself fails.
+            let rollback = self.lane.abort_contracted_selection();
+            self.pending_prepared_selection = None;
+            self.prepared_selections.clear();
+            self.last_prepared_selection = None;
+            return rollback;
+        }
+        match &self.reduction {
+            OnTheFlyReductionV1::Lc => self.lane.discard_pending_lc_queries()?,
+            OnTheFlyReductionV1::Contracted(_) => self.lane.discard_pending_contracted_queries()?,
+        }
+        self.pending_prepared_selection = None;
+        Ok(())
+    }
+
+    fn reuse_current_queries(&mut self, point_capacity: u32) -> RusticolResult<bool> {
+        match &self.reduction {
+            OnTheFlyReductionV1::Lc => self.lane.reuse_current_lc_queries(point_capacity),
+            OnTheFlyReductionV1::Contracted(_) => {
+                self.lane.reuse_current_contracted_queries(point_capacity)
+            }
+        }
+    }
+
+    fn commit_pending_selection(&mut self) {
+        let Some(selection) = self.pending_prepared_selection.take() else {
+            return;
+        };
+        self.prepared_selections.clear();
+        self.prepared_selections.push(selection);
+        self.last_prepared_selection = Some(0);
+    }
+
+    fn selected_axis_ids(&self) -> RusticolResult<(Vec<String>, Vec<String>)> {
+        let prepared = self.current_prepared_selection()?;
+        Ok((prepared.helicity_ids.to_vec(), prepared.color_ids.to_vec()))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn warm_up_f64<'observer>(
+        &mut self,
+        common: &ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        n_cores: Option<usize>,
+        observer: Option<
+            &'observer mut super::on_the_fly_warm_up::NativeOnTheFlyWarmUpObserver<'observer>,
+        >,
+    ) -> RusticolResult<super::on_the_fly_warm_up::NativeOnTheFlyWarmUpResult> {
+        if batch.point_count() != 1 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly warm-up requires exactly one binary64 phase-space point",
+            ));
+        }
+        let query_construction_threads = match n_cores {
+            Some(0) => {
+                return Err(RusticolError::invalid_argument(
+                    "on-the-fly warm-up n_cores must be positive",
+                ));
+            }
+            Some(requested) => {
+                super::on_the_fly_load::effective_query_construction_threads(requested)
+            }
+            None => self.lane.effective_query_construction_threads(),
+        };
+        let mut progress = super::on_the_fly_warm_up::OnTheFlyWarmUpProgress::new(
+            observer,
+            query_construction_threads,
+        )?;
+        let result = (|| {
+            self.lane.prepare_process_for_warm_up(&mut progress)?;
+            let prepared = self.prepare_selection_for_warm_up(
+                selected_helicities,
+                selected_colors,
+                query_construction_threads,
+                &mut progress,
+            )?;
+            let input_len = self.fill_point_major(batch)?;
+            progress.emit(
+                super::on_the_fly_warm_up::NativeOnTheFlyWarmUpEventKind::Start,
+                super::on_the_fly_warm_up::NativeOnTheFlyWarmUpStage::FirstEvaluation,
+                0,
+                1,
+                None,
+            )?;
+            let mut output = [0.0_f64];
+            match &self.reduction {
+                OnTheFlyReductionV1::Lc => self.lane.run_f64_into_unprofiled(
+                    &self.point_major_scratch[..input_len],
+                    1,
+                    &common.model_parameter_values_f64,
+                    common.normalization_factor,
+                    &mut output,
+                )?,
+                OnTheFlyReductionV1::Contracted(plan) => {
+                    self.lane.run_contracted_f64_into_unprofiled(
+                        &self.point_major_scratch[..input_len],
+                        1,
+                        &common.model_parameter_values_f64,
+                        common.normalization_factor,
+                        &plan.plan,
+                        plan.point_tile_size,
+                        &mut output,
+                    )?;
+                }
+            }
+            Ok(prepared)
+        })();
+        let prepared = match result {
+            Ok(prepared) => {
+                // The lane commits its executable family only after the first
+                // successful evaluation. Commit the matching public selector
+                // before publishing the terminal event so both cache layers
+                // remain coherent even if an embedding rejects that event.
+                self.commit_pending_selection();
+                prepared
+            }
+            Err(error) => {
+                self.discard_pending_selection()?;
+                return Err(error);
+            }
+        };
+        progress.emit_terminal_notification(
+            super::on_the_fly_warm_up::NativeOnTheFlyWarmUpStage::FirstEvaluation,
+            1,
+            1,
+            None,
+        );
+        let query_count = u64::try_from(prepared.query_count)
+            .map_err(|_| RusticolError::invalid_argument("warm-up query count exceeds u64"))?;
+        Ok(super::on_the_fly_warm_up::NativeOnTheFlyWarmUpResult {
+            schema_version: 1,
+            elapsed_seconds: progress.elapsed_seconds(),
+            query_count,
+            warmed_query_count: if prepared.already_warm {
+                0
+            } else {
+                query_count
+            },
+            current_rss_bytes: progress.current_rss_bytes(),
+            peak_rss_bytes: progress.peak_rss_bytes(),
+            already_warm: prepared.already_warm,
+            first_evaluation_completed: true,
+        })
+    }
+
+    pub(super) fn run_total_into_unprofiled(
+        &mut self,
+        common: &ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let result = (|| {
+            let point_count = batch.point_count();
+            self.prepare_selection(selected_helicities, selected_colors, point_count)?;
+            let input_len = self.fill_point_major(batch)?;
+            let native_point_count = u32::try_from(point_count).map_err(|_| {
+                RusticolError::invalid_argument("on-the-fly point count exceeds u32")
+            })?;
+            match &self.reduction {
+                OnTheFlyReductionV1::Lc => self.lane.run_f64_into_unprofiled(
+                    &self.point_major_scratch[..input_len],
+                    native_point_count,
+                    &common.model_parameter_values_f64,
+                    common.normalization_factor,
+                    output,
+                ),
+                OnTheFlyReductionV1::Contracted(plan) => {
+                    self.lane.run_contracted_f64_into_unprofiled(
+                        &self.point_major_scratch[..input_len],
+                        native_point_count,
+                        &common.model_parameter_values_f64,
+                        common.normalization_factor,
+                        &plan.plan,
+                        plan.point_tile_size,
+                        output,
+                    )
+                }
+            }
+        })();
+        match result {
+            Ok(()) => {
+                self.commit_pending_selection();
+                Ok(())
+            }
+            Err(error) => {
+                self.discard_pending_selection()?;
+                Err(error)
+            }
+        }
+    }
+
+    pub(super) fn run_total_into(
+        &mut self,
+        common: &ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<RuntimeProfile> {
+        let result = (|| {
+            let point_count = batch.point_count();
+            self.prepare_selection(selected_helicities, selected_colors, point_count)?;
+            let input_len = self.fill_point_major(batch)?;
+            let native_point_count = u32::try_from(point_count).map_err(|_| {
+                RusticolError::invalid_argument("on-the-fly point count exceeds u32")
+            })?;
+            let (_, profile) = match &self.reduction {
+                OnTheFlyReductionV1::Lc => self.lane.run_f64_into(
+                    &self.point_major_scratch[..input_len],
+                    native_point_count,
+                    &common.model_parameter_values_f64,
+                    common.normalization_factor,
+                    output,
+                )?,
+                OnTheFlyReductionV1::Contracted(plan) => self.lane.run_contracted_f64_into(
+                    &self.point_major_scratch[..input_len],
+                    native_point_count,
+                    &common.model_parameter_values_f64,
+                    common.normalization_factor,
+                    &plan.plan,
+                    plan.point_tile_size,
+                    output,
+                )?,
+            };
+            Ok(profile)
+        })();
+        match result {
+            Ok(profile) => {
+                self.commit_pending_selection();
+                Ok(profile)
+            }
+            Err(error) => {
+                self.discard_pending_selection()?;
+                Err(error)
+            }
+        }
+    }
+
+    fn run_total_into_by_ordinals(
+        &mut self,
+        common: &ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        helicity_ordinals: Option<&[usize]>,
+        color_ordinals: Option<&[usize]>,
+        output: &mut [f64],
+    ) -> RusticolResult<RuntimeProfile> {
+        let result = (|| {
+            let point_count = batch.point_count();
+            self.prepare_selection_from_ordinals(helicity_ordinals, color_ordinals, point_count)?;
+            let input_len = self.fill_point_major(batch)?;
+            let native_point_count = u32::try_from(point_count).map_err(|_| {
+                RusticolError::invalid_argument("on-the-fly point count exceeds u32")
+            })?;
+            let (_, profile) = match &self.reduction {
+                OnTheFlyReductionV1::Lc => self.lane.run_f64_into(
+                    &self.point_major_scratch[..input_len],
+                    native_point_count,
+                    &common.model_parameter_values_f64,
+                    common.normalization_factor,
+                    output,
+                )?,
+                OnTheFlyReductionV1::Contracted(plan) => self.lane.run_contracted_f64_into(
+                    &self.point_major_scratch[..input_len],
+                    native_point_count,
+                    &common.model_parameter_values_f64,
+                    common.normalization_factor,
+                    &plan.plan,
+                    plan.point_tile_size,
+                    output,
+                )?,
+            };
+            Ok(profile)
+        })();
+        match result {
+            Ok(profile) => {
+                self.commit_pending_selection();
+                Ok(profile)
+            }
+            Err(error) => {
+                self.discard_pending_selection()?;
+                Err(error)
+            }
+        }
+    }
+
+    fn run_total_into_by_ordinals_unprofiled(
+        &mut self,
+        common: &ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        helicity_ordinals: Option<&[usize]>,
+        color_ordinals: Option<&[usize]>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let result = (|| {
+            let point_count = batch.point_count();
+            self.prepare_selection_from_ordinals(helicity_ordinals, color_ordinals, point_count)?;
+            let input_len = self.fill_point_major(batch)?;
+            let native_point_count = u32::try_from(point_count).map_err(|_| {
+                RusticolError::invalid_argument("on-the-fly point count exceeds u32")
+            })?;
+            match &self.reduction {
+                OnTheFlyReductionV1::Lc => self.lane.run_f64_into_unprofiled(
+                    &self.point_major_scratch[..input_len],
+                    native_point_count,
+                    &common.model_parameter_values_f64,
+                    common.normalization_factor,
+                    output,
+                ),
+                OnTheFlyReductionV1::Contracted(plan) => {
+                    self.lane.run_contracted_f64_into_unprofiled(
+                        &self.point_major_scratch[..input_len],
+                        native_point_count,
+                        &common.model_parameter_values_f64,
+                        common.normalization_factor,
+                        &plan.plan,
+                        plan.point_tile_size,
+                        output,
+                    )
+                }
+            }
+        })();
+        match result {
+            Ok(()) => {
+                self.commit_pending_selection();
+                Ok(())
+            }
+            Err(error) => {
+                self.discard_pending_selection()?;
+                Err(error)
+            }
+        }
+    }
+
+    fn run_resolved(
+        &mut self,
+        common: &ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        let result = (|| {
+            let point_count = batch.point_count();
+            let (helicity_count, color_count) =
+                self.prepare_selection(selected_helicities, selected_colors, point_count)?;
+            let prepared = self.current_prepared_selection()?;
+            let helicity_indices = prepared.helicity_indices.to_vec();
+            let color_indices = prepared.color_indices.to_vec();
+            let value_count = point_count
+                .checked_mul(helicity_count)
+                .and_then(|value| value.checked_mul(color_count))
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument("on-the-fly resolved shape exceeds usize")
+                })?;
+            let mut values = vec![0.0; value_count];
+            let input_len = self.fill_point_major(batch)?;
+            let native_point_count = u32::try_from(point_count).map_err(|_| {
+                RusticolError::invalid_argument("on-the-fly point count exceeds u32")
+            })?;
+            let (_, profile) = match &self.reduction {
+                OnTheFlyReductionV1::Lc => self.lane.run_resolved_f64_into(
+                    &self.point_major_scratch[..input_len],
+                    native_point_count,
+                    &common.model_parameter_values_f64,
+                    common.normalization_factor,
+                    helicity_count,
+                    color_count,
+                    &mut values,
+                )?,
+                OnTheFlyReductionV1::Contracted(plan) => {
+                    if color_count != 1 {
+                        return Err(RusticolError::integrity(
+                            "on-the-fly contracted resolved color axis is not singleton",
+                        ));
+                    }
+                    self.lane.run_contracted_resolved_f64_into(
+                        &self.point_major_scratch[..input_len],
+                        native_point_count,
+                        &common.model_parameter_values_f64,
+                        common.normalization_factor,
+                        &plan.plan,
+                        plan.point_tile_size,
+                        helicity_count,
+                        &mut values,
+                    )?
+                }
+            };
+            Ok((
+                ResolvedValues {
+                    values,
+                    point_count,
+                    helicity_indices,
+                    color_indices,
+                },
+                profile,
+            ))
+        })();
+        match result {
+            Ok(result) => {
+                self.commit_pending_selection();
+                Ok(result)
+            }
+            Err(error) => {
+                self.discard_pending_selection()?;
+                Err(error)
+            }
+        }
+    }
+}
+
+struct PointSelectorProfileCounts {
+    gather_point_count: usize,
+    input_bytes_per_point: usize,
+    scatter_value_count: usize,
+}
+
+type ProfiledPreparedF64Batch = (Vec<Vec<[f64; 4]>>, Duration, Duration);
+
+fn attach_point_selector_profile(
+    profile: &mut NativeRuntimeProfile,
+    plan: &PointSelectorPlanProfile,
+    planner: Duration,
+    gather: Duration,
+    scatter: Duration,
+    counts: PointSelectorProfileCounts,
+) {
+    profile.selector_planner_s = profile_duration_seconds(planner);
+    profile.selector_gather_s = profile_duration_seconds(gather);
+    profile.selector_scatter_s = profile_duration_seconds(scatter);
+    profile.selector_plan_kind = plan.kind.to_string();
+    profile.selector_group_sizes.clone_from(&plan.group_sizes);
+    profile.selector_reordered_point_count = plan.reordered_point_count;
+    profile.selector_simd_lane_width = plan.simd_lane_width;
+    profile.selector_simd_occupancy = plan.simd_occupancy;
+    profile.selector_gather_point_count = counts.gather_point_count as u64;
+    profile.selector_gather_bytes =
+        (counts.gather_point_count * counts.input_bytes_per_point) as u64;
+    profile.selector_scatter_value_count = counts.scatter_value_count as u64;
+}
+
+fn execution_uses_simd_jit(runtime: &ExecutionRuntime) -> bool {
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    if runtime.compiled_direct_runtime.is_some() {
+        return true;
+    }
+    runtime
+        .stages
+        .as_ref()
+        .is_some_and(|stages| stages.iter().any(|stage| stage.evaluator.uses_simd_jit()))
+        || runtime
+            .amplitude_stage
+            .as_ref()
+            .and_then(|stage| stage.evaluator.as_ref())
+            .is_some_and(EvaluatorGroup::uses_simd_jit)
+        || runtime
+            .helicity_sum_runtime
+            .as_deref()
+            .is_some_and(execution_uses_simd_jit)
+        || runtime
+            .helicity_selector_runtimes
+            .iter()
+            .any(|lane| execution_uses_simd_jit(lane))
+        || runtime
+            .color_selector_runtimes
+            .values()
+            .any(|lane| execution_uses_simd_jit(lane))
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[derive(Clone, Copy, Debug, Default)]
+struct CompiledDirectProfileSnapshot {
+    engine_count: usize,
+    minimum_effective_tile_capacity: usize,
+    maximum_physical_scalar_values_per_point: usize,
+    maximum_hot_scalar_values_per_point: usize,
+    maximum_source_scalar_values_per_point: usize,
+    maximum_reduction_scalar_values_per_point: usize,
+    source_fill_bytes: u64,
+    momentum_fill_bytes: u64,
+    parameter_fill_bytes: u64,
+    scalar_broadcast_fill_bytes: u64,
+    amplitude_clear_bytes: u64,
+    backend_call_count: u64,
+    boundary_input_bytes: u64,
+    boundary_current_output_bytes: u64,
+    boundary_amplitude_output_bytes: u64,
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+const fn minimum_nonzero(left: usize, right: usize) -> usize {
+    match (left, right) {
+        (0, value) | (value, 0) => value,
+        (left, right) => {
+            if left < right {
+                left
+            } else {
+                right
+            }
+        }
+    }
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[derive(Clone, Copy, Debug, Default)]
+struct CompiledDirectConfigurationSnapshot {
+    engine_count: usize,
+    minimum_effective_tile_capacity: usize,
+    maximum_physical_scalar_values_per_point: usize,
+    maximum_hot_scalar_values_per_point: usize,
+    maximum_source_scalar_values_per_point: usize,
+    maximum_reduction_scalar_values_per_point: usize,
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn compiled_direct_configuration_snapshot(
+    runtime: &ExecutionRuntime,
+) -> CompiledDirectConfigurationSnapshot {
+    let mut snapshot = CompiledDirectConfigurationSnapshot::default();
+    if let Some(direct) = runtime.compiled_direct_runtime.as_ref() {
+        let sizing = direct.tile_sizing();
+        snapshot.engine_count = 1;
+        snapshot.minimum_effective_tile_capacity = sizing.effective_tile_capacity;
+        snapshot.maximum_physical_scalar_values_per_point = sizing.physical_scalar_values_per_point;
+        snapshot.maximum_hot_scalar_values_per_point = sizing.hot_scalar_values_per_point;
+        snapshot.maximum_source_scalar_values_per_point = sizing.source_scalar_values_per_point;
+        snapshot.maximum_reduction_scalar_values_per_point =
+            sizing.reduction_scalar_values_per_point;
+    }
+    let children = runtime
+        .helicity_sum_runtime
+        .iter()
+        .map(Box::as_ref)
+        .chain(runtime.helicity_selector_runtimes.iter().map(Box::as_ref))
+        .chain(runtime.color_selector_runtimes.values().map(Box::as_ref));
+    for child in children {
+        let child = compiled_direct_configuration_snapshot(child);
+        snapshot.engine_count += child.engine_count;
+        snapshot.minimum_effective_tile_capacity = minimum_nonzero(
+            snapshot.minimum_effective_tile_capacity,
+            child.minimum_effective_tile_capacity,
+        );
+        snapshot.maximum_physical_scalar_values_per_point = snapshot
+            .maximum_physical_scalar_values_per_point
+            .max(child.maximum_physical_scalar_values_per_point);
+        snapshot.maximum_hot_scalar_values_per_point = snapshot
+            .maximum_hot_scalar_values_per_point
+            .max(child.maximum_hot_scalar_values_per_point);
+        snapshot.maximum_source_scalar_values_per_point = snapshot
+            .maximum_source_scalar_values_per_point
+            .max(child.maximum_source_scalar_values_per_point);
+        snapshot.maximum_reduction_scalar_values_per_point = snapshot
+            .maximum_reduction_scalar_values_per_point
+            .max(child.maximum_reduction_scalar_values_per_point);
+    }
+    snapshot
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn compiled_direct_profile_snapshot(
+    runtime: &ExecutionRuntime,
+) -> RusticolResult<CompiledDirectProfileSnapshot> {
+    let mut snapshot = CompiledDirectProfileSnapshot::default();
+    if let Some(direct) = runtime.compiled_direct_runtime.as_ref() {
+        let traffic = direct.traffic();
+        traffic.leaf.validate_direct()?;
+        if traffic.boundary_input_bytes
+            | traffic.boundary_current_output_bytes
+            | traffic.boundary_amplitude_output_bytes
+            != 0
+        {
+            return Err(RusticolError::integrity(
+                "production compiled Direct-Arena profile observed developer boundary traffic",
+            ));
+        }
+        let sizing = direct.tile_sizing();
+        snapshot.engine_count += 1;
+        snapshot.minimum_effective_tile_capacity = sizing.effective_tile_capacity;
+        snapshot.maximum_physical_scalar_values_per_point = sizing.physical_scalar_values_per_point;
+        snapshot.maximum_hot_scalar_values_per_point = sizing.hot_scalar_values_per_point;
+        snapshot.maximum_source_scalar_values_per_point = sizing.source_scalar_values_per_point;
+        snapshot.maximum_reduction_scalar_values_per_point =
+            sizing.reduction_scalar_values_per_point;
+        snapshot.source_fill_bytes = traffic.source_fill_bytes;
+        snapshot.momentum_fill_bytes = traffic.momentum_fill_bytes;
+        snapshot.parameter_fill_bytes = traffic.parameter_fill_bytes;
+        snapshot.scalar_broadcast_fill_bytes = traffic.scalar_broadcast_fill_bytes;
+        snapshot.amplitude_clear_bytes = traffic.amplitude_clear_bytes;
+        snapshot.backend_call_count = traffic.leaf.calls;
+        snapshot.boundary_input_bytes = traffic.boundary_input_bytes;
+        snapshot.boundary_current_output_bytes = traffic.boundary_current_output_bytes;
+        snapshot.boundary_amplitude_output_bytes = traffic.boundary_amplitude_output_bytes;
+    }
+    let children = runtime
+        .helicity_sum_runtime
+        .iter()
+        .map(Box::as_ref)
+        .chain(runtime.helicity_selector_runtimes.iter().map(Box::as_ref))
+        .chain(runtime.color_selector_runtimes.values().map(Box::as_ref));
+    for child in children {
+        let child = compiled_direct_profile_snapshot(child)?;
+        snapshot.engine_count += child.engine_count;
+        snapshot.minimum_effective_tile_capacity = minimum_nonzero(
+            snapshot.minimum_effective_tile_capacity,
+            child.minimum_effective_tile_capacity,
+        );
+        snapshot.maximum_physical_scalar_values_per_point = snapshot
+            .maximum_physical_scalar_values_per_point
+            .max(child.maximum_physical_scalar_values_per_point);
+        snapshot.maximum_hot_scalar_values_per_point = snapshot
+            .maximum_hot_scalar_values_per_point
+            .max(child.maximum_hot_scalar_values_per_point);
+        snapshot.maximum_source_scalar_values_per_point = snapshot
+            .maximum_source_scalar_values_per_point
+            .max(child.maximum_source_scalar_values_per_point);
+        snapshot.maximum_reduction_scalar_values_per_point = snapshot
+            .maximum_reduction_scalar_values_per_point
+            .max(child.maximum_reduction_scalar_values_per_point);
+        snapshot.source_fill_bytes = snapshot
+            .source_fill_bytes
+            .saturating_add(child.source_fill_bytes);
+        snapshot.momentum_fill_bytes = snapshot
+            .momentum_fill_bytes
+            .saturating_add(child.momentum_fill_bytes);
+        snapshot.parameter_fill_bytes = snapshot
+            .parameter_fill_bytes
+            .saturating_add(child.parameter_fill_bytes);
+        snapshot.scalar_broadcast_fill_bytes = snapshot
+            .scalar_broadcast_fill_bytes
+            .saturating_add(child.scalar_broadcast_fill_bytes);
+        snapshot.amplitude_clear_bytes = snapshot
+            .amplitude_clear_bytes
+            .saturating_add(child.amplitude_clear_bytes);
+        snapshot.backend_call_count = snapshot
+            .backend_call_count
+            .saturating_add(child.backend_call_count);
+        snapshot.boundary_input_bytes = snapshot
+            .boundary_input_bytes
+            .saturating_add(child.boundary_input_bytes);
+        snapshot.boundary_current_output_bytes = snapshot
+            .boundary_current_output_bytes
+            .saturating_add(child.boundary_current_output_bytes);
+        snapshot.boundary_amplitude_output_bytes = snapshot
+            .boundary_amplitude_output_bytes
+            .saturating_add(child.boundary_amplitude_output_bytes);
+    }
+    Ok(snapshot)
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn attach_compiled_direct_configuration(
+    profile: &mut RuntimeProfile,
+    snapshot: CompiledDirectProfileSnapshot,
+) {
+    profile.compiled_direct_arena_minimum_effective_tile_capacity =
+        snapshot.minimum_effective_tile_capacity as u64;
+    profile.compiled_direct_arena_maximum_physical_scalar_values_per_point =
+        snapshot.maximum_physical_scalar_values_per_point as u64;
+    profile.compiled_direct_arena_maximum_hot_scalar_values_per_point =
+        snapshot.maximum_hot_scalar_values_per_point as u64;
+    profile.compiled_direct_arena_maximum_source_scalar_values_per_point =
+        snapshot.maximum_source_scalar_values_per_point as u64;
+    profile.compiled_direct_arena_maximum_reduction_scalar_values_per_point =
+        snapshot.maximum_reduction_scalar_values_per_point as u64;
+}
+
+fn ensure_selected_runtime_capabilities_supported(capabilities: &[String]) -> RusticolResult<()> {
+    if capabilities.iter().any(|capability| {
+        capability == EAGER_DAG_RUNTIME_CAPABILITY
+            || capability == EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY
+    }) {
+        return Err(RusticolError::compatibility(
+            "legacy eager plan-v2 artifacts are no longer executable; regenerate the artifact \
+             with the current `pyamplicol generate` before loading it",
+        ));
+    }
+    ensure_runtime_capabilities_supported(capabilities.iter().map(String::as_str))
+}
+
+impl NativeRuntime {
+    pub const ABI_VERSION: u32 = crate::C_ABI_VERSION;
+
+    /// Save the currently retained, completed on-the-fly cache to a file.
+    /// The original process output is still required to load its kernels.
+    /// Numeric momenta, parameters, and workspaces are not serialized.
+    pub fn save(&self, path: impl AsRef<Path>) -> RusticolResult<()> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if let NativeExecutionLane::OnTheFly(runtime) = &self.execution_lane {
+            return cache::save(self, runtime, path.as_ref());
+        }
+        let _ = path;
+        Err(RusticolError::compatibility(
+            "save() requires an on-the-fly runtime",
+        ))
+    }
+
+    /// Restore completed on-the-fly structural work against this loaded
+    /// process. The runner's current model parameters are kept. A failed load
+    /// leaves the previously usable cache intact.
+    pub fn load_cache(&mut self, path: impl AsRef<Path>) -> RusticolResult<()> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if matches!(self.execution_lane, NativeExecutionLane::OnTheFly(_)) {
+            return cache::load(self, path.as_ref());
+        }
+        let _ = path;
+        Err(RusticolError::compatibility(
+            "load_cache() requires an on-the-fly runtime",
+        ))
+    }
+
+    /// Content identity of the authenticated artifact manifest that supplied
+    /// this in-memory runtime.
+    pub fn artifact_id(&self) -> &str {
+        &self.artifact_id
+    }
+
+    /// Load only the authenticated physical reduction groups of an eager
+    /// plan-v3 artifact.
+    ///
+    /// Unlike the exact-section bridge, this does not materialize exact
+    /// invocations, attachments, finalizations, or closures that are unrelated
+    /// to reduction authentication.
+    #[doc(hidden)]
+    pub fn load_eager_reduction_groups(
+        artifact_path: impl AsRef<Path>,
+        process_id: &str,
+    ) -> Result<Value, RusticolError> {
+        let artifact = VerifiedArtifact::open_with_manifest_preflight(artifact_path, |manifest| {
+            let selection = manifest.select_process(Some(process_id))?;
+            ensure_selected_runtime_capabilities_supported(
+                &selection.process.required_runtime_capabilities,
+            )
+        })?;
+        let selection = artifact.select_process(Some(process_id))?;
+        if selection.remaps_public_process() {
+            return Err(RusticolError::invalid_argument(
+                "compact eager reduction groups must be requested by representative process ID",
+            ));
+        }
+        let (manifest, evaluator_root) = load_verified_evaluator(&artifact, &selection)?;
+        let physics_bytes = artifact.read_payload(&selection.process.physics_path)?;
+        let mut physics =
+            ProcessPhysicsV1::from_json(&physics_bytes, &selection.process.physics_path)?;
+        if physics.process_id != selection.process.id
+            || physics.process != selection.process.expression
+            || physics.color_accuracy.as_str() != selection.process.color_accuracy
+            || physics
+                .external_particles
+                .iter()
+                .map(|particle| particle.pdg)
+                .ne(selection.process.external_pdgs.iter().copied())
+        {
+            return Err(RusticolError::integrity(format!(
+                "runtime physics payload {:?} does not match process {:?}",
+                selection.process.physics_path, selection.process.id
+            )));
+        }
+        match manifest {
+            LoadedExecutionManifest::Compiled(_) => Err(RusticolError::compatibility(
+                "compact reduction-group loading requires an eager plan-v3 artifact",
+            )),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::EagerV3(manifest) => {
+                super::eager_v3_load::load_eager_v3_reduction_groups(
+                    &artifact,
+                    &evaluator_root,
+                    &manifest,
+                    &mut physics,
+                )
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::Recurrence(_) => Err(RusticolError::compatibility(
+                "recurrence reduction-group loading is unavailable through the eager bridge",
+            )),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::OnTheFly(_) => Err(RusticolError::compatibility(
+                "on-the-fly reduction-group loading is unavailable through the eager bridge",
+            )),
+        }
+    }
+
+    /// Load only the exact-required sections of an eager plan-v3 artifact.
+    ///
+    /// This authenticates the artifact and compact runtime container but does
+    /// not instantiate the prepared f64 backend. It is intentionally separate
+    /// from the normal runtime hot path.
+    pub fn load_eager_exact_sections(
+        artifact_path: impl AsRef<Path>,
+        process_id: &str,
+    ) -> Result<NativeEagerExactSections, RusticolError> {
+        let artifact = VerifiedArtifact::open_with_manifest_preflight(artifact_path, |manifest| {
+            let selection = manifest.select_process(Some(process_id))?;
+            ensure_selected_runtime_capabilities_supported(
+                &selection.process.required_runtime_capabilities,
+            )
+        })?;
+        let selection = artifact.select_process(Some(process_id))?;
+        if selection.remaps_public_process() {
+            return Err(RusticolError::invalid_argument(
+                "compact eager exact sections must be requested by representative process ID",
+            ));
+        }
+        let (manifest, evaluator_root) = load_verified_evaluator(&artifact, &selection)?;
+        let physics_bytes = artifact.read_payload(&selection.process.physics_path)?;
+        let mut physics =
+            ProcessPhysicsV1::from_json(&physics_bytes, &selection.process.physics_path)?;
+        if physics.process_id != selection.process.id
+            || physics.process != selection.process.expression
+            || physics.color_accuracy.as_str() != selection.process.color_accuracy
+            || physics
+                .external_particles
+                .iter()
+                .map(|particle| particle.pdg)
+                .ne(selection.process.external_pdgs.iter().copied())
+        {
+            return Err(RusticolError::integrity(format!(
+                "runtime physics payload {:?} does not match process {:?}",
+                selection.process.physics_path, selection.process.id
+            )));
+        }
+        match manifest {
+            LoadedExecutionManifest::Compiled(_) => Err(RusticolError::compatibility(
+                "compact exact-section loading requires an eager plan-v3 artifact",
+            )),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::EagerV3(manifest) => {
+                super::eager_v3_load::load_eager_v3_exact_sections(
+                    &artifact,
+                    &evaluator_root,
+                    &manifest,
+                    &mut physics,
+                )
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::Recurrence(_) => Err(RusticolError::compatibility(
+                "recurrence exact-section loading is not available in the initial f64 runtime slice",
+            )),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::OnTheFly(_) => Err(RusticolError::compatibility(
+                "on-the-fly exact-section loading is unavailable through the eager bridge",
+            )),
+        }
+    }
+
+    /// Load the immutable exact-execution sections of an authenticated
+    /// topology-replay recurrence artifact without instantiating its f64
+    /// Direct-Arena backend.
+    pub fn load_recurrence_exact_sections(
+        artifact_path: impl AsRef<Path>,
+        process_id: &str,
+    ) -> Result<NativeRecurrenceExactSections, RusticolError> {
+        let artifact = VerifiedArtifact::open_with_manifest_preflight(artifact_path, |manifest| {
+            let selection = manifest.select_process(Some(process_id))?;
+            ensure_selected_runtime_capabilities_supported(
+                &selection.process.required_runtime_capabilities,
+            )
+        })?;
+        let selection = artifact.select_process(Some(process_id))?;
+        if selection.remaps_public_process() {
+            return Err(RusticolError::invalid_argument(
+                "compact recurrence exact sections must be requested by representative process ID",
+            ));
+        }
+        let (manifest, evaluator_root) = load_verified_evaluator(&artifact, &selection)?;
+        let physics_bytes = artifact.read_payload(&selection.process.physics_path)?;
+        let physics = ProcessPhysicsV1::from_json(&physics_bytes, &selection.process.physics_path)?;
+        if physics.process_id != selection.process.id
+            || physics.process != selection.process.expression
+            || physics.color_accuracy.as_str() != selection.process.color_accuracy
+            || physics
+                .external_particles
+                .iter()
+                .map(|particle| particle.pdg)
+                .ne(selection.process.external_pdgs.iter().copied())
+        {
+            return Err(RusticolError::integrity(format!(
+                "runtime physics payload {:?} does not match process {:?}",
+                selection.process.physics_path, selection.process.id
+            )));
+        }
+        match manifest {
+            LoadedExecutionManifest::Compiled(_) => Err(RusticolError::compatibility(
+                "compact recurrence exact-section loading requires a recurrence artifact",
+            )),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::EagerV3(_) => Err(RusticolError::compatibility(
+                "compact recurrence exact-section loading requires a recurrence artifact",
+            )),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::Recurrence(manifest) => {
+                load_recurrence_exact_sections(&artifact, &evaluator_root, &manifest, &physics)
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::OnTheFly(_) => Err(RusticolError::compatibility(
+                "compact recurrence exact-section loading is unavailable for on-the-fly artifacts",
+            )),
+        }
+    }
+
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    #[allow(clippy::too_many_arguments)]
+    fn finish_dense_load(
+        root: PathBuf,
+        artifact_id: String,
+        selection: crate::ArtifactSelection,
+        mut physics_v1: ProcessPhysicsV1,
+        representative_key: String,
+        mut runtime: ExecutionRuntime,
+        execution_lane: NativeExecutionLane,
+        model_parameters_path: Option<&Path>,
+    ) -> Result<Self, RusticolError> {
+        let process = selection.public_expression.clone();
+        let process_key = selection.requested_id.clone();
+        let representative_process_id = selection.process.id.clone();
+        let public_remap = selection.remaps_public_process();
+        let nonidentity_permutation = selection
+            .external_permutation
+            .iter()
+            .copied()
+            .enumerate()
+            .any(|(representative_index, public_index)| representative_index != public_index);
+        let initial_count = physics_v1
+            .external_particles
+            .iter()
+            .take_while(|particle| particle.role == crate::ParticleRole::Initial)
+            .count();
+        let final_state_only = public_remap
+            && selection
+                .external_permutation
+                .iter()
+                .take(initial_count)
+                .copied()
+                .enumerate()
+                .all(|(index, public_index)| index == public_index);
+        let input_crossing_map = if public_remap {
+            let representative_physics = physics_v1.clone();
+            let public_physics = apply_process_permutation_metadata(physics_v1, &selection)
+                .map_err(|error| {
+                    RusticolError::with_kind(
+                        error.kind(),
+                        format!("could not remap process physics metadata: {error}"),
+                    )
+                })?;
+            let helicity_id_map = representative_physics
+                .helicities
+                .iter()
+                .zip(&public_physics.helicities)
+                .map(|(representative, public)| (representative.id.clone(), public.id.clone()))
+                .collect::<BTreeMap<_, _>>();
+            let color_id_map = representative_physics
+                .color_components
+                .iter()
+                .zip(&public_physics.color_components)
+                .map(|(representative, public)| {
+                    (representative.id().to_string(), public.id().to_string())
+                })
+                .collect::<BTreeMap<_, _>>();
+            runtime
+                .remap_lc_topology_replay_public_labels(&selection.external_permutation)
+                .map_err(|error| {
+                    RusticolError::with_kind(
+                        error.kind(),
+                        format!("could not remap process execution metadata: {error}"),
+                    )
+                })?;
+            runtime.remap_physics_reduction_overrides(&helicity_id_map, &color_id_map)?;
+            physics_v1 = public_physics;
+            runtime.set_external_pdg_order_recursive(&selection.external_pdgs);
+            nonidentity_permutation.then(|| {
+                selection
+                    .external_permutation
+                    .iter()
+                    .copied()
+                    .enumerate()
+                    .map(|(target_index, source_index)| InputCrossingMapEntry {
+                        target_index,
+                        source_index,
+                        sign: 1.0,
+                    })
+                    .collect()
+            })
+        } else {
+            None
+        };
+        let input_crossing_map =
+            prevalidate_input_crossing_lookup(runtime.external_count, input_crossing_map)?;
+        runtime.attach_physics(Arc::new(PhysicsRuntime::new(physics_v1.clone())?))?;
+        // Execution keeps the representative flavours and LC words; only the
+        // exposed metadata names the selected process-group member.
+        let physics_v1 = if selection.process_group.is_some() {
+            apply_process_group_metadata(&physics_v1, &selection)?
+        } else {
+            physics_v1
+        };
+        if matches!(&execution_lane, NativeExecutionLane::Compiled) {
+            runtime.initialize_compiled_helicity_execution_plan(
+                public_remap.then_some(selection.external_permutation.as_slice()),
+            )?;
+        }
+        let selector_simd_lane_width = {
+            let uses_simd_jit = match &execution_lane {
+                NativeExecutionLane::Compiled => execution_uses_simd_jit(&runtime),
+                #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                NativeExecutionLane::Eager(runtime) => runtime.backend_name() == "jit",
+                #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                NativeExecutionLane::Recurrence(runtime) => runtime.backend_name() == "jit",
+                #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                NativeExecutionLane::OnTheFly(_) => false,
+            };
+            if uses_simd_jit {
+                super::evaluator::native_f64_simd_lane_width()
+            } else {
+                1
+            }
+        };
+        let mut loaded = Self {
+            root,
+            artifact_id,
+            runtime,
+            execution_lane,
+            process,
+            process_key,
+            representative_process_id,
+            external_permutation: selection.external_permutation.clone(),
+            input_crossing_map,
+            permutation_alias_of: public_remap.then(|| representative_key.clone()),
+            process_group: process_group_routing(&selection, &representative_key),
+            final_state_permutation_alias_of: final_state_only.then_some(representative_key),
+            physics_v1: LazyProcessPhysicsV1::loaded(physics_v1),
+            warnings_muted: false,
+            warned_kinds: BTreeSet::new(),
+            pending_warnings: Vec::new(),
+            point_selector_scratch: PointSelectorExecutionScratch::default(),
+            selector_simd_lane_width,
+            correlated: None,
+        };
+        if let Some(path) = model_parameters_path {
+            loaded.set_model_parameters_json(path)?;
+        }
+        Ok(loaded)
+    }
+
+    // Darwin reports each referenced clean executable page in process RSS.
+    // Keep the authenticated process-ready load path and its load-only callees
+    // in one Apple section; evaluation code remains in the ordinary text
+    // section and non-Apple builds retain their normal placement.
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    fn load_recurrence_bootstrap(
+        bootstrap: crate::artifact::RecurrenceBootstrapArtifact,
+        model_parameters_path: Option<&Path>,
+    ) -> Result<Self, RusticolError> {
+        let crate::artifact::RecurrenceBootstrapArtifact {
+            mut artifact,
+            selection,
+            ready_execution,
+            physics: physics_v1,
+            evaluator_payload_container,
+        } = bootstrap;
+        ensure_selected_runtime_capabilities_supported(
+            &selection.process.required_runtime_capabilities,
+        )?;
+        validate_capability_list_match(
+            &artifact.manifest().runtime.required_runtime_capabilities,
+            &ready_execution.required_runtime_capabilities,
+            "outer runtime and recurrence process-ready recipe",
+        )?;
+        validate_representative_physics(&physics_v1, &selection)?;
+
+        // The authenticated member uses the exact conventional execution path
+        // above, and public process IDs are already confined by the outer
+        // manifest validator. Avoid reopening the duplicate loose JSON merely
+        // to recover its parent directory.
+        let evaluator_root = artifact
+            .root()
+            .join("processes")
+            .join(&selection.process.id);
+        let representative_key = ready_execution.key.clone();
+        let loaded = load_recurrence_ready_runtime(
+            &mut artifact,
+            &evaluator_root,
+            &ready_execution,
+            &physics_v1,
+            &evaluator_payload_container,
+        )?;
+        Self::finish_dense_load(
+            artifact.root().to_path_buf(),
+            artifact.manifest().artifact_id.clone(),
+            selection,
+            physics_v1,
+            representative_key,
+            loaded.common,
+            NativeExecutionLane::Recurrence(Box::new(loaded.lane)),
+            model_parameters_path,
+        )
+    }
+
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    pub fn load(
+        artifact_path: impl AsRef<Path>,
+        process_id: Option<&str>,
+        model_parameters_path: Option<&Path>,
+    ) -> Result<Self, RusticolError> {
+        let artifact_path = artifact_path.as_ref();
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if let Some(bootstrap) =
+            VerifiedArtifact::try_open_recurrence_bootstrap(artifact_path, process_id)?
+        {
+            return Self::load_recurrence_bootstrap(bootstrap, model_parameters_path);
+        }
+        Self::load_generic(artifact_path, process_id, model_parameters_path)
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn load_generic(
+        artifact_path: &Path,
+        process_id: Option<&str>,
+        model_parameters_path: Option<&Path>,
+    ) -> Result<Self, RusticolError> {
+        let artifact = VerifiedArtifact::open_with_manifest_preflight(artifact_path, |manifest| {
+            match manifest.select_process(process_id) {
+                Ok(selection) => ensure_selected_runtime_capabilities_supported(
+                    &selection.process.required_runtime_capabilities,
+                ),
+                // A process-group member resolves only after the map payload
+                // is read; its representative is checked below.
+                Err(_)
+                    if manifest
+                        .payloads
+                        .iter()
+                        .any(|payload| payload.role == crate::PayloadRole::ProcessGroups) =>
+                {
+                    Ok(())
+                }
+                Err(error) => Err(error),
+            }
+        })?;
+        let artifact_id = artifact.manifest().artifact_id.clone();
+        let selection = artifact.select_process(process_id)?;
+        if selection.process_group.is_some() {
+            ensure_selected_runtime_capabilities_supported(
+                &selection.process.required_runtime_capabilities,
+            )?;
+        }
+        let (manifest, evaluator_root) = load_verified_evaluator(&artifact, &selection)?;
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if let LoadedExecutionManifest::OnTheFly(on_the_fly) = &manifest {
+            let public_remap = selection.remaps_public_process();
+            let nonidentity_permutation = selection
+                .external_permutation
+                .iter()
+                .copied()
+                .enumerate()
+                .any(|(representative_index, public_index)| representative_index != public_index);
+            let initial_count = on_the_fly
+                .runtime_metadata
+                .external_legs
+                .iter()
+                .filter(|leg| leg.is_initial)
+                .count();
+            let final_state_only = public_remap
+                && selection
+                    .external_permutation
+                    .iter()
+                    .take(initial_count)
+                    .copied()
+                    .enumerate()
+                    .all(|(index, public_index)| index == public_index);
+            let loaded = super::on_the_fly_load::load_on_the_fly_native_runtime(
+                &artifact,
+                &evaluator_root,
+                on_the_fly,
+                &selection,
+            )?;
+            let super::on_the_fly_load::LoadedOnTheFlyRuntime {
+                mut common,
+                lane,
+                selectors,
+                metadata_selectors,
+                public_metadata,
+                color_contraction,
+            } = loaded;
+            if public_remap {
+                common.set_external_pdg_order_recursive(&selection.external_pdgs);
+            }
+            let input_crossing_map = nonidentity_permutation.then(|| {
+                selection
+                    .external_permutation
+                    .iter()
+                    .copied()
+                    .enumerate()
+                    .map(|(target_index, source_index)| InputCrossingMapEntry {
+                        target_index,
+                        source_index,
+                        sign: 1.0,
+                    })
+                    .collect::<Vec<_>>()
+            });
+            let input_crossing_map =
+                prevalidate_input_crossing_lookup(common.external_count, input_crossing_map)?;
+            let representative_key = on_the_fly.key.clone();
+            let mut runtime = Self {
+                root: artifact.root().to_path_buf(),
+                artifact_id,
+                runtime: common,
+                execution_lane: NativeExecutionLane::OnTheFly(Box::new(
+                    OnTheFlyExecutionRuntime::new(lane, selectors, color_contraction),
+                )),
+                process: selection.public_expression.clone(),
+                process_key: selection.requested_id.clone(),
+                representative_process_id: selection.process.id.clone(),
+                external_permutation: selection.external_permutation.clone(),
+                input_crossing_map,
+                permutation_alias_of: public_remap.then(|| representative_key.clone()),
+                process_group: process_group_routing(&selection, &representative_key),
+                final_state_permutation_alias_of: final_state_only.then_some(representative_key),
+                physics_v1: LazyProcessPhysicsV1::deferred_on_the_fly(
+                    public_metadata,
+                    metadata_selectors,
+                    selection,
+                ),
+                warnings_muted: false,
+                warned_kinds: BTreeSet::new(),
+                pending_warnings: Vec::new(),
+                point_selector_scratch: PointSelectorExecutionScratch::default(),
+                selector_simd_lane_width: 1,
+                correlated: None,
+            };
+            if let Some(path) = model_parameters_path {
+                runtime.set_model_parameters_json(path)?;
+            }
+            return Ok(runtime);
+        }
+        let physics_bytes = artifact.read_payload(&selection.process.physics_path)?;
+        let mut physics_v1 =
+            ProcessPhysicsV1::from_json(&physics_bytes, &selection.process.physics_path)?;
+        if physics_v1.process_id != selection.process.id
+            || physics_v1.process != selection.process.expression
+            || physics_v1.color_accuracy.as_str() != selection.process.color_accuracy
+            || physics_v1
+                .external_particles
+                .iter()
+                .map(|particle| particle.pdg)
+                .ne(selection.process.external_pdgs.iter().copied())
+        {
+            return Err(RusticolError::integrity(format!(
+                "runtime physics payload {:?} does not match process {:?}",
+                selection.process.physics_path, selection.process.id
+            )));
+        }
+        let (_representative_process, representative_key, runtime, execution_lane) = match manifest
+        {
+            LoadedExecutionManifest::Compiled(manifest) => {
+                super::eager_v3_load::reject_native_reduction_groups_for_compiled(&physics_v1)?;
+                let representative_process = manifest.process.clone();
+                let representative_key = manifest.key.clone();
+                let evaluator_payloads = artifact.evaluator_payload_store(&evaluator_root)?;
+                // Tile sizing is bound to the representative physics
+                // before public alias remapping. Aliases preserve these
+                // component counts and the execution payload itself is
+                // authenticated against the representative identifiers.
+                let sizing_physics = PhysicsRuntime::new(physics_v1.clone())?;
+                let runtime = load_execution_manifest_with_store(
+                    *manifest,
+                    &evaluator_payloads,
+                    &sizing_physics,
+                )?;
+                (
+                    representative_process,
+                    representative_key,
+                    runtime,
+                    NativeExecutionLane::Compiled,
+                )
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::EagerV3(manifest) => {
+                let representative_process = manifest.process.clone();
+                let representative_key = manifest.key.clone();
+                let loaded = super::eager_v3_load::load_eager_v3_native_runtime(
+                    &artifact,
+                    &evaluator_root,
+                    &manifest,
+                    &mut physics_v1,
+                )?;
+                (
+                    representative_process,
+                    representative_key,
+                    loaded.common,
+                    NativeExecutionLane::Eager(Box::new(loaded.lane)),
+                )
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::Recurrence(manifest) => {
+                let representative_process = manifest.process.clone();
+                let representative_key = manifest.key.clone();
+                let loaded = load_recurrence_native_runtime(
+                    &artifact,
+                    &evaluator_root,
+                    &manifest,
+                    &physics_v1,
+                    &selection,
+                )?;
+                (
+                    representative_process,
+                    representative_key,
+                    loaded.common,
+                    NativeExecutionLane::Recurrence(Box::new(loaded.lane)),
+                )
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            LoadedExecutionManifest::OnTheFly(_) => {
+                unreachable!("on-the-fly manifests are dispatched before dense physics loading")
+            }
+        };
+        Self::finish_dense_load(
+            artifact.root().to_path_buf(),
+            artifact_id,
+            selection,
+            physics_v1,
+            representative_key,
+            runtime,
+            execution_lane,
+            model_parameters_path,
+        )
+    }
+
+    pub fn metadata(&self) -> NativeRuntimeMetadata {
+        let (
+            execution_mode,
+            prepared_backend,
+            eager_effective_point_tile_size,
+            eager_workspace_bytes,
+            on_the_fly_requested_query_construction_threads,
+            on_the_fly_effective_query_construction_threads,
+        ) = match &self.execution_lane {
+            NativeExecutionLane::Compiled => ("compiled", None, None, None, None, None),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Eager(runtime) => (
+                "eager",
+                Some(runtime.backend_name().to_string()),
+                Some(runtime.effective_point_tile_size()),
+                Some(runtime.workspace_bytes()),
+                None,
+                None,
+            ),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Recurrence(runtime) => (
+                "recurrence",
+                Some(runtime.backend_name().to_string()),
+                Some(runtime.effective_point_tile_size()),
+                None,
+                None,
+                None,
+            ),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::OnTheFly(runtime) => (
+                "on-the-fly",
+                None,
+                None,
+                None,
+                Some(runtime.lane.requested_query_construction_threads()),
+                Some(runtime.lane.effective_query_construction_threads()),
+            ),
+        };
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        let compiled_direct_configuration = compiled_direct_configuration_snapshot(&self.runtime);
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        let (
+            compiled_direct_minimum_effective_tile_capacity,
+            compiled_direct_maximum_physical_scalar_values_per_point,
+            compiled_direct_maximum_hot_scalar_values_per_point,
+            compiled_direct_maximum_source_scalar_values_per_point,
+            compiled_direct_maximum_reduction_scalar_values_per_point,
+        ) = if compiled_direct_configuration.engine_count == 0 {
+            (None, None, None, None, None)
+        } else {
+            (
+                Some(compiled_direct_configuration.minimum_effective_tile_capacity),
+                Some(compiled_direct_configuration.maximum_physical_scalar_values_per_point),
+                Some(compiled_direct_configuration.maximum_hot_scalar_values_per_point),
+                Some(compiled_direct_configuration.maximum_source_scalar_values_per_point),
+                Some(compiled_direct_configuration.maximum_reduction_scalar_values_per_point),
+            )
+        };
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        let (
+            compiled_direct_minimum_effective_tile_capacity,
+            compiled_direct_maximum_physical_scalar_values_per_point,
+            compiled_direct_maximum_hot_scalar_values_per_point,
+            compiled_direct_maximum_source_scalar_values_per_point,
+            compiled_direct_maximum_reduction_scalar_values_per_point,
+        ) = (None, None, None, None, None);
+        NativeRuntimeMetadata {
+            abi_version: Self::ABI_VERSION,
+            schema_version: PROCESS_ARTIFACT_SCHEMA_VERSION,
+            execution_mode: execution_mode.to_string(),
+            prepared_backend,
+            eager_effective_point_tile_size,
+            eager_workspace_bytes,
+            on_the_fly_requested_query_construction_threads,
+            on_the_fly_effective_query_construction_threads,
+            compiled_direct_minimum_effective_tile_capacity,
+            compiled_direct_maximum_physical_scalar_values_per_point,
+            compiled_direct_maximum_hot_scalar_values_per_point,
+            compiled_direct_maximum_source_scalar_values_per_point,
+            compiled_direct_maximum_reduction_scalar_values_per_point,
+            process: self.process.clone(),
+            process_key: self.process_key.clone(),
+            representative_process: self.runtime.process.clone(),
+            representative_process_key: self.runtime.key.clone(),
+            external_permutation: self.external_permutation.clone(),
+            permutation_alias_of: self.permutation_alias_of.clone(),
+            final_state_permutation_alias_of: self.final_state_permutation_alias_of.clone(),
+            process_group_member_of: self
+                .process_group
+                .as_ref()
+                .map(|group| group.representative_process_key.clone()),
+            process_group_factor: self.process_group_factor(),
+            charge_conjugated: self.charge_conjugated(),
+            color_accuracy: self.runtime.color_accuracy.clone(),
+            external_pdg_order: self.runtime.external_pdg_order.clone(),
+            external_count: self.runtime.external_count,
+            current_count: self.runtime.current_count,
+            source_count: self.runtime.source_count,
+            interaction_count: self.runtime.interaction_count,
+            stage_count: self.runtime.stage_count,
+            amplitude_output_count: self.runtime.amplitude_output_count,
+        }
+    }
+
+    fn selector_simd_lane_width(&self) -> usize {
+        self.selector_simd_lane_width
+    }
+
+    pub fn metadata_json(&self) -> Result<String, RusticolError> {
+        serde_json::to_string(&self.metadata()).map_err(|error| {
+            RusticolError::serialization(format!("could not serialize runtime metadata: {error}"))
+        })
+    }
+
+    pub fn physics_json(&self) -> Result<String, RusticolError> {
+        serde_json::to_string(self.physics_v1.get()?).map_err(|error| {
+            RusticolError::serialization(format!("could not serialize physics metadata: {error}"))
+        })
+    }
+
+    /// Return the validated mutable state needed by the lazy Python
+    /// high-precision executor.
+    ///
+    /// The values have already passed Rusticol's atomic parameter update and
+    /// derived-parameter refresh logic. They are intentionally exposed only as
+    /// an internal bridge; f64 evaluation continues to execute entirely in the
+    /// Python-independent core.
+    pub fn exact_runtime_state_json(&self) -> Result<String, RusticolError> {
+        serde_json::to_string(&serde_json::json!({
+            "model_parameter_values": self.runtime.model_parameter_values_f64,
+            "normalization_factor": self.runtime.normalization_factor,
+            "representative_process_id": self.representative_process_id,
+            "representative_process_key": self.runtime.key,
+            "external_permutation": self.external_permutation,
+            "process_group_member_of": self
+                .process_group
+                .as_ref()
+                .map(|group| group.representative_process_key.as_str()),
+            "process_group_factor": self.process_group_factor(),
+            "charge_conjugated": self.charge_conjugated(),
+        }))
+        .map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not serialize exact-runtime state: {error}"
+            ))
+        })
+    }
+
+    pub fn process_physics(&self) -> RusticolResult<&ProcessPhysicsV1> {
+        self.physics_v1.get()
+    }
+
+    pub fn external_count(&self) -> usize {
+        self.runtime.external_count
+    }
+
+    pub fn representative_process_key(&self) -> &str {
+        &self.runtime.key
+    }
+
+    /// Full representative-index to public-index external permutation.
+    pub fn external_permutation(&self) -> &[usize] {
+        &self.external_permutation
+    }
+
+    /// Exact factor multiplying every representative matrix element; one
+    /// unless the selection is a process-group member.
+    pub fn process_group_factor(&self) -> NativeRationalFactor {
+        self.process_group.as_ref().map_or(
+            NativeRationalFactor {
+                numerator: 1,
+                denominator: 1,
+            },
+            |group| group.factor,
+        )
+    }
+
+    /// Whether the selection is the charge conjugate of its representative.
+    pub fn charge_conjugated(&self) -> bool {
+        self.process_group
+            .as_ref()
+            .is_some_and(|group| group.conjugated)
+    }
+
+    /// Scale representative matrix elements to the selected member.
+    pub(super) fn apply_process_group_factor(&self, values: &mut [f64]) {
+        let Some(group) = self.process_group.as_deref() else {
+            return;
+        };
+        let NativeRationalFactor {
+            numerator,
+            denominator,
+        } = group.factor;
+        if numerator != denominator {
+            let (numerator, denominator) = (numerator as f64, denominator as f64);
+            for value in values {
+                *value = *value * numerator / denominator;
+            }
+        }
+    }
+
+    /// Translate caller color IDs to the IDs the execution lanes use.
+    pub(super) fn execution_color_ids<'a>(
+        &self,
+        ids: Option<&'a [String]>,
+    ) -> Option<Cow<'a, [String]>> {
+        let ids = ids?;
+        Some(if self.charge_conjugated() {
+            Cow::Owned(
+                ids.iter()
+                    .map(|id| charge_conjugate_color_id(id).into_owned())
+                    .collect(),
+            )
+        } else {
+            Cow::Borrowed(ids)
+        })
+    }
+
+    /// Translate execution color IDs back to the caller's labels.
+    pub(super) fn publish_color_ids(&self, ids: &mut [String]) {
+        if self.charge_conjugated() {
+            for id in ids {
+                *id = charge_conjugate_color_id(id).into_owned();
+            }
+        }
+    }
+
+    /// Load one public-order kinematic point from JSON.
+    ///
+    /// The accepted shapes are `[external][4]` and a singleton batch
+    /// `[[external][4]]`. Components may be JSON numbers or decimal strings.
+    /// The returned flat values retain the caller's public process ordering;
+    /// the ordinary evaluation entry points apply any active process
+    /// permutation when packing runtime inputs.
+    pub fn load_kinematics_json(&self, path: impl AsRef<Path>) -> Result<Vec<f64>, RusticolError> {
+        let path = path.as_ref();
+        let bytes = fs::read(path).map_err(|error| {
+            RusticolError::invalid_argument(format!(
+                "could not read kinematics JSON {}: {error}",
+                path.display()
+            ))
+        })?;
+        let value: Value = serde_json::from_slice(&bytes).map_err(|error| {
+            RusticolError::invalid_argument(format!(
+                "could not parse kinematics JSON {}: {error}",
+                path.display()
+            ))
+        })?;
+        parse_public_kinematics_point(&value, self.external_count())
+    }
+
+    pub fn external_particles(&self) -> Result<Vec<NativeExternalParticle>, RusticolError> {
+        Ok(self
+            .physics_v1
+            .get()?
+            .external_particles
+            .iter()
+            .map(|item| NativeExternalParticle {
+                label: item.label,
+                index: item.index,
+                side: match item.role {
+                    crate::ParticleRole::Initial => "initial",
+                    crate::ParticleRole::Final => "final",
+                }
+                .to_string(),
+                role: match item.role {
+                    crate::ParticleRole::Initial => "initial",
+                    crate::ParticleRole::Final => "final",
+                }
+                .to_string(),
+                particle: item.particle.clone(),
+                outgoing_particle: item.particle.clone(),
+                pdg: item.pdg,
+                outgoing_pdg: item.pdg,
+                particle_class: String::new(),
+                momentum_slot: item.momentum_slot,
+            })
+            .collect())
+    }
+
+    pub fn helicities(&self) -> Result<Vec<NativeHelicityConfiguration>, RusticolError> {
+        Ok(self
+            .physics_v1
+            .get()?
+            .helicities
+            .iter()
+            .map(|item| NativeHelicityConfiguration {
+                id: item.id.clone(),
+                index: item.index,
+                helicities: item.values.clone(),
+                representative_id: item.representative_id.clone(),
+                computed: item.computed,
+                structural_zero: item.structural_zero,
+                coefficient: item.coefficient,
+            })
+            .collect())
+    }
+
+    pub fn color_components(&self) -> Result<Vec<NativeColorComponent>, RusticolError> {
+        Ok(self
+            .physics_v1
+            .get()?
+            .color_components
+            .iter()
+            .map(|item| match item {
+                PhysicsColorComponentV1::LcFlow(flow) => NativeColorComponent {
+                    id: flow.id.clone(),
+                    index: flow.index,
+                    kind: "lc-flow".to_string(),
+                    word: flow.word.clone(),
+                    representative_id: flow.representative_id.clone(),
+                    computed: flow.computed,
+                    coefficient: flow.coefficient,
+                },
+                PhysicsColorComponentV1::ContractedColor(color) => NativeColorComponent {
+                    id: color.id.clone(),
+                    index: color.index,
+                    kind: "contracted-color".to_string(),
+                    word: Vec::new(),
+                    representative_id: color.id.clone(),
+                    computed: true,
+                    coefficient: 1.0,
+                },
+            })
+            .collect())
+    }
+
+    /// Return the current logical parameter value, including refreshed derived values.
+    pub fn model_parameter_value(&self, name: &str) -> Result<(f64, f64), RusticolError> {
+        if !self
+            .physics_v1
+            .get()?
+            .model_parameters
+            .iter()
+            .any(|parameter| parameter.name == name)
+        {
+            return Err(RusticolError::model_parameter(format!(
+                "model parameter {name:?} is not declared by process {}",
+                self.process
+            )));
+        }
+        self.runtime.current_model_parameter_value(name)
+    }
+
+    pub fn model_parameters(&self) -> Result<Vec<NativeModelParameter>, RusticolError> {
+        Ok(self
+            .physics_v1
+            .get()?
+            .model_parameters
+            .iter()
+            .enumerate()
+            .map(|(parameter_index, item)| NativeModelParameter {
+                name: item.name.clone(),
+                kind: format!("{:?}", item.kind).to_ascii_lowercase(),
+                parameter_index,
+                default: item.default_real,
+                default_imaginary: item.default_imaginary,
+                mutable: item.mutable,
+            })
+            .collect())
+    }
+
+    pub fn helicity_ids(&self) -> Result<Vec<String>, RusticolError> {
+        Ok(self
+            .physics_v1
+            .get()?
+            .helicities
+            .iter()
+            .map(|item| item.id.clone())
+            .collect())
+    }
+
+    pub fn color_ids(&self) -> Result<Vec<String>, RusticolError> {
+        Ok(self
+            .physics_v1
+            .get()?
+            .color_components
+            .iter()
+            .map(|item| item.id().to_string())
+            .collect())
+    }
+
+    pub fn resolved_shape(
+        &self,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> Result<(usize, usize), RusticolError> {
+        let color_ids = self.execution_color_ids(color_ids);
+        let color_ids = color_ids.as_deref();
+        self.validate_selector_capabilities(helicity_ids.is_some(), color_ids.is_some())?;
+        let selected_helicities = selector_set(helicity_ids, "helicity")?;
+        let selected_colors = selector_set(color_ids, "color component")?;
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if let NativeExecutionLane::OnTheFly(runtime) = &self.execution_lane {
+            let selection = runtime.selectors.selection(
+                runtime.lane.seed(),
+                selected_helicities.as_ref(),
+                if runtime.uses_contracted_color() {
+                    None
+                } else {
+                    selected_colors.as_ref()
+                },
+            )?;
+            return Ok((
+                selection.helicity_count(),
+                if runtime.uses_contracted_color() {
+                    1
+                } else {
+                    selection.color_count()
+                },
+            ));
+        }
+        let physics = self.runtime.physics.as_ref().ok_or_else(|| {
+            RusticolError::artifact(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let helicity_count = physics
+            .selected_helicity_indices(selected_helicities.as_ref())
+            .map_err(|error| RusticolError::selector(error.to_string()))?
+            .len();
+        let color_count = physics
+            .selected_color_indices(selected_colors.as_ref())
+            .map_err(|error| RusticolError::selector(error.to_string()))?
+            .len();
+        Ok((helicity_count, color_count))
+    }
+
+    /// Private compact context for the existing Python benchmark service.
+    /// Non-OTF lanes return `None`; OTF resolves optional one-based color
+    /// ordinals without opening process-wide physics metadata.
+    pub fn on_the_fly_benchmark_context_json(
+        &self,
+        requested_color_ids: Option<&[String]>,
+    ) -> RusticolResult<Option<String>> {
+        let requested_color_ids = self.execution_color_ids(requested_color_ids);
+        let requested_color_ids = requested_color_ids.as_deref();
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if let NativeExecutionLane::OnTheFly(runtime) = &self.execution_lane {
+            let selection = runtime
+                .selectors
+                .selection(runtime.lane.seed(), None, None)?;
+            let mut selected_color_ids = Vec::new();
+            if let Some(requested) = requested_color_ids {
+                if runtime.uses_contracted_color() {
+                    return Err(RusticolError::selector(
+                        "on-the-fly contracted color does not expose benchmark color selectors",
+                    ));
+                }
+                selected_color_ids
+                    .try_reserve_exact(requested.len())
+                    .map_err(|error| {
+                        RusticolError::invalid_argument(format!(
+                            "on-the-fly benchmark selector allocation failed: {error}"
+                        ))
+                    })?;
+                for value in requested {
+                    let resolved = match value.parse::<usize>() {
+                        Ok(ordinal) if ordinal.to_string() == value.trim() => {
+                            if ordinal == 0 || ordinal > selection.color_count() {
+                                return Err(RusticolError::selector(format!(
+                                    "color-flow ordinal {value:?} is out of range; choose 1..{} or a stable color component ID",
+                                    selection.color_count(),
+                                )));
+                            }
+                            selection.color_id_at(ordinal - 1)?
+                        }
+                        _ => {
+                            runtime.selectors.parse_color_id(value)?;
+                            value.clone()
+                        }
+                    };
+                    selected_color_ids.push(resolved);
+                }
+            }
+            self.publish_color_ids(&mut selected_color_ids);
+            return serde_json::to_string(&serde_json::json!({
+                "process_id": self.process_key,
+                "process_expression": self.process,
+                "color_accuracy": self.runtime.color_accuracy,
+                "helicity_count": selection.helicity_count(),
+                "color_count": if runtime.uses_contracted_color() { 1 } else { selection.color_count() },
+                "selected_color_ids": selected_color_ids,
+            }))
+            .map(Some)
+            .map_err(|error| {
+                RusticolError::serialization(format!(
+                    "could not serialize on-the-fly benchmark context: {error}"
+                ))
+            });
+        }
+        Ok(None)
+    }
+
+    /// Resolve existing public per-point selector IDs to compact public-axis
+    /// ordinals without materializing process-wide physics metadata.
+    pub fn on_the_fly_selector_ordinals_json(
+        &self,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> RusticolResult<Option<String>> {
+        let color_ids = self.execution_color_ids(color_ids);
+        let color_ids = color_ids.as_deref();
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if let NativeExecutionLane::OnTheFly(runtime) = &self.execution_lane {
+            if runtime.uses_contracted_color() && color_ids.is_some() {
+                return Err(RusticolError::selector(
+                    "on-the-fly contracted color does not expose color selector ordinals",
+                ));
+            }
+            let helicity_ordinals = helicity_ids
+                .map(|ids| {
+                    ids.iter()
+                        .map(|id| {
+                            let selected = BTreeSet::from([id.clone()]);
+                            runtime
+                                .selectors
+                                .selection(runtime.lane.seed(), Some(&selected), None)?
+                                .helicity_ordinal_at(0)
+                        })
+                        .collect::<RusticolResult<Vec<_>>>()
+                })
+                .transpose()?;
+            let color_ordinals = color_ids
+                .map(|ids| {
+                    ids.iter()
+                        .map(|id| {
+                            let selected = BTreeSet::from([id.clone()]);
+                            runtime
+                                .selectors
+                                .selection(runtime.lane.seed(), None, Some(&selected))?
+                                .color_ordinal_at(0)
+                        })
+                        .collect::<RusticolResult<Vec<_>>>()
+                })
+                .transpose()?;
+            return serde_json::to_string(&serde_json::json!({
+                "helicity_ordinals": helicity_ordinals,
+                "color_ordinals": color_ordinals,
+            }))
+            .map(Some)
+            .map_err(|error| {
+                RusticolError::serialization(format!(
+                    "could not serialize on-the-fly selector ordinals: {error}"
+                ))
+            });
+        }
+        Ok(None)
+    }
+
+    /// Return private read-only production introspection for the loaded compact
+    /// query-family lane.
+    ///
+    /// This observes the same retained selector/family caches used by public
+    /// evaluation. It does not construct selectors or open dense physics
+    /// metadata. A recurrence lane reports the same census only when it owns
+    /// the authenticated singleton-helicity companion; other lanes return
+    /// `None`.
+    pub fn on_the_fly_runtime_state_census_json(&self) -> RusticolResult<Option<String>> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        {
+            let census = match &self.execution_lane {
+                NativeExecutionLane::OnTheFly(runtime) => {
+                    Some(runtime.state_census(&self.process_key)?)
+                }
+                NativeExecutionLane::Recurrence(runtime) => {
+                    runtime.helicity_selector_companion_state_census(&self.process_key)?
+                }
+                _ => None,
+            };
+            let Some(census) = census else {
+                return Ok(None);
+            };
+            serde_json::to_string(&census).map(Some).map_err(|error| {
+                RusticolError::serialization(format!(
+                    "could not serialize on-the-fly runtime state census: {error}"
+                ))
+            })
+        }
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        Ok(None)
+    }
+
+    /// Explicitly construct and retain one selected OTF family, then execute
+    /// exactly one binary64 point before committing its selector identity.
+    /// Progress callbacks run only on the coordinating caller thread.
+    /// `n_cores` overrides cold query construction for this call only; `None`
+    /// uses the process-output default. Positive overrides are capped by host
+    /// availability and do not invalidate an already retained family.
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    pub fn warm_up_f64<'observer>(
+        &mut self,
+        momenta: &[f64],
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+        n_cores: Option<usize>,
+        observer: Option<
+            &'observer mut super::on_the_fly_warm_up::NativeOnTheFlyWarmUpObserver<'observer>,
+        >,
+    ) -> RusticolResult<super::on_the_fly_warm_up::NativeOnTheFlyWarmUpResult> {
+        self.warm_up_on_the_fly_f64_with_selectors(
+            momenta,
+            helicity_ids,
+            color_ids,
+            n_cores,
+            observer,
+        )
+    }
+
+    /// Explicitly named alias for [`Self::warm_up_f64`], retained for bindings
+    /// which make the on-the-fly-only capability visible in their method name.
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    pub fn warm_up_on_the_fly_f64_with_selectors<'observer>(
+        &mut self,
+        momenta: &[f64],
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+        n_cores: Option<usize>,
+        observer: Option<
+            &'observer mut super::on_the_fly_warm_up::NativeOnTheFlyWarmUpObserver<'observer>,
+        >,
+    ) -> RusticolResult<super::on_the_fly_warm_up::NativeOnTheFlyWarmUpResult> {
+        let color_ids = self.execution_color_ids(color_ids);
+        let color_ids = color_ids.as_deref();
+        let expected = self.runtime.external_count.checked_mul(4).ok_or_else(|| {
+            RusticolError::invalid_argument("on-the-fly warm-up momentum shape exceeds usize")
+        })?;
+        if momenta.len() != expected {
+            return Err(RusticolError::invalid_argument(format!(
+                "on-the-fly warm-up requires exactly one point ({expected} binary64 momentum values), received {}",
+                momenta.len()
+            )));
+        }
+        let crossing_lookup = std::mem::take(&mut self.input_crossing_map);
+        let mut selector_scratch = std::mem::take(&mut self.point_selector_scratch);
+        let result = (|| {
+            let selected_helicities = selector_scratch
+                .helicity_selector_sets
+                .resolve(helicity_ids, "helicity")?;
+            let selected_colors = selector_scratch
+                .color_selector_sets
+                .resolve(color_ids, "color component")?;
+            let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                momenta,
+                1,
+                self.runtime.external_count,
+                crossing_lookup.as_deref(),
+            )?;
+            let NativeExecutionLane::OnTheFly(runtime) = &mut self.execution_lane else {
+                return Err(RusticolError::unsupported_runtime_capability(
+                    ON_THE_FLY_RUNTIME_CAPABILITY,
+                    "the explicit warm-up API requires an on-the-fly artifact",
+                ));
+            };
+            runtime.warm_up_f64(
+                &self.runtime,
+                batch,
+                selected_helicities,
+                selected_colors,
+                n_cores,
+                observer,
+            )
+        })();
+        self.point_selector_scratch = selector_scratch;
+        self.input_crossing_map = crossing_lookup;
+        result
+    }
+
+    /// Resolve and retain batch-global recurrence selectors once.
+    ///
+    /// The returned handle is tied to this artifact and representative
+    /// process. Handle creation may allocate; repeated evaluation through the
+    /// prepared-plan API does not rebuild string selector sets.
+    pub fn prepare_recurrence_selector_plan(
+        &self,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> RusticolResult<NativeRecurrenceSelectorPlan> {
+        let NativeExecutionLane::Recurrence(runtime) = &self.execution_lane else {
+            return Err(RusticolError::invalid_argument(
+                "recurrence selector plans require a recurrence artifact",
+            ));
+        };
+        let color_ids = self.execution_color_ids(color_ids);
+        let color_ids = color_ids.as_deref();
+        self.validate_selector_capabilities(helicity_ids.is_some(), color_ids.is_some())?;
+        let selected_helicities = selector_set(helicity_ids, "helicity")?;
+        let selected_colors = selector_set(color_ids, "color component")?;
+        let physics = self.runtime.physics.as_ref().ok_or_else(|| {
+            RusticolError::artifact("recurrence execution requires physics metadata")
+        })?;
+        runtime.validate_global_selectors(
+            physics,
+            selected_helicities.as_ref(),
+            selected_colors.as_ref(),
+        )?;
+        Ok(NativeRecurrenceSelectorPlan {
+            artifact_root: self.root.clone(),
+            process_key: self.process_key.clone(),
+            external_permutation: self.external_permutation.clone(),
+            selected_helicities,
+            selected_colors,
+        })
+    }
+
+    pub fn evaluate_f64(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+    ) -> Result<Vec<f64>, RusticolError> {
+        validate_flat_momentum_shape(momenta.len(), point_count, self.runtime.external_count)?;
+        let mut output = vec![0.0; point_count];
+        let crossing_lookup = std::mem::take(&mut self.input_crossing_map);
+        let result = (|| {
+            let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                momenta,
+                point_count,
+                self.runtime.external_count,
+                crossing_lookup.as_deref(),
+            )?;
+            self.run_f64_batch_into(batch, &mut output)
+        })();
+        self.input_crossing_map = crossing_lookup;
+        result?;
+        self.apply_process_group_factor(&mut output);
+        Ok(output)
+    }
+
+    pub fn evaluate_f64_into(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        validate_flat_momentum_shape(momenta.len(), point_count, self.runtime.external_count)?;
+        if output.len() != point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "evaluation output has length {}, expected {point_count}",
+                output.len()
+            )));
+        }
+        let crossing_lookup = std::mem::take(&mut self.input_crossing_map);
+        let result = (|| {
+            let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                momenta,
+                point_count,
+                self.runtime.external_count,
+                crossing_lookup.as_deref(),
+            )?;
+            self.run_f64_batch_into(batch, output)
+        })();
+        self.input_crossing_map = crossing_lookup;
+        result?;
+        self.apply_process_group_factor(output);
+        Ok(())
+    }
+
+    /// Evaluate recurrence totals with a previously resolved selector plan.
+    pub fn evaluate_f64_into_with_recurrence_selector_plan(
+        &mut self,
+        plan: &NativeRecurrenceSelectorPlan,
+        momenta: &[f64],
+        point_count: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        if !matches!(&self.execution_lane, NativeExecutionLane::Recurrence(_)) {
+            return Err(RusticolError::invalid_argument(
+                "recurrence selector plans require a recurrence artifact",
+            ));
+        }
+        plan.ensure_matches(self)?;
+        validate_flat_momentum_shape(momenta.len(), point_count, self.runtime.external_count)?;
+        if output.len() != point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "evaluation output has length {}, expected {point_count}",
+                output.len()
+            )));
+        }
+        let crossing_lookup = std::mem::take(&mut self.input_crossing_map);
+        let result = (|| {
+            let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                momenta,
+                point_count,
+                self.runtime.external_count,
+                crossing_lookup.as_deref(),
+            )?;
+            if plan.selected_helicities.is_some() || plan.selected_colors.is_some() {
+                self.run_selected_f64_batch_into(
+                    batch,
+                    plan.selected_helicities.as_ref(),
+                    plan.selected_colors.as_ref(),
+                    output,
+                )
+            } else {
+                self.run_f64_batch_into(batch, output)
+            }
+        })();
+        self.input_crossing_map = crossing_lookup;
+        result?;
+        self.apply_process_group_factor(output);
+        Ok(())
+    }
+
+    /// Evaluate one total per point with optional global or per-point selectors.
+    ///
+    /// Global selectors retain the existing subset semantics. Per-point
+    /// selectors are resolved physical-axis indices and contain exactly one
+    /// selector for every input point. The two forms are mutually exclusive on
+    /// the same axis. An omitted axis is summed over all components retained by
+    /// the artifact.
+    pub fn evaluate_f64_with_selectors(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+        helicity_by_point: Option<&[u32]>,
+        color_by_point: Option<&[u32]>,
+    ) -> Result<Vec<f64>, RusticolError> {
+        validate_flat_momentum_shape(momenta.len(), point_count, self.runtime.external_count)?;
+        let mut output = vec![0.0; point_count];
+        self.evaluate_f64_into_with_selectors(
+            momenta,
+            point_count,
+            helicity_ids,
+            color_ids,
+            helicity_by_point,
+            color_by_point,
+            &mut output,
+        )?;
+        Ok(output)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn evaluate_f64_into_with_selectors(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+        helicity_by_point: Option<&[u32]>,
+        color_by_point: Option<&[u32]>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let color_ids = self.execution_color_ids(color_ids);
+        self.evaluate_representative_f64_into_with_selectors(
+            momenta,
+            point_count,
+            helicity_ids,
+            color_ids.as_deref(),
+            helicity_by_point,
+            color_by_point,
+            output,
+        )?;
+        self.apply_process_group_factor(output);
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn evaluate_representative_f64_into_with_selectors(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+        helicity_by_point: Option<&[u32]>,
+        color_by_point: Option<&[u32]>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        validate_flat_momentum_shape(momenta.len(), point_count, self.runtime.external_count)?;
+        if output.len() != point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "evaluation output has length {}, expected {point_count}",
+                output.len()
+            )));
+        }
+        if helicity_ids.is_some() && helicity_by_point.is_some() {
+            return Err(RusticolError::selector(
+                "helicities and helicity_by_point are mutually exclusive",
+            ));
+        }
+        if color_ids.is_some() && color_by_point.is_some() {
+            return Err(RusticolError::selector(
+                "color_flows and color_flow_by_point are mutually exclusive",
+            ));
+        }
+        self.validate_selector_capabilities(
+            helicity_ids.is_some() || helicity_by_point.is_some(),
+            color_ids.is_some() || color_by_point.is_some(),
+        )?;
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if matches!(&self.execution_lane, NativeExecutionLane::OnTheFly(_)) {
+            return self.evaluate_on_the_fly_f64_into_with_selectors(
+                momenta,
+                point_count,
+                helicity_ids,
+                color_ids,
+                helicity_by_point,
+                color_by_point,
+                output,
+            );
+        }
+        let physics = self.runtime.physics.clone().ok_or_else(|| {
+            RusticolError::artifact(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let crossing_lookup = std::mem::take(&mut self.input_crossing_map);
+        let mut selector_scratch = std::mem::take(&mut self.point_selector_scratch);
+        let result = (|| {
+            if helicity_by_point.is_some() || color_by_point.is_some() {
+                selector_scratch.prepare_singletons(&physics);
+            }
+            let PointSelectorExecutionScratch {
+                planner,
+                gathered_batch,
+                partition_totals,
+                output_totals,
+                helicity_selector_sets,
+                color_selector_sets,
+                helicity_singletons,
+                color_singletons,
+            } = &mut selector_scratch;
+            let selected_helicities = helicity_selector_sets.resolve(helicity_ids, "helicity")?;
+            let selected_colors = color_selector_sets.resolve(color_ids, "color component")?;
+            let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                momenta,
+                point_count,
+                self.runtime.external_count,
+                crossing_lookup.as_deref(),
+            )?;
+            let plan = planner.build(
+                point_count,
+                helicity_by_point,
+                color_by_point,
+                physics.manifest.helicities.len(),
+                physics.manifest.color_components.len(),
+            )?;
+            if plan == PointSelectorPlan::None {
+                if selected_helicities.is_some() || selected_colors.is_some() {
+                    return self.run_selected_f64_batch_into(
+                        batch,
+                        selected_helicities,
+                        selected_colors,
+                        output,
+                    );
+                }
+                return self.run_f64_batch_into(batch, output);
+            }
+
+            self.record_resolved_warnings(helicity_ids, color_ids)?;
+            if let PointSelectorPlan::Homogeneous(key) = plan {
+                // Selecting the sole retained value of an axis is identical
+                // to leaving that axis unselected.  Generation-specialized
+                // recurrence artifacts use exactly this shape in scalar
+                // performance and event-loop calls; route it through the
+                // ordinary borrowed-output path so we do not rescan singleton
+                // string sets or stage through a second output buffer.
+                let point_helicities = key.helicity_index.and_then(|index| {
+                    (physics.manifest.helicities.len() != 1).then(|| &helicity_singletons[index])
+                });
+                let point_colors = key.color_index.and_then(|index| {
+                    (physics.manifest.color_components.len() != 1).then(|| &color_singletons[index])
+                });
+                let effective_helicities = point_helicities.or(selected_helicities);
+                let effective_colors = point_colors.or(selected_colors);
+                if effective_helicities.is_none() && effective_colors.is_none() {
+                    self.run_f64_batch_into(batch, output)?;
+                } else {
+                    self.run_selected_f64_batch_into(
+                        batch,
+                        effective_helicities,
+                        effective_colors,
+                        output,
+                    )?;
+                }
+                return Ok(());
+            }
+
+            output_totals.resize(point_count, 0.0);
+            output_totals.fill(0.0);
+            let partition_count = planner.partitions().len();
+            for partition_index in 0..partition_count {
+                let partition = planner.partitions()[partition_index];
+                let point_helicities = partition
+                    .key
+                    .helicity_index
+                    .map(|index| &helicity_singletons[index]);
+                let point_colors = partition
+                    .key
+                    .color_index
+                    .map(|index| &color_singletons[index]);
+                let effective_helicities = point_helicities.or(selected_helicities);
+                let effective_colors = point_colors.or(selected_colors);
+                match partition.rows {
+                    PointSelectorRows::Contiguous { start, end } => {
+                        self.run_selected_f64_batch_into(
+                            batch.subview(start, end)?,
+                            effective_helicities,
+                            effective_colors,
+                            &mut output_totals[start..end],
+                        )?;
+                    }
+                    rows @ PointSelectorRows::Gathered { .. } => {
+                        let point_indices = planner.gathered_rows(rows);
+                        let gathered_batch =
+                            fill_gathered_batch_from_view(gathered_batch, batch, point_indices)?;
+                        partition_totals.resize(partition.rows.len(), 0.0);
+                        partition_totals.fill(0.0);
+                        self.run_selected_f64_batch_into(
+                            F64MomentumBatchView::from_nested(
+                                gathered_batch,
+                                self.runtime.external_count,
+                            )?,
+                            effective_helicities,
+                            effective_colors,
+                            partition_totals,
+                        )?;
+                        scatter_partition_totals(
+                            output_totals,
+                            partition_totals,
+                            partition.rows,
+                            planner,
+                        );
+                    }
+                }
+            }
+            output.copy_from_slice(output_totals);
+            Ok(())
+        })();
+        self.point_selector_scratch = selector_scratch;
+        self.input_crossing_map = crossing_lookup;
+        result
+    }
+
+    /// Route ordinary public evaluation through the compact on-the-fly
+    /// selector domain.  This must run before any dense `PhysicsRuntime`
+    /// access: on-the-fly artifacts intentionally leave that metadata lazy.
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[allow(clippy::too_many_arguments)]
+    fn evaluate_on_the_fly_f64_into_with_selectors(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+        helicity_by_point: Option<&[u32]>,
+        color_by_point: Option<&[u32]>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let crossing_lookup = std::mem::take(&mut self.input_crossing_map);
+        let mut selector_scratch = std::mem::take(&mut self.point_selector_scratch);
+        let result = (|| {
+            let PointSelectorExecutionScratch {
+                planner,
+                gathered_batch,
+                partition_totals,
+                output_totals,
+                helicity_selector_sets,
+                color_selector_sets,
+                ..
+            } = &mut selector_scratch;
+            let selected_helicities = helicity_selector_sets.resolve(helicity_ids, "helicity")?;
+            let selected_colors = color_selector_sets.resolve(color_ids, "color component")?;
+            if helicity_by_point.is_none() && color_by_point.is_none() {
+                let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                    momenta,
+                    point_count,
+                    self.runtime.external_count,
+                    crossing_lookup.as_deref(),
+                )?;
+                return self.run_selected_f64_batch_into(
+                    batch,
+                    selected_helicities,
+                    selected_colors,
+                    output,
+                );
+            }
+            // Per-point routing retains its ordinal planner.  Fixed global
+            // selection is handled above so its IDs are parsed only by the
+            // lane on a cold family and matched allocation-free once warm.
+            let (selected_helicity_ordinals, selected_color_ordinals) =
+                self.on_the_fly_selected_ordinals(selected_helicities, selected_colors)?;
+            let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                momenta,
+                point_count,
+                self.runtime.external_count,
+                crossing_lookup.as_deref(),
+            )?;
+
+            let (helicity_count, color_count) = self.on_the_fly_selector_counts()?;
+            let plan = planner.build(
+                point_count,
+                helicity_by_point,
+                color_by_point,
+                helicity_count,
+                color_count,
+            )?;
+            self.record_resolved_warnings(helicity_ids, color_ids)?;
+            output_totals.resize(point_count, 0.0);
+            output_totals.fill(0.0);
+            if let PointSelectorPlan::Homogeneous(key) = plan {
+                let point_helicity = key.helicity_index.map(|index| [index]);
+                let point_color = key.color_index.map(|index| [index]);
+                self.run_on_the_fly_f64_batch_into_by_ordinals(
+                    batch,
+                    point_helicity
+                        .as_ref()
+                        .map(<[usize; 1]>::as_slice)
+                        .or(selected_helicity_ordinals.as_deref()),
+                    point_color
+                        .as_ref()
+                        .map(<[usize; 1]>::as_slice)
+                        .or(selected_color_ordinals.as_deref()),
+                    output_totals,
+                )?;
+                output.copy_from_slice(output_totals);
+                return Ok(());
+            }
+
+            let partition_count = planner.partitions().len();
+            for partition_index in 0..partition_count {
+                let partition = planner.partitions()[partition_index];
+                let point_helicity = partition.key.helicity_index.map(|index| [index]);
+                let point_color = partition.key.color_index.map(|index| [index]);
+                let effective_helicities = point_helicity
+                    .as_ref()
+                    .map(<[usize; 1]>::as_slice)
+                    .or(selected_helicity_ordinals.as_deref());
+                let effective_colors = point_color
+                    .as_ref()
+                    .map(<[usize; 1]>::as_slice)
+                    .or(selected_color_ordinals.as_deref());
+                match partition.rows {
+                    PointSelectorRows::Contiguous { start, end } => {
+                        self.run_on_the_fly_f64_batch_into_by_ordinals(
+                            batch.subview(start, end)?,
+                            effective_helicities,
+                            effective_colors,
+                            &mut output_totals[start..end],
+                        )?;
+                    }
+                    rows @ PointSelectorRows::Gathered { .. } => {
+                        let point_indices = planner.gathered_rows(rows);
+                        let gathered_batch =
+                            fill_gathered_batch_from_view(gathered_batch, batch, point_indices)?;
+                        partition_totals.resize(partition.rows.len(), 0.0);
+                        partition_totals.fill(0.0);
+                        self.run_on_the_fly_f64_batch_into_by_ordinals(
+                            F64MomentumBatchView::from_nested(
+                                gathered_batch,
+                                self.runtime.external_count,
+                            )?,
+                            effective_helicities,
+                            effective_colors,
+                            partition_totals,
+                        )?;
+                        scatter_partition_totals(
+                            output_totals,
+                            partition_totals,
+                            partition.rows,
+                            planner,
+                        );
+                    }
+                }
+            }
+            output.copy_from_slice(output_totals);
+            Ok(())
+        })();
+        self.point_selector_scratch = selector_scratch;
+        self.input_crossing_map = crossing_lookup;
+        result
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    fn on_the_fly_selector_counts(&self) -> RusticolResult<(usize, usize)> {
+        let NativeExecutionLane::OnTheFly(runtime) = &self.execution_lane else {
+            return Err(RusticolError::internal(
+                "compact selector counts require an on-the-fly execution lane",
+            ));
+        };
+        runtime.public_selector_counts()
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    fn on_the_fly_selected_ordinals(
+        &self,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<OnTheFlySelectedOrdinalsV1> {
+        let NativeExecutionLane::OnTheFly(runtime) = &self.execution_lane else {
+            return Err(RusticolError::internal(
+                "compact selector ordinals require an on-the-fly execution lane",
+            ));
+        };
+        if runtime.uses_contracted_color() {
+            if selected_colors.is_some() {
+                return Err(RusticolError::selector(
+                    "on-the-fly contracted color does not expose color selector ordinals",
+                ));
+            }
+            let (helicity_ordinals, _) = runtime
+                .selectors
+                .selected_ordinals(selected_helicities, None)?;
+            Ok((helicity_ordinals, None))
+        } else {
+            runtime
+                .selectors
+                .selected_ordinals(selected_helicities, selected_colors)
+        }
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    fn run_on_the_fly_f64_batch_into_by_ordinals(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        helicity_ordinals: Option<&[usize]>,
+        color_ordinals: Option<&[usize]>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let NativeExecutionLane::OnTheFly(runtime) = &mut self.execution_lane else {
+            return Err(RusticolError::internal(
+                "compact selector ordinals require an on-the-fly execution lane",
+            ));
+        };
+        runtime.run_total_into_by_ordinals_unprofiled(
+            &self.runtime,
+            batch,
+            helicity_ordinals,
+            color_ordinals,
+            output,
+        )
+    }
+
+    fn run_f64_batch_into(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        match &mut self.execution_lane {
+            NativeExecutionLane::Compiled => self.runtime.run_f64_into_unprofiled(batch, output),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Eager(runtime) => {
+                runtime.run_f64_view_into_unprofiled(&mut self.runtime, batch, output)
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Recurrence(runtime) => {
+                runtime.run_f64_view_into_unprofiled(&mut self.runtime, batch, None, None, output)
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::OnTheFly(runtime) => {
+                runtime.run_total_into_unprofiled(&self.runtime, batch, None, None, output)
+            }
+        }
+    }
+
+    fn run_selected_f64_batch_into(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        match &mut self.execution_lane {
+            NativeExecutionLane::Compiled => self.runtime.run_f64_selected_into_unprofiled(
+                batch,
+                selected_helicities,
+                selected_colors,
+                output,
+            ),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Eager(runtime) => runtime.run_f64_view_selected_into_unprofiled(
+                &mut self.runtime,
+                batch,
+                selected_helicities,
+                selected_colors,
+                output,
+            ),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Recurrence(runtime) => runtime.run_f64_view_into_unprofiled(
+                &mut self.runtime,
+                batch,
+                selected_helicities,
+                selected_colors,
+                output,
+            ),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::OnTheFly(runtime) => runtime.run_total_into_unprofiled(
+                &self.runtime,
+                batch,
+                selected_helicities,
+                selected_colors,
+                output,
+            ),
+        }
+    }
+
+    fn run_resolved_f64_batch(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> Result<ResolvedValues<f64>, RusticolError> {
+        match &mut self.execution_lane {
+            NativeExecutionLane::Compiled => self.runtime.run_resolved_f64_unprofiled(
+                batch,
+                selected_helicities,
+                selected_colors,
+            ),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Eager(runtime) => runtime.run_resolved_f64_view_unprofiled(
+                &mut self.runtime,
+                batch,
+                selected_helicities,
+                selected_colors,
+            ),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Recurrence(runtime) => {
+                let nested = batch.materialize_nested();
+                runtime
+                    .run_resolved_f64(
+                        &mut self.runtime,
+                        &nested,
+                        selected_helicities,
+                        selected_colors,
+                    )
+                    .map(|(resolved, _profile)| resolved)
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::OnTheFly(runtime) => runtime
+                .run_resolved(&self.runtime, batch, selected_helicities, selected_colors)
+                .map(|(resolved, _profile)| resolved),
+        }
+    }
+
+    fn run_selected_f64_batch_profile(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> Result<(Vec<f64>, RuntimeProfile), RusticolError> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if matches!(&self.execution_lane, NativeExecutionLane::Compiled) {
+            let before = compiled_direct_profile_snapshot(&self.runtime)?;
+            if before.engine_count != 0 {
+                let total_start = Instant::now();
+                let mut values = vec![0.0; batch.len()];
+                self.runtime.run_f64_selected_into_unprofiled(
+                    F64MomentumBatchView::from_nested(batch, self.runtime.external_count)?,
+                    selected_helicities,
+                    selected_colors,
+                    &mut values,
+                )?;
+                let total_s = total_start.elapsed().as_secs_f64();
+                let after = compiled_direct_profile_snapshot(&self.runtime)?;
+                let f64_bytes = std::mem::size_of::<f64>() as u64;
+                let complex_bytes = 2 * f64_bytes;
+                let mut profile = RuntimeProfile {
+                    // The direct hot path is deliberately uninstrumented.
+                    // Until its three coarse phase clocks are added, keep
+                    // the complete measured envelope in orchestration so
+                    // top-level accounting remains exact rather than
+                    // manufacturing dense-stage timing fields.
+                    orchestration_s: total_s,
+                    total_s,
+                    source_component_count: after
+                        .source_fill_bytes
+                        .saturating_sub(before.source_fill_bytes)
+                        / complex_bytes,
+                    momentum_component_count: after
+                        .momentum_fill_bytes
+                        .saturating_sub(before.momentum_fill_bytes)
+                        / f64_bytes,
+                    model_parameter_component_count: after
+                        .parameter_fill_bytes
+                        .saturating_sub(before.parameter_fill_bytes)
+                        / complex_bytes,
+                    state_clear_component_count: after
+                        .amplitude_clear_bytes
+                        .saturating_sub(before.amplitude_clear_bytes)
+                        / complex_bytes,
+                    evaluator_backend_call_count: after
+                        .backend_call_count
+                        .saturating_sub(before.backend_call_count),
+                    compiled_direct_arena_engine_count: after.engine_count as u64,
+                    compiled_direct_arena_call_count: after
+                        .backend_call_count
+                        .saturating_sub(before.backend_call_count),
+                    compiled_direct_arena_boundary_input_bytes: after.boundary_input_bytes,
+                    compiled_direct_arena_boundary_current_output_bytes: after
+                        .boundary_current_output_bytes,
+                    compiled_direct_arena_boundary_amplitude_output_bytes: after
+                        .boundary_amplitude_output_bytes,
+                    compiled_direct_arena_internal_broadcast_bytes: after
+                        .scalar_broadcast_fill_bytes
+                        .saturating_sub(before.scalar_broadcast_fill_bytes),
+                    total_materialized_value_count: batch.len() as u64,
+                    ..RuntimeProfile::default()
+                };
+                attach_compiled_direct_configuration(&mut profile, after);
+                return Ok((values, profile));
+            }
+        }
+        match &mut self.execution_lane {
+            NativeExecutionLane::Compiled => {
+                self.runtime
+                    .run_f64_selected_totals(batch, selected_helicities, selected_colors)
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Eager(runtime) => {
+                let (resolved, mut profile) = runtime.run_resolved_f64_profile(
+                    &mut self.runtime,
+                    batch,
+                    selected_helicities,
+                    selected_colors,
+                )?;
+                let materialization_start = Instant::now();
+                let values = resolved_f64_totals(&resolved)?;
+                profile.total_materialization_s += materialization_start.elapsed().as_secs_f64();
+                profile.total_materialized_value_count += values.len() as u64;
+                Ok((values, profile))
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Recurrence(runtime) => {
+                let (resolved, mut profile) = runtime.run_resolved_f64(
+                    &mut self.runtime,
+                    batch,
+                    selected_helicities,
+                    selected_colors,
+                )?;
+                let materialization_start = Instant::now();
+                let values = resolved_f64_totals(&resolved)?;
+                profile.total_materialization_s += materialization_start.elapsed().as_secs_f64();
+                profile.total_materialized_value_count += values.len() as u64;
+                Ok((values, profile))
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::OnTheFly(runtime) => {
+                let view = F64MomentumBatchView::from_nested(batch, self.runtime.external_count)?;
+                let mut values = vec![0.0; batch.len()];
+                let mut profile = runtime.run_total_into(
+                    &self.runtime,
+                    view,
+                    selected_helicities,
+                    selected_colors,
+                    &mut values,
+                )?;
+                profile.total_materialized_value_count += values.len() as u64;
+                Ok((values, profile))
+            }
+        }
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    fn run_on_the_fly_f64_batch_profile_by_ordinals(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+        helicity_ordinals: Option<&[usize]>,
+        color_ordinals: Option<&[usize]>,
+    ) -> Result<(Vec<f64>, RuntimeProfile), RusticolError> {
+        let view = F64MomentumBatchView::from_nested(batch, self.runtime.external_count)?;
+        let mut values = vec![0.0; batch.len()];
+        let NativeExecutionLane::OnTheFly(runtime) = &mut self.execution_lane else {
+            return Err(RusticolError::internal(
+                "compact selector ordinals require an on-the-fly execution lane",
+            ));
+        };
+        let mut profile = runtime.run_total_into_by_ordinals(
+            &self.runtime,
+            view,
+            helicity_ordinals,
+            color_ordinals,
+            &mut values,
+        )?;
+        profile.total_materialized_value_count += values.len() as u64;
+        Ok((values, profile))
+    }
+
+    pub fn benchmark_f64_wall_time(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        repetitions: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> Result<f64, RusticolError> {
+        self.benchmark_f64_wall_time_with_selectors(
+            momenta,
+            point_count,
+            repetitions,
+            helicity_ids,
+            color_ids,
+            None,
+            None,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn benchmark_f64_wall_time_with_selectors(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        repetitions: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+        helicity_by_point: Option<&[u32]>,
+        color_by_point: Option<&[u32]>,
+    ) -> Result<f64, RusticolError> {
+        if repetitions == 0 {
+            return Err(RusticolError::invalid_argument(
+                "benchmark repetitions must be positive",
+            ));
+        }
+        validate_flat_momentum_shape(momenta.len(), point_count, self.runtime.external_count)?;
+        let mut output = vec![0.0; point_count];
+        let started = Instant::now();
+        for _ in 0..repetitions {
+            self.evaluate_f64_into_with_selectors(
+                momenta,
+                point_count,
+                helicity_ids,
+                color_ids,
+                helicity_by_point,
+                color_by_point,
+                &mut output,
+            )?;
+            std::hint::black_box(&output);
+        }
+        Ok(started.elapsed().as_secs_f64())
+    }
+
+    /// Profile the warmed Direct-Arena timing boundary used by
+    /// [`Self::benchmark_f64_wall_time`] for batch-global selectors.
+    ///
+    /// The borrowed flat input and the caller-sized output are prepared once
+    /// outside the repeated region. Every measured repetition then uses the
+    /// allocation-free `evaluate_f64_into_with_selectors` path. This is kept
+    /// separate from the public diagnostic profiler below, whose materialized
+    /// input and owned result remain useful when inspecting legacy lanes.
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    pub fn evaluate_f64_arena_profile_repeated(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        repetitions: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> Result<NativeProfiledEvaluation, RusticolError> {
+        if repetitions == 0 {
+            return Err(RusticolError::invalid_argument(
+                "arena profile repetitions must be positive",
+            ));
+        }
+        validate_flat_momentum_shape(momenta.len(), point_count, self.runtime.external_count)?;
+        let compiled_lane = match &self.execution_lane {
+            NativeExecutionLane::Compiled => {
+                let snapshot = compiled_direct_profile_snapshot(&self.runtime)?;
+                if snapshot.engine_count == 0 {
+                    return Err(RusticolError::compatibility(
+                        "warmed Arena profiling requires a compiled Direct-Arena artifact",
+                    ));
+                }
+                true
+            }
+            NativeExecutionLane::Eager(_) => false,
+            NativeExecutionLane::Recurrence(_) => {
+                return Err(RusticolError::compatibility(
+                    "warmed Arena profiling is available only for eager and compiled execution",
+                ));
+            }
+            NativeExecutionLane::OnTheFly(_) => false,
+        };
+        let measured_points = point_count.checked_mul(repetitions).ok_or_else(|| {
+            RusticolError::invalid_argument("arena profile point count overflowed")
+        })?;
+        let measured_input_components =
+            momenta.len().checked_mul(repetitions).ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "arena profile native input component count overflowed",
+                )
+            })?;
+        let measured_points_u64 = u64::try_from(measured_points).map_err(|_| {
+            RusticolError::invalid_argument("arena profile point count does not fit in u64")
+        })?;
+        let measured_input_components_u64 =
+            u64::try_from(measured_input_components).map_err(|_| {
+                RusticolError::invalid_argument(
+                    "arena profile native input component count does not fit in u64",
+                )
+            })?;
+        let repetitions_u64 = u64::try_from(repetitions).map_err(|_| {
+            RusticolError::invalid_argument("arena profile repetition count does not fit in u64")
+        })?;
+
+        // The result allocation is deliberately outside the measured repeated
+        // boundary, matching the native headline timer. Prime the exact
+        // selector and workspace route once before the counter snapshot so the
+        // measured region is independently warmed even when this private
+        // operation is called directly.
+        let mut values = vec![0.0; point_count];
+        self.evaluate_f64_into_with_selectors(
+            momenta,
+            point_count,
+            helicity_ids,
+            color_ids,
+            None,
+            None,
+            &mut values,
+        )?;
+        let compiled_before = if compiled_lane {
+            Some(compiled_direct_profile_snapshot(&self.runtime)?)
+        } else {
+            None
+        };
+        let started = Instant::now();
+        for _ in 0..repetitions {
+            std::hint::black_box(&mut values);
+            self.evaluate_f64_into_with_selectors(
+                momenta,
+                point_count,
+                helicity_ids,
+                color_ids,
+                None,
+                None,
+                &mut values,
+            )?;
+            std::hint::black_box(&values);
+        }
+        let total_s = started.elapsed().as_secs_f64();
+        let mut runtime_profile = RuntimeProfile {
+            // The warmed Direct-Arena boundary is deliberately free of phase
+            // clocks. Keep its complete measured envelope in orchestration.
+            // Callers must treat leaf-evaluator phase timing as unavailable,
+            // rather than interpreting the zero-valued phase fields as
+            // measurements below clock resolution.
+            orchestration_s: total_s,
+            total_s,
+            total_materialized_value_count: measured_points_u64,
+            ..RuntimeProfile::default()
+        };
+        if let Some(before) = compiled_before {
+            let after = compiled_direct_profile_snapshot(&self.runtime)?;
+            let f64_bytes = std::mem::size_of::<f64>() as u64;
+            let complex_bytes = 2 * f64_bytes;
+            runtime_profile.source_component_count = after
+                .source_fill_bytes
+                .saturating_sub(before.source_fill_bytes)
+                / complex_bytes;
+            runtime_profile.momentum_component_count = after
+                .momentum_fill_bytes
+                .saturating_sub(before.momentum_fill_bytes)
+                / f64_bytes;
+            runtime_profile.model_parameter_component_count = after
+                .parameter_fill_bytes
+                .saturating_sub(before.parameter_fill_bytes)
+                / complex_bytes;
+            runtime_profile.state_clear_component_count = after
+                .amplitude_clear_bytes
+                .saturating_sub(before.amplitude_clear_bytes)
+                / complex_bytes;
+            runtime_profile.evaluator_backend_call_count = after
+                .backend_call_count
+                .saturating_sub(before.backend_call_count);
+            runtime_profile.compiled_direct_arena_engine_count = u64::try_from(before.engine_count)
+                .ok()
+                .and_then(|count| count.checked_mul(repetitions_u64))
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument("compiled Direct-Arena engine count overflowed")
+                })?;
+            runtime_profile.compiled_direct_arena_call_count =
+                runtime_profile.evaluator_backend_call_count;
+            runtime_profile.compiled_direct_arena_boundary_input_bytes = after
+                .boundary_input_bytes
+                .saturating_sub(before.boundary_input_bytes);
+            runtime_profile.compiled_direct_arena_boundary_current_output_bytes = after
+                .boundary_current_output_bytes
+                .saturating_sub(before.boundary_current_output_bytes);
+            runtime_profile.compiled_direct_arena_boundary_amplitude_output_bytes = after
+                .boundary_amplitude_output_bytes
+                .saturating_sub(before.boundary_amplitude_output_bytes);
+            runtime_profile.compiled_direct_arena_internal_broadcast_bytes = after
+                .scalar_broadcast_fill_bytes
+                .saturating_sub(before.scalar_broadcast_fill_bytes);
+            attach_compiled_direct_configuration(&mut runtime_profile, after);
+        }
+        runtime_profile.validate_recurrence_direct_boundary_traffic()?;
+        let mut profile: NativeRuntimeProfile = runtime_profile.into();
+        profile.native_input_component_count = measured_input_components_u64;
+        profile.native_input_pack_bytes = 0;
+        profile.native_input_crossing_bytes = 0;
+        profile.native_input_container_allocation_count = 0;
+        profile.native_output_allocation_count = 0;
+        self.validate_profile_accounting(&profile)?;
+        Ok(NativeProfiledEvaluation { values, profile })
+    }
+
+    #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+    pub fn evaluate_f64_arena_profile_repeated(
+        &mut self,
+        _momenta: &[f64],
+        _point_count: usize,
+        _repetitions: usize,
+        _helicity_ids: Option<&[String]>,
+        _color_ids: Option<&[String]>,
+    ) -> Result<NativeProfiledEvaluation, RusticolError> {
+        Err(RusticolError::compatibility(
+            "warmed Arena profiling requires the f64-compiled or f64-symjit feature",
+        ))
+    }
+
+    pub fn evaluate_f64_profile(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> Result<NativeProfiledEvaluation, RusticolError> {
+        let color_ids = self.execution_color_ids(color_ids);
+        let mut evaluation = self.evaluate_representative_f64_profile(
+            momenta,
+            point_count,
+            helicity_ids,
+            color_ids.as_deref(),
+        )?;
+        self.apply_process_group_factor(&mut evaluation.values);
+        Ok(evaluation)
+    }
+
+    fn evaluate_representative_f64_profile(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> Result<NativeProfiledEvaluation, RusticolError> {
+        let total_start = Instant::now();
+        let (batch, native_input_pack_elapsed, native_input_crossing_elapsed) =
+            self.prepare_f64_batch_profile(momenta, point_count)?;
+        let compiled_direct_profile = {
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            {
+                matches!(&self.execution_lane, NativeExecutionLane::Compiled)
+                    && compiled_direct_profile_snapshot(&self.runtime)?.engine_count != 0
+            }
+            #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+            {
+                false
+            }
+        };
+        let (values, profile) = if compiled_direct_profile {
+            if helicity_ids.is_some() || color_ids.is_some() {
+                self.validate_selector_capabilities(helicity_ids.is_some(), color_ids.is_some())?;
+                self.record_resolved_warnings(helicity_ids, color_ids)?;
+            }
+            let selected_helicities = selector_set(helicity_ids, "helicity")?;
+            let selected_colors = selector_set(color_ids, "color component")?;
+            self.run_selected_f64_batch_profile(
+                &batch,
+                selected_helicities.as_ref(),
+                selected_colors.as_ref(),
+            )?
+        } else if helicity_ids.is_some() || color_ids.is_some() {
+            self.validate_selector_capabilities(helicity_ids.is_some(), color_ids.is_some())?;
+            self.record_resolved_warnings(helicity_ids, color_ids)?;
+            let selected_helicities = selector_set(helicity_ids, "helicity")?;
+            let selected_colors = selector_set(color_ids, "color component")?;
+            let (values, profile) = match &mut self.execution_lane {
+                NativeExecutionLane::Compiled => self.runtime.run_f64_selected_totals(
+                    &batch,
+                    selected_helicities.as_ref(),
+                    selected_colors.as_ref(),
+                )?,
+                #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                NativeExecutionLane::Eager(runtime) => {
+                    let (resolved, mut profile) = runtime.run_resolved_f64_profile(
+                        &mut self.runtime,
+                        &batch,
+                        selected_helicities.as_ref(),
+                        selected_colors.as_ref(),
+                    )?;
+                    let materialization_start = Instant::now();
+                    let values = resolved_f64_totals(&resolved)?;
+                    profile.total_materialization_s +=
+                        materialization_start.elapsed().as_secs_f64();
+                    profile.total_materialized_value_count += point_count as u64;
+                    (values, profile)
+                }
+                #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                NativeExecutionLane::Recurrence(runtime) => {
+                    let (resolved, mut profile) = runtime.run_resolved_f64(
+                        &mut self.runtime,
+                        &batch,
+                        selected_helicities.as_ref(),
+                        selected_colors.as_ref(),
+                    )?;
+                    let materialization_start = Instant::now();
+                    let values = resolved_f64_totals(&resolved)?;
+                    profile.total_materialization_s +=
+                        materialization_start.elapsed().as_secs_f64();
+                    profile.total_materialized_value_count += point_count as u64;
+                    (values, profile)
+                }
+                #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                NativeExecutionLane::OnTheFly(runtime) => {
+                    let view =
+                        F64MomentumBatchView::from_nested(&batch, self.runtime.external_count)?;
+                    let mut values = vec![0.0; point_count];
+                    let mut profile = runtime.run_total_into(
+                        &self.runtime,
+                        view,
+                        selected_helicities.as_ref(),
+                        selected_colors.as_ref(),
+                        &mut values,
+                    )?;
+                    profile.total_materialized_value_count += point_count as u64;
+                    (values, profile)
+                }
+            };
+            (values, profile)
+        } else {
+            match &mut self.execution_lane {
+                NativeExecutionLane::Compiled => self.runtime.run_f64(&batch)?,
+                #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                NativeExecutionLane::Eager(runtime) => {
+                    runtime.run_f64_profile(&mut self.runtime, &batch)?
+                }
+                #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                NativeExecutionLane::Recurrence(runtime) => {
+                    runtime.run_f64(&mut self.runtime, &batch)?
+                }
+                #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                NativeExecutionLane::OnTheFly(runtime) => {
+                    let view =
+                        F64MomentumBatchView::from_nested(&batch, self.runtime.external_count)?;
+                    let mut values = vec![0.0; point_count];
+                    let profile =
+                        runtime.run_total_into(&self.runtime, view, None, None, &mut values)?;
+                    (values, profile)
+                }
+            }
+        };
+        profile.validate_recurrence_direct_boundary_traffic()?;
+        let mut profile: NativeRuntimeProfile = profile.into();
+        profile.native_input_pack_s = profile_duration_seconds(native_input_pack_elapsed);
+        profile.native_input_crossing_s = profile_duration_seconds(native_input_crossing_elapsed);
+        profile.native_input_component_count = momenta.len() as u64;
+        profile.native_input_pack_bytes = std::mem::size_of_val(momenta) as u64;
+        if self.input_crossing_map.is_some() {
+            profile.native_input_crossing_bytes = profile.native_input_pack_bytes;
+        }
+        profile.native_input_container_allocation_count =
+            (point_count + 1 + usize::from(self.input_crossing_map.is_some()) * (point_count + 2))
+                as u64;
+        profile.native_output_allocation_count = 1;
+        profile.total_s = total_start.elapsed().as_secs_f64();
+        self.validate_profile_accounting(&profile)?;
+        Ok(NativeProfiledEvaluation { values, profile })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn evaluate_f64_profile_with_selectors(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+        helicity_by_point: Option<&[u32]>,
+        color_by_point: Option<&[u32]>,
+    ) -> Result<NativeProfiledEvaluation, RusticolError> {
+        let color_ids = self.execution_color_ids(color_ids);
+        let mut evaluation = self.evaluate_representative_f64_profile_with_selectors(
+            momenta,
+            point_count,
+            helicity_ids,
+            color_ids.as_deref(),
+            helicity_by_point,
+            color_by_point,
+        )?;
+        self.apply_process_group_factor(&mut evaluation.values);
+        Ok(evaluation)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn evaluate_representative_f64_profile_with_selectors(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+        helicity_by_point: Option<&[u32]>,
+        color_by_point: Option<&[u32]>,
+    ) -> Result<NativeProfiledEvaluation, RusticolError> {
+        if helicity_by_point.is_none() && color_by_point.is_none() {
+            return self.evaluate_representative_f64_profile(
+                momenta,
+                point_count,
+                helicity_ids,
+                color_ids,
+            );
+        }
+        if helicity_ids.is_some() && helicity_by_point.is_some() {
+            return Err(RusticolError::selector(
+                "helicities and helicity_by_point are mutually exclusive",
+            ));
+        }
+        if color_ids.is_some() && color_by_point.is_some() {
+            return Err(RusticolError::selector(
+                "color_flows and color_flow_by_point are mutually exclusive",
+            ));
+        }
+        self.validate_selector_capabilities(
+            helicity_ids.is_some() || helicity_by_point.is_some(),
+            color_ids.is_some() || color_by_point.is_some(),
+        )?;
+        let total_start = Instant::now();
+        let selected_helicities = selector_set(helicity_ids, "helicity")?;
+        let selected_colors = selector_set(color_ids, "color component")?;
+        let (batch, native_input_pack_elapsed, native_input_crossing_elapsed) =
+            self.prepare_f64_batch_profile(momenta, point_count)?;
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        let on_the_fly = matches!(&self.execution_lane, NativeExecutionLane::OnTheFly(_));
+        #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+        let on_the_fly = false;
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        let on_the_fly_selected_ordinals = if on_the_fly {
+            Some(self.on_the_fly_selected_ordinals(
+                selected_helicities.as_ref(),
+                selected_colors.as_ref(),
+            )?)
+        } else {
+            None
+        };
+        let physics = if on_the_fly {
+            None
+        } else {
+            Some(self.runtime.physics.clone().ok_or_else(|| {
+                RusticolError::artifact(
+                    "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+                )
+            })?)
+        };
+        let (helicity_count, color_count) = if on_the_fly {
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            {
+                self.on_the_fly_selector_counts()?
+            }
+            #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+            {
+                unreachable!("on-the-fly lane requires an f64 evaluator feature")
+            }
+        } else {
+            let physics = physics
+                .as_ref()
+                .expect("non-on-the-fly profile has physics metadata");
+            (
+                physics.manifest.helicities.len(),
+                physics.manifest.color_components.len(),
+            )
+        };
+        let selector_simd_lane_width = self.selector_simd_lane_width();
+        let mut selector_scratch = std::mem::take(&mut self.point_selector_scratch);
+        let result = (|| {
+            let planner_started = Instant::now();
+            let plan = selector_scratch.planner.build(
+                point_count,
+                helicity_by_point,
+                color_by_point,
+                helicity_count,
+                color_count,
+            )?;
+            let plan_profile =
+                selector_scratch
+                    .planner
+                    .profile(plan, point_count, selector_simd_lane_width);
+            let planner = planner_started.elapsed();
+            self.record_resolved_warnings(helicity_ids, color_ids)?;
+
+            if let PointSelectorPlan::Homogeneous(key) = plan {
+                let (values, runtime_profile) = if on_the_fly {
+                    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                    {
+                        let (selected_helicities, selected_colors) = on_the_fly_selected_ordinals
+                            .as_ref()
+                            .expect("on-the-fly selected ordinals are absent");
+                        let point_helicity = key.helicity_index.map(|index| [index]);
+                        let point_color = key.color_index.map(|index| [index]);
+                        self.run_on_the_fly_f64_batch_profile_by_ordinals(
+                            &batch,
+                            point_helicity
+                                .as_ref()
+                                .map(<[usize; 1]>::as_slice)
+                                .or(selected_helicities.as_deref()),
+                            point_color
+                                .as_ref()
+                                .map(<[usize; 1]>::as_slice)
+                                .or(selected_colors.as_deref()),
+                        )?
+                    }
+                    #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+                    {
+                        unreachable!("on-the-fly lane requires an f64 evaluator feature")
+                    }
+                } else {
+                    let physics = physics
+                        .as_ref()
+                        .expect("non-on-the-fly profile has physics metadata");
+                    let point_helicities = key.helicity_index.map(|index| {
+                        BTreeSet::from([physics.manifest.helicities[index].id.clone()])
+                    });
+                    let point_colors = key.color_index.map(|index| {
+                        BTreeSet::from([physics.manifest.color_components[index].id().to_string()])
+                    });
+                    let effective_helicities =
+                        point_helicities.as_ref().or(selected_helicities.as_ref());
+                    let effective_colors = point_colors.as_ref().or(selected_colors.as_ref());
+                    self.run_selected_f64_batch_profile(
+                        &batch,
+                        effective_helicities,
+                        effective_colors,
+                    )?
+                };
+                runtime_profile.validate_recurrence_direct_boundary_traffic()?;
+                let mut profile: NativeRuntimeProfile = runtime_profile.into();
+                attach_point_selector_profile(
+                    &mut profile,
+                    &plan_profile,
+                    planner,
+                    Duration::ZERO,
+                    Duration::ZERO,
+                    PointSelectorProfileCounts {
+                        gather_point_count: 0,
+                        input_bytes_per_point: self.runtime.external_count
+                            * 4
+                            * std::mem::size_of::<f64>(),
+                        scatter_value_count: 0,
+                    },
+                );
+                profile.native_input_pack_s = profile_duration_seconds(native_input_pack_elapsed);
+                profile.native_input_crossing_s =
+                    profile_duration_seconds(native_input_crossing_elapsed);
+                profile.native_input_component_count = momenta.len() as u64;
+                profile.native_input_pack_bytes = std::mem::size_of_val(momenta) as u64;
+                if self.input_crossing_map.is_some() {
+                    profile.native_input_crossing_bytes = profile.native_input_pack_bytes;
+                }
+                profile.native_input_container_allocation_count = (point_count
+                    + 1
+                    + usize::from(self.input_crossing_map.is_some()) * (point_count + 2))
+                    as u64;
+                profile.native_output_allocation_count = 1;
+                profile.total_s = total_start.elapsed().as_secs_f64();
+                self.validate_profile_accounting(&profile)?;
+                return Ok(NativeProfiledEvaluation { values, profile });
+            }
+
+            let mut values = vec![0.0; point_count];
+            let mut partition_profiles = Vec::new();
+            let mut gather = Duration::ZERO;
+            let mut scatter = Duration::ZERO;
+            let mut gather_point_count = 0usize;
+            let partition_count = selector_scratch.planner.partitions().len();
+            for partition_index in 0..partition_count {
+                let partition = selector_scratch.planner.partitions()[partition_index];
+                let (partition_totals, partition_profile) = if on_the_fly {
+                    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+                    {
+                        let (selected_helicities, selected_colors) = on_the_fly_selected_ordinals
+                            .as_ref()
+                            .expect("on-the-fly selected ordinals are absent");
+                        let point_helicity = partition.key.helicity_index.map(|index| [index]);
+                        let point_color = partition.key.color_index.map(|index| [index]);
+                        let effective_helicities = point_helicity
+                            .as_ref()
+                            .map(<[usize; 1]>::as_slice)
+                            .or(selected_helicities.as_deref());
+                        let effective_colors = point_color
+                            .as_ref()
+                            .map(<[usize; 1]>::as_slice)
+                            .or(selected_colors.as_deref());
+                        match partition.rows {
+                            PointSelectorRows::Contiguous { start, end } => self
+                                .run_on_the_fly_f64_batch_profile_by_ordinals(
+                                    &batch[start..end],
+                                    effective_helicities,
+                                    effective_colors,
+                                )?,
+                            rows @ PointSelectorRows::Gathered { .. } => {
+                                let gather_started = Instant::now();
+                                let point_indices = selector_scratch.planner.gathered_rows(rows);
+                                gather_point_count += point_indices.len();
+                                let gathered_batch = fill_gathered_batch(
+                                    &mut selector_scratch.gathered_batch,
+                                    &batch,
+                                    point_indices,
+                                );
+                                gather += gather_started.elapsed();
+                                self.run_on_the_fly_f64_batch_profile_by_ordinals(
+                                    gathered_batch,
+                                    effective_helicities,
+                                    effective_colors,
+                                )?
+                            }
+                        }
+                    }
+                    #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+                    {
+                        unreachable!("on-the-fly lane requires an f64 evaluator feature")
+                    }
+                } else {
+                    let physics = physics
+                        .as_ref()
+                        .expect("non-on-the-fly profile has physics metadata");
+                    let point_helicities = partition.key.helicity_index.map(|index| {
+                        BTreeSet::from([physics.manifest.helicities[index].id.clone()])
+                    });
+                    let point_colors = partition.key.color_index.map(|index| {
+                        BTreeSet::from([physics.manifest.color_components[index].id().to_string()])
+                    });
+                    let effective_helicities =
+                        point_helicities.as_ref().or(selected_helicities.as_ref());
+                    let effective_colors = point_colors.as_ref().or(selected_colors.as_ref());
+                    match partition.rows {
+                        PointSelectorRows::Contiguous { start, end } => self
+                            .run_selected_f64_batch_profile(
+                                &batch[start..end],
+                                effective_helicities,
+                                effective_colors,
+                            )?,
+                        rows @ PointSelectorRows::Gathered { .. } => {
+                            let gather_started = Instant::now();
+                            let point_indices = selector_scratch.planner.gathered_rows(rows);
+                            gather_point_count += point_indices.len();
+                            let gathered_batch = fill_gathered_batch(
+                                &mut selector_scratch.gathered_batch,
+                                &batch,
+                                point_indices,
+                            );
+                            gather += gather_started.elapsed();
+                            self.run_selected_f64_batch_profile(
+                                gathered_batch,
+                                effective_helicities,
+                                effective_colors,
+                            )?
+                        }
+                    }
+                };
+                if partition_totals.len() != partition.rows.len() {
+                    return Err(RusticolError::integrity(
+                        "per-point selector partition returned the wrong number of values",
+                    ));
+                }
+                let scatter_started = Instant::now();
+                scatter_partition_totals(
+                    &mut values,
+                    &partition_totals,
+                    partition.rows,
+                    &selector_scratch.planner,
+                );
+                scatter += scatter_started.elapsed();
+                partition_profiles.push(partition_profile);
+            }
+            let mut runtime_profile = RuntimeProfile::default();
+            for partition_profile in &partition_profiles {
+                runtime_profile.add_sector(partition_profile);
+            }
+            runtime_profile.validate_recurrence_direct_boundary_traffic()?;
+            let mut profile: NativeRuntimeProfile = runtime_profile.into();
+            attach_point_selector_profile(
+                &mut profile,
+                &plan_profile,
+                planner,
+                gather,
+                scatter,
+                PointSelectorProfileCounts {
+                    gather_point_count,
+                    input_bytes_per_point: self.runtime.external_count
+                        * 4
+                        * std::mem::size_of::<f64>(),
+                    scatter_value_count: point_count,
+                },
+            );
+            profile.native_input_pack_s = profile_duration_seconds(native_input_pack_elapsed);
+            profile.native_input_crossing_s =
+                profile_duration_seconds(native_input_crossing_elapsed);
+            profile.native_input_component_count = momenta.len() as u64;
+            profile.native_input_pack_bytes = std::mem::size_of_val(momenta) as u64;
+            if self.input_crossing_map.is_some() {
+                profile.native_input_crossing_bytes = profile.native_input_pack_bytes;
+            }
+            profile.native_input_container_allocation_count = (point_count
+                + 1
+                + usize::from(self.input_crossing_map.is_some()) * (point_count + 2))
+                as u64;
+            profile.native_output_allocation_count = 1;
+            profile.total_s = total_start.elapsed().as_secs_f64();
+            self.validate_profile_accounting(&profile)?;
+            Ok(NativeProfiledEvaluation { values, profile })
+        })();
+        self.point_selector_scratch = selector_scratch;
+        result
+    }
+
+    pub fn evaluate_f64_profile_repeated(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        repetitions: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> Result<NativeProfiledEvaluation, RusticolError> {
+        self.evaluate_f64_profile_repeated_with_selectors(
+            momenta,
+            point_count,
+            repetitions,
+            helicity_ids,
+            color_ids,
+            None,
+            None,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn evaluate_f64_profile_repeated_with_selectors(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        repetitions: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+        helicity_by_point: Option<&[u32]>,
+        color_by_point: Option<&[u32]>,
+    ) -> Result<NativeProfiledEvaluation, RusticolError> {
+        if repetitions == 0 {
+            return Err(RusticolError::invalid_argument(
+                "profile repetitions must be positive",
+            ));
+        }
+        let started = Instant::now();
+        let mut profile: Option<Box<NativeRuntimeProfile>> = None;
+        let mut values = Vec::new();
+        for _ in 0..repetitions {
+            // The saved evaluator payload may use the complete AArch64
+            // floating-point register file. Keep the aggregate behind an
+            // opaque heap boundary so no accumulated f64 survives the next
+            // generated call in a register.
+            std::hint::black_box(&mut profile);
+            let profiled = self.evaluate_f64_profile_with_selectors(
+                momenta,
+                point_count,
+                helicity_ids,
+                color_ids,
+                helicity_by_point,
+                color_by_point,
+            )?;
+            std::hint::black_box(&profiled.values);
+            values = profiled.values;
+            if let Some(aggregate) = profile.as_deref_mut() {
+                aggregate.accumulate(&profiled.profile);
+            } else {
+                profile = Some(Box::new(profiled.profile));
+            }
+        }
+        let mut profile = *profile.expect("positive repetitions checked");
+        profile.total_s = started.elapsed().as_secs_f64();
+        self.validate_profile_accounting(&profile)?;
+        Ok(NativeProfiledEvaluation { values, profile })
+    }
+
+    fn validate_profile_accounting(&self, profile: &NativeRuntimeProfile) -> RusticolResult<()> {
+        match &self.execution_lane {
+            NativeExecutionLane::Compiled => profile.validate_compiled_top_level_accounting(),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Eager(_) => profile.validate_eager_top_level_accounting(),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::Recurrence(_) => {
+                profile.validate_recurrence_top_level_accounting()
+            }
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            NativeExecutionLane::OnTheFly(_) => profile.validate_recurrence_top_level_accounting(),
+        }
+    }
+
+    pub fn evaluate_resolved_f64(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> Result<NativeResolvedEvaluation, RusticolError> {
+        let color_ids = self.execution_color_ids(color_ids);
+        let mut resolved = self.evaluate_representative_resolved_f64(
+            momenta,
+            point_count,
+            helicity_ids,
+            color_ids.as_deref(),
+        )?;
+        self.apply_process_group_factor(&mut resolved.values);
+        self.publish_color_ids(&mut resolved.color_ids);
+        Ok(resolved)
+    }
+
+    fn evaluate_representative_resolved_f64(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> Result<NativeResolvedEvaluation, RusticolError> {
+        self.validate_selector_capabilities(helicity_ids.is_some(), color_ids.is_some())?;
+        self.record_resolved_warnings(helicity_ids, color_ids)?;
+        validate_flat_momentum_shape(momenta.len(), point_count, self.runtime.external_count)?;
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if let NativeExecutionLane::OnTheFly(runtime) = &mut self.execution_lane {
+            let selected_helicities = selector_set(helicity_ids, "helicity")?;
+            let selected_colors = selector_set(color_ids, "color component")?;
+            let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                momenta,
+                point_count,
+                self.runtime.external_count,
+                self.input_crossing_map.as_deref(),
+            )?;
+            let (resolved, _profile) = runtime.run_resolved(
+                &self.runtime,
+                batch,
+                selected_helicities.as_ref(),
+                selected_colors.as_ref(),
+            )?;
+            let (helicity_ids, color_ids) = runtime.selected_axis_ids()?;
+            return Ok(NativeResolvedEvaluation {
+                values: resolved.values,
+                point_count: resolved.point_count,
+                helicity_ids,
+                color_ids,
+            });
+        }
+        let physics = self.runtime.physics.clone().ok_or_else(|| {
+            RusticolError::artifact(
+                "schema-v3 artifact is missing resolved physics metadata; regenerate it with pyAmpliCol 0.1.0 or newer",
+            )
+        })?;
+        let crossing_lookup = std::mem::take(&mut self.input_crossing_map);
+        let mut selector_scratch = std::mem::take(&mut self.point_selector_scratch);
+        let result = (|| {
+            physics.validate_helicity_id_slice(helicity_ids)?;
+            physics.validate_color_id_slice(color_ids)?;
+            let selected_helicities = selector_scratch
+                .helicity_selector_sets
+                .resolve(helicity_ids, "helicity")?;
+            let selected_colors = selector_scratch
+                .color_selector_sets
+                .resolve(color_ids, "color component")?;
+            let batch = F64MomentumBatchView::from_contiguous_prevalidated(
+                momenta,
+                point_count,
+                self.runtime.external_count,
+                crossing_lookup.as_deref(),
+            )?;
+            self.run_resolved_f64_batch(batch, selected_helicities, selected_colors)
+        })();
+        self.point_selector_scratch = selector_scratch;
+        self.input_crossing_map = crossing_lookup;
+        let resolved = result?;
+        let helicity_ids = resolved
+            .helicity_indices
+            .iter()
+            .map(|index| physics.manifest.helicities[*index].id.clone())
+            .collect();
+        let color_ids = resolved
+            .color_indices
+            .iter()
+            .map(|index| physics.manifest.color_components[*index].id().to_string())
+            .collect();
+        Ok(NativeResolvedEvaluation {
+            values: resolved.values,
+            point_count: resolved.point_count,
+            helicity_ids,
+            color_ids,
+        })
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub fn evaluate_with_precision(
+        &mut self,
+        momenta: &[String],
+        point_count: usize,
+        decimal_digits: u32,
+    ) -> Result<NativeDecimalEvaluation, RusticolError> {
+        if decimal_digits == 0 {
+            return Err(RusticolError::unsupported_precision(
+                "precision must be a positive number of decimal digits",
+            ));
+        }
+        if decimal_digits == 16 {
+            let values = momenta
+                .iter()
+                .map(|value| {
+                    value.parse::<f64>().map_err(|error| {
+                        RusticolError::invalid_argument(format!(
+                            "could not parse f64 momentum component {value:?}: {error}"
+                        ))
+                    })
+                })
+                .collect::<Result<Vec<_>, _>>()?;
+            let values = self.evaluate_f64(&values, point_count)?;
+            return Ok(NativeDecimalEvaluation {
+                values: format_decimal_values(values, decimal_digits),
+                decimal_digits,
+            });
+        }
+        if self.execution_lane.is_eager() {
+            return Err(eager_parity_pending("higher-precision evaluation"));
+        }
+        if self.execution_lane.is_recurrence() {
+            return Err(recurrence_parity_pending("higher-precision evaluation"));
+        }
+        if decimal_digits == 32 {
+            let batch = self.prepare_double_batch(momenta, point_count)?;
+            let (mut values, _profile) = self.runtime.run_double(&batch)?;
+            self.apply_process_group_factor_high_precision(&mut values);
+            return Ok(NativeDecimalEvaluation {
+                values: format_decimal_values(values, decimal_digits),
+                decimal_digits,
+            });
+        }
+        let binary_precision = decimal_digits_to_bits(decimal_digits);
+        let batch = self.prepare_float_batch(momenta, point_count, binary_precision)?;
+        let (mut values, _profile) = self.runtime.run_float(&batch, binary_precision)?;
+        self.apply_process_group_factor_high_precision(&mut values);
+        Ok(NativeDecimalEvaluation {
+            values: format_decimal_values(values, decimal_digits),
+            decimal_digits,
+        })
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    fn apply_process_group_factor_high_precision<T>(&self, values: &mut [T])
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let NativeRationalFactor {
+            numerator,
+            denominator,
+        } = self.process_group_factor();
+        if numerator != denominator {
+            let numerator = T::from(numerator as f64);
+            let denominator = T::from(denominator as f64);
+            for value in values {
+                *value = value.clone() * numerator.clone() / denominator.clone();
+            }
+        }
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub fn evaluate_resolved_with_precision(
+        &mut self,
+        momenta: &[String],
+        point_count: usize,
+        decimal_digits: u32,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> Result<NativeDecimalResolvedEvaluation, RusticolError> {
+        if decimal_digits == 0 {
+            return Err(RusticolError::unsupported_precision(
+                "precision must be a positive number of decimal digits",
+            ));
+        }
+        let color_ids = self.execution_color_ids(color_ids);
+        let color_ids = color_ids.as_deref();
+        self.validate_selector_capabilities(helicity_ids.is_some(), color_ids.is_some())?;
+        if self.execution_lane.is_eager() {
+            return Err(eager_parity_pending("resolved higher-precision evaluation"));
+        }
+        if self.execution_lane.is_recurrence() {
+            return Err(recurrence_parity_pending(
+                "resolved higher-precision evaluation",
+            ));
+        }
+        self.record_resolved_warnings(helicity_ids, color_ids)?;
+        let selected_helicities = selector_set(helicity_ids, "helicity")?;
+        let selected_colors = selector_set(color_ids, "color component")?;
+        if decimal_digits == 16 {
+            let values = momenta
+                .iter()
+                .map(|value| {
+                    value.parse::<f64>().map_err(|error| {
+                        RusticolError::invalid_argument(format!(
+                            "could not parse f64 momentum component {value:?}: {error}"
+                        ))
+                    })
+                })
+                .collect::<Result<Vec<_>, _>>()?;
+            let mut resolved = self.evaluate_representative_resolved_f64(
+                &values,
+                point_count,
+                helicity_ids,
+                color_ids,
+            )?;
+            self.apply_process_group_factor(&mut resolved.values);
+            self.publish_color_ids(&mut resolved.color_ids);
+            let totals = resolved.totals();
+            return Ok(NativeDecimalResolvedEvaluation {
+                values: format_decimal_values(resolved.values, decimal_digits),
+                totals: format_decimal_values(totals, decimal_digits),
+                point_count: resolved.point_count,
+                helicity_ids: resolved.helicity_ids,
+                color_ids: resolved.color_ids,
+                decimal_digits,
+            });
+        }
+        let physics =
+            self.runtime.physics.clone().ok_or_else(|| {
+                RusticolError::artifact("resolved physics metadata is unavailable")
+            })?;
+        let mut evaluation = if decimal_digits == 32 {
+            let batch = self.prepare_double_batch(momenta, point_count)?;
+            let (mut resolved, _profile) = self.runtime.run_resolved_generic(
+                &batch,
+                None,
+                selected_helicities.as_ref(),
+                selected_colors.as_ref(),
+            )?;
+            self.apply_process_group_factor_high_precision(&mut resolved.values);
+            decimal_resolved_evaluation(resolved, &physics.manifest, decimal_digits)?
+        } else {
+            let binary_precision = decimal_digits_to_bits(decimal_digits);
+            let batch = self.prepare_float_batch(momenta, point_count, binary_precision)?;
+            let (mut resolved, _profile) = self.runtime.run_resolved_generic(
+                &batch,
+                Some(binary_precision),
+                selected_helicities.as_ref(),
+                selected_colors.as_ref(),
+            )?;
+            self.apply_process_group_factor_high_precision(&mut resolved.values);
+            decimal_resolved_evaluation(resolved, &physics.manifest, decimal_digits)?
+        };
+        self.publish_color_ids(&mut evaluation.color_ids);
+        Ok(evaluation)
+    }
+
+    pub fn set_model_parameters(
+        &mut self,
+        values: &BTreeMap<String, (f64, f64)>,
+    ) -> Result<(), RusticolError> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if matches!(self.execution_lane, NativeExecutionLane::OnTheFly(_)) {
+            return self
+                .runtime
+                .apply_model_parameter_overrides(values)
+                .map_err(|error| RusticolError::model_parameter(error.to_string()));
+        }
+        let physics = self.physics_v1.get()?;
+        for name in values.keys() {
+            let parameter = physics
+                .model_parameters
+                .iter()
+                .find(|parameter| parameter.name == *name)
+                .ok_or_else(|| {
+                    RusticolError::model_parameter(format!(
+                        "model parameter {name:?} is not declared by process {}",
+                        self.process
+                    ))
+                })?;
+            if !parameter.mutable {
+                return Err(RusticolError::model_parameter(format!(
+                    "model parameter {name:?} is derived or immutable"
+                )));
+            }
+        }
+        self.runtime
+            .apply_model_parameter_overrides(values)
+            .map_err(|error| RusticolError::model_parameter(error.to_string()))
+    }
+
+    /// Drop selector-local warmed state without unloading the artifact or
+    /// changing runtime model parameters. Other execution modes have no
+    /// corresponding query-family cache and therefore treat this as a no-op.
+    pub fn clear(&mut self) -> RusticolResult<()> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        match &mut self.execution_lane {
+            NativeExecutionLane::OnTheFly(runtime) => runtime.clear()?,
+            NativeExecutionLane::Recurrence(runtime) => {
+                runtime.clear_helicity_selector_companion()?
+            }
+            _ => {}
+        }
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if matches!(
+            &self.execution_lane,
+            NativeExecutionLane::OnTheFly(_) | NativeExecutionLane::Recurrence(_)
+        ) {
+            self.point_selector_scratch = PointSelectorExecutionScratch::default();
+        }
+        Ok(())
+    }
+
+    pub fn set_model_parameter(
+        &mut self,
+        name: &str,
+        real: f64,
+        imaginary: f64,
+    ) -> Result<(), RusticolError> {
+        self.set_model_parameters(&BTreeMap::from([(name.to_string(), (real, imaginary))]))
+    }
+
+    pub fn set_model_parameters_json(&mut self, path: &Path) -> Result<(), RusticolError> {
+        let text = fs::read_to_string(path).map_err(|error| {
+            RusticolError::model_parameter(format!(
+                "could not read model-parameter JSON {}: {error}",
+                path.display()
+            ))
+        })?;
+        let overrides = parse_complex_parameter_overrides(&text, path)
+            .map_err(|error| RusticolError::model_parameter(error.to_string()))?;
+        self.set_model_parameters(&overrides)
+    }
+
+    pub fn mute_warnings(&mut self) {
+        self.warnings_muted = true;
+    }
+
+    pub fn unmute_warnings(&mut self) {
+        self.warnings_muted = false;
+    }
+
+    pub fn take_warnings(&mut self) -> Vec<String> {
+        std::mem::take(&mut self.pending_warnings)
+    }
+
+    pub fn pending_warnings_json(&self) -> Result<String, RusticolError> {
+        serde_json::to_string(&self.pending_warnings).map_err(|error| {
+            RusticolError::serialization(format!("could not serialize warnings: {error}"))
+        })
+    }
+
+    pub fn clear_pending_warnings(&mut self) {
+        self.pending_warnings.clear();
+    }
+
+    pub fn take_warnings_json(&mut self) -> Result<String, RusticolError> {
+        serde_json::to_string(&self.take_warnings()).map_err(|error| {
+            RusticolError::serialization(format!("could not serialize warnings: {error}"))
+        })
+    }
+
+    pub fn root(&self) -> &Path {
+        &self.root
+    }
+
+    fn prepare_f64_batch_profile(
+        &self,
+        momenta: &[f64],
+        point_count: usize,
+    ) -> Result<ProfiledPreparedF64Batch, RusticolError> {
+        let pack_start = Instant::now();
+        let batch = self.prepare_uncrossed_f64_batch(momenta, point_count)?;
+        let pack_elapsed = pack_start.elapsed();
+        if self.input_crossing_map.is_none() {
+            return Ok((batch, pack_elapsed, Duration::ZERO));
+        }
+        let crossing_start = Instant::now();
+        let batch = apply_input_crossing_map(
+            batch,
+            self.runtime.external_count,
+            self.input_crossing_map.as_deref(),
+        )?;
+        Ok((batch, pack_elapsed, crossing_start.elapsed()))
+    }
+
+    fn prepare_uncrossed_f64_batch(
+        &self,
+        momenta: &[f64],
+        point_count: usize,
+    ) -> Result<Vec<Vec<[f64; 4]>>, RusticolError> {
+        if point_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "point_count must be positive",
+            ));
+        }
+        let values_per_point = self
+            .runtime
+            .external_count
+            .checked_mul(4)
+            .ok_or_else(|| RusticolError::invalid_argument("momentum shape overflow"))?;
+        let expected = point_count
+            .checked_mul(values_per_point)
+            .ok_or_else(|| RusticolError::invalid_argument("momentum shape overflow"))?;
+        if momenta.len() != expected {
+            return Err(RusticolError::invalid_argument(format!(
+                "momenta contain {} values, expected {expected} for shape ({point_count}, {}, 4)",
+                momenta.len(),
+                self.runtime.external_count
+            )));
+        }
+        let mut batch = Vec::with_capacity(point_count);
+        for point_values in momenta.chunks_exact(values_per_point) {
+            let point = point_values
+                .chunks_exact(4)
+                .map(|components| [components[0], components[1], components[2], components[3]])
+                .collect();
+            batch.push(point);
+        }
+        Ok(batch)
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    fn prepare_double_batch(
+        &self,
+        momenta: &[String],
+        point_count: usize,
+    ) -> RusticolResult<Vec<Vec<[DoubleFloat; 4]>>> {
+        let floats = self.prepare_float_batch(momenta, point_count, 106)?;
+        Ok(floats
+            .into_iter()
+            .map(|point| {
+                point
+                    .into_iter()
+                    .map(|leg| {
+                        [
+                            leg[0].to_double_float(),
+                            leg[1].to_double_float(),
+                            leg[2].to_double_float(),
+                            leg[3].to_double_float(),
+                        ]
+                    })
+                    .collect()
+            })
+            .collect())
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    fn prepare_float_batch(
+        &self,
+        momenta: &[String],
+        point_count: usize,
+        binary_precision: u32,
+    ) -> RusticolResult<Vec<Vec<[Float; 4]>>> {
+        let values_per_point =
+            validate_flat_momentum_shape(momenta.len(), point_count, self.runtime.external_count)?;
+        let mut batch = Vec::with_capacity(point_count);
+        for point_values in momenta.chunks_exact(values_per_point) {
+            let mut point = Vec::with_capacity(self.runtime.external_count);
+            for components in point_values.chunks_exact(4) {
+                let values = components
+                    .iter()
+                    .map(|value| {
+                        Float::parse(value, Some(binary_precision)).map_err(|error| {
+                            RusticolError::invalid_argument(format!(
+                                "could not parse high-precision momentum component {value:?}: {error}"
+                            ))
+                        })
+                    })
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                point.push([
+                    values[0].clone(),
+                    values[1].clone(),
+                    values[2].clone(),
+                    values[3].clone(),
+                ]);
+            }
+            batch.push(point);
+        }
+        apply_input_crossing_map_generic(
+            &batch,
+            self.runtime.external_count,
+            self.input_crossing_map.as_deref(),
+        )
+    }
+
+    pub(super) fn record_resolved_warnings(
+        &mut self,
+        helicity_ids: Option<&[String]>,
+        color_ids: Option<&[String]>,
+    ) -> Result<(), RusticolError> {
+        if self.warnings_muted {
+            return Ok(());
+        }
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if matches!(self.execution_lane, NativeExecutionLane::OnTheFly(_)) {
+            // Compact selector construction authenticates complete LC
+            // coverage and materializes exact requested members directly;
+            // there are no representative-only rows to warn about here.
+            return Ok(());
+        }
+        let physics = self.runtime.physics.as_ref().ok_or_else(|| {
+            RusticolError::artifact("resolved evaluation requires regenerated physics metadata")
+        })?;
+        let mut warnings = Vec::new();
+        if physics.manifest.coverage.helicities != "complete" {
+            warnings.push((
+                "incomplete-helicity-coverage",
+                "resolved evaluation contains only the helicities represented by this artifact",
+            ));
+        }
+        if physics.manifest.color_accuracy == crate::ColorAccuracy::Lc
+            && physics.manifest.coverage.color != "complete"
+        {
+            warnings.push((
+                "incomplete-color-coverage",
+                "resolved evaluation contains only the color components represented by this artifact",
+            ));
+        }
+        let reduction_only_helicity = helicity_ids.is_some_and(|ids| {
+            ids.iter().any(|id| {
+                physics
+                    .helicity_index_by_id
+                    .get(id)
+                    .and_then(|index| physics.manifest.helicities.get(*index))
+                    .is_some_and(|item| !item.computed)
+            })
+        });
+        let reduction_only_color = color_ids.is_some_and(|ids| {
+            ids.iter().any(|id| {
+                physics
+                    .color_index_by_id
+                    .get(id)
+                    .is_some_and(|index| !physics.color_is_computed(*index))
+            })
+        });
+        if reduction_only_helicity || reduction_only_color {
+            warnings.push((
+                "reduction-only-selection",
+                "the selected resolved component reuses an exact symmetry representative",
+            ));
+        }
+        for (kind, message) in warnings {
+            if self.warned_kinds.insert(kind.to_string()) {
+                self.pending_warnings.push(message.to_string());
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_selector_capabilities(
+        &self,
+        helicity_requested: bool,
+        color_requested: bool,
+    ) -> Result<(), RusticolError> {
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        if matches!(self.execution_lane, NativeExecutionLane::OnTheFly(_)) {
+            if color_requested && self.runtime.color_accuracy != "lc" {
+                return Err(RusticolError::selector(
+                    "on-the-fly color selection is available only for LC artifacts",
+                ));
+            }
+            return Ok(());
+        }
+        let physics = self.physics_v1.get()?;
+        if helicity_requested && !physics.selectors.helicity {
+            return Err(RusticolError::selector(
+                "this artifact does not support physical helicity selection",
+            ));
+        }
+        if color_requested {
+            if self.runtime.color_accuracy != "lc" {
+                return Err(RusticolError::selector(
+                    "LC color-flow selection is unavailable for NLC/full artifacts; their resolved color axis is contracted",
+                ));
+            }
+            if !physics.selectors.color_flow {
+                return Err(RusticolError::selector(
+                    "this artifact does not support physical color-flow selection",
+                ));
+            }
+        }
+        Ok(())
+    }
+}
+
+fn validate_flat_momentum_shape(
+    value_count: usize,
+    point_count: usize,
+    external_count: usize,
+) -> RusticolResult<usize> {
+    if point_count == 0 {
+        return Err(RusticolError::invalid_argument(
+            "point_count must be positive",
+        ));
+    }
+    let values_per_point = external_count
+        .checked_mul(4)
+        .ok_or_else(|| RusticolError::invalid_argument("momentum shape overflow"))?;
+    let expected = point_count
+        .checked_mul(values_per_point)
+        .ok_or_else(|| RusticolError::invalid_argument("momentum shape overflow"))?;
+    if value_count != expected {
+        return Err(RusticolError::invalid_argument(format!(
+            "momenta contain {value_count} values, expected {expected} for shape ({point_count}, {external_count}, 4)"
+        )));
+    }
+    Ok(values_per_point)
+}
+
+#[cfg(feature = "symbolica-runtime")]
+fn format_decimal_values<T: std::fmt::LowerExp>(
+    values: Vec<T>,
+    decimal_digits: u32,
+) -> Vec<String> {
+    let digits = decimal_digits as usize;
+    values
+        .into_iter()
+        .map(|value| format!("{value:.digits$e}"))
+        .collect()
+}
+
+#[cfg(feature = "symbolica-runtime")]
+fn decimal_resolved_evaluation<T>(
+    resolved: ResolvedValues<T>,
+    physics: &ProcessPhysicsV1,
+    decimal_digits: u32,
+) -> RusticolResult<NativeDecimalResolvedEvaluation>
+where
+    T: RusticolHighPrecisionNumber + std::fmt::LowerExp,
+    Complex<T>: Real + EvaluationDomain,
+{
+    let component_count = resolved.helicity_indices.len() * resolved.color_indices.len();
+    if component_count == 0 {
+        return Err(RusticolError::internal(
+            "resolved evaluation produced an empty component axis",
+        ));
+    }
+    let mut totals = Vec::with_capacity(resolved.point_count);
+    for point in resolved.values.chunks(component_count) {
+        let mut total = T::new_zero();
+        for value in point {
+            total += value.clone();
+        }
+        totals.push(total);
+    }
+    let helicity_ids = resolved
+        .helicity_indices
+        .iter()
+        .map(|index| physics.helicities[*index].id.clone())
+        .collect();
+    let color_ids = resolved
+        .color_indices
+        .iter()
+        .map(|index| physics.color_components[*index].id().to_string())
+        .collect();
+    Ok(NativeDecimalResolvedEvaluation {
+        values: format_decimal_values(resolved.values, decimal_digits),
+        totals: format_decimal_values(totals, decimal_digits),
+        point_count: resolved.point_count,
+        helicity_ids,
+        color_ids,
+        decimal_digits,
+    })
+}
+
+pub(super) fn parse_public_kinematics_point(
+    value: &Value,
+    external_count: usize,
+) -> RusticolResult<Vec<f64>> {
+    let outer = value.as_array().ok_or_else(|| {
+        RusticolError::invalid_argument(
+            "kinematics JSON must be one [external][4] point or a singleton batch",
+        )
+    })?;
+    let point = if looks_like_kinematics_point(outer) {
+        outer.as_slice()
+    } else if outer.len() == 1 {
+        outer[0].as_array().map(Vec::as_slice).ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "kinematics JSON singleton batch must contain one [external][4] point",
+            )
+        })?
+    } else {
+        return Err(RusticolError::invalid_argument(
+            "kinematics JSON must contain exactly one point",
+        ));
+    };
+    if point.len() != external_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "kinematics point has {} external momenta, expected {external_count}",
+            point.len()
+        )));
+    }
+    let mut flat = Vec::with_capacity(external_count.saturating_mul(4));
+    for (external_index, momentum) in point.iter().enumerate() {
+        let components = momentum.as_array().ok_or_else(|| {
+            RusticolError::invalid_argument(format!(
+                "kinematics momentum {external_index} must be an array of four components"
+            ))
+        })?;
+        if components.len() != 4 {
+            return Err(RusticolError::invalid_argument(format!(
+                "kinematics momentum {external_index} has {} components, expected 4",
+                components.len()
+            )));
+        }
+        for (component_index, component) in components.iter().enumerate() {
+            let parsed = match component {
+                Value::Number(number) => number.as_f64(),
+                Value::String(number) => number.parse::<f64>().ok(),
+                _ => None,
+            }
+            .filter(|number| number.is_finite())
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(format!(
+                    "kinematics component [{external_index}][{component_index}] must be a finite JSON number or decimal string"
+                ))
+            })?;
+            flat.push(parsed);
+        }
+    }
+    Ok(flat)
+}
+
+fn looks_like_kinematics_point(values: &[Value]) -> bool {
+    values.iter().all(|momentum| {
+        momentum.as_array().is_some_and(|components| {
+            components.len() == 4
+                && components
+                    .iter()
+                    .all(|component| matches!(component, Value::Number(_) | Value::String(_)))
+        })
+    })
+}
+
+#[cfg(feature = "symbolica-runtime")]
+fn eager_parity_pending(feature: &str) -> RusticolError {
+    RusticolError::unsupported_runtime_capability(
+        EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        format!(
+            "eager {feature} is not provided by the native f64 Direct-Arena ABI; \
+             use the public Python Runtime exact-evaluation path for precision above 16 digits"
+        ),
+    )
+}
+
+#[cfg(feature = "symbolica-runtime")]
+fn recurrence_parity_pending(feature: &str) -> RusticolError {
+    RusticolError::unsupported_runtime_capability(
+        RECURRENCE_RUNTIME_CAPABILITY,
+        format!(
+            "recurrence {feature} is not available in the initial f64 runtime slice; use compiled execution for this operation"
+        ),
+    )
+}
+
+#[cfg(test)]
+mod runtime_capability_cutover_tests {
+    use super::*;
+
+    #[test]
+    fn retired_eager_v2_capabilities_fail_with_regeneration_guidance() {
+        for capability in [
+            EAGER_DAG_RUNTIME_CAPABILITY,
+            EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY,
+        ] {
+            let error = ensure_selected_runtime_capabilities_supported(&[capability.to_string()])
+                .expect_err("retired eager capability must fail before generic preflight");
+            assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+            assert!(error.to_string().contains("legacy eager plan-v2"));
+            assert!(error.to_string().contains("regenerate"));
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_cache.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_cache.rs
new file mode 100644
index 0000000000..6bce99f251
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_cache.rs
@@ -0,0 +1,303 @@
+// SPDX-License-Identifier: 0BSD
+
+//! One streamed snapshot of retained OTF structure, independent of numeric inputs.
+
+use super::super::on_the_fly_lane::OnTheFlyLaneSnapshotV1;
+use super::*;
+use sha2::{Digest, Sha256};
+use std::fs::{File, OpenOptions};
+use std::io::{BufReader, BufWriter, Read, Seek, SeekFrom, Write};
+use std::sync::atomic::{AtomicU64, Ordering};
+
+const MAGIC: [u8; 8] = *b"PACOTFC1";
+const VERSION: u32 = 1;
+static TEMP_ID: AtomicU64 = AtomicU64::new(0);
+
+#[derive(bincode::Encode, bincode::Decode, Debug, PartialEq)]
+struct Header {
+    magic: [u8; 8],
+    version: u32,
+    artifact_id: String,
+    process_key: String,
+    external_permutation: Vec<usize>,
+}
+
+impl Header {
+    fn for_runtime(runtime: &NativeRuntime) -> Self {
+        Self {
+            magic: MAGIC,
+            version: VERSION,
+            artifact_id: runtime.artifact_id.clone(),
+            process_key: runtime.process_key.clone(),
+            external_permutation: runtime.external_permutation.clone(),
+        }
+    }
+}
+
+fn io_error(context: &str, error: impl std::fmt::Display) -> RusticolError {
+    RusticolError::serialization(format!("OTF cache {context}: {error}"))
+}
+
+struct HashWriter<W> {
+    inner: W,
+    hash: Sha256,
+}
+
+impl<W: Write> Write for HashWriter<W> {
+    fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
+        let written = self.inner.write(bytes)?;
+        self.hash.update(&bytes[..written]);
+        Ok(written)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+fn encode<T: bincode::Encode>(value: T, writer: &mut impl Write) -> RusticolResult<()> {
+    bincode::encode_into_std_write(value, writer, bincode::config::standard())
+        .map(|_| ())
+        .map_err(|error| io_error("encoding failed", error))
+}
+
+fn decode<T: bincode::Decode<()>>(reader: &mut impl Read) -> RusticolResult<T> {
+    bincode::decode_from_std_read(reader, bincode::config::standard())
+        .map_err(|error| io_error("decoding failed", error))
+}
+
+/// Write into an owned sibling temporary file, then atomically replace the
+/// destination. Failed saves do not truncate a previously usable snapshot.
+fn write_snapshot(
+    path: &Path,
+    write_body: impl FnOnce(&mut HashWriter<BufWriter<File>>) -> RusticolResult<()>,
+) -> RusticolResult<()> {
+    let file_name = path
+        .file_name()
+        .ok_or_else(|| RusticolError::invalid_argument("OTF cache path must name a file"))?;
+    let mut temporary_name = file_name.to_os_string();
+    temporary_name.push(format!(
+        ".otf-tmp-{}-{}",
+        std::process::id(),
+        TEMP_ID.fetch_add(1, Ordering::Relaxed)
+    ));
+    let temporary = path.with_file_name(temporary_name);
+    let file = OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&temporary)
+        .map_err(|error| io_error("file creation failed", error))?;
+    let result = (|| {
+        let mut writer = HashWriter {
+            inner: BufWriter::new(file),
+            hash: Sha256::new(),
+        };
+        write_body(&mut writer)?;
+        let digest = writer.hash.finalize();
+        writer
+            .inner
+            .write_all(&digest)
+            .map_err(|error| io_error("checksum write failed", error))?;
+        writer
+            .inner
+            .flush()
+            .map_err(|error| io_error("flush failed", error))?;
+        drop(writer.inner);
+        fs::rename(&temporary, path).map_err(|error| io_error("file replacement failed", error))
+    })();
+    if result.is_err() {
+        let _ = fs::remove_file(&temporary);
+    }
+    result
+}
+
+/// Verify the single body checksum before decoding native row indices. This
+/// reads sequentially and never buffers a second copy of a large family.
+fn open_snapshot(path: &Path) -> RusticolResult<std::io::Take<BufReader<File>>> {
+    let file = File::open(path).map_err(|error| io_error("open failed", error))?;
+    let length = file
+        .metadata()
+        .map_err(|error| io_error("metadata failed", error))?
+        .len();
+    let body_length = length
+        .checked_sub(32)
+        .ok_or_else(|| RusticolError::serialization("OTF cache is truncated"))?;
+    let mut reader = BufReader::new(file);
+    let mut hash = Sha256::new();
+    let mut remaining = body_length;
+    let mut buffer = [0_u8; 64 * 1024];
+    while remaining != 0 {
+        let size = usize::try_from(remaining.min(buffer.len() as u64)).expect("bounded read size");
+        reader
+            .read_exact(&mut buffer[..size])
+            .map_err(|error| io_error("body read failed", error))?;
+        hash.update(&buffer[..size]);
+        remaining -= size as u64;
+    }
+    let mut expected = [0_u8; 32];
+    reader
+        .read_exact(&mut expected)
+        .map_err(|error| io_error("checksum read failed", error))?;
+    let actual: [u8; 32] = hash.finalize().into();
+    if actual != expected {
+        return Err(RusticolError::integrity("OTF cache checksum mismatch"));
+    }
+    reader
+        .seek(SeekFrom::Start(0))
+        .map_err(|error| io_error("rewind failed", error))?;
+    Ok(reader.take(body_length))
+}
+
+pub(super) fn save(
+    owner: &NativeRuntime,
+    runtime: &OnTheFlyExecutionRuntime,
+    path: &Path,
+) -> RusticolResult<()> {
+    if runtime.prepared_selections.len() > 1
+        || runtime.last_prepared_selection.is_some() && runtime.last_prepared_selection != Some(0)
+    {
+        return Err(RusticolError::internal(
+            "OTF selection retention policy changed; update the cache format",
+        ));
+    }
+    let selection = runtime
+        .prepared_selections
+        .first()
+        .map(|selected| &selected.identity);
+    let lane = runtime.lane.snapshot()?;
+    write_snapshot(path, |writer| {
+        encode(Header::for_runtime(owner), writer)?;
+        encode(selection, writer)?;
+        encode(lane, writer)
+    })
+}
+
+pub(super) fn load(owner: &mut NativeRuntime, path: &Path) -> RusticolResult<()> {
+    let mut reader = open_snapshot(path)?;
+    let header: Header = decode(&mut reader)?;
+    if header.magic != MAGIC || header.version != VERSION {
+        return Err(RusticolError::compatibility(
+            "unsupported OTF cache format; save it with this version",
+        ));
+    }
+    if header != Header::for_runtime(owner) {
+        return Err(RusticolError::compatibility(
+            "OTF cache belongs to a different process output or external ordering",
+        ));
+    }
+    let identity: Option<OnTheFlySelectionIdentityV1> = decode(&mut reader)?;
+    let lane: OnTheFlyLaneSnapshotV1 = decode(&mut reader)?;
+    if reader.limit() != 0 {
+        return Err(RusticolError::serialization("OTF cache has trailing data"));
+    }
+    if identity.is_some() != lane.has_family() {
+        return Err(RusticolError::integrity(
+            "OTF cache selection and family disagree",
+        ));
+    }
+    let NativeExecutionLane::OnTheFly(runtime) = &mut owner.execution_lane else {
+        return Err(RusticolError::compatibility(
+            "load_cache() requires an on-the-fly runtime",
+        ));
+    };
+    runtime.restore_saved_selection(identity, lane)
+}
+
+impl OnTheFlyExecutionRuntime {
+    fn restore_saved_selection(
+        &mut self,
+        identity: Option<OnTheFlySelectionIdentityV1>,
+        lane: OnTheFlyLaneSnapshotV1,
+    ) -> RusticolResult<()> {
+        let mut restored = Vec::new();
+        let mut requests = None;
+        let mut contracted_count = None;
+        if let Some(identity) = identity {
+            let selected = self.selectors.selection_from_ordinals(
+                self.lane.seed(),
+                identity.helicity_ordinals.as_deref(),
+                identity.color_ordinals.as_deref(),
+            )?;
+            let helicity_indices = (0..selected.helicity_count())
+                .map(|i| selected.helicity_ordinal_at(i))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let helicity_ids = (0..selected.helicity_count())
+                .map(|i| selected.helicity_id_at(i))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let (color_indices, color_ids, query_count) = match &self.reduction {
+                OnTheFlyReductionV1::Lc => {
+                    let indices = (0..selected.color_count())
+                        .map(|i| selected.color_ordinal_at(i))
+                        .collect::<RusticolResult<Vec<_>>>()?;
+                    let ids = (0..selected.color_count())
+                        .map(|i| selected.color_id_at(i))
+                        .collect::<RusticolResult<Vec<_>>>()?;
+                    let decoded = selected.iter().collect::<RusticolResult<Vec<_>>>()?;
+                    let count = decoded.len();
+                    requests = Some(decoded);
+                    (indices, ids, count)
+                }
+                OnTheFlyReductionV1::Contracted(plan) => {
+                    if identity.color_ordinals.is_some() {
+                        return Err(RusticolError::integrity(
+                            "saved contracted OTF selection contains colour selectors",
+                        ));
+                    }
+                    let count = plan.destination_by_owner_ordinal.len();
+                    contracted_count = Some(count);
+                    let query_count =
+                        helicity_indices.len().checked_mul(count).ok_or_else(|| {
+                            RusticolError::integrity("saved OTF query count overflows")
+                        })?;
+                    (vec![0], vec!["color:contracted".to_string()], query_count)
+                }
+            };
+            restored.push(OnTheFlyPreparedSelectionV1 {
+                identity,
+                helicity_indices: helicity_indices.into_boxed_slice(),
+                color_indices: color_indices.into_boxed_slice(),
+                helicity_ids: helicity_ids.into_boxed_slice(),
+                color_ids: color_ids.into_boxed_slice(),
+                query_count,
+            });
+        }
+        let contracted =
+            contracted_count.map(|count| (restored[0].helicity_indices.as_ref(), count));
+        self.lane.restore_snapshot(lane, requests, contracted)?;
+        self.last_prepared_selection = (!restored.is_empty()).then_some(0);
+        self.prepared_selections = restored;
+        self.pending_prepared_selection = None;
+        self.point_major_scratch = Vec::new();
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn streamed_snapshot_checksum_rejects_damage_and_failed_save_keeps_previous_file() {
+        let path = std::env::temp_dir().join(format!(
+            "rusticol-otf-cache-{}-{}.bin",
+            std::process::id(),
+            TEMP_ID.fetch_add(1, Ordering::Relaxed)
+        ));
+        write_snapshot(&path, |writer| encode((42_u32, vec![1_u32, 2, 3]), writer)).unwrap();
+        let mut reader = open_snapshot(&path).unwrap();
+        let decoded: (u32, Vec<u32>) = decode(&mut reader).unwrap();
+        assert_eq!(decoded, (42, vec![1, 2, 3]));
+        assert_eq!(reader.limit(), 0);
+        assert!(
+            write_snapshot(&path, |_| Err(RusticolError::serialization("test failure"))).is_err()
+        );
+        assert!(open_snapshot(&path).is_ok());
+        let mut bytes = fs::read(&path).unwrap();
+        bytes[0] ^= 1;
+        fs::write(&path, &bytes).unwrap();
+        assert!(open_snapshot(&path).is_err());
+        fs::write(&path, &bytes[..8]).unwrap();
+        assert!(open_snapshot(&path).is_err());
+        fs::remove_file(path).unwrap();
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_lane.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_lane.rs
new file mode 100644
index 0000000000..d4b12ffc87
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_lane.rs
@@ -0,0 +1,3709 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Private native LC lane for selector-local on-the-fly recurrence.
+//!
+//! This lane deliberately owns only the compact process seed, authenticated
+//! model catalogs, and one warmed query-family executor.  It never accepts or
+//! materializes a [`crate::recurrence::DirectRecurrencePlan`], a dense flow
+//! catalog, or a process-wide recurrence schedule.  Public selectors are
+//! decoded by the existing runtime adapter before they reach this module.
+//! Likewise, load/evaluate/profile/benchmark need only this compact state.
+//! The existing physics-metadata API can hang a separate lazy cache from
+//! [`OnTheFlyNativeRuntime::seed`], deriving dense public axes only when a
+//! caller explicitly requests introspection; that cache must not participate
+//! in this lane's load or warmed-evaluation path.
+
+use super::on_the_fly_selectors::OnTheFlyCompactSelectorAdapterV1;
+use super::on_the_fly_warm_up::{
+    NativeOnTheFlyWarmUpEventKind, NativeOnTheFlyWarmUpStage, OnTheFlyWarmUpProgress,
+};
+use super::recurrence_backend::NativeOnTheFlyPreparedExecutorResolver;
+use super::recurrence_lane::{
+    DirectProfileDelta, LcResolvedOutputLayout, PreparedParameterProjectionEntry,
+    accumulate_lc_diagonal_amplitude, direct_profile_from_delta,
+    projected_prepared_parameter_values,
+};
+use super::recurrence_load::on_the_fly_source_major_momenta_into;
+use super::*;
+use crate::direct_arena::DirectArenaTrafficCounters;
+#[cfg(feature = "on-the-fly-test-support")]
+use crate::recurrence::AuthenticatedRecurrenceBuilderInput;
+use crate::recurrence::direct_backend::DirectExecutionCounters;
+use crate::recurrence::direct_runtime::DirectRuntimeActivityCounters;
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+use crate::recurrence::on_the_fly::OnTheFlyCouplingPolicyCensusV1;
+#[cfg(feature = "on-the-fly-test-support")]
+use crate::recurrence::on_the_fly::build_on_the_fly_selected_trace_against_seed_v1;
+use crate::recurrence::on_the_fly::{
+    DecodedLcQueryV1, OnTheFlyProcessSeedV1, OnTheFlyQueryConstructionPoolV1,
+    OnTheFlyQueryFamilyCensusV1, OnTheFlyQueryFamilyExecutionReportV1,
+    OnTheFlyQueryFamilyExecutorV1, OnTheFlyQueryFamilyHandleV1, OnTheFlyResolvedCouplingPolicyV1,
+    OnTheFlySelectedQueryOutcomeV1, PreparedOnTheFlyGrammarV1, QueryFamilyTraceInput,
+    build_selected_lc_query_family_v1, build_streamed_query_family_candidate_v1,
+    prepare_on_the_fly_process_v1,
+};
+use crate::recurrence::template::ValidatedRecurrenceTemplateInput;
+use crate::recurrence::{
+    PreparedDirectExecutorCatalog, RecurrenceColorContraction, RuntimeColorContractionEntry,
+    RuntimeColorContractionReducer, RuntimeSymmetricGroupColorWorkspace,
+};
+use std::time::{Duration, Instant};
+
+#[path = "on_the_fly_lane_cache.rs"]
+mod cache;
+pub(super) use cache::OnTheFlyLaneSnapshotV1;
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[derive(Clone, Debug, PartialEq)]
+pub(super) struct OnTheFlyExecutionDiagnosticCurrentV1 {
+    pub(super) semantic_digest: crate::recurrence::SemanticDigest,
+    pub(super) stage: u32,
+    pub(super) values: Vec<(f64, f64)>,
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[derive(Clone, Debug, PartialEq)]
+pub(super) struct OnTheFlyExecutionDiagnosticSnapshotV1 {
+    pub(super) seed_digest: crate::recurrence::SemanticDigest,
+    pub(super) query_digest: crate::recurrence::SemanticDigest,
+    pub(super) trace_digest: crate::recurrence::SemanticDigest,
+    pub(super) raw_amplitude: (f64, f64),
+    pub(super) prepared_parameters: Vec<(f64, f64)>,
+    pub(super) currents: Vec<OnTheFlyExecutionDiagnosticCurrentV1>,
+}
+
+/// One public resolved-output destination represented by a selector-local
+/// trace.  The coefficient is the established helicity-orbit times LC color
+/// weight; process normalization remains a call-local runtime input.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) struct OnTheFlyLcReductionTargetV1 {
+    helicity_position: usize,
+    color_position: usize,
+    coefficient: f64,
+}
+
+impl OnTheFlyLcReductionTargetV1 {
+    pub(super) fn new(
+        helicity_position: usize,
+        color_position: usize,
+        coefficient: f64,
+    ) -> RusticolResult<Self> {
+        if !coefficient.is_finite() || coefficient < 0.0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly LC reduction coefficient must be finite and nonnegative",
+            ));
+        }
+        Ok(Self {
+            helicity_position,
+            color_position,
+            coefficient,
+        })
+    }
+}
+
+/// Existing-runtime selector preparation expressed as one compact decoded LC
+/// query plus its public resolved placements.  A representative helicity may
+/// legitimately address several physical orbit members.
+#[derive(Clone, Debug, PartialEq)]
+pub(super) struct OnTheFlyLcQueryRequestV1 {
+    query: DecodedLcQueryV1,
+    reduction_targets: Box<[OnTheFlyLcReductionTargetV1]>,
+}
+
+impl OnTheFlyLcQueryRequestV1 {
+    pub(super) fn new(
+        query: DecodedLcQueryV1,
+        reduction_targets: Vec<OnTheFlyLcReductionTargetV1>,
+    ) -> RusticolResult<Self> {
+        if reduction_targets.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly LC query has no selected reduction target",
+            ));
+        }
+        let mut coordinates = reduction_targets
+            .iter()
+            .map(|target| (target.helicity_position, target.color_position))
+            .collect::<Vec<_>>();
+        coordinates.sort_unstable();
+        if coordinates.windows(2).any(|pair| pair[0] == pair[1]) {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly LC query repeats a resolved reduction target",
+            ));
+        }
+        let total_coefficient = reduction_targets
+            .iter()
+            .try_fold(0.0_f64, |total, target| {
+                let total = total + target.coefficient;
+                total.is_finite().then_some(total).ok_or_else(|| {
+                    RusticolError::invalid_argument(
+                        "on-the-fly LC reduction coefficient sum is not finite",
+                    )
+                })
+            })?;
+        if total_coefficient == 0.0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly LC query has zero total reduction weight",
+            ));
+        }
+        Ok(Self {
+            query,
+            reduction_targets: reduction_targets.into_boxed_slice(),
+        })
+    }
+
+    fn total_coefficient(&self) -> f64 {
+        self.reduction_targets
+            .iter()
+            .map(|target| target.coefficient)
+            .sum()
+    }
+}
+
+struct PreparedOnTheFlyLcFamilyV1 {
+    requests: Box<[OnTheFlyLcQueryRequestV1]>,
+    amplitude_destinations: Box<[Option<usize>]>,
+    executor_handle: Option<OnTheFlyQueryFamilyHandleV1>,
+    census: Option<OnTheFlyQueryFamilyCensusV1>,
+    logical_point_capacity: u32,
+}
+
+/// Retained contracted selection state.  Decoded structural queries and
+/// their traces are deliberately absent: after the union family is prepared,
+/// execution needs only the selected public-helicity identity and the compact
+/// H x S projection from authenticated metric destinations to union-family
+/// amplitude destinations.
+struct PreparedOnTheFlyContractedFamilyV1 {
+    helicity_ordinals: Box<[usize]>,
+    structural_color_count: usize,
+    amplitude_destinations: Box<[Option<usize>]>,
+    executor_handle: Option<OnTheFlyQueryFamilyHandleV1>,
+    census: Option<OnTheFlyQueryFamilyCensusV1>,
+    logical_point_capacity: u32,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(super) struct OnTheFlyRetainedStateCensusV1 {
+    pub(super) family_count: usize,
+    pub(super) request_count: usize,
+    pub(super) amplitude_destination_count: usize,
+    pub(super) executor_handle_count: usize,
+    pub(super) query_local_trace_count: usize,
+    pub(super) embedded_lookup_key_count: usize,
+}
+
+#[cfg(test)]
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(super) struct OnTheFlyProcessPreparationCensusV1 {
+    pub(super) catalog_validation_count: u64,
+    pub(super) grammar_preparation_count: u64,
+}
+
+/// Process-local production owner for the private on-the-fly lane.
+///
+/// Field order is intentional: the family executor (and therefore every row
+/// table borrowed by a prepared kernel) is dropped before the catalogs and
+/// compact process seed from which its traces were constructed.
+pub(super) struct OnTheFlyNativeRuntime {
+    executor: OnTheFlyQueryFamilyExecutorV1<NativeOnTheFlyPreparedExecutorResolver>,
+    templates: ValidatedRecurrenceTemplateInput,
+    direct_catalog: PreparedDirectExecutorCatalog,
+    seed: OnTheFlyProcessSeedV1,
+    requested_query_construction_threads: usize,
+    effective_query_construction_threads: usize,
+    prepared_grammar: Option<PreparedOnTheFlyGrammarV1>,
+    coupling_policy: Option<OnTheFlyResolvedCouplingPolicyV1>,
+    coupling_policy_resolution: Option<Duration>,
+    process_preparation_count: u64,
+    #[cfg(test)]
+    process_preparation_census: OnTheFlyProcessPreparationCensusV1,
+    parameter_defaults: Box<[crate::EagerComplex64]>,
+    parameter_projection: Box<[PreparedParameterProjectionEntry]>,
+    runtime_parameter_values: Box<[f64]>,
+    families: Vec<PreparedOnTheFlyLcFamilyV1>,
+    last_family: Option<usize>,
+    pending_family: Option<PreparedOnTheFlyLcFamilyV1>,
+    contracted_family: Option<PreparedOnTheFlyContractedFamilyV1>,
+    pending_contracted_family: Option<PreparedOnTheFlyContractedFamilyV1>,
+    #[cfg(test)]
+    contracted_test_execution_attempt: usize,
+    #[cfg(test)]
+    contracted_test_fail_execution_at: Option<usize>,
+    #[cfg(test)]
+    contracted_max_live_query_outcomes: usize,
+    source_momenta_scratch: Vec<f64>,
+    amplitude_scratch: Vec<(f64, f64)>,
+    symmetric_group_color_workspace: Option<RuntimeSymmetricGroupColorWorkspace>,
+}
+
+fn emit_progress(
+    progress: Option<&mut OnTheFlyWarmUpProgress<'_>>,
+    kind: NativeOnTheFlyWarmUpEventKind,
+    stage: NativeOnTheFlyWarmUpStage,
+    completed: usize,
+    total: usize,
+    message: Option<&str>,
+) -> RusticolResult<()> {
+    if let Some(progress) = progress {
+        progress.emit(kind, stage, completed, total, message)?;
+    }
+    Ok(())
+}
+
+/// Map one owner-ordered selector request into the group-ordered amplitude
+/// projection retained by contracted execution.  The inverse owner map is
+/// authenticated at load, so every later reducer consumes this table directly
+/// in normalized local-group order.
+fn contracted_projection_index(
+    helicity_position: usize,
+    owner_ordinal: usize,
+    structural_color_count: usize,
+    destination_by_owner_ordinal: &[u32],
+) -> RusticolResult<usize> {
+    let group = usize::try_from(*destination_by_owner_ordinal.get(owner_ordinal).ok_or_else(
+        || {
+            RusticolError::integrity(
+                "on-the-fly contracted owner is outside its destination mapping",
+            )
+        },
+    )?)
+    .map_err(|_| RusticolError::artifact("on-the-fly contracted destination exceeds usize"))?;
+    if group >= structural_color_count {
+        return Err(RusticolError::integrity(
+            "on-the-fly contracted destination is outside the structural group domain",
+        ));
+    }
+    helicity_position
+        .checked_mul(structural_color_count)
+        .and_then(|offset| offset.checked_add(group))
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("on-the-fly contracted projection exceeds usize")
+        })
+}
+
+fn emit_reused_family_progress(
+    mut progress: Option<&mut OnTheFlyWarmUpProgress<'_>>,
+    query_count: usize,
+) -> RusticolResult<()> {
+    emit_progress(
+        progress.as_deref_mut(),
+        NativeOnTheFlyWarmUpEventKind::Start,
+        NativeOnTheFlyWarmUpStage::QueryFamily,
+        query_count,
+        query_count,
+        Some("query family already retained"),
+    )?;
+    emit_progress(
+        progress.as_deref_mut(),
+        NativeOnTheFlyWarmUpEventKind::End,
+        NativeOnTheFlyWarmUpStage::QueryFamily,
+        query_count,
+        query_count,
+        Some("query family reused"),
+    )?;
+    emit_progress(
+        progress.as_deref_mut(),
+        NativeOnTheFlyWarmUpEventKind::Start,
+        NativeOnTheFlyWarmUpStage::FamilyFinalization,
+        1,
+        1,
+        Some("family finalization already retained"),
+    )?;
+    emit_progress(
+        progress,
+        NativeOnTheFlyWarmUpEventKind::End,
+        NativeOnTheFlyWarmUpStage::FamilyFinalization,
+        1,
+        1,
+        Some("family finalization reused"),
+    )
+}
+
+impl OnTheFlyNativeRuntime {
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn new(
+        templates: ValidatedRecurrenceTemplateInput,
+        direct_catalog: PreparedDirectExecutorCatalog,
+        seed: OnTheFlyProcessSeedV1,
+        resolver: NativeOnTheFlyPreparedExecutorResolver,
+        requested_query_construction_threads: usize,
+        effective_query_construction_threads: usize,
+        parameter_defaults: Vec<crate::EagerComplex64>,
+        parameter_projection: Vec<PreparedParameterProjectionEntry>,
+        runtime_parameter_values: &[f64],
+    ) -> RusticolResult<Self> {
+        let summary = templates.summary();
+        if seed.template_catalog_digest() != summary.catalog_digest
+            || seed.model_digest() != summary.compiled_model_digest
+            || seed.prepared_pack_digest() != summary.prepared_kernel_pack_digest
+            || seed.direct_catalog_digest() != direct_catalog.direct_template_catalog_digest()
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly native lane catalogs do not match its compact process seed",
+            ));
+        }
+        if parameter_defaults.len()
+            != usize::try_from(summary.parameter_count)
+                .map_err(|_| RusticolError::artifact("on-the-fly parameter count exceeds usize"))?
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly prepared parameter defaults have the wrong size",
+            ));
+        }
+        if runtime_parameter_values
+            .iter()
+            .any(|value| !value.is_finite())
+        {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly runtime parameter value is not finite",
+            ));
+        }
+        if requested_query_construction_threads == 0
+            || effective_query_construction_threads == 0
+            || effective_query_construction_threads > requested_query_construction_threads
+        {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly effective query construction threads must be in the positive requested domain",
+            ));
+        }
+
+        let prepared_parameters = projected_prepared_parameter_values(
+            &parameter_defaults,
+            &parameter_projection,
+            runtime_parameter_values,
+        )?;
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        executor.set_parameters(&prepared_parameters)?;
+        Ok(Self {
+            executor,
+            templates,
+            direct_catalog,
+            seed,
+            requested_query_construction_threads,
+            effective_query_construction_threads,
+            prepared_grammar: None,
+            coupling_policy: None,
+            coupling_policy_resolution: None,
+            process_preparation_count: 0,
+            #[cfg(test)]
+            process_preparation_census: OnTheFlyProcessPreparationCensusV1::default(),
+            parameter_defaults: parameter_defaults.into_boxed_slice(),
+            parameter_projection: parameter_projection.into_boxed_slice(),
+            runtime_parameter_values: runtime_parameter_values.to_vec().into_boxed_slice(),
+            families: Vec::new(),
+            last_family: None,
+            pending_family: None,
+            contracted_family: None,
+            pending_contracted_family: None,
+            #[cfg(test)]
+            contracted_test_execution_attempt: 0,
+            #[cfg(test)]
+            contracted_test_fail_execution_at: None,
+            #[cfg(test)]
+            contracted_max_live_query_outcomes: 0,
+            source_momenta_scratch: Vec::new(),
+            amplitude_scratch: Vec::new(),
+            symmetric_group_color_workspace: None,
+        })
+    }
+
+    pub(super) fn install_symmetric_group_color_workspace(
+        &mut self,
+        workspace: RuntimeSymmetricGroupColorWorkspace,
+    ) -> RusticolResult<()> {
+        if self.symmetric_group_color_workspace.is_some() {
+            return Err(RusticolError::internal(
+                "on-the-fly symmetric-group color workspace was installed twice",
+            ));
+        }
+        self.symmetric_group_color_workspace = Some(workspace);
+        Ok(())
+    }
+
+    pub(super) const fn seed(&self) -> &OnTheFlyProcessSeedV1 {
+        &self.seed
+    }
+
+    pub(super) const fn requested_query_construction_threads(&self) -> usize {
+        self.requested_query_construction_threads
+    }
+
+    pub(super) const fn effective_query_construction_threads(&self) -> usize {
+        self.effective_query_construction_threads
+    }
+
+    /// Execute one retained public query through the production batched
+    /// query-family path and expose point-zero current values for diagnostics.
+    /// This remains absent from release builds and does not alter row grouping.
+    #[cfg(feature = "on-the-fly-test-support")]
+    pub(super) fn execution_diagnostic_v1(
+        &mut self,
+        authenticated: &AuthenticatedRecurrenceBuilderInput,
+        selected_public_flow_id: u32,
+        public_helicities: &[i32],
+        point_major_momenta: &[f64],
+        runtime_parameters: &[f64],
+    ) -> RusticolResult<OnTheFlyExecutionDiagnosticSnapshotV1> {
+        let selected = build_on_the_fly_selected_trace_against_seed_v1(
+            authenticated,
+            &self.direct_catalog,
+            &self.seed,
+            selected_public_flow_id,
+            public_helicities,
+            true,
+            self.symmetric_group_color_workspace.is_some(),
+        )?;
+        let request = OnTheFlyLcQueryRequestV1::new(
+            selected.query.clone(),
+            vec![OnTheFlyLcReductionTargetV1::new(0, 0, 1.0)?],
+        )?;
+        self.prepare_lc_queries(std::slice::from_ref(&request), 1)?;
+        let destination = self
+            .current_family()
+            .and_then(|family| family.amplitude_destinations.first())
+            .copied()
+            .flatten()
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly execution diagnostic selected a structural-zero query",
+                )
+            })?;
+        let _ = self.execute_amplitudes(point_major_momenta, 1, runtime_parameters)?;
+        let raw_amplitude = *self
+            .amplitude_scratch
+            .get(destination)
+            .ok_or_else(|| RusticolError::integrity("on-the-fly diagnostic amplitude is absent"))?;
+        let currents = self
+            .executor
+            .observed_currents(0)?
+            .into_iter()
+            .map(|current| OnTheFlyExecutionDiagnosticCurrentV1 {
+                semantic_digest: current.semantic_digest,
+                stage: current.stage,
+                values: current.values,
+            })
+            .collect();
+        let prepared_parameters = projected_prepared_parameter_values(
+            &self.parameter_defaults,
+            &self.parameter_projection,
+            runtime_parameters,
+        )?;
+        Ok(OnTheFlyExecutionDiagnosticSnapshotV1 {
+            seed_digest: selected.seed.semantic_digest(),
+            query_digest: selected.query.semantic_digest(),
+            trace_digest: selected.trace.semantic_digest(),
+            raw_amplitude,
+            prepared_parameters,
+            currents,
+        })
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    pub(super) fn coupling_policy_census(&self) -> Option<OnTheFlyCouplingPolicyCensusV1> {
+        self.coupling_policy.as_ref().map(|policy| policy.census())
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    pub(super) const fn coupling_policy_resolution(&self) -> Option<Duration> {
+        self.coupling_policy_resolution
+    }
+
+    /// Private read-only production introspection of the existing preparation count.
+    pub(super) const fn process_preparation_count(&self) -> u64 {
+        self.process_preparation_count
+    }
+
+    #[cfg(test)]
+    pub(super) const fn process_preparation_census(&self) -> OnTheFlyProcessPreparationCensusV1 {
+        self.process_preparation_census
+    }
+
+    fn ensure_process_prepared(&mut self) -> RusticolResult<()> {
+        match (&self.prepared_grammar, &self.coupling_policy) {
+            (Some(_), Some(_)) => return Ok(()),
+            (None, None) => {}
+            _ => {
+                return Err(RusticolError::internal(
+                    "on-the-fly process preparation is only partially initialized",
+                ));
+            }
+        }
+        let started = Instant::now();
+        let (grammar, policy) = prepare_on_the_fly_process_v1(&self.templates, &self.seed)?;
+        #[cfg(test)]
+        {
+            self.process_preparation_census.catalog_validation_count = self
+                .process_preparation_census
+                .catalog_validation_count
+                .checked_add(1)
+                .ok_or_else(|| {
+                    RusticolError::internal("on-the-fly catalog-validation count exceeds u64")
+                })?;
+            self.process_preparation_census.grammar_preparation_count = self
+                .process_preparation_census
+                .grammar_preparation_count
+                .checked_add(1)
+                .ok_or_else(|| {
+                    RusticolError::internal("on-the-fly grammar-preparation count exceeds u64")
+                })?;
+        }
+        self.process_preparation_count =
+            self.process_preparation_count
+                .checked_add(1)
+                .ok_or_else(|| {
+                    RusticolError::internal("on-the-fly process preparation count exceeds u64")
+                })?;
+        self.prepared_grammar = Some(grammar);
+        self.coupling_policy = Some(policy);
+        self.coupling_policy_resolution = Some(started.elapsed());
+        Ok(())
+    }
+
+    pub(super) fn prepare_process_for_warm_up(
+        &mut self,
+        progress: &mut OnTheFlyWarmUpProgress<'_>,
+    ) -> RusticolResult<bool> {
+        let already_prepared = self.prepared_grammar.is_some() && self.coupling_policy.is_some();
+        progress.emit(
+            NativeOnTheFlyWarmUpEventKind::Start,
+            NativeOnTheFlyWarmUpStage::ProcessPreparation,
+            usize::from(already_prepared),
+            1,
+            already_prepared.then_some("process preparation already retained"),
+        )?;
+        self.ensure_process_prepared()?;
+        progress.emit(
+            NativeOnTheFlyWarmUpEventKind::End,
+            NativeOnTheFlyWarmUpStage::ProcessPreparation,
+            1,
+            1,
+            already_prepared.then_some("process preparation reused"),
+        )?;
+        Ok(already_prepared)
+    }
+
+    pub(super) fn report_reused_family_for_warm_up(
+        &self,
+        query_count: usize,
+        progress: &mut OnTheFlyWarmUpProgress<'_>,
+    ) -> RusticolResult<()> {
+        emit_reused_family_progress(Some(progress), query_count)
+    }
+
+    fn prepare_streamed_lc_candidate_for_warm_up(
+        &mut self,
+        requests: &[OnTheFlyLcQueryRequestV1],
+        logical_point_capacity: u32,
+        query_construction_threads: usize,
+        progress: &mut OnTheFlyWarmUpProgress<'_>,
+    ) -> RusticolResult<(bool, PreparedOnTheFlyLcFamilyV1)> {
+        let enable_cyclic_trace_reflection = self.symmetric_group_color_workspace.is_some();
+        let coupling_policy = self.coupling_policy.as_ref().ok_or_else(|| {
+            RusticolError::internal("on-the-fly coupling policy disappeared after preparation")
+        })?;
+        let grammar = self.prepared_grammar.as_ref().ok_or_else(|| {
+            RusticolError::internal("on-the-fly grammar disappeared after preparation")
+        })?;
+        let worker_count = query_construction_threads.min(requests.len()).max(1);
+        let query_pool = OnTheFlyQueryConstructionPoolV1::new(worker_count)?;
+        let mut amplitude_destinations = Vec::new();
+        amplitude_destinations
+            .try_reserve_exact(requests.len())
+            .map_err(|error| {
+                RusticolError::invalid_argument(format!(
+                    "on-the-fly LC warm-up projection allocation failed: {error}"
+                ))
+            })?;
+        amplitude_destinations.resize(requests.len(), None);
+
+        let templates = &self.templates;
+        let direct_catalog = &self.direct_catalog;
+        let seed = &self.seed;
+        let executor = &mut self.executor;
+        let mut binding_started = false;
+        let mut processed_query_count = 0_usize;
+        let streamed = build_streamed_query_family_candidate_v1(direct_catalog, |consumer| {
+            while processed_query_count < requests.len() {
+                let chunk_end = processed_query_count
+                    .saturating_add(query_pool.chunk_capacity())
+                    .min(requests.len());
+                let expected_queries = requests[processed_query_count..chunk_end]
+                    .iter()
+                    .map(|request| grammar.canonicalize_query(seed, request.query.clone()))
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                let outcomes = query_pool.build_chunk(
+                    templates,
+                    direct_catalog,
+                    seed,
+                    coupling_policy,
+                    grammar,
+                    enable_cyclic_trace_reflection,
+                    expected_queries.clone(),
+                )?;
+                if outcomes.len() != expected_queries.len() {
+                    return Err(RusticolError::integrity(
+                        "on-the-fly LC warm-up trace builder changed a chunk count",
+                    ));
+                }
+
+                let mut traces = Vec::new();
+                let mut projection_slots = Vec::new();
+                traces.try_reserve_exact(outcomes.len()).map_err(|error| {
+                    RusticolError::invalid_argument(format!(
+                        "on-the-fly LC warm-up trace-chunk allocation failed: {error}"
+                    ))
+                })?;
+                projection_slots
+                    .try_reserve_exact(outcomes.len())
+                    .map_err(|error| {
+                        RusticolError::invalid_argument(format!(
+                            "on-the-fly LC warm-up projection-chunk allocation failed: {error}"
+                        ))
+                    })?;
+                for (chunk_offset, (expected_query, outcome)) in
+                    expected_queries.into_iter().zip(outcomes).enumerate()
+                {
+                    let request_index = processed_query_count + chunk_offset;
+                    match outcome {
+                        OnTheFlySelectedQueryOutcomeV1::Trace(selected) => {
+                            if selected.query != expected_query {
+                                return Err(RusticolError::integrity(
+                                    "on-the-fly LC warm-up trace query changed during construction",
+                                ));
+                            }
+                            projection_slots.push(request_index);
+                            traces.push(selected);
+                        }
+                        OnTheFlySelectedQueryOutcomeV1::StructuralZero { query } => {
+                            if query != expected_query {
+                                return Err(RusticolError::integrity(
+                                    "on-the-fly LC warm-up structural-zero query changed during construction",
+                                ));
+                            }
+                        }
+                    }
+                }
+                if !traces.is_empty() {
+                    if !binding_started {
+                        executor
+                            .resolver_mut()
+                            .begin_on_the_fly_family_binding(templates, direct_catalog)?;
+                        binding_started = true;
+                    }
+                    executor.resolver_mut().extend_on_the_fly_family_binding(
+                        templates,
+                        direct_catalog,
+                        seed,
+                        traces.iter_mut().map(|selected| &mut selected.trace),
+                    )?;
+                    let inputs = traces
+                        .iter()
+                        .map(|selected| QueryFamilyTraceInput {
+                            trace: &selected.trace,
+                            projection: selected.projection,
+                        })
+                        .collect::<Vec<_>>();
+                    let destinations = consumer.push_chunk(&inputs)?;
+                    if destinations.len() != projection_slots.len() {
+                        return Err(RusticolError::integrity(
+                            "on-the-fly LC warm-up streamed destination range changed a chunk count",
+                        ));
+                    }
+                    for (request_index, destination) in
+                        projection_slots.into_iter().zip(destinations)
+                    {
+                        let slot =
+                            amplitude_destinations
+                                .get_mut(request_index)
+                                .ok_or_else(|| {
+                                    RusticolError::integrity(
+                                        "on-the-fly LC warm-up projection slot is absent",
+                                    )
+                                })?;
+                        if slot.replace(destination as usize).is_some() {
+                            return Err(RusticolError::integrity(
+                                "on-the-fly LC warm-up projection slot is repeated",
+                            ));
+                        }
+                    }
+                }
+                processed_query_count = chunk_end;
+                progress.emit(
+                    NativeOnTheFlyWarmUpEventKind::Update,
+                    NativeOnTheFlyWarmUpStage::QueryFamily,
+                    processed_query_count,
+                    requests.len(),
+                    None,
+                )?;
+            }
+            Ok(())
+        })?;
+        if processed_query_count != requests.len() {
+            return Err(RusticolError::integrity(
+                "on-the-fly LC warm-up streamed construction omitted a selected query",
+            ));
+        }
+        progress.emit(
+            NativeOnTheFlyWarmUpEventKind::End,
+            NativeOnTheFlyWarmUpStage::QueryFamily,
+            requests.len(),
+            requests.len(),
+            None,
+        )?;
+        progress.emit(
+            NativeOnTheFlyWarmUpEventKind::Start,
+            NativeOnTheFlyWarmUpStage::FamilyFinalization,
+            0,
+            1,
+            None,
+        )?;
+        let (cache_hit, census) = if let Some(streamed) = streamed {
+            if !binding_started {
+                return Err(RusticolError::integrity(
+                    "on-the-fly LC warm-up streamed family has no semantic binding transaction",
+                ));
+            }
+            let cache_hit =
+                executor.prepare_streamed_candidate(streamed, logical_point_capacity)?;
+            let census = executor.prepared_census().ok_or_else(|| {
+                RusticolError::integrity("on-the-fly LC warm-up family has no work census")
+            })?;
+            let projected_nonzero_count = amplitude_destinations
+                .iter()
+                .filter(|destination| destination.is_some())
+                .count();
+            if usize::try_from(census.union_amplitude_destination_count).ok()
+                != Some(projected_nonzero_count)
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly LC warm-up family does not retain one destination per nonzero query",
+                ));
+            }
+            (cache_hit, Some(census))
+        } else {
+            if binding_started {
+                return Err(RusticolError::integrity(
+                    "on-the-fly LC warm-up all-zero family retained semantic bindings",
+                ));
+            }
+            (false, None)
+        };
+        progress.emit(
+            NativeOnTheFlyWarmUpEventKind::End,
+            NativeOnTheFlyWarmUpStage::FamilyFinalization,
+            1,
+            1,
+            None,
+        )?;
+        Ok((
+            cache_hit,
+            PreparedOnTheFlyLcFamilyV1 {
+                requests: requests.to_vec().into_boxed_slice(),
+                amplitude_destinations: amplitude_destinations.into_boxed_slice(),
+                executor_handle: None,
+                census,
+                logical_point_capacity,
+            },
+        ))
+    }
+
+    /// Cold selector/trace construction. Repeating an identical public
+    /// selection reuses its retained requests, projections, and warmed row
+    /// family; increasing only the point capacity replaces numeric workspace.
+    pub(super) fn prepare_lc_queries(
+        &mut self,
+        requests: &[OnTheFlyLcQueryRequestV1],
+        logical_point_capacity: u32,
+    ) -> RusticolResult<bool> {
+        self.prepare_lc_queries_impl(requests, logical_point_capacity, None, None)
+    }
+
+    pub(super) fn prepare_lc_queries_for_warm_up(
+        &mut self,
+        requests: &[OnTheFlyLcQueryRequestV1],
+        logical_point_capacity: u32,
+        query_construction_threads: usize,
+        progress: &mut OnTheFlyWarmUpProgress<'_>,
+    ) -> RusticolResult<bool> {
+        self.prepare_lc_queries_impl(
+            requests,
+            logical_point_capacity,
+            Some(query_construction_threads),
+            Some(progress),
+        )
+    }
+
+    fn prepare_lc_queries_impl(
+        &mut self,
+        requests: &[OnTheFlyLcQueryRequestV1],
+        logical_point_capacity: u32,
+        query_construction_threads: Option<usize>,
+        mut progress: Option<&mut OnTheFlyWarmUpProgress<'_>>,
+    ) -> RusticolResult<bool> {
+        if requests.is_empty() || logical_point_capacity == 0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly LC preparation requires queries and a nonzero point capacity",
+            ));
+        }
+        if self.contracted_family.is_some() || self.pending_contracted_family.is_some() {
+            return Err(RusticolError::internal(
+                "on-the-fly lane cannot mix LC and contracted retained families",
+            ));
+        }
+        if requests
+            .iter()
+            .any(|request| request.query.process_seed_digest() != self.seed.semantic_digest())
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly LC query belongs to a different compact process seed",
+            ));
+        }
+
+        // The common same-selector path compares the sole retained family
+        // directly. When the numeric
+        // workspace is already large enough it also avoids a redundant second
+        // identity walk inside the executor.
+        if self.pending_family.is_none()
+            && self.last_family.is_some_and(|index| {
+                self.families.get(index).is_some_and(|family| {
+                    family.requests.as_ref() == requests
+                        && logical_point_capacity <= family.logical_point_capacity
+                })
+            })
+        {
+            emit_reused_family_progress(progress.as_deref_mut(), requests.len())?;
+            return Ok(true);
+        }
+        if self
+            .pending_family
+            .as_ref()
+            .is_some_and(|family| family.requests.as_ref() == requests)
+        {
+            let (current_capacity, has_executable_family) = self
+                .pending_family
+                .as_ref()
+                .map(|family| (family.logical_point_capacity, family.census.is_some()))
+                .expect("matching on-the-fly pending family disappeared");
+            if logical_point_capacity > current_capacity
+                && has_executable_family
+                && let Err(error) = self.executor.resize_active_family(logical_point_capacity)
+            {
+                self.discard_pending_lc_queries()?;
+                return Err(error);
+            }
+            let family = self
+                .pending_family
+                .as_mut()
+                .expect("matching on-the-fly pending family disappeared after resize");
+            family.logical_point_capacity =
+                family.logical_point_capacity.max(logical_point_capacity);
+            emit_reused_family_progress(progress.as_deref_mut(), requests.len())?;
+            return Ok(false);
+        }
+        // A different uncommitted selector is a failed/superseded candidate,
+        // not another cache entry.
+        self.discard_pending_lc_queries()?;
+
+        let retained = self.last_family.filter(|&index| {
+            self.families
+                .get(index)
+                .is_some_and(|family| family.requests.as_ref() == requests)
+        });
+        if let Some(index) = retained {
+            let family = self
+                .families
+                .get_mut(index)
+                .expect("on-the-fly retained family index is absent");
+            let cache_hit = if let Some(handle) = family.executor_handle {
+                self.executor
+                    .activate_retained_family(handle, logical_point_capacity)?
+            } else {
+                true
+            };
+            family.logical_point_capacity =
+                family.logical_point_capacity.max(logical_point_capacity);
+            self.pending_family = None;
+            self.last_family = Some(index);
+            emit_reused_family_progress(progress.as_deref_mut(), requests.len())?;
+            return Ok(cache_hit);
+        }
+
+        if self.families.capacity() == 0 {
+            self.families.try_reserve_exact(1).map_err(|error| {
+                RusticolError::invalid_argument(format!(
+                    "on-the-fly retained-family allocation failed: {error}"
+                ))
+            })?;
+        }
+        let candidate_result = (|| {
+            emit_progress(
+                progress.as_deref_mut(),
+                NativeOnTheFlyWarmUpEventKind::Start,
+                NativeOnTheFlyWarmUpStage::QueryFamily,
+                0,
+                requests.len(),
+                None,
+            )?;
+            self.ensure_process_prepared()?;
+            if let Some(progress) = progress.as_deref_mut() {
+                return self.prepare_streamed_lc_candidate_for_warm_up(
+                    requests,
+                    logical_point_capacity,
+                    query_construction_threads.expect("warm-up worker count is absent"),
+                    progress,
+                );
+            }
+            let enable_cyclic_trace_reflection = self.symmetric_group_color_workspace.is_some();
+            let coupling_policy = self.coupling_policy.as_ref().ok_or_else(|| {
+                RusticolError::internal("on-the-fly coupling policy disappeared after preparation")
+            })?;
+            let grammar = self.prepared_grammar.as_ref().ok_or_else(|| {
+                RusticolError::internal("on-the-fly grammar disappeared after preparation")
+            })?;
+            let expected_queries = requests
+                .iter()
+                .map(|request| grammar.canonicalize_query(&self.seed, request.query.clone()))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let outcomes = build_selected_lc_query_family_v1(
+                &self.templates,
+                &self.direct_catalog,
+                &self.seed,
+                coupling_policy,
+                grammar,
+                enable_cyclic_trace_reflection,
+                self.effective_query_construction_threads,
+                expected_queries.iter().cloned(),
+            )?;
+            if outcomes.len() != requests.len() {
+                return Err(RusticolError::integrity(
+                    "on-the-fly batch trace builder changed the query count",
+                ));
+            }
+            emit_progress(
+                progress.as_deref_mut(),
+                NativeOnTheFlyWarmUpEventKind::End,
+                NativeOnTheFlyWarmUpStage::QueryFamily,
+                requests.len(),
+                requests.len(),
+                None,
+            )?;
+            let mut traces = Vec::new();
+            let mut amplitude_destinations = vec![None; requests.len()];
+            traces.try_reserve_exact(requests.len()).map_err(|error| {
+                RusticolError::invalid_argument(format!(
+                    "on-the-fly trace-family allocation failed: {error}"
+                ))
+            })?;
+            for (request_index, (expected_query, outcome)) in
+                expected_queries.into_iter().zip(outcomes).enumerate()
+            {
+                match outcome {
+                    OnTheFlySelectedQueryOutcomeV1::Trace(selected) => {
+                        if selected.query != expected_query {
+                            return Err(RusticolError::integrity(
+                                "on-the-fly trace query changed during construction",
+                            ));
+                        }
+                        amplitude_destinations[request_index] = Some(traces.len());
+                        traces.push(selected);
+                    }
+                    OnTheFlySelectedQueryOutcomeV1::StructuralZero { query } => {
+                        if query != expected_query {
+                            return Err(RusticolError::integrity(
+                                "on-the-fly structural-zero query changed during construction",
+                            ));
+                        }
+                    }
+                }
+            }
+            emit_progress(
+                progress.as_deref_mut(),
+                NativeOnTheFlyWarmUpEventKind::Start,
+                NativeOnTheFlyWarmUpStage::FamilyFinalization,
+                0,
+                1,
+                None,
+            )?;
+            let (cache_hit, census) = if traces.is_empty() {
+                (false, None)
+            } else {
+                self.executor.resolver_mut().bind_on_the_fly_family(
+                    &self.templates,
+                    &self.direct_catalog,
+                    &self.seed,
+                    &mut traces,
+                )?;
+                let inputs = traces
+                    .iter()
+                    .map(|selected| QueryFamilyTraceInput {
+                        trace: &selected.trace,
+                        projection: selected.projection,
+                    })
+                    .collect::<Vec<_>>();
+                let cache_hit =
+                    self.executor
+                        .prepare(&self.direct_catalog, &inputs, logical_point_capacity)?;
+                let census = self.executor.prepared_census().ok_or_else(|| {
+                    RusticolError::integrity("on-the-fly prepared family has no work census")
+                })?;
+                if usize::try_from(census.union_amplitude_destination_count).ok()
+                    != Some(traces.len())
+                {
+                    return Err(RusticolError::integrity(
+                        "on-the-fly family does not retain one destination per nonzero query",
+                    ));
+                }
+                if cache_hit && self.executor.active_retained_handle().is_none() {
+                    return Err(RusticolError::integrity(
+                        "on-the-fly cache hit has no retained executor handle",
+                    ));
+                }
+                (cache_hit, Some(census))
+            };
+            emit_progress(
+                progress.as_deref_mut(),
+                NativeOnTheFlyWarmUpEventKind::End,
+                NativeOnTheFlyWarmUpStage::FamilyFinalization,
+                1,
+                1,
+                None,
+            )?;
+            Ok((
+                cache_hit,
+                PreparedOnTheFlyLcFamilyV1 {
+                    requests: requests.to_vec().into_boxed_slice(),
+                    amplitude_destinations: amplitude_destinations.into_boxed_slice(),
+                    executor_handle: None,
+                    census,
+                    logical_point_capacity,
+                },
+            ))
+        })();
+        let (cache_hit, candidate) = match candidate_result {
+            Ok(candidate) => candidate,
+            Err(error) => {
+                self.discard_pending_lc_queries()?;
+                return Err(error);
+            }
+        };
+        // Selection-level state is committed only after the first successful
+        // evaluation, including structural-zero and executor-cache-hit cases.
+        self.pending_family = Some(candidate);
+        Ok(cache_hit)
+    }
+
+    /// Prepare the transient H x S structural query family consumed by a
+    /// contracted NLC/full color metric.  Only its compact identity and
+    /// amplitude projection survive this cold boundary.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn prepare_contracted_queries(
+        &mut self,
+        selectors: &OnTheFlyCompactSelectorAdapterV1,
+        helicity_ordinals: &[usize],
+        structural_color_count: usize,
+        destination_by_owner_ordinal: &[u32],
+        logical_point_capacity: u32,
+    ) -> RusticolResult<bool> {
+        self.prepare_contracted_queries_impl(
+            selectors,
+            helicity_ordinals,
+            structural_color_count,
+            destination_by_owner_ordinal,
+            logical_point_capacity,
+            None,
+            None,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn prepare_contracted_queries_for_warm_up(
+        &mut self,
+        selectors: &OnTheFlyCompactSelectorAdapterV1,
+        helicity_ordinals: &[usize],
+        structural_color_count: usize,
+        destination_by_owner_ordinal: &[u32],
+        logical_point_capacity: u32,
+        query_construction_threads: usize,
+        progress: &mut OnTheFlyWarmUpProgress<'_>,
+    ) -> RusticolResult<bool> {
+        self.prepare_contracted_queries_impl(
+            selectors,
+            helicity_ordinals,
+            structural_color_count,
+            destination_by_owner_ordinal,
+            logical_point_capacity,
+            Some(query_construction_threads),
+            Some(progress),
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn prepare_contracted_queries_impl(
+        &mut self,
+        selectors: &OnTheFlyCompactSelectorAdapterV1,
+        helicity_ordinals: &[usize],
+        structural_color_count: usize,
+        destination_by_owner_ordinal: &[u32],
+        logical_point_capacity: u32,
+        query_construction_threads: Option<usize>,
+        mut progress: Option<&mut OnTheFlyWarmUpProgress<'_>>,
+    ) -> RusticolResult<bool> {
+        if helicity_ordinals.is_empty()
+            || structural_color_count == 0
+            || logical_point_capacity == 0
+        {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly contracted preparation requires helicities, structural colors, and a nonzero point capacity",
+            ));
+        }
+        if !self.families.is_empty() || self.pending_family.is_some() {
+            return Err(RusticolError::internal(
+                "on-the-fly lane cannot mix LC and contracted retained families",
+            ));
+        }
+        if helicity_ordinals.windows(2).any(|pair| pair[0] >= pair[1]) {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly contracted helicity ordinals are not strictly increasing",
+            ));
+        }
+        let query_count = helicity_ordinals
+            .len()
+            .checked_mul(structural_color_count)
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("on-the-fly contracted query shape exceeds usize")
+            })?;
+        if destination_by_owner_ordinal.len() != structural_color_count
+            || selectors.color_count() != structural_color_count
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly contracted selector or destination shape is inconsistent",
+            ));
+        }
+        let mut destination_seen = vec![false; structural_color_count];
+        for destination in destination_by_owner_ordinal {
+            let destination = usize::try_from(*destination).map_err(|_| {
+                RusticolError::artifact("on-the-fly contracted destination exceeds usize")
+            })?;
+            let seen = destination_seen.get_mut(destination).ok_or_else(|| {
+                RusticolError::integrity(
+                    "on-the-fly contracted destination is outside the structural owner domain",
+                )
+            })?;
+            if *seen {
+                return Err(RusticolError::integrity(
+                    "on-the-fly contracted destination mapping is not one-to-one",
+                ));
+            }
+            *seen = true;
+        }
+        if destination_seen.contains(&false) {
+            return Err(RusticolError::integrity(
+                "on-the-fly contracted destination mapping is not complete",
+            ));
+        }
+        let identity_matches = |family: &PreparedOnTheFlyContractedFamilyV1| {
+            family.helicity_ordinals.as_ref() == helicity_ordinals
+                && family.structural_color_count == structural_color_count
+        };
+        if self
+            .pending_contracted_family
+            .as_ref()
+            .is_some_and(identity_matches)
+        {
+            let (current_capacity, has_executable_family) = self
+                .pending_contracted_family
+                .as_ref()
+                .map(|family| (family.logical_point_capacity, family.census.is_some()))
+                .expect("matching contracted pending family disappeared");
+            if logical_point_capacity > current_capacity
+                && has_executable_family
+                && let Err(error) = self.executor.resize_active_family(logical_point_capacity)
+            {
+                self.discard_pending_contracted_queries()?;
+                return Err(error);
+            }
+            let family = self
+                .pending_contracted_family
+                .as_mut()
+                .expect("matching contracted pending family disappeared after resize");
+            family.logical_point_capacity =
+                family.logical_point_capacity.max(logical_point_capacity);
+            emit_reused_family_progress(progress.as_deref_mut(), query_count)?;
+            return Ok(false);
+        }
+        self.discard_pending_contracted_queries()?;
+        if self
+            .contracted_family
+            .as_ref()
+            .is_some_and(identity_matches)
+        {
+            let family = self
+                .contracted_family
+                .as_mut()
+                .expect("matching retained contracted family disappeared");
+            let cache_hit = if let Some(handle) = family.executor_handle {
+                self.executor
+                    .activate_retained_family(handle, logical_point_capacity)?
+            } else {
+                true
+            };
+            family.logical_point_capacity =
+                family.logical_point_capacity.max(logical_point_capacity);
+            emit_reused_family_progress(progress.as_deref_mut(), query_count)?;
+            return Ok(cache_hit);
+        }
+
+        let candidate_result = (|| {
+            emit_progress(
+                progress.as_deref_mut(),
+                NativeOnTheFlyWarmUpEventKind::Start,
+                NativeOnTheFlyWarmUpStage::QueryFamily,
+                0,
+                query_count,
+                None,
+            )?;
+            self.ensure_process_prepared()?;
+            let enable_cyclic_trace_reflection = self.symmetric_group_color_workspace.is_some();
+            let coupling_policy = self.coupling_policy.as_ref().ok_or_else(|| {
+                RusticolError::internal("on-the-fly coupling policy disappeared after preparation")
+            })?;
+            let grammar = self.prepared_grammar.as_ref().ok_or_else(|| {
+                RusticolError::internal("on-the-fly grammar disappeared after preparation")
+            })?;
+            let query_pool = OnTheFlyQueryConstructionPoolV1::new(
+                query_construction_threads.unwrap_or(self.effective_query_construction_threads),
+            )?;
+            let mut amplitude_destinations = Vec::new();
+            amplitude_destinations
+                .try_reserve_exact(query_count)
+                .map_err(|error| {
+                    RusticolError::invalid_argument(format!(
+                        "on-the-fly contracted projection allocation failed: {error}"
+                    ))
+                })?;
+            amplitude_destinations.resize(query_count, None);
+
+            let templates = &self.templates;
+            let direct_catalog = &self.direct_catalog;
+            let seed = &self.seed;
+            let executor = &mut self.executor;
+            let mut binding_started = false;
+            let mut processed_query_count = 0_usize;
+            #[cfg(test)]
+            let mut max_live_query_outcomes = 0_usize;
+            let streamed = build_streamed_query_family_candidate_v1(direct_catalog, |consumer| {
+                while processed_query_count < query_count {
+                    let chunk_end = processed_query_count
+                        .saturating_add(query_pool.chunk_capacity())
+                        .min(query_count);
+                    let mut queries = Vec::new();
+                    queries
+                        .try_reserve_exact(chunk_end - processed_query_count)
+                        .map_err(|error| {
+                            RusticolError::invalid_argument(format!(
+                                "on-the-fly contracted query-chunk allocation failed: {error}"
+                            ))
+                        })?;
+                    for request_index in processed_query_count..chunk_end {
+                        let helicity_position = request_index / structural_color_count;
+                        let owner_ordinal = request_index % structural_color_count;
+                        let query = selectors.decoded_query_at(
+                            seed,
+                            helicity_ordinals[helicity_position],
+                            owner_ordinal,
+                        )?;
+                        queries.push(grammar.canonicalize_query(seed, query)?);
+                    }
+                    let expected_queries = queries.clone();
+                    let outcomes = query_pool.build_chunk(
+                        templates,
+                        direct_catalog,
+                        seed,
+                        coupling_policy,
+                        grammar,
+                        enable_cyclic_trace_reflection,
+                        queries,
+                    )?;
+                    if outcomes.len() != expected_queries.len() {
+                        return Err(RusticolError::integrity(
+                            "on-the-fly contracted trace builder changed a chunk count",
+                        ));
+                    }
+                    #[cfg(test)]
+                    {
+                        max_live_query_outcomes = max_live_query_outcomes.max(outcomes.len());
+                    }
+
+                    let mut traces = Vec::new();
+                    let mut projection_slots = Vec::new();
+                    traces.try_reserve_exact(outcomes.len()).map_err(|error| {
+                        RusticolError::invalid_argument(format!(
+                            "on-the-fly contracted trace-chunk allocation failed: {error}"
+                        ))
+                    })?;
+                    projection_slots
+                        .try_reserve_exact(outcomes.len())
+                        .map_err(|error| {
+                            RusticolError::invalid_argument(format!(
+                                "on-the-fly contracted projection-chunk allocation failed: {error}"
+                            ))
+                        })?;
+                    for (chunk_offset, (expected_query, outcome)) in
+                        expected_queries.into_iter().zip(outcomes).enumerate()
+                    {
+                        let request_index = processed_query_count + chunk_offset;
+                        let helicity_position = request_index / structural_color_count;
+                        let owner_ordinal = request_index % structural_color_count;
+                        let projection_index = contracted_projection_index(
+                            helicity_position,
+                            owner_ordinal,
+                            structural_color_count,
+                            destination_by_owner_ordinal,
+                        )?;
+                        match outcome {
+                            OnTheFlySelectedQueryOutcomeV1::Trace(selected) => {
+                                if selected.query != expected_query {
+                                    return Err(RusticolError::integrity(
+                                        "on-the-fly contracted trace query changed during construction",
+                                    ));
+                                }
+                                projection_slots.push(projection_index);
+                                traces.push(selected);
+                            }
+                            OnTheFlySelectedQueryOutcomeV1::StructuralZero { query: selected } => {
+                                if selected != expected_query {
+                                    return Err(RusticolError::integrity(
+                                        "on-the-fly contracted structural-zero query changed during construction",
+                                    ));
+                                }
+                            }
+                        }
+                    }
+                    if !traces.is_empty() {
+                        if !binding_started {
+                            executor
+                                .resolver_mut()
+                                .begin_on_the_fly_family_binding(templates, direct_catalog)?;
+                            binding_started = true;
+                        }
+                        executor.resolver_mut().extend_on_the_fly_family_binding(
+                            templates,
+                            direct_catalog,
+                            seed,
+                            traces.iter_mut().map(|selected| &mut selected.trace),
+                        )?;
+                        let inputs = traces
+                            .iter()
+                            .map(|selected| QueryFamilyTraceInput {
+                                trace: &selected.trace,
+                                projection: selected.projection,
+                            })
+                            .collect::<Vec<_>>();
+                        let destinations = consumer.push_chunk(&inputs)?;
+                        if destinations.len() != projection_slots.len() {
+                            return Err(RusticolError::integrity(
+                                "on-the-fly streamed destination range changed a chunk count",
+                            ));
+                        }
+                        for (projection_index, destination) in
+                            projection_slots.into_iter().zip(destinations)
+                        {
+                            let slot = amplitude_destinations
+                                .get_mut(projection_index)
+                                .ok_or_else(|| {
+                                    RusticolError::integrity(
+                                        "on-the-fly contracted projection slot is absent",
+                                    )
+                                })?;
+                            if slot.replace(destination as usize).is_some() {
+                                return Err(RusticolError::integrity(
+                                    "on-the-fly contracted projection slot is repeated",
+                                ));
+                            }
+                        }
+                    }
+                    processed_query_count = chunk_end;
+                    emit_progress(
+                        progress.as_deref_mut(),
+                        NativeOnTheFlyWarmUpEventKind::Update,
+                        NativeOnTheFlyWarmUpStage::QueryFamily,
+                        processed_query_count,
+                        query_count,
+                        None,
+                    )?;
+                }
+                Ok(())
+            })?;
+            #[cfg(test)]
+            {
+                self.contracted_max_live_query_outcomes = max_live_query_outcomes;
+            }
+            if processed_query_count != query_count {
+                return Err(RusticolError::integrity(
+                    "on-the-fly contracted streamed construction omitted a structural query",
+                ));
+            }
+            emit_progress(
+                progress.as_deref_mut(),
+                NativeOnTheFlyWarmUpEventKind::End,
+                NativeOnTheFlyWarmUpStage::QueryFamily,
+                query_count,
+                query_count,
+                None,
+            )?;
+            emit_progress(
+                progress.as_deref_mut(),
+                NativeOnTheFlyWarmUpEventKind::Start,
+                NativeOnTheFlyWarmUpStage::FamilyFinalization,
+                0,
+                1,
+                None,
+            )?;
+            let (cache_hit, census) = if let Some(streamed) = streamed {
+                if !binding_started {
+                    return Err(RusticolError::integrity(
+                        "on-the-fly streamed family has no semantic binding transaction",
+                    ));
+                }
+                let cache_hit =
+                    executor.prepare_streamed_candidate(streamed, logical_point_capacity)?;
+                let census = executor.prepared_census().ok_or_else(|| {
+                    RusticolError::integrity("on-the-fly contracted family has no work census")
+                })?;
+                let projected_nonzero_count = amplitude_destinations
+                    .iter()
+                    .filter(|destination| destination.is_some())
+                    .count();
+                if usize::try_from(census.union_amplitude_destination_count).ok()
+                    != Some(projected_nonzero_count)
+                {
+                    return Err(RusticolError::integrity(
+                        "on-the-fly contracted family does not retain one destination per nonzero query",
+                    ));
+                }
+                (cache_hit, Some(census))
+            } else {
+                if binding_started {
+                    return Err(RusticolError::integrity(
+                        "on-the-fly all-zero streamed family retained semantic bindings",
+                    ));
+                }
+                (false, None)
+            };
+            emit_progress(
+                progress.as_deref_mut(),
+                NativeOnTheFlyWarmUpEventKind::End,
+                NativeOnTheFlyWarmUpStage::FamilyFinalization,
+                1,
+                1,
+                None,
+            )?;
+            Ok((
+                cache_hit,
+                PreparedOnTheFlyContractedFamilyV1 {
+                    helicity_ordinals: helicity_ordinals.to_vec().into_boxed_slice(),
+                    structural_color_count,
+                    amplitude_destinations: amplitude_destinations.into_boxed_slice(),
+                    executor_handle: None,
+                    census,
+                    logical_point_capacity,
+                },
+            ))
+        })();
+        let (cache_hit, candidate) = match candidate_result {
+            Ok(candidate) => candidate,
+            Err(error) => {
+                self.discard_pending_contracted_queries()?;
+                return Err(error);
+            }
+        };
+        self.pending_contracted_family = Some(candidate);
+        Ok(cache_hit)
+    }
+
+    /// Re-activate the family already selected by the runtime wrapper without
+    /// rebuilding its public selector requests.  The common warmed call has
+    /// sufficient point capacity and therefore performs no allocation or
+    /// identity walk.  Capacity growth remains explicit and fallible.
+    pub(super) fn reuse_current_lc_queries(
+        &mut self,
+        logical_point_capacity: u32,
+    ) -> RusticolResult<bool> {
+        if logical_point_capacity == 0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly LC preparation requires a nonzero point capacity",
+            ));
+        }
+        if let Some(family) = self.pending_family.as_mut() {
+            if logical_point_capacity <= family.logical_point_capacity {
+                return Ok(false);
+            }
+            let has_executable_family = family.census.is_some();
+            if has_executable_family
+                && let Err(error) = self.executor.resize_active_family(logical_point_capacity)
+            {
+                self.discard_pending_lc_queries()?;
+                return Err(error);
+            }
+            self.pending_family
+                .as_mut()
+                .expect("pending on-the-fly family disappeared after resize")
+                .logical_point_capacity = logical_point_capacity;
+            return Ok(false);
+        }
+        let index = self.last_family.ok_or_else(|| {
+            RusticolError::internal(
+                "on-the-fly selector cache has no corresponding prepared family",
+            )
+        })?;
+        let family = self.families.get_mut(index).ok_or_else(|| {
+            RusticolError::internal(
+                "on-the-fly selector cache references an absent prepared family",
+            )
+        })?;
+        if logical_point_capacity <= family.logical_point_capacity {
+            return Ok(true);
+        }
+        let cache_hit = if let Some(handle) = family.executor_handle {
+            self.executor
+                .activate_retained_family(handle, logical_point_capacity)?
+        } else {
+            true
+        };
+        family.logical_point_capacity = logical_point_capacity;
+        Ok(cache_hit)
+    }
+
+    pub(super) fn reuse_current_contracted_queries(
+        &mut self,
+        logical_point_capacity: u32,
+    ) -> RusticolResult<bool> {
+        if logical_point_capacity == 0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly contracted preparation requires a nonzero point capacity",
+            ));
+        }
+        if let Some(family) = self.pending_contracted_family.as_mut() {
+            if logical_point_capacity <= family.logical_point_capacity {
+                return Ok(false);
+            }
+            if family.census.is_some()
+                && let Err(error) = self.executor.resize_active_family(logical_point_capacity)
+            {
+                self.discard_pending_contracted_queries()?;
+                return Err(error);
+            }
+            self.pending_contracted_family
+                .as_mut()
+                .expect("pending contracted family disappeared after resize")
+                .logical_point_capacity = logical_point_capacity;
+            return Ok(false);
+        }
+        let family = self.contracted_family.as_mut().ok_or_else(|| {
+            RusticolError::internal("on-the-fly contracted selector cache has no prepared family")
+        })?;
+        if logical_point_capacity <= family.logical_point_capacity {
+            return Ok(true);
+        }
+        let cache_hit = if let Some(handle) = family.executor_handle {
+            self.executor
+                .activate_retained_family(handle, logical_point_capacity)?
+        } else {
+            true
+        };
+        family.logical_point_capacity = logical_point_capacity;
+        Ok(cache_hit)
+    }
+
+    pub(super) fn prepared_census(&self) -> Option<OnTheFlyQueryFamilyCensusV1> {
+        self.current_family()
+            .and_then(|family| family.census)
+            .or_else(|| {
+                self.current_contracted_family()
+                    .and_then(|family| family.census)
+            })
+    }
+
+    #[cfg(test)]
+    pub(super) fn retained_family_count(&self) -> usize {
+        self.families.len() + usize::from(self.contracted_family.is_some())
+    }
+
+    pub(super) fn pending_family_count(&self) -> usize {
+        usize::from(self.pending_family.is_some())
+            + usize::from(self.pending_contracted_family.is_some())
+    }
+
+    pub(super) fn semantic_executor_binding_count(&self) -> RusticolResult<u32> {
+        self.executor.resolver().semantic_executor_binding_count()
+    }
+
+    /// Count retained production state without constructing or mutating it.
+    pub(super) fn retained_state_census(&self) -> OnTheFlyRetainedStateCensusV1 {
+        let mut census = OnTheFlyRetainedStateCensusV1::default();
+        for family in &self.families {
+            census.family_count += 1;
+            census.request_count += family.requests.len();
+            census.executor_handle_count += usize::from(family.executor_handle.is_some());
+            for destination in &family.amplitude_destinations {
+                if destination.is_some() {
+                    census.amplitude_destination_count += 1;
+                }
+            }
+        }
+        if let Some(family) = &self.contracted_family {
+            census.family_count += 1;
+            census.request_count += family.amplitude_destinations.len();
+            census.executor_handle_count += usize::from(family.executor_handle.is_some());
+            census.amplitude_destination_count += family
+                .amplitude_destinations
+                .iter()
+                .filter(|destination| destination.is_some())
+                .count();
+        }
+        // Query-local traces and embedded lookup keys are deliberately absent
+        // from the compact retained family type. Their zero counters keep that
+        // invariant observable without exposing private family fields.
+        census
+    }
+
+    pub(super) fn clear(&mut self) -> RusticolResult<()> {
+        self.executor.clear_families()?;
+        self.executor.resolver_mut().clear_resolved_bindings();
+        self.pending_family = None;
+        self.last_family = None;
+        self.families.clear();
+        self.pending_contracted_family = None;
+        self.contracted_family = None;
+        self.prepared_grammar = None;
+        self.coupling_policy = None;
+        self.coupling_policy_resolution = None;
+        self.process_preparation_count = 0;
+        #[cfg(test)]
+        {
+            self.process_preparation_census = OnTheFlyProcessPreparationCensusV1::default();
+            self.contracted_max_live_query_outcomes = 0;
+        }
+        self.source_momenta_scratch = Vec::new();
+        self.amplitude_scratch = Vec::new();
+        Ok(())
+    }
+
+    fn current_family(&self) -> Option<&PreparedOnTheFlyLcFamilyV1> {
+        self.pending_family
+            .as_ref()
+            .or_else(|| self.last_family.and_then(|index| self.families.get(index)))
+    }
+
+    fn current_contracted_family(&self) -> Option<&PreparedOnTheFlyContractedFamilyV1> {
+        self.pending_contracted_family
+            .as_ref()
+            .or(self.contracted_family.as_ref())
+    }
+
+    pub(super) fn discard_pending_lc_queries(&mut self) -> RusticolResult<()> {
+        self.executor.discard_pending_family()?;
+        self.executor
+            .resolver_mut()
+            .discard_pending_resolved_bindings();
+        self.pending_family = None;
+        Ok(())
+    }
+
+    pub(super) fn discard_pending_contracted_queries(&mut self) -> RusticolResult<()> {
+        self.executor.discard_pending_family()?;
+        self.executor
+            .resolver_mut()
+            .discard_pending_resolved_bindings();
+        self.pending_contracted_family = None;
+        Ok(())
+    }
+
+    /// Roll back a contracted selection whose executor family may already
+    /// have committed on an earlier tile.  The wrapper deliberately clears
+    /// its public selection cache in the same error path, so both halves of
+    /// the last-family-only identity remain coherent.
+    pub(super) fn abort_contracted_selection(&mut self) -> RusticolResult<()> {
+        self.executor.clear_families()?;
+        self.executor.resolver_mut().clear_resolved_bindings();
+        self.pending_contracted_family = None;
+        self.contracted_family = None;
+        Ok(())
+    }
+
+    #[cfg(test)]
+    pub(super) fn fail_contracted_execution_at_for_test(&mut self, attempt: Option<usize>) {
+        self.contracted_test_execution_attempt = 0;
+        self.contracted_test_fail_execution_at = attempt;
+    }
+
+    #[cfg(test)]
+    pub(super) const fn contracted_max_live_query_outcomes_for_test(&self) -> usize {
+        self.contracted_max_live_query_outcomes
+    }
+
+    fn promote_pending_family(&mut self) -> RusticolResult<()> {
+        let Some(family) = self.pending_family.as_ref() else {
+            return Ok(());
+        };
+        let executor_handle = if family.census.is_some() {
+            let handle = self.executor.active_retained_handle().ok_or_else(|| {
+                RusticolError::internal(
+                    "successful on-the-fly family has no retained executor handle",
+                )
+            })?;
+            self.executor
+                .resolver_mut()
+                .commit_pending_resolved_bindings()?;
+            Some(handle)
+        } else {
+            // A structural-zero family replaces executable state only after
+            // its evaluation succeeds. Row-table owners disappear before the
+            // semantic bindings to their prepared contexts.
+            self.executor.clear_families()?;
+            self.executor.resolver_mut().clear_resolved_bindings();
+            None
+        };
+        let mut family = self
+            .pending_family
+            .take()
+            .expect("validated on-the-fly pending family disappeared during promotion");
+        family.executor_handle = executor_handle;
+        self.retain_family(family);
+        Ok(())
+    }
+
+    fn retain_family(&mut self, family: PreparedOnTheFlyLcFamilyV1) {
+        self.families.clear();
+        self.families.push(family);
+        self.last_family = Some(0);
+    }
+
+    fn promote_pending_contracted_family(&mut self) -> RusticolResult<()> {
+        let Some(family) = self.pending_contracted_family.as_ref() else {
+            return Ok(());
+        };
+        let executor_handle = if family.census.is_some() {
+            let handle = self.executor.active_retained_handle().ok_or_else(|| {
+                RusticolError::internal(
+                    "successful on-the-fly contracted family has no retained executor handle",
+                )
+            })?;
+            self.executor
+                .resolver_mut()
+                .commit_pending_resolved_bindings()?;
+            Some(handle)
+        } else {
+            self.executor.clear_families()?;
+            self.executor.resolver_mut().clear_resolved_bindings();
+            None
+        };
+        let mut family = self
+            .pending_contracted_family
+            .take()
+            .expect("validated on-the-fly contracted pending family disappeared during promotion");
+        family.executor_handle = executor_handle;
+        self.contracted_family = Some(family);
+        Ok(())
+    }
+
+    fn prepare_runtime_parameters(&mut self, runtime_values: &[f64]) -> RusticolResult<()> {
+        if runtime_values.iter().any(|value| !value.is_finite()) {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly runtime parameter value is not finite",
+            ));
+        }
+        if self.runtime_parameter_values.as_ref() == runtime_values {
+            return Ok(());
+        }
+        let prepared = projected_prepared_parameter_values(
+            &self.parameter_defaults,
+            &self.parameter_projection,
+            runtime_values,
+        )?;
+        self.executor.set_parameters(&prepared)?;
+        self.runtime_parameter_values = runtime_values.to_vec().into_boxed_slice();
+        Ok(())
+    }
+
+    fn ensure_point_capacity(&mut self, point_count: u32) -> RusticolResult<()> {
+        let Some(prepared) = self.current_family() else {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly evaluation requires prepared LC queries",
+            ));
+        };
+        if point_count <= prepared.logical_point_capacity {
+            return Ok(());
+        }
+        self.reuse_current_lc_queries(point_count)?;
+        Ok(())
+    }
+
+    fn ensure_amplitude_scratch(&mut self, point_count: u32) -> RusticolResult<usize> {
+        let query_count = self
+            .current_family()
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly evaluation requires prepared LC queries",
+                )
+            })?
+            .amplitude_destinations
+            .iter()
+            .filter(|destination| destination.is_some())
+            .count();
+        let required = query_count
+            .checked_mul(point_count as usize)
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("on-the-fly amplitude shape exceeds usize")
+            })?;
+        if self.amplitude_scratch.len() < required {
+            self.amplitude_scratch
+                .try_reserve_exact(required - self.amplitude_scratch.len())
+                .map_err(|error| {
+                    RusticolError::invalid_argument(format!(
+                        "on-the-fly amplitude workspace allocation failed: {error}"
+                    ))
+                })?;
+            self.amplitude_scratch.resize(required, (0.0, 0.0));
+        }
+        Ok(required)
+    }
+
+    fn execute_amplitudes(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+    ) -> RusticolResult<(
+        OnTheFlyQueryFamilyExecutionReportV1,
+        Duration,
+        Duration,
+        Duration,
+    )> {
+        let candidate_pending = self.pending_family.is_some();
+        let result =
+            self.execute_amplitudes_inner(point_major_momenta, point_count, runtime_parameters);
+        if result.is_err() && candidate_pending {
+            self.discard_pending_lc_queries()?;
+        }
+        result
+    }
+
+    fn execute_amplitudes_inner(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+    ) -> RusticolResult<(
+        OnTheFlyQueryFamilyExecutionReportV1,
+        Duration,
+        Duration,
+        Duration,
+    )> {
+        if point_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly evaluation requires at least one point",
+            ));
+        }
+        self.ensure_point_capacity(point_count)?;
+
+        let parameter_started = Instant::now();
+        self.prepare_runtime_parameters(runtime_parameters)?;
+        let parameter_setup = parameter_started.elapsed();
+
+        if self
+            .current_family()
+            .is_some_and(|family| family.census.is_none())
+        {
+            let cache_hit = self.pending_family.is_none();
+            self.promote_pending_family()?;
+            return Ok((
+                OnTheFlyQueryFamilyExecutionReportV1 {
+                    cache_hit,
+                    ..OnTheFlyQueryFamilyExecutionReportV1::default()
+                },
+                parameter_setup,
+                Duration::ZERO,
+                Duration::ZERO,
+            ));
+        }
+
+        let input_started = Instant::now();
+        let source_major_len = on_the_fly_source_major_momenta_into(
+            &self.seed,
+            point_major_momenta,
+            point_count,
+            4,
+            &mut self.source_momenta_scratch,
+        )?;
+        let input_setup = input_started.elapsed();
+
+        let output_len = self.ensure_amplitude_scratch(point_count)?;
+        let execution_started = Instant::now();
+        let report = self.executor.execute_into(
+            &self.source_momenta_scratch[..source_major_len],
+            point_count,
+            &mut self.amplitude_scratch[..output_len],
+        )?;
+        let execution = execution_started.elapsed();
+        // A cold family becomes reusable only after its first successful
+        // prepared-kernel execution.
+        self.promote_pending_family()?;
+        Ok((report, parameter_setup, input_setup, execution))
+    }
+
+    fn execute_amplitudes_unprofiled(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+    ) -> RusticolResult<()> {
+        let candidate_pending = self.pending_family.is_some();
+        let result = self.execute_amplitudes_unprofiled_inner(
+            point_major_momenta,
+            point_count,
+            runtime_parameters,
+        );
+        if result.is_err() && candidate_pending {
+            self.discard_pending_lc_queries()?;
+        }
+        result
+    }
+
+    fn execute_amplitudes_unprofiled_inner(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+    ) -> RusticolResult<()> {
+        if point_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly evaluation requires at least one point",
+            ));
+        }
+        self.ensure_point_capacity(point_count)?;
+        self.prepare_runtime_parameters(runtime_parameters)?;
+
+        if self
+            .current_family()
+            .is_some_and(|family| family.census.is_none())
+        {
+            self.promote_pending_family()?;
+            return Ok(());
+        }
+
+        let source_major_len = on_the_fly_source_major_momenta_into(
+            &self.seed,
+            point_major_momenta,
+            point_count,
+            4,
+            &mut self.source_momenta_scratch,
+        )?;
+        let output_len = self.ensure_amplitude_scratch(point_count)?;
+        self.executor.execute_into_unprofiled(
+            &self.source_momenta_scratch[..source_major_len],
+            point_count,
+            &mut self.amplitude_scratch[..output_len],
+        )?;
+        // A cold family becomes reusable only after its first successful
+        // prepared-kernel execution.
+        self.promote_pending_family()?;
+        Ok(())
+    }
+
+    fn ensure_contracted_point_capacity(&mut self, point_count: u32) -> RusticolResult<()> {
+        let Some(prepared) = self.current_contracted_family() else {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly contracted evaluation requires prepared queries",
+            ));
+        };
+        if point_count > prepared.logical_point_capacity {
+            self.reuse_current_contracted_queries(point_count)?;
+        }
+        Ok(())
+    }
+
+    fn ensure_contracted_amplitude_scratch(&mut self, point_count: u32) -> RusticolResult<usize> {
+        let query_count = self
+            .current_contracted_family()
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly contracted evaluation requires prepared queries",
+                )
+            })?
+            .amplitude_destinations
+            .iter()
+            .filter(|destination| destination.is_some())
+            .count();
+        let required = query_count
+            .checked_mul(point_count as usize)
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly contracted amplitude shape exceeds usize",
+                )
+            })?;
+        if self.amplitude_scratch.len() < required {
+            self.amplitude_scratch
+                .try_reserve_exact(required - self.amplitude_scratch.len())
+                .map_err(|error| {
+                    RusticolError::invalid_argument(format!(
+                        "on-the-fly contracted amplitude workspace allocation failed: {error}"
+                    ))
+                })?;
+            self.amplitude_scratch.resize(required, (0.0, 0.0));
+        }
+        Ok(required)
+    }
+
+    fn execute_contracted_amplitudes(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+    ) -> RusticolResult<(
+        OnTheFlyQueryFamilyExecutionReportV1,
+        Duration,
+        Duration,
+        Duration,
+    )> {
+        #[cfg(test)]
+        {
+            let attempt = self.contracted_test_execution_attempt;
+            self.contracted_test_execution_attempt = self
+                .contracted_test_execution_attempt
+                .checked_add(1)
+                .expect("contracted test execution-attempt count exceeds usize");
+            if self.contracted_test_fail_execution_at == Some(attempt) {
+                return Err(RusticolError::internal(
+                    "injected on-the-fly contracted tile failure",
+                ));
+            }
+        }
+        let candidate_pending = self.pending_contracted_family.is_some();
+        let result = self.execute_contracted_amplitudes_inner(
+            point_major_momenta,
+            point_count,
+            runtime_parameters,
+        );
+        if result.is_err() && candidate_pending {
+            self.discard_pending_contracted_queries()?;
+        }
+        result
+    }
+
+    fn execute_contracted_amplitudes_inner(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+    ) -> RusticolResult<(
+        OnTheFlyQueryFamilyExecutionReportV1,
+        Duration,
+        Duration,
+        Duration,
+    )> {
+        if point_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly contracted evaluation requires at least one point",
+            ));
+        }
+        self.ensure_contracted_point_capacity(point_count)?;
+
+        let parameter_started = Instant::now();
+        self.prepare_runtime_parameters(runtime_parameters)?;
+        let parameter_setup = parameter_started.elapsed();
+        if self
+            .current_contracted_family()
+            .is_some_and(|family| family.census.is_none())
+        {
+            let cache_hit = self.pending_contracted_family.is_none();
+            self.promote_pending_contracted_family()?;
+            return Ok((
+                OnTheFlyQueryFamilyExecutionReportV1 {
+                    cache_hit,
+                    ..OnTheFlyQueryFamilyExecutionReportV1::default()
+                },
+                parameter_setup,
+                Duration::ZERO,
+                Duration::ZERO,
+            ));
+        }
+
+        let input_started = Instant::now();
+        let source_major_len = on_the_fly_source_major_momenta_into(
+            &self.seed,
+            point_major_momenta,
+            point_count,
+            4,
+            &mut self.source_momenta_scratch,
+        )?;
+        let input_setup = input_started.elapsed();
+        let output_len = self.ensure_contracted_amplitude_scratch(point_count)?;
+        let execution_started = Instant::now();
+        let report = self.executor.execute_into(
+            &self.source_momenta_scratch[..source_major_len],
+            point_count,
+            &mut self.amplitude_scratch[..output_len],
+        )?;
+        let execution = execution_started.elapsed();
+        self.promote_pending_contracted_family()?;
+        Ok((report, parameter_setup, input_setup, execution))
+    }
+
+    fn execute_contracted_amplitudes_unprofiled(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+    ) -> RusticolResult<()> {
+        #[cfg(test)]
+        {
+            let attempt = self.contracted_test_execution_attempt;
+            self.contracted_test_execution_attempt = self
+                .contracted_test_execution_attempt
+                .checked_add(1)
+                .expect("contracted test execution-attempt count exceeds usize");
+            if self.contracted_test_fail_execution_at == Some(attempt) {
+                return Err(RusticolError::internal(
+                    "injected on-the-fly contracted tile failure",
+                ));
+            }
+        }
+        let candidate_pending = self.pending_contracted_family.is_some();
+        let result = self.execute_contracted_amplitudes_unprofiled_inner(
+            point_major_momenta,
+            point_count,
+            runtime_parameters,
+        );
+        if result.is_err() && candidate_pending {
+            self.discard_pending_contracted_queries()?;
+        }
+        result
+    }
+
+    fn execute_contracted_amplitudes_unprofiled_inner(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+    ) -> RusticolResult<()> {
+        if point_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly contracted evaluation requires at least one point",
+            ));
+        }
+        self.ensure_contracted_point_capacity(point_count)?;
+        self.prepare_runtime_parameters(runtime_parameters)?;
+        if self
+            .current_contracted_family()
+            .is_some_and(|family| family.census.is_none())
+        {
+            self.promote_pending_contracted_family()?;
+            return Ok(());
+        }
+
+        let source_major_len = on_the_fly_source_major_momenta_into(
+            &self.seed,
+            point_major_momenta,
+            point_count,
+            4,
+            &mut self.source_momenta_scratch,
+        )?;
+        let output_len = self.ensure_contracted_amplitude_scratch(point_count)?;
+        self.executor.execute_into_unprofiled(
+            &self.source_momenta_scratch[..source_major_len],
+            point_count,
+            &mut self.amplitude_scratch[..output_len],
+        )?;
+        self.promote_pending_contracted_family()?;
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn reduce_current_contracted_color(
+        &mut self,
+        contraction: &RecurrenceColorContraction,
+        point_count: usize,
+        helicity_count: usize,
+        normalization_factor: f64,
+        accumulate: impl FnMut(usize, usize, f64),
+    ) -> RusticolResult<()> {
+        let Self {
+            contracted_family,
+            pending_contracted_family,
+            amplitude_scratch,
+            symmetric_group_color_workspace,
+            ..
+        } = self;
+        let family = pending_contracted_family
+            .as_ref()
+            .or(contracted_family.as_ref())
+            .ok_or_else(|| {
+                RusticolError::internal(
+                    "successful on-the-fly contracted execution lost its prepared family",
+                )
+            })?;
+        reduce_contracted_color(
+            contraction,
+            symmetric_group_color_workspace.as_mut(),
+            &family.amplitude_destinations,
+            amplitude_scratch,
+            point_count,
+            helicity_count,
+            family.structural_color_count,
+            normalization_factor,
+            accumulate,
+        )
+    }
+
+    /// Evaluate a contracted NLC/full color metric without constructing a
+    /// diagnostic report or reading phase clocks.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn run_contracted_f64_into_unprofiled(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+        normalization_factor: f64,
+        contraction: &RecurrenceColorContraction,
+        point_tile_size: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        validate_contracted_run_shape(
+            point_major_momenta,
+            point_count,
+            normalization_factor,
+            contraction,
+            point_tile_size,
+            output.len(),
+            point_count as usize,
+        )?;
+        output.fill(0.0);
+        let point_stride = point_major_momenta.len() / point_count as usize;
+        let helicity_count = self
+            .current_contracted_family()
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly contracted total requires prepared queries",
+                )
+            })?
+            .helicity_ordinals
+            .len();
+        for point_start in (0..point_count as usize).step_by(point_tile_size) {
+            let tile_count = point_tile_size.min(point_count as usize - point_start);
+            let input_start = point_start * point_stride;
+            let input_end = input_start + tile_count * point_stride;
+            self.execute_contracted_amplitudes_unprofiled(
+                &point_major_momenta[input_start..input_end],
+                u32::try_from(tile_count).map_err(|_| {
+                    RusticolError::invalid_argument("on-the-fly contracted tile count exceeds u32")
+                })?,
+                runtime_parameters,
+            )?;
+            self.reduce_current_contracted_color(
+                contraction,
+                tile_count,
+                helicity_count,
+                normalization_factor,
+                |point, _helicity, value| output[point_start + point] += value,
+            )?;
+        }
+        Ok(())
+    }
+
+    /// Evaluate a contracted NLC/full color metric into one total per point.
+    /// The manifest tile size bounds both the prepared numeric family and the
+    /// H x S complex-amplitude scratch.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn run_contracted_f64_into(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+        normalization_factor: f64,
+        contraction: &RecurrenceColorContraction,
+        point_tile_size: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<(OnTheFlyQueryFamilyExecutionReportV1, RuntimeProfile)> {
+        validate_contracted_run_shape(
+            point_major_momenta,
+            point_count,
+            normalization_factor,
+            contraction,
+            point_tile_size,
+            output.len(),
+            point_count as usize,
+        )?;
+        output.fill(0.0);
+        let total_started = Instant::now();
+        let mut aggregate_profile = RuntimeProfile::default();
+        let mut aggregate_report = None;
+        let point_stride = point_major_momenta.len() / point_count as usize;
+        let helicity_count = self
+            .current_contracted_family()
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly contracted total requires prepared queries",
+                )
+            })?
+            .helicity_ordinals
+            .len();
+        for point_start in (0..point_count as usize).step_by(point_tile_size) {
+            let tile_count = point_tile_size.min(point_count as usize - point_start);
+            let input_start = point_start.checked_mul(point_stride).ok_or_else(|| {
+                RusticolError::invalid_argument("on-the-fly contracted tile offset exceeds usize")
+            })?;
+            let input_end = input_start
+                .checked_add(tile_count.checked_mul(point_stride).ok_or_else(|| {
+                    RusticolError::invalid_argument(
+                        "on-the-fly contracted tile shape exceeds usize",
+                    )
+                })?)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(
+                        "on-the-fly contracted tile range exceeds usize",
+                    )
+                })?;
+            let tile_started = Instant::now();
+            let (report, parameter_setup, input_setup, execution) = self
+                .execute_contracted_amplitudes(
+                    &point_major_momenta[input_start..input_end],
+                    u32::try_from(tile_count).map_err(|_| {
+                        RusticolError::invalid_argument(
+                            "on-the-fly contracted tile count exceeds u32",
+                        )
+                    })?,
+                    runtime_parameters,
+                )?;
+            let reduction_started = Instant::now();
+            self.reduce_current_contracted_color(
+                contraction,
+                tile_count,
+                helicity_count,
+                normalization_factor,
+                |point, _helicity, value| output[point_start + point] += value,
+            )?;
+            let reduction = reduction_started.elapsed();
+            let tile_profile = profile_from_report(
+                tile_started.elapsed(),
+                parameter_setup,
+                input_setup,
+                execution,
+                reduction,
+                input_end - input_start,
+                u32::try_from(tile_count).expect("validated tile count"),
+                report,
+            );
+            aggregate_profile.add_sector(&tile_profile);
+            merge_execution_report(&mut aggregate_report, report)?;
+        }
+        aggregate_profile.total_s = profile_duration_seconds(total_started.elapsed());
+        Ok((aggregate_report.unwrap_or_default(), aggregate_profile))
+    }
+
+    /// Evaluate contracted values in `[point][selected_helicity][1]` order.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn run_contracted_resolved_f64_into(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+        normalization_factor: f64,
+        contraction: &RecurrenceColorContraction,
+        point_tile_size: usize,
+        helicity_count: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<(OnTheFlyQueryFamilyExecutionReportV1, RuntimeProfile)> {
+        let expected_output = (point_count as usize)
+            .checked_mul(helicity_count)
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly contracted resolved shape exceeds usize",
+                )
+            })?;
+        validate_contracted_run_shape(
+            point_major_momenta,
+            point_count,
+            normalization_factor,
+            contraction,
+            point_tile_size,
+            output.len(),
+            expected_output,
+        )?;
+        let prepared_helicity_count = self
+            .current_contracted_family()
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly contracted resolved evaluation requires prepared queries",
+                )
+            })?
+            .helicity_ordinals
+            .len();
+        if helicity_count != prepared_helicity_count {
+            return Err(RusticolError::integrity(
+                "on-the-fly contracted resolved helicity shape disagrees with its prepared family",
+            ));
+        }
+        output.fill(0.0);
+        let total_started = Instant::now();
+        let mut aggregate_profile = RuntimeProfile::default();
+        let mut aggregate_report = None;
+        let point_stride = point_major_momenta.len() / point_count as usize;
+        for point_start in (0..point_count as usize).step_by(point_tile_size) {
+            let tile_count = point_tile_size.min(point_count as usize - point_start);
+            let input_start = point_start * point_stride;
+            let input_end = input_start + tile_count * point_stride;
+            let tile_started = Instant::now();
+            let (report, parameter_setup, input_setup, execution) = self
+                .execute_contracted_amplitudes(
+                    &point_major_momenta[input_start..input_end],
+                    u32::try_from(tile_count).map_err(|_| {
+                        RusticolError::invalid_argument(
+                            "on-the-fly contracted tile count exceeds u32",
+                        )
+                    })?,
+                    runtime_parameters,
+                )?;
+            let reduction_started = Instant::now();
+            self.reduce_current_contracted_color(
+                contraction,
+                tile_count,
+                helicity_count,
+                normalization_factor,
+                |point, helicity, value| {
+                    let destination = (point_start + point) * helicity_count + helicity;
+                    output[destination] += value;
+                },
+            )?;
+            let reduction = reduction_started.elapsed();
+            let tile_profile = profile_from_report(
+                tile_started.elapsed(),
+                parameter_setup,
+                input_setup,
+                execution,
+                reduction,
+                input_end - input_start,
+                u32::try_from(tile_count).expect("validated tile count"),
+                report,
+            );
+            aggregate_profile.add_sector(&tile_profile);
+            merge_execution_report(&mut aggregate_report, report)?;
+        }
+        aggregate_profile.total_s = profile_duration_seconds(total_started.elapsed());
+        Ok((aggregate_report.unwrap_or_default(), aggregate_profile))
+    }
+
+    /// Evaluate total LC matrix elements without constructing a diagnostic
+    /// report or reading phase clocks.
+    pub(super) fn run_f64_into_unprofiled(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+        normalization_factor: f64,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        if output.len() != point_count as usize
+            || !normalization_factor.is_finite()
+            || normalization_factor < 0.0
+        {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly total output shape or normalization is invalid",
+            ));
+        }
+        self.execute_amplitudes_unprofiled(point_major_momenta, point_count, runtime_parameters)?;
+        output.fill(0.0);
+        let family = self
+            .current_family()
+            .expect("successful on-the-fly execution lost its prepared family");
+        reduce_total_into(
+            &family.requests,
+            &family.amplitude_destinations,
+            &self.amplitude_scratch,
+            point_count as usize,
+            normalization_factor,
+            output,
+        )?;
+        Ok(())
+    }
+
+    /// Evaluate total LC matrix elements into the same one-value-per-point
+    /// shape consumed by the existing `Runtime.evaluate_into` path.
+    pub(super) fn run_f64_into(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+        normalization_factor: f64,
+        output: &mut [f64],
+    ) -> RusticolResult<(OnTheFlyQueryFamilyExecutionReportV1, RuntimeProfile)> {
+        if output.len() != point_count as usize
+            || !normalization_factor.is_finite()
+            || normalization_factor < 0.0
+        {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly total output shape or normalization is invalid",
+            ));
+        }
+        let total_started = Instant::now();
+        let (report, parameter_setup, input_setup, execution) =
+            self.execute_amplitudes(point_major_momenta, point_count, runtime_parameters)?;
+        output.fill(0.0);
+        let reduction_started = Instant::now();
+        let family = self
+            .current_family()
+            .expect("successful on-the-fly execution lost its prepared family");
+        reduce_total_into(
+            &family.requests,
+            &family.amplitude_destinations,
+            &self.amplitude_scratch,
+            point_count as usize,
+            normalization_factor,
+            output,
+        )?;
+        let reduction = reduction_started.elapsed();
+        let profile = profile_from_report(
+            total_started.elapsed(),
+            parameter_setup,
+            input_setup,
+            execution,
+            reduction,
+            point_major_momenta.len(),
+            point_count,
+            report,
+        );
+        Ok((report, profile))
+    }
+
+    /// Evaluate resolved LC values in the established
+    /// `[point][helicity][color]` order without creating a dense flow table.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn run_resolved_f64_into(
+        &mut self,
+        point_major_momenta: &[f64],
+        point_count: u32,
+        runtime_parameters: &[f64],
+        normalization_factor: f64,
+        helicity_count: usize,
+        color_count: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<(OnTheFlyQueryFamilyExecutionReportV1, RuntimeProfile)> {
+        if !normalization_factor.is_finite() || normalization_factor < 0.0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly resolved normalization is invalid",
+            ));
+        }
+        let layout =
+            LcResolvedOutputLayout::new(point_count as usize, helicity_count, color_count)?;
+        if output.len() != layout.output_len()? {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly resolved output has the wrong size",
+            ));
+        }
+        let requests = self.current_family().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "on-the-fly resolved evaluation requires prepared LC queries",
+            )
+        })?;
+        for target in requests
+            .requests
+            .iter()
+            .flat_map(|request| request.reduction_targets.iter())
+        {
+            if target.helicity_position >= helicity_count || target.color_position >= color_count {
+                return Err(RusticolError::integrity(
+                    "on-the-fly resolved target is outside the selected public axes",
+                ));
+            }
+        }
+
+        let total_started = Instant::now();
+        let (report, parameter_setup, input_setup, execution) =
+            self.execute_amplitudes(point_major_momenta, point_count, runtime_parameters)?;
+        output.fill(0.0);
+        let reduction_started = Instant::now();
+        let family = self
+            .current_family()
+            .expect("successful on-the-fly execution lost its prepared family");
+        reduce_resolved_into(
+            &family.requests,
+            &family.amplitude_destinations,
+            &self.amplitude_scratch,
+            point_count as usize,
+            normalization_factor,
+            layout,
+            output,
+        )?;
+        let reduction = reduction_started.elapsed();
+        let profile = profile_from_report(
+            total_started.elapsed(),
+            parameter_setup,
+            input_setup,
+            execution,
+            reduction,
+            point_major_momenta.len(),
+            point_count,
+            report,
+        );
+        Ok((report, profile))
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn validate_contracted_run_shape(
+    point_major_momenta: &[f64],
+    point_count: u32,
+    normalization_factor: f64,
+    contraction: &RecurrenceColorContraction,
+    point_tile_size: usize,
+    actual_output_len: usize,
+    expected_output_len: usize,
+) -> RusticolResult<()> {
+    if point_count == 0
+        || point_tile_size == 0
+        || !point_major_momenta
+            .len()
+            .is_multiple_of(point_count as usize)
+        || !normalization_factor.is_finite()
+        || normalization_factor < 0.0
+        || actual_output_len != expected_output_len
+    {
+        return Err(RusticolError::invalid_argument(
+            "on-the-fly contracted input, output, tile, or normalization shape is invalid",
+        ));
+    }
+    let supported_reducer = matches!(
+        contraction.runtime_reducer(),
+        None | Some(RuntimeColorContractionReducer::SymmetricGroupFourier(_))
+    );
+    if contraction.component_count() != 1
+        || contraction.destination_count() == 0
+        || !supported_reducer
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly contracted execution requires a supported one-component metric",
+        ));
+    }
+    Ok(())
+}
+
+/// Apply A-dagger C A independently for each selected physical helicity.
+/// Structural-zero amplitudes are represented by absent projection entries
+/// and therefore make every touching bilinear term exactly zero.
+#[allow(clippy::too_many_arguments)]
+fn reduce_contracted_color(
+    contraction: &RecurrenceColorContraction,
+    symmetric_group_workspace: Option<&mut RuntimeSymmetricGroupColorWorkspace>,
+    amplitude_destinations: &[Option<usize>],
+    amplitudes: &[(f64, f64)],
+    point_count: usize,
+    helicity_count: usize,
+    structural_color_count: usize,
+    normalization_factor: f64,
+    accumulate: impl FnMut(usize, usize, f64),
+) -> RusticolResult<()> {
+    let projection_len = helicity_count
+        .checked_mul(structural_color_count)
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("on-the-fly contracted projection shape exceeds usize")
+        })?;
+    if amplitude_destinations.len() != projection_len {
+        return Err(RusticolError::integrity(
+            "on-the-fly contracted amplitude projection has the wrong shape",
+        ));
+    }
+    match contraction.runtime_reducer() {
+        Some(RuntimeColorContractionReducer::SymmetricGroupFourier(reducer)) => {
+            let workspace = symmetric_group_workspace.ok_or_else(|| {
+                RusticolError::integrity("on-the-fly symmetric-group color workspace is absent")
+            })?;
+            return reduce_symmetric_group_contracted_color(
+                contraction,
+                reducer,
+                workspace,
+                amplitude_destinations,
+                amplitudes,
+                point_count,
+                helicity_count,
+                structural_color_count,
+                normalization_factor,
+                accumulate,
+            );
+        }
+        Some(RuntimeColorContractionReducer::Walsh(_)) => {
+            return Err(RusticolError::integrity(
+                "on-the-fly contracted execution does not support Walsh color storage",
+            ));
+        }
+        None => {}
+    }
+    reduce_direct_contracted_color(
+        contraction.runtime_entries(),
+        amplitude_destinations,
+        amplitudes,
+        point_count,
+        helicity_count,
+        structural_color_count,
+        normalization_factor,
+        accumulate,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn reduce_direct_contracted_color(
+    entries: impl IntoIterator<Item = RuntimeColorContractionEntry>,
+    amplitude_destinations: &[Option<usize>],
+    amplitudes: &[(f64, f64)],
+    point_count: usize,
+    helicity_count: usize,
+    structural_color_count: usize,
+    normalization_factor: f64,
+    mut accumulate: impl FnMut(usize, usize, f64),
+) -> RusticolResult<()> {
+    if amplitude_destinations.len()
+        != helicity_count
+            .checked_mul(structural_color_count)
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly direct contracted projection shape exceeds usize",
+                )
+            })?
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly direct contracted amplitude projection has the wrong shape",
+        ));
+    }
+    for entry in entries {
+        let left_color = usize::try_from(entry.left_destination_id).map_err(|_| {
+            RusticolError::artifact("on-the-fly contracted left destination exceeds usize")
+        })?;
+        let right_color = usize::try_from(entry.right_destination_id).map_err(|_| {
+            RusticolError::artifact("on-the-fly contracted right destination exceeds usize")
+        })?;
+        if left_color >= structural_color_count || right_color >= structural_color_count {
+            return Err(RusticolError::integrity(
+                "on-the-fly contracted metric destination is outside its structural basis",
+            ));
+        }
+        for helicity in 0..helicity_count {
+            let base = helicity * structural_color_count;
+            let (Some(left_destination), Some(right_destination)) = (
+                amplitude_destinations[base + left_color],
+                amplitude_destinations[base + right_color],
+            ) else {
+                continue;
+            };
+            let left_base = left_destination.checked_mul(point_count).ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly contracted left amplitude offset exceeds usize",
+                )
+            })?;
+            let right_base = right_destination.checked_mul(point_count).ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "on-the-fly contracted right amplitude offset exceeds usize",
+                )
+            })?;
+            if left_base
+                .checked_add(point_count)
+                .is_none_or(|end| end > amplitudes.len())
+                || right_base
+                    .checked_add(point_count)
+                    .is_none_or(|end| end > amplitudes.len())
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly contracted amplitude destination is absent",
+                ));
+            }
+            for point in 0..point_count {
+                let (left_re, left_im) = amplitudes[left_base + point];
+                let (right_re, right_im) = amplitudes[right_base + point];
+                let value = normalization_factor
+                    * entry.contract_real_bilinear(left_re, left_im, right_re, right_im);
+                accumulate(point, helicity, value);
+            }
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn reduce_symmetric_group_contracted_color(
+    contraction: &RecurrenceColorContraction,
+    reducer: &crate::recurrence::RuntimeSymmetricGroupColorContraction,
+    workspace: &mut RuntimeSymmetricGroupColorWorkspace,
+    amplitude_destinations: &[Option<usize>],
+    amplitudes: &[(f64, f64)],
+    point_count: usize,
+    helicity_count: usize,
+    structural_color_count: usize,
+    normalization_factor: f64,
+    mut accumulate: impl FnMut(usize, usize, f64),
+) -> RusticolResult<()> {
+    if reducer.local_group_count() != contraction.local_group_count() as usize
+        || contraction.destination_by_group().len() != structural_color_count
+        || reducer.local_group_count() != structural_color_count
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly symmetric-group reducer disagrees with its structural owner basis",
+        ));
+    }
+    for helicity in 0..helicity_count {
+        let projection_base = helicity * structural_color_count;
+        reducer.reduce_lanes(workspace, point_count, |local_group, point| {
+            // Contracted query preparation already inverted the authenticated
+            // owner projection and retained this table in normalized group
+            // order.  Applying destination_by_group here a second time would
+            // silently contract A(P^2 g) for a non-involutive permutation.
+            let Some(amplitude_destination) = amplitude_destinations[projection_base + local_group]
+            else {
+                return Ok((0.0, 0.0));
+            };
+            let amplitude_index = amplitude_destination
+                .checked_mul(point_count)
+                .and_then(|base| base.checked_add(point))
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(
+                        "on-the-fly symmetric-group amplitude offset exceeds usize",
+                    )
+                })?;
+            amplitudes.get(amplitude_index).copied().ok_or_else(|| {
+                RusticolError::integrity(
+                    "on-the-fly symmetric-group amplitude destination is absent",
+                )
+            })
+        })?;
+        for (point, value) in workspace.reduced(point_count)?.iter().copied().enumerate() {
+            accumulate(point, helicity, normalization_factor * value);
+        }
+    }
+    Ok(())
+}
+
+fn merge_execution_report(
+    aggregate: &mut Option<OnTheFlyQueryFamilyExecutionReportV1>,
+    report: OnTheFlyQueryFamilyExecutionReportV1,
+) -> RusticolResult<()> {
+    let Some(target) = aggregate.as_mut() else {
+        *aggregate = Some(report);
+        return Ok(());
+    };
+    target.cache_hit &= report.cache_hit;
+    macro_rules! checked_add_report_field {
+        ($field:ident) => {
+            target.$field = target.$field.checked_add(report.$field).ok_or_else(|| {
+                RusticolError::invalid_argument(concat!(
+                    "on-the-fly contracted execution report ",
+                    stringify!($field),
+                    " exceeds u32"
+                ))
+            })?;
+        };
+    }
+    checked_add_report_field!(source_calls);
+    checked_add_report_field!(source_rows);
+    checked_add_report_field!(contribution_calls);
+    checked_add_report_field!(contribution_rows);
+    checked_add_report_field!(finalization_calls);
+    checked_add_report_field!(finalization_rows);
+    checked_add_report_field!(closure_calls);
+    checked_add_report_field!(closure_rows);
+    Ok(())
+}
+
+fn reduce_total_into(
+    requests: &[OnTheFlyLcQueryRequestV1],
+    amplitude_destinations: &[Option<usize>],
+    amplitudes: &[(f64, f64)],
+    point_count: usize,
+    normalization_factor: f64,
+    output: &mut [f64],
+) -> RusticolResult<()> {
+    if amplitude_destinations.len() != requests.len() {
+        return Err(RusticolError::integrity(
+            "on-the-fly amplitude projection has the wrong request count",
+        ));
+    }
+    for (request, destination) in requests.iter().zip(amplitude_destinations) {
+        let Some(destination) = *destination else {
+            continue;
+        };
+        let base = destination.checked_mul(point_count).ok_or_else(|| {
+            RusticolError::invalid_argument("on-the-fly amplitude destination offset exceeds usize")
+        })?;
+        let end = base.checked_add(point_count).ok_or_else(|| {
+            RusticolError::invalid_argument("on-the-fly amplitude range exceeds usize")
+        })?;
+        if end > amplitudes.len() {
+            return Err(RusticolError::integrity(
+                "on-the-fly amplitude destination is absent",
+            ));
+        }
+        let weight = request.total_coefficient() * normalization_factor;
+        accumulate_lc_diagonal_amplitude(
+            point_count,
+            weight,
+            |point| amplitudes[base + point],
+            |point, value| output[point] += value,
+        );
+    }
+    Ok(())
+}
+
+fn reduce_resolved_into(
+    requests: &[OnTheFlyLcQueryRequestV1],
+    amplitude_destinations: &[Option<usize>],
+    amplitudes: &[(f64, f64)],
+    point_count: usize,
+    normalization_factor: f64,
+    layout: LcResolvedOutputLayout,
+    output: &mut [f64],
+) -> RusticolResult<()> {
+    if amplitude_destinations.len() != requests.len() {
+        return Err(RusticolError::integrity(
+            "on-the-fly amplitude projection has the wrong request count",
+        ));
+    }
+    for (request, destination) in requests.iter().zip(amplitude_destinations) {
+        let Some(destination) = *destination else {
+            continue;
+        };
+        let base = destination.checked_mul(point_count).ok_or_else(|| {
+            RusticolError::invalid_argument("on-the-fly amplitude destination offset exceeds usize")
+        })?;
+        let end = base.checked_add(point_count).ok_or_else(|| {
+            RusticolError::invalid_argument("on-the-fly amplitude range exceeds usize")
+        })?;
+        if end > amplitudes.len() {
+            return Err(RusticolError::integrity(
+                "on-the-fly amplitude destination is absent",
+            ));
+        }
+        for target in &request.reduction_targets {
+            let weight = target.coefficient * normalization_factor;
+            accumulate_lc_diagonal_amplitude(
+                point_count,
+                weight,
+                |point| amplitudes[base + point],
+                |point, value| {
+                    let target_index = layout
+                        .index(point, target.helicity_position, target.color_position)
+                        .expect("validated on-the-fly resolved coordinate");
+                    output[target_index] += value;
+                },
+            );
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn profile_from_report(
+    total: Duration,
+    parameter_setup: Duration,
+    input_setup: Duration,
+    execution: Duration,
+    reduction: Duration,
+    momentum_scalar_count: usize,
+    point_count: u32,
+    report: OnTheFlyQueryFamilyExecutionReportV1,
+) -> RuntimeProfile {
+    let calls = u64::from(report.source_calls)
+        + u64::from(report.contribution_calls)
+        + u64::from(report.finalization_calls)
+        + u64::from(report.closure_calls);
+    let rows = u64::from(report.source_rows)
+        + u64::from(report.contribution_rows)
+        + u64::from(report.finalization_rows)
+        + u64::from(report.closure_rows);
+    direct_profile_from_delta(
+        total,
+        parameter_setup,
+        input_setup,
+        reduction,
+        DirectProfileDelta {
+            direct_execution: execution,
+            execution: DirectExecutionCounters {
+                source_calls: u64::from(report.source_calls),
+                source_rows: u64::from(report.source_rows),
+                contribution_calls: u64::from(report.contribution_calls),
+                contribution_rows: u64::from(report.contribution_rows),
+                finalization_calls: u64::from(report.finalization_calls),
+                finalization_rows: u64::from(report.finalization_rows),
+                closure_calls: u64::from(report.closure_calls),
+                closure_rows: u64::from(report.closure_rows),
+                ..DirectExecutionCounters::default()
+            },
+            traffic: DirectArenaTrafficCounters {
+                calls,
+                rows,
+                points: calls.saturating_mul(u64::from(point_count)),
+                ..DirectArenaTrafficCounters::default()
+            },
+            activity: DirectRuntimeActivityCounters {
+                momentum_fill_calls: 1,
+                momentum_scalar_values_filled: momentum_scalar_count as u64,
+                schedule_executions: 1,
+                ..DirectRuntimeActivityCounters::default()
+            },
+            ..DirectProfileDelta::default()
+        },
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::recurrence_backend::on_the_fly_adapter_tests::{
+        direct_catalog, prepared_pool, source_domains,
+    };
+    use super::*;
+    use crate::recurrence::CheckedTableRange;
+    use crate::recurrence::SemanticDigest;
+    use crate::recurrence::on_the_fly::{OnTheFlyLcSelectorV1, scalar_adapter_test_seed};
+    use crate::recurrence::template::{CouplingOrderTermRow, IndexedRangeRow};
+    use crate::recurrence::validated_template_fixture;
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    fn scalar_query() -> DecodedLcQueryV1 {
+        let seed = scalar_adapter_test_seed(digest(1), digest(2), digest(3), digest(4)).unwrap();
+        DecodedLcQueryV1::new(&seed, vec![0, 1], &[0, 0], OnTheFlyLcSelectorV1::Singlet).unwrap()
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    fn scalar_lane_with_threads(query_construction_threads: usize) -> OnTheFlyNativeRuntime {
+        let mut template_input = validated_template_fixture().into_input();
+        template_input.coupling_order_ranges.push(IndexedRangeRow {
+            id: 1,
+            range: CheckedTableRange::new(0, 1),
+        });
+        template_input
+            .coupling_order_terms
+            .push(CouplingOrderTermRow {
+                set_id: 1,
+                name_string_id: 0,
+                power: 1,
+            });
+        let templates = template_input.validate().unwrap();
+        let summary = templates.summary();
+        let direct_digest = digest(40);
+        let direct = direct_catalog(direct_digest);
+        let seed = scalar_adapter_test_seed(
+            summary.compiled_model_digest,
+            summary.catalog_digest,
+            summary.prepared_kernel_pack_digest,
+            direct_digest,
+        )
+        .unwrap();
+        let pool = prepared_pool(&templates, direct_digest);
+        let sources = pool.bind_source_domains(source_domains()).unwrap();
+        let resolver = pool.into_on_the_fly_resolver(sources);
+        let defaults = vec![
+            crate::EagerComplex64::new(0.0, 0.0);
+            usize::try_from(summary.parameter_count).unwrap()
+        ];
+        OnTheFlyNativeRuntime::new(
+            templates,
+            direct,
+            seed,
+            resolver,
+            query_construction_threads,
+            query_construction_threads,
+            defaults,
+            Vec::new(),
+            &[],
+        )
+        .unwrap()
+    }
+
+    fn scalar_lane() -> OnTheFlyNativeRuntime {
+        scalar_lane_with_threads(4)
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    fn scalar_request(lane: &OnTheFlyNativeRuntime, coefficient: f64) -> OnTheFlyLcQueryRequestV1 {
+        let query = DecodedLcQueryV1::new(
+            lane.seed(),
+            vec![0, 1],
+            &[0, 0],
+            OnTheFlyLcSelectorV1::Singlet,
+        )
+        .unwrap();
+        OnTheFlyLcQueryRequestV1::new(
+            query,
+            vec![OnTheFlyLcReductionTargetV1::new(0, 0, coefficient).unwrap()],
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn lc_reduction_targets_reject_nonfinite_or_negative_coefficients() {
+        assert!(OnTheFlyLcReductionTargetV1::new(0, 0, -1.0).is_err());
+        assert!(OnTheFlyLcReductionTargetV1::new(0, 0, f64::NAN).is_err());
+        assert_eq!(
+            OnTheFlyLcReductionTargetV1::new(3, 5, 2.0)
+                .unwrap()
+                .coefficient,
+            2.0
+        );
+    }
+
+    #[test]
+    fn lc_query_rejects_duplicate_resolved_coordinates() {
+        let duplicate = vec![
+            OnTheFlyLcReductionTargetV1::new(2, 3, 1.0).unwrap(),
+            OnTheFlyLcReductionTargetV1::new(2, 3, 2.0).unwrap(),
+        ];
+        assert!(OnTheFlyLcQueryRequestV1::new(scalar_query(), duplicate).is_err());
+    }
+
+    #[test]
+    fn lc_query_rejects_zero_total_reduction_weight() {
+        let zero = vec![OnTheFlyLcReductionTargetV1::new(0, 0, 0.0).unwrap()];
+        assert!(OnTheFlyLcQueryRequestV1::new(scalar_query(), zero).is_err());
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[test]
+    fn serial_and_bounded_parallel_query_construction_match() {
+        let mut serial = scalar_lane_with_threads(1);
+        let mut parallel = scalar_lane_with_threads(4);
+        let serial_requests = [scalar_request(&serial, 1.0), scalar_request(&serial, 2.0)];
+        let parallel_requests = [
+            scalar_request(&parallel, 1.0),
+            scalar_request(&parallel, 2.0),
+        ];
+
+        assert!(!serial.prepare_lc_queries(&serial_requests, 1).unwrap());
+        assert!(!parallel.prepare_lc_queries(&parallel_requests, 1).unwrap());
+        assert_eq!(
+            serial.retained_state_census(),
+            parallel.retained_state_census()
+        );
+
+        let mut serial_value = [f64::NAN];
+        let mut parallel_value = [f64::NAN];
+        serial
+            .run_f64_into(&[0.0; 8], 1, &[], 1.0, &mut serial_value)
+            .unwrap();
+        parallel
+            .run_f64_into(&[0.0; 8], 1, &[], 1.0, &mut parallel_value)
+            .unwrap();
+        assert_eq!(serial_value, parallel_value);
+    }
+
+    #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+    #[test]
+    fn process_preparation_is_lazy_shared_compact_and_clearable() {
+        let mut lane = scalar_lane();
+        assert_eq!(lane.process_preparation_count(), 0);
+        assert_eq!(
+            lane.process_preparation_census(),
+            OnTheFlyProcessPreparationCensusV1::default()
+        );
+        assert_eq!(lane.coupling_policy_census(), None);
+        assert_eq!(lane.coupling_policy_resolution(), None);
+        assert_eq!(lane.retained_family_count(), 0);
+
+        let first = scalar_request(&lane, 1.0);
+        assert!(
+            !lane
+                .prepare_lc_queries(std::slice::from_ref(&first), 1)
+                .unwrap()
+        );
+        assert_eq!(lane.retained_state_census().family_count, 0);
+        assert_eq!(lane.pending_family_count(), 1);
+        assert_eq!(lane.process_preparation_count(), 1);
+        assert_eq!(
+            lane.process_preparation_census(),
+            OnTheFlyProcessPreparationCensusV1 {
+                catalog_validation_count: 1,
+                grammar_preparation_count: 1,
+            }
+        );
+        assert!(lane.coupling_policy_census().is_some());
+        assert!(lane.coupling_policy_resolution().is_some());
+        let mut first_value = [0.0];
+        lane.run_f64_into(&[0.0; 8], 1, &[], 1.0, &mut first_value)
+            .unwrap();
+        // This compact fixture is an authenticated structural-zero query.  It
+        // deliberately exercises the outer retained-family lifecycle without
+        // manufacturing an executor binding that the fixture's prepared pool
+        // does not own; nonzero A -> B -> A executor reuse is covered in the
+        // family executor tests below this public lane.
+        assert_eq!(first_value, [0.0]);
+        assert_eq!(lane.retained_state_census().family_count, 1);
+        assert_eq!(lane.pending_family_count(), 0);
+        assert!(
+            lane.prepare_lc_queries(std::slice::from_ref(&first), 1)
+                .unwrap()
+        );
+
+        let second = scalar_request(&lane, 2.0);
+        assert!(
+            !lane
+                .prepare_lc_queries(std::slice::from_ref(&second), 1)
+                .unwrap()
+        );
+        let mut second_value = [0.0];
+        lane.run_f64_into(&[0.0; 8], 1, &[], 1.0, &mut second_value)
+            .unwrap();
+        assert_eq!(second_value, [2.0 * first_value[0]]);
+
+        assert!(
+            !lane
+                .prepare_lc_queries(std::slice::from_ref(&first), 1)
+                .unwrap()
+        );
+        let mut repeated = [0.0];
+        lane.run_f64_into(&[0.0; 8], 1, &[], 1.0, &mut repeated)
+            .unwrap();
+        assert_eq!(repeated, first_value);
+
+        let batched = [first.clone(), second.clone()];
+        assert!(!lane.prepare_lc_queries(&batched, 1).unwrap());
+        let mut batched_value = [0.0];
+        lane.run_f64_into(&[0.0; 8], 1, &[], 1.0, &mut batched_value)
+            .unwrap();
+        assert_eq!(batched_value, [3.0 * first_value[0]]);
+        assert_eq!(lane.process_preparation_count(), 1);
+        assert_eq!(
+            lane.process_preparation_census(),
+            OnTheFlyProcessPreparationCensusV1 {
+                catalog_validation_count: 1,
+                grammar_preparation_count: 1,
+            }
+        );
+
+        let retained = lane.retained_state_census();
+        assert_eq!(retained.family_count, 1);
+        assert_eq!(retained.request_count, 2);
+        assert_eq!(retained.amplitude_destination_count, 0);
+        assert_eq!(retained.executor_handle_count, 0);
+        assert_eq!(retained.query_local_trace_count, 0);
+        assert_eq!(retained.embedded_lookup_key_count, 0);
+        assert_eq!(lane.pending_family_count(), 0);
+
+        lane.clear().unwrap();
+        assert_eq!(lane.process_preparation_count(), 0);
+        assert_eq!(
+            lane.process_preparation_census(),
+            OnTheFlyProcessPreparationCensusV1::default()
+        );
+        assert_eq!(lane.coupling_policy_census(), None);
+        assert_eq!(lane.coupling_policy_resolution(), None);
+        assert_eq!(
+            lane.retained_state_census(),
+            OnTheFlyRetainedStateCensusV1::default()
+        );
+        assert_eq!(lane.pending_family_count(), 0);
+        assert!(lane.source_momenta_scratch.is_empty());
+        assert_eq!(lane.source_momenta_scratch.capacity(), 0);
+        assert!(lane.amplitude_scratch.is_empty());
+        assert_eq!(lane.amplitude_scratch.capacity(), 0);
+
+        assert!(!lane.prepare_lc_queries(&[first], 1).unwrap());
+        assert_eq!(lane.process_preparation_count(), 1);
+        assert_eq!(
+            lane.process_preparation_census(),
+            OnTheFlyProcessPreparationCensusV1 {
+                catalog_validation_count: 1,
+                grammar_preparation_count: 1,
+            }
+        );
+        let mut rebuilt = [0.0];
+        lane.run_f64_into(&[0.0; 8], 1, &[], 1.0, &mut rebuilt)
+            .unwrap();
+        assert_eq!(rebuilt, first_value);
+    }
+
+    #[test]
+    fn profile_maps_grouped_family_role_counters_without_dense_plan_counters() {
+        let profile = profile_from_report(
+            Duration::from_millis(11),
+            Duration::from_millis(1),
+            Duration::from_millis(2),
+            Duration::from_millis(7),
+            Duration::from_millis(1),
+            96,
+            3,
+            OnTheFlyQueryFamilyExecutionReportV1 {
+                cache_hit: true,
+                source_calls: 2,
+                source_rows: 4,
+                contribution_calls: 3,
+                contribution_rows: 17,
+                finalization_calls: 1,
+                finalization_rows: 5,
+                closure_calls: 2,
+                closure_rows: 7,
+            },
+        );
+        assert_eq!(profile.recurrence_schedule_execution_count, 1);
+        assert_eq!(profile.recurrence_momentum_scalar_value_count, 96);
+        assert_eq!(profile.recurrence_source_call_count, 2);
+        assert_eq!(profile.recurrence_source_row_count, 4);
+        assert_eq!(profile.recurrence_contribution_call_count, 3);
+        assert_eq!(profile.recurrence_contribution_row_count, 17);
+        assert_eq!(profile.recurrence_finalization_call_count, 1);
+        assert_eq!(profile.recurrence_finalization_row_count, 5);
+        assert_eq!(profile.recurrence_closure_call_count, 2);
+        assert_eq!(profile.recurrence_closure_row_count, 7);
+    }
+
+    #[test]
+    fn source_major_workspace_is_reused_after_warmup() {
+        let seed = scalar_adapter_test_seed(digest(1), digest(2), digest(3), digest(4)).unwrap();
+        let point_major = (0..16).map(f64::from).collect::<Vec<_>>();
+        let mut scratch = Vec::new();
+        let output_len =
+            on_the_fly_source_major_momenta_into(&seed, &point_major, 2, 4, &mut scratch).unwrap();
+        assert_eq!(output_len, 16);
+        assert_eq!(scratch[..4], [0.0, 8.0, 1.0, 9.0]);
+        let warmed_pointer = scratch.as_ptr();
+        let warmed_capacity = scratch.capacity();
+        on_the_fly_source_major_momenta_into(&seed, &point_major, 2, 4, &mut scratch).unwrap();
+        assert_eq!(scratch.as_ptr(), warmed_pointer);
+        assert_eq!(scratch.capacity(), warmed_capacity);
+    }
+
+    #[test]
+    fn source_major_workspace_preserves_values_across_partial_batches() {
+        use crate::recurrence::on_the_fly::{OnTheFlyExternalColorRoleV1, OnTheFlySourceAnchorV1};
+
+        let base = scalar_adapter_test_seed(digest(1), digest(2), digest(3), digest(4)).unwrap();
+        let anchors = (0..3)
+            .map(|slot| {
+                OnTheFlySourceAnchorV1::new(
+                    slot,
+                    slot,
+                    false,
+                    OnTheFlyExternalColorRoleV1::Singlet,
+                    false,
+                    None,
+                    base.source_anchors()[0].states().to_vec(),
+                )
+                .unwrap()
+            })
+            .collect();
+        let seed = OnTheFlyProcessSeedV1::new(
+            base.process_digest(),
+            base.model_digest(),
+            base.template_catalog_digest(),
+            base.prepared_pack_digest(),
+            base.direct_catalog_digest(),
+            digest(92),
+            "raw-amplitude-test",
+            crate::recurrence::ExactComplexRational::ONE,
+            anchors,
+            vec![1, 2, 0],
+            base.coupling_order_policy(),
+            base.coupling_hierarchies().to_vec(),
+            base.explicit_coupling_limits().to_vec(),
+            Vec::new(),
+        )
+        .unwrap();
+        let mut scratch = vec![53.0; seed.external_permutation().len() * 4 * 17];
+        let pointer = scratch.as_ptr();
+        let capacity = scratch.capacity();
+        for lorentz_count in [1, 3, 4] {
+            for point_count in [1, 17, 3, 8, 1] {
+                let point_width = seed.external_permutation().len() * lorentz_count;
+                let input = (0..point_width * point_count)
+                    .map(|index| {
+                        if index % 7 == 0 {
+                            -0.0
+                        } else {
+                            index as f64 / 11.0
+                        }
+                    })
+                    .collect::<Vec<_>>();
+                scratch.fill(53.0);
+                let count = on_the_fly_source_major_momenta_into(
+                    &seed,
+                    &input,
+                    point_count as u32,
+                    lorentz_count as u16,
+                    &mut scratch,
+                )
+                .unwrap();
+                assert_eq!(count, input.len());
+                for (source, public) in seed.external_permutation().iter().copied().enumerate() {
+                    for lorentz in 0..lorentz_count {
+                        for point in 0..point_count {
+                            assert_eq!(
+                                scratch[(source * lorentz_count + lorentz) * point_count + point]
+                                    .to_bits(),
+                                input[point * point_width
+                                    + public as usize * lorentz_count
+                                    + lorentz]
+                                    .to_bits(),
+                            );
+                        }
+                    }
+                }
+                assert!(scratch[count..].iter().all(|value| *value == 53.0));
+                assert_eq!(scratch.as_ptr(), pointer);
+                assert_eq!(scratch.capacity(), capacity);
+            }
+        }
+        assert!(on_the_fly_source_major_momenta_into(&seed, &[1.0], 1, 4, &mut scratch).is_err());
+        assert!(on_the_fly_source_major_momenta_into(&seed, &[], 0, 4, &mut scratch).is_err());
+    }
+
+    #[test]
+    fn mixed_structural_zero_and_trace_preserve_zero_resolved_slot() {
+        let query = scalar_query();
+        let requests = vec![
+            OnTheFlyLcQueryRequestV1::new(
+                query.clone(),
+                vec![OnTheFlyLcReductionTargetV1::new(0, 0, 1.0).unwrap()],
+            )
+            .unwrap(),
+            OnTheFlyLcQueryRequestV1::new(
+                query,
+                vec![OnTheFlyLcReductionTargetV1::new(1, 0, 2.0).unwrap()],
+            )
+            .unwrap(),
+        ];
+        // Request zero is a structural zero and therefore has no amplitude
+        // destination. Request one is the sole nonzero trace destination.
+        let amplitude_destinations = [None, Some(0)];
+        let amplitudes = [(3.0, 4.0)];
+
+        let mut total = [0.0];
+        reduce_total_into(
+            &requests,
+            &amplitude_destinations,
+            &amplitudes,
+            1,
+            1.0,
+            &mut total,
+        )
+        .unwrap();
+        assert_eq!(total, [50.0]);
+
+        let layout = LcResolvedOutputLayout::new(1, 2, 1).unwrap();
+        let mut resolved = [0.0; 2];
+        reduce_resolved_into(
+            &requests,
+            &amplitude_destinations,
+            &amplitudes,
+            1,
+            1.0,
+            layout,
+            &mut resolved,
+        )
+        .unwrap();
+        assert_eq!(resolved, [0.0, 50.0]);
+    }
+
+    #[test]
+    fn all_structural_zero_family_reduces_to_exact_zero_without_amplitudes() {
+        let requests = [OnTheFlyLcQueryRequestV1::new(
+            scalar_query(),
+            vec![OnTheFlyLcReductionTargetV1::new(0, 0, 1.0).unwrap()],
+        )
+        .unwrap()];
+        let mut total = [0.0];
+        reduce_total_into(&requests, &[None], &[], 1, 1.0, &mut total).unwrap();
+        assert_eq!(total, [0.0]);
+
+        let layout = LcResolvedOutputLayout::new(1, 1, 1).unwrap();
+        let mut resolved = [0.0];
+        reduce_resolved_into(&requests, &[None], &[], 1, 1.0, layout, &mut resolved).unwrap();
+        assert_eq!(resolved, [0.0]);
+    }
+
+    #[test]
+    fn symmetric_group_contracted_query_projection_reaches_final_reducer_in_group_order() {
+        let destination_by_group = (0..13)
+            .map(|group| ((group * 5) % 13) as u32)
+            .collect::<Vec<_>>();
+        let mut destination_by_owner_ordinal = vec![0_u32; 13];
+        for (group, owner) in destination_by_group.iter().copied().enumerate() {
+            destination_by_owner_ordinal[owner as usize] = group as u32;
+        }
+        let contraction = RecurrenceColorContraction::symmetric_group_s3_for_runtime_test(
+            destination_by_group.clone(),
+            13,
+        );
+        let RuntimeColorContractionReducer::SymmetricGroupFourier(reducer) =
+            contraction.runtime_reducer().unwrap()
+        else {
+            panic!("expected symmetric-group runtime reducer")
+        };
+        let covered_group_count = reducer.channel_count() * reducer.group_order();
+        assert!(reducer.channel_count() > 0);
+        assert!(reducer.local_group_count() > covered_group_count);
+        assert!(reducer.residual_entries().iter().any(|entry| {
+            entry.left_group_index < covered_group_count as u32
+                && entry.right_group_index >= covered_group_count as u32
+        }));
+        let point_count = 3;
+        let helicity_count = 2;
+        let structural_color_count = 13;
+        let normalization = 1.75;
+        let mut projection = vec![None; helicity_count * structural_color_count];
+        let mut amplitudes = Vec::new();
+        let mut local_values =
+            vec![(0.0, 0.0); helicity_count * structural_color_count * point_count];
+        // Query construction enumerates owners.  Its production slot helper
+        // stores every outcome in the inverse-mapped Fourier-group slot.  The
+        // complex values deliberately depend on the owner so a second
+        // application of this order-4 permutation cannot pass accidentally.
+        for helicity in 0..helicity_count {
+            for owner in 0..structural_color_count {
+                let group = destination_by_owner_ordinal[owner] as usize;
+                let structural_zero = helicity == 1 && group == 4;
+                if structural_zero {
+                    continue;
+                }
+                let destination = amplitudes.len() / point_count;
+                let projection_index = contracted_projection_index(
+                    helicity,
+                    owner,
+                    structural_color_count,
+                    &destination_by_owner_ordinal,
+                )
+                .unwrap();
+                projection[projection_index] = Some(destination);
+                for point in 0..point_count {
+                    let value = (
+                        (helicity * 19 + owner * 7 + point * 3) as f64 / 11.0 - 1.0,
+                        (helicity * 5 + owner * 13 + point) as f64 / 17.0 - 0.5,
+                    );
+                    amplitudes.push(value);
+                    local_values
+                        [(helicity * structural_color_count + group) * point_count + point] = value;
+                }
+            }
+        }
+
+        let mut expected = vec![0.0; helicity_count * point_count];
+        let helicity_stride = structural_color_count * point_count;
+        for helicity in 0..helicity_count {
+            let start = helicity * helicity_stride;
+            let dense = RecurrenceColorContraction::symmetric_group_s3_dense_for_runtime_test(
+                &local_values[start..start + helicity_stride],
+                point_count,
+            );
+            for (point, value) in dense.into_iter().enumerate() {
+                expected[point * helicity_count + helicity] = normalization * value;
+            }
+        }
+
+        // Install exactly the compact family state produced by query
+        // preparation, then enter the native lane's real final-reduction seam.
+        // No decoded queries or owner-indexed side table survives this point.
+        let mut lane = scalar_lane();
+        lane.pending_contracted_family = Some(PreparedOnTheFlyContractedFamilyV1 {
+            helicity_ordinals: (0..helicity_count).collect::<Vec<_>>().into_boxed_slice(),
+            structural_color_count,
+            amplitude_destinations: projection.into_boxed_slice(),
+            executor_handle: None,
+            census: None,
+            logical_point_capacity: point_count as u32,
+        });
+        lane.amplitude_scratch = amplitudes;
+        lane.install_symmetric_group_color_workspace(reducer.workspace(point_count).unwrap())
+            .unwrap();
+        let mut actual = vec![0.0; expected.len()];
+        lane.reduce_current_contracted_color(
+            &contraction,
+            point_count,
+            helicity_count,
+            normalization,
+            |point, helicity, value| actual[point * helicity_count + helicity] += value,
+        )
+        .unwrap();
+        for (actual, expected) in actual.into_iter().zip(expected) {
+            let scale = expected.abs().max(1.0);
+            assert!((actual - expected).abs() <= 2.0e-11 * scale);
+        }
+    }
+
+    #[test]
+    fn contracted_metric_preserves_imaginary_off_diagonal_terms_per_helicity() {
+        let entries = [
+            RuntimeColorContractionEntry {
+                left_destination_id: 0,
+                right_destination_id: 0,
+                coefficient_re: 1.0,
+                coefficient_im: 0.0,
+            },
+            RuntimeColorContractionEntry {
+                left_destination_id: 0,
+                right_destination_id: 1,
+                coefficient_re: 2.0,
+                coefficient_im: 3.0,
+            },
+            RuntimeColorContractionEntry {
+                left_destination_id: 1,
+                right_destination_id: 1,
+                coefficient_re: 0.5,
+                coefficient_im: 0.0,
+            },
+        ];
+        // H0 owns both structural amplitudes. H1's second structural query is
+        // an authenticated zero and every bilinear touching it must vanish.
+        let projection = [Some(0), Some(1), Some(2), None];
+        let amplitudes = [(1.0, 2.0), (3.0, 4.0), (2.0, 0.0)];
+        let mut resolved = [0.0; 2];
+        reduce_direct_contracted_color(
+            entries,
+            &projection,
+            &amplitudes,
+            1,
+            2,
+            2,
+            2.0,
+            |point, helicity, value| resolved[point * 2 + helicity] += value,
+        )
+        .unwrap();
+
+        // Re((2+3i) * (1+2i) * conj(3+4i)) = 16. The complete
+        // H0 metric is 5 + 16 + 12.5; H1 retains only |2|^2.
+        assert_eq!(resolved, [67.0, 8.0]);
+        assert_eq!(resolved.iter().sum::<f64>(), 75.0);
+    }
+
+    #[test]
+    fn contracted_metric_rejects_projection_and_destination_shape_mismatches() {
+        let entry = RuntimeColorContractionEntry {
+            left_destination_id: 0,
+            right_destination_id: 1,
+            coefficient_re: 1.0,
+            coefficient_im: 0.0,
+        };
+        assert!(
+            reduce_direct_contracted_color(
+                [entry],
+                &[Some(0)],
+                &[(1.0, 0.0)],
+                1,
+                1,
+                2,
+                1.0,
+                |_, _, _| {},
+            )
+            .is_err()
+        );
+        assert!(
+            reduce_direct_contracted_color(
+                [RuntimeColorContractionEntry {
+                    right_destination_id: 2,
+                    ..entry
+                }],
+                &[Some(0), Some(1)],
+                &[(1.0, 0.0), (1.0, 0.0)],
+                1,
+                1,
+                2,
+                1.0,
+                |_, _, _| {},
+            )
+            .is_err()
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_lane_cache.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_lane_cache.rs
new file mode 100644
index 0000000000..1545d07d68
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_lane_cache.rs
@@ -0,0 +1,231 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::recurrence::on_the_fly::{
+    OnTheFlyFamilySnapshotRefV1, OnTheFlyFamilySnapshotV1, restore_on_the_fly_grammar_v1,
+};
+
+#[derive(bincode::Encode, bincode::Decode)]
+struct LcProjectionV1 {
+    amplitude_destinations: Box<[Option<usize>]>,
+    census: Option<OnTheFlyQueryFamilyCensusV1>,
+    logical_point_capacity: u32,
+}
+
+#[derive(bincode::Encode)]
+struct LcProjectionRefV1<'a> {
+    amplitude_destinations: &'a [Option<usize>],
+    census: Option<OnTheFlyQueryFamilyCensusV1>,
+    logical_point_capacity: u32,
+}
+
+#[derive(bincode::Encode, bincode::Decode)]
+struct ContractedProjectionV1 {
+    helicity_ordinals: Box<[usize]>,
+    structural_color_count: usize,
+    projection: LcProjectionV1,
+}
+
+#[derive(bincode::Encode)]
+struct ContractedProjectionRefV1<'a> {
+    helicity_ordinals: &'a [usize],
+    structural_color_count: usize,
+    projection: LcProjectionRefV1<'a>,
+}
+
+#[derive(bincode::Decode)]
+pub(in super::super) struct OnTheFlyLaneSnapshotV1 {
+    policy: Option<OnTheFlyResolvedCouplingPolicyV1>,
+    process_preparation_count: u64,
+    lc: Option<LcProjectionV1>,
+    contracted: Option<ContractedProjectionV1>,
+    executor: Option<OnTheFlyFamilySnapshotV1>,
+}
+
+#[derive(bincode::Encode)]
+pub(in super::super) struct OnTheFlyLaneSnapshotRefV1<'a> {
+    policy: Option<&'a OnTheFlyResolvedCouplingPolicyV1>,
+    process_preparation_count: u64,
+    lc: Option<LcProjectionRefV1<'a>>,
+    contracted: Option<ContractedProjectionRefV1<'a>>,
+    executor: Option<OnTheFlyFamilySnapshotRefV1<'a>>,
+}
+
+impl OnTheFlyLaneSnapshotV1 {
+    pub(in super::super) fn has_family(&self) -> bool {
+        self.lc.is_some() || self.contracted.is_some()
+    }
+}
+
+impl OnTheFlyNativeRuntime {
+    pub(in super::super) fn snapshot(&self) -> RusticolResult<OnTheFlyLaneSnapshotRefV1<'_>> {
+        if self.families.len() > 1 || (self.last_family.is_some() && self.last_family != Some(0)) {
+            return Err(RusticolError::internal(
+                "OTF retention policy changed; update the cache format",
+            ));
+        }
+        Ok(OnTheFlyLaneSnapshotRefV1 {
+            policy: self.coupling_policy.as_ref(),
+            process_preparation_count: self.process_preparation_count,
+            lc: self.families.first().map(|family| LcProjectionRefV1 {
+                amplitude_destinations: &family.amplitude_destinations,
+                census: family.census,
+                logical_point_capacity: family.logical_point_capacity,
+            }),
+            contracted: self
+                .contracted_family
+                .as_ref()
+                .map(|family| ContractedProjectionRefV1 {
+                    helicity_ordinals: &family.helicity_ordinals,
+                    structural_color_count: family.structural_color_count,
+                    projection: LcProjectionRefV1 {
+                        amplitude_destinations: &family.amplitude_destinations,
+                        census: family.census,
+                        logical_point_capacity: family.logical_point_capacity,
+                    },
+                }),
+            executor: self.executor.snapshot()?,
+        })
+    }
+
+    pub(in super::super) fn restore_snapshot(
+        &mut self,
+        snapshot: OnTheFlyLaneSnapshotV1,
+        requests: Option<Vec<OnTheFlyLcQueryRequestV1>>,
+        contracted_selection: Option<(&[usize], usize)>,
+    ) -> RusticolResult<()> {
+        let OnTheFlyLaneSnapshotV1 {
+            policy,
+            process_preparation_count,
+            lc,
+            contracted,
+            executor,
+        } = snapshot;
+        if lc.is_some() && contracted.is_some()
+            || lc.is_some() != requests.is_some()
+            || contracted.is_some() != contracted_selection.is_some()
+            || (lc.is_some() || contracted.is_some()) && policy.is_none()
+        {
+            return Err(RusticolError::integrity(
+                "saved OTF family and selected workload disagree",
+            ));
+        }
+        let grammar = policy
+            .as_ref()
+            .map(|policy| restore_on_the_fly_grammar_v1(&self.templates, &self.seed, policy))
+            .transpose()?;
+        let projection = lc
+            .as_ref()
+            .or_else(|| contracted.as_ref().map(|value| &value.projection));
+        if let Some(projection) = projection {
+            let count = executor
+                .as_ref()
+                .map_or(0, OnTheFlyFamilySnapshotV1::amplitude_destination_count);
+            if projection.logical_point_capacity == 0
+                || projection.census != executor.as_ref().map(OnTheFlyFamilySnapshotV1::census)
+                || projection
+                    .amplitude_destinations
+                    .iter()
+                    .flatten()
+                    .any(|&id| id >= count)
+                || executor.is_none()
+                    && projection
+                        .amplitude_destinations
+                        .iter()
+                        .any(Option::is_some)
+            {
+                return Err(RusticolError::integrity(
+                    "saved OTF amplitude projection is inconsistent",
+                ));
+            }
+        } else if executor.is_some() {
+            return Err(RusticolError::integrity(
+                "saved OTF executor has no selected workload",
+            ));
+        }
+        if let (Some(lc), Some(requests)) = (&lc, &requests)
+            && lc.amplitude_destinations.len() != requests.len()
+        {
+            return Err(RusticolError::integrity(
+                "saved OTF LC projection has the wrong query count",
+            ));
+        }
+        if let (Some(contracted), Some((helicities, colors))) = (&contracted, contracted_selection)
+            && (contracted.helicity_ordinals.as_ref() != helicities
+                || contracted.structural_color_count != colors
+                || helicities.len().checked_mul(colors)
+                    != Some(contracted.projection.amplitude_destinations.len()))
+        {
+            return Err(RusticolError::integrity(
+                "saved OTF contracted projection has the wrong selected axes",
+            ));
+        }
+        // Allocate all replacement metadata before committing a new executor.
+        let mut restored_lc = Vec::new();
+        if lc.is_some() {
+            restored_lc.try_reserve_exact(1).map_err(|error| {
+                RusticolError::invalid_argument(format!(
+                    "OTF restored selection allocation failed: {error}"
+                ))
+            })?;
+        }
+        let requests = requests.map(Vec::into_boxed_slice);
+        let capacity = projection.map_or(1, |value| value.logical_point_capacity);
+        let handle = if let Some(executor) = executor {
+            let restored = (|| {
+                self.executor.resolver_mut().bind_on_the_fly_saved_family(
+                    &self.templates,
+                    &self.direct_catalog,
+                    executor.executor_keys(),
+                )?;
+                self.executor.restore_snapshot(executor, capacity)
+            })();
+            match restored {
+                Ok(handle) => {
+                    self.executor
+                        .resolver_mut()
+                        .commit_pending_resolved_bindings()?;
+                    Some(handle)
+                }
+                Err(error) => {
+                    self.executor
+                        .resolver_mut()
+                        .discard_pending_resolved_bindings();
+                    return Err(error);
+                }
+            }
+        } else {
+            self.executor.clear_families()?;
+            self.executor.resolver_mut().clear_resolved_bindings();
+            None
+        };
+        if let Some(lc) = lc {
+            restored_lc.push(PreparedOnTheFlyLcFamilyV1 {
+                requests: requests.expect("validated saved LC requests disappeared"),
+                amplitude_destinations: lc.amplitude_destinations,
+                executor_handle: handle,
+                census: lc.census,
+                logical_point_capacity: lc.logical_point_capacity,
+            });
+        }
+        self.last_family = (!restored_lc.is_empty()).then_some(0);
+        self.families = restored_lc;
+        self.pending_family = None;
+        self.contracted_family = contracted.map(|value| PreparedOnTheFlyContractedFamilyV1 {
+            helicity_ordinals: value.helicity_ordinals,
+            structural_color_count: value.structural_color_count,
+            amplitude_destinations: value.projection.amplitude_destinations,
+            executor_handle: handle,
+            census: value.projection.census,
+            logical_point_capacity: value.projection.logical_point_capacity,
+        });
+        self.pending_contracted_family = None;
+        self.prepared_grammar = grammar;
+        self.coupling_policy = policy;
+        self.coupling_policy_resolution = self.coupling_policy.as_ref().map(|_| Duration::ZERO);
+        self.process_preparation_count = process_preparation_count;
+        self.source_momenta_scratch = Vec::new();
+        self.amplitude_scratch = Vec::new();
+        Ok(())
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_load.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_load.rs
new file mode 100644
index 0000000000..888e6e7a8c
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_load.rs
@@ -0,0 +1,975 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Authenticated construction boundary for the private on-the-fly lane.
+//!
+//! Loading stops at the compact process seed and model-wide prepared catalogs.
+//! It never opens or constructs a process-wide [`crate::recurrence::DirectRecurrencePlan`]
+//! and it never materializes dense helicity/color axes. NLC/full authenticate
+//! one recurrence-v3 color payload against the compact structural owner basis.
+//! The existing runtime adapter owns public selector decoding after this boundary.
+
+use super::eager_manifest::PreparedKernelPackManifest;
+use super::on_the_fly_lane::OnTheFlyNativeRuntime;
+use super::on_the_fly_manifest::{
+    ON_THE_FLY_PROCESS_SEED_MEMBER, OnTheFlyColorCoverage, OnTheFlyExecutionManifest,
+    OnTheFlyRuntimeContainer,
+};
+use super::on_the_fly_public_metadata::{
+    OnTheFlyPublicMetadataV1, parse_on_the_fly_public_metadata,
+};
+use super::on_the_fly_selectors::{
+    OnTheFlyCompactSelectorAdapterV1, OnTheFlyLcColorCoverageV1, OnTheFlyLcSelectorPolicyV1,
+};
+use super::recurrence_backend::{
+    NativeRecurrencePreparedExecutorPool, OnTheFlySourceDomainBinding,
+};
+use super::recurrence_bootstrap::{
+    RecurrenceReadyCompanionV1, RecurrenceReadyExecutionV1, RecurrenceReadyPlanV1,
+};
+use super::recurrence_lane::{
+    PreparedParameterProjectionEntry, RecurrencePersistedHelicitySelectorRuntime,
+};
+use super::recurrence_load::{
+    LoadedRecurrencePlan, build_direct_source_domains, build_on_the_fly_source_domains,
+    decode_ready_source_domains, decode_sha256, direct_helicity_to_physics,
+    load_color_contraction_reference, load_plan_summary, runtime_parameter_slots,
+    validate_ready_direct_helicity_to_physics, validate_recurrence_prepared_pack_outer_target,
+};
+use super::*;
+use crate::pacbin::{PacbinMemberKind, PacbinReader};
+use crate::recurrence::on_the_fly::{
+    OnTheFlyExternalColorRoleV1, OnTheFlyProcessSeedV1, decode_on_the_fly_process_seed_v1,
+    validate_on_the_fly_source_mass_bindings_v1,
+};
+use crate::recurrence::template_json::project_owned_recurrence_template_catalog_json_v1;
+use crate::recurrence::{
+    FactorizedColorContractionKind, RecurrenceColorAccuracy, RecurrenceColorContraction,
+    RecurrenceColorStorage, decode_recurrence_helicity_dispatch_v1,
+};
+use std::rc::Rc;
+
+pub(super) struct LoadedOnTheFlyColorContractionV1 {
+    pub(super) plan: RecurrenceColorContraction,
+    pub(super) destination_by_owner_ordinal: Box<[u32]>,
+    pub(super) point_tile_size: usize,
+}
+
+pub(super) struct LoadedOnTheFlyRuntime {
+    pub(super) common: ExecutionRuntime,
+    pub(super) lane: OnTheFlyNativeRuntime,
+    pub(super) selectors: OnTheFlyCompactSelectorAdapterV1,
+    pub(super) metadata_selectors: OnTheFlyCompactSelectorAdapterV1,
+    pub(super) public_metadata: OnTheFlyPublicMetadataV1,
+    pub(super) color_contraction: Option<LoadedOnTheFlyColorContractionV1>,
+}
+
+pub(super) struct LoadedRecurrenceHelicitySelectorCompanion {
+    pub(super) runtime: RecurrencePersistedHelicitySelectorRuntime,
+}
+
+fn clamp_query_construction_threads(requested: usize, available: usize) -> usize {
+    requested.min(available.max(1))
+}
+
+pub(super) fn effective_query_construction_threads(requested: usize) -> usize {
+    let available = std::thread::available_parallelism()
+        .map(std::num::NonZeroUsize::get)
+        .unwrap_or(1);
+    clamp_query_construction_threads(requested, available)
+}
+
+fn validate_recurrence_companion_process_digest(
+    primary_process_digest: &str,
+    companion_process_digest: &str,
+    decoded_seed_process_digest: &str,
+) -> RusticolResult<()> {
+    if primary_process_digest != companion_process_digest
+        || primary_process_digest != decoded_seed_process_digest
+    {
+        return Err(RusticolError::integrity(
+            "recurrence helicity-selector companion is bound to a different primary process",
+        ));
+    }
+    Ok(())
+}
+
+pub(super) fn load_on_the_fly_native_runtime(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &OnTheFlyExecutionManifest,
+    selection: &crate::ArtifactSelection,
+) -> RusticolResult<LoadedOnTheFlyRuntime> {
+    let public_metadata = load_public_metadata(artifact, manifest, &selection.process)?;
+    let seed = load_process_seed(artifact, evaluator_root, manifest)?;
+    if seed.identity() != manifest.runtime_metadata.process_seed_identity {
+        return Err(RusticolError::integrity(
+            "on-the-fly execution metadata does not identify its decoded process seed",
+        ));
+    }
+    let (mut pack, payload_root) = load_prepared_pack(artifact, manifest)?;
+    let raw_templates = pack.recurrence_template.take().ok_or_else(|| {
+        RusticolError::compatibility(
+            "on-the-fly execution requires the prepared recurrence template catalog",
+        )
+    })?;
+    let raw_template_json = serde_json::from_str(raw_templates.get()).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse prepared recurrence template catalog: {error}"
+        ))
+    })?;
+    drop(raw_templates);
+    let templates =
+        project_owned_recurrence_template_catalog_json_v1(raw_template_json)?.validate()?;
+    let summary = templates.summary();
+    if seed.template_catalog_digest() != summary.catalog_digest
+        || seed.model_digest() != summary.compiled_model_digest
+        || seed.prepared_pack_digest() != summary.prepared_kernel_pack_digest
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly process seed disagrees with the authenticated recurrence template catalog",
+        ));
+    }
+    let parameter_projection = manifest
+        .runtime_metadata
+        .parameter_projection
+        .iter()
+        .map(|row| {
+            (
+                row.parameter_template_id,
+                row.prepared_parameter_id,
+                row.component,
+            )
+        })
+        .collect::<Vec<_>>();
+    validate_on_the_fly_source_mass_bindings_v1(&seed, &templates, &parameter_projection)?;
+
+    let payloads = artifact.evaluator_payload_store(&payload_root)?;
+    let pool = NativeRecurrencePreparedExecutorPool::load_without_plan_from_validated_pack(
+        &mut pack,
+        &payloads,
+        &seed.prepared_pack_digest().to_string(),
+        &seed.direct_catalog_digest().to_string(),
+    )?;
+    let direct_catalog = pool.prepared_direct_catalog()?;
+    if direct_catalog.direct_template_catalog_digest() != seed.direct_catalog_digest() {
+        return Err(RusticolError::integrity(
+            "on-the-fly prepared Direct-Arena catalog disagrees with the compact process seed",
+        ));
+    }
+    let source_domains = build_on_the_fly_source_domains(&seed, &templates)?;
+    let sources = pool.bind_source_domains(source_domains)?;
+    let resolver = pool.into_on_the_fly_resolver(sources);
+
+    let (mut common, defaults, projection) = build_common_runtime(manifest)?;
+    common.model_parameter_evaluator =
+        super::eager_load::load_prepared_model_parameter_evaluator_for_runtime(
+            &pack,
+            &common.model_parameters,
+            &payloads,
+        )?;
+    common.refresh_derived_model_parameters()?;
+
+    let metadata_selectors = OnTheFlyCompactSelectorAdapterV1::from_seed(
+        &seed,
+        selector_policy(&manifest.selector_policy),
+    )?;
+    let public_color_count = if manifest.uses_contracted_color() {
+        1
+    } else {
+        metadata_selectors.color_count()
+    };
+    manifest
+        .selector_policy
+        .selector_census
+        .validate_against(metadata_selectors.helicity_count(), public_color_count)?;
+    let color_contraction = load_on_the_fly_color_contraction(
+        artifact,
+        evaluator_root,
+        OnTheFlyColorContractionLoadV1 {
+            process_key: &manifest.key,
+            color_accuracy: &manifest.color_accuracy,
+            requested_point_tile_size: manifest.runtime_options.point_tile_size,
+            reference: manifest.runtime_metadata.color_contraction.as_ref(),
+            seed: &seed,
+            selectors: &metadata_selectors,
+        },
+    )?;
+    let selectors = metadata_selectors
+        .clone()
+        .with_public_permutation(&selection.external_permutation)?;
+    let requested_query_construction_threads =
+        usize::try_from(manifest.runtime_options.query_construction_threads).map_err(|_| {
+            RusticolError::artifact("on-the-fly query construction thread count exceeds usize")
+        })?;
+    let effective_query_construction_threads =
+        effective_query_construction_threads(requested_query_construction_threads);
+    let mut lane = OnTheFlyNativeRuntime::new(
+        templates,
+        direct_catalog,
+        seed,
+        resolver,
+        requested_query_construction_threads,
+        effective_query_construction_threads,
+        defaults,
+        projection,
+        &common.model_parameter_values_f64,
+    )?;
+    if let Some(workspace) = symmetric_group_workspace_for_loaded_color(color_contraction.as_ref())?
+    {
+        lane.install_symmetric_group_color_workspace(workspace)?;
+    }
+    Ok(LoadedOnTheFlyRuntime {
+        common,
+        lane,
+        selectors,
+        metadata_selectors,
+        public_metadata,
+        color_contraction,
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn load_recurrence_helicity_selector_companion(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &super::recurrence_manifest::RecurrenceExecutionManifest,
+    physics: &ProcessPhysicsV1,
+    payloads: &EvaluatorPayloadStore,
+    common: &ExecutionRuntime,
+) -> RusticolResult<LoadedRecurrenceHelicitySelectorCompanion> {
+    let companion = manifest
+        .helicity_selector_companion
+        .as_ref()
+        .ok_or_else(|| {
+            RusticolError::integrity(
+                "recurrence companion loader was called without a companion descriptor",
+            )
+        })?;
+    let LoadedRecurrencePlan {
+        plan,
+        process_executors,
+    } = load_plan_summary(artifact, evaluator_root, manifest, &companion.plan)?;
+    validate_recurrence_companion_process_digest(
+        &manifest.plan.process_binding.process_digest,
+        &companion.process_digest,
+        &companion.plan.process_binding.process_digest,
+    )?;
+    let dispatch = load_recurrence_companion_dispatch(
+        artifact,
+        &plan,
+        companion.plan.helicity_dispatch.as_ref(),
+    )?;
+    let source_domains = build_direct_source_domains(
+        &plan,
+        &manifest.runtime_metadata,
+        &common.model_parameter_runtime_slots,
+    )?;
+    let direct_helicity_to_physics = direct_helicity_to_physics(&plan, physics)?;
+    finish_recurrence_helicity_selector_companion(
+        process_executors,
+        plan,
+        dispatch,
+        payloads,
+        RecurrenceCompanionModelIdentities {
+            compiled_model_digest: &manifest.compiled_model_digest,
+            recurrence_template_catalog_digest: &manifest.recurrence_template_catalog_digest,
+            prepared_kernel_pack_digest: &manifest.prepared_kernel_pack_digest,
+            direct_template_catalog_digest: &manifest.direct_template_catalog_digest,
+        },
+        source_domains,
+        direct_helicity_to_physics,
+        physics.helicities.len(),
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn load_recurrence_helicity_selector_companion_from_ready_parts(
+    artifact: &VerifiedArtifact,
+    loaded_plan: LoadedRecurrencePlan,
+    plan_reference: &RecurrenceReadyPlanV1,
+    companion: &RecurrenceReadyCompanionV1,
+    ready: &RecurrenceReadyExecutionV1,
+    physics: &ProcessPhysicsV1,
+    payloads: &EvaluatorPayloadStore,
+) -> RusticolResult<LoadedRecurrenceHelicitySelectorCompanion> {
+    validate_recurrence_companion_process_digest(
+        &ready.primary_plan.process_binding.process_digest,
+        &companion.process_digest,
+        &plan_reference.process_binding.process_digest,
+    )?;
+    let LoadedRecurrencePlan {
+        plan,
+        process_executors,
+    } = loaded_plan;
+    let dispatch = load_recurrence_companion_dispatch(
+        artifact,
+        &plan,
+        plan_reference.helicity_dispatch.as_ref(),
+    )?;
+    let source_domains = decode_ready_source_domains(&companion.source_domains, &plan)?;
+    let direct_helicity_to_physics = validate_ready_direct_helicity_to_physics(
+        &plan,
+        &companion.direct_helicity_to_physics,
+        physics,
+    )?;
+    finish_recurrence_helicity_selector_companion(
+        process_executors,
+        plan,
+        dispatch,
+        payloads,
+        RecurrenceCompanionModelIdentities {
+            compiled_model_digest: &ready.compiled_model_digest,
+            recurrence_template_catalog_digest: &ready.recurrence_template_catalog_digest,
+            prepared_kernel_pack_digest: &ready.prepared_kernel_pack_digest,
+            direct_template_catalog_digest: &ready.direct_template_catalog_digest,
+        },
+        source_domains,
+        direct_helicity_to_physics,
+        physics.helicities.len(),
+    )
+}
+
+fn load_recurrence_companion_dispatch(
+    artifact: &VerifiedArtifact,
+    plan: &crate::recurrence::DirectRecurrencePlan,
+    reference: Option<&super::recurrence_manifest::RecurrenceHelicityDispatchReference>,
+) -> RusticolResult<crate::recurrence::DirectHelicityDispatch> {
+    let reference = reference.ok_or_else(|| {
+        RusticolError::integrity("recurrence helicity-selector plan has no exact helicity dispatch")
+    })?;
+    let record = artifact.payload(&reference.path)?;
+    if record.role != PayloadRole::EvaluatorState
+        || record.media_type != "application/octet-stream"
+        || record.process_id.is_some()
+        || record.executable
+        || record.size_bytes != reference.size_bytes
+        || record.sha256 != reference.sha256
+    {
+        return Err(RusticolError::integrity(
+            "recurrence helicity dispatch disagrees with its authenticated payload",
+        ));
+    }
+    let bytes = artifact.read_payload(&reference.path)?;
+    let dispatch = decode_recurrence_helicity_dispatch_v1(&bytes)?;
+    dispatch.validate_for_plan(plan)?;
+    if dispatch.runtime_layout_digest().to_string() != reference.base_runtime_layout_digest
+        || dispatch.resolved_helicity_count() as u64 != reference.resolved_helicity_count
+    {
+        return Err(RusticolError::integrity(
+            "decoded recurrence helicity dispatch disagrees with its bounded summary",
+        ));
+    }
+    Ok(dispatch)
+}
+
+struct RecurrenceCompanionModelIdentities<'a> {
+    compiled_model_digest: &'a str,
+    recurrence_template_catalog_digest: &'a str,
+    prepared_kernel_pack_digest: &'a str,
+    direct_template_catalog_digest: &'a str,
+}
+
+#[allow(clippy::too_many_arguments)]
+fn finish_recurrence_helicity_selector_companion(
+    process_executors: super::recurrence_process_pack::ProcessDirectExecutorPack,
+    plan: crate::recurrence::DirectRecurrencePlan,
+    dispatch: crate::recurrence::DirectHelicityDispatch,
+    payloads: &EvaluatorPayloadStore,
+    identities: RecurrenceCompanionModelIdentities<'_>,
+    source_domains: Vec<super::evaluator::recurrence_source_direct::DirectSourceDispatchDomainSpec>,
+    direct_helicity_to_physics: Vec<usize>,
+    physics_helicity_count: usize,
+) -> RusticolResult<LoadedRecurrenceHelicitySelectorCompanion> {
+    let pool = Rc::new(
+        NativeRecurrencePreparedExecutorPool::load_for_direct_plan_from_process_pack(
+            &process_executors,
+            payloads,
+            &plan,
+        )?,
+    );
+    pool.validate_model_identities(
+        identities.compiled_model_digest,
+        identities.recurrence_template_catalog_digest,
+        identities.prepared_kernel_pack_digest,
+        identities.direct_template_catalog_digest,
+    )?;
+    let sources = OnTheFlySourceDomainBinding::load_for_process_plan(&plan, source_domains)?;
+    let resolver = Rc::clone(&pool).into_shared_on_the_fly_resolver(sources);
+    let runtime = RecurrencePersistedHelicitySelectorRuntime::new(
+        plan,
+        dispatch,
+        resolver,
+        direct_helicity_to_physics,
+        physics_helicity_count,
+    )?;
+    Ok(LoadedRecurrenceHelicitySelectorCompanion { runtime })
+}
+
+fn symmetric_group_workspace_for_loaded_color(
+    loaded: Option<&LoadedOnTheFlyColorContractionV1>,
+) -> RusticolResult<Option<crate::recurrence::RuntimeSymmetricGroupColorWorkspace>> {
+    let Some((reducer, point_tile_size)) = loaded.and_then(|loaded| {
+        loaded
+            .plan
+            .runtime_reducer()
+            .and_then(|reducer| match reducer {
+                crate::recurrence::RuntimeColorContractionReducer::SymmetricGroupFourier(value) => {
+                    Some((value, loaded.point_tile_size))
+                }
+                _ => None,
+            })
+    }) else {
+        return Ok(None);
+    };
+    // `point_tile_size` was already clamped against the shared 512 MiB
+    // workspace budget while authenticating the color payload.  Allocate the
+    // final capacity here so the first multi-point evaluation is warmed too.
+    Ok(Some(reducer.workspace(point_tile_size)?))
+}
+
+fn load_public_metadata(
+    artifact: &VerifiedArtifact,
+    manifest: &OnTheFlyExecutionManifest,
+    outer: &crate::ArtifactProcess,
+) -> RusticolResult<OnTheFlyPublicMetadataV1> {
+    let record = artifact.payload(&outer.physics_path)?;
+    if record.role != PayloadRole::RuntimePhysics
+        || record.media_type != "application/json"
+        || record.executable
+        || record.process_id.as_deref() != Some(manifest.key.as_str())
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly compact public metadata has the wrong authenticated payload role",
+        ));
+    }
+    let bytes = artifact.read_payload(&outer.physics_path)?;
+    parse_on_the_fly_public_metadata(&bytes, &outer.physics_path, outer, manifest)
+}
+
+fn selector_policy(
+    policy: &super::on_the_fly_manifest::OnTheFlySelectorPolicy,
+) -> OnTheFlyLcSelectorPolicyV1 {
+    let color_coverage = match policy.color_coverage {
+        OnTheFlyColorCoverage::Complete | OnTheFlyColorCoverage::Contracted => {
+            // NLC/full still use the compact complete LC structural basis
+            // internally; only the public axis is contracted.
+            OnTheFlyLcColorCoverageV1::Complete
+        }
+    };
+    OnTheFlyLcSelectorPolicyV1 {
+        color_coverage,
+        color_basis: policy.color_basis,
+        reference_color_word: policy
+            .reference_color_word
+            .clone()
+            .map(Vec::into_boxed_slice),
+        trace_reflections_folded: policy.trace_reflections_folded,
+    }
+}
+
+struct OnTheFlyColorContractionLoadV1<'a> {
+    process_key: &'a str,
+    color_accuracy: &'a str,
+    requested_point_tile_size: u32,
+    reference: Option<&'a super::recurrence_manifest::RecurrenceColorContractionReference>,
+    seed: &'a OnTheFlyProcessSeedV1,
+    selectors: &'a OnTheFlyCompactSelectorAdapterV1,
+}
+
+fn load_on_the_fly_color_contraction(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    request: OnTheFlyColorContractionLoadV1<'_>,
+) -> RusticolResult<Option<LoadedOnTheFlyColorContractionV1>> {
+    let OnTheFlyColorContractionLoadV1 {
+        process_key,
+        color_accuracy,
+        requested_point_tile_size,
+        reference,
+        seed,
+        selectors,
+    } = request;
+    let Some(reference) = reference else {
+        return Ok(None);
+    };
+    let plan = load_color_contraction_reference(artifact, evaluator_root, process_key, reference)?;
+    let expected_accuracy = match color_accuracy {
+        "nlc" => RecurrenceColorAccuracy::Nlc,
+        "full" => RecurrenceColorAccuracy::Full,
+        _ => {
+            return Err(RusticolError::integrity(
+                "LC on-the-fly execution unexpectedly loaded contracted color",
+            ));
+        }
+    };
+    let owner_count = selectors.color_count();
+    let owner_count_u32 = u32::try_from(owner_count).map_err(|_| {
+        RusticolError::artifact("on-the-fly contracted structural owner count exceeds u32")
+    })?;
+    let fundamental_count = seed
+        .source_anchors()
+        .iter()
+        .filter(|anchor| anchor.color_role() == OnTheFlyExternalColorRoleV1::Fundamental)
+        .count();
+    let alias_multiplicity = (1..=fundamental_count).try_fold(1usize, |value, factor| {
+        value.checked_mul(factor).ok_or_else(|| {
+            RusticolError::artifact(
+                "on-the-fly contracted open-line alias multiplicity exceeds usize",
+            )
+        })
+    })?;
+    let expected_sector_count = owner_count.checked_mul(alias_multiplicity).ok_or_else(|| {
+        RusticolError::artifact("on-the-fly contracted structural sector count exceeds usize")
+    })?;
+    let plan_sector_count = usize::try_from(plan.sector_count()).map_err(|_| {
+        RusticolError::artifact("on-the-fly contracted payload sector count exceeds usize")
+    })?;
+    let direct_storage =
+        plan.storage() == RecurrenceColorStorage::Expanded && plan.factorization().is_none();
+    let symmetric_group_storage = plan.storage() == RecurrenceColorStorage::ConvolutionKernels
+        && plan.factorization().is_some_and(|factorization| {
+            factorization.kind() == FactorizedColorContractionKind::SymmetricGroupFourier
+        });
+    if plan.accuracy() != expected_accuracy
+        || !(direct_storage || symmetric_group_storage)
+        || !plan.includes_color_factor()
+        || plan.component_count() != 1
+        || plan.active_sector_count() != owner_count
+        || plan.group_count() != owner_count_u32
+        || plan.destination_count() != owner_count_u32
+        || plan_sector_count != expected_sector_count
+        || plan.owner_by_sector().contains(&u32::MAX)
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly contracted color payload disagrees with the compact structural owner basis",
+        ));
+    }
+
+    let fixed_owner_sectors = plan
+        .owner_by_sector()
+        .iter()
+        .copied()
+        .enumerate()
+        .filter_map(|(sector, owner)| (owner as usize == sector).then_some(owner))
+        .collect::<Vec<_>>();
+    if fixed_owner_sectors.len() != owner_count {
+        return Err(RusticolError::integrity(
+            "on-the-fly contracted color owner fixed points are incomplete",
+        ));
+    }
+    let owner_class_sizes = plan.owner_by_sector().iter().copied().fold(
+        BTreeMap::<u32, usize>::new(),
+        |mut counts, owner| {
+            *counts.entry(owner).or_default() += 1;
+            counts
+        },
+    );
+    if owner_class_sizes.len() != owner_count
+        || owner_class_sizes
+            .values()
+            .any(|count| *count != alias_multiplicity)
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly contracted owner classes disagree with whole-open-line block aliases",
+        ));
+    }
+    let group_by_owner_sector = plan
+        .sector_by_group()
+        .iter()
+        .copied()
+        .zip(plan.component_by_group().iter().copied())
+        .enumerate()
+        .map(|(group_id, (sector, component))| {
+            if component != 0 {
+                return Err(RusticolError::integrity(
+                    "on-the-fly contracted group has a nonzero component",
+                ));
+            }
+            let group_id = u32::try_from(group_id).map_err(|_| {
+                RusticolError::artifact("on-the-fly contracted group ID exceeds u32")
+            })?;
+            Ok((sector, group_id))
+        })
+        .collect::<RusticolResult<BTreeMap<_, _>>>()?;
+    if group_by_owner_sector.len() != owner_count {
+        return Err(RusticolError::integrity(
+            "on-the-fly contracted groups do not cover every structural owner once",
+        ));
+    }
+    let destination_by_owner_ordinal = if direct_storage {
+        let mut destinations = Vec::new();
+        destinations
+            .try_reserve_exact(owner_count)
+            .map_err(|error| {
+                RusticolError::artifact(format!(
+                    "could not reserve on-the-fly contracted destination map: {error}"
+                ))
+            })?;
+        for (owner_ordinal, owner_sector) in fixed_owner_sectors.iter().copied().enumerate() {
+            let group_id = group_by_owner_sector
+                .get(&owner_sector)
+                .copied()
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "on-the-fly contracted owner has no component-zero group",
+                    )
+                })?;
+            let destination = plan.destination_by_group()[group_id as usize];
+            let expected_destination = u32::try_from(owner_ordinal).map_err(|_| {
+                RusticolError::artifact("on-the-fly contracted owner ordinal exceeds u32")
+            })?;
+            if destination != expected_destination
+                || plan.ordered_group_ids().get(owner_ordinal).copied() != Some(group_id)
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly contracted destination order disagrees with the compact structural owner basis",
+                ));
+            }
+            destinations.push(destination);
+        }
+        destinations
+    } else {
+        // Symmetric-group groups are channel/permutation ordered.  Their
+        // authenticated destination projection maps that order back to the
+        // compact selector-owner ordinals, so query construction consumes the
+        // inverse map (owner ordinal -> Fourier group ID).
+        let mut destinations = vec![u32::MAX; owner_count];
+        for (group_id, owner_ordinal) in plan.destination_by_group().iter().copied().enumerate() {
+            let owner_ordinal = usize::try_from(owner_ordinal).map_err(|_| {
+                RusticolError::artifact("on-the-fly contracted owner ordinal exceeds usize")
+            })?;
+            let slot = destinations.get_mut(owner_ordinal).ok_or_else(|| {
+                RusticolError::integrity(
+                    "on-the-fly symmetric-group destination is outside the owner domain",
+                )
+            })?;
+            if *slot != u32::MAX {
+                return Err(RusticolError::integrity(
+                    "on-the-fly symmetric-group destination projection is not one-to-one",
+                ));
+            }
+            *slot = u32::try_from(group_id).map_err(|_| {
+                RusticolError::artifact("on-the-fly symmetric-group group ID exceeds u32")
+            })?;
+        }
+        if destinations.contains(&u32::MAX) {
+            return Err(RusticolError::integrity(
+                "on-the-fly symmetric-group destination projection is incomplete",
+            ));
+        }
+        for (owner_ordinal, owner_sector) in fixed_owner_sectors.iter().copied().enumerate() {
+            let expected_group = group_by_owner_sector
+                .get(&owner_sector)
+                .copied()
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "on-the-fly contracted owner has no component-zero group",
+                    )
+                })?;
+            if destinations[owner_ordinal] != expected_group {
+                return Err(RusticolError::integrity(
+                    "on-the-fly symmetric-group projection disagrees with the authenticated owner sectors",
+                ));
+            }
+        }
+        destinations
+    };
+    let requested_point_tile_size = usize::try_from(requested_point_tile_size).map_err(|_| {
+        RusticolError::artifact("on-the-fly contracted point tile size exceeds usize")
+    })?;
+    let point_tile_size = match plan.runtime_reducer() {
+        Some(crate::recurrence::RuntimeColorContractionReducer::SymmetricGroupFourier(reducer)) => {
+            reducer.bounded_lane_capacity(requested_point_tile_size)?
+        }
+        _ => requested_point_tile_size,
+    };
+    Ok(Some(LoadedOnTheFlyColorContractionV1 {
+        plan,
+        destination_by_owner_ordinal: destination_by_owner_ordinal.into_boxed_slice(),
+        point_tile_size,
+    }))
+}
+
+fn load_process_seed(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &OnTheFlyExecutionManifest,
+) -> RusticolResult<crate::recurrence::on_the_fly::OnTheFlyProcessSeedV1> {
+    load_process_seed_from_container(
+        artifact,
+        evaluator_root,
+        &manifest.key,
+        &manifest.runtime_container,
+    )
+}
+
+fn load_process_seed_from_container(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    process_key: &str,
+    container: &OnTheFlyRuntimeContainer,
+) -> RusticolResult<crate::recurrence::on_the_fly::OnTheFlyProcessSeedV1> {
+    let payloads = artifact.evaluator_payload_store(evaluator_root)?;
+    let logical_path = payloads.logical_path(&container.path)?;
+    let record = artifact.payload(&logical_path)?;
+    if record.role != PayloadRole::EvaluatorState
+        || record.media_type != "application/octet-stream"
+        || record.executable
+        || record.process_id.as_deref() != Some(process_key)
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly runtime container has the wrong authenticated payload role",
+        ));
+    }
+    let path = artifact.root().join(&logical_path);
+    let file = artifact.open_payload_file(&logical_path)?;
+    let expected_sha = decode_sha256(&record.sha256)?;
+    let reader = PacbinReader::open_file_with_sha256(file, &path, &expected_sha)?;
+    if reader.members().len() != 1 {
+        return Err(RusticolError::integrity(
+            "on-the-fly runtime container must contain exactly its compact process seed",
+        ));
+    }
+    let member = reader.member(ON_THE_FLY_PROCESS_SEED_MEMBER)?;
+    if member.logical_path() != container.seed_member_path
+        || member.kind() != PacbinMemberKind::OnTheFlyProcessSeed
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly runtime container does not contain the canonical process-seed member",
+        ));
+    }
+    decode_on_the_fly_process_seed_v1(reader.member_bytes(ON_THE_FLY_PROCESS_SEED_MEMBER)?)
+}
+
+fn load_prepared_pack(
+    artifact: &VerifiedArtifact,
+    manifest: &OnTheFlyExecutionManifest,
+) -> RusticolResult<(PreparedKernelPackManifest, PathBuf)> {
+    let path = confined_internal_path(
+        &manifest.kernel_pack.manifest_path,
+        "on-the-fly prepared kernel-pack manifest path",
+    )?;
+    let logical = path.to_str().ok_or_else(|| {
+        RusticolError::security("on-the-fly prepared kernel-pack path is not UTF-8")
+    })?;
+    if artifact.payload(logical)?.role != PayloadRole::EvaluatorManifest {
+        return Err(RusticolError::security(
+            "on-the-fly prepared kernel-pack manifest has the wrong payload role",
+        ));
+    }
+    let bytes = artifact.read_payload(logical)?;
+    let pack: PreparedKernelPackManifest = serde_json::from_slice(&bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse on-the-fly prepared kernel pack: {error}"
+        ))
+    })?;
+    pack.validate()?;
+    validate_recurrence_prepared_pack_outer_target(&artifact.manifest().producer.target, &pack)?;
+    let payload_root = artifact.root().join(confined_internal_path(
+        &manifest.kernel_pack.payload_root,
+        "on-the-fly prepared kernel payload root",
+    )?);
+    Ok((pack, payload_root))
+}
+
+fn build_common_runtime(
+    manifest: &OnTheFlyExecutionManifest,
+) -> RusticolResult<(
+    ExecutionRuntime,
+    Vec<crate::EagerComplex64>,
+    Vec<PreparedParameterProjectionEntry>,
+)> {
+    let metadata = &manifest.runtime_metadata;
+    let model_parameters = metadata
+        .runtime_parameters
+        .iter()
+        .map(|parameter| GenericRuntimeModelParameterManifest {
+            name: parameter.name.clone(),
+            kind: parameter.kind.clone(),
+            parameter_index: parameter.parameter_index as usize,
+            default: parameter.default,
+            pdg: None,
+            runtime_name: parameter.runtime_name.clone(),
+            complex_component: parameter.complex_component.clone(),
+        })
+        .collect::<Vec<_>>();
+    let model_parameter_runtime_slots = runtime_parameter_slots(&model_parameters)?;
+    let model_parameter_values_f64 = model_parameters
+        .iter()
+        .map(|parameter| parameter.default)
+        .collect::<Vec<_>>();
+    let model_parameter_name_to_index = model_parameters
+        .iter()
+        .map(|parameter| (parameter.name.clone(), parameter.parameter_index))
+        .collect::<BTreeMap<_, _>>();
+    let defaults = metadata
+        .prepared_parameter_defaults
+        .iter()
+        .map(|[real, imaginary]| crate::EagerComplex64::new(*real, *imaginary))
+        .collect::<Vec<_>>();
+    let projection = metadata
+        .parameter_projection
+        .iter()
+        .filter_map(|row| row.prepared_parameter_id.map(|prepared| (row, prepared)))
+        .map(|(row, prepared)| {
+            Ok(PreparedParameterProjectionEntry {
+                runtime_slot: usize::try_from(row.runtime_slot).map_err(|_| {
+                    RusticolError::artifact("on-the-fly runtime parameter slot exceeds usize")
+                })?,
+                prepared_slot: usize::try_from(prepared).map_err(|_| {
+                    RusticolError::artifact("on-the-fly prepared parameter slot exceeds usize")
+                })?,
+                component: u8::try_from(row.component).map_err(|_| {
+                    RusticolError::artifact("on-the-fly parameter component exceeds u8")
+                })?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let normalization = &metadata.normalization;
+    if !normalization.couplings_in_stage_evaluators {
+        return Err(RusticolError::compatibility(
+            "on-the-fly execution requires local vertex couplings in prepared kernel calls",
+        ));
+    }
+    let color_factor = if metadata
+        .color_contraction
+        .as_ref()
+        .is_some_and(|contraction| contraction.includes_color_factor)
+    {
+        1.0
+    } else {
+        normalization.color_factor
+    };
+    let normalization_factor = color_factor * normalization.global_coupling_factor
+        / (normalization.average_factor * normalization.identical_factor);
+    if !normalization_factor.is_finite() {
+        return Err(RusticolError::integrity(
+            "on-the-fly runtime normalization is not finite",
+        ));
+    }
+    let particle_masses = metadata
+        .particle_masses
+        .iter()
+        .map(|row| (row.outgoing_pdg, row.mass))
+        .collect::<BTreeMap<_, _>>();
+    let external_count = metadata.external_legs.len();
+    let common = ExecutionRuntime {
+        process: manifest.process.clone(),
+        key: manifest.key.clone(),
+        color_accuracy: manifest.color_accuracy.clone(),
+        external_pdg_order: manifest.external_pdg_order.clone(),
+        external_count,
+        parameter_count: model_parameters.len(),
+        value_parameter_count: 0,
+        momentum_parameter_count: 0,
+        current_count: 0,
+        source_count: external_count,
+        interaction_count: 0,
+        stage_count: 0,
+        amplitude_output_count: 0,
+        lc_topology_replay_enabled: false,
+        lc_topology_replay_mappings: Arc::new(Vec::new()),
+        lc_topology_replay_public_mappings: Vec::new(),
+        lc_topology_replay_routes: Vec::new(),
+        lc_topology_replay_materialized_sector_ids: BTreeSet::new(),
+        lc_resolved_replay_plan: None,
+        lc_resolved_replay_selection_cache: None,
+        lc_replay_flat_momenta_scratch: Vec::new(),
+        lc_replay_target_components_scratch: Vec::new(),
+        color_topology_replay_enabled: false,
+        color_topology_replay_mappings: Arc::new(Vec::new()),
+        color_replay_flat_momenta_scratch: Vec::new(),
+        helicity_recurrence: None,
+        compiled_helicity_execution_plan: None,
+        compiled_color_execution_plan: None,
+        compiled_direct_runtime: None,
+        compiled_direct_color_schedules: BTreeMap::new(),
+        compiled_direct_helicity_schedules: BTreeMap::new(),
+        helicity_sum_runtime: None,
+        helicity_selector_runtimes: Vec::new(),
+        helicity_selector_runtime_schedule_modes: Vec::new(),
+        helicity_selector_lane_by_domain: BTreeMap::new(),
+        color_selector_runtimes: BTreeMap::new(),
+        runtime_unavailable_message: None,
+        sources: Vec::new(),
+        momentum_slots: Vec::new(),
+        external_is_initial: metadata
+            .external_legs
+            .iter()
+            .map(|leg| leg.is_initial)
+            .collect(),
+        particle_masses,
+        particle_mass_parameter_names: BTreeMap::new(),
+        normalization_factor,
+        normalization_color_factor: color_factor,
+        normalization_average_factor: normalization.average_factor,
+        normalization_identical_factor: normalization.identical_factor,
+        normalization_qcd_coupling_power: normalization.qcd_coupling_power.unwrap_or(0) as usize,
+        normalization_electroweak_coupling_power: normalization
+            .electroweak_coupling_power
+            .unwrap_or(0) as usize,
+        model_parameters,
+        model_parameter_name_to_index,
+        model_parameter_runtime_slots,
+        model_parameter_values_f64,
+        model_parameter_evaluator: None,
+        physics_reduction_override: None,
+        physics: None,
+        stages: None,
+        amplitude_stage: None,
+        state_scratch_f64: Vec::new(),
+        state_scratch_f64_requires_clear: false,
+        values_scratch_f64: Vec::new(),
+    };
+    Ok((common, defaults, projection))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        LoadedOnTheFlyColorContractionV1, clamp_query_construction_threads,
+        symmetric_group_workspace_for_loaded_color, validate_recurrence_companion_process_digest,
+    };
+    use crate::recurrence::RecurrenceColorContraction;
+
+    #[test]
+    fn query_construction_threads_are_capped_by_positive_host_availability() {
+        assert_eq!(clamp_query_construction_threads(8, 3), 3);
+        assert_eq!(clamp_query_construction_threads(2, 8), 2);
+        assert_eq!(clamp_query_construction_threads(4, 0), 1);
+    }
+
+    #[test]
+    fn cross_process_companion_seed_swap_is_rejected_by_primary_binding_digest() {
+        let primary = "10".repeat(32);
+        let swapped = "20".repeat(32);
+        validate_recurrence_companion_process_digest(&primary, &primary, &primary).unwrap();
+
+        for (companion, decoded) in [
+            (&swapped, &swapped),
+            (&primary, &swapped),
+            (&swapped, &primary),
+        ] {
+            let error = validate_recurrence_companion_process_digest(&primary, companion, decoded)
+                .unwrap_err();
+            assert!(error.to_string().contains("different primary process"));
+        }
+    }
+
+    #[test]
+    fn symmetric_group_workspace_is_installed_at_the_authenticated_tile_capacity() {
+        let loaded = LoadedOnTheFlyColorContractionV1 {
+            plan: RecurrenceColorContraction::symmetric_group_s3_for_runtime_test(
+                (0..13).collect(),
+                13,
+            ),
+            destination_by_owner_ordinal: (0..13).collect::<Vec<_>>().into_boxed_slice(),
+            point_tile_size: 5,
+        };
+        let workspace = symmetric_group_workspace_for_loaded_color(Some(&loaded))
+            .unwrap()
+            .expect("symmetric-group workspace");
+        assert_eq!(workspace.lane_capacity(), 5);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_manifest.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_manifest.rs
new file mode 100644
index 0000000000..1db590b7f6
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_manifest.rs
@@ -0,0 +1,1123 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Compact execution-manifest validation for the private on-the-fly lane.
+//!
+//! The verified outer artifact owns file sizes and digests, while PACBIN owns
+//! its member index and payload digests. This manifest therefore records only
+//! the identities and canonical paths needed to select the lane.
+
+use super::recurrence_manifest::{
+    RecurrenceColorContractionReference, RecurrenceExternalLeg, RecurrenceNormalization,
+    RecurrenceParameterProjection, RecurrenceParticleMass, RecurrenceRuntimeParameter,
+};
+use super::{
+    ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY, ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_RUNTIME_CAPABILITY, SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+    confined_internal_path,
+};
+use crate::recurrence::RECURRENCE_COLOR_CONTRACTION_CODEC_ABI;
+use crate::recurrence::on_the_fly::{
+    ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI, OnTheFlyProcessSeedIdentityV1,
+};
+use crate::{ArtifactProcess, PROCESS_ARTIFACT_SCHEMA_VERSION, RusticolError, RusticolResult};
+use serde::Deserialize;
+use std::collections::BTreeSet;
+
+pub(super) const ON_THE_FLY_EXECUTION_KIND: &str = "pyamplicol-runtime-on-the-fly-execution";
+pub(super) const ON_THE_FLY_RUNTIME_CONTAINER_KIND: &str =
+    "pyamplicol-on-the-fly-runtime-container";
+pub(super) const ON_THE_FLY_RUNTIME_CONTAINER_SCHEMA: u16 = 1;
+pub(super) const ON_THE_FLY_RUNTIME_STORAGE_ABI: &str = "pacbin-v1";
+pub(super) const ON_THE_FLY_RUNTIME_CONTAINER_PATH: &str = "on-the-fly-runtime.pacbin";
+pub(super) const ON_THE_FLY_PROCESS_SEED_MEMBER: &str = "on-the-fly/process-seed-v1.bin";
+pub(super) const ON_THE_FLY_KERNEL_PACK_MANIFEST_PATH: &str = "model/eager-kernel-pack.json";
+pub(super) const ON_THE_FLY_KERNEL_PAYLOAD_ROOT: &str = "model/eager-kernels";
+pub(super) const ON_THE_FLY_COLOR_CONTRACTION_PATH: &str = "on-the-fly-color.bin";
+#[expect(
+    dead_code,
+    reason = "retained to reject legacy v1 companion manifests explicitly"
+)]
+pub(super) const RECURRENCE_HELICITY_SELECTOR_COMPANION_KIND: &str =
+    "pyamplicol-recurrence-helicity-selector-companion-v1";
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct OnTheFlyExecutionManifest {
+    pub(super) schema_version: u32,
+    pub(super) kind: String,
+    pub(super) required_runtime_capabilities: Vec<String>,
+    pub(super) process: String,
+    pub(super) key: String,
+    pub(super) color_accuracy: String,
+    pub(super) external_pdg_order: Vec<i32>,
+    pub(super) kernel_pack: OnTheFlyKernelPackReference,
+    pub(super) runtime_options: OnTheFlyRuntimeOptions,
+    pub(super) selector_policy: OnTheFlySelectorPolicy,
+    pub(super) runtime_metadata: OnTheFlyRuntimeMetadata,
+    pub(super) runtime_container: OnTheFlyRuntimeContainer,
+}
+
+/// Irreducible process/runtime state shared with the established recurrence
+/// lane. Dense public color-flow catalogs and source-template replicas do not
+/// belong to an on-the-fly artifact: selectors and source dispatch are derived
+/// from the compact seed. NLC/full add only a bounded reference to their loose
+/// authenticated color-contraction payload.
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct OnTheFlyRuntimeMetadata {
+    pub(super) runtime_parameters: Vec<RecurrenceRuntimeParameter>,
+    pub(super) prepared_parameter_defaults: Vec<[f64; 2]>,
+    pub(super) parameter_projection: Vec<RecurrenceParameterProjection>,
+    pub(super) external_legs: Vec<RecurrenceExternalLeg>,
+    pub(super) particle_masses: Vec<RecurrenceParticleMass>,
+    pub(super) normalization: RecurrenceNormalization,
+    pub(super) process_seed_identity: OnTheFlyProcessSeedIdentityV1,
+    #[serde(default)]
+    pub(super) color_contraction: Option<RecurrenceColorContractionReference>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct OnTheFlyKernelPackReference {
+    pub(super) manifest_path: String,
+    pub(super) payload_root: String,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct OnTheFlyRuntimeOptions {
+    pub(super) point_tile_size: u32,
+    pub(super) query_construction_threads: u32,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+pub(super) enum OnTheFlyColorCoverage {
+    Complete,
+    Contracted,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+pub(super) enum OnTheFlyColorBasis {
+    #[default]
+    Trace,
+    Adjoint,
+}
+
+/// Compact facts that affect the internal structural color basis but cannot be
+/// reconstructed from external color roles alone.
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct OnTheFlySelectorPolicy {
+    pub(super) color_coverage: OnTheFlyColorCoverage,
+    #[serde(default)]
+    pub(super) color_basis: OnTheFlyColorBasis,
+    #[serde(default)]
+    pub(super) reference_color_word: Option<Vec<u32>>,
+    pub(super) trace_reflections_folded: bool,
+    pub(super) selector_census: OnTheFlySelectorCensus,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub(super) struct OnTheFlySelectorCensus {
+    pub(super) physical_helicity_count: u64,
+    pub(super) physical_color_flow_count: u64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct OnTheFlyRuntimeContainer {
+    pub(super) kind: String,
+    pub(super) schema_version: u16,
+    pub(super) storage_abi: String,
+    pub(super) path: String,
+    pub(super) seed_member_path: String,
+}
+
+/// Lane-only OTF state embedded by a complete contracted recurrence artifact.
+///
+/// Runtime parameters, external legs, normalization, and point tiling remain
+/// owned by the enclosing recurrence manifest.  The companion retains only
+/// the compact seed identity and policy needed to construct a selected query
+/// family plus its independent one-component color reducer.
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+#[expect(
+    dead_code,
+    reason = "retained to reject legacy v1 companion manifests explicitly"
+)]
+pub(super) struct OnTheFlyHelicitySelectorCompanionManifest {
+    pub(super) schema_version: u32,
+    pub(super) kind: String,
+    pub(super) process_digest: String,
+    pub(super) process_seed_identity: OnTheFlyProcessSeedIdentityV1,
+    pub(super) query_construction_threads: u32,
+    pub(super) selector_policy: OnTheFlySelectorPolicy,
+    pub(super) runtime_container: OnTheFlyRuntimeContainer,
+    pub(super) color_contraction: RecurrenceColorContractionReference,
+}
+
+impl OnTheFlyHelicitySelectorCompanionManifest {
+    #[expect(
+        dead_code,
+        reason = "retained to reject legacy v1 companion manifests explicitly"
+    )]
+    pub(super) fn validate(
+        &self,
+        process_digest: Option<&str>,
+        color_accuracy: &str,
+    ) -> RusticolResult<()> {
+        if self.schema_version != 1 || self.kind != RECURRENCE_HELICITY_SELECTOR_COMPANION_KIND {
+            return Err(RusticolError::compatibility(
+                "unsupported recurrence helicity-selector companion; regenerate the artifact",
+            ));
+        }
+        if process_digest != Some(self.process_digest.as_str())
+            || self.process_seed_identity.process_digest != self.process_digest
+        {
+            return Err(RusticolError::integrity(
+                "recurrence helicity-selector companion disagrees with the process digest",
+            ));
+        }
+        if self.query_construction_threads == 0 {
+            return Err(RusticolError::artifact(
+                "recurrence helicity-selector companion query thread count must be positive",
+            ));
+        }
+        if !matches!(color_accuracy, "nlc" | "full") {
+            return Err(RusticolError::integrity(
+                "only contracted recurrence may carry a helicity-selector companion",
+            ));
+        }
+        self.selector_policy.validate(color_accuracy)?;
+        self.runtime_container.validate()?;
+        validate_contracted_color_reference(&self.color_contraction, color_accuracy)?;
+        if self.color_contraction.component_count != 1 {
+            return Err(RusticolError::integrity(
+                "recurrence helicity-selector companion color payload must have one component",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl OnTheFlyExecutionManifest {
+    fn validate(&self, outer: &ArtifactProcess) -> RusticolResult<()> {
+        if self.schema_version != PROCESS_ARTIFACT_SCHEMA_VERSION
+            || self.kind != ON_THE_FLY_EXECUTION_KIND
+        {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported on-the-fly execution kind {:?} schema {}; regenerate the artifact",
+                self.kind, self.schema_version
+            )));
+        }
+        if self.process != outer.expression
+            || self.key != outer.id
+            || self.color_accuracy != outer.color_accuracy
+            || self.external_pdg_order != outer.external_pdgs
+        {
+            return Err(RusticolError::integrity(format!(
+                "on-the-fly execution manifest does not match outer process {:?}",
+                outer.id
+            )));
+        }
+        let actual = self
+            .required_runtime_capabilities
+            .iter()
+            .map(String::as_str)
+            .collect::<BTreeSet<_>>();
+        let color_capability = match self.color_accuracy.as_str() {
+            "lc" => ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+            "nlc" | "full" => ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            _ => {
+                return Err(RusticolError::compatibility(format!(
+                    "unsupported on-the-fly color accuracy {:?}",
+                    self.color_accuracy
+                )));
+            }
+        };
+        let uses_symmetric_group_fft = self
+            .runtime_metadata
+            .color_contraction
+            .as_ref()
+            .and_then(|reference| reference.factorization.as_ref())
+            .is_some_and(|factorization| factorization.kind == "symmetric-group-fourier");
+        let mut expected = BTreeSet::from([ON_THE_FLY_RUNTIME_CAPABILITY, color_capability]);
+        if uses_symmetric_group_fft {
+            expected.insert(SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY);
+        }
+        if actual.len() != self.required_runtime_capabilities.len() || actual != expected {
+            return Err(RusticolError::integrity(format!(
+                "on-the-fly execution must require exactly {expected:?}"
+            )));
+        }
+        if self.kernel_pack.manifest_path != ON_THE_FLY_KERNEL_PACK_MANIFEST_PATH
+            || self.kernel_pack.payload_root != ON_THE_FLY_KERNEL_PAYLOAD_ROOT
+        {
+            return Err(RusticolError::security(
+                "on-the-fly prepared-kernel paths are not canonical",
+            ));
+        }
+        if self.runtime_options.point_tile_size == 0 {
+            return Err(RusticolError::artifact(
+                "on-the-fly point_tile_size must be positive",
+            ));
+        }
+        if self.runtime_options.query_construction_threads == 0 {
+            return Err(RusticolError::artifact(
+                "on-the-fly query_construction_threads must be positive",
+            ));
+        }
+        self.selector_policy.validate(&self.color_accuracy)?;
+        self.runtime_metadata
+            .validate(&self.external_pdg_order, &self.color_accuracy)?;
+        self.runtime_container.validate()
+    }
+
+    pub(super) fn uses_contracted_color(&self) -> bool {
+        matches!(self.color_accuracy.as_str(), "nlc" | "full")
+    }
+}
+
+impl OnTheFlySelectorPolicy {
+    pub(super) fn validate(&self, color_accuracy: &str) -> RusticolResult<()> {
+        if let Some(word) = &self.reference_color_word
+            && (word.is_empty()
+                || word.contains(&0)
+                || word.iter().copied().collect::<BTreeSet<_>>().len() != word.len())
+        {
+            return Err(RusticolError::artifact(
+                "on-the-fly reference color word must contain unique positive external labels",
+            ));
+        }
+        self.selector_census.validate()?;
+        let coverage_matches = matches!(
+            (color_accuracy, self.color_coverage),
+            ("lc", OnTheFlyColorCoverage::Complete)
+                | ("nlc" | "full", OnTheFlyColorCoverage::Contracted)
+        );
+        if !coverage_matches
+            || self.color_basis == OnTheFlyColorBasis::Adjoint
+                && self.color_coverage != OnTheFlyColorCoverage::Contracted
+            || self.color_coverage == OnTheFlyColorCoverage::Contracted
+                && (self.trace_reflections_folded
+                    || self.selector_census.physical_color_flow_count != 1)
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly selector policy disagrees with its color accuracy",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl OnTheFlySelectorCensus {
+    fn validate(&self) -> RusticolResult<()> {
+        if self.physical_helicity_count == 0 || self.physical_color_flow_count == 0 {
+            return Err(RusticolError::artifact(
+                "on-the-fly selector census counts must be positive",
+            ));
+        }
+        Ok(())
+    }
+
+    pub(super) fn validate_against(
+        &self,
+        physical_helicity_count: usize,
+        physical_color_flow_count: usize,
+    ) -> RusticolResult<()> {
+        let helicities = u64::try_from(physical_helicity_count).map_err(|_| {
+            RusticolError::artifact("on-the-fly physical helicity count exceeds u64")
+        })?;
+        let color_flows = u64::try_from(physical_color_flow_count).map_err(|_| {
+            RusticolError::artifact("on-the-fly physical color-flow count exceeds u64")
+        })?;
+        if self.physical_helicity_count != helicities
+            || self.physical_color_flow_count != color_flows
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly selector census disagrees with the authenticated compact seed",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl OnTheFlyRuntimeMetadata {
+    fn validate(&self, external_pdgs: &[i32], color_accuracy: &str) -> RusticolResult<()> {
+        for (context, len) in [
+            ("runtime parameters", self.runtime_parameters.len()),
+            (
+                "prepared parameter defaults",
+                self.prepared_parameter_defaults.len(),
+            ),
+            ("parameter projection", self.parameter_projection.len()),
+            ("external legs", self.external_legs.len()),
+            ("particle masses", self.particle_masses.len()),
+        ] {
+            u32::try_from(len).map_err(|_| {
+                RusticolError::artifact(format!(
+                    "on-the-fly {context} count exceeds the u32 identifier domain"
+                ))
+            })?;
+        }
+        if self
+            .prepared_parameter_defaults
+            .iter()
+            .flatten()
+            .any(|component| !component.is_finite())
+        {
+            return Err(RusticolError::artifact(
+                "on-the-fly prepared-parameter defaults must be finite complex-f64 values",
+            ));
+        }
+        if self.runtime_parameters.len() != self.parameter_projection.len() {
+            return Err(RusticolError::integrity(
+                "on-the-fly runtime parameters do not cover the parameter projection",
+            ));
+        }
+        let mut previous_projection_key: Option<(&str, u32)> = None;
+        let mut current_name: Option<&str> = None;
+        let mut current_template = None;
+        let mut current_prepared = None;
+        for (runtime_slot, row) in self.parameter_projection.iter().enumerate() {
+            if row.runtime_slot as usize != runtime_slot
+                || row.runtime_name.is_empty()
+                || row.component > 1
+                || row.parameter_template_id as usize >= self.prepared_parameter_defaults.len()
+                || row
+                    .prepared_parameter_id
+                    .is_some_and(|id| id as usize >= self.prepared_parameter_defaults.len())
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly parameter projection is outside its prepared-parameter domain",
+                ));
+            }
+            let key = (row.runtime_name.as_str(), row.component);
+            if previous_projection_key.is_some_and(|previous| previous >= key) {
+                return Err(RusticolError::artifact(
+                    "on-the-fly parameter projection is not in strict name/component order",
+                ));
+            }
+            previous_projection_key = Some(key);
+            if current_name == Some(row.runtime_name.as_str()) {
+                if row.component != 1
+                    || current_template != Some(row.parameter_template_id)
+                    || current_prepared != Some(row.prepared_parameter_id)
+                {
+                    return Err(RusticolError::integrity(
+                        "on-the-fly complex parameter projection rows are inconsistent",
+                    ));
+                }
+            } else {
+                if row.component != 0 {
+                    return Err(RusticolError::artifact(
+                        "on-the-fly parameter projection must begin at component zero",
+                    ));
+                }
+                current_name = Some(&row.runtime_name);
+                current_template = Some(row.parameter_template_id);
+                current_prepared = Some(row.prepared_parameter_id);
+            }
+        }
+        let mut previous_runtime_name: Option<&str> = None;
+        let mut previous_kind: Option<&str> = None;
+        for (parameter_index, (parameter, projection)) in self
+            .runtime_parameters
+            .iter()
+            .zip(&self.parameter_projection)
+            .enumerate()
+        {
+            if parameter.parameter_index as usize != parameter_index
+                || parameter.parameter_index != projection.runtime_slot
+                || parameter.name.is_empty()
+                || parameter.kind.is_empty()
+                || !parameter.default.is_finite()
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly runtime parameter identity/default is invalid",
+                ));
+            }
+            match (&parameter.runtime_name, &parameter.complex_component) {
+                (Some(runtime_name), Some(component)) => {
+                    let expected_component = match projection.component {
+                        0 => "real",
+                        1 => "imag",
+                        _ => unreachable!("projection component was validated"),
+                    };
+                    if runtime_name.is_empty()
+                        || component != expected_component
+                        || projection.runtime_name != *runtime_name
+                        || parameter.name != format!("{runtime_name}.{component}")
+                        || (previous_runtime_name == Some(runtime_name)
+                            && previous_kind != Some(parameter.kind.as_str()))
+                    {
+                        return Err(RusticolError::integrity(
+                            "on-the-fly complex runtime parameter disagrees with its projection",
+                        ));
+                    }
+                    previous_runtime_name = Some(runtime_name);
+                    previous_kind = Some(&parameter.kind);
+                }
+                (None, None) => {
+                    if projection.component != 0 || parameter.name != projection.runtime_name {
+                        return Err(RusticolError::integrity(
+                            "on-the-fly real runtime parameter disagrees with its projection",
+                        ));
+                    }
+                    previous_runtime_name = None;
+                    previous_kind = None;
+                }
+                _ => {
+                    return Err(RusticolError::artifact(
+                        "on-the-fly runtime_name and complex_component must appear together",
+                    ));
+                }
+            }
+            if let Some(prepared_id) = projection.prepared_parameter_id
+                && parameter.default
+                    != self.prepared_parameter_defaults[prepared_id as usize]
+                        [projection.component as usize]
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly runtime parameter default disagrees with its prepared default",
+                ));
+            }
+        }
+
+        if self.external_legs.len() != external_pdgs.len() {
+            return Err(RusticolError::integrity(
+                "on-the-fly external legs do not match the execution PDG order",
+            ));
+        }
+        let mut public_labels = BTreeSet::new();
+        let mut saw_final = false;
+        for (source_slot, (leg, expected_pdg)) in
+            self.external_legs.iter().zip(external_pdgs).enumerate()
+        {
+            if leg.source_slot as usize != source_slot
+                || leg.public_label == 0
+                || !public_labels.insert(leg.public_label)
+                || leg.physical_pdg != *expected_pdg
+                || (saw_final && leg.is_initial)
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly external-leg order or identity is not canonical",
+                ));
+            }
+            saw_final |= !leg.is_initial;
+        }
+        let mut previous_mass_pdg = None;
+        for row in &self.particle_masses {
+            if previous_mass_pdg.is_some_and(|previous| previous >= row.outgoing_pdg)
+                || !row.mass.is_finite()
+                || row.mass < 0.0
+            {
+                return Err(RusticolError::artifact(
+                    "on-the-fly particle masses are not strictly ordered finite nonnegative values",
+                ));
+            }
+            previous_mass_pdg = Some(row.outgoing_pdg);
+        }
+        let normalization = &self.normalization;
+        if normalization.color_accuracy != color_accuracy
+            || [
+                normalization.color_factor,
+                normalization.average_factor,
+                normalization.identical_factor,
+                normalization.global_coupling_factor,
+            ]
+            .iter()
+            .any(|value| !value.is_finite())
+            || normalization.average_factor <= 0.0
+            || normalization.identical_factor <= 0.0
+            || normalization.qcd_coupling_power.is_some()
+                != normalization.electroweak_coupling_power.is_some()
+            || normalization.coupling_policy.is_empty()
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly normalization metadata is invalid",
+            ));
+        }
+        match (color_accuracy, self.color_contraction.as_ref()) {
+            ("lc", None) => {}
+            ("nlc" | "full", Some(reference)) => {
+                validate_contracted_color_reference(reference, color_accuracy)?;
+            }
+            ("lc", Some(_)) => {
+                return Err(RusticolError::integrity(
+                    "LC on-the-fly execution must not carry a color-contraction companion",
+                ));
+            }
+            ("nlc" | "full", None) => {
+                return Err(RusticolError::integrity(
+                    "NLC/full on-the-fly execution requires a color-contraction companion",
+                ));
+            }
+            _ => {
+                return Err(RusticolError::compatibility(
+                    "unsupported on-the-fly color accuracy",
+                ));
+            }
+        }
+        self.validate_process_seed_identity()?;
+        Ok(())
+    }
+
+    fn validate_process_seed_identity(&self) -> RusticolResult<()> {
+        let identity = &self.process_seed_identity;
+        if identity.abi != ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI {
+            return Err(RusticolError::compatibility(
+                "unsupported on-the-fly process-seed identity ABI; regenerate the artifact",
+            ));
+        }
+        for digest in [
+            &identity.process_digest,
+            &identity.compiled_model_digest,
+            &identity.recurrence_template_catalog_digest,
+            &identity.prepared_kernel_pack_digest,
+            &identity.recurrence_direct_template_catalog_digest,
+            &identity.semantic_digest,
+        ] {
+            if digest.len() != 64
+                || !digest
+                    .bytes()
+                    .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly process-seed identity contains an invalid SHA-256",
+                ));
+            }
+        }
+        if identity.external_permutation.len() != self.external_legs.len()
+            || identity.external_sources.len() != self.external_legs.len()
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly process-seed identity has the wrong external domain",
+            ));
+        }
+        let mut permutation = identity.external_permutation.clone();
+        permutation.sort_unstable();
+        if permutation
+            .iter()
+            .enumerate()
+            .any(|(index, slot)| *slot as usize != index)
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly process-seed identity permutation is not dense",
+            ));
+        }
+        for (source_slot, (source, leg)) in identity
+            .external_sources
+            .iter()
+            .zip(&self.external_legs)
+            .enumerate()
+        {
+            if source.source_slot as usize != source_slot
+                || source.public_label != leg.public_label
+                || source.is_initial != leg.is_initial
+                || source.states.is_empty()
+                || source
+                    .states
+                    .windows(2)
+                    .any(|pair| pair[0].state_index >= pair[1].state_index)
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly process-seed source identity disagrees with external legs",
+                ));
+            }
+        }
+        Ok(())
+    }
+}
+
+fn validate_contracted_color_reference(
+    reference: &RecurrenceColorContractionReference,
+    color_accuracy: &str,
+) -> RusticolResult<()> {
+    let digest_is_canonical = |value: &str| {
+        value.len() == 64
+            && value
+                .bytes()
+                .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+    };
+    if reference.abi != RECURRENCE_COLOR_CONTRACTION_CODEC_ABI
+        || reference.path != ON_THE_FLY_COLOR_CONTRACTION_PATH
+    {
+        return Err(RusticolError::compatibility(
+            "unsupported on-the-fly color-contraction payload contract",
+        ));
+    }
+    if reference.color_accuracy != color_accuracy
+        || !matches!(color_accuracy, "nlc" | "full")
+        || !matches!(
+            reference.storage.as_str(),
+            "expanded" | "convolution-kernels"
+        )
+        || !reference.includes_color_factor
+        || reference.component_count != 1
+        || reference.group_count == 0
+        || reference.group_count != reference.active_sector_count
+        || reference.group_count != reference.destination_count
+        || reference.sector_count < reference.active_sector_count
+        || reference
+            .materialized_destination_count
+            .is_some_and(|count| count != reference.destination_count)
+        || reference.entry_count == 0
+        || reference.logical_entry_count != reference.entry_count
+        || reference.size_bytes == 0
+        || reference.sha256 != reference.semantic_digest
+        || !digest_is_canonical(&reference.sha256)
+        || !digest_is_canonical(&reference.semantic_digest)
+        || [
+            reference.group_count,
+            reference.sector_count,
+            reference.active_sector_count,
+            reference.component_count,
+            reference.destination_count,
+        ]
+        .into_iter()
+        .any(|value| u32::try_from(value).is_err())
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly color-contraction summary is inconsistent",
+        ));
+    }
+    let symmetric_group_fft = reference
+        .factorization
+        .as_ref()
+        .is_some_and(|factorization| {
+            factorization.kind == "symmetric-group-fourier"
+                && (2..=10).contains(&factorization.rank)
+                && factorization.coset_count > 0
+        });
+    if reference.factorization.is_some() != symmetric_group_fft
+        || (reference.storage == "convolution-kernels") != symmetric_group_fft
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly convolution-kernel storage requires symmetric-group Fourier factorization",
+        ));
+    }
+    if symmetric_group_fft {
+        let factorization = reference
+            .factorization
+            .as_ref()
+            .expect("validated symmetric-group factorization");
+        let provenance = reference.fft_provenance.as_ref().ok_or_else(|| {
+            RusticolError::integrity(
+                "on-the-fly symmetric-group Fourier summary is missing FFT provenance",
+            )
+        })?;
+        reference.validate_fft_provenance(factorization, provenance)?;
+    } else if reference.fft_provenance.is_some() {
+        return Err(RusticolError::integrity(
+            "on-the-fly non-FFT color summary carries FFT provenance",
+        ));
+    }
+    confined_internal_path(&reference.path, "on-the-fly color-contraction payload")?;
+    Ok(())
+}
+
+impl OnTheFlyRuntimeContainer {
+    pub(super) fn validate(&self) -> RusticolResult<()> {
+        if self.kind != ON_THE_FLY_RUNTIME_CONTAINER_KIND
+            || self.schema_version != ON_THE_FLY_RUNTIME_CONTAINER_SCHEMA
+            || self.storage_abi != ON_THE_FLY_RUNTIME_STORAGE_ABI
+        {
+            return Err(RusticolError::compatibility(
+                "unsupported on-the-fly runtime-container contract",
+            ));
+        }
+        if self.path != ON_THE_FLY_RUNTIME_CONTAINER_PATH
+            || self.seed_member_path != ON_THE_FLY_PROCESS_SEED_MEMBER
+        {
+            return Err(RusticolError::security(
+                "on-the-fly runtime container or seed path is not canonical",
+            ));
+        }
+        confined_internal_path(&self.path, "on-the-fly runtime container")?;
+        confined_internal_path(&self.seed_member_path, "on-the-fly process seed")?;
+        Ok(())
+    }
+}
+
+pub(super) fn parse_on_the_fly_execution_manifest(
+    bytes: &[u8],
+    outer: &ArtifactProcess,
+) -> RusticolResult<OnTheFlyExecutionManifest> {
+    let manifest: OnTheFlyExecutionManifest = serde_json::from_slice(bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse on-the-fly execution manifest: {error}"
+        ))
+    })?;
+    manifest.validate(outer)?;
+    Ok(manifest)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::{Value, json};
+
+    fn outer_with_accuracy(color_accuracy: &str) -> ArtifactProcess {
+        let color_capability = if color_accuracy == "lc" {
+            ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY
+        } else {
+            ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY
+        };
+        ArtifactProcess {
+            id: "d_dbar_to_t_tbar_g_g".into(),
+            expression: "d d~ > t t~ g g".into(),
+            color_accuracy: color_accuracy.into(),
+            external_pdgs: vec![1, -1, 6, -6, 21, 21],
+            physics_path: "processes/d_dbar_to_t_tbar_g_g/physics.json".into(),
+            required_runtime_capabilities: vec![
+                color_capability.into(),
+                ON_THE_FLY_RUNTIME_CAPABILITY.into(),
+            ],
+            aliases: Vec::new(),
+        }
+    }
+
+    fn outer() -> ArtifactProcess {
+        outer_with_accuracy("lc")
+    }
+
+    fn manifest() -> Value {
+        let outer = outer();
+        json!({
+            "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+            "kind": ON_THE_FLY_EXECUTION_KIND,
+            "required_runtime_capabilities": [
+                ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+                ON_THE_FLY_RUNTIME_CAPABILITY,
+            ],
+            "process": outer.expression,
+            "key": outer.id,
+            "color_accuracy": "lc",
+            "external_pdg_order": outer.external_pdgs,
+            "kernel_pack": {
+                "manifest_path": ON_THE_FLY_KERNEL_PACK_MANIFEST_PATH,
+                "payload_root": ON_THE_FLY_KERNEL_PAYLOAD_ROOT,
+            },
+            "runtime_options": {
+                "point_tile_size": 64,
+                "query_construction_threads": 4
+            },
+            "selector_policy": {
+                "color_coverage": "complete",
+                "reference_color_word": null,
+                "trace_reflections_folded": false,
+                "selector_census": {
+                    "physical_helicity_count": 64,
+                    "physical_color_flow_count": 6
+                }
+            },
+            "runtime_metadata": {
+                "runtime_parameters": [],
+                "prepared_parameter_defaults": [],
+                "parameter_projection": [],
+                "external_legs": [
+                    {"source_slot": 0, "public_label": 1, "physical_pdg": 1, "outgoing_pdg": -1, "is_initial": true},
+                    {"source_slot": 1, "public_label": 2, "physical_pdg": -1, "outgoing_pdg": 1, "is_initial": true},
+                    {"source_slot": 2, "public_label": 3, "physical_pdg": 6, "outgoing_pdg": 6, "is_initial": false},
+                    {"source_slot": 3, "public_label": 4, "physical_pdg": -6, "outgoing_pdg": -6, "is_initial": false},
+                    {"source_slot": 4, "public_label": 5, "physical_pdg": 21, "outgoing_pdg": 21, "is_initial": false},
+                    {"source_slot": 5, "public_label": 6, "physical_pdg": 21, "outgoing_pdg": 21, "is_initial": false}
+                ],
+                "particle_masses": [],
+                "normalization": {
+                    "color_accuracy": "lc",
+                    "color_factor": 1.0,
+                    "average_factor": 1.0,
+                    "identical_factor": 1.0,
+                    "global_coupling_factor": 1.0,
+                    "qcd_coupling_power": 0,
+                    "electroweak_coupling_power": 0,
+                    "couplings_in_stage_evaluators": true,
+                    "coupling_policy": "local"
+                },
+                "process_seed_identity": {
+                    "abi": ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI,
+                    "process_digest": "11".repeat(32),
+                    "compiled_model_digest": "22".repeat(32),
+                    "recurrence_template_catalog_digest": "33".repeat(32),
+                    "prepared_kernel_pack_digest": "44".repeat(32),
+                    "recurrence_direct_template_catalog_digest": "55".repeat(32),
+                    "semantic_digest": "66".repeat(32),
+                    "external_permutation": [0, 1, 2, 3, 4, 5],
+                    "external_sources": [
+                        {"source_slot": 0, "public_label": 1, "is_initial": true, "states": [{"state_index": 0, "public_helicity": -1, "prepared_mass_parameter_slot": null}]},
+                        {"source_slot": 1, "public_label": 2, "is_initial": true, "states": [{"state_index": 0, "public_helicity": 1, "prepared_mass_parameter_slot": null}]},
+                        {"source_slot": 2, "public_label": 3, "is_initial": false, "states": [{"state_index": 0, "public_helicity": -1, "prepared_mass_parameter_slot": null}]},
+                        {"source_slot": 3, "public_label": 4, "is_initial": false, "states": [{"state_index": 0, "public_helicity": 1, "prepared_mass_parameter_slot": null}]},
+                        {"source_slot": 4, "public_label": 5, "is_initial": false, "states": [{"state_index": 0, "public_helicity": -1, "prepared_mass_parameter_slot": null}]},
+                        {"source_slot": 5, "public_label": 6, "is_initial": false, "states": [{"state_index": 0, "public_helicity": 1, "prepared_mass_parameter_slot": null}]}
+                    ]
+                }
+            },
+            "runtime_container": {
+                "kind": ON_THE_FLY_RUNTIME_CONTAINER_KIND,
+                "schema_version": ON_THE_FLY_RUNTIME_CONTAINER_SCHEMA,
+                "storage_abi": ON_THE_FLY_RUNTIME_STORAGE_ABI,
+                "path": ON_THE_FLY_RUNTIME_CONTAINER_PATH,
+                "seed_member_path": ON_THE_FLY_PROCESS_SEED_MEMBER,
+            },
+        })
+    }
+
+    fn parse(value: &Value) -> RusticolResult<OnTheFlyExecutionManifest> {
+        parse_on_the_fly_execution_manifest(&serde_json::to_vec(value).unwrap(), &outer())
+    }
+
+    fn contracted_manifest(color_accuracy: &str) -> Value {
+        let mut value = manifest();
+        value["color_accuracy"] = json!(color_accuracy);
+        value["required_runtime_capabilities"] = json!([
+            ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+        ]);
+        value["selector_policy"]["color_coverage"] = json!("contracted");
+        value["selector_policy"]["selector_census"]["physical_color_flow_count"] = json!(1);
+        value["runtime_metadata"]["normalization"]["color_accuracy"] = json!(color_accuracy);
+        value["runtime_metadata"]["color_contraction"] = json!({
+            "abi": RECURRENCE_COLOR_CONTRACTION_CODEC_ABI,
+            "path": ON_THE_FLY_COLOR_CONTRACTION_PATH,
+            "size_bytes": 256,
+            "sha256": "77".repeat(32),
+            "color_accuracy": color_accuracy,
+            "storage": "expanded",
+            "includes_color_factor": true,
+            "group_count": 6,
+            "sector_count": 36,
+            "active_sector_count": 6,
+            "component_count": 1,
+            "destination_count": 6,
+            "entry_count": 12,
+            "logical_entry_count": 12,
+            "semantic_digest": "77".repeat(32),
+            "factorization": null,
+        });
+        value
+    }
+
+    fn parse_contracted(
+        value: &Value,
+        color_accuracy: &str,
+    ) -> RusticolResult<OnTheFlyExecutionManifest> {
+        parse_on_the_fly_execution_manifest(
+            &serde_json::to_vec(value).unwrap(),
+            &outer_with_accuracy(color_accuracy),
+        )
+    }
+
+    fn symmetric_group_contracted_manifest(color_accuracy: &str) -> Value {
+        let mut value = contracted_manifest(color_accuracy);
+        value["required_runtime_capabilities"] = json!([
+            ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+            SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+        ]);
+        let reference = &mut value["runtime_metadata"]["color_contraction"];
+        reference["storage"] = json!("convolution-kernels");
+        reference["factorization"] = json!({
+            "kind": "symmetric-group-fourier",
+            "rank": 2,
+            "coset_count": 3,
+        });
+        reference["fft_provenance"] = json!({
+            "method": "symmetric-group-fourier",
+            "degree": 2,
+            "channel_count": 3,
+            "covered_local_group_count": 6,
+            "residual_group_count": 0,
+            "residual_entry_count": 0,
+            "raw_kernel_bytes": 192,
+            "transformed_kernel_bytes": 96,
+            "capability": SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+        });
+        value
+    }
+
+    #[test]
+    fn accepts_only_the_compact_lc_contract() {
+        let parsed = parse(&manifest()).unwrap();
+        assert_eq!(parsed.runtime_options.point_tile_size, 64);
+        assert_eq!(parsed.runtime_options.query_construction_threads, 4);
+        assert_eq!(
+            parsed.selector_policy.selector_census,
+            OnTheFlySelectorCensus {
+                physical_helicity_count: 64,
+                physical_color_flow_count: 6,
+            }
+        );
+        assert_eq!(
+            parsed.runtime_container.seed_member_path,
+            ON_THE_FLY_PROCESS_SEED_MEMBER
+        );
+
+        let mut nlc = manifest();
+        nlc["color_accuracy"] = json!("nlc");
+        assert!(parse(&nlc).is_err());
+
+        let mut extra_capability = manifest();
+        extra_capability["required_runtime_capabilities"]
+            .as_array_mut()
+            .unwrap()
+            .push(json!("unrelated.capability.v1"));
+        assert!(parse(&extra_capability).is_err());
+
+        let mut zero_census = manifest();
+        zero_census["selector_policy"]["selector_census"]["physical_helicity_count"] = json!(0);
+        assert!(parse(&zero_census).is_err());
+
+        let mut incomplete_census = manifest();
+        incomplete_census["selector_policy"]["selector_census"]
+            .as_object_mut()
+            .unwrap()
+            .remove("physical_color_flow_count");
+        assert!(parse(&incomplete_census).is_err());
+
+        let mut zero_query_construction_threads = manifest();
+        zero_query_construction_threads["runtime_options"]["query_construction_threads"] = json!(0);
+        assert!(parse(&zero_query_construction_threads).is_err());
+    }
+
+    #[test]
+    fn contracted_color_requires_the_canonical_companion_and_public_census() {
+        for accuracy in ["nlc", "full"] {
+            let value = contracted_manifest(accuracy);
+            let parsed = parse_contracted(&value, accuracy).unwrap();
+            assert!(parsed.uses_contracted_color());
+            assert_eq!(
+                parsed
+                    .runtime_metadata
+                    .color_contraction
+                    .as_ref()
+                    .unwrap()
+                    .path,
+                ON_THE_FLY_COLOR_CONTRACTION_PATH
+            );
+
+            let mut materialized = value.clone();
+            materialized["runtime_metadata"]["color_contraction"]["materialized_destination_count"] =
+                json!(6);
+            parse_contracted(&materialized, accuracy).unwrap();
+
+            materialized["runtime_metadata"]["color_contraction"]["materialized_destination_count"] =
+                json!(5);
+            assert!(parse_contracted(&materialized, accuracy).is_err());
+
+            let mut missing = value.clone();
+            missing["runtime_metadata"]
+                .as_object_mut()
+                .unwrap()
+                .remove("color_contraction");
+            assert!(parse_contracted(&missing, accuracy).is_err());
+
+            let mut lc_capability = value.clone();
+            lc_capability["required_runtime_capabilities"][0] =
+                json!(ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY);
+            assert!(parse_contracted(&lc_capability, accuracy).is_err());
+
+            let mut public_flows = value.clone();
+            public_flows["selector_policy"]["selector_census"]["physical_color_flow_count"] =
+                json!(6);
+            assert!(parse_contracted(&public_flows, accuracy).is_err());
+
+            let mut sparse_destinations = value;
+            sparse_destinations["runtime_metadata"]["color_contraction"]["destination_count"] =
+                json!(7);
+            assert!(parse_contracted(&sparse_destinations, accuracy).is_err());
+        }
+
+        let mut lc_with_companion = manifest();
+        lc_with_companion["runtime_metadata"]["color_contraction"] =
+            contracted_manifest("full")["runtime_metadata"]["color_contraction"].clone();
+        assert!(parse(&lc_with_companion).is_err());
+    }
+
+    #[test]
+    fn symmetric_group_contracted_color_keeps_the_exact_otf_owner_domain() {
+        let value = symmetric_group_contracted_manifest("full");
+        parse_contracted(&value, "full").unwrap();
+
+        let mut retained_alias_destination = value.clone();
+        retained_alias_destination["runtime_metadata"]["color_contraction"]["destination_count"] =
+            json!(7);
+        assert!(parse_contracted(&retained_alias_destination, "full").is_err());
+
+        let mut missing_capability = value.clone();
+        missing_capability["required_runtime_capabilities"] = json!([
+            ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+        ]);
+        assert!(parse_contracted(&missing_capability, "full").is_err());
+
+        let mut stale_transformed_size = value;
+        stale_transformed_size["runtime_metadata"]["color_contraction"]["fft_provenance"]["transformed_kernel_bytes"] =
+            json!(88);
+        assert!(parse_contracted(&stale_transformed_size, "full").is_err());
+    }
+
+    #[test]
+    fn adjoint_basis_is_explicit_and_limited_to_contracted_color() {
+        assert_eq!(
+            parse(&manifest()).unwrap().selector_policy.color_basis,
+            OnTheFlyColorBasis::Trace
+        );
+        for accuracy in ["nlc", "full"] {
+            let mut value = symmetric_group_contracted_manifest(accuracy);
+            value["selector_policy"]["color_basis"] = json!("adjoint");
+            assert_eq!(
+                parse_contracted(&value, accuracy)
+                    .unwrap()
+                    .selector_policy
+                    .color_basis,
+                OnTheFlyColorBasis::Adjoint
+            );
+            value["selector_policy"]["color_basis"] = json!("unknown");
+            assert!(parse_contracted(&value, accuracy).is_err());
+        }
+        let mut lc = manifest();
+        lc["selector_policy"]["color_basis"] = json!("adjoint");
+        assert!(parse(&lc).is_err());
+    }
+
+    #[test]
+    fn selector_census_fails_closed_against_authenticated_adapter_counts() {
+        let census = parse(&manifest()).unwrap().selector_policy.selector_census;
+        census.validate_against(64, 6).unwrap();
+        assert!(census.validate_against(63, 6).is_err());
+        assert!(census.validate_against(64, 5).is_err());
+    }
+
+    #[test]
+    fn rejects_noncanonical_runtime_and_kernel_paths() {
+        let mut runtime_escape = manifest();
+        runtime_escape["runtime_container"]["seed_member_path"] = json!("../seed.bin");
+        assert!(parse(&runtime_escape).is_err());
+
+        let mut kernel_alias = manifest();
+        kernel_alias["kernel_pack"]["manifest_path"] = json!("model/other.json");
+        assert!(parse(&kernel_alias).is_err());
+    }
+
+    #[test]
+    fn rejects_unbound_process_seed_identity_metadata() {
+        let mut stale_abi = manifest();
+        stale_abi["runtime_metadata"]["process_seed_identity"]["abi"] = json!("stale-v0");
+        assert!(parse(&stale_abi).is_err());
+
+        let mut changed_anchor = manifest();
+        changed_anchor["runtime_metadata"]["process_seed_identity"]["external_sources"][0]["public_label"] =
+            json!(9);
+        assert!(parse(&changed_anchor).is_err());
+
+        let mut unknown_field = manifest();
+        unknown_field["runtime_metadata"]["process_seed_identity"]["opaque"] = json!(true);
+        assert!(parse(&unknown_field).is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_public_metadata.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_public_metadata.rs
new file mode 100644
index 0000000000..43dd2f8568
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_public_metadata.rs
@@ -0,0 +1,481 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Compact public metadata for the on-the-fly lane.
+//!
+//! Ordinary evaluation needs only this O(externals + parameters) payload.
+//! The complete public helicity axis and LC color axis remain in the compact
+//! selector adapter and are materialized only when the established physics
+//! metadata API is explicitly requested. NLC/full expose one contracted color.
+
+use super::on_the_fly_manifest::OnTheFlyExecutionManifest;
+use super::on_the_fly_selectors::{
+    OnTheFlyCompactSelectorAdapterV1, OnTheFlySelectorIntrospectionCacheV1,
+};
+use crate::{
+    ArtifactProcess, ColorAccuracy, ColorComponent, ContractedColor, Coverage, ExternalParticle,
+    Helicity, LcColorFlow, ModelParameter, ParameterKind, ProcessPhysics as ProcessPhysicsV1,
+    Reduction, ReductionKind, RusticolError, RusticolResult, SelectorCapabilities,
+};
+use serde::Deserialize;
+use std::collections::{BTreeMap, BTreeSet};
+
+const ON_THE_FLY_PUBLIC_METADATA_KIND: &str = "pyamplicol-on-the-fly-public-metadata";
+const ON_THE_FLY_PUBLIC_METADATA_SCHEMA: u32 = 1;
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct OnTheFlyPublicMetadataV1 {
+    schema_version: u32,
+    kind: String,
+    process_id: String,
+    process: String,
+    color_accuracy: ColorAccuracy,
+    external_particles: Vec<ExternalParticle>,
+    model_parameters: Vec<ModelParameter>,
+}
+
+impl OnTheFlyPublicMetadataV1 {
+    #[cfg(test)]
+    pub(super) fn for_test(
+        process_id: &str,
+        process: &str,
+        external_particles: Vec<ExternalParticle>,
+    ) -> Self {
+        Self {
+            schema_version: ON_THE_FLY_PUBLIC_METADATA_SCHEMA,
+            kind: ON_THE_FLY_PUBLIC_METADATA_KIND.to_string(),
+            process_id: process_id.to_string(),
+            process: process.to_string(),
+            color_accuracy: ColorAccuracy::Lc,
+            external_particles,
+            model_parameters: Vec::new(),
+        }
+    }
+
+    fn validate(
+        &self,
+        path: &str,
+        outer: &ArtifactProcess,
+        manifest: &OnTheFlyExecutionManifest,
+    ) -> RusticolResult<()> {
+        if self.schema_version != ON_THE_FLY_PUBLIC_METADATA_SCHEMA
+            || self.kind != ON_THE_FLY_PUBLIC_METADATA_KIND
+        {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported on-the-fly public metadata kind {:?} schema {} at {path:?}; regenerate the artifact",
+                self.kind, self.schema_version
+            )));
+        }
+        if self.process_id != outer.id
+            || self.process != outer.expression
+            || self.process_id != manifest.key
+            || self.process != manifest.process
+            || self.color_accuracy.as_str() != outer.color_accuracy
+            || self.color_accuracy.as_str() != manifest.color_accuracy
+        {
+            return Err(RusticolError::integrity(format!(
+                "on-the-fly public metadata {path:?} does not match representative process {:?}",
+                outer.id
+            )));
+        }
+        if self.external_particles.len() != outer.external_pdgs.len()
+            || self.external_particles.len() != manifest.runtime_metadata.external_legs.len()
+            || self.external_particles.len() < 3
+        {
+            return Err(RusticolError::integrity(format!(
+                "on-the-fly public metadata {path:?} has inconsistent external-particle coverage"
+            )));
+        }
+        let expected_components = ["E", "px", "py", "pz"];
+        for (index, ((particle, expected_pdg), runtime_leg)) in self
+            .external_particles
+            .iter()
+            .zip(&outer.external_pdgs)
+            .zip(&manifest.runtime_metadata.external_legs)
+            .enumerate()
+        {
+            let expected_role = if runtime_leg.is_initial {
+                crate::ParticleRole::Initial
+            } else {
+                crate::ParticleRole::Final
+            };
+            if particle.index != index
+                || particle.label != index + 1
+                || particle.momentum_slot != index
+                || particle.particle.is_empty()
+                || particle.pdg != *expected_pdg
+                || particle.pdg != runtime_leg.physical_pdg
+                || particle.role != expected_role
+                || particle
+                    .momentum_components
+                    .iter()
+                    .map(String::as_str)
+                    .ne(expected_components)
+            {
+                return Err(RusticolError::integrity(format!(
+                    "on-the-fly public metadata {path:?} has invalid external particle {index}"
+                )));
+            }
+        }
+        let mut parameter_names = BTreeSet::new();
+        for parameter in &self.model_parameters {
+            if parameter.name.is_empty()
+                || !parameter_names.insert(parameter.name.as_str())
+                || !parameter.default_real.is_finite()
+                || !parameter.default_imaginary.is_finite()
+                || (parameter.kind == ParameterKind::Derived && parameter.mutable)
+            {
+                return Err(RusticolError::artifact(format!(
+                    "on-the-fly public metadata {path:?} has invalid model parameter {:?}",
+                    parameter.name
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    /// Materialize the existing public physics schema only for explicit
+    /// metadata access. Every selector is executed directly by this lane, so
+    /// each public member is its own exact representative with unit weight.
+    pub(super) fn synthesize(
+        &self,
+        selectors: &OnTheFlyCompactSelectorAdapterV1,
+    ) -> RusticolResult<ProcessPhysicsV1> {
+        let mut introspection = OnTheFlySelectorIntrospectionCacheV1::default();
+        let helicities = introspection
+            .helicities(selectors)?
+            .iter()
+            .map(|record| Helicity {
+                id: record.id.clone(),
+                index: record.index,
+                values: record.values.to_vec(),
+                computed: true,
+                structural_zero: false,
+                representative_id: record.id.clone(),
+                coefficient: 1.0,
+            })
+            .collect();
+        let (color_components, coverage_color, coverage_color_kind, reduction, selectors_metadata) =
+            match self.color_accuracy {
+                ColorAccuracy::Lc => {
+                    let color_components = introspection
+                        .colors(selectors)?
+                        .iter()
+                        .map(|record| {
+                            Ok(ColorComponent::LcFlow(LcColorFlow {
+                                id: record.id.clone(),
+                                index: record.index,
+                                word: record
+                                    .word
+                                    .iter()
+                                    .copied()
+                                    .map(|label| {
+                                        usize::try_from(label).map_err(|_| {
+                                            RusticolError::artifact(
+                                                "on-the-fly public color label exceeds usize",
+                                            )
+                                        })
+                                    })
+                                    .collect::<RusticolResult<Vec<_>>>()?,
+                                computed: true,
+                                representative_id: record.id.clone(),
+                                coefficient: 1.0,
+                            }))
+                        })
+                        .collect::<RusticolResult<Vec<_>>>()?;
+                    (
+                        color_components,
+                        "complete".to_string(),
+                        "physical-lc-flows".to_string(),
+                        Reduction {
+                            kind: ReductionKind::LcDiagonal,
+                            groups: Vec::new(),
+                        },
+                        SelectorCapabilities {
+                            helicity: true,
+                            color_flow: true,
+                            contracted_color: false,
+                        },
+                    )
+                }
+                ColorAccuracy::Nlc | ColorAccuracy::Full => (
+                    vec![ColorComponent::ContractedColor(ContractedColor {
+                        id: "color:contracted".to_string(),
+                        index: 0,
+                        description:
+                            "coherent sparse contraction of the complete ordered color basis"
+                                .to_string(),
+                    })],
+                    "contracted".to_string(),
+                    "contracted-color".to_string(),
+                    Reduction {
+                        kind: ReductionKind::ContractedColor,
+                        groups: Vec::new(),
+                    },
+                    SelectorCapabilities {
+                        helicity: true,
+                        color_flow: false,
+                        contracted_color: false,
+                    },
+                ),
+            };
+        let physics = ProcessPhysicsV1 {
+            schema_version: crate::RUNTIME_PHYSICS_SCHEMA_VERSION,
+            kind: "pyamplicol-resolved-physics".to_string(),
+            process_id: self.process_id.clone(),
+            process: self.process.clone(),
+            color_accuracy: self.color_accuracy,
+            coverage: Coverage {
+                helicities: "complete".to_string(),
+                color: coverage_color,
+                color_kind: coverage_color_kind,
+                structural_zero_helicity_count: 0,
+            },
+            external_particles: self.external_particles.clone(),
+            helicities,
+            color_components,
+            // Unlike eager/recurrence, the on-the-fly lane has no
+            // pre-materialized public quotient groups to hydrate here.
+            reduction,
+            model_parameters: self.model_parameters.clone(),
+            selectors: selectors_metadata,
+            extensions: BTreeMap::new(),
+        };
+        physics.validate()?;
+        Ok(physics)
+    }
+}
+
+pub(super) fn parse_on_the_fly_public_metadata(
+    bytes: &[u8],
+    path: &str,
+    outer: &ArtifactProcess,
+    manifest: &OnTheFlyExecutionManifest,
+) -> RusticolResult<OnTheFlyPublicMetadataV1> {
+    let metadata: OnTheFlyPublicMetadataV1 = serde_json::from_slice(bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse on-the-fly public metadata {path:?}: {error}"
+        ))
+    })?;
+    metadata.validate(path, outer, manifest)?;
+    Ok(metadata)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::engine::on_the_fly_manifest::{
+        ON_THE_FLY_EXECUTION_KIND, ON_THE_FLY_KERNEL_PACK_MANIFEST_PATH,
+        ON_THE_FLY_KERNEL_PAYLOAD_ROOT, ON_THE_FLY_PROCESS_SEED_MEMBER,
+        ON_THE_FLY_RUNTIME_CONTAINER_KIND, ON_THE_FLY_RUNTIME_CONTAINER_PATH,
+        ON_THE_FLY_RUNTIME_CONTAINER_SCHEMA, ON_THE_FLY_RUNTIME_STORAGE_ABI,
+        parse_on_the_fly_execution_manifest,
+    };
+    use crate::engine::{ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY, ON_THE_FLY_RUNTIME_CAPABILITY};
+    use serde_json::{Value, json};
+
+    fn outer_with_accuracy(color_accuracy: &str) -> ArtifactProcess {
+        ArtifactProcess {
+            id: "d_dbar_to_z".into(),
+            expression: "d d~ > z".into(),
+            color_accuracy: color_accuracy.into(),
+            external_pdgs: vec![1, -1, 23],
+            physics_path: "processes/d_dbar_to_z/physics.json".into(),
+            required_runtime_capabilities: vec![
+                ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY.into(),
+                ON_THE_FLY_RUNTIME_CAPABILITY.into(),
+            ],
+            aliases: Vec::new(),
+        }
+    }
+
+    fn outer() -> ArtifactProcess {
+        outer_with_accuracy("lc")
+    }
+
+    fn execution() -> OnTheFlyExecutionManifest {
+        let outer = outer();
+        let value = json!({
+            "schema_version": crate::PROCESS_ARTIFACT_SCHEMA_VERSION,
+            "kind": ON_THE_FLY_EXECUTION_KIND,
+            "required_runtime_capabilities": [
+                ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+                ON_THE_FLY_RUNTIME_CAPABILITY,
+            ],
+            "process": outer.expression,
+            "key": outer.id,
+            "color_accuracy": "lc",
+            "external_pdg_order": outer.external_pdgs,
+            "kernel_pack": {
+                "manifest_path": ON_THE_FLY_KERNEL_PACK_MANIFEST_PATH,
+                "payload_root": ON_THE_FLY_KERNEL_PAYLOAD_ROOT,
+            },
+            "runtime_options": {
+                "point_tile_size": 64,
+                "query_construction_threads": 1
+            },
+            "selector_policy": {
+                "color_coverage": "complete",
+                "reference_color_word": null,
+                "trace_reflections_folded": false,
+                "selector_census": {
+                    "physical_helicity_count": 1,
+                    "physical_color_flow_count": 1,
+                },
+            },
+            "runtime_metadata": {
+                "runtime_parameters": [],
+                "prepared_parameter_defaults": [],
+                "parameter_projection": [],
+                "external_legs": [
+                    {"source_slot": 0, "public_label": 1, "physical_pdg": 1, "outgoing_pdg": -1, "is_initial": true},
+                    {"source_slot": 1, "public_label": 2, "physical_pdg": -1, "outgoing_pdg": 1, "is_initial": true},
+                    {"source_slot": 2, "public_label": 3, "physical_pdg": 23, "outgoing_pdg": 23, "is_initial": false},
+                ],
+                "particle_masses": [],
+                "normalization": {
+                    "color_accuracy": "lc",
+                    "color_factor": 1.0,
+                    "average_factor": 1.0,
+                    "identical_factor": 1.0,
+                    "global_coupling_factor": 1.0,
+                    "qcd_coupling_power": 0,
+                    "electroweak_coupling_power": 0,
+                    "couplings_in_stage_evaluators": true,
+                    "coupling_policy": "local",
+                },
+                "process_seed_identity": {
+                    "abi": crate::recurrence::on_the_fly::ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI,
+                    "process_digest": "11".repeat(32),
+                    "compiled_model_digest": "22".repeat(32),
+                    "recurrence_template_catalog_digest": "33".repeat(32),
+                    "prepared_kernel_pack_digest": "44".repeat(32),
+                    "recurrence_direct_template_catalog_digest": "55".repeat(32),
+                    "semantic_digest": "66".repeat(32),
+                    "external_permutation": [0, 1, 2],
+                    "external_sources": [
+                        {"source_slot": 0, "public_label": 1, "is_initial": true, "states": [{"state_index": 0, "public_helicity": -1, "prepared_mass_parameter_slot": null}]},
+                        {"source_slot": 1, "public_label": 2, "is_initial": true, "states": [{"state_index": 0, "public_helicity": 1, "prepared_mass_parameter_slot": null}]},
+                        {"source_slot": 2, "public_label": 3, "is_initial": false, "states": [{"state_index": 0, "public_helicity": 0, "prepared_mass_parameter_slot": null}]}
+                    ]
+                },
+            },
+            "runtime_container": {
+                "kind": ON_THE_FLY_RUNTIME_CONTAINER_KIND,
+                "schema_version": ON_THE_FLY_RUNTIME_CONTAINER_SCHEMA,
+                "storage_abi": ON_THE_FLY_RUNTIME_STORAGE_ABI,
+                "path": ON_THE_FLY_RUNTIME_CONTAINER_PATH,
+                "seed_member_path": ON_THE_FLY_PROCESS_SEED_MEMBER,
+            },
+        });
+        parse_on_the_fly_execution_manifest(&serde_json::to_vec(&value).unwrap(), &outer).unwrap()
+    }
+
+    fn compact() -> Value {
+        json!({
+            "schema_version": ON_THE_FLY_PUBLIC_METADATA_SCHEMA,
+            "kind": ON_THE_FLY_PUBLIC_METADATA_KIND,
+            "process_id": "d_dbar_to_z",
+            "process": "d d~ > z",
+            "color_accuracy": "lc",
+            "external_particles": [
+                {"index": 0, "label": 1, "particle": "d", "pdg": 1, "role": "initial", "momentum_slot": 0, "momentum_components": ["E", "px", "py", "pz"]},
+                {"index": 1, "label": 2, "particle": "d~", "pdg": -1, "role": "initial", "momentum_slot": 1, "momentum_components": ["E", "px", "py", "pz"]},
+                {"index": 2, "label": 3, "particle": "z", "pdg": 23, "role": "final", "momentum_slot": 2, "momentum_components": ["E", "px", "py", "pz"]},
+            ],
+            "model_parameters": [
+                {"name": "alpha_s", "kind": "external", "default_real": 0.118, "default_imaginary": 0.0, "mutable": true},
+            ],
+        })
+    }
+
+    fn parse(value: &Value) -> RusticolResult<OnTheFlyPublicMetadataV1> {
+        parse_on_the_fly_public_metadata(
+            &serde_json::to_vec(value).unwrap(),
+            &outer().physics_path,
+            &outer(),
+            &execution(),
+        )
+    }
+
+    fn parse_contracted(
+        value: &Value,
+        color_accuracy: &str,
+    ) -> RusticolResult<OnTheFlyPublicMetadataV1> {
+        let outer = outer_with_accuracy(color_accuracy);
+        let mut manifest = execution();
+        manifest.color_accuracy = color_accuracy.to_string();
+        parse_on_the_fly_public_metadata(
+            &serde_json::to_vec(value).unwrap(),
+            &outer.physics_path,
+            &outer,
+            &manifest,
+        )
+    }
+
+    #[test]
+    fn compact_metadata_authenticates_identity_externals_and_parameters() {
+        parse(&compact()).unwrap();
+
+        let mut cases = Vec::new();
+        let mut wrong_kind = compact();
+        wrong_kind["kind"] = json!("pyamplicol-resolved-physics");
+        cases.push(wrong_kind);
+        let mut wrong_schema = compact();
+        wrong_schema["schema_version"] = json!(2);
+        cases.push(wrong_schema);
+        let mut wrong_id = compact();
+        wrong_id["process_id"] = json!("other");
+        cases.push(wrong_id);
+        let mut wrong_process = compact();
+        wrong_process["process"] = json!("d d~ > a");
+        cases.push(wrong_process);
+        let mut wrong_accuracy = compact();
+        wrong_accuracy["color_accuracy"] = json!("nlc");
+        cases.push(wrong_accuracy);
+
+        for invalid in cases {
+            assert!(parse(&invalid).is_err());
+        }
+    }
+
+    #[test]
+    fn compact_metadata_accepts_contracted_nlc_and_full_accuracy() {
+        for accuracy in ["nlc", "full"] {
+            let mut value = compact();
+            value["color_accuracy"] = json!(accuracy);
+            let parsed = parse_contracted(&value, accuracy).unwrap();
+            assert_eq!(parsed.color_accuracy.as_str(), accuracy);
+
+            value["color_accuracy"] = json!("lc");
+            assert!(parse_contracted(&value, accuracy).is_err());
+        }
+    }
+
+    #[test]
+    fn compact_metadata_tampering_fails_closed() {
+        let mut cases = Vec::new();
+        let mut wrong_pdg = compact();
+        wrong_pdg["external_particles"][2]["pdg"] = json!(22);
+        cases.push(wrong_pdg);
+        let mut wrong_role = compact();
+        wrong_role["external_particles"][1]["role"] = json!("final");
+        cases.push(wrong_role);
+        let mut wrong_slot = compact();
+        wrong_slot["external_particles"][2]["momentum_slot"] = json!(1);
+        cases.push(wrong_slot);
+        let mut wrong_components = compact();
+        wrong_components["external_particles"][0]["momentum_components"][0] = json!("energy");
+        cases.push(wrong_components);
+        let mut invalid_parameter = compact();
+        invalid_parameter["model_parameters"][0]["kind"] = json!("derived");
+        cases.push(invalid_parameter);
+        let mut unknown_field = compact();
+        unknown_field["dense_helicities"] = json!([]);
+        cases.push(unknown_field);
+
+        for invalid in cases {
+            assert!(parse(&invalid).is_err());
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_selectors.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_selectors.rs
new file mode 100644
index 0000000000..d8bc4e5320
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_selectors.rs
@@ -0,0 +1,2034 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Compact public-selector adapter for the private LC on-the-fly lane.
+//!
+//! The established runtime API addresses helicities as `h:+1,-1,...` and LC
+//! components as `flow:<external labels>` (or `flow:singlet`).  This module
+//! preserves those strings without loading a process-wide physics table.  It
+//! snapshots only O(external-state) seed data and derives individual axis
+//! members by ordinal when a selector or explicit introspection call needs
+//! them.
+//!
+//! Complete LC axes are factorial for general processes.  Accordingly,
+//! [`OnTheFlyLazySelectionV1`] is a lazy materializer: load, total evaluation,
+//! profiling, and benchmarking need not create dense helicity/color metadata.
+//! A caller which genuinely requests resolved metadata may explicitly
+//! materialize it through [`OnTheFlySelectorIntrospectionCacheV1`].
+
+use super::on_the_fly_lane::{OnTheFlyLcQueryRequestV1, OnTheFlyLcReductionTargetV1};
+use super::on_the_fly_manifest::OnTheFlyColorBasis;
+use crate::recurrence::on_the_fly::{
+    DecodedLcQueryV1, OnTheFlyExternalColorRoleV1, OnTheFlyLcSelectorV1, OnTheFlyProcessSeedV1,
+};
+use crate::{RusticolError, RusticolResult};
+use std::collections::{BTreeMap, BTreeSet};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::selector(format!("on-the-fly selector: {}", message.into()))
+}
+
+fn integrity(message: impl Into<String>) -> RusticolError {
+    RusticolError::integrity(format!("on-the-fly selector: {}", message.into()))
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct CompactExternalV1 {
+    source_slot: u32,
+    public_slot: u32,
+    public_label: u32,
+    is_initial: bool,
+    color_role: OnTheFlyExternalColorRoleV1,
+    public_helicities: Box<[i32]>,
+}
+
+/// Compact seed-derived external record.  Particle names and PDGs remain
+/// owned by the existing process-selection metadata; this structural record
+/// supplies the selector-relevant half of that existing API on demand.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct OnTheFlyExternalSelectorRecordV1 {
+    pub(super) source_slot: u32,
+    pub(super) public_slot: u32,
+    pub(super) public_label: u32,
+    pub(super) is_initial: bool,
+    pub(super) color_role: OnTheFlyExternalColorRoleV1,
+}
+
+/// One exact established public helicity ID, materialized only on request.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct OnTheFlyHelicitySelectorRecordV1 {
+    pub(super) id: String,
+    pub(super) index: usize,
+    pub(super) values: Box<[i32]>,
+}
+
+/// One exact established public LC color ID, materialized only on request.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct OnTheFlyColorSelectorRecordV1 {
+    pub(super) id: String,
+    pub(super) index: usize,
+    pub(super) word: Box<[u32]>,
+    pub(super) selector: OnTheFlyLcSelectorV1,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum CompactColorDomainV1 {
+    Singlet,
+    SingleTrace,
+    OpenLines,
+}
+
+/// Exact compact coverage marker supplied by generation.  Incomplete color
+/// coverage would require retaining the selected dense flow list, defeating
+/// this lane's process-seed contract, so it is rejected at construction.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum OnTheFlyLcColorCoverageV1 {
+    Complete,
+    #[expect(
+        dead_code,
+        reason = "retained as the explicit rejected compatibility sentinel"
+    )]
+    Incomplete,
+}
+
+/// Small generation-owned selector policy which cannot be reconstructed from
+/// external roles.  `reference_color_word` may reorder one ordinary complete
+/// flow to the front; reflection folding changes pure-trace public ordering
+/// while preserving both members as public aliases. Contracted adjoint colour
+/// instead retains ordinary trace amplitudes with two fixed DDM endpoints.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct OnTheFlyLcSelectorPolicyV1 {
+    pub(super) color_coverage: OnTheFlyLcColorCoverageV1,
+    pub(super) color_basis: OnTheFlyColorBasis,
+    pub(super) reference_color_word: Option<Box<[u32]>>,
+    pub(super) trace_reflections_folded: bool,
+}
+
+impl OnTheFlyLcSelectorPolicyV1 {
+    #[cfg(test)]
+    pub(super) fn complete(
+        reference_color_word: Option<Vec<u32>>,
+        trace_reflections_folded: bool,
+    ) -> Self {
+        Self {
+            color_coverage: OnTheFlyLcColorCoverageV1::Complete,
+            color_basis: OnTheFlyColorBasis::Trace,
+            reference_color_word: reference_color_word.map(Vec::into_boxed_slice),
+            trace_reflections_folded,
+        }
+    }
+}
+
+type OnTheFlySelectedOrdinalsV1 = (Option<Box<[usize]>>, Option<Box<[usize]>>);
+
+/// O(external-state) selector owner retained beside the private native lane.
+#[derive(Clone, Debug)]
+pub(super) struct OnTheFlyCompactSelectorAdapterV1 {
+    external_permutation: Box<[u32]>,
+    representative_to_public: Box<[u32]>,
+    public_to_representative: Box<[u32]>,
+    public_label_by_representative_label: BTreeMap<u32, u32>,
+    representative_label_by_public_label: BTreeMap<u32, u32>,
+    externals_by_public_slot: Box<[CompactExternalV1]>,
+    public_slot_by_label: BTreeMap<u32, usize>,
+    fundamental_labels: Box<[u32]>,
+    antifundamental_labels: Box<[u32]>,
+    adjoint_labels: Box<[u32]>,
+    color_domain: CompactColorDomainV1,
+    color_basis: OnTheFlyColorBasis,
+    reference_unfolded_color_ordinal: Option<usize>,
+    trace_reflections_folded: bool,
+    helicity_count: usize,
+    color_count: usize,
+}
+
+impl OnTheFlyCompactSelectorAdapterV1 {
+    /// Snapshot only selector-relevant seed data.  The accessors used here are
+    /// intentionally narrow; they do not expose the recurrence catalogs or a
+    /// dense public-flow table.
+    pub(super) fn from_seed(
+        seed: &OnTheFlyProcessSeedV1,
+        policy: OnTheFlyLcSelectorPolicyV1,
+    ) -> RusticolResult<Self> {
+        if policy.color_coverage != OnTheFlyLcColorCoverageV1::Complete {
+            return Err(invalid(
+                "on-the-fly LC requires complete public color coverage",
+            ));
+        }
+        let external_permutation = seed.external_permutation();
+        let anchors = seed.source_anchors();
+        if external_permutation.len() != anchors.len() {
+            return Err(integrity(
+                "external permutation and source-anchor domains differ",
+            ));
+        }
+
+        let mut by_public = vec![None; anchors.len()];
+        let mut public_slot_by_label = BTreeMap::new();
+        for anchor in anchors {
+            let public_slot = *external_permutation
+                .get(anchor.source_slot() as usize)
+                .ok_or_else(|| integrity("source anchor is outside the gather map"))?;
+            let destination = by_public
+                .get_mut(public_slot as usize)
+                .ok_or_else(|| integrity("gather map public slot is out of bounds"))?;
+            if destination.is_some() {
+                return Err(integrity("gather map repeats a public external slot"));
+            }
+            if public_slot_by_label
+                .insert(anchor.external_label(), public_slot as usize)
+                .is_some()
+            {
+                return Err(integrity("compact seed repeats a public external label"));
+            }
+            let mut public_helicities = Vec::new();
+            public_helicities
+                .try_reserve_exact(anchor.states().len())
+                .map_err(|error| invalid(format!("helicity-domain allocation failed: {error}")))?;
+            for state in anchor.states() {
+                let helicity = state.public_helicity();
+                if public_helicities.contains(&helicity) {
+                    return Err(integrity(format!(
+                        "source slot {} repeats public helicity {helicity}",
+                        anchor.source_slot(),
+                    )));
+                }
+                public_helicities.push(helicity);
+            }
+            if public_helicities.is_empty() {
+                return Err(integrity("source anchor has no public helicity"));
+            }
+            *destination = Some(CompactExternalV1 {
+                source_slot: anchor.source_slot(),
+                public_slot,
+                public_label: anchor.external_label(),
+                is_initial: anchor.is_initial(),
+                color_role: anchor.color_role(),
+                public_helicities: public_helicities.into_boxed_slice(),
+            });
+        }
+        let externals_by_public_slot = by_public
+            .into_iter()
+            .map(|entry| entry.ok_or_else(|| integrity("gather map omits a public slot")))
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+
+        // Pairing classes are not color-flow pairings: they authenticate Wick
+        // compatibility.  Nevertheless, checking their endpoint coverage here
+        // ensures that every fundamental/antifundamental role used to split a
+        // public flow is backed by the same compact seed contract.
+        let mut pairing_endpoints = BTreeSet::new();
+        for pairing_class in seed.pairing_classes() {
+            for endpoint in pairing_class
+                .fundamental_endpoints()
+                .iter()
+                .chain(pairing_class.antifundamental_endpoints())
+            {
+                if !pairing_endpoints.insert(endpoint.source_slot) {
+                    return Err(integrity("pairing classes repeat an endpoint"));
+                }
+            }
+        }
+
+        let mut fundamental_labels = Vec::new();
+        let mut antifundamental_labels = Vec::new();
+        let mut adjoint_labels = Vec::new();
+        let mut required_pairing_endpoints = BTreeSet::new();
+        for external in externals_by_public_slot.iter() {
+            match external.color_role {
+                OnTheFlyExternalColorRoleV1::Singlet => {}
+                OnTheFlyExternalColorRoleV1::Fundamental => {
+                    fundamental_labels.push(external.public_label);
+                    required_pairing_endpoints.insert(external.source_slot);
+                }
+                OnTheFlyExternalColorRoleV1::Antifundamental => {
+                    antifundamental_labels.push(external.public_label);
+                    required_pairing_endpoints.insert(external.source_slot);
+                }
+                OnTheFlyExternalColorRoleV1::Adjoint => {
+                    adjoint_labels.push(external.public_label);
+                }
+            }
+        }
+        if pairing_endpoints != required_pairing_endpoints {
+            return Err(integrity(
+                "pairing-class coverage differs from the open-line endpoint roles",
+            ));
+        }
+        fundamental_labels.sort_unstable();
+        antifundamental_labels.sort_unstable();
+        adjoint_labels.sort_unstable();
+        if fundamental_labels.len() != antifundamental_labels.len() {
+            return Err(integrity(
+                "LC selector domain has unbalanced open-line endpoints",
+            ));
+        }
+
+        let color_domain = if !fundamental_labels.is_empty() {
+            CompactColorDomainV1::OpenLines
+        } else if !adjoint_labels.is_empty() {
+            CompactColorDomainV1::SingleTrace
+        } else {
+            CompactColorDomainV1::Singlet
+        };
+        if policy.color_basis == OnTheFlyColorBasis::Adjoint
+            && (adjoint_labels.len() < 2
+                || !fundamental_labels.is_empty()
+                || policy.trace_reflections_folded)
+        {
+            return Err(integrity(
+                "adjoint color basis requires at least two adjoint external sources, no fundamental lines and no trace-reflection folding",
+            ));
+        }
+        let helicity_count = checked_product(
+            externals_by_public_slot
+                .iter()
+                .map(|external| external.public_helicities.len()),
+            "public helicity count",
+        )?;
+        let color_count = match color_domain {
+            CompactColorDomainV1::Singlet => 1,
+            CompactColorDomainV1::SingleTrace => {
+                single_trace_color_count(adjoint_labels.len(), policy.color_basis)?
+            }
+            CompactColorDomainV1::OpenLines => {
+                let line_count = fundamental_labels.len();
+                let pairing_count = checked_factorial(line_count, "open-line pairing count")?;
+                let adjoint_order_count =
+                    checked_factorial(adjoint_labels.len(), "adjoint order count")?;
+                let split_count = checked_binomial(
+                    adjoint_labels
+                        .len()
+                        .checked_add(line_count.saturating_sub(1))
+                        .ok_or_else(|| invalid("open-line split domain exceeds usize"))?,
+                    line_count.saturating_sub(1),
+                    "open-line split count",
+                )?;
+                pairing_count
+                    .checked_mul(adjoint_order_count)
+                    .and_then(|value| value.checked_mul(split_count))
+                    .ok_or_else(|| invalid("LC open-line flow count exceeds usize"))?
+            }
+        };
+        if policy.trace_reflections_folded && color_domain != CompactColorDomainV1::SingleTrace {
+            return Err(integrity(
+                "trace-reflection folding is valid only for a pure single-trace LC domain",
+            ));
+        }
+        let mut adapter = Self {
+            external_permutation: external_permutation.to_vec().into_boxed_slice(),
+            representative_to_public: (0..anchors.len() as u32)
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            public_to_representative: (0..anchors.len() as u32)
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            public_label_by_representative_label: public_slot_by_label
+                .keys()
+                .copied()
+                .map(|label| (label, label))
+                .collect(),
+            representative_label_by_public_label: public_slot_by_label
+                .keys()
+                .copied()
+                .map(|label| (label, label))
+                .collect(),
+            externals_by_public_slot,
+            public_slot_by_label,
+            fundamental_labels: fundamental_labels.into_boxed_slice(),
+            antifundamental_labels: antifundamental_labels.into_boxed_slice(),
+            adjoint_labels: adjoint_labels.into_boxed_slice(),
+            color_domain,
+            color_basis: policy.color_basis,
+            reference_unfolded_color_ordinal: None,
+            trace_reflections_folded: policy.trace_reflections_folded,
+            helicity_count,
+            color_count,
+        };
+        if let Some(reference) = policy.reference_color_word {
+            if reference.is_empty() {
+                if adapter.color_domain != CompactColorDomainV1::Singlet {
+                    return Err(invalid(
+                        "empty reference color word is valid only for a singlet process",
+                    ));
+                }
+            } else {
+                // Requiring a member of the ordinary complete axis excludes
+                // anti-endpoint-first and whole-block traversal aliases. Such
+                // references are useful generation hints, but are not distinct
+                // complete LC public components and cannot be retained without
+                // a dense exceptional-flow table.
+                adapter.selector_from_labels(&reference)?;
+                let ordinal = adapter.unfolded_color_ordinal(&reference)?;
+                let (actual, _) = adapter.unfolded_color_at(ordinal)?;
+                if actual.as_ref() != reference.as_ref() {
+                    return Err(invalid(
+                        "reference color word is not a member of the ordinary complete LC axis",
+                    ));
+                }
+                if adapter.trace_reflections_folded {
+                    let reflected = reflected_trace_word(&reference)?;
+                    let reflected_ordinal = adapter.unfolded_color_ordinal(&reflected)?;
+                    if ordinal > reflected_ordinal {
+                        return Err(invalid(
+                            "folded trace reference must be the canonical member of its reflection class",
+                        ));
+                    }
+                }
+                adapter.reference_unfolded_color_ordinal = Some(ordinal);
+            }
+        }
+        Ok(adapter)
+    }
+
+    /// Project public selector IDs through an already authenticated artifact
+    /// alias without changing the representative compact seed or its query
+    /// identity. The mapping is representative public slot -> requested public
+    /// slot, matching the existing artifact-selection ABI.
+    pub(super) fn with_public_permutation(mut self, permutation: &[usize]) -> RusticolResult<Self> {
+        if permutation.len() != self.externals_by_public_slot.len()
+            || permutation.iter().copied().collect::<BTreeSet<_>>()
+                != (0..permutation.len()).collect::<BTreeSet<_>>()
+        {
+            return Err(integrity(
+                "artifact alias does not define a complete public external permutation",
+            ));
+        }
+        if permutation
+            .iter()
+            .copied()
+            .enumerate()
+            .all(|(representative, public)| representative == public)
+        {
+            return Ok(self);
+        }
+        let mut inverse = vec![u32::MAX; permutation.len()];
+        let mut public_label_by_representative_label = BTreeMap::new();
+        let mut representative_label_by_public_label = BTreeMap::new();
+        for (representative_slot, public_slot) in permutation.iter().copied().enumerate() {
+            inverse[public_slot] = u32::try_from(representative_slot)
+                .map_err(|_| integrity("representative public slot exceeds u32"))?;
+            let external = self
+                .externals_by_public_slot
+                .get(representative_slot)
+                .ok_or_else(|| integrity("representative public slot is absent"))?;
+            let expected_label = u32::try_from(representative_slot + 1)
+                .map_err(|_| integrity("representative public label exceeds u32"))?;
+            if external.public_label != expected_label {
+                return Err(integrity(
+                    "permuted public selection requires canonical one-based external labels",
+                ));
+            }
+            let public_label = u32::try_from(public_slot + 1)
+                .map_err(|_| integrity("requested public label exceeds u32"))?;
+            public_label_by_representative_label.insert(expected_label, public_label);
+            representative_label_by_public_label.insert(public_label, expected_label);
+        }
+        if inverse.contains(&u32::MAX) {
+            return Err(integrity("artifact alias omits a public external slot"));
+        }
+        self.representative_to_public = permutation
+            .iter()
+            .copied()
+            .map(|slot| u32::try_from(slot).map_err(|_| integrity("public slot exceeds u32")))
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        self.public_to_representative = inverse.into_boxed_slice();
+        self.public_label_by_representative_label = public_label_by_representative_label;
+        self.representative_label_by_public_label = representative_label_by_public_label;
+        Ok(self)
+    }
+
+    pub(super) const fn helicity_count(&self) -> usize {
+        self.helicity_count
+    }
+
+    pub(super) const fn color_count(&self) -> usize {
+        self.color_count
+    }
+
+    /// Decode one structural query directly from compact ordinals.
+    ///
+    /// Contracted NLC/full execution has a singleton public color axis, but
+    /// evaluates its authenticated structural owner basis before applying the
+    /// color metric.  This cold adapter keeps those decoded queries transient
+    /// instead of retaining flow strings, traces, or a dense public table.
+    pub(super) fn decoded_query_at(
+        &self,
+        seed: &OnTheFlyProcessSeedV1,
+        helicity_ordinal: usize,
+        structural_color_ordinal: usize,
+    ) -> RusticolResult<DecodedLcQueryV1> {
+        let public_helicities = self.helicity_at(helicity_ordinal)?;
+        let (_, selector) = self.color_at(structural_color_ordinal)?;
+        DecodedLcQueryV1::new(
+            seed,
+            self.external_permutation.to_vec(),
+            &public_helicities,
+            selector,
+        )
+    }
+
+    pub(super) fn parse_helicity_id(&self, value: &str) -> RusticolResult<Box<[i32]>> {
+        let payload = value
+            .strip_prefix("h:")
+            .ok_or_else(|| invalid(format!("unknown helicity ID {value:?}")))?;
+        if payload.is_empty() {
+            return Err(invalid("helicity ID has no external values"));
+        }
+        let public_values = payload
+            .split(',')
+            .map(|part| {
+                let parsed = part.parse::<i32>().map_err(|_| {
+                    invalid(format!("helicity ID {value:?} has an invalid integer"))
+                })?;
+                if format!("{parsed:+}") != part {
+                    return Err(invalid(format!("helicity ID {value:?} is not canonical",)));
+                }
+                Ok(parsed)
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        if public_values.len() != self.externals_by_public_slot.len() {
+            return Err(invalid(format!(
+                "helicity ID {value:?} has {} values, expected {}",
+                public_values.len(),
+                self.externals_by_public_slot.len(),
+            )));
+        }
+        let mut values = vec![0; public_values.len()];
+        for (public_slot, selected) in public_values.iter().copied().enumerate() {
+            let representative_slot = *self
+                .public_to_representative
+                .get(public_slot)
+                .ok_or_else(|| integrity("requested public helicity slot is absent"))?;
+            values[representative_slot as usize] = selected;
+        }
+        for (public_slot, (external, selected)) in self
+            .externals_by_public_slot
+            .iter()
+            .zip(values.iter().copied())
+            .enumerate()
+        {
+            if !external.public_helicities.contains(&selected) {
+                return Err(invalid(format!(
+                    "helicity ID {value:?} selects unavailable helicity {selected} at public slot {public_slot}",
+                )));
+            }
+        }
+        Ok(values.into_boxed_slice())
+    }
+
+    pub(super) fn parse_color_id(
+        &self,
+        value: &str,
+    ) -> RusticolResult<(Box<[u32]>, OnTheFlyLcSelectorV1)> {
+        if value == "flow:singlet" {
+            if self.color_domain != CompactColorDomainV1::Singlet {
+                return Err(invalid(
+                    "flow:singlet is invalid for colored external particles",
+                ));
+            }
+            return Ok((Box::new([]), OnTheFlyLcSelectorV1::Singlet));
+        }
+        let payload = value
+            .strip_prefix("flow:")
+            .ok_or_else(|| invalid(format!("unknown LC color ID {value:?}")))?;
+        if payload.is_empty() {
+            return Err(invalid("LC color ID has no external labels"));
+        }
+        let labels = payload
+            .split(',')
+            .map(|part| {
+                let label = part
+                    .parse::<u32>()
+                    .map_err(|_| invalid(format!("LC color ID {value:?} has an invalid label")))?;
+                if label.to_string() != part {
+                    return Err(invalid(format!("LC color ID {value:?} is not canonical",)));
+                }
+                Ok(label)
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let canonical = canonical_color_id(&labels);
+        if canonical != value {
+            return Err(invalid(format!("LC color ID {value:?} is not canonical")));
+        }
+        let representative_labels = labels
+            .iter()
+            .map(|label| {
+                self.representative_label_by_public_label
+                    .get(label)
+                    .copied()
+                    .ok_or_else(|| invalid("LC color ID contains an unknown external label"))
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let selector = self.selector_from_labels(&representative_labels)?;
+        Ok((representative_labels.into_boxed_slice(), selector))
+    }
+
+    fn selector_from_labels(&self, labels: &[u32]) -> RusticolResult<OnTheFlyLcSelectorV1> {
+        let required = self
+            .externals_by_public_slot
+            .iter()
+            .filter(|external| external.color_role != OnTheFlyExternalColorRoleV1::Singlet)
+            .map(|external| external.public_label)
+            .collect::<BTreeSet<_>>();
+        let observed = labels.iter().copied().collect::<BTreeSet<_>>();
+        if observed.len() != labels.len() || observed != required {
+            return Err(invalid(
+                "LC color ID must cover every colored external label exactly once",
+            ));
+        }
+        let public_slots = labels
+            .iter()
+            .map(|label| {
+                self.public_slot_by_label
+                    .get(label)
+                    .copied()
+                    .ok_or_else(|| invalid("LC color ID contains an unknown external label"))
+                    .and_then(|slot| {
+                        u32::try_from(slot).map_err(|_| invalid("public external slot exceeds u32"))
+                    })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        match self.color_domain {
+            CompactColorDomainV1::Singlet => {
+                Err(invalid("colored LC flow is invalid for a singlet process"))
+            }
+            CompactColorDomainV1::SingleTrace => {
+                if labels.iter().any(|label| {
+                    let slot = self.public_slot_by_label[label];
+                    self.externals_by_public_slot[slot].color_role
+                        != OnTheFlyExternalColorRoleV1::Adjoint
+                }) {
+                    return Err(invalid("single-trace LC flow contains a non-adjoint label"));
+                }
+                if labels.first() != self.adjoint_labels.first() {
+                    return Err(invalid(
+                        "single-trace LC flow must use the minimum adjoint label as cyclic anchor",
+                    ));
+                }
+                if self.color_basis == OnTheFlyColorBasis::Adjoint
+                    && labels.last() != self.adjoint_labels.last()
+                {
+                    return Err(invalid(
+                        "adjoint color flow must preserve both fixed endpoint labels",
+                    ));
+                }
+                Ok(OnTheFlyLcSelectorV1::single_trace(public_slots))
+            }
+            CompactColorDomainV1::OpenLines => {
+                let mut blocks = Vec::<Vec<u32>>::new();
+                let mut offset = 0;
+                while offset < labels.len() {
+                    let start_slot = self.public_slot_by_label[&labels[offset]];
+                    if self.externals_by_public_slot[start_slot].color_role
+                        != OnTheFlyExternalColorRoleV1::Fundamental
+                    {
+                        return Err(invalid(
+                            "open-line LC flow block must start at a fundamental label",
+                        ));
+                    }
+                    let mut end = offset + 1;
+                    while end < labels.len() {
+                        let role = self.externals_by_public_slot
+                            [self.public_slot_by_label[&labels[end]]]
+                            .color_role;
+                        if role != OnTheFlyExternalColorRoleV1::Adjoint {
+                            break;
+                        }
+                        end += 1;
+                    }
+                    if end >= labels.len()
+                        || self.externals_by_public_slot[self.public_slot_by_label[&labels[end]]]
+                            .color_role
+                            != OnTheFlyExternalColorRoleV1::Antifundamental
+                    {
+                        return Err(invalid(
+                            "open-line LC flow block must end at an antifundamental label",
+                        ));
+                    }
+                    blocks.push(public_slots[offset..=end].to_vec());
+                    offset = end + 1;
+                }
+                if blocks.len() != self.fundamental_labels.len() {
+                    return Err(invalid("LC flow has the wrong number of open-line blocks"));
+                }
+                // The established LC public plan orders blocks by the sorted
+                // fundamental external labels.  Other block orders are valid
+                // traversal aliases internally, but are not distinct public IDs.
+                let starts = blocks
+                    .iter()
+                    .map(|block| {
+                        let public_slot = block[0] as usize;
+                        self.externals_by_public_slot[public_slot].public_label
+                    })
+                    .collect::<Vec<_>>();
+                if starts.as_slice() != self.fundamental_labels.as_ref() {
+                    return Err(invalid(
+                        "open-line LC flow blocks are not in canonical fundamental-label order",
+                    ));
+                }
+                Ok(OnTheFlyLcSelectorV1::open_lines(blocks))
+            }
+        }
+    }
+
+    fn helicity_at(&self, mut index: usize) -> RusticolResult<Box<[i32]>> {
+        if index >= self.helicity_count {
+            return Err(invalid("public helicity ordinal is out of bounds"));
+        }
+        let mut values = vec![0; self.externals_by_public_slot.len()];
+        for (slot, external) in self.externals_by_public_slot.iter().enumerate().rev() {
+            let radix = external.public_helicities.len();
+            values[slot] = external.public_helicities[index % radix];
+            index /= radix;
+        }
+        Ok(values.into_boxed_slice())
+    }
+
+    fn public_helicities_from_representative(
+        &self,
+        representative: &[i32],
+    ) -> RusticolResult<Box<[i32]>> {
+        if representative.len() != self.representative_to_public.len() {
+            return Err(integrity(
+                "representative helicity domain differs from the public permutation",
+            ));
+        }
+        let mut public = vec![0; representative.len()];
+        for (representative_slot, value) in representative.iter().copied().enumerate() {
+            let public_slot = self.representative_to_public[representative_slot] as usize;
+            public[public_slot] = value;
+        }
+        Ok(public.into_boxed_slice())
+    }
+
+    fn public_labels_from_representative(
+        &self,
+        representative: &[u32],
+    ) -> RusticolResult<Box<[u32]>> {
+        representative
+            .iter()
+            .map(|label| {
+                self.public_label_by_representative_label
+                    .get(label)
+                    .copied()
+                    .ok_or_else(|| integrity("representative LC label has no public alias"))
+            })
+            .collect::<RusticolResult<Vec<_>>>()
+            .map(Vec::into_boxed_slice)
+    }
+
+    fn helicity_ordinal(&self, values: &[i32]) -> RusticolResult<usize> {
+        let mut ordinal = 0usize;
+        for (external, selected) in self.externals_by_public_slot.iter().zip(values) {
+            let digit = external
+                .public_helicities
+                .iter()
+                .position(|candidate| candidate == selected)
+                .ok_or_else(|| invalid("public helicity is outside the compact seed"))?;
+            ordinal = ordinal
+                .checked_mul(external.public_helicities.len())
+                .and_then(|value| value.checked_add(digit))
+                .ok_or_else(|| invalid("public helicity ordinal exceeds usize"))?;
+        }
+        Ok(ordinal)
+    }
+
+    fn color_at(&self, index: usize) -> RusticolResult<(Box<[u32]>, OnTheFlyLcSelectorV1)> {
+        if index >= self.color_count {
+            return Err(invalid("public LC color ordinal is out of bounds"));
+        }
+        let unfolded = self.unfolded_color_ordinal_at(index)?;
+        self.unfolded_color_at(unfolded)
+    }
+
+    fn unfolded_color_at(
+        &self,
+        index: usize,
+    ) -> RusticolResult<(Box<[u32]>, OnTheFlyLcSelectorV1)> {
+        if index >= self.color_count {
+            return Err(invalid("unfolded LC color ordinal is out of bounds"));
+        }
+        let labels = match self.color_domain {
+            CompactColorDomainV1::Singlet => Vec::new(),
+            CompactColorDomainV1::SingleTrace => {
+                let first = *self
+                    .adjoint_labels
+                    .first()
+                    .ok_or_else(|| integrity("single-trace domain has no adjoint anchor"))?;
+                let mut labels = vec![first];
+                if self.color_basis == OnTheFlyColorBasis::Adjoint {
+                    let last = self.adjoint_labels.len() - 1;
+                    labels.extend(nth_permutation(&self.adjoint_labels[1..last], index)?);
+                    labels.push(self.adjoint_labels[last]);
+                } else {
+                    labels.extend(nth_permutation(&self.adjoint_labels[1..], index)?);
+                }
+                labels
+            }
+            CompactColorDomainV1::OpenLines => self.open_line_color_at(index)?,
+        };
+        let selector = if labels.is_empty() {
+            OnTheFlyLcSelectorV1::Singlet
+        } else {
+            self.selector_from_labels(&labels)?
+        };
+        Ok((labels.into_boxed_slice(), selector))
+    }
+
+    fn unfolded_color_ordinal_at(&self, public_index: usize) -> RusticolResult<usize> {
+        if public_index >= self.color_count {
+            return Err(invalid("public LC color ordinal is out of bounds"));
+        }
+        if self.trace_reflections_folded {
+            return self.folded_unfolded_color_ordinal_at(public_index);
+        }
+        match self.reference_unfolded_color_ordinal {
+            None => Ok(public_index),
+            Some(reference) if public_index == 0 => Ok(reference),
+            Some(reference) => {
+                let ordinary = public_index - 1;
+                Ok(if ordinary >= reference {
+                    ordinary + 1
+                } else {
+                    ordinary
+                })
+            }
+        }
+    }
+
+    fn folded_unfolded_color_ordinal_at(&self, public_index: usize) -> RusticolResult<usize> {
+        let reference = self.reference_unfolded_color_ordinal;
+        let mut next_public = 0usize;
+        if let Some(reference) = reference {
+            let (word, _) = self.unfolded_color_at(reference)?;
+            let reflected = reflected_trace_word(&word)?;
+            let reflected_ordinal = self.unfolded_color_ordinal(&reflected)?;
+            for ordinal in [reference, reflected_ordinal] {
+                if next_public == public_index {
+                    return Ok(ordinal);
+                }
+                next_public += 1;
+                if reflected_ordinal == reference {
+                    break;
+                }
+            }
+        }
+        for ordinal in 0..self.color_count {
+            let (word, _) = self.unfolded_color_at(ordinal)?;
+            let reflected = reflected_trace_word(&word)?;
+            let reflected_ordinal = self.unfolded_color_ordinal(&reflected)?;
+            if ordinal > reflected_ordinal || reference == Some(ordinal) {
+                continue;
+            }
+            for member in [ordinal, reflected_ordinal] {
+                if next_public == public_index {
+                    return Ok(member);
+                }
+                next_public += 1;
+                if reflected_ordinal == ordinal {
+                    break;
+                }
+            }
+        }
+        Err(integrity(
+            "folded trace enumeration did not cover its public color axis",
+        ))
+    }
+
+    fn open_line_color_at(&self, index: usize) -> RusticolResult<Vec<u32>> {
+        let line_count = self.fundamental_labels.len();
+        let split_count = checked_binomial(
+            self.adjoint_labels
+                .len()
+                .checked_add(line_count.saturating_sub(1))
+                .ok_or_else(|| invalid("open-line split domain exceeds usize"))?,
+            line_count.saturating_sub(1),
+            "open-line split count",
+        )?;
+        let adjoint_order_count =
+            checked_factorial(self.adjoint_labels.len(), "adjoint order count")?;
+        let allocation_count = adjoint_order_count
+            .checked_mul(split_count)
+            .ok_or_else(|| invalid("ordered adjoint allocation count exceeds usize"))?;
+        let pairing_index = index / allocation_count;
+        let allocation_index = index % allocation_count;
+        let adjoint_order_index = allocation_index / split_count;
+        let split_index = allocation_index % split_count;
+        let antifundamentals = nth_permutation(&self.antifundamental_labels, pairing_index)?;
+        let adjoints = nth_permutation(&self.adjoint_labels, adjoint_order_index)?;
+        let lengths = nth_weak_composition(adjoint_labels_len(&adjoints), line_count, split_index)?;
+
+        let mut labels = Vec::new();
+        labels
+            .try_reserve_exact(
+                line_count
+                    .checked_mul(2)
+                    .and_then(|value| value.checked_add(adjoints.len()))
+                    .ok_or_else(|| invalid("LC color word length exceeds usize"))?,
+            )
+            .map_err(|error| invalid(format!("LC color word allocation failed: {error}")))?;
+        let mut offset = 0_usize;
+        for line in 0..line_count {
+            labels.push(self.fundamental_labels[line]);
+            let end = offset
+                .checked_add(lengths[line])
+                .ok_or_else(|| invalid("LC adjoint allocation exceeds usize"))?;
+            labels.extend_from_slice(&adjoints[offset..end]);
+            labels.push(antifundamentals[line]);
+            offset = end;
+        }
+        if offset != adjoints.len() {
+            return Err(integrity("LC adjoint allocation did not consume its word"));
+        }
+        Ok(labels)
+    }
+
+    fn unfolded_color_ordinal(&self, labels: &[u32]) -> RusticolResult<usize> {
+        match self.color_domain {
+            CompactColorDomainV1::Singlet => {
+                if labels.is_empty() {
+                    Ok(0)
+                } else {
+                    Err(invalid("singlet color ordinal received a colored word"))
+                }
+            }
+            CompactColorDomainV1::SingleTrace => {
+                if labels.first() != self.adjoint_labels.first() {
+                    return Err(invalid("single-trace cyclic anchor differs"));
+                }
+                if self.color_basis == OnTheFlyColorBasis::Adjoint {
+                    if labels.len() != self.adjoint_labels.len()
+                        || labels.last() != self.adjoint_labels.last()
+                    {
+                        return Err(invalid("adjoint color flow endpoints differ"));
+                    }
+                    let last = self.adjoint_labels.len() - 1;
+                    permutation_rank(&self.adjoint_labels[1..last], &labels[1..last])
+                } else {
+                    permutation_rank(&self.adjoint_labels[1..], &labels[1..])
+                }
+            }
+            CompactColorDomainV1::OpenLines => {
+                let mut antifundamentals = Vec::new();
+                let mut adjoints = Vec::new();
+                let mut lengths = Vec::new();
+                let mut offset = 0;
+                for fundamental in self.fundamental_labels.iter().copied() {
+                    if labels.get(offset).copied() != Some(fundamental) {
+                        return Err(invalid("open-line block order differs"));
+                    }
+                    offset += 1;
+                    let start = adjoints.len();
+                    while let Some(label) = labels.get(offset).copied() {
+                        let role = self.externals_by_public_slot[self.public_slot_by_label[&label]]
+                            .color_role;
+                        if role != OnTheFlyExternalColorRoleV1::Adjoint {
+                            break;
+                        }
+                        adjoints.push(label);
+                        offset += 1;
+                    }
+                    let antifundamental = labels
+                        .get(offset)
+                        .copied()
+                        .ok_or_else(|| invalid("open-line block has no terminal endpoint"))?;
+                    antifundamentals.push(antifundamental);
+                    offset += 1;
+                    lengths.push(adjoints.len() - start);
+                }
+                if offset != labels.len() {
+                    return Err(invalid("open-line flow has trailing labels"));
+                }
+                let pairing_index =
+                    permutation_rank(&self.antifundamental_labels, &antifundamentals)?;
+                let adjoint_order_index = permutation_rank(&self.adjoint_labels, &adjoints)?;
+                let split_index = weak_composition_rank(&lengths)?;
+                let split_count = checked_binomial(
+                    self.adjoint_labels
+                        .len()
+                        .checked_add(self.fundamental_labels.len().saturating_sub(1))
+                        .ok_or_else(|| invalid("open-line split domain exceeds usize"))?,
+                    self.fundamental_labels.len().saturating_sub(1),
+                    "open-line split count",
+                )?;
+                let allocation_count =
+                    checked_factorial(self.adjoint_labels.len(), "adjoint order count")?
+                        .checked_mul(split_count)
+                        .ok_or_else(|| invalid("ordered adjoint allocation count exceeds usize"))?;
+                pairing_index
+                    .checked_mul(allocation_count)
+                    .and_then(|value| {
+                        value.checked_add(
+                            adjoint_order_index
+                                .checked_mul(split_count)
+                                .and_then(|inner| inner.checked_add(split_index))?,
+                        )
+                    })
+                    .ok_or_else(|| invalid("LC color ordinal exceeds usize"))
+            }
+        }
+    }
+
+    fn color_ordinal(&self, labels: &[u32]) -> RusticolResult<usize> {
+        let unfolded = self.unfolded_color_ordinal(labels)?;
+        if self.trace_reflections_folded {
+            for public in 0..self.color_count {
+                if self.folded_unfolded_color_ordinal_at(public)? == unfolded {
+                    return Ok(public);
+                }
+            }
+            return Err(integrity(
+                "folded trace public axis omits an unfolded color member",
+            ));
+        }
+        Ok(match self.reference_unfolded_color_ordinal {
+            None => unfolded,
+            Some(reference) if unfolded == reference => 0,
+            Some(reference) if unfolded < reference => unfolded + 1,
+            Some(_) => unfolded,
+        })
+    }
+
+    pub(super) fn selected_ordinals(
+        &self,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<OnTheFlySelectedOrdinalsV1> {
+        let helicity_ordinals = match selected_helicity_ids {
+            None => None,
+            Some(ids) => {
+                if ids.is_empty() {
+                    return Err(invalid("helicity selection is empty"));
+                }
+                let mut ordinals = ids
+                    .iter()
+                    .map(|id| {
+                        let values = self.parse_helicity_id(id)?;
+                        self.helicity_ordinal(&values)
+                    })
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                ordinals.sort_unstable();
+                ordinals.dedup();
+                Some(ordinals.into_boxed_slice())
+            }
+        };
+        let color_ordinals = match selected_color_ids {
+            None => None,
+            Some(ids) => {
+                if ids.is_empty() {
+                    return Err(invalid("LC color selection is empty"));
+                }
+                let mut ordinals = ids
+                    .iter()
+                    .map(|id| {
+                        let (labels, _) = self.parse_color_id(id)?;
+                        self.color_ordinal(&labels)
+                    })
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                ordinals.sort_unstable();
+                ordinals.dedup();
+                Some(ordinals.into_boxed_slice())
+            }
+        };
+        Ok((helicity_ordinals, color_ordinals))
+    }
+
+    pub(super) fn selection<'a>(
+        &'a self,
+        seed: &'a OnTheFlyProcessSeedV1,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<OnTheFlyLazySelectionV1<'a>> {
+        let (helicity_ordinals, color_ordinals) =
+            self.selected_ordinals(selected_helicity_ids, selected_color_ids)?;
+        Ok(OnTheFlyLazySelectionV1 {
+            adapter: self,
+            seed,
+            helicity_ordinals,
+            color_ordinals,
+        })
+    }
+
+    pub(super) fn selection_from_ordinals<'a>(
+        &'a self,
+        seed: &'a OnTheFlyProcessSeedV1,
+        helicity_ordinals: Option<&[usize]>,
+        color_ordinals: Option<&[usize]>,
+    ) -> RusticolResult<OnTheFlyLazySelectionV1<'a>> {
+        Ok(OnTheFlyLazySelectionV1 {
+            adapter: self,
+            seed,
+            helicity_ordinals: owned_selected_ordinals(
+                helicity_ordinals,
+                self.helicity_count,
+                "helicity",
+            )?,
+            color_ordinals: owned_selected_ordinals(color_ordinals, self.color_count, "color")?,
+        })
+    }
+}
+
+/// Lazy selector Cartesian product.  This is the explicit materializer seam
+/// for factorial default-all flow coverage; callers may consume one request or
+/// one bounded batch without ever allocating a dense public axis.
+pub(super) struct OnTheFlyLazySelectionV1<'a> {
+    adapter: &'a OnTheFlyCompactSelectorAdapterV1,
+    seed: &'a OnTheFlyProcessSeedV1,
+    helicity_ordinals: Option<Box<[usize]>>,
+    color_ordinals: Option<Box<[usize]>>,
+}
+
+impl OnTheFlyLazySelectionV1<'_> {
+    pub(super) fn helicity_count(&self) -> usize {
+        self.helicity_ordinals
+            .as_ref()
+            .map_or(self.adapter.helicity_count, |values| values.len())
+    }
+
+    pub(super) fn color_count(&self) -> usize {
+        self.color_ordinals
+            .as_ref()
+            .map_or(self.adapter.color_count, |values| values.len())
+    }
+
+    pub(super) fn helicity_ordinal_at(&self, position: usize) -> RusticolResult<usize> {
+        selected_ordinal(
+            self.helicity_ordinals.as_deref(),
+            self.adapter.helicity_count,
+            position,
+            "helicity",
+        )
+    }
+
+    pub(super) fn color_ordinal_at(&self, position: usize) -> RusticolResult<usize> {
+        selected_ordinal(
+            self.color_ordinals.as_deref(),
+            self.adapter.color_count,
+            position,
+            "color",
+        )
+    }
+
+    pub(super) fn request_count(&self) -> RusticolResult<usize> {
+        self.helicity_count()
+            .checked_mul(self.color_count())
+            .ok_or_else(|| invalid("selected LC query count exceeds usize"))
+    }
+
+    pub(super) fn helicity_id_at(&self, position: usize) -> RusticolResult<String> {
+        let ordinal = selected_ordinal(
+            self.helicity_ordinals.as_deref(),
+            self.adapter.helicity_count,
+            position,
+            "helicity",
+        )?;
+        let representative = self.adapter.helicity_at(ordinal)?;
+        let public = self
+            .adapter
+            .public_helicities_from_representative(&representative)?;
+        Ok(canonical_helicity_id(&public))
+    }
+
+    pub(super) fn color_id_at(&self, position: usize) -> RusticolResult<String> {
+        let ordinal = selected_ordinal(
+            self.color_ordinals.as_deref(),
+            self.adapter.color_count,
+            position,
+            "color",
+        )?;
+        let (representative, _) = self.adapter.color_at(ordinal)?;
+        let public = self
+            .adapter
+            .public_labels_from_representative(&representative)?;
+        Ok(canonical_color_id(&public))
+    }
+
+    pub(super) fn request_at(&self, position: usize) -> RusticolResult<OnTheFlyLcQueryRequestV1> {
+        let color_count = self.color_count();
+        if color_count == 0 || position >= self.request_count()? {
+            return Err(invalid("selected LC query ordinal is out of bounds"));
+        }
+        let helicity_position = position / color_count;
+        let color_position = position % color_count;
+        let helicity_ordinal = selected_ordinal(
+            self.helicity_ordinals.as_deref(),
+            self.adapter.helicity_count,
+            helicity_position,
+            "helicity",
+        )?;
+        let color_ordinal = selected_ordinal(
+            self.color_ordinals.as_deref(),
+            self.adapter.color_count,
+            color_position,
+            "color",
+        )?;
+        let query = self
+            .adapter
+            .decoded_query_at(self.seed, helicity_ordinal, color_ordinal)?;
+        OnTheFlyLcQueryRequestV1::new(
+            query,
+            vec![OnTheFlyLcReductionTargetV1::new(
+                helicity_position,
+                color_position,
+                1.0,
+            )?],
+        )
+    }
+
+    pub(super) fn iter(&self) -> OnTheFlyLazyRequestIterV1<'_, '_> {
+        OnTheFlyLazyRequestIterV1 {
+            selection: self,
+            next: 0,
+        }
+    }
+}
+
+pub(super) struct OnTheFlyLazyRequestIterV1<'selection, 'seed> {
+    selection: &'selection OnTheFlyLazySelectionV1<'seed>,
+    next: usize,
+}
+
+impl Iterator for OnTheFlyLazyRequestIterV1<'_, '_> {
+    type Item = RusticolResult<OnTheFlyLcQueryRequestV1>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let count = match self.selection.request_count() {
+            Ok(value) => value,
+            Err(error) => {
+                self.next = usize::MAX;
+                return Some(Err(error));
+            }
+        };
+        if self.next >= count {
+            return None;
+        }
+        let position = self.next;
+        self.next += 1;
+        Some(self.selection.request_at(position))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self.selection.request_count() {
+            Ok(count) => {
+                let remaining = count.saturating_sub(self.next);
+                (remaining, Some(remaining))
+            }
+            Err(_) => (1, Some(1)),
+        }
+    }
+}
+
+/// Lane-local cache used only by explicit metadata calls.  Evaluation and
+/// profiling consume [`OnTheFlyLazySelectionV1`] directly and never fill it.
+#[derive(Default)]
+pub(super) struct OnTheFlySelectorIntrospectionCacheV1 {
+    #[expect(
+        dead_code,
+        reason = "retained for the private external-selector metadata compatibility API"
+    )]
+    externals: Option<Box<[OnTheFlyExternalSelectorRecordV1]>>,
+    helicities: Option<Box<[OnTheFlyHelicitySelectorRecordV1]>>,
+    colors: Option<Box<[OnTheFlyColorSelectorRecordV1]>>,
+}
+
+impl OnTheFlySelectorIntrospectionCacheV1 {
+    #[expect(
+        dead_code,
+        reason = "retained for the private external-selector metadata compatibility API"
+    )]
+    pub(super) fn externals<'a>(
+        &'a mut self,
+        adapter: &OnTheFlyCompactSelectorAdapterV1,
+    ) -> &'a [OnTheFlyExternalSelectorRecordV1] {
+        self.externals.get_or_insert_with(|| {
+            adapter
+                .externals_by_public_slot
+                .iter()
+                .map(|external| OnTheFlyExternalSelectorRecordV1 {
+                    source_slot: external.source_slot,
+                    public_slot: external.public_slot,
+                    public_label: external.public_label,
+                    is_initial: external.is_initial,
+                    color_role: external.color_role,
+                })
+                .collect::<Vec<_>>()
+                .into_boxed_slice()
+        })
+    }
+
+    pub(super) fn helicities<'a>(
+        &'a mut self,
+        adapter: &OnTheFlyCompactSelectorAdapterV1,
+    ) -> RusticolResult<&'a [OnTheFlyHelicitySelectorRecordV1]> {
+        if self.helicities.is_none() {
+            let mut records = Vec::new();
+            records
+                .try_reserve_exact(adapter.helicity_count)
+                .map_err(|error| {
+                    invalid(format!("helicity metadata allocation failed: {error}"))
+                })?;
+            for index in 0..adapter.helicity_count {
+                let values = adapter.helicity_at(index)?;
+                records.push(OnTheFlyHelicitySelectorRecordV1 {
+                    id: canonical_helicity_id(&values),
+                    index,
+                    values,
+                });
+            }
+            self.helicities = Some(records.into_boxed_slice());
+        }
+        Ok(self
+            .helicities
+            .as_deref()
+            .expect("helicity cache was filled"))
+    }
+
+    pub(super) fn colors<'a>(
+        &'a mut self,
+        adapter: &OnTheFlyCompactSelectorAdapterV1,
+    ) -> RusticolResult<&'a [OnTheFlyColorSelectorRecordV1]> {
+        if self.colors.is_none() {
+            let mut records = Vec::new();
+            records
+                .try_reserve_exact(adapter.color_count)
+                .map_err(|error| invalid(format!("color metadata allocation failed: {error}")))?;
+            for index in 0..adapter.color_count {
+                let (word, selector) = adapter.color_at(index)?;
+                records.push(OnTheFlyColorSelectorRecordV1 {
+                    id: canonical_color_id(&word),
+                    index,
+                    word,
+                    selector,
+                });
+            }
+            self.colors = Some(records.into_boxed_slice());
+        }
+        Ok(self.colors.as_deref().expect("color cache was filled"))
+    }
+}
+
+fn selected_ordinal(
+    selected: Option<&[usize]>,
+    all_count: usize,
+    position: usize,
+    label: &str,
+) -> RusticolResult<usize> {
+    match selected {
+        Some(values) => values
+            .get(position)
+            .copied()
+            .ok_or_else(|| invalid(format!("selected {label} position is out of bounds"))),
+        None if position < all_count => Ok(position),
+        None => Err(invalid(format!("{label} position is out of bounds"))),
+    }
+}
+
+fn owned_selected_ordinals(
+    selected: Option<&[usize]>,
+    all_count: usize,
+    label: &str,
+) -> RusticolResult<Option<Box<[usize]>>> {
+    let Some(selected) = selected else {
+        return Ok(None);
+    };
+    if selected.is_empty() {
+        return Err(invalid(format!("{label} selection is empty")));
+    }
+    if selected.iter().any(|ordinal| *ordinal >= all_count) {
+        return Err(invalid(format!(
+            "selected {label} ordinal is out of bounds"
+        )));
+    }
+    if selected.windows(2).any(|pair| pair[0] >= pair[1]) {
+        return Err(invalid(format!(
+            "selected {label} ordinals are not strictly increasing"
+        )));
+    }
+    Ok(Some(selected.to_vec().into_boxed_slice()))
+}
+
+fn canonical_helicity_id(values: &[i32]) -> String {
+    format!(
+        "h:{}",
+        values
+            .iter()
+            .map(|value| format!("{value:+}"))
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}
+
+fn canonical_color_id(word: &[u32]) -> String {
+    if word.is_empty() {
+        "flow:singlet".to_string()
+    } else {
+        format!(
+            "flow:{}",
+            word.iter()
+                .map(u32::to_string)
+                .collect::<Vec<_>>()
+                .join(",")
+        )
+    }
+}
+
+fn reflected_trace_word(word: &[u32]) -> RusticolResult<Vec<u32>> {
+    let Some((first, rest)) = word.split_first() else {
+        return Err(invalid("cannot reflect an empty trace word"));
+    };
+    let mut reflected = Vec::new();
+    reflected
+        .try_reserve_exact(word.len())
+        .map_err(|error| invalid(format!("trace-reflection allocation failed: {error}")))?;
+    reflected.push(*first);
+    reflected.extend(rest.iter().rev().copied());
+    Ok(reflected)
+}
+
+fn checked_product(values: impl IntoIterator<Item = usize>, label: &str) -> RusticolResult<usize> {
+    values.into_iter().try_fold(1usize, |total, value| {
+        total
+            .checked_mul(value)
+            .ok_or_else(|| invalid(format!("{label} exceeds usize")))
+    })
+}
+
+fn single_trace_color_count(count: usize, basis: OnTheFlyColorBasis) -> RusticolResult<usize> {
+    let anchors = match basis {
+        OnTheFlyColorBasis::Trace => 1,
+        OnTheFlyColorBasis::Adjoint => 2,
+    };
+    checked_factorial(count.saturating_sub(anchors), "single-trace count")
+}
+
+fn checked_factorial(value: usize, label: &str) -> RusticolResult<usize> {
+    (2..=value).try_fold(1usize, |total, factor| {
+        total
+            .checked_mul(factor)
+            .ok_or_else(|| invalid(format!("{label} exceeds usize")))
+    })
+}
+
+fn checked_binomial(n: usize, k: usize, label: &str) -> RusticolResult<usize> {
+    let k = k.min(n.saturating_sub(k));
+    let mut value = 1usize;
+    for index in 0..k {
+        value = value
+            .checked_mul(n - index)
+            .ok_or_else(|| invalid(format!("{label} exceeds usize")))?
+            / (index + 1);
+    }
+    Ok(value)
+}
+
+fn nth_permutation(values: &[u32], mut rank: usize) -> RusticolResult<Vec<u32>> {
+    if rank >= checked_factorial(values.len(), "permutation count")? {
+        return Err(invalid("permutation ordinal is out of bounds"));
+    }
+    let mut remaining = values.to_vec();
+    let mut result = Vec::new();
+    result
+        .try_reserve_exact(values.len())
+        .map_err(|error| invalid(format!("permutation allocation failed: {error}")))?;
+    for width in (1..=values.len()).rev() {
+        let block = checked_factorial(width - 1, "permutation block")?;
+        let digit = rank / block;
+        rank %= block;
+        result.push(remaining.remove(digit));
+    }
+    Ok(result)
+}
+
+fn permutation_rank(reference: &[u32], selected: &[u32]) -> RusticolResult<usize> {
+    if reference.len() != selected.len() {
+        return Err(invalid("selected permutation has the wrong length"));
+    }
+    let mut remaining = reference.to_vec();
+    let mut rank = 0usize;
+    for (index, selected) in selected.iter().copied().enumerate() {
+        let digit = remaining
+            .iter()
+            .position(|candidate| *candidate == selected)
+            .ok_or_else(|| invalid("selected values are not a permutation"))?;
+        rank = rank
+            .checked_add(
+                digit
+                    .checked_mul(checked_factorial(
+                        reference.len() - index - 1,
+                        "permutation block",
+                    )?)
+                    .ok_or_else(|| invalid("permutation ordinal exceeds usize"))?,
+            )
+            .ok_or_else(|| invalid("permutation ordinal exceeds usize"))?;
+        remaining.remove(digit);
+    }
+    Ok(rank)
+}
+
+fn nth_weak_composition(total: usize, bins: usize, mut rank: usize) -> RusticolResult<Vec<usize>> {
+    if bins == 0 {
+        return if total == 0 && rank == 0 {
+            Ok(Vec::new())
+        } else {
+            Err(invalid("nonempty sequence cannot be split into zero bins"))
+        };
+    }
+    let count = checked_binomial(
+        total
+            .checked_add(bins - 1)
+            .ok_or_else(|| invalid("weak-composition domain exceeds usize"))?,
+        bins - 1,
+        "weak-composition count",
+    )?;
+    if rank >= count {
+        return Err(invalid("weak-composition ordinal is out of bounds"));
+    }
+    let mut remaining = total;
+    let mut result = Vec::with_capacity(bins);
+    for remaining_bins in (2..=bins).rev() {
+        let mut selected = None;
+        for head in 0..=remaining {
+            let suffix_count = checked_binomial(
+                remaining - head + remaining_bins - 2,
+                remaining_bins - 2,
+                "weak-composition suffix count",
+            )?;
+            if rank < suffix_count {
+                selected = Some(head);
+                break;
+            }
+            rank -= suffix_count;
+        }
+        let head = selected.ok_or_else(|| integrity("weak-composition unranking failed"))?;
+        result.push(head);
+        remaining -= head;
+    }
+    result.push(remaining);
+    Ok(result)
+}
+
+fn weak_composition_rank(values: &[usize]) -> RusticolResult<usize> {
+    if values.is_empty() {
+        return Err(invalid("weak composition has no bins"));
+    }
+    let mut remaining = values
+        .iter()
+        .try_fold(0usize, |total, value| total.checked_add(*value))
+        .ok_or_else(|| invalid("weak-composition total exceeds usize"))?;
+    let mut rank = 0usize;
+    for (index, selected) in values[..values.len() - 1].iter().copied().enumerate() {
+        if selected > remaining {
+            return Err(invalid("weak-composition value exceeds its remainder"));
+        }
+        let remaining_bins = values.len() - index;
+        for head in 0..selected {
+            rank = rank
+                .checked_add(checked_binomial(
+                    remaining - head + remaining_bins - 2,
+                    remaining_bins - 2,
+                    "weak-composition suffix count",
+                )?)
+                .ok_or_else(|| invalid("weak-composition ordinal exceeds usize"))?;
+        }
+        remaining -= selected;
+    }
+    if values.last().copied() != Some(remaining) {
+        return Err(invalid("weak composition does not preserve its total"));
+    }
+    Ok(rank)
+}
+
+const fn adjoint_labels_len(values: &[u32]) -> usize {
+    values.len()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::SemanticDigest;
+    use crate::recurrence::on_the_fly::scalar_adapter_test_seed;
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    fn adapter(
+        roles: &[(u32, OnTheFlyExternalColorRoleV1, &[i32])],
+    ) -> OnTheFlyCompactSelectorAdapterV1 {
+        adapter_in_basis(roles, OnTheFlyColorBasis::Trace)
+    }
+
+    fn adapter_in_basis(
+        roles: &[(u32, OnTheFlyExternalColorRoleV1, &[i32])],
+        color_basis: OnTheFlyColorBasis,
+    ) -> OnTheFlyCompactSelectorAdapterV1 {
+        let externals_by_public_slot = roles
+            .iter()
+            .enumerate()
+            .map(|(slot, (label, role, helicities))| CompactExternalV1 {
+                source_slot: slot as u32,
+                public_slot: slot as u32,
+                public_label: *label,
+                is_initial: slot < 2,
+                color_role: *role,
+                public_helicities: helicities.to_vec().into_boxed_slice(),
+            })
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+        let public_slot_by_label = externals_by_public_slot
+            .iter()
+            .enumerate()
+            .map(|(slot, external)| (external.public_label, slot))
+            .collect();
+        let labels = |role| {
+            let mut labels = externals_by_public_slot
+                .iter()
+                .filter(|external| external.color_role == role)
+                .map(|external| external.public_label)
+                .collect::<Vec<_>>();
+            labels.sort_unstable();
+            labels.into_boxed_slice()
+        };
+        let fundamental_labels = labels(OnTheFlyExternalColorRoleV1::Fundamental);
+        let antifundamental_labels = labels(OnTheFlyExternalColorRoleV1::Antifundamental);
+        let adjoint_labels = labels(OnTheFlyExternalColorRoleV1::Adjoint);
+        let color_domain = if !fundamental_labels.is_empty() {
+            CompactColorDomainV1::OpenLines
+        } else if !adjoint_labels.is_empty() {
+            CompactColorDomainV1::SingleTrace
+        } else {
+            CompactColorDomainV1::Singlet
+        };
+        let helicity_count = checked_product(
+            externals_by_public_slot
+                .iter()
+                .map(|external| external.public_helicities.len()),
+            "test helicities",
+        )
+        .unwrap();
+        let color_count = match color_domain {
+            CompactColorDomainV1::Singlet => 1,
+            CompactColorDomainV1::SingleTrace => {
+                single_trace_color_count(adjoint_labels.len(), color_basis).unwrap()
+            }
+            CompactColorDomainV1::OpenLines => {
+                checked_factorial(fundamental_labels.len(), "test pairings").unwrap()
+                    * checked_factorial(adjoint_labels.len(), "test adjoints").unwrap()
+                    * checked_binomial(
+                        adjoint_labels.len() + fundamental_labels.len() - 1,
+                        fundamental_labels.len() - 1,
+                        "test splits",
+                    )
+                    .unwrap()
+            }
+        };
+        OnTheFlyCompactSelectorAdapterV1 {
+            external_permutation: (0..roles.len() as u32)
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            representative_to_public: (0..roles.len() as u32)
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            public_to_representative: (0..roles.len() as u32)
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            public_label_by_representative_label: roles
+                .iter()
+                .map(|(label, _, _)| (*label, *label))
+                .collect(),
+            representative_label_by_public_label: roles
+                .iter()
+                .map(|(label, _, _)| (*label, *label))
+                .collect(),
+            externals_by_public_slot,
+            public_slot_by_label,
+            fundamental_labels,
+            antifundamental_labels,
+            adjoint_labels,
+            color_domain,
+            color_basis,
+            reference_unfolded_color_ordinal: None,
+            trace_reflections_folded: false,
+            helicity_count,
+            color_count,
+        }
+    }
+
+    #[test]
+    fn permutation_and_split_ranks_are_exact_inverses() {
+        let values = [1, 3, 5, 7];
+        for rank in 0..24 {
+            let selected = nth_permutation(&values, rank).unwrap();
+            assert_eq!(permutation_rank(&values, &selected).unwrap(), rank);
+        }
+        for total in 0..6 {
+            for bins in 1..5 {
+                let count = checked_binomial(total + bins - 1, bins - 1, "test").unwrap();
+                for rank in 0..count {
+                    let selected = nth_weak_composition(total, bins, rank).unwrap();
+                    assert_eq!(selected.iter().sum::<usize>(), total);
+                    assert_eq!(weak_composition_rank(&selected).unwrap(), rank);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn adjoint_color_ordinals_permute_only_between_both_fixed_anchors() {
+        for (total, expected_count) in [(3, 1), (4, 2), (5, 6), (6, 24), (7, 120)] {
+            let roles = (1..=total)
+                .map(|label| (label, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1][..]))
+                .collect::<Vec<_>>();
+            let selector = adapter_in_basis(&roles, OnTheFlyColorBasis::Adjoint);
+            assert_eq!(selector.color_count(), expected_count);
+            assert_eq!(selector.helicity_count(), 1 << total);
+            let mut words = BTreeSet::new();
+            for index in 0..expected_count {
+                let (word, _) = selector.color_at(index).unwrap();
+                assert_eq!(word.first(), Some(&1));
+                assert_eq!(word.last(), Some(&total));
+                assert_eq!(selector.color_ordinal(&word).unwrap(), index);
+                let (parsed, _) = selector.parse_color_id(&canonical_color_id(&word)).unwrap();
+                assert_eq!(parsed, word);
+                assert!(words.insert(word));
+            }
+            assert!(selector.color_at(expected_count).is_err());
+        }
+    }
+
+    #[test]
+    fn adjoint_reference_reordering_and_public_aliases_preserve_the_basis() {
+        let mut selector = adapter_in_basis(
+            &[
+                (1, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+                (2, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+                (3, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+                (4, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+            ],
+            OnTheFlyColorBasis::Adjoint,
+        );
+        assert!(selector.parse_color_id("flow:1,2,4,3").is_err());
+        assert!(selector.unfolded_color_ordinal(&[1, 2, 4, 3]).is_err());
+        assert!(selector.unfolded_color_ordinal(&[2, 1, 3, 4]).is_err());
+        assert!(selector.unfolded_color_ordinal(&[1, 4]).is_err());
+        selector.reference_unfolded_color_ordinal = Some(1);
+        for (index, expected) in [(0, [1, 3, 2, 4]), (1, [1, 2, 3, 4])] {
+            let (word, _) = selector.color_at(index).unwrap();
+            assert_eq!(word.as_ref(), expected);
+            assert_eq!(selector.color_ordinal(&word).unwrap(), index);
+        }
+        let aliased = selector.with_public_permutation(&[3, 1, 2, 0]).unwrap();
+        let (word, _) = aliased.parse_color_id("flow:4,3,2,1").unwrap();
+        assert_eq!(word.as_ref(), [1, 3, 2, 4]);
+        assert_eq!(aliased.color_ordinal(&word).unwrap(), 0);
+    }
+
+    #[test]
+    fn adjoint_basis_rejects_a_non_adjoint_seed_at_the_adapter_boundary() {
+        let seed = scalar_adapter_test_seed(digest(1), digest(2), digest(3), digest(4)).unwrap();
+        let mut policy = OnTheFlyLcSelectorPolicyV1::complete(None, false);
+        policy.color_basis = OnTheFlyColorBasis::Adjoint;
+        assert!(OnTheFlyCompactSelectorAdapterV1::from_seed(&seed, policy).is_err());
+    }
+
+    #[test]
+    fn adjoint_color_ordinals_allow_certified_colourless_spectators() {
+        // Model/coupling-order certification is generation-side. Here only
+        // the structural selector domain is validated: singlets do not take
+        // part in the two-anchor colour permutation.
+        for gluon_count in [2, 3, 4] {
+            let mut sources: Vec<_> = (1..=gluon_count)
+                .map(|label| (label, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1][..]))
+                .collect();
+            sources.push((gluon_count + 1, OnTheFlyExternalColorRoleV1::Singlet, &[0]));
+            let selector = adapter_in_basis(&sources, OnTheFlyColorBasis::Adjoint);
+            assert_eq!(selector.helicity_count(), 1 << gluon_count);
+            assert_eq!(
+                selector.color_count(),
+                single_trace_color_count(gluon_count as usize, OnTheFlyColorBasis::Adjoint)
+                    .unwrap()
+            );
+            for index in 0..selector.color_count() {
+                let (word, _) = selector.color_at(index).unwrap();
+                assert_eq!(word.len(), gluon_count as usize);
+                assert_eq!(word.first(), Some(&1));
+                assert_eq!(word.last(), Some(&gluon_count));
+                assert_eq!(selector.color_ordinal(&word).unwrap(), index);
+            }
+        }
+    }
+
+    #[test]
+    fn public_ids_require_the_existing_canonical_spelling() {
+        assert_eq!(canonical_helicity_id(&[-1, 0, 1]), "h:-1,+0,+1");
+        assert_eq!(canonical_color_id(&[]), "flow:singlet");
+        assert_eq!(canonical_color_id(&[2, 5, 1]), "flow:2,5,1");
+    }
+
+    #[test]
+    fn direct_ordinal_decoder_matches_the_existing_lc_query_contract() {
+        let seed = scalar_adapter_test_seed(digest(1), digest(2), digest(3), digest(4)).unwrap();
+        let selector = OnTheFlyCompactSelectorAdapterV1::from_seed(
+            &seed,
+            OnTheFlyLcSelectorPolicyV1::complete(None, false),
+        )
+        .unwrap();
+        let decoded = selector.decoded_query_at(&seed, 0, 0).unwrap();
+        let expected =
+            DecodedLcQueryV1::new(&seed, vec![0, 1], &[0, 0], OnTheFlyLcSelectorV1::Singlet)
+                .unwrap();
+        assert_eq!(decoded, expected);
+    }
+
+    #[test]
+    fn six_fermion_compact_census_has_sixty_four_helicities_and_six_flows() {
+        let selector = adapter(&[
+            (1, OnTheFlyExternalColorRoleV1::Fundamental, &[-1, 1]),
+            (2, OnTheFlyExternalColorRoleV1::Antifundamental, &[-1, 1]),
+            (3, OnTheFlyExternalColorRoleV1::Fundamental, &[-1, 1]),
+            (4, OnTheFlyExternalColorRoleV1::Antifundamental, &[-1, 1]),
+            (5, OnTheFlyExternalColorRoleV1::Fundamental, &[-1, 1]),
+            (6, OnTheFlyExternalColorRoleV1::Antifundamental, &[-1, 1]),
+        ]);
+        assert_eq!(selector.helicity_count(), 64);
+        assert_eq!(selector.color_count(), 6);
+    }
+
+    #[test]
+    fn alias_permutation_round_trips_helicity_and_color_ids_without_changing_ordinals() {
+        let representative = adapter(&[
+            (1, OnTheFlyExternalColorRoleV1::Fundamental, &[-1, 1]),
+            (2, OnTheFlyExternalColorRoleV1::Antifundamental, &[-1, 1]),
+            (3, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+            (4, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+        ]);
+        let representative_helicity = representative.parse_helicity_id("h:+1,-1,+1,-1").unwrap();
+        let (representative_color, _) = representative.parse_color_id("flow:1,3,4,2").unwrap();
+        let helicity_ordinal = representative
+            .helicity_ordinal(&representative_helicity)
+            .unwrap();
+        let color_ordinal = representative.color_ordinal(&representative_color).unwrap();
+
+        let aliased = representative
+            .with_public_permutation(&[0, 1, 3, 2])
+            .unwrap();
+        let aliased_helicity = aliased.parse_helicity_id("h:+1,-1,-1,+1").unwrap();
+        let (aliased_color, _) = aliased.parse_color_id("flow:1,4,3,2").unwrap();
+        assert_eq!(aliased_helicity, representative_helicity);
+        assert_eq!(aliased_color, representative_color);
+        assert_eq!(
+            aliased.helicity_ordinal(&aliased_helicity).unwrap(),
+            helicity_ordinal
+        );
+        assert_eq!(
+            aliased.color_ordinal(&aliased_color).unwrap(),
+            color_ordinal
+        );
+        assert_eq!(
+            aliased
+                .public_helicities_from_representative(&representative_helicity)
+                .unwrap()
+                .as_ref(),
+            [1, -1, -1, 1]
+        );
+        assert_eq!(
+            aliased
+                .public_labels_from_representative(&representative_color)
+                .unwrap()
+                .as_ref(),
+            [1, 4, 3, 2]
+        );
+    }
+
+    #[test]
+    fn deferred_public_physics_materializes_once_and_applies_alias_permutation_once() {
+        use crate::{ArtifactProcess, ArtifactSelection, ExternalParticle, ParticleRole};
+
+        let representative = adapter(&[
+            (1, OnTheFlyExternalColorRoleV1::Fundamental, &[-1]),
+            (2, OnTheFlyExternalColorRoleV1::Antifundamental, &[1]),
+            (3, OnTheFlyExternalColorRoleV1::Adjoint, &[0]),
+            (4, OnTheFlyExternalColorRoleV1::Adjoint, &[2]),
+        ]);
+        let external_particles = [
+            ("a", 1, ParticleRole::Initial),
+            ("b", -1, ParticleRole::Initial),
+            ("c", 21, ParticleRole::Final),
+            ("d", 22, ParticleRole::Final),
+        ]
+        .into_iter()
+        .enumerate()
+        .map(|(index, (particle, pdg, role))| ExternalParticle {
+            index,
+            label: index + 1,
+            particle: particle.to_string(),
+            pdg,
+            role,
+            momentum_slot: index,
+            momentum_components: ["E", "px", "py", "pz"].map(str::to_string),
+        })
+        .collect();
+        let metadata = super::super::on_the_fly_public_metadata::OnTheFlyPublicMetadataV1::for_test(
+            "a_b_to_c_d",
+            "a b > c d",
+            external_particles,
+        );
+        let selection = ArtifactSelection {
+            process: ArtifactProcess {
+                id: "a_b_to_c_d".to_string(),
+                expression: "a b > c d".to_string(),
+                color_accuracy: "lc".to_string(),
+                external_pdgs: vec![1, -1, 21, 22],
+                physics_path: "processes/a_b_to_c_d/physics.json".to_string(),
+                required_runtime_capabilities: Vec::new(),
+                aliases: Vec::new(),
+            },
+            requested_id: "a_b_to_d_c".to_string(),
+            alias: None,
+            public_expression: "a b > d c".to_string(),
+            external_pdgs: vec![1, -1, 22, 21],
+            external_permutation: vec![0, 1, 3, 2],
+            inferred_permutation: true,
+            process_group: None,
+        };
+        let lazy = super::super::native_runtime::LazyProcessPhysicsV1::deferred_on_the_fly(
+            metadata,
+            representative,
+            selection,
+        );
+
+        let first = lazy.get().unwrap();
+        let second = lazy.get().unwrap();
+        assert!(std::ptr::eq(first, second));
+        assert_eq!(first.process_id, "a_b_to_d_c");
+        assert_eq!(first.process, "a b > d c");
+        assert_eq!(
+            first
+                .external_particles
+                .iter()
+                .map(|particle| particle.pdg)
+                .collect::<Vec<_>>(),
+            [1, -1, 22, 21]
+        );
+        assert_eq!(first.helicities.len(), 1);
+        assert_eq!(first.helicities[0].id, "h:-1,+1,+2,+0");
+        assert_eq!(first.helicities[0].values, [-1, 1, 2, 0]);
+        assert_eq!(first.color_components[0].id(), "flow:1,4,3,2");
+        let crate::ColorComponent::LcFlow(flow) = &first.color_components[0] else {
+            panic!("on-the-fly public color axis changed kind")
+        };
+        assert_eq!(flow.word, [1, 4, 3, 2]);
+    }
+
+    #[test]
+    fn helicity_ids_validate_exact_seed_domains_and_canonical_signs() {
+        let adapter = adapter(&[
+            (1, OnTheFlyExternalColorRoleV1::Singlet, &[-1, 1]),
+            (2, OnTheFlyExternalColorRoleV1::Singlet, &[0]),
+        ]);
+        assert_eq!(adapter.helicity_count(), 2);
+        assert_eq!(adapter.helicity_at(0).unwrap().as_ref(), [-1, 0]);
+        assert_eq!(adapter.helicity_at(1).unwrap().as_ref(), [1, 0]);
+        assert_eq!(
+            adapter.parse_helicity_id("h:+1,+0").unwrap().as_ref(),
+            [1, 0]
+        );
+        assert!(adapter.parse_helicity_id("h:1,+0").is_err());
+        assert!(adapter.parse_helicity_id("h:+1,+1").is_err());
+        assert!(adapter.parse_helicity_id("h:+1").is_err());
+    }
+
+    #[test]
+    fn pure_adjoint_flows_keep_the_minimum_label_as_cyclic_anchor() {
+        let adapter = adapter(&[
+            (3, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+            (1, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+            (2, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+        ]);
+        assert_eq!(adapter.color_count(), 2);
+        assert_eq!(adapter.color_at(0).unwrap().0.as_ref(), [1, 2, 3]);
+        assert_eq!(adapter.color_at(1).unwrap().0.as_ref(), [1, 3, 2]);
+        assert!(adapter.parse_color_id("flow:1,3,2").is_ok());
+        assert!(adapter.parse_color_id("flow:2,3,1").is_err());
+        assert!(adapter.parse_color_id("flow:01,3,2").is_err());
+    }
+
+    #[test]
+    fn reference_word_reorders_one_complete_flow_without_changing_the_axis() {
+        let mut adapter = adapter(&[
+            (1, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+            (2, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+            (3, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+        ]);
+        adapter.reference_unfolded_color_ordinal = Some(1);
+        assert_eq!(adapter.color_at(0).unwrap().0.as_ref(), [1, 3, 2]);
+        assert_eq!(adapter.color_at(1).unwrap().0.as_ref(), [1, 2, 3]);
+        assert_eq!(adapter.color_ordinal(&[1, 3, 2]).unwrap(), 0);
+        assert_eq!(adapter.color_ordinal(&[1, 2, 3]).unwrap(), 1);
+    }
+
+    #[test]
+    fn folded_trace_axis_retains_each_public_alias_in_generator_order() {
+        let mut adapter = adapter(&[
+            (1, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+            (2, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+            (3, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+            (4, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+        ]);
+        adapter.trace_reflections_folded = true;
+        let expected = [
+            [1, 2, 3, 4],
+            [1, 4, 3, 2],
+            [1, 2, 4, 3],
+            [1, 3, 4, 2],
+            [1, 3, 2, 4],
+            [1, 4, 2, 3],
+        ];
+        for (index, word) in expected.iter().enumerate() {
+            assert_eq!(adapter.color_at(index).unwrap().0.as_ref(), word);
+            assert_eq!(adapter.color_ordinal(word).unwrap(), index);
+        }
+
+        adapter.reference_unfolded_color_ordinal = Some(2);
+        let with_reference = [
+            [1, 3, 2, 4],
+            [1, 4, 2, 3],
+            [1, 2, 3, 4],
+            [1, 4, 3, 2],
+            [1, 2, 4, 3],
+            [1, 3, 4, 2],
+        ];
+        for (index, word) in with_reference.iter().enumerate() {
+            assert_eq!(adapter.color_at(index).unwrap().0.as_ref(), word);
+            assert_eq!(adapter.color_ordinal(word).unwrap(), index);
+        }
+    }
+
+    #[test]
+    fn open_line_lazy_order_matches_the_established_generator() {
+        let adapter = adapter(&[
+            (1, OnTheFlyExternalColorRoleV1::Antifundamental, &[-1, 1]),
+            (2, OnTheFlyExternalColorRoleV1::Fundamental, &[-1, 1]),
+            (3, OnTheFlyExternalColorRoleV1::Fundamental, &[-1, 1]),
+            (4, OnTheFlyExternalColorRoleV1::Antifundamental, &[-1, 1]),
+            (5, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+            (6, OnTheFlyExternalColorRoleV1::Adjoint, &[-1, 1]),
+        ]);
+        assert_eq!(adapter.color_count(), 12);
+        let first = [
+            [2, 1, 3, 5, 6, 4],
+            [2, 5, 1, 3, 6, 4],
+            [2, 5, 6, 1, 3, 4],
+            [2, 1, 3, 6, 5, 4],
+        ];
+        for (index, expected) in first.iter().enumerate() {
+            let (actual, _) = adapter.color_at(index).unwrap();
+            assert_eq!(actual.as_ref(), expected);
+            assert_eq!(adapter.color_ordinal(&actual).unwrap(), index);
+            assert!(adapter.parse_color_id(&canonical_color_id(&actual)).is_ok());
+        }
+        assert!(adapter.parse_color_id("flow:3,5,6,4,2,1").is_err());
+        assert!(adapter.parse_color_id("flow:2,5,1,4,6,3").is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_warm_up.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_warm_up.rs
new file mode 100644
index 0000000000..2913a992b2
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/on_the_fly_warm_up.rs
@@ -0,0 +1,230 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Structured progress for the explicit one-point on-the-fly warm-up API.
+//!
+//! Ordinary evaluation never constructs this state.  In particular, resident
+//! memory sampling is performed only while an explicit observer is installed,
+//! so the warmed evaluation path acquires no clock, allocation, or syscall.
+
+use crate::{RusticolError, RusticolResult};
+use serde::Serialize;
+use std::time::{Duration, Instant};
+
+const PROGRESS_UPDATE_INTERVAL: Duration = Duration::from_millis(250);
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum NativeOnTheFlyWarmUpEventKind {
+    Start,
+    Update,
+    End,
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum NativeOnTheFlyWarmUpStage {
+    ProcessPreparation,
+    QueryFamily,
+    FamilyFinalization,
+    FirstEvaluation,
+}
+
+/// One structured warm-up progress event.  A renderer is deliberately not
+/// part of rusticol-core; Python, a CLI, or another embedding chooses how to
+/// display these snapshots.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct NativeOnTheFlyWarmUpEvent {
+    pub schema_version: u32,
+    pub kind: NativeOnTheFlyWarmUpEventKind,
+    pub stage: NativeOnTheFlyWarmUpStage,
+    pub completed: u64,
+    pub total: u64,
+    pub elapsed_seconds: f64,
+    pub current_rss_bytes: Option<u64>,
+    pub peak_rss_bytes: Option<u64>,
+    pub workers: u64,
+    pub message: Option<String>,
+}
+
+/// Summary of an explicit one-point binary64 warm-up transaction.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct NativeOnTheFlyWarmUpResult {
+    pub schema_version: u32,
+    pub elapsed_seconds: f64,
+    pub query_count: u64,
+    pub warmed_query_count: u64,
+    pub current_rss_bytes: Option<u64>,
+    pub peak_rss_bytes: Option<u64>,
+    pub already_warm: bool,
+    pub first_evaluation_completed: bool,
+}
+
+/// Returning `false` requests cancellation at the next observable cold-path
+/// boundary. Observer errors and cancellation are propagated through the
+/// same pending-family rollback used by ordinary evaluation failures. The one
+/// exception is the terminal `End` event for `FirstEvaluation`: it is an
+/// informational notification delivered after commit, so its return value or
+/// error cannot undo a completed warm-up.
+pub type NativeOnTheFlyWarmUpObserver<'a> =
+    dyn FnMut(&NativeOnTheFlyWarmUpEvent) -> RusticolResult<bool> + 'a;
+
+pub(super) struct OnTheFlyWarmUpProgress<'a> {
+    observer: Option<&'a mut NativeOnTheFlyWarmUpObserver<'a>>,
+    started: Instant,
+    current_rss_bytes: Option<u64>,
+    peak_rss_bytes: Option<u64>,
+    workers: u64,
+    last_update_delivery: Option<Instant>,
+}
+
+impl<'a> OnTheFlyWarmUpProgress<'a> {
+    pub(super) fn new(
+        observer: Option<&'a mut NativeOnTheFlyWarmUpObserver<'a>>,
+        workers: usize,
+    ) -> RusticolResult<Self> {
+        let workers = u64::try_from(workers)
+            .map_err(|_| RusticolError::invalid_argument("warm-up worker count exceeds u64"))?;
+        Ok(Self {
+            observer,
+            started: Instant::now(),
+            current_rss_bytes: None,
+            peak_rss_bytes: None,
+            workers,
+            last_update_delivery: None,
+        })
+    }
+
+    pub(super) fn elapsed_seconds(&self) -> f64 {
+        self.started.elapsed().as_secs_f64()
+    }
+
+    pub(super) const fn current_rss_bytes(&self) -> Option<u64> {
+        self.current_rss_bytes
+    }
+
+    pub(super) const fn peak_rss_bytes(&self) -> Option<u64> {
+        self.peak_rss_bytes
+    }
+
+    pub(super) fn emit(
+        &mut self,
+        kind: NativeOnTheFlyWarmUpEventKind,
+        stage: NativeOnTheFlyWarmUpStage,
+        completed: usize,
+        total: usize,
+        message: Option<&str>,
+    ) -> RusticolResult<()> {
+        if self.observer.is_none() {
+            return Ok(());
+        }
+        if kind == NativeOnTheFlyWarmUpEventKind::Update {
+            let now = Instant::now();
+            if self
+                .last_update_delivery
+                .is_some_and(|last| now.duration_since(last) < PROGRESS_UPDATE_INTERVAL)
+            {
+                return Ok(());
+            }
+            self.last_update_delivery = Some(now);
+        }
+        self.deliver(kind, stage, completed, total, message, true)
+    }
+
+    /// Publish the post-commit completion notification.  The selected family
+    /// and its public identity are already committed at this boundary, so a
+    /// rejecting or failing observer cannot retroactively turn the completed
+    /// warm-up into an error. Embeddings may report such delivery failures as
+    /// unraisable diagnostics, but must not roll back physics state.
+    pub(super) fn emit_terminal_notification(
+        &mut self,
+        stage: NativeOnTheFlyWarmUpStage,
+        completed: usize,
+        total: usize,
+        message: Option<&str>,
+    ) {
+        let _ = self.deliver(
+            NativeOnTheFlyWarmUpEventKind::End,
+            stage,
+            completed,
+            total,
+            message,
+            false,
+        );
+    }
+
+    fn deliver(
+        &mut self,
+        kind: NativeOnTheFlyWarmUpEventKind,
+        stage: NativeOnTheFlyWarmUpStage,
+        completed: usize,
+        total: usize,
+        message: Option<&str>,
+        cancellable: bool,
+    ) -> RusticolResult<()> {
+        let Some(observer) = self.observer.as_deref_mut() else {
+            return Ok(());
+        };
+        let current_rss_bytes = current_process_rss_bytes();
+        if let Some(current) = current_rss_bytes {
+            self.current_rss_bytes = Some(current);
+            self.peak_rss_bytes = Some(self.peak_rss_bytes.unwrap_or(0).max(current));
+        }
+        let event = NativeOnTheFlyWarmUpEvent {
+            schema_version: 1,
+            kind,
+            stage,
+            completed: u64::try_from(completed).map_err(|_| {
+                RusticolError::invalid_argument("warm-up completed count exceeds u64")
+            })?,
+            total: u64::try_from(total)
+                .map_err(|_| RusticolError::invalid_argument("warm-up total exceeds u64"))?,
+            elapsed_seconds: self.started.elapsed().as_secs_f64(),
+            current_rss_bytes: self.current_rss_bytes,
+            peak_rss_bytes: self.peak_rss_bytes,
+            workers: self.workers,
+            message: message.map(str::to_owned),
+        };
+        match observer(&event) {
+            Ok(true) => Ok(()),
+            Ok(false) if !cancellable => Ok(()),
+            Ok(false) => Err(RusticolError::evaluation(
+                "on-the-fly warm-up cancelled by its progress observer",
+            )),
+            Err(_) if !cancellable => Ok(()),
+            Err(error) => Err(error),
+        }
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn current_process_rss_bytes() -> Option<u64> {
+    let mut info = std::mem::MaybeUninit::<libc::proc_taskinfo>::zeroed();
+    let size = std::mem::size_of::<libc::proc_taskinfo>();
+    let written = unsafe {
+        libc::proc_pidinfo(
+            libc::getpid(),
+            libc::PROC_PIDTASKINFO,
+            0,
+            info.as_mut_ptr().cast(),
+            i32::try_from(size).ok()?,
+        )
+    };
+    if usize::try_from(written).ok()? != size {
+        return None;
+    }
+    Some(unsafe { info.assume_init() }.pti_resident_size)
+}
+
+#[cfg(target_os = "linux")]
+fn current_process_rss_bytes() -> Option<u64> {
+    let statm = std::fs::read_to_string("/proc/self/statm").ok()?;
+    let resident_pages = statm.split_whitespace().nth(1)?.parse::<u64>().ok()?;
+    let page_size = unsafe { libc::sysconf(libc::_SC_PAGESIZE) };
+    let page_size = u64::try_from(page_size).ok()?;
+    resident_pages.checked_mul(page_size)
+}
+
+#[cfg(not(any(target_os = "linux", target_os = "macos")))]
+const fn current_process_rss_bytes() -> Option<u64> {
+    None
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/physics.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/physics.rs
new file mode 100644
index 0000000000..4ecdf95ff2
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/physics.rs
@@ -0,0 +1,1370 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+static NEXT_PHYSICS_RUNTIME_BINDING_ID: std::sync::atomic::AtomicU64 =
+    std::sync::atomic::AtomicU64::new(1);
+
+impl PhysicsRuntime {
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    pub(super) fn new(manifest: ProcessPhysicsV1) -> RusticolResult<Self> {
+        manifest.validate()?;
+        let helicity_index_by_id = manifest
+            .helicities
+            .iter()
+            .enumerate()
+            .map(|(index, helicity)| (helicity.id.clone(), index))
+            .collect::<BTreeMap<_, _>>();
+        let helicity_representative_index = manifest
+            .helicities
+            .iter()
+            .map(|helicity| {
+                helicity_index_by_id
+                    .get(&helicity.representative_id)
+                    .copied()
+                    .ok_or_else(|| {
+                        RusticolError::artifact(format!(
+                            "helicity {} references absent representative {}",
+                            helicity.id, helicity.representative_id
+                        ))
+                    })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let mut helicity_members_by_representative = vec![Vec::new(); manifest.helicities.len()];
+        for (physical_index, representative_index) in
+            helicity_representative_index.iter().copied().enumerate()
+        {
+            if !manifest.helicities[physical_index].structural_zero {
+                helicity_members_by_representative[representative_index].push(physical_index);
+            }
+        }
+        let color_index_by_id = manifest
+            .color_components
+            .iter()
+            .enumerate()
+            .map(|(index, color)| (color.id().to_string(), index))
+            .collect::<BTreeMap<_, _>>();
+        let mut reduction_by_group_id = BTreeMap::new();
+        let mut numeric_reduction_by_group_id = BTreeMap::new();
+        for group in &manifest.reduction.groups {
+            let group_id = parse_reduction_group_id(&group.id)?;
+            let mut expected_helicity_weight = None;
+            for id in &group.physical_helicity_ids {
+                let index = helicity_index_by_id[id];
+                let coefficient = manifest.helicities[index].coefficient;
+                if let Some(expected) = expected_helicity_weight {
+                    if coefficient.to_bits() != expected {
+                        return Err(RusticolError::artifact(format!(
+                            "resolved reduction group {} has inconsistent helicity weights",
+                            group.id
+                        )));
+                    }
+                } else {
+                    expected_helicity_weight = Some(coefficient.to_bits());
+                }
+            }
+            if reduction_by_group_id
+                .insert(group_id, group.clone())
+                .is_some()
+            {
+                return Err(RusticolError::artifact(format!(
+                    "resolved reduction groups map to duplicate evaluator id {group_id}"
+                )));
+            }
+            if numeric_reduction_by_group_id
+                .insert(
+                    group_id,
+                    numeric_reduction_group(
+                        group,
+                        &manifest,
+                        &helicity_index_by_id,
+                        &color_index_by_id,
+                    )?,
+                )
+                .is_some()
+            {
+                return Err(RusticolError::artifact(format!(
+                    "resolved reduction groups map to duplicate numeric evaluator id {group_id}"
+                )));
+            }
+        }
+        Ok(Self {
+            binding_id: NEXT_PHYSICS_RUNTIME_BINDING_ID
+                .fetch_add(1, std::sync::atomic::Ordering::Relaxed),
+            manifest,
+            helicity_index_by_id,
+            helicity_members_by_representative,
+            color_index_by_id,
+            reduction_by_group_id,
+            numeric_reduction_by_group_id,
+        })
+    }
+
+    pub(super) fn selected_helicity_indices(
+        &self,
+        ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<Vec<usize>> {
+        let mut indices = Vec::new();
+        self.select_indices_into(ids, &self.helicity_index_by_id, "helicity", &mut indices)?;
+        Ok(indices)
+    }
+
+    pub(super) fn selected_color_indices(
+        &self,
+        ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<Vec<usize>> {
+        let mut indices = Vec::new();
+        self.select_indices_into(
+            ids,
+            &self.color_index_by_id,
+            "color component",
+            &mut indices,
+        )?;
+        Ok(indices)
+    }
+
+    pub(super) fn canonical_total_helicity_selector<'a>(
+        &self,
+        ids: Option<&'a BTreeSet<String>>,
+    ) -> Option<&'a BTreeSet<String>> {
+        canonical_total_axis_selector(ids, &self.helicity_index_by_id)
+    }
+
+    pub(super) fn canonical_total_color_selector<'a>(
+        &self,
+        ids: Option<&'a BTreeSet<String>>,
+    ) -> Option<&'a BTreeSet<String>> {
+        canonical_total_axis_selector(ids, &self.color_index_by_id)
+    }
+
+    pub(super) fn validate_helicity_id_slice(&self, ids: Option<&[String]>) -> RusticolResult<()> {
+        self.validate_id_slice(ids, &self.helicity_index_by_id, "helicity")
+    }
+
+    pub(super) fn validate_color_id_slice(&self, ids: Option<&[String]>) -> RusticolResult<()> {
+        self.validate_id_slice(ids, &self.color_index_by_id, "color component")
+    }
+
+    fn validate_id_slice(
+        &self,
+        ids: Option<&[String]>,
+        available: &BTreeMap<String, usize>,
+        kind: &str,
+    ) -> RusticolResult<()> {
+        if let Some(ids) = ids {
+            for id in ids {
+                if !available.contains_key(id) {
+                    return Err(RusticolError::selector(format!(
+                        "unknown resolved {kind} id {id:?}"
+                    )));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn select_indices_into(
+        &self,
+        ids: Option<&BTreeSet<String>>,
+        available: &BTreeMap<String, usize>,
+        kind: &str,
+        indices: &mut Vec<usize>,
+    ) -> RusticolResult<()> {
+        indices.clear();
+        if let Some(ids) = ids {
+            for id in ids {
+                let index = available.get(id).ok_or_else(|| {
+                    RusticolError::selector(format!("unknown resolved {kind} id {id:?}"))
+                })?;
+                indices.push(*index);
+            }
+            indices.sort_unstable();
+        } else {
+            indices.extend(0..available.len());
+        }
+        Ok(())
+    }
+
+    pub(super) fn selected_helicity_indices_into(
+        &self,
+        ids: Option<&BTreeSet<String>>,
+        indices: &mut Vec<usize>,
+    ) -> RusticolResult<()> {
+        self.select_indices_into(ids, &self.helicity_index_by_id, "helicity", indices)
+    }
+
+    pub(super) fn selected_color_indices_into(
+        &self,
+        ids: Option<&BTreeSet<String>>,
+        indices: &mut Vec<usize>,
+    ) -> RusticolResult<()> {
+        self.select_indices_into(ids, &self.color_index_by_id, "color component", indices)
+    }
+
+    pub(super) fn has_contracted_color_axis(&self) -> bool {
+        matches!(
+            self.manifest.color_components.as_slice(),
+            [PhysicsColorComponentV1::ContractedColor(_)]
+        )
+    }
+
+    pub(super) fn color_is_computed(&self, index: usize) -> bool {
+        match &self.manifest.color_components[index] {
+            PhysicsColorComponentV1::LcFlow(flow) => flow.computed,
+            PhysicsColorComponentV1::ContractedColor(_) => true,
+        }
+    }
+
+    #[inline(always)]
+    pub(super) fn helicity_orbit_members(&self, representative: usize) -> &[usize] {
+        self.helicity_members_by_representative
+            .get(representative)
+            .map(Vec::as_slice)
+            .unwrap_or_default()
+    }
+
+    pub(super) fn normalized_helicity_weights(
+        &self,
+        group: &crate::ReductionGroup,
+    ) -> RusticolResult<Vec<(usize, f64)>> {
+        let mut weights = Vec::new();
+        self.normalized_helicity_weights_into(group, &mut weights)?;
+        Ok(weights)
+    }
+
+    pub(super) fn normalized_helicity_weights_into(
+        &self,
+        group: &crate::ReductionGroup,
+        weights: &mut Vec<(usize, f64)>,
+    ) -> RusticolResult<()> {
+        weights.clear();
+        weights
+            .try_reserve(group.physical_helicity_ids.len())
+            .map_err(|error| {
+                RusticolError::invalid_argument(format!(
+                    "could not reserve normalized helicity weights: {error}"
+                ))
+            })?;
+        let mut total = 0.0;
+        for id in &group.physical_helicity_ids {
+            let index = self.helicity_index_by_id[id];
+            let coefficient = self.manifest.helicities[index].coefficient;
+            total += coefficient;
+            weights.push((index, coefficient));
+        }
+        if !total.is_finite() || total <= 0.0 {
+            return Err(RusticolError::artifact(format!(
+                "resolved reduction group {} has no positive helicity weight",
+                group.id
+            )));
+        }
+        for (_, weight) in weights.iter_mut() {
+            *weight /= total;
+        }
+        Ok(())
+    }
+
+    pub(super) fn normalized_member_weights(
+        &self,
+        group: &crate::ReductionGroup,
+    ) -> RusticolResult<Vec<(usize, usize, f64)>> {
+        let mut weights = Vec::new();
+        self.normalized_member_weights_into(group, &mut weights)?;
+        Ok(weights)
+    }
+
+    pub(super) fn normalized_member_weights_into(
+        &self,
+        group: &crate::ReductionGroup,
+        weights: &mut Vec<(usize, usize, f64)>,
+    ) -> RusticolResult<()> {
+        weights.clear();
+        let mut total = 0.0;
+        for helicity_id in &group.physical_helicity_ids {
+            let helicity_index = self.helicity_index_by_id[helicity_id];
+            let helicity_weight = self.manifest.helicities[helicity_index].coefficient;
+            for color_id in &group.physical_color_ids {
+                let color_index = self.color_index_by_id[color_id];
+                let weight =
+                    helicity_weight * self.manifest.color_components[color_index].coefficient();
+                total += weight;
+                weights.push((helicity_index, color_index, weight));
+            }
+        }
+        if !total.is_finite() || total <= 0.0 {
+            return Err(RusticolError::artifact(format!(
+                "resolved reduction group {} has no positive member weight",
+                group.id
+            )));
+        }
+        for (_, _, weight) in weights.iter_mut() {
+            *weight /= total;
+        }
+        Ok(())
+    }
+
+    pub(super) fn lc_resolved_replay_plan(
+        &self,
+        mappings: &LcTopologyReplayMappings,
+        sector_routes: &[Vec<LcTopologyReplaySectorRoute>],
+        materialized_sector_by_id: &BTreeMap<i64, LcMaterializedSector>,
+    ) -> RusticolResult<LcResolvedReplayPlan> {
+        if self.manifest.color_accuracy.as_str() != "lc" {
+            return Err(RusticolError::artifact(
+                "LC topology replay requires LC resolved physics metadata",
+            ));
+        }
+        if mappings.len() != sector_routes.len() {
+            return Err(RusticolError::artifact(
+                "LC topology replay mappings and sector routes have inconsistent lengths",
+            ));
+        }
+
+        let helicity_count = self.manifest.helicities.len();
+        let color_count = self.manifest.color_components.len();
+        let mut relevant_helicities = BTreeSet::new();
+        let mut relevant_colors = BTreeSet::new();
+        for reduction in self.reduction_by_group_id.values() {
+            for id in &reduction.physical_helicity_ids {
+                relevant_helicities.insert(self.helicity_index_by_id[id]);
+            }
+            for id in &reduction.physical_color_ids {
+                relevant_colors.insert(self.color_index_by_id[id]);
+            }
+        }
+        if relevant_helicities.is_empty() || relevant_colors.is_empty() {
+            return Err(RusticolError::artifact(
+                "LC topology replay has no materialized resolved members",
+            ));
+        }
+
+        let helicity_index_by_values = self
+            .manifest
+            .helicities
+            .iter()
+            .enumerate()
+            .map(|(index, helicity)| (helicity.values.clone(), index))
+            .collect::<BTreeMap<_, _>>();
+        if helicity_index_by_values.len() != helicity_count {
+            return Err(RusticolError::artifact(
+                "resolved physics contains duplicate helicity vectors",
+            ));
+        }
+        let mut color_index_by_word = BTreeMap::new();
+        for (index, color) in self.manifest.color_components.iter().enumerate() {
+            let PhysicsColorComponentV1::LcFlow(flow) = color else {
+                return Err(RusticolError::artifact(
+                    "LC topology replay encountered a contracted color component",
+                ));
+            };
+            if color_index_by_word
+                .insert(flow.word.clone(), index)
+                .is_some()
+            {
+                return Err(RusticolError::artifact(
+                    "resolved physics contains duplicate LC flow words",
+                ));
+            }
+        }
+
+        let mut entries = Vec::with_capacity(mappings.len());
+        let mut target_sector_by_color = BTreeMap::new();
+        for (mapping, mapping_routes) in mappings.iter().zip(sector_routes) {
+            validate_public_label_permutation(mapping, self.manifest.external_particles.len())?;
+            let mut helicity_targets = BTreeMap::new();
+            for source_index in &relevant_helicities {
+                let source = &self.manifest.helicities[*source_index];
+                let target_values = permute_public_helicity(&source.values, mapping);
+                let target_index = *helicity_index_by_values.get(&target_values).ok_or_else(|| {
+                    RusticolError::compatibility(format!(
+                        "resolved physics is missing replayed helicity vector {target_values:?}; regenerate the artifact with complete topology-replay reductions"
+                    ))
+                })?;
+                let target = &self.manifest.helicities[target_index];
+                if source.coefficient.to_bits() != target.coefficient.to_bits() {
+                    return Err(RusticolError::artifact(format!(
+                        "LC topology replay maps helicity {} to {} with a different reduction coefficient",
+                        source.id, target.id
+                    )));
+                }
+                helicity_targets.insert(*source_index, target_index);
+            }
+
+            let mut routes = Vec::new();
+            for sector_route in mapping_routes {
+                let source_sector = *materialized_sector_by_id
+                    .get(&sector_route.materialized_sector_id)
+                    .ok_or_else(|| {
+                        RusticolError::artifact(format!(
+                            "LC topology replay materialized sector {} has no computed physics component",
+                            sector_route.materialized_sector_id
+                        ))
+                    })?;
+                let source_index = source_sector.color_index;
+                let PhysicsColorComponentV1::LcFlow(source) =
+                    &self.manifest.color_components[source_index]
+                else {
+                    return Err(RusticolError::artifact(
+                        "LC topology replay encountered a contracted materialized color component",
+                    ));
+                };
+                if !source.computed || source.representative_id != source.id {
+                    return Err(RusticolError::artifact(format!(
+                        "LC topology replay sector {} is not bound to a self-representing computed color component",
+                        sector_route.materialized_sector_id
+                    )));
+                }
+                let target_word = permute_public_color_word(&source.word, mapping);
+                let reduction_weight = if sector_route.residual {
+                    source_sector.reduction_weight
+                } else {
+                    sector_route.squared_reduction_weight()
+                };
+                let target_words = replay_public_color_words(&target_word, reduction_weight)?;
+                let mut target_coefficients = BTreeMap::new();
+                for word in target_words {
+                    let target_index = *color_index_by_word.get(&word).ok_or_else(|| {
+                        RusticolError::compatibility(format!(
+                            "resolved physics is missing replayed LC flow word {word:?}; regenerate the artifact with replay-to-public-flow reductions"
+                        ))
+                    })?;
+                    let coefficient = self.manifest.color_components[target_index].coefficient();
+                    if !coefficient.is_finite() || coefficient <= 0.0 {
+                        return Err(RusticolError::artifact(format!(
+                            "replayed LC flow {} has no positive reduction coefficient",
+                            self.manifest.color_components[target_index].id()
+                        )));
+                    }
+                    let PhysicsColorComponentV1::LcFlow(target) =
+                        &self.manifest.color_components[target_index]
+                    else {
+                        unreachable!("LC color axes checked above");
+                    };
+                    if target.representative_id != source.id {
+                        return Err(RusticolError::artifact(format!(
+                            "LC topology replay physical sector {} targets color {} represented by {}, expected {}",
+                            sector_route.physical_sector_id,
+                            target.id,
+                            target.representative_id,
+                            source.id
+                        )));
+                    }
+                    if let Some(previous_sector) =
+                        target_sector_by_color.insert(target_index, sector_route.physical_sector_id)
+                        && previous_sector != sector_route.physical_sector_id
+                    {
+                        return Err(RusticolError::artifact(format!(
+                            "LC topology replay physical sectors {previous_sector} and {} overlap color {}",
+                            sector_route.physical_sector_id, target.id
+                        )));
+                    }
+                    target_coefficients
+                        .entry(target_index)
+                        .or_insert(coefficient);
+                }
+                let total = target_coefficients.values().sum::<f64>();
+                if !total.is_finite() || total <= 0.0 {
+                    return Err(RusticolError::artifact(
+                        "LC topology replay has no positive public-flow reduction weight",
+                    ));
+                }
+                for (source_helicity, target_helicity) in &helicity_targets {
+                    for (target_color, coefficient) in &target_coefficients {
+                        routes.push(LcResolvedReplayRoute {
+                            source_index: source_helicity * color_count + source_index,
+                            target_index: target_helicity * color_count + target_color,
+                            weight: reduction_weight * coefficient / total,
+                        });
+                    }
+                }
+            }
+            if routes.is_empty() {
+                return Err(RusticolError::artifact(
+                    "LC topology replay mapping contains no resolved component routes",
+                ));
+            }
+            entries.push(LcResolvedReplayEntry { routes });
+        }
+        if target_sector_by_color.len() != color_count {
+            return Err(RusticolError::artifact(format!(
+                "LC topology replay covers {} of {color_count} physical color components",
+                target_sector_by_color.len()
+            )));
+        }
+        let mut routes_by_target = vec![Vec::new(); helicity_count * color_count];
+        for (mapping_index, entry) in entries.iter().enumerate() {
+            for route in &entry.routes {
+                routes_by_target[route.target_index].push(LcResolvedReplayTargetRoute {
+                    mapping_index,
+                    source_index: route.source_index,
+                    weight: route.weight,
+                });
+            }
+        }
+        Ok(LcResolvedReplayPlan {
+            #[cfg(test)]
+            entries,
+            routes_by_target,
+            color_count,
+        })
+    }
+
+    #[cfg(test)]
+    pub(super) fn select_lc_resolved_replay_plan(
+        &self,
+        plan: &LcResolvedReplayPlan,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<LcResolvedReplaySelection> {
+        let key =
+            self.lc_resolved_replay_selection_key(selected_helicity_ids, selected_color_ids)?;
+        self.select_lc_resolved_replay_plan_for_key(plan, &key)
+    }
+
+    pub(super) fn lc_resolved_replay_selection_key(
+        &self,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<LcResolvedReplaySelectionKey> {
+        Ok(LcResolvedReplaySelectionKey {
+            helicity_indices: selected_helicity_ids
+                .map(|ids| self.selected_helicity_indices(Some(ids)))
+                .transpose()?,
+            color_indices: selected_color_ids
+                .map(|ids| self.selected_color_indices(Some(ids)))
+                .transpose()?,
+        })
+    }
+
+    pub(super) fn select_lc_resolved_replay_plan_for_key(
+        &self,
+        plan: &LcResolvedReplayPlan,
+        key: &LcResolvedReplaySelectionKey,
+    ) -> RusticolResult<LcResolvedReplaySelection> {
+        let helicity_indices = key
+            .helicity_indices
+            .clone()
+            .unwrap_or_else(|| (0..self.manifest.helicities.len()).collect());
+        let color_indices = key
+            .color_indices
+            .clone()
+            .unwrap_or_else(|| (0..self.manifest.color_components.len()).collect());
+        let mut compact_target_by_full = BTreeMap::new();
+        for (helicity_position, helicity_index) in helicity_indices.iter().enumerate() {
+            for (color_position, color_index) in color_indices.iter().enumerate() {
+                compact_target_by_full.insert(
+                    helicity_index * plan.color_count + color_index,
+                    helicity_position * color_indices.len() + color_position,
+                );
+            }
+        }
+
+        let mut routes_by_mapping = BTreeMap::<usize, Vec<LcResolvedReplayRoute>>::new();
+        for (target_full_index, target_compact_index) in &compact_target_by_full {
+            let routes = plan
+                .routes_by_target
+                .get(*target_full_index)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "LC topology replay target index is outside its route index",
+                    )
+                })?;
+            for route in routes {
+                routes_by_mapping
+                    .entry(route.mapping_index)
+                    .or_default()
+                    .push(LcResolvedReplayRoute {
+                        source_index: route.source_index,
+                        target_index: *target_compact_index,
+                        weight: route.weight,
+                    });
+            }
+        }
+
+        let mut mapping_indices = Vec::with_capacity(routes_by_mapping.len());
+        let mut entries = Vec::with_capacity(routes_by_mapping.len());
+        let mut source_helicity_indices = Vec::new();
+        let mut source_color_indices = Vec::new();
+        for (mapping_index, selected_routes) in routes_by_mapping {
+            let source_helicities = selected_routes
+                .iter()
+                .map(|route| route.source_index / plan.color_count)
+                .collect::<BTreeSet<_>>()
+                .into_iter()
+                .collect::<Vec<_>>();
+            let source_colors = selected_routes
+                .iter()
+                .map(|route| route.source_index % plan.color_count)
+                .collect::<BTreeSet<_>>()
+                .into_iter()
+                .collect::<Vec<_>>();
+            let compact_helicity = source_helicities
+                .iter()
+                .copied()
+                .enumerate()
+                .map(|(position, index)| (index, position))
+                .collect::<BTreeMap<_, _>>();
+            let compact_color = source_colors
+                .iter()
+                .copied()
+                .enumerate()
+                .map(|(position, index)| (index, position))
+                .collect::<BTreeMap<_, _>>();
+            let routes = selected_routes
+                .into_iter()
+                .map(|route| {
+                    let source_helicity = route.source_index / plan.color_count;
+                    let source_color = route.source_index % plan.color_count;
+                    LcResolvedReplayRoute {
+                        source_index: compact_helicity[&source_helicity] * source_colors.len()
+                            + compact_color[&source_color],
+                        target_index: route.target_index,
+                        weight: route.weight,
+                    }
+                })
+                .collect();
+            mapping_indices.push(mapping_index);
+            entries.push(LcResolvedReplayEntry { routes });
+            source_helicity_indices.push(source_helicities);
+            source_color_indices.push(source_colors);
+        }
+        if entries.len() != mapping_indices.len()
+            || entries.len() != source_helicity_indices.len()
+            || entries.len() != source_color_indices.len()
+        {
+            return Err(RusticolError::integrity(
+                "LC topology replay selection has inconsistent mappings and entries",
+            ));
+        }
+        let mut entry_indices_by_source = BTreeMap::<(Vec<usize>, Vec<usize>), Vec<usize>>::new();
+        for entry_index in 0..entries.len() {
+            entry_indices_by_source
+                .entry((
+                    source_helicity_indices[entry_index].clone(),
+                    source_color_indices[entry_index].clone(),
+                ))
+                .or_default()
+                .push(entry_index);
+        }
+        let source_groups = entry_indices_by_source
+            .into_iter()
+            .map(|((helicity_indices, color_indices), entry_indices)| {
+                let helicity_ids = helicity_indices
+                    .iter()
+                    .map(|index| self.manifest.helicities[*index].id.clone())
+                    .collect();
+                let color_ids = color_indices
+                    .iter()
+                    .map(|index| self.manifest.color_components[*index].id().to_string())
+                    .collect();
+                LcResolvedReplaySourceGroup {
+                    mapping_indices: entry_indices
+                        .iter()
+                        .map(|entry_index| mapping_indices[*entry_index])
+                        .collect(),
+                    entries: entry_indices
+                        .iter()
+                        .map(|entry_index| entries[*entry_index].clone())
+                        .collect(),
+                    helicity_ids,
+                    color_ids,
+                    materialized_sector_ids: None,
+                    direct_total_plan: None,
+                    source_component_count: helicity_indices.len() * color_indices.len(),
+                }
+            })
+            .collect();
+        Ok(LcResolvedReplaySelection {
+            #[cfg(test)]
+            mapping_indices,
+            #[cfg(test)]
+            entries,
+            #[cfg(test)]
+            source_helicity_indices,
+            #[cfg(test)]
+            source_color_indices,
+            source_groups,
+            helicity_indices,
+            color_indices,
+        })
+    }
+}
+
+fn canonical_total_axis_selector<'a>(
+    ids: Option<&'a BTreeSet<String>>,
+    available: &BTreeMap<String, usize>,
+) -> Option<&'a BTreeSet<String>> {
+    ids.filter(|ids| {
+        ids.len() != available.len() || ids.iter().any(|id| !available.contains_key(id))
+    })
+}
+
+fn numeric_reduction_group(
+    group: &crate::ReductionGroup,
+    manifest: &ProcessPhysicsV1,
+    helicity_index_by_id: &BTreeMap<String, usize>,
+    color_index_by_id: &BTreeMap<String, usize>,
+) -> RusticolResult<NumericReductionGroup> {
+    let mut physical_helicity_indices = Vec::with_capacity(group.physical_helicity_ids.len());
+    let mut helicity_membership = vec![false; manifest.helicities.len()];
+    let mut normalized_helicity_weights = Vec::with_capacity(group.physical_helicity_ids.len());
+    let mut total_helicity_weight = 0.0;
+    for id in &group.physical_helicity_ids {
+        let index = *helicity_index_by_id.get(id).ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "resolved reduction group {} references unknown helicity {id:?}",
+                group.id
+            ))
+        })?;
+        let coefficient = manifest.helicities[index].coefficient;
+        physical_helicity_indices.push(index);
+        helicity_membership[index] = true;
+        normalized_helicity_weights.push((index, coefficient));
+        total_helicity_weight += coefficient;
+    }
+    if !total_helicity_weight.is_finite() || total_helicity_weight <= 0.0 {
+        return Err(RusticolError::artifact(format!(
+            "resolved reduction group {} has no positive helicity weight",
+            group.id
+        )));
+    }
+    for (_, weight) in &mut normalized_helicity_weights {
+        *weight /= total_helicity_weight;
+    }
+
+    let mut physical_color_weights = Vec::with_capacity(group.physical_color_ids.len());
+    let mut total_color_weight = 0.0;
+    for id in &group.physical_color_ids {
+        let index = *color_index_by_id.get(id).ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "resolved reduction group {} references unknown color {id:?}",
+                group.id
+            ))
+        })?;
+        let coefficient = manifest.color_components[index].coefficient();
+        physical_color_weights.push((index, coefficient));
+        total_color_weight += coefficient;
+    }
+    if !total_color_weight.is_finite() || total_color_weight <= 0.0 {
+        return Err(RusticolError::artifact(format!(
+            "resolved reduction group {} has no positive color weight",
+            group.id
+        )));
+    }
+    let mut normalized_color_weights = physical_color_weights.clone();
+    for (_, weight) in &mut normalized_color_weights {
+        *weight /= total_color_weight;
+    }
+
+    let member_count = group
+        .physical_helicity_ids
+        .len()
+        .checked_mul(group.physical_color_ids.len())
+        .ok_or_else(|| RusticolError::artifact("resolved reduction member count overflows"))?;
+    let mut normalized_member_weights = Vec::with_capacity(member_count);
+    let mut total_member_weight = 0.0;
+    for helicity_id in &group.physical_helicity_ids {
+        let helicity_index = helicity_index_by_id[helicity_id];
+        let helicity_weight = manifest.helicities[helicity_index].coefficient;
+        for (color_index, color_weight) in &physical_color_weights {
+            let weight = helicity_weight * *color_weight;
+            total_member_weight += weight;
+            normalized_member_weights.push((helicity_index, *color_index, weight));
+        }
+    }
+    if !total_member_weight.is_finite() || total_member_weight <= 0.0 {
+        return Err(RusticolError::artifact(format!(
+            "resolved reduction group {} has no positive member weight",
+            group.id
+        )));
+    }
+    for (_, _, weight) in &mut normalized_member_weights {
+        *weight /= total_member_weight;
+    }
+
+    Ok(NumericReductionGroup {
+        physical_helicity_indices,
+        helicity_membership,
+        normalized_helicity_weights,
+        normalized_color_weights,
+        normalized_member_weights,
+    })
+}
+
+impl ExecutionRuntime {
+    pub(super) fn set_external_pdg_order_recursive(&mut self, pdgs: &[i32]) {
+        self.external_pdg_order = pdgs.to_vec();
+        if let Some(sum_runtime) = self.helicity_sum_runtime.as_mut() {
+            sum_runtime.set_external_pdg_order_recursive(pdgs);
+        }
+        for selector_runtime in &mut self.helicity_selector_runtimes {
+            selector_runtime.set_external_pdg_order_recursive(pdgs);
+        }
+        for selector_runtime in self.color_selector_runtimes.values_mut() {
+            selector_runtime.set_external_pdg_order_recursive(pdgs);
+        }
+    }
+
+    pub(super) fn remap_physics_reduction_overrides(
+        &mut self,
+        helicity_id_map: &BTreeMap<String, String>,
+        color_id_map: &BTreeMap<String, String>,
+    ) -> RusticolResult<()> {
+        self.lc_resolved_replay_plan = None;
+        self.lc_resolved_replay_selection_cache = None;
+        if let Some(reduction) = self.physics_reduction_override.as_mut() {
+            remap_reduction_ids(reduction, helicity_id_map, color_id_map)?;
+        }
+        if let Some(sum_runtime) = self.helicity_sum_runtime.as_mut() {
+            sum_runtime.remap_physics_reduction_overrides(helicity_id_map, color_id_map)?;
+        }
+        for selector_runtime in &mut self.helicity_selector_runtimes {
+            selector_runtime.remap_physics_reduction_overrides(helicity_id_map, color_id_map)?;
+        }
+        for selector_runtime in self.color_selector_runtimes.values_mut() {
+            selector_runtime.remap_physics_reduction_overrides(helicity_id_map, color_id_map)?;
+        }
+        Ok(())
+    }
+
+    pub(super) fn attach_physics(&mut self, physics: Arc<PhysicsRuntime>) -> RusticolResult<()> {
+        self.lc_resolved_replay_plan = None;
+        self.lc_resolved_replay_selection_cache = None;
+        self.physics = Some(Arc::clone(&physics));
+        if let Some(sum_runtime) = self.helicity_sum_runtime.as_mut() {
+            let sum_physics =
+                if let Some(reduction) = sum_runtime.physics_reduction_override.as_ref() {
+                    let mut manifest = physics.manifest.clone();
+                    manifest.reduction = reduction.clone();
+                    Arc::new(PhysicsRuntime::new(manifest)?)
+                } else {
+                    Arc::clone(&physics)
+                };
+            sum_runtime.attach_physics(sum_physics)?;
+        }
+        for selector_runtime in &mut self.helicity_selector_runtimes {
+            let selector_physics =
+                if let Some(reduction) = selector_runtime.physics_reduction_override.as_ref() {
+                    let mut manifest = physics.manifest.clone();
+                    manifest.reduction = reduction.clone();
+                    Arc::new(PhysicsRuntime::new(manifest)?)
+                } else {
+                    Arc::clone(&physics)
+                };
+            selector_runtime.attach_physics(selector_physics)?;
+        }
+        for selector_runtime in self.color_selector_runtimes.values_mut() {
+            let selector_physics =
+                if let Some(reduction) = selector_runtime.physics_reduction_override.as_ref() {
+                    let mut manifest = physics.manifest.clone();
+                    manifest.reduction = reduction.clone();
+                    Arc::new(PhysicsRuntime::new(manifest)?)
+                } else {
+                    Arc::clone(&physics)
+                };
+            selector_runtime.attach_physics(selector_physics)?;
+        }
+        Ok(())
+    }
+
+    pub(super) fn cached_lc_resolved_replay_plan(
+        &mut self,
+        physics: &PhysicsRuntime,
+    ) -> RusticolResult<Arc<LcResolvedReplayPlan>> {
+        if let Some(plan) = &self.lc_resolved_replay_plan {
+            return Ok(Arc::clone(plan));
+        }
+        let materialized_sector_by_id = self.lc_materialized_sectors_by_id(physics)?;
+        let plan = Arc::new(physics.lc_resolved_replay_plan(
+            &self.lc_topology_replay_public_mappings,
+            &self.lc_topology_replay_routes,
+            &materialized_sector_by_id,
+        )?);
+        self.lc_resolved_replay_plan = Some(Arc::clone(&plan));
+        Ok(plan)
+    }
+
+    pub(super) fn cached_lc_resolved_replay_selection(
+        &mut self,
+        physics: &PhysicsRuntime,
+        plan: &LcResolvedReplayPlan,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<Arc<LcResolvedReplaySelection>> {
+        if let Some((cached_key, selection)) = &self.lc_resolved_replay_selection_cache
+            && selected_helicity_ids.is_none()
+            && cached_key.helicity_indices.is_none()
+            && let Some(color_ids) = selected_color_ids
+            && color_ids.len() == 1
+            && let Some(color_id) = color_ids.iter().next()
+            && let Some(color_index) = physics.color_index_by_id.get(color_id)
+            && cached_key.color_indices.as_deref() == Some(std::slice::from_ref(color_index))
+        {
+            return Ok(Arc::clone(selection));
+        }
+        if let Some((cached_key, selection)) = &self.lc_resolved_replay_selection_cache
+            && selected_color_ids.is_none()
+            && cached_key.color_indices.is_none()
+            && let Some(helicity_ids) = selected_helicity_ids
+            && helicity_ids.len() == 1
+            && let Some(helicity_id) = helicity_ids.iter().next()
+            && let Some(helicity_index) = physics.helicity_index_by_id.get(helicity_id)
+            && cached_key.helicity_indices.as_deref() == Some(std::slice::from_ref(helicity_index))
+        {
+            return Ok(Arc::clone(selection));
+        }
+        let key =
+            physics.lc_resolved_replay_selection_key(selected_helicity_ids, selected_color_ids)?;
+        if let Some((cached_key, selection)) = &self.lc_resolved_replay_selection_cache
+            && cached_key == &key
+        {
+            return Ok(Arc::clone(selection));
+        }
+        let mut selection = physics.select_lc_resolved_replay_plan_for_key(plan, &key)?;
+        let sectors_by_id = self.lc_materialized_sectors_by_id(physics)?;
+        let sector_by_color_index = sectors_by_id
+            .iter()
+            .map(|(sector_id, sector)| (sector.color_index, *sector_id))
+            .collect::<BTreeMap<_, _>>();
+        let target_component_count = selection
+            .helicity_indices
+            .len()
+            .checked_mul(selection.color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        for source_group in &mut selection.source_groups {
+            let materialized_sector_ids = source_group
+                .color_ids
+                .iter()
+                .map(|color_id| {
+                    let color_index = physics.color_index_by_id.get(color_id).ok_or_else(|| {
+                        RusticolError::integrity(format!(
+                            "LC topology replay selected unknown materialized color {color_id:?}"
+                        ))
+                    })?;
+                    sector_by_color_index.get(color_index).copied().ok_or_else(|| {
+                        RusticolError::integrity(format!(
+                            "LC topology replay has no materialized sector for color {color_id:?}"
+                        ))
+                    })
+                })
+                .collect::<RusticolResult<BTreeSet<_>>>()?;
+            source_group.direct_total_plan = None;
+            if selected_helicity_ids.is_none()
+                && let ([mapping_index], [replay_entry]) = (
+                    source_group.mapping_indices.as_slice(),
+                    source_group.entries.as_slice(),
+                )
+                && materialized_sector_ids.len() == 1
+                && let Some(materialized_sector_id) = materialized_sector_ids.iter().next().copied()
+                && let Some(scale) = uniform_lc_replay_total_scale(
+                    replay_entry,
+                    source_group.source_component_count,
+                    target_component_count,
+                )
+                && self
+                    .color_selector_runtimes
+                    .get(&materialized_sector_id)
+                    .is_some_and(|runtime| {
+                        certifies_lc_direct_total_source(
+                            runtime,
+                            &source_group.helicity_ids,
+                            &source_group.color_ids,
+                        )
+                    })
+            {
+                source_group.direct_total_plan = Some(LcDirectTotalPlan {
+                    mapping_index: *mapping_index,
+                    materialized_sector_id,
+                    scale,
+                });
+            }
+            source_group.materialized_sector_ids = Some(materialized_sector_ids);
+        }
+        let selection = Arc::new(selection);
+        self.lc_resolved_replay_selection_cache = Some((key, Arc::clone(&selection)));
+        Ok(selection)
+    }
+
+    pub(super) fn lc_materialized_sectors_by_id(
+        &self,
+        physics: &PhysicsRuntime,
+    ) -> RusticolResult<BTreeMap<i64, LcMaterializedSector>> {
+        let amplitude = self.amplitude_stage.as_ref().ok_or_else(|| {
+            RusticolError::artifact("LC topology replay requires a loaded compiled amplitude stage")
+        })?;
+        self.lc_materialized_sectors_by_id_from_groups(physics, &amplitude.raw_sum_groups)
+    }
+
+    pub(super) fn lc_materialized_sector_ids_for_color_ids(
+        &self,
+        physics: &PhysicsRuntime,
+        color_ids: &BTreeSet<String>,
+    ) -> RusticolResult<BTreeSet<i64>> {
+        let sectors_by_id = self.lc_materialized_sectors_by_id(physics)?;
+        let sector_by_color_index = sectors_by_id
+            .iter()
+            .map(|(sector_id, sector)| (sector.color_index, *sector_id))
+            .collect::<BTreeMap<_, _>>();
+        color_ids
+            .iter()
+            .map(|color_id| {
+                let color_index = physics.color_index_by_id.get(color_id).ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "LC topology replay selected unknown materialized color {color_id:?}"
+                    ))
+                })?;
+                sector_by_color_index
+                    .get(color_index)
+                    .copied()
+                    .ok_or_else(|| {
+                        RusticolError::integrity(format!(
+                            "LC topology replay color {color_id:?} has no materialized sector"
+                        ))
+                    })
+            })
+            .collect()
+    }
+
+    pub(super) fn lc_materialized_sectors_by_id_from_groups(
+        &self,
+        physics: &PhysicsRuntime,
+        groups: &[RawSumGroup],
+    ) -> RusticolResult<BTreeMap<i64, LcMaterializedSector>> {
+        let mut result = BTreeMap::new();
+        for group in groups {
+            if group.sector_ids.is_empty() {
+                continue;
+            }
+            let reduction = physics
+                .reduction_by_group_id
+                .get(&group.id)
+                .ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "LC topology replay is missing physics reduction group {}",
+                        group.id
+                    ))
+                })?;
+            let computed = reduction
+                .physical_color_ids
+                .iter()
+                .map(|id| physics.color_index_by_id[id])
+                .filter(|index| physics.color_is_computed(*index))
+                .collect::<BTreeSet<_>>();
+            if computed.len() != 1 {
+                return Err(RusticolError::artifact(format!(
+                    "LC topology replay coherent group {} has {} computed color representatives, expected one",
+                    group.id,
+                    computed.len()
+                )));
+            }
+            let color_index = *computed.iter().next().expect("one computed color checked");
+            let sector = LcMaterializedSector {
+                color_index,
+                // all_sector_weight folds independent helicity and color
+                // multiplicities. Resolved public-flow expansion must only
+                // distribute the color factor; helicity replay is handled by
+                // its own selector/reduction axis.
+                reduction_weight: lc_color_replay_weight(group)?,
+            };
+            for sector_id in &group.sector_ids {
+                if let Some(previous) = result.insert(*sector_id, sector)
+                    && (previous.color_index != sector.color_index
+                        || previous.reduction_weight.to_bits() != sector.reduction_weight.to_bits())
+                {
+                    return Err(RusticolError::artifact(format!(
+                        "LC topology replay materialized sector {sector_id} maps to inconsistent computed colors or weights"
+                    )));
+                }
+            }
+        }
+        for sector_id in &self.lc_topology_replay_materialized_sector_ids {
+            if !result.contains_key(sector_id) {
+                return Err(RusticolError::artifact(format!(
+                    "LC topology replay materialized sector {sector_id} is absent from the amplitude groups"
+                )));
+            }
+        }
+        Ok(result)
+    }
+
+    pub(super) fn remap_lc_topology_replay_public_labels(
+        &mut self,
+        representative_to_public: &[usize],
+    ) -> RusticolResult<()> {
+        if representative_to_public.len() != self.external_count
+            || representative_to_public
+                .iter()
+                .copied()
+                .collect::<BTreeSet<_>>()
+                != (0..self.external_count).collect::<BTreeSet<_>>()
+        {
+            return Err(RusticolError::artifact(
+                "process alias has an invalid public-label permutation for LC topology replay",
+            ));
+        }
+        if let Some(sum_runtime) = self.helicity_sum_runtime.as_mut() {
+            sum_runtime.remap_lc_topology_replay_public_labels(representative_to_public)?;
+        }
+        for selector_runtime in &mut self.helicity_selector_runtimes {
+            selector_runtime.remap_lc_topology_replay_public_labels(representative_to_public)?;
+        }
+        if !self.lc_topology_replay_enabled {
+            return Ok(());
+        }
+        self.lc_topology_replay_public_mappings = self
+            .lc_topology_replay_mappings
+            .iter()
+            .map(|mapping| {
+                mapping
+                    .iter()
+                    .map(|(representative, sector)| {
+                        (
+                            representative_to_public[*representative],
+                            representative_to_public[*sector],
+                        )
+                    })
+                    .collect()
+            })
+            .collect();
+        self.lc_resolved_replay_plan = None;
+        self.lc_resolved_replay_selection_cache = None;
+        Ok(())
+    }
+}
+
+pub(super) fn certifies_lc_direct_total_source(
+    runtime: &ExecutionRuntime,
+    helicity_ids: &BTreeSet<String>,
+    color_ids: &BTreeSet<String>,
+) -> bool {
+    if helicity_ids.is_empty()
+        || color_ids.is_empty()
+        || runtime.helicity_sum_runtime.is_some()
+        || runtime.lc_topology_replay_enabled
+        || runtime.has_compiled_helicity_execution_plan()
+    {
+        return false;
+    }
+    let Some(physics) = runtime.physics.as_deref() else {
+        return false;
+    };
+    let Some(amplitude) = runtime.amplitude_stage.as_ref() else {
+        return false;
+    };
+    if amplitude.color_contraction.is_some()
+        || physics.manifest.reduction.kind != crate::ReductionKind::LcDiagonal
+    {
+        return false;
+    }
+    let Some(expected_component_count) = helicity_ids.len().checked_mul(color_ids.len()) else {
+        return false;
+    };
+    let groups = &physics.manifest.reduction.groups;
+    if groups.is_empty()
+        || amplitude.raw_sum_groups.len() != groups.len()
+        || runtime.amplitude_output_count != groups.len()
+    {
+        return false;
+    }
+    let raw_group_ids = amplitude
+        .raw_sum_groups
+        .iter()
+        .map(|group| group.id)
+        .collect::<BTreeSet<_>>();
+    if raw_group_ids != physics.reduction_by_group_id.keys().copied().collect() {
+        return false;
+    }
+    let mut covered_members = BTreeSet::new();
+    for group in groups {
+        if group.physical_helicity_ids.is_empty()
+            || group.physical_color_ids.is_empty()
+            || !group
+                .physical_helicity_ids
+                .contains(&group.representative_helicity_id)
+            || !group
+                .physical_color_ids
+                .contains(&group.representative_color_id)
+        {
+            return false;
+        }
+        for helicity_id in &group.physical_helicity_ids {
+            for color_id in &group.physical_color_ids {
+                if !helicity_ids.contains(helicity_id)
+                    || !color_ids.contains(color_id)
+                    || !covered_members.insert((helicity_id.as_str(), color_id.as_str()))
+                {
+                    return false;
+                }
+            }
+        }
+    }
+    covered_members.len() == expected_component_count
+}
+
+fn remap_reduction_ids(
+    reduction: &mut crate::Reduction,
+    helicity_id_map: &BTreeMap<String, String>,
+    color_id_map: &BTreeMap<String, String>,
+) -> RusticolResult<()> {
+    for group in &mut reduction.groups {
+        group.representative_helicity_id = helicity_id_map
+            .get(&group.representative_helicity_id)
+            .cloned()
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "reduction override representative helicity {:?} is absent from alias remapping",
+                    group.representative_helicity_id
+                ))
+            })?;
+        group.representative_color_id = color_id_map
+            .get(&group.representative_color_id)
+            .cloned()
+            .ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "reduction override representative color {:?} is absent from alias remapping",
+                group.representative_color_id
+            ))
+        })?;
+        for id in &mut group.physical_helicity_ids {
+            *id = helicity_id_map.get(id).cloned().ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "reduction override physical helicity {id:?} is absent from alias remapping"
+                ))
+            })?;
+        }
+        for id in &mut group.physical_color_ids {
+            *id = color_id_map.get(id).cloned().ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "reduction override physical color {id:?} is absent from alias remapping"
+                ))
+            })?;
+        }
+    }
+    Ok(())
+}
+
+fn lc_color_replay_weight(group: &RawSumGroup) -> RusticolResult<f64> {
+    if !group.weight.is_finite()
+        || group.weight <= 0.0
+        || !group.all_sector_weight.is_finite()
+        || group.all_sector_weight <= 0.0
+    {
+        return Err(RusticolError::artifact(format!(
+            "LC topology replay coherent group {} has no positive helicity/color weight",
+            group.id
+        )));
+    }
+    let color_replay_weight = group.all_sector_weight / group.weight;
+    if !color_replay_weight.is_finite() || color_replay_weight <= 0.0 {
+        return Err(RusticolError::artifact(format!(
+            "LC topology replay coherent group {} has no positive color-only weight",
+            group.id
+        )));
+    }
+    Ok(color_replay_weight)
+}
+
+fn validate_public_label_permutation(
+    mapping: &[(usize, usize)],
+    external_count: usize,
+) -> RusticolResult<()> {
+    let mut representatives = BTreeSet::new();
+    let mut sectors = BTreeSet::new();
+    for (representative, sector) in mapping {
+        if *representative >= external_count || *sector >= external_count {
+            return Err(RusticolError::artifact(
+                "LC topology replay public-label mapping references an out-of-range external leg",
+            ));
+        }
+        if !representatives.insert(*representative) || !sectors.insert(*sector) {
+            return Err(RusticolError::artifact(
+                "LC topology replay public-label mapping is not one-to-one",
+            ));
+        }
+    }
+    if representatives != sectors {
+        return Err(RusticolError::artifact(
+            "LC topology replay public-label mapping is not a permutation of its support",
+        ));
+    }
+    Ok(())
+}
+
+fn permute_public_helicity(values: &[i32], mapping: &[(usize, usize)]) -> Vec<i32> {
+    let mut target = values.to_vec();
+    for (representative, sector) in mapping {
+        target[*sector] = values[*representative];
+    }
+    target
+}
+
+fn permute_public_color_word(word: &[usize], mapping: &[(usize, usize)]) -> Vec<usize> {
+    let labels = mapping.iter().copied().collect::<BTreeMap<_, _>>();
+    word.iter()
+        .map(|label| {
+            label
+                .checked_sub(1)
+                .and_then(|index| labels.get(&index).copied())
+                .map(|index| index + 1)
+                .unwrap_or(*label)
+        })
+        .collect()
+}
+
+fn replay_public_color_words(
+    word: &[usize],
+    replay_weight: f64,
+) -> RusticolResult<Vec<Vec<usize>>> {
+    const WEIGHT_TOLERANCE: f64 = 1.0e-12;
+    if (replay_weight - 1.0).abs() <= WEIGHT_TOLERANCE {
+        return Ok(vec![word.to_vec()]);
+    }
+    if (replay_weight - 2.0).abs() > WEIGHT_TOLERANCE {
+        return Err(RusticolError::compatibility(format!(
+            "resolved LC topology replay cannot expand sector weight {replay_weight}; schema-v3 replay metadata defines public-flow expansion only for unit sectors and folded trace-reflection weight two"
+        )));
+    }
+    if word.len() < 2 {
+        return Ok(vec![word.to_vec()]);
+    }
+    let mut reflected = Vec::with_capacity(word.len());
+    reflected.push(word[0]);
+    reflected.extend(word[1..].iter().rev().copied());
+    if reflected == word {
+        Ok(vec![word.to_vec()])
+    } else {
+        Ok(vec![word.to_vec(), reflected])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn color_replay_weight_excludes_helicity_multiplicity() {
+        let group = RawSumGroup {
+            id: 7,
+            indices: vec![0],
+            weight: 2.0,
+            all_sector_weight: 4.0,
+            sector_ids: vec![0],
+        };
+
+        assert_eq!(lc_color_replay_weight(&group).unwrap(), 2.0);
+    }
+
+    #[test]
+    fn color_replay_weight_rejects_invalid_axes() {
+        let group = RawSumGroup {
+            id: 7,
+            indices: vec![0],
+            weight: 0.0,
+            all_sector_weight: 2.0,
+            sector_ids: vec![0],
+        };
+
+        assert!(lc_color_replay_weight(&group).is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/point_selectors.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/point_selectors.rs
new file mode 100644
index 0000000000..c47e56117d
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/point_selectors.rs
@@ -0,0 +1,724 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use std::collections::HashMap;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub(super) struct PointSelectorKey {
+    pub(super) helicity_index: Option<usize>,
+    pub(super) color_index: Option<usize>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) struct PointSelectorPartition {
+    pub(super) key: PointSelectorKey,
+    pub(super) rows: PointSelectorRows,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum PointSelectorRows {
+    Contiguous { start: usize, end: usize },
+    Gathered { start: usize, end: usize },
+}
+
+impl PointSelectorRows {
+    pub(super) fn len(self) -> usize {
+        match self {
+            Self::Contiguous { start, end } | Self::Gathered { start, end } => end - start,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum PointSelectorPlan {
+    None,
+    Homogeneous(PointSelectorKey),
+    Partitioned,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub(super) struct PointSelectorPlanProfile {
+    pub(super) kind: &'static str,
+    pub(super) group_sizes: Vec<usize>,
+    pub(super) reordered_point_count: usize,
+    pub(super) simd_lane_width: usize,
+    pub(super) simd_occupancy: f64,
+}
+
+/// Reusable storage for stable per-point selector grouping.
+///
+/// Partition order follows first occurrence and row order within a gathered
+/// partition follows caller order. `HashMap` iteration order therefore never
+/// affects execution order. Clearing the map and vectors retains their backing
+/// allocations for subsequent calls of the same or smaller shape.
+#[derive(Default)]
+pub(super) struct PointSelectorPlanner {
+    partition_index_by_key: HashMap<PointSelectorKey, usize>,
+    partitions: Vec<PointSelectorPartition>,
+    partition_counts: Vec<usize>,
+    partition_cursors: Vec<usize>,
+    gathered_rows: Vec<usize>,
+}
+
+impl PointSelectorPlanner {
+    pub(super) fn build(
+        &mut self,
+        point_count: usize,
+        helicity_by_point: Option<&[u32]>,
+        color_by_point: Option<&[u32]>,
+        helicity_count: usize,
+        color_count: usize,
+    ) -> RusticolResult<PointSelectorPlan> {
+        self.clear_plan();
+        if helicity_by_point.is_none() && color_by_point.is_none() {
+            return Ok(PointSelectorPlan::None);
+        }
+        validate_selector_axis(
+            helicity_by_point,
+            point_count,
+            helicity_count,
+            "helicity_by_point",
+        )?;
+        validate_selector_axis(
+            color_by_point,
+            point_count,
+            color_count,
+            "color_flow_by_point",
+        )?;
+
+        let selector_key = |point_index: usize| PointSelectorKey {
+            helicity_index: helicity_by_point.map(|values| values[point_index] as usize),
+            color_index: color_by_point.map(|values| values[point_index] as usize),
+        };
+        if point_count == 0 {
+            return Ok(PointSelectorPlan::Partitioned);
+        }
+
+        let first = selector_key(0);
+        if (1..point_count).all(|point_index| selector_key(point_index) == first) {
+            return Ok(PointSelectorPlan::Homogeneous(first));
+        }
+
+        if self.build_contiguous_runs(point_count, &selector_key) {
+            return Ok(PointSelectorPlan::Partitioned);
+        }
+
+        self.build_stable_gathered_partitions(point_count, &selector_key);
+        Ok(PointSelectorPlan::Partitioned)
+    }
+
+    pub(super) fn partitions(&self) -> &[PointSelectorPartition] {
+        &self.partitions
+    }
+
+    pub(super) fn gathered_rows(&self, rows: PointSelectorRows) -> &[usize] {
+        match rows {
+            PointSelectorRows::Gathered { start, end } => &self.gathered_rows[start..end],
+            PointSelectorRows::Contiguous { .. } => &[],
+        }
+    }
+
+    pub(super) fn profile(
+        &self,
+        plan: PointSelectorPlan,
+        point_count: usize,
+        simd_lane_width: usize,
+    ) -> PointSelectorPlanProfile {
+        let (kind, group_sizes, reordered_point_count) = match plan {
+            PointSelectorPlan::None => ("none", Vec::new(), 0),
+            PointSelectorPlan::Homogeneous(_) => ("homogeneous", vec![point_count], 0),
+            PointSelectorPlan::Partitioned
+                if self.partitions.iter().all(|partition| {
+                    matches!(partition.rows, PointSelectorRows::Contiguous { .. })
+                }) =>
+            {
+                (
+                    "contiguous",
+                    self.partitions
+                        .iter()
+                        .map(|partition| partition.rows.len())
+                        .collect(),
+                    0,
+                )
+            }
+            PointSelectorPlan::Partitioned => {
+                let reordered_point_count = self
+                    .gathered_rows
+                    .iter()
+                    .copied()
+                    .enumerate()
+                    .filter(|(grouped_index, source_index)| grouped_index != source_index)
+                    .count();
+                (
+                    "stable-grouped",
+                    self.partitions
+                        .iter()
+                        .map(|partition| partition.rows.len())
+                        .collect(),
+                    reordered_point_count,
+                )
+            }
+        };
+        let simd_lane_width = simd_lane_width.max(1);
+        let padded_point_count = group_sizes
+            .iter()
+            .map(|size| size.div_ceil(simd_lane_width) * simd_lane_width)
+            .sum::<usize>();
+        let simd_occupancy = if point_count == 0 || padded_point_count == 0 {
+            1.0
+        } else {
+            point_count as f64 / padded_point_count as f64
+        };
+        PointSelectorPlanProfile {
+            kind,
+            group_sizes,
+            reordered_point_count,
+            simd_lane_width,
+            simd_occupancy,
+        }
+    }
+
+    fn clear_plan(&mut self) {
+        self.partition_index_by_key.clear();
+        self.partitions.clear();
+        self.partition_counts.clear();
+        self.partition_cursors.clear();
+        self.gathered_rows.clear();
+    }
+
+    fn build_contiguous_runs(
+        &mut self,
+        point_count: usize,
+        selector_key: &impl Fn(usize) -> PointSelectorKey,
+    ) -> bool {
+        let mut run_start = 0;
+        let mut run_key = selector_key(0);
+        for point_index in 1..=point_count {
+            let next_key = (point_index < point_count).then(|| selector_key(point_index));
+            if next_key == Some(run_key) {
+                continue;
+            }
+            if self.partition_index_by_key.contains_key(&run_key) {
+                return false;
+            }
+            self.partition_index_by_key
+                .insert(run_key, self.partitions.len());
+            self.partitions.push(PointSelectorPartition {
+                key: run_key,
+                rows: PointSelectorRows::Contiguous {
+                    start: run_start,
+                    end: point_index,
+                },
+            });
+            if let Some(key) = next_key {
+                run_start = point_index;
+                run_key = key;
+            }
+        }
+        true
+    }
+
+    fn build_stable_gathered_partitions(
+        &mut self,
+        point_count: usize,
+        selector_key: &impl Fn(usize) -> PointSelectorKey,
+    ) {
+        self.partition_index_by_key.clear();
+        self.partitions.clear();
+        self.partition_counts.clear();
+
+        for point_index in 0..point_count {
+            let key = selector_key(point_index);
+            let partition_index = match self.partition_index_by_key.get(&key).copied() {
+                Some(index) => index,
+                None => {
+                    let index = self.partitions.len();
+                    self.partition_index_by_key.insert(key, index);
+                    self.partitions.push(PointSelectorPartition {
+                        key,
+                        rows: PointSelectorRows::Gathered { start: 0, end: 0 },
+                    });
+                    self.partition_counts.push(0);
+                    index
+                }
+            };
+            self.partition_counts[partition_index] += 1;
+        }
+
+        self.partition_cursors.resize(self.partitions.len(), 0);
+        let mut offset = 0;
+        for (partition_index, partition) in self.partitions.iter_mut().enumerate() {
+            let end = offset + self.partition_counts[partition_index];
+            partition.rows = PointSelectorRows::Gathered { start: offset, end };
+            self.partition_cursors[partition_index] = offset;
+            offset = end;
+        }
+        self.gathered_rows.resize(point_count, 0);
+        for point_index in 0..point_count {
+            let partition_index = self.partition_index_by_key[&selector_key(point_index)];
+            let cursor = &mut self.partition_cursors[partition_index];
+            self.gathered_rows[*cursor] = point_index;
+            *cursor += 1;
+        }
+    }
+}
+
+#[derive(Default)]
+pub(super) struct SelectorSetCache {
+    entries: Vec<SelectorSetCacheEntry>,
+}
+
+struct SelectorSetCacheEntry {
+    ids: Vec<String>,
+    selected: BTreeSet<String>,
+}
+
+impl SelectorSetCache {
+    const MAX_ENTRIES: usize = 64;
+
+    pub(super) fn resolve(
+        &mut self,
+        ids: Option<&[String]>,
+        kind: &str,
+    ) -> RusticolResult<Option<&BTreeSet<String>>> {
+        let Some(ids) = ids else {
+            return Ok(None);
+        };
+        if ids.is_empty() {
+            return Err(RusticolError::selector(format!(
+                "resolved {kind} selection must not be empty"
+            )));
+        }
+        if let Some(index) = self
+            .entries
+            .iter()
+            .position(|entry| entry.ids.as_slice() == ids)
+        {
+            return Ok(Some(&self.entries[index].selected));
+        }
+        let selected = ids.iter().cloned().collect::<BTreeSet<_>>();
+        if selected.len() != ids.len() {
+            return Err(RusticolError::selector(format!(
+                "resolved {kind} selection contains duplicate ids"
+            )));
+        }
+        if self.entries.len() == Self::MAX_ENTRIES {
+            self.entries.remove(0);
+        }
+        self.entries.push(SelectorSetCacheEntry {
+            ids: ids.to_vec(),
+            selected,
+        });
+        Ok(Some(
+            &self
+                .entries
+                .last()
+                .expect("selector cache entry was just appended")
+                .selected,
+        ))
+    }
+}
+
+#[cfg(test)]
+mod selector_set_cache_tests {
+    use super::*;
+
+    #[test]
+    fn selector_set_cache_is_bounded_and_rejects_duplicates() {
+        let mut cache = SelectorSetCache::default();
+        for index in 0..=SelectorSetCache::MAX_ENTRIES {
+            let ids = vec![format!("id-{index}")];
+            cache.resolve(Some(&ids), "test").unwrap();
+        }
+        assert_eq!(cache.entries.len(), SelectorSetCache::MAX_ENTRIES);
+        assert_eq!(cache.entries[0].ids, vec!["id-1"]);
+
+        let duplicate = vec!["same".to_string(), "same".to_string()];
+        assert!(cache.resolve(Some(&duplicate), "test").is_err());
+        assert_eq!(cache.entries.len(), SelectorSetCache::MAX_ENTRIES);
+    }
+}
+
+#[derive(Default)]
+pub(super) struct PointSelectorExecutionScratch {
+    pub(super) planner: PointSelectorPlanner,
+    pub(super) gathered_batch: Vec<Vec<[f64; 4]>>,
+    pub(super) partition_totals: Vec<f64>,
+    pub(super) output_totals: Vec<f64>,
+    pub(super) helicity_selector_sets: SelectorSetCache,
+    pub(super) color_selector_sets: SelectorSetCache,
+    pub(super) helicity_singletons: Vec<BTreeSet<String>>,
+    pub(super) color_singletons: Vec<BTreeSet<String>>,
+}
+
+impl PointSelectorExecutionScratch {
+    pub(super) fn prepare_singletons(&mut self, physics: &PhysicsRuntime) {
+        if self.helicity_singletons.len() != physics.manifest.helicities.len() {
+            self.helicity_singletons.clear();
+            self.helicity_singletons
+                .reserve(physics.manifest.helicities.len());
+            self.helicity_singletons.extend(
+                physics
+                    .manifest
+                    .helicities
+                    .iter()
+                    .map(|helicity| BTreeSet::from([helicity.id.clone()])),
+            );
+        }
+        if self.color_singletons.len() != physics.manifest.color_components.len() {
+            self.color_singletons.clear();
+            self.color_singletons
+                .reserve(physics.manifest.color_components.len());
+            self.color_singletons.extend(
+                physics
+                    .manifest
+                    .color_components
+                    .iter()
+                    .map(|color| BTreeSet::from([color.id().to_string()])),
+            );
+        }
+    }
+}
+
+pub(super) fn fill_gathered_batch<'a>(
+    gathered_batch: &'a mut Vec<Vec<[f64; 4]>>,
+    batch: &[Vec<[f64; 4]>],
+    point_indices: &[usize],
+) -> &'a [Vec<[f64; 4]>] {
+    if gathered_batch.len() < point_indices.len() {
+        gathered_batch.resize_with(point_indices.len(), Vec::new);
+    }
+    for (target, source_index) in gathered_batch.iter_mut().zip(point_indices.iter().copied()) {
+        target.clear();
+        target.extend_from_slice(&batch[source_index]);
+    }
+    &gathered_batch[..point_indices.len()]
+}
+
+pub(super) fn fill_gathered_batch_from_view<'a>(
+    gathered_batch: &'a mut Vec<Vec<[f64; 4]>>,
+    batch: F64MomentumBatchView<'_>,
+    point_indices: &[usize],
+) -> RusticolResult<&'a [Vec<[f64; 4]>]> {
+    if gathered_batch.len() < point_indices.len() {
+        gathered_batch.resize_with(point_indices.len(), Vec::new);
+    }
+    for (target, source_index) in gathered_batch.iter_mut().zip(point_indices.iter().copied()) {
+        if source_index >= batch.point_count() {
+            return Err(RusticolError::integrity(
+                "point-selector gather references an out-of-range input row",
+            ));
+        }
+        let point = batch.point(source_index);
+        target.clear();
+        target.reserve(batch.external_count());
+        for external_index in 0..batch.external_count() {
+            target.push(point.momentum(external_index).ok_or_else(|| {
+                RusticolError::integrity(
+                    "validated momentum view is missing an external leg during selector gather",
+                )
+            })?);
+        }
+    }
+    Ok(&gathered_batch[..point_indices.len()])
+}
+
+#[cfg(test)]
+pub(super) fn write_partition_totals(
+    partition_totals: &mut Vec<f64>,
+    resolved: &ResolvedValues<f64>,
+) {
+    let component_count = resolved.helicity_indices.len() * resolved.color_indices.len();
+    partition_totals.clear();
+    if component_count == 0 {
+        partition_totals.resize(resolved.point_count, 0.0);
+    } else {
+        partition_totals.reserve(resolved.point_count);
+        partition_totals.extend(
+            resolved
+                .values
+                .chunks(component_count)
+                .map(|point| point.iter().sum::<f64>()),
+        );
+    }
+}
+
+pub(super) fn scatter_partition_totals(
+    values: &mut [f64],
+    partition_totals: &[f64],
+    rows: PointSelectorRows,
+    planner: &PointSelectorPlanner,
+) {
+    match rows {
+        PointSelectorRows::Contiguous { start, end } => {
+            values[start..end].copy_from_slice(partition_totals);
+        }
+        rows @ PointSelectorRows::Gathered { .. } => {
+            for (source, target) in partition_totals
+                .iter()
+                .copied()
+                .zip(planner.gathered_rows(rows).iter().copied())
+            {
+                values[target] = source;
+            }
+        }
+    }
+}
+
+fn validate_selector_axis(
+    values: Option<&[u32]>,
+    point_count: usize,
+    available_count: usize,
+    name: &str,
+) -> RusticolResult<()> {
+    let Some(values) = values else {
+        return Ok(());
+    };
+    if values.len() != point_count {
+        return Err(RusticolError::selector(format!(
+            "{name} contains {} entries, expected one selector for each of {point_count} points",
+            values.len()
+        )));
+    }
+    if let Some((point_index, selector)) = values
+        .iter()
+        .copied()
+        .enumerate()
+        .find(|(_, selector)| *selector as usize >= available_count)
+    {
+        return Err(RusticolError::selector(format!(
+            "{name}[{point_index}]={selector} is out of range; the artifact exposes {available_count} selectors on this axis"
+        )));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn expanded_rows(planner: &PointSelectorPlanner) -> Vec<(PointSelectorKey, Vec<usize>, bool)> {
+        planner
+            .partitions()
+            .iter()
+            .map(|partition| match partition.rows {
+                PointSelectorRows::Contiguous { start, end } => {
+                    (partition.key, (start..end).collect(), true)
+                }
+                rows @ PointSelectorRows::Gathered { .. } => {
+                    (partition.key, planner.gathered_rows(rows).to_vec(), false)
+                }
+            })
+            .collect()
+    }
+
+    #[test]
+    fn stable_random_grouping_preserves_first_occurrence_and_caller_order() {
+        let colors = [2, 1, 2, 0, 1, 2, 0];
+        let mut planner = PointSelectorPlanner::default();
+        assert_eq!(
+            planner
+                .build(7, None, Some(&colors), 1, 3)
+                .expect("selector plan"),
+            PointSelectorPlan::Partitioned
+        );
+        assert_eq!(
+            expanded_rows(&planner),
+            vec![
+                (
+                    PointSelectorKey {
+                        helicity_index: None,
+                        color_index: Some(2),
+                    },
+                    vec![0, 2, 5],
+                    false,
+                ),
+                (
+                    PointSelectorKey {
+                        helicity_index: None,
+                        color_index: Some(1),
+                    },
+                    vec![1, 4],
+                    false,
+                ),
+                (
+                    PointSelectorKey {
+                        helicity_index: None,
+                        color_index: Some(0),
+                    },
+                    vec![3, 6],
+                    false,
+                ),
+            ]
+        );
+    }
+
+    #[test]
+    fn profile_distinguishes_zero_reorder_and_stable_grouped_plans() {
+        let mut planner = PointSelectorPlanner::default();
+        let pooled = [0, 0, 1, 1];
+        let plan = planner
+            .build(4, None, Some(&pooled), 1, 2)
+            .expect("pooled selector plan");
+        let profile = planner.profile(plan, 4, 2);
+        assert_eq!(profile.kind, "contiguous");
+        assert_eq!(profile.group_sizes, vec![2, 2]);
+        assert_eq!(profile.reordered_point_count, 0);
+
+        let alternating = [0, 1, 0, 1];
+        let plan = planner
+            .build(4, None, Some(&alternating), 1, 2)
+            .expect("alternating selector plan");
+        let profile = planner.profile(plan, 4, 2);
+        assert_eq!(profile.kind, "stable-grouped");
+        assert_eq!(profile.group_sizes, vec![2, 2]);
+        assert_eq!(profile.reordered_point_count, 2);
+        assert!((0.0..=1.0).contains(&profile.simd_occupancy));
+    }
+
+    #[test]
+    fn pooled_selector_runs_are_borrowed_without_gathering() {
+        let colors = [2, 2, 1, 1, 0];
+        let mut planner = PointSelectorPlanner::default();
+        assert_eq!(
+            planner
+                .build(5, None, Some(&colors), 1, 3)
+                .expect("selector plan"),
+            PointSelectorPlan::Partitioned
+        );
+        assert_eq!(
+            expanded_rows(&planner),
+            vec![
+                (
+                    PointSelectorKey {
+                        helicity_index: None,
+                        color_index: Some(2),
+                    },
+                    vec![0, 1],
+                    true,
+                ),
+                (
+                    PointSelectorKey {
+                        helicity_index: None,
+                        color_index: Some(1),
+                    },
+                    vec![2, 3],
+                    true,
+                ),
+                (
+                    PointSelectorKey {
+                        helicity_index: None,
+                        color_index: Some(0),
+                    },
+                    vec![4],
+                    true,
+                ),
+            ]
+        );
+        assert!(planner.gathered_rows.is_empty());
+    }
+
+    #[test]
+    fn recognizes_homogeneous_selectors_without_partition_storage() {
+        let helicities = [1, 1, 1, 1];
+        let colors = [2, 2, 2, 2];
+        let mut planner = PointSelectorPlanner::default();
+        assert_eq!(
+            planner
+                .build(4, Some(&helicities), Some(&colors), 2, 3)
+                .expect("selector plan"),
+            PointSelectorPlan::Homogeneous(PointSelectorKey {
+                helicity_index: Some(1),
+                color_index: Some(2),
+            })
+        );
+        assert!(planner.partitions().is_empty());
+    }
+
+    #[test]
+    fn reuses_planner_gather_and_partition_result_buffers() {
+        let colors = [2, 1, 2, 0, 1, 2, 0];
+        let batch = (0..colors.len())
+            .map(|point| vec![[point as f64, 0.0, 0.0, 0.0]; 3])
+            .collect::<Vec<_>>();
+        let mut scratch = PointSelectorExecutionScratch::default();
+
+        scratch
+            .planner
+            .build(colors.len(), None, Some(&colors), 1, 3)
+            .expect("first selector plan");
+        let partition_storage = scratch.planner.partitions.as_ptr();
+        let gathered_row_storage = scratch.planner.gathered_rows.as_ptr();
+        let first_rows = scratch.planner.partitions[0].rows;
+        let first_indices = scratch.planner.gathered_rows(first_rows).to_vec();
+        fill_gathered_batch(&mut scratch.gathered_batch, &batch, &first_indices);
+        let gathered_batch_storage = scratch.gathered_batch.as_ptr();
+        let gathered_point_storage = scratch.gathered_batch[0].as_ptr();
+        let resolved = ResolvedValues {
+            values: vec![1.0, 2.0, 3.0],
+            point_count: 3,
+            helicity_indices: vec![0],
+            color_indices: vec![0],
+        };
+        write_partition_totals(&mut scratch.partition_totals, &resolved);
+        let partition_total_storage = scratch.partition_totals.as_ptr();
+
+        scratch
+            .planner
+            .build(colors.len(), None, Some(&colors), 1, 3)
+            .expect("second selector plan");
+        assert_eq!(scratch.planner.partitions.as_ptr(), partition_storage);
+        assert_eq!(scratch.planner.gathered_rows.as_ptr(), gathered_row_storage);
+        let first_rows = scratch.planner.partitions[0].rows;
+        let first_indices = scratch.planner.gathered_rows(first_rows).to_vec();
+        fill_gathered_batch(&mut scratch.gathered_batch, &batch, &first_indices);
+        assert_eq!(scratch.gathered_batch.as_ptr(), gathered_batch_storage);
+        assert_eq!(scratch.gathered_batch[0].as_ptr(), gathered_point_storage);
+        write_partition_totals(&mut scratch.partition_totals, &resolved);
+        assert_eq!(scratch.partition_totals.as_ptr(), partition_total_storage);
+    }
+
+    #[test]
+    fn gathered_partition_scatter_restores_caller_order() {
+        let colors = [2, 1, 2, 0, 1, 2, 0];
+        let mut planner = PointSelectorPlanner::default();
+        planner
+            .build(colors.len(), None, Some(&colors), 1, 3)
+            .expect("selector plan");
+
+        let mut values = vec![0.0; colors.len()];
+        for partition in planner.partitions().iter().copied() {
+            let point_indices = planner.gathered_rows(partition.rows);
+            let partition_values = point_indices
+                .iter()
+                .map(|point_index| 100.0 + *point_index as f64)
+                .collect::<Vec<_>>();
+            scatter_partition_totals(&mut values, &partition_values, partition.rows, &planner);
+        }
+
+        assert_eq!(
+            values,
+            (0..colors.len())
+                .map(|point_index| 100.0 + point_index as f64)
+                .collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn validates_lengths_and_bounds() {
+        let mut planner = PointSelectorPlanner::default();
+        let error = planner
+            .build(2, Some(&[0]), None, 1, 1)
+            .expect_err("length mismatch");
+        assert!(
+            error
+                .to_string()
+                .contains("one selector for each of 2 points")
+        );
+
+        let error = planner
+            .build(2, None, Some(&[0, 1]), 1, 1)
+            .expect_err("out-of-range selector");
+        assert!(error.to_string().contains("color_flow_by_point[1]=1"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/quantum_number_flow_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/quantum_number_flow_tests.rs
new file mode 100644
index 0000000000..53550bbd0d
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/quantum_number_flow_tests.rs
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: 0BSD
+use serde_json::{Value, json};
+
+use super::GenericCurrentSlotManifest;
+
+fn compact_current_slot() -> Value {
+    json!({
+        "current_id": 0,
+        "component_start": 0,
+        "component_stop": 1,
+        "dimension": 1,
+        "is_source": true,
+        "particle_id": 101,
+        "external_mask": 1,
+        "chirality": 0,
+        "momentum_mask": 1,
+        "auxiliary_kind": null
+    })
+}
+
+#[test]
+fn compact_current_slot_has_no_quantum_number_payload() {
+    serde_json::from_value::<GenericCurrentSlotManifest>(compact_current_slot())
+        .expect("compact current slot should deserialize without quantum numbers");
+
+    for (field, value) in [
+        ("charge_flow", json!(1)),
+        ("quantum_number_flow", json!([["electric_charge", "1/5"]])),
+    ] {
+        let mut payload = compact_current_slot();
+        payload
+            .as_object_mut()
+            .expect("test current slot must be an object")
+            .insert(field.to_owned(), value);
+        let error = serde_json::from_value::<GenericCurrentSlotManifest>(payload)
+            .expect_err("Rust execution current slots must reject quantum-number fields");
+        assert!(error.to_string().contains("unknown field"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_backend.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_backend.rs
new file mode 100644
index 0000000000..bf6591850b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_backend.rs
@@ -0,0 +1,2519 @@
+// SPDX-License-Identifier: 0BSD
+
+#[cfg(feature = "f64-compiled")]
+use super::PreparedKernelManifest;
+use super::PreparedKernelPackManifest;
+#[cfg(feature = "f64-compiled")]
+use super::evaluator::native_direct::LoadedNativeDirectExecutor;
+use super::evaluator::recurrence_closure_direct::execute_closure_reduce_rows;
+use super::evaluator::recurrence_intrinsic_direct::{
+    FEYNMAN_VECTOR_PROPAGATOR_TEMPLATE, LoadedRecurrenceIntrinsicDirectExecutor,
+    RecurrenceIntrinsicScale, WEYL_PROPAGATOR_NEGATIVE_TEMPLATE, WEYL_PROPAGATOR_POSITIVE_TEMPLATE,
+    execute_identity_finalization_rows,
+};
+use super::evaluator::recurrence_source_direct::{
+    DirectSourceDispatchDomainSpec, LoadedDirectSourceExecutor,
+};
+#[cfg(feature = "f64-symjit")]
+use super::evaluator::symjit_direct::{
+    LoadedSymjitDirectExecutor, SymjitDirectParameterBinding, SymjitDirectPlaneProjection,
+    SymjitDirectScalarProjection,
+};
+#[cfg(feature = "f64-symjit")]
+use super::recurrence_process_pack::ProcessJitExecutor;
+#[cfg(feature = "f64-compiled")]
+use super::recurrence_process_pack::ProcessNativeExecutor;
+use super::recurrence_process_pack::{
+    ProcessDirectExecutorBinding, ProcessDirectExecutorDescriptor, ProcessDirectExecutorPack,
+    ProcessIntrinsicExecutor,
+};
+#[cfg(feature = "on-the-fly-test-support")]
+use crate::VerifiedArtifact;
+use crate::artifact::EvaluatorPayloadStore;
+use crate::recurrence::direct_backend::{
+    DirectContributionExecutionMetadata, DirectContributionFanoutExecutorHandle,
+    DirectExecutorCatalog, DirectExecutorHandle, DirectInteractionExecutorCapability,
+    DirectUnionSourceDispatchHandle,
+};
+use crate::recurrence::on_the_fly::{
+    OnTheFlyBoundUnionSourceProgram, OnTheFlyExecutorKeyV1, OnTheFlyPreparedExecutorResolver,
+    OnTheFlyProcessSeedV1, OnTheFlySelectedQueryTraceV1, OnTheFlyStructuralTraceV1,
+    OnTheFlyUnionSourceBindingView, ResolvedOnTheFlyExecutor,
+    authenticated_prepared_executor_binding,
+};
+use crate::recurrence::template::ValidatedRecurrenceTemplateInput;
+use crate::recurrence::{
+    DIRECT_NONE_U32, DirectExecutorRole, DirectRecurrencePlan, PreparedDirectExecutorBinding,
+    PreparedDirectExecutorCatalog, RecurrenceStrategy, SemanticDigest,
+};
+use crate::{RusticolError, RusticolResult};
+#[cfg(feature = "f64-symjit")]
+use sha2::{Digest, Sha256};
+use std::collections::BTreeMap;
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+use std::collections::BTreeSet;
+#[cfg(feature = "on-the-fly-test-support")]
+use std::path::Path;
+#[cfg(feature = "f64-symjit")]
+use std::path::PathBuf;
+use std::rc::Rc;
+
+#[cfg(feature = "f64-symjit")]
+use super::eager_manifest::RecurrenceDirectPlaneProjectionManifest;
+use super::eager_manifest::{
+    RecurrenceDirectParameterBindingManifest, RecurrenceDirectScalarProjectionManifest,
+    RecurrenceDirectTemplateManifest,
+};
+
+/// Authenticated identity of one loaded Direct-Arena recurrence executor catalog.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct NativeRecurrenceDirectBackendSummary {
+    pub(super) prepared_kernel_pack_digest: String,
+    pub(super) direct_template_catalog_digest: String,
+    pub(super) backend: String,
+    pub(super) target_triple: String,
+    pub(super) target_portable: bool,
+    pub(super) executor_count: usize,
+}
+
+/// Context owners backing a loaded Direct-Arena executor catalog.
+///
+/// Handles stored in `catalog` address immutable heap allocations owned by
+/// `source`, `symjit`, and `native`. Those owners therefore must remain alive
+/// for every direct runtime call.
+pub(super) struct NativeRecurrenceDirectExecutorBackend {
+    catalog: DirectExecutorCatalog,
+    owners: NativeRecurrenceDirectExecutorOwners,
+}
+
+/// Model-level ownership of one authenticated prepared-executor catalog.
+///
+/// Source executors are deliberately absent: their contexts contain crossed
+/// source domains and therefore belong to a process/lane binding.  Every
+/// other handle addresses immutable contexts owned by this pool and can be
+/// shared by independent selector-local traces without constructing a direct
+/// recurrence plan.
+pub(super) struct NativeRecurrencePreparedExecutorPool {
+    handles: Box<[Option<DirectExecutorHandle>]>,
+    bindings: BTreeMap<(DirectExecutorRole, u32), NativePreparedExecutorBinding>,
+    executor_roles: Box<[Option<DirectExecutorRole>]>,
+    contribution_metadata: Box<[Option<DirectContributionExecutionMetadata>]>,
+    contribution_fanout: Box<[Option<DirectContributionFanoutExecutorHandle>]>,
+    packed_singleton_capabilities: Box<[bool]>,
+    identity_finalizer_id: Option<u32>,
+    direct_template_catalog_digest: SemanticDigest,
+    recurrence_template_catalog_digest: SemanticDigest,
+    compiled_model_digest: SemanticDigest,
+    prepared_kernel_pack_digest: SemanticDigest,
+    _intrinsics: Vec<LoadedRecurrenceIntrinsicDirectExecutor>,
+    #[cfg(feature = "f64-symjit")]
+    _symjit: Vec<LoadedSymjitDirectExecutor>,
+    #[cfg(feature = "f64-compiled")]
+    _native: Vec<LoadedNativeDirectExecutor>,
+    summary: NativeRecurrenceDirectBackendSummary,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct NativePreparedExecutorBinding {
+    executor_id: u32,
+    parent_permutation: [u8; 2],
+}
+
+/// Process/lane-owned crossed-source dispatch binding.
+///
+/// This value must outlive every source handle obtained from it and must be
+/// dropped before the model-level prepared pool during lane teardown.
+pub(super) struct OnTheFlySourceDomainBinding {
+    source: Option<LoadedDirectSourceExecutor>,
+}
+
+impl OnTheFlySourceDomainBinding {
+    /// Bind source domains owned by a concrete process plan.
+    ///
+    /// All-flow plans execute source rows through the union-source dispatcher,
+    /// so their sparse process pack intentionally has no Source descriptor.
+    /// The plan-owned source rows, rather than the descriptor catalog, are the
+    /// authoritative signal that this binding is required.
+    pub(super) fn load_for_process_plan(
+        plan: &DirectRecurrencePlan,
+        source_domains: Vec<DirectSourceDispatchDomainSpec>,
+    ) -> RusticolResult<Self> {
+        if plan.sources().is_empty() {
+            return Err(RusticolError::integrity(
+                "process recurrence plan has no source rows",
+            ));
+        }
+        Ok(Self {
+            source: Some(LoadedDirectSourceExecutor::load(source_domains)?),
+        })
+    }
+}
+
+/// Owning semantic resolver used by the private on-the-fly interpreter.
+///
+/// The copied direct handles address heap-stable contexts owned by `sources`
+/// and `pool`. Declaration order is intentional: resolved handles disappear
+/// first, then process-bound source contexts, then the model-level pool.
+pub(super) struct NativeOnTheFlyPreparedExecutorResolver {
+    resolved: BTreeMap<OnTheFlyExecutorKeyV1, ResolvedOnTheFlyExecutor>,
+    pending_resolved: Option<BTreeMap<OnTheFlyExecutorKeyV1, ResolvedOnTheFlyExecutor>>,
+    sources: OnTheFlySourceDomainBinding,
+    pool: Rc<NativeRecurrencePreparedExecutorPool>,
+}
+
+impl NativeOnTheFlyPreparedExecutorResolver {
+    fn effective_resolved(&self) -> &BTreeMap<OnTheFlyExecutorKeyV1, ResolvedOnTheFlyExecutor> {
+        self.pending_resolved.as_ref().unwrap_or(&self.resolved)
+    }
+
+    pub(super) fn semantic_executor_binding_count(&self) -> RusticolResult<u32> {
+        u32::try_from(self.effective_resolved().len()).map_err(|_| {
+            RusticolError::integrity("on-the-fly semantic executor binding count exceeds u32")
+        })
+    }
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+impl NativeOnTheFlyPreparedExecutorResolver {
+    pub(super) fn distinct_prepared_executor_count(&self) -> RusticolResult<u32> {
+        let direct_executor_ids = self
+            .effective_resolved()
+            .values()
+            .map(|resolved| resolved.direct_executor_id)
+            .collect::<BTreeSet<_>>();
+        u32::try_from(direct_executor_ids.len())
+            .map_err(|_| RusticolError::integrity("on-the-fly prepared executor count exceeds u32"))
+    }
+}
+
+/// Immutable context ownership retained beside the native recurrence scheduler.
+pub(super) struct NativeRecurrenceDirectExecutorOwners {
+    // Field order documents the required destruction order. Rust drops fields
+    // in declaration order: process-bound source contexts before model pool.
+    source_binding: OnTheFlySourceDomainBinding,
+    pool: Rc<NativeRecurrencePreparedExecutorPool>,
+}
+
+impl NativeRecurrenceDirectExecutorBackend {
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    pub(super) fn load_from_process_pack(
+        pack: &ProcessDirectExecutorPack,
+        payloads: &EvaluatorPayloadStore,
+        plan: &DirectRecurrencePlan,
+        source_domains: Vec<DirectSourceDispatchDomainSpec>,
+    ) -> RusticolResult<Self> {
+        let pool = NativeRecurrencePreparedExecutorPool::load_for_direct_plan_from_process_pack(
+            pack, payloads, plan,
+        )?;
+        let source_binding =
+            OnTheFlySourceDomainBinding::load_for_process_plan(plan, source_domains)?;
+        let pool = Rc::new(pool);
+        let catalog = pool.bind_direct_plan(plan, &source_binding)?;
+        Ok(Self {
+            catalog,
+            owners: NativeRecurrenceDirectExecutorOwners {
+                source_binding,
+                pool,
+            },
+        })
+    }
+
+    /// Load Direct-Arena executors from a verified artifact payload store.
+    ///
+    /// `source_domains` is derived from the process runtime metadata. Its
+    /// indices must match `DirectSourceRow::source_template_or_dispatch_domain`.
+    #[cfg(feature = "on-the-fly-test-support")]
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn load_from_verified_artifact(
+        pack: &mut PreparedKernelPackManifest,
+        artifact: &VerifiedArtifact,
+        payload_root: impl AsRef<Path>,
+        plan: &DirectRecurrencePlan,
+        expected_prepared_pack_digest: &str,
+        expected_catalog_digest: &str,
+        source_domains: Vec<DirectSourceDispatchDomainSpec>,
+    ) -> RusticolResult<Self> {
+        let payloads = artifact.evaluator_payload_store(payload_root.as_ref())?;
+        Self::load_from_store(
+            pack,
+            &payloads,
+            plan,
+            expected_prepared_pack_digest,
+            expected_catalog_digest,
+            source_domains,
+        )
+    }
+
+    #[cfg(feature = "on-the-fly-test-support")]
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn load_from_store(
+        pack: &mut PreparedKernelPackManifest,
+        payloads: &EvaluatorPayloadStore,
+        plan: &DirectRecurrencePlan,
+        expected_prepared_pack_digest: &str,
+        expected_catalog_digest: &str,
+        source_domains: Vec<DirectSourceDispatchDomainSpec>,
+    ) -> RusticolResult<Self> {
+        let pool = NativeRecurrencePreparedExecutorPool::load_for_direct_plan_from_validated_pack(
+            pack,
+            payloads,
+            plan,
+            expected_prepared_pack_digest,
+            expected_catalog_digest,
+        )?;
+        let pool = Rc::new(pool);
+        let source_binding = pool.bind_source_domains(source_domains)?;
+        let catalog = pool.bind_direct_plan(plan, &source_binding)?;
+        Ok(Self {
+            catalog,
+            owners: NativeRecurrenceDirectExecutorOwners {
+                source_binding,
+                pool,
+            },
+        })
+    }
+
+    /// Split the lightweight handle catalog from the contexts that it addresses.
+    ///
+    /// The caller must retain `owners` for at least as long as `catalog` can be
+    /// invoked. Contexts are boxed, so moving either returned value cannot
+    /// invalidate a handle.
+    pub(super) fn into_parts(
+        self,
+    ) -> (DirectExecutorCatalog, NativeRecurrenceDirectExecutorOwners) {
+        (self.catalog, self.owners)
+    }
+}
+
+impl NativeRecurrencePreparedExecutorPool {
+    pub(super) fn validate_model_identities(
+        &self,
+        compiled_model_digest: &str,
+        recurrence_template_catalog_digest: &str,
+        prepared_kernel_pack_digest: &str,
+        direct_template_catalog_digest: &str,
+    ) -> RusticolResult<()> {
+        if self.compiled_model_digest.to_string() != compiled_model_digest
+            || self.recurrence_template_catalog_digest.to_string()
+                != recurrence_template_catalog_digest
+            || self.prepared_kernel_pack_digest.to_string() != prepared_kernel_pack_digest
+            || self.direct_template_catalog_digest.to_string() != direct_template_catalog_digest
+        {
+            return Err(RusticolError::integrity(
+                "complete prepared executor pool disagrees with recurrence manifest identities",
+            ));
+        }
+        Ok(())
+    }
+
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    pub(super) fn load_for_direct_plan_from_process_pack(
+        pack: &ProcessDirectExecutorPack,
+        payloads: &EvaluatorPayloadStore,
+        plan: &DirectRecurrencePlan,
+    ) -> RusticolResult<Self> {
+        #[cfg(not(any(feature = "f64-symjit", feature = "f64-compiled")))]
+        let _ = payloads;
+        if pack.catalog_executor_count != plan.direct_executor_count()
+            || pack.identities.direct_template_catalog_digest
+                != plan.direct_template_catalog_digest()
+        {
+            return Err(RusticolError::integrity(
+                "process Direct-Arena pack does not belong to the recurrence plan",
+            ));
+        }
+        let executor_count = usize::try_from(pack.catalog_executor_count).map_err(|_| {
+            RusticolError::artifact("process Direct-Arena executor count exceeds usize")
+        })?;
+        let mut intrinsics = Vec::new();
+        #[cfg(feature = "f64-symjit")]
+        let mut symjit = Vec::new();
+        #[cfg(feature = "f64-compiled")]
+        let mut native = Vec::new();
+        let mut handles = vec![None; executor_count];
+        let mut executor_roles = vec![None; executor_count];
+        let mut contribution_metadata = vec![None; executor_count];
+        let mut contribution_fanout = vec![None; executor_count];
+        let mut packed_singleton_capabilities = vec![false; executor_count];
+        for descriptor in &pack.descriptors {
+            let executor_id = usize::try_from(descriptor.direct_executor_id).map_err(|_| {
+                RusticolError::artifact("process Direct-Arena executor ID exceeds usize")
+            })?;
+            let role_slot = executor_roles.get_mut(executor_id).ok_or_else(|| {
+                RusticolError::integrity(
+                    "process Direct-Arena executor is outside the complete catalog",
+                )
+            })?;
+            if role_slot.replace(descriptor.role).is_some() {
+                return Err(RusticolError::integrity(
+                    "process Direct-Arena pack repeats an executor",
+                ));
+            }
+            let mut fanout = None;
+            let (handle, packed_singleton_capable) = match &descriptor.binding {
+                ProcessDirectExecutorBinding::Source => (None, false),
+                ProcessDirectExecutorBinding::Intrinsic(intrinsic) => {
+                    if descriptor.role == DirectExecutorRole::Contribution {
+                        let loaded = load_process_contribution_intrinsic(intrinsic)?;
+                        let handle = loaded.handle();
+                        fanout = loaded.contribution_fanout_handle();
+                        intrinsics.push(loaded);
+                        (Some(handle), true)
+                    } else {
+                        (
+                            Some(load_process_intrinsic_handle(
+                                descriptor.role,
+                                &intrinsic.runtime_template,
+                            )?),
+                            true,
+                        )
+                    }
+                }
+                ProcessDirectExecutorBinding::Jit(jit) => {
+                    #[cfg(feature = "f64-symjit")]
+                    {
+                        let loaded = load_process_jit_executor(jit, descriptor.role, payloads)?;
+                        let handle = loaded.handle();
+                        symjit.push(loaded);
+                        (Some(handle), true)
+                    }
+                    #[cfg(not(feature = "f64-symjit"))]
+                    {
+                        let _ = jit;
+                        return Err(RusticolError::compatibility(
+                            "process Direct-Arena JIT execution requires f64-symjit",
+                        ));
+                    }
+                }
+                ProcessDirectExecutorBinding::Native(native_descriptor) => {
+                    #[cfg(feature = "f64-compiled")]
+                    {
+                        let loaded = load_process_native_executor(
+                            native_descriptor,
+                            descriptor.role,
+                            payloads,
+                        )?;
+                        let handle = loaded.handle();
+                        native.push(loaded);
+                        (Some(handle), true)
+                    }
+                    #[cfg(not(feature = "f64-compiled"))]
+                    {
+                        let _ = native_descriptor;
+                        return Err(RusticolError::compatibility(
+                            "process Direct-Arena native execution requires f64-compiled",
+                        ));
+                    }
+                }
+            };
+            if handle.is_some_and(|handle| handle.role() != descriptor.role) {
+                return Err(RusticolError::integrity(format!(
+                    "process Direct-Arena executor {} resolved with the wrong role",
+                    descriptor.direct_executor_id
+                )));
+            }
+            handles[executor_id] = handle;
+            contribution_fanout[executor_id] = fanout;
+            packed_singleton_capabilities[executor_id] = packed_singleton_capable;
+            contribution_metadata[executor_id] =
+                process_contribution_execution_metadata(descriptor)?;
+        }
+        let summary = NativeRecurrenceDirectBackendSummary {
+            prepared_kernel_pack_digest: pack.identities.prepared_kernel_pack_digest.to_string(),
+            direct_template_catalog_digest: pack
+                .identities
+                .direct_template_catalog_digest
+                .to_string(),
+            backend: pack.target.backend.as_str().to_owned(),
+            target_triple: pack.target.target_triple.clone(),
+            target_portable: pack.target.portable,
+            executor_count,
+        };
+        Ok(Self {
+            handles: handles.into_boxed_slice(),
+            bindings: BTreeMap::new(),
+            executor_roles: executor_roles.into_boxed_slice(),
+            contribution_metadata: contribution_metadata.into_boxed_slice(),
+            contribution_fanout: contribution_fanout.into_boxed_slice(),
+            packed_singleton_capabilities: packed_singleton_capabilities.into_boxed_slice(),
+            identity_finalizer_id: None,
+            direct_template_catalog_digest: pack.identities.direct_template_catalog_digest,
+            recurrence_template_catalog_digest: pack.identities.recurrence_template_catalog_digest,
+            compiled_model_digest: pack.identities.compiled_model_digest,
+            prepared_kernel_pack_digest: pack.identities.prepared_kernel_pack_digest,
+            _intrinsics: intrinsics,
+            #[cfg(feature = "f64-symjit")]
+            _symjit: symjit,
+            #[cfg(feature = "f64-compiled")]
+            _native: native,
+            summary,
+        })
+    }
+
+    /// Load and authenticate model-level prepared executors without binding a
+    /// process source domain or a recurrence plan.
+    #[cfg(feature = "on-the-fly-test-support")]
+    pub(super) fn load_from_store(
+        manifest_json: &[u8],
+        payloads: &EvaluatorPayloadStore,
+        expected_prepared_pack_digest: &str,
+        expected_catalog_digest: &str,
+    ) -> RusticolResult<Self> {
+        #[cfg(not(any(feature = "f64-symjit", feature = "f64-compiled")))]
+        let _ = payloads;
+        let mut pack: PreparedKernelPackManifest =
+            serde_json::from_slice(manifest_json).map_err(|error| {
+                RusticolError::serialization(format!(
+                    "could not parse prepared Direct-Arena kernel pack: {error}"
+                ))
+            })?;
+        pack.validate()?;
+        Self::load_without_plan_from_validated_pack(
+            &mut pack,
+            payloads,
+            expected_prepared_pack_digest,
+            expected_catalog_digest,
+        )
+    }
+
+    /// Load a model-level pool from a pack already validated at the artifact boundary.
+    pub(super) fn load_without_plan_from_validated_pack(
+        pack: &mut PreparedKernelPackManifest,
+        payloads: &EvaluatorPayloadStore,
+        expected_prepared_pack_digest: &str,
+        expected_catalog_digest: &str,
+    ) -> RusticolResult<Self> {
+        Self::load_from_validated_pack(
+            pack,
+            payloads,
+            None,
+            expected_prepared_pack_digest,
+            expected_catalog_digest,
+        )
+    }
+
+    /// Load only the executor contexts referenced by one authenticated direct
+    /// plan while retaining the complete prepared-catalog identity and index
+    /// domain. The caller has already validated `pack` at the artifact boundary.
+    #[cfg(feature = "on-the-fly-test-support")]
+    fn load_for_direct_plan_from_validated_pack(
+        pack: &mut PreparedKernelPackManifest,
+        payloads: &EvaluatorPayloadStore,
+        plan: &DirectRecurrencePlan,
+        expected_prepared_pack_digest: &str,
+        expected_catalog_digest: &str,
+    ) -> RusticolResult<Self> {
+        Self::load_from_validated_pack(
+            pack,
+            payloads,
+            Some(plan),
+            expected_prepared_pack_digest,
+            expected_catalog_digest,
+        )
+    }
+
+    fn load_from_validated_pack(
+        pack: &mut PreparedKernelPackManifest,
+        payloads: &EvaluatorPayloadStore,
+        plan: Option<&DirectRecurrencePlan>,
+        expected_prepared_pack_digest: &str,
+        expected_catalog_digest: &str,
+    ) -> RusticolResult<Self> {
+        #[cfg(not(any(feature = "f64-symjit", feature = "f64-compiled")))]
+        let _ = payloads;
+        let direct = pack.take_recurrence_direct_template_catalog(
+            expected_prepared_pack_digest,
+            expected_catalog_digest,
+        )?;
+        let digest = semantic_digest(&direct.catalog_digest, "Direct-Arena catalog")?;
+        if plan.is_some_and(|plan| digest != plan.direct_template_catalog_digest()) {
+            return Err(RusticolError::integrity(
+                "prepared Direct-Arena catalog digest does not match the recurrence plan",
+            ));
+        }
+        let required_executors = plan
+            .map(|plan| required_direct_executor_mask(plan, direct.templates.len()))
+            .transpose()?;
+        let mut intrinsics = Vec::new();
+        #[cfg(feature = "f64-symjit")]
+        let mut symjit = Vec::new();
+        #[cfg(feature = "f64-compiled")]
+        let mut native = Vec::new();
+        let mut handles = Vec::with_capacity(direct.templates.len());
+        let mut bindings = BTreeMap::new();
+        let mut executor_roles = Vec::with_capacity(direct.templates.len());
+        let mut contribution_metadata = Vec::with_capacity(direct.templates.len());
+        let mut contribution_fanout = Vec::with_capacity(direct.templates.len());
+        let mut packed_singleton_capabilities = Vec::with_capacity(direct.templates.len());
+        let mut identity_finalizer_id = None;
+        for template in &direct.templates {
+            let mut fanout = None;
+            let mut packed_singleton_capable = false;
+            let role = direct_role(&template.role)?;
+            let parent_permutation: [u8; 2] = template
+                .payload_binding
+                .contribution_parent_permutation
+                .as_slice()
+                .try_into()
+                .map_err(|_| {
+                    RusticolError::integrity(
+                        "prepared Direct-Arena executor has an invalid parent permutation",
+                    )
+                })?;
+            if bindings
+                .insert(
+                    (role, template.evaluator_binding_id),
+                    NativePreparedExecutorBinding {
+                        executor_id: template.direct_executor_id,
+                        parent_permutation,
+                    },
+                )
+                .is_some()
+            {
+                return Err(RusticolError::integrity(
+                    "prepared Direct-Arena catalog repeats a semantic executor binding",
+                ));
+            }
+            if template.payload_binding.kind == "rusticol-intrinsic"
+                && template.payload_binding.runtime_template.as_deref()
+                    == Some("rusticol.identity-finalize-in-place.v1")
+                && identity_finalizer_id
+                    .replace(template.direct_executor_id)
+                    .is_some()
+            {
+                return Err(RusticolError::integrity(
+                    "prepared Direct-Arena catalog repeats the identity finalizer",
+                ));
+            }
+            let handle = instantiate_selected_executor(
+                required_executors.as_deref(),
+                template.direct_executor_id,
+                || {
+                    let handle = match template.payload_binding.kind.as_str() {
+                        "rusticol-intrinsic" if template.role == "contribution" => {
+                            let loaded = load_contribution_intrinsic(template)?;
+                            let handle = loaded.handle();
+                            fanout = loaded.contribution_fanout_handle();
+                            packed_singleton_capable = true;
+                            intrinsics.push(loaded);
+                            Some(handle)
+                        }
+                        "rusticol-intrinsic" if template.role == "source" => None,
+                        "rusticol-intrinsic" => {
+                            let handle = load_intrinsic_handle(template)?;
+                            packed_singleton_capable = true;
+                            Some(handle)
+                        }
+                        "prepared-direct-call" => match template.backend.as_str() {
+                            "jit" => {
+                                #[cfg(feature = "f64-symjit")]
+                                {
+                                    let loaded = load_symjit_executor(template, pack, payloads)?;
+                                    let handle = loaded.handle();
+                                    packed_singleton_capable = true;
+                                    symjit.push(loaded);
+                                    Some(handle)
+                                }
+                                #[cfg(not(feature = "f64-symjit"))]
+                                {
+                                    return Err(RusticolError::compatibility(
+                                        "Direct-Arena JIT recurrence execution requires the f64-symjit feature",
+                                    ));
+                                }
+                            }
+                            "cpp" | "asm" => {
+                                #[cfg(feature = "f64-compiled")]
+                                {
+                                    let loaded = load_native_executor(template, pack, payloads)?;
+                                    let handle = loaded.handle();
+                                    packed_singleton_capable = true;
+                                    native.push(loaded);
+                                    Some(handle)
+                                }
+                                #[cfg(not(feature = "f64-compiled"))]
+                                {
+                                    return Err(RusticolError::compatibility(
+                                        "Direct-Arena C++/ASM recurrence execution requires the f64-compiled feature",
+                                    ));
+                                }
+                            }
+                            other => {
+                                return Err(RusticolError::compatibility(format!(
+                                    "unsupported Direct-Arena prepared-call backend {other:?}"
+                                )));
+                            }
+                        },
+                        other => {
+                            return Err(RusticolError::compatibility(format!(
+                                "unsupported Direct-Arena executor binding {other:?}"
+                            )));
+                        }
+                    };
+                    Ok(handle)
+                },
+            )?;
+            if let Some(handle) = handle
+                && handle.role() != role
+            {
+                return Err(RusticolError::integrity(format!(
+                    "Direct-Arena executor {} resolved with the wrong role",
+                    template.direct_executor_id
+                )));
+            }
+            handles.push(handle);
+            contribution_fanout.push(fanout);
+            packed_singleton_capabilities.push(packed_singleton_capable);
+            executor_roles.push(Some(role));
+            contribution_metadata.push(if role == DirectExecutorRole::Contribution {
+                Some(DirectContributionExecutionMetadata::new(
+                    template.destination_component_count,
+                    !template
+                        .payload_binding
+                        .exact_factor_scalar_slots
+                        .is_empty(),
+                )?)
+            } else {
+                None
+            });
+        }
+        let recurrence_template_catalog_digest = semantic_digest(
+            &direct.recurrence_template_catalog_digest,
+            "recurrence template catalog",
+        )?;
+        let compiled_model_digest =
+            semantic_digest(&direct.compiled_model_digest, "compiled model")?;
+        let prepared_kernel_pack_digest =
+            semantic_digest(&direct.prepared_kernel_pack_digest, "prepared kernel pack")?;
+        let summary = NativeRecurrenceDirectBackendSummary {
+            prepared_kernel_pack_digest: direct.prepared_kernel_pack_digest.clone(),
+            direct_template_catalog_digest: direct.catalog_digest.clone(),
+            backend: direct.backend.clone(),
+            target_triple: direct.target_triple.clone(),
+            target_portable: direct.portable,
+            executor_count: direct.templates.len(),
+        };
+        Ok(Self {
+            handles: handles.into_boxed_slice(),
+            bindings,
+            executor_roles: executor_roles.into_boxed_slice(),
+            contribution_metadata: contribution_metadata.into_boxed_slice(),
+            contribution_fanout: contribution_fanout.into_boxed_slice(),
+            packed_singleton_capabilities: packed_singleton_capabilities.into_boxed_slice(),
+            identity_finalizer_id,
+            direct_template_catalog_digest: digest,
+            recurrence_template_catalog_digest,
+            compiled_model_digest,
+            prepared_kernel_pack_digest,
+            _intrinsics: intrinsics,
+            #[cfg(feature = "f64-symjit")]
+            _symjit: symjit,
+            #[cfg(feature = "f64-compiled")]
+            _native: native,
+            summary,
+        })
+    }
+
+    pub(super) fn bind_source_domains(
+        &self,
+        source_domains: Vec<DirectSourceDispatchDomainSpec>,
+    ) -> RusticolResult<OnTheFlySourceDomainBinding> {
+        let source_needed = self
+            .executor_roles
+            .contains(&Some(DirectExecutorRole::Source));
+        let source = if source_needed {
+            Some(LoadedDirectSourceExecutor::load(source_domains)?)
+        } else {
+            if !source_domains.is_empty() {
+                return Err(RusticolError::integrity(
+                    "source domains were supplied to a prepared catalog without source executors",
+                ));
+            }
+            None
+        };
+        Ok(OnTheFlySourceDomainBinding { source })
+    }
+
+    /// Re-express the already authenticated prepared-pack mappings through
+    /// the shared semantic resolver used by selector-local lowering.  This is
+    /// a compact model-level catalog, not a process recurrence plan.
+    pub(super) fn prepared_direct_catalog(&self) -> RusticolResult<PreparedDirectExecutorCatalog> {
+        let mut bindings = self
+            .bindings
+            .iter()
+            .map(|(&(role, evaluator_binding_id), binding)| {
+                PreparedDirectExecutorBinding::evaluator_with_parent_permutation(
+                    role,
+                    evaluator_binding_id,
+                    binding.executor_id,
+                    binding.parent_permutation,
+                )
+            })
+            .collect::<Vec<_>>();
+        if let Some(executor_id) = self.identity_finalizer_id {
+            bindings.push(PreparedDirectExecutorBinding::identity_finalizer(
+                executor_id,
+            ));
+        }
+        PreparedDirectExecutorCatalog::new(self.direct_template_catalog_digest, bindings)
+    }
+
+    pub(super) fn into_on_the_fly_resolver(
+        self,
+        sources: OnTheFlySourceDomainBinding,
+    ) -> NativeOnTheFlyPreparedExecutorResolver {
+        Rc::new(self).into_shared_on_the_fly_resolver(sources)
+    }
+
+    pub(super) fn into_shared_on_the_fly_resolver(
+        self: Rc<Self>,
+        sources: OnTheFlySourceDomainBinding,
+    ) -> NativeOnTheFlyPreparedExecutorResolver {
+        NativeOnTheFlyPreparedExecutorResolver {
+            resolved: BTreeMap::new(),
+            pending_resolved: None,
+            sources,
+            pool: self,
+        }
+    }
+
+    fn resolve_handle(
+        &self,
+        sources: &OnTheFlySourceDomainBinding,
+        role: DirectExecutorRole,
+        evaluator_binding_id: u32,
+    ) -> RusticolResult<(u32, DirectExecutorHandle, [u8; 2])> {
+        let binding = self
+            .bindings
+            .get(&(role, evaluator_binding_id))
+            .copied()
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "prepared recurrence catalog has no {role:?} semantic binding {evaluator_binding_id}"
+                ))
+            })?;
+        let handle = match role {
+            DirectExecutorRole::Source => sources.source_handle()?,
+            _ => self
+                .handles
+                .get(binding.executor_id as usize)
+                .and_then(|handle| *handle)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "prepared recurrence executor {} is not loaded",
+                        binding.executor_id,
+                    ))
+                })?,
+        };
+        if handle.role() != role {
+            return Err(RusticolError::integrity(format!(
+                "prepared recurrence executor {} has role {:?}, expected {role:?}",
+                binding.executor_id,
+                handle.role()
+            )));
+        }
+        Ok((binding.executor_id, handle, binding.parent_permutation))
+    }
+
+    fn resolve_direct_executor_id(
+        &self,
+        sources: &OnTheFlySourceDomainBinding,
+        direct_executor_id: u32,
+        role: DirectExecutorRole,
+    ) -> RusticolResult<ResolvedOnTheFlyExecutor> {
+        let expected_role = self
+            .executor_roles
+            .get(direct_executor_id as usize)
+            .copied()
+            .flatten()
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "persisted direct executor {direct_executor_id} has no authenticated role"
+                ))
+            })?;
+        if expected_role != role {
+            return Err(RusticolError::integrity(format!(
+                "persisted direct executor {direct_executor_id} has role {expected_role:?}, expected {role:?}"
+            )));
+        }
+        let handle = if role == DirectExecutorRole::Source {
+            sources.source_handle()?
+        } else {
+            self.handles
+                .get(direct_executor_id as usize)
+                .and_then(|handle| *handle)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "persisted direct executor {direct_executor_id} is not loaded"
+                    ))
+                })?
+        };
+        Ok(ResolvedOnTheFlyExecutor {
+            direct_executor_id,
+            handle,
+            // Persisted direct rows already carry the lowering-time parent
+            // permutation; no query-local remap remains at this boundary.
+            parent_permutation: [0, 1],
+            packed_singleton_capable: self.packed_singleton_capability(
+                sources,
+                direct_executor_id,
+                handle,
+            )?,
+            interaction_capability: self.interaction_capability(direct_executor_id, handle)?,
+        })
+    }
+
+    fn identity_finalizer_handle(&self) -> RusticolResult<(u32, DirectExecutorHandle)> {
+        let executor_id = self.identity_finalizer_id.ok_or_else(|| {
+            RusticolError::integrity("prepared recurrence catalog has no identity finalizer")
+        })?;
+        let handle = self
+            .handles
+            .get(executor_id as usize)
+            .and_then(|handle| *handle)
+            .ok_or_else(|| RusticolError::integrity("identity finalizer is not loaded"))?;
+        Ok((executor_id, handle))
+    }
+
+    fn interaction_capability(
+        &self,
+        executor_id: u32,
+        handle: DirectExecutorHandle,
+    ) -> RusticolResult<Option<DirectInteractionExecutorCapability>> {
+        if handle.role() != DirectExecutorRole::Contribution {
+            return Ok(None);
+        }
+        let metadata = self
+            .contribution_metadata
+            .get(executor_id as usize)
+            .and_then(|metadata| *metadata)
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "prepared contribution executor {executor_id} has no authenticated execution metadata"
+                ))
+            })?;
+        self.contribution_fanout
+            .get(executor_id as usize)
+            .and_then(|fanout| *fanout)
+            .map(|fanout| DirectInteractionExecutorCapability::new(handle, metadata, fanout))
+            .transpose()
+    }
+
+    fn packed_singleton_capability(
+        &self,
+        sources: &OnTheFlySourceDomainBinding,
+        executor_id: u32,
+        handle: DirectExecutorHandle,
+    ) -> RusticolResult<bool> {
+        let role = self
+            .executor_roles
+            .get(executor_id as usize)
+            .copied()
+            .flatten()
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "prepared executor {executor_id} has no authenticated role"
+                ))
+            })?;
+        if handle.role() != role {
+            return Err(RusticolError::integrity(format!(
+                "prepared executor {executor_id} has role {:?}, expected {role:?}",
+                handle.role()
+            )));
+        }
+        if role == DirectExecutorRole::Source {
+            return Ok(sources.packed_singleton_capability());
+        }
+        if self
+            .handles
+            .get(executor_id as usize)
+            .and_then(|handle| *handle)
+            .is_none()
+        {
+            return Ok(false);
+        }
+        Ok(self
+            .packed_singleton_capabilities
+            .get(executor_id as usize)
+            .copied()
+            .unwrap_or(false))
+    }
+
+    fn bind_direct_plan(
+        &self,
+        plan: &DirectRecurrencePlan,
+        sources: &OnTheFlySourceDomainBinding,
+    ) -> RusticolResult<DirectExecutorCatalog> {
+        if self.direct_template_catalog_digest != plan.direct_template_catalog_digest() {
+            return Err(RusticolError::integrity(
+                "prepared Direct-Arena catalog digest does not match the recurrence plan",
+            ));
+        }
+        let required_executors = required_direct_executor_mask(plan, self.handles.len())?;
+        let mut handles = Vec::with_capacity(self.handles.len());
+        let source_capable = sources.packed_singleton_capability();
+        let all_required_executors_are_stride_generic = required_executors.iter().any(|x| *x)
+            && required_executors
+                .iter()
+                .copied()
+                .enumerate()
+                .all(|(id, required)| {
+                    !required
+                        || match self.executor_roles.get(id).copied().flatten() {
+                            Some(DirectExecutorRole::Source) => source_capable,
+                            Some(_) => self
+                                .packed_singleton_capabilities
+                                .get(id)
+                                .copied()
+                                .unwrap_or(false),
+                            None => false,
+                        }
+                })
+            && (plan.strategy() != RecurrenceStrategy::AllFlowUnion || source_capable);
+        for (executor_id, handle) in self.handles.iter().copied().enumerate() {
+            let selected = required_executors[executor_id];
+            let handle = match (handle, selected) {
+                (Some(handle), _) => Some(handle),
+                (None, false) => None,
+                (None, true) => {
+                    let role = self
+                        .executor_roles
+                        .get(executor_id)
+                        .copied()
+                        .flatten()
+                        .ok_or_else(|| {
+                            RusticolError::integrity("prepared executor role is absent")
+                        })?;
+                    if role != DirectExecutorRole::Source {
+                        return Err(RusticolError::integrity(format!(
+                            "referenced prepared non-source executor {executor_id} has no loaded handle"
+                        )));
+                    }
+                    Some(sources.source_handle()?)
+                }
+            };
+            handles.push(handle);
+        }
+        let catalog = DirectExecutorCatalog::new_sparse_with_metadata_and_fanout(
+            plan,
+            self.direct_template_catalog_digest,
+            handles,
+            self.contribution_metadata.to_vec(),
+            self.contribution_fanout.to_vec(),
+        )?;
+        Ok(if all_required_executors_are_stride_generic {
+            catalog.mark_packed_singleton_capable()
+        } else {
+            catalog
+        })
+    }
+}
+
+fn process_contribution_execution_metadata(
+    descriptor: &ProcessDirectExecutorDescriptor,
+) -> RusticolResult<Option<DirectContributionExecutionMetadata>> {
+    if descriptor.role != DirectExecutorRole::Contribution {
+        return Ok(None);
+    }
+    DirectContributionExecutionMetadata::new(
+        descriptor.destination_component_count,
+        descriptor.uses_exact_factor,
+    )
+    .map(Some)
+}
+
+fn required_direct_executor_mask(
+    plan: &DirectRecurrencePlan,
+    catalog_executor_count: usize,
+) -> RusticolResult<Vec<bool>> {
+    if plan.direct_executor_count() as usize != catalog_executor_count {
+        return Err(RusticolError::integrity(format!(
+            "prepared Direct-Arena catalog has {catalog_executor_count} executors, expected {}",
+            plan.direct_executor_count()
+        )));
+    }
+    let mut required = vec![false; catalog_executor_count];
+    for descriptor in plan.row_groups() {
+        if descriptor.direct_executor_id == DIRECT_NONE_U32 {
+            continue;
+        }
+        let slot = required
+            .get_mut(descriptor.direct_executor_id as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "recurrence row group references absent prepared executor {}",
+                    descriptor.direct_executor_id
+                ))
+            })?;
+        *slot = true;
+    }
+    Ok(required)
+}
+
+fn instantiate_selected_executor<T>(
+    required_executors: Option<&[bool]>,
+    executor_id: u32,
+    instantiate: impl FnOnce() -> RusticolResult<Option<T>>,
+) -> RusticolResult<Option<T>> {
+    let selected = required_executors.map_or(Ok(true), |required| {
+        required.get(executor_id as usize).copied().ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "prepared executor {executor_id} is outside the authenticated catalog"
+            ))
+        })
+    })?;
+    if selected { instantiate() } else { Ok(None) }
+}
+
+impl NativeOnTheFlyPreparedExecutorResolver {
+    pub(super) fn clear_resolved_bindings(&mut self) {
+        self.pending_resolved = None;
+        self.resolved.clear();
+    }
+
+    pub(super) fn discard_pending_resolved_bindings(&mut self) {
+        self.pending_resolved = None;
+    }
+
+    pub(super) fn commit_pending_resolved_bindings(&mut self) -> RusticolResult<()> {
+        let pending = self.pending_resolved.take().ok_or_else(|| {
+            RusticolError::internal("on-the-fly family retention has no pending semantic bindings")
+        })?;
+        self.resolved = pending;
+        Ok(())
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    pub(super) fn bind_on_the_fly_trace(
+        &mut self,
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct: &PreparedDirectExecutorCatalog,
+        seed: &OnTheFlyProcessSeedV1,
+        trace: &mut OnTheFlyStructuralTraceV1,
+    ) -> RusticolResult<()> {
+        self.begin_on_the_fly_family_binding(templates, direct)?;
+        self.extend_on_the_fly_family_binding(templates, direct, seed, std::iter::once(trace))
+    }
+
+    pub(super) fn bind_on_the_fly_family(
+        &mut self,
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct: &PreparedDirectExecutorCatalog,
+        seed: &OnTheFlyProcessSeedV1,
+        selected: &mut [OnTheFlySelectedQueryTraceV1],
+    ) -> RusticolResult<()> {
+        self.begin_on_the_fly_family_binding(templates, direct)?;
+        self.extend_on_the_fly_family_binding(
+            templates,
+            direct,
+            seed,
+            selected.iter_mut().map(|selected| &mut selected.trace),
+        )
+    }
+
+    /// Begin a streamed semantic-binding transaction without disturbing the
+    /// last successfully committed family.
+    pub(super) fn begin_on_the_fly_family_binding(
+        &mut self,
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct: &PreparedDirectExecutorCatalog,
+    ) -> RusticolResult<()> {
+        self.pending_resolved = None;
+        let summary = templates.summary();
+        if summary.catalog_digest != self.pool.recurrence_template_catalog_digest
+            || summary.compiled_model_digest != self.pool.compiled_model_digest
+            || summary.prepared_kernel_pack_digest != self.pool.prepared_kernel_pack_digest
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly recurrence templates do not belong to the loaded prepared pack",
+            ));
+        }
+        if direct.direct_template_catalog_digest() != self.pool.direct_template_catalog_digest {
+            return Err(RusticolError::integrity(
+                "on-the-fly direct-template catalog does not match the loaded prepared pack",
+            ));
+        }
+        self.pending_resolved = Some(BTreeMap::new());
+        Ok(())
+    }
+
+    /// Extend the current streamed transaction by one bounded trace chunk.
+    /// Failure drops only the uncommitted map; the active map remains intact.
+    pub(super) fn extend_on_the_fly_family_binding<'trace>(
+        &mut self,
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct: &PreparedDirectExecutorCatalog,
+        seed: &OnTheFlyProcessSeedV1,
+        traces: impl IntoIterator<Item = &'trace mut OnTheFlyStructuralTraceV1>,
+    ) -> RusticolResult<()> {
+        let mut resolved = self.pending_resolved.take().ok_or_else(|| {
+            RusticolError::internal(
+                "on-the-fly streamed binding extension has no pending transaction",
+            )
+        })?;
+        let authenticate = authenticated_prepared_executor_binding(templates, direct)?;
+        let mut trace_count = 0_u32;
+        for trace in traces {
+            trace_count = trace_count.checked_add(1).ok_or_else(|| {
+                RusticolError::integrity("on-the-fly trace-family count exceeds u32")
+            })?;
+            if seed.template_catalog_digest() != self.pool.recurrence_template_catalog_digest
+                || seed.model_digest() != self.pool.compiled_model_digest
+                || seed.prepared_pack_digest() != self.pool.prepared_kernel_pack_digest
+                || seed.direct_catalog_digest() != self.pool.direct_template_catalog_digest
+                || trace.seed_digest() != seed.semantic_digest()
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly compact process identity does not match the loaded prepared pack",
+                ));
+            }
+            let mut parent_permutations = BTreeMap::new();
+            for key in trace.executor_keys() {
+                let resolved_executor = if let Some(resolved) = resolved.get(&key).copied() {
+                    resolved
+                } else {
+                    let expected = authenticate(key)?;
+                    let (direct_executor_id, handle, parent_permutation) =
+                        if let Some(evaluator_binding_id) = key.evaluator_binding_id() {
+                            self.pool.resolve_handle(
+                                &self.sources,
+                                key.role(),
+                                evaluator_binding_id,
+                            )?
+                        } else {
+                            let (executor_id, handle) = self.pool.identity_finalizer_handle()?;
+                            (executor_id, handle, [0, 1])
+                        };
+                    if direct_executor_id != expected.direct_executor_id
+                        || parent_permutation != expected.parent_permutation
+                    {
+                        return Err(RusticolError::integrity(
+                            "prepared pool and authenticated direct-template mapping disagree",
+                        ));
+                    }
+                    let resolved_executor = ResolvedOnTheFlyExecutor {
+                        direct_executor_id,
+                        handle,
+                        parent_permutation,
+                        packed_singleton_capable: self.pool.packed_singleton_capability(
+                            &self.sources,
+                            direct_executor_id,
+                            handle,
+                        )?,
+                        interaction_capability: self
+                            .pool
+                            .interaction_capability(direct_executor_id, handle)?,
+                    };
+                    resolved.insert(key, resolved_executor);
+                    resolved_executor
+                };
+                parent_permutations.insert(key, resolved_executor.parent_permutation);
+            }
+            trace.bind_prepared_executor_rows(&parent_permutations)?;
+        }
+        if trace_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly prepared executor family is empty",
+            ));
+        }
+        self.pending_resolved = Some(resolved);
+        Ok(())
+    }
+
+    /// Bind saved semantic operations to this runner's own prepared kernels.
+    /// Saved rows already include the authenticated parent permutation; no
+    /// trace or query reconstruction is involved here.
+    pub(super) fn bind_on_the_fly_saved_family(
+        &mut self,
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct: &PreparedDirectExecutorCatalog,
+        keys: impl IntoIterator<Item = OnTheFlyExecutorKeyV1>,
+    ) -> RusticolResult<()> {
+        self.begin_on_the_fly_family_binding(templates, direct)?;
+        let authenticate = authenticated_prepared_executor_binding(templates, direct)?;
+        let mut resolved = BTreeMap::new();
+        for key in keys {
+            if resolved.contains_key(&key) {
+                continue;
+            }
+            let expected = authenticate(key)?;
+            let (direct_executor_id, handle, parent_permutation) =
+                if let Some(binding_id) = key.evaluator_binding_id() {
+                    self.pool
+                        .resolve_handle(&self.sources, key.role(), binding_id)?
+                } else {
+                    let (id, handle) = self.pool.identity_finalizer_handle()?;
+                    (id, handle, [0, 1])
+                };
+            if direct_executor_id != expected.direct_executor_id
+                || parent_permutation != expected.parent_permutation
+            {
+                return Err(RusticolError::integrity(
+                    "saved on-the-fly operation differs from its prepared kernel",
+                ));
+            }
+            resolved.insert(
+                key,
+                ResolvedOnTheFlyExecutor {
+                    direct_executor_id,
+                    handle,
+                    parent_permutation,
+                    packed_singleton_capable: self.pool.packed_singleton_capability(
+                        &self.sources,
+                        direct_executor_id,
+                        handle,
+                    )?,
+                    interaction_capability: self
+                        .pool
+                        .interaction_capability(direct_executor_id, handle)?,
+                },
+            );
+        }
+        self.pending_resolved = Some(resolved);
+        Ok(())
+    }
+}
+
+impl OnTheFlySourceDomainBinding {
+    fn packed_singleton_capability(&self) -> bool {
+        self.source.is_some()
+    }
+
+    fn source_handle(&self) -> RusticolResult<DirectExecutorHandle> {
+        let source = self.source.as_ref().ok_or_else(|| {
+            RusticolError::integrity("on-the-fly source-domain binding is absent")
+        })?;
+        let handle = source.handle();
+        Ok(DirectExecutorHandle::Source {
+            call: handle.call,
+            context: handle.context,
+        })
+    }
+
+    pub(super) fn union_source_dispatch(&self) -> RusticolResult<DirectUnionSourceDispatchHandle> {
+        self.source
+            .as_ref()
+            .map(LoadedDirectSourceExecutor::union_handle)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "all-flow-union recurrence backend has no SourceIR dispatcher",
+                )
+            })
+    }
+
+    fn bind_union_source_program(
+        &self,
+        view: OnTheFlyUnionSourceBindingView<'_>,
+    ) -> RusticolResult<Box<dyn OnTheFlyBoundUnionSourceProgram>> {
+        self.source
+            .as_ref()
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "all-flow-union recurrence backend has no SourceIR dispatcher",
+                )
+            })?
+            .bind_union_program(view)
+    }
+}
+
+impl OnTheFlyPreparedExecutorResolver for NativeOnTheFlyPreparedExecutorResolver {
+    fn resolve(&self, key: OnTheFlyExecutorKeyV1) -> RusticolResult<ResolvedOnTheFlyExecutor> {
+        self.effective_resolved().get(&key).copied().ok_or_else(|| {
+            RusticolError::integrity(
+                "on-the-fly operation has no exact authenticated prepared executor",
+            )
+        })
+    }
+
+    fn invalidate_row_tables(&self) -> RusticolResult<()> {
+        self.pool.invalidate_on_the_fly_row_tables()
+    }
+
+    fn resolve_direct_executor(
+        &self,
+        direct_executor_id: u32,
+        role: DirectExecutorRole,
+    ) -> RusticolResult<ResolvedOnTheFlyExecutor> {
+        self.pool
+            .resolve_direct_executor_id(&self.sources, direct_executor_id, role)
+    }
+
+    fn union_source_dispatch(&self) -> RusticolResult<DirectUnionSourceDispatchHandle> {
+        self.sources.union_source_dispatch()
+    }
+
+    fn bind_union_source_program(
+        &self,
+        view: OnTheFlyUnionSourceBindingView<'_>,
+    ) -> RusticolResult<Box<dyn OnTheFlyBoundUnionSourceProgram>> {
+        self.sources.bind_union_source_program(view)
+    }
+
+    fn union_source_packed_singleton_capable(&self) -> bool {
+        self.sources.packed_singleton_capability()
+    }
+}
+
+impl NativeRecurrencePreparedExecutorPool {
+    fn invalidate_on_the_fly_row_tables(&self) -> RusticolResult<()> {
+        #[cfg(feature = "f64-symjit")]
+        for executor in &self._symjit {
+            executor.invalidate_row_tables()?;
+        }
+        Ok(())
+    }
+}
+
+impl NativeRecurrenceDirectExecutorOwners {
+    pub(super) fn summary(&self) -> &NativeRecurrenceDirectBackendSummary {
+        &self.pool.summary
+    }
+
+    pub(super) fn internal_traffic_bytes(&self) -> (u64, u64) {
+        #[cfg(feature = "f64-symjit")]
+        {
+            self.pool
+                ._symjit
+                .iter()
+                .map(LoadedSymjitDirectExecutor::internal_traffic_bytes)
+                .fold(
+                    (0_u64, 0_u64),
+                    |(scratch, broadcast), (next_scratch, next_broadcast)| {
+                        (
+                            scratch.saturating_add(next_scratch),
+                            broadcast.saturating_add(next_broadcast),
+                        )
+                    },
+                )
+        }
+        #[cfg(not(feature = "f64-symjit"))]
+        {
+            (0, 0)
+        }
+    }
+
+    pub(super) fn union_source_dispatch(&self) -> RusticolResult<DirectUnionSourceDispatchHandle> {
+        self.source_binding.union_source_dispatch()
+    }
+}
+
+#[cfg(feature = "f64-compiled")]
+fn load_process_native_executor(
+    descriptor: &ProcessNativeExecutor,
+    role: DirectExecutorRole,
+    payloads: &EvaluatorPayloadStore,
+) -> RusticolResult<LoadedNativeDirectExecutor> {
+    LoadedNativeDirectExecutor::load(
+        payloads.load_native_library(&descriptor.library_path)?,
+        role,
+        descriptor.prepared_kernel_id,
+        &descriptor.native_entry_point,
+        descriptor.coupling,
+    )
+}
+
+#[cfg(feature = "f64-symjit")]
+fn load_process_jit_executor(
+    descriptor: &ProcessJitExecutor,
+    role: DirectExecutorRole,
+    payloads: &EvaluatorPayloadStore,
+) -> RusticolResult<LoadedSymjitDirectExecutor> {
+    let source = payloads.source(&descriptor.source_application_path)?;
+    let bytes = source.read()?;
+    if Sha256::digest(bytes.as_ref()).as_slice() != descriptor.source_application_sha256.as_slice()
+    {
+        return Err(RusticolError::integrity(format!(
+            "process Direct-Arena source application {} has the wrong digest",
+            source.display_name()
+        )));
+    }
+    let parameter_bindings = descriptor
+        .parameter_bindings
+        .iter()
+        .copied()
+        .map(|binding| match binding {
+            RecurrenceDirectParameterBindingManifest::Plane { index } => {
+                SymjitDirectParameterBinding::Plane { index }
+            }
+            RecurrenceDirectParameterBindingManifest::Scalar { index } => {
+                SymjitDirectParameterBinding::Broadcast { index }
+            }
+        })
+        .collect();
+    let input_planes = descriptor
+        .input_plane_projections
+        .iter()
+        .copied()
+        .map(plane_projection)
+        .collect();
+    let scalars = descriptor
+        .scalar_projections
+        .iter()
+        .copied()
+        .map(scalar_projection)
+        .collect::<RusticolResult<Vec<_>>>()?;
+    LoadedSymjitDirectExecutor::load_prepared_application_bytes(
+        bytes.as_ref(),
+        PathBuf::from(source.display_name()),
+        &descriptor.source_application_abi,
+        descriptor.optimization_level,
+        descriptor.plane_compression,
+        role,
+        parameter_bindings,
+        input_planes,
+        scalars,
+        descriptor.output_alias_inputs.clone(),
+    )
+}
+
+fn load_process_contribution_intrinsic(
+    intrinsic: &ProcessIntrinsicExecutor,
+) -> RusticolResult<LoadedRecurrenceIntrinsicDirectExecutor> {
+    let scale = intrinsic.scale.ok_or_else(|| {
+        RusticolError::integrity("process contribution intrinsic has no certified scale")
+    })?;
+    LoadedRecurrenceIntrinsicDirectExecutor::load_runtime_template(
+        &intrinsic.runtime_template,
+        RecurrenceIntrinsicScale::new(
+            f64::from_bits(scale.constant_real_bits),
+            f64::from_bits(scale.constant_imag_bits),
+            scale.parameter_index,
+        )?,
+    )
+}
+
+fn load_process_intrinsic_handle(
+    role: DirectExecutorRole,
+    runtime_template: &str,
+) -> RusticolResult<DirectExecutorHandle> {
+    match role {
+        DirectExecutorRole::Finalization
+            if runtime_template == "rusticol.identity-finalize-in-place.v1" =>
+        {
+            Ok(DirectExecutorHandle::Finalization {
+                call: execute_identity_finalization_rows,
+                context: std::ptr::null::<std::ffi::c_void>(),
+            })
+        }
+        DirectExecutorRole::Finalization
+            if matches!(
+                runtime_template,
+                WEYL_PROPAGATOR_POSITIVE_TEMPLATE
+                    | WEYL_PROPAGATOR_NEGATIVE_TEMPLATE
+                    | FEYNMAN_VECTOR_PROPAGATOR_TEMPLATE
+            ) =>
+        {
+            LoadedRecurrenceIntrinsicDirectExecutor::finalization_handle(runtime_template)
+        }
+        DirectExecutorRole::Closure
+            if runtime_template.starts_with("rusticol.closure-reduce.v1:") =>
+        {
+            Ok(DirectExecutorHandle::Closure {
+                call: execute_closure_reduce_rows,
+                context: std::ptr::null::<std::ffi::c_void>(),
+            })
+        }
+        _ => Err(RusticolError::compatibility(format!(
+            "unsupported process Direct-Arena intrinsic {runtime_template:?} for {role:?}"
+        ))),
+    }
+}
+
+#[cfg(feature = "f64-compiled")]
+fn load_native_executor(
+    template: &RecurrenceDirectTemplateManifest,
+    pack: &PreparedKernelPackManifest,
+    payloads: &EvaluatorPayloadStore,
+) -> RusticolResult<LoadedNativeDirectExecutor> {
+    let binding = &template.payload_binding;
+    let library_path = binding.source_application_path.as_deref().ok_or_else(|| {
+        RusticolError::artifact("native Direct-Arena prepared call has no library payload")
+    })?;
+    let exported_symbol = binding.native_entry_point.as_deref().ok_or_else(|| {
+        RusticolError::artifact("native Direct-Arena prepared call has no exported symbol")
+    })?;
+    let prepared_kernel_id = binding.prepared_kernel_id.ok_or_else(|| {
+        RusticolError::artifact("native Direct-Arena prepared call has no kernel ID")
+    })?;
+    let kernel = pack
+        .kernels
+        .iter()
+        .find(|kernel| kernel.kernel_id == prepared_kernel_id)
+        .ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "native Direct-Arena prepared kernel {prepared_kernel_id} is absent"
+            ))
+        })?;
+    let binding_coupling = native_binding_coupling(binding, kernel)?;
+    LoadedNativeDirectExecutor::load(
+        payloads.load_native_library(library_path)?,
+        direct_role(&template.role)?,
+        prepared_kernel_id,
+        exported_symbol,
+        binding_coupling,
+    )
+}
+
+#[cfg(feature = "f64-compiled")]
+fn native_binding_coupling(
+    binding: &super::eager_manifest::RecurrenceDirectPayloadBindingManifest,
+    kernel: &PreparedKernelManifest,
+) -> RusticolResult<Option<(f64, f64)>> {
+    let expected_parameter_bindings =
+        kernel.input_contracts.len().checked_mul(2).ok_or_else(|| {
+            RusticolError::artifact("native Direct-Arena input count exceeds usize")
+        })?;
+    if binding.parameter_bindings.len() != expected_parameter_bindings {
+        return Err(RusticolError::integrity(format!(
+            "native Direct-Arena kernel {} has {} parameter bindings, expected {}",
+            kernel.kernel_id,
+            binding.parameter_bindings.len(),
+            expected_parameter_bindings,
+        )));
+    }
+
+    let mut coupling_re = None;
+    let mut coupling_im = None;
+    for (input_index, input) in kernel.input_contracts.iter().enumerate() {
+        let destination = match input.role.as_str() {
+            "coupling-real" => &mut coupling_re,
+            "coupling-imag" => &mut coupling_im,
+            _ => continue,
+        };
+        if destination.is_some() {
+            return Err(RusticolError::integrity(format!(
+                "native Direct-Arena kernel {} repeats {:?}",
+                kernel.kernel_id, input.role
+            )));
+        }
+        let base = input_index * 2;
+        *destination = Some(native_literal_binding(
+            binding,
+            base,
+            &format!("kernel {} {} input", kernel.kernel_id, input.role),
+        )?);
+        let imaginary = native_literal_binding(
+            binding,
+            base + 1,
+            &format!("kernel {} {} imaginary input", kernel.kernel_id, input.role),
+        )?;
+        if imaginary != 0.0 {
+            return Err(RusticolError::integrity(format!(
+                "native Direct-Arena kernel {} coupling input has a nonzero imaginary scalar lane",
+                kernel.kernel_id
+            )));
+        }
+    }
+    if coupling_re.is_none() && coupling_im.is_none() {
+        return Ok(None);
+    }
+    Ok(Some((
+        coupling_re.unwrap_or(0.0),
+        coupling_im.unwrap_or(0.0),
+    )))
+}
+
+#[cfg(feature = "f64-compiled")]
+fn native_literal_binding(
+    binding: &super::eager_manifest::RecurrenceDirectPayloadBindingManifest,
+    parameter_index: usize,
+    label: &str,
+) -> RusticolResult<f64> {
+    let scalar_index = match binding.parameter_bindings.get(parameter_index) {
+        Some(RecurrenceDirectParameterBindingManifest::Scalar { index }) => *index,
+        _ => {
+            return Err(RusticolError::integrity(format!(
+                "native Direct-Arena {label} is not bound to a scalar"
+            )));
+        }
+    };
+    let value = match binding.scalar_projections.get(scalar_index as usize) {
+        Some(RecurrenceDirectScalarProjectionManifest::Literal { value }) => *value,
+        _ => {
+            return Err(RusticolError::integrity(format!(
+                "native Direct-Arena {label} is not an immutable literal"
+            )));
+        }
+    };
+    if !value.is_finite() {
+        return Err(RusticolError::integrity(format!(
+            "native Direct-Arena {label} is non-finite"
+        )));
+    }
+    Ok(value)
+}
+
+fn load_contribution_intrinsic(
+    template: &RecurrenceDirectTemplateManifest,
+) -> RusticolResult<LoadedRecurrenceIntrinsicDirectExecutor> {
+    let runtime_template = template
+        .payload_binding
+        .runtime_template
+        .as_deref()
+        .ok_or_else(|| RusticolError::artifact("contribution intrinsic has no template"))?;
+    let scale = match template.payload_binding.scalar_projections.as_slice() {
+        [
+            RecurrenceDirectScalarProjectionManifest::IntrinsicScale {
+                constant_real_bits,
+                constant_imag_bits,
+                parameter_index,
+            },
+        ] => RecurrenceIntrinsicScale::new(
+            f64::from_bits(*constant_real_bits),
+            f64::from_bits(*constant_imag_bits),
+            *parameter_index,
+        )?,
+        _ => {
+            return Err(RusticolError::integrity(
+                "contribution intrinsic must carry exactly one intrinsic scale",
+            ));
+        }
+    };
+    LoadedRecurrenceIntrinsicDirectExecutor::load_runtime_template(runtime_template, scale)
+}
+
+fn load_intrinsic_handle(
+    template: &RecurrenceDirectTemplateManifest,
+) -> RusticolResult<DirectExecutorHandle> {
+    let runtime_template = template
+        .payload_binding
+        .runtime_template
+        .as_deref()
+        .ok_or_else(|| RusticolError::artifact("Direct-Arena intrinsic has no runtime template"))?;
+    load_process_intrinsic_handle(direct_role(&template.role)?, runtime_template)
+}
+
+#[cfg(feature = "f64-symjit")]
+fn load_symjit_executor(
+    template: &RecurrenceDirectTemplateManifest,
+    pack: &PreparedKernelPackManifest,
+    payloads: &EvaluatorPayloadStore,
+) -> RusticolResult<LoadedSymjitDirectExecutor> {
+    let binding = &template.payload_binding;
+    let expected_compression = symjit_plane_compression(binding, pack)?;
+    let source_path = binding.source_application_path.as_deref().ok_or_else(|| {
+        RusticolError::artifact("Direct-Arena prepared call has no source application")
+    })?;
+    let source = payloads.source(source_path)?;
+    let bytes = source.read()?;
+    let expected_sha = binding
+        .source_application_sha256
+        .as_deref()
+        .ok_or_else(|| RusticolError::artifact("Direct-Arena source application has no digest"))?;
+    let actual_sha = format!("{:x}", Sha256::digest(bytes.as_ref()));
+    if actual_sha != expected_sha {
+        return Err(RusticolError::integrity(format!(
+            "Direct-Arena source application {} has digest {actual_sha}, expected {expected_sha}",
+            source.display_name()
+        )));
+    }
+    let role = direct_role(&template.role)?;
+    validate_direct_destination_policy(role, &template.destination_operation)?;
+    let parameter_bindings = binding
+        .parameter_bindings
+        .iter()
+        .map(|binding| match *binding {
+            RecurrenceDirectParameterBindingManifest::Plane { index } => {
+                SymjitDirectParameterBinding::Plane { index }
+            }
+            RecurrenceDirectParameterBindingManifest::Scalar { index } => {
+                SymjitDirectParameterBinding::Broadcast { index }
+            }
+        })
+        .collect::<Vec<_>>();
+    let input_planes = binding
+        .input_plane_projections
+        .iter()
+        .copied()
+        .map(plane_projection)
+        .collect();
+    let scalars = binding
+        .scalar_projections
+        .iter()
+        .copied()
+        .map(scalar_projection)
+        .collect::<RusticolResult<Vec<_>>>()?;
+    LoadedSymjitDirectExecutor::load_prepared_application_bytes(
+        bytes.as_ref(),
+        PathBuf::from(source.display_name()),
+        binding
+            .source_application_abi
+            .as_deref()
+            .unwrap_or_default(),
+        template.optimization_level,
+        expected_compression,
+        role,
+        parameter_bindings,
+        input_planes,
+        scalars,
+        binding.output_alias_inputs.clone(),
+    )
+}
+
+#[cfg(feature = "f64-symjit")]
+fn symjit_plane_compression(
+    binding: &super::eager_manifest::RecurrenceDirectPayloadBindingManifest,
+    pack: &PreparedKernelPackManifest,
+) -> RusticolResult<bool> {
+    let prepared_kernel_id = binding
+        .prepared_kernel_id
+        .ok_or_else(|| RusticolError::artifact("Direct-Arena prepared call has no kernel ID"))?;
+    let kernel = pack
+        .kernels
+        .iter()
+        .find(|kernel| kernel.kernel_id == prepared_kernel_id)
+        .ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "Direct-Arena prepared kernel {prepared_kernel_id} is absent"
+            ))
+        })?;
+    kernel
+        .f64_evaluator_manifest
+        .get("plane_application")
+        .and_then(serde_json::Value::as_object)
+        .and_then(|plane| plane.get("compression"))
+        .and_then(serde_json::Value::as_bool)
+        .ok_or_else(|| {
+            RusticolError::compatibility(format!(
+                "Direct-Arena prepared JIT kernel {prepared_kernel_id} has no authenticated \
+                 SymJIT compression setting; regenerate the prepared model"
+            ))
+        })
+}
+
+#[cfg(feature = "f64-symjit")]
+fn plane_projection(
+    projection: RecurrenceDirectPlaneProjectionManifest,
+) -> SymjitDirectPlaneProjection {
+    match projection {
+        RecurrenceDirectPlaneProjectionManifest::ParentCurrent {
+            parent,
+            component,
+            imaginary,
+        } => SymjitDirectPlaneProjection::ParentCurrent {
+            parent,
+            component,
+            imaginary,
+        },
+        RecurrenceDirectPlaneProjectionManifest::Momentum {
+            operand,
+            lorentz_component,
+        } => SymjitDirectPlaneProjection::Momentum {
+            operand,
+            lorentz_component,
+        },
+        RecurrenceDirectPlaneProjectionManifest::DestinationCurrent {
+            component,
+            imaginary,
+        } => SymjitDirectPlaneProjection::DestinationCurrent {
+            component,
+            imaginary,
+        },
+        RecurrenceDirectPlaneProjectionManifest::DestinationAmplitude {
+            component,
+            imaginary,
+        } => SymjitDirectPlaneProjection::DestinationAmplitude {
+            component,
+            imaginary,
+        },
+    }
+}
+
+#[cfg(feature = "f64-symjit")]
+fn scalar_projection(
+    projection: RecurrenceDirectScalarProjectionManifest,
+) -> RusticolResult<SymjitDirectScalarProjection> {
+    Ok(match projection {
+        RecurrenceDirectScalarProjectionManifest::ExactFactor { imaginary } => {
+            SymjitDirectScalarProjection::ExactFactor { imaginary }
+        }
+        RecurrenceDirectScalarProjectionManifest::Parameter { index, imaginary } => {
+            SymjitDirectScalarProjection::Parameter { index, imaginary }
+        }
+        RecurrenceDirectScalarProjectionManifest::Literal { value } => {
+            if !value.is_finite() {
+                return Err(RusticolError::artifact(
+                    "Direct-Arena literal scalar projection is not finite",
+                ));
+            }
+            SymjitDirectScalarProjection::Literal(value)
+        }
+        RecurrenceDirectScalarProjectionManifest::IntrinsicScale { .. } => {
+            return Err(RusticolError::integrity(
+                "intrinsic scale cannot be used by a prepared SymJIT callable",
+            ));
+        }
+    })
+}
+
+fn direct_role(role: &str) -> RusticolResult<DirectExecutorRole> {
+    match role {
+        "source" => Ok(DirectExecutorRole::Source),
+        "contribution" => Ok(DirectExecutorRole::Contribution),
+        "finalization" => Ok(DirectExecutorRole::Finalization),
+        "closure" => Ok(DirectExecutorRole::Closure),
+        other => Err(RusticolError::compatibility(format!(
+            "unsupported Direct-Arena executor role {other:?}"
+        ))),
+    }
+}
+
+#[cfg(feature = "f64-symjit")]
+fn validate_direct_destination_policy(role: DirectExecutorRole, value: &str) -> RusticolResult<()> {
+    let expected = match role {
+        DirectExecutorRole::Source => "initialize",
+        DirectExecutorRole::Contribution => "add",
+        DirectExecutorRole::Finalization => "finalize-in-place",
+        DirectExecutorRole::Closure => "closure-add",
+    };
+    if value == expected {
+        Ok(())
+    } else {
+        Err(RusticolError::integrity(format!(
+            "Direct-Arena destination operation {value:?} does not match role {role:?}; expected {expected:?}"
+        )))
+    }
+}
+
+fn semantic_digest(value: &str, label: &str) -> RusticolResult<SemanticDigest> {
+    let bytes = value.as_bytes();
+    if bytes.len() != 64 {
+        return Err(RusticolError::artifact(format!(
+            "{label} is not a SHA-256 digest"
+        )));
+    }
+    let mut digest = [0_u8; 32];
+    for (index, pair) in bytes.chunks_exact(2).enumerate() {
+        let high = hex_nibble(pair[0]).ok_or_else(|| {
+            RusticolError::artifact(format!("{label} is not lowercase hexadecimal"))
+        })?;
+        let low = hex_nibble(pair[1]).ok_or_else(|| {
+            RusticolError::artifact(format!("{label} is not lowercase hexadecimal"))
+        })?;
+        digest[index] = (high << 4) | low;
+    }
+    SemanticDigest::new(digest)
+        .map_err(|_| RusticolError::artifact(format!("{label} must not be all zero")))
+}
+
+fn hex_nibble(value: u8) -> Option<u8> {
+    match value {
+        b'0'..=b'9' => Some(value - b'0'),
+        b'a'..=b'f' => Some(value - b'a' + 10),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+pub(in crate::engine) mod on_the_fly_adapter_tests {
+    use super::*;
+    use crate::engine::evaluator::recurrence_source_direct::{
+        DirectSourceDispatchKey, DirectSourceDispatchVariantSpec, DirectSourceOrientation,
+        DirectSourceTemplateSpec, DirectSourceWavefunctionFamily,
+    };
+    use crate::recurrence::on_the_fly::{
+        OnTheFlyStructuralInterpreter, OnTheFlyWorkspaceV1, scalar_adapter_test_seed,
+        scalar_adapter_test_trace,
+    };
+    use crate::recurrence::{
+        DirectResolvedSourceSelection, DirectSourceDispatchVariantDescriptor,
+        DirectSourceEmbeddingRow, DirectSourceProjectionRow, PreparedDirectExecutorBinding,
+        PreparedDirectExecutorCatalog, valid_direct_plan_parts_fixture, validated_template_fixture,
+    };
+    use std::cell::Cell;
+    use std::ptr;
+
+    #[test]
+    fn selected_prepared_finalization_exact_factor_is_not_contribution_metadata() {
+        let descriptor = ProcessDirectExecutorDescriptor {
+            direct_executor_id: 574,
+            role: DirectExecutorRole::Finalization,
+            destination_component_count: 2,
+            uses_exact_factor: true,
+            binding: ProcessDirectExecutorBinding::Native(
+                crate::engine::recurrence_process_pack::ProcessNativeExecutor {
+                    prepared_kernel_id: 17,
+                    library_path: "prepared-finalizer.so".to_owned(),
+                    native_entry_point: "prepared_finalizer".to_owned(),
+                    coupling: None,
+                },
+            ),
+        };
+
+        assert!(descriptor.uses_exact_factor);
+        assert!(
+            process_contribution_execution_metadata(&descriptor)
+                .unwrap()
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn unreferenced_symjit_executor_loader_is_not_invoked_by_plan_filter() {
+        let required = [true, false, true];
+        let calls = Cell::new(0_u32);
+        let skipped = instantiate_selected_executor(Some(&required), 1, || {
+            calls.set(calls.get() + 1);
+            Ok(Some(7_u32))
+        })
+        .unwrap();
+        assert_eq!(skipped, None);
+        assert_eq!(calls.get(), 0);
+
+        let loaded = instantiate_selected_executor(Some(&required), 2, || {
+            calls.set(calls.get() + 1);
+            Ok(Some(9_u32))
+        })
+        .unwrap();
+        assert_eq!(loaded, Some(9));
+        assert_eq!(calls.get(), 1);
+
+        let full_catalog = instantiate_selected_executor(None, 99, || {
+            calls.set(calls.get() + 1);
+            Ok(Some(13_u32))
+        })
+        .unwrap();
+        assert_eq!(full_catalog, Some(13));
+        assert_eq!(calls.get(), 2);
+
+        let propagated = instantiate_selected_executor(Some(&required), 0, || {
+            Err::<Option<u32>, _>(RusticolError::artifact("selected payload is absent"))
+        })
+        .unwrap_err();
+        assert_eq!(propagated.kind(), crate::RusticolErrorKind::Artifact);
+
+        let error =
+            instantiate_selected_executor(Some(&required), 3, || Ok(Some(11_u32))).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    }
+
+    #[test]
+    fn persisted_direct_ids_resolve_without_a_semantic_binding_catalog() {
+        let templates = validated_template_fixture();
+        let direct_digest = digest(40);
+        let mut pool = prepared_pool(&templates, direct_digest);
+        // Process packs retain only plan-owned dense executor IDs. They do not
+        // carry the model-wide semantic binding map used by query-local OTF.
+        pool.bindings.clear();
+        pool.identity_finalizer_id = None;
+        let sources = pool.bind_source_domains(source_domains()).unwrap();
+        let resolver = pool.into_on_the_fly_resolver(sources);
+
+        let source = resolver
+            .resolve_direct_executor(0, DirectExecutorRole::Source)
+            .unwrap();
+        assert_eq!(source.direct_executor_id, 0);
+        assert_eq!(source.handle.role(), DirectExecutorRole::Source);
+        assert!(resolver.union_source_dispatch().is_ok());
+
+        let closure = resolver
+            .resolve_direct_executor(1, DirectExecutorRole::Closure)
+            .unwrap();
+        assert_eq!(closure.direct_executor_id, 1);
+        assert_eq!(closure.handle.role(), DirectExecutorRole::Closure);
+
+        let finalization = resolver
+            .resolve_direct_executor(2, DirectExecutorRole::Finalization)
+            .unwrap();
+        assert_eq!(finalization.direct_executor_id, 2);
+        assert_eq!(finalization.handle.role(), DirectExecutorRole::Finalization);
+
+        assert!(
+            resolver
+                .resolve_direct_executor(1, DirectExecutorRole::Finalization)
+                .is_err()
+        );
+        assert!(
+            resolver
+                .resolve_direct_executor(3, DirectExecutorRole::Closure)
+                .is_err()
+        );
+    }
+
+    pub(in crate::engine) fn digest(seed: u8) -> SemanticDigest {
+        SemanticDigest::new([seed; 32]).unwrap()
+    }
+
+    pub(in crate::engine) fn direct_catalog(
+        direct_digest: SemanticDigest,
+    ) -> PreparedDirectExecutorCatalog {
+        PreparedDirectExecutorCatalog::new(
+            direct_digest,
+            vec![
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Source, 0, 0),
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Closure, 3, 1),
+                PreparedDirectExecutorBinding::identity_finalizer(2),
+            ],
+        )
+        .unwrap()
+    }
+
+    pub(in crate::engine) fn complete_scalar_direct_catalog(
+        direct_digest: SemanticDigest,
+    ) -> PreparedDirectExecutorCatalog {
+        PreparedDirectExecutorCatalog::new(
+            direct_digest,
+            vec![
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Source, 0, 0),
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Closure, 3, 1),
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Closure, 4, 1),
+                PreparedDirectExecutorBinding::identity_finalizer(2),
+            ],
+        )
+        .unwrap()
+    }
+
+    pub(in crate::engine) fn prepared_pool(
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct_digest: SemanticDigest,
+    ) -> NativeRecurrencePreparedExecutorPool {
+        let summary = templates.summary();
+        NativeRecurrencePreparedExecutorPool {
+            handles: vec![
+                None,
+                Some(DirectExecutorHandle::Closure {
+                    call: execute_closure_reduce_rows,
+                    context: ptr::null(),
+                }),
+                Some(DirectExecutorHandle::Finalization {
+                    call: execute_identity_finalization_rows,
+                    context: ptr::null(),
+                }),
+            ]
+            .into_boxed_slice(),
+            bindings: BTreeMap::from([
+                (
+                    (DirectExecutorRole::Source, 0),
+                    NativePreparedExecutorBinding {
+                        executor_id: 0,
+                        parent_permutation: [0, 1],
+                    },
+                ),
+                (
+                    (DirectExecutorRole::Closure, 3),
+                    NativePreparedExecutorBinding {
+                        executor_id: 1,
+                        parent_permutation: [0, 1],
+                    },
+                ),
+            ]),
+            executor_roles: vec![
+                Some(DirectExecutorRole::Source),
+                Some(DirectExecutorRole::Closure),
+                Some(DirectExecutorRole::Finalization),
+            ]
+            .into_boxed_slice(),
+            contribution_metadata: vec![None, None, None].into_boxed_slice(),
+            contribution_fanout: vec![None, None, None].into_boxed_slice(),
+            packed_singleton_capabilities: vec![false, true, true].into_boxed_slice(),
+            identity_finalizer_id: Some(2),
+            direct_template_catalog_digest: direct_digest,
+            recurrence_template_catalog_digest: summary.catalog_digest,
+            compiled_model_digest: summary.compiled_model_digest,
+            prepared_kernel_pack_digest: summary.prepared_kernel_pack_digest,
+            _intrinsics: Vec::new(),
+            #[cfg(feature = "f64-symjit")]
+            _symjit: Vec::new(),
+            #[cfg(feature = "f64-compiled")]
+            _native: Vec::new(),
+            summary: NativeRecurrenceDirectBackendSummary {
+                prepared_kernel_pack_digest: summary.prepared_kernel_pack_digest.to_string(),
+                direct_template_catalog_digest: direct_digest.to_string(),
+                backend: "test-intrinsic".into(),
+                target_triple: "test".into(),
+                target_portable: true,
+                executor_count: 3,
+            },
+        }
+    }
+
+    pub(in crate::engine) fn complete_scalar_prepared_pool(
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct_digest: SemanticDigest,
+    ) -> NativeRecurrencePreparedExecutorPool {
+        let mut pool = prepared_pool(templates, direct_digest);
+        pool.bindings.insert(
+            (DirectExecutorRole::Closure, 4),
+            NativePreparedExecutorBinding {
+                executor_id: 1,
+                parent_permutation: [0, 1],
+            },
+        );
+        pool
+    }
+
+    pub(in crate::engine) fn source_domains() -> Vec<DirectSourceDispatchDomainSpec> {
+        vec![DirectSourceDispatchDomainSpec {
+            variants: vec![DirectSourceDispatchVariantSpec {
+                key: DirectSourceDispatchKey::SpinStateClass(50_000),
+                template: DirectSourceTemplateSpec {
+                    spin_state_class: 50_000,
+                    family: DirectSourceWavefunctionFamily::Scalar,
+                    orientation: DirectSourceOrientation::SelfConjugate,
+                    helicity: 0,
+                    chirality: 0,
+                    mass_parameter_index: None,
+                },
+            }],
+        }]
+    }
+
+    fn all_flow_process_plan_with_internal_source_group() -> DirectRecurrencePlan {
+        let mut parts = valid_direct_plan_parts_fixture();
+        parts.strategy = RecurrenceStrategy::AllFlowUnion;
+        parts.runtime_helicity_contract_count = 1;
+        parts.runtime_helicity_variant_count = 1;
+        parts.sources[0].source_template_or_dispatch_domain = 0;
+        parts.row_groups[0].direct_executor_id = DIRECT_NONE_U32;
+        parts.replay_targets[0].helicity_map_count = 0;
+        parts.replay_helicity_map.clear();
+        parts.amplitude_destinations[0].target_helicity_id_or_sentinel = DIRECT_NONE_U32;
+        parts.resolved_helicities[0].source_selection_count = 1;
+        parts.source_dispatch_variants = vec![DirectSourceDispatchVariantDescriptor {
+            embedding_start: 0,
+            projection_start: 0,
+            source_row_id: 0,
+            dispatch_domain_id: 0,
+            runtime_variant_id: 0,
+            source_state_index: 0,
+            source_template_id: 0,
+            source_state_template_id: 0,
+            crossed_state_template_id: 0,
+            crossed_spin_state_class: 0,
+            direct_executor_id: 0,
+            crossing_exact_factor_id: 0,
+            embedding_count: 2,
+            projection_count: 2,
+        }];
+        parts.source_embeddings = vec![
+            DirectSourceEmbeddingRow {
+                full_component: 0,
+                source_component_or_sentinel: 0,
+                exact_factor_id: 0,
+            },
+            DirectSourceEmbeddingRow {
+                full_component: 1,
+                source_component_or_sentinel: 1,
+                exact_factor_id: 0,
+            },
+        ];
+        parts.source_projections = vec![
+            DirectSourceProjectionRow {
+                source_component: 0,
+                full_component: 0,
+            },
+            DirectSourceProjectionRow {
+                source_component: 1,
+                full_component: 1,
+            },
+        ];
+        parts.resolved_source_selections = vec![DirectResolvedSourceSelection {
+            source_slot: 0,
+            dispatch_variant_id: 0,
+        }];
+        DirectRecurrencePlan::new(parts).unwrap()
+    }
+
+    #[test]
+    fn sparse_all_flow_process_pack_binds_plan_owned_union_source() {
+        let plan = all_flow_process_plan_with_internal_source_group();
+        assert_eq!(plan.strategy(), RecurrenceStrategy::AllFlowUnion);
+        assert_eq!(plan.row_groups()[0].direct_executor_id, DIRECT_NONE_U32);
+
+        let templates = validated_template_fixture();
+        let mut pool = prepared_pool(&templates, plan.direct_template_catalog_digest());
+        // This is the authenticated sparse process-pack shape for AllFlow:
+        // the internal source group has no descriptor or prepared handle.
+        pool.executor_roles[0] = None;
+        pool.bindings.remove(&(DirectExecutorRole::Source, 0));
+        assert!(
+            !pool
+                .executor_roles
+                .contains(&Some(DirectExecutorRole::Source))
+        );
+        assert!(pool.bind_source_domains(source_domains()).is_err());
+
+        let sources =
+            OnTheFlySourceDomainBinding::load_for_process_plan(&plan, source_domains()).unwrap();
+        let resolver = pool.into_on_the_fly_resolver(sources);
+        assert!(resolver.union_source_dispatch().is_ok());
+    }
+
+    #[test]
+    fn genuine_scalar_sources_nonunit_identity_and_closure_execute_to_two() {
+        let templates = validated_template_fixture();
+        let summary = templates.summary();
+        let direct_digest = digest(40);
+        let direct = direct_catalog(direct_digest);
+        let seed = scalar_adapter_test_seed(
+            summary.compiled_model_digest,
+            summary.catalog_digest,
+            summary.prepared_kernel_pack_digest,
+            direct_digest,
+        )
+        .unwrap();
+        let mut trace = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        trace.test_insert_identity_finalizer(direct_digest);
+        let pool = prepared_pool(&templates, direct_digest);
+        let sources = pool.bind_source_domains(source_domains()).unwrap();
+        let mut resolver = pool.into_on_the_fly_resolver(sources);
+        resolver
+            .bind_on_the_fly_trace(&templates, &direct, &seed, &mut trace)
+            .unwrap();
+        let work = trace.execution_work_census().unwrap();
+        assert_eq!(work.logical_current_count, 2);
+        assert_eq!(work.resident_current_count, 2);
+        assert_eq!(work.resident_current_component_count, 2);
+        assert_eq!(work.source_operation_count, 2);
+        assert_eq!(work.contribution_operation_count, 0);
+        assert_eq!(work.finalization_operation_count, 1);
+        assert_eq!(work.closure_operation_count, 1);
+        assert_eq!(work.total_kernel_application_count, 4);
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 3);
+        assert_eq!(resolver.distinct_prepared_executor_count().unwrap(), 3);
+        let packed_roles = trace
+            .executor_keys()
+            .map(|key| {
+                let resolved = resolver.resolve(key).unwrap();
+                assert!(resolved.packed_singleton_capable);
+                resolved.handle.role()
+            })
+            .collect::<BTreeSet<_>>();
+        assert_eq!(
+            packed_roles,
+            BTreeSet::from([
+                DirectExecutorRole::Source,
+                DirectExecutorRole::Finalization,
+                DirectExecutorRole::Closure,
+            ])
+        );
+        let mut workspace = OnTheFlyWorkspaceV1::new(&trace, 1).unwrap();
+        workspace
+            .fill_momenta_from_external(&trace, &[0.0; 8], 1)
+            .unwrap();
+        OnTheFlyStructuralInterpreter::execute(&trace, &resolver, &mut workspace, 1).unwrap();
+        assert_eq!(workspace.amplitude(0).unwrap(), (2.0, 0.0));
+    }
+
+    #[test]
+    fn adapter_rejects_tampered_operation_and_identity_keys() {
+        let templates = validated_template_fixture();
+        let summary = templates.summary();
+        let direct_digest = digest(40);
+        let direct = direct_catalog(direct_digest);
+        let seed = scalar_adapter_test_seed(
+            summary.compiled_model_digest,
+            summary.catalog_digest,
+            summary.prepared_kernel_pack_digest,
+            direct_digest,
+        )
+        .unwrap();
+        let pool = prepared_pool(&templates, direct_digest);
+        let sources = pool.bind_source_domains(source_domains()).unwrap();
+        let mut resolver = pool.into_on_the_fly_resolver(sources);
+
+        let mut operation_tamper = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        operation_tamper.test_tamper_first_operation_semantic_digest(digest(99));
+        assert!(
+            resolver
+                .bind_on_the_fly_trace(&templates, &direct, &seed, &mut operation_tamper)
+                .is_err()
+        );
+
+        let mut identity_tamper = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        identity_tamper.test_insert_identity_finalizer(digest(99));
+        assert!(
+            resolver
+                .bind_on_the_fly_trace(&templates, &direct, &seed, &mut identity_tamper)
+                .is_err()
+        );
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 0);
+
+        let mut retained = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        resolver
+            .bind_on_the_fly_trace(&templates, &direct, &seed, &mut retained)
+            .unwrap();
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 2);
+    }
+
+    #[test]
+    fn semantic_binding_candidates_replace_exactly_only_after_commit() {
+        let templates = validated_template_fixture();
+        let summary = templates.summary();
+        let direct_digest = digest(40);
+        let direct = direct_catalog(direct_digest);
+        let seed = scalar_adapter_test_seed(
+            summary.compiled_model_digest,
+            summary.catalog_digest,
+            summary.prepared_kernel_pack_digest,
+            direct_digest,
+        )
+        .unwrap();
+        let pool = prepared_pool(&templates, direct_digest);
+        let sources = pool.bind_source_domains(source_domains()).unwrap();
+        let mut resolver = pool.into_on_the_fly_resolver(sources);
+
+        let mut first = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        resolver
+            .bind_on_the_fly_trace(&templates, &direct, &seed, &mut first)
+            .unwrap();
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 2);
+        resolver.commit_pending_resolved_bindings().unwrap();
+
+        let mut second = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        second.test_insert_identity_finalizer(direct_digest);
+        resolver
+            .bind_on_the_fly_trace(&templates, &direct, &seed, &mut second)
+            .unwrap();
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 3);
+        resolver.discard_pending_resolved_bindings();
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 2);
+
+        let mut malformed = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        malformed.test_insert_identity_finalizer(digest(99));
+        assert!(
+            resolver
+                .bind_on_the_fly_trace(&templates, &direct, &seed, &mut malformed)
+                .is_err()
+        );
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 2);
+
+        let mut committed_second = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        committed_second.test_insert_identity_finalizer(direct_digest);
+        resolver
+            .bind_on_the_fly_trace(&templates, &direct, &seed, &mut committed_second)
+            .unwrap();
+        resolver.commit_pending_resolved_bindings().unwrap();
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 3);
+
+        let mut revisited_first = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        resolver
+            .bind_on_the_fly_trace(&templates, &direct, &seed, &mut revisited_first)
+            .unwrap();
+        resolver.commit_pending_resolved_bindings().unwrap();
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 2);
+    }
+
+    #[test]
+    fn streamed_semantic_binding_failure_rolls_back_every_prior_chunk() {
+        let templates = validated_template_fixture();
+        let summary = templates.summary();
+        let direct_digest = digest(40);
+        let direct = direct_catalog(direct_digest);
+        let seed = scalar_adapter_test_seed(
+            summary.compiled_model_digest,
+            summary.catalog_digest,
+            summary.prepared_kernel_pack_digest,
+            direct_digest,
+        )
+        .unwrap();
+        let pool = prepared_pool(&templates, direct_digest);
+        let sources = pool.bind_source_domains(source_domains()).unwrap();
+        let mut resolver = pool.into_on_the_fly_resolver(sources);
+
+        let mut committed = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        resolver
+            .bind_on_the_fly_trace(&templates, &direct, &seed, &mut committed)
+            .unwrap();
+        resolver.commit_pending_resolved_bindings().unwrap();
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 2);
+
+        let mut first_chunk = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        first_chunk.test_insert_identity_finalizer(direct_digest);
+        resolver
+            .begin_on_the_fly_family_binding(&templates, &direct)
+            .unwrap();
+        resolver
+            .extend_on_the_fly_family_binding(
+                &templates,
+                &direct,
+                &seed,
+                std::iter::once(&mut first_chunk),
+            )
+            .unwrap();
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 3);
+
+        let mut malformed_second_chunk = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        malformed_second_chunk.test_insert_identity_finalizer(digest(99));
+        let error = resolver
+            .extend_on_the_fly_family_binding(
+                &templates,
+                &direct,
+                &seed,
+                std::iter::once(&mut malformed_second_chunk),
+            )
+            .unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 2);
+        assert!(resolver.commit_pending_resolved_bindings().is_err());
+        assert_eq!(resolver.semantic_executor_binding_count().unwrap(), 2);
+    }
+
+    #[test]
+    fn adapter_rejects_missing_binding_and_each_compact_catalog_identity_mismatch() {
+        let templates = validated_template_fixture();
+        let summary = templates.summary();
+        let direct_digest = digest(40);
+        let direct = direct_catalog(direct_digest);
+        let pool = prepared_pool(&templates, direct_digest);
+        let sources = pool.bind_source_domains(source_domains()).unwrap();
+        let mut resolver = pool.into_on_the_fly_resolver(sources);
+        let seed = scalar_adapter_test_seed(
+            summary.compiled_model_digest,
+            summary.catalog_digest,
+            summary.prepared_kernel_pack_digest,
+            direct_digest,
+        )
+        .unwrap();
+        let mut trace = scalar_adapter_test_trace(&templates, &seed).unwrap();
+        let missing = PreparedDirectExecutorCatalog::new(
+            direct_digest,
+            vec![
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Source, 0, 0),
+                PreparedDirectExecutorBinding::identity_finalizer(1),
+            ],
+        )
+        .unwrap();
+        assert!(
+            resolver
+                .bind_on_the_fly_trace(&templates, &missing, &seed, &mut trace)
+                .is_err()
+        );
+
+        for (model, template, pack, direct_id) in [
+            (
+                digest(90),
+                summary.catalog_digest,
+                summary.prepared_kernel_pack_digest,
+                direct_digest,
+            ),
+            (
+                summary.compiled_model_digest,
+                digest(90),
+                summary.prepared_kernel_pack_digest,
+                direct_digest,
+            ),
+            (
+                summary.compiled_model_digest,
+                summary.catalog_digest,
+                digest(90),
+                direct_digest,
+            ),
+            (
+                summary.compiled_model_digest,
+                summary.catalog_digest,
+                summary.prepared_kernel_pack_digest,
+                digest(90),
+            ),
+        ] {
+            let mismatched = scalar_adapter_test_seed(model, template, pack, direct_id).unwrap();
+            let mut mismatched_trace = scalar_adapter_test_trace(&templates, &mismatched).unwrap();
+            assert!(
+                resolver
+                    .bind_on_the_fly_trace(&templates, &direct, &mismatched, &mut mismatched_trace,)
+                    .is_err()
+            );
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_bootstrap.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_bootstrap.rs
new file mode 100644
index 0000000000..ac50da55d1
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_bootstrap.rs
@@ -0,0 +1,570 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Authenticated compact cold-load image for recurrence artifacts.
+//!
+//! The image deliberately contains no copy of its own digest or the final
+//! artifact ID.  Generation encodes the staged payload inventory, publishes
+//! this image as one more ordinary evaluator-state payload, and lets normal
+//! artifact finalization bind the image digest into the artifact ID.  At load
+//! time the image record can therefore be reconstructed from the checked file
+//! itself without a self-hash cycle or a broad JSON-manifest parse. The
+//! authenticated image is the runtime authority for producer, process, and
+//! execution metadata; the outer manifest contributes only its canonical
+//! payload artifact ID on this deliberately narrow path.
+
+use super::*;
+use crate::artifact::{ArtifactRuntime, EvaluatorPayloadContainerExtension, Producer};
+use crate::{ArtifactProcess, Payload};
+use bincode::Decode;
+#[cfg(any(feature = "python-generation-bridge", test))]
+use bincode::Encode;
+#[cfg(feature = "python-generation-bridge")]
+use serde::Deserialize;
+use sha2::{Digest, Sha256};
+#[cfg(feature = "python-generation-bridge")]
+use std::path::PathBuf;
+
+pub(crate) const RECURRENCE_BOOTSTRAP_IMAGE_ABI: &str = "pyamplicol-recurrence-bootstrap-image-v1";
+const RECURRENCE_BOOTSTRAP_IMAGE_MAGIC: &[u8; 8] = b"PACRBIN1";
+const RECURRENCE_BOOTSTRAP_IMAGE_VERSION: u16 = 1;
+const RECURRENCE_BOOTSTRAP_IMAGE_SCHEMA_VERSION: u16 = 1;
+const RECURRENCE_BOOTSTRAP_IMAGE_HEADER_BYTES: usize = 64;
+
+#[cfg(feature = "python-generation-bridge")]
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct RecurrenceBootstrapBuildContextV1 {
+    schema_version: u16,
+    /// Private staging root used only while lowering the process-ready image.
+    /// It is deliberately not serialized into the artifact.
+    staged_root: PathBuf,
+    producer: Producer,
+    runtime: ArtifactRuntime,
+    process: ArtifactProcess,
+    payloads: Vec<Payload>,
+    evaluator_payload_container: EvaluatorPayloadContainerExtension,
+}
+
+/// Only the authenticated, operational pieces needed to reopen one direct
+/// recurrence plan.  The schedule PACBIN and process binding remain the sole
+/// authorities; this value is a source-digest-bound load recipe, not a second
+/// copy of the plan.
+#[derive(Clone, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub(super) struct RecurrenceReadyPlanV1 {
+    pub(super) runtime_schedule: RecurrenceRuntimeContainer,
+    pub(super) process_binding: RecurrenceProcessBinding,
+    pub(super) runtime_container_member: RecurrenceRuntimeContainerMember,
+    pub(super) color_projection_certificate: Option<RecurrenceColorProjectionCertificate>,
+    pub(super) helicity_dispatch: Option<RecurrenceHelicityDispatchReference>,
+}
+
+impl RecurrenceReadyPlanV1 {
+    #[cfg(feature = "python-generation-bridge")]
+    pub(super) fn from_summary(summary: &RecurrencePlanSummary) -> Self {
+        Self {
+            runtime_schedule: summary.runtime_schedule.clone(),
+            process_binding: summary.process_binding.clone(),
+            runtime_container_member: summary.inspection_summary.runtime_container_member.clone(),
+            color_projection_certificate: summary
+                .inspection_summary
+                .color_projection_certificate
+                .clone(),
+            helicity_dispatch: summary.helicity_dispatch.clone(),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub(super) enum RecurrenceReadySourceFamilyV1 {
+    Scalar,
+    WeylFermion,
+    DiracFermion,
+    Vector,
+    Spin2,
+}
+
+#[derive(Clone, Copy, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub(super) enum RecurrenceReadySourceOrientationV1 {
+    Particle,
+    Antiparticle,
+    SelfConjugate,
+}
+
+#[derive(Clone, Copy, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub(super) enum RecurrenceReadySourceKeyV1 {
+    SpinStateClass(i32),
+    RuntimeVariant {
+        source_row_id: u32,
+        runtime_variant_id: u32,
+    },
+}
+
+#[derive(Clone, Copy, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub(super) struct RecurrenceReadySourceTemplateV1 {
+    pub(super) spin_state_class: i32,
+    pub(super) family: RecurrenceReadySourceFamilyV1,
+    pub(super) orientation: RecurrenceReadySourceOrientationV1,
+    pub(super) helicity: i32,
+    pub(super) chirality: i32,
+    pub(super) mass_parameter_index: Option<u32>,
+}
+
+#[derive(Clone, Copy, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub(super) struct RecurrenceReadySourceVariantV1 {
+    pub(super) key: RecurrenceReadySourceKeyV1,
+    pub(super) template: RecurrenceReadySourceTemplateV1,
+}
+
+#[derive(Clone, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub(super) struct RecurrenceReadySourceDomainV1 {
+    pub(super) variants: Vec<RecurrenceReadySourceVariantV1>,
+}
+
+#[derive(Clone, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub(super) struct RecurrenceReadyRuntimeV1 {
+    pub(super) runtime_parameters: Vec<RecurrenceRuntimeParameter>,
+    pub(super) prepared_parameter_defaults: Vec<[f64; 2]>,
+    pub(super) parameter_projection: Vec<RecurrenceParameterProjection>,
+    pub(super) source_domains: Vec<RecurrenceReadySourceDomainV1>,
+    pub(super) external_is_initial: Vec<bool>,
+    pub(super) particle_masses: Vec<(i32, f64)>,
+    pub(super) particle_mass_parameter_names: Vec<(i32, String)>,
+    pub(super) normalization: RecurrenceNormalization,
+    /// Public physics-flow ordinal to the plan's construction sector.  This
+    /// cannot be reconstructed for folded all-flow schedules.
+    pub(super) public_flow_ids: Vec<u32>,
+    /// Public IDs in the same order, retained so the compact decoder checks
+    /// the sector mapping against the authenticated physics axis.
+    pub(super) public_flow_public_ids: Vec<String>,
+    pub(super) direct_helicity_to_physics: Vec<u64>,
+    pub(super) color_contraction: Option<RecurrenceColorContractionReference>,
+}
+
+#[derive(Clone, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub(super) struct RecurrenceReadyCompanionV1 {
+    pub(super) process_digest: String,
+    pub(super) plan: RecurrenceReadyPlanV1,
+    pub(super) source_domains: Vec<RecurrenceReadySourceDomainV1>,
+    pub(super) direct_helicity_to_physics: Vec<u64>,
+}
+
+#[derive(Clone, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub(crate) struct RecurrenceReadyExecutionV1 {
+    pub(super) schema_version: u16,
+    pub(super) required_runtime_capabilities: Vec<String>,
+    pub(super) process: String,
+    pub(super) key: String,
+    pub(super) color_accuracy: String,
+    pub(super) external_pdg_order: Vec<i32>,
+    pub(super) compiled_model_digest: String,
+    pub(super) recurrence_template_catalog_digest: String,
+    pub(super) prepared_kernel_pack_digest: String,
+    pub(super) direct_template_catalog_digest: String,
+    pub(super) kernel_pack: RecurrenceKernelPackReference,
+    pub(super) primary_plan: RecurrenceReadyPlanV1,
+    pub(super) runtime: RecurrenceReadyRuntimeV1,
+    pub(super) companion: Option<RecurrenceReadyCompanionV1>,
+}
+
+fn validate_ready_execution_outer(
+    ready: &RecurrenceReadyExecutionV1,
+    outer: &ArtifactProcess,
+) -> RusticolResult<()> {
+    if ready.schema_version != RECURRENCE_BOOTSTRAP_IMAGE_SCHEMA_VERSION
+        || ready.process != outer.expression
+        || ready.key != outer.id
+        || ready.color_accuracy != outer.color_accuracy
+        || ready.external_pdg_order != outer.external_pdgs
+    {
+        return Err(RusticolError::integrity(format!(
+            "recurrence process-ready recipe does not match outer process {:?}",
+            outer.id
+        )));
+    }
+    if ready.kernel_pack.manifest_path != RECURRENCE_KERNEL_PACK_MANIFEST_PATH
+        || ready.kernel_pack.payload_root != RECURRENCE_KERNEL_PAYLOAD_ROOT
+    {
+        return Err(RusticolError::security(
+            "recurrence process-ready recipe has non-canonical prepared-pack paths",
+        ));
+    }
+    for (label, digest) in [
+        ("compiled model", &ready.compiled_model_digest),
+        (
+            "recurrence-template catalog",
+            &ready.recurrence_template_catalog_digest,
+        ),
+        ("prepared-kernel pack", &ready.prepared_kernel_pack_digest),
+        (
+            "direct-template catalog",
+            &ready.direct_template_catalog_digest,
+        ),
+    ] {
+        if digest.len() != 64
+            || !digest
+                .bytes()
+                .all(|byte| byte.is_ascii_hexdigit() && !byte.is_ascii_uppercase())
+        {
+            return Err(RusticolError::integrity(format!(
+                "recurrence process-ready {label} digest is not canonical SHA-256"
+            )));
+        }
+    }
+    validate_capability_list_match(
+        &outer.required_runtime_capabilities,
+        &ready.required_runtime_capabilities,
+        "outer process and recurrence process-ready recipe",
+    )
+}
+
+#[derive(Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+struct RecurrenceBootstrapImageBodyV1 {
+    schema_version: u16,
+    producer: Producer,
+    runtime: ArtifactRuntime,
+    process: ArtifactProcess,
+    /// Ordinary payload declarations before this image is registered.
+    payloads: Vec<Payload>,
+    evaluator_payload_container: EvaluatorPayloadContainerExtension,
+    execution_path: String,
+    execution_sha256: String,
+    physics_path: String,
+    physics_sha256: String,
+    ready_execution: RecurrenceReadyExecutionV1,
+    physics_binary: Vec<u8>,
+}
+
+pub(crate) struct DecodedRecurrenceBootstrapV1 {
+    pub(crate) producer: Producer,
+    pub(crate) runtime: ArtifactRuntime,
+    pub(crate) process: ArtifactProcess,
+    pub(crate) payloads: Vec<Payload>,
+    pub(crate) evaluator_payload_container: EvaluatorPayloadContainerExtension,
+    pub(crate) execution_path: String,
+    pub(crate) execution_sha256: String,
+    pub(crate) physics_path: String,
+    pub(crate) physics_sha256: String,
+    pub(crate) ready_execution: RecurrenceReadyExecutionV1,
+    pub(crate) physics: ProcessPhysicsV1,
+}
+
+#[cfg(feature = "python-generation-bridge")]
+pub(crate) fn build_recurrence_bootstrap_image_v1(
+    context_json: &[u8],
+    execution_json: &[u8],
+    physics_json: &[u8],
+) -> RusticolResult<Vec<u8>> {
+    let context: RecurrenceBootstrapBuildContextV1 =
+        serde_json::from_slice(context_json).map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not parse recurrence bootstrap build context: {error}"
+            ))
+        })?;
+    if context.schema_version != RECURRENCE_BOOTSTRAP_IMAGE_SCHEMA_VERSION {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported recurrence bootstrap build-context schema {}; expected {}",
+            context.schema_version, RECURRENCE_BOOTSTRAP_IMAGE_SCHEMA_VERSION
+        )));
+    }
+    let execution_path = format!("processes/{}/execution.json", context.process.id);
+    let execution =
+        parse_recurrence_execution_manifest(execution_json, &execution_path, &context.process)?;
+    let physics_path = context.process.physics_path.clone();
+    let physics = ProcessPhysicsV1::from_json(physics_json, &physics_path)?;
+    validate_bootstrap_representative_physics(&physics, &context.process)?;
+    let execution_sha256 = require_build_source_payload(
+        &context.payloads,
+        &execution_path,
+        PayloadRole::EvaluatorManifest,
+        &context.process.id,
+        execution_json,
+    )?
+    .sha256
+    .clone();
+    let physics_sha256 = require_build_source_payload(
+        &context.payloads,
+        &physics_path,
+        PayloadRole::RuntimePhysics,
+        &context.process.id,
+        physics_json,
+    )?
+    .sha256
+    .clone();
+    let staged_artifact = crate::artifact::open_staged_recurrence_bootstrap_artifact(
+        context.staged_root,
+        context.producer.clone(),
+        context.runtime.clone(),
+        context.process.clone(),
+        context.payloads.clone(),
+        context.evaluator_payload_container.clone(),
+    )?;
+    let evaluator_root = staged_artifact
+        .root()
+        .join("processes")
+        .join(&context.process.id);
+    let ready_execution = build_recurrence_ready_execution_v1(
+        &staged_artifact,
+        &evaluator_root,
+        &execution,
+        &physics,
+    )?;
+    let body = RecurrenceBootstrapImageBodyV1 {
+        schema_version: RECURRENCE_BOOTSTRAP_IMAGE_SCHEMA_VERSION,
+        producer: context.producer,
+        runtime: context.runtime,
+        process: context.process,
+        payloads: context.payloads,
+        evaluator_payload_container: context.evaluator_payload_container,
+        execution_path,
+        execution_sha256,
+        physics_path,
+        physics_sha256,
+        ready_execution,
+        physics_binary: encode_recurrence_bootstrap_physics_v1(&physics)?,
+    };
+    encode_image_body(&body)
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+pub(crate) fn decode_recurrence_bootstrap_image_v1(
+    bytes: &[u8],
+) -> RusticolResult<DecodedRecurrenceBootstrapV1> {
+    let body_bytes = checked_image_body(bytes)?;
+    let (body, consumed): (RecurrenceBootstrapImageBodyV1, usize) =
+        bincode::decode_from_slice(body_bytes, bincode::config::standard()).map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not decode {RECURRENCE_BOOTSTRAP_IMAGE_ABI}: {error}"
+            ))
+        })?;
+    if consumed != body_bytes.len() {
+        return Err(RusticolError::serialization(format!(
+            "{RECURRENCE_BOOTSTRAP_IMAGE_ABI} contains {} trailing body bytes",
+            body_bytes.len() - consumed
+        )));
+    }
+    if body.schema_version != RECURRENCE_BOOTSTRAP_IMAGE_SCHEMA_VERSION {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported recurrence bootstrap body schema {}; expected {}",
+            body.schema_version, RECURRENCE_BOOTSTRAP_IMAGE_SCHEMA_VERSION
+        )));
+    }
+    let physics = decode_recurrence_bootstrap_physics_v1(&body.physics_binary)?;
+    validate_bootstrap_representative_physics(&physics, &body.process)?;
+    validate_ready_execution_outer(&body.ready_execution, &body.process)?;
+    Ok(DecodedRecurrenceBootstrapV1 {
+        producer: body.producer,
+        runtime: body.runtime,
+        process: body.process,
+        payloads: body.payloads,
+        evaluator_payload_container: body.evaluator_payload_container,
+        execution_path: body.execution_path,
+        execution_sha256: body.execution_sha256,
+        physics_path: body.physics_path,
+        physics_sha256: body.physics_sha256,
+        ready_execution: body.ready_execution,
+        physics,
+    })
+}
+
+#[cfg(feature = "python-generation-bridge")]
+fn require_build_source_payload<'a>(
+    payloads: &'a [Payload],
+    path: &str,
+    role: PayloadRole,
+    process_id: &str,
+    bytes: &[u8],
+) -> RusticolResult<&'a Payload> {
+    let payload = payloads
+        .iter()
+        .find(|payload| payload.path == path)
+        .ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "recurrence bootstrap source {path:?} is absent from the staged payload inventory"
+            ))
+        })?;
+    let size = u64::try_from(bytes.len()).map_err(|_| {
+        RusticolError::artifact(format!(
+            "recurrence bootstrap source {path:?} exceeds the u64 size domain"
+        ))
+    })?;
+    let digest = format!("{:x}", Sha256::digest(bytes));
+    if payload.role != role
+        || payload.media_type != "application/json"
+        || payload.process_id.as_deref() != Some(process_id)
+        || payload.executable
+        || payload.size_bytes != size
+        || payload.sha256 != digest
+    {
+        return Err(RusticolError::integrity(format!(
+            "recurrence bootstrap source {path:?} disagrees with its staged payload declaration"
+        )));
+    }
+    Ok(payload)
+}
+
+fn validate_bootstrap_representative_physics(
+    physics: &ProcessPhysicsV1,
+    process: &ArtifactProcess,
+) -> RusticolResult<()> {
+    if physics.process_id != process.id
+        || physics.process != process.expression
+        || physics.color_accuracy.as_str() != process.color_accuracy
+        || physics
+            .external_particles
+            .iter()
+            .map(|particle| particle.pdg)
+            .ne(process.external_pdgs.iter().copied())
+    {
+        return Err(RusticolError::integrity(format!(
+            "recurrence bootstrap physics does not match process {:?}",
+            process.id
+        )));
+    }
+    Ok(())
+}
+
+#[cfg(feature = "python-generation-bridge")]
+fn encode_image_body(body: &RecurrenceBootstrapImageBodyV1) -> RusticolResult<Vec<u8>> {
+    let encoded = bincode::encode_to_vec(body, bincode::config::standard()).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not encode {RECURRENCE_BOOTSTRAP_IMAGE_ABI}: {error}"
+        ))
+    })?;
+    let body_len = u64::try_from(encoded.len()).map_err(|_| {
+        RusticolError::artifact(format!(
+            "{RECURRENCE_BOOTSTRAP_IMAGE_ABI} body length exceeds u64"
+        ))
+    })?;
+    let total_len = RECURRENCE_BOOTSTRAP_IMAGE_HEADER_BYTES
+        .checked_add(encoded.len())
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "{RECURRENCE_BOOTSTRAP_IMAGE_ABI} total length overflows usize"
+            ))
+        })?;
+    let mut image = Vec::new();
+    image.try_reserve_exact(total_len).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not allocate {total_len} bytes for {RECURRENCE_BOOTSTRAP_IMAGE_ABI}: {error}"
+        ))
+    })?;
+    image.extend_from_slice(RECURRENCE_BOOTSTRAP_IMAGE_MAGIC);
+    image.extend_from_slice(&RECURRENCE_BOOTSTRAP_IMAGE_VERSION.to_le_bytes());
+    image.extend_from_slice(&0_u16.to_le_bytes());
+    image.extend_from_slice(&(RECURRENCE_BOOTSTRAP_IMAGE_HEADER_BYTES as u32).to_le_bytes());
+    image.extend_from_slice(&body_len.to_le_bytes());
+    image.extend_from_slice(&Sha256::digest(&encoded));
+    image.extend_from_slice(&[0_u8; 8]);
+    debug_assert_eq!(image.len(), RECURRENCE_BOOTSTRAP_IMAGE_HEADER_BYTES);
+    image.extend_from_slice(&encoded);
+    Ok(image)
+}
+
+fn checked_image_body(bytes: &[u8]) -> RusticolResult<&[u8]> {
+    let header = bytes
+        .get(..RECURRENCE_BOOTSTRAP_IMAGE_HEADER_BYTES)
+        .ok_or_else(|| {
+            RusticolError::serialization(format!(
+                "truncated {RECURRENCE_BOOTSTRAP_IMAGE_ABI} header"
+            ))
+        })?;
+    if header.get(..8) != Some(RECURRENCE_BOOTSTRAP_IMAGE_MAGIC.as_slice()) {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported recurrence bootstrap magic; expected {RECURRENCE_BOOTSTRAP_IMAGE_ABI}"
+        )));
+    }
+    let version = u16::from_le_bytes(header[8..10].try_into().expect("fixed version field"));
+    let flags = u16::from_le_bytes(header[10..12].try_into().expect("fixed flags field"));
+    let header_bytes = u32::from_le_bytes(
+        header[12..16]
+            .try_into()
+            .expect("fixed header-length field"),
+    );
+    if version != RECURRENCE_BOOTSTRAP_IMAGE_VERSION
+        || flags != 0
+        || header_bytes != RECURRENCE_BOOTSTRAP_IMAGE_HEADER_BYTES as u32
+        || header[56..64].iter().any(|byte| *byte != 0)
+    {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported {RECURRENCE_BOOTSTRAP_IMAGE_ABI} version/flags/header"
+        )));
+    }
+    let body_len = usize::try_from(u64::from_le_bytes(
+        header[16..24].try_into().expect("fixed body-length field"),
+    ))
+    .map_err(|_| {
+        RusticolError::artifact(format!(
+            "{RECURRENCE_BOOTSTRAP_IMAGE_ABI} body length exceeds usize"
+        ))
+    })?;
+    let expected_len = RECURRENCE_BOOTSTRAP_IMAGE_HEADER_BYTES
+        .checked_add(body_len)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "{RECURRENCE_BOOTSTRAP_IMAGE_ABI} length overflows usize"
+            ))
+        })?;
+    if bytes.len() != expected_len {
+        return Err(RusticolError::serialization(format!(
+            "{RECURRENCE_BOOTSTRAP_IMAGE_ABI} length is {}, expected {expected_len}",
+            bytes.len()
+        )));
+    }
+    let body = &bytes[RECURRENCE_BOOTSTRAP_IMAGE_HEADER_BYTES..];
+    if Sha256::digest(body).as_slice() != &header[24..56] {
+        return Err(RusticolError::integrity(format!(
+            "{RECURRENCE_BOOTSTRAP_IMAGE_ABI} body SHA-256 mismatch"
+        )));
+    }
+    Ok(body)
+}
+
+#[cfg(test)]
+mod image_tests {
+    use super::*;
+
+    fn framed(body: &[u8]) -> Vec<u8> {
+        let mut image = Vec::with_capacity(RECURRENCE_BOOTSTRAP_IMAGE_HEADER_BYTES + body.len());
+        image.extend_from_slice(RECURRENCE_BOOTSTRAP_IMAGE_MAGIC);
+        image.extend_from_slice(&RECURRENCE_BOOTSTRAP_IMAGE_VERSION.to_le_bytes());
+        image.extend_from_slice(&0_u16.to_le_bytes());
+        image.extend_from_slice(&(RECURRENCE_BOOTSTRAP_IMAGE_HEADER_BYTES as u32).to_le_bytes());
+        image.extend_from_slice(&(body.len() as u64).to_le_bytes());
+        image.extend_from_slice(&Sha256::digest(body));
+        image.extend_from_slice(&[0_u8; 8]);
+        image.extend_from_slice(body);
+        image
+    }
+
+    #[test]
+    fn outer_image_header_authenticates_body_and_exact_length() {
+        let image = framed(b"bincode-body");
+        assert_eq!(checked_image_body(&image).unwrap(), b"bincode-body");
+
+        let mut corrupted = image.clone();
+        *corrupted.last_mut().unwrap() ^= 1;
+        assert_eq!(
+            checked_image_body(&corrupted).unwrap_err().kind(),
+            crate::RusticolErrorKind::Integrity
+        );
+
+        let mut trailing = image;
+        trailing.push(0);
+        assert_eq!(
+            checked_image_body(&trailing).unwrap_err().kind(),
+            crate::RusticolErrorKind::Serialization
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_bootstrap_physics.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_bootstrap_physics.rs
new file mode 100644
index 0000000000..b2f2505754
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_bootstrap_physics.rs
@@ -0,0 +1,770 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Compact native image of recurrence process physics.
+//!
+//! This is an internal cold-load cache, not a stable interchange format.  The
+//! enclosing PACBIN member authenticates its bytes; this codec supplies an
+//! independently recognizable ABI, file-length checks, exact consumption, and
+//! the same semantic validation as the canonical JSON path.
+
+use crate::{
+    ColorAccuracy, ColorComponent, Coverage, ExternalParticle, Helicity, ModelParameter,
+    ProcessPhysics as ProcessPhysicsV1, Reduction, RusticolError, RusticolResult,
+    SelectorCapabilities,
+};
+use bincode::Decode;
+#[cfg(any(feature = "python-generation-bridge", test))]
+use bincode::Encode;
+use bincode::de::{Decoder, read::Reader};
+use bincode::error::{AllowedEnumVariants, DecodeError};
+use serde_json::{Map as JsonMap, Number as JsonNumber, Value as JsonValue};
+use std::collections::BTreeMap;
+
+/// Native, internal serialization ABI for one already-resolved physics image.
+/// Artifacts carrying this image must be regenerated when this wire domain
+/// changes.
+pub(super) const RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI: &str =
+    "pyamplicol-recurrence-bootstrap-physics-v1";
+
+const RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_MAGIC: &[u8; 8] = b"PACRPHM1";
+const RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_VERSION: u16 = 1;
+const RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_HEADER_BYTES: usize = 16;
+
+// serde_json's ordinary parser rejects nesting beyond 128 levels.  Apply the
+// same bound to the native representation so a recursive Decode cannot be used
+// to exhaust the stack.
+const COMPACT_JSON_MAX_DEPTH: usize = 128;
+
+#[derive(Clone, Debug, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[bincode(decode_context = "CompactJsonDecodeContext")]
+struct RecurrenceBootstrapPhysicsV1 {
+    schema_version: u32,
+    kind: String,
+    process_id: String,
+    process: String,
+    color_accuracy: ColorAccuracy,
+    coverage: Coverage,
+    external_particles: Vec<ExternalParticle>,
+    helicities: Vec<Helicity>,
+    color_components: Vec<ColorComponent>,
+    reduction: Reduction,
+    model_parameters: Vec<ModelParameter>,
+    selectors: SelectorCapabilities,
+    extensions: CompactJsonObject,
+}
+
+impl RecurrenceBootstrapPhysicsV1 {
+    #[cfg(any(feature = "python-generation-bridge", test))]
+    fn from_physics(physics: &ProcessPhysicsV1) -> RusticolResult<Self> {
+        Ok(Self {
+            schema_version: physics.schema_version,
+            kind: physics.kind.clone(),
+            process_id: physics.process_id.clone(),
+            process: physics.process.clone(),
+            color_accuracy: physics.color_accuracy,
+            coverage: physics.coverage.clone(),
+            external_particles: physics.external_particles.clone(),
+            helicities: physics.helicities.clone(),
+            color_components: physics.color_components.clone(),
+            reduction: physics.reduction.clone(),
+            model_parameters: physics.model_parameters.clone(),
+            selectors: physics.selectors.clone(),
+            extensions: CompactJsonObject::from_extensions(&physics.extensions)?,
+        })
+    }
+
+    fn into_physics(self) -> RusticolResult<ProcessPhysicsV1> {
+        Ok(ProcessPhysicsV1 {
+            schema_version: self.schema_version,
+            kind: self.kind,
+            process_id: self.process_id,
+            process: self.process,
+            color_accuracy: self.color_accuracy,
+            coverage: self.coverage,
+            external_particles: self.external_particles,
+            helicities: self.helicities,
+            color_components: self.color_components,
+            reduction: self.reduction,
+            model_parameters: self.model_parameters,
+            selectors: self.selectors,
+            extensions: self.extensions.into_extensions()?,
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+struct CompactJsonObject(Vec<(String, CompactJsonValue)>);
+
+impl CompactJsonObject {
+    #[cfg(any(feature = "python-generation-bridge", test))]
+    fn from_extensions(extensions: &BTreeMap<String, JsonValue>) -> RusticolResult<Self> {
+        Self::from_entries(extensions.iter(), 0)
+    }
+
+    #[cfg(any(feature = "python-generation-bridge", test))]
+    fn from_json_map(values: &JsonMap<String, JsonValue>, depth: usize) -> RusticolResult<Self> {
+        Self::from_entries(values.iter(), depth)
+    }
+
+    #[cfg(any(feature = "python-generation-bridge", test))]
+    fn from_entries<'a>(
+        entries: impl ExactSizeIterator<Item = (&'a String, &'a JsonValue)>,
+        depth: usize,
+    ) -> RusticolResult<Self> {
+        let mut compact = Vec::new();
+        compact.try_reserve_exact(entries.len()).map_err(|error| {
+            compact_json_bound_error(format!("could not allocate compact JSON object: {error}"))
+        })?;
+        for (key, value) in entries {
+            compact.push((key.clone(), CompactJsonValue::from_json(value, depth)?));
+        }
+        compact.sort_unstable_by(|left, right| left.0.cmp(&right.0));
+        Ok(Self(compact))
+    }
+
+    fn into_extensions(self) -> RusticolResult<BTreeMap<String, JsonValue>> {
+        let mut extensions = BTreeMap::new();
+        for (key, value) in self.0 {
+            if extensions.insert(key, value.into_json()?).is_some() {
+                return Err(RusticolError::integrity(
+                    "compact recurrence physics extensions contain a duplicate key",
+                ));
+            }
+        }
+        Ok(extensions)
+    }
+
+    fn into_json_map(self) -> RusticolResult<JsonMap<String, JsonValue>> {
+        let mut values = JsonMap::new();
+        for (key, value) in self.0 {
+            if values.insert(key, value.into_json()?).is_some() {
+                return Err(RusticolError::integrity(
+                    "compact recurrence physics JSON object contains a duplicate key",
+                ));
+            }
+        }
+        Ok(values)
+    }
+}
+
+impl Decode<CompactJsonDecodeContext> for CompactJsonObject {
+    fn decode<D: Decoder<Context = CompactJsonDecodeContext>>(
+        decoder: &mut D,
+    ) -> Result<Self, DecodeError> {
+        let len = decode_compact_json_length(decoder, "object")?;
+        decoder.claim_container_read::<(String, CompactJsonValue)>(len)?;
+        let mut entries = Vec::new();
+        entries.try_reserve_exact(len).map_err(|error| {
+            DecodeError::OtherString(format!("could not allocate compact JSON object: {error}"))
+        })?;
+        for _ in 0..len {
+            decoder.unclaim_bytes_read(std::mem::size_of::<(String, CompactJsonValue)>());
+            let key = decode_compact_json_string(decoder, "object key")?;
+            if entries
+                .last()
+                .is_some_and(|(previous, _): &(String, CompactJsonValue)| previous >= &key)
+            {
+                return Err(DecodeError::Other(
+                    "compact JSON object keys must be unique and strictly ordered",
+                ));
+            }
+            let value = CompactJsonValue::decode(decoder)?;
+            entries.push((key, value));
+        }
+        Ok(Self(entries))
+    }
+}
+
+bincode::impl_borrow_decode_with_context!(CompactJsonObject, CompactJsonDecodeContext);
+
+#[derive(Clone, Debug)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+enum CompactJsonValue {
+    Null,
+    Bool(bool),
+    U64(u64),
+    I64(i64),
+    F64Bits(u64),
+    String(String),
+    Array(Vec<Self>),
+    Object(CompactJsonObject),
+}
+
+impl CompactJsonValue {
+    #[cfg(any(feature = "python-generation-bridge", test))]
+    fn from_json(value: &JsonValue, depth: usize) -> RusticolResult<Self> {
+        if depth > COMPACT_JSON_MAX_DEPTH {
+            return Err(compact_json_bound_error(format!(
+                "nesting exceeds the {COMPACT_JSON_MAX_DEPTH}-level limit"
+            )));
+        }
+        match value {
+            JsonValue::Null => Ok(Self::Null),
+            JsonValue::Bool(value) => Ok(Self::Bool(*value)),
+            JsonValue::Number(value) if value.is_u64() => Ok(Self::U64(
+                value.as_u64().expect("u64 classification checked"),
+            )),
+            JsonValue::Number(value) if value.is_i64() => Ok(Self::I64(
+                value.as_i64().expect("i64 classification checked"),
+            )),
+            JsonValue::Number(value) => {
+                let value = value.as_f64().ok_or_else(|| {
+                    RusticolError::artifact(
+                        "compact recurrence physics extension has an unsupported JSON number",
+                    )
+                })?;
+                if !value.is_finite() {
+                    return Err(RusticolError::artifact(
+                        "compact recurrence physics extension has a non-finite JSON number",
+                    ));
+                }
+                Ok(Self::F64Bits(value.to_bits()))
+            }
+            JsonValue::String(value) => Ok(Self::String(value.clone())),
+            JsonValue::Array(values) => {
+                let mut compact = Vec::new();
+                compact.try_reserve_exact(values.len()).map_err(|error| {
+                    compact_json_bound_error(format!(
+                        "could not allocate compact JSON array: {error}"
+                    ))
+                })?;
+                for value in values {
+                    compact.push(Self::from_json(value, depth + 1)?);
+                }
+                Ok(Self::Array(compact))
+            }
+            JsonValue::Object(values) => Ok(Self::Object(CompactJsonObject::from_json_map(
+                values,
+                depth + 1,
+            )?)),
+        }
+    }
+
+    fn into_json(self) -> RusticolResult<JsonValue> {
+        match self {
+            Self::Null => Ok(JsonValue::Null),
+            Self::Bool(value) => Ok(JsonValue::Bool(value)),
+            Self::U64(value) => Ok(JsonValue::Number(JsonNumber::from(value))),
+            Self::I64(value) => Ok(JsonValue::Number(JsonNumber::from(value))),
+            Self::F64Bits(bits) => {
+                let value = f64::from_bits(bits);
+                let number = JsonNumber::from_f64(value).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "compact recurrence physics extension contains a non-finite JSON number",
+                    )
+                })?;
+                Ok(JsonValue::Number(number))
+            }
+            Self::String(value) => Ok(JsonValue::String(value)),
+            Self::Array(values) => values
+                .into_iter()
+                .map(Self::into_json)
+                .collect::<RusticolResult<Vec<_>>>()
+                .map(JsonValue::Array),
+            Self::Object(values) => values.into_json_map().map(JsonValue::Object),
+        }
+    }
+}
+
+impl Decode<CompactJsonDecodeContext> for CompactJsonValue {
+    fn decode<D: Decoder<Context = CompactJsonDecodeContext>>(
+        decoder: &mut D,
+    ) -> Result<Self, DecodeError> {
+        {
+            let context = decoder.context();
+            if context.depth > COMPACT_JSON_MAX_DEPTH {
+                return Err(DecodeError::Other(
+                    "compact JSON nesting exceeds its depth limit",
+                ));
+            }
+            if context.nodes_remaining == 0 {
+                return Err(DecodeError::Other(
+                    "compact JSON node count cannot fit in the encoded payload",
+                ));
+            }
+            context.nodes_remaining -= 1;
+        }
+
+        let variant = <u32 as Decode<CompactJsonDecodeContext>>::decode(decoder)?;
+        match variant {
+            0 => Ok(Self::Null),
+            1 => bool::decode(decoder).map(Self::Bool),
+            2 => u64::decode(decoder).map(Self::U64),
+            3 => i64::decode(decoder).map(Self::I64),
+            4 => {
+                let bits = u64::decode(decoder)?;
+                if !f64::from_bits(bits).is_finite() {
+                    return Err(DecodeError::Other("compact JSON number must be finite"));
+                }
+                Ok(Self::F64Bits(bits))
+            }
+            5 => decode_compact_json_string(decoder, "string").map(Self::String),
+            6 => decode_compact_json_children(decoder).map(Self::Array),
+            7 => decode_compact_json_object(decoder).map(Self::Object),
+            found => Err(DecodeError::UnexpectedVariant {
+                type_name: "CompactJsonValue",
+                allowed: &COMPACT_JSON_ALLOWED_VARIANTS,
+                found,
+            }),
+        }
+    }
+}
+
+bincode::impl_borrow_decode_with_context!(CompactJsonValue, CompactJsonDecodeContext);
+
+static COMPACT_JSON_ALLOWED_VARIANTS: AllowedEnumVariants =
+    AllowedEnumVariants::Range { min: 0, max: 7 };
+
+#[derive(Clone, Copy, Debug)]
+struct CompactJsonDecodeContext {
+    depth: usize,
+    payload_bytes: usize,
+    nodes_remaining: usize,
+}
+
+impl CompactJsonDecodeContext {
+    fn new(payload_bytes: usize) -> Self {
+        Self {
+            depth: 0,
+            payload_bytes,
+            // Each node needs at least one encoded variant byte.
+            nodes_remaining: payload_bytes,
+        }
+    }
+}
+
+fn decode_compact_json_children<D: Decoder<Context = CompactJsonDecodeContext>>(
+    decoder: &mut D,
+) -> Result<Vec<CompactJsonValue>, DecodeError> {
+    let len = decode_compact_json_length(decoder, "array")?;
+    decoder.claim_container_read::<CompactJsonValue>(len)?;
+    let mut values = Vec::new();
+    values.try_reserve_exact(len).map_err(|error| {
+        DecodeError::OtherString(format!("could not allocate compact JSON array: {error}"))
+    })?;
+    let previous_depth = decoder.context().depth;
+    decoder.context().depth = previous_depth + 1;
+    let result = (|| {
+        for _ in 0..len {
+            decoder.unclaim_bytes_read(std::mem::size_of::<CompactJsonValue>());
+            values.push(CompactJsonValue::decode(decoder)?);
+        }
+        Ok(values)
+    })();
+    decoder.context().depth = previous_depth;
+    result
+}
+
+fn decode_compact_json_object<D: Decoder<Context = CompactJsonDecodeContext>>(
+    decoder: &mut D,
+) -> Result<CompactJsonObject, DecodeError> {
+    let previous_depth = decoder.context().depth;
+    decoder.context().depth = previous_depth + 1;
+    let result = CompactJsonObject::decode(decoder);
+    decoder.context().depth = previous_depth;
+    result
+}
+
+fn decode_compact_json_length<D: Decoder<Context = CompactJsonDecodeContext>>(
+    decoder: &mut D,
+    description: &str,
+) -> Result<usize, DecodeError> {
+    let wire_len = u64::decode(decoder)?;
+    let len = usize::try_from(wire_len).map_err(|_| DecodeError::OutsideUsizeRange(wire_len))?;
+    if len > decoder.context().payload_bytes {
+        return Err(DecodeError::OtherString(format!(
+            "compact JSON {description} count {len} cannot fit in the encoded payload"
+        )));
+    }
+    Ok(len)
+}
+
+fn decode_compact_json_string<D: Decoder<Context = CompactJsonDecodeContext>>(
+    decoder: &mut D,
+    description: &str,
+) -> Result<String, DecodeError> {
+    let wire_len = u64::decode(decoder)?;
+    let len = usize::try_from(wire_len).map_err(|_| DecodeError::OutsideUsizeRange(wire_len))?;
+    if len > decoder.context().payload_bytes {
+        return Err(DecodeError::OtherString(format!(
+            "compact JSON {description} length {len} cannot fit in the encoded payload"
+        )));
+    }
+    decoder.claim_bytes_read(len)?;
+    let mut bytes = Vec::new();
+    bytes.try_reserve_exact(len).map_err(|error| {
+        DecodeError::OtherString(format!(
+            "could not allocate compact JSON {description}: {error}"
+        ))
+    })?;
+    bytes.resize(len, 0);
+    decoder.reader().read(&mut bytes)?;
+    String::from_utf8(bytes).map_err(|error| DecodeError::Utf8 {
+        inner: error.utf8_error(),
+    })
+}
+
+#[cfg(any(feature = "python-generation-bridge", test))]
+fn compact_json_bound_error(detail: impl std::fmt::Display) -> RusticolError {
+    RusticolError::artifact(format!(
+        "compact recurrence physics extension exceeds its bounds: {detail}"
+    ))
+}
+
+/// Encode one typed physics payload for the native recurrence bootstrap.
+#[cfg(any(feature = "python-generation-bridge", test))]
+pub(super) fn encode_recurrence_bootstrap_physics_v1(
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<Vec<u8>> {
+    let wire = RecurrenceBootstrapPhysicsV1::from_physics(physics)?;
+    encode_recurrence_bootstrap_physics_wire_v1(&wire)
+}
+
+#[cfg(any(feature = "python-generation-bridge", test))]
+fn encode_recurrence_bootstrap_physics_wire_v1(
+    physics: &RecurrenceBootstrapPhysicsV1,
+) -> RusticolResult<Vec<u8>> {
+    let body = bincode::encode_to_vec(physics, bincode::config::standard()).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not encode {RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI}: {error}"
+        ))
+    })?;
+    let body_len = u32::try_from(body.len()).map_err(|_| {
+        RusticolError::artifact(format!(
+            "{RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI} body length exceeds its u32 wire domain"
+        ))
+    })?;
+    let encoded_len = RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_HEADER_BYTES
+        .checked_add(body.len())
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "{RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI} encoded length overflows usize"
+            ))
+        })?;
+    let mut encoded = Vec::new();
+    encoded.try_reserve_exact(encoded_len).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not allocate {encoded_len} bytes for {RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI}: {error}"
+        ))
+    })?;
+    encoded.extend_from_slice(RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_MAGIC);
+    encoded.extend_from_slice(&RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_VERSION.to_le_bytes());
+    encoded.extend_from_slice(&0_u16.to_le_bytes());
+    encoded.extend_from_slice(&body_len.to_le_bytes());
+    encoded.extend_from_slice(&body);
+    Ok(encoded)
+}
+
+/// Decode and semantically validate one native recurrence physics
+/// payload. Exact consumption is part of the ABI.
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+pub(super) fn decode_recurrence_bootstrap_physics_v1(
+    bytes: &[u8],
+) -> RusticolResult<ProcessPhysicsV1> {
+    let header = bytes
+        .get(..RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_HEADER_BYTES)
+        .ok_or_else(|| {
+            RusticolError::serialization(format!(
+                "truncated {RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI} header"
+            ))
+        })?;
+    if header.get(..8) != Some(RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_MAGIC.as_slice()) {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported recurrence physics binary magic; expected {RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI}"
+        )));
+    }
+    let version = u16::from_le_bytes(
+        header[8..10]
+            .try_into()
+            .expect("fixed recurrence physics version field"),
+    );
+    if version != RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_VERSION {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported recurrence physics binary version {version}; expected {RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_VERSION}"
+        )));
+    }
+    let reserved = u16::from_le_bytes(
+        header[10..12]
+            .try_into()
+            .expect("fixed recurrence physics reserved field"),
+    );
+    if reserved != 0 {
+        return Err(RusticolError::compatibility(
+            "recurrence physics binary reserved flags must be zero",
+        ));
+    }
+    let declared_body_len = usize::try_from(u32::from_le_bytes(
+        header[12..16]
+            .try_into()
+            .expect("fixed recurrence physics length field"),
+    ))
+    .map_err(|_| {
+        RusticolError::artifact(format!(
+            "{RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI} body length exceeds usize"
+        ))
+    })?;
+    let expected_len = RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_HEADER_BYTES
+        .checked_add(declared_body_len)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "{RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI} declared length overflows usize"
+            ))
+        })?;
+    if bytes.len() != expected_len {
+        return Err(RusticolError::serialization(format!(
+            "{RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI} payload length is {}, expected {expected_len}",
+            bytes.len(),
+        )));
+    }
+
+    let body = &bytes[RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_HEADER_BYTES..];
+    let (wire, consumed): (RecurrenceBootstrapPhysicsV1, usize) =
+        bincode::decode_from_slice_with_context(
+            body,
+            bincode::config::standard(),
+            CompactJsonDecodeContext::new(body.len()),
+        )
+        .map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not decode {RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI}: {error}"
+            ))
+        })?;
+    if consumed != body.len() {
+        return Err(RusticolError::serialization(format!(
+            "{RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_ABI} contains {} trailing bytes",
+            body.len() - consumed,
+        )));
+    }
+    let physics = wire.into_physics()?;
+    physics.validate()?;
+    Ok(physics)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        ColorAccuracy, ColorComponent, ContractedColor, Coverage, ExternalParticle, Helicity,
+        ModelParameter, ParameterKind, ParticleRole, RUNTIME_PHYSICS_SCHEMA_VERSION, Reduction,
+        ReductionGroup, ReductionKind, SelectorCapabilities,
+    };
+    use serde_json::json;
+
+    fn physics_fixture() -> ProcessPhysicsV1 {
+        let mut extensions = BTreeMap::new();
+        extensions.insert("array".to_owned(), json!([null, true, {"nested": [1, 2]}]));
+        extensions.insert("float".to_owned(), json!(0.125));
+        extensions.insert("i64".to_owned(), json!(i64::MIN));
+        extensions.insert("negative_zero".to_owned(), json!(-0.0));
+        extensions.insert("string".to_owned(), json!("extension text"));
+        extensions.insert("u64".to_owned(), json!(u64::MAX));
+
+        ProcessPhysicsV1 {
+            schema_version: RUNTIME_PHYSICS_SCHEMA_VERSION,
+            kind: "pyamplicol-resolved-physics".to_owned(),
+            process_id: "p0".to_owned(),
+            process: "a b > c".to_owned(),
+            color_accuracy: ColorAccuracy::Full,
+            coverage: Coverage {
+                helicities: "complete".to_owned(),
+                color: "contracted".to_owned(),
+                color_kind: "contracted-color".to_owned(),
+                structural_zero_helicity_count: 0,
+            },
+            external_particles: (0..3)
+                .map(|index| ExternalParticle {
+                    index,
+                    label: index + 1,
+                    particle: format!("particle-{index}"),
+                    pdg: index as i32 + 1,
+                    role: if index < 2 {
+                        ParticleRole::Initial
+                    } else {
+                        ParticleRole::Final
+                    },
+                    momentum_slot: index,
+                    momentum_components: [
+                        "E".to_owned(),
+                        "px".to_owned(),
+                        "py".to_owned(),
+                        "pz".to_owned(),
+                    ],
+                })
+                .collect(),
+            helicities: vec![Helicity {
+                id: "helicity:0".to_owned(),
+                index: 0,
+                values: vec![1, -1, 1],
+                computed: true,
+                structural_zero: false,
+                representative_id: "helicity:0".to_owned(),
+                coefficient: 1.0,
+            }],
+            color_components: vec![ColorComponent::ContractedColor(ContractedColor {
+                id: "contracted".to_owned(),
+                index: 0,
+                description: "coherent contracted color".to_owned(),
+            })],
+            reduction: Reduction {
+                kind: ReductionKind::ContractedColor,
+                groups: vec![ReductionGroup {
+                    id: "group:0".to_owned(),
+                    representative_helicity_id: "helicity:0".to_owned(),
+                    representative_color_id: "contracted".to_owned(),
+                    physical_helicity_ids: vec!["helicity:0".to_owned()],
+                    physical_color_ids: vec!["contracted".to_owned()],
+                }],
+            },
+            model_parameters: vec![ModelParameter {
+                name: "coupling".to_owned(),
+                kind: ParameterKind::Coupling,
+                default_real: f64::from_bits(0x3fdd_8fdb_d004_403d),
+                default_imaginary: -0.0,
+                mutable: true,
+            }],
+            selectors: SelectorCapabilities {
+                helicity: true,
+                color_flow: false,
+                contracted_color: false,
+            },
+            extensions,
+        }
+    }
+
+    #[test]
+    fn compact_recurrence_physics_round_trips_every_json_value_exactly() {
+        let physics = physics_fixture();
+        physics.validate().expect("valid physics fixture");
+        let encoded = encode_recurrence_bootstrap_physics_v1(&physics)
+            .expect("encode compact recurrence physics");
+        assert_eq!(
+            encoded.get(..8),
+            Some(RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_MAGIC.as_slice())
+        );
+
+        let decoded = decode_recurrence_bootstrap_physics_v1(&encoded)
+            .expect("decode compact recurrence physics");
+        assert_eq!(decoded, physics);
+        assert_eq!(
+            decoded.extensions["negative_zero"]
+                .as_f64()
+                .expect("negative zero number")
+                .to_bits(),
+            (-0.0_f64).to_bits()
+        );
+        assert_eq!(
+            encode_recurrence_bootstrap_physics_v1(&decoded)
+                .expect("deterministic compact recurrence physics re-encode"),
+            encoded
+        );
+    }
+
+    #[test]
+    fn compact_recurrence_physics_rejects_format_extensions_and_oversize() {
+        let encoded = encode_recurrence_bootstrap_physics_v1(&physics_fixture())
+            .expect("encode compact recurrence physics");
+
+        let mut future_version = encoded.clone();
+        future_version[8..10]
+            .copy_from_slice(&(RECURRENCE_BOOTSTRAP_PHYSICS_BINARY_VERSION + 1).to_le_bytes());
+        assert!(
+            decode_recurrence_bootstrap_physics_v1(&future_version)
+                .unwrap_err()
+                .message()
+                .contains("version")
+        );
+
+        let mut future_flags = encoded.clone();
+        future_flags[10..12].copy_from_slice(&1_u16.to_le_bytes());
+        assert!(
+            decode_recurrence_bootstrap_physics_v1(&future_flags)
+                .unwrap_err()
+                .message()
+                .contains("reserved")
+        );
+
+        let mut trailing_body = encoded.clone();
+        let body_len = u32::from_le_bytes(trailing_body[12..16].try_into().unwrap());
+        trailing_body[12..16].copy_from_slice(&(body_len + 1).to_le_bytes());
+        trailing_body.push(0);
+        assert!(
+            decode_recurrence_bootstrap_physics_v1(&trailing_body)
+                .unwrap_err()
+                .message()
+                .contains("trailing")
+        );
+
+        let mut oversized = encoded;
+        oversized[12..16].copy_from_slice(&u32::MAX.to_le_bytes());
+        assert!(
+            decode_recurrence_bootstrap_physics_v1(&oversized)
+                .unwrap_err()
+                .message()
+                .contains("payload length")
+        );
+    }
+
+    #[test]
+    fn compact_recurrence_physics_rejects_noncanonical_and_deep_extensions() {
+        let mut wire = RecurrenceBootstrapPhysicsV1::from_physics(&physics_fixture())
+            .expect("construct compact recurrence physics");
+        wire.extensions = CompactJsonObject(vec![
+            ("z".to_owned(), CompactJsonValue::Null),
+            ("a".to_owned(), CompactJsonValue::Null),
+        ]);
+        let encoded = encode_recurrence_bootstrap_physics_wire_v1(&wire)
+            .expect("encode noncanonical compact object");
+        assert!(
+            decode_recurrence_bootstrap_physics_v1(&encoded)
+                .unwrap_err()
+                .message()
+                .contains("strictly ordered")
+        );
+
+        let mut value = CompactJsonValue::Null;
+        for _ in 0..=COMPACT_JSON_MAX_DEPTH {
+            value = CompactJsonValue::Array(vec![value]);
+        }
+        wire.extensions = CompactJsonObject(vec![("deep".to_owned(), value)]);
+        let encoded = encode_recurrence_bootstrap_physics_wire_v1(&wire)
+            .expect("encode over-deep compact extension");
+        assert!(
+            decode_recurrence_bootstrap_physics_v1(&encoded)
+                .unwrap_err()
+                .message()
+                .contains("depth")
+        );
+    }
+
+    #[test]
+    fn compact_recurrence_physics_revalidates_typed_semantics_and_numbers() {
+        let mut wire = RecurrenceBootstrapPhysicsV1::from_physics(&physics_fixture())
+            .expect("construct compact recurrence physics");
+        wire.process.clear();
+        let encoded = encode_recurrence_bootstrap_physics_wire_v1(&wire)
+            .expect("encode invalid compact recurrence physics");
+        assert!(
+            decode_recurrence_bootstrap_physics_v1(&encoded)
+                .unwrap_err()
+                .message()
+                .contains("invalid process")
+        );
+
+        wire.process = "a b > c".to_owned();
+        wire.extensions = CompactJsonObject(vec![(
+            "nan".to_owned(),
+            CompactJsonValue::F64Bits(f64::NAN.to_bits()),
+        )]);
+        let encoded = encode_recurrence_bootstrap_physics_wire_v1(&wire)
+            .expect("encode non-finite compact JSON number");
+        assert!(
+            decode_recurrence_bootstrap_physics_v1(&encoded)
+                .unwrap_err()
+                .message()
+                .contains("finite")
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_integration_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_integration_tests.rs
new file mode 100644
index 0000000000..9397f34647
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_integration_tests.rs
@@ -0,0 +1,253 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Opt-in generated-artifact smoke tests for the recurrence execution lane.
+
+use super::*;
+
+fn assert_close(actual: f64, expected: f64, context: &str) {
+    let tolerance = 1.0e-15 + 1.0e-12 * expected.abs();
+    assert!(
+        (actual - expected).abs() <= tolerance,
+        "{context}: {actual:.17e} != {expected:.17e}"
+    );
+}
+
+#[cfg(feature = "f64-symjit")]
+fn generated_recurrence_validation_point(runtime: &NativeRuntime) -> Vec<[f64; 4]> {
+    let validation_path = runtime
+        .root()
+        .join("processes")
+        .join(&runtime.metadata().representative_process_key)
+        .join("validation-momenta.json");
+    let validation: Value = serde_json::from_slice(
+        &fs::read(&validation_path).expect("read recurrence validation momenta"),
+    )
+    .expect("parse recurrence validation momenta");
+    validation["points"][0]
+        .as_array()
+        .expect("one recurrence validation point")
+        .iter()
+        .map(|leg| {
+            let components = leg["momentum"]
+                .as_array()
+                .expect("four momentum components");
+            assert_eq!(
+                components.len(),
+                4,
+                "recurrence momentum has four components"
+            );
+            std::array::from_fn(|index| {
+                components[index]
+                    .as_str()
+                    .expect("decimal momentum string")
+                    .parse::<f64>()
+                    .expect("f64 validation momentum")
+            })
+        })
+        .collect()
+}
+
+#[cfg(feature = "f64-symjit")]
+fn assert_zero_recurrence_direct_boundary_traffic(profile: &RuntimeProfile, context: &str) {
+    for (label, observed) in [
+        (
+            "legacy packed input bytes",
+            profile.recurrence_direct_packed_input_bytes,
+        ),
+        (
+            "legacy packed output bytes",
+            profile.recurrence_direct_packed_output_bytes,
+        ),
+        (
+            "legacy scatter bytes",
+            profile.recurrence_direct_scatter_bytes,
+        ),
+        (
+            "packet input bytes",
+            profile.recurrence_direct_packet_input_bytes,
+        ),
+        (
+            "packet output bytes",
+            profile.recurrence_direct_packet_output_bytes,
+        ),
+        ("gather bytes", profile.recurrence_direct_gather_bytes),
+        (
+            "traffic scatter bytes",
+            profile.recurrence_direct_traffic_scatter_bytes,
+        ),
+        ("remap bytes", profile.recurrence_direct_remap_bytes),
+    ] {
+        assert_eq!(observed, 0, "{context}: {label}");
+    }
+    profile
+        .validate_recurrence_direct_boundary_traffic()
+        .unwrap_or_else(|error| panic!("{context}: {error}"));
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn generated_recurrence_artifact_loads_when_fixture_is_supplied() {
+    let Some(root) = std::env::var_os("RUSTICOL_RECURRENCE_ARTIFACT") else {
+        return;
+    };
+    let mut runtime = NativeRuntime::load(PathBuf::from(root), None, None)
+        .expect("load generated recurrence artifact through NativeRuntime");
+    assert_eq!(runtime.metadata().execution_mode, "recurrence");
+
+    let point = generated_recurrence_validation_point(&runtime);
+    let momenta = point
+        .iter()
+        .flat_map(|momentum| momentum.iter().copied())
+        .collect::<Vec<_>>();
+
+    let values = runtime
+        .evaluate_f64(&momenta, 1)
+        .expect("evaluate generated recurrence artifact");
+    assert_eq!(values.len(), 1);
+    assert!(values[0].is_finite());
+    let mut direct_values = [f64::NAN];
+    runtime
+        .evaluate_f64_into(&momenta, 1, &mut direct_values)
+        .expect("evaluate generated recurrence artifact into caller storage");
+    assert_close(
+        direct_values[0],
+        values[0],
+        "recurrence direct-output total",
+    );
+
+    let resolved = runtime
+        .evaluate_resolved_f64(&momenta, 1, None, None)
+        .expect("resolve generated recurrence artifact");
+    assert_eq!(resolved.point_count, 1);
+    assert_close(resolved.totals()[0], values[0], "recurrence resolved sum");
+
+    let selected_color = runtime
+        .color_ids()
+        .expect("recurrence color metadata")
+        .into_iter()
+        .next()
+        .expect("one recurrence color component");
+    let selected = runtime
+        .evaluate_resolved_f64(
+            &momenta,
+            1,
+            None,
+            Some(std::slice::from_ref(&selected_color)),
+        )
+        .expect("select recurrence color component");
+    assert_eq!(selected.color_ids, [selected_color]);
+    assert!(selected.values.iter().all(|value| value.is_finite()));
+    let selected_total = runtime
+        .evaluate_f64_with_selectors(&momenta, 1, None, Some(&selected.color_ids), None, None)
+        .expect("evaluate selected recurrence color component");
+    assert_close(
+        selected_total[0],
+        selected.totals()[0],
+        "recurrence selected color total",
+    );
+    let mut selected_direct = [f64::NAN];
+    runtime
+        .evaluate_f64_into_with_selectors(
+            &momenta,
+            1,
+            None,
+            Some(&selected.color_ids),
+            None,
+            None,
+            &mut selected_direct,
+        )
+        .expect("evaluate selected recurrence component into caller storage");
+    assert_close(
+        selected_direct[0],
+        selected_total[0],
+        "recurrence selected direct-output total",
+    );
+}
+
+#[cfg(feature = "f64-symjit")]
+#[test]
+fn generated_recurrence_odd_tails_report_zero_direct_boundary_traffic_when_fixtures_are_supplied() {
+    const ODD_TAIL_POINT_COUNTS: [usize; 4] = [127, 129, 1023, 1025];
+    const FIXTURES: [(&str, &str); 2] = [
+        (
+            "RUSTICOL_RECURRENCE_TOPOLOGY_ALLOCATION_ARTIFACT",
+            "topology-replay",
+        ),
+        (
+            "RUSTICOL_RECURRENCE_UNION_ALLOCATION_ARTIFACT",
+            "all-flow-union",
+        ),
+    ];
+
+    for (environment_name, layout) in FIXTURES {
+        let Some(root) = std::env::var_os(environment_name) else {
+            eprintln!(
+                "skipping genuine recurrence {layout} boundary gate: \
+                 {environment_name} is not set"
+            );
+            continue;
+        };
+        let mut runtime = NativeRuntime::load(PathBuf::from(root), None, None)
+            .unwrap_or_else(|error| panic!("load genuine recurrence {layout} artifact: {error}"));
+        let metadata = runtime.metadata();
+        assert_eq!(
+            metadata.execution_mode, "recurrence",
+            "genuine {layout} fixture execution mode"
+        );
+        assert_eq!(
+            metadata.prepared_backend.as_deref(),
+            Some("jit"),
+            "genuine {layout} fixture backend"
+        );
+        let point = generated_recurrence_validation_point(&runtime);
+
+        for point_count in ODD_TAIL_POINT_COUNTS {
+            let batch = vec![point.clone(); point_count];
+            let flat_momenta = batch
+                .iter()
+                .flat_map(|momenta| momenta.iter().flat_map(|value| value.iter().copied()))
+                .collect::<Vec<_>>();
+            let mut caller_output = vec![f64::NAN; point_count];
+            runtime
+                .evaluate_f64_into(&flat_momenta, point_count, &mut caller_output)
+                .unwrap_or_else(|error| {
+                    panic!(
+                        "warm genuine recurrence {layout} caller-output path at \
+                         {point_count} points: {error}"
+                    )
+                });
+
+            let (profiled_values, profile) = {
+                let (common, execution_lane) = (&mut runtime.runtime, &mut runtime.execution_lane);
+                let NativeExecutionLane::Recurrence(lane) = execution_lane else {
+                    panic!("genuine {layout} fixture did not load the recurrence lane");
+                };
+                lane.run_f64(common, &batch).unwrap_or_else(|error| {
+                    panic!(
+                        "profile genuine recurrence {layout} Direct-Arena path at \
+                         {point_count} points: {error}"
+                    )
+                })
+            };
+            let context = format!("genuine recurrence {layout} odd tail {point_count}");
+            assert_zero_recurrence_direct_boundary_traffic(&profile, &context);
+            assert_eq!(
+                profiled_values.len(),
+                caller_output.len(),
+                "{context}: profiled output length"
+            );
+            for (index, (profiled, warmed)) in profiled_values
+                .iter()
+                .copied()
+                .zip(caller_output.iter().copied())
+                .enumerate()
+            {
+                assert_close(
+                    profiled,
+                    warmed,
+                    &format!("{context}: caller-output parity point {index}"),
+                );
+            }
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_lane.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_lane.rs
new file mode 100644
index 0000000000..38e2d08f59
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_lane.rs
@@ -0,0 +1,5317 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Native adapter from public runtime inputs to Direct-Arena recurrence.
+
+use super::recurrence_backend::{
+    NativeOnTheFlyPreparedExecutorResolver, NativeRecurrenceDirectExecutorOwners,
+};
+use super::*;
+use crate::direct_arena::DirectArenaTrafficCounters;
+use crate::recurrence::direct_backend::{
+    DirectExecutionCounters, DirectExecutionRoleTimings, DirectExecutorCatalog,
+};
+use crate::recurrence::direct_runtime::{
+    DirectRecurrenceExecutionRuntime, DirectRecurrenceTileOutput, DirectReplaySelectorPlan,
+    DirectRuntimeActivityCounters, DirectRuntimePhaseTimings, DirectUnionHelicitySelectorPlan,
+};
+use crate::recurrence::on_the_fly::{
+    PersistedHelicityAmplitudeTileV1, PersistedHelicityFamilyCacheCensusV1,
+    PersistedHelicityFamilyExecutionReportV1, PersistedHelicityFamilyExecutorV1,
+    PersistedHelicityFamilyInspectionCensusV1,
+};
+use crate::recurrence::{
+    DIRECT_NONE_U32, DirectAmplitudeDestinationDescriptor, DirectHelicityDispatch,
+    DirectRecurrencePlan, RecurrenceColorContraction, RecurrenceColorStorage, RecurrenceStrategy,
+    RuntimeColorContractionEntry, RuntimeColorContractionReducer,
+    RuntimeSymmetricGroupColorWorkspace,
+};
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+#[derive(Clone, Copy, Debug)]
+pub(super) struct PreparedParameterProjectionEntry {
+    pub(super) runtime_slot: usize,
+    pub(super) prepared_slot: usize,
+    pub(super) component: u8,
+}
+
+/// One process-local Direct-Arena runtime.
+///
+/// `_backend_owner` keeps every immutable source/SymJIT context addressed by
+/// the scheduler's lightweight function handles alive. All point-dependent
+/// storage belongs to `scheduler` or the fixed-size external-momentum scratch.
+pub(super) struct RecurrenceNativeRuntime {
+    scheduler: DirectRecurrenceExecutionRuntime,
+    _backend_owner: NativeRecurrenceDirectExecutorOwners,
+    backend_name: String,
+    selectors: RecurrenceNativeSelectors,
+    parameter_defaults: Vec<crate::EagerComplex64>,
+    parameter_projection: Vec<PreparedParameterProjectionEntry>,
+    external_source_count: usize,
+    effective_point_tile_size: usize,
+    external_momenta: Vec<f64>,
+    contracted_replay_re: Vec<f64>,
+    contracted_replay_im: Vec<f64>,
+    color_transform_re: Vec<f64>,
+    color_transform_im: Vec<f64>,
+    symmetric_group_color_workspace: Option<RuntimeSymmetricGroupColorWorkspace>,
+    replay_color_index_scratch: Vec<usize>,
+    selected_replay_cache:
+        BTreeMap<BTreeSet<String>, BTreeMap<usize, Arc<DirectReplaySelectorPlan>>>,
+    selected_replay_programs: BTreeMap<(u32, Vec<u32>), Arc<DirectReplaySelectorPlan>>,
+    helicity_selector_companion: Option<RecurrencePersistedHelicitySelectorRuntime>,
+}
+
+pub(super) struct RecurrencePersistedHelicitySelectorRuntime {
+    plan: DirectRecurrencePlan,
+    dispatch: DirectHelicityDispatch,
+    executor: PersistedHelicityFamilyExecutorV1<NativeOnTheFlyPreparedExecutorResolver>,
+    resolved_helicity_by_physics: Box<[u32]>,
+    primary_color_view: Option<PrimaryLocalColorViewV1>,
+}
+
+struct PrimaryLocalColorViewV1 {
+    auxiliary_destination_by_local_group: Box<[u32]>,
+    local_group_by_primary_destination: Box<[u32]>,
+}
+
+impl RecurrencePersistedHelicitySelectorRuntime {
+    pub(super) fn new(
+        plan: DirectRecurrencePlan,
+        dispatch: DirectHelicityDispatch,
+        resolver: NativeOnTheFlyPreparedExecutorResolver,
+        direct_helicity_to_physics: Vec<usize>,
+        physics_helicity_count: usize,
+    ) -> RusticolResult<Self> {
+        if plan.strategy() != RecurrenceStrategy::AllFlowUnion {
+            return Err(RusticolError::integrity(
+                "persisted recurrence helicity selector is not all-flow-union",
+            ));
+        }
+        dispatch.validate_for_plan(&plan)?;
+        if direct_helicity_to_physics.len() != plan.resolved_helicities().len() {
+            return Err(RusticolError::integrity(
+                "persisted selector helicity mapping does not cover its auxiliary plan",
+            ));
+        }
+        let mut resolved_helicity_by_physics = vec![DIRECT_NONE_U32; physics_helicity_count];
+        for (resolved_helicity_id, physics_helicity_id) in
+            direct_helicity_to_physics.into_iter().enumerate()
+        {
+            let slot = resolved_helicity_by_physics
+                .get_mut(physics_helicity_id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "persisted selector helicity maps outside the public physics axis",
+                    )
+                })?;
+            if *slot != DIRECT_NONE_U32 {
+                return Err(RusticolError::integrity(
+                    "persisted selector helicity mapping repeats a public helicity",
+                ));
+            }
+            *slot = u32::try_from(resolved_helicity_id).map_err(|_| {
+                RusticolError::artifact("persisted selector resolved helicity exceeds u32")
+            })?;
+        }
+        if resolved_helicity_by_physics.contains(&DIRECT_NONE_U32) {
+            return Err(RusticolError::integrity(
+                "persisted selector does not cover the complete public helicity axis",
+            ));
+        }
+        Ok(Self {
+            plan,
+            dispatch,
+            executor: PersistedHelicityFamilyExecutorV1::new(resolver),
+            resolved_helicity_by_physics: resolved_helicity_by_physics.into_boxed_slice(),
+            primary_color_view: None,
+        })
+    }
+
+    fn bind_primary_color_view(
+        &mut self,
+        contraction: &RecurrenceColorContraction,
+    ) -> RusticolResult<()> {
+        if self.primary_color_view.is_some() {
+            return Err(RusticolError::internal(
+                "persisted selector primary color view was bound twice",
+            ));
+        }
+        self.primary_color_view = Some(primary_local_color_destination_map(
+            contraction,
+            self.plan.amplitude_destinations(),
+        )?);
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn resolved_helicity_id(&self, physics_helicity_id: usize) -> RusticolResult<u32> {
+        self.resolved_helicity_by_physics
+            .get(physics_helicity_id)
+            .copied()
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "persisted selector public helicity is outside its resolved map",
+                )
+            })
+    }
+
+    fn clear(&mut self) -> RusticolResult<()> {
+        self.executor.clear_families()
+    }
+
+    fn cache_census(&self) -> PersistedHelicityFamilyCacheCensusV1 {
+        self.executor.cache_census()
+    }
+
+    fn active_family_inspection_census(&self) -> Option<PersistedHelicityFamilyInspectionCensusV1> {
+        self.executor.active_family_inspection_census()
+    }
+}
+
+fn primary_local_color_destination_map(
+    contraction: &RecurrenceColorContraction,
+    auxiliary_destinations: &[DirectAmplitudeDestinationDescriptor],
+) -> RusticolResult<PrimaryLocalColorViewV1> {
+    if contraction.storage() == RecurrenceColorStorage::Expanded
+        && contraction.component_count() != 1
+    {
+        return Err(RusticolError::compatibility(
+            "expanded persisted helicity color view must contain exactly one component",
+        ));
+    }
+    let component_count = contraction.component_count() as usize;
+    let local_group_count = match contraction.storage() {
+        RecurrenceColorStorage::Expanded => contraction.group_count() as usize,
+        RecurrenceColorStorage::Repeated | RecurrenceColorStorage::ConvolutionKernels => {
+            contraction.local_group_count() as usize
+        }
+    };
+    if local_group_count == 0
+        || component_count == 0
+        || auxiliary_destinations.len() != local_group_count
+    {
+        return Err(RusticolError::integrity(
+            "persisted selector physical destinations disagree with the primary local color domain",
+        ));
+    }
+
+    let active_owner_sectors = contraction
+        .owner_by_sector()
+        .iter()
+        .copied()
+        .enumerate()
+        .filter_map(|(sector, owner)| (owner as usize == sector).then_some(sector))
+        .collect::<Vec<_>>();
+    if active_owner_sectors.len() != local_group_count {
+        return Err(RusticolError::integrity(
+            "primary local color groups do not match its canonical active owners",
+        ));
+    }
+    let mut dense_rank_by_sector = vec![DIRECT_NONE_U32; contraction.owner_by_sector().len()];
+    for (rank, sector) in active_owner_sectors.into_iter().enumerate() {
+        dense_rank_by_sector[sector] = u32::try_from(rank)
+            .map_err(|_| RusticolError::artifact("primary color owner rank exceeds u32"))?;
+    }
+
+    let mut auxiliary_destination_by_rank = vec![DIRECT_NONE_U32; local_group_count];
+    for destination in auxiliary_destinations {
+        if destination.target_helicity_id_or_sentinel != DIRECT_NONE_U32 {
+            return Err(RusticolError::integrity(
+                "persisted selector auxiliary destination fixes a numerical helicity",
+            ));
+        }
+        let slot = auxiliary_destination_by_rank
+            .get_mut(destination.target_sector_id as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "persisted selector auxiliary destination has a non-dense physical sector",
+                )
+            })?;
+        if *slot != DIRECT_NONE_U32 {
+            return Err(RusticolError::integrity(
+                "persisted selector repeats an auxiliary physical sector",
+            ));
+        }
+        *slot = destination.id;
+    }
+    if auxiliary_destination_by_rank.contains(&DIRECT_NONE_U32) {
+        return Err(RusticolError::integrity(
+            "persisted selector does not cover every dense auxiliary physical sector",
+        ));
+    }
+
+    let ordered_groups = contraction.ordered_group_ids();
+    let sectors = contraction.sector_by_group();
+    let components = contraction.component_by_group();
+    let destinations = contraction.destination_by_group();
+    let mut auxiliary_destination_by_local_group = Vec::with_capacity(local_group_count);
+    let mut local_group_by_primary_destination =
+        vec![DIRECT_NONE_U32; contraction.destination_count() as usize];
+    for local_group in 0..local_group_count {
+        let mut owner_sector = None;
+        for component in 0..component_count {
+            let ordered_index = local_group
+                .checked_mul(component_count)
+                .and_then(|base| base.checked_add(component))
+                .ok_or_else(|| RusticolError::artifact("primary local color index overflows"))?;
+            let group_id = *ordered_groups
+                .get(ordered_index)
+                .ok_or_else(|| RusticolError::integrity("primary ordered color group is absent"))?
+                as usize;
+            let sector = *sectors.get(group_id).ok_or_else(|| {
+                RusticolError::integrity("primary color group has no physical sector")
+            })? as usize;
+            if components.get(group_id).copied() != Some(component as u32)
+                || contraction.owner_by_sector().get(sector).copied() != Some(sector as u32)
+                || owner_sector.is_some_and(|expected| expected != sector)
+            {
+                return Err(RusticolError::integrity(
+                    "primary local color block mixes components or non-owner sectors",
+                ));
+            }
+            owner_sector = Some(sector);
+            let primary_destination = *destinations.get(group_id).ok_or_else(|| {
+                RusticolError::integrity("primary color group has no amplitude destination")
+            })? as usize;
+            let slot = local_group_by_primary_destination
+                .get_mut(primary_destination)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "primary color destination is outside its authenticated domain",
+                    )
+                })?;
+            let local_group_u32 = u32::try_from(local_group)
+                .map_err(|_| RusticolError::artifact("primary local color group exceeds u32"))?;
+            if *slot != DIRECT_NONE_U32 && *slot != local_group_u32 {
+                return Err(RusticolError::integrity(
+                    "primary color destination maps to multiple local groups",
+                ));
+            }
+            *slot = local_group_u32;
+        }
+        let owner_sector = owner_sector.expect("positive component count was validated");
+        let dense_rank = *dense_rank_by_sector.get(owner_sector).ok_or_else(|| {
+            RusticolError::integrity("primary color owner has no dense canonical rank")
+        })?;
+        if dense_rank == DIRECT_NONE_U32 {
+            return Err(RusticolError::integrity(
+                "primary color local group references an inactive owner",
+            ));
+        }
+        auxiliary_destination_by_local_group
+            .push(auxiliary_destination_by_rank[dense_rank as usize]);
+    }
+    Ok(PrimaryLocalColorViewV1 {
+        auxiliary_destination_by_local_group: auxiliary_destination_by_local_group
+            .into_boxed_slice(),
+        local_group_by_primary_destination: local_group_by_primary_destination.into_boxed_slice(),
+    })
+}
+
+struct ContractedReplayRoute {
+    selector: DirectReplaySelectorPlan,
+    destination_copies: Vec<(u32, u32)>,
+}
+
+// Boxing the contracted-color payload would add an indirection to every
+// contracted recurrence tile; this enum is instantiated only once per runtime.
+#[allow(clippy::large_enum_variant)]
+enum RecurrenceNativeSelectors {
+    TopologyReplay {
+        replay_selectors: Vec<DirectReplaySelectorPlan>,
+        direct_helicity_to_physics: Vec<usize>,
+    },
+    AllFlowUnion {
+        helicity_selectors_by_physics: Vec<Option<DirectUnionHelicitySelectorPlan>>,
+        destination_by_public_flow: Vec<u32>,
+    },
+    ContractedColorUnion {
+        contraction: RecurrenceColorContraction,
+        destination_physics_helicity: Vec<usize>,
+        replay_routes: Vec<ContractedReplayRoute>,
+    },
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum CompanionSingletonSelection {
+    StructuralZero,
+    Runnable {
+        physics_helicity_id: usize,
+        resolved_helicity_id: u32,
+    },
+}
+
+/// Borrowed LC selector and reduction state shared by topology replay and the
+/// future compact on-the-fly lane.
+///
+/// Constructing this view is allocation-free. It deliberately exposes only
+/// the public axes and orbit weights needed after an amplitude is computed;
+/// an on-the-fly runtime can therefore provide the same backing slices/maps
+/// without materializing a dense [`ProcessPhysicsV1`].
+#[derive(Clone, Copy)]
+pub(super) struct LcSelectorReductionView<'a> {
+    helicities: &'a [crate::Helicity],
+    color_components: &'a [crate::ColorComponent],
+    helicity_index_by_id: &'a BTreeMap<String, usize>,
+    color_index_by_id: &'a BTreeMap<String, usize>,
+    helicity_members_by_representative: &'a [Vec<usize>],
+}
+
+impl<'a> LcSelectorReductionView<'a> {
+    pub(super) const fn from_parts(
+        helicities: &'a [crate::Helicity],
+        color_components: &'a [crate::ColorComponent],
+        helicity_index_by_id: &'a BTreeMap<String, usize>,
+        color_index_by_id: &'a BTreeMap<String, usize>,
+        helicity_members_by_representative: &'a [Vec<usize>],
+    ) -> Self {
+        Self {
+            helicities,
+            color_components,
+            helicity_index_by_id,
+            color_index_by_id,
+            helicity_members_by_representative,
+        }
+    }
+
+    fn validate_selector_ids(
+        self,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<()> {
+        if let Some(id) = selected_helicities.and_then(|ids| {
+            ids.iter()
+                .find(|id| !self.helicity_index_by_id.contains_key(*id))
+        }) {
+            return Err(RusticolError::selector(format!(
+                "unknown resolved helicity id {id:?}"
+            )));
+        }
+        if let Some(id) = selected_colors.and_then(|ids| {
+            ids.iter()
+                .find(|id| !self.color_index_by_id.contains_key(*id))
+        }) {
+            return Err(RusticolError::selector(format!(
+                "unknown resolved color component id {id:?}"
+            )));
+        }
+        Ok(())
+    }
+
+    fn selected_indices(
+        available: &BTreeMap<String, usize>,
+        ids: Option<&BTreeSet<String>>,
+        kind: &str,
+    ) -> RusticolResult<Vec<usize>> {
+        let mut indices = if let Some(ids) = ids {
+            ids.iter()
+                .map(|id| {
+                    available.get(id).copied().ok_or_else(|| {
+                        RusticolError::selector(format!("unknown resolved {kind} id {id:?}"))
+                    })
+                })
+                .collect::<RusticolResult<Vec<_>>>()?
+        } else {
+            (0..available.len()).collect()
+        };
+        indices.sort_unstable();
+        Ok(indices)
+    }
+
+    fn selected_helicity_indices(
+        self,
+        ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<Vec<usize>> {
+        Self::selected_indices(self.helicity_index_by_id, ids, "helicity")
+    }
+
+    fn selected_color_indices(self, ids: Option<&BTreeSet<String>>) -> RusticolResult<Vec<usize>> {
+        Self::selected_indices(self.color_index_by_id, ids, "color component")
+    }
+
+    fn retain_selected_color_indices(
+        self,
+        ids: &BTreeSet<String>,
+        indices: &mut Vec<usize>,
+    ) -> RusticolResult<()> {
+        indices.clear();
+        indices.reserve(ids.len());
+        for id in ids {
+            indices.push(*self.color_index_by_id.get(id).ok_or_else(|| {
+                RusticolError::selector(format!("unknown resolved color component id {id:?}"))
+            })?);
+        }
+        indices.sort_unstable();
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn helicity(self, index: usize) -> &'a crate::Helicity {
+        &self.helicities[index]
+    }
+
+    #[inline(always)]
+    fn color(self, index: usize) -> &'a crate::ColorComponent {
+        &self.color_components[index]
+    }
+
+    #[inline(always)]
+    fn color_is_computed(self, index: usize) -> bool {
+        match self.color(index) {
+            crate::ColorComponent::LcFlow(flow) => flow.computed,
+            crate::ColorComponent::ContractedColor(_) => true,
+        }
+    }
+
+    #[inline(always)]
+    fn helicity_orbit_members(self, representative: usize) -> &'a [usize] {
+        self.helicity_members_by_representative
+            .get(representative)
+            .map(Vec::as_slice)
+            .unwrap_or_default()
+    }
+
+    #[inline(always)]
+    fn helicity_is_selected(self, selected: Option<&BTreeSet<String>>, index: usize) -> bool {
+        selected.is_none_or(|ids| ids.contains(&self.helicity(index).id))
+    }
+
+    #[inline(always)]
+    fn helicity_orbit_weight(
+        self,
+        selected: Option<&BTreeSet<String>>,
+        representative_index: usize,
+    ) -> f64 {
+        self.helicity_orbit_members(representative_index)
+            .iter()
+            .copied()
+            .filter(|index| self.helicity_is_selected(selected, *index))
+            .map(|index| self.helicity(index).coefficient)
+            .sum()
+    }
+
+    #[cfg(test)]
+    #[inline(always)]
+    fn color_is_selected(self, selected: Option<&BTreeSet<String>>, index: usize) -> bool {
+        selected.is_none_or(|ids| ids.contains(self.color(index).id()))
+    }
+}
+
+#[inline(always)]
+fn visit_replay_color_indices(
+    color_count: usize,
+    selected: Option<&[usize]>,
+    mut visit: impl FnMut(usize) -> RusticolResult<()>,
+) -> RusticolResult<()> {
+    if let Some(selected) = selected {
+        for &color_index in selected {
+            visit(color_index)?;
+        }
+    } else {
+        for color_index in 0..color_count {
+            visit(color_index)?;
+        }
+    }
+    Ok(())
+}
+
+impl PhysicsRuntime {
+    pub(super) fn lc_selector_reduction_view(&self) -> LcSelectorReductionView<'_> {
+        LcSelectorReductionView::from_parts(
+            &self.manifest.helicities,
+            &self.manifest.color_components,
+            &self.helicity_index_by_id,
+            &self.color_index_by_id,
+            &self.helicity_members_by_representative,
+        )
+    }
+}
+
+/// Apply the established LC diagonal reduction to one complex amplitude
+/// stream. Both topology replay's split real/imaginary planes and the future
+/// on-the-fly query-major output can provide their native storage through the
+/// inlined accessor without copying or changing the reduction formula.
+#[inline(always)]
+pub(super) fn accumulate_lc_diagonal_amplitude(
+    point_count: usize,
+    weight: f64,
+    mut value: impl FnMut(usize) -> (f64, f64),
+    mut accumulate: impl FnMut(usize, f64),
+) {
+    for point in 0..point_count {
+        let (real, imaginary) = value(point);
+        accumulate(point, weight * real.mul_add(real, imaginary * imaginary));
+    }
+}
+
+/// Initialize prepared complex parameters from authenticated defaults and the
+/// mutable runtime projection shared by recurrence and on-the-fly execution.
+/// Every fallible shape/index check completes before either destination plane
+/// is modified.
+pub(super) fn initialize_prepared_parameter_planes(
+    defaults: &[crate::EagerComplex64],
+    projection: &[PreparedParameterProjectionEntry],
+    runtime_values: &[f64],
+    destination_re: &mut [f64],
+    destination_im: &mut [f64],
+) -> RusticolResult<()> {
+    if destination_re.len() != defaults.len() || destination_im.len() != defaults.len() {
+        return Err(RusticolError::integrity(
+            "prepared parameter workspace has the wrong size",
+        ));
+    }
+    for entry in projection {
+        if entry.prepared_slot >= defaults.len()
+            || entry.runtime_slot >= runtime_values.len()
+            || entry.component > 1
+        {
+            return Err(RusticolError::integrity(
+                "runtime parameter projection is outside its prepared layout",
+            ));
+        }
+    }
+    for ((real, imaginary), default) in destination_re
+        .iter_mut()
+        .zip(destination_im.iter_mut())
+        .zip(defaults)
+    {
+        *real = default.re;
+        *imaginary = default.im;
+    }
+    for entry in projection {
+        let value = runtime_values[entry.runtime_slot];
+        if entry.component == 0 {
+            destination_re[entry.prepared_slot] = value;
+        } else {
+            destination_im[entry.prepared_slot] = value;
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn projected_prepared_parameter_values(
+    defaults: &[crate::EagerComplex64],
+    projection: &[PreparedParameterProjectionEntry],
+    runtime_values: &[f64],
+) -> RusticolResult<Vec<(f64, f64)>> {
+    let mut real = vec![0.0; defaults.len()];
+    let mut imaginary = vec![0.0; defaults.len()];
+    initialize_prepared_parameter_planes(
+        defaults,
+        projection,
+        runtime_values,
+        &mut real,
+        &mut imaginary,
+    )?;
+    Ok(real.into_iter().zip(imaginary).collect())
+}
+
+/// Existing point-major resolved-output placement shared by recurrence and
+/// on-the-fly LC execution. The selected axis order remains
+/// `[point][helicity][color]` without requiring a persisted dense flow table.
+#[derive(Clone, Copy, Debug)]
+pub(super) struct LcResolvedOutputLayout {
+    point_count: usize,
+    helicity_count: usize,
+    color_count: usize,
+}
+
+impl LcResolvedOutputLayout {
+    pub(super) fn new(
+        point_count: usize,
+        helicity_count: usize,
+        color_count: usize,
+    ) -> RusticolResult<Self> {
+        if point_count == 0 || helicity_count == 0 || color_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "resolved LC output shape is empty",
+            ));
+        }
+        let layout = Self {
+            point_count,
+            helicity_count,
+            color_count,
+        };
+        layout.output_len()?;
+        Ok(layout)
+    }
+
+    pub(super) fn output_len(self) -> RusticolResult<usize> {
+        self.point_count
+            .checked_mul(self.helicity_count)
+            .and_then(|count| count.checked_mul(self.color_count))
+            .ok_or_else(|| RusticolError::invalid_argument("resolved LC output shape overflows"))
+    }
+
+    #[inline(always)]
+    pub(super) fn index(
+        self,
+        point: usize,
+        helicity: usize,
+        color: usize,
+    ) -> RusticolResult<usize> {
+        if point >= self.point_count || helicity >= self.helicity_count || color >= self.color_count
+        {
+            return Err(RusticolError::integrity(
+                "resolved LC output coordinate is outside its selected axes",
+            ));
+        }
+        point
+            .checked_mul(self.helicity_count)
+            .and_then(|base| base.checked_add(helicity))
+            .and_then(|base| base.checked_mul(self.color_count))
+            .and_then(|base| base.checked_add(color))
+            .ok_or_else(|| RusticolError::invalid_argument("resolved LC output index overflows"))
+    }
+}
+
+impl RecurrenceNativeRuntime {
+    #[allow(clippy::too_many_arguments)]
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    pub(super) fn new(
+        plan: DirectRecurrencePlan,
+        executors: DirectExecutorCatalog,
+        backend_owner: NativeRecurrenceDirectExecutorOwners,
+        parameter_defaults: Vec<crate::EagerComplex64>,
+        parameter_projection: Vec<PreparedParameterProjectionEntry>,
+        public_flow_ids: Vec<u32>,
+        direct_helicity_to_physics: Vec<usize>,
+        color_contraction: Option<RecurrenceColorContraction>,
+        mut helicity_selector_companion: Option<RecurrencePersistedHelicitySelectorRuntime>,
+    ) -> RusticolResult<Self> {
+        let parameter_count = usize::try_from(plan.parameter_value_count())
+            .map_err(|_| RusticolError::artifact("recurrence parameter count exceeds usize"))?;
+        if parameter_defaults.len() != parameter_count {
+            return Err(RusticolError::integrity(format!(
+                "recurrence prepared defaults have length {}, expected {parameter_count}",
+                parameter_defaults.len()
+            )));
+        }
+        for entry in &parameter_projection {
+            if entry.prepared_slot >= parameter_count || entry.component > 1 {
+                return Err(RusticolError::artifact(
+                    "recurrence parameter projection is outside the prepared layout",
+                ));
+            }
+        }
+        if direct_helicity_to_physics.len() != plan.resolved_helicities().len() {
+            return Err(RusticolError::integrity(
+                "recurrence resolved-helicity mapping does not cover the direct plan",
+            ));
+        }
+        let backend_name = backend_owner.summary().backend.clone();
+        let strategy = plan.strategy();
+        let has_color_contraction = color_contraction.is_some();
+        if public_flow_ids.is_empty() && strategy != RecurrenceStrategy::ContractedColorUnion {
+            return Err(RusticolError::integrity(
+                "recurrence public color-flow mapping is empty",
+            ));
+        }
+        let scheduler = match strategy {
+            RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion => {
+                DirectRecurrenceExecutionRuntime::new(plan, executors, 4)?
+            }
+            RecurrenceStrategy::AllFlowUnion => {
+                let dispatch = backend_owner.union_source_dispatch()?;
+                DirectRecurrenceExecutionRuntime::new_with_union_source_dispatch(
+                    plan, executors, 4, dispatch,
+                )?
+            }
+        };
+        let point_tile_capacity = scheduler.point_tile_size() as usize;
+        let mut effective_point_tile_size = point_tile_capacity;
+        let mut color_transform_scratch_len = 0usize;
+        let mut symmetric_group_color_workspace = None;
+        if let Some(contraction) = color_contraction.as_ref() {
+            match contraction.runtime_reducer() {
+                Some(RuntimeColorContractionReducer::Walsh(_)) => {
+                    color_transform_scratch_len = usize::try_from(contraction.local_group_count())
+                        .ok()
+                        .and_then(|groups| groups.checked_mul(point_tile_capacity))
+                        .ok_or_else(|| {
+                            RusticolError::artifact(
+                                "recurrence factorized color workspace overflows usize",
+                            )
+                        })?;
+                }
+                Some(RuntimeColorContractionReducer::SymmetricGroupFourier(reducer)) => {
+                    (effective_point_tile_size, symmetric_group_color_workspace) =
+                        lazy_symmetric_group_workspace_for_point_tile(
+                            reducer,
+                            point_tile_capacity,
+                        )?;
+                }
+                None => {}
+            }
+        }
+        let selectors = match strategy {
+            RecurrenceStrategy::TopologyReplay => {
+                let replay_selectors = public_flow_ids
+                    .into_iter()
+                    .map(|public_flow_id| scheduler.prepare_replay_selector(public_flow_id))
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                validate_replay_destination_helicity_mappings(
+                    scheduler.plan(),
+                    &replay_selectors,
+                    &direct_helicity_to_physics,
+                )?;
+                RecurrenceNativeSelectors::TopologyReplay {
+                    replay_selectors,
+                    direct_helicity_to_physics,
+                }
+            }
+            RecurrenceStrategy::AllFlowUnion => {
+                let physics_helicity_count = direct_helicity_to_physics
+                    .iter()
+                    .copied()
+                    .max()
+                    .and_then(|value| value.checked_add(1))
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "all-flow-union recurrence has no public helicities",
+                        )
+                    })?;
+                let mut helicity_selectors_by_physics = vec![None; physics_helicity_count];
+                for (direct_id, physics_id) in
+                    direct_helicity_to_physics.iter().copied().enumerate()
+                {
+                    let selector = scheduler.prepare_union_helicity_selector(
+                        u32::try_from(direct_id).map_err(|_| {
+                            RusticolError::artifact("recurrence direct helicity ID exceeds u32")
+                        })?,
+                    )?;
+                    if helicity_selectors_by_physics[physics_id]
+                        .replace(selector)
+                        .is_some()
+                    {
+                        return Err(RusticolError::integrity(
+                            "all-flow-union recurrence repeats a public helicity",
+                        ));
+                    }
+                }
+                if helicity_selectors_by_physics.iter().any(Option::is_none) {
+                    return Err(RusticolError::integrity(
+                        "all-flow-union recurrence does not cover the public helicity axis",
+                    ));
+                }
+                let destination_by_public_flow =
+                    union_destination_ids(scheduler.plan(), &public_flow_ids)?;
+                RecurrenceNativeSelectors::AllFlowUnion {
+                    helicity_selectors_by_physics,
+                    destination_by_public_flow,
+                }
+            }
+            RecurrenceStrategy::ContractedColorUnion => {
+                if !public_flow_ids.is_empty() {
+                    return Err(RusticolError::integrity(
+                        "contracted recurrence unexpectedly exposes public color flows",
+                    ));
+                }
+                let contraction = color_contraction.ok_or_else(|| {
+                    RusticolError::integrity(
+                        "contracted recurrence has no color-contraction payload",
+                    )
+                })?;
+                let destination_physics_helicity =
+                    contracted_destination_helicity_map(&contraction, &direct_helicity_to_physics)?;
+                let replay_routes = contracted_replay_routes(&scheduler, &contraction)?;
+                RecurrenceNativeSelectors::ContractedColorUnion {
+                    contraction,
+                    destination_physics_helicity,
+                    replay_routes,
+                }
+            }
+        };
+        if strategy != RecurrenceStrategy::ContractedColorUnion && has_color_contraction {
+            return Err(RusticolError::integrity(
+                "LC recurrence unexpectedly carries a color-contraction payload",
+            ));
+        }
+        if helicity_selector_companion.is_some()
+            && strategy != RecurrenceStrategy::ContractedColorUnion
+        {
+            return Err(RusticolError::integrity(
+                "recurrence helicity-selector companion requires contracted-color-union",
+            ));
+        }
+        if let Some(companion) = &mut helicity_selector_companion {
+            if companion.plan.parameter_value_count() != scheduler.plan().parameter_value_count()
+                || companion.plan.prepared_pack_digest() != scheduler.plan().prepared_pack_digest()
+                || companion.plan.direct_template_catalog_digest()
+                    != scheduler.plan().direct_template_catalog_digest()
+            {
+                return Err(RusticolError::integrity(
+                    "persisted selector prepared-parameter layout disagrees with the primary recurrence plan",
+                ));
+            }
+            let RecurrenceNativeSelectors::ContractedColorUnion { contraction, .. } = &selectors
+            else {
+                return Err(RusticolError::integrity(
+                    "recurrence helicity-selector companion has no primary color contraction",
+                ));
+            };
+            companion.bind_primary_color_view(contraction)?;
+        }
+        let external_source_count = usize::try_from(scheduler.plan().external_source_count())
+            .map_err(|_| RusticolError::artifact("recurrence source count exceeds usize"))?;
+        scheduler
+            .point_tile_size()
+            .try_into()
+            .ok()
+            .and_then(|points: usize| points.checked_mul(external_source_count))
+            .and_then(|values| values.checked_mul(4))
+            .ok_or_else(|| {
+                RusticolError::artifact("recurrence external-momentum workspace overflows usize")
+            })?;
+        let mut external_momenta = Vec::new();
+        ensure_external_momentum_workspace_capacity(
+            &mut external_momenta,
+            1,
+            external_source_count,
+            effective_point_tile_size,
+        )?;
+        let contracted_replay_len = match &selectors {
+            RecurrenceNativeSelectors::ContractedColorUnion {
+                contraction,
+                replay_routes,
+                ..
+            } if !replay_routes.is_empty() => usize::try_from(contraction.destination_count())
+                .ok()
+                .and_then(|destinations| {
+                    usize::try_from(scheduler.point_tile_size())
+                        .ok()
+                        .and_then(|points| destinations.checked_mul(points))
+                })
+                .ok_or_else(|| {
+                    RusticolError::artifact("contracted replay amplitude workspace overflows usize")
+                })?,
+            _ => 0,
+        };
+
+        Ok(Self {
+            scheduler,
+            _backend_owner: backend_owner,
+            backend_name,
+            selectors,
+            parameter_defaults,
+            parameter_projection,
+            external_source_count,
+            effective_point_tile_size,
+            external_momenta,
+            contracted_replay_re: vec![0.0; contracted_replay_len],
+            contracted_replay_im: vec![0.0; contracted_replay_len],
+            color_transform_re: vec![0.0; color_transform_scratch_len],
+            color_transform_im: vec![0.0; color_transform_scratch_len],
+            symmetric_group_color_workspace,
+            replay_color_index_scratch: Vec::new(),
+            selected_replay_cache: BTreeMap::new(),
+            selected_replay_programs: BTreeMap::new(),
+            helicity_selector_companion,
+        })
+    }
+
+    pub(super) fn backend_name(&self) -> &str {
+        &self.backend_name
+    }
+
+    pub(super) fn effective_point_tile_size(&self) -> usize {
+        self.effective_point_tile_size
+    }
+
+    pub(super) fn clear_helicity_selector_companion(&mut self) -> RusticolResult<()> {
+        if let Some(companion) = &mut self.helicity_selector_companion {
+            companion.clear()?;
+        }
+        Ok(())
+    }
+
+    pub(super) fn helicity_selector_companion_state_census(
+        &self,
+        process_id: &str,
+    ) -> RusticolResult<Option<serde_json::Value>> {
+        let Some(companion) = &self.helicity_selector_companion else {
+            return Ok(None);
+        };
+        Ok(Some(Self::persisted_helicity_selector_state_census(
+            process_id,
+            companion.cache_census(),
+            companion.active_family_inspection_census(),
+        )))
+    }
+
+    fn persisted_helicity_selector_state_census(
+        process_id: &str,
+        cache: PersistedHelicityFamilyCacheCensusV1,
+        active: Option<PersistedHelicityFamilyInspectionCensusV1>,
+    ) -> serde_json::Value {
+        let active_family_union_census = active.map(|census| {
+            serde_json::json!({
+                "basis": "shared-query-family-union-v1",
+                "scope": "active-family-union",
+                "query_count": census.query_count,
+                "union_unique_current_count": census.union_unique_current_count,
+                "union_unique_current_component_count": (
+                    census.union_unique_current_component_count
+                ),
+                "union_source_rows": census.union_source_rows,
+                "union_contribution_rows": census.union_contribution_rows,
+                "union_finalization_rows": census.union_finalization_rows,
+                "union_closure_rows": census.union_closure_rows,
+                "union_amplitude_destination_count": (
+                    census.union_amplitude_destination_count
+                ),
+                "union_source_executor_call_groups": (
+                    census.union_source_executor_call_groups
+                ),
+                "union_contribution_executor_call_groups": (
+                    census.union_contribution_executor_call_groups
+                ),
+                "union_finalization_executor_call_groups": (
+                    census.union_finalization_executor_call_groups
+                ),
+                "union_closure_executor_call_groups": (
+                    census.union_closure_executor_call_groups
+                ),
+            })
+        });
+        let retained_request_count = active.map_or(0, |census| census.query_count);
+        let retained_amplitude_destination_count =
+            active.map_or(0, |census| census.union_amplitude_destination_count);
+        let retained_executor_handle_count = cache.retained_family_count;
+        let semantic_executor_binding_count =
+            active.map_or(0, |census| census.semantic_executor_binding_count);
+        serde_json::json!({
+            "kind": "rusticol-on-the-fly-runtime-state-census-v1",
+            "process_id": process_id,
+            "family_cache_policy": "last-family-only",
+            "family_cache_limit": 1,
+            "process_preparation_count": cache.retained_family_count,
+            "retained_family_count": cache.retained_family_count,
+            "pending_family_count": 0,
+            "retained_selection_count": cache.retained_family_count,
+            "retained_request_count": retained_request_count,
+            "retained_amplitude_destination_count": retained_amplitude_destination_count,
+            "retained_executor_handle_count": retained_executor_handle_count,
+            "retained_query_local_trace_count": 0,
+            "retained_embedded_lookup_key_count": 0,
+            "semantic_executor_binding_count": semantic_executor_binding_count,
+            "active_family_union_census": active_family_union_census,
+        })
+    }
+
+    pub(super) fn validate_global_selectors(
+        &self,
+        physics: &PhysicsRuntime,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<()> {
+        self.validate_public_axis_lengths(physics)?;
+        if matches!(
+            &self.selectors,
+            RecurrenceNativeSelectors::TopologyReplay { .. }
+        ) {
+            physics
+                .lc_selector_reduction_view()
+                .validate_selector_ids(selected_helicities, selected_colors)?;
+        } else {
+            validate_recurrence_selector_ids(physics, selected_helicities, selected_colors)?;
+        }
+        if matches!(
+            &self.selectors,
+            RecurrenceNativeSelectors::ContractedColorUnion { .. }
+        ) {
+            reject_contracted_color_selector(selected_colors)?;
+        }
+        Ok(())
+    }
+
+    /// Classify the exact singleton selector served by the complete compact
+    /// companion. `Some(false)` is an authenticated structural zero and must
+    /// return without preparing either execution lane.
+    fn companion_singleton_selection(
+        &self,
+        physics: &PhysicsRuntime,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<Option<CompanionSingletonSelection>> {
+        if self.helicity_selector_companion.is_none()
+            || !matches!(
+                &self.selectors,
+                RecurrenceNativeSelectors::ContractedColorUnion { .. }
+            )
+            || selected_colors.is_some()
+        {
+            return Ok(None);
+        }
+        let Some(selected_helicities) = selected_helicities else {
+            return Ok(None);
+        };
+        if selected_helicities.len() != 1 {
+            return Ok(None);
+        }
+        let selected_id = selected_helicities
+            .first()
+            .expect("singleton helicity selector disappeared");
+        let helicity_index = physics
+            .helicity_index_by_id
+            .get(selected_id)
+            .copied()
+            .ok_or_else(|| {
+                RusticolError::selector(format!("unknown resolved helicity id {selected_id:?}"))
+            })?;
+        let helicity = &physics.manifest.helicities[helicity_index];
+        if helicity.structural_zero || helicity.coefficient == 0.0 {
+            return Ok(Some(CompanionSingletonSelection::StructuralZero));
+        }
+        let resolved_helicity_id = self
+            .helicity_selector_companion
+            .as_ref()
+            .expect("classified recurrence companion disappeared")
+            .resolved_helicity_id(helicity_index)?;
+        Ok(Some(CompanionSingletonSelection::Runnable {
+            physics_helicity_id: helicity_index,
+            resolved_helicity_id,
+        }))
+    }
+
+    fn prepare_persisted_companion_parameters(
+        &mut self,
+        common: &ExecutionRuntime,
+    ) -> RusticolResult<()> {
+        self.prepare_parameters(common)?;
+        let companion = self
+            .helicity_selector_companion
+            .as_mut()
+            .ok_or_else(|| RusticolError::internal("persisted helicity companion disappeared"))?;
+        let (parameters_re, parameters_im) = self.scheduler.parameters_mut();
+        companion
+            .executor
+            .set_parameter_planes(parameters_re, parameters_im)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn run_persisted_companion_view_into_unprofiled(
+        &mut self,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        batch: F64MomentumBatchView<'_>,
+        physics_helicity_id: usize,
+        resolved_helicity_id: u32,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let mut tile_start = 0usize;
+        while tile_start < batch.point_count() {
+            let tile_stop =
+                (tile_start + self.effective_point_tile_size()).min(batch.point_count());
+            let point_count =
+                self.flatten_external_tile_view::<false>(batch.subview(tile_start, tile_stop)?)?;
+            self.ensure_primary_symmetric_group_color_workspace_for_capacity(point_count)?;
+            let input_len = self.external_tile_input_len(point_count)?;
+            let point_count_u32 = direct_point_count(point_count)?;
+            let Self {
+                selectors: RecurrenceNativeSelectors::ContractedColorUnion { contraction, .. },
+                external_momenta,
+                color_transform_re,
+                color_transform_im,
+                symmetric_group_color_workspace,
+                helicity_selector_companion: Some(companion),
+                ..
+            } = self
+            else {
+                return Err(RusticolError::internal(
+                    "persisted helicity companion lost its contracted recurrence lane",
+                ));
+            };
+            let RecurrencePersistedHelicitySelectorRuntime {
+                plan,
+                dispatch,
+                executor,
+                primary_color_view: Some(color_view),
+                ..
+            } = companion
+            else {
+                return Err(RusticolError::integrity(
+                    "persisted helicity companion has no primary local-color view",
+                ));
+            };
+            executor.prepare(plan, dispatch, resolved_helicity_id, 4, point_count_u32)?;
+            let tile = executor
+                .execute_tile_unprofiled(&external_momenta[..input_len], point_count_u32)?;
+            contract_primary_local_color_tile(
+                tile,
+                contraction,
+                color_view,
+                physics,
+                physics_helicity_id,
+                normalization_factor,
+                color_transform_re,
+                color_transform_im,
+                symmetric_group_color_workspace.as_mut(),
+                |point, value| output[tile_start + point] += value,
+            )?;
+            tile_start = tile_stop;
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn run_persisted_companion_profiled(
+        &mut self,
+        common: &ExecutionRuntime,
+        physics: &PhysicsRuntime,
+        batch: &[Vec<[f64; 4]>],
+        physics_helicity_id: usize,
+        resolved_helicity_id: u32,
+        mut accumulate: impl FnMut(usize, f64),
+    ) -> RusticolResult<RuntimeProfile> {
+        let total_started = Instant::now();
+        let parameter_started = Instant::now();
+        self.prepare_persisted_companion_parameters(common)?;
+        let parameter_setup = parameter_started.elapsed();
+        let mut input_setup = Duration::ZERO;
+        let mut execution = Duration::ZERO;
+        let mut reduction = Duration::ZERO;
+        let mut report = persisted_execution_report_aggregate();
+        let mut momentum_scalar_values = 0_u64;
+        let mut tile_start = 0usize;
+        while tile_start < batch.len() {
+            let tile_stop = (tile_start + self.effective_point_tile_size()).min(batch.len());
+            let input_started = Instant::now();
+            let point_count = self.flatten_external_tile::<false>(&batch[tile_start..tile_stop])?;
+            input_setup += input_started.elapsed();
+            self.ensure_primary_symmetric_group_color_workspace_for_capacity(point_count)?;
+            let input_len = self.external_tile_input_len(point_count)?;
+            let point_count_u32 = direct_point_count(point_count)?;
+            let Self {
+                selectors: RecurrenceNativeSelectors::ContractedColorUnion { contraction, .. },
+                external_momenta,
+                color_transform_re,
+                color_transform_im,
+                symmetric_group_color_workspace,
+                helicity_selector_companion: Some(companion),
+                ..
+            } = self
+            else {
+                return Err(RusticolError::internal(
+                    "persisted helicity companion lost its contracted recurrence lane",
+                ));
+            };
+            let RecurrencePersistedHelicitySelectorRuntime {
+                plan,
+                dispatch,
+                executor,
+                primary_color_view: Some(color_view),
+                ..
+            } = companion
+            else {
+                return Err(RusticolError::integrity(
+                    "persisted helicity companion has no primary local-color view",
+                ));
+            };
+            let execution_started = Instant::now();
+            executor.prepare(plan, dispatch, resolved_helicity_id, 4, point_count_u32)?;
+            let (tile, tile_report) =
+                executor.execute_tile_profiled(&external_momenta[..input_len], point_count_u32)?;
+            execution += execution_started.elapsed();
+            add_persisted_execution_report(&mut report, tile_report);
+            momentum_scalar_values = momentum_scalar_values.saturating_add(
+                (plan.momentum_forms().len() as u64)
+                    .saturating_mul(4)
+                    .saturating_mul(point_count as u64),
+            );
+            let reduction_started = Instant::now();
+            contract_primary_local_color_tile(
+                tile,
+                contraction,
+                color_view,
+                physics,
+                physics_helicity_id,
+                common.normalization_factor,
+                color_transform_re,
+                color_transform_im,
+                symmetric_group_color_workspace.as_mut(),
+                |point, value| accumulate(tile_start + point, value),
+            )?;
+            reduction += reduction_started.elapsed();
+            tile_start = tile_stop;
+        }
+        Ok(persisted_companion_profile(
+            total_started.elapsed(),
+            parameter_setup,
+            input_setup,
+            execution,
+            reduction,
+            momentum_scalar_values,
+            report,
+        ))
+    }
+
+    pub(super) fn run_f64(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        self.run_f64_with_global_selectors(common, batch, None, None)
+    }
+
+    /// Clock-free totals path used by the native f64 ABI.
+    ///
+    /// Momentum input and result storage remain borrowed throughout this
+    /// call. Selector membership is tested against the authenticated public
+    /// axes directly so a warmed evaluation does not allocate temporary
+    /// index vectors.
+    pub(super) fn run_f64_view_into_unprofiled(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        if output.len() != batch.point_count() {
+            return Err(RusticolError::invalid_argument(format!(
+                "recurrence output has length {}, expected {}",
+                output.len(),
+                batch.point_count()
+            )));
+        }
+        if batch.external_count() != self.external_source_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "recurrence input has {} external momenta, expected {}",
+                batch.external_count(),
+                self.external_source_count
+            )));
+        }
+        let physics = common.physics.as_ref().ok_or_else(|| {
+            RusticolError::artifact("recurrence execution requires physics metadata")
+        })?;
+        self.validate_global_selectors(physics, selected_helicities, selected_colors)?;
+        output.fill(0.0);
+        if selected_helicities.is_some_and(BTreeSet::is_empty) {
+            return Ok(());
+        }
+        if let Some(selection) =
+            self.companion_singleton_selection(physics, selected_helicities, selected_colors)?
+        {
+            match selection {
+                CompanionSingletonSelection::StructuralZero => return Ok(()),
+                CompanionSingletonSelection::Runnable {
+                    physics_helicity_id,
+                    resolved_helicity_id,
+                } => {
+                    self.prepare_persisted_companion_parameters(common)?;
+                    return self.run_persisted_companion_view_into_unprofiled(
+                        physics,
+                        common.normalization_factor,
+                        batch,
+                        physics_helicity_id,
+                        resolved_helicity_id,
+                        output,
+                    );
+                }
+            }
+        }
+        self.prepare_parameters(common)?;
+
+        match &self.selectors {
+            RecurrenceNativeSelectors::TopologyReplay { .. } => self
+                .run_replay_view_into_unprofiled(
+                    physics.lc_selector_reduction_view(),
+                    common.normalization_factor,
+                    batch,
+                    selected_helicities,
+                    selected_colors,
+                    output,
+                ),
+            RecurrenceNativeSelectors::AllFlowUnion { .. } => self.run_union_view_into_unprofiled(
+                physics,
+                common.normalization_factor,
+                batch,
+                selected_helicities,
+                selected_colors,
+                output,
+            ),
+            RecurrenceNativeSelectors::ContractedColorUnion { .. } => self
+                .run_contracted_view_into_unprofiled(
+                    physics,
+                    common.normalization_factor,
+                    batch,
+                    selected_helicities,
+                    selected_colors,
+                    output,
+                ),
+        }
+    }
+
+    fn run_replay_view_into_unprofiled(
+        &mut self,
+        reduction: LcSelectorReductionView<'_>,
+        normalization_factor: f64,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let Some(selected_colors) = selected_colors else {
+            return visit_replay_color_indices(
+                reduction.color_components.len(),
+                None,
+                |color_index| {
+                    self.run_replay_color_view_into_unprofiled(
+                        reduction,
+                        normalization_factor,
+                        batch,
+                        selected_helicities,
+                        output,
+                        color_index,
+                    )
+                },
+            );
+        };
+
+        let mut color_indices = std::mem::take(&mut self.replay_color_index_scratch);
+        let result = (|| {
+            reduction.retain_selected_color_indices(selected_colors, &mut color_indices)?;
+            visit_replay_color_indices(
+                reduction.color_components.len(),
+                Some(&color_indices),
+                |color_index| {
+                    self.run_replay_color_view_into_unprofiled(
+                        reduction,
+                        normalization_factor,
+                        batch,
+                        selected_helicities,
+                        output,
+                        color_index,
+                    )
+                },
+            )
+        })();
+        self.replay_color_index_scratch = color_indices;
+        result
+    }
+
+    /// Restrict work only when the caller restricts the physical helicity
+    /// axis. The original helicity-summed selectors remain untouched. Plans
+    /// are prepared once per requested subset/flow, outside the point loop,
+    /// and retained across selector changes and intervening summed calls.
+    fn selected_replay_color_plan(
+        &mut self,
+        reduction: LcSelectorReductionView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        color_index: usize,
+    ) -> RusticolResult<Option<Arc<DirectReplaySelectorPlan>>> {
+        let Some(selected_helicities) = selected_helicities else {
+            return Ok(None);
+        };
+        if selected_helicities.len() == reduction.helicity_index_by_id.len() {
+            // Selector IDs were validated at the public boundary. Spelling
+            // out the complete axis is the same work as omitting it.
+            return Ok(None);
+        }
+        if let Some(plan) = self
+            .selected_replay_cache
+            .get(selected_helicities)
+            .and_then(|plans| plans.get(&color_index))
+        {
+            return Ok(Some(Arc::clone(plan)));
+        }
+        let RecurrenceNativeSelectors::TopologyReplay {
+            replay_selectors,
+            direct_helicity_to_physics,
+        } = &self.selectors
+        else {
+            return Err(RusticolError::internal(
+                "selected replay plan requires topology replay",
+            ));
+        };
+        let selector = replay_selectors.get(color_index).ok_or_else(|| {
+            RusticolError::integrity("recurrence replay selector is outside the public color axis")
+        })?;
+        let destinations = selected_replay_destination_ids(
+            self.scheduler.plan().amplitude_destinations(),
+            selector.representative_flow_id(),
+            selector.helicity_map(),
+            direct_helicity_to_physics,
+            reduction,
+            selected_helicities,
+        )?;
+        let program_key = (selector.representative_flow_id(), destinations);
+        // Different public flows and physical aliases can select the same
+        // representative currents. Share their dependency program instead
+        // of retaining another copy for every flow/permutation.
+        let selected = if let Some(program) = self.selected_replay_programs.get(&program_key) {
+            Arc::new(
+                self.scheduler
+                    .prepare_replay_selector_with_destination_program(selector, program)?,
+            )
+        } else {
+            let selected = Arc::new(
+                self.scheduler
+                    .prepare_replay_selector_for_destinations(selector, &program_key.1)?,
+            );
+            self.selected_replay_programs
+                .insert(program_key, Arc::clone(&selected));
+            selected
+        };
+        self.selected_replay_cache
+            .entry(selected_helicities.clone())
+            .or_default()
+            .insert(color_index, Arc::clone(&selected));
+        Ok(Some(selected))
+    }
+
+    #[inline(always)]
+    #[allow(clippy::too_many_arguments)]
+    fn run_replay_color_view_into_unprofiled(
+        &mut self,
+        reduction: LcSelectorReductionView<'_>,
+        normalization_factor: f64,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+        color_index: usize,
+    ) -> RusticolResult<()> {
+        if !reduction.color_is_computed(color_index) {
+            return Ok(());
+        }
+        let color_weight = reduction.color(color_index).coefficient();
+        let selected_replay =
+            self.selected_replay_color_plan(reduction, selected_helicities, color_index)?;
+
+        let mut tile_start = 0usize;
+        while tile_start < batch.point_count() {
+            let tile_stop =
+                (tile_start + self.effective_point_tile_size()).min(batch.point_count());
+            let point_count =
+                self.flatten_external_tile_view::<true>(batch.subview(tile_start, tile_stop)?)?;
+            let input_len = self.external_tile_input_len(point_count)?;
+            let (replay_selector, direct_helicity_to_physics) = match &self.selectors {
+                RecurrenceNativeSelectors::TopologyReplay {
+                    replay_selectors,
+                    direct_helicity_to_physics,
+                } => (
+                    replay_selectors.get(color_index).ok_or_else(|| {
+                        RusticolError::integrity(
+                            "recurrence replay selector is outside the public color axis",
+                        )
+                    })?,
+                    direct_helicity_to_physics,
+                ),
+                RecurrenceNativeSelectors::AllFlowUnion { .. } => unreachable!(),
+                RecurrenceNativeSelectors::ContractedColorUnion { .. } => unreachable!(),
+            };
+            let replay_selector = selected_replay.as_deref().unwrap_or(replay_selector);
+            let direct_output = self
+                .scheduler
+                .execute_replay_tile_from_external_planes::<false>(
+                    replay_selector,
+                    direct_point_count(point_count)?,
+                    &self.external_momenta[..input_len],
+                )?;
+
+            for amplitude in direct_output.selected_amplitudes() {
+                let amplitude = amplitude?;
+                let helicity_index = replay_destination_physics_helicity(
+                    replay_selector.helicity_map(),
+                    direct_helicity_to_physics,
+                    amplitude.destination.target_helicity_id_or_sentinel,
+                )?;
+                let helicity = reduction.helicity(helicity_index);
+                if !helicity.computed || helicity.structural_zero || helicity.coefficient == 0.0 {
+                    continue;
+                }
+                let helicity_weight =
+                    reduction.helicity_orbit_weight(selected_helicities, helicity_index);
+                if helicity_weight == 0.0 {
+                    continue;
+                }
+                let weight = helicity_weight * color_weight * normalization_factor;
+                accumulate_lc_diagonal_amplitude(
+                    point_count,
+                    weight,
+                    |point| (amplitude.real[point], amplitude.imaginary[point]),
+                    |point, value| output[tile_start + point] += value,
+                );
+            }
+            tile_start = tile_stop;
+        }
+        Ok(())
+    }
+
+    fn run_union_view_into_unprofiled(
+        &mut self,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        for helicity_index in 0..physics.manifest.helicities.len() {
+            if !recurrence_helicity_is_selected(physics, selected_helicities, helicity_index) {
+                continue;
+            }
+            let helicity = &physics.manifest.helicities[helicity_index];
+            if !helicity.computed || helicity.structural_zero || helicity.coefficient == 0.0 {
+                continue;
+            }
+            let selector = self.union_helicity_selector(helicity_index)?;
+            let mut tile_start = 0usize;
+            while tile_start < batch.point_count() {
+                let tile_stop =
+                    (tile_start + self.effective_point_tile_size()).min(batch.point_count());
+                let point_count =
+                    self.flatten_external_tile_view::<true>(batch.subview(tile_start, tile_stop)?)?;
+                let input_len = self.external_tile_input_len(point_count)?;
+                let destination_by_public_flow = match &self.selectors {
+                    RecurrenceNativeSelectors::AllFlowUnion {
+                        destination_by_public_flow,
+                        ..
+                    } => destination_by_public_flow,
+                    RecurrenceNativeSelectors::TopologyReplay { .. } => unreachable!(),
+                    RecurrenceNativeSelectors::ContractedColorUnion { .. } => unreachable!(),
+                };
+                let direct_output = self
+                    .scheduler
+                    .execute_union_tile_from_external_planes::<false>(
+                        &selector,
+                        direct_point_count(point_count)?,
+                        &self.external_momenta[..input_len],
+                    )?;
+
+                for color_index in 0..physics.manifest.color_components.len() {
+                    if !physics.color_is_computed(color_index)
+                        || !recurrence_color_is_selected(physics, selected_colors, color_index)
+                    {
+                        continue;
+                    }
+                    let destination_id =
+                        *destination_by_public_flow.get(color_index).ok_or_else(|| {
+                            RusticolError::integrity(
+                                "all-flow-union color is outside retained public coverage",
+                            )
+                        })?;
+                    let values_re =
+                        direct_output
+                            .destination_re(destination_id)
+                            .ok_or_else(|| {
+                                RusticolError::integrity(
+                                    "all-flow-union amplitude destination is absent",
+                                )
+                            })?;
+                    let values_im =
+                        direct_output
+                            .destination_im(destination_id)
+                            .ok_or_else(|| {
+                                RusticolError::integrity(
+                                    "all-flow-union amplitude destination is absent",
+                                )
+                            })?;
+                    let color_weight = physics.manifest.color_components[color_index].coefficient();
+                    let weight = helicity.coefficient * color_weight * normalization_factor;
+                    for point in 0..point_count {
+                        output[tile_start + point] += weight
+                            * values_re[point]
+                                .mul_add(values_re[point], values_im[point] * values_im[point]);
+                    }
+                }
+                tile_start = tile_stop;
+            }
+        }
+        Ok(())
+    }
+
+    fn run_contracted_view_into_unprofiled(
+        &mut self,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        batch: F64MomentumBatchView<'_>,
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        reject_contracted_color_selector(selected_colors)?;
+        let mut tile_start = 0usize;
+        while tile_start < batch.point_count() {
+            let tile_stop =
+                (tile_start + self.effective_point_tile_size()).min(batch.point_count());
+            let point_count =
+                self.flatten_external_tile_view::<true>(batch.subview(tile_start, tile_stop)?)?;
+            let input_len = self.external_tile_input_len(point_count)?;
+            self.execute_and_contract_contracted_tile(
+                point_count,
+                input_len,
+                physics,
+                selected_helicities,
+                normalization_factor,
+                false,
+                |point, _helicity, value| output[tile_start + point] += value,
+            )?;
+            tile_start = tile_stop;
+        }
+        Ok(())
+    }
+
+    pub(super) fn run_f64_with_global_selectors(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        match &self.selectors {
+            RecurrenceNativeSelectors::AllFlowUnion { .. } => {
+                return self.run_union_f64_with_global_selectors(
+                    common,
+                    batch,
+                    selected_helicities,
+                    selected_colors,
+                );
+            }
+            RecurrenceNativeSelectors::ContractedColorUnion { .. } => {
+                return self.run_contracted_f64_with_global_selectors(
+                    common,
+                    batch,
+                    selected_helicities,
+                    selected_colors,
+                );
+            }
+            RecurrenceNativeSelectors::TopologyReplay { .. } => {}
+        }
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "recurrence evaluation requires at least one point",
+            ));
+        }
+        let total_started = Instant::now();
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("recurrence execution requires physics metadata")
+        })?;
+        let reduction_view = physics.lc_selector_reduction_view();
+        let helicity_indices = reduction_view.selected_helicity_indices(selected_helicities)?;
+        let color_indices = reduction_view.selected_color_indices(selected_colors)?;
+        self.validate_public_axes(&physics, &helicity_indices, &color_indices)?;
+
+        let mut values = vec![0.0; batch.len()];
+        let profile_before = DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner);
+        let parameter_started = Instant::now();
+        self.prepare_parameters(common)?;
+        let parameter_setup = parameter_started.elapsed();
+        let mut external_momentum_flatten = Duration::ZERO;
+        let mut reduction = Duration::ZERO;
+
+        for color_index in color_indices {
+            if !reduction_view.color_is_computed(color_index) {
+                continue;
+            }
+            let color_weight = reduction_view.color(color_index).coefficient();
+            let selected_replay =
+                self.selected_replay_color_plan(reduction_view, selected_helicities, color_index)?;
+            let mut tile_start = 0usize;
+            while tile_start < batch.len() {
+                let tile_stop = (tile_start + self.effective_point_tile_size()).min(batch.len());
+                let flatten_started = Instant::now();
+                let point_count =
+                    self.flatten_external_tile::<true>(&batch[tile_start..tile_stop])?;
+                external_momentum_flatten += flatten_started.elapsed();
+                let input_len = point_count
+                    .checked_mul(self.external_source_count)
+                    .and_then(|values| values.checked_mul(4))
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(
+                            "recurrence external-momentum tile length overflows",
+                        )
+                    })?;
+                let (replay_selector, direct_helicity_to_physics) = match &self.selectors {
+                    RecurrenceNativeSelectors::TopologyReplay {
+                        replay_selectors,
+                        direct_helicity_to_physics,
+                    } => (
+                        replay_selectors.get(color_index).ok_or_else(|| {
+                            RusticolError::integrity(
+                                "recurrence replay selector is outside the public color axis",
+                            )
+                        })?,
+                        direct_helicity_to_physics,
+                    ),
+                    RecurrenceNativeSelectors::AllFlowUnion { .. } => unreachable!(),
+                    RecurrenceNativeSelectors::ContractedColorUnion { .. } => unreachable!(),
+                };
+                let replay_selector = selected_replay.as_deref().unwrap_or(replay_selector);
+                let output = self
+                    .scheduler
+                    .execute_replay_tile_from_external_planes::<true>(
+                        replay_selector,
+                        u32::try_from(point_count).map_err(|_| {
+                            RusticolError::invalid_argument(
+                                "recurrence point tile exceeds the native u32 ABI",
+                            )
+                        })?,
+                        &self.external_momenta[..input_len],
+                    )?;
+
+                let reduction_started = Instant::now();
+                for amplitude in output.selected_amplitudes() {
+                    let amplitude = amplitude?;
+                    let helicity_index = replay_destination_physics_helicity(
+                        replay_selector.helicity_map(),
+                        direct_helicity_to_physics,
+                        amplitude.destination.target_helicity_id_or_sentinel,
+                    )?;
+                    let helicity = reduction_view.helicity(helicity_index);
+                    if !helicity.computed || helicity.structural_zero || helicity.coefficient == 0.0
+                    {
+                        continue;
+                    }
+                    let helicity_weight =
+                        reduction_view.helicity_orbit_weight(selected_helicities, helicity_index);
+                    if helicity_weight == 0.0 {
+                        continue;
+                    }
+                    let weight = helicity_weight * color_weight * common.normalization_factor;
+                    accumulate_lc_diagonal_amplitude(
+                        point_count,
+                        weight,
+                        |point| (amplitude.real[point], amplitude.imaginary[point]),
+                        |point, value| values[tile_start + point] += value,
+                    );
+                }
+                reduction += reduction_started.elapsed();
+                tile_start = tile_stop;
+            }
+        }
+
+        Ok((
+            values,
+            direct_profile(
+                total_started.elapsed(),
+                parameter_setup,
+                external_momentum_flatten,
+                reduction,
+                profile_before,
+                DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner),
+            ),
+        ))
+    }
+
+    pub(super) fn run_resolved_f64(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        match &self.selectors {
+            RecurrenceNativeSelectors::AllFlowUnion { .. } => {
+                return self.run_union_resolved_f64(
+                    common,
+                    batch,
+                    selected_helicities,
+                    selected_colors,
+                );
+            }
+            RecurrenceNativeSelectors::ContractedColorUnion { .. } => {
+                return self.run_contracted_resolved_f64(
+                    common,
+                    batch,
+                    selected_helicities,
+                    selected_colors,
+                );
+            }
+            RecurrenceNativeSelectors::TopologyReplay { .. } => {}
+        }
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "resolved recurrence evaluation requires at least one point",
+            ));
+        }
+        let total_started = Instant::now();
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("resolved recurrence execution requires physics metadata")
+        })?;
+        let reduction_view = physics.lc_selector_reduction_view();
+        let helicity_indices = reduction_view.selected_helicity_indices(selected_helicities)?;
+        let color_indices = reduction_view.selected_color_indices(selected_colors)?;
+        self.validate_public_axes(&physics, &helicity_indices, &color_indices)?;
+        let output_layout =
+            LcResolvedOutputLayout::new(batch.len(), helicity_indices.len(), color_indices.len())?;
+        let mut values = vec![0.0; output_layout.output_len()?];
+        let mut helicity_position = vec![None; reduction_view.helicities.len()];
+        for (position, index) in helicity_indices.iter().copied().enumerate() {
+            helicity_position[index] = Some(position);
+        }
+
+        let profile_before = DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner);
+        let parameter_started = Instant::now();
+        self.prepare_parameters(common)?;
+        let parameter_setup = parameter_started.elapsed();
+        let mut external_momentum_flatten = Duration::ZERO;
+        let mut reduction = Duration::ZERO;
+
+        for (color_position, color_index) in color_indices.iter().copied().enumerate() {
+            if !reduction_view.color_is_computed(color_index) {
+                continue;
+            }
+            let color_weight = reduction_view.color(color_index).coefficient();
+            let selected_replay =
+                self.selected_replay_color_plan(reduction_view, selected_helicities, color_index)?;
+            let mut tile_start = 0usize;
+            while tile_start < batch.len() {
+                let tile_stop = (tile_start + self.effective_point_tile_size()).min(batch.len());
+                let flatten_started = Instant::now();
+                let point_count =
+                    self.flatten_external_tile::<true>(&batch[tile_start..tile_stop])?;
+                external_momentum_flatten += flatten_started.elapsed();
+                let input_len = point_count
+                    .checked_mul(self.external_source_count)
+                    .and_then(|count| count.checked_mul(4))
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(
+                            "recurrence external-momentum tile length overflows",
+                        )
+                    })?;
+                let (replay_selector, direct_helicity_to_physics) = match &self.selectors {
+                    RecurrenceNativeSelectors::TopologyReplay {
+                        replay_selectors,
+                        direct_helicity_to_physics,
+                    } => (
+                        replay_selectors.get(color_index).ok_or_else(|| {
+                            RusticolError::integrity(
+                                "recurrence replay selector is outside the public color axis",
+                            )
+                        })?,
+                        direct_helicity_to_physics,
+                    ),
+                    RecurrenceNativeSelectors::AllFlowUnion { .. } => unreachable!(),
+                    RecurrenceNativeSelectors::ContractedColorUnion { .. } => unreachable!(),
+                };
+                let replay_selector = selected_replay.as_deref().unwrap_or(replay_selector);
+                let output = self
+                    .scheduler
+                    .execute_replay_tile_from_external_planes::<true>(
+                        replay_selector,
+                        u32::try_from(point_count).map_err(|_| {
+                            RusticolError::invalid_argument(
+                                "recurrence point tile exceeds the native u32 ABI",
+                            )
+                        })?,
+                        &self.external_momenta[..input_len],
+                    )?;
+
+                let reduction_started = Instant::now();
+                for amplitude in output.selected_amplitudes() {
+                    let amplitude = amplitude?;
+                    let helicity_index = replay_destination_physics_helicity(
+                        replay_selector.helicity_map(),
+                        direct_helicity_to_physics,
+                        amplitude.destination.target_helicity_id_or_sentinel,
+                    )?;
+                    let helicity = reduction_view.helicity(helicity_index);
+                    if !helicity.computed || helicity.structural_zero || helicity.coefficient == 0.0
+                    {
+                        continue;
+                    }
+                    for physical_helicity in reduction_view.helicity_orbit_members(helicity_index) {
+                        let Some(helicity_position) = helicity_position[*physical_helicity] else {
+                            continue;
+                        };
+                        let weight = reduction_view.helicity(*physical_helicity).coefficient
+                            * color_weight
+                            * common.normalization_factor;
+                        accumulate_lc_diagonal_amplitude(
+                            point_count,
+                            weight,
+                            |point| (amplitude.real[point], amplitude.imaginary[point]),
+                            |point, value| {
+                                let target = output_layout
+                                    .index(tile_start + point, helicity_position, color_position)
+                                    .expect("validated resolved LC coordinate");
+                                values[target] += value;
+                            },
+                        );
+                    }
+                }
+                reduction += reduction_started.elapsed();
+                tile_start = tile_stop;
+            }
+        }
+
+        Ok((
+            ResolvedValues {
+                values,
+                point_count: batch.len(),
+                helicity_indices,
+                color_indices,
+            },
+            direct_profile(
+                total_started.elapsed(),
+                parameter_setup,
+                external_momentum_flatten,
+                reduction,
+                profile_before,
+                DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner),
+            ),
+        ))
+    }
+
+    fn run_contracted_f64_with_global_selectors(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "recurrence evaluation requires at least one point",
+            ));
+        }
+        reject_contracted_color_selector(selected_colors)?;
+        let total_started = Instant::now();
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("recurrence execution requires physics metadata")
+        })?;
+        let helicity_indices = physics.selected_helicity_indices(selected_helicities)?;
+        self.validate_public_axes(&physics, &helicity_indices, &[0])?;
+        let mut values = vec![0.0; batch.len()];
+        if selected_helicities.is_some_and(BTreeSet::is_empty) {
+            return Ok((values, RuntimeProfile::default()));
+        }
+        if let Some(selection) =
+            self.companion_singleton_selection(&physics, selected_helicities, selected_colors)?
+        {
+            return match selection {
+                CompanionSingletonSelection::StructuralZero => {
+                    Ok((values, RuntimeProfile::default()))
+                }
+                CompanionSingletonSelection::Runnable {
+                    physics_helicity_id,
+                    resolved_helicity_id,
+                } => {
+                    let profile = self.run_persisted_companion_profiled(
+                        common,
+                        &physics,
+                        batch,
+                        physics_helicity_id,
+                        resolved_helicity_id,
+                        |point, value| values[point] += value,
+                    )?;
+                    Ok((values, profile))
+                }
+            };
+        }
+        let profile_before = DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner);
+        let parameter_started = Instant::now();
+        self.prepare_parameters(common)?;
+        let parameter_setup = parameter_started.elapsed();
+        let mut external_momentum_flatten = Duration::ZERO;
+        let mut reduction = Duration::ZERO;
+
+        let mut tile_start = 0usize;
+        while tile_start < batch.len() {
+            let tile_stop = (tile_start + self.effective_point_tile_size()).min(batch.len());
+            let flatten_started = Instant::now();
+            let point_count = self.flatten_external_tile::<true>(&batch[tile_start..tile_stop])?;
+            external_momentum_flatten += flatten_started.elapsed();
+            let input_len = self.external_tile_input_len(point_count)?;
+            reduction += self.execute_and_contract_contracted_tile(
+                point_count,
+                input_len,
+                &physics,
+                selected_helicities,
+                common.normalization_factor,
+                true,
+                |point, _helicity, value| values[tile_start + point] += value,
+            )?;
+            tile_start = tile_stop;
+        }
+
+        Ok((
+            values,
+            direct_profile(
+                total_started.elapsed(),
+                parameter_setup,
+                external_momentum_flatten,
+                reduction,
+                profile_before,
+                DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner),
+            ),
+        ))
+    }
+
+    fn run_contracted_resolved_f64(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "resolved recurrence evaluation requires at least one point",
+            ));
+        }
+        reject_contracted_color_selector(selected_colors)?;
+        let total_started = Instant::now();
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("resolved recurrence execution requires physics metadata")
+        })?;
+        let helicity_indices = physics.selected_helicity_indices(selected_helicities)?;
+        self.validate_public_axes(&physics, &helicity_indices, &[0])?;
+        let mut helicity_position = vec![None; physics.manifest.helicities.len()];
+        for (position, index) in helicity_indices.iter().copied().enumerate() {
+            helicity_position[index] = Some(position);
+        }
+        let component_count = helicity_indices.len();
+        let mut values = vec![
+            0.0;
+            batch.len().checked_mul(component_count).ok_or_else(|| {
+                RusticolError::invalid_argument("recurrence resolved output overflows")
+            })?
+        ];
+        if selected_helicities.is_some_and(BTreeSet::is_empty) {
+            return Ok((
+                ResolvedValues {
+                    values,
+                    point_count: batch.len(),
+                    helicity_indices,
+                    color_indices: vec![0],
+                },
+                RuntimeProfile::default(),
+            ));
+        }
+        if let Some(selection) =
+            self.companion_singleton_selection(&physics, selected_helicities, selected_colors)?
+        {
+            let profile = match selection {
+                CompanionSingletonSelection::StructuralZero => RuntimeProfile::default(),
+                CompanionSingletonSelection::Runnable {
+                    physics_helicity_id,
+                    resolved_helicity_id,
+                } => {
+                    let position = helicity_position[physics_helicity_id]
+                        .expect("singleton persisted helicity has no resolved output position");
+                    self.run_persisted_companion_profiled(
+                        common,
+                        &physics,
+                        batch,
+                        physics_helicity_id,
+                        resolved_helicity_id,
+                        |point, value| {
+                            values[point * component_count + position] += value;
+                        },
+                    )?
+                }
+            };
+            return Ok((
+                ResolvedValues {
+                    values,
+                    point_count: batch.len(),
+                    helicity_indices,
+                    color_indices: vec![0],
+                },
+                profile,
+            ));
+        }
+        let profile_before = DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner);
+        let parameter_started = Instant::now();
+        self.prepare_parameters(common)?;
+        let parameter_setup = parameter_started.elapsed();
+        let mut external_momentum_flatten = Duration::ZERO;
+        let mut reduction = Duration::ZERO;
+
+        let mut tile_start = 0usize;
+        while tile_start < batch.len() {
+            let tile_stop = (tile_start + self.effective_point_tile_size()).min(batch.len());
+            let flatten_started = Instant::now();
+            let point_count = self.flatten_external_tile::<true>(&batch[tile_start..tile_stop])?;
+            external_momentum_flatten += flatten_started.elapsed();
+            let input_len = self.external_tile_input_len(point_count)?;
+            reduction += self.execute_and_contract_contracted_tile(
+                point_count,
+                input_len,
+                &physics,
+                selected_helicities,
+                common.normalization_factor,
+                true,
+                |point, helicity, value| {
+                    let position = helicity_position[helicity]
+                        .expect("selected contracted helicity has a result position");
+                    values[(tile_start + point) * component_count + position] += value;
+                },
+            )?;
+            tile_start = tile_stop;
+        }
+
+        Ok((
+            ResolvedValues {
+                values,
+                point_count: batch.len(),
+                helicity_indices,
+                color_indices: vec![0],
+            },
+            direct_profile(
+                total_started.elapsed(),
+                parameter_setup,
+                external_momentum_flatten,
+                reduction,
+                profile_before,
+                DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner),
+            ),
+        ))
+    }
+
+    fn run_union_f64_with_global_selectors(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(Vec<f64>, RuntimeProfile)> {
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "recurrence evaluation requires at least one point",
+            ));
+        }
+        let total_started = Instant::now();
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("recurrence execution requires physics metadata")
+        })?;
+        let helicity_indices = physics.selected_helicity_indices(selected_helicities)?;
+        let color_indices = physics.selected_color_indices(selected_colors)?;
+        self.validate_public_axes(&physics, &helicity_indices, &color_indices)?;
+        let color_destinations = color_indices
+            .iter()
+            .copied()
+            .map(|color_index| Ok((color_index, self.union_destination_id(color_index)?)))
+            .collect::<RusticolResult<Vec<_>>>()?;
+
+        let mut values = vec![0.0; batch.len()];
+        let profile_before = DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner);
+        let parameter_started = Instant::now();
+        self.prepare_parameters(common)?;
+        let parameter_setup = parameter_started.elapsed();
+        let mut external_momentum_flatten = Duration::ZERO;
+        let mut reduction = Duration::ZERO;
+
+        for helicity_index in helicity_indices {
+            let helicity = &physics.manifest.helicities[helicity_index];
+            if !helicity.computed || helicity.structural_zero || helicity.coefficient == 0.0 {
+                continue;
+            }
+            let selector = self.union_helicity_selector(helicity_index)?;
+            let mut tile_start = 0usize;
+            while tile_start < batch.len() {
+                let tile_stop = (tile_start + self.effective_point_tile_size()).min(batch.len());
+                let flatten_started = Instant::now();
+                let point_count =
+                    self.flatten_external_tile::<true>(&batch[tile_start..tile_stop])?;
+                external_momentum_flatten += flatten_started.elapsed();
+                let input_len = point_count
+                    .checked_mul(self.external_source_count)
+                    .and_then(|count| count.checked_mul(4))
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(
+                            "recurrence external-momentum tile length overflows",
+                        )
+                    })?;
+                let output = self
+                    .scheduler
+                    .execute_union_tile_from_external_planes::<true>(
+                        &selector,
+                        u32::try_from(point_count).map_err(|_| {
+                            RusticolError::invalid_argument(
+                                "recurrence point tile exceeds the native u32 ABI",
+                            )
+                        })?,
+                        &self.external_momenta[..input_len],
+                    )?;
+
+                let reduction_started = Instant::now();
+                for (color_index, destination_id) in color_destinations.iter().copied() {
+                    if !physics.color_is_computed(color_index) {
+                        continue;
+                    }
+                    let values_re = output.destination_re(destination_id).ok_or_else(|| {
+                        RusticolError::integrity("all-flow-union amplitude destination is absent")
+                    })?;
+                    let values_im = output.destination_im(destination_id).ok_or_else(|| {
+                        RusticolError::integrity("all-flow-union amplitude destination is absent")
+                    })?;
+                    let color_weight = physics.manifest.color_components[color_index].coefficient();
+                    let weight = helicity.coefficient * color_weight * common.normalization_factor;
+                    for point in 0..point_count {
+                        values[tile_start + point] += weight
+                            * values_re[point]
+                                .mul_add(values_re[point], values_im[point] * values_im[point]);
+                    }
+                }
+                reduction += reduction_started.elapsed();
+                tile_start = tile_stop;
+            }
+        }
+
+        Ok((
+            values,
+            direct_profile(
+                total_started.elapsed(),
+                parameter_setup,
+                external_momentum_flatten,
+                reduction,
+                profile_before,
+                DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner),
+            ),
+        ))
+    }
+
+    fn run_union_resolved_f64(
+        &mut self,
+        common: &mut ExecutionRuntime,
+        batch: &[Vec<[f64; 4]>],
+        selected_helicities: Option<&BTreeSet<String>>,
+        selected_colors: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<f64>, RuntimeProfile)> {
+        if batch.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "resolved recurrence evaluation requires at least one point",
+            ));
+        }
+        let total_started = Instant::now();
+        let physics = common.physics.clone().ok_or_else(|| {
+            RusticolError::artifact("resolved recurrence execution requires physics metadata")
+        })?;
+        let helicity_indices = physics.selected_helicity_indices(selected_helicities)?;
+        let color_indices = physics.selected_color_indices(selected_colors)?;
+        self.validate_public_axes(&physics, &helicity_indices, &color_indices)?;
+        let color_destinations = color_indices
+            .iter()
+            .copied()
+            .enumerate()
+            .map(|(color_position, color_index)| {
+                Ok((
+                    color_position,
+                    color_index,
+                    self.union_destination_id(color_index)?,
+                ))
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let component_count = helicity_indices
+            .len()
+            .checked_mul(color_indices.len())
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("recurrence resolved shape overflows")
+            })?;
+        let mut values = vec![
+            0.0;
+            batch.len().checked_mul(component_count).ok_or_else(|| {
+                RusticolError::invalid_argument("recurrence resolved output overflows")
+            })?
+        ];
+
+        let profile_before = DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner);
+        let parameter_started = Instant::now();
+        self.prepare_parameters(common)?;
+        let parameter_setup = parameter_started.elapsed();
+        let mut external_momentum_flatten = Duration::ZERO;
+        let mut reduction = Duration::ZERO;
+
+        for (helicity_position, helicity_index) in helicity_indices.iter().copied().enumerate() {
+            let helicity = &physics.manifest.helicities[helicity_index];
+            if !helicity.computed || helicity.structural_zero || helicity.coefficient == 0.0 {
+                continue;
+            }
+            let selector = self.union_helicity_selector(helicity_index)?;
+            let mut tile_start = 0usize;
+            while tile_start < batch.len() {
+                let tile_stop = (tile_start + self.effective_point_tile_size()).min(batch.len());
+                let flatten_started = Instant::now();
+                let point_count =
+                    self.flatten_external_tile::<true>(&batch[tile_start..tile_stop])?;
+                external_momentum_flatten += flatten_started.elapsed();
+                let input_len = point_count
+                    .checked_mul(self.external_source_count)
+                    .and_then(|count| count.checked_mul(4))
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(
+                            "recurrence external-momentum tile length overflows",
+                        )
+                    })?;
+                let output = self
+                    .scheduler
+                    .execute_union_tile_from_external_planes::<true>(
+                        &selector,
+                        u32::try_from(point_count).map_err(|_| {
+                            RusticolError::invalid_argument(
+                                "recurrence point tile exceeds the native u32 ABI",
+                            )
+                        })?,
+                        &self.external_momenta[..input_len],
+                    )?;
+
+                let reduction_started = Instant::now();
+                for (color_position, color_index, destination_id) in
+                    color_destinations.iter().copied()
+                {
+                    if !physics.color_is_computed(color_index) {
+                        continue;
+                    }
+                    let values_re = output.destination_re(destination_id).ok_or_else(|| {
+                        RusticolError::integrity("all-flow-union amplitude destination is absent")
+                    })?;
+                    let values_im = output.destination_im(destination_id).ok_or_else(|| {
+                        RusticolError::integrity("all-flow-union amplitude destination is absent")
+                    })?;
+                    let color_weight = physics.manifest.color_components[color_index].coefficient();
+                    let weight = helicity.coefficient * color_weight * common.normalization_factor;
+                    for point in 0..point_count {
+                        let target = (tile_start + point) * component_count
+                            + helicity_position * color_indices.len()
+                            + color_position;
+                        values[target] += weight
+                            * values_re[point]
+                                .mul_add(values_re[point], values_im[point] * values_im[point]);
+                    }
+                }
+                reduction += reduction_started.elapsed();
+                tile_start = tile_stop;
+            }
+        }
+
+        Ok((
+            ResolvedValues {
+                values,
+                point_count: batch.len(),
+                helicity_indices,
+                color_indices,
+            },
+            direct_profile(
+                total_started.elapsed(),
+                parameter_setup,
+                external_momentum_flatten,
+                reduction,
+                profile_before,
+                DirectProfileSnapshot::capture(&self.scheduler, &self._backend_owner),
+            ),
+        ))
+    }
+
+    fn union_helicity_selector(
+        &self,
+        physics_helicity_index: usize,
+    ) -> RusticolResult<DirectUnionHelicitySelectorPlan> {
+        match &self.selectors {
+            RecurrenceNativeSelectors::AllFlowUnion {
+                helicity_selectors_by_physics,
+                ..
+            } => helicity_selectors_by_physics
+                .get(physics_helicity_index)
+                .copied()
+                .flatten()
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "all-flow-union helicity is outside retained public coverage",
+                    )
+                }),
+            RecurrenceNativeSelectors::TopologyReplay { .. } => Err(RusticolError::integrity(
+                "union selector requested from topology replay",
+            )),
+            RecurrenceNativeSelectors::ContractedColorUnion { .. } => {
+                Err(RusticolError::integrity(
+                    "union selector requested from contracted-color recurrence",
+                ))
+            }
+        }
+    }
+
+    fn union_destination_id(&self, color_index: usize) -> RusticolResult<u32> {
+        match &self.selectors {
+            RecurrenceNativeSelectors::AllFlowUnion {
+                destination_by_public_flow,
+                ..
+            } => destination_by_public_flow
+                .get(color_index)
+                .copied()
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "all-flow-union color is outside retained public coverage",
+                    )
+                }),
+            RecurrenceNativeSelectors::TopologyReplay { .. } => Err(RusticolError::integrity(
+                "union destination requested from topology replay",
+            )),
+            RecurrenceNativeSelectors::ContractedColorUnion { .. } => {
+                Err(RusticolError::integrity(
+                    "union destination requested from contracted-color recurrence",
+                ))
+            }
+        }
+    }
+
+    fn prepare_parameters(&mut self, common: &ExecutionRuntime) -> RusticolResult<()> {
+        let (parameters_re, parameters_im) = self.scheduler.parameters_mut();
+        initialize_prepared_parameter_planes(
+            &self.parameter_defaults,
+            &self.parameter_projection,
+            &common.model_parameter_values_f64,
+            parameters_re,
+            parameters_im,
+        )
+    }
+
+    // The ordinary direct scheduler consumes contiguous source/component
+    // planes. Persisted-helicity companion entrypoints retain their existing
+    // point-major contract by requesting SOURCE_MAJOR=false. Both layouts use
+    // the same preallocated workspace and the same single input-copy pass.
+    fn flatten_external_tile<const SOURCE_MAJOR: bool>(
+        &mut self,
+        batch: &[Vec<[f64; 4]>],
+    ) -> RusticolResult<usize> {
+        let point_count = batch.len();
+        for point in batch {
+            if point.len() != self.external_source_count {
+                return Err(RusticolError::invalid_argument(format!(
+                    "recurrence point has {} external momenta, expected {}",
+                    point.len(),
+                    self.external_source_count
+                )));
+            }
+        }
+        ensure_external_momentum_workspace_capacity(
+            &mut self.external_momenta,
+            point_count,
+            self.external_source_count,
+            self.effective_point_tile_size,
+        )?;
+        for (point_index, point) in batch.iter().enumerate() {
+            for (source_slot, momentum) in point.iter().enumerate() {
+                write_external_momentum::<SOURCE_MAJOR>(
+                    &mut self.external_momenta,
+                    point_count,
+                    self.external_source_count,
+                    point_index,
+                    source_slot,
+                    momentum,
+                );
+            }
+        }
+        Ok(point_count)
+    }
+
+    fn flatten_external_tile_view<const SOURCE_MAJOR: bool>(
+        &mut self,
+        batch: F64MomentumBatchView<'_>,
+    ) -> RusticolResult<usize> {
+        let point_count = batch.point_count();
+        if batch.external_count() != self.external_source_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "recurrence input has {} external momenta, expected {}",
+                batch.external_count(),
+                self.external_source_count
+            )));
+        }
+        ensure_external_momentum_workspace_capacity(
+            &mut self.external_momenta,
+            point_count,
+            self.external_source_count,
+            self.effective_point_tile_size,
+        )?;
+        for point_index in 0..point_count {
+            let point = batch.point(point_index);
+            for source_slot in 0..self.external_source_count {
+                let momentum = point.momentum(source_slot).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "validated recurrence momentum view is missing an external leg",
+                    )
+                })?;
+                write_external_momentum::<SOURCE_MAJOR>(
+                    &mut self.external_momenta,
+                    point_count,
+                    self.external_source_count,
+                    point_index,
+                    source_slot,
+                    &momentum,
+                );
+            }
+        }
+        Ok(point_count)
+    }
+
+    fn external_tile_input_len(&self, point_count: usize) -> RusticolResult<usize> {
+        external_momentum_scalar_len(point_count, self.external_source_count)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn execute_and_contract_contracted_tile(
+        &mut self,
+        point_count: usize,
+        input_len: usize,
+        physics: &PhysicsRuntime,
+        selected_helicities: Option<&BTreeSet<String>>,
+        normalization_factor: f64,
+        profiled: bool,
+        accumulate: impl FnMut(usize, usize, f64),
+    ) -> RusticolResult<Duration> {
+        {
+            let RecurrenceNativeSelectors::ContractedColorUnion {
+                destination_physics_helicity,
+                ..
+            } = &self.selectors
+            else {
+                return Err(RusticolError::integrity(
+                    "contracted execution requested from a non-contracted recurrence",
+                ));
+            };
+            if let Some(selected_helicities) = selected_helicities
+                && !contracted_selection_has_computed_destination(
+                    destination_physics_helicity,
+                    physics,
+                    selected_helicities,
+                )?
+            {
+                // The selected public orbit is structural-zero or has no computed
+                // representative. The caller zeroed its output before entering
+                // this tile, so no recurrence, color work, or lazy FFT workspace
+                // is required. An absent selector deliberately still means full
+                // execution.
+                return Ok(Duration::ZERO);
+            }
+        }
+        self.ensure_primary_symmetric_group_color_workspace_for_capacity(point_count)?;
+        let Self {
+            scheduler,
+            selectors:
+                RecurrenceNativeSelectors::ContractedColorUnion {
+                    contraction,
+                    destination_physics_helicity,
+                    replay_routes,
+                },
+            external_momenta,
+            contracted_replay_re,
+            contracted_replay_im,
+            color_transform_re,
+            color_transform_im,
+            symmetric_group_color_workspace,
+            ..
+        } = self
+        else {
+            return Err(RusticolError::integrity(
+                "contracted execution requested from a non-contracted recurrence",
+            ));
+        };
+        let input = &external_momenta[..input_len];
+        let point_count_u32 = direct_point_count(point_count)?;
+
+        if replay_routes.is_empty() {
+            let direct_output = if profiled {
+                scheduler
+                    .execute_contracted_tile_from_external_planes::<true>(point_count_u32, input)?
+            } else {
+                scheduler
+                    .execute_contracted_tile_from_external_planes::<false>(point_count_u32, input)?
+            };
+            let reduction_started = profiled.then(Instant::now);
+            contract_color_tile(
+                &direct_output,
+                contraction,
+                destination_physics_helicity,
+                physics,
+                selected_helicities,
+                normalization_factor,
+                color_transform_re,
+                color_transform_im,
+                symmetric_group_color_workspace.as_mut(),
+                accumulate,
+            )?;
+            return Ok(reduction_started.map_or(Duration::ZERO, |started| started.elapsed()));
+        }
+
+        let point_stride = scheduler.point_tile_size() as usize;
+        let destination_count = contraction.destination_count() as usize;
+        let required = destination_count.checked_mul(point_stride).ok_or_else(|| {
+            RusticolError::integrity("contracted replay amplitude workspace overflows usize")
+        })?;
+        if contracted_replay_re.len() < required || contracted_replay_im.len() < required {
+            return Err(RusticolError::integrity(
+                "contracted replay amplitude workspace is too small",
+            ));
+        }
+        let mut replay_output_copy = Duration::ZERO;
+        for route in replay_routes {
+            let direct_output = if profiled {
+                scheduler.execute_replay_tile_from_external_planes::<true>(
+                    &route.selector,
+                    point_count_u32,
+                    input,
+                )?
+            } else {
+                scheduler.execute_replay_tile_from_external_planes::<false>(
+                    &route.selector,
+                    point_count_u32,
+                    input,
+                )?
+            };
+            // The scheduler profiles momentum fill, schedule execution, and
+            // replay scaling independently.  Start this clock only after it
+            // returns: including the scheduler call here would attribute the
+            // complete recurrence execution a second time as reduction.
+            let replay_output_copy_started = profiled.then(Instant::now);
+            for &(source_destination, physical_destination) in &route.destination_copies {
+                let source_re = direct_output
+                    .destination_re(source_destination)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "contracted replay source amplitude destination is absent",
+                        )
+                    })?;
+                let source_im = direct_output
+                    .destination_im(source_destination)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "contracted replay source amplitude destination is absent",
+                        )
+                    })?;
+                let start = physical_destination as usize * point_stride;
+                contracted_replay_re[start..start + point_count].copy_from_slice(source_re);
+                contracted_replay_im[start..start + point_count].copy_from_slice(source_im);
+            }
+            if let Some(started) = replay_output_copy_started {
+                replay_output_copy += started.elapsed();
+            }
+        }
+        let tile = ContractedReplayTile {
+            values_re: contracted_replay_re,
+            values_im: contracted_replay_im,
+            point_count,
+            point_stride,
+            destination_count,
+        };
+        let reduction_started = profiled.then(Instant::now);
+        contract_color_tile(
+            &tile,
+            contraction,
+            destination_physics_helicity,
+            physics,
+            selected_helicities,
+            normalization_factor,
+            color_transform_re,
+            color_transform_im,
+            symmetric_group_color_workspace.as_mut(),
+            accumulate,
+        )?;
+        Ok(replay_output_copy
+            + reduction_started.map_or(Duration::ZERO, |started| started.elapsed()))
+    }
+
+    fn ensure_primary_symmetric_group_color_workspace_for_capacity(
+        &mut self,
+        point_capacity: usize,
+    ) -> RusticolResult<()> {
+        let Self {
+            selectors,
+            symmetric_group_color_workspace,
+            ..
+        } = self;
+        let RecurrenceNativeSelectors::ContractedColorUnion { contraction, .. } = selectors else {
+            return Ok(());
+        };
+        let Some(RuntimeColorContractionReducer::SymmetricGroupFourier(reducer)) =
+            contraction.runtime_reducer()
+        else {
+            return Ok(());
+        };
+        ensure_symmetric_group_color_workspace_capacity(
+            symmetric_group_color_workspace,
+            reducer,
+            point_capacity,
+        )
+    }
+
+    fn validate_public_axis_lengths(&self, physics: &PhysicsRuntime) -> RusticolResult<()> {
+        let (color_count, helicity_count) = match &self.selectors {
+            RecurrenceNativeSelectors::TopologyReplay {
+                replay_selectors, ..
+            } => (replay_selectors.len(), physics.manifest.helicities.len()),
+            RecurrenceNativeSelectors::AllFlowUnion {
+                helicity_selectors_by_physics,
+                destination_by_public_flow,
+            } => (
+                destination_by_public_flow.len(),
+                helicity_selectors_by_physics.len(),
+            ),
+            RecurrenceNativeSelectors::ContractedColorUnion {
+                destination_physics_helicity,
+                ..
+            } => {
+                if destination_physics_helicity
+                    .iter()
+                    .any(|index| *index >= physics.manifest.helicities.len())
+                {
+                    return Err(RusticolError::integrity(
+                        "contracted recurrence maps a destination outside the public helicity axis",
+                    ));
+                }
+                (1, physics.manifest.helicities.len())
+            }
+        };
+        if color_count != physics.manifest.color_components.len()
+            || helicity_count != physics.manifest.helicities.len()
+        {
+            return Err(RusticolError::integrity(
+                "recurrence selectors do not cover the public physics axes",
+            ));
+        }
+        Ok(())
+    }
+
+    fn validate_public_axes(
+        &self,
+        physics: &PhysicsRuntime,
+        helicity_indices: &[usize],
+        color_indices: &[usize],
+    ) -> RusticolResult<()> {
+        self.validate_public_axis_lengths(physics)?;
+        let color_count = physics.manifest.color_components.len();
+        let helicity_count = physics.manifest.helicities.len();
+        if color_indices.iter().any(|index| *index >= color_count)
+            || helicity_indices
+                .iter()
+                .any(|index| *index >= helicity_count)
+        {
+            return Err(RusticolError::integrity(
+                "recurrence selector mapping is outside the public physics axes",
+            ));
+        }
+        Ok(())
+    }
+}
+
+fn lazy_symmetric_group_workspace_for_point_tile(
+    reducer: &crate::recurrence::RuntimeSymmetricGroupColorContraction,
+    requested_point_tile_size: usize,
+) -> RusticolResult<(usize, Option<RuntimeSymmetricGroupColorWorkspace>)> {
+    Ok((
+        reducer.bounded_lane_capacity(requested_point_tile_size)?,
+        None,
+    ))
+}
+
+fn ensure_symmetric_group_color_workspace_capacity(
+    workspace: &mut Option<RuntimeSymmetricGroupColorWorkspace>,
+    reducer: &crate::recurrence::RuntimeSymmetricGroupColorContraction,
+    point_capacity: usize,
+) -> RusticolResult<()> {
+    if let Some(workspace) = workspace.as_mut() {
+        return workspace.ensure_lane_capacity(reducer, point_capacity);
+    }
+    *workspace = Some(reducer.workspace(point_capacity)?);
+    Ok(())
+}
+
+fn external_momentum_scalar_len(
+    point_count: usize,
+    external_source_count: usize,
+) -> RusticolResult<usize> {
+    point_count
+        .checked_mul(external_source_count)
+        .and_then(|count| count.checked_mul(4))
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("recurrence external-momentum tile length overflows")
+        })
+}
+
+#[inline]
+fn write_external_momentum<const SOURCE_MAJOR: bool>(
+    output: &mut [f64],
+    point_count: usize,
+    source_count: usize,
+    point: usize,
+    source: usize,
+    momentum: &[f64; 4],
+) {
+    if SOURCE_MAJOR {
+        for (component, &value) in momentum.iter().enumerate() {
+            output[(source * 4 + component) * point_count + point] = value;
+        }
+    } else {
+        let start = (point * source_count + source) * 4;
+        output[start..start + 4].copy_from_slice(momentum);
+    }
+}
+
+fn ensure_external_momentum_workspace_capacity(
+    workspace: &mut Vec<f64>,
+    point_count: usize,
+    external_source_count: usize,
+    maximum_point_count: usize,
+) -> RusticolResult<usize> {
+    if point_count > maximum_point_count {
+        return Err(RusticolError::invalid_argument(
+            "recurrence point tile exceeds its persistent workspace",
+        ));
+    }
+    let required = external_momentum_scalar_len(point_count, external_source_count)?;
+    if workspace.len() < required {
+        workspace
+            .try_reserve_exact(required - workspace.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "recurrence external-momentum workspace allocation failed: {error}"
+                ))
+            })?;
+        workspace.resize(required, 0.0);
+    }
+    Ok(required)
+}
+
+fn validate_recurrence_selector_ids(
+    physics: &PhysicsRuntime,
+    selected_helicities: Option<&BTreeSet<String>>,
+    selected_colors: Option<&BTreeSet<String>>,
+) -> RusticolResult<()> {
+    if let Some(ids) = selected_helicities
+        && let Some(id) = ids
+            .iter()
+            .find(|id| !physics.helicity_index_by_id.contains_key(*id))
+    {
+        return Err(RusticolError::selector(format!(
+            "unknown resolved helicity id {id:?}"
+        )));
+    }
+    if let Some(ids) = selected_colors
+        && let Some(id) = ids
+            .iter()
+            .find(|id| !physics.color_index_by_id.contains_key(*id))
+    {
+        return Err(RusticolError::selector(format!(
+            "unknown resolved color component id {id:?}"
+        )));
+    }
+    Ok(())
+}
+
+#[inline(always)]
+fn recurrence_helicity_is_selected(
+    physics: &PhysicsRuntime,
+    selected: Option<&BTreeSet<String>>,
+    index: usize,
+) -> bool {
+    selected.is_none_or(|ids| ids.contains(&physics.manifest.helicities[index].id))
+}
+
+#[inline(always)]
+fn recurrence_helicity_orbit_weight(
+    physics: &PhysicsRuntime,
+    selected: Option<&BTreeSet<String>>,
+    representative_index: usize,
+) -> f64 {
+    physics
+        .helicity_orbit_members(representative_index)
+        .iter()
+        .copied()
+        .filter(|index| recurrence_helicity_is_selected(physics, selected, *index))
+        .map(|index| physics.manifest.helicities[index].coefficient)
+        .sum()
+}
+
+#[inline(always)]
+fn recurrence_color_is_selected(
+    physics: &PhysicsRuntime,
+    selected: Option<&BTreeSet<String>>,
+    index: usize,
+) -> bool {
+    selected.is_none_or(|ids| ids.contains(physics.manifest.color_components[index].id()))
+}
+
+fn direct_point_count(point_count: usize) -> RusticolResult<u32> {
+    u32::try_from(point_count).map_err(|_| {
+        RusticolError::invalid_argument("recurrence point tile exceeds the native u32 ABI")
+    })
+}
+
+fn reject_contracted_color_selector(
+    selected_colors: Option<&BTreeSet<String>>,
+) -> RusticolResult<()> {
+    if selected_colors.is_some() {
+        return Err(RusticolError::selector(
+            "contracted NLC/full recurrence does not expose a color-flow selector",
+        ));
+    }
+    Ok(())
+}
+
+fn contracted_destination_helicity_map(
+    contraction: &RecurrenceColorContraction,
+    direct_helicity_to_physics: &[usize],
+) -> RusticolResult<Vec<usize>> {
+    let destination_count = contraction.destination_count() as usize;
+    let group_count = contraction.group_count() as usize;
+    let symmetric_group = matches!(
+        contraction.runtime_reducer(),
+        Some(RuntimeColorContractionReducer::SymmetricGroupFourier(_))
+    );
+    if contraction.component_count() as usize != direct_helicity_to_physics.len()
+        || contraction.destination_by_group().len() != group_count
+        || contraction.sector_by_group().len() != group_count
+        || contraction.component_by_group().len() != group_count
+        || (!symmetric_group && group_count != destination_count)
+    {
+        return Err(RusticolError::integrity(
+            "contracted color dimensions disagree with the public helicity map",
+        ));
+    }
+
+    let mut destination_physics_helicity = vec![usize::MAX; destination_count];
+    for (group_id, destination_id) in contraction
+        .destination_by_group()
+        .iter()
+        .copied()
+        .enumerate()
+    {
+        let expected_direct_helicity = contraction.component_by_group()[group_id] as usize;
+        let physics_helicity = *direct_helicity_to_physics
+            .get(expected_direct_helicity)
+            .ok_or_else(|| {
+                RusticolError::integrity("contracted destination has no public helicity mapping")
+            })?;
+        let slot = destination_physics_helicity
+            .get_mut(destination_id as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "contracted destination mapping exceeds its authenticated range",
+                )
+            })?;
+        if *slot != usize::MAX {
+            return Err(RusticolError::integrity(
+                "contracted color map repeats an amplitude destination",
+            ));
+        }
+        *slot = physics_helicity;
+    }
+    if !symmetric_group && destination_physics_helicity.contains(&usize::MAX) {
+        return Err(RusticolError::integrity(
+            "contracted color map does not cover every amplitude destination",
+        ));
+    }
+    if !symmetric_group {
+        for entry in contraction.canonical_logical_entries() {
+            if contraction.component_by_group()[entry.left_group_id as usize]
+                != contraction.component_by_group()[entry.right_group_id as usize]
+            {
+                return Err(RusticolError::integrity(
+                    "contracted color entry mixes different helicity components",
+                ));
+            }
+        }
+    }
+    Ok(destination_physics_helicity)
+}
+
+fn contracted_selection_has_computed_destination(
+    destination_physics_helicity: &[usize],
+    physics: &PhysicsRuntime,
+    selected_helicities: &BTreeSet<String>,
+) -> RusticolResult<bool> {
+    for &helicity_index in destination_physics_helicity {
+        // Symmetric-group payloads may reserve authenticated amplitude slots
+        // that are absent from the active local-group table.
+        if helicity_index == usize::MAX {
+            continue;
+        }
+        let helicity = physics
+            .manifest
+            .helicities
+            .get(helicity_index)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "contracted destination selector references an absent public helicity",
+                )
+            })?;
+        if !helicity.computed
+            || helicity.structural_zero
+            || helicity.coefficient == 0.0
+            || recurrence_helicity_orbit_weight(physics, Some(selected_helicities), helicity_index)
+                == 0.0
+        {
+            continue;
+        }
+        return Ok(true);
+    }
+    Ok(false)
+}
+
+fn contracted_replay_routes(
+    scheduler: &DirectRecurrenceExecutionRuntime,
+    contraction: &RecurrenceColorContraction,
+) -> RusticolResult<Vec<ContractedReplayRoute>> {
+    let plan = scheduler.plan();
+    if plan.strategy() != RecurrenceStrategy::ContractedColorUnion {
+        return Err(RusticolError::integrity(
+            "contracted replay routes require a contracted-color plan",
+        ));
+    }
+    if plan.replay_targets().is_empty() {
+        if contraction.destination_count() as usize != plan.amplitude_destinations().len() {
+            return Err(RusticolError::integrity(
+                "non-replayed contracted color destinations disagree with the Direct plan",
+            ));
+        }
+        return Ok(Vec::new());
+    }
+    if contraction.sector_count() != plan.physical_sector_count()
+        || contraction.component_count() as usize != plan.resolved_helicities().len()
+    {
+        return Err(RusticolError::integrity(
+            "contracted replay domain disagrees with the Direct plan",
+        ));
+    }
+
+    let destination_count = contraction.destination_count() as usize;
+    let component_count = contraction.component_count() as usize;
+    let symmetric_group = matches!(
+        contraction.runtime_reducer(),
+        Some(RuntimeColorContractionReducer::SymmetricGroupFourier(_))
+    );
+    let mut covered = vec![false; destination_count];
+    let mut routes = Vec::with_capacity(plan.replay_targets().len());
+    for target in plan.replay_targets() {
+        let selector = scheduler.prepare_replay_selector(target.public_flow_id)?;
+        let target_sector = selector.public_flow_id() as usize;
+        let mut destination_copies = Vec::with_capacity(component_count);
+        for destination in plan
+            .amplitude_destinations()
+            .iter()
+            .filter(|destination| destination.target_sector_id == selector.representative_flow_id())
+        {
+            let direct_helicity = destination.target_helicity_id_or_sentinel;
+            if direct_helicity == DIRECT_NONE_U32 {
+                return Err(RusticolError::integrity(
+                    "contracted replay destination lacks a resolved helicity",
+                ));
+            }
+            let mapped_helicity = selector
+                .helicity_map()
+                .get(direct_helicity as usize)
+                .copied()
+                .ok_or_else(|| {
+                    RusticolError::integrity("contracted replay destination helicity is not mapped")
+                })? as usize;
+            let physical_destination = target_sector
+                .checked_mul(component_count)
+                .and_then(|offset| offset.checked_add(mapped_helicity))
+                .ok_or_else(|| {
+                    RusticolError::artifact(
+                        "contracted replay physical destination overflows usize",
+                    )
+                })?;
+            if physical_destination >= destination_count || covered[physical_destination] {
+                return Err(RusticolError::integrity(
+                    "contracted replay route is not a dense physical color/helicity bijection",
+                ));
+            }
+            if !symmetric_group
+                && (contraction.sector_by_group()[physical_destination] as usize != target_sector
+                    || contraction.component_by_group()[physical_destination] as usize
+                        != mapped_helicity
+                    || contraction.destination_by_group()[physical_destination] as usize
+                        != physical_destination)
+            {
+                return Err(RusticolError::integrity(
+                    "contracted replay route disagrees with the direct color projection",
+                ));
+            }
+            covered[physical_destination] = true;
+            destination_copies.push((
+                destination.id,
+                u32::try_from(physical_destination).map_err(|_| {
+                    RusticolError::artifact("contracted replay physical destination exceeds u32")
+                })?,
+            ));
+        }
+        if destination_copies.len() != component_count {
+            return Err(RusticolError::integrity(
+                "contracted replay representative lacks complete helicity coverage",
+            ));
+        }
+        routes.push(ContractedReplayRoute {
+            selector,
+            destination_copies,
+        });
+    }
+    if covered.contains(&false) {
+        return Err(RusticolError::integrity(
+            "contracted replay routes do not cover every physical color/helicity destination",
+        ));
+    }
+    Ok(routes)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn contract_primary_local_color_tile(
+    output: PersistedHelicityAmplitudeTileV1<'_>,
+    contraction: &RecurrenceColorContraction,
+    view: &PrimaryLocalColorViewV1,
+    physics: &PhysicsRuntime,
+    physics_helicity_id: usize,
+    normalization_factor: f64,
+    color_transform_re: &mut [f64],
+    color_transform_im: &mut [f64],
+    symmetric_group_workspace: Option<&mut RuntimeSymmetricGroupColorWorkspace>,
+    mut accumulate: impl FnMut(usize, f64),
+) -> RusticolResult<()> {
+    let helicity = physics
+        .manifest
+        .helicities
+        .get(physics_helicity_id)
+        .ok_or_else(|| {
+            RusticolError::integrity("persisted selector references an absent public helicity")
+        })?;
+    if helicity.structural_zero || helicity.coefficient == 0.0 {
+        return Err(RusticolError::internal(
+            "structural-zero helicity reached persisted color contraction",
+        ));
+    }
+    let scale = helicity.coefficient * normalization_factor;
+    match contraction.runtime_reducer() {
+        Some(RuntimeColorContractionReducer::Walsh(factorization)) => {
+            contract_primary_local_walsh_tile(
+                output,
+                factorization,
+                &view.auxiliary_destination_by_local_group,
+                scale,
+                color_transform_re,
+                color_transform_im,
+                &mut accumulate,
+            )
+        }
+        Some(RuntimeColorContractionReducer::SymmetricGroupFourier(reducer)) => {
+            let workspace = symmetric_group_workspace.ok_or_else(|| {
+                RusticolError::integrity("symmetric-group recurrence color workspace is absent")
+            })?;
+            contract_primary_local_symmetric_group_tile(
+                output,
+                reducer,
+                workspace,
+                &view.auxiliary_destination_by_local_group,
+                scale,
+                &mut accumulate,
+            )
+        }
+        None => {
+            contract_primary_local_direct_tile(output, contraction, view, scale, &mut accumulate)
+        }
+    }
+}
+
+fn contract_primary_local_direct_tile(
+    output: PersistedHelicityAmplitudeTileV1<'_>,
+    contraction: &RecurrenceColorContraction,
+    view: &PrimaryLocalColorViewV1,
+    scale: f64,
+    accumulate: &mut impl FnMut(usize, f64),
+) -> RusticolResult<()> {
+    for raw in contraction.entries() {
+        let local_group = |stored_group_id: u32| -> RusticolResult<usize> {
+            match contraction.storage() {
+                RecurrenceColorStorage::Repeated => {
+                    let local = stored_group_id as usize;
+                    if local >= view.auxiliary_destination_by_local_group.len() {
+                        return Err(RusticolError::integrity(
+                            "repeated primary color entry is outside its local group domain",
+                        ));
+                    }
+                    Ok(local)
+                }
+                RecurrenceColorStorage::Expanded => {
+                    let primary_destination = contraction
+                        .destination_by_group()
+                        .get(stored_group_id as usize)
+                        .copied()
+                        .ok_or_else(|| {
+                            RusticolError::integrity(
+                                "expanded primary color entry references an absent group",
+                            )
+                        })?;
+                    let local = view
+                        .local_group_by_primary_destination
+                        .get(primary_destination as usize)
+                        .copied()
+                        .ok_or_else(|| {
+                            RusticolError::integrity(
+                                "expanded primary color destination is out of bounds",
+                            )
+                        })?;
+                    if local == DIRECT_NONE_U32 {
+                        return Err(RusticolError::integrity(
+                            "expanded primary color destination has no local owner",
+                        ));
+                    }
+                    Ok(local as usize)
+                }
+                RecurrenceColorStorage::ConvolutionKernels => Err(RusticolError::internal(
+                    "factorized primary color reached the direct reducer",
+                )),
+            }
+        };
+        let left_local = local_group(raw.left_group_id)?;
+        let right_local = local_group(raw.right_group_id)?;
+        let entry = RuntimeColorContractionEntry {
+            left_destination_id: view.auxiliary_destination_by_local_group[left_local],
+            right_destination_id: view.auxiliary_destination_by_local_group[right_local],
+            coefficient_re: raw.weight_re * raw.symmetry_factor,
+            coefficient_im: raw.weight_im * raw.symmetry_factor,
+        };
+        let left_re = output.destination_re(entry.left_destination_id)?;
+        let left_im = output.destination_im(entry.left_destination_id)?;
+        let right_re = output.destination_re(entry.right_destination_id)?;
+        let right_im = output.destination_im(entry.right_destination_id)?;
+        for point in 0..output.point_count() as usize {
+            accumulate(
+                point,
+                scale
+                    * entry.contract_real_bilinear(
+                        left_re[point],
+                        left_im[point],
+                        right_re[point],
+                        right_im[point],
+                    ),
+            );
+        }
+    }
+    Ok(())
+}
+
+fn contract_primary_local_symmetric_group_tile(
+    output: PersistedHelicityAmplitudeTileV1<'_>,
+    reducer: &crate::recurrence::RuntimeSymmetricGroupColorContraction,
+    workspace: &mut RuntimeSymmetricGroupColorWorkspace,
+    auxiliary_destination_by_local_group: &[u32],
+    scale: f64,
+    accumulate: &mut impl FnMut(usize, f64),
+) -> RusticolResult<()> {
+    if reducer.local_group_count() != auxiliary_destination_by_local_group.len() {
+        return Err(RusticolError::integrity(
+            "symmetric-group primary local-color view has the wrong domain",
+        ));
+    }
+    let point_count = output.point_count() as usize;
+    reducer.reduce_lanes(workspace, point_count, |local_group, point| {
+        let destination = auxiliary_destination_by_local_group[local_group];
+        let real = output.destination_re(destination)?;
+        let imaginary = output.destination_im(destination)?;
+        Ok((real[point], imaginary[point]))
+    })?;
+    for (point, contracted) in workspace.reduced(point_count)?.iter().copied().enumerate() {
+        accumulate(point, scale * contracted);
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn contract_primary_local_walsh_tile(
+    output: PersistedHelicityAmplitudeTileV1<'_>,
+    factorization: &crate::recurrence::RuntimeFactorizedColorContraction,
+    auxiliary_destination_by_local_group: &[u32],
+    scale: f64,
+    color_transform_re: &mut [f64],
+    color_transform_im: &mut [f64],
+    accumulate: &mut impl FnMut(usize, f64),
+) -> RusticolResult<()> {
+    let point_count = output.point_count() as usize;
+    let local_group_count = auxiliary_destination_by_local_group.len();
+    let scratch_len = local_group_count.checked_mul(point_count).ok_or_else(|| {
+        RusticolError::integrity("factorized primary local-color scratch length overflows")
+    })?;
+    if color_transform_re.len() < scratch_len || color_transform_im.len() < scratch_len {
+        return Err(RusticolError::integrity(
+            "factorized primary local-color workspace has the wrong shape",
+        ));
+    }
+    let transform_re = &mut color_transform_re[..scratch_len];
+    let transform_im = &mut color_transform_im[..scratch_len];
+    for (local_group, destination) in auxiliary_destination_by_local_group
+        .iter()
+        .copied()
+        .enumerate()
+    {
+        let source_re = output.destination_re(destination)?;
+        let source_im = output.destination_im(destination)?;
+        let start = local_group * point_count;
+        transform_re[start..start + point_count].copy_from_slice(source_re);
+        transform_im[start..start + point_count].copy_from_slice(source_im);
+    }
+
+    if factorization.subgroup_order() == 4 {
+        let amplitude_scale = factorization.amplitude_scale();
+        for coset in factorization.cosets() {
+            let [g0, g1, g2, g3] = <[u32; 4]>::try_from(coset.as_slice()).map_err(|_| {
+                RusticolError::integrity("rank-two color factorization has a malformed coset")
+            })?;
+            let starts = [g0, g1, g2, g3].map(|group| group as usize * point_count);
+            for point in 0..point_count {
+                let re0 = transform_re[starts[0] + point];
+                let re1 = transform_re[starts[1] + point];
+                let re2 = transform_re[starts[2] + point];
+                let re3 = transform_re[starts[3] + point];
+                let im0 = transform_im[starts[0] + point];
+                let im1 = transform_im[starts[1] + point];
+                let im2 = transform_im[starts[2] + point];
+                let im3 = transform_im[starts[3] + point];
+                let re01 = re0 + re1;
+                let re23 = re2 + re3;
+                let re01_difference = re0 - re1;
+                let re23_difference = re2 - re3;
+                let im01 = im0 + im1;
+                let im23 = im2 + im3;
+                let im01_difference = im0 - im1;
+                let im23_difference = im2 - im3;
+                transform_re[starts[0] + point] = (re01 + re23) * amplitude_scale;
+                transform_re[starts[1] + point] =
+                    (re01_difference + re23_difference) * amplitude_scale;
+                transform_re[starts[2] + point] = (re01 - re23) * amplitude_scale;
+                transform_re[starts[3] + point] =
+                    (re01_difference - re23_difference) * amplitude_scale;
+                transform_im[starts[0] + point] = (im01 + im23) * amplitude_scale;
+                transform_im[starts[1] + point] =
+                    (im01_difference + im23_difference) * amplitude_scale;
+                transform_im[starts[2] + point] = (im01 - im23) * amplitude_scale;
+                transform_im[starts[3] + point] =
+                    (im01_difference - im23_difference) * amplitude_scale;
+            }
+        }
+    } else {
+        for coset in factorization.cosets() {
+            let mut stride = 1usize;
+            while stride < factorization.subgroup_order() {
+                for start in (0..factorization.subgroup_order()).step_by(stride * 2) {
+                    for offset in 0..stride {
+                        let left_start = coset[start + offset] as usize * point_count;
+                        let right_start = coset[start + stride + offset] as usize * point_count;
+                        for point in 0..point_count {
+                            let left_re = transform_re[left_start + point];
+                            let right_re = transform_re[right_start + point];
+                            let left_im = transform_im[left_start + point];
+                            let right_im = transform_im[right_start + point];
+                            transform_re[left_start + point] = left_re + right_re;
+                            transform_re[right_start + point] = left_re - right_re;
+                            transform_im[left_start + point] = left_im + right_im;
+                            transform_im[right_start + point] = left_im - right_im;
+                        }
+                    }
+                }
+                stride *= 2;
+            }
+        }
+    }
+
+    for entry in factorization.entries() {
+        let left_start = entry.left_group_index as usize * point_count;
+        let right_start = entry.right_group_index as usize * point_count;
+        for point in 0..point_count {
+            let product_re = transform_re[left_start + point].mul_add(
+                transform_re[right_start + point],
+                transform_im[left_start + point] * transform_im[right_start + point],
+            );
+            let product_im = transform_im[left_start + point].mul_add(
+                transform_re[right_start + point],
+                -transform_re[left_start + point] * transform_im[right_start + point],
+            );
+            let contracted = entry
+                .coefficient_re
+                .mul_add(product_re, -entry.coefficient_im * product_im);
+            accumulate(point, scale * contracted);
+        }
+    }
+    Ok(())
+}
+
+trait ContractedAmplitudeTile {
+    fn point_count(&self) -> usize;
+    fn destination_re(&self, destination_id: u32) -> Option<&[f64]>;
+    fn destination_im(&self, destination_id: u32) -> Option<&[f64]>;
+}
+
+impl ContractedAmplitudeTile for DirectRecurrenceTileOutput<'_> {
+    fn point_count(&self) -> usize {
+        DirectRecurrenceTileOutput::point_count(self) as usize
+    }
+
+    fn destination_re(&self, destination_id: u32) -> Option<&[f64]> {
+        DirectRecurrenceTileOutput::destination_re(self, destination_id)
+    }
+
+    fn destination_im(&self, destination_id: u32) -> Option<&[f64]> {
+        DirectRecurrenceTileOutput::destination_im(self, destination_id)
+    }
+}
+
+struct ContractedReplayTile<'a> {
+    values_re: &'a [f64],
+    values_im: &'a [f64],
+    point_count: usize,
+    point_stride: usize,
+    destination_count: usize,
+}
+
+impl ContractedAmplitudeTile for ContractedReplayTile<'_> {
+    fn point_count(&self) -> usize {
+        self.point_count
+    }
+
+    fn destination_re(&self, destination_id: u32) -> Option<&[f64]> {
+        self.destination(self.values_re, destination_id)
+    }
+
+    fn destination_im(&self, destination_id: u32) -> Option<&[f64]> {
+        self.destination(self.values_im, destination_id)
+    }
+}
+
+impl ContractedReplayTile<'_> {
+    fn destination<'a>(&self, values: &'a [f64], destination_id: u32) -> Option<&'a [f64]> {
+        let destination = destination_id as usize;
+        if destination >= self.destination_count {
+            return None;
+        }
+        let start = destination.checked_mul(self.point_stride)?;
+        values.get(start..start + self.point_count)
+    }
+}
+
+// These arguments are the authenticated tile views and selector/reduction
+// contract; grouping them would obscure ownership without reducing call state.
+#[allow(clippy::too_many_arguments)]
+fn contract_color_tile<T: ContractedAmplitudeTile>(
+    output: &T,
+    contraction: &RecurrenceColorContraction,
+    destination_physics_helicity: &[usize],
+    physics: &PhysicsRuntime,
+    selected_helicities: Option<&BTreeSet<String>>,
+    normalization_factor: f64,
+    color_transform_re: &mut [f64],
+    color_transform_im: &mut [f64],
+    symmetric_group_workspace: Option<&mut RuntimeSymmetricGroupColorWorkspace>,
+    mut accumulate: impl FnMut(usize, usize, f64),
+) -> RusticolResult<()> {
+    let point_count = output.point_count();
+    match contraction.runtime_reducer() {
+        Some(RuntimeColorContractionReducer::Walsh(factorization)) => {
+            return contract_factorized_color_tile(
+                output,
+                contraction,
+                factorization,
+                destination_physics_helicity,
+                physics,
+                selected_helicities,
+                normalization_factor,
+                color_transform_re,
+                color_transform_im,
+                &mut accumulate,
+            );
+        }
+        Some(RuntimeColorContractionReducer::SymmetricGroupFourier(reducer)) => {
+            let workspace = symmetric_group_workspace.ok_or_else(|| {
+                RusticolError::integrity("symmetric-group recurrence color workspace is absent")
+            })?;
+            return contract_symmetric_group_color_tile(
+                output,
+                contraction,
+                reducer,
+                workspace,
+                destination_physics_helicity,
+                physics,
+                selected_helicities,
+                normalization_factor,
+                &mut accumulate,
+            );
+        }
+        None => {}
+    }
+    for entry in contraction.runtime_entries() {
+        let left_helicity = *destination_physics_helicity
+            .get(entry.left_destination_id as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "contracted left destination has no public helicity mapping",
+                )
+            })?;
+        let right_helicity = *destination_physics_helicity
+            .get(entry.right_destination_id as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "contracted right destination has no public helicity mapping",
+                )
+            })?;
+        if left_helicity != right_helicity {
+            return Err(RusticolError::integrity(
+                "contracted color entry mixes public helicities",
+            ));
+        }
+        let helicity = physics
+            .manifest
+            .helicities
+            .get(left_helicity)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "contracted color entry references an absent public helicity",
+                )
+            })?;
+        if !helicity.computed || helicity.structural_zero || helicity.coefficient == 0.0 {
+            continue;
+        }
+        if recurrence_helicity_orbit_weight(physics, selected_helicities, left_helicity) == 0.0 {
+            continue;
+        }
+        let left_re = output
+            .destination_re(entry.left_destination_id)
+            .ok_or_else(|| {
+                RusticolError::integrity("contracted left amplitude destination is absent")
+            })?;
+        let left_im = output
+            .destination_im(entry.left_destination_id)
+            .ok_or_else(|| {
+                RusticolError::integrity("contracted left amplitude destination is absent")
+            })?;
+        let right_re = output
+            .destination_re(entry.right_destination_id)
+            .ok_or_else(|| {
+                RusticolError::integrity("contracted right amplitude destination is absent")
+            })?;
+        let right_im = output
+            .destination_im(entry.right_destination_id)
+            .ok_or_else(|| {
+                RusticolError::integrity("contracted right amplitude destination is absent")
+            })?;
+        for point in 0..point_count {
+            let contracted = entry.contract_real_bilinear(
+                left_re[point],
+                left_im[point],
+                right_re[point],
+                right_im[point],
+            );
+            for physical_helicity in physics.helicity_orbit_members(left_helicity) {
+                if !recurrence_helicity_is_selected(
+                    physics,
+                    selected_helicities,
+                    *physical_helicity,
+                ) {
+                    continue;
+                }
+                let scale = physics.manifest.helicities[*physical_helicity].coefficient
+                    * normalization_factor;
+                accumulate(point, *physical_helicity, scale * contracted);
+            }
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn contract_symmetric_group_color_tile<T: ContractedAmplitudeTile>(
+    output: &T,
+    contraction: &RecurrenceColorContraction,
+    reducer: &crate::recurrence::RuntimeSymmetricGroupColorContraction,
+    workspace: &mut RuntimeSymmetricGroupColorWorkspace,
+    destination_physics_helicity: &[usize],
+    physics: &PhysicsRuntime,
+    selected_helicities: Option<&BTreeSet<String>>,
+    normalization_factor: f64,
+    accumulate: &mut impl FnMut(usize, usize, f64),
+) -> RusticolResult<()> {
+    let point_count = output.point_count();
+    let component_count = contraction.component_count() as usize;
+    if reducer.local_group_count() != contraction.local_group_count() as usize {
+        return Err(RusticolError::integrity(
+            "symmetric-group recurrence reducer has the wrong local-group domain",
+        ));
+    }
+
+    for component_index in 0..component_count {
+        let representative_destination = contraction
+            .ordered_destination_id(0, component_index)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "symmetric-group recurrence component has no amplitude destination",
+                )
+            })?;
+        let helicity_index = *destination_physics_helicity
+            .get(representative_destination as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "symmetric-group recurrence destination has no public helicity mapping",
+                )
+            })?;
+        let helicity = physics
+            .manifest
+            .helicities
+            .get(helicity_index)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "symmetric-group recurrence component references an absent helicity",
+                )
+            })?;
+        if !helicity.computed || helicity.structural_zero || helicity.coefficient == 0.0 {
+            continue;
+        }
+        if recurrence_helicity_orbit_weight(physics, selected_helicities, helicity_index) == 0.0 {
+            continue;
+        }
+
+        for local_group_index in 0..reducer.local_group_count() {
+            let destination_id = contraction
+                .ordered_destination_id(local_group_index, component_index)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "symmetric-group recurrence local group has no amplitude destination",
+                    )
+                })?;
+            if destination_physics_helicity
+                .get(destination_id as usize)
+                .copied()
+                != Some(helicity_index)
+                || output.destination_re(destination_id).is_none()
+                || output.destination_im(destination_id).is_none()
+            {
+                return Err(RusticolError::integrity(
+                    "symmetric-group recurrence local groups mix helicities or lack amplitudes",
+                ));
+            }
+        }
+
+        reducer.reduce_lanes(workspace, point_count, |local_group_index, point| {
+            let destination_id = contraction
+                .ordered_destination_id(local_group_index, component_index)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "symmetric-group recurrence local group has no amplitude destination",
+                    )
+                })?;
+            let real = output.destination_re(destination_id).ok_or_else(|| {
+                RusticolError::integrity(
+                    "symmetric-group recurrence real amplitude destination is absent",
+                )
+            })?;
+            let imaginary = output.destination_im(destination_id).ok_or_else(|| {
+                RusticolError::integrity(
+                    "symmetric-group recurrence imaginary amplitude destination is absent",
+                )
+            })?;
+            Ok((
+                *real.get(point).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "symmetric-group recurrence real amplitude tile is too short",
+                    )
+                })?,
+                *imaginary.get(point).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "symmetric-group recurrence imaginary amplitude tile is too short",
+                    )
+                })?,
+            ))
+        })?;
+
+        for (point, contracted) in workspace.reduced(point_count)?.iter().copied().enumerate() {
+            for physical_helicity in physics.helicity_orbit_members(helicity_index) {
+                if !recurrence_helicity_is_selected(
+                    physics,
+                    selected_helicities,
+                    *physical_helicity,
+                ) {
+                    continue;
+                }
+                let scale = physics.manifest.helicities[*physical_helicity].coefficient
+                    * normalization_factor;
+                accumulate(point, *physical_helicity, scale * contracted);
+            }
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn contract_factorized_color_tile<T: ContractedAmplitudeTile>(
+    output: &T,
+    contraction: &RecurrenceColorContraction,
+    factorization: &crate::recurrence::RuntimeFactorizedColorContraction,
+    destination_physics_helicity: &[usize],
+    physics: &PhysicsRuntime,
+    selected_helicities: Option<&BTreeSet<String>>,
+    normalization_factor: f64,
+    color_transform_re: &mut [f64],
+    color_transform_im: &mut [f64],
+    accumulate: &mut impl FnMut(usize, usize, f64),
+) -> RusticolResult<()> {
+    let point_count = output.point_count();
+    let local_group_count = contraction.local_group_count() as usize;
+    let scratch_len = local_group_count.checked_mul(point_count).ok_or_else(|| {
+        RusticolError::integrity("factorized recurrence color scratch length overflows")
+    })?;
+    if color_transform_re.len() < scratch_len || color_transform_im.len() < scratch_len {
+        return Err(RusticolError::integrity(
+            "factorized recurrence color workspace is smaller than the point tile",
+        ));
+    }
+    let transform_re = &mut color_transform_re[..scratch_len];
+    let transform_im = &mut color_transform_im[..scratch_len];
+    let component_count = contraction.component_count() as usize;
+
+    for component_index in 0..component_count {
+        let representative_destination = contraction
+            .ordered_destination_id(0, component_index)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "factorized recurrence component has no amplitude destination",
+                )
+            })?;
+        let helicity_index = *destination_physics_helicity
+            .get(representative_destination as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "factorized recurrence destination has no public helicity mapping",
+                )
+            })?;
+        let helicity = physics
+            .manifest
+            .helicities
+            .get(helicity_index)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "factorized recurrence color component references an absent helicity",
+                )
+            })?;
+        if !helicity.computed || helicity.structural_zero || helicity.coefficient == 0.0 {
+            continue;
+        }
+        if recurrence_helicity_orbit_weight(physics, selected_helicities, helicity_index) == 0.0 {
+            continue;
+        }
+
+        for local_group_index in 0..local_group_count {
+            let destination_id = contraction
+                .ordered_destination_id(local_group_index, component_index)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "factorized recurrence local group has no amplitude destination",
+                    )
+                })?;
+            if destination_physics_helicity
+                .get(destination_id as usize)
+                .copied()
+                != Some(helicity_index)
+            {
+                return Err(RusticolError::integrity(
+                    "factorized recurrence local groups mix public helicities",
+                ));
+            }
+            let source_re = output.destination_re(destination_id).ok_or_else(|| {
+                RusticolError::integrity(
+                    "factorized recurrence real amplitude destination is absent",
+                )
+            })?;
+            let source_im = output.destination_im(destination_id).ok_or_else(|| {
+                RusticolError::integrity(
+                    "factorized recurrence imaginary amplitude destination is absent",
+                )
+            })?;
+            let start = local_group_index * point_count;
+            transform_re[start..start + point_count].copy_from_slice(source_re);
+            transform_im[start..start + point_count].copy_from_slice(source_im);
+        }
+
+        if factorization.subgroup_order() == 4 {
+            let amplitude_scale = factorization.amplitude_scale();
+            for coset in factorization.cosets() {
+                let [g0, g1, g2, g3] = <[u32; 4]>::try_from(coset.as_slice()).map_err(|_| {
+                    RusticolError::integrity(
+                        "rank-two recurrence color factorization has a malformed coset",
+                    )
+                })?;
+                let starts = [
+                    g0 as usize * point_count,
+                    g1 as usize * point_count,
+                    g2 as usize * point_count,
+                    g3 as usize * point_count,
+                ];
+                for point in 0..point_count {
+                    let re0 = transform_re[starts[0] + point];
+                    let re1 = transform_re[starts[1] + point];
+                    let re2 = transform_re[starts[2] + point];
+                    let re3 = transform_re[starts[3] + point];
+                    let im0 = transform_im[starts[0] + point];
+                    let im1 = transform_im[starts[1] + point];
+                    let im2 = transform_im[starts[2] + point];
+                    let im3 = transform_im[starts[3] + point];
+                    let re01 = re0 + re1;
+                    let re23 = re2 + re3;
+                    let re01_difference = re0 - re1;
+                    let re23_difference = re2 - re3;
+                    let im01 = im0 + im1;
+                    let im23 = im2 + im3;
+                    let im01_difference = im0 - im1;
+                    let im23_difference = im2 - im3;
+                    transform_re[starts[0] + point] = (re01 + re23) * amplitude_scale;
+                    transform_re[starts[1] + point] =
+                        (re01_difference + re23_difference) * amplitude_scale;
+                    transform_re[starts[2] + point] = (re01 - re23) * amplitude_scale;
+                    transform_re[starts[3] + point] =
+                        (re01_difference - re23_difference) * amplitude_scale;
+                    transform_im[starts[0] + point] = (im01 + im23) * amplitude_scale;
+                    transform_im[starts[1] + point] =
+                        (im01_difference + im23_difference) * amplitude_scale;
+                    transform_im[starts[2] + point] = (im01 - im23) * amplitude_scale;
+                    transform_im[starts[3] + point] =
+                        (im01_difference - im23_difference) * amplitude_scale;
+                }
+            }
+        } else {
+            for coset in factorization.cosets() {
+                let mut stride = 1usize;
+                while stride < factorization.subgroup_order() {
+                    for start in (0..factorization.subgroup_order()).step_by(stride * 2) {
+                        for offset in 0..stride {
+                            let left_group = coset[start + offset] as usize;
+                            let right_group = coset[start + stride + offset] as usize;
+                            let left_start = left_group * point_count;
+                            let right_start = right_group * point_count;
+                            for point in 0..point_count {
+                                let left_re = transform_re[left_start + point];
+                                let right_re = transform_re[right_start + point];
+                                let left_im = transform_im[left_start + point];
+                                let right_im = transform_im[right_start + point];
+                                transform_re[left_start + point] = left_re + right_re;
+                                transform_re[right_start + point] = left_re - right_re;
+                                transform_im[left_start + point] = left_im + right_im;
+                                transform_im[right_start + point] = left_im - right_im;
+                            }
+                        }
+                    }
+                    stride *= 2;
+                }
+            }
+        }
+
+        for entry in factorization.entries() {
+            let left_start = entry.left_group_index as usize * point_count;
+            let right_start = entry.right_group_index as usize * point_count;
+            for point in 0..point_count {
+                let product_re = transform_re[left_start + point].mul_add(
+                    transform_re[right_start + point],
+                    transform_im[left_start + point] * transform_im[right_start + point],
+                );
+                let product_im = transform_im[left_start + point].mul_add(
+                    transform_re[right_start + point],
+                    -transform_re[left_start + point] * transform_im[right_start + point],
+                );
+                let contracted = entry
+                    .coefficient_re
+                    .mul_add(product_re, -entry.coefficient_im * product_im);
+                for physical_helicity in physics.helicity_orbit_members(helicity_index) {
+                    if !recurrence_helicity_is_selected(
+                        physics,
+                        selected_helicities,
+                        *physical_helicity,
+                    ) {
+                        continue;
+                    }
+                    let scale = physics.manifest.helicities[*physical_helicity].coefficient
+                        * normalization_factor;
+                    accumulate(point, *physical_helicity, scale * contracted);
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn union_destination_ids(
+    plan: &DirectRecurrencePlan,
+    public_flow_ids: &[u32],
+) -> RusticolResult<Vec<u32>> {
+    if plan.strategy() != RecurrenceStrategy::AllFlowUnion {
+        return Err(RusticolError::integrity(
+            "union destination mapping requires an all-flow-union plan",
+        ));
+    }
+    let mut destination_by_sector = BTreeMap::new();
+    for destination in plan.amplitude_destinations() {
+        if destination.target_helicity_id_or_sentinel != DIRECT_NONE_U32 {
+            return Err(RusticolError::integrity(
+                "all-flow-union amplitude destination fixes a numerical helicity",
+            ));
+        }
+        if destination_by_sector
+            .insert(destination.target_sector_id, destination.id)
+            .is_some()
+        {
+            return Err(RusticolError::integrity(
+                "all-flow-union repeats a physical-flow destination",
+            ));
+        }
+    }
+    let result = public_flow_ids
+        .iter()
+        .map(|sector_id| {
+            destination_by_sector
+                .get(sector_id)
+                .copied()
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "all-flow-union public flow has no amplitude destination",
+                    )
+                })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    if result.iter().copied().collect::<BTreeSet<_>>()
+        != destination_by_sector
+            .values()
+            .copied()
+            .collect::<BTreeSet<_>>()
+    {
+        return Err(RusticolError::integrity(
+            "all-flow-union amplitude destinations do not match the public flow axis",
+        ));
+    }
+    Ok(result)
+}
+
+fn validate_replay_destination_helicity_mappings(
+    plan: &DirectRecurrencePlan,
+    replay_selectors: &[DirectReplaySelectorPlan],
+    direct_helicity_to_physics: &[usize],
+) -> RusticolResult<()> {
+    for destination in plan.amplitude_destinations() {
+        replay_target_helicity_index(
+            destination.target_helicity_id_or_sentinel,
+            plan.resolved_helicities().len(),
+        )?;
+    }
+
+    for selector in replay_selectors {
+        if selector.helicity_map().len() != plan.resolved_helicities().len() {
+            return Err(RusticolError::integrity(format!(
+                "recurrence replay flow {} has incomplete helicity coverage",
+                selector.public_flow_id()
+            )));
+        }
+        for mapped_direct_id in selector.helicity_map() {
+            replay_mapped_direct_physics_helicity(direct_helicity_to_physics, *mapped_direct_id)?;
+        }
+    }
+    Ok(())
+}
+
+/// Resolve selection in the physical helicity domain, after the requested
+/// flow's relabelling. A parity/numerical alias requests its computed
+/// representative's destination; a structural zero requests no work.
+fn selected_replay_destination_ids(
+    destinations: &[DirectAmplitudeDestinationDescriptor],
+    representative_flow_id: u32,
+    replay_helicity_map: &[u32],
+    direct_helicity_to_physics: &[usize],
+    reduction: LcSelectorReductionView<'_>,
+    selected_helicities: &BTreeSet<String>,
+) -> RusticolResult<Vec<u32>> {
+    let mut selected = Vec::new();
+    for destination in destinations {
+        if destination.target_sector_id != representative_flow_id {
+            continue;
+        }
+        let physics_helicity = replay_destination_physics_helicity(
+            replay_helicity_map,
+            direct_helicity_to_physics,
+            destination.target_helicity_id_or_sentinel,
+        )?;
+        let helicity = reduction.helicity(physics_helicity);
+        if helicity.computed
+            && !helicity.structural_zero
+            && helicity.coefficient != 0.0
+            && reduction.helicity_orbit_weight(Some(selected_helicities), physics_helicity) != 0.0
+        {
+            selected.push(destination.id);
+        }
+    }
+    Ok(selected)
+}
+
+fn replay_destination_physics_helicity(
+    replay_helicity_map: &[u32],
+    direct_helicity_to_physics: &[usize],
+    target_helicity_id_or_sentinel: u32,
+) -> RusticolResult<usize> {
+    let target_helicity_index =
+        replay_target_helicity_index(target_helicity_id_or_sentinel, replay_helicity_map.len())?;
+    let mapped_direct_id = replay_helicity_map[target_helicity_index];
+    replay_mapped_direct_physics_helicity(direct_helicity_to_physics, mapped_direct_id)
+}
+
+fn replay_target_helicity_index(
+    target_helicity_id_or_sentinel: u32,
+    helicity_count: usize,
+) -> RusticolResult<usize> {
+    if target_helicity_id_or_sentinel == DIRECT_NONE_U32 {
+        return Err(RusticolError::integrity(
+            "topology-replay amplitude destination lacks a resolved helicity",
+        ));
+    }
+    let target_helicity_index = target_helicity_id_or_sentinel as usize;
+    if target_helicity_index >= helicity_count {
+        return Err(RusticolError::integrity(
+            "recurrence amplitude destination helicity is not replay-mapped",
+        ));
+    }
+    Ok(target_helicity_index)
+}
+
+fn replay_mapped_direct_physics_helicity(
+    direct_helicity_to_physics: &[usize],
+    mapped_direct_id: u32,
+) -> RusticolResult<usize> {
+    direct_helicity_to_physics
+        .get(mapped_direct_id as usize)
+        .copied()
+        .ok_or_else(|| {
+            RusticolError::integrity("recurrence replay helicity has no public physics mapping")
+        })
+}
+
+#[cfg(test)]
+mod replay_destination_helicity_tests {
+    use super::*;
+
+    fn auxiliary_physical_destinations(count: u32) -> Vec<DirectAmplitudeDestinationDescriptor> {
+        (0..count)
+            .map(|id| DirectAmplitudeDestinationDescriptor {
+                closure_row_start: 0,
+                id,
+                target_sector_id: id,
+                target_helicity_id_or_sentinel: DIRECT_NONE_U32,
+                closure_row_count: 0,
+                selector_domain_id: 0,
+            })
+            .collect()
+    }
+
+    #[test]
+    fn primary_local_color_view_uses_dense_owner_ranks_and_supports_expanded_one_component() {
+        let contraction =
+            RecurrenceColorContraction::symmetric_group_s3_for_runtime_test((0..13).collect(), 13)
+                .with_sparse_sector_domain_for_runtime_test();
+        let mut auxiliary = auxiliary_physical_destinations(13);
+        for destination in &mut auxiliary {
+            destination.id = 12 - destination.id;
+        }
+        auxiliary.reverse();
+        let view = primary_local_color_destination_map(&contraction, &auxiliary).unwrap();
+        assert_eq!(
+            view.auxiliary_destination_by_local_group.as_ref(),
+            &[12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
+        );
+
+        let expanded = RecurrenceColorContraction::expanded_identity_for_runtime_test();
+        let expanded_view =
+            primary_local_color_destination_map(&expanded, &auxiliary_physical_destinations(1))
+                .unwrap();
+        assert_eq!(
+            expanded_view.auxiliary_destination_by_local_group.as_ref(),
+            &[0]
+        );
+        assert_eq!(
+            expanded_view.local_group_by_primary_destination.as_ref(),
+            &[0]
+        );
+    }
+
+    #[test]
+    fn primary_local_color_view_rejects_reordered_auxiliary_sector_identity() {
+        let contraction =
+            RecurrenceColorContraction::symmetric_group_s3_for_runtime_test((0..13).collect(), 13)
+                .with_sparse_sector_domain_for_runtime_test();
+        let mut auxiliary = auxiliary_physical_destinations(13);
+        auxiliary[0].target_sector_id = 1;
+        let error = match primary_local_color_destination_map(&contraction, &auxiliary) {
+            Ok(_) => panic!("duplicate/missing dense auxiliary owner must fail closed"),
+            Err(error) => error,
+        };
+        assert!(
+            error
+                .message()
+                .contains("repeats an auxiliary physical sector")
+        );
+    }
+
+    #[test]
+    fn persisted_companion_census_keeps_legacy_outer_contract() {
+        let cold = RecurrenceNativeRuntime::persisted_helicity_selector_state_census(
+            "gg_to_gg",
+            PersistedHelicityFamilyCacheCensusV1::default(),
+            None,
+        );
+        assert_eq!(cold["kind"], "rusticol-on-the-fly-runtime-state-census-v1");
+        assert_eq!(cold["family_cache_policy"], "last-family-only");
+        assert_eq!(cold["family_cache_limit"], 1);
+        assert_eq!(cold["retained_family_count"], 0);
+        assert_eq!(cold["retained_executor_handle_count"], 0);
+        assert!(cold["active_family_union_census"].is_null());
+
+        let warm = RecurrenceNativeRuntime::persisted_helicity_selector_state_census(
+            "gg_to_gg",
+            PersistedHelicityFamilyCacheCensusV1 {
+                resolved_helicity_count: 4,
+                retained_family_count: 1,
+                retained_row_count: 17,
+                active_resolved_helicity_id: Some(2),
+            },
+            Some(PersistedHelicityFamilyInspectionCensusV1 {
+                query_count: 3,
+                union_unique_current_count: 5,
+                union_unique_current_component_count: 9,
+                union_source_rows: 2,
+                union_contribution_rows: 7,
+                union_finalization_rows: 2,
+                union_closure_rows: 3,
+                union_amplitude_destination_count: 3,
+                union_source_executor_call_groups: 1,
+                union_contribution_executor_call_groups: 2,
+                union_finalization_executor_call_groups: 1,
+                union_closure_executor_call_groups: 1,
+                semantic_executor_binding_count: 4,
+            }),
+        );
+        assert_eq!(warm["process_preparation_count"], 1);
+        assert_eq!(warm["retained_family_count"], 1);
+        assert_eq!(warm["retained_selection_count"], 1);
+        assert_eq!(warm["retained_request_count"], 3);
+        assert_eq!(warm["retained_amplitude_destination_count"], 3);
+        assert_eq!(warm["retained_executor_handle_count"], 1);
+        assert_eq!(warm["semantic_executor_binding_count"], 4);
+        assert_eq!(
+            warm["active_family_union_census"]["union_unique_current_count"],
+            5
+        );
+        assert_eq!(warm["active_family_union_census"]["union_closure_rows"], 3);
+        let fields = warm
+            .as_object()
+            .expect("persisted census must be an object")
+            .keys()
+            .map(String::as_str)
+            .collect::<BTreeSet<_>>();
+        assert_eq!(
+            fields,
+            BTreeSet::from([
+                "kind",
+                "process_id",
+                "family_cache_policy",
+                "family_cache_limit",
+                "process_preparation_count",
+                "retained_family_count",
+                "pending_family_count",
+                "retained_selection_count",
+                "retained_request_count",
+                "retained_amplitude_destination_count",
+                "retained_executor_handle_count",
+                "retained_query_local_trace_count",
+                "retained_embedded_lookup_key_count",
+                "semantic_executor_binding_count",
+                "active_family_union_census",
+            ])
+        );
+    }
+
+    #[test]
+    fn prepared_parameter_projection_validates_before_modifying_planes() {
+        let defaults = [
+            crate::EagerComplex64::new(1.0, -1.0),
+            crate::EagerComplex64::new(2.0, -2.0),
+        ];
+        let runtime_values = [11.0, 22.0];
+        let mut real = [91.0, 92.0];
+        let mut imaginary = [-91.0, -92.0];
+        let invalid = [PreparedParameterProjectionEntry {
+            runtime_slot: 2,
+            prepared_slot: 0,
+            component: 0,
+        }];
+
+        initialize_prepared_parameter_planes(
+            &defaults,
+            &invalid,
+            &runtime_values,
+            &mut real,
+            &mut imaginary,
+        )
+        .expect_err("invalid projection must fail closed");
+        assert_eq!(real, [91.0, 92.0]);
+        assert_eq!(imaginary, [-91.0, -92.0]);
+
+        let projection = [
+            PreparedParameterProjectionEntry {
+                runtime_slot: 1,
+                prepared_slot: 0,
+                component: 0,
+            },
+            PreparedParameterProjectionEntry {
+                runtime_slot: 0,
+                prepared_slot: 1,
+                component: 1,
+            },
+        ];
+        initialize_prepared_parameter_planes(
+            &defaults,
+            &projection,
+            &runtime_values,
+            &mut real,
+            &mut imaginary,
+        )
+        .unwrap();
+        assert_eq!(real, [22.0, 2.0]);
+        assert_eq!(imaginary, [-1.0, 11.0]);
+    }
+
+    #[test]
+    fn resolved_lc_output_layout_is_point_helicity_color_major() {
+        let layout = LcResolvedOutputLayout::new(2, 3, 4).unwrap();
+        assert_eq!(layout.output_len().unwrap(), 24);
+        assert_eq!(layout.index(0, 0, 0).unwrap(), 0);
+        assert_eq!(layout.index(0, 1, 0).unwrap(), 4);
+        assert_eq!(layout.index(1, 0, 0).unwrap(), 12);
+        assert_eq!(layout.index(1, 2, 3).unwrap(), 23);
+        assert!(layout.index(2, 0, 0).is_err());
+        assert!(LcResolvedOutputLayout::new(1, 0, 1).is_err());
+    }
+
+    #[test]
+    fn compact_lc_selector_reduction_view_matches_topology_replay_semantics() {
+        let helicities = vec![
+            crate::Helicity {
+                id: "h0".into(),
+                index: 0,
+                values: vec![1, -1],
+                computed: true,
+                structural_zero: false,
+                representative_id: "h0".into(),
+                coefficient: 0.25,
+            },
+            crate::Helicity {
+                id: "h1".into(),
+                index: 1,
+                values: vec![-1, 1],
+                computed: false,
+                structural_zero: false,
+                representative_id: "h0".into(),
+                coefficient: 0.75,
+            },
+        ];
+        let colors = vec![
+            crate::ColorComponent::LcFlow(crate::LcColorFlow {
+                id: "c0".into(),
+                index: 0,
+                word: vec![0, 1],
+                computed: true,
+                representative_id: "c0".into(),
+                coefficient: 2.0,
+            }),
+            crate::ColorComponent::LcFlow(crate::LcColorFlow {
+                id: "c1".into(),
+                index: 1,
+                word: vec![1, 0],
+                computed: false,
+                representative_id: "c0".into(),
+                coefficient: 3.0,
+            }),
+        ];
+        let helicity_ids = BTreeMap::from([("h0".into(), 0), ("h1".into(), 1)]);
+        let color_ids = BTreeMap::from([("c0".into(), 0), ("c1".into(), 1)]);
+        let orbits = vec![vec![0, 1], Vec::new()];
+        let view = LcSelectorReductionView::from_parts(
+            &helicities,
+            &colors,
+            &helicity_ids,
+            &color_ids,
+            &orbits,
+        );
+        let selected_helicities = BTreeSet::from(["h1".to_string()]);
+        let selected_colors = BTreeSet::from(["c0".to_string()]);
+
+        view.validate_selector_ids(Some(&selected_helicities), Some(&selected_colors))
+            .unwrap();
+        assert_eq!(
+            view.selected_helicity_indices(Some(&selected_helicities))
+                .unwrap(),
+            [1]
+        );
+        assert_eq!(
+            view.selected_color_indices(Some(&selected_colors)).unwrap(),
+            [0]
+        );
+        assert_eq!(view.helicity_orbit_weight(None, 0), 1.0);
+        assert_eq!(
+            view.helicity_orbit_weight(Some(&selected_helicities), 0),
+            0.75
+        );
+        assert!(view.color_is_computed(0));
+        assert!(!view.color_is_computed(1));
+        assert!(view.color_is_selected(Some(&selected_colors), 0));
+        assert!(
+            view.validate_selector_ids(Some(&BTreeSet::from(["missing".into()])), None)
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn selected_replay_destinations_follow_flow_permutation_and_physical_orbits() {
+        let helicities = (0..5)
+            .map(|index| crate::Helicity {
+                id: format!("h{index}"),
+                index,
+                values: Vec::new(),
+                computed: !matches!(index, 1 | 3),
+                structural_zero: index == 3,
+                representative_id: format!("h{}", if index == 1 { 0 } else { index }),
+                coefficient: if index == 4 { 0.0 } else { 1.0 },
+            })
+            .collect::<Vec<_>>();
+        let helicity_ids = helicities
+            .iter()
+            .enumerate()
+            .map(|(index, helicity)| (helicity.id.clone(), index))
+            .collect::<BTreeMap<_, _>>();
+        let colors = BTreeMap::new();
+        let orbits = vec![vec![0, 1], vec![], vec![2], vec![], vec![4]];
+        let reduction =
+            LcSelectorReductionView::from_parts(&helicities, &[], &helicity_ids, &colors, &orbits);
+        let mut destinations = (0..4)
+            .map(|id| DirectAmplitudeDestinationDescriptor {
+                id,
+                target_sector_id: 7,
+                target_helicity_id_or_sentinel: id,
+                closure_row_start: 0,
+                closure_row_count: 0,
+                selector_domain_id: 0,
+            })
+            .collect::<Vec<_>>();
+        destinations.push(DirectAmplitudeDestinationDescriptor {
+            id: 4,
+            target_sector_id: 8,
+            target_helicity_id_or_sentinel: 0,
+            closure_row_start: 0,
+            closure_row_count: 0,
+            selector_domain_id: 0,
+        });
+        let selected = |ids: &[&str]| {
+            selected_replay_destination_ids(
+                &destinations,
+                7,
+                &[1, 0, 2, 3],
+                &[0, 2, 3, 4],
+                reduction,
+                &ids.iter().map(|id| (*id).to_string()).collect(),
+            )
+            .unwrap()
+        };
+
+        // Selecting an uncomputed physical alias must retain the current of
+        // its computed representative, after the non-identity flow map.
+        assert_eq!(selected(&["h1"]), [1]);
+        assert_eq!(selected(&["h0"]), [1]);
+        assert_eq!(selected(&["h2"]), [0]);
+        assert_eq!(selected(&["h1", "h2"]), [0, 1]);
+        assert_eq!(selected(&["h0", "h1"]), [1]);
+        assert!(selected(&["h3"]).is_empty());
+        assert!(selected(&["h4"]).is_empty());
+        assert!(selected(&[]).is_empty());
+        let invalid = BTreeSet::from(["not-a-helicity".to_string()]);
+        assert!(
+            reduction
+                .validate_selector_ids(Some(&invalid), None)
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn unprofiled_replay_selected_colors_are_sorted_by_public_index() {
+        let helicity_ids = BTreeMap::new();
+        let color_ids = BTreeMap::from([
+            ("alpha".to_string(), 4),
+            ("middle".to_string(), 0),
+            ("zeta".to_string(), 2),
+        ]);
+        let view = LcSelectorReductionView::from_parts(&[], &[], &helicity_ids, &color_ids, &[]);
+        let selected = BTreeSet::from([
+            "alpha".to_string(),
+            "middle".to_string(),
+            "zeta".to_string(),
+        ]);
+        let mut scratch = vec![usize::MAX];
+
+        view.retain_selected_color_indices(&selected, &mut scratch)
+            .unwrap();
+
+        assert_eq!(scratch, [0, 2, 4]);
+        let mut visited = Vec::new();
+        visit_replay_color_indices(5, Some(&scratch), |color_index| {
+            visited.push(color_index);
+            Ok(())
+        })
+        .unwrap();
+        assert_eq!(visited, scratch);
+    }
+
+    #[test]
+    fn unprofiled_replay_all_colors_keep_public_axis_order() {
+        let mut visited = Vec::new();
+        visit_replay_color_indices(4, None, |color_index| {
+            visited.push(color_index);
+            Ok(())
+        })
+        .unwrap();
+        assert_eq!(visited, [0, 1, 2, 3]);
+    }
+
+    #[test]
+    fn unprofiled_replay_color_scratch_retains_allocation() {
+        let helicity_ids = BTreeMap::new();
+        let color_ids = BTreeMap::from([
+            ("c0".to_string(), 0),
+            ("c1".to_string(), 1),
+            ("c2".to_string(), 2),
+            ("c3".to_string(), 3),
+        ]);
+        let view = LcSelectorReductionView::from_parts(&[], &[], &helicity_ids, &color_ids, &[]);
+        let all = BTreeSet::from([
+            "c0".to_string(),
+            "c1".to_string(),
+            "c2".to_string(),
+            "c3".to_string(),
+        ]);
+        let subset = BTreeSet::from(["c1".to_string(), "c3".to_string()]);
+        let mut scratch = Vec::new();
+
+        view.retain_selected_color_indices(&all, &mut scratch)
+            .unwrap();
+        let capacity = scratch.capacity();
+        let allocation = scratch.as_ptr();
+        view.retain_selected_color_indices(&subset, &mut scratch)
+            .unwrap();
+
+        assert_eq!(scratch, [1, 3]);
+        assert_eq!(scratch.capacity(), capacity);
+        assert_eq!(scratch.as_ptr(), allocation);
+    }
+
+    #[test]
+    fn composes_distinct_replay_flow_permutations_without_destination_tables() {
+        let direct_helicity_to_physics = [2, 0, 1];
+        let flow_zero = [0, 1, 2];
+        let flow_one = [2, 0, 1];
+
+        for (replay_helicity_map, expected) in
+            [(&flow_zero[..], [2, 0, 1]), (&flow_one[..], [1, 2, 0])]
+        {
+            let actual = (0..3)
+                .map(|target_helicity_id| {
+                    replay_destination_physics_helicity(
+                        replay_helicity_map,
+                        &direct_helicity_to_physics,
+                        target_helicity_id,
+                    )
+                    .expect("compose authenticated replay and physics mappings")
+                })
+                .collect::<Vec<_>>();
+            assert_eq!(actual, expected);
+        }
+    }
+
+    #[test]
+    fn rejects_absent_or_out_of_range_replay_helicity_mappings() {
+        let missing = replay_destination_physics_helicity(&[0], &[0], DIRECT_NONE_U32)
+            .expect_err("sentinel destination helicity must fail closed");
+        assert_eq!(
+            missing.message(),
+            "topology-replay amplitude destination lacks a resolved helicity"
+        );
+
+        let incomplete = replay_destination_physics_helicity(&[0], &[0], 1)
+            .expect_err("incomplete replay permutation must fail closed");
+        assert_eq!(
+            incomplete.message(),
+            "recurrence amplitude destination helicity is not replay-mapped"
+        );
+
+        let out_of_range = replay_destination_physics_helicity(&[1], &[0], 0)
+            .expect_err("out-of-range direct helicity must fail closed");
+        assert_eq!(
+            out_of_range.message(),
+            "recurrence replay helicity has no public physics mapping"
+        );
+    }
+
+    #[test]
+    fn symmetric_group_recurrence_workspace_is_lazy_and_first_allocation_is_bounded() {
+        let contraction =
+            RecurrenceColorContraction::symmetric_group_s3_for_runtime_test((0..13).collect(), 13);
+        let RuntimeColorContractionReducer::SymmetricGroupFourier(reducer) =
+            contraction.runtime_reducer().unwrap()
+        else {
+            panic!("expected symmetric-group runtime reducer")
+        };
+        let (effective_point_tile_size, workspace) =
+            lazy_symmetric_group_workspace_for_point_tile(reducer, 5).unwrap();
+        assert_eq!(effective_point_tile_size, 5);
+        assert!(workspace.is_none());
+
+        let mut workspace = None;
+        ensure_symmetric_group_color_workspace_capacity(&mut workspace, reducer, 1).unwrap();
+        assert_eq!(workspace.as_ref().unwrap().lane_capacity(), 1);
+
+        ensure_symmetric_group_color_workspace_capacity(&mut workspace, reducer, 1).unwrap();
+        assert_eq!(workspace.as_ref().unwrap().lane_capacity(), 1);
+
+        ensure_symmetric_group_color_workspace_capacity(&mut workspace, reducer, 3).unwrap();
+        assert_eq!(workspace.as_ref().unwrap().lane_capacity(), 3);
+
+        ensure_symmetric_group_color_workspace_capacity(&mut workspace, reducer, 2).unwrap();
+        assert_eq!(workspace.as_ref().unwrap().lane_capacity(), 3);
+    }
+
+    #[test]
+    fn recurrence_external_planes_match_nested_contiguous_and_crossed_views() {
+        let source_count = 3;
+        let values = (0..7 * source_count * 4)
+            .map(|index| {
+                if index % 9 == 0 {
+                    -0.0
+                } else {
+                    index as f64 + 0.5
+                }
+            })
+            .collect::<Vec<_>>();
+        let crossing = [
+            InputCrossingMapEntry {
+                target_index: 0,
+                source_index: 2,
+                sign: -1.0,
+            },
+            InputCrossingMapEntry {
+                target_index: 1,
+                source_index: 0,
+                sign: 1.0,
+            },
+            InputCrossingMapEntry {
+                target_index: 2,
+                source_index: 1,
+                sign: -1.0,
+            },
+        ];
+        for lookup in [None, Some(crossing.as_slice())] {
+            let contiguous = F64MomentumBatchView::from_contiguous_prevalidated(
+                &values,
+                7,
+                source_count,
+                lookup,
+            )
+            .unwrap();
+            let nested = contiguous.materialize_nested();
+            let nested_view = F64MomentumBatchView::from_nested(&nested, source_count).unwrap();
+            for (start, stop) in [(0, 7), (2, 6), (6, 7)] {
+                let count = stop - start;
+                let mut expected = vec![0.0_f64; source_count * 4 * count];
+                for source in 0..source_count {
+                    for component in 0..4 {
+                        for point in 0..count {
+                            expected[(source * 4 + component) * count + point] =
+                                nested[start + point][source][component];
+                        }
+                    }
+                }
+                for view in [contiguous, nested_view] {
+                    let view = view.subview(start, stop).unwrap();
+                    let mut source_major = vec![17.0; expected.len() + 8];
+                    let mut point_major = vec![17.0; expected.len() + 8];
+                    for point in 0..count {
+                        for source in 0..source_count {
+                            let momentum = view.point(point).momentum(source).unwrap();
+                            write_external_momentum::<true>(
+                                &mut source_major,
+                                count,
+                                source_count,
+                                point,
+                                source,
+                                &momentum,
+                            );
+                            write_external_momentum::<false>(
+                                &mut point_major,
+                                count,
+                                source_count,
+                                point,
+                                source,
+                                &momentum,
+                            );
+                            assert_eq!(
+                                point_major[(point * source_count + source) * 4
+                                    ..(point * source_count + source + 1) * 4],
+                                momentum
+                            );
+                        }
+                    }
+                    assert_eq!(
+                        source_major[..expected.len()]
+                            .iter()
+                            .map(|value| value.to_bits())
+                            .collect::<Vec<_>>(),
+                        expected
+                            .iter()
+                            .map(|value| value.to_bits())
+                            .collect::<Vec<_>>()
+                    );
+                    assert!(
+                        source_major[expected.len()..]
+                            .iter()
+                            .all(|&value| value == 17.0)
+                    );
+                    assert!(
+                        point_major[expected.len()..]
+                            .iter()
+                            .all(|&value| value == 17.0)
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn recurrence_external_momentum_workspace_starts_singleton_and_grows_without_shrinking() {
+        let external_source_count = 4;
+        let maximum_point_count = 5;
+        let mut workspace = Vec::new();
+
+        let singleton_len = ensure_external_momentum_workspace_capacity(
+            &mut workspace,
+            1,
+            external_source_count,
+            maximum_point_count,
+        )
+        .unwrap();
+        assert_eq!(singleton_len, external_source_count * 4);
+        assert_eq!(workspace.len(), singleton_len);
+        workspace[0] = 17.0;
+
+        let singleton_ptr = workspace.as_ptr();
+        let singleton_capacity = workspace.capacity();
+        ensure_external_momentum_workspace_capacity(
+            &mut workspace,
+            1,
+            external_source_count,
+            maximum_point_count,
+        )
+        .unwrap();
+        assert_eq!(workspace.as_ptr(), singleton_ptr);
+        assert_eq!(workspace.capacity(), singleton_capacity);
+
+        let grown_len = ensure_external_momentum_workspace_capacity(
+            &mut workspace,
+            3,
+            external_source_count,
+            maximum_point_count,
+        )
+        .unwrap();
+        assert_eq!(grown_len, 3 * external_source_count * 4);
+        assert_eq!(workspace.len(), grown_len);
+        assert_eq!(workspace[0], 17.0);
+        assert!(workspace[singleton_len..].iter().all(|value| *value == 0.0));
+
+        let grown_ptr = workspace.as_ptr();
+        let grown_capacity = workspace.capacity();
+        ensure_external_momentum_workspace_capacity(
+            &mut workspace,
+            2,
+            external_source_count,
+            maximum_point_count,
+        )
+        .unwrap();
+        assert_eq!(workspace.len(), grown_len);
+        assert_eq!(workspace.as_ptr(), grown_ptr);
+        assert_eq!(workspace.capacity(), grown_capacity);
+
+        let error = ensure_external_momentum_workspace_capacity(
+            &mut workspace,
+            maximum_point_count + 1,
+            external_source_count,
+            maximum_point_count,
+        )
+        .expect_err("workspace growth past the persistent tile limit must fail");
+        assert_eq!(
+            error.message(),
+            "recurrence point tile exceeds its persistent workspace"
+        );
+        assert_eq!(workspace.len(), grown_len);
+    }
+
+    #[test]
+    fn symmetric_group_recurrence_dispatch_handles_sparse_owner_destinations_and_partial_tiles() {
+        let contraction = RecurrenceColorContraction::symmetric_group_s3_for_runtime_test(
+            (0..13).map(|group| group + 2).collect(),
+            20,
+        );
+        let destination_physics_helicity =
+            contracted_destination_helicity_map(&contraction, &[0]).unwrap();
+        assert_eq!(destination_physics_helicity.len(), 20);
+        assert_eq!(destination_physics_helicity[..2], [usize::MAX; 2]);
+        assert!(
+            destination_physics_helicity[2..15]
+                .iter()
+                .all(|helicity| *helicity == 0)
+        );
+        assert!(
+            destination_physics_helicity[15..]
+                .iter()
+                .all(|helicity| *helicity == usize::MAX)
+        );
+
+        let mut physics = PhysicsRuntime {
+            binding_id: 0,
+            manifest: ProcessPhysicsV1 {
+                schema_version: crate::RUNTIME_PHYSICS_SCHEMA_VERSION,
+                kind: "pyamplicol-resolved-physics".to_string(),
+                process_id: "fft-runtime-test".to_string(),
+                process: "g g > g g".to_string(),
+                color_accuracy: crate::ColorAccuracy::Full,
+                coverage: crate::Coverage {
+                    helicities: "complete".to_string(),
+                    color: "contracted".to_string(),
+                    color_kind: "contracted-color".to_string(),
+                    structural_zero_helicity_count: 0,
+                },
+                external_particles: Vec::new(),
+                helicities: vec![crate::Helicity {
+                    id: "h0".to_string(),
+                    index: 0,
+                    values: Vec::new(),
+                    representative_id: "h0".to_string(),
+                    computed: true,
+                    structural_zero: false,
+                    coefficient: 1.0,
+                }],
+                color_components: vec![crate::ColorComponent::ContractedColor(
+                    crate::ContractedColor {
+                        id: "contracted".to_string(),
+                        index: 0,
+                        description: "contracted color".to_string(),
+                    },
+                )],
+                reduction: crate::Reduction {
+                    kind: crate::ReductionKind::ContractedColor,
+                    groups: Vec::new(),
+                },
+                model_parameters: Vec::new(),
+                selectors: crate::SelectorCapabilities {
+                    helicity: true,
+                    color_flow: false,
+                    contracted_color: false,
+                },
+                extensions: BTreeMap::new(),
+            },
+            helicity_index_by_id: BTreeMap::from([("h0".to_string(), 0)]),
+            helicity_members_by_representative: vec![vec![0]],
+            color_index_by_id: BTreeMap::from([("contracted".to_string(), 0)]),
+            reduction_by_group_id: BTreeMap::new(),
+            numeric_reduction_by_group_id: BTreeMap::new(),
+        };
+        let point_count = 3;
+        let point_stride = point_count;
+        let mut values_re = vec![0.0; 20 * point_stride];
+        let mut values_im = vec![0.0; 20 * point_stride];
+        let mut local_values = vec![(0.0, 0.0); 13 * point_count];
+        for group in 0..13 {
+            for point in 0..point_count {
+                let value = (
+                    (group * 7 + point * 3) as f64 / 11.0 - 1.0,
+                    (group * 5 + point) as f64 / 13.0 - 0.4,
+                );
+                local_values[group * point_count + point] = value;
+                values_re[(group + 2) * point_stride + point] = value.0;
+                values_im[(group + 2) * point_stride + point] = value.1;
+            }
+        }
+        let tile = ContractedReplayTile {
+            values_re: &values_re,
+            values_im: &values_im,
+            point_count,
+            point_stride,
+            destination_count: 20,
+        };
+        let RuntimeColorContractionReducer::SymmetricGroupFourier(reducer) =
+            contraction.runtime_reducer().unwrap()
+        else {
+            panic!("expected symmetric-group runtime reducer")
+        };
+        let covered_group_count = reducer.channel_count() * reducer.group_order();
+        assert!(reducer.channel_count() > 0);
+        assert!(reducer.local_group_count() > covered_group_count);
+        assert!(reducer.residual_entries().iter().any(|entry| {
+            entry.left_group_index < covered_group_count as u32
+                && entry.right_group_index >= covered_group_count as u32
+        }));
+        let expected = RecurrenceColorContraction::symmetric_group_s3_dense_for_runtime_test(
+            &local_values,
+            point_count,
+        );
+
+        let mut workspace = reducer.workspace(1).unwrap();
+        let mut actual = vec![0.0; point_count];
+        contract_color_tile(
+            &tile,
+            &contraction,
+            &destination_physics_helicity,
+            &physics,
+            None,
+            1.0,
+            &mut [],
+            &mut [],
+            Some(&mut workspace),
+            |point, helicity, value| {
+                assert_eq!(helicity, 0);
+                actual[point] += value;
+            },
+        )
+        .unwrap();
+        assert_eq!(workspace.lane_capacity(), point_count);
+        for (actual, expected) in actual.into_iter().zip(expected) {
+            let scale = expected.abs().max(1.0);
+            assert!((actual - expected).abs() <= 2.0e-11 * scale);
+        }
+
+        physics.manifest.helicities[0].computed = false;
+        physics.manifest.helicities[0].structural_zero = true;
+        let selected = BTreeSet::from(["h0".to_string()]);
+        assert!(
+            !contracted_selection_has_computed_destination(
+                &destination_physics_helicity,
+                &physics,
+                &selected,
+            )
+            .unwrap()
+        );
+    }
+}
+
+#[derive(Clone, Copy)]
+struct DirectProfileSnapshot {
+    phases: DirectRuntimePhaseTimings,
+    roles: DirectExecutionRoleTimings,
+    execution: DirectExecutionCounters,
+    traffic: DirectArenaTrafficCounters,
+    activity: DirectRuntimeActivityCounters,
+    internal_scratch_bytes: u64,
+    internal_broadcast_bytes: u64,
+}
+
+impl DirectProfileSnapshot {
+    fn capture(
+        runtime: &DirectRecurrenceExecutionRuntime,
+        owners: &NativeRecurrenceDirectExecutorOwners,
+    ) -> Self {
+        let (internal_scratch_bytes, internal_broadcast_bytes) = owners.internal_traffic_bytes();
+        Self {
+            phases: runtime.phase_timings(),
+            roles: runtime.role_timings(),
+            execution: runtime.counters(),
+            traffic: runtime.traffic_counters(),
+            activity: runtime.activity_counters(),
+            internal_scratch_bytes,
+            internal_broadcast_bytes,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Default)]
+pub(super) struct DirectProfileDelta {
+    pub(super) momentum_fill: Duration,
+    pub(super) union_source_fill: Duration,
+    pub(super) direct_execution: Duration,
+    pub(super) replay_output_mapping: Duration,
+    pub(super) source_kernel: Duration,
+    pub(super) contribution_kernel: Duration,
+    pub(super) finalization: Duration,
+    pub(super) closure: Duration,
+    pub(super) execution: DirectExecutionCounters,
+    pub(super) traffic: DirectArenaTrafficCounters,
+    pub(super) activity: DirectRuntimeActivityCounters,
+    pub(super) internal_scratch_bytes: u64,
+    pub(super) internal_broadcast_bytes: u64,
+}
+
+fn add_persisted_execution_report(
+    target: &mut PersistedHelicityFamilyExecutionReportV1,
+    source: PersistedHelicityFamilyExecutionReportV1,
+) {
+    target.cache_hit &= source.cache_hit;
+    target.source_calls = target.source_calls.saturating_add(source.source_calls);
+    target.source_rows = target.source_rows.saturating_add(source.source_rows);
+    target.contribution_calls = target
+        .contribution_calls
+        .saturating_add(source.contribution_calls);
+    target.contribution_rows = target
+        .contribution_rows
+        .saturating_add(source.contribution_rows);
+    target.finalization_calls = target
+        .finalization_calls
+        .saturating_add(source.finalization_calls);
+    target.finalization_rows = target
+        .finalization_rows
+        .saturating_add(source.finalization_rows);
+    target.closure_calls = target.closure_calls.saturating_add(source.closure_calls);
+    target.closure_rows = target.closure_rows.saturating_add(source.closure_rows);
+}
+
+fn persisted_execution_report_aggregate() -> PersistedHelicityFamilyExecutionReportV1 {
+    PersistedHelicityFamilyExecutionReportV1 {
+        // Conjunction uses true as its identity, so an all-hit tile sequence
+        // remains a hit while any cold tile turns the aggregate into a miss.
+        cache_hit: true,
+        ..PersistedHelicityFamilyExecutionReportV1::default()
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn persisted_companion_profile(
+    total: Duration,
+    parameter_setup: Duration,
+    input_setup: Duration,
+    execution: Duration,
+    reduction: Duration,
+    momentum_scalar_values: u64,
+    report: PersistedHelicityFamilyExecutionReportV1,
+) -> RuntimeProfile {
+    let calls = u64::from(report.source_calls)
+        + u64::from(report.contribution_calls)
+        + u64::from(report.finalization_calls)
+        + u64::from(report.closure_calls);
+    let rows = u64::from(report.source_rows)
+        + u64::from(report.contribution_rows)
+        + u64::from(report.finalization_rows)
+        + u64::from(report.closure_rows);
+    let schedule_executions = u64::from(report.source_calls);
+    direct_profile_from_delta(
+        total,
+        parameter_setup,
+        input_setup,
+        reduction,
+        DirectProfileDelta {
+            direct_execution: execution,
+            execution: DirectExecutionCounters {
+                source_calls: u64::from(report.source_calls),
+                source_rows: u64::from(report.source_rows),
+                contribution_calls: u64::from(report.contribution_calls),
+                contribution_rows: u64::from(report.contribution_rows),
+                finalization_calls: u64::from(report.finalization_calls),
+                finalization_rows: u64::from(report.finalization_rows),
+                closure_calls: u64::from(report.closure_calls),
+                closure_rows: u64::from(report.closure_rows),
+                ..DirectExecutionCounters::default()
+            },
+            traffic: DirectArenaTrafficCounters {
+                calls,
+                rows,
+                ..DirectArenaTrafficCounters::default()
+            },
+            activity: DirectRuntimeActivityCounters {
+                momentum_fill_calls: schedule_executions,
+                momentum_scalar_values_filled: momentum_scalar_values,
+                schedule_executions,
+                union_source_dispatch_calls: u64::from(report.source_calls),
+                union_source_rows: u64::from(report.source_rows),
+                union_schedule_executions: schedule_executions,
+                ..DirectRuntimeActivityCounters::default()
+            },
+            ..DirectProfileDelta::default()
+        },
+    )
+}
+
+fn direct_profile(
+    total: Duration,
+    parameter_setup: Duration,
+    external_momentum_flatten: Duration,
+    reduction: Duration,
+    before: DirectProfileSnapshot,
+    after: DirectProfileSnapshot,
+) -> RuntimeProfile {
+    let momentum_fill = after
+        .phases
+        .momentum_fill
+        .saturating_sub(before.phases.momentum_fill);
+    let union_source_fill = after
+        .phases
+        .union_source_fill
+        .saturating_sub(before.phases.union_source_fill);
+    let direct_execution = after
+        .phases
+        .direct_execution
+        .saturating_sub(before.phases.direct_execution);
+    let replay_output_mapping = after
+        .phases
+        .replay_output_mapping
+        .saturating_sub(before.phases.replay_output_mapping);
+    let source_kernel = after.roles.source.saturating_sub(before.roles.source);
+    let contribution_kernel = after
+        .roles
+        .contribution
+        .saturating_sub(before.roles.contribution);
+    let finalization = after
+        .roles
+        .finalization
+        .saturating_sub(before.roles.finalization);
+    let closure = after.roles.closure.saturating_sub(before.roles.closure);
+    let execution = DirectExecutionCounters {
+        source_calls: after
+            .execution
+            .source_calls
+            .saturating_sub(before.execution.source_calls),
+        source_rows: after
+            .execution
+            .source_rows
+            .saturating_sub(before.execution.source_rows),
+        contribution_calls: after
+            .execution
+            .contribution_calls
+            .saturating_sub(before.execution.contribution_calls),
+        contribution_rows: after
+            .execution
+            .contribution_rows
+            .saturating_sub(before.execution.contribution_rows),
+        finalization_calls: after
+            .execution
+            .finalization_calls
+            .saturating_sub(before.execution.finalization_calls),
+        finalization_rows: after
+            .execution
+            .finalization_rows
+            .saturating_sub(before.execution.finalization_rows),
+        closure_calls: after
+            .execution
+            .closure_calls
+            .saturating_sub(before.execution.closure_calls),
+        closure_rows: after
+            .execution
+            .closure_rows
+            .saturating_sub(before.execution.closure_rows),
+        packed_input_bytes: after
+            .execution
+            .packed_input_bytes
+            .saturating_sub(before.execution.packed_input_bytes),
+        packed_output_bytes: after
+            .execution
+            .packed_output_bytes
+            .saturating_sub(before.execution.packed_output_bytes),
+        scatter_bytes: after
+            .execution
+            .scatter_bytes
+            .saturating_sub(before.execution.scatter_bytes),
+    };
+    let traffic = DirectArenaTrafficCounters {
+        calls: after.traffic.calls.saturating_sub(before.traffic.calls),
+        rows: after.traffic.rows.saturating_sub(before.traffic.rows),
+        points: after.traffic.points.saturating_sub(before.traffic.points),
+        packet_input_bytes: after
+            .traffic
+            .packet_input_bytes
+            .saturating_sub(before.traffic.packet_input_bytes),
+        packet_output_bytes: after
+            .traffic
+            .packet_output_bytes
+            .saturating_sub(before.traffic.packet_output_bytes),
+        gather_bytes: after
+            .traffic
+            .gather_bytes
+            .saturating_sub(before.traffic.gather_bytes),
+        scatter_bytes: after
+            .traffic
+            .scatter_bytes
+            .saturating_sub(before.traffic.scatter_bytes),
+        remap_bytes: after
+            .traffic
+            .remap_bytes
+            .saturating_sub(before.traffic.remap_bytes),
+    };
+    let internal_scratch_bytes = after
+        .internal_scratch_bytes
+        .saturating_sub(before.internal_scratch_bytes);
+    let internal_broadcast_bytes = after
+        .internal_broadcast_bytes
+        .saturating_sub(before.internal_broadcast_bytes);
+    let activity = DirectRuntimeActivityCounters {
+        momentum_fill_calls: after
+            .activity
+            .momentum_fill_calls
+            .saturating_sub(before.activity.momentum_fill_calls),
+        momentum_forms_filled: after
+            .activity
+            .momentum_forms_filled
+            .saturating_sub(before.activity.momentum_forms_filled),
+        momentum_terms_filled: after
+            .activity
+            .momentum_terms_filled
+            .saturating_sub(before.activity.momentum_terms_filled),
+        momentum_scalar_values_filled: after
+            .activity
+            .momentum_scalar_values_filled
+            .saturating_sub(before.activity.momentum_scalar_values_filled),
+        schedule_executions: after
+            .activity
+            .schedule_executions
+            .saturating_sub(before.activity.schedule_executions),
+        replay_schedule_executions: after
+            .activity
+            .replay_schedule_executions
+            .saturating_sub(before.activity.replay_schedule_executions),
+        replay_output_values_scaled: after
+            .activity
+            .replay_output_values_scaled
+            .saturating_sub(before.activity.replay_output_values_scaled),
+        union_source_dispatch_calls: after
+            .activity
+            .union_source_dispatch_calls
+            .saturating_sub(before.activity.union_source_dispatch_calls),
+        union_source_rows: after
+            .activity
+            .union_source_rows
+            .saturating_sub(before.activity.union_source_rows),
+        union_schedule_executions: after
+            .activity
+            .union_schedule_executions
+            .saturating_sub(before.activity.union_schedule_executions),
+    };
+    direct_profile_from_delta(
+        total,
+        parameter_setup,
+        external_momentum_flatten,
+        reduction,
+        DirectProfileDelta {
+            momentum_fill,
+            union_source_fill,
+            direct_execution,
+            replay_output_mapping,
+            source_kernel,
+            contribution_kernel,
+            finalization,
+            closure,
+            execution,
+            traffic,
+            activity,
+            internal_scratch_bytes,
+            internal_broadcast_bytes,
+        },
+    )
+}
+
+pub(super) fn direct_profile_from_delta(
+    total: Duration,
+    parameter_setup: Duration,
+    external_momentum_flatten: Duration,
+    reduction: Duration,
+    delta: DirectProfileDelta,
+) -> RuntimeProfile {
+    RuntimeProfile {
+        momentum_setup_s: profile_duration_seconds(external_momentum_flatten + delta.momentum_fill),
+        momentum_input_setup_s: profile_duration_seconds(external_momentum_flatten),
+        model_parameter_setup_s: profile_duration_seconds(parameter_setup),
+        stage_evaluator_call_s: profile_duration_seconds(delta.direct_execution),
+        stage_evaluator_s: profile_duration_seconds(delta.direct_execution),
+        recurrence_momentum_fill_s: profile_duration_seconds(delta.momentum_fill),
+        recurrence_union_source_fill_s: profile_duration_seconds(delta.union_source_fill),
+        recurrence_schedule_s: profile_duration_seconds(delta.direct_execution),
+        recurrence_source_kernel_s: profile_duration_seconds(delta.source_kernel),
+        recurrence_contribution_kernel_s: profile_duration_seconds(delta.contribution_kernel),
+        recurrence_finalization_s: profile_duration_seconds(delta.finalization),
+        recurrence_closure_s: profile_duration_seconds(delta.closure),
+        recurrence_replay_output_mapping_s: profile_duration_seconds(delta.replay_output_mapping),
+        recurrence_momentum_scalar_value_count: delta.activity.momentum_scalar_values_filled,
+        recurrence_schedule_execution_count: delta.activity.schedule_executions,
+        recurrence_replay_schedule_execution_count: delta.activity.replay_schedule_executions,
+        recurrence_union_schedule_execution_count: delta.activity.union_schedule_executions,
+        recurrence_union_source_row_count: delta.activity.union_source_rows,
+        recurrence_replay_output_value_count: delta.activity.replay_output_values_scaled,
+        recurrence_source_call_count: delta.execution.source_calls,
+        recurrence_source_row_count: delta.execution.source_rows,
+        recurrence_contribution_call_count: delta.execution.contribution_calls,
+        recurrence_contribution_row_count: delta.execution.contribution_rows,
+        recurrence_finalization_call_count: delta.execution.finalization_calls,
+        recurrence_finalization_row_count: delta.execution.finalization_rows,
+        recurrence_closure_call_count: delta.execution.closure_calls,
+        recurrence_closure_row_count: delta.execution.closure_rows,
+        recurrence_direct_packed_input_bytes: delta.execution.packed_input_bytes,
+        recurrence_direct_packed_output_bytes: delta.execution.packed_output_bytes,
+        // Fanout broadcasts stay within the persistent Direct-Arena current
+        // workspace. They are not the retired evaluator-boundary scatter.
+        recurrence_direct_scatter_bytes: 0,
+        recurrence_direct_packet_input_bytes: delta.traffic.packet_input_bytes,
+        recurrence_direct_packet_output_bytes: delta.traffic.packet_output_bytes,
+        recurrence_direct_gather_bytes: delta.traffic.gather_bytes,
+        recurrence_direct_traffic_scatter_bytes: delta.traffic.scatter_bytes,
+        recurrence_direct_remap_bytes: delta.traffic.remap_bytes,
+        recurrence_internal_scratch_bytes: delta.internal_scratch_bytes,
+        recurrence_internal_broadcast_bytes: delta
+            .internal_broadcast_bytes
+            .saturating_add(delta.execution.scatter_bytes),
+        reduction_s: profile_duration_seconds(reduction),
+        total_s: profile_duration_seconds(total),
+        ..RuntimeProfile::default()
+    }
+}
+
+#[cfg(test)]
+mod direct_profile_tests {
+    use super::*;
+
+    #[test]
+    fn persisted_cache_hit_aggregation_is_true_only_when_every_tile_hits() {
+        let mut all_hits = persisted_execution_report_aggregate();
+        add_persisted_execution_report(
+            &mut all_hits,
+            PersistedHelicityFamilyExecutionReportV1 {
+                cache_hit: true,
+                ..PersistedHelicityFamilyExecutionReportV1::default()
+            },
+        );
+        add_persisted_execution_report(
+            &mut all_hits,
+            PersistedHelicityFamilyExecutionReportV1 {
+                cache_hit: true,
+                ..PersistedHelicityFamilyExecutionReportV1::default()
+            },
+        );
+        assert!(all_hits.cache_hit);
+
+        add_persisted_execution_report(
+            &mut all_hits,
+            PersistedHelicityFamilyExecutionReportV1::default(),
+        );
+        assert!(!all_hits.cache_hit);
+    }
+
+    #[test]
+    fn fanout_scatter_is_reported_as_internal_broadcast_traffic() {
+        let profile = direct_profile_from_delta(
+            Duration::ZERO,
+            Duration::ZERO,
+            Duration::ZERO,
+            Duration::ZERO,
+            DirectProfileDelta {
+                execution: DirectExecutionCounters {
+                    scatter_bytes: 96,
+                    ..DirectExecutionCounters::default()
+                },
+                internal_broadcast_bytes: 32,
+                ..DirectProfileDelta::default()
+            },
+        );
+
+        assert_eq!(profile.recurrence_direct_scatter_bytes, 0);
+        assert_eq!(profile.recurrence_internal_broadcast_bytes, 128);
+        profile
+            .validate_recurrence_direct_boundary_traffic()
+            .unwrap();
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_load.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_load.rs
new file mode 100644
index 0000000000..943c4722c7
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_load.rs
@@ -0,0 +1,5434 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Native loading of compact recurrence artifacts.
+
+use super::eager_manifest::PreparedKernelPackManifest;
+use super::evaluator::recurrence_source_direct::{
+    DirectSourceDispatchDomainSpec, DirectSourceDispatchKey, DirectSourceDispatchVariantSpec,
+    DirectSourceOrientation, DirectSourceTemplateSpec, DirectSourceWavefunctionFamily,
+};
+use super::recurrence_backend::NativeRecurrenceDirectExecutorBackend;
+#[cfg(feature = "on-the-fly-test-support")]
+use super::recurrence_backend::NativeRecurrencePreparedExecutorPool;
+#[cfg(feature = "python-generation-bridge")]
+use super::recurrence_bootstrap::{
+    RecurrenceReadyCompanionV1, RecurrenceReadyRuntimeV1, RecurrenceReadySourceTemplateV1,
+    RecurrenceReadySourceVariantV1,
+};
+use super::recurrence_bootstrap::{
+    RecurrenceReadyExecutionV1, RecurrenceReadyPlanV1, RecurrenceReadySourceDomainV1,
+    RecurrenceReadySourceFamilyV1, RecurrenceReadySourceKeyV1, RecurrenceReadySourceOrientationV1,
+};
+use super::recurrence_manifest::*;
+use super::recurrence_process_pack::{
+    ProcessDirectExecutorBinding, ProcessDirectExecutorPack, ProcessExecutorBackend,
+    ProcessExecutorIdentities, ProcessExecutorTarget, RECURRENCE_PROCESS_BINDING_HEADER_SIZE_V4,
+    RECURRENCE_PROCESS_BINDING_MAGIC_V4, RECURRENCE_PROCESS_BINDING_VERSION_V4,
+    decode_process_executor_descriptors, read_string, semantic_digest_from_bytes,
+};
+use super::*;
+use crate::pacbin::{PacbinMemberKind, PacbinReader};
+#[cfg(feature = "on-the-fly-test-support")]
+use crate::recurrence::direct_backend::{
+    DirectCurrentObservation, begin_direct_current_observation, take_direct_current_observation,
+};
+#[cfg(feature = "on-the-fly-test-support")]
+use crate::recurrence::direct_runtime::{
+    DirectRecurrenceExecutionRuntime, DirectReplaySelectorPlan,
+};
+#[cfg(test)]
+use crate::recurrence::on_the_fly::OnTheFlySourceExecutionSpecV1;
+#[cfg(feature = "on-the-fly-test-support")]
+use crate::recurrence::on_the_fly::hash_current_key;
+#[cfg(feature = "on-the-fly-test-support")]
+use crate::recurrence::on_the_fly::{
+    ON_THE_FLY_WORK_CENSUS_BASIS_V1, OnTheFlyForbiddenWorkGuardV1, OnTheFlyQueryFamilyExecutorV1,
+    OnTheFlySelectedQueryTraceV1, OnTheFlyStructuralInterpreter, OnTheFlyWorkspaceV1,
+    QueryFamilyTraceInput, build_on_the_fly_selected_trace_v1,
+};
+use crate::recurrence::on_the_fly::{
+    OnTheFlyProcessSeedV1, OnTheFlySourceOrientationV1, OnTheFlySourceWavefunctionFamilyV1,
+};
+#[cfg(feature = "on-the-fly-test-support")]
+use crate::recurrence::{AuthenticatedRecurrenceBuilderInput, PreparedDirectExecutorCatalog};
+use crate::recurrence::{
+    DirectRecurrencePlan, FactorizedColorContractionKind,
+    RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER, RECURRENCE_DIRECT_SCHEDULE_MEMBER,
+    RecurrenceColorContraction, SemanticDigest, decode_recurrence_color_contraction_v3,
+    decode_recurrence_direct_plan_v2, recurrence_color_contraction_digest,
+    validate_recurrence_color_projection_certificate,
+};
+
+#[cfg(feature = "on-the-fly-test-support")]
+const ON_THE_FLY_FAMILY_WORK_CENSUS_BASIS_V1: &str = "shared-query-family-union-v1";
+
+pub(super) struct LoadedRecurrenceRuntime {
+    pub(super) common: ExecutionRuntime,
+    pub(super) lane: RecurrenceNativeRuntime,
+}
+
+fn companion_helicity_coefficient_is_canonical(structural_zero: bool, coefficient: f64) -> bool {
+    coefficient == if structural_zero { 0.0 } else { 1.0 }
+}
+
+pub(super) struct LoadedRecurrencePlan {
+    pub(super) plan: DirectRecurrencePlan,
+    pub(super) process_executors: ProcessDirectExecutorPack,
+}
+
+struct LoadedRecurrenceProcessBinding {
+    remap: RecurrenceProcessRemap,
+    process_executors: ProcessDirectExecutorPack,
+}
+
+pub(super) fn load_recurrence_native_runtime(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &RecurrenceExecutionManifest,
+    physics: &ProcessPhysicsV1,
+    _selection: &crate::ArtifactSelection,
+) -> RusticolResult<LoadedRecurrenceRuntime> {
+    let loaded_plan = load_plan(artifact, evaluator_root, manifest)?;
+    let plan = loaded_plan.plan;
+    let (mut common, parameter_defaults, parameter_projection, source_domains) =
+        build_common_runtime(&plan, manifest, physics)?;
+    let payload_root = recurrence_payload_root(artifact, manifest)?;
+    let kernel_payloads = artifact.evaluator_payload_store(&payload_root)?;
+    if manifest.helicity_selector_companion.is_some() {
+        validate_recurrence_companion_physics(physics)?;
+    }
+    common.model_parameter_evaluator = if common
+        .model_parameters
+        .iter()
+        .any(|parameter| parameter.kind == "derived_parameter_component")
+    {
+        let (pack_bytes, mut pack, fallback_payload_root) = load_prepared_pack(artifact, manifest)?;
+        drop(pack_bytes);
+        drop(pack.recurrence_template.take());
+        drop(pack.recurrence_direct_template.take());
+        if fallback_payload_root != payload_root {
+            return Err(RusticolError::integrity(
+                "recurrence parameter fallback resolved a different prepared payload root",
+            ));
+        }
+        super::eager_load::load_prepared_model_parameter_evaluator_for_runtime(
+            &pack,
+            &common.model_parameters,
+            &kernel_payloads,
+        )?
+    } else {
+        None
+    };
+    common.refresh_derived_model_parameters()?;
+    let helicity_selector_companion = if manifest.helicity_selector_companion.is_some() {
+        Some(
+            super::on_the_fly_load::load_recurrence_helicity_selector_companion(
+                artifact,
+                evaluator_root,
+                manifest,
+                physics,
+                &kernel_payloads,
+                &common,
+            )?
+            .runtime,
+        )
+    } else {
+        None
+    };
+    let loaded_backend = NativeRecurrenceDirectExecutorBackend::load_from_process_pack(
+        &loaded_plan.process_executors,
+        &kernel_payloads,
+        &plan,
+        source_domains,
+    )?;
+    let (executors, backend_owners) = loaded_backend.into_parts();
+    let public_flow_ids = public_flow_ids(&plan, &manifest.runtime_metadata, physics)?;
+    let direct_helicity_to_physics = direct_helicity_to_physics(&plan, physics)?;
+    let color_contraction = load_color_contraction(artifact, evaluator_root, manifest)?;
+    let lane = RecurrenceNativeRuntime::new(
+        plan,
+        executors,
+        backend_owners,
+        parameter_defaults,
+        parameter_projection,
+        public_flow_ids,
+        direct_helicity_to_physics,
+        color_contraction,
+        helicity_selector_companion,
+    )?;
+    Ok(LoadedRecurrenceRuntime { common, lane })
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+pub(super) fn load_recurrence_ready_runtime(
+    artifact: &mut VerifiedArtifact,
+    evaluator_root: &Path,
+    ready: &RecurrenceReadyExecutionV1,
+    physics: &ProcessPhysicsV1,
+    evaluator_payload_container: &crate::artifact::EvaluatorPayloadContainerExtension,
+) -> RusticolResult<LoadedRecurrenceRuntime> {
+    validate_ready_runtime_capabilities(ready)?;
+    if ready.runtime.external_is_initial.len() != physics.external_particles.len()
+        || ready
+            .runtime
+            .external_is_initial
+            .iter()
+            .zip(&physics.external_particles)
+            .any(|(is_initial, particle)| {
+                *is_initial != (particle.role == crate::ParticleRole::Initial)
+            })
+    {
+        return Err(RusticolError::integrity(
+            "process-ready recurrence external roles disagree with authenticated physics",
+        ));
+    }
+    let loaded_primary = load_ready_plan(
+        artifact,
+        evaluator_root,
+        ready,
+        &ready.primary_plan,
+        RecurrenceReadyPlanRoleV1::Primary,
+    )?;
+    let mut loaded_companion = ready
+        .companion
+        .as_ref()
+        .map(|companion| {
+            validate_recurrence_companion_physics(physics)?;
+            if companion.process_digest != ready.primary_plan.process_binding.process_digest
+                || companion.process_digest != companion.plan.process_binding.process_digest
+            {
+                return Err(RusticolError::integrity(
+                    "process-ready recurrence companion belongs to a different process",
+                ));
+            }
+            load_ready_plan(
+                artifact,
+                evaluator_root,
+                ready,
+                &companion.plan,
+                RecurrenceReadyPlanRoleV1::HelicitySelector,
+            )
+        })
+        .transpose()?;
+    let has_derived_parameters = ready
+        .runtime
+        .runtime_parameters
+        .iter()
+        .any(|parameter| parameter.kind == "derived_parameter_component");
+    let needs_evaluator_payloads = recurrence_ready_needs_evaluator_payloads(
+        process_pack_requires_evaluator_payloads(&loaded_primary.process_executors),
+        has_derived_parameters,
+        ready.companion.is_some(),
+    );
+    if needs_evaluator_payloads {
+        artifact.install_evaluator_payload_container(evaluator_payload_container)?;
+    }
+
+    let plan = loaded_primary.plan;
+    let (mut common, parameter_defaults, parameter_projection, source_domains) =
+        build_ready_common_runtime(&plan, ready)?;
+    let payload_root = ready_recurrence_payload_root(artifact, ready)?;
+    let kernel_payloads = artifact.evaluator_payload_store(&payload_root)?;
+    common.model_parameter_evaluator = if has_derived_parameters {
+        let (pack_bytes, mut pack, fallback_payload_root) =
+            load_ready_prepared_pack(artifact, ready)?;
+        drop(pack_bytes);
+        drop(pack.recurrence_template.take());
+        let direct = pack.recurrence_direct_template_catalog(
+            &ready.prepared_kernel_pack_digest,
+            &ready.direct_template_catalog_digest,
+        )?;
+        if direct.compiled_model_digest != ready.compiled_model_digest
+            || direct.recurrence_template_catalog_digest != ready.recurrence_template_catalog_digest
+        {
+            return Err(RusticolError::integrity(
+                "prepared parameter fallback belongs to a different recurrence model",
+            ));
+        }
+        drop(direct);
+        drop(pack.recurrence_direct_template.take());
+        if fallback_payload_root != payload_root {
+            return Err(RusticolError::integrity(
+                "process-ready recurrence parameter fallback resolved a different payload root",
+            ));
+        }
+        super::eager_load::load_prepared_model_parameter_evaluator_for_runtime(
+            &pack,
+            &common.model_parameters,
+            &kernel_payloads,
+        )?
+    } else {
+        None
+    };
+    common.refresh_derived_model_parameters()?;
+
+    let helicity_selector_companion = match (ready.companion.as_ref(), loaded_companion.take()) {
+        (Some(companion), Some(loaded)) => Some(
+            super::on_the_fly_load::load_recurrence_helicity_selector_companion_from_ready_parts(
+                artifact,
+                loaded,
+                &companion.plan,
+                companion,
+                ready,
+                physics,
+                &kernel_payloads,
+            )?
+            .runtime,
+        ),
+        (None, None) => None,
+        _ => {
+            return Err(RusticolError::internal(
+                "process-ready recurrence companion load state drifted",
+            ));
+        }
+    };
+    let loaded_backend = NativeRecurrenceDirectExecutorBackend::load_from_process_pack(
+        &loaded_primary.process_executors,
+        &kernel_payloads,
+        &plan,
+        source_domains,
+    )?;
+    let (executors, backend_owners) = loaded_backend.into_parts();
+    let public_flow_ids = validate_ready_public_flow_ids(
+        &plan,
+        &ready.runtime.public_flow_ids,
+        &ready.runtime.public_flow_public_ids,
+        physics,
+    )?;
+    let direct_helicity_to_physics = validate_ready_direct_helicity_to_physics(
+        &plan,
+        &ready.runtime.direct_helicity_to_physics,
+        physics,
+    )?;
+    let color_contraction = ready
+        .runtime
+        .color_contraction
+        .as_ref()
+        .map(|reference| {
+            load_color_contraction_reference(artifact, evaluator_root, &ready.key, reference)
+        })
+        .transpose()?;
+    let lane = RecurrenceNativeRuntime::new(
+        plan,
+        executors,
+        backend_owners,
+        parameter_defaults,
+        parameter_projection,
+        public_flow_ids,
+        direct_helicity_to_physics,
+        color_contraction,
+        helicity_selector_companion,
+    )?;
+    Ok(LoadedRecurrenceRuntime { common, lane })
+}
+
+fn process_pack_requires_evaluator_payloads(pack: &ProcessDirectExecutorPack) -> bool {
+    pack.descriptors
+        .iter()
+        .any(|descriptor| process_binding_requires_evaluator_payloads(&descriptor.binding))
+}
+
+fn process_binding_requires_evaluator_payloads(binding: &ProcessDirectExecutorBinding) -> bool {
+    match binding {
+        ProcessDirectExecutorBinding::Source | ProcessDirectExecutorBinding::Intrinsic(_) => false,
+        ProcessDirectExecutorBinding::Jit(_) | ProcessDirectExecutorBinding::Native(_) => true,
+    }
+}
+
+const fn recurrence_ready_needs_evaluator_payloads(
+    process_pack_requires_payloads: bool,
+    has_derived_parameters: bool,
+    has_companion: bool,
+) -> bool {
+    process_pack_requires_payloads
+        || has_derived_parameters
+        // Companion executors are intentionally conservative here. They may
+        // warm a different sparse descriptor family than the primary plan.
+        || has_companion
+}
+
+fn validate_ready_runtime_capabilities(ready: &RecurrenceReadyExecutionV1) -> RusticolResult<()> {
+    let color_capability = match ready.color_accuracy.as_str() {
+        "lc" => crate::recurrence::RECURRENCE_LC_COLOR_CAPABILITY,
+        "nlc" | "full" => crate::recurrence::RECURRENCE_CONTRACTED_COLOR_CAPABILITY,
+        other => {
+            return Err(RusticolError::compatibility(format!(
+                "process-ready recurrence has unsupported color accuracy {other:?}"
+            )));
+        }
+    };
+    let mut expected = vec![
+        color_capability,
+        crate::recurrence::RECURRENCE_RUNTIME_CAPABILITY,
+    ];
+    if ready
+        .runtime
+        .color_contraction
+        .as_ref()
+        .and_then(|reference| reference.factorization.as_ref())
+        .is_some_and(|factorization| factorization.kind == "symmetric-group-fourier")
+    {
+        expected.push(SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY);
+    }
+    if ready.companion.is_some() {
+        expected.push(RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY);
+    }
+    expected.sort_unstable();
+    if ready
+        .required_runtime_capabilities
+        .iter()
+        .map(String::as_str)
+        .ne(expected.iter().copied())
+    {
+        return Err(RusticolError::compatibility(format!(
+            "process-ready recurrence must require exactly {expected:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn load_color_contraction(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &RecurrenceExecutionManifest,
+) -> RusticolResult<Option<RecurrenceColorContraction>> {
+    let Some(reference) = manifest.runtime_metadata.color_contraction.as_ref() else {
+        return Ok(None);
+    };
+    load_color_contraction_reference(artifact, evaluator_root, &manifest.key, reference).map(Some)
+}
+
+pub(super) fn load_color_contraction_reference(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    process_key: &str,
+    reference: &RecurrenceColorContractionReference,
+) -> RusticolResult<RecurrenceColorContraction> {
+    let relative_root = evaluator_root
+        .strip_prefix(artifact.root())
+        .map_err(|_| RusticolError::security("recurrence process root escapes the artifact"))?;
+    let logical = relative_root.join(&reference.path);
+    let logical = logical
+        .to_str()
+        .ok_or_else(|| RusticolError::security("recurrence color payload path is not UTF-8"))?;
+    let record = artifact.payload(logical)?;
+    if record.role != PayloadRole::EvaluatorState
+        || record.media_type != "application/octet-stream"
+        || record.process_id.as_deref() != Some(process_key)
+        || record.size_bytes != reference.size_bytes
+        || record.sha256 != reference.sha256
+    {
+        return Err(RusticolError::integrity(
+            "recurrence color-contraction payload disagrees with execution.json",
+        ));
+    }
+    let bytes = artifact.read_payload(logical)?;
+    let semantic_digest = SemanticDigest::new(recurrence_color_contraction_digest(&bytes))
+        .map_err(|_| {
+            RusticolError::integrity(
+                "recurrence color-contraction payload has an invalid semantic digest",
+            )
+        })?;
+    if semantic_digest.to_string() != reference.semantic_digest {
+        return Err(RusticolError::integrity(
+            "recurrence color-contraction payload digest is inconsistent",
+        ));
+    }
+    let contraction = decode_recurrence_color_contraction_v3(&bytes)?;
+    let accuracy = match contraction.accuracy() {
+        crate::recurrence::RecurrenceColorAccuracy::Nlc => "nlc",
+        crate::recurrence::RecurrenceColorAccuracy::Full => "full",
+    };
+    let storage = match contraction.storage() {
+        crate::recurrence::RecurrenceColorStorage::Expanded => "expanded",
+        crate::recurrence::RecurrenceColorStorage::Repeated => "repeated",
+        crate::recurrence::RecurrenceColorStorage::ConvolutionKernels => "convolution-kernels",
+    };
+    if accuracy != reference.color_accuracy
+        || storage != reference.storage
+        || contraction.active_sector_count() as u64 != reference.active_sector_count
+        || contraction.group_count() as u64 != reference.group_count
+        || contraction.sector_count() as u64 != reference.sector_count
+        || contraction.component_count() as u64 != reference.component_count
+        || contraction.destination_count() as u64 != reference.destination_count
+        || contraction.stored_entry_count() as u64 != reference.entry_count
+        || contraction.logical_entry_count() as u64 != reference.logical_entry_count
+        || contraction.includes_color_factor() != reference.includes_color_factor
+    {
+        return Err(RusticolError::integrity(
+            "recurrence color-contraction payload disagrees with its bounded summary",
+        ));
+    }
+    let factorization_matches = match (
+        reference.factorization.as_ref(),
+        contraction.factorization(),
+    ) {
+        (None, None) => true,
+        (Some(reference), Some(factorization)) => {
+            let kind = match factorization.kind() {
+                FactorizedColorContractionKind::KleinFourWalsh => "klein-four-walsh",
+                FactorizedColorContractionKind::ElementaryAbelianWalsh => {
+                    "elementary-abelian-walsh"
+                }
+                FactorizedColorContractionKind::SymmetricGroupFourier => "symmetric-group-fourier",
+            };
+            reference.kind == kind
+                && reference.rank == factorization.rank()
+                && reference.coset_count == factorization.coset_count() as u64
+        }
+        _ => false,
+    };
+    if !factorization_matches {
+        return Err(RusticolError::integrity(
+            "recurrence color-contraction factorization disagrees with its bounded summary",
+        ));
+    }
+    Ok(contraction)
+}
+
+pub(super) fn load_recurrence_exact_sections(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &RecurrenceExecutionManifest,
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<NativeRecurrenceExactSections> {
+    let (pack_bytes, pack, _payload_root) = load_prepared_pack(artifact, manifest)?;
+    drop(pack_bytes);
+    let plan = load_plan(artifact, evaluator_root, manifest)?.plan;
+    let direct = pack.recurrence_direct_template_catalog(
+        &manifest.prepared_kernel_pack_digest,
+        &manifest.direct_template_catalog_digest,
+    )?;
+    if direct.catalog_digest != plan.direct_template_catalog_digest().to_string() {
+        return Err(RusticolError::integrity(
+            "prepared Direct-Arena catalog digest does not match the recurrence plan",
+        ));
+    }
+    let public_flow_ids = public_flow_ids(&plan, &manifest.runtime_metadata, physics)?;
+    let exact_factors = plan
+        .exact_factors()
+        .iter()
+        .map(|factor| NativeRecurrenceExactFactor {
+            real_numerator: factor.real().numerator().to_string(),
+            real_denominator: factor.real().denominator().to_string(),
+            imaginary_numerator: factor.imag().numerator().to_string(),
+            imaginary_denominator: factor.imag().denominator().to_string(),
+        })
+        .collect();
+    let executors = direct
+        .templates
+        .into_iter()
+        .map(|template| NativeRecurrenceExactExecutor {
+            direct_executor_id: template.direct_executor_id,
+            role: template.role,
+            destination_operation: template.destination_operation,
+            parent_component_counts: template.parent_component_counts,
+            destination_component_count: template.destination_component_count,
+            momentum_operand_count: template.momentum_operand_count,
+            prepared_kernel_id: template.payload_binding.prepared_kernel_id,
+            runtime_template: template.payload_binding.runtime_template,
+        })
+        .collect();
+    Ok(NativeRecurrenceExactSections {
+        process_id: manifest.key.clone(),
+        strategy: plan.strategy().as_str().to_string(),
+        semantic_digest: manifest
+            .plan
+            .process_binding
+            .process_semantic_digest
+            .clone(),
+        runtime_layout_digest: plan.runtime_layout_digest().to_string(),
+        current_arena_components: plan.current_arena_components(),
+        amplitude_destination_count: plan.amplitude_destination_count(),
+        parameter_value_count: plan.parameter_value_count(),
+        external_source_count: plan.external_source_count(),
+        currents: plan.currents().to_vec(),
+        sources: plan.sources().to_vec(),
+        contributions: plan.contributions().to_vec(),
+        finalizations: plan.finalizations().to_vec(),
+        closures: plan.closures().to_vec(),
+        row_groups: plan.row_groups().to_vec(),
+        momentum_forms: plan.momentum_forms().to_vec(),
+        momentum_terms: plan.momentum_terms().to_vec(),
+        replay_targets: plan.replay_targets().to_vec(),
+        source_permutations: plan.source_permutations().to_vec(),
+        replay_momentum_signs: plan.replay_momentum_signs().to_vec(),
+        replay_helicity_map: plan.replay_helicity_map().to_vec(),
+        amplitude_destinations: plan.amplitude_destinations().to_vec(),
+        resolved_helicities: plan.resolved_helicities().to_vec(),
+        public_helicities: plan.public_helicities().to_vec(),
+        source_state_assignments: plan.source_state_assignments().to_vec(),
+        source_dispatch_variants: plan.source_dispatch_variants().to_vec(),
+        source_embeddings: plan.source_embeddings().to_vec(),
+        source_projections: plan.source_projections().to_vec(),
+        resolved_source_selections: plan.resolved_source_selections().to_vec(),
+        exact_factors,
+        public_flow_ids,
+        executors,
+    })
+}
+
+fn public_flow_ids(
+    plan: &DirectRecurrencePlan,
+    metadata: &RecurrenceRuntimeMetadata,
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<Vec<u32>> {
+    let available = match plan.strategy() {
+        crate::recurrence::RecurrenceStrategy::TopologyReplay => {
+            let available = plan
+                .replay_targets()
+                .iter()
+                .map(|target| target.public_flow_id)
+                .collect::<BTreeSet<_>>();
+            if available.len() != plan.replay_targets().len() {
+                return Err(RusticolError::integrity(
+                    "recurrence direct plan repeats a public replay target",
+                ));
+            }
+            available
+        }
+        crate::recurrence::RecurrenceStrategy::AllFlowUnion => {
+            let available = plan
+                .amplitude_destinations()
+                .iter()
+                .map(|destination| destination.target_sector_id)
+                .collect::<BTreeSet<_>>();
+            if available.len() != plan.amplitude_destinations().len() {
+                return Err(RusticolError::integrity(
+                    "all-flow-union direct plan repeats a physical-flow destination",
+                ));
+            }
+            available
+        }
+        crate::recurrence::RecurrenceStrategy::ContractedColorUnion => {
+            if !metadata.public_color_flows.is_empty()
+                || physics.color_components.len() != 1
+                || !matches!(
+                    physics.color_components.first(),
+                    Some(PhysicsColorComponentV1::ContractedColor(_))
+                )
+            {
+                return Err(RusticolError::integrity(
+                    "contracted recurrence must expose exactly one contracted color component and no public flow bindings",
+                ));
+            }
+            return Ok(Vec::new());
+        }
+    };
+    if metadata.public_color_flows.len() != physics.color_components.len() {
+        return Err(RusticolError::integrity(
+            "recurrence public color-flow bindings do not cover the physics axis",
+        ));
+    }
+    let mut seen = BTreeSet::new();
+    let strategy = plan.strategy();
+    let result = metadata
+        .public_color_flows
+        .iter()
+        .zip(&physics.color_components)
+        .map(|(binding, component)| {
+            if binding.public_id != component.id() {
+                return Err(RusticolError::integrity(
+                    "recurrence public color-flow binding order disagrees with physics.json",
+                ));
+            }
+            if !matches!(component, PhysicsColorComponentV1::LcFlow(_)) {
+                return Err(RusticolError::integrity(
+                    "recurrence public color-flow binding references a non-LC component",
+                ));
+            }
+            let plan_sector_id = match strategy {
+                crate::recurrence::RecurrenceStrategy::TopologyReplay => binding.target_sector_id,
+                crate::recurrence::RecurrenceStrategy::AllFlowUnion => {
+                    binding.construction_sector_id
+                }
+                crate::recurrence::RecurrenceStrategy::ContractedColorUnion => {
+                    unreachable!("contracted recurrence has no public color-flow bindings")
+                }
+            };
+            if plan_sector_id >= plan.physical_sector_count()
+                || !available.contains(&plan_sector_id)
+                || (strategy == crate::recurrence::RecurrenceStrategy::TopologyReplay
+                    && !seen.insert(plan_sector_id))
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence public color-flow target is absent or repeated in the direct plan",
+                ));
+            }
+            seen.insert(plan_sector_id);
+            Ok(plan_sector_id)
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    if seen != available {
+        return Err(RusticolError::integrity(
+            "recurrence direct-plan flow destinations do not match the public color-flow axis",
+        ));
+    }
+    Ok(result)
+}
+
+fn validate_ready_public_flow_ids(
+    plan: &DirectRecurrencePlan,
+    stored: &[u32],
+    stored_public_ids: &[String],
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<Vec<u32>> {
+    let available = match plan.strategy() {
+        crate::recurrence::RecurrenceStrategy::TopologyReplay => plan
+            .replay_targets()
+            .iter()
+            .map(|target| target.public_flow_id)
+            .collect::<BTreeSet<_>>(),
+        crate::recurrence::RecurrenceStrategy::AllFlowUnion => plan
+            .amplitude_destinations()
+            .iter()
+            .map(|destination| destination.target_sector_id)
+            .collect::<BTreeSet<_>>(),
+        crate::recurrence::RecurrenceStrategy::ContractedColorUnion => {
+            if !stored.is_empty()
+                || !stored_public_ids.is_empty()
+                || physics.color_components.len() != 1
+                || !matches!(
+                    physics.color_components.first(),
+                    Some(PhysicsColorComponentV1::ContractedColor(_))
+                )
+            {
+                return Err(RusticolError::integrity(
+                    "process-ready contracted recurrence has an invalid public color axis",
+                ));
+            }
+            return Ok(Vec::new());
+        }
+    };
+    if stored.len() != physics.color_components.len()
+        || stored_public_ids.len() != physics.color_components.len()
+        || physics
+            .color_components
+            .iter()
+            .any(|component| !matches!(component, PhysicsColorComponentV1::LcFlow(_)))
+    {
+        return Err(RusticolError::integrity(
+            "process-ready recurrence flow mapping does not cover the LC physics axis",
+        ));
+    }
+    if stored_public_ids
+        .iter()
+        .zip(&physics.color_components)
+        .any(|(stored_id, component)| stored_id != component.id())
+    {
+        return Err(RusticolError::integrity(
+            "process-ready recurrence flow IDs disagree with the physics axis",
+        ));
+    }
+    let mut seen = BTreeSet::new();
+    for sector in stored {
+        if *sector >= plan.physical_sector_count()
+            || !available.contains(sector)
+            || (plan.strategy() == crate::recurrence::RecurrenceStrategy::TopologyReplay
+                && !seen.insert(*sector))
+        {
+            return Err(RusticolError::integrity(
+                "process-ready recurrence flow mapping references an absent plan sector",
+            ));
+        }
+        seen.insert(*sector);
+    }
+    if seen != available {
+        return Err(RusticolError::integrity(
+            "process-ready recurrence flow mapping does not cover the plan destinations",
+        ));
+    }
+    Ok(stored.to_vec())
+}
+
+pub(super) fn direct_helicity_to_physics(
+    plan: &DirectRecurrencePlan,
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<Vec<usize>> {
+    let mut result = Vec::with_capacity(plan.resolved_helicities().len());
+    let mut seen_physics = BTreeSet::new();
+    for (expected_id, descriptor) in plan.resolved_helicities().iter().enumerate() {
+        if descriptor.id as usize != expected_id {
+            return Err(RusticolError::integrity(
+                "recurrence resolved-helicity IDs are not dense and ordered",
+            ));
+        }
+        let start = usize::try_from(descriptor.public_helicity_start).map_err(|_| {
+            RusticolError::artifact("recurrence public-helicity offset exceeds usize")
+        })?;
+        let count = usize::try_from(descriptor.public_helicity_count).map_err(|_| {
+            RusticolError::artifact("recurrence public-helicity count exceeds usize")
+        })?;
+        let stop = start
+            .checked_add(count)
+            .ok_or_else(|| RusticolError::artifact("recurrence public-helicity range overflows"))?;
+        let values = plan.public_helicities().get(start..stop).ok_or_else(|| {
+            RusticolError::integrity(
+                "recurrence resolved-helicity public vector is outside the direct plan",
+            )
+        })?;
+        if values.len() != physics.external_particles.len() {
+            return Err(RusticolError::integrity(
+                "recurrence resolved-helicity width disagrees with the physics axis",
+            ));
+        }
+        let matches = physics
+            .helicities
+            .iter()
+            .enumerate()
+            .filter_map(|(index, helicity)| (helicity.values == values).then_some(index))
+            .collect::<Vec<_>>();
+        if matches.len() != 1 {
+            return Err(RusticolError::integrity(format!(
+                "recurrence resolved helicity {expected_id} maps to {} physics helicities",
+                matches.len()
+            )));
+        }
+        let physics_index = matches[0];
+        if !seen_physics.insert(physics_index) {
+            return Err(RusticolError::integrity(
+                "recurrence resolved helicities repeat a physics helicity",
+            ));
+        }
+        result.push(physics_index);
+    }
+    Ok(result)
+}
+
+pub(super) fn validate_ready_direct_helicity_to_physics(
+    plan: &DirectRecurrencePlan,
+    stored: &[u64],
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<Vec<usize>> {
+    if stored.len() != plan.resolved_helicities().len() {
+        return Err(RusticolError::integrity(
+            "process-ready helicity mapping has the wrong size",
+        ));
+    }
+    let mut result = Vec::with_capacity(stored.len());
+    let mut seen = BTreeSet::new();
+    for (expected_id, (descriptor, physics_index)) in
+        plan.resolved_helicities().iter().zip(stored).enumerate()
+    {
+        if descriptor.id as usize != expected_id {
+            return Err(RusticolError::integrity(
+                "recurrence resolved-helicity IDs are not dense and ordered",
+            ));
+        }
+        let physics_index = usize::try_from(*physics_index)
+            .map_err(|_| RusticolError::artifact("physics helicity index exceeds usize"))?;
+        if !seen.insert(physics_index) {
+            return Err(RusticolError::integrity(
+                "process-ready recurrence helicity mapping repeats a physics row",
+            ));
+        }
+        let physics_helicity = physics.helicities.get(physics_index).ok_or_else(|| {
+            RusticolError::integrity(
+                "process-ready recurrence helicity mapping is outside the physics axis",
+            )
+        })?;
+        let start = usize::try_from(descriptor.public_helicity_start)
+            .map_err(|_| RusticolError::artifact("public-helicity offset exceeds usize"))?;
+        let count = usize::try_from(descriptor.public_helicity_count)
+            .map_err(|_| RusticolError::artifact("public-helicity count exceeds usize"))?;
+        let stop = start
+            .checked_add(count)
+            .ok_or_else(|| RusticolError::artifact("public-helicity range overflows"))?;
+        if plan.public_helicities().get(start..stop) != Some(physics_helicity.values.as_slice()) {
+            return Err(RusticolError::integrity(
+                "process-ready recurrence helicity mapping disagrees with the direct plan",
+            ));
+        }
+        result.push(physics_index);
+    }
+    Ok(result)
+}
+
+fn load_prepared_pack(
+    artifact: &VerifiedArtifact,
+    manifest: &RecurrenceExecutionManifest,
+) -> RusticolResult<(Vec<u8>, PreparedKernelPackManifest, PathBuf)> {
+    load_prepared_pack_reference(
+        artifact,
+        &manifest.kernel_pack.manifest_path,
+        &manifest.kernel_pack.payload_root,
+    )
+}
+
+fn load_ready_prepared_pack(
+    artifact: &VerifiedArtifact,
+    ready: &RecurrenceReadyExecutionV1,
+) -> RusticolResult<(Vec<u8>, PreparedKernelPackManifest, PathBuf)> {
+    load_prepared_pack_reference(
+        artifact,
+        &ready.kernel_pack.manifest_path,
+        &ready.kernel_pack.payload_root,
+    )
+}
+
+fn load_prepared_pack_reference(
+    artifact: &VerifiedArtifact,
+    manifest_path: &str,
+    payload_root: &str,
+) -> RusticolResult<(Vec<u8>, PreparedKernelPackManifest, PathBuf)> {
+    let manifest_path = confined_internal_path(
+        manifest_path,
+        "recurrence prepared kernel-pack manifest path",
+    )?;
+    let manifest_path = manifest_path.to_str().ok_or_else(|| {
+        RusticolError::security("recurrence kernel-pack manifest path is not valid UTF-8")
+    })?;
+    if artifact.payload(manifest_path)?.role != PayloadRole::EvaluatorManifest {
+        return Err(RusticolError::security(
+            "recurrence kernel-pack manifest is not an evaluator-manifest payload",
+        ));
+    }
+    let bytes = artifact.read_payload(manifest_path)?;
+    let pack: PreparedKernelPackManifest = serde_json::from_slice(&bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse recurrence prepared kernel pack: {error}"
+        ))
+    })?;
+    pack.validate()?;
+    validate_recurrence_prepared_pack_outer_target(&artifact.manifest().producer.target, &pack)?;
+    let payload_root = artifact.root().join(confined_internal_path(
+        payload_root,
+        "recurrence prepared kernel payload root",
+    )?);
+    Ok((bytes, pack, payload_root))
+}
+
+fn recurrence_payload_root(
+    artifact: &VerifiedArtifact,
+    manifest: &RecurrenceExecutionManifest,
+) -> RusticolResult<PathBuf> {
+    Ok(artifact.root().join(confined_internal_path(
+        &manifest.kernel_pack.payload_root,
+        "recurrence prepared kernel payload root",
+    )?))
+}
+
+fn ready_recurrence_payload_root(
+    artifact: &VerifiedArtifact,
+    ready: &RecurrenceReadyExecutionV1,
+) -> RusticolResult<PathBuf> {
+    Ok(artifact.root().join(confined_internal_path(
+        &ready.kernel_pack.payload_root,
+        "process-ready recurrence kernel payload root",
+    )?))
+}
+
+pub(super) fn validate_recurrence_prepared_pack_outer_target(
+    outer_target: &crate::Target,
+    pack: &PreparedKernelPackManifest,
+) -> RusticolResult<()> {
+    pack.validate_portable_process_artifact_target(outer_target, "recurrence")
+}
+
+fn load_plan(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &RecurrenceExecutionManifest,
+) -> RusticolResult<LoadedRecurrencePlan> {
+    load_plan_summary(artifact, evaluator_root, manifest, &manifest.plan)
+}
+
+pub(super) fn load_plan_summary(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &RecurrenceExecutionManifest,
+    summary: &RecurrencePlanSummary,
+) -> RusticolResult<LoadedRecurrencePlan> {
+    load_plan_reference(
+        artifact,
+        evaluator_root,
+        RecurrencePlanLoadSpec {
+            process_key: &manifest.key,
+            compiled_model_digest: &manifest.compiled_model_digest,
+            recurrence_template_catalog_digest: &manifest.recurrence_template_catalog_digest,
+            prepared_kernel_pack_digest: &manifest.prepared_kernel_pack_digest,
+            direct_template_catalog_digest: &manifest.direct_template_catalog_digest,
+            plan: RecurrenceReadyPlanRef {
+                runtime_schedule: &summary.runtime_schedule,
+                process_binding: &summary.process_binding,
+                runtime_container_member: &summary.inspection_summary.runtime_container_member,
+                color_projection_certificate: summary
+                    .inspection_summary
+                    .color_projection_certificate
+                    .as_ref(),
+                helicity_dispatch: summary.helicity_dispatch.as_ref(),
+            },
+            role: if summary.helicity_dispatch.is_some() {
+                RecurrenceReadyPlanRoleV1::HelicitySelector
+            } else {
+                RecurrenceReadyPlanRoleV1::Primary
+            },
+        },
+    )
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum RecurrenceReadyPlanRoleV1 {
+    Primary,
+    HelicitySelector,
+}
+
+struct RecurrenceReadyPlanRef<'a> {
+    runtime_schedule: &'a RecurrenceRuntimeContainer,
+    process_binding: &'a RecurrenceProcessBinding,
+    runtime_container_member: &'a RecurrenceRuntimeContainerMember,
+    color_projection_certificate: Option<&'a RecurrenceColorProjectionCertificate>,
+    helicity_dispatch: Option<&'a RecurrenceHelicityDispatchReference>,
+}
+
+struct RecurrencePlanLoadSpec<'a> {
+    process_key: &'a str,
+    compiled_model_digest: &'a str,
+    recurrence_template_catalog_digest: &'a str,
+    prepared_kernel_pack_digest: &'a str,
+    direct_template_catalog_digest: &'a str,
+    plan: RecurrenceReadyPlanRef<'a>,
+    role: RecurrenceReadyPlanRoleV1,
+}
+
+fn validate_ready_plan_reference(spec: &RecurrencePlanLoadSpec<'_>) -> RusticolResult<()> {
+    let container = spec.plan.runtime_schedule;
+    let binding = spec.plan.process_binding;
+    if container.kind != RECURRENCE_RUNTIME_CONTAINER_KIND
+        || container.schema_version != RECURRENCE_RUNTIME_CONTAINER_SCHEMA
+        || container.storage_abi != RECURRENCE_RUNTIME_STORAGE_ABI
+        || container.plan_member_path != RECURRENCE_DIRECT_SCHEDULE_MEMBER
+    {
+        return Err(RusticolError::compatibility(
+            "unsupported process-ready recurrence schedule contract",
+        ));
+    }
+    let expected_schedule_path = format!(
+        "recurrence/schedules/{}/recurrence-runtime.pacbin",
+        binding.schedule_digest
+    );
+    if container.path != expected_schedule_path
+        || !(1..=2).contains(&container.member_count)
+        || container.size_bytes == 0
+        || container.unpacked_size_bytes == 0
+        || container.unpacked_size_bytes > container.size_bytes
+    {
+        return Err(RusticolError::integrity(
+            "process-ready recurrence schedule metadata is inconsistent",
+        ));
+    }
+    for digest in [
+        &container.sha256,
+        &container.index_sha256,
+        &binding.schedule_digest,
+        &binding.native_schedule_semantic_digest,
+        &binding.process_digest,
+        &binding.process_semantic_digest,
+        &binding.sha256,
+    ] {
+        decode_sha256(digest)?;
+    }
+    let expected_binding_path = match spec.role {
+        RecurrenceReadyPlanRoleV1::Primary => RECURRENCE_PROCESS_BINDING_PATH,
+        RecurrenceReadyPlanRoleV1::HelicitySelector => RECURRENCE_HELICITY_SELECTOR_BINDING_PATH,
+    };
+    if binding.abi != RECURRENCE_PROCESS_BINDING_ABI
+        || binding.path != expected_binding_path
+        || binding.process_id != spec.process_key
+        || binding.size_bytes == 0
+        || binding.process_support_words.is_empty()
+        || binding.process_support_words.last() == Some(&0)
+        || binding
+            .process_support_words
+            .iter()
+            .map(|word| word.count_ones())
+            .sum::<u32>()
+            != 1
+    {
+        return Err(RusticolError::integrity(
+            "process-ready recurrence binding metadata is inconsistent",
+        ));
+    }
+    validate_ready_process_remap(&binding.remap)?;
+
+    let member = spec.plan.runtime_container_member;
+    if member.path != RECURRENCE_DIRECT_SCHEDULE_MEMBER
+        || member.size_bytes == 0
+        || member.container_size_bytes != container.size_bytes
+        || member.size_bytes > member.container_size_bytes
+    {
+        return Err(RusticolError::integrity(
+            "process-ready recurrence plan-member metadata is inconsistent",
+        ));
+    }
+    decode_sha256(&member.sha256)?;
+    let certificate_size = if let Some(certificate) = spec.plan.color_projection_certificate {
+        if certificate.path != RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER
+            || certificate.schema_version != 1
+            || certificate.proof_kind != "exact-rectangular-sum-projection"
+            || !certificate.publishable
+            || certificate.size_bytes == 0
+        {
+            return Err(RusticolError::compatibility(
+                "unsupported process-ready recurrence projection certificate",
+            ));
+        }
+        decode_sha256(&certificate.sha256)?;
+        certificate.size_bytes
+    } else {
+        0
+    };
+    let expected_member_count = 1 + u64::from(certificate_size != 0);
+    let expected_unpacked = member
+        .size_bytes
+        .checked_add(certificate_size)
+        .ok_or_else(|| RusticolError::artifact("recurrence member sizes overflow u64"))?;
+    if container.member_count != expected_member_count
+        || container.unpacked_size_bytes != expected_unpacked
+    {
+        return Err(RusticolError::integrity(
+            "process-ready recurrence PACBIN member inventory is inconsistent",
+        ));
+    }
+    match (spec.role, spec.plan.helicity_dispatch) {
+        (RecurrenceReadyPlanRoleV1::Primary, None) => {}
+        (RecurrenceReadyPlanRoleV1::HelicitySelector, Some(dispatch)) => {
+            let expected_path = format!(
+                "recurrence/schedules/{}/{}",
+                binding.schedule_digest, RECURRENCE_HELICITY_DISPATCH_PATH
+            );
+            if dispatch.abi != crate::recurrence::RECURRENCE_HELICITY_DISPATCH_ABI
+                || dispatch.path != expected_path
+                || dispatch.size_bytes == 0
+                || dispatch.resolved_helicity_count > u64::from(u32::MAX)
+            {
+                return Err(RusticolError::compatibility(
+                    "unsupported process-ready recurrence helicity dispatch",
+                ));
+            }
+            decode_sha256(&dispatch.sha256)?;
+            decode_sha256(&dispatch.base_runtime_layout_digest)?;
+        }
+        _ => {
+            return Err(RusticolError::integrity(
+                "process-ready recurrence plan has the wrong helicity-dispatch role",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn validate_ready_process_remap(remap: &RecurrenceProcessRemap) -> RusticolResult<()> {
+    decode_sha256(&remap.bijection_digest)?;
+    validate_ready_permutation(&remap.source_slots, "source slots")?;
+    validate_ready_permutation(&remap.public_flow_ids, "public flows")?;
+    validate_ready_permutation(&remap.physical_sector_ids, "physical sectors")?;
+    if remap.source_momentum_signs.len() != remap.source_slots.len()
+        || remap.source_helicity_signs.len() != remap.source_slots.len()
+        || remap
+            .source_momentum_signs
+            .iter()
+            .chain(&remap.source_helicity_signs)
+            .any(|sign| !matches!(sign, -1 | 1))
+        || remap.source_state_offsets.len() != remap.source_slots.len() + 1
+        || remap.source_state_offsets.first() != Some(&0)
+        || remap.source_state_offsets.last().copied().map(u64::from)
+            != Some(remap.source_state_indices.len() as u64)
+        || remap
+            .source_state_offsets
+            .windows(2)
+            .any(|window| window[0] > window[1])
+    {
+        return Err(RusticolError::integrity(
+            "process-ready recurrence source-state remap is malformed",
+        ));
+    }
+    for window in remap.source_state_offsets.windows(2) {
+        let start = usize::try_from(window[0])
+            .map_err(|_| RusticolError::artifact("source-state offset exceeds usize"))?;
+        let stop = usize::try_from(window[1])
+            .map_err(|_| RusticolError::artifact("source-state offset exceeds usize"))?;
+        validate_ready_permutation(
+            remap.source_state_indices.get(start..stop).ok_or_else(|| {
+                RusticolError::integrity("source-state remap range is out of bounds")
+            })?,
+            "source states",
+        )?;
+    }
+    for mapping in [
+        &remap.state_templates,
+        &remap.source_templates,
+        &remap.direct_executors,
+        &remap.parameter_slots,
+    ] {
+        let mut previous = None;
+        let mut sources = BTreeSet::new();
+        let mut targets = BTreeSet::new();
+        for [source, target] in &mapping.changes {
+            if *source >= mapping.count
+                || *target >= mapping.count
+                || source == target
+                || previous.is_some_and(|value| value >= *source)
+                || !targets.insert(*target)
+            {
+                return Err(RusticolError::integrity(
+                    "process-ready sparse recurrence bijection is malformed",
+                ));
+            }
+            previous = Some(*source);
+            sources.insert(*source);
+        }
+        if sources != targets {
+            return Err(RusticolError::integrity(
+                "process-ready sparse recurrence changes do not form a bijection",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn validate_ready_permutation(values: &[u32], context: &str) -> RusticolResult<()> {
+    let mut seen = vec![false; values.len()];
+    for value in values {
+        let index = usize::try_from(*value)
+            .map_err(|_| RusticolError::artifact(format!("{context} index exceeds usize")))?;
+        let slot = seen.get_mut(index).ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "process-ready recurrence {context} is not a permutation"
+            ))
+        })?;
+        if std::mem::replace(slot, true) {
+            return Err(RusticolError::integrity(format!(
+                "process-ready recurrence {context} repeats an index"
+            )));
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn load_ready_plan(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    ready: &RecurrenceReadyExecutionV1,
+    plan: &RecurrenceReadyPlanV1,
+    role: RecurrenceReadyPlanRoleV1,
+) -> RusticolResult<LoadedRecurrencePlan> {
+    load_plan_reference(
+        artifact,
+        evaluator_root,
+        RecurrencePlanLoadSpec {
+            process_key: &ready.key,
+            compiled_model_digest: &ready.compiled_model_digest,
+            recurrence_template_catalog_digest: &ready.recurrence_template_catalog_digest,
+            prepared_kernel_pack_digest: &ready.prepared_kernel_pack_digest,
+            direct_template_catalog_digest: &ready.direct_template_catalog_digest,
+            plan: RecurrenceReadyPlanRef {
+                runtime_schedule: &plan.runtime_schedule,
+                process_binding: &plan.process_binding,
+                runtime_container_member: &plan.runtime_container_member,
+                color_projection_certificate: plan.color_projection_certificate.as_ref(),
+                helicity_dispatch: plan.helicity_dispatch.as_ref(),
+            },
+            role,
+        },
+    )
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn load_plan_reference(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    spec: RecurrencePlanLoadSpec<'_>,
+) -> RusticolResult<LoadedRecurrencePlan> {
+    #[cfg(feature = "on-the-fly-test-support")]
+    crate::recurrence::on_the_fly::reject_forbidden_work_if_probed(
+        crate::recurrence::on_the_fly::OnTheFlyForbiddenWorkV1::DirectPlanLoad,
+    )?;
+    validate_ready_plan_reference(&spec)?;
+    let container = spec.plan.runtime_schedule;
+    let path = artifact.root().join(&container.path);
+    let payload = artifact.payload(&container.path)?;
+    if payload.role != PayloadRole::EvaluatorState
+        || payload.media_type != "application/octet-stream"
+        || payload.process_id.is_some()
+        || payload.executable
+        || payload.size_bytes != container.size_bytes
+        || payload.sha256 != container.sha256
+    {
+        return Err(RusticolError::integrity(
+            "recurrence root schedule disagrees with its authenticated payload",
+        ));
+    }
+
+    let process_binding = validate_process_binding(artifact, evaluator_root, &spec)?;
+
+    let expected_file_sha = decode_sha256(&container.sha256)?;
+    let container_file = artifact.open_payload_file(&container.path)?;
+    let reader = PacbinReader::open_file_with_sha256(container_file, &path, &expected_file_sha)?;
+    let index = reader.index();
+    if index.file_size() != container.size_bytes
+        || reader.container_size() as u64 != container.size_bytes
+        || index.index_sha256().as_slice() != decode_sha256(&container.index_sha256)?.as_slice()
+        || index.members().len() as u64 != container.member_count
+        || index
+            .members()
+            .iter()
+            .map(|member| member.length())
+            .sum::<u64>()
+            != container.unpacked_size_bytes
+    {
+        return Err(RusticolError::integrity(
+            "recurrence runtime PACBIN metadata disagrees with execution.json",
+        ));
+    }
+    let member = reader.member(RECURRENCE_DIRECT_SCHEDULE_MEMBER)?;
+    let plan_metadata = spec.plan.runtime_container_member;
+    if member.kind() != PacbinMemberKind::RecurrenceDirectPlan {
+        return Err(RusticolError::compatibility(
+            "recurrence runtime PACBIN contains an incompatible plan member",
+        ));
+    }
+    if member.length() != plan_metadata.size_bytes
+        || member.sha256().as_slice() != decode_sha256(&plan_metadata.sha256)?.as_slice()
+    {
+        return Err(RusticolError::integrity(
+            "recurrence DirectPlan member disagrees with execution.json",
+        ));
+    }
+    match (
+        spec.plan.color_projection_certificate,
+        index.members().len(),
+    ) {
+        (None, 1) => {}
+        (Some(metadata), 2) => {
+            let certificate = reader.member(RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER)?;
+            if certificate.kind() != PacbinMemberKind::RecurrenceColorProjectionCertificate {
+                return Err(RusticolError::compatibility(
+                    "recurrence runtime PACBIN contains an incompatible projection certificate",
+                ));
+            }
+            if certificate.length() != metadata.size_bytes
+                || certificate.sha256().as_slice() != decode_sha256(&metadata.sha256)?.as_slice()
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence color-projection certificate disagrees with execution.json",
+                ));
+            }
+            validate_recurrence_color_projection_certificate(
+                reader.member_bytes(RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER)?,
+            )?;
+        }
+        (None, 2) | (Some(_), 1) => {
+            return Err(RusticolError::integrity(
+                "recurrence runtime PACBIN projection certificate disagrees with execution.json",
+            ));
+        }
+        (_, count) => {
+            return Err(RusticolError::compatibility(format!(
+                "recurrence runtime PACBIN contains {count} members; expected one plan and at most one projection certificate"
+            )));
+        }
+    }
+    let bytes = reader.member_bytes(RECURRENCE_DIRECT_SCHEDULE_MEMBER)?;
+    let plan = decode_recurrence_direct_plan_v2(bytes)?;
+    if plan.semantic_digest().to_string()
+        != spec.plan.process_binding.native_schedule_semantic_digest()
+    {
+        return Err(RusticolError::integrity(
+            "recurrence native schedule semantic digest disagrees with its process binding",
+        ));
+    }
+    if plan.prepared_pack_digest().to_string() != spec.prepared_kernel_pack_digest
+        || plan.direct_template_catalog_digest().to_string() != spec.direct_template_catalog_digest
+    {
+        return Err(RusticolError::integrity(
+            "direct recurrence plan authentication digests disagree with execution.json",
+        ));
+    }
+    let root_runtime_layout_digest = plan.runtime_layout_digest();
+    let plan = apply_process_remap(plan, &process_binding.remap)?.into_runtime_compacted();
+    let expected_prepared_pack_digest = semantic_digest_from_bytes(
+        decode_sha256(spec.prepared_kernel_pack_digest)?,
+        "prepared-kernel pack",
+    )?;
+    let expected_catalog_digest = semantic_digest_from_bytes(
+        decode_sha256(spec.direct_template_catalog_digest)?,
+        "direct-template catalog",
+    )?;
+    process_binding.process_executors.validate_for_plan(
+        &plan,
+        expected_prepared_pack_digest,
+        expected_catalog_digest,
+        root_runtime_layout_digest,
+    )?;
+    Ok(LoadedRecurrencePlan {
+        plan,
+        process_executors: process_binding.process_executors,
+    })
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+#[cfg_attr(target_vendor = "apple", cold)]
+fn validate_process_binding(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    spec: &RecurrencePlanLoadSpec<'_>,
+) -> RusticolResult<LoadedRecurrenceProcessBinding> {
+    let binding = spec.plan.process_binding;
+    let relative_root = evaluator_root
+        .strip_prefix(artifact.root())
+        .map_err(|_| RusticolError::security("recurrence process root escapes the artifact"))?;
+    let logical = relative_root.join(&binding.path);
+    let logical = logical
+        .to_str()
+        .ok_or_else(|| RusticolError::security("recurrence process-binding path is not UTF-8"))?;
+    let record = artifact.payload(logical)?;
+    if record.role != PayloadRole::EvaluatorState
+        || record.process_id.as_deref() != Some(spec.process_key)
+        || record.size_bytes != binding.size_bytes
+        || record.sha256 != binding.sha256
+    {
+        return Err(RusticolError::integrity(
+            "recurrence process-binding payload disagrees with execution.json",
+        ));
+    }
+    let bytes = artifact.read_payload(logical)?;
+    if bytes.len() < RECURRENCE_PROCESS_BINDING_HEADER_SIZE_V4
+        || bytes.get(..8) != Some(RECURRENCE_PROCESS_BINDING_MAGIC_V4.as_slice())
+    {
+        return Err(RusticolError::compatibility(
+            "unsupported recurrence process-binding payload",
+        ));
+    }
+    let u32_at = |offset: usize| {
+        bytes
+            .get(offset..offset + 4)
+            .and_then(|raw| raw.try_into().ok())
+            .map(u32::from_le_bytes)
+            .ok_or_else(|| RusticolError::artifact("truncated recurrence process binding"))
+    };
+    if u32_at(8)? != RECURRENCE_PROCESS_BINDING_VERSION_V4
+        || usize::try_from(u32_at(12)?).ok() != Some(RECURRENCE_PROCESS_BINDING_HEADER_SIZE_V4)
+    {
+        return Err(RusticolError::compatibility(
+            "unsupported recurrence process-binding version",
+        ));
+    }
+    let process_len = usize::try_from(u32_at(16)?)
+        .map_err(|_| RusticolError::artifact("recurrence process ID is too large"))?;
+    let word_count = usize::try_from(u32_at(20)?)
+        .map_err(|_| RusticolError::artifact("recurrence support mask is too large"))?;
+    let target_len = usize::try_from(u32_at(24)?)
+        .map_err(|_| RusticolError::artifact("recurrence executor target is too large"))?;
+    let cpu_feature_count = u32_at(28)?;
+    let descriptor_count = u32_at(32)?;
+    let catalog_executor_count = u32_at(36)?;
+    let backend = ProcessExecutorBackend::decode(
+        *bytes
+            .get(40)
+            .ok_or_else(|| RusticolError::artifact("truncated executor backend"))?,
+    )?;
+    let portable = match bytes.get(41).copied() {
+        Some(0) => false,
+        Some(1) => true,
+        _ => {
+            return Err(RusticolError::artifact(
+                "recurrence executor portability is not a canonical boolean",
+            ));
+        }
+    };
+    if bytes.get(42) != Some(&64) || bytes.get(43) != Some(&0) {
+        return Err(RusticolError::compatibility(
+            "recurrence process executors require a 64-bit little-endian target",
+        ));
+    }
+    let counts = (0..11)
+        .map(|index| u32_at(44 + index * 4))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    if counts[5] != catalog_executor_count {
+        return Err(RusticolError::integrity(
+            "recurrence executor catalog domain disagrees with its process remap",
+        ));
+    }
+    let schedule_digest = read_header_digest(&bytes, 88, "root schedule")?;
+    let process_semantic_digest = read_header_digest(&bytes, 120, "process semantic")?;
+    let compiled_model_digest = semantic_digest_from_bytes(
+        read_header_digest(&bytes, 152, "compiled model")?,
+        "compiled model",
+    )?;
+    let recurrence_template_catalog_digest = semantic_digest_from_bytes(
+        read_header_digest(&bytes, 184, "recurrence-template catalog")?,
+        "recurrence-template catalog",
+    )?;
+    let prepared_kernel_pack_digest = semantic_digest_from_bytes(
+        read_header_digest(&bytes, 216, "prepared-kernel pack")?,
+        "prepared-kernel pack",
+    )?;
+    let direct_template_catalog_digest = semantic_digest_from_bytes(
+        read_header_digest(&bytes, 248, "direct-template catalog")?,
+        "direct-template catalog",
+    )?;
+    let runtime_layout_digest = semantic_digest_from_bytes(
+        read_header_digest(&bytes, 280, "runtime layout")?,
+        "runtime layout",
+    )?;
+    let process_digest = read_header_digest(&bytes, 312, "process")?;
+    if schedule_digest != decode_sha256(&binding.schedule_digest)?
+        || process_digest != decode_sha256(&binding.process_digest)?
+        || process_semantic_digest != decode_sha256(&binding.process_semantic_digest)?
+        || compiled_model_digest.to_string() != spec.compiled_model_digest
+        || recurrence_template_catalog_digest.to_string() != spec.recurrence_template_catalog_digest
+        || prepared_kernel_pack_digest.to_string() != spec.prepared_kernel_pack_digest
+        || direct_template_catalog_digest.to_string() != spec.direct_template_catalog_digest
+    {
+        return Err(RusticolError::integrity(
+            "recurrence process-executor identities disagree with execution.json",
+        ));
+    }
+    let process_start = RECURRENCE_PROCESS_BINDING_HEADER_SIZE_V4;
+    let process_end = process_start
+        .checked_add(process_len)
+        .ok_or_else(|| RusticolError::artifact("recurrence process binding overflows"))?;
+    let target_end = process_end
+        .checked_add(target_len)
+        .ok_or_else(|| RusticolError::artifact("recurrence executor target range overflows"))?;
+    if bytes.get(process_start..process_end) != Some(spec.process_key.as_bytes()) || word_count == 0
+    {
+        return Err(RusticolError::integrity(
+            "recurrence process-binding payload is inconsistent",
+        ));
+    }
+    let target_triple =
+        std::str::from_utf8(bytes.get(process_end..target_end).ok_or_else(|| {
+            RusticolError::artifact("truncated recurrence process-executor target")
+        })?)
+        .map_err(|_| RusticolError::artifact("recurrence executor target is not UTF-8"))?
+        .to_owned();
+    if target_triple.is_empty() {
+        return Err(RusticolError::artifact(
+            "recurrence process-executor target is empty",
+        ));
+    }
+    let mut cursor = target_end;
+    let cpu_features = (0..cpu_feature_count)
+        .map(|_| read_string(&bytes, &mut cursor, "executor CPU feature"))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let target = ProcessExecutorTarget {
+        backend,
+        target_triple,
+        portable,
+        cpu_features,
+    };
+    target.validate(&artifact.manifest().producer.target)?;
+    let words = read_u64_values(
+        &bytes,
+        &mut cursor,
+        u32::try_from(word_count)
+            .map_err(|_| RusticolError::artifact("recurrence support mask is too large"))?,
+        "recurrence support mask",
+    )?;
+    if words != binding.process_support_words {
+        return Err(RusticolError::integrity(
+            "recurrence process support mask is inconsistent",
+        ));
+    }
+    let source_slots = read_u32_rows(&bytes, &mut cursor, counts[0], 1, "source-slot remap")?
+        .into_iter()
+        .map(|row| row[0])
+        .collect();
+    let source_momentum_signs =
+        read_i32_values(&bytes, &mut cursor, counts[0], "source momentum signs")?;
+    let source_helicity_signs =
+        read_i32_values(&bytes, &mut cursor, counts[0], "source helicity signs")?;
+    let source_state_offsets = read_u32_rows(
+        &bytes,
+        &mut cursor,
+        counts[0].checked_add(1).ok_or_else(|| {
+            RusticolError::artifact("recurrence source-state offset count overflows")
+        })?,
+        1,
+        "source-state remap offsets",
+    )?
+    .into_iter()
+    .map(|row| row[0])
+    .collect::<Vec<_>>();
+    let source_state_count = source_state_offsets
+        .last()
+        .copied()
+        .ok_or_else(|| RusticolError::artifact("recurrence source-state remap has no offsets"))?;
+    let source_state_indices = read_u32_rows(
+        &bytes,
+        &mut cursor,
+        source_state_count,
+        1,
+        "source-state remap indices",
+    )?
+    .into_iter()
+    .map(|row| row[0])
+    .collect();
+    let public_flow_ids = read_u32_rows(&bytes, &mut cursor, counts[1], 1, "public-flow remap")?
+        .into_iter()
+        .map(|row| row[0])
+        .collect();
+    let physical_sector_ids =
+        read_u32_rows(&bytes, &mut cursor, counts[2], 1, "physical-sector remap")?
+            .into_iter()
+            .map(|row| row[0])
+            .collect();
+    let state_templates = RecurrenceSparseBijection {
+        count: counts[3],
+        changes: read_u32_pairs(&bytes, &mut cursor, counts[7], "state-template remap")?,
+    };
+    let source_templates = RecurrenceSparseBijection {
+        count: counts[4],
+        changes: read_u32_pairs(&bytes, &mut cursor, counts[8], "source-template remap")?,
+    };
+    let direct_executors = RecurrenceSparseBijection {
+        count: counts[5],
+        changes: read_u32_pairs(&bytes, &mut cursor, counts[9], "direct-executor remap")?,
+    };
+    let parameter_slots = RecurrenceSparseBijection {
+        count: counts[6],
+        changes: read_u32_pairs(&bytes, &mut cursor, counts[10], "parameter-slot remap")?,
+    };
+    let decoded = RecurrenceProcessRemap {
+        bijection_digest: binding.remap.bijection_digest.clone(),
+        source_slots,
+        source_momentum_signs,
+        source_helicity_signs,
+        source_state_offsets,
+        source_state_indices,
+        public_flow_ids,
+        physical_sector_ids,
+        state_templates,
+        source_templates,
+        direct_executors,
+        parameter_slots,
+    };
+    if decoded != binding.remap {
+        return Err(RusticolError::integrity(
+            "recurrence process-binding binary remap disagrees with execution.json",
+        ));
+    }
+    let process_executors = decode_process_executor_descriptors(
+        &bytes,
+        &mut cursor,
+        descriptor_count,
+        catalog_executor_count,
+        target,
+        ProcessExecutorIdentities {
+            compiled_model_digest,
+            recurrence_template_catalog_digest,
+            prepared_kernel_pack_digest,
+            direct_template_catalog_digest,
+            runtime_layout_digest,
+        },
+    )?;
+    if cursor != bytes.len() {
+        return Err(RusticolError::integrity(
+            "recurrence process-binding payload has trailing bytes",
+        ));
+    }
+    Ok(LoadedRecurrenceProcessBinding {
+        remap: decoded,
+        process_executors,
+    })
+}
+
+fn read_header_digest(bytes: &[u8], offset: usize, context: &str) -> RusticolResult<[u8; 32]> {
+    bytes
+        .get(offset..offset + 32)
+        .ok_or_else(|| RusticolError::artifact(format!("truncated {context} digest")))?
+        .try_into()
+        .map_err(|_| RusticolError::internal("process-binding digest width drifted"))
+}
+
+fn read_u32_pairs(
+    bytes: &[u8],
+    cursor: &mut usize,
+    count: u32,
+    context: &str,
+) -> RusticolResult<Vec<[u32; 2]>> {
+    read_u32_rows(bytes, cursor, count, 2, context)?
+        .into_iter()
+        .map(|row| {
+            row.try_into()
+                .map_err(|_| RusticolError::internal("u32 pair width drifted"))
+        })
+        .collect()
+}
+
+fn read_u32_rows(
+    bytes: &[u8],
+    cursor: &mut usize,
+    row_count: u32,
+    row_width: usize,
+    context: &str,
+) -> RusticolResult<Vec<Vec<u32>>> {
+    let value_count = usize::try_from(row_count)
+        .ok()
+        .and_then(|count| count.checked_mul(row_width))
+        .ok_or_else(|| RusticolError::artifact(format!("{context} count overflows")))?;
+    let byte_count = value_count
+        .checked_mul(4)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} byte size overflows")))?;
+    let end = cursor
+        .checked_add(byte_count)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} range overflows")))?;
+    let payload = bytes
+        .get(*cursor..end)
+        .ok_or_else(|| RusticolError::artifact(format!("truncated {context}")))?;
+    *cursor = end;
+    payload
+        .chunks_exact(row_width * 4)
+        .map(|row| {
+            row.chunks_exact(4)
+                .map(|raw| {
+                    raw.try_into()
+                        .map(u32::from_le_bytes)
+                        .map_err(|_| RusticolError::artifact(format!("truncated {context}")))
+                })
+                .collect()
+        })
+        .collect()
+}
+
+fn read_i32_values(
+    bytes: &[u8],
+    cursor: &mut usize,
+    count: u32,
+    context: &str,
+) -> RusticolResult<Vec<i32>> {
+    let count = usize::try_from(count)
+        .map_err(|_| RusticolError::artifact(format!("{context} count exceeds usize")))?;
+    let byte_count = count
+        .checked_mul(4)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} byte size overflows")))?;
+    let end = cursor
+        .checked_add(byte_count)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} range overflows")))?;
+    let payload = bytes
+        .get(*cursor..end)
+        .ok_or_else(|| RusticolError::artifact(format!("truncated {context}")))?;
+    *cursor = end;
+    payload
+        .chunks_exact(4)
+        .map(|raw| {
+            raw.try_into()
+                .map(i32::from_le_bytes)
+                .map_err(|_| RusticolError::artifact(format!("truncated {context}")))
+        })
+        .collect()
+}
+
+fn read_u64_values(
+    bytes: &[u8],
+    cursor: &mut usize,
+    count: u32,
+    context: &str,
+) -> RusticolResult<Vec<u64>> {
+    let count = usize::try_from(count)
+        .map_err(|_| RusticolError::artifact(format!("{context} count exceeds usize")))?;
+    let byte_count = count
+        .checked_mul(8)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} byte size overflows")))?;
+    let end = cursor
+        .checked_add(byte_count)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} range overflows")))?;
+    let payload = bytes
+        .get(*cursor..end)
+        .ok_or_else(|| RusticolError::artifact(format!("truncated {context}")))?;
+    *cursor = end;
+    payload
+        .chunks_exact(8)
+        .map(|raw| {
+            raw.try_into()
+                .map(u64::from_le_bytes)
+                .map_err(|_| RusticolError::artifact(format!("truncated {context}")))
+        })
+        .collect()
+}
+
+fn apply_process_remap(
+    plan: DirectRecurrencePlan,
+    remap: &RecurrenceProcessRemap,
+) -> RusticolResult<DirectRecurrencePlan> {
+    let source_count = usize::try_from(plan.external_source_count())
+        .map_err(|_| RusticolError::artifact("recurrence source count exceeds usize"))?;
+    let topology_flow_count = match plan.strategy() {
+        crate::recurrence::RecurrenceStrategy::TopologyReplay => Some(plan.replay_targets().len()),
+        crate::recurrence::RecurrenceStrategy::AllFlowUnion
+        | crate::recurrence::RecurrenceStrategy::ContractedColorUnion => None,
+    };
+    if remap.source_slots.len() != source_count
+        || remap.source_momentum_signs.len() != source_count
+        || remap.source_helicity_signs.len() != source_count
+        || topology_flow_count.is_some_and(|flow_count| remap.public_flow_ids.len() != flow_count)
+        || remap.physical_sector_ids.len() != plan.physical_sector_count() as usize
+        || remap.state_templates.count != plan.state_template_count()
+        || remap.source_templates.count != plan.source_template_count()
+        || remap.direct_executors.count != plan.direct_executor_count()
+        || remap.parameter_slots.count != plan.parameter_value_count()
+    {
+        return Err(RusticolError::integrity(
+            "recurrence process remap domain counts disagree with the root schedule",
+        ));
+    }
+    let identity = remap
+        .source_slots
+        .iter()
+        .enumerate()
+        .all(|(index, value)| *value as usize == index)
+        && remap.source_momentum_signs.iter().all(|value| *value == 1)
+        && remap.source_helicity_signs.iter().all(|value| *value == 1)
+        && remap
+            .source_state_offsets
+            .windows(2)
+            .enumerate()
+            .all(|(source_slot, window)| {
+                let start = window[0] as usize;
+                let stop = window[1] as usize;
+                remap.source_state_indices[start..stop]
+                    .iter()
+                    .enumerate()
+                    .all(|(state_index, value)| *value as usize == state_index)
+                    && source_slot < remap.source_slots.len()
+            })
+        && remap
+            .public_flow_ids
+            .iter()
+            .enumerate()
+            .all(|(index, value)| *value as usize == index)
+        && remap
+            .physical_sector_ids
+            .iter()
+            .enumerate()
+            .all(|(index, value)| *value as usize == index)
+        && remap.state_templates.changes.is_empty()
+        && remap.source_templates.changes.is_empty()
+        && remap.direct_executors.changes.is_empty()
+        && remap.parameter_slots.changes.is_empty();
+    if identity {
+        return Ok(plan);
+    }
+    if plan.strategy() != crate::recurrence::RecurrenceStrategy::TopologyReplay {
+        return Err(RusticolError::compatibility(
+            "cross-process recurrence sharing currently supports topology-replay schedules only",
+        ));
+    }
+    if !remap.parameter_slots.changes.is_empty() {
+        return Err(RusticolError::compatibility(
+            "cross-process recurrence sharing does not support prepared-parameter reordering",
+        ));
+    }
+
+    let mut parts = plan.into_parts();
+    for current in &mut parts.currents {
+        current.state_template_id =
+            sparse_bijection_value(&remap.state_templates, current.state_template_id)?;
+    }
+    for source in &mut parts.sources {
+        source.source_slot = *remap
+            .source_slots
+            .get(source.source_slot as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "recurrence source row is outside the process source remap",
+                )
+            })?;
+        source.source_template_or_dispatch_domain = sparse_bijection_value(
+            &remap.source_templates,
+            source.source_template_or_dispatch_domain,
+        )?;
+    }
+    for group in &mut parts.row_groups {
+        group.direct_executor_id =
+            sparse_bijection_value(&remap.direct_executors, group.direct_executor_id)?;
+    }
+    for target in &mut parts.replay_targets {
+        target.public_flow_id = *remap
+            .public_flow_ids
+            .get(target.public_flow_id as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "recurrence replay target is outside the public-flow remap",
+                )
+            })?;
+        let start = usize::try_from(target.source_permutation_start).map_err(|_| {
+            RusticolError::artifact("recurrence replay permutation offset exceeds usize")
+        })?;
+        let stop = start
+            .checked_add(target.source_permutation_count as usize)
+            .ok_or_else(|| {
+                RusticolError::artifact("recurrence replay permutation range overflows")
+            })?;
+        let permutations = parts
+            .source_permutations
+            .get_mut(start..stop)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "recurrence replay permutation is outside the root schedule",
+                )
+            })?;
+        let momentum_signs = parts
+            .replay_momentum_signs
+            .get_mut(start..stop)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "recurrence replay momentum signs are outside the root schedule",
+                )
+            })?;
+        for (source_slot, momentum_sign) in permutations.iter_mut().zip(momentum_signs.iter_mut()) {
+            let root_slot = *source_slot as usize;
+            *source_slot = *remap.source_slots.get(root_slot).ok_or_else(|| {
+                RusticolError::integrity("recurrence replay source is outside the process remap")
+            })?;
+            *momentum_sign = momentum_sign
+                .checked_mul(*remap.source_momentum_signs.get(root_slot).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "recurrence replay source has no process momentum sign",
+                    )
+                })?)
+                .ok_or_else(|| {
+                    RusticolError::integrity("recurrence replay momentum sign overflows")
+                })?;
+        }
+    }
+    for descriptor in &parts.resolved_helicities {
+        let start = usize::try_from(descriptor.public_helicity_start).map_err(|_| {
+            RusticolError::artifact("recurrence public-helicity offset exceeds usize")
+        })?;
+        let stop = start
+            .checked_add(descriptor.public_helicity_count as usize)
+            .ok_or_else(|| RusticolError::artifact("recurrence public-helicity range overflows"))?;
+        let source = parts
+            .public_helicities
+            .get(start..stop)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "recurrence public-helicity vector is outside the root schedule",
+                )
+            })?
+            .to_vec();
+        if source.len() != source_count {
+            return Err(RusticolError::integrity(
+                "recurrence public-helicity width disagrees with the process remap",
+            ));
+        }
+        let target = parts
+            .public_helicities
+            .get_mut(start..stop)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "recurrence public-helicity vector is outside the root schedule",
+                )
+            })?;
+        for (root_slot, value) in source.into_iter().enumerate() {
+            let target_slot = remap.source_slots[root_slot] as usize;
+            target[target_slot] = value
+                .checked_mul(remap.source_helicity_signs[root_slot])
+                .ok_or_else(|| RusticolError::integrity("recurrence public helicity overflows"))?;
+        }
+    }
+    for descriptor in &parts.resolved_helicities {
+        let start = usize::try_from(descriptor.source_state_start).map_err(|_| {
+            RusticolError::artifact("recurrence source-state assignment offset exceeds usize")
+        })?;
+        let stop = start
+            .checked_add(descriptor.source_state_count as usize)
+            .ok_or_else(|| {
+                RusticolError::artifact("recurrence source-state assignment range overflows")
+            })?;
+        let source = parts
+            .source_state_assignments
+            .get(start..stop)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "recurrence source-state assignment range is outside the root schedule",
+                )
+            })?
+            .to_vec();
+        if source.len() != source_count {
+            return Err(RusticolError::integrity(
+                "recurrence source-state assignment width disagrees with the process remap",
+            ));
+        }
+        let target = parts
+            .source_state_assignments
+            .get_mut(start..stop)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "recurrence source-state assignment range is outside the root schedule",
+                )
+            })?;
+        for assignment in source {
+            let target_slot = *remap
+                .source_slots
+                .get(assignment.source_slot as usize)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "recurrence source-state assignment is outside the process remap",
+                    )
+                })?;
+            let state_start = *remap
+                .source_state_offsets
+                .get(assignment.source_slot as usize)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "recurrence source-state assignment has no remap offset",
+                    )
+                })? as usize;
+            let state_stop = *remap
+                .source_state_offsets
+                .get(assignment.source_slot as usize + 1)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "recurrence source-state assignment has no remap limit",
+                    )
+                })? as usize;
+            let target_state_index = *remap
+                .source_state_indices
+                .get(state_start..state_stop)
+                .and_then(|values| values.get(assignment.state_index as usize))
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "recurrence source-state assignment is outside its state remap",
+                    )
+                })?;
+            target[target_slot as usize] = crate::recurrence::DirectSourceStateAssignment {
+                source_slot: target_slot,
+                state_index: target_state_index,
+            };
+        }
+    }
+    DirectRecurrencePlan::new(parts)
+}
+
+fn sparse_bijection_value(mapping: &RecurrenceSparseBijection, value: u32) -> RusticolResult<u32> {
+    if value >= mapping.count {
+        return Err(RusticolError::integrity(
+            "recurrence process remap input is outside its domain",
+        ));
+    }
+    Ok(mapping
+        .changes
+        .binary_search_by_key(&value, |change| change[0])
+        .map(|index| mapping.changes[index][1])
+        .unwrap_or(value))
+}
+
+type RecurrenceCommonRuntimeParts = (
+    ExecutionRuntime,
+    Vec<crate::EagerComplex64>,
+    Vec<PreparedParameterProjectionEntry>,
+    Vec<DirectSourceDispatchDomainSpec>,
+);
+
+fn recurrence_runtime_parameters(
+    metadata: &RecurrenceRuntimeMetadata,
+) -> Vec<GenericRuntimeModelParameterManifest> {
+    recurrence_runtime_parameters_from(&metadata.runtime_parameters)
+}
+
+fn recurrence_runtime_parameters_from(
+    parameters: &[RecurrenceRuntimeParameter],
+) -> Vec<GenericRuntimeModelParameterManifest> {
+    parameters
+        .iter()
+        .map(|parameter| GenericRuntimeModelParameterManifest {
+            name: parameter.name.clone(),
+            kind: parameter.kind.clone(),
+            parameter_index: parameter.parameter_index as usize,
+            default: parameter.default,
+            pdg: None,
+            runtime_name: parameter.runtime_name.clone(),
+            complex_component: parameter.complex_component.clone(),
+        })
+        .collect()
+}
+
+#[derive(Clone, Copy)]
+struct RecurrenceNormalizationValues {
+    factor: f64,
+    color_factor: f64,
+}
+
+fn recurrence_normalization_values(
+    metadata: &RecurrenceRuntimeMetadata,
+) -> RusticolResult<RecurrenceNormalizationValues> {
+    recurrence_normalization_values_from(
+        &metadata.normalization,
+        metadata.color_contraction.as_ref(),
+    )
+}
+
+fn recurrence_normalization_values_from(
+    normalization: &RecurrenceNormalization,
+    color_contraction: Option<&RecurrenceColorContractionReference>,
+) -> RusticolResult<RecurrenceNormalizationValues> {
+    if !normalization.couplings_in_stage_evaluators {
+        return Err(RusticolError::compatibility(
+            "recurrence execution requires local vertex couplings in prepared kernel calls",
+        ));
+    }
+    let color_factor =
+        if color_contraction.is_some_and(|contraction| contraction.includes_color_factor) {
+            1.0
+        } else {
+            normalization.color_factor
+        };
+    let factor = color_factor * normalization.global_coupling_factor
+        / (normalization.average_factor * normalization.identical_factor);
+    if !factor.is_finite() {
+        return Err(RusticolError::integrity(
+            "recurrence runtime normalization is not finite",
+        ));
+    }
+    Ok(RecurrenceNormalizationValues {
+        factor,
+        color_factor,
+    })
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn on_the_fly_prepared_parameters(
+    metadata: &RecurrenceRuntimeMetadata,
+    runtime_parameters: &[GenericRuntimeModelParameterManifest],
+    mut model_parameter_evaluator: Option<ModelParameterEvaluatorRuntime>,
+    overrides: &BTreeMap<String, [f64; 2]>,
+) -> RusticolResult<Vec<[f64; 2]>> {
+    let runtime_slots = runtime_parameter_slots(runtime_parameters)?;
+    let mut runtime_values = runtime_parameters
+        .iter()
+        .map(|parameter| parameter.default)
+        .collect::<Vec<_>>();
+    for value in &runtime_values {
+        if !value.is_finite() {
+            return Err(RusticolError::integrity(
+                "recurrence runtime parameter default is not finite",
+            ));
+        }
+    }
+    for value in &metadata.prepared_parameter_defaults {
+        if !value[0].is_finite() || !value[1].is_finite() {
+            return Err(RusticolError::integrity(
+                "recurrence prepared parameter default is not finite",
+            ));
+        }
+    }
+    for (name, override_value) in overrides {
+        if !override_value[0].is_finite() || !override_value[1].is_finite() {
+            return Err(RusticolError::invalid_argument(format!(
+                "on-the-fly parameter override {name:?} is not finite"
+            )));
+        }
+        if runtime_parameters.iter().any(|parameter| {
+            parameter.kind == "derived_parameter_component"
+                && parameter.runtime_name.as_deref().unwrap_or(&parameter.name) == name
+        }) {
+            return Err(RusticolError::invalid_argument(format!(
+                "derived on-the-fly parameter {name:?} is immutable"
+            )));
+        }
+        let Some(slots) = runtime_slots.get(name).copied() else {
+            return Err(RusticolError::invalid_argument(format!(
+                "on-the-fly parameter override {name:?} is not used by the process"
+            )));
+        };
+        let real = runtime_values.get_mut(slots.real).ok_or_else(|| {
+            RusticolError::integrity("on-the-fly runtime parameter real slot is absent")
+        })?;
+        *real = override_value[0];
+        if let Some(imaginary_slot) = slots.imaginary {
+            let imaginary = runtime_values.get_mut(imaginary_slot).ok_or_else(|| {
+                RusticolError::integrity("on-the-fly runtime parameter imaginary slot is absent")
+            })?;
+            *imaginary = override_value[1];
+        } else if override_value[1] != 0.0 {
+            return Err(RusticolError::invalid_argument(format!(
+                "real on-the-fly parameter {name:?} cannot receive an imaginary value"
+            )));
+        }
+    }
+    super::model_parameters::refresh_derived_model_parameter_values(
+        model_parameter_evaluator.as_mut(),
+        &mut runtime_values,
+    )?;
+
+    let defaults = metadata
+        .prepared_parameter_defaults
+        .iter()
+        .map(|[real, imaginary]| crate::EagerComplex64::new(*real, *imaginary))
+        .collect::<Vec<_>>();
+    let projection = metadata
+        .parameter_projection
+        .iter()
+        .filter_map(|row| {
+            row.prepared_parameter_id
+                .map(|prepared_slot| (row, prepared_slot))
+        })
+        .map(|(row, prepared_slot)| {
+            Ok(PreparedParameterProjectionEntry {
+                runtime_slot: usize::try_from(row.runtime_slot).map_err(|_| {
+                    RusticolError::integrity("on-the-fly runtime parameter slot exceeds usize")
+                })?,
+                prepared_slot: usize::try_from(prepared_slot).map_err(|_| {
+                    RusticolError::integrity("on-the-fly prepared parameter slot exceeds usize")
+                })?,
+                component: u8::try_from(row.component).map_err(|_| {
+                    RusticolError::integrity("on-the-fly parameter component exceeds u8")
+                })?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    projected_prepared_parameter_values(&defaults, &projection, &runtime_values).map(|values| {
+        values
+            .into_iter()
+            .map(|(real, imaginary)| [real, imaginary])
+            .collect()
+    })
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+pub(super) fn on_the_fly_source_major_momenta(
+    seed: &OnTheFlyProcessSeedV1,
+    point_major: &[f64],
+    point_count: u32,
+    lorentz_component_count: u16,
+) -> RusticolResult<Vec<f64>> {
+    let mut source_major = Vec::new();
+    let output_len = on_the_fly_source_major_momenta_into(
+        seed,
+        point_major,
+        point_count,
+        lorentz_component_count,
+        &mut source_major,
+    )?;
+    source_major.truncate(output_len);
+    Ok(source_major)
+}
+
+/// Transpose public point-major momenta into the source-major plane layout
+/// without reallocating once `source_major` has reached the warmed capacity.
+/// The returned length identifies the initialized prefix; callers may retain
+/// a larger backing allocation for later batches.
+pub(super) fn on_the_fly_source_major_momenta_into(
+    seed: &OnTheFlyProcessSeedV1,
+    point_major: &[f64],
+    point_count: u32,
+    lorentz_component_count: u16,
+    source_major: &mut Vec<f64>,
+) -> RusticolResult<usize> {
+    let permutation = seed.external_permutation();
+    let point_count_usize = point_count as usize;
+    let lorentz_count = usize::from(lorentz_component_count);
+    let point_width = permutation
+        .len()
+        .checked_mul(lorentz_count)
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("on-the-fly momentum shape exceeds usize")
+        })?;
+    let expected = point_count_usize.checked_mul(point_width).ok_or_else(|| {
+        RusticolError::invalid_argument("on-the-fly momentum shape exceeds usize")
+    })?;
+    if point_count == 0 || point_major.len() != expected {
+        return Err(RusticolError::invalid_argument(format!(
+            "on-the-fly point-major momenta contain {} scalars, expected {expected}",
+            point_major.len()
+        )));
+    }
+    if source_major.len() < expected {
+        source_major
+            .try_reserve_exact(expected - source_major.len())
+            .map_err(|error| {
+                RusticolError::invalid_argument(format!(
+                    "on-the-fly momentum workspace allocation failed: {error}"
+                ))
+            })?;
+        source_major.resize(expected, 0.0);
+    }
+    for (source_slot, public_slot) in permutation.iter().copied().enumerate() {
+        let public_slot = usize::try_from(public_slot).map_err(|_| {
+            RusticolError::integrity("on-the-fly public momentum slot exceeds usize")
+        })?;
+        if public_slot >= permutation.len() {
+            return Err(RusticolError::integrity(
+                "on-the-fly public momentum slot is out of bounds",
+            ));
+        }
+        for lorentz in 0..lorentz_count {
+            // The checked total shape bounds every plane offset. Walk the
+            // strided input and contiguous destination directly instead of
+            // repeating checked index arithmetic for every scalar.
+            let input_offset = public_slot * lorentz_count + lorentz;
+            let output_offset = (source_slot * lorentz_count + lorentz) * point_count_usize;
+            let output = &mut source_major[output_offset..output_offset + point_count_usize];
+            for (value, source) in output
+                .iter_mut()
+                .zip(point_major[input_offset..].iter().step_by(point_width))
+            {
+                *value = *source;
+            }
+        }
+    }
+    Ok(expected)
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+struct OnTheFlyQueryTraceCacheV1<T> {
+    entries: BTreeMap<SemanticDigest, T>,
+    trace_build_count: u32,
+    trace_cache_hit_count: std::cell::Cell<u32>,
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+impl<T> Default for OnTheFlyQueryTraceCacheV1<T> {
+    fn default() -> Self {
+        Self {
+            entries: BTreeMap::new(),
+            trace_build_count: 0,
+            trace_cache_hit_count: std::cell::Cell::new(0),
+        }
+    }
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+impl<T> OnTheFlyQueryTraceCacheV1<T> {
+    fn insert_built(&mut self, query_digest: SemanticDigest, trace: T) -> RusticolResult<()> {
+        match self.entries.entry(query_digest) {
+            std::collections::btree_map::Entry::Vacant(entry) => {
+                entry.insert(trace);
+            }
+            std::collections::btree_map::Entry::Occupied(_) => {
+                return Err(RusticolError::integrity(
+                    "on-the-fly trace cache repeated a fresh query digest",
+                ));
+            }
+        }
+        self.trace_build_count = self
+            .trace_build_count
+            .checked_add(1)
+            .ok_or_else(|| RusticolError::integrity("on-the-fly trace-build counter overflowed"))?;
+        Ok(())
+    }
+
+    fn prepared(&self, query_digest: SemanticDigest) -> RusticolResult<&T> {
+        self.entries.get(&query_digest).ok_or_else(|| {
+            RusticolError::integrity("fresh on-the-fly trace disappeared from its cache")
+        })
+    }
+
+    fn prepared_mut(&mut self, query_digest: SemanticDigest) -> RusticolResult<&mut T> {
+        self.entries.get_mut(&query_digest).ok_or_else(|| {
+            RusticolError::integrity("fresh on-the-fly trace disappeared from its cache")
+        })
+    }
+
+    fn lookup(&self, query_digest: SemanticDigest) -> RusticolResult<&T> {
+        let trace = self.entries.get(&query_digest).ok_or_else(|| {
+            RusticolError::integrity("on-the-fly benchmark query disappeared from its trace cache")
+        })?;
+        self.trace_cache_hit_count.set(
+            self.trace_cache_hit_count
+                .get()
+                .checked_add(1)
+                .ok_or_else(|| {
+                    RusticolError::integrity("on-the-fly trace-cache-hit counter overflowed")
+                })?,
+        );
+        Ok(trace)
+    }
+
+    fn counts(&self) -> (u32, u32) {
+        (self.trace_build_count, self.trace_cache_hit_count.get())
+    }
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn validate_on_the_fly_probe_outputs(
+    raw_amplitudes: &[[f64; 2]],
+    normalized_values: &[f64],
+) -> RusticolResult<()> {
+    if raw_amplitudes.len() != normalized_values.len() {
+        return Err(RusticolError::integrity(
+            "on-the-fly probe output lengths disagree",
+        ));
+    }
+    for (point, ([real, imaginary], normalized)) in
+        raw_amplitudes.iter().zip(normalized_values).enumerate()
+    {
+        if !real.is_finite() || !imaginary.is_finite() {
+            return Err(RusticolError::evaluation(format!(
+                "on-the-fly probe produced a non-finite raw amplitude at point {point}"
+            )));
+        }
+        if !normalized.is_finite() {
+            return Err(RusticolError::evaluation(format!(
+                "on-the-fly probe produced a non-finite normalized value at point {point}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn validate_on_the_fly_family_execution(
+    census: crate::recurrence::OnTheFlyQueryFamilyCensusV1,
+    report: crate::recurrence::on_the_fly::OnTheFlyQueryFamilyExecutionReportV1,
+    require_cache_hit: bool,
+) -> RusticolResult<()> {
+    if report.cache_hit != require_cache_hit
+        || report.source_calls != census.union_source_executor_call_groups
+        || report.source_rows != census.union_source_rows
+        || report.contribution_calls != census.union_contribution_executor_call_groups
+        || report.contribution_rows != census.union_contribution_rows
+        || report.finalization_calls != census.union_finalization_executor_call_groups
+        || report.finalization_rows != census.union_finalization_rows
+        || report.closure_calls != census.union_closure_executor_call_groups
+        || report.closure_rows != census.union_closure_rows
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly family execution differs from its prepared census/cache state",
+        ));
+    }
+    Ok(())
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[allow(clippy::too_many_arguments)]
+fn execute_on_the_fly_query_family_v1(
+    artifact: &VerifiedArtifact,
+    manifest: &RecurrenceExecutionManifest,
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    direct: &PreparedDirectExecutorCatalog,
+    selected_public_flow_id: u32,
+    public_helicities: &[i32],
+    query_family: &[(u32, Vec<i32>)],
+    point_major_external_momenta: &[f64],
+    point_count: u32,
+    parameter_overrides: &BTreeMap<String, [f64; 2]>,
+    benchmark: bool,
+    benchmark_warmup_repetitions: u32,
+    benchmark_repetitions: u32,
+    enable_color_projection: bool,
+) -> RusticolResult<NativeOnTheFlyArtifactProbeV1> {
+    if query_family.is_empty() {
+        return Err(RusticolError::invalid_argument(
+            "on-the-fly query family must not be empty",
+        ));
+    }
+    if query_family[0].0 != selected_public_flow_id
+        || query_family[0].1.as_slice() != public_helicities
+    {
+        return Err(RusticolError::invalid_argument(
+            "on-the-fly query family must begin with the required single selector",
+        ));
+    }
+    if benchmark && benchmark_warmup_repetitions < 2 {
+        return Err(RusticolError::invalid_argument(
+            "on-the-fly family benchmark requires at least two warmup repetitions",
+        ));
+    }
+
+    let selected_with_seed = query_family
+        .iter()
+        .map(|(flow, helicities)| {
+            build_on_the_fly_selected_trace_v1(
+                authenticated,
+                direct,
+                *flow,
+                helicities,
+                enable_color_projection,
+            )
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let seed = selected_with_seed
+        .first()
+        .ok_or_else(|| RusticolError::integrity("on-the-fly family compact seed is absent"))?
+        .seed
+        .clone();
+    let seed_digest = seed.semantic_digest();
+    let mut selected = selected_with_seed
+        .into_iter()
+        .map(|selected| {
+            if selected.seed.semantic_digest() != seed_digest
+                || selected.query.process_seed_digest() != seed_digest
+                || selected.trace.seed_digest() != seed_digest
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly query family does not share one compact process identity",
+                ));
+            }
+            Ok(OnTheFlySelectedQueryTraceV1 {
+                query: selected.query,
+                trace: selected.trace,
+                projection: selected.projection,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let (pack_json, pack, payload_root) = load_prepared_pack(artifact, manifest)?;
+    let payloads = artifact.evaluator_payload_store(&payload_root)?;
+    let runtime_parameters = recurrence_runtime_parameters(&manifest.runtime_metadata);
+    let model_parameter_evaluator =
+        super::eager_load::load_prepared_model_parameter_evaluator_for_runtime(
+            &pack,
+            &runtime_parameters,
+            &payloads,
+        )?;
+    let pool = NativeRecurrencePreparedExecutorPool::load_from_store(
+        &pack_json,
+        &payloads,
+        &manifest.prepared_kernel_pack_digest,
+        &manifest.direct_template_catalog_digest,
+    )?;
+    let source_domains = build_on_the_fly_source_domains(&seed, authenticated.template())?;
+    let sources = pool.bind_source_domains(source_domains)?;
+    let mut resolver = pool.into_on_the_fly_resolver(sources);
+    resolver.bind_on_the_fly_family(authenticated.template(), direct, &seed, &mut selected)?;
+    let semantic_executor_binding_count = resolver.semantic_executor_binding_count()?;
+    let distinct_prepared_executor_count = resolver.distinct_prepared_executor_count()?;
+    let trace_inputs = selected
+        .iter()
+        .map(|selected| QueryFamilyTraceInput {
+            trace: &selected.trace,
+            projection: selected.projection,
+        })
+        .collect::<Vec<_>>();
+    let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+    let prepare_started = Instant::now();
+    if executor.prepare(direct, &trace_inputs, point_count)? {
+        return Err(RusticolError::integrity(
+            "fresh on-the-fly family executor reported a cold cache hit",
+        ));
+    }
+    let cold_prepare_seconds = profile_duration_seconds(prepare_started.elapsed());
+    let census = executor
+        .prepared_census()
+        .ok_or_else(|| RusticolError::integrity("prepared on-the-fly family census is absent"))?;
+    let prepared_parameters = on_the_fly_prepared_parameters(
+        &manifest.runtime_metadata,
+        &runtime_parameters,
+        model_parameter_evaluator,
+        parameter_overrides,
+    )?
+    .into_iter()
+    .map(|value| (value[0], value[1]))
+    .collect::<Vec<_>>();
+    executor.set_parameters(&prepared_parameters)?;
+    let source_major = on_the_fly_source_major_momenta(
+        &seed,
+        point_major_external_momenta,
+        point_count,
+        selected[0].trace.layout().lorentz_component_count(),
+    )?;
+    let output_len = query_family
+        .len()
+        .checked_mul(point_count as usize)
+        .ok_or_else(|| RusticolError::invalid_argument("on-the-fly family output exceeds usize"))?;
+    let mut outputs = vec![(0.0, 0.0); output_len];
+    let mut execution_count = 0_u32;
+    let mut last_report = None;
+    let benchmark_elapsed_seconds = if benchmark {
+        for warmup in 0..benchmark_warmup_repetitions {
+            let report = executor.execute_into(&source_major, point_count, &mut outputs)?;
+            validate_on_the_fly_family_execution(census, report, warmup != 0)?;
+            execution_count = execution_count.checked_add(1).ok_or_else(|| {
+                RusticolError::integrity("on-the-fly family execution count exceeds u32")
+            })?;
+            last_report = Some(report);
+            std::hint::black_box(&outputs);
+        }
+        let started = Instant::now();
+        for _ in 0..benchmark_repetitions {
+            let report = executor.execute_into(&source_major, point_count, &mut outputs)?;
+            validate_on_the_fly_family_execution(census, report, true)?;
+            execution_count = execution_count.checked_add(1).ok_or_else(|| {
+                RusticolError::integrity("on-the-fly family execution count exceeds u32")
+            })?;
+            last_report = Some(report);
+            std::hint::black_box(&outputs);
+        }
+        Some(profile_duration_seconds(started.elapsed()))
+    } else {
+        let report = executor.execute_into(&source_major, point_count, &mut outputs)?;
+        validate_on_the_fly_family_execution(census, report, false)?;
+        execution_count = 1;
+        last_report = Some(report);
+        None
+    };
+    let report = last_report.ok_or_else(|| {
+        RusticolError::integrity("on-the-fly family produced no execution report")
+    })?;
+    let normalization_factor = recurrence_normalization_values(&manifest.runtime_metadata)?.factor;
+    let mut query_reports = Vec::new();
+    for ((flow, helicities), (selected_query, amplitudes)) in query_family.iter().zip(
+        selected
+            .iter()
+            .zip(outputs.chunks_exact(point_count as usize)),
+    ) {
+        let raw_amplitudes = amplitudes
+            .iter()
+            .map(|&(real, imaginary)| [real, imaginary])
+            .collect::<Vec<_>>();
+        let normalized_values = raw_amplitudes
+            .iter()
+            .map(|[real, imaginary]| {
+                real.mul_add(*real, imaginary * imaginary) * normalization_factor
+            })
+            .collect::<Vec<_>>();
+        validate_on_the_fly_probe_outputs(&raw_amplitudes, &normalized_values)?;
+        query_reports.push(NativeOnTheFlyFamilyQueryProbeV1 {
+            selected_public_flow_id: *flow,
+            public_helicities: helicities.clone(),
+            query_digest: selected_query.query.semantic_digest().to_string(),
+            raw_amplitudes,
+            normalized_values,
+        });
+    }
+    let first = query_reports
+        .first()
+        .ok_or_else(|| RusticolError::integrity("on-the-fly family lost its first query output"))?;
+    let first_raw_amplitudes = first.raw_amplitudes.clone();
+    let first_normalized_values = first.normalized_values.clone();
+    let benchmark_seconds_per_point = benchmark_elapsed_seconds
+        .map(|elapsed| elapsed / (f64::from(benchmark_repetitions) * f64::from(point_count)));
+    let first_selected = &selected[0];
+    Ok(NativeOnTheFlyArtifactProbeV1 {
+        artifact_id: artifact.manifest().artifact_id.clone(),
+        process_id: manifest.key.clone(),
+        seed_digest: seed.semantic_digest().to_string(),
+        query_digest: first_selected.query.semantic_digest().to_string(),
+        trace_digest: first_selected.trace.semantic_digest().to_string(),
+        point_count,
+        raw_amplitudes: first_raw_amplitudes,
+        normalized_values: first_normalized_values,
+        normalization_factor,
+        query_family: Some(NativeOnTheFlyFamilyProbeV1 {
+            queries: query_reports,
+            census,
+            execution_cache_hit: report.cache_hit,
+            execution_source_calls: report.source_calls,
+            execution_source_rows: report.source_rows,
+            execution_contribution_calls: report.contribution_calls,
+            execution_contribution_rows: report.contribution_rows,
+            execution_finalization_calls: report.finalization_calls,
+            execution_finalization_rows: report.finalization_rows,
+            execution_closure_calls: report.closure_calls,
+            execution_closure_rows: report.closure_rows,
+            cold_prepare_seconds,
+            benchmark_warmup_repetitions,
+            benchmark_repetitions,
+            benchmark_elapsed_seconds,
+            benchmark_seconds_per_point,
+        }),
+        currents: Vec::new(),
+        projection_enabled: first_selected.projection.enabled,
+        projection_applied: first_selected.projection.applied,
+        projection_counts: [
+            first_selected.projection.pre,
+            first_selected.projection.post,
+        ],
+        work_census_basis: ON_THE_FLY_FAMILY_WORK_CENSUS_BASIS_V1.to_owned(),
+        logical_current_count: census.union_unique_current_count,
+        resident_current_count: census.union_unique_current_count,
+        resident_current_component_count: census.union_unique_current_component_count,
+        source_operation_count: census.union_source_rows,
+        contribution_operation_count: census.union_contribution_rows,
+        finalization_operation_count: census.union_finalization_rows,
+        closure_operation_count: census.union_closure_rows,
+        total_kernel_application_count: census.union_kernel_application_count()?,
+        semantic_executor_binding_count,
+        distinct_prepared_executor_count,
+        trace_build_count: census.query_count,
+        // The prepared family cache is reported by `query_family`; this path
+        // performs no query-trace cache lookup after construction.
+        trace_cache_hit_count: 0,
+        momentum_fill_count: execution_count,
+        benchmark_warmup_repetitions,
+        benchmark_repetitions,
+        benchmark_elapsed_seconds,
+        benchmark_seconds_per_point,
+        direct_plan_load_attempts: 0,
+        direct_plan_decode_attempts: 0,
+        direct_plan_materialization_attempts: 0,
+        established_builder_attempts: 0,
+    })
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+impl NativeRuntime {
+    /// Execute one authenticated selector-local recurrence trace directly from
+    /// a genuine artifact without loading or decoding its DirectPlan.
+    #[doc(hidden)]
+    #[allow(clippy::too_many_arguments)]
+    pub fn on_the_fly_artifact_probe_v1(
+        artifact_path: impl AsRef<Path>,
+        process_id: &str,
+        authenticated: &AuthenticatedRecurrenceBuilderInput,
+        direct: &PreparedDirectExecutorCatalog,
+        selected_public_flow_id: u32,
+        public_helicities: &[i32],
+        point_major_external_momenta: &[f64],
+        point_count: u32,
+        parameter_overrides: &BTreeMap<String, [f64; 2]>,
+        tamper_executor_key: bool,
+        benchmark: bool,
+        benchmark_warmup_repetitions: u32,
+        benchmark_repetitions: u32,
+        collect_current_diagnostics: bool,
+        enable_color_projection: bool,
+        query_family: Option<&[(u32, Vec<i32>)]>,
+    ) -> RusticolResult<NativeOnTheFlyArtifactProbeV1> {
+        if benchmark && benchmark_repetitions == 0 {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly benchmark requires at least one timed repetition",
+            ));
+        }
+        if !benchmark && (benchmark_warmup_repetitions != 0 || benchmark_repetitions != 0) {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly benchmark repetitions require benchmark=true",
+            ));
+        }
+        if query_family.is_some() && collect_current_diagnostics {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly family probing does not collect per-current diagnostics",
+            ));
+        }
+        if query_family.is_some() && tamper_executor_key {
+            return Err(RusticolError::invalid_argument(
+                "on-the-fly family probing does not support executor-key tampering",
+            ));
+        }
+        let guard = OnTheFlyForbiddenWorkGuardV1::begin()?;
+        let result = (|| {
+            let artifact = VerifiedArtifact::open(artifact_path)?;
+            let selection = artifact.select_process(Some(process_id))?;
+            if selection.remaps_public_process() {
+                return Err(RusticolError::invalid_argument(
+                    "on-the-fly artifact probing requires a representative process ID",
+                ));
+            }
+            let (loaded, _evaluator_root) = load_verified_evaluator(&artifact, &selection)?;
+            let physics_bytes = artifact.read_payload(&selection.process.physics_path)?;
+            let physics =
+                ProcessPhysicsV1::from_json(&physics_bytes, &selection.process.physics_path)?;
+            if physics.process_id != selection.process.id
+                || physics.process != selection.process.expression
+                || physics.color_accuracy.as_str() != selection.process.color_accuracy
+                || physics
+                    .external_particles
+                    .iter()
+                    .map(|particle| particle.pdg)
+                    .ne(selection.process.external_pdgs.iter().copied())
+            {
+                return Err(RusticolError::integrity(format!(
+                    "runtime physics payload {:?} does not match process {:?}",
+                    selection.process.physics_path, selection.process.id
+                )));
+            }
+            let manifest = match loaded {
+                LoadedExecutionManifest::Recurrence(manifest) => manifest,
+                LoadedExecutionManifest::Compiled(_)
+                | LoadedExecutionManifest::EagerV3(_)
+                | LoadedExecutionManifest::OnTheFly(_) => {
+                    return Err(RusticolError::compatibility(
+                        "on-the-fly artifact probing requires a recurrence artifact",
+                    ));
+                }
+            };
+            if authenticated
+                .process()
+                .semantic_identity()
+                .input_digest()
+                .to_string()
+                != manifest.plan.builder_input_sha256
+                || direct.direct_template_catalog_digest().to_string()
+                    != manifest.direct_template_catalog_digest
+                || authenticated
+                    .template()
+                    .summary()
+                    .prepared_kernel_pack_digest
+                    .to_string()
+                    != manifest.prepared_kernel_pack_digest
+            {
+                return Err(RusticolError::integrity(
+                    "retained on-the-fly canonical inputs do not belong to the selected artifact",
+                ));
+            }
+
+            if let Some(query_family) = query_family {
+                return execute_on_the_fly_query_family_v1(
+                    &artifact,
+                    &manifest,
+                    authenticated,
+                    direct,
+                    selected_public_flow_id,
+                    public_helicities,
+                    query_family,
+                    point_major_external_momenta,
+                    point_count,
+                    parameter_overrides,
+                    benchmark,
+                    benchmark_warmup_repetitions,
+                    benchmark_repetitions,
+                    enable_color_projection,
+                );
+            }
+
+            let mut trace_cache = OnTheFlyQueryTraceCacheV1::default();
+            let selected = build_on_the_fly_selected_trace_v1(
+                authenticated,
+                direct,
+                selected_public_flow_id,
+                public_helicities,
+                enable_color_projection,
+            )?;
+            let query_digest = selected.query.semantic_digest();
+            trace_cache.insert_built(query_digest, selected)?;
+            if tamper_executor_key {
+                trace_cache
+                    .prepared_mut(query_digest)?
+                    .trace
+                    .tamper_first_prepared_executor_key_for_probe()?;
+            }
+            let (pack_json, pack, payload_root) = load_prepared_pack(&artifact, &manifest)?;
+            let payloads = artifact.evaluator_payload_store(&payload_root)?;
+            let runtime_parameters = recurrence_runtime_parameters(&manifest.runtime_metadata);
+            let model_parameter_evaluator =
+                super::eager_load::load_prepared_model_parameter_evaluator_for_runtime(
+                    &pack,
+                    &runtime_parameters,
+                    &payloads,
+                )?;
+            let pool = NativeRecurrencePreparedExecutorPool::load_from_store(
+                &pack_json,
+                &payloads,
+                &manifest.prepared_kernel_pack_digest,
+                &manifest.direct_template_catalog_digest,
+            )?;
+            let selected = trace_cache.prepared(query_digest)?;
+            let source_domains =
+                build_on_the_fly_source_domains(&selected.seed, authenticated.template())?;
+            let sources = pool.bind_source_domains(source_domains)?;
+            let mut resolver = pool.into_on_the_fly_resolver(sources);
+            {
+                let selected = trace_cache.prepared_mut(query_digest)?;
+                resolver.bind_on_the_fly_trace(
+                    authenticated.template(),
+                    direct,
+                    &selected.seed,
+                    &mut selected.trace,
+                )?;
+            }
+            let selected = trace_cache.prepared(query_digest)?;
+            let work_census = selected.trace.execution_work_census()?;
+            let semantic_executor_binding_count = resolver.semantic_executor_binding_count()?;
+            let distinct_prepared_executor_count = resolver.distinct_prepared_executor_count()?;
+            let mut workspace = OnTheFlyWorkspaceV1::new(&selected.trace, point_count)?;
+            for (parameter_id, value) in on_the_fly_prepared_parameters(
+                &manifest.runtime_metadata,
+                &runtime_parameters,
+                model_parameter_evaluator,
+                parameter_overrides,
+            )?
+            .into_iter()
+            .enumerate()
+            {
+                workspace.set_parameter(
+                    u32::try_from(parameter_id).map_err(|_| {
+                        RusticolError::artifact("on-the-fly prepared parameter count exceeds u32")
+                    })?,
+                    value[0],
+                    value[1],
+                )?;
+            }
+            let source_major = on_the_fly_source_major_momenta(
+                &selected.seed,
+                point_major_external_momenta,
+                point_count,
+                selected.trace.layout().lorentz_component_count(),
+            )?;
+            let mut momentum_fill_count = 0_u32;
+            let benchmark_elapsed_seconds = if !benchmark {
+                workspace.fill_momenta_from_external(
+                    &selected.trace,
+                    &source_major,
+                    point_count,
+                )?;
+                momentum_fill_count = 1;
+                OnTheFlyStructuralInterpreter::execute(
+                    &selected.trace,
+                    &resolver,
+                    &mut workspace,
+                    point_count,
+                )?;
+                None
+            } else {
+                for _ in 0..benchmark_warmup_repetitions {
+                    let cached = trace_cache.lookup(std::hint::black_box(query_digest))?;
+                    workspace.fill_momenta_from_external(
+                        &cached.trace,
+                        &source_major,
+                        point_count,
+                    )?;
+                    momentum_fill_count = momentum_fill_count.checked_add(1).ok_or_else(|| {
+                        RusticolError::integrity("on-the-fly momentum-fill counter overflowed")
+                    })?;
+                    OnTheFlyStructuralInterpreter::execute(
+                        &cached.trace,
+                        &resolver,
+                        &mut workspace,
+                        point_count,
+                    )?;
+                    std::hint::black_box(workspace.amplitude(0)?);
+                }
+                let started = Instant::now();
+                for _ in 0..benchmark_repetitions {
+                    let cached = trace_cache.lookup(std::hint::black_box(query_digest))?;
+                    workspace.fill_momenta_from_external(
+                        &cached.trace,
+                        &source_major,
+                        point_count,
+                    )?;
+                    momentum_fill_count = momentum_fill_count.checked_add(1).ok_or_else(|| {
+                        RusticolError::integrity("on-the-fly momentum-fill counter overflowed")
+                    })?;
+                    OnTheFlyStructuralInterpreter::execute(
+                        &cached.trace,
+                        &resolver,
+                        &mut workspace,
+                        point_count,
+                    )?;
+                    std::hint::black_box(workspace.amplitude(0)?);
+                }
+                Some(profile_duration_seconds(started.elapsed()))
+            };
+            let benchmark_seconds_per_point = benchmark_elapsed_seconds.map(|elapsed| {
+                elapsed / (f64::from(benchmark_repetitions) * f64::from(point_count))
+            });
+            let (trace_build_count, trace_cache_hit_count) = trace_cache.counts();
+
+            let raw_amplitudes = (0..point_count)
+                .map(|point| workspace.amplitude(point).map(|(real, imag)| [real, imag]))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let normalization_factor =
+                recurrence_normalization_values(&manifest.runtime_metadata)?.factor;
+            let normalized_values: Vec<f64> = raw_amplitudes
+                .iter()
+                .map(|[real, imaginary]| {
+                    (real.mul_add(*real, imaginary * imaginary)) * normalization_factor
+                })
+                .collect();
+            validate_on_the_fly_probe_outputs(&raw_amplitudes, &normalized_values)?;
+            let current_count = selected.trace.proof().current_count();
+            let currents = if collect_current_diagnostics {
+                (0..current_count)
+                    .map(|current_id| {
+                        let [_, component_count] =
+                            selected.trace.current_component_range(current_id)?;
+                        let mut values =
+                            Vec::with_capacity(point_count as usize * component_count as usize);
+                        for point in 0..point_count {
+                            values.extend(
+                                workspace
+                                    .observed_current_components(
+                                        &selected.trace,
+                                        current_id,
+                                        point,
+                                    )?
+                                    .into_iter()
+                                    .map(|(real, imaginary)| [real, imaginary]),
+                            );
+                        }
+                        Ok(NativeOnTheFlyCurrentProbeV1 {
+                            semantic_digest: selected
+                                .trace
+                                .current_semantic_digest(current_id)?
+                                .to_string(),
+                            component_count,
+                            values,
+                        })
+                    })
+                    .collect::<RusticolResult<Vec<_>>>()?
+            } else {
+                Vec::new()
+            };
+
+            Ok(NativeOnTheFlyArtifactProbeV1 {
+                artifact_id: artifact.manifest().artifact_id.clone(),
+                process_id: manifest.key.clone(),
+                seed_digest: selected.seed.semantic_digest().to_string(),
+                query_digest: selected.query.semantic_digest().to_string(),
+                trace_digest: selected.trace.semantic_digest().to_string(),
+                point_count,
+                raw_amplitudes,
+                normalized_values,
+                query_family: None,
+                normalization_factor,
+                currents,
+                projection_enabled: selected.projection.enabled,
+                projection_applied: selected.projection.applied,
+                projection_counts: [selected.projection.pre, selected.projection.post],
+                work_census_basis: ON_THE_FLY_WORK_CENSUS_BASIS_V1.to_owned(),
+                logical_current_count: work_census.logical_current_count,
+                resident_current_count: work_census.resident_current_count,
+                resident_current_component_count: work_census.resident_current_component_count,
+                source_operation_count: work_census.source_operation_count,
+                contribution_operation_count: work_census.contribution_operation_count,
+                finalization_operation_count: work_census.finalization_operation_count,
+                closure_operation_count: work_census.closure_operation_count,
+                total_kernel_application_count: work_census.total_kernel_application_count,
+                semantic_executor_binding_count,
+                distinct_prepared_executor_count,
+                trace_build_count,
+                trace_cache_hit_count,
+                momentum_fill_count,
+                benchmark_warmup_repetitions,
+                benchmark_repetitions,
+                benchmark_elapsed_seconds,
+                benchmark_seconds_per_point,
+                direct_plan_load_attempts: 0,
+                direct_plan_decode_attempts: 0,
+                direct_plan_materialization_attempts: 0,
+                established_builder_attempts: 0,
+            })
+        })();
+        let counts = guard.finish()?;
+        let mut report = result?;
+        report.direct_plan_load_attempts = counts.direct_plan_load_attempts;
+        report.direct_plan_decode_attempts = counts.direct_plan_decode_attempts;
+        report.direct_plan_materialization_attempts = counts.direct_plan_materialization_attempts;
+        report.established_builder_attempts = counts.established_builder_attempts;
+        if report.direct_plan_load_attempts != 0
+            || report.direct_plan_decode_attempts != 0
+            || report.direct_plan_materialization_attempts != 0
+            || report.established_builder_attempts != 0
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly artifact probe observed forbidden global work",
+            ));
+        }
+        Ok(report)
+    }
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn direct_public_helicity_id(
+    plan: &DirectRecurrencePlan,
+    public_helicities: &[i32],
+) -> RusticolResult<u32> {
+    let mut matched = None;
+    for descriptor in plan.resolved_helicities() {
+        let start = usize::try_from(descriptor.public_helicity_start)
+            .map_err(|_| RusticolError::integrity("direct public-helicity start exceeds usize"))?;
+        let end = start
+            .checked_add(descriptor.public_helicity_count as usize)
+            .ok_or_else(|| RusticolError::integrity("direct public-helicity range overflows"))?;
+        if plan.public_helicities().get(start..end) == Some(public_helicities) {
+            if matched.replace(descriptor.id).is_some() {
+                return Err(RusticolError::integrity(
+                    "direct plan repeats the requested public helicity",
+                ));
+            }
+        }
+    }
+    matched.ok_or_else(|| {
+        RusticolError::invalid_argument(
+            "requested public helicities are absent from the recurrence comparator",
+        )
+    })
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+fn invert_replay_helicity_map(
+    public_flow_id: u32,
+    helicity_map: &[u32],
+    public_direct_helicity_id: u32,
+) -> RusticolResult<u32> {
+    let matches = helicity_map
+        .iter()
+        .copied()
+        .enumerate()
+        .filter(|(_, mapped)| *mapped == public_direct_helicity_id)
+        .map(|(representative, _)| representative)
+        .collect::<Vec<_>>();
+    let [representative] = matches.as_slice() else {
+        return Err(RusticolError::integrity(format!(
+            "replay flow {} maps {} representative helicities to public helicity {}",
+            public_flow_id,
+            matches.len(),
+            public_direct_helicity_id,
+        )));
+    };
+    u32::try_from(*representative)
+        .map_err(|_| RusticolError::integrity("representative helicity ID exceeds u32"))
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn representative_direct_helicity_id(
+    selector: &DirectReplaySelectorPlan,
+    public_direct_helicity_id: u32,
+) -> RusticolResult<u32> {
+    invert_replay_helicity_map(
+        selector.public_flow_id(),
+        selector.helicity_map(),
+        public_direct_helicity_id,
+    )
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn direct_representative_source_states(
+    plan: &DirectRecurrencePlan,
+    representative_helicity_id: u32,
+) -> RusticolResult<BTreeMap<u32, u32>> {
+    let descriptor = plan
+        .resolved_helicities()
+        .get(representative_helicity_id as usize)
+        .filter(|descriptor| descriptor.id == representative_helicity_id)
+        .ok_or_else(|| RusticolError::integrity("representative helicity is absent"))?;
+    let start = usize::try_from(descriptor.source_state_start)
+        .map_err(|_| RusticolError::integrity("source-state start exceeds usize"))?;
+    let end = start
+        .checked_add(descriptor.source_state_count as usize)
+        .ok_or_else(|| RusticolError::integrity("source-state range overflows usize"))?;
+    plan.source_state_assignments()
+        .get(start..end)
+        .ok_or_else(|| RusticolError::integrity("source-state range is absent"))?
+        .iter()
+        .map(|assignment| Ok((assignment.source_slot, assignment.state_index)))
+        .collect()
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn current_belongs_to_representative_helicity(
+    current: &crate::recurrence::RecurrenceCurrent,
+    source_states: &BTreeMap<u32, u32>,
+) -> bool {
+    current
+        .key()
+        .helicity_identity()
+        .local_source_states()
+        .iter()
+        .all(|assignment| {
+            source_states.get(&assignment.source_slot()) == Some(&assignment.state_index())
+        })
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn diagnostic_complex_scale(value: (f64, f64), scale: (f64, f64)) -> (f64, f64) {
+    (
+        value.0 * scale.0 - value.1 * scale.1,
+        value.0 * scale.1 + value.1 * scale.0,
+    )
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+impl NativeRuntime {
+    /// Compare point zero from a genuine compact artifact with a separately
+    /// authenticated recurrence artifact. Neither artifact is treated as a
+    /// carrier for the other's execution payload.
+    #[doc(hidden)]
+    #[allow(clippy::too_many_arguments)]
+    pub fn on_the_fly_execution_diagnostic_v1(
+        on_the_fly_artifact_path: impl AsRef<Path>,
+        on_the_fly_process_id: &str,
+        recurrence_artifact_path: impl AsRef<Path>,
+        recurrence_process_id: &str,
+        authenticated: &AuthenticatedRecurrenceBuilderInput,
+        retained_direct: &PreparedDirectExecutorCatalog,
+        selected_public_flow_id: u32,
+        public_helicities: &[i32],
+        point_major_external_momenta: &[f64],
+        parameter_overrides: &BTreeMap<String, [f64; 2]>,
+    ) -> RusticolResult<NativeOnTheFlyExecutionDiagnosticV1> {
+        let on_the_fly_artifact = VerifiedArtifact::open(on_the_fly_artifact_path)?;
+        let on_the_fly_selection =
+            on_the_fly_artifact.select_process(Some(on_the_fly_process_id))?;
+        if on_the_fly_selection.remaps_public_process() {
+            return Err(RusticolError::invalid_argument(
+                "execution diagnostics require a representative on-the-fly process ID",
+            ));
+        }
+        let (loaded_on_the_fly, on_the_fly_evaluator_root) =
+            load_verified_evaluator(&on_the_fly_artifact, &on_the_fly_selection)?;
+        let on_the_fly_manifest = match loaded_on_the_fly {
+            LoadedExecutionManifest::OnTheFly(manifest) => manifest,
+            _ => {
+                return Err(RusticolError::compatibility(
+                    "execution diagnostic artifact A must be a genuine on-the-fly artifact",
+                ));
+            }
+        };
+        let loaded_on_the_fly = super::on_the_fly_load::load_on_the_fly_native_runtime(
+            &on_the_fly_artifact,
+            &on_the_fly_evaluator_root,
+            &on_the_fly_manifest,
+            &on_the_fly_selection,
+        )?;
+        let super::on_the_fly_load::LoadedOnTheFlyRuntime {
+            common: mut on_the_fly_common,
+            lane: mut on_the_fly_lane,
+            selectors: _,
+            metadata_selectors: _,
+            public_metadata: _,
+            color_contraction: _,
+        } = loaded_on_the_fly;
+
+        let seed = on_the_fly_lane.seed();
+        let retained_summary = authenticated.template().summary();
+        if seed.process_digest() != authenticated.process().semantic_identity().process_digest()
+            || seed.model_digest() != retained_summary.compiled_model_digest
+            || seed.template_catalog_digest() != retained_summary.catalog_digest
+            || seed.prepared_pack_digest() != retained_summary.prepared_kernel_pack_digest
+            || seed.direct_catalog_digest() != retained_direct.direct_template_catalog_digest()
+        {
+            return Err(RusticolError::integrity(
+                "retained diagnostic inputs do not belong to on-the-fly artifact A",
+            ));
+        }
+        let on_the_fly_seed_model_digest = seed.model_digest();
+        let on_the_fly_seed_template_digest = seed.template_catalog_digest();
+        let on_the_fly_seed_pack_digest = seed.prepared_pack_digest();
+        let on_the_fly_seed_direct_digest = seed.direct_catalog_digest();
+
+        let overrides = parameter_overrides
+            .iter()
+            .map(|(name, value)| (name.clone(), (value[0], value[1])))
+            .collect::<BTreeMap<_, _>>();
+        on_the_fly_common.apply_model_parameter_overrides(&overrides)?;
+        let on_the_fly_snapshot = on_the_fly_lane.execution_diagnostic_v1(
+            authenticated,
+            selected_public_flow_id,
+            public_helicities,
+            point_major_external_momenta,
+            &on_the_fly_common.model_parameter_values_f64,
+        )?;
+
+        // The compact probe guard is deliberately not active here: artifact B
+        // is an independent recurrence comparator whose DirectPlan must load.
+        let recurrence_artifact = VerifiedArtifact::open(recurrence_artifact_path)?;
+        let recurrence_selection =
+            recurrence_artifact.select_process(Some(recurrence_process_id))?;
+        if recurrence_selection.remaps_public_process() {
+            return Err(RusticolError::invalid_argument(
+                "execution diagnostics require a representative recurrence process ID",
+            ));
+        }
+        let (loaded_recurrence, recurrence_evaluator_root) =
+            load_verified_evaluator(&recurrence_artifact, &recurrence_selection)?;
+        let recurrence_manifest = match loaded_recurrence {
+            LoadedExecutionManifest::Recurrence(manifest) => manifest,
+            _ => {
+                return Err(RusticolError::compatibility(
+                    "execution diagnostic artifact B must be a recurrence artifact",
+                ));
+            }
+        };
+        if on_the_fly_selection.process.expression != recurrence_selection.process.expression
+            || on_the_fly_selection.process.external_pdgs
+                != recurrence_selection.process.external_pdgs
+            || on_the_fly_selection.process.color_accuracy
+                != recurrence_selection.process.color_accuracy
+            || recurrence_manifest.plan.builder_input_sha256
+                != authenticated
+                    .process()
+                    .semantic_identity()
+                    .input_digest()
+                    .to_string()
+            || recurrence_manifest.prepared_kernel_pack_digest
+                != on_the_fly_seed_pack_digest.to_string()
+            || recurrence_manifest.direct_template_catalog_digest
+                != on_the_fly_seed_direct_digest.to_string()
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly artifact A, recurrence artifact B, and retained inputs have different identities",
+            ));
+        }
+
+        let plan = load_plan(
+            &recurrence_artifact,
+            &recurrence_evaluator_root,
+            &recurrence_manifest,
+        )?
+        .plan;
+        let (recurrence_pack_bytes, mut recurrence_pack, recurrence_payload_root) =
+            load_prepared_pack(&recurrence_artifact, &recurrence_manifest)?;
+        drop(recurrence_pack_bytes);
+        let recurrence_direct_manifest = recurrence_pack.recurrence_direct_template_catalog(
+            &recurrence_manifest.prepared_kernel_pack_digest,
+            &recurrence_manifest.direct_template_catalog_digest,
+        )?;
+        if recurrence_direct_manifest.compiled_model_digest
+            != on_the_fly_seed_model_digest.to_string()
+            || recurrence_direct_manifest.recurrence_template_catalog_digest
+                != on_the_fly_seed_template_digest.to_string()
+        {
+            return Err(RusticolError::integrity(
+                "artifact A and comparator B use different model/template catalogs",
+            ));
+        }
+        let recurrence_payloads =
+            recurrence_artifact.evaluator_payload_store(&recurrence_payload_root)?;
+        let recurrence_runtime_parameters =
+            recurrence_runtime_parameters(&recurrence_manifest.runtime_metadata);
+        let recurrence_parameter_evaluator =
+            super::eager_load::load_prepared_model_parameter_evaluator_for_runtime(
+                &recurrence_pack,
+                &recurrence_runtime_parameters,
+                &recurrence_payloads,
+            )?;
+        let recurrence_prepared_parameters = on_the_fly_prepared_parameters(
+            &recurrence_manifest.runtime_metadata,
+            &recurrence_runtime_parameters,
+            recurrence_parameter_evaluator,
+            parameter_overrides,
+        )?;
+        if recurrence_prepared_parameters.len() != on_the_fly_snapshot.prepared_parameters.len()
+            || recurrence_prepared_parameters
+                .iter()
+                .zip(&on_the_fly_snapshot.prepared_parameters)
+                .any(|(recurrence, on_the_fly)| {
+                    recurrence[0].to_bits() != on_the_fly.0.to_bits()
+                        || recurrence[1].to_bits() != on_the_fly.1.to_bits()
+                })
+        {
+            return Err(RusticolError::integrity(
+                "artifacts A and B prepared different parameter vectors",
+            ));
+        }
+
+        let recurrence_runtime_slots = runtime_parameter_slots(&recurrence_runtime_parameters)?;
+        let source_domains = build_direct_source_domains(
+            &plan,
+            &recurrence_manifest.runtime_metadata,
+            &recurrence_runtime_slots,
+        )?;
+        let backend = NativeRecurrenceDirectExecutorBackend::load_from_verified_artifact(
+            &mut recurrence_pack,
+            &recurrence_artifact,
+            &recurrence_payload_root,
+            &plan,
+            &recurrence_manifest.prepared_kernel_pack_digest,
+            &recurrence_manifest.direct_template_catalog_digest,
+            source_domains,
+        )?;
+        let (executors, _backend_owners) = backend.into_parts();
+        let mut direct_runtime = DirectRecurrenceExecutionRuntime::new(plan.clone(), executors, 4)?;
+        let parameter_re = on_the_fly_snapshot
+            .prepared_parameters
+            .iter()
+            .map(|value| value.0)
+            .collect::<Vec<_>>();
+        let parameter_im = on_the_fly_snapshot
+            .prepared_parameters
+            .iter()
+            .map(|value| value.1)
+            .collect::<Vec<_>>();
+        direct_runtime.set_parameters(&parameter_re, &parameter_im)?;
+        let selector = direct_runtime.prepare_replay_selector(selected_public_flow_id)?;
+        let public_direct_helicity_id = direct_public_helicity_id(&plan, public_helicities)?;
+        let representative_direct_helicity_id =
+            representative_direct_helicity_id(&selector, public_direct_helicity_id)?;
+        let representative_source_states =
+            direct_representative_source_states(&plan, representative_direct_helicity_id)?;
+        let destination = plan
+            .amplitude_destinations()
+            .iter()
+            .filter(|destination| {
+                destination.target_sector_id == selector.representative_flow_id()
+                    && destination.target_helicity_id_or_sentinel
+                        == representative_direct_helicity_id
+            })
+            .copied()
+            .collect::<Vec<_>>();
+        let [destination] = destination.as_slice() else {
+            return Err(RusticolError::integrity(format!(
+                "selected recurrence lane has {} amplitude destinations, expected one",
+                destination.len(),
+            )));
+        };
+
+        begin_direct_current_observation(
+            direct_runtime.plan(),
+            Some(selector.representative_flow_id()),
+            1,
+        )?;
+        let execution = direct_runtime
+            .execute_replay_tile_from_external_unprofiled(
+                &selector,
+                1,
+                point_major_external_momenta,
+            )
+            .and_then(|output| {
+                Ok((
+                    *output
+                        .destination_re(destination.id)
+                        .and_then(|values| values.first())
+                        .ok_or_else(|| {
+                            RusticolError::integrity(
+                                "selected recurrence public amplitude real value is absent",
+                            )
+                        })?,
+                    *output
+                        .destination_im(destination.id)
+                        .and_then(|values| values.first())
+                        .ok_or_else(|| {
+                            RusticolError::integrity(
+                                "selected recurrence public amplitude imaginary value is absent",
+                            )
+                        })?,
+                ))
+            });
+        let observation = take_direct_current_observation();
+        let recurrence_public_amplitude = execution?;
+        let observation: DirectCurrentObservation = observation?;
+        let recurrence_representative_amplitude = observation
+            .amplitudes_before_replay
+            .get(&destination.id)
+            .and_then(|values| values.first())
+            .copied()
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "selected recurrence representative amplitude was not observed",
+                )
+            })?;
+        let phase = selector.phase();
+        let scale = (
+            phase.0 * f64::from(selector.multiplicity()),
+            phase.1 * f64::from(selector.multiplicity()),
+        );
+        let expected_public = diagnostic_complex_scale(recurrence_representative_amplitude, scale);
+        if expected_public.0.to_bits() != recurrence_public_amplitude.0.to_bits()
+            || expected_public.1.to_bits() != recurrence_public_amplitude.1.to_bits()
+        {
+            return Err(RusticolError::integrity(
+                "recurrence replay scale was not applied exactly once",
+            ));
+        }
+
+        let established = authenticated.build()?;
+        if established.currents().len() != plan.currents().len() {
+            return Err(RusticolError::integrity(
+                "retained established current catalog differs from comparator B",
+            ));
+        }
+        let mut on_the_fly_currents = BTreeMap::new();
+        for current in &on_the_fly_snapshot.currents {
+            if on_the_fly_currents
+                .insert(current.semantic_digest, current)
+                .is_some()
+            {
+                return Err(RusticolError::integrity(
+                    "on-the-fly selected trace repeats a semantic current",
+                ));
+            }
+        }
+        let mut direct_currents = BTreeMap::new();
+        let mut excluded_direct_current_count = 0_u32;
+        for (semantic_current_id, observed) in &observation.currents {
+            let current = established
+                .currents()
+                .get(*semantic_current_id as usize)
+                .filter(|current| current.id() == *semantic_current_id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "observed Direct current is absent from retained construction",
+                    )
+                })?;
+            if !current_belongs_to_representative_helicity(current, &representative_source_states) {
+                excluded_direct_current_count = excluded_direct_current_count.saturating_add(1);
+                continue;
+            }
+            let color = established
+                .dynamic_color_states()
+                .get(current.key().dynamic_lc_color_state_id().get() as usize)
+                .ok_or_else(|| {
+                    RusticolError::integrity("observed Direct current color state is absent")
+                })?;
+            let digest = hash_current_key(current.key(), color)?;
+            if !on_the_fly_currents.contains_key(&digest) {
+                excluded_direct_current_count = excluded_direct_current_count.saturating_add(1);
+                continue;
+            }
+            if direct_currents.insert(digest, observed).is_some() {
+                return Err(RusticolError::integrity(
+                    "selected Direct live slice repeats a semantic current",
+                ));
+            }
+        }
+        if direct_currents.len() != on_the_fly_currents.len() {
+            return Err(RusticolError::integrity(format!(
+                "selected current bijection has {} on-the-fly and {} Direct currents",
+                on_the_fly_currents.len(),
+                direct_currents.len(),
+            )));
+        }
+
+        let mut ordered = on_the_fly_currents
+            .iter()
+            .map(|(digest, on_the_fly)| {
+                let direct = direct_currents.get(digest).copied().ok_or_else(|| {
+                    RusticolError::integrity(
+                        "selected Direct live slice omits an on-the-fly current",
+                    )
+                })?;
+                if on_the_fly.stage != u32::from(direct.descriptor.stage)
+                    || on_the_fly.values.len() != usize::from(direct.descriptor.component_count)
+                    || direct.values.len() != on_the_fly.values.len()
+                {
+                    return Err(RusticolError::integrity(
+                        "matched semantic current has a different depth or component layout",
+                    ));
+                }
+                Ok((on_the_fly.stage, *digest, *on_the_fly, direct))
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        ordered.sort_by_key(|(stage, digest, _, _)| (*stage, digest.to_string()));
+        let mut current_components = Vec::new();
+        for (stage, digest, on_the_fly, direct) in ordered {
+            for (component, (&on_the_fly_value, &recurrence_value)) in
+                on_the_fly.values.iter().zip(&direct.values).enumerate()
+            {
+                for value in [on_the_fly_value, recurrence_value] {
+                    if !value.0.is_finite() || !value.1.is_finite() {
+                        return Err(RusticolError::evaluation(
+                            "execution diagnostic observed a non-finite current value",
+                        ));
+                    }
+                }
+                current_components.push(NativeOnTheFlyExecutionComponentV1 {
+                    dependency_depth: stage,
+                    semantic_digest: digest.to_string(),
+                    component: u32::try_from(component).map_err(|_| {
+                        RusticolError::integrity("current component index exceeds u32")
+                    })?,
+                    on_the_fly: [on_the_fly_value.0, on_the_fly_value.1],
+                    recurrence: [recurrence_value.0, recurrence_value.1],
+                    on_the_fly_bits: [on_the_fly_value.0.to_bits(), on_the_fly_value.1.to_bits()],
+                    recurrence_bits: [recurrence_value.0.to_bits(), recurrence_value.1.to_bits()],
+                    absolute_delta: [
+                        (on_the_fly_value.0 - recurrence_value.0).abs(),
+                        (on_the_fly_value.1 - recurrence_value.1).abs(),
+                    ],
+                });
+            }
+        }
+        let first_raw_bit_difference = current_components
+            .iter()
+            .position(|component| component.on_the_fly_bits != component.recurrence_bits);
+        let raw_bit_difference_count = u32::try_from(
+            current_components
+                .iter()
+                .filter(|component| component.on_the_fly_bits != component.recurrence_bits)
+                .count(),
+        )
+        .map_err(|_| RusticolError::integrity("raw difference count exceeds u32"))?;
+        let on_the_fly_public_amplitude = on_the_fly_snapshot.raw_amplitude;
+        for value in [
+            on_the_fly_public_amplitude,
+            recurrence_representative_amplitude,
+            recurrence_public_amplitude,
+        ] {
+            if !value.0.is_finite() || !value.1.is_finite() {
+                return Err(RusticolError::evaluation(
+                    "execution diagnostic observed a non-finite amplitude",
+                ));
+            }
+        }
+
+        Ok(NativeOnTheFlyExecutionDiagnosticV1 {
+            on_the_fly_artifact_id: on_the_fly_artifact.manifest().artifact_id.clone(),
+            on_the_fly_process_id: on_the_fly_manifest.key.clone(),
+            recurrence_artifact_id: recurrence_artifact.manifest().artifact_id.clone(),
+            recurrence_process_id: recurrence_manifest.key.clone(),
+            seed_digest: on_the_fly_snapshot.seed_digest.to_string(),
+            query_digest: on_the_fly_snapshot.query_digest.to_string(),
+            trace_digest: on_the_fly_snapshot.trace_digest.to_string(),
+            direct_plan_semantic_digest: plan.semantic_digest().to_string(),
+            direct_runtime_layout_digest: plan.runtime_layout_digest().to_string(),
+            public_flow_id: selector.public_flow_id(),
+            representative_flow_id: selector.representative_flow_id(),
+            public_helicities: public_helicities.to_vec(),
+            public_direct_helicity_id,
+            representative_direct_helicity_id,
+            replay_phase: [phase.0, phase.1],
+            replay_multiplicity: selector.multiplicity(),
+            replay_scale: [scale.0, scale.1],
+            on_the_fly_public_amplitude: [
+                on_the_fly_public_amplitude.0,
+                on_the_fly_public_amplitude.1,
+            ],
+            recurrence_representative_amplitude: [
+                recurrence_representative_amplitude.0,
+                recurrence_representative_amplitude.1,
+            ],
+            recurrence_public_amplitude: [
+                recurrence_public_amplitude.0,
+                recurrence_public_amplitude.1,
+            ],
+            amplitude_absolute_delta: [
+                (on_the_fly_public_amplitude.0 - recurrence_public_amplitude.0).abs(),
+                (on_the_fly_public_amplitude.1 - recurrence_public_amplitude.1).abs(),
+            ],
+            current_components,
+            first_raw_bit_difference,
+            raw_bit_difference_count,
+            compared_current_count: u32::try_from(on_the_fly_currents.len())
+                .map_err(|_| RusticolError::integrity("compared current count exceeds u32"))?,
+            excluded_direct_current_count,
+        })
+    }
+}
+
+#[cfg(feature = "python-generation-bridge")]
+pub(super) fn build_recurrence_ready_execution_v1(
+    artifact: &VerifiedArtifact,
+    evaluator_root: &Path,
+    manifest: &RecurrenceExecutionManifest,
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<RecurrenceReadyExecutionV1> {
+    let loaded_primary = load_plan(artifact, evaluator_root, manifest)?;
+    let primary_plan = &loaded_primary.plan;
+    let (common, _defaults, _projection, source_domains) =
+        build_common_runtime(primary_plan, manifest, physics)?;
+    let public_flow_ids = public_flow_ids(primary_plan, &manifest.runtime_metadata, physics)?;
+    let primary_direct_helicity_to_physics = direct_helicity_to_physics(primary_plan, physics)?
+        .into_iter()
+        .map(|value| {
+            u64::try_from(value)
+                .map_err(|_| RusticolError::artifact("physics helicity index exceeds u64"))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let runtime = RecurrenceReadyRuntimeV1 {
+        runtime_parameters: manifest.runtime_metadata.runtime_parameters.clone(),
+        prepared_parameter_defaults: manifest
+            .runtime_metadata
+            .prepared_parameter_defaults
+            .clone(),
+        parameter_projection: manifest.runtime_metadata.parameter_projection.clone(),
+        source_domains: encode_ready_source_domains(&source_domains),
+        external_is_initial: common.external_is_initial.clone(),
+        particle_masses: common
+            .particle_masses
+            .iter()
+            .map(|(pdg, mass)| (*pdg, *mass))
+            .collect(),
+        particle_mass_parameter_names: common
+            .particle_mass_parameter_names
+            .iter()
+            .map(|(pdg, name)| (*pdg, name.clone()))
+            .collect(),
+        normalization: manifest.runtime_metadata.normalization.clone(),
+        public_flow_ids,
+        public_flow_public_ids: manifest
+            .runtime_metadata
+            .public_color_flows
+            .iter()
+            .map(|binding| binding.public_id.clone())
+            .collect(),
+        direct_helicity_to_physics: primary_direct_helicity_to_physics,
+        color_contraction: manifest.runtime_metadata.color_contraction.clone(),
+    };
+    let companion = manifest
+        .helicity_selector_companion
+        .as_ref()
+        .map(|companion| {
+            validate_recurrence_companion_physics(physics)?;
+            let loaded = load_plan_summary(artifact, evaluator_root, manifest, &companion.plan)?;
+            let source_domains = build_direct_source_domains(
+                &loaded.plan,
+                &manifest.runtime_metadata,
+                &common.model_parameter_runtime_slots,
+            )?;
+            let direct_helicity_to_physics = direct_helicity_to_physics(&loaded.plan, physics)?
+                .into_iter()
+                .map(|value| {
+                    u64::try_from(value)
+                        .map_err(|_| RusticolError::artifact("companion physics index exceeds u64"))
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(RecurrenceReadyCompanionV1 {
+                process_digest: companion.process_digest.clone(),
+                plan: RecurrenceReadyPlanV1::from_summary(&companion.plan),
+                source_domains: encode_ready_source_domains(&source_domains),
+                direct_helicity_to_physics,
+            })
+        })
+        .transpose()?;
+    Ok(RecurrenceReadyExecutionV1 {
+        schema_version: 1,
+        required_runtime_capabilities: manifest.required_runtime_capabilities.clone(),
+        process: manifest.process.clone(),
+        key: manifest.key.clone(),
+        color_accuracy: manifest.color_accuracy.clone(),
+        external_pdg_order: manifest.external_pdg_order.clone(),
+        compiled_model_digest: manifest.compiled_model_digest.clone(),
+        recurrence_template_catalog_digest: manifest.recurrence_template_catalog_digest.clone(),
+        prepared_kernel_pack_digest: manifest.prepared_kernel_pack_digest.clone(),
+        direct_template_catalog_digest: manifest.direct_template_catalog_digest.clone(),
+        kernel_pack: manifest.kernel_pack.clone(),
+        primary_plan: RecurrenceReadyPlanV1::from_summary(&manifest.plan),
+        runtime,
+        companion,
+    })
+}
+
+#[cfg(feature = "python-generation-bridge")]
+fn encode_ready_source_domains(
+    domains: &[DirectSourceDispatchDomainSpec],
+) -> Vec<RecurrenceReadySourceDomainV1> {
+    domains
+        .iter()
+        .map(|domain| RecurrenceReadySourceDomainV1 {
+            variants: domain
+                .variants
+                .iter()
+                .map(|variant| RecurrenceReadySourceVariantV1 {
+                    key: match variant.key {
+                        DirectSourceDispatchKey::SpinStateClass(value) => {
+                            RecurrenceReadySourceKeyV1::SpinStateClass(value)
+                        }
+                        DirectSourceDispatchKey::RuntimeVariant {
+                            source_row_id,
+                            runtime_variant_id,
+                        } => RecurrenceReadySourceKeyV1::RuntimeVariant {
+                            source_row_id,
+                            runtime_variant_id,
+                        },
+                    },
+                    template: RecurrenceReadySourceTemplateV1 {
+                        spin_state_class: variant.template.spin_state_class,
+                        family: match variant.template.family {
+                            DirectSourceWavefunctionFamily::Scalar => {
+                                RecurrenceReadySourceFamilyV1::Scalar
+                            }
+                            DirectSourceWavefunctionFamily::WeylFermion => {
+                                RecurrenceReadySourceFamilyV1::WeylFermion
+                            }
+                            DirectSourceWavefunctionFamily::DiracFermion => {
+                                RecurrenceReadySourceFamilyV1::DiracFermion
+                            }
+                            DirectSourceWavefunctionFamily::Vector => {
+                                RecurrenceReadySourceFamilyV1::Vector
+                            }
+                            DirectSourceWavefunctionFamily::Spin2 => {
+                                RecurrenceReadySourceFamilyV1::Spin2
+                            }
+                        },
+                        orientation: match variant.template.orientation {
+                            DirectSourceOrientation::Particle => {
+                                RecurrenceReadySourceOrientationV1::Particle
+                            }
+                            DirectSourceOrientation::Antiparticle => {
+                                RecurrenceReadySourceOrientationV1::Antiparticle
+                            }
+                            DirectSourceOrientation::SelfConjugate => {
+                                RecurrenceReadySourceOrientationV1::SelfConjugate
+                            }
+                        },
+                        helicity: variant.template.helicity,
+                        chirality: variant.template.chirality,
+                        mass_parameter_index: variant.template.mass_parameter_index,
+                    },
+                })
+                .collect(),
+        })
+        .collect()
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+pub(super) fn decode_ready_source_domains(
+    domains: &[RecurrenceReadySourceDomainV1],
+    plan: &DirectRecurrencePlan,
+) -> RusticolResult<Vec<DirectSourceDispatchDomainSpec>> {
+    if domains.len()
+        != usize::try_from(plan.source_template_or_dispatch_count())
+            .map_err(|_| RusticolError::artifact("source-domain count exceeds usize"))?
+    {
+        return Err(RusticolError::integrity(
+            "process-ready source-domain count disagrees with the recurrence plan",
+        ));
+    }
+    let domains = domains
+        .iter()
+        .map(|domain| DirectSourceDispatchDomainSpec {
+            variants: domain
+                .variants
+                .iter()
+                .map(|variant| DirectSourceDispatchVariantSpec {
+                    key: match variant.key {
+                        RecurrenceReadySourceKeyV1::SpinStateClass(value) => {
+                            DirectSourceDispatchKey::SpinStateClass(value)
+                        }
+                        RecurrenceReadySourceKeyV1::RuntimeVariant {
+                            source_row_id,
+                            runtime_variant_id,
+                        } => DirectSourceDispatchKey::RuntimeVariant {
+                            source_row_id,
+                            runtime_variant_id,
+                        },
+                    },
+                    template: DirectSourceTemplateSpec {
+                        spin_state_class: variant.template.spin_state_class,
+                        family: match variant.template.family {
+                            RecurrenceReadySourceFamilyV1::Scalar => {
+                                DirectSourceWavefunctionFamily::Scalar
+                            }
+                            RecurrenceReadySourceFamilyV1::WeylFermion => {
+                                DirectSourceWavefunctionFamily::WeylFermion
+                            }
+                            RecurrenceReadySourceFamilyV1::DiracFermion => {
+                                DirectSourceWavefunctionFamily::DiracFermion
+                            }
+                            RecurrenceReadySourceFamilyV1::Vector => {
+                                DirectSourceWavefunctionFamily::Vector
+                            }
+                            RecurrenceReadySourceFamilyV1::Spin2 => {
+                                DirectSourceWavefunctionFamily::Spin2
+                            }
+                        },
+                        orientation: match variant.template.orientation {
+                            RecurrenceReadySourceOrientationV1::Particle => {
+                                DirectSourceOrientation::Particle
+                            }
+                            RecurrenceReadySourceOrientationV1::Antiparticle => {
+                                DirectSourceOrientation::Antiparticle
+                            }
+                            RecurrenceReadySourceOrientationV1::SelfConjugate => {
+                                DirectSourceOrientation::SelfConjugate
+                            }
+                        },
+                        helicity: variant.template.helicity,
+                        chirality: variant.template.chirality,
+                        mass_parameter_index: variant.template.mass_parameter_index,
+                    },
+                })
+                .collect(),
+        })
+        .collect::<Vec<_>>();
+    validate_ready_source_domains_against_plan(&domains, plan)?;
+    Ok(domains)
+}
+
+fn validate_ready_source_domains_against_plan(
+    domains: &[DirectSourceDispatchDomainSpec],
+    plan: &DirectRecurrencePlan,
+) -> RusticolResult<()> {
+    let mut expected = vec![BTreeMap::new(); domains.len()];
+    match plan.strategy() {
+        crate::recurrence::RecurrenceStrategy::TopologyReplay
+        | crate::recurrence::RecurrenceStrategy::ContractedColorUnion => {
+            for row in plan.sources() {
+                let domain = expected
+                    .get_mut(row.source_template_or_dispatch_domain as usize)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "process-ready fixed source references an absent domain",
+                        )
+                    })?;
+                let key = DirectSourceDispatchKey::SpinStateClass(row.spin_state_class);
+                if domain
+                    .insert(key, row.spin_state_class)
+                    .is_some_and(|previous| previous != row.spin_state_class)
+                {
+                    return Err(RusticolError::integrity(
+                        "process-ready fixed source key has inconsistent spin semantics",
+                    ));
+                }
+            }
+        }
+        crate::recurrence::RecurrenceStrategy::AllFlowUnion => {
+            for variant in plan.source_dispatch_variants() {
+                let domain = expected
+                    .get_mut(variant.dispatch_domain_id as usize)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "process-ready union source references an absent domain",
+                        )
+                    })?;
+                let key = DirectSourceDispatchKey::RuntimeVariant {
+                    source_row_id: variant.source_row_id,
+                    runtime_variant_id: variant.runtime_variant_id,
+                };
+                if domain
+                    .insert(key, variant.crossed_spin_state_class)
+                    .is_some_and(|previous| previous != variant.crossed_spin_state_class)
+                {
+                    return Err(RusticolError::integrity(
+                        "process-ready union source key has inconsistent spin semantics",
+                    ));
+                }
+            }
+        }
+    }
+    validate_ready_source_domain_shape(domains, &expected, plan.parameter_value_count())
+}
+
+fn validate_ready_source_domain_shape(
+    domains: &[DirectSourceDispatchDomainSpec],
+    expected: &[BTreeMap<DirectSourceDispatchKey, i32>],
+    parameter_count: u32,
+) -> RusticolResult<()> {
+    if domains.len() != expected.len() {
+        return Err(RusticolError::integrity(
+            "process-ready source-domain expectations have the wrong width",
+        ));
+    }
+    let globally_referenced = expected
+        .iter()
+        .flat_map(BTreeMap::iter)
+        .map(|(key, spin)| (*key, *spin))
+        .collect::<BTreeMap<_, _>>();
+    for (domain_id, (domain, expected)) in domains.iter().zip(expected).enumerate() {
+        if domain.variants.is_empty()
+            || domain
+                .variants
+                .windows(2)
+                .any(|pair| pair[0].key >= pair[1].key)
+            || domain.variants.iter().any(|variant| {
+                variant
+                    .template
+                    .mass_parameter_index
+                    .is_some_and(|slot| slot >= parameter_count)
+            })
+        {
+            return Err(RusticolError::integrity(format!(
+                "process-ready source domain {domain_id} is non-canonical or out of bounds"
+            )));
+        }
+
+        if expected.is_empty() {
+            // Model-global source-template IDs can be sparse for one process.
+            // The established builder fills each unused slot with exactly one
+            // inert copy of a referenced source so the row-addressable ABI
+            // remains dense; it can never be selected by this plan.
+            let [inert] = domain.variants.as_slice() else {
+                return Err(RusticolError::integrity(format!(
+                    "process-ready unused source domain {domain_id} is not a singleton"
+                )));
+            };
+            if globally_referenced.get(&inert.key) != Some(&inert.template.spin_state_class) {
+                return Err(RusticolError::integrity(format!(
+                    "process-ready unused source domain {domain_id} is not an inert referenced source"
+                )));
+            }
+            continue;
+        }
+
+        if domain.variants.len() != expected.len()
+            || domain.variants.iter().any(|variant| {
+                expected.get(&variant.key) != Some(&variant.template.spin_state_class)
+                    || matches!(
+                        variant.key,
+                        DirectSourceDispatchKey::SpinStateClass(spin)
+                            if spin != variant.template.spin_state_class
+                    )
+            })
+        {
+            return Err(RusticolError::integrity(format!(
+                "process-ready source domain {domain_id} does not exactly cover its plan keys"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_recurrence_companion_physics(physics: &ProcessPhysicsV1) -> RusticolResult<()> {
+    if physics.coverage.helicities != "complete" || physics.coverage.color != "contracted" {
+        return Err(RusticolError::integrity(
+            "recurrence helicity-selector companion requires complete helicity and contracted-color coverage",
+        ));
+    }
+    if physics.helicities.iter().any(|helicity| {
+        !companion_helicity_coefficient_is_canonical(helicity.structural_zero, helicity.coefficient)
+    }) {
+        return Err(RusticolError::integrity(
+            "recurrence helicity-selector companion requires unit physical-helicity coefficients and zero structural-zero coefficients",
+        ));
+    }
+    Ok(())
+}
+
+fn recurrence_parameter_parts(
+    plan: &DirectRecurrencePlan,
+    defaults: &[[f64; 2]],
+    projection: &[RecurrenceParameterProjection],
+) -> RusticolResult<(
+    Vec<crate::EagerComplex64>,
+    Vec<PreparedParameterProjectionEntry>,
+)> {
+    if defaults
+        .iter()
+        .flatten()
+        .any(|component| !component.is_finite())
+    {
+        return Err(RusticolError::integrity(
+            "recurrence prepared parameter defaults are not finite",
+        ));
+    }
+    let defaults = defaults
+        .iter()
+        .map(|[real, imaginary]| crate::EagerComplex64::new(*real, *imaginary))
+        .collect::<Vec<_>>();
+    if defaults.len()
+        != usize::try_from(plan.parameter_value_count())
+            .map_err(|_| RusticolError::artifact("recurrence parameter count exceeds usize"))?
+    {
+        return Err(RusticolError::integrity(
+            "recurrence prepared defaults do not match the direct plan",
+        ));
+    }
+    let projection = projection
+        .iter()
+        .filter_map(|row| {
+            row.prepared_parameter_id
+                .map(|prepared_slot| (row, prepared_slot))
+        })
+        .map(|(row, prepared_slot)| {
+            Ok(PreparedParameterProjectionEntry {
+                runtime_slot: usize::try_from(row.runtime_slot).map_err(|_| {
+                    RusticolError::artifact("recurrence runtime parameter slot exceeds usize")
+                })?,
+                prepared_slot: usize::try_from(prepared_slot).map_err(|_| {
+                    RusticolError::artifact("recurrence prepared parameter slot exceeds usize")
+                })?,
+                component: u8::try_from(row.component).map_err(|_| {
+                    RusticolError::artifact("recurrence parameter component exceeds u8")
+                })?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    Ok((defaults, projection))
+}
+
+fn build_common_runtime(
+    plan: &DirectRecurrencePlan,
+    manifest: &RecurrenceExecutionManifest,
+    physics: &ProcessPhysicsV1,
+) -> RusticolResult<RecurrenceCommonRuntimeParts> {
+    let metadata = &manifest.runtime_metadata;
+    let runtime_parameters = recurrence_runtime_parameters(metadata);
+    let model_parameter_runtime_slots = runtime_parameter_slots(&runtime_parameters)?;
+    let model_parameter_values_f64 = runtime_parameters
+        .iter()
+        .map(|parameter| parameter.default)
+        .collect::<Vec<_>>();
+    let (parameter_defaults, parameter_projection) = recurrence_parameter_parts(
+        plan,
+        &metadata.prepared_parameter_defaults,
+        &metadata.parameter_projection,
+    )?;
+
+    let mut particle_masses = metadata
+        .particle_masses
+        .iter()
+        .map(|row| (row.outgoing_pdg, row.mass))
+        .collect::<BTreeMap<_, _>>();
+    let mut particle_mass_parameter_names = BTreeMap::new();
+    for source in &metadata.source_templates {
+        let Some(name) = source.source_ir.mass_parameter.as_ref() else {
+            continue;
+        };
+        for pdg in [
+            source.source_ir.identity.pdg_label,
+            source.source_ir.identity.anti_pdg_label,
+        ] {
+            particle_mass_parameter_names.insert(pdg, name.clone());
+            if let Some(slots) = model_parameter_runtime_slots.get(name)
+                && let Some(mass) = model_parameter_values_f64.get(slots.real)
+            {
+                particle_masses.insert(pdg, *mass);
+            }
+        }
+    }
+
+    let source_domains =
+        build_direct_source_domains(plan, metadata, &model_parameter_runtime_slots)?;
+    let normalization = &metadata.normalization;
+    let normalization_values = recurrence_normalization_values(metadata)?;
+    let color_factor = normalization_values.color_factor;
+    let normalization_factor = normalization_values.factor;
+    let external_count = manifest.external_pdg_order.len();
+    if plan.external_source_count() as usize != external_count
+        || metadata.external_legs.len() != external_count
+    {
+        return Err(RusticolError::integrity(
+            "recurrence direct plan external-source count disagrees with process metadata",
+        ));
+    }
+    let external_is_initial = physics
+        .external_particles
+        .iter()
+        .map(|particle| particle.role == crate::ParticleRole::Initial)
+        .collect();
+    let common = assemble_common_runtime(
+        plan,
+        RecurrenceCommonRuntimeDefinition {
+            process: manifest.process.clone(),
+            key: manifest.key.clone(),
+            color_accuracy: manifest.color_accuracy.clone(),
+            external_pdg_order: manifest.external_pdg_order.clone(),
+            runtime_parameters,
+            model_parameter_runtime_slots,
+            model_parameter_values_f64,
+            external_is_initial,
+            particle_masses,
+            particle_mass_parameter_names,
+            normalization_factor,
+            normalization_color_factor: color_factor,
+            normalization_average_factor: normalization.average_factor,
+            normalization_identical_factor: normalization.identical_factor,
+            normalization_qcd_coupling_power: normalization.qcd_coupling_power.unwrap_or(0),
+            normalization_electroweak_coupling_power: normalization
+                .electroweak_coupling_power
+                .unwrap_or(0),
+        },
+    )?;
+    Ok((
+        common,
+        parameter_defaults,
+        parameter_projection,
+        source_domains,
+    ))
+}
+
+fn build_ready_common_runtime(
+    plan: &DirectRecurrencePlan,
+    ready: &RecurrenceReadyExecutionV1,
+) -> RusticolResult<RecurrenceCommonRuntimeParts> {
+    let runtime = &ready.runtime;
+    validate_recurrence_parameter_runtime_parts(
+        &runtime.runtime_parameters,
+        &runtime.prepared_parameter_defaults,
+        &runtime.parameter_projection,
+        u64::from(plan.parameter_value_count()),
+    )?;
+    let runtime_parameters = recurrence_runtime_parameters_from(&runtime.runtime_parameters);
+    let model_parameter_runtime_slots = runtime_parameter_slots(&runtime_parameters)?;
+    let model_parameter_values_f64 = runtime_parameters
+        .iter()
+        .map(|parameter| parameter.default)
+        .collect::<Vec<_>>();
+    let (parameter_defaults, parameter_projection) = recurrence_parameter_parts(
+        plan,
+        &runtime.prepared_parameter_defaults,
+        &runtime.parameter_projection,
+    )?;
+    let particle_masses = ready_pairs_to_map(&runtime.particle_masses, "particle mass", |mass| {
+        mass.is_finite() && mass >= 0.0
+    })?;
+    let particle_mass_parameter_names =
+        ready_string_pairs_to_map(&runtime.particle_mass_parameter_names, "particle mass name")?;
+    if particle_mass_parameter_names
+        .values()
+        .any(|name| !model_parameter_runtime_slots.contains_key(name))
+    {
+        return Err(RusticolError::integrity(
+            "process-ready particle mass references an absent runtime parameter",
+        ));
+    }
+    if runtime.normalization.color_accuracy != ready.color_accuracy
+        || !runtime.normalization.average_factor.is_finite()
+        || runtime.normalization.average_factor <= 0.0
+        || !runtime.normalization.identical_factor.is_finite()
+        || runtime.normalization.identical_factor <= 0.0
+    {
+        return Err(RusticolError::integrity(
+            "process-ready recurrence normalization is inconsistent",
+        ));
+    }
+    let normalization = recurrence_normalization_values_from(
+        &runtime.normalization,
+        runtime.color_contraction.as_ref(),
+    )?;
+    let source_domains = decode_ready_source_domains(&runtime.source_domains, plan)?;
+    let common = assemble_common_runtime(
+        plan,
+        RecurrenceCommonRuntimeDefinition {
+            process: ready.process.clone(),
+            key: ready.key.clone(),
+            color_accuracy: ready.color_accuracy.clone(),
+            external_pdg_order: ready.external_pdg_order.clone(),
+            runtime_parameters,
+            model_parameter_runtime_slots,
+            model_parameter_values_f64,
+            external_is_initial: runtime.external_is_initial.clone(),
+            particle_masses,
+            particle_mass_parameter_names,
+            normalization_factor: normalization.factor,
+            normalization_color_factor: normalization.color_factor,
+            normalization_average_factor: runtime.normalization.average_factor,
+            normalization_identical_factor: runtime.normalization.identical_factor,
+            normalization_qcd_coupling_power: runtime.normalization.qcd_coupling_power.unwrap_or(0),
+            normalization_electroweak_coupling_power: runtime
+                .normalization
+                .electroweak_coupling_power
+                .unwrap_or(0),
+        },
+    )?;
+    Ok((
+        common,
+        parameter_defaults,
+        parameter_projection,
+        source_domains,
+    ))
+}
+
+fn ready_pairs_to_map(
+    values: &[(i32, f64)],
+    context: &str,
+    valid: impl Fn(f64) -> bool,
+) -> RusticolResult<BTreeMap<i32, f64>> {
+    let mut result = BTreeMap::new();
+    let mut previous = None;
+    for (key, value) in values {
+        if previous.is_some_and(|previous| previous >= *key)
+            || result.insert(*key, *value).is_some()
+            || !valid(*value)
+        {
+            return Err(RusticolError::integrity(format!(
+                "process-ready recurrence {context} entries are not canonical"
+            )));
+        }
+        previous = Some(*key);
+    }
+    Ok(result)
+}
+
+fn ready_string_pairs_to_map(
+    values: &[(i32, String)],
+    context: &str,
+) -> RusticolResult<BTreeMap<i32, String>> {
+    let mut result = BTreeMap::new();
+    let mut previous = None;
+    for (key, value) in values {
+        if previous.is_some_and(|previous| previous >= *key)
+            || value.is_empty()
+            || result.insert(*key, value.clone()).is_some()
+        {
+            return Err(RusticolError::integrity(format!(
+                "process-ready recurrence {context} entries are not canonical"
+            )));
+        }
+        previous = Some(*key);
+    }
+    Ok(result)
+}
+
+struct RecurrenceCommonRuntimeDefinition {
+    process: String,
+    key: String,
+    color_accuracy: String,
+    external_pdg_order: Vec<i32>,
+    runtime_parameters: Vec<GenericRuntimeModelParameterManifest>,
+    model_parameter_runtime_slots: BTreeMap<String, RuntimeParameterSlots>,
+    model_parameter_values_f64: Vec<f64>,
+    external_is_initial: Vec<bool>,
+    particle_masses: BTreeMap<i32, f64>,
+    particle_mass_parameter_names: BTreeMap<i32, String>,
+    normalization_factor: f64,
+    normalization_color_factor: f64,
+    normalization_average_factor: f64,
+    normalization_identical_factor: f64,
+    normalization_qcd_coupling_power: u64,
+    normalization_electroweak_coupling_power: u64,
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn assemble_common_runtime(
+    plan: &DirectRecurrencePlan,
+    definition: RecurrenceCommonRuntimeDefinition,
+) -> RusticolResult<ExecutionRuntime> {
+    let RecurrenceCommonRuntimeDefinition {
+        process,
+        key,
+        color_accuracy,
+        external_pdg_order,
+        runtime_parameters,
+        model_parameter_runtime_slots,
+        model_parameter_values_f64,
+        external_is_initial,
+        particle_masses,
+        particle_mass_parameter_names,
+        normalization_factor,
+        normalization_color_factor,
+        normalization_average_factor,
+        normalization_identical_factor,
+        normalization_qcd_coupling_power,
+        normalization_electroweak_coupling_power,
+    } = definition;
+    let external_count = external_pdg_order.len();
+    if plan.external_source_count() as usize != external_count
+        || external_is_initial.len() != external_count
+    {
+        return Err(RusticolError::integrity(
+            "recurrence common runtime external domain disagrees with its plan",
+        ));
+    }
+    let model_parameter_name_to_index = runtime_parameters
+        .iter()
+        .map(|parameter| (parameter.name.clone(), parameter.parameter_index))
+        .collect::<BTreeMap<_, _>>();
+    let source_count = plan.sources().len();
+    let current_count = plan.currents().len();
+    let interaction_count = plan.contributions().len();
+    let stage_count = plan
+        .row_groups()
+        .iter()
+        .map(|group| usize::from(group.stage))
+        .max()
+        .and_then(|stage| stage.checked_add(1))
+        .ok_or_else(|| RusticolError::integrity("recurrence direct plan has no row groups"))?;
+    let amplitude_output_count = plan.amplitude_destinations().len();
+    Ok(ExecutionRuntime {
+        process,
+        key,
+        color_accuracy,
+        external_pdg_order,
+        external_count,
+        parameter_count: runtime_parameters.len(),
+        value_parameter_count: 0,
+        momentum_parameter_count: 0,
+        current_count,
+        source_count,
+        interaction_count,
+        stage_count,
+        amplitude_output_count,
+        lc_topology_replay_enabled: false,
+        lc_topology_replay_mappings: Arc::new(Vec::new()),
+        lc_topology_replay_public_mappings: Vec::new(),
+        lc_topology_replay_routes: Vec::new(),
+        lc_topology_replay_materialized_sector_ids: BTreeSet::new(),
+        lc_resolved_replay_plan: None,
+        lc_resolved_replay_selection_cache: None,
+        lc_replay_flat_momenta_scratch: Vec::new(),
+        lc_replay_target_components_scratch: Vec::new(),
+        color_topology_replay_enabled: false,
+        color_topology_replay_mappings: Arc::new(Vec::new()),
+        color_replay_flat_momenta_scratch: Vec::new(),
+        helicity_recurrence: None,
+        compiled_helicity_execution_plan: None,
+        compiled_color_execution_plan: None,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        compiled_direct_runtime: None,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        compiled_direct_color_schedules: BTreeMap::new(),
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        compiled_direct_helicity_schedules: BTreeMap::new(),
+        helicity_sum_runtime: None,
+        helicity_selector_runtimes: Vec::new(),
+        helicity_selector_runtime_schedule_modes: Vec::new(),
+        helicity_selector_lane_by_domain: BTreeMap::new(),
+        color_selector_runtimes: BTreeMap::new(),
+        runtime_unavailable_message: None,
+        // Direct-Arena source execution owns typed SourceIR dispatch domains.
+        // The legacy source records are intentionally not reconstructed.
+        sources: Vec::new(),
+        momentum_slots: Vec::new(),
+        external_is_initial,
+        particle_masses,
+        particle_mass_parameter_names,
+        normalization_factor,
+        normalization_color_factor,
+        normalization_average_factor,
+        normalization_identical_factor,
+        normalization_qcd_coupling_power: usize::try_from(normalization_qcd_coupling_power)
+            .map_err(|_| RusticolError::artifact("QCD coupling power exceeds usize"))?,
+        normalization_electroweak_coupling_power: usize::try_from(
+            normalization_electroweak_coupling_power,
+        )
+        .map_err(|_| RusticolError::artifact("electroweak coupling power exceeds usize"))?,
+        model_parameters: runtime_parameters,
+        model_parameter_name_to_index,
+        model_parameter_runtime_slots,
+        model_parameter_values_f64,
+        model_parameter_evaluator: None,
+        physics_reduction_override: None,
+        physics: None,
+        stages: None,
+        amplitude_stage: None,
+        state_scratch_f64: Vec::new(),
+        state_scratch_f64_requires_clear: false,
+        values_scratch_f64: Vec::new(),
+    })
+}
+
+pub(super) fn build_direct_source_domains(
+    plan: &DirectRecurrencePlan,
+    metadata: &RecurrenceRuntimeMetadata,
+    runtime_parameter_slots: &BTreeMap<String, RuntimeParameterSlots>,
+) -> RusticolResult<Vec<DirectSourceDispatchDomainSpec>> {
+    let templates = metadata
+        .source_templates
+        .iter()
+        .map(|source| (source.source_template_id, source))
+        .collect::<BTreeMap<_, _>>();
+    let legs = metadata
+        .external_legs
+        .iter()
+        .map(|leg| (leg.source_slot, leg))
+        .collect::<BTreeMap<_, _>>();
+    let domain_count = usize::try_from(plan.source_template_or_dispatch_count())
+        .map_err(|_| RusticolError::artifact("recurrence source-domain count exceeds usize"))?;
+    let mut variants =
+        vec![BTreeMap::<DirectSourceDispatchKey, DirectSourceTemplateSpec>::new(); domain_count];
+
+    match plan.strategy() {
+        crate::recurrence::RecurrenceStrategy::TopologyReplay
+        | crate::recurrence::RecurrenceStrategy::ContractedColorUnion => {
+            for row in plan.sources() {
+                let source = templates
+                    .get(&row.source_template_or_dispatch_domain)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "recurrence direct plan references an absent SourceIR template",
+                        )
+                    })?;
+                let leg = legs.get(&row.source_slot).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "recurrence direct source references an absent external leg",
+                    )
+                })?;
+                let spec = direct_source_template_spec(
+                    source,
+                    leg,
+                    metadata,
+                    runtime_parameter_slots,
+                    plan.parameter_value_count(),
+                )?;
+                if row.spin_state_class != spec.spin_state_class {
+                    return Err(RusticolError::integrity(
+                        "recurrence direct source spin class disagrees with crossed SourceIR metadata",
+                    ));
+                }
+                insert_source_domain_variant(
+                    &mut variants,
+                    row.source_template_or_dispatch_domain,
+                    DirectSourceDispatchKey::SpinStateClass(row.spin_state_class),
+                    spec,
+                )?;
+            }
+        }
+        crate::recurrence::RecurrenceStrategy::AllFlowUnion => {
+            for variant in plan.source_dispatch_variants() {
+                let row = plan
+                    .sources()
+                    .get(variant.source_row_id as usize)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "recurrence source variant references an absent source row",
+                        )
+                    })?;
+                let source = templates.get(&variant.source_template_id).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "recurrence source variant references an absent SourceIR template",
+                    )
+                })?;
+                let leg = legs.get(&row.source_slot).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "recurrence source variant references an absent external leg",
+                    )
+                })?;
+                let spec = direct_source_template_spec(
+                    source,
+                    leg,
+                    metadata,
+                    runtime_parameter_slots,
+                    plan.parameter_value_count(),
+                )?;
+                if row.source_template_or_dispatch_domain != variant.dispatch_domain_id
+                    || spec.spin_state_class != variant.crossed_spin_state_class
+                {
+                    return Err(RusticolError::integrity(
+                        "recurrence union source variant disagrees with its dispatch domain or crossed SourceIR state",
+                    ));
+                }
+                insert_source_domain_variant(
+                    &mut variants,
+                    variant.dispatch_domain_id,
+                    DirectSourceDispatchKey::RuntimeVariant {
+                        source_row_id: variant.source_row_id,
+                        runtime_variant_id: variant.runtime_variant_id,
+                    },
+                    spec,
+                )?;
+            }
+        }
+    }
+
+    finish_direct_source_domains(variants)
+}
+
+fn finish_direct_source_domains(
+    variants: Vec<BTreeMap<DirectSourceDispatchKey, DirectSourceTemplateSpec>>,
+) -> RusticolResult<Vec<DirectSourceDispatchDomainSpec>> {
+    let inert = variants
+        .iter()
+        .flat_map(BTreeMap::iter)
+        .next()
+        .map(|(key, spec)| (*key, *spec))
+        .ok_or_else(|| RusticolError::integrity("recurrence direct plan has no source rows"))?;
+    Ok(variants
+        .into_iter()
+        .map(|domain| DirectSourceDispatchDomainSpec {
+            // Prepared source-template IDs are model-global and may be sparse
+            // for one process. Unreferenced slots remain inert but preserve the
+            // stable IDs addressed by DirectSourceRow.
+            variants: if domain.is_empty() {
+                vec![DirectSourceDispatchVariantSpec {
+                    key: inert.0,
+                    template: inert.1,
+                }]
+            } else {
+                domain
+                    .into_iter()
+                    .map(|(key, template)| DirectSourceDispatchVariantSpec { key, template })
+                    .collect()
+            },
+        })
+        .collect())
+}
+
+/// Bind the compact process seed to the same crossed SourceIR semantics used
+/// by the established direct-plan loader.  This boundary is deliberately
+/// plan-independent: source-template IDs remain the authenticated model-level
+/// IDs, including sparse slots that this process does not address.
+pub(super) fn build_on_the_fly_source_domains(
+    seed: &OnTheFlyProcessSeedV1,
+    templates: &crate::recurrence::template::ValidatedRecurrenceTemplateInput,
+) -> RusticolResult<Vec<DirectSourceDispatchDomainSpec>> {
+    let summary = templates.summary();
+    if seed.template_catalog_digest() != summary.catalog_digest
+        || seed.model_digest() != summary.compiled_model_digest
+        || seed.prepared_pack_digest() != summary.prepared_kernel_pack_digest
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly source seed does not belong to the authenticated recurrence templates",
+        ));
+    }
+    let domain_count = usize::try_from(summary.source_count)
+        .map_err(|_| RusticolError::artifact("recurrence source-domain count exceeds usize"))?;
+    let mut variants =
+        vec![BTreeMap::<DirectSourceDispatchKey, DirectSourceTemplateSpec>::new(); domain_count];
+    for compact in seed.source_execution_specs() {
+        if compact.source_template_id as usize >= domain_count
+            || compact
+                .prepared_mass_parameter_slot
+                .is_some_and(|slot| slot >= summary.parameter_count)
+        {
+            return Err(RusticolError::integrity(
+                "on-the-fly source or mass-parameter slot is outside its authenticated template domain",
+            ));
+        }
+        let source_template_id = compact.source_template_id;
+        let spec = DirectSourceTemplateSpec {
+            spin_state_class: compact.spin_state_class,
+            family: direct_on_the_fly_source_family(compact.family),
+            orientation: direct_on_the_fly_source_orientation(compact.orientation),
+            helicity: compact.helicity,
+            chirality: compact.chirality,
+            mass_parameter_index: compact.prepared_mass_parameter_slot,
+        };
+        insert_source_domain_variant(
+            &mut variants,
+            source_template_id,
+            DirectSourceDispatchKey::SpinStateClass(spec.spin_state_class),
+            spec,
+        )?;
+    }
+    finish_direct_source_domains(variants)
+}
+
+#[cfg(test)]
+fn build_on_the_fly_source_domains_from_specs(
+    specs: impl IntoIterator<Item = OnTheFlySourceExecutionSpecV1>,
+    domain_count: usize,
+    parameter_count: u32,
+    metadata: &RecurrenceRuntimeMetadata,
+    runtime_parameter_slots: &BTreeMap<String, RuntimeParameterSlots>,
+) -> RusticolResult<Vec<DirectSourceDispatchDomainSpec>> {
+    let templates = metadata
+        .source_templates
+        .iter()
+        .map(|source| (source.source_template_id, source))
+        .collect::<BTreeMap<_, _>>();
+    let legs = metadata
+        .external_legs
+        .iter()
+        .map(|leg| (leg.source_slot, leg))
+        .collect::<BTreeMap<_, _>>();
+    let mut variants =
+        vec![BTreeMap::<DirectSourceDispatchKey, DirectSourceTemplateSpec>::new(); domain_count];
+    for compact in specs {
+        let source = templates.get(&compact.source_template_id).ok_or_else(|| {
+            RusticolError::integrity("on-the-fly source references an absent SourceIR template")
+        })?;
+        let leg = legs.get(&compact.source_slot).ok_or_else(|| {
+            RusticolError::integrity("on-the-fly source references an absent external leg")
+        })?;
+        let authoritative = direct_source_template_spec(
+            source,
+            leg,
+            metadata,
+            runtime_parameter_slots,
+            parameter_count,
+        )?;
+        let compact = DirectSourceTemplateSpec {
+            spin_state_class: compact.spin_state_class,
+            family: direct_on_the_fly_source_family(compact.family),
+            orientation: direct_on_the_fly_source_orientation(compact.orientation),
+            helicity: compact.helicity,
+            chirality: compact.chirality,
+            mass_parameter_index: compact.prepared_mass_parameter_slot,
+        };
+        let authoritative = bind_on_the_fly_source_spec(compact, authoritative)?;
+        insert_source_domain_variant(
+            &mut variants,
+            source.source_template_id,
+            DirectSourceDispatchKey::SpinStateClass(authoritative.spin_state_class),
+            authoritative,
+        )?;
+    }
+    finish_direct_source_domains(variants)
+}
+
+#[cfg(test)]
+fn bind_on_the_fly_source_spec(
+    compact: DirectSourceTemplateSpec,
+    authoritative: DirectSourceTemplateSpec,
+) -> RusticolResult<DirectSourceTemplateSpec> {
+    if compact.spin_state_class != authoritative.spin_state_class {
+        return Err(RusticolError::integrity(
+            "on-the-fly source spin class disagrees with crossed SourceIR metadata",
+        ));
+    }
+    if compact.family != authoritative.family {
+        return Err(RusticolError::integrity(
+            "on-the-fly source family disagrees with crossed SourceIR metadata",
+        ));
+    }
+    if compact.orientation != authoritative.orientation {
+        return Err(RusticolError::integrity(
+            "on-the-fly source orientation disagrees with crossed SourceIR metadata",
+        ));
+    }
+    if compact.helicity != authoritative.helicity {
+        return Err(RusticolError::integrity(
+            "on-the-fly source helicity disagrees with crossed SourceIR metadata",
+        ));
+    }
+    if compact.chirality != authoritative.chirality {
+        return Err(RusticolError::integrity(
+            "on-the-fly source chirality disagrees with crossed SourceIR metadata",
+        ));
+    }
+    if compact.mass_parameter_index.is_some()
+        && compact.mass_parameter_index != authoritative.mass_parameter_index
+    {
+        return Err(RusticolError::integrity(
+            "on-the-fly source prepared mass parameter slot disagrees with SourceIR metadata",
+        ));
+    }
+    Ok(authoritative)
+}
+
+const fn direct_on_the_fly_source_family(
+    value: OnTheFlySourceWavefunctionFamilyV1,
+) -> DirectSourceWavefunctionFamily {
+    match value {
+        OnTheFlySourceWavefunctionFamilyV1::Scalar => DirectSourceWavefunctionFamily::Scalar,
+        OnTheFlySourceWavefunctionFamilyV1::WeylFermion => {
+            DirectSourceWavefunctionFamily::WeylFermion
+        }
+        OnTheFlySourceWavefunctionFamilyV1::DiracFermion => {
+            DirectSourceWavefunctionFamily::DiracFermion
+        }
+        OnTheFlySourceWavefunctionFamilyV1::Vector => DirectSourceWavefunctionFamily::Vector,
+        OnTheFlySourceWavefunctionFamilyV1::Spin2 => DirectSourceWavefunctionFamily::Spin2,
+    }
+}
+
+const fn direct_on_the_fly_source_orientation(
+    value: OnTheFlySourceOrientationV1,
+) -> DirectSourceOrientation {
+    match value {
+        OnTheFlySourceOrientationV1::Particle => DirectSourceOrientation::Particle,
+        OnTheFlySourceOrientationV1::Antiparticle => DirectSourceOrientation::Antiparticle,
+        OnTheFlySourceOrientationV1::SelfConjugate => DirectSourceOrientation::SelfConjugate,
+    }
+}
+
+fn insert_source_domain_variant(
+    domains: &mut [BTreeMap<DirectSourceDispatchKey, DirectSourceTemplateSpec>],
+    domain_id: u32,
+    key: DirectSourceDispatchKey,
+    spec: DirectSourceTemplateSpec,
+) -> RusticolResult<()> {
+    let domain = domains.get_mut(domain_id as usize).ok_or_else(|| {
+        RusticolError::integrity("recurrence direct source-domain ID is out of bounds")
+    })?;
+    if let Some(previous) = domain.insert(key, spec)
+        && previous != spec
+    {
+        return Err(RusticolError::integrity(
+            "recurrence source domain maps one dispatch key to different SourceIR semantics",
+        ));
+    }
+    Ok(())
+}
+
+fn direct_source_template_spec(
+    source: &RecurrenceSourceTemplate,
+    leg: &RecurrenceExternalLeg,
+    metadata: &RecurrenceRuntimeMetadata,
+    runtime_parameter_slots: &BTreeMap<String, RuntimeParameterSlots>,
+    parameter_count: u32,
+) -> RusticolResult<DirectSourceTemplateSpec> {
+    if source.source_ir.identity.pdg_label != leg.outgoing_pdg {
+        return Err(RusticolError::integrity(
+            "recurrence SourceIR particle disagrees with its external leg",
+        ));
+    }
+    let crossing = if leg.is_initial {
+        &source.crossing
+    } else {
+        &IDENTITY_RECURRENCE_CROSSING
+    };
+    let helicity = source
+        .helicity
+        .checked_mul(crossing.helicity_factor)
+        .ok_or_else(|| RusticolError::integrity("recurrence source helicity overflows"))?;
+    let chirality = source
+        .chirality
+        .checked_mul(crossing.chirality_factor)
+        .ok_or_else(|| RusticolError::integrity("recurrence source chirality overflows"))?;
+    let spin_state_class = source
+        .spin_state
+        .checked_mul(crossing.spin_state_factor)
+        .ok_or_else(|| RusticolError::integrity("recurrence source spin state overflows"))?;
+    let family = direct_source_family(&source.source_ir)?;
+    let orientation = match source.source_ir.identity.orientation {
+        RecurrenceSourceOrientation::Particle => DirectSourceOrientation::Particle,
+        RecurrenceSourceOrientation::Antiparticle => DirectSourceOrientation::Antiparticle,
+        RecurrenceSourceOrientation::SelfConjugate => DirectSourceOrientation::SelfConjugate,
+    };
+    let mass_parameter_index = source
+        .source_ir
+        .mass_parameter
+        .as_deref()
+        .map(|name| {
+            prepared_parameter_index(
+                name,
+                runtime_parameter_slots,
+                &metadata.parameter_projection,
+                parameter_count,
+            )
+        })
+        .transpose()?;
+    if mass_parameter_index.is_none()
+        && metadata
+            .particle_masses
+            .iter()
+            .find(|mass| mass.outgoing_pdg == leg.outgoing_pdg)
+            .is_some_and(|mass| mass.mass != 0.0)
+    {
+        return Err(RusticolError::compatibility(
+            "massive recurrence SourceIR has no prepared mass-parameter slot",
+        ));
+    }
+    Ok(DirectSourceTemplateSpec {
+        spin_state_class,
+        family,
+        orientation,
+        helicity,
+        chirality,
+        mass_parameter_index,
+    })
+}
+
+const IDENTITY_RECURRENCE_CROSSING: RecurrenceGenericCrossingIr = RecurrenceGenericCrossingIr {
+    momentum_transform: RecurrenceMomentumTransform::Identity,
+    helicity_factor: 1,
+    chirality_factor: 1,
+    spin_state_factor: 1,
+    phase: [1.0, 0.0],
+};
+
+fn direct_source_family(
+    source: &RecurrenceGenericSourceIr,
+) -> RusticolResult<DirectSourceWavefunctionFamily> {
+    match (
+        source.statistics,
+        source.wavefunction_family,
+        source.component_dimension,
+    ) {
+        (RecurrenceParticleStatistics::Boson, RecurrenceWavefunctionFamily::Scalar, 1) => {
+            Ok(DirectSourceWavefunctionFamily::Scalar)
+        }
+        (RecurrenceParticleStatistics::Fermion, RecurrenceWavefunctionFamily::Fermion, 2) => {
+            Ok(DirectSourceWavefunctionFamily::WeylFermion)
+        }
+        (RecurrenceParticleStatistics::Fermion, RecurrenceWavefunctionFamily::Fermion, 4) => {
+            Ok(DirectSourceWavefunctionFamily::DiracFermion)
+        }
+        (RecurrenceParticleStatistics::Boson, RecurrenceWavefunctionFamily::Vector, 4) => {
+            Ok(DirectSourceWavefunctionFamily::Vector)
+        }
+        (RecurrenceParticleStatistics::Boson, RecurrenceWavefunctionFamily::Spin2, 16) => {
+            Ok(DirectSourceWavefunctionFamily::Spin2)
+        }
+        (_, RecurrenceWavefunctionFamily::Ghost, _)
+        | (_, RecurrenceWavefunctionFamily::Auxiliary, _) => Err(RusticolError::compatibility(
+            "Direct-Arena recurrence does not yet support ghost or auxiliary external sources",
+        )),
+        _ => Err(RusticolError::integrity(
+            "recurrence SourceIR statistics, family, and component dimension are incompatible",
+        )),
+    }
+}
+
+fn prepared_parameter_index(
+    name: &str,
+    runtime_parameter_slots: &BTreeMap<String, RuntimeParameterSlots>,
+    projection: &[RecurrenceParameterProjection],
+    parameter_count: u32,
+) -> RusticolResult<u32> {
+    let runtime_slot = runtime_parameter_slots
+        .get(name)
+        .ok_or_else(|| {
+            RusticolError::integrity(format!(
+                "recurrence source mass parameter {name:?} has no runtime projection"
+            ))
+        })?
+        .real;
+    let row = projection
+        .iter()
+        .find(|row| row.runtime_slot as usize == runtime_slot && row.component == 0)
+        .ok_or_else(|| {
+            RusticolError::integrity(
+                "recurrence source mass parameter has no real prepared projection",
+            )
+        })?;
+    if row.runtime_name != name {
+        return Err(RusticolError::integrity(
+            "recurrence source mass projection is not its real component",
+        ));
+    }
+    let prepared = row.prepared_parameter_id.ok_or_else(|| {
+        RusticolError::compatibility(format!(
+            "recurrence source mass parameter {name:?} has no prepared parameter slot"
+        ))
+    })?;
+    if prepared >= parameter_count {
+        return Err(RusticolError::integrity(
+            "recurrence source mass prepared slot exceeds the direct plan",
+        ));
+    }
+    Ok(prepared)
+}
+
+pub(super) fn runtime_parameter_slots(
+    parameters: &[GenericRuntimeModelParameterManifest],
+) -> RusticolResult<BTreeMap<String, RuntimeParameterSlots>> {
+    let mut result = BTreeMap::new();
+    let mut complex = BTreeMap::<String, (Option<usize>, Option<usize>)>::new();
+    for parameter in parameters {
+        if let Some(name) = &parameter.runtime_name {
+            let slots = complex.entry(name.clone()).or_default();
+            let target = match parameter.complex_component.as_deref() {
+                Some("real") => &mut slots.0,
+                Some("imag") => &mut slots.1,
+                _ => {
+                    return Err(RusticolError::integrity(
+                        "recurrence complex parameter lacks component metadata",
+                    ));
+                }
+            };
+            if target.replace(parameter.parameter_index).is_some() {
+                return Err(RusticolError::integrity(
+                    "recurrence complex parameter repeats a component",
+                ));
+            }
+        } else if result
+            .insert(
+                parameter.name.clone(),
+                RuntimeParameterSlots {
+                    real: parameter.parameter_index,
+                    imaginary: None,
+                },
+            )
+            .is_some()
+        {
+            return Err(RusticolError::integrity(
+                "recurrence runtime parameter names are not unique",
+            ));
+        }
+    }
+    for (name, (real, imaginary)) in complex {
+        let real = real.ok_or_else(|| {
+            RusticolError::integrity("recurrence complex parameter lacks a real component")
+        })?;
+        if result
+            .insert(name, RuntimeParameterSlots { real, imaginary })
+            .is_some()
+        {
+            return Err(RusticolError::integrity(
+                "recurrence runtime parameter names conflict",
+            ));
+        }
+    }
+    Ok(result)
+}
+
+pub(super) fn decode_sha256(value: &str) -> RusticolResult<[u8; 32]> {
+    if value.len() != 64 {
+        return Err(RusticolError::integrity(
+            "recurrence SHA-256 has an invalid encoded length",
+        ));
+    }
+    let mut output = [0u8; 32];
+    for (index, byte) in output.iter_mut().enumerate() {
+        *byte = u8::from_str_radix(&value[index * 2..index * 2 + 2], 16).map_err(|_| {
+            RusticolError::integrity("recurrence SHA-256 is not lowercase hexadecimal")
+        })?;
+    }
+    Ok(output)
+}
+
+#[cfg(test)]
+mod binding_decode_tests {
+    use super::super::recurrence_process_pack::{
+        ProcessDirectExecutorBinding, ProcessIntrinsicExecutor, ProcessJitExecutor,
+        ProcessNativeExecutor,
+    };
+    use super::{
+        DirectSourceDispatchDomainSpec, DirectSourceDispatchKey, DirectSourceDispatchVariantSpec,
+        DirectSourceOrientation, DirectSourceTemplateSpec, DirectSourceWavefunctionFamily,
+        OnTheFlySourceExecutionSpecV1, OnTheFlySourceOrientationV1,
+        OnTheFlySourceWavefunctionFamilyV1, RecurrenceExternalLeg, RecurrenceGenericCrossingIr,
+        RecurrenceGenericParticleIdentityIr, RecurrenceGenericSourceIr,
+        RecurrenceMomentumTransform, RecurrenceNormalization, RecurrenceParameterProjection,
+        RecurrenceParticleMass, RecurrenceParticleStatistics, RecurrenceRuntimeMetadata,
+        RecurrenceRuntimeParameter, RecurrenceSourceOrientation, RecurrenceSourceTemplate,
+        RecurrenceWavefunctionFamily, RuntimeParameterSlots,
+        build_on_the_fly_source_domains_from_specs, companion_helicity_coefficient_is_canonical,
+        invert_replay_helicity_map, process_binding_requires_evaluator_payloads, read_u64_values,
+        recurrence_ready_needs_evaluator_payloads, validate_ready_source_domain_shape,
+        validate_recurrence_parameter_runtime_parts,
+    };
+    #[cfg(feature = "on-the-fly-test-support")]
+    use super::{OnTheFlyQueryTraceCacheV1, validate_on_the_fly_probe_outputs};
+    use std::collections::BTreeMap;
+
+    #[test]
+    fn execution_diagnostic_inverts_nonidentity_replay_helicity_map() {
+        // The replay map is representative ID -> public ID. Public helicity
+        // zero is therefore represented by ID one, not by the same index.
+        assert_eq!(invert_replay_helicity_map(17, &[2, 0, 1], 0).unwrap(), 1);
+    }
+
+    #[test]
+    fn process_ready_evaluator_payload_predicate_is_exhaustive() {
+        assert!(!process_binding_requires_evaluator_payloads(
+            &ProcessDirectExecutorBinding::Source
+        ));
+        assert!(!process_binding_requires_evaluator_payloads(
+            &ProcessDirectExecutorBinding::Intrinsic(ProcessIntrinsicExecutor {
+                runtime_template: "identity-finalizer-v1".into(),
+                scale: None,
+            })
+        ));
+        assert!(process_binding_requires_evaluator_payloads(
+            &ProcessDirectExecutorBinding::Jit(ProcessJitExecutor {
+                optimization_level: 2,
+                plane_compression: true,
+                source_application_sha256: [0; 32],
+                source_application_path: "application.bin".into(),
+                source_application_abi: "test".into(),
+                parameter_bindings: Vec::new(),
+                input_plane_projections: Vec::new(),
+                scalar_projections: Vec::new(),
+                output_alias_inputs: Vec::new(),
+            })
+        ));
+        assert!(process_binding_requires_evaluator_payloads(
+            &ProcessDirectExecutorBinding::Native(ProcessNativeExecutor {
+                prepared_kernel_id: 0,
+                library_path: "kernel.so".into(),
+                native_entry_point: "kernel".into(),
+                coupling: None,
+            })
+        ));
+    }
+
+    #[test]
+    fn process_ready_container_need_skips_plain_intrinsic_runtime() {
+        assert!(!recurrence_ready_needs_evaluator_payloads(
+            false, false, false
+        ));
+        for flags in [
+            (true, false, false),
+            (false, true, false),
+            (false, false, true),
+        ] {
+            assert!(recurrence_ready_needs_evaluator_payloads(
+                flags.0, flags.1, flags.2
+            ));
+        }
+    }
+
+    #[test]
+    fn process_ready_parameter_schema_rejects_manifest_parity_drift() {
+        let defaults = vec![[1.0, 2.0]];
+        let projection = vec![
+            RecurrenceParameterProjection {
+                runtime_slot: 0,
+                runtime_name: "Z".into(),
+                parameter_template_id: 0,
+                prepared_parameter_id: Some(0),
+                component: 0,
+            },
+            RecurrenceParameterProjection {
+                runtime_slot: 1,
+                runtime_name: "Z".into(),
+                parameter_template_id: 0,
+                prepared_parameter_id: Some(0),
+                component: 1,
+            },
+        ];
+        let parameters = vec![
+            RecurrenceRuntimeParameter {
+                name: "Z.real".into(),
+                kind: "external_parameter_component".into(),
+                parameter_index: 0,
+                default: 1.0,
+                runtime_name: Some("Z".into()),
+                complex_component: Some("real".into()),
+            },
+            RecurrenceRuntimeParameter {
+                name: "Z.imag".into(),
+                kind: "external_parameter_component".into(),
+                parameter_index: 1,
+                default: 2.0,
+                runtime_name: Some("Z".into()),
+                complex_component: Some("imag".into()),
+            },
+        ];
+        validate_recurrence_parameter_runtime_parts(&parameters, &defaults, &projection, 1)
+            .unwrap();
+
+        let mut malformed = parameters.clone();
+        malformed[1].default = 3.0;
+        let error =
+            validate_recurrence_parameter_runtime_parts(&malformed, &defaults, &projection, 1)
+                .expect_err("process-ready defaults must remain bound to prepared defaults");
+        assert!(error.to_string().contains("prepared default"));
+
+        let mut malformed = projection.clone();
+        malformed[1].runtime_slot = 7;
+        let error =
+            validate_recurrence_parameter_runtime_parts(&parameters, &defaults, &malformed, 1)
+                .expect_err("process-ready projection slots must remain dense");
+        assert!(error.to_string().contains("dense"));
+    }
+
+    #[test]
+    fn process_ready_sources_reject_key_or_mass_drift_from_plan() {
+        let template = DirectSourceTemplateSpec {
+            spin_state_class: 7,
+            family: DirectSourceWavefunctionFamily::WeylFermion,
+            orientation: DirectSourceOrientation::Particle,
+            helicity: 1,
+            chirality: -1,
+            mass_parameter_index: Some(0),
+        };
+        let expected = vec![BTreeMap::from([(
+            DirectSourceDispatchKey::SpinStateClass(7),
+            7,
+        )])];
+        let valid = vec![DirectSourceDispatchDomainSpec {
+            variants: vec![DirectSourceDispatchVariantSpec {
+                key: DirectSourceDispatchKey::SpinStateClass(7),
+                template,
+            }],
+        }];
+        validate_ready_source_domain_shape(&valid, &expected, 1).unwrap();
+
+        let mut malformed_key = valid.clone();
+        malformed_key[0].variants[0].key = DirectSourceDispatchKey::SpinStateClass(8);
+        let error = validate_ready_source_domain_shape(&malformed_key, &expected, 1)
+            .expect_err("a process-ready source key must be plan-referenced");
+        assert!(error.to_string().contains("plan keys"));
+
+        let mut malformed_mass = valid;
+        malformed_mass[0].variants[0].template.mass_parameter_index = Some(1);
+        let error = validate_ready_source_domain_shape(&malformed_mass, &expected, 1)
+            .expect_err("a process-ready source mass slot must be plan-bounded");
+        assert!(error.to_string().contains("out of bounds"));
+    }
+
+    #[test]
+    fn companion_helicity_coefficients_fail_closed_outside_physical_unit_weights() {
+        assert!(companion_helicity_coefficient_is_canonical(false, 1.0));
+        assert!(companion_helicity_coefficient_is_canonical(true, 0.0));
+        for (structural_zero, coefficient) in
+            [(false, 0.0), (false, 2.0), (true, 1.0), (true, f64::NAN)]
+        {
+            assert!(!companion_helicity_coefficient_is_canonical(
+                structural_zero,
+                coefficient,
+            ));
+        }
+    }
+
+    #[cfg(feature = "on-the-fly-test-support")]
+    #[test]
+    fn on_the_fly_query_cache_counts_builds_and_real_digest_lookups() {
+        let digest = SemanticDigest::new([7; 32]).unwrap();
+        let mut cache = OnTheFlyQueryTraceCacheV1::default();
+
+        cache.insert_built(digest, 41_u32).unwrap();
+        assert_eq!(cache.counts(), (1, 0));
+        assert_eq!(*cache.prepared(digest).unwrap(), 41);
+        assert_eq!(cache.counts(), (1, 0));
+        assert_eq!(*cache.lookup(digest).unwrap(), 41);
+        assert_eq!(*cache.lookup(digest).unwrap(), 41);
+        assert_eq!(cache.counts(), (1, 2));
+
+        let error = cache
+            .insert_built(digest, 99)
+            .expect_err("one query digest must not be rebuilt");
+        assert!(error.to_string().contains("repeated a fresh query digest"));
+        assert_eq!(*cache.prepared(digest).unwrap(), 41);
+        assert_eq!(cache.counts(), (1, 2));
+    }
+
+    #[cfg(feature = "on-the-fly-test-support")]
+    #[test]
+    fn on_the_fly_probe_rejects_non_finite_outputs() {
+        validate_on_the_fly_probe_outputs(&[[0.0, 1.0]], &[1.0]).unwrap();
+
+        let raw_error = validate_on_the_fly_probe_outputs(&[[f64::NAN, 1.0]], &[1.0])
+            .expect_err("non-finite raw amplitude must fail closed");
+        assert!(raw_error.to_string().contains("non-finite raw amplitude"));
+
+        let normalized_error = validate_on_the_fly_probe_outputs(&[[0.0, 1.0]], &[f64::INFINITY])
+            .expect_err("non-finite normalized value must fail closed");
+        assert!(
+            normalized_error
+                .to_string()
+                .contains("non-finite normalized value")
+        );
+    }
+
+    fn source_ir(
+        name: &str,
+        pdg: i32,
+        family: RecurrenceWavefunctionFamily,
+        statistics: RecurrenceParticleStatistics,
+        dimension: u64,
+        mass_parameter: Option<&str>,
+    ) -> RecurrenceGenericSourceIr {
+        RecurrenceGenericSourceIr {
+            identity: RecurrenceGenericParticleIdentityIr {
+                canonical_id: name.into(),
+                species_id: name.into(),
+                anti_canonical_id: format!("anti-{name}"),
+                display_name: name.into(),
+                anti_display_name: format!("anti-{name}"),
+                pdg_label: pdg,
+                anti_pdg_label: -pdg,
+                orientation: if statistics == RecurrenceParticleStatistics::Fermion {
+                    RecurrenceSourceOrientation::Particle
+                } else {
+                    RecurrenceSourceOrientation::SelfConjugate
+                },
+                self_conjugate: statistics != RecurrenceParticleStatistics::Fermion,
+            },
+            statistics,
+            wavefunction_family: family,
+            component_dimension: dimension,
+            states: Vec::new(),
+            crossing: RecurrenceGenericCrossingIr {
+                momentum_transform: RecurrenceMomentumTransform::Identity,
+                helicity_factor: 1,
+                chirality_factor: 1,
+                spin_state_factor: 1,
+                phase: [1.0, 0.0],
+            },
+            basis: "test".into(),
+            mass_parameter: mass_parameter.map(str::to_owned),
+            width_parameter: None,
+        }
+    }
+
+    fn source_domain_metadata() -> RecurrenceRuntimeMetadata {
+        RecurrenceRuntimeMetadata {
+            public_color_flows: Vec::new(),
+            runtime_parameters: Vec::new(),
+            prepared_parameter_defaults: vec![[0.0, 0.0]; 4],
+            parameter_projection: vec![RecurrenceParameterProjection {
+                runtime_slot: 0,
+                runtime_name: "MF".into(),
+                parameter_template_id: 0,
+                prepared_parameter_id: Some(3),
+                component: 0,
+            }],
+            source_templates: vec![
+                RecurrenceSourceTemplate {
+                    source_template_id: 0,
+                    _current_state_template_id: 0,
+                    dimension: 2,
+                    helicity: -1,
+                    chirality: 1,
+                    spin_state: 7,
+                    source_ir: source_ir(
+                        "f",
+                        1,
+                        RecurrenceWavefunctionFamily::Fermion,
+                        RecurrenceParticleStatistics::Fermion,
+                        2,
+                        Some("MF"),
+                    ),
+                    crossing: RecurrenceGenericCrossingIr {
+                        momentum_transform: RecurrenceMomentumTransform::NegateFourMomentum,
+                        helicity_factor: -1,
+                        chirality_factor: -1,
+                        spin_state_factor: 1,
+                        phase: [1.0, 0.0],
+                    },
+                },
+                RecurrenceSourceTemplate {
+                    source_template_id: 2,
+                    _current_state_template_id: 2,
+                    dimension: 1,
+                    helicity: 0,
+                    chirality: 0,
+                    spin_state: 0,
+                    source_ir: source_ir(
+                        "s",
+                        25,
+                        RecurrenceWavefunctionFamily::Scalar,
+                        RecurrenceParticleStatistics::Boson,
+                        1,
+                        None,
+                    ),
+                    crossing: RecurrenceGenericCrossingIr {
+                        momentum_transform: RecurrenceMomentumTransform::Identity,
+                        helicity_factor: 1,
+                        chirality_factor: 1,
+                        spin_state_factor: 1,
+                        phase: [1.0, 0.0],
+                    },
+                },
+            ],
+            external_legs: vec![
+                RecurrenceExternalLeg {
+                    source_slot: 0,
+                    public_label: 0,
+                    physical_pdg: 1,
+                    outgoing_pdg: 1,
+                    is_initial: true,
+                },
+                RecurrenceExternalLeg {
+                    source_slot: 1,
+                    public_label: 1,
+                    physical_pdg: 25,
+                    outgoing_pdg: 25,
+                    is_initial: false,
+                },
+                RecurrenceExternalLeg {
+                    source_slot: 2,
+                    public_label: 2,
+                    physical_pdg: 1,
+                    outgoing_pdg: 1,
+                    is_initial: false,
+                },
+            ],
+            particle_masses: vec![RecurrenceParticleMass {
+                outgoing_pdg: 1,
+                mass: 2.0,
+            }],
+            normalization: RecurrenceNormalization {
+                color_accuracy: "lc".into(),
+                color_factor: 1.0,
+                average_factor: 1.0,
+                identical_factor: 1.0,
+                global_coupling_factor: 1.0,
+                qcd_coupling_power: None,
+                electroweak_coupling_power: None,
+                couplings_in_stage_evaluators: true,
+                coupling_policy: "test".into(),
+            },
+            color_contraction: None,
+        }
+    }
+
+    fn crossed_fermion(
+        source_slot: u32,
+        helicity: i32,
+        chirality: i32,
+    ) -> OnTheFlySourceExecutionSpecV1 {
+        OnTheFlySourceExecutionSpecV1 {
+            source_slot,
+            source_template_id: 0,
+            spin_state_class: 7,
+            family: OnTheFlySourceWavefunctionFamilyV1::WeylFermion,
+            orientation: OnTheFlySourceOrientationV1::Particle,
+            helicity,
+            chirality,
+            prepared_mass_parameter_slot: Some(3),
+        }
+    }
+
+    fn scalar_source() -> OnTheFlySourceExecutionSpecV1 {
+        OnTheFlySourceExecutionSpecV1 {
+            source_slot: 1,
+            source_template_id: 2,
+            spin_state_class: 0,
+            family: OnTheFlySourceWavefunctionFamilyV1::Scalar,
+            orientation: OnTheFlySourceOrientationV1::SelfConjugate,
+            helicity: 0,
+            chirality: 0,
+            prepared_mass_parameter_slot: None,
+        }
+    }
+
+    #[test]
+    fn truncated_support_words_return_an_artifact_error() {
+        let mut cursor = 0;
+        let error = read_u64_values(&[0; 7], &mut cursor, 1, "recurrence support mask")
+            .expect_err("truncated support words must be rejected");
+        assert!(
+            error
+                .to_string()
+                .contains("truncated recurrence support mask")
+        );
+        assert_eq!(cursor, 0);
+    }
+
+    #[test]
+    fn compact_sources_match_crossing_mass_and_sparse_inert_domains() {
+        let metadata = source_domain_metadata();
+        let slots = BTreeMap::from([(
+            "MF".into(),
+            RuntimeParameterSlots {
+                real: 0,
+                imaginary: None,
+            },
+        )]);
+        let fermion = crossed_fermion(0, 1, -1);
+        let domains = build_on_the_fly_source_domains_from_specs(
+            [fermion, fermion, scalar_source()],
+            4,
+            4,
+            &metadata,
+            &slots,
+        )
+        .unwrap();
+        assert_eq!(domains.len(), 4);
+        assert_eq!(domains[0].variants.len(), 1);
+        assert_eq!(
+            domains[0].variants[0].key,
+            DirectSourceDispatchKey::SpinStateClass(7)
+        );
+        let template = domains[0].variants[0].template;
+        assert_eq!(template.family, DirectSourceWavefunctionFamily::WeylFermion);
+        assert_eq!(template.orientation, DirectSourceOrientation::Particle);
+        assert_eq!((template.helicity, template.chirality), (1, -1));
+        assert_eq!(template.mass_parameter_index, Some(3));
+        assert_eq!(domains[1], domains[0]);
+        assert_eq!(domains[3], domains[0]);
+        assert_eq!(domains[2].variants.len(), 1);
+        assert_eq!(
+            domains[2].variants[0].template.family,
+            DirectSourceWavefunctionFamily::Scalar
+        );
+    }
+
+    #[test]
+    fn compact_source_without_prebound_mass_uses_authoritative_source_ir_slot() {
+        let metadata = source_domain_metadata();
+        let slots = BTreeMap::from([(
+            "MF".into(),
+            RuntimeParameterSlots {
+                real: 0,
+                imaginary: None,
+            },
+        )]);
+        let mut fermion = crossed_fermion(0, 1, -1);
+        fermion.prepared_mass_parameter_slot = None;
+
+        let domains =
+            build_on_the_fly_source_domains_from_specs([fermion], 4, 4, &metadata, &slots).unwrap();
+
+        assert_eq!(
+            domains[0].variants[0].template.mass_parameter_index,
+            Some(3)
+        );
+    }
+
+    #[test]
+    fn compact_source_rejects_conflicting_prebound_mass_slot() {
+        let metadata = source_domain_metadata();
+        let slots = BTreeMap::from([(
+            "MF".into(),
+            RuntimeParameterSlots {
+                real: 0,
+                imaginary: None,
+            },
+        )]);
+        let mut fermion = crossed_fermion(0, 1, -1);
+        fermion.prepared_mass_parameter_slot = Some(2);
+
+        let error = build_on_the_fly_source_domains_from_specs([fermion], 4, 4, &metadata, &slots)
+            .expect_err("an explicit compact mass slot must match SourceIR");
+
+        assert!(error.to_string().contains("prepared mass parameter slot"));
+    }
+
+    #[test]
+    fn compact_source_still_rejects_non_mass_semantic_mismatch() {
+        let metadata = source_domain_metadata();
+        let slots = BTreeMap::from([(
+            "MF".into(),
+            RuntimeParameterSlots {
+                real: 0,
+                imaginary: None,
+            },
+        )]);
+        let mut fermion = crossed_fermion(0, 1, -1);
+        fermion.helicity = -1;
+
+        let error = build_on_the_fly_source_domains_from_specs([fermion], 4, 4, &metadata, &slots)
+            .expect_err("compact helicity must remain exact");
+
+        assert!(error.to_string().contains("source helicity"));
+    }
+
+    #[test]
+    fn compact_sources_reject_one_key_with_conflicting_crossed_semantics() {
+        let metadata = source_domain_metadata();
+        let slots = BTreeMap::from([(
+            "MF".into(),
+            RuntimeParameterSlots {
+                real: 0,
+                imaginary: None,
+            },
+        )]);
+        let error = build_on_the_fly_source_domains_from_specs(
+            [crossed_fermion(0, 1, -1), crossed_fermion(2, -1, 1)],
+            4,
+            4,
+            &metadata,
+            &slots,
+        )
+        .expect_err("one dispatch key cannot have two crossed SourceIR meanings");
+        assert!(error.to_string().contains("maps one dispatch key"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_manifest.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_manifest.rs
new file mode 100644
index 0000000000..ca8eae7ae4
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_manifest.rs
@@ -0,0 +1,5054 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Bounded parsing and semantic validation for recurrence execution manifests.
+
+use crate::engine::{
+    RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+    SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+};
+use crate::recurrence::direct_backend::RECURRENCE_DIRECT_BACKEND_ABI;
+use crate::recurrence::template::RECURRENCE_TEMPLATE_INPUT_ABI;
+use crate::recurrence::{
+    CLOSURE_TARGET_DOMAIN_PROOF_KIND, RECURRENCE_BUILDER_INPUT_ABI,
+    RECURRENCE_COLOR_CONTRACTION_CODEC_ABI, RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER,
+    RECURRENCE_CONTRACTED_COLOR_CAPABILITY, RECURRENCE_DIRECT_SCHEDULE_MEMBER,
+    RECURRENCE_DIRECT_TEMPLATE_ABI, RECURRENCE_HELICITY_DISPATCH_ABI,
+    RECURRENCE_LC_COLOR_CAPABILITY, RECURRENCE_PLAN_ABI, RECURRENCE_RUNTIME_CAPABILITY,
+    RECURRENCE_RUNTIME_KIND, RECURRENCE_RUNTIME_LAYOUT_ABI, relation_certificate_algorithm,
+};
+use crate::{ArtifactProcess, PROCESS_ARTIFACT_SCHEMA_VERSION, RusticolError, RusticolResult};
+use bincode::Decode;
+#[cfg(any(feature = "python-generation-bridge", test))]
+use bincode::Encode;
+use serde::Deserialize;
+use serde_json::{Value, json};
+use sha2::{Digest, Sha256};
+use std::collections::BTreeSet;
+
+pub(super) const RECURRENCE_RUNTIME_STORAGE_ABI: &str = "pacbin-v1";
+pub(super) const RECURRENCE_RUNTIME_CONTAINER_KIND: &str =
+    "pyamplicol-recurrence-runtime-container";
+pub(super) const RECURRENCE_RUNTIME_CONTAINER_SCHEMA: u16 = 1;
+pub(super) const RECURRENCE_PROCESS_BINDING_ABI: &str = "pyamplicol-recurrence-process-binding-v4";
+pub(super) const RECURRENCE_PROCESS_BINDING_PATH: &str = "recurrence-binding.bin";
+pub(super) const RECURRENCE_HELICITY_SELECTOR_BINDING_PATH: &str = "helicity-selector-binding.bin";
+pub(super) const RECURRENCE_HELICITY_DISPATCH_PATH: &str = "recurrence-helicity-dispatch-v1.bin";
+pub(super) const RECURRENCE_HELICITY_SELECTOR_COMPANION_KIND: &str =
+    "pyamplicol-recurrence-helicity-selector-companion-v2";
+pub(super) const RECURRENCE_PRIMARY_LOCAL_COLOR_VIEW: &str = "primary-local-color-view-v1";
+pub(super) const RECURRENCE_COLOR_CONTRACTION_PATH: &str = "recurrence-color.bin";
+pub(super) const RECURRENCE_KERNEL_PACK_MANIFEST_PATH: &str = "model/eager-kernel-pack.json";
+pub(super) const RECURRENCE_KERNEL_PAYLOAD_ROOT: &str = "model/eager-kernels";
+
+const MAX_RELATION_DISCOVERY_SAMPLES: usize = 16;
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(crate) struct RecurrenceExecutionManifest {
+    pub(super) schema_version: u32,
+    pub(super) kind: String,
+    pub(super) required_runtime_capabilities: Vec<String>,
+    pub(super) process: String,
+    pub(super) key: String,
+    pub(super) color_accuracy: String,
+    pub(super) external_pdg_order: Vec<i32>,
+    pub(super) process_digest: Option<String>,
+    pub(super) builder_input_abi: String,
+    pub(super) recurrence_plan_abi: String,
+    pub(super) runtime_layout_abi: String,
+    pub(super) direct_template_abi: String,
+    pub(super) direct_backend_abi: String,
+    pub(super) compiled_model_digest: String,
+    pub(super) recurrence_template_catalog_digest: String,
+    pub(super) prepared_kernel_pack_digest: String,
+    pub(super) direct_template_catalog_digest: String,
+    pub(super) kernel_pack: RecurrenceKernelPackReference,
+    pub(super) runtime_options: RecurrenceRuntimeOptions,
+    pub(super) runtime_metadata: RecurrenceRuntimeMetadata,
+    pub(super) helicity_selector_companion: Option<RecurrenceHelicitySelectorCompanionManifest>,
+    pub(super) plan: RecurrencePlanSummary,
+    pub(super) recurrence_summary: RecurrenceSummary,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceKernelPackReference {
+    pub(super) manifest_path: String,
+    pub(super) payload_root: String,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRuntimeOptions {
+    pub(super) point_tile_size: u32,
+    pub(super) workspace_mib: u32,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrencePlanSummary {
+    pub(super) kind: String,
+    pub(super) builder_input_abi: String,
+    pub(super) recurrence_plan_abi: String,
+    pub(super) runtime_layout_abi: String,
+    pub(super) direct_template_abi: String,
+    pub(super) direct_backend_abi: String,
+    pub(super) builder_input_sha256: String,
+    pub(super) prepared_kernel_pack_digest: String,
+    pub(super) direct_template_catalog_digest: String,
+    pub(super) required_runtime_capabilities: Vec<String>,
+    pub(super) runtime_schedule: RecurrenceRuntimeContainer,
+    #[serde(default)]
+    pub(super) helicity_dispatch: Option<RecurrenceHelicityDispatchReference>,
+    pub(super) process_binding: RecurrenceProcessBinding,
+    pub(super) inspection_summary: RecurrenceInspectionSummary,
+}
+
+/// One pre-lowered physical-colour schedule plus an exact runtime-helicity
+/// dispatch.  Physics and color storage remain owned by the enclosing
+/// recurrence process.
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceHelicitySelectorCompanionManifest {
+    pub(super) schema_version: u32,
+    pub(super) kind: String,
+    pub(super) process_digest: String,
+    pub(super) plan: RecurrencePlanSummary,
+    pub(super) color_contraction: RecurrenceHelicitySelectorColorView,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceHelicityDispatchReference {
+    pub(super) abi: String,
+    pub(super) path: String,
+    pub(super) size_bytes: u64,
+    pub(super) sha256: String,
+    pub(super) base_runtime_layout_digest: String,
+    pub(super) resolved_helicity_count: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceHelicitySelectorColorView {
+    pub(super) source: String,
+    pub(super) view: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceProcessBinding {
+    pub(super) abi: String,
+    pub(super) process_id: String,
+    pub(super) schedule_digest: String,
+    pub(super) native_schedule_semantic_digest: String,
+    pub(super) process_digest: String,
+    pub(super) process_semantic_digest: String,
+    pub(super) process_support_words: Vec<u64>,
+    pub(super) remap: RecurrenceProcessRemap,
+    pub(super) path: String,
+    pub(super) size_bytes: u64,
+    pub(super) sha256: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceProcessRemap {
+    pub(super) bijection_digest: String,
+    pub(super) source_slots: Vec<u32>,
+    pub(super) source_momentum_signs: Vec<i32>,
+    pub(super) source_helicity_signs: Vec<i32>,
+    pub(super) source_state_offsets: Vec<u32>,
+    pub(super) source_state_indices: Vec<u32>,
+    pub(super) public_flow_ids: Vec<u32>,
+    pub(super) physical_sector_ids: Vec<u32>,
+    pub(super) state_templates: RecurrenceSparseBijection,
+    pub(super) source_templates: RecurrenceSparseBijection,
+    pub(super) direct_executors: RecurrenceSparseBijection,
+    pub(super) parameter_slots: RecurrenceSparseBijection,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceSparseBijection {
+    pub(super) count: u32,
+    pub(super) changes: Vec<[u32; 2]>,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRuntimeContainer {
+    pub(super) kind: String,
+    pub(super) schema_version: u16,
+    pub(super) storage_abi: String,
+    pub(super) path: String,
+    pub(super) plan_member_path: String,
+    pub(super) size_bytes: u64,
+    pub(super) sha256: String,
+    pub(super) member_count: u64,
+    pub(super) unpacked_size_bytes: u64,
+    pub(super) index_sha256: String,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "kebab-case")]
+pub(super) enum RecurrenceLcFlowLayout {
+    TopologyReplay,
+    AllFlowUnion,
+    ContractedColorUnion,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "kebab-case")]
+pub(super) enum RecurrenceCacheFootprintPolicy {
+    SelectorActiveMaxV1,
+    PersistedArenaV1,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "kebab-case")]
+pub(super) enum RecurrencePeakContributionCountSemantics {
+    ResidentPendingContributionsV1,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceInspectionSummary {
+    pub(super) execution_mode: String,
+    pub(super) recurrence_plan_abi: String,
+    pub(super) runtime_layout_abi: String,
+    pub(super) direct_template_abi: String,
+    pub(super) process_id: String,
+    pub(super) lc_flow_layout: RecurrenceLcFlowLayout,
+    pub(super) parameter_count: u64,
+    pub(super) sector_count: u64,
+    pub(super) prepared_kernel_count: u64,
+    pub(super) direct_executor_count: u64,
+    pub(super) semantic_digest: String,
+    pub(super) schedule_digest: String,
+    pub(super) runtime_layout_digest: String,
+    pub(super) schedule: RecurrenceScheduleSummary,
+    #[serde(default)]
+    pub(super) selector_work_certificate: Option<RecurrenceSelectorWorkCertificate>,
+    pub(super) construction: RecurrenceConstructionSummary,
+    pub(super) direct_arena: RecurrenceDirectArenaSummary,
+    pub(super) runtime_container_member: RecurrenceRuntimeContainerMember,
+    #[serde(default)]
+    pub(super) color_projection_certificate: Option<RecurrenceColorProjectionCertificate>,
+    #[serde(default)]
+    pub(super) relation_discovery: Option<RecurrenceRelationDiscoverySummary>,
+    #[serde(default)]
+    pub(super) structural_zero_physical_sector_certificate:
+        Option<RecurrenceStructuralZeroPhysicalSectorCertificate>,
+    pub(super) generation_timings_seconds: RecurrenceGenerationTimings,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceStructuralZeroPhysicalSectorCertificate {
+    pub(super) proof_kind: String,
+    pub(super) semantic_digest: String,
+    pub(super) sector_count: u64,
+    pub(super) resolved_helicity_count: u64,
+    pub(super) certified_structural_zero_sector_count: u64,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceScheduleSummary {
+    pub(super) current_count: u64,
+    pub(super) source_row_count: u64,
+    pub(super) contribution_count: u64,
+    pub(super) finalization_count: u64,
+    pub(super) amplitude_destination_count: u64,
+    pub(super) closure_term_count: u64,
+    pub(super) replay_target_count: u64,
+    pub(super) retained_helicity_count: u64,
+    pub(super) resolved_helicity_count: u64,
+    pub(super) exact_factor_count: u64,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceSelectorPersistedUnion {
+    pub(super) current_count: u64,
+    pub(super) semantic_component_count: u64,
+    pub(super) source_row_count: u64,
+    pub(super) contribution_count: u64,
+    pub(super) finalization_count: u64,
+    pub(super) closure_count: u64,
+    pub(super) row_count: u64,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceSelectorRepresentative {
+    pub(super) representative_sector_id: u64,
+    pub(super) public_flow_count: u64,
+    pub(super) current_count: u64,
+    pub(super) semantic_component_count: u64,
+    pub(super) source_row_count: u64,
+    pub(super) contribution_count: u64,
+    pub(super) finalization_count: u64,
+    pub(super) closure_count: u64,
+    pub(super) amplitude_destination_count: u64,
+    pub(super) row_count: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceSelectorWorkCertificate {
+    pub(super) schema_version: u16,
+    pub(super) binding: String,
+    pub(super) persisted_union: RecurrenceSelectorPersistedUnion,
+    pub(super) representatives: Vec<RecurrenceSelectorRepresentative>,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceConstructionSummary {
+    pub(super) peak_current_count: u64,
+    pub(super) peak_contribution_count: u64,
+    // Typed deserialization authenticates the marker; publication audits
+    // decide whether an absent legacy marker is admissible evidence.
+    #[allow(dead_code)]
+    #[serde(default)]
+    pub(super) peak_contribution_count_semantics: Option<RecurrencePeakContributionCountSemantics>,
+    pub(super) peak_dynamic_color_state_count: u64,
+    pub(super) color_target_prune_count: u64,
+    pub(super) candidate_parent_pair_count: u64,
+    pub(super) peak_to_final_current_ratio: f64,
+    pub(super) peak_to_final_contribution_ratio: f64,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceDirectArenaSummary {
+    pub(super) semantic_component_count: u64,
+    pub(super) current_arena_components: u64,
+    pub(super) arena_component_reuse_count: u64,
+    pub(super) momentum_form_count: u64,
+    pub(super) selector_domain_count: u64,
+    #[serde(default)]
+    pub(super) cache_footprint_policy: Option<RecurrenceCacheFootprintPolicy>,
+    pub(super) row_group_count: u64,
+    pub(super) packed_input_bytes: u64,
+    pub(super) packed_output_bytes: u64,
+    pub(super) scatter_bytes: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRuntimeContainerMember {
+    pub(super) path: String,
+    pub(super) size_bytes: u64,
+    pub(super) sha256: String,
+    pub(super) container_size_bytes: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceColorProjectionCertificate {
+    pub(super) path: String,
+    pub(super) schema_version: u16,
+    pub(super) proof_kind: String,
+    pub(super) publishable: bool,
+    pub(super) size_bytes: u64,
+    pub(super) sha256: String,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "kebab-case")]
+pub(super) enum RecurrenceRelationDiscoveryMode {
+    Diagnostic,
+    CertifiedReuse,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRelationDiscoverySummary {
+    pub(super) schema_version: u16,
+    pub(super) requested_mode: RecurrenceRelationDiscoveryMode,
+    pub(super) state: String,
+    pub(super) scope: RecurrenceRelationDiscoveryScope,
+    pub(super) probe: RecurrenceRelationDiscoveryProbe,
+    pub(super) certificate_replay: RecurrenceRelationCertificateReplay,
+    pub(super) numerical_candidate_count: u64,
+    pub(super) uncertified_candidate_count: u64,
+    pub(super) rejected_hypothesis_count: u64,
+    pub(super) exact_certified_relation_count: u64,
+    pub(super) applied_relation_count: u64,
+    pub(super) interaction_evaluation_count_before: u64,
+    pub(super) interaction_evaluation_count_after: u64,
+    pub(super) interaction_evaluation_savings: u64,
+    pub(super) current_count_before: u64,
+    pub(super) current_count_after: u64,
+    pub(super) contribution_count_before: u64,
+    pub(super) contribution_count_after: u64,
+    pub(super) scale_copy_row_count: u64,
+    pub(super) certificates: Vec<RecurrenceRelationCertificateSample>,
+    pub(super) certificate_count: u64,
+    pub(super) certificates_truncated: bool,
+    pub(super) rejected_candidates: Vec<RecurrenceRelationRejectedCandidate>,
+    #[serde(default)]
+    pub(super) rejected_candidate_diagnostics: Option<RecurrenceRelationRejectedDiagnostics>,
+    pub(super) follow_up_boundary: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRelationRejectedDiagnostics {
+    pub(super) total_rejected_hypothesis_count: u64,
+    pub(super) retained_count: u64,
+    pub(super) truncated: bool,
+    pub(super) truncation_policy: String,
+    pub(super) retained_sha256: String,
+    pub(super) full_census_sha256: String,
+    pub(super) full_rejection_sha256: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRelationDiscoveryScope {
+    pub(super) execution_mode: String,
+    pub(super) color_accuracy: String,
+    pub(super) representation: String,
+    pub(super) lc_flow_layout: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRelationDiscoveryProbe {
+    pub(super) status: String,
+    pub(super) precision_digits: u32,
+    pub(super) probe_count: u32,
+    pub(super) verification_probe_count: u32,
+    pub(super) effective_projection_count: u32,
+    pub(super) seed: u64,
+    pub(super) deterministic: bool,
+    pub(super) candidate_only: bool,
+    pub(super) tested_hypothesis_count: u64,
+    pub(super) verification_rejected_count: u64,
+    pub(super) runtime_parameter_schema_sha256: Option<String>,
+    pub(super) candidate_observation_batch_sha256: Option<String>,
+    pub(super) verification_observation_batch_sha256: Option<String>,
+    pub(super) decision_sha256: Option<String>,
+    pub(super) rejection_decision_sha256: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRelationCertificateReplay {
+    pub(super) algorithm: String,
+    pub(super) status: String,
+    pub(super) certificate_set_sha256: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRelationCertificateSample {
+    pub(super) algorithm: String,
+    pub(super) current_id: u64,
+    pub(super) representative_id: u64,
+    pub(super) factor_exact_rational: RecurrenceRelationExactFactor,
+    pub(super) current_term_vector_sha256: String,
+    pub(super) representative_term_vector_sha256: String,
+    pub(super) proof_sha256: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRelationExactFactor {
+    pub(super) real_numerator: String,
+    pub(super) real_denominator: String,
+    pub(super) imag_numerator: String,
+    pub(super) imag_denominator: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRelationRejectedCandidate {
+    pub(super) reason: String,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceGenerationTimings {
+    pub(super) python_extraction: f64,
+    pub(super) catalog_authentication: f64,
+    pub(super) semantic_construction: f64,
+    pub(super) direct_lowering: f64,
+    pub(super) serialization: f64,
+    pub(super) native_total: f64,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceSummary {
+    pub(super) lc_flow_layout: RecurrenceLcFlowLayout,
+    pub(super) builder_input_abi: String,
+    pub(super) template_input_abi: String,
+    pub(super) current_count: u64,
+    pub(super) contribution_count: u64,
+    pub(super) closure_term_count: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRuntimeMetadata {
+    pub(super) public_color_flows: Vec<RecurrencePublicColorFlow>,
+    pub(super) runtime_parameters: Vec<RecurrenceRuntimeParameter>,
+    pub(super) prepared_parameter_defaults: Vec<[f64; 2]>,
+    pub(super) parameter_projection: Vec<RecurrenceParameterProjection>,
+    pub(super) source_templates: Vec<RecurrenceSourceTemplate>,
+    pub(super) external_legs: Vec<RecurrenceExternalLeg>,
+    pub(super) particle_masses: Vec<RecurrenceParticleMass>,
+    pub(super) normalization: RecurrenceNormalization,
+    pub(super) color_contraction: Option<RecurrenceColorContractionReference>,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceColorContractionReference {
+    pub(super) abi: String,
+    pub(super) path: String,
+    pub(super) size_bytes: u64,
+    pub(super) sha256: String,
+    pub(super) color_accuracy: String,
+    pub(super) storage: String,
+    pub(super) includes_color_factor: bool,
+    pub(super) group_count: u64,
+    pub(super) sector_count: u64,
+    pub(super) active_sector_count: u64,
+    pub(super) component_count: u64,
+    pub(super) destination_count: u64,
+    #[serde(default, deserialize_with = "deserialize_optional_u64_if_present")]
+    pub(super) materialized_destination_count: Option<u64>,
+    pub(super) entry_count: u64,
+    pub(super) logical_entry_count: u64,
+    pub(super) semantic_digest: String,
+    #[serde(default)]
+    pub(super) factorization: Option<RecurrenceColorFactorizationReference>,
+    #[serde(default)]
+    pub(super) fft_provenance: Option<RecurrenceColorFftProvenance>,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceColorFactorizationReference {
+    pub(super) kind: String,
+    pub(super) rank: u32,
+    pub(super) coset_count: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceColorFftProvenance {
+    pub(super) method: String,
+    pub(super) degree: u32,
+    pub(super) channel_count: u64,
+    pub(super) covered_local_group_count: u64,
+    pub(super) residual_group_count: u64,
+    pub(super) residual_entry_count: u64,
+    pub(super) raw_kernel_bytes: u64,
+    pub(super) transformed_kernel_bytes: u64,
+    pub(super) capability: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrencePublicColorFlow {
+    pub(super) public_id: String,
+    pub(super) construction_sector_id: u32,
+    pub(super) target_sector_id: u32,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceRuntimeParameter {
+    pub(super) name: String,
+    pub(super) kind: String,
+    pub(super) parameter_index: u32,
+    pub(super) default: f64,
+    #[serde(default)]
+    pub(super) runtime_name: Option<String>,
+    #[serde(default)]
+    pub(super) complex_component: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceParameterProjection {
+    pub(super) runtime_slot: u32,
+    pub(super) runtime_name: String,
+    pub(super) parameter_template_id: u32,
+    #[serde(deserialize_with = "deserialize_required_nullable_u32")]
+    pub(super) prepared_parameter_id: Option<u32>,
+    pub(super) component: u32,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceSourceTemplate {
+    pub(super) source_template_id: u32,
+    #[serde(rename = "current_state_template_id")]
+    pub(super) _current_state_template_id: u32,
+    pub(super) dimension: u64,
+    pub(super) helicity: i32,
+    pub(super) chirality: i32,
+    pub(super) spin_state: i32,
+    pub(super) source_ir: RecurrenceGenericSourceIr,
+    pub(super) crossing: RecurrenceGenericCrossingIr,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceExternalLeg {
+    pub(super) source_slot: u32,
+    pub(super) public_label: u32,
+    pub(super) physical_pdg: i32,
+    pub(super) outgoing_pdg: i32,
+    pub(super) is_initial: bool,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceParticleMass {
+    pub(super) outgoing_pdg: i32,
+    pub(super) mass: f64,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceNormalization {
+    pub(super) color_accuracy: String,
+    pub(super) color_factor: f64,
+    pub(super) average_factor: f64,
+    pub(super) identical_factor: f64,
+    pub(super) global_coupling_factor: f64,
+    #[serde(default, deserialize_with = "deserialize_optional_u64_if_present")]
+    pub(super) qcd_coupling_power: Option<u64>,
+    #[serde(default, deserialize_with = "deserialize_optional_u64_if_present")]
+    pub(super) electroweak_coupling_power: Option<u64>,
+    pub(super) couplings_in_stage_evaluators: bool,
+    pub(super) coupling_policy: String,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "kebab-case")]
+pub(super) enum RecurrenceSourceOrientation {
+    Particle,
+    Antiparticle,
+    SelfConjugate,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "lowercase")]
+pub(super) enum RecurrenceParticleStatistics {
+    Boson,
+    Fermion,
+    Ghost,
+    Auxiliary,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "lowercase")]
+pub(super) enum RecurrenceWavefunctionFamily {
+    Scalar,
+    Fermion,
+    Vector,
+    Spin2,
+    Ghost,
+    Auxiliary,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "kebab-case")]
+pub(super) enum RecurrenceMomentumTransform {
+    Identity,
+    NegateFourMomentum,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode, Eq, Ord, PartialEq, PartialOrd)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(untagged)]
+pub(super) enum RecurrenceSourceSpinState {
+    Scalar(i32),
+    Components(Vec<i32>),
+}
+
+#[derive(Clone, Debug, Deserialize, Decode, Eq, Ord, PartialEq, PartialOrd)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceGenericSourceStateIr {
+    pub(super) helicity: i32,
+    pub(super) chirality: i32,
+    pub(super) spin_state: RecurrenceSourceSpinState,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceGenericCrossingIr {
+    pub(super) momentum_transform: RecurrenceMomentumTransform,
+    pub(super) helicity_factor: i32,
+    pub(super) chirality_factor: i32,
+    pub(super) spin_state_factor: i32,
+    #[serde(deserialize_with = "deserialize_recurrence_phase")]
+    pub(super) phase: [f64; 2],
+}
+
+#[derive(Clone, Debug, Deserialize, Decode, Eq, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceGenericParticleIdentityIr {
+    pub(super) canonical_id: String,
+    pub(super) species_id: String,
+    pub(super) anti_canonical_id: String,
+    pub(super) display_name: String,
+    pub(super) anti_display_name: String,
+    pub(super) pdg_label: i32,
+    pub(super) anti_pdg_label: i32,
+    pub(super) orientation: RecurrenceSourceOrientation,
+    pub(super) self_conjugate: bool,
+}
+
+#[derive(Clone, Debug, Deserialize, Decode, PartialEq)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub(super) struct RecurrenceGenericSourceIr {
+    pub(super) identity: RecurrenceGenericParticleIdentityIr,
+    pub(super) statistics: RecurrenceParticleStatistics,
+    pub(super) wavefunction_family: RecurrenceWavefunctionFamily,
+    pub(super) component_dimension: u64,
+    pub(super) states: Vec<RecurrenceGenericSourceStateIr>,
+    pub(super) crossing: RecurrenceGenericCrossingIr,
+    pub(super) basis: String,
+    #[serde(deserialize_with = "deserialize_required_nullable_string")]
+    pub(super) mass_parameter: Option<String>,
+    #[serde(deserialize_with = "deserialize_required_nullable_string")]
+    pub(super) width_parameter: Option<String>,
+}
+
+impl RecurrenceExecutionManifest {
+    fn validate(&self, outer: &ArtifactProcess) -> RusticolResult<()> {
+        if self.schema_version != PROCESS_ARTIFACT_SCHEMA_VERSION
+            || self.kind != RECURRENCE_RUNTIME_KIND
+        {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported recurrence execution kind {:?} schema {}; regenerate the artifact",
+                self.kind, self.schema_version
+            )));
+        }
+        if self.process != outer.expression
+            || self.key != outer.id
+            || self.color_accuracy != outer.color_accuracy
+            || self.external_pdg_order != outer.external_pdgs
+        {
+            return Err(RusticolError::integrity(format!(
+                "recurrence execution manifest does not match outer process {:?}",
+                outer.id
+            )));
+        }
+        let uses_symmetric_group_fft = self
+            .runtime_metadata
+            .color_contraction
+            .as_ref()
+            .and_then(|reference| reference.factorization.as_ref())
+            .is_some_and(|factorization| factorization.kind == "symmetric-group-fourier");
+        let has_helicity_selector_companion = self.helicity_selector_companion.is_some();
+        validate_capabilities(
+            &self.required_runtime_capabilities,
+            &self.color_accuracy,
+            uses_symmetric_group_fft,
+            has_helicity_selector_companion,
+            "recurrence execution manifest",
+        )?;
+        validate_capabilities(
+            &outer.required_runtime_capabilities,
+            &self.color_accuracy,
+            uses_symmetric_group_fft,
+            has_helicity_selector_companion,
+            "outer recurrence process",
+        )?;
+        validate_direct_contract(
+            &self.builder_input_abi,
+            &self.recurrence_plan_abi,
+            &self.runtime_layout_abi,
+            &self.direct_template_abi,
+            &self.direct_backend_abi,
+            "recurrence execution manifest",
+        )?;
+        parse_sha256(&self.compiled_model_digest, "recurrence compiled model")?;
+        parse_sha256(
+            &self.recurrence_template_catalog_digest,
+            "recurrence template catalog",
+        )?;
+        parse_sha256(
+            &self.prepared_kernel_pack_digest,
+            "recurrence prepared-kernel pack",
+        )?;
+        parse_sha256(
+            &self.direct_template_catalog_digest,
+            "recurrence direct-template catalog",
+        )?;
+        if self.kernel_pack.manifest_path != RECURRENCE_KERNEL_PACK_MANIFEST_PATH
+            || self.kernel_pack.payload_root != RECURRENCE_KERNEL_PAYLOAD_ROOT
+        {
+            return Err(RusticolError::security(
+                "recurrence kernel-pack paths are not canonical",
+            ));
+        }
+        bounded_len("external PDG order", self.external_pdg_order.len())?;
+        if self.external_pdg_order.is_empty() {
+            return Err(RusticolError::artifact(
+                "recurrence execution manifest has no external particles",
+            ));
+        }
+        self.runtime_options.validate()?;
+        self.plan.validate(RecurrencePlanValidation {
+            process_key: &self.key,
+            prepared_kernel_pack_digest: &self.prepared_kernel_pack_digest,
+            direct_template_catalog_digest: &self.direct_template_catalog_digest,
+            color_accuracy: &self.color_accuracy,
+            uses_symmetric_group_fft,
+            has_helicity_selector_companion,
+            role: RecurrencePlanRole::Primary,
+        })?;
+        self.recurrence_summary.validate()?;
+        self.runtime_metadata.validate(
+            &self.external_pdg_order,
+            &self.color_accuracy,
+            &self.plan.inspection_summary,
+        )?;
+        if has_helicity_selector_companion != self.process_digest.is_some() {
+            return Err(RusticolError::integrity(
+                "recurrence process digest must appear exactly with its helicity-selector companion",
+            ));
+        }
+        if let Some(process_digest) = &self.process_digest {
+            parse_sha256(process_digest, "recurrence process")?;
+            if process_digest != &self.plan.process_binding.process_digest {
+                return Err(RusticolError::integrity(
+                    "recurrence companion process digest disagrees with the primary process binding",
+                ));
+            }
+        }
+        if let Some(companion) = &self.helicity_selector_companion {
+            companion.validate(self, uses_symmetric_group_fft)?;
+        }
+
+        let inspection = &self.plan.inspection_summary;
+        let remap = &self.plan.process_binding.remap;
+        if (inspection.lc_flow_layout != RecurrenceLcFlowLayout::ContractedColorUnion
+            && remap.public_flow_ids.len() != self.runtime_metadata.public_color_flows.len())
+            || remap.physical_sector_ids.len() as u64 != inspection.sector_count
+        {
+            return Err(RusticolError::integrity(
+                "recurrence process binding domains disagree with runtime metadata",
+            ));
+        }
+        let schedule = inspection.schedule;
+        if inspection.lc_flow_layout != self.recurrence_summary.lc_flow_layout
+            || schedule.current_count != self.recurrence_summary.current_count
+            || schedule.contribution_count != self.recurrence_summary.contribution_count
+            || schedule.closure_term_count != self.recurrence_summary.closure_term_count
+        {
+            return Err(RusticolError::integrity(
+                "recurrence inspection counts disagree with the recurrence summary",
+            ));
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum RecurrencePlanRole {
+    Primary,
+    HelicitySelector,
+}
+
+struct RecurrencePlanValidation<'a> {
+    process_key: &'a str,
+    prepared_kernel_pack_digest: &'a str,
+    direct_template_catalog_digest: &'a str,
+    color_accuracy: &'a str,
+    uses_symmetric_group_fft: bool,
+    has_helicity_selector_companion: bool,
+    role: RecurrencePlanRole,
+}
+
+impl RecurrenceRuntimeOptions {
+    fn validate(self) -> RusticolResult<()> {
+        if self.point_tile_size == 0 {
+            return Err(RusticolError::artifact(
+                "recurrence point_tile_size must be positive",
+            ));
+        }
+        if self.workspace_mib == 0 {
+            return Err(RusticolError::artifact(
+                "recurrence workspace_mib must be positive",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrencePlanSummary {
+    fn validate(&self, validation: RecurrencePlanValidation<'_>) -> RusticolResult<()> {
+        let RecurrencePlanValidation {
+            process_key,
+            prepared_kernel_pack_digest,
+            direct_template_catalog_digest,
+            color_accuracy,
+            uses_symmetric_group_fft,
+            has_helicity_selector_companion,
+            role,
+        } = validation;
+        if self.kind != RECURRENCE_RUNTIME_KIND {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported recurrence plan kind {:?}",
+                self.kind
+            )));
+        }
+        validate_direct_contract(
+            &self.builder_input_abi,
+            &self.recurrence_plan_abi,
+            &self.runtime_layout_abi,
+            &self.direct_template_abi,
+            &self.direct_backend_abi,
+            "nested recurrence plan",
+        )?;
+        parse_sha256(&self.builder_input_sha256, "recurrence builder input")?;
+        parse_sha256(
+            &self.prepared_kernel_pack_digest,
+            "nested recurrence prepared-kernel pack",
+        )?;
+        parse_sha256(
+            &self.direct_template_catalog_digest,
+            "nested recurrence direct-template catalog",
+        )?;
+        if self.prepared_kernel_pack_digest != prepared_kernel_pack_digest {
+            return Err(RusticolError::integrity(
+                "recurrence prepared-kernel pack digest differs between execution and plan metadata",
+            ));
+        }
+        if self.direct_template_catalog_digest != direct_template_catalog_digest {
+            return Err(RusticolError::integrity(
+                "recurrence direct-template catalog digest differs between execution and plan metadata",
+            ));
+        }
+        validate_capabilities(
+            &self.required_runtime_capabilities,
+            color_accuracy,
+            uses_symmetric_group_fft,
+            has_helicity_selector_companion,
+            "nested recurrence plan",
+        )?;
+        if self.helicity_dispatch.is_some() != (role == RecurrencePlanRole::HelicitySelector) {
+            return Err(RusticolError::integrity(match role {
+                RecurrencePlanRole::Primary => {
+                    "primary recurrence plan must not carry a helicity dispatch"
+                }
+                RecurrencePlanRole::HelicitySelector => {
+                    "recurrence helicity-selector plan requires a helicity dispatch"
+                }
+            }));
+        }
+        self.runtime_schedule.validate()?;
+        let binding_path = match role {
+            RecurrencePlanRole::Primary => RECURRENCE_PROCESS_BINDING_PATH,
+            RecurrencePlanRole::HelicitySelector => RECURRENCE_HELICITY_SELECTOR_BINDING_PATH,
+        };
+        self.process_binding.validate(process_key, binding_path)?;
+        self.inspection_summary
+            .validate(process_key, color_accuracy)?;
+        let schedule_identity_matches = match role {
+            RecurrencePlanRole::Primary => {
+                self.process_binding.schedule_digest == self.inspection_summary.schedule_digest
+            }
+            RecurrencePlanRole::HelicitySelector => {
+                self.process_binding.native_schedule_semantic_digest
+                    == self.inspection_summary.schedule_digest
+            }
+        };
+        if !schedule_identity_matches
+            || self.process_binding.process_semantic_digest
+                != self.inspection_summary.semantic_digest
+            || self.process_binding.process_semantic_digest != self.builder_input_sha256
+        {
+            return Err(RusticolError::integrity(
+                "recurrence schedule/process binding disagrees with inspection metadata",
+            ));
+        }
+        let expected_schedule_path = format!(
+            "recurrence/schedules/{}/recurrence-runtime.pacbin",
+            self.process_binding.schedule_digest
+        );
+        if self.runtime_schedule.path != expected_schedule_path {
+            return Err(RusticolError::integrity(
+                "recurrence root schedule path disagrees with its binding digest",
+            ));
+        }
+        if let Some(dispatch) = self.helicity_dispatch.as_ref() {
+            dispatch.validate(&self.process_binding, &self.inspection_summary)?;
+        }
+        let member = &self.inspection_summary.runtime_container_member;
+        let certificate = self
+            .inspection_summary
+            .color_projection_certificate
+            .as_ref();
+        let expected_member_count = if certificate.is_some() { 2 } else { 1 };
+        let expected_unpacked_size_bytes =
+            certificate.map_or(Ok(member.size_bytes), |certificate| {
+                member
+                    .size_bytes
+                    .checked_add(certificate.size_bytes)
+                    .ok_or_else(|| {
+                        RusticolError::artifact("recurrence runtime member sizes overflow u64")
+                    })
+            })?;
+        if member.path != self.runtime_schedule.plan_member_path
+            || member.container_size_bytes != self.runtime_schedule.size_bytes
+            || self.runtime_schedule.member_count != expected_member_count
+            || self.runtime_schedule.unpacked_size_bytes != expected_unpacked_size_bytes
+        {
+            return Err(RusticolError::integrity(
+                "Direct-Arena v2 plan member metadata disagrees with its recurrence runtime container",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceHelicitySelectorCompanionManifest {
+    fn validate(
+        &self,
+        primary: &RecurrenceExecutionManifest,
+        uses_symmetric_group_fft: bool,
+    ) -> RusticolResult<()> {
+        if self.schema_version != 2 || self.kind != RECURRENCE_HELICITY_SELECTOR_COMPANION_KIND {
+            return Err(RusticolError::compatibility(
+                "unsupported persisted recurrence helicity-selector companion; regenerate the artifact",
+            ));
+        }
+        if !matches!(primary.color_accuracy.as_str(), "nlc" | "full") {
+            return Err(RusticolError::integrity(
+                "only contracted recurrence may carry a persisted helicity-selector companion",
+            ));
+        }
+        parse_sha256(&self.process_digest, "recurrence helicity-selector process")?;
+        if primary.process_digest.as_deref() != Some(self.process_digest.as_str())
+            || primary.plan.process_binding.process_digest != self.process_digest
+            || self.plan.process_binding.process_digest != self.process_digest
+        {
+            return Err(RusticolError::integrity(
+                "recurrence helicity-selector companion disagrees with the primary process digest",
+            ));
+        }
+
+        // The v4 binding payload authenticates the compiled-model and
+        // recurrence-template identities.  At the bounded manifest boundary,
+        // the shared process digest plus the two explicitly repeated pack
+        // identities prevent a selector plan from crossing model owners.
+        parse_sha256(
+            &primary.compiled_model_digest,
+            "primary recurrence compiled model",
+        )?;
+        parse_sha256(
+            &primary.recurrence_template_catalog_digest,
+            "primary recurrence template catalog",
+        )?;
+        self.plan.validate(RecurrencePlanValidation {
+            process_key: &primary.key,
+            prepared_kernel_pack_digest: &primary.prepared_kernel_pack_digest,
+            direct_template_catalog_digest: &primary.direct_template_catalog_digest,
+            color_accuracy: &primary.color_accuracy,
+            uses_symmetric_group_fft,
+            has_helicity_selector_companion: true,
+            role: RecurrencePlanRole::HelicitySelector,
+        })?;
+
+        let primary_inspection = &primary.plan.inspection_summary;
+        let inspection = &self.plan.inspection_summary;
+        let schedule = inspection.schedule;
+        if inspection.lc_flow_layout != RecurrenceLcFlowLayout::AllFlowUnion
+            || schedule.replay_target_count != 0
+            || schedule.amplitude_destination_count == 0
+            || schedule.amplitude_destination_count != inspection.sector_count
+            || self.plan.process_binding.remap.physical_sector_ids.len() as u64
+                != inspection.sector_count
+        {
+            return Err(RusticolError::integrity(
+                "recurrence helicity-selector plan is not a dense physical all-flow union",
+            ));
+        }
+        if schedule.resolved_helicity_count == 0
+            || schedule.resolved_helicity_count != schedule.retained_helicity_count
+            || schedule.resolved_helicity_count
+                != primary_inspection.schedule.retained_helicity_count
+        {
+            return Err(RusticolError::integrity(
+                "recurrence helicity-selector plan does not retain its full resolved-helicity domain",
+            ));
+        }
+        if inspection.prepared_kernel_count != primary_inspection.prepared_kernel_count
+            || inspection.direct_executor_count != primary_inspection.direct_executor_count
+            || self.plan.process_binding.process_support_words
+                != primary.plan.process_binding.process_support_words
+        {
+            return Err(RusticolError::integrity(
+                "recurrence helicity-selector model identities disagree with the primary recurrence plan",
+            ));
+        }
+
+        let primary_color = primary
+            .runtime_metadata
+            .color_contraction
+            .as_ref()
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "persisted recurrence helicity selection requires a primary color reducer",
+                )
+            })?;
+        self.color_contraction
+            .validate(primary_color, &primary.color_accuracy, inspection)?;
+        Ok(())
+    }
+}
+
+impl RecurrenceHelicityDispatchReference {
+    fn validate(
+        &self,
+        binding: &RecurrenceProcessBinding,
+        inspection: &RecurrenceInspectionSummary,
+    ) -> RusticolResult<()> {
+        if self.abi != RECURRENCE_HELICITY_DISPATCH_ABI {
+            return Err(unsupported_abi("recurrence helicity-dispatch", &self.abi));
+        }
+        parse_sha256(&self.sha256, "recurrence helicity-dispatch payload")?;
+        parse_sha256(
+            &self.base_runtime_layout_digest,
+            "recurrence helicity-dispatch base runtime layout",
+        )?;
+        if self.size_bytes == 0 || u32::try_from(self.resolved_helicity_count).is_err() {
+            return Err(RusticolError::artifact(
+                "recurrence helicity-dispatch size or resolved-helicity count is outside its wire domain",
+            ));
+        }
+        if self.base_runtime_layout_digest != inspection.runtime_layout_digest
+            || self.resolved_helicity_count != inspection.schedule.resolved_helicity_count
+            || self.resolved_helicity_count != inspection.schedule.retained_helicity_count
+        {
+            return Err(RusticolError::integrity(
+                "recurrence helicity dispatch disagrees with its base runtime layout or helicity domain",
+            ));
+        }
+        let expected_schedule_digest = recurrence_helicity_selector_schedule_digest(
+            &inspection.schedule_digest,
+            &self.sha256,
+        )?;
+        if binding.schedule_digest != expected_schedule_digest {
+            return Err(RusticolError::integrity(
+                "recurrence helicity-selector root digest does not bind its Direct plan and dispatch",
+            ));
+        }
+        let expected_path = format!(
+            "recurrence/schedules/{}/{}",
+            binding.schedule_digest, RECURRENCE_HELICITY_DISPATCH_PATH
+        );
+        if self.path != expected_path {
+            return Err(RusticolError::security(
+                "recurrence helicity-dispatch path is not canonical",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceHelicitySelectorColorView {
+    fn validate(
+        &self,
+        primary: &RecurrenceColorContractionReference,
+        color_accuracy: &str,
+        selector_inspection: &RecurrenceInspectionSummary,
+    ) -> RusticolResult<()> {
+        if self.source != "primary" || self.view != RECURRENCE_PRIMARY_LOCAL_COLOR_VIEW {
+            return Err(RusticolError::compatibility(
+                "unsupported recurrence helicity-selector color view",
+            ));
+        }
+        if primary.color_accuracy != color_accuracy
+            || !matches!(color_accuracy, "nlc" | "full")
+            || primary.abi != RECURRENCE_COLOR_CONTRACTION_CODEC_ABI
+        {
+            return Err(RusticolError::integrity(
+                "recurrence helicity-selector primary color view has the wrong owner",
+            ));
+        }
+        let factorization_kind = primary
+            .factorization
+            .as_ref()
+            .map(|factorization| factorization.kind.as_str());
+        let supported_reducer = matches!(
+            (primary.storage.as_str(), factorization_kind),
+            ("expanded", None)
+                | (
+                    "repeated",
+                    None | Some("klein-four-walsh") | Some("elementary-abelian-walsh")
+                )
+                | ("convolution-kernels", Some("symmetric-group-fourier"))
+        );
+        if !supported_reducer
+            || (primary.storage == "expanded" && primary.component_count != 1)
+            || primary.component_count == 0
+            || !primary.group_count.is_multiple_of(primary.component_count)
+            || primary.group_count / primary.component_count != selector_inspection.sector_count
+        {
+            return Err(RusticolError::integrity(
+                "recurrence helicity-selector primary local-color group shape or reducer mode is incompatible",
+            ));
+        }
+        Ok(())
+    }
+}
+
+fn recurrence_helicity_selector_schedule_digest(
+    base_schedule_digest: &str,
+    dispatch_sha256: &str,
+) -> RusticolResult<String> {
+    parse_sha256(
+        base_schedule_digest,
+        "recurrence helicity-selector base schedule",
+    )?;
+    parse_sha256(dispatch_sha256, "recurrence helicity-selector dispatch")?;
+    let payload = json!({
+        "base_schedule_digest": base_schedule_digest,
+        "contract": "pyamplicol-recurrence-helicity-selector-schedule-v1",
+        "helicity_dispatch": {
+            "abi": RECURRENCE_HELICITY_DISPATCH_ABI,
+            "sha256": dispatch_sha256,
+        },
+    });
+    let bytes = serde_json::to_vec(&payload).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not encode recurrence helicity-selector schedule identity: {error}"
+        ))
+    })?;
+    Ok(format!("{:x}", Sha256::digest(bytes)))
+}
+
+impl RecurrenceRuntimeContainer {
+    fn validate(&self) -> RusticolResult<()> {
+        if self.kind != RECURRENCE_RUNTIME_CONTAINER_KIND {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported recurrence runtime container kind {:?}",
+                self.kind
+            )));
+        }
+        if self.schema_version != RECURRENCE_RUNTIME_CONTAINER_SCHEMA {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported recurrence runtime container schema {}",
+                self.schema_version
+            )));
+        }
+        if self.storage_abi != RECURRENCE_RUNTIME_STORAGE_ABI {
+            return Err(unsupported_abi(
+                "recurrence runtime storage",
+                &self.storage_abi,
+            ));
+        }
+        let expected_prefix = "recurrence/schedules/";
+        let expected_suffix = "/recurrence-runtime.pacbin";
+        if !self.path.starts_with(expected_prefix)
+            || !self.path.ends_with(expected_suffix)
+            || self.path[expected_prefix.len()..self.path.len() - expected_suffix.len()].len() != 64
+            || self.path.contains("..")
+        {
+            return Err(RusticolError::security(
+                "recurrence root schedule path is not canonical",
+            ));
+        }
+        if self.plan_member_path != RECURRENCE_DIRECT_SCHEDULE_MEMBER {
+            return Err(RusticolError::security(format!(
+                "Direct-Arena v2 schedule member path must be exactly {RECURRENCE_DIRECT_SCHEDULE_MEMBER:?}"
+            )));
+        }
+        if !(1..=2).contains(&self.member_count) {
+            return Err(RusticolError::integrity(
+                "Direct-Arena v2 recurrence runtime container must declare one or two members",
+            ));
+        }
+        if self.size_bytes == 0 {
+            return Err(RusticolError::artifact(
+                "recurrence runtime container size must be positive",
+            ));
+        }
+        if self.unpacked_size_bytes == 0 || self.unpacked_size_bytes > self.size_bytes {
+            return Err(RusticolError::artifact(
+                "recurrence runtime unpacked size is outside canonical bounds",
+            ));
+        }
+        parse_sha256(&self.sha256, "recurrence runtime container")?;
+        parse_sha256(&self.index_sha256, "recurrence runtime index")?;
+        Ok(())
+    }
+}
+
+impl RecurrenceProcessBinding {
+    pub(super) fn native_schedule_semantic_digest(&self) -> &str {
+        &self.native_schedule_semantic_digest
+    }
+
+    fn validate(&self, process_key: &str, expected_path: &str) -> RusticolResult<()> {
+        if self.abi != RECURRENCE_PROCESS_BINDING_ABI || self.path != expected_path {
+            return Err(RusticolError::compatibility(
+                "unsupported recurrence process-binding contract",
+            ));
+        }
+        if self.process_id != process_key {
+            return Err(RusticolError::integrity(
+                "recurrence process binding has the wrong process ID",
+            ));
+        }
+        parse_sha256(&self.schedule_digest, "recurrence root schedule")?;
+        parse_sha256(
+            &self.native_schedule_semantic_digest,
+            "recurrence native schedule semantic digest",
+        )?;
+        parse_sha256(&self.process_digest, "recurrence process")?;
+        parse_sha256(
+            &self.process_semantic_digest,
+            "recurrence process semantic binding",
+        )?;
+        parse_sha256(&self.sha256, "recurrence process-binding payload")?;
+        self.remap.validate()?;
+        if self.process_support_words.is_empty()
+            || self.process_support_words.last() == Some(&0)
+            || self
+                .process_support_words
+                .iter()
+                .map(|word| word.count_ones())
+                .sum::<u32>()
+                != 1
+            || self.size_bytes == 0
+        {
+            return Err(RusticolError::integrity(
+                "recurrence process binding has invalid support words or size metadata",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceProcessRemap {
+    fn validate(&self) -> RusticolResult<()> {
+        parse_sha256(&self.bijection_digest, "recurrence process bijection")?;
+        validate_permutation(&self.source_slots, "recurrence source-slot remap")?;
+        if self.source_momentum_signs.len() != self.source_slots.len()
+            || self.source_helicity_signs.len() != self.source_slots.len()
+            || self
+                .source_momentum_signs
+                .iter()
+                .chain(&self.source_helicity_signs)
+                .any(|sign| !matches!(sign, -1 | 1))
+        {
+            return Err(RusticolError::integrity(
+                "recurrence process binding has invalid source signs",
+            ));
+        }
+        validate_ragged_permutations(
+            &self.source_state_offsets,
+            &self.source_state_indices,
+            self.source_slots.len(),
+            "recurrence source-state remap",
+        )?;
+        validate_permutation(&self.public_flow_ids, "recurrence public-flow remap")?;
+        validate_permutation(
+            &self.physical_sector_ids,
+            "recurrence physical-sector remap",
+        )?;
+        self.state_templates
+            .validate("recurrence state-template remap")?;
+        self.source_templates
+            .validate("recurrence source-template remap")?;
+        self.direct_executors
+            .validate("recurrence direct-executor remap")?;
+        self.parameter_slots
+            .validate("recurrence parameter-slot remap")?;
+        Ok(())
+    }
+}
+
+impl RecurrenceSparseBijection {
+    fn validate(&self, context: &str) -> RusticolResult<()> {
+        let count = usize::try_from(self.count)
+            .map_err(|_| RusticolError::artifact(format!("{context} count exceeds usize")))?;
+        bounded_len(context, count)?;
+        let mut mapping = (0..self.count).collect::<Vec<_>>();
+        let mut previous = None;
+        for [source, target] in &self.changes {
+            if *source >= self.count
+                || *target >= self.count
+                || source == target
+                || previous.is_some_and(|value| value >= *source)
+            {
+                return Err(RusticolError::integrity(format!(
+                    "{context} contains a noncanonical change"
+                )));
+            }
+            previous = Some(*source);
+            mapping[*source as usize] = *target;
+        }
+        validate_permutation(&mapping, context)
+    }
+}
+
+fn validate_permutation(values: &[u32], context: &str) -> RusticolResult<()> {
+    bounded_len(context, values.len())?;
+    if values
+        .iter()
+        .copied()
+        .any(|value| value as usize >= values.len())
+        || values.iter().copied().collect::<BTreeSet<_>>().len() != values.len()
+    {
+        return Err(RusticolError::integrity(format!(
+            "{context} is not a dense zero-based permutation"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_ragged_permutations(
+    offsets: &[u32],
+    values: &[u32],
+    row_count: usize,
+    context: &str,
+) -> RusticolResult<()> {
+    if offsets.len() != row_count.saturating_add(1)
+        || offsets.first().copied() != Some(0)
+        || offsets.last().copied().map(|value| value as usize) != Some(values.len())
+        || offsets.windows(2).any(|window| window[0] > window[1])
+    {
+        return Err(RusticolError::integrity(format!(
+            "{context} offsets are invalid"
+        )));
+    }
+    for window in offsets.windows(2) {
+        let start = window[0] as usize;
+        let stop = window[1] as usize;
+        validate_permutation(&values[start..stop], context)?;
+    }
+    Ok(())
+}
+
+impl RecurrenceInspectionSummary {
+    fn validate(&self, process_key: &str, color_accuracy: &str) -> RusticolResult<()> {
+        if self.execution_mode != "recurrence"
+            || self.recurrence_plan_abi != RECURRENCE_PLAN_ABI
+            || self.runtime_layout_abi != RECURRENCE_RUNTIME_LAYOUT_ABI
+            || self.direct_template_abi != RECURRENCE_DIRECT_TEMPLATE_ABI
+        {
+            return Err(RusticolError::compatibility(
+                "recurrence inspection summary does not match Direct-Arena v2",
+            ));
+        }
+        if self.process_id != process_key {
+            return Err(RusticolError::integrity(
+                "recurrence inspection process id does not match its execution manifest",
+            ));
+        }
+        validate_counts(
+            "recurrence inspection summary",
+            &[
+                self.parameter_count,
+                self.sector_count,
+                self.prepared_kernel_count,
+                self.direct_executor_count,
+            ],
+        )?;
+        parse_sha256(&self.semantic_digest, "recurrence semantic plan")?;
+        parse_sha256(&self.schedule_digest, "recurrence root schedule")?;
+        parse_sha256(
+            &self.runtime_layout_digest,
+            "recurrence Direct-Arena runtime layout",
+        )?;
+        self.schedule.validate()?;
+        self.construction.validate(self.schedule)?;
+        self.direct_arena.validate(self.lc_flow_layout)?;
+        if self.selector_work_certificate.is_some()
+            != self.direct_arena.cache_footprint_policy.is_some()
+        {
+            return Err(RusticolError::integrity(
+                "recurrence selector-work certificate and cache-footprint policy must be declared together",
+            ));
+        }
+        if let Some(certificate) = self.selector_work_certificate.as_ref() {
+            certificate.validate(
+                self.lc_flow_layout,
+                self.schedule,
+                self.direct_arena,
+                self.sector_count,
+            )?;
+        }
+        self.runtime_container_member.validate()?;
+        if let Some(certificate) = self.color_projection_certificate.as_ref() {
+            certificate.validate(self.lc_flow_layout)?;
+        }
+        if let Some(discovery) = self.relation_discovery.as_ref() {
+            discovery.validate(color_accuracy, self.lc_flow_layout, self.schedule)?;
+        }
+        match (
+            self.structural_zero_physical_sector_certificate.as_ref(),
+            self.lc_flow_layout,
+        ) {
+            (Some(certificate), RecurrenceLcFlowLayout::ContractedColorUnion) => {
+                certificate.validate(self.sector_count, self.schedule.resolved_helicity_count)?;
+            }
+            (None, RecurrenceLcFlowLayout::ContractedColorUnion) => {
+                return Err(RusticolError::integrity(
+                    "contracted recurrence inspection omitted its structural-zero physical-sector certificate",
+                ));
+            }
+            (Some(_), _) => {
+                return Err(RusticolError::integrity(
+                    "structural-zero physical-sector certificate is restricted to contracted recurrence",
+                ));
+            }
+            (None, _) => {}
+        }
+        self.generation_timings_seconds.validate()?;
+        if self.schedule.source_row_count > self.schedule.current_count
+            || self.schedule.finalization_count > self.schedule.current_count
+        {
+            return Err(RusticolError::integrity(
+                "recurrence inspection schedule disagrees with its top-level counts",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceStructuralZeroPhysicalSectorCertificate {
+    fn validate(
+        &self,
+        physical_sector_count: u64,
+        resolved_helicity_count: u64,
+    ) -> RusticolResult<()> {
+        if self.proof_kind != CLOSURE_TARGET_DOMAIN_PROOF_KIND {
+            return Err(RusticolError::compatibility(
+                "unsupported recurrence structural-zero physical-sector proof",
+            ));
+        }
+        parse_sha256(
+            &self.semantic_digest,
+            "recurrence structural-zero physical-sector proof",
+        )?;
+        if self.sector_count != physical_sector_count
+            || self.resolved_helicity_count != resolved_helicity_count
+            || self.certified_structural_zero_sector_count > self.sector_count
+        {
+            return Err(RusticolError::integrity(
+                "recurrence structural-zero physical-sector proof disagrees with its inspection domain",
+            ));
+        }
+        Ok(())
+    }
+}
+
+fn selector_row_count(
+    source_rows: u64,
+    contributions: u64,
+    finalizations: u64,
+    closures: u64,
+) -> RusticolResult<u64> {
+    source_rows
+        .checked_add(contributions)
+        .and_then(|total| total.checked_add(finalizations))
+        .and_then(|total| total.checked_add(closures))
+        .ok_or_else(|| RusticolError::artifact("recurrence selector row count overflows u64"))
+}
+
+impl RecurrenceSelectorWorkCertificate {
+    fn validate(
+        &self,
+        layout: RecurrenceLcFlowLayout,
+        schedule: RecurrenceScheduleSummary,
+        direct_arena: RecurrenceDirectArenaSummary,
+        sector_count: u64,
+    ) -> RusticolResult<()> {
+        if self.schema_version != 1 || self.binding != "runtime_layout_digest" {
+            return Err(RusticolError::compatibility(
+                "recurrence selector-work certificate identity is unsupported",
+            ));
+        }
+        self.persisted_union.validate(schedule, direct_arena)?;
+        bounded_len(
+            "recurrence selector-work representatives",
+            self.representatives.len(),
+        )?;
+        let has_representatives = !self.representatives.is_empty();
+        let has_replay_targets = schedule.replay_target_count != 0;
+        match layout {
+            RecurrenceLcFlowLayout::TopologyReplay if !has_representatives => {
+                return Err(RusticolError::integrity(
+                    "recurrence selector-work representatives disagree with the flow layout",
+                ));
+            }
+            RecurrenceLcFlowLayout::AllFlowUnion if has_representatives => {
+                return Err(RusticolError::integrity(
+                    "recurrence selector-work representatives disagree with the flow layout",
+                ));
+            }
+            // Schema-v1 contracted artifacts predating representative-level
+            // accounting legitimately carry replay targets with an empty
+            // representative list.  New writers emit representatives, but
+            // their absence must remain load-compatible until the certificate
+            // schema itself is versioned.
+            RecurrenceLcFlowLayout::ContractedColorUnion
+                if has_representatives && !has_replay_targets =>
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence selector-work representatives disagree with the flow layout",
+                ));
+            }
+            RecurrenceLcFlowLayout::TopologyReplay
+            | RecurrenceLcFlowLayout::AllFlowUnion
+            | RecurrenceLcFlowLayout::ContractedColorUnion => {}
+        }
+        let mut sector_ids = BTreeSet::new();
+        let mut public_flow_count = 0_u64;
+        for representative in &self.representatives {
+            representative.validate(
+                self.persisted_union,
+                schedule.amplitude_destination_count,
+                sector_count,
+            )?;
+            if !sector_ids.insert(representative.representative_sector_id) {
+                return Err(RusticolError::integrity(
+                    "recurrence selector-work representative sector is duplicated",
+                ));
+            }
+            public_flow_count = public_flow_count
+                .checked_add(representative.public_flow_count)
+                .ok_or_else(|| {
+                    RusticolError::artifact(
+                        "recurrence selector-work public-flow count overflows u64",
+                    )
+                })?;
+        }
+        if has_representatives && public_flow_count != schedule.replay_target_count {
+            return Err(RusticolError::integrity(
+                "recurrence selector-work public-flow count disagrees with replay targets",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceSelectorPersistedUnion {
+    fn validate(
+        self,
+        schedule: RecurrenceScheduleSummary,
+        direct_arena: RecurrenceDirectArenaSummary,
+    ) -> RusticolResult<()> {
+        validate_counts(
+            "recurrence persisted selector-work summary",
+            &[
+                self.current_count,
+                self.semantic_component_count,
+                self.source_row_count,
+                self.contribution_count,
+                self.finalization_count,
+                self.closure_count,
+                self.row_count,
+            ],
+        )?;
+        if self.current_count != schedule.current_count
+            || self.semantic_component_count != direct_arena.semantic_component_count
+            || self.source_row_count != schedule.source_row_count
+            || self.contribution_count != schedule.contribution_count
+            || self.finalization_count != schedule.finalization_count
+            || self.closure_count != schedule.closure_term_count
+            || self.row_count
+                != selector_row_count(
+                    self.source_row_count,
+                    self.contribution_count,
+                    self.finalization_count,
+                    self.closure_count,
+                )?
+        {
+            return Err(RusticolError::integrity(
+                "recurrence persisted selector-work summary disagrees with the inspection schedule",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceSelectorRepresentative {
+    fn validate(
+        self,
+        persisted: RecurrenceSelectorPersistedUnion,
+        amplitude_destination_count: u64,
+        sector_count: u64,
+    ) -> RusticolResult<()> {
+        validate_counts(
+            "recurrence selector-work representative",
+            &[
+                self.representative_sector_id,
+                self.public_flow_count,
+                self.current_count,
+                self.semantic_component_count,
+                self.source_row_count,
+                self.contribution_count,
+                self.finalization_count,
+                self.closure_count,
+                self.amplitude_destination_count,
+                self.row_count,
+            ],
+        )?;
+        if self.representative_sector_id >= sector_count
+            || self.public_flow_count == 0
+            || self.current_count > persisted.current_count
+            || self.semantic_component_count > persisted.semantic_component_count
+            || self.source_row_count > persisted.source_row_count
+            || self.contribution_count > persisted.contribution_count
+            || self.finalization_count > persisted.finalization_count
+            || self.closure_count > persisted.closure_count
+            || self.amplitude_destination_count > amplitude_destination_count
+            || self.row_count
+                != selector_row_count(
+                    self.source_row_count,
+                    self.contribution_count,
+                    self.finalization_count,
+                    self.closure_count,
+                )?
+        {
+            return Err(RusticolError::integrity(
+                "recurrence selector-work representative is inconsistent",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceConstructionSummary {
+    fn validate(self, schedule: RecurrenceScheduleSummary) -> RusticolResult<()> {
+        validate_counts(
+            "recurrence construction summary",
+            &[
+                self.peak_current_count,
+                self.peak_contribution_count,
+                self.peak_dynamic_color_state_count,
+                self.color_target_prune_count,
+                self.candidate_parent_pair_count,
+            ],
+        )?;
+        if self.peak_current_count < schedule.current_count
+            || self.peak_contribution_count < schedule.contribution_count
+            || !self.peak_to_final_current_ratio.is_finite()
+            || !self.peak_to_final_contribution_ratio.is_finite()
+            || self.peak_to_final_current_ratio < 0.0
+            || self.peak_to_final_contribution_ratio < 0.0
+            || (schedule.current_count != 0 && self.peak_to_final_current_ratio < 1.0)
+            || (schedule.contribution_count != 0 && self.peak_to_final_contribution_ratio < 1.0)
+        {
+            return Err(RusticolError::integrity(
+                "recurrence construction summary is inconsistent with the final schedule",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceScheduleSummary {
+    fn validate(self) -> RusticolResult<()> {
+        validate_counts(
+            "recurrence schedule summary",
+            &[
+                self.current_count,
+                self.source_row_count,
+                self.contribution_count,
+                self.finalization_count,
+                self.amplitude_destination_count,
+                self.closure_term_count,
+                self.replay_target_count,
+                self.retained_helicity_count,
+                self.resolved_helicity_count,
+                self.exact_factor_count,
+            ],
+        )?;
+        if self.resolved_helicity_count > self.retained_helicity_count {
+            return Err(RusticolError::integrity(
+                "recurrence resolved helicities exceed retained helicities",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceDirectArenaSummary {
+    fn validate(self, layout: RecurrenceLcFlowLayout) -> RusticolResult<()> {
+        validate_counts(
+            "recurrence Direct-Arena summary",
+            &[
+                self.semantic_component_count,
+                self.current_arena_components,
+                self.arena_component_reuse_count,
+                self.momentum_form_count,
+                self.selector_domain_count,
+                self.row_group_count,
+                self.packed_input_bytes,
+                self.packed_output_bytes,
+                self.scatter_bytes,
+            ],
+        )?;
+        let expected_semantic = self
+            .current_arena_components
+            .checked_add(self.arena_component_reuse_count)
+            .ok_or_else(|| {
+                RusticolError::artifact("recurrence Direct-Arena component count overflows u64")
+            })?;
+        if self.semantic_component_count != expected_semantic {
+            return Err(RusticolError::integrity(
+                "recurrence Direct-Arena component reuse count is inconsistent",
+            ));
+        }
+        if self.packed_input_bytes != 0 || self.packed_output_bytes != 0 || self.scatter_bytes != 0
+        {
+            return Err(RusticolError::compatibility(
+                "Direct-Arena v2 must not declare packed input, packed output, or scatter bytes",
+            ));
+        }
+        let expected_policy = match layout {
+            RecurrenceLcFlowLayout::TopologyReplay => {
+                RecurrenceCacheFootprintPolicy::SelectorActiveMaxV1
+            }
+            RecurrenceLcFlowLayout::AllFlowUnion | RecurrenceLcFlowLayout::ContractedColorUnion => {
+                RecurrenceCacheFootprintPolicy::PersistedArenaV1
+            }
+        };
+        if self
+            .cache_footprint_policy
+            .is_some_and(|policy| policy != expected_policy)
+        {
+            return Err(RusticolError::integrity(
+                "recurrence Direct-Arena cache-footprint policy disagrees with its flow layout",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceRuntimeContainerMember {
+    fn validate(&self) -> RusticolResult<()> {
+        if self.path != RECURRENCE_DIRECT_SCHEDULE_MEMBER {
+            return Err(RusticolError::security(format!(
+                "Direct-Arena v2 inspection member path must be exactly {RECURRENCE_DIRECT_SCHEDULE_MEMBER:?}"
+            )));
+        }
+        if self.size_bytes == 0 {
+            return Err(RusticolError::artifact(
+                "Direct-Arena v2 plan member size is outside canonical bounds",
+            ));
+        }
+        if self.container_size_bytes == 0 || self.size_bytes > self.container_size_bytes {
+            return Err(RusticolError::artifact(
+                "Direct-Arena v2 plan member/container sizes are inconsistent",
+            ));
+        }
+        parse_sha256(&self.sha256, "recurrence Direct-Arena plan member")?;
+        Ok(())
+    }
+}
+
+impl RecurrenceColorProjectionCertificate {
+    fn validate(&self, layout: RecurrenceLcFlowLayout) -> RusticolResult<()> {
+        if layout != RecurrenceLcFlowLayout::TopologyReplay
+            || self.path != RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER
+            || self.schema_version != 1
+            || self.proof_kind != "exact-rectangular-sum-projection"
+        {
+            return Err(RusticolError::compatibility(
+                "unsupported recurrence color-projection certificate contract",
+            ));
+        }
+        if !self.publishable || self.size_bytes == 0 {
+            return Err(RusticolError::integrity(
+                "recurrence color-projection certificate metadata is not publishable",
+            ));
+        }
+        parse_sha256(&self.sha256, "recurrence color-projection certificate")?;
+        Ok(())
+    }
+}
+
+impl RecurrenceRelationDiscoverySummary {
+    fn validate(
+        &self,
+        color_accuracy: &str,
+        layout: RecurrenceLcFlowLayout,
+        schedule: RecurrenceScheduleSummary,
+    ) -> RusticolResult<()> {
+        if self.schema_version != 1 {
+            return Err(RusticolError::compatibility(
+                "unsupported recurrence relation-discovery summary schema",
+            ));
+        }
+        let expected_layout = match layout {
+            RecurrenceLcFlowLayout::TopologyReplay => "topology-replay",
+            RecurrenceLcFlowLayout::AllFlowUnion => "all-flow-union",
+            RecurrenceLcFlowLayout::ContractedColorUnion => "contracted-color-union",
+        };
+        if self.scope.execution_mode != "recurrence"
+            || self.scope.representation != "recurrence-direct-plan-v2"
+            || self.scope.lc_flow_layout != expected_layout
+            || self.scope.color_accuracy != color_accuracy
+        {
+            return Err(RusticolError::compatibility(
+                "unsupported recurrence relation-discovery scope",
+            ));
+        }
+        for (value, context) in [
+            (&self.state, "recurrence relation-discovery state"),
+            (
+                &self.scope.color_accuracy,
+                "recurrence relation-discovery color accuracy",
+            ),
+            (
+                &self.follow_up_boundary,
+                "recurrence relation-discovery follow-up boundary",
+            ),
+        ] {
+            validate_text(value, context)?;
+        }
+        validate_counts(
+            "recurrence relation-discovery summary",
+            &[
+                self.numerical_candidate_count,
+                self.uncertified_candidate_count,
+                self.rejected_hypothesis_count,
+                self.exact_certified_relation_count,
+                self.applied_relation_count,
+                self.interaction_evaluation_count_before,
+                self.interaction_evaluation_count_after,
+                self.interaction_evaluation_savings,
+                self.current_count_before,
+                self.current_count_after,
+                self.contribution_count_before,
+                self.contribution_count_after,
+                self.scale_copy_row_count,
+                self.certificate_count,
+            ],
+        )?;
+        // Every u64 seed is valid. It remains part of the strict manifest
+        // identity even though no runtime arithmetic depends on it.
+        let _probe_seed = self.probe.seed;
+        if self.probe.status != "completed"
+            || self.probe.precision_digits < 80
+            || self.probe.probe_count < 2
+            || self.probe.verification_probe_count < 2
+            || self.probe.effective_projection_count < self.probe.probe_count
+            || !self.probe.deterministic
+        {
+            return Err(RusticolError::integrity(
+                "recurrence relation-discovery probe contract is invalid",
+            ));
+        }
+        parse_sha256(
+            &self.probe.rejection_decision_sha256,
+            "recurrence rejected-hypothesis decisions",
+        )?;
+        for (digest, context) in [
+            (
+                self.probe.runtime_parameter_schema_sha256.as_ref(),
+                "recurrence runtime-parameter schema",
+            ),
+            (
+                self.probe.candidate_observation_batch_sha256.as_ref(),
+                "recurrence candidate observation batch",
+            ),
+            (
+                self.probe.verification_observation_batch_sha256.as_ref(),
+                "recurrence verification observation batch",
+            ),
+            (
+                self.probe.decision_sha256.as_ref(),
+                "recurrence full hypothesis decisions",
+            ),
+        ] {
+            if let Some(digest) = digest {
+                parse_sha256(digest, context)?;
+            }
+        }
+        if !self.probe.candidate_only {
+            let authenticated_raw_commitments = [
+                self.probe.runtime_parameter_schema_sha256.as_ref(),
+                self.probe.candidate_observation_batch_sha256.as_ref(),
+                self.probe.verification_observation_batch_sha256.as_ref(),
+                self.probe.decision_sha256.as_ref(),
+            ];
+            let certified = self.exact_certified_relation_count;
+            if authenticated_raw_commitments
+                .iter()
+                .any(|digest| digest.is_none())
+                || self.numerical_candidate_count
+                    != certified
+                        .checked_add(self.probe.verification_rejected_count)
+                        .ok_or_else(|| {
+                            RusticolError::integrity("recurrence raw candidate count overflows")
+                        })?
+                || self.uncertified_candidate_count != self.probe.verification_rejected_count
+                || self.uncertified_candidate_count
+                    != self
+                        .numerical_candidate_count
+                        .checked_sub(certified)
+                        .ok_or_else(|| {
+                            RusticolError::integrity("recurrence raw uncertified count underflows")
+                        })?
+                || self.rejected_hypothesis_count
+                    != self
+                        .probe
+                        .tested_hypothesis_count
+                        .checked_sub(certified)
+                        .ok_or_else(|| {
+                            RusticolError::integrity("recurrence raw rejection count underflows")
+                        })?
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence authenticated raw rejection census is inconsistent",
+                ));
+            }
+        }
+        let certified = self.exact_certified_relation_count;
+        let applied = self.applied_relation_count;
+        let expected_state = match self.requested_mode {
+            RecurrenceRelationDiscoveryMode::Diagnostic => {
+                if applied != 0 || self.scale_copy_row_count != 0 {
+                    return Err(RusticolError::integrity(
+                        "diagnostic recurrence relation discovery altered the schedule",
+                    ));
+                }
+                "diagnostic-only"
+            }
+            RecurrenceRelationDiscoveryMode::CertifiedReuse => {
+                if applied != certified || self.scale_copy_row_count != applied {
+                    return Err(RusticolError::integrity(
+                        "certified recurrence relation-discovery counts disagree",
+                    ));
+                }
+                if applied == 0 {
+                    "diagnostic-only"
+                } else {
+                    "exact-certified-applied"
+                }
+            }
+        };
+        if self.state != expected_state
+            || self.current_count_before != schedule.current_count
+            || self.current_count_after != schedule.current_count
+            || self.interaction_evaluation_count_before != self.contribution_count_before
+            || self.interaction_evaluation_count_after > self.interaction_evaluation_count_before
+            || self.interaction_evaluation_savings
+                != self
+                    .interaction_evaluation_count_before
+                    .checked_sub(self.interaction_evaluation_count_after)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "recurrence relation-discovery interaction counts underflow",
+                        )
+                    })?
+            || self.contribution_count_after
+                != self
+                    .interaction_evaluation_count_after
+                    .checked_add(certified)
+                    .ok_or_else(|| {
+                        RusticolError::artifact(
+                            "recurrence relation-discovery contribution count overflows",
+                        )
+                    })?
+            || match self.requested_mode {
+                RecurrenceRelationDiscoveryMode::Diagnostic => {
+                    self.contribution_count_before != schedule.contribution_count
+                }
+                RecurrenceRelationDiscoveryMode::CertifiedReuse => {
+                    self.contribution_count_after != schedule.contribution_count
+                }
+            }
+        {
+            return Err(RusticolError::integrity(
+                "recurrence relation-discovery summary disagrees with the schedule",
+            ));
+        }
+        if self.certificate_count != certified
+            || self.certificates.len()
+                != usize::try_from(certified.min(MAX_RELATION_DISCOVERY_SAMPLES as u64)).map_err(
+                    |_| {
+                        RusticolError::artifact(
+                            "recurrence relation-discovery sample count exceeds usize",
+                        )
+                    },
+                )?
+            || self.certificates_truncated != (certified > MAX_RELATION_DISCOVERY_SAMPLES as u64)
+            || self.certificates.len() > MAX_RELATION_DISCOVERY_SAMPLES
+            || self.rejected_candidates.len() > MAX_RELATION_DISCOVERY_SAMPLES
+        {
+            return Err(RusticolError::integrity(
+                "recurrence relation-discovery bounded samples are inconsistent",
+            ));
+        }
+        let replay = &self.certificate_replay;
+        if replay.algorithm != relation_certificate_algorithm()
+            || replay.status
+                != if certified == 0 {
+                    "no-certified-relations"
+                } else {
+                    "verified"
+                }
+        {
+            return Err(RusticolError::compatibility(
+                "unsupported recurrence relation-certificate replay contract",
+            ));
+        }
+        parse_sha256(
+            &replay.certificate_set_sha256,
+            "recurrence relation certificate set",
+        )?;
+        for certificate in &self.certificates {
+            certificate.validate(self.current_count_before)?;
+        }
+        for rejected in &self.rejected_candidates {
+            validate_text(
+                &rejected.reason,
+                "recurrence relation-discovery rejection reason",
+            )?;
+        }
+        if !self.probe.candidate_only && self.rejected_candidate_diagnostics.is_none() {
+            return Err(RusticolError::integrity(
+                "full recurrence numerical probes require rejected-candidate diagnostics",
+            ));
+        }
+        if let Some(diagnostics) = self.rejected_candidate_diagnostics.as_ref() {
+            let retained = u64::try_from(self.rejected_candidates.len()).map_err(|_| {
+                RusticolError::artifact(
+                    "recurrence relation-discovery rejection sample count exceeds u64",
+                )
+            })?;
+            let retention_is_consistent = match diagnostics.truncation_policy.as_str() {
+                "first-16-in-canonical-discovery-order-v1" => {
+                    retained
+                        == diagnostics
+                            .total_rejected_hypothesis_count
+                            .min(MAX_RELATION_DISCOVERY_SAMPLES as u64)
+                }
+                "none-authenticated-full-rejection-digest-v1" => retained == 0,
+                _ => false,
+            };
+            if diagnostics.total_rejected_hypothesis_count != self.rejected_hypothesis_count
+                || diagnostics.retained_count != retained
+                || diagnostics.truncated != (diagnostics.total_rejected_hypothesis_count > retained)
+                || !retention_is_consistent
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence relation-discovery rejection diagnostics are inconsistent",
+                ));
+            }
+            let retained_rows = self
+                .rejected_candidates
+                .iter()
+                .map(|rejected| json!({"reason": &rejected.reason}))
+                .collect::<Vec<_>>();
+            let retained_payload = json!({
+                "abi": "pyamplicol-rejected-relation-diagnostics-v1",
+                "rows": retained_rows,
+            });
+            let retained_bytes = serde_json::to_vec(&retained_payload).map_err(|error| {
+                RusticolError::artifact(format!(
+                    "could not canonicalize recurrence retained rejection diagnostics: {error}"
+                ))
+            })?;
+            let expected_retained_sha256 = format!("{:x}", Sha256::digest(retained_bytes));
+            if diagnostics.retained_sha256 != expected_retained_sha256 {
+                return Err(RusticolError::integrity(
+                    "recurrence retained rejection diagnostics commitment is inconsistent",
+                ));
+            }
+            let full_census_payload = json!({
+                "abi": "pyamplicol-relation-discovery-full-census-v1",
+                "tested_hypothesis_count":
+                    self.probe.tested_hypothesis_count,
+                "numerical_candidate_count": self.numerical_candidate_count,
+                "verification_rejected_count":
+                    self.probe.verification_rejected_count,
+                "uncertified_candidate_count":
+                    self.uncertified_candidate_count,
+                "certified_relation_count":
+                    self.exact_certified_relation_count,
+                "rejected_hypothesis_count":
+                    self.rejected_hypothesis_count,
+                "applied_relation_count": self.applied_relation_count,
+                "runtime_parameter_schema_sha256":
+                    self.probe.runtime_parameter_schema_sha256,
+                "candidate_observation_batch_sha256":
+                    self.probe.candidate_observation_batch_sha256,
+                "verification_observation_batch_sha256":
+                    self.probe.verification_observation_batch_sha256,
+                "decision_sha256": self.probe.decision_sha256,
+                "rejection_decision_sha256":
+                    self.probe.rejection_decision_sha256,
+            });
+            let full_census_bytes = serde_json::to_vec(&full_census_payload).map_err(|error| {
+                RusticolError::artifact(format!(
+                    "could not canonicalize recurrence rejection census: {error}"
+                ))
+            })?;
+            let expected_full_census_sha256 = format!("{:x}", Sha256::digest(full_census_bytes));
+            if diagnostics.full_census_sha256 != expected_full_census_sha256
+                || diagnostics.full_rejection_sha256 != self.probe.rejection_decision_sha256
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence full rejection census or decision commitment is inconsistent",
+                ));
+            }
+            for (digest, context) in [
+                (
+                    &diagnostics.retained_sha256,
+                    "recurrence retained rejection diagnostics",
+                ),
+                (
+                    &diagnostics.full_census_sha256,
+                    "recurrence rejection full census",
+                ),
+                (
+                    &diagnostics.full_rejection_sha256,
+                    "recurrence full rejection decisions",
+                ),
+            ] {
+                parse_sha256(digest, context)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceRelationCertificateSample {
+    fn validate(&self, current_count: u64) -> RusticolResult<()> {
+        if self.algorithm != relation_certificate_algorithm()
+            || self.current_id >= current_count
+            || self.representative_id >= current_count
+            || self.current_id == self.representative_id
+        {
+            return Err(RusticolError::integrity(
+                "recurrence relation-certificate sample is inconsistent",
+            ));
+        }
+        self.factor_exact_rational.validate()?;
+        for (digest, context) in [
+            (
+                &self.current_term_vector_sha256,
+                "recurrence current term vector",
+            ),
+            (
+                &self.representative_term_vector_sha256,
+                "recurrence representative term vector",
+            ),
+            (&self.proof_sha256, "recurrence relation proof"),
+        ] {
+            parse_sha256(digest, context)?;
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceRelationExactFactor {
+    fn validate(&self) -> RusticolResult<()> {
+        for (value, context) in [
+            (&self.real_numerator, "recurrence relation real numerator"),
+            (
+                &self.real_denominator,
+                "recurrence relation real denominator",
+            ),
+            (
+                &self.imag_numerator,
+                "recurrence relation imaginary numerator",
+            ),
+            (
+                &self.imag_denominator,
+                "recurrence relation imaginary denominator",
+            ),
+        ] {
+            validate_text(value, context)?;
+            value.parse::<i128>().map_err(|_| {
+                RusticolError::artifact(format!("{context} is not a bounded integer"))
+            })?;
+        }
+        if self.real_denominator == "0" || self.imag_denominator == "0" {
+            return Err(RusticolError::artifact(
+                "recurrence relation factor denominator is zero",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceGenerationTimings {
+    fn validate(self) -> RusticolResult<()> {
+        let values = [
+            self.python_extraction,
+            self.catalog_authentication,
+            self.semantic_construction,
+            self.direct_lowering,
+            self.serialization,
+            self.native_total,
+        ];
+        if values
+            .iter()
+            .any(|value| !value.is_finite() || *value < 0.0)
+        {
+            return Err(RusticolError::artifact(
+                "recurrence Direct-Arena generation timings must be finite and nonnegative",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceSummary {
+    fn validate(&self) -> RusticolResult<()> {
+        if self.builder_input_abi != RECURRENCE_BUILDER_INPUT_ABI {
+            return Err(unsupported_abi(
+                "recurrence builder input",
+                &self.builder_input_abi,
+            ));
+        }
+        if self.template_input_abi != RECURRENCE_TEMPLATE_INPUT_ABI {
+            return Err(unsupported_abi(
+                "recurrence template input",
+                &self.template_input_abi,
+            ));
+        }
+        validate_counts(
+            "recurrence summary",
+            &[
+                self.current_count,
+                self.contribution_count,
+                self.closure_term_count,
+            ],
+        )
+    }
+}
+
+impl RecurrenceRuntimeMetadata {
+    fn validate(
+        &self,
+        external_pdgs: &[i32],
+        color_accuracy: &str,
+        inspection: &RecurrenceInspectionSummary,
+    ) -> RusticolResult<()> {
+        for (context, len) in [
+            ("public color flows", self.public_color_flows.len()),
+            ("runtime parameters", self.runtime_parameters.len()),
+            (
+                "prepared parameter defaults",
+                self.prepared_parameter_defaults.len(),
+            ),
+            ("parameter projection", self.parameter_projection.len()),
+            ("source templates", self.source_templates.len()),
+            ("external legs", self.external_legs.len()),
+            ("particle masses", self.particle_masses.len()),
+        ] {
+            bounded_len(context, len)?;
+        }
+        let expected_public_flow_count = match inspection.lc_flow_layout {
+            RecurrenceLcFlowLayout::TopologyReplay => Some(inspection.schedule.replay_target_count),
+            // Folded trace reflections remain distinct public flows while
+            // sharing one authenticated construction sector.
+            RecurrenceLcFlowLayout::AllFlowUnion => None,
+            RecurrenceLcFlowLayout::ContractedColorUnion => Some(0),
+        };
+        if expected_public_flow_count
+            .is_some_and(|count| self.public_color_flows.len() as u64 != count)
+        {
+            return Err(RusticolError::integrity(
+                "recurrence public color-flow count does not match the Direct-Arena replay count",
+            ));
+        }
+        let mut public_ids = BTreeSet::new();
+        let mut construction_sector_ids = BTreeSet::new();
+        for (target_sector_id, flow) in self.public_color_flows.iter().enumerate() {
+            validate_text(&flow.public_id, "recurrence public color-flow ID")?;
+            if !public_ids.insert(flow.public_id.as_str()) {
+                return Err(RusticolError::artifact(
+                    "recurrence public color-flow IDs are not unique",
+                ));
+            }
+            if u64::from(flow.construction_sector_id) >= inspection.sector_count {
+                return Err(RusticolError::integrity(
+                    "recurrence public color flow references an absent construction sector",
+                ));
+            }
+            construction_sector_ids.insert(flow.construction_sector_id);
+            if flow.target_sector_id as usize != target_sector_id
+                || flow.target_sector_id as usize >= self.public_color_flows.len()
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence public color-flow target sectors are not dense or in range",
+                ));
+            }
+        }
+        if inspection.lc_flow_layout == RecurrenceLcFlowLayout::AllFlowUnion
+            && (construction_sector_ids.len() as u64 != inspection.sector_count
+                || construction_sector_ids.iter().copied().ne(0..u32::try_from(
+                    inspection.sector_count,
+                )
+                .map_err(|_| {
+                    RusticolError::artifact("recurrence Direct-Arena sector count exceeds u32")
+                })?))
+        {
+            return Err(RusticolError::integrity(
+                "recurrence public color flows do not cover every Direct-Arena construction sector",
+            ));
+        }
+        match inspection.lc_flow_layout {
+            RecurrenceLcFlowLayout::TopologyReplay | RecurrenceLcFlowLayout::AllFlowUnion => {
+                if color_accuracy != "lc" || self.public_color_flows.is_empty() {
+                    return Err(RusticolError::artifact(
+                        "LC recurrence runtime metadata requires public physical color flows",
+                    ));
+                }
+                if self.color_contraction.is_some() {
+                    return Err(RusticolError::artifact(
+                        "LC recurrence must not carry a contracted-color payload",
+                    ));
+                }
+            }
+            RecurrenceLcFlowLayout::ContractedColorUnion => {
+                if !matches!(color_accuracy, "nlc" | "full") || !self.public_color_flows.is_empty()
+                {
+                    return Err(RusticolError::artifact(
+                        "contracted recurrence metadata requires NLC/full color and no public color-flow axis",
+                    ));
+                }
+                let color_contraction = self.color_contraction.as_ref().ok_or_else(|| {
+                    RusticolError::artifact(
+                        "NLC/full recurrence has no contracted-color payload reference",
+                    )
+                })?;
+                color_contraction.validate(color_accuracy, inspection)?;
+            }
+        }
+        validate_recurrence_parameter_runtime_parts(
+            &self.runtime_parameters,
+            &self.prepared_parameter_defaults,
+            &self.parameter_projection,
+            inspection.parameter_count,
+        )?;
+
+        if self.source_templates.is_empty() {
+            return Err(RusticolError::artifact(
+                "recurrence runtime metadata has no source templates",
+            ));
+        }
+        let mut previous_source_id = None;
+        let mut source_pdgs = BTreeSet::new();
+        for (index, source) in self.source_templates.iter().enumerate() {
+            if previous_source_id.is_some_and(|previous| previous >= source.source_template_id) {
+                return Err(RusticolError::artifact(
+                    "recurrence source templates are not in strict source-template ID order",
+                ));
+            }
+            previous_source_id = Some(source.source_template_id);
+            source.validate(index)?;
+            source_pdgs.insert(source.source_ir.identity.pdg_label);
+        }
+
+        if self.external_legs.len() != external_pdgs.len() {
+            return Err(RusticolError::integrity(
+                "recurrence runtime external legs do not match the execution PDG order",
+            ));
+        }
+        let mut public_labels = BTreeSet::new();
+        let mut saw_final = false;
+        for (source_slot, (leg, expected_pdg)) in
+            self.external_legs.iter().zip(external_pdgs).enumerate()
+        {
+            if leg.source_slot as usize != source_slot
+                || leg.public_label == 0
+                || !public_labels.insert(leg.public_label)
+            {
+                return Err(RusticolError::artifact(
+                    "recurrence external source slots or public labels are not canonical",
+                ));
+            }
+            if leg.physical_pdg != *expected_pdg {
+                return Err(RusticolError::integrity(
+                    "recurrence external physical PDGs disagree with the execution manifest",
+                ));
+            }
+            if saw_final && leg.is_initial {
+                return Err(RusticolError::artifact(
+                    "recurrence initial-state legs must precede final-state legs",
+                ));
+            }
+            saw_final |= !leg.is_initial;
+            if !source_pdgs.contains(&leg.outgoing_pdg) {
+                return Err(RusticolError::integrity(format!(
+                    "recurrence external outgoing PDG {} has no source template",
+                    leg.outgoing_pdg
+                )));
+            }
+        }
+
+        let mut mass_pdgs = BTreeSet::new();
+        let mut previous_mass_pdg = None;
+        for row in &self.particle_masses {
+            if previous_mass_pdg.is_some_and(|previous| previous >= row.outgoing_pdg)
+                || !mass_pdgs.insert(row.outgoing_pdg)
+            {
+                return Err(RusticolError::artifact(
+                    "recurrence particle masses are not in strict outgoing-PDG order",
+                ));
+            }
+            previous_mass_pdg = Some(row.outgoing_pdg);
+            if !row.mass.is_finite() || row.mass < 0.0 {
+                return Err(RusticolError::artifact(
+                    "recurrence particle masses must be finite and nonnegative",
+                ));
+            }
+        }
+        if mass_pdgs != source_pdgs {
+            return Err(RusticolError::integrity(
+                "recurrence particle masses do not cover exactly the source-template particles",
+            ));
+        }
+        self.normalization.validate(color_accuracy)
+    }
+}
+
+/// Validate the operational parameter schema shared by the broad manifest
+/// and the compact process-ready recipe.  Keeping this boundary shared avoids
+/// accepting a recipe that would bind runtime slots differently from the
+/// generation manifest it was derived from.
+pub(super) fn validate_recurrence_parameter_runtime_parts(
+    parameters: &[RecurrenceRuntimeParameter],
+    prepared_parameter_defaults: &[[f64; 2]],
+    parameter_projection: &[RecurrenceParameterProjection],
+    expected_parameter_count: u64,
+) -> RusticolResult<()> {
+    if prepared_parameter_defaults.len() as u64 != expected_parameter_count {
+        return Err(RusticolError::integrity(
+            "recurrence prepared-parameter defaults do not match the plan parameter count",
+        ));
+    }
+    if prepared_parameter_defaults
+        .iter()
+        .flatten()
+        .any(|component| !component.is_finite())
+    {
+        return Err(RusticolError::artifact(
+            "recurrence prepared-parameter defaults must be finite complex-f64 values",
+        ));
+    }
+    validate_parameter_projection(prepared_parameter_defaults.len(), parameter_projection)?;
+    validate_runtime_parameters(
+        parameters,
+        prepared_parameter_defaults,
+        parameter_projection,
+    )
+}
+
+fn validate_runtime_parameters(
+    parameters: &[RecurrenceRuntimeParameter],
+    prepared_parameter_defaults: &[[f64; 2]],
+    parameter_projection: &[RecurrenceParameterProjection],
+) -> RusticolResult<()> {
+    if parameters.len() != parameter_projection.len() {
+        return Err(RusticolError::integrity(
+            "recurrence runtime parameters do not cover the parameter projection",
+        ));
+    }
+    let mut previous_runtime_name: Option<&str> = None;
+    let mut previous_kind: Option<&str> = None;
+    for (parameter_index, (parameter, projection)) in
+        parameters.iter().zip(parameter_projection).enumerate()
+    {
+        if parameter.parameter_index as usize != parameter_index
+            || parameter.parameter_index != projection.runtime_slot
+        {
+            return Err(RusticolError::artifact(
+                "recurrence runtime parameter indices must be dense and match projection slots",
+            ));
+        }
+        validate_text(&parameter.name, "recurrence runtime parameter name")?;
+        validate_text(&parameter.kind, "recurrence runtime parameter kind")?;
+        if !parameter.default.is_finite() {
+            return Err(RusticolError::artifact(
+                "recurrence runtime parameter defaults must be finite",
+            ));
+        }
+
+        match (&parameter.runtime_name, &parameter.complex_component) {
+            (Some(runtime_name), Some(component)) => {
+                validate_text(runtime_name, "recurrence runtime parameter public name")?;
+                let expected_component = match projection.component {
+                    0 => "real",
+                    1 => "imag",
+                    _ => {
+                        return Err(RusticolError::integrity(
+                            "recurrence runtime parameter has an invalid projected component",
+                        ));
+                    }
+                };
+                if component != expected_component
+                    || projection.runtime_name != *runtime_name
+                    || parameter.name != format!("{runtime_name}.{component}")
+                {
+                    return Err(RusticolError::integrity(
+                        "recurrence complex runtime parameter disagrees with its projection",
+                    ));
+                }
+                if previous_runtime_name == Some(runtime_name.as_str())
+                    && previous_kind != Some(parameter.kind.as_str())
+                {
+                    return Err(RusticolError::integrity(
+                        "recurrence complex runtime parameter components have different kinds",
+                    ));
+                }
+                previous_runtime_name = Some(runtime_name);
+                previous_kind = Some(&parameter.kind);
+            }
+            (None, None) => {
+                if projection.component != 0 || parameter.name != projection.runtime_name {
+                    return Err(RusticolError::integrity(
+                        "recurrence real runtime parameter disagrees with its projection",
+                    ));
+                }
+                previous_runtime_name = None;
+                previous_kind = None;
+            }
+            _ => {
+                return Err(RusticolError::artifact(
+                    "recurrence runtime_name and complex_component must be both present or both absent",
+                ));
+            }
+        }
+
+        if let Some(prepared_id) = projection.prepared_parameter_id {
+            let expected_default =
+                prepared_parameter_defaults[prepared_id as usize][projection.component as usize];
+            if parameter.default != expected_default {
+                return Err(RusticolError::integrity(
+                    "recurrence runtime parameter default disagrees with its prepared default",
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_parameter_projection(
+    parameter_count: usize,
+    parameter_projection: &[RecurrenceParameterProjection],
+) -> RusticolResult<()> {
+    let mut previous_key: Option<(&str, u32)> = None;
+    let mut current_name: Option<&str> = None;
+    let mut current_template = None;
+    let mut current_prepared = None;
+    for (runtime_slot, row) in parameter_projection.iter().enumerate() {
+        if row.runtime_slot as usize != runtime_slot {
+            return Err(RusticolError::artifact(
+                "recurrence runtime parameter slots must be dense and ordered from zero",
+            ));
+        }
+        validate_text(&row.runtime_name, "recurrence runtime parameter name")?;
+        if row.component > 1 {
+            return Err(RusticolError::artifact(
+                "recurrence runtime parameter component must be zero or one",
+            ));
+        }
+        if row.parameter_template_id as usize >= parameter_count
+            || row
+                .prepared_parameter_id
+                .is_some_and(|id| id as usize >= parameter_count)
+        {
+            return Err(RusticolError::integrity(
+                "recurrence parameter projection references an absent parameter",
+            ));
+        }
+        let key = (row.runtime_name.as_str(), row.component);
+        if previous_key.is_some_and(|previous| previous >= key) {
+            return Err(RusticolError::artifact(
+                "recurrence parameter projection is not in strict name/component order",
+            ));
+        }
+        previous_key = Some(key);
+        if current_name == Some(row.runtime_name.as_str()) {
+            if row.component != 1
+                || current_template != Some(row.parameter_template_id)
+                || current_prepared != Some(row.prepared_parameter_id)
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence complex parameter projection rows are inconsistent",
+                ));
+            }
+        } else {
+            if row.component != 0 {
+                return Err(RusticolError::artifact(
+                    "recurrence parameter projection must begin each parameter at component zero",
+                ));
+            }
+            current_name = Some(row.runtime_name.as_str());
+            current_template = Some(row.parameter_template_id);
+            current_prepared = Some(row.prepared_parameter_id);
+        }
+    }
+    Ok(())
+}
+
+impl RecurrenceColorContractionReference {
+    fn validate(
+        &self,
+        color_accuracy: &str,
+        inspection: &RecurrenceInspectionSummary,
+    ) -> RusticolResult<()> {
+        if self.abi != RECURRENCE_COLOR_CONTRACTION_CODEC_ABI
+            || self.path != RECURRENCE_COLOR_CONTRACTION_PATH
+        {
+            return Err(RusticolError::compatibility(
+                "unsupported recurrence color-contraction payload contract",
+            ));
+        }
+        if self.color_accuracy != color_accuracy
+            || !matches!(self.color_accuracy.as_str(), "nlc" | "full")
+            || !matches!(
+                self.storage.as_str(),
+                "expanded" | "repeated" | "convolution-kernels"
+            )
+        {
+            return Err(RusticolError::integrity(
+                "recurrence color-contraction summary has incompatible accuracy or storage",
+            ));
+        }
+        if !self.includes_color_factor {
+            return Err(RusticolError::integrity(
+                "NLC/full recurrence color contraction must include the color factor",
+            ));
+        }
+        if let Some(factorization) = &self.factorization {
+            let valid_kind_and_rank = match factorization.kind.as_str() {
+                "klein-four-walsh" => factorization.rank == 2,
+                "elementary-abelian-walsh" => (3..u32::BITS).contains(&factorization.rank),
+                "symmetric-group-fourier" => (2..=10).contains(&factorization.rank),
+                _ => false,
+            };
+            let valid_storage = match factorization.kind.as_str() {
+                "symmetric-group-fourier" => self.storage == "convolution-kernels",
+                _ => self.storage == "repeated",
+            };
+            if !valid_storage || !valid_kind_and_rank || factorization.coset_count == 0 {
+                return Err(RusticolError::integrity(
+                    "recurrence color factorization summary is inconsistent",
+                ));
+            }
+        }
+        if (self.storage == "convolution-kernels")
+            != self
+                .factorization
+                .as_ref()
+                .is_some_and(|value| value.kind == "symmetric-group-fourier")
+        {
+            return Err(RusticolError::integrity(
+                "recurrence convolution-kernel storage requires symmetric-group Fourier factorization",
+            ));
+        }
+        match (&self.factorization, &self.fft_provenance) {
+            (Some(factorization), Some(provenance))
+                if factorization.kind == "symmetric-group-fourier" =>
+            {
+                self.validate_fft_provenance(factorization, provenance)?;
+            }
+            (Some(factorization), None) if factorization.kind == "symmetric-group-fourier" => {
+                return Err(RusticolError::integrity(
+                    "recurrence symmetric-group Fourier summary is missing FFT provenance",
+                ));
+            }
+            (_, Some(_)) => {
+                return Err(RusticolError::integrity(
+                    "recurrence non-FFT color summary carries FFT provenance",
+                ));
+            }
+            _ => {}
+        }
+        parse_sha256(&self.sha256, "recurrence color-contraction payload")?;
+        parse_sha256(
+            &self.semantic_digest,
+            "recurrence color-contraction semantic payload",
+        )?;
+        let expected_destination_count = if inspection.schedule.replay_target_count != 0 {
+            inspection
+                .sector_count
+                .checked_mul(inspection.schedule.resolved_helicity_count)
+                .ok_or_else(|| {
+                    RusticolError::artifact(
+                        "recurrence replay color-contraction destination count overflows",
+                    )
+                })?
+        } else {
+            inspection.schedule.amplitude_destination_count
+        };
+        if self.sha256 != self.semantic_digest
+            || self.size_bytes == 0
+            || self.sector_count != inspection.sector_count
+            || self.component_count != inspection.schedule.resolved_helicity_count
+            || self.destination_count != expected_destination_count
+            || self.materialized_destination_count.is_some_and(|count| {
+                count != inspection.schedule.amplitude_destination_count
+                    || count > self.destination_count
+            })
+            || self.active_sector_count == 0
+            || self.active_sector_count > self.sector_count
+            || self.group_count < self.active_sector_count
+            || self.group_count
+                > self
+                    .active_sector_count
+                    .checked_mul(self.component_count)
+                    .ok_or_else(|| {
+                        RusticolError::artifact(
+                            "recurrence color-contraction active group bound overflows",
+                        )
+                    })?
+            || self.entry_count == 0
+            || self.logical_entry_count < self.entry_count
+        {
+            return Err(RusticolError::integrity(
+                "recurrence color-contraction summary is inconsistent with the Direct-Arena schedule",
+            ));
+        }
+        Ok(())
+    }
+
+    pub(super) fn validate_fft_provenance(
+        &self,
+        factorization: &RecurrenceColorFactorizationReference,
+        provenance: &RecurrenceColorFftProvenance,
+    ) -> RusticolResult<()> {
+        let group_order = (2..=factorization.rank)
+            .try_fold(1_u64, |value, factor| value.checked_mul(u64::from(factor)));
+        let Some(group_order) = group_order else {
+            return Err(RusticolError::artifact(
+                "recurrence symmetric-group order overflows u64",
+            ));
+        };
+        let Some(covered_local_group_count) = factorization.coset_count.checked_mul(group_order)
+        else {
+            return Err(RusticolError::artifact(
+                "recurrence FFT-covered local group count overflows u64",
+            ));
+        };
+        if self.component_count == 0 || !self.group_count.is_multiple_of(self.component_count) {
+            return Err(RusticolError::integrity(
+                "recurrence symmetric-group component map is not rectangular",
+            ));
+        }
+        let local_group_count = self.group_count / self.component_count;
+        let Some(residual_group_count) = local_group_count.checked_sub(covered_local_group_count)
+        else {
+            return Err(RusticolError::integrity(
+                "recurrence FFT-covered groups exceed the local color domain",
+            ));
+        };
+        let upper_triangle_count = |count: u64| {
+            count
+                .checked_add(1)
+                .and_then(|successor| count.checked_mul(successor))
+                .and_then(|value| value.checked_div(2))
+        };
+        let Some(total_pair_count) = upper_triangle_count(local_group_count) else {
+            return Err(RusticolError::artifact(
+                "recurrence local color pair count overflows u64",
+            ));
+        };
+        let Some(covered_pair_count) = upper_triangle_count(covered_local_group_count) else {
+            return Err(RusticolError::artifact(
+                "recurrence FFT-covered color pair count overflows u64",
+            ));
+        };
+        let residual_entry_count = total_pair_count - covered_pair_count;
+        let Some(channel_pair_count) = upper_triangle_count(factorization.coset_count) else {
+            return Err(RusticolError::artifact(
+                "recurrence FFT channel-pair count overflows u64",
+            ));
+        };
+        let Some(kernel_entry_count) = channel_pair_count.checked_mul(group_order) else {
+            return Err(RusticolError::artifact(
+                "recurrence FFT kernel entry count overflows u64",
+            ));
+        };
+        let Some(raw_kernel_bytes) = kernel_entry_count.checked_mul(16) else {
+            return Err(RusticolError::artifact(
+                "recurrence FFT kernel storage exceeds u64",
+            ));
+        };
+        let Some(transformed_kernel_bytes) = kernel_entry_count.checked_mul(8) else {
+            return Err(RusticolError::artifact(
+                "recurrence transformed FFT kernel storage exceeds u64",
+            ));
+        };
+        let expected_entry_count = kernel_entry_count
+            .checked_add(residual_entry_count)
+            .ok_or_else(|| RusticolError::artifact("recurrence FFT entry count overflows u64"))?;
+        let expected_logical_entry_count = expected_entry_count
+            .checked_mul(self.component_count)
+            .ok_or_else(|| {
+            RusticolError::artifact("recurrence FFT logical entry count overflows u64")
+        })?;
+        if provenance.method != "symmetric-group-fourier"
+            || provenance.degree != factorization.rank
+            || provenance.channel_count != factorization.coset_count
+            || provenance.covered_local_group_count != covered_local_group_count
+            || provenance.residual_group_count != residual_group_count
+            || provenance.residual_entry_count != residual_entry_count
+            || provenance.raw_kernel_bytes != raw_kernel_bytes
+            || provenance.transformed_kernel_bytes != transformed_kernel_bytes
+            || provenance.capability != SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY
+            || self.entry_count != expected_entry_count
+            || self.logical_entry_count != expected_logical_entry_count
+        {
+            return Err(RusticolError::integrity(
+                "recurrence symmetric-group FFT provenance is inconsistent",
+            ));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceSourceTemplate {
+    fn validate(&self, index: usize) -> RusticolResult<()> {
+        if self.dimension == 0 || u32::try_from(self.dimension).is_err() {
+            return Err(RusticolError::artifact(format!(
+                "recurrence source template {index} has an unsupported dimension"
+            )));
+        }
+        self.source_ir.validate(index)?;
+        self.crossing.validate(index, "source-template")?;
+        if self.dimension != self.source_ir.component_dimension
+            || self.crossing != self.source_ir.crossing
+        {
+            return Err(RusticolError::integrity(format!(
+                "recurrence source template {index} disagrees with its typed SourceIR"
+            )));
+        }
+        let declared = self.source_ir.states.iter().any(|state| {
+            state.helicity == self.helicity
+                && state.chirality == self.chirality
+                && state.spin_state == RecurrenceSourceSpinState::Scalar(self.spin_state)
+        });
+        if !declared {
+            return Err(RusticolError::artifact(format!(
+                "recurrence source template {index} state is not declared by its typed SourceIR"
+            )));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceGenericSourceIr {
+    fn validate(&self, index: usize) -> RusticolResult<()> {
+        let identity = &self.identity;
+        for (label, value) in [
+            ("canonical id", identity.canonical_id.as_str()),
+            ("species id", identity.species_id.as_str()),
+            ("anti-canonical id", identity.anti_canonical_id.as_str()),
+            ("display name", identity.display_name.as_str()),
+            ("anti-display name", identity.anti_display_name.as_str()),
+        ] {
+            validate_text(value, &format!("recurrence source {index} {label}"))?;
+        }
+        if identity.anti_pdg_label == 0 {
+            return Err(RusticolError::artifact(format!(
+                "recurrence source {index} has an invalid antiparticle relation"
+            )));
+        }
+        let canonical_self_conjugate = identity.canonical_id == identity.anti_canonical_id;
+        let pdg_self_conjugate = identity.pdg_label == identity.anti_pdg_label;
+        if identity.self_conjugate != canonical_self_conjugate
+            || identity.self_conjugate != pdg_self_conjugate
+            || (identity.orientation == RecurrenceSourceOrientation::SelfConjugate)
+                != identity.self_conjugate
+        {
+            return Err(RusticolError::artifact(format!(
+                "recurrence source {index} orientation is inconsistent with its antiparticle relation"
+            )));
+        }
+        validate_text(&self.basis, &format!("recurrence source {index} basis"))?;
+        for (label, value) in [
+            ("mass parameter", self.mass_parameter.as_deref()),
+            ("width parameter", self.width_parameter.as_deref()),
+        ] {
+            if let Some(value) = value {
+                validate_text(value, &format!("recurrence source {index} {label}"))?;
+            }
+        }
+        if self.component_dimension == 0 || u32::try_from(self.component_dimension).is_err() {
+            return Err(RusticolError::artifact(format!(
+                "recurrence source {index} has an unsupported component dimension"
+            )));
+        }
+        bounded_len("recurrence SourceIR states", self.states.len())?;
+        if self.states.is_empty() {
+            return Err(RusticolError::artifact(format!(
+                "recurrence source {index} has no declared SourceIR states"
+            )));
+        }
+        self.crossing.validate(index, "declared")?;
+
+        let expected_statistics = match self.wavefunction_family {
+            RecurrenceWavefunctionFamily::Fermion => RecurrenceParticleStatistics::Fermion,
+            RecurrenceWavefunctionFamily::Ghost => RecurrenceParticleStatistics::Ghost,
+            RecurrenceWavefunctionFamily::Auxiliary => RecurrenceParticleStatistics::Auxiliary,
+            RecurrenceWavefunctionFamily::Scalar
+            | RecurrenceWavefunctionFamily::Vector
+            | RecurrenceWavefunctionFamily::Spin2 => RecurrenceParticleStatistics::Boson,
+        };
+        if self.statistics != expected_statistics {
+            return Err(RusticolError::artifact(format!(
+                "recurrence source {index} statistics disagree with its wavefunction family"
+            )));
+        }
+        match (self.wavefunction_family, self.component_dimension) {
+            (RecurrenceWavefunctionFamily::Fermion, 2 | 4) => {
+                if identity.self_conjugate {
+                    return Err(RusticolError::artifact(format!(
+                        "recurrence source {index} is an unsupported self-conjugate fermion source"
+                    )));
+                }
+            }
+            (RecurrenceWavefunctionFamily::Scalar, 1)
+            | (RecurrenceWavefunctionFamily::Vector, 4)
+            | (RecurrenceWavefunctionFamily::Spin2, 16) => {}
+            _ => {
+                return Err(RusticolError::artifact(format!(
+                    "recurrence source {index} has an unsupported wavefunction family/dimension pair"
+                )));
+            }
+        }
+
+        let max_helicity = if self.wavefunction_family == RecurrenceWavefunctionFamily::Spin2 {
+            2
+        } else {
+            1
+        };
+        let mut states = BTreeSet::new();
+        for (state_index, state) in self.states.iter().enumerate() {
+            if state.chirality.unsigned_abs() > 1 || state.helicity.unsigned_abs() > max_helicity {
+                return Err(RusticolError::artifact(format!(
+                    "recurrence source {index} SourceIR state {state_index} is outside the supported helicity/chirality range"
+                )));
+            }
+            if let RecurrenceSourceSpinState::Components(components) = &state.spin_state {
+                bounded_len("structured source spin state", components.len())?;
+                if components.is_empty() || components.len() as u64 > self.component_dimension {
+                    return Err(RusticolError::artifact(format!(
+                        "recurrence source {index} SourceIR state {state_index} has invalid structured spin metadata"
+                    )));
+                }
+            }
+            if !states.insert(state) {
+                return Err(RusticolError::artifact(format!(
+                    "recurrence source {index} contains duplicate SourceIR states"
+                )));
+            }
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceGenericCrossingIr {
+    fn validate(&self, index: usize, label: &str) -> RusticolResult<()> {
+        if ![-1, 1].contains(&self.helicity_factor)
+            || ![-1, 1].contains(&self.chirality_factor)
+            || ![-1, 1].contains(&self.spin_state_factor)
+            || !self.phase.iter().all(|component| component.is_finite())
+            || self.phase == [0.0, 0.0]
+        {
+            return Err(RusticolError::artifact(format!(
+                "recurrence source {index} has invalid {label} CrossingIR metadata"
+            )));
+        }
+        Ok(())
+    }
+}
+
+impl RecurrenceNormalization {
+    fn validate(&self, color_accuracy: &str) -> RusticolResult<()> {
+        if self.color_accuracy != color_accuracy {
+            return Err(RusticolError::integrity(
+                "recurrence normalization color accuracy disagrees with the process",
+            ));
+        }
+        if [
+            self.color_factor,
+            self.average_factor,
+            self.identical_factor,
+            self.global_coupling_factor,
+        ]
+        .iter()
+        .any(|value| !value.is_finite())
+        {
+            return Err(RusticolError::artifact(
+                "recurrence normalization factors must be finite",
+            ));
+        }
+        if self.average_factor <= 0.0 || self.identical_factor <= 0.0 {
+            return Err(RusticolError::artifact(
+                "recurrence averaging and identical-particle factors must be positive",
+            ));
+        }
+        if self.qcd_coupling_power.is_some() != self.electroweak_coupling_power.is_some() {
+            return Err(RusticolError::artifact(
+                "recurrence normalization coupling powers must be both present or both absent",
+            ));
+        }
+        validate_counts(
+            "recurrence normalization",
+            &[
+                self.qcd_coupling_power.unwrap_or(0),
+                self.electroweak_coupling_power.unwrap_or(0),
+            ],
+        )?;
+        validate_text(
+            &self.coupling_policy,
+            "recurrence normalization coupling policy",
+        )?;
+        Ok(())
+    }
+}
+
+/// Parse and validate one bounded recurrence `execution.json`.
+pub(super) fn parse_recurrence_execution_manifest(
+    bytes: &[u8],
+    path: &str,
+    outer: &ArtifactProcess,
+) -> RusticolResult<RecurrenceExecutionManifest> {
+    let manifest: RecurrenceExecutionManifest = serde_json::from_slice(bytes).map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not parse bounded recurrence execution manifest {path:?}: {error}"
+        ))
+    })?;
+    manifest.validate(outer)?;
+    Ok(manifest)
+}
+
+fn validate_capabilities(
+    capabilities: &[String],
+    color_accuracy: &str,
+    uses_symmetric_group_fft: bool,
+    has_helicity_selector_companion: bool,
+    context: &str,
+) -> RusticolResult<()> {
+    let color_capability = match color_accuracy {
+        "lc" => RECURRENCE_LC_COLOR_CAPABILITY,
+        "nlc" | "full" => RECURRENCE_CONTRACTED_COLOR_CAPABILITY,
+        other => {
+            return Err(RusticolError::compatibility(format!(
+                "{context} has unsupported recurrence color accuracy {other:?}"
+            )));
+        }
+    };
+    let mut expected = Vec::from([color_capability, RECURRENCE_RUNTIME_CAPABILITY]);
+    if uses_symmetric_group_fft {
+        expected.push(SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY);
+    }
+    if has_helicity_selector_companion {
+        expected.push(RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY);
+    }
+    expected.sort_unstable();
+    if capabilities.iter().map(String::as_str).collect::<Vec<_>>() != expected {
+        return Err(RusticolError::compatibility(format!(
+            "{context} must require exactly {expected:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_direct_contract(
+    builder_input_abi: &str,
+    recurrence_plan_abi: &str,
+    runtime_layout_abi: &str,
+    direct_template_abi: &str,
+    direct_backend_abi: &str,
+    context: &str,
+) -> RusticolResult<()> {
+    for (label, actual, expected) in [
+        (
+            "builder input",
+            builder_input_abi,
+            RECURRENCE_BUILDER_INPUT_ABI,
+        ),
+        ("plan", recurrence_plan_abi, RECURRENCE_PLAN_ABI),
+        (
+            "runtime layout",
+            runtime_layout_abi,
+            RECURRENCE_RUNTIME_LAYOUT_ABI,
+        ),
+        (
+            "direct template",
+            direct_template_abi,
+            RECURRENCE_DIRECT_TEMPLATE_ABI,
+        ),
+        (
+            "direct backend",
+            direct_backend_abi,
+            RECURRENCE_DIRECT_BACKEND_ABI,
+        ),
+    ] {
+        if actual != expected {
+            return Err(RusticolError::compatibility(format!(
+                "{context} has unsupported Direct-Arena v2 {label} ABI {actual:?}; regenerate the recurrence artifact"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn bounded_len(context: &str, len: usize) -> RusticolResult<()> {
+    if u32::try_from(len).is_err() {
+        return Err(RusticolError::artifact(format!(
+            "{context} count exceeds the u32 identifier domain"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_counts(context: &str, counts: &[u64]) -> RusticolResult<()> {
+    if counts.iter().any(|count| usize::try_from(*count).is_err()) {
+        return Err(RusticolError::artifact(format!(
+            "{context} count exceeds the platform index domain"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_text(value: &str, context: &str) -> RusticolResult<()> {
+    if value.is_empty() {
+        return Err(RusticolError::artifact(format!("{context} is empty")));
+    }
+    Ok(())
+}
+
+fn unsupported_abi(context: &str, value: &str) -> RusticolError {
+    RusticolError::compatibility(format!("unsupported {context} ABI {value:?}"))
+}
+
+fn parse_sha256(value: &str, context: &str) -> RusticolResult<[u8; 32]> {
+    if value.len() != 64
+        || value
+            .as_bytes()
+            .iter()
+            .any(|byte| !matches!(byte, b'0'..=b'9' | b'a'..=b'f'))
+    {
+        return Err(RusticolError::artifact(format!(
+            "{context} SHA-256 must be 64 lowercase hexadecimal characters"
+        )));
+    }
+    let mut digest = [0_u8; 32];
+    for (index, pair) in value.as_bytes().chunks_exact(2).enumerate() {
+        digest[index] = (hex_nibble(pair[0]) << 4) | hex_nibble(pair[1]);
+    }
+    Ok(digest)
+}
+
+fn hex_nibble(value: u8) -> u8 {
+    match value {
+        b'0'..=b'9' => value - b'0',
+        b'a'..=b'f' => value - b'a' + 10,
+        _ => unreachable!("digest validation precedes hexadecimal decoding"),
+    }
+}
+
+fn deserialize_required_nullable_string<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    match Value::deserialize(deserializer)? {
+        Value::Null => Ok(None),
+        Value::String(value) => Ok(Some(value)),
+        _ => Err(<D::Error as serde::de::Error>::custom(
+            "expected a string or null",
+        )),
+    }
+}
+
+fn deserialize_required_nullable_u32<'de, D>(deserializer: D) -> Result<Option<u32>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    Option::<u32>::deserialize(deserializer)
+}
+
+fn deserialize_recurrence_phase<'de, D>(deserializer: D) -> Result<[f64; 2], D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let value = Value::deserialize(deserializer)?;
+    if let Ok(pair) = serde_json::from_value::<[f64; 2]>(value.clone()) {
+        return Ok(pair);
+    }
+    let object = value.as_object().ok_or_else(|| {
+        serde::de::Error::custom("recurrence crossing phase must be a complex-f64 pair")
+    })?;
+    let component = |prefix: &str| -> Result<f64, D::Error> {
+        let numerator = object
+            .get(&format!("{prefix}_numerator"))
+            .and_then(Value::as_str)
+            .ok_or_else(|| serde::de::Error::custom("invalid exact recurrence phase"))?
+            .parse::<f64>()
+            .map_err(|_| serde::de::Error::custom("invalid exact recurrence phase numerator"))?;
+        let denominator = object
+            .get(&format!("{prefix}_denominator"))
+            .and_then(Value::as_str)
+            .ok_or_else(|| serde::de::Error::custom("invalid exact recurrence phase"))?
+            .parse::<f64>()
+            .map_err(|_| serde::de::Error::custom("invalid exact recurrence phase denominator"))?;
+        let value = numerator / denominator;
+        if denominator == 0.0 || !value.is_finite() {
+            return Err(serde::de::Error::custom(
+                "exact recurrence phase is not finite",
+            ));
+        }
+        Ok(value)
+    };
+    Ok([component("real")?, component("imag")?])
+}
+
+fn deserialize_optional_u64_if_present<'de, D>(deserializer: D) -> Result<Option<u64>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    u64::deserialize(deserializer).map(Some)
+}
+
+#[cfg(test)]
+pub(super) mod tests {
+    use super::*;
+    use serde_json::{Value, json};
+
+    fn capabilities() -> Value {
+        json!([
+            RECURRENCE_LC_COLOR_CAPABILITY,
+            RECURRENCE_RUNTIME_CAPABILITY
+        ])
+    }
+
+    fn crossing() -> Value {
+        json!({
+            "momentum_transform": "identity",
+            "helicity_factor": 1,
+            "chirality_factor": 1,
+            "spin_state_factor": 1,
+            "phase": [1.0, 0.0]
+        })
+    }
+
+    fn source_ir() -> Value {
+        json!({
+            "identity": {
+                "canonical_id": "model:test:state:x",
+                "species_id": "model:test:species:x",
+                "anti_canonical_id": "model:test:state:x",
+                "display_name": "x",
+                "anti_display_name": "x",
+                "pdg_label": 25,
+                "anti_pdg_label": 25,
+                "orientation": "self-conjugate",
+                "self_conjugate": true
+            },
+            "statistics": "boson",
+            "wavefunction_family": "scalar",
+            "component_dimension": 1,
+            "states": [{"helicity": 0, "chirality": 0, "spin_state": 0}],
+            "crossing": crossing(),
+            "basis": "scalar",
+            "mass_parameter": null,
+            "width_parameter": null
+        })
+    }
+
+    fn runtime_metadata() -> Value {
+        json!({
+            "public_color_flows": [{
+                "public_id": "flow:1",
+                "construction_sector_id": 0,
+                "target_sector_id": 0
+            }],
+            "runtime_parameters": [{
+                "name": "mass.x",
+                "kind": "external_parameter",
+                "parameter_index": 0,
+                "default": 1.0,
+                "runtime_name": null,
+                "complex_component": null
+            }],
+            "prepared_parameter_defaults": [[1.0, 0.0]],
+            "parameter_projection": [{
+                "runtime_slot": 0,
+                "runtime_name": "mass.x",
+                "parameter_template_id": 0,
+                "prepared_parameter_id": 0,
+                "component": 0
+            }],
+            "source_templates": [{
+                "source_template_id": 0,
+                "current_state_template_id": 0,
+                "dimension": 1,
+                "helicity": 0,
+                "chirality": 0,
+                "spin_state": 0,
+                "source_ir": source_ir(),
+                "crossing": crossing()
+            }],
+            "external_legs": [{
+                "source_slot": 0,
+                "public_label": 1,
+                "physical_pdg": 25,
+                "outgoing_pdg": 25,
+                "is_initial": false
+            }],
+            "particle_masses": [{"outgoing_pdg": 25, "mass": 0.0}],
+            "color_contraction": null,
+            "normalization": {
+                "color_accuracy": "lc",
+                "color_factor": 1.0,
+                "average_factor": 1.0,
+                "identical_factor": 1.0,
+                "global_coupling_factor": 1.0,
+                "qcd_coupling_power": 0,
+                "electroweak_coupling_power": 0,
+                "couplings_in_stage_evaluators": true,
+                "coupling_policy": "test"
+            }
+        })
+    }
+
+    fn inspection_summary() -> Value {
+        json!({
+            "execution_mode": "recurrence",
+            "recurrence_plan_abi": RECURRENCE_PLAN_ABI,
+            "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_ABI,
+            "direct_template_abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+            "process_id": "x_to_x",
+            "lc_flow_layout": "topology-replay",
+            "parameter_count": 1,
+            "sector_count": 1,
+            "prepared_kernel_count": 1,
+            "direct_executor_count": 4,
+            "semantic_digest": "11".repeat(32),
+            "schedule_digest": "aa".repeat(32),
+            "runtime_layout_digest": "77".repeat(32),
+            "schedule": {
+                "current_count": 1,
+                "source_row_count": 1,
+                "contribution_count": 0,
+                "finalization_count": 1,
+                "amplitude_destination_count": 1,
+                "closure_term_count": 0,
+                "replay_target_count": 1,
+                "retained_helicity_count": 1,
+                "resolved_helicity_count": 1,
+                "exact_factor_count": 1
+            },
+            "construction": {
+                "peak_current_count": 1,
+                "peak_contribution_count": 0,
+                "peak_dynamic_color_state_count": 1,
+                "color_target_prune_count": 0,
+                "candidate_parent_pair_count": 0,
+                "peak_to_final_current_ratio": 1.0,
+                "peak_to_final_contribution_ratio": 0.0
+            },
+            "direct_arena": {
+                "semantic_component_count": 1,
+                "current_arena_components": 1,
+                "arena_component_reuse_count": 0,
+                "momentum_form_count": 1,
+                "selector_domain_count": 1,
+                "row_group_count": 4,
+                "packed_input_bytes": 0,
+                "packed_output_bytes": 0,
+                "scatter_bytes": 0
+            },
+            "runtime_container_member": {
+                "path": RECURRENCE_DIRECT_SCHEDULE_MEMBER,
+                "size_bytes": 512,
+                "sha256": "88".repeat(32),
+                "container_size_bytes": 4096
+            },
+            "generation_timings_seconds": {
+                "python_extraction": 0.1,
+                "catalog_authentication": 0.1,
+                "semantic_construction": 0.1,
+                "direct_lowering": 0.1,
+                "serialization": 0.1,
+                "native_total": 0.5
+            }
+        })
+    }
+
+    pub(crate) fn manifest() -> Value {
+        let plan = json!({
+            "kind": RECURRENCE_RUNTIME_KIND,
+            "builder_input_abi": RECURRENCE_BUILDER_INPUT_ABI,
+            "recurrence_plan_abi": RECURRENCE_PLAN_ABI,
+            "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_ABI,
+            "direct_template_abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+            "direct_backend_abi": RECURRENCE_DIRECT_BACKEND_ABI,
+            "builder_input_sha256": "11".repeat(32),
+            "prepared_kernel_pack_digest": "44".repeat(32),
+            "direct_template_catalog_digest": "55".repeat(32),
+            "required_runtime_capabilities": capabilities(),
+            "runtime_schedule": {
+                "kind": RECURRENCE_RUNTIME_CONTAINER_KIND,
+                "schema_version": RECURRENCE_RUNTIME_CONTAINER_SCHEMA,
+                "storage_abi": RECURRENCE_RUNTIME_STORAGE_ABI,
+                "path": format!(
+                    "recurrence/schedules/{}/recurrence-runtime.pacbin",
+                    "aa".repeat(32)
+                ),
+                "plan_member_path": RECURRENCE_DIRECT_SCHEDULE_MEMBER,
+                "size_bytes": 4096,
+                "sha256": "22".repeat(32),
+                "member_count": 1,
+                "unpacked_size_bytes": 512,
+                "index_sha256": "33".repeat(32)
+            },
+            "process_binding": {
+                "abi": RECURRENCE_PROCESS_BINDING_ABI,
+                "process_id": "x_to_x",
+                "schedule_digest": "aa".repeat(32),
+                "native_schedule_semantic_digest": "ab".repeat(32),
+                "process_digest": "12".repeat(32),
+                "process_semantic_digest": "11".repeat(32),
+                "process_support_words": [1],
+                "remap": {
+                    "bijection_digest": "66".repeat(32),
+                    "source_slots": [0],
+                    "source_momentum_signs": [1],
+                    "source_helicity_signs": [1],
+                    "source_state_offsets": [0, 1],
+                    "source_state_indices": [0],
+                    "public_flow_ids": [0],
+                    "physical_sector_ids": [0],
+                    "state_templates": {"count": 1, "changes": []},
+                    "source_templates": {"count": 1, "changes": []},
+                    "direct_executors": {"count": 4, "changes": []},
+                    "parameter_slots": {"count": 1, "changes": []}
+                },
+                "path": RECURRENCE_PROCESS_BINDING_PATH,
+                "size_bytes": 256,
+                "sha256": "99".repeat(32)
+            },
+            "inspection_summary": inspection_summary()
+        });
+        json!({
+            "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+            "kind": RECURRENCE_RUNTIME_KIND,
+            "required_runtime_capabilities": capabilities(),
+            "process": "x > x",
+            "key": "x_to_x",
+            "color_accuracy": "lc",
+            "external_pdg_order": [25],
+            "process_digest": null,
+            "builder_input_abi": RECURRENCE_BUILDER_INPUT_ABI,
+            "recurrence_plan_abi": RECURRENCE_PLAN_ABI,
+            "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_ABI,
+            "direct_template_abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+            "direct_backend_abi": RECURRENCE_DIRECT_BACKEND_ABI,
+            "compiled_model_digest": "bb".repeat(32),
+            "recurrence_template_catalog_digest": "cc".repeat(32),
+            "prepared_kernel_pack_digest": "44".repeat(32),
+            "direct_template_catalog_digest": "55".repeat(32),
+            "kernel_pack": {
+                "manifest_path": RECURRENCE_KERNEL_PACK_MANIFEST_PATH,
+                "payload_root": RECURRENCE_KERNEL_PAYLOAD_ROOT
+            },
+            "runtime_options": {"point_tile_size": 8, "workspace_mib": 64},
+            "runtime_metadata": runtime_metadata(),
+            "helicity_selector_companion": null,
+            "plan": plan,
+            "recurrence_summary": {
+                "lc_flow_layout": "topology-replay",
+                "builder_input_abi": RECURRENCE_BUILDER_INPUT_ABI,
+                "template_input_abi": RECURRENCE_TEMPLATE_INPUT_ABI,
+                "current_count": 1,
+                "contribution_count": 0,
+                "closure_term_count": 0
+            }
+        })
+    }
+
+    pub(crate) fn outer() -> ArtifactProcess {
+        ArtifactProcess {
+            id: "x_to_x".to_owned(),
+            expression: "x > x".to_owned(),
+            color_accuracy: "lc".to_owned(),
+            external_pdgs: vec![25],
+            physics_path: "processes/x_to_x/physics.json".to_owned(),
+            required_runtime_capabilities: vec![
+                RECURRENCE_LC_COLOR_CAPABILITY.to_owned(),
+                RECURRENCE_RUNTIME_CAPABILITY.to_owned(),
+            ],
+            aliases: Vec::new(),
+        }
+    }
+
+    fn parse(value: &Value) -> RusticolResult<RecurrenceExecutionManifest> {
+        parse_recurrence_execution_manifest(
+            &serde_json::to_vec(value).unwrap(),
+            "processes/x_to_x/execution.json",
+            &outer(),
+        )
+    }
+
+    fn add_python_selector_work_certificate(value: &mut Value) {
+        value["plan"]["inspection_summary"]["selector_work_certificate"] = json!({
+            "schema_version": 1,
+            "binding": "runtime_layout_digest",
+            "persisted_union": {
+                "current_count": 1,
+                "semantic_component_count": 1,
+                "source_row_count": 1,
+                "contribution_count": 0,
+                "finalization_count": 1,
+                "closure_count": 0,
+                "row_count": 2
+            },
+            "representatives": [{
+                "representative_sector_id": 0,
+                "public_flow_count": 1,
+                "current_count": 1,
+                "semantic_component_count": 1,
+                "source_row_count": 1,
+                "contribution_count": 0,
+                "finalization_count": 1,
+                "closure_count": 0,
+                "amplitude_destination_count": 1,
+                "row_count": 2
+            }]
+        });
+        value["plan"]["inspection_summary"]["direct_arena"]["cache_footprint_policy"] =
+            json!("selector-active-max-v1");
+    }
+
+    fn add_python_color_projection_certificate(value: &mut Value) {
+        value["plan"]["inspection_summary"]["color_projection_certificate"] = json!({
+            "path": RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER,
+            "schema_version": 1,
+            "proof_kind": "exact-rectangular-sum-projection",
+            "publishable": true,
+            "size_bytes": 128,
+            "sha256": "cc".repeat(32)
+        });
+        value["plan"]["runtime_schedule"]["member_count"] = json!(2);
+        value["plan"]["runtime_schedule"]["unpacked_size_bytes"] = json!(640);
+    }
+
+    fn add_python_relation_discovery(value: &mut Value, requested_mode: &str) {
+        let retained_payload = json!({
+            "abi": "pyamplicol-rejected-relation-diagnostics-v1",
+            "rows": [],
+        });
+        let retained_sha256 = format!(
+            "{:x}",
+            Sha256::digest(serde_json::to_vec(&retained_payload).unwrap())
+        );
+        let rejection_decision_sha256 = "aa".repeat(32);
+        let full_census = json!({
+            "abi": "pyamplicol-relation-discovery-full-census-v1",
+            "tested_hypothesis_count": 0,
+            "numerical_candidate_count": 0,
+            "verification_rejected_count": 0,
+            "uncertified_candidate_count": 0,
+            "certified_relation_count": 0,
+            "rejected_hypothesis_count": 0,
+            "applied_relation_count": 0,
+            "runtime_parameter_schema_sha256": null,
+            "candidate_observation_batch_sha256": null,
+            "verification_observation_batch_sha256": null,
+            "decision_sha256": null,
+            "rejection_decision_sha256": rejection_decision_sha256,
+        });
+        let full_census_sha256 = format!(
+            "{:x}",
+            Sha256::digest(serde_json::to_vec(&full_census).unwrap())
+        );
+        value["plan"]["inspection_summary"]["relation_discovery"] = json!({
+            "schema_version": 1,
+            "requested_mode": requested_mode,
+            "state": "diagnostic-only",
+            "scope": {
+                "execution_mode": "recurrence",
+                "color_accuracy": "lc",
+                "representation": "recurrence-direct-plan-v2",
+                "lc_flow_layout": "topology-replay"
+            },
+            "probe": {
+                "status": "completed",
+                "precision_digits": 96,
+                "probe_count": 4,
+                "verification_probe_count": 4,
+                "effective_projection_count": 7,
+                "seed": 17,
+                "deterministic": true,
+                "candidate_only": true,
+                "tested_hypothesis_count": 0,
+                "verification_rejected_count": 0,
+                "runtime_parameter_schema_sha256": null,
+                "candidate_observation_batch_sha256": null,
+                "verification_observation_batch_sha256": null,
+                "decision_sha256": null,
+                "rejection_decision_sha256": rejection_decision_sha256
+            },
+            "certificate_replay": {
+                "algorithm": relation_certificate_algorithm(),
+                "status": "no-certified-relations",
+                "certificate_set_sha256": "dd".repeat(32)
+            },
+            "numerical_candidate_count": 0,
+            "uncertified_candidate_count": 0,
+            "rejected_hypothesis_count": 0,
+            "exact_certified_relation_count": 0,
+            "applied_relation_count": 0,
+            "interaction_evaluation_count_before": 0,
+            "interaction_evaluation_count_after": 0,
+            "interaction_evaluation_savings": 0,
+            "current_count_before": 1,
+            "current_count_after": 1,
+            "contribution_count_before": 0,
+            "contribution_count_after": 0,
+            "scale_copy_row_count": 0,
+            "certificates": [],
+            "certificate_count": 0,
+            "certificates_truncated": false,
+            "rejected_candidates": [],
+            "rejected_candidate_diagnostics": {
+                "total_rejected_hypothesis_count": 0,
+                "retained_count": 0,
+                "truncated": false,
+                "truncation_policy": "first-16-in-canonical-discovery-order-v1",
+                "retained_sha256": retained_sha256,
+                "full_census_sha256": full_census_sha256,
+                "full_rejection_sha256": "aa".repeat(32)
+            },
+            "follow_up_boundary": "exact relation discovery is opt-in"
+        });
+    }
+
+    fn hzz_outer(color_accuracy: &str) -> ArtifactProcess {
+        ArtifactProcess {
+            id: "d_dbar_to_z_z_z".to_owned(),
+            expression: "d d~ > z z z".to_owned(),
+            color_accuracy: color_accuracy.to_owned(),
+            external_pdgs: vec![1, -1, 23, 23, 23],
+            physics_path: "processes/d_dbar_to_z_z_z/physics.json".to_owned(),
+            required_runtime_capabilities: vec![
+                if color_accuracy == "lc" {
+                    RECURRENCE_LC_COLOR_CAPABILITY
+                } else {
+                    RECURRENCE_CONTRACTED_COLOR_CAPABILITY
+                }
+                .to_owned(),
+                RECURRENCE_RUNTIME_CAPABILITY.to_owned(),
+            ],
+            aliases: Vec::new(),
+        }
+    }
+
+    fn hzz_companion_outer(color_accuracy: &str) -> ArtifactProcess {
+        let mut outer = hzz_outer(color_accuracy);
+        outer
+            .required_runtime_capabilities
+            .push(RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY.to_owned());
+        outer.required_runtime_capabilities.sort_unstable();
+        outer
+    }
+
+    fn parse_hzz_fixture(
+        bytes: &[u8],
+        color_accuracy: &str,
+    ) -> RusticolResult<RecurrenceExecutionManifest> {
+        parse_recurrence_execution_manifest(
+            bytes,
+            "processes/d_dbar_to_z_z_z/execution.json",
+            &hzz_outer(color_accuracy),
+        )
+    }
+
+    fn parse_hzz_companion_fixture(
+        bytes: &[u8],
+        color_accuracy: &str,
+    ) -> RusticolResult<RecurrenceExecutionManifest> {
+        parse_recurrence_execution_manifest(
+            bytes,
+            "processes/d_dbar_to_z_z_z/execution.json",
+            &hzz_companion_outer(color_accuracy),
+        )
+    }
+
+    fn legacy_full_hzz_fixture_value() -> Value {
+        let mut value: Value = serde_json::from_slice(include_bytes!(
+            "../../tests/fixtures/recurrence_execution_hzz_full_v2.json"
+        ))
+        .unwrap();
+        upgrade_hzz_fixture_manifest(&mut value);
+        value
+    }
+
+    fn full_hzz_fixture_value() -> Value {
+        let mut value = legacy_full_hzz_fixture_value();
+        add_hzz_contracted_selector_representative(&mut value);
+        value
+    }
+
+    fn add_hzz_contracted_selector_representative(value: &mut Value) {
+        value["plan"]["inspection_summary"]["selector_work_certificate"]["representatives"] = json!([{
+            "representative_sector_id": 0,
+            "public_flow_count": 1,
+            "current_count": 193,
+            "semantic_component_count": 431,
+            "source_row_count": 13,
+            "contribution_count": 450,
+            "finalization_count": 126,
+            "closure_count": 54,
+            "amplitude_destination_count": 54,
+            "row_count": 643
+        }]);
+    }
+
+    fn add_hzz_helicity_selector_companion(value: &mut Value) {
+        let process_digest = "10".repeat(32);
+        let builder_input_digest = "20".repeat(32);
+        let base_schedule_digest = "21".repeat(32);
+        let runtime_layout_digest = "22".repeat(32);
+        let dispatch_sha256 = "23".repeat(32);
+        let composite_schedule_digest =
+            recurrence_helicity_selector_schedule_digest(&base_schedule_digest, &dispatch_sha256)
+                .unwrap();
+        let resolved_helicity_count = 108_u64;
+
+        for pointer in [
+            "/required_runtime_capabilities",
+            "/plan/required_runtime_capabilities",
+        ] {
+            let capabilities = value.pointer_mut(pointer).unwrap();
+            capabilities.as_array_mut().unwrap().push(json!(
+                RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY
+            ));
+            capabilities
+                .as_array_mut()
+                .unwrap()
+                .sort_by(|left, right| left.as_str().unwrap().cmp(right.as_str().unwrap()));
+        }
+
+        value["process_digest"] = json!(process_digest.clone());
+        value["plan"]["process_binding"]["process_digest"] = json!(process_digest.clone());
+        let mut plan = value["plan"].clone();
+        plan["builder_input_sha256"] = json!(builder_input_digest.clone());
+        plan["process_binding"]["schedule_digest"] = json!(composite_schedule_digest.clone());
+        plan["process_binding"]["native_schedule_semantic_digest"] =
+            json!(base_schedule_digest.clone());
+        plan["process_binding"]["process_digest"] = json!(process_digest.clone());
+        plan["process_binding"]["process_semantic_digest"] = json!(builder_input_digest.clone());
+        plan["process_binding"]["path"] = json!(RECURRENCE_HELICITY_SELECTOR_BINDING_PATH);
+        plan["process_binding"]["sha256"] = json!("24".repeat(32));
+        plan["runtime_schedule"]["path"] = json!(format!(
+            "recurrence/schedules/{composite_schedule_digest}/recurrence-runtime.pacbin"
+        ));
+        plan["runtime_schedule"]["sha256"] = json!("25".repeat(32));
+        plan["inspection_summary"]["lc_flow_layout"] = json!("all-flow-union");
+        plan["inspection_summary"]["semantic_digest"] = json!(builder_input_digest);
+        plan["inspection_summary"]["schedule_digest"] = json!(base_schedule_digest);
+        plan["inspection_summary"]["runtime_layout_digest"] = json!(runtime_layout_digest.clone());
+        plan["inspection_summary"]["schedule"]["amplitude_destination_count"] = json!(1);
+        plan["inspection_summary"]["schedule"]["replay_target_count"] = json!(0);
+        plan["inspection_summary"]["schedule"]["retained_helicity_count"] =
+            json!(resolved_helicity_count);
+        plan["inspection_summary"]["schedule"]["resolved_helicity_count"] =
+            json!(resolved_helicity_count);
+        plan["inspection_summary"]
+            .as_object_mut()
+            .unwrap()
+            .remove("structural_zero_physical_sector_certificate");
+        plan["inspection_summary"]["selector_work_certificate"]["representatives"] = json!([]);
+        plan["helicity_dispatch"] = json!({
+            "abi": RECURRENCE_HELICITY_DISPATCH_ABI,
+            "path": format!(
+                "recurrence/schedules/{composite_schedule_digest}/{RECURRENCE_HELICITY_DISPATCH_PATH}"
+            ),
+            "size_bytes": 96,
+            "sha256": dispatch_sha256,
+            "base_runtime_layout_digest": runtime_layout_digest,
+            "resolved_helicity_count": resolved_helicity_count,
+        });
+        value["helicity_selector_companion"] = json!({
+            "schema_version": 2,
+            "kind": RECURRENCE_HELICITY_SELECTOR_COMPANION_KIND,
+            "process_digest": process_digest,
+            "plan": plan,
+            "color_contraction": {
+                "source": "primary",
+                "view": RECURRENCE_PRIMARY_LOCAL_COLOR_VIEW,
+            },
+        });
+    }
+
+    fn legacy_nlc_hzz_fixture_value() -> Value {
+        let mut value: Value = serde_json::from_slice(include_bytes!(
+            "../../tests/fixtures/recurrence_execution_hzz_nlc.json"
+        ))
+        .unwrap();
+        upgrade_hzz_fixture_manifest(&mut value);
+        value
+    }
+
+    fn nlc_hzz_fixture_value() -> Value {
+        let mut value = legacy_nlc_hzz_fixture_value();
+        add_hzz_contracted_selector_representative(&mut value);
+        value
+    }
+
+    fn lc_hzz_fixture_value() -> Value {
+        let mut value: Value = serde_json::from_slice(include_bytes!(
+            "../../tests/fixtures/recurrence_execution_hzz_lc.json"
+        ))
+        .unwrap();
+        upgrade_hzz_fixture_manifest(&mut value);
+        value
+    }
+
+    fn upgrade_hzz_fixture_manifest(value: &mut Value) {
+        value["compiled_model_digest"] = json!("bb".repeat(32));
+        value["recurrence_template_catalog_digest"] = json!("cc".repeat(32));
+        value["plan"]["process_binding"]["abi"] = json!(RECURRENCE_PROCESS_BINDING_ABI);
+        value["plan"]["process_binding"]["native_schedule_semantic_digest"] =
+            value["plan"]["process_binding"]["schedule_digest"].clone();
+        value["plan"]["process_binding"]["process_digest"] = json!("12".repeat(32));
+        if value["plan"]["inspection_summary"]["lc_flow_layout"] == json!("contracted-color-union")
+        {
+            let sector_count = value["plan"]["inspection_summary"]["sector_count"].clone();
+            let resolved_helicity_count =
+                value["plan"]["inspection_summary"]["schedule"]["resolved_helicity_count"].clone();
+            value["plan"]["inspection_summary"]["structural_zero_physical_sector_certificate"] = json!({
+                "proof_kind": CLOSURE_TARGET_DOMAIN_PROOF_KIND,
+                "semantic_digest": "de".repeat(32),
+                "sector_count": sector_count,
+                "resolved_helicity_count": resolved_helicity_count,
+                "certified_structural_zero_sector_count": 0
+            });
+        }
+    }
+
+    fn manifest_bytes_with_size(size: usize) -> Vec<u8> {
+        let mut bytes = serde_json::to_vec(&manifest()).unwrap();
+        assert!(bytes.len() <= size);
+        bytes.resize(size, b' ');
+        bytes
+    }
+
+    #[test]
+    fn accepts_strict_typed_recurrence_manifest() {
+        let parsed = parse(&manifest()).unwrap();
+        assert_eq!(parsed.runtime_metadata.public_color_flows.len(), 1);
+        assert_eq!(parsed.runtime_metadata.source_templates.len(), 1);
+        assert_eq!(parsed.plan.runtime_schedule.member_count, 1);
+        assert_eq!(
+            parsed.plan.inspection_summary.direct_arena.row_group_count,
+            4
+        );
+    }
+
+    #[test]
+    fn accepts_and_validates_generated_structural_zero_sector_provenance() {
+        let value = full_hzz_fixture_value();
+        let parsed = parse_hzz_fixture(&serde_json::to_vec(&value).unwrap(), "full").unwrap();
+        let certificate = parsed
+            .plan
+            .inspection_summary
+            .structural_zero_physical_sector_certificate
+            .unwrap();
+        assert_eq!(certificate.proof_kind, CLOSURE_TARGET_DOMAIN_PROOF_KIND);
+        assert_eq!(certificate.sector_count, 1);
+        assert_eq!(certificate.resolved_helicity_count, 54);
+
+        let mut mismatched = value;
+        mismatched["plan"]["inspection_summary"]["structural_zero_physical_sector_certificate"]["sector_count"] =
+            json!(2);
+        let error =
+            parse_hzz_fixture(&serde_json::to_vec(&mismatched).unwrap(), "full").unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("disagrees with its inspection domain")
+        );
+    }
+
+    #[test]
+    fn accepts_resident_peak_contribution_semantics() {
+        let mut value = manifest();
+        value["plan"]["inspection_summary"]["construction"]["peak_contribution_count_semantics"] =
+            json!("resident-pending-contributions-v1");
+
+        let parsed = parse(&value).unwrap();
+
+        assert_eq!(
+            parsed
+                .plan
+                .inspection_summary
+                .construction
+                .peak_contribution_count_semantics,
+            Some(RecurrencePeakContributionCountSemantics::ResidentPendingContributionsV1)
+        );
+    }
+
+    #[test]
+    fn rejects_unknown_peak_contribution_semantics() {
+        let mut value = manifest();
+        value["plan"]["inspection_summary"]["construction"]["peak_contribution_count_semantics"] =
+            json!("unknown");
+
+        assert!(parse(&value).is_err());
+    }
+
+    #[test]
+    fn accepts_python_emitted_selector_work_schema() {
+        let mut value = manifest();
+        add_python_selector_work_certificate(&mut value);
+
+        let parsed = parse(&value).unwrap();
+
+        assert_eq!(
+            parsed
+                .plan
+                .inspection_summary
+                .direct_arena
+                .cache_footprint_policy,
+            Some(RecurrenceCacheFootprintPolicy::SelectorActiveMaxV1)
+        );
+    }
+
+    #[test]
+    fn accepts_contracted_selector_work_representatives() {
+        let value = full_hzz_fixture_value();
+
+        let parsed = parse_hzz_fixture(&serde_json::to_vec(&value).unwrap(), "full").unwrap();
+
+        assert_eq!(
+            parsed
+                .plan
+                .inspection_summary
+                .selector_work_certificate
+                .as_ref()
+                .unwrap()
+                .representatives
+                .len(),
+            1
+        );
+    }
+
+    #[test]
+    fn accepts_persisted_helicity_selector_companion_v2() {
+        let mut value = full_hzz_fixture_value();
+        add_hzz_helicity_selector_companion(&mut value);
+
+        let parsed =
+            parse_hzz_companion_fixture(&serde_json::to_vec(&value).unwrap(), "full").unwrap();
+
+        assert_eq!(parsed.process_digest, Some("10".repeat(32)));
+        let companion = parsed.helicity_selector_companion.unwrap();
+        assert_eq!(companion.schema_version, 2);
+        assert_eq!(companion.kind, RECURRENCE_HELICITY_SELECTOR_COMPANION_KIND);
+        assert_eq!(
+            companion.plan.inspection_summary.lc_flow_layout,
+            RecurrenceLcFlowLayout::AllFlowUnion
+        );
+        assert_eq!(
+            companion
+                .plan
+                .helicity_dispatch
+                .as_ref()
+                .unwrap()
+                .resolved_helicity_count,
+            108
+        );
+        assert_eq!(companion.color_contraction.source, "primary");
+        assert_eq!(
+            companion.color_contraction.view,
+            RECURRENCE_PRIMARY_LOCAL_COLOR_VIEW
+        );
+    }
+
+    #[test]
+    fn helicity_selector_composite_digest_matches_the_python_writer() {
+        assert_eq!(
+            recurrence_helicity_selector_schedule_digest(&"21".repeat(32), &"23".repeat(32),)
+                .unwrap(),
+            "5913a2ef2448054b070d57414e621e2a9892676d7ecac59ec161fbf82b3580e7"
+        );
+    }
+
+    #[test]
+    fn rejects_incomplete_or_tampered_helicity_selector_companion_contract() {
+        let mut baseline = full_hzz_fixture_value();
+        add_hzz_helicity_selector_companion(&mut baseline);
+
+        let mut missing_process_digest = baseline.clone();
+        missing_process_digest["process_digest"] = Value::Null;
+        assert!(
+            parse_hzz_companion_fixture(
+                &serde_json::to_vec(&missing_process_digest).unwrap(),
+                "full",
+            )
+            .is_err()
+        );
+
+        let mut swapped_primary_process = baseline.clone();
+        swapped_primary_process["plan"]["process_binding"]["process_digest"] =
+            json!("30".repeat(32));
+        assert!(
+            parse_hzz_companion_fixture(
+                &serde_json::to_vec(&swapped_primary_process).unwrap(),
+                "full",
+            )
+            .is_err()
+        );
+
+        let mut missing_capability = baseline.clone();
+        missing_capability["required_runtime_capabilities"]
+            .as_array_mut()
+            .unwrap()
+            .retain(|value| {
+                value.as_str() != Some(RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY)
+            });
+        assert!(
+            parse_hzz_companion_fixture(&serde_json::to_vec(&missing_capability).unwrap(), "full",)
+                .is_err()
+        );
+
+        for (pointer, replacement) in [
+            ("/helicity_selector_companion/schema_version", json!(1)),
+            (
+                "/helicity_selector_companion/kind",
+                json!("pyamplicol-recurrence-helicity-selector-companion-v1"),
+            ),
+            (
+                "/helicity_selector_companion/process_digest",
+                json!("40".repeat(32)),
+            ),
+            (
+                "/helicity_selector_companion/plan/prepared_kernel_pack_digest",
+                json!("41".repeat(32)),
+            ),
+            (
+                "/helicity_selector_companion/plan/direct_template_catalog_digest",
+                json!("42".repeat(32)),
+            ),
+            (
+                "/helicity_selector_companion/plan/inspection_summary/lc_flow_layout",
+                json!("contracted-color-union"),
+            ),
+            (
+                "/helicity_selector_companion/plan/inspection_summary/schedule/amplitude_destination_count",
+                json!(2),
+            ),
+            (
+                "/helicity_selector_companion/plan/inspection_summary/schedule/retained_helicity_count",
+                json!(107),
+            ),
+            (
+                "/plan/inspection_summary/schedule/retained_helicity_count",
+                json!(107),
+            ),
+            (
+                "/helicity_selector_companion/plan/process_binding/native_schedule_semantic_digest",
+                json!("43".repeat(32)),
+            ),
+            (
+                "/helicity_selector_companion/plan/process_binding/schedule_digest",
+                json!("44".repeat(32)),
+            ),
+            (
+                "/helicity_selector_companion/plan/process_binding/path",
+                json!(RECURRENCE_PROCESS_BINDING_PATH),
+            ),
+            (
+                "/helicity_selector_companion/plan/runtime_schedule/path",
+                json!("recurrence-runtime.pacbin"),
+            ),
+            (
+                "/helicity_selector_companion/plan/helicity_dispatch/abi",
+                json!("pyamplicol-recurrence-helicity-dispatch-v0"),
+            ),
+            (
+                "/helicity_selector_companion/plan/helicity_dispatch/path",
+                json!(RECURRENCE_HELICITY_DISPATCH_PATH),
+            ),
+            (
+                "/helicity_selector_companion/plan/helicity_dispatch/size_bytes",
+                json!(0),
+            ),
+            (
+                "/helicity_selector_companion/plan/helicity_dispatch/sha256",
+                json!("not-a-sha"),
+            ),
+            (
+                "/helicity_selector_companion/plan/helicity_dispatch/base_runtime_layout_digest",
+                json!("45".repeat(32)),
+            ),
+            (
+                "/helicity_selector_companion/plan/helicity_dispatch/resolved_helicity_count",
+                json!(107),
+            ),
+            (
+                "/helicity_selector_companion/color_contraction/source",
+                json!("companion"),
+            ),
+            (
+                "/helicity_selector_companion/color_contraction/view",
+                json!("primary-local-color-view-v2"),
+            ),
+            (
+                "/runtime_metadata/color_contraction/storage",
+                json!("expanded"),
+            ),
+        ] {
+            let mut invalid = baseline.clone();
+            *invalid.pointer_mut(pointer).unwrap() = replacement;
+            assert!(
+                parse_hzz_companion_fixture(&serde_json::to_vec(&invalid).unwrap(), "full")
+                    .is_err(),
+                "accepted invalid companion field at {pointer}",
+            );
+        }
+    }
+
+    #[test]
+    fn accepts_legacy_contracted_replay_without_selector_work_representatives() {
+        for (value, accuracy) in [
+            (legacy_full_hzz_fixture_value(), "full"),
+            (legacy_nlc_hzz_fixture_value(), "nlc"),
+        ] {
+            let parsed = parse_hzz_fixture(&serde_json::to_vec(&value).unwrap(), accuracy).unwrap();
+            assert!(
+                parsed
+                    .plan
+                    .inspection_summary
+                    .selector_work_certificate
+                    .as_ref()
+                    .unwrap()
+                    .representatives
+                    .is_empty()
+            );
+        }
+    }
+
+    #[test]
+    fn rejects_contracted_selector_work_representatives_without_replay_targets() {
+        let mut value = full_hzz_fixture_value();
+        value["plan"]["inspection_summary"]["schedule"]["replay_target_count"] = json!(0);
+
+        assert!(
+            parse_hzz_fixture(&serde_json::to_vec(&value).unwrap(), "full")
+                .unwrap_err()
+                .to_string()
+                .contains("representatives disagree with the flow layout")
+        );
+    }
+
+    #[test]
+    fn accepts_python_emitted_color_projection_certificate() {
+        let mut value = manifest();
+        add_python_selector_work_certificate(&mut value);
+        add_python_color_projection_certificate(&mut value);
+
+        let parsed = parse(&value).unwrap();
+
+        assert_eq!(parsed.plan.runtime_schedule.member_count, 2);
+        assert_eq!(parsed.plan.runtime_schedule.unpacked_size_bytes, 640);
+        assert_eq!(
+            parsed
+                .plan
+                .inspection_summary
+                .color_projection_certificate
+                .as_ref()
+                .unwrap()
+                .size_bytes,
+            128
+        );
+    }
+
+    #[test]
+    fn accepts_python_emitted_relation_discovery_summaries() {
+        for mode in ["diagnostic", "certified-reuse"] {
+            let mut value = manifest();
+            add_python_relation_discovery(&mut value, mode);
+
+            let parsed = parse(&value).unwrap();
+
+            assert_eq!(
+                parsed
+                    .plan
+                    .inspection_summary
+                    .relation_discovery
+                    .as_ref()
+                    .unwrap()
+                    .certificate_count,
+                0
+            );
+        }
+    }
+
+    #[test]
+    fn rejects_relation_discovery_that_mutates_diagnostic_mode() {
+        let mut value = manifest();
+        add_python_relation_discovery(&mut value, "diagnostic");
+        value["plan"]["inspection_summary"]["relation_discovery"]["applied_relation_count"] =
+            json!(1);
+
+        assert!(
+            parse(&value)
+                .unwrap_err()
+                .to_string()
+                .contains("diagnostic recurrence relation discovery altered")
+        );
+    }
+
+    #[test]
+    fn rejects_tampered_rejected_diagnostics_commitment() {
+        let mut value = manifest();
+        add_python_relation_discovery(&mut value, "diagnostic");
+        value["plan"]["inspection_summary"]["relation_discovery"]["rejected_candidate_diagnostics"]
+            ["retained_sha256"] = json!("00".repeat(32));
+
+        assert!(
+            parse(&value)
+                .unwrap_err()
+                .to_string()
+                .contains("retained rejection diagnostics commitment")
+        );
+    }
+
+    #[test]
+    fn rejects_tampered_full_rejection_census_and_decision_commitments() {
+        for field in ["full_census_sha256", "full_rejection_sha256"] {
+            let mut value = manifest();
+            add_python_relation_discovery(&mut value, "diagnostic");
+            value["plan"]["inspection_summary"]["relation_discovery"]["rejected_candidate_diagnostics"]
+                [field] = json!("00".repeat(32));
+
+            assert!(
+                parse(&value)
+                    .unwrap_err()
+                    .to_string()
+                    .contains("full rejection census or decision commitment"),
+                "tampered {field} was not rejected"
+            );
+        }
+    }
+
+    fn mark_relation_discovery_as_full_probe(value: &mut Value) {
+        let discovery = &mut value["plan"]["inspection_summary"]["relation_discovery"];
+        discovery["probe"]["candidate_only"] = json!(false);
+        for field in [
+            "runtime_parameter_schema_sha256",
+            "candidate_observation_batch_sha256",
+            "verification_observation_batch_sha256",
+            "decision_sha256",
+        ] {
+            discovery["probe"][field] = json!("bb".repeat(32));
+        }
+    }
+
+    #[test]
+    fn rejects_full_probe_with_removed_rejected_diagnostics() {
+        let mut value = manifest();
+        add_python_relation_discovery(&mut value, "diagnostic");
+        mark_relation_discovery_as_full_probe(&mut value);
+        value["plan"]["inspection_summary"]["relation_discovery"]
+            .as_object_mut()
+            .unwrap()
+            .remove("rejected_candidate_diagnostics");
+
+        assert!(
+            parse(&value)
+                .unwrap_err()
+                .to_string()
+                .contains("require rejected-candidate diagnostics")
+        );
+    }
+
+    #[test]
+    fn rejects_full_probe_with_null_rejected_diagnostics() {
+        let mut value = manifest();
+        add_python_relation_discovery(&mut value, "diagnostic");
+        mark_relation_discovery_as_full_probe(&mut value);
+        value["plan"]["inspection_summary"]["relation_discovery"]["rejected_candidate_diagnostics"] =
+            Value::Null;
+
+        assert!(
+            parse(&value)
+                .unwrap_err()
+                .to_string()
+                .contains("require rejected-candidate diagnostics")
+        );
+    }
+
+    #[test]
+    fn rejects_raw_uncertified_count_that_disagrees_with_verification_failures() {
+        let mut value = manifest();
+        add_python_relation_discovery(&mut value, "diagnostic");
+        mark_relation_discovery_as_full_probe(&mut value);
+        let discovery = &mut value["plan"]["inspection_summary"]["relation_discovery"];
+        discovery["uncertified_candidate_count"] = json!(1);
+
+        assert!(
+            parse(&value)
+                .unwrap_err()
+                .to_string()
+                .contains("authenticated raw rejection census is inconsistent")
+        );
+    }
+
+    #[test]
+    fn accepts_actual_python_emitted_full_lc_and_nlc_manifests() {
+        let fixtures = [
+            (full_hzz_fixture_value(), "full", Some(54)),
+            (lc_hzz_fixture_value(), "lc", None),
+            (nlc_hzz_fixture_value(), "nlc", Some(54)),
+        ];
+
+        for (value, color_accuracy, expected_materialized_destinations) in fixtures {
+            let parsed =
+                parse_hzz_fixture(&serde_json::to_vec(&value).unwrap(), color_accuracy).unwrap();
+            assert_eq!(
+                parsed
+                    .runtime_metadata
+                    .color_contraction
+                    .as_ref()
+                    .and_then(|metadata| metadata.materialized_destination_count),
+                expected_materialized_destinations
+            );
+        }
+    }
+
+    #[test]
+    fn materialized_destination_count_is_backward_compatible_and_validated() {
+        let mut value = full_hzz_fixture_value();
+        value["runtime_metadata"]["color_contraction"]
+            .as_object_mut()
+            .unwrap()
+            .remove("materialized_destination_count");
+        parse_hzz_fixture(&serde_json::to_vec(&value).unwrap(), "full").unwrap();
+
+        value["runtime_metadata"]["color_contraction"]["materialized_destination_count"] =
+            json!(53);
+        assert!(
+            parse_hzz_fixture(&serde_json::to_vec(&value).unwrap(), "full")
+                .unwrap_err()
+                .to_string()
+                .contains("color-contraction summary is inconsistent")
+        );
+    }
+
+    #[test]
+    fn rejects_inconsistent_color_projection_certificate_metadata() {
+        let mut bad_members = manifest();
+        add_python_selector_work_certificate(&mut bad_members);
+        add_python_color_projection_certificate(&mut bad_members);
+        bad_members["plan"]["runtime_schedule"]["member_count"] = json!(1);
+        assert!(
+            parse(&bad_members)
+                .unwrap_err()
+                .to_string()
+                .contains("plan member metadata disagrees")
+        );
+
+        let mut bad_unpacked_size = manifest();
+        add_python_selector_work_certificate(&mut bad_unpacked_size);
+        add_python_color_projection_certificate(&mut bad_unpacked_size);
+        bad_unpacked_size["plan"]["runtime_schedule"]["unpacked_size_bytes"] = json!(639);
+        assert!(
+            parse(&bad_unpacked_size)
+                .unwrap_err()
+                .to_string()
+                .contains("plan member metadata disagrees")
+        );
+
+        let mut not_publishable = manifest();
+        add_python_selector_work_certificate(&mut not_publishable);
+        add_python_color_projection_certificate(&mut not_publishable);
+        not_publishable["plan"]["inspection_summary"]["color_projection_certificate"]["publishable"] =
+            json!(false);
+        assert!(
+            parse(&not_publishable)
+                .unwrap_err()
+                .to_string()
+                .contains("metadata is not publishable")
+        );
+
+        let mut wrong_layout = manifest();
+        add_python_color_projection_certificate(&mut wrong_layout);
+        wrong_layout["plan"]["inspection_summary"]["lc_flow_layout"] = json!("all-flow-union");
+        wrong_layout["recurrence_summary"]["lc_flow_layout"] = json!("all-flow-union");
+        assert!(
+            parse(&wrong_layout)
+                .unwrap_err()
+                .to_string()
+                .contains("unsupported recurrence color-projection certificate contract")
+        );
+    }
+
+    #[test]
+    fn accepts_persisted_selector_work_schema() {
+        for layout in ["all-flow-union", "contracted-color-union"] {
+            let mut value = inspection_summary();
+            value["lc_flow_layout"] = json!(layout);
+            value["schedule"]["replay_target_count"] = json!(0);
+            if layout == "contracted-color-union" {
+                value["structural_zero_physical_sector_certificate"] = json!({
+                    "proof_kind": CLOSURE_TARGET_DOMAIN_PROOF_KIND,
+                    "semantic_digest": "de".repeat(32),
+                    "sector_count": 1,
+                    "resolved_helicity_count": 1,
+                    "certified_structural_zero_sector_count": 0
+                });
+            }
+            value["selector_work_certificate"] = json!({
+                "schema_version": 1,
+                "binding": "runtime_layout_digest",
+                "persisted_union": {
+                    "current_count": 1,
+                    "semantic_component_count": 1,
+                    "source_row_count": 1,
+                    "contribution_count": 0,
+                    "finalization_count": 1,
+                    "closure_count": 0,
+                    "row_count": 2
+                },
+                "representatives": []
+            });
+            value["direct_arena"]["cache_footprint_policy"] = json!("persisted-arena-v1");
+            let parsed = serde_json::from_value::<RecurrenceInspectionSummary>(value).unwrap();
+
+            parsed.validate("x_to_x", "lc").unwrap();
+        }
+    }
+
+    #[test]
+    fn rejects_cache_footprint_policy_for_another_flow_layout() {
+        let mut value = manifest();
+        add_python_selector_work_certificate(&mut value);
+        value["plan"]["inspection_summary"]["direct_arena"]["cache_footprint_policy"] =
+            json!("persisted-arena-v1");
+
+        let error = parse(&value).unwrap_err();
+
+        assert!(
+            error
+                .to_string()
+                .contains("cache-footprint policy disagrees with its flow layout")
+        );
+    }
+
+    #[test]
+    fn rejects_standalone_selector_work_schema_member() {
+        let mut policy_only = manifest();
+        policy_only["plan"]["inspection_summary"]["direct_arena"]["cache_footprint_policy"] =
+            json!("selector-active-max-v1");
+        assert!(
+            parse(&policy_only)
+                .unwrap_err()
+                .to_string()
+                .contains("must be declared together")
+        );
+
+        let mut certificate_only = manifest();
+        add_python_selector_work_certificate(&mut certificate_only);
+        certificate_only["plan"]["inspection_summary"]["direct_arena"]
+            .as_object_mut()
+            .unwrap()
+            .remove("cache_footprint_policy");
+        assert!(
+            parse(&certificate_only)
+                .unwrap_err()
+                .to_string()
+                .contains("must be declared together")
+        );
+    }
+
+    #[test]
+    fn rejects_inconsistent_selector_work_certificates() {
+        let mut wrong_schema = manifest();
+        add_python_selector_work_certificate(&mut wrong_schema);
+        wrong_schema["plan"]["inspection_summary"]["selector_work_certificate"]["schema_version"] =
+            json!(2);
+        assert!(
+            parse(&wrong_schema)
+                .unwrap_err()
+                .to_string()
+                .contains("certificate identity is unsupported")
+        );
+
+        let mut wrong_binding = manifest();
+        add_python_selector_work_certificate(&mut wrong_binding);
+        wrong_binding["plan"]["inspection_summary"]["selector_work_certificate"]["binding"] =
+            json!("semantic_digest");
+        assert!(
+            parse(&wrong_binding)
+                .unwrap_err()
+                .to_string()
+                .contains("certificate identity is unsupported")
+        );
+
+        let mut wrong_union = manifest();
+        add_python_selector_work_certificate(&mut wrong_union);
+        wrong_union["plan"]["inspection_summary"]["selector_work_certificate"]["persisted_union"]
+            ["row_count"] = json!(3);
+        assert!(
+            parse(&wrong_union)
+                .unwrap_err()
+                .to_string()
+                .contains("persisted selector-work summary disagrees")
+        );
+
+        let mut duplicate = manifest();
+        add_python_selector_work_certificate(&mut duplicate);
+        let representative =
+            duplicate["plan"]["inspection_summary"]["selector_work_certificate"]["representatives"]
+                [0]
+            .clone();
+        duplicate["plan"]["inspection_summary"]["selector_work_certificate"]["representatives"]
+            .as_array_mut()
+            .unwrap()
+            .push(representative);
+        duplicate["plan"]["inspection_summary"]["schedule"]["replay_target_count"] = json!(2);
+        assert!(
+            parse(&duplicate)
+                .unwrap_err()
+                .to_string()
+                .contains("representative sector is duplicated")
+        );
+
+        let mut out_of_range = manifest();
+        add_python_selector_work_certificate(&mut out_of_range);
+        out_of_range["plan"]["inspection_summary"]["selector_work_certificate"]["representatives"]
+            [0]["representative_sector_id"] = json!(1);
+        assert!(
+            parse(&out_of_range)
+                .unwrap_err()
+                .to_string()
+                .contains("representative is inconsistent")
+        );
+
+        let mut wrong_public_flow_count = manifest();
+        add_python_selector_work_certificate(&mut wrong_public_flow_count);
+        wrong_public_flow_count["plan"]["inspection_summary"]["selector_work_certificate"]["representatives"]
+            [0]["public_flow_count"] = json!(2);
+        assert!(
+            parse(&wrong_public_flow_count)
+                .unwrap_err()
+                .to_string()
+                .contains("public-flow count disagrees with replay targets")
+        );
+    }
+
+    #[test]
+    fn accepts_observed_large_recurrence_manifest() {
+        let bytes = manifest_bytes_with_size(40_826_959);
+        let parsed = parse_recurrence_execution_manifest(
+            &bytes,
+            "processes/x_to_x/execution.json",
+            &outer(),
+        )
+        .unwrap();
+
+        assert_eq!(parsed.key, "x_to_x");
+    }
+
+    #[test]
+    fn accepts_runtime_options_above_old_reader_ceilings() {
+        let mut value = manifest();
+        value["runtime_options"]["point_tile_size"] = json!(1_048_577);
+        value["runtime_options"]["workspace_mib"] = json!(4097);
+
+        parse(&value).unwrap();
+
+        value["runtime_options"]["workspace_mib"] = json!(0);
+        assert!(parse(&value).is_err());
+
+        value["runtime_options"]["workspace_mib"] = json!(u64::from(u32::MAX) + 1);
+        assert!(parse(&value).is_err());
+
+        value["runtime_options"]["workspace_mib"] = json!(4097);
+        value["runtime_options"]["point_tile_size"] = json!(u64::from(u32::MAX) + 1);
+        assert!(parse(&value).is_err());
+    }
+
+    #[test]
+    fn accepts_large_authenticated_recurrence_payload_metadata() {
+        let mut value = manifest();
+        add_python_selector_work_certificate(&mut value);
+        add_python_color_projection_certificate(&mut value);
+
+        let member_size = 1_u64 << 40;
+        let certificate_size = member_size + 1;
+        let unpacked_size = member_size + certificate_size;
+        let container_size = unpacked_size + 4096;
+        value["plan"]["runtime_schedule"]["size_bytes"] = json!(container_size);
+        value["plan"]["runtime_schedule"]["unpacked_size_bytes"] = json!(unpacked_size);
+        value["plan"]["process_binding"]["size_bytes"] = json!(1_u64 << 30);
+        value["plan"]["inspection_summary"]["runtime_container_member"]["size_bytes"] =
+            json!(member_size);
+        value["plan"]["inspection_summary"]["runtime_container_member"]["container_size_bytes"] =
+            json!(container_size);
+        value["plan"]["inspection_summary"]["color_projection_certificate"]["size_bytes"] =
+            json!(certificate_size);
+
+        let parsed = parse(&value).unwrap();
+
+        assert_eq!(parsed.plan.runtime_schedule.size_bytes, container_size);
+        assert_eq!(
+            parsed.plan.runtime_schedule.unpacked_size_bytes,
+            unpacked_size
+        );
+        assert_eq!(parsed.plan.process_binding.size_bytes, 1_u64 << 30);
+        assert_eq!(
+            parsed
+                .plan
+                .inspection_summary
+                .runtime_container_member
+                .size_bytes,
+            member_size
+        );
+        assert_eq!(
+            parsed
+                .plan
+                .inspection_summary
+                .color_projection_certificate
+                .unwrap()
+                .size_bytes,
+            certificate_size
+        );
+    }
+
+    #[test]
+    fn rejects_zero_recurrence_payload_metadata() {
+        let mut baseline = manifest();
+        add_python_selector_work_certificate(&mut baseline);
+        add_python_color_projection_certificate(&mut baseline);
+
+        for pointer in [
+            "/plan/runtime_schedule/size_bytes",
+            "/plan/runtime_schedule/unpacked_size_bytes",
+            "/plan/process_binding/size_bytes",
+            "/plan/inspection_summary/runtime_container_member/size_bytes",
+            "/plan/inspection_summary/runtime_container_member/container_size_bytes",
+            "/plan/inspection_summary/color_projection_certificate/size_bytes",
+        ] {
+            let mut value = baseline.clone();
+            *value.pointer_mut(pointer).unwrap() = json!(0);
+            assert!(
+                parse(&value).is_err(),
+                "accepted zero metadata at {pointer}"
+            );
+        }
+
+        let mut color = full_hzz_fixture_value();
+        color["runtime_metadata"]["color_contraction"]["size_bytes"] = json!(0);
+        assert!(
+            parse_hzz_fixture(&serde_json::to_vec(&color).unwrap(), "full").is_err(),
+            "accepted zero recurrence color payload size"
+        );
+    }
+
+    #[test]
+    fn accepts_large_recurrence_color_payload_metadata() {
+        let mut value = full_hzz_fixture_value();
+        value["runtime_metadata"]["color_contraction"]["size_bytes"] = json!(1_u64 << 40);
+
+        let parsed = parse_hzz_fixture(&serde_json::to_vec(&value).unwrap(), "full").unwrap();
+
+        assert_eq!(
+            parsed
+                .runtime_metadata
+                .color_contraction
+                .unwrap()
+                .size_bytes,
+            1_u64 << 40
+        );
+    }
+
+    #[test]
+    fn accepts_large_generated_text_but_still_rejects_empty_text() {
+        let mut value = manifest();
+        let coupling_policy = "x".repeat(4097);
+        value["runtime_metadata"]["normalization"]["coupling_policy"] = json!(coupling_policy);
+
+        let parsed = parse(&value).unwrap();
+        assert_eq!(
+            parsed.runtime_metadata.normalization.coupling_policy.len(),
+            4097
+        );
+
+        value["runtime_metadata"]["normalization"]["coupling_policy"] = json!("");
+        assert!(
+            parse(&value)
+                .unwrap_err()
+                .to_string()
+                .contains("recurrence normalization coupling policy is empty")
+        );
+    }
+
+    #[test]
+    fn rejects_unknown_runtime_metadata_fields() {
+        let mut value = manifest();
+        value["runtime_metadata"]["opaque"] = json!({});
+        let error = parse(&value).unwrap_err();
+        assert!(error.to_string().contains("unknown field `opaque`"));
+    }
+
+    #[test]
+    fn rejects_public_color_flow_outside_construction_sectors() {
+        let mut value = manifest();
+        value["runtime_metadata"]["public_color_flows"][0]["construction_sector_id"] = json!(1);
+        let error = parse(&value).unwrap_err();
+        assert!(error.to_string().contains("absent construction sector"));
+    }
+
+    #[test]
+    fn rejects_noncanonical_public_color_flow_target_sector() {
+        let mut value = manifest();
+        value["runtime_metadata"]["public_color_flows"][0]["target_sector_id"] = json!(1);
+        let error = parse(&value).unwrap_err();
+        assert!(error.to_string().contains("not dense or in range"));
+    }
+
+    #[test]
+    fn rejects_source_ir_and_crossing_disagreement() {
+        let mut value = manifest();
+        value["runtime_metadata"]["source_templates"][0]["crossing"]["phase"] = json!([0.0, 1.0]);
+        let error = parse(&value).unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("disagrees with its typed SourceIR")
+        );
+    }
+
+    #[test]
+    fn rejects_noncanonical_container_and_capability_metadata() {
+        let mut bad_path = manifest();
+        bad_path["plan"]["runtime_schedule"]["path"] = json!("../recurrence-runtime.pacbin");
+        assert!(
+            parse(&bad_path)
+                .unwrap_err()
+                .to_string()
+                .contains("canonical")
+        );
+
+        let mut bad_capabilities = manifest();
+        bad_capabilities["required_runtime_capabilities"] = json!([
+            RECURRENCE_RUNTIME_CAPABILITY,
+            RECURRENCE_LC_COLOR_CAPABILITY
+        ]);
+        assert!(
+            parse(&bad_capabilities)
+                .unwrap_err()
+                .to_string()
+                .contains("must require exactly")
+        );
+
+        let mut bad_member_path = manifest();
+        bad_member_path["plan"]["runtime_schedule"]["plan_member_path"] =
+            json!("plan/recurrence-plan-v1.bin");
+        assert!(
+            parse(&bad_member_path)
+                .unwrap_err()
+                .to_string()
+                .contains("Direct-Arena v2 schedule member path")
+        );
+    }
+
+    #[test]
+    fn rejects_pre_direct_arena_abis() {
+        let mut value = manifest();
+        value["recurrence_plan_abi"] = json!("pyamplicol-recurrence-plan-v1");
+        let error = parse(&value).unwrap_err();
+        assert!(error.to_string().contains("Direct-Arena v2 plan ABI"));
+        assert!(error.to_string().contains("regenerate"));
+    }
+
+    #[test]
+    fn rejects_cross_record_direct_digest_mismatches() {
+        let mut bad_pack = manifest();
+        bad_pack["plan"]["prepared_kernel_pack_digest"] = json!("99".repeat(32));
+        assert!(
+            parse(&bad_pack)
+                .unwrap_err()
+                .to_string()
+                .contains("prepared-kernel pack digest differs")
+        );
+
+        let mut bad_catalog = manifest();
+        bad_catalog["plan"]["direct_template_catalog_digest"] = json!("aa".repeat(32));
+        assert!(
+            parse(&bad_catalog)
+                .unwrap_err()
+                .to_string()
+                .contains("direct-template catalog digest differs")
+        );
+    }
+
+    #[test]
+    fn rejects_malformed_direct_authentication_digests() {
+        let mut value = manifest();
+        value["direct_template_catalog_digest"] = json!("A5".repeat(32));
+        let error = parse(&value).unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("64 lowercase hexadecimal characters")
+        );
+    }
+
+    #[test]
+    fn rejects_malformed_native_schedule_semantic_digest() {
+        let mut value = manifest();
+        value["plan"]["process_binding"]["native_schedule_semantic_digest"] =
+            json!("AB".repeat(32));
+        let error = parse(&value).unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("64 lowercase hexadecimal characters")
+        );
+    }
+
+    #[test]
+    fn rejects_missing_native_schedule_semantic_digest() {
+        let mut value = manifest();
+        value["plan"]["process_binding"]
+            .as_object_mut()
+            .unwrap()
+            .remove("native_schedule_semantic_digest");
+        let error = parse(&value).unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("native_schedule_semantic_digest"),
+            "{error}"
+        );
+    }
+
+    #[test]
+    fn rejects_inconsistent_direct_container_member_metadata() {
+        let mut value = manifest();
+        value["plan"]["inspection_summary"]["runtime_container_member"]["container_size_bytes"] =
+            json!(4095);
+        let error = parse(&value).unwrap_err();
+        assert!(error.to_string().contains("plan member metadata disagrees"));
+    }
+
+    #[test]
+    fn rejects_runtime_metadata_cross_record_mismatches() {
+        let mut bad_parameter_count = manifest();
+        bad_parameter_count["plan"]["inspection_summary"]["parameter_count"] = json!(2);
+        assert!(
+            parse(&bad_parameter_count)
+                .unwrap_err()
+                .to_string()
+                .contains("plan parameter count")
+        );
+
+        let mut bad_external = manifest();
+        bad_external["runtime_metadata"]["external_legs"][0]["physical_pdg"] = json!(24);
+        assert!(
+            parse(&bad_external)
+                .unwrap_err()
+                .to_string()
+                .contains("physical PDGs")
+        );
+    }
+
+    #[test]
+    fn rejects_nonbijective_source_state_remaps() {
+        let mut duplicate = manifest();
+        duplicate["plan"]["process_binding"]["remap"]["source_state_offsets"] = json!([0, 2]);
+        duplicate["plan"]["process_binding"]["remap"]["source_state_indices"] = json!([0, 0]);
+        assert!(
+            parse(&duplicate)
+                .unwrap_err()
+                .to_string()
+                .contains("dense zero-based permutation")
+        );
+
+        let mut invalid_offsets = manifest();
+        invalid_offsets["plan"]["process_binding"]["remap"]["source_state_offsets"] = json!([1, 2]);
+        invalid_offsets["plan"]["process_binding"]["remap"]["source_state_indices"] = json!([0, 1]);
+        assert!(
+            parse(&invalid_offsets)
+                .unwrap_err()
+                .to_string()
+                .contains("offsets are invalid")
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_process_pack.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_process_pack.rs
new file mode 100644
index 0000000000..6e7a8c72e2
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/recurrence_process_pack.rs
@@ -0,0 +1,866 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Process-owned operational Direct-executor records embedded in PACRDBN4.
+
+use super::eager_manifest::{
+    RecurrenceDirectParameterBindingManifest, RecurrenceDirectPlaneProjectionManifest,
+    RecurrenceDirectScalarProjectionManifest,
+};
+use crate::recurrence::{
+    DIRECT_NONE_U32, DirectExecutorRole, DirectRecurrencePlan, SemanticDigest,
+};
+use crate::{RusticolError, RusticolResult, Target};
+use std::collections::{BTreeMap, BTreeSet};
+
+pub(super) const RECURRENCE_PROCESS_BINDING_MAGIC_V4: &[u8; 8] = b"PACRDBN4";
+pub(super) const RECURRENCE_PROCESS_BINDING_VERSION_V4: u32 = 4;
+pub(super) const RECURRENCE_PROCESS_BINDING_HEADER_SIZE_V4: usize = 344;
+
+const PROCESS_EXECUTOR_FLAG_USES_EXACT_FACTOR: u16 = 1 << 0;
+const PROCESS_EXECUTOR_FLAGS_KNOWN: u16 = PROCESS_EXECUTOR_FLAG_USES_EXACT_FACTOR;
+const PREPARED_JIT_PORTABLE_TARGET: &str = "symjit-storage-v3-portable";
+const PREPARED_JIT_OPTIMIZATION_LEVEL: u32 = 2;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum ProcessExecutorBackend {
+    Jit,
+    Cpp,
+    Asm,
+}
+
+impl ProcessExecutorBackend {
+    pub(super) fn decode(value: u8) -> RusticolResult<Self> {
+        match value {
+            0 => Ok(Self::Jit),
+            1 => Ok(Self::Cpp),
+            2 => Ok(Self::Asm),
+            _ => Err(RusticolError::compatibility(format!(
+                "unsupported recurrence process-executor backend tag {value}"
+            ))),
+        }
+    }
+
+    pub(super) const fn as_str(self) -> &'static str {
+        match self {
+            Self::Jit => "jit",
+            Self::Cpp => "cpp",
+            Self::Asm => "asm",
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ProcessExecutorTarget {
+    pub(super) backend: ProcessExecutorBackend,
+    pub(super) target_triple: String,
+    pub(super) portable: bool,
+    pub(super) cpu_features: Vec<String>,
+}
+
+impl ProcessExecutorTarget {
+    pub(super) fn validate(&self, outer: &Target) -> RusticolResult<()> {
+        if self.cpu_features.windows(2).any(|pair| pair[0] >= pair[1]) {
+            return Err(RusticolError::integrity(
+                "recurrence process-executor CPU features are not sorted and unique",
+            ));
+        }
+        match self.backend {
+            ProcessExecutorBackend::Jit => {
+                if !matches!(std::env::consts::ARCH, "aarch64" | "x86_64")
+                    || !self.portable
+                    || self.target_triple != PREPARED_JIT_PORTABLE_TARGET
+                    || !self.cpu_features.is_empty()
+                    || outer.triple != crate::artifact::PORTABLE_64LE_ARTIFACT_TARGET
+                    || !outer.cpu_features.is_empty()
+                {
+                    return Err(RusticolError::compatibility(
+                        "portable recurrence JIT executors have an incompatible target",
+                    ));
+                }
+            }
+            ProcessExecutorBackend::Cpp | ProcessExecutorBackend::Asm => {
+                let host = crate::runtime_target_info();
+                let host_features = host.cpu_features.into_iter().collect::<BTreeSet<_>>();
+                if self.portable
+                    || self.target_triple != host.triple
+                    || outer.triple != host.triple
+                    || self
+                        .cpu_features
+                        .iter()
+                        .any(|feature| !host_features.contains(feature))
+                    || self.cpu_features != outer.cpu_features
+                {
+                    return Err(RusticolError::compatibility(
+                        "target-native recurrence executors are incompatible with this host",
+                    ));
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ProcessExecutorIdentities {
+    pub(super) compiled_model_digest: SemanticDigest,
+    pub(super) recurrence_template_catalog_digest: SemanticDigest,
+    pub(super) prepared_kernel_pack_digest: SemanticDigest,
+    pub(super) direct_template_catalog_digest: SemanticDigest,
+    pub(super) runtime_layout_digest: SemanticDigest,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ProcessDirectExecutorPack {
+    pub(super) identities: ProcessExecutorIdentities,
+    pub(super) target: ProcessExecutorTarget,
+    pub(super) catalog_executor_count: u32,
+    pub(super) descriptors: Vec<ProcessDirectExecutorDescriptor>,
+}
+
+impl ProcessDirectExecutorPack {
+    pub(super) fn validate_for_plan(
+        &self,
+        plan: &DirectRecurrencePlan,
+        expected_prepared_pack_digest: SemanticDigest,
+        expected_catalog_digest: SemanticDigest,
+        expected_root_runtime_layout_digest: SemanticDigest,
+    ) -> RusticolResult<()> {
+        if self.catalog_executor_count != plan.direct_executor_count()
+            || self.identities.prepared_kernel_pack_digest != expected_prepared_pack_digest
+            || self.identities.prepared_kernel_pack_digest != plan.prepared_pack_digest()
+            || self.identities.direct_template_catalog_digest != expected_catalog_digest
+            || self.identities.direct_template_catalog_digest
+                != plan.direct_template_catalog_digest()
+            || self.identities.runtime_layout_digest != expected_root_runtime_layout_digest
+        {
+            return Err(RusticolError::integrity(
+                "recurrence process-executor identities disagree with the remapped plan",
+            ));
+        }
+        let descriptors = self
+            .descriptors
+            .iter()
+            .map(|descriptor| (descriptor.direct_executor_id, descriptor))
+            .collect::<BTreeMap<_, _>>();
+        if descriptors.len() != self.descriptors.len() {
+            return Err(RusticolError::integrity(
+                "recurrence process-executor pack repeats an executor ID",
+            ));
+        }
+        if descriptors
+            .keys()
+            .any(|executor_id| *executor_id >= self.catalog_executor_count)
+        {
+            return Err(RusticolError::integrity(
+                "recurrence process-executor pack contains an out-of-range executor ID",
+            ));
+        }
+        let mut required = BTreeMap::<u32, DirectExecutorRole>::new();
+        for group in plan.row_groups() {
+            if group.direct_executor_id == DIRECT_NONE_U32 {
+                continue;
+            }
+            if group.direct_executor_id >= self.catalog_executor_count {
+                return Err(RusticolError::integrity(
+                    "recurrence plan references an executor outside its complete catalog",
+                ));
+            }
+            if required
+                .insert(group.direct_executor_id, group.role)
+                .is_some_and(|previous| previous != group.role)
+            {
+                return Err(RusticolError::integrity(format!(
+                    "recurrence executor {} is used with multiple roles",
+                    group.direct_executor_id
+                )));
+            }
+        }
+        if required.len() != descriptors.len()
+            || required.keys().copied().ne(descriptors.keys().copied())
+        {
+            return Err(RusticolError::integrity(
+                "recurrence process-executor pack has a missing or extra required executor",
+            ));
+        }
+        for (executor_id, role) in required {
+            let descriptor = descriptors.get(&executor_id).ok_or_else(|| {
+                RusticolError::integrity("required recurrence executor descriptor is absent")
+            })?;
+            if descriptor.role != role {
+                return Err(RusticolError::integrity(format!(
+                    "recurrence executor {executor_id} has the wrong role"
+                )));
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ProcessDirectExecutorDescriptor {
+    pub(super) direct_executor_id: u32,
+    pub(super) role: DirectExecutorRole,
+    pub(super) destination_component_count: u32,
+    pub(super) uses_exact_factor: bool,
+    pub(super) binding: ProcessDirectExecutorBinding,
+}
+
+#[derive(Clone, Debug)]
+pub(super) enum ProcessDirectExecutorBinding {
+    Source,
+    Intrinsic(ProcessIntrinsicExecutor),
+    Jit(ProcessJitExecutor),
+    Native(ProcessNativeExecutor),
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ProcessIntrinsicExecutor {
+    pub(super) runtime_template: String,
+    pub(super) scale: Option<ProcessIntrinsicScale>,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(super) struct ProcessIntrinsicScale {
+    pub(super) constant_real_bits: u64,
+    pub(super) constant_imag_bits: u64,
+    pub(super) parameter_index: Option<u32>,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ProcessJitExecutor {
+    pub(super) optimization_level: u32,
+    pub(super) plane_compression: bool,
+    pub(super) source_application_sha256: [u8; 32],
+    pub(super) source_application_path: String,
+    pub(super) source_application_abi: String,
+    pub(super) parameter_bindings: Vec<RecurrenceDirectParameterBindingManifest>,
+    pub(super) input_plane_projections: Vec<RecurrenceDirectPlaneProjectionManifest>,
+    pub(super) scalar_projections: Vec<RecurrenceDirectScalarProjectionManifest>,
+    pub(super) output_alias_inputs: Vec<u32>,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ProcessNativeExecutor {
+    pub(super) prepared_kernel_id: u32,
+    pub(super) library_path: String,
+    pub(super) native_entry_point: String,
+    pub(super) coupling: Option<(f64, f64)>,
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+#[cfg_attr(target_vendor = "apple", cold)]
+pub(super) fn decode_process_executor_descriptors(
+    bytes: &[u8],
+    cursor: &mut usize,
+    descriptor_count: u32,
+    catalog_executor_count: u32,
+    target: ProcessExecutorTarget,
+    identities: ProcessExecutorIdentities,
+) -> RusticolResult<ProcessDirectExecutorPack> {
+    if descriptor_count > catalog_executor_count {
+        return Err(RusticolError::integrity(
+            "recurrence process-executor descriptor count is outside its catalog domain",
+        ));
+    }
+    let capacity = usize::try_from(descriptor_count)
+        .map_err(|_| RusticolError::artifact("recurrence process-executor count exceeds usize"))?;
+    let mut descriptors = Vec::with_capacity(capacity);
+    let mut previous_id = None;
+    for _ in 0..descriptor_count {
+        let record_start = *cursor;
+        let record_size = usize::try_from(read_u32(bytes, cursor, "executor record size")?)
+            .map_err(|_| RusticolError::artifact("executor record size exceeds usize"))?;
+        if record_size < 16 {
+            return Err(RusticolError::artifact(
+                "recurrence process-executor record is shorter than its fixed header",
+            ));
+        }
+        let record_end = record_start
+            .checked_add(record_size)
+            .filter(|end| *end <= bytes.len())
+            .ok_or_else(|| RusticolError::artifact("truncated process-executor record"))?;
+        let executor_id = read_u32(bytes, cursor, "executor ID")?;
+        if executor_id >= catalog_executor_count
+            || previous_id.is_some_and(|previous| executor_id <= previous)
+        {
+            return Err(RusticolError::integrity(
+                "recurrence process-executor IDs are not sorted, unique, and in range",
+            ));
+        }
+        previous_id = Some(executor_id);
+        let role =
+            DirectExecutorRole::try_from(u16::from(read_u8(bytes, cursor, "executor role")?))
+                .map_err(|_| RusticolError::compatibility("unsupported process-executor role"))?;
+        let binding_tag = read_u8(bytes, cursor, "executor binding tag")?;
+        let flags = read_u16(bytes, cursor, "executor flags")?;
+        if flags & !PROCESS_EXECUTOR_FLAGS_KNOWN != 0 {
+            return Err(RusticolError::compatibility(
+                "recurrence process executor has unknown flags",
+            ));
+        }
+        let destination_component_count =
+            read_u32(bytes, cursor, "executor destination component count")?;
+        if destination_component_count == 0 {
+            return Err(RusticolError::artifact(
+                "recurrence process executor has an empty destination shape",
+            ));
+        }
+        let binding = match binding_tag {
+            0 => ProcessDirectExecutorBinding::Source,
+            1 => ProcessDirectExecutorBinding::Intrinsic(decode_intrinsic(bytes, cursor)?),
+            2 => ProcessDirectExecutorBinding::Jit(decode_jit(bytes, cursor)?),
+            3 => ProcessDirectExecutorBinding::Native(decode_native(bytes, cursor)?),
+            _ => {
+                return Err(RusticolError::compatibility(format!(
+                    "unsupported process-executor binding tag {binding_tag}"
+                )));
+            }
+        };
+        if *cursor != record_end {
+            return Err(RusticolError::integrity(
+                "recurrence process-executor record has trailing bytes",
+            ));
+        }
+        validate_binding_policy(role, &binding, target.backend)?;
+        descriptors.push(ProcessDirectExecutorDescriptor {
+            direct_executor_id: executor_id,
+            role,
+            destination_component_count,
+            uses_exact_factor: flags & PROCESS_EXECUTOR_FLAG_USES_EXACT_FACTOR != 0,
+            binding,
+        });
+    }
+    Ok(ProcessDirectExecutorPack {
+        identities,
+        target,
+        catalog_executor_count,
+        descriptors,
+    })
+}
+
+fn validate_binding_policy(
+    role: DirectExecutorRole,
+    binding: &ProcessDirectExecutorBinding,
+    backend: ProcessExecutorBackend,
+) -> RusticolResult<()> {
+    let valid = match binding {
+        ProcessDirectExecutorBinding::Source => role == DirectExecutorRole::Source,
+        ProcessDirectExecutorBinding::Intrinsic(intrinsic) => {
+            role != DirectExecutorRole::Source
+                && (role == DirectExecutorRole::Contribution) == intrinsic.scale.is_some()
+        }
+        ProcessDirectExecutorBinding::Jit(jit) => {
+            role != DirectExecutorRole::Source
+                && backend == ProcessExecutorBackend::Jit
+                && jit.optimization_level == PREPARED_JIT_OPTIMIZATION_LEVEL
+        }
+        ProcessDirectExecutorBinding::Native(_) => {
+            role != DirectExecutorRole::Source
+                && matches!(
+                    backend,
+                    ProcessExecutorBackend::Cpp | ProcessExecutorBackend::Asm
+                )
+        }
+    };
+    if !valid {
+        return Err(RusticolError::integrity(
+            "recurrence process-executor binding does not match its role/backend",
+        ));
+    }
+    Ok(())
+}
+
+fn decode_intrinsic(bytes: &[u8], cursor: &mut usize) -> RusticolResult<ProcessIntrinsicExecutor> {
+    let has_scale = read_bool(bytes, cursor, "intrinsic scale flag")?;
+    require_zero(bytes, cursor, 3, "intrinsic reserved bytes")?;
+    let constant_real_bits = read_u64(bytes, cursor, "intrinsic real bits")?;
+    let constant_imag_bits = read_u64(bytes, cursor, "intrinsic imaginary bits")?;
+    let parameter = read_u32(bytes, cursor, "intrinsic parameter index")?;
+    let runtime_template = read_string(bytes, cursor, "intrinsic runtime template")?;
+    let scale = if has_scale {
+        Some(ProcessIntrinsicScale {
+            constant_real_bits,
+            constant_imag_bits,
+            parameter_index: (parameter != DIRECT_NONE_U32).then_some(parameter),
+        })
+    } else {
+        if constant_real_bits != 0 || constant_imag_bits != 0 || parameter != DIRECT_NONE_U32 {
+            return Err(RusticolError::integrity(
+                "non-scale intrinsic has noncanonical scale fields",
+            ));
+        }
+        None
+    };
+    Ok(ProcessIntrinsicExecutor {
+        runtime_template,
+        scale,
+    })
+}
+
+fn decode_jit(bytes: &[u8], cursor: &mut usize) -> RusticolResult<ProcessJitExecutor> {
+    let prepared_kernel_id = read_u32(bytes, cursor, "JIT prepared-kernel ID")?;
+    if prepared_kernel_id == DIRECT_NONE_U32 {
+        return Err(RusticolError::artifact(
+            "JIT process executor uses the missing kernel sentinel",
+        ));
+    }
+    let optimization_level = read_u32(bytes, cursor, "JIT optimization level")?;
+    let plane_compression = read_bool(bytes, cursor, "JIT compression flag")?;
+    require_zero(bytes, cursor, 3, "JIT reserved bytes")?;
+    let source_application_sha256 = read_array::<32>(bytes, cursor, "JIT source digest")?;
+    let source_application_path = read_string(bytes, cursor, "JIT source path")?;
+    let source_application_abi = read_string(bytes, cursor, "JIT source ABI")?;
+    let parameter_count = read_u32(bytes, cursor, "JIT parameter-binding count")?;
+    let plane_count = read_u32(bytes, cursor, "JIT plane-projection count")?;
+    let scalar_count = read_u32(bytes, cursor, "JIT scalar-projection count")?;
+    let alias_count = read_u32(bytes, cursor, "JIT output-alias count")?;
+    let parameter_bindings = (0..parameter_count)
+        .map(|_| decode_parameter_binding(bytes, cursor))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let input_plane_projections = (0..plane_count)
+        .map(|_| decode_plane_projection(bytes, cursor))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let scalar_projections = (0..scalar_count)
+        .map(|_| decode_scalar_projection(bytes, cursor))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let output_alias_inputs = (0..alias_count)
+        .map(|_| read_u32(bytes, cursor, "JIT output-alias input"))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    for binding in &parameter_bindings {
+        let (index, limit) = match *binding {
+            RecurrenceDirectParameterBindingManifest::Plane { index } => (index, plane_count),
+            RecurrenceDirectParameterBindingManifest::Scalar { index } => (index, scalar_count),
+        };
+        if index >= limit {
+            return Err(RusticolError::integrity(
+                "JIT process executor parameter binding is out of bounds",
+            ));
+        }
+    }
+    if output_alias_inputs
+        .iter()
+        .any(|index| *index >= plane_count)
+    {
+        return Err(RusticolError::integrity(
+            "JIT process executor output alias is out of bounds",
+        ));
+    }
+    Ok(ProcessJitExecutor {
+        optimization_level,
+        plane_compression,
+        source_application_sha256,
+        source_application_path,
+        source_application_abi,
+        parameter_bindings,
+        input_plane_projections,
+        scalar_projections,
+        output_alias_inputs,
+    })
+}
+
+fn decode_native(bytes: &[u8], cursor: &mut usize) -> RusticolResult<ProcessNativeExecutor> {
+    let prepared_kernel_id = read_u32(bytes, cursor, "native prepared-kernel ID")?;
+    if prepared_kernel_id == DIRECT_NONE_U32 {
+        return Err(RusticolError::artifact(
+            "native process executor uses the missing kernel sentinel",
+        ));
+    }
+    let has_coupling = read_bool(bytes, cursor, "native coupling flag")?;
+    require_zero(bytes, cursor, 3, "native reserved bytes")?;
+    let coupling_real = f64::from_bits(read_u64(bytes, cursor, "native coupling real bits")?);
+    let coupling_imag = f64::from_bits(read_u64(bytes, cursor, "native coupling imaginary bits")?);
+    let coupling = if has_coupling {
+        if !coupling_real.is_finite() || !coupling_imag.is_finite() {
+            return Err(RusticolError::artifact(
+                "native process executor coupling is not finite",
+            ));
+        }
+        Some((coupling_real, coupling_imag))
+    } else {
+        if coupling_real.to_bits() != 0 || coupling_imag.to_bits() != 0 {
+            return Err(RusticolError::integrity(
+                "native process executor has noncanonical absent coupling bits",
+            ));
+        }
+        None
+    };
+    Ok(ProcessNativeExecutor {
+        prepared_kernel_id,
+        library_path: read_string(bytes, cursor, "native library path")?,
+        native_entry_point: read_string(bytes, cursor, "native entry point")?,
+        coupling,
+    })
+}
+
+fn decode_parameter_binding(
+    bytes: &[u8],
+    cursor: &mut usize,
+) -> RusticolResult<RecurrenceDirectParameterBindingManifest> {
+    let tag = read_u8(bytes, cursor, "JIT parameter-binding tag")?;
+    require_zero(bytes, cursor, 3, "JIT parameter-binding reserved bytes")?;
+    let index = read_u32(bytes, cursor, "JIT parameter-binding index")?;
+    match tag {
+        0 => Ok(RecurrenceDirectParameterBindingManifest::Plane { index }),
+        1 => Ok(RecurrenceDirectParameterBindingManifest::Scalar { index }),
+        _ => Err(RusticolError::compatibility(
+            "unsupported JIT parameter-binding tag",
+        )),
+    }
+}
+
+fn decode_plane_projection(
+    bytes: &[u8],
+    cursor: &mut usize,
+) -> RusticolResult<RecurrenceDirectPlaneProjectionManifest> {
+    let tag = read_u8(bytes, cursor, "JIT plane-projection tag")?;
+    let operand = read_u8(bytes, cursor, "JIT plane-projection operand")?;
+    let component = read_u16(bytes, cursor, "JIT plane-projection component")?;
+    let imaginary = read_bool(bytes, cursor, "JIT plane-projection imaginary flag")?;
+    require_zero(bytes, cursor, 3, "JIT plane-projection reserved bytes")?;
+    match tag {
+        0 => Ok(RecurrenceDirectPlaneProjectionManifest::ParentCurrent {
+            parent: operand,
+            component,
+            imaginary,
+        }),
+        1 if !imaginary => Ok(RecurrenceDirectPlaneProjectionManifest::Momentum {
+            operand,
+            lorentz_component: component,
+        }),
+        2 if operand == 0 => Ok(
+            RecurrenceDirectPlaneProjectionManifest::DestinationCurrent {
+                component,
+                imaginary,
+            },
+        ),
+        3 if operand == 0 => Ok(
+            RecurrenceDirectPlaneProjectionManifest::DestinationAmplitude {
+                component,
+                imaginary,
+            },
+        ),
+        _ => Err(RusticolError::integrity(
+            "JIT plane-projection record is noncanonical",
+        )),
+    }
+}
+
+fn decode_scalar_projection(
+    bytes: &[u8],
+    cursor: &mut usize,
+) -> RusticolResult<RecurrenceDirectScalarProjectionManifest> {
+    let tag = read_u8(bytes, cursor, "JIT scalar-projection tag")?;
+    let imaginary = read_bool(bytes, cursor, "JIT scalar-projection imaginary flag")?;
+    if read_u16(bytes, cursor, "JIT scalar-projection reserved bytes")? != 0 {
+        return Err(RusticolError::integrity(
+            "JIT scalar-projection reserved bytes are nonzero",
+        ));
+    }
+    let index = read_u32(bytes, cursor, "JIT scalar-projection index")?;
+    let bits = read_u64(bytes, cursor, "JIT scalar-projection bits")?;
+    match tag {
+        0 if index == 0 && bits == 0 => {
+            Ok(RecurrenceDirectScalarProjectionManifest::ExactFactor { imaginary })
+        }
+        1 if bits == 0 => {
+            Ok(RecurrenceDirectScalarProjectionManifest::Parameter { index, imaginary })
+        }
+        2 if !imaginary && index == 0 => {
+            let value = f64::from_bits(bits);
+            if !value.is_finite() {
+                return Err(RusticolError::artifact(
+                    "JIT literal scalar projection is not finite",
+                ));
+            }
+            Ok(RecurrenceDirectScalarProjectionManifest::Literal { value })
+        }
+        _ => Err(RusticolError::integrity(
+            "JIT scalar-projection record is noncanonical",
+        )),
+    }
+}
+
+pub(super) fn semantic_digest_from_bytes(
+    bytes: [u8; 32],
+    context: &str,
+) -> RusticolResult<SemanticDigest> {
+    SemanticDigest::new(bytes)
+        .map_err(|_| RusticolError::artifact(format!("{context} digest must not be all zero")))
+}
+
+pub(super) fn read_u8(bytes: &[u8], cursor: &mut usize, context: &str) -> RusticolResult<u8> {
+    let value = *bytes
+        .get(*cursor)
+        .ok_or_else(|| RusticolError::artifact(format!("truncated {context}")))?;
+    *cursor += 1;
+    Ok(value)
+}
+
+pub(super) fn read_u16(bytes: &[u8], cursor: &mut usize, context: &str) -> RusticolResult<u16> {
+    Ok(u16::from_le_bytes(read_array(bytes, cursor, context)?))
+}
+
+pub(super) fn read_u32(bytes: &[u8], cursor: &mut usize, context: &str) -> RusticolResult<u32> {
+    Ok(u32::from_le_bytes(read_array(bytes, cursor, context)?))
+}
+
+pub(super) fn read_u64(bytes: &[u8], cursor: &mut usize, context: &str) -> RusticolResult<u64> {
+    Ok(u64::from_le_bytes(read_array(bytes, cursor, context)?))
+}
+
+pub(super) fn read_array<const N: usize>(
+    bytes: &[u8],
+    cursor: &mut usize,
+    context: &str,
+) -> RusticolResult<[u8; N]> {
+    let end = cursor
+        .checked_add(N)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} range overflows")))?;
+    let value = bytes
+        .get(*cursor..end)
+        .ok_or_else(|| RusticolError::artifact(format!("truncated {context}")))?
+        .try_into()
+        .map_err(|_| RusticolError::internal("fixed-width process-pack read drifted"))?;
+    *cursor = end;
+    Ok(value)
+}
+
+pub(super) fn read_string(
+    bytes: &[u8],
+    cursor: &mut usize,
+    context: &str,
+) -> RusticolResult<String> {
+    let length = usize::try_from(read_u32(bytes, cursor, context)?)
+        .map_err(|_| RusticolError::artifact(format!("{context} length exceeds usize")))?;
+    if length == 0 {
+        return Err(RusticolError::artifact(format!("{context} is empty")));
+    }
+    let end = cursor
+        .checked_add(length)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} range overflows")))?;
+    let raw = bytes
+        .get(*cursor..end)
+        .ok_or_else(|| RusticolError::artifact(format!("truncated {context}")))?;
+    let value = std::str::from_utf8(raw)
+        .map_err(|_| RusticolError::artifact(format!("{context} is not UTF-8")))?
+        .to_owned();
+    *cursor = end;
+    Ok(value)
+}
+
+fn read_bool(bytes: &[u8], cursor: &mut usize, context: &str) -> RusticolResult<bool> {
+    match read_u8(bytes, cursor, context)? {
+        0 => Ok(false),
+        1 => Ok(true),
+        _ => Err(RusticolError::artifact(format!(
+            "{context} is not a canonical boolean"
+        ))),
+    }
+}
+
+fn require_zero(
+    bytes: &[u8],
+    cursor: &mut usize,
+    count: usize,
+    context: &str,
+) -> RusticolResult<()> {
+    let end = cursor
+        .checked_add(count)
+        .ok_or_else(|| RusticolError::artifact(format!("{context} range overflows")))?;
+    if bytes
+        .get(*cursor..end)
+        .is_none_or(|reserved| reserved.iter().any(|byte| *byte != 0))
+    {
+        return Err(RusticolError::integrity(format!(
+            "{context} are nonzero or truncated"
+        )));
+    }
+    *cursor = end;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::{valid_direct_plan_fixture, valid_direct_plan_parts_fixture};
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    fn descriptor(
+        direct_executor_id: u32,
+        role: DirectExecutorRole,
+    ) -> ProcessDirectExecutorDescriptor {
+        let binding = match role {
+            DirectExecutorRole::Source => ProcessDirectExecutorBinding::Source,
+            DirectExecutorRole::Contribution => {
+                ProcessDirectExecutorBinding::Intrinsic(ProcessIntrinsicExecutor {
+                    runtime_template: "rusticol.test-contribution.v1".to_owned(),
+                    scale: Some(ProcessIntrinsicScale {
+                        constant_real_bits: 1.0_f64.to_bits(),
+                        constant_imag_bits: 0,
+                        parameter_index: None,
+                    }),
+                })
+            }
+            DirectExecutorRole::Finalization | DirectExecutorRole::Closure => {
+                ProcessDirectExecutorBinding::Intrinsic(ProcessIntrinsicExecutor {
+                    runtime_template: "rusticol.test-noncontribution.v1".to_owned(),
+                    scale: None,
+                })
+            }
+        };
+        ProcessDirectExecutorDescriptor {
+            direct_executor_id,
+            role,
+            destination_component_count: 1,
+            uses_exact_factor: role == DirectExecutorRole::Contribution,
+            binding,
+        }
+    }
+
+    fn pack_for(plan: &DirectRecurrencePlan) -> ProcessDirectExecutorPack {
+        let descriptors = plan
+            .row_groups()
+            .iter()
+            .filter(|group| group.direct_executor_id != DIRECT_NONE_U32)
+            .map(|group| {
+                (
+                    group.direct_executor_id,
+                    descriptor(group.direct_executor_id, group.role),
+                )
+            })
+            .collect::<BTreeMap<_, _>>()
+            .into_values()
+            .collect();
+        ProcessDirectExecutorPack {
+            identities: ProcessExecutorIdentities {
+                compiled_model_digest: digest(0x44),
+                recurrence_template_catalog_digest: digest(0x55),
+                prepared_kernel_pack_digest: plan.prepared_pack_digest(),
+                direct_template_catalog_digest: plan.direct_template_catalog_digest(),
+                runtime_layout_digest: plan.runtime_layout_digest(),
+            },
+            target: ProcessExecutorTarget {
+                backend: ProcessExecutorBackend::Jit,
+                target_triple: PREPARED_JIT_PORTABLE_TARGET.to_owned(),
+                portable: true,
+                cpu_features: Vec::new(),
+            },
+            catalog_executor_count: plan.direct_executor_count(),
+            descriptors,
+        }
+    }
+
+    fn validate(
+        pack: &ProcessDirectExecutorPack,
+        plan: &DirectRecurrencePlan,
+    ) -> RusticolResult<()> {
+        pack.validate_for_plan(
+            plan,
+            plan.prepared_pack_digest(),
+            plan.direct_template_catalog_digest(),
+            plan.runtime_layout_digest(),
+        )
+    }
+
+    #[test]
+    fn required_executor_set_is_exact_and_role_typed() {
+        let plan = valid_direct_plan_fixture();
+        let pack = pack_for(&plan);
+        validate(&pack, &plan).unwrap();
+
+        let mut missing = pack.clone();
+        missing.descriptors.pop();
+        assert!(
+            validate(&missing, &plan)
+                .unwrap_err()
+                .to_string()
+                .contains("missing or extra")
+        );
+
+        let mut duplicate = pack.clone();
+        duplicate.descriptors.push(duplicate.descriptors[0].clone());
+        assert!(
+            validate(&duplicate, &plan)
+                .unwrap_err()
+                .to_string()
+                .contains("repeats an executor ID")
+        );
+
+        let mut wrong_role = pack.clone();
+        wrong_role.descriptors[0].role = DirectExecutorRole::Closure;
+        assert!(
+            validate(&wrong_role, &plan)
+                .unwrap_err()
+                .to_string()
+                .contains("wrong role")
+        );
+
+        let mut out_of_range = pack;
+        out_of_range.descriptors[0].direct_executor_id = plan.direct_executor_count();
+        assert!(
+            validate(&out_of_range, &plan)
+                .unwrap_err()
+                .to_string()
+                .contains("out-of-range")
+        );
+    }
+
+    #[test]
+    fn required_executor_set_rejects_an_extra_in_range_record() {
+        let mut parts = valid_direct_plan_parts_fixture();
+        parts.direct_executor_count = 5;
+        let plan = DirectRecurrencePlan::new(parts).unwrap();
+        let mut pack = pack_for(&plan);
+        pack.descriptors
+            .push(descriptor(4, DirectExecutorRole::Closure));
+
+        assert!(
+            validate(&pack, &plan)
+                .unwrap_err()
+                .to_string()
+                .contains("missing or extra")
+        );
+    }
+
+    #[test]
+    fn decodes_python_source_descriptor_golden() {
+        // Python struct.pack("<IIBBHI", 16, 2, 0, 0, 0, 4).
+        let bytes = [0x10, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0];
+        let mut cursor = 0;
+        let decoded = decode_process_executor_descriptors(
+            &bytes,
+            &mut cursor,
+            1,
+            4,
+            ProcessExecutorTarget {
+                backend: ProcessExecutorBackend::Jit,
+                target_triple: PREPARED_JIT_PORTABLE_TARGET.to_owned(),
+                portable: true,
+                cpu_features: Vec::new(),
+            },
+            ProcessExecutorIdentities {
+                compiled_model_digest: digest(1),
+                recurrence_template_catalog_digest: digest(2),
+                prepared_kernel_pack_digest: digest(3),
+                direct_template_catalog_digest: digest(4),
+                runtime_layout_digest: digest(5),
+            },
+        )
+        .unwrap();
+
+        assert_eq!(cursor, bytes.len());
+        assert_eq!(decoded.catalog_executor_count, 4);
+        assert_eq!(decoded.descriptors.len(), 1);
+        assert_eq!(decoded.descriptors[0].direct_executor_id, 2);
+        assert_eq!(decoded.descriptors[0].role, DirectExecutorRole::Source);
+        assert_eq!(decoded.descriptors[0].destination_component_count, 4);
+        assert!(matches!(
+            decoded.descriptors[0].binding,
+            ProcessDirectExecutorBinding::Source
+        ));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/runtime_load.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/runtime_load.rs
new file mode 100644
index 0000000000..2cb37f0d77
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/runtime_load.rs
@@ -0,0 +1,6082 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+fn load_compiled_symmetric_group_color_contraction(
+    payload: Option<&CompiledColorContractionPayloadManifest>,
+    payloads: &EvaluatorPayloadStore,
+    physics: &PhysicsRuntime,
+) -> RusticolResult<Option<crate::recurrence::RecurrenceColorContraction>> {
+    let Some(payload) = payload else {
+        return Ok(None);
+    };
+    if !physics.has_contracted_color_axis() || physics.manifest.color_components.len() != 1 {
+        return Err(RusticolError::compatibility(
+            "compiled symmetric-group FFT diagnostic requires one contracted FullColour axis",
+        ));
+    }
+    if physics.manifest.coverage.helicities != "selected" {
+        return Err(RusticolError::compatibility(
+            "compiled symmetric-group FFT diagnostic requires generation-time selected helicity coverage",
+        ));
+    }
+    let live_helicity_count = physics
+        .manifest
+        .helicities
+        .iter()
+        .filter(|helicity| {
+            helicity.computed && !helicity.structural_zero && helicity.coefficient != 0.0
+        })
+        .count();
+    if live_helicity_count != 1 {
+        return Err(RusticolError::compatibility(
+            "compiled symmetric-group FFT diagnostic requires exactly one generation-time selected helicity",
+        ));
+    }
+    let bytes = payloads.packed_member_bytes(
+        &payload.path,
+        crate::pacbin::PacbinMemberKind::ColorContraction,
+    )?;
+    crate::recurrence::decode_recurrence_color_contraction_v3(bytes).map(Some)
+}
+
+#[cfg(test)]
+mod compiled_symmetric_group_load_tests {
+    use super::*;
+
+    #[test]
+    fn complete_helicity_coverage_is_rejected_even_with_one_live_helicity() {
+        let physics = crate::engine::tests::test_physics_runtime("full");
+        assert_eq!(physics.manifest.coverage.helicities, "complete");
+        assert_eq!(
+            physics
+                .manifest
+                .helicities
+                .iter()
+                .filter(|helicity| {
+                    helicity.computed && !helicity.structural_zero && helicity.coefficient != 0.0
+                })
+                .count(),
+            1,
+        );
+        let payload = CompiledColorContractionPayloadManifest {
+            path: "not-read.pacrclr3".to_string(),
+        };
+        let payloads = EvaluatorPayloadStore::directory(std::path::Path::new("."));
+
+        let error =
+            load_compiled_symmetric_group_color_contraction(Some(&payload), &payloads, &physics)
+                .expect_err("complete helicity coverage must not enter the selected diagnostic");
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.message().contains("selected helicity coverage"));
+    }
+}
+
+fn validate_compiled_plane_arena_contract(manifest: &ExecutionManifest) -> RusticolResult<bool> {
+    let declared_execution = manifest
+        .required_runtime_capabilities
+        .iter()
+        .any(|value| value == COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY);
+    let Some(stages) = manifest.compiled.stage_evaluators.as_ref() else {
+        if declared_execution {
+            return Err(RusticolError::integrity(
+                "compiled-plane-arena-v1 is declared without fused stage evaluators",
+            ));
+        }
+        return Ok(false);
+    };
+    let declared_stage = stages
+        .required_runtime_capabilities
+        .iter()
+        .any(|value| value == COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY);
+    let all_stages = stages
+        .stages
+        .iter()
+        .chain(std::iter::once(&stages.amplitude_stage))
+        .collect::<Vec<_>>();
+    let all_direct_capable = all_stages.iter().all(|stage| {
+        stage.evaluator.leaf_layout().is_ok_and(|leaves| {
+            !leaves.is_empty()
+                && leaves.iter().all(|leaf| {
+                    matches!(
+                        leaf.evaluator,
+                        EvaluatorManifest::SymjitApplication { .. }
+                            | EvaluatorManifest::CompiledComplex {
+                                native_direct_application: Some(_),
+                                ..
+                            }
+                    )
+                })
+        })
+    });
+    let direct_count = all_stages
+        .iter()
+        .filter(|stage| stage.compiled_plane_arena.is_some())
+        .count();
+
+    if !declared_execution && !declared_stage && direct_count == 0 {
+        return Err(RusticolError::compatibility(
+            "this compiled f64 artifact predates compiled-plane-arena-v1; regenerate it with \
+             `pyamplicol generate` using the current pyAmpliCol build",
+        ));
+    }
+    if !declared_execution
+        || !declared_stage
+        || direct_count != all_stages.len()
+        || !all_direct_capable
+    {
+        return Err(RusticolError::integrity(
+            "compiled-plane-arena-v1 capability, fused direct-capable leaves, and stage bindings \
+             do not form one complete execution contract",
+        ));
+    }
+    let momentum_slot_ids = manifest.compiled.momentum_slot_ids.as_deref().ok_or_else(|| {
+        RusticolError::compatibility(
+            "compiled execution omits generation-time momentum-slot selection; regenerate the artifact",
+        )
+    })?;
+    validate_sorted_unique_ids(
+        momentum_slot_ids,
+        manifest.runtime_schema.momentum_slots.len(),
+        "compiled momentum-slot ids",
+    )?;
+    for (position, stage) in all_stages.into_iter().enumerate() {
+        validate_compiled_plane_arena_stage(
+            stage,
+            position == stages.stages.len(),
+            manifest.runtime_schema.value_storage.component_count,
+            manifest.runtime_schema.amplitude_stage.output_count,
+            manifest
+                .runtime_schema
+                .parameter_layout
+                .momentum_parameter_count,
+            momentum_slot_ids,
+        )?;
+    }
+    Ok(true)
+}
+
+fn validate_compiled_plane_arena_stage(
+    stage: &GenericSerializedStageEvaluatorManifest,
+    is_amplitude: bool,
+    value_component_count: usize,
+    amplitude_component_count: usize,
+    momentum_component_count: usize,
+    momentum_slot_ids: &[usize],
+) -> RusticolResult<()> {
+    let direct = stage.compiled_plane_arena.as_ref().ok_or_else(|| {
+        RusticolError::integrity("compiled plane-arena fused stage has no direct bindings")
+    })?;
+    let symjit_contract = direct.application_abi == COMPILED_PLANE_DIRECT_APPLICATION_ABI
+        && direct.source_application_abi == COMPILED_PLANE_SOURCE_APPLICATION_ABI;
+    #[cfg(feature = "f64-compiled")]
+    let native_contract = direct.application_abi
+        == super::evaluator::native_compiled_direct::NATIVE_COMPILED_DIRECT_APPLICATION_ABI
+        && direct.source_application_abi
+            == super::evaluator::native_compiled_direct::NATIVE_COMPILED_DIRECT_APPLICATION_ABI;
+    #[cfg(not(feature = "f64-compiled"))]
+    let native_contract = false;
+    if direct.schema_version != 1
+        || direct.kind != "compiled-plane-arena-stage"
+        || !(symjit_contract || native_contract)
+        || direct.element_layout != "split-complex-component-major"
+        || direct.output_operation != "overwrite"
+        || direct.output_factor != "identity"
+        || direct.input_output_aliasing != "forbidden"
+        || direct.output_output_aliasing != "forbidden"
+    {
+        return Err(RusticolError::compatibility(format!(
+            "compiled plane-arena stage {:?} has an incompatible direct ABI; regenerate the artifact",
+            stage.evaluator_label
+        )));
+    }
+    if stage.parameter_layout != "stage-local-value-momentum"
+        || direct.input_bindings.len() != stage.parameter_count
+        || direct.output_bindings.len() != stage.output_length
+        || direct.leaves.is_empty()
+    {
+        return Err(RusticolError::integrity(format!(
+            "compiled plane-arena stage {:?} has incomplete direct bindings",
+            stage.evaluator_label
+        )));
+    }
+    u32::try_from(value_component_count)
+        .and_then(|_| u32::try_from(amplitude_component_count))
+        .and_then(|_| u32::try_from(stage.parameter_count))
+        .and_then(|_| u32::try_from(stage.output_length))
+        .map_err(|_| {
+            RusticolError::integrity(
+                "compiled plane-arena plane or scalar address space exceeds u32",
+            )
+        })?;
+
+    let mut canonical_inputs = vec![None; stage.parameter_count];
+    for component in &stage.input_components {
+        let slot = canonical_inputs
+            .get_mut(component.parameter_index)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "compiled plane-arena input binding index is out of bounds",
+                )
+            })?;
+        if slot
+            .replace(CompiledPlaneInputBindingManifest {
+                parameter_index: component.parameter_index,
+                kind: component.kind.clone(),
+                source_id: component.source_id,
+                component: component.component,
+                global_component: component.global_component,
+                real_valued: component.real_valued,
+            })
+            .is_some()
+        {
+            return Err(RusticolError::integrity(
+                "compiled plane-arena input bindings contain duplicates",
+            ));
+        }
+    }
+    if canonical_inputs.iter().any(Option::is_none)
+        || canonical_inputs
+            .into_iter()
+            .map(Option::unwrap)
+            .ne(direct.input_bindings.iter().cloned())
+    {
+        return Err(RusticolError::integrity(format!(
+            "compiled plane-arena stage {:?} input bindings disagree with the DAG",
+            stage.evaluator_label
+        )));
+    }
+
+    let expected_arena = if is_amplitude { "amplitude" } else { "current" };
+    let output_limit = if is_amplitude {
+        amplitude_component_count
+    } else {
+        value_component_count
+    };
+    let mut canonical_outputs = vec![None; stage.output_length];
+    let mut output_components = BTreeSet::new();
+    for slot in &stage.output_slots {
+        let output_len = slot
+            .output_stop
+            .checked_sub(slot.output_start)
+            .filter(|length| slot.component_stop.checked_sub(slot.component_start) == Some(*length))
+            .ok_or_else(|| {
+                RusticolError::integrity("compiled plane-arena output binding range is invalid")
+            })?;
+        if slot.output_stop > stage.output_length || slot.component_stop > output_limit {
+            return Err(RusticolError::integrity(
+                "compiled plane-arena output binding is out of bounds",
+            ));
+        }
+        for offset in 0..output_len {
+            let output_index = slot.output_start + offset;
+            let component = slot.component_start + offset;
+            if !output_components.insert(component)
+                || canonical_outputs[output_index]
+                    .replace(CompiledPlaneOutputBindingManifest {
+                        output_index,
+                        arena: expected_arena.to_string(),
+                        component,
+                    })
+                    .is_some()
+            {
+                return Err(RusticolError::integrity(
+                    "compiled plane-arena output bindings alias",
+                ));
+            }
+        }
+    }
+    if canonical_outputs.iter().any(Option::is_none)
+        || canonical_outputs
+            .into_iter()
+            .map(Option::unwrap)
+            .ne(direct.output_bindings.iter().cloned())
+    {
+        return Err(RusticolError::integrity(format!(
+            "compiled plane-arena stage {:?} output bindings disagree with the DAG",
+            stage.evaluator_label
+        )));
+    }
+    if !is_amplitude {
+        let input_currents = direct
+            .input_bindings
+            .iter()
+            .filter(|binding| binding.kind == "value")
+            .map(|binding| binding.global_component)
+            .collect::<BTreeSet<_>>();
+        if output_components
+            .iter()
+            .any(|component| input_currents.contains(component))
+        {
+            return Err(RusticolError::integrity(
+                "compiled plane-arena fused stage aliases an input and output plane",
+            ));
+        }
+    }
+
+    let canonical_leaves = stage.evaluator.leaf_layout()?;
+    if canonical_leaves.len() != direct.leaves.len() {
+        return Err(RusticolError::integrity(
+            "compiled plane-arena leaf bindings do not cover the evaluator",
+        ));
+    }
+    for (canonical, binding) in canonical_leaves.iter().zip(&direct.leaves) {
+        let (
+            application_path,
+            application_abi,
+            input_len,
+            output_len,
+            optimization_level,
+            supported_optimization_level,
+        ) = match canonical.evaluator {
+            EvaluatorManifest::SymjitApplication {
+                input_len,
+                output_len,
+                optimization_level,
+                plane_application,
+                ..
+            } => {
+                let plane_application = plane_application.as_ref().ok_or_else(|| {
+                    RusticolError::compatibility(
+                        "compiled SymJIT leaf predates the standard plane application ABI; \
+                         regenerate the artifact",
+                    )
+                })?;
+                plane_application.validate(*input_len, *output_len, *optimization_level)?;
+                (
+                    plane_application.application_path.as_str(),
+                    plane_application.application_abi.as_str(),
+                    *input_len,
+                    *output_len,
+                    *optimization_level,
+                    *optimization_level <= 3,
+                )
+            }
+            EvaluatorManifest::CompiledComplex {
+                function_name,
+                input_len,
+                output_len,
+                native_direct_application: Some(application),
+                ..
+            } => {
+                application.validate(function_name, *input_len, *output_len)?;
+                (
+                    application.library_path.as_str(),
+                    application.application_abi.as_str(),
+                    *input_len,
+                    *output_len,
+                    3,
+                    true,
+                )
+            }
+            _ => {
+                return Err(RusticolError::integrity(
+                    "compiled plane-arena stage contains a leaf without a direct application",
+                ));
+            }
+        };
+        if !supported_optimization_level {
+            return Err(RusticolError::compatibility(
+                "compiled-plane-arena-v1 supports compiled JIT optimization levels 0 through 3",
+            ));
+        }
+        if binding.optimization_level != optimization_level {
+            return Err(RusticolError::integrity(
+                "compiled plane-arena leaf optimization level disagrees with its source payload",
+            ));
+        }
+        if binding.direct_codegen_optimization_level != optimization_level {
+            return Err(RusticolError::compatibility(
+                "compiled plane-arena leaf direct code generation must match its standard \
+                 P-kernel optimization level",
+            ));
+        }
+        if binding.application_path != application_path
+            || binding.source_application_abi != application_abi
+            || binding.source_application_abi != direct.source_application_abi
+            || binding.input_len != input_len
+            || binding.output_len != output_len
+            || binding.input_indices != canonical.input_indices
+            || binding.output_start != canonical.output_range.start
+            || binding.output_stop != canonical.output_range.end
+        {
+            return Err(RusticolError::integrity(format!(
+                "compiled plane-arena stage {:?} leaf bindings disagree with its source payload",
+                stage.evaluator_label
+            )));
+        }
+        for &input_index in &binding.input_indices {
+            let input = direct.input_bindings.get(input_index).ok_or_else(|| {
+                RusticolError::integrity("compiled leaf input index is outside its bindings")
+            })?;
+            if input.kind == "momentum" {
+                let component = input
+                    .global_component
+                    .checked_sub(value_component_count)
+                    .filter(|component| *component < momentum_component_count)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "compiled leaf momentum input is outside momentum planes",
+                        )
+                    })?;
+                if momentum_slot_ids.binary_search(&(component / 4)).is_err() {
+                    return Err(RusticolError::integrity(
+                        "compiled momentum-slot selection omits a leaf input",
+                    ));
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn build_lc_topology_replay_mappings(
+    replay: Option<&LcTopologyReplayManifest>,
+) -> RusticolResult<(LcTopologyReplayMappings, Vec<f64>)> {
+    let data = build_lc_topology_replay_data(replay)?;
+    let mapping_count = data.mappings.len();
+    Ok((data.mappings, vec![1.0; mapping_count]))
+}
+
+pub(super) fn build_lc_topology_replay_data(
+    replay: Option<&LcTopologyReplayManifest>,
+) -> RusticolResult<LcTopologyReplayData> {
+    let Some(replay) = replay else {
+        return Ok(LcTopologyReplayData::default());
+    };
+    let contract_version = replay.contract_version.unwrap_or(1);
+    if !matches!(contract_version, 1 | 2) {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported LC topology replay contract version {contract_version}"
+        )));
+    }
+    if !replay.enabled {
+        if contract_version == 2
+            && (!replay.groups.is_empty()
+                || replay.replayed_sector_count != 0
+                || !replay.materialized_sector_ids.is_empty()
+                || !replay.residual_sector_ids.is_empty())
+        {
+            return Err(RusticolError::invalid_argument(
+                "disabled LC topology replay contract v2 contains active coverage",
+            ));
+        }
+        return Ok(LcTopologyReplayData::default());
+    }
+    if replay.mode != "external-label-permutation" {
+        return Err(RusticolError::invalid_argument(format!(
+            "unsupported LC topology replay mode {:?}",
+            replay.mode
+        )));
+    }
+    let mut routes_by_mapping =
+        BTreeMap::<Vec<(usize, usize)>, Vec<LcTopologyReplaySectorRoute>>::new();
+    let mut replayed_sector_ids = BTreeSet::new();
+    let mut group_materialized_sector_ids = BTreeSet::new();
+    for group in &replay.groups {
+        if group.materialized_sector_id != group.representative_sector_id {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay currently requires the materialized sector to be the representative sector",
+            ));
+        }
+        if group.sector_permutations.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "enabled LC topology replay group contains no sector permutations",
+            ));
+        }
+        if contract_version == 2 {
+            validate_lc_topology_replay_proof(group.proof.as_ref())?;
+        }
+        let active_sector_ids = if group.active_sector_ids.is_empty() && contract_version == 1 {
+            group
+                .sector_permutations
+                .iter()
+                .map(|permutation| permutation.sector_id)
+                .collect::<Vec<_>>()
+        } else {
+            group.active_sector_ids.clone()
+        };
+        let active_sector_ids =
+            unique_lc_sector_ids(&active_sector_ids, "LC topology replay active sector ids")?;
+        if !active_sector_ids.contains(&group.representative_sector_id) {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay active sector ids do not include the representative sector",
+            ));
+        }
+        if !group_materialized_sector_ids.insert(group.materialized_sector_id) {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay groups reuse a materialized representative sector",
+            ));
+        }
+        for sector_id in &active_sector_ids {
+            if !replayed_sector_ids.insert(*sector_id) {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay groups overlap in physical sector coverage",
+                ));
+            }
+        }
+        let mut seen_permutations = BTreeSet::new();
+        for permutation in &group.sector_permutations {
+            if !active_sector_ids.contains(&permutation.sector_id) {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay sector permutation is not listed in active sector ids",
+                ));
+            }
+            if !seen_permutations.insert(permutation.sector_id) {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay sector permutations contain duplicate sector ids",
+                ));
+            }
+            if !permutation.weight.is_finite() || permutation.weight <= 0.0 {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay sector permutation weights must be positive finite numbers",
+                ));
+            }
+            if !matches!(permutation.sign, -1 | 1) {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay permutation signs must be -1 or 1",
+                ));
+            }
+            let expected_factor = permutation.weight * f64::from(permutation.sign);
+            let amplitude_factor = match permutation.factor.as_deref() {
+                Some([real, imaginary]) => {
+                    if !real.is_finite()
+                        || !imaginary.is_finite()
+                        || *imaginary != 0.0
+                        || real.to_bits() != expected_factor.to_bits()
+                    {
+                        return Err(RusticolError::invalid_argument(
+                            "LC topology replay signed factor does not match its weight and sign",
+                        ));
+                    }
+                    [*real, *imaginary]
+                }
+                Some(_) => {
+                    return Err(RusticolError::invalid_argument(
+                        "LC topology replay signed factor must contain real and imaginary components",
+                    ));
+                }
+                None if contract_version == 1 => [expected_factor, 0.0],
+                None => {
+                    return Err(RusticolError::invalid_argument(
+                        "LC topology replay contract v2 permutation is missing its signed factor",
+                    ));
+                }
+            };
+            let mapping = normalized_lc_topology_label_permutation(&permutation.label_permutation)?;
+            let route = LcTopologyReplaySectorRoute {
+                physical_sector_id: permutation.sector_id,
+                materialized_sector_id: group.materialized_sector_id,
+                weight: permutation.weight,
+                sign: permutation.sign,
+                amplitude_factor,
+                residual: false,
+            };
+            if route.squared_reduction_weight().to_bits() != route.weight.to_bits() {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay signed factor has inconsistent squared reduction semantics",
+                ));
+            }
+            routes_by_mapping.entry(mapping).or_default().push(route);
+        }
+        if seen_permutations != active_sector_ids {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay sector permutations do not exactly cover the active sectors",
+            ));
+        }
+    }
+    if replayed_sector_ids.len() != replay.replayed_sector_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "LC topology replay declares {} sectors but contains {} permutations",
+            replay.replayed_sector_count,
+            replayed_sector_ids.len()
+        )));
+    }
+    let residual_sector_ids = unique_lc_sector_ids(
+        &replay.residual_sector_ids,
+        "LC topology replay residual sector ids",
+    )?;
+    if replayed_sector_ids
+        .intersection(&residual_sector_ids)
+        .next()
+        .is_some()
+    {
+        return Err(RusticolError::invalid_argument(
+            "LC topology replay residual sectors overlap replayed sectors",
+        ));
+    }
+    for sector_id in &residual_sector_ids {
+        routes_by_mapping
+            .entry(Vec::new())
+            .or_default()
+            .push(LcTopologyReplaySectorRoute {
+                physical_sector_id: *sector_id,
+                materialized_sector_id: *sector_id,
+                weight: 1.0,
+                sign: 1,
+                amplitude_factor: [1.0, 0.0],
+                residual: true,
+            });
+    }
+
+    let mut materialized_sector_ids = group_materialized_sector_ids;
+    materialized_sector_ids.extend(residual_sector_ids.iter().copied());
+    if contract_version == 2 {
+        let declared_materialized = unique_lc_sector_ids(
+            &replay.materialized_sector_ids,
+            "LC topology replay materialized sector ids",
+        )?;
+        if declared_materialized != materialized_sector_ids {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay materialized coverage does not match groups and residuals",
+            ));
+        }
+        let physical_sector_count = replay.physical_sector_count.ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "LC topology replay contract v2 is missing physical_sector_count",
+            )
+        })?;
+        let mut physical_sector_ids = replayed_sector_ids.clone();
+        physical_sector_ids.extend(residual_sector_ids.iter().copied());
+        let expected = (0..physical_sector_count)
+            .map(|sector_id| sector_id as i64)
+            .collect::<BTreeSet<_>>();
+        if physical_sector_ids != expected {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay contract v2 does not cover every physical sector exactly once",
+            ));
+        }
+    } else if !replay.materialized_sector_ids.is_empty()
+        || !replay.residual_sector_ids.is_empty()
+        || replay.physical_sector_count.is_some()
+    {
+        return Err(RusticolError::invalid_argument(
+            "legacy LC topology replay contract contains contract-v2 coverage fields",
+        ));
+    }
+
+    let mut mappings = Vec::with_capacity(routes_by_mapping.len());
+    let mut routes = Vec::with_capacity(routes_by_mapping.len());
+    for (mapping, mut mapping_routes) in routes_by_mapping {
+        mapping_routes.sort_by_key(|route| route.physical_sector_id);
+        mappings.push(mapping);
+        routes.push(mapping_routes);
+    }
+    Ok(LcTopologyReplayData {
+        mappings,
+        routes,
+        materialized_sector_ids,
+    })
+}
+
+pub(super) fn build_color_topology_replay_data(
+    replay: Option<&ColorTopologyReplayManifest>,
+    color_accuracy: &str,
+) -> RusticolResult<LcTopologyReplayData> {
+    let Some(replay) = replay else {
+        return Ok(LcTopologyReplayData::default());
+    };
+    if !replay.enabled {
+        if !replay.groups.is_empty()
+            || replay.replayed_sector_count != 0
+            || !replay.materialized_sector_ids.is_empty()
+            || !replay.residual_sector_ids.is_empty()
+        {
+            return Err(RusticolError::artifact(
+                "disabled color topology replay contains active coverage",
+            ));
+        }
+        return Ok(LcTopologyReplayData::default());
+    }
+    if !matches!(color_accuracy, "nlc" | "full")
+        || replay.color_accuracy != color_accuracy
+        || replay.mode != "external-label-permutation"
+        || replay.contract_version != Some(3)
+    {
+        return Err(RusticolError::artifact(
+            "color topology replay is not bound to the NLC/full artifact accuracy",
+        ));
+    }
+    let compatibility = LcTopologyReplayManifest {
+        enabled: replay.enabled,
+        mode: replay.mode.clone(),
+        contract_version: Some(2),
+        physical_sector_count: replay.physical_sector_count,
+        replayed_sector_count: replay.replayed_sector_count,
+        materialized_sector_ids: replay.materialized_sector_ids.clone(),
+        residual_sector_ids: replay.residual_sector_ids.clone(),
+        groups: replay.groups.clone(),
+    };
+    build_lc_topology_replay_data(Some(&compatibility))
+}
+
+fn validate_lc_topology_replay_proof(
+    proof: Option<&LcTopologyReplayProofManifest>,
+) -> RusticolResult<()> {
+    let proof = proof.ok_or_else(|| {
+        RusticolError::invalid_argument(
+            "LC topology replay contract v2 group is missing proof metadata",
+        )
+    })?;
+    let algorithm = proof.algorithm.as_deref().unwrap_or_default();
+    let digest = proof.digest.as_deref().unwrap_or_default();
+    if proof.status != "proven"
+        || algorithm.is_empty()
+        || digest.len() != 64
+        || !digest
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+    {
+        return Err(RusticolError::invalid_argument(
+            "LC topology replay contract v2 requires a proven algorithm and lowercase SHA-256 digest",
+        ));
+    }
+    Ok(())
+}
+
+fn unique_lc_sector_ids(values: &[i64], description: &str) -> RusticolResult<BTreeSet<i64>> {
+    let result = values.iter().copied().collect::<BTreeSet<_>>();
+    if result.len() != values.len() || result.iter().any(|sector_id| *sector_id < 0) {
+        return Err(RusticolError::invalid_argument(format!(
+            "{description} contain duplicates or negative ids"
+        )));
+    }
+    Ok(result)
+}
+
+fn normalized_lc_topology_label_permutation(
+    values: &[LcTopologyReplayLabelPermutationManifest],
+) -> RusticolResult<Vec<(usize, usize)>> {
+    let mut representatives = BTreeSet::new();
+    let mut sectors = BTreeSet::new();
+    let mut mapping = Vec::new();
+    for item in values {
+        if item.representative_label == 0 || item.sector_label == 0 {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay label permutations must use one-based labels",
+            ));
+        }
+        let representative = item.representative_label - 1;
+        let sector = item.sector_label - 1;
+        if !representatives.insert(representative) || !sectors.insert(sector) {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay label permutation is not one-to-one",
+            ));
+        }
+        if representative != sector {
+            mapping.push((representative, sector));
+        }
+    }
+    if representatives != sectors {
+        return Err(RusticolError::invalid_argument(
+            "LC topology replay label permutation is not a permutation of its support",
+        ));
+    }
+    mapping.sort_unstable();
+    Ok(mapping)
+}
+
+#[derive(Clone, Debug)]
+struct HelicityRecurrenceSchemaCurrent {
+    is_source: bool,
+    external_labels: Vec<usize>,
+}
+
+#[derive(Clone, Debug)]
+struct HelicityRecurrenceSchemaSource {
+    external_label: usize,
+    helicity: i32,
+    chirality: i32,
+    spin_state: GenericSourceSpinStateManifest,
+    declared_states: Vec<GenericSourceStateIrManifest>,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct HelicityRecurrenceSchemaRoot {
+    output_index: usize,
+    left_current_id: usize,
+    right_current_id: usize,
+    helicity_weight: f64,
+}
+
+#[derive(Clone, Debug)]
+struct HelicityCompiledStageChunkCoverage {
+    current_ids_by_chunk: Vec<BTreeSet<usize>>,
+    input_current_ids_by_chunk: Vec<BTreeSet<usize>>,
+}
+
+#[derive(Clone, Debug)]
+struct HelicityCompiledChunkCoverage {
+    stages: Vec<HelicityCompiledStageChunkCoverage>,
+    amplitude_root_ids_by_chunk: Vec<BTreeSet<usize>>,
+    amplitude_input_current_ids_by_chunk: Vec<BTreeSet<usize>>,
+}
+
+#[derive(Clone, Debug)]
+struct HelicityRecurrenceSchemaView {
+    external_count: usize,
+    currents: Vec<HelicityRecurrenceSchemaCurrent>,
+    sources: BTreeMap<usize, HelicityRecurrenceSchemaSource>,
+    roots: Vec<HelicityRecurrenceSchemaRoot>,
+    compiled_chunks: Option<HelicityCompiledChunkCoverage>,
+}
+
+impl HelicityRecurrenceSchemaView {
+    fn from_execution_manifest(manifest: &ExecutionManifest) -> RusticolResult<Self> {
+        let currents = manifest
+            .runtime_schema
+            .current_storage
+            .current_slots
+            .iter()
+            .map(|slot| HelicityRecurrenceSchemaCurrent {
+                is_source: slot.is_source,
+                external_labels: slot.external_labels.clone(),
+            })
+            .collect::<Vec<_>>();
+        let mut sources = BTreeMap::new();
+        for source in &manifest.runtime_schema.source_fill.sources {
+            let declared_states = source
+                .source_ir
+                .states
+                .iter()
+                .map(|state| {
+                    state.transformed(&source.applied_crossing).map_err(|message| {
+                        RusticolError::artifact(format!(
+                            "helicity recurrence source current {} has an invalid declared state: {message}",
+                            source.current_id
+                        ))
+                    })
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let spin_state = serde_json::from_value(source.spin_state.clone()).map_err(|_| {
+                RusticolError::artifact(format!(
+                    "helicity recurrence source current {} has an invalid spin state",
+                    source.current_id
+                ))
+            })?;
+            let record = HelicityRecurrenceSchemaSource {
+                external_label: source.leg_label,
+                helicity: source.source_helicity,
+                chirality: source.chirality,
+                spin_state,
+                declared_states,
+            };
+            if sources.insert(source.current_id, record).is_some() {
+                return Err(RusticolError::artifact(format!(
+                    "helicity recurrence runtime schema repeats source current {}",
+                    source.current_id
+                )));
+            }
+        }
+        let roots = manifest
+            .runtime_schema
+            .amplitude_stage
+            .roots
+            .iter()
+            .map(|root| HelicityRecurrenceSchemaRoot {
+                output_index: root.output_index,
+                left_current_id: root.left_current_id,
+                right_current_id: root.right_current_id,
+                helicity_weight: root.helicity_weight,
+            })
+            .collect::<Vec<_>>();
+        let compiled_chunks = if manifest
+            .runtime_schema
+            .helicity_recurrence
+            .as_ref()
+            .is_some_and(|recurrence| recurrence.materialization.is_some())
+        {
+            manifest
+                .compiled
+                .stage_evaluators
+                .as_ref()
+                .map(|evaluators| {
+                    build_helicity_compiled_chunk_coverage(evaluators, &manifest.runtime_schema)
+                })
+                .transpose()?
+        } else {
+            None
+        };
+        Ok(Self {
+            external_count: manifest.runtime_schema.external_particles.len(),
+            currents,
+            sources,
+            roots,
+            compiled_chunks,
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+struct CompiledValueInputLayout {
+    current_ids_by_slot: BTreeMap<usize, usize>,
+    current_ids_by_global_component: Vec<Option<usize>>,
+}
+
+fn compiled_value_input_layout(schema: &ExecutionPlan) -> RusticolResult<CompiledValueInputLayout> {
+    let current_count = schema.current_storage.current_slots.len();
+    let mut current_ids_by_slot = BTreeMap::new();
+    let mut current_ids_by_global_component = vec![None; schema.value_storage.component_count];
+    for slot in &schema.value_storage.value_slots {
+        if slot.current_id >= current_count
+            || slot.component_start >= slot.component_stop
+            || slot.component_stop > current_ids_by_global_component.len()
+        {
+            return Err(RusticolError::artifact(format!(
+                "value slot {} has stale current {} or component coverage",
+                slot.value_slot_id, slot.current_id
+            )));
+        }
+        if current_ids_by_slot
+            .insert(slot.value_slot_id, slot.current_id)
+            .is_some()
+        {
+            return Err(RusticolError::artifact(format!(
+                "runtime schema repeats value slot {}",
+                slot.value_slot_id
+            )));
+        }
+        for owner in &mut current_ids_by_global_component[slot.component_start..slot.component_stop]
+        {
+            if owner.replace(slot.current_id).is_some() {
+                return Err(RusticolError::artifact(format!(
+                    "value slot {} overlaps another global value component range",
+                    slot.value_slot_id
+                )));
+            }
+        }
+    }
+    Ok(CompiledValueInputLayout {
+        current_ids_by_slot,
+        current_ids_by_global_component,
+    })
+}
+
+fn compiled_input_current_ids_by_chunk(
+    stage: &GenericSerializedStageEvaluatorManifest,
+    value_inputs: &CompiledValueInputLayout,
+    current_count: usize,
+) -> RusticolResult<Vec<BTreeSet<usize>>> {
+    if stage.parameter_layout != "stage-local-value-momentum" {
+        return Err(RusticolError::artifact(format!(
+            "compiled selector stage {:?} requires stage-local input metadata",
+            stage.evaluator_label
+        )));
+    }
+    let evaluator_input_len = stage.evaluator.io_len()?.0;
+    if evaluator_input_len != stage.parameter_count {
+        return Err(RusticolError::artifact(format!(
+            "compiled selector stage {:?} evaluator input count does not match its parameter layout",
+            stage.evaluator_label
+        )));
+    }
+    let mut components_by_parameter = vec![None; stage.parameter_count];
+    for component in &stage.input_components {
+        if component.parameter_index >= stage.parameter_count
+            || components_by_parameter[component.parameter_index]
+                .replace(component)
+                .is_some()
+        {
+            return Err(RusticolError::artifact(format!(
+                "compiled selector stage {:?} has duplicate or stale input-component metadata",
+                stage.evaluator_label
+            )));
+        }
+    }
+    if components_by_parameter.iter().any(Option::is_none) {
+        return Err(RusticolError::artifact(format!(
+            "compiled selector stage {:?} has incomplete input-component metadata",
+            stage.evaluator_label
+        )));
+    }
+
+    stage
+        .evaluator
+        .leaf_layout()?
+        .into_iter()
+        .map(|leaf| {
+            let mut current_ids = BTreeSet::new();
+            for parameter_index in leaf.input_indices {
+                let component = components_by_parameter
+                    .get(parameter_index)
+                    .and_then(|component| *component)
+                    .ok_or_else(|| {
+                        RusticolError::artifact(format!(
+                            "compiled selector stage {:?} chunk references an absent input component",
+                            stage.evaluator_label
+                        ))
+                    })?;
+                match component.kind.as_str() {
+                    "value" => {
+                        let declared_current_id = value_inputs
+                            .current_ids_by_slot
+                            .get(&component.source_id)
+                            .copied()
+                            .ok_or_else(|| {
+                                RusticolError::artifact(format!(
+                                    "compiled selector stage {:?} references absent value slot {}",
+                                    stage.evaluator_label, component.source_id
+                                ))
+                            })?;
+                        let current_id = value_inputs
+                            .current_ids_by_global_component
+                            .get(component.global_component)
+                            .copied()
+                            .flatten()
+                            .ok_or_else(|| {
+                                RusticolError::artifact(format!(
+                                    "compiled selector stage {:?} references unowned global value component {}",
+                                    stage.evaluator_label, component.global_component
+                                ))
+                            })?;
+                        if current_id != declared_current_id {
+                            return Err(RusticolError::artifact(format!(
+                                "compiled selector stage {:?} value-slot and global-component dependencies disagree",
+                                stage.evaluator_label
+                            )));
+                        }
+                        if current_id >= current_count {
+                            return Err(RusticolError::artifact(format!(
+                                "compiled selector stage {:?} references stale current {current_id}",
+                                stage.evaluator_label
+                            )));
+                        }
+                        current_ids.insert(current_id);
+                    }
+                    "momentum" | "model_parameter" => {}
+                    kind => {
+                        return Err(RusticolError::artifact(format!(
+                            "compiled selector stage {:?} has unsupported input kind {kind:?}",
+                            stage.evaluator_label
+                        )));
+                    }
+                }
+            }
+            Ok(current_ids)
+        })
+        .collect()
+}
+
+fn build_helicity_compiled_chunk_coverage(
+    evaluators: &GenericStageEvaluatorArtifactsManifest,
+    schema: &ExecutionPlan,
+) -> RusticolResult<HelicityCompiledChunkCoverage> {
+    let current_count = schema.current_storage.current_slots.len();
+    let roots = schema
+        .amplitude_stage
+        .roots
+        .iter()
+        .map(|root| HelicityRecurrenceSchemaRoot {
+            output_index: root.output_index,
+            left_current_id: root.left_current_id,
+            right_current_id: root.right_current_id,
+            helicity_weight: root.helicity_weight,
+        })
+        .collect::<Vec<_>>();
+    let value_inputs = compiled_value_input_layout(schema)?;
+    build_helicity_compiled_chunk_coverage_from_parts(
+        evaluators,
+        current_count,
+        &roots,
+        &value_inputs,
+    )
+}
+
+fn build_helicity_compiled_chunk_coverage_from_parts(
+    evaluators: &GenericStageEvaluatorArtifactsManifest,
+    current_count: usize,
+    roots: &[HelicityRecurrenceSchemaRoot],
+    value_inputs: &CompiledValueInputLayout,
+) -> RusticolResult<HelicityCompiledChunkCoverage> {
+    let mut stages = Vec::with_capacity(evaluators.stages.len());
+    for stage in &evaluators.stages {
+        let ranges = evaluator_output_chunk_ranges(&stage.evaluator)?;
+        validate_evaluator_output_ranges(&ranges, stage.output_length, &stage.evaluator_label)?;
+        let input_current_ids_by_chunk =
+            compiled_input_current_ids_by_chunk(stage, value_inputs, current_count)?;
+        if input_current_ids_by_chunk.len() != ranges.len() {
+            return Err(RusticolError::artifact(format!(
+                "compiled selector stage {:?} input and output chunk counts disagree",
+                stage.evaluator_label
+            )));
+        }
+        let mut current_ids_by_chunk = vec![BTreeSet::new(); ranges.len()];
+        for slot in &stage.output_slots {
+            let current_id = usize::try_from(slot.current_id).map_err(|_| {
+                RusticolError::artifact(format!(
+                    "helicity recurrence stage {} has a non-current output slot",
+                    stage.stage_index
+                ))
+            })?;
+            if current_id >= current_count
+                || slot.output_start >= slot.output_stop
+                || slot.output_stop > stage.output_length
+            {
+                return Err(RusticolError::artifact(format!(
+                    "helicity recurrence stage {} has a stale current or output range",
+                    stage.stage_index
+                )));
+            }
+            let mut covered = false;
+            for (chunk_index, (start, stop)) in ranges.iter().copied().enumerate() {
+                if slot.output_start < stop && start < slot.output_stop {
+                    current_ids_by_chunk[chunk_index].insert(current_id);
+                    covered = true;
+                }
+            }
+            if !covered {
+                return Err(RusticolError::artifact(format!(
+                    "helicity recurrence stage {} output for current {current_id} is not covered by an evaluator chunk",
+                    stage.stage_index
+                )));
+            }
+        }
+        stages.push(HelicityCompiledStageChunkCoverage {
+            current_ids_by_chunk,
+            input_current_ids_by_chunk,
+        });
+    }
+
+    let amplitude = &evaluators.amplitude_stage;
+    let ranges = evaluator_output_chunk_ranges(&amplitude.evaluator)?;
+    validate_evaluator_output_ranges(&ranges, amplitude.output_length, &amplitude.evaluator_label)?;
+    let amplitude_input_current_ids_by_chunk =
+        compiled_input_current_ids_by_chunk(amplitude, value_inputs, current_count)?;
+    if amplitude_input_current_ids_by_chunk.len() != ranges.len() {
+        return Err(RusticolError::artifact(
+            "compiled selector amplitude input and output chunk counts disagree",
+        ));
+    }
+    let mut amplitude_root_ids_by_chunk = vec![BTreeSet::new(); ranges.len()];
+    let mut output_owner = vec![None; amplitude.output_length];
+    let mut evaluator_column_by_root_output = vec![None; amplitude.output_length];
+    for slot in &amplitude.output_slots {
+        if slot.current_id != -1
+            || slot.output_start >= slot.output_stop
+            || slot.output_stop > amplitude.output_length
+        {
+            return Err(RusticolError::artifact(
+                "helicity recurrence amplitude evaluator has an invalid output slot",
+            ));
+        }
+        let output_len = slot.output_stop - slot.output_start;
+        if slot.component_stop.checked_sub(slot.component_start) != Some(output_len) {
+            return Err(RusticolError::artifact(
+                "helicity recurrence amplitude evaluator has inconsistent output mapping",
+            ));
+        }
+        for offset in 0..output_len {
+            let evaluator_output = slot.output_start + offset;
+            let root_output = slot.component_start + offset;
+            if root_output >= amplitude.output_length
+                || output_owner[evaluator_output].replace(()).is_some()
+                || evaluator_column_by_root_output[root_output]
+                    .replace(evaluator_output)
+                    .is_some()
+            {
+                return Err(RusticolError::artifact(
+                    "helicity recurrence amplitude evaluator has overlapping output slots",
+                ));
+            }
+        }
+    }
+    for (root_id, root) in roots.iter().enumerate() {
+        let evaluator_output = evaluator_column_by_root_output
+            .get(root.output_index)
+            .copied()
+            .flatten()
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "helicity recurrence amplitude root {root_id} is not covered by an evaluator output slot"
+                ))
+            })?;
+        if output_owner[evaluator_output].is_none() {
+            return Err(RusticolError::artifact(format!(
+                "helicity recurrence amplitude root {root_id} is not covered by an evaluator output slot"
+            )));
+        }
+        let chunk_index = ranges
+            .iter()
+            .position(|(start, stop)| *start <= evaluator_output && evaluator_output < *stop)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "helicity recurrence amplitude root {root_id} is not covered by an evaluator chunk"
+                ))
+            })?;
+        amplitude_root_ids_by_chunk[chunk_index].insert(root_id);
+    }
+    Ok(HelicityCompiledChunkCoverage {
+        stages,
+        amplitude_root_ids_by_chunk,
+        amplitude_input_current_ids_by_chunk,
+    })
+}
+
+fn validate_compiled_selector_schedule_closure(
+    context: &str,
+    current_is_source: &[bool],
+    chunks: &HelicityCompiledChunkCoverage,
+    active_stage_chunk_indices: &[Vec<usize>],
+    active_amplitude_chunk_indices: &[usize],
+    allowed_current_ids: Option<&BTreeSet<usize>>,
+    allowed_root_ids: Option<&BTreeSet<usize>>,
+) -> RusticolResult<()> {
+    if active_stage_chunk_indices.len() != chunks.stages.len() {
+        return Err(RusticolError::artifact(format!(
+            "{context} has {} stage schedules, expected {}",
+            active_stage_chunk_indices.len(),
+            chunks.stages.len()
+        )));
+    }
+    let mut available_current_ids = current_is_source
+        .iter()
+        .enumerate()
+        .filter_map(|(current_id, is_source)| {
+            (*is_source && allowed_current_ids.is_none_or(|allowed| allowed.contains(&current_id)))
+                .then_some(current_id)
+        })
+        .collect::<BTreeSet<_>>();
+
+    for (stage_index, (stage, active_chunks)) in chunks
+        .stages
+        .iter()
+        .zip(active_stage_chunk_indices)
+        .enumerate()
+    {
+        validate_sorted_unique_ids(
+            active_chunks,
+            stage.current_ids_by_chunk.len(),
+            &format!("{context} stage {stage_index} active chunks"),
+        )?;
+        let mut stage_outputs = BTreeSet::new();
+        for chunk_index in active_chunks {
+            let output_current_ids = &stage.current_ids_by_chunk[*chunk_index];
+            if let Some(allowed) = allowed_current_ids
+                && !output_current_ids.is_subset(allowed)
+            {
+                let foreign = output_current_ids
+                    .difference(allowed)
+                    .copied()
+                    .collect::<Vec<_>>();
+                return Err(RusticolError::artifact(format!(
+                    "{context} stage {stage_index} evaluator chunk {chunk_index} crosses selector domains through currents {foreign:?}",
+                )));
+            }
+            let missing = stage.input_current_ids_by_chunk[*chunk_index]
+                .difference(&available_current_ids)
+                .copied()
+                .collect::<Vec<_>>();
+            if !missing.is_empty() {
+                return Err(RusticolError::artifact(format!(
+                    "{context} stage {stage_index} evaluator chunk {chunk_index} is missing compiled ancestors {missing:?}",
+                )));
+            }
+            stage_outputs.extend(output_current_ids.iter().copied());
+        }
+        available_current_ids.extend(stage_outputs);
+    }
+
+    validate_sorted_unique_ids(
+        active_amplitude_chunk_indices,
+        chunks.amplitude_root_ids_by_chunk.len(),
+        &format!("{context} active amplitude chunks"),
+    )?;
+    for chunk_index in active_amplitude_chunk_indices {
+        let root_ids = &chunks.amplitude_root_ids_by_chunk[*chunk_index];
+        if let Some(allowed) = allowed_root_ids
+            && !root_ids.is_subset(allowed)
+        {
+            let foreign = root_ids.difference(allowed).copied().collect::<Vec<_>>();
+            return Err(RusticolError::artifact(format!(
+                "{context} amplitude evaluator chunk {chunk_index} crosses selector domains through roots {foreign:?}",
+            )));
+        }
+        let missing = chunks.amplitude_input_current_ids_by_chunk[*chunk_index]
+            .difference(&available_current_ids)
+            .copied()
+            .collect::<Vec<_>>();
+        if !missing.is_empty() {
+            return Err(RusticolError::artifact(format!(
+                "{context} amplitude evaluator chunk {chunk_index} is missing compiled ancestors {missing:?}",
+            )));
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn build_compiled_color_execution_plan(
+    evaluators: &GenericStageEvaluatorArtifactsManifest,
+    schema: &ExecutionPlan,
+    replay_materialized_sector_ids: &BTreeSet<i64>,
+) -> RusticolResult<Option<CompiledColorExecutionPlan>> {
+    let declared_materialized_sector_ids = evaluators
+        .stages
+        .iter()
+        .chain(std::iter::once(&evaluators.amplitude_stage))
+        .flat_map(|stage| &stage.output_slots)
+        .flat_map(|slot| slot.color_selector_domain_ids.iter().copied())
+        .collect::<BTreeSet<_>>();
+    if declared_materialized_sector_ids.is_empty() {
+        return Ok(None);
+    }
+    if !replay_materialized_sector_ids.is_empty()
+        && &declared_materialized_sector_ids != replay_materialized_sector_ids
+    {
+        return Err(RusticolError::artifact(
+            "compiled color-selector metadata does not match LC topology-replay sectors",
+        ));
+    }
+    let materialized_sector_ids = &declared_materialized_sector_ids;
+    let chunks = build_helicity_compiled_chunk_coverage(evaluators, schema)?;
+    let current_is_source = schema
+        .current_storage
+        .current_slots
+        .iter()
+        .map(|current| current.is_source)
+        .collect::<Vec<_>>();
+
+    let mut active_stages = materialized_sector_ids
+        .iter()
+        .map(|sector_id| (*sector_id, Vec::with_capacity(evaluators.stages.len())))
+        .collect::<BTreeMap<_, _>>();
+    for stage in &evaluators.stages {
+        let domains_by_chunk = compiled_color_domains_by_chunk(stage, materialized_sector_ids)?;
+        for sector_id in materialized_sector_ids {
+            active_stages
+                .get_mut(sector_id)
+                .expect("materialized color schedule initialized")
+                .push(
+                    domains_by_chunk
+                        .iter()
+                        .enumerate()
+                        .filter_map(|(chunk_index, domains)| {
+                            domains.contains(sector_id).then_some(chunk_index)
+                        })
+                        .collect(),
+                );
+        }
+    }
+
+    let amplitude_domains =
+        compiled_color_domains_by_chunk(&evaluators.amplitude_stage, materialized_sector_ids)?;
+    let mut schedules_by_materialized_sector = BTreeMap::new();
+    for sector_id in materialized_sector_ids {
+        let active_amplitude_chunk_indices = amplitude_domains
+            .iter()
+            .enumerate()
+            .filter_map(|(chunk_index, domains)| domains.contains(sector_id).then_some(chunk_index))
+            .collect::<Vec<_>>();
+        if active_amplitude_chunk_indices.is_empty() {
+            return Err(RusticolError::artifact(format!(
+                "compiled color selector sector {sector_id} has no amplitude chunk coverage"
+            )));
+        }
+        let active_stage_chunk_indices = active_stages
+            .remove(sector_id)
+            .expect("materialized color schedule initialized");
+        validate_compiled_selector_schedule_closure(
+            &format!("compiled color selector sector {sector_id}"),
+            &current_is_source,
+            &chunks,
+            &active_stage_chunk_indices,
+            &active_amplitude_chunk_indices,
+            None,
+            None,
+        )?;
+        schedules_by_materialized_sector.insert(
+            *sector_id,
+            Arc::new(CompiledColorSelectorSchedule {
+                active_stage_chunk_indices,
+                active_amplitude_chunk_indices,
+            }),
+        );
+    }
+    Ok(Some(CompiledColorExecutionPlan {
+        schedules_by_materialized_sector,
+    }))
+}
+
+fn compiled_color_domains_by_chunk(
+    stage: &GenericSerializedStageEvaluatorManifest,
+    materialized_sector_ids: &BTreeSet<i64>,
+) -> RusticolResult<Vec<BTreeSet<i64>>> {
+    let ranges = evaluator_output_chunk_ranges(&stage.evaluator)?;
+    validate_evaluator_output_ranges(&ranges, stage.output_length, &stage.evaluator_label)?;
+    let mut domains_by_chunk = vec![None; ranges.len()];
+    for slot in &stage.output_slots {
+        if slot.output_start >= slot.output_stop || slot.output_stop > stage.output_length {
+            return Err(RusticolError::artifact(format!(
+                "compiled color selector stage {:?} has an invalid output slot",
+                stage.evaluator_label
+            )));
+        }
+        let domains = slot
+            .color_selector_domain_ids
+            .iter()
+            .copied()
+            .collect::<BTreeSet<_>>();
+        if domains.len() != slot.color_selector_domain_ids.len()
+            || !domains.is_subset(materialized_sector_ids)
+        {
+            return Err(RusticolError::artifact(format!(
+                "compiled color selector stage {:?} has invalid materialized-sector coverage",
+                stage.evaluator_label
+            )));
+        }
+        for (chunk_index, (start, stop)) in ranges.iter().copied().enumerate() {
+            if slot.output_start < stop && start < slot.output_stop {
+                if let Some(previous) = &domains_by_chunk[chunk_index] {
+                    if previous != &domains {
+                        return Err(RusticolError::artifact(format!(
+                            "compiled color selector stage {:?} evaluator chunk {chunk_index} crosses selector domains",
+                            stage.evaluator_label
+                        )));
+                    }
+                } else {
+                    domains_by_chunk[chunk_index] = Some(domains.clone());
+                }
+            }
+        }
+    }
+    domains_by_chunk
+        .into_iter()
+        .enumerate()
+        .map(|(chunk_index, domains)| {
+            domains.ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "compiled color selector stage {:?} evaluator chunk {chunk_index} has no output ownership",
+                    stage.evaluator_label
+                ))
+            })
+        })
+        .collect()
+}
+
+fn evaluator_output_chunk_ranges(
+    evaluator: &EvaluatorManifest,
+) -> RusticolResult<Vec<(usize, usize)>> {
+    evaluator.leaf_layout().map(|layout| {
+        layout
+            .into_iter()
+            .map(|leaf| (leaf.output_range.start, leaf.output_range.end))
+            .collect()
+    })
+}
+
+fn validate_evaluator_output_ranges(
+    ranges: &[(usize, usize)],
+    expected_output_length: usize,
+    label: &str,
+) -> RusticolResult<()> {
+    if ranges.is_empty()
+        || ranges.first().map(|range| range.0) != Some(0)
+        || ranges.last().map(|range| range.1) != Some(expected_output_length)
+        || ranges
+            .windows(2)
+            .any(|pair| pair[0].1 != pair[1].0 || pair[0].0 >= pair[0].1)
+    {
+        return Err(RusticolError::artifact(format!(
+            "helicity recurrence evaluator {label:?} has inconsistent chunk output ranges"
+        )));
+    }
+    Ok(())
+}
+
+#[derive(Clone, Copy, Debug)]
+struct HelicityCurrentOwner {
+    class_index: usize,
+    selector_domain_id: usize,
+    factor: [f64; 2],
+}
+
+fn build_helicity_recurrence_runtime(
+    manifest: &ExecutionManifest,
+) -> RusticolResult<Option<HelicityRecurrenceRuntime>> {
+    let recurrence = manifest.runtime_schema.helicity_recurrence.as_ref();
+    let view = HelicityRecurrenceSchemaView::from_execution_manifest(manifest)?;
+    build_helicity_recurrence_runtime_from_view(recurrence, &view)
+}
+
+fn detach_compiled_helicity_load_inputs(
+    manifest: &mut ExecutionManifest,
+) -> RusticolResult<(
+    Option<GenericStageEvaluatorArtifactsManifest>,
+    Option<HelicityRecurrenceRuntime>,
+)> {
+    let helicity_recurrence = build_helicity_recurrence_runtime(manifest)?;
+    let stage_evaluators = manifest.compiled.stage_evaluators.take();
+    // The authenticated runtime owns every derived selector schedule.  Hide the
+    // source contract from the metadata-only constructor after its serialized
+    // evaluators have moved into the payload loader so it cannot rederive the
+    // schedules against an artificially empty evaluator set.
+    manifest.runtime_schema.helicity_recurrence = None;
+    Ok((stage_evaluators, helicity_recurrence))
+}
+
+fn build_helicity_recurrence_runtime_from_view(
+    recurrence: Option<&HelicityRecurrenceManifest>,
+    schema: &HelicityRecurrenceSchemaView,
+) -> RusticolResult<Option<HelicityRecurrenceRuntime>> {
+    let Some(recurrence) = recurrence else {
+        return Ok(None);
+    };
+    if recurrence.kind != HELICITY_RECURRENCE_KIND {
+        return Err(RusticolError::artifact(format!(
+            "unsupported helicity recurrence kind {:?}",
+            recurrence.kind
+        )));
+    }
+    if recurrence.contract_version != HELICITY_RECURRENCE_CONTRACT_VERSION {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported helicity recurrence contract version {}; regenerate the artifact",
+            recurrence.contract_version
+        )));
+    }
+    if recurrence.proof_algorithm != HELICITY_RECURRENCE_PROOF_ALGORITHM {
+        return Err(RusticolError::artifact(format!(
+            "unsupported helicity recurrence proof algorithm {:?}",
+            recurrence.proof_algorithm
+        )));
+    }
+    if recurrence.materialization.is_none()
+        && (recurrence.current_count != schema.currents.len()
+            || recurrence.amplitude_root_count != schema.roots.len())
+    {
+        return Err(RusticolError::artifact(
+            "helicity recurrence counts do not match the final runtime schema",
+        ));
+    }
+
+    let mut domain_keys = BTreeSet::new();
+    let mut selector_domains = Vec::with_capacity(recurrence.selector_domains.len());
+    for (expected_id, domain) in recurrence.selector_domains.iter().enumerate() {
+        if domain.id != expected_id {
+            return Err(RusticolError::artifact(format!(
+                "helicity selector domain ids must be contiguous; expected {expected_id}, got {}",
+                domain.id
+            )));
+        }
+        let labels = validate_helicity_external_labels(
+            domain
+                .source_states
+                .iter()
+                .map(|state| state.external_label),
+            schema.external_count,
+            &format!("helicity selector domain {expected_id}"),
+        )?;
+        let is_complete = labels.len() == schema.external_count
+            && labels
+                .iter()
+                .enumerate()
+                .all(|(index, label)| *label == index + 1);
+        if domain.complete != is_complete {
+            return Err(RusticolError::artifact(format!(
+                "helicity selector domain {expected_id} has inconsistent complete coverage"
+            )));
+        }
+        let key = domain
+            .source_states
+            .iter()
+            .map(|state| (state.external_label, state.helicity))
+            .collect::<Vec<_>>();
+        if !domain_keys.insert(key.clone()) {
+            return Err(RusticolError::artifact(
+                "helicity selector domains repeat a source-state assignment",
+            ));
+        }
+        selector_domains.push(HelicitySelectorDomainRuntime {
+            complete: domain.complete,
+            source_states: key
+                .into_iter()
+                .map(|(label, helicity)| (label - 1, helicity))
+                .collect(),
+        });
+    }
+
+    let mut class_ids = BTreeMap::new();
+    let mut current_owners = vec![None; recurrence.current_count];
+    let mut recurrence_classes = Vec::with_capacity(recurrence.recurrence_classes.len());
+    for (class_index, class) in recurrence.recurrence_classes.iter().enumerate() {
+        validate_helicity_recurrence_proof(
+            &class.class_id,
+            "helicity-current-sha256:",
+            &class.proof,
+        )?;
+        if class_ids
+            .insert(class.class_id.as_str(), class_index)
+            .is_some()
+        {
+            return Err(RusticolError::artifact(
+                "helicity recurrence class ids must be unique",
+            ));
+        }
+        if class.members.is_empty() {
+            return Err(RusticolError::artifact(format!(
+                "helicity recurrence class {:?} has no members",
+                class.class_id
+            )));
+        }
+        let external_labels = validate_helicity_external_labels(
+            class.external_labels.iter().copied(),
+            schema.external_count,
+            &format!("helicity recurrence class {:?}", class.class_id),
+        )?;
+        if class.source_class && external_labels.len() != 1 {
+            return Err(RusticolError::artifact(format!(
+                "helicity source recurrence class {:?} must cover exactly one external label",
+                class.class_id
+            )));
+        }
+        let mut representative_seen = false;
+        let mut members = Vec::with_capacity(class.members.len());
+        for member in &class.members {
+            validate_helicity_factor(
+                member.factor,
+                &format!("helicity recurrence current {}", member.current_id),
+            )?;
+            if member.current_id >= recurrence.current_count {
+                return Err(RusticolError::artifact(format!(
+                    "helicity recurrence class {:?} references stale current id {}",
+                    class.class_id, member.current_id
+                )));
+            }
+            let domain = recurrence
+                .selector_domains
+                .get(member.selector_domain_id)
+                .ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "helicity recurrence current {} references unknown selector domain {}",
+                        member.current_id, member.selector_domain_id
+                    ))
+                })?;
+            let domain_labels = domain
+                .source_states
+                .iter()
+                .map(|state| state.external_label)
+                .collect::<Vec<_>>();
+            if domain_labels != external_labels {
+                return Err(RusticolError::artifact(format!(
+                    "helicity recurrence current {} does not match class {:?}",
+                    member.current_id, class.class_id
+                )));
+            }
+            if recurrence.materialization.is_none() {
+                let current = &schema.currents[member.current_id];
+                if current.is_source != class.source_class
+                    || (!current.external_labels.is_empty()
+                        && current.external_labels != external_labels)
+                {
+                    return Err(RusticolError::artifact(format!(
+                        "helicity recurrence current {} does not match class {:?}",
+                        member.current_id, class.class_id
+                    )));
+                }
+            }
+            if current_owners[member.current_id]
+                .replace(HelicityCurrentOwner {
+                    class_index,
+                    selector_domain_id: member.selector_domain_id,
+                    factor: member.factor,
+                })
+                .is_some()
+            {
+                return Err(RusticolError::artifact(format!(
+                    "helicity recurrence current {} belongs to multiple classes",
+                    member.current_id
+                )));
+            }
+            if member.current_id == class.representative_current_id {
+                representative_seen = true;
+                if !helicity_factors_equal(member.factor, [1.0, 0.0]) {
+                    return Err(RusticolError::artifact(format!(
+                        "helicity recurrence representative current {} must carry the identity factor",
+                        member.current_id
+                    )));
+                }
+            }
+            members.push(HelicityCurrentReplayMemberRuntime {
+                current_id: member.current_id,
+                selector_domain_id: member.selector_domain_id,
+                factor: member.factor,
+            });
+        }
+        if !representative_seen {
+            return Err(RusticolError::artifact(format!(
+                "helicity recurrence representative current {} is not a member of class {:?}",
+                class.representative_current_id, class.class_id
+            )));
+        }
+        recurrence_classes.push(HelicityRecurrenceClassRuntime {
+            representative_current_id: class.representative_current_id,
+            external_labels: external_labels.into_iter().map(|label| label - 1).collect(),
+            source_class: class.source_class,
+            members,
+        });
+    }
+
+    validate_sorted_unique_ids(
+        &recurrence.residual_current_ids,
+        recurrence.current_count,
+        "helicity recurrence residual current ids",
+    )?;
+    for current_id in &recurrence.residual_current_ids {
+        if current_owners[*current_id].is_some() {
+            return Err(RusticolError::artifact(format!(
+                "helicity residual current {current_id} overlaps a proven recurrence class"
+            )));
+        }
+    }
+    if current_owners
+        .iter()
+        .filter(|owner| owner.is_some())
+        .count()
+        + recurrence.residual_current_ids.len()
+        != recurrence.current_count
+    {
+        return Err(RusticolError::artifact(
+            "helicity recurrence classes and residual currents do not cover the proof DAG",
+        ));
+    }
+    if recurrence.materialization.is_none()
+        && recurrence
+            .residual_current_ids
+            .iter()
+            .any(|current_id| schema.currents[*current_id].is_source)
+    {
+        return Err(RusticolError::artifact(
+            "helicity recurrence leaves a final runtime source current residual",
+        ));
+    }
+
+    let source_class_current_ids = recurrence
+        .recurrence_classes
+        .iter()
+        .filter(|class| class.source_class)
+        .flat_map(|class| class.members.iter().map(|member| member.current_id))
+        .collect::<BTreeSet<_>>();
+    let mut mapped_source_ids = BTreeSet::new();
+    let mut source_state_mappings = Vec::with_capacity(recurrence.source_state_mappings.len());
+    for mapping in &recurrence.source_state_mappings {
+        validate_helicity_factor(
+            mapping.factor,
+            &format!("helicity source mapping for current {}", mapping.current_id),
+        )?;
+        validate_sha256_digest(
+            &mapping.source_contract_digest,
+            &format!("helicity source mapping for current {}", mapping.current_id),
+        )?;
+        if !mapped_source_ids.insert(mapping.current_id) {
+            return Err(RusticolError::artifact(format!(
+                "helicity source current {} has multiple state mappings",
+                mapping.current_id
+            )));
+        }
+        let owner = current_owners
+            .get(mapping.current_id)
+            .and_then(|owner| *owner)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "helicity source mapping references residual or stale current {}",
+                    mapping.current_id
+                ))
+            })?;
+        let class = &recurrence.recurrence_classes[owner.class_index];
+        let domain = recurrence
+            .selector_domains
+            .get(mapping.selector_domain_id)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "helicity source mapping current {} references unknown selector domain {}",
+                    mapping.current_id, mapping.selector_domain_id
+                ))
+            })?;
+        if !class.source_class
+            || mapping.recurrence_class_id != class.class_id
+            || mapping.representative_current_id != class.representative_current_id
+            || mapping.selector_domain_id != owner.selector_domain_id
+            || !helicity_factors_equal(mapping.factor, owner.factor)
+            || !domain.source_states.iter().any(|state| {
+                state.external_label == mapping.external_label && state.helicity == mapping.helicity
+            })
+        {
+            return Err(RusticolError::artifact(format!(
+                "helicity source mapping current {} is inconsistent with its recurrence class, selector domain, or SourceIR",
+                mapping.current_id
+            )));
+        }
+        if recurrence.materialization.is_none() {
+            validate_helicity_source_against_runtime(
+                mapping.current_id,
+                mapping.external_label,
+                mapping.helicity,
+                mapping.chirality,
+                &mapping.spin_state,
+                mapping.declared_state_index,
+                schema,
+            )?;
+        }
+        source_state_mappings.push(HelicitySourceStateMappingRuntime {
+            current_id: mapping.current_id,
+            external_index: mapping.external_label - 1,
+            helicity: mapping.helicity,
+            chirality: mapping.chirality,
+            spin_state: mapping.spin_state.clone(),
+            declared_state_index: mapping.declared_state_index,
+            selector_domain_id: mapping.selector_domain_id,
+            recurrence_class_index: owner.class_index,
+            representative_current_id: mapping.representative_current_id,
+            factor: mapping.factor,
+        });
+    }
+    if mapped_source_ids != source_class_current_ids {
+        return Err(RusticolError::artifact(
+            "helicity source-state mappings do not exactly cover proven source-class currents",
+        ));
+    }
+    let residual_current_ids = recurrence
+        .residual_current_ids
+        .iter()
+        .copied()
+        .collect::<BTreeSet<_>>();
+    let mut root_owners = vec![false; recurrence.amplitude_root_count];
+    let mut amplitude_class_ids = BTreeSet::new();
+    let mut represented_complete_domains = BTreeSet::new();
+    let mut amplitude_classes = Vec::with_capacity(recurrence.amplitude_classes.len());
+    for class in &recurrence.amplitude_classes {
+        validate_helicity_recurrence_proof(
+            &class.class_id,
+            "helicity-amplitude-sha256:",
+            &class.proof,
+        )?;
+        if !amplitude_class_ids.insert(class.class_id.as_str()) {
+            return Err(RusticolError::artifact(
+                "helicity amplitude recurrence class ids must be unique",
+            ));
+        }
+        if class.members.is_empty() {
+            return Err(RusticolError::artifact(format!(
+                "helicity amplitude class {:?} has no members",
+                class.class_id
+            )));
+        }
+        let mut representative_seen = false;
+        let mut members = Vec::with_capacity(class.members.len());
+        for member in &class.members {
+            validate_helicity_factor(
+                member.factor,
+                &format!("helicity amplitude root {}", member.root_id),
+            )?;
+            if member.root_id >= recurrence.amplitude_root_count {
+                return Err(RusticolError::artifact(format!(
+                    "helicity amplitude class {:?} references stale root id {}",
+                    class.class_id, member.root_id
+                )));
+            }
+            if root_owners[member.root_id] {
+                return Err(RusticolError::artifact(format!(
+                    "helicity amplitude root {} belongs to multiple classes",
+                    member.root_id
+                )));
+            }
+            root_owners[member.root_id] = true;
+            validate_complete_selector_ids(
+                &member.selector_domain_ids,
+                recurrence,
+                &format!("helicity amplitude root {}", member.root_id),
+            )?;
+            represented_complete_domains.extend(member.selector_domain_ids.iter().copied());
+            if recurrence.materialization.is_none() {
+                let root = &schema.roots[member.root_id];
+                if !root.helicity_weight.is_finite()
+                    || (root.helicity_weight - member.selector_domain_ids.len() as f64).abs()
+                        > 1.0e-12
+                {
+                    return Err(RusticolError::artifact(format!(
+                        "helicity amplitude root {} selector coverage disagrees with its final runtime helicity weight",
+                        member.root_id
+                    )));
+                }
+                if residual_current_ids.contains(&root.left_current_id)
+                    || residual_current_ids.contains(&root.right_current_id)
+                {
+                    return Err(RusticolError::artifact(format!(
+                        "proven helicity amplitude root {} depends on a residual current",
+                        member.root_id
+                    )));
+                }
+            }
+            representative_seen |= member.root_id == class.representative_root_id;
+            members.push(HelicityAmplitudeReplayMemberRuntime {
+                root_id: member.root_id,
+                selector_domain_ids: member.selector_domain_ids.clone(),
+                factor: member.factor,
+            });
+        }
+        if !representative_seen {
+            return Err(RusticolError::artifact(format!(
+                "helicity amplitude representative root {} is not a member of class {:?}",
+                class.representative_root_id, class.class_id
+            )));
+        }
+        amplitude_classes.push(HelicityAmplitudeReplayClassRuntime {
+            representative_root_id: class.representative_root_id,
+            members,
+        });
+    }
+
+    validate_sorted_unique_ids(
+        &recurrence.residual_root_ids,
+        recurrence.amplitude_root_count,
+        "helicity recurrence residual root ids",
+    )?;
+    for root_id in &recurrence.residual_root_ids {
+        if root_owners[*root_id] {
+            return Err(RusticolError::artifact(format!(
+                "helicity residual root {root_id} overlaps a proven amplitude class"
+            )));
+        }
+    }
+    if root_owners.iter().filter(|owned| **owned).count() + recurrence.residual_root_ids.len()
+        != recurrence.amplitude_root_count
+    {
+        return Err(RusticolError::artifact(
+            "helicity amplitude classes and residual roots do not cover the proof DAG",
+        ));
+    }
+
+    validate_sorted_unique_ids(
+        &recurrence.structural_zero_selector_domain_ids,
+        recurrence.selector_domains.len(),
+        "structural-zero helicity selector domain ids",
+    )?;
+    let structural_zero_domains = recurrence
+        .structural_zero_selector_domain_ids
+        .iter()
+        .copied()
+        .collect::<BTreeSet<_>>();
+    if structural_zero_domains
+        .iter()
+        .any(|domain_id| !recurrence.selector_domains[*domain_id].complete)
+        || !structural_zero_domains.is_disjoint(&represented_complete_domains)
+    {
+        return Err(RusticolError::artifact(
+            "structural-zero helicity domains must be complete and disjoint from amplitude coverage",
+        ));
+    }
+    if recurrence.materialization.is_none() {
+        let available_source_states = recurrence
+            .source_state_mappings
+            .iter()
+            .map(|mapping| (mapping.external_label, mapping.helicity))
+            .collect::<BTreeSet<_>>();
+        let directly_executable_domains = recurrence
+            .selector_domains
+            .iter()
+            .filter(|domain| {
+                domain.source_states.iter().all(|state| {
+                    available_source_states.contains(&(state.external_label, state.helicity))
+                })
+            })
+            .map(|domain| domain.id)
+            .collect::<BTreeSet<_>>();
+        let mut replay_anchored_domains = BTreeSet::new();
+        for class in &recurrence.amplitude_classes {
+            for member in &class.members {
+                if !member
+                    .selector_domain_ids
+                    .iter()
+                    .any(|domain_id| directly_executable_domains.contains(domain_id))
+                {
+                    let domain_id =
+                        member.selector_domain_ids.first().copied().ok_or_else(|| {
+                            RusticolError::artifact(
+                                "helicity amplitude replay member has no selector domains",
+                            )
+                        })?;
+                    return Err(RusticolError::artifact(format!(
+                        "helicity selector domain {domain_id} has no directly executable source-state anchor in its certified amplitude replay group"
+                    )));
+                }
+                replay_anchored_domains.extend(member.selector_domain_ids.iter().copied());
+            }
+        }
+        for domain in &recurrence.selector_domains {
+            if structural_zero_domains.contains(&domain.id)
+                || directly_executable_domains.contains(&domain.id)
+                || replay_anchored_domains.contains(&domain.id)
+            {
+                continue;
+            }
+            if domain.complete {
+                return Err(RusticolError::artifact(format!(
+                    "helicity selector domain {} is neither directly executable nor covered by a certified amplitude replay group",
+                    domain.id
+                )));
+            }
+        }
+    }
+    let complete_domains = recurrence
+        .selector_domains
+        .iter()
+        .filter(|domain| domain.complete)
+        .map(|domain| domain.id)
+        .collect::<BTreeSet<_>>();
+    if complete_domains
+        != represented_complete_domains
+            .union(&structural_zero_domains)
+            .copied()
+            .collect()
+    {
+        return Err(RusticolError::artifact(
+            "helicity amplitude and structural-zero domains do not cover every complete selector domain",
+        ));
+    }
+
+    let actual_counts = HelicityRecurrenceProofCountsManifest {
+        recurrence_class_count: recurrence.recurrence_classes.len(),
+        optimized_recurrence_class_count: recurrence
+            .recurrence_classes
+            .iter()
+            .filter(|class| class.members.len() > 1)
+            .count(),
+        optimized_current_count: recurrence
+            .recurrence_classes
+            .iter()
+            .filter(|class| class.members.len() > 1)
+            .map(|class| class.members.len())
+            .sum(),
+        residual_current_count: recurrence.residual_current_ids.len(),
+        amplitude_class_count: recurrence.amplitude_classes.len(),
+        optimized_amplitude_class_count: recurrence
+            .amplitude_classes
+            .iter()
+            .filter(|class| class.members.len() > 1)
+            .count(),
+        residual_amplitude_count: recurrence.residual_root_ids.len(),
+        source_state_mapping_count: recurrence.source_state_mappings.len(),
+        physical_helicity_count: complete_domains.len(),
+        structural_zero_helicity_count: structural_zero_domains.len(),
+    };
+    if recurrence.proof_counts != actual_counts {
+        return Err(RusticolError::artifact(
+            "helicity recurrence proof counts do not match validated manifest contents",
+        ));
+    }
+
+    let materialization = recurrence
+        .materialization
+        .as_ref()
+        .map(|materialization| {
+            build_helicity_materialization_runtime(
+                recurrence,
+                materialization,
+                schema,
+                &current_owners,
+                &complete_domains,
+                &structural_zero_domains,
+            )
+        })
+        .transpose()?;
+
+    Ok(Some(HelicityRecurrenceRuntime {
+        selector_domains,
+        source_state_mappings,
+        recurrence_classes,
+        amplitude_classes,
+        residual_current_ids: recurrence.residual_current_ids.clone(),
+        residual_root_ids: recurrence.residual_root_ids.clone(),
+        structural_zero_selector_domain_ids: recurrence.structural_zero_selector_domain_ids.clone(),
+        materialization,
+    }))
+}
+
+fn validate_helicity_source_against_runtime(
+    current_id: usize,
+    external_label: usize,
+    helicity: i32,
+    chirality: i32,
+    spin_state: &GenericSourceSpinStateManifest,
+    declared_state_index: usize,
+    schema: &HelicityRecurrenceSchemaView,
+) -> RusticolResult<()> {
+    let source = schema.sources.get(&current_id).ok_or_else(|| {
+        RusticolError::artifact(format!(
+            "helicity source mapping current {current_id} is not a runtime source"
+        ))
+    })?;
+    let declared_state = source
+        .declared_states
+        .get(declared_state_index)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "helicity source mapping current {current_id} has stale declared state index {declared_state_index}"
+            ))
+        })?;
+    if external_label != source.external_label
+        || helicity != source.helicity
+        || chirality != source.chirality
+        || spin_state != &source.spin_state
+        || declared_state.helicity != helicity
+        || declared_state.chirality != chirality
+        || &declared_state.spin_state != spin_state
+    {
+        return Err(RusticolError::artifact(format!(
+            "helicity source mapping current {current_id} is inconsistent with its SourceIR"
+        )));
+    }
+    Ok(())
+}
+
+fn build_helicity_materialization_runtime(
+    recurrence: &HelicityRecurrenceManifest,
+    materialization: &HelicityRecurrenceMaterializationManifest,
+    schema: &HelicityRecurrenceSchemaView,
+    current_owners: &[Option<HelicityCurrentOwner>],
+    complete_domains: &BTreeSet<usize>,
+    structural_zero_domains: &BTreeSet<usize>,
+) -> RusticolResult<HelicityRecurrenceMaterializationRuntime> {
+    if materialization.kind != HELICITY_MATERIALIZATION_KIND {
+        return Err(RusticolError::artifact(format!(
+            "unsupported helicity recurrence materialization kind {:?}",
+            materialization.kind
+        )));
+    }
+    if materialization.contract_version != HELICITY_MATERIALIZATION_CONTRACT_VERSION {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported helicity recurrence materialization contract version {}; regenerate the artifact",
+            materialization.contract_version
+        )));
+    }
+    if materialization.proof_current_count != recurrence.current_count
+        || materialization.proof_root_count != recurrence.amplitude_root_count
+    {
+        return Err(RusticolError::artifact(
+            "helicity materialization proof counts do not match the recurrence proof DAG",
+        ));
+    }
+    if materialization.materialized_current_count != schema.currents.len()
+        || materialization.materialized_root_count != schema.roots.len()
+    {
+        return Err(RusticolError::artifact(
+            "helicity materialization counts do not match the final runtime schema",
+        ));
+    }
+    if materialization.proof_to_materialized_current.len() != recurrence.current_count
+        || materialization
+            .proof_to_materialized_current
+            .iter()
+            .any(|current_id| *current_id >= materialization.materialized_current_count)
+    {
+        return Err(RusticolError::artifact(
+            "helicity proof-to-materialized current map has a stale id or incorrect length",
+        ));
+    }
+
+    let residual_targets = match materialization.strategy {
+        HelicityMaterializationStrategy::Quotient => {
+            validate_quotient_helicity_current_map(recurrence, materialization, schema)?
+        }
+        HelicityMaterializationStrategy::RetainedProofGraph => {
+            validate_retained_helicity_current_map(recurrence, materialization, schema)?
+        }
+    };
+
+    let source_routes = validate_helicity_materialized_source_routes(
+        recurrence,
+        materialization,
+        schema,
+        current_owners,
+    )?;
+    let amplitude_routes = validate_helicity_materialized_amplitude_routes(
+        recurrence,
+        materialization,
+        schema,
+        complete_domains,
+        structural_zero_domains,
+        &residual_targets,
+    )?;
+    let selector_schedules = validate_helicity_materialized_selector_schedules(
+        recurrence,
+        materialization,
+        schema,
+        complete_domains,
+        structural_zero_domains,
+    )?;
+
+    Ok(HelicityRecurrenceMaterializationRuntime {
+        strategy: materialization.strategy,
+        proof_to_materialized_current: materialization.proof_to_materialized_current.clone(),
+        source_routes,
+        amplitude_routes,
+        selector_schedules,
+    })
+}
+
+fn validate_quotient_helicity_current_map(
+    recurrence: &HelicityRecurrenceManifest,
+    materialization: &HelicityRecurrenceMaterializationManifest,
+    schema: &HelicityRecurrenceSchemaView,
+) -> RusticolResult<BTreeSet<usize>> {
+    let mut target_seen = vec![false; materialization.materialized_current_count];
+    for class in &recurrence.recurrence_classes {
+        let target = materialization.proof_to_materialized_current[class.representative_current_id];
+        if class.members.iter().any(|member| {
+            materialization.proof_to_materialized_current[member.current_id] != target
+        }) {
+            return Err(RusticolError::artifact(format!(
+                "helicity recurrence class {:?} is split across materialized currents",
+                class.class_id
+            )));
+        }
+        if target_seen[target] {
+            return Err(RusticolError::artifact(format!(
+                "helicity materialized current {target} is shared by distinct proof classes"
+            )));
+        }
+        target_seen[target] = true;
+        let current = &schema.currents[target];
+        if current.is_source != class.source_class
+            || (!current.external_labels.is_empty()
+                && current.external_labels != class.external_labels)
+        {
+            return Err(RusticolError::artifact(format!(
+                "helicity materialized current {target} does not match proof class {:?}",
+                class.class_id
+            )));
+        }
+    }
+    let mut residual_targets = BTreeSet::new();
+    for proof_current_id in &recurrence.residual_current_ids {
+        let target = materialization.proof_to_materialized_current[*proof_current_id];
+        if target_seen[target] || !residual_targets.insert(target) {
+            return Err(RusticolError::artifact(format!(
+                "helicity residual proof current {proof_current_id} overlaps another materialized current"
+            )));
+        }
+        if schema.currents[target].is_source {
+            return Err(RusticolError::artifact(format!(
+                "helicity residual proof current {proof_current_id} materializes as an unrouted source"
+            )));
+        }
+        target_seen[target] = true;
+    }
+    if target_seen.iter().any(|seen| !seen) {
+        return Err(RusticolError::artifact(
+            "helicity proof-to-materialized current map does not cover every final current",
+        ));
+    }
+    Ok(residual_targets)
+}
+
+fn validate_retained_helicity_current_map(
+    recurrence: &HelicityRecurrenceManifest,
+    materialization: &HelicityRecurrenceMaterializationManifest,
+    schema: &HelicityRecurrenceSchemaView,
+) -> RusticolResult<BTreeSet<usize>> {
+    if materialization.materialized_current_count != recurrence.current_count
+        || materialization.materialized_root_count != recurrence.amplitude_root_count
+    {
+        return Err(RusticolError::artifact(
+            "retained helicity materialization must preserve every proof current and root",
+        ));
+    }
+    if materialization
+        .proof_to_materialized_current
+        .iter()
+        .enumerate()
+        .any(|(proof_id, materialized_id)| proof_id != *materialized_id)
+    {
+        return Err(RusticolError::artifact(
+            "retained helicity materialization requires an identity current map",
+        ));
+    }
+
+    let mut current_seen = vec![false; recurrence.current_count];
+    for class in &recurrence.recurrence_classes {
+        for member in &class.members {
+            let current = &schema.currents[member.current_id];
+            if current_seen[member.current_id]
+                || current.is_source != class.source_class
+                || (!current.external_labels.is_empty()
+                    && current.external_labels != class.external_labels)
+            {
+                return Err(RusticolError::artifact(format!(
+                    "retained helicity current {} does not match proof class {:?}",
+                    member.current_id, class.class_id
+                )));
+            }
+            current_seen[member.current_id] = true;
+        }
+    }
+    let mut residual_targets = BTreeSet::new();
+    for proof_current_id in &recurrence.residual_current_ids {
+        if current_seen[*proof_current_id] || !residual_targets.insert(*proof_current_id) {
+            return Err(RusticolError::artifact(format!(
+                "retained helicity residual current {proof_current_id} overlaps another proof current"
+            )));
+        }
+        if schema.currents[*proof_current_id].is_source {
+            return Err(RusticolError::artifact(format!(
+                "retained helicity residual current {proof_current_id} is an unrouted source"
+            )));
+        }
+        current_seen[*proof_current_id] = true;
+    }
+    if current_seen.iter().any(|seen| !seen) {
+        return Err(RusticolError::artifact(
+            "retained helicity materialization does not cover every proof current",
+        ));
+    }
+    Ok(residual_targets)
+}
+
+fn validate_helicity_materialized_source_routes(
+    recurrence: &HelicityRecurrenceManifest,
+    materialization: &HelicityRecurrenceMaterializationManifest,
+    schema: &HelicityRecurrenceSchemaView,
+    current_owners: &[Option<HelicityCurrentOwner>],
+) -> RusticolResult<Vec<HelicityMaterializedSourceRouteRuntime>> {
+    if materialization.source_routes.len() != recurrence.source_state_mappings.len() {
+        return Err(RusticolError::artifact(
+            "helicity materialized source routes do not cover every proof source mapping",
+        ));
+    }
+    let mut route_keys = BTreeSet::new();
+    let mut routed_source_ids = BTreeSet::new();
+    let mut runtime_routes = Vec::with_capacity(materialization.source_routes.len());
+    for (mapping, route) in recurrence
+        .source_state_mappings
+        .iter()
+        .zip(&materialization.source_routes)
+    {
+        validate_helicity_factor(
+            route.factor,
+            &format!(
+                "helicity materialized source route for proof current {}",
+                mapping.current_id
+            ),
+        )?;
+        let owner = current_owners[mapping.current_id].ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "helicity materialized source route references unproven current {}",
+                mapping.current_id
+            ))
+        })?;
+        let class = &recurrence.recurrence_classes[owner.class_index];
+        let representative_factor = class
+            .members
+            .iter()
+            .find(|member| member.current_id == class.representative_current_id)
+            .map(|member| member.factor)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "helicity source class {:?} has no representative factor",
+                    class.class_id
+                ))
+            })?;
+        let expected_current_id = materialization.proof_to_materialized_current[mapping.current_id];
+        let factor_matches = match materialization.strategy {
+            HelicityMaterializationStrategy::Quotient => {
+                helicity_factor_ratio_matches(route.factor, mapping.factor, representative_factor)
+            }
+            HelicityMaterializationStrategy::RetainedProofGraph => {
+                helicity_factors_equal(route.factor, [1.0, 0.0])
+            }
+        };
+        if route.materialized_current_id != expected_current_id
+            || route.external_label != mapping.external_label
+            || route.helicity != mapping.helicity
+            || route.chirality != mapping.chirality
+            || route.spin_state != mapping.spin_state
+            || route.declared_state_index != mapping.declared_state_index
+            || route.selector_domain_id != mapping.selector_domain_id
+            || !factor_matches
+        {
+            return Err(RusticolError::artifact(format!(
+                "helicity materialized source route for proof current {} is inconsistent",
+                mapping.current_id
+            )));
+        }
+        let source = schema
+            .sources
+            .get(&route.materialized_current_id)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "helicity materialized source route targets non-source current {}",
+                    route.materialized_current_id
+                ))
+            })?;
+        let declared_state = source
+            .declared_states
+            .get(route.declared_state_index)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "helicity materialized source route for current {} has stale declared state index {}",
+                    route.materialized_current_id, route.declared_state_index
+                ))
+            })?;
+        if source.external_label != route.external_label
+            || declared_state.helicity != route.helicity
+            || declared_state.chirality != route.chirality
+            || declared_state.spin_state != route.spin_state
+        {
+            return Err(RusticolError::artifact(format!(
+                "helicity materialized source route for current {} disagrees with SourceIR",
+                route.materialized_current_id
+            )));
+        }
+        if !route_keys.insert((
+            route.materialized_current_id,
+            route.selector_domain_id,
+            route.external_label,
+            route.helicity,
+            route.chirality,
+            route.declared_state_index,
+        )) {
+            return Err(RusticolError::artifact(
+                "helicity materialized source routes contain a duplicate physical state",
+            ));
+        }
+        routed_source_ids.insert(route.materialized_current_id);
+        runtime_routes.push(HelicityMaterializedSourceRouteRuntime {
+            materialized_current_id: route.materialized_current_id,
+            external_index: route.external_label - 1,
+            helicity: route.helicity,
+            chirality: route.chirality,
+            spin_state: route.spin_state.clone(),
+            declared_state_index: route.declared_state_index,
+            selector_domain_id: route.selector_domain_id,
+            factor: route.factor,
+        });
+    }
+    if routed_source_ids != schema.sources.keys().copied().collect() {
+        return Err(RusticolError::artifact(
+            "helicity materialized source routes do not cover every final runtime source",
+        ));
+    }
+    Ok(runtime_routes)
+}
+
+fn validate_helicity_materialized_amplitude_routes(
+    recurrence: &HelicityRecurrenceManifest,
+    materialization: &HelicityRecurrenceMaterializationManifest,
+    schema: &HelicityRecurrenceSchemaView,
+    complete_domains: &BTreeSet<usize>,
+    structural_zero_domains: &BTreeSet<usize>,
+    residual_current_targets: &BTreeSet<usize>,
+) -> RusticolResult<Vec<HelicityMaterializedAmplitudeRouteRuntime>> {
+    match materialization.strategy {
+        HelicityMaterializationStrategy::Quotient => validate_quotient_helicity_amplitude_routes(
+            recurrence,
+            materialization,
+            schema,
+            complete_domains,
+            structural_zero_domains,
+            residual_current_targets,
+        ),
+        HelicityMaterializationStrategy::RetainedProofGraph => {
+            validate_retained_helicity_amplitude_routes(
+                recurrence,
+                materialization,
+                schema,
+                complete_domains,
+                structural_zero_domains,
+                residual_current_targets,
+            )
+        }
+    }
+}
+
+fn validate_quotient_helicity_amplitude_routes(
+    recurrence: &HelicityRecurrenceManifest,
+    materialization: &HelicityRecurrenceMaterializationManifest,
+    schema: &HelicityRecurrenceSchemaView,
+    complete_domains: &BTreeSet<usize>,
+    structural_zero_domains: &BTreeSet<usize>,
+    residual_current_targets: &BTreeSet<usize>,
+) -> RusticolResult<Vec<HelicityMaterializedAmplitudeRouteRuntime>> {
+    let expected_root_count = recurrence
+        .amplitude_classes
+        .len()
+        .checked_add(recurrence.residual_root_ids.len())
+        .ok_or_else(|| {
+            RusticolError::artifact("helicity materialized root count overflows usize")
+        })?;
+    let expected_route_count = recurrence
+        .amplitude_classes
+        .iter()
+        .map(|class| class.members.len())
+        .sum::<usize>()
+        .checked_add(recurrence.residual_root_ids.len())
+        .ok_or_else(|| {
+            RusticolError::artifact("helicity materialized route count overflows usize")
+        })?;
+    if materialization.materialized_root_count != expected_root_count
+        || materialization.amplitude_routes.len() != expected_route_count
+    {
+        return Err(RusticolError::artifact(
+            "helicity materialized amplitude routes do not match proof class and residual coverage",
+        ));
+    }
+    let mut output_indices = BTreeSet::new();
+    for (root_id, root) in schema.roots.iter().enumerate() {
+        if root.left_current_id >= schema.currents.len()
+            || root.right_current_id >= schema.currents.len()
+            || root.output_index >= schema.roots.len()
+            || !output_indices.insert(root.output_index)
+            || !root.helicity_weight.is_finite()
+            || (root.helicity_weight - 1.0).abs() > 1.0e-12
+        {
+            return Err(RusticolError::artifact(format!(
+                "helicity materialized amplitude root {root_id} is inconsistent with the final runtime schema"
+            )));
+        }
+    }
+
+    let mut runtime_routes = Vec::with_capacity(expected_route_count);
+    let mut route_index = 0;
+    let mut represented_domains = BTreeSet::new();
+    for (materialized_root_id, class) in recurrence.amplitude_classes.iter().enumerate() {
+        let representative_factor = class
+            .members
+            .iter()
+            .find(|member| member.root_id == class.representative_root_id)
+            .map(|member| member.factor)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "helicity amplitude class {:?} has no representative factor",
+                    class.class_id
+                ))
+            })?;
+        let root = &schema.roots[materialized_root_id];
+        if residual_current_targets.contains(&root.left_current_id)
+            || residual_current_targets.contains(&root.right_current_id)
+        {
+            return Err(RusticolError::artifact(format!(
+                "proven helicity materialized amplitude root {materialized_root_id} depends on a residual current"
+            )));
+        }
+        for member in &class.members {
+            let route = &materialization.amplitude_routes[route_index];
+            validate_helicity_factor(
+                route.factor,
+                &format!("helicity materialized amplitude route {route_index}"),
+            )?;
+            validate_complete_selector_ids(
+                &route.selector_domain_ids,
+                recurrence,
+                &format!("helicity materialized amplitude route {route_index}"),
+            )?;
+            if route.materialized_root_id != materialized_root_id
+                || route.selector_domain_ids != member.selector_domain_ids
+                || route.residual
+                || !helicity_factor_ratio_matches(
+                    route.factor,
+                    member.factor,
+                    representative_factor,
+                )
+            {
+                return Err(RusticolError::artifact(format!(
+                    "helicity materialized amplitude route {route_index} disagrees with its proof member"
+                )));
+            }
+            represented_domains.extend(route.selector_domain_ids.iter().copied());
+            runtime_routes.push(HelicityMaterializedAmplitudeRouteRuntime {
+                materialized_root_id: route.materialized_root_id,
+                selector_domain_ids: route.selector_domain_ids.clone(),
+                factor: route.factor,
+                residual: false,
+            });
+            route_index += 1;
+        }
+    }
+    for residual_index in 0..recurrence.residual_root_ids.len() {
+        let route = &materialization.amplitude_routes[route_index];
+        let materialized_root_id = recurrence.amplitude_classes.len() + residual_index;
+        validate_complete_selector_ids(
+            &route.selector_domain_ids,
+            recurrence,
+            &format!("helicity residual materialized amplitude route {route_index}"),
+        )?;
+        if route.materialized_root_id != materialized_root_id
+            || route.selector_domain_ids.len() != 1
+            || !route.residual
+            || !helicity_factors_equal(route.factor, [1.0, 0.0])
+        {
+            return Err(RusticolError::artifact(format!(
+                "helicity residual materialized amplitude route {route_index} is inconsistent"
+            )));
+        }
+        represented_domains.extend(route.selector_domain_ids.iter().copied());
+        runtime_routes.push(HelicityMaterializedAmplitudeRouteRuntime {
+            materialized_root_id: route.materialized_root_id,
+            selector_domain_ids: route.selector_domain_ids.clone(),
+            factor: route.factor,
+            residual: true,
+        });
+        route_index += 1;
+    }
+    let expected_nonzero_domains = complete_domains
+        .difference(structural_zero_domains)
+        .copied()
+        .collect::<BTreeSet<_>>();
+    if represented_domains != expected_nonzero_domains {
+        return Err(RusticolError::artifact(
+            "helicity materialized amplitude routes do not cover exactly the nonzero complete selector domains",
+        ));
+    }
+    Ok(runtime_routes)
+}
+
+fn validate_retained_helicity_amplitude_routes(
+    recurrence: &HelicityRecurrenceManifest,
+    materialization: &HelicityRecurrenceMaterializationManifest,
+    schema: &HelicityRecurrenceSchemaView,
+    complete_domains: &BTreeSet<usize>,
+    structural_zero_domains: &BTreeSet<usize>,
+    residual_current_targets: &BTreeSet<usize>,
+) -> RusticolResult<Vec<HelicityMaterializedAmplitudeRouteRuntime>> {
+    if materialization.materialized_root_count != recurrence.amplitude_root_count
+        || materialization.amplitude_routes.len() != recurrence.amplitude_root_count
+    {
+        return Err(RusticolError::artifact(
+            "retained helicity amplitude routes must cover every proof root",
+        ));
+    }
+
+    let mut expected_routes = vec![None; recurrence.amplitude_root_count];
+    for class in &recurrence.amplitude_classes {
+        for member in &class.members {
+            if member.root_id >= expected_routes.len()
+                || expected_routes[member.root_id]
+                    .replace((member.selector_domain_ids.clone(), false))
+                    .is_some()
+            {
+                return Err(RusticolError::artifact(format!(
+                    "retained helicity amplitude root {} is covered more than once",
+                    member.root_id
+                )));
+            }
+        }
+    }
+    for root_id in &recurrence.residual_root_ids {
+        if *root_id >= expected_routes.len()
+            || expected_routes[*root_id]
+                .replace((Vec::new(), true))
+                .is_some()
+        {
+            return Err(RusticolError::artifact(format!(
+                "retained helicity residual root {root_id} overlaps another proof root"
+            )));
+        }
+    }
+    if expected_routes.iter().any(Option::is_none) {
+        return Err(RusticolError::artifact(
+            "retained helicity amplitude routes do not cover the proof root space",
+        ));
+    }
+
+    let mut output_indices = BTreeSet::new();
+    let mut represented_domains = BTreeSet::new();
+    let mut runtime_routes = Vec::with_capacity(materialization.amplitude_routes.len());
+    for (root_id, (root, route)) in schema
+        .roots
+        .iter()
+        .zip(&materialization.amplitude_routes)
+        .enumerate()
+    {
+        if root.left_current_id >= schema.currents.len()
+            || root.right_current_id >= schema.currents.len()
+            || root.output_index >= schema.roots.len()
+            || !output_indices.insert(root.output_index)
+            || !root.helicity_weight.is_finite()
+            || root.helicity_weight <= 0.0
+        {
+            return Err(RusticolError::artifact(format!(
+                "retained helicity amplitude root {root_id} is inconsistent with the final runtime schema"
+            )));
+        }
+        let (expected_domain_ids, residual) = expected_routes[root_id]
+            .as_ref()
+            .expect("retained root coverage checked above");
+        validate_complete_selector_ids(
+            &route.selector_domain_ids,
+            recurrence,
+            &format!("retained helicity amplitude route {root_id}"),
+        )?;
+        if route.materialized_root_id != root_id
+            || route.residual != *residual
+            || (!*residual
+                && route.selector_domain_ids.as_slice() != expected_domain_ids.as_slice())
+            || (*residual && route.selector_domain_ids.is_empty())
+            || !helicity_factors_equal(route.factor, [root.helicity_weight.sqrt().recip(), 0.0])
+        {
+            return Err(RusticolError::artifact(format!(
+                "retained helicity amplitude route {root_id} disagrees with its proof root"
+            )));
+        }
+        if !*residual
+            && (residual_current_targets.contains(&root.left_current_id)
+                || residual_current_targets.contains(&root.right_current_id))
+        {
+            return Err(RusticolError::artifact(format!(
+                "proven retained helicity amplitude root {root_id} depends on a residual current"
+            )));
+        }
+        represented_domains.extend(route.selector_domain_ids.iter().copied());
+        runtime_routes.push(HelicityMaterializedAmplitudeRouteRuntime {
+            materialized_root_id: root_id,
+            selector_domain_ids: route.selector_domain_ids.clone(),
+            factor: route.factor,
+            residual: *residual,
+        });
+    }
+    let expected_nonzero_domains = complete_domains
+        .difference(structural_zero_domains)
+        .copied()
+        .collect::<BTreeSet<_>>();
+    if represented_domains != expected_nonzero_domains {
+        return Err(RusticolError::artifact(
+            "retained helicity amplitude routes do not cover exactly the nonzero complete selector domains",
+        ));
+    }
+    Ok(runtime_routes)
+}
+
+fn validate_helicity_materialized_selector_schedules(
+    recurrence: &HelicityRecurrenceManifest,
+    materialization: &HelicityRecurrenceMaterializationManifest,
+    schema: &HelicityRecurrenceSchemaView,
+    complete_domains: &BTreeSet<usize>,
+    structural_zero_domains: &BTreeSet<usize>,
+) -> RusticolResult<Vec<HelicityMaterializedSelectorScheduleRuntime>> {
+    let expected_domain_ids = complete_domains.iter().copied().collect::<Vec<_>>();
+    if materialization.selector_schedules.len() != expected_domain_ids.len()
+        || materialization
+            .selector_schedules
+            .iter()
+            .map(|schedule| schedule.selector_domain_id)
+            .ne(expected_domain_ids.iter().copied())
+    {
+        return Err(RusticolError::artifact(
+            "helicity materialized selector schedules must cover complete domains in order",
+        ));
+    }
+    let chunks = schema.compiled_chunks.as_ref().ok_or_else(|| {
+        RusticolError::artifact(
+            "helicity materialized selector schedules require serialized stage evaluators",
+        )
+    })?;
+    let mut runtime_schedules = Vec::with_capacity(materialization.selector_schedules.len());
+    for schedule in &materialization.selector_schedules {
+        validate_sorted_unique_ids(
+            &schedule.active_current_ids,
+            schema.currents.len(),
+            &format!(
+                "helicity selector schedule {} active current ids",
+                schedule.selector_domain_id
+            ),
+        )?;
+        validate_sorted_unique_ids(
+            &schedule.active_root_ids,
+            schema.roots.len(),
+            &format!(
+                "helicity selector schedule {} active root ids",
+                schedule.selector_domain_id
+            ),
+        )?;
+        let structural_zero = structural_zero_domains.contains(&schedule.selector_domain_id);
+        if schedule.structural_zero != structural_zero
+            || (structural_zero
+                && (!schedule.active_current_ids.is_empty()
+                    || !schedule.active_root_ids.is_empty()))
+        {
+            return Err(RusticolError::artifact(format!(
+                "helicity selector schedule {} disagrees with structural-zero proof coverage",
+                schedule.selector_domain_id
+            )));
+        }
+        let expected_root_ids = materialization
+            .amplitude_routes
+            .iter()
+            .filter(|route| {
+                route
+                    .selector_domain_ids
+                    .contains(&schedule.selector_domain_id)
+            })
+            .map(|route| route.materialized_root_id)
+            .collect::<BTreeSet<_>>();
+        if expected_root_ids
+            != schedule
+                .active_root_ids
+                .iter()
+                .copied()
+                .collect::<BTreeSet<_>>()
+        {
+            return Err(RusticolError::artifact(format!(
+                "helicity selector schedule {} active roots disagree with amplitude routes",
+                schedule.selector_domain_id
+            )));
+        }
+        if !structural_zero && schedule.active_root_ids.is_empty() {
+            return Err(RusticolError::artifact(format!(
+                "helicity selector schedule {} has no active amplitude roots",
+                schedule.selector_domain_id
+            )));
+        }
+
+        let active_current_ids = schedule
+            .active_current_ids
+            .iter()
+            .copied()
+            .collect::<BTreeSet<_>>();
+        for root_id in &schedule.active_root_ids {
+            let root = &schema.roots[*root_id];
+            if !active_current_ids.contains(&root.left_current_id)
+                || !active_current_ids.contains(&root.right_current_id)
+            {
+                return Err(RusticolError::artifact(format!(
+                    "helicity selector schedule {} omits a parent of active root {root_id}",
+                    schedule.selector_domain_id
+                )));
+            }
+        }
+        if !structural_zero {
+            let domain = &recurrence.selector_domains[schedule.selector_domain_id];
+            let active_source_ids = active_current_ids
+                .iter()
+                .filter(|current_id| schema.currents[**current_id].is_source)
+                .copied()
+                .collect::<BTreeSet<_>>();
+            let active_source_labels = active_source_ids
+                .iter()
+                .map(|current_id| {
+                    schema
+                        .sources
+                        .get(current_id)
+                        .map(|source| source.external_label)
+                        .ok_or_else(|| {
+                            RusticolError::artifact(format!(
+                                "helicity selector schedule {} references source current {} without source metadata",
+                                schedule.selector_domain_id, current_id
+                            ))
+                        })
+                })
+                .collect::<RusticolResult<BTreeSet<_>>>()?;
+            let expected_source_labels = domain
+                .source_states
+                .iter()
+                .map(|state| state.external_label)
+                .collect::<BTreeSet<_>>();
+            if active_source_labels != expected_source_labels {
+                return Err(RusticolError::artifact(format!(
+                    "helicity selector schedule {} source-label coverage disagrees with its complete domain",
+                    schedule.selector_domain_id
+                )));
+            }
+        }
+
+        let mut covered_non_source_ids = BTreeSet::new();
+        let mut active_stage_chunk_indices = Vec::with_capacity(chunks.stages.len());
+        for stage in &chunks.stages {
+            let indices = stage
+                .current_ids_by_chunk
+                .iter()
+                .enumerate()
+                .filter_map(|(chunk_index, current_ids)| {
+                    current_ids
+                        .iter()
+                        .any(|current_id| active_current_ids.contains(current_id))
+                        .then_some(chunk_index)
+                })
+                .collect::<Vec<_>>();
+            for chunk_index in &indices {
+                covered_non_source_ids.extend(
+                    stage.current_ids_by_chunk[*chunk_index]
+                        .intersection(&active_current_ids)
+                        .copied()
+                        .filter(|current_id| !schema.currents[*current_id].is_source),
+                );
+            }
+            active_stage_chunk_indices.push(indices);
+        }
+        let required_non_source_ids = active_current_ids
+            .iter()
+            .copied()
+            .filter(|current_id| !schema.currents[*current_id].is_source)
+            .collect::<BTreeSet<_>>();
+        if covered_non_source_ids != required_non_source_ids {
+            let missing = required_non_source_ids
+                .difference(&covered_non_source_ids)
+                .copied()
+                .collect::<Vec<_>>();
+            return Err(RusticolError::artifact(format!(
+                "helicity selector schedule {} has active non-source currents without compiled stage output coverage: {missing:?}",
+                schedule.selector_domain_id
+            )));
+        }
+
+        let active_root_ids = schedule
+            .active_root_ids
+            .iter()
+            .copied()
+            .collect::<BTreeSet<_>>();
+        let active_amplitude_chunk_indices = chunks
+            .amplitude_root_ids_by_chunk
+            .iter()
+            .enumerate()
+            .filter_map(|(chunk_index, root_ids)| {
+                root_ids
+                    .iter()
+                    .any(|root_id| active_root_ids.contains(root_id))
+                    .then_some(chunk_index)
+            })
+            .collect::<Vec<_>>();
+        let covered_root_ids = active_amplitude_chunk_indices
+            .iter()
+            .flat_map(|chunk_index| {
+                chunks.amplitude_root_ids_by_chunk[*chunk_index]
+                    .intersection(&active_root_ids)
+                    .copied()
+            })
+            .collect::<BTreeSet<_>>();
+        if covered_root_ids != active_root_ids {
+            return Err(RusticolError::artifact(format!(
+                "helicity selector schedule {} has active roots without compiled amplitude output coverage",
+                schedule.selector_domain_id
+            )));
+        }
+        let current_is_source = schema
+            .currents
+            .iter()
+            .map(|current| current.is_source)
+            .collect::<Vec<_>>();
+        validate_compiled_selector_schedule_closure(
+            &format!("helicity selector schedule {}", schedule.selector_domain_id),
+            &current_is_source,
+            chunks,
+            &active_stage_chunk_indices,
+            &active_amplitude_chunk_indices,
+            Some(&active_current_ids),
+            Some(&active_root_ids),
+        )?;
+        runtime_schedules.push(HelicityMaterializedSelectorScheduleRuntime {
+            selector_domain_id: schedule.selector_domain_id,
+            active_current_ids: schedule.active_current_ids.clone(),
+            active_root_ids: schedule.active_root_ids.clone(),
+            active_stage_chunk_indices,
+            active_amplitude_chunk_indices,
+            structural_zero,
+        });
+    }
+    Ok(runtime_schedules)
+}
+
+fn validate_complete_selector_ids(
+    selector_domain_ids: &[usize],
+    recurrence: &HelicityRecurrenceManifest,
+    context: &str,
+) -> RusticolResult<()> {
+    if selector_domain_ids.is_empty()
+        || selector_domain_ids.iter().any(|domain_id| {
+            recurrence
+                .selector_domains
+                .get(*domain_id)
+                .is_none_or(|domain| !domain.complete)
+        })
+        || selector_domain_ids
+            .windows(2)
+            .any(|pair| pair[0] >= pair[1])
+    {
+        return Err(RusticolError::artifact(format!(
+            "{context} requires distinct ordered complete selector domains"
+        )));
+    }
+    Ok(())
+}
+
+fn helicity_factor_ratio_matches(
+    actual: [f64; 2],
+    numerator: [f64; 2],
+    denominator: [f64; 2],
+) -> bool {
+    let product = [
+        actual[0] * denominator[0] - actual[1] * denominator[1],
+        actual[0] * denominator[1] + actual[1] * denominator[0],
+    ];
+    product
+        .into_iter()
+        .zip(numerator)
+        .all(|(actual, expected)| {
+            let tolerance = 64.0 * f64::EPSILON * expected.abs().max(1.0);
+            (actual - expected).abs() <= tolerance
+        })
+}
+
+fn validate_helicity_recurrence_proof(
+    class_id: &str,
+    class_prefix: &str,
+    proof: &HelicityRecurrenceProofManifest,
+) -> RusticolResult<()> {
+    validate_sha256_digest(&proof.digest, class_id)?;
+    if proof.status != "proven"
+        || proof.algorithm != HELICITY_RECURRENCE_PROOF_ALGORITHM
+        || class_id != format!("{class_prefix}{}", proof.digest)
+        || proof
+            .transition_contract_ids
+            .iter()
+            .any(|contract| contract.is_empty())
+        || proof
+            .transition_contract_ids
+            .windows(2)
+            .any(|pair| pair[0] >= pair[1])
+    {
+        return Err(RusticolError::artifact(format!(
+            "helicity recurrence class {class_id:?} has invalid proof metadata"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_sha256_digest(digest: &str, context: &str) -> RusticolResult<()> {
+    if digest.len() != 64
+        || !digest
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+    {
+        return Err(RusticolError::artifact(format!(
+            "{context} requires a lowercase SHA-256 digest"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_helicity_external_labels(
+    labels: impl IntoIterator<Item = usize>,
+    external_count: usize,
+    context: &str,
+) -> RusticolResult<Vec<usize>> {
+    let labels = labels.into_iter().collect::<Vec<_>>();
+    if labels.is_empty()
+        || labels
+            .iter()
+            .any(|label| *label == 0 || *label > external_count)
+        || labels.windows(2).any(|pair| pair[0] >= pair[1])
+    {
+        return Err(RusticolError::artifact(format!(
+            "{context} contains invalid, duplicate, or unordered external labels"
+        )));
+    }
+    Ok(labels)
+}
+
+fn validate_sorted_unique_ids(
+    ids: &[usize],
+    upper_bound: usize,
+    context: &str,
+) -> RusticolResult<()> {
+    if ids.iter().any(|id| *id >= upper_bound) || ids.windows(2).any(|pair| pair[0] >= pair[1]) {
+        return Err(RusticolError::artifact(format!(
+            "{context} contain stale, duplicate, or unordered ids"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_helicity_factor(factor: [f64; 2], context: &str) -> RusticolResult<()> {
+    if !factor.iter().all(|component| component.is_finite()) || factor == [0.0, 0.0] {
+        return Err(RusticolError::artifact(format!(
+            "{context} has an invalid recurrence factor"
+        )));
+    }
+    Ok(())
+}
+
+fn helicity_factors_equal(left: [f64; 2], right: [f64; 2]) -> bool {
+    left.into_iter()
+        .zip(right)
+        .all(|(left, right)| left.to_bits() == right.to_bits())
+}
+
+fn build_runtime_parameter_slots(
+    parameters: &[GenericRuntimeModelParameterManifest],
+) -> RusticolResult<BTreeMap<String, RuntimeParameterSlots>> {
+    let mut direct = BTreeMap::new();
+    let mut complex_components: BTreeMap<String, (Option<usize>, Option<usize>)> = BTreeMap::new();
+    for parameter in parameters {
+        if parameter.kind == "derived_parameter_component" {
+            continue;
+        }
+        if let Some(runtime_name) = &parameter.runtime_name {
+            let slots = complex_components
+                .entry(runtime_name.clone())
+                .or_insert((None, None));
+            match parameter.complex_component.as_deref() {
+                Some("real") if slots.0.replace(parameter.parameter_index).is_none() => {}
+                Some("imag") if slots.1.replace(parameter.parameter_index).is_none() => {}
+                Some(component) => {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "runtime model parameter {runtime_name:?} has duplicate or invalid component {component:?}"
+                    )));
+                }
+                None => {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "runtime model parameter {runtime_name:?} is missing component metadata"
+                    )));
+                }
+            }
+        } else if direct
+            .insert(
+                parameter.name.clone(),
+                RuntimeParameterSlots {
+                    real: parameter.parameter_index,
+                    imaginary: None,
+                },
+            )
+            .is_some()
+        {
+            return Err(RusticolError::invalid_argument(format!(
+                "duplicate runtime model parameter name {:?}",
+                parameter.name
+            )));
+        }
+    }
+    for (name, (real, imaginary)) in complex_components {
+        let (Some(real), Some(imaginary)) = (real, imaginary) else {
+            return Err(RusticolError::invalid_argument(format!(
+                "runtime model parameter {name:?} requires real and imaginary slots"
+            )));
+        };
+        if direct
+            .insert(
+                name.clone(),
+                RuntimeParameterSlots {
+                    real,
+                    imaginary: Some(imaginary),
+                },
+            )
+            .is_some()
+        {
+            return Err(RusticolError::invalid_argument(format!(
+                "duplicate runtime model parameter name {name:?}"
+            )));
+        }
+    }
+    Ok(direct)
+}
+
+impl ExecutionRuntime {
+    pub(super) fn from_manifest(mut manifest: ExecutionManifest) -> RusticolResult<Self> {
+        validate_helicity_sum_execution(&manifest)?;
+        validate_helicity_selector_executions(&manifest)?;
+        validate_color_selector_executions(&manifest)?;
+        let helicity_sum_runtime = manifest
+            .helicity_sum_execution
+            .take()
+            .map(|sum_manifest| Self::from_manifest(*sum_manifest).map(Box::new))
+            .transpose()?;
+        let helicity_selector_manifests =
+            std::mem::take(&mut manifest.helicity_selector_executions);
+        let mut helicity_selector_runtimes = Vec::with_capacity(helicity_selector_manifests.len());
+        let mut helicity_selector_runtime_schedule_modes =
+            Vec::with_capacity(helicity_selector_manifests.len());
+        let mut helicity_selector_lane_by_domain = BTreeMap::new();
+        for record in helicity_selector_manifests {
+            let lane_index = helicity_selector_runtimes.len();
+            for selector_domain_id in record.selector_domain_ids {
+                helicity_selector_lane_by_domain.insert(selector_domain_id, lane_index);
+            }
+            helicity_selector_runtime_schedule_modes.push(record.schedule_mode);
+            helicity_selector_runtimes.push(Box::new(Self::from_manifest(*record.execution)?));
+        }
+        let color_selector_runtimes = manifest
+            .color_selector_executions
+            .drain(..)
+            .map(|record| {
+                Ok((
+                    record.materialized_sector_id,
+                    Box::new(Self::from_manifest(*record.execution)?),
+                ))
+            })
+            .collect::<RusticolResult<BTreeMap<_, _>>>()?;
+        let topology_replay = manifest.compiled.lc_topology_replay.as_ref();
+        let topology_replay_data = build_lc_topology_replay_data(topology_replay)?;
+        let color_topology_replay = manifest.compiled.color_topology_replay.as_ref();
+        let color_topology_replay_data =
+            build_color_topology_replay_data(color_topology_replay, &manifest.color_accuracy)?;
+        if !topology_replay_data.mappings.is_empty()
+            && !color_topology_replay_data.mappings.is_empty()
+        {
+            return Err(RusticolError::artifact(
+                "an artifact cannot enable LC and contracted-color topology replay together",
+            ));
+        }
+        let compiled_color_execution_plan = manifest
+            .compiled
+            .stage_evaluators
+            .as_ref()
+            .map(|evaluators| {
+                build_compiled_color_execution_plan(
+                    evaluators,
+                    &manifest.runtime_schema,
+                    &topology_replay_data.materialized_sector_ids,
+                )
+            })
+            .transpose()?
+            .flatten();
+        let topology_replay_mappings = topology_replay_data.mappings;
+        let topology_replay_public_mappings = topology_replay_mappings.clone();
+        let helicity_recurrence = build_helicity_recurrence_runtime(&manifest)?;
+        let external_is_initial = manifest
+            .runtime_schema
+            .external_particles
+            .iter()
+            .map(|particle| particle.role == "initial")
+            .collect::<Vec<_>>();
+        let particle_masses = manifest
+            .runtime_schema
+            .model
+            .as_ref()
+            .map(|model| {
+                model
+                    .particles
+                    .iter()
+                    .map(|particle| (particle.pdg, particle.mass))
+                    .collect::<BTreeMap<_, _>>()
+            })
+            .unwrap_or_default();
+        let particle_mass_parameter_names = manifest
+            .runtime_schema
+            .model
+            .as_ref()
+            .map(|model| {
+                model
+                    .particles
+                    .iter()
+                    .filter_map(|particle| {
+                        particle
+                            .mass_parameter
+                            .as_ref()
+                            .map(|name| (particle.pdg, name.clone()))
+                    })
+                    .collect::<BTreeMap<_, _>>()
+            })
+            .unwrap_or_default();
+        let mut model_parameters = manifest.runtime_schema.model_parameters.clone();
+        model_parameters.sort_by_key(|parameter| parameter.parameter_index);
+        let model_parameter_values_f64 = model_parameters
+            .iter()
+            .map(|parameter| parameter.default)
+            .collect::<Vec<_>>();
+        let model_parameter_name_to_index = model_parameters
+            .iter()
+            .map(|parameter| (parameter.name.clone(), parameter.parameter_index))
+            .collect::<BTreeMap<_, _>>();
+        let model_parameter_runtime_slots = build_runtime_parameter_slots(&model_parameters)?;
+        let color_factor_in_contraction = manifest
+            .runtime_schema
+            .amplitude_stage
+            .color_contraction
+            .as_ref()
+            .map(|contraction| contraction.supported && contraction.includes_color_factor)
+            .unwrap_or(false);
+        let (
+            normalization_factor,
+            normalization_color_factor,
+            normalization_average_factor,
+            normalization_identical_factor,
+            normalization_qcd_coupling_power,
+            normalization_electroweak_coupling_power,
+        ) = manifest
+            .runtime_schema
+            .normalization
+            .as_ref()
+            .map(|normalization| {
+                let color_factor = if color_factor_in_contraction {
+                    1.0
+                } else {
+                    normalization.color_factor
+                };
+                (
+                    color_factor * normalization.global_coupling_factor
+                        / (normalization.average_factor * normalization.identical_factor),
+                    color_factor,
+                    normalization.average_factor,
+                    normalization.identical_factor,
+                    normalization.qcd_coupling_power,
+                    normalization.electroweak_coupling_power,
+                )
+            })
+            .unwrap_or((1.0, 1.0, 1.0, 1.0, 0, 0));
+        Ok(Self {
+            process: manifest.process,
+            key: manifest.key,
+            color_accuracy: manifest.color_accuracy,
+            external_count: manifest.external_pdg_order.len(),
+            external_pdg_order: manifest.external_pdg_order,
+            parameter_count: manifest
+                .runtime_schema
+                .parameter_layout
+                .value_component_count
+                + manifest
+                    .runtime_schema
+                    .parameter_layout
+                    .momentum_parameter_count
+                + manifest
+                    .runtime_schema
+                    .parameter_layout
+                    .model_parameter_count,
+            value_parameter_count: manifest
+                .runtime_schema
+                .parameter_layout
+                .value_component_count,
+            momentum_parameter_count: manifest
+                .runtime_schema
+                .parameter_layout
+                .momentum_parameter_count,
+            current_count: manifest.dag_summary.current_count,
+            source_count: manifest.dag_summary.source_count,
+            interaction_count: manifest.dag_summary.interaction_count,
+            stage_count: manifest.runtime_schema.stages.len(),
+            amplitude_output_count: manifest.runtime_schema.amplitude_stage.output_count,
+            lc_topology_replay_enabled: !topology_replay_mappings.is_empty(),
+            lc_topology_replay_mappings: Arc::new(topology_replay_mappings),
+            lc_topology_replay_public_mappings: topology_replay_public_mappings,
+            lc_topology_replay_routes: topology_replay_data.routes,
+            lc_topology_replay_materialized_sector_ids: topology_replay_data
+                .materialized_sector_ids,
+            lc_resolved_replay_plan: None,
+            lc_resolved_replay_selection_cache: None,
+            lc_replay_flat_momenta_scratch: Vec::new(),
+            lc_replay_target_components_scratch: Vec::new(),
+            color_topology_replay_enabled: !color_topology_replay_data.mappings.is_empty(),
+            color_topology_replay_mappings: Arc::new(color_topology_replay_data.mappings),
+            color_replay_flat_momenta_scratch: Vec::new(),
+            helicity_recurrence,
+            compiled_helicity_execution_plan: None,
+            compiled_color_execution_plan,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            compiled_direct_runtime: None,
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            compiled_direct_color_schedules: BTreeMap::new(),
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            compiled_direct_helicity_schedules: BTreeMap::new(),
+            helicity_sum_runtime,
+            helicity_selector_runtimes,
+            helicity_selector_runtime_schedule_modes,
+            helicity_selector_lane_by_domain,
+            color_selector_runtimes,
+            runtime_unavailable_message: manifest.compiled.runtime_unavailable_message,
+            sources: manifest.runtime_schema.source_fill.sources,
+            momentum_slots: manifest.runtime_schema.momentum_slots,
+            external_is_initial,
+            particle_masses,
+            particle_mass_parameter_names,
+            normalization_factor,
+            normalization_color_factor,
+            normalization_average_factor,
+            normalization_identical_factor,
+            normalization_qcd_coupling_power,
+            normalization_electroweak_coupling_power,
+            model_parameters,
+            model_parameter_name_to_index,
+            model_parameter_runtime_slots,
+            model_parameter_values_f64,
+            model_parameter_evaluator: None,
+            physics_reduction_override: manifest.physics_reduction,
+            physics: None,
+            stages: None,
+            amplitude_stage: None,
+            state_scratch_f64: Vec::new(),
+            state_scratch_f64_requires_clear: false,
+            values_scratch_f64: Vec::new(),
+        })
+    }
+
+    fn compiled_direct_routed_reduction_footprint(
+        &self,
+        amplitude: &AmplitudeRuntime,
+        physics: &PhysicsRuntime,
+    ) -> RusticolResult<CompiledDirectRoutedReductionFootprint> {
+        if !self.lc_topology_replay_enabled {
+            return Ok(CompiledDirectRoutedReductionFootprint::default());
+        }
+        let materialized_sector_by_id =
+            self.lc_materialized_sectors_by_id_from_groups(physics, &amplitude.raw_sum_groups)?;
+        let replay_plan = physics.lc_resolved_replay_plan(
+            &self.lc_topology_replay_public_mappings,
+            &self.lc_topology_replay_routes,
+            &materialized_sector_by_id,
+        )?;
+        let selection_key = physics.lc_resolved_replay_selection_key(None, None)?;
+        let selection =
+            physics.select_lc_resolved_replay_plan_for_key(&replay_plan, &selection_key)?;
+        let maximum_source_component_count = selection
+            .source_groups
+            .iter()
+            .map(|group| group.source_component_count)
+            .max()
+            .ok_or_else(|| {
+                RusticolError::artifact(
+                    "enabled LC topology replay has no authenticated source group",
+                )
+            })?;
+        let maximum_target_component_count = selection
+            .helicity_indices
+            .len()
+            .checked_mul(selection.color_indices.len())
+            .filter(|count| *count != 0)
+            .ok_or_else(|| {
+                RusticolError::artifact(
+                    "enabled LC topology replay has no authenticated target components",
+                )
+            })?;
+        Ok(CompiledDirectRoutedReductionFootprint {
+            maximum_source_component_count,
+            maximum_target_component_count,
+        })
+    }
+
+    pub(super) fn load_from_manifest_with_store(
+        manifest: ExecutionManifest,
+        payloads: &EvaluatorPayloadStore,
+        sizing_physics: &PhysicsRuntime,
+    ) -> RusticolResult<Self> {
+        Self::load_from_manifest_with_store_and_replay_footprint(
+            manifest,
+            payloads,
+            Some(CompiledDirectRoutedReductionFootprint::default()),
+            sizing_physics,
+        )
+    }
+
+    fn load_from_manifest_with_store_and_replay_footprint(
+        mut manifest: ExecutionManifest,
+        payloads: &EvaluatorPayloadStore,
+        inherited_routed_footprint: Option<CompiledDirectRoutedReductionFootprint>,
+        inherited_sizing_physics: &PhysicsRuntime,
+    ) -> RusticolResult<Self> {
+        validate_helicity_sum_execution(&manifest)?;
+        validate_helicity_selector_executions(&manifest)?;
+        validate_color_selector_executions(&manifest)?;
+        let compiled_plane_arena = validate_compiled_plane_arena_contract(&manifest)?;
+        let compiled_momentum_slot_ids = manifest.compiled.momentum_slot_ids.take();
+        ensure_execution_capabilities_supported(&manifest)?;
+        let helicity_sum_manifest = manifest.helicity_sum_execution.take();
+        let helicity_selector_manifests =
+            std::mem::take(&mut manifest.helicity_selector_executions);
+        let color_selector_manifests = std::mem::take(&mut manifest.color_selector_executions);
+        let compiled_color_payload = manifest.color_contraction_payload.take();
+        let (stage_evaluators, helicity_recurrence) =
+            detach_compiled_helicity_load_inputs(&mut manifest)?;
+        let model_parameter_evaluator = manifest.compiled.model_parameter_evaluator.take();
+        let replay_materialized_sector_ids =
+            build_lc_topology_replay_data(manifest.compiled.lc_topology_replay.as_ref())?
+                .materialized_sector_ids;
+        let compiled_color_execution_plan = stage_evaluators
+            .as_ref()
+            .map(|evaluators| {
+                build_compiled_color_execution_plan(
+                    evaluators,
+                    &manifest.runtime_schema,
+                    &replay_materialized_sector_ids,
+                )
+            })
+            .transpose()?
+            .flatten();
+        drop(replay_materialized_sector_ids);
+        let amplitude_stage_manifest = manifest.runtime_schema.amplitude_stage.clone();
+        let mut runtime = Self::from_manifest(manifest)?;
+        if compiled_plane_arena {
+            // These ids were selected at generation and checked alongside
+            // the final leaf bindings above. Loading only binds that list;
+            // it does not rediscover which momentum sums are live.
+            runtime.momentum_slots = compiled_momentum_slot_ids
+                .expect("validated compiled momentum-slot selection")
+                .into_iter()
+                .map(|id| runtime.momentum_slots[id].clone())
+                .collect();
+        }
+        runtime.helicity_recurrence = helicity_recurrence;
+        runtime.compiled_color_execution_plan = compiled_color_execution_plan;
+        let sizing_physics = if let Some(reduction) = runtime.physics_reduction_override.as_ref() {
+            let mut manifest = inherited_sizing_physics.manifest.clone();
+            manifest.reduction = reduction.clone();
+            PhysicsRuntime::new(manifest)?
+        } else {
+            inherited_sizing_physics.clone()
+        };
+        let mut compiled_color_contraction = load_compiled_symmetric_group_color_contraction(
+            compiled_color_payload.as_ref(),
+            payloads,
+            &sizing_physics,
+        )?;
+        let routed_footprint = if runtime.lc_topology_replay_enabled {
+            if let Some(stage_evaluators) = stage_evaluators.as_ref() {
+                let sizing_amplitude = AmplitudeRuntime::load_reducer_only(
+                    &amplitude_stage_manifest,
+                    &stage_evaluators.amplitude_stage,
+                )?;
+                let own = runtime.compiled_direct_routed_reduction_footprint(
+                    &sizing_amplitude,
+                    &sizing_physics,
+                )?;
+                inherited_routed_footprint.map(|inherited| inherited.merge(own))
+            } else {
+                // The replay may route into a nested Direct engine, but this
+                // legacy parent exposes no amplitude metadata from which to
+                // authenticate its source/target shape.
+                None
+            }
+        } else {
+            inherited_routed_footprint
+        };
+        runtime.helicity_sum_runtime = helicity_sum_manifest
+            .map(|sum_manifest| {
+                Self::load_from_manifest_with_store_and_replay_footprint(
+                    *sum_manifest,
+                    payloads,
+                    routed_footprint,
+                    &sizing_physics,
+                )
+                .map(Box::new)
+            })
+            .transpose()?;
+        runtime.helicity_selector_runtimes = Vec::with_capacity(helicity_selector_manifests.len());
+        runtime.helicity_selector_runtime_schedule_modes =
+            Vec::with_capacity(helicity_selector_manifests.len());
+        runtime.helicity_selector_lane_by_domain.clear();
+        for record in helicity_selector_manifests {
+            let lane_index = runtime.helicity_selector_runtimes.len();
+            for selector_domain_id in record.selector_domain_ids {
+                runtime
+                    .helicity_selector_lane_by_domain
+                    .insert(selector_domain_id, lane_index);
+            }
+            runtime
+                .helicity_selector_runtime_schedule_modes
+                .push(record.schedule_mode);
+            runtime.helicity_selector_runtimes.push(Box::new(
+                Self::load_from_manifest_with_store_and_replay_footprint(
+                    *record.execution,
+                    payloads,
+                    routed_footprint,
+                    &sizing_physics,
+                )?,
+            ));
+        }
+        runtime.color_selector_runtimes = color_selector_manifests
+            .into_iter()
+            .map(|record| {
+                Ok((
+                    record.materialized_sector_id,
+                    Box::new(Self::load_from_manifest_with_store_and_replay_footprint(
+                        *record.execution,
+                        payloads,
+                        routed_footprint,
+                        &sizing_physics,
+                    )?),
+                ))
+            })
+            .collect::<RusticolResult<BTreeMap<_, _>>>()?;
+        if let Some(manifest) = model_parameter_evaluator {
+            if manifest.kind != "generic-model-parameter-evaluator" {
+                return Err(RusticolError::invalid_argument(format!(
+                    "unsupported model-parameter evaluator kind {:?}",
+                    manifest.kind
+                )));
+            }
+            runtime.model_parameter_evaluator = Some(ModelParameterEvaluatorRuntime {
+                input_parameter_indices: manifest.input_parameter_indices,
+                outputs: manifest.outputs,
+                evaluator: EvaluatorGroup::load_from_store(&manifest.evaluator, payloads)?,
+            });
+            runtime.refresh_derived_model_parameters()?;
+        }
+        if let Some(stage_evaluators) = stage_evaluators {
+            #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+            if compiled_plane_arena {
+                #[cfg(feature = "symbolica-runtime")]
+                let (stages, mut amplitude) = match compiled_color_contraction.take() {
+                    Some(color) => (
+                        Vec::new(),
+                        AmplitudeRuntime::load_reducer_only_with_compiled_color(
+                            &amplitude_stage_manifest,
+                            &stage_evaluators.amplitude_stage,
+                            Some(color),
+                        )?,
+                    ),
+                    None => {
+                        // Preserve the public exact-precision API for ordinary
+                        // compiled artifacts without instantiating a second f64
+                        // evaluator representation. The selected-helicity SG
+                        // diagnostic rejects exact execution and therefore uses
+                        // only the reducer construction above.
+                        (
+                            stage_evaluators
+                                .stages
+                                .iter()
+                                .map(|stage| StageRuntime::load_exact_from_plane(stage, payloads))
+                                .collect::<RusticolResult<Vec<_>>>()?,
+                            AmplitudeRuntime::load_exact_from_plane(
+                                &amplitude_stage_manifest,
+                                &stage_evaluators.amplitude_stage,
+                                payloads,
+                            )?,
+                        )
+                    }
+                };
+                #[cfg(not(feature = "symbolica-runtime"))]
+                let (stages, mut amplitude) = (
+                    Vec::new(),
+                    match compiled_color_contraction.take() {
+                        Some(color) => AmplitudeRuntime::load_reducer_only_with_compiled_color(
+                            &amplitude_stage_manifest,
+                            &stage_evaluators.amplitude_stage,
+                            Some(color),
+                        )?,
+                        None => AmplitudeRuntime::load_reducer_only(
+                            &amplitude_stage_manifest,
+                            &stage_evaluators.amplitude_stage,
+                        )?,
+                    },
+                );
+                let maximum_resolved_component_count = sizing_physics
+                    .manifest
+                    .helicities
+                    .len()
+                    .checked_mul(sizing_physics.manifest.color_components.len())
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "compiled Direct-Arena resolved footprint overflows",
+                        )
+                    })?;
+                let reduction_footprint = if let Some(routed_footprint) = routed_footprint {
+                    amplitude.compiled_direct_reduction_footprint(
+                        maximum_resolved_component_count,
+                        routed_footprint,
+                    )?
+                } else {
+                    CompiledDirectReductionFootprint::Unauthenticated
+                };
+                let direct =
+                    compiled_direct_prototype::CompiledDirectEnginePrototype::load_production(
+                        &stage_evaluators.stages,
+                        &stage_evaluators.amplitude_stage,
+                        payloads,
+                        &runtime.sources,
+                        runtime.value_parameter_count,
+                        runtime.momentum_parameter_count,
+                        runtime.model_parameter_values_f64.len(),
+                        stage_evaluators.amplitude_stage.output_length,
+                        reduction_footprint,
+                    )?;
+                amplitude
+                    .prepare_compiled_symmetric_group_workspace(direct.reduction_tile_capacity())?;
+                runtime.stages = Some(stages);
+                runtime.amplitude_stage = Some(amplitude);
+                let mut color_schedules = BTreeMap::new();
+                if let Some(color_plan) = runtime.compiled_color_execution_plan.as_ref() {
+                    for (sector_id, schedule) in &color_plan.schedules_by_materialized_sector {
+                        color_schedules
+                            .insert(*sector_id, direct.bind_color_schedule(schedule.as_ref())?);
+                    }
+                }
+                runtime.compiled_direct_color_schedules = color_schedules;
+                runtime.compiled_direct_runtime = Some(direct);
+            } else {
+                if compiled_color_contraction.is_some() {
+                    return Err(RusticolError::compatibility(
+                        "compiled symmetric-group FFT diagnostic requires compiled-plane-arena-v1",
+                    ));
+                }
+                let stages = stage_evaluators
+                    .stages
+                    .iter()
+                    .map(|stage| StageRuntime::load(stage, payloads))
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                runtime.stages = Some(stages);
+                runtime.amplitude_stage = Some(AmplitudeRuntime::load(
+                    &amplitude_stage_manifest,
+                    &stage_evaluators.amplitude_stage,
+                    payloads,
+                )?);
+            }
+            #[cfg(not(any(feature = "f64-compiled", feature = "f64-symjit")))]
+            {
+                if compiled_plane_arena {
+                    return Err(RusticolError::unsupported_runtime_capability(
+                        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+                        "this Rusticol build has no compiled DirectApplication backend",
+                    ));
+                }
+                let stages = stage_evaluators
+                    .stages
+                    .iter()
+                    .map(|stage| StageRuntime::load(stage, payloads))
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                runtime.stages = Some(stages);
+                runtime.amplitude_stage = Some(AmplitudeRuntime::load(
+                    &amplitude_stage_manifest,
+                    &stage_evaluators.amplitude_stage,
+                    payloads,
+                )?);
+            }
+        }
+        runtime.validate_color_topology_replay_amplitude()?;
+        Ok(runtime)
+    }
+
+    fn validate_color_topology_replay_amplitude(&self) -> RusticolResult<()> {
+        if !self.color_topology_replay_enabled {
+            if self
+                .amplitude_stage
+                .as_ref()
+                .and_then(|amplitude| amplitude.color_topology_replay.as_ref())
+                .is_some()
+            {
+                return Err(RusticolError::artifact(
+                    "amplitude color replay is present without its proof certificate",
+                ));
+            }
+            return Ok(());
+        }
+        let amplitude = self.amplitude_stage.as_ref().ok_or_else(|| {
+            RusticolError::artifact("color topology replay proof has no executable amplitude stage")
+        })?;
+        let amplitude_mappings = amplitude.color_topology_replay_mappings().ok_or_else(|| {
+            RusticolError::artifact("color topology replay proof has no amplitude-level gather")
+        })?;
+        if amplitude_mappings.as_slice() != self.color_topology_replay_mappings.as_slice() {
+            return Err(RusticolError::artifact(
+                "color topology replay proof and amplitude gather mappings disagree",
+            ));
+        }
+        Ok(())
+    }
+
+    pub(super) fn execution_unavailable_error(&self) -> RusticolError {
+        if self.stages.is_none() || self.amplitude_stage.is_none() {
+            return RusticolError::invalid_argument(format!(
+                "generic DAG schema-v3 artifact for {} loaded successfully, but it has no \
+                 serialized generic stage evaluators",
+                self.process
+            ));
+        }
+        let detail = self.runtime_unavailable_message.as_deref().unwrap_or(
+            "generic source filling and staged evaluator execution from schema-v3 metadata remain pending",
+        );
+        RusticolError::invalid_argument(format!(
+            "generic DAG schema-v3 artifact for {} loaded successfully, but generic Rusticol \
+             execution is not wired yet; {detail}",
+            self.process,
+        ))
+    }
+}
+
+fn validate_helicity_sum_execution(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let Some(sum_manifest) = manifest.helicity_sum_execution.as_deref() else {
+        return Ok(());
+    };
+    if sum_manifest.helicity_sum_execution.is_some()
+        || !sum_manifest.helicity_selector_executions.is_empty()
+    {
+        return Err(RusticolError::integrity(
+            "compiled helicity-sum execution cannot contain another auxiliary execution",
+        ));
+    }
+    if sum_manifest.physics_reduction.is_none() {
+        return Err(RusticolError::integrity(
+            "compiled helicity-sum execution has no reduction override",
+        ));
+    }
+    if sum_manifest
+        .runtime_schema
+        .helicity_recurrence
+        .as_ref()
+        .is_some_and(|recurrence| recurrence.materialization.is_some())
+    {
+        return Err(RusticolError::integrity(
+            "compiled helicity-sum execution cannot contain helicity materialization",
+        ));
+    }
+    if sum_manifest.process != manifest.process
+        || sum_manifest.key != manifest.key
+        || sum_manifest.color_accuracy != manifest.color_accuracy
+        || sum_manifest.external_pdg_order != manifest.external_pdg_order
+    {
+        return Err(RusticolError::integrity(
+            "compiled helicity-sum execution does not match its primary process contract",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_helicity_selector_executions(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    if manifest.helicity_selector_executions.is_empty() {
+        return Ok(());
+    }
+    let recurrence = manifest
+        .runtime_schema
+        .helicity_recurrence
+        .as_ref()
+        .filter(|recurrence| recurrence.materialization.is_some())
+        .ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled helicity-selector executions require primary helicity materialization",
+            )
+        })?;
+    let mut assigned_domains = BTreeSet::new();
+    for (lane_index, record) in manifest.helicity_selector_executions.iter().enumerate() {
+        if record.selector_domain_ids.is_empty() {
+            return Err(RusticolError::integrity(format!(
+                "compiled helicity-selector execution {lane_index} has no selector domains"
+            )));
+        }
+        for selector_domain_id in &record.selector_domain_ids {
+            let domain = recurrence
+                .selector_domains
+                .get(*selector_domain_id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "compiled helicity-selector execution {lane_index} references unknown selector domain {selector_domain_id}"
+                    ))
+                })?;
+            if domain.id != *selector_domain_id || !domain.complete {
+                return Err(RusticolError::integrity(format!(
+                    "compiled helicity-selector execution {lane_index} references incomplete selector domain {selector_domain_id}"
+                )));
+            }
+            if !assigned_domains.insert(*selector_domain_id) {
+                return Err(RusticolError::integrity(format!(
+                    "compiled helicity-selector executions contain duplicate selector domain {selector_domain_id}"
+                )));
+            }
+        }
+
+        let selector_manifest = record.execution.as_ref();
+        if selector_manifest.helicity_sum_execution.is_some()
+            || !selector_manifest.color_selector_executions.is_empty()
+        {
+            return Err(RusticolError::integrity(
+                "compiled helicity-selector execution cannot contain a helicity-sum or color-selector auxiliary execution",
+            ));
+        }
+        if !selector_manifest.helicity_selector_executions.is_empty()
+            && record.schedule_mode != HelicitySelectorScheduleMode::NestedRuntime
+        {
+            return Err(RusticolError::integrity(
+                "only a nested-runtime helicity-selector execution may contain closure lanes",
+            ));
+        }
+        if selector_manifest.physics_reduction.is_none() {
+            return Err(RusticolError::integrity(
+                "compiled helicity-selector execution has no reduction override",
+            ));
+        }
+        if selector_manifest.process != manifest.process
+            || selector_manifest.key != manifest.key
+            || selector_manifest.color_accuracy != manifest.color_accuracy
+            || selector_manifest.external_pdg_order != manifest.external_pdg_order
+        {
+            return Err(RusticolError::integrity(
+                "compiled helicity-selector execution does not match its primary process contract",
+            ));
+        }
+        match record.schedule_mode {
+            HelicitySelectorScheduleMode::ParentClosure => {
+                if selector_manifest.compiled.lc_topology_replay.is_some()
+                    || selector_manifest.compiled.color_topology_replay.is_some()
+                    || selector_manifest
+                        .runtime_schema
+                        .amplitude_stage
+                        .color_topology_replay
+                        .is_some()
+                {
+                    return Err(RusticolError::integrity(
+                        "parent-closure helicity-selector execution cannot own colour-topology replay",
+                    ));
+                }
+                if selector_manifest
+                    .runtime_schema
+                    .helicity_recurrence
+                    .as_ref()
+                    .is_some_and(|lane_recurrence| lane_recurrence.materialization.is_some())
+                {
+                    return Err(RusticolError::integrity(
+                        "parent-closure helicity-selector execution cannot contain helicity materialization",
+                    ));
+                }
+                let primary_layout = &manifest.runtime_schema.parameter_layout;
+                let selector_layout = &selector_manifest.runtime_schema.parameter_layout;
+                if primary_layout.source_component_parameter_count
+                    != selector_layout.source_component_parameter_count
+                    || primary_layout.value_component_count != selector_layout.value_component_count
+                    || primary_layout.momentum_parameter_count
+                        != selector_layout.momentum_parameter_count
+                    || primary_layout.model_parameter_count != selector_layout.model_parameter_count
+                    || primary_layout.parameter_count_if_flattened
+                        != selector_layout.parameter_count_if_flattened
+                    || primary_layout.source_components_complex
+                        != selector_layout.source_components_complex
+                    || primary_layout.momentum_components_real
+                        != selector_layout.momentum_components_real
+                    || primary_layout.real_valued_inputs != selector_layout.real_valued_inputs
+                    || manifest.runtime_schema.current_storage.component_count
+                        != selector_manifest
+                            .runtime_schema
+                            .current_storage
+                            .component_count
+                    || manifest.runtime_schema.value_storage.component_count
+                        != selector_manifest
+                            .runtime_schema
+                            .value_storage
+                            .component_count
+                    || manifest.runtime_schema.stages.len()
+                        != selector_manifest.runtime_schema.stages.len()
+                    || manifest.runtime_schema.amplitude_stage.output_count
+                        != selector_manifest
+                            .runtime_schema
+                            .amplitude_stage
+                            .output_count
+                {
+                    return Err(RusticolError::integrity(
+                        "parent-closure helicity-selector execution layout does not match its primary execution",
+                    ));
+                }
+            }
+            HelicitySelectorScheduleMode::NestedRuntime => {
+                let selector_recurrence = selector_manifest
+                    .runtime_schema
+                    .helicity_recurrence
+                    .as_ref()
+                    .filter(|lane_recurrence| lane_recurrence.materialization.is_some())
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "nested-runtime helicity-selector execution requires helicity materialization",
+                        )
+                    })?;
+                let selector_materialization = selector_recurrence
+                    .materialization
+                    .as_ref()
+                    .expect("nested-runtime materialization checked");
+                let selector_schedule_domains = selector_materialization
+                    .selector_schedules
+                    .iter()
+                    .map(|schedule| schedule.selector_domain_id)
+                    .collect::<BTreeSet<_>>();
+                let primary_complete_domains = recurrence
+                    .selector_domains
+                    .iter()
+                    .filter(|domain| domain.complete)
+                    .map(|domain| domain.source_states.clone())
+                    .collect::<BTreeSet<_>>();
+                let nested_complete_domains = selector_recurrence
+                    .selector_domains
+                    .iter()
+                    .filter(|domain| domain.complete)
+                    .map(|domain| domain.source_states.clone())
+                    .collect::<BTreeSet<_>>();
+                if nested_complete_domains != primary_complete_domains {
+                    return Err(RusticolError::integrity(format!(
+                        "nested-runtime helicity-selector execution {lane_index} disagrees with the primary complete-helicity domain contract"
+                    )));
+                }
+                let primary_structural_zeros = recurrence
+                    .structural_zero_selector_domain_ids
+                    .iter()
+                    .map(|domain_id| {
+                        recurrence.selector_domains[*domain_id]
+                            .source_states
+                            .clone()
+                    })
+                    .collect::<BTreeSet<_>>();
+                let nested_structural_zeros = selector_recurrence
+                    .structural_zero_selector_domain_ids
+                    .iter()
+                    .map(|domain_id| {
+                        selector_recurrence.selector_domains[*domain_id]
+                            .source_states
+                            .clone()
+                    })
+                    .collect::<BTreeSet<_>>();
+                if nested_structural_zeros != primary_structural_zeros {
+                    return Err(RusticolError::integrity(format!(
+                        "nested-runtime helicity-selector execution {lane_index} disagrees with the primary structural-zero domain contract"
+                    )));
+                }
+                for selector_domain_id in &record.selector_domain_ids {
+                    let primary_domain = &recurrence.selector_domains[*selector_domain_id];
+                    let nested_domain = selector_recurrence
+                        .selector_domains
+                        .iter()
+                        .find(|domain| {
+                            domain.complete && domain.source_states == primary_domain.source_states
+                        })
+                        .ok_or_else(|| {
+                            RusticolError::integrity(format!(
+                                "nested-runtime helicity-selector execution {lane_index} omits selector domain {selector_domain_id}"
+                            ))
+                        })?;
+                    if !selector_schedule_domains.contains(&nested_domain.id) {
+                        return Err(RusticolError::integrity(format!(
+                            "nested-runtime helicity-selector execution {lane_index} has no materialized schedule for selector domain {selector_domain_id}"
+                        )));
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_color_selector_executions(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let mut sector_ids = BTreeSet::new();
+    for record in &manifest.color_selector_executions {
+        if !sector_ids.insert(record.materialized_sector_id) {
+            return Err(RusticolError::integrity(format!(
+                "compiled color-selector executions contain duplicate materialized sector {}",
+                record.materialized_sector_id
+            )));
+        }
+        let lane = record.execution.as_ref();
+        if lane.helicity_sum_execution.is_some()
+            || !lane.helicity_selector_executions.is_empty()
+            || !lane.color_selector_executions.is_empty()
+        {
+            return Err(RusticolError::integrity(
+                "compiled color-selector execution cannot contain auxiliary executions",
+            ));
+        }
+        if lane.physics_reduction.is_none() {
+            return Err(RusticolError::integrity(
+                "compiled color-selector execution has no reduction override",
+            ));
+        }
+        if lane.process != manifest.process
+            || lane.key != manifest.key
+            || lane.color_accuracy != manifest.color_accuracy
+            || lane.external_pdg_order != manifest.external_pdg_order
+        {
+            return Err(RusticolError::integrity(
+                "compiled color-selector execution does not match its primary process contract",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn ensure_execution_capabilities_supported(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let has_helicity_sum_execution = manifest.helicity_sum_execution.is_some();
+    let has_helicity_selector_executions = !manifest.helicity_selector_executions.is_empty();
+    let has_color_selector_executions = !manifest.color_selector_executions.is_empty();
+    if let Some(sum_manifest) = manifest.helicity_sum_execution.as_deref() {
+        ensure_execution_capabilities_supported(sum_manifest)?;
+    }
+    for record in &manifest.helicity_selector_executions {
+        ensure_execution_capabilities_supported(record.execution.as_ref())?;
+    }
+    for record in &manifest.color_selector_executions {
+        ensure_execution_capabilities_supported(record.execution.as_ref())?;
+    }
+    let mut execution_capabilities = BTreeSet::new();
+    if let Some(parameters) = &manifest.compiled.model_parameter_evaluator {
+        ensure_evaluator_capabilities_supported(&parameters.evaluator)?;
+        let actual = evaluator_runtime_capabilities(&parameters.evaluator)?;
+        validate_declared_capabilities(
+            &parameters.required_runtime_capabilities,
+            &actual,
+            "model-parameter evaluator",
+        )?;
+        execution_capabilities.extend(actual);
+    }
+    if let Some(stages) = &manifest.compiled.stage_evaluators {
+        let mut stage_capabilities = BTreeSet::new();
+        for stage in &stages.stages {
+            ensure_evaluator_capabilities_supported(&stage.evaluator)?;
+            stage_capabilities.extend(evaluator_runtime_capabilities(&stage.evaluator)?);
+        }
+        ensure_evaluator_capabilities_supported(&stages.amplitude_stage.evaluator)?;
+        stage_capabilities.extend(evaluator_runtime_capabilities(
+            &stages.amplitude_stage.evaluator,
+        )?);
+        let has_compiled_selector_metadata = manifest
+            .runtime_schema
+            .helicity_recurrence
+            .as_ref()
+            .is_some_and(|recurrence| recurrence.materialization.is_some())
+            || stages
+                .stages
+                .iter()
+                .chain(std::iter::once(&stages.amplitude_stage))
+                .flat_map(|stage| &stage.output_slots)
+                .any(|slot| !slot.color_selector_domain_ids.is_empty());
+        if stages
+            .required_runtime_capabilities
+            .iter()
+            .any(|capability| capability == COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+        {
+            if !has_compiled_selector_metadata {
+                return Err(RusticolError::integrity(
+                    "compiled runtime-selector capability has no selector metadata",
+                ));
+            }
+            stage_capabilities.insert(COMPILED_RUNTIME_SELECTORS_CAPABILITY.to_string());
+        }
+        if stages
+            .required_runtime_capabilities
+            .iter()
+            .any(|capability| capability == COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY)
+        {
+            let all_direct = stages
+                .stages
+                .iter()
+                .chain(std::iter::once(&stages.amplitude_stage))
+                .all(|stage| stage.compiled_plane_arena.is_some());
+            if !all_direct {
+                return Err(RusticolError::integrity(
+                    "compiled-plane-arena-v1 capability has incomplete stage metadata",
+                ));
+            }
+            stage_capabilities.insert(COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY.to_string());
+        }
+        validate_declared_capabilities(
+            &stages.required_runtime_capabilities,
+            &stage_capabilities,
+            "stage evaluator set",
+        )?;
+        execution_capabilities.extend(stage_capabilities);
+    }
+    if has_helicity_sum_execution {
+        execution_capabilities.extend(
+            manifest
+                .helicity_sum_execution
+                .as_deref()
+                .into_iter()
+                .flat_map(|sum_manifest| {
+                    sum_manifest.required_runtime_capabilities.iter().cloned()
+                }),
+        );
+        execution_capabilities.insert(COMPILED_HELICITY_DUAL_LANE_CAPABILITY.to_string());
+    }
+    if !has_helicity_sum_execution
+        && manifest
+            .runtime_schema
+            .helicity_recurrence
+            .as_ref()
+            .is_some_and(|recurrence| recurrence.materialization.is_some())
+    {
+        execution_capabilities.insert(COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY.to_string());
+    }
+    if has_helicity_selector_executions {
+        execution_capabilities.extend(manifest.helicity_selector_executions.iter().flat_map(
+            |record| {
+                record
+                    .execution
+                    .required_runtime_capabilities
+                    .iter()
+                    .cloned()
+            },
+        ));
+        execution_capabilities.insert(COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY.to_string());
+        execution_capabilities.insert(COMPILED_RUNTIME_SELECTORS_CAPABILITY.to_string());
+    }
+    if has_color_selector_executions {
+        execution_capabilities.extend(manifest.color_selector_executions.iter().flat_map(
+            |record| {
+                record
+                    .execution
+                    .required_runtime_capabilities
+                    .iter()
+                    .cloned()
+            },
+        ));
+        execution_capabilities.insert(COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY.to_string());
+        execution_capabilities.insert(COMPILED_RUNTIME_SELECTORS_CAPABILITY.to_string());
+    }
+    if let Some(factorized_block) = manifest
+        .runtime_schema
+        .amplitude_stage
+        .color_contraction
+        .as_ref()
+        .and_then(|contraction| contraction.repeated_block.as_ref())
+        .and_then(|repeated| repeated.factorized_block.as_ref())
+    {
+        execution_capabilities.insert(
+            match factorized_block {
+                GenericFactorizedColorContractionBlockManifest::KleinFourWalsh { .. } => {
+                    COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY
+                }
+                GenericFactorizedColorContractionBlockManifest::ElementaryAbelianWalsh {
+                    ..
+                } => COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY,
+            }
+            .to_string(),
+        );
+    }
+    if manifest.color_contraction_payload.is_some() {
+        execution_capabilities.insert(SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY.to_string());
+    }
+    validate_declared_execution_capabilities(
+        &manifest.required_runtime_capabilities,
+        &execution_capabilities,
+    )?;
+    Ok(())
+}
+
+fn validate_declared_execution_capabilities(
+    declared: &[String],
+    actual: &BTreeSet<String>,
+) -> RusticolResult<()> {
+    let declared_set = declared.iter().cloned().collect::<BTreeSet<_>>();
+    if declared_set.len() == declared.len() && &declared_set == actual {
+        return Ok(());
+    }
+
+    // Artifacts written before this capability was made explicit already carry
+    // the complete primary-recurrence materialization. Accept only that exact
+    // legacy omission; every other declaration mismatch remains an integrity
+    // error.
+    let mut legacy_actual = actual.clone();
+    if declared_set.len() == declared.len()
+        && legacy_actual.remove(COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY)
+        && declared_set == legacy_actual
+    {
+        return Ok(());
+    }
+
+    Err(RusticolError::integrity(format!(
+        "execution manifest capabilities {declared:?} do not match evaluator capabilities {actual:?}"
+    )))
+}
+
+#[cfg(all(test, feature = "f64-symjit"))]
+mod compiled_plane_arena_contract_tests {
+    use super::*;
+    use serde_json::{Value, json};
+
+    fn source_binding(parameter_index: usize) -> Value {
+        let (kind, source_id, component, global_component, real_valued) = if parameter_index < 2 {
+            ("value", parameter_index, 0, parameter_index, false)
+        } else {
+            (
+                "momentum",
+                (parameter_index - 2) / 4,
+                (parameter_index - 2) % 4,
+                parameter_index,
+                true,
+            )
+        };
+        json!({
+            "parameter_index": parameter_index,
+            "kind": kind,
+            "source_id": source_id,
+            "component": component,
+            "global_component": global_component,
+            "real_valued": real_valued,
+        })
+    }
+
+    fn arena_manifest_at(optimization_level: u8) -> ExecutionManifest {
+        let mut value = crate::artifact::tests::minimal_execution_manifest(
+            "p0",
+            "a b > c",
+            SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+            crate::artifact::tests::direct_evaluator_manifest("evaluators/direct.symjit"),
+        );
+        value["compiled"]["momentum_slot_ids"] = json!([0, 1, 2]);
+        let stage = &mut value["compiled"]["stage_evaluators"]["amplitude_stage"];
+        stage["parameter_layout"] = json!("stage-local-value-momentum");
+        stage["input_components"] = Value::Array((0..14).map(source_binding).collect());
+        stage["evaluator"]["optimization_level"] = json!(optimization_level);
+        stage["evaluator"]["plane_application"] = json!({
+            "application_path": "evaluators/direct.plane.symjit",
+            "application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+            "storage_abi": SYMJIT_APPLICATION_STORAGE_ABI,
+            "element_layout": "split-complex-plane-major",
+            "descriptor_order": "inputs-re-im-then-outputs-re-im",
+            "input_complex_count": 14,
+            "output_complex_count": 1,
+            "input_plane_count": 28,
+            "output_plane_count": 2,
+            "compiler_type": "native",
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": optimization_level,
+            "simd": true,
+            "complex": true,
+            "fast_math": true,
+            "fast_complex": false,
+            "compression": true,
+            "threading": false,
+            "direct_arena": true,
+            "source_digest": "00".repeat(32),
+            "target": {
+                "word_bits": 64,
+                "endianness": "little",
+                "triple": "test-native",
+                "cpu_features": [],
+            },
+        });
+        stage["compiled_plane_arena"] = json!({
+            "schema_version": 1,
+            "kind": "compiled-plane-arena-stage",
+            "application_abi": COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+            "source_application_abi": COMPILED_PLANE_SOURCE_APPLICATION_ABI,
+            "element_layout": "split-complex-component-major",
+            "output_operation": "overwrite",
+            "output_factor": "identity",
+            "input_output_aliasing": "forbidden",
+            "output_output_aliasing": "forbidden",
+            "input_bindings": (0..14).map(source_binding).collect::<Vec<_>>(),
+            "output_bindings": [{
+                "output_index": 0,
+                "arena": "amplitude",
+                "component": 0,
+            }],
+            "leaves": [{
+                "application_path": "evaluators/direct.plane.symjit",
+                "source_application_abi": COMPILED_PLANE_SOURCE_APPLICATION_ABI,
+                "optimization_level": optimization_level,
+                "direct_codegen_optimization_level": optimization_level,
+                "input_len": 14,
+                "output_len": 1,
+                "input_indices": (0..14).collect::<Vec<_>>(),
+                "output_start": 0,
+                "output_stop": 1,
+            }],
+        });
+        value["compiled"]["stage_evaluators"]["parameter_layout"] =
+            json!("stage-local-value-momentum");
+        value["compiled"]["stage_evaluators"]["required_runtime_capabilities"] = json!([
+            COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+            SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+        ]);
+        value["required_runtime_capabilities"] = json!([
+            COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+            SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+        ]);
+        serde_json::from_value(value).expect("deserialize compiled plane-arena fixture")
+    }
+
+    fn arena_manifest() -> ExecutionManifest {
+        arena_manifest_at(3)
+    }
+
+    #[test]
+    fn compiled_momentum_slot_selection_is_required_and_covers_final_inputs() {
+        let mut manifest = arena_manifest();
+        assert!(validate_compiled_plane_arena_contract(&manifest).unwrap());
+        manifest.compiled.momentum_slot_ids = None;
+        assert!(
+            validate_compiled_plane_arena_contract(&manifest)
+                .unwrap_err()
+                .message()
+                .contains("regenerate")
+        );
+        for ids in [
+            vec![0, 1],
+            vec![0, 0, 1, 2],
+            vec![2, 1, 0],
+            vec![0, 1, 2, 3],
+        ] {
+            manifest.compiled.momentum_slot_ids = Some(ids);
+            assert!(validate_compiled_plane_arena_contract(&manifest).is_err());
+        }
+    }
+
+    #[test]
+    fn pre_arena_compiled_f64_requires_actionable_regeneration() {
+        let value = crate::artifact::tests::minimal_execution_manifest(
+            "p0",
+            "a b > c",
+            SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+            crate::artifact::tests::direct_evaluator_manifest("evaluators/direct.symjit"),
+        );
+        let manifest =
+            serde_json::from_value(value).expect("deserialize pre-arena compiled fixture");
+
+        let error = validate_compiled_plane_arena_contract(&manifest)
+            .expect_err("pre-arena compiled f64 must fail closed");
+
+        let message = error.to_string();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(message.contains("compiled-plane-arena-v1"));
+        assert!(message.contains("`pyamplicol generate`"));
+    }
+
+    #[test]
+    fn pre_arena_non_o3_compiled_f64_fails_closed() {
+        let mut value = crate::artifact::tests::minimal_execution_manifest(
+            "p0",
+            "a b > c",
+            SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+            crate::artifact::tests::direct_evaluator_manifest("evaluators/direct.symjit"),
+        );
+        value["compiled"]["stage_evaluators"]["amplitude_stage"]["evaluator"]["optimization_level"] =
+            json!(1);
+        let manifest =
+            serde_json::from_value(value).expect("deserialize row-major compiled fixture");
+
+        let error = validate_compiled_plane_arena_contract(&manifest)
+            .expect_err("pre-arena non-O3 compiled f64 must fail closed");
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.to_string().contains("compiled-plane-arena-v1"));
+    }
+
+    #[test]
+    fn compiled_plane_contract_rejects_predecessor_binding_abi() {
+        let mut manifest = arena_manifest();
+        manifest
+            .compiled
+            .stage_evaluators
+            .as_mut()
+            .unwrap()
+            .amplitude_stage
+            .compiled_plane_arena
+            .as_mut()
+            .unwrap()
+            .application_abi = concat!("symjit-direct-", "application-storage-v1").to_string();
+
+        let error = validate_compiled_plane_arena_contract(&manifest)
+            .expect_err("the predecessor compiled-plane ABI must fail closed");
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.to_string().contains("incompatible direct ABI"));
+        assert!(error.to_string().contains("regenerate"));
+    }
+
+    #[test]
+    fn complete_plane_contract_supports_jit_o0_through_o3() {
+        for optimization_level in 0..=3 {
+            let manifest = arena_manifest_at(optimization_level);
+
+            assert!(validate_compiled_plane_arena_contract(&manifest).unwrap());
+            ensure_execution_capabilities_supported(&manifest).unwrap();
+        }
+        assert!(
+            supported_runtime_capabilities().contains(&COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY)
+        );
+    }
+
+    #[test]
+    fn plane_contract_rejects_binding_and_capability_drift() {
+        let mut manifest = arena_manifest();
+        manifest
+            .compiled
+            .stage_evaluators
+            .as_mut()
+            .unwrap()
+            .amplitude_stage
+            .compiled_plane_arena
+            .as_mut()
+            .unwrap()
+            .input_bindings[2]
+            .global_component = 99;
+        let error = validate_compiled_plane_arena_contract(&manifest).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+        assert!(error.to_string().contains("input bindings disagree"));
+
+        let mut manifest = arena_manifest();
+        manifest
+            .compiled
+            .stage_evaluators
+            .as_mut()
+            .unwrap()
+            .required_runtime_capabilities
+            .retain(|value| value != COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY);
+        let error = validate_compiled_plane_arena_contract(&manifest).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    }
+
+    #[test]
+    fn plane_contract_authenticates_leaf_optimization_level() {
+        let mut manifest = arena_manifest_at(1);
+        let stage = &mut manifest
+            .compiled
+            .stage_evaluators
+            .as_mut()
+            .unwrap()
+            .amplitude_stage;
+        stage.compiled_plane_arena.as_mut().unwrap().leaves[0].optimization_level = 2;
+
+        let error = validate_compiled_plane_arena_contract(&manifest).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+        assert!(error.to_string().contains("optimization level disagrees"));
+    }
+
+    #[test]
+    fn plane_contract_rejects_unknown_jit_optimization_level() {
+        let mut manifest = arena_manifest();
+        let stage = &mut manifest
+            .compiled
+            .stage_evaluators
+            .as_mut()
+            .unwrap()
+            .amplitude_stage;
+        let EvaluatorManifest::SymjitApplication {
+            optimization_level,
+            plane_application,
+            ..
+        } = &mut stage.evaluator
+        else {
+            panic!("compiled plane fixture must use one SymJIT evaluator");
+        };
+        *optimization_level = 4;
+        plane_application.as_mut().unwrap().optimization_level = 4;
+        let leaf = &mut stage.compiled_plane_arena.as_mut().unwrap().leaves[0];
+        leaf.optimization_level = 4;
+        leaf.direct_codegen_optimization_level = 4;
+
+        let error = validate_compiled_plane_arena_contract(&manifest).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.to_string().contains("levels 0 through 3"));
+    }
+}
+
+#[cfg(test)]
+mod legacy_primary_recurrence_capability_tests {
+    use super::*;
+
+    fn capabilities(values: &[&str]) -> BTreeSet<String> {
+        values.iter().map(|value| (*value).to_string()).collect()
+    }
+
+    #[test]
+    fn accepts_only_the_legacy_primary_recurrence_omission() {
+        let direct = "symjit.application.complex-f64.v1";
+        let declared = vec![direct.to_string()];
+        let actual = capabilities(&[COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY, direct]);
+
+        validate_declared_execution_capabilities(&declared, &actual)
+            .expect("the legacy omission remains compatible");
+    }
+
+    #[test]
+    fn rejects_every_other_capability_mismatch() {
+        let direct = "symjit.application.complex-f64.v1";
+        let declared = vec![direct.to_string()];
+        let actual = capabilities(&[COMPILED_RUNTIME_SELECTORS_CAPABILITY, direct]);
+
+        let error = validate_declared_execution_capabilities(&declared, &actual)
+            .expect_err("unrelated missing capabilities remain invalid");
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    }
+}
+
+#[cfg(all(test, feature = "f64-symjit"))]
+mod walsh_color_contraction_capability_tests {
+    use super::*;
+    use serde_json::json;
+
+    const DIRECT: &str = "symjit.application.complex-f64.v1";
+
+    fn manifest(has_factorized_block: bool, declares_capability: bool) -> ExecutionManifest {
+        let mut value = crate::artifact::tests::minimal_execution_manifest(
+            "p0",
+            "a b > c",
+            DIRECT,
+            crate::artifact::tests::direct_evaluator_manifest("evaluators/direct.symjit"),
+        );
+        if has_factorized_block {
+            value["runtime_schema"]["amplitude_stage"]["color_contraction"] = json!({
+                "supported": true,
+                "reason": null,
+                "group_count": 8,
+                "includes_color_factor": true,
+                "entries": [],
+                "repeated_block": {
+                    "component_count": 2,
+                    "component_group_ids": [0, 1, 2, 3, 4, 5, 6, 7],
+                    "entries": [],
+                    "factorized_block": {
+                        "kind": "klein-four-walsh",
+                        "cosets": [[0, 1, 2, 3]],
+                    },
+                },
+            });
+        }
+        if declares_capability {
+            value["required_runtime_capabilities"] =
+                json!([COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY, DIRECT]);
+        }
+        serde_json::from_value(value).expect("deserialize Walsh capability fixture")
+    }
+
+    fn c2k_manifest(has_factorized_block: bool, declares_capability: bool) -> ExecutionManifest {
+        let mut value = crate::artifact::tests::minimal_execution_manifest(
+            "p0",
+            "a b > c",
+            DIRECT,
+            crate::artifact::tests::direct_evaluator_manifest("evaluators/direct.symjit"),
+        );
+        if has_factorized_block {
+            value["runtime_schema"]["amplitude_stage"]["color_contraction"] = json!({
+                "supported": true,
+                "reason": null,
+                "group_count": 16,
+                "includes_color_factor": true,
+                "entries": [],
+                "repeated_block": {
+                    "component_count": 2,
+                    "component_group_ids": [
+                        0, 1, 2, 3, 4, 5, 6, 7,
+                        8, 9, 10, 11, 12, 13, 14, 15,
+                    ],
+                    "entries": [],
+                    "factorized_block": {
+                        "kind": "elementary-abelian-walsh",
+                        "rank": 3,
+                        "cosets": [[0, 1, 2, 3, 4, 5, 6, 7]],
+                    },
+                },
+            });
+        }
+        if declares_capability {
+            value["required_runtime_capabilities"] =
+                json!([COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY, DIRECT]);
+        }
+        serde_json::from_value(value).expect("deserialize C2^k Walsh capability fixture")
+    }
+
+    #[test]
+    fn supported_capabilities_include_walsh_color_contraction() {
+        assert!(
+            supported_runtime_capabilities().contains(&COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY)
+        );
+        assert!(
+            supported_runtime_capabilities()
+                .contains(&COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY)
+        );
+    }
+
+    #[test]
+    fn walsh_color_contraction_requires_an_exact_capability_declaration() {
+        ensure_execution_capabilities_supported(&manifest(false, false))
+            .expect("legacy execution without Walsh metadata");
+        ensure_execution_capabilities_supported(&manifest(true, true))
+            .expect("Walsh execution with matching capability");
+
+        for manifest in [manifest(true, false), manifest(false, true)] {
+            let error = ensure_execution_capabilities_supported(&manifest)
+                .expect_err("Walsh capability drift must fail closed");
+            assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+            assert!(
+                error
+                    .to_string()
+                    .contains(COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY),
+                "{error}"
+            );
+        }
+    }
+
+    #[test]
+    fn c2k_walsh_color_contraction_requires_its_distinct_exact_capability() {
+        ensure_execution_capabilities_supported(&c2k_manifest(true, true))
+            .expect("C2^k Walsh execution with matching capability");
+
+        for manifest in [c2k_manifest(true, false), c2k_manifest(false, true), {
+            let mut manifest = c2k_manifest(true, true);
+            manifest.required_runtime_capabilities[0] =
+                COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY.to_string();
+            manifest
+        }] {
+            let error = ensure_execution_capabilities_supported(&manifest)
+                .expect_err("C2^k Walsh capability drift must fail closed");
+            assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+        }
+    }
+}
+
+fn validate_declared_capabilities(
+    declared: &[String],
+    actual: &BTreeSet<String>,
+    context: &str,
+) -> RusticolResult<()> {
+    let declared_set = declared.iter().cloned().collect::<BTreeSet<_>>();
+    if declared_set.len() != declared.len() || &declared_set != actual {
+        return Err(RusticolError::integrity(format!(
+            "{context} capabilities {declared:?} do not match evaluator capabilities {actual:?}"
+        )));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod lc_topology_replay_contract_tests {
+    use super::*;
+
+    fn proof() -> LcTopologyReplayProofManifest {
+        LcTopologyReplayProofManifest {
+            status: "proven".to_string(),
+            algorithm: Some("canonical-contract-test-v1".to_string()),
+            digest: Some("a".repeat(64)),
+        }
+    }
+
+    fn labels(values: &[(usize, usize)]) -> Vec<LcTopologyReplayLabelPermutationManifest> {
+        values
+            .iter()
+            .map(
+                |(representative_label, sector_label)| LcTopologyReplayLabelPermutationManifest {
+                    representative_label: *representative_label,
+                    sector_label: *sector_label,
+                },
+            )
+            .collect()
+    }
+
+    fn permutation(
+        sector_id: i64,
+        weight: f64,
+        sign: i8,
+        mapping: &[(usize, usize)],
+    ) -> LcTopologyReplaySectorPermutationManifest {
+        LcTopologyReplaySectorPermutationManifest {
+            sector_id,
+            weight,
+            sign,
+            factor: Some(vec![weight * f64::from(sign), 0.0]),
+            label_permutation: labels(mapping),
+        }
+    }
+
+    fn group(
+        representative_sector_id: i64,
+        active_sector_ids: &[i64],
+        target_sector_id: i64,
+        sign: i8,
+    ) -> LcTopologyReplayGroupManifest {
+        LcTopologyReplayGroupManifest {
+            representative_sector_id,
+            materialized_sector_id: representative_sector_id,
+            active_sector_ids: active_sector_ids.to_vec(),
+            proof: Some(proof()),
+            sector_permutations: vec![
+                permutation(representative_sector_id, 1.0, 1, &[(1, 1), (2, 2)]),
+                permutation(target_sector_id, 1.0, sign, &[(1, 2), (2, 1)]),
+            ],
+        }
+    }
+
+    fn v2_replay() -> LcTopologyReplayManifest {
+        LcTopologyReplayManifest {
+            enabled: true,
+            mode: "external-label-permutation".to_string(),
+            contract_version: Some(2),
+            physical_sector_count: Some(5),
+            replayed_sector_count: 4,
+            materialized_sector_ids: vec![0, 2, 4],
+            residual_sector_ids: vec![4],
+            groups: vec![group(0, &[0, 1], 1, -1), group(2, &[2, 3], 3, 1)],
+        }
+    }
+
+    #[test]
+    fn v2_deduplicates_mappings_and_keeps_groups_and_residuals_additive() {
+        let data = build_lc_topology_replay_data(Some(&v2_replay())).unwrap();
+
+        assert_eq!(data.mappings, vec![vec![], vec![(0, 1), (1, 0)]]);
+        assert_eq!(data.materialized_sector_ids, BTreeSet::from([0, 2, 4]));
+        assert_eq!(
+            data.routes[0]
+                .iter()
+                .map(|route| (route.physical_sector_id, route.materialized_sector_id))
+                .collect::<Vec<_>>(),
+            vec![(0, 0), (2, 2), (4, 4)]
+        );
+        assert_eq!(
+            data.routes[1]
+                .iter()
+                .map(|route| (route.physical_sector_id, route.materialized_sector_id))
+                .collect::<Vec<_>>(),
+            vec![(1, 0), (3, 2)]
+        );
+        assert_eq!(data.routes[1][0].sign, -1);
+        assert_eq!(data.routes[1][0].amplitude_factor, [-1.0, 0.0]);
+        assert_eq!(data.routes[1][0].squared_reduction_weight(), 1.0);
+    }
+
+    #[test]
+    fn v2_rejects_malformed_physical_and_materialized_coverage() {
+        let mut replay = v2_replay();
+        replay.materialized_sector_ids = vec![0, 2];
+        let error = build_lc_topology_replay_data(Some(&replay)).unwrap_err();
+        assert!(error.to_string().contains("materialized coverage"));
+
+        let mut replay = v2_replay();
+        replay.physical_sector_count = Some(6);
+        let error = build_lc_topology_replay_data(Some(&replay)).unwrap_err();
+        assert!(error.to_string().contains("every physical sector"));
+    }
+
+    #[test]
+    fn v2_rejects_unproven_groups_and_inconsistent_signed_factors() {
+        let mut replay = v2_replay();
+        replay.groups[0].proof.as_mut().unwrap().status = "assumed".to_string();
+        let error = build_lc_topology_replay_data(Some(&replay)).unwrap_err();
+        assert!(error.to_string().contains("requires a proven"));
+
+        let mut replay = v2_replay();
+        replay.groups[0].sector_permutations[1].factor = Some(vec![1.0, 0.0]);
+        let error = build_lc_topology_replay_data(Some(&replay)).unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("does not match its weight and sign")
+        );
+    }
+
+    #[test]
+    fn legacy_contract_remains_loadable() {
+        let mut replay = v2_replay();
+        replay.contract_version = None;
+        replay.physical_sector_count = None;
+        replay.materialized_sector_ids.clear();
+        replay.residual_sector_ids.clear();
+        replay.replayed_sector_count = 4;
+        for group in &mut replay.groups {
+            group.proof = None;
+            for permutation in &mut group.sector_permutations {
+                permutation.factor = None;
+            }
+        }
+
+        let data = build_lc_topology_replay_data(Some(&replay)).unwrap();
+        assert_eq!(data.materialized_sector_ids, BTreeSet::from([0, 2]));
+        assert_eq!(data.routes.iter().map(Vec::len).sum::<usize>(), 4);
+    }
+}
+
+#[cfg(test)]
+mod helicity_recurrence_contract_tests {
+    use super::*;
+    use serde_json::json;
+
+    #[cfg(feature = "f64-symjit")]
+    #[test]
+    fn compiled_parent_detach_preserves_selected_materialized_stage_schedule() {
+        const DIRECT: &str = "symjit.application.complex-f64.v1";
+        let mut value = crate::artifact::tests::minimal_execution_manifest(
+            "p0",
+            "a > a",
+            DIRECT,
+            crate::artifact::tests::direct_evaluator_manifest("evaluators/direct.symjit"),
+        );
+        value["external_pdg_order"] = json!([1]);
+        value["runtime_schema"]["external_particles"]
+            .as_array_mut()
+            .expect("external-particle fixture")
+            .truncate(1);
+        value["runtime_schema"]["current_storage"]["current_slots"][1]["is_source"] = json!(false);
+        value["runtime_schema"]["source_fill"]["source_count"] = json!(1);
+        value["runtime_schema"]["source_fill"]["sources"]
+            .as_array_mut()
+            .expect("source fixture")
+            .truncate(1);
+        let source = &mut value["runtime_schema"]["source_fill"]["sources"][0];
+        source["source_helicity"] = json!(-1);
+        source["chirality"] = json!(-1);
+        source["spin_state"] = json!(-1);
+        source["source_ir"]["states"] = json!([
+            {"helicity": -1, "chirality": -1, "spin_state": -1},
+            {"helicity": 1, "chirality": 1, "spin_state": 1},
+        ]);
+        let root = &mut value["runtime_schema"]["amplitude_stage"]["roots"][0];
+        root["left_current_id"] = json!(1);
+        root["right_current_id"] = json!(0);
+
+        let evaluators = &mut value["compiled"]["stage_evaluators"];
+        evaluators["parameter_layout"] = json!("stage-local-value-momentum");
+        evaluators["parameter_count"] = json!(0);
+        evaluators["value_parameter_count"] = json!(0);
+        evaluators["momentum_parameter_count"] = json!(0);
+        evaluators["real_valued_inputs"] = json!([]);
+        evaluators["stage_count"] = json!(2);
+        let mut current_stage = evaluators["amplitude_stage"].clone();
+        current_stage["stage_index"] = json!(1);
+        current_stage["stage_kind"] = json!("current-combine");
+        current_stage["subset_size"] = json!(1);
+        current_stage["evaluator_label"] = json!("materialized_current");
+        current_stage["parameter_layout"] = json!("stage-local-value-momentum");
+        current_stage["output_slots"] = json!([{
+            "value_slot_id": 1,
+            "current_id": 1,
+            "variant": "unpropagated",
+            "component_start": 0,
+            "component_stop": 1,
+            "output_start": 0,
+            "output_stop": 1,
+        }]);
+        current_stage["input_value_slot_ids"] = json!([0]);
+        current_stage["output_value_slot_ids"] = json!([1]);
+        current_stage["input_components"] = json!([{
+            "kind": "value",
+            "source_id": 0,
+            "component": 0,
+            "global_component": 0,
+            "parameter_index": 0,
+            "real_valued": false,
+        }]);
+        current_stage["parameter_count"] = json!(1);
+        current_stage["value_parameter_count"] = json!(1);
+        current_stage["momentum_parameter_count"] = json!(0);
+        current_stage["real_valued_inputs"] = json!([]);
+        current_stage["evaluator"]["input_len"] = json!(1);
+        evaluators["stages"] = json!([current_stage]);
+
+        let amplitude = &mut evaluators["amplitude_stage"];
+        amplitude["parameter_layout"] = json!("stage-local-value-momentum");
+        amplitude["input_components"] = json!([
+            {
+                "kind": "value", "source_id": 0, "component": 0,
+                "global_component": 0, "parameter_index": 0,
+                "real_valued": false,
+            },
+            {
+                "kind": "value", "source_id": 1, "component": 0,
+                "global_component": 1, "parameter_index": 1,
+                "real_valued": false,
+            },
+        ]);
+        amplitude["parameter_count"] = json!(2);
+        amplitude["value_parameter_count"] = json!(2);
+        amplitude["momentum_parameter_count"] = json!(0);
+        amplitude["real_valued_inputs"] = json!([]);
+        amplitude["evaluator"]["input_len"] = json!(2);
+
+        let mut manifest = serde_json::from_value::<ExecutionManifest>(value)
+            .expect("deserialize compiled-parent fixture");
+        let (recurrence, _) = valid_materialized_contract();
+        manifest.runtime_schema.helicity_recurrence = Some(recurrence);
+
+        let (stage_evaluators, helicity_recurrence) =
+            detach_compiled_helicity_load_inputs(&mut manifest).unwrap();
+
+        assert!(stage_evaluators.is_some());
+        assert!(manifest.compiled.stage_evaluators.is_none());
+        assert!(manifest.runtime_schema.helicity_recurrence.is_none());
+        let materialization = helicity_recurrence
+            .as_ref()
+            .and_then(|recurrence| recurrence.materialization.as_ref())
+            .expect("compiled parent retained its selected-helicity schedule");
+        assert_eq!(
+            materialization.selector_schedules[0].active_stage_chunk_indices,
+            vec![vec![0]]
+        );
+        assert_eq!(
+            materialization.selector_schedules[0].active_amplitude_chunk_indices,
+            vec![0]
+        );
+
+        let mut runtime = ExecutionRuntime::from_manifest(manifest).unwrap();
+        runtime.helicity_recurrence = helicity_recurrence;
+        assert!(
+            runtime
+                .helicity_recurrence
+                .as_ref()
+                .is_some_and(|recurrence| recurrence.materialization.is_some())
+        );
+    }
+
+    #[cfg(feature = "f64-symjit")]
+    #[test]
+    fn helicity_selector_lane_rejects_parent_layout_mismatch() {
+        let value = crate::artifact::tests::minimal_helicity_selector_lane_execution();
+        let mut manifest = serde_json::from_value::<ExecutionManifest>(value)
+            .expect("deserialize selector-lane fixture");
+        manifest.helicity_selector_executions[0]
+            .execution
+            .runtime_schema
+            .parameter_layout
+            .value_component_count += 1;
+
+        let error = validate_helicity_selector_executions(&manifest).unwrap_err();
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+        assert!(
+            error
+                .to_string()
+                .contains("layout does not match its primary execution"),
+            "{error}"
+        );
+    }
+
+    #[cfg(feature = "f64-symjit")]
+    #[test]
+    fn parent_closure_helicity_selector_lane_rejects_topology_replay() {
+        let mut value = crate::artifact::tests::minimal_helicity_selector_lane_execution();
+        value["helicity_selector_executions"][0]["execution"]["compiled"]["color_topology_replay"] =
+            json!({"enabled": true});
+        let manifest = serde_json::from_value::<ExecutionManifest>(value)
+            .expect("deserialize replay-owning selector-lane fixture");
+
+        let error = validate_helicity_selector_executions(&manifest).unwrap_err();
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+        assert!(
+            error
+                .to_string()
+                .contains("cannot own colour-topology replay"),
+            "{error}"
+        );
+    }
+
+    #[cfg(feature = "f64-symjit")]
+    #[test]
+    fn helicity_selector_lane_capabilities_are_aggregated_from_every_record() {
+        let value = crate::artifact::tests::minimal_helicity_selector_lane_execution();
+        let manifest = serde_json::from_value::<ExecutionManifest>(value)
+            .expect("deserialize selector-lane fixture");
+
+        ensure_execution_capabilities_supported(&manifest).unwrap();
+    }
+
+    #[cfg(feature = "f64-symjit")]
+    #[test]
+    fn primary_recurrence_legacy_omission_does_not_mask_other_capability_drift() {
+        let mut value = crate::artifact::tests::minimal_helicity_selector_lane_execution();
+        value["required_runtime_capabilities"]
+            .as_array_mut()
+            .expect("capability array")
+            .retain(|capability| {
+                !matches!(
+                    capability.as_str(),
+                    Some(COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY)
+                        | Some(COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+                )
+            });
+        let manifest = serde_json::from_value::<ExecutionManifest>(value)
+            .expect("deserialize selector-lane fixture");
+
+        let error = ensure_execution_capabilities_supported(&manifest).unwrap_err();
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity, "{error}");
+        assert!(
+            error
+                .to_string()
+                .contains(COMPILED_RUNTIME_SELECTORS_CAPABILITY),
+            "{error}"
+        );
+    }
+
+    #[cfg(feature = "f64-symjit")]
+    #[test]
+    fn nested_runtime_helicity_selector_lane_accepts_its_own_domain_schedule() {
+        let mut value = crate::artifact::tests::minimal_helicity_selector_lane_execution();
+        value["helicity_selector_executions"][0]["schedule_mode"] = json!("nested-runtime");
+        let child = value["helicity_selector_executions"][0]["execution"].clone();
+        let mut nested_recurrence = crate::artifact::tests::mock_helicity_materialization();
+        nested_recurrence["materialization"]["selector_schedules"] = json!([
+            {
+                "selector_domain_id": 0,
+                "active_current_ids": [0, 1],
+                "active_root_ids": [0],
+                "structural_zero": false,
+            },
+            {
+                "selector_domain_id": 1,
+                "active_current_ids": [0, 1],
+                "active_root_ids": [0],
+                "structural_zero": false,
+            },
+        ]);
+        value["helicity_selector_executions"][0]["execution"]["runtime_schema"]["helicity_recurrence"] =
+            nested_recurrence;
+        value["helicity_selector_executions"][0]["execution"]["helicity_selector_executions"] = json!([
+            {
+                "selector_domain_ids": [0],
+                "schedule_mode": "parent-closure",
+                "execution": child.clone(),
+            },
+            {
+                "selector_domain_ids": [1],
+                "schedule_mode": "parent-closure",
+                "execution": child,
+            },
+        ]);
+        let manifest = serde_json::from_value::<ExecutionManifest>(value)
+            .expect("deserialize nested-runtime selector-lane fixture");
+
+        validate_helicity_selector_executions(&manifest).unwrap();
+        validate_helicity_selector_executions(
+            manifest.helicity_selector_executions[0].execution.as_ref(),
+        )
+        .unwrap();
+    }
+
+    fn digest(character: char) -> String {
+        std::iter::repeat_n(character, 64).collect()
+    }
+
+    fn proof(digest: &str) -> HelicityRecurrenceProofManifest {
+        HelicityRecurrenceProofManifest {
+            status: "proven".to_string(),
+            algorithm: HELICITY_RECURRENCE_PROOF_ALGORITHM.to_string(),
+            digest: digest.to_string(),
+            transition_contract_ids: Vec::new(),
+        }
+    }
+
+    fn domain(id: usize, helicity: i32) -> HelicitySelectorDomainManifest {
+        HelicitySelectorDomainManifest {
+            id,
+            complete: true,
+            source_states: vec![HelicitySelectorSourceStateManifest {
+                external_label: 1,
+                helicity,
+            }],
+        }
+    }
+
+    fn source_mapping(
+        current_id: usize,
+        helicity: i32,
+        chirality: i32,
+        selector_domain_id: usize,
+        source_digest: char,
+    ) -> HelicitySourceStateMappingManifest {
+        HelicitySourceStateMappingManifest {
+            current_id,
+            external_label: 1,
+            helicity,
+            chirality,
+            spin_state: GenericSourceSpinStateManifest::Scalar(helicity),
+            declared_state_index: 0,
+            selector_domain_id,
+            recurrence_class_id: format!("helicity-current-sha256:{}", digest('a')),
+            representative_current_id: 0,
+            source_contract_digest: digest(source_digest),
+            factor: [1.0, 0.0],
+        }
+    }
+
+    fn valid_recurrence() -> HelicityRecurrenceManifest {
+        let current_digest = digest('a');
+        let amplitude_digest = digest('b');
+        HelicityRecurrenceManifest {
+            kind: HELICITY_RECURRENCE_KIND.to_string(),
+            contract_version: HELICITY_RECURRENCE_CONTRACT_VERSION,
+            proof_algorithm: HELICITY_RECURRENCE_PROOF_ALGORITHM.to_string(),
+            current_count: 2,
+            amplitude_root_count: 1,
+            proof_counts: HelicityRecurrenceProofCountsManifest {
+                recurrence_class_count: 1,
+                optimized_recurrence_class_count: 1,
+                optimized_current_count: 2,
+                residual_current_count: 0,
+                amplitude_class_count: 1,
+                optimized_amplitude_class_count: 0,
+                residual_amplitude_count: 0,
+                source_state_mapping_count: 2,
+                physical_helicity_count: 2,
+                structural_zero_helicity_count: 0,
+            },
+            selector_domains: vec![domain(0, -1), domain(1, 1)],
+            source_state_mappings: vec![
+                source_mapping(0, -1, -1, 0, 'c'),
+                source_mapping(1, 1, 1, 1, 'd'),
+            ],
+            recurrence_classes: vec![HelicityRecurrenceClassManifest {
+                class_id: format!("helicity-current-sha256:{current_digest}"),
+                representative_current_id: 0,
+                external_labels: vec![1],
+                source_class: true,
+                members: vec![
+                    HelicityCurrentReplayMemberManifest {
+                        current_id: 0,
+                        selector_domain_id: 0,
+                        factor: [1.0, 0.0],
+                    },
+                    HelicityCurrentReplayMemberManifest {
+                        current_id: 1,
+                        selector_domain_id: 1,
+                        factor: [1.0, 0.0],
+                    },
+                ],
+                proof: proof(&current_digest),
+            }],
+            amplitude_classes: vec![HelicityAmplitudeReplayClassManifest {
+                class_id: format!("helicity-amplitude-sha256:{amplitude_digest}"),
+                representative_root_id: 0,
+                members: vec![HelicityAmplitudeReplayMemberManifest {
+                    root_id: 0,
+                    selector_domain_ids: vec![0, 1],
+                    factor: [1.0, 0.0],
+                }],
+                proof: proof(&amplitude_digest),
+            }],
+            residual_current_ids: Vec::new(),
+            residual_root_ids: Vec::new(),
+            structural_zero_selector_domain_ids: Vec::new(),
+            diagnostics: Vec::new(),
+            materialization: None,
+        }
+    }
+
+    fn source_schema(helicity: i32, chirality: i32) -> HelicityRecurrenceSchemaSource {
+        HelicityRecurrenceSchemaSource {
+            external_label: 1,
+            helicity,
+            chirality,
+            spin_state: GenericSourceSpinStateManifest::Scalar(helicity),
+            declared_states: vec![GenericSourceStateIrManifest {
+                helicity,
+                chirality,
+                spin_state: GenericSourceSpinStateManifest::Scalar(helicity),
+            }],
+        }
+    }
+
+    fn valid_schema() -> HelicityRecurrenceSchemaView {
+        HelicityRecurrenceSchemaView {
+            external_count: 1,
+            currents: vec![
+                HelicityRecurrenceSchemaCurrent {
+                    is_source: true,
+                    external_labels: vec![1],
+                },
+                HelicityRecurrenceSchemaCurrent {
+                    is_source: true,
+                    external_labels: vec![1],
+                },
+            ],
+            sources: BTreeMap::from([(0, source_schema(-1, -1)), (1, source_schema(1, 1))]),
+            roots: vec![HelicityRecurrenceSchemaRoot {
+                output_index: 0,
+                left_current_id: 0,
+                right_current_id: 1,
+                helicity_weight: 2.0,
+            }],
+            compiled_chunks: None,
+        }
+    }
+
+    fn valid_materialized_contract() -> (HelicityRecurrenceManifest, HelicityRecurrenceSchemaView) {
+        let mut recurrence = valid_recurrence();
+        recurrence.current_count = 4;
+        recurrence.proof_counts.recurrence_class_count = 2;
+        recurrence.proof_counts.optimized_recurrence_class_count = 2;
+        recurrence.proof_counts.optimized_current_count = 4;
+        recurrence.source_state_mappings[1].declared_state_index = 1;
+        let generated_digest = digest('e');
+        recurrence
+            .recurrence_classes
+            .push(HelicityRecurrenceClassManifest {
+                class_id: format!("helicity-current-sha256:{generated_digest}"),
+                representative_current_id: 2,
+                external_labels: vec![1],
+                source_class: false,
+                members: vec![
+                    HelicityCurrentReplayMemberManifest {
+                        current_id: 2,
+                        selector_domain_id: 0,
+                        factor: [1.0, 0.0],
+                    },
+                    HelicityCurrentReplayMemberManifest {
+                        current_id: 3,
+                        selector_domain_id: 1,
+                        factor: [1.0, 0.0],
+                    },
+                ],
+                proof: proof(&generated_digest),
+            });
+        recurrence.materialization = Some(HelicityRecurrenceMaterializationManifest {
+            kind: HELICITY_MATERIALIZATION_KIND.to_string(),
+            contract_version: HELICITY_MATERIALIZATION_CONTRACT_VERSION,
+            strategy: HelicityMaterializationStrategy::Quotient,
+            proof_current_count: 4,
+            proof_root_count: 1,
+            materialized_current_count: 2,
+            materialized_root_count: 1,
+            proof_to_materialized_current: vec![0, 0, 1, 1],
+            source_routes: vec![
+                HelicityMaterializedSourceRouteManifest {
+                    materialized_current_id: 0,
+                    external_label: 1,
+                    helicity: -1,
+                    chirality: -1,
+                    spin_state: GenericSourceSpinStateManifest::Scalar(-1),
+                    declared_state_index: 0,
+                    selector_domain_id: 0,
+                    factor: [1.0, 0.0],
+                },
+                HelicityMaterializedSourceRouteManifest {
+                    materialized_current_id: 0,
+                    external_label: 1,
+                    helicity: 1,
+                    chirality: 1,
+                    spin_state: GenericSourceSpinStateManifest::Scalar(1),
+                    declared_state_index: 1,
+                    selector_domain_id: 1,
+                    factor: [1.0, 0.0],
+                },
+            ],
+            amplitude_routes: vec![HelicityMaterializedAmplitudeRouteManifest {
+                materialized_root_id: 0,
+                selector_domain_ids: vec![0, 1],
+                factor: [1.0, 0.0],
+                residual: false,
+            }],
+            selector_schedules: vec![
+                HelicityMaterializedSelectorScheduleManifest {
+                    selector_domain_id: 0,
+                    active_current_ids: vec![0, 1],
+                    active_root_ids: vec![0],
+                    structural_zero: false,
+                },
+                HelicityMaterializedSelectorScheduleManifest {
+                    selector_domain_id: 1,
+                    active_current_ids: vec![0, 1],
+                    active_root_ids: vec![0],
+                    structural_zero: false,
+                },
+            ],
+        });
+        let source = HelicityRecurrenceSchemaSource {
+            external_label: 1,
+            helicity: -1,
+            chirality: -1,
+            spin_state: GenericSourceSpinStateManifest::Scalar(-1),
+            declared_states: vec![
+                GenericSourceStateIrManifest {
+                    helicity: -1,
+                    chirality: -1,
+                    spin_state: GenericSourceSpinStateManifest::Scalar(-1),
+                },
+                GenericSourceStateIrManifest {
+                    helicity: 1,
+                    chirality: 1,
+                    spin_state: GenericSourceSpinStateManifest::Scalar(1),
+                },
+            ],
+        };
+        let schema = HelicityRecurrenceSchemaView {
+            external_count: 1,
+            currents: vec![
+                HelicityRecurrenceSchemaCurrent {
+                    is_source: true,
+                    external_labels: vec![1],
+                },
+                HelicityRecurrenceSchemaCurrent {
+                    is_source: false,
+                    external_labels: vec![1],
+                },
+            ],
+            sources: BTreeMap::from([(0, source)]),
+            roots: vec![HelicityRecurrenceSchemaRoot {
+                output_index: 0,
+                left_current_id: 1,
+                right_current_id: 0,
+                helicity_weight: 1.0,
+            }],
+            compiled_chunks: Some(HelicityCompiledChunkCoverage {
+                stages: vec![HelicityCompiledStageChunkCoverage {
+                    current_ids_by_chunk: vec![BTreeSet::from([1])],
+                    input_current_ids_by_chunk: vec![BTreeSet::from([0])],
+                }],
+                amplitude_root_ids_by_chunk: vec![BTreeSet::from([0])],
+                amplitude_input_current_ids_by_chunk: vec![BTreeSet::from([0, 1])],
+            }),
+        };
+        (recurrence, schema)
+    }
+
+    fn valid_retained_materialized_contract()
+    -> (HelicityRecurrenceManifest, HelicityRecurrenceSchemaView) {
+        let (mut recurrence, compact_schema) = valid_materialized_contract();
+        let materialization = recurrence
+            .materialization
+            .as_mut()
+            .expect("materialization fixture");
+        materialization.strategy = HelicityMaterializationStrategy::RetainedProofGraph;
+        materialization.materialized_current_count = 4;
+        materialization.materialized_root_count = 1;
+        materialization.proof_to_materialized_current = vec![0, 1, 2, 3];
+        materialization.source_routes[1].materialized_current_id = 1;
+        materialization.amplitude_routes[0].factor = [2.0_f64.sqrt().recip(), 0.0];
+        for schedule in &mut materialization.selector_schedules {
+            schedule.active_current_ids = vec![0, 2];
+        }
+
+        let source = compact_schema.sources[&0].clone();
+        let mut flipped_source = source.clone();
+        flipped_source.helicity = 1;
+        flipped_source.chirality = 1;
+        flipped_source.spin_state = GenericSourceSpinStateManifest::Scalar(1);
+        let schema = HelicityRecurrenceSchemaView {
+            external_count: 1,
+            currents: vec![
+                HelicityRecurrenceSchemaCurrent {
+                    is_source: true,
+                    external_labels: vec![1],
+                },
+                HelicityRecurrenceSchemaCurrent {
+                    is_source: true,
+                    external_labels: vec![1],
+                },
+                HelicityRecurrenceSchemaCurrent {
+                    is_source: false,
+                    external_labels: vec![1],
+                },
+                HelicityRecurrenceSchemaCurrent {
+                    is_source: false,
+                    external_labels: vec![1],
+                },
+            ],
+            sources: BTreeMap::from([(0, source), (1, flipped_source)]),
+            roots: vec![HelicityRecurrenceSchemaRoot {
+                output_index: 0,
+                left_current_id: 2,
+                right_current_id: 0,
+                helicity_weight: 2.0,
+            }],
+            compiled_chunks: Some(HelicityCompiledChunkCoverage {
+                stages: vec![HelicityCompiledStageChunkCoverage {
+                    current_ids_by_chunk: vec![BTreeSet::from([2]), BTreeSet::from([3])],
+                    input_current_ids_by_chunk: vec![BTreeSet::from([0]), BTreeSet::from([1])],
+                }],
+                amplitude_root_ids_by_chunk: vec![BTreeSet::from([0])],
+                amplitude_input_current_ids_by_chunk: vec![BTreeSet::from([0, 2])],
+            }),
+        };
+        (recurrence, schema)
+    }
+
+    fn materialized_load_error(
+        recurrence: &HelicityRecurrenceManifest,
+        schema: &HelicityRecurrenceSchemaView,
+    ) -> String {
+        build_helicity_recurrence_runtime_from_view(Some(recurrence), schema)
+            .unwrap_err()
+            .to_string()
+    }
+
+    fn load_error(recurrence: &HelicityRecurrenceManifest) -> String {
+        build_helicity_recurrence_runtime_from_view(Some(recurrence), &valid_schema())
+            .unwrap_err()
+            .to_string()
+    }
+
+    #[test]
+    fn valid_contract_builds_compact_runtime_and_absence_remains_compatible() {
+        let schema = valid_schema();
+        assert!(
+            build_helicity_recurrence_runtime_from_view(None, &schema)
+                .unwrap()
+                .is_none()
+        );
+
+        let runtime =
+            build_helicity_recurrence_runtime_from_view(Some(&valid_recurrence()), &schema)
+                .unwrap()
+                .unwrap();
+
+        assert_eq!(runtime.selector_domains.len(), 2);
+        assert_eq!(runtime.recurrence_classes.len(), 1);
+        assert_eq!(runtime.recurrence_classes[0].members.len(), 2);
+        assert_eq!(runtime.source_state_mappings.len(), 2);
+        assert_eq!(runtime.source_state_mappings[1].recurrence_class_index, 0);
+        assert_eq!(runtime.amplitude_classes.len(), 1);
+        assert!(runtime.residual_current_ids.is_empty());
+        assert!(runtime.residual_root_ids.is_empty());
+    }
+
+    #[test]
+    fn strict_wire_types_reject_unknown_fields_and_bad_factor_shapes() {
+        let error = serde_json::from_value::<HelicityRecurrenceProofManifest>(json!({
+            "status": "proven",
+            "algorithm": HELICITY_RECURRENCE_PROOF_ALGORITHM,
+            "digest": digest('a'),
+            "transition_contract_ids": [],
+            "unexpected": true,
+        }))
+        .unwrap_err();
+        assert!(error.to_string().contains("unknown field"));
+
+        let error = serde_json::from_value::<HelicityCurrentReplayMemberManifest>(json!({
+            "current_id": 0,
+            "selector_domain_id": 0,
+            "factor": [1.0],
+        }))
+        .unwrap_err();
+        assert!(error.to_string().contains("length 2"));
+
+        let error = serde_json::from_value::<HelicityMaterializedSelectorScheduleManifest>(json!({
+            "selector_domain_id": 0,
+            "active_current_ids": [],
+            "active_root_ids": [],
+            "structural_zero": true,
+            "unexpected": true,
+        }))
+        .unwrap_err();
+        assert!(error.to_string().contains("unknown field"));
+    }
+
+    #[test]
+    fn contract_and_proof_drift_are_rejected() {
+        let mut recurrence = valid_recurrence();
+        recurrence.contract_version += 1;
+        assert!(load_error(&recurrence).contains("contract version"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.recurrence_classes[0].proof.status = "assumed".to_string();
+        assert!(load_error(&recurrence).contains("invalid proof metadata"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.amplitude_classes[0].proof.digest = "A".repeat(64);
+        assert!(load_error(&recurrence).contains("lowercase SHA-256"));
+    }
+
+    #[test]
+    fn selector_domains_must_be_contiguous_unique_and_complete() {
+        let mut recurrence = valid_recurrence();
+        recurrence.selector_domains[1].id = 4;
+        assert!(load_error(&recurrence).contains("must be contiguous"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.selector_domains[1].source_states[0].helicity = -1;
+        assert!(load_error(&recurrence).contains("repeat a source-state assignment"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.selector_domains[0].complete = false;
+        assert!(load_error(&recurrence).contains("inconsistent complete coverage"));
+    }
+
+    #[test]
+    fn stale_current_ids_and_residual_overlap_are_rejected() {
+        let mut recurrence = valid_recurrence();
+        recurrence.recurrence_classes[0].members[1].current_id = 2;
+        assert!(load_error(&recurrence).contains("stale current id"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.residual_current_ids = vec![0];
+        assert!(load_error(&recurrence).contains("overlaps a proven recurrence class"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.recurrence_classes[0].members.pop();
+        assert!(load_error(&recurrence).contains("do not cover the proof DAG"));
+    }
+
+    #[test]
+    fn source_state_mappings_are_checked_against_domains_classes_and_source_ir() {
+        let mut recurrence = valid_recurrence();
+        recurrence.source_state_mappings[0].declared_state_index = 1;
+        assert!(load_error(&recurrence).contains("stale declared state index"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.source_state_mappings[0].recurrence_class_id = "wrong".to_string();
+        assert!(load_error(&recurrence).contains("inconsistent with its recurrence class"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.source_state_mappings.pop();
+        assert!(load_error(&recurrence).contains("do not exactly cover"));
+    }
+
+    #[test]
+    fn factors_root_overlap_and_structural_zero_overlap_are_rejected() {
+        let mut recurrence = valid_recurrence();
+        recurrence.recurrence_classes[0].members[0].factor = [0.0, 0.0];
+        assert!(load_error(&recurrence).contains("invalid recurrence factor"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.recurrence_classes[0].members[0].factor = [-1.0, 0.0];
+        assert!(load_error(&recurrence).contains("identity factor"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.residual_root_ids = vec![0];
+        assert!(load_error(&recurrence).contains("overlaps a proven amplitude class"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.structural_zero_selector_domain_ids = vec![0];
+        assert!(load_error(&recurrence).contains("disjoint from amplitude coverage"));
+    }
+
+    #[test]
+    fn structural_zero_domains_may_reference_unmaterialized_source_states() {
+        let mut recurrence = valid_recurrence();
+        recurrence.selector_domains.push(domain(2, 0));
+        recurrence.structural_zero_selector_domain_ids.push(2);
+        recurrence.proof_counts.physical_helicity_count = 3;
+        recurrence.proof_counts.structural_zero_helicity_count = 1;
+
+        build_helicity_recurrence_runtime_from_view(Some(&recurrence), &valid_schema())
+            .expect("structural-zero domains do not require executable source states");
+    }
+
+    #[test]
+    fn nonzero_selector_domains_may_replay_from_an_executable_anchor() {
+        let mut recurrence = valid_recurrence();
+        recurrence.selector_domains.push(domain(2, 0));
+        recurrence.amplitude_classes[0].members[0]
+            .selector_domain_ids
+            .push(2);
+        recurrence.proof_counts.physical_helicity_count = 3;
+        let mut schema = valid_schema();
+        schema.roots[0].helicity_weight = 3.0;
+
+        build_helicity_recurrence_runtime_from_view(Some(&recurrence), &schema)
+            .expect("certified replay group contains directly executable domains");
+    }
+
+    #[test]
+    fn nonzero_replay_groups_require_a_directly_executable_anchor() {
+        let mut recurrence = valid_recurrence();
+        recurrence.selector_domains.push(domain(2, 0));
+        recurrence.amplitude_classes[0].members[0].selector_domain_ids = vec![2];
+        recurrence.proof_counts.physical_helicity_count = 3;
+        let mut schema = valid_schema();
+        schema.roots[0].helicity_weight = 1.0;
+
+        let error = materialized_load_error(&recurrence, &schema);
+        assert!(
+            error.contains("no directly executable source-state anchor"),
+            "{error}"
+        );
+    }
+
+    #[test]
+    fn proof_counts_and_final_runtime_counts_must_match() {
+        let mut recurrence = valid_recurrence();
+        recurrence.proof_counts.optimized_current_count = 99;
+        assert!(load_error(&recurrence).contains("proof counts"));
+
+        let mut recurrence = valid_recurrence();
+        recurrence.current_count = 3;
+        assert!(load_error(&recurrence).contains("final runtime schema"));
+    }
+
+    #[test]
+    fn materialized_contract_accepts_larger_proof_space_and_derives_active_chunks() {
+        let (recurrence, schema) = valid_materialized_contract();
+        let runtime = build_helicity_recurrence_runtime_from_view(Some(&recurrence), &schema)
+            .unwrap()
+            .unwrap();
+        let materialization = runtime.materialization.unwrap();
+
+        assert_eq!(
+            materialization.proof_to_materialized_current,
+            vec![0, 0, 1, 1]
+        );
+        assert_eq!(materialization.source_routes.len(), 2);
+        assert_eq!(materialization.amplitude_routes.len(), 1);
+        assert_eq!(materialization.selector_schedules.len(), 2);
+        assert_eq!(
+            materialization.selector_schedules[0].active_stage_chunk_indices,
+            vec![vec![0]]
+        );
+        assert_eq!(
+            materialization.selector_schedules[0].active_amplitude_chunk_indices,
+            vec![0]
+        );
+    }
+
+    #[test]
+    fn retained_materialization_accepts_identity_proof_graph() {
+        let (recurrence, schema) = valid_retained_materialized_contract();
+        let runtime = build_helicity_recurrence_runtime_from_view(Some(&recurrence), &schema)
+            .unwrap()
+            .unwrap();
+        let materialization = runtime.materialization.unwrap();
+
+        assert_eq!(
+            materialization.strategy,
+            HelicityMaterializationStrategy::RetainedProofGraph
+        );
+        assert_eq!(
+            materialization.proof_to_materialized_current,
+            vec![0, 1, 2, 3]
+        );
+        assert_eq!(
+            materialization.selector_schedules[0].active_stage_chunk_indices,
+            vec![vec![0]]
+        );
+    }
+
+    #[test]
+    fn retained_materialization_rejects_nonidentity_current_map() {
+        let (mut recurrence, schema) = valid_retained_materialized_contract();
+        recurrence
+            .materialization
+            .as_mut()
+            .unwrap()
+            .proof_to_materialized_current
+            .swap(0, 1);
+
+        assert!(materialized_load_error(&recurrence, &schema).contains("identity current map"));
+    }
+
+    #[test]
+    fn materialized_contract_rejects_stale_maps_and_overlapping_targets() {
+        let (mut recurrence, schema) = valid_materialized_contract();
+        recurrence
+            .materialization
+            .as_mut()
+            .unwrap()
+            .proof_to_materialized_current
+            .pop();
+        assert!(materialized_load_error(&recurrence, &schema).contains("incorrect length"));
+
+        let (mut recurrence, schema) = valid_materialized_contract();
+        recurrence
+            .materialization
+            .as_mut()
+            .unwrap()
+            .proof_to_materialized_current = vec![0, 0, 0, 0];
+        assert!(materialized_load_error(&recurrence, &schema).contains("distinct proof classes"));
+    }
+
+    #[test]
+    fn materialized_routes_and_selector_domains_are_strict() {
+        let (mut recurrence, schema) = valid_materialized_contract();
+        recurrence.materialization.as_mut().unwrap().source_routes[1].declared_state_index = 0;
+        assert!(materialized_load_error(&recurrence, &schema).contains("inconsistent"));
+
+        let (mut recurrence, schema) = valid_materialized_contract();
+        recurrence
+            .materialization
+            .as_mut()
+            .unwrap()
+            .amplitude_routes[0]
+            .selector_domain_ids = vec![1, 0];
+        assert!(
+            materialized_load_error(&recurrence, &schema)
+                .contains("ordered complete selector domains")
+        );
+    }
+
+    #[test]
+    fn materialized_schedules_require_compiled_coverage_for_active_currents() {
+        let (recurrence, mut schema) = valid_materialized_contract();
+        schema.compiled_chunks.as_mut().unwrap().stages[0].current_ids_by_chunk[0].clear();
+        assert!(
+            materialized_load_error(&recurrence, &schema)
+                .contains("without compiled stage output coverage")
+        );
+
+        let (mut recurrence, schema) = valid_materialized_contract();
+        recurrence
+            .materialization
+            .as_mut()
+            .unwrap()
+            .selector_schedules[0]
+            .active_root_ids
+            .clear();
+        assert!(
+            materialized_load_error(&recurrence, &schema)
+                .contains("active roots disagree with amplitude routes")
+        );
+    }
+
+    #[test]
+    fn materialized_schedules_reject_cross_domain_chunks_and_missing_ancestors() {
+        let (recurrence, mut schema) = valid_retained_materialized_contract();
+        schema.compiled_chunks.as_mut().unwrap().stages[0].current_ids_by_chunk[0].insert(3);
+        assert!(
+            materialized_load_error(&recurrence, &schema)
+                .contains("crosses selector domains through currents [3]")
+        );
+
+        let (recurrence, mut schema) = valid_materialized_contract();
+        schema.compiled_chunks.as_mut().unwrap().stages[0].input_current_ids_by_chunk[0] =
+            BTreeSet::from([1]);
+        assert!(
+            materialized_load_error(&recurrence, &schema)
+                .contains("stage 0 evaluator chunk 0 is missing compiled ancestors [1]")
+        );
+
+        let (recurrence, mut schema) = valid_retained_materialized_contract();
+        schema
+            .compiled_chunks
+            .as_mut()
+            .unwrap()
+            .amplitude_input_current_ids_by_chunk[0] = BTreeSet::from([3]);
+        assert!(
+            materialized_load_error(&recurrence, &schema)
+                .contains("amplitude evaluator chunk 0 is missing compiled ancestors [3]")
+        );
+    }
+
+    #[test]
+    fn compiled_color_schedule_rejects_a_missing_transitive_ancestor() {
+        let chunks = HelicityCompiledChunkCoverage {
+            stages: vec![
+                HelicityCompiledStageChunkCoverage {
+                    current_ids_by_chunk: vec![BTreeSet::from([1])],
+                    input_current_ids_by_chunk: vec![BTreeSet::from([0])],
+                },
+                HelicityCompiledStageChunkCoverage {
+                    current_ids_by_chunk: vec![BTreeSet::from([2])],
+                    input_current_ids_by_chunk: vec![BTreeSet::from([1])],
+                },
+            ],
+            amplitude_root_ids_by_chunk: vec![BTreeSet::from([0])],
+            amplitude_input_current_ids_by_chunk: vec![BTreeSet::from([2])],
+        };
+
+        validate_compiled_selector_schedule_closure(
+            "compiled color selector sector 0",
+            &[true, false, false],
+            &chunks,
+            &[vec![0], vec![0]],
+            &[0],
+            None,
+            None,
+        )
+        .unwrap();
+
+        let error = validate_compiled_selector_schedule_closure(
+            "compiled color selector sector 0",
+            &[true, false, false],
+            &chunks,
+            &[Vec::new(), vec![0]],
+            &[0],
+            None,
+            None,
+        )
+        .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("stage 1 evaluator chunk 0 is missing compiled ancestors [1]")
+        );
+    }
+
+    #[test]
+    fn serialized_chunk_input_maps_resolve_actual_current_dependencies() {
+        let leaf = |name: &str| EvaluatorManifest::CompiledComplex {
+            runtime_capability: "test.runtime".to_string(),
+            function_name: name.to_string(),
+            input_len: 1,
+            output_len: 1,
+            library_path: "test.so".to_string(),
+            evaluator_state_path: None,
+            number_type: "complex-f64".to_string(),
+            native_direct_application: None,
+        };
+        let stage = GenericSerializedStageEvaluatorManifest {
+            stage_index: 1,
+            stage_kind: "current-combine".to_string(),
+            subset_size: Some(2),
+            evaluator_label: "mapped-input-stage".to_string(),
+            parameter_layout: "stage-local-value-momentum".to_string(),
+            output_length: 2,
+            output_slots: Vec::new(),
+            input_value_slot_ids: vec![10, 11],
+            output_value_slot_ids: Vec::new(),
+            interaction_ids: Vec::new(),
+            input_components: vec![
+                GenericStageInputComponentManifest {
+                    kind: "value".to_string(),
+                    source_id: 10,
+                    component: 0,
+                    global_component: 0,
+                    parameter_index: 0,
+                    real_valued: false,
+                },
+                GenericStageInputComponentManifest {
+                    kind: "value".to_string(),
+                    source_id: 11,
+                    component: 0,
+                    global_component: 1,
+                    parameter_index: 1,
+                    real_valued: false,
+                },
+            ],
+            parameter_count: 2,
+            value_parameter_count: 2,
+            momentum_parameter_count: 0,
+            model_parameter_count: 0,
+            real_valued_inputs: Vec::new(),
+            expression_ready: true,
+            blockers: Vec::new(),
+            evaluator: EvaluatorManifest::Chunked {
+                required_runtime_capabilities: Vec::new(),
+                input_len: Some(2),
+                chunk_input_indices: Some(vec![vec![1], vec![0]]),
+                chunks: vec![leaf("right"), leaf("left")],
+            },
+            compiled_plane_arena: None,
+        };
+
+        let dependencies = compiled_input_current_ids_by_chunk(
+            &stage,
+            &CompiledValueInputLayout {
+                current_ids_by_slot: BTreeMap::from([(10, 0), (11, 1)]),
+                current_ids_by_global_component: vec![Some(0), Some(1)],
+            },
+            2,
+        )
+        .unwrap();
+
+        assert_eq!(dependencies, vec![BTreeSet::from([1]), BTreeSet::from([0])]);
+
+        let mut mismatched = stage;
+        mismatched.input_components[0].global_component = 1;
+        let error = compiled_input_current_ids_by_chunk(
+            &mismatched,
+            &CompiledValueInputLayout {
+                current_ids_by_slot: BTreeMap::from([(10, 0), (11, 1)]),
+                current_ids_by_global_component: vec![Some(0), Some(1)],
+            },
+            2,
+        )
+        .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("value-slot and global-component dependencies disagree")
+        );
+    }
+
+    #[test]
+    fn serialized_output_ranges_derive_stage_and_amplitude_chunk_coverage() {
+        fn leaf(output_len: usize) -> EvaluatorManifest {
+            EvaluatorManifest::CompiledComplex {
+                runtime_capability: "test.runtime".to_string(),
+                function_name: "test".to_string(),
+                input_len: 0,
+                output_len,
+                library_path: "test.so".to_string(),
+                evaluator_state_path: None,
+                number_type: "complex-f64".to_string(),
+                native_direct_application: None,
+            }
+        }
+        fn chunked(output_lengths: &[usize]) -> EvaluatorManifest {
+            EvaluatorManifest::Chunked {
+                required_runtime_capabilities: Vec::new(),
+                input_len: Some(0),
+                chunk_input_indices: Some(vec![Vec::new(); output_lengths.len()]),
+                chunks: output_lengths.iter().copied().map(leaf).collect(),
+            }
+        }
+        fn stage(
+            stage_index: usize,
+            label: &str,
+            output_slots: Vec<GenericStageOutputSlotManifest>,
+            output_lengths: &[usize],
+        ) -> GenericSerializedStageEvaluatorManifest {
+            GenericSerializedStageEvaluatorManifest {
+                stage_index,
+                stage_kind: label.to_string(),
+                subset_size: Some(stage_index + 1),
+                evaluator_label: label.to_string(),
+                parameter_layout: "stage-local-value-momentum".to_string(),
+                output_length: output_lengths.iter().sum(),
+                output_slots,
+                input_value_slot_ids: Vec::new(),
+                output_value_slot_ids: Vec::new(),
+                interaction_ids: Vec::new(),
+                input_components: Vec::new(),
+                parameter_count: 0,
+                value_parameter_count: 0,
+                momentum_parameter_count: 0,
+                model_parameter_count: 0,
+                real_valued_inputs: Vec::new(),
+                expression_ready: true,
+                blockers: Vec::new(),
+                evaluator: chunked(output_lengths),
+                compiled_plane_arena: None,
+            }
+        }
+        fn slot(
+            current_id: isize,
+            output_start: usize,
+            output_stop: usize,
+        ) -> GenericStageOutputSlotManifest {
+            GenericStageOutputSlotManifest {
+                value_slot_id: current_id,
+                current_id,
+                variant: if current_id < 0 {
+                    "amplitude-root".to_string()
+                } else {
+                    "unpropagated".to_string()
+                },
+                component_start: output_start,
+                component_stop: output_stop,
+                output_start,
+                output_stop,
+                color_selector_domain_ids: Vec::new(),
+            }
+        }
+
+        let stages = GenericStageEvaluatorArtifactsManifest {
+            kind: "generic-dag-stage-evaluator-artifacts".to_string(),
+            required_runtime_capabilities: Vec::new(),
+            runtime_available: true,
+            runtime_unavailable_message: None,
+            parameter_count: 0,
+            value_parameter_count: 0,
+            momentum_parameter_count: 0,
+            model_parameter_count: 0,
+            real_valued_inputs: Vec::new(),
+            parameter_layout: "stage-local-value-momentum".to_string(),
+            stage_count: 1,
+            stages: vec![stage(
+                1,
+                "current-combine",
+                vec![slot(0, 0, 2), slot(1, 2, 4)],
+                &[2, 2],
+            )],
+            amplitude_stage: stage(
+                0,
+                "amplitude-roots",
+                vec![slot(-1, 0, 1), slot(-1, 1, 2)],
+                &[1, 1],
+            ),
+        };
+        let roots = vec![
+            HelicityRecurrenceSchemaRoot {
+                output_index: 0,
+                left_current_id: 0,
+                right_current_id: 0,
+                helicity_weight: 1.0,
+            },
+            HelicityRecurrenceSchemaRoot {
+                output_index: 1,
+                left_current_id: 1,
+                right_current_id: 1,
+                helicity_weight: 1.0,
+            },
+        ];
+        let coverage = build_helicity_compiled_chunk_coverage_from_parts(
+            &stages,
+            2,
+            &roots,
+            &CompiledValueInputLayout {
+                current_ids_by_slot: BTreeMap::new(),
+                current_ids_by_global_component: Vec::new(),
+            },
+        )
+        .unwrap();
+
+        assert_eq!(
+            coverage.stages[0].current_ids_by_chunk,
+            vec![BTreeSet::from([0]), BTreeSet::from([1])]
+        );
+        assert_eq!(
+            coverage.amplitude_root_ids_by_chunk,
+            vec![BTreeSet::from([0]), BTreeSet::from([1])]
+        );
+
+        let mut inactive_chunk = stage(
+            1,
+            "inactive-chunk",
+            vec![slot(0, 0, 2), slot(1, 2, 4)],
+            &[2, 2],
+        );
+        inactive_chunk.output_slots[0].color_selector_domain_ids = vec![0];
+        assert_eq!(
+            compiled_color_domains_by_chunk(&inactive_chunk, &BTreeSet::from([0_i64])).unwrap(),
+            vec![BTreeSet::from([0]), BTreeSet::new()]
+        );
+
+        let mut cross_domain = stage(1, "cross-domain", vec![slot(0, 0, 2), slot(1, 2, 4)], &[4]);
+        cross_domain.output_slots[0].color_selector_domain_ids = vec![0];
+        cross_domain.output_slots[1].color_selector_domain_ids = vec![1];
+        let error = compiled_color_domains_by_chunk(&cross_domain, &BTreeSet::from([0_i64, 1_i64]))
+            .unwrap_err();
+        assert!(error.to_string().contains("crosses selector domains"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/source_metadata_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/source_metadata_tests.rs
new file mode 100644
index 0000000000..39998a3b0e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/source_metadata_tests.rs
@@ -0,0 +1,777 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use serde_json::{Value, json};
+
+#[test]
+fn resolved_source_inputs_match_formula_bits_for_all_families_and_crossings() {
+    let external_count = 3;
+    let flat = (0..9)
+        .flat_map(|index| [10.0 + index as f64, 1.0, -0.0, 3.0])
+        .collect::<Vec<_>>();
+    let crossing = [
+        InputCrossingMapEntry {
+            target_index: 0,
+            source_index: 2,
+            sign: -1.0,
+        },
+        InputCrossingMapEntry {
+            target_index: 1,
+            source_index: 0,
+            sign: -1.0,
+        },
+        InputCrossingMapEntry {
+            target_index: 2,
+            source_index: 1,
+            sign: 1.0,
+        },
+    ];
+    for (family, dimension, orientation, mass) in [
+        ("scalar", 1, "self-conjugate", 0.0),
+        ("fermion", 2, "particle", 0.0),
+        ("fermion", 2, "antiparticle", 0.0),
+        ("fermion", 4, "particle", 2.0),
+        ("fermion", 4, "antiparticle", 2.0),
+        ("vector", 4, "self-conjugate", 0.0),
+        ("vector", 4, "self-conjugate", 2.0),
+        ("spin2", 16, "self-conjugate", 2.0),
+    ] {
+        let mut source = source_record(900, -900, orientation, family, dimension);
+        source.leg_label = 2;
+        for helicity in [-1, 1] {
+            for chirality in [-1, 1] {
+                let state = GenericSourceStateIrManifest {
+                    helicity,
+                    chirality,
+                    spin_state: GenericSourceSpinStateManifest::Scalar(helicity),
+                };
+                for phase in [[1.0, 0.0], [0.0, 1.0], [0.6, -0.8]] {
+                    source.applied_crossing.phase = phase;
+                    for transform in [
+                        GenericMomentumTransformManifest::Identity,
+                        GenericMomentumTransformManifest::NegateFourMomentum,
+                    ] {
+                        source.applied_crossing.momentum_transform = transform;
+                        // Re-resolve changed masses, just as each compiled tile does.
+                        for mass in [mass, mass * 1.5] {
+                            let masses = BTreeMap::from([(-900, mass)]);
+                            let resolved = sources::ResolvedSourceWavefunction::new(
+                                &source,
+                                &state,
+                                external_count,
+                                &masses,
+                                dimension,
+                            )
+                            .unwrap();
+                            for lookup in [None, Some(crossing.as_slice())] {
+                                let contiguous =
+                                    F64MomentumBatchView::from_contiguous_prevalidated(
+                                        &flat,
+                                        3,
+                                        external_count,
+                                        lookup,
+                                    )
+                                    .unwrap();
+                                let nested = contiguous.materialize_nested();
+                                let nested_view =
+                                    F64MomentumBatchView::from_nested(&nested, external_count)
+                                        .unwrap();
+                                for batch in [contiguous, nested_view] {
+                                    for (start, stop) in [(0, 3), (1, 2)] {
+                                        let batch = batch.subview(start, stop).unwrap();
+                                        for point_index in 0..batch.point_count() {
+                                            let point = batch.point(point_index);
+                                            let mut momentum = point.momentum(1).unwrap();
+                                            if transform == GenericMomentumTransformManifest::NegateFourMomentum {
+                                                momentum = negate(momentum);
+                                            }
+                                            let mut expected =
+                                                match (family, dimension, orientation) {
+                                                    ("scalar", _, _) => vec![c64(1.0, 0.0)],
+                                                    ("fermion", 2, "particle") => {
+                                                        ext_quark_weyl_array(
+                                                            momentum, helicity, chirality,
+                                                        )
+                                                        .to_vec()
+                                                    }
+                                                    ("fermion", 2, _) => ext_antiquark_weyl_array(
+                                                        momentum, helicity, chirality,
+                                                    )
+                                                    .to_vec(),
+                                                    ("fermion", 4, "particle") => {
+                                                        ext_quark_dirac_massive(
+                                                            momentum, helicity, mass,
+                                                        )
+                                                        .to_vec()
+                                                    }
+                                                    ("fermion", 4, _) => {
+                                                        ext_antiquark_dirac_massive(
+                                                            momentum, helicity, mass,
+                                                        )
+                                                        .to_vec()
+                                                    }
+                                                    ("vector", _, _) if mass == 0.0 => {
+                                                        ext_gluon(momentum, helicity).to_vec()
+                                                    }
+                                                    ("vector", _, _) => {
+                                                        ext_massive_vector(momentum, helicity, mass)
+                                                            .to_vec()
+                                                    }
+                                                    ("spin2", _, _) => {
+                                                        ext_spin2(momentum, helicity, mass)
+                                                            .unwrap()
+                                                            .to_vec()
+                                                    }
+                                                    _ => unreachable!(),
+                                                };
+                                            if phase != [1.0, 0.0] {
+                                                for value in &mut expected {
+                                                    *value *= c64(phase[0], phase[1]);
+                                                }
+                                            }
+                                            let mut observed =
+                                                vec![c64(17.0, -19.0); dimension + 2];
+                                            resolved
+                                                .write(&point, &mut observed[..dimension])
+                                                .unwrap();
+                                            for (observed, expected) in
+                                                observed.iter().zip(expected)
+                                            {
+                                                assert_eq!(
+                                                    observed.re.to_bits(),
+                                                    expected.re.to_bits()
+                                                );
+                                                assert_eq!(
+                                                    observed.im.to_bits(),
+                                                    expected.im.to_bits()
+                                                );
+                                            }
+                                            assert!(
+                                                observed[dimension..]
+                                                    .iter()
+                                                    .all(|&v| v == c64(17.0, -19.0))
+                                            );
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn resolved_source_inputs_reject_invalid_metadata_and_absent_points() {
+    let mut source = source_record(25, 25, "self-conjugate", "scalar", 1);
+    let state = ExecutionRuntime::default_runtime_source_state(&source).unwrap();
+    let masses = BTreeMap::new();
+    assert!(sources::ResolvedSourceWavefunction::new(&source, &state, 1, &masses, 2).is_err());
+    source.leg_label = 0;
+    assert!(sources::ResolvedSourceWavefunction::new(&source, &state, 1, &masses, 1).is_err());
+    source.leg_label = 2;
+    assert!(sources::ResolvedSourceWavefunction::new(&source, &state, 1, &masses, 1).is_err());
+    source.leg_label = 1;
+    source.source_kind = "unsupported".to_owned();
+    assert!(sources::ResolvedSourceWavefunction::new(&source, &state, 1, &masses, 1).is_err());
+    source.source_kind = "external-wavefunction".to_owned();
+    source.source_ir.component_dimension = 3;
+    assert!(sources::ResolvedSourceWavefunction::new(&source, &state, 1, &masses, 3).is_err());
+    source.source_ir.component_dimension = 1;
+    let resolved =
+        sources::ResolvedSourceWavefunction::new(&source, &state, 1, &masses, 1).unwrap();
+    let mut output = [c64(17.0, -19.0)];
+    assert!(
+        resolved
+            .write(&Vec::<[f64; 4]>::new(), &mut output)
+            .is_err()
+    );
+    assert_eq!(output, [c64(17.0, -19.0)]);
+}
+
+fn crossing_value(
+    momentum_transform: &str,
+    helicity_factor: i32,
+    chirality_factor: i32,
+    spin_state_factor: i32,
+) -> Value {
+    json!({
+        "momentum_transform": momentum_transform,
+        "helicity_factor": helicity_factor,
+        "chirality_factor": chirality_factor,
+        "spin_state_factor": spin_state_factor,
+        "phase": [1.0, 0.0],
+    })
+}
+
+fn source_value(
+    particle_id: i32,
+    anti_particle_id: i32,
+    source_orientation: &str,
+    wavefunction_kind: &str,
+    dimension: usize,
+) -> Value {
+    let basis = match (wavefunction_kind, dimension) {
+        ("fermion", 2) => "weyl-chiral",
+        ("fermion", 4) => "dirac",
+        ("scalar", _) => "scalar",
+        ("vector", _) => "lorentz-vector",
+        ("spin2", _) => "lorentz-tensor-rank2",
+        _ => "test-basis",
+    };
+    let statistics = if wavefunction_kind == "fermion" {
+        "fermion"
+    } else {
+        "boson"
+    };
+    let chirality = if wavefunction_kind == "fermion" { 1 } else { 0 };
+    let identity_crossing = crossing_value("identity", 1, 1, 1);
+    json!({
+        "source_id": 0,
+        "current_id": 0,
+        "current_component_start": 0,
+        "current_component_stop": dimension,
+        "value_slot": {
+            "value_slot_id": 0,
+            "current_id": 0,
+            "variant": "source",
+            "component_start": 0,
+            "component_stop": dimension,
+            "dimension": dimension,
+        },
+        "source_parameter_start": 0,
+        "source_parameter_stop": dimension,
+        "leg_label": 1,
+        "input_momentum_slot": 0,
+        "side": "final",
+        "crossing": "identity",
+        "physical_pdg": particle_id,
+        "outgoing_pdg": particle_id,
+        "particle_id": particle_id,
+        "anti_particle_id": anti_particle_id,
+        "source_kind": "external-wavefunction",
+        "wavefunction_kind": wavefunction_kind,
+        "source_orientation": source_orientation,
+        "source_basis": basis,
+        "source_ir": {
+            "identity": {
+                "canonical_id": format!("model:test:state:{particle_id}"),
+                "species_id": format!("model:test:species:{}", particle_id.abs()),
+                "anti_canonical_id": format!("model:test:state:{anti_particle_id}"),
+                "display_name": format!("state_{particle_id}"),
+                "anti_display_name": format!("state_{anti_particle_id}"),
+                "pdg_label": particle_id,
+                "anti_pdg_label": anti_particle_id,
+                "orientation": source_orientation,
+                "self_conjugate": particle_id == anti_particle_id,
+            },
+            "statistics": statistics,
+            "wavefunction_family": wavefunction_kind,
+            "component_dimension": dimension,
+            "states": [{"helicity": 1, "chirality": chirality, "spin_state": 1}],
+            "crossing": identity_crossing,
+            "basis": basis,
+            "mass_parameter": null,
+            "width_parameter": null,
+        },
+        "applied_crossing": crossing_value("identity", 1, 1, 1),
+        "source_helicity": 1,
+        "chirality": chirality,
+        "spin_state": 1,
+        "dimension": dimension,
+        "helicity_ancestry": 1,
+        "color_state": {},
+    })
+}
+
+fn initial_crossed_source_value(
+    particle_id: i32,
+    anti_particle_id: i32,
+    source_orientation: &str,
+) -> Value {
+    let mut source = source_value(
+        particle_id,
+        anti_particle_id,
+        source_orientation,
+        "fermion",
+        2,
+    );
+    let crossing = crossing_value("negate-four-momentum", 1, -1, -1);
+    source["side"] = json!("initial");
+    source["crossing"] = json!("negate-incoming-momentum");
+    source["source_ir"]["crossing"] = crossing.clone();
+    source["applied_crossing"] = crossing;
+    source["chirality"] = json!(-1);
+    source["spin_state"] = json!(-1);
+    source
+}
+
+fn source_record(
+    particle_id: i32,
+    anti_particle_id: i32,
+    source_orientation: &str,
+    wavefunction_kind: &str,
+    dimension: usize,
+) -> GenericSourceRecordManifest {
+    serde_json::from_value(source_value(
+        particle_id,
+        anti_particle_id,
+        source_orientation,
+        wavefunction_kind,
+        dimension,
+    ))
+    .expect("source manifest record")
+}
+
+#[test]
+fn runtime_source_state_selects_declared_helicity_and_applies_factor() {
+    let mut value = source_value(21, 21, "self-conjugate", "vector", 4);
+    value["source_ir"]["states"] = json!([
+        {"helicity": 1, "chirality": 0, "spin_state": 1},
+        {"helicity": -1, "chirality": 0, "spin_state": -1},
+    ]);
+    let source: GenericSourceRecordManifest =
+        serde_json::from_value(value).expect("runtime-selectable vector source");
+    let runtime_state = ExecutionRuntime::runtime_source_state(&source, 1, c64(0.0, 1.0))
+        .expect("declared runtime source state");
+    assert_eq!(runtime_state.state.helicity, -1);
+
+    let point = [[10.0, 2.0, 1.0, 9.746_794_344_808_963]];
+    let masses = BTreeMap::new();
+    let mut raw = vec![c64(0.0, 0.0); 4];
+    ExecutionRuntime::write_source_wavefunction_with_state(
+        &source,
+        &runtime_state.state,
+        1,
+        &masses,
+        &point,
+        &mut raw,
+    )
+    .expect("raw selected source");
+    let mut factored = vec![c64(0.0, 0.0); 4];
+    ExecutionRuntime::fill_sources_row_with_states(
+        std::slice::from_ref(&source),
+        std::slice::from_ref(&runtime_state),
+        1,
+        &masses,
+        &mut factored,
+        &point,
+    )
+    .expect("factored selected source");
+    for (raw_component, factored_component) in raw.iter().zip(&factored) {
+        assert_eq!(*factored_component, *raw_component * c64(0.0, 1.0));
+    }
+}
+
+#[test]
+fn inactive_runtime_source_state_zero_fills_its_slot() {
+    let source = source_record(21, 21, "self-conjugate", "vector", 4);
+    let runtime_state = ExecutionRuntime::inactive_runtime_source_state(&source)
+        .expect("inactive runtime source state");
+    let point = [[10.0, 2.0, 1.0, 9.746_794_344_808_963]];
+    let masses = BTreeMap::new();
+    let mut row = vec![c64(7.0, -3.0); 4];
+    ExecutionRuntime::fill_sources_row_with_states(
+        std::slice::from_ref(&source),
+        std::slice::from_ref(&runtime_state),
+        1,
+        &masses,
+        &mut row,
+        &point,
+    )
+    .expect("zero-filled inactive source");
+    assert!(row.iter().all(|value| *value == c64(0.0, 0.0)));
+}
+
+#[test]
+fn runtime_source_helicity_lookup_is_exact_and_rejects_ambiguity() {
+    let mut value = source_value(21, 21, "self-conjugate", "vector", 4);
+    value["source_ir"]["states"] = json!([
+        {"helicity": 1, "chirality": 0, "spin_state": 1},
+        {"helicity": -1, "chirality": 0, "spin_state": -1},
+    ]);
+    let source: GenericSourceRecordManifest =
+        serde_json::from_value(value.clone()).expect("runtime-selectable vector source");
+    assert_eq!(
+        ExecutionRuntime::runtime_source_state_index_for_helicity(&source, 1).unwrap(),
+        Some(0)
+    );
+    assert_eq!(
+        ExecutionRuntime::runtime_source_state_index_for_helicity(&source, -1).unwrap(),
+        Some(1)
+    );
+    assert_eq!(
+        ExecutionRuntime::runtime_source_state_index_for_helicity(&source, 0).unwrap(),
+        None
+    );
+
+    value["source_ir"]["states"] = json!([
+        {"helicity": 1, "chirality": -1, "spin_state": -1},
+        {"helicity": 1, "chirality": 1, "spin_state": 1},
+    ]);
+    let ambiguous: GenericSourceRecordManifest =
+        serde_json::from_value(value).expect("same-helicity source states");
+    assert!(
+        ExecutionRuntime::runtime_source_state_index_for_helicity(&ambiguous, 1)
+            .unwrap_err()
+            .to_string()
+            .contains("multiple runtime states")
+    );
+}
+
+#[test]
+fn source_manifest_requires_typed_source_and_crossing_records() {
+    for field in ["source_ir", "applied_crossing"] {
+        let mut missing = source_value(810_001, -810_001, "particle", "fermion", 2);
+        missing
+            .as_object_mut()
+            .expect("source object")
+            .remove(field);
+
+        let error = serde_json::from_value::<GenericSourceRecordManifest>(missing).unwrap_err();
+
+        assert!(error.to_string().contains(field));
+    }
+}
+
+#[test]
+fn source_manifest_requires_complete_strict_source_ir() {
+    let mut missing_orientation = source_value(810_001, -810_001, "particle", "fermion", 2);
+    missing_orientation["source_ir"]["identity"]
+        .as_object_mut()
+        .expect("identity object")
+        .remove("orientation");
+    let error =
+        serde_json::from_value::<GenericSourceRecordManifest>(missing_orientation).unwrap_err();
+    assert!(error.to_string().contains("orientation"));
+
+    let mut missing_nullable = source_value(810_001, -810_001, "particle", "fermion", 2);
+    missing_nullable["source_ir"]
+        .as_object_mut()
+        .expect("SourceIR object")
+        .remove("mass_parameter");
+    let error =
+        serde_json::from_value::<GenericSourceRecordManifest>(missing_nullable).unwrap_err();
+    assert!(error.to_string().contains("mass_parameter"));
+
+    let mut unknown = source_value(810_001, -810_001, "particle", "fermion", 2);
+    unknown["source_ir"]["identity"]["taxonomy"] = json!("sm-fermion");
+    let error = serde_json::from_value::<GenericSourceRecordManifest>(unknown).unwrap_err();
+    assert!(error.to_string().contains("unknown field"));
+}
+
+#[test]
+fn pre_source_ir_schema_v3_reports_actionable_regeneration_error() {
+    let mut missing = source_value(810_001, -810_001, "particle", "fermion", 2);
+    missing.as_object_mut().unwrap().remove("source_ir");
+    let parse_error = serde_json::from_value::<GenericSourceRecordManifest>(missing).unwrap_err();
+
+    let error = execution_manifest_parse_error("processes/example/execution.json", parse_error);
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+    assert!(error.to_string().contains("typed source metadata"));
+    assert!(error.to_string().contains("regenerate"));
+}
+
+#[test]
+fn repeated_source_records_must_share_one_canonical_source_ir() {
+    let first = source_record(810_001, -810_001, "particle", "fermion", 2);
+    let mut second = source_record(810_001, -810_001, "particle", "fermion", 2);
+    second.source_id = 1;
+    second.current_id = 1;
+    second.source_ir.crossing.phase = [0.0, 1.0];
+    let mut canonical_by_slot = BTreeMap::new();
+    let mut canonical_by_identity = BTreeMap::new();
+
+    validate_consistent_source_ir(
+        &mut canonical_by_slot,
+        &mut canonical_by_identity,
+        0,
+        &first,
+    )
+    .expect("first source is canonical");
+    let error = validate_consistent_source_ir(
+        &mut canonical_by_slot,
+        &mut canonical_by_identity,
+        1,
+        &second,
+    )
+    .unwrap_err();
+
+    assert!(error.to_string().contains("canonical SourceIR"));
+    assert!(error.to_string().contains("momentum slot"));
+}
+
+#[test]
+fn separate_legs_share_one_source_ir_per_oriented_particle() {
+    let first = source_record(810_001, -810_001, "particle", "fermion", 2);
+    let mut second = source_record(810_001, -810_001, "particle", "fermion", 2);
+    second.source_id = 1;
+    second.current_id = 1;
+    second.input_momentum_slot = 1;
+    second.source_ir.crossing.phase = [0.0, 1.0];
+    let mut canonical_by_slot = BTreeMap::new();
+    let mut canonical_by_identity = BTreeMap::new();
+
+    validate_consistent_source_ir(
+        &mut canonical_by_slot,
+        &mut canonical_by_identity,
+        0,
+        &first,
+    )
+    .expect("first source is canonical");
+    let error = validate_consistent_source_ir(
+        &mut canonical_by_slot,
+        &mut canonical_by_identity,
+        1,
+        &second,
+    )
+    .unwrap_err();
+
+    assert!(error.to_string().contains("canonical SourceIR"));
+    assert!(error.to_string().contains("oriented particle"));
+}
+
+#[test]
+fn represented_antiparticle_identities_must_form_an_involution() {
+    let particle = source_record(810_001, -810_001, "particle", "fermion", 2);
+    let mut antiparticle = source_record(-810_001, 810_001, "antiparticle", "fermion", 2);
+    antiparticle.source_id = 1;
+    antiparticle.current_id = 1;
+    antiparticle.input_momentum_slot = 1;
+    let mut canonical_by_slot = BTreeMap::new();
+    let mut canonical_by_identity = BTreeMap::new();
+
+    validate_consistent_source_ir(
+        &mut canonical_by_slot,
+        &mut canonical_by_identity,
+        0,
+        &particle,
+    )
+    .expect("particle source is valid");
+    validate_consistent_source_ir(
+        &mut canonical_by_slot,
+        &mut canonical_by_identity,
+        1,
+        &antiparticle,
+    )
+    .expect("valid antiparticle relation is accepted");
+
+    let mut inconsistent = antiparticle;
+    inconsistent.source_ir.identity.species_id = "model:test:species:other".to_string();
+    let mut canonical_by_slot = BTreeMap::new();
+    let mut canonical_by_identity = BTreeMap::new();
+    validate_consistent_source_ir(
+        &mut canonical_by_slot,
+        &mut canonical_by_identity,
+        0,
+        &particle,
+    )
+    .expect("particle source is valid");
+    let error = validate_consistent_source_ir(
+        &mut canonical_by_slot,
+        &mut canonical_by_identity,
+        1,
+        &inconsistent,
+    )
+    .unwrap_err();
+
+    assert!(error.to_string().contains("non-involutive"));
+}
+
+#[test]
+fn source_manifest_validation_rejects_self_conjugate_fermions() {
+    let source = source_record(810_001, 810_001, "self-conjugate", "fermion", 2);
+
+    let error = validate_source_wavefunction_metadata(0, &source).unwrap_err();
+
+    assert!(
+        error
+            .to_string()
+            .contains("unsupported self-conjugate fermion source")
+    );
+}
+
+#[test]
+fn source_manifest_validation_rejects_family_dimension_mismatches() {
+    let source = source_record(910_101, 910_101, "self-conjugate", "vector", 2);
+
+    let error = validate_source_wavefunction_metadata(0, &source).unwrap_err();
+
+    assert!(error.to_string().contains("wavefunction kind \"vector\""));
+}
+
+#[test]
+fn source_manifest_validation_checks_flattened_projections() {
+    let mut value = source_value(810_001, -810_001, "particle", "fermion", 2);
+    value["wavefunction_kind"] = json!("scalar");
+    let source = serde_json::from_value(value).expect("source manifest record");
+
+    let error = validate_source_wavefunction_metadata(0, &source).unwrap_err();
+
+    assert!(error.to_string().contains("\"wavefunction_kind\""));
+}
+
+#[test]
+fn source_manifest_validation_checks_statistics_against_family() {
+    let mut value = source_value(810_001, -810_001, "particle", "fermion", 2);
+    value["source_ir"]["statistics"] = json!("boson");
+    let source = serde_json::from_value(value).expect("source manifest record");
+
+    let error = validate_source_wavefunction_metadata(0, &source).unwrap_err();
+
+    assert!(error.to_string().contains("statistics disagree"));
+}
+
+#[test]
+fn source_manifest_validation_enforces_side_dependent_crossing() {
+    let mut final_value = source_value(810_001, -810_001, "particle", "fermion", 2);
+    final_value["crossing"] = json!("negate-incoming-momentum");
+    final_value["applied_crossing"] = crossing_value("negate-four-momentum", 1, 1, 1);
+    let final_source = serde_json::from_value(final_value).expect("final source record");
+    let error = validate_source_wavefunction_metadata(0, &final_source).unwrap_err();
+    assert!(error.to_string().contains("final-state applied crossing"));
+
+    let mut initial_value = initial_crossed_source_value(810_001, -810_001, "particle");
+    initial_value["crossing"] = json!("identity");
+    initial_value["applied_crossing"] = crossing_value("identity", 1, 1, 1);
+    let initial_source = serde_json::from_value(initial_value).expect("initial source record");
+    let error = validate_source_wavefunction_metadata(0, &initial_source).unwrap_err();
+    assert!(error.to_string().contains("declared SourceIR crossing"));
+}
+
+#[test]
+fn source_manifest_validation_checks_crossed_current_state() {
+    let mut value = initial_crossed_source_value(810_001, -810_001, "particle");
+    value["chirality"] = json!(1);
+    let source = serde_json::from_value(value).expect("initial source record");
+
+    let error = validate_source_wavefunction_metadata(0, &source).unwrap_err();
+
+    assert!(error.to_string().contains("current state is not declared"));
+}
+
+#[test]
+fn source_manifest_validation_rejects_zero_and_nonfinite_crossing_phases() {
+    for phase in [[0.0, 0.0], [f64::INFINITY, 0.0]] {
+        let mut source: GenericSourceRecordManifest =
+            serde_json::from_value(initial_crossed_source_value(810_001, -810_001, "particle"))
+                .expect("initial source record");
+        source.source_ir.crossing.phase = phase;
+        source.applied_crossing.phase = phase;
+
+        let error = validate_source_wavefunction_metadata(0, &source).unwrap_err();
+
+        assert!(error.to_string().contains("invalid declared CrossingIR"));
+    }
+}
+
+#[test]
+fn f64_sources_use_typed_orientation_instead_of_flattened_metadata() {
+    let mut source = source_record(810_001, -810_001, "antiparticle", "fermion", 2);
+    source.source_orientation = GenericSourceOrientationManifest::Particle;
+    let point = [[5.0, 3.0, 4.0, 0.0]];
+    let mut output = [c64(0.0, 0.0); 2];
+
+    ExecutionRuntime::write_source_wavefunction(&source, 1, &BTreeMap::new(), &point, &mut output)
+        .expect("evaluate relabeled antiparticle source");
+
+    assert_eq!(output, ext_antiquark_weyl_array(point[0], 1, 1));
+    assert_ne!(output, ext_quark_weyl_array(point[0], 1, 1));
+}
+
+#[test]
+fn f64_sources_use_typed_family_dimension_and_pdg_relation() {
+    let mut source = source_record(810_001, 910_002, "particle", "vector", 4);
+    source.wavefunction_kind = "scalar".to_owned();
+    source.dimension = 1;
+    source.particle_id = -810_001;
+    source.anti_particle_id = -810_001;
+    let point = [[13.0, 0.0, 0.0, 12.0]];
+    let masses = BTreeMap::from([(-810_001, 99.0), (910_002, 5.0)]);
+    let mut output = [c64(0.0, 0.0); 4];
+
+    ExecutionRuntime::write_source_wavefunction(&source, 1, &masses, &point, &mut output)
+        .expect("evaluate source with typed SourceIR metadata");
+
+    assert_eq!(output, ext_massive_vector(point[0], 1, 5.0));
+}
+
+#[test]
+fn f64_sources_use_applied_crossing_momentum_transform() {
+    let mut source: GenericSourceRecordManifest =
+        serde_json::from_value(initial_crossed_source_value(810_001, -810_001, "particle"))
+            .expect("initial source record");
+    source.crossing = "identity".to_owned();
+    let point = [[5.0, 3.0, 4.0, 0.0]];
+    let mut output = [c64(0.0, 0.0); 2];
+
+    ExecutionRuntime::write_source_wavefunction(&source, 1, &BTreeMap::new(), &point, &mut output)
+        .expect("evaluate crossed source");
+
+    assert_eq!(output, ext_quark_weyl_array(negate(point[0]), 1, -1));
+}
+
+#[test]
+fn f64_sources_apply_nontrivial_crossing_phase_to_every_component() {
+    let mut value = initial_crossed_source_value(810_001, -810_001, "particle");
+    value["source_ir"]["crossing"]["phase"] = json!([0.5, -0.25]);
+    value["applied_crossing"]["phase"] = json!([0.5, -0.25]);
+    let source: GenericSourceRecordManifest =
+        serde_json::from_value(value).expect("phased initial source record");
+    validate_source_wavefunction_metadata(0, &source).expect("valid nontrivial phase");
+    let point = [[5.0, 3.0, 4.0, 0.0]];
+    let mut output = [c64(0.0, 0.0); 2];
+
+    ExecutionRuntime::write_source_wavefunction(&source, 1, &BTreeMap::new(), &point, &mut output)
+        .expect("evaluate phased source");
+
+    let phase = c64(0.5, -0.25);
+    let expected = ext_quark_weyl_array(negate(point[0]), 1, -1).map(|component| component * phase);
+    assert_eq!(output, expected);
+}
+
+#[cfg(feature = "symbolica-runtime")]
+#[test]
+fn high_precision_sources_use_typed_orientation_crossing_and_phase() {
+    let mut source: GenericSourceRecordManifest = serde_json::from_value(
+        initial_crossed_source_value(810_001, -810_001, "antiparticle"),
+    )
+    .expect("initial source record");
+    source.source_orientation = GenericSourceOrientationManifest::Particle;
+    source.crossing = "identity".to_owned();
+    source.source_ir.crossing.phase = [0.5, -0.25];
+    source.applied_crossing.phase = [0.5, -0.25];
+    let point = [[
+        DoubleFloat::from(5.0),
+        DoubleFloat::from(3.0),
+        DoubleFloat::from(4.0),
+        DoubleFloat::from(0.0),
+    ]];
+    let zero = || Complex::new(DoubleFloat::from(0.0), DoubleFloat::from(0.0));
+    let mut output = vec![zero(), zero()];
+
+    ExecutionRuntime::write_source_wavefunction_generic(
+        &source,
+        1,
+        &BTreeMap::new(),
+        &point,
+        &mut output,
+    )
+    .expect("evaluate high-precision crossed antiparticle source");
+
+    let momentum = negate_generic(&point[0]);
+    let phase = c_generic(DoubleFloat::from(0.5), DoubleFloat::from(-0.25));
+    let expected = ext_antiquark_weyl_generic(&momentum, 1, -1)
+        .into_iter()
+        .map(|component| component * phase)
+        .collect::<Vec<_>>();
+    let unexpected = ext_quark_weyl_generic(&momentum, 1, -1)
+        .into_iter()
+        .map(|component| component * phase)
+        .collect::<Vec<_>>();
+    assert_eq!(output, expected);
+    assert_ne!(output, unexpected);
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/sources.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/sources.rs
new file mode 100644
index 0000000000..0a9e1f342e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/sources.rs
@@ -0,0 +1,814 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+#[derive(Clone, Debug)]
+pub(super) struct RuntimeSourceState {
+    pub(super) state: GenericSourceStateIrManifest,
+    pub(super) factor: Complex<f64>,
+}
+
+#[derive(Clone, Copy)]
+enum ResolvedSourceKind {
+    Scalar,
+    Weyl { antiparticle: bool },
+    Dirac { antiparticle: bool, mass: f64 },
+    MasslessVector,
+    MassiveVector { mass: f64 },
+    Spin2 { mass: f64 },
+}
+
+/// Resolve the already-generated SourceIR once for a source's point loop.
+/// Masses are read at this boundary, so parameter changes apply to the next
+/// tile without a new process plan or a second set of wavefunction formulas.
+pub(super) struct ResolvedSourceWavefunction<'a> {
+    source: &'a GenericSourceRecordManifest,
+    state: &'a GenericSourceStateIrManifest,
+    external_index: usize,
+    kind: ResolvedSourceKind,
+}
+
+impl<'a> ResolvedSourceWavefunction<'a> {
+    #[inline]
+    pub(super) fn new(
+        source: &'a GenericSourceRecordManifest,
+        state: &'a GenericSourceStateIrManifest,
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        output_len: usize,
+    ) -> RusticolResult<Self> {
+        if source.source_kind != "external-wavefunction" {
+            return Err(RusticolError::invalid_argument(format!(
+                "generic source kind {:?} is not implemented",
+                source.source_kind
+            )));
+        }
+        let external_index = source.leg_label.checked_sub(1).ok_or_else(|| {
+            RusticolError::invalid_argument("generic source leg labels are one-based")
+        })?;
+        if external_index >= external_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "generic source {} refers to unknown external label {}",
+                source.source_id, source.leg_label
+            )));
+        }
+        let family = source.source_ir.wavefunction_family;
+        let dimension = source.source_ir.component_dimension;
+        if output_len != dimension {
+            return Err(RusticolError::invalid_argument(format!(
+                "generic source {} expected dimension {} but slot has length {}",
+                source.source_id, dimension, output_len
+            )));
+        }
+        let mass = || {
+            particle_mass_from_map(
+                particle_masses,
+                source.source_ir.identity.pdg_label,
+                source.source_ir.identity.anti_pdg_label,
+            )
+        };
+        let kind = match (family, dimension) {
+            (GenericWavefunctionFamilyManifest::Scalar, 1) => ResolvedSourceKind::Scalar,
+            (GenericWavefunctionFamilyManifest::Fermion, 2) => ResolvedSourceKind::Weyl {
+                antiparticle: source_is_antiparticle(source)?,
+            },
+            (GenericWavefunctionFamilyManifest::Fermion, 4) => ResolvedSourceKind::Dirac {
+                antiparticle: source_is_antiparticle(source)?,
+                mass: mass(),
+            },
+            (GenericWavefunctionFamilyManifest::Vector, 4) => match mass() {
+                0.0 => ResolvedSourceKind::MasslessVector,
+                mass => ResolvedSourceKind::MassiveVector { mass },
+            },
+            (GenericWavefunctionFamilyManifest::Spin2, 16) => {
+                ResolvedSourceKind::Spin2 { mass: mass() }
+            }
+            _ => return Err(unsupported_source_wavefunction(source)),
+        };
+        Ok(Self {
+            source,
+            state,
+            external_index,
+            kind,
+        })
+    }
+
+    #[inline]
+    pub(super) fn write<P>(&self, point: &P, out: &mut [Complex<f64>]) -> RusticolResult<()>
+    where
+        P: F64MomentumPoint + ?Sized,
+    {
+        debug_assert_eq!(out.len(), self.source.source_ir.component_dimension);
+        let input = point.momentum(self.external_index).ok_or_else(|| {
+            RusticolError::invalid_argument(format!(
+                "generic source {} refers to absent external label {}",
+                self.source.source_id, self.source.leg_label
+            ))
+        })?;
+        let momentum = match self.source.applied_crossing.momentum_transform {
+            GenericMomentumTransformManifest::Identity => input,
+            GenericMomentumTransformManifest::NegateFourMomentum => negate(input),
+        };
+        match self.kind {
+            ResolvedSourceKind::Scalar => out[0] = c64(1.0, 0.0),
+            ResolvedSourceKind::Weyl { antiparticle } => {
+                let wave = if antiparticle {
+                    ext_antiquark_weyl_array(momentum, self.state.helicity, self.state.chirality)
+                } else {
+                    ext_quark_weyl_array(momentum, self.state.helicity, self.state.chirality)
+                };
+                out.copy_from_slice(&wave);
+            }
+            ResolvedSourceKind::Dirac { antiparticle, mass } => {
+                let wave = if antiparticle {
+                    ext_antiquark_dirac_massive(momentum, self.state.helicity, mass)
+                } else {
+                    ext_quark_dirac_massive(momentum, self.state.helicity, mass)
+                };
+                out.copy_from_slice(&wave);
+            }
+            ResolvedSourceKind::MasslessVector => {
+                out.copy_from_slice(&ext_gluon(momentum, self.state.helicity));
+            }
+            ResolvedSourceKind::MassiveVector { mass } => {
+                out.copy_from_slice(&ext_massive_vector(momentum, self.state.helicity, mass));
+            }
+            ResolvedSourceKind::Spin2 { mass } => {
+                out.copy_from_slice(&ext_spin2(momentum, self.state.helicity, mass)?);
+            }
+        }
+        // Do not fold this phase into a runtime-state factor: their existing
+        // two complex multiplications have a defined floating-point order.
+        apply_source_phase_f64(&self.source.applied_crossing, out);
+        Ok(())
+    }
+}
+
+impl ExecutionRuntime {
+    pub(super) fn default_runtime_source_state(
+        source: &GenericSourceRecordManifest,
+    ) -> RusticolResult<GenericSourceStateIrManifest> {
+        default_source_state(source)
+    }
+
+    pub(super) fn fill_sources_row_with_states<P>(
+        sources: &[GenericSourceRecordManifest],
+        source_states: &[RuntimeSourceState],
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        row: &mut [Complex<f64>],
+        point: &P,
+    ) -> RusticolResult<()>
+    where
+        P: F64MomentumPoint + ?Sized,
+    {
+        if source_states.len() != sources.len() {
+            return Err(RusticolError::invalid_argument(format!(
+                "runtime source-state count {} does not match source count {}",
+                source_states.len(),
+                sources.len()
+            )));
+        }
+        for (source, runtime_state) in sources.iter().zip(source_states) {
+            let start = source.value_slot.component_start;
+            let stop = source.value_slot.component_stop;
+            if stop > row.len() || stop < start {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic source {} has an invalid value-slot range",
+                    source.source_id
+                )));
+            }
+            if runtime_state.factor == c64(0.0, 0.0) {
+                row[start..stop].fill(c64(0.0, 0.0));
+                continue;
+            }
+            Self::write_source_wavefunction_with_state(
+                source,
+                &runtime_state.state,
+                external_count,
+                particle_masses,
+                point,
+                &mut row[start..stop],
+            )?;
+            if runtime_state.factor != c64(1.0, 0.0) {
+                for component in &mut row[start..stop] {
+                    *component *= runtime_state.factor;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn fill_sources_row_generic_with_states<T>(
+        sources: &[GenericSourceRecordManifest],
+        source_states: &[RuntimeSourceState],
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        row: &mut [Complex<T>],
+        point: &[[T; 4]],
+    ) -> RusticolResult<()>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        if source_states.len() != sources.len() {
+            return Err(RusticolError::invalid_argument(format!(
+                "runtime source-state count {} does not match source count {}",
+                source_states.len(),
+                sources.len()
+            )));
+        }
+        for (source, runtime_state) in sources.iter().zip(source_states) {
+            let start = source.value_slot.component_start;
+            let stop = source.value_slot.component_stop;
+            if stop > row.len() || stop < start {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic source {} has an invalid value-slot range",
+                    source.source_id
+                )));
+            }
+            if runtime_state.factor == c64(0.0, 0.0) {
+                row[start..stop].fill(complex_zero::<T>());
+                continue;
+            }
+            Self::write_source_wavefunction_generic_with_state(
+                source,
+                &runtime_state.state,
+                external_count,
+                particle_masses,
+                point,
+                &mut row[start..stop],
+            )?;
+            if runtime_state.factor != c64(1.0, 0.0) {
+                let factor = c_generic(
+                    T::from(runtime_state.factor.re),
+                    T::from(runtime_state.factor.im),
+                );
+                for component in &mut row[start..stop] {
+                    *component *= factor.clone();
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub(super) fn runtime_source_state(
+        source: &GenericSourceRecordManifest,
+        declared_state_index: usize,
+        factor: Complex<f64>,
+    ) -> RusticolResult<RuntimeSourceState> {
+        let declared = source
+            .source_ir
+            .states
+            .get(declared_state_index)
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(format!(
+                    "generic source {} has no declared state {}",
+                    source.source_id, declared_state_index
+                ))
+            })?;
+        let state = declared
+            .transformed(&source.applied_crossing)
+            .map_err(|error| {
+                RusticolError::invalid_argument(format!(
+                    "generic source {} runtime state is invalid: {error}",
+                    source.source_id
+                ))
+            })?;
+        Ok(RuntimeSourceState { state, factor })
+    }
+
+    pub(super) fn runtime_source_state_index_for_helicity(
+        source: &GenericSourceRecordManifest,
+        helicity: i32,
+    ) -> RusticolResult<Option<usize>> {
+        let mut matching =
+            source
+                .source_ir
+                .states
+                .iter()
+                .enumerate()
+                .filter_map(|(index, state)| {
+                    state
+                        .transformed(&source.applied_crossing)
+                        .ok()
+                        .filter(|state| state.helicity == helicity)
+                        .map(|_| index)
+                });
+        let result = matching.next();
+        if matching.next().is_some() {
+            return Err(RusticolError::artifact(format!(
+                "generic source {} declares multiple runtime states for helicity {}",
+                source.source_id, helicity
+            )));
+        }
+        Ok(result)
+    }
+
+    pub(super) fn inactive_runtime_source_state(
+        source: &GenericSourceRecordManifest,
+    ) -> RusticolResult<RuntimeSourceState> {
+        Ok(RuntimeSourceState {
+            state: default_source_state(source)?,
+            factor: c64(0.0, 0.0),
+        })
+    }
+
+    pub(super) fn fill_sources_row<P>(
+        sources: &[GenericSourceRecordManifest],
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        row: &mut [Complex<f64>],
+        point: &P,
+    ) -> RusticolResult<()>
+    where
+        P: F64MomentumPoint + ?Sized,
+    {
+        for source in sources {
+            let start = source.value_slot.component_start;
+            let stop = source.value_slot.component_stop;
+            if stop > row.len() || stop < start {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic source {} has an invalid value-slot range",
+                    source.source_id
+                )));
+            }
+            Self::write_source_wavefunction(
+                source,
+                external_count,
+                particle_masses,
+                point,
+                &mut row[start..stop],
+            )?;
+        }
+        Ok(())
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn fill_sources_row_generic<T>(
+        sources: &[GenericSourceRecordManifest],
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        row: &mut [Complex<T>],
+        point: &[[T; 4]],
+    ) -> RusticolResult<()>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        for source in sources {
+            let start = source.value_slot.component_start;
+            let stop = source.value_slot.component_stop;
+            if stop > row.len() || stop < start {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic source {} has an invalid value-slot range",
+                    source.source_id
+                )));
+            }
+            Self::write_source_wavefunction_generic(
+                source,
+                external_count,
+                particle_masses,
+                point,
+                &mut row[start..stop],
+            )?;
+        }
+        Ok(())
+    }
+
+    pub(super) fn fill_momenta_row<P>(
+        momentum_slots: &[GenericMomentumSlotManifest],
+        value_parameter_count: usize,
+        external_count: usize,
+        external_is_initial: &[bool],
+        row: &mut [Complex<f64>],
+        point: &P,
+    ) -> RusticolResult<()>
+    where
+        P: F64MomentumPoint + ?Sized,
+    {
+        for slot in momentum_slots {
+            let start = value_parameter_count + slot.component_start;
+            let stop = value_parameter_count + slot.component_stop;
+            if stop > row.len() || stop < start || stop - start != 4 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic momentum slot {} has an invalid component range",
+                    slot.momentum_slot_id
+                )));
+            }
+            let mut momentum = [0.0; 4];
+            for label in &slot.external_labels {
+                let index = label.checked_sub(1).ok_or_else(|| {
+                    RusticolError::invalid_argument("generic momentum labels are one-based")
+                })?;
+                if index >= external_count || index >= external_is_initial.len() {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "generic momentum slot {} refers to unknown external label {}",
+                        slot.momentum_slot_id, label
+                    )));
+                }
+                let sign = if external_is_initial[index] {
+                    -1.0
+                } else {
+                    1.0
+                };
+                let point_momentum = point.momentum(index).ok_or_else(|| {
+                    RusticolError::invalid_argument(format!(
+                        "generic momentum slot {} refers to absent external label {}",
+                        slot.momentum_slot_id, label
+                    ))
+                })?;
+                for (momentum_component, point_component) in momentum.iter_mut().zip(point_momentum)
+                {
+                    *momentum_component += sign * point_component;
+                }
+            }
+            for (output, component) in row[start..stop].iter_mut().zip(momentum) {
+                *output = c64(component, 0.0);
+            }
+        }
+        Ok(())
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn fill_momenta_row_generic<T>(
+        momentum_slots: &[GenericMomentumSlotManifest],
+        value_parameter_count: usize,
+        external_count: usize,
+        external_is_initial: &[bool],
+        row: &mut [Complex<T>],
+        point: &[[T; 4]],
+    ) -> RusticolResult<()>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        for slot in momentum_slots {
+            let start = value_parameter_count + slot.component_start;
+            let stop = value_parameter_count + slot.component_stop;
+            if stop > row.len() || stop < start || stop - start != 4 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic momentum slot {} has an invalid component range",
+                    slot.momentum_slot_id
+                )));
+            }
+            let mut momentum: [T; 4] = std::array::from_fn(|_| T::new_zero());
+            for label in &slot.external_labels {
+                let index = label.checked_sub(1).ok_or_else(|| {
+                    RusticolError::invalid_argument("generic momentum labels are one-based")
+                })?;
+                if index >= external_count || index >= external_is_initial.len() {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "generic momentum slot {} refers to unknown external label {}",
+                        slot.momentum_slot_id, label
+                    )));
+                }
+                for (momentum_component, point_component) in momentum.iter_mut().zip(&point[index])
+                {
+                    if external_is_initial[index] {
+                        *momentum_component -= point_component.clone();
+                    } else {
+                        *momentum_component += point_component.clone();
+                    }
+                }
+            }
+            for (output, component) in row[start..stop].iter_mut().zip(momentum) {
+                *output = c_generic(component, T::new_zero());
+            }
+        }
+        Ok(())
+    }
+
+    pub(super) fn fill_model_parameters_row(
+        model_parameter_start: usize,
+        model_parameter_values: &[f64],
+        row: &mut [Complex<f64>],
+    ) -> RusticolResult<()> {
+        let stop = model_parameter_start + model_parameter_values.len();
+        if stop > row.len() {
+            return Err(RusticolError::invalid_argument(
+                "generic model-parameter block exceeds runtime row length",
+            ));
+        }
+        for (index, value) in model_parameter_values.iter().enumerate() {
+            row[model_parameter_start + index] = c64(*value, 0.0);
+        }
+        Ok(())
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn fill_model_parameters_row_generic<T>(
+        model_parameter_start: usize,
+        model_parameter_values: &[f64],
+        row: &mut [Complex<T>],
+    ) -> RusticolResult<()>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let stop = model_parameter_start + model_parameter_values.len();
+        if stop > row.len() {
+            return Err(RusticolError::invalid_argument(
+                "generic model-parameter block exceeds runtime row length",
+            ));
+        }
+        for (index, value) in model_parameter_values.iter().enumerate() {
+            row[model_parameter_start + index] = c_generic(T::from(*value), T::new_zero());
+        }
+        Ok(())
+    }
+
+    pub(super) fn write_source_wavefunction<P>(
+        source: &GenericSourceRecordManifest,
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        point: &P,
+        out: &mut [Complex<f64>],
+    ) -> RusticolResult<()>
+    where
+        P: F64MomentumPoint + ?Sized,
+    {
+        let state = default_source_state(source)?;
+        Self::write_source_wavefunction_with_state(
+            source,
+            &state,
+            external_count,
+            particle_masses,
+            point,
+            out,
+        )
+    }
+
+    pub(super) fn write_source_wavefunction_with_state<P>(
+        source: &GenericSourceRecordManifest,
+        state: &GenericSourceStateIrManifest,
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        point: &P,
+        out: &mut [Complex<f64>],
+    ) -> RusticolResult<()>
+    where
+        P: F64MomentumPoint + ?Sized,
+    {
+        ResolvedSourceWavefunction::new(source, state, external_count, particle_masses, out.len())?
+            .write(point, out)
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn write_source_wavefunction_generic<T>(
+        source: &GenericSourceRecordManifest,
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        point: &[[T; 4]],
+        out: &mut [Complex<T>],
+    ) -> RusticolResult<()>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let state = default_source_state(source)?;
+        Self::write_source_wavefunction_generic_with_state(
+            source,
+            &state,
+            external_count,
+            particle_masses,
+            point,
+            out,
+        )
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(super) fn write_source_wavefunction_generic_with_state<T>(
+        source: &GenericSourceRecordManifest,
+        state: &GenericSourceStateIrManifest,
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        point: &[[T; 4]],
+        out: &mut [Complex<T>],
+    ) -> RusticolResult<()>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        Self::write_source_wavefunction_generic_unphased(
+            source,
+            state,
+            external_count,
+            particle_masses,
+            point,
+            out,
+        )?;
+        apply_source_phase_generic(&source.applied_crossing, out);
+        Ok(())
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    fn write_source_wavefunction_generic_unphased<T>(
+        source: &GenericSourceRecordManifest,
+        state: &GenericSourceStateIrManifest,
+        external_count: usize,
+        particle_masses: &BTreeMap<i32, f64>,
+        point: &[[T; 4]],
+        out: &mut [Complex<T>],
+    ) -> RusticolResult<()>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        if source.source_kind != "external-wavefunction" {
+            return Err(RusticolError::invalid_argument(format!(
+                "generic source kind {:?} is not implemented",
+                source.source_kind
+            )));
+        }
+        let index = source.leg_label.checked_sub(1).ok_or_else(|| {
+            RusticolError::invalid_argument("generic source leg labels are one-based")
+        })?;
+        if index >= external_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "generic source {} refers to unknown external label {}",
+                source.source_id, source.leg_label
+            )));
+        }
+        let source_ir = &source.source_ir;
+        let identity = &source_ir.identity;
+        let family = source_ir.wavefunction_family;
+        let dimension = source_ir.component_dimension;
+        let momentum = match source.applied_crossing.momentum_transform {
+            GenericMomentumTransformManifest::Identity => point[index].clone(),
+            GenericMomentumTransformManifest::NegateFourMomentum => negate_generic(&point[index]),
+        };
+        if dimension == 1 && family == GenericWavefunctionFamilyManifest::Scalar {
+            if out.len() != 1 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic source {} expected dimension 1 but slot has length {}",
+                    source.source_id,
+                    out.len()
+                )));
+            }
+            out[0] = c_generic(T::from(1.0), T::new_zero());
+            return Ok(());
+        }
+        if dimension == 2 && family == GenericWavefunctionFamilyManifest::Fermion {
+            if out.len() != 2 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic source {} expected dimension 2 but slot has length {}",
+                    source.source_id,
+                    out.len()
+                )));
+            }
+            let chirality = state.chirality;
+            let wave = if source_is_antiparticle(source)? {
+                ext_antiquark_weyl_generic(&momentum, state.helicity, chirality)
+            } else {
+                ext_quark_weyl_generic(&momentum, state.helicity, chirality)
+            };
+            out.clone_from_slice(&wave);
+            return Ok(());
+        }
+        if dimension == 4 {
+            if out.len() != 4 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic source {} expected dimension 4 but slot has length {}",
+                    source.source_id,
+                    out.len()
+                )));
+            }
+            let wave = if family == GenericWavefunctionFamilyManifest::Fermion {
+                let mass = particle_mass_from_map(
+                    particle_masses,
+                    identity.pdg_label,
+                    identity.anti_pdg_label,
+                );
+                if mass != 0.0 {
+                    return Err(RusticolError::invalid_argument(
+                        "high-precision generic massive fermion sources are not implemented",
+                    ));
+                }
+                if source_is_antiparticle(source)? {
+                    ext_antiquark_dirac_generic(&momentum, state.helicity)
+                } else {
+                    ext_quark_dirac_generic(&momentum, state.helicity)
+                }
+            } else if family == GenericWavefunctionFamilyManifest::Vector {
+                let mass = particle_mass_from_map(
+                    particle_masses,
+                    identity.pdg_label,
+                    identity.anti_pdg_label,
+                );
+                if mass == 0.0 {
+                    ext_gluon_generic(&momentum, state.helicity)
+                } else {
+                    ext_massive_vector_generic(&momentum, state.helicity, T::from(mass))
+                }
+            } else {
+                return Err(unsupported_source_wavefunction(source));
+            };
+            out.clone_from_slice(&wave);
+            return Ok(());
+        }
+        if dimension == 16 && family == GenericWavefunctionFamilyManifest::Spin2 {
+            if out.len() != 16 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "generic source {} expected dimension 16 but slot has length {}",
+                    source.source_id,
+                    out.len()
+                )));
+            }
+            let wave = ext_spin2_generic(
+                &momentum,
+                state.helicity,
+                T::from(particle_mass_from_map(
+                    particle_masses,
+                    identity.pdg_label,
+                    identity.anti_pdg_label,
+                )),
+            )?;
+            out.clone_from_slice(&wave);
+            return Ok(());
+        }
+        Err(RusticolError::invalid_argument(format!(
+            "generic source kind {:?} with dimension {} is not implemented",
+            family.as_str(),
+            dimension
+        )))
+    }
+}
+
+fn default_source_state(
+    source: &GenericSourceRecordManifest,
+) -> RusticolResult<GenericSourceStateIrManifest> {
+    source
+        .source_ir
+        .states
+        .iter()
+        .filter_map(|state| state.transformed(&source.applied_crossing).ok())
+        .find(|state| {
+            state.helicity == source.source_helicity && state.chirality == source.chirality
+        })
+        .ok_or_else(|| {
+            RusticolError::invalid_argument(format!(
+                "generic source {} default state is absent from its SourceIR",
+                source.source_id
+            ))
+        })
+}
+
+fn apply_source_phase_f64(crossing: &GenericCrossingIrManifest, out: &mut [Complex<f64>]) {
+    if crossing.phase == [1.0, 0.0] {
+        return;
+    }
+    let phase = c64(crossing.phase[0], crossing.phase[1]);
+    for component in out {
+        *component *= phase;
+    }
+}
+
+#[cfg(feature = "symbolica-runtime")]
+fn apply_source_phase_generic<T>(crossing: &GenericCrossingIrManifest, out: &mut [Complex<T>])
+where
+    T: RusticolHighPrecisionNumber,
+    Complex<T>: Real + EvaluationDomain,
+{
+    if crossing.phase == [1.0, 0.0] {
+        return;
+    }
+    let phase = c_generic(T::from(crossing.phase[0]), T::from(crossing.phase[1]));
+    for component in out {
+        *component *= &phase;
+    }
+}
+
+fn source_is_antiparticle(source: &GenericSourceRecordManifest) -> RusticolResult<bool> {
+    match source.source_ir.identity.orientation {
+        GenericSourceOrientationManifest::Particle => Ok(false),
+        GenericSourceOrientationManifest::Antiparticle => Ok(true),
+        GenericSourceOrientationManifest::SelfConjugate => {
+            Err(RusticolError::invalid_argument(format!(
+                "generic source {} uses an unsupported self-conjugate fermion wavefunction",
+                source.source_id
+            )))
+        }
+    }
+}
+
+fn unsupported_source_wavefunction(source: &GenericSourceRecordManifest) -> RusticolError {
+    RusticolError::invalid_argument(format!(
+        "generic source kind {:?} with dimension {} is not implemented",
+        source.source_ir.wavefunction_family.as_str(),
+        source.source_ir.component_dimension
+    ))
+}
+
+fn particle_mass_from_map(
+    particle_masses: &BTreeMap<i32, f64>,
+    particle_id: i32,
+    anti_particle_id: i32,
+) -> f64 {
+    particle_masses
+        .get(&particle_id)
+        .copied()
+        .or_else(|| particle_masses.get(&anti_particle_id).copied())
+        .unwrap_or(0.0)
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine/validation.rs b/pyamplicol/rust/crates/rusticol-core/src/engine/validation.rs
new file mode 100644
index 0000000000..fd6f465843
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine/validation.rs
@@ -0,0 +1,2104 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+pub(super) fn load_execution_manifest_with_store(
+    manifest: ExecutionManifest,
+    payloads: &EvaluatorPayloadStore,
+    sizing_physics: &PhysicsRuntime,
+) -> RusticolResult<ExecutionRuntime> {
+    validate_execution_manifest(&manifest)?;
+    ExecutionRuntime::load_from_manifest_with_store(manifest, payloads, sizing_physics)
+}
+
+fn validate_execution_manifest(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    if manifest.schema_version != PROCESS_ARTIFACT_SCHEMA_VERSION
+        || manifest.kind != "pyamplicol-runtime-execution"
+    {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported execution manifest kind {} schema {}; regenerate the artifact with pyAmpliCol 0.1.0 or newer",
+            manifest.kind, manifest.schema_version
+        )));
+    }
+    if manifest.runtime_schema.schema_version != PROCESS_ARTIFACT_SCHEMA_VERSION
+        || manifest.runtime_schema.kind != "pyamplicol-runtime-execution-plan"
+    {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported execution-plan kind {} schema {}; regenerate the artifact with pyAmpliCol 0.1.0 or newer",
+            manifest.runtime_schema.kind, manifest.runtime_schema.schema_version
+        )));
+    }
+    if manifest.runtime_schema.process != manifest.process
+        || manifest.runtime_schema.process_key != manifest.key
+    {
+        return Err(RusticolError::artifact(
+            "generic runtime schema process identity does not match manifest",
+        ));
+    }
+    if manifest.compiled.kind != "generic-dag-stage-blueprint" {
+        return Err(RusticolError::artifact(
+            "schema-v3 execution manifests require a generic-dag-stage-blueprint",
+        ));
+    }
+    if !manifest.compiled.runtime_available || manifest.compiled.stage_evaluators.is_none() {
+        return Err(RusticolError::artifact(
+            "schema-v3 execution manifest has no serialized stage evaluators; regenerate the artifact",
+        ));
+    }
+    if manifest.dag_summary.truncated {
+        return Err(RusticolError::artifact(
+            "generic DAG schema-v3 artifact was truncated during current construction",
+        ));
+    }
+    if manifest.dag_summary.interaction_evaluation_count > manifest.dag_summary.interaction_count {
+        return Err(RusticolError::integrity(
+            "generic DAG interaction-evaluation count exceeds its interaction count",
+        ));
+    }
+    let expected_materialization = BTreeMap::from([
+        (
+            "amplitude_root_count".to_string(),
+            manifest.dag_summary.amplitude_root_count,
+        ),
+        (
+            "current_count".to_string(),
+            manifest.dag_summary.current_count,
+        ),
+        (
+            "interaction_count".to_string(),
+            manifest.dag_summary.interaction_count,
+        ),
+        (
+            "interaction_evaluation_count".to_string(),
+            manifest.dag_summary.interaction_evaluation_count,
+        ),
+        (
+            "source_count".to_string(),
+            manifest.dag_summary.source_count,
+        ),
+    ]);
+    if manifest.materialization_census.abi != "pyamplicol-fully-resident-materialization-census-v1"
+        || manifest.materialization_census.basis != "immutable-fully-resident-compiled-dag"
+    {
+        return Err(RusticolError::compatibility(
+            "compiled materialization census ABI or basis is unsupported",
+        ));
+    }
+    if !manifest.materialization_census.final_equals_peak
+        || manifest.materialization_census.r#final != expected_materialization
+        || manifest.materialization_census.peak != expected_materialization
+    {
+        return Err(RusticolError::integrity(
+            "compiled materialization census disagrees with the persisted DAG",
+        ));
+    }
+    if manifest.external_pdg_order.len() != manifest.runtime_schema.external_particles.len() {
+        return Err(RusticolError::artifact(
+            "generic runtime schema external particle count does not match external_pdg_order",
+        ));
+    }
+    for (index, (pdg, particle)) in manifest
+        .external_pdg_order
+        .iter()
+        .zip(&manifest.runtime_schema.external_particles)
+        .enumerate()
+    {
+        if particle.index != index || particle.momentum_slot != index || particle.pdg != *pdg {
+            return Err(RusticolError::artifact(format!(
+                "generic external particle metadata mismatch at index {index}"
+            )));
+        }
+        if particle.label != index + 1 {
+            return Err(RusticolError::artifact(format!(
+                "generic external particle labels must be contiguous; got {} at index {index}",
+                particle.label
+            )));
+        }
+        if particle.outgoing_pdg == 0 || (particle.role != "initial" && particle.role != "final") {
+            return Err(RusticolError::artifact(format!(
+                "generic external particle {index} has invalid role or outgoing PDG"
+            )));
+        }
+    }
+    validate_generic_parameter_layout(&manifest.runtime_schema)?;
+    validate_generic_current_storage(manifest)?;
+    validate_generic_value_storage(manifest)?;
+    validate_generic_sources(manifest)?;
+    validate_generic_momentum_slots(manifest)?;
+    validate_generic_stages(manifest)?;
+    validate_generic_amplitudes(manifest)?;
+    validate_compiled_symmetric_group_diagnostic(manifest)?;
+    validate_generic_stage_evaluators(manifest)?;
+    validate_lc_topology_replay(manifest)?;
+    if let Some(sum_manifest) = manifest.helicity_sum_execution.as_deref() {
+        if sum_manifest.helicity_sum_execution.is_some()
+            || !sum_manifest.helicity_selector_executions.is_empty()
+        {
+            return Err(RusticolError::integrity(
+                "compiled helicity-sum execution contains a recursively nested auxiliary execution",
+            ));
+        }
+        validate_execution_manifest(sum_manifest)?;
+    }
+    let mut helicity_selector_domain_ids = BTreeSet::new();
+    for record in &manifest.helicity_selector_executions {
+        for selector_domain_id in &record.selector_domain_ids {
+            if !helicity_selector_domain_ids.insert(*selector_domain_id) {
+                return Err(RusticolError::integrity(format!(
+                    "compiled helicity-selector executions contain duplicate selector domain {selector_domain_id}"
+                )));
+            }
+        }
+        let selector_manifest = record.execution.as_ref();
+        if selector_manifest.helicity_sum_execution.is_some()
+            || !selector_manifest.color_selector_executions.is_empty()
+        {
+            return Err(RusticolError::integrity(
+                "compiled helicity-selector execution contains an unsupported auxiliary execution",
+            ));
+        }
+        if !selector_manifest.helicity_selector_executions.is_empty()
+            && record.schedule_mode != HelicitySelectorScheduleMode::NestedRuntime
+        {
+            return Err(RusticolError::integrity(
+                "only a nested-runtime helicity-selector execution may contain closure lanes",
+            ));
+        }
+        let has_materialization = selector_manifest
+            .runtime_schema
+            .helicity_recurrence
+            .as_ref()
+            .is_some_and(|recurrence| recurrence.materialization.is_some());
+        match record.schedule_mode {
+            HelicitySelectorScheduleMode::ParentClosure if has_materialization => {
+                return Err(RusticolError::integrity(
+                    "parent-closure helicity-selector execution cannot contain helicity materialization",
+                ));
+            }
+            HelicitySelectorScheduleMode::NestedRuntime if !has_materialization => {
+                return Err(RusticolError::integrity(
+                    "nested-runtime helicity-selector execution requires helicity materialization",
+                ));
+            }
+            _ => {}
+        }
+        validate_execution_manifest(selector_manifest)?;
+    }
+    let mut color_sector_ids = BTreeSet::new();
+    for lane in &manifest.color_selector_executions {
+        if !color_sector_ids.insert(lane.materialized_sector_id) {
+            return Err(RusticolError::integrity(format!(
+                "compiled color-selector executions contain duplicate materialized sector {}",
+                lane.materialized_sector_id
+            )));
+        }
+        if lane.execution.helicity_sum_execution.is_some()
+            || !lane.execution.helicity_selector_executions.is_empty()
+            || !lane.execution.color_selector_executions.is_empty()
+        {
+            return Err(RusticolError::integrity(
+                "compiled color-selector execution cannot contain auxiliary executions",
+            ));
+        }
+        validate_execution_manifest(lane.execution.as_ref())?;
+    }
+    Ok(())
+}
+
+fn validate_compiled_symmetric_group_diagnostic(
+    manifest: &ExecutionManifest,
+) -> RusticolResult<()> {
+    let Some(payload) = manifest.color_contraction_payload.as_ref() else {
+        return Ok(());
+    };
+    if payload.path.is_empty() {
+        return Err(RusticolError::compatibility(
+            "compiled symmetric-group FFT payload has an empty path",
+        ));
+    }
+    if manifest.color_accuracy != "full"
+        || manifest.helicity_sum_execution.is_some()
+        || !manifest.helicity_selector_executions.is_empty()
+        || !manifest.color_selector_executions.is_empty()
+        || manifest.runtime_schema.helicity_recurrence.is_some()
+        || manifest.compiled.lc_topology_replay.is_some()
+        || manifest.compiled.color_topology_replay.is_some()
+        || manifest
+            .runtime_schema
+            .amplitude_stage
+            .color_topology_replay
+            .is_some()
+    {
+        return Err(RusticolError::compatibility(
+            "compiled symmetric-group FFT diagnostic supports only selected-helicity FullColour total execution without selector or topology-replay lanes",
+        ));
+    }
+    let contraction = manifest
+        .runtime_schema
+        .amplitude_stage
+        .color_contraction
+        .as_ref()
+        .ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled symmetric-group FFT payload has no amplitude contraction metadata",
+            )
+        })?;
+    if !contraction.supported
+        || contraction.group_count == 0
+        || !contraction.entries.is_empty()
+        || contraction.repeated_block.is_some()
+    {
+        return Err(RusticolError::integrity(
+            "compiled symmetric-group FFT diagnostic requires a compact payload-only amplitude contraction",
+        ));
+    }
+    Ok(())
+}
+
+#[cfg(all(test, feature = "f64-symjit"))]
+mod execution_summary_tests {
+    use super::*;
+
+    fn manifest() -> ExecutionManifest {
+        serde_json::from_value(crate::artifact::tests::minimal_execution_manifest(
+            "p0",
+            "a b > c",
+            SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+            crate::artifact::tests::direct_evaluator_manifest("evaluators/direct.symjit"),
+        ))
+        .expect("deserialize compiled execution summary fixture")
+    }
+
+    #[test]
+    fn compiled_summary_and_materialization_census_round_trip() {
+        validate_execution_manifest(&manifest()).expect("validate exact compiled census");
+
+        let mut excessive = manifest();
+        excessive.dag_summary.interaction_evaluation_count = 1;
+        let error = validate_execution_manifest(&excessive).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+        assert!(error.to_string().contains("exceeds"));
+
+        let mut inconsistent = manifest();
+        inconsistent
+            .materialization_census
+            .r#final
+            .insert("interaction_evaluation_count".to_string(), 1);
+        let error = validate_execution_manifest(&inconsistent).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+        assert!(error.to_string().contains("disagrees"));
+    }
+}
+
+fn validate_lc_topology_replay(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let Some(replay) = manifest.compiled.lc_topology_replay.as_ref() else {
+        return Ok(());
+    };
+    if !replay.enabled {
+        return Ok(());
+    }
+    let (mappings, _weights) = build_lc_topology_replay_mappings(Some(replay))?;
+    if mappings.is_empty() {
+        return Err(RusticolError::artifact(
+            "enabled LC topology replay contains no sector mappings",
+        ));
+    }
+    let expected_legs = manifest.external_pdg_order.len();
+    for mapping in &mappings {
+        let mut seen = vec![false; expected_legs];
+        for (representative_index, sector_index) in mapping {
+            if *representative_index >= expected_legs || *sector_index >= expected_legs {
+                return Err(RusticolError::artifact(
+                    "LC topology replay mapping references an out-of-range external leg",
+                ));
+            }
+            if seen[*representative_index] {
+                return Err(RusticolError::artifact(
+                    "LC topology replay mapping contains a duplicate representative label",
+                ));
+            }
+            seen[*representative_index] = true;
+        }
+    }
+    Ok(())
+}
+
+fn validate_generic_parameter_layout(schema: &ExecutionPlan) -> RusticolResult<()> {
+    let layout = &schema.parameter_layout;
+    if !layout.source_components_complex || !layout.momentum_components_real {
+        return Err(RusticolError::artifact(
+            "generic runtime schema requires complex source components and real momenta",
+        ));
+    }
+    if layout.parameter_count_if_flattened
+        != layout.source_component_parameter_count
+            + layout.momentum_parameter_count
+            + layout.model_parameter_count
+    {
+        return Err(RusticolError::artifact(
+            "generic runtime schema flattened parameter count is inconsistent",
+        ));
+    }
+    if layout.momentum_parameter_count != 4 * schema.momentum_slots.len() {
+        return Err(RusticolError::artifact(
+            "generic runtime schema momentum parameter count does not match momentum slots",
+        ));
+    }
+    let expected_real_inputs = (layout.source_component_parameter_count
+        ..layout.parameter_count_if_flattened)
+        .collect::<Vec<_>>();
+    if layout.real_valued_inputs != expected_real_inputs {
+        return Err(RusticolError::artifact(
+            "generic runtime schema real-valued input indices are inconsistent",
+        ));
+    }
+    if schema.model_parameters.len() != layout.model_parameter_count {
+        return Err(RusticolError::artifact(
+            "generic runtime schema model-parameter count is inconsistent",
+        ));
+    }
+    let mut seen_model_parameters = BTreeSet::new();
+    let mut seen_model_parameter_names = BTreeSet::new();
+    for parameter in &schema.model_parameters {
+        if parameter.name.is_empty()
+            || parameter.parameter_index >= layout.model_parameter_count
+            || !parameter.default.is_finite()
+            || !seen_model_parameters.insert(parameter.parameter_index)
+            || !seen_model_parameter_names.insert(parameter.name.clone())
+            || parameter
+                .runtime_name
+                .as_ref()
+                .is_some_and(|name| name.is_empty())
+            || !matches!(
+                (
+                    &parameter.runtime_name,
+                    parameter.complex_component.as_deref(),
+                ),
+                (Some(_), Some("real" | "imag")) | (None, None)
+            )
+        {
+            return Err(RusticolError::artifact(
+                "generic runtime schema contains invalid model-parameter metadata",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn positive_json_integer(value: &Value) -> bool {
+    if let Some(unsigned) = value.as_u64() {
+        return unsigned > 0;
+    }
+    if let Some(signed) = value.as_i64() {
+        return signed > 0;
+    }
+    if let Some(float_value) = value.as_f64() {
+        return float_value.is_finite() && float_value > 0.0;
+    }
+    if let Some(text) = value.as_str() {
+        if let Some(hex) = text.strip_prefix("0x").or_else(|| text.strip_prefix("0X")) {
+            return !hex.is_empty()
+                && hex.bytes().all(|byte| byte.is_ascii_hexdigit())
+                && hex.bytes().any(|byte| byte != b'0');
+        }
+        return !text.is_empty()
+            && text.bytes().all(|byte| byte.is_ascii_digit())
+            && text.bytes().any(|byte| byte != b'0');
+    }
+    false
+}
+
+fn validate_generic_current_storage(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let storage = &manifest.runtime_schema.current_storage;
+    if storage.number_type != "complex" {
+        return Err(RusticolError::artifact(
+            "generic current storage must use complex number type",
+        ));
+    }
+    if storage.current_slots.len() != manifest.dag_summary.current_count {
+        return Err(RusticolError::artifact(
+            "generic current slot count does not match DAG summary",
+        ));
+    }
+    let mut offset = 0usize;
+    for (index, slot) in storage.current_slots.iter().enumerate() {
+        if slot.current_id != index {
+            return Err(RusticolError::artifact(format!(
+                "generic current slot id mismatch at index {index}"
+            )));
+        }
+        if slot.component_start != offset
+            || slot.component_stop != slot.component_start + slot.dimension
+            || slot.dimension == 0
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic current slot {index} has inconsistent component range"
+            )));
+        }
+        if slot.particle_id == 0 || slot.external_mask == 0 || slot.momentum_mask == 0 {
+            return Err(RusticolError::artifact(format!(
+                "generic current slot {index} has invalid physics identity"
+            )));
+        }
+        if !valid_current_chirality(slot.chirality) {
+            return Err(RusticolError::artifact(format!(
+                "generic current slot {index} has invalid quantum-flow metadata"
+            )));
+        }
+        if !storage.metadata_compacted {
+            if slot.external_labels.is_empty()
+                || !positive_json_integer(&slot.helicity_ancestry)
+                || slot.color_state.is_null()
+            {
+                return Err(RusticolError::artifact(format!(
+                    "generic current slot {index} is missing current-index metadata"
+                )));
+            }
+            if slot.flavour_flow.is_empty() {
+                return Err(RusticolError::artifact(format!(
+                    "generic current slot {index} has invalid quantum-flow metadata"
+                )));
+            }
+            if slot.spin_state.is_null()
+                || slot
+                    .auxiliary_kind
+                    .as_ref()
+                    .is_some_and(|kind| kind.is_empty())
+            {
+                return Err(RusticolError::artifact(format!(
+                    "generic current slot {index} has invalid spin/auxiliary metadata"
+                )));
+            }
+        }
+        offset = slot.component_stop;
+    }
+    if storage.component_count != offset {
+        return Err(RusticolError::artifact(
+            "generic current storage component_count is inconsistent",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_generic_value_storage(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let schema = &manifest.runtime_schema;
+    let storage = &schema.value_storage;
+    if storage.number_type != "complex" {
+        return Err(RusticolError::artifact(
+            "generic value storage must use complex number type",
+        ));
+    }
+    if schema.parameter_layout.value_component_count != storage.component_count {
+        return Err(RusticolError::artifact(
+            "generic value component count does not match parameter layout",
+        ));
+    }
+    if storage.value_slots.is_empty() && manifest.dag_summary.current_count != 0 {
+        return Err(RusticolError::artifact(
+            "generic value storage has no value slots",
+        ));
+    }
+    let current_slots = &schema.current_storage.current_slots;
+    let mut offset = 0usize;
+    for (index, slot) in storage.value_slots.iter().enumerate() {
+        if slot.value_slot_id != index
+            || slot.component_start != offset
+            || slot.component_stop != slot.component_start + slot.dimension
+            || slot.dimension == 0
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic value slot {index} has inconsistent component range"
+            )));
+        }
+        let current = current_slots.get(slot.current_id).ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "generic value slot {index} references missing current {}",
+                slot.current_id
+            ))
+        })?;
+        if current.dimension != slot.dimension || current.is_source != slot.is_source {
+            return Err(RusticolError::artifact(format!(
+                "generic value slot {index} does not match its current slot"
+            )));
+        }
+        if slot.current_component_start != current.component_start
+            || slot.current_component_stop != current.component_stop
+            || slot.particle_id != current.particle_id
+            || slot.external_mask != current.external_mask
+            || (!storage.metadata_compacted && slot.external_labels != current.external_labels)
+            || slot.momentum_mask != current.momentum_mask
+            || slot.chirality != current.chirality
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic value slot {index} does not preserve its current identity"
+            )));
+        }
+        validate_generic_propagator(index, slot, current)?;
+        match slot.variant.as_str() {
+            "source" => {
+                if !slot.is_source || slot.applies_propagator {
+                    return Err(RusticolError::artifact(format!(
+                        "generic source value slot {index} is inconsistent"
+                    )));
+                }
+            }
+            "propagated" => {
+                if slot.is_source || !slot.applies_propagator {
+                    return Err(RusticolError::artifact(format!(
+                        "generic propagated value slot {index} is inconsistent"
+                    )));
+                }
+            }
+            "unpropagated" => {
+                if slot.is_source || slot.applies_propagator {
+                    return Err(RusticolError::artifact(format!(
+                        "generic unpropagated value slot {index} is inconsistent"
+                    )));
+                }
+            }
+            other => {
+                return Err(RusticolError::artifact(format!(
+                    "generic value slot {index} has unsupported variant {other:?}"
+                )));
+            }
+        }
+        offset = slot.component_stop;
+    }
+    if storage.component_count != offset {
+        return Err(RusticolError::artifact(
+            "generic value storage component_count is inconsistent",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_generic_propagator(
+    index: usize,
+    slot: &GenericValueSlotManifest,
+    current: &GenericCurrentSlotManifest,
+) -> RusticolResult<()> {
+    let propagator = &slot.propagator;
+    let identity = &propagator.identity;
+    if propagator.particle_id != slot.particle_id
+        || propagator.chirality != slot.chirality
+        || identity.pdg_label != slot.particle_id
+        || identity.canonical_id.is_empty()
+        || identity.species_id.is_empty()
+        || identity.anti_canonical_id.is_empty()
+        || identity.display_name.is_empty()
+        || identity.anti_display_name.is_empty()
+        || identity.self_conjugate != (identity.pdg_label == identity.anti_pdg_label)
+        || identity.self_conjugate != (identity.canonical_id == identity.anti_canonical_id)
+        || propagator.backend.is_empty()
+        || propagator.basis.is_empty()
+        || propagator.kernel.is_empty()
+        || propagator.description.is_empty()
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic value slot {index} has inconsistent propagator identity"
+        )));
+    }
+    if identity.self_conjugate
+        != matches!(
+            identity.orientation,
+            GenericSourceOrientationManifest::SelfConjugate
+        )
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic value slot {index} has inconsistent propagator orientation"
+        )));
+    }
+    for value in [
+        propagator.numerator.as_ref(),
+        propagator.denominator.as_ref(),
+        propagator.mass_parameter.as_ref(),
+        propagator.width_parameter.as_ref(),
+        propagator.custom_source.as_ref(),
+        propagator.auxiliary_policy.as_ref(),
+    ] {
+        if value.is_some_and(String::is_empty) {
+            return Err(RusticolError::artifact(format!(
+                "generic value slot {index} has empty propagator metadata"
+            )));
+        }
+    }
+    let expected_dimension = match propagator.kind {
+        GenericPropagatorKindManifest::Scalar => Some(1),
+        GenericPropagatorKindManifest::WeylFermion => Some(2),
+        GenericPropagatorKindManifest::DiracFermion | GenericPropagatorKindManifest::Vector => {
+            Some(4)
+        }
+        GenericPropagatorKindManifest::Spin2 => Some(16),
+        GenericPropagatorKindManifest::Identity
+        | GenericPropagatorKindManifest::Custom
+        | GenericPropagatorKindManifest::Unsupported => None,
+    };
+    if expected_dimension.is_some_and(|dimension| dimension != current.dimension) {
+        return Err(RusticolError::artifact(format!(
+            "generic value slot {index} propagator dimension does not match its current"
+        )));
+    }
+    if propagator.kind != GenericPropagatorKindManifest::Unsupported
+        && !propagator.full_tensor_network_ready
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic value slot {index} has an incomplete propagator contract"
+        )));
+    }
+    match propagator.kind {
+        GenericPropagatorKindManifest::Identity => {
+            if propagator.applies_propagator
+                || propagator.mass_class != GenericPropagatorMassClassManifest::NotApplicable
+                || propagator.gauge.is_some()
+                || propagator.auxiliary_policy.is_none()
+            {
+                return Err(RusticolError::artifact(format!(
+                    "generic value slot {index} has an invalid identity propagator"
+                )));
+            }
+        }
+        GenericPropagatorKindManifest::Vector => {
+            if !propagator.applies_propagator
+                || !matches!(
+                    propagator.gauge,
+                    Some(
+                        GenericPropagatorGaugeManifest::Feynman
+                            | GenericPropagatorGaugeManifest::Unitary
+                    )
+                )
+            {
+                return Err(RusticolError::artifact(format!(
+                    "generic value slot {index} has an invalid vector propagator"
+                )));
+            }
+        }
+        GenericPropagatorKindManifest::Spin2 => {
+            if !propagator.applies_propagator
+                || !matches!(
+                    propagator.gauge,
+                    Some(
+                        GenericPropagatorGaugeManifest::DeDonder
+                            | GenericPropagatorGaugeManifest::FierzPauli
+                    )
+                )
+            {
+                return Err(RusticolError::artifact(format!(
+                    "generic value slot {index} has an invalid spin-2 propagator"
+                )));
+            }
+        }
+        GenericPropagatorKindManifest::Custom => {
+            if !propagator.applies_propagator
+                || propagator.gauge != Some(GenericPropagatorGaugeManifest::ModelSupplied)
+                || propagator.custom_source.is_none()
+            {
+                return Err(RusticolError::artifact(format!(
+                    "generic value slot {index} has an invalid custom propagator"
+                )));
+            }
+        }
+        GenericPropagatorKindManifest::Scalar
+        | GenericPropagatorKindManifest::WeylFermion
+        | GenericPropagatorKindManifest::DiracFermion
+        | GenericPropagatorKindManifest::Unsupported => {
+            if !propagator.applies_propagator || propagator.gauge.is_some() {
+                return Err(RusticolError::artifact(format!(
+                    "generic value slot {index} has an invalid standard propagator"
+                )));
+            }
+        }
+    }
+    if propagator.kind != GenericPropagatorKindManifest::Identity
+        && propagator.mass_class == GenericPropagatorMassClassManifest::NotApplicable
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic value slot {index} has an invalid propagator mass class"
+        )));
+    }
+    if propagator.goldstone_policy == GenericGoldstonePolicyManifest::Absorbed
+        && !(propagator.kind == GenericPropagatorKindManifest::Vector
+            && propagator.gauge == Some(GenericPropagatorGaugeManifest::Unitary))
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic value slot {index} has an invalid Goldstone policy"
+        )));
+    }
+    if propagator.goldstone_policy == GenericGoldstonePolicyManifest::ModelSupplied
+        && propagator.kind != GenericPropagatorKindManifest::Custom
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic value slot {index} has an invalid model-supplied Goldstone policy"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_generic_sources(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let schema = &manifest.runtime_schema;
+    if schema.source_fill.source_count != manifest.dag_summary.source_count
+        || schema.source_fill.sources.len() != manifest.dag_summary.source_count
+    {
+        return Err(RusticolError::artifact(
+            "generic source count does not match DAG summary",
+        ));
+    }
+    let current_slots = &schema.current_storage.current_slots;
+    let mut source_offset = 0usize;
+    let mut source_ir_by_momentum_slot = BTreeMap::new();
+    let mut source_ir_by_canonical_id = BTreeMap::new();
+    for (index, source) in schema.source_fill.sources.iter().enumerate() {
+        if source.source_id != index {
+            return Err(RusticolError::artifact(format!(
+                "generic source id mismatch at index {index}"
+            )));
+        }
+        let slot = current_slots.get(source.current_id).ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "generic source {index} references missing current {}",
+                source.current_id
+            ))
+        })?;
+        if !slot.is_source
+            || slot.dimension != source.dimension
+            || slot.particle_id != source.particle_id
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} does not match its current slot"
+            )));
+        }
+        if source.current_component_start != slot.component_start
+            || source.current_component_stop != slot.component_stop
+            || source.source_parameter_start != source_offset
+            || source.source_parameter_stop != source_offset + source.dimension
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} has inconsistent component offsets"
+            )));
+        }
+        validate_value_slot_ref(
+            &source.value_slot,
+            source.current_id,
+            Some("source"),
+            &schema.value_storage,
+        )?;
+        if source.source_kind != "external-wavefunction" {
+            return Err(RusticolError::artifact(format!(
+                "unsupported generic source kind {:?}",
+                source.source_kind
+            )));
+        }
+        if source.side != "initial" && source.side != "final" {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} has invalid side {:?}",
+                source.side
+            )));
+        }
+        validate_source_wavefunction_metadata(index, source)?;
+        validate_consistent_source_ir(
+            &mut source_ir_by_momentum_slot,
+            &mut source_ir_by_canonical_id,
+            index,
+            source,
+        )?;
+        let max_helicity =
+            if source.source_ir.wavefunction_family == GenericWavefunctionFamilyManifest::Spin2 {
+                2
+            } else {
+                1
+            };
+        if source.physical_pdg == 0
+            || source.outgoing_pdg != source.particle_id
+            || source.chirality.unsigned_abs() > 1
+            || source.source_helicity.unsigned_abs() > max_helicity
+            || source.spin_state.is_null()
+            || !positive_json_integer(&source.helicity_ancestry)
+            || source.color_state.is_null()
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} has invalid physics metadata"
+            )));
+        }
+        let particle = schema
+            .external_particles
+            .get(source.input_momentum_slot)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "generic source {index} references missing momentum slot {}",
+                    source.input_momentum_slot
+                ))
+            })?;
+        if particle.label != source.leg_label
+            || particle.role != source.side
+            || particle.pdg != source.physical_pdg
+            || particle.outgoing_pdg != source.outgoing_pdg
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} does not match its external particle"
+            )));
+        }
+        source_offset = source.source_parameter_stop;
+    }
+    if source_offset != schema.parameter_layout.source_component_parameter_count {
+        return Err(RusticolError::artifact(
+            "generic source parameter count does not match source records",
+        ));
+    }
+    Ok(())
+}
+
+pub(super) fn validate_consistent_source_ir(
+    source_ir_by_momentum_slot: &mut BTreeMap<usize, GenericSourceIrManifest>,
+    source_ir_by_canonical_id: &mut BTreeMap<String, GenericSourceIrManifest>,
+    index: usize,
+    source: &GenericSourceRecordManifest,
+) -> RusticolResult<()> {
+    if let Some(canonical) = source_ir_by_momentum_slot.get(&source.input_momentum_slot) {
+        if canonical != &source.source_ir {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} disagrees with canonical SourceIR metadata for momentum slot {}",
+                source.input_momentum_slot
+            )));
+        }
+    } else {
+        source_ir_by_momentum_slot.insert(source.input_momentum_slot, source.source_ir.clone());
+    }
+
+    let identity = &source.source_ir.identity;
+    if let Some(canonical) = source_ir_by_canonical_id.get(&identity.canonical_id)
+        && canonical != &source.source_ir
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic source {index} disagrees with canonical SourceIR metadata for oriented particle {:?}",
+            identity.canonical_id
+        )));
+    }
+    if let Some(antiparticle) = source_ir_by_canonical_id.get(&identity.anti_canonical_id) {
+        validate_antiparticle_identity_pair(index, identity, &antiparticle.identity)?;
+    }
+    source_ir_by_canonical_id
+        .entry(identity.canonical_id.clone())
+        .or_insert_with(|| source.source_ir.clone());
+    Ok(())
+}
+
+fn validate_antiparticle_identity_pair(
+    index: usize,
+    identity: &GenericParticleIdentityIrManifest,
+    antiparticle: &GenericParticleIdentityIrManifest,
+) -> RusticolResult<()> {
+    let orientations_match = matches!(
+        (identity.orientation, antiparticle.orientation),
+        (
+            GenericSourceOrientationManifest::Particle,
+            GenericSourceOrientationManifest::Antiparticle,
+        ) | (
+            GenericSourceOrientationManifest::Antiparticle,
+            GenericSourceOrientationManifest::Particle,
+        ) | (
+            GenericSourceOrientationManifest::SelfConjugate,
+            GenericSourceOrientationManifest::SelfConjugate,
+        )
+    );
+    if identity.anti_canonical_id != antiparticle.canonical_id
+        || antiparticle.anti_canonical_id != identity.canonical_id
+        || identity.species_id != antiparticle.species_id
+        || identity.anti_pdg_label != antiparticle.pdg_label
+        || antiparticle.anti_pdg_label != identity.pdg_label
+        || identity.anti_display_name != antiparticle.display_name
+        || antiparticle.anti_display_name != identity.display_name
+        || identity.self_conjugate != antiparticle.self_conjugate
+        || !orientations_match
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic source {index} has a non-involutive particle/antiparticle identity relation for {:?}",
+            identity.canonical_id
+        )));
+    }
+    Ok(())
+}
+
+pub(super) fn validate_source_wavefunction_metadata(
+    index: usize,
+    source: &GenericSourceRecordManifest,
+) -> RusticolResult<()> {
+    let source_ir = &source.source_ir;
+    let identity = &source_ir.identity;
+    if identity.canonical_id.is_empty()
+        || identity.species_id.is_empty()
+        || identity.anti_canonical_id.is_empty()
+        || identity.display_name.is_empty()
+        || identity.anti_display_name.is_empty()
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic source {index} has incomplete typed particle identity"
+        )));
+    }
+    if identity.anti_pdg_label == 0 {
+        return Err(RusticolError::artifact(format!(
+            "generic source {index} has an invalid antiparticle relation"
+        )));
+    }
+    let canonical_self_conjugate = identity.canonical_id == identity.anti_canonical_id;
+    let pdg_self_conjugate = identity.pdg_label == identity.anti_pdg_label;
+    if identity.self_conjugate != canonical_self_conjugate
+        || identity.self_conjugate != pdg_self_conjugate
+        || (identity.orientation == GenericSourceOrientationManifest::SelfConjugate)
+            != identity.self_conjugate
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic source {index} orientation is inconsistent with its antiparticle relation"
+        )));
+    }
+
+    if source_ir.component_dimension == 0
+        || source_ir.states.is_empty()
+        || source_ir.basis.is_empty()
+        || source_ir
+            .mass_parameter
+            .as_ref()
+            .is_some_and(String::is_empty)
+        || source_ir
+            .width_parameter
+            .as_ref()
+            .is_some_and(String::is_empty)
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic source {index} has invalid typed SourceIR metadata"
+        )));
+    }
+    validate_crossing_ir(index, "declared", &source_ir.crossing)?;
+    validate_crossing_ir(index, "applied", &source.applied_crossing)?;
+
+    let expected_statistics = match source_ir.wavefunction_family {
+        GenericWavefunctionFamilyManifest::Fermion => GenericParticleStatisticsManifest::Fermion,
+        GenericWavefunctionFamilyManifest::Ghost => GenericParticleStatisticsManifest::Ghost,
+        GenericWavefunctionFamilyManifest::Auxiliary => {
+            GenericParticleStatisticsManifest::Auxiliary
+        }
+        GenericWavefunctionFamilyManifest::Scalar
+        | GenericWavefunctionFamilyManifest::Vector
+        | GenericWavefunctionFamilyManifest::Spin2 => GenericParticleStatisticsManifest::Boson,
+    };
+    if source_ir.statistics != expected_statistics {
+        return Err(RusticolError::artifact(format!(
+            "generic source {index} statistics disagree with its wavefunction family"
+        )));
+    }
+
+    match (source_ir.wavefunction_family, source_ir.component_dimension) {
+        (GenericWavefunctionFamilyManifest::Fermion, 2 | 4) => {
+            if identity.self_conjugate {
+                return Err(RusticolError::artifact(format!(
+                    "generic source {index} is an unsupported self-conjugate fermion source"
+                )));
+            }
+        }
+        (GenericWavefunctionFamilyManifest::Scalar, 1)
+        | (GenericWavefunctionFamilyManifest::Vector, 4)
+        | (GenericWavefunctionFamilyManifest::Spin2, 16) => {}
+        (kind, dimension) => {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} has unsupported wavefunction kind {:?} with dimension {dimension}",
+                kind.as_str()
+            )));
+        }
+    }
+
+    for (field, matches) in [
+        ("particle_id", source.particle_id == identity.pdg_label),
+        (
+            "anti_particle_id",
+            source.anti_particle_id == identity.anti_pdg_label,
+        ),
+        (
+            "source_orientation",
+            source.source_orientation == identity.orientation,
+        ),
+        (
+            "wavefunction_kind",
+            source.wavefunction_kind == source_ir.wavefunction_family.as_str(),
+        ),
+        (
+            "dimension",
+            source.dimension == source_ir.component_dimension,
+        ),
+        ("source_basis", source.source_basis == source_ir.basis),
+        (
+            "crossing",
+            source.crossing
+                == source
+                    .applied_crossing
+                    .momentum_transform
+                    .legacy_projection(),
+        ),
+    ] {
+        if !matches {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} flattened field {field:?} disagrees with typed metadata"
+            )));
+        }
+    }
+
+    match source.side.as_str() {
+        "initial" if source.applied_crossing != source_ir.crossing => {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} applied crossing does not match its declared SourceIR crossing"
+            )));
+        }
+        "final" if !source.applied_crossing.is_identity() => {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} final-state applied crossing is not identity"
+            )));
+        }
+        "initial" | "final" => {}
+        _ => {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} has invalid side {:?}",
+                source.side
+            )));
+        }
+    }
+    let current_spin_state: GenericSourceSpinStateManifest =
+        serde_json::from_value(source.spin_state.clone()).map_err(|_| {
+            RusticolError::artifact(format!(
+                "generic source {index} has an invalid flattened spin state"
+            ))
+        })?;
+    let current_state = GenericSourceStateIrManifest {
+        helicity: source.source_helicity,
+        chirality: source.chirality,
+        spin_state: current_spin_state,
+    };
+    let max_helicity = if source_ir.wavefunction_family == GenericWavefunctionFamilyManifest::Spin2
+    {
+        2
+    } else {
+        1
+    };
+    let mut state_is_declared = false;
+    for (state_index, declared_state) in source_ir.states.iter().enumerate() {
+        if declared_state.chirality.unsigned_abs() > 1
+            || declared_state.helicity.unsigned_abs() > max_helicity
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic source {index} SourceIR state {state_index} is outside the supported helicity/chirality range"
+            )));
+        }
+        let transformed = declared_state
+            .transformed(&source.applied_crossing)
+            .map_err(|message| {
+                RusticolError::artifact(format!(
+                    "generic source {index} SourceIR state {state_index} is invalid: {message}"
+                ))
+            })?;
+        state_is_declared |= transformed == current_state;
+    }
+    if !state_is_declared {
+        return Err(RusticolError::artifact(format!(
+            "generic source {index} current state is not declared by its typed SourceIR"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_crossing_ir(
+    index: usize,
+    label: &str,
+    crossing: &GenericCrossingIrManifest,
+) -> RusticolResult<()> {
+    if ![-1, 1].contains(&crossing.helicity_factor)
+        || ![-1, 1].contains(&crossing.chirality_factor)
+        || ![-1, 1].contains(&crossing.spin_state_factor)
+        || !crossing.phase.iter().all(|component| component.is_finite())
+        || crossing.phase == [0.0, 0.0]
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic source {index} has invalid {label} CrossingIR metadata"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_generic_momentum_slots(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let schema = &manifest.runtime_schema;
+    for (index, slot) in schema.momentum_slots.iter().enumerate() {
+        if slot.momentum_slot_id != index
+            || slot.component_start != 4 * index
+            || slot.component_stop != slot.component_start + 4
+            || !slot.real_valued
+            || slot.momentum_mask == 0
+            || slot.external_labels.is_empty()
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic momentum slot {index} is inconsistent"
+            )));
+        }
+        for label in &slot.external_labels {
+            if *label == 0 || *label > schema.external_particles.len() {
+                return Err(RusticolError::artifact(format!(
+                    "generic momentum slot {index} has invalid external label {label}"
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_generic_stages(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let schema = &manifest.runtime_schema;
+    let current_count = schema.current_storage.current_slots.len();
+    let value_count = schema.value_storage.value_slots.len();
+    let momentum_count = schema.momentum_slots.len();
+    let input_value_variants =
+        build_input_value_variants(&schema.current_storage, &schema.value_storage)?;
+    let mut seen_interactions = 0usize;
+    let mut seen_interaction_ids = BTreeSet::new();
+    for (stage_offset, stage) in schema.stages.iter().enumerate() {
+        if stage.stage_index != stage_offset + 1
+            || stage.stage_kind != "current-combine"
+            || stage.subset_size < 2
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic stage {} is inconsistent",
+                stage.stage_index
+            )));
+        }
+        if stage.interactions_compacted {
+            if !stage.interactions.is_empty()
+                || stage.interaction_ids.len() != stage.interaction_count
+            {
+                return Err(RusticolError::artifact(format!(
+                    "generic compact stage {} has inconsistent interaction metadata",
+                    stage.stage_index
+                )));
+            }
+            for interaction_id in &stage.interaction_ids {
+                if !seen_interaction_ids.insert(*interaction_id) {
+                    return Err(RusticolError::artifact(format!(
+                        "generic compact stage {} repeats interaction {interaction_id}",
+                        stage.stage_index
+                    )));
+                }
+            }
+        } else if stage.interaction_count != stage.interactions.len()
+            || !stage.interaction_ids.is_empty()
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic stage {} is inconsistent",
+                stage.stage_index
+            )));
+        }
+        let mut input_current_membership = vec![false; current_count];
+        let mut output_current_membership = vec![false; current_count];
+        for (ids, membership) in [
+            (&stage.input_current_ids, &mut input_current_membership),
+            (&stage.output_current_ids, &mut output_current_membership),
+        ] {
+            for id in ids {
+                if *id >= current_count {
+                    return Err(RusticolError::artifact(format!(
+                        "generic stage {} references invalid current {id}",
+                        stage.stage_index
+                    )));
+                }
+                membership[*id] = true;
+            }
+        }
+        let mut input_value_membership = vec![false; value_count];
+        let mut output_value_membership = vec![false; value_count];
+        for (ids, membership) in [
+            (&stage.input_value_slot_ids, &mut input_value_membership),
+            (&stage.output_value_slot_ids, &mut output_value_membership),
+        ] {
+            for value_id in ids {
+                if *value_id >= value_count {
+                    return Err(RusticolError::artifact(format!(
+                        "generic stage {} references invalid value slot {value_id}",
+                        stage.stage_index
+                    )));
+                }
+                membership[*value_id] = true;
+            }
+        }
+        for interaction in &stage.interactions {
+            if !seen_interaction_ids.insert(interaction.interaction_id) {
+                return Err(RusticolError::artifact(format!(
+                    "generic stage {} repeats interaction {}",
+                    stage.stage_index, interaction.interaction_id
+                )));
+            }
+            validate_generic_interaction(
+                interaction,
+                &schema.current_storage,
+                &schema.value_storage,
+                &input_value_variants,
+                momentum_count,
+            )?;
+            if !input_current_membership[interaction.left_current_id]
+                || !input_current_membership[interaction.right_current_id]
+                || !output_current_membership[interaction.result_current_id]
+            {
+                return Err(RusticolError::artifact(format!(
+                    "generic interaction {} is not listed in its stage inputs/outputs",
+                    interaction.interaction_id
+                )));
+            }
+            if !input_value_membership[interaction.left_value_slot.value_slot_id]
+                || !input_value_membership[interaction.right_value_slot.value_slot_id]
+                || interaction
+                    .result_value_slots
+                    .iter()
+                    .any(|slot| !output_value_membership[slot.value_slot_id])
+            {
+                return Err(RusticolError::artifact(format!(
+                    "generic interaction {} value slots are not listed in its stage inputs/outputs",
+                    interaction.interaction_id
+                )));
+            }
+        }
+        seen_interactions += stage.interaction_count;
+    }
+    if seen_interactions != manifest.dag_summary.interaction_count {
+        return Err(RusticolError::artifact(
+            "generic stage interaction count does not match DAG summary",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_generic_interaction(
+    interaction: &GenericInteractionManifest,
+    current_storage: &GenericCurrentStorageManifest,
+    value_storage: &GenericValueStorageManifest,
+    input_value_variants: &[Option<GenericInputValueVariant>],
+    momentum_count: usize,
+) -> RusticolResult<()> {
+    let current_count = current_storage.current_slots.len();
+    for current_id in [
+        interaction.left_current_id,
+        interaction.right_current_id,
+        interaction.result_current_id,
+    ] {
+        if current_id >= current_count {
+            return Err(RusticolError::artifact(format!(
+                "generic interaction {} references invalid current {current_id}",
+                interaction.interaction_id
+            )));
+        }
+    }
+    for slot_id in [
+        interaction.momentum_slots.left,
+        interaction.momentum_slots.right,
+        interaction.momentum_slots.result,
+    ] {
+        if slot_id >= momentum_count {
+            return Err(RusticolError::artifact(format!(
+                "generic interaction {} references invalid momentum slot {slot_id}",
+                interaction.interaction_id
+            )));
+        }
+    }
+    validate_slot_ref(
+        &interaction.left_slot,
+        interaction.left_current_id,
+        current_storage,
+    )?;
+    validate_slot_ref(
+        &interaction.right_slot,
+        interaction.right_current_id,
+        current_storage,
+    )?;
+    validate_slot_ref(
+        &interaction.result_slot,
+        interaction.result_current_id,
+        current_storage,
+    )?;
+    validate_value_slot_ref(
+        &interaction.left_value_slot,
+        interaction.left_current_id,
+        Some(input_value_variant(
+            input_value_variants,
+            interaction.left_current_id,
+        )?),
+        value_storage,
+    )?;
+    validate_value_slot_ref(
+        &interaction.right_value_slot,
+        interaction.right_current_id,
+        Some(input_value_variant(
+            input_value_variants,
+            interaction.right_current_id,
+        )?),
+        value_storage,
+    )?;
+    if interaction.result_value_slots.is_empty() {
+        return Err(RusticolError::artifact(format!(
+            "generic interaction {} has no result value slots",
+            interaction.interaction_id
+        )));
+    }
+    for result_slot in &interaction.result_value_slots {
+        validate_value_slot_ref(
+            result_slot,
+            interaction.result_current_id,
+            None,
+            value_storage,
+        )?;
+        if result_slot.variant != "propagated" && result_slot.variant != "unpropagated" {
+            return Err(RusticolError::artifact(format!(
+                "generic interaction {} has invalid result value variant {:?}",
+                interaction.interaction_id, result_slot.variant
+            )));
+        }
+    }
+    if interaction.vertex_kind < 0 {
+        return Err(RusticolError::artifact(format!(
+            "generic interaction {} has invalid vertex kind {}",
+            interaction.interaction_id, interaction.vertex_kind
+        )));
+    }
+    if interaction.vertex_particles.len() != 3
+        || interaction.coupling.len() != 2
+        || interaction.color_weight.len() != 2
+        || interaction.accumulation != "sum-into-result-current"
+        || interaction.lowering.kind != interaction.vertex_kind
+        || interaction.lowering.full_tensor_network_ready != interaction.full_tensor_network_ready
+        || interaction.lowering.backend.is_empty()
+        || interaction.lowering.expression_head.is_empty()
+        || interaction.lowering.kernel.is_empty()
+        || interaction.lowering.input_roles.len() != 2
+        || interaction.lowering.output_role.is_empty()
+        || interaction.lowering.coupling_mode.is_empty()
+        || interaction
+            .lowering
+            .tensor_names
+            .iter()
+            .any(|name| name.is_empty())
+        || interaction.lowering.description.is_empty()
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic interaction {} has inconsistent model/lowering metadata",
+            interaction.interaction_id
+        )));
+    }
+    if interaction.result_requires_propagated_value
+        && !interaction
+            .result_value_slots
+            .iter()
+            .any(|slot| slot.variant == "propagated")
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic interaction {} declares a propagated result without a propagated slot",
+            interaction.interaction_id
+        )));
+    }
+    if interaction.result_requires_unpropagated_value
+        && !interaction
+            .result_value_slots
+            .iter()
+            .any(|slot| slot.variant == "unpropagated")
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic interaction {} declares an unpropagated result without an unpropagated slot",
+            interaction.interaction_id
+        )));
+    }
+    if !interaction.full_tensor_network_ready {
+        return Err(RusticolError::artifact(format!(
+            "generic interaction {} is not ready for tensor-network lowering",
+            interaction.interaction_id
+        )));
+    }
+    Ok(())
+}
+
+fn validate_generic_amplitudes(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let schema = &manifest.runtime_schema;
+    let stage = &schema.amplitude_stage;
+    if stage.stage_kind != "amplitude-roots"
+        || stage.output_count != stage.roots.len()
+        || stage.output_count != manifest.dag_summary.amplitude_root_count
+    {
+        return Err(RusticolError::artifact(
+            "generic amplitude stage output count is inconsistent",
+        ));
+    }
+    let current_count = schema.current_storage.current_slots.len();
+    for (index, root) in stage.roots.iter().enumerate() {
+        if root.output_index != index || root.root_id != index {
+            return Err(RusticolError::artifact(format!(
+                "generic amplitude root index mismatch at output {index}"
+            )));
+        }
+        if root.left_current_id >= current_count || root.right_current_id >= current_count {
+            return Err(RusticolError::artifact(format!(
+                "generic amplitude root {index} references invalid current"
+            )));
+        }
+        if root.kind != "direct-contraction" && root.kind != "vertex-closure" {
+            return Err(RusticolError::artifact(format!(
+                "generic amplitude root {index} has unsupported kind {:?}",
+                root.kind
+            )));
+        }
+        if root.coupling.len() != 2
+            || root.color_weight.len() != 2
+            || root.contraction.is_empty()
+            || !root.helicity_weight.is_finite()
+            || root.coherent_group_id.as_ref().is_some_and(Value::is_null)
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic amplitude root {index} has inconsistent physics metadata"
+            )));
+        }
+        validate_amplitude_root_kind(index, root, &schema.current_storage)?;
+        validate_slot_ref(
+            &root.left_slot,
+            root.left_current_id,
+            &schema.current_storage,
+        )?;
+        validate_slot_ref(
+            &root.right_slot,
+            root.right_current_id,
+            &schema.current_storage,
+        )?;
+        validate_value_slot_ref(
+            &root.left_value_slot,
+            root.left_current_id,
+            Some(amplitude_value_variant(
+                &schema.current_storage,
+                root.left_current_id,
+            )?),
+            &schema.value_storage,
+        )?;
+        validate_value_slot_ref(
+            &root.right_value_slot,
+            root.right_current_id,
+            Some(amplitude_value_variant(
+                &schema.current_storage,
+                root.right_current_id,
+            )?),
+            &schema.value_storage,
+        )?;
+        validate_amplitude_contraction(
+            index,
+            root,
+            &schema.current_storage,
+            &schema.value_storage,
+        )?;
+    }
+    Ok(())
+}
+
+pub(super) fn validate_amplitude_contraction(
+    index: usize,
+    root: &GenericAmplitudeRootManifest,
+    current_storage: &GenericCurrentStorageManifest,
+    value_storage: &GenericValueStorageManifest,
+) -> RusticolResult<()> {
+    let contraction = &root.contraction_ir;
+    if contraction.name.is_empty()
+        || contraction.left_basis.is_empty()
+        || contraction.right_basis.is_empty()
+        || contraction.coefficients.is_empty()
+        || contraction
+            .metric_signature
+            .as_ref()
+            .is_some_and(String::is_empty)
+        || contraction
+            .coefficients
+            .iter()
+            .flatten()
+            .any(|component| !component.is_finite())
+        || !contraction
+            .coefficients
+            .iter()
+            .any(|coefficient| *coefficient != [0.0, 0.0])
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic amplitude root {index} has invalid typed contraction metadata"
+        )));
+    }
+    if root.contraction != contraction.name {
+        return Err(RusticolError::artifact(format!(
+            "generic amplitude root {index} contraction projection does not match ContractionIR"
+        )));
+    }
+
+    if root.kind == "vertex-closure" {
+        if contraction.coefficients.len() != 1
+            || contraction.left_basis != "scalar"
+            || contraction.right_basis != "scalar"
+            || contraction.chirality_relation != GenericContractionChiralityRelationManifest::Any
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic vertex-closure root {index} does not declare a scalar projection"
+            )));
+        }
+        return Ok(());
+    }
+
+    let left_current = current_storage
+        .current_slots
+        .get(root.left_current_id)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "generic amplitude root {index} references a missing left current"
+            ))
+        })?;
+    let right_current = current_storage
+        .current_slots
+        .get(root.right_current_id)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "generic amplitude root {index} references a missing right current"
+            ))
+        })?;
+    let left_value = value_storage
+        .value_slots
+        .get(root.left_value_slot.value_slot_id)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "generic amplitude root {index} references a missing left value slot"
+            ))
+        })?;
+    let right_value = value_storage
+        .value_slots
+        .get(root.right_value_slot.value_slot_id)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "generic amplitude root {index} references a missing right value slot"
+            ))
+        })?;
+    if contraction.coefficients.len() != root.left_value_slot.dimension
+        || contraction.coefficients.len() != root.right_value_slot.dimension
+        || contraction.left_basis != left_value.propagator.basis
+        || contraction.right_basis != right_value.propagator.basis
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic amplitude root {index} ContractionIR does not match its value slots"
+        )));
+    }
+    let chirality_matches = contraction_chiralities_match(
+        contraction.chirality_relation,
+        left_current.chirality,
+        right_current.chirality,
+    );
+    if !chirality_matches {
+        return Err(RusticolError::artifact(format!(
+            "generic amplitude root {index} violates its ContractionIR chirality relation"
+        )));
+    }
+    Ok(())
+}
+
+pub(super) fn validate_amplitude_root_kind(
+    index: usize,
+    root: &GenericAmplitudeRootManifest,
+    current_storage: &GenericCurrentStorageManifest,
+) -> RusticolResult<()> {
+    match root.kind.as_str() {
+        "direct-contraction" => {
+            if root.vertex_kind.is_some() || root.vertex_particles.is_some() {
+                return Err(RusticolError::artifact(format!(
+                    "generic direct-contraction root {index} carries vertex metadata"
+                )));
+            }
+        }
+        "vertex-closure" => {
+            let vertex_kind = root.vertex_kind.filter(|kind| *kind > 0).ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "generic vertex-closure root {index} has an invalid vertex kind"
+                ))
+            })?;
+            let particles = root
+                .vertex_particles
+                .as_ref()
+                .filter(|values| values.len() == 3)
+                .ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "generic vertex-closure root {index} is missing vertex particles"
+                    ))
+                })?;
+            let left = current_storage
+                .current_slots
+                .get(root.left_current_id)
+                .ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "generic vertex-closure root {index} references a missing left current"
+                    ))
+                })?;
+            let right = current_storage
+                .current_slots
+                .get(root.right_current_id)
+                .ok_or_else(|| {
+                    RusticolError::artifact(format!(
+                        "generic vertex-closure root {index} references a missing right current"
+                    ))
+                })?;
+            if particles[0] != left.particle_id || particles[1] != right.particle_id {
+                return Err(RusticolError::artifact(format!(
+                    "generic vertex-closure root {index} vertex {vertex_kind} does not match its input currents"
+                )));
+            }
+        }
+        _ => {
+            return Err(RusticolError::artifact(format!(
+                "generic amplitude root {index} has unsupported kind {:?}",
+                root.kind
+            )));
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn valid_current_chirality(chirality: i32) -> bool {
+    (-1..=1).contains(&chirality)
+}
+
+pub(super) fn contraction_chiralities_match(
+    relation: GenericContractionChiralityRelationManifest,
+    left: i32,
+    right: i32,
+) -> bool {
+    match relation {
+        GenericContractionChiralityRelationManifest::Any => true,
+        GenericContractionChiralityRelationManifest::Equal => left == right,
+        GenericContractionChiralityRelationManifest::Opposite => {
+            right.checked_neg().is_some_and(|opposite| left == opposite)
+        }
+    }
+}
+
+fn validate_generic_stage_evaluators(manifest: &ExecutionManifest) -> RusticolResult<()> {
+    let Some(stage_evaluators) = &manifest.compiled.stage_evaluators else {
+        return Ok(());
+    };
+    let schema = &manifest.runtime_schema;
+    let expected_parameter_count = schema.parameter_layout.value_component_count
+        + schema.parameter_layout.momentum_parameter_count
+        + schema.parameter_layout.model_parameter_count;
+    let expected_real_inputs = (schema.parameter_layout.value_component_count
+        ..expected_parameter_count)
+        .collect::<Vec<_>>();
+    let header_is_global = stage_evaluators.parameter_layout == "global-value-momentum"
+        && stage_evaluators.parameter_count == expected_parameter_count
+        && stage_evaluators.value_parameter_count == schema.parameter_layout.value_component_count
+        && stage_evaluators.momentum_parameter_count
+            == schema.parameter_layout.momentum_parameter_count
+        && stage_evaluators.model_parameter_count == schema.parameter_layout.model_parameter_count
+        && stage_evaluators.real_valued_inputs == expected_real_inputs;
+    let header_is_stage_local = stage_evaluators.parameter_layout == "stage-local-value-momentum"
+        && stage_evaluators.parameter_count == 0
+        && stage_evaluators.value_parameter_count == 0
+        && stage_evaluators.momentum_parameter_count == 0
+        && stage_evaluators.model_parameter_count == 0
+        && stage_evaluators.real_valued_inputs.is_empty();
+    if stage_evaluators.kind != "generic-dag-stage-evaluator-artifacts"
+        || (!header_is_global && !header_is_stage_local)
+        || stage_evaluators.stage_count != schema.stages.len() + 1
+        || stage_evaluators.stages.len() != schema.stages.len()
+        || !stage_evaluators.runtime_available
+        || stage_evaluators.runtime_unavailable_message.is_some()
+    {
+        return Err(RusticolError::artifact(
+            "generic stage evaluator artifact header is inconsistent with runtime schema",
+        ));
+    }
+    for (stage, runtime_stage) in stage_evaluators.stages.iter().zip(&schema.stages) {
+        validate_generic_serialized_stage_evaluator(
+            stage,
+            runtime_stage.stage_index,
+            "current-combine",
+            Some(runtime_stage.subset_size),
+            expected_parameter_count,
+            Some(runtime_stage),
+            None,
+        )?;
+    }
+    validate_generic_serialized_stage_evaluator(
+        &stage_evaluators.amplitude_stage,
+        0,
+        "amplitude-roots",
+        None,
+        expected_parameter_count,
+        None,
+        Some(&schema.amplitude_stage),
+    )?;
+    Ok(())
+}
+
+fn validate_generic_serialized_stage_evaluator(
+    stage: &GenericSerializedStageEvaluatorManifest,
+    expected_stage_index: usize,
+    expected_stage_kind: &str,
+    expected_subset_size: Option<usize>,
+    expected_parameter_count: usize,
+    runtime_stage: Option<&GenericStageManifest>,
+    amplitude_stage: Option<&GenericAmplitudeStageManifest>,
+) -> RusticolResult<()> {
+    let stage_is_global = stage.parameter_layout == "global-value-momentum";
+    let stage_is_local = stage.parameter_layout == "stage-local-value-momentum";
+    if stage.stage_index != expected_stage_index
+        || stage.stage_kind != expected_stage_kind
+        || stage.subset_size != expected_subset_size
+        || (!stage_is_global && !stage_is_local)
+        || !stage.expression_ready
+        || !stage.blockers.is_empty()
+        || stage.evaluator_label.is_empty()
+        || stage.output_length == 0
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic serialized stage evaluator {} is inconsistent",
+            stage.evaluator_label
+        )));
+    }
+    validate_generic_stage_output_slots(stage)?;
+    let (input_len, output_len) = stage.evaluator.io_len()?;
+    if stage_is_global && input_len != expected_parameter_count {
+        return Err(RusticolError::artifact(format!(
+            "generic serialized stage evaluator {} has inconsistent global evaluator input length",
+            stage.evaluator_label
+        )));
+    }
+    if stage_is_local {
+        validate_generic_stage_input_components(stage, expected_parameter_count)?;
+        if input_len != stage.parameter_count
+            || stage.parameter_count != stage.input_components.len()
+            || stage.value_parameter_count
+                + stage.momentum_parameter_count
+                + stage.model_parameter_count
+                != stage.parameter_count
+            || stage
+                .real_valued_inputs
+                .iter()
+                .any(|index| *index >= stage.parameter_count)
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic serialized stage evaluator {} has inconsistent local evaluator input metadata",
+                stage.evaluator_label
+            )));
+        }
+    }
+    if output_len != stage.output_length {
+        return Err(RusticolError::artifact(format!(
+            "generic serialized stage evaluator {} has inconsistent evaluator IO",
+            stage.evaluator_label
+        )));
+    }
+    if let Some(runtime_stage) = runtime_stage {
+        let expected_interactions = if runtime_stage.interactions_compacted {
+            runtime_stage.interaction_ids.clone()
+        } else {
+            runtime_stage
+                .interactions
+                .iter()
+                .map(|interaction| interaction.interaction_id)
+                .collect::<Vec<_>>()
+        };
+        if stage.input_value_slot_ids != runtime_stage.input_value_slot_ids
+            || stage.output_value_slot_ids != runtime_stage.output_value_slot_ids
+            || stage.interaction_ids != expected_interactions
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic serialized stage evaluator {} does not match runtime stage slots",
+                stage.evaluator_label
+            )));
+        }
+    }
+    if let Some(amplitude_stage) = amplitude_stage
+        && (!stage.output_value_slot_ids.is_empty()
+            || !stage.interaction_ids.is_empty()
+            || stage.output_length != amplitude_stage.output_count)
+    {
+        return Err(RusticolError::artifact(
+            "generic serialized amplitude evaluator does not match amplitude stage",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_generic_stage_output_slots(
+    stage: &GenericSerializedStageEvaluatorManifest,
+) -> RusticolResult<()> {
+    if stage.output_slots.is_empty() {
+        return Err(RusticolError::artifact(format!(
+            "generic serialized stage evaluator {} has no output slots",
+            stage.evaluator_label
+        )));
+    }
+    let mut max_output_stop = 0usize;
+    for slot in &stage.output_slots {
+        if slot.variant.is_empty()
+            || slot.component_stop < slot.component_start
+            || slot.output_stop <= slot.output_start
+            || slot.output_stop > stage.output_length
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic serialized stage evaluator {} has invalid output slot",
+                stage.evaluator_label
+            )));
+        }
+        if stage.stage_kind == "amplitude-roots" {
+            if slot.value_slot_id != -1 || slot.current_id != -1 || slot.variant != "amplitude-root"
+            {
+                return Err(RusticolError::artifact(
+                    "generic serialized amplitude evaluator has invalid output slot metadata",
+                ));
+            }
+        } else if slot.value_slot_id < 0 || slot.current_id < 0 || slot.variant == "amplitude-root"
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic serialized stage evaluator {} has invalid current output slot metadata",
+                stage.evaluator_label
+            )));
+        }
+        max_output_stop = max_output_stop.max(slot.output_stop);
+    }
+    if max_output_stop != stage.output_length {
+        return Err(RusticolError::artifact(format!(
+            "generic serialized stage evaluator {} output slots do not cover evaluator outputs",
+            stage.evaluator_label
+        )));
+    }
+    Ok(())
+}
+
+fn validate_generic_stage_input_components(
+    stage: &GenericSerializedStageEvaluatorManifest,
+    global_parameter_count: usize,
+) -> RusticolResult<()> {
+    if stage.input_components.is_empty() {
+        return Err(RusticolError::artifact(format!(
+            "generic serialized stage evaluator {} has no local input components",
+            stage.evaluator_label
+        )));
+    }
+    let mut seen_parameters = BTreeSet::new();
+    for component in &stage.input_components {
+        if component.kind != "value"
+            && component.kind != "momentum"
+            && component.kind != "model_parameter"
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic serialized stage evaluator {} has invalid local input kind {:?}",
+                stage.evaluator_label, component.kind
+            )));
+        }
+        if component.global_component >= global_parameter_count
+            || component.parameter_index >= stage.parameter_count
+            || component.source_id >= global_parameter_count
+            || component.component >= global_parameter_count
+            || !seen_parameters.insert(component.parameter_index)
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic serialized stage evaluator {} has invalid local input component map",
+                stage.evaluator_label
+            )));
+        }
+        if component.real_valued
+            && component.kind != "momentum"
+            && component.kind != "model_parameter"
+        {
+            return Err(RusticolError::artifact(format!(
+                "generic serialized stage evaluator {} marks a complex local input as real",
+                stage.evaluator_label
+            )));
+        }
+    }
+    if seen_parameters.len() != stage.parameter_count {
+        return Err(RusticolError::artifact(format!(
+            "generic serialized stage evaluator {} local input map is not dense",
+            stage.evaluator_label
+        )));
+    }
+    let real_inputs = stage
+        .input_components
+        .iter()
+        .filter_map(|component| {
+            if component.real_valued {
+                Some(component.parameter_index)
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<_>>();
+    if real_inputs != stage.real_valued_inputs {
+        return Err(RusticolError::artifact(format!(
+            "generic serialized stage evaluator {} local real-input metadata is inconsistent",
+            stage.evaluator_label
+        )));
+    }
+    Ok(())
+}
+
+pub(super) fn validate_slot_ref(
+    slot: &GenericSlotRefManifest,
+    current_id: usize,
+    current_storage: &GenericCurrentStorageManifest,
+) -> RusticolResult<()> {
+    if slot.current_id != current_id
+        || slot.component_stop != slot.component_start + slot.dimension
+        || slot.dimension == 0
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic slot reference for current {current_id} is inconsistent"
+        )));
+    }
+    let storage_slot = current_storage
+        .current_slots
+        .get(current_id)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "generic slot reference for current {current_id} points outside current storage"
+            ))
+        })?;
+    if storage_slot.current_id != slot.current_id
+        || storage_slot.component_start != slot.component_start
+        || storage_slot.component_stop != slot.component_stop
+        || storage_slot.dimension != slot.dimension
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic slot reference for current {current_id} does not match current storage"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_value_slot_ref(
+    slot: &GenericValueSlotRefManifest,
+    current_id: usize,
+    expected_variant: Option<&str>,
+    value_storage: &GenericValueStorageManifest,
+) -> RusticolResult<()> {
+    if slot.current_id != current_id
+        || slot.component_stop != slot.component_start + slot.dimension
+        || slot.dimension == 0
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic value slot reference for current {current_id} is inconsistent"
+        )));
+    }
+    if let Some(expected) = expected_variant
+        && slot.variant != expected
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic value slot reference for current {current_id} uses variant {:?}, expected {expected:?}",
+            slot.variant
+        )));
+    }
+    let storage_slot = value_storage
+        .value_slots
+        .get(slot.value_slot_id)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "generic value slot reference for current {current_id} points outside value storage"
+            ))
+        })?;
+    if storage_slot.current_id != slot.current_id
+        || storage_slot.variant != slot.variant
+        || storage_slot.component_start != slot.component_start
+        || storage_slot.component_stop != slot.component_stop
+        || storage_slot.dimension != slot.dimension
+    {
+        return Err(RusticolError::artifact(format!(
+            "generic value slot reference for current {current_id} does not match value storage"
+        )));
+    }
+    Ok(())
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum GenericInputValueVariant {
+    Source,
+    Propagated,
+    Unpropagated,
+}
+
+impl GenericInputValueVariant {
+    fn as_str(self) -> &'static str {
+        match self {
+            Self::Source => "source",
+            Self::Propagated => "propagated",
+            Self::Unpropagated => "unpropagated",
+        }
+    }
+}
+
+fn build_input_value_variants(
+    current_storage: &GenericCurrentStorageManifest,
+    value_storage: &GenericValueStorageManifest,
+) -> RusticolResult<Vec<Option<GenericInputValueVariant>>> {
+    let mut variants = current_storage
+        .current_slots
+        .iter()
+        .map(|current| {
+            current
+                .is_source
+                .then_some(GenericInputValueVariant::Source)
+        })
+        .collect::<Vec<_>>();
+    for slot in &value_storage.value_slots {
+        let current = current_storage
+            .current_slots
+            .get(slot.current_id)
+            .ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "generic value slot references missing current {}",
+                    slot.current_id
+                ))
+            })?;
+        if current.is_source {
+            continue;
+        }
+        match slot.variant.as_str() {
+            "propagated" => {
+                variants[slot.current_id] = Some(GenericInputValueVariant::Propagated);
+            }
+            "unpropagated"
+                if variants[slot.current_id] != Some(GenericInputValueVariant::Propagated) =>
+            {
+                variants[slot.current_id] = Some(GenericInputValueVariant::Unpropagated);
+            }
+            _ => {}
+        }
+    }
+    Ok(variants)
+}
+
+fn input_value_variant(
+    input_value_variants: &[Option<GenericInputValueVariant>],
+    current_id: usize,
+) -> RusticolResult<&'static str> {
+    let variant = input_value_variants.get(current_id).ok_or_else(|| {
+        RusticolError::artifact(format!(
+            "generic input value references missing current {current_id}"
+        ))
+    })?;
+    variant
+        .map(GenericInputValueVariant::as_str)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "generic input value references current {current_id} without an input value slot"
+            ))
+        })
+}
+
+fn amplitude_value_variant(
+    current_storage: &GenericCurrentStorageManifest,
+    current_id: usize,
+) -> RusticolResult<&'static str> {
+    let current = current_storage
+        .current_slots
+        .get(current_id)
+        .ok_or_else(|| {
+            RusticolError::artifact(format!(
+                "generic amplitude value references missing current {current_id}"
+            ))
+        })?;
+    Ok(if current.is_source {
+        "source"
+    } else {
+        "unpropagated"
+    })
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/engine_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/engine_tests.rs
new file mode 100644
index 0000000000..196df30c3f
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/engine_tests.rs
@@ -0,0 +1,6441 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::evaluation::accumulate_selected_lc_replay_resolved_f64;
+use super::physics::certifies_lc_direct_total_source;
+use super::*;
+use serde_json::json;
+
+fn symjit_plane_application_manifest(target: Value) -> SymjitPlaneApplicationManifest {
+    serde_json::from_value(json!({
+        "application_path": "evaluators/kernel.plane.symjit",
+        "application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+        "storage_abi": SYMJIT_APPLICATION_STORAGE_ABI,
+        "element_layout": "split-complex-plane-major",
+        "descriptor_order": "inputs-re-im-then-outputs-re-im",
+        "input_complex_count": 2,
+        "output_complex_count": 1,
+        "input_plane_count": 4,
+        "output_plane_count": 2,
+        "compiler_type": "native",
+        "translation_mode": "symbolica-structured-instructions",
+        "optimization_level": 2,
+        "simd": true,
+        "complex": true,
+        "fast_math": true,
+        "fast_complex": false,
+        "compression": false,
+        "threading": false,
+        "direct_arena": true,
+        "source_digest": "a".repeat(64),
+        "target": target,
+    }))
+    .unwrap()
+}
+
+#[test]
+fn symjit_plane_application_manifest_authenticates_target_shape() {
+    for target in [
+        json!({"word_bits": 64, "endianness": "little"}),
+        json!({
+            "word_bits": 64,
+            "endianness": "little",
+            "triple": "aarch64-apple-darwin",
+            "cpu_features": ["aes", "neon"],
+        }),
+    ] {
+        symjit_plane_application_manifest(target)
+            .validate(2, 1, 2)
+            .unwrap();
+    }
+
+    for target in [
+        json!({"word_bits": 32, "endianness": "little"}),
+        json!({"word_bits": 64, "endianness": "big"}),
+        json!({"word_bits": 64, "endianness": "little", "triple": ""}),
+        json!({"word_bits": 64, "endianness": "little", "cpu_features": "neon"}),
+        json!({
+            "word_bits": 64,
+            "endianness": "little",
+            "cpu_features": ["neon", "neon"],
+        }),
+        json!({"word_bits": 64, "endianness": "little", "unexpected": true}),
+    ] {
+        let error = symjit_plane_application_manifest(target)
+            .validate(2, 1, 2)
+            .unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.message().contains("regenerate"));
+    }
+}
+
+fn native_compiled_direct_application() -> NativeCompiledDirectApplicationManifest {
+    NativeCompiledDirectApplicationManifest {
+        application_abi: "pyamplicol-native-compiled-direct-application-v1".to_string(),
+        function_name: "direct_leaf".to_string(),
+        source_path: "compiled/direct_leaf.cpp".to_string(),
+        library_path: "compiled/libdirect_leaf".to_string(),
+        target: NativeCompiledDirectTargetManifest {
+            triple: "aarch64-apple-darwin".to_string(),
+            cpu_features: vec!["neon".to_string()],
+        },
+        evaluator_state_sha256: "a".repeat(64),
+        instruction_count: 17,
+        temporary_count: 3,
+        input_plane_count: 4,
+        scalar_input_count: 1,
+        output_plane_count: 4,
+        simd_lane_width: 2,
+        logical_stack_bytes: 160,
+        output_semantics: "factor-free-overwrite".to_string(),
+    }
+}
+
+#[test]
+fn native_compiled_direct_application_manifest_validates_shape() {
+    let manifest = EvaluatorManifest::CompiledComplex {
+        runtime_capability: "symbolica.compiled-cpp.complex-f64.v1".to_string(),
+        function_name: "direct_leaf".to_string(),
+        input_len: 3,
+        output_len: 2,
+        library_path: "compiled/liblegacy_leaf".to_string(),
+        evaluator_state_path: Some("compiled/direct_leaf.evaluator.bin".to_string()),
+        number_type: "complex".to_string(),
+        native_direct_application: Some(native_compiled_direct_application()),
+    };
+
+    assert_eq!(manifest.io_len().unwrap(), (3, 2));
+}
+
+#[test]
+fn native_compiled_direct_application_manifest_rejects_inconsistent_stack() {
+    let mut application = native_compiled_direct_application();
+    application.logical_stack_bytes += 32;
+    let manifest = EvaluatorManifest::CompiledComplex {
+        runtime_capability: "symbolica.compiled-cpp.complex-f64.v1".to_string(),
+        function_name: "direct_leaf".to_string(),
+        input_len: 3,
+        output_len: 2,
+        library_path: "compiled/liblegacy_leaf".to_string(),
+        evaluator_state_path: Some("compiled/direct_leaf.evaluator.bin".to_string()),
+        number_type: "complex".to_string(),
+        native_direct_application: Some(application),
+    };
+
+    let error = manifest.io_len().unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("logical stack metadata"));
+}
+
+pub(super) fn test_physics_runtime(color_accuracy: &str) -> PhysicsRuntime {
+    let contracted = color_accuracy != "lc";
+    let color_components = if contracted {
+        vec![crate::ColorComponent::ContractedColor(
+            crate::ContractedColor {
+                id: "contracted".to_string(),
+                index: 0,
+                description: "contracted color sum".to_string(),
+            },
+        )]
+    } else {
+        vec![
+            crate::ColorComponent::LcFlow(crate::LcColorFlow {
+                id: "flow:0".to_string(),
+                index: 0,
+                word: vec![1, 2],
+                representative_id: "flow:0".to_string(),
+                computed: true,
+                coefficient: 1.0,
+            }),
+            crate::ColorComponent::LcFlow(crate::LcColorFlow {
+                id: "flow:1".to_string(),
+                index: 1,
+                word: vec![2, 1],
+                representative_id: "flow:0".to_string(),
+                computed: false,
+                coefficient: 1.0,
+            }),
+        ]
+    };
+    let physical_color_ids = color_components
+        .iter()
+        .map(|item| item.id().to_string())
+        .collect();
+    let mut helicities = vec![
+        crate::Helicity {
+            id: "hel:+-".to_string(),
+            index: 0,
+            values: vec![1, -1, 1],
+            representative_id: "hel:+-".to_string(),
+            computed: true,
+            structural_zero: false,
+            coefficient: 1.0,
+        },
+        crate::Helicity {
+            id: "hel:-+".to_string(),
+            index: 1,
+            values: vec![-1, 1, 1],
+            representative_id: "hel:+-".to_string(),
+            computed: false,
+            structural_zero: false,
+            coefficient: 1.0,
+        },
+    ];
+    if !contracted {
+        helicities.push(crate::Helicity {
+            id: "hel:zero".to_string(),
+            index: 2,
+            values: vec![1, 1, 1],
+            representative_id: "hel:zero".to_string(),
+            computed: false,
+            structural_zero: true,
+            coefficient: 0.0,
+        });
+    }
+    PhysicsRuntime::new(ProcessPhysicsV1 {
+        schema_version: crate::RUNTIME_PHYSICS_SCHEMA_VERSION,
+        kind: "pyamplicol-resolved-physics".to_string(),
+        process_id: "x_x_to_y".to_string(),
+        process: "x x > y".to_string(),
+        color_accuracy: if contracted {
+            if color_accuracy == "nlc" {
+                crate::ColorAccuracy::Nlc
+            } else {
+                crate::ColorAccuracy::Full
+            }
+        } else {
+            crate::ColorAccuracy::Lc
+        },
+        coverage: crate::Coverage {
+            helicities: "complete".to_string(),
+            color: if contracted { "contracted" } else { "complete" }.to_string(),
+            color_kind: if contracted {
+                "contracted-color"
+            } else {
+                "physical-lc-flows"
+            }
+            .to_string(),
+            structural_zero_helicity_count: usize::from(!contracted),
+        },
+        external_particles: vec![
+            test_external_particle(0, "x", 1, crate::ParticleRole::Initial),
+            test_external_particle(1, "x~", -1, crate::ParticleRole::Initial),
+            test_external_particle(2, "y", 23, crate::ParticleRole::Final),
+        ],
+        helicities,
+        color_components,
+        reduction: crate::Reduction {
+            kind: if contracted {
+                crate::ReductionKind::ContractedColor
+            } else {
+                crate::ReductionKind::LcDiagonal
+            },
+            groups: vec![crate::ReductionGroup {
+                id: "group:7".to_string(),
+                representative_helicity_id: "hel:+-".to_string(),
+                physical_helicity_ids: vec!["hel:+-".to_string(), "hel:-+".to_string()],
+                representative_color_id: if contracted {
+                    "contracted".to_string()
+                } else {
+                    "flow:0".to_string()
+                },
+                physical_color_ids,
+            }],
+        },
+        model_parameters: Vec::new(),
+        selectors: crate::SelectorCapabilities {
+            helicity: true,
+            color_flow: !contracted,
+            contracted_color: false,
+        },
+        extensions: BTreeMap::new(),
+    })
+    .unwrap()
+}
+
+#[test]
+fn total_selector_canonicalization_elides_only_exact_authenticated_axes() {
+    let physics = test_physics_runtime("lc");
+    let all_helicities = physics
+        .manifest
+        .helicities
+        .iter()
+        .map(|helicity| helicity.id.clone())
+        .collect::<BTreeSet<_>>();
+    let all_colors = physics
+        .manifest
+        .color_components
+        .iter()
+        .map(|color| color.id().to_string())
+        .collect::<BTreeSet<_>>();
+    assert!(
+        physics
+            .canonical_total_helicity_selector(Some(&all_helicities))
+            .is_none()
+    );
+    assert!(
+        physics
+            .canonical_total_color_selector(Some(&all_colors))
+            .is_none()
+    );
+
+    let helicity_subset = BTreeSet::from(["hel:+-".to_string()]);
+    let color_subset = BTreeSet::from(["flow:0".to_string()]);
+    assert_eq!(
+        physics.canonical_total_helicity_selector(Some(&helicity_subset)),
+        Some(&helicity_subset)
+    );
+    assert_eq!(
+        physics.canonical_total_color_selector(Some(&color_subset)),
+        Some(&color_subset)
+    );
+
+    let same_size_unknown_helicities = BTreeSet::from([
+        "hel:+-".to_string(),
+        "hel:-+".to_string(),
+        "hel:unknown".to_string(),
+    ]);
+    let same_size_unknown_colors =
+        BTreeSet::from(["flow:0".to_string(), "flow:unknown".to_string()]);
+    let retained_helicities =
+        physics.canonical_total_helicity_selector(Some(&same_size_unknown_helicities));
+    let retained_colors = physics.canonical_total_color_selector(Some(&same_size_unknown_colors));
+    assert_eq!(retained_helicities, Some(&same_size_unknown_helicities));
+    assert_eq!(retained_colors, Some(&same_size_unknown_colors));
+    assert_eq!(
+        physics
+            .selected_helicity_indices(retained_helicities)
+            .unwrap_err()
+            .kind(),
+        crate::RusticolErrorKind::Selector
+    );
+    assert_eq!(
+        physics
+            .selected_color_indices(retained_colors)
+            .unwrap_err()
+            .kind(),
+        crate::RusticolErrorKind::Selector
+    );
+
+    let mut selected_manifest = test_physics_runtime("full").manifest;
+    selected_manifest.helicities.truncate(1);
+    selected_manifest.reduction.groups[0]
+        .physical_helicity_ids
+        .truncate(1);
+    selected_manifest.coverage.helicities = "selected".to_string();
+    let selected_physics = PhysicsRuntime::new(selected_manifest).unwrap();
+    let sole_helicity = BTreeSet::from([selected_physics.manifest.helicities[0].id.clone()]);
+    assert!(
+        selected_physics
+            .canonical_total_helicity_selector(Some(&sole_helicity))
+            .is_none()
+    );
+}
+
+#[test]
+fn compiled_symmetric_group_rejects_exhaustive_runtime_selector_before_canonicalization() {
+    let physics = test_physics_runtime("full");
+    let all_helicities = physics
+        .manifest
+        .helicities
+        .iter()
+        .map(|helicity| helicity.id.clone())
+        .collect::<BTreeSet<_>>();
+    let plan = crate::recurrence::RecurrenceColorContraction::symmetric_group_s3_for_runtime_test(
+        vec![0; 13],
+        13,
+    );
+    let contraction = ColorContractionRuntime {
+        group_count: 0,
+        entries: Vec::new(),
+        repeated_block: None,
+        symmetric_group: Some(CompiledSymmetricGroupColorContraction {
+            plan,
+            ordered_group_indices: Vec::new(),
+            workspace: None,
+        }),
+        group_scratch_f64: Vec::new(),
+    };
+    let mut runtime = empty_generic_runtime();
+    runtime.physics = Some(Arc::new(physics));
+    runtime.amplitude_stage = Some(test_amplitude_runtime(Vec::new(), Some(contraction)));
+    let batch = F64MomentumBatchView::from_contiguous_prevalidated(&[], 1, 0, None).unwrap();
+    let error = runtime
+        .run_f64_selected_into_unprofiled(batch, Some(&all_helicities), None, &mut [0.0])
+        .unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+    assert!(error.message().contains("runtime selectors"));
+}
+
+fn test_external_particle(
+    index: usize,
+    particle: &str,
+    pdg: i32,
+    role: crate::ParticleRole,
+) -> crate::ExternalParticle {
+    crate::ExternalParticle {
+        index,
+        label: index + 1,
+        particle: particle.to_string(),
+        pdg,
+        role,
+        momentum_slot: index,
+        momentum_components: [
+            "E".to_string(),
+            "px".to_string(),
+            "py".to_string(),
+            "pz".to_string(),
+        ],
+    }
+}
+
+fn replay_test_physics() -> PhysicsRuntime {
+    PhysicsRuntime::new(ProcessPhysicsV1 {
+        schema_version: crate::RUNTIME_PHYSICS_SCHEMA_VERSION,
+        kind: "pyamplicol-resolved-physics".to_string(),
+        process_id: "d_dbar_to_g_g".to_string(),
+        process: "d d~ > g g".to_string(),
+        color_accuracy: crate::ColorAccuracy::Lc,
+        coverage: crate::Coverage {
+            helicities: "complete".to_string(),
+            color: "complete".to_string(),
+            color_kind: "physical-lc-flows".to_string(),
+            structural_zero_helicity_count: 0,
+        },
+        external_particles: vec![
+            test_external_particle(0, "d", 1, crate::ParticleRole::Initial),
+            test_external_particle(1, "d~", -1, crate::ParticleRole::Initial),
+            test_external_particle(2, "g", 21, crate::ParticleRole::Final),
+            test_external_particle(3, "g", 21, crate::ParticleRole::Final),
+        ],
+        helicities: vec![
+            crate::Helicity {
+                id: "h:+1,-1,+1,-1".to_string(),
+                index: 0,
+                values: vec![1, -1, 1, -1],
+                computed: true,
+                structural_zero: false,
+                representative_id: "h:+1,-1,+1,-1".to_string(),
+                coefficient: 1.0,
+            },
+            crate::Helicity {
+                id: "h:+1,-1,-1,+1".to_string(),
+                index: 1,
+                values: vec![1, -1, -1, 1],
+                computed: false,
+                structural_zero: false,
+                representative_id: "h:+1,-1,+1,-1".to_string(),
+                coefficient: 1.0,
+            },
+        ],
+        color_components: vec![
+            crate::ColorComponent::LcFlow(crate::LcColorFlow {
+                id: "flow:1,2,3,4".to_string(),
+                index: 0,
+                word: vec![1, 2, 3, 4],
+                computed: true,
+                representative_id: "flow:1,2,3,4".to_string(),
+                coefficient: 1.0,
+            }),
+            crate::ColorComponent::LcFlow(crate::LcColorFlow {
+                id: "flow:1,4,3,2".to_string(),
+                index: 1,
+                word: vec![1, 4, 3, 2],
+                computed: false,
+                representative_id: "flow:1,2,3,4".to_string(),
+                coefficient: 1.0,
+            }),
+            crate::ColorComponent::LcFlow(crate::LcColorFlow {
+                id: "flow:1,2,4,3".to_string(),
+                index: 2,
+                word: vec![1, 2, 4, 3],
+                computed: false,
+                representative_id: "flow:1,2,3,4".to_string(),
+                coefficient: 1.0,
+            }),
+        ],
+        reduction: crate::Reduction {
+            kind: crate::ReductionKind::LcDiagonal,
+            groups: vec![crate::ReductionGroup {
+                id: "reduction:7".to_string(),
+                representative_helicity_id: "h:+1,-1,+1,-1".to_string(),
+                representative_color_id: "flow:1,2,3,4".to_string(),
+                physical_helicity_ids: vec!["h:+1,-1,+1,-1".to_string()],
+                physical_color_ids: vec!["flow:1,2,3,4".to_string()],
+            }],
+        },
+        model_parameters: Vec::new(),
+        selectors: crate::SelectorCapabilities {
+            helicity: true,
+            color_flow: true,
+            contracted_color: false,
+        },
+        extensions: BTreeMap::new(),
+    })
+    .unwrap()
+}
+
+#[test]
+fn lc_replay_routes_materialized_cells_to_public_axes_and_selectors() {
+    let physics = replay_test_physics();
+    let mappings = vec![Vec::new(), vec![(2, 3), (3, 2)]];
+    let routes = vec![
+        vec![LcTopologyReplaySectorRoute {
+            physical_sector_id: 0,
+            materialized_sector_id: 0,
+            weight: 2.0,
+            sign: 1,
+            amplitude_factor: [2.0, 0.0],
+            residual: false,
+        }],
+        vec![LcTopologyReplaySectorRoute {
+            physical_sector_id: 1,
+            materialized_sector_id: 0,
+            weight: 1.0,
+            sign: -1,
+            amplitude_factor: [-1.0, 0.0],
+            residual: false,
+        }],
+    ];
+    let plan = physics
+        .lc_resolved_replay_plan(
+            &mappings,
+            &routes,
+            &BTreeMap::from([(
+                0,
+                LcMaterializedSector {
+                    color_index: 0,
+                    reduction_weight: 2.0,
+                },
+            )]),
+        )
+        .unwrap();
+    assert_eq!(plan.color_count, 3);
+    let replay_selection = physics
+        .select_lc_resolved_replay_plan(
+            &plan,
+            Some(&BTreeSet::from(["h:+1,-1,-1,+1".to_string()])),
+            Some(&BTreeSet::from(["flow:1,2,4,3".to_string()])),
+        )
+        .unwrap();
+    assert_eq!(replay_selection.mapping_indices, vec![1]);
+    assert_eq!(replay_selection.entries.len(), 1);
+    assert_eq!(replay_selection.entries[0].routes.len(), 1);
+    assert_eq!(replay_selection.entries[0].routes[0].source_index, 0);
+    assert_eq!(replay_selection.entries[0].routes[0].target_index, 0);
+    assert_eq!(replay_selection.source_helicity_indices, vec![vec![0]]);
+    assert_eq!(replay_selection.source_color_indices, vec![vec![0]]);
+
+    let materialized = ResolvedValues {
+        values: vec![
+            3.0, 0.0, 0.0, 0.0, 0.0, 0.0, // identity, point 0
+            5.0, 0.0, 0.0, 0.0, 0.0, 0.0, // identity, point 1
+            7.0, 0.0, 0.0, 0.0, 0.0, 0.0, // swap, point 0
+            11.0, 0.0, 0.0, 0.0, 0.0, 0.0, // swap, point 1
+        ],
+        point_count: 4,
+        helicity_indices: vec![0, 1],
+        color_indices: vec![0, 1, 2],
+    };
+    let mut full = vec![0.0; 12];
+    super::evaluation::accumulate_lc_replay_resolved_f64(
+        &mut full,
+        2,
+        &materialized,
+        &plan.entries,
+        6,
+    )
+    .unwrap();
+
+    assert_eq!(
+        full,
+        vec![3.0, 3.0, 0.0, 0.0, 0.0, 7.0, 5.0, 5.0, 0.0, 0.0, 0.0, 11.0]
+    );
+    assert_eq!(full[..6].iter().sum::<f64>(), 2.0 * 3.0 + 7.0);
+    assert_eq!(full[6..].iter().sum::<f64>(), 2.0 * 5.0 + 11.0);
+
+    let selected = super::evaluation::select_resolved_values(
+        full,
+        2,
+        &physics,
+        Some(&BTreeSet::from(["h:+1,-1,-1,+1".to_string()])),
+        Some(&BTreeSet::from(["flow:1,2,4,3".to_string()])),
+    )
+    .unwrap();
+    assert_eq!(selected.helicity_indices, vec![1]);
+    assert_eq!(selected.color_indices, vec![2]);
+    assert_eq!(selected.values, vec![7.0, 11.0]);
+}
+
+#[test]
+fn lc_replay_requires_every_public_flow_reduction_member() {
+    let mut manifest = replay_test_physics().manifest;
+    manifest.color_components.remove(1);
+    manifest.color_components[1] = match manifest.color_components[1].clone() {
+        crate::ColorComponent::LcFlow(mut flow) => {
+            flow.index = 1;
+            crate::ColorComponent::LcFlow(flow)
+        }
+        value => value,
+    };
+    manifest.coverage.color = "selected".to_string();
+    let physics = PhysicsRuntime::new(manifest).unwrap();
+
+    let error = physics
+        .lc_resolved_replay_plan(
+            &vec![Vec::new()],
+            &[vec![LcTopologyReplaySectorRoute {
+                physical_sector_id: 0,
+                materialized_sector_id: 0,
+                weight: 2.0,
+                sign: 1,
+                amplitude_factor: [2.0, 0.0],
+                residual: false,
+            }]],
+            &BTreeMap::from([(
+                0,
+                LcMaterializedSector {
+                    color_index: 0,
+                    reduction_weight: 2.0,
+                },
+            )]),
+        )
+        .unwrap_err();
+
+    assert!(error.to_string().contains("missing replayed LC flow word"));
+}
+
+#[test]
+fn lc_replay_expands_trace_reflection_for_residual_sectors() {
+    fn flow(
+        index: usize,
+        word: &[usize],
+        computed: bool,
+        representative: &[usize],
+    ) -> crate::ColorComponent {
+        let id = format!(
+            "flow:{}",
+            word.iter()
+                .map(usize::to_string)
+                .collect::<Vec<_>>()
+                .join(",")
+        );
+        let representative_id = format!(
+            "flow:{}",
+            representative
+                .iter()
+                .map(usize::to_string)
+                .collect::<Vec<_>>()
+                .join(",")
+        );
+        crate::ColorComponent::LcFlow(crate::LcColorFlow {
+            id,
+            index,
+            word: word.to_vec(),
+            computed,
+            representative_id,
+            coefficient: 1.0,
+        })
+    }
+
+    let mut manifest = replay_test_physics().manifest;
+    manifest.color_components = vec![
+        flow(0, &[1, 2, 3, 4], true, &[1, 2, 3, 4]),
+        flow(1, &[1, 2, 4, 3], false, &[1, 2, 3, 4]),
+        flow(2, &[1, 3, 2, 4], true, &[1, 3, 2, 4]),
+        flow(3, &[1, 3, 4, 2], false, &[1, 2, 3, 4]),
+        flow(4, &[1, 4, 2, 3], false, &[1, 3, 2, 4]),
+        flow(5, &[1, 4, 3, 2], false, &[1, 2, 3, 4]),
+    ];
+    manifest.reduction.groups = vec![
+        crate::ReductionGroup {
+            id: "reduction:0".to_string(),
+            representative_helicity_id: "h:+1,-1,+1,-1".to_string(),
+            representative_color_id: "flow:1,2,3,4".to_string(),
+            physical_helicity_ids: vec!["h:+1,-1,+1,-1".to_string()],
+            physical_color_ids: vec!["flow:1,2,3,4".to_string(), "flow:1,4,3,2".to_string()],
+        },
+        crate::ReductionGroup {
+            id: "reduction:1".to_string(),
+            representative_helicity_id: "h:+1,-1,+1,-1".to_string(),
+            representative_color_id: "flow:1,3,2,4".to_string(),
+            physical_helicity_ids: vec!["h:+1,-1,+1,-1".to_string()],
+            physical_color_ids: vec!["flow:1,3,2,4".to_string(), "flow:1,4,2,3".to_string()],
+        },
+    ];
+    let physics = PhysicsRuntime::new(manifest).unwrap();
+    let mappings = vec![Vec::new(), vec![(2, 3), (3, 2)]];
+    let routes = vec![
+        vec![
+            LcTopologyReplaySectorRoute {
+                physical_sector_id: 0,
+                materialized_sector_id: 0,
+                weight: 2.0,
+                sign: 1,
+                amplitude_factor: [2.0, 0.0],
+                residual: false,
+            },
+            LcTopologyReplaySectorRoute {
+                physical_sector_id: 2,
+                materialized_sector_id: 2,
+                weight: 1.0,
+                sign: 1,
+                amplitude_factor: [1.0, 0.0],
+                residual: true,
+            },
+        ],
+        vec![LcTopologyReplaySectorRoute {
+            physical_sector_id: 1,
+            materialized_sector_id: 0,
+            weight: 2.0,
+            sign: 1,
+            amplitude_factor: [2.0, 0.0],
+            residual: false,
+        }],
+    ];
+    let materialized = BTreeMap::from([
+        (
+            0,
+            LcMaterializedSector {
+                color_index: 0,
+                reduction_weight: 2.0,
+            },
+        ),
+        (
+            2,
+            LcMaterializedSector {
+                color_index: 2,
+                reduction_weight: 2.0,
+            },
+        ),
+    ]);
+
+    let plan = physics
+        .lc_resolved_replay_plan(&mappings, &routes, &materialized)
+        .unwrap();
+    let target_colors = plan
+        .entries
+        .iter()
+        .flat_map(|entry| entry.routes.iter())
+        .map(|route| route.target_index % plan.color_count)
+        .collect::<BTreeSet<_>>();
+
+    assert_eq!(target_colors, (0..6).collect());
+    assert!(
+        plan.entries
+            .iter()
+            .flat_map(|entry| entry.routes.iter())
+            .all(|route| route.weight.to_bits() == 1.0f64.to_bits())
+    );
+}
+
+fn alias_test_physics(color_accuracy: &str) -> ProcessPhysicsV1 {
+    let contracted = color_accuracy != "lc";
+    let representative_helicity_id = "h:+1,-1,+0,+1,-1".to_string();
+    let helicities = vec![
+        crate::Helicity {
+            id: representative_helicity_id.clone(),
+            index: 0,
+            values: vec![1, -1, 0, 1, -1],
+            representative_id: representative_helicity_id.clone(),
+            computed: true,
+            structural_zero: false,
+            coefficient: 1.0,
+        },
+        crate::Helicity {
+            id: "h:-1,+1,+0,-1,+1".to_string(),
+            index: 1,
+            values: vec![-1, 1, 0, -1, 1],
+            representative_id: representative_helicity_id.clone(),
+            computed: false,
+            structural_zero: false,
+            coefficient: 1.0,
+        },
+    ];
+    let (color_components, reduction_kind, representative_color_id, physical_color_ids) =
+        if contracted {
+            (
+                vec![crate::ColorComponent::ContractedColor(
+                    crate::ContractedColor {
+                        id: "color:contracted".to_string(),
+                        index: 0,
+                        description: "contracted color sum".to_string(),
+                    },
+                )],
+                crate::ReductionKind::ContractedColor,
+                "color:contracted".to_string(),
+                vec!["color:contracted".to_string()],
+            )
+        } else {
+            (
+                vec![
+                    crate::ColorComponent::LcFlow(crate::LcColorFlow {
+                        id: "flow:1,3,4,5,2".to_string(),
+                        index: 0,
+                        word: vec![1, 3, 4, 5, 2],
+                        representative_id: "flow:1,3,4,5,2".to_string(),
+                        computed: true,
+                        coefficient: 1.0,
+                    }),
+                    crate::ColorComponent::LcFlow(crate::LcColorFlow {
+                        id: "flow:1,5,4,3,2".to_string(),
+                        index: 1,
+                        word: vec![1, 5, 4, 3, 2],
+                        representative_id: "flow:1,3,4,5,2".to_string(),
+                        computed: false,
+                        coefficient: 1.0,
+                    }),
+                ],
+                crate::ReductionKind::LcDiagonal,
+                "flow:1,3,4,5,2".to_string(),
+                vec!["flow:1,3,4,5,2".to_string(), "flow:1,5,4,3,2".to_string()],
+            )
+        };
+    ProcessPhysicsV1 {
+        schema_version: crate::RUNTIME_PHYSICS_SCHEMA_VERSION,
+        kind: "pyamplicol-resolved-physics".to_string(),
+        process_id: "representative".to_string(),
+        process: "d d~ > z g a".to_string(),
+        color_accuracy: match color_accuracy {
+            "lc" => crate::ColorAccuracy::Lc,
+            "nlc" => crate::ColorAccuracy::Nlc,
+            _ => crate::ColorAccuracy::Full,
+        },
+        coverage: crate::Coverage {
+            helicities: "complete".to_string(),
+            color: if contracted { "contracted" } else { "complete" }.to_string(),
+            color_kind: if contracted {
+                "contracted-color"
+            } else {
+                "physical-lc-flows"
+            }
+            .to_string(),
+            structural_zero_helicity_count: 0,
+        },
+        external_particles: vec![
+            test_external_particle(0, "d", 1, crate::ParticleRole::Initial),
+            test_external_particle(1, "d~", -1, crate::ParticleRole::Initial),
+            test_external_particle(2, "z", 23, crate::ParticleRole::Final),
+            test_external_particle(3, "g", 21, crate::ParticleRole::Final),
+            test_external_particle(4, "a", 22, crate::ParticleRole::Final),
+        ],
+        helicities,
+        color_components,
+        reduction: crate::Reduction {
+            kind: reduction_kind,
+            groups: vec![crate::ReductionGroup {
+                id: "group:7".to_string(),
+                representative_helicity_id,
+                representative_color_id,
+                physical_helicity_ids: vec![
+                    "h:+1,-1,+0,+1,-1".to_string(),
+                    "h:-1,+1,+0,-1,+1".to_string(),
+                ],
+                physical_color_ids,
+            }],
+        },
+        model_parameters: Vec::new(),
+        selectors: crate::SelectorCapabilities {
+            helicity: true,
+            color_flow: !contracted,
+            contracted_color: false,
+        },
+        extensions: BTreeMap::new(),
+    }
+}
+
+fn three_cycle_alias() -> crate::ProcessAlias {
+    crate::ProcessAlias {
+        id: "cycled".to_string(),
+        expression: "d d~ > a z g".to_string(),
+        external_pdgs: vec![1, -1, 22, 23, 21],
+        external_permutation: vec![0, 1, 3, 4, 2],
+    }
+}
+
+fn stored_alias_selection(
+    physics: &ProcessPhysicsV1,
+    alias: &crate::ProcessAlias,
+) -> crate::ArtifactSelection {
+    crate::ArtifactSelection {
+        process: crate::ArtifactProcess {
+            id: physics.process_id.clone(),
+            expression: physics.process.clone(),
+            color_accuracy: physics.color_accuracy.as_str().to_string(),
+            external_pdgs: physics
+                .external_particles
+                .iter()
+                .map(|particle| particle.pdg)
+                .collect(),
+            physics_path: "processes/test/physics.json".to_string(),
+            required_runtime_capabilities: vec!["symjit.application.complex-f64.v1".to_string()],
+            aliases: vec![alias.clone()],
+        },
+        requested_id: alias.id.clone(),
+        alias: Some(alias.clone()),
+        public_expression: alias.expression.clone(),
+        external_pdgs: alias.external_pdgs.clone(),
+        external_permutation: alias.external_permutation.clone(),
+        inferred_permutation: false,
+        process_group: None,
+    }
+}
+
+#[test]
+fn final_state_alias_three_cycle_remaps_lc_metadata_and_selectors() {
+    let representative_manifest = alias_test_physics("lc");
+    representative_manifest.validate().unwrap();
+    let representative_physics = PhysicsRuntime::new(representative_manifest.clone()).unwrap();
+    let alias = three_cycle_alias();
+    let alias_manifest = apply_process_permutation_metadata(
+        representative_manifest.clone(),
+        &stored_alias_selection(&representative_manifest, &alias),
+    )
+    .unwrap();
+
+    let helicity_id_map = representative_manifest
+        .helicities
+        .iter()
+        .zip(&alias_manifest.helicities)
+        .map(|(representative, public)| (representative.id.clone(), public.id.clone()))
+        .collect::<BTreeMap<_, _>>();
+    let color_id_map = representative_manifest
+        .color_components
+        .iter()
+        .zip(&alias_manifest.color_components)
+        .map(|(representative, public)| (representative.id().to_string(), public.id().to_string()))
+        .collect::<BTreeMap<_, _>>();
+    let mut override_runtime = empty_generic_runtime();
+    override_runtime.physics_reduction_override = Some(representative_manifest.reduction.clone());
+    override_runtime
+        .remap_physics_reduction_overrides(&helicity_id_map, &color_id_map)
+        .unwrap();
+    assert_eq!(
+        override_runtime.physics_reduction_override,
+        Some(alias_manifest.reduction.clone())
+    );
+
+    assert_eq!(alias_manifest.process_id, "cycled");
+    assert_eq!(alias_manifest.process, "d d~ > a z g");
+    assert_eq!(
+        alias_manifest
+            .external_particles
+            .iter()
+            .map(|particle| (
+                particle.index,
+                particle.label,
+                particle.momentum_slot,
+                particle.pdg
+            ))
+            .collect::<Vec<_>>(),
+        vec![
+            (0, 1, 0, 1),
+            (1, 2, 1, -1),
+            (2, 3, 2, 22),
+            (3, 4, 3, 23),
+            (4, 5, 4, 21),
+        ]
+    );
+    assert_eq!(
+        alias_manifest
+            .external_particles
+            .iter()
+            .map(|particle| particle.particle.as_str())
+            .collect::<Vec<_>>(),
+        vec!["d", "d~", "a", "z", "g"]
+    );
+    assert_eq!(alias_manifest.helicities[0].values, vec![1, -1, -1, 0, 1]);
+    assert_eq!(alias_manifest.helicities[0].id, "h:+1,-1,-1,+0,+1");
+    assert_eq!(
+        alias_manifest.helicities[1].representative_id,
+        "h:+1,-1,-1,+0,+1"
+    );
+    let PhysicsColorComponentV1::LcFlow(first_flow) = &alias_manifest.color_components[0] else {
+        panic!("expected LC flow");
+    };
+    let PhysicsColorComponentV1::LcFlow(second_flow) = &alias_manifest.color_components[1] else {
+        panic!("expected LC flow");
+    };
+    assert_eq!(first_flow.word, vec![1, 4, 5, 3, 2]);
+    assert_eq!(first_flow.id, "flow:1,4,5,3,2");
+    assert_eq!(second_flow.id, "flow:1,3,5,4,2");
+    assert_eq!(second_flow.representative_id, "flow:1,4,5,3,2");
+    assert_eq!(
+        alias_manifest.reduction.groups[0].physical_helicity_ids,
+        vec![
+            "h:+1,-1,-1,+0,+1".to_string(),
+            "h:-1,+1,+1,+0,-1".to_string(),
+        ]
+    );
+    assert_eq!(
+        alias_manifest.reduction.groups[0].physical_color_ids,
+        vec!["flow:1,4,5,3,2".to_string(), "flow:1,3,5,4,2".to_string(),]
+    );
+
+    let alias_physics = PhysicsRuntime::new(alias_manifest.clone()).unwrap();
+    assert_eq!(
+        alias_physics
+            .selected_helicity_indices(Some(&BTreeSet::from(["h:-1,+1,+1,+0,-1".to_string(),])))
+            .unwrap(),
+        vec![1]
+    );
+    assert_eq!(
+        alias_physics
+            .selected_color_indices(Some(&BTreeSet::from(["flow:1,3,5,4,2".to_string(),])))
+            .unwrap(),
+        vec![1]
+    );
+
+    let representative_total = test_amplitude_runtime(vec![c64(2.0, 0.0)], None)
+        .reduce_scratch_f64_resolved(1, &representative_physics, 4.0, None, None)
+        .unwrap()
+        .values
+        .iter()
+        .sum::<f64>();
+    let alias_total = test_amplitude_runtime(vec![c64(2.0, 0.0)], None)
+        .reduce_scratch_f64_resolved(1, &alias_physics, 4.0, None, None)
+        .unwrap()
+        .values
+        .iter()
+        .sum::<f64>();
+    assert_eq!(alias_total, representative_total);
+
+    let representative_point = (0..5)
+        .map(|index| [index as f64, index as f64 + 0.1, 0.0, 0.0])
+        .collect::<Vec<_>>();
+    let mut alias_point = vec![[0.0; 4]; 5];
+    for (representative_index, alias_index) in
+        alias.external_permutation.iter().copied().enumerate()
+    {
+        alias_point[alias_index] = representative_point[representative_index];
+    }
+    let crossing_map = alias
+        .external_permutation
+        .iter()
+        .copied()
+        .enumerate()
+        .map(|(target_index, source_index)| InputCrossingMapEntry {
+            target_index,
+            source_index,
+            sign: 1.0,
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(
+        apply_input_crossing_map(vec![alias_point], 5, Some(&crossing_map)).unwrap(),
+        vec![representative_point]
+    );
+
+    let mut execution = empty_generic_runtime();
+    execution.external_pdg_order = alias.external_pdgs.clone();
+    execution.external_count = 5;
+    execution.physics = Some(Arc::new(alias_physics));
+    let runtime = NativeRuntime {
+        root: PathBuf::new(),
+        artifact_id: "0".repeat(64),
+        runtime: execution,
+        execution_lane: NativeExecutionLane::Compiled,
+        process: alias.expression,
+        process_key: alias.id,
+        representative_process_id: "representative".to_string(),
+        external_permutation: alias.external_permutation,
+        input_crossing_map: Some(crossing_map),
+        permutation_alias_of: Some("representative".to_string()),
+        final_state_permutation_alias_of: Some("representative".to_string()),
+        physics_v1: native_runtime::LazyProcessPhysicsV1::loaded(alias_manifest),
+        warnings_muted: false,
+        warned_kinds: BTreeSet::new(),
+        pending_warnings: Vec::new(),
+        point_selector_scratch: PointSelectorExecutionScratch::default(),
+        selector_simd_lane_width: 1,
+        correlated: None,
+        process_group: None,
+    };
+    let metadata = runtime.metadata();
+    assert_eq!(metadata.external_pdg_order, vec![1, -1, 22, 23, 21]);
+    assert_eq!(metadata.external_permutation, vec![0, 1, 3, 4, 2]);
+    assert_eq!(
+        metadata.permutation_alias_of.as_deref(),
+        Some("representative")
+    );
+    assert_eq!(
+        metadata.final_state_permutation_alias_of.as_deref(),
+        Some("representative")
+    );
+    let exact_state: serde_json::Value =
+        serde_json::from_str(&runtime.exact_runtime_state_json().unwrap()).unwrap();
+    assert_eq!(exact_state["representative_process_id"], "representative");
+    assert_eq!(exact_state["representative_process_key"], "p0");
+    assert_eq!(
+        exact_state["external_permutation"],
+        serde_json::json!([0, 1, 3, 4, 2])
+    );
+}
+
+fn conjugated_member_selection(physics: &ProcessPhysicsV1) -> crate::ArtifactSelection {
+    let mut selection = stored_alias_selection(physics, &three_cycle_alias());
+    selection.process.aliases.clear();
+    selection.alias = None;
+    selection.requested_id = "s_sbar_member".to_string();
+    selection.public_expression = "s~ s > a z g".to_string();
+    selection.external_pdgs = vec![-3, 3, 22, 23, 21];
+    selection.external_permutation = vec![1, 0, 3, 4, 2];
+    selection.process_group = Some(crate::ProcessGroupRelation {
+        factor_numerator: 3,
+        factor_denominator: 2,
+        conjugated: true,
+        external_particles: ["s~", "s", "a", "z", "g"].map(str::to_string).to_vec(),
+    });
+    selection
+}
+
+#[test]
+fn process_group_member_relabels_flavours_and_reverses_lc_words() {
+    let representative = alias_test_physics("lc");
+    let selection = conjugated_member_selection(&representative);
+    let execution = apply_process_permutation_metadata(representative, &selection).unwrap();
+    let public = apply_process_group_metadata(&execution, &selection).unwrap();
+
+    assert_eq!(public.process_id, "s_sbar_member");
+    assert_eq!(public.process, "s~ s > a z g");
+    assert_eq!(
+        public
+            .external_particles
+            .iter()
+            .map(|particle| (particle.particle.as_str(), particle.pdg))
+            .collect::<Vec<_>>(),
+        [("s~", -3), ("s", 3), ("a", 22), ("z", 23), ("g", 21)]
+    );
+    // Execution keeps the representative flavours in the public order.
+    assert_eq!(
+        execution
+            .external_particles
+            .iter()
+            .map(|particle| particle.pdg)
+            .collect::<Vec<_>>(),
+        [-1, 1, 22, 23, 21]
+    );
+    assert_eq!(execution.helicities, public.helicities);
+    for (execution_color, public_color) in execution
+        .color_components
+        .iter()
+        .zip(&public.color_components)
+    {
+        let (
+            PhysicsColorComponentV1::LcFlow(execution_flow),
+            PhysicsColorComponentV1::LcFlow(public_flow),
+        ) = (execution_color, public_color)
+        else {
+            panic!("expected LC flows");
+        };
+        let mut reversed = execution_flow.word.clone();
+        reversed.reverse();
+        assert_eq!(public_flow.word, reversed);
+        assert_eq!(
+            public_flow.id,
+            format!(
+                "flow:{}",
+                reversed
+                    .iter()
+                    .map(usize::to_string)
+                    .collect::<Vec<_>>()
+                    .join(",")
+            )
+        );
+        assert_eq!(
+            charge_conjugate_color_id(&public_flow.id),
+            execution_flow.id
+        );
+        assert_eq!(
+            charge_conjugate_color_id(&execution_flow.representative_id),
+            public_flow.representative_id
+        );
+    }
+    assert_eq!(
+        public.reduction.groups[0].physical_color_ids,
+        execution.reduction.groups[0]
+            .physical_color_ids
+            .iter()
+            .map(|id| charge_conjugate_color_id(id).into_owned())
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(charge_conjugate_color_id("flow:singlet"), "flow:singlet");
+    assert_eq!(charge_conjugate_color_id("flow:7"), "flow:7");
+    assert_eq!(
+        charge_conjugate_color_id("color:contracted"),
+        "color:contracted"
+    );
+
+    let contracted = alias_test_physics("full");
+    let selection = conjugated_member_selection(&contracted);
+    let execution = apply_process_permutation_metadata(contracted, &selection).unwrap();
+    let public = apply_process_group_metadata(&execution, &selection).unwrap();
+    assert_eq!(public.color_components, execution.color_components);
+    assert_eq!(public.reduction, execution.reduction);
+}
+
+#[test]
+fn process_group_runtime_scales_outputs_and_translates_color_ids() {
+    let representative = alias_test_physics("lc");
+    let selection = conjugated_member_selection(&representative);
+    let execution_physics = apply_process_permutation_metadata(representative, &selection).unwrap();
+    let public_physics = apply_process_group_metadata(&execution_physics, &selection).unwrap();
+    let mut execution = empty_generic_runtime();
+    execution.external_count = 5;
+    execution.physics = Some(Arc::new(
+        PhysicsRuntime::new(execution_physics.clone()).unwrap(),
+    ));
+    let mut runtime = NativeRuntime {
+        root: PathBuf::new(),
+        artifact_id: "0".repeat(64),
+        runtime: execution,
+        execution_lane: NativeExecutionLane::Compiled,
+        process: selection.public_expression.clone(),
+        process_key: selection.requested_id.clone(),
+        representative_process_id: "representative".to_string(),
+        external_permutation: selection.external_permutation.clone(),
+        input_crossing_map: None,
+        permutation_alias_of: Some("p0".to_string()),
+        final_state_permutation_alias_of: None,
+        process_group: None,
+        physics_v1: native_runtime::LazyProcessPhysicsV1::loaded(public_physics.clone()),
+        warnings_muted: false,
+        warned_kinds: BTreeSet::new(),
+        pending_warnings: Vec::new(),
+        point_selector_scratch: PointSelectorExecutionScratch::default(),
+        selector_simd_lane_width: 1,
+        correlated: None,
+    };
+
+    // Without a relation, values and IDs pass through unchanged.
+    let mut values = [2.0, 6.0];
+    runtime.apply_process_group_factor(&mut values);
+    assert_eq!(values, [2.0, 6.0]);
+    let caller = ["flow:2,3,5,4,1".to_string()];
+    assert_eq!(
+        runtime.execution_color_ids(Some(&caller)).as_deref(),
+        Some(&caller[..])
+    );
+
+    runtime.process_group = Some(Box::new(ProcessGroupRouting {
+        representative_process_key: "p0".to_string(),
+        factor: NativeRationalFactor {
+            numerator: 3,
+            denominator: 2,
+        },
+        conjugated: true,
+    }));
+    runtime.apply_process_group_factor(&mut values);
+    assert_eq!(values, [3.0, 9.0]);
+    let public_ids = runtime.color_ids().unwrap();
+    let execution_ids = runtime
+        .execution_color_ids(Some(&public_ids))
+        .expect("translated IDs")
+        .into_owned();
+    assert_eq!(
+        execution_ids,
+        execution_physics
+            .color_components
+            .iter()
+            .map(|color| color.id().to_string())
+            .collect::<Vec<_>>()
+    );
+    let mut round_trip = execution_ids.clone();
+    runtime.publish_color_ids(&mut round_trip);
+    assert_eq!(round_trip, public_ids);
+
+    let metadata = runtime.metadata();
+    assert_eq!(metadata.process_group_member_of.as_deref(), Some("p0"));
+    assert_eq!(
+        metadata.process_group_factor,
+        NativeRationalFactor {
+            numerator: 3,
+            denominator: 2
+        }
+    );
+    assert!(metadata.charge_conjugated);
+    let exact_state: serde_json::Value =
+        serde_json::from_str(&runtime.exact_runtime_state_json().unwrap()).unwrap();
+    assert_eq!(
+        exact_state["process_group_factor"],
+        serde_json::json!({"numerator": 3, "denominator": 2})
+    );
+    assert_eq!(exact_state["charge_conjugated"], true);
+    assert_eq!(exact_state["process_group_member_of"], "p0");
+}
+
+#[test]
+fn incoming_and_outgoing_process_permutation_remaps_all_resolved_metadata() {
+    let representative = alias_test_physics("lc");
+    let alias = crate::ProcessAlias {
+        id: "both-sides".to_string(),
+        expression: "d~ d > a z g".to_string(),
+        external_pdgs: vec![-1, 1, 22, 23, 21],
+        external_permutation: vec![1, 0, 3, 4, 2],
+    };
+    let selection = stored_alias_selection(&representative, &alias);
+    let public = apply_process_permutation_metadata(representative, &selection).unwrap();
+
+    assert_eq!(public.process_id, "both-sides");
+    assert_eq!(public.process, "d~ d > a z g");
+    assert_eq!(
+        public
+            .external_particles
+            .iter()
+            .map(|particle| (particle.index, particle.pdg, particle.role))
+            .collect::<Vec<_>>(),
+        vec![
+            (0, -1, crate::ParticleRole::Initial),
+            (1, 1, crate::ParticleRole::Initial),
+            (2, 22, crate::ParticleRole::Final),
+            (3, 23, crate::ParticleRole::Final),
+            (4, 21, crate::ParticleRole::Final),
+        ]
+    );
+    assert_eq!(public.helicities[0].values, [-1, 1, -1, 0, 1]);
+    assert_eq!(public.helicities[0].id, "h:-1,+1,-1,+0,+1");
+    let PhysicsColorComponentV1::LcFlow(flow) = &public.color_components[0] else {
+        panic!("expected LC flow");
+    };
+    assert_eq!(flow.word, [2, 4, 5, 3, 1]);
+    assert_eq!(flow.id, "flow:2,4,5,3,1");
+    assert_eq!(
+        public.reduction.groups[0].representative_helicity_id,
+        "h:-1,+1,-1,+0,+1"
+    );
+    assert_eq!(
+        public.reduction.groups[0].representative_color_id,
+        "flow:2,4,5,3,1"
+    );
+}
+
+#[test]
+fn final_state_alias_three_cycle_preserves_contracted_color_reduction() {
+    let representative_manifest = alias_test_physics("full");
+    representative_manifest.validate().unwrap();
+    let representative_physics = PhysicsRuntime::new(representative_manifest.clone()).unwrap();
+    let alias = three_cycle_alias();
+    let alias_manifest = apply_process_permutation_metadata(
+        representative_manifest.clone(),
+        &stored_alias_selection(&representative_manifest, &alias),
+    )
+    .unwrap();
+    let alias_physics = PhysicsRuntime::new(alias_manifest.clone()).unwrap();
+
+    assert_eq!(alias_manifest.color_components[0].id(), "color:contracted");
+    assert_eq!(
+        alias_manifest.reduction.groups[0].representative_color_id,
+        "color:contracted"
+    );
+    assert_eq!(
+        alias_physics
+            .selected_helicity_indices(Some(&BTreeSet::from(["h:-1,+1,+1,+0,-1".to_string(),])))
+            .unwrap(),
+        vec![1]
+    );
+    assert_eq!(
+        alias_physics
+            .selected_color_indices(Some(&BTreeSet::from(["color:contracted".to_string()])))
+            .unwrap(),
+        vec![0]
+    );
+
+    let contraction = || {
+        let groups = [RawSumGroup {
+            id: 7,
+            indices: vec![0],
+            weight: 1.0,
+            all_sector_weight: 1.0,
+            sector_ids: vec![0],
+        }];
+        ColorContractionRuntime::new(
+            &groups,
+            vec![ColorContractionEntry {
+                left_group_index: 0,
+                right_group_index: 0,
+                weight_re: 2.0,
+                weight_im: 0.0,
+                symmetry_factor: 1.0,
+            }],
+        )
+    };
+    let representative_total = test_amplitude_runtime(vec![c64(3.0, 0.0)], Some(contraction()))
+        .reduce_scratch_f64_resolved(1, &representative_physics, 2.0, None, None)
+        .unwrap()
+        .values
+        .iter()
+        .sum::<f64>();
+    let alias_total = test_amplitude_runtime(vec![c64(3.0, 0.0)], Some(contraction()))
+        .reduce_scratch_f64_resolved(1, &alias_physics, 2.0, None, None)
+        .unwrap()
+        .values
+        .iter()
+        .sum::<f64>();
+    assert_eq!(alias_total, representative_total);
+}
+
+fn empty_evaluator_group() -> EvaluatorGroup {
+    EvaluatorGroup {
+        evaluators: Vec::new(),
+        input_len: 0,
+        input_mappings: Vec::new(),
+        input_mapping_spans: Vec::new(),
+        output_len: 0,
+        chunk_parameter_scratch_f64: Vec::new(),
+        chunk_scratch_f64: Vec::new(),
+        chunk_parameter_scratch_aosoa_f64: Vec::new(),
+        chunk_scratch_aosoa_f64: Vec::new(),
+        chunk_input_mapping_scratch: Vec::new(),
+    }
+}
+
+fn test_amplitude_runtime(
+    outputs: Vec<Complex<f64>>,
+    color_contraction: Option<ColorContractionRuntime>,
+) -> AmplitudeRuntime {
+    let output_length = outputs.len();
+    AmplitudeRuntime {
+        output_length,
+        raw_sum_weights: vec![1.0; output_length],
+        raw_sum_all_sector_weights: vec![1.0; output_length],
+        raw_sum_color_sector_ids: vec![None; output_length],
+        raw_sum_groups: vec![RawSumGroup {
+            id: 7,
+            indices: (0..output_length).collect(),
+            weight: 1.0,
+            all_sector_weight: 1.0,
+            sector_ids: vec![0],
+        }],
+        has_coherent_groups: true,
+        color_contraction,
+        color_topology_replay: None,
+        input_components: None,
+        input_spans: Vec::new(),
+        parameter_scratch_f64: Vec::new(),
+        evaluator_output_scratch_f64: Vec::new(),
+        output_scratch_f64: outputs,
+        resolved_source_row_scratch_f64: Vec::new(),
+        resolved_target_row_scratch_f64: Vec::new(),
+        routed_reduction_scratch: RoutedReductionScratch::default(),
+        materialized_helicity_direct_total_plans: Vec::new(),
+        materialized_helicity_direct_total_plan_capacity: 0,
+        materialized_helicity_direct_total_next_replacement: 0,
+        materialized_helicity_direct_default_plan_by_selector_domain: Vec::new(),
+        evaluator_output_order: None,
+        evaluator: Some(empty_evaluator_group()),
+    }
+}
+
+fn plane_native_totals(
+    amplitude: &mut AmplitudeRuntime,
+    outputs: &[Complex<f64>],
+    batch_size: usize,
+    selected_color_sector_ids: Option<&BTreeSet<i64>>,
+) -> Vec<f64> {
+    assert_eq!(outputs.len(), batch_size * amplitude.output_length);
+    let mut workspace = crate::direct_arena::DirectArenaWorkspace::new(
+        0,
+        amplitude.output_length as u32,
+        batch_size as u32,
+    )
+    .unwrap();
+    workspace.begin_tile(batch_size as u32).unwrap();
+    let stride = workspace.point_stride() as usize;
+    {
+        let (_, _, values_re, values_im) = workspace.split_slices_mut();
+        values_re.fill(73.0);
+        values_im.fill(-91.0);
+        for point in 0..batch_size {
+            for component in 0..amplitude.output_length {
+                let value = outputs[point * amplitude.output_length + component];
+                values_re[component * stride + point] = value.re;
+                values_im[component * stride + point] = value.im;
+            }
+        }
+    }
+    let mut totals = vec![f64::from_bits(0x7ff8_0000_0000_0042); batch_size];
+    {
+        let (values_re, values_im) = workspace.amplitude_slices();
+        let planes = crate::direct_arena::DirectAmplitudePlanes::new(
+            values_re,
+            values_im,
+            stride as u32,
+            batch_size as u32,
+        )
+        .unwrap();
+        amplitude
+            .reduce_planes_f64_into_selected_slice(planes, &mut totals, selected_color_sector_ids)
+            .unwrap();
+    }
+    let (values_re, values_im) = workspace.amplitude_slices();
+    for component in 0..amplitude.output_length {
+        assert!(
+            values_re[component * stride + batch_size..(component + 1) * stride]
+                .iter()
+                .all(|value| *value == 73.0)
+        );
+        assert!(
+            values_im[component * stride + batch_size..(component + 1) * stride]
+                .iter()
+                .all(|value| *value == -91.0)
+        );
+    }
+    totals
+}
+
+fn with_plane_native_amplitudes<T>(
+    outputs: &[Complex<f64>],
+    batch_size: usize,
+    output_length: usize,
+    reduce: impl FnOnce(crate::direct_arena::DirectAmplitudePlanes<'_>) -> T,
+) -> T {
+    assert_eq!(outputs.len(), batch_size * output_length);
+    let mut workspace =
+        crate::direct_arena::DirectArenaWorkspace::new(0, output_length as u32, batch_size as u32)
+            .unwrap();
+    workspace.begin_tile(batch_size as u32).unwrap();
+    let stride = workspace.point_stride() as usize;
+    const PAD_RE: f64 = 73.0;
+    const PAD_IM: f64 = -91.0;
+    {
+        let (_, _, values_re, values_im) = workspace.split_slices_mut();
+        values_re.fill(PAD_RE);
+        values_im.fill(PAD_IM);
+        for point in 0..batch_size {
+            for component in 0..output_length {
+                let value = outputs[point * output_length + component];
+                values_re[component * stride + point] = value.re;
+                values_im[component * stride + point] = value.im;
+            }
+        }
+    }
+    let reduced = {
+        let (values_re, values_im) = workspace.amplitude_slices();
+        let planes = crate::direct_arena::DirectAmplitudePlanes::new(
+            values_re,
+            values_im,
+            stride as u32,
+            batch_size as u32,
+        )
+        .unwrap();
+        reduce(planes)
+    };
+    let (values_re, values_im) = workspace.amplitude_slices();
+    for component in 0..output_length {
+        assert!(
+            values_re[component * stride + batch_size..(component + 1) * stride]
+                .iter()
+                .all(|value| *value == PAD_RE)
+        );
+        assert!(
+            values_im[component * stride + batch_size..(component + 1) * stride]
+                .iter()
+                .all(|value| *value == PAD_IM)
+        );
+    }
+    reduced
+}
+
+fn assert_resolved_values_equal(left: &ResolvedValues<f64>, right: &ResolvedValues<f64>) {
+    assert_eq!(left.point_count, right.point_count);
+    assert_eq!(left.helicity_indices, right.helicity_indices);
+    assert_eq!(left.color_indices, right.color_indices);
+    assert_eq!(left.values, right.values);
+}
+
+#[test]
+fn plane_native_lc_totals_match_selected_row_major_odd_tail_and_structural_zero() {
+    const POINT_COUNT: usize = 129;
+    const OUTPUT_COUNT: usize = 5;
+    let outputs = (0..POINT_COUNT)
+        .flat_map(|point| {
+            (0..OUTPUT_COUNT).map(move |output| {
+                if output == 3 {
+                    c64(0.0, 0.0)
+                } else {
+                    c64(
+                        (point * 7 + output * 3) as f64 * 0.03125 - 2.0,
+                        (point * 5 + output * 11) as f64 * -0.015625 + 1.0,
+                    )
+                }
+            })
+        })
+        .collect::<Vec<_>>();
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), None);
+    amplitude.output_length = OUTPUT_COUNT;
+    amplitude.has_coherent_groups = false;
+    amplitude.raw_sum_groups.clear();
+    amplitude.raw_sum_weights = vec![1.0, 0.5, 2.0, 17.0, -0.25];
+    amplitude.raw_sum_all_sector_weights = vec![1.25, 0.75, 3.0, 19.0, -0.5];
+    amplitude.raw_sum_color_sector_ids = vec![Some(10), Some(20), Some(10), Some(30), Some(20)];
+
+    for selected in [None, Some(BTreeSet::from([20_i64]))] {
+        let mut row_major = vec![f64::NAN; POINT_COUNT];
+        amplitude
+            .reduce_scratch_f64_into_selected_slice(POINT_COUNT, &mut row_major, selected.as_ref())
+            .unwrap();
+        let plane_native =
+            plane_native_totals(&mut amplitude, &outputs, POINT_COUNT, selected.as_ref());
+        assert_eq!(plane_native, row_major);
+    }
+}
+
+#[test]
+fn row_major_reduction_dimensions_fail_closed_before_indexing() {
+    let mut amplitude = test_amplitude_runtime(vec![c64(1.0, 0.0), c64(2.0, 0.0)], None);
+    let error = amplitude
+        .reduce_scratch_f64_into_selected_slice(usize::MAX, &mut [], None)
+        .unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::InvalidArgument);
+    assert!(error.to_string().contains("dimensions overflow"));
+}
+
+#[cfg(not(feature = "f64-symjit"))]
+#[test]
+fn warmed_plane_native_reduction_allocates_zero() {
+    const POINT_COUNT: usize = 129;
+    const OUTPUT_COUNT: usize = 5;
+    let outputs = (0..POINT_COUNT * OUTPUT_COUNT)
+        .map(|index| c64(index as f64 * 0.03125 - 3.0, index as f64 * -0.015625 + 2.0))
+        .collect::<Vec<_>>();
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), None);
+    amplitude.output_length = OUTPUT_COUNT;
+    amplitude.has_coherent_groups = false;
+    amplitude.raw_sum_groups.clear();
+    amplitude.raw_sum_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_all_sector_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_color_sector_ids = vec![None; OUTPUT_COUNT];
+
+    let mut workspace =
+        crate::direct_arena::DirectArenaWorkspace::new(0, OUTPUT_COUNT as u32, POINT_COUNT as u32)
+            .unwrap();
+    workspace.begin_tile(POINT_COUNT as u32).unwrap();
+    let stride = workspace.point_stride() as usize;
+    {
+        let (_, _, values_re, values_im) = workspace.split_slices_mut();
+        for point in 0..POINT_COUNT {
+            for component in 0..OUTPUT_COUNT {
+                let value = outputs[point * OUTPUT_COUNT + component];
+                values_re[component * stride + point] = value.re;
+                values_im[component * stride + point] = value.im;
+            }
+        }
+    }
+    let mut totals = vec![0.0; POINT_COUNT];
+    let (values_re, values_im) = workspace.amplitude_slices();
+    let planes = crate::direct_arena::DirectAmplitudePlanes::new(
+        values_re,
+        values_im,
+        stride as u32,
+        POINT_COUNT as u32,
+    )
+    .unwrap();
+
+    amplitude
+        .reduce_planes_f64_into_selected_slice(planes, &mut totals, None)
+        .unwrap();
+    let (result, allocation_count, allocated_bytes) =
+        super::evaluator::native_direct::tests::count_allocations(|| {
+            amplitude.reduce_planes_f64_into_selected_slice(planes, &mut totals, None)
+        });
+    result.unwrap();
+    assert_eq!(allocation_count, 0, "warmed plane reduction allocated");
+    assert_eq!(allocated_bytes, 0, "warmed plane reduction allocated bytes");
+}
+
+#[cfg(not(feature = "f64-symjit"))]
+#[test]
+fn warmed_plane_native_repeated_contracted_reduction_allocates_zero() {
+    const POINT_COUNT: usize = 129;
+    const COMPONENT_COUNT: usize = 8;
+    const OUTPUT_COUNT: usize = COMPONENT_COUNT * 2;
+    let groups = (0..OUTPUT_COUNT)
+        .map(|output_index| {
+            repeated_test_group(
+                10 + output_index as i64,
+                output_index,
+                if output_index < COMPONENT_COUNT {
+                    100
+                } else {
+                    200
+                },
+            )
+        })
+        .collect::<Vec<_>>();
+    let entries = (0..COMPONENT_COUNT)
+        .map(|component| ColorContractionEntry {
+            left_group_index: component,
+            right_group_index: COMPONENT_COUNT + component,
+            weight_re: 0.75,
+            weight_im: 0.0,
+            symmetry_factor: 2.0,
+        })
+        .collect::<Vec<_>>();
+    let outputs = (0..POINT_COUNT * OUTPUT_COUNT)
+        .map(|index| {
+            c64(
+                (index * 13 % 101) as f64 * 0.03125 - 1.0,
+                (index * 19 % 103) as f64 * -0.015625 + 0.5,
+            )
+        })
+        .collect::<Vec<_>>();
+    let mut amplitude = reduction_test_amplitude(OUTPUT_COUNT, outputs.clone(), groups, entries);
+    let repeated = amplitude
+        .color_contraction
+        .as_ref()
+        .and_then(|contraction| contraction.repeated_block.as_ref())
+        .unwrap();
+    assert_eq!(repeated.component_count, COMPONENT_COUNT);
+    assert!(repeated.all_weights_real);
+
+    let mut workspace =
+        crate::direct_arena::DirectArenaWorkspace::new(0, OUTPUT_COUNT as u32, POINT_COUNT as u32)
+            .unwrap();
+    workspace.begin_tile(POINT_COUNT as u32).unwrap();
+    let stride = workspace.point_stride() as usize;
+    {
+        let (_, _, values_re, values_im) = workspace.split_slices_mut();
+        for point in 0..POINT_COUNT {
+            for component in 0..OUTPUT_COUNT {
+                let value = outputs[point * OUTPUT_COUNT + component];
+                values_re[component * stride + point] = value.re;
+                values_im[component * stride + point] = value.im;
+            }
+        }
+    }
+    let (values_re, values_im) = workspace.amplitude_slices();
+    let planes = crate::direct_arena::DirectAmplitudePlanes::new(
+        values_re,
+        values_im,
+        stride as u32,
+        POINT_COUNT as u32,
+    )
+    .unwrap();
+    let mut totals = vec![0.0; POINT_COUNT];
+    amplitude
+        .reduce_planes_f64_into_selected_slice(planes, &mut totals, None)
+        .unwrap();
+    let (result, allocation_count, allocated_bytes) =
+        super::evaluator::native_direct::tests::count_allocations(|| {
+            amplitude.reduce_planes_f64_into_selected_slice(planes, &mut totals, None)
+        });
+    result.unwrap();
+    assert_eq!(
+        allocation_count, 0,
+        "warmed repeated NLC/full contraction allocated"
+    );
+    assert_eq!(
+        allocated_bytes, 0,
+        "warmed repeated NLC/full contraction allocated bytes"
+    );
+}
+
+#[test]
+fn resolved_lc_reduction_expands_symmetries_and_structural_zeros() {
+    let physics = test_physics_runtime("lc");
+    let mut amplitude = test_amplitude_runtime(vec![c64(2.0, 0.0)], None);
+
+    let resolved = amplitude
+        .reduce_scratch_f64_resolved(1, &physics, 4.0, None, None)
+        .unwrap();
+
+    assert_eq!(resolved.helicity_indices, vec![0, 1, 2]);
+    assert_eq!(resolved.color_indices, vec![0, 1]);
+    assert_eq!(resolved.values, vec![4.0, 4.0, 4.0, 4.0, 0.0, 0.0]);
+    assert_eq!(resolved.values.iter().sum::<f64>(), 16.0);
+
+    let helicities = BTreeSet::from(["hel:-+".to_string()]);
+    let colors = BTreeSet::from(["flow:1".to_string()]);
+    let selected = amplitude
+        .reduce_scratch_f64_resolved(1, &physics, 4.0, Some(&helicities), Some(&colors))
+        .unwrap();
+    assert_eq!(selected.values, vec![4.0]);
+}
+
+#[test]
+fn plane_native_lc_resolved_matches_full_and_selected_row_major_odd_tail() {
+    const POINT_COUNT: usize = 129;
+    let physics = test_physics_runtime("lc");
+    let outputs = (0..POINT_COUNT)
+        .map(|point| c64(point as f64 * 0.03125 - 2.0, point as f64 * -0.015625 + 1.0))
+        .collect::<Vec<_>>();
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), None);
+    amplitude.output_length = 1;
+    amplitude.raw_sum_weights = vec![1.0];
+    amplitude.raw_sum_all_sector_weights = vec![1.0];
+    amplitude.raw_sum_color_sector_ids = vec![None];
+    amplitude.raw_sum_groups[0].indices = vec![0];
+    let selected_helicities = BTreeSet::from(["hel:-+".to_string()]);
+    let selected_colors = BTreeSet::from(["flow:1".to_string()]);
+
+    for (helicities, colors) in [
+        (None, None),
+        (Some(&selected_helicities), Some(&selected_colors)),
+    ] {
+        let row_major = amplitude
+            .reduce_scratch_f64_resolved(POINT_COUNT, &physics, 1.75, helicities, colors)
+            .unwrap();
+        let plane_native = with_plane_native_amplitudes(&outputs, POINT_COUNT, 1, |planes| {
+            amplitude
+                .reduce_planes_f64_resolved(planes, &physics, 1.75, helicities, colors)
+                .unwrap()
+        });
+        assert_resolved_values_equal(&plane_native, &row_major);
+    }
+}
+
+#[test]
+fn plane_native_lc_resolved_routes_preserve_row_major_order() {
+    let physics = test_physics_runtime("lc");
+    let outputs = vec![c64(2.0, -0.5)];
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), None);
+    let replay = LcResolvedReplayEntry {
+        routes: vec![
+            LcResolvedReplayRoute {
+                source_index: 1,
+                target_index: 0,
+                weight: 0.5,
+            },
+            LcResolvedReplayRoute {
+                source_index: 0,
+                target_index: 2,
+                weight: 2.0,
+            },
+            LcResolvedReplayRoute {
+                source_index: 2,
+                target_index: 1,
+                weight: -0.25,
+            },
+            LcResolvedReplayRoute {
+                source_index: 3,
+                target_index: 2,
+                weight: 1.5,
+            },
+        ],
+    };
+    let mut row_major = [f64::NAN];
+    amplitude
+        .reduce_scratch_f64_routed_totals_into(
+            1,
+            &physics,
+            4.0,
+            None,
+            None,
+            &replay,
+            6,
+            3,
+            &mut row_major,
+        )
+        .unwrap();
+
+    let mut workspace = crate::direct_arena::DirectArenaWorkspace::new(0, 1, 1).unwrap();
+    workspace.begin_tile(1).unwrap();
+    let stride = workspace.point_stride();
+    {
+        let (_, _, values_re, values_im) = workspace.split_slices_mut();
+        values_re[0] = outputs[0].re;
+        values_im[0] = outputs[0].im;
+    }
+    let (values_re, values_im) = workspace.amplitude_slices();
+    let planes =
+        crate::direct_arena::DirectAmplitudePlanes::new(values_re, values_im, stride, 1).unwrap();
+    let mut plane_native = [f64::NAN];
+    amplitude
+        .reduce_planes_f64_routed_totals_into(
+            planes,
+            &physics,
+            4.0,
+            None,
+            None,
+            &replay,
+            6,
+            3,
+            &mut plane_native,
+        )
+        .unwrap();
+    assert_eq!(plane_native, row_major);
+}
+
+#[test]
+fn plane_native_lc_routed_components_match_resolved_multi_mapping_accumulation() {
+    const POINT_COUNT: usize = 65;
+    const TARGET_COMPONENT_COUNT: usize = 3;
+    let physics = test_physics_runtime("lc");
+    let mapping_outputs = [
+        (0..POINT_COUNT)
+            .map(|point| c64(point as f64 * 0.03125 - 1.0, point as f64 * -0.015625 + 0.5))
+            .collect::<Vec<_>>(),
+        (0..POINT_COUNT)
+            .map(|point| {
+                c64(
+                    point as f64 * -0.0625 + 2.0,
+                    point as f64 * 0.0078125 - 0.25,
+                )
+            })
+            .collect::<Vec<_>>(),
+    ];
+    let replay_entries = [
+        LcResolvedReplayEntry {
+            routes: vec![
+                LcResolvedReplayRoute {
+                    source_index: 0,
+                    target_index: 2,
+                    weight: 1.25,
+                },
+                LcResolvedReplayRoute {
+                    source_index: 3,
+                    target_index: 0,
+                    weight: -0.5,
+                },
+            ],
+        },
+        LcResolvedReplayEntry {
+            routes: vec![
+                LcResolvedReplayRoute {
+                    source_index: 1,
+                    target_index: 1,
+                    weight: 0.75,
+                },
+                LcResolvedReplayRoute {
+                    source_index: 4,
+                    target_index: 2,
+                    weight: 2.0,
+                },
+            ],
+        },
+    ];
+    let mut amplitude = test_amplitude_runtime(mapping_outputs[0].clone(), None);
+    amplitude.output_length = 1;
+    amplitude.raw_sum_weights = vec![1.0];
+    amplitude.raw_sum_all_sector_weights = vec![1.0];
+    amplitude.raw_sum_color_sector_ids = vec![None];
+    amplitude.raw_sum_groups[0].indices = vec![0];
+    let mut expected = vec![0.0; POINT_COUNT * TARGET_COMPONENT_COUNT];
+    let mut candidate = vec![0.0; POINT_COUNT * TARGET_COMPONENT_COUNT];
+
+    for (outputs, replay_entry) in mapping_outputs.iter().zip(&replay_entries) {
+        let materialized = with_plane_native_amplitudes(outputs, POINT_COUNT, 1, |planes| {
+            amplitude
+                .reduce_planes_f64_resolved(planes, &physics, 1.75, None, None)
+                .unwrap()
+        });
+        accumulate_selected_lc_replay_resolved_f64(
+            &mut expected,
+            POINT_COUNT,
+            &materialized,
+            std::slice::from_ref(replay_entry),
+            6,
+            TARGET_COMPONENT_COUNT,
+        )
+        .unwrap();
+        for (start, stop) in [(0usize, 32usize), (32, POINT_COUNT)] {
+            with_plane_native_amplitudes(&outputs[start..stop], stop - start, 1, |planes| {
+                amplitude
+                    .reduce_planes_f64_routed_components_add_into(
+                        planes,
+                        &physics,
+                        1.75,
+                        None,
+                        None,
+                        replay_entry,
+                        6,
+                        TARGET_COMPONENT_COUNT,
+                        POINT_COUNT,
+                        start,
+                        &mut candidate,
+                    )
+                    .unwrap()
+            });
+        }
+    }
+    assert_eq!(candidate, expected);
+    let candidate_totals = candidate
+        .chunks_exact(TARGET_COMPONENT_COUNT)
+        .map(|components| components.iter().sum::<f64>())
+        .collect::<Vec<_>>();
+    let expected_totals = expected
+        .chunks_exact(TARGET_COMPONENT_COUNT)
+        .map(|components| components.iter().sum::<f64>())
+        .collect::<Vec<_>>();
+    assert_eq!(candidate_totals, expected_totals);
+}
+
+#[cfg(not(feature = "f64-symjit"))]
+#[test]
+fn warmed_plane_native_selected_lc_routes_allocate_zero() {
+    let physics = test_physics_runtime("lc");
+    let outputs = vec![c64(2.0, -0.5)];
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), None);
+    let replay = LcResolvedReplayEntry {
+        routes: vec![LcResolvedReplayRoute {
+            source_index: 0,
+            target_index: 0,
+            weight: 1.25,
+        }],
+    };
+    let helicities = BTreeSet::from(["hel:-+".to_string()]);
+    let colors = BTreeSet::from(["flow:1".to_string()]);
+    let mut workspace = crate::direct_arena::DirectArenaWorkspace::new(0, 1, 1).unwrap();
+    workspace.begin_tile(1).unwrap();
+    let stride = workspace.point_stride();
+    {
+        let (_, _, values_re, values_im) = workspace.split_slices_mut();
+        values_re[0] = outputs[0].re;
+        values_im[0] = outputs[0].im;
+    }
+    let (values_re, values_im) = workspace.amplitude_slices();
+    let planes =
+        crate::direct_arena::DirectAmplitudePlanes::new(values_re, values_im, stride, 1).unwrap();
+    let mut totals = [0.0];
+    amplitude
+        .reduce_planes_f64_routed_totals_into(
+            planes,
+            &physics,
+            4.0,
+            Some(&helicities),
+            Some(&colors),
+            &replay,
+            1,
+            1,
+            &mut totals,
+        )
+        .unwrap();
+    let (result, allocation_count, allocated_bytes) =
+        super::evaluator::native_direct::tests::count_allocations(|| {
+            amplitude.reduce_planes_f64_routed_totals_into(
+                planes,
+                &physics,
+                4.0,
+                Some(&helicities),
+                Some(&colors),
+                &replay,
+                1,
+                1,
+                &mut totals,
+            )
+        });
+    result.unwrap();
+    assert_eq!(
+        allocation_count, 0,
+        "warmed selected LC routed reduction allocated"
+    );
+    assert_eq!(
+        allocated_bytes, 0,
+        "warmed selected LC routed reduction allocated bytes"
+    );
+
+    let mut target_components = [0.0];
+    amplitude
+        .reduce_planes_f64_routed_components_add_into(
+            planes,
+            &physics,
+            4.0,
+            Some(&helicities),
+            Some(&colors),
+            &replay,
+            1,
+            1,
+            1,
+            0,
+            &mut target_components,
+        )
+        .unwrap();
+    target_components.fill(0.0);
+    let (result, allocation_count, allocated_bytes) =
+        super::evaluator::native_direct::tests::count_allocations(|| {
+            amplitude.reduce_planes_f64_routed_components_add_into(
+                planes,
+                &physics,
+                4.0,
+                Some(&helicities),
+                Some(&colors),
+                &replay,
+                1,
+                1,
+                1,
+                0,
+                &mut target_components,
+            )
+        });
+    result.unwrap();
+    assert_eq!(
+        allocation_count, 0,
+        "warmed persistent selected LC routed reduction allocated"
+    );
+    assert_eq!(
+        allocated_bytes, 0,
+        "warmed persistent selected LC routed reduction allocated bytes"
+    );
+}
+
+#[test]
+fn contracted_reductions_have_one_color_component_and_sum_to_total() {
+    for color_accuracy in ["nlc", "full"] {
+        let physics = test_physics_runtime(color_accuracy);
+        let groups = [RawSumGroup {
+            id: 7,
+            indices: vec![0],
+            weight: 1.0,
+            all_sector_weight: 1.0,
+            sector_ids: vec![0],
+        }];
+        let contraction = ColorContractionRuntime::new(
+            &groups,
+            vec![ColorContractionEntry {
+                left_group_index: 0,
+                right_group_index: 0,
+                weight_re: 2.0,
+                weight_im: 0.0,
+                symmetry_factor: 1.0,
+            }],
+        );
+        let mut amplitude = test_amplitude_runtime(vec![c64(3.0, 0.0)], Some(contraction));
+
+        let resolved = amplitude
+            .reduce_scratch_f64_resolved(1, &physics, 2.0, None, None)
+            .unwrap();
+
+        assert_eq!(resolved.helicity_indices, vec![0, 1]);
+        assert_eq!(resolved.color_indices, vec![0]);
+        assert_eq!(resolved.values, vec![18.0, 18.0]);
+        assert_eq!(resolved.values.iter().sum::<f64>(), 36.0);
+    }
+}
+
+#[test]
+fn plane_native_nlc_and_full_resolved_match_row_major_odd_tail() {
+    const POINT_COUNT: usize = 129;
+    let outputs = (0..POINT_COUNT)
+        .map(|point| c64(point as f64 * 0.0625 - 3.0, point as f64 * -0.03125 + 0.75))
+        .collect::<Vec<_>>();
+    let selected_helicities = BTreeSet::from(["hel:-+".to_string()]);
+    let root_factors = [Some(c64(0.75, -0.25))];
+
+    for color_accuracy in ["nlc", "full"] {
+        let physics = test_physics_runtime(color_accuracy);
+        let groups = [RawSumGroup {
+            id: 7,
+            indices: vec![0],
+            weight: 1.0,
+            all_sector_weight: 1.0,
+            sector_ids: vec![0],
+        }];
+        let contraction = || {
+            ColorContractionRuntime::new(
+                &groups,
+                vec![ColorContractionEntry {
+                    left_group_index: 0,
+                    right_group_index: 0,
+                    weight_re: 2.0,
+                    weight_im: 0.0,
+                    symmetry_factor: 1.0,
+                }],
+            )
+        };
+        let mut amplitude = test_amplitude_runtime(outputs.clone(), Some(contraction()));
+        amplitude.output_length = 1;
+        amplitude.raw_sum_weights = vec![1.0];
+        amplitude.raw_sum_all_sector_weights = vec![1.0];
+        amplitude.raw_sum_color_sector_ids = vec![None];
+        amplitude.raw_sum_groups[0].indices = vec![0];
+        let row_major = amplitude
+            .reduce_scratch_f64_resolved(
+                POINT_COUNT,
+                &physics,
+                2.0,
+                Some(&selected_helicities),
+                None,
+            )
+            .unwrap();
+        let plane_native = with_plane_native_amplitudes(&outputs, POINT_COUNT, 1, |planes| {
+            amplitude
+                .reduce_planes_f64_resolved(planes, &physics, 2.0, Some(&selected_helicities), None)
+                .unwrap()
+        });
+        assert_resolved_values_equal(&plane_native, &row_major);
+
+        let row_major_materialized = amplitude
+            .reduce_scratch_f64_for_materialized_helicity(
+                POINT_COUNT,
+                &physics,
+                2.0,
+                0,
+                &root_factors,
+                None,
+            )
+            .unwrap();
+        let plane_native_materialized =
+            with_plane_native_amplitudes(&outputs, POINT_COUNT, 1, |planes| {
+                amplitude
+                    .reduce_planes_f64_for_materialized_helicity(
+                        planes,
+                        &physics,
+                        2.0,
+                        0,
+                        &root_factors,
+                        None,
+                    )
+                    .unwrap()
+            });
+        assert_resolved_values_equal(&plane_native_materialized, &row_major_materialized);
+
+        let initial = (0..POINT_COUNT)
+            .map(|point| point as f64 * 0.125 - 4.0)
+            .collect::<Vec<_>>();
+        let mut row_major_totals = initial.clone();
+        amplitude
+            .reduce_scratch_f64_for_materialized_helicity_add_into(
+                POINT_COUNT,
+                &physics,
+                2.0,
+                0,
+                &root_factors,
+                None,
+                &mut row_major_totals,
+            )
+            .unwrap();
+        let mut plane_native_totals = initial;
+        with_plane_native_amplitudes(&outputs, POINT_COUNT, 1, |planes| {
+            amplitude
+                .reduce_planes_f64_for_materialized_helicity_add_into(
+                    planes,
+                    &physics,
+                    2.0,
+                    0,
+                    &root_factors,
+                    None,
+                    &mut plane_native_totals,
+                )
+                .unwrap()
+        });
+        assert_eq!(plane_native_totals, row_major_totals);
+        assert_eq!(amplitude.materialized_helicity_direct_total_plans.len(), 1);
+
+        let identity_root_factors = [Some(c64(1.0, 0.0))];
+        let mut identity_row_major = vec![0.25; POINT_COUNT];
+        amplitude
+            .reduce_scratch_f64_for_materialized_helicity_add_into(
+                POINT_COUNT,
+                &physics,
+                2.0,
+                0,
+                &identity_root_factors,
+                None,
+                &mut identity_row_major,
+            )
+            .unwrap();
+        let mut identity_plane_native = vec![0.25; POINT_COUNT];
+        with_plane_native_amplitudes(&outputs, POINT_COUNT, 1, |planes| {
+            amplitude
+                .reduce_planes_f64_for_materialized_helicity_add_into(
+                    planes,
+                    &physics,
+                    2.0,
+                    0,
+                    &identity_root_factors,
+                    None,
+                    &mut identity_plane_native,
+                )
+                .unwrap()
+        });
+        assert_eq!(
+            identity_plane_native
+                .iter()
+                .map(|value| value.to_bits())
+                .collect::<Vec<_>>(),
+            identity_row_major
+                .iter()
+                .map(|value| value.to_bits())
+                .collect::<Vec<_>>()
+        );
+        assert_eq!(
+            amplitude.materialized_helicity_direct_total_plans[1].groups[0].identity_output_index,
+            Some(0)
+        );
+    }
+}
+
+#[test]
+fn materialized_contracted_plan_keeps_only_selected_helicity_entries_and_caches_domain() {
+    let mut physics_manifest = test_physics_runtime("full").manifest.clone();
+    physics_manifest.reduction.groups = vec![
+        crate::ReductionGroup {
+            id: "group:7".to_string(),
+            representative_helicity_id: "hel:+-".to_string(),
+            physical_helicity_ids: vec!["hel:+-".to_string()],
+            representative_color_id: "contracted".to_string(),
+            physical_color_ids: vec!["contracted".to_string()],
+        },
+        crate::ReductionGroup {
+            id: "group:8".to_string(),
+            representative_helicity_id: "hel:-+".to_string(),
+            physical_helicity_ids: vec!["hel:-+".to_string()],
+            representative_color_id: "contracted".to_string(),
+            physical_color_ids: vec!["contracted".to_string()],
+        },
+    ];
+    let physics = PhysicsRuntime::new(physics_manifest).unwrap();
+    let groups = vec![
+        RawSumGroup {
+            id: 7,
+            indices: vec![0],
+            weight: 1.0,
+            all_sector_weight: 1.0,
+            sector_ids: vec![0],
+        },
+        RawSumGroup {
+            id: 8,
+            indices: vec![1],
+            weight: 1.0,
+            all_sector_weight: 1.0,
+            sector_ids: vec![0],
+        },
+    ];
+    let contraction = ColorContractionRuntime::new(
+        &groups,
+        vec![
+            ColorContractionEntry {
+                left_group_index: 0,
+                right_group_index: 0,
+                weight_re: 2.0,
+                weight_im: 0.0,
+                symmetry_factor: 1.0,
+            },
+            ColorContractionEntry {
+                left_group_index: 1,
+                right_group_index: 1,
+                weight_re: 2.0,
+                weight_im: 0.0,
+                symmetry_factor: 1.0,
+            },
+        ],
+    );
+    let mut amplitude = test_amplitude_runtime(
+        vec![c64(3.0, 0.0), c64(f64::NAN, f64::NAN)],
+        Some(contraction),
+    );
+    amplitude.output_length = 2;
+    amplitude.raw_sum_weights = vec![1.0; 2];
+    amplitude.raw_sum_all_sector_weights = vec![1.0; 2];
+    amplitude.raw_sum_color_sector_ids = vec![None; 2];
+    amplitude.raw_sum_groups = groups;
+    let root_factors = [Some(c64(1.0, 0.0)), None];
+
+    let plan_index = amplitude
+        .bind_default_materialized_helicity_direct_total_plan(4, &physics, 0, &root_factors, None)
+        .unwrap();
+    let MaterializedHelicityDirectTotalReduction::Contracted { entries } =
+        &amplitude.materialized_helicity_direct_total_plans[plan_index].reduction
+    else {
+        panic!("FullColour materialized plan must use contracted reduction");
+    };
+    assert_eq!(entries.len(), 1);
+    assert_eq!(entries[0].left_group_index, 0);
+    assert_eq!(entries[0].right_group_index, 0);
+
+    assert_eq!(
+        amplitude
+            .bind_default_materialized_helicity_direct_total_plan(
+                4,
+                &physics,
+                0,
+                &root_factors,
+                None,
+            )
+            .unwrap(),
+        plan_index
+    );
+    assert_eq!(amplitude.materialized_helicity_direct_total_plans.len(), 1);
+    assert_eq!(
+        amplitude.materialized_helicity_direct_default_plan_by_selector_domain[4]
+            .expect("selector-domain plan cache")
+            .plan_index,
+        plan_index
+    );
+}
+
+#[test]
+fn plane_native_materialized_helicity_resolved_and_add_into_match_lc_odd_tail() {
+    const POINT_COUNT: usize = 129;
+    const OUTPUT_COUNT: usize = 2;
+    let physics = test_physics_runtime("lc");
+    let outputs = (0..POINT_COUNT)
+        .flat_map(|point| {
+            (0..OUTPUT_COUNT).map(move |output| {
+                c64(
+                    (point * 7 + output * 3) as f64 * 0.03125 - 1.5,
+                    (point * 5 + output * 11) as f64 * -0.015625 + 0.25,
+                )
+            })
+        })
+        .collect::<Vec<_>>();
+    let root_factors = [Some(c64(0.75, -0.25)), Some(c64(-0.5, 0.125))];
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), None);
+    amplitude.output_length = OUTPUT_COUNT;
+    amplitude.raw_sum_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_all_sector_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_color_sector_ids = vec![None; OUTPUT_COUNT];
+    amplitude.raw_sum_groups[0].indices = vec![0, 1];
+    let selected_colors = BTreeSet::from(["flow:1".to_string()]);
+
+    for colors in [None, Some(&selected_colors)] {
+        let row_major = amplitude
+            .reduce_scratch_f64_for_materialized_helicity(
+                POINT_COUNT,
+                &physics,
+                1.25,
+                0,
+                &root_factors,
+                colors,
+            )
+            .unwrap();
+        let plane_native =
+            with_plane_native_amplitudes(&outputs, POINT_COUNT, OUTPUT_COUNT, |planes| {
+                amplitude
+                    .reduce_planes_f64_for_materialized_helicity(
+                        planes,
+                        &physics,
+                        1.25,
+                        0,
+                        &root_factors,
+                        colors,
+                    )
+                    .unwrap()
+            });
+        assert_resolved_values_equal(&plane_native, &row_major);
+
+        let initial = (0..POINT_COUNT)
+            .map(|point| point as f64 * 0.125 - 4.0)
+            .collect::<Vec<_>>();
+        let mut row_major_totals = initial.clone();
+        amplitude
+            .reduce_scratch_f64_for_materialized_helicity_add_into(
+                POINT_COUNT,
+                &physics,
+                1.25,
+                0,
+                &root_factors,
+                colors,
+                &mut row_major_totals,
+            )
+            .unwrap();
+        let mut plane_native_totals = initial;
+        with_plane_native_amplitudes(&outputs, POINT_COUNT, OUTPUT_COUNT, |planes| {
+            amplitude
+                .reduce_planes_f64_for_materialized_helicity_add_into(
+                    planes,
+                    &physics,
+                    1.25,
+                    0,
+                    &root_factors,
+                    colors,
+                    &mut plane_native_totals,
+                )
+                .unwrap()
+        });
+        assert_eq!(plane_native_totals, row_major_totals);
+        let expected_plan_index = usize::from(colors.is_some());
+        assert_eq!(
+            amplitude
+                .bind_materialized_helicity_direct_total_plan(&physics, 0, &root_factors, colors)
+                .unwrap(),
+            expected_plan_index
+        );
+        assert_eq!(
+            amplitude.materialized_helicity_direct_total_plans.len(),
+            expected_plan_index + 1,
+            "equivalent materialized-helicity reductions must reuse their cold binding"
+        );
+    }
+}
+
+#[test]
+fn materialized_helicity_direct_total_plan_uses_actual_physics_recipient() {
+    const POINT_COUNT: usize = 17;
+    const OUTPUT_COUNT: usize = 2;
+    let representative_physics = test_physics_runtime("lc");
+    let mut weighted_manifest = representative_physics.manifest.clone();
+    let crate::ColorComponent::LcFlow(weighted_flow) = &mut weighted_manifest.color_components[1]
+    else {
+        panic!("LC test physics must contain physical flows");
+    };
+    weighted_flow.coefficient = 3.0;
+    let parent_physics =
+        PhysicsRuntime::new(weighted_manifest).expect("valid parent-closure test physics");
+    let outputs = (0..POINT_COUNT)
+        .flat_map(|point| {
+            (0..OUTPUT_COUNT).map(move |output| {
+                c64(
+                    (point * 5 + output * 7) as f64 * 0.03125 - 0.75,
+                    (point * 11 + output * 3) as f64 * -0.015625 + 0.5,
+                )
+            })
+        })
+        .collect::<Vec<_>>();
+    let root_factors = [Some(c64(0.75, -0.25)), Some(c64(-0.5, 0.125))];
+    let selected_colors = BTreeSet::from(["flow:0".to_string()]);
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), None);
+    amplitude.output_length = OUTPUT_COUNT;
+    amplitude.raw_sum_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_all_sector_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_color_sector_ids = vec![None; OUTPUT_COUNT];
+    amplitude.raw_sum_groups[0].indices = vec![0, 1];
+
+    for (expected_plan_index, physics) in [&representative_physics, &parent_physics]
+        .into_iter()
+        .enumerate()
+    {
+        let mut expected = vec![0.0; POINT_COUNT];
+        amplitude
+            .reduce_scratch_f64_for_materialized_helicity_add_into(
+                POINT_COUNT,
+                physics,
+                1.25,
+                0,
+                &root_factors,
+                Some(&selected_colors),
+                &mut expected,
+            )
+            .unwrap();
+        let mut candidate = vec![0.0; POINT_COUNT];
+        with_plane_native_amplitudes(&outputs, POINT_COUNT, OUTPUT_COUNT, |planes| {
+            amplitude
+                .reduce_planes_f64_for_materialized_helicity_add_into(
+                    planes,
+                    physics,
+                    1.25,
+                    0,
+                    &root_factors,
+                    Some(&selected_colors),
+                    &mut candidate,
+                )
+                .unwrap()
+        });
+        assert_eq!(candidate, expected);
+        assert_eq!(
+            amplitude
+                .bind_materialized_helicity_direct_total_plan(
+                    physics,
+                    0,
+                    &root_factors,
+                    Some(&selected_colors)
+                )
+                .unwrap(),
+            expected_plan_index
+        );
+    }
+    assert_eq!(amplitude.materialized_helicity_direct_total_plans.len(), 2);
+}
+
+#[test]
+fn materialized_helicity_direct_total_identity_singleton_is_bitwise_exact() {
+    let physics = test_physics_runtime("lc");
+    let outputs = vec![
+        c64(2.0, -3.0),
+        c64(-0.0, 0.0),
+        c64(0.0, -0.0),
+        c64(-1.25, 4.5),
+    ];
+    let root_factors = [Some(c64(1.0, 0.0))];
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), None);
+    amplitude.output_length = 1;
+    amplitude.raw_sum_weights = vec![1.0];
+    amplitude.raw_sum_all_sector_weights = vec![1.0];
+    amplitude.raw_sum_color_sector_ids = vec![None];
+    amplitude.raw_sum_groups[0].indices = vec![0];
+
+    let mut expected = vec![-0.0, 0.25, -2.0, 7.0];
+    amplitude
+        .reduce_scratch_f64_for_materialized_helicity_add_into(
+            outputs.len(),
+            &physics,
+            1.25,
+            0,
+            &root_factors,
+            None,
+            &mut expected,
+        )
+        .unwrap();
+    let mut candidate = vec![-0.0, 0.25, -2.0, 7.0];
+    with_plane_native_amplitudes(&outputs, outputs.len(), 1, |planes| {
+        amplitude
+            .reduce_planes_f64_for_materialized_helicity_add_into(
+                planes,
+                &physics,
+                1.25,
+                0,
+                &root_factors,
+                None,
+                &mut candidate,
+            )
+            .unwrap()
+    });
+    assert_eq!(
+        candidate
+            .iter()
+            .map(|value| value.to_bits())
+            .collect::<Vec<_>>(),
+        expected
+            .iter()
+            .map(|value| value.to_bits())
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(
+        amplitude.materialized_helicity_direct_total_plans[0].groups[0].identity_output_index,
+        Some(0)
+    );
+}
+
+#[test]
+fn materialized_helicity_direct_total_plan_cache_is_artifact_bounded() {
+    let physics = test_physics_runtime("lc");
+    let mut amplitude = test_amplitude_runtime(vec![c64(1.0, 0.0)], None);
+    for index in 0..24 {
+        amplitude
+            .bind_materialized_helicity_direct_total_plan(
+                &physics,
+                0,
+                &[Some(c64(index as f64 + 1.0, 0.0))],
+                None,
+            )
+            .unwrap();
+    }
+    let expected_capacity = physics.manifest.helicities.len().clamp(16, 512);
+    assert_eq!(
+        amplitude.materialized_helicity_direct_total_plan_capacity,
+        expected_capacity
+    );
+    assert_eq!(
+        amplitude.materialized_helicity_direct_total_plans.len(),
+        expected_capacity
+    );
+}
+
+#[test]
+fn plane_native_materialized_helicity_routed_components_match_resolved_accumulation() {
+    const POINT_COUNT: usize = 65;
+    const OUTPUT_COUNT: usize = 2;
+    const TARGET_COMPONENT_COUNT: usize = 3;
+    let physics = test_physics_runtime("lc");
+    let outputs = (0..POINT_COUNT)
+        .flat_map(|point| {
+            (0..OUTPUT_COUNT).map(move |output| {
+                c64(
+                    (point * 7 + output * 3) as f64 * 0.03125 - 1.5,
+                    (point * 5 + output * 11) as f64 * -0.015625 + 0.25,
+                )
+            })
+        })
+        .collect::<Vec<_>>();
+    let root_factors = [Some(c64(0.75, -0.25)), Some(c64(-0.5, 0.125))];
+    let replay = LcResolvedReplayEntry {
+        routes: vec![
+            LcResolvedReplayRoute {
+                source_index: 0,
+                target_index: 2,
+                weight: 1.5,
+            },
+            LcResolvedReplayRoute {
+                source_index: 1,
+                target_index: 0,
+                weight: -0.25,
+            },
+        ],
+    };
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), None);
+    amplitude.output_length = OUTPUT_COUNT;
+    amplitude.raw_sum_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_all_sector_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_color_sector_ids = vec![None; OUTPUT_COUNT];
+    amplitude.raw_sum_groups[0].indices = vec![0, 1];
+    let materialized =
+        with_plane_native_amplitudes(&outputs, POINT_COUNT, OUTPUT_COUNT, |planes| {
+            amplitude
+                .reduce_planes_f64_for_materialized_helicity(
+                    planes,
+                    &physics,
+                    1.25,
+                    0,
+                    &root_factors,
+                    None,
+                )
+                .unwrap()
+        });
+    let mut expected = vec![0.0; POINT_COUNT * TARGET_COMPONENT_COUNT];
+    accumulate_selected_lc_replay_resolved_f64(
+        &mut expected,
+        POINT_COUNT,
+        &materialized,
+        std::slice::from_ref(&replay),
+        2,
+        TARGET_COMPONENT_COUNT,
+    )
+    .unwrap();
+    let mut candidate = vec![0.0; POINT_COUNT * TARGET_COMPONENT_COUNT];
+    for (start, stop) in [(0usize, 32usize), (32, POINT_COUNT)] {
+        with_plane_native_amplitudes(
+            &outputs[start * OUTPUT_COUNT..stop * OUTPUT_COUNT],
+            stop - start,
+            OUTPUT_COUNT,
+            |planes| {
+                amplitude
+                    .reduce_planes_f64_for_materialized_helicity_routed_components_add_into(
+                        planes,
+                        &physics,
+                        1.25,
+                        0,
+                        &root_factors,
+                        None,
+                        &replay,
+                        2,
+                        TARGET_COMPONENT_COUNT,
+                        POINT_COUNT,
+                        start,
+                        &mut candidate,
+                    )
+                    .unwrap()
+            },
+        );
+    }
+    assert_eq!(candidate, expected);
+
+    // Alternate proper subsets with implicit and explicit complete axes.
+    // Sparse routing must neither read nor reset a previous dense position
+    // table, and it must preserve the resolved reducer's accumulation order.
+    for selected_colors in [
+        Some(BTreeSet::from(["flow:1".to_string()])),
+        None,
+        Some(BTreeSet::from(["flow:0".to_string()])),
+        Some(BTreeSet::from(["flow:0".to_string(), "flow:1".to_string()])),
+        Some(BTreeSet::from(["flow:1".to_string()])),
+    ] {
+        let selected_colors = selected_colors.as_ref();
+        let color_indices = physics.selected_color_indices(selected_colors).unwrap();
+        let selected_replay = LcResolvedReplayEntry {
+            routes: color_indices
+                .iter()
+                .enumerate()
+                .map(|(position, &color)| LcResolvedReplayRoute {
+                    source_index: position,
+                    target_index: (color + 1) % TARGET_COMPONENT_COUNT,
+                    weight: if position == 0 { 1.5 } else { -0.25 },
+                })
+                .collect(),
+        };
+        let materialized =
+            with_plane_native_amplitudes(&outputs, POINT_COUNT, OUTPUT_COUNT, |planes| {
+                amplitude
+                    .reduce_planes_f64_for_materialized_helicity(
+                        planes,
+                        &physics,
+                        1.25,
+                        0,
+                        &root_factors,
+                        selected_colors,
+                    )
+                    .unwrap()
+            });
+        let mut expected = vec![0.0; POINT_COUNT * TARGET_COMPONENT_COUNT];
+        accumulate_selected_lc_replay_resolved_f64(
+            &mut expected,
+            POINT_COUNT,
+            &materialized,
+            std::slice::from_ref(&selected_replay),
+            color_indices.len(),
+            TARGET_COMPONENT_COUNT,
+        )
+        .unwrap();
+        amplitude.routed_reduction_scratch.color_positions = vec![Some(usize::MAX); 7];
+        let mut candidate = vec![0.0; POINT_COUNT * TARGET_COMPONENT_COUNT];
+        for (start, stop) in [(0usize, 32usize), (32, POINT_COUNT)] {
+            with_plane_native_amplitudes(
+                &outputs[start * OUTPUT_COUNT..stop * OUTPUT_COUNT],
+                stop - start,
+                OUTPUT_COUNT,
+                |planes| {
+                    amplitude
+                        .reduce_planes_f64_for_materialized_helicity_routed_components_add_into(
+                            planes,
+                            &physics,
+                            1.25,
+                            0,
+                            &root_factors,
+                            selected_colors,
+                            &selected_replay,
+                            color_indices.len(),
+                            TARGET_COMPONENT_COUNT,
+                            POINT_COUNT,
+                            start,
+                            &mut candidate,
+                        )
+                        .unwrap()
+                },
+            );
+        }
+        assert_eq!(candidate, expected);
+        if color_indices.len() < physics.manifest.color_components.len() {
+            assert_eq!(
+                amplitude.routed_reduction_scratch.color_positions,
+                vec![Some(usize::MAX); 7],
+                "restricted colours must not touch the complete-axis position table"
+            );
+        } else {
+            assert_eq!(
+                amplitude.routed_reduction_scratch.color_positions,
+                vec![Some(0), Some(1)]
+            );
+        }
+    }
+}
+
+#[cfg(not(feature = "f64-symjit"))]
+#[test]
+fn warmed_plane_native_materialized_helicity_add_into_allocates_zero() {
+    const POINT_COUNT: usize = 129;
+    const OUTPUT_COUNT: usize = 2;
+    let physics = test_physics_runtime("lc");
+    let outputs = (0..POINT_COUNT)
+        .flat_map(|point| {
+            (0..OUTPUT_COUNT).map(move |output| {
+                c64(
+                    (point * 7 + output * 3) as f64 * 0.03125 - 1.5,
+                    (point * 5 + output * 11) as f64 * -0.015625 + 0.25,
+                )
+            })
+        })
+        .collect::<Vec<_>>();
+    let root_factors = [Some(c64(0.75, -0.25)), Some(c64(-0.5, 0.125))];
+    let selected_colors = BTreeSet::from(["flow:1".to_string()]);
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), None);
+    amplitude.output_length = OUTPUT_COUNT;
+    amplitude.raw_sum_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_all_sector_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_color_sector_ids = vec![None; OUTPUT_COUNT];
+    amplitude.raw_sum_groups[0].indices = vec![0, 1];
+
+    let mut workspace =
+        crate::direct_arena::DirectArenaWorkspace::new(0, OUTPUT_COUNT as u32, POINT_COUNT as u32)
+            .unwrap();
+    workspace.begin_tile(POINT_COUNT as u32).unwrap();
+    let stride = workspace.point_stride() as usize;
+    {
+        let (_, _, values_re, values_im) = workspace.split_slices_mut();
+        for point in 0..POINT_COUNT {
+            for component in 0..OUTPUT_COUNT {
+                let value = outputs[point * OUTPUT_COUNT + component];
+                values_re[component * stride + point] = value.re;
+                values_im[component * stride + point] = value.im;
+            }
+        }
+    }
+    let (values_re, values_im) = workspace.amplitude_slices();
+    let planes = crate::direct_arena::DirectAmplitudePlanes::new(
+        values_re,
+        values_im,
+        stride as u32,
+        POINT_COUNT as u32,
+    )
+    .unwrap();
+    let mut totals = vec![0.0; POINT_COUNT];
+    amplitude
+        .reduce_planes_f64_for_materialized_helicity_add_into(
+            planes,
+            &physics,
+            1.25,
+            0,
+            &root_factors,
+            Some(&selected_colors),
+            &mut totals,
+        )
+        .unwrap();
+    totals.fill(0.0);
+    let (result, allocation_count, allocated_bytes) =
+        super::evaluator::native_direct::tests::count_allocations(|| {
+            amplitude.reduce_planes_f64_for_materialized_helicity_add_into(
+                planes,
+                &physics,
+                1.25,
+                0,
+                &root_factors,
+                Some(&selected_colors),
+                &mut totals,
+            )
+        });
+    result.unwrap();
+    assert_eq!(
+        allocation_count, 0,
+        "warmed materialized-helicity plane accumulator allocated"
+    );
+    assert_eq!(
+        allocated_bytes, 0,
+        "warmed materialized-helicity plane accumulator allocated bytes"
+    );
+
+    let replay = LcResolvedReplayEntry {
+        routes: vec![LcResolvedReplayRoute {
+            source_index: 0,
+            target_index: 0,
+            weight: 1.0,
+        }],
+    };
+    let mut target_components = vec![0.0; POINT_COUNT];
+    amplitude
+        .reduce_planes_f64_for_materialized_helicity_routed_components_add_into(
+            planes,
+            &physics,
+            1.25,
+            0,
+            &root_factors,
+            Some(&selected_colors),
+            &replay,
+            1,
+            1,
+            POINT_COUNT,
+            0,
+            &mut target_components,
+        )
+        .unwrap();
+    target_components.fill(0.0);
+    let (result, allocation_count, allocated_bytes) =
+        super::evaluator::native_direct::tests::count_allocations(|| {
+            amplitude.reduce_planes_f64_for_materialized_helicity_routed_components_add_into(
+                planes,
+                &physics,
+                1.25,
+                0,
+                &root_factors,
+                Some(&selected_colors),
+                &replay,
+                1,
+                1,
+                POINT_COUNT,
+                0,
+                &mut target_components,
+            )
+        });
+    result.unwrap();
+    assert_eq!(
+        allocation_count, 0,
+        "warmed persistent materialized-helicity route allocated"
+    );
+    assert_eq!(
+        allocated_bytes, 0,
+        "warmed persistent materialized-helicity route allocated bytes"
+    );
+}
+
+fn repeated_test_group(id: i64, output_index: usize, sector_id: i64) -> RawSumGroup {
+    RawSumGroup {
+        id,
+        indices: vec![output_index],
+        weight: 1.0,
+        all_sector_weight: 1.0,
+        sector_ids: vec![sector_id],
+    }
+}
+
+fn legacy_color_contraction_totals(
+    amplitudes: &[Complex<f64>],
+    output_length: usize,
+    groups: &[RawSumGroup],
+    entries: &[ColorContractionEntry],
+) -> Vec<f64> {
+    amplitudes
+        .chunks_exact(output_length)
+        .map(|row| {
+            let group_values = groups
+                .iter()
+                .map(|group| {
+                    group
+                        .indices
+                        .iter()
+                        .fold(Complex::new(0.0, 0.0), |total, index| total + row[*index])
+                })
+                .collect::<Vec<_>>();
+            entries.iter().fold(0.0, |total, entry| {
+                let product = group_values[entry.left_group_index]
+                    * group_values[entry.right_group_index].conj();
+                total
+                    + entry.symmetry_factor
+                        * (entry.weight_re * product.re - entry.weight_im * product.im)
+            })
+        })
+        .collect()
+}
+
+fn reduction_test_amplitude(
+    output_length: usize,
+    outputs: Vec<Complex<f64>>,
+    groups: Vec<RawSumGroup>,
+    entries: Vec<ColorContractionEntry>,
+) -> AmplitudeRuntime {
+    let contraction = ColorContractionRuntime::new(&groups, entries);
+    AmplitudeRuntime {
+        output_length,
+        raw_sum_weights: vec![1.0; output_length],
+        raw_sum_all_sector_weights: vec![1.0; output_length],
+        raw_sum_color_sector_ids: vec![None; output_length],
+        raw_sum_groups: groups,
+        has_coherent_groups: true,
+        color_contraction: Some(contraction),
+        color_topology_replay: None,
+        input_components: None,
+        input_spans: Vec::new(),
+        parameter_scratch_f64: Vec::new(),
+        evaluator_output_scratch_f64: Vec::new(),
+        output_scratch_f64: outputs,
+        resolved_source_row_scratch_f64: Vec::new(),
+        resolved_target_row_scratch_f64: Vec::new(),
+        routed_reduction_scratch: RoutedReductionScratch::default(),
+        materialized_helicity_direct_total_plans: Vec::new(),
+        materialized_helicity_direct_total_plan_capacity: 0,
+        materialized_helicity_direct_total_next_replacement: 0,
+        materialized_helicity_direct_default_plan_by_selector_domain: Vec::new(),
+        evaluator_output_order: None,
+        evaluator: Some(empty_evaluator_group()),
+    }
+}
+
+#[test]
+fn compiled_symmetric_group_reducer_binds_group_ids_and_multi_root_odd_tail() {
+    const POINT_COUNT: usize = 127;
+    const PREPARED_CAPACITY: usize = 136;
+    const GROUP_COUNT: usize = 13;
+    const OUTPUT_COUNT: usize = 15;
+    let destination_ids = vec![7, 0, 12, 3, 9, 1, 11, 4, 10, 2, 8, 5, 6];
+    let vector_order = [12, 4, 1, 9, 0, 7, 3, 11, 2, 10, 5, 8, 6];
+    let mut sector_by_id = [0usize; GROUP_COUNT];
+    for (sector, destination) in destination_ids.iter().copied().enumerate() {
+        sector_by_id[destination as usize] = sector;
+    }
+    let mut next_output = 0usize;
+    let groups = vector_order
+        .into_iter()
+        .map(|id| {
+            let root_count = if id == 7 { 3 } else { 1 };
+            let indices = (next_output..next_output + root_count).collect::<Vec<_>>();
+            next_output += root_count;
+            RawSumGroup {
+                id,
+                indices,
+                weight: 1.0,
+                all_sector_weight: 1.0,
+                sector_ids: vec![sector_by_id[id as usize] as i64],
+            }
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(next_output, OUTPUT_COUNT);
+    let outputs = (0..POINT_COUNT * OUTPUT_COUNT)
+        .map(|index| {
+            c64(
+                (index * 29 % 211) as f64 * 0.03125 - 2.5,
+                (index * 43 % 197) as f64 * -0.015625 + 1.25,
+            )
+        })
+        .collect::<Vec<_>>();
+    let manifest = GenericColorContractionManifest {
+        supported: true,
+        reason: None,
+        group_count: GROUP_COUNT,
+        includes_color_factor: true,
+        entries: Vec::new(),
+        repeated_block: None,
+    };
+
+    let duplicated_destination =
+        crate::recurrence::RecurrenceColorContraction::symmetric_group_s3_for_runtime_test(
+            vec![0; GROUP_COUNT],
+            GROUP_COUNT as u32,
+        );
+    let duplicate_error = match build_compiled_symmetric_group_color_contraction_runtime(
+        Some(&manifest),
+        &groups,
+        duplicated_destination,
+    ) {
+        Ok(_) => panic!("duplicate coherent destination unexpectedly bound"),
+        Err(error) => error,
+    };
+    assert_eq!(duplicate_error.kind(), crate::RusticolErrorKind::Integrity);
+    assert!(duplicate_error.message().contains("symmetric-group FFT"));
+
+    let sparse_groups = groups
+        .iter()
+        .map(|group| RawSumGroup {
+            id: group.id,
+            indices: group.indices.clone(),
+            weight: group.weight,
+            all_sector_weight: group.all_sector_weight,
+            sector_ids: group
+                .sector_ids
+                .iter()
+                .map(|sector| 2 * sector + 1)
+                .collect(),
+        })
+        .collect::<Vec<_>>();
+    let sparse_plan =
+        crate::recurrence::RecurrenceColorContraction::symmetric_group_s3_for_runtime_test(
+            destination_ids.clone(),
+            GROUP_COUNT as u32,
+        )
+        .with_sparse_sector_domain_for_runtime_test();
+    let sparse_contraction = build_compiled_symmetric_group_color_contraction_runtime(
+        Some(&manifest),
+        &sparse_groups,
+        sparse_plan,
+    )
+    .expect("inactive physical sectors must not block a compiled FFT reducer");
+    assert_eq!(
+        sparse_contraction
+            .symmetric_group
+            .as_ref()
+            .unwrap()
+            .plan
+            .active_sector_count(),
+        GROUP_COUNT,
+    );
+
+    let plan = crate::recurrence::RecurrenceColorContraction::symmetric_group_s3_for_runtime_test(
+        destination_ids.clone(),
+        GROUP_COUNT as u32,
+    );
+    let reducer = match plan.runtime_reducer().unwrap() {
+        crate::recurrence::RuntimeColorContractionReducer::SymmetricGroupFourier(reducer) => {
+            reducer
+        }
+        _ => panic!("expected symmetric-group reducer"),
+    };
+    let mut expected_workspace = reducer.workspace(PREPARED_CAPACITY).unwrap();
+    reducer
+        .reduce_lanes(
+            &mut expected_workspace,
+            POINT_COUNT,
+            |local_group, point| {
+                let group_id = i64::from(destination_ids[local_group]);
+                let group = groups.iter().find(|group| group.id == group_id).unwrap();
+                let value = group.indices.iter().fold(c64(0.0, 0.0), |total, index| {
+                    total + outputs[point * OUTPUT_COUNT + *index]
+                });
+                Ok((value.re, value.im))
+            },
+        )
+        .unwrap();
+    let expected = expected_workspace.reduced(POINT_COUNT).unwrap().to_vec();
+
+    let contraction =
+        build_compiled_symmetric_group_color_contraction_runtime(Some(&manifest), &groups, plan)
+            .unwrap();
+    assert_eq!(
+        contraction
+            .symmetric_group
+            .as_ref()
+            .unwrap()
+            .ordered_group_indices,
+        destination_ids
+            .iter()
+            .map(|destination| {
+                groups
+                    .iter()
+                    .position(|group| group.id == i64::from(*destination))
+                    .unwrap()
+            })
+            .collect::<Vec<_>>(),
+    );
+    let mut amplitude = reduction_test_amplitude(OUTPUT_COUNT, outputs.clone(), groups, Vec::new());
+    amplitude.color_contraction = Some(contraction);
+    amplitude
+        .prepare_compiled_symmetric_group_workspace(PREPARED_CAPACITY)
+        .unwrap();
+    assert_eq!(
+        amplitude
+            .color_contraction
+            .as_ref()
+            .and_then(|contraction| contraction.symmetric_group.as_ref())
+            .and_then(|symmetric_group| symmetric_group.workspace.as_ref())
+            .unwrap()
+            .lane_capacity(),
+        PREPARED_CAPACITY,
+    );
+
+    let actual = plane_native_totals(&mut amplitude, &outputs, POINT_COUNT, None);
+    for (actual, expected) in actual.iter().zip(expected.iter()) {
+        assert!(
+            (actual - expected).abs() <= 1.0e-11 * expected.abs().max(1.0),
+            "compiled symmetric-group reduction {actual} differs from reference {expected}",
+        );
+    }
+
+    #[cfg(not(feature = "f64-symjit"))]
+    {
+        let mut workspace = crate::direct_arena::DirectArenaWorkspace::new(
+            0,
+            OUTPUT_COUNT as u32,
+            POINT_COUNT as u32,
+        )
+        .unwrap();
+        workspace.begin_tile(POINT_COUNT as u32).unwrap();
+        let stride = workspace.point_stride() as usize;
+        {
+            let (_, _, values_re, values_im) = workspace.split_slices_mut();
+            for point in 0..POINT_COUNT {
+                for component in 0..OUTPUT_COUNT {
+                    let value = outputs[point * OUTPUT_COUNT + component];
+                    values_re[component * stride + point] = value.re;
+                    values_im[component * stride + point] = value.im;
+                }
+            }
+        }
+        let (values_re, values_im) = workspace.amplitude_slices();
+        let planes = crate::direct_arena::DirectAmplitudePlanes::new(
+            values_re,
+            values_im,
+            stride as u32,
+            POINT_COUNT as u32,
+        )
+        .unwrap();
+        let mut totals = vec![0.0; POINT_COUNT];
+        amplitude
+            .reduce_planes_f64_into_selected_slice(planes, &mut totals, None)
+            .unwrap();
+        let (result, allocation_count, allocated_bytes) =
+            super::evaluator::native_direct::tests::count_allocations(|| {
+                amplitude.reduce_planes_f64_into_selected_slice(planes, &mut totals, None)
+            });
+        result.unwrap();
+        assert_eq!(
+            allocation_count, 0,
+            "warmed symmetric-group reduction allocated"
+        );
+        assert_eq!(
+            allocated_bytes, 0,
+            "warmed symmetric-group reduction allocated bytes",
+        );
+    }
+}
+
+#[test]
+fn repeated_real_color_blocks_match_legacy_reduction_for_permuted_outputs() {
+    let groups = vec![
+        repeated_test_group(10, 2, 100),
+        repeated_test_group(11, 5, 100),
+        repeated_test_group(12, 0, 200),
+        repeated_test_group(13, 3, 200),
+        repeated_test_group(14, 1, 300),
+        repeated_test_group(15, 4, 300),
+    ];
+    // Deliberately interleave the two disconnected components and do not
+    // present their left indices monotonically. Runtime canonicalization may
+    // change floating-point association, but it must preserve the contraction.
+    let entries = vec![
+        ColorContractionEntry {
+            left_group_index: 3,
+            right_group_index: 5,
+            weight_re: 0.5,
+            weight_im: 0.0,
+            symmetry_factor: 2.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 0,
+            right_group_index: 0,
+            weight_re: 1.25,
+            weight_im: 0.0,
+            symmetry_factor: 1.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 1,
+            right_group_index: 3,
+            weight_re: -0.75,
+            weight_im: 0.0,
+            symmetry_factor: 2.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 4,
+            right_group_index: 4,
+            weight_re: 2.0,
+            weight_im: 0.0,
+            symmetry_factor: 1.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 2,
+            right_group_index: 4,
+            weight_re: 0.5,
+            weight_im: 0.0,
+            symmetry_factor: 2.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 1,
+            right_group_index: 1,
+            weight_re: 1.25,
+            weight_im: 0.0,
+            symmetry_factor: 1.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 0,
+            right_group_index: 2,
+            weight_re: -0.75,
+            weight_im: 0.0,
+            symmetry_factor: 2.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 5,
+            right_group_index: 5,
+            weight_re: 2.0,
+            weight_im: 0.0,
+            symmetry_factor: 1.0,
+        },
+    ];
+    let outputs = vec![
+        c64(0.5, -1.0),
+        c64(1.5, 0.25),
+        c64(-0.75, 2.0),
+        c64(0.125, -0.5),
+        c64(2.25, 1.0),
+        c64(-1.25, -0.75),
+        c64(1.0, 0.5),
+        c64(-0.25, 1.25),
+        c64(0.75, -1.5),
+        c64(2.0, 0.125),
+        c64(-1.0, 0.75),
+        c64(0.25, -2.0),
+    ];
+    let expected = legacy_color_contraction_totals(&outputs, 6, &groups, &entries);
+    let mut amplitude = reduction_test_amplitude(6, outputs.clone(), groups, entries);
+    let repeated = amplitude
+        .color_contraction
+        .as_ref()
+        .and_then(|contraction| contraction.repeated_block.as_ref())
+        .expect("two identical color components should be canonicalized");
+    assert_eq!(repeated.component_count, 2);
+    assert_eq!(repeated.entries.len(), 4);
+    assert_eq!(
+        repeated.singleton_output_indices.as_deref(),
+        Some([2, 5, 0, 3, 1, 4].as_slice())
+    );
+    assert!(repeated.all_weights_real);
+
+    let mut actual = vec![0.0; 2];
+    amplitude
+        .reduce_scratch_f64_into_selected_slice(2, &mut actual, None)
+        .unwrap();
+    let plane_native = plane_native_totals(&mut amplitude, &outputs, 2, None);
+    assert_eq!(plane_native, actual);
+    for (actual, expected) in actual.iter().zip(expected) {
+        assert!(
+            (actual - expected).abs() <= 1.0e-12 * expected.abs().max(1.0),
+            "repeated-block reduction {actual} differs from legacy {expected}"
+        );
+    }
+}
+
+#[test]
+fn repeated_color_block_requires_identical_component_coefficients() {
+    let groups = vec![
+        repeated_test_group(10, 0, 100),
+        repeated_test_group(11, 1, 100),
+        repeated_test_group(12, 2, 200),
+        repeated_test_group(13, 3, 200),
+    ];
+    let entries = vec![
+        ColorContractionEntry {
+            left_group_index: 0,
+            right_group_index: 2,
+            weight_re: 1.0,
+            weight_im: 0.0,
+            symmetry_factor: 2.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 1,
+            right_group_index: 3,
+            weight_re: 1.0 + f64::EPSILON,
+            weight_im: 0.0,
+            symmetry_factor: 2.0,
+        },
+    ];
+    let contraction = ColorContractionRuntime::new(&groups, entries);
+    assert!(contraction.repeated_block.is_none());
+}
+
+#[test]
+fn plane_native_expanded_color_contraction_matches_row_major_odd_tail() {
+    const POINT_COUNT: usize = 127;
+    let groups = vec![
+        RawSumGroup {
+            id: 10,
+            indices: vec![0, 3],
+            weight: 1.0,
+            all_sector_weight: 1.0,
+            sector_ids: vec![100],
+        },
+        repeated_test_group(11, 1, 200),
+        repeated_test_group(12, 2, 300),
+    ];
+    let entries = vec![
+        ColorContractionEntry {
+            left_group_index: 0,
+            right_group_index: 0,
+            weight_re: 1.25,
+            weight_im: 0.0,
+            symmetry_factor: 1.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 0,
+            right_group_index: 1,
+            weight_re: -0.75,
+            weight_im: 0.125,
+            symmetry_factor: 2.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 1,
+            right_group_index: 2,
+            weight_re: 0.5,
+            weight_im: -0.25,
+            symmetry_factor: 2.0,
+        },
+    ];
+    let outputs = (0..POINT_COUNT * 4)
+        .map(|index| {
+            c64(
+                (index * 13 % 97) as f64 * 0.0625 - 2.0,
+                (index * 17 % 89) as f64 * -0.03125 + 1.5,
+            )
+        })
+        .collect::<Vec<_>>();
+    let mut amplitude = reduction_test_amplitude(4, outputs.clone(), groups, entries);
+    assert!(
+        amplitude
+            .color_contraction
+            .as_ref()
+            .unwrap()
+            .repeated_block
+            .is_none()
+    );
+    let mut row_major = vec![0.0; POINT_COUNT];
+    amplitude
+        .reduce_scratch_f64_into_selected_slice(POINT_COUNT, &mut row_major, None)
+        .unwrap();
+    let plane_native = plane_native_totals(&mut amplitude, &outputs, POINT_COUNT, None);
+    assert_eq!(plane_native, row_major);
+}
+
+#[test]
+fn compact_repeated_color_manifest_builds_without_expanded_entries() {
+    let groups = vec![
+        repeated_test_group(10, 2, 100),
+        repeated_test_group(11, 3, 100),
+        repeated_test_group(12, 0, 200),
+        repeated_test_group(13, 1, 200),
+    ];
+    let manifest = GenericColorContractionManifest {
+        supported: true,
+        reason: None,
+        group_count: groups.len(),
+        includes_color_factor: true,
+        entries: Vec::new(),
+        repeated_block: Some(GenericRepeatedColorContractionBlockManifest {
+            component_count: 2,
+            component_group_ids: vec![10, 11, 12, 13],
+            entries: vec![
+                GenericRepeatedColorContractionEntryManifest {
+                    _exact_weight: None,
+                    left_group_index: 0,
+                    right_group_index: 0,
+                    weight: vec![1.25, 0.0],
+                    symmetry_factor: 1.0,
+                },
+                GenericRepeatedColorContractionEntryManifest {
+                    _exact_weight: None,
+                    left_group_index: 0,
+                    right_group_index: 1,
+                    weight: vec![-0.75, 0.0],
+                    symmetry_factor: 2.0,
+                },
+                GenericRepeatedColorContractionEntryManifest {
+                    _exact_weight: None,
+                    left_group_index: 1,
+                    right_group_index: 1,
+                    weight: vec![2.0, 0.0],
+                    symmetry_factor: 1.0,
+                },
+            ],
+            factorized_block: None,
+        }),
+    };
+    let contraction = build_color_contraction_runtime(Some(&manifest), &groups)
+        .unwrap()
+        .expect("compact repeated contraction");
+    assert!(contraction.entries.is_empty());
+    assert_eq!(contraction.logical_entry_count().unwrap(), 6);
+    let logical_entries = contraction.logical_entries().collect::<Vec<_>>();
+    assert_eq!(
+        logical_entries
+            .iter()
+            .map(|entry| (entry.left_group_index, entry.right_group_index))
+            .collect::<Vec<_>>(),
+        vec![(0, 0), (0, 2), (2, 2), (1, 1), (1, 3), (3, 3)]
+    );
+
+    let outputs = vec![
+        c64(0.5, -1.0),
+        c64(1.5, 0.25),
+        c64(-0.75, 2.0),
+        c64(0.125, -0.5),
+    ];
+    let expected = legacy_color_contraction_totals(&outputs, 4, &groups, &logical_entries)[0];
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), Some(contraction));
+    amplitude.raw_sum_groups = groups;
+    let mut actual = vec![0.0];
+    amplitude
+        .reduce_scratch_f64_into_selected_slice(1, &mut actual, None)
+        .unwrap();
+    assert!((actual[0] - expected).abs() <= 1.0e-12 * expected.abs().max(1.0));
+}
+
+#[test]
+fn compact_walsh_color_manifest_matches_expanded_repeated_reduction() {
+    let component_count = 3;
+    let output_indices = [7, 0, 10, 3, 5, 11, 1, 8, 4, 9, 2, 6];
+    let groups = output_indices
+        .iter()
+        .copied()
+        .enumerate()
+        .map(|(group_index, output_index)| {
+            repeated_test_group(
+                10 + group_index as i64,
+                output_index,
+                100 + (group_index / component_count) as i64,
+            )
+        })
+        .collect::<Vec<_>>();
+    let kernel = [4.0, 1.0, 2.0, 0.5];
+    let entries = (0..4)
+        .flat_map(|left_group_index| {
+            (left_group_index..4).map(move |right_group_index| {
+                GenericRepeatedColorContractionEntryManifest {
+                    _exact_weight: None,
+                    left_group_index,
+                    right_group_index,
+                    weight: vec![kernel[left_group_index ^ right_group_index], 0.0],
+                    symmetry_factor: if left_group_index == right_group_index {
+                        1.0
+                    } else {
+                        2.0
+                    },
+                }
+            })
+        })
+        .collect::<Vec<_>>();
+    let manifest = GenericColorContractionManifest {
+        supported: true,
+        reason: None,
+        group_count: groups.len(),
+        includes_color_factor: true,
+        entries: Vec::new(),
+        repeated_block: Some(GenericRepeatedColorContractionBlockManifest {
+            component_count,
+            component_group_ids: (10..10 + groups.len() as i64).collect(),
+            entries,
+            factorized_block: Some(
+                GenericFactorizedColorContractionBlockManifest::KleinFourWalsh {
+                    cosets: vec![[0, 1, 2, 3]],
+                },
+            ),
+        }),
+    };
+    let contraction = build_color_contraction_runtime(Some(&manifest), &groups)
+        .unwrap()
+        .expect("compact Walsh contraction");
+    let repeated = contraction
+        .repeated_block
+        .as_ref()
+        .expect("repeated contraction");
+    let walsh = repeated.walsh_block.as_ref().expect("Walsh block");
+    assert_eq!(walsh.cosets, vec![[0, 1, 2, 3]]);
+    assert_eq!(walsh.entries.len(), 4);
+    let logical_entries = contraction.logical_entries().collect::<Vec<_>>();
+    let outputs = (0..12)
+        .map(|index| {
+            let value = index as f64 + 1.0;
+            c64(0.25 * value, 0.125 * (5.0 - value))
+        })
+        .collect::<Vec<_>>();
+    let expected = legacy_color_contraction_totals(&outputs, 12, &groups, &logical_entries)[0];
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), Some(contraction));
+    amplitude.raw_sum_groups = groups;
+    let mut actual = vec![0.0];
+
+    amplitude
+        .reduce_scratch_f64_into_selected_slice(1, &mut actual, None)
+        .unwrap();
+    let plane_native = plane_native_totals(&mut amplitude, &outputs, 1, None);
+
+    assert!(
+        (actual[0] - expected).abs() <= 1.0e-12 * expected.abs().max(1.0),
+        "Walsh reduction {} differs from expanded repeated reduction {expected}",
+        actual[0]
+    );
+    assert_eq!(plane_native, actual);
+}
+
+#[test]
+fn compact_c2k_walsh_h8_manifest_matches_expanded_repeated_reduction() {
+    let component_count = 3;
+    let local_group_count = 8;
+    let output_count = component_count * local_group_count;
+    let groups = (0..output_count)
+        .map(|group_index| {
+            repeated_test_group(
+                10 + group_index as i64,
+                (group_index * 7) % output_count,
+                100 + (group_index / component_count) as i64,
+            )
+        })
+        .collect::<Vec<_>>();
+    let kernel = [8.0, 1.0, 2.0, 0.5, 3.0, 0.25, 0.75, 0.125];
+    let entries = (0..local_group_count)
+        .flat_map(|left_group_index| {
+            (left_group_index..local_group_count).map(move |right_group_index| {
+                GenericRepeatedColorContractionEntryManifest {
+                    _exact_weight: None,
+                    left_group_index,
+                    right_group_index,
+                    weight: vec![kernel[left_group_index ^ right_group_index], 0.0],
+                    symmetry_factor: if left_group_index == right_group_index {
+                        1.0
+                    } else {
+                        2.0
+                    },
+                }
+            })
+        })
+        .collect::<Vec<_>>();
+    let manifest = GenericColorContractionManifest {
+        supported: true,
+        reason: None,
+        group_count: groups.len(),
+        includes_color_factor: true,
+        entries: Vec::new(),
+        repeated_block: Some(GenericRepeatedColorContractionBlockManifest {
+            component_count,
+            component_group_ids: (10..10 + groups.len() as i64).collect(),
+            entries,
+            factorized_block: Some(
+                GenericFactorizedColorContractionBlockManifest::ElementaryAbelianWalsh {
+                    rank: 3,
+                    cosets: vec![(0..local_group_count).collect()],
+                },
+            ),
+        }),
+    };
+    let contraction = build_color_contraction_runtime(Some(&manifest), &groups)
+        .unwrap()
+        .expect("compact C2^3 Walsh contraction");
+    let repeated = contraction
+        .repeated_block
+        .as_ref()
+        .expect("repeated contraction");
+    let walsh = repeated.c2k_walsh_block.as_ref().expect("C2^3 Walsh block");
+    assert_eq!(walsh.subgroup_order, 8);
+    assert_eq!(walsh.cosets, vec![(0..8).collect::<Vec<_>>()]);
+    assert_eq!(walsh.entries.len(), 8);
+    let logical_entries = contraction.logical_entries().collect::<Vec<_>>();
+    let outputs = (0..output_count)
+        .map(|index| {
+            let value = index as f64 + 1.0;
+            c64(0.125 * value, 0.0625 * (7.0 - value))
+        })
+        .collect::<Vec<_>>();
+    let expected =
+        legacy_color_contraction_totals(&outputs, output_count, &groups, &logical_entries)[0];
+    let mut amplitude = test_amplitude_runtime(outputs.clone(), Some(contraction));
+    amplitude.raw_sum_groups = groups;
+    let mut actual = vec![0.0];
+
+    amplitude
+        .reduce_scratch_f64_into_selected_slice(1, &mut actual, None)
+        .unwrap();
+    let plane_native = plane_native_totals(&mut amplitude, &outputs, 1, None);
+
+    assert!(
+        (actual[0] - expected).abs() <= 1.0e-12 * expected.abs().max(1.0),
+        "C2^3 Walsh reduction {} differs from expanded repeated reduction {expected}",
+        actual[0]
+    );
+    assert_eq!(plane_native, actual);
+}
+
+#[test]
+fn compact_c2k_walsh_h8_multiple_cosets_matches_expanded_reference() {
+    const COMPONENT_COUNT: usize = 4;
+    const COSET_COUNT: usize = 3;
+    const SUBGROUP_ORDER: usize = 8;
+    const LOCAL_GROUP_COUNT: usize = COSET_COUNT * SUBGROUP_ORDER;
+    const OUTPUT_COUNT: usize = COMPONENT_COUNT * LOCAL_GROUP_COUNT;
+
+    // Each row is ordered by the C2^3 generator bitmask, but the local group
+    // indices deliberately form a shuffled partition.
+    let cosets = vec![
+        vec![17, 2, 21, 6, 13, 10, 1, 22],
+        vec![5, 18, 8, 15, 3, 20, 12, 7],
+        vec![23, 0, 14, 9, 19, 4, 16, 11],
+    ];
+    let mut local_coordinates = vec![(usize::MAX, usize::MAX); LOCAL_GROUP_COUNT];
+    for (coset_index, coset) in cosets.iter().enumerate() {
+        for (subgroup_index, local_group_index) in coset.iter().copied().enumerate() {
+            local_coordinates[local_group_index] = (coset_index, subgroup_index);
+        }
+    }
+    assert!(
+        local_coordinates
+            .iter()
+            .all(|coordinates| coordinates.0 != usize::MAX)
+    );
+
+    // The six independent coset-pair kernels include negative, small, and
+    // off-diagonal weights. XOR indexing makes every block exactly C2^3
+    // circulant while retaining nontrivial couplings between all cosets.
+    let kernels = [
+        [3.25, -0.5, 0.125, 1.75, -2.0, 0.0625, 0.875, -0.25],
+        [-1.5, 0.375, 2.25, -0.125, 0.75, -3.0, 0.03125, 1.0],
+        [0.625, -2.5, 0.1875, 1.125, -0.75, 0.5, 2.0, -0.0625],
+        [4.0, 0.25, -1.25, 0.5, 0.015625, -0.875, 1.5, -2.25],
+        [-0.4375, 1.875, -0.03125, 2.5, 0.75, -1.0, 0.3125, 3.0],
+        [2.75, -0.1875, 0.5625, -1.75, 1.25, 0.046875, -2.0, 0.375],
+    ];
+    let kernel_index = |left_coset: usize, right_coset: usize| match (
+        left_coset.min(right_coset),
+        left_coset.max(right_coset),
+    ) {
+        (0, 0) => 0,
+        (0, 1) => 1,
+        (0, 2) => 2,
+        (1, 1) => 3,
+        (1, 2) => 4,
+        (2, 2) => 5,
+        pair => panic!("unexpected coset pair {pair:?}"),
+    };
+    let mut entries = Vec::new();
+    for left_group_index in 0..LOCAL_GROUP_COUNT {
+        let (left_coset, left_subgroup) = local_coordinates[left_group_index];
+        for (right_group_index, &(right_coset, right_subgroup)) in
+            local_coordinates.iter().enumerate().skip(left_group_index)
+        {
+            entries.push(GenericRepeatedColorContractionEntryManifest {
+                _exact_weight: None,
+                left_group_index,
+                right_group_index,
+                weight: vec![
+                    kernels[kernel_index(left_coset, right_coset)][left_subgroup ^ right_subgroup],
+                    0.0,
+                ],
+                symmetry_factor: if left_group_index == right_group_index {
+                    1.0
+                } else {
+                    2.0
+                },
+            });
+        }
+    }
+
+    let group_id = |mapping_slot: usize| 10_000 + 13 * mapping_slot as i64;
+    let component_group_ids = (0..OUTPUT_COUNT).map(group_id).collect::<Vec<_>>();
+    let mut group_index_by_mapping_slot = vec![usize::MAX; OUTPUT_COUNT];
+    let groups = (0..OUTPUT_COUNT)
+        .map(|group_index| {
+            let mapping_slot = (group_index * 37 + 11) % OUTPUT_COUNT;
+            group_index_by_mapping_slot[mapping_slot] = group_index;
+            repeated_test_group(
+                group_id(mapping_slot),
+                (mapping_slot * 29 + 7) % OUTPUT_COUNT,
+                500 + (mapping_slot / COMPONENT_COUNT) as i64,
+            )
+        })
+        .collect::<Vec<_>>();
+    assert!(
+        group_index_by_mapping_slot
+            .iter()
+            .all(|group_index| *group_index != usize::MAX)
+    );
+
+    // Build the independent expanded reference before moving the compact
+    // entries into the manifest. This reproduces the logical matrix for every
+    // repeated component without consulting the optimized runtime plan.
+    let group_index_by_mapping_slot = &group_index_by_mapping_slot;
+    let explicit_entries = (0..COMPONENT_COUNT)
+        .flat_map(|component_index| {
+            entries.iter().map(move |entry| ColorContractionEntry {
+                left_group_index: group_index_by_mapping_slot
+                    [entry.left_group_index * COMPONENT_COUNT + component_index],
+                right_group_index: group_index_by_mapping_slot
+                    [entry.right_group_index * COMPONENT_COUNT + component_index],
+                weight_re: entry.weight[0],
+                weight_im: entry.weight[1],
+                symmetry_factor: entry.symmetry_factor,
+            })
+        })
+        .collect::<Vec<_>>();
+    let manifest = GenericColorContractionManifest {
+        supported: true,
+        reason: None,
+        group_count: groups.len(),
+        includes_color_factor: true,
+        entries: Vec::new(),
+        repeated_block: Some(GenericRepeatedColorContractionBlockManifest {
+            component_count: COMPONENT_COUNT,
+            component_group_ids,
+            entries,
+            factorized_block: Some(
+                GenericFactorizedColorContractionBlockManifest::ElementaryAbelianWalsh {
+                    rank: 3,
+                    cosets,
+                },
+            ),
+        }),
+    };
+    let contraction = build_color_contraction_runtime(Some(&manifest), &groups)
+        .unwrap()
+        .expect("multi-coset C2^3 Walsh contraction");
+    let repeated = contraction
+        .repeated_block
+        .as_ref()
+        .expect("repeated contraction");
+    let walsh = repeated.c2k_walsh_block.as_ref().expect("C2^3 Walsh block");
+    assert_eq!(walsh.subgroup_order, SUBGROUP_ORDER);
+    assert_eq!(walsh.cosets.len(), COSET_COUNT);
+    assert!(
+        walsh
+            .entries
+            .iter()
+            .any(|entry| entry.left_group_index != entry.right_group_index),
+        "transformed plan must retain off-diagonal coset couplings"
+    );
+
+    let point_count = 3;
+    let mut outputs = Vec::with_capacity(point_count * OUTPUT_COUNT);
+    for point_index in 0..point_count {
+        let point_scale = [1.0, 0.03125, 5.5][point_index];
+        for output_index in 0..OUTPUT_COUNT {
+            let centered = output_index as f64 - (OUTPUT_COUNT as f64 - 1.0) * 0.5;
+            let modulation = ((output_index * 17 + point_index * 5) % 19) as f64 - 9.0;
+            outputs.push(c64(
+                point_scale * (0.0234375 * centered + 0.0078125 * modulation),
+                point_scale
+                    * (-0.015625 * centered + 0.00390625 * (modulation * modulation - 13.0)),
+            ));
+        }
+    }
+    let expected =
+        legacy_color_contraction_totals(&outputs, OUTPUT_COUNT, &groups, &explicit_entries);
+    let mut amplitude = test_amplitude_runtime(outputs, Some(contraction));
+    amplitude.output_length = OUTPUT_COUNT;
+    amplitude.raw_sum_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_all_sector_weights = vec![1.0; OUTPUT_COUNT];
+    amplitude.raw_sum_color_sector_ids = vec![None; OUTPUT_COUNT];
+    amplitude.raw_sum_groups = groups;
+    let mut actual = vec![0.0; point_count];
+
+    amplitude
+        .reduce_scratch_f64_into_selected_slice(point_count, &mut actual, None)
+        .unwrap();
+
+    for (point_index, (actual, expected)) in actual.iter().zip(expected).enumerate() {
+        let absolute_error = (actual - expected).abs();
+        let tolerance = 1.0e-15 + 1.0e-12 * expected.abs();
+        assert!(
+            absolute_error <= tolerance,
+            "multi-coset C2^3 Walsh point {point_index} differs from expanded reference: \
+             actual={actual}, expected={expected}, absolute_error={absolute_error}, \
+             tolerance={tolerance}"
+        );
+    }
+}
+
+#[test]
+fn compact_c2k_walsh_generic_rank_four_matches_expanded_reduction() {
+    let component_count = 2;
+    let local_group_count = 16;
+    let output_count = component_count * local_group_count;
+    let groups = (0..output_count)
+        .map(|group_index| {
+            repeated_test_group(
+                20 + group_index as i64,
+                group_index,
+                200 + (group_index / component_count) as i64,
+            )
+        })
+        .collect::<Vec<_>>();
+    let kernel = (0..local_group_count)
+        .map(|index| 1.0 / (index + 1) as f64)
+        .collect::<Vec<_>>();
+    let entries = (0..local_group_count)
+        .flat_map(|left_group_index| {
+            let kernel = &kernel;
+            (left_group_index..local_group_count).map(move |right_group_index| {
+                GenericRepeatedColorContractionEntryManifest {
+                    _exact_weight: None,
+                    left_group_index,
+                    right_group_index,
+                    weight: vec![kernel[left_group_index ^ right_group_index], 0.0],
+                    symmetry_factor: if left_group_index == right_group_index {
+                        1.0
+                    } else {
+                        2.0
+                    },
+                }
+            })
+        })
+        .collect::<Vec<_>>();
+    let manifest = GenericColorContractionManifest {
+        supported: true,
+        reason: None,
+        group_count: groups.len(),
+        includes_color_factor: true,
+        entries: Vec::new(),
+        repeated_block: Some(GenericRepeatedColorContractionBlockManifest {
+            component_count,
+            component_group_ids: (20..20 + groups.len() as i64).collect(),
+            entries,
+            factorized_block: Some(
+                GenericFactorizedColorContractionBlockManifest::ElementaryAbelianWalsh {
+                    rank: 4,
+                    cosets: vec![(0..local_group_count).collect()],
+                },
+            ),
+        }),
+    };
+    let contraction = build_color_contraction_runtime(Some(&manifest), &groups)
+        .unwrap()
+        .expect("compact C2^4 Walsh contraction");
+    let logical_entries = contraction.logical_entries().collect::<Vec<_>>();
+    let outputs = (0..output_count)
+        .map(|index| c64(index as f64 * 0.03125, 1.0 - index as f64 * 0.015625))
+        .collect::<Vec<_>>();
+    let expected =
+        legacy_color_contraction_totals(&outputs, output_count, &groups, &logical_entries)[0];
+    let mut amplitude = test_amplitude_runtime(outputs, Some(contraction));
+    amplitude.raw_sum_groups = groups;
+    let mut actual = vec![0.0];
+
+    amplitude
+        .reduce_scratch_f64_into_selected_slice(1, &mut actual, None)
+        .unwrap();
+
+    assert!(
+        (actual[0] - expected).abs() <= 1.0e-12 * expected.abs().max(1.0),
+        "generic C2^4 Walsh reduction {} differs from expanded repeated reduction {expected}",
+        actual[0]
+    );
+}
+
+#[test]
+fn compact_walsh_color_manifest_rejects_malformed_or_noninvariant_plans() {
+    let groups = (0..8)
+        .map(|group_index| {
+            repeated_test_group(
+                10 + group_index as i64,
+                group_index,
+                100 + (group_index / 2) as i64,
+            )
+        })
+        .collect::<Vec<_>>();
+    let manifest = |cosets: Vec<[usize; 4]>,
+                    entries: Vec<GenericRepeatedColorContractionEntryManifest>| {
+        GenericColorContractionManifest {
+            supported: true,
+            reason: None,
+            group_count: groups.len(),
+            includes_color_factor: true,
+            entries: Vec::new(),
+            repeated_block: Some(GenericRepeatedColorContractionBlockManifest {
+                component_count: 2,
+                component_group_ids: (10..18).collect(),
+                entries,
+                factorized_block: Some(
+                    GenericFactorizedColorContractionBlockManifest::KleinFourWalsh { cosets },
+                ),
+            }),
+        }
+    };
+    let cases = [
+        ("duplicate index", manifest(vec![[0, 1, 2, 2]], Vec::new())),
+        (
+            "not invariant",
+            manifest(
+                vec![[0, 1, 2, 3]],
+                vec![GenericRepeatedColorContractionEntryManifest {
+                    _exact_weight: None,
+                    left_group_index: 0,
+                    right_group_index: 0,
+                    weight: vec![1.0, 0.0],
+                    symmetry_factor: 1.0,
+                }],
+            ),
+        ),
+    ];
+    for (expected, manifest) in cases {
+        let error = match build_color_contraction_runtime(Some(&manifest), &groups) {
+            Ok(_) => panic!("malformed Walsh color contraction must fail"),
+            Err(error) => error,
+        };
+        assert!(
+            error.to_string().contains(expected),
+            "unexpected error for {expected}: {error}"
+        );
+    }
+
+    let unknown = serde_json::from_value::<GenericFactorizedColorContractionBlockManifest>(
+        json!({"kind": "future-transform", "cosets": [[0, 1, 2, 3]]}),
+    );
+    assert!(
+        unknown.is_err(),
+        "unknown factorization kind must fail closed"
+    );
+}
+
+#[test]
+fn compact_c2k_walsh_manifest_fails_closed_on_invalid_metadata() {
+    let groups = (0..16)
+        .map(|group_index| {
+            repeated_test_group(
+                10 + group_index as i64,
+                group_index,
+                100 + (group_index / 2) as i64,
+            )
+        })
+        .collect::<Vec<_>>();
+    let entry = |left_group_index: usize,
+                 right_group_index: usize,
+                 weight_re: f64|
+     -> GenericRepeatedColorContractionEntryManifest {
+        GenericRepeatedColorContractionEntryManifest {
+            _exact_weight: None,
+            left_group_index,
+            right_group_index,
+            weight: vec![weight_re, 0.0],
+            symmetry_factor: if left_group_index == right_group_index {
+                1.0
+            } else {
+                2.0
+            },
+        }
+    };
+    let manifest = |rank: usize,
+                    cosets: Vec<Vec<usize>>,
+                    entries: Vec<GenericRepeatedColorContractionEntryManifest>| {
+        GenericColorContractionManifest {
+            supported: true,
+            reason: None,
+            group_count: groups.len(),
+            includes_color_factor: true,
+            entries: Vec::new(),
+            repeated_block: Some(GenericRepeatedColorContractionBlockManifest {
+                component_count: 2,
+                component_group_ids: (10..26).collect(),
+                entries,
+                factorized_block: Some(
+                    GenericFactorizedColorContractionBlockManifest::ElementaryAbelianWalsh {
+                        rank,
+                        cosets,
+                    },
+                ),
+            }),
+        }
+    };
+    let canonical_coset = vec![(0..8).collect::<Vec<_>>()];
+    let cases = [
+        (
+            "rank must be at least three",
+            manifest(2, vec![(0..4).collect()], Vec::new()),
+        ),
+        (
+            "do not match rank or local groups",
+            manifest(3, vec![(0..7).collect()], Vec::new()),
+        ),
+        (
+            "duplicate index",
+            manifest(3, vec![vec![0, 1, 2, 3, 4, 5, 6, 6]], Vec::new()),
+        ),
+        (
+            "weights must be finite",
+            manifest(3, canonical_coset.clone(), vec![entry(0, 0, f64::NAN)]),
+        ),
+        (
+            "duplicate matrix entry",
+            manifest(
+                3,
+                canonical_coset.clone(),
+                vec![entry(0, 1, 1.0), entry(1, 0, 1.0)],
+            ),
+        ),
+        (
+            "not invariant",
+            manifest(3, canonical_coset.clone(), vec![entry(0, 0, 1.0)]),
+        ),
+        (
+            "subgroup order overflows",
+            manifest(usize::BITS as usize, canonical_coset, Vec::new()),
+        ),
+    ];
+    for (expected, manifest) in cases {
+        let error = match build_color_contraction_runtime(Some(&manifest), &groups) {
+            Ok(_) => panic!("malformed C2^k Walsh color contraction must fail"),
+            Err(error) => error,
+        };
+        assert!(
+            error.to_string().contains(expected),
+            "unexpected error for {expected}: {error}"
+        );
+    }
+
+    for malformed in [
+        json!({
+            "kind": "elementary-abelian-walsh",
+            "cosets": [[0, 1, 2, 3, 4, 5, 6, 7]],
+        }),
+        json!({
+            "kind": "elementary-abelian-walsh",
+            "rank": 3,
+            "cosets": [[0, 1, 2, 3, 4, 5, 6, 7]],
+            "unexpected": true,
+        }),
+    ] {
+        assert!(
+            serde_json::from_value::<GenericFactorizedColorContractionBlockManifest>(malformed)
+                .is_err(),
+            "C2^k Walsh wire metadata must be exact"
+        );
+    }
+}
+
+#[test]
+fn compact_repeated_color_manifest_rejects_duplicate_group_mapping() {
+    let groups = vec![
+        repeated_test_group(10, 0, 100),
+        repeated_test_group(11, 1, 100),
+    ];
+    let manifest = GenericColorContractionManifest {
+        supported: true,
+        reason: None,
+        group_count: groups.len(),
+        includes_color_factor: true,
+        entries: Vec::new(),
+        repeated_block: Some(GenericRepeatedColorContractionBlockManifest {
+            component_count: 2,
+            component_group_ids: vec![10, 10],
+            entries: Vec::new(),
+            factorized_block: None,
+        }),
+    };
+    let error = match build_color_contraction_runtime(Some(&manifest), &groups) {
+        Ok(_) => panic!("duplicate repeated color group mapping must fail"),
+        Err(error) => error,
+    };
+    assert!(
+        error
+            .to_string()
+            .contains("maps a coherent group more than once")
+    );
+}
+
+#[test]
+fn compact_repeated_color_manifest_rejects_malformed_storage() {
+    let missing_entries = serde_json::from_value::<GenericColorContractionManifest>(json!({
+        "supported": true,
+        "group_count": 2,
+        "includes_color_factor": true,
+    }));
+    assert!(missing_entries.is_err());
+
+    let groups = vec![
+        repeated_test_group(10, 0, 100),
+        repeated_test_group(11, 1, 100),
+    ];
+    let repeated = |weight: Vec<f64>, left_group_index: usize| {
+        Some(GenericRepeatedColorContractionBlockManifest {
+            component_count: 2,
+            component_group_ids: vec![10, 11],
+            entries: vec![GenericRepeatedColorContractionEntryManifest {
+                _exact_weight: None,
+                left_group_index,
+                right_group_index: 0,
+                weight,
+                symmetry_factor: 1.0,
+            }],
+            factorized_block: None,
+        })
+    };
+    let malformed = [
+        (
+            "two components",
+            GenericColorContractionManifest {
+                supported: true,
+                reason: None,
+                group_count: 2,
+                includes_color_factor: true,
+                entries: Vec::new(),
+                repeated_block: repeated(vec![1.0], 0),
+            },
+        ),
+        (
+            "out of bounds",
+            GenericColorContractionManifest {
+                supported: true,
+                reason: None,
+                group_count: 2,
+                includes_color_factor: true,
+                entries: Vec::new(),
+                repeated_block: repeated(vec![1.0, 0.0], 1),
+            },
+        ),
+        (
+            "cannot mix",
+            GenericColorContractionManifest {
+                supported: true,
+                reason: None,
+                group_count: 2,
+                includes_color_factor: true,
+                entries: vec![GenericColorContractionEntryManifest {
+                    _exact_weight: None,
+                    left_group_id: 10,
+                    right_group_id: 10,
+                    weight: vec![1.0, 0.0],
+                    symmetry_factor: 1.0,
+                }],
+                repeated_block: repeated(vec![1.0, 0.0], 0),
+            },
+        ),
+    ];
+    for (expected, manifest) in malformed {
+        let error = match build_color_contraction_runtime(Some(&manifest), &groups) {
+            Ok(_) => panic!("malformed repeated color storage must fail"),
+            Err(error) => error,
+        };
+        assert!(
+            error.to_string().contains(expected),
+            "unexpected error for {expected}: {error}"
+        );
+    }
+}
+
+#[test]
+fn repeated_complex_color_blocks_match_legacy_reduction() {
+    let groups = vec![
+        repeated_test_group(10, 0, 100),
+        repeated_test_group(11, 1, 100),
+        repeated_test_group(12, 2, 200),
+        repeated_test_group(13, 3, 200),
+    ];
+    let entries = vec![
+        ColorContractionEntry {
+            left_group_index: 0,
+            right_group_index: 2,
+            weight_re: 0.75,
+            weight_im: -0.25,
+            symmetry_factor: 2.0,
+        },
+        ColorContractionEntry {
+            left_group_index: 1,
+            right_group_index: 3,
+            weight_re: 0.75,
+            weight_im: -0.25,
+            symmetry_factor: 2.0,
+        },
+    ];
+    let outputs = vec![
+        c64(1.0, 2.0),
+        c64(-0.5, 0.25),
+        c64(0.75, -1.0),
+        c64(2.0, 0.5),
+    ];
+    let expected = legacy_color_contraction_totals(&outputs, 4, &groups, &entries);
+    let mut amplitude = reduction_test_amplitude(4, outputs.clone(), groups, entries);
+    assert!(
+        !amplitude
+            .color_contraction
+            .as_ref()
+            .unwrap()
+            .repeated_block
+            .as_ref()
+            .unwrap()
+            .all_weights_real
+    );
+    let mut actual = vec![0.0];
+    amplitude
+        .reduce_scratch_f64_into_selected_slice(1, &mut actual, None)
+        .unwrap();
+    let plane_native = plane_native_totals(&mut amplitude, &outputs, 1, None);
+    assert_eq!(plane_native, actual);
+    assert!((actual[0] - expected[0]).abs() <= 1.0e-12 * expected[0].abs().max(1.0));
+}
+
+#[test]
+fn contracted_color_coverage_does_not_warn_as_incomplete() {
+    for color_accuracy in ["nlc", "full"] {
+        let physics = test_physics_runtime(color_accuracy);
+        let physics_v1 = physics.manifest.clone();
+        let mut execution = empty_generic_runtime();
+        execution.color_accuracy = color_accuracy.to_string();
+        execution.physics = Some(Arc::new(physics));
+        let mut runtime = NativeRuntime {
+            root: PathBuf::new(),
+            artifact_id: "0".repeat(64),
+            runtime: execution,
+            execution_lane: NativeExecutionLane::Compiled,
+            process: "x x > y".to_string(),
+            process_key: "x_x_to_y".to_string(),
+            representative_process_id: "x_x_to_y".to_string(),
+            external_permutation: vec![0, 1, 2],
+            input_crossing_map: None,
+            permutation_alias_of: None,
+            final_state_permutation_alias_of: None,
+            physics_v1: native_runtime::LazyProcessPhysicsV1::loaded(physics_v1),
+            warnings_muted: false,
+            warned_kinds: BTreeSet::new(),
+            pending_warnings: Vec::new(),
+            point_selector_scratch: PointSelectorExecutionScratch::default(),
+            selector_simd_lane_width: 1,
+            correlated: None,
+            process_group: None,
+        };
+
+        runtime.record_resolved_warnings(None, None).unwrap();
+
+        assert!(runtime.pending_warnings.is_empty());
+    }
+}
+
+#[test]
+fn inconsistent_helicity_weights_are_rejected() {
+    let mut physics = test_physics_runtime("nlc").manifest;
+    physics.helicities[1].coefficient = 2.0;
+
+    let error = PhysicsRuntime::new(physics).err().unwrap();
+
+    assert!(error.to_string().contains("inconsistent helicity weights"));
+}
+
+#[test]
+fn numeric_reduction_binding_preserves_manifest_order_and_weights() {
+    for color_accuracy in ["lc", "nlc", "full"] {
+        let physics = test_physics_runtime(color_accuracy);
+        let reduction = physics.reduction_by_group_id.get(&7).unwrap();
+        let numeric = physics.numeric_reduction_by_group_id.get(&7).unwrap();
+
+        let expected_helicity_indices = reduction
+            .physical_helicity_ids
+            .iter()
+            .map(|id| physics.helicity_index_by_id[id])
+            .collect::<Vec<_>>();
+        assert_eq!(numeric.physical_helicity_indices, expected_helicity_indices);
+        for (index, helicity) in physics.manifest.helicities.iter().enumerate() {
+            assert_eq!(
+                numeric.contains_helicity(index),
+                reduction.physical_helicity_ids.contains(&helicity.id)
+            );
+        }
+        assert_eq!(
+            numeric.normalized_helicity_weights,
+            physics.normalized_helicity_weights(reduction).unwrap()
+        );
+        assert_eq!(
+            numeric.normalized_member_weights,
+            physics.normalized_member_weights(reduction).unwrap()
+        );
+
+        let mut expected_color_weights = reduction
+            .physical_color_ids
+            .iter()
+            .map(|id| {
+                let index = physics.color_index_by_id[id];
+                (
+                    index,
+                    physics.manifest.color_components[index].coefficient(),
+                )
+            })
+            .collect::<Vec<_>>();
+        let total_color_weight = expected_color_weights
+            .iter()
+            .map(|(_, weight)| *weight)
+            .sum::<f64>();
+        for (_, weight) in &mut expected_color_weights {
+            *weight /= total_color_weight;
+        }
+        assert_eq!(numeric.normalized_color_weights, expected_color_weights);
+    }
+}
+
+pub(super) fn empty_generic_runtime() -> ExecutionRuntime {
+    ExecutionRuntime {
+        process: "a b > c".to_string(),
+        key: "p0".to_string(),
+        color_accuracy: "lc".to_string(),
+        external_pdg_order: Vec::new(),
+        external_count: 0,
+        parameter_count: 1,
+        value_parameter_count: 0,
+        momentum_parameter_count: 0,
+        current_count: 0,
+        source_count: 0,
+        interaction_count: 0,
+        stage_count: 0,
+        amplitude_output_count: 0,
+        lc_topology_replay_enabled: false,
+        lc_topology_replay_mappings: Arc::new(Vec::new()),
+        lc_topology_replay_public_mappings: Vec::new(),
+        lc_topology_replay_routes: Vec::new(),
+        lc_topology_replay_materialized_sector_ids: BTreeSet::new(),
+        lc_resolved_replay_plan: None,
+        lc_resolved_replay_selection_cache: None,
+        lc_replay_flat_momenta_scratch: Vec::new(),
+        lc_replay_target_components_scratch: Vec::new(),
+        color_topology_replay_enabled: false,
+        color_topology_replay_mappings: Arc::new(Vec::new()),
+        color_replay_flat_momenta_scratch: Vec::new(),
+        helicity_recurrence: None,
+        compiled_helicity_execution_plan: None,
+        compiled_color_execution_plan: None,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        compiled_direct_runtime: None,
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        compiled_direct_color_schedules: BTreeMap::new(),
+        #[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+        compiled_direct_helicity_schedules: BTreeMap::new(),
+        helicity_sum_runtime: None,
+        helicity_selector_runtimes: Vec::new(),
+        helicity_selector_runtime_schedule_modes: Vec::new(),
+        helicity_selector_lane_by_domain: BTreeMap::new(),
+        color_selector_runtimes: BTreeMap::new(),
+        runtime_unavailable_message: None,
+        sources: Vec::new(),
+        momentum_slots: Vec::new(),
+        external_is_initial: Vec::new(),
+        particle_masses: BTreeMap::new(),
+        particle_mass_parameter_names: BTreeMap::new(),
+        normalization_factor: 1.0,
+        normalization_color_factor: 1.0,
+        normalization_average_factor: 1.0,
+        normalization_identical_factor: 1.0,
+        normalization_qcd_coupling_power: 0,
+        normalization_electroweak_coupling_power: 0,
+        model_parameters: Vec::new(),
+        model_parameter_name_to_index: BTreeMap::new(),
+        model_parameter_runtime_slots: BTreeMap::new(),
+        model_parameter_values_f64: vec![0.118],
+        model_parameter_evaluator: None,
+        physics_reduction_override: None,
+        physics: None,
+        stages: None,
+        amplitude_stage: None,
+        state_scratch_f64: Vec::new(),
+        state_scratch_f64_requires_clear: false,
+        values_scratch_f64: Vec::new(),
+    }
+}
+
+fn lc_direct_total_test_group(id: i64, helicity_id: &str, color_id: &str) -> crate::ReductionGroup {
+    crate::ReductionGroup {
+        id: format!("group:{id}"),
+        representative_helicity_id: helicity_id.to_string(),
+        physical_helicity_ids: vec![helicity_id.to_string()],
+        representative_color_id: color_id.to_string(),
+        physical_color_ids: vec![color_id.to_string()],
+    }
+}
+
+fn strict_lc_direct_total_test_groups() -> Vec<crate::ReductionGroup> {
+    [
+        ("hel:+-", "flow:0"),
+        ("hel:+-", "flow:1"),
+        ("hel:-+", "flow:0"),
+        ("hel:-+", "flow:1"),
+    ]
+    .into_iter()
+    .enumerate()
+    .map(|(index, (helicity_id, color_id))| {
+        lc_direct_total_test_group(7 + index as i64, helicity_id, color_id)
+    })
+    .collect()
+}
+
+fn lc_direct_total_test_runtime(groups: Vec<crate::ReductionGroup>) -> ExecutionRuntime {
+    let mut manifest = test_physics_runtime("lc").manifest;
+    manifest.helicities[1].computed = true;
+    manifest.helicities[1].representative_id = manifest.helicities[1].id.clone();
+    let crate::ColorComponent::LcFlow(second_flow) = &mut manifest.color_components[1] else {
+        panic!("LC test physics must contain LC flows");
+    };
+    second_flow.computed = true;
+    second_flow.representative_id = second_flow.id.clone();
+    manifest.reduction.groups = groups.clone();
+    let physics = PhysicsRuntime::new(manifest).expect("valid LC direct-total test physics");
+
+    let mut amplitude = test_amplitude_runtime(vec![c64(1.0, 0.0); groups.len()], None);
+    amplitude.raw_sum_groups = groups
+        .iter()
+        .enumerate()
+        .map(|(index, group)| RawSumGroup {
+            id: parse_reduction_group_id(&group.id).expect("numeric test reduction group id"),
+            indices: vec![index],
+            weight: 1.0,
+            all_sector_weight: 1.0,
+            sector_ids: vec![index as i64],
+        })
+        .collect();
+
+    let mut runtime = empty_generic_runtime();
+    runtime.amplitude_output_count = groups.len();
+    runtime.physics = Some(Arc::new(physics));
+    runtime.amplitude_stage = Some(amplitude);
+    runtime
+}
+
+fn lc_direct_total_test_selectors() -> (BTreeSet<String>, BTreeSet<String>) {
+    (
+        BTreeSet::from(["hel:+-".to_string(), "hel:-+".to_string()]),
+        BTreeSet::from(["flow:0".to_string(), "flow:1".to_string()]),
+    )
+}
+
+#[test]
+fn lc_direct_total_source_certification_accepts_exact_cartesian_partitions() {
+    let runtime = lc_direct_total_test_runtime(strict_lc_direct_total_test_groups());
+    let (helicity_ids, color_ids) = lc_direct_total_test_selectors();
+
+    assert!(certifies_lc_direct_total_source(
+        &runtime,
+        &helicity_ids,
+        &color_ids
+    ));
+
+    let grouped_runtime = lc_direct_total_test_runtime(vec![
+        crate::ReductionGroup {
+            id: "group:7".to_string(),
+            representative_helicity_id: "hel:+-".to_string(),
+            physical_helicity_ids: vec!["hel:+-".to_string(), "hel:-+".to_string()],
+            representative_color_id: "flow:0".to_string(),
+            physical_color_ids: vec!["flow:0".to_string()],
+        },
+        crate::ReductionGroup {
+            id: "group:8".to_string(),
+            representative_helicity_id: "hel:+-".to_string(),
+            physical_helicity_ids: vec!["hel:+-".to_string(), "hel:-+".to_string()],
+            representative_color_id: "flow:1".to_string(),
+            physical_color_ids: vec!["flow:1".to_string()],
+        },
+    ]);
+    assert!(certifies_lc_direct_total_source(
+        &grouped_runtime,
+        &helicity_ids,
+        &color_ids
+    ));
+}
+
+#[test]
+fn lc_direct_total_source_certification_rejects_nonexact_auxiliary_reductions() {
+    let (helicity_ids, color_ids) = lc_direct_total_test_selectors();
+
+    let mut overbroad_groups = strict_lc_direct_total_test_groups();
+    overbroad_groups[0].physical_helicity_ids = vec!["hel:+-".to_string(), "hel:-+".to_string()];
+    let overbroad = lc_direct_total_test_runtime(overbroad_groups);
+    assert!(
+        !certifies_lc_direct_total_source(&overbroad, &helicity_ids, &color_ids),
+        "an auxiliary reduction group may not cover extra source helicities"
+    );
+
+    let mut partial_groups = strict_lc_direct_total_test_groups();
+    partial_groups.pop();
+    let partial = lc_direct_total_test_runtime(partial_groups);
+    assert!(
+        !certifies_lc_direct_total_source(&partial, &helicity_ids, &color_ids),
+        "an auxiliary reduction must cover every requested source component"
+    );
+
+    let mut duplicate_groups = strict_lc_direct_total_test_groups();
+    duplicate_groups[3].representative_helicity_id = "hel:+-".to_string();
+    duplicate_groups[3].physical_helicity_ids = vec!["hel:+-".to_string()];
+    duplicate_groups[3].representative_color_id = "flow:0".to_string();
+    duplicate_groups[3].physical_color_ids = vec!["flow:0".to_string()];
+    let duplicate = lc_direct_total_test_runtime(duplicate_groups);
+    assert!(
+        !certifies_lc_direct_total_source(&duplicate, &helicity_ids, &color_ids),
+        "duplicate source members may not stand in for a missing Cartesian member"
+    );
+
+    let mut mismatched_ids = lc_direct_total_test_runtime(strict_lc_direct_total_test_groups());
+    mismatched_ids
+        .amplitude_stage
+        .as_mut()
+        .expect("test amplitude")
+        .raw_sum_groups[0]
+        .id = 999;
+    assert!(
+        !certifies_lc_direct_total_source(&mismatched_ids, &helicity_ids, &color_ids),
+        "the auxiliary evaluator groups must match the certified physics reduction"
+    );
+}
+
+fn zero_native_runtime() -> NativeRuntime {
+    let physics = test_physics_runtime("lc");
+    let physics_v1 = physics.manifest.clone();
+    let mut execution = empty_generic_runtime();
+    execution.external_count = 3;
+    execution.external_pdg_order = vec![1, -1, 23];
+    execution.external_is_initial = vec![true, true, false];
+    execution.physics = Some(Arc::new(physics));
+    execution.stages = Some(Vec::new());
+    let mut amplitude = test_amplitude_runtime(Vec::new(), None);
+    amplitude.input_components = Some(Vec::new());
+    execution.amplitude_stage = Some(amplitude);
+    NativeRuntime {
+        root: PathBuf::new(),
+        artifact_id: "0".repeat(64),
+        runtime: execution,
+        execution_lane: NativeExecutionLane::Compiled,
+        process: "x x > y".to_string(),
+        process_key: "x_x_to_y".to_string(),
+        representative_process_id: "x_x_to_y".to_string(),
+        external_permutation: vec![0, 1, 2],
+        input_crossing_map: None,
+        permutation_alias_of: None,
+        final_state_permutation_alias_of: None,
+        physics_v1: native_runtime::LazyProcessPhysicsV1::loaded(physics_v1),
+        warnings_muted: false,
+        warned_kinds: BTreeSet::new(),
+        pending_warnings: Vec::new(),
+        point_selector_scratch: PointSelectorExecutionScratch::default(),
+        selector_simd_lane_width: 1,
+        correlated: None,
+        process_group: None,
+    }
+}
+
+#[test]
+fn native_runtime_clear_is_a_noop_outside_the_on_the_fly_lane() {
+    let mut runtime = zero_native_runtime();
+    let artifact_id = runtime.artifact_id().to_string();
+    let parameters = runtime.runtime.model_parameter_values_f64.clone();
+    let metadata = runtime.metadata_json().unwrap();
+
+    runtime.clear().unwrap();
+
+    assert_eq!(runtime.artifact_id(), artifact_id);
+    assert_eq!(runtime.runtime.model_parameter_values_f64, parameters);
+    assert_eq!(runtime.metadata_json().unwrap(), metadata);
+    assert!(
+        runtime
+            .on_the_fly_runtime_state_census_json()
+            .unwrap()
+            .is_none()
+    );
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn scalar_on_the_fly_native_runtime() -> NativeRuntime {
+    scalar_on_the_fly_native_runtime_with_color_contraction(None)
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+fn scalar_on_the_fly_native_runtime_with_color_contraction(
+    color_contraction: Option<super::on_the_fly_load::LoadedOnTheFlyColorContractionV1>,
+) -> NativeRuntime {
+    use super::on_the_fly_lane::OnTheFlyNativeRuntime;
+    use super::on_the_fly_selectors::{
+        OnTheFlyCompactSelectorAdapterV1, OnTheFlyLcColorCoverageV1, OnTheFlyLcSelectorPolicyV1,
+    };
+    use super::recurrence_backend::on_the_fly_adapter_tests::{
+        complete_scalar_direct_catalog, complete_scalar_prepared_pool, digest, source_domains,
+    };
+    use crate::recurrence::CheckedTableRange;
+    use crate::recurrence::on_the_fly::scalar_adapter_test_seed;
+    use crate::recurrence::template::{CouplingOrderTermRow, IndexedRangeRow};
+    use crate::recurrence::validated_template_fixture;
+
+    let mut template_input = validated_template_fixture().into_input();
+    let spin_start = u64::try_from(template_input.i32_sequence_values.len()).unwrap();
+    let spin_sequence_id = u32::try_from(template_input.i32_sequence_ranges.len()).unwrap();
+    template_input.i32_sequence_ranges.push(IndexedRangeRow {
+        id: spin_sequence_id,
+        range: CheckedTableRange::new(spin_start, 2),
+    });
+    template_input.i32_sequence_values.extend([50_000, 50_000]);
+    template_input.quantum_flows[0].input_spin_sequence_id = spin_sequence_id;
+    template_input.coupling_order_ranges.push(IndexedRangeRow {
+        id: 1,
+        range: CheckedTableRange::new(0, 1),
+    });
+    template_input
+        .coupling_order_terms
+        .push(CouplingOrderTermRow {
+            set_id: 1,
+            name_string_id: 0,
+            power: 1,
+        });
+    let templates = template_input.validate().unwrap();
+    let summary = templates.summary();
+    let direct_digest = digest(40);
+    let direct = complete_scalar_direct_catalog(direct_digest);
+    let seed = scalar_adapter_test_seed(
+        summary.compiled_model_digest,
+        summary.catalog_digest,
+        summary.prepared_kernel_pack_digest,
+        direct_digest,
+    )
+    .and_then(|seed| seed.with_selector_local_zero())
+    .unwrap();
+    let pool = complete_scalar_prepared_pool(&templates, direct_digest);
+    let sources = pool.bind_source_domains(source_domains()).unwrap();
+    let resolver = pool.into_on_the_fly_resolver(sources);
+    let defaults = vec![
+        crate::EagerComplex64::new(0.0, 0.0);
+        usize::try_from(summary.parameter_count).unwrap()
+    ];
+    let selectors = OnTheFlyCompactSelectorAdapterV1::from_seed(
+        &seed,
+        OnTheFlyLcSelectorPolicyV1 {
+            color_coverage: OnTheFlyLcColorCoverageV1::Complete,
+            color_basis: Default::default(),
+            reference_color_word: None,
+            trace_reflections_folded: false,
+        },
+    )
+    .unwrap();
+    let lane = OnTheFlyNativeRuntime::new(
+        templates,
+        direct,
+        seed,
+        resolver,
+        1,
+        1,
+        defaults,
+        Vec::new(),
+        &[],
+    )
+    .unwrap();
+    let mut execution = empty_generic_runtime();
+    execution.external_count = 2;
+    execution.external_pdg_order = vec![900_000, 900_000];
+    execution.external_is_initial = vec![true, false];
+    execution.physics = None;
+    execution.normalization_factor = 1.0;
+    NativeRuntime {
+        root: PathBuf::new(),
+        artifact_id: "0".repeat(64),
+        runtime: execution,
+        execution_lane: NativeExecutionLane::OnTheFly(Box::new(
+            native_runtime::OnTheFlyExecutionRuntime::new(lane, selectors, color_contraction),
+        )),
+        process: "s > s".to_string(),
+        process_key: "s_to_s".to_string(),
+        representative_process_id: "s_to_s".to_string(),
+        external_permutation: vec![0, 1],
+        input_crossing_map: None,
+        permutation_alias_of: None,
+        final_state_permutation_alias_of: None,
+        physics_v1: native_runtime::LazyProcessPhysicsV1::unavailable(),
+        warnings_muted: false,
+        warned_kinds: BTreeSet::new(),
+        pending_warnings: Vec::new(),
+        point_selector_scratch: PointSelectorExecutionScratch::default(),
+        selector_simd_lane_width: 1,
+        correlated: None,
+        process_group: None,
+    }
+}
+
+#[cfg(all(
+    any(feature = "f64-compiled", feature = "f64-symjit"),
+    any(target_os = "linux", target_os = "macos")
+))]
+#[test]
+fn on_the_fly_warmed_fixed_selection_is_allocation_free_and_last_family_only() {
+    let mut runtime = scalar_on_the_fly_native_runtime();
+    let point_count = 2;
+    let momenta = vec![0.0; point_count * 2 * 4];
+    let color = ["flow:singlet".to_string()];
+    let selection_a = ["h:+0,+0".to_string()];
+    let selection_b = ["h:+1,+1".to_string()];
+    let mut output = vec![0.0; point_count];
+
+    runtime
+        .evaluate_f64_into_with_selectors(
+            &momenta,
+            point_count,
+            Some(&selection_a),
+            Some(&color),
+            None,
+            None,
+            &mut output,
+        )
+        .unwrap();
+    assert!(output.iter().all(|value| value.abs() > f64::EPSILON));
+    let expected_a = output.clone();
+
+    let (warm_a, allocations, bytes) = super::count_allocations(|| {
+        runtime.evaluate_f64_into_with_selectors(
+            &momenta,
+            point_count,
+            Some(&selection_a),
+            Some(&color),
+            None,
+            None,
+            &mut output,
+        )
+    });
+    warm_a.unwrap();
+    assert_eq!(output, expected_a);
+    assert_eq!(allocations, 0, "warmed fixed OTF selection allocated");
+    assert_eq!(bytes, 0, "warmed fixed OTF selection allocated bytes");
+
+    let (cold_b, allocations, _) = super::count_allocations(|| {
+        runtime.evaluate_f64_into_with_selectors(
+            &momenta,
+            point_count,
+            Some(&selection_b),
+            Some(&color),
+            None,
+            None,
+            &mut output,
+        )
+    });
+    cold_b.unwrap();
+    assert!(allocations > 0, "replacement family was not prepared cold");
+    assert_eq!(output, [0.0; 2]);
+
+    let (warm_b, allocations, bytes) = super::count_allocations(|| {
+        runtime.evaluate_f64_into_with_selectors(
+            &momenta,
+            point_count,
+            Some(&selection_b),
+            Some(&color),
+            None,
+            None,
+            &mut output,
+        )
+    });
+    warm_b.unwrap();
+    assert_eq!(allocations, 0, "warmed replacement OTF selection allocated");
+    assert_eq!(bytes, 0, "warmed replacement OTF selection allocated bytes");
+
+    // Only the current family is retained. Returning to A must rebuild it,
+    // after which the same A selection is allocation-free again.
+    let (revisited_a, allocations, _) = super::count_allocations(|| {
+        runtime.evaluate_f64_into_with_selectors(
+            &momenta,
+            point_count,
+            Some(&selection_a),
+            Some(&color),
+            None,
+            None,
+            &mut output,
+        )
+    });
+    revisited_a.unwrap();
+    assert!(
+        allocations > 0,
+        "evicted fixed OTF selection was not rebuilt"
+    );
+    assert_eq!(output, expected_a);
+
+    let (warm_revisited_a, allocations, bytes) = super::count_allocations(|| {
+        runtime.evaluate_f64_into_with_selectors(
+            &momenta,
+            point_count,
+            Some(&selection_a),
+            Some(&color),
+            None,
+            None,
+            &mut output,
+        )
+    });
+    warm_revisited_a.unwrap();
+    assert_eq!(allocations, 0, "rewarmed fixed OTF selection allocated");
+    assert_eq!(bytes, 0, "rewarmed fixed OTF selection allocated bytes");
+    let NativeExecutionLane::OnTheFly(execution) = &runtime.execution_lane else {
+        panic!("test runtime changed execution lane");
+    };
+    assert_eq!(execution.retained_family_count(), 1);
+    assert_eq!(execution.retained_selection_count(), 1);
+}
+
+#[cfg(all(
+    any(feature = "f64-compiled", feature = "f64-symjit"),
+    any(target_os = "linux", target_os = "macos")
+))]
+#[test]
+fn on_the_fly_unprofiled_lc_and_contracted_match_profiles_and_allocate_nothing() {
+    for contracted in [false, true] {
+        let contraction = contracted.then(|| {
+            super::on_the_fly_load::LoadedOnTheFlyColorContractionV1 {
+                plan: crate::recurrence::RecurrenceColorContraction::expanded_identity_for_runtime_test(),
+                destination_by_owner_ordinal: vec![0].into_boxed_slice(),
+                point_tile_size: 1,
+            }
+        });
+        let mut runtime = scalar_on_the_fly_native_runtime_with_color_contraction(contraction);
+        if contracted {
+            runtime.runtime.color_accuracy = "full".to_string();
+        }
+        let label = if contracted { "contracted" } else { "LC" };
+        let point_count = 2;
+        let momenta = vec![0.0; point_count * 2 * 4];
+        let helicities = ["h:+0,+0".to_string()];
+        let color = ["flow:singlet".to_string()];
+        let colors = (!contracted).then_some(color.as_slice());
+        let mut output = vec![f64::NAN; point_count];
+
+        runtime
+            .evaluate_f64_into_with_selectors(
+                &momenta,
+                point_count,
+                Some(&helicities),
+                colors,
+                None,
+                None,
+                &mut output,
+            )
+            .unwrap();
+        let expected = output.clone();
+        let profiled = runtime
+            .evaluate_f64_profile(&momenta, point_count, Some(&helicities), colors)
+            .unwrap();
+        assert!(
+            profiled
+                .values
+                .iter()
+                .zip(&expected)
+                .all(|(candidate, expected)| candidate.to_bits() == expected.to_bits()),
+            "unprofiled {label} values differ bitwise from the diagnostic profile"
+        );
+        assert!(
+            profiled.profile.total_s.is_finite() && profiled.profile.total_s >= 0.0,
+            "{label} profile produced invalid timing"
+        );
+        assert!(
+            profiled.profile.recurrence_schedule_execution_count > 0,
+            "{label} profile lost schedule counts"
+        );
+        assert!(
+            profiled.profile.recurrence_source_call_count > 0,
+            "{label} profile lost source-call counts"
+        );
+        assert!(
+            profiled.profile.recurrence_closure_call_count > 0,
+            "{label} profile lost closure-call counts"
+        );
+        let NativeExecutionLane::OnTheFly(execution) = &runtime.execution_lane else {
+            panic!("test runtime changed execution lane");
+        };
+        let selected_census = execution.active_family_prepared_census().unwrap();
+        assert_eq!(
+            selected_census.query_count, 1,
+            "{label} evaluated unselected helicities"
+        );
+        assert_eq!(selected_census.union_amplitude_destination_count, 1);
+
+        runtime
+            .evaluate_f64_into_with_selectors(
+                &momenta,
+                point_count,
+                Some(&helicities),
+                colors,
+                None,
+                None,
+                &mut output,
+            )
+            .unwrap();
+        let (result, allocations, bytes) = super::count_allocations(|| {
+            runtime.evaluate_f64_into_with_selectors(
+                &momenta,
+                point_count,
+                Some(&helicities),
+                colors,
+                None,
+                None,
+                &mut output,
+            )
+        });
+        result.unwrap();
+        assert_eq!(output, expected, "warmed {label} values changed");
+        assert_eq!(allocations, 0, "warmed {label} OTF evaluation allocated");
+        assert_eq!(bytes, 0, "warmed {label} OTF evaluation allocated bytes");
+    }
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_runtime_state_census_is_observational() {
+    let retained_state = |runtime: &NativeRuntime| {
+        let NativeExecutionLane::OnTheFly(lane) = &runtime.execution_lane else {
+            panic!("test runtime changed execution lane");
+        };
+        (
+            lane.retained_family_count(),
+            lane.retained_selection_count(),
+            lane.semantic_executor_binding_count().unwrap(),
+        )
+    };
+    let census = |runtime: &NativeRuntime| {
+        runtime
+            .on_the_fly_runtime_state_census_json()
+            .unwrap()
+            .expect("on-the-fly runtime census is absent")
+    };
+
+    let mut runtime = scalar_on_the_fly_native_runtime();
+    let metadata = runtime.metadata();
+    assert_eq!(
+        metadata.on_the_fly_requested_query_construction_threads,
+        Some(1)
+    );
+    assert_eq!(
+        metadata.on_the_fly_effective_query_construction_threads,
+        Some(1)
+    );
+    let cold_state = retained_state(&runtime);
+    let cold_census = census(&runtime);
+    assert_eq!(census(&runtime), cold_census);
+    assert_eq!(retained_state(&runtime), cold_state);
+
+    let point_count = 2;
+    let momenta = vec![0.0; point_count * 2 * 4];
+    let first = runtime
+        .evaluate_f64_with_selectors(&momenta, point_count, None, None, None, None)
+        .unwrap();
+    let warm_state = retained_state(&runtime);
+    let warm_census = census(&runtime);
+    assert_eq!(census(&runtime), warm_census);
+    assert_eq!(retained_state(&runtime), warm_state);
+
+    let repeated = runtime
+        .evaluate_f64_with_selectors(&momenta, point_count, None, None, None, None)
+        .unwrap();
+    assert_eq!(repeated, first);
+    assert_eq!(census(&runtime), warm_census);
+    assert_eq!(retained_state(&runtime), warm_state);
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_contracted_color_selectors_fail_at_the_common_public_boundary() {
+    let mut runtime = scalar_on_the_fly_native_runtime();
+    // Selector capability validation is intentionally lane-neutral and keyed
+    // by authenticated public accuracy.  No contracted request may reach the
+    // compact structural planner.
+    runtime.runtime.color_accuracy = "full".to_string();
+    let momenta = vec![0.0; 2 * 4];
+    let color_by_point = [0_u32];
+    let error = runtime
+        .evaluate_f64_with_selectors(&momenta, 1, None, None, None, Some(&color_by_point))
+        .unwrap_err();
+    assert!(error.to_string().contains("only for LC"));
+
+    let color_ids = ["color:contracted".to_string()];
+    let error = runtime.resolved_shape(None, Some(&color_ids)).unwrap_err();
+    assert!(error.to_string().contains("only for LC"));
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_contracted_later_tile_failure_clears_both_selection_caches() {
+    let contraction = super::on_the_fly_load::LoadedOnTheFlyColorContractionV1 {
+        plan: crate::recurrence::RecurrenceColorContraction::expanded_identity_for_runtime_test(),
+        destination_by_owner_ordinal: vec![0].into_boxed_slice(),
+        point_tile_size: 1,
+    };
+    let mut runtime = scalar_on_the_fly_native_runtime_with_color_contraction(Some(contraction));
+    runtime.runtime.color_accuracy = "full".to_string();
+    let point_count = 2;
+    let momenta = vec![0.0; point_count * 2 * 4];
+    let selection_a = ["h:+0,+0".to_string()];
+    let selection_b = ["h:+1,+1".to_string()];
+
+    let a_before = runtime
+        .evaluate_f64_with_selectors(&momenta, point_count, Some(&selection_a), None, None, None)
+        .unwrap();
+    let NativeExecutionLane::OnTheFly(execution) = &mut runtime.execution_lane else {
+        panic!("test runtime changed execution lane");
+    };
+    assert_eq!(execution.retained_family_count(), 1);
+    assert_eq!(execution.retained_selection_count(), 1);
+    // Selection A is retained on both sides. For replacement B, attempt zero
+    // commits B's cold family on tile one; attempt one fails before tile two,
+    // while B's public wrapper selection is still pending.
+    execution.fail_contracted_execution_at_for_test(Some(1));
+
+    let error = runtime
+        .evaluate_f64_with_selectors(&momenta, point_count, Some(&selection_b), None, None, None)
+        .unwrap_err();
+    assert!(error.to_string().contains("injected"));
+
+    let NativeExecutionLane::OnTheFly(execution) = &mut runtime.execution_lane else {
+        panic!("test runtime changed execution lane");
+    };
+    assert_eq!(execution.retained_family_count(), 0);
+    assert_eq!(execution.retained_selection_count(), 0);
+    execution.fail_contracted_execution_at_for_test(None);
+
+    let a_after = runtime
+        .evaluate_f64_with_selectors(&momenta, point_count, Some(&selection_a), None, None, None)
+        .unwrap();
+    assert_eq!(a_after, a_before);
+    let NativeExecutionLane::OnTheFly(execution) = &runtime.execution_lane else {
+        panic!("test runtime changed execution lane");
+    };
+    assert_eq!(execution.retained_family_count(), 1);
+    assert_eq!(execution.retained_selection_count(), 1);
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_contracted_streaming_bounds_live_outcomes_and_retains_one_family() {
+    let contraction = super::on_the_fly_load::LoadedOnTheFlyColorContractionV1 {
+        plan: crate::recurrence::RecurrenceColorContraction::expanded_identity_for_runtime_test(),
+        destination_by_owner_ordinal: vec![0].into_boxed_slice(),
+        point_tile_size: 1,
+    };
+    let mut runtime = scalar_on_the_fly_native_runtime_with_color_contraction(Some(contraction));
+    runtime.runtime.color_accuracy = "full".to_string();
+    let momenta = vec![0.0; 2 * 4];
+
+    let values = runtime
+        .evaluate_f64_with_selectors(&momenta, 1, None, None, None, None)
+        .unwrap();
+    assert_eq!(values.len(), 1);
+    let NativeExecutionLane::OnTheFly(execution) = &runtime.execution_lane else {
+        panic!("test runtime changed execution lane");
+    };
+    // The complete scalar selector domain contains four helicities.  With a
+    // one-thread construction pool, only one query outcome may be alive at a
+    // time even though the complete H x S projection remains reusable.
+    assert_eq!(execution.contracted_max_live_query_outcomes_for_test(), 1);
+    assert_eq!(execution.retained_family_count(), 1);
+    assert_eq!(execution.retained_selection_count(), 1);
+    assert!(execution.active_family_prepared_census().is_some());
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_warm_up_reports_ordered_phases_and_reuses_the_committed_family() {
+    let contraction = super::on_the_fly_load::LoadedOnTheFlyColorContractionV1 {
+        plan: crate::recurrence::RecurrenceColorContraction::expanded_identity_for_runtime_test(),
+        destination_by_owner_ordinal: vec![0].into_boxed_slice(),
+        point_tile_size: 1,
+    };
+    let mut runtime = scalar_on_the_fly_native_runtime_with_color_contraction(Some(contraction));
+    runtime.runtime.color_accuracy = "full".to_string();
+    let momenta = vec![0.0; 2 * 4];
+    let mut events = Vec::new();
+    let mut observer = |event: &NativeOnTheFlyWarmUpEvent| {
+        assert_eq!(event.schema_version, 1);
+        assert!(event.completed <= event.total);
+        assert!(event.elapsed_seconds.is_finite() && event.elapsed_seconds >= 0.0);
+        events.push((event.kind, event.stage, event.completed, event.total));
+        Ok(true)
+    };
+    let observer: &mut NativeOnTheFlyWarmUpObserver<'_> = &mut observer;
+    let first = runtime
+        .warm_up_on_the_fly_f64_with_selectors(&momenta, None, None, None, Some(observer))
+        .unwrap();
+    assert!(!first.already_warm);
+    assert!(first.first_evaluation_completed);
+    assert_eq!(first.query_count, 4);
+    assert_eq!(first.warmed_query_count, 4);
+    assert_eq!(
+        events
+            .iter()
+            .map(|(_, stage, _, _)| *stage)
+            .collect::<BTreeSet<_>>(),
+        BTreeSet::from([
+            NativeOnTheFlyWarmUpStage::ProcessPreparation,
+            NativeOnTheFlyWarmUpStage::QueryFamily,
+            NativeOnTheFlyWarmUpStage::FamilyFinalization,
+            NativeOnTheFlyWarmUpStage::FirstEvaluation,
+        ])
+    );
+    let stage_ordinals = events
+        .iter()
+        .map(|(_, stage, _, _)| match stage {
+            NativeOnTheFlyWarmUpStage::ProcessPreparation => 0,
+            NativeOnTheFlyWarmUpStage::QueryFamily => 1,
+            NativeOnTheFlyWarmUpStage::FamilyFinalization => 2,
+            NativeOnTheFlyWarmUpStage::FirstEvaluation => 3,
+        })
+        .collect::<Vec<_>>();
+    assert!(stage_ordinals.windows(2).all(|pair| pair[0] <= pair[1]));
+
+    let repeated = runtime
+        .warm_up_on_the_fly_f64_with_selectors(&momenta, None, None, None, None)
+        .unwrap();
+    assert!(repeated.already_warm);
+    assert_eq!(repeated.query_count, first.query_count);
+    assert_eq!(repeated.warmed_query_count, 0);
+    let values = runtime
+        .evaluate_f64_with_selectors(&momenta, 1, None, None, None, None)
+        .unwrap();
+    assert_eq!(values.len(), 1);
+    assert!(values[0].is_finite());
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_lc_warm_up_streams_intermediate_progress_and_matches_ordinary_evaluation() {
+    let momenta = vec![0.0; 2 * 4];
+    let mut warmed = scalar_on_the_fly_native_runtime();
+    let mut events = Vec::new();
+    let mut observer = |event: &NativeOnTheFlyWarmUpEvent| {
+        events.push(event.clone());
+        Ok(true)
+    };
+    let observer: &mut NativeOnTheFlyWarmUpObserver<'_> = &mut observer;
+    let result = warmed
+        .warm_up_on_the_fly_f64_with_selectors(&momenta, None, None, None, Some(observer))
+        .unwrap();
+    assert!(result.query_count > 1);
+    assert!(events.iter().any(|event| {
+        event.kind == NativeOnTheFlyWarmUpEventKind::Update
+            && event.stage == NativeOnTheFlyWarmUpStage::QueryFamily
+            && event.completed > 0
+            && event.completed < event.total
+    }));
+
+    let mut per_stage = BTreeMap::<NativeOnTheFlyWarmUpStage, (u64, u64)>::new();
+    for event in &events {
+        assert!(event.completed <= event.total);
+        let (total, last_completed) = per_stage
+            .entry(event.stage)
+            .or_insert((event.total, event.completed));
+        assert_eq!(*total, event.total, "warm-up stage total changed");
+        assert!(
+            event.completed >= *last_completed,
+            "warm-up progress regressed"
+        );
+        *last_completed = event.completed;
+    }
+
+    let warmed_value = warmed
+        .evaluate_f64_with_selectors(&momenta, 1, None, None, None, None)
+        .unwrap();
+    let mut ordinary = scalar_on_the_fly_native_runtime();
+    let ordinary_value = ordinary
+        .evaluate_f64_with_selectors(&momenta, 1, None, None, None, None)
+        .unwrap();
+    assert_eq!(warmed_value.len(), ordinary_value.len());
+    assert!(
+        warmed_value
+            .iter()
+            .zip(&ordinary_value)
+            .all(|(warm, ordinary)| warm.to_bits() == ordinary.to_bits())
+    );
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_warm_up_core_override_preserves_nonzero_results_and_cache() {
+    for color_accuracy in ["lc", "nlc", "full"] {
+        let make_runtime = || {
+            let contraction = (color_accuracy != "lc").then(|| {
+                super::on_the_fly_load::LoadedOnTheFlyColorContractionV1 {
+                    plan: crate::recurrence::RecurrenceColorContraction::expanded_identity_for_runtime_test(),
+                    destination_by_owner_ordinal: vec![0].into_boxed_slice(),
+                    point_tile_size: 1,
+                }
+            });
+            let mut runtime = scalar_on_the_fly_native_runtime_with_color_contraction(contraction);
+            runtime.runtime.color_accuracy = color_accuracy.to_string();
+            runtime
+        };
+        let momenta = [0.0; 2 * 4];
+        let mut serial = make_runtime();
+        serial
+            .warm_up_f64(&momenta, None, None, Some(1), None)
+            .unwrap();
+        let expected = serial
+            .evaluate_f64_with_selectors(&momenta, 1, None, None, None, None)
+            .unwrap();
+        assert!(
+            expected
+                .iter()
+                .all(|value| value.is_finite() && *value > 0.0)
+        );
+
+        let mut parallel = make_runtime();
+        let effective = super::on_the_fly_load::effective_query_construction_threads(4);
+        let caller = std::thread::current().id();
+        let mut events = Vec::new();
+        let mut observer = |event: &NativeOnTheFlyWarmUpEvent| {
+            assert_eq!(std::thread::current().id(), caller);
+            assert_eq!(event.workers, effective as u64);
+            events.push(event.clone());
+            Ok(true)
+        };
+        let first = parallel
+            .warm_up_f64(&momenta, None, None, Some(4), Some(&mut observer))
+            .unwrap();
+        assert!(!first.already_warm);
+        assert_eq!(first.query_count, 4);
+        assert!(!events.is_empty());
+        let actual = parallel
+            .evaluate_f64_with_selectors(&momenta, 1, None, None, None, None)
+            .unwrap();
+        assert_eq!(actual, expected);
+        let NativeExecutionLane::OnTheFly(serial_lane) = &serial.execution_lane else {
+            panic!("test runtime changed execution lane");
+        };
+        let NativeExecutionLane::OnTheFly(parallel_lane) = &parallel.execution_lane else {
+            panic!("test runtime changed execution lane");
+        };
+        assert_eq!(
+            parallel_lane.active_family_prepared_census(),
+            serial_lane.active_family_prepared_census(),
+        );
+        if color_accuracy != "lc" {
+            assert_eq!(
+                parallel_lane.contracted_max_live_query_outcomes_for_test(),
+                effective.min(4),
+            );
+        }
+        let metadata = parallel.metadata();
+        assert_eq!(
+            metadata.on_the_fly_requested_query_construction_threads,
+            Some(1)
+        );
+        assert_eq!(
+            metadata.on_the_fly_effective_query_construction_threads,
+            Some(1)
+        );
+
+        // A different override and then the process default must both reuse
+        // the exact committed family, rather than reconstructing it.
+        for n_cores in [Some(1), None] {
+            let mut observer = |event: &NativeOnTheFlyWarmUpEvent| {
+                assert_eq!(event.workers, 1);
+                Ok(true)
+            };
+            let repeated = parallel
+                .warm_up_f64(&momenta, None, None, n_cores, Some(&mut observer))
+                .unwrap();
+            assert!(repeated.already_warm);
+            assert_eq!(repeated.warmed_query_count, 0);
+        }
+    }
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_warm_up_rejects_zero_cores_without_changing_cache() {
+    let mut runtime = scalar_on_the_fly_native_runtime();
+    let momenta = [0.0; 2 * 4];
+    let cold = runtime.on_the_fly_runtime_state_census_json().unwrap();
+    let error = runtime
+        .warm_up_f64(&momenta, None, None, Some(0), None)
+        .unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::InvalidArgument);
+    assert!(error.to_string().contains("n_cores must be positive"));
+    assert_eq!(
+        runtime.on_the_fly_runtime_state_census_json().unwrap(),
+        cold
+    );
+
+    runtime
+        .warm_up_f64(&momenta, None, None, Some(2), None)
+        .unwrap();
+    let warm = runtime.on_the_fly_runtime_state_census_json().unwrap();
+    let error = runtime
+        .warm_up_f64(&momenta, None, None, Some(0), None)
+        .unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::InvalidArgument);
+    assert_eq!(
+        runtime.on_the_fly_runtime_state_census_json().unwrap(),
+        warm
+    );
+    let repeated = runtime
+        .warm_up_f64(&momenta, None, None, None, None)
+        .unwrap();
+    assert!(repeated.already_warm);
+    assert_eq!(repeated.warmed_query_count, 0);
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_contracted_midstream_warm_up_cancellation_rolls_back_to_retained_selection() {
+    let contraction = super::on_the_fly_load::LoadedOnTheFlyColorContractionV1 {
+        plan: crate::recurrence::RecurrenceColorContraction::expanded_identity_for_runtime_test(),
+        destination_by_owner_ordinal: vec![0].into_boxed_slice(),
+        point_tile_size: 1,
+    };
+    let mut runtime = scalar_on_the_fly_native_runtime_with_color_contraction(Some(contraction));
+    runtime.runtime.color_accuracy = "full".to_string();
+    let momenta = vec![0.0; 2 * 4];
+    let retained_helicity = ["h:+0,+0".to_string()];
+    runtime
+        .warm_up_on_the_fly_f64_with_selectors(&momenta, Some(&retained_helicity), None, None, None)
+        .unwrap();
+    let expected = runtime
+        .evaluate_f64_with_selectors(&momenta, 1, Some(&retained_helicity), None, None, None)
+        .unwrap();
+
+    let saw_midstream = std::cell::Cell::new(false);
+    let mut observer = |event: &NativeOnTheFlyWarmUpEvent| {
+        if event.kind == NativeOnTheFlyWarmUpEventKind::Update
+            && event.stage == NativeOnTheFlyWarmUpStage::QueryFamily
+            && event.completed < event.total
+        {
+            saw_midstream.set(true);
+            return Ok(false);
+        }
+        Ok(true)
+    };
+    let observer: &mut NativeOnTheFlyWarmUpObserver<'_> = &mut observer;
+    let error = runtime
+        .warm_up_on_the_fly_f64_with_selectors(&momenta, None, None, Some(2), Some(observer))
+        .unwrap_err();
+    assert!(error.to_string().contains("cancelled"));
+    assert!(saw_midstream.get());
+    let retained = runtime
+        .evaluate_f64_with_selectors(&momenta, 1, Some(&retained_helicity), None, None, None)
+        .unwrap();
+    assert_eq!(retained, expected);
+    let NativeExecutionLane::OnTheFly(execution) = &runtime.execution_lane else {
+        panic!("test runtime changed execution lane");
+    };
+    assert_eq!(execution.retained_family_count(), 1);
+    assert_eq!(execution.retained_selection_count(), 1);
+    assert_eq!(execution.pending_family_count(), 0);
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_warm_up_terminal_notification_is_non_cancellable_after_commit() {
+    let momenta = vec![0.0; 2 * 4];
+    let mut runtime = scalar_on_the_fly_native_runtime();
+    let terminal_delivery_count = std::cell::Cell::new(0);
+    let mut failing_terminal = |event: &NativeOnTheFlyWarmUpEvent| {
+        if event.kind == NativeOnTheFlyWarmUpEventKind::End
+            && event.stage == NativeOnTheFlyWarmUpStage::FirstEvaluation
+        {
+            terminal_delivery_count.set(terminal_delivery_count.get() + 1);
+            return Err(RusticolError::evaluation(
+                "injected terminal notification failure",
+            ));
+        }
+        Ok(true)
+    };
+    let observer: &mut NativeOnTheFlyWarmUpObserver<'_> = &mut failing_terminal;
+    let first = runtime
+        .warm_up_on_the_fly_f64_with_selectors(&momenta, None, None, None, Some(observer))
+        .unwrap();
+    assert!(first.first_evaluation_completed);
+    assert_eq!(terminal_delivery_count.get(), 1);
+
+    let mut rejecting_terminal = |event: &NativeOnTheFlyWarmUpEvent| {
+        Ok(!(event.kind == NativeOnTheFlyWarmUpEventKind::End
+            && event.stage == NativeOnTheFlyWarmUpStage::FirstEvaluation))
+    };
+    let observer: &mut NativeOnTheFlyWarmUpObserver<'_> = &mut rejecting_terminal;
+    let repeated = runtime
+        .warm_up_on_the_fly_f64_with_selectors(&momenta, None, None, None, Some(observer))
+        .unwrap();
+    assert!(repeated.already_warm);
+    assert_eq!(repeated.warmed_query_count, 0);
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_warm_up_native_boundary_rejects_invalid_lane_and_selectors() {
+    let mut compiled = zero_native_runtime();
+    let compiled_momenta = vec![0.0; compiled.external_count() * 4];
+    let error = compiled
+        .warm_up_on_the_fly_f64_with_selectors(&compiled_momenta, None, None, None, None)
+        .unwrap_err();
+    assert_eq!(
+        error.kind(),
+        crate::RusticolErrorKind::UnsupportedRuntimeCapability
+    );
+
+    let contraction = super::on_the_fly_load::LoadedOnTheFlyColorContractionV1 {
+        plan: crate::recurrence::RecurrenceColorContraction::expanded_identity_for_runtime_test(),
+        destination_by_owner_ordinal: vec![0].into_boxed_slice(),
+        point_tile_size: 1,
+    };
+    let mut contracted = scalar_on_the_fly_native_runtime_with_color_contraction(Some(contraction));
+    contracted.runtime.color_accuracy = "full".to_string();
+    let momenta = vec![0.0; contracted.external_count() * 4];
+    let color = ["color:contracted".to_string()];
+    let error = contracted
+        .warm_up_on_the_fly_f64_with_selectors(&momenta, None, Some(&color), None, None)
+        .unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Selector);
+
+    let mut lc = scalar_on_the_fly_native_runtime();
+    let unknown_helicity = ["h:not-a-helicity".to_string()];
+    let error = lc
+        .warm_up_on_the_fly_f64_with_selectors(&momenta, Some(&unknown_helicity), None, None, None)
+        .unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Selector);
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_warm_up_cancellation_preserves_the_last_committed_selection() {
+    let mut runtime = scalar_on_the_fly_native_runtime();
+    let momenta = vec![0.0; 2 * 4];
+    let color = ["flow:singlet".to_string()];
+    let selection_a = ["h:+0,+0".to_string()];
+    let selection_b = ["h:+1,+1".to_string()];
+    runtime
+        .warm_up_on_the_fly_f64_with_selectors(
+            &momenta,
+            Some(&selection_a),
+            Some(&color),
+            None,
+            None,
+        )
+        .unwrap();
+    let expected = runtime
+        .evaluate_f64_with_selectors(&momenta, 1, Some(&selection_a), Some(&color), None, None)
+        .unwrap();
+
+    let mut observer = |event: &NativeOnTheFlyWarmUpEvent| {
+        Ok(!(event.kind == NativeOnTheFlyWarmUpEventKind::Start
+            && event.stage == NativeOnTheFlyWarmUpStage::QueryFamily))
+    };
+    let observer: &mut NativeOnTheFlyWarmUpObserver<'_> = &mut observer;
+    let error = runtime
+        .warm_up_on_the_fly_f64_with_selectors(
+            &momenta,
+            Some(&selection_b),
+            Some(&color),
+            None,
+            Some(observer),
+        )
+        .unwrap_err();
+    assert!(error.to_string().contains("cancelled"));
+    let retained = runtime
+        .evaluate_f64_with_selectors(&momenta, 1, Some(&selection_a), Some(&color), None, None)
+        .unwrap();
+    assert_eq!(retained, expected);
+    let NativeExecutionLane::OnTheFly(execution) = &runtime.execution_lane else {
+        panic!("test runtime changed execution lane");
+    };
+    assert_eq!(execution.retained_family_count(), 1);
+    assert_eq!(execution.retained_selection_count(), 1);
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_warm_up_rejects_more_than_one_point() {
+    let mut runtime = scalar_on_the_fly_native_runtime();
+    let error = runtime
+        .warm_up_on_the_fly_f64_with_selectors(&[0.0; 2 * 2 * 4], None, None, None, None)
+        .unwrap_err();
+    assert!(error.to_string().contains("exactly one point"));
+}
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[test]
+fn on_the_fly_public_paths_vectorize_with_a_last_family_only_cache() {
+    let retained = |runtime: &NativeRuntime| {
+        let NativeExecutionLane::OnTheFly(lane) = &runtime.execution_lane else {
+            panic!("test runtime changed execution lane");
+        };
+        (
+            lane.retained_family_count(),
+            lane.retained_selection_count(),
+            lane.semantic_executor_binding_count().unwrap(),
+        )
+    };
+    let census = |runtime: &NativeRuntime| -> Value {
+        serde_json::from_str(
+            runtime
+                .on_the_fly_runtime_state_census_json()
+                .unwrap()
+                .as_deref()
+                .expect("on-the-fly runtime census is absent"),
+        )
+        .unwrap()
+    };
+    let prepared_census = |runtime: &NativeRuntime| {
+        let NativeExecutionLane::OnTheFly(lane) = &runtime.execution_lane else {
+            panic!("test runtime changed execution lane");
+        };
+        lane.active_family_prepared_census()
+            .expect("active on-the-fly family has no prepared census")
+    };
+
+    let mut runtime = scalar_on_the_fly_native_runtime();
+    let point_count = 6;
+    let momenta = vec![0.0; point_count * 2 * 4];
+    let cold_census = census(&runtime);
+    assert_eq!(
+        cold_census["kind"],
+        "rusticol-on-the-fly-runtime-state-census-v1"
+    );
+    assert_eq!(cold_census["process_id"], "s_to_s");
+    assert_eq!(cold_census["family_cache_policy"], "last-family-only");
+    assert_eq!(cold_census["family_cache_limit"], 1);
+    assert_eq!(cold_census["process_preparation_count"], 0);
+    assert_eq!(cold_census["retained_family_count"], 0);
+    assert_eq!(cold_census["pending_family_count"], 0);
+    assert_eq!(cold_census["retained_selection_count"], 0);
+    assert_eq!(cold_census["semantic_executor_binding_count"], 0);
+    assert!(cold_census["active_family_union_census"].is_null());
+
+    // A: the complete compact selector domain. Only its first helicity is
+    // executable; the other three are authenticated selector-local zeros.
+    let global = runtime
+        .evaluate_f64_with_selectors(&momenta, point_count, None, None, None, None)
+        .unwrap();
+    assert_eq!(global.len(), point_count);
+    assert!(
+        global
+            .iter()
+            .all(|value| value.is_finite() && value.abs() > f64::EPSILON)
+    );
+    let (family_count, selection_count, binding_count) = retained(&runtime);
+    assert_eq!((family_count, selection_count), (1, 1));
+    assert!(binding_count > 0);
+    let global_census = census(&runtime);
+    assert_eq!(global_census["process_preparation_count"], 1);
+    assert_eq!(global_census["retained_family_count"], 1);
+    assert_eq!(global_census["pending_family_count"], 0);
+    assert_eq!(global_census["retained_selection_count"], 1);
+    assert_eq!(global_census["retained_request_count"], 4);
+    assert_eq!(global_census["retained_amplitude_destination_count"], 1);
+    assert_eq!(
+        global_census["retained_request_count"].as_u64().unwrap()
+            - global_census["retained_amplitude_destination_count"]
+                .as_u64()
+                .unwrap(),
+        3
+    );
+    let active = &global_census["active_family_union_census"];
+    assert_eq!(active["basis"], "shared-query-family-union-v1");
+    assert_eq!(active["scope"], "active-family-union");
+    let prepared = prepared_census(&runtime);
+    macro_rules! assert_mapped {
+        ($($field:ident),+ $(,)?) => {
+            $(assert_eq!(
+                active[stringify!($field)].as_u64(),
+                Some(u64::from(prepared.$field)),
+                stringify!($field),
+            );)+
+        };
+    }
+    assert_mapped!(
+        query_count,
+        union_unique_current_count,
+        union_unique_current_component_count,
+        union_source_rows,
+        union_contribution_rows,
+        union_finalization_rows,
+        union_closure_rows,
+        union_amplitude_destination_count,
+        union_source_executor_call_groups,
+        union_contribution_executor_call_groups,
+        union_finalization_executor_call_groups,
+        union_closure_executor_call_groups,
+    );
+    assert!(prepared.union_unique_current_count <= prepared.union_unique_current_component_count);
+    for role in ["source", "contribution", "finalization", "closure"] {
+        let groups = active[format!("union_{role}_executor_call_groups")]
+            .as_u64()
+            .unwrap();
+        let rows = active[format!("union_{role}_rows")].as_u64().unwrap();
+        assert!(groups <= rows, "{role}");
+    }
+
+    // B: one explicit nonzero selector. Switching A -> B -> A retains only
+    // the current public mapping and lower-lane family; evicted A is cold.
+    let helicity = vec!["h:+0,+0".to_string()];
+    let color = vec!["flow:singlet".to_string()];
+    let selected = runtime
+        .evaluate_f64_with_selectors(
+            &momenta,
+            point_count,
+            Some(&helicity),
+            Some(&color),
+            None,
+            None,
+        )
+        .unwrap();
+    assert_eq!(selected, global);
+    assert_eq!(retained(&runtime).0, 1);
+    assert_eq!(retained(&runtime).1, 1);
+    // The output retains all four physical helicities, but this selected
+    // call prepares only one query, rather than evaluating all and filtering.
+    let selected_census = census(&runtime);
+    assert_eq!(selected_census["retained_request_count"], 1);
+    assert_eq!(selected_census["retained_amplitude_destination_count"], 1);
+    assert_eq!(
+        selected_census["active_family_union_census"]["query_count"],
+        1
+    );
+
+    let global_again = runtime
+        .evaluate_f64_with_selectors(&momenta, point_count, None, None, None, None)
+        .unwrap();
+    assert_eq!(global_again, global);
+    assert_eq!(retained(&runtime).0, 1);
+    assert_eq!(retained(&runtime).1, 1);
+    let revisited_census = census(&runtime);
+    assert_eq!(revisited_census["process_preparation_count"], 1);
+    assert_eq!(revisited_census["retained_family_count"], 1);
+    assert_eq!(revisited_census["pending_family_count"], 0);
+    assert_eq!(revisited_census["retained_selection_count"], 1);
+    assert_eq!(
+        revisited_census["active_family_union_census"],
+        global_census["active_family_union_census"]
+    );
+
+    let resolved = runtime
+        .evaluate_resolved_f64(&momenta, point_count, None, None)
+        .unwrap();
+    assert_eq!(resolved.shape(), (point_count, 4, 1));
+    assert_eq!(resolved.totals(), global);
+    assert_eq!(
+        resolved.helicity_ids,
+        ["h:+0,+0", "h:+0,+1", "h:+1,+0", "h:+1,+1"]
+    );
+    assert_eq!(resolved.color_ids, color);
+    assert_eq!(retained(&runtime).0, 1);
+    assert_eq!(retained(&runtime).1, 1);
+
+    // Alternating selectors form two stable three-point partitions. The
+    // nonzero partition reaches each prepared row group once, while the
+    // selector-local-zero partition remains exactly zero.
+    let helicity_by_point = [0, 3, 0, 3, 0, 3];
+    let color_by_point = [0; 6];
+    let expected_partitioned = global
+        .iter()
+        .enumerate()
+        .map(|(index, value)| if index % 2 == 0 { *value } else { 0.0 })
+        .collect::<Vec<_>>();
+    let per_point = runtime
+        .evaluate_f64_with_selectors(
+            &momenta,
+            point_count,
+            None,
+            None,
+            Some(&helicity_by_point),
+            Some(&color_by_point),
+        )
+        .unwrap();
+    assert_eq!(per_point, expected_partitioned);
+    assert_eq!(retained(&runtime).0, 1);
+    assert_eq!(retained(&runtime).1, 1);
+    let partitioned_census = census(&runtime);
+
+    let per_point_again = runtime
+        .evaluate_f64_with_selectors(
+            &momenta,
+            point_count,
+            None,
+            None,
+            Some(&helicity_by_point),
+            Some(&color_by_point),
+        )
+        .unwrap();
+    assert_eq!(per_point_again, expected_partitioned);
+    assert_eq!(retained(&runtime).0, 1);
+    assert_eq!(retained(&runtime).1, 1);
+    assert_eq!(census(&runtime), partitioned_census);
+
+    let profiled = runtime
+        .evaluate_f64_profile_with_selectors(
+            &momenta,
+            point_count,
+            None,
+            None,
+            Some(&helicity_by_point),
+            Some(&color_by_point),
+        )
+        .unwrap();
+    assert_eq!(profiled.values, expected_partitioned);
+    assert_eq!(profiled.profile.selector_plan_kind, "stable-grouped");
+    assert_eq!(profiled.profile.selector_group_sizes, [3, 3]);
+    assert_eq!(profiled.profile.recurrence_schedule_execution_count, 2);
+    assert_eq!(
+        profiled.profile.recurrence_momentum_scalar_value_count,
+        u64::try_from(point_count * 2 * 4).unwrap()
+    );
+    assert!(profiled.profile.recurrence_source_call_count > 0);
+    assert!(profiled.profile.recurrence_closure_call_count > 0);
+    assert!(profiled.profile.recurrence_source_call_count < point_count as u64);
+    assert!(profiled.profile.recurrence_closure_call_count < point_count as u64);
+    assert!(
+        runtime
+            .benchmark_f64_wall_time_with_selectors(
+                &momenta,
+                point_count,
+                2,
+                None,
+                None,
+                Some(&helicity_by_point),
+                Some(&color_by_point),
+            )
+            .unwrap()
+            >= 0.0
+    );
+    assert_eq!(retained(&runtime).0, 1);
+    assert_eq!(retained(&runtime).1, 1);
+    assert_eq!(census(&runtime), partitioned_census);
+
+    assert!(runtime.physics_v1.get().is_err());
+
+    runtime.clear().unwrap();
+    assert_eq!(retained(&runtime), (0, 0, 0));
+    assert_eq!(census(&runtime), cold_census);
+    let NativeExecutionLane::OnTheFly(lane) = &runtime.execution_lane else {
+        panic!("test runtime changed execution lane");
+    };
+    assert_eq!(lane.point_major_scratch_state(), (0, 0));
+    assert!(runtime.physics_v1.get().is_err());
+    let rebuilt = runtime
+        .evaluate_f64_with_selectors(&momenta, point_count, None, None, None, None)
+        .unwrap();
+    assert_eq!(rebuilt, global);
+    let (family_count, selection_count, binding_count) = retained(&runtime);
+    assert_eq!((family_count, selection_count), (1, 1));
+    assert!(binding_count > 0);
+    assert_eq!(census(&runtime), global_census);
+}
+
+#[test]
+fn recurrence_selector_plan_is_bound_to_the_public_external_ordering() {
+    let runtime = zero_native_runtime();
+    let plan = NativeRecurrenceSelectorPlan {
+        artifact_root: runtime.root.clone(),
+        process_key: runtime.process_key.clone(),
+        external_permutation: runtime.external_permutation.clone(),
+        selected_helicities: None,
+        selected_colors: None,
+    };
+    plan.ensure_matches(&runtime).unwrap();
+
+    let mut reordered_runtime = zero_native_runtime();
+    reordered_runtime.external_permutation = vec![1, 0, 2];
+    let error = plan.ensure_matches(&reordered_runtime).unwrap_err();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Selector);
+    assert!(error.to_string().contains("external ordering"));
+}
+
+#[test]
+fn native_kinematics_json_accepts_one_numeric_or_decimal_string_point() {
+    let direct = serde_json::json!([
+        ["10.0000000000000001", 0, 0.0, "10"],
+        [10, 0, 0, -10],
+        [20, "0", 0, 0]
+    ]);
+    let flat = native_runtime::parse_public_kinematics_point(&direct, 3).unwrap();
+    assert_eq!(flat.len(), 12);
+    assert_eq!(flat[0], 10.0);
+    assert_eq!(flat[3], 10.0);
+    assert_eq!(flat[7], -10.0);
+    assert_eq!(flat[8], 20.0);
+
+    let singleton = serde_json::json!([direct]);
+    assert_eq!(
+        native_runtime::parse_public_kinematics_point(&singleton, 3).unwrap(),
+        flat
+    );
+}
+
+#[test]
+fn native_kinematics_json_rejects_multiple_points_and_invalid_components() {
+    let point = serde_json::json!([[1, 0, 0, 1], [1, 0, 0, -1], [2, 0, 0, 0]]);
+    for invalid in [
+        serde_json::json!([point.clone(), point]),
+        serde_json::json!([[1, 0, 0, 1], [1, 0, 0, -1]]),
+        serde_json::json!([[1, 0, 0, true], [1, 0, 0, -1], [2, 0, 0, 0]]),
+        serde_json::json!([[1, 0, 0, "1e400"], [1, 0, 0, -1], [2, 0, 0, 0]]),
+        serde_json::json!([[1, 0, 1], [1, 0, 0, -1], [2, 0, 0, 0]]),
+    ] {
+        let error = native_runtime::parse_public_kinematics_point(&invalid, 3).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::InvalidArgument);
+    }
+}
+
+#[test]
+fn native_f64_into_matches_allocating_wrapper_and_validates_output() {
+    let point = [
+        10.0, 0.0, 0.0, 10.0, 10.0, 0.0, 0.0, -10.0, 20.0, 0.0, 0.0, 0.0,
+    ];
+    let momenta = point.repeat(4);
+    let mut runtime = zero_native_runtime();
+    let allocated = runtime.evaluate_f64(&momenta, 4).unwrap();
+    let mut output = vec![f64::NAN; 4];
+    runtime.evaluate_f64_into(&momenta, 4, &mut output).unwrap();
+    assert_eq!(output, allocated);
+
+    let helicity_by_point = [0_u32, 1, 2, 0];
+    runtime
+        .evaluate_f64_into_with_selectors(
+            &momenta,
+            4,
+            None,
+            None,
+            Some(&helicity_by_point),
+            None,
+            &mut output,
+        )
+        .unwrap();
+    assert_eq!(output, vec![0.0; 4]);
+
+    let error = runtime
+        .evaluate_f64_into(&momenta, 4, &mut [0.0; 3])
+        .unwrap_err();
+    assert!(
+        error
+            .to_string()
+            .contains("output has length 3, expected 4")
+    );
+    let error = runtime
+        .evaluate_f64_into(&momenta, 4, &mut [0.0; 5])
+        .unwrap_err();
+    assert!(
+        error
+            .to_string()
+            .contains("output has length 5, expected 4")
+    );
+}
+
+#[test]
+fn native_f64_totals_bypass_point_selector_scratch() {
+    let point = [
+        10.0, 0.0, 0.0, 10.0, 10.0, 0.0, 0.0, -10.0, 20.0, 0.0, 0.0, 0.0,
+    ];
+    let momenta = point.repeat(4);
+    let mut runtime = zero_native_runtime();
+    runtime
+        .point_selector_scratch
+        .planner
+        .build(4, Some(&[0, 1, 0, 1]), None, 3, 1)
+        .expect("seed point-selector planner");
+    let retained_partitions = runtime.point_selector_scratch.planner.partitions().to_vec();
+    assert!(!retained_partitions.is_empty());
+
+    let allocated = runtime
+        .evaluate_f64(&momenta, 4)
+        .expect("evaluate owned totals without selectors");
+    let mut output = [f64::NAN; 4];
+    runtime
+        .evaluate_f64_into(&momenta, 4, &mut output)
+        .expect("evaluate borrowed totals without selectors");
+
+    assert_eq!(output.as_slice(), allocated);
+    assert_eq!(
+        runtime.point_selector_scratch.planner.partitions(),
+        retained_partitions,
+        "no-selector totals must not clear or rebuild selector planner state"
+    );
+}
+
+#[test]
+fn current_parameter_values_include_complex_and_derived_slots() {
+    let mut runtime = empty_generic_runtime();
+    runtime.model_parameters = vec![
+        GenericRuntimeModelParameterManifest {
+            name: "aS".into(),
+            kind: "external_parameter".into(),
+            parameter_index: 0,
+            default: 0.118,
+            pdg: None,
+            runtime_name: None,
+            complex_component: None,
+        },
+        GenericRuntimeModelParameterManifest {
+            name: "derived.real".into(),
+            kind: "derived_parameter_component".into(),
+            parameter_index: 1,
+            default: 1.0,
+            pdg: None,
+            runtime_name: Some("derived".into()),
+            complex_component: Some("real".into()),
+        },
+        GenericRuntimeModelParameterManifest {
+            name: "derived.imag".into(),
+            kind: "derived_parameter_component".into(),
+            parameter_index: 2,
+            default: 0.0,
+            pdg: None,
+            runtime_name: Some("derived".into()),
+            complex_component: Some("imag".into()),
+        },
+    ];
+    runtime.model_parameter_values_f64 = vec![0.101, 2.5, -0.75];
+    assert_eq!(
+        runtime.current_model_parameter_value("aS").unwrap(),
+        (0.101, 0.0)
+    );
+    assert_eq!(
+        runtime.current_model_parameter_value("derived").unwrap(),
+        (2.5, -0.75)
+    );
+    assert!(runtime.current_model_parameter_value("unknown").is_err());
+    runtime.model_parameter_values_f64[1] = 7.0;
+    assert_eq!(
+        runtime.current_model_parameter_value("derived").unwrap(),
+        (7.0, -0.75)
+    );
+    runtime.model_parameter_values_f64.truncate(1);
+    assert!(runtime.current_model_parameter_value("derived").is_err());
+}
+
+#[test]
+fn model_parameter_override_batch_is_atomic() {
+    let mut runtime = empty_generic_runtime();
+    runtime.model_parameter_runtime_slots.insert(
+        "alpha_s".to_string(),
+        RuntimeParameterSlots {
+            real: 0,
+            imaginary: None,
+        },
+    );
+    let invalid_batch = BTreeMap::from([
+        ("alpha_s".to_string(), (0.101, 0.0)),
+        ("unknown.parameter".to_string(), (1.0, 0.0)),
+    ]);
+
+    let error = runtime
+        .apply_model_parameter_overrides(&invalid_batch)
+        .unwrap_err();
+
+    assert!(error.to_string().contains("unknown.parameter"));
+    assert_eq!(runtime.model_parameter_values_f64, vec![0.118]);
+    runtime
+        .apply_model_parameter_overrides(&BTreeMap::from([("alpha_s".to_string(), (0.101, 0.0))]))
+        .unwrap();
+    assert_eq!(runtime.model_parameter_values_f64, vec![0.101]);
+}
+
+#[test]
+fn model_parameter_overrides_are_atomic_across_helicity_lanes() {
+    let mut runtime = empty_generic_runtime();
+    runtime.model_parameter_runtime_slots.insert(
+        "alpha_s".to_string(),
+        RuntimeParameterSlots {
+            real: 0,
+            imaginary: None,
+        },
+    );
+    let mut sum_runtime = empty_generic_runtime();
+    sum_runtime.model_parameter_runtime_slots.insert(
+        "alpha_s".to_string(),
+        RuntimeParameterSlots {
+            real: 0,
+            imaginary: None,
+        },
+    );
+    runtime.helicity_sum_runtime = Some(Box::new(sum_runtime));
+
+    runtime
+        .apply_model_parameter_overrides(&BTreeMap::from([("alpha_s".to_string(), (0.101, 0.0))]))
+        .unwrap();
+
+    assert_eq!(runtime.model_parameter_values_f64, vec![0.101]);
+    assert_eq!(
+        runtime
+            .helicity_sum_runtime
+            .as_ref()
+            .unwrap()
+            .model_parameter_values_f64,
+        vec![0.101]
+    );
+
+    runtime
+        .helicity_sum_runtime
+        .as_mut()
+        .unwrap()
+        .model_parameter_runtime_slots
+        .clear();
+    let error = runtime
+        .apply_model_parameter_overrides(&BTreeMap::from([("alpha_s".to_string(), (0.089, 0.0))]))
+        .unwrap_err();
+
+    assert!(error.to_string().contains("alpha_s"));
+    assert_eq!(runtime.model_parameter_values_f64, vec![0.101]);
+    assert_eq!(
+        runtime
+            .helicity_sum_runtime
+            .as_ref()
+            .unwrap()
+            .model_parameter_values_f64,
+        vec![0.101]
+    );
+}
+
+#[test]
+fn model_parameter_overrides_are_atomic_across_color_selector_lanes() {
+    fn runtime_with_alpha_s() -> ExecutionRuntime {
+        let mut runtime = empty_generic_runtime();
+        runtime.model_parameter_runtime_slots.insert(
+            "alpha_s".to_string(),
+            RuntimeParameterSlots {
+                real: 0,
+                imaginary: None,
+            },
+        );
+        runtime
+    }
+
+    let mut runtime = runtime_with_alpha_s();
+    runtime
+        .color_selector_runtimes
+        .insert(0, Box::new(runtime_with_alpha_s()));
+    runtime
+        .color_selector_runtimes
+        .insert(1, Box::new(runtime_with_alpha_s()));
+
+    runtime
+        .apply_model_parameter_overrides(&BTreeMap::from([("alpha_s".to_string(), (0.101, 0.0))]))
+        .unwrap();
+    assert_eq!(runtime.model_parameter_values_f64, vec![0.101]);
+    assert!(
+        runtime
+            .color_selector_runtimes
+            .values()
+            .all(|lane| lane.model_parameter_values_f64 == vec![0.101])
+    );
+
+    runtime
+        .color_selector_runtimes
+        .get_mut(&1)
+        .unwrap()
+        .model_parameter_runtime_slots
+        .clear();
+    let error = runtime
+        .apply_model_parameter_overrides(&BTreeMap::from([("alpha_s".to_string(), (0.089, 0.0))]))
+        .unwrap_err();
+
+    assert!(error.to_string().contains("alpha_s"));
+    assert_eq!(runtime.model_parameter_values_f64, vec![0.101]);
+    assert!(
+        runtime
+            .color_selector_runtimes
+            .values()
+            .all(|lane| lane.model_parameter_values_f64 == vec![0.101])
+    );
+}
+
+#[test]
+fn model_parameter_overrides_are_atomic_across_shared_helicity_selector_lanes() {
+    fn runtime_with_alpha_s() -> ExecutionRuntime {
+        let mut runtime = empty_generic_runtime();
+        runtime.model_parameter_runtime_slots.insert(
+            "alpha_s".to_string(),
+            RuntimeParameterSlots {
+                real: 0,
+                imaginary: None,
+            },
+        );
+        runtime
+    }
+
+    let mut runtime = runtime_with_alpha_s();
+    runtime
+        .helicity_selector_runtimes
+        .push(Box::new(runtime_with_alpha_s()));
+    runtime
+        .helicity_selector_runtime_schedule_modes
+        .push(HelicitySelectorScheduleMode::ParentClosure);
+    runtime
+        .helicity_selector_runtimes
+        .push(Box::new(runtime_with_alpha_s()));
+    runtime
+        .helicity_selector_runtime_schedule_modes
+        .push(HelicitySelectorScheduleMode::ParentClosure);
+    runtime.helicity_selector_lane_by_domain = BTreeMap::from([(0, 0), (1, 0), (2, 1)]);
+
+    runtime
+        .apply_model_parameter_overrides(&BTreeMap::from([("alpha_s".to_string(), (0.101, 0.0))]))
+        .unwrap();
+    assert_eq!(runtime.model_parameter_values_f64, vec![0.101]);
+    assert_eq!(runtime.helicity_selector_runtimes.len(), 2);
+    assert_eq!(runtime.helicity_selector_lane_by_domain.len(), 3);
+    assert!(
+        runtime
+            .helicity_selector_runtimes
+            .iter()
+            .all(|lane| lane.model_parameter_values_f64 == vec![0.101])
+    );
+
+    runtime.helicity_selector_runtimes[1]
+        .model_parameter_runtime_slots
+        .clear();
+    let error = runtime
+        .apply_model_parameter_overrides(&BTreeMap::from([("alpha_s".to_string(), (0.089, 0.0))]))
+        .unwrap_err();
+
+    assert!(error.to_string().contains("alpha_s"));
+    assert_eq!(runtime.model_parameter_values_f64, vec![0.101]);
+    assert!(
+        runtime
+            .helicity_selector_runtimes
+            .iter()
+            .all(|lane| lane.model_parameter_values_f64 == vec![0.101])
+    );
+}
+
+#[test]
+fn alias_external_order_initialization_reaches_shared_helicity_selector_lanes() {
+    let mut runtime = empty_generic_runtime();
+    runtime
+        .helicity_selector_runtimes
+        .push(Box::new(empty_generic_runtime()));
+    runtime
+        .helicity_selector_runtime_schedule_modes
+        .push(HelicitySelectorScheduleMode::ParentClosure);
+    runtime.helicity_selector_lane_by_domain = BTreeMap::from([(0, 0), (1, 0)]);
+
+    runtime.set_external_pdg_order_recursive(&[1, -1, 23]);
+
+    assert_eq!(runtime.external_pdg_order, vec![1, -1, 23]);
+    assert_eq!(runtime.helicity_selector_runtimes.len(), 1);
+    assert_eq!(
+        runtime.helicity_selector_runtimes[0].external_pdg_order,
+        vec![1, -1, 23]
+    );
+}
+
+#[test]
+fn model_parameter_override_rejects_mass_class_changes_atomically() {
+    let mut runtime = empty_generic_runtime();
+    runtime.model_parameter_values_f64 = vec![91.188];
+    runtime.model_parameter_runtime_slots.insert(
+        "MZ".to_string(),
+        RuntimeParameterSlots {
+            real: 0,
+            imaginary: None,
+        },
+    );
+    runtime
+        .particle_mass_parameter_names
+        .insert(23, "MZ".to_string());
+    runtime.particle_masses.insert(23, 91.188);
+
+    let error = runtime
+        .apply_model_parameter_overrides(&BTreeMap::from([("MZ".to_string(), (0.0, 0.0))]))
+        .unwrap_err();
+
+    assert!(error.to_string().contains("mass class"));
+    assert!(error.to_string().contains("regenerate"));
+    assert_eq!(runtime.model_parameter_values_f64, vec![91.188]);
+    assert_eq!(runtime.particle_masses.get(&23), Some(&91.188));
+
+    runtime
+        .apply_model_parameter_overrides(&BTreeMap::from([("MZ".to_string(), (100.0, 0.0))]))
+        .expect("massive-to-massive update remains valid");
+    assert_eq!(runtime.model_parameter_values_f64, vec![100.0]);
+    assert_eq!(runtime.particle_masses.get(&23), Some(&100.0));
+}
+
+#[test]
+fn compiled_color_topology_lane_requires_physics_reduction() {
+    let mut manifest: ExecutionManifest = serde_json::from_slice(include_bytes!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/../../../src/pyamplicol/assets/selftest/portable-64le/artifact/processes/",
+        "d_dbar_to_z/execution.json"
+    )))
+    .expect("parse packaged execution fixture");
+    let mut lane = manifest.clone();
+    lane.physics_reduction = None;
+    lane.helicity_sum_execution = None;
+    lane.helicity_selector_executions.clear();
+    lane.color_selector_executions.clear();
+    manifest
+        .color_selector_executions
+        .push(ColorSelectorExecutionManifest {
+            materialized_sector_id: 0,
+            execution: Box::new(lane),
+        });
+
+    let error = ExecutionRuntime::from_manifest(manifest)
+        .err()
+        .expect("color topology lane without reduction must fail");
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+    assert!(
+        error.to_string().contains("has no reduction override"),
+        "unexpected error: {error}"
+    );
+}
+
+#[test]
+fn eager_native_profile_accepts_non_overlapping_top_level_phases() {
+    let mut profile: NativeRuntimeProfile = RuntimeProfile::default().into();
+    profile.total_s = 10.0e-3;
+    profile.source_fill_s = 1.0e-3;
+    profile.momentum_input_setup_s = 0.5e-3;
+    profile.momentum_setup_s = 0.5e-3;
+    profile.stage_evaluator_call_s = 7.0e-3;
+    profile.eager_initialize_s = 0.5e-3;
+    profile.eager_kernel_call_s = 6.0e-3;
+    profile.eager_copy_out_s = 0.5e-3;
+
+    profile.validate_eager_top_level_accounting().unwrap();
+}
+
+#[test]
+fn native_profile_preserves_legacy_momentum_setup_aggregate() {
+    let profile: NativeRuntimeProfile = RuntimeProfile {
+        momentum_input_setup_s: 0.25,
+        momentum_setup_s: 0.75,
+        model_parameter_setup_s: 0.5,
+        ..RuntimeProfile::default()
+    }
+    .into();
+
+    assert_eq!(profile.momentum_input_setup_s, 0.25);
+    assert_eq!(profile.momentum_setup_s, 0.75);
+    assert_eq!(profile.model_parameter_setup_s, 0.5);
+}
+
+#[test]
+fn eager_native_profile_rejects_top_level_overlap() {
+    let mut profile: NativeRuntimeProfile = RuntimeProfile::default().into();
+    profile.total_s = 10.0e-3;
+    profile.source_fill_s = 4.0e-3;
+    profile.stage_evaluator_call_s = 7.0e-3;
+
+    let error = profile.validate_eager_top_level_accounting().unwrap_err();
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Internal);
+    assert!(error.to_string().contains("exclusive top-level phases"));
+    assert!(error.to_string().contains("exceeding wall time"));
+}
+
+#[test]
+fn recurrence_native_profile_accepts_nested_schedule_attribution() {
+    let mut profile: NativeRuntimeProfile = RuntimeProfile::default().into();
+    profile.total_s = 12.0e-3;
+    profile.source_fill_s = 0.5e-3;
+    profile.momentum_input_setup_s = 0.5e-3;
+    profile.recurrence_momentum_fill_s = 1.0e-3;
+    profile.recurrence_union_source_fill_s = 0.5e-3;
+    profile.recurrence_schedule_s = 8.0e-3;
+    profile.recurrence_source_kernel_s = 0.5e-3;
+    profile.recurrence_contribution_kernel_s = 5.0e-3;
+    profile.recurrence_finalization_s = 1.0e-3;
+    profile.recurrence_closure_s = 0.5e-3;
+    profile.recurrence_replay_output_mapping_s = 0.5e-3;
+    profile.reduction_s = 0.5e-3;
+
+    profile.validate_recurrence_top_level_accounting().unwrap();
+}
+
+#[test]
+fn recurrence_native_profile_keeps_contracted_replay_schedule_out_of_reduction() {
+    // A contracted replay owns three distinct top-level intervals: momentum
+    // fill, schedule execution, and the post-schedule copy/contraction.  The
+    // latter must not start before the scheduler call or it counts the
+    // schedule twice and can exceed the enclosing wall clock.
+    let mut profile: NativeRuntimeProfile = RuntimeProfile::default().into();
+    profile.total_s = 26.959e-6;
+    profile.recurrence_momentum_fill_s = 2.0e-6;
+    profile.recurrence_schedule_s = 20.459e-6;
+    profile.recurrence_replay_output_mapping_s = 0.5e-6;
+    profile.reduction_s = 2.0e-6;
+
+    profile.validate_recurrence_top_level_accounting().unwrap();
+
+    let mut double_counted = profile;
+    double_counted.reduction_s += double_counted.recurrence_schedule_s;
+    let error = double_counted
+        .validate_recurrence_top_level_accounting()
+        .unwrap_err();
+    assert!(error.to_string().contains("exclusive top-level phases"));
+}
+
+#[test]
+fn recurrence_native_profile_rejects_top_level_overlap() {
+    let mut profile: NativeRuntimeProfile = RuntimeProfile::default().into();
+    profile.total_s = 10.0e-3;
+    profile.recurrence_momentum_fill_s = 4.0e-3;
+    profile.recurrence_schedule_s = 7.0e-3;
+
+    let error = profile
+        .validate_recurrence_top_level_accounting()
+        .unwrap_err();
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Internal);
+    assert!(error.to_string().contains("exclusive top-level phases"));
+    assert!(error.to_string().contains("exceeding wall time"));
+}
+
+#[test]
+fn recurrence_native_profile_rejects_attribution_larger_than_schedule() {
+    let mut profile: NativeRuntimeProfile = RuntimeProfile::default().into();
+    profile.total_s = 10.0e-3;
+    profile.recurrence_schedule_s = 7.0e-3;
+    profile.recurrence_source_kernel_s = 2.0e-3;
+    profile.recurrence_contribution_kernel_s = 6.0e-3;
+
+    let error = profile
+        .validate_recurrence_top_level_accounting()
+        .unwrap_err();
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Internal);
+    assert!(error.to_string().contains("schedule sub-attribution"));
+    assert!(
+        error
+            .to_string()
+            .contains("exceeding inclusive recurrence schedule")
+    );
+}
+
+#[test]
+fn compiled_native_profile_rejects_top_level_overlap() {
+    let mut profile: NativeRuntimeProfile = RuntimeProfile::default().into();
+    profile.total_s = 10.0e-3;
+    profile.stage_input_pack_s = 4.0e-3;
+    profile.stage_evaluator_call_s = 7.0e-3;
+
+    let error = profile
+        .validate_compiled_top_level_accounting()
+        .unwrap_err();
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Internal);
+    assert!(error.to_string().contains("exclusive top-level phases"));
+    assert!(error.to_string().contains("exceeding wall time"));
+}
+
+#[test]
+fn native_profile_accumulates_compiled_accounting() {
+    let mut profile: NativeRuntimeProfile = RuntimeProfile {
+        orchestration_s: 1.0,
+        stage_leaf_input_pack_s: 2.0,
+        recurrence_schedule_s: 6.0,
+        recurrence_contribution_kernel_s: 4.0,
+        recurrence_schedule_execution_count: 2,
+        recurrence_contribution_row_count: 7,
+        stage_leaf_input_pack_by_stage_s: vec![2.0],
+        stage_leaf_input_copy_component_count: 3,
+        evaluator_backend_call_count: 4,
+        scratch_reallocation_count: 5,
+        ..RuntimeProfile::default()
+    }
+    .into();
+    let repeated: NativeRuntimeProfile = RuntimeProfile {
+        orchestration_s: 10.0,
+        stage_leaf_input_pack_s: 20.0,
+        recurrence_schedule_s: 60.0,
+        recurrence_contribution_kernel_s: 40.0,
+        recurrence_schedule_execution_count: 20,
+        recurrence_contribution_row_count: 70,
+        stage_leaf_input_pack_by_stage_s: vec![20.0, 30.0],
+        stage_leaf_input_copy_component_count: 30,
+        evaluator_backend_call_count: 40,
+        scratch_reallocation_count: 50,
+        ..RuntimeProfile::default()
+    }
+    .into();
+
+    profile.accumulate(&repeated);
+
+    assert_eq!(profile.orchestration_s, 11.0);
+    assert_eq!(profile.stage_leaf_input_pack_s, 22.0);
+    assert_eq!(profile.recurrence_schedule_s, 66.0);
+    assert_eq!(profile.recurrence_contribution_kernel_s, 44.0);
+    assert_eq!(profile.recurrence_schedule_execution_count, 22);
+    assert_eq!(profile.recurrence_contribution_row_count, 77);
+    assert_eq!(profile.stage_leaf_input_pack_by_stage_s, [22.0, 30.0]);
+    assert_eq!(profile.stage_leaf_input_copy_component_count, 33);
+    assert_eq!(profile.evaluator_backend_call_count, 44);
+    assert_eq!(profile.observed_scratch_reallocation_count, 55);
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/error.rs b/pyamplicol/rust/crates/rusticol-core/src/error.rs
new file mode 100644
index 0000000000..fe6e751d20
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/error.rs
@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::fmt;
+
+/// Stable error categories shared by the Python and C ABI boundaries.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[non_exhaustive]
+pub enum RusticolErrorKind {
+    InvalidArgument,
+    Artifact,
+    Security,
+    Integrity,
+    Compatibility,
+    Serialization,
+    Evaluation,
+    Selector,
+    ModelParameter,
+    UnsupportedPrecision,
+    UnsupportedRuntimeCapability,
+    Internal,
+}
+
+/// A Python-independent runtime error with a machine-readable category.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RusticolError {
+    kind: RusticolErrorKind,
+    message: String,
+}
+
+pub type RusticolResult<T> = Result<T, RusticolError>;
+
+impl RusticolError {
+    pub fn new(message: impl Into<String>) -> Self {
+        Self::internal(message)
+    }
+
+    pub fn with_kind(kind: RusticolErrorKind, message: impl Into<String>) -> Self {
+        Self {
+            kind,
+            message: message.into(),
+        }
+    }
+
+    pub fn invalid_argument(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::InvalidArgument, message)
+    }
+
+    pub fn artifact(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::Artifact, message)
+    }
+
+    pub fn security(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::Security, message)
+    }
+
+    pub fn integrity(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::Integrity, message)
+    }
+
+    pub fn compatibility(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::Compatibility, message)
+    }
+
+    pub fn serialization(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::Serialization, message)
+    }
+
+    pub fn evaluation(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::Evaluation, message)
+    }
+
+    pub fn selector(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::Selector, message)
+    }
+
+    pub fn model_parameter(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::ModelParameter, message)
+    }
+
+    pub fn unsupported_precision(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::UnsupportedPrecision, message)
+    }
+
+    pub fn unsupported_runtime_capability(
+        capability: impl AsRef<str>,
+        detail: impl AsRef<str>,
+    ) -> Self {
+        Self::with_kind(
+            RusticolErrorKind::UnsupportedRuntimeCapability,
+            format!(
+                "unsupported runtime capability {:?}: {}",
+                capability.as_ref(),
+                detail.as_ref()
+            ),
+        )
+    }
+
+    pub fn internal(message: impl Into<String>) -> Self {
+        Self::with_kind(RusticolErrorKind::Internal, message)
+    }
+
+    pub fn kind(&self) -> RusticolErrorKind {
+        self.kind
+    }
+
+    pub fn message(&self) -> &str {
+        &self.message
+    }
+}
+
+impl fmt::Display for RusticolError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(&self.message)
+    }
+}
+
+impl std::error::Error for RusticolError {}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator.rs
new file mode 100644
index 0000000000..ff698d575d
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator.rs
@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: 0BSD
+
+#[path = "evaluator/crossing.rs"]
+mod crossing;
+pub(crate) use crossing::*;
+
+#[path = "evaluator/backend.rs"]
+mod backend;
+pub(crate) use backend::{ensure_evaluator_capabilities_supported, evaluator_runtime_capabilities};
+
+#[cfg(feature = "f64-compiled")]
+#[path = "evaluator/compiled.rs"]
+mod compiled;
+#[cfg(feature = "f64-compiled")]
+pub(crate) use compiled::*;
+
+#[cfg(feature = "f64-compiled")]
+#[path = "evaluator/native_direct.rs"]
+pub(crate) mod native_direct;
+
+#[cfg(feature = "f64-compiled")]
+#[path = "evaluator/native_compiled_direct.rs"]
+pub(crate) mod native_compiled_direct;
+
+#[cfg(feature = "f64-symjit")]
+#[path = "evaluator/symjit.rs"]
+mod symjit;
+#[cfg(feature = "f64-symjit")]
+pub(crate) use symjit::*;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[path = "evaluator/symjit_plane.rs"]
+pub(crate) mod symjit_plane;
+
+#[cfg(feature = "f64-symjit")]
+#[path = "evaluator/symjit_direct.rs"]
+pub(crate) mod symjit_direct;
+#[cfg(all(test, feature = "f64-symjit"))]
+pub(crate) use symjit_direct::tests::count_allocations as count_test_allocations;
+
+#[cfg(feature = "f64-symjit")]
+#[path = "evaluator/symjit_compiled_direct.rs"]
+pub(crate) mod symjit_compiled_direct;
+
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+#[path = "evaluator/symjit_eager_direct.rs"]
+pub(crate) mod symjit_eager_direct;
+
+#[path = "evaluator/recurrence_source_direct.rs"]
+pub(crate) mod recurrence_source_direct;
+
+#[path = "evaluator/recurrence_closure_direct.rs"]
+pub(crate) mod recurrence_closure_direct;
+
+#[path = "evaluator/recurrence_intrinsic_direct.rs"]
+pub(crate) mod recurrence_intrinsic_direct;
+
+#[path = "evaluator/stage.rs"]
+mod stage;
+pub(crate) use stage::*;
+
+#[path = "evaluator/amplitude.rs"]
+mod amplitude;
+#[cfg(test)]
+pub(crate) use amplitude::build_compiled_symmetric_group_color_contraction_runtime;
+pub(crate) use amplitude::{
+    build_color_contraction_runtime, build_raw_sum_groups, generic_root_group_id,
+};
+
+pub(crate) fn native_f64_simd_lane_width() -> usize {
+    #[cfg(target_arch = "x86_64")]
+    {
+        if std::is_x86_feature_detected!("avx512f") {
+            return 8;
+        }
+        if std::is_x86_feature_detected!("avx2") {
+            return 4;
+        }
+        if std::is_x86_feature_detected!("sse2") {
+            return 2;
+        }
+    }
+    #[cfg(target_arch = "aarch64")]
+    {
+        if std::arch::is_aarch64_feature_detected!("neon") {
+            return 2;
+        }
+    }
+    1
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/amplitude.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/amplitude.rs
new file mode 100644
index 0000000000..7ddf688727
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/amplitude.rs
@@ -0,0 +1,4946 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::super::*;
+use super::*;
+
+/// A single-state selector needs only an equality check, not a position table
+/// covering every physical helicity or colour per tile. Larger selections
+/// retain the existing constant-time dense lookup, including nearly full axes.
+enum SelectedAxisPositions<'a> {
+    Sparse(&'a [usize]),
+    Dense(&'a [Option<usize>]),
+}
+
+impl<'a> SelectedAxisPositions<'a> {
+    fn new(indices: &'a [usize], complete_count: usize, dense: &'a mut Vec<Option<usize>>) -> Self {
+        if indices.len() <= 1 {
+            return Self::Sparse(indices);
+        }
+        dense.clear();
+        dense.resize(complete_count, None);
+        for (position, index) in indices.iter().copied().enumerate() {
+            dense[index] = Some(position);
+        }
+        Self::Dense(dense)
+    }
+
+    #[inline(always)]
+    fn position(&self, index: usize) -> Option<usize> {
+        match self {
+            Self::Sparse(indices) => indices
+                .first()
+                .filter(|&&selected| selected == index)
+                .map(|_| 0),
+            Self::Dense(positions) => positions[index],
+        }
+    }
+}
+
+trait AmplitudeSamples: Copy {
+    fn value(self, row: usize, output: usize, output_length: usize) -> Complex<f64>;
+}
+
+#[derive(Clone, Copy)]
+struct RowMajorAmplitudeSamples<'a> {
+    values: &'a [Complex<f64>],
+    point_count: usize,
+    output_length: usize,
+}
+
+impl<'a> RowMajorAmplitudeSamples<'a> {
+    fn new(
+        values: &'a [Complex<f64>],
+        point_count: usize,
+        output_length: usize,
+    ) -> RusticolResult<Self> {
+        let expected = point_count.checked_mul(output_length).ok_or_else(|| {
+            RusticolError::invalid_argument("generic amplitude output dimensions overflow")
+        })?;
+        if values.len() != expected {
+            return Err(RusticolError::invalid_argument(format!(
+                "generic amplitude output buffer has length {}, expected {expected}",
+                values.len()
+            )));
+        }
+        Ok(Self {
+            values,
+            point_count,
+            output_length,
+        })
+    }
+}
+
+impl AmplitudeSamples for RowMajorAmplitudeSamples<'_> {
+    #[inline(always)]
+    fn value(self, row: usize, output: usize, output_length: usize) -> Complex<f64> {
+        debug_assert_eq!(output_length, self.output_length);
+        debug_assert!(row < self.point_count);
+        debug_assert!(output < self.output_length);
+        self.values[row * self.output_length + output]
+    }
+}
+
+#[derive(Clone, Copy)]
+struct EagerAmplitudeMajorSamples<'a> {
+    values: &'a [crate::EagerComplex64],
+    point_count: usize,
+    output_length: usize,
+}
+
+impl<'a> EagerAmplitudeMajorSamples<'a> {
+    fn new(
+        values: &'a [crate::EagerComplex64],
+        point_count: usize,
+        output_length: usize,
+    ) -> RusticolResult<Self> {
+        let expected = point_count.checked_mul(output_length).ok_or_else(|| {
+            RusticolError::invalid_argument("eager amplitude output dimensions overflow")
+        })?;
+        if values.len() != expected {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager amplitude output buffer has length {}, expected {expected}",
+                values.len()
+            )));
+        }
+        Ok(Self {
+            values,
+            point_count,
+            output_length,
+        })
+    }
+}
+
+impl AmplitudeSamples for EagerAmplitudeMajorSamples<'_> {
+    #[inline(always)]
+    fn value(self, row: usize, output: usize, output_length: usize) -> Complex<f64> {
+        debug_assert_eq!(output_length, self.output_length);
+        debug_assert!(row < self.point_count);
+        debug_assert!(output < self.output_length);
+        // The eager scheduler copies each amplitude's complete point plane,
+        // unlike the point-major generic evaluator output.
+        let value = self.values[output * self.point_count + row];
+        c64(value.re, value.im)
+    }
+}
+
+impl AmplitudeSamples for crate::direct_arena::DirectAmplitudePlanes<'_> {
+    #[inline(always)]
+    fn value(self, row: usize, output: usize, _output_length: usize) -> Complex<f64> {
+        let (re, im) = self.value_unchecked(output, row);
+        c64(re, im)
+    }
+}
+
+#[inline(always)]
+fn sum_real_hermitian_products(left: &[Complex<f64>], right: &[Complex<f64>]) -> f64 {
+    debug_assert_eq!(left.len(), right.len());
+    // Eight independent chains cover the wide repeated-helicity blocks while
+    // the four-lane remainder preserves the smaller-block execution shape.
+    let mut sums = [0.0; 8];
+    let mut index = 0;
+    while index + 8 <= left.len() {
+        for lane in 0..8 {
+            let left_value = left[index + lane];
+            let right_value = right[index + lane];
+            sums[lane] += left_value.re * right_value.re + left_value.im * right_value.im;
+        }
+        index += 8;
+    }
+    while index + 4 <= left.len() {
+        for lane in 0..4 {
+            let left_value = left[index + lane];
+            let right_value = right[index + lane];
+            sums[lane] += left_value.re * right_value.re + left_value.im * right_value.im;
+        }
+        index += 4;
+    }
+    while index < left.len() {
+        let left_value = left[index];
+        let right_value = right[index];
+        sums[0] += left_value.re * right_value.re + left_value.im * right_value.im;
+        index += 1;
+    }
+    ((sums[0] + sums[1]) + (sums[2] + sums[3])) + ((sums[4] + sums[5]) + (sums[6] + sums[7]))
+}
+
+#[inline(always)]
+fn sum_hermitian_products(left: &[Complex<f64>], right: &[Complex<f64>]) -> Complex<f64> {
+    debug_assert_eq!(left.len(), right.len());
+    let mut sum = c64(0.0, 0.0);
+    for (left_value, right_value) in left.iter().zip(right) {
+        sum.re += left_value.re * right_value.re + left_value.im * right_value.im;
+        sum.im += left_value.im * right_value.re - left_value.re * right_value.im;
+    }
+    sum
+}
+
+fn remap_amplitude_outputs(
+    batch_size: usize,
+    evaluator_output_order: &[usize],
+    evaluator_outputs: &[Complex<f64>],
+    canonical_outputs: &mut Vec<Complex<f64>>,
+) -> RusticolResult<()> {
+    let output_length = evaluator_output_order.len();
+    let expected = batch_size
+        .checked_mul(output_length)
+        .ok_or_else(|| RusticolError::invalid_argument("amplitude output length overflows"))?;
+    if evaluator_outputs.len() != expected {
+        return Err(RusticolError::integrity(
+            "amplitude evaluator output mapping has an inconsistent buffer length",
+        ));
+    }
+    canonical_outputs.clear();
+    canonical_outputs.resize(expected, c64(0.0, 0.0));
+    for row in 0..batch_size {
+        let row_offset = row * output_length;
+        for (evaluator_output, canonical_output) in
+            evaluator_output_order.iter().copied().enumerate()
+        {
+            canonical_outputs[row_offset + canonical_output] =
+                evaluator_outputs[row_offset + evaluator_output];
+        }
+    }
+    Ok(())
+}
+
+impl AmplitudeRuntime {
+    pub(crate) fn compiled_direct_reduction_footprint(
+        &self,
+        maximum_resolved_component_count: usize,
+        routed: CompiledDirectRoutedReductionFootprint,
+    ) -> RusticolResult<CompiledDirectReductionFootprint> {
+        let maximum_group_component_count = self
+            .raw_sum_groups
+            .iter()
+            .map(|group| group.indices.len())
+            .max()
+            .unwrap_or(1);
+        let kind = if let Some(replay) = self.color_topology_replay.as_ref() {
+            CompiledDirectReducerKind::ColorTopologyReplay {
+                physical_group_count: replay.physical_groups.len(),
+            }
+        } else if let Some(workspace_scalars_per_lane) =
+            self.compiled_symmetric_group_workspace_scalars_per_lane()?
+        {
+            CompiledDirectReducerKind::SymmetricGroup {
+                workspace_scalars_per_lane,
+            }
+        } else if let Some(contraction) = self.color_contraction.as_ref() {
+            CompiledDirectReducerKind::Contracted {
+                group_count: contraction.group_count,
+            }
+        } else if self.has_coherent_groups {
+            CompiledDirectReducerKind::Coherent
+        } else {
+            CompiledDirectReducerKind::Plain
+        };
+        CompiledDirectReductionFootprint::authenticated(
+            kind,
+            maximum_group_component_count,
+            maximum_resolved_component_count,
+            routed,
+        )
+    }
+
+    pub(in crate::engine) fn color_topology_replay_reducer(
+        output_length: usize,
+        materialized_groups: &[RawSumGroup],
+        replay_manifest: &GenericColorTopologyReplayAmplitudeManifest,
+        contraction_manifest: &GenericColorContractionManifest,
+    ) -> RusticolResult<Self> {
+        let raw_sum_groups = materialized_groups
+            .iter()
+            .map(|group| RawSumGroup {
+                id: group.id,
+                indices: group.indices.clone(),
+                weight: group.weight,
+                all_sector_weight: group.all_sector_weight,
+                sector_ids: group.sector_ids.clone(),
+            })
+            .collect::<Vec<_>>();
+        let color_topology_replay = build_color_topology_replay_amplitude_runtime(
+            Some(replay_manifest),
+            Some(contraction_manifest),
+            &raw_sum_groups,
+        )?
+        .ok_or_else(|| {
+            RusticolError::integrity("color topology replay reducer lost its amplitude manifest")
+        })?;
+        Ok(Self {
+            output_length,
+            raw_sum_weights: vec![1.0; output_length],
+            raw_sum_all_sector_weights: vec![1.0; output_length],
+            raw_sum_color_sector_ids: vec![None; output_length],
+            raw_sum_groups,
+            has_coherent_groups: true,
+            color_contraction: None,
+            color_topology_replay: Some(color_topology_replay),
+            input_components: None,
+            input_spans: Vec::new(),
+            parameter_scratch_f64: Vec::new(),
+            evaluator_output_scratch_f64: Vec::new(),
+            output_scratch_f64: Vec::new(),
+            resolved_source_row_scratch_f64: Vec::new(),
+            resolved_target_row_scratch_f64: Vec::new(),
+            routed_reduction_scratch: RoutedReductionScratch::default(),
+            materialized_helicity_direct_total_plans: Vec::new(),
+            materialized_helicity_direct_total_plan_capacity: 0,
+            materialized_helicity_direct_total_next_replacement: 0,
+            materialized_helicity_direct_default_plan_by_selector_domain: Vec::new(),
+            evaluator_output_order: None,
+            evaluator: None,
+        })
+    }
+
+    pub(crate) fn load(
+        amplitude_stage: &GenericAmplitudeStageManifest,
+        stage: &GenericSerializedStageEvaluatorManifest,
+        payloads: &EvaluatorPayloadStore,
+    ) -> RusticolResult<Self> {
+        let mut runtime = Self::load_reducer_only(amplitude_stage, stage)?;
+        runtime.evaluator = Some(EvaluatorGroup::load_from_store(&stage.evaluator, payloads)?);
+        Ok(runtime)
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(crate) fn load_exact_from_plane(
+        amplitude_stage: &GenericAmplitudeStageManifest,
+        stage: &GenericSerializedStageEvaluatorManifest,
+        payloads: &EvaluatorPayloadStore,
+    ) -> RusticolResult<Self> {
+        let mut runtime = Self::load_reducer_only(amplitude_stage, stage)?;
+        runtime.evaluator = Some(EvaluatorGroup::load_exact_from_plane(stage, payloads)?);
+        Ok(runtime)
+    }
+
+    pub(crate) fn load_reducer_only(
+        amplitude_stage: &GenericAmplitudeStageManifest,
+        stage: &GenericSerializedStageEvaluatorManifest,
+    ) -> RusticolResult<Self> {
+        Self::load_reducer_only_with_compiled_color(amplitude_stage, stage, None)
+    }
+
+    pub(crate) fn load_reducer_only_with_compiled_color(
+        amplitude_stage: &GenericAmplitudeStageManifest,
+        stage: &GenericSerializedStageEvaluatorManifest,
+        compiled_color: Option<crate::recurrence::RecurrenceColorContraction>,
+    ) -> RusticolResult<Self> {
+        if stage.stage_kind != "amplitude-roots" {
+            return Err(RusticolError::invalid_argument(
+                "generic amplitude runtime expected an amplitude-roots stage",
+            ));
+        }
+        let raw_sum_weights = amplitude_stage
+            .roots
+            .iter()
+            .map(|root| root.helicity_weight)
+            .collect::<Vec<_>>();
+        let raw_sum_all_sector_weights = amplitude_stage
+            .roots
+            .iter()
+            .map(|root| root.all_sector_weight.unwrap_or(root.helicity_weight))
+            .collect::<Vec<_>>();
+        let raw_sum_color_sector_ids = amplitude_stage
+            .roots
+            .iter()
+            .map(|root| root.color_sector_id)
+            .collect::<Vec<_>>();
+        let raw_sum_group_ids = amplitude_stage
+            .roots
+            .iter()
+            .map(generic_root_group_id)
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let has_coherent_groups = raw_sum_group_ids.iter().any(Option::is_some);
+        let raw_sum_groups = if has_coherent_groups {
+            build_raw_sum_groups(
+                amplitude_stage.output_count,
+                &raw_sum_weights,
+                &raw_sum_all_sector_weights,
+                &raw_sum_group_ids,
+                &raw_sum_color_sector_ids,
+            )?
+        } else {
+            Vec::new()
+        };
+        let color_topology_replay = build_color_topology_replay_amplitude_runtime(
+            amplitude_stage.color_topology_replay.as_ref(),
+            amplitude_stage.color_contraction.as_ref(),
+            &raw_sum_groups,
+        )?;
+        let color_contraction = if color_topology_replay.is_some() {
+            if compiled_color.is_some() {
+                return Err(RusticolError::compatibility(
+                    "compiled symmetric-group FFT diagnostic does not support colour-topology replay",
+                ));
+            }
+            None
+        } else if let Some(compiled_color) = compiled_color {
+            Some(build_compiled_symmetric_group_color_contraction_runtime(
+                amplitude_stage.color_contraction.as_ref(),
+                &raw_sum_groups,
+                compiled_color,
+            )?)
+        } else {
+            build_color_contraction_runtime(
+                amplitude_stage.color_contraction.as_ref(),
+                &raw_sum_groups,
+            )?
+        };
+        let (input_components, input_spans) =
+            if stage.parameter_layout == "stage-local-value-momentum" {
+                let mut map = vec![0usize; stage.parameter_count];
+                if let Some(direct) = stage.compiled_plane_arena.as_ref() {
+                    for component in &direct.input_bindings {
+                        map[component.parameter_index] = component.global_component;
+                    }
+                } else {
+                    for component in &stage.input_components {
+                        map[component.parameter_index] = component.global_component;
+                    }
+                }
+                let spans = contiguous_input_spans(&map);
+                (Some(map), spans)
+            } else {
+                (None, Vec::new())
+            };
+        let mut evaluator_output_order = vec![usize::MAX; stage.output_length];
+        let mut canonical_outputs = vec![false; stage.output_length];
+        if let Some(direct) = stage.compiled_plane_arena.as_ref() {
+            for binding in &direct.output_bindings {
+                if binding.arena != "amplitude" {
+                    return Err(RusticolError::integrity(
+                        "compiled plane-arena amplitude binding names the wrong arena",
+                    ));
+                }
+                let evaluator_output = binding.output_index;
+                let canonical_output = binding.component;
+                if evaluator_output >= stage.output_length
+                    || canonical_output >= stage.output_length
+                    || evaluator_output_order[evaluator_output] != usize::MAX
+                    || canonical_outputs[canonical_output]
+                {
+                    return Err(RusticolError::artifact(
+                        "amplitude evaluator output mapping is not a permutation",
+                    ));
+                }
+                evaluator_output_order[evaluator_output] = canonical_output;
+                canonical_outputs[canonical_output] = true;
+            }
+        } else {
+            for slot in &stage.output_slots {
+                let output_len =
+                    slot.output_stop
+                        .checked_sub(slot.output_start)
+                        .ok_or_else(|| {
+                            RusticolError::artifact(
+                                "amplitude evaluator has an invalid output range",
+                            )
+                        })?;
+                let component_len = slot
+                    .component_stop
+                    .checked_sub(slot.component_start)
+                    .ok_or_else(|| {
+                        RusticolError::artifact(
+                            "amplitude evaluator has an invalid component range",
+                        )
+                    })?;
+                if output_len != component_len {
+                    return Err(RusticolError::artifact(
+                        "amplitude evaluator output and component ranges disagree",
+                    ));
+                }
+                for offset in 0..output_len {
+                    let evaluator_output = slot.output_start + offset;
+                    let canonical_output = slot.component_start + offset;
+                    if evaluator_output >= stage.output_length
+                        || canonical_output >= stage.output_length
+                        || evaluator_output_order[evaluator_output] != usize::MAX
+                        || canonical_outputs[canonical_output]
+                    {
+                        return Err(RusticolError::artifact(
+                            "amplitude evaluator output mapping is not a permutation",
+                        ));
+                    }
+                    evaluator_output_order[evaluator_output] = canonical_output;
+                    canonical_outputs[canonical_output] = true;
+                }
+            }
+        }
+        if evaluator_output_order.contains(&usize::MAX)
+            || canonical_outputs.iter().any(|covered| !covered)
+        {
+            return Err(RusticolError::artifact(
+                "amplitude evaluator output mapping is incomplete",
+            ));
+        }
+        let evaluator_output_order = evaluator_output_order
+            .iter()
+            .enumerate()
+            .any(|(index, output)| index != *output)
+            .then_some(evaluator_output_order);
+        Ok(Self {
+            output_length: amplitude_stage.output_count,
+            raw_sum_weights,
+            raw_sum_all_sector_weights,
+            raw_sum_color_sector_ids,
+            raw_sum_groups,
+            has_coherent_groups,
+            color_contraction,
+            color_topology_replay,
+            input_components,
+            input_spans,
+            parameter_scratch_f64: Vec::new(),
+            evaluator_output_scratch_f64: Vec::new(),
+            output_scratch_f64: Vec::new(),
+            resolved_source_row_scratch_f64: Vec::new(),
+            resolved_target_row_scratch_f64: Vec::new(),
+            routed_reduction_scratch: RoutedReductionScratch::default(),
+            materialized_helicity_direct_total_plans: Vec::new(),
+            materialized_helicity_direct_total_plan_capacity: 0,
+            materialized_helicity_direct_total_next_replacement: 0,
+            materialized_helicity_direct_default_plan_by_selector_domain: Vec::new(),
+            evaluator_output_order,
+            evaluator: None,
+        })
+    }
+
+    pub(crate) fn prepare_compiled_symmetric_group_workspace(
+        &mut self,
+        lane_capacity: usize,
+    ) -> RusticolResult<()> {
+        let Some(contraction) = self.color_contraction.as_mut() else {
+            return Ok(());
+        };
+        let Some(symmetric_group) = contraction.symmetric_group.as_mut() else {
+            return Ok(());
+        };
+        let reducer = match symmetric_group.plan.runtime_reducer() {
+            Some(crate::recurrence::RuntimeColorContractionReducer::SymmetricGroupFourier(
+                reducer,
+            )) => reducer,
+            _ => {
+                return Err(RusticolError::integrity(
+                    "compiled symmetric-group FFT payload lost its runtime reducer",
+                ));
+            }
+        };
+        symmetric_group.workspace = Some(reducer.workspace(lane_capacity)?);
+        Ok(())
+    }
+
+    fn compiled_symmetric_group_workspace_scalars_per_lane(&self) -> RusticolResult<Option<usize>> {
+        let Some(symmetric_group) = self
+            .color_contraction
+            .as_ref()
+            .and_then(|contraction| contraction.symmetric_group.as_ref())
+        else {
+            return Ok(None);
+        };
+        let reducer = match symmetric_group.plan.runtime_reducer() {
+            Some(crate::recurrence::RuntimeColorContractionReducer::SymmetricGroupFourier(
+                reducer,
+            )) => reducer,
+            _ => {
+                return Err(RusticolError::integrity(
+                    "compiled symmetric-group FFT payload lost its runtime reducer",
+                ));
+            }
+        };
+        // The largest irrep block has d^2 <= |S_m|. Count split-complex
+        // gathered, transformed, permutation, and block workspaces plus the
+        // real reduced lane. This conservative authenticated bound controls
+        // the reduction tile; the workspace itself is allocated exactly once.
+        let complex_values = reducer
+            .local_group_count()
+            .checked_add(
+                reducer
+                    .channel_count()
+                    .checked_mul(reducer.group_order())
+                    .ok_or_else(|| {
+                        RusticolError::integrity("compiled symmetric-group workspace overflows")
+                    })?,
+            )
+            .and_then(|value| {
+                reducer
+                    .group_order()
+                    .checked_mul(2)
+                    .and_then(|scratch| value.checked_add(scratch))
+            })
+            .ok_or_else(|| {
+                RusticolError::integrity("compiled symmetric-group workspace overflows")
+            })?;
+        Ok(Some(
+            complex_values
+                .checked_mul(2)
+                .and_then(|value| value.checked_add(1))
+                .ok_or_else(|| {
+                    RusticolError::integrity("compiled symmetric-group scalar footprint overflows")
+                })?,
+        ))
+    }
+
+    pub(crate) fn color_topology_replay_mappings(&self) -> Option<Vec<Vec<(usize, usize)>>> {
+        self.color_topology_replay.as_ref().map(|replay| {
+            replay
+                .mappings
+                .iter()
+                .map(|mapping| mapping.label_permutation.clone())
+                .collect()
+        })
+    }
+
+    pub(crate) fn begin_color_topology_replay(&mut self, batch_size: usize) -> RusticolResult<()> {
+        let replay = self.color_topology_replay.as_mut().ok_or_else(|| {
+            RusticolError::integrity(
+                "color topology replay was requested without its amplitude gather",
+            )
+        })?;
+        let scalar_count = batch_size
+            .checked_mul(replay.physical_groups.len())
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "color topology replay physical amplitude shape overflows usize",
+                )
+            })?;
+        replay
+            .physical_group_scratch_f64
+            .resize(scalar_count, c64(0.0, 0.0));
+        replay.physical_group_scratch_f64.fill(c64(0.0, 0.0));
+        replay.covered_groups.fill(false);
+        Ok(())
+    }
+
+    pub(crate) fn gather_color_topology_replay_mapping(
+        &mut self,
+        batch_size: usize,
+        mapping_index: usize,
+    ) -> RusticolResult<()> {
+        let output_scratch = std::mem::take(&mut self.output_scratch_f64);
+        let result = (|| {
+            let samples =
+                RowMajorAmplitudeSamples::new(&output_scratch, batch_size, self.output_length)?;
+            self.gather_color_topology_replay_samples(samples, batch_size, 0, mapping_index)
+        })();
+        self.output_scratch_f64 = output_scratch;
+        result
+    }
+
+    pub(in crate::engine) fn gather_color_topology_replay_eager_amplitudes(
+        &mut self,
+        amplitudes: &[crate::EagerComplex64],
+        batch_size: usize,
+        mapping_index: usize,
+    ) -> RusticolResult<()> {
+        let samples = EagerAmplitudeMajorSamples::new(amplitudes, batch_size, self.output_length)?;
+        self.gather_color_topology_replay_samples(samples, batch_size, 0, mapping_index)
+    }
+
+    pub(crate) fn gather_color_topology_replay_planes(
+        &mut self,
+        amplitudes: crate::direct_arena::DirectAmplitudePlanes<'_>,
+        target_row_start: usize,
+        mapping_index: usize,
+    ) -> RusticolResult<()> {
+        let plane_count = usize::try_from(amplitudes.component_count()?)
+            .map_err(|_| RusticolError::invalid_argument("amplitude plane count exceeds usize"))?;
+        if plane_count != self.output_length {
+            return Err(RusticolError::integrity(
+                "color topology replay direct amplitude width is inconsistent",
+            ));
+        }
+        self.gather_color_topology_replay_samples(
+            amplitudes,
+            amplitudes.point_count() as usize,
+            target_row_start,
+            mapping_index,
+        )
+    }
+
+    fn gather_color_topology_replay_samples<S: AmplitudeSamples>(
+        &mut self,
+        amplitudes: S,
+        batch_size: usize,
+        target_row_start: usize,
+        mapping_index: usize,
+    ) -> RusticolResult<()> {
+        let replay = self.color_topology_replay.as_mut().ok_or_else(|| {
+            RusticolError::integrity(
+                "color topology replay was requested without its amplitude gather",
+            )
+        })?;
+        let mapping = replay.mappings.get(mapping_index).ok_or_else(|| {
+            RusticolError::integrity(
+                "color topology replay requested an unknown external-label mapping",
+            )
+        })?;
+        let physical_group_count = replay.physical_groups.len();
+        let physical_row_count = replay
+            .physical_group_scratch_f64
+            .len()
+            .checked_div(physical_group_count)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "color topology replay physical amplitude scratch is invalid",
+                )
+            })?;
+        if target_row_start
+            .checked_add(batch_size)
+            .is_none_or(|stop| stop > physical_row_count)
+        {
+            return Err(RusticolError::integrity(
+                "color topology replay target row range exceeds its physical scratch",
+            ));
+        }
+        for route in &mapping.group_routes {
+            if target_row_start == 0 {
+                if std::mem::replace(&mut replay.covered_groups[route.target_group_index], true) {
+                    return Err(RusticolError::integrity(
+                        "color topology replay attempted to materialize a physical group twice",
+                    ));
+                }
+            } else if !replay.covered_groups[route.target_group_index] {
+                return Err(RusticolError::integrity(
+                    "color topology replay direct tiles arrived out of order",
+                ));
+            }
+            let source_group = &self.raw_sum_groups[route.source_group_index];
+            for row in 0..batch_size {
+                let mut value = c64(0.0, 0.0);
+                for output_index in &source_group.indices {
+                    value += amplitudes.value(row, *output_index, self.output_length);
+                }
+                replay.physical_group_scratch_f64
+                    [(target_row_start + row) * physical_group_count + route.target_group_index] =
+                    value * route.factor;
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn reduce_color_topology_replay_f64_into(
+        &mut self,
+        batch_size: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let replay = self.color_topology_replay.as_mut().ok_or_else(|| {
+            RusticolError::integrity(
+                "color topology replay was requested without its amplitude gather",
+            )
+        })?;
+        if replay.covered_groups.iter().any(|covered| !covered) {
+            return Err(RusticolError::integrity(
+                "color topology replay did not materialize every physical amplitude group",
+            ));
+        }
+        let samples = RowMajorAmplitudeSamples::new(
+            &replay.physical_group_scratch_f64,
+            batch_size,
+            replay.physical_groups.len(),
+        )?;
+        Self::reduce_amplitude_samples_f64_into_selected_slice(
+            samples,
+            batch_size,
+            output,
+            None,
+            replay.physical_groups.len(),
+            &replay.unit_weights,
+            &replay.unit_weights,
+            &replay.no_sector_ids,
+            &replay.physical_groups,
+            true,
+            &mut replay.color_contraction,
+        )
+    }
+
+    pub(crate) fn reduce_color_topology_replay_f64_resolved(
+        &mut self,
+        batch_size: usize,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let replay = self.color_topology_replay.as_mut().ok_or_else(|| {
+            RusticolError::integrity(
+                "color topology replay was requested without its amplitude gather",
+            )
+        })?;
+        if replay.covered_groups.iter().any(|covered| !covered) {
+            return Err(RusticolError::integrity(
+                "color topology replay did not materialize every physical amplitude group",
+            ));
+        }
+        if !physics.has_contracted_color_axis() {
+            return Err(RusticolError::artifact(
+                "color topology replay resolved reduction requires contracted color",
+            ));
+        }
+        let helicity_indices = physics.selected_helicity_indices(selected_helicity_ids)?;
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        if color_indices.iter().any(|index| *index != 0) {
+            return Err(RusticolError::selector(
+                "color topology replay exposes one contracted color component",
+            ));
+        }
+        let mut selected_positions = vec![None; physics.manifest.helicities.len()];
+        for (position, index) in helicity_indices.iter().copied().enumerate() {
+            selected_positions[index] = Some(position);
+        }
+        let index_by_values = physics
+            .manifest
+            .helicities
+            .iter()
+            .map(|helicity| (helicity.values.clone(), helicity.index))
+            .collect::<BTreeMap<_, _>>();
+        let mut members_by_group = Vec::with_capacity(replay.physical_groups.len());
+        for (group, representative) in replay
+            .physical_groups
+            .iter()
+            .zip(&replay.physical_group_helicities)
+        {
+            let mut members = vec![representative.clone()];
+            if group.weight > 1.0 {
+                if group.weight.to_bits() != 2.0f64.to_bits() {
+                    return Err(RusticolError::artifact(
+                        "color topology replay has an unsupported helicity reuse weight",
+                    ));
+                }
+                let flipped = representative
+                    .iter()
+                    .map(|value| -*value)
+                    .collect::<Vec<_>>();
+                if flipped != *representative {
+                    members.push(flipped);
+                }
+            }
+            let mut indexed = Vec::with_capacity(members.len());
+            let mut total_weight = 0.0;
+            for member in members {
+                let index = index_by_values.get(&member).copied().ok_or_else(|| {
+                    RusticolError::artifact(
+                        "color topology replay physical helicity is absent from public metadata",
+                    )
+                })?;
+                let weight = physics.manifest.helicities[index].coefficient;
+                total_weight += weight;
+                indexed.push((index, weight));
+            }
+            if !total_weight.is_finite() || total_weight <= 0.0 {
+                return Err(RusticolError::artifact(
+                    "color topology replay physical helicity has no positive weight",
+                ));
+            }
+            for (_, weight) in &mut indexed {
+                *weight /= total_weight;
+            }
+            members_by_group.push(indexed);
+        }
+        let contraction = replay.color_contraction.as_mut().ok_or_else(|| {
+            RusticolError::integrity(
+                "color topology replay lost its authenticated color contraction",
+            )
+        })?;
+        let entries = contraction.logical_entries().collect::<Vec<_>>();
+        for entry in &entries {
+            if members_by_group[entry.left_group_index] != members_by_group[entry.right_group_index]
+            {
+                return Err(RusticolError::artifact(
+                    "color contraction mixes distinct replayed physical helicities",
+                ));
+            }
+        }
+        let component_count = helicity_indices
+            .len()
+            .checked_mul(color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        let mut values = vec![0.0; batch_size * component_count];
+        let group_count = replay.physical_groups.len();
+        for row in 0..batch_size {
+            let group_row = row * group_count;
+            for entry in &entries {
+                let left = replay.physical_group_scratch_f64[group_row + entry.left_group_index];
+                let right = replay.physical_group_scratch_f64[group_row + entry.right_group_index];
+                let product = left * right.conj();
+                let contribution = normalization_factor
+                    * entry.symmetry_factor
+                    * (entry.weight_re * product.re - entry.weight_im * product.im);
+                for (helicity_index, weight) in &members_by_group[entry.left_group_index] {
+                    let Some(position) = selected_positions[*helicity_index] else {
+                        continue;
+                    };
+                    values[row * component_count + position * color_indices.len()] +=
+                        contribution * weight;
+                }
+            }
+        }
+        Ok(ResolvedValues {
+            values,
+            point_count: batch_size,
+            helicity_indices,
+            color_indices,
+        })
+    }
+
+    pub(crate) fn evaluate_f64_into_scratch(
+        &mut self,
+        batch_size: usize,
+        state: &[Complex<f64>],
+    ) -> RusticolResult<()> {
+        let evaluator = self.evaluator.as_mut().ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled plane-arena reducer cannot execute a dense amplitude evaluator",
+            )
+        })?;
+        let evaluator_params = if let Some(input_components) = self.input_components.as_ref() {
+            let local_parameter_count = input_components.len();
+            let global_parameter_count = state.len().checked_div(batch_size).ok_or_else(|| {
+                RusticolError::invalid_argument("generic amplitude batch size is zero")
+            })?;
+            self.parameter_scratch_f64
+                .resize(batch_size * local_parameter_count, c64(0.0, 0.0));
+            for row in 0..batch_size {
+                let row_state = row * global_parameter_count;
+                let row_params = row * local_parameter_count;
+                if self.input_spans.is_empty() {
+                    for (local_index, global_index) in input_components.iter().enumerate() {
+                        self.parameter_scratch_f64[row_params + local_index] =
+                            state[row_state + *global_index];
+                    }
+                } else {
+                    for (local_start, global_start, len) in &self.input_spans {
+                        let target_start = row_params + *local_start;
+                        let source_start = row_state + *global_start;
+                        self.parameter_scratch_f64[target_start..target_start + *len]
+                            .copy_from_slice(&state[source_start..source_start + *len]);
+                    }
+                }
+            }
+            self.parameter_scratch_f64.as_slice()
+        } else {
+            state
+        };
+        if let Some(order) = self.evaluator_output_order.as_deref() {
+            evaluator.evaluate_batch_into(
+                batch_size,
+                evaluator_params,
+                &mut self.evaluator_output_scratch_f64,
+            )?;
+            remap_amplitude_outputs(
+                batch_size,
+                order,
+                &self.evaluator_output_scratch_f64,
+                &mut self.output_scratch_f64,
+            )
+        } else {
+            evaluator.evaluate_batch_into(
+                batch_size,
+                evaluator_params,
+                &mut self.output_scratch_f64,
+            )
+        }
+    }
+
+    pub(crate) fn evaluate_f64_into_scratch_profile(
+        &mut self,
+        batch_size: usize,
+        state: &[Complex<f64>],
+    ) -> RusticolResult<AmplitudeEvaluationProfile> {
+        let evaluator_runtime = self.evaluator.as_mut().ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled plane-arena reducer cannot profile a dense amplitude evaluator",
+            )
+        })?;
+        let mut input_pack_elapsed = Duration::ZERO;
+        let input_copy_component_count;
+        let mut scratch_reallocation_count = 0;
+        let evaluator;
+        let evaluator_params;
+        if let Some(input_components) = self.input_components.as_ref() {
+            let local_parameter_count = input_components.len();
+            let global_parameter_count = state.len().checked_div(batch_size).ok_or_else(|| {
+                RusticolError::invalid_argument("generic amplitude batch size is zero")
+            })?;
+            let pack_start = Instant::now();
+            let capacity = self.parameter_scratch_f64.capacity();
+            self.parameter_scratch_f64
+                .resize(batch_size * local_parameter_count, c64(0.0, 0.0));
+            scratch_reallocation_count +=
+                u64::from(self.parameter_scratch_f64.capacity() != capacity);
+            for row in 0..batch_size {
+                let row_state = row * global_parameter_count;
+                let row_params = row * local_parameter_count;
+                if self.input_spans.is_empty() {
+                    for (local_index, global_index) in input_components.iter().enumerate() {
+                        self.parameter_scratch_f64[row_params + local_index] =
+                            state[row_state + *global_index];
+                    }
+                } else {
+                    for (local_start, global_start, len) in &self.input_spans {
+                        let target_start = row_params + *local_start;
+                        let source_start = row_state + *global_start;
+                        self.parameter_scratch_f64[target_start..target_start + *len]
+                            .copy_from_slice(&state[source_start..source_start + *len]);
+                    }
+                }
+            }
+            // Generated evaluators may use the platform floating-point ABI
+            // aggressively. Keep timing state in integer-backed Duration
+            // values until the generated call has returned.
+            input_pack_elapsed = pack_start.elapsed();
+            input_copy_component_count = batch_size * local_parameter_count;
+            evaluator_params = self.parameter_scratch_f64.as_slice();
+        } else {
+            input_copy_component_count = 0;
+            evaluator_params = state;
+        }
+        let mut output_remap_elapsed = Duration::ZERO;
+        if let Some(order) = self.evaluator_output_order.as_deref() {
+            evaluator = evaluator_runtime.evaluate_batch_into_profile(
+                batch_size,
+                evaluator_params,
+                &mut self.evaluator_output_scratch_f64,
+                false,
+            )?;
+            let remap_start = Instant::now();
+            remap_amplitude_outputs(
+                batch_size,
+                order,
+                &self.evaluator_output_scratch_f64,
+                &mut self.output_scratch_f64,
+            )?;
+            output_remap_elapsed = remap_start.elapsed();
+        } else {
+            evaluator = evaluator_runtime.evaluate_batch_into_profile(
+                batch_size,
+                evaluator_params,
+                &mut self.output_scratch_f64,
+                false,
+            )?;
+        }
+        let input_pack_s = profile_duration_seconds(input_pack_elapsed);
+        Ok(AmplitudeEvaluationProfile {
+            input_pack_s,
+            evaluator,
+            output_remap_s: profile_duration_seconds(output_remap_elapsed),
+            input_copy_component_count: input_copy_component_count as u64,
+            output_remap_component_count: if self.evaluator_output_order.is_some() {
+                (batch_size * self.output_length) as u64
+            } else {
+                0
+            },
+            scratch_reallocation_count,
+        })
+    }
+
+    pub(crate) fn evaluate_active_chunks_f64_into_scratch(
+        &mut self,
+        batch_size: usize,
+        state: &[Complex<f64>],
+        active_chunk_indices: &[usize],
+    ) -> RusticolResult<()> {
+        let evaluator = self.evaluator.as_mut().ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled plane-arena reducer cannot execute selected dense amplitude chunks",
+            )
+        })?;
+        if let Some(order) = self.evaluator_output_order.as_deref() {
+            evaluator.evaluate_selected_chunks_f64_into_output(
+                batch_size,
+                state,
+                self.input_components.as_deref(),
+                &self.input_spans,
+                &mut self.evaluator_output_scratch_f64,
+                active_chunk_indices,
+            )?;
+            remap_amplitude_outputs(
+                batch_size,
+                order,
+                &self.evaluator_output_scratch_f64,
+                &mut self.output_scratch_f64,
+            )
+        } else {
+            evaluator.evaluate_selected_chunks_f64_into_output(
+                batch_size,
+                state,
+                self.input_components.as_deref(),
+                &self.input_spans,
+                &mut self.output_scratch_f64,
+                active_chunk_indices,
+            )
+        }
+    }
+
+    pub(crate) fn evaluate_active_chunks_f64_into_scratch_profile(
+        &mut self,
+        batch_size: usize,
+        state: &[Complex<f64>],
+        active_chunk_indices: &[usize],
+    ) -> RusticolResult<AmplitudeEvaluationProfile> {
+        let evaluator_runtime = self.evaluator.as_mut().ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled plane-arena reducer cannot profile selected dense amplitude chunks",
+            )
+        })?;
+        let evaluator;
+        let mut output_remap_elapsed = Duration::ZERO;
+        if let Some(order) = self.evaluator_output_order.as_deref() {
+            evaluator = evaluator_runtime.evaluate_selected_chunks_f64_into_output_profile(
+                batch_size,
+                state,
+                self.input_components.as_deref(),
+                &self.input_spans,
+                &mut self.evaluator_output_scratch_f64,
+                active_chunk_indices,
+            )?;
+            let remap_start = Instant::now();
+            remap_amplitude_outputs(
+                batch_size,
+                order,
+                &self.evaluator_output_scratch_f64,
+                &mut self.output_scratch_f64,
+            )?;
+            output_remap_elapsed = remap_start.elapsed();
+        } else {
+            evaluator = evaluator_runtime.evaluate_selected_chunks_f64_into_output_profile(
+                batch_size,
+                state,
+                self.input_components.as_deref(),
+                &self.input_spans,
+                &mut self.output_scratch_f64,
+                active_chunk_indices,
+            )?;
+        }
+        Ok(AmplitudeEvaluationProfile {
+            input_pack_s: evaluator.leaf_input_pack_s,
+            output_remap_s: profile_duration_seconds(output_remap_elapsed),
+            // Active chunks compose the amplitude input and leaf maps, so
+            // the evaluator leaf gather is the only actual input copy.
+            input_copy_component_count: 0,
+            output_remap_component_count: if self.evaluator_output_order.is_some() {
+                (batch_size * self.output_length) as u64
+            } else {
+                0
+            },
+            scratch_reallocation_count: 0,
+            evaluator,
+        })
+    }
+
+    pub(crate) fn reduce_scratch_f64_into_selected(
+        &mut self,
+        batch_size: usize,
+        raw_sums: &mut Vec<f64>,
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<()> {
+        raw_sums.clear();
+        raw_sums.resize(batch_size, 0.0);
+        self.reduce_scratch_f64_into_selected_slice(batch_size, raw_sums, selected_color_sector_ids)
+    }
+
+    pub(crate) fn reduce_scratch_f64_into_selected_slice(
+        &mut self,
+        batch_size: usize,
+        raw_sums: &mut [f64],
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<()> {
+        let samples = RowMajorAmplitudeSamples::new(
+            &self.output_scratch_f64,
+            batch_size,
+            self.output_length,
+        )?;
+        Self::reduce_amplitude_samples_f64_into_selected_slice(
+            samples,
+            batch_size,
+            raw_sums,
+            selected_color_sector_ids,
+            self.output_length,
+            &self.raw_sum_weights,
+            &self.raw_sum_all_sector_weights,
+            &self.raw_sum_color_sector_ids,
+            &self.raw_sum_groups,
+            self.has_coherent_groups,
+            &mut self.color_contraction,
+        )
+    }
+
+    /// Reduce canonical split-complex amplitude planes without packing them
+    /// into the legacy point-major complex buffer.
+    #[allow(dead_code)]
+    pub(crate) fn reduce_planes_f64_into_selected_slice(
+        &mut self,
+        amplitudes: crate::direct_arena::DirectAmplitudePlanes<'_>,
+        raw_sums: &mut [f64],
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+    ) -> RusticolResult<()> {
+        let plane_count = usize::try_from(amplitudes.component_count()?)
+            .map_err(|_| RusticolError::invalid_argument("amplitude plane count exceeds usize"))?;
+        if plane_count != self.output_length {
+            return Err(RusticolError::invalid_argument(format!(
+                "direct amplitude plane count is {plane_count}, expected {}",
+                self.output_length
+            )));
+        }
+        let batch_size = amplitudes.point_count() as usize;
+        if raw_sums.len() != batch_size {
+            return Err(RusticolError::invalid_argument(format!(
+                "generic reduction output has length {}, expected {batch_size}",
+                raw_sums.len()
+            )));
+        }
+        raw_sums.fill(0.0);
+        let scratch = &mut self.routed_reduction_scratch;
+        if let Some(contraction) = self.color_contraction.as_mut() {
+            if selected_color_sector_ids.is_some() {
+                return Err(RusticolError::invalid_argument(
+                    "LC color-sector runtime selection is only supported for leading-colour diagonal artifacts",
+                ));
+            }
+            if self.raw_sum_groups.len() != contraction.group_count {
+                return Err(RusticolError::invalid_argument(
+                    "colour contraction group count does not match coherent groups",
+                ));
+            }
+            if let Some(symmetric_group) = contraction.symmetric_group.as_mut() {
+                return reduce_compiled_symmetric_group_planes(
+                    amplitudes,
+                    raw_sums,
+                    &self.raw_sum_groups,
+                    symmetric_group,
+                );
+            }
+            let group_scalar_count =
+                contraction
+                    .group_count
+                    .checked_mul(batch_size)
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(
+                            "plane-native color-contraction scratch shape overflows usize",
+                        )
+                    })?;
+            scratch.direct_group_re.resize(group_scalar_count, 0.0);
+            scratch.direct_group_re.fill(0.0);
+            scratch.direct_group_im.resize(group_scalar_count, 0.0);
+            scratch.direct_group_im.fill(0.0);
+            for (group_index, group) in self.raw_sum_groups.iter().enumerate() {
+                let group_start = group_index * batch_size;
+                for output_index in &group.indices {
+                    let (plane_re, plane_im) = amplitudes.plane_unchecked(*output_index);
+                    for point in 0..batch_size {
+                        scratch.direct_group_re[group_start + point] += plane_re[point];
+                        scratch.direct_group_im[group_start + point] += plane_im[point];
+                    }
+                }
+            }
+            for entry in contraction.logical_entries() {
+                let left_start = entry.left_group_index * batch_size;
+                let right_start = entry.right_group_index * batch_size;
+                for (point, raw_sum) in raw_sums.iter_mut().enumerate() {
+                    let left_re = scratch.direct_group_re[left_start + point];
+                    let left_im = scratch.direct_group_im[left_start + point];
+                    let right_re = scratch.direct_group_re[right_start + point];
+                    let right_im = scratch.direct_group_im[right_start + point];
+                    let product_re = left_re * right_re + left_im * right_im;
+                    let product_im = left_im * right_re - left_re * right_im;
+                    *raw_sum += entry.symmetry_factor
+                        * (entry.weight_re * product_re - entry.weight_im * product_im);
+                }
+            }
+            return Ok(());
+        }
+
+        scratch.direct_group_re.resize(batch_size, 0.0);
+        scratch.direct_group_im.resize(batch_size, 0.0);
+        if self.has_coherent_groups {
+            for group in &self.raw_sum_groups {
+                if !raw_sum_group_is_selected(group, selected_color_sector_ids) {
+                    continue;
+                }
+                scratch.direct_group_re.fill(0.0);
+                scratch.direct_group_im.fill(0.0);
+                for index in &group.indices {
+                    let (plane_re, plane_im) = amplitudes.plane_unchecked(*index);
+                    for point in 0..batch_size {
+                        scratch.direct_group_re[point] += plane_re[point];
+                        scratch.direct_group_im[point] += plane_im[point];
+                    }
+                }
+                let weight = if selected_color_sector_ids.is_none() {
+                    group.all_sector_weight
+                } else {
+                    group.weight
+                };
+                for (point, raw_sum) in raw_sums.iter_mut().enumerate() {
+                    let re = scratch.direct_group_re[point];
+                    let im = scratch.direct_group_im[point];
+                    *raw_sum += weight * (re * re + im * im);
+                }
+            }
+            return Ok(());
+        }
+        for index in 0..self.output_length {
+            if !raw_sum_index_is_selected(
+                self.raw_sum_color_sector_ids.get(index).copied().flatten(),
+                selected_color_sector_ids,
+            ) {
+                continue;
+            }
+            let (plane_re, plane_im) = amplitudes.plane_unchecked(index);
+            let weight = if selected_color_sector_ids.is_none() {
+                self.raw_sum_all_sector_weights[index]
+            } else {
+                self.raw_sum_weights[index]
+            };
+            for point in 0..batch_size {
+                raw_sums[point] += weight
+                    * (plane_re[point] * plane_re[point] + plane_im[point] * plane_im[point]);
+            }
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn reduce_amplitude_samples_f64_into_selected_slice<S: AmplitudeSamples>(
+        amplitudes: S,
+        batch_size: usize,
+        raw_sums: &mut [f64],
+        selected_color_sector_ids: Option<&BTreeSet<i64>>,
+        output_length: usize,
+        raw_sum_weights: &[f64],
+        raw_sum_all_sector_weights: &[f64],
+        raw_sum_color_sector_ids: &[Option<i64>],
+        raw_sum_groups: &[RawSumGroup],
+        has_coherent_groups: bool,
+        color_contraction: &mut Option<ColorContractionRuntime>,
+    ) -> RusticolResult<()> {
+        if raw_sums.len() != batch_size {
+            return Err(RusticolError::invalid_argument(format!(
+                "generic reduction output has length {}, expected {batch_size}",
+                raw_sums.len()
+            )));
+        }
+        raw_sums.fill(0.0);
+        if let Some(contraction) = color_contraction.as_mut() {
+            if selected_color_sector_ids.is_some() {
+                return Err(RusticolError::invalid_argument(
+                    "LC color-sector runtime selection is only supported for leading-colour diagonal artifacts",
+                ));
+            }
+            if raw_sum_groups.len() != contraction.group_count {
+                return Err(RusticolError::invalid_argument(
+                    "colour contraction group count does not match coherent groups",
+                ));
+            }
+            if let Some(repeated_block) = contraction.repeated_block.as_ref() {
+                contraction
+                    .group_scratch_f64
+                    .resize(contraction.group_count, c64(0.0, 0.0));
+                for (row, raw_sum) in raw_sums.iter_mut().enumerate() {
+                    if let (Some(walsh_block), Some(output_indices)) = (
+                        repeated_block.walsh_block.as_ref(),
+                        repeated_block.singleton_output_indices.as_deref(),
+                    ) {
+                        let component_count = repeated_block.component_count;
+                        let coset_count = walsh_block.cosets.len();
+                        for (coset_index, coset) in walsh_block.cosets.iter().enumerate() {
+                            for component_index in 0..component_count {
+                                let source = |local_group_index: usize| {
+                                    amplitudes.value(
+                                        row,
+                                        output_indices
+                                            [local_group_index * component_count + component_index],
+                                        output_length,
+                                    )
+                                };
+                                let x0 = source(coset[0]);
+                                let x1 = source(coset[1]);
+                                let x2 = source(coset[2]);
+                                let x3 = source(coset[3]);
+                                let sum01 = x0 + x1;
+                                let difference01 = x0 - x1;
+                                let sum23 = x2 + x3;
+                                let difference23 = x2 - x3;
+                                let targets = [
+                                    (sum01 + sum23) * 0.5,
+                                    (difference01 + difference23) * 0.5,
+                                    (sum01 - sum23) * 0.5,
+                                    (difference01 - difference23) * 0.5,
+                                ];
+                                for (character_index, value) in targets.into_iter().enumerate() {
+                                    contraction.group_scratch_f64[((character_index
+                                        * coset_count
+                                        + coset_index)
+                                        * component_count)
+                                        + component_index] = value;
+                                }
+                            }
+                        }
+                        for entry in &walsh_block.entries {
+                            let left_start = entry.left_group_index * component_count;
+                            let right_start = entry.right_group_index * component_count;
+                            let product_re = sum_real_hermitian_products(
+                                &contraction.group_scratch_f64
+                                    [left_start..left_start + component_count],
+                                &contraction.group_scratch_f64
+                                    [right_start..right_start + component_count],
+                            );
+                            *raw_sum += entry.symmetry_factor * entry.weight_re * product_re;
+                        }
+                        continue;
+                    }
+                    if let (Some(walsh_block), Some(output_indices)) = (
+                        repeated_block.c2k_walsh_block.as_ref(),
+                        repeated_block.singleton_output_indices.as_deref(),
+                    ) {
+                        let component_count = repeated_block.component_count;
+                        let coset_count = walsh_block.cosets.len();
+                        if walsh_block.subgroup_order == 8 {
+                            for (coset_index, coset) in walsh_block.cosets.iter().enumerate() {
+                                for component_index in 0..component_count {
+                                    let source = |local_group_index: usize| {
+                                        amplitudes.value(
+                                            row,
+                                            output_indices[local_group_index * component_count
+                                                + component_index],
+                                            output_length,
+                                        )
+                                    };
+                                    let x0 = source(coset[0]);
+                                    let x1 = source(coset[1]);
+                                    let x2 = source(coset[2]);
+                                    let x3 = source(coset[3]);
+                                    let x4 = source(coset[4]);
+                                    let x5 = source(coset[5]);
+                                    let x6 = source(coset[6]);
+                                    let x7 = source(coset[7]);
+                                    let sum01 = x0 + x1;
+                                    let difference01 = x0 - x1;
+                                    let sum23 = x2 + x3;
+                                    let difference23 = x2 - x3;
+                                    let sum45 = x4 + x5;
+                                    let difference45 = x4 - x5;
+                                    let sum67 = x6 + x7;
+                                    let difference67 = x6 - x7;
+                                    let lower = [
+                                        sum01 + sum23,
+                                        difference01 + difference23,
+                                        sum01 - sum23,
+                                        difference01 - difference23,
+                                    ];
+                                    let upper = [
+                                        sum45 + sum67,
+                                        difference45 + difference67,
+                                        sum45 - sum67,
+                                        difference45 - difference67,
+                                    ];
+                                    let targets = [
+                                        lower[0] + upper[0],
+                                        lower[1] + upper[1],
+                                        lower[2] + upper[2],
+                                        lower[3] + upper[3],
+                                        lower[0] - upper[0],
+                                        lower[1] - upper[1],
+                                        lower[2] - upper[2],
+                                        lower[3] - upper[3],
+                                    ];
+                                    for (character_index, value) in targets.into_iter().enumerate()
+                                    {
+                                        contraction.group_scratch_f64[((character_index
+                                            * coset_count
+                                            + coset_index)
+                                            * component_count)
+                                            + component_index] = value;
+                                    }
+                                }
+                            }
+                        } else {
+                            for (coset_index, coset) in walsh_block.cosets.iter().enumerate() {
+                                for component_index in 0..component_count {
+                                    for (subgroup_index, local_group_index) in
+                                        coset.iter().copied().enumerate()
+                                    {
+                                        let target = ((subgroup_index * coset_count + coset_index)
+                                            * component_count)
+                                            + component_index;
+                                        contraction.group_scratch_f64[target] = amplitudes.value(
+                                            row,
+                                            output_indices[local_group_index * component_count
+                                                + component_index],
+                                            output_length,
+                                        );
+                                    }
+                                    let mut stride = 1;
+                                    while stride < walsh_block.subgroup_order {
+                                        for start in
+                                            (0..walsh_block.subgroup_order).step_by(stride * 2)
+                                        {
+                                            for offset in 0..stride {
+                                                let left_character = start + offset;
+                                                let right_character = left_character + stride;
+                                                let left_target = ((left_character * coset_count
+                                                    + coset_index)
+                                                    * component_count)
+                                                    + component_index;
+                                                let right_target =
+                                                    ((right_character * coset_count + coset_index)
+                                                        * component_count)
+                                                        + component_index;
+                                                let left =
+                                                    contraction.group_scratch_f64[left_target];
+                                                let right =
+                                                    contraction.group_scratch_f64[right_target];
+                                                contraction.group_scratch_f64[left_target] =
+                                                    left + right;
+                                                contraction.group_scratch_f64[right_target] =
+                                                    left - right;
+                                            }
+                                        }
+                                        stride *= 2;
+                                    }
+                                }
+                            }
+                        }
+                        for entry in &walsh_block.entries {
+                            let left_start = entry.left_group_index * component_count;
+                            let right_start = entry.right_group_index * component_count;
+                            let product_re = sum_real_hermitian_products(
+                                &contraction.group_scratch_f64
+                                    [left_start..left_start + component_count],
+                                &contraction.group_scratch_f64
+                                    [right_start..right_start + component_count],
+                            );
+                            *raw_sum += entry.symmetry_factor * entry.weight_re * product_re;
+                        }
+                        continue;
+                    }
+                    if let Some(output_indices) = repeated_block.singleton_output_indices.as_deref()
+                    {
+                        for (target, output_index) in
+                            contraction.group_scratch_f64.iter_mut().zip(output_indices)
+                        {
+                            *target = amplitudes.value(row, *output_index, output_length);
+                        }
+                    } else {
+                        for (target, group_index) in contraction
+                            .group_scratch_f64
+                            .iter_mut()
+                            .zip(&repeated_block.component_group_indices)
+                        {
+                            let mut sum = c64(0.0, 0.0);
+                            for output_index in &raw_sum_groups[*group_index].indices {
+                                sum += amplitudes.value(row, *output_index, output_length);
+                            }
+                            *target = sum;
+                        }
+                    }
+
+                    let component_count = repeated_block.component_count;
+                    if repeated_block.all_weights_real {
+                        for entry in &repeated_block.entries {
+                            let left_start = entry.left_group_index * component_count;
+                            let right_start = entry.right_group_index * component_count;
+                            let product_re = sum_real_hermitian_products(
+                                &contraction.group_scratch_f64
+                                    [left_start..left_start + component_count],
+                                &contraction.group_scratch_f64
+                                    [right_start..right_start + component_count],
+                            );
+                            *raw_sum += entry.symmetry_factor * (entry.weight_re * product_re);
+                        }
+                    } else {
+                        for entry in &repeated_block.entries {
+                            let left_start = entry.left_group_index * component_count;
+                            let right_start = entry.right_group_index * component_count;
+                            let product = sum_hermitian_products(
+                                &contraction.group_scratch_f64
+                                    [left_start..left_start + component_count],
+                                &contraction.group_scratch_f64
+                                    [right_start..right_start + component_count],
+                            );
+                            *raw_sum += entry.symmetry_factor
+                                * (entry.weight_re * product.re - entry.weight_im * product.im);
+                        }
+                    }
+                }
+                return Ok(());
+            }
+            contraction
+                .group_scratch_f64
+                .resize(batch_size * contraction.group_count, c64(0.0, 0.0));
+            for (row, raw_sum) in raw_sums.iter_mut().enumerate() {
+                let group_row = row * contraction.group_count;
+                for (group_index, group) in raw_sum_groups.iter().enumerate() {
+                    let mut sum = c64(0.0, 0.0);
+                    for index in &group.indices {
+                        sum += amplitudes.value(row, *index, output_length);
+                    }
+                    contraction.group_scratch_f64[group_row + group_index] = sum;
+                }
+                for entry in contraction.logical_entries() {
+                    let left = contraction.group_scratch_f64[group_row + entry.left_group_index];
+                    let right = contraction.group_scratch_f64[group_row + entry.right_group_index];
+                    let product = left * right.conj();
+                    *raw_sum += entry.symmetry_factor
+                        * (entry.weight_re * product.re - entry.weight_im * product.im);
+                }
+            }
+            return Ok(());
+        }
+        for (row, raw_sum) in raw_sums.iter_mut().enumerate() {
+            if has_coherent_groups {
+                for group in raw_sum_groups {
+                    if !raw_sum_group_is_selected(group, selected_color_sector_ids) {
+                        continue;
+                    }
+                    let mut sum = c64(0.0, 0.0);
+                    for index in &group.indices {
+                        sum += amplitudes.value(row, *index, output_length);
+                    }
+                    let weight = if selected_color_sector_ids.is_none() {
+                        group.all_sector_weight
+                    } else {
+                        group.weight
+                    };
+                    *raw_sum += weight * (sum.re * sum.re + sum.im * sum.im);
+                }
+                continue;
+            }
+            for index in 0..output_length {
+                if !raw_sum_index_is_selected(
+                    raw_sum_color_sector_ids.get(index).copied().flatten(),
+                    selected_color_sector_ids,
+                ) {
+                    continue;
+                }
+                let value = amplitudes.value(row, index, output_length);
+                let weight = if selected_color_sector_ids.is_none() {
+                    raw_sum_all_sector_weights[index]
+                } else {
+                    raw_sum_weights[index]
+                };
+                *raw_sum += weight * (value.re * value.re + value.im * value.im);
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn reduce_scratch_f64_resolved(
+        &mut self,
+        batch_size: usize,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let amplitudes = RowMajorAmplitudeSamples::new(
+            &self.output_scratch_f64,
+            batch_size,
+            self.output_length,
+        )?;
+        Self::reduce_amplitude_samples_f64_resolved(
+            amplitudes,
+            batch_size,
+            physics,
+            normalization_factor,
+            selected_helicity_ids,
+            selected_color_ids,
+            self.output_length,
+            &self.raw_sum_groups,
+            self.has_coherent_groups,
+            &mut self.color_contraction,
+        )
+    }
+
+    /// Plane-native counterpart of the ordinary resolved reducer.
+    #[allow(dead_code)]
+    pub(crate) fn reduce_planes_f64_resolved(
+        &mut self,
+        amplitudes: crate::direct_arena::DirectAmplitudePlanes<'_>,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let plane_count = usize::try_from(amplitudes.component_count()?)
+            .map_err(|_| RusticolError::invalid_argument("amplitude plane count exceeds usize"))?;
+        if plane_count != self.output_length {
+            return Err(RusticolError::invalid_argument(format!(
+                "direct amplitude plane count is {plane_count}, expected {}",
+                self.output_length
+            )));
+        }
+        Self::reduce_amplitude_samples_f64_resolved(
+            amplitudes,
+            amplitudes.point_count() as usize,
+            physics,
+            normalization_factor,
+            selected_helicity_ids,
+            selected_color_ids,
+            self.output_length,
+            &self.raw_sum_groups,
+            self.has_coherent_groups,
+            &mut self.color_contraction,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn reduce_amplitude_samples_f64_resolved<S: AmplitudeSamples>(
+        amplitudes: S,
+        batch_size: usize,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output_length: usize,
+        raw_sum_groups: &[RawSumGroup],
+        has_coherent_groups: bool,
+        color_contraction: &mut Option<ColorContractionRuntime>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let helicity_count = physics.manifest.helicities.len();
+        let color_count = physics.manifest.color_components.len();
+        let helicity_indices = physics.selected_helicity_indices(selected_helicity_ids)?;
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        let mut selected_helicity_positions = vec![None; helicity_count];
+        for (position, index) in helicity_indices.iter().copied().enumerate() {
+            selected_helicity_positions[index] = Some(position);
+        }
+        let mut selected_color_positions = vec![None; color_count];
+        for (position, index) in color_indices.iter().copied().enumerate() {
+            selected_color_positions[index] = Some(position);
+        }
+        let selected_component_count = helicity_indices
+            .len()
+            .checked_mul(color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        let mut values = vec![0.0; batch_size * selected_component_count];
+
+        if let Some(contraction) = color_contraction.as_mut() {
+            if color_count != 1 || !physics.has_contracted_color_axis() {
+                return Err(RusticolError::invalid_argument(
+                    "resolved NLC/full evaluation requires one contracted color component",
+                ));
+            }
+            if raw_sum_groups.len() != contraction.group_count {
+                return Err(RusticolError::invalid_argument(
+                    "colour contraction group count does not match coherent groups",
+                ));
+            }
+            let selected_contracted_color_position = selected_color_positions[0];
+            let mut selected_helicity_weights_by_entry =
+                Vec::with_capacity(contraction.logical_entry_count()?);
+            for entry in contraction.logical_entries() {
+                let left_group = &raw_sum_groups[entry.left_group_index];
+                let right_group = &raw_sum_groups[entry.right_group_index];
+                let left_reduction = physics
+                    .numeric_reduction_by_group_id
+                    .get(&left_group.id)
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(format!(
+                            "resolved metadata is missing coherent group {}",
+                            left_group.id
+                        ))
+                    })?;
+                let right_reduction = physics
+                    .numeric_reduction_by_group_id
+                    .get(&right_group.id)
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(format!(
+                            "resolved metadata is missing coherent group {}",
+                            right_group.id
+                        ))
+                    })?;
+                if left_reduction.physical_helicity_indices
+                    != right_reduction.physical_helicity_indices
+                {
+                    return Err(RusticolError::invalid_argument(
+                        "colour contraction mixed distinct physical helicities",
+                    ));
+                }
+                let left_weights = &left_reduction.normalized_helicity_weights;
+                let right_weights = &right_reduction.normalized_helicity_weights;
+                if left_weights.len() != right_weights.len()
+                    || left_weights.iter().zip(right_weights).any(
+                        |((left_index, left_weight), (right_index, right_weight))| {
+                            left_index != right_index
+                                || left_weight.to_bits() != right_weight.to_bits()
+                        },
+                    )
+                {
+                    return Err(RusticolError::invalid_argument(
+                        "colour contraction groups have inconsistent helicity weights",
+                    ));
+                }
+                selected_helicity_weights_by_entry.push(
+                    left_weights
+                        .iter()
+                        .copied()
+                        .filter_map(|(helicity_index, weight)| {
+                            selected_helicity_positions[helicity_index]
+                                .map(|position| (position, weight))
+                        })
+                        .collect::<Vec<_>>(),
+                );
+            }
+            contraction
+                .group_scratch_f64
+                .resize(batch_size * contraction.group_count, c64(0.0, 0.0));
+            for row in 0..batch_size {
+                let group_row = row * contraction.group_count;
+                for (group_index, group) in raw_sum_groups.iter().enumerate() {
+                    let mut sum = c64(0.0, 0.0);
+                    for index in &group.indices {
+                        sum += amplitudes.value(row, *index, output_length);
+                    }
+                    contraction.group_scratch_f64[group_row + group_index] = sum;
+                }
+                for (entry, left_weights) in contraction
+                    .logical_entries()
+                    .zip(&selected_helicity_weights_by_entry)
+                {
+                    let left = contraction.group_scratch_f64[group_row + entry.left_group_index];
+                    let right = contraction.group_scratch_f64[group_row + entry.right_group_index];
+                    let product = left * right.conj();
+                    let contribution = normalization_factor
+                        * entry.symmetry_factor
+                        * (entry.weight_re * product.re - entry.weight_im * product.im);
+                    let Some(color_position) = selected_contracted_color_position else {
+                        continue;
+                    };
+                    for (helicity_position, weight) in left_weights {
+                        values[row * selected_component_count
+                            + *helicity_position * color_indices.len()
+                            + color_position] += contribution * weight;
+                    }
+                }
+            }
+        } else {
+            if !has_coherent_groups {
+                return Err(RusticolError::invalid_argument(
+                    "resolved evaluation requires coherent amplitude-group metadata",
+                ));
+            }
+            let mut selected_member_weights_by_group = Vec::with_capacity(raw_sum_groups.len());
+            for group in raw_sum_groups {
+                let reduction = physics
+                    .numeric_reduction_by_group_id
+                    .get(&group.id)
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(format!(
+                            "resolved metadata is missing coherent group {}",
+                            group.id
+                        ))
+                    })?;
+                selected_member_weights_by_group.push(
+                    reduction
+                        .normalized_member_weights
+                        .iter()
+                        .copied()
+                        .filter_map(|(helicity_index, color_index, weight)| {
+                            Some((
+                                selected_helicity_positions[helicity_index]?,
+                                selected_color_positions[color_index]?,
+                                weight,
+                            ))
+                        })
+                        .collect::<Vec<_>>(),
+                );
+            }
+            for row in 0..batch_size {
+                for (group, member_weights) in
+                    raw_sum_groups.iter().zip(&selected_member_weights_by_group)
+                {
+                    let mut sum = c64(0.0, 0.0);
+                    for index in &group.indices {
+                        sum += amplitudes.value(row, *index, output_length);
+                    }
+                    let contribution = normalization_factor
+                        * group.all_sector_weight
+                        * (sum.re * sum.re + sum.im * sum.im);
+                    for (helicity_position, color_position, weight) in member_weights {
+                        values[row * selected_component_count
+                            + *helicity_position * color_indices.len()
+                            + *color_position] += contribution * weight;
+                    }
+                }
+            }
+        }
+        Ok(ResolvedValues {
+            values,
+            point_count: batch_size,
+            helicity_indices,
+            color_indices,
+        })
+    }
+
+    /// Reduce one topology-replay source mapping directly into public totals.
+    ///
+    /// The source and target component buffers are row-sized persistent
+    /// scratch.  Replaying the routes before summing the target row preserves
+    /// the resolved contract's component accumulation and H-major/C-minor
+    /// summation order without materializing either batch-wide tensor.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn reduce_scratch_f64_routed_totals_into(
+        &mut self,
+        batch_size: usize,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        replay_entry: &LcResolvedReplayEntry,
+        source_component_count: usize,
+        target_component_count: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let amplitudes = RowMajorAmplitudeSamples::new(
+            &self.output_scratch_f64,
+            batch_size,
+            self.output_length,
+        )?;
+        Self::reduce_amplitude_samples_f64_routed_totals_into(
+            amplitudes,
+            batch_size,
+            physics,
+            normalization_factor,
+            selected_helicity_ids,
+            selected_color_ids,
+            replay_entry,
+            source_component_count,
+            target_component_count,
+            output,
+            self.output_length,
+            &self.raw_sum_groups,
+            self.has_coherent_groups,
+            self.color_contraction.is_some(),
+            &mut self.resolved_source_row_scratch_f64,
+            &mut self.resolved_target_row_scratch_f64,
+            &mut self.routed_reduction_scratch,
+        )
+    }
+
+    /// Plane-native counterpart of the LC topology-replay totals reducer.
+    #[allow(clippy::too_many_arguments)]
+    #[allow(dead_code)]
+    pub(crate) fn reduce_planes_f64_routed_totals_into(
+        &mut self,
+        amplitudes: crate::direct_arena::DirectAmplitudePlanes<'_>,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        replay_entry: &LcResolvedReplayEntry,
+        source_component_count: usize,
+        target_component_count: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let plane_count = usize::try_from(amplitudes.component_count()?)
+            .map_err(|_| RusticolError::invalid_argument("amplitude plane count exceeds usize"))?;
+        if plane_count != self.output_length {
+            return Err(RusticolError::invalid_argument(format!(
+                "direct amplitude plane count is {plane_count}, expected {}",
+                self.output_length
+            )));
+        }
+        let batch_size = amplitudes.point_count() as usize;
+        if output.len() != batch_size {
+            return Err(RusticolError::invalid_argument(format!(
+                "routed reduction output has length {}, expected {batch_size}",
+                output.len()
+            )));
+        }
+        if self.color_contraction.is_some() {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay does not support contracted color reduction",
+            ));
+        }
+        if !self.has_coherent_groups {
+            return Err(RusticolError::invalid_argument(
+                "resolved evaluation requires coherent amplitude-group metadata",
+            ));
+        }
+
+        let scratch = &mut self.routed_reduction_scratch;
+        let helicity_count = physics.manifest.helicities.len();
+        let color_count = physics.manifest.color_components.len();
+        physics
+            .selected_helicity_indices_into(selected_helicity_ids, &mut scratch.helicity_indices)?;
+        physics.selected_color_indices_into(selected_color_ids, &mut scratch.color_indices)?;
+        let selected_color_count = scratch.color_indices.len();
+        let expected_source_component_count = scratch
+            .helicity_indices
+            .len()
+            .checked_mul(selected_color_count)
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        if source_component_count != expected_source_component_count {
+            return Err(RusticolError::integrity(format!(
+                "topology replay source has {source_component_count} components, expected {expected_source_component_count}"
+            )));
+        }
+        for route in &replay_entry.routes {
+            if route.source_index >= source_component_count
+                || route.target_index >= target_component_count
+            {
+                return Err(RusticolError::integrity(
+                    "LC topology replay selected route is out of bounds",
+                ));
+            }
+        }
+
+        let helicity_positions = SelectedAxisPositions::new(
+            &scratch.helicity_indices,
+            helicity_count,
+            &mut scratch.helicity_positions,
+        );
+        let color_positions = SelectedAxisPositions::new(
+            &scratch.color_indices,
+            color_count,
+            &mut scratch.color_positions,
+        );
+        scratch.selected_member_weights.clear();
+        scratch.selected_member_weight_ranges.clear();
+        for group in &self.raw_sum_groups {
+            let reduction = physics
+                .numeric_reduction_by_group_id
+                .get(&group.id)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(format!(
+                        "resolved metadata is missing coherent group {}",
+                        group.id
+                    ))
+                })?;
+            let start = scratch.selected_member_weights.len();
+            for (helicity_index, color_index, weight) in
+                reduction.normalized_member_weights.iter().copied()
+            {
+                let (Some(helicity_position), Some(color_position)) = (
+                    helicity_positions.position(helicity_index),
+                    color_positions.position(color_index),
+                ) else {
+                    continue;
+                };
+                scratch
+                    .selected_member_weights
+                    .push((helicity_position, color_position, weight));
+            }
+            scratch
+                .selected_member_weight_ranges
+                .push(start..scratch.selected_member_weights.len());
+        }
+
+        let source_scalar_count =
+            source_component_count
+                .checked_mul(batch_size)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument("routed source scratch shape overflows usize")
+                })?;
+        let target_scalar_count =
+            target_component_count
+                .checked_mul(batch_size)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument("routed target scratch shape overflows usize")
+                })?;
+        scratch.direct_group_re.resize(batch_size, 0.0);
+        scratch.direct_group_im.resize(batch_size, 0.0);
+        scratch.direct_totals.resize(batch_size, 0.0);
+        scratch
+            .direct_source_components
+            .resize(source_scalar_count, 0.0);
+        scratch.direct_source_components.fill(0.0);
+        scratch
+            .direct_target_components
+            .resize(target_scalar_count, 0.0);
+        scratch.direct_target_components.fill(0.0);
+
+        for (group, member_weight_range) in self
+            .raw_sum_groups
+            .iter()
+            .zip(&scratch.selected_member_weight_ranges)
+        {
+            if member_weight_range.is_empty() {
+                continue;
+            }
+            scratch.direct_group_re.fill(0.0);
+            scratch.direct_group_im.fill(0.0);
+            for index in &group.indices {
+                let (plane_re, plane_im) = amplitudes.plane_unchecked(*index);
+                for point in 0..batch_size {
+                    scratch.direct_group_re[point] += plane_re[point];
+                    scratch.direct_group_im[point] += plane_im[point];
+                }
+            }
+            for point in 0..batch_size {
+                let re = scratch.direct_group_re[point];
+                let im = scratch.direct_group_im[point];
+                scratch.direct_totals[point] =
+                    normalization_factor * group.all_sector_weight * (re * re + im * im);
+            }
+            for (helicity_position, color_position, weight) in
+                &scratch.selected_member_weights[member_weight_range.clone()]
+            {
+                let component = *helicity_position * selected_color_count + *color_position;
+                let source_start = component * batch_size;
+                for point in 0..batch_size {
+                    scratch.direct_source_components[source_start + point] +=
+                        scratch.direct_totals[point] * *weight;
+                }
+            }
+        }
+
+        for route in &replay_entry.routes {
+            let source_start = route.source_index * batch_size;
+            let target_start = route.target_index * batch_size;
+            for point in 0..batch_size {
+                scratch.direct_target_components[target_start + point] +=
+                    route.weight * scratch.direct_source_components[source_start + point];
+            }
+        }
+        output.fill(0.0);
+        for target_index in 0..target_component_count {
+            let target_start = target_index * batch_size;
+            for (point, target) in output.iter_mut().enumerate() {
+                *target += scratch.direct_target_components[target_start + point];
+            }
+        }
+        Ok(())
+    }
+
+    /// Add one plane-native topology-replay mapping to persistent point-major
+    /// target components.
+    ///
+    /// Mappings are accumulated in caller order, while the final public fold
+    /// remains H-major/C-minor. This is the allocation-free multi-mapping
+    /// counterpart of `reduce_planes_f64_routed_totals_into`.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn reduce_planes_f64_routed_components_add_into(
+        &mut self,
+        amplitudes: crate::direct_arena::DirectAmplitudePlanes<'_>,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        replay_entry: &LcResolvedReplayEntry,
+        source_component_count: usize,
+        target_component_count: usize,
+        target_point_count: usize,
+        target_point_start: usize,
+        target_components: &mut [f64],
+    ) -> RusticolResult<()> {
+        let plane_count = usize::try_from(amplitudes.component_count()?)
+            .map_err(|_| RusticolError::invalid_argument("amplitude plane count exceeds usize"))?;
+        if plane_count != self.output_length {
+            return Err(RusticolError::invalid_argument(format!(
+                "direct amplitude plane count is {plane_count}, expected {}",
+                self.output_length
+            )));
+        }
+        let batch_size = amplitudes.point_count() as usize;
+        let expected_target_len = target_point_count
+            .checked_mul(target_component_count)
+            .ok_or_else(|| RusticolError::invalid_argument("routed target shape overflows"))?;
+        if target_components.len() != expected_target_len
+            || target_point_start
+                .checked_add(batch_size)
+                .is_none_or(|stop| stop > target_point_count)
+        {
+            return Err(RusticolError::invalid_argument(
+                "routed target components have an inconsistent shape",
+            ));
+        }
+        if self.color_contraction.is_some() {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay does not support contracted color reduction",
+            ));
+        }
+        if !self.has_coherent_groups {
+            return Err(RusticolError::invalid_argument(
+                "resolved evaluation requires coherent amplitude-group metadata",
+            ));
+        }
+
+        let scratch = &mut self.routed_reduction_scratch;
+        let helicity_count = physics.manifest.helicities.len();
+        let color_count = physics.manifest.color_components.len();
+        physics
+            .selected_helicity_indices_into(selected_helicity_ids, &mut scratch.helicity_indices)?;
+        physics.selected_color_indices_into(selected_color_ids, &mut scratch.color_indices)?;
+        let selected_color_count = scratch.color_indices.len();
+        let expected_source_component_count = scratch
+            .helicity_indices
+            .len()
+            .checked_mul(selected_color_count)
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        if source_component_count != expected_source_component_count {
+            return Err(RusticolError::integrity(format!(
+                "topology replay source has {source_component_count} components, expected {expected_source_component_count}"
+            )));
+        }
+        for route in &replay_entry.routes {
+            if route.source_index >= source_component_count
+                || route.target_index >= target_component_count
+            {
+                return Err(RusticolError::integrity(
+                    "LC topology replay selected route is out of bounds",
+                ));
+            }
+        }
+
+        let helicity_positions = SelectedAxisPositions::new(
+            &scratch.helicity_indices,
+            helicity_count,
+            &mut scratch.helicity_positions,
+        );
+        let color_positions = SelectedAxisPositions::new(
+            &scratch.color_indices,
+            color_count,
+            &mut scratch.color_positions,
+        );
+        scratch.selected_member_weights.clear();
+        scratch.selected_member_weight_ranges.clear();
+        for group in &self.raw_sum_groups {
+            let reduction = physics
+                .numeric_reduction_by_group_id
+                .get(&group.id)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(format!(
+                        "resolved metadata is missing coherent group {}",
+                        group.id
+                    ))
+                })?;
+            let start = scratch.selected_member_weights.len();
+            for (helicity_index, color_index, weight) in
+                reduction.normalized_member_weights.iter().copied()
+            {
+                let (Some(helicity_position), Some(color_position)) = (
+                    helicity_positions.position(helicity_index),
+                    color_positions.position(color_index),
+                ) else {
+                    continue;
+                };
+                scratch
+                    .selected_member_weights
+                    .push((helicity_position, color_position, weight));
+            }
+            scratch
+                .selected_member_weight_ranges
+                .push(start..scratch.selected_member_weights.len());
+        }
+
+        let source_scalar_count =
+            source_component_count
+                .checked_mul(batch_size)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument("routed source scratch shape overflows usize")
+                })?;
+        scratch.direct_group_re.resize(batch_size, 0.0);
+        scratch.direct_group_im.resize(batch_size, 0.0);
+        scratch.direct_totals.resize(batch_size, 0.0);
+        scratch
+            .direct_source_components
+            .resize(source_scalar_count, 0.0);
+        scratch.direct_source_components.fill(0.0);
+
+        for (group, member_weight_range) in self
+            .raw_sum_groups
+            .iter()
+            .zip(&scratch.selected_member_weight_ranges)
+        {
+            if member_weight_range.is_empty() {
+                continue;
+            }
+            scratch.direct_group_re.fill(0.0);
+            scratch.direct_group_im.fill(0.0);
+            for index in &group.indices {
+                let (plane_re, plane_im) = amplitudes.plane_unchecked(*index);
+                for point in 0..batch_size {
+                    scratch.direct_group_re[point] += plane_re[point];
+                    scratch.direct_group_im[point] += plane_im[point];
+                }
+            }
+            for point in 0..batch_size {
+                let re = scratch.direct_group_re[point];
+                let im = scratch.direct_group_im[point];
+                scratch.direct_totals[point] =
+                    normalization_factor * group.all_sector_weight * (re * re + im * im);
+            }
+            for (helicity_position, color_position, weight) in
+                &scratch.selected_member_weights[member_weight_range.clone()]
+            {
+                let component = *helicity_position * selected_color_count + *color_position;
+                let source_start = component * batch_size;
+                for point in 0..batch_size {
+                    scratch.direct_source_components[source_start + point] +=
+                        scratch.direct_totals[point] * *weight;
+                }
+            }
+        }
+
+        for route in &replay_entry.routes {
+            let source_start = route.source_index * batch_size;
+            for point in 0..batch_size {
+                let target =
+                    (target_point_start + point) * target_component_count + route.target_index;
+                target_components[target] +=
+                    route.weight * scratch.direct_source_components[source_start + point];
+            }
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn reduce_amplitude_samples_f64_routed_totals_into<S: AmplitudeSamples>(
+        amplitudes: S,
+        batch_size: usize,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+        replay_entry: &LcResolvedReplayEntry,
+        source_component_count: usize,
+        target_component_count: usize,
+        output: &mut [f64],
+        output_length: usize,
+        raw_sum_groups: &[RawSumGroup],
+        has_coherent_groups: bool,
+        has_color_contraction: bool,
+        resolved_source_row_scratch_f64: &mut Vec<f64>,
+        resolved_target_row_scratch_f64: &mut Vec<f64>,
+        scratch: &mut RoutedReductionScratch,
+    ) -> RusticolResult<()> {
+        if output.len() != batch_size {
+            return Err(RusticolError::invalid_argument(format!(
+                "routed reduction output has length {}, expected {batch_size}",
+                output.len()
+            )));
+        }
+        if has_color_contraction {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay does not support contracted color reduction",
+            ));
+        }
+        if !has_coherent_groups {
+            return Err(RusticolError::invalid_argument(
+                "resolved evaluation requires coherent amplitude-group metadata",
+            ));
+        }
+
+        let helicity_count = physics.manifest.helicities.len();
+        let color_count = physics.manifest.color_components.len();
+        physics
+            .selected_helicity_indices_into(selected_helicity_ids, &mut scratch.helicity_indices)?;
+        physics.selected_color_indices_into(selected_color_ids, &mut scratch.color_indices)?;
+        let expected_source_component_count = scratch
+            .helicity_indices
+            .len()
+            .checked_mul(scratch.color_indices.len())
+            .ok_or_else(|| RusticolError::invalid_argument("resolved shape overflows usize"))?;
+        if source_component_count != expected_source_component_count {
+            return Err(RusticolError::integrity(format!(
+                "topology replay source has {source_component_count} components, expected {expected_source_component_count}"
+            )));
+        }
+
+        let helicity_positions = SelectedAxisPositions::new(
+            &scratch.helicity_indices,
+            helicity_count,
+            &mut scratch.helicity_positions,
+        );
+        let color_positions = SelectedAxisPositions::new(
+            &scratch.color_indices,
+            color_count,
+            &mut scratch.color_positions,
+        );
+        scratch.selected_member_weights.clear();
+        scratch.selected_member_weight_ranges.clear();
+        for group in raw_sum_groups {
+            let reduction = physics
+                .numeric_reduction_by_group_id
+                .get(&group.id)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(format!(
+                        "resolved metadata is missing coherent group {}",
+                        group.id
+                    ))
+                })?;
+            let start = scratch.selected_member_weights.len();
+            for (helicity_index, color_index, weight) in
+                reduction.normalized_member_weights.iter().copied()
+            {
+                let (Some(helicity_position), Some(color_position)) = (
+                    helicity_positions.position(helicity_index),
+                    color_positions.position(color_index),
+                ) else {
+                    continue;
+                };
+                scratch
+                    .selected_member_weights
+                    .push((helicity_position, color_position, weight));
+            }
+            scratch
+                .selected_member_weight_ranges
+                .push(start..scratch.selected_member_weights.len());
+        }
+
+        resolved_source_row_scratch_f64.resize(source_component_count, 0.0);
+        resolved_target_row_scratch_f64.resize(target_component_count, 0.0);
+        for (row, target_total) in output.iter_mut().enumerate() {
+            let source_row = &mut *resolved_source_row_scratch_f64;
+            source_row.fill(0.0);
+            for (group, member_weight_range) in raw_sum_groups
+                .iter()
+                .zip(&scratch.selected_member_weight_ranges)
+            {
+                let mut sum = c64(0.0, 0.0);
+                for index in &group.indices {
+                    sum += amplitudes.value(row, *index, output_length);
+                }
+                let contribution = normalization_factor
+                    * group.all_sector_weight
+                    * (sum.re * sum.re + sum.im * sum.im);
+                for (helicity_position, color_position, weight) in
+                    &scratch.selected_member_weights[member_weight_range.clone()]
+                {
+                    source_row
+                        [*helicity_position * scratch.color_indices.len() + *color_position] +=
+                        contribution * weight;
+                }
+            }
+
+            let target_row = &mut *resolved_target_row_scratch_f64;
+            target_row.fill(0.0);
+            for route in &replay_entry.routes {
+                if route.source_index >= source_component_count
+                    || route.target_index >= target_component_count
+                {
+                    return Err(RusticolError::integrity(
+                        "LC topology replay selected route is out of bounds",
+                    ));
+                }
+                target_row[route.target_index] += route.weight * source_row[route.source_index];
+            }
+            *target_total = target_row.iter().sum();
+        }
+        Ok(())
+    }
+
+    /// Reduce amplitudes evaluated for one physical runtime-helicity domain.
+    ///
+    /// The ordinary resolved reducer distributes one representative amplitude
+    /// over every proof-equivalent physical helicity.  A materialized
+    /// recurrence artifact instead reevaluates that representative with the
+    /// requested source states, so the selected helicity receives the full
+    /// contribution.  Colour symmetry weights remain distributed over their
+    /// physical components exactly as in the ordinary resolved contract.
+    pub(crate) fn reduce_scratch_f64_for_materialized_helicity(
+        &mut self,
+        batch_size: usize,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        helicity_index: usize,
+        root_factors: &[Option<Complex<f64>>],
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let amplitudes = RowMajorAmplitudeSamples::new(
+            &self.output_scratch_f64,
+            batch_size,
+            self.output_length,
+        )?;
+        Self::reduce_amplitude_samples_f64_for_materialized_helicity(
+            amplitudes,
+            batch_size,
+            physics,
+            normalization_factor,
+            helicity_index,
+            root_factors,
+            selected_color_ids,
+            self.output_length,
+            &self.raw_sum_groups,
+            self.has_coherent_groups,
+            &mut self.color_contraction,
+        )
+    }
+
+    /// Plane-native counterpart of the materialized physical-helicity reducer.
+    #[allow(dead_code)]
+    pub(crate) fn reduce_planes_f64_for_materialized_helicity(
+        &mut self,
+        amplitudes: crate::direct_arena::DirectAmplitudePlanes<'_>,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        helicity_index: usize,
+        root_factors: &[Option<Complex<f64>>],
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        let plane_count = usize::try_from(amplitudes.component_count()?)
+            .map_err(|_| RusticolError::invalid_argument("amplitude plane count exceeds usize"))?;
+        if plane_count != self.output_length {
+            return Err(RusticolError::invalid_argument(format!(
+                "direct amplitude plane count is {plane_count}, expected {}",
+                self.output_length
+            )));
+        }
+        Self::reduce_amplitude_samples_f64_for_materialized_helicity(
+            amplitudes,
+            amplitudes.point_count() as usize,
+            physics,
+            normalization_factor,
+            helicity_index,
+            root_factors,
+            selected_color_ids,
+            self.output_length,
+            &self.raw_sum_groups,
+            self.has_coherent_groups,
+            &mut self.color_contraction,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn reduce_amplitude_samples_f64_for_materialized_helicity<S: AmplitudeSamples>(
+        amplitudes: S,
+        batch_size: usize,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        helicity_index: usize,
+        root_factors: &[Option<Complex<f64>>],
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output_length: usize,
+        raw_sum_groups: &[RawSumGroup],
+        has_coherent_groups: bool,
+        color_contraction: &mut Option<ColorContractionRuntime>,
+    ) -> RusticolResult<ResolvedValues<f64>> {
+        if root_factors.len() != output_length {
+            return Err(RusticolError::integrity(format!(
+                "helicity recurrence route table has {} roots, expected {}",
+                root_factors.len(),
+                output_length
+            )));
+        }
+        if helicity_index >= physics.manifest.helicities.len() {
+            return Err(RusticolError::selector(format!(
+                "runtime helicity index {helicity_index} is out of range"
+            )));
+        }
+        let color_count = physics.manifest.color_components.len();
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        let mut full_values = vec![0.0; batch_size * color_count];
+
+        if let Some(contraction) = color_contraction.as_mut() {
+            if color_count != 1 || !physics.has_contracted_color_axis() {
+                return Err(RusticolError::invalid_argument(
+                    "resolved NLC/full evaluation requires one contracted color component",
+                ));
+            }
+            if raw_sum_groups.len() != contraction.group_count {
+                return Err(RusticolError::invalid_argument(
+                    "colour contraction group count does not match coherent groups",
+                ));
+            }
+            contraction
+                .group_scratch_f64
+                .resize(batch_size * contraction.group_count, c64(0.0, 0.0));
+            let mut group_active = vec![false; contraction.group_count];
+            for (group_index, group) in raw_sum_groups.iter().enumerate() {
+                let reduction = physics
+                    .numeric_reduction_by_group_id
+                    .get(&group.id)
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(format!(
+                            "resolved metadata is missing coherent group {}",
+                            group.id
+                        ))
+                    })?;
+                group_active[group_index] = reduction.contains_helicity(helicity_index)
+                    && group
+                        .indices
+                        .iter()
+                        .any(|index| root_factors[*index].is_some());
+            }
+            for (row, full_value) in full_values.iter_mut().enumerate().take(batch_size) {
+                let group_row = row * contraction.group_count;
+                for (group_index, group) in raw_sum_groups.iter().enumerate() {
+                    let mut sum = c64(0.0, 0.0);
+                    if group_active[group_index] {
+                        for index in &group.indices {
+                            if let Some(factor) = root_factors[*index] {
+                                sum += amplitudes.value(row, *index, output_length) * factor;
+                            }
+                        }
+                    }
+                    contraction.group_scratch_f64[group_row + group_index] = sum;
+                }
+                for entry in contraction.logical_entries() {
+                    if !group_active[entry.left_group_index]
+                        || !group_active[entry.right_group_index]
+                    {
+                        continue;
+                    }
+                    let left = contraction.group_scratch_f64[group_row + entry.left_group_index];
+                    let right = contraction.group_scratch_f64[group_row + entry.right_group_index];
+                    let product = left * right.conj();
+                    *full_value += normalization_factor
+                        * entry.symmetry_factor
+                        * (entry.weight_re * product.re - entry.weight_im * product.im);
+                }
+            }
+        } else {
+            if !has_coherent_groups {
+                return Err(RusticolError::invalid_argument(
+                    "materialized helicity reduction requires coherent amplitude-group metadata",
+                ));
+            }
+            let mut active_groups = Vec::new();
+            for (group_index, group) in raw_sum_groups.iter().enumerate() {
+                let reduction = physics
+                    .numeric_reduction_by_group_id
+                    .get(&group.id)
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(format!(
+                            "resolved metadata is missing coherent group {}",
+                            group.id
+                        ))
+                    })?;
+                if !reduction.contains_helicity(helicity_index)
+                    || !group
+                        .indices
+                        .iter()
+                        .any(|index| root_factors[*index].is_some())
+                {
+                    continue;
+                }
+                active_groups.push((group_index, reduction.normalized_color_weights.clone()));
+            }
+            for row in 0..batch_size {
+                let color_row = row * color_count;
+                for (group_index, color_weights) in &active_groups {
+                    let group = &raw_sum_groups[*group_index];
+                    let mut sum = c64(0.0, 0.0);
+                    for index in &group.indices {
+                        if let Some(factor) = root_factors[*index] {
+                            sum += amplitudes.value(row, *index, output_length) * factor;
+                        }
+                    }
+                    let contribution = normalization_factor
+                        * group.all_sector_weight
+                        * (sum.re * sum.re + sum.im * sum.im);
+                    for (color_index, weight) in color_weights {
+                        full_values[color_row + *color_index] += contribution * *weight;
+                    }
+                }
+            }
+        }
+
+        let mut values = Vec::with_capacity(batch_size * color_indices.len());
+        for row in 0..batch_size {
+            for color_index in &color_indices {
+                values.push(full_values[row * color_count + *color_index]);
+            }
+        }
+        Ok(ResolvedValues {
+            values,
+            point_count: batch_size,
+            helicity_indices: vec![helicity_index],
+            color_indices,
+        })
+    }
+
+    /// Add one materialized physical-helicity row to caller-owned totals.
+    ///
+    /// Colour cells are accumulated in the same group order as the resolved
+    /// reducer, then folded into each point total in manifest colour order.
+    /// Keeping only one colour row preserves exact summation semantics while
+    /// avoiding a batch-by-colour resolved allocation.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn reduce_scratch_f64_for_materialized_helicity_add_into(
+        &mut self,
+        batch_size: usize,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        helicity_index: usize,
+        root_factors: &[Option<Complex<f64>>],
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let amplitudes = RowMajorAmplitudeSamples::new(
+            &self.output_scratch_f64,
+            batch_size,
+            self.output_length,
+        )?;
+        Self::reduce_amplitude_samples_f64_for_materialized_helicity_add_into(
+            amplitudes,
+            batch_size,
+            physics,
+            normalization_factor,
+            helicity_index,
+            root_factors,
+            selected_color_ids,
+            output,
+            self.output_length,
+            &self.raw_sum_groups,
+            self.has_coherent_groups,
+            &mut self.color_contraction,
+            &mut self.resolved_source_row_scratch_f64,
+            &mut self.routed_reduction_scratch,
+        )
+    }
+
+    /// Cold-bind the numeric materialized-helicity totals reducer for one
+    /// concrete physics/amplitude recipient.
+    ///
+    /// Parent-closure lanes deliberately pass the parent's physics metadata to
+    /// a child amplitude runtime.  The binding key therefore includes the
+    /// actual `PhysicsRuntime`, rather than assuming the amplitude's owning
+    /// execution runtime supplies the reduction metadata.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn bind_materialized_helicity_direct_total_plan(
+        &mut self,
+        physics: &PhysicsRuntime,
+        helicity_index: usize,
+        root_factors: &[Option<Complex<f64>>],
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<usize> {
+        if root_factors.len() != self.output_length {
+            return Err(RusticolError::integrity(format!(
+                "helicity recurrence route table has {} roots, expected {}",
+                root_factors.len(),
+                self.output_length
+            )));
+        }
+        if helicity_index >= physics.manifest.helicities.len() {
+            return Err(RusticolError::selector(format!(
+                "runtime helicity index {helicity_index} is out of range"
+            )));
+        }
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        let root_factor_bits = root_factors
+            .iter()
+            .enumerate()
+            .filter_map(|(index, factor)| {
+                factor.map(|factor| (index, [factor.re.to_bits(), factor.im.to_bits()]))
+            })
+            .collect::<Vec<_>>();
+        let key = MaterializedHelicityDirectTotalPlanKey {
+            physics_binding_id: physics.binding_id,
+            helicity_index,
+            root_factor_bits,
+            color_indices,
+        };
+        // Common 384-helicity artifacts fit every schedule; 768-helicity
+        // artifacts have at most 384 non-structural/global-flip primaries and
+        // therefore fit as well. Parent-closure lanes use 192 schedules for the
+        // qq_Z6g artifact. Arbitrary dynamic selector/root-factor combinations
+        // remain capped instead of growing the runtime cache indefinitely.
+        let artifact_plan_capacity = physics.manifest.helicities.len().clamp(16, 512);
+        self.materialized_helicity_direct_total_plan_capacity = self
+            .materialized_helicity_direct_total_plan_capacity
+            .max(artifact_plan_capacity);
+        if let Some(index) = self
+            .materialized_helicity_direct_total_plans
+            .iter()
+            .position(|plan| plan.key == key)
+        {
+            return Ok(index);
+        }
+
+        let mut roots = Vec::new();
+        let mut groups = Vec::new();
+        let mut bound_group_by_raw_group = vec![None; self.raw_sum_groups.len()];
+        let mut color_weights_by_group = Vec::new();
+        for (raw_group_index, group) in self.raw_sum_groups.iter().enumerate() {
+            let numeric = physics
+                .numeric_reduction_by_group_id
+                .get(&group.id)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(format!(
+                        "resolved metadata is missing coherent group {}",
+                        group.id
+                    ))
+                })?;
+            if !numeric.contains_helicity(helicity_index) {
+                continue;
+            }
+            let root_start = roots.len();
+            for output_index in &group.indices {
+                let factor = root_factors.get(*output_index).ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "coherent group {} references missing amplitude root {output_index}",
+                        group.id
+                    ))
+                })?;
+                if let Some(factor) = factor {
+                    roots.push(MaterializedHelicityDirectTotalRoot {
+                        output_index: *output_index,
+                        factor: *factor,
+                    });
+                }
+            }
+            if roots.len() == root_start {
+                continue;
+            }
+            let bound_group_index = groups.len();
+            bound_group_by_raw_group[raw_group_index] = Some(bound_group_index);
+            let root_range = root_start..roots.len();
+            let identity_output_index = match &roots[root_range.clone()] {
+                [root]
+                    if root.factor.re.to_bits() == 1.0f64.to_bits()
+                        && root.factor.im.to_bits() == 0.0f64.to_bits() =>
+                {
+                    Some(root.output_index)
+                }
+                _ => None,
+            };
+            groups.push(MaterializedHelicityDirectTotalGroup {
+                root_range,
+                all_sector_weight: group.all_sector_weight,
+                identity_output_index,
+            });
+            color_weights_by_group.push(numeric.normalized_color_weights.clone());
+        }
+
+        let reduction = if let Some(contraction) = self.color_contraction.as_ref() {
+            if !physics.has_contracted_color_axis() || physics.manifest.color_components.len() != 1
+            {
+                return Err(RusticolError::invalid_argument(
+                    "materialized-helicity color contraction requires one contracted color component",
+                ));
+            }
+            if self.raw_sum_groups.len() != contraction.group_count {
+                return Err(RusticolError::invalid_argument(
+                    "colour contraction group count does not match coherent groups",
+                ));
+            }
+            if selected_color_ids.is_some() && key.color_indices.as_slice() != [0] {
+                return Err(RusticolError::selector(
+                    "materialized-helicity color selection does not match the contracted axis",
+                ));
+            }
+            let entries = contraction
+                .logical_entries()
+                .filter_map(|entry| {
+                    Some(MaterializedHelicityDirectTotalContractionEntry {
+                        left_group_index: bound_group_by_raw_group[entry.left_group_index]?,
+                        right_group_index: bound_group_by_raw_group[entry.right_group_index]?,
+                        weight_re: entry.weight_re,
+                        weight_im: entry.weight_im,
+                        symmetry_factor: entry.symmetry_factor,
+                    })
+                })
+                .collect();
+            MaterializedHelicityDirectTotalReduction::Contracted { entries }
+        } else {
+            if !self.has_coherent_groups {
+                return Err(RusticolError::invalid_argument(
+                    "materialized helicity reduction requires coherent amplitude-group metadata",
+                ));
+            }
+            let mut color_group_ranges = Vec::with_capacity(key.color_indices.len());
+            let mut color_groups = Vec::new();
+            for color_index in &key.color_indices {
+                let start = color_groups.len();
+                for (group_index, color_weights) in color_weights_by_group.iter().enumerate() {
+                    for (_, weight) in color_weights
+                        .iter()
+                        .filter(|(candidate, _)| candidate == color_index)
+                    {
+                        color_groups.push(MaterializedHelicityDirectTotalColorGroup {
+                            group_index,
+                            weight: *weight,
+                        });
+                    }
+                }
+                color_group_ranges.push(start..color_groups.len());
+            }
+            MaterializedHelicityDirectTotalReduction::Lc {
+                color_group_ranges,
+                color_groups,
+            }
+        };
+        let plan = MaterializedHelicityDirectTotalPlan {
+            key,
+            roots,
+            groups,
+            reduction,
+        };
+        let index = if self.materialized_helicity_direct_total_plans.len()
+            < self.materialized_helicity_direct_total_plan_capacity
+        {
+            let index = self.materialized_helicity_direct_total_plans.len();
+            self.materialized_helicity_direct_total_plans.push(plan);
+            index
+        } else {
+            let index = self.materialized_helicity_direct_total_next_replacement
+                % self.materialized_helicity_direct_total_plans.len();
+            self.materialized_helicity_direct_total_plans[index] = plan;
+            for cached in &mut self.materialized_helicity_direct_default_plan_by_selector_domain {
+                if cached.is_some_and(|cached| cached.plan_index == index) {
+                    *cached = None;
+                }
+            }
+            self.materialized_helicity_direct_total_next_replacement =
+                (index + 1) % self.materialized_helicity_direct_total_plans.len();
+            index
+        };
+        Ok(index)
+    }
+
+    /// Bind the immutable default contracted-colour plan for one authenticated
+    /// selector domain, reusing its plan index on subsequent warm calls.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn bind_default_materialized_helicity_direct_total_plan(
+        &mut self,
+        selector_domain_id: usize,
+        physics: &PhysicsRuntime,
+        helicity_index: usize,
+        root_factors: &[Option<Complex<f64>>],
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<usize> {
+        if selected_color_ids.is_some() || !physics.has_contracted_color_axis() {
+            return self.bind_materialized_helicity_direct_total_plan(
+                physics,
+                helicity_index,
+                root_factors,
+                selected_color_ids,
+            );
+        }
+        let cached = self
+            .materialized_helicity_direct_default_plan_by_selector_domain
+            .get(selector_domain_id)
+            .copied()
+            .flatten();
+        if let Some(cached) = cached
+            && cached.physics_binding_id == physics.binding_id
+            && cached.helicity_index == helicity_index
+            && self
+                .materialized_helicity_direct_total_plans
+                .get(cached.plan_index)
+                .is_some_and(|plan| {
+                    plan.key.physics_binding_id == physics.binding_id
+                        && plan.key.helicity_index == helicity_index
+                        && plan.key.color_indices.as_slice() == [0]
+                })
+        {
+            return Ok(cached.plan_index);
+        }
+
+        let plan_index = self.bind_materialized_helicity_direct_total_plan(
+            physics,
+            helicity_index,
+            root_factors,
+            selected_color_ids,
+        )?;
+        if self
+            .materialized_helicity_direct_default_plan_by_selector_domain
+            .len()
+            <= selector_domain_id
+        {
+            self.materialized_helicity_direct_default_plan_by_selector_domain
+                .resize(selector_domain_id + 1, None);
+        }
+        self.materialized_helicity_direct_default_plan_by_selector_domain[selector_domain_id] =
+            Some(MaterializedHelicityDirectDefaultPlanCacheEntry {
+                physics_binding_id: physics.binding_id,
+                helicity_index,
+                plan_index,
+            });
+        Ok(plan_index)
+    }
+
+    /// Plane-native materialized-helicity totals using a cold-bound numeric
+    /// reduction plan.
+    pub(crate) fn reduce_planes_f64_for_materialized_helicity_plan_add_into(
+        &mut self,
+        amplitudes: crate::direct_arena::DirectAmplitudePlanes<'_>,
+        normalization_factor: f64,
+        plan_index: usize,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let plane_count = usize::try_from(amplitudes.component_count()?)
+            .map_err(|_| RusticolError::invalid_argument("amplitude plane count exceeds usize"))?;
+        if plane_count != self.output_length {
+            return Err(RusticolError::invalid_argument(format!(
+                "direct amplitude plane count is {plane_count}, expected {}",
+                self.output_length
+            )));
+        }
+        let batch_size = amplitudes.point_count() as usize;
+        if output.len() != batch_size {
+            return Err(RusticolError::invalid_argument(format!(
+                "materialized helicity output has length {}, expected {batch_size}",
+                output.len()
+            )));
+        }
+        let plan = self
+            .materialized_helicity_direct_total_plans
+            .get(plan_index)
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "materialized-helicity direct-total plan {plan_index} is not bound"
+                ))
+            })?;
+        let scratch = &mut self.routed_reduction_scratch;
+        scratch.direct_group_re.resize(batch_size, 0.0);
+        scratch.direct_group_im.resize(batch_size, 0.0);
+        scratch.direct_totals.resize(batch_size, 0.0);
+
+        match &plan.reduction {
+            MaterializedHelicityDirectTotalReduction::Lc {
+                color_group_ranges,
+                color_groups,
+            } => {
+                for color_group_range in color_group_ranges {
+                    scratch.direct_totals.fill(0.0);
+                    for color_group in &color_groups[color_group_range.clone()] {
+                        let group = &plan.groups[color_group.group_index];
+                        if let Some(output_index) = group.identity_output_index {
+                            let (plane_re, plane_im) = amplitudes.plane_unchecked(output_index);
+                            for point in 0..batch_size {
+                                let re = plane_re[point];
+                                let im = plane_im[point];
+                                let norm = if re.is_finite() && im.is_finite() {
+                                    re * re + im * im
+                                } else {
+                                    let value = c64(re, im) * c64(1.0, 0.0);
+                                    value.re * value.re + value.im * value.im
+                                };
+                                let contribution =
+                                    normalization_factor * group.all_sector_weight * norm;
+                                scratch.direct_totals[point] += contribution * color_group.weight;
+                            }
+                            continue;
+                        }
+                        scratch.direct_group_re.fill(0.0);
+                        scratch.direct_group_im.fill(0.0);
+                        for root in &plan.roots[group.root_range.clone()] {
+                            let (plane_re, plane_im) =
+                                amplitudes.plane_unchecked(root.output_index);
+                            for point in 0..batch_size {
+                                let value = c64(plane_re[point], plane_im[point]) * root.factor;
+                                scratch.direct_group_re[point] += value.re;
+                                scratch.direct_group_im[point] += value.im;
+                            }
+                        }
+                        for point in 0..batch_size {
+                            let re = scratch.direct_group_re[point];
+                            let im = scratch.direct_group_im[point];
+                            let contribution = normalization_factor
+                                * group.all_sector_weight
+                                * (re * re + im * im);
+                            scratch.direct_totals[point] += contribution * color_group.weight;
+                        }
+                    }
+                    for (target, total) in output.iter_mut().zip(&scratch.direct_totals) {
+                        *target += *total;
+                    }
+                }
+            }
+            MaterializedHelicityDirectTotalReduction::Contracted { entries } => {
+                let group_scalar_count =
+                    plan.groups.len().checked_mul(batch_size).ok_or_else(|| {
+                        RusticolError::invalid_argument(
+                            "materialized-helicity group scratch shape overflows usize",
+                        )
+                    })?;
+                scratch.direct_group_re.resize(group_scalar_count, 0.0);
+                scratch.direct_group_re.fill(0.0);
+                scratch.direct_group_im.resize(group_scalar_count, 0.0);
+                scratch.direct_group_im.fill(0.0);
+                for (group_index, group) in plan.groups.iter().enumerate() {
+                    let group_start = group_index * batch_size;
+                    if let Some(output_index) = group.identity_output_index {
+                        let (plane_re, plane_im) = amplitudes.plane_unchecked(output_index);
+                        for point in 0..batch_size {
+                            let re = plane_re[point];
+                            let im = plane_im[point];
+                            if re.is_finite() && im.is_finite() {
+                                scratch.direct_group_re[group_start + point] = re;
+                                scratch.direct_group_im[group_start + point] = im;
+                            } else {
+                                let value = c64(re, im) * c64(1.0, 0.0);
+                                scratch.direct_group_re[group_start + point] = value.re;
+                                scratch.direct_group_im[group_start + point] = value.im;
+                            }
+                        }
+                        continue;
+                    }
+                    for root in &plan.roots[group.root_range.clone()] {
+                        let (plane_re, plane_im) = amplitudes.plane_unchecked(root.output_index);
+                        for point in 0..batch_size {
+                            let value = c64(plane_re[point], plane_im[point]) * root.factor;
+                            scratch.direct_group_re[group_start + point] += value.re;
+                            scratch.direct_group_im[group_start + point] += value.im;
+                        }
+                    }
+                }
+                scratch.direct_totals.fill(0.0);
+                for entry in entries {
+                    for point in 0..batch_size {
+                        let left_start = entry.left_group_index * batch_size;
+                        let left = c64(
+                            scratch.direct_group_re[left_start + point],
+                            scratch.direct_group_im[left_start + point],
+                        );
+                        let right_start = entry.right_group_index * batch_size;
+                        let right = c64(
+                            scratch.direct_group_re[right_start + point],
+                            scratch.direct_group_im[right_start + point],
+                        );
+                        let product = left * right.conj();
+                        scratch.direct_totals[point] += normalization_factor
+                            * entry.symmetry_factor
+                            * (entry.weight_re * product.re - entry.weight_im * product.im);
+                    }
+                }
+                for (target, total) in output.iter_mut().zip(&scratch.direct_totals) {
+                    *target += *total;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Plane-native counterpart of the materialized-helicity totals accumulator.
+    #[allow(dead_code)]
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn reduce_planes_f64_for_materialized_helicity_add_into(
+        &mut self,
+        amplitudes: crate::direct_arena::DirectAmplitudePlanes<'_>,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        helicity_index: usize,
+        root_factors: &[Option<Complex<f64>>],
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+    ) -> RusticolResult<()> {
+        let plan_index = self.bind_materialized_helicity_direct_total_plan(
+            physics,
+            helicity_index,
+            root_factors,
+            selected_color_ids,
+        )?;
+        self.reduce_planes_f64_for_materialized_helicity_plan_add_into(
+            amplitudes,
+            normalization_factor,
+            plan_index,
+            output,
+        )
+    }
+
+    /// Route one materialized-helicity tile into persistent public replay
+    /// components without constructing a resolved colour tensor.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn reduce_planes_f64_for_materialized_helicity_routed_components_add_into(
+        &mut self,
+        amplitudes: crate::direct_arena::DirectAmplitudePlanes<'_>,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        helicity_index: usize,
+        root_factors: &[Option<Complex<f64>>],
+        selected_color_ids: Option<&BTreeSet<String>>,
+        replay_entry: &LcResolvedReplayEntry,
+        source_component_count: usize,
+        target_component_count: usize,
+        target_point_count: usize,
+        target_point_start: usize,
+        target_components: &mut [f64],
+    ) -> RusticolResult<()> {
+        let plane_count = usize::try_from(amplitudes.component_count()?)
+            .map_err(|_| RusticolError::invalid_argument("amplitude plane count exceeds usize"))?;
+        if plane_count != self.output_length {
+            return Err(RusticolError::invalid_argument(format!(
+                "direct amplitude plane count is {plane_count}, expected {}",
+                self.output_length
+            )));
+        }
+        if root_factors.len() != self.output_length {
+            return Err(RusticolError::integrity(format!(
+                "helicity recurrence route table has {} roots, expected {}",
+                root_factors.len(),
+                self.output_length
+            )));
+        }
+        if self.color_contraction.is_some() {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay does not support contracted color reduction",
+            ));
+        }
+        if !self.has_coherent_groups {
+            return Err(RusticolError::invalid_argument(
+                "materialized helicity reduction requires coherent amplitude-group metadata",
+            ));
+        }
+        if helicity_index >= physics.manifest.helicities.len() {
+            return Err(RusticolError::selector(format!(
+                "runtime helicity index {helicity_index} is out of range"
+            )));
+        }
+        let batch_size = amplitudes.point_count() as usize;
+        let expected_target_len = target_point_count
+            .checked_mul(target_component_count)
+            .ok_or_else(|| RusticolError::invalid_argument("routed target shape overflows"))?;
+        if target_components.len() != expected_target_len
+            || target_point_start
+                .checked_add(batch_size)
+                .is_none_or(|stop| stop > target_point_count)
+        {
+            return Err(RusticolError::invalid_argument(
+                "routed target components have an inconsistent shape",
+            ));
+        }
+
+        let scratch = &mut self.routed_reduction_scratch;
+        let color_count = physics.manifest.color_components.len();
+        physics.selected_color_indices_into(selected_color_ids, &mut scratch.color_indices)?;
+        if source_component_count != scratch.color_indices.len() {
+            return Err(RusticolError::integrity(format!(
+                "topology replay materialized-helicity source has {source_component_count} components, expected {}",
+                scratch.color_indices.len()
+            )));
+        }
+        for route in &replay_entry.routes {
+            if route.source_index >= source_component_count
+                || route.target_index >= target_component_count
+            {
+                return Err(RusticolError::integrity(
+                    "LC topology replay selected route is out of bounds",
+                ));
+            }
+        }
+        let color_positions = SelectedAxisPositions::new(
+            &scratch.color_indices,
+            color_count,
+            &mut scratch.color_positions,
+        );
+
+        scratch.selected_member_weights.clear();
+        scratch.selected_member_weight_ranges.clear();
+        for group in &self.raw_sum_groups {
+            let start = scratch.selected_member_weights.len();
+            let reduction = physics
+                .numeric_reduction_by_group_id
+                .get(&group.id)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(format!(
+                        "resolved metadata is missing coherent group {}",
+                        group.id
+                    ))
+                })?;
+            if !reduction.contains_helicity(helicity_index)
+                || !group
+                    .indices
+                    .iter()
+                    .any(|index| root_factors[*index].is_some())
+            {
+                scratch.selected_member_weight_ranges.push(start..start);
+                continue;
+            }
+            for (color_index, weight) in reduction.normalized_color_weights.iter().copied() {
+                if let Some(color_position) = color_positions.position(color_index) {
+                    scratch
+                        .selected_member_weights
+                        .push((0, color_position, weight));
+                }
+            }
+            scratch
+                .selected_member_weight_ranges
+                .push(start..scratch.selected_member_weights.len());
+        }
+
+        let source_scalar_count =
+            source_component_count
+                .checked_mul(batch_size)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument("routed source scratch shape overflows usize")
+                })?;
+        scratch.direct_group_re.resize(batch_size, 0.0);
+        scratch.direct_group_im.resize(batch_size, 0.0);
+        scratch.direct_totals.resize(batch_size, 0.0);
+        scratch
+            .direct_source_components
+            .resize(source_scalar_count, 0.0);
+        scratch.direct_source_components.fill(0.0);
+        for (group, color_weight_range) in self
+            .raw_sum_groups
+            .iter()
+            .zip(&scratch.selected_member_weight_ranges)
+        {
+            if color_weight_range.is_empty() {
+                continue;
+            }
+            scratch.direct_group_re.fill(0.0);
+            scratch.direct_group_im.fill(0.0);
+            for index in &group.indices {
+                let Some(factor) = root_factors[*index] else {
+                    continue;
+                };
+                let (plane_re, plane_im) = amplitudes.plane_unchecked(*index);
+                for point in 0..batch_size {
+                    let value = c64(plane_re[point], plane_im[point]) * factor;
+                    scratch.direct_group_re[point] += value.re;
+                    scratch.direct_group_im[point] += value.im;
+                }
+            }
+            for point in 0..batch_size {
+                let re = scratch.direct_group_re[point];
+                let im = scratch.direct_group_im[point];
+                scratch.direct_totals[point] =
+                    normalization_factor * group.all_sector_weight * (re * re + im * im);
+            }
+            for (_, color_position, weight) in
+                &scratch.selected_member_weights[color_weight_range.clone()]
+            {
+                let source_start = *color_position * batch_size;
+                for point in 0..batch_size {
+                    scratch.direct_source_components[source_start + point] +=
+                        scratch.direct_totals[point] * *weight;
+                }
+            }
+        }
+
+        for route in &replay_entry.routes {
+            let source_start = route.source_index * batch_size;
+            for point in 0..batch_size {
+                let target =
+                    (target_point_start + point) * target_component_count + route.target_index;
+                target_components[target] +=
+                    route.weight * scratch.direct_source_components[source_start + point];
+            }
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn reduce_amplitude_samples_f64_for_materialized_helicity_add_into<S: AmplitudeSamples>(
+        amplitudes: S,
+        batch_size: usize,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        helicity_index: usize,
+        root_factors: &[Option<Complex<f64>>],
+        selected_color_ids: Option<&BTreeSet<String>>,
+        output: &mut [f64],
+        output_length: usize,
+        raw_sum_groups: &[RawSumGroup],
+        has_coherent_groups: bool,
+        color_contraction: &mut Option<ColorContractionRuntime>,
+        resolved_source_row_scratch_f64: &mut Vec<f64>,
+        scratch: &mut RoutedReductionScratch,
+    ) -> RusticolResult<()> {
+        if output.len() != batch_size {
+            return Err(RusticolError::invalid_argument(format!(
+                "materialized helicity output has length {}, expected {batch_size}",
+                output.len()
+            )));
+        }
+        if root_factors.len() != output_length {
+            return Err(RusticolError::integrity(format!(
+                "helicity recurrence route table has {} roots, expected {}",
+                root_factors.len(),
+                output_length
+            )));
+        }
+        if helicity_index >= physics.manifest.helicities.len() {
+            return Err(RusticolError::selector(format!(
+                "runtime helicity index {helicity_index} is out of range"
+            )));
+        }
+        if let Some(contraction) = color_contraction.as_mut() {
+            if !physics.has_contracted_color_axis() || physics.manifest.color_components.len() != 1
+            {
+                return Err(RusticolError::invalid_argument(
+                    "materialized-helicity color contraction requires one contracted color component",
+                ));
+            }
+            if raw_sum_groups.len() != contraction.group_count {
+                return Err(RusticolError::invalid_argument(
+                    "colour contraction group count does not match coherent groups",
+                ));
+            }
+            if let Some(ids) = selected_color_ids
+                && (ids.len() != 1
+                    || !ids
+                        .iter()
+                        .all(|id| physics.color_index_by_id.contains_key(id)))
+            {
+                return Err(RusticolError::selector(
+                    "materialized-helicity color selection does not match the contracted axis",
+                ));
+            }
+            contraction
+                .group_scratch_f64
+                .resize(contraction.group_count, c64(0.0, 0.0));
+            for (row, target) in output.iter_mut().enumerate() {
+                for (group_index, group) in raw_sum_groups.iter().enumerate() {
+                    let reduction = physics
+                        .numeric_reduction_by_group_id
+                        .get(&group.id)
+                        .ok_or_else(|| {
+                            RusticolError::invalid_argument(format!(
+                                "resolved metadata is missing coherent group {}",
+                                group.id
+                            ))
+                        })?;
+                    let active = reduction.contains_helicity(helicity_index)
+                        && group
+                            .indices
+                            .iter()
+                            .any(|index| root_factors[*index].is_some());
+                    let mut sum = c64(0.0, 0.0);
+                    if active {
+                        for index in &group.indices {
+                            if let Some(factor) = root_factors[*index] {
+                                sum += amplitudes.value(row, *index, output_length) * factor;
+                            }
+                        }
+                    }
+                    contraction.group_scratch_f64[group_index] = sum;
+                }
+                let mut contribution = 0.0;
+                for entry in contraction.logical_entries() {
+                    let left = contraction.group_scratch_f64[entry.left_group_index];
+                    let right = contraction.group_scratch_f64[entry.right_group_index];
+                    let product = left * right.conj();
+                    contribution += normalization_factor
+                        * entry.symmetry_factor
+                        * (entry.weight_re * product.re - entry.weight_im * product.im);
+                }
+                *target += contribution;
+            }
+            return Ok(());
+        }
+        if !has_coherent_groups {
+            return Err(RusticolError::invalid_argument(
+                "materialized helicity reduction requires coherent amplitude-group metadata",
+            ));
+        }
+        let color_count = physics.manifest.color_components.len();
+        physics.selected_color_indices_into(selected_color_ids, &mut scratch.color_indices)?;
+
+        scratch.selected_member_weights.clear();
+        scratch.selected_member_weight_ranges.clear();
+        for group in raw_sum_groups {
+            let start = scratch.selected_member_weights.len();
+            let reduction = physics
+                .numeric_reduction_by_group_id
+                .get(&group.id)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(format!(
+                        "resolved metadata is missing coherent group {}",
+                        group.id
+                    ))
+                })?;
+            if !reduction.contains_helicity(helicity_index)
+                || !group
+                    .indices
+                    .iter()
+                    .any(|index| root_factors[*index].is_some())
+            {
+                scratch.selected_member_weight_ranges.push(start..start);
+                continue;
+            }
+            for (color_index, weight) in reduction.normalized_color_weights.iter().copied() {
+                scratch
+                    .selected_member_weights
+                    .push((0, color_index, weight));
+            }
+            let stop = scratch.selected_member_weights.len();
+            scratch.selected_member_weight_ranges.push(start..stop);
+        }
+
+        resolved_source_row_scratch_f64.resize(color_count, 0.0);
+        for (row, target_total) in output.iter_mut().enumerate() {
+            let color_row = &mut *resolved_source_row_scratch_f64;
+            color_row.fill(0.0);
+            for (group, color_weight_range) in raw_sum_groups
+                .iter()
+                .zip(&scratch.selected_member_weight_ranges)
+            {
+                if color_weight_range.is_empty() {
+                    continue;
+                }
+                let mut sum = c64(0.0, 0.0);
+                for index in &group.indices {
+                    if let Some(factor) = root_factors[*index] {
+                        sum += amplitudes.value(row, *index, output_length) * factor;
+                    }
+                }
+                let contribution = normalization_factor
+                    * group.all_sector_weight
+                    * (sum.re * sum.re + sum.im * sum.im);
+                for (_, color_index, weight) in
+                    &scratch.selected_member_weights[color_weight_range.clone()]
+                {
+                    color_row[*color_index] += contribution * *weight;
+                }
+            }
+            for color_index in &scratch.color_indices {
+                *target_total += color_row[*color_index];
+            }
+        }
+        Ok(())
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_materialized_helicity_generic<T>(
+        &mut self,
+        batch_size: usize,
+        state: &[Complex<T>],
+        binary_precision: Option<u32>,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        helicity_index: usize,
+        root_factors: &[Option<Complex<f64>>],
+        selected_color_ids: Option<&BTreeSet<String>>,
+        active_chunk_indices: &[usize],
+    ) -> RusticolResult<(ResolvedValues<T>, f64, f64, f64)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let (amplitudes, input_pack_s, evaluator_call_s) = self.evaluate_selected_outputs_generic(
+            batch_size,
+            state,
+            binary_precision,
+            Some(active_chunk_indices),
+        )?;
+        let reduction_start = Instant::now();
+        if root_factors.len() != self.output_length {
+            return Err(RusticolError::integrity(format!(
+                "helicity recurrence route table has {} roots, expected {}",
+                root_factors.len(),
+                self.output_length
+            )));
+        }
+        let helicity = physics
+            .manifest
+            .helicities
+            .get(helicity_index)
+            .ok_or_else(|| {
+                RusticolError::selector(format!(
+                    "runtime helicity index {helicity_index} is out of range"
+                ))
+            })?;
+        let color_count = physics.manifest.color_components.len();
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        let mut full_values = vec![T::new_zero(); batch_size * color_count];
+
+        if let Some(contraction) = self.color_contraction.as_ref() {
+            if color_count != 1 || !physics.has_contracted_color_axis() {
+                return Err(RusticolError::invalid_argument(
+                    "resolved NLC/full evaluation requires one contracted color component",
+                ));
+            }
+            if self.raw_sum_groups.len() != contraction.group_count {
+                return Err(RusticolError::invalid_argument(
+                    "colour contraction group count does not match coherent groups",
+                ));
+            }
+            let mut group_active = vec![false; contraction.group_count];
+            for (group_index, group) in self.raw_sum_groups.iter().enumerate() {
+                let reduction = physics
+                    .reduction_by_group_id
+                    .get(&group.id)
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(format!(
+                            "resolved metadata is missing coherent group {}",
+                            group.id
+                        ))
+                    })?;
+                group_active[group_index] = reduction
+                    .physical_helicity_ids
+                    .iter()
+                    .any(|id| id == &helicity.id)
+                    && group
+                        .indices
+                        .iter()
+                        .any(|index| root_factors[*index].is_some());
+            }
+            let mut group_values = vec![complex_zero::<T>(); batch_size * contraction.group_count];
+            for (row, full_value) in full_values.iter_mut().enumerate() {
+                let row_offset = row * self.output_length;
+                let group_row = row * contraction.group_count;
+                for (group_index, group) in self.raw_sum_groups.iter().enumerate() {
+                    if !group_active[group_index] {
+                        continue;
+                    }
+                    let mut sum = complex_zero::<T>();
+                    for index in &group.indices {
+                        let Some(factor) = root_factors[*index] else {
+                            continue;
+                        };
+                        sum += amplitudes[row_offset + *index].clone()
+                            * c_generic(T::from(factor.re), T::from(factor.im));
+                    }
+                    group_values[group_row + group_index] = sum;
+                }
+                for entry in contraction.logical_entries() {
+                    if !group_active[entry.left_group_index]
+                        || !group_active[entry.right_group_index]
+                    {
+                        continue;
+                    }
+                    let left = &group_values[group_row + entry.left_group_index];
+                    let right = &group_values[group_row + entry.right_group_index];
+                    let product_re =
+                        left.re.clone() * right.re.clone() + left.im.clone() * right.im.clone();
+                    let product_im =
+                        left.im.clone() * right.re.clone() - left.re.clone() * right.im.clone();
+                    *full_value += T::from(normalization_factor * entry.symmetry_factor)
+                        * (T::from(entry.weight_re) * product_re
+                            - T::from(entry.weight_im) * product_im);
+                }
+            }
+        } else {
+            if !self.has_coherent_groups {
+                return Err(RusticolError::invalid_argument(
+                    "materialized helicity reduction requires coherent amplitude-group metadata",
+                ));
+            }
+            for row in 0..batch_size {
+                let row_offset = row * self.output_length;
+                let color_row = row * color_count;
+                for group in &self.raw_sum_groups {
+                    let reduction =
+                        physics
+                            .reduction_by_group_id
+                            .get(&group.id)
+                            .ok_or_else(|| {
+                                RusticolError::invalid_argument(format!(
+                                    "resolved metadata is missing coherent group {}",
+                                    group.id
+                                ))
+                            })?;
+                    if !reduction
+                        .physical_helicity_ids
+                        .iter()
+                        .any(|id| id == &helicity.id)
+                    {
+                        continue;
+                    }
+                    let mut sum = complex_zero::<T>();
+                    for index in &group.indices {
+                        let Some(factor) = root_factors[*index] else {
+                            continue;
+                        };
+                        sum += amplitudes[row_offset + *index].clone()
+                            * c_generic(T::from(factor.re), T::from(factor.im));
+                    }
+                    let color_weights = reduction
+                        .physical_color_ids
+                        .iter()
+                        .map(|id| {
+                            let index = *physics.color_index_by_id.get(id).ok_or_else(|| {
+                                RusticolError::artifact(format!(
+                                    "resolved reduction group {} references unknown color {id:?}",
+                                    group.id
+                                ))
+                            })?;
+                            Ok((
+                                index,
+                                physics.manifest.color_components[index].coefficient(),
+                            ))
+                        })
+                        .collect::<RusticolResult<Vec<_>>>()?;
+                    let total_color_weight =
+                        color_weights.iter().map(|(_, weight)| *weight).sum::<f64>();
+                    if !total_color_weight.is_finite() || total_color_weight <= 0.0 {
+                        return Err(RusticolError::artifact(format!(
+                            "resolved reduction group {} has no positive color weight",
+                            group.id
+                        )));
+                    }
+                    let contribution = T::from(normalization_factor * group.all_sector_weight)
+                        * (sum.re.clone() * sum.re + sum.im.clone() * sum.im);
+                    for (color_index, weight) in color_weights {
+                        full_values[color_row + color_index] +=
+                            contribution.clone() * T::from(weight / total_color_weight);
+                    }
+                }
+            }
+        }
+
+        let mut values = Vec::with_capacity(batch_size * color_indices.len());
+        for row in 0..batch_size {
+            for color_index in &color_indices {
+                values.push(full_values[row * color_count + *color_index].clone());
+            }
+        }
+        Ok((
+            ResolvedValues {
+                values,
+                point_count: batch_size,
+                helicity_indices: vec![helicity_index],
+                color_indices,
+            },
+            input_pack_s,
+            evaluator_call_s,
+            reduction_start.elapsed().as_secs_f64(),
+        ))
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(crate) fn evaluate_outputs_generic<T>(
+        &mut self,
+        batch_size: usize,
+        state: &[Complex<T>],
+        binary_precision: Option<u32>,
+    ) -> RusticolResult<(Vec<Complex<T>>, f64, f64)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        self.evaluate_selected_outputs_generic(batch_size, state, binary_precision, None)
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    fn evaluate_selected_outputs_generic<T>(
+        &mut self,
+        batch_size: usize,
+        state: &[Complex<T>],
+        binary_precision: Option<u32>,
+        active_chunk_indices: Option<&[usize]>,
+    ) -> RusticolResult<(Vec<Complex<T>>, f64, f64)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let evaluator = self.evaluator.as_mut().ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled plane-arena reducer cannot execute an exact dense amplitude evaluator",
+            )
+        })?;
+        let mut input_pack_elapsed = Duration::ZERO;
+        let (evaluated, evaluator_call_s) = if let Some(input_components) =
+            self.input_components.as_ref()
+        {
+            let local_parameter_count = input_components.len();
+            let global_parameter_count = state.len().checked_div(batch_size).ok_or_else(|| {
+                RusticolError::invalid_argument("generic amplitude batch size is zero")
+            })?;
+            let pack_start = Instant::now();
+            let mut parameter_scratch =
+                vec![complex_zero::<T>(); batch_size * local_parameter_count];
+            for row in 0..batch_size {
+                let row_state = row * global_parameter_count;
+                let row_params = row * local_parameter_count;
+                if self.input_spans.is_empty() {
+                    for (local_index, global_index) in input_components.iter().enumerate() {
+                        parameter_scratch[row_params + local_index] =
+                            state[row_state + *global_index].clone();
+                    }
+                } else {
+                    for (local_start, global_start, len) in &self.input_spans {
+                        let target_start = row_params + *local_start;
+                        let source_start = row_state + *global_start;
+                        parameter_scratch[target_start..target_start + *len]
+                            .clone_from_slice(&state[source_start..source_start + *len]);
+                    }
+                }
+            }
+            input_pack_elapsed = pack_start.elapsed();
+            let eval_start = Instant::now();
+            let evaluated = evaluator.evaluate_selected_chunks_generic(
+                batch_size,
+                &parameter_scratch,
+                binary_precision,
+                active_chunk_indices,
+            )?;
+            (evaluated, eval_start.elapsed().as_secs_f64())
+        } else {
+            let eval_start = Instant::now();
+            let evaluated = evaluator.evaluate_selected_chunks_generic(
+                batch_size,
+                state,
+                binary_precision,
+                active_chunk_indices,
+            )?;
+            (evaluated, eval_start.elapsed().as_secs_f64())
+        };
+        if evaluated.len() != batch_size * self.output_length {
+            return Err(RusticolError::invalid_argument(format!(
+                "generic amplitude output buffer has length {}, expected {}",
+                evaluated.len(),
+                batch_size * self.output_length
+            )));
+        }
+        Ok((
+            evaluated,
+            profile_duration_seconds(input_pack_elapsed),
+            evaluator_call_s,
+        ))
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(crate) fn evaluate_raw_sums_generic<T>(
+        &mut self,
+        batch_size: usize,
+        state: &[Complex<T>],
+        binary_precision: Option<u32>,
+    ) -> RusticolResult<(Vec<T>, f64, f64)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let (evaluated, input_pack_s, evaluator_call_s) =
+            self.evaluate_outputs_generic(batch_size, state, binary_precision)?;
+        let mut raw_sums = vec![T::new_zero(); batch_size];
+        if let Some(contraction) = self.color_contraction.as_ref() {
+            if self.raw_sum_groups.len() != contraction.group_count {
+                return Err(RusticolError::invalid_argument(
+                    "colour contraction group count does not match coherent groups",
+                ));
+            }
+            let mut group_values = vec![complex_zero::<T>(); batch_size * contraction.group_count];
+            for (row, raw_sum) in raw_sums.iter_mut().enumerate() {
+                let row_offset = row * self.output_length;
+                let group_row = row * contraction.group_count;
+                for (group_index, group) in self.raw_sum_groups.iter().enumerate() {
+                    let mut sum = complex_zero::<T>();
+                    for index in &group.indices {
+                        sum.re += evaluated[row_offset + *index].re.clone();
+                        sum.im += evaluated[row_offset + *index].im.clone();
+                    }
+                    group_values[group_row + group_index] = sum;
+                }
+                for entry in contraction.logical_entries() {
+                    let left = &group_values[group_row + entry.left_group_index];
+                    let right = &group_values[group_row + entry.right_group_index];
+                    let product_re =
+                        left.re.clone() * right.re.clone() + left.im.clone() * right.im.clone();
+                    let product_im =
+                        left.im.clone() * right.re.clone() - left.re.clone() * right.im.clone();
+                    *raw_sum += T::from(entry.symmetry_factor)
+                        * (T::from(entry.weight_re) * product_re
+                            - T::from(entry.weight_im) * product_im);
+                }
+            }
+            return Ok((raw_sums, input_pack_s, evaluator_call_s));
+        }
+        for (row, raw_sum) in raw_sums.iter_mut().enumerate() {
+            let row_offset = row * self.output_length;
+            if self.has_coherent_groups {
+                for group in &self.raw_sum_groups {
+                    let mut sum_re = T::new_zero();
+                    let mut sum_im = T::new_zero();
+                    for index in &group.indices {
+                        let value = &evaluated[row_offset + *index];
+                        sum_re += value.re.clone();
+                        sum_im += value.im.clone();
+                    }
+                    *raw_sum += T::from(group.all_sector_weight)
+                        * (sum_re.clone() * sum_re + sum_im.clone() * sum_im);
+                }
+                continue;
+            }
+            for index in 0..self.output_length {
+                let value = &evaluated[row_offset + index];
+                *raw_sum += T::from(self.raw_sum_all_sector_weights[index])
+                    * (value.re.clone() * value.re.clone() + value.im.clone() * value.im.clone());
+            }
+        }
+        Ok((raw_sums, input_pack_s, evaluator_call_s))
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_resolved_generic<T>(
+        &mut self,
+        batch_size: usize,
+        state: &[Complex<T>],
+        binary_precision: Option<u32>,
+        physics: &PhysicsRuntime,
+        normalization_factor: f64,
+        selected_helicity_ids: Option<&BTreeSet<String>>,
+        selected_color_ids: Option<&BTreeSet<String>>,
+    ) -> RusticolResult<(ResolvedValues<T>, f64, f64)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let (evaluated, input_pack_s, evaluator_call_s) =
+            self.evaluate_outputs_generic(batch_size, state, binary_precision)?;
+        let helicity_count = physics.manifest.helicities.len();
+        let color_count = physics.manifest.color_components.len();
+        let mut full_values = vec![T::new_zero(); batch_size * helicity_count * color_count];
+        if let Some(contraction) = self.color_contraction.as_ref() {
+            if color_count != 1 || !physics.has_contracted_color_axis() {
+                return Err(RusticolError::invalid_argument(
+                    "resolved NLC/full evaluation requires one contracted color component",
+                ));
+            }
+            let mut group_values = vec![complex_zero::<T>(); batch_size * contraction.group_count];
+            for row in 0..batch_size {
+                let row_offset = row * self.output_length;
+                let group_row = row * contraction.group_count;
+                for (group_index, group) in self.raw_sum_groups.iter().enumerate() {
+                    let mut sum = complex_zero::<T>();
+                    for index in &group.indices {
+                        sum.re += evaluated[row_offset + *index].re.clone();
+                        sum.im += evaluated[row_offset + *index].im.clone();
+                    }
+                    group_values[group_row + group_index] = sum;
+                }
+                for entry in contraction.logical_entries() {
+                    let left_group = &self.raw_sum_groups[entry.left_group_index];
+                    let right_group = &self.raw_sum_groups[entry.right_group_index];
+                    let left_reduction = physics
+                        .reduction_by_group_id
+                        .get(&left_group.id)
+                        .ok_or_else(|| {
+                            RusticolError::invalid_argument(format!(
+                                "resolved metadata is missing coherent group {}",
+                                left_group.id
+                            ))
+                        })?;
+                    let right_reduction = physics
+                        .reduction_by_group_id
+                        .get(&right_group.id)
+                        .ok_or_else(|| {
+                            RusticolError::invalid_argument(format!(
+                                "resolved metadata is missing coherent group {}",
+                                right_group.id
+                            ))
+                        })?;
+                    if left_reduction.physical_helicity_ids != right_reduction.physical_helicity_ids
+                    {
+                        return Err(RusticolError::invalid_argument(
+                            "colour contraction mixed distinct physical helicities",
+                        ));
+                    }
+                    let left_weights = physics.normalized_helicity_weights(left_reduction)?;
+                    let right_weights = physics.normalized_helicity_weights(right_reduction)?;
+                    if left_weights.len() != right_weights.len()
+                        || left_weights.iter().zip(&right_weights).any(
+                            |((left_index, left_weight), (right_index, right_weight))| {
+                                left_index != right_index
+                                    || left_weight.to_bits() != right_weight.to_bits()
+                            },
+                        )
+                    {
+                        return Err(RusticolError::invalid_argument(
+                            "colour contraction groups have inconsistent helicity weights",
+                        ));
+                    }
+                    let left = &group_values[group_row + entry.left_group_index];
+                    let right = &group_values[group_row + entry.right_group_index];
+                    let product_re =
+                        left.re.clone() * right.re.clone() + left.im.clone() * right.im.clone();
+                    let product_im =
+                        left.im.clone() * right.re.clone() - left.re.clone() * right.im.clone();
+                    let coefficient = normalization_factor * entry.symmetry_factor;
+                    let contribution = T::from(coefficient)
+                        * (T::from(entry.weight_re) * product_re
+                            - T::from(entry.weight_im) * product_im);
+                    for (helicity_index, weight) in left_weights {
+                        full_values[(row * helicity_count + helicity_index) * color_count] +=
+                            contribution.clone() * T::from(weight);
+                    }
+                }
+            }
+        } else {
+            for row in 0..batch_size {
+                let row_offset = row * self.output_length;
+                for group in &self.raw_sum_groups {
+                    let reduction =
+                        physics
+                            .reduction_by_group_id
+                            .get(&group.id)
+                            .ok_or_else(|| {
+                                RusticolError::invalid_argument(format!(
+                                    "resolved metadata is missing coherent group {}",
+                                    group.id
+                                ))
+                            })?;
+                    let mut sum_re = T::new_zero();
+                    let mut sum_im = T::new_zero();
+                    for index in &group.indices {
+                        sum_re += evaluated[row_offset + *index].re.clone();
+                        sum_im += evaluated[row_offset + *index].im.clone();
+                    }
+                    let contribution = T::from(normalization_factor * group.all_sector_weight)
+                        * (sum_re.clone() * sum_re + sum_im.clone() * sum_im);
+                    for (helicity_index, color_index, weight) in
+                        physics.normalized_member_weights(reduction)?
+                    {
+                        full_values[(row * helicity_count + helicity_index) * color_count
+                            + color_index] += contribution.clone() * T::from(weight);
+                    }
+                }
+            }
+        }
+        let helicity_indices = physics.selected_helicity_indices(selected_helicity_ids)?;
+        let color_indices = physics.selected_color_indices(selected_color_ids)?;
+        let mut values =
+            Vec::with_capacity(batch_size * helicity_indices.len() * color_indices.len());
+        for row in 0..batch_size {
+            for helicity_index in &helicity_indices {
+                for color_index in &color_indices {
+                    values.push(
+                        full_values
+                            [(row * helicity_count + *helicity_index) * color_count + *color_index]
+                            .clone(),
+                    );
+                }
+            }
+        }
+        Ok((
+            ResolvedValues {
+                values,
+                point_count: batch_size,
+                helicity_indices,
+                color_indices,
+            },
+            input_pack_s,
+            evaluator_call_s,
+        ))
+    }
+}
+
+fn reduce_compiled_symmetric_group_planes(
+    amplitudes: crate::direct_arena::DirectAmplitudePlanes<'_>,
+    output: &mut [f64],
+    groups: &[RawSumGroup],
+    symmetric_group: &mut CompiledSymmetricGroupColorContraction,
+) -> RusticolResult<()> {
+    let point_count = amplitudes.point_count() as usize;
+    if output.len() != point_count {
+        return Err(RusticolError::invalid_argument(
+            "compiled symmetric-group FFT output has the wrong point count",
+        ));
+    }
+    let reducer = match symmetric_group.plan.runtime_reducer() {
+        Some(crate::recurrence::RuntimeColorContractionReducer::SymmetricGroupFourier(reducer)) => {
+            reducer
+        }
+        _ => {
+            return Err(RusticolError::integrity(
+                "compiled symmetric-group FFT payload lost its runtime reducer",
+            ));
+        }
+    };
+    let ordered_group_indices = &symmetric_group.ordered_group_indices;
+    let workspace = symmetric_group.workspace.as_mut().ok_or_else(|| {
+        RusticolError::integrity("compiled symmetric-group FFT workspace was not cold-prepared")
+    })?;
+    reducer.reduce_lanes(workspace, point_count, |local_group, point| {
+        let group_index = *ordered_group_indices.get(local_group).ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled symmetric-group FFT local group binding is incomplete",
+            )
+        })?;
+        let group = groups.get(group_index).ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled symmetric-group FFT coherent group binding is out of bounds",
+            )
+        })?;
+        let mut real = 0.0;
+        let mut imaginary = 0.0;
+        for output_index in &group.indices {
+            let (plane_re, plane_im) = amplitudes.plane_unchecked(*output_index);
+            real += plane_re[point];
+            imaginary += plane_im[point];
+        }
+        Ok((real, imaginary))
+    })?;
+    output.copy_from_slice(workspace.reduced(point_count)?);
+    Ok(())
+}
+
+pub(crate) fn build_raw_sum_groups(
+    output_length: usize,
+    weights: &[f64],
+    all_sector_weights: &[f64],
+    group_ids: &[Option<i64>],
+    color_sector_ids: &[Option<i64>],
+) -> RusticolResult<Vec<RawSumGroup>> {
+    if weights.len() != output_length
+        || all_sector_weights.len() != output_length
+        || group_ids.len() != output_length
+        || color_sector_ids.len() != output_length
+    {
+        return Err(RusticolError::invalid_argument(
+            "raw-sum group metadata length does not match amplitude outputs",
+        ));
+    }
+    let mut grouped: BTreeMap<i64, Vec<usize>> = BTreeMap::new();
+    let mut groups = Vec::new();
+    for index in 0..output_length {
+        if let Some(group_id) = group_ids[index] {
+            grouped.entry(group_id).or_default().push(index);
+        } else {
+            groups.push(RawSumGroup {
+                id: index as i64,
+                indices: vec![index],
+                weight: weights[index],
+                all_sector_weight: all_sector_weights[index],
+                sector_ids: color_sector_ids[index].into_iter().collect(),
+            });
+        }
+    }
+    for (group_id, indices) in grouped {
+        let weight = weights[indices[0]];
+        let all_sector_weight = all_sector_weights[indices[0]];
+        if indices
+            .iter()
+            .any(|index| (weights[*index] - weight).abs() > 0.0)
+        {
+            return Err(RusticolError::invalid_argument(format!(
+                "coherent amplitude group {group_id} has inconsistent raw-sum weights"
+            )));
+        }
+        if indices
+            .iter()
+            .any(|index| (all_sector_weights[*index] - all_sector_weight).abs() > 0.0)
+        {
+            return Err(RusticolError::invalid_argument(format!(
+                "coherent amplitude group {group_id} has inconsistent all-sector raw-sum weights"
+            )));
+        }
+        groups.push(RawSumGroup {
+            id: group_id,
+            sector_ids: unique_color_sector_ids(&indices, color_sector_ids),
+            indices,
+            weight,
+            all_sector_weight,
+        });
+    }
+    Ok(groups)
+}
+
+fn build_color_topology_replay_amplitude_runtime(
+    manifest: Option<&GenericColorTopologyReplayAmplitudeManifest>,
+    contraction_manifest: Option<&GenericColorContractionManifest>,
+    materialized_groups: &[RawSumGroup],
+) -> RusticolResult<Option<ColorTopologyReplayAmplitudeRuntime>> {
+    let Some(manifest) = manifest else {
+        return Ok(None);
+    };
+    if manifest.contract_version != 1
+        || manifest.physical_group_count == 0
+        || manifest.physical_groups.len() != manifest.physical_group_count
+        || manifest.mappings.is_empty()
+    {
+        return Err(RusticolError::artifact(
+            "color topology replay amplitude gather has an invalid header",
+        ));
+    }
+    let source_index_by_id = materialized_groups
+        .iter()
+        .enumerate()
+        .map(|(index, group)| (group.id, index))
+        .collect::<BTreeMap<_, _>>();
+    if source_index_by_id.len() != materialized_groups.len() {
+        return Err(RusticolError::artifact(
+            "color topology replay materialized coherent-group ids are not unique",
+        ));
+    }
+    let mut physical_groups = Vec::with_capacity(manifest.physical_group_count);
+    let mut physical_group_helicities = Vec::with_capacity(manifest.physical_group_count);
+    for (index, group) in manifest.physical_groups.iter().enumerate() {
+        if group.group_id != index as i64
+            || group.color_sector_id < 0
+            || group.color_word.is_empty()
+            || group.helicities.is_empty()
+            || !group.helicity_weight.is_finite()
+            || group.helicity_weight <= 0.0
+        {
+            return Err(RusticolError::artifact(
+                "color topology replay physical coherent-group metadata is invalid",
+            ));
+        }
+        physical_groups.push(RawSumGroup {
+            id: group.group_id,
+            indices: vec![index],
+            weight: group.helicity_weight,
+            all_sector_weight: group.helicity_weight,
+            sector_ids: vec![group.color_sector_id],
+        });
+        physical_group_helicities.push(group.helicities.clone());
+    }
+    let color_contraction =
+        build_color_contraction_runtime(contraction_manifest, &physical_groups)?.ok_or_else(
+            || {
+                RusticolError::artifact(
+                    "color topology replay requires a complete NLC/full color contraction",
+                )
+            },
+        )?;
+    let mut target_coverage = vec![false; manifest.physical_group_count];
+    let mut mappings = Vec::with_capacity(manifest.mappings.len());
+    for mapping in &manifest.mappings {
+        let label_permutation =
+            normalized_color_topology_label_permutation(&mapping.label_permutation)?;
+        if mapping.group_routes.is_empty() {
+            return Err(RusticolError::artifact(
+                "color topology replay mapping contains no amplitude routes",
+            ));
+        }
+        let mut group_routes = Vec::with_capacity(mapping.group_routes.len());
+        let mut mapping_sources = BTreeSet::new();
+        for route in &mapping.group_routes {
+            let source_group_index = source_index_by_id
+                .get(&route.source_group_id)
+                .copied()
+                .ok_or_else(|| {
+                    RusticolError::artifact(
+                        "color topology replay route names an unknown materialized group",
+                    )
+                })?;
+            let target_group_index = usize::try_from(route.target_group_id)
+                .ok()
+                .filter(|index| *index < manifest.physical_group_count)
+                .ok_or_else(|| {
+                    RusticolError::artifact(
+                        "color topology replay route names an unknown physical group",
+                    )
+                })?;
+            let factor = match route.factor.as_slice() {
+                [real, imaginary] if real.is_finite() && imaginary.is_finite() => {
+                    c64(*real, *imaginary)
+                }
+                _ => {
+                    return Err(RusticolError::artifact(
+                        "color topology replay amplitude factor must be finite complex data",
+                    ));
+                }
+            };
+            if factor == c64(0.0, 0.0)
+                || !mapping_sources.insert(source_group_index)
+                || std::mem::replace(&mut target_coverage[target_group_index], true)
+            {
+                return Err(RusticolError::artifact(
+                    "color topology replay amplitude routes are not a bijection",
+                ));
+            }
+            group_routes.push(ColorTopologyReplayAmplitudeGroupRoute {
+                source_group_index,
+                target_group_index,
+                factor,
+            });
+        }
+        group_routes.sort_by_key(|route| route.target_group_index);
+        mappings.push(ColorTopologyReplayAmplitudeMapping {
+            label_permutation,
+            group_routes,
+        });
+    }
+    if target_coverage.iter().any(|covered| !covered) {
+        return Err(RusticolError::artifact(
+            "color topology replay amplitude routes do not cover every physical group",
+        ));
+    }
+    Ok(Some(ColorTopologyReplayAmplitudeRuntime {
+        mappings,
+        physical_groups,
+        physical_group_helicities,
+        color_contraction: Some(color_contraction),
+        unit_weights: vec![1.0; manifest.physical_group_count],
+        no_sector_ids: vec![None; manifest.physical_group_count],
+        physical_group_scratch_f64: Vec::new(),
+        covered_groups: vec![false; manifest.physical_group_count],
+    }))
+}
+
+fn normalized_color_topology_label_permutation(
+    values: &[LcTopologyReplayLabelPermutationManifest],
+) -> RusticolResult<Vec<(usize, usize)>> {
+    let mut representatives = BTreeSet::new();
+    let mut sectors = BTreeSet::new();
+    let mut mapping = Vec::new();
+    for item in values {
+        if item.representative_label == 0 || item.sector_label == 0 {
+            return Err(RusticolError::artifact(
+                "color topology replay label permutations use one-based labels",
+            ));
+        }
+        let representative = item.representative_label - 1;
+        let sector = item.sector_label - 1;
+        if !representatives.insert(representative) || !sectors.insert(sector) {
+            return Err(RusticolError::artifact(
+                "color topology replay label permutation is not one-to-one",
+            ));
+        }
+        if representative != sector {
+            mapping.push((representative, sector));
+        }
+    }
+    if representatives != sectors {
+        return Err(RusticolError::artifact(
+            "color topology replay label permutation is not a permutation",
+        ));
+    }
+    mapping.sort_unstable();
+    Ok(mapping)
+}
+
+pub(crate) fn unique_color_sector_ids(
+    indices: &[usize],
+    color_sector_ids: &[Option<i64>],
+) -> Vec<i64> {
+    indices
+        .iter()
+        .filter_map(|index| color_sector_ids.get(*index).copied().flatten())
+        .collect::<BTreeSet<_>>()
+        .into_iter()
+        .collect()
+}
+
+pub(crate) fn raw_sum_group_is_selected(
+    group: &RawSumGroup,
+    selected_color_sector_ids: Option<&BTreeSet<i64>>,
+) -> bool {
+    let Some(selected) = selected_color_sector_ids else {
+        return true;
+    };
+    group
+        .sector_ids
+        .iter()
+        .any(|sector_id| selected.contains(sector_id))
+}
+
+pub(crate) fn raw_sum_index_is_selected(
+    sector_id: Option<i64>,
+    selected_color_sector_ids: Option<&BTreeSet<i64>>,
+) -> bool {
+    let Some(selected) = selected_color_sector_ids else {
+        return true;
+    };
+    sector_id
+        .map(|value| selected.contains(&value))
+        .unwrap_or(false)
+}
+
+pub(crate) fn build_color_contraction_runtime(
+    manifest: Option<&GenericColorContractionManifest>,
+    groups: &[RawSumGroup],
+) -> RusticolResult<Option<ColorContractionRuntime>> {
+    let Some(manifest) = manifest else {
+        return Ok(None);
+    };
+    if !manifest.supported {
+        return Err(RusticolError::invalid_argument(format!(
+            "generic colour contraction is unsupported: {}",
+            manifest
+                .reason
+                .as_deref()
+                .unwrap_or("no diagnostic was provided")
+        )));
+    }
+    let group_index_by_id = groups
+        .iter()
+        .enumerate()
+        .map(|(index, group)| (group.id, index))
+        .collect::<BTreeMap<_, _>>();
+    if group_index_by_id.len() != manifest.group_count {
+        return Err(RusticolError::invalid_argument(format!(
+            "colour contraction declares {} groups but runtime has {} coherent groups",
+            manifest.group_count,
+            group_index_by_id.len()
+        )));
+    }
+    if let Some(repeated) = manifest.repeated_block.as_ref() {
+        if !manifest.entries.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "colour contraction cannot mix expanded entries with a repeated block",
+            ));
+        }
+        if repeated.component_count < 2 {
+            return Err(RusticolError::invalid_argument(
+                "repeated colour contraction must contain at least two components",
+            ));
+        }
+        if repeated.component_group_ids.len() != manifest.group_count
+            || repeated.component_group_ids.len() % repeated.component_count != 0
+        {
+            return Err(RusticolError::invalid_argument(
+                "repeated colour contraction group mapping has an inconsistent shape",
+            ));
+        }
+        let groups_per_component = repeated.component_group_ids.len() / repeated.component_count;
+        if groups_per_component == 0 {
+            return Err(RusticolError::invalid_argument(
+                "repeated colour contraction components cannot be empty",
+            ));
+        }
+        let mut mapped_group_ids = BTreeSet::new();
+        let mut component_group_indices = Vec::with_capacity(manifest.group_count);
+        for group_id in &repeated.component_group_ids {
+            if !mapped_group_ids.insert(*group_id) {
+                return Err(RusticolError::invalid_argument(
+                    "repeated colour contraction maps a coherent group more than once",
+                ));
+            }
+            component_group_indices.push(*group_index_by_id.get(group_id).ok_or_else(|| {
+                RusticolError::invalid_argument(format!(
+                    "repeated colour contraction references unknown group {group_id}"
+                ))
+            })?);
+        }
+        let mut entries = Vec::with_capacity(repeated.entries.len());
+        for entry in &repeated.entries {
+            if entry.weight.len() != 2 {
+                return Err(RusticolError::invalid_argument(
+                    "repeated colour contraction weight must have two components",
+                ));
+            }
+            if entry.left_group_index >= groups_per_component
+                || entry.right_group_index >= groups_per_component
+            {
+                return Err(RusticolError::invalid_argument(
+                    "repeated colour contraction entry index is out of bounds",
+                ));
+            }
+            entries.push(ColorContractionEntry {
+                left_group_index: entry.left_group_index,
+                right_group_index: entry.right_group_index,
+                weight_re: entry.weight.first().copied().unwrap_or(0.0),
+                weight_im: entry.weight.get(1).copied().unwrap_or(0.0),
+                symmetry_factor: entry.symmetry_factor,
+            });
+        }
+        let (walsh_block, c2k_walsh_block) = build_walsh_color_contraction_blocks(
+            repeated.factorized_block.as_ref(),
+            groups_per_component,
+            &entries,
+        )?;
+        return Ok(Some(ColorContractionRuntime::from_repeated_block(
+            groups,
+            repeated.component_count,
+            component_group_indices,
+            entries,
+            walsh_block,
+            c2k_walsh_block,
+        )));
+    }
+    let mut entries = Vec::with_capacity(manifest.entries.len());
+    for entry in &manifest.entries {
+        let left_group_index = *group_index_by_id.get(&entry.left_group_id).ok_or_else(|| {
+            RusticolError::invalid_argument(format!(
+                "colour contraction references unknown left group {}",
+                entry.left_group_id
+            ))
+        })?;
+        let right_group_index = *group_index_by_id
+            .get(&entry.right_group_id)
+            .ok_or_else(|| {
+                RusticolError::invalid_argument(format!(
+                    "colour contraction references unknown right group {}",
+                    entry.right_group_id
+                ))
+            })?;
+        let weight_re = entry.weight.first().copied().unwrap_or(0.0);
+        let weight_im = entry.weight.get(1).copied().unwrap_or(0.0);
+        entries.push(ColorContractionEntry {
+            left_group_index,
+            right_group_index,
+            weight_re,
+            weight_im,
+            symmetry_factor: entry.symmetry_factor,
+        });
+    }
+    Ok(Some(ColorContractionRuntime::new(groups, entries)))
+}
+
+pub(crate) fn build_compiled_symmetric_group_color_contraction_runtime(
+    manifest: Option<&GenericColorContractionManifest>,
+    groups: &[RawSumGroup],
+    plan: crate::recurrence::RecurrenceColorContraction,
+) -> RusticolResult<ColorContractionRuntime> {
+    let manifest = manifest.ok_or_else(|| {
+        RusticolError::integrity("compiled symmetric-group FFT payload has no contraction metadata")
+    })?;
+    if !manifest.supported
+        || manifest.group_count != groups.len()
+        || !manifest.entries.is_empty()
+        || manifest.repeated_block.is_some()
+    {
+        return Err(RusticolError::integrity(
+            "compiled symmetric-group FFT metadata disagrees with coherent groups",
+        ));
+    }
+    if plan.accuracy() != crate::recurrence::RecurrenceColorAccuracy::Full
+        || plan.storage() != crate::recurrence::RecurrenceColorStorage::ConvolutionKernels
+        || plan.component_count() != 1
+        || plan.group_count() as usize != groups.len()
+        || plan.local_group_count() as usize != groups.len()
+        || plan.destination_count() as usize != groups.len()
+        || plan.active_sector_count() != groups.len()
+        || !matches!(
+            plan.runtime_reducer(),
+            Some(crate::recurrence::RuntimeColorContractionReducer::SymmetricGroupFourier(_))
+        )
+    {
+        return Err(RusticolError::compatibility(
+            "compiled symmetric-group FFT diagnostic payload is not a one-component FullColour active-sector convolution",
+        ));
+    }
+    let group_index_by_id = groups
+        .iter()
+        .enumerate()
+        .map(|(index, group)| (group.id, index))
+        .collect::<BTreeMap<_, _>>();
+    if group_index_by_id.len() != groups.len() {
+        return Err(RusticolError::integrity(
+            "compiled symmetric-group FFT coherent group IDs are not unique",
+        ));
+    }
+    let mut ordered_group_indices = Vec::with_capacity(groups.len());
+    let mut covered = BTreeSet::new();
+    for local_group in 0..groups.len() {
+        let destination_id = plan.ordered_destination_id(local_group, 0).ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled symmetric-group FFT local group has no coherent destination",
+            )
+        })?;
+        let group_index = *group_index_by_id
+            .get(&i64::from(destination_id))
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "compiled symmetric-group FFT references unknown coherent group {destination_id}"
+                ))
+            })?;
+        if !covered.insert(group_index) {
+            return Err(RusticolError::integrity(
+                "compiled symmetric-group FFT maps a coherent group more than once",
+            ));
+        }
+        let ordered_group_id = *plan.ordered_group_ids().get(local_group).ok_or_else(|| {
+            RusticolError::integrity("compiled symmetric-group FFT ordered group map is incomplete")
+        })? as usize;
+        let sector_id = *plan
+            .sector_by_group()
+            .get(ordered_group_id)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "compiled symmetric-group FFT ordered sector map is incomplete",
+                )
+            })?;
+        if groups[group_index].sector_ids.as_slice() != [i64::from(sector_id)] {
+            return Err(RusticolError::integrity(
+                "compiled symmetric-group FFT coherent group sector identity disagrees with its payload",
+            ));
+        }
+        ordered_group_indices.push(group_index);
+    }
+    if covered.len() != groups.len() {
+        return Err(RusticolError::integrity(
+            "compiled symmetric-group FFT does not exhaust coherent groups",
+        ));
+    }
+    Ok(ColorContractionRuntime::from_symmetric_group(
+        groups,
+        plan,
+        ordered_group_indices,
+    ))
+}
+
+fn build_walsh_color_contraction_blocks(
+    manifest: Option<&GenericFactorizedColorContractionBlockManifest>,
+    local_group_count: usize,
+    entries: &[ColorContractionEntry],
+) -> RusticolResult<(
+    Option<WalshColorContractionBlock>,
+    Option<C2kWalshColorContractionBlock>,
+)> {
+    let Some(manifest) = manifest else {
+        return Ok((None, None));
+    };
+    match manifest {
+        GenericFactorizedColorContractionBlockManifest::KleinFourWalsh { cosets } => Ok((
+            Some(build_klein_four_walsh_color_contraction_block(
+                cosets,
+                local_group_count,
+                entries,
+            )?),
+            None,
+        )),
+        GenericFactorizedColorContractionBlockManifest::ElementaryAbelianWalsh { rank, cosets } => {
+            Ok((
+                None,
+                Some(build_c2k_walsh_color_contraction_block(
+                    *rank,
+                    cosets,
+                    local_group_count,
+                    entries,
+                )?),
+            ))
+        }
+    }
+}
+
+fn build_klein_four_walsh_color_contraction_block(
+    cosets: &[[usize; 4]],
+    local_group_count: usize,
+    entries: &[ColorContractionEntry],
+) -> RusticolResult<WalshColorContractionBlock> {
+    let mapped_group_count = cosets.len().checked_mul(4).ok_or_else(|| {
+        RusticolError::invalid_argument("factorized color contraction coset count overflows")
+    })?;
+    if cosets.is_empty() || mapped_group_count != local_group_count {
+        return Err(RusticolError::invalid_argument(
+            "factorized color contraction cosets do not match local groups",
+        ));
+    }
+    let mut mapped_groups = vec![false; local_group_count];
+    for coset in cosets {
+        for local_group_index in coset {
+            let Some(mapped) = mapped_groups.get_mut(*local_group_index) else {
+                return Err(RusticolError::invalid_argument(
+                    "factorized color contraction coset index is out of bounds",
+                ));
+            };
+            if *mapped {
+                return Err(RusticolError::invalid_argument(
+                    "factorized color contraction cosets contain a duplicate index",
+                ));
+            }
+            *mapped = true;
+        }
+    }
+
+    let matrix_size = local_group_count
+        .checked_mul(local_group_count)
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("factorized color contraction matrix size overflows")
+        })?;
+    let mut matrix = vec![0.0; matrix_size];
+    let mut seen_pairs = BTreeSet::new();
+    for entry in entries {
+        if entry.weight_im != 0.0 {
+            return Err(RusticolError::invalid_argument(
+                "factorized color contraction requires real weights",
+            ));
+        }
+        if !entry.weight_re.is_finite() || !entry.symmetry_factor.is_finite() {
+            return Err(RusticolError::invalid_argument(
+                "factorized color contraction weights must be finite",
+            ));
+        }
+        let (left, right) = if entry.left_group_index <= entry.right_group_index {
+            (entry.left_group_index, entry.right_group_index)
+        } else {
+            (entry.right_group_index, entry.left_group_index)
+        };
+        if !seen_pairs.insert((left, right)) {
+            return Err(RusticolError::invalid_argument(
+                "factorized color contraction has a duplicate matrix entry",
+            ));
+        }
+        let weight = if left == right {
+            entry.symmetry_factor * entry.weight_re
+        } else {
+            0.5 * entry.symmetry_factor * entry.weight_re
+        };
+        if !weight.is_finite() {
+            return Err(RusticolError::invalid_argument(
+                "factorized color contraction matrix weight is not finite",
+            ));
+        }
+        matrix[left * local_group_count + right] = weight;
+        matrix[right * local_group_count + left] = weight;
+    }
+
+    for left_coset in cosets {
+        for right_coset in cosets {
+            for left_subgroup_index in 0..4 {
+                for right_subgroup_index in 0..4 {
+                    let actual = matrix[left_coset[left_subgroup_index] * local_group_count
+                        + right_coset[right_subgroup_index]];
+                    let expected = matrix[left_coset[0] * local_group_count
+                        + right_coset[left_subgroup_index ^ right_subgroup_index]];
+                    if actual != expected {
+                        return Err(RusticolError::invalid_argument(
+                            "factorized color contraction matrix is not invariant under its Klein-four action",
+                        ));
+                    }
+                }
+            }
+        }
+    }
+
+    let coset_count = cosets.len();
+    let mut transformed_entries = Vec::new();
+    let characters = [
+        [1.0, 1.0, 1.0, 1.0],
+        [1.0, -1.0, 1.0, -1.0],
+        [1.0, 1.0, -1.0, -1.0],
+        [1.0, -1.0, -1.0, 1.0],
+    ];
+    for (character_index, character) in characters.iter().enumerate() {
+        for left_coset_index in 0..coset_count {
+            for right_coset_index in left_coset_index..coset_count {
+                let left_coset = cosets[left_coset_index];
+                let right_coset = cosets[right_coset_index];
+                let values = [
+                    matrix[left_coset[0] * local_group_count + right_coset[0]],
+                    matrix[left_coset[0] * local_group_count + right_coset[1]],
+                    matrix[left_coset[0] * local_group_count + right_coset[2]],
+                    matrix[left_coset[0] * local_group_count + right_coset[3]],
+                ];
+                let mut weight = 0.0;
+                for (sign, value) in character.iter().zip(values) {
+                    weight += sign * value;
+                }
+                if !weight.is_finite() {
+                    return Err(RusticolError::invalid_argument(
+                        "factorized color contraction Walsh weight is not finite",
+                    ));
+                }
+                if weight == 0.0 {
+                    continue;
+                }
+                transformed_entries.push(ColorContractionEntry {
+                    left_group_index: character_index * coset_count + left_coset_index,
+                    right_group_index: character_index * coset_count + right_coset_index,
+                    weight_re: weight,
+                    weight_im: 0.0,
+                    symmetry_factor: if left_coset_index == right_coset_index {
+                        1.0
+                    } else {
+                        2.0
+                    },
+                });
+            }
+        }
+    }
+    Ok(WalshColorContractionBlock {
+        cosets: cosets.to_vec(),
+        entries: transformed_entries,
+    })
+}
+
+fn build_c2k_walsh_color_contraction_block(
+    rank: usize,
+    cosets: &[Vec<usize>],
+    local_group_count: usize,
+    entries: &[ColorContractionEntry],
+) -> RusticolResult<C2kWalshColorContractionBlock> {
+    if rank < 3 {
+        return Err(RusticolError::invalid_argument(
+            "elementary-Abelian Walsh color contraction rank must be at least three",
+        ));
+    }
+    let shift = u32::try_from(rank).map_err(|_| {
+        RusticolError::invalid_argument(
+            "elementary-Abelian Walsh color contraction rank is too large",
+        )
+    })?;
+    let subgroup_order = 1usize.checked_shl(shift).ok_or_else(|| {
+        RusticolError::invalid_argument(
+            "elementary-Abelian Walsh color contraction subgroup order overflows",
+        )
+    })?;
+    let mapped_group_count = cosets.len().checked_mul(subgroup_order).ok_or_else(|| {
+        RusticolError::invalid_argument("factorized color contraction coset count overflows")
+    })?;
+    if cosets.is_empty()
+        || cosets.iter().any(|coset| coset.len() != subgroup_order)
+        || mapped_group_count != local_group_count
+    {
+        return Err(RusticolError::invalid_argument(
+            "elementary-Abelian Walsh color contraction cosets do not match rank or local groups",
+        ));
+    }
+
+    let mut mapped_groups = vec![false; local_group_count];
+    for coset in cosets {
+        for local_group_index in coset {
+            let Some(mapped) = mapped_groups.get_mut(*local_group_index) else {
+                return Err(RusticolError::invalid_argument(
+                    "factorized color contraction coset index is out of bounds",
+                ));
+            };
+            if *mapped {
+                return Err(RusticolError::invalid_argument(
+                    "factorized color contraction cosets contain a duplicate index",
+                ));
+            }
+            *mapped = true;
+        }
+    }
+    if mapped_groups.iter().any(|mapped| !mapped) {
+        return Err(RusticolError::invalid_argument(
+            "factorized color contraction cosets do not partition local groups",
+        ));
+    }
+
+    let matrix_size = local_group_count
+        .checked_mul(local_group_count)
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("factorized color contraction matrix size overflows")
+        })?;
+    let mut matrix = vec![0.0; matrix_size];
+    let mut seen_pairs = BTreeSet::new();
+    for entry in entries {
+        if entry.weight_im != 0.0 {
+            return Err(RusticolError::invalid_argument(
+                "factorized color contraction requires real weights",
+            ));
+        }
+        if !entry.weight_re.is_finite() || !entry.symmetry_factor.is_finite() {
+            return Err(RusticolError::invalid_argument(
+                "factorized color contraction weights must be finite",
+            ));
+        }
+        let (left, right) = if entry.left_group_index <= entry.right_group_index {
+            (entry.left_group_index, entry.right_group_index)
+        } else {
+            (entry.right_group_index, entry.left_group_index)
+        };
+        if !seen_pairs.insert((left, right)) {
+            return Err(RusticolError::invalid_argument(
+                "factorized color contraction has a duplicate matrix entry",
+            ));
+        }
+        let weight = if left == right {
+            entry.symmetry_factor * entry.weight_re
+        } else {
+            0.5 * entry.symmetry_factor * entry.weight_re
+        };
+        if !weight.is_finite() {
+            return Err(RusticolError::invalid_argument(
+                "factorized color contraction matrix weight is not finite",
+            ));
+        }
+        matrix[left * local_group_count + right] = weight;
+        matrix[right * local_group_count + left] = weight;
+    }
+
+    for left_coset in cosets {
+        for right_coset in cosets {
+            for left_subgroup_index in 0..subgroup_order {
+                for right_subgroup_index in 0..subgroup_order {
+                    let actual = matrix[left_coset[left_subgroup_index] * local_group_count
+                        + right_coset[right_subgroup_index]];
+                    let expected = matrix[left_coset[0] * local_group_count
+                        + right_coset[left_subgroup_index ^ right_subgroup_index]];
+                    if actual != expected {
+                        return Err(RusticolError::invalid_argument(
+                            "factorized color contraction matrix is not invariant under its elementary-Abelian XOR action",
+                        ));
+                    }
+                }
+            }
+        }
+    }
+
+    let coset_count = cosets.len();
+    let mut transformed_entries = Vec::new();
+    for left_coset_index in 0..coset_count {
+        for right_coset_index in left_coset_index..coset_count {
+            let left_coset = &cosets[left_coset_index];
+            let right_coset = &cosets[right_coset_index];
+            let mut weights = (0..subgroup_order)
+                .map(|subgroup_index| {
+                    matrix[left_coset[0] * local_group_count + right_coset[subgroup_index]]
+                })
+                .collect::<Vec<_>>();
+            walsh_butterfly_f64(&mut weights);
+            for (character_index, weight) in weights.into_iter().enumerate() {
+                if !weight.is_finite() {
+                    return Err(RusticolError::invalid_argument(
+                        "factorized color contraction Walsh weight is not finite",
+                    ));
+                }
+                if weight == 0.0 {
+                    continue;
+                }
+                transformed_entries.push(ColorContractionEntry {
+                    left_group_index: character_index * coset_count + left_coset_index,
+                    right_group_index: character_index * coset_count + right_coset_index,
+                    // The C2^k runtime deliberately applies the unnormalized
+                    // Walsh transform. H H^T = subgroup_order * I, so carry
+                    // its inverse once in the transformed matrix instead of
+                    // scaling every complex amplitude at every point.
+                    weight_re: weight / subgroup_order as f64,
+                    weight_im: 0.0,
+                    symmetry_factor: if left_coset_index == right_coset_index {
+                        1.0
+                    } else {
+                        2.0
+                    },
+                });
+            }
+        }
+    }
+
+    Ok(C2kWalshColorContractionBlock {
+        subgroup_order,
+        cosets: cosets.to_vec(),
+        entries: transformed_entries,
+    })
+}
+
+fn walsh_butterfly_f64(values: &mut [f64]) {
+    debug_assert!(values.len().is_power_of_two());
+    let mut stride = 1;
+    while stride < values.len() {
+        for start in (0..values.len()).step_by(stride * 2) {
+            for offset in 0..stride {
+                let left = values[start + offset];
+                let right = values[start + stride + offset];
+                values[start + offset] = left + right;
+                values[start + stride + offset] = left - right;
+            }
+        }
+        stride *= 2;
+    }
+}
+
+pub(crate) fn generic_root_group_id(
+    root: &GenericAmplitudeRootManifest,
+) -> RusticolResult<Option<i64>> {
+    let Some(value) = root.coherent_group_id.as_ref() else {
+        return Ok(None);
+    };
+    if value.is_null() {
+        return Ok(None);
+    }
+    if let Some(group_id) = value.as_i64() {
+        return Ok(Some(group_id));
+    }
+    if let Some(group_id) = value.as_u64() {
+        return i64::try_from(group_id)
+            .map(Some)
+            .map_err(|_| RusticolError::invalid_argument("generic coherent group id exceeds i64"));
+    }
+    if let Some(text) = value.as_str() {
+        return text.parse::<i64>().map(Some).map_err(|err| {
+            RusticolError::invalid_argument(format!(
+                "could not parse generic coherent group id {text:?}: {err}"
+            ))
+        });
+    }
+    Err(RusticolError::invalid_argument(format!(
+        "generic coherent group id for root {} must be an integer or string",
+        root.root_id
+    )))
+}
+
+#[cfg(test)]
+mod selected_axis_position_tests {
+    use super::*;
+
+    #[test]
+    fn sparse_and_complete_axis_positions_match_without_resizing_sparse_scratch() {
+        let mut dense = vec![Some(usize::MAX); 17];
+        for selected in [&[8][..], &[][..]] {
+            let positions = SelectedAxisPositions::new(selected, 10, &mut dense);
+            assert!(matches!(positions, SelectedAxisPositions::Sparse(_)));
+            for index in 0..10 {
+                assert_eq!(
+                    positions.position(index),
+                    selected.iter().position(|&i| i == index)
+                );
+            }
+            assert_eq!(dense, vec![Some(usize::MAX); 17]);
+        }
+        for selected in [vec![1, 4, 8], (1..10).collect(), (0..10).collect()] {
+            let positions = SelectedAxisPositions::new(&selected, 10, &mut dense);
+            assert!(matches!(positions, SelectedAxisPositions::Dense(_)));
+            for index in 0..10 {
+                assert_eq!(
+                    positions.position(index),
+                    selected.iter().position(|&i| i == index)
+                );
+            }
+            assert_eq!(dense.len(), 10);
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/backend.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/backend.rs
new file mode 100644
index 0000000000..d94078962c
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/backend.rs
@@ -0,0 +1,2803 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::super::*;
+use super::*;
+
+impl EvaluatorGroup {
+    pub(crate) fn load(manifest: &EvaluatorManifest, root: &Path) -> RusticolResult<Self> {
+        let payloads = EvaluatorPayloadStore::directory(root);
+        Self::load_from_store(manifest, &payloads)
+    }
+
+    pub(crate) fn load_from_store(
+        manifest: &EvaluatorManifest,
+        payloads: &EvaluatorPayloadStore,
+    ) -> RusticolResult<Self> {
+        ensure_evaluator_capabilities_supported(manifest)?;
+        let (input_len, _) = manifest.io_len()?;
+        let leaf_layout = manifest.leaf_layout()?;
+        let mut evaluators = Vec::new();
+        let mut input_mappings = Vec::new();
+        for leaf in &leaf_layout {
+            let before = evaluators.len();
+            flatten_evaluators_from_store(leaf.evaluator, payloads, &mut evaluators)?;
+            if evaluators.len() != before + 1 {
+                return Err(RusticolError::integrity(
+                    "canonical evaluator leaf layout did not load exactly one evaluator",
+                ));
+            }
+            let mapping = if leaf.input_indices.len() == input_len
+                && leaf
+                    .input_indices
+                    .iter()
+                    .enumerate()
+                    .all(|(expected, index)| expected == *index)
+            {
+                None
+            } else {
+                Some(leaf.input_indices.clone())
+            };
+            input_mappings.push(mapping);
+        }
+        let input_mapping_spans = input_mappings
+            .iter()
+            .map(|mapping| {
+                mapping
+                    .as_deref()
+                    .map(contiguous_input_spans)
+                    .unwrap_or_default()
+            })
+            .collect();
+        let output_len = leaf_layout.last().map_or(0, |leaf| leaf.output_range.end);
+        Ok(Self {
+            evaluators,
+            input_len,
+            input_mappings,
+            input_mapping_spans,
+            output_len,
+            chunk_parameter_scratch_f64: Vec::new(),
+            chunk_scratch_f64: Vec::new(),
+            chunk_parameter_scratch_aosoa_f64: Vec::new(),
+            chunk_scratch_aosoa_f64: Vec::new(),
+            chunk_input_mapping_scratch: Vec::new(),
+        })
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(crate) fn load_exact_from_plane(
+        stage: &GenericSerializedStageEvaluatorManifest,
+        payloads: &EvaluatorPayloadStore,
+    ) -> RusticolResult<Self> {
+        let manifest = &stage.evaluator;
+        let direct = stage.compiled_plane_arena.as_ref().ok_or_else(|| {
+            RusticolError::integrity(
+                "compiled plane-arena exact evaluator has no serialized bindings",
+            )
+        })?;
+        let (input_len, _) = manifest.io_len()?;
+        let leaf_layout = manifest.leaf_layout()?;
+        if leaf_layout.len() != direct.leaves.len() {
+            return Err(RusticolError::integrity(
+                "compiled plane-arena exact leaf bindings are incomplete",
+            ));
+        }
+        let mut evaluators = Vec::new();
+        let mut input_mappings = Vec::new();
+        for (leaf, binding) in leaf_layout.iter().zip(&direct.leaves) {
+            flatten_exact_evaluators_from_store(leaf.evaluator, payloads, &mut evaluators)?;
+            let mapping = if binding.input_indices.len() == input_len
+                && binding
+                    .input_indices
+                    .iter()
+                    .enumerate()
+                    .all(|(expected, index)| expected == *index)
+            {
+                None
+            } else {
+                Some(binding.input_indices.clone())
+            };
+            input_mappings.push(mapping);
+        }
+        let input_mapping_spans = input_mappings
+            .iter()
+            .map(|mapping| {
+                mapping
+                    .as_deref()
+                    .map(contiguous_input_spans)
+                    .unwrap_or_default()
+            })
+            .collect();
+        let output_len = direct.leaves.last().map_or(0, |leaf| leaf.output_stop);
+        Ok(Self {
+            evaluators,
+            input_len,
+            input_mappings,
+            input_mapping_spans,
+            output_len,
+            chunk_parameter_scratch_f64: Vec::new(),
+            chunk_scratch_f64: Vec::new(),
+            chunk_parameter_scratch_aosoa_f64: Vec::new(),
+            chunk_scratch_aosoa_f64: Vec::new(),
+            chunk_input_mapping_scratch: Vec::new(),
+        })
+    }
+
+    pub(crate) fn uses_simd_jit(&self) -> bool {
+        self.evaluators
+            .iter()
+            .any(|evaluator| match &evaluator.eval {
+                #[cfg(feature = "symbolica-runtime")]
+                F64Evaluator::ExactOnly => false,
+                #[cfg(feature = "f64-symjit")]
+                F64Evaluator::SymjitApplication(_) => true,
+                #[cfg(feature = "symbolica-runtime")]
+                F64Evaluator::Jit(_) => true,
+                #[cfg(feature = "f64-compiled")]
+                F64Evaluator::Compiled(_) => false,
+            })
+    }
+
+    pub(crate) fn evaluate_batch(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+    ) -> RusticolResult<Vec<Complex<f64>>> {
+        let mut out = Vec::new();
+        self.evaluate_batch_into(batch_size, params, &mut out)?;
+        Ok(out)
+    }
+
+    pub(crate) fn evaluate_single_row(
+        &mut self,
+        params: &[Complex<f64>],
+    ) -> RusticolResult<Vec<Complex<f64>>> {
+        self.evaluate_batch(1, params)
+    }
+
+    pub(crate) fn output_chunk_lengths(&self) -> Vec<usize> {
+        self.evaluators
+            .iter()
+            .map(|evaluator| evaluator.output_len)
+            .collect()
+    }
+
+    pub(crate) fn is_chunked(&self) -> bool {
+        self.evaluators.len() > 1
+    }
+
+    pub(crate) fn evaluate_chunks_f64_into_state(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        state_parameter_count: usize,
+        state: &mut [Complex<f64>],
+        chunk_outputs: &[Vec<(usize, usize)>],
+        chunk_output_spans: &[Vec<(usize, usize, usize)>],
+    ) -> RusticolResult<()> {
+        if chunk_outputs.len() != self.evaluators.len()
+            || chunk_output_spans.len() != self.evaluators.len()
+        {
+            return Err(RusticolError::invalid_argument(
+                "stage chunk-output layout does not match evaluator chunks",
+            ));
+        }
+        let expected_state_len = batch_size
+            .checked_mul(state_parameter_count)
+            .ok_or_else(|| RusticolError::invalid_argument("stage state length overflows usize"))?;
+        if state.len() != expected_state_len {
+            return Err(RusticolError::invalid_argument(format!(
+                "stage state has length {}, expected {expected_state_len}",
+                state.len()
+            )));
+        }
+        if params.len() != batch_size * self.input_len {
+            return Err(RusticolError::invalid_argument(format!(
+                "parameter buffer has length {}, expected {}",
+                params.len(),
+                batch_size * self.input_len
+            )));
+        }
+        for ((((evaluator, input_mapping), input_spans), outputs), spans) in self
+            .evaluators
+            .iter_mut()
+            .zip(&self.input_mappings)
+            .zip(&self.input_mapping_spans)
+            .zip(chunk_outputs)
+            .zip(chunk_output_spans)
+        {
+            if let Some(lane_width) = evaluator
+                .simd_lane_width()
+                .filter(|lane_width| *lane_width > 1 && batch_size >= *lane_width)
+            {
+                let mapping = input_mapping.as_deref();
+                let block_count = pack_f64_parameters_aosoa(
+                    params,
+                    batch_size,
+                    self.input_len,
+                    evaluator.input_len,
+                    lane_width,
+                    mapping,
+                    &mut self.chunk_parameter_scratch_aosoa_f64,
+                )?;
+                self.chunk_scratch_aosoa_f64.resize(
+                    aosoa_scalar_len(block_count, evaluator.output_len, lane_width, "output")?,
+                    0.0,
+                );
+                if evaluator.evaluate_f64_aosoa_blocks(
+                    block_count,
+                    &self.chunk_parameter_scratch_aosoa_f64,
+                    &mut self.chunk_scratch_aosoa_f64,
+                )? {
+                    scatter_f64_aosoa_outputs_to_state(
+                        &self.chunk_scratch_aosoa_f64,
+                        batch_size,
+                        evaluator.output_len,
+                        lane_width,
+                        state_parameter_count,
+                        state,
+                        outputs,
+                        spans,
+                    )?;
+                    continue;
+                }
+            }
+            let evaluator_params = mapped_f64_parameters(
+                params,
+                batch_size,
+                self.input_len,
+                input_mapping.as_deref(),
+                input_spans,
+                &mut self.chunk_parameter_scratch_f64,
+            );
+            validate_leaf_parameter_length(evaluator, batch_size, evaluator_params)?;
+            self.chunk_scratch_f64
+                .resize(batch_size * evaluator.output_len, c64(0.0, 0.0));
+            evaluator.evaluate_f64_batch_unpadded(
+                batch_size,
+                evaluator_params,
+                &mut self.chunk_scratch_f64,
+            )?;
+            for row in 0..batch_size {
+                let row_state = row * state_parameter_count;
+                let row_eval = row * evaluator.output_len;
+                if spans.is_empty() {
+                    for (column, state_offset) in outputs {
+                        state[row_state + *state_offset] =
+                            self.chunk_scratch_f64[row_eval + *column];
+                    }
+                } else {
+                    for (column_start, state_offset_start, len) in spans {
+                        let source_start = row_eval + *column_start;
+                        let target_start = row_state + *state_offset_start;
+                        state[target_start..target_start + *len].copy_from_slice(
+                            &self.chunk_scratch_f64[source_start..source_start + *len],
+                        );
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn evaluate_chunks_f64_into_state_profile(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        state_parameter_count: usize,
+        state: &mut [Complex<f64>],
+        chunk_outputs: &[Vec<(usize, usize)>],
+        chunk_output_spans: &[Vec<(usize, usize, usize)>],
+    ) -> RusticolResult<(EvaluatorBatchProfile, f64)> {
+        if chunk_outputs.len() != self.evaluators.len()
+            || chunk_output_spans.len() != self.evaluators.len()
+        {
+            return Err(RusticolError::invalid_argument(
+                "stage chunk-output layout does not match evaluator chunks",
+            ));
+        }
+        let expected_state_len = batch_size
+            .checked_mul(state_parameter_count)
+            .ok_or_else(|| RusticolError::invalid_argument("stage state length overflows usize"))?;
+        if state.len() != expected_state_len {
+            return Err(RusticolError::invalid_argument(format!(
+                "stage state has length {}, expected {expected_state_len}",
+                state.len()
+            )));
+        }
+
+        // Keep timing state out of floating-point registers while generated
+        // evaluators execute. Some native evaluator ABIs use the full SIMD
+        // register file, whereas Duration remains integer-backed.
+        let mut leaf_input_pack_elapsed = Duration::ZERO;
+        let mut evaluator_elapsed = Duration::ZERO;
+        let mut leaf_input_copy_component_count = 0u64;
+        let mut backend_call_count = 0u64;
+        let mut scratch_reallocation_count = 0u64;
+        let mut assign_elapsed = Duration::ZERO;
+        if params.len() != batch_size * self.input_len {
+            return Err(RusticolError::invalid_argument(format!(
+                "parameter buffer has length {}, expected {}",
+                params.len(),
+                batch_size * self.input_len
+            )));
+        }
+        for ((((evaluator, input_mapping), input_spans), outputs), spans) in self
+            .evaluators
+            .iter_mut()
+            .zip(&self.input_mappings)
+            .zip(&self.input_mapping_spans)
+            .zip(chunk_outputs)
+            .zip(chunk_output_spans)
+        {
+            if let Some(lane_width) = evaluator
+                .simd_lane_width()
+                .filter(|lane_width| *lane_width > 1 && batch_size >= *lane_width)
+            {
+                let parameter_capacity = self.chunk_parameter_scratch_aosoa_f64.capacity();
+                let leaf_start = Instant::now();
+                let mapping = input_mapping.as_deref();
+                let block_count = pack_f64_parameters_aosoa(
+                    params,
+                    batch_size,
+                    self.input_len,
+                    evaluator.input_len,
+                    lane_width,
+                    mapping,
+                    &mut self.chunk_parameter_scratch_aosoa_f64,
+                )?;
+                leaf_input_pack_elapsed += leaf_start.elapsed();
+                leaf_input_copy_component_count +=
+                    (self.chunk_parameter_scratch_aosoa_f64.len() / 2) as u64;
+                scratch_reallocation_count += u64::from(
+                    self.chunk_parameter_scratch_aosoa_f64.capacity() != parameter_capacity,
+                );
+
+                let output_capacity = self.chunk_scratch_aosoa_f64.capacity();
+                self.chunk_scratch_aosoa_f64.resize(
+                    aosoa_scalar_len(block_count, evaluator.output_len, lane_width, "output")?,
+                    0.0,
+                );
+                scratch_reallocation_count +=
+                    u64::from(self.chunk_scratch_aosoa_f64.capacity() != output_capacity);
+                let eval_start = Instant::now();
+                let evaluated = evaluator.evaluate_f64_aosoa_blocks(
+                    block_count,
+                    &self.chunk_parameter_scratch_aosoa_f64,
+                    &mut self.chunk_scratch_aosoa_f64,
+                )?;
+                evaluator_elapsed += eval_start.elapsed();
+                backend_call_count += 1;
+                if evaluated {
+                    let assign_start = Instant::now();
+                    scatter_f64_aosoa_outputs_to_state(
+                        &self.chunk_scratch_aosoa_f64,
+                        batch_size,
+                        evaluator.output_len,
+                        lane_width,
+                        state_parameter_count,
+                        state,
+                        outputs,
+                        spans,
+                    )?;
+                    assign_elapsed += assign_start.elapsed();
+                    continue;
+                }
+            }
+            let leaf_capacity = self.chunk_parameter_scratch_f64.capacity();
+            let leaf_start = Instant::now();
+            let evaluator_params = mapped_f64_parameters(
+                params,
+                batch_size,
+                self.input_len,
+                input_mapping.as_deref(),
+                input_spans,
+                &mut self.chunk_parameter_scratch_f64,
+            );
+            leaf_input_pack_elapsed += leaf_start.elapsed();
+            if input_mapping.is_some() {
+                leaf_input_copy_component_count += evaluator_params.len() as u64;
+            }
+            validate_leaf_parameter_length(evaluator, batch_size, evaluator_params)?;
+            let chunk_capacity = self.chunk_scratch_f64.capacity();
+            self.chunk_scratch_f64
+                .resize(batch_size * evaluator.output_len, c64(0.0, 0.0));
+            let eval_start = Instant::now();
+            evaluator.evaluate_f64_batch_unpadded(
+                batch_size,
+                evaluator_params,
+                &mut self.chunk_scratch_f64,
+            )?;
+            evaluator_elapsed += eval_start.elapsed();
+            backend_call_count += 1;
+            scratch_reallocation_count +=
+                u64::from(self.chunk_scratch_f64.capacity() != chunk_capacity);
+            // The mapped slice is no longer live after the backend call.
+            scratch_reallocation_count +=
+                u64::from(self.chunk_parameter_scratch_f64.capacity() != leaf_capacity);
+
+            let assign_start = Instant::now();
+            for row in 0..batch_size {
+                let row_state = row * state_parameter_count;
+                let row_eval = row * evaluator.output_len;
+                if spans.is_empty() {
+                    for (column, state_offset) in outputs {
+                        state[row_state + *state_offset] =
+                            self.chunk_scratch_f64[row_eval + *column];
+                    }
+                } else {
+                    for (column_start, state_offset_start, len) in spans {
+                        let source_start = row_eval + *column_start;
+                        let target_start = row_state + *state_offset_start;
+                        state[target_start..target_start + *len].copy_from_slice(
+                            &self.chunk_scratch_f64[source_start..source_start + *len],
+                        );
+                    }
+                }
+            }
+            assign_elapsed += assign_start.elapsed();
+        }
+        let leaf_input_pack_s = profile_duration_seconds(leaf_input_pack_elapsed);
+        let evaluator_call_s = profile_duration_seconds(evaluator_elapsed);
+        let profile = EvaluatorBatchProfile {
+            leaf_input_pack_s,
+            legacy_evaluator_call_s: leaf_input_pack_s + evaluator_call_s,
+            evaluator_call_s,
+            leaf_input_copy_component_count,
+            backend_call_count,
+            scratch_reallocation_count,
+            ..EvaluatorBatchProfile::default()
+        };
+        Ok((profile, assign_elapsed.as_secs_f64()))
+    }
+
+    // The explicit slices avoid constructing a descriptor in this selector hot path.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_selected_chunks_f64_into_state(
+        &mut self,
+        batch_size: usize,
+        state_parameter_count: usize,
+        state: &mut [Complex<f64>],
+        parent_input_components: Option<&[usize]>,
+        parent_input_spans: &[(usize, usize, usize)],
+        chunk_outputs: &[Vec<(usize, usize)>],
+        chunk_output_spans: &[Vec<(usize, usize, usize)>],
+        active_chunk_indices: &[usize],
+    ) -> RusticolResult<()> {
+        if chunk_outputs.len() != self.evaluators.len()
+            || chunk_output_spans.len() != self.evaluators.len()
+        {
+            return Err(RusticolError::invalid_argument(
+                "stage chunk-output layout does not match evaluator chunks",
+            ));
+        }
+        validate_active_chunk_indices(active_chunk_indices, self.evaluators.len())?;
+        let expected_state_len = batch_size
+            .checked_mul(state_parameter_count)
+            .ok_or_else(|| RusticolError::invalid_argument("stage state length overflows usize"))?;
+        if state.len() != expected_state_len {
+            return Err(RusticolError::invalid_argument(format!(
+                "stage state has length {}, expected {expected_state_len}",
+                state.len()
+            )));
+        }
+        match parent_input_components {
+            Some(components) => {
+                if components.len() != self.input_len {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "stage input-component map has length {}, expected {}",
+                        components.len(),
+                        self.input_len
+                    )));
+                }
+                if components
+                    .iter()
+                    .any(|component| *component >= state_parameter_count)
+                {
+                    return Err(RusticolError::invalid_argument(
+                        "stage input-component map references state outside the parameter layout",
+                    ));
+                }
+            }
+            None if self.input_len != state_parameter_count => {
+                return Err(RusticolError::invalid_argument(format!(
+                    "evaluator input length {} does not match stage state parameter count {state_parameter_count}",
+                    self.input_len
+                )));
+            }
+            None => {}
+        }
+        for &chunk_index in active_chunk_indices {
+            let evaluator = &mut self.evaluators[chunk_index];
+            if let Some(lane_width) = evaluator
+                .simd_lane_width()
+                .filter(|lane_width| *lane_width > 1 && batch_size >= *lane_width)
+            {
+                let input_mapping = self.input_mappings[chunk_index].as_deref();
+                self.chunk_input_mapping_scratch.clear();
+                self.chunk_input_mapping_scratch
+                    .reserve(evaluator.input_len);
+                for local_component in 0..evaluator.input_len {
+                    let parent_component =
+                        input_mapping.map_or(local_component, |indices| indices[local_component]);
+                    self.chunk_input_mapping_scratch.push(
+                        parent_input_components
+                            .map_or(parent_component, |components| components[parent_component]),
+                    );
+                }
+                let block_count = pack_f64_parameters_aosoa(
+                    state,
+                    batch_size,
+                    state_parameter_count,
+                    evaluator.input_len,
+                    lane_width,
+                    Some(&self.chunk_input_mapping_scratch),
+                    &mut self.chunk_parameter_scratch_aosoa_f64,
+                )?;
+                self.chunk_scratch_aosoa_f64.resize(
+                    aosoa_scalar_len(block_count, evaluator.output_len, lane_width, "output")?,
+                    0.0,
+                );
+                if evaluator.evaluate_f64_aosoa_blocks(
+                    block_count,
+                    &self.chunk_parameter_scratch_aosoa_f64,
+                    &mut self.chunk_scratch_aosoa_f64,
+                )? {
+                    scatter_f64_aosoa_outputs_to_state(
+                        &self.chunk_scratch_aosoa_f64,
+                        batch_size,
+                        evaluator.output_len,
+                        lane_width,
+                        state_parameter_count,
+                        state,
+                        &chunk_outputs[chunk_index],
+                        &chunk_output_spans[chunk_index],
+                    )?;
+                    continue;
+                }
+            }
+            let evaluator_params = selected_chunk_f64_parameters(
+                state,
+                batch_size,
+                state_parameter_count,
+                self.input_len,
+                parent_input_components,
+                parent_input_spans,
+                self.input_mappings[chunk_index].as_deref(),
+                &self.input_mapping_spans[chunk_index],
+                &mut self.chunk_parameter_scratch_f64,
+            )?;
+            validate_leaf_parameter_length(evaluator, batch_size, evaluator_params)?;
+            let scratch_len = batch_size
+                .checked_mul(evaluator.output_len)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument("stage chunk output length overflows usize")
+                })?;
+            self.chunk_scratch_f64.resize(scratch_len, c64(0.0, 0.0));
+            evaluator.evaluate_f64_batch_unpadded(
+                batch_size,
+                evaluator_params,
+                &mut self.chunk_scratch_f64,
+            )?;
+            let outputs = &chunk_outputs[chunk_index];
+            let spans = &chunk_output_spans[chunk_index];
+            for row in 0..batch_size {
+                let row_state = row * state_parameter_count;
+                let row_eval = row * evaluator.output_len;
+                if spans.is_empty() {
+                    for (column, state_offset) in outputs {
+                        state[row_state + *state_offset] =
+                            self.chunk_scratch_f64[row_eval + *column];
+                    }
+                } else {
+                    for (column_start, state_offset_start, len) in spans {
+                        let source_start = row_eval + *column_start;
+                        let target_start = row_state + *state_offset_start;
+                        state[target_start..target_start + *len].copy_from_slice(
+                            &self.chunk_scratch_f64[source_start..source_start + *len],
+                        );
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn evaluate_selected_chunks_f64_into_state_profile(
+        &mut self,
+        batch_size: usize,
+        state_parameter_count: usize,
+        state: &mut [Complex<f64>],
+        parent_input_components: Option<&[usize]>,
+        parent_input_spans: &[(usize, usize, usize)],
+        chunk_outputs: &[Vec<(usize, usize)>],
+        chunk_output_spans: &[Vec<(usize, usize, usize)>],
+        active_chunk_indices: &[usize],
+    ) -> RusticolResult<(EvaluatorBatchProfile, f64)> {
+        if chunk_outputs.len() != self.evaluators.len()
+            || chunk_output_spans.len() != self.evaluators.len()
+        {
+            return Err(RusticolError::invalid_argument(
+                "stage chunk-output layout does not match evaluator chunks",
+            ));
+        }
+        validate_active_chunk_indices(active_chunk_indices, self.evaluators.len())?;
+        let expected_state_len = batch_size
+            .checked_mul(state_parameter_count)
+            .ok_or_else(|| RusticolError::invalid_argument("stage state length overflows usize"))?;
+        if state.len() != expected_state_len {
+            return Err(RusticolError::invalid_argument(format!(
+                "stage state has length {}, expected {expected_state_len}",
+                state.len()
+            )));
+        }
+        match parent_input_components {
+            Some(components) => {
+                if components.len() != self.input_len {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "stage input-component map has length {}, expected {}",
+                        components.len(),
+                        self.input_len
+                    )));
+                }
+                if components
+                    .iter()
+                    .any(|component| *component >= state_parameter_count)
+                {
+                    return Err(RusticolError::invalid_argument(
+                        "stage input-component map references state outside the parameter layout",
+                    ));
+                }
+            }
+            None if self.input_len != state_parameter_count => {
+                return Err(RusticolError::invalid_argument(format!(
+                    "evaluator input length {} does not match stage state parameter count {state_parameter_count}",
+                    self.input_len
+                )));
+            }
+            None => {}
+        }
+
+        let mut input_pack_elapsed = Duration::ZERO;
+        let mut evaluator_elapsed = Duration::ZERO;
+        let mut assign_elapsed = Duration::ZERO;
+        let mut leaf_input_copy_component_count = 0u64;
+        let mut backend_call_count = 0u64;
+        let mut scratch_reallocation_count = 0u64;
+        for &chunk_index in active_chunk_indices {
+            let evaluator = &mut self.evaluators[chunk_index];
+            if let Some(lane_width) = evaluator
+                .simd_lane_width()
+                .filter(|lane_width| *lane_width > 1 && batch_size >= *lane_width)
+            {
+                let parameter_capacity = self.chunk_parameter_scratch_aosoa_f64.capacity();
+                let input_pack_start = Instant::now();
+                let input_mapping = self.input_mappings[chunk_index].as_deref();
+                let mapping_capacity = self.chunk_input_mapping_scratch.capacity();
+                self.chunk_input_mapping_scratch.clear();
+                self.chunk_input_mapping_scratch
+                    .reserve(evaluator.input_len);
+                for local_component in 0..evaluator.input_len {
+                    let parent_component =
+                        input_mapping.map_or(local_component, |indices| indices[local_component]);
+                    self.chunk_input_mapping_scratch.push(
+                        parent_input_components
+                            .map_or(parent_component, |components| components[parent_component]),
+                    );
+                }
+                scratch_reallocation_count +=
+                    u64::from(self.chunk_input_mapping_scratch.capacity() != mapping_capacity);
+                let block_count = pack_f64_parameters_aosoa(
+                    state,
+                    batch_size,
+                    state_parameter_count,
+                    evaluator.input_len,
+                    lane_width,
+                    Some(&self.chunk_input_mapping_scratch),
+                    &mut self.chunk_parameter_scratch_aosoa_f64,
+                )?;
+                input_pack_elapsed += input_pack_start.elapsed();
+                leaf_input_copy_component_count +=
+                    (self.chunk_parameter_scratch_aosoa_f64.len() / 2) as u64;
+                scratch_reallocation_count += u64::from(
+                    self.chunk_parameter_scratch_aosoa_f64.capacity() != parameter_capacity,
+                );
+
+                let output_capacity = self.chunk_scratch_aosoa_f64.capacity();
+                self.chunk_scratch_aosoa_f64.resize(
+                    aosoa_scalar_len(block_count, evaluator.output_len, lane_width, "output")?,
+                    0.0,
+                );
+                scratch_reallocation_count +=
+                    u64::from(self.chunk_scratch_aosoa_f64.capacity() != output_capacity);
+                let eval_start = Instant::now();
+                let evaluated = evaluator.evaluate_f64_aosoa_blocks(
+                    block_count,
+                    &self.chunk_parameter_scratch_aosoa_f64,
+                    &mut self.chunk_scratch_aosoa_f64,
+                )?;
+                evaluator_elapsed += eval_start.elapsed();
+                backend_call_count += 1;
+                if evaluated {
+                    let assign_start = Instant::now();
+                    scatter_f64_aosoa_outputs_to_state(
+                        &self.chunk_scratch_aosoa_f64,
+                        batch_size,
+                        evaluator.output_len,
+                        lane_width,
+                        state_parameter_count,
+                        state,
+                        &chunk_outputs[chunk_index],
+                        &chunk_output_spans[chunk_index],
+                    )?;
+                    assign_elapsed += assign_start.elapsed();
+                    continue;
+                }
+            }
+            let parameter_capacity = self.chunk_parameter_scratch_f64.capacity();
+            let input_pack_start = Instant::now();
+            let evaluator_params = selected_chunk_f64_parameters(
+                state,
+                batch_size,
+                state_parameter_count,
+                self.input_len,
+                parent_input_components,
+                parent_input_spans,
+                self.input_mappings[chunk_index].as_deref(),
+                &self.input_mapping_spans[chunk_index],
+                &mut self.chunk_parameter_scratch_f64,
+            )?;
+            input_pack_elapsed += input_pack_start.elapsed();
+            if parent_input_components.is_some() || self.input_mappings[chunk_index].is_some() {
+                leaf_input_copy_component_count += evaluator_params.len() as u64;
+            }
+
+            validate_leaf_parameter_length(evaluator, batch_size, evaluator_params)?;
+            let scratch_len = batch_size
+                .checked_mul(evaluator.output_len)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument("stage chunk output length overflows usize")
+                })?;
+            let output_capacity = self.chunk_scratch_f64.capacity();
+            self.chunk_scratch_f64.resize(scratch_len, c64(0.0, 0.0));
+            let eval_start = Instant::now();
+            evaluator.evaluate_f64_batch_unpadded(
+                batch_size,
+                evaluator_params,
+                &mut self.chunk_scratch_f64,
+            )?;
+            evaluator_elapsed += eval_start.elapsed();
+            backend_call_count += 1;
+            scratch_reallocation_count +=
+                u64::from(self.chunk_parameter_scratch_f64.capacity() != parameter_capacity)
+                    + u64::from(self.chunk_scratch_f64.capacity() != output_capacity);
+
+            let assign_start = Instant::now();
+            let outputs = &chunk_outputs[chunk_index];
+            let spans = &chunk_output_spans[chunk_index];
+            for row in 0..batch_size {
+                let row_state = row * state_parameter_count;
+                let row_eval = row * evaluator.output_len;
+                if spans.is_empty() {
+                    for (column, state_offset) in outputs {
+                        state[row_state + *state_offset] =
+                            self.chunk_scratch_f64[row_eval + *column];
+                    }
+                } else {
+                    for (column_start, state_offset_start, len) in spans {
+                        let source_start = row_eval + *column_start;
+                        let target_start = row_state + *state_offset_start;
+                        state[target_start..target_start + *len].copy_from_slice(
+                            &self.chunk_scratch_f64[source_start..source_start + *len],
+                        );
+                    }
+                }
+            }
+            assign_elapsed += assign_start.elapsed();
+        }
+        let leaf_input_pack_s = profile_duration_seconds(input_pack_elapsed);
+        let evaluator_call_s = profile_duration_seconds(evaluator_elapsed);
+        Ok((
+            EvaluatorBatchProfile {
+                leaf_input_pack_s,
+                legacy_evaluator_call_s: evaluator_call_s,
+                evaluator_call_s,
+                leaf_input_copy_component_count,
+                backend_call_count,
+                scratch_reallocation_count,
+                ..EvaluatorBatchProfile::default()
+            },
+            profile_duration_seconds(assign_elapsed),
+        ))
+    }
+
+    pub(crate) fn evaluate_selected_chunks_f64_into_output(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        parent_input_components: Option<&[usize]>,
+        parent_input_spans: &[(usize, usize, usize)],
+        out: &mut Vec<Complex<f64>>,
+        active_chunk_indices: &[usize],
+    ) -> RusticolResult<()> {
+        validate_active_chunk_indices(active_chunk_indices, self.evaluators.len())?;
+        if batch_size == 0 || !params.len().is_multiple_of(batch_size) {
+            return Err(RusticolError::invalid_argument(
+                "amplitude evaluator parameter buffer has an inconsistent batch size",
+            ));
+        }
+        let state_parameter_count = params.len() / batch_size;
+        match parent_input_components {
+            Some(components) => {
+                if components.len() != self.input_len
+                    || components
+                        .iter()
+                        .any(|component| *component >= state_parameter_count)
+                {
+                    return Err(RusticolError::invalid_argument(
+                        "amplitude input-component map is inconsistent with runtime state",
+                    ));
+                }
+            }
+            None if self.input_len != state_parameter_count => {
+                return Err(RusticolError::invalid_argument(format!(
+                    "evaluator input length {} does not match amplitude state parameter count {state_parameter_count}",
+                    self.input_len
+                )));
+            }
+            None => {}
+        }
+        let output_len = batch_size
+            .checked_mul(self.output_len)
+            .ok_or_else(|| RusticolError::invalid_argument("amplitude output length overflows"))?;
+        out.resize(output_len, c64(0.0, 0.0));
+        out.fill(c64(0.0, 0.0));
+
+        let mut output_start = 0usize;
+        for chunk_index in 0..self.evaluators.len() {
+            let evaluator_output_len = self.evaluators[chunk_index].output_len;
+            if active_chunk_indices.binary_search(&chunk_index).is_ok() {
+                let evaluator = &mut self.evaluators[chunk_index];
+                let mut evaluated_aosoa = false;
+                if let Some(lane_width) = evaluator
+                    .amplitude_aosoa_lane_width()
+                    .filter(|lane_width| *lane_width > 1 && batch_size >= *lane_width)
+                {
+                    let input_mapping = self.input_mappings[chunk_index].as_deref();
+                    self.chunk_input_mapping_scratch.clear();
+                    self.chunk_input_mapping_scratch
+                        .reserve(evaluator.input_len);
+                    for local_component in 0..evaluator.input_len {
+                        let parent_component = input_mapping
+                            .map_or(local_component, |indices| indices[local_component]);
+                        self.chunk_input_mapping_scratch.push(
+                            parent_input_components.map_or(parent_component, |components| {
+                                components[parent_component]
+                            }),
+                        );
+                    }
+                    let block_count = pack_f64_parameters_aosoa(
+                        params,
+                        batch_size,
+                        state_parameter_count,
+                        evaluator.input_len,
+                        lane_width,
+                        Some(&self.chunk_input_mapping_scratch),
+                        &mut self.chunk_parameter_scratch_aosoa_f64,
+                    )?;
+                    self.chunk_scratch_aosoa_f64.resize(
+                        aosoa_scalar_len(block_count, evaluator.output_len, lane_width, "output")?,
+                        0.0,
+                    );
+                    if evaluator.evaluate_f64_aosoa_blocks(
+                        block_count,
+                        &self.chunk_parameter_scratch_aosoa_f64,
+                        &mut self.chunk_scratch_aosoa_f64,
+                    )? {
+                        scatter_f64_aosoa_outputs_to_rows(
+                            &self.chunk_scratch_aosoa_f64,
+                            batch_size,
+                            evaluator.output_len,
+                            lane_width,
+                            self.output_len,
+                            output_start,
+                            out,
+                        )?;
+                        evaluated_aosoa = true;
+                    }
+                }
+                if !evaluated_aosoa {
+                    let evaluator_params = selected_chunk_f64_parameters(
+                        params,
+                        batch_size,
+                        state_parameter_count,
+                        self.input_len,
+                        parent_input_components,
+                        parent_input_spans,
+                        self.input_mappings[chunk_index].as_deref(),
+                        &self.input_mapping_spans[chunk_index],
+                        &mut self.chunk_parameter_scratch_f64,
+                    )?;
+                    validate_leaf_parameter_length(evaluator, batch_size, evaluator_params)?;
+                    self.chunk_scratch_f64.resize(
+                        batch_size
+                            .checked_mul(evaluator_output_len)
+                            .ok_or_else(|| {
+                                RusticolError::invalid_argument(
+                                    "amplitude chunk output length overflows usize",
+                                )
+                            })?,
+                        c64(0.0, 0.0),
+                    );
+                    evaluator.evaluate_f64_batch_unpadded(
+                        batch_size,
+                        evaluator_params,
+                        &mut self.chunk_scratch_f64,
+                    )?;
+                    for row in 0..batch_size {
+                        let source_start = row * evaluator_output_len;
+                        let target_start = row * self.output_len + output_start;
+                        out[target_start..target_start + evaluator_output_len].copy_from_slice(
+                            &self.chunk_scratch_f64
+                                [source_start..source_start + evaluator_output_len],
+                        );
+                    }
+                }
+            }
+            output_start = output_start
+                .checked_add(evaluator_output_len)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument("amplitude chunk output range overflows")
+                })?;
+        }
+        if output_start != self.output_len {
+            return Err(RusticolError::integrity(
+                "amplitude evaluator chunk outputs do not cover the declared output length",
+            ));
+        }
+        Ok(())
+    }
+
+    pub(crate) fn evaluate_selected_chunks_f64_into_output_profile(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        parent_input_components: Option<&[usize]>,
+        parent_input_spans: &[(usize, usize, usize)],
+        out: &mut Vec<Complex<f64>>,
+        active_chunk_indices: &[usize],
+    ) -> RusticolResult<EvaluatorBatchProfile> {
+        validate_active_chunk_indices(active_chunk_indices, self.evaluators.len())?;
+        if batch_size == 0 || !params.len().is_multiple_of(batch_size) {
+            return Err(RusticolError::invalid_argument(
+                "amplitude evaluator parameter buffer has an inconsistent batch size",
+            ));
+        }
+        let state_parameter_count = params.len() / batch_size;
+        match parent_input_components {
+            Some(components) => {
+                if components.len() != self.input_len
+                    || components
+                        .iter()
+                        .any(|component| *component >= state_parameter_count)
+                {
+                    return Err(RusticolError::invalid_argument(
+                        "amplitude input-component map is inconsistent with runtime state",
+                    ));
+                }
+            }
+            None if self.input_len != state_parameter_count => {
+                return Err(RusticolError::invalid_argument(format!(
+                    "evaluator input length {} does not match amplitude state parameter count {state_parameter_count}",
+                    self.input_len
+                )));
+            }
+            None => {}
+        }
+        let output_len = batch_size
+            .checked_mul(self.output_len)
+            .ok_or_else(|| RusticolError::invalid_argument("amplitude output length overflows"))?;
+        let mut output_gather_elapsed = Duration::ZERO;
+        let output_prepare_start = Instant::now();
+        let output_capacity = out.capacity();
+        out.resize(output_len, c64(0.0, 0.0));
+        out.fill(c64(0.0, 0.0));
+        output_gather_elapsed += output_prepare_start.elapsed();
+        let mut output_gather_component_count = output_len as u64;
+        let mut scratch_reallocation_count = u64::from(out.capacity() != output_capacity);
+
+        let mut chunk_output_starts = Vec::with_capacity(self.evaluators.len());
+        let mut output_start = 0usize;
+        for evaluator in &self.evaluators {
+            chunk_output_starts.push(output_start);
+            output_start = output_start
+                .checked_add(evaluator.output_len)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument("amplitude chunk output range overflows")
+                })?;
+        }
+        if output_start != self.output_len {
+            return Err(RusticolError::integrity(
+                "amplitude evaluator chunk outputs do not cover the declared output length",
+            ));
+        }
+
+        let mut input_pack_elapsed = Duration::ZERO;
+        let mut evaluator_elapsed = Duration::ZERO;
+        let mut leaf_input_copy_component_count = 0u64;
+        let mut backend_call_count = 0u64;
+        for &chunk_index in active_chunk_indices {
+            let evaluator = &mut self.evaluators[chunk_index];
+            if let Some(lane_width) = evaluator
+                .amplitude_aosoa_lane_width()
+                .filter(|lane_width| *lane_width > 1 && batch_size >= *lane_width)
+            {
+                let parameter_capacity = self.chunk_parameter_scratch_aosoa_f64.capacity();
+                let mapping_capacity = self.chunk_input_mapping_scratch.capacity();
+                let input_pack_start = Instant::now();
+                let input_mapping = self.input_mappings[chunk_index].as_deref();
+                self.chunk_input_mapping_scratch.clear();
+                self.chunk_input_mapping_scratch
+                    .reserve(evaluator.input_len);
+                for local_component in 0..evaluator.input_len {
+                    let parent_component =
+                        input_mapping.map_or(local_component, |indices| indices[local_component]);
+                    self.chunk_input_mapping_scratch.push(
+                        parent_input_components
+                            .map_or(parent_component, |components| components[parent_component]),
+                    );
+                }
+                let block_count = pack_f64_parameters_aosoa(
+                    params,
+                    batch_size,
+                    state_parameter_count,
+                    evaluator.input_len,
+                    lane_width,
+                    Some(&self.chunk_input_mapping_scratch),
+                    &mut self.chunk_parameter_scratch_aosoa_f64,
+                )?;
+                input_pack_elapsed += input_pack_start.elapsed();
+                leaf_input_copy_component_count +=
+                    (self.chunk_parameter_scratch_aosoa_f64.len() / 2) as u64;
+                scratch_reallocation_count +=
+                    u64::from(
+                        self.chunk_parameter_scratch_aosoa_f64.capacity() != parameter_capacity,
+                    ) + u64::from(self.chunk_input_mapping_scratch.capacity() != mapping_capacity);
+
+                let chunk_capacity = self.chunk_scratch_aosoa_f64.capacity();
+                self.chunk_scratch_aosoa_f64.resize(
+                    aosoa_scalar_len(block_count, evaluator.output_len, lane_width, "output")?,
+                    0.0,
+                );
+                scratch_reallocation_count +=
+                    u64::from(self.chunk_scratch_aosoa_f64.capacity() != chunk_capacity);
+                let eval_start = Instant::now();
+                let evaluated = evaluator.evaluate_f64_aosoa_blocks(
+                    block_count,
+                    &self.chunk_parameter_scratch_aosoa_f64,
+                    &mut self.chunk_scratch_aosoa_f64,
+                )?;
+                evaluator_elapsed += eval_start.elapsed();
+                backend_call_count += 1;
+                if evaluated {
+                    let output_gather_start = Instant::now();
+                    scatter_f64_aosoa_outputs_to_rows(
+                        &self.chunk_scratch_aosoa_f64,
+                        batch_size,
+                        evaluator.output_len,
+                        lane_width,
+                        self.output_len,
+                        chunk_output_starts[chunk_index],
+                        out,
+                    )?;
+                    output_gather_elapsed += output_gather_start.elapsed();
+                    output_gather_component_count += (batch_size * evaluator.output_len) as u64;
+                    continue;
+                }
+            }
+            let parameter_capacity = self.chunk_parameter_scratch_f64.capacity();
+            let input_pack_start = Instant::now();
+            let evaluator_params = selected_chunk_f64_parameters(
+                params,
+                batch_size,
+                state_parameter_count,
+                self.input_len,
+                parent_input_components,
+                parent_input_spans,
+                self.input_mappings[chunk_index].as_deref(),
+                &self.input_mapping_spans[chunk_index],
+                &mut self.chunk_parameter_scratch_f64,
+            )?;
+            input_pack_elapsed += input_pack_start.elapsed();
+            if parent_input_components.is_some() || self.input_mappings[chunk_index].is_some() {
+                leaf_input_copy_component_count += evaluator_params.len() as u64;
+            }
+
+            validate_leaf_parameter_length(evaluator, batch_size, evaluator_params)?;
+            let chunk_capacity = self.chunk_scratch_f64.capacity();
+            self.chunk_scratch_f64.resize(
+                batch_size
+                    .checked_mul(evaluator.output_len)
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(
+                            "amplitude chunk output length overflows usize",
+                        )
+                    })?,
+                c64(0.0, 0.0),
+            );
+            let eval_start = Instant::now();
+            evaluator.evaluate_f64_batch_unpadded(
+                batch_size,
+                evaluator_params,
+                &mut self.chunk_scratch_f64,
+            )?;
+            evaluator_elapsed += eval_start.elapsed();
+            backend_call_count += 1;
+            scratch_reallocation_count +=
+                u64::from(self.chunk_parameter_scratch_f64.capacity() != parameter_capacity)
+                    + u64::from(self.chunk_scratch_f64.capacity() != chunk_capacity);
+            let output_gather_start = Instant::now();
+            let chunk_output_start = chunk_output_starts[chunk_index];
+            for row in 0..batch_size {
+                let source_start = row * evaluator.output_len;
+                let target_start = row * self.output_len + chunk_output_start;
+                out[target_start..target_start + evaluator.output_len].copy_from_slice(
+                    &self.chunk_scratch_f64[source_start..source_start + evaluator.output_len],
+                );
+            }
+            output_gather_elapsed += output_gather_start.elapsed();
+            output_gather_component_count += (batch_size * evaluator.output_len) as u64;
+        }
+        let leaf_input_pack_s = profile_duration_seconds(input_pack_elapsed);
+        let evaluator_call_s = profile_duration_seconds(evaluator_elapsed);
+        let output_gather_s = profile_duration_seconds(output_gather_elapsed);
+        Ok(EvaluatorBatchProfile {
+            leaf_input_pack_s,
+            legacy_evaluator_call_s: evaluator_call_s + output_gather_s,
+            evaluator_call_s,
+            output_gather_s,
+            leaf_input_copy_component_count,
+            output_gather_component_count,
+            backend_call_count,
+            scratch_reallocation_count,
+        })
+    }
+
+    pub(crate) fn evaluate_batch_into(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        out: &mut Vec<Complex<f64>>,
+    ) -> RusticolResult<()> {
+        self.evaluate_batch_into_unprofiled(batch_size, params, out, false)
+    }
+
+    pub(crate) fn evaluate_batch_into_padded_simd_tail(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        out: &mut Vec<Complex<f64>>,
+    ) -> RusticolResult<()> {
+        self.evaluate_batch_into_unprofiled(batch_size, params, out, true)
+    }
+
+    fn evaluate_batch_into_unprofiled(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        out: &mut Vec<Complex<f64>>,
+        pad_incomplete_simd_tail: bool,
+    ) -> RusticolResult<()> {
+        let expected_output_len = batch_size * self.output_len;
+        if out.len() != expected_output_len {
+            out.resize(expected_output_len, c64(0.0, 0.0));
+        }
+        if params.len() != batch_size * self.input_len {
+            return Err(RusticolError::invalid_argument(format!(
+                "parameter buffer has length {}, expected {}",
+                params.len(),
+                batch_size * self.input_len
+            )));
+        }
+        if self.evaluators.len() == 1 {
+            let evaluator = &mut self.evaluators[0];
+            if let Some(lane_width) = evaluator
+                .amplitude_aosoa_lane_width()
+                .filter(|lane_width| *lane_width > 1 && batch_size >= *lane_width)
+            {
+                let block_count = pack_f64_parameters_aosoa(
+                    params,
+                    batch_size,
+                    self.input_len,
+                    evaluator.input_len,
+                    lane_width,
+                    self.input_mappings[0].as_deref(),
+                    &mut self.chunk_parameter_scratch_aosoa_f64,
+                )?;
+                self.chunk_scratch_aosoa_f64.resize(
+                    aosoa_scalar_len(block_count, evaluator.output_len, lane_width, "output")?,
+                    0.0,
+                );
+                if evaluator.evaluate_f64_aosoa_blocks(
+                    block_count,
+                    &self.chunk_parameter_scratch_aosoa_f64,
+                    &mut self.chunk_scratch_aosoa_f64,
+                )? {
+                    scatter_f64_aosoa_outputs_to_rows(
+                        &self.chunk_scratch_aosoa_f64,
+                        batch_size,
+                        evaluator.output_len,
+                        lane_width,
+                        self.output_len,
+                        0,
+                        out,
+                    )?;
+                    return Ok(());
+                }
+            }
+            let evaluator_params = mapped_f64_parameters(
+                params,
+                batch_size,
+                self.input_len,
+                self.input_mappings[0].as_deref(),
+                &self.input_mapping_spans[0],
+                &mut self.chunk_parameter_scratch_f64,
+            );
+            validate_leaf_parameter_length(evaluator, batch_size, evaluator_params)?;
+            if pad_incomplete_simd_tail {
+                evaluator.evaluate_f64_batch(batch_size, evaluator_params, out)?;
+            } else {
+                evaluator.evaluate_f64_batch_unpadded(batch_size, evaluator_params, out)?;
+            }
+            return Ok(());
+        }
+        let mut output_offset = 0;
+        for ((evaluator, input_mapping), input_spans) in self
+            .evaluators
+            .iter_mut()
+            .zip(&self.input_mappings)
+            .zip(&self.input_mapping_spans)
+        {
+            if let Some(lane_width) = evaluator
+                .amplitude_aosoa_lane_width()
+                .filter(|lane_width| *lane_width > 1 && batch_size >= *lane_width)
+            {
+                let block_count = pack_f64_parameters_aosoa(
+                    params,
+                    batch_size,
+                    self.input_len,
+                    evaluator.input_len,
+                    lane_width,
+                    input_mapping.as_deref(),
+                    &mut self.chunk_parameter_scratch_aosoa_f64,
+                )?;
+                self.chunk_scratch_aosoa_f64.resize(
+                    aosoa_scalar_len(block_count, evaluator.output_len, lane_width, "output")?,
+                    0.0,
+                );
+                if evaluator.evaluate_f64_aosoa_blocks(
+                    block_count,
+                    &self.chunk_parameter_scratch_aosoa_f64,
+                    &mut self.chunk_scratch_aosoa_f64,
+                )? {
+                    scatter_f64_aosoa_outputs_to_rows(
+                        &self.chunk_scratch_aosoa_f64,
+                        batch_size,
+                        evaluator.output_len,
+                        lane_width,
+                        self.output_len,
+                        output_offset,
+                        out,
+                    )?;
+                    output_offset += evaluator.output_len;
+                    continue;
+                }
+            }
+            let evaluator_params = mapped_f64_parameters(
+                params,
+                batch_size,
+                self.input_len,
+                input_mapping.as_deref(),
+                input_spans,
+                &mut self.chunk_parameter_scratch_f64,
+            );
+            validate_leaf_parameter_length(evaluator, batch_size, evaluator_params)?;
+            self.chunk_scratch_f64
+                .resize(batch_size * evaluator.output_len, c64(0.0, 0.0));
+            if pad_incomplete_simd_tail {
+                evaluator.evaluate_f64_batch(
+                    batch_size,
+                    evaluator_params,
+                    &mut self.chunk_scratch_f64,
+                )?;
+            } else {
+                evaluator.evaluate_f64_batch_unpadded(
+                    batch_size,
+                    evaluator_params,
+                    &mut self.chunk_scratch_f64,
+                )?;
+            }
+            for row in 0..batch_size {
+                let src = row * evaluator.output_len;
+                let dst = row * self.output_len + output_offset;
+                out[dst..dst + evaluator.output_len]
+                    .copy_from_slice(&self.chunk_scratch_f64[src..src + evaluator.output_len]);
+            }
+            output_offset += evaluator.output_len;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn evaluate_batch_into_profile(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        out: &mut Vec<Complex<f64>>,
+        pad_incomplete_simd_tail: bool,
+    ) -> RusticolResult<EvaluatorBatchProfile> {
+        let mut leaf_input_pack_elapsed = Duration::ZERO;
+        let mut evaluator_elapsed = Duration::ZERO;
+        let mut output_gather_elapsed = Duration::ZERO;
+        let mut leaf_input_copy_component_count = 0u64;
+        let mut output_gather_component_count = 0u64;
+        let mut backend_call_count = 0u64;
+        let mut scratch_reallocation_count = 0u64;
+        let expected_output_len = batch_size * self.output_len;
+        let output_capacity = out.capacity();
+        if out.len() != expected_output_len {
+            out.resize(expected_output_len, c64(0.0, 0.0));
+        }
+        scratch_reallocation_count += u64::from(out.capacity() != output_capacity);
+        if params.len() != batch_size * self.input_len {
+            return Err(RusticolError::invalid_argument(format!(
+                "parameter buffer has length {}, expected {}",
+                params.len(),
+                batch_size * self.input_len
+            )));
+        }
+        if self.evaluators.len() == 1 {
+            let evaluator = &mut self.evaluators[0];
+            if let Some(lane_width) = evaluator
+                .amplitude_aosoa_lane_width()
+                .filter(|lane_width| *lane_width > 1 && batch_size >= *lane_width)
+            {
+                let leaf_capacity = self.chunk_parameter_scratch_aosoa_f64.capacity();
+                let leaf_start = Instant::now();
+                let block_count = pack_f64_parameters_aosoa(
+                    params,
+                    batch_size,
+                    self.input_len,
+                    evaluator.input_len,
+                    lane_width,
+                    self.input_mappings[0].as_deref(),
+                    &mut self.chunk_parameter_scratch_aosoa_f64,
+                )?;
+                leaf_input_pack_elapsed += leaf_start.elapsed();
+                leaf_input_copy_component_count +=
+                    (self.chunk_parameter_scratch_aosoa_f64.len() / 2) as u64;
+                scratch_reallocation_count +=
+                    u64::from(self.chunk_parameter_scratch_aosoa_f64.capacity() != leaf_capacity);
+                let chunk_capacity = self.chunk_scratch_aosoa_f64.capacity();
+                self.chunk_scratch_aosoa_f64.resize(
+                    aosoa_scalar_len(block_count, evaluator.output_len, lane_width, "output")?,
+                    0.0,
+                );
+                scratch_reallocation_count +=
+                    u64::from(self.chunk_scratch_aosoa_f64.capacity() != chunk_capacity);
+                let backend_start = Instant::now();
+                let evaluated = evaluator.evaluate_f64_aosoa_blocks(
+                    block_count,
+                    &self.chunk_parameter_scratch_aosoa_f64,
+                    &mut self.chunk_scratch_aosoa_f64,
+                )?;
+                evaluator_elapsed += backend_start.elapsed();
+                backend_call_count += 1;
+                if evaluated {
+                    let gather_start = Instant::now();
+                    scatter_f64_aosoa_outputs_to_rows(
+                        &self.chunk_scratch_aosoa_f64,
+                        batch_size,
+                        evaluator.output_len,
+                        lane_width,
+                        self.output_len,
+                        0,
+                        out,
+                    )?;
+                    output_gather_elapsed += gather_start.elapsed();
+                    output_gather_component_count += (batch_size * evaluator.output_len) as u64;
+                    let leaf_input_pack_s = profile_duration_seconds(leaf_input_pack_elapsed);
+                    let evaluator_call_s = profile_duration_seconds(evaluator_elapsed);
+                    let output_gather_s = profile_duration_seconds(output_gather_elapsed);
+                    return Ok(EvaluatorBatchProfile {
+                        leaf_input_pack_s,
+                        legacy_evaluator_call_s: leaf_input_pack_s
+                            + evaluator_call_s
+                            + output_gather_s,
+                        evaluator_call_s,
+                        output_gather_s,
+                        leaf_input_copy_component_count,
+                        output_gather_component_count,
+                        backend_call_count,
+                        scratch_reallocation_count,
+                    });
+                }
+            }
+            let leaf_capacity = self.chunk_parameter_scratch_f64.capacity();
+            let leaf_start = Instant::now();
+            let evaluator_params = mapped_f64_parameters(
+                params,
+                batch_size,
+                self.input_len,
+                self.input_mappings[0].as_deref(),
+                &self.input_mapping_spans[0],
+                &mut self.chunk_parameter_scratch_f64,
+            );
+            leaf_input_pack_elapsed += leaf_start.elapsed();
+            if self.input_mappings[0].is_some() {
+                leaf_input_copy_component_count += evaluator_params.len() as u64;
+            }
+            validate_leaf_parameter_length(evaluator, batch_size, evaluator_params)?;
+            let backend_start = Instant::now();
+            if pad_incomplete_simd_tail {
+                evaluator.evaluate_f64_batch(batch_size, evaluator_params, out)?;
+            } else {
+                evaluator.evaluate_f64_batch_unpadded(batch_size, evaluator_params, out)?;
+            }
+            evaluator_elapsed += backend_start.elapsed();
+            backend_call_count += 1;
+            scratch_reallocation_count +=
+                u64::from(self.chunk_parameter_scratch_f64.capacity() != leaf_capacity);
+            let leaf_input_pack_s = profile_duration_seconds(leaf_input_pack_elapsed);
+            let evaluator_call_s = profile_duration_seconds(evaluator_elapsed);
+            return Ok(EvaluatorBatchProfile {
+                leaf_input_pack_s,
+                legacy_evaluator_call_s: leaf_input_pack_s + evaluator_call_s,
+                evaluator_call_s,
+                leaf_input_copy_component_count,
+                backend_call_count,
+                scratch_reallocation_count,
+                ..EvaluatorBatchProfile::default()
+            });
+        }
+        let mut output_offset = 0;
+        for ((evaluator, input_mapping), input_spans) in self
+            .evaluators
+            .iter_mut()
+            .zip(&self.input_mappings)
+            .zip(&self.input_mapping_spans)
+        {
+            if let Some(lane_width) = evaluator
+                .amplitude_aosoa_lane_width()
+                .filter(|lane_width| *lane_width > 1 && batch_size >= *lane_width)
+            {
+                let leaf_capacity = self.chunk_parameter_scratch_aosoa_f64.capacity();
+                let leaf_start = Instant::now();
+                let block_count = pack_f64_parameters_aosoa(
+                    params,
+                    batch_size,
+                    self.input_len,
+                    evaluator.input_len,
+                    lane_width,
+                    input_mapping.as_deref(),
+                    &mut self.chunk_parameter_scratch_aosoa_f64,
+                )?;
+                leaf_input_pack_elapsed += leaf_start.elapsed();
+                leaf_input_copy_component_count +=
+                    (self.chunk_parameter_scratch_aosoa_f64.len() / 2) as u64;
+                scratch_reallocation_count +=
+                    u64::from(self.chunk_parameter_scratch_aosoa_f64.capacity() != leaf_capacity);
+                let chunk_capacity = self.chunk_scratch_aosoa_f64.capacity();
+                self.chunk_scratch_aosoa_f64.resize(
+                    aosoa_scalar_len(block_count, evaluator.output_len, lane_width, "output")?,
+                    0.0,
+                );
+                scratch_reallocation_count +=
+                    u64::from(self.chunk_scratch_aosoa_f64.capacity() != chunk_capacity);
+                let backend_start = Instant::now();
+                let evaluated = evaluator.evaluate_f64_aosoa_blocks(
+                    block_count,
+                    &self.chunk_parameter_scratch_aosoa_f64,
+                    &mut self.chunk_scratch_aosoa_f64,
+                )?;
+                evaluator_elapsed += backend_start.elapsed();
+                backend_call_count += 1;
+                if evaluated {
+                    let gather_start = Instant::now();
+                    scatter_f64_aosoa_outputs_to_rows(
+                        &self.chunk_scratch_aosoa_f64,
+                        batch_size,
+                        evaluator.output_len,
+                        lane_width,
+                        self.output_len,
+                        output_offset,
+                        out,
+                    )?;
+                    output_gather_elapsed += gather_start.elapsed();
+                    output_gather_component_count += (batch_size * evaluator.output_len) as u64;
+                    output_offset += evaluator.output_len;
+                    continue;
+                }
+            }
+            let leaf_capacity = self.chunk_parameter_scratch_f64.capacity();
+            let leaf_start = Instant::now();
+            let evaluator_params = mapped_f64_parameters(
+                params,
+                batch_size,
+                self.input_len,
+                input_mapping.as_deref(),
+                input_spans,
+                &mut self.chunk_parameter_scratch_f64,
+            );
+            leaf_input_pack_elapsed += leaf_start.elapsed();
+            if input_mapping.is_some() {
+                leaf_input_copy_component_count += evaluator_params.len() as u64;
+            }
+            validate_leaf_parameter_length(evaluator, batch_size, evaluator_params)?;
+            let chunk_capacity = self.chunk_scratch_f64.capacity();
+            self.chunk_scratch_f64
+                .resize(batch_size * evaluator.output_len, c64(0.0, 0.0));
+            scratch_reallocation_count +=
+                u64::from(self.chunk_scratch_f64.capacity() != chunk_capacity);
+            let backend_start = Instant::now();
+            if pad_incomplete_simd_tail {
+                evaluator.evaluate_f64_batch(
+                    batch_size,
+                    evaluator_params,
+                    &mut self.chunk_scratch_f64,
+                )?;
+            } else {
+                evaluator.evaluate_f64_batch_unpadded(
+                    batch_size,
+                    evaluator_params,
+                    &mut self.chunk_scratch_f64,
+                )?;
+            }
+            evaluator_elapsed += backend_start.elapsed();
+            backend_call_count += 1;
+            scratch_reallocation_count +=
+                u64::from(self.chunk_parameter_scratch_f64.capacity() != leaf_capacity);
+            let gather_start = Instant::now();
+            for row in 0..batch_size {
+                let src = row * evaluator.output_len;
+                let dst = row * self.output_len + output_offset;
+                out[dst..dst + evaluator.output_len]
+                    .copy_from_slice(&self.chunk_scratch_f64[src..src + evaluator.output_len]);
+            }
+            output_gather_elapsed += gather_start.elapsed();
+            output_gather_component_count += (batch_size * evaluator.output_len) as u64;
+            output_offset += evaluator.output_len;
+        }
+        let leaf_input_pack_s = profile_duration_seconds(leaf_input_pack_elapsed);
+        let evaluator_call_s = profile_duration_seconds(evaluator_elapsed);
+        let output_gather_s = profile_duration_seconds(output_gather_elapsed);
+        Ok(EvaluatorBatchProfile {
+            leaf_input_pack_s,
+            legacy_evaluator_call_s: leaf_input_pack_s + evaluator_call_s + output_gather_s,
+            evaluator_call_s,
+            output_gather_s,
+            leaf_input_copy_component_count,
+            output_gather_component_count,
+            backend_call_count,
+            scratch_reallocation_count,
+        })
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(crate) fn evaluate_selected_chunks_generic<T>(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<T>],
+        binary_precision: Option<u32>,
+        active_chunk_indices: Option<&[usize]>,
+    ) -> RusticolResult<Vec<Complex<T>>>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        if let Some(indices) = active_chunk_indices {
+            validate_active_chunk_indices(indices, self.evaluators.len())?;
+        }
+        let mut out = vec![complex_zero::<T>(); batch_size * self.output_len];
+        if params.len() != batch_size * self.input_len {
+            return Err(RusticolError::invalid_argument(format!(
+                "parameter buffer has length {}, expected {}",
+                params.len(),
+                batch_size * self.input_len
+            )));
+        }
+        let mut output_offset = 0;
+        let mut active_position = 0;
+        for (chunk_index, (evaluator, input_mapping)) in self
+            .evaluators
+            .iter_mut()
+            .zip(&self.input_mappings)
+            .enumerate()
+        {
+            if let Some(indices) = active_chunk_indices {
+                if indices.get(active_position) != Some(&chunk_index) {
+                    output_offset += evaluator.output_len;
+                    continue;
+                }
+                active_position += 1;
+            }
+            let mapped_params = input_mapping.as_ref().map(|indices| {
+                let mut mapped = Vec::with_capacity(batch_size * indices.len());
+                for row in 0..batch_size {
+                    let row_start = row * self.input_len;
+                    mapped.extend(
+                        indices
+                            .iter()
+                            .map(|index| params[row_start + *index].clone()),
+                    );
+                }
+                mapped
+            });
+            let evaluator_params = mapped_params.as_deref().unwrap_or(params);
+            let mut chunk_out = vec![complex_zero::<T>(); batch_size * evaluator.output_len];
+            for row in 0..batch_size {
+                let in_start = row * evaluator.input_len;
+                let out_start = row * evaluator.output_len;
+                T::evaluate_loaded(
+                    evaluator,
+                    &evaluator_params[in_start..in_start + evaluator.input_len],
+                    &mut chunk_out[out_start..out_start + evaluator.output_len],
+                    binary_precision,
+                )?;
+            }
+            for row in 0..batch_size {
+                let src = row * evaluator.output_len;
+                let dst = row * self.output_len + output_offset;
+                out[dst..dst + evaluator.output_len]
+                    .clone_from_slice(&chunk_out[src..src + evaluator.output_len]);
+            }
+            output_offset += evaluator.output_len;
+        }
+        Ok(out)
+    }
+}
+
+fn aosoa_scalar_len(
+    block_count: usize,
+    component_count: usize,
+    lane_width: usize,
+    label: &str,
+) -> RusticolResult<usize> {
+    block_count
+        .checked_mul(component_count)
+        .and_then(|len| len.checked_mul(2))
+        .and_then(|len| len.checked_mul(lane_width))
+        .ok_or_else(|| {
+            RusticolError::invalid_argument(format!("{label} AoSoA buffer length overflows usize"))
+        })
+}
+
+fn pack_f64_parameters_aosoa(
+    source: &[Complex<f64>],
+    batch_size: usize,
+    source_parameter_count: usize,
+    leaf_input_len: usize,
+    lane_width: usize,
+    input_components: Option<&[usize]>,
+    scratch: &mut Vec<f64>,
+) -> RusticolResult<usize> {
+    if batch_size == 0 || lane_width <= 1 {
+        return Err(RusticolError::invalid_argument(
+            "AoSoA parameter packing requires a non-empty SIMD batch",
+        ));
+    }
+    let expected_source_len = batch_size
+        .checked_mul(source_parameter_count)
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("source parameter length overflows usize")
+        })?;
+    if source.len() != expected_source_len {
+        return Err(RusticolError::invalid_argument(format!(
+            "source parameter buffer has length {}, expected {expected_source_len}",
+            source.len()
+        )));
+    }
+    match input_components {
+        Some(components)
+            if components.len() != leaf_input_len
+                || components
+                    .iter()
+                    .any(|component| *component >= source_parameter_count) =>
+        {
+            return Err(RusticolError::integrity(
+                "AoSoA leaf input mapping is inconsistent with source parameters",
+            ));
+        }
+        None if leaf_input_len != source_parameter_count => {
+            return Err(RusticolError::integrity(
+                "AoSoA identity leaf input length does not match source parameters",
+            ));
+        }
+        Some(_) | None => {}
+    }
+    let block_count = batch_size.div_ceil(lane_width);
+    scratch.resize(
+        aosoa_scalar_len(block_count, leaf_input_len, lane_width, "parameter")?,
+        0.0,
+    );
+    match lane_width {
+        // SAFETY: the checks above establish every source component and the
+        // complete destination length required by the fixed-lane packers.
+        2 => unsafe {
+            pack_f64_parameters_aosoa_lanes::<2>(
+                source,
+                batch_size,
+                source_parameter_count,
+                leaf_input_len,
+                input_components,
+                scratch,
+            )
+        },
+        // SAFETY: see the lane-2 branch.
+        4 => unsafe {
+            pack_f64_parameters_aosoa_lanes::<4>(
+                source,
+                batch_size,
+                source_parameter_count,
+                leaf_input_len,
+                input_components,
+                scratch,
+            )
+        },
+        // SAFETY: see the lane-2 branch.
+        8 => unsafe {
+            pack_f64_parameters_aosoa_lanes::<8>(
+                source,
+                batch_size,
+                source_parameter_count,
+                leaf_input_len,
+                input_components,
+                scratch,
+            )
+        },
+        _ => pack_f64_parameters_aosoa_dynamic(
+            source,
+            batch_size,
+            source_parameter_count,
+            leaf_input_len,
+            lane_width,
+            input_components,
+            scratch,
+        ),
+    }
+    Ok(block_count)
+}
+
+/// # Safety
+///
+/// `source` must contain `batch_size * source_parameter_count` elements,
+/// `input_components` must contain `leaf_input_len` in-range indices when
+/// present, and `scratch` must contain the complete padded AoSoA destination.
+unsafe fn pack_f64_parameters_aosoa_lanes<const LANES: usize>(
+    source: &[Complex<f64>],
+    batch_size: usize,
+    source_parameter_count: usize,
+    leaf_input_len: usize,
+    input_components: Option<&[usize]>,
+    scratch: &mut [f64],
+) {
+    let block_count = batch_size.div_ceil(LANES);
+    let source_ptr = source.as_ptr();
+    let target_ptr = scratch.as_mut_ptr();
+    for block in 0..block_count {
+        let first_row = block * LANES;
+        for local_component in 0..leaf_input_len {
+            let component =
+                input_components.map_or(local_component, |components| components[local_component]);
+            let target = (block * leaf_input_len + local_component) * 2 * LANES;
+            for lane in 0..LANES {
+                let row = (first_row + lane).min(batch_size - 1);
+                // SAFETY: the caller validated the complete source and target
+                // lengths plus every mapped component before entering this
+                // fixed-lane hot loop.
+                unsafe {
+                    let value = *source_ptr.add(row * source_parameter_count + component);
+                    *target_ptr.add(target + lane) = value.re;
+                    *target_ptr.add(target + LANES + lane) = value.im;
+                }
+            }
+        }
+    }
+}
+
+fn pack_f64_parameters_aosoa_dynamic(
+    source: &[Complex<f64>],
+    batch_size: usize,
+    source_parameter_count: usize,
+    leaf_input_len: usize,
+    lane_width: usize,
+    input_components: Option<&[usize]>,
+    scratch: &mut [f64],
+) {
+    let block_count = batch_size.div_ceil(lane_width);
+    let scalar_stride = lane_width * 2;
+    for block in 0..block_count {
+        let first_row = block * lane_width;
+        for local_component in 0..leaf_input_len {
+            let component =
+                input_components.map_or(local_component, |components| components[local_component]);
+            let target = (block * leaf_input_len + local_component) * scalar_stride;
+            for lane in 0..lane_width {
+                let row = (first_row + lane).min(batch_size - 1);
+                let value = source[row * source_parameter_count + component];
+                scratch[target + lane] = value.re;
+                scratch[target + lane_width + lane] = value.im;
+            }
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn scatter_f64_aosoa_outputs_to_state(
+    outputs_aosoa: &[f64],
+    batch_size: usize,
+    evaluator_output_len: usize,
+    lane_width: usize,
+    state_parameter_count: usize,
+    state: &mut [Complex<f64>],
+    outputs: &[(usize, usize)],
+    spans: &[(usize, usize, usize)],
+) -> RusticolResult<()> {
+    let expected_state_len = batch_size
+        .checked_mul(state_parameter_count)
+        .ok_or_else(|| RusticolError::invalid_argument("stage state length overflows usize"))?;
+    if state.len() != expected_state_len {
+        return Err(RusticolError::invalid_argument(format!(
+            "stage state has length {}, expected {expected_state_len}",
+            state.len()
+        )));
+    }
+    let block_count = batch_size.div_ceil(lane_width);
+    let expected_output_len =
+        aosoa_scalar_len(block_count, evaluator_output_len, lane_width, "output")?;
+    if outputs_aosoa.len() != expected_output_len {
+        return Err(RusticolError::integrity(format!(
+            "AoSoA evaluator output has length {}, expected {expected_output_len}",
+            outputs_aosoa.len()
+        )));
+    }
+    let scalar_stride = lane_width * 2;
+    for block in 0..block_count {
+        let first_row = block * lane_width;
+        let valid_lanes = (batch_size - first_row).min(lane_width);
+        for lane in 0..valid_lanes {
+            let row_state = (first_row + lane) * state_parameter_count;
+            if spans.is_empty() {
+                for (column, state_offset) in outputs {
+                    let source = (block * evaluator_output_len + *column) * scalar_stride;
+                    state[row_state + *state_offset] = Complex::new(
+                        outputs_aosoa[source + lane],
+                        outputs_aosoa[source + lane_width + lane],
+                    );
+                }
+            } else {
+                for (column_start, state_offset_start, len) in spans {
+                    for offset in 0..*len {
+                        let source =
+                            (block * evaluator_output_len + column_start + offset) * scalar_stride;
+                        state[row_state + state_offset_start + offset] = Complex::new(
+                            outputs_aosoa[source + lane],
+                            outputs_aosoa[source + lane_width + lane],
+                        );
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn scatter_f64_aosoa_outputs_to_rows(
+    outputs_aosoa: &[f64],
+    batch_size: usize,
+    evaluator_output_len: usize,
+    lane_width: usize,
+    row_output_len: usize,
+    output_offset: usize,
+    out: &mut [Complex<f64>],
+) -> RusticolResult<()> {
+    let expected_output_rows = batch_size.checked_mul(row_output_len).ok_or_else(|| {
+        RusticolError::invalid_argument("amplitude output length overflows usize")
+    })?;
+    if out.len() != expected_output_rows {
+        return Err(RusticolError::invalid_argument(format!(
+            "amplitude output has length {}, expected {expected_output_rows}",
+            out.len()
+        )));
+    }
+    let output_end = output_offset
+        .checked_add(evaluator_output_len)
+        .ok_or_else(|| RusticolError::invalid_argument("amplitude output range overflows usize"))?;
+    if output_end > row_output_len {
+        return Err(RusticolError::integrity(
+            "AoSoA evaluator output range exceeds the amplitude row",
+        ));
+    }
+    let block_count = batch_size.div_ceil(lane_width);
+    let expected_aosoa_len =
+        aosoa_scalar_len(block_count, evaluator_output_len, lane_width, "output")?;
+    if outputs_aosoa.len() != expected_aosoa_len {
+        return Err(RusticolError::integrity(format!(
+            "AoSoA evaluator output has length {}, expected {expected_aosoa_len}",
+            outputs_aosoa.len()
+        )));
+    }
+    let scalar_stride = lane_width * 2;
+    for block in 0..block_count {
+        let first_row = block * lane_width;
+        let valid_lanes = (batch_size - first_row).min(lane_width);
+        for lane in 0..valid_lanes {
+            let row_output = (first_row + lane) * row_output_len + output_offset;
+            for column in 0..evaluator_output_len {
+                let source = (block * evaluator_output_len + column) * scalar_stride;
+                out[row_output + column] = Complex::new(
+                    outputs_aosoa[source + lane],
+                    outputs_aosoa[source + lane_width + lane],
+                );
+            }
+        }
+    }
+    Ok(())
+}
+
+fn mapped_f64_parameters<'a>(
+    params: &'a [Complex<f64>],
+    batch_size: usize,
+    parent_input_len: usize,
+    input_mapping: Option<&[usize]>,
+    input_spans: &[(usize, usize, usize)],
+    scratch: &'a mut Vec<Complex<f64>>,
+) -> &'a [Complex<f64>] {
+    let Some(indices) = input_mapping else {
+        return params;
+    };
+    scratch.resize(batch_size * indices.len(), c64(0.0, 0.0));
+    for row in 0..batch_size {
+        let source_start = row * parent_input_len;
+        let target_start = row * indices.len();
+        if input_spans.is_empty() {
+            for (local_index, parent_index) in indices.iter().enumerate() {
+                scratch[target_start + local_index] = params[source_start + *parent_index];
+            }
+        } else {
+            for (local_start, parent_start, len) in input_spans {
+                let target = target_start + *local_start;
+                let source = source_start + *parent_start;
+                scratch[target..target + *len].copy_from_slice(&params[source..source + *len]);
+            }
+        }
+    }
+    scratch
+}
+
+#[allow(clippy::too_many_arguments, dead_code)]
+fn selected_chunk_f64_parameters<'a>(
+    state: &'a [Complex<f64>],
+    batch_size: usize,
+    state_parameter_count: usize,
+    parent_input_len: usize,
+    parent_input_components: Option<&[usize]>,
+    parent_input_spans: &[(usize, usize, usize)],
+    input_mapping: Option<&[usize]>,
+    input_mapping_spans: &[(usize, usize, usize)],
+    scratch: &'a mut Vec<Complex<f64>>,
+) -> RusticolResult<&'a [Complex<f64>]> {
+    let Some(parent_components) = parent_input_components else {
+        return Ok(mapped_f64_parameters(
+            state,
+            batch_size,
+            state_parameter_count,
+            input_mapping,
+            input_mapping_spans,
+            scratch,
+        ));
+    };
+    let mapped_input_len = input_mapping.map_or(parent_input_len, <[usize]>::len);
+    let scratch_len = batch_size.checked_mul(mapped_input_len).ok_or_else(|| {
+        RusticolError::invalid_argument("selected stage input length overflows usize")
+    })?;
+    scratch.resize(scratch_len, c64(0.0, 0.0));
+    for row in 0..batch_size {
+        let source_start = row * state_parameter_count;
+        let target_start = row * mapped_input_len;
+        if let Some(indices) = input_mapping {
+            for (local_index, parent_index) in indices.iter().copied().enumerate() {
+                scratch[target_start + local_index] =
+                    state[source_start + parent_components[parent_index]];
+            }
+        } else if parent_input_spans.is_empty() {
+            for (local_index, global_index) in parent_components.iter().copied().enumerate() {
+                scratch[target_start + local_index] = state[source_start + global_index];
+            }
+        } else {
+            for (local_start, global_start, len) in parent_input_spans {
+                let target = target_start + *local_start;
+                let source = source_start + *global_start;
+                scratch[target..target + *len].copy_from_slice(&state[source..source + *len]);
+            }
+        }
+    }
+    Ok(scratch)
+}
+
+#[allow(dead_code)]
+fn validate_active_chunk_indices(
+    active_chunk_indices: &[usize],
+    chunk_count: usize,
+) -> RusticolResult<()> {
+    let mut previous = None;
+    for &chunk_index in active_chunk_indices {
+        if chunk_index >= chunk_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "active evaluator chunk index {chunk_index} is outside chunk count {chunk_count}",
+            )));
+        }
+        if previous.is_some_and(|previous| previous >= chunk_index) {
+            return Err(RusticolError::invalid_argument(
+                "active evaluator chunk indices must be strictly increasing",
+            ));
+        }
+        previous = Some(chunk_index);
+    }
+    Ok(())
+}
+
+fn validate_leaf_parameter_length(
+    evaluator: &LoadedEvaluator,
+    batch_size: usize,
+    params: &[Complex<f64>],
+) -> RusticolResult<()> {
+    if params.len() != batch_size * evaluator.input_len {
+        return Err(RusticolError::artifact(format!(
+            "mapped evaluator parameter buffer has length {}, expected {}",
+            params.len(),
+            batch_size * evaluator.input_len
+        )));
+    }
+    Ok(())
+}
+
+impl LoadedEvaluator {
+    #[cfg(feature = "symbolica-runtime")]
+    pub(crate) fn exact_evaluator(
+        &mut self,
+    ) -> RusticolResult<&ExpressionEvaluator<Complex<Rational>>> {
+        if self.exact_eval.is_none() {
+            let source = self.exact_eval_source.as_ref().ok_or_else(|| {
+                RusticolError::invalid_argument(
+                    "high-precision evaluation requires an evaluator-state artifact, but this process artifact has no evaluator_state_path for one or more chunks",
+                )
+            })?;
+            self.exact_eval = Some(load_evaluator_state_source(source)?.1);
+        }
+        Ok(self
+            .exact_eval
+            .as_ref()
+            .expect("exact evaluator initialized from its state path"))
+    }
+
+    fn simd_lane_width(&self) -> Option<usize> {
+        match &self.eval {
+            #[cfg(feature = "symbolica-runtime")]
+            F64Evaluator::ExactOnly => None,
+            #[cfg(feature = "f64-symjit")]
+            F64Evaluator::SymjitApplication(eval) => eval.simd_lane_width(),
+            #[cfg(feature = "f64-compiled")]
+            F64Evaluator::Compiled(_) => None,
+            #[cfg(feature = "symbolica-runtime")]
+            F64Evaluator::Jit(_) => None,
+        }
+    }
+
+    fn amplitude_aosoa_lane_width(&self) -> Option<usize> {
+        // Tiny amplitude leaves (notably LC's common 4 -> 1 kernels) do not
+        // amortize direct packing and scattering. This static shape gate keeps
+        // the portable path for substantive kernels without runtime tuning or
+        // architecture-specific thresholds.
+        const MINIMUM_COMPONENT_FOOTPRINT: usize = 32;
+        if self.input_len.saturating_add(self.output_len) < MINIMUM_COMPONENT_FOOTPRINT {
+            None
+        } else {
+            self.simd_lane_width()
+        }
+    }
+
+    fn evaluate_f64_aosoa_blocks(
+        &self,
+        block_count: usize,
+        params: &[f64],
+        out: &mut [f64],
+    ) -> RusticolResult<bool> {
+        match &self.eval {
+            #[cfg(feature = "symbolica-runtime")]
+            F64Evaluator::ExactOnly => Ok(false),
+            #[cfg(feature = "f64-symjit")]
+            F64Evaluator::SymjitApplication(eval) => {
+                eval.evaluate_aosoa_blocks(block_count, params, out)
+            }
+            #[cfg(feature = "f64-compiled")]
+            F64Evaluator::Compiled(_) => Ok(false),
+            #[cfg(feature = "symbolica-runtime")]
+            F64Evaluator::Jit(_) => Ok(false),
+        }
+    }
+
+    pub(crate) fn evaluate_f64_batch(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        out: &mut [Complex<f64>],
+    ) -> RusticolResult<()> {
+        match &mut self.eval {
+            #[cfg(feature = "symbolica-runtime")]
+            F64Evaluator::ExactOnly => Err(RusticolError::integrity(
+                "compiled plane-arena exact evaluator cannot execute f64",
+            )),
+            #[cfg(feature = "f64-symjit")]
+            F64Evaluator::SymjitApplication(eval) => eval.evaluate_batch(batch_size, params, out),
+            #[cfg(feature = "f64-compiled")]
+            F64Evaluator::Compiled(eval) => eval.evaluate_batch(batch_size, params, out),
+            #[cfg(feature = "symbolica-runtime")]
+            F64Evaluator::Jit(eval) => {
+                if params.len() != batch_size * self.input_len {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "parameter buffer has length {}, expected {}",
+                        params.len(),
+                        batch_size * self.input_len
+                    )));
+                }
+                if out.len() != batch_size * self.output_len {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "output buffer has length {}, expected {}",
+                        out.len(),
+                        batch_size * self.output_len
+                    )));
+                }
+                eval.evaluate_batch(batch_size, params, out)
+                    .map_err(RusticolError::evaluation)
+            }
+        }
+    }
+
+    fn evaluate_f64_batch_unpadded(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        out: &mut [Complex<f64>],
+    ) -> RusticolResult<()> {
+        match &mut self.eval {
+            #[cfg(feature = "symbolica-runtime")]
+            F64Evaluator::ExactOnly => Err(RusticolError::integrity(
+                "compiled plane-arena exact evaluator cannot execute f64",
+            )),
+            #[cfg(feature = "f64-symjit")]
+            F64Evaluator::SymjitApplication(eval) => {
+                eval.evaluate_batch_unpadded(batch_size, params, out)
+            }
+            #[cfg(feature = "f64-compiled")]
+            F64Evaluator::Compiled(eval) => eval.evaluate_batch(batch_size, params, out),
+            #[cfg(feature = "symbolica-runtime")]
+            F64Evaluator::Jit(eval) => {
+                if params.len() != batch_size * self.input_len {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "parameter buffer has length {}, expected {}",
+                        params.len(),
+                        batch_size * self.input_len
+                    )));
+                }
+                if out.len() != batch_size * self.output_len {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "output buffer has length {}, expected {}",
+                        out.len(),
+                        batch_size * self.output_len
+                    )));
+                }
+                eval.evaluate_batch(batch_size, params, out)
+                    .map_err(RusticolError::evaluation)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "symbolica-runtime")]
+fn flatten_exact_evaluators_from_store(
+    manifest: &EvaluatorManifest,
+    payloads: &EvaluatorPayloadStore,
+    output: &mut Vec<LoadedEvaluator>,
+) -> RusticolResult<()> {
+    match manifest {
+        EvaluatorManifest::SymjitApplication {
+            input_len,
+            output_len,
+            evaluator_state_path,
+            evaluator_state_runtime_capability,
+            ..
+        } => {
+            let state_path = evaluator_state_path.as_ref().ok_or_else(|| {
+                RusticolError::compatibility(
+                    "compiled plane-arena exact execution requires evaluator-state payloads",
+                )
+            })?;
+            if evaluator_state_runtime_capability.as_deref()
+                != Some(SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY)
+            {
+                return Err(RusticolError::compatibility(format!(
+                    "SymJIT evaluator state {state_path:?} does not declare capability {:?}",
+                    SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY
+                )));
+            }
+            output.push(LoadedEvaluator {
+                eval: F64Evaluator::ExactOnly,
+                exact_eval: None,
+                exact_eval_source: Some(payloads.source(state_path)?),
+                double_eval: None,
+                arb_eval: None,
+                input_len: *input_len,
+                output_len: *output_len,
+            });
+            Ok(())
+        }
+        EvaluatorManifest::CompiledComplex {
+            input_len,
+            output_len,
+            evaluator_state_path,
+            native_direct_application: Some(_),
+            ..
+        } => {
+            let state_path = evaluator_state_path.as_ref().ok_or_else(|| {
+                RusticolError::compatibility(
+                    "compiled plane-arena exact execution requires evaluator-state payloads",
+                )
+            })?;
+            output.push(LoadedEvaluator {
+                eval: F64Evaluator::ExactOnly,
+                exact_eval: None,
+                exact_eval_source: Some(payloads.source(state_path)?),
+                double_eval: None,
+                arb_eval: None,
+                input_len: *input_len,
+                output_len: *output_len,
+            });
+            Ok(())
+        }
+        EvaluatorManifest::Chunked { chunks, .. } => {
+            for chunk in chunks {
+                flatten_exact_evaluators_from_store(chunk, payloads, output)?;
+            }
+            Ok(())
+        }
+        _ => Err(RusticolError::compatibility(
+            "compiled plane-arena exact execution requires direct leaves with evaluator state",
+        )),
+    }
+}
+
+pub(crate) fn flatten_evaluators_from_store(
+    manifest: &EvaluatorManifest,
+    payloads: &EvaluatorPayloadStore,
+    output: &mut Vec<LoadedEvaluator>,
+) -> RusticolResult<()> {
+    match manifest {
+        EvaluatorManifest::SymjitApplication {
+            runtime_capability,
+            application_path,
+            application_abi,
+            input_len,
+            output_len,
+            element_layout,
+            batch_layout,
+            compiler_type,
+            translation_mode,
+            optimization_level,
+            word_bits,
+            endianness,
+            required_defuns,
+            evaluator_state_path,
+            evaluator_state_runtime_capability,
+            ..
+        } => {
+            #[cfg(feature = "f64-symjit")]
+            {
+                let application_source = payloads.source(application_path)?;
+                let application_bytes = application_source.read()?;
+                let eval = SymjitApplicationEvaluator::load_bytes(
+                    application_bytes.as_ref(),
+                    PathBuf::from(application_source.display_name()),
+                    SymjitApplicationMetadata {
+                        runtime_capability,
+                        application_abi,
+                        input_len: *input_len,
+                        output_len: *output_len,
+                        element_layout,
+                        batch_layout,
+                        compiler_type,
+                        translation_mode,
+                        optimization_level: *optimization_level,
+                        word_bits: *word_bits,
+                        endianness,
+                        required_defuns,
+                    },
+                )?;
+                #[cfg(feature = "symbolica-runtime")]
+                let exact_eval_source = match evaluator_state_path {
+                    Some(state_path) => {
+                        if evaluator_state_runtime_capability.as_deref()
+                            != Some(SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY)
+                        {
+                            return Err(RusticolError::compatibility(format!(
+                                "SymJIT evaluator state {:?} does not declare capability {:?}",
+                                state_path, SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY
+                            )));
+                        }
+                        Some(payloads.source(state_path)?)
+                    }
+                    None => None,
+                };
+                #[cfg(not(feature = "symbolica-runtime"))]
+                let _ = (evaluator_state_path, evaluator_state_runtime_capability);
+                output.push(LoadedEvaluator {
+                    eval: F64Evaluator::SymjitApplication(eval),
+                    #[cfg(feature = "symbolica-runtime")]
+                    exact_eval: None,
+                    #[cfg(feature = "symbolica-runtime")]
+                    exact_eval_source,
+                    #[cfg(feature = "symbolica-runtime")]
+                    double_eval: None,
+                    #[cfg(feature = "symbolica-runtime")]
+                    arb_eval: None,
+                    input_len: *input_len,
+                    output_len: *output_len,
+                });
+                Ok(())
+            }
+            #[cfg(not(feature = "f64-symjit"))]
+            {
+                let _ = (
+                    application_path,
+                    application_abi,
+                    input_len,
+                    output_len,
+                    element_layout,
+                    batch_layout,
+                    compiler_type,
+                    translation_mode,
+                    optimization_level,
+                    word_bits,
+                    endianness,
+                    required_defuns,
+                    evaluator_state_path,
+                    evaluator_state_runtime_capability,
+                );
+                Err(unsupported_capability(runtime_capability))
+            }
+        }
+        EvaluatorManifest::Jit {
+            runtime_capability,
+            input_len,
+            output_len,
+            evaluator_state_path,
+        } => {
+            #[cfg(feature = "symbolica-runtime")]
+            {
+                let _ = runtime_capability;
+                let (jit_settings, exact_eval, jit_eval) =
+                    load_evaluator_state_source(&payloads.source(evaluator_state_path)?)?;
+                let eval = F64Evaluator::Jit(match jit_eval {
+                    Some(eval) => eval,
+                    None => exact_eval
+                        .jit_compile::<Complex<f64>>(jit_settings)
+                        .map_err(|err| {
+                            RusticolError::evaluation(format!(
+                                "could not compile scalar JIT evaluator from {}: {err}",
+                                evaluator_state_path
+                            ))
+                        })?,
+                });
+                output.push(LoadedEvaluator {
+                    eval,
+                    exact_eval: Some(exact_eval),
+                    exact_eval_source: None,
+                    double_eval: None,
+                    arb_eval: None,
+                    input_len: *input_len,
+                    output_len: *output_len,
+                });
+                Ok(())
+            }
+            #[cfg(not(feature = "symbolica-runtime"))]
+            {
+                let _ = (input_len, output_len, evaluator_state_path);
+                Err(unsupported_capability(runtime_capability))
+            }
+        }
+        EvaluatorManifest::CompiledComplex {
+            runtime_capability,
+            function_name,
+            input_len,
+            output_len,
+            library_path,
+            evaluator_state_path,
+            number_type,
+            native_direct_application: _,
+        } => {
+            #[cfg(feature = "f64-compiled")]
+            {
+                let _ = runtime_capability;
+                if number_type != "complex" {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "rusticol currently supports compiled complex evaluators, got {number_type}"
+                    )));
+                }
+                let library = payloads.load_native_library(library_path)?;
+                let eval = CompiledComplexF64Evaluator::load(
+                    library,
+                    function_name,
+                    *input_len,
+                    *output_len,
+                )?;
+                #[cfg(feature = "symbolica-runtime")]
+                let exact_eval_source = evaluator_state_path
+                    .as_deref()
+                    .map(|state_path| payloads.source(state_path))
+                    .transpose()?;
+                #[cfg(not(feature = "symbolica-runtime"))]
+                let _ = evaluator_state_path;
+                output.push(LoadedEvaluator {
+                    eval: F64Evaluator::Compiled(eval),
+                    #[cfg(feature = "symbolica-runtime")]
+                    exact_eval: None,
+                    #[cfg(feature = "symbolica-runtime")]
+                    exact_eval_source,
+                    #[cfg(feature = "symbolica-runtime")]
+                    double_eval: None,
+                    #[cfg(feature = "symbolica-runtime")]
+                    arb_eval: None,
+                    input_len: *input_len,
+                    output_len: *output_len,
+                });
+                Ok(())
+            }
+            #[cfg(not(feature = "f64-compiled"))]
+            {
+                let _ = (
+                    function_name,
+                    input_len,
+                    output_len,
+                    library_path,
+                    evaluator_state_path,
+                    number_type,
+                );
+                Err(unsupported_capability(runtime_capability))
+            }
+        }
+        EvaluatorManifest::Chunked { chunks, .. } => {
+            for chunk in chunks {
+                flatten_evaluators_from_store(chunk, payloads, output)?;
+            }
+            Ok(())
+        }
+    }
+}
+
+pub(crate) fn ensure_evaluator_capabilities_supported(
+    manifest: &EvaluatorManifest,
+) -> RusticolResult<()> {
+    let declared = evaluator_runtime_capabilities(manifest)?;
+    ensure_runtime_capabilities_supported(declared.iter().map(String::as_str))
+}
+
+pub(crate) fn evaluator_runtime_capabilities(
+    manifest: &EvaluatorManifest,
+) -> RusticolResult<BTreeSet<String>> {
+    let mut capabilities = BTreeSet::new();
+    collect_evaluator_capabilities(manifest, &mut capabilities)?;
+    Ok(capabilities)
+}
+
+fn collect_evaluator_capabilities(
+    manifest: &EvaluatorManifest,
+    output: &mut BTreeSet<String>,
+) -> RusticolResult<()> {
+    match manifest {
+        EvaluatorManifest::SymjitApplication {
+            runtime_capability, ..
+        } => validate_and_insert_capability(
+            runtime_capability,
+            &[SYMJIT_APPLICATION_RUNTIME_CAPABILITY],
+            output,
+        ),
+        EvaluatorManifest::Jit {
+            runtime_capability, ..
+        } => validate_and_insert_capability(
+            runtime_capability,
+            &[SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY],
+            output,
+        ),
+        EvaluatorManifest::CompiledComplex {
+            runtime_capability, ..
+        } => validate_and_insert_capability(
+            runtime_capability,
+            &[
+                SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY,
+                SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY,
+            ],
+            output,
+        ),
+        EvaluatorManifest::Chunked {
+            required_runtime_capabilities,
+            chunks,
+            ..
+        } => {
+            let mut actual = BTreeSet::new();
+            for chunk in chunks {
+                collect_evaluator_capabilities(chunk, &mut actual)?;
+            }
+            let declared = required_runtime_capabilities
+                .iter()
+                .cloned()
+                .collect::<BTreeSet<_>>();
+            if declared.len() != required_runtime_capabilities.len() || declared != actual {
+                return Err(RusticolError::integrity(format!(
+                    "chunked evaluator capabilities {:?} do not match child capabilities {:?}",
+                    required_runtime_capabilities, actual
+                )));
+            }
+            output.extend(actual);
+            Ok(())
+        }
+    }
+}
+
+fn validate_and_insert_capability(
+    capability: &str,
+    expected: &[&str],
+    output: &mut BTreeSet<String>,
+) -> RusticolResult<()> {
+    if !expected.contains(&capability) {
+        return Err(RusticolError::compatibility(format!(
+            "evaluator declares runtime capability {capability:?}, expected one of {expected:?}"
+        )));
+    }
+    output.insert(capability.to_string());
+    Ok(())
+}
+
+#[cfg(any(
+    not(feature = "f64-compiled"),
+    not(feature = "f64-symjit"),
+    not(feature = "symbolica-runtime")
+))]
+fn unsupported_capability(capability: &str) -> RusticolError {
+    RusticolError::unsupported_runtime_capability(
+        capability,
+        format!(
+            "this Rusticol build supports {:?}",
+            supported_runtime_capabilities()
+        ),
+    )
+}
+
+#[cfg(feature = "symbolica-runtime")]
+type LoadedEvaluatorState = (
+    JITCompilationSettings,
+    ExpressionEvaluator<Complex<Rational>>,
+    Option<JITCompiledEvaluator<Complex<f64>>>,
+);
+
+#[cfg(feature = "symbolica-runtime")]
+fn load_evaluator_state_source(
+    source: &EvaluatorPayloadSource,
+) -> RusticolResult<LoadedEvaluatorState> {
+    let bytes = source.read()?;
+    load_evaluator_state_bytes(bytes.as_ref(), &source.display_name())
+}
+
+#[cfg(feature = "symbolica-runtime")]
+fn load_evaluator_state_bytes(
+    bytes: &[u8],
+    display_name: &str,
+) -> RusticolResult<LoadedEvaluatorState> {
+    type SavedEvaluator = (
+        bool,
+        JITCompilationSettings,
+        ExpressionEvaluator<Complex<Rational>>,
+        Option<JITCompiledEvaluator<f64>>,
+        Option<JITCompiledEvaluator<Complex<f64>>>,
+    );
+
+    let ((_, settings, evaluator, _, jit_complex), consumed) =
+        bincode::decode_from_slice::<SavedEvaluator, _>(bytes, bincode::config::standard())
+            .map_err(|error| {
+                RusticolError::compatibility(format!(
+                    "evaluator state {} does not match Symbolica serialization ABI {}: {error}; regenerate the schema-v3 artifact",
+                    display_name,
+                    crate::SYMBOLICA_SERIALIZATION_ABI
+                ))
+            })?;
+    ensure_evaluator_state_consumed(display_name, bytes.len(), consumed)?;
+    Ok((settings, evaluator, jit_complex))
+}
+
+#[cfg(feature = "symbolica-runtime")]
+fn ensure_evaluator_state_consumed(
+    display_name: &str,
+    encoded_len: usize,
+    consumed: usize,
+) -> RusticolResult<()> {
+    if consumed == encoded_len {
+        return Ok(());
+    }
+    Err(RusticolError::integrity(format!(
+        "evaluator state {} contains {} trailing bytes",
+        display_name,
+        encoded_len - consumed
+    )))
+}
+
+#[cfg(test)]
+mod aosoa_tests {
+    use super::*;
+
+    fn source_value(row: usize, component: usize) -> Complex<f64> {
+        Complex::new(
+            (100 * row + component) as f64,
+            -((100 * row + component) as f64) - 0.5,
+        )
+    }
+
+    fn check_pack_and_scatter(lane_width: usize) {
+        let batch_size = lane_width + 1;
+        let source_parameter_count = 4;
+        let input_components = [2, 0, 3];
+        let source = (0..batch_size)
+            .flat_map(|row| {
+                (0..source_parameter_count).map(move |component| source_value(row, component))
+            })
+            .collect::<Vec<_>>();
+        let mut packed = Vec::new();
+        let block_count = pack_f64_parameters_aosoa(
+            &source,
+            batch_size,
+            source_parameter_count,
+            input_components.len(),
+            lane_width,
+            Some(&input_components),
+            &mut packed,
+        )
+        .unwrap();
+        assert_eq!(block_count, 2);
+        for block in 0..block_count {
+            for (local_component, source_component) in input_components.iter().copied().enumerate()
+            {
+                let scalar_start =
+                    (block * input_components.len() + local_component) * 2 * lane_width;
+                for lane in 0..lane_width {
+                    let row = (block * lane_width + lane).min(batch_size - 1);
+                    let expected = source_value(row, source_component);
+                    assert_eq!(packed[scalar_start + lane], expected.re);
+                    assert_eq!(packed[scalar_start + lane_width + lane], expected.im);
+                }
+            }
+        }
+
+        let evaluator_output_len = 4;
+        let mut evaluator_outputs = vec![0.0; block_count * evaluator_output_len * 2 * lane_width];
+        for block in 0..block_count {
+            for column in 0..evaluator_output_len {
+                let scalar_start = (block * evaluator_output_len + column) * 2 * lane_width;
+                for lane in 0..lane_width {
+                    let row = block * lane_width + lane;
+                    evaluator_outputs[scalar_start + lane] = (1000 * row + column) as f64;
+                    evaluator_outputs[scalar_start + lane_width + lane] =
+                        -((1000 * row + column) as f64);
+                }
+            }
+        }
+
+        let state_parameter_count = 7;
+        let sentinel = Complex::new(12345.0, -12345.0);
+        let mut mapped_state = vec![sentinel; batch_size * state_parameter_count];
+        scatter_f64_aosoa_outputs_to_state(
+            &evaluator_outputs,
+            batch_size,
+            evaluator_output_len,
+            lane_width,
+            state_parameter_count,
+            &mut mapped_state,
+            &[(0, 1), (2, 5)],
+            &[],
+        )
+        .unwrap();
+        for row in 0..batch_size {
+            assert_eq!(
+                mapped_state[row * state_parameter_count + 1],
+                Complex::new((1000 * row) as f64, -((1000 * row) as f64))
+            );
+            assert_eq!(
+                mapped_state[row * state_parameter_count + 5],
+                Complex::new((1000 * row + 2) as f64, -((1000 * row + 2) as f64))
+            );
+            assert_eq!(mapped_state[row * state_parameter_count], sentinel);
+        }
+
+        let mut spanned_state = vec![sentinel; batch_size * state_parameter_count];
+        scatter_f64_aosoa_outputs_to_state(
+            &evaluator_outputs,
+            batch_size,
+            evaluator_output_len,
+            lane_width,
+            state_parameter_count,
+            &mut spanned_state,
+            &[],
+            &[(1, 3, 2)],
+        )
+        .unwrap();
+        for row in 0..batch_size {
+            for offset in 0..2 {
+                assert_eq!(
+                    spanned_state[row * state_parameter_count + 3 + offset],
+                    Complex::new(
+                        (1000 * row + 1 + offset) as f64,
+                        -((1000 * row + 1 + offset) as f64)
+                    )
+                );
+            }
+            assert_eq!(spanned_state[row * state_parameter_count], sentinel);
+        }
+
+        let row_output_len = evaluator_output_len + 2;
+        let mut row_outputs = vec![sentinel; batch_size * row_output_len];
+        scatter_f64_aosoa_outputs_to_rows(
+            &evaluator_outputs,
+            batch_size,
+            evaluator_output_len,
+            lane_width,
+            row_output_len,
+            1,
+            &mut row_outputs,
+        )
+        .unwrap();
+        for row in 0..batch_size {
+            assert_eq!(row_outputs[row * row_output_len], sentinel);
+            assert_eq!(
+                row_outputs[row * row_output_len + row_output_len - 1],
+                sentinel
+            );
+            for column in 0..evaluator_output_len {
+                assert_eq!(
+                    row_outputs[row * row_output_len + 1 + column],
+                    Complex::new(
+                        (1000 * row + column) as f64,
+                        -((1000 * row + column) as f64)
+                    )
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn portable_aosoa_pack_and_scatter_cover_fixed_and_dynamic_widths() {
+        for lane_width in [2, 4, 8, 3] {
+            check_pack_and_scatter(lane_width);
+        }
+    }
+
+    #[test]
+    fn aosoa_pack_rejects_inconsistent_mappings_and_lengths() {
+        let mut scratch = Vec::new();
+        let source = vec![c64(0.0, 0.0); 8];
+        assert!(pack_f64_parameters_aosoa(&source, 2, 4, 2, 4, Some(&[0]), &mut scratch).is_err());
+        assert!(
+            pack_f64_parameters_aosoa(&source, 2, 4, 2, 4, Some(&[0, 4]), &mut scratch).is_err()
+        );
+        assert!(
+            pack_f64_parameters_aosoa(&source[..7], 2, 4, 2, 4, Some(&[0, 1]), &mut scratch)
+                .is_err()
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/compiled.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/compiled.rs
new file mode 100644
index 0000000000..92aa4f5b60
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/compiled.rs
@@ -0,0 +1,263 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::super::*;
+use crate::artifact::PinnedNativeLibrary;
+use std::sync::Arc;
+
+type EvaluateFunction =
+    unsafe extern "C" fn(*const Complex<f64>, *mut Complex<f64>, *mut Complex<f64>);
+type BufferLengthFunction = unsafe extern "C" fn() -> std::ffi::c_ulong;
+
+pub(crate) struct CompiledComplexF64Evaluator {
+    _library: Arc<PinnedNativeLibrary>,
+    evaluate: EvaluateFunction,
+    scratch: Vec<Complex<f64>>,
+    input_len: usize,
+    output_len: usize,
+}
+
+impl CompiledComplexF64Evaluator {
+    pub(crate) fn load(
+        library: Arc<PinnedNativeLibrary>,
+        function_name: &str,
+        input_len: usize,
+        output_len: usize,
+    ) -> RusticolResult<Self> {
+        if function_name.is_empty() || input_len == 0 || output_len == 0 {
+            return Err(RusticolError::invalid_argument(
+                "compiled evaluator function_name, input_len, and output_len must be non-empty",
+            ));
+        }
+        if std::mem::size_of::<Complex<f64>>() != 2 * std::mem::size_of::<f64>()
+            || std::mem::align_of::<Complex<f64>>() != std::mem::align_of::<f64>()
+        {
+            return Err(RusticolError::compatibility(
+                "Rusticol complex-f64 storage is incompatible with the compiled evaluator ABI",
+            ));
+        }
+
+        let path = library.display_path();
+        let exported_name = format!("{function_name}_complexf64");
+        let evaluate = unsafe {
+            *library
+                .get::<EvaluateFunction>(exported_name.as_bytes())
+                .map_err(|error| {
+                    RusticolError::evaluation(format!(
+                        "could not load compiled evaluator symbol {exported_name:?} from {}: {error}",
+                        path.display()
+                    ))
+                })?
+        };
+        let buffer_name = format!("{exported_name}_get_buffer_len");
+        let buffer_length = unsafe {
+            *library
+                .get::<BufferLengthFunction>(buffer_name.as_bytes())
+                .map_err(|error| {
+                    RusticolError::evaluation(format!(
+                        "could not load compiled evaluator symbol {buffer_name:?} from {}: {error}",
+                        path.display()
+                    ))
+                })?
+        };
+        let scratch_len = usize::try_from(unsafe { buffer_length() }).map_err(|_| {
+            RusticolError::evaluation("compiled evaluator scratch-buffer length exceeds usize")
+        })?;
+        let mut scratch = Vec::new();
+        scratch.try_reserve_exact(scratch_len).map_err(|error| {
+            RusticolError::evaluation(format!(
+                "could not allocate compiled evaluator scratch buffer of length {scratch_len}: {error}"
+            ))
+        })?;
+        scratch.resize(scratch_len, Complex { re: 0.0, im: 0.0 });
+
+        Ok(Self {
+            _library: library,
+            evaluate,
+            scratch,
+            input_len,
+            output_len,
+        })
+    }
+
+    pub(crate) fn evaluate_batch(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        out: &mut [Complex<f64>],
+    ) -> RusticolResult<()> {
+        if batch_size == 0 {
+            return Err(RusticolError::invalid_argument(
+                "compiled evaluator batch_size must be positive",
+            ));
+        }
+        let expected_params = batch_size.checked_mul(self.input_len).ok_or_else(|| {
+            RusticolError::invalid_argument("compiled evaluator input length overflows usize")
+        })?;
+        let expected_outputs = batch_size.checked_mul(self.output_len).ok_or_else(|| {
+            RusticolError::invalid_argument("compiled evaluator output length overflows usize")
+        })?;
+        if params.len() != expected_params {
+            return Err(RusticolError::invalid_argument(format!(
+                "parameter buffer has length {}, expected {expected_params}",
+                params.len()
+            )));
+        }
+        if out.len() != expected_outputs {
+            return Err(RusticolError::invalid_argument(format!(
+                "output buffer has length {}, expected {expected_outputs}",
+                out.len()
+            )));
+        }
+
+        for (input_row, output_row) in params
+            .chunks_exact(self.input_len)
+            .zip(out.chunks_exact_mut(self.output_len))
+        {
+            // SAFETY: Length checks above guarantee complete input/output rows. The
+            // scratch buffer has the size reported by the loaded evaluator itself.
+            unsafe {
+                (self.evaluate)(
+                    input_row.as_ptr(),
+                    self.scratch.as_mut_ptr(),
+                    output_row.as_mut_ptr(),
+                );
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(all(test, any(target_os = "linux", target_os = "macos")))]
+mod tests {
+    use super::*;
+    use std::process::Command;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn compiled_fixture() -> (PathBuf, PathBuf) {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let directory = std::env::temp_dir().join(format!(
+            "rusticol-compiled-test-{}-{unique}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&directory).unwrap();
+        let source = directory.join("fixture.cpp");
+        let library = directory.join(if cfg!(target_os = "macos") {
+            "libfixture.dylib"
+        } else {
+            "libfixture.so"
+        });
+        fs::write(
+            &source,
+            r#"#include <complex>
+extern "C" unsigned long rusticol_test_complexf64_get_buffer_len() { return 1; }
+extern "C" void rusticol_test_complexf64(
+    std::complex<double>* params,
+    std::complex<double>* buffer,
+    std::complex<double>* out) {
+    buffer[0] = params[0] + params[1];
+    out[0] = buffer[0];
+    out[1] = params[0] * params[1];
+}
+"#,
+        )
+        .unwrap();
+        let compiler = std::env::var("CXX").unwrap_or_else(|_| "c++".to_string());
+        let mut command = Command::new(compiler);
+        command.arg("-std=c++17");
+        if cfg!(target_os = "macos") {
+            command.arg("-dynamiclib");
+        } else {
+            command.args(["-shared", "-fPIC"]);
+        }
+        let output = command
+            .arg(&source)
+            .arg("-o")
+            .arg(&library)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "could not compile test evaluator: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        (directory, library)
+    }
+
+    #[test]
+    fn symbolica_compiled_complex_abi_loads_and_evaluates_batches() {
+        let (directory, library) = compiled_fixture();
+        let mut evaluator = CompiledComplexF64Evaluator::load(
+            PinnedNativeLibrary::from_test_path(&library).unwrap(),
+            "rusticol_test",
+            2,
+            2,
+        )
+        .unwrap();
+        let params = [
+            Complex::new(1.0, 2.0),
+            Complex::new(3.0, -4.0),
+            Complex::new(-2.0, 0.5),
+            Complex::new(4.0, 1.5),
+        ];
+        let mut output = [Complex::new(0.0, 0.0); 4];
+
+        evaluator.evaluate_batch(2, &params, &mut output).unwrap();
+
+        assert_eq!(output[0], Complex::new(4.0, -2.0));
+        assert_eq!(output[1], Complex::new(11.0, 2.0));
+        assert_eq!(output[2], Complex::new(2.0, 2.0));
+        assert_eq!(output[3], Complex::new(-8.75, -1.0));
+        fs::remove_dir_all(directory).unwrap();
+    }
+
+    #[test]
+    fn cpp_and_asm_manifests_load_through_the_runtime_group() {
+        let (directory, library) = compiled_fixture();
+        let library_name = library.file_name().unwrap().to_str().unwrap().to_string();
+        for capability in [
+            SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY,
+            SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY,
+        ] {
+            let manifest = EvaluatorManifest::CompiledComplex {
+                runtime_capability: capability.to_string(),
+                function_name: "rusticol_test".to_string(),
+                input_len: 2,
+                output_len: 2,
+                library_path: library_name.clone(),
+                evaluator_state_path: Some("unused-symbolica-state.bin".to_string()),
+                number_type: "complex".to_string(),
+                native_direct_application: None,
+            };
+            let mut group = EvaluatorGroup::load(&manifest, &directory).unwrap();
+            let output = group
+                .evaluate_batch(1, &[Complex::new(1.0, 2.0), Complex::new(3.0, -4.0)])
+                .unwrap();
+
+            assert_eq!(output, [Complex::new(4.0, -2.0), Complex::new(11.0, 2.0)]);
+        }
+        fs::remove_dir_all(directory).unwrap();
+    }
+
+    #[test]
+    fn compiled_evaluator_validates_batch_dimensions() {
+        let (directory, library) = compiled_fixture();
+        let mut evaluator = CompiledComplexF64Evaluator::load(
+            PinnedNativeLibrary::from_test_path(&library).unwrap(),
+            "rusticol_test",
+            2,
+            2,
+        )
+        .unwrap();
+        let mut output = [Complex::new(0.0, 0.0); 2];
+
+        let error = evaluator
+            .evaluate_batch(1, &[Complex::new(1.0, 0.0)], &mut output)
+            .unwrap_err();
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::InvalidArgument);
+        fs::remove_dir_all(directory).unwrap();
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/crossing.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/crossing.rs
new file mode 100644
index 0000000000..b4acab86e3
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/crossing.rs
@@ -0,0 +1,363 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::super::*;
+
+pub(crate) fn apply_input_crossing_map(
+    batch: Vec<Vec<[f64; 4]>>,
+    expected_legs: usize,
+    input_crossing_map: Option<&[InputCrossingMapEntry]>,
+) -> RusticolResult<Vec<Vec<[f64; 4]>>> {
+    let Some(map) = input_crossing_map else {
+        return Ok(batch);
+    };
+    if map.len() != expected_legs {
+        return Err(RusticolError::invalid_argument(format!(
+            "input crossing map has {} entries, expected {expected_legs}",
+            map.len()
+        )));
+    }
+    let mut seen = vec![false; expected_legs];
+    for entry in map {
+        if entry.target_index >= expected_legs || entry.source_index >= expected_legs {
+            return Err(RusticolError::invalid_argument(
+                "input crossing map references an out-of-range external leg",
+            ));
+        }
+        if seen[entry.target_index] {
+            return Err(RusticolError::invalid_argument(
+                "input crossing map contains a duplicate target index",
+            ));
+        }
+        seen[entry.target_index] = true;
+    }
+    if seen.iter().any(|value| !*value) {
+        return Err(RusticolError::invalid_argument(
+            "input crossing map does not cover every target index",
+        ));
+    }
+    let mut mapped_batch = Vec::with_capacity(batch.len());
+    for point in batch {
+        let mut mapped = vec![[0.0; 4]; expected_legs];
+        for entry in map {
+            let source = point[entry.source_index];
+            mapped[entry.target_index] = [
+                entry.sign * source[0],
+                entry.sign * source[1],
+                entry.sign * source[2],
+                entry.sign * source[3],
+            ];
+        }
+        mapped_batch.push(mapped);
+    }
+    Ok(mapped_batch)
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(crate) fn validate_input_crossing_map(
+    expected_legs: usize,
+    input_crossing_map: Option<&[InputCrossingMapEntry]>,
+) -> RusticolResult<Option<&[InputCrossingMapEntry]>> {
+    let Some(map) = input_crossing_map else {
+        return Ok(None);
+    };
+    if map.len() != expected_legs {
+        return Err(RusticolError::invalid_argument(format!(
+            "input crossing map has {} entries, expected {expected_legs}",
+            map.len()
+        )));
+    }
+    let mut seen = vec![false; expected_legs];
+    for entry in map {
+        if entry.target_index >= expected_legs || entry.source_index >= expected_legs {
+            return Err(RusticolError::invalid_argument(
+                "input crossing map references an out-of-range external leg",
+            ));
+        }
+        if seen[entry.target_index] {
+            return Err(RusticolError::invalid_argument(
+                "input crossing map contains a duplicate target index",
+            ));
+        }
+        seen[entry.target_index] = true;
+    }
+    if seen.iter().any(|value| !*value) {
+        return Err(RusticolError::invalid_argument(
+            "input crossing map does not cover every target index",
+        ));
+    }
+    Ok(Some(map))
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(crate) fn apply_input_crossing_map_generic<T>(
+    batch: &[Vec<[T; 4]>],
+    expected_legs: usize,
+    input_crossing_map: Option<&[InputCrossingMapEntry]>,
+) -> RusticolResult<Vec<Vec<[T; 4]>>>
+where
+    T: RusticolHighPrecisionNumber,
+    Complex<T>: Real + EvaluationDomain,
+{
+    let Some(map) = validate_input_crossing_map(expected_legs, input_crossing_map)? else {
+        return Ok(batch.to_vec());
+    };
+    let mut mapped_batch = Vec::with_capacity(batch.len());
+    for point in batch {
+        let mut mapped = vec![std::array::from_fn(|_| T::new_zero()); expected_legs];
+        for entry in map {
+            let source = &point[entry.source_index];
+            for (target, source_component) in mapped[entry.target_index].iter_mut().zip(source) {
+                *target = T::from(entry.sign) * source_component.clone();
+            }
+        }
+        mapped_batch.push(mapped);
+    }
+    Ok(mapped_batch)
+}
+
+pub(crate) fn apply_lc_topology_label_permutation(
+    batch: &[Vec<[f64; 4]>],
+    expected_legs: usize,
+    mapping: &[(usize, usize)],
+) -> RusticolResult<Vec<Vec<[f64; 4]>>> {
+    let mut seen = vec![false; expected_legs];
+    for (representative_index, sector_index) in mapping {
+        if *representative_index >= expected_legs || *sector_index >= expected_legs {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay label permutation references an out-of-range external leg",
+            ));
+        }
+        if seen[*representative_index] {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay label permutation contains a duplicate representative label",
+            ));
+        }
+        seen[*representative_index] = true;
+    }
+    let mut mapped_batch = Vec::with_capacity(batch.len());
+    for point in batch {
+        if point.len() != expected_legs {
+            return Err(RusticolError::invalid_argument(format!(
+                "LC topology replay point has {} external legs, expected {expected_legs}",
+                point.len(),
+            )));
+        }
+        let mut mapped = point.clone();
+        for (representative_index, sector_index) in mapping {
+            mapped[*representative_index] = point[*sector_index];
+        }
+        mapped_batch.push(mapped);
+    }
+    Ok(mapped_batch)
+}
+
+pub(crate) fn apply_lc_topology_label_permutations(
+    batch: &[Vec<[f64; 4]>],
+    expected_legs: usize,
+    mappings: &[Vec<(usize, usize)>],
+) -> RusticolResult<Vec<Vec<[f64; 4]>>> {
+    let mut expanded_batch = Vec::with_capacity(batch.len() * mappings.len());
+    for mapping in mappings {
+        expanded_batch.extend(apply_lc_topology_label_permutation(
+            batch,
+            expected_legs,
+            mapping,
+        )?);
+    }
+    Ok(expanded_batch)
+}
+
+pub(crate) fn apply_lc_topology_label_permutations_from_view(
+    batch: F64MomentumBatchView<'_>,
+    expected_legs: usize,
+    mappings: &[Vec<(usize, usize)>],
+) -> RusticolResult<Vec<Vec<[f64; 4]>>> {
+    if batch.external_count() != expected_legs {
+        return Err(RusticolError::invalid_argument(format!(
+            "LC topology replay input has {} external legs, expected {expected_legs}",
+            batch.external_count()
+        )));
+    }
+    let capacity = batch
+        .point_count()
+        .checked_mul(mappings.len())
+        .ok_or_else(|| RusticolError::invalid_argument("LC topology replay batch overflows"))?;
+    let mut expanded_batch = Vec::with_capacity(capacity);
+    for mapping in mappings {
+        let mut seen = vec![false; expected_legs];
+        for (representative_index, sector_index) in mapping {
+            if *representative_index >= expected_legs || *sector_index >= expected_legs {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay label permutation references an out-of-range external leg",
+                ));
+            }
+            if seen[*representative_index] {
+                return Err(RusticolError::invalid_argument(
+                    "LC topology replay label permutation contains a duplicate representative label",
+                ));
+            }
+            seen[*representative_index] = true;
+        }
+        for point_index in 0..batch.point_count() {
+            let point = batch.point(point_index);
+            let mut mapped = (0..expected_legs)
+                .map(|external_index| {
+                    point.momentum(external_index).ok_or_else(|| {
+                        RusticolError::integrity(
+                            "validated momentum view is missing an external leg during topology replay",
+                        )
+                    })
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+            for (representative_index, sector_index) in mapping {
+                mapped[*representative_index] = point.momentum(*sector_index).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "validated momentum view is missing a permuted external leg",
+                    )
+                })?;
+            }
+            expanded_batch.push(mapped);
+        }
+    }
+    Ok(expanded_batch)
+}
+
+/// Materialize one validated topology-replay permutation into reusable flat
+/// row-major storage.
+///
+/// This is the totals-only Direct-Arena crossing lane: it avoids both the
+/// nested per-point vectors and the mapping-by-batch expansion used by the
+/// resolved compatibility path. The caller owns and reuses `output`.
+pub(crate) fn apply_lc_topology_label_permutation_from_view_into_flat(
+    batch: F64MomentumBatchView<'_>,
+    expected_legs: usize,
+    mapping: &[(usize, usize)],
+    output: &mut Vec<f64>,
+) -> RusticolResult<()> {
+    if batch.external_count() != expected_legs {
+        return Err(RusticolError::invalid_argument(format!(
+            "LC topology replay input has {} external legs, expected {expected_legs}",
+            batch.external_count()
+        )));
+    }
+    for (mapping_index, (representative_index, sector_index)) in mapping.iter().enumerate() {
+        if *representative_index >= expected_legs || *sector_index >= expected_legs {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay label permutation references an out-of-range external leg",
+            ));
+        }
+        if mapping[..mapping_index]
+            .iter()
+            .any(|(previous, _)| previous == representative_index)
+        {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay label permutation contains a duplicate representative label",
+            ));
+        }
+    }
+    let values_per_point = expected_legs
+        .checked_mul(4)
+        .ok_or_else(|| RusticolError::invalid_argument("LC topology replay batch overflows"))?;
+    let scalar_count = batch
+        .point_count()
+        .checked_mul(values_per_point)
+        .ok_or_else(|| RusticolError::invalid_argument("LC topology replay batch overflows"))?;
+    output.resize(scalar_count, 0.0);
+    for point_index in 0..batch.point_count() {
+        let point = batch.point(point_index);
+        let row_start = point_index * values_per_point;
+        for external_index in 0..expected_legs {
+            let momentum = point.momentum(external_index).ok_or_else(|| {
+                RusticolError::integrity(
+                    "validated momentum view is missing an external leg during topology replay",
+                )
+            })?;
+            output[row_start + external_index * 4..row_start + (external_index + 1) * 4]
+                .copy_from_slice(&momentum);
+        }
+        for (representative_index, sector_index) in mapping {
+            let momentum = point.momentum(*sector_index).ok_or_else(|| {
+                RusticolError::integrity(
+                    "validated momentum view is missing a permuted external leg",
+                )
+            })?;
+            let start = row_start + representative_index * 4;
+            output[start..start + 4].copy_from_slice(&momentum);
+        }
+    }
+    Ok(())
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(crate) fn apply_lc_topology_label_permutation_generic<T>(
+    batch: &[Vec<[T; 4]>],
+    expected_legs: usize,
+    mapping: &[(usize, usize)],
+) -> RusticolResult<Vec<Vec<[T; 4]>>>
+where
+    T: RusticolHighPrecisionNumber,
+    Complex<T>: Real + EvaluationDomain,
+{
+    let mut seen = vec![false; expected_legs];
+    for (representative_index, sector_index) in mapping {
+        if *representative_index >= expected_legs || *sector_index >= expected_legs {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay label permutation references an out-of-range external leg",
+            ));
+        }
+        if seen[*representative_index] {
+            return Err(RusticolError::invalid_argument(
+                "LC topology replay label permutation contains a duplicate representative label",
+            ));
+        }
+        seen[*representative_index] = true;
+    }
+    let mut mapped_batch = Vec::with_capacity(batch.len());
+    for point in batch {
+        if point.len() != expected_legs {
+            return Err(RusticolError::invalid_argument(format!(
+                "LC topology replay point has {} external legs, expected {expected_legs}",
+                point.len(),
+            )));
+        }
+        let mut mapped = point.clone();
+        for (representative_index, sector_index) in mapping {
+            mapped[*representative_index] = point[*sector_index].clone();
+        }
+        mapped_batch.push(mapped);
+    }
+    Ok(mapped_batch)
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(crate) fn apply_lc_topology_label_permutations_generic<T>(
+    batch: &[Vec<[T; 4]>],
+    expected_legs: usize,
+    mappings: &[Vec<(usize, usize)>],
+) -> RusticolResult<Vec<Vec<[T; 4]>>>
+where
+    T: RusticolHighPrecisionNumber,
+    Complex<T>: Real + EvaluationDomain,
+{
+    let mut expanded_batch = Vec::with_capacity(batch.len() * mappings.len());
+    for mapping in mappings {
+        expanded_batch.extend(apply_lc_topology_label_permutation_generic(
+            batch,
+            expected_legs,
+            mapping,
+        )?);
+    }
+    Ok(expanded_batch)
+}
+
+pub(crate) fn replay_mappings_per_expanded_batch(n_points: usize) -> usize {
+    if n_points == 0 {
+        return 1;
+    }
+    (MAX_LC_TOPOLOGY_REPLAY_EXPANDED_POINTS / n_points).max(1)
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(crate) fn decimal_digits_to_bits(decimal_digits: u32) -> u32 {
+    (decimal_digits as f64 * std::f64::consts::LOG2_10).ceil() as u32
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/native_compiled_direct.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/native_compiled_direct.rs
new file mode 100644
index 0000000000..3eaedeaaa4
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/native_compiled_direct.rs
@@ -0,0 +1,1363 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Target-native DirectApplication adapter for one fused compiled leaf.
+//!
+//! C++ and inline-ASM compiled artifacts are both target-native dynamic
+//! libraries, so they share this small C ABI.  Unlike the historical
+//! `params/buffer/out` entry point, the native function consumes fixed
+//! split-complex plane descriptors and writes canonical output planes itself.
+//! It therefore does not hide a dense-row gather/call/scatter wrapper.
+//!
+//! This module is a bounded ABI prototype and is intentionally not wired into
+//! the production engine yet.
+
+#![allow(dead_code)]
+
+use std::path::Path;
+use std::ptr;
+use std::sync::Arc;
+
+use crate::artifact::PinnedNativeLibrary;
+use crate::direct_arena::{
+    AlignedF64Buffer, DirectArenaTrafficCounters, DirectArenaView, DirectFactorView,
+    DirectMomentumView, DirectParameterView, validate_direct_views,
+};
+use crate::{RusticolError, RusticolResult};
+
+pub(crate) const NATIVE_COMPILED_DIRECT_APPLICATION_ABI: &str =
+    "pyamplicol-native-compiled-direct-application-v1";
+
+const NATIVE_COMPILED_DIRECT_ABI_VERSION: u32 = 1;
+const NATIVE_COMPILED_DIRECT_FLAG_SPLIT_COMPLEX: u32 = 1 << 0;
+const NATIVE_COMPILED_DIRECT_FLAG_COMPONENT_MAJOR: u32 = 1 << 1;
+const NATIVE_COMPILED_DIRECT_FLAG_POINT_CONTIGUOUS: u32 = 1 << 2;
+const NATIVE_COMPILED_DIRECT_FLAG_FACTOR_FREE_OVERWRITE: u32 = 1 << 3;
+const NATIVE_COMPILED_DIRECT_FLAG_NO_OUTPUT_ALIAS: u32 = 1 << 4;
+const NATIVE_COMPILED_DIRECT_FLAG_NOEXCEPT: u32 = 1 << 5;
+const NATIVE_COMPILED_DIRECT_REQUIRED_FLAGS: u32 = NATIVE_COMPILED_DIRECT_FLAG_SPLIT_COMPLEX
+    | NATIVE_COMPILED_DIRECT_FLAG_COMPONENT_MAJOR
+    | NATIVE_COMPILED_DIRECT_FLAG_POINT_CONTIGUOUS
+    | NATIVE_COMPILED_DIRECT_FLAG_FACTOR_FREE_OVERWRITE
+    | NATIVE_COMPILED_DIRECT_FLAG_NO_OUTPUT_ALIAS
+    | NATIVE_COMPILED_DIRECT_FLAG_NOEXCEPT;
+const NATIVE_COMPILED_DIRECT_KNOWN_FLAGS: u32 = NATIVE_COMPILED_DIRECT_REQUIRED_FLAGS;
+const NATIVE_COMPILED_DIRECT_STATUS_OK: i32 = 0;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+struct NativeCompiledDirectMetadataV1 {
+    abi_version: u32,
+    struct_size: u32,
+    flags: u32,
+    input_plane_count: u32,
+    scalar_input_count: u32,
+    output_plane_count: u32,
+    simd_lane_width: u32,
+    reserved: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct NativeCompiledDirectDescriptorCounts {
+    input_planes: u32,
+    scalar_inputs: u32,
+    output_planes: u32,
+}
+
+impl NativeCompiledDirectDescriptorCounts {
+    fn checked_from_lengths(
+        input_planes: usize,
+        scalar_inputs: usize,
+        output_planes: usize,
+    ) -> RusticolResult<Self> {
+        Ok(Self {
+            input_planes: checked_descriptor_count(input_planes, "input-plane")?,
+            scalar_inputs: checked_descriptor_count(scalar_inputs, "scalar-input")?,
+            output_planes: checked_descriptor_count(output_planes, "output-plane")?,
+        })
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct NativeCompiledDirectInputPlaneV1 {
+    values: *const f64,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct NativeCompiledDirectOutputPlaneV1 {
+    values: *mut f64,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct NativeCompiledDirectScalarV1 {
+    value: *const f64,
+}
+
+type NativeCompiledDirectMetadataFunction =
+    unsafe extern "C" fn() -> NativeCompiledDirectMetadataV1;
+type NativeCompiledDirectEvaluateFunction = unsafe extern "C" fn(
+    *const NativeCompiledDirectInputPlaneV1,
+    u32,
+    *const NativeCompiledDirectScalarV1,
+    u32,
+    *const NativeCompiledDirectOutputPlaneV1,
+    u32,
+    u32,
+    u32,
+) -> i32;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub(crate) enum NativeCompiledDirectArenaPlane {
+    Current { component: u32, imaginary: bool },
+    Amplitude { component: u32, imaginary: bool },
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub(crate) enum NativeCompiledDirectPlaneBinding {
+    Arena(NativeCompiledDirectArenaPlane),
+    Momentum { form: u32, lorentz_component: u16 },
+    Zero,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum NativeCompiledDirectScalarBinding {
+    Parameter { index: u32, imaginary: bool },
+    Literal(f64),
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub(crate) struct NativeCompiledDirectOutputBinding(pub NativeCompiledDirectArenaPlane);
+
+/// Loaded native function plus its authenticated logical bindings.
+pub(crate) struct LoadedNativeCompiledDirectStage {
+    _library: Arc<PinnedNativeLibrary>,
+    evaluate: NativeCompiledDirectEvaluateFunction,
+    descriptor_counts: NativeCompiledDirectDescriptorCounts,
+    declared_lane_width: usize,
+    input_bindings: Box<[NativeCompiledDirectPlaneBinding]>,
+    scalar_bindings: Box<[NativeCompiledDirectScalarBinding]>,
+    output_bindings: Box<[NativeCompiledDirectOutputBinding]>,
+    display_path: Box<Path>,
+}
+
+/// Fixed descriptors borrowing persistent Direct-Arena allocations.
+pub(crate) struct BoundNativeCompiledDirectStage {
+    _library: Arc<PinnedNativeLibrary>,
+    evaluate: NativeCompiledDirectEvaluateFunction,
+    inputs: Box<[NativeCompiledDirectInputPlaneV1]>,
+    scalars: Box<[NativeCompiledDirectScalarV1]>,
+    outputs: Box<[NativeCompiledDirectOutputPlaneV1]>,
+    _literal_values: Box<[f64]>,
+    _zero_plane: AlignedF64Buffer,
+    input_count: u32,
+    scalar_count: u32,
+    output_count: u32,
+    point_stride: u32,
+    declared_lane_width: usize,
+    display_path: Box<Path>,
+}
+
+impl LoadedNativeCompiledDirectStage {
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn load(
+        library: Arc<PinnedNativeLibrary>,
+        function_name: &str,
+        application_abi: &str,
+        input_bindings: Vec<NativeCompiledDirectPlaneBinding>,
+        scalar_bindings: Vec<NativeCompiledDirectScalarBinding>,
+        output_bindings: Vec<NativeCompiledDirectOutputBinding>,
+    ) -> RusticolResult<Self> {
+        if application_abi != NATIVE_COMPILED_DIRECT_APPLICATION_ABI {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported native compiled DirectApplication ABI {application_abi:?}; expected \
+                 {NATIVE_COMPILED_DIRECT_APPLICATION_ABI:?}"
+            )));
+        }
+        validate_c_symbol(function_name)?;
+        let descriptor_counts = NativeCompiledDirectDescriptorCounts::checked_from_lengths(
+            input_bindings.len(),
+            scalar_bindings.len(),
+            output_bindings.len(),
+        )?;
+        validate_static_bindings(&input_bindings, &output_bindings)?;
+
+        let display_path = library.display_path().to_path_buf().into_boxed_path();
+        let path = display_path.as_ref();
+        let symbol_prefix = format!("{function_name}_direct_application_v1");
+        let metadata_symbol = format!("{symbol_prefix}_metadata");
+        let metadata_function = unsafe {
+            load_export::<NativeCompiledDirectMetadataFunction>(&library, path, &metadata_symbol)?
+        };
+        let evaluate = unsafe {
+            load_export::<NativeCompiledDirectEvaluateFunction>(&library, path, &symbol_prefix)?
+        };
+        // SAFETY: the authenticated producer contract assigns this symbol the
+        // fixed metadata signature. Native exports must be `noexcept`; foreign
+        // unwinding across this C boundary is not recoverable by Rust.
+        let metadata = unsafe { metadata_function() };
+        validate_metadata(metadata, descriptor_counts, path)?;
+
+        Ok(Self {
+            _library: library,
+            evaluate,
+            descriptor_counts,
+            declared_lane_width: metadata.simd_lane_width as usize,
+            input_bindings: input_bindings.into_boxed_slice(),
+            scalar_bindings: scalar_bindings.into_boxed_slice(),
+            output_bindings: output_bindings.into_boxed_slice(),
+            display_path,
+        })
+    }
+
+    pub(crate) const fn declared_lane_width(&self) -> usize {
+        self.declared_lane_width
+    }
+
+    /// Bind the native function to persistent plane and scalar storage.
+    ///
+    /// # Safety
+    ///
+    /// Every allocation referenced by `arena`, `momenta`, and `parameters`
+    /// must retain its address and declared length until the returned object
+    /// drops. During `evaluate`, the caller must provide exclusive access to
+    /// arena outputs and must not mutate any bound input or scalar storage.
+    pub(crate) unsafe fn bind(
+        self,
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+    ) -> RusticolResult<BoundNativeCompiledDirectStage> {
+        // SAFETY: this entry point preserves the historical identity mapping
+        // and forwards the caller's complete fixed-storage contract.
+        unsafe { self.bind_with_current_map(arena, momenta, parameters, &[]) }
+    }
+
+    /// Bind canonical current IDs through a cold, immutable physical map.
+    pub(crate) unsafe fn bind_with_current_map(
+        self,
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+        current_component_map: &[u32],
+    ) -> RusticolResult<BoundNativeCompiledDirectStage> {
+        validate_direct_views(
+            arena,
+            momenta,
+            parameters,
+            DirectFactorView {
+                values_re: ptr::null(),
+                values_im: ptr::null(),
+                value_count: 0,
+            },
+        )?;
+        validate_mapped_bindings(
+            &self.input_bindings,
+            &self.output_bindings,
+            current_component_map,
+        )?;
+
+        let point_stride = arena.point_stride;
+        let zero_plane =
+            AlignedF64Buffer::zeroed(point_stride as usize, "native compiled zero plane")?;
+        let mut literal_values = Vec::new();
+        literal_values
+            .try_reserve_exact(self.scalar_bindings.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate native compiled literal storage: {error}"
+                ))
+            })?;
+        literal_values.resize(self.scalar_bindings.len(), 0.0);
+        let mut literal_values = literal_values.into_boxed_slice();
+        for (index, binding) in self.scalar_bindings.iter().copied().enumerate() {
+            if let NativeCompiledDirectScalarBinding::Literal(value) = binding {
+                if !value.is_finite() {
+                    return Err(RusticolError::integrity(
+                        "native compiled DirectApplication literal must be finite",
+                    ));
+                }
+                literal_values[index] = value;
+            }
+        }
+
+        let inputs = self
+            .input_bindings
+            .iter()
+            .copied()
+            .map(|binding| {
+                resolve_input_plane(binding, arena, momenta, &zero_plane, current_component_map)
+                    .map(|values| NativeCompiledDirectInputPlaneV1 { values })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        let outputs = self
+            .output_bindings
+            .iter()
+            .copied()
+            .map(|binding| {
+                resolve_arena_plane(binding.0, arena, current_component_map)
+                    .map(|values| NativeCompiledDirectOutputPlaneV1 { values })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        let scalars = self
+            .scalar_bindings
+            .iter()
+            .copied()
+            .enumerate()
+            .map(|(literal_index, binding)| {
+                let value = match binding {
+                    NativeCompiledDirectScalarBinding::Parameter { index, imaginary } => {
+                        if index >= parameters.value_count {
+                            return Err(RusticolError::integrity(format!(
+                                "native compiled parameter binding {index} is out of bounds"
+                            )));
+                        }
+                        let base = if imaginary {
+                            parameters.values_im
+                        } else {
+                            parameters.values_re
+                        };
+                        // SAFETY: the parameter view was validated and `index`
+                        // lies within its declared storage.
+                        unsafe { base.add(index as usize) }
+                    }
+                    NativeCompiledDirectScalarBinding::Literal(_) => {
+                        ptr::from_ref(&literal_values[literal_index])
+                    }
+                };
+                Ok(NativeCompiledDirectScalarV1 { value })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        let descriptor_counts = NativeCompiledDirectDescriptorCounts::checked_from_lengths(
+            inputs.len(),
+            scalars.len(),
+            outputs.len(),
+        )?;
+        if descriptor_counts != self.descriptor_counts {
+            return Err(RusticolError::internal(
+                "native compiled descriptor counts changed while binding persistent storage",
+            ));
+        }
+
+        Ok(BoundNativeCompiledDirectStage {
+            _library: self._library,
+            evaluate: self.evaluate,
+            inputs,
+            scalars,
+            outputs,
+            _literal_values: literal_values,
+            _zero_plane: zero_plane,
+            input_count: descriptor_counts.input_planes,
+            scalar_count: descriptor_counts.scalar_inputs,
+            output_count: descriptor_counts.output_planes,
+            point_stride,
+            declared_lane_width: self.declared_lane_width,
+            display_path: self.display_path,
+        })
+    }
+}
+
+impl BoundNativeCompiledDirectStage {
+    pub(crate) const fn declared_lane_width(&self) -> usize {
+        self.declared_lane_width
+    }
+
+    /// Invoke the authenticated native function without allocating or packing.
+    pub(crate) fn evaluate(&self, point_start: u32, point_count: u32) -> RusticolResult<()> {
+        if point_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "native compiled DirectApplication point count must be positive",
+            ));
+        }
+        let point_stop = point_start.checked_add(point_count).ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "native compiled DirectApplication point range overflows u32",
+            )
+        })?;
+        if point_stop > self.point_stride {
+            return Err(RusticolError::invalid_argument(format!(
+                "native compiled DirectApplication point range {point_start}..{point_stop} \
+                 exceeds physical stride {}",
+                self.point_stride
+            )));
+        }
+
+        // SAFETY: load and bind authenticated the function signature and fixed
+        // descriptors. The producer contract requires `noexcept` and status
+        // returns; Rust cannot contain foreign unwinding across this C ABI.
+        let status = unsafe {
+            (self.evaluate)(
+                self.inputs.as_ptr(),
+                self.input_count,
+                self.scalars.as_ptr(),
+                self.scalar_count,
+                self.outputs.as_ptr(),
+                self.output_count,
+                point_start,
+                point_count,
+            )
+        };
+        if status != NATIVE_COMPILED_DIRECT_STATUS_OK {
+            return Err(RusticolError::evaluation(format!(
+                "native compiled DirectApplication {} returned status {status}",
+                self.display_path.display()
+            )));
+        }
+        Ok(())
+    }
+
+    /// Profile adapter-side traffic without adding work to the unprofiled path.
+    ///
+    /// These counters describe Rust-side materialization around the call. They
+    /// cannot observe allocation or copying hidden inside a native producer.
+    pub(crate) fn evaluate_profiled(
+        &self,
+        point_start: u32,
+        point_count: u32,
+        traffic: &mut DirectArenaTrafficCounters,
+    ) -> RusticolResult<()> {
+        self.evaluate(point_start, point_count)?;
+        traffic.record_call(1, point_count);
+        traffic.validate_direct()
+    }
+}
+
+fn validate_metadata(
+    metadata: NativeCompiledDirectMetadataV1,
+    descriptor_counts: NativeCompiledDirectDescriptorCounts,
+    path: &Path,
+) -> RusticolResult<()> {
+    if metadata.abi_version != NATIVE_COMPILED_DIRECT_ABI_VERSION
+        || metadata.struct_size as usize != std::mem::size_of::<NativeCompiledDirectMetadataV1>()
+        || metadata.reserved != 0
+    {
+        return Err(RusticolError::compatibility(format!(
+            "native compiled DirectApplication {} has incompatible v1 metadata",
+            path.display()
+        )));
+    }
+    if metadata.flags & NATIVE_COMPILED_DIRECT_REQUIRED_FLAGS
+        != NATIVE_COMPILED_DIRECT_REQUIRED_FLAGS
+        || metadata.flags & !NATIVE_COMPILED_DIRECT_KNOWN_FLAGS != 0
+    {
+        return Err(RusticolError::compatibility(format!(
+            "native compiled DirectApplication {} does not certify split-plane, \
+             point-contiguous, factor-free overwrite, no-alias and noexcept semantics",
+            path.display()
+        )));
+    }
+    for (actual, expected, label) in [
+        (
+            metadata.input_plane_count,
+            descriptor_counts.input_planes,
+            "input plane",
+        ),
+        (
+            metadata.scalar_input_count,
+            descriptor_counts.scalar_inputs,
+            "scalar input",
+        ),
+        (
+            metadata.output_plane_count,
+            descriptor_counts.output_planes,
+            "output plane",
+        ),
+    ] {
+        if actual != expected {
+            return Err(RusticolError::integrity(format!(
+                "native compiled DirectApplication {} {label} count {actual} does not match \
+                 binding count {expected}",
+                path.display()
+            )));
+        }
+    }
+    if metadata.simd_lane_width == 0 || !metadata.simd_lane_width.is_power_of_two() {
+        return Err(RusticolError::compatibility(format!(
+            "native compiled DirectApplication {} has invalid declared lane width {}",
+            path.display(),
+            metadata.simd_lane_width
+        )));
+    }
+    Ok(())
+}
+
+fn checked_descriptor_count(count: usize, label: &str) -> RusticolResult<u32> {
+    u32::try_from(count).map_err(|_| {
+        RusticolError::integrity(format!(
+            "native compiled DirectApplication {label} count {count} exceeds u32"
+        ))
+    })
+}
+
+fn validate_static_bindings(
+    inputs: &[NativeCompiledDirectPlaneBinding],
+    outputs: &[NativeCompiledDirectOutputBinding],
+) -> RusticolResult<()> {
+    if outputs.is_empty() {
+        return Err(RusticolError::integrity(
+            "native compiled DirectApplication must expose an output",
+        ));
+    }
+    for (index, output) in outputs.iter().copied().enumerate() {
+        if outputs[..index].contains(&output) {
+            return Err(RusticolError::integrity(format!(
+                "native compiled output binding {index} aliases an earlier output"
+            )));
+        }
+        if inputs.contains(&NativeCompiledDirectPlaneBinding::Arena(output.0)) {
+            return Err(RusticolError::integrity(format!(
+                "native compiled output binding {index} aliases an input plane"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_mapped_bindings(
+    inputs: &[NativeCompiledDirectPlaneBinding],
+    outputs: &[NativeCompiledDirectOutputBinding],
+    current_component_map: &[u32],
+) -> RusticolResult<()> {
+    let mapped_inputs = inputs
+        .iter()
+        .copied()
+        .filter_map(|binding| match binding {
+            NativeCompiledDirectPlaneBinding::Arena(arena) => {
+                Some(map_arena_plane(arena, current_component_map))
+            }
+            NativeCompiledDirectPlaneBinding::Momentum { .. }
+            | NativeCompiledDirectPlaneBinding::Zero => None,
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let mut mapped_outputs = Vec::with_capacity(outputs.len());
+    for (index, output) in outputs.iter().copied().enumerate() {
+        let mapped = map_arena_plane(output.0, current_component_map)?;
+        if mapped_outputs.contains(&mapped) {
+            return Err(RusticolError::integrity(format!(
+                "native compiled mapped output binding {index} aliases an earlier output"
+            )));
+        }
+        if mapped_inputs.contains(&mapped) {
+            return Err(RusticolError::integrity(format!(
+                "native compiled mapped output binding {index} aliases an input plane"
+            )));
+        }
+        mapped_outputs.push(mapped);
+    }
+    Ok(())
+}
+
+fn map_arena_plane(
+    binding: NativeCompiledDirectArenaPlane,
+    current_component_map: &[u32],
+) -> RusticolResult<NativeCompiledDirectArenaPlane> {
+    match binding {
+        NativeCompiledDirectArenaPlane::Current {
+            component,
+            imaginary,
+        } if !current_component_map.is_empty() => {
+            let physical = current_component_map
+                .get(component as usize)
+                .copied()
+                .filter(|physical| *physical != u32::MAX)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "native compiled current binding {component} has no physical mapping"
+                    ))
+                })?;
+            Ok(NativeCompiledDirectArenaPlane::Current {
+                component: physical,
+                imaginary,
+            })
+        }
+        _ => Ok(binding),
+    }
+}
+
+fn resolve_input_plane(
+    binding: NativeCompiledDirectPlaneBinding,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    zero_plane: &AlignedF64Buffer,
+    current_component_map: &[u32],
+) -> RusticolResult<*const f64> {
+    match binding {
+        NativeCompiledDirectPlaneBinding::Arena(binding) => {
+            Ok(resolve_arena_plane(binding, arena, current_component_map)?.cast_const())
+        }
+        NativeCompiledDirectPlaneBinding::Momentum {
+            form,
+            lorentz_component,
+        } => {
+            if form >= momenta.form_count || lorentz_component >= momenta.lorentz_component_count {
+                return Err(RusticolError::integrity(format!(
+                    "native compiled momentum binding ({form}, {lorentz_component}) is out of \
+                     bounds"
+                )));
+            }
+            let component = form
+                .checked_mul(u32::from(momenta.lorentz_component_count))
+                .and_then(|base| base.checked_add(u32::from(lorentz_component)))
+                .ok_or_else(|| {
+                    RusticolError::integrity("native compiled momentum component overflows u32")
+                })?;
+            let offset = usize::try_from(component)
+                .ok()
+                .and_then(|component| component.checked_mul(momenta.point_stride as usize))
+                .ok_or_else(|| {
+                    RusticolError::integrity("native compiled momentum offset overflows usize")
+                })?;
+            // SAFETY: view and component bounds were validated.
+            Ok(unsafe { momenta.values.add(offset) })
+        }
+        NativeCompiledDirectPlaneBinding::Zero => Ok(zero_plane.as_ptr()),
+    }
+}
+
+fn resolve_arena_plane(
+    binding: NativeCompiledDirectArenaPlane,
+    arena: DirectArenaView,
+    current_component_map: &[u32],
+) -> RusticolResult<*mut f64> {
+    let binding = map_arena_plane(binding, current_component_map)?;
+    let (base, shape, label) = match binding {
+        NativeCompiledDirectArenaPlane::Current {
+            component,
+            imaginary,
+        } => (
+            if imaginary {
+                arena.current_im
+            } else {
+                arena.current_re
+            },
+            arena.current_shape()?,
+            ("current", component),
+        ),
+        NativeCompiledDirectArenaPlane::Amplitude {
+            component,
+            imaginary,
+        } => (
+            if imaginary {
+                arena.amplitude_im
+            } else {
+                arena.amplitude_re
+            },
+            arena.amplitude_shape()?,
+            ("amplitude", component),
+        ),
+    };
+    let offset = shape.checked_scalar_index(label.1, 0, label.0)?;
+    // SAFETY: the checked component proves a complete pitched plane exists.
+    Ok(unsafe { base.add(offset) })
+}
+
+fn validate_c_symbol(symbol: &str) -> RusticolResult<()> {
+    let mut bytes = symbol.bytes();
+    let Some(first) = bytes.next() else {
+        return Err(RusticolError::invalid_argument(
+            "native compiled DirectApplication function name must not be empty",
+        ));
+    };
+    if !(first == b'_' || first.is_ascii_alphabetic())
+        || bytes.any(|byte| !(byte == b'_' || byte.is_ascii_alphanumeric()))
+    {
+        return Err(RusticolError::invalid_argument(format!(
+            "native compiled DirectApplication function name {symbol:?} is not a portable C \
+             identifier"
+        )));
+    }
+    Ok(())
+}
+
+unsafe fn load_export<T: Copy>(
+    library: &libloading::Library,
+    path: &Path,
+    exported_symbol: &str,
+) -> RusticolResult<T> {
+    // SAFETY: the producer contract assigns each fixed symbol the exact v1
+    // signature selected by the caller.
+    unsafe {
+        library
+            .get::<T>(exported_symbol.as_bytes())
+            .map(|symbol| *symbol)
+            .map_err(|error| {
+                RusticolError::evaluation(format!(
+                    "could not load native compiled DirectApplication symbol \
+                     {exported_symbol:?} from {}: {error}",
+                    path.display()
+                ))
+            })
+    }
+}
+
+#[cfg(all(test, any(target_os = "linux", target_os = "macos")))]
+mod tests {
+    use super::super::CompiledComplexF64Evaluator;
+    #[cfg(not(feature = "f64-symjit"))]
+    use super::super::native_direct::tests::count_allocations;
+    #[cfg(feature = "f64-symjit")]
+    use super::super::symjit_direct::tests::count_allocations;
+    use super::*;
+    use crate::RusticolErrorKind;
+    use crate::direct_arena::{DirectArenaWorkspace, DirectMomentumView};
+    #[cfg(not(feature = "symbolica-runtime"))]
+    use num_complex::Complex;
+    use std::fs;
+    use std::process::Command;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use std::time::{Instant, SystemTime, UNIX_EPOCH};
+    #[cfg(feature = "symbolica-runtime")]
+    use symbolica::prelude::Complex;
+
+    const POINT_COUNT: usize = 129;
+    const REQUIRED_FLAGS: u32 = NATIVE_COMPILED_DIRECT_REQUIRED_FLAGS;
+    static FIXTURE_SEQUENCE: AtomicU64 = AtomicU64::new(0);
+
+    fn native_fixture() -> (std::path::PathBuf, std::path::PathBuf) {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let directory = std::env::temp_dir().join(format!(
+            "rusticol-native-compiled-direct-test-{}-{unique}-{}",
+            std::process::id(),
+            FIXTURE_SEQUENCE.fetch_add(1, Ordering::Relaxed),
+        ));
+        fs::create_dir_all(&directory).unwrap();
+        let source = directory.join("fixture.cpp");
+        let library = directory.join(if cfg!(target_os = "macos") {
+            "libfixture.dylib"
+        } else {
+            "libfixture.so"
+        });
+        fs::write(
+            &source,
+            format!(
+                r#"#include <complex>
+#include <cstdint>
+#include <cstddef>
+
+struct Metadata {{
+  std::uint32_t abi_version;
+  std::uint32_t struct_size;
+  std::uint32_t flags;
+  std::uint32_t input_plane_count;
+  std::uint32_t scalar_input_count;
+  std::uint32_t output_plane_count;
+  std::uint32_t simd_lane_width;
+  std::uint32_t reserved;
+}};
+struct InputPlane {{ const double* values; }};
+struct OutputPlane {{ double* values; }};
+struct Scalar {{ const double* value; }};
+
+extern "C" unsigned long rusticol_native_leaf_complexf64_get_buffer_len() {{
+  return 1ul;
+}}
+extern "C" void rusticol_native_leaf_complexf64(
+    const std::complex<double>* params,
+    std::complex<double>* buffer,
+    std::complex<double>* out) {{
+  buffer[0] = params[0] * params[1];
+  out[0] = buffer[0] + params[2];
+  out[1] = params[0] + params[1];
+}}
+
+extern "C" Metadata
+rusticol_native_leaf_direct_application_v1_metadata() noexcept {{
+  return Metadata{{1u, sizeof(Metadata), {REQUIRED_FLAGS}u, 4u, 2u, 4u, 2u, 0u}};
+}}
+
+// This is a synthetic scalar plane-loop fixture. It addresses planes directly,
+// never calls the dense function, and never constructs a params/buffer/out row.
+// The declared width of 2 exercises metadata plumbing; it is not proof that
+// this fixture contains SIMD or production compressed-O3 code.
+extern "C" int rusticol_native_leaf_direct_application_v1(
+    const InputPlane* inputs,
+    std::uint32_t input_count,
+    const Scalar* scalars,
+    std::uint32_t scalar_count,
+    const OutputPlane* outputs,
+    std::uint32_t output_count,
+    std::uint32_t point_start,
+    std::uint32_t point_count) noexcept {{
+  if (inputs == nullptr || outputs == nullptr || scalars == nullptr ||
+      input_count != 4u || scalar_count != 2u || output_count != 4u ||
+      point_count == 0u) return 2;
+  for (std::uint32_t offset = 0; offset < point_count; ++offset) {{
+    const std::uint32_t point = point_start + offset;
+    const double x_re = inputs[0].values[point];
+    const double x_im = inputs[1].values[point];
+    const double y_re = inputs[2].values[point];
+    const double y_im = inputs[3].values[point];
+    const double product_re = x_re * y_re - x_im * y_im;
+    const double product_im = x_re * y_im + x_im * y_re;
+    outputs[0].values[point] = product_re + *scalars[0].value;
+    outputs[1].values[point] = product_im + *scalars[1].value;
+    outputs[2].values[point] = x_re + y_re;
+    outputs[3].values[point] = x_im + y_im;
+  }}
+  return 0;
+}}
+
+extern "C" Metadata
+rusticol_status_leaf_direct_application_v1_metadata() noexcept {{
+  return Metadata{{1u, sizeof(Metadata), {REQUIRED_FLAGS}u, 4u, 2u, 4u, 1u, 0u}};
+}}
+extern "C" int rusticol_status_leaf_direct_application_v1(
+    const InputPlane*, std::uint32_t, const Scalar*, std::uint32_t,
+    const OutputPlane*, std::uint32_t, std::uint32_t, std::uint32_t) noexcept {{
+  return 17;
+}}
+"#
+            ),
+        )
+        .unwrap();
+        let compiler = std::env::var("CXX").unwrap_or_else(|_| "c++".to_string());
+        let mut command = Command::new(compiler);
+        command.args(["-std=c++17", "-O3"]);
+        if cfg!(target_os = "macos") {
+            command.arg("-dynamiclib");
+        } else {
+            command.args(["-shared", "-fPIC"]);
+        }
+        let output = command
+            .arg(&source)
+            .arg("-o")
+            .arg(&library)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "could not compile native direct fixture: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        (directory, library)
+    }
+
+    fn input_bindings() -> Vec<NativeCompiledDirectPlaneBinding> {
+        vec![
+            NativeCompiledDirectPlaneBinding::Arena(NativeCompiledDirectArenaPlane::Current {
+                component: 0,
+                imaginary: false,
+            }),
+            NativeCompiledDirectPlaneBinding::Arena(NativeCompiledDirectArenaPlane::Current {
+                component: 0,
+                imaginary: true,
+            }),
+            NativeCompiledDirectPlaneBinding::Arena(NativeCompiledDirectArenaPlane::Current {
+                component: 1,
+                imaginary: false,
+            }),
+            NativeCompiledDirectPlaneBinding::Arena(NativeCompiledDirectArenaPlane::Current {
+                component: 1,
+                imaginary: true,
+            }),
+        ]
+    }
+
+    fn scalar_bindings() -> Vec<NativeCompiledDirectScalarBinding> {
+        vec![
+            NativeCompiledDirectScalarBinding::Parameter {
+                index: 0,
+                imaginary: false,
+            },
+            NativeCompiledDirectScalarBinding::Parameter {
+                index: 0,
+                imaginary: true,
+            },
+        ]
+    }
+
+    fn output_bindings() -> Vec<NativeCompiledDirectOutputBinding> {
+        vec![
+            NativeCompiledDirectOutputBinding(NativeCompiledDirectArenaPlane::Current {
+                component: 2,
+                imaginary: false,
+            }),
+            NativeCompiledDirectOutputBinding(NativeCompiledDirectArenaPlane::Current {
+                component: 2,
+                imaginary: true,
+            }),
+            NativeCompiledDirectOutputBinding(NativeCompiledDirectArenaPlane::Current {
+                component: 3,
+                imaginary: false,
+            }),
+            NativeCompiledDirectOutputBinding(NativeCompiledDirectArenaPlane::Current {
+                component: 3,
+                imaginary: true,
+            }),
+        ]
+    }
+
+    fn empty_momenta(point_stride: u32) -> AlignedF64Buffer {
+        AlignedF64Buffer::zeroed(4 * point_stride as usize, "native compiled test momenta").unwrap()
+    }
+
+    fn momentum_view(values: &AlignedF64Buffer, point_stride: u32) -> DirectMomentumView {
+        DirectMomentumView {
+            values: values.as_ptr(),
+            scalar_len: values.len() as u64,
+            form_count: 1,
+            lorentz_component_count: 4,
+            point_stride,
+        }
+    }
+
+    fn fill_inputs(workspace: &mut DirectArenaWorkspace, point_count: usize) {
+        let stride = workspace.point_stride() as usize;
+        let (current_re, current_im, _, _) = workspace.split_slices_mut();
+        for point in 0..point_count {
+            current_re[point] = 0.25 + point as f64 * 0.03125;
+            current_im[point] = if point % 2 == 0 { -0.0 } else { 0.5 };
+            current_re[stride + point] = 1.5 - point as f64 * 0.0078125;
+            current_im[stride + point] = if point % 3 == 0 { 0.0 } else { -0.25 };
+        }
+    }
+
+    fn load_and_bind(
+        library: &Path,
+        function_name: &str,
+        workspace: &mut DirectArenaWorkspace,
+        momenta: &AlignedF64Buffer,
+        parameter_re: &[f64; 1],
+        parameter_im: &[f64; 1],
+    ) -> RusticolResult<BoundNativeCompiledDirectStage> {
+        let loaded = LoadedNativeCompiledDirectStage::load(
+            PinnedNativeLibrary::from_test_path(library)?,
+            function_name,
+            NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+            input_bindings(),
+            scalar_bindings(),
+            output_bindings(),
+        )?;
+        let arena = workspace.view()?;
+        let parameters = DirectParameterView {
+            values_re: parameter_re.as_ptr(),
+            values_im: parameter_im.as_ptr(),
+            value_count: 1,
+        };
+        unsafe {
+            loaded.bind(
+                arena,
+                momentum_view(momenta, arena.point_stride),
+                parameters,
+            )
+        }
+    }
+
+    #[test]
+    fn synthetic_plane_loop_preserves_odd_tails_and_allocates_zero_when_warm() {
+        let (directory, library) = native_fixture();
+        let mut workspace = DirectArenaWorkspace::new(4, 0, POINT_COUNT as u32).unwrap();
+        workspace.begin_tile(POINT_COUNT as u32).unwrap();
+        fill_inputs(&mut workspace, POINT_COUNT);
+        let stride = workspace.point_stride() as usize;
+        let momenta = empty_momenta(stride as u32);
+        let parameter_re = [0.375];
+        let parameter_im = [-0.625];
+        let bound = load_and_bind(
+            &library,
+            "rusticol_native_leaf",
+            &mut workspace,
+            &momenta,
+            &parameter_re,
+            &parameter_im,
+        )
+        .unwrap();
+        assert_eq!(bound.declared_lane_width(), 2);
+
+        for (point_start, point_count) in [
+            (0_u32, 1_u32),
+            (0, 2),
+            (0, 3),
+            (0, 127),
+            (1, 127),
+            (0, 128),
+            (0, 129),
+        ] {
+            {
+                let (current_re, current_im, _, _) = workspace.split_slices_mut();
+                current_re[2 * stride..4 * stride].fill(f64::NAN);
+                current_im[2 * stride..4 * stride].fill(f64::NAN);
+            }
+            bound.evaluate(point_start, point_count).unwrap();
+            let point_stop = (point_start + point_count) as usize;
+            let (current_re, current_im) = workspace.current_slices();
+            for point in point_start as usize..point_stop {
+                let x = Complex::new(current_re[point], current_im[point]);
+                let y = Complex::new(current_re[stride + point], current_im[stride + point]);
+                let expected_product = x * y + Complex::new(parameter_re[0], parameter_im[0]);
+                let expected_sum = x + y;
+                assert_eq!(
+                    current_re[2 * stride + point].to_bits(),
+                    expected_product.re.to_bits()
+                );
+                assert_eq!(
+                    current_im[2 * stride + point].to_bits(),
+                    expected_product.im.to_bits()
+                );
+                assert_eq!(
+                    current_re[3 * stride + point].to_bits(),
+                    expected_sum.re.to_bits()
+                );
+                assert_eq!(
+                    current_im[3 * stride + point].to_bits(),
+                    expected_sum.im.to_bits()
+                );
+            }
+            for point in (0..point_start as usize).chain(point_stop..stride) {
+                assert!(current_re[2 * stride + point].is_nan());
+                assert!(current_im[2 * stride + point].is_nan());
+                assert!(current_re[3 * stride + point].is_nan());
+                assert!(current_im[3 * stride + point].is_nan());
+            }
+        }
+
+        bound.evaluate(0, POINT_COUNT as u32).unwrap();
+        let (result, allocation_count, allocated_bytes) =
+            count_allocations(|| bound.evaluate(0, POINT_COUNT as u32));
+        result.unwrap();
+        assert_eq!(
+            allocation_count, 0,
+            "warmed native direct call allocated in Rust"
+        );
+        assert_eq!(
+            allocated_bytes, 0,
+            "warmed native direct call allocated bytes in Rust"
+        );
+        // This accounts only for Rust adapter-side traffic. The fixture source
+        // is inspected separately to establish that its native loop also
+        // contains no dense-row wrapper.
+        let mut traffic = DirectArenaTrafficCounters::default();
+        bound
+            .evaluate_profiled(0, POINT_COUNT as u32, &mut traffic)
+            .unwrap();
+        assert_eq!(traffic.calls, 1);
+        assert_eq!(traffic.rows, 1);
+        assert_eq!(traffic.points, POINT_COUNT as u64);
+        assert_eq!(traffic.packet_input_bytes, 0);
+        assert_eq!(traffic.packet_output_bytes, 0);
+        assert_eq!(traffic.gather_bytes, 0);
+        assert_eq!(traffic.scatter_bytes, 0);
+        assert_eq!(traffic.remap_bytes, 0);
+        fs::remove_dir_all(directory).unwrap();
+    }
+
+    #[test]
+    fn synthetic_plane_loop_matches_existing_dense_gather_call_scatter() {
+        let (directory, library) = native_fixture();
+        let mut workspace = DirectArenaWorkspace::new(4, 0, POINT_COUNT as u32).unwrap();
+        workspace.begin_tile(POINT_COUNT as u32).unwrap();
+        fill_inputs(&mut workspace, POINT_COUNT);
+        let stride = workspace.point_stride() as usize;
+        let momenta = empty_momenta(stride as u32);
+        let parameter_re = [0.375];
+        let parameter_im = [-0.625];
+
+        let mut dense = CompiledComplexF64Evaluator::load(
+            PinnedNativeLibrary::from_test_path(&library).unwrap(),
+            "rusticol_native_leaf",
+            3,
+            2,
+        )
+        .unwrap();
+        let mut packed_inputs = vec![Complex::new(0.0, 0.0); POINT_COUNT * 3];
+        let mut packed_outputs = vec![Complex::new(0.0, 0.0); POINT_COUNT * 2];
+        {
+            let (current_re, current_im) = workspace.current_slices();
+            for point in 0..POINT_COUNT {
+                packed_inputs[3 * point] = Complex::new(current_re[point], current_im[point]);
+                packed_inputs[3 * point + 1] =
+                    Complex::new(current_re[stride + point], current_im[stride + point]);
+                packed_inputs[3 * point + 2] = Complex::new(parameter_re[0], parameter_im[0]);
+            }
+        }
+        dense
+            .evaluate_batch(POINT_COUNT, &packed_inputs, &mut packed_outputs)
+            .unwrap();
+        let bound = load_and_bind(
+            &library,
+            "rusticol_native_leaf",
+            &mut workspace,
+            &momenta,
+            &parameter_re,
+            &parameter_im,
+        )
+        .unwrap();
+        bound.evaluate(0, POINT_COUNT as u32).unwrap();
+
+        let (current_re, current_im) = workspace.current_slices();
+        for point in 0..POINT_COUNT {
+            for (component, expected) in [
+                (2, packed_outputs[2 * point]),
+                (3, packed_outputs[2 * point + 1]),
+            ] {
+                assert_eq!(
+                    current_re[component * stride + point].to_bits(),
+                    expected.re.to_bits()
+                );
+                assert_eq!(
+                    current_im[component * stride + point].to_bits(),
+                    expected.im.to_bits()
+                );
+            }
+        }
+        fs::remove_dir_all(directory).unwrap();
+    }
+
+    #[test]
+    fn mapped_native_bindings_reject_a_physical_input_output_alias() {
+        let error = validate_mapped_bindings(&input_bindings(), &output_bindings(), &[0, 1, 0, 1])
+            .unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+        assert!(error.message().contains("mapped output"));
+        assert!(error.message().contains("aliases an input plane"));
+    }
+
+    #[test]
+    fn aliases_bounds_and_native_status_fail_closed() {
+        let (directory, library) = native_fixture();
+        let mut aliased_outputs = output_bindings();
+        aliased_outputs[0] =
+            NativeCompiledDirectOutputBinding(NativeCompiledDirectArenaPlane::Current {
+                component: 0,
+                imaginary: false,
+            });
+        let alias_error = match LoadedNativeCompiledDirectStage::load(
+            PinnedNativeLibrary::from_test_path(&library).unwrap(),
+            "rusticol_native_leaf",
+            NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+            input_bindings(),
+            scalar_bindings(),
+            aliased_outputs,
+        ) {
+            Ok(_) => panic!("input/output alias unexpectedly loaded"),
+            Err(error) => error,
+        };
+        assert_eq!(alias_error.kind(), RusticolErrorKind::Integrity);
+        assert!(alias_error.message().contains("aliases an input plane"));
+
+        let mut workspace = DirectArenaWorkspace::new(4, 0, POINT_COUNT as u32).unwrap();
+        workspace.begin_tile(POINT_COUNT as u32).unwrap();
+        fill_inputs(&mut workspace, POINT_COUNT);
+        let stride = workspace.point_stride();
+        let momenta = empty_momenta(stride);
+        let parameter_re = [0.375];
+        let parameter_im = [-0.625];
+        let bound = load_and_bind(
+            &library,
+            "rusticol_native_leaf",
+            &mut workspace,
+            &momenta,
+            &parameter_re,
+            &parameter_im,
+        )
+        .unwrap();
+        assert_eq!(
+            bound.evaluate(stride - 1, 2).unwrap_err().kind(),
+            RusticolErrorKind::InvalidArgument
+        );
+        assert_eq!(
+            bound.evaluate(0, 0).unwrap_err().kind(),
+            RusticolErrorKind::InvalidArgument
+        );
+
+        let status_bound = load_and_bind(
+            &library,
+            "rusticol_status_leaf",
+            &mut workspace,
+            &momenta,
+            &parameter_re,
+            &parameter_im,
+        )
+        .unwrap();
+        let error = status_bound.evaluate(0, 1).unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Evaluation);
+        assert!(error.message().contains("status 17"));
+        fs::remove_dir_all(directory).unwrap();
+    }
+
+    #[test]
+    fn descriptor_counts_fail_before_any_truncating_ffi_conversion() {
+        let maximum = NativeCompiledDirectDescriptorCounts::checked_from_lengths(
+            u32::MAX as usize,
+            u32::MAX as usize,
+            u32::MAX as usize,
+        )
+        .unwrap();
+        assert_eq!(maximum.input_planes, u32::MAX);
+        assert_eq!(maximum.scalar_inputs, u32::MAX);
+        assert_eq!(maximum.output_planes, u32::MAX);
+
+        if usize::BITS > u32::BITS {
+            let too_many = usize::try_from(u64::from(u32::MAX) + 1).unwrap();
+            for error in [
+                NativeCompiledDirectDescriptorCounts::checked_from_lengths(too_many, 0, 1)
+                    .unwrap_err(),
+                NativeCompiledDirectDescriptorCounts::checked_from_lengths(0, too_many, 1)
+                    .unwrap_err(),
+                NativeCompiledDirectDescriptorCounts::checked_from_lengths(0, 0, too_many)
+                    .unwrap_err(),
+            ] {
+                assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+                assert!(error.message().contains("exceeds u32"));
+            }
+        }
+    }
+
+    fn gather_call_scatter(
+        dense: &mut CompiledComplexF64Evaluator,
+        workspace: &mut DirectArenaWorkspace,
+        parameter: Complex<f64>,
+        packed_inputs: &mut [Complex<f64>],
+        packed_outputs: &mut [Complex<f64>],
+    ) {
+        let stride = workspace.point_stride() as usize;
+        {
+            let (current_re, current_im) = workspace.current_slices();
+            for point in 0..POINT_COUNT {
+                packed_inputs[3 * point] = Complex::new(current_re[point], current_im[point]);
+                packed_inputs[3 * point + 1] =
+                    Complex::new(current_re[stride + point], current_im[stride + point]);
+                packed_inputs[3 * point + 2] = parameter;
+            }
+        }
+        dense
+            .evaluate_batch(POINT_COUNT, packed_inputs, packed_outputs)
+            .unwrap();
+        let (current_re, current_im, _, _) = workspace.split_slices_mut();
+        for point in 0..POINT_COUNT {
+            let product = packed_outputs[2 * point];
+            let sum = packed_outputs[2 * point + 1];
+            current_re[2 * stride + point] = product.re;
+            current_im[2 * stride + point] = product.im;
+            current_re[3 * stride + point] = sum.re;
+            current_im[3 * stride + point] = sum.im;
+        }
+    }
+
+    fn median(values: &mut [u128]) -> u128 {
+        values.sort_unstable();
+        values[values.len() / 2]
+    }
+
+    fn median_absolute_deviation(values: &[u128], center: u128) -> u128 {
+        let mut deviations = values
+            .iter()
+            .map(|value| value.abs_diff(center))
+            .collect::<Vec<_>>();
+        median(&mut deviations)
+    }
+
+    #[test]
+    #[ignore = "manual interleaved native DirectApplication benchmark"]
+    fn benchmark_synthetic_native_plane_loop_against_gather_call_scatter() {
+        const SAMPLES: usize = 9;
+        const REPEATS: usize = 10_000;
+
+        let (directory, library) = native_fixture();
+        let mut workspace = DirectArenaWorkspace::new(4, 0, POINT_COUNT as u32).unwrap();
+        workspace.begin_tile(POINT_COUNT as u32).unwrap();
+        fill_inputs(&mut workspace, POINT_COUNT);
+        let stride = workspace.point_stride();
+        let momenta = empty_momenta(stride);
+        let parameter_re = [0.375];
+        let parameter_im = [-0.625];
+        let parameter = Complex::new(parameter_re[0], parameter_im[0]);
+        let bound = load_and_bind(
+            &library,
+            "rusticol_native_leaf",
+            &mut workspace,
+            &momenta,
+            &parameter_re,
+            &parameter_im,
+        )
+        .unwrap();
+        let mut dense = CompiledComplexF64Evaluator::load(
+            PinnedNativeLibrary::from_test_path(&library).unwrap(),
+            "rusticol_native_leaf",
+            3,
+            2,
+        )
+        .unwrap();
+        let mut packed_inputs = vec![Complex::new(0.0, 0.0); POINT_COUNT * 3];
+        let mut packed_outputs = vec![Complex::new(0.0, 0.0); POINT_COUNT * 2];
+
+        bound.evaluate(0, POINT_COUNT as u32).unwrap();
+        gather_call_scatter(
+            &mut dense,
+            &mut workspace,
+            parameter,
+            &mut packed_inputs,
+            &mut packed_outputs,
+        );
+        let (_, direct_allocations, direct_bytes) =
+            count_allocations(|| bound.evaluate(0, POINT_COUNT as u32));
+        let (_, packed_allocations, packed_bytes) = count_allocations(|| {
+            gather_call_scatter(
+                &mut dense,
+                &mut workspace,
+                parameter,
+                &mut packed_inputs,
+                &mut packed_outputs,
+            )
+        });
+
+        let mut direct_samples = [0_u128; SAMPLES];
+        let mut packed_samples = [0_u128; SAMPLES];
+        for sample in 0..SAMPLES {
+            let time_direct = || {
+                let started = Instant::now();
+                for _ in 0..REPEATS {
+                    bound.evaluate(0, POINT_COUNT as u32).unwrap();
+                }
+                started.elapsed().as_nanos() / REPEATS as u128
+            };
+            let mut time_packed = || {
+                let started = Instant::now();
+                for _ in 0..REPEATS {
+                    gather_call_scatter(
+                        &mut dense,
+                        &mut workspace,
+                        parameter,
+                        &mut packed_inputs,
+                        &mut packed_outputs,
+                    );
+                }
+                started.elapsed().as_nanos() / REPEATS as u128
+            };
+            if sample.is_multiple_of(2) {
+                direct_samples[sample] = time_direct();
+                packed_samples[sample] = time_packed();
+            } else {
+                packed_samples[sample] = time_packed();
+                direct_samples[sample] = time_direct();
+            }
+            std::hint::black_box(workspace.current_slices().0[2 * stride as usize]);
+        }
+        let direct_ordered = direct_samples;
+        let packed_ordered = packed_samples;
+        let direct_median = median(&mut direct_samples);
+        let packed_median = median(&mut packed_samples);
+        let direct_mad = median_absolute_deviation(&direct_ordered, direct_median);
+        let packed_mad = median_absolute_deviation(&packed_ordered, packed_median);
+        eprintln!(
+            "synthetic-native-compiled-plane-loop points={POINT_COUNT} samples={SAMPLES} \
+             repeats={REPEATS} \
+             direct_ns={direct_ordered:?} packed_ns={packed_ordered:?} \
+             direct_median_ns={direct_median} direct_mad_ns={direct_mad} \
+             packed_median_ns={packed_median} packed_mad_ns={packed_mad} \
+             speedup={:.6} direct_rust_allocations={direct_allocations} \
+             direct_rust_allocated_bytes={direct_bytes} \
+             packed_rust_allocations={packed_allocations} \
+             packed_rust_allocated_bytes={packed_bytes}",
+            packed_median as f64 / direct_median as f64,
+        );
+        fs::remove_dir_all(directory).unwrap();
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/native_direct.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/native_direct.rs
new file mode 100644
index 0000000000..ff7e78f9bd
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/native_direct.rs
@@ -0,0 +1,680 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Native dynamic-library adapter for Direct-Arena recurrence executors.
+//!
+//! This module only owns and authenticates native prepared callables. Source
+//! filling and intrinsic closure reduction remain Rusticol-owned. The returned
+//! handle calls directly into the loaded library and therefore performs no
+//! packing, scattering, or allocation. Callers must retain this owner for as
+//! long as a copied [`DirectExecutorHandle`] can be invoked.
+
+use crate::artifact::PinnedNativeLibrary;
+use crate::recurrence::direct_backend::{
+    DirectClosureExecutor, DirectContributionExecutor, DirectExecutorHandle,
+    DirectFinalizationExecutor,
+};
+use crate::recurrence::{DIRECT_NONE_U32, DirectExecutorRole};
+use crate::{RusticolError, RusticolResult};
+use std::path::Path;
+use std::ptr;
+use std::sync::Arc;
+
+const NATIVE_DIRECT_SYMBOL_PREFIX: &str = "pyamplicol_recurrence_direct";
+
+#[repr(C)]
+struct NativeDirectBindingContextV1 {
+    coupling_re: f64,
+    coupling_im: f64,
+}
+
+/// Owns one loaded native Direct-Arena executor and its dynamic library.
+///
+/// Moving this value is safe because the copied function pointer addresses the
+/// loaded library rather than this Rust object. Dropping it invalidates any
+/// copied handle, so runtime integration must retain the owner beside the
+/// `DirectExecutorCatalog`.
+pub(crate) struct LoadedNativeDirectExecutor {
+    _library: Arc<PinnedNativeLibrary>,
+    _binding_context: Option<Box<NativeDirectBindingContextV1>>,
+    handle: DirectExecutorHandle,
+    #[cfg(test)]
+    role: DirectExecutorRole,
+    #[cfg(test)]
+    prepared_kernel_id: u32,
+}
+
+impl LoadedNativeDirectExecutor {
+    /// Load one authenticated role-specific native Direct-Arena export.
+    ///
+    /// `exported_symbol` is carried by the prepared-kernel producer contract.
+    /// It must exactly equal [`native_direct_symbol_name`] for the requested
+    /// role and prepared-kernel ID. This makes role confusion fail before the
+    /// dynamic library is opened.
+    pub(crate) fn load(
+        library: Arc<PinnedNativeLibrary>,
+        role: DirectExecutorRole,
+        prepared_kernel_id: u32,
+        exported_symbol: &str,
+        binding_coupling: Option<(f64, f64)>,
+    ) -> RusticolResult<Self> {
+        validate_c_symbol(exported_symbol)?;
+        let expected_symbol = native_direct_symbol_name(role, prepared_kernel_id)?;
+        if exported_symbol != expected_symbol {
+            return Err(RusticolError::integrity(format!(
+                "native Direct-Arena symbol {exported_symbol:?} does not authenticate role \
+                 {role:?} and prepared kernel {prepared_kernel_id}; expected \
+                 {expected_symbol:?}"
+            )));
+        }
+        if binding_coupling.is_some_and(|(re, im)| !re.is_finite() || !im.is_finite()) {
+            return Err(RusticolError::integrity(
+                "native Direct-Arena binding coupling must be finite",
+            ));
+        }
+
+        let path = library.display_path();
+        let binding_context = binding_coupling.map(|(coupling_re, coupling_im)| {
+            Box::new(NativeDirectBindingContextV1 {
+                coupling_re,
+                coupling_im,
+            })
+        });
+        let context = binding_context
+            .as_deref()
+            .map_or(ptr::null(), |value| std::ptr::from_ref(value).cast());
+        let handle = match role {
+            DirectExecutorRole::Contribution => {
+                let call = unsafe {
+                    load_export::<DirectContributionExecutor>(&library, path, exported_symbol)?
+                };
+                DirectExecutorHandle::Contribution { call, context }
+            }
+            DirectExecutorRole::Finalization => {
+                let call = unsafe {
+                    load_export::<DirectFinalizationExecutor>(&library, path, exported_symbol)?
+                };
+                DirectExecutorHandle::Finalization { call, context }
+            }
+            DirectExecutorRole::Closure => {
+                let call = unsafe {
+                    load_export::<DirectClosureExecutor>(&library, path, exported_symbol)?
+                };
+                DirectExecutorHandle::Closure { call, context }
+            }
+            DirectExecutorRole::Source => {
+                return Err(RusticolError::invalid_argument(
+                    "native Direct-Arena libraries cannot provide source executors; source filling is Rusticol-owned",
+                ));
+            }
+        };
+
+        Ok(Self {
+            _library: library,
+            _binding_context: binding_context,
+            handle,
+            #[cfg(test)]
+            role,
+            #[cfg(test)]
+            prepared_kernel_id,
+        })
+    }
+
+    /// Return the direct callable. The owner must outlive every invocation.
+    pub(crate) const fn handle(&self) -> DirectExecutorHandle {
+        self.handle
+    }
+
+    #[cfg(test)]
+    pub(crate) const fn role(&self) -> DirectExecutorRole {
+        self.role
+    }
+
+    #[cfg(test)]
+    pub(crate) const fn prepared_kernel_id(&self) -> u32 {
+        self.prepared_kernel_id
+    }
+}
+
+/// Deterministic C export for one prepared Direct-Arena kernel.
+///
+/// The convention is
+/// `pyamplicol_recurrence_direct_<role>_k<8-lowercase-hex-id>_v1`.
+pub(crate) fn native_direct_symbol_name(
+    role: DirectExecutorRole,
+    prepared_kernel_id: u32,
+) -> RusticolResult<String> {
+    if prepared_kernel_id == DIRECT_NONE_U32 {
+        return Err(RusticolError::invalid_argument(
+            "native Direct-Arena prepared-kernel ID must not be the missing-ID sentinel",
+        ));
+    }
+    let role_name = match role {
+        DirectExecutorRole::Contribution => "contribution",
+        DirectExecutorRole::Finalization => "finalization",
+        DirectExecutorRole::Closure => "closure",
+        DirectExecutorRole::Source => {
+            return Err(RusticolError::invalid_argument(
+                "native Direct-Arena symbol names are not defined for Rusticol-owned source executors",
+            ));
+        }
+    };
+    Ok(format!(
+        "{NATIVE_DIRECT_SYMBOL_PREFIX}_{role_name}_k{prepared_kernel_id:08x}_v1"
+    ))
+}
+
+fn validate_c_symbol(symbol: &str) -> RusticolResult<()> {
+    let mut bytes = symbol.bytes();
+    let Some(first) = bytes.next() else {
+        return Err(RusticolError::invalid_argument(
+            "native Direct-Arena exported symbol must not be empty",
+        ));
+    };
+    if !(first == b'_' || first.is_ascii_alphabetic())
+        || bytes.any(|byte| !(byte == b'_' || byte.is_ascii_alphanumeric()))
+    {
+        return Err(RusticolError::invalid_argument(format!(
+            "native Direct-Arena exported symbol {symbol:?} is not a portable C identifier"
+        )));
+    }
+    Ok(())
+}
+
+unsafe fn load_export<T: Copy>(
+    library: &libloading::Library,
+    path: &Path,
+    exported_symbol: &str,
+) -> RusticolResult<T> {
+    // SAFETY: The producer contract assigns this authenticated role-specific
+    // symbol exactly the `T` function signature selected by the caller.
+    unsafe {
+        library
+            .get::<T>(exported_symbol.as_bytes())
+            .map(|symbol| *symbol)
+            .map_err(|error| {
+                RusticolError::evaluation(format!(
+                    "could not load native Direct-Arena symbol {exported_symbol:?} from {}: {error}",
+                    path.display()
+                ))
+            })
+    }
+}
+
+#[cfg(all(test, any(target_os = "linux", target_os = "macos")))]
+pub(crate) mod tests {
+    use super::*;
+    use crate::RusticolErrorKind;
+    use crate::artifact::EvaluatorPayloadStore;
+    use crate::recurrence::direct_backend::{
+        DirectArenaView, DirectFactorView, DirectMomentumView, DirectParameterView,
+    };
+    #[cfg(not(feature = "f64-symjit"))]
+    use std::alloc::{GlobalAlloc, Layout, System};
+    #[cfg(not(feature = "f64-symjit"))]
+    use std::cell::Cell;
+    use std::fs;
+    use std::process::Command;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    #[cfg(not(feature = "f64-symjit"))]
+    thread_local! {
+        static TRACK_ALLOCATIONS: Cell<bool> = const { Cell::new(false) };
+        static ALLOCATION_COUNT: Cell<usize> = const { Cell::new(0) };
+        static ALLOCATED_BYTES: Cell<usize> = const { Cell::new(0) };
+    }
+
+    #[cfg(not(feature = "f64-symjit"))]
+    struct CountingAllocator;
+
+    #[cfg(not(feature = "f64-symjit"))]
+    #[global_allocator]
+    static GLOBAL_ALLOCATOR: CountingAllocator = CountingAllocator;
+
+    #[cfg(not(feature = "f64-symjit"))]
+    unsafe impl GlobalAlloc for CountingAllocator {
+        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+            count_allocation(layout.size());
+            unsafe { System.alloc(layout) }
+        }
+
+        unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+            count_allocation(layout.size());
+            unsafe { System.alloc_zeroed(layout) }
+        }
+
+        unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+            count_allocation(new_size);
+            unsafe { System.realloc(pointer, layout, new_size) }
+        }
+
+        unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+            unsafe { System.dealloc(pointer, layout) }
+        }
+    }
+
+    #[cfg(not(feature = "f64-symjit"))]
+    fn count_allocation(bytes: usize) {
+        let tracking = TRACK_ALLOCATIONS.try_with(Cell::get).unwrap_or(false);
+        if tracking {
+            let _ = ALLOCATION_COUNT.try_with(|count| count.set(count.get() + 1));
+            let _ = ALLOCATED_BYTES.try_with(|total| total.set(total.get().saturating_add(bytes)));
+        }
+    }
+
+    #[cfg(not(feature = "f64-symjit"))]
+    pub(crate) fn count_allocations<T>(operation: impl FnOnce() -> T) -> (T, usize, usize) {
+        ALLOCATION_COUNT.with(|count| count.set(0));
+        ALLOCATED_BYTES.with(|total| total.set(0));
+        TRACK_ALLOCATIONS.with(|tracking| tracking.set(true));
+        let result = operation();
+        TRACK_ALLOCATIONS.with(|tracking| tracking.set(false));
+        let count = ALLOCATION_COUNT.with(Cell::get);
+        let bytes = ALLOCATED_BYTES.with(Cell::get);
+        (result, count, bytes)
+    }
+
+    const CONTRIBUTION_ID: u32 = 7;
+    const FINALIZATION_ID: u32 = 11;
+    const CLOSURE_ID: u32 = 13;
+
+    fn expect_load_error(result: RusticolResult<LoadedNativeDirectExecutor>) -> RusticolError {
+        match result {
+            Ok(_) => panic!("native Direct-Arena executor unexpectedly loaded"),
+            Err(error) => error,
+        }
+    }
+
+    fn native_fixture() -> (std::path::PathBuf, std::path::PathBuf) {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let directory = std::env::temp_dir().join(format!(
+            "rusticol-native-direct-test-{}-{unique}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&directory).unwrap();
+        let source = directory.join("fixture.c");
+        let library = directory.join(if cfg!(target_os = "macos") {
+            "libnative_direct_fixture.dylib"
+        } else {
+            "libnative_direct_fixture.so"
+        });
+        let contribution_symbol =
+            native_direct_symbol_name(DirectExecutorRole::Contribution, CONTRIBUTION_ID).unwrap();
+        let finalization_symbol =
+            native_direct_symbol_name(DirectExecutorRole::Finalization, FINALIZATION_ID).unwrap();
+        let closure_symbol =
+            native_direct_symbol_name(DirectExecutorRole::Closure, CLOSURE_ID).unwrap();
+        let fixture = r#"#include <stdint.h>
+
+typedef struct {
+    double *current_re;
+    double *current_im;
+    uint64_t current_scalar_len;
+    double *amplitude_re;
+    double *amplitude_im;
+    uint64_t amplitude_scalar_len;
+    uint32_t point_stride;
+} DirectArenaView;
+
+typedef struct {
+    const double *values;
+    uint64_t scalar_len;
+    uint32_t form_count;
+    uint16_t lorentz_component_count;
+    uint32_t point_stride;
+} DirectMomentumView;
+
+typedef struct {
+    const double *values_re;
+    const double *values_im;
+    uint32_t value_count;
+} DirectParameterView;
+
+typedef DirectParameterView DirectFactorView;
+
+typedef struct {
+    double coupling_re;
+    double coupling_im;
+} DirectNativeBindingContextV1;
+
+#define DIRECT_ARGS \
+    const void *context, \
+    DirectArenaView arena, \
+    DirectMomentumView momenta, \
+    DirectParameterView parameters, \
+    DirectFactorView factors, \
+    const void *rows, \
+    uint32_t row_count, \
+    uint32_t point_count
+
+int __CONTRIBUTION_SYMBOL__(DIRECT_ARGS) {
+    (void)arena; (void)momenta; (void)parameters; (void)factors; (void)rows;
+    int binding_offset = 0;
+    if (context != 0) {
+        const DirectNativeBindingContextV1 *binding =
+            (const DirectNativeBindingContextV1 *)context;
+        binding_offset =
+            (int)(100.0 * binding->coupling_re + 10.0 * binding->coupling_im);
+    }
+    return 1000 + binding_offset + (int)row_count + (int)point_count;
+}
+
+int __FINALIZATION_SYMBOL__(DIRECT_ARGS) {
+    (void)context; (void)arena; (void)momenta; (void)parameters; (void)factors; (void)rows;
+    return 2000 + (int)row_count + (int)point_count;
+}
+
+int __CLOSURE_SYMBOL__(DIRECT_ARGS) {
+    (void)context; (void)arena; (void)momenta; (void)parameters; (void)factors; (void)rows;
+    return 3000 + (int)row_count + (int)point_count;
+}
+"#
+        .replace("__CONTRIBUTION_SYMBOL__", &contribution_symbol)
+        .replace("__FINALIZATION_SYMBOL__", &finalization_symbol)
+        .replace("__CLOSURE_SYMBOL__", &closure_symbol);
+        fs::write(&source, fixture).unwrap();
+        let compiler = std::env::var("CC").unwrap_or_else(|_| "cc".to_string());
+        let mut command = Command::new(compiler);
+        if cfg!(target_os = "macos") {
+            command.arg("-dynamiclib");
+        } else {
+            command.args(["-shared", "-fPIC"]);
+        }
+        let output = command
+            .arg(&source)
+            .arg("-o")
+            .arg(&library)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "could not compile native Direct-Arena fixture: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        (directory, library)
+    }
+
+    fn pinned(path: &Path) -> Arc<PinnedNativeLibrary> {
+        PinnedNativeLibrary::from_test_path(path).unwrap()
+    }
+
+    fn empty_views() -> (
+        DirectArenaView,
+        DirectMomentumView,
+        DirectParameterView,
+        DirectFactorView,
+    ) {
+        (
+            DirectArenaView {
+                current_re: ptr::null_mut(),
+                current_im: ptr::null_mut(),
+                current_scalar_len: 0,
+                amplitude_re: ptr::null_mut(),
+                amplitude_im: ptr::null_mut(),
+                amplitude_scalar_len: 0,
+                point_stride: 0,
+            },
+            DirectMomentumView {
+                values: ptr::null(),
+                scalar_len: 0,
+                form_count: 0,
+                lorentz_component_count: 0,
+                point_stride: 0,
+            },
+            DirectParameterView {
+                values_re: ptr::null(),
+                values_im: ptr::null(),
+                value_count: 0,
+            },
+            DirectFactorView {
+                values_re: ptr::null(),
+                values_im: ptr::null(),
+                value_count: 0,
+            },
+        )
+    }
+
+    #[test]
+    fn deterministic_symbols_encode_role_and_prepared_kernel_id() {
+        assert_eq!(
+            native_direct_symbol_name(DirectExecutorRole::Contribution, CONTRIBUTION_ID,).unwrap(),
+            "pyamplicol_recurrence_direct_contribution_k00000007_v1"
+        );
+        assert_eq!(
+            native_direct_symbol_name(DirectExecutorRole::Finalization, FINALIZATION_ID,).unwrap(),
+            "pyamplicol_recurrence_direct_finalization_k0000000b_v1"
+        );
+        assert_eq!(
+            native_direct_symbol_name(DirectExecutorRole::Closure, CLOSURE_ID).unwrap(),
+            "pyamplicol_recurrence_direct_closure_k0000000d_v1"
+        );
+        assert_eq!(
+            native_direct_symbol_name(DirectExecutorRole::Source, 0)
+                .unwrap_err()
+                .kind(),
+            RusticolErrorKind::InvalidArgument
+        );
+        assert_eq!(
+            native_direct_symbol_name(DirectExecutorRole::Contribution, DIRECT_NONE_U32,)
+                .unwrap_err()
+                .kind(),
+            RusticolErrorKind::InvalidArgument
+        );
+    }
+
+    #[test]
+    fn symbol_authentication_rejects_empty_invalid_and_wrong_role_names() {
+        let (directory, library_path) = native_fixture();
+        let library = pinned(&library_path);
+        for symbol in ["", "not-a-c-symbol", "contains\0nul"] {
+            let error = expect_load_error(LoadedNativeDirectExecutor::load(
+                Arc::clone(&library),
+                DirectExecutorRole::Contribution,
+                CONTRIBUTION_ID,
+                symbol,
+                None,
+            ));
+            assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+        }
+
+        let contribution_symbol =
+            native_direct_symbol_name(DirectExecutorRole::Contribution, CONTRIBUTION_ID).unwrap();
+        let error = expect_load_error(LoadedNativeDirectExecutor::load(
+            Arc::clone(&library),
+            DirectExecutorRole::Closure,
+            CONTRIBUTION_ID,
+            &contribution_symbol,
+            None,
+        ));
+        assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+        assert!(error.message().contains("expected"));
+
+        let error = expect_load_error(LoadedNativeDirectExecutor::load(
+            Arc::clone(&library),
+            DirectExecutorRole::Contribution,
+            CONTRIBUTION_ID,
+            &contribution_symbol,
+            Some((f64::NAN, 0.0)),
+        ));
+        assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+
+        let error = expect_load_error(LoadedNativeDirectExecutor::load(
+            library,
+            DirectExecutorRole::Source,
+            0,
+            "pyamplicol_recurrence_direct_source_k00000000_v1",
+            None,
+        ));
+        assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+        fs::remove_dir_all(directory).unwrap();
+    }
+
+    #[test]
+    fn native_role_exports_load_and_remain_callable_while_owners_move() {
+        let (directory, library_path) = native_fixture();
+        let store = EvaluatorPayloadStore::directory(&directory);
+        let relative_library = library_path.file_name().unwrap().to_str().unwrap();
+        let library = store.load_native_library(relative_library).unwrap();
+        let cached_library = store.load_native_library(relative_library).unwrap();
+        assert!(Arc::ptr_eq(&library, &cached_library));
+        let specifications = [
+            (DirectExecutorRole::Contribution, CONTRIBUTION_ID, 1008),
+            (DirectExecutorRole::Finalization, FINALIZATION_ID, 2008),
+            (DirectExecutorRole::Closure, CLOSURE_ID, 3008),
+        ];
+        let mut owners = Vec::new();
+        let mut handles = Vec::new();
+        for (role, prepared_kernel_id, _) in specifications {
+            let symbol = native_direct_symbol_name(role, prepared_kernel_id).unwrap();
+            let owner = LoadedNativeDirectExecutor::load(
+                Arc::clone(&library),
+                role,
+                prepared_kernel_id,
+                &symbol,
+                None,
+            )
+            .unwrap();
+            assert_eq!(owner.role(), role);
+            assert_eq!(owner.prepared_kernel_id(), prepared_kernel_id);
+            handles.push(owner.handle());
+            owners.push(owner);
+        }
+
+        fs::write(&library_path, b"replaced-after-authenticated-load").unwrap();
+
+        let (arena, momenta, parameters, factors) = empty_views();
+        for ((role, _, expected), handle) in specifications.into_iter().zip(handles.iter().copied())
+        {
+            let status = unsafe {
+                match (role, handle) {
+                    (
+                        DirectExecutorRole::Contribution,
+                        DirectExecutorHandle::Contribution { call, context },
+                    ) => call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        ptr::null(),
+                        3,
+                        5,
+                    ),
+                    (
+                        DirectExecutorRole::Finalization,
+                        DirectExecutorHandle::Finalization { call, context },
+                    ) => call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        ptr::null(),
+                        3,
+                        5,
+                    ),
+                    (
+                        DirectExecutorRole::Closure,
+                        DirectExecutorHandle::Closure { call, context },
+                    ) => call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        ptr::null(),
+                        3,
+                        5,
+                    ),
+                    _ => panic!("native Direct-Arena handle has the wrong role"),
+                }
+            };
+            assert_eq!(status, expected);
+        }
+
+        let contribution_symbol =
+            native_direct_symbol_name(DirectExecutorRole::Contribution, CONTRIBUTION_ID).unwrap();
+        let first_context = LoadedNativeDirectExecutor::load(
+            Arc::clone(&library),
+            DirectExecutorRole::Contribution,
+            CONTRIBUTION_ID,
+            &contribution_symbol,
+            Some((2.0, 3.0)),
+        )
+        .unwrap();
+        let first_handle = first_context.handle();
+        let second_context = LoadedNativeDirectExecutor::load(
+            Arc::clone(&library),
+            DirectExecutorRole::Contribution,
+            CONTRIBUTION_ID,
+            &contribution_symbol,
+            Some((-1.0, 4.0)),
+        )
+        .unwrap();
+        let second_handle = second_context.handle();
+        owners.push(first_context);
+        owners.push(second_context);
+        for (handle, expected) in [(first_handle, 1_238), (second_handle, 948)] {
+            let DirectExecutorHandle::Contribution { call, context } = handle else {
+                panic!("context fixture must load a contribution");
+            };
+            let status = unsafe {
+                call(
+                    context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::null(),
+                    3,
+                    5,
+                )
+            };
+            assert_eq!(status, expected);
+        }
+
+        #[cfg(not(feature = "f64-symjit"))]
+        {
+            let DirectExecutorHandle::Contribution { call, context } = handles[0] else {
+                panic!("first native Direct-Arena handle must be a contribution");
+            };
+            let (status_sum, allocation_count, allocated_bytes) = count_allocations(|| {
+                let mut status_sum = 0;
+                for _ in 0..1_024 {
+                    status_sum += unsafe {
+                        call(
+                            context,
+                            arena,
+                            momenta,
+                            parameters,
+                            factors,
+                            ptr::null(),
+                            3,
+                            5,
+                        )
+                    };
+                }
+                status_sum
+            });
+            assert_eq!(status_sum, 1_024 * 1_008);
+            assert_eq!(allocation_count, 0, "warmed native direct calls allocated");
+            assert_eq!(allocated_bytes, 0, "warmed native direct calls allocated");
+        }
+
+        let missing_symbol =
+            native_direct_symbol_name(DirectExecutorRole::Contribution, 23).unwrap();
+        let error = expect_load_error(LoadedNativeDirectExecutor::load(
+            library,
+            DirectExecutorRole::Contribution,
+            23,
+            &missing_symbol,
+            None,
+        ));
+        assert_eq!(error.kind(), RusticolErrorKind::Evaluation);
+
+        drop(owners);
+        fs::remove_dir_all(directory).unwrap();
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/recurrence_closure_direct.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/recurrence_closure_direct.rs
new file mode 100644
index 0000000000..7d75feac8f
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/recurrence_closure_direct.rs
@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Allocation-free component-metric closures for Direct-Arena recurrence.
+
+use crate::recurrence::DirectClosureRow;
+use crate::recurrence::direct_backend::{
+    DIRECT_STATUS_OK, DirectArenaView, DirectFactorView, DirectMomentumView, DirectParameterView,
+};
+use std::ffi::{c_int, c_void};
+
+const STATUS_INVALID_ARGUMENT: c_int = 2;
+const STATUS_BOUNDS: c_int = 4;
+
+/// Contract two split-complex currents directly into amplitude planes.
+///
+/// Coefficient planes are stored in the authenticated plan factor catalog.
+/// The point loop is innermost so each current and destination access remains
+/// contiguous and auto-vectorizable.
+pub(crate) unsafe extern "C" fn execute_closure_reduce_rows(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectClosureRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    if point_count == 0
+        || point_count > arena.point_stride
+        || (row_count != 0 && rows.is_null())
+        || arena.current_re.is_null()
+        || arena.current_im.is_null()
+        || arena.amplitude_re.is_null()
+        || arena.amplitude_im.is_null()
+        || factors.values_re.is_null()
+        || factors.values_im.is_null()
+    {
+        return STATUS_INVALID_ARGUMENT;
+    }
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    let stride = arena.point_stride as usize;
+    let points = point_count as usize;
+
+    for row in rows {
+        if row.parent1_component_base_or_sentinel == u32::MAX
+            || row.component_count == 0
+            || row.exact_factor_id >= factors.value_count
+        {
+            return STATUS_INVALID_ARGUMENT;
+        }
+        let coefficient_end = match row
+            .component_factor_start
+            .checked_add(u32::from(row.component_count))
+        {
+            Some(end) if end <= factors.value_count => end,
+            _ => return STATUS_BOUNDS,
+        };
+        debug_assert!(coefficient_end <= factors.value_count);
+
+        let row_factor_re = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        let row_factor_im = unsafe { *factors.values_im.add(row.exact_factor_id as usize) };
+        let destination_base = match (row.amplitude_destination_id as usize).checked_mul(stride) {
+            Some(value) => value,
+            None => return STATUS_BOUNDS,
+        };
+        if destination_base
+            .checked_add(points)
+            .is_none_or(|end| end > arena.amplitude_scalar_len as usize)
+        {
+            return STATUS_BOUNDS;
+        }
+
+        for component in 0..u32::from(row.component_count) {
+            let coefficient_id = row.component_factor_start + component;
+            let coefficient_re = unsafe { *factors.values_re.add(coefficient_id as usize) };
+            let coefficient_im = unsafe { *factors.values_im.add(coefficient_id as usize) };
+            let scale_re = coefficient_re * row_factor_re - coefficient_im * row_factor_im;
+            let scale_im = coefficient_re * row_factor_im + coefficient_im * row_factor_re;
+
+            let left_plane = match (row.parent0_component_base as usize)
+                .checked_add(component as usize)
+                .and_then(|plane| plane.checked_mul(stride))
+            {
+                Some(value) => value,
+                None => return STATUS_BOUNDS,
+            };
+            let right_plane = match (row.parent1_component_base_or_sentinel as usize)
+                .checked_add(component as usize)
+                .and_then(|plane| plane.checked_mul(stride))
+            {
+                Some(value) => value,
+                None => return STATUS_BOUNDS,
+            };
+            if left_plane
+                .checked_add(points)
+                .is_none_or(|end| end > arena.current_scalar_len as usize)
+                || right_plane
+                    .checked_add(points)
+                    .is_none_or(|end| end > arena.current_scalar_len as usize)
+            {
+                return STATUS_BOUNDS;
+            }
+
+            for point in 0..points {
+                let left = left_plane + point;
+                let right = right_plane + point;
+                let destination = destination_base + point;
+                let left_re = unsafe { *arena.current_re.add(left) };
+                let left_im = unsafe { *arena.current_im.add(left) };
+                let right_re = unsafe { *arena.current_re.add(right) };
+                let right_im = unsafe { *arena.current_im.add(right) };
+                let product_re = left_re * right_re - left_im * right_im;
+                let product_im = left_re * right_im + left_im * right_re;
+                unsafe {
+                    *arena.amplitude_re.add(destination) +=
+                        product_re * scale_re - product_im * scale_im;
+                    *arena.amplitude_im.add(destination) +=
+                        product_re * scale_im + product_im * scale_re;
+                }
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/recurrence_intrinsic_direct.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/recurrence_intrinsic_direct.rs
new file mode 100644
index 0000000000..248dad2453
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/recurrence_intrinsic_direct.rs
@@ -0,0 +1,5004 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Allocation-free model-generic contribution intrinsics for Direct-Arena recurrence.
+//!
+//! Every callback consumes authenticated fixed-width contribution rows and
+//! reads/writes persistent split-complex current planes directly. The loader
+//! owns the immutable scale context and retains it for at least as long as the
+//! returned executor handle can be called.
+
+use crate::recurrence::direct_backend::{
+    DIRECT_STATUS_OK, DirectArenaView, DirectContributionExecutor, DirectContributionFanoutBatch,
+    DirectContributionFanoutExecutor, DirectContributionFanoutExecutorHandle,
+    DirectContributionFanoutScale, DirectExecutorHandle, DirectFactorView,
+    DirectFinalizationExecutor, DirectInteractionBundleBatch, DirectInteractionExecutorContexts,
+    DirectInteractionIntrinsicKind, DirectInteractionOperand, DirectInteractionOperands,
+    DirectInteractionRuntimeRequirements, DirectInteractionTerminalBatch,
+    DirectInteractionVectorParent, DirectMomentumView, DirectParameterView,
+};
+use crate::recurrence::{
+    DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION, DIRECT_NONE_U32, DirectContributionRow,
+    DirectFinalizationRow,
+};
+use crate::{RusticolError, RusticolResult};
+use std::ffi::{c_int, c_void};
+use std::ptr;
+use wide::f64x2;
+
+const STATUS_INVALID_CONTEXT: c_int = 1;
+const STATUS_INVALID_ARGUMENT: c_int = 2;
+const STATUS_BOUNDS: c_int = 4;
+
+pub(crate) const WEYL_VECTOR_TO_WEYL_POSITIVE_TEMPLATE: &str =
+    "rusticol.recurrence-intrinsic.weyl-vector-to-weyl-a.v1";
+pub(crate) const WEYL_VECTOR_TO_WEYL_NEGATIVE_TEMPLATE: &str =
+    "rusticol.recurrence-intrinsic.weyl-vector-to-weyl-b.v1";
+pub(crate) const ANTISYMMETRIC_TENSOR_VECTOR_TO_VECTOR_TEMPLATE: &str =
+    "rusticol.recurrence-intrinsic.antisymmetric-tensor-vector.v1";
+pub(crate) const VECTOR_WEDGE_VECTOR_TO_ANTISYMMETRIC_TENSOR_TEMPLATE: &str =
+    "rusticol.recurrence-intrinsic.vector-wedge-vector.v1";
+pub(crate) const COLOR_ORDERED_THREE_VECTOR_TEMPLATE: &str =
+    "rusticol.recurrence-intrinsic.color-ordered-three-vector.v1";
+pub(crate) const WEYL_PROPAGATOR_POSITIVE_TEMPLATE: &str =
+    "rusticol.recurrence-intrinsic.weyl-propagator-a.v1";
+pub(crate) const WEYL_PROPAGATOR_NEGATIVE_TEMPLATE: &str =
+    "rusticol.recurrence-intrinsic.weyl-propagator-b.v1";
+pub(crate) const FEYNMAN_VECTOR_PROPAGATOR_TEMPLATE: &str =
+    "rusticol.recurrence-intrinsic.vector-propagator-feynman.v1";
+
+/// Exact algebra class certified by the model compiler.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum RecurrenceContributionIntrinsicKind {
+    WeylVectorToWeylPositive,
+    WeylVectorToWeylNegative,
+    AntisymmetricTensorVectorToVector,
+    VectorWedgeVectorToAntisymmetricTensor,
+    ColorOrderedThreeVector,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum RecurrenceFinalizationIntrinsicKind {
+    WeylPropagatorPositive,
+    WeylPropagatorNegative,
+    FeynmanVectorPropagator,
+}
+
+impl RecurrenceFinalizationIntrinsicKind {
+    pub(crate) fn from_runtime_template(value: &str) -> RusticolResult<Self> {
+        match value {
+            WEYL_PROPAGATOR_POSITIVE_TEMPLATE => Ok(Self::WeylPropagatorPositive),
+            WEYL_PROPAGATOR_NEGATIVE_TEMPLATE => Ok(Self::WeylPropagatorNegative),
+            FEYNMAN_VECTOR_PROPAGATOR_TEMPLATE => Ok(Self::FeynmanVectorPropagator),
+            other => Err(RusticolError::compatibility(format!(
+                "unsupported Direct-Arena recurrence finalization intrinsic {other:?}"
+            ))),
+        }
+    }
+}
+
+impl RecurrenceContributionIntrinsicKind {
+    #[cfg(test)]
+    pub(crate) const fn runtime_template(self) -> &'static str {
+        match self {
+            Self::WeylVectorToWeylPositive => WEYL_VECTOR_TO_WEYL_POSITIVE_TEMPLATE,
+            Self::WeylVectorToWeylNegative => WEYL_VECTOR_TO_WEYL_NEGATIVE_TEMPLATE,
+            Self::AntisymmetricTensorVectorToVector => {
+                ANTISYMMETRIC_TENSOR_VECTOR_TO_VECTOR_TEMPLATE
+            }
+            Self::VectorWedgeVectorToAntisymmetricTensor => {
+                VECTOR_WEDGE_VECTOR_TO_ANTISYMMETRIC_TENSOR_TEMPLATE
+            }
+            Self::ColorOrderedThreeVector => COLOR_ORDERED_THREE_VECTOR_TEMPLATE,
+        }
+    }
+
+    pub(crate) fn from_runtime_template(value: &str) -> RusticolResult<Self> {
+        match value {
+            WEYL_VECTOR_TO_WEYL_POSITIVE_TEMPLATE => Ok(Self::WeylVectorToWeylPositive),
+            WEYL_VECTOR_TO_WEYL_NEGATIVE_TEMPLATE => Ok(Self::WeylVectorToWeylNegative),
+            ANTISYMMETRIC_TENSOR_VECTOR_TO_VECTOR_TEMPLATE => {
+                Ok(Self::AntisymmetricTensorVectorToVector)
+            }
+            VECTOR_WEDGE_VECTOR_TO_ANTISYMMETRIC_TENSOR_TEMPLATE => {
+                Ok(Self::VectorWedgeVectorToAntisymmetricTensor)
+            }
+            COLOR_ORDERED_THREE_VECTOR_TEMPLATE => Ok(Self::ColorOrderedThreeVector),
+            other => Err(RusticolError::compatibility(format!(
+                "unsupported Direct-Arena recurrence contribution intrinsic {other:?}"
+            ))),
+        }
+    }
+}
+
+/// Immutable scale applied after the certified intrinsic algebra.
+///
+/// The effective scale is `literal * parameters[model_parameter_index]` when
+/// a parameter index is present, or just `literal` otherwise. Every row then
+/// contributes `effective_scale * exact_factor[row.exact_factor_id] * base`.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) struct RecurrenceIntrinsicScale {
+    literal_re: f64,
+    literal_im: f64,
+    model_parameter_index: Option<u32>,
+}
+
+impl RecurrenceIntrinsicScale {
+    pub(crate) fn new(
+        literal_re: f64,
+        literal_im: f64,
+        model_parameter_index: Option<u32>,
+    ) -> RusticolResult<Self> {
+        if !literal_re.is_finite() || !literal_im.is_finite() {
+            return Err(RusticolError::invalid_argument(
+                "Direct-Arena recurrence intrinsic scale must be finite",
+            ));
+        }
+        if model_parameter_index == Some(DIRECT_NONE_U32) {
+            return Err(RusticolError::invalid_argument(
+                "Direct-Arena recurrence intrinsic parameter index uses the reserved sentinel",
+            ));
+        }
+        Ok(Self {
+            literal_re,
+            literal_im,
+            model_parameter_index,
+        })
+    }
+
+    #[cfg(test)]
+    pub(crate) fn unit() -> Self {
+        Self {
+            literal_re: 1.0,
+            literal_im: 0.0,
+            model_parameter_index: None,
+        }
+    }
+}
+
+/// A context-aware contribution handle whose owner must outlive every call.
+#[derive(Clone, Copy)]
+pub(crate) struct ContextDirectContributionExecutorHandle {
+    pub(crate) call: DirectContributionExecutor,
+    pub(crate) context: *const c_void,
+}
+
+/// Owns one immutable intrinsic scale context.
+pub(crate) struct LoadedRecurrenceIntrinsicDirectExecutor {
+    kind: RecurrenceContributionIntrinsicKind,
+    scale: Box<RecurrenceIntrinsicScale>,
+}
+
+impl LoadedRecurrenceIntrinsicDirectExecutor {
+    pub(crate) fn load(
+        kind: RecurrenceContributionIntrinsicKind,
+        scale: RecurrenceIntrinsicScale,
+    ) -> Self {
+        Self {
+            kind,
+            scale: Box::new(scale),
+        }
+    }
+
+    pub(crate) fn load_runtime_template(
+        runtime_template: &str,
+        scale: RecurrenceIntrinsicScale,
+    ) -> RusticolResult<Self> {
+        Ok(Self::load(
+            RecurrenceContributionIntrinsicKind::from_runtime_template(runtime_template)?,
+            scale,
+        ))
+    }
+
+    pub(crate) fn contribution_handle(&self) -> ContextDirectContributionExecutorHandle {
+        let call = match self.kind {
+            RecurrenceContributionIntrinsicKind::WeylVectorToWeylPositive => {
+                execute_weyl_vector_to_weyl_positive_rows
+            }
+            RecurrenceContributionIntrinsicKind::WeylVectorToWeylNegative => {
+                execute_weyl_vector_to_weyl_negative_rows
+            }
+            RecurrenceContributionIntrinsicKind::AntisymmetricTensorVectorToVector => {
+                execute_antisymmetric_tensor_vector_to_vector_rows
+            }
+            RecurrenceContributionIntrinsicKind::VectorWedgeVectorToAntisymmetricTensor => {
+                execute_vector_wedge_vector_to_antisymmetric_tensor_rows
+            }
+            RecurrenceContributionIntrinsicKind::ColorOrderedThreeVector => {
+                execute_color_ordered_three_vector_rows
+            }
+        };
+        ContextDirectContributionExecutorHandle {
+            call,
+            context: ptr::from_ref(self.scale.as_ref()).cast(),
+        }
+    }
+
+    pub(crate) fn contribution_fanout_handle(
+        &self,
+    ) -> Option<DirectContributionFanoutExecutorHandle> {
+        let (
+            call,
+            destination_component_count,
+            parent_component_counts,
+            requires_two_momenta,
+            interaction_kind,
+        ): (
+            DirectContributionFanoutExecutor,
+            u32,
+            [u32; 2],
+            bool,
+            DirectInteractionIntrinsicKind,
+        ) = match self.kind {
+            RecurrenceContributionIntrinsicKind::AntisymmetricTensorVectorToVector => (
+                execute_antisymmetric_tensor_vector_to_vector_fanout,
+                4,
+                [6, 4],
+                false,
+                DirectInteractionIntrinsicKind::AntisymmetricTensorVector,
+            ),
+            RecurrenceContributionIntrinsicKind::VectorWedgeVectorToAntisymmetricTensor => (
+                execute_vector_wedge_vector_to_antisymmetric_tensor_fanout,
+                6,
+                [4, 4],
+                false,
+                DirectInteractionIntrinsicKind::VectorWedgeVector,
+            ),
+            RecurrenceContributionIntrinsicKind::ColorOrderedThreeVector => (
+                execute_color_ordered_three_vector_fanout,
+                4,
+                [4, 4],
+                true,
+                DirectInteractionIntrinsicKind::ColorOrderedThreeVector,
+            ),
+            _ => return None,
+        };
+        Some(DirectContributionFanoutExecutorHandle {
+            call,
+            context: ptr::from_ref(self.scale.as_ref()).cast(),
+            destination_component_count,
+            parent_component_counts,
+            requires_two_momenta,
+            required_parameter_count: self
+                .scale
+                .model_parameter_index
+                .map_or(0, |parameter| parameter + 1),
+            interaction_kind,
+            interaction_call: (interaction_kind
+                == DirectInteractionIntrinsicKind::ColorOrderedThreeVector)
+                .then_some(execute_interaction_bundle),
+        })
+    }
+
+    pub(crate) fn handle(&self) -> DirectExecutorHandle {
+        let handle = self.contribution_handle();
+        DirectExecutorHandle::Contribution {
+            call: handle.call,
+            context: handle.context,
+        }
+    }
+
+    pub(crate) fn finalization_handle(
+        runtime_template: &str,
+    ) -> RusticolResult<DirectExecutorHandle> {
+        let call: DirectFinalizationExecutor =
+            match RecurrenceFinalizationIntrinsicKind::from_runtime_template(runtime_template)? {
+                RecurrenceFinalizationIntrinsicKind::WeylPropagatorPositive => {
+                    execute_weyl_propagator_positive_rows
+                }
+                RecurrenceFinalizationIntrinsicKind::WeylPropagatorNegative => {
+                    execute_weyl_propagator_negative_rows
+                }
+                RecurrenceFinalizationIntrinsicKind::FeynmanVectorPropagator => {
+                    execute_feynman_vector_propagator_rows
+                }
+            };
+        Ok(DirectExecutorHandle::Finalization {
+            call,
+            context: ptr::null::<c_void>(),
+        })
+    }
+}
+
+/// One generic identity finalizer for every non-propagating state.
+///
+/// The prepared catalog resolves exactly this one function. Per-state
+/// dimensions are deliberately read from `row.component_count`.
+pub(crate) unsafe extern "C" fn execute_identity_finalization_rows(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectFinalizationRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    if rows.is_null()
+        || row_count == 0
+        || point_count == 0
+        || arena.point_stride == 0
+        || point_count > arena.point_stride
+    {
+        return STATUS_INVALID_ARGUMENT;
+    }
+    if arena.current_re.is_null()
+        || arena.current_im.is_null()
+        || factors.values_re.is_null()
+        || factors.values_im.is_null()
+    {
+        return STATUS_INVALID_ARGUMENT;
+    }
+
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        if row.component_count == 0 || row.exact_factor_id >= factors.value_count {
+            return STATUS_BOUNDS;
+        }
+        let factor_re = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        let factor_im = unsafe { *factors.values_im.add(row.exact_factor_id as usize) };
+        for component in 0..u64::from(row.component_count) {
+            let plane = match u64::from(row.component_base).checked_add(component) {
+                Some(value) => value,
+                None => return STATUS_BOUNDS,
+            };
+            let offset = match plane.checked_mul(u64::from(arena.point_stride)) {
+                Some(value) => value,
+                None => return STATUS_BOUNDS,
+            };
+            let end = match offset.checked_add(u64::from(point_count)) {
+                Some(value) => value,
+                None => return STATUS_BOUNDS,
+            };
+            if end > arena.current_scalar_len {
+                return STATUS_BOUNDS;
+            }
+            let Ok(offset) = usize::try_from(offset) else {
+                return STATUS_BOUNDS;
+            };
+            for point in 0..point_count as usize {
+                let index = offset + point;
+                let value_re = unsafe { *arena.current_re.add(index) };
+                let value_im = unsafe { *arena.current_im.add(index) };
+                unsafe {
+                    *arena.current_re.add(index) = factor_re * value_re - factor_im * value_im;
+                    *arena.current_im.add(index) = factor_re * value_im + factor_im * value_re;
+                }
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+#[derive(Clone, Copy)]
+struct ComplexValue {
+    re: f64,
+    im: f64,
+}
+
+impl ComplexValue {
+    const ZERO: Self = Self { re: 0.0, im: 0.0 };
+
+    #[inline(always)]
+    const fn new(re: f64, im: f64) -> Self {
+        Self { re, im }
+    }
+
+    #[inline(always)]
+    fn add(self, other: Self) -> Self {
+        Self::new(self.re + other.re, self.im + other.im)
+    }
+
+    #[inline(always)]
+    fn sub(self, other: Self) -> Self {
+        Self::new(self.re - other.re, self.im - other.im)
+    }
+
+    #[inline(always)]
+    fn neg(self) -> Self {
+        Self::new(-self.re, -self.im)
+    }
+
+    #[inline(always)]
+    fn mul(self, other: Self) -> Self {
+        Self::new(
+            self.re * other.re - self.im * other.im,
+            self.re * other.im + self.im * other.re,
+        )
+    }
+
+    #[inline(always)]
+    fn mul_i(self) -> Self {
+        Self::new(-self.im, self.re)
+    }
+
+    #[inline(always)]
+    fn mul_real(self, value: f64) -> Self {
+        Self::new(self.re * value, self.im * value)
+    }
+
+    #[inline(always)]
+    fn mul_real_pair(self, value: f64x2) -> SimdComplex2 {
+        SimdComplex2::new(
+            f64x2::new([self.re, self.re]) * value,
+            f64x2::new([self.im, self.im]) * value,
+        )
+    }
+}
+
+trait DirectContributionFormula {
+    const PARENT0_COMPONENTS: u32;
+    const PARENT1_COMPONENTS: u32;
+    const DESTINATION_COMPONENTS: u32;
+    const BASE_SCALE: ComplexValue;
+
+    /// Evaluate one point after all row and arena bounds have been validated.
+    unsafe fn evaluate_point(
+        arena: DirectArenaView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    );
+
+    #[inline(always)]
+    unsafe fn evaluate_pair(
+        arena: DirectArenaView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        unsafe {
+            Self::evaluate_point(arena, row, stride, point, scale);
+            Self::evaluate_point(arena, row, stride, point + 1, scale);
+        }
+    }
+}
+
+struct WeylVectorToWeylPositive;
+struct WeylVectorToWeylNegative;
+struct AntisymmetricTensorVectorToVector;
+struct VectorWedgeVectorToAntisymmetricTensor;
+struct ColorOrderedThreeVector;
+
+trait DirectContributionFanoutFormula<const N: usize> {
+    const BASE_SCALE: ComplexValue;
+
+    unsafe fn evaluate(
+        arena: DirectArenaView,
+        momenta: Option<DirectMomentumView>,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+    ) -> [ComplexValue; N];
+}
+
+#[derive(Clone, Copy)]
+struct SimdComplex2 {
+    re: f64x2,
+    im: f64x2,
+}
+
+impl SimdComplex2 {
+    #[inline(always)]
+    fn new(re: f64x2, im: f64x2) -> Self {
+        Self { re, im }
+    }
+
+    #[inline(always)]
+    fn add(self, other: Self) -> Self {
+        Self::new(self.re + other.re, self.im + other.im)
+    }
+
+    #[inline(always)]
+    fn sub(self, other: Self) -> Self {
+        Self::new(self.re - other.re, self.im - other.im)
+    }
+
+    #[inline(always)]
+    fn neg(self) -> Self {
+        Self::new(-self.re, -self.im)
+    }
+
+    #[inline(always)]
+    fn mul(self, other: Self) -> Self {
+        Self::new(
+            self.re * other.re - self.im * other.im,
+            self.re * other.im + self.im * other.re,
+        )
+    }
+
+    #[inline(always)]
+    fn mul_i(self) -> Self {
+        Self::new(-self.im, self.re)
+    }
+
+    #[inline(always)]
+    fn mul_real(self, value: f64x2) -> Self {
+        Self::new(self.re * value, self.im * value)
+    }
+}
+
+impl ColorOrderedThreeVector {
+    const PARENT_COMPONENTS: u32 = 4;
+    const DESTINATION_COMPONENTS: u32 = 4;
+    const BASE_SCALE: ComplexValue = ComplexValue::new(1.0, 0.0);
+
+    #[inline(always)]
+    unsafe fn evaluate_pair(
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        let mut left = [SimdComplex2::new(f64x2::ZERO, f64x2::ZERO); 4];
+        let mut right = [SimdComplex2::new(f64x2::ZERO, f64x2::ZERO); 4];
+        let mut parent0_momentum = [f64x2::ZERO; 4];
+        let mut parent1_momentum = [f64x2::ZERO; 4];
+        for component in 0..4 {
+            left[component] = unsafe {
+                load_current_pair(
+                    arena,
+                    row.parent0_component_base + component as u32,
+                    stride,
+                    point,
+                )
+            };
+            right[component] = unsafe {
+                load_current_pair(
+                    arena,
+                    row.parent1_component_base_or_sentinel + component as u32,
+                    stride,
+                    point,
+                )
+            };
+            parent0_momentum[component] = unsafe {
+                load_momentum_pair(
+                    momenta,
+                    row.parent0_momentum_form_id,
+                    component as u16,
+                    stride,
+                    point,
+                )
+            };
+            parent1_momentum[component] = unsafe {
+                load_momentum_pair(
+                    momenta,
+                    row.parent1_momentum_form_id_or_sentinel,
+                    component as u16,
+                    stride,
+                    point,
+                )
+            };
+        }
+
+        let vector_dot = minkowski_simd_complex_dot(left, right);
+        let left_dot_parent1 = minkowski_simd_complex_real_dot(left, parent1_momentum);
+        let right_dot_parent0 = minkowski_simd_complex_real_dot(right, parent0_momentum);
+        let two = f64x2::new([2.0, 2.0]);
+        for component in 0..4 {
+            let momentum_term =
+                vector_dot.mul_real(parent0_momentum[component] - parent1_momentum[component]);
+            let current_term = left_dot_parent1
+                .mul(right[component])
+                .sub(right_dot_parent0.mul(left[component]))
+                .mul_real(two);
+            unsafe {
+                add_scaled_current_pair(
+                    arena,
+                    row.destination_component_base + component as u32,
+                    stride,
+                    point,
+                    momentum_term.add(current_term),
+                    scale,
+                    contribution_accumulates(row),
+                );
+            }
+        }
+    }
+
+    #[inline(always)]
+    unsafe fn evaluate_point(
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        let output = unsafe {
+            <Self as DirectContributionFanoutFormula<4>>::evaluate(
+                arena,
+                Some(momenta),
+                row,
+                stride,
+                point,
+            )
+        };
+        for (component, value) in output.into_iter().enumerate() {
+            unsafe {
+                add_scaled_current(
+                    arena,
+                    row.destination_component_base + component as u32,
+                    stride,
+                    point,
+                    value,
+                    scale,
+                    contribution_accumulates(row),
+                );
+            }
+        }
+    }
+}
+
+#[inline(always)]
+fn color_ordered_three_vector_loaded(
+    left: [ComplexValue; 4],
+    right: [ComplexValue; 4],
+    parent0_momentum: [f64; 4],
+    parent1_momentum: [f64; 4],
+) -> [ComplexValue; 4] {
+    let vector_dot = minkowski_complex_dot(left, right);
+    let left_dot_parent1 = minkowski_complex_real_dot(left, parent1_momentum);
+    let right_dot_parent0 = minkowski_complex_real_dot(right, parent0_momentum);
+    core::array::from_fn(|component| {
+        let momentum_term =
+            vector_dot.mul_real(parent0_momentum[component] - parent1_momentum[component]);
+        let current_term = left_dot_parent1
+            .mul(right[component])
+            .sub(right_dot_parent0.mul(left[component]))
+            .mul_real(2.0);
+        momentum_term.add(current_term)
+    })
+}
+
+impl DirectContributionFanoutFormula<4> for ColorOrderedThreeVector {
+    const BASE_SCALE: ComplexValue = Self::BASE_SCALE;
+
+    #[inline(always)]
+    unsafe fn evaluate(
+        arena: DirectArenaView,
+        momenta: Option<DirectMomentumView>,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+    ) -> [ComplexValue; 4] {
+        let momenta = momenta.expect("color-ordered fanout inputs were validated");
+        let mut left = [ComplexValue::ZERO; 4];
+        let mut right = [ComplexValue::ZERO; 4];
+        let mut parent0_momentum = [0.0; 4];
+        let mut parent1_momentum = [0.0; 4];
+        for component in 0..4 {
+            left[component] = unsafe {
+                load_current(
+                    arena,
+                    row.parent0_component_base + component as u32,
+                    stride,
+                    point,
+                )
+            };
+            right[component] = unsafe {
+                load_current(
+                    arena,
+                    row.parent1_component_base_or_sentinel + component as u32,
+                    stride,
+                    point,
+                )
+            };
+            parent0_momentum[component] = unsafe {
+                load_momentum(
+                    momenta,
+                    row.parent0_momentum_form_id,
+                    component as u16,
+                    stride,
+                    point,
+                )
+            };
+            parent1_momentum[component] = unsafe {
+                load_momentum(
+                    momenta,
+                    row.parent1_momentum_form_id_or_sentinel,
+                    component as u16,
+                    stride,
+                    point,
+                )
+            };
+        }
+
+        color_ordered_three_vector_loaded(left, right, parent0_momentum, parent1_momentum)
+    }
+}
+
+impl DirectContributionFormula for WeylVectorToWeylPositive {
+    const PARENT0_COMPONENTS: u32 = 2;
+    const PARENT1_COMPONENTS: u32 = 4;
+    const DESTINATION_COMPONENTS: u32 = 2;
+    const BASE_SCALE: ComplexValue = ComplexValue::new(1.0, 0.0);
+
+    #[inline(always)]
+    unsafe fn evaluate_point(
+        arena: DirectArenaView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        let l0 = unsafe { load_current(arena, row.parent0_component_base, stride, point) };
+        let l1 = unsafe { load_current(arena, row.parent0_component_base + 1, stride, point) };
+        let r0 =
+            unsafe { load_current(arena, row.parent1_component_base_or_sentinel, stride, point) };
+        let r1 = unsafe {
+            load_current(
+                arena,
+                row.parent1_component_base_or_sentinel + 1,
+                stride,
+                point,
+            )
+        };
+        let r2 = unsafe {
+            load_current(
+                arena,
+                row.parent1_component_base_or_sentinel + 2,
+                stride,
+                point,
+            )
+        };
+        let r3 = unsafe {
+            load_current(
+                arena,
+                row.parent1_component_base_or_sentinel + 3,
+                stride,
+                point,
+            )
+        };
+
+        let output0 = l0
+            .mul(r3)
+            .mul_i()
+            .neg()
+            .sub(l1.mul(r1).mul_i())
+            .add(l1.mul(r2))
+            .add(l0.mul(r0).mul_i());
+        let output1 = l0
+            .mul(r2)
+            .neg()
+            .sub(l0.mul(r1).mul_i())
+            .add(l1.mul(r0).mul_i())
+            .add(l1.mul(r3).mul_i());
+        unsafe {
+            add_scaled_current(
+                arena,
+                row.destination_component_base,
+                stride,
+                point,
+                output0,
+                scale,
+                contribution_accumulates(row),
+            );
+            add_scaled_current(
+                arena,
+                row.destination_component_base + 1,
+                stride,
+                point,
+                output1,
+                scale,
+                contribution_accumulates(row),
+            );
+        }
+    }
+
+    #[inline(always)]
+    unsafe fn evaluate_pair(
+        arena: DirectArenaView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        let l0 = unsafe { load_current_pair(arena, row.parent0_component_base, stride, point) };
+        let l1 = unsafe { load_current_pair(arena, row.parent0_component_base + 1, stride, point) };
+        let r0 = unsafe {
+            load_current_pair(arena, row.parent1_component_base_or_sentinel, stride, point)
+        };
+        let r1 = unsafe {
+            load_current_pair(
+                arena,
+                row.parent1_component_base_or_sentinel + 1,
+                stride,
+                point,
+            )
+        };
+        let r2 = unsafe {
+            load_current_pair(
+                arena,
+                row.parent1_component_base_or_sentinel + 2,
+                stride,
+                point,
+            )
+        };
+        let r3 = unsafe {
+            load_current_pair(
+                arena,
+                row.parent1_component_base_or_sentinel + 3,
+                stride,
+                point,
+            )
+        };
+
+        let output0 = l0
+            .mul(r3)
+            .mul_i()
+            .neg()
+            .sub(l1.mul(r1).mul_i())
+            .add(l1.mul(r2))
+            .add(l0.mul(r0).mul_i());
+        let output1 = l0
+            .mul(r2)
+            .neg()
+            .sub(l0.mul(r1).mul_i())
+            .add(l1.mul(r0).mul_i())
+            .add(l1.mul(r3).mul_i());
+        unsafe {
+            add_scaled_current_pair(
+                arena,
+                row.destination_component_base,
+                stride,
+                point,
+                output0,
+                scale,
+                contribution_accumulates(row),
+            );
+            add_scaled_current_pair(
+                arena,
+                row.destination_component_base + 1,
+                stride,
+                point,
+                output1,
+                scale,
+                contribution_accumulates(row),
+            );
+        }
+    }
+}
+
+impl DirectContributionFormula for WeylVectorToWeylNegative {
+    const PARENT0_COMPONENTS: u32 = 2;
+    const PARENT1_COMPONENTS: u32 = 4;
+    const DESTINATION_COMPONENTS: u32 = 2;
+    const BASE_SCALE: ComplexValue = ComplexValue::new(1.0, 0.0);
+
+    #[inline(always)]
+    unsafe fn evaluate_point(
+        arena: DirectArenaView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        let l0 = unsafe { load_current(arena, row.parent0_component_base, stride, point) };
+        let l1 = unsafe { load_current(arena, row.parent0_component_base + 1, stride, point) };
+        let r0 =
+            unsafe { load_current(arena, row.parent1_component_base_or_sentinel, stride, point) };
+        let r1 = unsafe {
+            load_current(
+                arena,
+                row.parent1_component_base_or_sentinel + 1,
+                stride,
+                point,
+            )
+        };
+        let r2 = unsafe {
+            load_current(
+                arena,
+                row.parent1_component_base_or_sentinel + 2,
+                stride,
+                point,
+            )
+        };
+        let r3 = unsafe {
+            load_current(
+                arena,
+                row.parent1_component_base_or_sentinel + 3,
+                stride,
+                point,
+            )
+        };
+
+        let output0 = l1
+            .mul(r2)
+            .neg()
+            .add(l0.mul(r0).mul_i())
+            .add(l0.mul(r3).mul_i())
+            .add(l1.mul(r1).mul_i());
+        let output1 = l1
+            .mul(r3)
+            .mul_i()
+            .neg()
+            .add(l0.mul(r2))
+            .add(l0.mul(r1).mul_i())
+            .add(l1.mul(r0).mul_i());
+        unsafe {
+            add_scaled_current(
+                arena,
+                row.destination_component_base,
+                stride,
+                point,
+                output0,
+                scale,
+                contribution_accumulates(row),
+            );
+            add_scaled_current(
+                arena,
+                row.destination_component_base + 1,
+                stride,
+                point,
+                output1,
+                scale,
+                contribution_accumulates(row),
+            );
+        }
+    }
+
+    #[inline(always)]
+    unsafe fn evaluate_pair(
+        arena: DirectArenaView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        let l0 = unsafe { load_current_pair(arena, row.parent0_component_base, stride, point) };
+        let l1 = unsafe { load_current_pair(arena, row.parent0_component_base + 1, stride, point) };
+        let r0 = unsafe {
+            load_current_pair(arena, row.parent1_component_base_or_sentinel, stride, point)
+        };
+        let r1 = unsafe {
+            load_current_pair(
+                arena,
+                row.parent1_component_base_or_sentinel + 1,
+                stride,
+                point,
+            )
+        };
+        let r2 = unsafe {
+            load_current_pair(
+                arena,
+                row.parent1_component_base_or_sentinel + 2,
+                stride,
+                point,
+            )
+        };
+        let r3 = unsafe {
+            load_current_pair(
+                arena,
+                row.parent1_component_base_or_sentinel + 3,
+                stride,
+                point,
+            )
+        };
+
+        let output0 = l1
+            .mul(r2)
+            .neg()
+            .add(l0.mul(r0).mul_i())
+            .add(l0.mul(r3).mul_i())
+            .add(l1.mul(r1).mul_i());
+        let output1 = l1
+            .mul(r3)
+            .mul_i()
+            .neg()
+            .add(l0.mul(r2))
+            .add(l0.mul(r1).mul_i())
+            .add(l1.mul(r0).mul_i());
+        unsafe {
+            add_scaled_current_pair(
+                arena,
+                row.destination_component_base,
+                stride,
+                point,
+                output0,
+                scale,
+                contribution_accumulates(row),
+            );
+            add_scaled_current_pair(
+                arena,
+                row.destination_component_base + 1,
+                stride,
+                point,
+                output1,
+                scale,
+                contribution_accumulates(row),
+            );
+        }
+    }
+}
+
+impl DirectContributionFormula for AntisymmetricTensorVectorToVector {
+    const PARENT0_COMPONENTS: u32 = 6;
+    const PARENT1_COMPONENTS: u32 = 4;
+    const DESTINATION_COMPONENTS: u32 = 4;
+    const BASE_SCALE: ComplexValue = ComplexValue::new(1.0, 0.0);
+
+    #[inline(always)]
+    unsafe fn evaluate_point(
+        arena: DirectArenaView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        let output = unsafe {
+            <Self as DirectContributionFanoutFormula<4>>::evaluate(arena, None, row, stride, point)
+        };
+        for (component, value) in output.into_iter().enumerate() {
+            unsafe {
+                add_scaled_current(
+                    arena,
+                    row.destination_component_base + component as u32,
+                    stride,
+                    point,
+                    value,
+                    scale,
+                    contribution_accumulates(row),
+                );
+            }
+        }
+    }
+
+    #[inline(always)]
+    unsafe fn evaluate_pair(
+        arena: DirectArenaView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        let mut left = [SimdComplex2::new(f64x2::ZERO, f64x2::ZERO); 6];
+        let mut right = [SimdComplex2::new(f64x2::ZERO, f64x2::ZERO); 4];
+        for (component, value) in left.iter_mut().enumerate() {
+            *value = unsafe {
+                load_current_pair(
+                    arena,
+                    row.parent0_component_base + component as u32,
+                    stride,
+                    point,
+                )
+            };
+        }
+        for (component, value) in right.iter_mut().enumerate() {
+            *value = unsafe {
+                load_current_pair(
+                    arena,
+                    row.parent1_component_base_or_sentinel + component as u32,
+                    stride,
+                    point,
+                )
+            };
+        }
+        let output = [
+            left[0]
+                .mul(right[1])
+                .add(left[1].mul(right[2]))
+                .add(left[2].mul(right[3])),
+            left[0]
+                .mul(right[0])
+                .add(left[3].mul(right[2]))
+                .add(left[4].mul(right[3])),
+            left[1]
+                .mul(right[0])
+                .sub(left[3].mul(right[1]))
+                .add(left[5].mul(right[3])),
+            left[2]
+                .mul(right[0])
+                .sub(left[4].mul(right[1]))
+                .sub(left[5].mul(right[2])),
+        ];
+        for (component, value) in output.into_iter().enumerate() {
+            unsafe {
+                add_scaled_current_pair(
+                    arena,
+                    row.destination_component_base + component as u32,
+                    stride,
+                    point,
+                    value,
+                    scale,
+                    contribution_accumulates(row),
+                );
+            }
+        }
+    }
+}
+
+impl DirectContributionFanoutFormula<4> for AntisymmetricTensorVectorToVector {
+    const BASE_SCALE: ComplexValue = <Self as DirectContributionFormula>::BASE_SCALE;
+
+    #[inline(always)]
+    unsafe fn evaluate(
+        arena: DirectArenaView,
+        _momenta: Option<DirectMomentumView>,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+    ) -> [ComplexValue; 4] {
+        let mut left = [ComplexValue::ZERO; 6];
+        let mut right = [ComplexValue::ZERO; 4];
+        for (component, value) in left.iter_mut().enumerate() {
+            *value = unsafe {
+                load_current(
+                    arena,
+                    row.parent0_component_base + component as u32,
+                    stride,
+                    point,
+                )
+            };
+        }
+        for (component, value) in right.iter_mut().enumerate() {
+            *value = unsafe {
+                load_current(
+                    arena,
+                    row.parent1_component_base_or_sentinel + component as u32,
+                    stride,
+                    point,
+                )
+            };
+        }
+        antisymmetric_tensor_vector_loaded(left, right)
+    }
+}
+
+#[inline(always)]
+fn antisymmetric_tensor_vector_loaded(
+    left: [ComplexValue; 6],
+    right: [ComplexValue; 4],
+) -> [ComplexValue; 4] {
+    [
+        left[0]
+            .mul(right[1])
+            .add(left[1].mul(right[2]))
+            .add(left[2].mul(right[3])),
+        left[0]
+            .mul(right[0])
+            .add(left[3].mul(right[2]))
+            .add(left[4].mul(right[3])),
+        left[1]
+            .mul(right[0])
+            .sub(left[3].mul(right[1]))
+            .add(left[5].mul(right[3])),
+        left[2]
+            .mul(right[0])
+            .sub(left[4].mul(right[1]))
+            .sub(left[5].mul(right[2])),
+    ]
+}
+
+impl DirectContributionFormula for VectorWedgeVectorToAntisymmetricTensor {
+    const PARENT0_COMPONENTS: u32 = 4;
+    const PARENT1_COMPONENTS: u32 = 4;
+    const DESTINATION_COMPONENTS: u32 = 6;
+    const BASE_SCALE: ComplexValue = ComplexValue::new(1.0, 0.0);
+
+    #[inline(always)]
+    unsafe fn evaluate_point(
+        arena: DirectArenaView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        let output = unsafe {
+            <Self as DirectContributionFanoutFormula<6>>::evaluate(arena, None, row, stride, point)
+        };
+        for (component, value) in output.into_iter().enumerate() {
+            unsafe {
+                add_scaled_current(
+                    arena,
+                    row.destination_component_base + component as u32,
+                    stride,
+                    point,
+                    value,
+                    scale,
+                    contribution_accumulates(row),
+                );
+            }
+        }
+    }
+
+    #[inline(always)]
+    unsafe fn evaluate_pair(
+        arena: DirectArenaView,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+        scale: ComplexValue,
+    ) {
+        let mut left = [SimdComplex2::new(f64x2::ZERO, f64x2::ZERO); 4];
+        let mut right = [SimdComplex2::new(f64x2::ZERO, f64x2::ZERO); 4];
+        for component in 0..4 {
+            left[component] = unsafe {
+                load_current_pair(
+                    arena,
+                    row.parent0_component_base + component as u32,
+                    stride,
+                    point,
+                )
+            };
+            right[component] = unsafe {
+                load_current_pair(
+                    arena,
+                    row.parent1_component_base_or_sentinel + component as u32,
+                    stride,
+                    point,
+                )
+            };
+        }
+        let output = [
+            left[0].mul(right[1]).sub(left[1].mul(right[0])),
+            left[0].mul(right[2]).sub(left[2].mul(right[0])),
+            left[0].mul(right[3]).sub(left[3].mul(right[0])),
+            left[1].mul(right[2]).sub(left[2].mul(right[1])),
+            left[1].mul(right[3]).sub(left[3].mul(right[1])),
+            left[2].mul(right[3]).sub(left[3].mul(right[2])),
+        ];
+        for (component, value) in output.into_iter().enumerate() {
+            unsafe {
+                add_scaled_current_pair(
+                    arena,
+                    row.destination_component_base + component as u32,
+                    stride,
+                    point,
+                    value,
+                    scale,
+                    contribution_accumulates(row),
+                );
+            }
+        }
+    }
+}
+
+impl DirectContributionFanoutFormula<6> for VectorWedgeVectorToAntisymmetricTensor {
+    const BASE_SCALE: ComplexValue = <Self as DirectContributionFormula>::BASE_SCALE;
+
+    #[inline(always)]
+    unsafe fn evaluate(
+        arena: DirectArenaView,
+        _momenta: Option<DirectMomentumView>,
+        row: DirectContributionRow,
+        stride: usize,
+        point: usize,
+    ) -> [ComplexValue; 6] {
+        let mut left = [ComplexValue::ZERO; 4];
+        let mut right = [ComplexValue::ZERO; 4];
+        for component in 0..4 {
+            left[component] = unsafe {
+                load_current(
+                    arena,
+                    row.parent0_component_base + component as u32,
+                    stride,
+                    point,
+                )
+            };
+            right[component] = unsafe {
+                load_current(
+                    arena,
+                    row.parent1_component_base_or_sentinel + component as u32,
+                    stride,
+                    point,
+                )
+            };
+        }
+        vector_wedge_vector_loaded(left, right)
+    }
+}
+
+#[inline(always)]
+fn vector_wedge_vector_loaded(
+    left: [ComplexValue; 4],
+    right: [ComplexValue; 4],
+) -> [ComplexValue; 6] {
+    [
+        left[0].mul(right[1]).sub(left[1].mul(right[0])),
+        left[0].mul(right[2]).sub(left[2].mul(right[0])),
+        left[0].mul(right[3]).sub(left[3].mul(right[0])),
+        left[1].mul(right[2]).sub(left[2].mul(right[1])),
+        left[1].mul(right[3]).sub(left[3].mul(right[1])),
+        left[2].mul(right[3]).sub(left[3].mul(right[2])),
+    ]
+}
+
+#[allow(clippy::too_many_arguments)]
+unsafe fn execute_contribution_fanout<F, const N: usize>(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    batch: DirectContributionFanoutBatch<'_>,
+) -> RusticolResult<()>
+where
+    F: DirectContributionFanoutFormula<N>,
+{
+    // The private batch is produced only by a cold-authenticated direct or
+    // family-local fanout program. Its row spans and all raw views were
+    // validated before this call.
+    let context = unsafe { &*context.cast::<RecurrenceIntrinsicScale>() };
+    let context_scale = effective_context_scale(*context, parameters)
+        .map_err(|_| RusticolError::evaluation("fused contribution fanout scale is unavailable"))?
+        .mul(F::BASE_SCALE);
+    let stride = arena.point_stride as usize;
+
+    for run in batch.runs {
+        let row_start = usize::try_from(run.row_start)
+            .map_err(|_| RusticolError::integrity("fused fanout row start exceeds usize"))?;
+        let row_end = row_start
+            .checked_add(run.row_count as usize)
+            .ok_or_else(|| RusticolError::integrity("fused fanout row range overflows usize"))?;
+        let run_rows = batch
+            .rows
+            .get(row_start..row_end)
+            .ok_or_else(|| RusticolError::integrity("fused fanout row range is out of bounds"))?;
+        let representative = *run_rows.first().ok_or_else(|| {
+            RusticolError::integrity("fused fanout run has no representative row")
+        })?;
+        let mut output = unsafe { F::evaluate(arena, Some(momenta), representative, stride, 0) };
+        for value in &mut output {
+            *value = value.mul(context_scale);
+        }
+
+        let bundle_start = usize::try_from(run.bundle_start)
+            .map_err(|_| RusticolError::integrity("fused fanout bundle start exceeds usize"))?;
+        let bundle_end = bundle_start
+            .checked_add(run.bundle_count as usize)
+            .ok_or_else(|| RusticolError::integrity("fused fanout bundle range overflows usize"))?;
+        let bundles = batch.bundles.get(bundle_start..bundle_end).ok_or_else(|| {
+            RusticolError::integrity("fused fanout bundle range is out of bounds")
+        })?;
+        for bundle in bundles {
+            if bundle.effective_factor_id_or_sentinel == DIRECT_NONE_U32 {
+                return Err(RusticolError::integrity(
+                    "fused contribution fanout requires an explicit destination factor",
+                ));
+            }
+            let factor = bundle.effective_factor_id_or_sentinel as usize;
+            if factor >= factors.value_count as usize {
+                return Err(RusticolError::integrity(
+                    "fused contribution fanout factor is out of bounds",
+                ));
+            }
+            let scale = DirectContributionFanoutScale::new(
+                unsafe { *factors.values_re.add(factor) },
+                unsafe { *factors.values_im.add(factor) },
+            );
+            let scaled_output = output.map(|value| {
+                let (re, im) = scale.apply(value.re, value.im);
+                ComplexValue::new(re, im)
+            });
+            let bundle_row_start = usize::try_from(bundle.row_start).map_err(|_| {
+                RusticolError::integrity("fused fanout bundle row start exceeds usize")
+            })?;
+            let bundle_row_end = bundle_row_start
+                .checked_add(bundle.row_count as usize)
+                .ok_or_else(|| {
+                    RusticolError::integrity("fused fanout bundle row range overflows usize")
+                })?;
+            let rows = batch
+                .rows
+                .get(bundle_row_start..bundle_row_end)
+                .ok_or_else(|| {
+                    RusticolError::integrity("fused fanout bundle row range is out of bounds")
+                })?;
+            for row in rows {
+                for (component, value) in scaled_output.iter().enumerate() {
+                    let destination =
+                        (row.destination_component_base as usize + component) * stride;
+                    unsafe {
+                        if contribution_accumulates(*row) {
+                            *arena.current_re.add(destination) += value.re;
+                            *arena.current_im.add(destination) += value.im;
+                        } else {
+                            *arena.current_re.add(destination) = value.re;
+                            *arena.current_im.add(destination) = value.im;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+unsafe fn execute_antisymmetric_tensor_vector_to_vector_fanout(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    batch: DirectContributionFanoutBatch<'_>,
+) -> RusticolResult<()> {
+    unsafe {
+        execute_contribution_fanout::<AntisymmetricTensorVectorToVector, 4>(
+            context, arena, momenta, parameters, factors, batch,
+        )
+    }
+}
+
+unsafe fn execute_vector_wedge_vector_to_antisymmetric_tensor_fanout(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    batch: DirectContributionFanoutBatch<'_>,
+) -> RusticolResult<()> {
+    unsafe {
+        execute_contribution_fanout::<VectorWedgeVectorToAntisymmetricTensor, 6>(
+            context, arena, momenta, parameters, factors, batch,
+        )
+    }
+}
+
+unsafe fn execute_color_ordered_three_vector_fanout(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    batch: DirectContributionFanoutBatch<'_>,
+) -> RusticolResult<()> {
+    if momenta.values.is_null()
+        || momenta.lorentz_component_count != 4
+        || momenta.point_stride != arena.point_stride
+    {
+        return Err(RusticolError::evaluation(
+            "color-ordered fused fanout requires four-component momenta at the arena point stride",
+        ));
+    }
+    unsafe {
+        execute_contribution_fanout::<ColorOrderedThreeVector, 4>(
+            context, arena, momenta, parameters, factors, batch,
+        )
+    }
+}
+
+unsafe fn execute_interaction_bundle(
+    contexts: DirectInteractionExecutorContexts,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    batch: DirectInteractionBundleBatch<'_>,
+) -> RusticolResult<()> {
+    if contexts.color.is_null()
+        || contexts.antisymmetric_tensor_vector.is_null()
+        || (!batch.tensor_outputs.is_empty() && contexts.vector_wedge_vector.is_null())
+    {
+        return Err(RusticolError::evaluation(
+            "direct interaction bundle has a null intrinsic context",
+        ));
+    }
+    let stride = validate_interaction_runtime_views(
+        arena,
+        momenta,
+        parameters,
+        factors,
+        batch.requirements,
+    )?;
+    let color_context = unsafe { &*contexts.color.cast::<RecurrenceIntrinsicScale>() };
+    let atv_context = unsafe {
+        &*contexts
+            .antisymmetric_tensor_vector
+            .cast::<RecurrenceIntrinsicScale>()
+    };
+    let color_context_scale = effective_context_scale(*color_context, parameters)
+        .map_err(|_| RusticolError::evaluation("interaction color scale is unavailable"))?;
+    let atv_context_scale = effective_context_scale(*atv_context, parameters)
+        .map_err(|_| RusticolError::evaluation("interaction tensor-vector scale is unavailable"))?;
+    if batch.tensor_outputs.is_empty() && batch.terminal.is_none() {
+        return unsafe {
+            execute_vector_interaction_bundle(
+                arena,
+                momenta,
+                factors,
+                batch,
+                stride,
+                color_context_scale,
+                atv_context_scale,
+            )
+        };
+    }
+    let wedge_context_scale = if batch.tensor_outputs.is_empty() {
+        None
+    } else {
+        let wedge_context = unsafe {
+            &*contexts
+                .vector_wedge_vector
+                .cast::<RecurrenceIntrinsicScale>()
+        };
+        Some(
+            effective_context_scale(*wedge_context, parameters).map_err(|_| {
+                RusticolError::evaluation("interaction vector-wedge scale is unavailable")
+            })?,
+        )
+    };
+    let terminal_inputs = if let Some(terminal) = batch.terminal {
+        let mut partner = [ComplexValue::ZERO; 4];
+        let mut projection_weights = [ComplexValue::ZERO; 4];
+        for component in 0..4 {
+            partner[component] = unsafe {
+                load_current(
+                    arena,
+                    terminal.partner_component_base + component as u32,
+                    stride,
+                    0,
+                )
+            };
+            let factor_id = terminal.component_factor_start + component as u32;
+            let component_factor = ComplexValue::new(
+                unsafe { *factors.values_re.add(factor_id as usize) },
+                unsafe { *factors.values_im.add(factor_id as usize) },
+            );
+            projection_weights[component] = partner[component].mul(component_factor);
+        }
+        Some(projection_weights)
+    } else {
+        None
+    };
+
+    for anchor in batch.anchors {
+        let mut left = [ComplexValue::ZERO; 4];
+        let mut right = [ComplexValue::ZERO; 4];
+        let mut parent0_momentum = [0.0; 4];
+        let mut parent1_momentum = [0.0; 4];
+        for component in 0..4 {
+            left[component] = unsafe {
+                load_current(
+                    arena,
+                    anchor.parent_component_bases[0] + component as u32,
+                    stride,
+                    0,
+                )
+            };
+            right[component] = unsafe {
+                load_current(
+                    arena,
+                    anchor.parent_component_bases[1] + component as u32,
+                    stride,
+                    0,
+                )
+            };
+            parent0_momentum[component] = unsafe {
+                load_momentum(
+                    momenta,
+                    anchor.parent_momentum_form_ids[0],
+                    component as u16,
+                    stride,
+                    0,
+                )
+            };
+            parent1_momentum[component] = unsafe {
+                load_momentum(
+                    momenta,
+                    anchor.parent_momentum_form_ids[1],
+                    component as u16,
+                    stride,
+                    0,
+                )
+            };
+        }
+        let color_output =
+            color_ordered_three_vector_loaded(left, right, parent0_momentum, parent1_momentum)
+                .map(|value| value.mul(color_context_scale));
+        let wedge_output = wedge_context_scale
+            .map(|scale| vector_wedge_vector_loaded(left, right).map(|value| value.mul(scale)));
+
+        let mut atv_outputs = [[ComplexValue::ZERO; 4]; 2];
+        let atv_count = match anchor.operands {
+            DirectInteractionOperands::None => 0,
+            DirectInteractionOperands::One(operand) => {
+                atv_outputs[0] = unsafe {
+                    evaluate_interaction_operand(
+                        operand,
+                        left,
+                        right,
+                        arena,
+                        stride,
+                        atv_context_scale,
+                    )
+                };
+                1
+            }
+            DirectInteractionOperands::Two(operands) => {
+                atv_outputs[0] = unsafe {
+                    evaluate_interaction_operand(
+                        operands[0],
+                        left,
+                        right,
+                        arena,
+                        stride,
+                        atv_context_scale,
+                    )
+                };
+                atv_outputs[1] = unsafe {
+                    evaluate_interaction_operand(
+                        operands[1],
+                        left,
+                        right,
+                        arena,
+                        stride,
+                        atv_context_scale,
+                    )
+                };
+                2
+            }
+        };
+        let outputs = batch
+            .outputs
+            .get(anchor.output_start as usize..anchor.output_end as usize)
+            .ok_or_else(|| RusticolError::integrity("interaction output range is out of bounds"))?;
+
+        if let Some(projection_weights) = terminal_inputs {
+            let projected_color = project_terminal_vector(color_output, projection_weights);
+            let mut projected_atv = [ComplexValue::ZERO; 2];
+            for slot in 0..atv_count {
+                projected_atv[slot] =
+                    project_terminal_vector(atv_outputs[slot], projection_weights);
+            }
+            for output in outputs {
+                let color_scale =
+                    unsafe { live_interaction_factor(factors, output.exact_factor_ids[0]) };
+                let scaled_color = apply_fanout_scale(projected_color, color_scale);
+                let mut combined = if batch.atv_before_color {
+                    ComplexValue::ZERO
+                } else {
+                    scaled_color
+                };
+                for (slot, projected) in projected_atv.iter().take(atv_count).enumerate() {
+                    let scale = unsafe {
+                        live_interaction_factor(factors, output.exact_factor_ids[slot + 1])
+                    };
+                    combined = combined.add(apply_fanout_scale(*projected, scale));
+                }
+                if batch.atv_before_color {
+                    combined = combined.add(scaled_color);
+                }
+                let destination = output.destination_component_base as usize * stride;
+                unsafe {
+                    if output.initialize {
+                        *arena.current_re.add(destination) = combined.re;
+                        *arena.current_im.add(destination) = combined.im;
+                    } else {
+                        *arena.current_re.add(destination) += combined.re;
+                        *arena.current_im.add(destination) += combined.im;
+                    }
+                }
+            }
+        } else {
+            for output in outputs {
+                let color_scale =
+                    unsafe { live_interaction_factor(factors, output.exact_factor_ids[0]) };
+                let scaled_color = color_output.map(|value| apply_fanout_scale(value, color_scale));
+                let mut combined = if batch.atv_before_color {
+                    [ComplexValue::ZERO; 4]
+                } else {
+                    scaled_color
+                };
+                for (slot, atv_output) in atv_outputs.iter().take(atv_count).enumerate() {
+                    let scale = unsafe {
+                        live_interaction_factor(factors, output.exact_factor_ids[slot + 1])
+                    };
+                    for component in 0..4 {
+                        combined[component] = combined[component]
+                            .add(apply_fanout_scale(atv_output[component], scale));
+                    }
+                }
+                if batch.atv_before_color {
+                    for component in 0..4 {
+                        combined[component] = combined[component].add(scaled_color[component]);
+                    }
+                }
+                for (component, value) in combined.into_iter().enumerate() {
+                    let destination =
+                        (output.destination_component_base as usize + component) * stride;
+                    unsafe {
+                        if output.initialize {
+                            *arena.current_re.add(destination) = value.re;
+                            *arena.current_im.add(destination) = value.im;
+                        } else {
+                            *arena.current_re.add(destination) += value.re;
+                            *arena.current_im.add(destination) += value.im;
+                        }
+                    }
+                }
+            }
+        }
+        let tensor_outputs = batch
+            .tensor_outputs
+            .get(anchor.tensor_output_start as usize..anchor.tensor_output_end as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity("interaction tensor-output range is out of bounds")
+            })?;
+        if !tensor_outputs.is_empty() {
+            let wedge_output = wedge_output.ok_or_else(|| {
+                RusticolError::integrity("interaction tensor outputs have no wedge evaluation")
+            })?;
+            for output in tensor_outputs {
+                let scale = unsafe { live_interaction_factor(factors, output.exact_factor_id) };
+                for (component, value) in wedge_output.into_iter().enumerate() {
+                    let value = apply_fanout_scale(value, scale);
+                    let destination =
+                        (output.destination_component_base as usize + component) * stride;
+                    unsafe {
+                        if output.initialize {
+                            *arena.current_re.add(destination) = value.re;
+                            *arena.current_im.add(destination) = value.im;
+                        } else {
+                            *arena.current_re.add(destination) += value.re;
+                            *arena.current_im.add(destination) += value.im;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+unsafe fn execute_vector_interaction_bundle(
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    factors: DirectFactorView,
+    batch: DirectInteractionBundleBatch<'_>,
+    stride: usize,
+    color_context_scale: ComplexValue,
+    atv_context_scale: ComplexValue,
+) -> RusticolResult<()> {
+    for anchor in batch.anchors {
+        let mut left = [ComplexValue::ZERO; 4];
+        let mut right = [ComplexValue::ZERO; 4];
+        let mut parent0_momentum = [0.0; 4];
+        let mut parent1_momentum = [0.0; 4];
+        for component in 0..4 {
+            left[component] = unsafe {
+                load_current(
+                    arena,
+                    anchor.parent_component_bases[0] + component as u32,
+                    stride,
+                    0,
+                )
+            };
+            right[component] = unsafe {
+                load_current(
+                    arena,
+                    anchor.parent_component_bases[1] + component as u32,
+                    stride,
+                    0,
+                )
+            };
+            parent0_momentum[component] = unsafe {
+                load_momentum(
+                    momenta,
+                    anchor.parent_momentum_form_ids[0],
+                    component as u16,
+                    stride,
+                    0,
+                )
+            };
+            parent1_momentum[component] = unsafe {
+                load_momentum(
+                    momenta,
+                    anchor.parent_momentum_form_ids[1],
+                    component as u16,
+                    stride,
+                    0,
+                )
+            };
+        }
+        let color_output =
+            color_ordered_three_vector_loaded(left, right, parent0_momentum, parent1_momentum)
+                .map(|value| value.mul(color_context_scale));
+        let mut atv_outputs = [[ComplexValue::ZERO; 4]; 2];
+        let atv_count = match anchor.operands {
+            DirectInteractionOperands::None => 0,
+            DirectInteractionOperands::One(operand) => {
+                atv_outputs[0] = unsafe {
+                    evaluate_interaction_operand(
+                        operand,
+                        left,
+                        right,
+                        arena,
+                        stride,
+                        atv_context_scale,
+                    )
+                };
+                1
+            }
+            DirectInteractionOperands::Two(operands) => {
+                atv_outputs[0] = unsafe {
+                    evaluate_interaction_operand(
+                        operands[0],
+                        left,
+                        right,
+                        arena,
+                        stride,
+                        atv_context_scale,
+                    )
+                };
+                atv_outputs[1] = unsafe {
+                    evaluate_interaction_operand(
+                        operands[1],
+                        left,
+                        right,
+                        arena,
+                        stride,
+                        atv_context_scale,
+                    )
+                };
+                2
+            }
+        };
+        let outputs = batch
+            .outputs
+            .get(anchor.output_start as usize..anchor.output_end as usize)
+            .ok_or_else(|| RusticolError::integrity("interaction output range is out of bounds"))?;
+        for output in outputs {
+            let color_scale =
+                unsafe { live_interaction_factor(factors, output.exact_factor_ids[0]) };
+            let scaled_color = color_output.map(|value| apply_fanout_scale(value, color_scale));
+            let mut combined = if batch.atv_before_color {
+                [ComplexValue::ZERO; 4]
+            } else {
+                scaled_color
+            };
+            for (slot, atv_output) in atv_outputs.iter().take(atv_count).enumerate() {
+                let scale =
+                    unsafe { live_interaction_factor(factors, output.exact_factor_ids[slot + 1]) };
+                for component in 0..4 {
+                    combined[component] =
+                        combined[component].add(apply_fanout_scale(atv_output[component], scale));
+                }
+            }
+            if batch.atv_before_color {
+                for component in 0..4 {
+                    combined[component] = combined[component].add(scaled_color[component]);
+                }
+            }
+            for (component, value) in combined.into_iter().enumerate() {
+                let destination = (output.destination_component_base as usize + component) * stride;
+                unsafe {
+                    if output.initialize {
+                        *arena.current_re.add(destination) = value.re;
+                        *arena.current_im.add(destination) = value.im;
+                    } else {
+                        *arena.current_re.add(destination) += value.re;
+                        *arena.current_im.add(destination) += value.im;
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+pub(crate) unsafe fn execute_interaction_terminal_closures(
+    arena: DirectArenaView,
+    factors: DirectFactorView,
+    terminal: DirectInteractionTerminalBatch<'_>,
+) -> RusticolResult<()> {
+    if arena.point_stride == 0
+        || arena.current_re.is_null()
+        || arena.current_im.is_null()
+        || arena.amplitude_re.is_null()
+        || arena.amplitude_im.is_null()
+        || factors.values_re.is_null()
+        || factors.values_im.is_null()
+    {
+        return Err(RusticolError::evaluation(
+            "terminal interaction closure arenas are unavailable",
+        ));
+    }
+    let stride = arena.point_stride as usize;
+    let required_amplitude_scalars = u64::from(terminal.amplitude_destination_count)
+        .checked_mul(u64::from(arena.point_stride))
+        .ok_or_else(|| RusticolError::evaluation("terminal amplitude range overflows"))?;
+    if required_amplitude_scalars > arena.amplitude_scalar_len {
+        return Err(RusticolError::evaluation(
+            "terminal interaction amplitude arena is too short",
+        ));
+    }
+    for closure in terminal.closures {
+        let root = unsafe { load_current(arena, closure.root_component_base, stride, 0) };
+        let row_factor = unsafe { live_interaction_factor(factors, closure.exact_factor_id) };
+        let value = apply_fanout_scale(root, row_factor);
+        let destination = closure.amplitude_destination_id as usize * stride;
+        unsafe {
+            *arena.amplitude_re.add(destination) += value.re;
+            *arena.amplitude_im.add(destination) += value.im;
+        }
+    }
+    Ok(())
+}
+
+#[inline(always)]
+fn project_terminal_vector(
+    vector: [ComplexValue; 4],
+    projection_weights: [ComplexValue; 4],
+) -> ComplexValue {
+    let mut projected = ComplexValue::ZERO;
+    for component in 0..4 {
+        projected = projected.add(vector[component].mul(projection_weights[component]));
+    }
+    projected
+}
+
+#[inline(always)]
+unsafe fn evaluate_interaction_operand(
+    operand: DirectInteractionOperand,
+    left: [ComplexValue; 4],
+    right: [ComplexValue; 4],
+    arena: DirectArenaView,
+    stride: usize,
+    context_scale: ComplexValue,
+) -> [ComplexValue; 4] {
+    let mut tensor = [ComplexValue::ZERO; 6];
+    for (component, value) in tensor.iter_mut().enumerate() {
+        *value = unsafe {
+            load_current(
+                arena,
+                operand.tensor_component_base + component as u32,
+                stride,
+                0,
+            )
+        };
+    }
+    let vector = match operand.vector_parent {
+        DirectInteractionVectorParent::Parent0 => left,
+        DirectInteractionVectorParent::Parent1 => right,
+    };
+    antisymmetric_tensor_vector_loaded(tensor, vector).map(|value| value.mul(context_scale))
+}
+
+fn validate_interaction_runtime_views(
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    requirements: DirectInteractionRuntimeRequirements,
+) -> RusticolResult<usize> {
+    if arena.point_stride == 0 || arena.current_re.is_null() || arena.current_im.is_null() {
+        return Err(RusticolError::evaluation(
+            "direct interaction current arena is unavailable",
+        ));
+    }
+    let required_current_scalars = u64::from(requirements.current_component_count)
+        .checked_mul(u64::from(arena.point_stride))
+        .ok_or_else(|| RusticolError::evaluation("direct interaction current arena overflows"))?;
+    if arena.current_scalar_len < required_current_scalars
+        || usize::try_from(required_current_scalars).is_err()
+    {
+        return Err(RusticolError::evaluation(
+            "direct interaction current arena is too short",
+        ));
+    }
+    let required_momentum_scalars = u64::from(requirements.momentum_form_count)
+        .checked_mul(4)
+        .and_then(|count| count.checked_mul(u64::from(arena.point_stride)))
+        .ok_or_else(|| RusticolError::evaluation("direct interaction momentum arena overflows"))?;
+    if momenta.values.is_null()
+        || momenta.lorentz_component_count != 4
+        || momenta.point_stride != arena.point_stride
+        || momenta.form_count < requirements.momentum_form_count
+        || momenta.scalar_len < required_momentum_scalars
+        || usize::try_from(required_momentum_scalars).is_err()
+    {
+        return Err(RusticolError::evaluation(
+            "direct interaction momentum arena does not cover its cold program",
+        ));
+    }
+    if requirements.parameter_count != 0
+        && (parameters.values_re.is_null()
+            || parameters.values_im.is_null()
+            || parameters.value_count < requirements.parameter_count)
+    {
+        return Err(RusticolError::evaluation(
+            "direct interaction parameter catalog does not cover its cold program",
+        ));
+    }
+    if requirements.factor_count != 0
+        && (factors.values_re.is_null()
+            || factors.values_im.is_null()
+            || factors.value_count < requirements.factor_count)
+    {
+        return Err(RusticolError::evaluation(
+            "direct interaction factor catalog does not cover its cold program",
+        ));
+    }
+    usize::try_from(arena.point_stride)
+        .map_err(|_| RusticolError::evaluation("direct interaction point stride exceeds usize"))
+}
+
+#[inline(always)]
+unsafe fn live_interaction_factor(
+    factors: DirectFactorView,
+    factor_id: u32,
+) -> DirectContributionFanoutScale {
+    DirectContributionFanoutScale::new(
+        unsafe { *factors.values_re.add(factor_id as usize) },
+        unsafe { *factors.values_im.add(factor_id as usize) },
+    )
+}
+
+#[inline(always)]
+fn apply_fanout_scale(value: ComplexValue, scale: DirectContributionFanoutScale) -> ComplexValue {
+    let (re, im) = scale.apply(value.re, value.im);
+    ComplexValue::new(re, im)
+}
+
+unsafe extern "C" fn execute_weyl_vector_to_weyl_positive_rows(
+    context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    unsafe {
+        execute_rows::<WeylVectorToWeylPositive>(
+            context,
+            arena,
+            parameters,
+            factors,
+            rows,
+            row_count,
+            point_count,
+        )
+    }
+}
+
+unsafe extern "C" fn execute_weyl_vector_to_weyl_negative_rows(
+    context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    unsafe {
+        execute_rows::<WeylVectorToWeylNegative>(
+            context,
+            arena,
+            parameters,
+            factors,
+            rows,
+            row_count,
+            point_count,
+        )
+    }
+}
+
+unsafe extern "C" fn execute_antisymmetric_tensor_vector_to_vector_rows(
+    context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    unsafe {
+        execute_rows::<AntisymmetricTensorVectorToVector>(
+            context,
+            arena,
+            parameters,
+            factors,
+            rows,
+            row_count,
+            point_count,
+        )
+    }
+}
+
+unsafe extern "C" fn execute_vector_wedge_vector_to_antisymmetric_tensor_rows(
+    context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    unsafe {
+        execute_rows::<VectorWedgeVectorToAntisymmetricTensor>(
+            context,
+            arena,
+            parameters,
+            factors,
+            rows,
+            row_count,
+            point_count,
+        )
+    }
+}
+
+unsafe extern "C" fn execute_color_ordered_three_vector_rows(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    if context.is_null() {
+        return STATUS_INVALID_CONTEXT;
+    }
+    if row_count == 0
+        || rows.is_null()
+        || point_count == 0
+        || arena.point_stride == 0
+        || point_count > arena.point_stride
+        || arena.current_re.is_null()
+        || arena.current_im.is_null()
+        || momenta.values.is_null()
+        || momenta.lorentz_component_count != 4
+        || momenta.point_stride != arena.point_stride
+        || point_count > momenta.point_stride
+        || factors.values_re.is_null()
+        || factors.values_im.is_null()
+    {
+        return STATUS_INVALID_ARGUMENT;
+    }
+    let context = unsafe { &*context.cast::<RecurrenceIntrinsicScale>() };
+    let context_scale = match effective_context_scale(*context, parameters) {
+        Ok(scale) => scale.mul(ColorOrderedThreeVector::BASE_SCALE),
+        Err(status) => return status,
+    };
+    let stride = arena.point_stride as usize;
+    let points = point_count as usize;
+
+    for row_index in 0..row_count as usize {
+        let row = unsafe { *rows.add(row_index) };
+        if row.parent1_component_base_or_sentinel == DIRECT_NONE_U32
+            || row.parent0_momentum_form_id == DIRECT_NONE_U32
+            || row.parent1_momentum_form_id_or_sentinel == DIRECT_NONE_U32
+        {
+            return STATUS_INVALID_ARGUMENT;
+        }
+        if row.exact_factor_id >= factors.value_count
+            || !component_range_in_bounds(
+                row.parent0_component_base,
+                ColorOrderedThreeVector::PARENT_COMPONENTS,
+                arena.current_scalar_len,
+                arena.point_stride,
+                point_count,
+            )
+            || !component_range_in_bounds(
+                row.parent1_component_base_or_sentinel,
+                ColorOrderedThreeVector::PARENT_COMPONENTS,
+                arena.current_scalar_len,
+                arena.point_stride,
+                point_count,
+            )
+            || !component_range_in_bounds(
+                row.destination_component_base,
+                ColorOrderedThreeVector::DESTINATION_COMPONENTS,
+                arena.current_scalar_len,
+                arena.point_stride,
+                point_count,
+            )
+            || !momentum_form_in_bounds(momenta, row.parent0_momentum_form_id, point_count)
+            || !momentum_form_in_bounds(
+                momenta,
+                row.parent1_momentum_form_id_or_sentinel,
+                point_count,
+            )
+        {
+            return STATUS_BOUNDS;
+        }
+        let row_factor = ComplexValue::new(
+            unsafe { *factors.values_re.add(row.exact_factor_id as usize) },
+            unsafe { *factors.values_im.add(row.exact_factor_id as usize) },
+        );
+        let scale = context_scale.mul(row_factor);
+        let mut point = 0usize;
+        while point + 1 < points {
+            unsafe {
+                ColorOrderedThreeVector::evaluate_pair(arena, momenta, row, stride, point, scale);
+            }
+            point += 2;
+        }
+        if point < points {
+            unsafe {
+                ColorOrderedThreeVector::evaluate_point(arena, momenta, row, stride, point, scale);
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+trait DirectFinalizationFormula {
+    const COMPONENTS: u16;
+
+    unsafe fn evaluate_point(
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        row: DirectFinalizationRow,
+        stride: usize,
+        point: usize,
+        row_factor: ComplexValue,
+    );
+
+    unsafe fn evaluate_pair(
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        row: DirectFinalizationRow,
+        stride: usize,
+        point: usize,
+        row_factor: ComplexValue,
+    ) {
+        unsafe {
+            Self::evaluate_point(arena, momenta, row, stride, point, row_factor);
+            Self::evaluate_point(arena, momenta, row, stride, point + 1, row_factor);
+        }
+    }
+}
+
+struct WeylPropagatorPositive;
+struct WeylPropagatorNegative;
+struct FeynmanVectorPropagator;
+
+impl DirectFinalizationFormula for WeylPropagatorPositive {
+    const COMPONENTS: u16 = 2;
+
+    #[inline(always)]
+    unsafe fn evaluate_point(
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        row: DirectFinalizationRow,
+        stride: usize,
+        point: usize,
+        row_factor: ComplexValue,
+    ) {
+        let c0 = unsafe { load_current(arena, row.component_base, stride, point) };
+        let c1 = unsafe { load_current(arena, row.component_base + 1, stride, point) };
+        let p0 = unsafe { load_momentum(momenta, row.momentum_form_id, 0, stride, point) };
+        let p1 = unsafe { load_momentum(momenta, row.momentum_form_id, 1, stride, point) };
+        let p2 = unsafe { load_momentum(momenta, row.momentum_form_id, 2, stride, point) };
+        let p3 = unsafe { load_momentum(momenta, row.momentum_form_id, 3, stride, point) };
+        let inv = reciprocal_minkowski_norm(p0, p1, p2, p3);
+        let scale = row_factor.mul_real(inv);
+        let output0 = c0
+            .mul_real(p3)
+            .mul_i()
+            .neg()
+            .sub(c1.mul_real(p1).mul_i())
+            .add(c1.mul_real(p2))
+            .add(c0.mul_real(p0).mul_i());
+        let output1 = c0
+            .mul_real(p2)
+            .neg()
+            .sub(c0.mul_real(p1).mul_i())
+            .add(c1.mul_real(p0).mul_i())
+            .add(c1.mul_real(p3).mul_i());
+        unsafe {
+            set_scaled_current(arena, row.component_base, stride, point, output0, scale);
+            set_scaled_current(arena, row.component_base + 1, stride, point, output1, scale);
+        }
+    }
+
+    #[inline(always)]
+    unsafe fn evaluate_pair(
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        row: DirectFinalizationRow,
+        stride: usize,
+        point: usize,
+        row_factor: ComplexValue,
+    ) {
+        let c0 = unsafe { load_current_pair(arena, row.component_base, stride, point) };
+        let c1 = unsafe { load_current_pair(arena, row.component_base + 1, stride, point) };
+        let p0 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 0, stride, point) };
+        let p1 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 1, stride, point) };
+        let p2 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 2, stride, point) };
+        let p3 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 3, stride, point) };
+        let inv = reciprocal_minkowski_norm_pair(p0, p1, p2, p3);
+        let scale = row_factor.mul_real_pair(inv);
+        let output0 = c0
+            .mul_real(p3)
+            .mul_i()
+            .neg()
+            .sub(c1.mul_real(p1).mul_i())
+            .add(c1.mul_real(p2))
+            .add(c0.mul_real(p0).mul_i());
+        let output1 = c0
+            .mul_real(p2)
+            .neg()
+            .sub(c0.mul_real(p1).mul_i())
+            .add(c1.mul_real(p0).mul_i())
+            .add(c1.mul_real(p3).mul_i());
+        unsafe {
+            set_pre_scaled_current_pair(arena, row.component_base, stride, point, output0, scale);
+            set_pre_scaled_current_pair(
+                arena,
+                row.component_base + 1,
+                stride,
+                point,
+                output1,
+                scale,
+            );
+        }
+    }
+}
+
+impl DirectFinalizationFormula for WeylPropagatorNegative {
+    const COMPONENTS: u16 = 2;
+
+    #[inline(always)]
+    unsafe fn evaluate_point(
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        row: DirectFinalizationRow,
+        stride: usize,
+        point: usize,
+        row_factor: ComplexValue,
+    ) {
+        let c0 = unsafe { load_current(arena, row.component_base, stride, point) };
+        let c1 = unsafe { load_current(arena, row.component_base + 1, stride, point) };
+        let p0 = unsafe { load_momentum(momenta, row.momentum_form_id, 0, stride, point) };
+        let p1 = unsafe { load_momentum(momenta, row.momentum_form_id, 1, stride, point) };
+        let p2 = unsafe { load_momentum(momenta, row.momentum_form_id, 2, stride, point) };
+        let p3 = unsafe { load_momentum(momenta, row.momentum_form_id, 3, stride, point) };
+        let inv = reciprocal_minkowski_norm(p0, p1, p2, p3);
+        let scale = row_factor.mul_real(inv);
+        let output0 = c1
+            .mul_real(p2)
+            .neg()
+            .add(c0.mul_real(p0).mul_i())
+            .add(c0.mul_real(p3).mul_i())
+            .add(c1.mul_real(p1).mul_i());
+        let output1 = c1
+            .mul_real(p3)
+            .mul_i()
+            .neg()
+            .add(c0.mul_real(p2))
+            .add(c0.mul_real(p1).mul_i())
+            .add(c1.mul_real(p0).mul_i());
+        unsafe {
+            set_scaled_current(arena, row.component_base, stride, point, output0, scale);
+            set_scaled_current(arena, row.component_base + 1, stride, point, output1, scale);
+        }
+    }
+
+    #[inline(always)]
+    unsafe fn evaluate_pair(
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        row: DirectFinalizationRow,
+        stride: usize,
+        point: usize,
+        row_factor: ComplexValue,
+    ) {
+        let c0 = unsafe { load_current_pair(arena, row.component_base, stride, point) };
+        let c1 = unsafe { load_current_pair(arena, row.component_base + 1, stride, point) };
+        let p0 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 0, stride, point) };
+        let p1 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 1, stride, point) };
+        let p2 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 2, stride, point) };
+        let p3 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 3, stride, point) };
+        let inv = reciprocal_minkowski_norm_pair(p0, p1, p2, p3);
+        let scale = row_factor.mul_real_pair(inv);
+        let output0 = c1
+            .mul_real(p2)
+            .neg()
+            .add(c0.mul_real(p0).mul_i())
+            .add(c0.mul_real(p3).mul_i())
+            .add(c1.mul_real(p1).mul_i());
+        let output1 = c1
+            .mul_real(p3)
+            .mul_i()
+            .neg()
+            .add(c0.mul_real(p2))
+            .add(c0.mul_real(p1).mul_i())
+            .add(c1.mul_real(p0).mul_i());
+        unsafe {
+            set_pre_scaled_current_pair(arena, row.component_base, stride, point, output0, scale);
+            set_pre_scaled_current_pair(
+                arena,
+                row.component_base + 1,
+                stride,
+                point,
+                output1,
+                scale,
+            );
+        }
+    }
+}
+
+impl DirectFinalizationFormula for FeynmanVectorPropagator {
+    const COMPONENTS: u16 = 4;
+
+    #[inline(always)]
+    unsafe fn evaluate_point(
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        row: DirectFinalizationRow,
+        stride: usize,
+        point: usize,
+        row_factor: ComplexValue,
+    ) {
+        let p0 = unsafe { load_momentum(momenta, row.momentum_form_id, 0, stride, point) };
+        let p1 = unsafe { load_momentum(momenta, row.momentum_form_id, 1, stride, point) };
+        let p2 = unsafe { load_momentum(momenta, row.momentum_form_id, 2, stride, point) };
+        let p3 = unsafe { load_momentum(momenta, row.momentum_form_id, 3, stride, point) };
+        let scale = row_factor
+            .mul(ComplexValue::new(0.0, -1.0))
+            .mul_real(reciprocal_minkowski_norm(p0, p1, p2, p3));
+        for component in 0..4u32 {
+            let value =
+                unsafe { load_current(arena, row.component_base + component, stride, point) };
+            unsafe {
+                set_scaled_current(
+                    arena,
+                    row.component_base + component,
+                    stride,
+                    point,
+                    value,
+                    scale,
+                );
+            }
+        }
+    }
+
+    #[inline(always)]
+    unsafe fn evaluate_pair(
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        row: DirectFinalizationRow,
+        stride: usize,
+        point: usize,
+        row_factor: ComplexValue,
+    ) {
+        let p0 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 0, stride, point) };
+        let p1 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 1, stride, point) };
+        let p2 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 2, stride, point) };
+        let p3 = unsafe { load_momentum_pair(momenta, row.momentum_form_id, 3, stride, point) };
+        let scale = row_factor
+            .mul(ComplexValue::new(0.0, -1.0))
+            .mul_real_pair(reciprocal_minkowski_norm_pair(p0, p1, p2, p3));
+        for component in 0..4u32 {
+            let value =
+                unsafe { load_current_pair(arena, row.component_base + component, stride, point) };
+            unsafe {
+                set_pre_scaled_current_pair(
+                    arena,
+                    row.component_base + component,
+                    stride,
+                    point,
+                    value,
+                    scale,
+                );
+            }
+        }
+    }
+}
+
+unsafe extern "C" fn execute_weyl_propagator_positive_rows(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectFinalizationRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    unsafe {
+        execute_finalization_rows::<WeylPropagatorPositive>(
+            arena,
+            momenta,
+            factors,
+            rows,
+            row_count,
+            point_count,
+        )
+    }
+}
+
+unsafe extern "C" fn execute_weyl_propagator_negative_rows(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectFinalizationRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    unsafe {
+        execute_finalization_rows::<WeylPropagatorNegative>(
+            arena,
+            momenta,
+            factors,
+            rows,
+            row_count,
+            point_count,
+        )
+    }
+}
+
+unsafe extern "C" fn execute_feynman_vector_propagator_rows(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectFinalizationRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    unsafe {
+        execute_finalization_rows::<FeynmanVectorPropagator>(
+            arena,
+            momenta,
+            factors,
+            rows,
+            row_count,
+            point_count,
+        )
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+unsafe fn execute_rows<F: DirectContributionFormula>(
+    context: *const c_void,
+    arena: DirectArenaView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    if context.is_null() {
+        return STATUS_INVALID_CONTEXT;
+    }
+    if row_count == 0
+        || rows.is_null()
+        || point_count == 0
+        || arena.point_stride == 0
+        || point_count > arena.point_stride
+        || arena.current_re.is_null()
+        || arena.current_im.is_null()
+        || factors.values_re.is_null()
+        || factors.values_im.is_null()
+    {
+        return STATUS_INVALID_ARGUMENT;
+    }
+    let context = unsafe { &*context.cast::<RecurrenceIntrinsicScale>() };
+    let context_scale = match effective_context_scale(*context, parameters) {
+        Ok(scale) => scale.mul(F::BASE_SCALE),
+        Err(status) => return status,
+    };
+    let stride = arena.point_stride as usize;
+    let points = point_count as usize;
+
+    for row_index in 0..row_count as usize {
+        let row = unsafe { *rows.add(row_index) };
+        if row.parent1_component_base_or_sentinel == DIRECT_NONE_U32 {
+            return STATUS_INVALID_ARGUMENT;
+        }
+        if row.exact_factor_id >= factors.value_count
+            || !component_range_in_bounds(
+                row.parent0_component_base,
+                F::PARENT0_COMPONENTS,
+                arena.current_scalar_len,
+                arena.point_stride,
+                point_count,
+            )
+            || !component_range_in_bounds(
+                row.parent1_component_base_or_sentinel,
+                F::PARENT1_COMPONENTS,
+                arena.current_scalar_len,
+                arena.point_stride,
+                point_count,
+            )
+            || !component_range_in_bounds(
+                row.destination_component_base,
+                F::DESTINATION_COMPONENTS,
+                arena.current_scalar_len,
+                arena.point_stride,
+                point_count,
+            )
+        {
+            return STATUS_BOUNDS;
+        }
+        let row_factor = ComplexValue::new(
+            unsafe { *factors.values_re.add(row.exact_factor_id as usize) },
+            unsafe { *factors.values_im.add(row.exact_factor_id as usize) },
+        );
+        let scale = context_scale.mul(row_factor);
+        let mut point = 0usize;
+        while point + 1 < points {
+            unsafe { F::evaluate_pair(arena, row, stride, point, scale) };
+            point += 2;
+        }
+        if point < points {
+            unsafe { F::evaluate_point(arena, row, stride, point, scale) };
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+unsafe fn execute_finalization_rows<F: DirectFinalizationFormula>(
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    factors: DirectFactorView,
+    rows: *const DirectFinalizationRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    if row_count == 0
+        || rows.is_null()
+        || point_count == 0
+        || arena.point_stride == 0
+        || point_count > arena.point_stride
+        || arena.current_re.is_null()
+        || arena.current_im.is_null()
+        || momenta.values.is_null()
+        || momenta.lorentz_component_count != 4
+        || momenta.point_stride != arena.point_stride
+        || point_count > momenta.point_stride
+        || factors.values_re.is_null()
+        || factors.values_im.is_null()
+    {
+        return STATUS_INVALID_ARGUMENT;
+    }
+    let stride = arena.point_stride as usize;
+    let points = point_count as usize;
+    for row_index in 0..row_count as usize {
+        let row = unsafe { *rows.add(row_index) };
+        if row.component_count != F::COMPONENTS
+            || row.exact_factor_id >= factors.value_count
+            || !component_range_in_bounds(
+                row.component_base,
+                u32::from(F::COMPONENTS),
+                arena.current_scalar_len,
+                arena.point_stride,
+                point_count,
+            )
+            || !momentum_form_in_bounds(momenta, row.momentum_form_id, point_count)
+        {
+            return STATUS_BOUNDS;
+        }
+        let row_factor = ComplexValue::new(
+            unsafe { *factors.values_re.add(row.exact_factor_id as usize) },
+            unsafe { *factors.values_im.add(row.exact_factor_id as usize) },
+        );
+        let mut point = 0usize;
+        while point + 1 < points {
+            unsafe { F::evaluate_pair(arena, momenta, row, stride, point, row_factor) };
+            point += 2;
+        }
+        if point < points {
+            unsafe { F::evaluate_point(arena, momenta, row, stride, point, row_factor) };
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+fn effective_context_scale(
+    context: RecurrenceIntrinsicScale,
+    parameters: DirectParameterView,
+) -> Result<ComplexValue, c_int> {
+    let literal = ComplexValue::new(context.literal_re, context.literal_im);
+    let Some(parameter_index) = context.model_parameter_index else {
+        return Ok(literal);
+    };
+    if parameters.values_re.is_null()
+        || parameters.values_im.is_null()
+        || parameter_index >= parameters.value_count
+    {
+        return Err(STATUS_BOUNDS);
+    }
+    let parameter = ComplexValue::new(
+        unsafe { *parameters.values_re.add(parameter_index as usize) },
+        unsafe { *parameters.values_im.add(parameter_index as usize) },
+    );
+    Ok(literal.mul(parameter))
+}
+
+#[inline(always)]
+fn reciprocal_minkowski_norm(p0: f64, p1: f64, p2: f64, p3: f64) -> f64 {
+    1.0 / (p0 * p0 - p1 * p1 - p2 * p2 - p3 * p3)
+}
+
+#[inline(always)]
+fn reciprocal_minkowski_norm_pair(p0: f64x2, p1: f64x2, p2: f64x2, p3: f64x2) -> f64x2 {
+    let one = f64x2::new([1.0, 1.0]);
+    one / (p0 * p0 - p1 * p1 - p2 * p2 - p3 * p3)
+}
+
+fn component_range_in_bounds(
+    component_base: u32,
+    component_count: u32,
+    scalar_len: u64,
+    point_stride: u32,
+    point_count: u32,
+) -> bool {
+    let Some(last_component) = component_base.checked_add(component_count.saturating_sub(1)) else {
+        return false;
+    };
+    u64::from(last_component)
+        .checked_mul(u64::from(point_stride))
+        .and_then(|base| base.checked_add(u64::from(point_count)))
+        .is_some_and(|end| end <= scalar_len)
+}
+
+fn momentum_form_in_bounds(
+    momenta: DirectMomentumView,
+    momentum_form_id: u32,
+    point_count: u32,
+) -> bool {
+    if momentum_form_id >= momenta.form_count || momenta.lorentz_component_count != 4 {
+        return false;
+    }
+    u64::from(momentum_form_id)
+        .checked_mul(u64::from(momenta.lorentz_component_count))
+        .and_then(|plane| plane.checked_add(3))
+        .and_then(|plane| plane.checked_mul(u64::from(momenta.point_stride)))
+        .and_then(|base| base.checked_add(u64::from(point_count)))
+        .is_some_and(|end| end <= momenta.scalar_len)
+}
+
+#[inline(always)]
+fn minkowski_complex_dot(left: [ComplexValue; 4], right: [ComplexValue; 4]) -> ComplexValue {
+    left[0]
+        .mul(right[0])
+        .sub(left[1].mul(right[1]))
+        .sub(left[2].mul(right[2]))
+        .sub(left[3].mul(right[3]))
+}
+
+#[inline(always)]
+fn minkowski_complex_real_dot(left: [ComplexValue; 4], right: [f64; 4]) -> ComplexValue {
+    left[0]
+        .mul_real(right[0])
+        .sub(left[1].mul_real(right[1]))
+        .sub(left[2].mul_real(right[2]))
+        .sub(left[3].mul_real(right[3]))
+}
+
+#[inline(always)]
+fn minkowski_simd_complex_dot(left: [SimdComplex2; 4], right: [SimdComplex2; 4]) -> SimdComplex2 {
+    left[0]
+        .mul(right[0])
+        .sub(left[1].mul(right[1]))
+        .sub(left[2].mul(right[2]))
+        .sub(left[3].mul(right[3]))
+}
+
+#[inline(always)]
+fn minkowski_simd_complex_real_dot(left: [SimdComplex2; 4], right: [f64x2; 4]) -> SimdComplex2 {
+    left[0]
+        .mul_real(right[0])
+        .sub(left[1].mul_real(right[1]))
+        .sub(left[2].mul_real(right[2]))
+        .sub(left[3].mul_real(right[3]))
+}
+
+#[inline(always)]
+unsafe fn load_current(
+    arena: DirectArenaView,
+    component: u32,
+    stride: usize,
+    point: usize,
+) -> ComplexValue {
+    let offset = component as usize * stride + point;
+    ComplexValue::new(unsafe { *arena.current_re.add(offset) }, unsafe {
+        *arena.current_im.add(offset)
+    })
+}
+
+#[inline(always)]
+unsafe fn load_current_pair(
+    arena: DirectArenaView,
+    component: u32,
+    stride: usize,
+    point: usize,
+) -> SimdComplex2 {
+    let offset = component as usize * stride + point;
+    SimdComplex2::new(
+        f64x2::new([unsafe { *arena.current_re.add(offset) }, unsafe {
+            *arena.current_re.add(offset + 1)
+        }]),
+        f64x2::new([unsafe { *arena.current_im.add(offset) }, unsafe {
+            *arena.current_im.add(offset + 1)
+        }]),
+    )
+}
+
+#[inline(always)]
+unsafe fn load_momentum(
+    momenta: DirectMomentumView,
+    momentum_form_id: u32,
+    lorentz_component: u16,
+    stride: usize,
+    point: usize,
+) -> f64 {
+    let plane = momentum_form_id as usize * usize::from(momenta.lorentz_component_count)
+        + usize::from(lorentz_component);
+    unsafe { *momenta.values.add(plane * stride + point) }
+}
+
+#[inline(always)]
+unsafe fn load_momentum_pair(
+    momenta: DirectMomentumView,
+    momentum_form_id: u32,
+    lorentz_component: u16,
+    stride: usize,
+    point: usize,
+) -> f64x2 {
+    let plane = momentum_form_id as usize * usize::from(momenta.lorentz_component_count)
+        + usize::from(lorentz_component);
+    let offset = plane * stride + point;
+    f64x2::new([unsafe { *momenta.values.add(offset) }, unsafe {
+        *momenta.values.add(offset + 1)
+    }])
+}
+
+#[inline(always)]
+fn contribution_accumulates(row: DirectContributionRow) -> bool {
+    row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION == 0
+}
+
+#[inline(always)]
+unsafe fn add_scaled_current(
+    arena: DirectArenaView,
+    component: u32,
+    stride: usize,
+    point: usize,
+    value: ComplexValue,
+    scale: ComplexValue,
+    accumulate: bool,
+) {
+    let offset = component as usize * stride + point;
+    let contribution = value.mul(scale);
+    unsafe {
+        if accumulate {
+            *arena.current_re.add(offset) += contribution.re;
+            *arena.current_im.add(offset) += contribution.im;
+        } else {
+            *arena.current_re.add(offset) = contribution.re;
+            *arena.current_im.add(offset) = contribution.im;
+        }
+    }
+}
+
+#[inline(always)]
+unsafe fn add_scaled_current_pair(
+    arena: DirectArenaView,
+    component: u32,
+    stride: usize,
+    point: usize,
+    value: SimdComplex2,
+    scale: ComplexValue,
+    accumulate: bool,
+) {
+    let scale_re = f64x2::new([scale.re, scale.re]);
+    let scale_im = f64x2::new([scale.im, scale.im]);
+    let contribution_re = value.re * scale_re - value.im * scale_im;
+    let contribution_im = value.re * scale_im + value.im * scale_re;
+    let re = unsafe { core::mem::transmute::<f64x2, [f64; 2]>(contribution_re) };
+    let im = unsafe { core::mem::transmute::<f64x2, [f64; 2]>(contribution_im) };
+    let offset = component as usize * stride + point;
+    unsafe {
+        if accumulate {
+            *arena.current_re.add(offset) += re[0];
+            *arena.current_re.add(offset + 1) += re[1];
+            *arena.current_im.add(offset) += im[0];
+            *arena.current_im.add(offset + 1) += im[1];
+        } else {
+            *arena.current_re.add(offset) = re[0];
+            *arena.current_re.add(offset + 1) = re[1];
+            *arena.current_im.add(offset) = im[0];
+            *arena.current_im.add(offset + 1) = im[1];
+        }
+    }
+}
+
+#[inline(always)]
+unsafe fn set_scaled_current(
+    arena: DirectArenaView,
+    component: u32,
+    stride: usize,
+    point: usize,
+    value: ComplexValue,
+    scale: ComplexValue,
+) {
+    let offset = component as usize * stride + point;
+    let contribution = value.mul(scale);
+    unsafe {
+        *arena.current_re.add(offset) = contribution.re;
+        *arena.current_im.add(offset) = contribution.im;
+    }
+}
+
+#[inline(always)]
+unsafe fn set_pre_scaled_current_pair(
+    arena: DirectArenaView,
+    component: u32,
+    stride: usize,
+    point: usize,
+    value: SimdComplex2,
+    scale: SimdComplex2,
+) {
+    let contribution = value.mul(scale);
+    let re = unsafe { core::mem::transmute::<f64x2, [f64; 2]>(contribution.re) };
+    let im = unsafe { core::mem::transmute::<f64x2, [f64; 2]>(contribution.im) };
+    let offset = component as usize * stride + point;
+    unsafe {
+        *arena.current_re.add(offset) = re[0];
+        *arena.current_re.add(offset + 1) = re[1];
+        *arena.current_im.add(offset) = im[0];
+        *arena.current_im.add(offset + 1) = im[1];
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::DirectClosureRow;
+    use crate::recurrence::direct_backend::{
+        DirectContributionFanoutBundle, DirectContributionFanoutRun, DirectInteractionAnchor,
+        DirectInteractionOutput, DirectInteractionTensorOutput, DirectInteractionTerminalClosure,
+    };
+
+    #[derive(Clone, Copy, Debug)]
+    struct ReferenceComplex {
+        re: f64,
+        im: f64,
+    }
+
+    impl ReferenceComplex {
+        fn new(re: f64, im: f64) -> Self {
+            Self { re, im }
+        }
+
+        fn add(self, other: Self) -> Self {
+            Self::new(self.re + other.re, self.im + other.im)
+        }
+
+        fn sub(self, other: Self) -> Self {
+            Self::new(self.re - other.re, self.im - other.im)
+        }
+
+        fn neg(self) -> Self {
+            Self::new(-self.re, -self.im)
+        }
+
+        fn mul(self, other: Self) -> Self {
+            Self::new(
+                self.re * other.re - self.im * other.im,
+                self.re * other.im + self.im * other.re,
+            )
+        }
+
+        fn mul_i(self) -> Self {
+            Self::new(-self.im, self.re)
+        }
+
+        fn mul_real(self, value: f64) -> Self {
+            Self::new(self.re * value, self.im * value)
+        }
+    }
+
+    fn fill_component(re: &mut [f64], im: &mut [f64], stride: usize, component: usize, seed: f64) {
+        for point in 0..stride {
+            re[component * stride + point] = seed + point as f64 * 0.17;
+            im[component * stride + point] = -0.3 * seed + point as f64 * 0.11;
+        }
+    }
+
+    fn read_component(
+        re: &[f64],
+        im: &[f64],
+        stride: usize,
+        component: usize,
+        point: usize,
+    ) -> ReferenceComplex {
+        ReferenceComplex::new(
+            re[component * stride + point],
+            im[component * stride + point],
+        )
+    }
+
+    fn views(
+        current_re: &mut [f64],
+        current_im: &mut [f64],
+        stride: u32,
+        parameters_re: &[f64],
+        parameters_im: &[f64],
+        factors_re: &[f64],
+        factors_im: &[f64],
+    ) -> (
+        DirectArenaView,
+        DirectMomentumView,
+        DirectParameterView,
+        DirectFactorView,
+    ) {
+        (
+            DirectArenaView {
+                current_re: current_re.as_mut_ptr(),
+                current_im: current_im.as_mut_ptr(),
+                current_scalar_len: current_re.len() as u64,
+                amplitude_re: ptr::null_mut(),
+                amplitude_im: ptr::null_mut(),
+                amplitude_scalar_len: 0,
+                point_stride: stride,
+            },
+            DirectMomentumView {
+                values: ptr::null(),
+                scalar_len: 0,
+                form_count: 0,
+                lorentz_component_count: 4,
+                point_stride: stride,
+            },
+            DirectParameterView {
+                values_re: parameters_re.as_ptr(),
+                values_im: parameters_im.as_ptr(),
+                value_count: parameters_re.len() as u32,
+            },
+            DirectFactorView {
+                values_re: factors_re.as_ptr(),
+                values_im: factors_im.as_ptr(),
+                value_count: factors_re.len() as u32,
+            },
+        )
+    }
+
+    fn effective_test_scale(
+        literal: ReferenceComplex,
+        parameter: ReferenceComplex,
+        factor: ReferenceComplex,
+    ) -> ReferenceComplex {
+        literal.mul(parameter).mul(factor)
+    }
+
+    fn assert_close(actual: ReferenceComplex, expected: ReferenceComplex) {
+        assert!(
+            (actual.re - expected.re).abs() < 2.0e-13,
+            "real mismatch: actual {}, expected {}",
+            actual.re,
+            expected.re
+        );
+        assert!(
+            (actual.im - expected.im).abs() < 2.0e-13,
+            "imaginary mismatch: actual {}, expected {}",
+            actual.im,
+            expected.im
+        );
+    }
+
+    #[test]
+    fn runtime_template_names_round_trip_and_unknown_names_fail_closed() {
+        let kinds = [
+            RecurrenceContributionIntrinsicKind::WeylVectorToWeylPositive,
+            RecurrenceContributionIntrinsicKind::WeylVectorToWeylNegative,
+            RecurrenceContributionIntrinsicKind::AntisymmetricTensorVectorToVector,
+            RecurrenceContributionIntrinsicKind::VectorWedgeVectorToAntisymmetricTensor,
+            RecurrenceContributionIntrinsicKind::ColorOrderedThreeVector,
+        ];
+        for kind in kinds {
+            assert_eq!(
+                RecurrenceContributionIntrinsicKind::from_runtime_template(kind.runtime_template())
+                    .unwrap(),
+                kind
+            );
+        }
+        assert!(
+            RecurrenceContributionIntrinsicKind::from_runtime_template(
+                "rusticol.recurrence.contribution.unknown.v1"
+            )
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn fused_fanout_matches_supported_intrinsic_rows() {
+        for kind in [
+            RecurrenceContributionIntrinsicKind::AntisymmetricTensorVectorToVector,
+            RecurrenceContributionIntrinsicKind::VectorWedgeVectorToAntisymmetricTensor,
+            RecurrenceContributionIntrinsicKind::ColorOrderedThreeVector,
+        ] {
+            let initial_re = (0..22)
+                .map(|component| component as f64 * 0.37 - 1.2)
+                .collect::<Vec<_>>();
+            let initial_im = initial_re
+                .iter()
+                .map(|value| -0.3 * value)
+                .collect::<Vec<_>>();
+            let mut direct_re = initial_re.clone();
+            let mut direct_im = initial_im.clone();
+            let mut fused_re = initial_re;
+            let mut fused_im = initial_im;
+            let factors_re = [0.7, -0.3];
+            let factors_im = [0.2, 0.8];
+            let parameters_re = [-0.4];
+            let parameters_im = [0.6];
+            let momenta_values = [1.1, 0.2, -0.4, 0.7, 0.6, -0.8, 0.3, -0.5];
+            let first = DirectContributionRow {
+                parent0_component_base: 0,
+                parent1_component_base_or_sentinel: 6,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 1,
+                destination_component_base: 10,
+                exact_factor_id: 0,
+                selector_domain_id: 0,
+                flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            };
+            let rows = [
+                first,
+                DirectContributionRow {
+                    destination_component_base: 16,
+                    exact_factor_id: 1,
+                    flags: 0,
+                    ..first
+                },
+            ];
+            let executor = LoadedRecurrenceIntrinsicDirectExecutor::load(
+                kind,
+                RecurrenceIntrinsicScale::new(0.75, -0.2, Some(0)).unwrap(),
+            );
+            let execute_views = |re: &mut [f64], im: &mut [f64]| {
+                let (arena, _, parameters, factors) = views(
+                    re,
+                    im,
+                    1,
+                    &parameters_re,
+                    &parameters_im,
+                    &factors_re,
+                    &factors_im,
+                );
+                let momenta = DirectMomentumView {
+                    values: momenta_values.as_ptr(),
+                    scalar_len: 8,
+                    form_count: 2,
+                    lorentz_component_count: 4,
+                    point_stride: 1,
+                };
+                (arena, momenta, parameters, factors)
+            };
+            let (arena, momenta, parameters, factors) =
+                execute_views(&mut direct_re, &mut direct_im);
+            let handle = executor.contribution_handle();
+            assert_eq!(
+                unsafe {
+                    (handle.call)(
+                        handle.context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        rows.as_ptr(),
+                        2,
+                        1,
+                    )
+                },
+                DIRECT_STATUS_OK
+            );
+
+            let (arena, momenta, parameters, factors) = execute_views(&mut fused_re, &mut fused_im);
+            let fused = executor.contribution_fanout_handle().unwrap();
+            let run = DirectContributionFanoutRun {
+                row_start: 0,
+                row_count: 2,
+                scratch_component_base: 0,
+                bundle_start: 0,
+                bundle_count: 2,
+            };
+            let bundles = [
+                DirectContributionFanoutBundle {
+                    row_start: 0,
+                    row_count: 1,
+                    effective_factor_id_or_sentinel: 0,
+                },
+                DirectContributionFanoutBundle {
+                    row_start: 1,
+                    row_count: 1,
+                    effective_factor_id_or_sentinel: 1,
+                },
+            ];
+            unsafe {
+                (fused.call)(
+                    fused.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    DirectContributionFanoutBatch {
+                        rows: &rows,
+                        runs: &[run],
+                        bundles: &bundles,
+                    },
+                )
+            }
+            .unwrap();
+            if kind == RecurrenceContributionIntrinsicKind::ColorOrderedThreeVector {
+                assert!(
+                    unsafe {
+                        (fused.call)(
+                            fused.context,
+                            arena,
+                            DirectMomentumView {
+                                lorentz_component_count: 3,
+                                ..momenta
+                            },
+                            parameters,
+                            factors,
+                            DirectContributionFanoutBatch {
+                                rows: &rows,
+                                runs: &[run],
+                                bundles: &bundles,
+                            },
+                        )
+                    }
+                    .is_err()
+                );
+            }
+            for (actual, expected) in fused_re
+                .iter()
+                .zip(&direct_re)
+                .chain(fused_im.iter().zip(&direct_im))
+            {
+                assert!((actual - expected).abs() < 2.0e-13);
+            }
+        }
+    }
+
+    #[test]
+    fn identity_finalization_is_backend_neutral_and_bounds_checked() {
+        let stride = 3usize;
+        let point_count = 2usize;
+        let mut current_re = vec![1.0, 2.0, 99.0, 3.0, 4.0, 88.0];
+        let mut current_im = vec![5.0, 6.0, 77.0, 7.0, 8.0, 66.0];
+        let factors_re = [2.0];
+        let factors_im = [-1.0];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            stride as u32,
+            &[],
+            &[],
+            &factors_re,
+            &factors_im,
+        );
+        let row = DirectFinalizationRow {
+            component_base: 0,
+            component_count: 2,
+            momentum_form_id: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+
+        assert_eq!(
+            unsafe {
+                execute_identity_finalization_rows(
+                    ptr::null(),
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&row),
+                    1,
+                    point_count as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+        assert_eq!(current_re, vec![7.0, 10.0, 99.0, 13.0, 16.0, 88.0]);
+        assert_eq!(current_im, vec![9.0, 10.0, 77.0, 11.0, 12.0, 66.0]);
+
+        let out_of_bounds = DirectFinalizationRow {
+            component_base: 1,
+            component_count: 2,
+            ..row
+        };
+        assert_eq!(
+            unsafe {
+                execute_identity_finalization_rows(
+                    ptr::null(),
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&out_of_bounds),
+                    1,
+                    point_count as u32,
+                )
+            },
+            STATUS_BOUNDS
+        );
+    }
+
+    #[test]
+    fn weyl_vector_chirality_variants_match_reference_math_and_add() {
+        for kind in [
+            RecurrenceContributionIntrinsicKind::WeylVectorToWeylPositive,
+            RecurrenceContributionIntrinsicKind::WeylVectorToWeylNegative,
+        ] {
+            let stride = 5usize;
+            let mut current_re = vec![0.0; 8 * stride];
+            let mut current_im = vec![0.0; 8 * stride];
+            for component in 0..6 {
+                fill_component(
+                    &mut current_re,
+                    &mut current_im,
+                    stride,
+                    component,
+                    0.4 + component as f64,
+                );
+            }
+            fill_component(&mut current_re, &mut current_im, stride, 6, 7.0);
+            fill_component(&mut current_re, &mut current_im, stride, 7, -3.0);
+            let before_re = current_re.clone();
+            let before_im = current_im.clone();
+            let parameters_re = [-0.4];
+            let parameters_im = [0.3];
+            let factors_re = [1.25];
+            let factors_im = [-0.5];
+            let (arena, momenta, parameters, factors) = views(
+                &mut current_re,
+                &mut current_im,
+                stride as u32,
+                &parameters_re,
+                &parameters_im,
+                &factors_re,
+                &factors_im,
+            );
+            let intrinsic_literal = ReferenceComplex::new(0.75, -0.2)
+                .mul(ReferenceComplex::new(std::f64::consts::FRAC_1_SQRT_2, 0.0));
+            let scale =
+                RecurrenceIntrinsicScale::new(intrinsic_literal.re, intrinsic_literal.im, Some(0))
+                    .unwrap();
+            let executor = LoadedRecurrenceIntrinsicDirectExecutor::load(kind, scale);
+            let handle = executor.contribution_handle();
+            let row = DirectContributionRow {
+                parent0_component_base: 0,
+                parent1_component_base_or_sentinel: 2,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 0,
+                destination_component_base: 6,
+                exact_factor_id: 0,
+                selector_domain_id: 0,
+                flags: 0,
+            };
+            let status = unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&row),
+                    1,
+                    stride as u32,
+                )
+            };
+            assert_eq!(status, DIRECT_STATUS_OK);
+
+            let total_scale = effective_test_scale(
+                intrinsic_literal,
+                ReferenceComplex::new(parameters_re[0], parameters_im[0]),
+                ReferenceComplex::new(factors_re[0], factors_im[0]),
+            );
+            for point in 0..stride {
+                let l0 = read_component(&before_re, &before_im, stride, 0, point);
+                let l1 = read_component(&before_re, &before_im, stride, 1, point);
+                let r0 = read_component(&before_re, &before_im, stride, 2, point);
+                let r1 = read_component(&before_re, &before_im, stride, 3, point);
+                let r2 = read_component(&before_re, &before_im, stride, 4, point);
+                let r3 = read_component(&before_re, &before_im, stride, 5, point);
+                let output = match kind {
+                    RecurrenceContributionIntrinsicKind::WeylVectorToWeylPositive => [
+                        l0.mul(r3)
+                            .mul_i()
+                            .neg()
+                            .sub(l1.mul(r1).mul_i())
+                            .add(l1.mul(r2))
+                            .add(l0.mul(r0).mul_i()),
+                        l0.mul(r2)
+                            .neg()
+                            .sub(l0.mul(r1).mul_i())
+                            .add(l1.mul(r0).mul_i())
+                            .add(l1.mul(r3).mul_i()),
+                    ],
+                    RecurrenceContributionIntrinsicKind::WeylVectorToWeylNegative => [
+                        l1.mul(r2)
+                            .neg()
+                            .add(l0.mul(r0).mul_i())
+                            .add(l0.mul(r3).mul_i())
+                            .add(l1.mul(r1).mul_i()),
+                        l1.mul(r3)
+                            .mul_i()
+                            .neg()
+                            .add(l0.mul(r2))
+                            .add(l0.mul(r1).mul_i())
+                            .add(l1.mul(r0).mul_i()),
+                    ],
+                    _ => unreachable!(),
+                };
+                for (component, value) in output.into_iter().enumerate() {
+                    let initial =
+                        read_component(&before_re, &before_im, stride, 6 + component, point);
+                    let expected = initial.add(value.mul(total_scale));
+                    let actual =
+                        read_component(&current_re, &current_im, stride, 6 + component, point);
+                    assert_close(actual, expected);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn initializing_intrinsic_contribution_overwrites_poisoned_complex_multipoint_destination() {
+        let stride = 5usize;
+        let mut current_re = vec![0.0; 8 * stride];
+        let mut current_im = vec![0.0; 8 * stride];
+        for component in 0..6 {
+            fill_component(
+                &mut current_re,
+                &mut current_im,
+                stride,
+                component,
+                0.4 + component as f64,
+            );
+        }
+        let factors_re = [1.25];
+        let factors_im = [-0.5];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            stride as u32,
+            &[],
+            &[],
+            &factors_re,
+            &factors_im,
+        );
+        let executor = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::WeylVectorToWeylPositive,
+            RecurrenceIntrinsicScale::new(0.75, -0.2, None).unwrap(),
+        );
+        let handle = executor.contribution_handle();
+        let row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 2,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 0,
+            destination_component_base: 6,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&row),
+                    1,
+                    stride as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+        let expected_re = current_re[6 * stride..].to_vec();
+        let expected_im = current_im[6 * stride..].to_vec();
+        current_re[6 * stride..].fill(f64::NAN);
+        current_im[6 * stride..].fill(f64::NAN);
+        let initializing = DirectContributionRow {
+            flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            ..row
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&initializing),
+                    1,
+                    stride as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+        assert_eq!(&current_re[6 * stride..], expected_re.as_slice());
+        assert_eq!(&current_im[6 * stride..], expected_im.as_slice());
+        assert!(expected_im.iter().any(|value| *value != 0.0));
+    }
+
+    #[test]
+    fn tensor_vector_intrinsic_matches_reference_math() {
+        let stride = 4usize;
+        let mut current_re = vec![0.0; 14 * stride];
+        let mut current_im = vec![0.0; 14 * stride];
+        for component in 0..14 {
+            fill_component(
+                &mut current_re,
+                &mut current_im,
+                stride,
+                component,
+                0.2 + component as f64 * 0.4,
+            );
+        }
+        let before_re = current_re.clone();
+        let before_im = current_im.clone();
+        let factors_re = [0.8];
+        let factors_im = [0.1];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            stride as u32,
+            &[],
+            &[],
+            &factors_re,
+            &factors_im,
+        );
+        let executor = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::AntisymmetricTensorVectorToVector,
+            RecurrenceIntrinsicScale::new(0.0, 0.5, None).unwrap(),
+        );
+        let handle = executor.contribution_handle();
+        let row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 6,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 0,
+            destination_component_base: 10,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&row),
+                    1,
+                    stride as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+
+        let scale = ReferenceComplex::new(0.0, 0.5)
+            .mul(ReferenceComplex::new(factors_re[0], factors_im[0]));
+        for point in 0..stride {
+            let left = std::array::from_fn::<_, 6, _>(|component| {
+                read_component(&before_re, &before_im, stride, component, point)
+            });
+            let right = std::array::from_fn::<_, 4, _>(|component| {
+                read_component(&before_re, &before_im, stride, 6 + component, point)
+            });
+            let output = [
+                left[0]
+                    .mul(right[1])
+                    .add(left[1].mul(right[2]))
+                    .add(left[2].mul(right[3])),
+                left[0]
+                    .mul(right[0])
+                    .add(left[3].mul(right[2]))
+                    .add(left[4].mul(right[3])),
+                left[1]
+                    .mul(right[0])
+                    .sub(left[3].mul(right[1]))
+                    .add(left[5].mul(right[3])),
+                left[2]
+                    .mul(right[0])
+                    .sub(left[4].mul(right[1]))
+                    .sub(left[5].mul(right[2])),
+            ];
+            for (component, value) in output.into_iter().enumerate() {
+                let initial = read_component(&before_re, &before_im, stride, 10 + component, point);
+                let actual =
+                    read_component(&current_re, &current_im, stride, 10 + component, point);
+                assert_close(actual, initial.add(value.mul(scale)));
+            }
+        }
+    }
+
+    #[test]
+    fn vector_wedge_intrinsic_matches_reference_math() {
+        let stride = 3usize;
+        let mut current_re = vec![0.0; 14 * stride];
+        let mut current_im = vec![0.0; 14 * stride];
+        for component in 0..14 {
+            fill_component(
+                &mut current_re,
+                &mut current_im,
+                stride,
+                component,
+                -0.7 + component as f64 * 0.6,
+            );
+        }
+        let before_re = current_re.clone();
+        let before_im = current_im.clone();
+        let factors_re = [1.1];
+        let factors_im = [-0.35];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            stride as u32,
+            &[],
+            &[],
+            &factors_re,
+            &factors_im,
+        );
+        let executor = LoadedRecurrenceIntrinsicDirectExecutor::load_runtime_template(
+            VECTOR_WEDGE_VECTOR_TO_ANTISYMMETRIC_TENSOR_TEMPLATE,
+            RecurrenceIntrinsicScale::unit(),
+        )
+        .unwrap();
+        let handle = executor.contribution_handle();
+        assert!(
+            executor
+                .contribution_fanout_handle()
+                .unwrap()
+                .interaction_call
+                .is_none(),
+            "wedge remains on its ordinary/fanout dispatch path"
+        );
+        let row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 4,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 0,
+            destination_component_base: 8,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&row),
+                    1,
+                    stride as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+
+        let scale = ReferenceComplex::new(factors_re[0], factors_im[0]);
+        for point in 0..stride {
+            let left = std::array::from_fn::<_, 4, _>(|component| {
+                read_component(&before_re, &before_im, stride, component, point)
+            });
+            let right = std::array::from_fn::<_, 4, _>(|component| {
+                read_component(&before_re, &before_im, stride, 4 + component, point)
+            });
+            let output = [
+                left[0].mul(right[1]).sub(left[1].mul(right[0])),
+                left[0].mul(right[2]).sub(left[2].mul(right[0])),
+                left[0].mul(right[3]).sub(left[3].mul(right[0])),
+                left[1].mul(right[2]).sub(left[2].mul(right[1])),
+                left[1].mul(right[3]).sub(left[3].mul(right[1])),
+                left[2].mul(right[3]).sub(left[3].mul(right[2])),
+            ];
+            for (component, value) in output.into_iter().enumerate() {
+                let initial = read_component(&before_re, &before_im, stride, 8 + component, point);
+                let actual = read_component(&current_re, &current_im, stride, 8 + component, point);
+                assert_close(actual, initial.add(value.mul(scale)));
+            }
+        }
+    }
+
+    #[test]
+    fn interaction_bundle_matches_rows_across_order_sides_and_live_mutation() {
+        let component_count = 56_usize;
+        let mut seed_re = vec![0.0; component_count];
+        let mut seed_im = vec![0.0; component_count];
+        for component in 0..component_count {
+            seed_re[component] = 0.13 + component as f64 * 0.071;
+            seed_im[component] = -0.29 + component as f64 * 0.043;
+        }
+        for component in 40..48 {
+            seed_re[component] = 91.0;
+            seed_im[component] = -37.0;
+        }
+        let momenta_values = (0..16)
+            .map(|index| -0.8 + index as f64 * 0.19)
+            .collect::<Vec<_>>();
+        let rows = [
+            DirectContributionRow {
+                parent0_component_base: 0,
+                parent1_component_base_or_sentinel: 4,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 1,
+                destination_component_base: 40,
+                exact_factor_id: 0,
+                selector_domain_id: 0,
+                flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            },
+            DirectContributionRow {
+                parent0_component_base: 0,
+                parent1_component_base_or_sentinel: 4,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 1,
+                destination_component_base: 44,
+                exact_factor_id: 1,
+                selector_domain_id: 0,
+                flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            },
+            DirectContributionRow {
+                parent0_component_base: 8,
+                parent1_component_base_or_sentinel: 12,
+                parent0_momentum_form_id: 2,
+                parent1_momentum_form_id_or_sentinel: 3,
+                destination_component_base: 40,
+                exact_factor_id: 2,
+                selector_domain_id: 0,
+                flags: 0,
+            },
+            DirectContributionRow {
+                parent0_component_base: 16,
+                parent1_component_base_or_sentinel: 0,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 0,
+                destination_component_base: 44,
+                exact_factor_id: 3,
+                selector_domain_id: 0,
+                flags: 0,
+            },
+            DirectContributionRow {
+                parent0_component_base: 16,
+                parent1_component_base_or_sentinel: 0,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 0,
+                destination_component_base: 40,
+                exact_factor_id: 4,
+                selector_domain_id: 0,
+                flags: 0,
+            },
+            DirectContributionRow {
+                parent0_component_base: 24,
+                parent1_component_base_or_sentinel: 12,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 3,
+                destination_component_base: 40,
+                exact_factor_id: 5,
+                selector_domain_id: 0,
+                flags: 0,
+            },
+        ];
+        let anchors = [
+            DirectInteractionAnchor {
+                parent_component_bases: [0, 4],
+                parent_momentum_form_ids: [0, 1],
+                operands: DirectInteractionOperands::One(DirectInteractionOperand {
+                    tensor_component_base: 16,
+                    vector_parent: DirectInteractionVectorParent::Parent0,
+                }),
+                output_start: 0,
+                output_end: 2,
+                tensor_output_start: 0,
+                tensor_output_end: 0,
+            },
+            DirectInteractionAnchor {
+                parent_component_bases: [8, 12],
+                parent_momentum_form_ids: [2, 3],
+                operands: DirectInteractionOperands::One(DirectInteractionOperand {
+                    tensor_component_base: 24,
+                    vector_parent: DirectInteractionVectorParent::Parent1,
+                }),
+                output_start: 2,
+                output_end: 3,
+                tensor_output_start: 0,
+                tensor_output_end: 0,
+            },
+        ];
+        let outputs = [
+            DirectInteractionOutput {
+                destination_component_base: 40,
+                exact_factor_ids: [0, 4, 0],
+                initialize: true,
+            },
+            DirectInteractionOutput {
+                destination_component_base: 44,
+                exact_factor_ids: [1, 3, 0],
+                initialize: true,
+            },
+            DirectInteractionOutput {
+                destination_component_base: 40,
+                exact_factor_ids: [2, 5, 0],
+                initialize: false,
+            },
+        ];
+        let color = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::ColorOrderedThreeVector,
+            RecurrenceIntrinsicScale::new(0.73, -0.21, Some(0)).unwrap(),
+        );
+        let atv = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::AntisymmetricTensorVectorToVector,
+            RecurrenceIntrinsicScale::new(-0.37, 0.42, Some(0)).unwrap(),
+        );
+        let color_handle = color.contribution_handle();
+        let atv_handle = atv.contribution_handle();
+        let contexts = DirectInteractionExecutorContexts {
+            color: color_handle.context,
+            vector_wedge_vector: ptr::null(),
+            antisymmetric_tensor_vector: atv_handle.context,
+        };
+
+        for atv_before_color in [false, true] {
+            for (parameters_re, parameters_im, factors_re, factors_im) in [
+                (
+                    vec![0.61],
+                    vec![-0.17],
+                    vec![1.2, -0.8, 0.55, -1.4, 0.72, -0.31],
+                    vec![0.1, 0.35, -0.22, 0.19, -0.44, 0.27],
+                ),
+                (
+                    vec![-0.43],
+                    vec![0.29],
+                    vec![-0.7, 1.6, -1.1, 0.48, -0.36, 1.23],
+                    vec![0.31, -0.27, 0.08, -0.52, 0.41, -0.14],
+                ),
+            ] {
+                let mut expected_re = seed_re.clone();
+                let mut expected_im = seed_im.clone();
+                let mut candidate_re = seed_re.clone();
+                let mut candidate_im = seed_im.clone();
+                let parameter_view = DirectParameterView {
+                    values_re: parameters_re.as_ptr(),
+                    values_im: parameters_im.as_ptr(),
+                    value_count: 1,
+                };
+                let factor_view = DirectFactorView {
+                    values_re: factors_re.as_ptr(),
+                    values_im: factors_im.as_ptr(),
+                    value_count: factors_re.len() as u32,
+                };
+                let momentum_view = DirectMomentumView {
+                    values: momenta_values.as_ptr(),
+                    scalar_len: momenta_values.len() as u64,
+                    form_count: 4,
+                    lorentz_component_count: 4,
+                    point_stride: 1,
+                };
+                let arena = |re: &mut [f64], im: &mut [f64]| DirectArenaView {
+                    current_re: re.as_mut_ptr(),
+                    current_im: im.as_mut_ptr(),
+                    current_scalar_len: re.len() as u64,
+                    amplitude_re: ptr::null_mut(),
+                    amplitude_im: ptr::null_mut(),
+                    amplitude_scalar_len: 0,
+                    point_stride: 1,
+                };
+                let mut oracle_rows = rows;
+                if atv_before_color {
+                    oracle_rows[0].flags = 0;
+                    oracle_rows[1].flags = 0;
+                    oracle_rows[3].flags = DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION;
+                    oracle_rows[4].flags = DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION;
+                    assert_eq!(
+                        unsafe {
+                            (atv_handle.call)(
+                                atv_handle.context,
+                                arena(&mut expected_re, &mut expected_im),
+                                momentum_view,
+                                parameter_view,
+                                factor_view,
+                                oracle_rows[3..].as_ptr(),
+                                3,
+                                1,
+                            )
+                        },
+                        DIRECT_STATUS_OK
+                    );
+                    assert_eq!(
+                        unsafe {
+                            (color_handle.call)(
+                                color_handle.context,
+                                arena(&mut expected_re, &mut expected_im),
+                                momentum_view,
+                                parameter_view,
+                                factor_view,
+                                oracle_rows[..3].as_ptr(),
+                                3,
+                                1,
+                            )
+                        },
+                        DIRECT_STATUS_OK
+                    );
+                } else {
+                    assert_eq!(
+                        unsafe {
+                            (color_handle.call)(
+                                color_handle.context,
+                                arena(&mut expected_re, &mut expected_im),
+                                momentum_view,
+                                parameter_view,
+                                factor_view,
+                                oracle_rows[..3].as_ptr(),
+                                3,
+                                1,
+                            )
+                        },
+                        DIRECT_STATUS_OK
+                    );
+                    assert_eq!(
+                        unsafe {
+                            (atv_handle.call)(
+                                atv_handle.context,
+                                arena(&mut expected_re, &mut expected_im),
+                                momentum_view,
+                                parameter_view,
+                                factor_view,
+                                oracle_rows[3..].as_ptr(),
+                                3,
+                                1,
+                            )
+                        },
+                        DIRECT_STATUS_OK
+                    );
+                }
+                let candidate_pointer = candidate_re.as_ptr();
+                unsafe {
+                    execute_interaction_bundle(
+                        contexts,
+                        arena(&mut candidate_re, &mut candidate_im),
+                        momentum_view,
+                        parameter_view,
+                        factor_view,
+                        DirectInteractionBundleBatch {
+                            anchors: &anchors,
+                            outputs: &outputs,
+                            tensor_outputs: &[],
+                            terminal: None,
+                            requirements: DirectInteractionRuntimeRequirements {
+                                current_component_count: 48,
+                                momentum_form_count: 4,
+                                parameter_count: 1,
+                                factor_count: 6,
+                            },
+                            atv_before_color,
+                        },
+                    )
+                }
+                .unwrap();
+                assert_eq!(candidate_re.as_ptr(), candidate_pointer);
+                for component in 40..48 {
+                    let error = (candidate_re[component] - expected_re[component])
+                        .hypot(candidate_im[component] - expected_im[component]);
+                    let scale = candidate_re[component]
+                        .hypot(candidate_im[component])
+                        .max(expected_re[component].hypot(expected_im[component]))
+                        .max(1.0);
+                    assert!(error <= 2.0e-12 * scale, "component {component}: {error:e}");
+                }
+            }
+        }
+
+        let mut rejected_re = seed_re.clone();
+        let mut rejected_im = seed_im.clone();
+        let before_re = rejected_re.clone();
+        let before_im = rejected_im.clone();
+        let parameters_re = [0.61];
+        let parameters_im = [-0.17];
+        let short_factors_re = [1.2, -0.8, 0.55, -1.4, 0.72];
+        let short_factors_im = [0.1, 0.35, -0.22, 0.19, -0.44];
+        let error = unsafe {
+            execute_interaction_bundle(
+                contexts,
+                DirectArenaView {
+                    current_re: rejected_re.as_mut_ptr(),
+                    current_im: rejected_im.as_mut_ptr(),
+                    current_scalar_len: rejected_re.len() as u64,
+                    amplitude_re: ptr::null_mut(),
+                    amplitude_im: ptr::null_mut(),
+                    amplitude_scalar_len: 0,
+                    point_stride: 1,
+                },
+                DirectMomentumView {
+                    values: momenta_values.as_ptr(),
+                    scalar_len: momenta_values.len() as u64,
+                    form_count: 4,
+                    lorentz_component_count: 4,
+                    point_stride: 1,
+                },
+                DirectParameterView {
+                    values_re: parameters_re.as_ptr(),
+                    values_im: parameters_im.as_ptr(),
+                    value_count: 1,
+                },
+                DirectFactorView {
+                    values_re: short_factors_re.as_ptr(),
+                    values_im: short_factors_im.as_ptr(),
+                    value_count: short_factors_re.len() as u32,
+                },
+                DirectInteractionBundleBatch {
+                    anchors: &anchors,
+                    outputs: &outputs,
+                    tensor_outputs: &[],
+                    terminal: None,
+                    requirements: DirectInteractionRuntimeRequirements {
+                        current_component_count: 48,
+                        momentum_form_count: 4,
+                        parameter_count: 1,
+                        factor_count: 6,
+                    },
+                    atv_before_color: false,
+                },
+            )
+        }
+        .unwrap_err();
+        assert!(error.to_string().contains("factor catalog"));
+        assert_eq!(rejected_re, before_re);
+        assert_eq!(rejected_im, before_im);
+    }
+
+    #[test]
+    fn interaction_bundle_fuses_sibling_wedge_with_live_complex_scales() {
+        let mut seed_re = vec![0.0; 48];
+        let mut seed_im = vec![0.0; 48];
+        for component in 0..48 {
+            seed_re[component] = -0.8 + component as f64 * 0.071;
+            seed_im[component] = 0.3 - component as f64 * 0.043;
+        }
+        let momenta_values = [0.7, -1.1, 0.4, 1.6, -0.2, 0.9, -1.3, 0.5];
+        let parameters_re = [0.61];
+        let parameters_im = [-0.29];
+        let factors_re = [1.2, -0.73, 0.44, -1.31];
+        let factors_im = [-0.17, 0.36, 0.28, -0.09];
+        let color_rows = [
+            DirectContributionRow {
+                parent0_component_base: 0,
+                parent1_component_base_or_sentinel: 4,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 1,
+                destination_component_base: 20,
+                exact_factor_id: 0,
+                selector_domain_id: 0,
+                flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            },
+            DirectContributionRow {
+                exact_factor_id: 1,
+                flags: 0,
+                ..DirectContributionRow {
+                    parent0_component_base: 0,
+                    parent1_component_base_or_sentinel: 4,
+                    parent0_momentum_form_id: 0,
+                    parent1_momentum_form_id_or_sentinel: 1,
+                    destination_component_base: 20,
+                    exact_factor_id: 0,
+                    selector_domain_id: 0,
+                    flags: 0,
+                }
+            },
+        ];
+        let atv_rows = [
+            DirectContributionRow {
+                parent0_component_base: 8,
+                parent1_component_base_or_sentinel: 0,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 0,
+                destination_component_base: 20,
+                exact_factor_id: 2,
+                selector_domain_id: 0,
+                flags: 0,
+            },
+            DirectContributionRow {
+                exact_factor_id: 3,
+                ..DirectContributionRow {
+                    parent0_component_base: 8,
+                    parent1_component_base_or_sentinel: 0,
+                    parent0_momentum_form_id: 0,
+                    parent1_momentum_form_id_or_sentinel: 0,
+                    destination_component_base: 20,
+                    exact_factor_id: 2,
+                    selector_domain_id: 0,
+                    flags: 0,
+                }
+            },
+        ];
+        let wedge_rows = [
+            DirectContributionRow {
+                destination_component_base: 40,
+                exact_factor_id: 0,
+                flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+                ..color_rows[0]
+            },
+            DirectContributionRow {
+                destination_component_base: 40,
+                exact_factor_id: 1,
+                flags: 0,
+                ..color_rows[1]
+            },
+        ];
+        let color = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::ColorOrderedThreeVector,
+            RecurrenceIntrinsicScale::new(0.73, -0.21, Some(0)).unwrap(),
+        );
+        let atv = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::AntisymmetricTensorVectorToVector,
+            RecurrenceIntrinsicScale::new(-0.37, 0.42, Some(0)).unwrap(),
+        );
+        let wedge = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::VectorWedgeVectorToAntisymmetricTensor,
+            RecurrenceIntrinsicScale::new(0.28, 0.63, Some(0)).unwrap(),
+        );
+        let color_handle = color.contribution_handle();
+        let atv_handle = atv.contribution_handle();
+        let wedge_handle = wedge.contribution_handle();
+        let momentum_view = DirectMomentumView {
+            values: momenta_values.as_ptr(),
+            scalar_len: momenta_values.len() as u64,
+            form_count: 2,
+            lorentz_component_count: 4,
+            point_stride: 1,
+        };
+        let parameter_view = DirectParameterView {
+            values_re: parameters_re.as_ptr(),
+            values_im: parameters_im.as_ptr(),
+            value_count: 1,
+        };
+        let factor_view = DirectFactorView {
+            values_re: factors_re.as_ptr(),
+            values_im: factors_im.as_ptr(),
+            value_count: factors_re.len() as u32,
+        };
+        let arena = |re: &mut [f64], im: &mut [f64]| DirectArenaView {
+            current_re: re.as_mut_ptr(),
+            current_im: im.as_mut_ptr(),
+            current_scalar_len: re.len() as u64,
+            amplitude_re: ptr::null_mut(),
+            amplitude_im: ptr::null_mut(),
+            amplitude_scalar_len: 0,
+            point_stride: 1,
+        };
+        let mut expected_re = seed_re.clone();
+        let mut expected_im = seed_im.clone();
+        for (handle, rows) in [
+            (color_handle, color_rows.as_slice()),
+            (atv_handle, atv_rows.as_slice()),
+            (wedge_handle, wedge_rows.as_slice()),
+        ] {
+            assert_eq!(
+                unsafe {
+                    (handle.call)(
+                        handle.context,
+                        arena(&mut expected_re, &mut expected_im),
+                        momentum_view,
+                        parameter_view,
+                        factor_view,
+                        rows.as_ptr(),
+                        rows.len() as u32,
+                        1,
+                    )
+                },
+                DIRECT_STATUS_OK
+            );
+        }
+
+        let anchors = [DirectInteractionAnchor {
+            parent_component_bases: [0, 4],
+            parent_momentum_form_ids: [0, 1],
+            operands: DirectInteractionOperands::One(DirectInteractionOperand {
+                tensor_component_base: 8,
+                vector_parent: DirectInteractionVectorParent::Parent0,
+            }),
+            output_start: 0,
+            output_end: 2,
+            tensor_output_start: 0,
+            tensor_output_end: 2,
+        }];
+        let outputs = [
+            DirectInteractionOutput {
+                destination_component_base: 20,
+                exact_factor_ids: [0, 2, 0],
+                initialize: true,
+            },
+            DirectInteractionOutput {
+                destination_component_base: 20,
+                exact_factor_ids: [1, 3, 0],
+                initialize: false,
+            },
+        ];
+        let tensor_outputs = [
+            DirectInteractionTensorOutput {
+                destination_component_base: 40,
+                exact_factor_id: 0,
+                initialize: true,
+            },
+            DirectInteractionTensorOutput {
+                destination_component_base: 40,
+                exact_factor_id: 1,
+                initialize: false,
+            },
+        ];
+        let mut actual_re = seed_re.clone();
+        let mut actual_im = seed_im.clone();
+        unsafe {
+            execute_interaction_bundle(
+                DirectInteractionExecutorContexts {
+                    color: color_handle.context,
+                    vector_wedge_vector: wedge_handle.context,
+                    antisymmetric_tensor_vector: atv_handle.context,
+                },
+                arena(&mut actual_re, &mut actual_im),
+                momentum_view,
+                parameter_view,
+                factor_view,
+                DirectInteractionBundleBatch {
+                    anchors: &anchors,
+                    outputs: &outputs,
+                    tensor_outputs: &tensor_outputs,
+                    terminal: None,
+                    requirements: DirectInteractionRuntimeRequirements {
+                        current_component_count: 46,
+                        momentum_form_count: 2,
+                        parameter_count: 1,
+                        factor_count: 4,
+                    },
+                    atv_before_color: false,
+                },
+            )
+        }
+        .unwrap();
+        for component in (20..24).chain(40..46) {
+            let error = (actual_re[component] - expected_re[component])
+                .hypot(actual_im[component] - expected_im[component]);
+            let scale = actual_re[component]
+                .hypot(actual_im[component])
+                .max(expected_re[component].hypot(expected_im[component]))
+                .max(1.0);
+            assert!(error <= 2.0e-12 * scale, "component {component}: {error:e}");
+        }
+    }
+
+    #[test]
+    fn terminal_interaction_scalarization_matches_materialized_closure_replay() {
+        let mut seed_re = vec![0.0; 40];
+        let mut seed_im = vec![0.0; 40];
+        for component in 0..40 {
+            seed_re[component] = 0.17 - component as f64 * 0.039;
+            seed_im[component] = -0.41 + component as f64 * 0.052;
+        }
+        let momenta_values = [0.8, -0.5, 1.2, -1.4, -0.3, 1.1, 0.6, -0.9];
+        let parameters_re = [0.57];
+        let parameters_im = [0.23];
+        let factors_re = [1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0];
+        let factors_im = [0.0; 10];
+        let closure_rows = [
+            DirectClosureRow {
+                parent0_component_base: 20,
+                parent1_component_base_or_sentinel: 30,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 0,
+                amplitude_destination_id: 0,
+                exact_factor_id: 8,
+                component_factor_start: 4,
+                component_count: 4,
+                selector_domain_id: 0,
+                flags: 0,
+            },
+            DirectClosureRow {
+                amplitude_destination_id: 1,
+                exact_factor_id: 9,
+                ..DirectClosureRow {
+                    parent0_component_base: 20,
+                    parent1_component_base_or_sentinel: 30,
+                    parent0_momentum_form_id: 0,
+                    parent1_momentum_form_id_or_sentinel: 0,
+                    amplitude_destination_id: 0,
+                    exact_factor_id: 8,
+                    component_factor_start: 4,
+                    component_count: 4,
+                    selector_domain_id: 0,
+                    flags: 0,
+                }
+            },
+        ];
+        let terminal_closures = [
+            DirectInteractionTerminalClosure {
+                root_component_base: 20,
+                amplitude_destination_id: 0,
+                exact_factor_id: 8,
+            },
+            DirectInteractionTerminalClosure {
+                root_component_base: 20,
+                amplitude_destination_id: 1,
+                exact_factor_id: 9,
+            },
+        ];
+        let terminal = DirectInteractionTerminalBatch {
+            partner_component_base: 30,
+            component_factor_start: 4,
+            amplitude_destination_count: 2,
+            closures: &terminal_closures,
+        };
+        let anchor = [DirectInteractionAnchor {
+            parent_component_bases: [0, 4],
+            parent_momentum_form_ids: [0, 1],
+            operands: DirectInteractionOperands::One(DirectInteractionOperand {
+                tensor_component_base: 8,
+                vector_parent: DirectInteractionVectorParent::Parent0,
+            }),
+            output_start: 0,
+            output_end: 2,
+            tensor_output_start: 0,
+            tensor_output_end: 0,
+        }];
+        let outputs = [
+            DirectInteractionOutput {
+                destination_component_base: 20,
+                exact_factor_ids: [0, 2, 0],
+                initialize: true,
+            },
+            DirectInteractionOutput {
+                destination_component_base: 20,
+                exact_factor_ids: [1, 3, 0],
+                initialize: false,
+            },
+        ];
+        let color = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::ColorOrderedThreeVector,
+            RecurrenceIntrinsicScale::new(0.0, 0.69, None).unwrap(),
+        );
+        let atv = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::AntisymmetricTensorVectorToVector,
+            RecurrenceIntrinsicScale::new(0.0, -0.41, None).unwrap(),
+        );
+        let color_handle = color.contribution_handle();
+        let atv_handle = atv.contribution_handle();
+        let contexts = DirectInteractionExecutorContexts {
+            color: color_handle.context,
+            vector_wedge_vector: ptr::null(),
+            antisymmetric_tensor_vector: atv_handle.context,
+        };
+        let momentum_view = DirectMomentumView {
+            values: momenta_values.as_ptr(),
+            scalar_len: momenta_values.len() as u64,
+            form_count: 2,
+            lorentz_component_count: 4,
+            point_stride: 1,
+        };
+        let parameter_view = DirectParameterView {
+            values_re: parameters_re.as_ptr(),
+            values_im: parameters_im.as_ptr(),
+            value_count: 1,
+        };
+        let factor_view = DirectFactorView {
+            values_re: factors_re.as_ptr(),
+            values_im: factors_im.as_ptr(),
+            value_count: factors_re.len() as u32,
+        };
+        let arena = |re: &mut [f64],
+                     im: &mut [f64],
+                     amplitude_re: &mut [f64],
+                     amplitude_im: &mut [f64]|
+         -> DirectArenaView {
+            DirectArenaView {
+                current_re: re.as_mut_ptr(),
+                current_im: im.as_mut_ptr(),
+                current_scalar_len: re.len() as u64,
+                amplitude_re: amplitude_re.as_mut_ptr(),
+                amplitude_im: amplitude_im.as_mut_ptr(),
+                amplitude_scalar_len: amplitude_re.len() as u64,
+                point_stride: 1,
+            }
+        };
+        let requirements = DirectInteractionRuntimeRequirements {
+            current_component_count: 34,
+            momentum_form_count: 2,
+            parameter_count: 0,
+            factor_count: factors_re.len() as u32,
+        };
+
+        let mut expected_re = seed_re.clone();
+        let mut expected_im = seed_im.clone();
+        let mut expected_amplitude_re = vec![0.13, -0.27];
+        let mut expected_amplitude_im = vec![-0.19, 0.08];
+        unsafe {
+            execute_interaction_bundle(
+                contexts,
+                arena(
+                    &mut expected_re,
+                    &mut expected_im,
+                    &mut expected_amplitude_re,
+                    &mut expected_amplitude_im,
+                ),
+                momentum_view,
+                parameter_view,
+                factor_view,
+                DirectInteractionBundleBatch {
+                    anchors: &anchor,
+                    outputs: &outputs,
+                    tensor_outputs: &[],
+                    terminal: None,
+                    requirements,
+                    atv_before_color: false,
+                },
+            )
+        }
+        .unwrap();
+        assert_eq!(
+            unsafe {
+                crate::engine::execute_closure_reduce_rows(
+                    ptr::null(),
+                    arena(
+                        &mut expected_re,
+                        &mut expected_im,
+                        &mut expected_amplitude_re,
+                        &mut expected_amplitude_im,
+                    ),
+                    momentum_view,
+                    parameter_view,
+                    factor_view,
+                    closure_rows.as_ptr(),
+                    closure_rows.len() as u32,
+                    1,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+
+        let mut actual_re = seed_re.clone();
+        let mut actual_im = seed_im.clone();
+        let mut actual_amplitude_re = vec![0.13, -0.27];
+        let mut actual_amplitude_im = vec![-0.19, 0.08];
+        let actual_arena = arena(
+            &mut actual_re,
+            &mut actual_im,
+            &mut actual_amplitude_re,
+            &mut actual_amplitude_im,
+        );
+        unsafe {
+            execute_interaction_bundle(
+                contexts,
+                actual_arena,
+                momentum_view,
+                parameter_view,
+                factor_view,
+                DirectInteractionBundleBatch {
+                    anchors: &anchor,
+                    outputs: &outputs,
+                    tensor_outputs: &[],
+                    terminal: Some(terminal),
+                    requirements,
+                    atv_before_color: false,
+                },
+            )
+        }
+        .unwrap();
+        unsafe { execute_interaction_terminal_closures(actual_arena, factor_view, terminal) }
+            .unwrap();
+
+        for destination in 0..2 {
+            let error = (actual_amplitude_re[destination] - expected_amplitude_re[destination])
+                .hypot(actual_amplitude_im[destination] - expected_amplitude_im[destination]);
+            let scale = actual_amplitude_re[destination]
+                .hypot(actual_amplitude_im[destination])
+                .max(expected_amplitude_re[destination].hypot(expected_amplitude_im[destination]))
+                .max(1.0);
+            assert!(
+                error <= 2.0e-12 * scale,
+                "destination {destination}: {error:e}"
+            );
+        }
+    }
+
+    #[test]
+    fn color_ordered_three_vector_matches_reference_math_and_accumulates() {
+        let stride = 5usize;
+        let point_count = 4usize;
+        let mut current_re = vec![0.0; 12 * stride];
+        let mut current_im = vec![0.0; 12 * stride];
+        for component in 0..12 {
+            fill_component(
+                &mut current_re,
+                &mut current_im,
+                stride,
+                component,
+                -0.9 + component as f64 * 0.37,
+            );
+        }
+        let before_re = current_re.clone();
+        let before_im = current_im.clone();
+        let mut momentum_values = vec![0.0; 2 * 4 * stride];
+        for form in 0..2 {
+            for component in 0..4 {
+                for point in 0..stride {
+                    momentum_values[(form * 4 + component) * stride + point] =
+                        0.23 + form as f64 * 1.7 - component as f64 * 0.41 + point as f64 * 0.19;
+                }
+            }
+        }
+        let parameters_re = [-0.35];
+        let parameters_im = [0.8];
+        let factors_re = [1.2];
+        let factors_im = [0.25];
+        let (arena, _, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            stride as u32,
+            &parameters_re,
+            &parameters_im,
+            &factors_re,
+            &factors_im,
+        );
+        let momenta = DirectMomentumView {
+            values: momentum_values.as_ptr(),
+            scalar_len: momentum_values.len() as u64,
+            form_count: 2,
+            lorentz_component_count: 4,
+            point_stride: stride as u32,
+        };
+        let literal = ReferenceComplex::new(0.45, -0.7);
+        let executor = LoadedRecurrenceIntrinsicDirectExecutor::load_runtime_template(
+            COLOR_ORDERED_THREE_VECTOR_TEMPLATE,
+            RecurrenceIntrinsicScale::new(literal.re, literal.im, Some(0)).unwrap(),
+        )
+        .unwrap();
+        let handle = executor.contribution_handle();
+        let row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 4,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 1,
+            destination_component_base: 8,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&row),
+                    1,
+                    point_count as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+
+        let alpha = effective_test_scale(
+            literal,
+            ReferenceComplex::new(parameters_re[0], parameters_im[0]),
+            ReferenceComplex::new(factors_re[0], factors_im[0]),
+        );
+        for point in 0..point_count {
+            let left = std::array::from_fn::<_, 4, _>(|component| {
+                read_component(&before_re, &before_im, stride, component, point)
+            });
+            let right = std::array::from_fn::<_, 4, _>(|component| {
+                read_component(&before_re, &before_im, stride, 4 + component, point)
+            });
+            let parent0_momentum = std::array::from_fn::<_, 4, _>(|component| {
+                momentum_values[component * stride + point]
+            });
+            let parent1_momentum = std::array::from_fn::<_, 4, _>(|component| {
+                momentum_values[(4 + component) * stride + point]
+            });
+            let vector_dot = left[0]
+                .mul(right[0])
+                .sub(left[1].mul(right[1]))
+                .sub(left[2].mul(right[2]))
+                .sub(left[3].mul(right[3]));
+            let left_dot_parent1 = left[0]
+                .mul_real(parent1_momentum[0])
+                .sub(left[1].mul_real(parent1_momentum[1]))
+                .sub(left[2].mul_real(parent1_momentum[2]))
+                .sub(left[3].mul_real(parent1_momentum[3]));
+            let right_dot_parent0 = right[0]
+                .mul_real(parent0_momentum[0])
+                .sub(right[1].mul_real(parent0_momentum[1]))
+                .sub(right[2].mul_real(parent0_momentum[2]))
+                .sub(right[3].mul_real(parent0_momentum[3]));
+
+            for component in 0..4 {
+                let reference = vector_dot
+                    .mul_real(parent0_momentum[component] - parent1_momentum[component])
+                    .add(
+                        left_dot_parent1
+                            .mul(right[component])
+                            .sub(right_dot_parent0.mul(left[component]))
+                            .mul_real(2.0),
+                    );
+                let initial = read_component(&before_re, &before_im, stride, 8 + component, point);
+                let actual = read_component(&current_re, &current_im, stride, 8 + component, point);
+                assert_close(actual, initial.add(reference.mul(alpha)));
+            }
+        }
+        for component in 8..12 {
+            assert_close(
+                read_component(&current_re, &current_im, stride, component, point_count),
+                read_component(&before_re, &before_im, stride, component, point_count),
+            );
+        }
+
+        let mut expected = Vec::new();
+        for component in 8..12 {
+            for point in 0..point_count {
+                expected.push(
+                    read_component(&current_re, &current_im, stride, component, point).sub(
+                        read_component(&before_re, &before_im, stride, component, point),
+                    ),
+                );
+            }
+        }
+        for component in 8..12 {
+            let start = component * stride;
+            current_re[start..start + point_count].fill(f64::NAN);
+            current_im[start..start + point_count].fill(f64::NAN);
+        }
+        let initializing = DirectContributionRow {
+            flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            ..row
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&initializing),
+                    1,
+                    point_count as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+        for (index, (component, point)) in (8..12)
+            .flat_map(|component| (0..point_count).map(move |point| (component, point)))
+            .enumerate()
+        {
+            assert_close(
+                read_component(&current_re, &current_im, stride, component, point),
+                expected[index],
+            );
+        }
+    }
+
+    #[test]
+    fn color_ordered_three_vector_rejects_malformed_momentum_views_and_rows() {
+        let stride = 3usize;
+        let mut current_re = vec![0.0; 12 * stride];
+        let mut current_im = vec![0.0; 12 * stride];
+        let momentum_values = vec![0.0; 2 * 4 * stride];
+        let factors_re = [1.0];
+        let factors_im = [0.0];
+        let (arena, _, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            stride as u32,
+            &[],
+            &[],
+            &factors_re,
+            &factors_im,
+        );
+        let valid_momenta = DirectMomentumView {
+            values: momentum_values.as_ptr(),
+            scalar_len: momentum_values.len() as u64,
+            form_count: 2,
+            lorentz_component_count: 4,
+            point_stride: stride as u32,
+        };
+        let executor = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::ColorOrderedThreeVector,
+            RecurrenceIntrinsicScale::unit(),
+        );
+        let handle = executor.contribution_handle();
+        let valid_row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 4,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 1,
+            destination_component_base: 8,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        let call = |momenta: DirectMomentumView, row: DirectContributionRow, point_count: u32| unsafe {
+            (handle.call)(
+                handle.context,
+                arena,
+                momenta,
+                parameters,
+                factors,
+                ptr::from_ref(&row),
+                1,
+                point_count,
+            )
+        };
+
+        assert_eq!(
+            call(
+                DirectMomentumView {
+                    values: ptr::null(),
+                    ..valid_momenta
+                },
+                valid_row,
+                stride as u32,
+            ),
+            STATUS_INVALID_ARGUMENT
+        );
+        assert_eq!(
+            call(
+                DirectMomentumView {
+                    lorentz_component_count: 3,
+                    ..valid_momenta
+                },
+                valid_row,
+                stride as u32,
+            ),
+            STATUS_INVALID_ARGUMENT
+        );
+        assert_eq!(
+            call(
+                DirectMomentumView {
+                    point_stride: stride as u32 + 1,
+                    ..valid_momenta
+                },
+                valid_row,
+                stride as u32,
+            ),
+            STATUS_INVALID_ARGUMENT
+        );
+        assert_eq!(
+            call(
+                valid_momenta,
+                DirectContributionRow {
+                    parent0_momentum_form_id: DIRECT_NONE_U32,
+                    ..valid_row
+                },
+                stride as u32,
+            ),
+            STATUS_INVALID_ARGUMENT
+        );
+        assert_eq!(
+            call(
+                valid_momenta,
+                DirectContributionRow {
+                    parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+                    ..valid_row
+                },
+                stride as u32,
+            ),
+            STATUS_INVALID_ARGUMENT
+        );
+        assert_eq!(
+            call(
+                valid_momenta,
+                DirectContributionRow {
+                    parent1_momentum_form_id_or_sentinel: 2,
+                    ..valid_row
+                },
+                stride as u32,
+            ),
+            STATUS_BOUNDS
+        );
+        assert_eq!(
+            call(
+                DirectMomentumView {
+                    scalar_len: valid_momenta.scalar_len - 1,
+                    ..valid_momenta
+                },
+                valid_row,
+                stride as u32,
+            ),
+            STATUS_BOUNDS
+        );
+        assert_eq!(
+            call(valid_momenta, valid_row, stride as u32 + 1),
+            STATUS_INVALID_ARGUMENT
+        );
+    }
+
+    #[test]
+    fn callback_rejects_invalid_context_arguments_and_bounds() {
+        let stride = 2usize;
+        let mut current_re = vec![0.0; 8 * stride];
+        let mut current_im = vec![0.0; 8 * stride];
+        let factors_re = [1.0];
+        let factors_im = [0.0];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            stride as u32,
+            &[],
+            &[],
+            &factors_re,
+            &factors_im,
+        );
+        let executor = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::WeylVectorToWeylPositive,
+            RecurrenceIntrinsicScale::unit(),
+        );
+        let handle = executor.contribution_handle();
+        let valid_row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 2,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 0,
+            destination_component_base: 6,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    ptr::null(),
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&valid_row),
+                    1,
+                    stride as u32,
+                )
+            },
+            STATUS_INVALID_CONTEXT
+        );
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&valid_row),
+                    1,
+                    stride as u32 + 1,
+                )
+            },
+            STATUS_INVALID_ARGUMENT
+        );
+
+        let missing_parent = DirectContributionRow {
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            ..valid_row
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&missing_parent),
+                    1,
+                    stride as u32,
+                )
+            },
+            STATUS_INVALID_ARGUMENT
+        );
+
+        let bad_factor = DirectContributionRow {
+            exact_factor_id: 1,
+            ..valid_row
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&bad_factor),
+                    1,
+                    stride as u32,
+                )
+            },
+            STATUS_BOUNDS
+        );
+
+        let bad_destination = DirectContributionRow {
+            destination_component_base: 7,
+            ..valid_row
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&bad_destination),
+                    1,
+                    stride as u32,
+                )
+            },
+            STATUS_BOUNDS
+        );
+    }
+
+    #[test]
+    fn optional_parameter_index_is_checked_before_row_execution() {
+        let stride = 2usize;
+        let mut current_re = vec![0.0; 8 * stride];
+        let mut current_im = vec![0.0; 8 * stride];
+        let factors_re = [1.0];
+        let factors_im = [0.0];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            stride as u32,
+            &[],
+            &[],
+            &factors_re,
+            &factors_im,
+        );
+        let executor = LoadedRecurrenceIntrinsicDirectExecutor::load(
+            RecurrenceContributionIntrinsicKind::WeylVectorToWeylNegative,
+            RecurrenceIntrinsicScale::new(1.0, 0.0, Some(0)).unwrap(),
+        );
+        let handle = executor.contribution_handle();
+        let row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 2,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 0,
+            destination_component_base: 6,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        assert_eq!(
+            unsafe {
+                (handle.call)(
+                    handle.context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    ptr::from_ref(&row),
+                    1,
+                    stride as u32,
+                )
+            },
+            STATUS_BOUNDS
+        );
+    }
+
+    #[test]
+    fn scale_constructor_rejects_nonfinite_values_and_reserved_parameter_index() {
+        assert!(RecurrenceIntrinsicScale::new(f64::NAN, 0.0, None).is_err());
+        assert!(RecurrenceIntrinsicScale::new(1.0, f64::INFINITY, None).is_err());
+        assert!(RecurrenceIntrinsicScale::new(1.0, 0.0, Some(DIRECT_NONE_U32)).is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/recurrence_source_direct.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/recurrence_source_direct.rs
new file mode 100644
index 0000000000..2c8fc31155
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/recurrence_source_direct.rs
@@ -0,0 +1,2480 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Model-generic SourceIR execution for Direct-Arena recurrence plans.
+//!
+//! The loader resolves SourceIR crossing semantics once into immutable
+//! dispatch domains. Momentum crossing is already represented by each direct
+//! row's momentum form, and its exact factor owns the crossing phase. The hot
+//! call therefore reads one crossed momentum, evaluates the established
+//! Rusticol source formula, multiplies the row factor, and writes directly to
+//! persistent split-complex current planes.
+
+#[cfg(not(feature = "symbolica-runtime"))]
+use num_complex::Complex;
+#[cfg(feature = "symbolica-runtime")]
+use symbolica::prelude::Complex;
+
+use crate::recurrence::direct_backend::{
+    DIRECT_STATUS_OK, DirectArenaView, DirectFactorView, DirectMomentumView, DirectParameterView,
+    DirectResolvedSourceSelection, DirectSourceDispatchVariantDescriptor, DirectSourceEmbeddingRow,
+    DirectSourceExecutor, DirectUnionSourceDispatchHandle,
+};
+use crate::recurrence::on_the_fly::{
+    OnTheFlyBoundUnionSourceProgram, OnTheFlyUnionSourceBindingView,
+};
+use crate::recurrence::{DIRECT_NONE_U32, DirectSourceRow, ExactComplexRational};
+use crate::{RusticolError, RusticolResult};
+use std::ffi::{c_int, c_void};
+use std::ptr;
+
+// Reuse the established generic source formulas instead of maintaining a
+// second set of physics expressions.
+use crate::engine::wavefunctions as source_wavefunctions;
+
+const STATUS_INVALID_CONTEXT: c_int = 1;
+const STATUS_INVALID_ARGUMENT: c_int = 2;
+const STATUS_EXECUTION_FAILED: c_int = 3;
+const STATUS_BOUNDS: c_int = 4;
+
+/// Source families currently supported by the canonical SourceIR executor.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum DirectSourceWavefunctionFamily {
+    Scalar,
+    WeylFermion,
+    DiracFermion,
+    Vector,
+    Spin2,
+}
+
+impl DirectSourceWavefunctionFamily {
+    const fn component_count(self) -> u16 {
+        match self {
+            Self::Scalar => 1,
+            Self::WeylFermion => 2,
+            Self::DiracFermion | Self::Vector => 4,
+            Self::Spin2 => 16,
+        }
+    }
+}
+
+/// Particle orientation needed by fermion source formulas.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum DirectSourceOrientation {
+    Particle,
+    Antiparticle,
+    SelfConjugate,
+}
+
+/// One crossed SourceIR state ready for direct execution.
+///
+/// `helicity` and `chirality` are the effective values after SourceIR
+/// crossing. `mass_parameter_index` addresses the prepared parameter view.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct DirectSourceTemplateSpec {
+    pub(crate) spin_state_class: i32,
+    pub(crate) family: DirectSourceWavefunctionFamily,
+    pub(crate) orientation: DirectSourceOrientation,
+    pub(crate) helicity: i32,
+    pub(crate) chirality: i32,
+    pub(crate) mass_parameter_index: Option<u32>,
+}
+
+impl DirectSourceTemplateSpec {
+    fn validate(self) -> RusticolResult<()> {
+        if matches!(
+            self.family,
+            DirectSourceWavefunctionFamily::WeylFermion
+                | DirectSourceWavefunctionFamily::DiracFermion
+        ) && self.orientation == DirectSourceOrientation::SelfConjugate
+        {
+            return Err(RusticolError::invalid_argument(
+                "direct recurrence SourceIR fermion cannot use self-conjugate orientation",
+            ));
+        }
+        match self.family {
+            DirectSourceWavefunctionFamily::Scalar if self.helicity != 0 => {
+                return Err(RusticolError::invalid_argument(
+                    "direct recurrence scalar source helicity must be zero",
+                ));
+            }
+            DirectSourceWavefunctionFamily::WeylFermion
+            | DirectSourceWavefunctionFamily::DiracFermion
+                if !matches!(self.helicity, -1 | 1) =>
+            {
+                return Err(RusticolError::invalid_argument(
+                    "direct recurrence fermion source helicity must be -1 or +1",
+                ));
+            }
+            DirectSourceWavefunctionFamily::WeylFermion if !matches!(self.chirality, -1 | 1) => {
+                return Err(RusticolError::invalid_argument(
+                    "direct recurrence Weyl source chirality must be -1 or +1",
+                ));
+            }
+            DirectSourceWavefunctionFamily::Vector if !matches!(self.helicity, -1..=1) => {
+                return Err(RusticolError::invalid_argument(
+                    "direct recurrence vector source helicity must be -1, 0, or +1",
+                ));
+            }
+            DirectSourceWavefunctionFamily::Spin2 if !matches!(self.helicity, -2..=2) => {
+                return Err(RusticolError::invalid_argument(
+                    "direct recurrence spin-2 source helicity must be between -2 and +2",
+                ));
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+}
+
+/// One row-addressable source-template or runtime-dispatch domain.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(crate) enum DirectSourceDispatchKey {
+    SpinStateClass(i32),
+    RuntimeVariant {
+        source_row_id: u32,
+        runtime_variant_id: u32,
+    },
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct DirectSourceDispatchVariantSpec {
+    pub(crate) key: DirectSourceDispatchKey,
+    pub(crate) template: DirectSourceTemplateSpec,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct DirectSourceDispatchDomainSpec {
+    pub(crate) variants: Vec<DirectSourceDispatchVariantSpec>,
+}
+
+struct DirectSourceDispatchDomain {
+    variants: Box<[DirectSourceDispatchVariantSpec]>,
+}
+
+impl DirectSourceDispatchDomain {
+    fn resolve(&self, key: DirectSourceDispatchKey) -> Option<DirectSourceTemplateSpec> {
+        self.variants
+            .binary_search_by_key(&key, |variant| variant.key)
+            .ok()
+            .map(|index| self.variants[index].template)
+    }
+}
+
+struct DirectSourceExecutorContext {
+    domains: Box<[DirectSourceDispatchDomain]>,
+}
+
+#[derive(Clone, Copy)]
+struct BoundUnionSourceEmbedding {
+    source_component_or_sentinel: u32,
+    scale_re: f64,
+    scale_im: f64,
+}
+
+#[derive(Clone, Copy)]
+struct BoundUnionSourceRow {
+    template: DirectSourceTemplateSpec,
+    destination_component_base: u32,
+    momentum_form_id: u32,
+    embedding_start: u32,
+    embedding_count: u32,
+}
+
+struct LoadedBoundUnionSourceProgram {
+    rows: Box<[BoundUnionSourceRow]>,
+    embeddings: Box<[BoundUnionSourceEmbedding]>,
+    current_component_count: u32,
+    momentum_form_count: u32,
+    parameter_count: u32,
+}
+
+fn source_binding_integrity(message: impl Into<String>) -> RusticolError {
+    RusticolError::integrity(format!(
+        "cold-bound recurrence union source: {}",
+        message.into()
+    ))
+}
+
+fn exact_factor_parts(value: ExactComplexRational) -> RusticolResult<(f64, f64)> {
+    let real = value.real().numerator() as f64 / value.real().denominator() as f64;
+    let imag = value.imag().numerator() as f64 / value.imag().denominator() as f64;
+    if !real.is_finite() || !imag.is_finite() {
+        return Err(source_binding_integrity(
+            "exact factor is not finite in binary64",
+        ));
+    }
+    Ok((real, imag))
+}
+
+/// Context-aware source handle published into the Direct-Arena catalog.
+#[derive(Clone, Copy)]
+pub(crate) struct ContextDirectSourceExecutorHandle {
+    pub(crate) call: DirectSourceExecutor,
+    pub(crate) context: *const c_void,
+}
+
+/// Owns the immutable context addressed by a source handle.
+pub(crate) struct LoadedDirectSourceExecutor {
+    context: Box<DirectSourceExecutorContext>,
+}
+
+impl LoadedDirectSourceExecutor {
+    /// Build and authenticate source dispatch domains at load time.
+    ///
+    /// Domain indices must match `DirectSourceRow::
+    /// source_template_or_dispatch_domain`. Singleton domains represent fixed
+    /// topology-replay templates; multi-variant domains support runtime
+    /// helicity dispatch without changing the hot-call ABI.
+    pub(crate) fn load(mut domains: Vec<DirectSourceDispatchDomainSpec>) -> RusticolResult<Self> {
+        if domains.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "direct recurrence source catalog must contain at least one dispatch domain",
+            ));
+        }
+        let mut loaded = Vec::with_capacity(domains.len());
+        for (domain_index, domain) in domains.iter_mut().enumerate() {
+            if domain.variants.is_empty() {
+                return Err(RusticolError::invalid_argument(format!(
+                    "direct recurrence source dispatch domain {domain_index} is empty"
+                )));
+            }
+            domain.variants.sort_unstable_by_key(|variant| variant.key);
+            for variant in &domain.variants {
+                variant.template.validate()?;
+            }
+            if domain.variants.windows(2).any(|pair| {
+                std::mem::discriminant(&pair[0].key) != std::mem::discriminant(&pair[1].key)
+            }) {
+                return Err(RusticolError::invalid_argument(format!(
+                    "direct recurrence source dispatch domain {domain_index} mixes spin and runtime-variant keys"
+                )));
+            }
+            if domain
+                .variants
+                .windows(2)
+                .any(|pair| pair[0].key == pair[1].key)
+            {
+                return Err(RusticolError::invalid_argument(format!(
+                    "direct recurrence source dispatch domain {domain_index} repeats a dispatch key"
+                )));
+            }
+            loaded.push(DirectSourceDispatchDomain {
+                variants: std::mem::take(&mut domain.variants).into_boxed_slice(),
+            });
+        }
+        Ok(Self {
+            context: Box::new(DirectSourceExecutorContext {
+                domains: loaded.into_boxed_slice(),
+            }),
+        })
+    }
+
+    pub(crate) fn handle(&self) -> ContextDirectSourceExecutorHandle {
+        ContextDirectSourceExecutorHandle {
+            call: execute_direct_source_rows,
+            context: ptr::from_ref(self.context.as_ref()).cast(),
+        }
+    }
+
+    /// Return the all-flow-union source-dispatch handle backed by the same
+    /// immutable SourceIR domain catalog.
+    pub(crate) fn union_handle(&self) -> DirectUnionSourceDispatchHandle {
+        DirectUnionSourceDispatchHandle {
+            call: execute_direct_union_source_rows,
+            context: ptr::from_ref(self.context.as_ref()).cast(),
+        }
+    }
+
+    /// Resolve and authenticate one selected-helicity union source program.
+    ///
+    /// The returned object owns compact copies of its templates and embedded
+    /// component scales.  The complete variant/domain catalogs are consulted
+    /// only here and are absent from warmed execution.
+    pub(crate) fn bind_union_program(
+        &self,
+        view: OnTheFlyUnionSourceBindingView<'_>,
+    ) -> RusticolResult<Box<dyn OnTheFlyBoundUnionSourceProgram>> {
+        if view.sources.is_empty()
+            || view.variants.is_empty()
+            || view.embeddings.is_empty()
+            || view.selections.is_empty()
+            || view.exact_factors.is_empty()
+            || view.current_component_count == 0
+            || view.momentum_form_count == 0
+            || view.sources.len() != view.selections.len()
+        {
+            return Err(source_binding_integrity(
+                "selected source tables or execution shape are empty or inconsistent",
+            ));
+        }
+
+        let mut rows = Vec::with_capacity(view.selections.len());
+        let mut embeddings = Vec::new();
+        for (source_slot, selection) in view.selections.iter().copied().enumerate() {
+            if selection.source_slot != source_slot as u32 {
+                return Err(source_binding_integrity(
+                    "source selections are not in canonical source-slot order",
+                ));
+            }
+            let variant = view
+                .variants
+                .get(selection.dispatch_variant_id as usize)
+                .ok_or_else(|| source_binding_integrity("dispatch variant is out of bounds"))?;
+            let row = view
+                .sources
+                .get(variant.source_row_id as usize)
+                .ok_or_else(|| source_binding_integrity("source row is out of bounds"))?;
+            if row.source_slot != selection.source_slot
+                || row.source_template_or_dispatch_domain != variant.dispatch_domain_id
+                || row.momentum_form_id >= view.momentum_form_count
+            {
+                return Err(source_binding_integrity(
+                    "source row, dispatch domain, or momentum form is inconsistent",
+                ));
+            }
+            let row_factor = view
+                .exact_factors
+                .get(row.exact_factor_id as usize)
+                .ok_or_else(|| source_binding_integrity("source row factor is out of bounds"))?;
+            if *row_factor != ExactComplexRational::ONE {
+                return Err(source_binding_integrity(
+                    "union source row has a non-unit structural factor",
+                ));
+            }
+            let crossing_factor = view
+                .exact_factors
+                .get(variant.crossing_exact_factor_id as usize)
+                .copied()
+                .ok_or_else(|| source_binding_integrity("crossing factor is out of bounds"))?;
+            let (crossing_re, crossing_im) = exact_factor_parts(crossing_factor)?;
+
+            let domain = self
+                .context
+                .domains
+                .get(variant.dispatch_domain_id as usize)
+                .ok_or_else(|| source_binding_integrity("dispatch domain is out of bounds"))?;
+            let template = domain
+                .resolve(DirectSourceDispatchKey::RuntimeVariant {
+                    source_row_id: variant.source_row_id,
+                    runtime_variant_id: variant.runtime_variant_id,
+                })
+                .ok_or_else(|| {
+                    source_binding_integrity("runtime source template is absent from its domain")
+                })?;
+            if template.spin_state_class != variant.crossed_spin_state_class
+                || u32::from(template.family.component_count()) != variant.projection_count
+            {
+                return Err(source_binding_integrity(
+                    "runtime source template disagrees with its variant descriptor",
+                ));
+            }
+            if template
+                .mass_parameter_index
+                .is_some_and(|index| index >= view.parameter_count)
+            {
+                return Err(source_binding_integrity(
+                    "runtime source mass parameter is out of bounds",
+                ));
+            }
+
+            let embedding_start = usize::try_from(variant.embedding_start)
+                .map_err(|_| source_binding_integrity("embedding start exceeds usize"))?;
+            let embedding_end = embedding_start
+                .checked_add(variant.embedding_count as usize)
+                .ok_or_else(|| source_binding_integrity("embedding range overflows usize"))?;
+            let selected_embeddings = view
+                .embeddings
+                .get(embedding_start..embedding_end)
+                .ok_or_else(|| source_binding_integrity("embedding range is out of bounds"))?;
+            if selected_embeddings.is_empty() {
+                return Err(source_binding_integrity("embedding range is empty"));
+            }
+            let destination_end = row
+                .destination_component_base
+                .checked_add(variant.embedding_count)
+                .ok_or_else(|| source_binding_integrity("destination range overflows u32"))?;
+            if destination_end > view.current_component_count {
+                return Err(source_binding_integrity(
+                    "destination range is outside the current arena",
+                ));
+            }
+
+            let bound_embedding_start = u32::try_from(embeddings.len())
+                .map_err(|_| source_binding_integrity("bound embedding start exceeds u32"))?;
+            for (full_component, embedding) in selected_embeddings.iter().copied().enumerate() {
+                if embedding.full_component != full_component as u32 {
+                    return Err(source_binding_integrity(
+                        "embedding components are not in canonical order",
+                    ));
+                }
+                let factor = view
+                    .exact_factors
+                    .get(embedding.exact_factor_id as usize)
+                    .copied()
+                    .ok_or_else(|| source_binding_integrity("embedding factor is out of bounds"))?;
+                let (embedding_re, embedding_im) = exact_factor_parts(factor)?;
+                if embedding.source_component_or_sentinel != DIRECT_NONE_U32
+                    && embedding.source_component_or_sentinel
+                        >= u32::from(template.family.component_count())
+                {
+                    return Err(source_binding_integrity(
+                        "embedding source component is out of bounds",
+                    ));
+                }
+                // The legacy dispatcher does not combine an inactive
+                // embedding's otherwise-authenticated factor. Preserve that
+                // exact zero path even if two finite factors would overflow
+                // when multiplied.
+                let (scale_re, scale_im) =
+                    if embedding.source_component_or_sentinel == DIRECT_NONE_U32 {
+                        (0.0, 0.0)
+                    } else {
+                        (
+                            crossing_re * embedding_re - crossing_im * embedding_im,
+                            crossing_re * embedding_im + crossing_im * embedding_re,
+                        )
+                    };
+                embeddings.push(BoundUnionSourceEmbedding {
+                    source_component_or_sentinel: embedding.source_component_or_sentinel,
+                    scale_re,
+                    scale_im,
+                });
+            }
+            rows.push(BoundUnionSourceRow {
+                template,
+                destination_component_base: row.destination_component_base,
+                momentum_form_id: row.momentum_form_id,
+                embedding_start: bound_embedding_start,
+                embedding_count: variant.embedding_count,
+            });
+        }
+
+        Ok(Box::new(LoadedBoundUnionSourceProgram {
+            rows: rows.into_boxed_slice(),
+            embeddings: embeddings.into_boxed_slice(),
+            current_component_count: view.current_component_count,
+            momentum_form_count: view.momentum_form_count,
+            parameter_count: view.parameter_count,
+        }))
+    }
+}
+
+impl OnTheFlyBoundUnionSourceProgram for LoadedBoundUnionSourceProgram {
+    unsafe fn execute(
+        &self,
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        let expected_current_scalars = u64::from(self.current_component_count)
+            .checked_mul(u64::from(arena.point_stride))
+            .ok_or_else(|| source_binding_integrity("current arena shape overflows u64"))?;
+        let expected_momentum_scalars = u64::from(self.momentum_form_count)
+            .checked_mul(4)
+            .and_then(|planes| planes.checked_mul(u64::from(arena.point_stride)))
+            .ok_or_else(|| source_binding_integrity("momentum arena shape overflows u64"))?;
+        if point_count == 0
+            || arena.point_stride == 0
+            || point_count > arena.point_stride
+            || arena.current_re.is_null()
+            || arena.current_im.is_null()
+            || arena.current_scalar_len != expected_current_scalars
+            || momenta.values.is_null()
+            || momenta.point_stride != arena.point_stride
+            || momenta.lorentz_component_count != 4
+            || momenta.form_count != self.momentum_form_count
+            || momenta.scalar_len != expected_momentum_scalars
+            || parameters.value_count != self.parameter_count
+            || (self.parameter_count != 0 && parameters.values_re.is_null())
+        {
+            return Err(source_binding_integrity(
+                "warm Direct-Arena views disagree with the cold-bound shape",
+            ));
+        }
+        usize::try_from(expected_current_scalars)
+            .and_then(|_| usize::try_from(expected_momentum_scalars))
+            .map_err(|_| source_binding_integrity("warm Direct-Arena shape exceeds usize"))?;
+
+        for row in &self.rows {
+            let start = row.embedding_start as usize;
+            let end = start + row.embedding_count as usize;
+            // Cold binding proved every compact range against the owned
+            // embedding table.  Rechecking that invariant for every warmed
+            // source row would put a catalog bound back on the hot path.
+            let row_embeddings = unsafe { self.embeddings.get_unchecked(start..end) };
+            let mass = match row.template.mass_parameter_index {
+                Some(index) => unsafe { *parameters.values_re.add(index as usize) },
+                None => 0.0,
+            };
+            for point in 0..point_count {
+                let momentum = read_momentum(momenta, row.momentum_form_id, point);
+                match row.template.family {
+                    DirectSourceWavefunctionFamily::Scalar => unsafe {
+                        write_bound_embedded_wavefunction(
+                            arena,
+                            row.destination_component_base,
+                            point,
+                            [Complex::new(1.0, 0.0)],
+                            row_embeddings,
+                        )
+                    },
+                    DirectSourceWavefunctionFamily::WeylFermion => {
+                        let wave = match row.template.orientation {
+                            DirectSourceOrientation::Particle => {
+                                source_wavefunctions::ext_quark_weyl_array(
+                                    momentum,
+                                    row.template.helicity,
+                                    row.template.chirality,
+                                )
+                            }
+                            DirectSourceOrientation::Antiparticle => {
+                                source_wavefunctions::ext_antiquark_weyl_array(
+                                    momentum,
+                                    row.template.helicity,
+                                    row.template.chirality,
+                                )
+                            }
+                            DirectSourceOrientation::SelfConjugate => {
+                                return Err(source_binding_integrity(
+                                    "Weyl source has self-conjugate orientation",
+                                ));
+                            }
+                        };
+                        unsafe {
+                            write_bound_embedded_wavefunction(
+                                arena,
+                                row.destination_component_base,
+                                point,
+                                wave,
+                                row_embeddings,
+                            )
+                        };
+                    }
+                    DirectSourceWavefunctionFamily::DiracFermion => {
+                        let wave = match row.template.orientation {
+                            DirectSourceOrientation::Particle => {
+                                source_wavefunctions::ext_quark_dirac_massive(
+                                    momentum,
+                                    row.template.helicity,
+                                    mass,
+                                )
+                            }
+                            DirectSourceOrientation::Antiparticle => {
+                                source_wavefunctions::ext_antiquark_dirac_massive(
+                                    momentum,
+                                    row.template.helicity,
+                                    mass,
+                                )
+                            }
+                            DirectSourceOrientation::SelfConjugate => {
+                                return Err(source_binding_integrity(
+                                    "Dirac source has self-conjugate orientation",
+                                ));
+                            }
+                        };
+                        unsafe {
+                            write_bound_embedded_wavefunction(
+                                arena,
+                                row.destination_component_base,
+                                point,
+                                wave,
+                                row_embeddings,
+                            )
+                        };
+                    }
+                    DirectSourceWavefunctionFamily::Vector => {
+                        let wave = if mass == 0.0 {
+                            source_wavefunctions::ext_gluon(momentum, row.template.helicity)
+                        } else {
+                            source_wavefunctions::ext_massive_vector(
+                                momentum,
+                                row.template.helicity,
+                                mass,
+                            )
+                        };
+                        unsafe {
+                            write_bound_embedded_wavefunction(
+                                arena,
+                                row.destination_component_base,
+                                point,
+                                wave,
+                                row_embeddings,
+                            )
+                        };
+                    }
+                    DirectSourceWavefunctionFamily::Spin2 => {
+                        let wave =
+                            source_wavefunctions::ext_spin2(momentum, row.template.helicity, mass)
+                                .map_err(|_| {
+                                    RusticolError::evaluation(
+                                        "cold-bound recurrence spin-2 source evaluation failed",
+                                    )
+                                })?;
+                        unsafe {
+                            write_bound_embedded_wavefunction(
+                                arena,
+                                row.destination_component_base,
+                                point,
+                                wave,
+                                row_embeddings,
+                            )
+                        };
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+unsafe extern "C" fn execute_direct_source_rows(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectSourceRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    if context.is_null() {
+        return STATUS_INVALID_CONTEXT;
+    }
+    if rows.is_null()
+        || row_count == 0
+        || point_count == 0
+        || arena.point_stride == 0
+        || point_count > arena.point_stride
+        || momenta.point_stride != arena.point_stride
+        || momenta.lorentz_component_count != 4
+    {
+        return STATUS_INVALID_ARGUMENT;
+    }
+    if arena.current_re.is_null()
+        || arena.current_im.is_null()
+        || momenta.values.is_null()
+        || factors.values_re.is_null()
+        || factors.values_im.is_null()
+    {
+        return STATUS_INVALID_ARGUMENT;
+    }
+
+    let context = unsafe { &*context.cast::<DirectSourceExecutorContext>() };
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        let Some(domain) = context
+            .domains
+            .get(row.source_template_or_dispatch_domain as usize)
+        else {
+            return STATUS_BOUNDS;
+        };
+        let Some(template) = domain.resolve(DirectSourceDispatchKey::SpinStateClass(
+            row.spin_state_class,
+        )) else {
+            return STATUS_BOUNDS;
+        };
+        if row.momentum_form_id >= momenta.form_count || row.exact_factor_id >= factors.value_count
+        {
+            return STATUS_BOUNDS;
+        }
+        let Some(destination_end) = u64::from(row.destination_component_base)
+            .checked_add(u64::from(template.family.component_count()))
+            .and_then(|planes| planes.checked_mul(u64::from(arena.point_stride)))
+        else {
+            return STATUS_BOUNDS;
+        };
+        if destination_end > arena.current_scalar_len {
+            return STATUS_BOUNDS;
+        }
+        let Some(momentum_end) = u64::from(row.momentum_form_id)
+            .checked_mul(4)
+            .and_then(|base| base.checked_add(4))
+            .and_then(|planes| planes.checked_mul(u64::from(momenta.point_stride)))
+        else {
+            return STATUS_BOUNDS;
+        };
+        if momentum_end > momenta.scalar_len {
+            return STATUS_BOUNDS;
+        }
+        let mass = match template.mass_parameter_index {
+            Some(index) => {
+                if index >= parameters.value_count || parameters.values_re.is_null() {
+                    return STATUS_BOUNDS;
+                }
+                unsafe { *parameters.values_re.add(index as usize) }
+            }
+            None => 0.0,
+        };
+        let factor_re = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        let factor_im = unsafe { *factors.values_im.add(row.exact_factor_id as usize) };
+
+        for point in 0..point_count {
+            let momentum = read_momentum(momenta, row.momentum_form_id, point);
+            let status = match template.family {
+                DirectSourceWavefunctionFamily::Scalar => write_wavefunction(
+                    arena,
+                    row.destination_component_base,
+                    point,
+                    factor_re,
+                    factor_im,
+                    [Complex::new(1.0, 0.0)],
+                ),
+                DirectSourceWavefunctionFamily::WeylFermion => {
+                    let wave = match template.orientation {
+                        DirectSourceOrientation::Particle => {
+                            source_wavefunctions::ext_quark_weyl_array(
+                                momentum,
+                                template.helicity,
+                                template.chirality,
+                            )
+                        }
+                        DirectSourceOrientation::Antiparticle => {
+                            source_wavefunctions::ext_antiquark_weyl_array(
+                                momentum,
+                                template.helicity,
+                                template.chirality,
+                            )
+                        }
+                        DirectSourceOrientation::SelfConjugate => {
+                            return STATUS_EXECUTION_FAILED;
+                        }
+                    };
+                    write_wavefunction(
+                        arena,
+                        row.destination_component_base,
+                        point,
+                        factor_re,
+                        factor_im,
+                        wave,
+                    )
+                }
+                DirectSourceWavefunctionFamily::DiracFermion => {
+                    let wave = match template.orientation {
+                        DirectSourceOrientation::Particle => {
+                            source_wavefunctions::ext_quark_dirac_massive(
+                                momentum,
+                                template.helicity,
+                                mass,
+                            )
+                        }
+                        DirectSourceOrientation::Antiparticle => {
+                            source_wavefunctions::ext_antiquark_dirac_massive(
+                                momentum,
+                                template.helicity,
+                                mass,
+                            )
+                        }
+                        DirectSourceOrientation::SelfConjugate => {
+                            return STATUS_EXECUTION_FAILED;
+                        }
+                    };
+                    write_wavefunction(
+                        arena,
+                        row.destination_component_base,
+                        point,
+                        factor_re,
+                        factor_im,
+                        wave,
+                    )
+                }
+                DirectSourceWavefunctionFamily::Vector => {
+                    let wave = if mass == 0.0 {
+                        source_wavefunctions::ext_gluon(momentum, template.helicity)
+                    } else {
+                        source_wavefunctions::ext_massive_vector(momentum, template.helicity, mass)
+                    };
+                    write_wavefunction(
+                        arena,
+                        row.destination_component_base,
+                        point,
+                        factor_re,
+                        factor_im,
+                        wave,
+                    )
+                }
+                DirectSourceWavefunctionFamily::Spin2 => {
+                    let Ok(wave) =
+                        source_wavefunctions::ext_spin2(momentum, template.helicity, mass)
+                    else {
+                        return STATUS_EXECUTION_FAILED;
+                    };
+                    write_wavefunction(
+                        arena,
+                        row.destination_component_base,
+                        point,
+                        factor_re,
+                        factor_im,
+                        wave,
+                    )
+                }
+            };
+            if status != DIRECT_STATUS_OK {
+                return status;
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+#[allow(clippy::too_many_arguments)]
+unsafe extern "C" fn execute_direct_union_source_rows(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectSourceRow,
+    row_count: u32,
+    variants: *const DirectSourceDispatchVariantDescriptor,
+    variant_count: u32,
+    embeddings: *const DirectSourceEmbeddingRow,
+    embedding_count: u32,
+    selections: *const DirectResolvedSourceSelection,
+    selection_count: u32,
+    point_count: u32,
+) -> c_int {
+    if context.is_null() {
+        return STATUS_INVALID_CONTEXT;
+    }
+    if rows.is_null()
+        || variants.is_null()
+        || embeddings.is_null()
+        || selections.is_null()
+        || row_count == 0
+        || variant_count == 0
+        || embedding_count == 0
+        || selection_count == 0
+        || point_count == 0
+        || arena.point_stride == 0
+        || point_count > arena.point_stride
+        || momenta.point_stride != arena.point_stride
+        || momenta.lorentz_component_count != 4
+    {
+        return STATUS_INVALID_ARGUMENT;
+    }
+    if arena.current_re.is_null()
+        || arena.current_im.is_null()
+        || momenta.values.is_null()
+        || factors.values_re.is_null()
+        || factors.values_im.is_null()
+    {
+        return STATUS_INVALID_ARGUMENT;
+    }
+
+    let context = unsafe { &*context.cast::<DirectSourceExecutorContext>() };
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    let variants = unsafe { std::slice::from_raw_parts(variants, variant_count as usize) };
+    let embeddings = unsafe { std::slice::from_raw_parts(embeddings, embedding_count as usize) };
+    let selections = unsafe { std::slice::from_raw_parts(selections, selection_count as usize) };
+
+    for (source_slot, selection) in selections.iter().enumerate() {
+        if selection.source_slot != source_slot as u32 {
+            return STATUS_INVALID_ARGUMENT;
+        }
+        let Some(variant) = variants.get(selection.dispatch_variant_id as usize) else {
+            return STATUS_BOUNDS;
+        };
+        let Some(row) = rows.get(variant.source_row_id as usize) else {
+            return STATUS_BOUNDS;
+        };
+        if row.source_slot != selection.source_slot
+            || row.source_template_or_dispatch_domain != variant.dispatch_domain_id
+            || row.momentum_form_id >= momenta.form_count
+            || row.exact_factor_id >= factors.value_count
+            || variant.crossing_exact_factor_id >= factors.value_count
+        {
+            return STATUS_BOUNDS;
+        }
+        // Union source rows are only structural destinations. Crossing and
+        // embedding own the complete source factorization.
+        let row_factor_re = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        let row_factor_im = unsafe { *factors.values_im.add(row.exact_factor_id as usize) };
+        if row_factor_re != 1.0 || row_factor_im != 0.0 {
+            return STATUS_EXECUTION_FAILED;
+        }
+
+        let Some(domain) = context.domains.get(variant.dispatch_domain_id as usize) else {
+            return STATUS_BOUNDS;
+        };
+        let Some(template) = domain.resolve(DirectSourceDispatchKey::RuntimeVariant {
+            source_row_id: variant.source_row_id,
+            runtime_variant_id: variant.runtime_variant_id,
+        }) else {
+            return STATUS_BOUNDS;
+        };
+        if template.spin_state_class != variant.crossed_spin_state_class {
+            return STATUS_EXECUTION_FAILED;
+        }
+        if u32::from(template.family.component_count()) != variant.projection_count {
+            return STATUS_EXECUTION_FAILED;
+        }
+
+        let Some(embedding_end) = variant
+            .embedding_start
+            .checked_add(u64::from(variant.embedding_count))
+        else {
+            return STATUS_BOUNDS;
+        };
+        if embedding_end > embedding_count as u64 {
+            return STATUS_BOUNDS;
+        }
+        let embedding_start = variant.embedding_start as usize;
+        let embedding_end = embedding_end as usize;
+        let variant_embeddings = &embeddings[embedding_start..embedding_end];
+        let Some(destination_end) = u64::from(row.destination_component_base)
+            .checked_add(u64::from(variant.embedding_count))
+            .and_then(|planes| planes.checked_mul(u64::from(arena.point_stride)))
+        else {
+            return STATUS_BOUNDS;
+        };
+        if destination_end > arena.current_scalar_len {
+            return STATUS_BOUNDS;
+        }
+        let Some(momentum_end) = u64::from(row.momentum_form_id)
+            .checked_mul(4)
+            .and_then(|base| base.checked_add(4))
+            .and_then(|planes| planes.checked_mul(u64::from(momenta.point_stride)))
+        else {
+            return STATUS_BOUNDS;
+        };
+        if momentum_end > momenta.scalar_len {
+            return STATUS_BOUNDS;
+        }
+        let mass = match template.mass_parameter_index {
+            Some(index) => {
+                if index >= parameters.value_count || parameters.values_re.is_null() {
+                    return STATUS_BOUNDS;
+                }
+                unsafe { *parameters.values_re.add(index as usize) }
+            }
+            None => 0.0,
+        };
+        let crossing_re = unsafe {
+            *factors
+                .values_re
+                .add(variant.crossing_exact_factor_id as usize)
+        };
+        let crossing_im = unsafe {
+            *factors
+                .values_im
+                .add(variant.crossing_exact_factor_id as usize)
+        };
+
+        for point in 0..point_count {
+            let momentum = read_momentum(momenta, row.momentum_form_id, point);
+            let status = match template.family {
+                DirectSourceWavefunctionFamily::Scalar => write_embedded_wavefunction(
+                    arena,
+                    row.destination_component_base,
+                    point,
+                    crossing_re,
+                    crossing_im,
+                    [Complex::new(1.0, 0.0)],
+                    variant_embeddings,
+                    factors,
+                ),
+                DirectSourceWavefunctionFamily::WeylFermion => {
+                    let wave = match template.orientation {
+                        DirectSourceOrientation::Particle => {
+                            source_wavefunctions::ext_quark_weyl_array(
+                                momentum,
+                                template.helicity,
+                                template.chirality,
+                            )
+                        }
+                        DirectSourceOrientation::Antiparticle => {
+                            source_wavefunctions::ext_antiquark_weyl_array(
+                                momentum,
+                                template.helicity,
+                                template.chirality,
+                            )
+                        }
+                        DirectSourceOrientation::SelfConjugate => {
+                            return STATUS_EXECUTION_FAILED;
+                        }
+                    };
+                    write_embedded_wavefunction(
+                        arena,
+                        row.destination_component_base,
+                        point,
+                        crossing_re,
+                        crossing_im,
+                        wave,
+                        variant_embeddings,
+                        factors,
+                    )
+                }
+                DirectSourceWavefunctionFamily::DiracFermion => {
+                    let wave = match template.orientation {
+                        DirectSourceOrientation::Particle => {
+                            source_wavefunctions::ext_quark_dirac_massive(
+                                momentum,
+                                template.helicity,
+                                mass,
+                            )
+                        }
+                        DirectSourceOrientation::Antiparticle => {
+                            source_wavefunctions::ext_antiquark_dirac_massive(
+                                momentum,
+                                template.helicity,
+                                mass,
+                            )
+                        }
+                        DirectSourceOrientation::SelfConjugate => {
+                            return STATUS_EXECUTION_FAILED;
+                        }
+                    };
+                    write_embedded_wavefunction(
+                        arena,
+                        row.destination_component_base,
+                        point,
+                        crossing_re,
+                        crossing_im,
+                        wave,
+                        variant_embeddings,
+                        factors,
+                    )
+                }
+                DirectSourceWavefunctionFamily::Vector => {
+                    let wave = if mass == 0.0 {
+                        source_wavefunctions::ext_gluon(momentum, template.helicity)
+                    } else {
+                        source_wavefunctions::ext_massive_vector(momentum, template.helicity, mass)
+                    };
+                    write_embedded_wavefunction(
+                        arena,
+                        row.destination_component_base,
+                        point,
+                        crossing_re,
+                        crossing_im,
+                        wave,
+                        variant_embeddings,
+                        factors,
+                    )
+                }
+                DirectSourceWavefunctionFamily::Spin2 => {
+                    let Ok(wave) =
+                        source_wavefunctions::ext_spin2(momentum, template.helicity, mass)
+                    else {
+                        return STATUS_EXECUTION_FAILED;
+                    };
+                    write_embedded_wavefunction(
+                        arena,
+                        row.destination_component_base,
+                        point,
+                        crossing_re,
+                        crossing_im,
+                        wave,
+                        variant_embeddings,
+                        factors,
+                    )
+                }
+            };
+            if status != DIRECT_STATUS_OK {
+                return status;
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+fn read_momentum(momenta: DirectMomentumView, form: u32, point: u32) -> [f64; 4] {
+    std::array::from_fn(|component| {
+        let plane = form as usize * 4 + component;
+        let offset = plane * momenta.point_stride as usize + point as usize;
+        unsafe { *momenta.values.add(offset) }
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn write_wavefunction<const N: usize>(
+    arena: DirectArenaView,
+    destination_component_base: u32,
+    point: u32,
+    factor_re: f64,
+    factor_im: f64,
+    wave: [Complex<f64>; N],
+) -> c_int {
+    for (component, value) in wave.into_iter().enumerate() {
+        let Some(plane) = (destination_component_base as usize).checked_add(component) else {
+            return STATUS_BOUNDS;
+        };
+        let Some(offset) = plane
+            .checked_mul(arena.point_stride as usize)
+            .and_then(|base| base.checked_add(point as usize))
+        else {
+            return STATUS_BOUNDS;
+        };
+        if offset >= arena.current_scalar_len as usize {
+            return STATUS_BOUNDS;
+        }
+        unsafe {
+            *arena.current_re.add(offset) = factor_re * value.re - factor_im * value.im;
+            *arena.current_im.add(offset) = factor_re * value.im + factor_im * value.re;
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+#[allow(clippy::too_many_arguments)]
+fn write_embedded_wavefunction<const N: usize>(
+    arena: DirectArenaView,
+    destination_component_base: u32,
+    point: u32,
+    crossing_re: f64,
+    crossing_im: f64,
+    wave: [Complex<f64>; N],
+    embeddings: &[DirectSourceEmbeddingRow],
+    factors: DirectFactorView,
+) -> c_int {
+    for (full_component, embedding) in embeddings.iter().enumerate() {
+        if embedding.full_component != full_component as u32
+            || embedding.exact_factor_id >= factors.value_count
+        {
+            return STATUS_BOUNDS;
+        }
+        let Some(plane) = (destination_component_base as usize).checked_add(full_component) else {
+            return STATUS_BOUNDS;
+        };
+        let Some(offset) = plane
+            .checked_mul(arena.point_stride as usize)
+            .and_then(|base| base.checked_add(point as usize))
+        else {
+            return STATUS_BOUNDS;
+        };
+        if offset >= arena.current_scalar_len as usize {
+            return STATUS_BOUNDS;
+        }
+
+        let (value_re, value_im) = if embedding.source_component_or_sentinel == DIRECT_NONE_U32 {
+            (0.0, 0.0)
+        } else {
+            let Some(value) = wave.get(embedding.source_component_or_sentinel as usize) else {
+                return STATUS_BOUNDS;
+            };
+            let embedding_re =
+                unsafe { *factors.values_re.add(embedding.exact_factor_id as usize) };
+            let embedding_im =
+                unsafe { *factors.values_im.add(embedding.exact_factor_id as usize) };
+            let scale_re = crossing_re * embedding_re - crossing_im * embedding_im;
+            let scale_im = crossing_re * embedding_im + crossing_im * embedding_re;
+            (
+                scale_re * value.re - scale_im * value.im,
+                scale_re * value.im + scale_im * value.re,
+            )
+        };
+        unsafe {
+            *arena.current_re.add(offset) = value_re;
+            *arena.current_im.add(offset) = value_im;
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+/// Write one cold-authenticated embedded source without revisiting component,
+/// factor, or arena bounds.  `LoadedBoundUnionSourceProgram::execute` checks
+/// the dynamic view shape once, while `bind_union_program` proves every
+/// component index and precombines the immutable exact scales.
+unsafe fn write_bound_embedded_wavefunction<const N: usize>(
+    arena: DirectArenaView,
+    destination_component_base: u32,
+    point: u32,
+    wave: [Complex<f64>; N],
+    embeddings: &[BoundUnionSourceEmbedding],
+) {
+    let stride = arena.point_stride as usize;
+    for (full_component, embedding) in embeddings.iter().copied().enumerate() {
+        let plane = destination_component_base as usize + full_component;
+        let offset = plane * stride + point as usize;
+        let (value_re, value_im) = if embedding.source_component_or_sentinel == DIRECT_NONE_U32 {
+            (0.0, 0.0)
+        } else {
+            let value =
+                unsafe { wave.get_unchecked(embedding.source_component_or_sentinel as usize) };
+            (
+                embedding.scale_re * value.re - embedding.scale_im * value.im,
+                embedding.scale_re * value.im + embedding.scale_im * value.re,
+            )
+        };
+        unsafe {
+            *arena.current_re.add(offset) = value_re;
+            *arena.current_im.add(offset) = value_im;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::ExactRational;
+    use crate::recurrence::direct_backend::{
+        DirectArenaView, DirectFactorView, DirectMomentumView, DirectParameterView,
+    };
+
+    fn domain(variant: DirectSourceTemplateSpec) -> DirectSourceDispatchDomainSpec {
+        DirectSourceDispatchDomainSpec {
+            variants: vec![DirectSourceDispatchVariantSpec {
+                key: DirectSourceDispatchKey::SpinStateClass(variant.spin_state_class),
+                template: variant,
+            }],
+        }
+    }
+
+    fn runtime_domain(
+        variants: impl IntoIterator<Item = (u32, DirectSourceTemplateSpec)>,
+    ) -> DirectSourceDispatchDomainSpec {
+        DirectSourceDispatchDomainSpec {
+            variants: variants
+                .into_iter()
+                .map(
+                    |(runtime_variant_id, template)| DirectSourceDispatchVariantSpec {
+                        key: DirectSourceDispatchKey::RuntimeVariant {
+                            source_row_id: 0,
+                            runtime_variant_id,
+                        },
+                        template,
+                    },
+                )
+                .collect(),
+        }
+    }
+
+    fn source_row(
+        domain: u32,
+        spin_state_class: i32,
+        destination_component_base: u32,
+        momentum_form_id: u32,
+        exact_factor_id: u32,
+    ) -> DirectSourceRow {
+        DirectSourceRow {
+            source_slot: domain,
+            destination_component_base,
+            momentum_form_id,
+            source_template_or_dispatch_domain: domain,
+            spin_state_class,
+            exact_factor_id,
+            selector_domain_id: 0,
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn invoke(
+        executor: &LoadedDirectSourceExecutor,
+        rows: &[DirectSourceRow],
+        current_re: &mut [f64],
+        current_im: &mut [f64],
+        momenta: &[f64],
+        momentum_forms: u32,
+        parameters: &[f64],
+        factors_re: &[f64],
+        factors_im: &[f64],
+        point_stride: u32,
+        point_count: u32,
+    ) -> c_int {
+        let handle = executor.handle();
+        let mut amplitude_re = [0.0];
+        let mut amplitude_im = [0.0];
+        unsafe {
+            (handle.call)(
+                handle.context,
+                DirectArenaView {
+                    current_re: current_re.as_mut_ptr(),
+                    current_im: current_im.as_mut_ptr(),
+                    current_scalar_len: current_re.len() as u64,
+                    amplitude_re: amplitude_re.as_mut_ptr(),
+                    amplitude_im: amplitude_im.as_mut_ptr(),
+                    amplitude_scalar_len: 1,
+                    point_stride,
+                },
+                DirectMomentumView {
+                    values: momenta.as_ptr(),
+                    scalar_len: momenta.len() as u64,
+                    form_count: momentum_forms,
+                    lorentz_component_count: 4,
+                    point_stride,
+                },
+                DirectParameterView {
+                    values_re: parameters.as_ptr(),
+                    values_im: ptr::null(),
+                    value_count: parameters.len() as u32,
+                },
+                DirectFactorView {
+                    values_re: factors_re.as_ptr(),
+                    values_im: factors_im.as_ptr(),
+                    value_count: factors_re.len() as u32,
+                },
+                rows.as_ptr(),
+                rows.len() as u32,
+                point_count,
+            )
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn invoke_union(
+        executor: &LoadedDirectSourceExecutor,
+        rows: &[DirectSourceRow],
+        variants: &[DirectSourceDispatchVariantDescriptor],
+        embeddings: &[DirectSourceEmbeddingRow],
+        selections: &[DirectResolvedSourceSelection],
+        current_re: &mut [f64],
+        current_im: &mut [f64],
+        momenta: &[f64],
+        momentum_forms: u32,
+        parameters: &[f64],
+        factors_re: &[f64],
+        factors_im: &[f64],
+        point_stride: u32,
+        point_count: u32,
+    ) -> c_int {
+        let handle = executor.union_handle();
+        let mut amplitude_re = [0.0];
+        let mut amplitude_im = [0.0];
+        unsafe {
+            (handle.call)(
+                handle.context,
+                DirectArenaView {
+                    current_re: current_re.as_mut_ptr(),
+                    current_im: current_im.as_mut_ptr(),
+                    current_scalar_len: current_re.len() as u64,
+                    amplitude_re: amplitude_re.as_mut_ptr(),
+                    amplitude_im: amplitude_im.as_mut_ptr(),
+                    amplitude_scalar_len: 1,
+                    point_stride,
+                },
+                DirectMomentumView {
+                    values: momenta.as_ptr(),
+                    scalar_len: momenta.len() as u64,
+                    form_count: momentum_forms,
+                    lorentz_component_count: 4,
+                    point_stride,
+                },
+                DirectParameterView {
+                    values_re: parameters.as_ptr(),
+                    values_im: ptr::null(),
+                    value_count: parameters.len() as u32,
+                },
+                DirectFactorView {
+                    values_re: factors_re.as_ptr(),
+                    values_im: factors_im.as_ptr(),
+                    value_count: factors_re.len() as u32,
+                },
+                rows.as_ptr(),
+                rows.len() as u32,
+                variants.as_ptr(),
+                variants.len() as u32,
+                embeddings.as_ptr(),
+                embeddings.len() as u32,
+                selections.as_ptr(),
+                selections.len() as u32,
+                point_count,
+            )
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn invoke_bound_union(
+        executor: &LoadedDirectSourceExecutor,
+        rows: &[DirectSourceRow],
+        variants: &[DirectSourceDispatchVariantDescriptor],
+        embeddings: &[DirectSourceEmbeddingRow],
+        selections: &[DirectResolvedSourceSelection],
+        exact_factors: &[ExactComplexRational],
+        current_re: &mut [f64],
+        current_im: &mut [f64],
+        momenta: &[f64],
+        momentum_forms: u32,
+        parameters: &[f64],
+        point_stride: u32,
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        let program = executor.bind_union_program(OnTheFlyUnionSourceBindingView {
+            sources: rows,
+            variants,
+            embeddings,
+            selections,
+            exact_factors,
+            current_component_count: u32::try_from(current_re.len() / point_stride as usize)
+                .unwrap(),
+            momentum_form_count: momentum_forms,
+            parameter_count: parameters.len() as u32,
+        })?;
+        let mut amplitude_re = [0.0];
+        let mut amplitude_im = [0.0];
+        unsafe {
+            program.execute(
+                DirectArenaView {
+                    current_re: current_re.as_mut_ptr(),
+                    current_im: current_im.as_mut_ptr(),
+                    current_scalar_len: current_re.len() as u64,
+                    amplitude_re: amplitude_re.as_mut_ptr(),
+                    amplitude_im: amplitude_im.as_mut_ptr(),
+                    amplitude_scalar_len: 1,
+                    point_stride,
+                },
+                DirectMomentumView {
+                    values: momenta.as_ptr(),
+                    scalar_len: momenta.len() as u64,
+                    form_count: momentum_forms,
+                    lorentz_component_count: 4,
+                    point_stride,
+                },
+                DirectParameterView {
+                    values_re: parameters.as_ptr(),
+                    values_im: parameters.as_ptr(),
+                    value_count: parameters.len() as u32,
+                },
+                point_count,
+            )
+        }
+    }
+
+    fn exact_union_factors() -> [ExactComplexRational; 4] {
+        [
+            ExactComplexRational::ONE,
+            ExactComplexRational::new(ExactRational::ZERO, ExactRational::ONE),
+            ExactComplexRational::new(ExactRational::new(2, 1).unwrap(), ExactRational::ZERO),
+            ExactComplexRational::ZERO,
+        ]
+    }
+
+    #[test]
+    fn scalar_source_writes_exact_complex_factor_directly_into_arena() {
+        let executor = LoadedDirectSourceExecutor::load(vec![domain(DirectSourceTemplateSpec {
+            spin_state_class: 0,
+            family: DirectSourceWavefunctionFamily::Scalar,
+            orientation: DirectSourceOrientation::SelfConjugate,
+            helicity: 0,
+            chirality: 0,
+            mass_parameter_index: None,
+        })])
+        .unwrap();
+        let rows = [source_row(0, 0, 0, 0, 0)];
+        let mut current_re = [99.0, 99.0];
+        let mut current_im = [99.0, 99.0];
+        let momenta = [10.0, 11.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
+        assert_eq!(
+            invoke(
+                &executor,
+                &rows,
+                &mut current_re,
+                &mut current_im,
+                &momenta,
+                1,
+                &[],
+                &[2.0],
+                &[-3.0],
+                2,
+                2,
+            ),
+            DIRECT_STATUS_OK
+        );
+        assert_eq!(current_re, [2.0, 2.0]);
+        assert_eq!(current_im, [-3.0, -3.0]);
+    }
+
+    #[test]
+    fn vector_source_matches_established_source_ir_formula_for_every_point() {
+        let executor = LoadedDirectSourceExecutor::load(vec![domain(DirectSourceTemplateSpec {
+            spin_state_class: 1,
+            family: DirectSourceWavefunctionFamily::Vector,
+            orientation: DirectSourceOrientation::SelfConjugate,
+            helicity: 1,
+            chirality: 0,
+            mass_parameter_index: None,
+        })])
+        .unwrap();
+        let rows = [source_row(0, 1, 0, 0, 0)];
+        let points = [
+            [100.0, 30.0, 40.0, 86.60254037844386],
+            [-120.0, -20.0, 50.0, -107.23805294763608],
+        ];
+        let momenta = [
+            points[0][0],
+            points[1][0],
+            points[0][1],
+            points[1][1],
+            points[0][2],
+            points[1][2],
+            points[0][3],
+            points[1][3],
+        ];
+        let mut current_re = [0.0; 8];
+        let mut current_im = [0.0; 8];
+        assert_eq!(
+            invoke(
+                &executor,
+                &rows,
+                &mut current_re,
+                &mut current_im,
+                &momenta,
+                1,
+                &[],
+                &[1.0],
+                &[0.0],
+                2,
+                2,
+            ),
+            DIRECT_STATUS_OK
+        );
+        for (point_index, point) in points.into_iter().enumerate() {
+            let expected = source_wavefunctions::ext_gluon(point, 1);
+            for (component, value) in expected.into_iter().enumerate() {
+                let offset = component * 2 + point_index;
+                assert_eq!(current_re[offset], value.re);
+                assert_eq!(current_im[offset], value.im);
+            }
+        }
+    }
+
+    #[test]
+    fn dispatch_domains_select_crossed_fermion_state_without_packing() {
+        let executor = LoadedDirectSourceExecutor::load(vec![DirectSourceDispatchDomainSpec {
+            variants: vec![
+                DirectSourceDispatchVariantSpec {
+                    key: DirectSourceDispatchKey::SpinStateClass(1),
+                    template: DirectSourceTemplateSpec {
+                        spin_state_class: 1,
+                        family: DirectSourceWavefunctionFamily::WeylFermion,
+                        orientation: DirectSourceOrientation::Particle,
+                        helicity: 1,
+                        chirality: 1,
+                        mass_parameter_index: None,
+                    },
+                },
+                DirectSourceDispatchVariantSpec {
+                    key: DirectSourceDispatchKey::SpinStateClass(-1),
+                    template: DirectSourceTemplateSpec {
+                        spin_state_class: -1,
+                        family: DirectSourceWavefunctionFamily::WeylFermion,
+                        orientation: DirectSourceOrientation::Antiparticle,
+                        helicity: -1,
+                        chirality: -1,
+                        mass_parameter_index: None,
+                    },
+                },
+            ],
+        }])
+        .unwrap();
+        let rows = [source_row(0, -1, 0, 0, 0)];
+        let momentum = [-50.0, -10.0, -20.0, -44.721359549995796];
+        let momenta = [momentum[0], momentum[1], momentum[2], momentum[3]];
+        let mut current_re = [0.0; 2];
+        let mut current_im = [0.0; 2];
+        assert_eq!(
+            invoke(
+                &executor,
+                &rows,
+                &mut current_re,
+                &mut current_im,
+                &momenta,
+                1,
+                &[],
+                &[0.0],
+                &[1.0],
+                1,
+                1,
+            ),
+            DIRECT_STATUS_OK
+        );
+        let expected = source_wavefunctions::ext_antiquark_weyl_array(momentum, -1, -1);
+        for (component, value) in expected.into_iter().enumerate() {
+            assert_eq!(current_re[component], -value.im);
+            assert_eq!(current_im[component], value.re);
+        }
+    }
+
+    #[test]
+    fn runtime_variants_preserve_distinct_source_semantics_for_one_spin_class() {
+        let particle = DirectSourceTemplateSpec {
+            spin_state_class: 1,
+            family: DirectSourceWavefunctionFamily::WeylFermion,
+            orientation: DirectSourceOrientation::Particle,
+            helicity: 1,
+            chirality: 1,
+            mass_parameter_index: None,
+        };
+        let antiparticle = DirectSourceTemplateSpec {
+            orientation: DirectSourceOrientation::Antiparticle,
+            ..particle
+        };
+        let executor = LoadedDirectSourceExecutor::load(vec![runtime_domain([
+            (3, particle),
+            (7, antiparticle),
+        ])])
+        .expect("runtime variant identity must distinguish equal spin classes");
+        let domain = &executor.context.domains[0];
+
+        assert_eq!(
+            domain
+                .resolve(DirectSourceDispatchKey::RuntimeVariant {
+                    source_row_id: 0,
+                    runtime_variant_id: 3,
+                })
+                .expect("particle runtime variant")
+                .orientation,
+            DirectSourceOrientation::Particle
+        );
+        assert_eq!(
+            domain
+                .resolve(DirectSourceDispatchKey::RuntimeVariant {
+                    source_row_id: 0,
+                    runtime_variant_id: 7,
+                })
+                .expect("antiparticle runtime variant")
+                .orientation,
+            DirectSourceOrientation::Antiparticle
+        );
+        assert!(
+            domain
+                .resolve(DirectSourceDispatchKey::SpinStateClass(1))
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn runtime_variants_distinguish_crossed_source_rows_in_one_contract() {
+        let incoming = DirectSourceTemplateSpec {
+            spin_state_class: -1,
+            family: DirectSourceWavefunctionFamily::Vector,
+            orientation: DirectSourceOrientation::SelfConjugate,
+            helicity: -1,
+            chirality: 0,
+            mass_parameter_index: None,
+        };
+        let outgoing = DirectSourceTemplateSpec {
+            spin_state_class: 1,
+            helicity: 1,
+            ..incoming
+        };
+        let executor = LoadedDirectSourceExecutor::load(vec![DirectSourceDispatchDomainSpec {
+            variants: vec![
+                DirectSourceDispatchVariantSpec {
+                    key: DirectSourceDispatchKey::RuntimeVariant {
+                        source_row_id: 0,
+                        runtime_variant_id: 3,
+                    },
+                    template: incoming,
+                },
+                DirectSourceDispatchVariantSpec {
+                    key: DirectSourceDispatchKey::RuntimeVariant {
+                        source_row_id: 2,
+                        runtime_variant_id: 3,
+                    },
+                    template: outgoing,
+                },
+            ],
+        }])
+        .expect("one runtime variant may have distinct crossed source-row semantics");
+        let domain = &executor.context.domains[0];
+
+        assert_eq!(
+            domain
+                .resolve(DirectSourceDispatchKey::RuntimeVariant {
+                    source_row_id: 0,
+                    runtime_variant_id: 3,
+                })
+                .expect("incoming source row"),
+            incoming
+        );
+        assert_eq!(
+            domain
+                .resolve(DirectSourceDispatchKey::RuntimeVariant {
+                    source_row_id: 2,
+                    runtime_variant_id: 3,
+                })
+                .expect("outgoing source row"),
+            outgoing
+        );
+    }
+
+    #[test]
+    fn every_supported_source_ir_spin_family_executes_from_persistent_views() {
+        let specs = [
+            DirectSourceTemplateSpec {
+                spin_state_class: 0,
+                family: DirectSourceWavefunctionFamily::Scalar,
+                orientation: DirectSourceOrientation::SelfConjugate,
+                helicity: 0,
+                chirality: 0,
+                mass_parameter_index: None,
+            },
+            DirectSourceTemplateSpec {
+                spin_state_class: 1,
+                family: DirectSourceWavefunctionFamily::WeylFermion,
+                orientation: DirectSourceOrientation::Particle,
+                helicity: 1,
+                chirality: 1,
+                mass_parameter_index: None,
+            },
+            DirectSourceTemplateSpec {
+                spin_state_class: 2,
+                family: DirectSourceWavefunctionFamily::DiracFermion,
+                orientation: DirectSourceOrientation::Antiparticle,
+                helicity: -1,
+                chirality: 0,
+                mass_parameter_index: Some(0),
+            },
+            DirectSourceTemplateSpec {
+                spin_state_class: 3,
+                family: DirectSourceWavefunctionFamily::Vector,
+                orientation: DirectSourceOrientation::SelfConjugate,
+                helicity: 0,
+                chirality: 0,
+                mass_parameter_index: Some(1),
+            },
+            DirectSourceTemplateSpec {
+                spin_state_class: 4,
+                family: DirectSourceWavefunctionFamily::Spin2,
+                orientation: DirectSourceOrientation::SelfConjugate,
+                helicity: 2,
+                chirality: 0,
+                mass_parameter_index: Some(2),
+            },
+        ];
+        let executor =
+            LoadedDirectSourceExecutor::load(specs.into_iter().map(domain).collect()).unwrap();
+        let bases = [0, 1, 3, 7, 11];
+        let rows: Vec<_> = specs
+            .into_iter()
+            .enumerate()
+            .map(|(index, spec)| {
+                source_row(index as u32, spec.spin_state_class, bases[index], 0, 0)
+            })
+            .collect();
+        let momenta = [20.0, 3.0, 4.0, 19.364916731037084];
+        let mut current_re = [0.0; 27];
+        let mut current_im = [0.0; 27];
+        assert_eq!(
+            invoke(
+                &executor,
+                &rows,
+                &mut current_re,
+                &mut current_im,
+                &momenta,
+                1,
+                &[2.0, 5.0, 7.0],
+                &[1.0],
+                &[0.0],
+                1,
+                1,
+            ),
+            DIRECT_STATUS_OK
+        );
+        assert!(
+            current_re
+                .iter()
+                .chain(&current_im)
+                .all(|value| value.is_finite())
+        );
+        assert!(
+            current_re
+                .iter()
+                .chain(&current_im)
+                .any(|value| *value != 0.0)
+        );
+    }
+
+    #[test]
+    fn source_handle_owns_stable_context_and_repeated_calls_allocate_no_scratch() {
+        let executor = LoadedDirectSourceExecutor::load(vec![domain(DirectSourceTemplateSpec {
+            spin_state_class: 0,
+            family: DirectSourceWavefunctionFamily::Scalar,
+            orientation: DirectSourceOrientation::SelfConjugate,
+            helicity: 0,
+            chirality: 0,
+            mass_parameter_index: None,
+        })])
+        .unwrap();
+        let first = executor.handle();
+        let second = executor.handle();
+        assert_eq!(first.context, second.context);
+        assert_eq!(first.call as usize, second.call as usize);
+
+        let rows = [source_row(0, 0, 0, 0, 0)];
+        let momenta = [1.0, 0.0, 0.0, 1.0];
+        let mut current_re = [0.0];
+        let mut current_im = [0.0];
+        for _ in 0..32 {
+            assert_eq!(
+                invoke(
+                    &executor,
+                    &rows,
+                    &mut current_re,
+                    &mut current_im,
+                    &momenta,
+                    1,
+                    &[],
+                    &[1.0],
+                    &[0.0],
+                    1,
+                    1,
+                ),
+                DIRECT_STATUS_OK
+            );
+        }
+        assert_eq!(current_re, [1.0]);
+        assert_eq!(current_im, [0.0]);
+    }
+
+    #[test]
+    fn malformed_domains_and_views_fail_before_arena_mutation() {
+        let duplicate = DirectSourceTemplateSpec {
+            spin_state_class: 1,
+            family: DirectSourceWavefunctionFamily::Scalar,
+            orientation: DirectSourceOrientation::SelfConjugate,
+            helicity: 0,
+            chirality: 0,
+            mass_parameter_index: None,
+        };
+        assert!(
+            LoadedDirectSourceExecutor::load(vec![DirectSourceDispatchDomainSpec {
+                variants: vec![
+                    DirectSourceDispatchVariantSpec {
+                        key: DirectSourceDispatchKey::SpinStateClass(1),
+                        template: duplicate,
+                    },
+                    DirectSourceDispatchVariantSpec {
+                        key: DirectSourceDispatchKey::SpinStateClass(1),
+                        template: duplicate,
+                    },
+                ],
+            }])
+            .is_err()
+        );
+
+        let executor = LoadedDirectSourceExecutor::load(vec![domain(duplicate)]).unwrap();
+        let rows = [source_row(0, 99, 0, 0, 0)];
+        let mut current_re = [17.0];
+        let mut current_im = [19.0];
+        assert_eq!(
+            invoke(
+                &executor,
+                &rows,
+                &mut current_re,
+                &mut current_im,
+                &[1.0, 0.0, 0.0, 1.0],
+                1,
+                &[],
+                &[1.0],
+                &[0.0],
+                1,
+                1,
+            ),
+            STATUS_BOUNDS
+        );
+        assert_eq!(current_re, [17.0]);
+        assert_eq!(current_im, [19.0]);
+    }
+
+    #[test]
+    fn union_dispatch_embeds_weyl_source_into_full_state_and_zeros_inactive_components() {
+        let executor = LoadedDirectSourceExecutor::load(vec![runtime_domain([(
+            0,
+            DirectSourceTemplateSpec {
+                spin_state_class: 1,
+                family: DirectSourceWavefunctionFamily::WeylFermion,
+                orientation: DirectSourceOrientation::Particle,
+                helicity: 1,
+                chirality: 1,
+                mass_parameter_index: None,
+            },
+        )])])
+        .unwrap();
+        let rows = [source_row(0, 0, 0, 0, 0)];
+        let variants = [DirectSourceDispatchVariantDescriptor {
+            embedding_start: 0,
+            projection_start: 0,
+            source_row_id: 0,
+            dispatch_domain_id: 0,
+            runtime_variant_id: 0,
+            source_state_index: 0,
+            source_template_id: 0,
+            source_state_template_id: 0,
+            crossed_state_template_id: 0,
+            crossed_spin_state_class: 1,
+            direct_executor_id: 0,
+            crossing_exact_factor_id: 1,
+            embedding_count: 4,
+            projection_count: 2,
+        }];
+        let embeddings = [
+            DirectSourceEmbeddingRow {
+                full_component: 0,
+                source_component_or_sentinel: 0,
+                exact_factor_id: 2,
+            },
+            DirectSourceEmbeddingRow {
+                full_component: 1,
+                source_component_or_sentinel: DIRECT_NONE_U32,
+                exact_factor_id: 3,
+            },
+            DirectSourceEmbeddingRow {
+                full_component: 2,
+                source_component_or_sentinel: 1,
+                exact_factor_id: 0,
+            },
+            DirectSourceEmbeddingRow {
+                full_component: 3,
+                source_component_or_sentinel: DIRECT_NONE_U32,
+                exact_factor_id: 3,
+            },
+        ];
+        let selections = [DirectResolvedSourceSelection {
+            source_slot: 0,
+            dispatch_variant_id: 0,
+        }];
+        let momentum = [50.0, 10.0, 20.0, 44.721359549995796];
+        let mut current_re = [99.0; 4];
+        let mut current_im = [-99.0; 4];
+        let factors_re = [1.0, 0.0, 2.0, 0.0];
+        let factors_im = [0.0, 1.0, 0.0, 0.0];
+        assert_eq!(
+            invoke_union(
+                &executor,
+                &rows,
+                &variants,
+                &embeddings,
+                &selections,
+                &mut current_re,
+                &mut current_im,
+                &momentum,
+                1,
+                &[],
+                &factors_re,
+                &factors_im,
+                1,
+                1,
+            ),
+            DIRECT_STATUS_OK
+        );
+        let wave = source_wavefunctions::ext_quark_weyl_array(momentum, 1, 1);
+        assert_eq!(current_re[0], -2.0 * wave[0].im);
+        assert_eq!(current_im[0], 2.0 * wave[0].re);
+        assert_eq!((current_re[1], current_im[1]), (0.0, 0.0));
+        assert_eq!(current_re[2], -wave[1].im);
+        assert_eq!(current_im[2], wave[1].re);
+        assert_eq!((current_re[3], current_im[3]), (0.0, 0.0));
+
+        current_re.fill(123.0);
+        current_im.fill(456.0);
+        assert_eq!(
+            invoke_union(
+                &executor,
+                &rows,
+                &variants,
+                &embeddings,
+                &selections,
+                &mut current_re,
+                &mut current_im,
+                &momentum,
+                1,
+                &[],
+                &factors_re,
+                &factors_im,
+                1,
+                1,
+            ),
+            DIRECT_STATUS_OK
+        );
+        assert_eq!((current_re[1], current_im[1]), (0.0, 0.0));
+        assert_eq!((current_re[3], current_im[3]), (0.0, 0.0));
+    }
+
+    #[test]
+    fn cold_bound_union_source_is_bitwise_equal_to_the_authenticated_legacy_dispatch() {
+        let executor = LoadedDirectSourceExecutor::load(vec![runtime_domain([(
+            0,
+            DirectSourceTemplateSpec {
+                spin_state_class: 1,
+                family: DirectSourceWavefunctionFamily::WeylFermion,
+                orientation: DirectSourceOrientation::Particle,
+                helicity: 1,
+                chirality: 1,
+                mass_parameter_index: None,
+            },
+        )])])
+        .unwrap();
+        let rows = [source_row(0, 0, 0, 0, 0)];
+        let variants = [DirectSourceDispatchVariantDescriptor {
+            embedding_start: 0,
+            projection_start: 0,
+            source_row_id: 0,
+            dispatch_domain_id: 0,
+            runtime_variant_id: 0,
+            source_state_index: 0,
+            source_template_id: 0,
+            source_state_template_id: 0,
+            crossed_state_template_id: 0,
+            crossed_spin_state_class: 1,
+            direct_executor_id: 0,
+            crossing_exact_factor_id: 1,
+            embedding_count: 4,
+            projection_count: 2,
+        }];
+        let embeddings = [
+            DirectSourceEmbeddingRow {
+                full_component: 0,
+                source_component_or_sentinel: 0,
+                exact_factor_id: 2,
+            },
+            DirectSourceEmbeddingRow {
+                full_component: 1,
+                source_component_or_sentinel: DIRECT_NONE_U32,
+                exact_factor_id: 3,
+            },
+            DirectSourceEmbeddingRow {
+                full_component: 2,
+                source_component_or_sentinel: 1,
+                exact_factor_id: 0,
+            },
+            DirectSourceEmbeddingRow {
+                full_component: 3,
+                source_component_or_sentinel: DIRECT_NONE_U32,
+                exact_factor_id: 3,
+            },
+        ];
+        let selections = [DirectResolvedSourceSelection {
+            source_slot: 0,
+            dispatch_variant_id: 0,
+        }];
+        let momentum = [50.0, 10.0, 20.0, 44.721359549995796];
+        let factors_re = [1.0, 0.0, 2.0, 0.0];
+        let factors_im = [0.0, 1.0, 0.0, 0.0];
+        let mut legacy_re = [99.0; 4];
+        let mut legacy_im = [-99.0; 4];
+        assert_eq!(
+            invoke_union(
+                &executor,
+                &rows,
+                &variants,
+                &embeddings,
+                &selections,
+                &mut legacy_re,
+                &mut legacy_im,
+                &momentum,
+                1,
+                &[],
+                &factors_re,
+                &factors_im,
+                1,
+                1,
+            ),
+            DIRECT_STATUS_OK
+        );
+
+        let mut bound_re = [99.0; 4];
+        let mut bound_im = [-99.0; 4];
+        invoke_bound_union(
+            &executor,
+            &rows,
+            &variants,
+            &embeddings,
+            &selections,
+            &exact_union_factors(),
+            &mut bound_re,
+            &mut bound_im,
+            &momentum,
+            1,
+            &[],
+            1,
+            1,
+        )
+        .unwrap();
+        assert_eq!(bound_re, legacy_re);
+        assert_eq!(bound_im, legacy_im);
+    }
+
+    #[test]
+    fn cold_bound_union_source_rejects_corrupt_catalogs_before_execution() {
+        let executor = LoadedDirectSourceExecutor::load(vec![runtime_domain([(
+            0,
+            DirectSourceTemplateSpec {
+                spin_state_class: 0,
+                family: DirectSourceWavefunctionFamily::Scalar,
+                orientation: DirectSourceOrientation::SelfConjugate,
+                helicity: 0,
+                chirality: 0,
+                mass_parameter_index: None,
+            },
+        )])])
+        .unwrap();
+        let rows = [source_row(0, 0, 0, 0, 0)];
+        let variant = DirectSourceDispatchVariantDescriptor {
+            embedding_start: 0,
+            projection_start: 0,
+            source_row_id: 0,
+            dispatch_domain_id: 0,
+            runtime_variant_id: 0,
+            source_state_index: 0,
+            source_template_id: 0,
+            source_state_template_id: 0,
+            crossed_state_template_id: 0,
+            crossed_spin_state_class: 0,
+            direct_executor_id: 0,
+            crossing_exact_factor_id: 0,
+            embedding_count: 1,
+            projection_count: 1,
+        };
+        let embedding = DirectSourceEmbeddingRow {
+            full_component: 0,
+            source_component_or_sentinel: 0,
+            exact_factor_id: 0,
+        };
+        let selection = DirectResolvedSourceSelection {
+            source_slot: 0,
+            dispatch_variant_id: 0,
+        };
+        let factors = [ExactComplexRational::ONE];
+        let bind = |rows: &[DirectSourceRow],
+                    variants: &[DirectSourceDispatchVariantDescriptor],
+                    embeddings: &[DirectSourceEmbeddingRow],
+                    selections: &[DirectResolvedSourceSelection],
+                    exact_factors: &[ExactComplexRational],
+                    current_component_count: u32,
+                    momentum_form_count: u32| {
+            executor.bind_union_program(OnTheFlyUnionSourceBindingView {
+                sources: rows,
+                variants,
+                embeddings,
+                selections,
+                exact_factors,
+                current_component_count,
+                momentum_form_count,
+                parameter_count: 0,
+            })
+        };
+
+        let bad_selection = DirectResolvedSourceSelection {
+            source_slot: 1,
+            ..selection
+        };
+        assert!(
+            bind(
+                &rows,
+                &[variant],
+                &[embedding],
+                &[bad_selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let bad_variant_id = DirectResolvedSourceSelection {
+            dispatch_variant_id: 1,
+            ..selection
+        };
+        assert!(
+            bind(
+                &rows,
+                &[variant],
+                &[embedding],
+                &[bad_variant_id],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let mut bad_domain = variant;
+        bad_domain.dispatch_domain_id = 1;
+        assert!(
+            bind(
+                &rows,
+                &[bad_domain],
+                &[embedding],
+                &[selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let mut bad_template = variant;
+        bad_template.crossed_spin_state_class = 1;
+        assert!(
+            bind(
+                &rows,
+                &[bad_template],
+                &[embedding],
+                &[selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let mut bad_range = variant;
+        bad_range.embedding_start = 1;
+        assert!(
+            bind(
+                &rows,
+                &[bad_range],
+                &[embedding],
+                &[selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let bad_order = DirectSourceEmbeddingRow {
+            full_component: 1,
+            ..embedding
+        };
+        assert!(
+            bind(
+                &rows,
+                &[variant],
+                &[bad_order],
+                &[selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let bad_source_component = DirectSourceEmbeddingRow {
+            source_component_or_sentinel: 1,
+            ..embedding
+        };
+        assert!(
+            bind(
+                &rows,
+                &[variant],
+                &[bad_source_component],
+                &[selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let bad_factor = DirectSourceEmbeddingRow {
+            exact_factor_id: 1,
+            ..embedding
+        };
+        assert!(
+            bind(
+                &rows,
+                &[variant],
+                &[bad_factor],
+                &[selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        assert!(
+            bind(
+                &rows,
+                &[variant],
+                &[embedding],
+                &[selection],
+                &factors,
+                0,
+                1,
+            )
+            .is_err()
+        );
+        assert!(
+            bind(
+                &rows,
+                &[variant],
+                &[embedding],
+                &[selection],
+                &factors,
+                1,
+                0,
+            )
+            .is_err()
+        );
+        let bad_destination = [source_row(0, 0, 1, 0, 0)];
+        assert!(
+            bind(
+                &bad_destination,
+                &[variant],
+                &[embedding],
+                &[selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let bad_momentum = [source_row(0, 0, 0, 1, 0)];
+        assert!(
+            bind(
+                &bad_momentum,
+                &[variant],
+                &[embedding],
+                &[selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let bad_row_factor = [source_row(0, 0, 0, 0, 1)];
+        assert!(
+            bind(
+                &bad_row_factor,
+                &[variant],
+                &[embedding],
+                &[selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let mut bad_crossing_factor = variant;
+        bad_crossing_factor.crossing_exact_factor_id = 1;
+        assert!(
+            bind(
+                &rows,
+                &[bad_crossing_factor],
+                &[embedding],
+                &[selection],
+                &factors,
+                1,
+                1,
+            )
+            .is_err()
+        );
+        let nonunit =
+            ExactComplexRational::new(ExactRational::new(2, 1).unwrap(), ExactRational::ZERO);
+        assert!(
+            bind(
+                &rows,
+                &[variant],
+                &[embedding],
+                &[selection],
+                &[nonunit],
+                1,
+                1,
+            )
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn union_dispatch_rejects_malformed_selection_variant_and_embedding_ranges() {
+        let executor = LoadedDirectSourceExecutor::load(vec![runtime_domain([(
+            0,
+            DirectSourceTemplateSpec {
+                spin_state_class: 0,
+                family: DirectSourceWavefunctionFamily::Scalar,
+                orientation: DirectSourceOrientation::SelfConjugate,
+                helicity: 0,
+                chirality: 0,
+                mass_parameter_index: None,
+            },
+        )])])
+        .unwrap();
+        let rows = [source_row(0, 0, 0, 0, 0)];
+        let base_variant = DirectSourceDispatchVariantDescriptor {
+            embedding_start: 0,
+            projection_start: 0,
+            source_row_id: 0,
+            dispatch_domain_id: 0,
+            runtime_variant_id: 0,
+            source_state_index: 0,
+            source_template_id: 0,
+            source_state_template_id: 0,
+            crossed_state_template_id: 0,
+            crossed_spin_state_class: 0,
+            direct_executor_id: 0,
+            crossing_exact_factor_id: 0,
+            embedding_count: 1,
+            projection_count: 1,
+        };
+        let embeddings = [DirectSourceEmbeddingRow {
+            full_component: 0,
+            source_component_or_sentinel: 0,
+            exact_factor_id: 0,
+        }];
+        let mut current_re = [7.0];
+        let mut current_im = [9.0];
+        let momenta = [1.0, 0.0, 0.0, 1.0];
+
+        let bad_variant = [DirectResolvedSourceSelection {
+            source_slot: 0,
+            dispatch_variant_id: 1,
+        }];
+        assert_eq!(
+            invoke_union(
+                &executor,
+                &rows,
+                &[base_variant],
+                &embeddings,
+                &bad_variant,
+                &mut current_re,
+                &mut current_im,
+                &momenta,
+                1,
+                &[],
+                &[1.0],
+                &[0.0],
+                1,
+                1,
+            ),
+            STATUS_BOUNDS
+        );
+
+        let bad_order = [DirectResolvedSourceSelection {
+            source_slot: 1,
+            dispatch_variant_id: 0,
+        }];
+        assert_eq!(
+            invoke_union(
+                &executor,
+                &rows,
+                &[base_variant],
+                &embeddings,
+                &bad_order,
+                &mut current_re,
+                &mut current_im,
+                &momenta,
+                1,
+                &[],
+                &[1.0],
+                &[0.0],
+                1,
+                1,
+            ),
+            STATUS_INVALID_ARGUMENT
+        );
+
+        let mut bad_embedding = base_variant;
+        bad_embedding.embedding_start = 2;
+        let good_selection = [DirectResolvedSourceSelection {
+            source_slot: 0,
+            dispatch_variant_id: 0,
+        }];
+        assert_eq!(
+            invoke_union(
+                &executor,
+                &rows,
+                &[bad_embedding],
+                &embeddings,
+                &good_selection,
+                &mut current_re,
+                &mut current_im,
+                &momenta,
+                1,
+                &[],
+                &[1.0],
+                &[0.0],
+                1,
+                1,
+            ),
+            STATUS_BOUNDS
+        );
+        assert_eq!(current_re, [7.0]);
+        assert_eq!(current_im, [9.0]);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/stage.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/stage.rs
new file mode 100644
index 0000000000..6ab96e8d62
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/stage.rs
@@ -0,0 +1,940 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::super::*;
+
+impl StageRuntime {
+    pub(crate) fn load(
+        stage: &GenericSerializedStageEvaluatorManifest,
+        payloads: &EvaluatorPayloadStore,
+    ) -> RusticolResult<Self> {
+        let evaluator = EvaluatorGroup::load_from_store(&stage.evaluator, payloads)?;
+        Self::load_with_evaluator(stage, evaluator, false)
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(crate) fn load_exact_from_plane(
+        stage: &GenericSerializedStageEvaluatorManifest,
+        payloads: &EvaluatorPayloadStore,
+    ) -> RusticolResult<Self> {
+        let evaluator = EvaluatorGroup::load_exact_from_plane(stage, payloads)?;
+        Self::load_with_evaluator(stage, evaluator, true)
+    }
+
+    fn load_with_evaluator(
+        stage: &GenericSerializedStageEvaluatorManifest,
+        evaluator: EvaluatorGroup,
+        plane_bindings: bool,
+    ) -> RusticolResult<Self> {
+        let mut outputs = Vec::new();
+        if plane_bindings {
+            let direct = stage.compiled_plane_arena.as_ref().ok_or_else(|| {
+                RusticolError::integrity(
+                    "compiled plane-arena exact stage has no serialized bindings",
+                )
+            })?;
+            for binding in &direct.output_bindings {
+                if binding.arena != "current" {
+                    return Err(RusticolError::integrity(
+                        "compiled plane-arena exact current stage names the wrong output arena",
+                    ));
+                }
+                outputs.push((binding.output_index, binding.component));
+            }
+        } else {
+            for slot in &stage.output_slots {
+                let output_len =
+                    slot.output_stop
+                        .checked_sub(slot.output_start)
+                        .ok_or_else(|| {
+                            RusticolError::invalid_argument(format!(
+                                "generic stage {} has an invalid output slot range",
+                                stage.evaluator_label
+                            ))
+                        })?;
+                let component_len = slot
+                    .component_stop
+                    .checked_sub(slot.component_start)
+                    .ok_or_else(|| {
+                        RusticolError::invalid_argument(format!(
+                            "generic stage {} has an invalid component slot range",
+                            stage.evaluator_label
+                        ))
+                    })?;
+                if output_len != component_len {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "generic stage {} output slot length does not match component length",
+                        stage.evaluator_label
+                    )));
+                }
+                for component in 0..component_len {
+                    outputs.push((
+                        slot.output_start + component,
+                        slot.component_start + component,
+                    ));
+                }
+            }
+        }
+        outputs.sort_unstable_by_key(|(column, _state_offset)| *column);
+        let (input_components, input_spans) =
+            if stage.parameter_layout == "stage-local-value-momentum" {
+                let mut map = vec![0usize; stage.parameter_count];
+                if plane_bindings {
+                    let direct = stage.compiled_plane_arena.as_ref().ok_or_else(|| {
+                        RusticolError::integrity(
+                            "compiled plane-arena exact stage has no serialized bindings",
+                        )
+                    })?;
+                    for component in &direct.input_bindings {
+                        map[component.parameter_index] = component.global_component;
+                    }
+                } else {
+                    for component in &stage.input_components {
+                        map[component.parameter_index] = component.global_component;
+                    }
+                }
+                let spans = contiguous_input_spans(&map);
+                (Some(map), spans)
+            } else {
+                (None, Vec::new())
+            };
+        let output_spans = contiguous_output_spans(&outputs);
+        let (chunk_outputs, chunk_output_spans) =
+            localized_chunk_output_layouts(&evaluator.output_chunk_lengths(), &outputs)?;
+        Ok(Self {
+            outputs,
+            output_spans,
+            chunk_outputs,
+            chunk_output_spans,
+            input_components,
+            input_spans,
+            parameter_scratch_f64: Vec::new(),
+            output_scratch_f64: Vec::new(),
+            evaluator,
+        })
+    }
+
+    pub(crate) fn evaluate_f64_into_state(
+        &mut self,
+        batch_size: usize,
+        parameter_count: usize,
+        state: &mut [Complex<f64>],
+    ) -> RusticolResult<()> {
+        let evaluator_params = if let Some(input_components) = self.input_components.as_ref() {
+            let local_parameter_count = input_components.len();
+            self.parameter_scratch_f64
+                .resize(batch_size * local_parameter_count, c64(0.0, 0.0));
+            for row in 0..batch_size {
+                let row_state = row * parameter_count;
+                let row_params = row * local_parameter_count;
+                if self.input_spans.is_empty() {
+                    for (local_index, global_index) in input_components.iter().enumerate() {
+                        self.parameter_scratch_f64[row_params + local_index] =
+                            state[row_state + *global_index];
+                    }
+                } else {
+                    for (local_start, global_start, len) in &self.input_spans {
+                        let target_start = row_params + *local_start;
+                        let source_start = row_state + *global_start;
+                        self.parameter_scratch_f64[target_start..target_start + *len]
+                            .copy_from_slice(&state[source_start..source_start + *len]);
+                    }
+                }
+            }
+            if self.evaluator.is_chunked() {
+                return self.evaluator.evaluate_chunks_f64_into_state(
+                    batch_size,
+                    &self.parameter_scratch_f64,
+                    parameter_count,
+                    state,
+                    &self.chunk_outputs,
+                    &self.chunk_output_spans,
+                );
+            }
+            self.parameter_scratch_f64.as_slice()
+        } else {
+            &*state
+        };
+        self.evaluator.evaluate_batch_into(
+            batch_size,
+            evaluator_params,
+            &mut self.output_scratch_f64,
+        )?;
+        for row in 0..batch_size {
+            let row_state = row * parameter_count;
+            let row_eval = row * self.evaluator.output_len;
+            if self.output_spans.is_empty() {
+                for (column, state_offset) in &self.outputs {
+                    state[row_state + *state_offset] = self.output_scratch_f64[row_eval + *column];
+                }
+            } else {
+                for (column_start, state_offset_start, len) in &self.output_spans {
+                    let source_start = row_eval + *column_start;
+                    let target_start = row_state + *state_offset_start;
+                    state[target_start..target_start + *len].copy_from_slice(
+                        &self.output_scratch_f64[source_start..source_start + *len],
+                    );
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn evaluate_f64_into_state_profile(
+        &mut self,
+        batch_size: usize,
+        parameter_count: usize,
+        state: &mut [Complex<f64>],
+    ) -> RusticolResult<StageEvaluationProfile> {
+        let mut input_pack_elapsed = Duration::ZERO;
+        let evaluator;
+        let mut scratch_reallocation_count = 0;
+        if let Some(input_components) = self.input_components.as_ref() {
+            let local_parameter_count = input_components.len();
+            let pack_start = Instant::now();
+            let capacity = self.parameter_scratch_f64.capacity();
+            self.parameter_scratch_f64
+                .resize(batch_size * local_parameter_count, c64(0.0, 0.0));
+            scratch_reallocation_count +=
+                u64::from(self.parameter_scratch_f64.capacity() != capacity);
+            for row in 0..batch_size {
+                let row_state = row * parameter_count;
+                let row_params = row * local_parameter_count;
+                if self.input_spans.is_empty() {
+                    for (local_index, global_index) in input_components.iter().enumerate() {
+                        self.parameter_scratch_f64[row_params + local_index] =
+                            state[row_state + *global_index];
+                    }
+                } else {
+                    for (local_start, global_start, len) in &self.input_spans {
+                        let target_start = row_params + *local_start;
+                        let source_start = row_state + *global_start;
+                        self.parameter_scratch_f64[target_start..target_start + *len]
+                            .copy_from_slice(&state[source_start..source_start + *len]);
+                    }
+                }
+            }
+            input_pack_elapsed = pack_start.elapsed();
+            if self.evaluator.is_chunked() {
+                let (evaluator, assign_s) = self.evaluator.evaluate_chunks_f64_into_state_profile(
+                    batch_size,
+                    &self.parameter_scratch_f64,
+                    parameter_count,
+                    state,
+                    &self.chunk_outputs,
+                    &self.chunk_output_spans,
+                )?;
+                return Ok(StageEvaluationProfile {
+                    input_pack_s: input_pack_elapsed.as_secs_f64(),
+                    evaluator,
+                    output_assign_s: assign_s,
+                    input_copy_component_count: (batch_size * local_parameter_count) as u64,
+                    output_assign_component_count: (batch_size * self.outputs.len()) as u64,
+                    scratch_reallocation_count,
+                });
+            }
+            evaluator = self.evaluator.evaluate_batch_into_profile(
+                batch_size,
+                &self.parameter_scratch_f64,
+                &mut self.output_scratch_f64,
+                false,
+            )?;
+        } else {
+            evaluator = self.evaluator.evaluate_batch_into_profile(
+                batch_size,
+                state,
+                &mut self.output_scratch_f64,
+                false,
+            )?;
+        }
+
+        let assign_start = Instant::now();
+        for row in 0..batch_size {
+            let row_state = row * parameter_count;
+            let row_eval = row * self.evaluator.output_len;
+            if self.output_spans.is_empty() {
+                for (column, state_offset) in &self.outputs {
+                    state[row_state + *state_offset] = self.output_scratch_f64[row_eval + *column];
+                }
+            } else {
+                for (column_start, state_offset_start, len) in &self.output_spans {
+                    let source_start = row_eval + *column_start;
+                    let target_start = row_state + *state_offset_start;
+                    state[target_start..target_start + *len].copy_from_slice(
+                        &self.output_scratch_f64[source_start..source_start + *len],
+                    );
+                }
+            }
+        }
+        Ok(StageEvaluationProfile {
+            input_pack_s: input_pack_elapsed.as_secs_f64(),
+            evaluator,
+            output_assign_s: assign_start.elapsed().as_secs_f64(),
+            input_copy_component_count: self
+                .input_components
+                .as_ref()
+                .map_or(0, |components| batch_size * components.len())
+                as u64,
+            output_assign_component_count: (batch_size * self.outputs.len()) as u64,
+            scratch_reallocation_count,
+        })
+    }
+
+    pub(crate) fn evaluate_active_chunks_f64_into_state(
+        &mut self,
+        batch_size: usize,
+        parameter_count: usize,
+        state: &mut [Complex<f64>],
+        active_chunk_indices: &[usize],
+    ) -> RusticolResult<()> {
+        self.evaluator.evaluate_selected_chunks_f64_into_state(
+            batch_size,
+            parameter_count,
+            state,
+            self.input_components.as_deref(),
+            &self.input_spans,
+            &self.chunk_outputs,
+            &self.chunk_output_spans,
+            active_chunk_indices,
+        )
+    }
+
+    pub(crate) fn evaluate_active_chunks_f64_into_state_profile(
+        &mut self,
+        batch_size: usize,
+        parameter_count: usize,
+        state: &mut [Complex<f64>],
+        active_chunk_indices: &[usize],
+    ) -> RusticolResult<StageEvaluationProfile> {
+        let (evaluator, output_assign_s) = self
+            .evaluator
+            .evaluate_selected_chunks_f64_into_state_profile(
+                batch_size,
+                parameter_count,
+                state,
+                self.input_components.as_deref(),
+                &self.input_spans,
+                &self.chunk_outputs,
+                &self.chunk_output_spans,
+                active_chunk_indices,
+            )?;
+        Ok(StageEvaluationProfile {
+            input_pack_s: evaluator.leaf_input_pack_s,
+            output_assign_s,
+            // The selected-chunk evaluator gathers directly from global
+            // state into leaf inputs. There is no distinct parent stage-input
+            // copy to count in addition to the evaluator's leaf gather.
+            input_copy_component_count: 0,
+            output_assign_component_count: active_chunk_indices
+                .iter()
+                .map(|index| self.chunk_outputs[*index].len() as u64 * batch_size as u64)
+                .sum(),
+            scratch_reallocation_count: 0,
+            evaluator,
+        })
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(crate) fn evaluate_generic_into_state<T>(
+        &mut self,
+        batch_size: usize,
+        parameter_count: usize,
+        state: &mut [Complex<T>],
+        binary_precision: Option<u32>,
+    ) -> RusticolResult<(f64, f64, f64)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        self.evaluate_selected_chunks_generic_into_state(
+            batch_size,
+            parameter_count,
+            state,
+            binary_precision,
+            None,
+        )
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(crate) fn evaluate_selected_chunks_generic_into_state<T>(
+        &mut self,
+        batch_size: usize,
+        parameter_count: usize,
+        state: &mut [Complex<T>],
+        binary_precision: Option<u32>,
+        active_chunk_indices: Option<&[usize]>,
+    ) -> RusticolResult<(f64, f64, f64)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let mut input_pack_s = 0.0;
+        let (evaluated, evaluator_s) =
+            if let Some(input_components) = self.input_components.as_ref() {
+                let local_parameter_count = input_components.len();
+                let pack_start = Instant::now();
+                let mut parameter_scratch =
+                    vec![complex_zero::<T>(); batch_size * local_parameter_count];
+                for row in 0..batch_size {
+                    let row_state = row * parameter_count;
+                    let row_params = row * local_parameter_count;
+                    if self.input_spans.is_empty() {
+                        for (local_index, global_index) in input_components.iter().enumerate() {
+                            parameter_scratch[row_params + local_index] =
+                                state[row_state + *global_index].clone();
+                        }
+                    } else {
+                        for (local_start, global_start, len) in &self.input_spans {
+                            let target_start = row_params + *local_start;
+                            let source_start = row_state + *global_start;
+                            parameter_scratch[target_start..target_start + *len]
+                                .clone_from_slice(&state[source_start..source_start + *len]);
+                        }
+                    }
+                }
+                input_pack_s = pack_start.elapsed().as_secs_f64();
+                let eval_start = Instant::now();
+                let evaluated = self.evaluator.evaluate_selected_chunks_generic(
+                    batch_size,
+                    &parameter_scratch,
+                    binary_precision,
+                    active_chunk_indices,
+                )?;
+                (evaluated, eval_start.elapsed().as_secs_f64())
+            } else {
+                let eval_start = Instant::now();
+                let evaluated = self.evaluator.evaluate_selected_chunks_generic(
+                    batch_size,
+                    state,
+                    binary_precision,
+                    active_chunk_indices,
+                )?;
+                (evaluated, eval_start.elapsed().as_secs_f64())
+            };
+
+        if let Some(indices) = active_chunk_indices {
+            // Inactive chunks may share storage with still-live currents.
+            // Assign only the selected leaves, never their zero placeholders.
+            let assign_start = Instant::now();
+            let mut offset = 0;
+            let chunk_offsets = self
+                .evaluator
+                .output_chunk_lengths()
+                .into_iter()
+                .map(|length| {
+                    let start = offset;
+                    offset += length;
+                    start
+                })
+                .collect::<Vec<_>>();
+            for row in 0..batch_size {
+                let row_state = row * parameter_count;
+                let row_eval = row * self.evaluator.output_len;
+                for &index in indices {
+                    for &(column, state_offset) in &self.chunk_outputs[index] {
+                        state[row_state + state_offset] =
+                            evaluated[row_eval + chunk_offsets[index] + column].clone();
+                    }
+                }
+            }
+            return Ok((
+                input_pack_s,
+                evaluator_s,
+                assign_start.elapsed().as_secs_f64(),
+            ));
+        }
+        self.assign_generic_outputs(
+            batch_size,
+            parameter_count,
+            state,
+            evaluated,
+            input_pack_s,
+            evaluator_s,
+        )
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    pub(crate) fn assign_generic_outputs<T>(
+        &self,
+        batch_size: usize,
+        parameter_count: usize,
+        state: &mut [Complex<T>],
+        evaluated: Vec<Complex<T>>,
+        input_pack_s: f64,
+        evaluator_s: f64,
+    ) -> RusticolResult<(f64, f64, f64)>
+    where
+        T: RusticolHighPrecisionNumber,
+        Complex<T>: Real + EvaluationDomain,
+    {
+        let assign_start = Instant::now();
+        for row in 0..batch_size {
+            let row_state = row * parameter_count;
+            let row_eval = row * self.evaluator.output_len;
+            if self.output_spans.is_empty() {
+                for (column, state_offset) in &self.outputs {
+                    state[row_state + *state_offset] = evaluated[row_eval + *column].clone();
+                }
+            } else {
+                for (column_start, state_offset_start, len) in &self.output_spans {
+                    let source_start = row_eval + *column_start;
+                    let target_start = row_state + *state_offset_start;
+                    state[target_start..target_start + *len]
+                        .clone_from_slice(&evaluated[source_start..source_start + *len]);
+                }
+            }
+        }
+        Ok((
+            input_pack_s,
+            evaluator_s,
+            assign_start.elapsed().as_secs_f64(),
+        ))
+    }
+}
+
+type ChunkOutputs = Vec<Vec<(usize, usize)>>;
+type ChunkOutputSpans = Vec<Vec<(usize, usize, usize)>>;
+
+fn localized_chunk_output_layouts(
+    chunk_lengths: &[usize],
+    outputs: &[(usize, usize)],
+) -> RusticolResult<(ChunkOutputs, ChunkOutputSpans)> {
+    if chunk_lengths.iter().sum::<usize>() != outputs.len() {
+        return Err(RusticolError::invalid_argument(
+            "stage output layout length does not match evaluator output length",
+        ));
+    }
+    let mut chunk_outputs = Vec::with_capacity(chunk_lengths.len());
+    let mut chunk_spans = Vec::with_capacity(chunk_lengths.len());
+    let mut output_offset = 0usize;
+    for chunk_len in chunk_lengths {
+        let chunk_stop = output_offset + *chunk_len;
+        let mut localized = Vec::with_capacity(*chunk_len);
+        for (expected_column, (column, state_offset)) in outputs[output_offset..chunk_stop]
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            let expected_global_column = output_offset + expected_column;
+            if column != expected_global_column {
+                return Err(RusticolError::invalid_argument(
+                    "stage output columns are not contiguous in evaluator order",
+                ));
+            }
+            localized.push((expected_column, state_offset));
+        }
+        chunk_spans.push(contiguous_output_spans(&localized));
+        chunk_outputs.push(localized);
+        output_offset = chunk_stop;
+    }
+    Ok((chunk_outputs, chunk_spans))
+}
+
+pub(crate) fn contiguous_input_spans(input_components: &[usize]) -> Vec<(usize, usize, usize)> {
+    if input_components.is_empty() {
+        return Vec::new();
+    }
+    let mut spans = Vec::new();
+    let mut local_start = 0usize;
+    let mut global_start = input_components[0];
+    let mut previous_local = local_start;
+    let mut previous_global = global_start;
+    let mut len = 1usize;
+    for (local, global) in input_components.iter().copied().enumerate().skip(1) {
+        if local == previous_local + 1 && global == previous_global + 1 {
+            previous_local = local;
+            previous_global = global;
+            len += 1;
+            continue;
+        }
+        spans.push((local_start, global_start, len));
+        local_start = local;
+        global_start = global;
+        previous_local = local;
+        previous_global = global;
+        len = 1;
+    }
+    spans.push((local_start, global_start, len));
+    if spans.len() >= input_components.len() {
+        Vec::new()
+    } else {
+        spans
+    }
+}
+
+pub(crate) fn contiguous_output_spans(outputs: &[(usize, usize)]) -> Vec<(usize, usize, usize)> {
+    if outputs.is_empty() {
+        return Vec::new();
+    }
+    let mut spans = Vec::new();
+    let (mut output_start, mut state_start) = outputs[0];
+    let mut previous_output = output_start;
+    let mut previous_state = state_start;
+    let mut len = 1usize;
+    for (output, state) in outputs.iter().copied().skip(1) {
+        if output == previous_output + 1 && state == previous_state + 1 {
+            previous_output = output;
+            previous_state = state;
+            len += 1;
+            continue;
+        }
+        spans.push((output_start, state_start, len));
+        output_start = output;
+        state_start = state;
+        previous_output = output;
+        previous_state = state;
+        len = 1;
+    }
+    spans.push((output_start, state_start, len));
+    if spans.len() >= outputs.len() {
+        Vec::new()
+    } else {
+        spans
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(all(
+        feature = "f64-compiled",
+        any(target_os = "linux", target_os = "macos")
+    ))]
+    use std::process::Command;
+    #[cfg(all(
+        feature = "f64-compiled",
+        any(target_os = "linux", target_os = "macos")
+    ))]
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    #[test]
+    fn chunk_output_layouts_are_localized_without_losing_state_offsets() {
+        let outputs = vec![(0, 10), (1, 11), (2, 20), (3, 22), (4, 23)];
+        let (chunks, spans) = localized_chunk_output_layouts(&[2, 3], &outputs).unwrap();
+
+        assert_eq!(chunks[0], vec![(0, 10), (1, 11)]);
+        assert_eq!(chunks[1], vec![(0, 20), (1, 22), (2, 23)]);
+        assert_eq!(spans[0], vec![(0, 10, 2)]);
+        assert_eq!(spans[1], vec![(0, 20, 1), (1, 22, 2)]);
+    }
+
+    #[test]
+    fn chunk_output_layouts_reject_inconsistent_evaluator_metadata() {
+        let length_error = localized_chunk_output_layouts(&[1], &[(0, 10), (1, 11)])
+            .expect_err("chunk lengths must cover every output");
+        assert!(
+            length_error
+                .to_string()
+                .contains("layout length does not match")
+        );
+
+        let order_error = localized_chunk_output_layouts(&[2], &[(0, 10), (2, 11)])
+            .expect_err("output columns must be contiguous");
+        assert!(
+            order_error
+                .to_string()
+                .contains("columns are not contiguous")
+        );
+    }
+
+    #[cfg(feature = "symbolica-runtime")]
+    #[test]
+    fn generic_selected_chunks_preserve_inactive_live_current_slots() {
+        use symbolica::{atom::AtomCore, parse};
+
+        let leaf = |expression: &str| LoadedEvaluator {
+            eval: F64Evaluator::ExactOnly,
+            exact_eval: Some(
+                parse!(expression)
+                    .evaluator(&[parse!("selected_chunk_x")])
+                    .build()
+                    .unwrap(),
+            ),
+            exact_eval_source: None,
+            double_eval: None,
+            arb_eval: None,
+            input_len: 1,
+            output_len: 1,
+        };
+        let evaluator = EvaluatorGroup {
+            evaluators: vec![
+                leaf("selected_chunk_x + 100"),
+                leaf("selected_chunk_x + 200"),
+            ],
+            input_len: 2,
+            input_mappings: vec![Some(vec![0]), Some(vec![1])],
+            input_mapping_spans: vec![Vec::new(), Vec::new()],
+            output_len: 2,
+            chunk_parameter_scratch_f64: Vec::new(),
+            chunk_scratch_f64: Vec::new(),
+            chunk_parameter_scratch_aosoa_f64: Vec::new(),
+            chunk_scratch_aosoa_f64: Vec::new(),
+            chunk_input_mapping_scratch: Vec::new(),
+        };
+        let mut stage = StageRuntime {
+            outputs: vec![(0, 1), (1, 3)],
+            output_spans: Vec::new(),
+            chunk_outputs: vec![vec![(0, 1)], vec![(0, 3)]],
+            chunk_output_spans: vec![Vec::new(), Vec::new()],
+            input_components: Some(vec![2, 0]),
+            input_spans: Vec::new(),
+            parameter_scratch_f64: Vec::new(),
+            output_scratch_f64: Vec::new(),
+            evaluator,
+        };
+        let number = |value| c_generic(DoubleFloat::from(value), DoubleFloat::from(0.0));
+        let initial = [3.0, -99.0, 7.0, -99.0, 11.0, -99.0, 13.0, -99.0]
+            .map(number)
+            .to_vec();
+        let mut state = initial.clone();
+        stage
+            .evaluate_selected_chunks_generic_into_state(2, 4, &mut state, None, Some(&[1]))
+            .unwrap();
+        assert!(stage.evaluator.evaluators[0].double_eval.is_none());
+        assert!(stage.evaluator.evaluators[1].double_eval.is_some());
+        assert_eq!(state[1], number(-99.0));
+        assert_eq!(state[5], number(-99.0));
+        assert_eq!(state[3], number(203.0));
+        assert_eq!(state[7], number(211.0));
+
+        stage
+            .evaluate_selected_chunks_generic_into_state(2, 4, &mut state, None, Some(&[0]))
+            .unwrap();
+        assert_eq!(state[1], number(107.0));
+        assert_eq!(state[5], number(113.0));
+        assert_eq!(state[3], number(203.0));
+        assert_eq!(state[7], number(211.0));
+        let mut complete = initial;
+        stage
+            .evaluate_generic_into_state(2, 4, &mut complete, None)
+            .unwrap();
+        assert_eq!(state, complete);
+        for invalid in [&[1, 1][..], &[1, 0][..], &[2][..]] {
+            assert!(
+                stage
+                    .evaluate_selected_chunks_generic_into_state(
+                        2,
+                        4,
+                        &mut state,
+                        None,
+                        Some(invalid),
+                    )
+                    .is_err()
+            );
+            assert_eq!(state, complete);
+        }
+    }
+
+    #[cfg(all(
+        feature = "f64-compiled",
+        any(target_os = "linux", target_os = "macos")
+    ))]
+    #[test]
+    fn alternating_selected_stage_chunks_cannot_leak_inactive_prior_state() {
+        let (directory, library, marker) = selective_stage_fixture();
+        let library_name = library.file_name().unwrap().to_str().unwrap().to_string();
+        let leaf = |function_name: &str| EvaluatorManifest::CompiledComplex {
+            runtime_capability: SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY.to_string(),
+            function_name: function_name.to_string(),
+            input_len: 1,
+            output_len: 1,
+            library_path: library_name.clone(),
+            evaluator_state_path: None,
+            number_type: "complex".to_string(),
+            native_direct_application: None,
+        };
+        let evaluator = EvaluatorGroup::load(
+            &EvaluatorManifest::Chunked {
+                required_runtime_capabilities: vec![
+                    SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY.to_string(),
+                ],
+                input_len: Some(2),
+                chunk_input_indices: Some(vec![vec![0], vec![1]]),
+                chunks: vec![leaf("stage_chunk_0"), leaf("stage_chunk_1")],
+            },
+            &directory,
+        )
+        .unwrap();
+        let outputs = vec![(0, 1), (1, 3)];
+        let mut stage = StageRuntime {
+            output_spans: contiguous_output_spans(&outputs),
+            outputs,
+            chunk_outputs: vec![vec![(0, 1)], vec![(0, 3)]],
+            chunk_output_spans: vec![Vec::new(), Vec::new()],
+            input_components: Some(vec![2, 0]),
+            input_spans: Vec::new(),
+            parameter_scratch_f64: Vec::new(),
+            output_scratch_f64: Vec::new(),
+            evaluator,
+        };
+
+        let sentinel = c64(-99.0, 0.0);
+        let mut selected_state = vec![c64(3.0, 0.0), sentinel, c64(7.0, 0.0), sentinel];
+        let selected_profile = stage
+            .evaluate_active_chunks_f64_into_state_profile(1, 4, &mut selected_state, &[1])
+            .unwrap();
+        assert_eq!(selected_state[1], sentinel, "inactive output was assigned");
+        assert_eq!(selected_state[3], c64(203.0, 0.0));
+        assert_eq!(
+            selected_profile.input_copy_component_count, 0,
+            "composed selected-chunk gather is not a separate parent input copy"
+        );
+        assert_eq!(
+            selected_profile.evaluator.leaf_input_copy_component_count, 1,
+            "the composed selected-chunk gather must be counted once as a leaf input"
+        );
+        assert_eq!(fs::read_to_string(&marker).unwrap(), "1");
+
+        let parameter_capacity = stage.evaluator.chunk_parameter_scratch_f64.capacity();
+        let output_capacity = stage.evaluator.chunk_scratch_f64.capacity();
+        selected_state[3] = sentinel;
+        stage
+            .evaluate_active_chunks_f64_into_state(1, 4, &mut selected_state, &[1])
+            .unwrap();
+        assert_eq!(
+            stage.evaluator.chunk_parameter_scratch_f64.capacity(),
+            parameter_capacity
+        );
+        assert_eq!(
+            stage.evaluator.chunk_scratch_f64.capacity(),
+            output_capacity
+        );
+
+        let marker_before_invalid = fs::read_to_string(&marker).unwrap();
+        for invalid in [&[1, 1][..], &[1, 0][..], &[2][..]] {
+            assert!(
+                stage
+                    .evaluate_active_chunks_f64_into_state(1, 4, &mut selected_state, invalid)
+                    .is_err()
+            );
+        }
+        assert_eq!(fs::read_to_string(&marker).unwrap(), marker_before_invalid);
+
+        fs::write(&marker, "").unwrap();
+        let mut full_state = vec![c64(3.0, 0.0), sentinel, c64(7.0, 0.0), sentinel];
+        stage
+            .evaluate_f64_into_state(1, 4, &mut full_state)
+            .unwrap();
+        assert_eq!(full_state[1], c64(107.0, 0.0));
+        assert_eq!(full_state[3], c64(203.0, 0.0));
+        assert_eq!(fs::read_to_string(&marker).unwrap(), "01");
+
+        // The execution runtime clears its reusable state before every
+        // selector-pruned schedule. Alternate schedules on the same backing
+        // allocation to ensure inactive outputs cannot retain a prior value.
+        for chunk_index in [0, 1, 0, 1] {
+            selected_state.fill(c64(0.0, 0.0));
+            selected_state[0] = c64(3.0, 0.0);
+            selected_state[2] = c64(7.0, 0.0);
+            stage
+                .evaluate_active_chunks_f64_into_state(1, 4, &mut selected_state, &[chunk_index])
+                .unwrap();
+            if chunk_index == 0 {
+                assert_eq!(selected_state[1], c64(107.0, 0.0));
+                assert_eq!(selected_state[3], c64(0.0, 0.0));
+            } else {
+                assert_eq!(selected_state[1], c64(0.0, 0.0));
+                assert_eq!(selected_state[3], c64(203.0, 0.0));
+            }
+        }
+
+        let parent_inputs = [c64(7.0, 0.0), c64(3.0, 0.0)];
+        let mut selected_outputs = vec![sentinel; 2];
+        for chunk_index in [0, 1, 0, 1] {
+            stage
+                .evaluator
+                .evaluate_selected_chunks_f64_into_output(
+                    1,
+                    &parent_inputs,
+                    None,
+                    &[],
+                    &mut selected_outputs,
+                    &[chunk_index],
+                )
+                .unwrap();
+            if chunk_index == 0 {
+                assert_eq!(selected_outputs, vec![c64(107.0, 0.0), c64(0.0, 0.0)]);
+            } else {
+                assert_eq!(selected_outputs, vec![c64(0.0, 0.0), c64(203.0, 0.0)]);
+            }
+        }
+
+        drop(stage);
+        fs::remove_dir_all(directory).unwrap();
+    }
+
+    #[cfg(all(
+        feature = "f64-compiled",
+        any(target_os = "linux", target_os = "macos")
+    ))]
+    fn selective_stage_fixture() -> (PathBuf, PathBuf, PathBuf) {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let directory = std::env::temp_dir().join(format!(
+            "rusticol-selective-stage-test-{}-{unique}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&directory).unwrap();
+        let source = directory.join("fixture.cpp");
+        let marker = directory.join("calls.txt");
+        fs::write(&marker, "").unwrap();
+        let library = directory.join(if cfg!(target_os = "macos") {
+            "libfixture.dylib"
+        } else {
+            "libfixture.so"
+        });
+        let marker_literal = marker.to_string_lossy().replace('\\', "\\\\");
+        fs::write(
+            &source,
+            format!(
+                r#"#include <complex>
+#include <cstdio>
+static void mark(const char* value) {{
+    std::FILE* file = std::fopen("{marker_literal}", "a");
+    std::fputs(value, file);
+    std::fclose(file);
+}}
+extern "C" unsigned long stage_chunk_0_complexf64_get_buffer_len() {{ return 1; }}
+extern "C" void stage_chunk_0_complexf64(
+    std::complex<double>* params,
+    std::complex<double>*,
+    std::complex<double>* out) {{
+    mark("0");
+    out[0] = params[0] + std::complex<double>(100.0, 0.0);
+}}
+extern "C" unsigned long stage_chunk_1_complexf64_get_buffer_len() {{ return 1; }}
+extern "C" void stage_chunk_1_complexf64(
+    std::complex<double>* params,
+    std::complex<double>*,
+    std::complex<double>* out) {{
+    mark("1");
+    out[0] = params[0] + std::complex<double>(200.0, 0.0);
+}}
+"#
+            ),
+        )
+        .unwrap();
+        let compiler = std::env::var("CXX").unwrap_or_else(|_| "c++".to_string());
+        let mut command = Command::new(compiler);
+        command.arg("-std=c++17");
+        if cfg!(target_os = "macos") {
+            command.arg("-dynamiclib");
+        } else {
+            command.args(["-shared", "-fPIC"]);
+        }
+        let output = command
+            .arg(&source)
+            .arg("-o")
+            .arg(&library)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "could not compile selective stage fixture: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        (directory, library, marker)
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit.rs
new file mode 100644
index 0000000000..134f83de68
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit.rs
@@ -0,0 +1,1112 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::super::*;
+use std::any::Any;
+use std::panic::{AssertUnwindSafe, catch_unwind};
+use symjit::{Applet, Application, Compiled, Config, Defuns, Storage};
+
+pub(crate) struct SymjitApplicationEvaluator {
+    applet: Applet,
+    application_path: PathBuf,
+    input_len: usize,
+    output_len: usize,
+    input_tail_scratch: Vec<Complex<f64>>,
+    output_tail_scratch: Vec<Complex<f64>>,
+}
+
+impl std::fmt::Debug for SymjitApplicationEvaluator {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("SymjitApplicationEvaluator")
+            .field("application_path", &self.application_path)
+            .field("input_len", &self.input_len)
+            .field("output_len", &self.output_len)
+            .finish_non_exhaustive()
+    }
+}
+
+pub(crate) struct SymjitApplicationMetadata<'a> {
+    pub(crate) runtime_capability: &'a str,
+    pub(crate) application_abi: &'a str,
+    pub(crate) input_len: usize,
+    pub(crate) output_len: usize,
+    pub(crate) element_layout: &'a str,
+    pub(crate) batch_layout: &'a str,
+    pub(crate) compiler_type: &'a str,
+    pub(crate) translation_mode: &'a str,
+    pub(crate) optimization_level: u8,
+    pub(crate) word_bits: u8,
+    pub(crate) endianness: &'a str,
+    pub(crate) required_defuns: &'a [String],
+}
+
+impl SymjitApplicationEvaluator {
+    #[cfg(test)]
+    pub(crate) fn load(
+        path: &Path,
+        metadata: SymjitApplicationMetadata<'_>,
+    ) -> RusticolResult<Self> {
+        let bytes = fs::read(path).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not read SymJIT application {}: {error}",
+                path.display()
+            ))
+        })?;
+        Self::load_bytes(&bytes, path.to_path_buf(), metadata)
+    }
+
+    pub(crate) fn load_bytes(
+        bytes: &[u8],
+        display_path: PathBuf,
+        metadata: SymjitApplicationMetadata<'_>,
+    ) -> RusticolResult<Self> {
+        validate_manifest_metadata(&metadata)?;
+
+        // This is the same trusted-input path used by Symbolica's
+        // JITCompiledEvaluator::load.
+        let mut loader_config = Config::default();
+        loader_config.set_defuns(Defuns::new());
+        let mut input = bytes;
+        let application = guard_symjit_panic(
+            || Application::load(&mut input, &loader_config),
+            |detail| {
+                RusticolError::compatibility(format!(
+                    "SymJIT panicked while loading application {} with ABI {}: {detail}",
+                    display_path.display(),
+                    SYMJIT_APPLICATION_STORAGE_ABI
+                ))
+            },
+        )?
+        .map_err(|error| {
+            RusticolError::compatibility(format!(
+                "could not load SymJIT application {} with ABI {}: {error}",
+                display_path.display(),
+                SYMJIT_APPLICATION_STORAGE_ABI
+            ))
+        })?;
+        validate_loaded_application(&display_path, &application, &metadata)?;
+        let applet = guard_symjit_panic(
+            || application.seal(),
+            |detail| {
+                RusticolError::compatibility(format!(
+                    "SymJIT panicked while sealing application {}: {detail}",
+                    display_path.display()
+                ))
+            },
+        )?
+        .map_err(|error| {
+            RusticolError::evaluation(format!(
+                "could not seal SymJIT application {}: {error}",
+                display_path.display()
+            ))
+        })?;
+        Ok(Self {
+            applet,
+            application_path: display_path,
+            input_len: metadata.input_len,
+            output_len: metadata.output_len,
+            input_tail_scratch: Vec::new(),
+            output_tail_scratch: Vec::new(),
+        })
+    }
+
+    pub(crate) fn evaluate_batch(
+        &mut self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        out: &mut [Complex<f64>],
+    ) -> RusticolResult<()> {
+        validate_batch_lengths(
+            batch_size,
+            self.input_len,
+            self.output_len,
+            params.len(),
+            out.len(),
+        )?;
+        if batch_size == 0 {
+            return Ok(());
+        }
+        let lane_width = super::native_f64_simd_lane_width();
+        let remainder = batch_size % lane_width;
+        if remainder == 0 {
+            return evaluate_matrix(
+                &self.applet,
+                &self.application_path,
+                batch_size,
+                params,
+                out,
+            );
+        }
+
+        let aligned_batch_size = batch_size - remainder;
+        if aligned_batch_size != 0 {
+            evaluate_matrix(
+                &self.applet,
+                &self.application_path,
+                aligned_batch_size,
+                &params[..aligned_batch_size * self.input_len],
+                &mut out[..aligned_batch_size * self.output_len],
+            )?;
+        }
+
+        let padded_input_len = lane_width
+            .checked_mul(self.input_len)
+            .ok_or_else(|| RusticolError::invalid_argument("SymJIT SIMD input batch overflows"))?;
+        self.input_tail_scratch
+            .resize(padded_input_len, Complex::new(0.0, 0.0));
+        let source_start = aligned_batch_size * self.input_len;
+        let source_end = source_start + remainder * self.input_len;
+        self.input_tail_scratch[..remainder * self.input_len]
+            .copy_from_slice(&params[source_start..source_end]);
+        let tail_row_start = (remainder - 1) * self.input_len;
+        for row in remainder..lane_width {
+            let target_start = row * self.input_len;
+            self.input_tail_scratch.copy_within(
+                tail_row_start..tail_row_start + self.input_len,
+                target_start,
+            );
+        }
+        let padded_output_len = lane_width
+            .checked_mul(self.output_len)
+            .ok_or_else(|| RusticolError::invalid_argument("SymJIT SIMD output batch overflows"))?;
+        self.output_tail_scratch
+            .resize(padded_output_len, Complex::new(0.0, 0.0));
+        evaluate_matrix(
+            &self.applet,
+            &self.application_path,
+            lane_width,
+            &self.input_tail_scratch,
+            &mut self.output_tail_scratch,
+        )?;
+        let output_start = aligned_batch_size * self.output_len;
+        let output_end = output_start + remainder * self.output_len;
+        out[output_start..output_end]
+            .copy_from_slice(&self.output_tail_scratch[..remainder * self.output_len]);
+        Ok(())
+    }
+
+    pub(crate) fn evaluate_batch_unpadded(
+        &self,
+        batch_size: usize,
+        params: &[Complex<f64>],
+        out: &mut [Complex<f64>],
+    ) -> RusticolResult<()> {
+        validate_batch_lengths(
+            batch_size,
+            self.input_len,
+            self.output_len,
+            params.len(),
+            out.len(),
+        )?;
+        evaluate_matrix(
+            &self.applet,
+            &self.application_path,
+            batch_size,
+            params,
+            out,
+        )
+    }
+
+    pub(crate) fn simd_lane_width(&self) -> Option<usize> {
+        if self.applet.use_threads {
+            // The direct AoSoA entry point below executes blocks serially.
+            // Preserve SymJIT's threaded matrix dispatch for applications that
+            // explicitly requested it.
+            return None;
+        }
+        self.applet
+            .compiled_simd
+            .as_ref()
+            .map(Compiled::count_lanes)
+            .filter(|lane_width| *lane_width != 0)
+    }
+
+    /// Evaluates already-transposed SIMD blocks without a row-major staging copy.
+    ///
+    /// Each block contains `input_len` complex SIMD values in AoSoA order: all
+    /// real lanes followed by all imaginary lanes for one input, then the next
+    /// input. Outputs use the analogous `output_len` layout. `false` asks the
+    /// caller to fall back to the ordinary evaluator because no SIMD kernel is
+    /// available or the loaded kernel rejected a block.
+    pub(crate) fn evaluate_aosoa_blocks(
+        &self,
+        block_count: usize,
+        params: &[f64],
+        out: &mut [f64],
+    ) -> RusticolResult<bool> {
+        let Some(compiled) = self.applet.compiled_simd.as_ref() else {
+            return Ok(false);
+        };
+        let lane_width = compiled.count_lanes();
+        if lane_width == 0 {
+            return Ok(false);
+        }
+        validate_aosoa_lengths(
+            block_count,
+            lane_width,
+            self.input_len,
+            self.output_len,
+            params.len(),
+            out.len(),
+        )?;
+        if block_count == 0 {
+            return Ok(true);
+        }
+
+        let input_block_len = lane_width * self.input_len * 2;
+        let output_block_len = lane_width * self.output_len * 2;
+        let function = compiled.func();
+        guard_symjit_panic(
+            || {
+                for block in 0..block_count {
+                    let status = function(
+                        out[block * output_block_len..].as_mut_ptr(),
+                        std::ptr::null(),
+                        0,
+                        params[block * input_block_len..].as_ptr(),
+                    );
+                    if status != 0 {
+                        return false;
+                    }
+                }
+                true
+            },
+            |detail| {
+                RusticolError::evaluation(format!(
+                    "SymJIT panicked while evaluating AoSoA blocks for application {}: {detail}",
+                    self.application_path.display()
+                ))
+            },
+        )
+    }
+}
+
+fn evaluate_matrix(
+    applet: &Applet,
+    application_path: &Path,
+    batch_size: usize,
+    params: &[Complex<f64>],
+    out: &mut [Complex<f64>],
+) -> RusticolResult<()> {
+    let params = complex_slice_as_scalars(params);
+    let out = complex_slice_as_scalars_mut(out);
+    guard_symjit_panic(
+        || applet.evaluate_matrix(params, out, batch_size),
+        |detail| {
+            RusticolError::evaluation(format!(
+                "SymJIT panicked while evaluating application {}: {detail}",
+                application_path.display()
+            ))
+        },
+    )?;
+    Ok(())
+}
+
+fn guard_symjit_panic<T>(
+    operation: impl FnOnce() -> T,
+    error: impl FnOnce(String) -> RusticolError,
+) -> RusticolResult<T> {
+    catch_unwind(AssertUnwindSafe(operation)).map_err(|payload| error(panic_detail(payload)))
+}
+
+fn panic_detail(payload: Box<dyn Any + Send>) -> String {
+    if let Some(message) = payload.downcast_ref::<&str>() {
+        (*message).to_string()
+    } else if let Some(message) = payload.downcast_ref::<String>() {
+        message.clone()
+    } else {
+        "non-string panic payload".to_string()
+    }
+}
+
+pub(crate) fn validate_manifest_metadata(
+    metadata: &SymjitApplicationMetadata<'_>,
+) -> RusticolResult<()> {
+    if metadata.runtime_capability != SYMJIT_APPLICATION_RUNTIME_CAPABILITY {
+        return Err(RusticolError::unsupported_runtime_capability(
+            metadata.runtime_capability,
+            format!("a direct SymJIT evaluator requires {SYMJIT_APPLICATION_RUNTIME_CAPABILITY:?}"),
+        ));
+    }
+    if metadata.application_abi != SYMJIT_APPLICATION_STORAGE_ABI {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT application ABI {:?} is unsupported; this runtime requires {:?}",
+            metadata.application_abi, SYMJIT_APPLICATION_STORAGE_ABI
+        )));
+    }
+    if metadata.input_len == 0 || metadata.output_len == 0 {
+        return Err(RusticolError::invalid_argument(
+            "SymJIT application input_len and output_len must both be positive",
+        ));
+    }
+    if metadata.element_layout != "complex-f64" || metadata.batch_layout != "row-major" {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported SymJIT application layout element={:?}, batch={:?}",
+            metadata.element_layout, metadata.batch_layout
+        )));
+    }
+    if metadata.compiler_type != "native" {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported SymJIT compiler type {:?}; expected \"native\"",
+            metadata.compiler_type
+        )));
+    }
+    if metadata.translation_mode != "indirect" {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported SymJIT translation {:?}; direct translation is not a stable artifact ABI",
+            metadata.translation_mode
+        )));
+    }
+    if metadata.word_bits != usize::BITS as u8 || metadata.word_bits != 64 {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT application requires a {}-bit runtime, but this host uses {} bits",
+            metadata.word_bits,
+            usize::BITS
+        )));
+    }
+    let host_endianness = if cfg!(target_endian = "little") {
+        "little"
+    } else {
+        "big"
+    };
+    if metadata.endianness != host_endianness || metadata.endianness != "little" {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT application endianness {:?} is incompatible with host endianness {host_endianness:?}",
+            metadata.endianness
+        )));
+    }
+    if !metadata.required_defuns.is_empty() {
+        return Err(RusticolError::unsupported_runtime_capability(
+            SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+            format!(
+                "external functions are not self-contained: {}",
+                metadata.required_defuns.join(", ")
+            ),
+        ));
+    }
+    Ok(())
+}
+
+fn validate_loaded_application(
+    path: &Path,
+    application: &Application,
+    metadata: &SymjitApplicationMetadata<'_>,
+) -> RusticolResult<()> {
+    let expected_params = metadata.input_len.checked_mul(2).ok_or_else(|| {
+        RusticolError::invalid_argument("SymJIT complex input count overflows usize")
+    })?;
+    let expected_outputs = metadata.output_len.checked_mul(2).ok_or_else(|| {
+        RusticolError::invalid_argument("SymJIT complex output count overflows usize")
+    })?;
+    if application.count_states != 0
+        || application.count_diffs != 0
+        || application.count_params != expected_params
+        || application.count_obs != expected_outputs
+    {
+        return Err(RusticolError::integrity(format!(
+            "SymJIT application {} has counts states={}, params={}, outputs={}, diffs={}; expected 0, {}, {}, 0",
+            path.display(),
+            application.count_states,
+            application.count_params,
+            application.count_obs,
+            application.count_diffs,
+            expected_params,
+            expected_outputs
+        )));
+    }
+    validate_application_config(path, &application.config, metadata)
+}
+
+fn validate_application_config(
+    path: &Path,
+    config: &Config,
+    metadata: &SymjitApplicationMetadata<'_>,
+) -> RusticolResult<()> {
+    if !config.is_complex() || !config.symbolica() {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT application {} is not a complex Symbolica evaluator",
+            path.display()
+        )));
+    }
+    if config.direct() {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT application {} uses direct translation; regenerate it with indirect translation",
+            path.display()
+        )));
+    }
+    let host_native = if cfg!(target_arch = "aarch64") {
+        config.is_arm64()
+    } else if cfg!(target_arch = "x86_64") {
+        config.is_amd64()
+    } else if cfg!(target_arch = "riscv64") {
+        config.is_riscv64()
+    } else {
+        false
+    };
+    if !host_native && !matches!(metadata.optimization_level, 1 | 2) {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT application {} uses compiler type {:?}, which is not native for this host; only optimization level 1 or 2 applications are cross-architecture portable",
+            path.display(),
+            config.compiler_type()
+        )));
+    }
+    if config.opt_level() != metadata.optimization_level {
+        return Err(RusticolError::integrity(format!(
+            "SymJIT application {} declares optimization level {} but stores optimization level {}",
+            path.display(),
+            metadata.optimization_level,
+            config.opt_level()
+        )));
+    }
+    Ok(())
+}
+
+fn validate_batch_lengths(
+    rows: usize,
+    input_len: usize,
+    output_len: usize,
+    params_len: usize,
+    output_buffer_len: usize,
+) -> RusticolResult<()> {
+    let expected_params = rows.checked_mul(input_len).ok_or_else(|| {
+        RusticolError::invalid_argument("SymJIT parameter buffer length overflows usize")
+    })?;
+    let expected_outputs = rows.checked_mul(output_len).ok_or_else(|| {
+        RusticolError::invalid_argument("SymJIT output buffer length overflows usize")
+    })?;
+    if params_len != expected_params {
+        return Err(RusticolError::invalid_argument(format!(
+            "parameter buffer has length {params_len}, expected {expected_params}"
+        )));
+    }
+    if output_buffer_len != expected_outputs {
+        return Err(RusticolError::invalid_argument(format!(
+            "output buffer has length {output_buffer_len}, expected {expected_outputs}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_aosoa_lengths(
+    block_count: usize,
+    lane_width: usize,
+    input_len: usize,
+    output_len: usize,
+    params_len: usize,
+    output_buffer_len: usize,
+) -> RusticolResult<()> {
+    let scalar_lanes = lane_width.checked_mul(2).ok_or_else(|| {
+        RusticolError::invalid_argument("SymJIT AoSoA complex lane count overflows usize")
+    })?;
+    let expected_params = block_count
+        .checked_mul(input_len)
+        .and_then(|count| count.checked_mul(scalar_lanes))
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("SymJIT AoSoA parameter buffer length overflows usize")
+        })?;
+    let expected_outputs = block_count
+        .checked_mul(output_len)
+        .and_then(|count| count.checked_mul(scalar_lanes))
+        .ok_or_else(|| {
+            RusticolError::invalid_argument("SymJIT AoSoA output buffer length overflows usize")
+        })?;
+    if params_len != expected_params {
+        return Err(RusticolError::invalid_argument(format!(
+            "AoSoA parameter buffer has length {params_len}, expected {expected_params}"
+        )));
+    }
+    if output_buffer_len != expected_outputs {
+        return Err(RusticolError::invalid_argument(format!(
+            "AoSoA output buffer has length {output_buffer_len}, expected {expected_outputs}"
+        )));
+    }
+    Ok(())
+}
+
+fn complex_slice_as_scalars<T>(values: &[Complex<T>]) -> &[T] {
+    assert_eq!(
+        std::mem::size_of::<Complex<T>>(),
+        2 * std::mem::size_of::<T>(),
+        "complex storage must be two adjacent scalars"
+    );
+    assert_eq!(
+        std::mem::align_of::<Complex<T>>(),
+        std::mem::align_of::<T>(),
+        "complex storage must use scalar alignment"
+    );
+    // SAFETY: Both supported Complex implementations are repr(C) structs containing exactly
+    // adjacent `re` and `im` fields. The size/alignment assertions guard this runtime contract.
+    unsafe { std::slice::from_raw_parts(values.as_ptr().cast::<T>(), values.len() * 2) }
+}
+
+fn complex_slice_as_scalars_mut<T>(values: &mut [Complex<T>]) -> &mut [T] {
+    assert_eq!(
+        std::mem::size_of::<Complex<T>>(),
+        2 * std::mem::size_of::<T>(),
+        "complex storage must be two adjacent scalars"
+    );
+    assert_eq!(
+        std::mem::align_of::<Complex<T>>(),
+        std::mem::align_of::<T>(),
+        "complex storage must use scalar alignment"
+    );
+    // SAFETY: See complex_slice_as_scalars. The mutable borrow guarantees exclusive access.
+    unsafe { std::slice::from_raw_parts_mut(values.as_mut_ptr().cast::<T>(), values.len() * 2) }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use symjit::{Compiler, CompilerType, Storage};
+
+    fn application_bytes() -> Vec<u8> {
+        let mut config = Config::new(CompilerType::Native, 0).unwrap();
+        config.set_complex(true);
+        config.set_symbolica(true);
+        config.set_opt_level(3);
+        config.set_simd(true);
+        let mut compiler = Compiler::with_config(config);
+        let instructions = r#"[[{"Add":[{"Out":0},[{"Param":0},{"Param":1}],0]}],1,[]]"#;
+        let application = compiler.translate(instructions.to_string(), 2).unwrap();
+        let mut bytes = Vec::new();
+        application.save(&mut bytes).unwrap();
+        bytes
+    }
+
+    fn metadata<'a>(required_defuns: &'a [String]) -> SymjitApplicationMetadata<'a> {
+        SymjitApplicationMetadata {
+            runtime_capability: SYMJIT_APPLICATION_RUNTIME_CAPABILITY,
+            application_abi: SYMJIT_APPLICATION_STORAGE_ABI,
+            input_len: 2,
+            output_len: 1,
+            element_layout: "complex-f64",
+            batch_layout: "row-major",
+            compiler_type: "native",
+            translation_mode: "indirect",
+            optimization_level: 3,
+            word_bits: 64,
+            endianness: "little",
+            required_defuns,
+        }
+    }
+
+    fn nonnative_config(optimization_level: u8) -> Config {
+        let compiler_type = if cfg!(target_arch = "aarch64") {
+            CompilerType::Amd
+        } else {
+            CompilerType::Arm
+        };
+        let mut config = Config::new(compiler_type, 0).unwrap();
+        config.set_complex(true);
+        config.set_symbolica(true);
+        config.set_direct(false);
+        config.set_opt_level(optimization_level);
+        config
+    }
+
+    fn write_application(bytes: &[u8], suffix: &str) -> PathBuf {
+        let path = std::env::temp_dir().join(format!(
+            "rusticol-symjit-{}-{suffix}.symjit",
+            std::process::id()
+        ));
+        let mut file = fs::File::create(&path).unwrap();
+        file.write_all(bytes).unwrap();
+        path
+    }
+
+    fn direct_manifest(application_path: String) -> EvaluatorManifest {
+        EvaluatorManifest::SymjitApplication {
+            runtime_capability: SYMJIT_APPLICATION_RUNTIME_CAPABILITY.to_string(),
+            application_path,
+            application_abi: SYMJIT_APPLICATION_STORAGE_ABI.to_string(),
+            input_len: 2,
+            output_len: 1,
+            element_layout: "complex-f64".to_string(),
+            batch_layout: "row-major".to_string(),
+            compiler_type: "native".to_string(),
+            translation_mode: "indirect".to_string(),
+            optimization_level: 3,
+            word_bits: 64,
+            endianness: "little".to_string(),
+            required_defuns: Vec::new(),
+            plane_application: None,
+            evaluator_state_path: Some("absent-exact-evaluator-state.bin".to_string()),
+            evaluator_state_runtime_capability: Some(
+                SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY.to_string(),
+            ),
+        }
+    }
+
+    fn pack_aosoa(
+        params: &[Complex<f64>],
+        batch_size: usize,
+        input_len: usize,
+        lane_width: usize,
+    ) -> Vec<f64> {
+        assert!(batch_size != 0);
+        let block_count = batch_size.div_ceil(lane_width);
+        let mut packed = vec![0.0; block_count * input_len * 2 * lane_width];
+        for block in 0..block_count {
+            for lane in 0..lane_width {
+                let row = (block * lane_width + lane).min(batch_size - 1);
+                for input in 0..input_len {
+                    let value = params[row * input_len + input];
+                    let start = (block * input_len + input) * 2 * lane_width;
+                    packed[start + lane] = value.re;
+                    packed[start + lane_width + lane] = value.im;
+                }
+            }
+        }
+        packed
+    }
+
+    fn unpack_aosoa(
+        packed: &[f64],
+        batch_size: usize,
+        output_len: usize,
+        lane_width: usize,
+    ) -> Vec<Complex<f64>> {
+        let mut outputs = Vec::with_capacity(batch_size * output_len);
+        for row in 0..batch_size {
+            let block = row / lane_width;
+            let lane = row % lane_width;
+            for output in 0..output_len {
+                let start = (block * output_len + output) * 2 * lane_width;
+                outputs.push(Complex::new(
+                    packed[start + lane],
+                    packed[start + lane_width + lane],
+                ));
+            }
+        }
+        outputs
+    }
+
+    #[test]
+    fn direct_application_loads_and_evaluates_complex_batches() {
+        let path = write_application(&application_bytes(), "batch");
+        let mut evaluator = SymjitApplicationEvaluator::load(&path, metadata(&[])).unwrap();
+        let params = [
+            Complex::new(1.0, 2.0),
+            Complex::new(3.0, 4.0),
+            Complex::new(-2.0, 1.5),
+            Complex::new(5.0, -0.5),
+        ];
+        let mut outputs = [Complex::new(0.0, 0.0); 2];
+        evaluator.evaluate_batch(2, &params, &mut outputs).unwrap();
+        assert_eq!(outputs[0], Complex::new(4.0, 6.0));
+        assert_eq!(outputs[1], Complex::new(3.0, 1.0));
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn direct_aosoa_blocks_match_complete_row_major_batches() {
+        let path = write_application(&application_bytes(), "aosoa-complete");
+        let mut evaluator = SymjitApplicationEvaluator::load(&path, metadata(&[])).unwrap();
+        let Some(lane_width) = evaluator.simd_lane_width() else {
+            let _ = fs::remove_file(path);
+            return;
+        };
+        let batch_size = 2 * lane_width;
+        let mut params = Vec::with_capacity(batch_size * 2);
+        for row in 0..batch_size {
+            params.extend([
+                Complex::new(row as f64 + 0.25, -(row as f64) - 0.5),
+                Complex::new(2.0 * row as f64 + 1.0, row as f64 + 0.75),
+            ]);
+        }
+        let mut expected = vec![Complex::new(0.0, 0.0); batch_size];
+        evaluator
+            .evaluate_batch(batch_size, &params, &mut expected)
+            .unwrap();
+
+        let packed = pack_aosoa(&params, batch_size, 2, lane_width);
+        let mut packed_outputs = vec![0.0; 2 * lane_width * 2];
+        assert!(
+            evaluator
+                .evaluate_aosoa_blocks(2, &packed, &mut packed_outputs)
+                .unwrap()
+        );
+        assert_eq!(
+            unpack_aosoa(&packed_outputs, batch_size, 1, lane_width),
+            expected
+        );
+
+        assert!(
+            evaluator
+                .evaluate_aosoa_blocks(2, &packed[..packed.len() - 1], &mut packed_outputs)
+                .is_err()
+        );
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn direct_aosoa_blocks_match_padded_row_major_tails() {
+        let path = write_application(&application_bytes(), "aosoa-tail");
+        let mut evaluator = SymjitApplicationEvaluator::load(&path, metadata(&[])).unwrap();
+        let Some(lane_width) = evaluator.simd_lane_width() else {
+            let _ = fs::remove_file(path);
+            return;
+        };
+        let batch_size = lane_width + 1;
+        let mut params = Vec::with_capacity(batch_size * 2);
+        for row in 0..batch_size {
+            params.extend([
+                Complex::new(row as f64 + 1.0, row as f64 + 2.0),
+                Complex::new(-(row as f64) - 3.0, 0.5 * row as f64),
+            ]);
+        }
+        let mut expected = vec![Complex::new(0.0, 0.0); batch_size];
+        evaluator
+            .evaluate_batch(batch_size, &params, &mut expected)
+            .unwrap();
+
+        let block_count = batch_size.div_ceil(lane_width);
+        let packed = pack_aosoa(&params, batch_size, 2, lane_width);
+        let mut packed_outputs = vec![0.0; block_count * lane_width * 2];
+        assert!(
+            evaluator
+                .evaluate_aosoa_blocks(block_count, &packed, &mut packed_outputs)
+                .unwrap()
+        );
+        assert_eq!(
+            unpack_aosoa(&packed_outputs, batch_size, 1, lane_width),
+            expected
+        );
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn direct_application_pads_incomplete_simd_tails() {
+        let path = write_application(&application_bytes(), "simd-tail");
+        let mut evaluator = SymjitApplicationEvaluator::load(&path, metadata(&[])).unwrap();
+        let lane_width = super::super::native_f64_simd_lane_width();
+        let batch_size = lane_width.saturating_add(1);
+        let mut params = Vec::with_capacity(batch_size * 2);
+        let mut expected = Vec::with_capacity(batch_size);
+        for row in 0..batch_size {
+            let left = Complex::new(row as f64 + 1.0, 2.0);
+            let right = Complex::new(3.0, -(row as f64));
+            params.extend([left, right]);
+            expected.push(left + right);
+        }
+        let mut outputs = vec![Complex::new(0.0, 0.0); batch_size];
+        evaluator
+            .evaluate_batch(batch_size, &params, &mut outputs)
+            .unwrap();
+        assert_eq!(outputs, expected);
+        if lane_width > 1 {
+            assert_eq!(evaluator.input_tail_scratch.len(), lane_width * 2);
+            assert_eq!(evaluator.output_tail_scratch.len(), lane_width);
+        }
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn direct_f64_group_load_does_not_read_exact_fallback_state() {
+        let path = write_application(&application_bytes(), "lazy-exact");
+        let root = path.parent().unwrap();
+        let manifest = direct_manifest(path.file_name().unwrap().to_str().unwrap().to_string());
+
+        let capabilities = evaluator_runtime_capabilities(&manifest).unwrap();
+        assert_eq!(
+            capabilities,
+            BTreeSet::from([SYMJIT_APPLICATION_RUNTIME_CAPABILITY.to_string()])
+        );
+
+        let mut group = EvaluatorGroup::load(&manifest, root).unwrap();
+        let output = group
+            .evaluate_batch(1, &[Complex::new(2.0, 3.0), Complex::new(5.0, 7.0)])
+            .unwrap();
+        assert_eq!(output, vec![Complex::new(7.0, 10.0)]);
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn chunked_group_gathers_mapped_parent_inputs() {
+        let path = write_application(&application_bytes(), "mapped-inputs");
+        let root = path.parent().unwrap();
+        let application_path = path.file_name().unwrap().to_str().unwrap().to_string();
+        let manifest = EvaluatorManifest::Chunked {
+            required_runtime_capabilities: vec![SYMJIT_APPLICATION_RUNTIME_CAPABILITY.to_string()],
+            input_len: Some(3),
+            chunk_input_indices: Some(vec![vec![0, 2], vec![1, 2]]),
+            chunks: vec![
+                direct_manifest(application_path.clone()),
+                direct_manifest(application_path),
+            ],
+        };
+
+        let mut group = EvaluatorGroup::load(&manifest, root).unwrap();
+        let output = group
+            .evaluate_batch(
+                2,
+                &[
+                    Complex::new(1.0, 0.0),
+                    Complex::new(10.0, 0.0),
+                    Complex::new(3.0, 0.0),
+                    Complex::new(2.0, 0.0),
+                    Complex::new(20.0, 0.0),
+                    Complex::new(5.0, 0.0),
+                ],
+            )
+            .unwrap();
+
+        assert_eq!(
+            output,
+            vec![
+                Complex::new(4.0, 0.0),
+                Complex::new(13.0, 0.0),
+                Complex::new(7.0, 0.0),
+                Complex::new(25.0, 0.0),
+            ]
+        );
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn chunked_group_copies_contiguous_mapped_input_spans() {
+        let path = write_application(&application_bytes(), "mapped-input-spans");
+        let root = path.parent().unwrap();
+        let application_path = path.file_name().unwrap().to_str().unwrap().to_string();
+        let manifest = EvaluatorManifest::Chunked {
+            required_runtime_capabilities: vec![SYMJIT_APPLICATION_RUNTIME_CAPABILITY.to_string()],
+            input_len: Some(4),
+            chunk_input_indices: Some(vec![vec![0, 1], vec![2, 3]]),
+            chunks: vec![
+                direct_manifest(application_path.clone()),
+                direct_manifest(application_path),
+            ],
+        };
+
+        let mut group = EvaluatorGroup::load(&manifest, root).unwrap();
+        assert_eq!(
+            group.input_mapping_spans,
+            vec![vec![(0, 0, 2)], vec![(0, 2, 2)]]
+        );
+        let output = group
+            .evaluate_batch(
+                2,
+                &[
+                    Complex::new(1.0, 0.0),
+                    Complex::new(3.0, 0.0),
+                    Complex::new(10.0, 0.0),
+                    Complex::new(30.0, 0.0),
+                    Complex::new(2.0, 0.0),
+                    Complex::new(5.0, 0.0),
+                    Complex::new(20.0, 0.0),
+                    Complex::new(50.0, 0.0),
+                ],
+            )
+            .unwrap();
+
+        assert_eq!(
+            output,
+            vec![
+                Complex::new(4.0, 0.0),
+                Complex::new(40.0, 0.0),
+                Complex::new(7.0, 0.0),
+                Complex::new(70.0, 0.0),
+            ]
+        );
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn legacy_chunked_group_reuses_full_parent_inputs() {
+        let path = write_application(&application_bytes(), "legacy-chunks");
+        let root = path.parent().unwrap();
+        let application_path = path.file_name().unwrap().to_str().unwrap().to_string();
+        let manifest = EvaluatorManifest::Chunked {
+            required_runtime_capabilities: vec![SYMJIT_APPLICATION_RUNTIME_CAPABILITY.to_string()],
+            input_len: None,
+            chunk_input_indices: None,
+            chunks: vec![
+                direct_manifest(application_path.clone()),
+                direct_manifest(application_path),
+            ],
+        };
+
+        let mut group = EvaluatorGroup::load(&manifest, root).unwrap();
+        let output = group
+            .evaluate_batch(1, &[Complex::new(2.0, 3.0), Complex::new(5.0, 7.0)])
+            .unwrap();
+
+        assert_eq!(
+            output,
+            vec![Complex::new(7.0, 10.0), Complex::new(7.0, 10.0)]
+        );
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn direct_f64_group_loads_without_exact_fallback_metadata() {
+        let path = write_application(&application_bytes(), "no-exact-fallback");
+        let root = path.parent().unwrap();
+        let mut manifest = direct_manifest(path.file_name().unwrap().to_str().unwrap().to_string());
+        let EvaluatorManifest::SymjitApplication {
+            evaluator_state_path,
+            evaluator_state_runtime_capability,
+            ..
+        } = &mut manifest
+        else {
+            unreachable!()
+        };
+        *evaluator_state_path = None;
+        *evaluator_state_runtime_capability = None;
+
+        let mut group = EvaluatorGroup::load(&manifest, root).unwrap();
+        let output = group
+            .evaluate_batch(1, &[Complex::new(2.0, 3.0), Complex::new(5.0, 7.0)])
+            .unwrap();
+
+        assert_eq!(output, vec![Complex::new(7.0, 10.0)]);
+        let _ = fs::remove_file(path);
+    }
+
+    #[cfg(not(feature = "symbolica-runtime"))]
+    #[test]
+    fn unsupported_legacy_jit_evaluator_is_rejected_before_payload_access() {
+        let manifest = EvaluatorManifest::Jit {
+            runtime_capability: SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY.to_string(),
+            input_len: 2,
+            output_len: 1,
+            evaluator_state_path: "absent-legacy-jit-state.bin".to_string(),
+        };
+
+        let error = match EvaluatorGroup::load(&manifest, Path::new("/absent-artifact-root")) {
+            Ok(_) => panic!("unsupported capability must win over absent payload"),
+            Err(error) => error,
+        };
+        assert_eq!(
+            error.kind(),
+            crate::RusticolErrorKind::UnsupportedRuntimeCapability
+        );
+    }
+
+    #[cfg(not(feature = "f64-compiled"))]
+    #[test]
+    fn unsupported_compiled_evaluators_are_rejected_before_payload_access() {
+        let manifests = [
+            EvaluatorManifest::CompiledComplex {
+                runtime_capability: SYMBOLICA_COMPILED_CPP_RUNTIME_CAPABILITY.to_string(),
+                function_name: "evaluate".to_string(),
+                input_len: 2,
+                output_len: 1,
+                library_path: "absent-cpp-library.so".to_string(),
+                evaluator_state_path: None,
+                number_type: "complex".to_string(),
+                native_direct_application: None,
+            },
+            EvaluatorManifest::CompiledComplex {
+                runtime_capability: SYMBOLICA_COMPILED_ASM_RUNTIME_CAPABILITY.to_string(),
+                function_name: "evaluate".to_string(),
+                input_len: 2,
+                output_len: 1,
+                library_path: "absent-asm-library.so".to_string(),
+                evaluator_state_path: None,
+                number_type: "complex".to_string(),
+                native_direct_application: None,
+            },
+        ];
+
+        for manifest in manifests {
+            let error = match EvaluatorGroup::load(&manifest, Path::new("/absent-artifact-root")) {
+                Ok(_) => panic!("unsupported capability must win over absent payload"),
+                Err(error) => error,
+            };
+            assert_eq!(
+                error.kind(),
+                crate::RusticolErrorKind::UnsupportedRuntimeCapability
+            );
+        }
+    }
+
+    #[test]
+    fn malformed_application_bytes_are_rejected() {
+        let path = write_application(b"not-a-symjit-application", "malformed");
+        let error = SymjitApplicationEvaluator::load(&path, metadata(&[])).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn cross_architecture_application_accepts_o1_o2_only() {
+        for optimization_level in [1, 2] {
+            let mut metadata = metadata(&[]);
+            metadata.optimization_level = optimization_level;
+            validate_application_config(
+                Path::new("portable.symjit"),
+                &nonnative_config(optimization_level),
+                &metadata,
+            )
+            .unwrap();
+        }
+
+        for optimization_level in [0, 3] {
+            let mut metadata = metadata(&[]);
+            metadata.optimization_level = optimization_level;
+            let error = validate_application_config(
+                Path::new("target-specific.symjit"),
+                &nonnative_config(optimization_level),
+                &metadata,
+            )
+            .unwrap_err();
+            assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+            assert!(error.to_string().contains("optimization level 1 or 2"));
+        }
+    }
+
+    #[test]
+    fn symjit_panic_payloads_retain_dependency_context() {
+        assert_eq!(
+            panic_detail(Box::new(String::from(
+                "architecture-specific register allocation"
+            ))),
+            "architecture-specific register allocation"
+        );
+    }
+
+    #[test]
+    fn direct_application_requires_complex_f64_row_major_layout() {
+        let path = write_application(&application_bytes(), "layout");
+
+        let mut wrong_element_layout = metadata(&[]);
+        wrong_element_layout.element_layout = "complex-f32";
+        let error = SymjitApplicationEvaluator::load(&path, wrong_element_layout).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+
+        let mut wrong_batch_layout = metadata(&[]);
+        wrong_batch_layout.batch_layout = "column-major";
+        let error = SymjitApplicationEvaluator::load(&path, wrong_batch_layout).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn capability_counts_and_external_functions_are_validated() {
+        let bytes = application_bytes();
+        let path = write_application(&bytes, "metadata");
+
+        let mut wrong_counts = metadata(&[]);
+        wrong_counts.output_len = 2;
+        let error = SymjitApplicationEvaluator::load(&path, wrong_counts).unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+
+        let functions = vec!["model_function".to_string()];
+        let error = SymjitApplicationEvaluator::load(&path, metadata(&functions)).unwrap_err();
+        assert_eq!(
+            error.kind(),
+            crate::RusticolErrorKind::UnsupportedRuntimeCapability
+        );
+
+        let mut wrong_capability = metadata(&[]);
+        wrong_capability.runtime_capability = SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY;
+        let error = SymjitApplicationEvaluator::load(&path, wrong_capability).unwrap_err();
+        assert_eq!(
+            error.kind(),
+            crate::RusticolErrorKind::UnsupportedRuntimeCapability
+        );
+        let _ = fs::remove_file(path);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_compiled_direct.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_compiled_direct.rs
new file mode 100644
index 0000000000..dac23814bb
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_compiled_direct.rs
@@ -0,0 +1,904 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Compiled-stage adapter for standard SymJIT direct-arena P-kernels.
+//!
+//! pyAmpliCol owns the fused-stage binding policy. SymJIT owns only the
+//! ordinary P-kernel prologue, invariant body, and epilogue. Point-dependent
+//! values bind directly to persistent arena planes. Point-independent inputs
+//! bind through persistent broadcast planes which are refreshed only when the
+//! backing model parameter changes.
+
+use std::path::{Path, PathBuf};
+use std::ptr;
+
+use super::symjit_plane::{
+    PlaneDescriptor, SymjitPlaneKernel, SymjitPlaneLayout, SymjitPlaneTable,
+};
+use crate::direct_arena::{
+    AlignedF64Buffer, DirectArenaAllocationCounters, DirectArenaView, DirectFactorView,
+    DirectMomentumView, DirectParameterView, validate_direct_views,
+};
+use crate::engine::SYMJIT_PLANE_APPLICATION_ABI;
+use crate::{RusticolError, RusticolResult};
+
+/// One split-complex plane in the persistent compiled-stage arena.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub(crate) enum CompiledDirectArenaPlane {
+    Current { component: u32, imaginary: bool },
+    Amplitude { component: u32, imaginary: bool },
+}
+
+/// One point-dependent input consumed by a fused compiled stage.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub(crate) enum CompiledDirectPlaneBinding {
+    Arena(CompiledDirectArenaPlane),
+    Momentum {
+        form: u32,
+        lorentz_component: u16,
+    },
+    /// The runtime-owned persistent structural-zero plane.
+    Zero,
+}
+
+/// One point-independent scalar consumed by a fused compiled stage.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum CompiledDirectScalarBinding {
+    Parameter {
+        index: u32,
+        imaginary: bool,
+    },
+    // The plane ABI supports persistent literal broadcasts even though the
+    // current production lowering emits parameter bindings only.
+    #[allow(dead_code)]
+    Literal(f64),
+}
+
+/// One distinct output plane overwritten by a fused compiled stage.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub(crate) struct CompiledDirectOutputBinding(pub CompiledDirectArenaPlane);
+
+/// Routing from the P-kernel's split input order to runtime plane catalogs.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum CompiledDirectSourceInputBinding {
+    Plane(u32),
+    Scalar(u32),
+}
+
+/// Loaded but not yet pinned compiled-stage P-kernel.
+pub(crate) struct LoadedSymjitCompiledDirectStage {
+    kernel: SymjitPlaneKernel,
+    source_input_bindings: Box<[CompiledDirectSourceInputBinding]>,
+    input_bindings: Box<[CompiledDirectPlaneBinding]>,
+    scalar_bindings: Box<[CompiledDirectScalarBinding]>,
+    output_bindings: Box<[CompiledDirectOutputBinding]>,
+    display_path: PathBuf,
+}
+
+#[derive(Clone, Copy)]
+enum BroadcastSource {
+    Parameter { value: *const f64, cached_bits: u64 },
+    Literal,
+}
+
+/// A cold-bound P-kernel descriptor table for one persistent compiled arena.
+///
+/// The unsafe bind contract guarantees that external arena, momentum,
+/// parameter, and zero-plane allocations remain fixed until this object drops.
+pub(crate) struct BoundSymjitCompiledDirectStage {
+    kernel: SymjitPlaneKernel,
+    table: SymjitPlaneTable<'static>,
+    broadcast_values: AlignedF64Buffer,
+    broadcast_sources: Box<[BroadcastSource]>,
+    point_stride: u32,
+    pending_broadcast_fill_bytes: u64,
+    display_path: PathBuf,
+}
+
+impl LoadedSymjitCompiledDirectStage {
+    pub(crate) const fn broadcast_plane_count(&self) -> usize {
+        self.scalar_bindings.len()
+    }
+
+    /// Load one persisted standard complex P-kernel and authenticate its
+    /// pyAmpliCol-owned split-plane routing.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn load_source_bytes(
+        bytes: &[u8],
+        display_path: impl AsRef<Path>,
+        source_application_abi: &str,
+        source_optimization_level: u8,
+        source_compression: bool,
+        source_input_bindings: Vec<CompiledDirectSourceInputBinding>,
+        input_bindings: Vec<CompiledDirectPlaneBinding>,
+        scalar_bindings: Vec<CompiledDirectScalarBinding>,
+        output_bindings: Vec<CompiledDirectOutputBinding>,
+    ) -> RusticolResult<Self> {
+        let display_path = display_path.as_ref().to_path_buf();
+        if source_application_abi != SYMJIT_PLANE_APPLICATION_ABI {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported compiled plane application ABI \
+                 {source_application_abi:?}; expected \
+                 {SYMJIT_PLANE_APPLICATION_ABI:?}; regenerate the artifact"
+            )));
+        }
+        validate_static_bindings(
+            &source_input_bindings,
+            &input_bindings,
+            &scalar_bindings,
+            &output_bindings,
+        )?;
+        let input_complex_count = source_input_bindings.len() / 2;
+        let output_complex_count = output_bindings.len() / 2;
+        let kernel = SymjitPlaneKernel::load_bytes(
+            bytes,
+            display_path.clone(),
+            SymjitPlaneLayout::complex(input_complex_count, output_complex_count),
+        )?;
+        if kernel.optimization_level() != source_optimization_level {
+            return Err(RusticolError::integrity(format!(
+                "compiled plane application {} declares optimization level \
+                 {source_optimization_level} but stores optimization level {}",
+                display_path.display(),
+                kernel.optimization_level()
+            )));
+        }
+        if kernel.compression() != source_compression {
+            return Err(RusticolError::integrity(format!(
+                "compiled plane application {} declares compression \
+                 {source_compression} but stores compression {}; regenerate the artifact",
+                display_path.display(),
+                kernel.compression()
+            )));
+        }
+        if kernel.input_plane_count() != source_input_bindings.len()
+            || kernel.output_plane_count() != output_bindings.len()
+        {
+            return Err(RusticolError::integrity(format!(
+                "compiled plane application {} shape disagrees with its bindings",
+                display_path.display()
+            )));
+        }
+        Ok(Self {
+            kernel,
+            source_input_bindings: source_input_bindings.into_boxed_slice(),
+            input_bindings: input_bindings.into_boxed_slice(),
+            scalar_bindings: scalar_bindings.into_boxed_slice(),
+            output_bindings: output_bindings.into_boxed_slice(),
+            display_path,
+        })
+    }
+
+    /// Pin this stage to persistent Direct-Arena storage.
+    ///
+    /// # Safety
+    ///
+    /// Every allocation referenced by `arena`, `momenta`, `parameters`, and
+    /// `zero_plane` must remain allocated at the same address until the
+    /// returned stage is dropped. Parameter values may change only between
+    /// calls to `evaluate`. No other access may overlap a kernel invocation.
+    #[cfg(test)]
+    pub(crate) unsafe fn bind(
+        self,
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+        zero_plane: &AlignedF64Buffer,
+    ) -> RusticolResult<BoundSymjitCompiledDirectStage> {
+        // SAFETY: this is the identity-layout specialization of the complete
+        // fixed-storage contract above.
+        unsafe { self.bind_with_current_map(arena, momenta, parameters, zero_plane, &[]) }
+    }
+
+    /// Pin canonical current IDs through a cold immutable physical map.
+    ///
+    /// # Safety
+    ///
+    /// Every allocation addressed by `arena`, `momenta`, `parameters`, and
+    /// `zero_plane` must remain live and at a stable address until the returned
+    /// bound stage drops. `current_component_map` must remain immutable for
+    /// this call. No access may race with stage execution; model-parameter
+    /// updates must use the runtime's synchronized update path.
+    pub(crate) unsafe fn bind_with_current_map(
+        self,
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+        zero_plane: &AlignedF64Buffer,
+        current_component_map: &[u32],
+    ) -> RusticolResult<BoundSymjitCompiledDirectStage> {
+        validate_direct_views(
+            arena,
+            momenta,
+            parameters,
+            DirectFactorView {
+                values_re: ptr::null(),
+                values_im: ptr::null(),
+                value_count: 0,
+            },
+        )?;
+        validate_mapped_bindings(
+            &self.input_bindings,
+            &self.output_bindings,
+            current_component_map,
+        )?;
+
+        let point_stride = arena.point_stride;
+        let stride = point_stride as usize;
+        if zero_plane.len() != stride {
+            return Err(RusticolError::integrity(format!(
+                "compiled shared zero plane has length {}, expected {point_stride}",
+                zero_plane.len()
+            )));
+        }
+        if zero_plane.as_slice().iter().any(|value| *value != 0.0) {
+            return Err(RusticolError::integrity(
+                "compiled shared zero plane contains a nonzero value",
+            ));
+        }
+
+        let broadcast_len = self
+            .scalar_bindings
+            .len()
+            .checked_mul(stride)
+            .ok_or_else(|| {
+                RusticolError::integrity("compiled scalar broadcast storage overflows usize")
+            })?;
+        let mut broadcast_values =
+            AlignedF64Buffer::zeroed(broadcast_len, "compiled scalar broadcasts")?;
+        let mut broadcast_sources = Vec::new();
+        broadcast_sources
+            .try_reserve_exact(self.scalar_bindings.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate compiled scalar broadcast metadata: {error}"
+                ))
+            })?;
+        for (slot, binding) in self.scalar_bindings.iter().copied().enumerate() {
+            let (value, source) = match binding {
+                CompiledDirectScalarBinding::Parameter { index, imaginary } => {
+                    if index >= parameters.value_count {
+                        return Err(RusticolError::integrity(format!(
+                            "compiled parameter binding {index} is out of bounds"
+                        )));
+                    }
+                    let base = if imaginary {
+                        parameters.values_im
+                    } else {
+                        parameters.values_re
+                    };
+                    // SAFETY: the parameter view was validated above and the
+                    // checked index lies in its fixed allocation.
+                    let value_pointer = unsafe { base.add(index as usize) };
+                    // SAFETY: the pointer remains live by the bind contract.
+                    let initial = unsafe { *value_pointer };
+                    (
+                        initial,
+                        BroadcastSource::Parameter {
+                            value: value_pointer,
+                            cached_bits: initial.to_bits(),
+                        },
+                    )
+                }
+                CompiledDirectScalarBinding::Literal(value) => (value, BroadcastSource::Literal),
+            };
+            let start = slot * stride;
+            broadcast_values.as_mut_slice()[start..start + stride].fill(value);
+            broadcast_sources.push(source);
+        }
+
+        let mut resolved_inputs = Vec::new();
+        resolved_inputs
+            .try_reserve_exact(self.input_bindings.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate compiled input-plane catalog: {error}"
+                ))
+            })?;
+        for binding in self.input_bindings.iter().copied() {
+            resolved_inputs.push(resolve_input_plane_pointer(
+                binding,
+                arena,
+                momenta,
+                zero_plane,
+                current_component_map,
+            )?);
+        }
+
+        let descriptor_count = self
+            .source_input_bindings
+            .len()
+            .checked_add(self.output_bindings.len())
+            .ok_or_else(|| {
+                RusticolError::integrity("compiled plane descriptor count overflows usize")
+            })?;
+        let mut descriptors = Vec::new();
+        descriptors
+            .try_reserve_exact(descriptor_count)
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate compiled P-kernel descriptors: {error}"
+                ))
+            })?;
+        let broadcast_base = broadcast_values.as_mut_ptr();
+        for source in self.source_input_bindings.iter().copied() {
+            let pointer = match source {
+                CompiledDirectSourceInputBinding::Plane(index) => resolved_inputs[index as usize],
+                CompiledDirectSourceInputBinding::Scalar(index) => {
+                    // SAFETY: static binding validation proved this scalar
+                    // index and the multiplication above proved the allocation.
+                    unsafe { broadcast_base.add(index as usize * stride) }
+                }
+            };
+            // SAFETY: every resolved pointer covers one complete fixed plane
+            // and remains live for the bound stage lifetime.
+            descriptors.push(unsafe { PlaneDescriptor::from_cached_raw_parts(pointer, stride)? });
+        }
+        for output in self.output_bindings.iter().copied() {
+            let pointer = resolve_arena_plane_pointer(output.0, arena, current_component_map)?;
+            // SAFETY: mapped output validation proves distinct complete planes
+            // which remain live for the bound stage lifetime.
+            descriptors.push(unsafe { PlaneDescriptor::from_cached_raw_parts(pointer, stride)? });
+        }
+        let table = self.kernel.build_raw_table_from_descriptors(&descriptors)?;
+        let initial_fill_bytes = u64::try_from(broadcast_len)
+            .unwrap_or(u64::MAX)
+            .saturating_mul(std::mem::size_of::<f64>() as u64);
+        Ok(BoundSymjitCompiledDirectStage {
+            kernel: self.kernel,
+            table,
+            broadcast_values,
+            broadcast_sources: broadcast_sources.into_boxed_slice(),
+            point_stride,
+            pending_broadcast_fill_bytes: initial_fill_bytes,
+            display_path: self.display_path,
+        })
+    }
+}
+
+impl BoundSymjitCompiledDirectStage {
+    pub(crate) fn allocation_counters(&self) -> DirectArenaAllocationCounters {
+        self.broadcast_values.allocation_counters()
+    }
+
+    /// Evaluate a point range directly into its disjoint output planes.
+    ///
+    /// The returned byte count is internal scalar-broadcast traffic. It is
+    /// deliberately separate from boundary pack/gather/scatter counters.
+    pub(crate) fn evaluate(&mut self, point_start: u32, point_count: u32) -> RusticolResult<u64> {
+        if point_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "compiled Direct-Arena point count must be positive",
+            ));
+        }
+        let point_stop = point_start.checked_add(point_count).ok_or_else(|| {
+            RusticolError::invalid_argument("compiled Direct-Arena point range overflows u32")
+        })?;
+        if point_stop > self.point_stride {
+            return Err(RusticolError::invalid_argument(format!(
+                "compiled Direct-Arena point range {point_start}..{point_stop} \
+                 exceeds physical stride {}",
+                self.point_stride
+            )));
+        }
+
+        let mut fill_bytes = self.pending_broadcast_fill_bytes;
+        self.pending_broadcast_fill_bytes = 0;
+        let stride = self.point_stride as usize;
+        let values = self.broadcast_values.as_mut_slice();
+        for (slot, source) in self.broadcast_sources.iter_mut().enumerate() {
+            let BroadcastSource::Parameter { value, cached_bits } = source else {
+                continue;
+            };
+            // SAFETY: the bind contract keeps the parameter allocation live,
+            // and evaluation has exclusive synchronized access.
+            let current = unsafe { **value };
+            if current.to_bits() == *cached_bits {
+                continue;
+            }
+            let start = slot * stride;
+            values[start..start + stride].fill(current);
+            *cached_bits = current.to_bits();
+            fill_bytes = fill_bytes.saturating_add(
+                u64::try_from(stride)
+                    .unwrap_or(u64::MAX)
+                    .saturating_mul(std::mem::size_of::<f64>() as u64),
+            );
+        }
+        self.kernel
+            .execute_table(&mut self.table, point_start as usize, point_count as usize)
+            .map_err(|error| {
+                RusticolError::evaluation(format!(
+                    "compiled plane application {} failed: {}",
+                    self.display_path.display(),
+                    error.message()
+                ))
+            })?;
+        Ok(fill_bytes)
+    }
+}
+
+fn validate_static_bindings(
+    sources: &[CompiledDirectSourceInputBinding],
+    inputs: &[CompiledDirectPlaneBinding],
+    scalars: &[CompiledDirectScalarBinding],
+    outputs: &[CompiledDirectOutputBinding],
+) -> RusticolResult<()> {
+    if sources.is_empty() || !sources.len().is_multiple_of(2) {
+        return Err(RusticolError::integrity(
+            "compiled P-kernel split input binding count must be positive and even",
+        ));
+    }
+    if outputs.is_empty() || !outputs.len().is_multiple_of(2) {
+        return Err(RusticolError::integrity(
+            "compiled P-kernel split output binding count must be positive and even",
+        ));
+    }
+    for (index, source) in sources.iter().copied().enumerate() {
+        let valid = match source {
+            CompiledDirectSourceInputBinding::Plane(slot) => (slot as usize) < inputs.len(),
+            CompiledDirectSourceInputBinding::Scalar(slot) => (slot as usize) < scalars.len(),
+        };
+        if !valid {
+            return Err(RusticolError::integrity(format!(
+                "compiled P-kernel source input binding {index} is out of bounds"
+            )));
+        }
+    }
+    for (index, output) in outputs.iter().copied().enumerate() {
+        if outputs[..index].contains(&output) {
+            return Err(RusticolError::integrity(format!(
+                "compiled P-kernel output binding {index} aliases an earlier output"
+            )));
+        }
+        if inputs.contains(&CompiledDirectPlaneBinding::Arena(output.0)) {
+            return Err(RusticolError::integrity(format!(
+                "compiled P-kernel output binding {index} aliases an input plane"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_mapped_bindings(
+    inputs: &[CompiledDirectPlaneBinding],
+    outputs: &[CompiledDirectOutputBinding],
+    current_component_map: &[u32],
+) -> RusticolResult<()> {
+    let mapped_inputs = inputs
+        .iter()
+        .copied()
+        .filter_map(|binding| match binding {
+            CompiledDirectPlaneBinding::Arena(arena) => {
+                Some(map_arena_plane(arena, current_component_map))
+            }
+            CompiledDirectPlaneBinding::Momentum { .. } | CompiledDirectPlaneBinding::Zero => None,
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let mut mapped_outputs = Vec::with_capacity(outputs.len());
+    for (index, output) in outputs.iter().copied().enumerate() {
+        let mapped = map_arena_plane(output.0, current_component_map)?;
+        if mapped_outputs.contains(&mapped) {
+            return Err(RusticolError::integrity(format!(
+                "compiled P-kernel mapped output binding {index} aliases an earlier output"
+            )));
+        }
+        if mapped_inputs.contains(&mapped) {
+            return Err(RusticolError::integrity(format!(
+                "compiled P-kernel mapped output binding {index} aliases an input plane"
+            )));
+        }
+        mapped_outputs.push(mapped);
+    }
+    Ok(())
+}
+
+fn map_arena_plane(
+    binding: CompiledDirectArenaPlane,
+    current_component_map: &[u32],
+) -> RusticolResult<CompiledDirectArenaPlane> {
+    match binding {
+        CompiledDirectArenaPlane::Current {
+            component,
+            imaginary,
+        } if !current_component_map.is_empty() => {
+            let physical = current_component_map
+                .get(component as usize)
+                .copied()
+                .filter(|physical| *physical != u32::MAX)
+                .ok_or_else(|| {
+                    RusticolError::integrity(format!(
+                        "compiled current binding {component} has no physical mapping"
+                    ))
+                })?;
+            Ok(CompiledDirectArenaPlane::Current {
+                component: physical,
+                imaginary,
+            })
+        }
+        _ => Ok(binding),
+    }
+}
+
+fn resolve_input_plane_pointer(
+    binding: CompiledDirectPlaneBinding,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    zero_plane: &AlignedF64Buffer,
+    current_component_map: &[u32],
+) -> RusticolResult<*mut f64> {
+    match binding {
+        CompiledDirectPlaneBinding::Arena(binding) => {
+            resolve_arena_plane_pointer(binding, arena, current_component_map)
+        }
+        CompiledDirectPlaneBinding::Momentum {
+            form,
+            lorentz_component,
+        } => {
+            if form >= momenta.form_count || lorentz_component >= momenta.lorentz_component_count {
+                return Err(RusticolError::integrity(format!(
+                    "compiled momentum binding ({form}, {lorentz_component}) is out of bounds"
+                )));
+            }
+            let component = form
+                .checked_mul(u32::from(momenta.lorentz_component_count))
+                .and_then(|base| base.checked_add(u32::from(lorentz_component)))
+                .ok_or_else(|| {
+                    RusticolError::integrity("compiled momentum component overflows u32")
+                })?;
+            let offset = usize::try_from(component)
+                .ok()
+                .and_then(|component| component.checked_mul(momenta.point_stride as usize))
+                .ok_or_else(|| {
+                    RusticolError::integrity("compiled momentum offset overflows usize")
+                })?;
+            // SAFETY: the momentum view and component bounds were validated.
+            Ok(unsafe { momenta.values.add(offset) }.cast_mut())
+        }
+        CompiledDirectPlaneBinding::Zero => Ok(zero_plane.as_ptr().cast_mut()),
+    }
+}
+
+fn resolve_arena_plane_pointer(
+    binding: CompiledDirectArenaPlane,
+    arena: DirectArenaView,
+    current_component_map: &[u32],
+) -> RusticolResult<*mut f64> {
+    let binding = map_arena_plane(binding, current_component_map)?;
+    let (base, shape, label) = match binding {
+        CompiledDirectArenaPlane::Current {
+            component,
+            imaginary,
+        } => (
+            if imaginary {
+                arena.current_im
+            } else {
+                arena.current_re
+            },
+            arena.current_shape()?,
+            ("current", component),
+        ),
+        CompiledDirectArenaPlane::Amplitude {
+            component,
+            imaginary,
+        } => (
+            if imaginary {
+                arena.amplitude_im
+            } else {
+                arena.amplitude_re
+            },
+            arena.amplitude_shape()?,
+            ("amplitude", component),
+        ),
+    };
+    let offset = shape.checked_scalar_index(label.1, 0, label.0)?;
+    // SAFETY: shape validation and the checked offset prove one complete
+    // pitched plane begins at this pointer.
+    Ok(unsafe { base.add(offset) })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::symjit_direct::tests::count_allocations;
+    use super::super::symjit_plane::compile_symbolica_program_to_plane_application_bytes;
+    use super::*;
+    use crate::RusticolErrorKind;
+    use crate::direct_arena::{DirectArenaWorkspace, DirectMomentumView};
+
+    const MODEL: &str = "
+([('fun', ('temp', 0), 'square', [], [('param', 0)], False),
+  ('add', ('temp', 1), [('temp', 0), ('param', 1)], 0),
+  ('assign', ('out', 0), ('temp', 1))],
+ 2,
+ [])
+";
+
+    fn application_bytes(level: u8) -> Vec<u8> {
+        compile_symbolica_program_to_plane_application_bytes(MODEL, 2, 1, level, true).unwrap()
+    }
+
+    fn momentum_view(values: &AlignedF64Buffer, point_stride: u32) -> DirectMomentumView {
+        DirectMomentumView {
+            values: values.as_ptr(),
+            scalar_len: values.len() as u64,
+            form_count: 1,
+            lorentz_component_count: 4,
+            point_stride,
+        }
+    }
+
+    fn loaded(level: u8) -> LoadedSymjitCompiledDirectStage {
+        try_loaded(level, true).unwrap()
+    }
+
+    fn try_loaded(
+        level: u8,
+        expected_compression: bool,
+    ) -> RusticolResult<LoadedSymjitCompiledDirectStage> {
+        LoadedSymjitCompiledDirectStage::load_source_bytes(
+            &application_bytes(level),
+            format!("compiled-plane-o{level}.symjit"),
+            SYMJIT_PLANE_APPLICATION_ABI,
+            level,
+            expected_compression,
+            vec![
+                CompiledDirectSourceInputBinding::Plane(0),
+                CompiledDirectSourceInputBinding::Plane(1),
+                CompiledDirectSourceInputBinding::Scalar(0),
+                CompiledDirectSourceInputBinding::Scalar(1),
+            ],
+            vec![
+                CompiledDirectPlaneBinding::Arena(CompiledDirectArenaPlane::Current {
+                    component: 0,
+                    imaginary: false,
+                }),
+                CompiledDirectPlaneBinding::Arena(CompiledDirectArenaPlane::Current {
+                    component: 0,
+                    imaginary: true,
+                }),
+            ],
+            vec![
+                CompiledDirectScalarBinding::Parameter {
+                    index: 0,
+                    imaginary: false,
+                },
+                CompiledDirectScalarBinding::Parameter {
+                    index: 0,
+                    imaginary: true,
+                },
+            ],
+            vec![
+                CompiledDirectOutputBinding(CompiledDirectArenaPlane::Current {
+                    component: 1,
+                    imaginary: false,
+                }),
+                CompiledDirectOutputBinding(CompiledDirectArenaPlane::Current {
+                    component: 1,
+                    imaginary: true,
+                }),
+            ],
+        )
+    }
+
+    #[test]
+    fn compiled_plane_stage_refreshes_parameters_and_allocates_zero_when_warm() {
+        const POINTS: usize = 1025;
+        const ODD_TAIL_LENGTHS: &[usize] = &[127, 129, 1023, 1025];
+        let loaded = loaded(3);
+        assert!(matches!(loaded.kernel.simd_lanes(), 1 | 2 | 4));
+        let mut workspace = DirectArenaWorkspace::new(2, 0, POINTS as u32).unwrap();
+        workspace.begin_tile(POINTS as u32).unwrap();
+        let stride = workspace.point_stride() as usize;
+        {
+            let (current_re, current_im, _, _) = workspace.split_slices_mut();
+            for point in 0..POINTS {
+                current_re[point] = 0.25 + point as f64 / 32.0;
+                current_im[point] = -0.5 + point as f64 / 64.0;
+            }
+            current_re[stride..2 * stride].fill(f64::NAN);
+            current_im[stride..2 * stride].fill(f64::NAN);
+        }
+        let momenta = AlignedF64Buffer::zeroed(4 * stride, "compiled test momenta").unwrap();
+        let zero = AlignedF64Buffer::zeroed(stride, "compiled test zero").unwrap();
+        let mut parameter_re = [1.5];
+        let mut parameter_im = [-0.75];
+        let parameters = DirectParameterView {
+            values_re: parameter_re.as_ptr(),
+            values_im: parameter_im.as_ptr(),
+            value_count: 1,
+        };
+        let arena = workspace.view().unwrap();
+        let mut bound = unsafe {
+            loaded.bind(
+                arena,
+                momentum_view(&momenta, arena.point_stride),
+                parameters,
+                &zero,
+            )
+        }
+        .unwrap();
+
+        let initial_bytes = bound.evaluate(1, 127).unwrap();
+        assert_eq!(initial_bytes, (2 * stride * 8) as u64);
+        {
+            let (current_re, current_im) = workspace.current_slices();
+            assert!(current_re[stride].is_nan());
+            assert!(current_im[stride].is_nan());
+            assert!(current_re[stride + 128].is_nan());
+            assert!(current_im[stride + 128].is_nan());
+            for point in 1..128 {
+                let xr = current_re[point];
+                let xi = current_im[point];
+                assert_eq!(
+                    current_re[stride + point],
+                    xr * xr - xi * xi + parameter_re[0]
+                );
+                assert_eq!(current_im[stride + point], 2.0 * xr * xi + parameter_im[0]);
+            }
+        }
+
+        for (case, &points) in ODD_TAIL_LENGTHS.iter().enumerate() {
+            parameter_re[0] = -2.0 - case as f64;
+            parameter_im[0] = 0.375 + case as f64 / 8.0;
+            {
+                let (current_re, current_im, _, _) = workspace.split_slices_mut();
+                current_re[stride..2 * stride].fill(f64::NAN);
+                current_im[stride..2 * stride].fill(f64::NAN);
+            }
+            let (refresh, refresh_allocations, refresh_bytes) =
+                count_allocations(|| bound.evaluate(0, points as u32));
+            assert_eq!(refresh.unwrap(), (2 * stride * 8) as u64);
+            assert_eq!(
+                (refresh_allocations, refresh_bytes),
+                (0, 0),
+                "compiled parameter refresh allocated for {points} points"
+            );
+            let (cached, cached_allocations, cached_bytes) =
+                count_allocations(|| bound.evaluate(0, points as u32));
+            assert_eq!(cached.unwrap(), 0);
+            assert_eq!(
+                (cached_allocations, cached_bytes),
+                (0, 0),
+                "warmed compiled call allocated for {points} points"
+            );
+
+            let (current_re, current_im) = workspace.current_slices();
+            for point in 0..points {
+                let xr = current_re[point];
+                let xi = current_im[point];
+                assert_eq!(
+                    current_re[stride + point],
+                    xr * xr - xi * xi + parameter_re[0]
+                );
+                assert_eq!(current_im[stride + point], 2.0 * xr * xi + parameter_im[0]);
+            }
+            if points < POINTS {
+                assert!(current_re[stride + points].is_nan());
+                assert!(current_im[stride + points].is_nan());
+            }
+        }
+    }
+
+    #[test]
+    fn compiled_plane_stage_accepts_o0_through_o3_and_rejects_old_abi() {
+        for level in 0..=3 {
+            let stage = loaded(level);
+            assert_eq!(stage.kernel.optimization_level(), level);
+        }
+        let error = LoadedSymjitCompiledDirectStage::load_source_bytes(
+            &application_bytes(2),
+            "old-plane-application.symjit",
+            "pyamplicol-symjit-plane-application-v1",
+            2,
+            true,
+            vec![
+                CompiledDirectSourceInputBinding::Plane(0),
+                CompiledDirectSourceInputBinding::Plane(1),
+                CompiledDirectSourceInputBinding::Scalar(0),
+                CompiledDirectSourceInputBinding::Scalar(1),
+            ],
+            vec![
+                CompiledDirectPlaneBinding::Zero,
+                CompiledDirectPlaneBinding::Zero,
+            ],
+            vec![
+                CompiledDirectScalarBinding::Literal(1.0),
+                CompiledDirectScalarBinding::Literal(0.0),
+            ],
+            vec![
+                CompiledDirectOutputBinding(CompiledDirectArenaPlane::Current {
+                    component: 0,
+                    imaginary: false,
+                }),
+                CompiledDirectOutputBinding(CompiledDirectArenaPlane::Current {
+                    component: 0,
+                    imaginary: true,
+                }),
+            ],
+        )
+        .err()
+        .expect("old ABI must fail closed");
+        assert_eq!(error.kind(), RusticolErrorKind::Compatibility);
+        assert!(error.message().contains("regenerate"));
+    }
+
+    #[test]
+    fn authenticated_manifest_compression_mismatch_fails_closed() {
+        let error = try_loaded(2, false)
+            .err()
+            .expect("a manifest/application compression mismatch must fail closed");
+        assert!(error.message().contains("compression"));
+        assert!(error.message().contains("regenerate"));
+    }
+
+    #[test]
+    fn static_and_mapped_output_aliases_fail_before_execution() {
+        let bytes = application_bytes(2);
+        let error = LoadedSymjitCompiledDirectStage::load_source_bytes(
+            &bytes,
+            "static-alias.symjit",
+            SYMJIT_PLANE_APPLICATION_ABI,
+            2,
+            true,
+            vec![
+                CompiledDirectSourceInputBinding::Plane(0),
+                CompiledDirectSourceInputBinding::Plane(1),
+                CompiledDirectSourceInputBinding::Scalar(0),
+                CompiledDirectSourceInputBinding::Scalar(1),
+            ],
+            vec![
+                CompiledDirectPlaneBinding::Arena(CompiledDirectArenaPlane::Current {
+                    component: 0,
+                    imaginary: false,
+                }),
+                CompiledDirectPlaneBinding::Arena(CompiledDirectArenaPlane::Current {
+                    component: 0,
+                    imaginary: true,
+                }),
+            ],
+            vec![
+                CompiledDirectScalarBinding::Literal(0.0),
+                CompiledDirectScalarBinding::Literal(0.0),
+            ],
+            vec![
+                CompiledDirectOutputBinding(CompiledDirectArenaPlane::Current {
+                    component: 0,
+                    imaginary: false,
+                }),
+                CompiledDirectOutputBinding(CompiledDirectArenaPlane::Current {
+                    component: 1,
+                    imaginary: true,
+                }),
+            ],
+        )
+        .err()
+        .expect("input/output alias must fail");
+        assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+
+        let loaded = loaded(2);
+        let mut workspace = DirectArenaWorkspace::new(2, 0, 8).unwrap();
+        workspace.begin_tile(8).unwrap();
+        let stride = workspace.point_stride() as usize;
+        let momenta = AlignedF64Buffer::zeroed(4 * stride, "mapped test momenta").unwrap();
+        let zero = AlignedF64Buffer::zeroed(stride, "mapped test zero").unwrap();
+        let parameter_re = [0.0];
+        let parameter_im = [0.0];
+        let parameters = DirectParameterView {
+            values_re: parameter_re.as_ptr(),
+            values_im: parameter_im.as_ptr(),
+            value_count: 1,
+        };
+        let arena = workspace.view().unwrap();
+        let error = unsafe {
+            loaded.bind_with_current_map(
+                arena,
+                momentum_view(&momenta, arena.point_stride),
+                parameters,
+                &zero,
+                &[0, 0],
+            )
+        }
+        .err()
+        .expect("mapped alias must fail");
+        assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_direct.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_direct.rs
new file mode 100644
index 0000000000..fef0d0731d
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_direct.rs
@@ -0,0 +1,3349 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Recurrence adapter for standard SymJIT direct-arena P-kernels.
+//!
+//! The adapter deliberately owns the recurrence policy which used to live in
+//! pyAmpliCol's SymJIT fork. Proven-disjoint identity overwrites bind ordinary
+//! P-kernel outputs directly to their arena destinations. Every accumulation,
+//! non-identity factor, and before-write alias instead evaluates once into
+//! persistent split-complex scratch planes, after which Rusticol applies the
+//! exact complex factor and role-specific overwrite/add policy. Inputs which
+//! are scalar at recurrence runtime are represented by persistent broadcast
+//! planes and refreshed only when their value changes.
+
+use super::symjit_plane::{
+    PlaneDescriptor, SymjitPlaneKernel, SymjitPlaneLayout, SymjitPlaneTable,
+};
+use crate::recurrence::direct_backend::{
+    DIRECT_STATUS_OK, DirectArenaView, DirectClosureExecutor, DirectContributionExecutor,
+    DirectExecutorHandle, DirectFactorView, DirectFinalizationExecutor, DirectMomentumView,
+    DirectParameterView, record_direct_executor_error_detail,
+};
+use crate::recurrence::{
+    DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION, DIRECT_NONE_U32, DirectClosureRow,
+    DirectContributionRow, DirectExecutorRole, DirectFinalizationRow,
+};
+use crate::{RusticolError, RusticolResult};
+use std::cell::{Cell, RefCell};
+use std::collections::HashMap;
+use std::ffi::{c_int, c_void};
+use std::hash::{Hash, Hasher};
+use std::mem::size_of;
+use std::panic::{AssertUnwindSafe, catch_unwind};
+use std::path::PathBuf;
+use std::ptr;
+#[cfg(target_arch = "aarch64")]
+use wide::f64x2;
+#[cfg(target_arch = "x86_64")]
+use wide::f64x4;
+
+pub(crate) const SYMJIT_RECURRENCE_PLANE_APPLICATION_ABI: &str =
+    "pyamplicol-symjit-plane-application-v2";
+
+const STATUS_INVALID_CONTEXT: c_int = 1;
+const STATUS_INVALID_ARGUMENT: c_int = 2;
+const STATUS_ROLE_MISMATCH: c_int = 3;
+const STATUS_EXECUTION_FAILED: c_int = 4;
+
+/// One model-fixed arena-plane projection.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum SymjitDirectPlaneProjection {
+    ParentCurrent {
+        parent: u8,
+        component: u16,
+        imaginary: bool,
+    },
+    Momentum {
+        operand: u8,
+        lorentz_component: u16,
+    },
+    DestinationCurrent {
+        component: u16,
+        imaginary: bool,
+    },
+    DestinationAmplitude {
+        component: u16,
+        imaginary: bool,
+    },
+}
+
+/// One model-fixed scalar projection used to fill a broadcast plane.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum SymjitDirectScalarProjection {
+    Parameter { index: u32, imaginary: bool },
+    ExactFactor { imaginary: bool },
+    Literal(f64),
+}
+
+/// Maps one split source-input plane in the P-kernel to recurrence storage.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum SymjitDirectParameterBinding {
+    Plane { index: u32 },
+    Broadcast { index: u32 },
+}
+
+/// Owns the context addressed by a [`DirectExecutorHandle`].
+pub(crate) struct LoadedSymjitDirectExecutor {
+    context: Box<SymjitDirectExecutorContext>,
+}
+
+struct SymjitDirectExecutorContext {
+    role: DirectExecutorRole,
+    kernel: SymjitPlaneKernel,
+    parameter_bindings: Box<[SymjitDirectParameterBinding]>,
+    input_planes: Box<[SymjitDirectPlaneProjection]>,
+    scalars: Box<[SymjitDirectScalarProjection]>,
+    output_destinations: Box<[u32]>,
+    broadcast_slot_by_binding: Box<[Option<u32>]>,
+    broadcast_scalar_by_slot: Box<[u32]>,
+    exact_factor_broadcast_slots: Box<[usize]>,
+    scalar_workspace: RefCell<PlaneWorkspace>,
+    tiled_workspace: RefCell<PlaneWorkspace>,
+    internal_scratch_bytes: Cell<u64>,
+    internal_broadcast_bytes: Cell<u64>,
+    #[cfg(test)]
+    invariant_broadcast_resolution_count: Cell<u64>,
+    #[cfg(test)]
+    exact_factor_broadcast_resolution_count: Cell<u64>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct DescriptorStorageIdentity {
+    current_re: usize,
+    current_im: usize,
+    current_scalar_len: u64,
+    amplitude_re: usize,
+    amplitude_im: usize,
+    amplitude_scalar_len: u64,
+    point_stride: u32,
+    momenta: usize,
+    momentum_scalar_len: u64,
+    momentum_form_count: u32,
+    momentum_lorentz_component_count: u16,
+}
+
+impl DescriptorStorageIdentity {
+    fn new(arena: DirectArenaView, momenta: DirectMomentumView) -> Self {
+        Self {
+            current_re: arena.current_re.addr(),
+            current_im: arena.current_im.addr(),
+            current_scalar_len: arena.current_scalar_len,
+            amplitude_re: arena.amplitude_re.addr(),
+            amplitude_im: arena.amplitude_im.addr(),
+            amplitude_scalar_len: arena.amplitude_scalar_len,
+            point_stride: arena.point_stride,
+            momenta: momenta.values.addr(),
+            momentum_scalar_len: momenta.scalar_len,
+            momentum_form_count: momenta.form_count,
+            momentum_lorentz_component_count: momenta.lorentz_component_count,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct RowTableIdentity {
+    role: DirectExecutorRole,
+    address: usize,
+    row_count: u32,
+}
+
+impl Hash for RowTableIdentity {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        (self.role as u16).hash(state);
+        self.address.hash(state);
+        self.row_count.hash(state);
+    }
+}
+
+const ROW_GROUP_LINEAR_LOOKUP_LIMIT: usize = 4;
+
+struct CachedRowGroup {
+    identity: RowTableIdentity,
+    rows: Vec<CachedRowTables>,
+    descriptor_bytes: usize,
+}
+
+struct CachedRowTables {
+    scratch: SymjitPlaneTable<'static>,
+    direct: Option<SymjitPlaneTable<'static>>,
+}
+
+/// Hot storage owned by one loaded recurrence executor.
+///
+/// Every cached table contains only the generic raw descriptors exposed by the
+/// SymJIT patch. Multiple tables may therefore name the same persistent
+/// scratch/broadcast planes without constructing overlapping Rust references;
+/// the executor calls them strictly sequentially.
+#[derive(Default)]
+struct PlaneWorkspace {
+    storage: Option<DescriptorStorageIdentity>,
+    row_groups: Vec<CachedRowGroup>,
+    row_group_indices: HashMap<RowTableIdentity, usize>,
+    descriptor_bytes: usize,
+    scratch: Vec<f64>,
+    broadcasts: Vec<f64>,
+    broadcast_value_bits: Vec<Option<u64>>,
+    point_stride: usize,
+}
+
+impl PlaneWorkspace {
+    fn invalidate_row_tables(&mut self) {
+        self.row_groups.clear();
+        self.row_group_indices.clear();
+        self.storage = None;
+        self.descriptor_bytes = 0;
+    }
+
+    fn cached_row_group_index(&self, identity: RowTableIdentity) -> Option<usize> {
+        // The usual full-schedule cache has only a few entries. Varied runtime
+        // selections can add many row slices, which must not slow warm lookup.
+        if self.row_groups.len() <= ROW_GROUP_LINEAR_LOOKUP_LIMIT {
+            self.row_groups
+                .iter()
+                .position(|cached| cached.identity == identity)
+        } else {
+            self.row_group_indices.get(&identity).copied()
+        }
+    }
+
+    fn cache_row_group(&mut self, cached: CachedRowGroup) -> RusticolResult<usize> {
+        let total_bytes =
+            checked_descriptor_cache_bytes(self.descriptor_bytes, cached.descriptor_bytes)?;
+        self.row_groups.try_reserve(1).map_err(|error| {
+            RusticolError::compatibility(format!(
+                "could not reserve recurrence descriptor row group: {error}"
+            ))
+        })?;
+        let index = self.row_groups.len();
+        if index >= ROW_GROUP_LINEAR_LOOKUP_LIMIT {
+            let additional = if index == ROW_GROUP_LINEAR_LOOKUP_LIMIT {
+                index + 1
+            } else {
+                1
+            };
+            self.row_group_indices
+                .try_reserve(additional)
+                .map_err(|error| {
+                    RusticolError::compatibility(format!(
+                        "could not reserve recurrence descriptor row index: {error}"
+                    ))
+                })?;
+            if index == ROW_GROUP_LINEAR_LOOKUP_LIMIT {
+                self.row_group_indices.extend(
+                    self.row_groups
+                        .iter()
+                        .enumerate()
+                        .map(|(index, cached)| (cached.identity, index)),
+                );
+            }
+            self.row_group_indices.insert(cached.identity, index);
+        }
+        self.descriptor_bytes = total_bytes;
+        self.row_groups.push(cached);
+        Ok(index)
+    }
+
+    fn prepare(
+        &mut self,
+        point_stride: usize,
+        input_plane_count: usize,
+        output_plane_count: usize,
+        broadcast_plane_count: usize,
+    ) -> RusticolResult<()> {
+        let descriptor_count = input_plane_count
+            .checked_add(output_plane_count)
+            .ok_or_else(|| RusticolError::internal("recurrence descriptor count overflows"))?;
+        let expected_scratch = output_plane_count
+            .checked_mul(point_stride)
+            .ok_or_else(|| RusticolError::internal("recurrence scratch size overflows"))?;
+        let expected_broadcasts = broadcast_plane_count
+            .checked_mul(point_stride)
+            .ok_or_else(|| RusticolError::internal("recurrence broadcast size overflows"))?;
+        if self.point_stride == point_stride
+            && self.scratch.len() == expected_scratch
+            && self.broadcasts.len() == expected_broadcasts
+        {
+            return Ok(());
+        }
+
+        // Drop every raw table before replacing its backing storage.
+        self.invalidate_row_tables();
+        let mut scratch = Vec::new();
+        scratch
+            .try_reserve_exact(expected_scratch)
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate recurrence scratch planes: {error}"
+                ))
+            })?;
+        scratch.resize(expected_scratch, 0.0);
+        let mut broadcasts = Vec::new();
+        broadcasts
+            .try_reserve_exact(expected_broadcasts)
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate recurrence broadcast planes: {error}"
+                ))
+            })?;
+        broadcasts.resize(expected_broadcasts, 0.0);
+        let mut broadcast_value_bits = Vec::new();
+        broadcast_value_bits
+            .try_reserve_exact(broadcast_plane_count)
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate recurrence broadcast cache: {error}"
+                ))
+            })?;
+        broadcast_value_bits.resize(broadcast_plane_count, None);
+        self.scratch = scratch;
+        self.broadcasts = broadcasts;
+        self.broadcast_value_bits = broadcast_value_bits;
+        self.point_stride = point_stride;
+        debug_assert_eq!(descriptor_count, input_plane_count + output_plane_count);
+        Ok(())
+    }
+
+    fn broadcast_pointer(&mut self, slot: usize, value: f64) -> RusticolResult<(*mut f64, bool)> {
+        let start = slot
+            .checked_mul(self.point_stride)
+            .ok_or_else(|| RusticolError::internal("broadcast plane offset overflows"))?;
+        let end = start
+            .checked_add(self.point_stride)
+            .ok_or_else(|| RusticolError::internal("broadcast plane range overflows"))?;
+        let plane = self.broadcasts.get_mut(start..end).ok_or_else(|| {
+            RusticolError::internal("broadcast plane is outside its persistent workspace")
+        })?;
+        let bits = value.to_bits();
+        let cached = self.broadcast_value_bits.get_mut(slot).ok_or_else(|| {
+            RusticolError::internal("broadcast cache slot is outside its workspace")
+        })?;
+        let refreshed = *cached != Some(bits);
+        if refreshed {
+            plane.fill(value);
+            *cached = Some(bits);
+        }
+        Ok((plane.as_mut_ptr(), refreshed))
+    }
+
+    fn scratch_pointer(&mut self, plane: usize) -> RusticolResult<*mut f64> {
+        let start = plane
+            .checked_mul(self.point_stride)
+            .ok_or_else(|| RusticolError::internal("scratch plane offset overflows"))?;
+        let end = start
+            .checked_add(self.point_stride)
+            .ok_or_else(|| RusticolError::internal("scratch plane range overflows"))?;
+        self.scratch
+            .get_mut(start..end)
+            .map(<[f64]>::as_mut_ptr)
+            .ok_or_else(|| RusticolError::internal("scratch plane is outside its workspace"))
+    }
+
+    fn broadcast_plane_pointer(&mut self, slot: usize) -> RusticolResult<*mut f64> {
+        let start = slot
+            .checked_mul(self.point_stride)
+            .ok_or_else(|| RusticolError::internal("broadcast plane offset overflows"))?;
+        let end = start
+            .checked_add(self.point_stride)
+            .ok_or_else(|| RusticolError::internal("broadcast plane range overflows"))?;
+        self.broadcasts
+            .get_mut(start..end)
+            .map(<[f64]>::as_mut_ptr)
+            .ok_or_else(|| RusticolError::internal("broadcast plane is outside its workspace"))
+    }
+}
+
+impl LoadedSymjitDirectExecutor {
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn load_prepared_application_bytes(
+        bytes: &[u8],
+        display_path: PathBuf,
+        application_abi: &str,
+        expected_optimization_level: u32,
+        expected_compression: bool,
+        role: DirectExecutorRole,
+        parameter_bindings: Vec<SymjitDirectParameterBinding>,
+        input_planes: Vec<SymjitDirectPlaneProjection>,
+        scalars: Vec<SymjitDirectScalarProjection>,
+        output_destinations: Vec<u32>,
+    ) -> RusticolResult<Self> {
+        if role == DirectExecutorRole::Source {
+            return Err(RusticolError::compatibility(
+                "recurrence source executors are Rusticol SourceIR intrinsics, not SymJIT plane applications",
+            ));
+        }
+        if application_abi != SYMJIT_RECURRENCE_PLANE_APPLICATION_ABI {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported recurrence SymJIT plane-application ABI {application_abi:?}; regenerate the prepared model with this pyAmpliCol version"
+            )));
+        }
+        if !parameter_bindings.len().is_multiple_of(2)
+            || !output_destinations.len().is_multiple_of(2)
+        {
+            return Err(RusticolError::integrity(
+                "recurrence SymJIT split-complex binding has an odd plane count",
+            ));
+        }
+        let layout =
+            SymjitPlaneLayout::complex(parameter_bindings.len() / 2, output_destinations.len() / 2);
+        let kernel = SymjitPlaneKernel::load_bytes(bytes, display_path.clone(), layout)?;
+        if u32::from(kernel.optimization_level()) != expected_optimization_level {
+            return Err(RusticolError::integrity(format!(
+                "recurrence SymJIT plane application {} stores optimization level {}, but its \
+                 authenticated template declares optimization level \
+                 {expected_optimization_level}; regenerate the prepared model",
+                display_path.display(),
+                kernel.optimization_level(),
+            )));
+        }
+        if kernel.compression() != expected_compression {
+            return Err(RusticolError::integrity(format!(
+                "recurrence SymJIT plane application {} stores compression {}, but its \
+                 authenticated prepared-kernel manifest declares compression \
+                 {expected_compression}; regenerate the prepared model",
+                display_path.display(),
+                kernel.compression(),
+            )));
+        }
+        validate_binding(
+            &kernel,
+            role,
+            &parameter_bindings,
+            &input_planes,
+            &scalars,
+            &output_destinations,
+        )?;
+
+        // A structured evaluator may bind one scalar projection to several
+        // source planes (most commonly the shared structural-zero projection).
+        // Intern those occurrences on the cold path so duplicate descriptors
+        // address one persistent broadcast plane.
+        let mut slot_by_scalar = Vec::new();
+        slot_by_scalar
+            .try_reserve_exact(scalars.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate recurrence scalar slot map: {error}"
+                ))
+            })?;
+        slot_by_scalar.resize(scalars.len(), None);
+        let mut broadcast_scalar_by_slot = Vec::new();
+        broadcast_scalar_by_slot
+            .try_reserve_exact(scalars.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate recurrence broadcast scalar catalog: {error}"
+                ))
+            })?;
+        let mut broadcast_slot_by_binding = Vec::new();
+        broadcast_slot_by_binding
+            .try_reserve_exact(parameter_bindings.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate recurrence broadcast binding map: {error}"
+                ))
+            })?;
+        for binding in &parameter_bindings {
+            let SymjitDirectParameterBinding::Broadcast { index } = *binding else {
+                broadcast_slot_by_binding.push(None);
+                continue;
+            };
+            let scalar_index = index as usize;
+            let slot = if let Some(slot) = slot_by_scalar[scalar_index] {
+                slot
+            } else {
+                let slot = u32::try_from(broadcast_scalar_by_slot.len()).map_err(|_| {
+                    RusticolError::integrity(
+                        "recurrence persistent broadcast plane count exceeds u32",
+                    )
+                })?;
+                slot_by_scalar[scalar_index] = Some(slot);
+                broadcast_scalar_by_slot.push(index);
+                slot
+            };
+            broadcast_slot_by_binding.push(Some(slot));
+        }
+        let mut exact_factor_broadcast_slots = Vec::new();
+        exact_factor_broadcast_slots
+            .try_reserve_exact(broadcast_scalar_by_slot.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate recurrence exact-factor broadcast catalog: {error}"
+                ))
+            })?;
+        for (slot, &scalar_index) in broadcast_scalar_by_slot.iter().enumerate() {
+            match scalars.get(scalar_index as usize).ok_or_else(|| {
+                RusticolError::integrity("recurrence scalar projection is out of bounds")
+            })? {
+                SymjitDirectScalarProjection::Literal(_)
+                | SymjitDirectScalarProjection::Parameter { .. } => {}
+                SymjitDirectScalarProjection::ExactFactor { .. } => {
+                    exact_factor_broadcast_slots.push(slot);
+                }
+            }
+        }
+
+        Ok(Self {
+            context: Box::new(SymjitDirectExecutorContext {
+                role,
+                kernel,
+                parameter_bindings: parameter_bindings.into_boxed_slice(),
+                input_planes: input_planes.into_boxed_slice(),
+                scalars: scalars.into_boxed_slice(),
+                output_destinations: output_destinations.into_boxed_slice(),
+                broadcast_slot_by_binding: broadcast_slot_by_binding.into_boxed_slice(),
+                broadcast_scalar_by_slot: broadcast_scalar_by_slot.into_boxed_slice(),
+                exact_factor_broadcast_slots: exact_factor_broadcast_slots.into_boxed_slice(),
+                scalar_workspace: RefCell::new(PlaneWorkspace::default()),
+                tiled_workspace: RefCell::new(PlaneWorkspace::default()),
+                internal_scratch_bytes: Cell::new(0),
+                internal_broadcast_bytes: Cell::new(0),
+                #[cfg(test)]
+                invariant_broadcast_resolution_count: Cell::new(0),
+                #[cfg(test)]
+                exact_factor_broadcast_resolution_count: Cell::new(0),
+            }),
+        })
+    }
+
+    pub(crate) fn handle(&self) -> DirectExecutorHandle {
+        let context = ptr::from_ref(self.context.as_ref()).cast();
+        match self.context.role {
+            DirectExecutorRole::Contribution => DirectExecutorHandle::Contribution {
+                call: execute_contribution_rows as DirectContributionExecutor,
+                context,
+            },
+            DirectExecutorRole::Finalization => DirectExecutorHandle::Finalization {
+                call: execute_finalization_rows as DirectFinalizationExecutor,
+                context,
+            },
+            DirectExecutorRole::Closure => DirectExecutorHandle::Closure {
+                call: execute_closure_rows as DirectClosureExecutor,
+                context,
+            },
+            DirectExecutorRole::Source => {
+                unreachable!("source roles are rejected while loading a SymJIT plane executor")
+            }
+        }
+    }
+
+    /// Drop every cached table that borrows Direct-Arena row/storage pointers.
+    pub(crate) fn invalidate_row_tables(&self) -> RusticolResult<()> {
+        let mut scalar = self
+            .context
+            .scalar_workspace
+            .try_borrow_mut()
+            .map_err(|_| {
+                RusticolError::internal(
+                    "cannot invalidate recurrence SymJIT row tables during an active call",
+                )
+            })?;
+        let mut tiled = self.context.tiled_workspace.try_borrow_mut().map_err(|_| {
+            RusticolError::internal(
+                "cannot invalidate recurrence SymJIT row tables during an active call",
+            )
+        })?;
+        scalar.invalidate_row_tables();
+        tiled.invalidate_row_tables();
+        Ok(())
+    }
+
+    pub(crate) fn internal_traffic_bytes(&self) -> (u64, u64) {
+        (
+            self.context.internal_scratch_bytes.get(),
+            self.context.internal_broadcast_bytes.get(),
+        )
+    }
+
+    #[cfg(test)]
+    fn simd_lane_width(&self) -> usize {
+        self.context.kernel.simd_lanes()
+    }
+
+    #[cfg(test)]
+    fn cached_direct_table_count(&self) -> usize {
+        [
+            &self.context.scalar_workspace,
+            &self.context.tiled_workspace,
+        ]
+        .into_iter()
+        .map(|workspace| {
+            workspace
+                .borrow()
+                .row_groups
+                .iter()
+                .flat_map(|group| &group.rows)
+                .filter(|row| row.direct.is_some())
+                .count()
+        })
+        .sum()
+    }
+
+    #[cfg(test)]
+    fn broadcast_plane_count(&self) -> usize {
+        self.context.broadcast_scalar_by_slot.len()
+    }
+
+    #[cfg(test)]
+    fn broadcast_resolution_counts(&self) -> (u64, u64) {
+        (
+            self.context.invariant_broadcast_resolution_count.get(),
+            self.context.exact_factor_broadcast_resolution_count.get(),
+        )
+    }
+}
+
+fn validate_binding(
+    kernel: &SymjitPlaneKernel,
+    role: DirectExecutorRole,
+    parameter_bindings: &[SymjitDirectParameterBinding],
+    input_planes: &[SymjitDirectPlaneProjection],
+    scalars: &[SymjitDirectScalarProjection],
+    output_destinations: &[u32],
+) -> RusticolResult<()> {
+    if parameter_bindings.len() != kernel.input_plane_count()
+        || output_destinations.len() != kernel.output_plane_count()
+    {
+        return Err(RusticolError::integrity(
+            "recurrence plane binding shape does not match its SymJIT P-kernel",
+        ));
+    }
+    if scalars.first() != Some(&SymjitDirectScalarProjection::ExactFactor { imaginary: false })
+        || scalars.get(1) != Some(&SymjitDirectScalarProjection::ExactFactor { imaginary: true })
+    {
+        return Err(RusticolError::integrity(
+            "recurrence scalar sources 0 and 1 must be the exact factor real and imaginary values",
+        ));
+    }
+    for binding in parameter_bindings {
+        match *binding {
+            SymjitDirectParameterBinding::Plane { index }
+                if index as usize >= input_planes.len() =>
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence P-kernel input plane projection is out of bounds",
+                ));
+            }
+            SymjitDirectParameterBinding::Broadcast { index }
+                if index as usize >= scalars.len() =>
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence P-kernel broadcast projection is out of bounds",
+                ));
+            }
+            _ => {}
+        }
+    }
+    for (output, &destination) in output_destinations.iter().enumerate() {
+        let projection = input_planes
+            .get(destination as usize)
+            .copied()
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "recurrence P-kernel destination projection is out of bounds",
+                )
+            })?;
+        let expected_imaginary = output % 2 == 1;
+        let valid = match (role, projection) {
+            (
+                DirectExecutorRole::Contribution | DirectExecutorRole::Finalization,
+                SymjitDirectPlaneProjection::DestinationCurrent { imaginary, .. },
+            )
+            | (
+                DirectExecutorRole::Closure,
+                SymjitDirectPlaneProjection::DestinationAmplitude { imaginary, .. },
+            ) => imaginary == expected_imaginary,
+            _ => false,
+        };
+        if !valid {
+            return Err(RusticolError::integrity(
+                "recurrence P-kernel output does not map to the expected split-complex destination",
+            ));
+        }
+    }
+    for pair in output_destinations.chunks_exact(2) {
+        let real = input_planes[pair[0] as usize];
+        let imaginary = input_planes[pair[1] as usize];
+        if !matching_split_destination(real, imaginary) {
+            return Err(RusticolError::integrity(
+                "recurrence P-kernel output pair maps to different destination components",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn matching_split_destination(
+    real: SymjitDirectPlaneProjection,
+    imaginary: SymjitDirectPlaneProjection,
+) -> bool {
+    match (real, imaginary) {
+        (
+            SymjitDirectPlaneProjection::DestinationCurrent {
+                component: left,
+                imaginary: false,
+            },
+            SymjitDirectPlaneProjection::DestinationCurrent {
+                component: right,
+                imaginary: true,
+            },
+        )
+        | (
+            SymjitDirectPlaneProjection::DestinationAmplitude {
+                component: left,
+                imaginary: false,
+            },
+            SymjitDirectPlaneProjection::DestinationAmplitude {
+                component: right,
+                imaginary: true,
+            },
+        ) => left == right,
+        _ => false,
+    }
+}
+
+unsafe extern "C" fn execute_contribution_rows(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    invoke_typed_rows(
+        context,
+        arena,
+        momenta,
+        parameters,
+        factors,
+        rows,
+        row_count,
+        point_count,
+    )
+}
+
+unsafe extern "C" fn execute_finalization_rows(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectFinalizationRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    invoke_typed_rows(
+        context,
+        arena,
+        momenta,
+        parameters,
+        factors,
+        rows,
+        row_count,
+        point_count,
+    )
+}
+
+unsafe extern "C" fn execute_closure_rows(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectClosureRow,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    invoke_typed_rows(
+        context,
+        arena,
+        momenta,
+        parameters,
+        factors,
+        rows,
+        row_count,
+        point_count,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn invoke_typed_rows<T: DirectTypedRow>(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const T,
+    row_count: u32,
+    point_count: u32,
+) -> c_int {
+    if context.is_null() {
+        return STATUS_INVALID_CONTEXT;
+    }
+    if rows.is_null() || row_count == 0 || point_count == 0 {
+        return STATUS_INVALID_ARGUMENT;
+    }
+    match catch_unwind(AssertUnwindSafe(|| {
+        let context = unsafe { &*context.cast::<SymjitDirectExecutorContext>() };
+        if context.role != T::ROLE {
+            return Ok(STATUS_ROLE_MISMATCH);
+        }
+        let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+        context.execute_rows(arena, momenta, parameters, factors, rows, point_count)?;
+        Ok(DIRECT_STATUS_OK)
+    })) {
+        Ok(Ok(status)) => status,
+        Ok(Err(error)) => {
+            record_direct_executor_error_detail(error);
+            STATUS_EXECUTION_FAILED
+        }
+        Err(payload) => {
+            let message = if let Some(message) = payload.downcast_ref::<&str>() {
+                (*message).to_owned()
+            } else if let Some(message) = payload.downcast_ref::<String>() {
+                message.clone()
+            } else {
+                "non-string panic payload".to_owned()
+            };
+            record_direct_executor_error_detail(RusticolError::internal(format!(
+                "recurrence SymJIT executor panicked: {message}"
+            )));
+            STATUS_EXECUTION_FAILED
+        }
+    }
+}
+
+enum DirectRowRef<'a> {
+    Contribution(&'a DirectContributionRow),
+    Finalization(&'a DirectFinalizationRow),
+    Closure(&'a DirectClosureRow),
+}
+
+trait DirectTypedRow {
+    const ROLE: DirectExecutorRole;
+    fn direct_row_ref(&self) -> DirectRowRef<'_>;
+}
+
+impl DirectTypedRow for DirectContributionRow {
+    const ROLE: DirectExecutorRole = DirectExecutorRole::Contribution;
+
+    fn direct_row_ref(&self) -> DirectRowRef<'_> {
+        DirectRowRef::Contribution(self)
+    }
+}
+
+impl DirectTypedRow for DirectFinalizationRow {
+    const ROLE: DirectExecutorRole = DirectExecutorRole::Finalization;
+
+    fn direct_row_ref(&self) -> DirectRowRef<'_> {
+        DirectRowRef::Finalization(self)
+    }
+}
+
+impl DirectTypedRow for DirectClosureRow {
+    const ROLE: DirectExecutorRole = DirectExecutorRole::Closure;
+
+    fn direct_row_ref(&self) -> DirectRowRef<'_> {
+        DirectRowRef::Closure(self)
+    }
+}
+
+impl DirectRowRef<'_> {
+    fn exact_factor_id(&self) -> u32 {
+        match self {
+            Self::Contribution(row) => row.exact_factor_id,
+            Self::Finalization(row) => row.exact_factor_id,
+            Self::Closure(row) => row.exact_factor_id,
+        }
+    }
+
+    fn parent_component_base(&self, parent: u8) -> Option<u32> {
+        match (self, parent) {
+            (Self::Contribution(row), 0) => Some(row.parent0_component_base),
+            (Self::Contribution(row), 1)
+                if row.parent1_component_base_or_sentinel != DIRECT_NONE_U32 =>
+            {
+                Some(row.parent1_component_base_or_sentinel)
+            }
+            (Self::Finalization(row), 0) => Some(row.component_base),
+            (Self::Closure(row), 0) => Some(row.parent0_component_base),
+            (Self::Closure(row), 1)
+                if row.parent1_component_base_or_sentinel != DIRECT_NONE_U32 =>
+            {
+                Some(row.parent1_component_base_or_sentinel)
+            }
+            _ => None,
+        }
+    }
+
+    fn momentum_form_id(&self, operand: u8) -> Option<u32> {
+        match (self, operand) {
+            (Self::Contribution(row), 0) => Some(row.parent0_momentum_form_id),
+            (Self::Contribution(row), 1)
+                if row.parent1_momentum_form_id_or_sentinel != DIRECT_NONE_U32 =>
+            {
+                Some(row.parent1_momentum_form_id_or_sentinel)
+            }
+            (Self::Finalization(row), 0) => Some(row.momentum_form_id),
+            (Self::Closure(row), 0) => Some(row.parent0_momentum_form_id),
+            (Self::Closure(row), 1)
+                if row.parent1_momentum_form_id_or_sentinel != DIRECT_NONE_U32 =>
+            {
+                Some(row.parent1_momentum_form_id_or_sentinel)
+            }
+            _ => None,
+        }
+    }
+
+    fn destination_current_base(&self) -> Option<u32> {
+        match self {
+            Self::Contribution(row) => Some(row.destination_component_base),
+            Self::Finalization(row) => Some(row.component_base),
+            Self::Closure(_) => None,
+        }
+    }
+
+    fn destination_amplitude_base(&self) -> Option<u32> {
+        match self {
+            Self::Closure(row) => Some(row.amplitude_destination_id),
+            _ => None,
+        }
+    }
+
+    fn accumulates_output(&self) -> bool {
+        match self {
+            Self::Contribution(row) => {
+                row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION == 0
+            }
+            Self::Finalization(_) => false,
+            Self::Closure(_) => true,
+        }
+    }
+}
+
+impl SymjitDirectExecutorContext {
+    fn execute_rows<T: DirectTypedRow>(
+        &self,
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+        factors: DirectFactorView,
+        rows: &[T],
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        if arena.point_stride == 0
+            || point_count > arena.point_stride
+            || arena.point_stride != momenta.point_stride
+        {
+            return Err(RusticolError::invalid_argument(
+                "recurrence SymJIT point range or momentum stride is invalid",
+            ));
+        }
+        let point_stride = arena.point_stride as usize;
+        let broadcast_count = self.broadcast_scalar_by_slot.len();
+        let workspace = if point_stride == 1 {
+            &self.scalar_workspace
+        } else {
+            &self.tiled_workspace
+        };
+        let mut workspace = workspace.borrow_mut();
+        workspace.prepare(
+            point_stride,
+            self.parameter_bindings.len(),
+            self.output_destinations.len(),
+            broadcast_count,
+        )?;
+
+        let storage = DescriptorStorageIdentity::new(arena, momenta);
+        if workspace.storage.is_some_and(|cached| cached != storage) {
+            workspace.invalidate_row_tables();
+        }
+        workspace.storage = Some(storage);
+        let row_count = u32::try_from(rows.len())
+            .map_err(|_| RusticolError::integrity("recurrence row count exceeds u32"))?;
+        let identity = RowTableIdentity {
+            role: T::ROLE,
+            address: rows.as_ptr().addr(),
+            row_count,
+        };
+        let group_index = if let Some(index) = workspace.cached_row_group_index(identity) {
+            index
+        } else {
+            let cached =
+                self.build_cached_row_group(&mut workspace, identity, rows, arena, momenta)?;
+            workspace.cache_row_group(cached)?
+        };
+
+        let mut call_scratch_bytes = 0_u64;
+        let mut call_broadcast_bytes = 0_u64;
+        let result = (|| {
+            for (row_index, typed_row) in rows.iter().enumerate() {
+                let row = typed_row.direct_row_ref();
+                let refresh_bytes = if row_index == 0 {
+                    // Preserve scalar-catalog order on the first row while
+                    // refreshing every literal/model parameter exactly once
+                    // for this executor call. Only exact factors can vary on
+                    // later rows.
+                    self.refresh_first_row_broadcasts(&mut workspace, &row, parameters, factors)?
+                } else {
+                    self.refresh_exact_factor_broadcasts(&mut workspace, &row, parameters, factors)?
+                };
+                call_broadcast_bytes = call_broadcast_bytes.saturating_add(refresh_bytes);
+                let (factor_re, factor_im) = exact_factor(&row, factors)?;
+                let use_direct = is_identity_factor(factor_re, factor_im)
+                    && workspace
+                        .row_groups
+                        .get(group_index)
+                        .and_then(|group| group.rows.get(row_index))
+                        .is_some_and(|tables| tables.direct.is_some());
+                {
+                    let tables = workspace
+                        .row_groups
+                        .get_mut(group_index)
+                        .and_then(|group| group.rows.get_mut(row_index))
+                        .ok_or_else(|| {
+                            RusticolError::internal(
+                                "recurrence cached descriptor table is out of bounds",
+                            )
+                        })?;
+                    let table = if use_direct {
+                        tables.direct.as_mut().ok_or_else(|| {
+                            RusticolError::internal(
+                                "recurrence direct-output table disappeared after selection",
+                            )
+                        })?
+                    } else {
+                        &mut tables.scratch
+                    };
+                    self.kernel.execute_table(table, 0, point_count as usize)?;
+                }
+                if !use_direct {
+                    apply_outputs(
+                        &self.input_planes,
+                        &self.output_destinations,
+                        &workspace.scratch,
+                        point_stride,
+                        point_count as usize,
+                        factor_re,
+                        factor_im,
+                        &row,
+                        arena,
+                        momenta,
+                    )?;
+                    let scratch_one_way = internal_plane_bytes(
+                        self.output_destinations.len(),
+                        point_count as usize,
+                        "recurrence scratch traffic",
+                    )?;
+                    call_scratch_bytes =
+                        call_scratch_bytes.saturating_add(scratch_one_way.saturating_mul(2));
+                }
+                call_broadcast_bytes = call_broadcast_bytes.saturating_add(internal_plane_bytes(
+                    broadcast_count,
+                    point_count as usize,
+                    "recurrence broadcast traffic",
+                )?);
+            }
+            Ok(())
+        })();
+        self.record_internal_scratch_bytes(call_scratch_bytes);
+        self.record_internal_broadcast_bytes(call_broadcast_bytes);
+        result
+    }
+
+    fn build_cached_row_group<T: DirectTypedRow>(
+        &self,
+        workspace: &mut PlaneWorkspace,
+        identity: RowTableIdentity,
+        rows: &[T],
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+    ) -> RusticolResult<CachedRowGroup> {
+        let descriptor_count = self
+            .parameter_bindings
+            .len()
+            .checked_add(self.output_destinations.len())
+            .ok_or_else(|| RusticolError::integrity("recurrence descriptor count overflows"))?;
+        let bytes_per_table = descriptor_count
+            .checked_mul(size_of::<PlaneDescriptor<'static>>())
+            .ok_or_else(|| {
+                RusticolError::compatibility("recurrence descriptor cache size overflows")
+            })?;
+        let mut descriptor_bytes = 0_usize;
+        let mut cached_rows: Vec<CachedRowTables> = Vec::new();
+        cached_rows.try_reserve_exact(rows.len()).map_err(|_| {
+            RusticolError::compatibility("could not reserve recurrence descriptor tables")
+        })?;
+        for typed_row in rows {
+            let row = typed_row.direct_row_ref();
+            let mut input_pointers = Vec::new();
+            input_pointers
+                .try_reserve_exact(self.parameter_bindings.len())
+                .map_err(|_| {
+                    RusticolError::compatibility(
+                        "could not reserve recurrence input plane pointers",
+                    )
+                })?;
+            for (binding_index, binding) in self.parameter_bindings.iter().enumerate() {
+                let pointer = match *binding {
+                    SymjitDirectParameterBinding::Plane { index } => resolve_plane_pointer(
+                        *self.input_planes.get(index as usize).ok_or_else(|| {
+                            RusticolError::integrity("recurrence input projection is out of bounds")
+                        })?,
+                        &row,
+                        arena,
+                        momenta,
+                    )?,
+                    SymjitDirectParameterBinding::Broadcast { .. } => {
+                        let slot =
+                            self.broadcast_slot_by_binding[binding_index].ok_or_else(|| {
+                                RusticolError::internal(
+                                    "recurrence broadcast binding has no persistent slot",
+                                )
+                            })? as usize;
+                        workspace.broadcast_plane_pointer(slot)?
+                    }
+                };
+                input_pointers.push(pointer);
+            }
+            let mut output_pointers = Vec::new();
+            output_pointers
+                .try_reserve_exact(self.output_destinations.len())
+                .map_err(|_| {
+                    RusticolError::compatibility(
+                        "could not reserve recurrence output plane pointers",
+                    )
+                })?;
+            for &destination in self.output_destinations.iter() {
+                output_pointers.push(resolve_plane_pointer(
+                    *self.input_planes.get(destination as usize).ok_or_else(|| {
+                        RusticolError::integrity("recurrence output projection is out of bounds")
+                    })?,
+                    &row,
+                    arena,
+                    momenta,
+                )?);
+            }
+            let mut scratch_pointers = Vec::new();
+            scratch_pointers
+                .try_reserve_exact(self.output_destinations.len())
+                .map_err(|_| {
+                    RusticolError::compatibility(
+                        "could not reserve recurrence scratch plane pointers",
+                    )
+                })?;
+            for output in 0..self.output_destinations.len() {
+                scratch_pointers.push(workspace.scratch_pointer(output)?);
+            }
+            let scratch = build_plane_table(
+                &self.kernel,
+                &input_pointers,
+                &scratch_pointers,
+                workspace.point_stride,
+            )?;
+            descriptor_bytes = descriptor_bytes
+                .checked_add(bytes_per_table)
+                .ok_or_else(|| {
+                    RusticolError::compatibility("recurrence descriptor cache size overflows")
+                })?;
+            let direct = if direct_outputs_are_structurally_safe(
+                self.role,
+                &input_pointers,
+                &output_pointers,
+                workspace.point_stride,
+            )? {
+                descriptor_bytes =
+                    descriptor_bytes
+                        .checked_add(bytes_per_table)
+                        .ok_or_else(|| {
+                            RusticolError::compatibility(
+                                "recurrence descriptor cache size overflows",
+                            )
+                        })?;
+                Some(build_plane_table(
+                    &self.kernel,
+                    &input_pointers,
+                    &output_pointers,
+                    workspace.point_stride,
+                )?)
+            } else {
+                None
+            };
+            cached_rows.push(CachedRowTables { scratch, direct });
+        }
+        Ok(CachedRowGroup {
+            identity,
+            rows: cached_rows,
+            descriptor_bytes,
+        })
+    }
+
+    fn refresh_first_row_broadcasts(
+        &self,
+        workspace: &mut PlaneWorkspace,
+        row: &DirectRowRef<'_>,
+        parameters: DirectParameterView,
+        factors: DirectFactorView,
+    ) -> RusticolResult<u64> {
+        let mut refresh_bytes = 0_u64;
+        for (slot, &index) in self.broadcast_scalar_by_slot.iter().enumerate() {
+            let projection = self.scalars.get(index as usize).ok_or_else(|| {
+                RusticolError::integrity("recurrence scalar projection is out of bounds")
+            })?;
+            #[cfg(test)]
+            match projection {
+                SymjitDirectScalarProjection::Literal(_)
+                | SymjitDirectScalarProjection::Parameter { .. } => {
+                    self.invariant_broadcast_resolution_count.set(
+                        self.invariant_broadcast_resolution_count
+                            .get()
+                            .saturating_add(1),
+                    )
+                }
+                SymjitDirectScalarProjection::ExactFactor { .. } => {
+                    self.exact_factor_broadcast_resolution_count.set(
+                        self.exact_factor_broadcast_resolution_count
+                            .get()
+                            .saturating_add(1),
+                    )
+                }
+            }
+            let value = resolve_scalar_value(projection, row, parameters, factors)?;
+            let (_, refreshed) = workspace.broadcast_pointer(slot, value)?;
+            if refreshed {
+                refresh_bytes = refresh_bytes.saturating_add(internal_plane_bytes(
+                    1,
+                    workspace.point_stride,
+                    "recurrence broadcast refresh traffic",
+                )?);
+            }
+        }
+        Ok(refresh_bytes)
+    }
+
+    fn refresh_exact_factor_broadcasts(
+        &self,
+        workspace: &mut PlaneWorkspace,
+        row: &DirectRowRef<'_>,
+        parameters: DirectParameterView,
+        factors: DirectFactorView,
+    ) -> RusticolResult<u64> {
+        let mut refresh_bytes = 0_u64;
+        for &slot in self.exact_factor_broadcast_slots.iter() {
+            let scalar_index = *self.broadcast_scalar_by_slot.get(slot).ok_or_else(|| {
+                RusticolError::internal(
+                    "recurrence exact-factor broadcast slot is outside its catalog",
+                )
+            })?;
+            let projection = self.scalars.get(scalar_index as usize).ok_or_else(|| {
+                RusticolError::integrity("recurrence scalar projection is out of bounds")
+            })?;
+            let SymjitDirectScalarProjection::ExactFactor { .. } = projection else {
+                return Err(RusticolError::internal(
+                    "recurrence row-local broadcast is not an exact factor",
+                ));
+            };
+            #[cfg(test)]
+            self.exact_factor_broadcast_resolution_count.set(
+                self.exact_factor_broadcast_resolution_count
+                    .get()
+                    .saturating_add(1),
+            );
+            let value = resolve_scalar_value(projection, row, parameters, factors)?;
+            let (_, refreshed) = workspace.broadcast_pointer(slot, value)?;
+            if refreshed {
+                refresh_bytes = refresh_bytes.saturating_add(internal_plane_bytes(
+                    1,
+                    workspace.point_stride,
+                    "recurrence broadcast refresh traffic",
+                )?);
+            }
+        }
+        Ok(refresh_bytes)
+    }
+
+    fn record_internal_scratch_bytes(&self, bytes: u64) {
+        self.internal_scratch_bytes
+            .set(self.internal_scratch_bytes.get().saturating_add(bytes));
+    }
+
+    fn record_internal_broadcast_bytes(&self, bytes: u64) {
+        self.internal_broadcast_bytes
+            .set(self.internal_broadcast_bytes.get().saturating_add(bytes));
+    }
+}
+
+fn checked_descriptor_cache_bytes(current: usize, additional: usize) -> RusticolResult<usize> {
+    current.checked_add(additional).ok_or_else(|| {
+        RusticolError::compatibility("recurrence SymJIT descriptor cache size overflows")
+    })
+}
+
+fn build_plane_table(
+    kernel: &SymjitPlaneKernel,
+    input_pointers: &[*mut f64],
+    output_pointers: &[*mut f64],
+    point_stride: usize,
+) -> RusticolResult<SymjitPlaneTable<'static>> {
+    let descriptor_count = input_pointers
+        .len()
+        .checked_add(output_pointers.len())
+        .ok_or_else(|| RusticolError::integrity("recurrence descriptor count overflows"))?;
+    let mut descriptors: Vec<PlaneDescriptor<'static>> = Vec::new();
+    descriptors
+        .try_reserve_exact(descriptor_count)
+        .map_err(|_| {
+            RusticolError::compatibility("could not reserve recurrence plane descriptors")
+        })?;
+    for &pointer in input_pointers.iter().chain(output_pointers) {
+        descriptors.push(unsafe { PlaneDescriptor::from_cached_raw_parts(pointer, point_stride)? });
+    }
+    kernel.build_raw_table(descriptors)
+}
+
+fn direct_outputs_are_structurally_safe(
+    role: DirectExecutorRole,
+    input_pointers: &[*mut f64],
+    output_pointers: &[*mut f64],
+    point_stride: usize,
+) -> RusticolResult<bool> {
+    if role != DirectExecutorRole::Finalization {
+        return Ok(false);
+    }
+    for (output_index, &pointer) in output_pointers.iter().enumerate() {
+        let output = PlaneAddressRange::new(pointer, point_stride)?;
+        for &input in input_pointers {
+            if output.overlaps(PlaneAddressRange::new(input, point_stride)?) {
+                return Ok(false);
+            }
+        }
+        for &prior in &output_pointers[..output_index] {
+            if output.overlaps(PlaneAddressRange::new(prior, point_stride)?) {
+                return Ok(false);
+            }
+        }
+    }
+    Ok(true)
+}
+
+#[derive(Clone, Copy)]
+struct PlaneAddressRange {
+    start: usize,
+    end: usize,
+}
+
+impl PlaneAddressRange {
+    fn new(pointer: *mut f64, point_stride: usize) -> RusticolResult<Self> {
+        if pointer.is_null() || point_stride == 0 {
+            return Err(RusticolError::integrity(
+                "recurrence direct-output plane has a null pointer or zero stride",
+            ));
+        }
+        let bytes = point_stride
+            .checked_mul(size_of::<f64>())
+            .ok_or_else(|| RusticolError::integrity("recurrence plane byte range overflows"))?;
+        let start = pointer.addr();
+        let end = start
+            .checked_add(bytes)
+            .ok_or_else(|| RusticolError::integrity("recurrence plane address range overflows"))?;
+        Ok(Self { start, end })
+    }
+
+    fn overlaps(self, other: Self) -> bool {
+        self.start < other.end && other.start < self.end
+    }
+}
+
+fn is_identity_factor(real: f64, imaginary: f64) -> bool {
+    real.to_bits() == 1.0_f64.to_bits() && imaginary.to_bits() == 0.0_f64.to_bits()
+}
+
+fn internal_plane_bytes(
+    plane_count: usize,
+    point_count: usize,
+    description: &str,
+) -> RusticolResult<u64> {
+    let bytes = plane_count
+        .checked_mul(point_count)
+        .and_then(|count| count.checked_mul(size_of::<f64>()))
+        .ok_or_else(|| RusticolError::integrity(format!("{description} overflows usize")))?;
+    u64::try_from(bytes).map_err(|_| RusticolError::integrity(format!("{description} exceeds u64")))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn apply_outputs(
+    projections: &[SymjitDirectPlaneProjection],
+    output_destinations: &[u32],
+    scratch: &[f64],
+    point_stride: usize,
+    point_count: usize,
+    factor_re: f64,
+    factor_im: f64,
+    row: &DirectRowRef<'_>,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+) -> RusticolResult<()> {
+    for (component, destination_pair) in output_destinations.chunks_exact(2).enumerate() {
+        let scratch_re_start = component
+            .checked_mul(2)
+            .and_then(|plane| plane.checked_mul(point_stride))
+            .ok_or_else(|| RusticolError::internal("recurrence scratch range overflows"))?;
+        let scratch_im_start = scratch_re_start
+            .checked_add(point_stride)
+            .ok_or_else(|| RusticolError::internal("recurrence scratch range overflows"))?;
+        let scratch_re = scratch
+            .get(scratch_re_start..scratch_re_start + point_count)
+            .ok_or_else(|| RusticolError::internal("recurrence real scratch is out of bounds"))?;
+        let scratch_im = scratch
+            .get(scratch_im_start..scratch_im_start + point_count)
+            .ok_or_else(|| {
+                RusticolError::internal("recurrence imaginary scratch is out of bounds")
+            })?;
+        let destination_re = resolve_plane_pointer(
+            projections[destination_pair[0] as usize],
+            row,
+            arena,
+            momenta,
+        )?;
+        let destination_im = resolve_plane_pointer(
+            projections[destination_pair[1] as usize],
+            row,
+            arena,
+            momenta,
+        )?;
+        let destination_re = unsafe { std::slice::from_raw_parts_mut(destination_re, point_count) };
+        let destination_im = unsafe { std::slice::from_raw_parts_mut(destination_im, point_count) };
+        apply_complex_scaled(
+            destination_re,
+            destination_im,
+            scratch_re,
+            scratch_im,
+            factor_re,
+            factor_im,
+            row.accumulates_output(),
+        );
+    }
+    Ok(())
+}
+
+#[inline]
+fn apply_complex_scaled(
+    destination_re: &mut [f64],
+    destination_im: &mut [f64],
+    source_re: &[f64],
+    source_im: &[f64],
+    factor_re: f64,
+    factor_im: f64,
+    accumulate: bool,
+) {
+    debug_assert_eq!(destination_re.len(), destination_im.len());
+    debug_assert_eq!(destination_re.len(), source_re.len());
+    debug_assert_eq!(destination_re.len(), source_im.len());
+    #[cfg(target_arch = "x86_64")]
+    let mut point = apply_complex_scaled_x86_64(
+        destination_re,
+        destination_im,
+        source_re,
+        source_im,
+        factor_re,
+        factor_im,
+        accumulate,
+    );
+    #[cfg(target_arch = "aarch64")]
+    let mut point = apply_complex_scaled_aarch64(
+        destination_re,
+        destination_im,
+        source_re,
+        source_im,
+        factor_re,
+        factor_im,
+        accumulate,
+    );
+    #[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
+    let mut point = 0;
+    if accumulate {
+        while point < destination_re.len() {
+            let re = source_re[point];
+            let im = source_im[point];
+            destination_re[point] += re * factor_re - im * factor_im;
+            destination_im[point] += re * factor_im + im * factor_re;
+            point += 1;
+        }
+    } else {
+        while point < destination_re.len() {
+            let re = source_re[point];
+            let im = source_im[point];
+            destination_re[point] = re * factor_re - im * factor_im;
+            destination_im[point] = re * factor_im + im * factor_re;
+            point += 1;
+        }
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+#[inline]
+#[allow(clippy::too_many_arguments)]
+fn apply_complex_scaled_x86_64(
+    destination_re: &mut [f64],
+    destination_im: &mut [f64],
+    source_re: &[f64],
+    source_im: &[f64],
+    factor_re: f64,
+    factor_im: f64,
+    accumulate: bool,
+) -> usize {
+    let factor_re = f64x4::new([factor_re; 4]);
+    let factor_im = f64x4::new([factor_im; 4]);
+    let mut point = 0;
+    while destination_re.len() - point >= 4 {
+        let re = f64x4::new([
+            source_re[point],
+            source_re[point + 1],
+            source_re[point + 2],
+            source_re[point + 3],
+        ]);
+        let im = f64x4::new([
+            source_im[point],
+            source_im[point + 1],
+            source_im[point + 2],
+            source_im[point + 3],
+        ]);
+        let mut scaled_re = re * factor_re - im * factor_im;
+        let mut scaled_im = re * factor_im + im * factor_re;
+        if accumulate {
+            scaled_re += f64x4::new([
+                destination_re[point],
+                destination_re[point + 1],
+                destination_re[point + 2],
+                destination_re[point + 3],
+            ]);
+            scaled_im += f64x4::new([
+                destination_im[point],
+                destination_im[point + 1],
+                destination_im[point + 2],
+                destination_im[point + 3],
+            ]);
+        }
+        destination_re[point..point + 4].copy_from_slice(&scaled_re.to_array());
+        destination_im[point..point + 4].copy_from_slice(&scaled_im.to_array());
+        point += 4;
+    }
+    point
+}
+
+#[cfg(target_arch = "aarch64")]
+#[inline]
+#[allow(clippy::too_many_arguments)]
+fn apply_complex_scaled_aarch64(
+    destination_re: &mut [f64],
+    destination_im: &mut [f64],
+    source_re: &[f64],
+    source_im: &[f64],
+    factor_re: f64,
+    factor_im: f64,
+    accumulate: bool,
+) -> usize {
+    let factor_re = f64x2::new([factor_re; 2]);
+    let factor_im = f64x2::new([factor_im; 2]);
+    let mut point = 0;
+    while destination_re.len() - point >= 2 {
+        let re = f64x2::new([source_re[point], source_re[point + 1]]);
+        let im = f64x2::new([source_im[point], source_im[point + 1]]);
+        let mut scaled_re = re * factor_re - im * factor_im;
+        let mut scaled_im = re * factor_im + im * factor_re;
+        if accumulate {
+            scaled_re += f64x2::new([destination_re[point], destination_re[point + 1]]);
+            scaled_im += f64x2::new([destination_im[point], destination_im[point + 1]]);
+        }
+        destination_re[point..point + 2].copy_from_slice(&scaled_re.to_array());
+        destination_im[point..point + 2].copy_from_slice(&scaled_im.to_array());
+        point += 2;
+    }
+    point
+}
+
+fn exact_factor(row: &DirectRowRef<'_>, factors: DirectFactorView) -> RusticolResult<(f64, f64)> {
+    let index = row.exact_factor_id();
+    if index >= factors.value_count || factors.values_re.is_null() || factors.values_im.is_null() {
+        return Err(RusticolError::integrity(
+            "recurrence exact factor is outside its split-complex catalog",
+        ));
+    }
+    Ok(unsafe {
+        (
+            *factors.values_re.add(index as usize),
+            *factors.values_im.add(index as usize),
+        )
+    })
+}
+
+fn resolve_scalar_value(
+    projection: &SymjitDirectScalarProjection,
+    row: &DirectRowRef<'_>,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+) -> RusticolResult<f64> {
+    match *projection {
+        SymjitDirectScalarProjection::Literal(value) => Ok(value),
+        SymjitDirectScalarProjection::Parameter { index, imaginary } => {
+            if index >= parameters.value_count {
+                return Err(RusticolError::integrity(
+                    "recurrence model parameter is outside its split-complex catalog",
+                ));
+            }
+            let base = if imaginary {
+                parameters.values_im
+            } else {
+                parameters.values_re
+            };
+            if base.is_null() {
+                return Err(RusticolError::integrity(
+                    "recurrence model parameter catalog has a null pointer",
+                ));
+            }
+            Ok(unsafe { *base.add(index as usize) })
+        }
+        SymjitDirectScalarProjection::ExactFactor { imaginary } => {
+            let (real, imag) = exact_factor(row, factors)?;
+            Ok(if imaginary { imag } else { real })
+        }
+    }
+}
+
+fn resolve_plane_pointer(
+    projection: SymjitDirectPlaneProjection,
+    row: &DirectRowRef<'_>,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+) -> RusticolResult<*mut f64> {
+    let pointer = match projection {
+        SymjitDirectPlaneProjection::ParentCurrent {
+            parent,
+            component,
+            imaginary,
+        } => {
+            let base = row.parent_component_base(parent).ok_or_else(|| {
+                RusticolError::integrity("recurrence row has no requested parent")
+            })?;
+            arena_plane_pointer(
+                if imaginary {
+                    arena.current_im
+                } else {
+                    arena.current_re
+                },
+                arena.current_scalar_len,
+                u64::from(base) + u64::from(component),
+                arena.point_stride,
+            )
+        }
+        SymjitDirectPlaneProjection::Momentum {
+            operand,
+            lorentz_component,
+        } => {
+            let form = row.momentum_form_id(operand).ok_or_else(|| {
+                RusticolError::integrity("recurrence row has no requested momentum operand")
+            })?;
+            if form >= momenta.form_count || lorentz_component >= momenta.lorentz_component_count {
+                return Err(RusticolError::integrity(
+                    "recurrence momentum projection is out of bounds",
+                ));
+            }
+            let plane = u64::from(form)
+                .checked_mul(u64::from(momenta.lorentz_component_count))
+                .and_then(|base| base.checked_add(u64::from(lorentz_component)))
+                .ok_or_else(|| RusticolError::integrity("momentum plane index overflows"))?;
+            arena_plane_pointer(
+                momenta.values.cast_mut(),
+                momenta.scalar_len,
+                plane,
+                momenta.point_stride,
+            )
+        }
+        SymjitDirectPlaneProjection::DestinationCurrent {
+            component,
+            imaginary,
+        } => {
+            let base = row.destination_current_base().ok_or_else(|| {
+                RusticolError::integrity("recurrence row has no current destination")
+            })?;
+            arena_plane_pointer(
+                if imaginary {
+                    arena.current_im
+                } else {
+                    arena.current_re
+                },
+                arena.current_scalar_len,
+                u64::from(base) + u64::from(component),
+                arena.point_stride,
+            )
+        }
+        SymjitDirectPlaneProjection::DestinationAmplitude {
+            component,
+            imaginary,
+        } => {
+            let base = row.destination_amplitude_base().ok_or_else(|| {
+                RusticolError::integrity("recurrence row has no amplitude destination")
+            })?;
+            arena_plane_pointer(
+                if imaginary {
+                    arena.amplitude_im
+                } else {
+                    arena.amplitude_re
+                },
+                arena.amplitude_scalar_len,
+                u64::from(base) + u64::from(component),
+                arena.point_stride,
+            )
+        }
+    }?;
+    Ok(pointer)
+}
+
+fn arena_plane_pointer(
+    pointer: *mut f64,
+    scalar_len: u64,
+    plane: u64,
+    point_stride: u32,
+) -> RusticolResult<*mut f64> {
+    if pointer.is_null() || point_stride == 0 {
+        return Err(RusticolError::integrity(
+            "recurrence plane storage has a null pointer or zero stride",
+        ));
+    }
+    let offset = plane
+        .checked_mul(u64::from(point_stride))
+        .ok_or_else(|| RusticolError::integrity("recurrence plane offset overflows"))?;
+    let end = offset
+        .checked_add(u64::from(point_stride))
+        .ok_or_else(|| RusticolError::integrity("recurrence plane range overflows"))?;
+    if end > scalar_len {
+        return Err(RusticolError::integrity(
+            "recurrence plane projection is outside its arena",
+        ));
+    }
+    let offset = usize::try_from(offset)
+        .map_err(|_| RusticolError::integrity("recurrence plane offset exceeds usize"))?;
+    Ok(unsafe { pointer.add(offset) })
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::super::symjit_plane::compile_symbolica_program_to_plane_application_bytes;
+    use super::*;
+    use crate::recurrence::DirectSourceRow;
+    use crate::recurrence::on_the_fly::{
+        OnTheFlyExecutorKeyV1, OnTheFlyPreparedExecutorResolver, OnTheFlyStructuralInterpreter,
+        OnTheFlyStructuralTraceV1, OnTheFlyWorkspaceV1, ResolvedOnTheFlyExecutor,
+    };
+    use std::alloc::{GlobalAlloc, Layout, System};
+    use std::collections::BTreeMap;
+
+    thread_local! {
+        static TRACK_ALLOCATIONS: Cell<bool> = const { Cell::new(false) };
+        static ALLOCATION_COUNT: Cell<usize> = const { Cell::new(0) };
+        static ALLOCATED_BYTES: Cell<usize> = const { Cell::new(0) };
+    }
+
+    struct CountingAllocator;
+
+    #[global_allocator]
+    static GLOBAL_ALLOCATOR: CountingAllocator = CountingAllocator;
+
+    unsafe impl GlobalAlloc for CountingAllocator {
+        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+            count_allocation(layout.size());
+            unsafe { System.alloc(layout) }
+        }
+
+        unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+            count_allocation(layout.size());
+            unsafe { System.alloc_zeroed(layout) }
+        }
+
+        unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+            count_allocation(new_size);
+            unsafe { System.realloc(pointer, layout, new_size) }
+        }
+
+        unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+            unsafe { System.dealloc(pointer, layout) }
+        }
+    }
+
+    fn count_allocation(bytes: usize) {
+        let tracking = TRACK_ALLOCATIONS.try_with(Cell::get).unwrap_or(false);
+        if tracking {
+            let _ = ALLOCATION_COUNT.try_with(|count| count.set(count.get() + 1));
+            let _ = ALLOCATED_BYTES.try_with(|total| total.set(total.get().saturating_add(bytes)));
+        }
+    }
+
+    pub(crate) fn count_allocations<T>(operation: impl FnOnce() -> T) -> (T, usize, usize) {
+        ALLOCATION_COUNT.with(|count| count.set(0));
+        ALLOCATED_BYTES.with(|total| total.set(0));
+        TRACK_ALLOCATIONS.with(|tracking| tracking.set(true));
+        let result = operation();
+        TRACK_ALLOCATIONS.with(|tracking| tracking.set(false));
+        let count = ALLOCATION_COUNT.with(Cell::get);
+        let bytes = ALLOCATED_BYTES.with(Cell::get);
+        (result, count, bytes)
+    }
+
+    const IDENTITY_PROGRAM: &str = "([('assign', ('out', 0), ('param', 0))], 1, [])";
+    const DOUBLE_PROGRAM: &str = "
+([('add', ('temp', 0), [('param', 0), ('param', 1)], 0),
+  ('assign', ('out', 0), ('temp', 0))],
+ 2,
+ [])
+";
+    const LENGTHS: &[usize] = &[1, 2, 3, 7, 8, 127, 128, 129, 1023, 1024, 1025];
+
+    fn identity_executor(role: DirectExecutorRole) -> LoadedSymjitDirectExecutor {
+        try_identity_executor(role, 2, false).unwrap()
+    }
+
+    fn try_identity_executor(
+        role: DirectExecutorRole,
+        expected_optimization_level: u32,
+        expected_compression: bool,
+    ) -> RusticolResult<LoadedSymjitDirectExecutor> {
+        try_identity_executor_with_abi(
+            role,
+            expected_optimization_level,
+            expected_compression,
+            SYMJIT_RECURRENCE_PLANE_APPLICATION_ABI,
+        )
+    }
+
+    fn try_identity_executor_with_abi(
+        role: DirectExecutorRole,
+        expected_optimization_level: u32,
+        expected_compression: bool,
+        application_abi: &str,
+    ) -> RusticolResult<LoadedSymjitDirectExecutor> {
+        let bytes =
+            compile_symbolica_program_to_plane_application_bytes(IDENTITY_PROGRAM, 1, 1, 2, false)
+                .unwrap();
+        let destination = match role {
+            DirectExecutorRole::Closure => [
+                SymjitDirectPlaneProjection::DestinationAmplitude {
+                    component: 0,
+                    imaginary: false,
+                },
+                SymjitDirectPlaneProjection::DestinationAmplitude {
+                    component: 0,
+                    imaginary: true,
+                },
+            ],
+            _ => [
+                SymjitDirectPlaneProjection::DestinationCurrent {
+                    component: 0,
+                    imaginary: false,
+                },
+                SymjitDirectPlaneProjection::DestinationCurrent {
+                    component: 0,
+                    imaginary: true,
+                },
+            ],
+        };
+        LoadedSymjitDirectExecutor::load_prepared_application_bytes(
+            &bytes,
+            PathBuf::from("identity-recurrence-plane.symjit"),
+            application_abi,
+            expected_optimization_level,
+            expected_compression,
+            role,
+            vec![
+                SymjitDirectParameterBinding::Plane { index: 0 },
+                SymjitDirectParameterBinding::Plane { index: 1 },
+            ],
+            vec![
+                SymjitDirectPlaneProjection::ParentCurrent {
+                    parent: 0,
+                    component: 0,
+                    imaginary: false,
+                },
+                SymjitDirectPlaneProjection::ParentCurrent {
+                    parent: 0,
+                    component: 0,
+                    imaginary: true,
+                },
+                destination[0],
+                destination[1],
+            ],
+            vec![
+                SymjitDirectScalarProjection::ExactFactor { imaginary: false },
+                SymjitDirectScalarProjection::ExactFactor { imaginary: true },
+            ],
+            vec![2, 3],
+        )
+    }
+
+    #[test]
+    fn predecessor_plane_application_abi_fails_closed_with_regeneration_message() {
+        let error = try_identity_executor_with_abi(
+            DirectExecutorRole::Contribution,
+            2,
+            false,
+            "pyamplicol-symjit-plane-application-v1",
+        )
+        .err()
+        .expect("the predecessor recurrence plane-application ABI must fail closed");
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.message().contains("regenerate"));
+    }
+
+    #[test]
+    fn authenticated_template_optimization_level_mismatch_fails_closed() {
+        let error = try_identity_executor(DirectExecutorRole::Contribution, 3, false)
+            .err()
+            .expect("a template/application optimization mismatch must fail closed");
+        assert!(error.message().contains("optimization level"));
+        assert!(error.message().contains("authenticated template"));
+        assert!(error.message().contains("regenerate"));
+    }
+
+    #[test]
+    fn authenticated_manifest_compression_mismatch_fails_closed() {
+        let error = try_identity_executor(DirectExecutorRole::Contribution, 2, true)
+            .err()
+            .expect("a manifest/application compression mismatch must fail closed");
+        assert!(error.message().contains("compression"));
+        assert!(error.message().contains("regenerate"));
+    }
+
+    #[test]
+    fn writer_valid_large_plane_and_scalar_bindings_are_not_artificially_capped() {
+        const INPUT_COMPLEX_COUNT: usize = 257;
+        let program =
+            format!("([('assign', ('out', 0), ('param', 0))], {INPUT_COMPLEX_COUNT}, [])");
+        let bytes = compile_symbolica_program_to_plane_application_bytes(
+            &program,
+            INPUT_COMPLEX_COUNT,
+            1,
+            2,
+            false,
+        )
+        .unwrap();
+        let mut parameter_bindings = Vec::new();
+        let mut input_planes = Vec::new();
+        for index in 0..(2 * INPUT_COMPLEX_COUNT) {
+            parameter_bindings.push(SymjitDirectParameterBinding::Plane {
+                index: index as u32,
+            });
+            input_planes.push(SymjitDirectPlaneProjection::ParentCurrent {
+                parent: 0,
+                component: 0,
+                imaginary: index % 2 == 1,
+            });
+        }
+        input_planes.extend([
+            SymjitDirectPlaneProjection::DestinationCurrent {
+                component: 0,
+                imaginary: false,
+            },
+            SymjitDirectPlaneProjection::DestinationCurrent {
+                component: 0,
+                imaginary: true,
+            },
+        ]);
+        let mut scalars = vec![
+            SymjitDirectScalarProjection::ExactFactor { imaginary: false },
+            SymjitDirectScalarProjection::ExactFactor { imaginary: true },
+        ];
+        scalars.resize(257, SymjitDirectScalarProjection::Literal(0.0));
+
+        LoadedSymjitDirectExecutor::load_prepared_application_bytes(
+            &bytes,
+            PathBuf::from("large-recurrence-plane.symjit"),
+            SYMJIT_RECURRENCE_PLANE_APPLICATION_ABI,
+            2,
+            false,
+            DirectExecutorRole::Contribution,
+            parameter_bindings,
+            input_planes,
+            scalars,
+            vec![514, 515],
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn descriptor_cache_accounting_accepts_the_observed_303_megabyte_geometry() {
+        assert_eq!(
+            checked_descriptor_cache_bytes(153_624_576, 149_667_840).unwrap(),
+            303_292_416
+        );
+        assert!(checked_descriptor_cache_bytes(usize::MAX, 1).is_err());
+    }
+
+    #[test]
+    fn callback_failure_reaches_the_direct_backend_with_concrete_context() {
+        let loaded = identity_executor(DirectExecutorRole::Contribution);
+        let DirectExecutorHandle::Contribution { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let mut current_re = vec![1.0; 2];
+        let mut current_im = vec![0.0; 2];
+        let mut amplitude_re = vec![0.0; 1];
+        let mut amplitude_im = vec![0.0; 1];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            &mut amplitude_re,
+            &mut amplitude_im,
+            &[],
+            &[],
+            &[],
+            &[],
+            1,
+        );
+        let row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            destination_component_base: 1,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+
+        crate::recurrence::direct_backend::clear_direct_executor_error_detail();
+        let status = unsafe { call(context, arena, momenta, parameters, factors, &row, 1, 1) };
+        let error = crate::recurrence::direct_backend::check_status(
+            DirectExecutorRole::Contribution,
+            312,
+            status,
+        )
+        .unwrap_err();
+
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Integrity);
+        assert!(error.message().contains("Contribution executor 312 failed"));
+        assert!(error.message().contains("exact factor"));
+    }
+
+    fn parameter_broadcast_executor(role: DirectExecutorRole) -> LoadedSymjitDirectExecutor {
+        let bytes =
+            compile_symbolica_program_to_plane_application_bytes(IDENTITY_PROGRAM, 1, 1, 2, false)
+                .unwrap();
+        let destination = match role {
+            DirectExecutorRole::Closure => [
+                SymjitDirectPlaneProjection::DestinationAmplitude {
+                    component: 0,
+                    imaginary: false,
+                },
+                SymjitDirectPlaneProjection::DestinationAmplitude {
+                    component: 0,
+                    imaginary: true,
+                },
+            ],
+            _ => [
+                SymjitDirectPlaneProjection::DestinationCurrent {
+                    component: 0,
+                    imaginary: false,
+                },
+                SymjitDirectPlaneProjection::DestinationCurrent {
+                    component: 0,
+                    imaginary: true,
+                },
+            ],
+        };
+        LoadedSymjitDirectExecutor::load_prepared_application_bytes(
+            &bytes,
+            PathBuf::from("parameter-recurrence-plane.symjit"),
+            SYMJIT_RECURRENCE_PLANE_APPLICATION_ABI,
+            2,
+            false,
+            role,
+            vec![
+                SymjitDirectParameterBinding::Broadcast { index: 2 },
+                SymjitDirectParameterBinding::Broadcast { index: 3 },
+            ],
+            vec![destination[0], destination[1]],
+            vec![
+                SymjitDirectScalarProjection::ExactFactor { imaginary: false },
+                SymjitDirectScalarProjection::ExactFactor { imaginary: true },
+                SymjitDirectScalarProjection::Parameter {
+                    index: 0,
+                    imaginary: false,
+                },
+                SymjitDirectScalarProjection::Parameter {
+                    index: 0,
+                    imaginary: true,
+                },
+            ],
+            vec![0, 1],
+        )
+        .unwrap()
+    }
+
+    fn repeated_parameter_and_zero_broadcast_executor() -> LoadedSymjitDirectExecutor {
+        let bytes =
+            compile_symbolica_program_to_plane_application_bytes(DOUBLE_PROGRAM, 2, 1, 2, false)
+                .unwrap();
+        LoadedSymjitDirectExecutor::load_prepared_application_bytes(
+            &bytes,
+            PathBuf::from("shared-recurrence-broadcasts.symjit"),
+            SYMJIT_RECURRENCE_PLANE_APPLICATION_ABI,
+            2,
+            false,
+            DirectExecutorRole::Contribution,
+            vec![
+                SymjitDirectParameterBinding::Broadcast { index: 2 },
+                SymjitDirectParameterBinding::Broadcast { index: 3 },
+                SymjitDirectParameterBinding::Broadcast { index: 2 },
+                SymjitDirectParameterBinding::Broadcast { index: 3 },
+            ],
+            vec![
+                SymjitDirectPlaneProjection::DestinationCurrent {
+                    component: 0,
+                    imaginary: false,
+                },
+                SymjitDirectPlaneProjection::DestinationCurrent {
+                    component: 0,
+                    imaginary: true,
+                },
+            ],
+            vec![
+                SymjitDirectScalarProjection::ExactFactor { imaginary: false },
+                SymjitDirectScalarProjection::ExactFactor { imaginary: true },
+                SymjitDirectScalarProjection::Parameter {
+                    index: 0,
+                    imaginary: false,
+                },
+                SymjitDirectScalarProjection::Literal(0.0),
+            ],
+            vec![0, 1],
+        )
+        .unwrap()
+    }
+
+    fn mixed_invariant_and_exact_broadcast_executor() -> LoadedSymjitDirectExecutor {
+        let bytes =
+            compile_symbolica_program_to_plane_application_bytes(DOUBLE_PROGRAM, 2, 1, 2, false)
+                .unwrap();
+        LoadedSymjitDirectExecutor::load_prepared_application_bytes(
+            &bytes,
+            PathBuf::from("mixed-recurrence-broadcasts.symjit"),
+            SYMJIT_RECURRENCE_PLANE_APPLICATION_ABI,
+            2,
+            false,
+            DirectExecutorRole::Contribution,
+            vec![
+                SymjitDirectParameterBinding::Broadcast { index: 2 },
+                SymjitDirectParameterBinding::Broadcast { index: 3 },
+                SymjitDirectParameterBinding::Broadcast { index: 0 },
+                SymjitDirectParameterBinding::Broadcast { index: 1 },
+            ],
+            vec![
+                SymjitDirectPlaneProjection::DestinationCurrent {
+                    component: 0,
+                    imaginary: false,
+                },
+                SymjitDirectPlaneProjection::DestinationCurrent {
+                    component: 0,
+                    imaginary: true,
+                },
+            ],
+            vec![
+                SymjitDirectScalarProjection::ExactFactor { imaginary: false },
+                SymjitDirectScalarProjection::ExactFactor { imaginary: true },
+                SymjitDirectScalarProjection::Parameter {
+                    index: 0,
+                    imaginary: false,
+                },
+                SymjitDirectScalarProjection::Parameter {
+                    index: 0,
+                    imaginary: true,
+                },
+            ],
+            vec![0, 1],
+        )
+        .unwrap()
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn views(
+        current_re: &mut [f64],
+        current_im: &mut [f64],
+        amplitude_re: &mut [f64],
+        amplitude_im: &mut [f64],
+        parameters_re: &[f64],
+        parameters_im: &[f64],
+        factors_re: &[f64],
+        factors_im: &[f64],
+        stride: usize,
+    ) -> (
+        DirectArenaView,
+        DirectMomentumView,
+        DirectParameterView,
+        DirectFactorView,
+    ) {
+        (
+            DirectArenaView {
+                current_re: current_re.as_mut_ptr(),
+                current_im: current_im.as_mut_ptr(),
+                current_scalar_len: current_re.len() as u64,
+                amplitude_re: amplitude_re.as_mut_ptr(),
+                amplitude_im: amplitude_im.as_mut_ptr(),
+                amplitude_scalar_len: amplitude_re.len() as u64,
+                point_stride: stride as u32,
+            },
+            DirectMomentumView {
+                values: ptr::NonNull::<f64>::dangling().as_ptr(),
+                scalar_len: 0,
+                form_count: 0,
+                lorentz_component_count: 4,
+                point_stride: stride as u32,
+            },
+            DirectParameterView {
+                values_re: parameters_re.as_ptr(),
+                values_im: parameters_im.as_ptr(),
+                value_count: parameters_re.len() as u32,
+            },
+            DirectFactorView {
+                values_re: factors_re.as_ptr(),
+                values_im: factors_im.as_ptr(),
+                value_count: factors_re.len() as u32,
+            },
+        )
+    }
+
+    #[test]
+    fn direct_output_classifier_requires_finalization_and_disjoint_planes() {
+        let mut inputs = vec![0.0; 32];
+        let mut output_re = vec![0.0; 32];
+        let mut output_im = vec![0.0; 32];
+        let input_pointers = [inputs.as_mut_ptr()];
+        let disjoint_outputs = [output_re.as_mut_ptr(), output_im.as_mut_ptr()];
+        assert!(
+            direct_outputs_are_structurally_safe(
+                DirectExecutorRole::Finalization,
+                &input_pointers,
+                &disjoint_outputs,
+                32,
+            )
+            .unwrap()
+        );
+        assert!(
+            !direct_outputs_are_structurally_safe(
+                DirectExecutorRole::Contribution,
+                &input_pointers,
+                &disjoint_outputs,
+                32,
+            )
+            .unwrap()
+        );
+        assert!(
+            !direct_outputs_are_structurally_safe(
+                DirectExecutorRole::Finalization,
+                &input_pointers,
+                &[inputs.as_mut_ptr()],
+                32,
+            )
+            .unwrap()
+        );
+        assert!(
+            !direct_outputs_are_structurally_safe(
+                DirectExecutorRole::Finalization,
+                &input_pointers,
+                &[output_re.as_mut_ptr(), output_re.as_mut_ptr()],
+                32,
+            )
+            .unwrap()
+        );
+    }
+
+    #[test]
+    fn contribution_scalar_simd_tails_apply_complex_scale_and_accumulate() {
+        let loaded = identity_executor(DirectExecutorRole::Contribution);
+        assert!(matches!(loaded.simd_lane_width(), 1 | 2 | 4));
+        let DirectExecutorHandle::Contribution { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        for &len in LENGTHS {
+            let mut current_re = vec![0.0; len * 2];
+            let mut current_im = vec![0.0; len * 2];
+            for point in 0..len {
+                current_re[point] = point as f64 + 0.25;
+                current_im[point] = 0.5 - point as f64 * 0.125;
+                current_re[len + point] = 7.0;
+                current_im[len + point] = -2.0;
+            }
+            let mut amplitude_re = vec![0.0; len];
+            let mut amplitude_im = vec![0.0; len];
+            let factors_re = [2.0];
+            let factors_im = [-0.5];
+            let (arena, momenta, parameters, factors) = views(
+                &mut current_re,
+                &mut current_im,
+                &mut amplitude_re,
+                &mut amplitude_im,
+                &[],
+                &[],
+                &factors_re,
+                &factors_im,
+                len,
+            );
+            let row = DirectContributionRow {
+                parent0_component_base: 0,
+                parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+                destination_component_base: 1,
+                exact_factor_id: 0,
+                selector_domain_id: 0,
+                flags: 0,
+            };
+            assert_eq!(
+                unsafe {
+                    call(
+                        context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                    )
+                },
+                DIRECT_STATUS_OK
+            );
+            for point in 0..len {
+                let re = point as f64 + 0.25;
+                let im = 0.5 - point as f64 * 0.125;
+                assert_eq!(current_re[len + point], 7.0 + re * 2.0 + im * 0.5);
+                assert_eq!(current_im[len + point], -2.0 - re * 0.5 + im * 2.0);
+            }
+        }
+    }
+
+    #[test]
+    fn initializing_contribution_overwrites_poisoned_complex_multipoint_destination() {
+        let loaded = identity_executor(DirectExecutorRole::Contribution);
+        let DirectExecutorHandle::Contribution { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        for &len in &[3, 7, 129] {
+            let mut current_re = vec![f64::NAN; len * 2];
+            let mut current_im = vec![f64::NAN; len * 2];
+            for point in 0..len {
+                current_re[point] = point as f64 + 0.25;
+                current_im[point] = 0.5 - point as f64 * 0.125;
+            }
+            let mut amplitude_re = vec![0.0; len];
+            let mut amplitude_im = vec![0.0; len];
+            let factors_re = [2.0];
+            let factors_im = [-0.5];
+            let (arena, momenta, parameters, factors) = views(
+                &mut current_re,
+                &mut current_im,
+                &mut amplitude_re,
+                &mut amplitude_im,
+                &[],
+                &[],
+                &factors_re,
+                &factors_im,
+                len,
+            );
+            let row = DirectContributionRow {
+                parent0_component_base: 0,
+                parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+                destination_component_base: 1,
+                exact_factor_id: 0,
+                selector_domain_id: 0,
+                flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            };
+            assert_eq!(
+                unsafe {
+                    call(
+                        context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                    )
+                },
+                DIRECT_STATUS_OK
+            );
+            for point in 0..len {
+                let re = point as f64 + 0.25;
+                let im = 0.5 - point as f64 * 0.125;
+                assert_eq!(current_re[len + point], re * 2.0 + im * 0.5);
+                assert_eq!(current_im[len + point], -re * 0.5 + im * 2.0);
+            }
+        }
+    }
+
+    #[test]
+    fn disjoint_identity_finalization_uses_direct_outputs_for_odd_tails() {
+        let loaded = parameter_broadcast_executor(DirectExecutorRole::Finalization);
+        assert!(matches!(loaded.simd_lane_width(), 1 | 2 | 4));
+        let DirectExecutorHandle::Finalization { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let row = DirectFinalizationRow {
+            component_base: 0,
+            component_count: 1,
+            momentum_form_id: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        let parameters_re = [2.5];
+        let parameters_im = [-0.75];
+        let factors_re = [1.0];
+        let factors_im = [0.0];
+        for &len in &[127, 129, 1023, 1025] {
+            let mut current_re = vec![f64::NAN; len];
+            let mut current_im = vec![f64::NAN; len];
+            let mut amplitude_re = vec![0.0; len];
+            let mut amplitude_im = vec![0.0; len];
+            let (arena, momenta, parameters, factors) = views(
+                &mut current_re,
+                &mut current_im,
+                &mut amplitude_re,
+                &mut amplitude_im,
+                &parameters_re,
+                &parameters_im,
+                &factors_re,
+                &factors_im,
+                len,
+            );
+            assert_eq!(
+                unsafe {
+                    call(
+                        context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                    )
+                },
+                DIRECT_STATUS_OK
+            );
+            assert_eq!(loaded.cached_direct_table_count(), 1);
+            assert!(current_re.iter().all(|&value| value == parameters_re[0]));
+            assert!(current_im.iter().all(|&value| value == parameters_im[0]));
+
+            current_re.fill(f64::NAN);
+            current_im.fill(f64::NAN);
+            let (status, allocations, bytes) = count_allocations(|| unsafe {
+                call(
+                    context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                )
+            });
+            assert_eq!(status, DIRECT_STATUS_OK);
+            assert_eq!((allocations, bytes), (0, 0));
+            assert!(current_re.iter().all(|&value| value == parameters_re[0]));
+            assert!(current_im.iter().all(|&value| value == parameters_im[0]));
+        }
+        assert_eq!(loaded.internal_traffic_bytes().0, 0);
+    }
+
+    #[test]
+    fn scalar_and_tiled_row_workspaces_remain_warm_independently() {
+        let loaded = parameter_broadcast_executor(DirectExecutorRole::Finalization);
+        let DirectExecutorHandle::Finalization { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let row = DirectFinalizationRow {
+            component_base: 0,
+            component_count: 1,
+            momentum_form_id: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        let parameters_re = [2.5];
+        let parameters_im = [-0.75];
+        let factors_re = [1.0];
+        let factors_im = [0.0];
+        let mut scalar_re = [f64::NAN; 1];
+        let mut scalar_im = [f64::NAN; 1];
+        let mut scalar_amplitude_re = [0.0; 1];
+        let mut scalar_amplitude_im = [0.0; 1];
+        let scalar = views(
+            &mut scalar_re,
+            &mut scalar_im,
+            &mut scalar_amplitude_re,
+            &mut scalar_amplitude_im,
+            &parameters_re,
+            &parameters_im,
+            &factors_re,
+            &factors_im,
+            1,
+        );
+        let mut tiled_re = [f64::NAN; 8];
+        let mut tiled_im = [f64::NAN; 8];
+        let mut tiled_amplitude_re = [0.0; 8];
+        let mut tiled_amplitude_im = [0.0; 8];
+        let tiled = views(
+            &mut tiled_re,
+            &mut tiled_im,
+            &mut tiled_amplitude_re,
+            &mut tiled_amplitude_im,
+            &parameters_re,
+            &parameters_im,
+            &factors_re,
+            &factors_im,
+            8,
+        );
+        for (views, points) in [(scalar, 1), (tiled, 8)] {
+            assert_eq!(
+                unsafe { call(context, views.0, views.1, views.2, views.3, &row, 1, points,) },
+                DIRECT_STATUS_OK
+            );
+        }
+        let (status, allocations, bytes) = count_allocations(|| unsafe {
+            call(context, scalar.0, scalar.1, scalar.2, scalar.3, &row, 1, 1)
+        });
+        assert_eq!(status, DIRECT_STATUS_OK);
+        assert_eq!((allocations, bytes), (0, 0));
+        assert_eq!(loaded.context.scalar_workspace.borrow().row_groups.len(), 1);
+        assert_eq!(loaded.context.tiled_workspace.borrow().row_groups.len(), 1);
+    }
+
+    #[test]
+    fn disjoint_nonidentity_finalization_uses_scratch_and_tracks_traffic() {
+        let loaded = parameter_broadcast_executor(DirectExecutorRole::Finalization);
+        let DirectExecutorHandle::Finalization { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let len = 129;
+        let mut current_re = vec![f64::NAN; len];
+        let mut current_im = vec![f64::NAN; len];
+        let mut amplitude_re = vec![0.0; len];
+        let mut amplitude_im = vec![0.0; len];
+        let parameters_re = [2.5];
+        let parameters_im = [-0.75];
+        let factors_re = [0.5];
+        let factors_im = [-0.25];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            &mut amplitude_re,
+            &mut amplitude_im,
+            &parameters_re,
+            &parameters_im,
+            &factors_re,
+            &factors_im,
+            len,
+        );
+        let row = DirectFinalizationRow {
+            component_base: 0,
+            component_count: 1,
+            momentum_form_id: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        assert_eq!(
+            unsafe {
+                call(
+                    context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+        assert_eq!(loaded.cached_direct_table_count(), 1);
+        let expected_re = parameters_re[0] * factors_re[0] - parameters_im[0] * factors_im[0];
+        let expected_im = parameters_re[0] * factors_im[0] + parameters_im[0] * factors_re[0];
+        assert!(current_re.iter().all(|&value| value == expected_re));
+        assert!(current_im.iter().all(|&value| value == expected_im));
+        let scratch_one_way = internal_plane_bytes(2, len, "test scratch traffic").unwrap();
+        assert_eq!(
+            loaded.internal_traffic_bytes().0,
+            scratch_one_way.saturating_mul(2)
+        );
+    }
+
+    #[test]
+    fn aliased_identity_finalization_stays_on_scratch() {
+        let loaded = identity_executor(DirectExecutorRole::Finalization);
+        let DirectExecutorHandle::Finalization { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let len = 129;
+        let mut current_re = (0..len).map(|point| point as f64 + 1.0).collect::<Vec<_>>();
+        let mut current_im = (0..len).map(|point| 3.0 - point as f64).collect::<Vec<_>>();
+        let expected_re = current_re.clone();
+        let expected_im = current_im.clone();
+        let mut amplitude_re = vec![0.0; len];
+        let mut amplitude_im = vec![0.0; len];
+        let factors_re = [1.0];
+        let factors_im = [0.0];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            &mut amplitude_re,
+            &mut amplitude_im,
+            &[],
+            &[],
+            &factors_re,
+            &factors_im,
+            len,
+        );
+        let row = DirectFinalizationRow {
+            component_base: 0,
+            component_count: 1,
+            momentum_form_id: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        assert_eq!(
+            unsafe {
+                call(
+                    context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+        assert_eq!(loaded.cached_direct_table_count(), 0);
+        assert_eq!(current_re, expected_re);
+        assert_eq!(current_im, expected_im);
+        let scratch_one_way = internal_plane_bytes(2, len, "test scratch traffic").unwrap();
+        assert_eq!(
+            loaded.internal_traffic_bytes().0,
+            scratch_one_way.saturating_mul(2)
+        );
+    }
+
+    #[test]
+    fn finalization_snapshots_input_before_overwrite() {
+        let loaded = identity_executor(DirectExecutorRole::Finalization);
+        let DirectExecutorHandle::Finalization { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let len = 129;
+        let mut current_re = (0..len).map(|point| point as f64 + 1.0).collect::<Vec<_>>();
+        let mut current_im = (0..len).map(|point| 3.0 - point as f64).collect::<Vec<_>>();
+        let original_re = current_re.clone();
+        let original_im = current_im.clone();
+        let mut amplitude_re = vec![0.0; len];
+        let mut amplitude_im = vec![0.0; len];
+        let factors_re = [0.25];
+        let factors_im = [0.75];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            &mut amplitude_re,
+            &mut amplitude_im,
+            &[],
+            &[],
+            &factors_re,
+            &factors_im,
+            len,
+        );
+        let row = DirectFinalizationRow {
+            component_base: 0,
+            component_count: 1,
+            momentum_form_id: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        assert_eq!(
+            unsafe {
+                call(
+                    context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+        for point in 0..len {
+            assert_eq!(
+                current_re[point],
+                original_re[point] * 0.25 - original_im[point] * 0.75
+            );
+            assert_eq!(
+                current_im[point],
+                original_re[point] * 0.75 + original_im[point] * 0.25
+            );
+        }
+    }
+
+    #[test]
+    fn row_group_cache_preserves_exact_identity_across_lookup_modes() {
+        let mut workspace = PlaneWorkspace::default();
+        let mut identities = vec![
+            RowTableIdentity {
+                role: DirectExecutorRole::Contribution,
+                address: 100,
+                row_count: 1,
+            },
+            RowTableIdentity {
+                role: DirectExecutorRole::Contribution,
+                address: 100,
+                row_count: 2,
+            },
+            RowTableIdentity {
+                role: DirectExecutorRole::Closure,
+                address: 100,
+                row_count: 1,
+            },
+            RowTableIdentity {
+                role: DirectExecutorRole::Contribution,
+                address: 101,
+                row_count: 1,
+            },
+        ];
+        identities.extend((102..230).map(|address| RowTableIdentity {
+            role: DirectExecutorRole::Finalization,
+            address,
+            row_count: 1,
+        }));
+        for (index, identity) in identities.iter().copied().enumerate() {
+            assert_eq!(workspace.cached_row_group_index(identity), None);
+            assert_eq!(
+                workspace
+                    .cache_row_group(CachedRowGroup {
+                        identity,
+                        rows: Vec::new(),
+                        descriptor_bytes: 0,
+                    })
+                    .unwrap(),
+                index
+            );
+            assert_eq!(
+                workspace.row_group_indices.is_empty(),
+                index < ROW_GROUP_LINEAR_LOOKUP_LIMIT
+            );
+            for (expected_index, cached_identity) in identities[..=index].iter().enumerate() {
+                assert_eq!(
+                    workspace.cached_row_group_index(*cached_identity),
+                    Some(expected_index)
+                );
+            }
+        }
+        let (_, allocations, _) = count_allocations(|| {
+            for (index, identity) in identities.iter().enumerate().rev() {
+                assert_eq!(workspace.cached_row_group_index(*identity), Some(index));
+            }
+        });
+        assert_eq!(allocations, 0);
+    }
+
+    #[test]
+    fn row_group_cache_invalidation_restarts_small_lookup() {
+        let mut workspace = PlaneWorkspace::default();
+        for address in 0..32 {
+            workspace
+                .cache_row_group(CachedRowGroup {
+                    identity: RowTableIdentity {
+                        role: DirectExecutorRole::Contribution,
+                        address,
+                        row_count: 1,
+                    },
+                    rows: Vec::new(),
+                    descriptor_bytes: 1,
+                })
+                .unwrap();
+        }
+        let old_identity = workspace.row_groups[31].identity;
+        assert_eq!(workspace.cached_row_group_index(old_identity), Some(31));
+        workspace.invalidate_row_tables();
+        assert!(workspace.row_groups.is_empty());
+        assert!(workspace.row_group_indices.is_empty());
+        assert_eq!(workspace.descriptor_bytes, 0);
+        assert_eq!(workspace.cached_row_group_index(old_identity), None);
+        assert_eq!(
+            workspace
+                .cache_row_group(CachedRowGroup {
+                    identity: old_identity,
+                    rows: Vec::new(),
+                    descriptor_bytes: 1,
+                })
+                .unwrap(),
+            0
+        );
+        assert!(workspace.row_group_indices.is_empty());
+        assert_eq!(workspace.cached_row_group_index(old_identity), Some(0));
+    }
+
+    #[test]
+    fn cached_row_group_reuses_one_scratch_set_sequentially() {
+        let loaded = identity_executor(DirectExecutorRole::Contribution);
+        let DirectExecutorHandle::Contribution { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let len = 7;
+        let mut current_re = vec![0.0; len * 4];
+        let mut current_im = vec![0.0; len * 4];
+        for point in 0..len {
+            current_re[point] = point as f64 + 1.0;
+            current_im[point] = 0.25;
+            current_re[2 * len + point] = 10.0 + point as f64;
+            current_im[2 * len + point] = -0.5;
+        }
+        let mut amplitude_re = vec![0.0; len];
+        let mut amplitude_im = vec![0.0; len];
+        let factors_re = [1.0];
+        let factors_im = [0.0];
+        let (arena, momenta, parameters, factors) = views(
+            &mut current_re,
+            &mut current_im,
+            &mut amplitude_re,
+            &mut amplitude_im,
+            &[],
+            &[],
+            &factors_re,
+            &factors_im,
+            len,
+        );
+        let rows = [
+            DirectContributionRow {
+                parent0_component_base: 0,
+                parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+                destination_component_base: 1,
+                exact_factor_id: 0,
+                selector_domain_id: 0,
+                flags: 0,
+            },
+            DirectContributionRow {
+                parent0_component_base: 2,
+                parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+                destination_component_base: 3,
+                exact_factor_id: 0,
+                selector_domain_id: 0,
+                flags: 0,
+            },
+        ];
+        assert_eq!(
+            unsafe {
+                call(
+                    context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    rows.as_ptr(),
+                    rows.len() as u32,
+                    len as u32,
+                )
+            },
+            DIRECT_STATUS_OK
+        );
+        for point in 0..len {
+            assert_eq!(current_re[len + point], point as f64 + 1.0);
+            assert_eq!(current_im[len + point], 0.25);
+            assert_eq!(current_re[3 * len + point], 10.0 + point as f64);
+            assert_eq!(current_im[3 * len + point], -0.5);
+        }
+        // A selected dependency run can share the same first row as a longer
+        // selection. Pointer equality alone must not reject the second table.
+        for row_count in [1, 2, 1] {
+            assert_eq!(
+                unsafe {
+                    call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        rows.as_ptr(),
+                        row_count,
+                        len as u32,
+                    )
+                },
+                DIRECT_STATUS_OK
+            );
+        }
+        assert_eq!(loaded.context.tiled_workspace.borrow().row_groups.len(), 2);
+    }
+
+    unsafe extern "C" fn initialize_stable_row_probe_sources(
+        _context: *const c_void,
+        arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        rows: *const DirectSourceRow,
+        row_count: u32,
+        point_count: u32,
+    ) -> c_int {
+        if rows.is_null() || row_count == 0 {
+            return STATUS_INVALID_ARGUMENT;
+        }
+        let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+        for row in rows {
+            for point in 0..point_count {
+                let destination = row.destination_component_base as usize
+                    * arena.point_stride as usize
+                    + point as usize;
+                unsafe {
+                    *arena.current_re.add(destination) =
+                        f64::from(row.destination_component_base + 1);
+                    *arena.current_im.add(destination) = 0.0;
+                }
+            }
+        }
+        DIRECT_STATUS_OK
+    }
+
+    struct StableRowProbeResolver {
+        source_key: OnTheFlyExecutorKeyV1,
+        contribution_key: OnTheFlyExecutorKeyV1,
+        contribution_handle: DirectExecutorHandle,
+    }
+
+    impl OnTheFlyPreparedExecutorResolver for StableRowProbeResolver {
+        fn resolve(&self, key: OnTheFlyExecutorKeyV1) -> RusticolResult<ResolvedOnTheFlyExecutor> {
+            if key == self.source_key {
+                return Ok(ResolvedOnTheFlyExecutor {
+                    direct_executor_id: 0,
+                    handle: DirectExecutorHandle::Source {
+                        call: initialize_stable_row_probe_sources,
+                        context: ptr::null(),
+                    },
+                    parent_permutation: [0, 1],
+                    packed_singleton_capable: false,
+                    interaction_capability: None,
+                });
+            }
+            if key == self.contribution_key {
+                return Ok(ResolvedOnTheFlyExecutor {
+                    direct_executor_id: 1,
+                    handle: self.contribution_handle,
+                    parent_permutation: [1, 0],
+                    packed_singleton_capable: false,
+                    interaction_capability: None,
+                });
+            }
+            Err(RusticolError::integrity(
+                "stable-row probe received an unknown executor key",
+            ))
+        }
+
+        fn invalidate_row_tables(&self) -> RusticolResult<()> {
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn on_the_fly_uses_stable_permuted_rows_across_symjit_warm_reuse() {
+        let loaded = identity_executor(DirectExecutorRole::Contribution);
+        let (mut trace, source_key, contribution_key) =
+            OnTheFlyStructuralTraceV1::test_two_contribution_rows();
+        let semantic_digest = trace.semantic_digest();
+        let parent_permutations =
+            BTreeMap::from([(source_key, [0, 1]), (contribution_key, [1, 0])]);
+        trace
+            .bind_prepared_executor_rows(&parent_permutations)
+            .unwrap();
+        assert_eq!(trace.semantic_digest(), semantic_digest);
+        assert!(
+            trace
+                .bind_prepared_executor_rows(&parent_permutations)
+                .is_err()
+        );
+        let rows = trace.test_bound_contribution_rows();
+        assert_eq!(
+            rows.iter()
+                .map(|row| {
+                    (
+                        row.parent0_component_base,
+                        row.parent1_component_base_or_sentinel,
+                        row.parent0_momentum_form_id,
+                        row.parent1_momentum_form_id_or_sentinel,
+                        row.destination_component_base,
+                    )
+                })
+                .collect::<Vec<_>>(),
+            vec![(1, 0, 1, 0, 2), (3, 0, 3, 0, 4)]
+        );
+
+        let resolver = StableRowProbeResolver {
+            source_key,
+            contribution_key,
+            contribution_handle: loaded.handle(),
+        };
+        let mut workspace = OnTheFlyWorkspaceV1::new(&trace, 1).unwrap();
+        for _ in 0..2 {
+            OnTheFlyStructuralInterpreter::execute(&trace, &resolver, &mut workspace, 1).unwrap();
+            assert_eq!(
+                workspace.observed_current_components(&trace, 2, 0).unwrap(),
+                vec![(2.0, 0.0)]
+            );
+            assert_eq!(
+                workspace.observed_current_components(&trace, 4, 0).unwrap(),
+                vec![(4.0, 0.0)]
+            );
+        }
+        // The legacy OTF interpreter keeps an aligned arena stride even for a
+        // one-point call, so its tables belong to the tiled cache. The newer
+        // packed-singleton path uses the independent scalar cache.
+        assert_eq!(loaded.context.tiled_workspace.borrow().row_groups.len(), 2);
+        loaded.invalidate_row_tables().unwrap();
+        for workspace in [
+            &loaded.context.scalar_workspace,
+            &loaded.context.tiled_workspace,
+        ] {
+            let workspace = workspace.borrow();
+            assert!(workspace.row_groups.is_empty());
+            assert!(workspace.row_group_indices.is_empty());
+            assert!(workspace.storage.is_none());
+            assert_eq!(workspace.descriptor_bytes, 0);
+        }
+    }
+
+    #[test]
+    fn model_parameter_broadcast_planes_refresh_without_reloading_kernel() {
+        let loaded = parameter_broadcast_executor(DirectExecutorRole::Contribution);
+        let DirectExecutorHandle::Contribution { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let len = 17;
+        let mut current_re = vec![0.0; len];
+        let mut current_im = vec![0.0; len];
+        let mut amplitude_re = vec![0.0; len];
+        let mut amplitude_im = vec![0.0; len];
+        let factors_re = [1.0];
+        let factors_im = [0.0];
+        let row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            destination_component_base: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        let mut expected_re = 0.0;
+        let mut expected_im = 0.0;
+        for (iteration, (parameter_re, parameter_im)) in [(2.5, -0.75), (-4.0, 1.25), (-4.0, 1.25)]
+            .into_iter()
+            .enumerate()
+        {
+            expected_re += parameter_re;
+            expected_im += parameter_im;
+            let parameters_re = [parameter_re];
+            let parameters_im = [parameter_im];
+            let (arena, momenta, parameters, factors) = views(
+                &mut current_re,
+                &mut current_im,
+                &mut amplitude_re,
+                &mut amplitude_im,
+                &parameters_re,
+                &parameters_im,
+                &factors_re,
+                &factors_im,
+                len,
+            );
+            let invoke = || unsafe {
+                call(
+                    context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                )
+            };
+            let status = if iteration == 0 {
+                invoke()
+            } else {
+                let (status, allocations, bytes) = count_allocations(invoke);
+                assert_eq!((allocations, bytes), (0, 0));
+                status
+            };
+            assert_eq!(status, DIRECT_STATUS_OK);
+            for point in 0..len {
+                assert_eq!(current_re[point], expected_re);
+                assert_eq!(current_im[point], expected_im);
+            }
+        }
+        let active_plane_bytes = 2 * len as u64 * size_of::<f64>() as u64;
+        assert_eq!(
+            loaded.internal_traffic_bytes(),
+            (
+                3 * 2 * active_plane_bytes,
+                3 * active_plane_bytes + 2 * active_plane_bytes,
+            )
+        );
+    }
+
+    #[test]
+    fn migration_contract_interns_repeated_parameter_and_zero_broadcasts() {
+        let loaded = repeated_parameter_and_zero_broadcast_executor();
+        assert_eq!(loaded.broadcast_plane_count(), 2);
+        assert_eq!(
+            loaded.context.broadcast_slot_by_binding.as_ref(),
+            [Some(0), Some(1), Some(0), Some(1)]
+        );
+        let DirectExecutorHandle::Contribution { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let len = 129;
+        let mut current_re = vec![1.0; len];
+        let mut current_im = vec![-2.0; len];
+        let mut amplitude_re = vec![0.0; len];
+        let mut amplitude_im = vec![0.0; len];
+        let factors_re = [1.0];
+        let factors_im = [0.0];
+        let row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            destination_component_base: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        let mut expected_re = 1.0;
+        for (iteration, parameter_re) in [2.5, 2.5, -4.0].into_iter().enumerate() {
+            expected_re += 2.0 * parameter_re;
+            let parameters_re = [parameter_re];
+            let parameters_im = [123.0];
+            let (arena, momenta, parameters, factors) = views(
+                &mut current_re,
+                &mut current_im,
+                &mut amplitude_re,
+                &mut amplitude_im,
+                &parameters_re,
+                &parameters_im,
+                &factors_re,
+                &factors_im,
+                len,
+            );
+            let invoke = || unsafe {
+                call(
+                    context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                )
+            };
+            let status = if iteration == 0 {
+                invoke()
+            } else {
+                let (status, allocations, bytes) = count_allocations(invoke);
+                assert_eq!((allocations, bytes), (0, 0));
+                status
+            };
+            assert_eq!(status, DIRECT_STATUS_OK);
+            assert!(current_re.iter().all(|&value| value == expected_re));
+            assert!(current_im.iter().all(|&value| value == -2.0));
+        }
+        assert_eq!(
+            loaded.context.tiled_workspace.borrow().broadcasts.len(),
+            2 * len
+        );
+        let plane_bytes = len as u64 * size_of::<f64>() as u64;
+        assert_eq!(
+            loaded.internal_traffic_bytes(),
+            (
+                3 * 4 * plane_bytes,
+                // Two shared planes are read on each call. Both are filled
+                // once, and only the parameter plane changes on the last call.
+                3 * 2 * plane_bytes + 3 * plane_bytes,
+            )
+        );
+    }
+
+    #[test]
+    fn multirow_call_refreshes_invariants_once_and_exact_factors_per_row() {
+        let loaded = mixed_invariant_and_exact_broadcast_executor();
+        assert_eq!(loaded.broadcast_plane_count(), 4);
+        assert_eq!(loaded.context.exact_factor_broadcast_slots.as_ref(), [2, 3]);
+        let DirectExecutorHandle::Contribution { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let len = 17;
+        let mut current_re = vec![0.0; 2 * len];
+        let mut current_im = vec![0.0; 2 * len];
+        let mut amplitude_re = vec![0.0; len];
+        let mut amplitude_im = vec![0.0; len];
+        let factors_re = [2.0, -1.0];
+        let factors_im = [-0.25, 0.75];
+        let first_row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            destination_component_base: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        let rows = [
+            first_row,
+            DirectContributionRow {
+                destination_component_base: 1,
+                exact_factor_id: 1,
+                ..first_row
+            },
+        ];
+        let expected_increment = |parameter_re: f64, parameter_im: f64, factor: usize| {
+            let kernel_re = parameter_re + factors_re[factor];
+            let kernel_im = parameter_im + factors_im[factor];
+            (
+                kernel_re * factors_re[factor] - kernel_im * factors_im[factor],
+                kernel_re * factors_im[factor] + kernel_im * factors_re[factor],
+            )
+        };
+        let invoke = |parameter_re: f64,
+                      parameter_im: f64,
+                      current_re: &mut [f64],
+                      current_im: &mut [f64],
+                      amplitude_re: &mut [f64],
+                      amplitude_im: &mut [f64]| {
+            let parameters_re = [parameter_re];
+            let parameters_im = [parameter_im];
+            let (arena, momenta, parameters, factors) = views(
+                current_re,
+                current_im,
+                amplitude_re,
+                amplitude_im,
+                &parameters_re,
+                &parameters_im,
+                &factors_re,
+                &factors_im,
+                len,
+            );
+            unsafe {
+                call(
+                    context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    rows.as_ptr(),
+                    rows.len() as u32,
+                    len as u32,
+                )
+            }
+        };
+
+        assert_eq!(
+            invoke(
+                3.0,
+                0.5,
+                &mut current_re,
+                &mut current_im,
+                &mut amplitude_re,
+                &mut amplitude_im,
+            ),
+            DIRECT_STATUS_OK
+        );
+        assert_eq!(loaded.broadcast_resolution_counts(), (2, 4));
+        for factor in 0..2 {
+            let (expected_re, expected_im) = expected_increment(3.0, 0.5, factor);
+            assert!(
+                current_re[factor * len..(factor + 1) * len]
+                    .iter()
+                    .all(|&value| value == expected_re)
+            );
+            assert!(
+                current_im[factor * len..(factor + 1) * len]
+                    .iter()
+                    .all(|&value| value == expected_im)
+            );
+        }
+
+        let (status, allocations, bytes) = count_allocations(|| {
+            invoke(
+                3.0,
+                0.5,
+                &mut current_re,
+                &mut current_im,
+                &mut amplitude_re,
+                &mut amplitude_im,
+            )
+        });
+        assert_eq!(status, DIRECT_STATUS_OK);
+        assert_eq!((allocations, bytes), (0, 0));
+        assert_eq!(loaded.broadcast_resolution_counts(), (4, 8));
+
+        assert_eq!(
+            invoke(
+                -4.0,
+                1.25,
+                &mut current_re,
+                &mut current_im,
+                &mut amplitude_re,
+                &mut amplitude_im,
+            ),
+            DIRECT_STATUS_OK
+        );
+        assert_eq!(loaded.broadcast_resolution_counts(), (6, 12));
+        for factor in 0..2 {
+            let (first_re, first_im) = expected_increment(3.0, 0.5, factor);
+            let (mutated_re, mutated_im) = expected_increment(-4.0, 1.25, factor);
+            assert!(
+                current_re[factor * len..(factor + 1) * len]
+                    .iter()
+                    .all(|&value| value == 2.0 * first_re + mutated_re)
+            );
+            assert!(
+                current_im[factor * len..(factor + 1) * len]
+                    .iter()
+                    .all(|&value| value == 2.0 * first_im + mutated_im)
+            );
+        }
+
+        let plane_bytes = len as u64 * size_of::<f64>() as u64;
+        assert_eq!(
+            loaded.internal_traffic_bytes(),
+            (
+                // Two scratch output planes are written and read for each of
+                // two rows on every call.
+                3 * 2 * 2 * 2 * plane_bytes,
+                // Four broadcast planes are read per row. Refreshes are 6 on
+                // the cold call, 4 on the identical warm call, then 6 after
+                // both model-parameter planes mutate.
+                (3 * 2 * 4 + 6 + 4 + 6) * plane_bytes,
+            )
+        );
+    }
+
+    #[test]
+    fn warmed_recurrence_plane_call_allocates_nothing() {
+        let loaded = identity_executor(DirectExecutorRole::Contribution);
+        let DirectExecutorHandle::Contribution { call, context } = loaded.handle() else {
+            unreachable!()
+        };
+        let mut expected_scratch_bytes = 0;
+        for &len in &[127, 129, 1023, 1025] {
+            let mut current_re = vec![1.0; len * 2];
+            let mut current_im = vec![0.5; len * 2];
+            let mut amplitude_re = vec![0.0; len];
+            let mut amplitude_im = vec![0.0; len];
+            let factors_re = [1.0];
+            let factors_im = [0.0];
+            let (arena, momenta, parameters, factors) = views(
+                &mut current_re,
+                &mut current_im,
+                &mut amplitude_re,
+                &mut amplitude_im,
+                &[],
+                &[],
+                &factors_re,
+                &factors_im,
+                len,
+            );
+            let row = DirectContributionRow {
+                parent0_component_base: 0,
+                parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+                destination_component_base: 1,
+                exact_factor_id: 0,
+                selector_domain_id: 0,
+                flags: 0,
+            };
+            assert_eq!(
+                unsafe {
+                    call(
+                        context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                    )
+                },
+                DIRECT_STATUS_OK
+            );
+            let (status, allocations, bytes) = count_allocations(|| unsafe {
+                call(
+                    context, arena, momenta, parameters, factors, &row, 1, len as u32,
+                )
+            });
+            assert_eq!(status, DIRECT_STATUS_OK);
+            assert_eq!(
+                (allocations, bytes),
+                (0, 0),
+                "warmed recurrence call allocated for {len} points"
+            );
+            let scratch_one_way = internal_plane_bytes(2, len, "test scratch traffic").unwrap();
+            expected_scratch_bytes += scratch_one_way.saturating_mul(4);
+        }
+        assert_eq!(loaded.cached_direct_table_count(), 0);
+        assert_eq!(loaded.internal_traffic_bytes().0, expected_scratch_bytes);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_eager_direct.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_eager_direct.rs
new file mode 100644
index 0000000000..bbef7136d5
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_eager_direct.rs
@@ -0,0 +1,2234 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Eager-lane orchestration for standard SymJIT direct-arena P-kernels.
+//!
+//! SymJIT owns only the ordinary plane kernel. Rusticol authenticates and
+//! decodes immutable invocation/attachment rows, preserves their order and
+//! hazards, and implements factors, overwrite/add, and fanout. A single safe
+//! identity overwrite binds outputs directly; every other invocation writes
+//! once to persistent split-complex scratch and fans out in allocation-free
+//! Rust loops. Native C++/ASM table callables retain their public C layout.
+
+use super::symjit_plane::{PlaneDescriptor, SymjitPlaneKernel, SymjitPlaneLayout};
+use crate::artifact::PinnedNativeLibrary;
+use crate::direct_arena::{DirectArenaView, DirectArenaWorkspace};
+pub(crate) use crate::eager_layout::{
+    EAGER_DIRECT_SOURCE_APPLICATION_ABI, EAGER_DIRECT_TABLE_BINDING_ABI,
+    EAGER_DIRECT_TABLE_DESCRIPTOR_ABI, EAGER_NATIVE_DIRECT_TABLE_APPLICATION_ABI,
+};
+use crate::{RusticolError, RusticolResult};
+use sha2::{Digest, Sha256};
+use std::any::Any;
+#[cfg(feature = "f64-compiled")]
+use std::ffi::CStr;
+#[cfg(feature = "f64-compiled")]
+use std::os::raw::c_char;
+use std::panic::{AssertUnwindSafe, catch_unwind};
+use std::path::{Path, PathBuf};
+use std::ptr;
+use std::sync::Arc;
+#[cfg(target_arch = "aarch64")]
+use wide::f64x2;
+#[cfg(target_arch = "x86_64")]
+use wide::f64x4;
+
+const EAGER_PLANE_DESCRIPTOR_MAGIC: [u8; 8] = *b"PACETD01";
+const EAGER_PLANE_DESCRIPTOR_VERSION: u32 = 1;
+const EAGER_PLANE_DESCRIPTOR_SIZE: usize = 64;
+const EAGER_DESTINATION_OVERWRITE: u32 = 0;
+const EAGER_DESTINATION_ACCUMULATE: u32 = 1;
+const DIRECT_STATUS_OK: i32 = 0;
+const DIRECT_STATUS_INVALID_CONTEXT: i32 = 1;
+const DIRECT_STATUS_INVALID_ARGUMENT: i32 = 2;
+const DIRECT_STATUS_EXECUTION_FAILED: i32 = 3;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct EagerDirectTableMetadata {
+    input_complex_count: u32,
+    output_complex_count: u32,
+    input_plane_count: usize,
+    output_plane_count: usize,
+    invocation_stride: u32,
+    attachment_stride: u32,
+}
+
+impl EagerDirectTableMetadata {
+    fn new(input_complex_count: u32, output_complex_count: u32) -> RusticolResult<Self> {
+        if input_complex_count == 0 || output_complex_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "eager direct-table input and output widths must be positive",
+            ));
+        }
+        let input_plane_count_u32 = input_complex_count.checked_mul(2).ok_or_else(|| {
+            RusticolError::invalid_argument("eager direct-table input width overflows")
+        })?;
+        let output_plane_count_u32 = output_complex_count.checked_mul(2).ok_or_else(|| {
+            RusticolError::invalid_argument("eager direct-table output width overflows")
+        })?;
+        let invocation_stride = input_plane_count_u32
+            .checked_add(2)
+            .and_then(|count| count.checked_mul(4))
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("eager direct-table invocation row overflows")
+            })?;
+        let attachment_stride = output_plane_count_u32
+            .checked_add(2)
+            .and_then(|count| count.checked_mul(4))
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("eager direct-table attachment row overflows")
+            })?;
+        Ok(Self {
+            input_complex_count,
+            output_complex_count,
+            input_plane_count: input_plane_count_u32 as usize,
+            output_plane_count: output_plane_count_u32 as usize,
+            invocation_stride,
+            attachment_stride,
+        })
+    }
+
+    const fn layout(self) -> SymjitPlaneLayout {
+        SymjitPlaneLayout::complex(
+            self.input_complex_count as usize,
+            self.output_complex_count as usize,
+        )
+    }
+
+    const fn attachment_start_offset(self) -> usize {
+        self.input_plane_count * std::mem::size_of::<u32>()
+    }
+
+    const fn attachment_count_offset(self) -> usize {
+        self.attachment_start_offset() + std::mem::size_of::<u32>()
+    }
+
+    const fn scale_offset(self) -> usize {
+        self.output_plane_count * std::mem::size_of::<u32>()
+    }
+
+    const fn operation_offset(self) -> usize {
+        self.scale_offset() + std::mem::size_of::<u32>()
+    }
+}
+
+/// Derive the authenticated Rusticol plane-table descriptor for one prepared
+/// P-kernel. The function signature is retained for Python artifact generation.
+pub(crate) fn eager_direct_descriptor_for_source_application_bytes(
+    source_bytes: &[u8],
+    input_complex_count: u32,
+    output_complex_count: u32,
+    display_path: &Path,
+) -> RusticolResult<Vec<u8>> {
+    let metadata = EagerDirectTableMetadata::new(input_complex_count, output_complex_count)?;
+    // Loading here proves that generation cannot bind a B-kernel, a malformed
+    // application, or mismatched split-plane dimensions.
+    let _kernel = SymjitPlaneKernel::load_bytes(source_bytes, display_path, metadata.layout())?;
+    Ok(encode_plane_descriptor(source_bytes, metadata))
+}
+
+fn encode_plane_descriptor(source_bytes: &[u8], metadata: EagerDirectTableMetadata) -> Vec<u8> {
+    let digest = Sha256::digest(source_bytes);
+    let mut bytes = Vec::with_capacity(EAGER_PLANE_DESCRIPTOR_SIZE);
+    bytes.extend_from_slice(&EAGER_PLANE_DESCRIPTOR_MAGIC);
+    push_descriptor_u32(&mut bytes, EAGER_PLANE_DESCRIPTOR_VERSION);
+    push_descriptor_u32(&mut bytes, EAGER_PLANE_DESCRIPTOR_SIZE as u32);
+    push_descriptor_u32(&mut bytes, metadata.input_complex_count);
+    push_descriptor_u32(&mut bytes, metadata.output_complex_count);
+    push_descriptor_u32(&mut bytes, metadata.invocation_stride);
+    push_descriptor_u32(&mut bytes, metadata.attachment_stride);
+    bytes.extend_from_slice(&digest);
+    debug_assert_eq!(bytes.len(), EAGER_PLANE_DESCRIPTOR_SIZE);
+    bytes
+}
+
+fn decode_plane_descriptor(
+    source_bytes: &[u8],
+    descriptor_bytes: &[u8],
+    display_path: &Path,
+) -> RusticolResult<EagerDirectTableMetadata> {
+    let regenerate = || {
+        RusticolError::compatibility(format!(
+            "eager plane-table descriptor {} is not compatible with the SymJIT 2.22 P-kernel ABI; regenerate the prepared model",
+            display_path.display()
+        ))
+    };
+    if descriptor_bytes.len() != EAGER_PLANE_DESCRIPTOR_SIZE
+        || descriptor_bytes.get(..8) != Some(EAGER_PLANE_DESCRIPTOR_MAGIC.as_slice())
+        || read_descriptor_u32(descriptor_bytes, 8)? != EAGER_PLANE_DESCRIPTOR_VERSION
+        || read_descriptor_u32(descriptor_bytes, 12)? != EAGER_PLANE_DESCRIPTOR_SIZE as u32
+    {
+        return Err(regenerate());
+    }
+    let metadata = EagerDirectTableMetadata::new(
+        read_descriptor_u32(descriptor_bytes, 16)?,
+        read_descriptor_u32(descriptor_bytes, 20)?,
+    )?;
+    if read_descriptor_u32(descriptor_bytes, 24)? != metadata.invocation_stride
+        || read_descriptor_u32(descriptor_bytes, 28)? != metadata.attachment_stride
+    {
+        return Err(RusticolError::integrity(format!(
+            "eager plane-table descriptor {} has inconsistent canonical row strides",
+            display_path.display()
+        )));
+    }
+    let digest = Sha256::digest(source_bytes);
+    if descriptor_bytes[32..] != digest[..] {
+        return Err(RusticolError::integrity(format!(
+            "eager plane-table descriptor {} does not authenticate its P-kernel source",
+            display_path.display()
+        )));
+    }
+    Ok(metadata)
+}
+
+fn push_descriptor_u32(bytes: &mut Vec<u8>, value: u32) {
+    bytes.extend_from_slice(&value.to_le_bytes());
+}
+
+fn read_descriptor_u32(bytes: &[u8], offset: usize) -> RusticolResult<u32> {
+    let encoded = bytes
+        .get(offset..offset + 4)
+        .ok_or_else(|| RusticolError::integrity("eager plane-table descriptor is truncated"))?;
+    Ok(u32::from_le_bytes(encoded.try_into().map_err(|_| {
+        RusticolError::internal("could not decode eager descriptor field")
+    })?))
+}
+
+/// One persistent plane-catalog entry backed by the eager arena.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum EagerDirectArenaPlaneBinding {
+    CurrentReal(u32),
+    CurrentImag(u32),
+    AmplitudeReal(u32),
+    AmplitudeImag(u32),
+}
+
+/// Rusticol-owned ABI twin retained for native C++/ASM callables.
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+struct EagerDirectPlane {
+    values: *mut f64,
+    len: usize,
+}
+
+/// Rusticol-owned ABI twin retained for native C++/ASM callables.
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+struct EagerDirectScalar {
+    value: *const f64,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct ParsedInvocation {
+    input_start: usize,
+    attachment_start: u32,
+    attachment_count: u32,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct ParsedAttachment {
+    destination_start: usize,
+    factor: u32,
+    operation: u32,
+}
+
+/// Immutable raw rows plus their cold-decoded Rust orchestration form.
+#[derive(Debug)]
+pub(crate) struct EagerDirectTableRows {
+    invocations_raw: Box<[u8]>,
+    attachments_raw: Box<[u8]>,
+    invocations: Box<[ParsedInvocation]>,
+    input_planes: Box<[u32]>,
+    attachments: Box<[ParsedAttachment]>,
+    destination_planes: Box<[u32]>,
+    input_plane_count: usize,
+    output_plane_count: usize,
+}
+
+impl EagerDirectTableRows {
+    pub(crate) fn invocation_count(&self) -> u32 {
+        self.invocations.len() as u32
+    }
+
+    pub(crate) fn attachment_count(&self) -> u32 {
+        self.attachments.len() as u32
+    }
+}
+
+/// Persistent eager arena, native catalogs, P-kernel descriptors, and scratch.
+pub(crate) struct EagerDirectTableWorkspace {
+    arena: DirectArenaWorkspace,
+    planes: Box<[EagerDirectPlane]>,
+    /// Plane-catalog entry reserved as an immutable structural zero for
+    /// real-only SymJIT inputs. Native tables never use this remapping.
+    read_only_zero_plane_index: Option<u32>,
+    // Own the stable allocations addressed by `scalars`.
+    _scalar_values: Box<[f64]>,
+    scalars: Box<[EagerDirectScalar]>,
+    factor_re: Box<[f64]>,
+    factor_im: Box<[f64]>,
+    symjit_descriptors: Vec<PlaneDescriptor<'static>>,
+    symjit_scratch: Vec<f64>,
+    internal_scratch_bytes: u64,
+}
+
+impl EagerDirectTableWorkspace {
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn new(
+        current_plane_count: u32,
+        amplitude_plane_count: u32,
+        tile_capacity: u32,
+        plane_bindings: &[EagerDirectArenaPlaneBinding],
+        read_only_zero_plane_index: Option<u32>,
+        scalar_values: Vec<f64>,
+        factor_re: Vec<f64>,
+        factor_im: Vec<f64>,
+    ) -> RusticolResult<Self> {
+        if plane_bindings.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "eager direct-table plane catalog must not be empty",
+            ));
+        }
+        if factor_re.is_empty() || factor_re.len() != factor_im.len() {
+            return Err(RusticolError::invalid_argument(
+                "eager direct-table factors must be nonempty split-complex pairs",
+            ));
+        }
+        let _ = u32::try_from(plane_bindings.len()).map_err(|_| {
+            RusticolError::invalid_argument("eager direct-table plane catalog exceeds u32")
+        })?;
+        if let Some(zero_plane) = read_only_zero_plane_index {
+            let zero_binding = plane_bindings.get(zero_plane as usize).ok_or_else(|| {
+                RusticolError::invalid_argument(format!(
+                    "eager direct-table shared-zero plane {zero_plane} exceeds catalog size {}",
+                    plane_bindings.len()
+                ))
+            })?;
+            if !matches!(zero_binding, EagerDirectArenaPlaneBinding::CurrentImag(_)) {
+                return Err(RusticolError::invalid_argument(format!(
+                    "eager direct-table shared-zero plane {zero_plane} is not an imaginary current plane"
+                )));
+            }
+            if plane_bindings
+                .iter()
+                .enumerate()
+                .any(|(index, binding)| index != zero_plane as usize && binding == zero_binding)
+            {
+                return Err(RusticolError::invalid_argument(format!(
+                    "eager direct-table shared-zero plane {zero_plane} has an aliased catalog binding"
+                )));
+            }
+        }
+        let _ = u32::try_from(scalar_values.len()).map_err(|_| {
+            RusticolError::invalid_argument("eager direct-table scalar catalog exceeds u32")
+        })?;
+        let _ = u32::try_from(factor_re.len()).map_err(|_| {
+            RusticolError::invalid_argument("eager direct-table factor catalog exceeds u32")
+        })?;
+        let mut arena =
+            DirectArenaWorkspace::new(current_plane_count, amplitude_plane_count, tile_capacity)?;
+        arena.begin_tile(tile_capacity)?;
+        let view = arena.view()?;
+        let mut planes = Vec::new();
+        planes
+            .try_reserve_exact(plane_bindings.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not reserve eager direct-table plane catalog: {error}"
+                ))
+            })?;
+        for &binding in plane_bindings {
+            planes.push(bind_arena_plane(view, binding)?);
+        }
+
+        let scalar_values = scalar_values.into_boxed_slice();
+        let scalars = scalar_values
+            .iter()
+            .map(|value| EagerDirectScalar {
+                value: ptr::from_ref(value),
+            })
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+        Ok(Self {
+            arena,
+            planes: planes.into_boxed_slice(),
+            read_only_zero_plane_index,
+            _scalar_values: scalar_values,
+            scalars,
+            factor_re: factor_re.into_boxed_slice(),
+            factor_im: factor_im.into_boxed_slice(),
+            symjit_descriptors: Vec::new(),
+            symjit_scratch: Vec::new(),
+            internal_scratch_bytes: 0,
+        })
+    }
+
+    pub(crate) fn begin_tile(&mut self, point_count: u32) -> RusticolResult<()> {
+        self.arena.begin_tile(point_count)
+    }
+
+    pub(crate) fn arena(&self) -> &DirectArenaWorkspace {
+        &self.arena
+    }
+
+    pub(crate) fn split_arena_slices_mut(
+        &mut self,
+    ) -> (&mut [f64], &mut [f64], &mut [f64], &mut [f64]) {
+        self.arena.split_slices_mut()
+    }
+
+    pub(crate) fn clear_current_active(
+        &mut self,
+        component_base: u32,
+        component_count: u32,
+    ) -> RusticolResult<()> {
+        self.arena
+            .clear_current_active(component_base, component_count)
+    }
+
+    pub(crate) fn clear_amplitude_active(
+        &mut self,
+        component_base: u32,
+        component_count: u32,
+    ) -> RusticolResult<()> {
+        self.arena
+            .clear_amplitude_active(component_base, component_count)
+    }
+
+    /// Retained for cold scalar refresh paths; current eager manifests bind
+    /// immutable scalar catalogs.
+    #[allow(dead_code)]
+    pub(crate) fn scalar_values_mut(&mut self) -> &mut [f64] {
+        &mut self._scalar_values
+    }
+
+    pub(crate) fn factors_mut(&mut self) -> (&mut [f64], &mut [f64]) {
+        (&mut self.factor_re, &mut self.factor_im)
+    }
+
+    pub(crate) const fn internal_scratch_bytes(&self) -> u64 {
+        self.internal_scratch_bytes
+    }
+
+    pub(crate) fn symjit_descriptor_storage_bytes(
+        descriptor_count: usize,
+    ) -> RusticolResult<usize> {
+        descriptor_count
+            .checked_mul(std::mem::size_of::<PlaneDescriptor<'static>>())
+            .ok_or_else(|| RusticolError::internal("eager descriptor storage size overflows"))
+    }
+
+    pub(crate) fn symjit_workspace_bytes(&self) -> RusticolResult<usize> {
+        Self::symjit_descriptor_storage_bytes(self.symjit_descriptors.capacity())?
+            .checked_add(
+                self.symjit_scratch
+                    .capacity()
+                    .checked_mul(std::mem::size_of::<f64>())
+                    .ok_or_else(|| {
+                        RusticolError::internal("eager scratch storage size overflows")
+                    })?,
+            )
+            .ok_or_else(|| RusticolError::internal("eager SymJIT workspace size overflows"))
+    }
+
+    fn prepare_symjit(&mut self, metadata: EagerDirectTableMetadata) -> RusticolResult<()> {
+        let descriptor_count = metadata
+            .input_plane_count
+            .checked_add(metadata.output_plane_count)
+            .ok_or_else(|| RusticolError::internal("eager descriptor count overflows"))?;
+        if self.symjit_descriptors.capacity() < descriptor_count {
+            self.symjit_descriptors
+                .try_reserve_exact(descriptor_count - self.symjit_descriptors.len())
+                .map_err(|error| {
+                    RusticolError::internal(format!(
+                        "could not reserve eager P-kernel descriptors: {error}"
+                    ))
+                })?;
+        }
+        let scratch_len = metadata
+            .output_plane_count
+            .checked_mul(self.arena.point_stride() as usize)
+            .ok_or_else(|| RusticolError::internal("eager scratch size overflows"))?;
+        if self.symjit_scratch.len() < scratch_len {
+            self.symjit_scratch
+                .try_reserve_exact(scratch_len - self.symjit_scratch.len())
+                .map_err(|error| {
+                    RusticolError::internal(format!(
+                        "could not reserve eager P-kernel scratch: {error}"
+                    ))
+                })?;
+            self.symjit_scratch.resize(scratch_len, 0.0);
+        }
+        Ok(())
+    }
+
+    fn checked_range(&self, point_start: u32, point_count: u32) -> RusticolResult<(usize, usize)> {
+        if point_count == 0 {
+            return Err(RusticolError::invalid_argument(
+                "eager direct-table point count must be positive",
+            ));
+        }
+        let point_stop = point_start.checked_add(point_count).ok_or_else(|| {
+            RusticolError::invalid_argument("eager direct-table point range overflows u32")
+        })?;
+        if point_stop > self.arena.active_point_count() {
+            return Err(RusticolError::invalid_argument(format!(
+                "eager direct-table point range {point_start}..{point_stop} exceeds active tile {}",
+                self.arena.active_point_count()
+            )));
+        }
+        Ok((point_start as usize, point_stop as usize))
+    }
+
+    fn native_view(
+        &self,
+        rows: &EagerDirectTableRows,
+        metadata: EagerDirectTableMetadata,
+        point_start: u32,
+        point_count: u32,
+    ) -> RusticolResult<EagerDirectTableCallViewV1> {
+        let _ = self.checked_range(point_start, point_count)?;
+        Ok(EagerDirectTableCallViewV1 {
+            invocations: rows.invocations_raw.as_ptr(),
+            invocation_count: rows.invocation_count(),
+            invocation_stride: metadata.invocation_stride,
+            attachments: rows.attachments_raw.as_ptr(),
+            attachment_count: rows.attachment_count(),
+            attachment_stride: metadata.attachment_stride,
+            planes: self.planes.as_ptr(),
+            plane_count: self.planes.len() as u32,
+            scalar_count: self.scalars.len() as u32,
+            scalars: if self.scalars.is_empty() {
+                ptr::null()
+            } else {
+                self.scalars.as_ptr()
+            },
+            scale_re: self.factor_re.as_ptr(),
+            scale_im: self.factor_im.as_ptr(),
+            scale_count: self.factor_re.len() as u32,
+            point_start,
+            point_count,
+        })
+    }
+}
+
+/// Loaded owner of one prepared eager callable.
+pub(crate) struct LoadedSymjitEagerDirectTable {
+    callable: EagerDirectTableCallable,
+    display_path: PathBuf,
+}
+
+// Keep the callable inline: it is cold-built once, while boxing it would add a
+// separately tracked allocation and indirection to every warmed dispatch.
+#[allow(clippy::large_enum_variant)]
+enum EagerDirectTableCallable {
+    Symjit {
+        kernel: SymjitPlaneKernel,
+        metadata: EagerDirectTableMetadata,
+    },
+    #[cfg(feature = "f64-compiled")]
+    Native(LoadedNativeEagerDirectTable),
+}
+
+#[derive(Clone, Copy)]
+#[repr(C)]
+struct EagerDirectTableCallViewV1 {
+    invocations: *const u8,
+    invocation_count: u32,
+    invocation_stride: u32,
+    attachments: *const u8,
+    attachment_count: u32,
+    attachment_stride: u32,
+    planes: *const EagerDirectPlane,
+    plane_count: u32,
+    scalar_count: u32,
+    scalars: *const EagerDirectScalar,
+    scale_re: *const f64,
+    scale_im: *const f64,
+    scale_count: u32,
+    point_start: u32,
+    point_count: u32,
+}
+
+#[cfg(feature = "f64-compiled")]
+type NativeEagerDirectTableCall = unsafe extern "C" fn(*const EagerDirectTableCallViewV1) -> i32;
+
+#[cfg(feature = "f64-compiled")]
+#[repr(C)]
+struct NativeEagerDirectTableMetadataV1 {
+    struct_size: u32,
+    abi_version: u32,
+    flags: u32,
+    invocation_stride: u32,
+    attachment_stride: u32,
+    input_complex_count: u32,
+    output_complex_count: u32,
+    simd_lane_width: u32,
+    application_abi: *const c_char,
+    function_name: *const c_char,
+    target_triple: *const c_char,
+    evaluator_state_sha256: *const c_char,
+}
+
+#[cfg(feature = "f64-compiled")]
+type NativeEagerDirectTableMetadataCall =
+    unsafe extern "C" fn() -> *const NativeEagerDirectTableMetadataV1;
+
+#[cfg(feature = "f64-compiled")]
+const NATIVE_EAGER_DIRECT_TABLE_METADATA_VERSION: u32 = 1;
+#[cfg(feature = "f64-compiled")]
+const NATIVE_EAGER_DIRECT_TABLE_REQUIRED_FLAGS: u32 = 0x1f;
+
+#[cfg(feature = "f64-compiled")]
+struct LoadedNativeEagerDirectTable {
+    _library: Arc<PinnedNativeLibrary>,
+    call: NativeEagerDirectTableCall,
+    metadata: EagerDirectTableMetadata,
+}
+
+impl LoadedSymjitEagerDirectTable {
+    /// Whether this callable consumes SymJIT P-kernel plane descriptors.
+    ///
+    /// Native C++/ASM tables retain their original per-semantic plane IDs.
+    pub(crate) fn is_symjit(&self) -> bool {
+        matches!(&self.callable, EagerDirectTableCallable::Symjit { .. })
+    }
+
+    /// Fixed workspace shape required by this callable.
+    ///
+    /// The first element is the cold descriptor count. The second is the
+    /// number of point-pitched scalar scratch planes. Native table callables
+    /// own their workspace and therefore report no Rust-side SymJIT shape.
+    pub(crate) fn symjit_workspace_shape(&self) -> Option<(usize, usize)> {
+        match &self.callable {
+            EagerDirectTableCallable::Symjit { metadata, .. } => Some((
+                metadata.input_plane_count + metadata.output_plane_count,
+                metadata.output_plane_count,
+            )),
+            #[cfg(feature = "f64-compiled")]
+            EagerDirectTableCallable::Native(_) => None,
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn load_prepared_application_bytes(
+        source_bytes: &[u8],
+        descriptor_bytes: &[u8],
+        display_path: PathBuf,
+        source_application_abi: &str,
+        descriptor_abi: &str,
+        binding_abi: &str,
+        expected_optimization_level: u32,
+        expected_compression: bool,
+    ) -> RusticolResult<Self> {
+        validate_portable_abis(source_application_abi, descriptor_abi, binding_abi)?;
+        let metadata = decode_plane_descriptor(source_bytes, descriptor_bytes, &display_path)?;
+        let kernel = SymjitPlaneKernel::load_bytes(source_bytes, &display_path, metadata.layout())?;
+        if u32::from(kernel.optimization_level()) != expected_optimization_level {
+            return Err(RusticolError::integrity(format!(
+                "eager SymJIT plane application {} stores optimization level {}, but its \
+                 authenticated prepared-kernel variant declares optimization level \
+                 {expected_optimization_level}; regenerate the prepared model",
+                display_path.display(),
+                kernel.optimization_level(),
+            )));
+        }
+        if kernel.compression() != expected_compression {
+            return Err(RusticolError::integrity(format!(
+                "eager SymJIT plane application {} stores compression {}, but its \
+                 authenticated prepared-kernel manifest declares compression \
+                 {expected_compression}; regenerate the prepared model",
+                display_path.display(),
+                kernel.compression(),
+            )));
+        }
+        Ok(Self {
+            callable: EagerDirectTableCallable::Symjit { kernel, metadata },
+            display_path,
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn load_native_application(
+        library: Arc<PinnedNativeLibrary>,
+        function_name: &str,
+        display_path: PathBuf,
+        source_application_abi: &str,
+        invocation_stride: u32,
+        attachment_stride: u32,
+        input_complex_count: u32,
+        output_complex_count: u32,
+        expected_target_triple: &str,
+        expected_evaluator_state_sha256: &str,
+        expected_simd_lane_width: u32,
+    ) -> RusticolResult<Self> {
+        if source_application_abi != EAGER_NATIVE_DIRECT_TABLE_APPLICATION_ABI {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported native eager DirectTable application ABI {source_application_abi:?}; expected {EAGER_NATIVE_DIRECT_TABLE_APPLICATION_ABI:?}"
+            )));
+        }
+        validate_c_symbol(function_name)?;
+        let metadata = EagerDirectTableMetadata::new(input_complex_count, output_complex_count)?;
+        if metadata.invocation_stride != invocation_stride
+            || metadata.attachment_stride != attachment_stride
+        {
+            return Err(RusticolError::integrity(format!(
+                "native eager DirectTable {} row strides ({invocation_stride}, {attachment_stride}) do not match ({}, {})",
+                display_path.display(),
+                metadata.invocation_stride,
+                metadata.attachment_stride,
+            )));
+        }
+        #[cfg(not(feature = "f64-compiled"))]
+        {
+            let _ = (
+                library,
+                function_name,
+                metadata,
+                expected_target_triple,
+                expected_evaluator_state_sha256,
+                expected_simd_lane_width,
+            );
+            return Err(RusticolError::compatibility(
+                "native eager DirectTable execution requires the f64-compiled feature",
+            ));
+        }
+        #[cfg(feature = "f64-compiled")]
+        {
+            let library_path = library.display_path();
+            let metadata_symbol_name = format!("{function_name}_metadata_v1");
+            let metadata_call = unsafe {
+                library
+                    .get::<NativeEagerDirectTableMetadataCall>(metadata_symbol_name.as_bytes())
+                    .map(|symbol| *symbol)
+                    .map_err(|error| {
+                        RusticolError::compatibility(format!(
+                            "could not load native eager DirectTable metadata symbol {metadata_symbol_name:?} from {}: {error}",
+                            library_path.display()
+                        ))
+                    })?
+            };
+            let exported = unsafe { metadata_call() };
+            if exported.is_null() {
+                return Err(RusticolError::integrity(format!(
+                    "native eager DirectTable {} returned null ABI metadata",
+                    display_path.display()
+                )));
+            }
+            let exported = unsafe { &*exported };
+            let expected_struct_size =
+                u32::try_from(std::mem::size_of::<NativeEagerDirectTableMetadataV1>())
+                    .expect("native eager metadata size fits u32");
+            if exported.struct_size != expected_struct_size
+                || exported.abi_version != NATIVE_EAGER_DIRECT_TABLE_METADATA_VERSION
+                || exported.flags != NATIVE_EAGER_DIRECT_TABLE_REQUIRED_FLAGS
+                || exported.invocation_stride != invocation_stride
+                || exported.attachment_stride != attachment_stride
+                || exported.input_complex_count != input_complex_count
+                || exported.output_complex_count != output_complex_count
+                || exported.simd_lane_width != expected_simd_lane_width
+            {
+                return Err(RusticolError::compatibility(format!(
+                    "native eager DirectTable {} exports incompatible ABI metadata",
+                    display_path.display()
+                )));
+            }
+            for (label, pointer, expected) in [
+                (
+                    "application ABI",
+                    exported.application_abi,
+                    source_application_abi,
+                ),
+                ("function name", exported.function_name, function_name),
+                (
+                    "target triple",
+                    exported.target_triple,
+                    expected_target_triple,
+                ),
+                (
+                    "evaluator-state digest",
+                    exported.evaluator_state_sha256,
+                    expected_evaluator_state_sha256,
+                ),
+            ] {
+                let actual = native_metadata_text(pointer, label, &display_path)?;
+                if actual != expected {
+                    return Err(RusticolError::compatibility(format!(
+                        "native eager DirectTable {} {label} is {actual:?}, expected {expected:?}",
+                        display_path.display()
+                    )));
+                }
+            }
+            let call = unsafe {
+                library
+                    .get::<NativeEagerDirectTableCall>(function_name.as_bytes())
+                    .map(|symbol| *symbol)
+                    .map_err(|error| {
+                        RusticolError::evaluation(format!(
+                            "could not load native eager DirectTable symbol {function_name:?} from {}: {error}",
+                            library_path.display()
+                        ))
+                    })?
+            };
+            Ok(Self {
+                callable: EagerDirectTableCallable::Native(LoadedNativeEagerDirectTable {
+                    _library: library,
+                    call,
+                    metadata,
+                }),
+                display_path,
+            })
+        }
+    }
+
+    fn metadata(&self) -> EagerDirectTableMetadata {
+        match &self.callable {
+            EagerDirectTableCallable::Symjit { metadata, .. } => *metadata,
+            #[cfg(feature = "f64-compiled")]
+            EagerDirectTableCallable::Native(callable) => callable.metadata,
+        }
+    }
+
+    pub(crate) fn load_rows(
+        &self,
+        invocation_bytes: Vec<u8>,
+        attachment_bytes: Vec<u8>,
+    ) -> RusticolResult<EagerDirectTableRows> {
+        parse_rows(self.metadata(), invocation_bytes, attachment_bytes)
+    }
+
+    /// Validate immutable rows, catalogs, factors, hazards, and maximum range.
+    /// P-kernel descriptor/scratch capacity is also allocated here, never hot.
+    pub(crate) fn validate_call(
+        &self,
+        rows: &EagerDirectTableRows,
+        workspace: &mut EagerDirectTableWorkspace,
+        point_start: u32,
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        let metadata = self.metadata();
+        validate_call(
+            metadata,
+            rows,
+            workspace,
+            point_start,
+            point_count,
+            &self.display_path,
+        )?;
+        if matches!(&self.callable, EagerDirectTableCallable::Symjit { .. }) {
+            workspace.prepare_symjit(metadata)?;
+        }
+        Ok(())
+    }
+
+    #[cfg(test)]
+    pub(crate) fn evaluate_checked(
+        &self,
+        rows: &EagerDirectTableRows,
+        workspace: &mut EagerDirectTableWorkspace,
+        point_start: u32,
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        self.validate_call(rows, workspace, point_start, point_count)?;
+        unsafe { self.evaluate_validated_unchecked(rows, workspace, point_start, point_count) }
+    }
+
+    /// Execute rows previously authenticated by [`Self::validate_call`].
+    ///
+    /// # Safety
+    ///
+    /// Rows, plane/factor catalogs, and arena allocation addresses must remain
+    /// unchanged. Scalar/factor values and active point ranges may change.
+    pub(crate) unsafe fn evaluate_validated_unchecked(
+        &self,
+        rows: &EagerDirectTableRows,
+        workspace: &mut EagerDirectTableWorkspace,
+        point_start: u32,
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        let metadata = self.metadata();
+        let _ = workspace.checked_range(point_start, point_count)?;
+        match &self.callable {
+            EagerDirectTableCallable::Symjit { kernel, .. } => execute_symjit_rows(
+                kernel,
+                metadata,
+                rows,
+                workspace,
+                point_start as usize,
+                point_count as usize,
+            ),
+            #[cfg(feature = "f64-compiled")]
+            EagerDirectTableCallable::Native(callable) => {
+                let view = workspace.native_view(rows, metadata, point_start, point_count)?;
+                let status = guard_dependency_panic(
+                    || unsafe { (callable.call)(ptr::from_ref(&view)) },
+                    &self.display_path,
+                    "execute native table call",
+                )?;
+                map_direct_status(status, &self.display_path)
+            }
+        }
+    }
+}
+
+fn validate_portable_abis(
+    source_application_abi: &str,
+    descriptor_abi: &str,
+    binding_abi: &str,
+) -> RusticolResult<()> {
+    if source_application_abi != EAGER_DIRECT_SOURCE_APPLICATION_ABI
+        || descriptor_abi != EAGER_DIRECT_TABLE_DESCRIPTOR_ABI
+        || binding_abi != EAGER_DIRECT_TABLE_BINDING_ABI
+    {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported eager plane-table artifact ABIs ({source_application_abi:?}, {descriptor_abi:?}, {binding_abi:?}); regenerate the prepared model"
+        )));
+    }
+    Ok(())
+}
+
+fn parse_rows(
+    metadata: EagerDirectTableMetadata,
+    invocation_bytes: Vec<u8>,
+    attachment_bytes: Vec<u8>,
+) -> RusticolResult<EagerDirectTableRows> {
+    let invocation_count = table_row_count(
+        &invocation_bytes,
+        metadata.invocation_stride,
+        "invocation",
+        false,
+    )?;
+    let attachment_count = table_row_count(
+        &attachment_bytes,
+        metadata.attachment_stride,
+        "attachment",
+        true,
+    )?;
+    let mut invocations = Vec::with_capacity(invocation_count as usize);
+    let mut input_planes =
+        Vec::with_capacity(invocation_count as usize * metadata.input_plane_count);
+    for row in 0..invocation_count as usize {
+        let input_start = input_planes.len();
+        for input in 0..metadata.input_plane_count {
+            input_planes.push(read_row_u32(
+                &invocation_bytes,
+                row,
+                metadata.invocation_stride as usize,
+                input * 4,
+            )?);
+        }
+        let attachment_start = read_row_u32(
+            &invocation_bytes,
+            row,
+            metadata.invocation_stride as usize,
+            metadata.attachment_start_offset(),
+        )?;
+        let row_attachment_count = read_row_u32(
+            &invocation_bytes,
+            row,
+            metadata.invocation_stride as usize,
+            metadata.attachment_count_offset(),
+        )?;
+        let stop = attachment_start
+            .checked_add(row_attachment_count)
+            .ok_or_else(|| {
+                RusticolError::integrity("eager invocation attachment range overflows")
+            })?;
+        if stop > attachment_count {
+            return Err(RusticolError::integrity(format!(
+                "eager invocation {row} attachment range {attachment_start}..{stop} exceeds {attachment_count}"
+            )));
+        }
+        invocations.push(ParsedInvocation {
+            input_start,
+            attachment_start,
+            attachment_count: row_attachment_count,
+        });
+    }
+
+    let mut attachments = Vec::with_capacity(attachment_count as usize);
+    let mut destination_planes =
+        Vec::with_capacity(attachment_count as usize * metadata.output_plane_count);
+    for row in 0..attachment_count as usize {
+        let destination_start = destination_planes.len();
+        for output in 0..metadata.output_plane_count {
+            destination_planes.push(read_row_u32(
+                &attachment_bytes,
+                row,
+                metadata.attachment_stride as usize,
+                output * 4,
+            )?);
+        }
+        attachments.push(ParsedAttachment {
+            destination_start,
+            factor: read_row_u32(
+                &attachment_bytes,
+                row,
+                metadata.attachment_stride as usize,
+                metadata.scale_offset(),
+            )?,
+            operation: read_row_u32(
+                &attachment_bytes,
+                row,
+                metadata.attachment_stride as usize,
+                metadata.operation_offset(),
+            )?,
+        });
+    }
+    Ok(EagerDirectTableRows {
+        invocations_raw: invocation_bytes.into_boxed_slice(),
+        attachments_raw: attachment_bytes.into_boxed_slice(),
+        invocations: invocations.into_boxed_slice(),
+        input_planes: input_planes.into_boxed_slice(),
+        attachments: attachments.into_boxed_slice(),
+        destination_planes: destination_planes.into_boxed_slice(),
+        input_plane_count: metadata.input_plane_count,
+        output_plane_count: metadata.output_plane_count,
+    })
+}
+
+fn read_row_u32(bytes: &[u8], row: usize, stride: usize, offset: usize) -> RusticolResult<u32> {
+    let start = row
+        .checked_mul(stride)
+        .and_then(|start| start.checked_add(offset))
+        .ok_or_else(|| RusticolError::integrity("eager row field offset overflows"))?;
+    let field = bytes
+        .get(start..start + 4)
+        .ok_or_else(|| RusticolError::integrity("eager row field is truncated"))?;
+    Ok(u32::from_le_bytes(field.try_into().map_err(|_| {
+        RusticolError::internal("could not decode eager row field")
+    })?))
+}
+
+fn validate_call(
+    metadata: EagerDirectTableMetadata,
+    rows: &EagerDirectTableRows,
+    workspace: &EagerDirectTableWorkspace,
+    point_start: u32,
+    point_count: u32,
+    display_path: &Path,
+) -> RusticolResult<()> {
+    if rows.input_plane_count != metadata.input_plane_count
+        || rows.output_plane_count != metadata.output_plane_count
+    {
+        return Err(RusticolError::integrity(
+            "eager rows were loaded for a different P-kernel shape",
+        ));
+    }
+    let (_, point_stop) = workspace.checked_range(point_start, point_count)?;
+    if !workspace.scalars.is_empty() {
+        return Err(RusticolError::integrity(
+            "eager P-kernel plane tables do not accept scalar descriptors",
+        ));
+    }
+    if workspace.factor_re.is_empty() || workspace.factor_re.len() != workspace.factor_im.len() {
+        return Err(RusticolError::integrity(
+            "eager factor catalog is not a nonempty split-complex pair",
+        ));
+    }
+    for (index, plane) in workspace.planes.iter().enumerate() {
+        if plane.values.is_null() || plane.len < point_stop {
+            return Err(RusticolError::integrity(format!(
+                "eager plane {index} does not cover the validated point range"
+            )));
+        }
+    }
+    for (row_index, invocation) in rows.invocations.iter().enumerate() {
+        let inputs = invocation_inputs(rows, *invocation, metadata);
+        for (binding, &plane) in inputs.iter().enumerate() {
+            if plane as usize >= workspace.planes.len() {
+                return Err(RusticolError::integrity(format!(
+                    "eager invocation {row_index} input binding {binding} references plane {plane}, catalog has {}",
+                    workspace.planes.len()
+                )));
+            }
+        }
+        for attachment_index in
+            invocation.attachment_start..invocation.attachment_start + invocation.attachment_count
+        {
+            let attachment = rows.attachments[attachment_index as usize];
+            let destinations = attachment_destinations(rows, attachment, metadata);
+            for (component, &plane) in destinations.iter().enumerate() {
+                if plane as usize >= workspace.planes.len() {
+                    return Err(RusticolError::integrity(format!(
+                        "eager attachment {attachment_index} destination component {component} references plane {plane}, catalog has {}",
+                        workspace.planes.len()
+                    )));
+                }
+                if workspace.read_only_zero_plane_index == Some(plane) {
+                    return Err(RusticolError::integrity(format!(
+                        "eager attachment {attachment_index} destination component {component} \
+                         references read-only shared-zero plane {plane}"
+                    )));
+                }
+            }
+            if attachment.factor as usize >= workspace.factor_re.len() {
+                return Err(RusticolError::integrity(format!(
+                    "eager attachment {attachment_index} factor {} exceeds {}",
+                    attachment.factor,
+                    workspace.factor_re.len()
+                )));
+            }
+            if !matches!(
+                attachment.operation,
+                EAGER_DESTINATION_OVERWRITE | EAGER_DESTINATION_ACCUMULATE
+            ) {
+                return Err(RusticolError::integrity(format!(
+                    "eager attachment {attachment_index} operation {} is not overwrite(0) or accumulate(1)",
+                    attachment.operation
+                )));
+            }
+        }
+        validate_invocation_hazards(row_index, *invocation, metadata, rows, workspace)?;
+    }
+    let _ = display_path;
+    Ok(())
+}
+
+fn validate_invocation_hazards(
+    row_index: usize,
+    invocation: ParsedInvocation,
+    metadata: EagerDirectTableMetadata,
+    rows: &EagerDirectTableRows,
+    workspace: &EagerDirectTableWorkspace,
+) -> RusticolResult<()> {
+    let inputs = invocation_inputs(rows, invocation, metadata);
+    for (binding, &input_index) in inputs.iter().enumerate() {
+        let input = plane_range(workspace.planes[input_index as usize])?;
+        for attachment_index in
+            invocation.attachment_start..invocation.attachment_start + invocation.attachment_count
+        {
+            let attachment = rows.attachments[attachment_index as usize];
+            for (component, &destination_index) in
+                attachment_destinations(rows, attachment, metadata)
+                    .iter()
+                    .enumerate()
+            {
+                if input.overlaps(plane_range(workspace.planes[destination_index as usize])?) {
+                    return Err(RusticolError::integrity(format!(
+                        "eager invocation {row_index} input binding {binding} overlaps attachment {attachment_index} destination component {component}"
+                    )));
+                }
+            }
+        }
+    }
+
+    let destination_count = invocation.attachment_count as usize * metadata.output_plane_count;
+    for left in 0..destination_count {
+        let left_attachment =
+            invocation.attachment_start as usize + left / metadata.output_plane_count;
+        let left_component = left % metadata.output_plane_count;
+        let left_row = rows.attachments[left_attachment];
+        let left_index = attachment_destinations(rows, left_row, metadata)[left_component] as usize;
+        let left_range = plane_range(workspace.planes[left_index])?;
+        for right in left + 1..destination_count {
+            let right_attachment =
+                invocation.attachment_start as usize + right / metadata.output_plane_count;
+            let right_component = right % metadata.output_plane_count;
+            let right_row = rows.attachments[right_attachment];
+            let right_index =
+                attachment_destinations(rows, right_row, metadata)[right_component] as usize;
+            if left_range.overlaps(plane_range(workspace.planes[right_index])?) {
+                return Err(RusticolError::integrity(format!(
+                    "eager invocation {row_index} attachment {left_attachment} destination component {left_component} overlaps attachment {right_attachment} destination component {right_component}"
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+#[derive(Clone, Copy)]
+struct AddressRange {
+    start: usize,
+    end: usize,
+}
+
+impl AddressRange {
+    const fn overlaps(self, other: Self) -> bool {
+        self.start < other.end && other.start < self.end
+    }
+}
+
+fn plane_range(plane: EagerDirectPlane) -> RusticolResult<AddressRange> {
+    let bytes = plane
+        .len
+        .checked_mul(std::mem::size_of::<f64>())
+        .ok_or_else(|| RusticolError::integrity("eager plane byte range overflows"))?;
+    let start = plane.values.addr();
+    let end = start
+        .checked_add(bytes)
+        .ok_or_else(|| RusticolError::integrity("eager plane address range overflows"))?;
+    Ok(AddressRange { start, end })
+}
+
+fn invocation_inputs(
+    rows: &EagerDirectTableRows,
+    invocation: ParsedInvocation,
+    metadata: EagerDirectTableMetadata,
+) -> &[u32] {
+    &rows.input_planes[invocation.input_start..invocation.input_start + metadata.input_plane_count]
+}
+
+fn attachment_destinations(
+    rows: &EagerDirectTableRows,
+    attachment: ParsedAttachment,
+    metadata: EagerDirectTableMetadata,
+) -> &[u32] {
+    &rows.destination_planes
+        [attachment.destination_start..attachment.destination_start + metadata.output_plane_count]
+}
+
+fn execute_symjit_rows(
+    kernel: &SymjitPlaneKernel,
+    metadata: EagerDirectTableMetadata,
+    rows: &EagerDirectTableRows,
+    workspace: &mut EagerDirectTableWorkspace,
+    point_start: usize,
+    point_count: usize,
+) -> RusticolResult<()> {
+    let stride = workspace.arena.point_stride() as usize;
+    debug_assert!(
+        workspace.symjit_descriptors.capacity()
+            >= metadata.input_plane_count + metadata.output_plane_count
+    );
+    debug_assert!(workspace.symjit_scratch.len() >= metadata.output_plane_count * stride);
+
+    for invocation in rows.invocations.iter().copied() {
+        workspace.symjit_descriptors.clear();
+        for &plane_index in invocation_inputs(rows, invocation, metadata) {
+            let plane = workspace.planes[plane_index as usize];
+            workspace
+                .symjit_descriptors
+                .push(unsafe { PlaneDescriptor::from_cached_raw_parts(plane.values, plane.len)? });
+        }
+
+        let direct_attachment = (invocation.attachment_count == 1)
+            .then(|| rows.attachments[invocation.attachment_start as usize])
+            .filter(|attachment| {
+                attachment.operation == EAGER_DESTINATION_OVERWRITE
+                    && workspace.factor_re[attachment.factor as usize].to_bits()
+                        == 1.0_f64.to_bits()
+                    && workspace.factor_im[attachment.factor as usize].to_bits()
+                        == 0.0_f64.to_bits()
+            });
+        if let Some(attachment) = direct_attachment {
+            for &plane_index in attachment_destinations(rows, attachment, metadata) {
+                let plane = workspace.planes[plane_index as usize];
+                workspace.symjit_descriptors.push(unsafe {
+                    PlaneDescriptor::from_cached_raw_parts(plane.values, plane.len)?
+                });
+            }
+        } else {
+            let scratch = workspace.symjit_scratch.as_mut_ptr();
+            for output in 0..metadata.output_plane_count {
+                workspace.symjit_descriptors.push(unsafe {
+                    PlaneDescriptor::from_cached_raw_parts(scratch.add(output * stride), stride)?
+                });
+            }
+        }
+
+        let execution = unsafe {
+            kernel.execute_raw_descriptors_unchecked(
+                &workspace.symjit_descriptors,
+                point_start,
+                point_count,
+            )
+        };
+        workspace.symjit_descriptors.clear();
+        execution?;
+
+        if direct_attachment.is_none() {
+            apply_scratch_fanout(
+                metadata,
+                invocation,
+                rows,
+                workspace,
+                point_start,
+                point_count,
+            );
+        }
+    }
+    Ok(())
+}
+
+fn apply_scratch_fanout(
+    metadata: EagerDirectTableMetadata,
+    invocation: ParsedInvocation,
+    rows: &EagerDirectTableRows,
+    workspace: &mut EagerDirectTableWorkspace,
+    point_start: usize,
+    point_count: usize,
+) {
+    let stride = workspace.arena.point_stride() as usize;
+    let output_bytes = (metadata.output_plane_count as u64)
+        .saturating_mul(point_count as u64)
+        .saturating_mul(std::mem::size_of::<f64>() as u64);
+    let read_bytes = output_bytes.saturating_mul(invocation.attachment_count as u64);
+    workspace.internal_scratch_bytes = workspace
+        .internal_scratch_bytes
+        .saturating_add(output_bytes)
+        .saturating_add(read_bytes);
+
+    for attachment_index in
+        invocation.attachment_start..invocation.attachment_start + invocation.attachment_count
+    {
+        let attachment = rows.attachments[attachment_index as usize];
+        let factor_re = workspace.factor_re[attachment.factor as usize];
+        let factor_im = workspace.factor_im[attachment.factor as usize];
+        for (output, destination_indices) in attachment_destinations(rows, attachment, metadata)
+            .chunks_exact(2)
+            .enumerate()
+        {
+            let source_re = unsafe {
+                std::slice::from_raw_parts(
+                    workspace
+                        .symjit_scratch
+                        .as_ptr()
+                        .add(2 * output * stride + point_start),
+                    point_count,
+                )
+            };
+            let source_im = unsafe {
+                std::slice::from_raw_parts(
+                    workspace
+                        .symjit_scratch
+                        .as_ptr()
+                        .add((2 * output + 1) * stride + point_start),
+                    point_count,
+                )
+            };
+            let destination_re_plane = workspace.planes[destination_indices[0] as usize];
+            let destination_im_plane = workspace.planes[destination_indices[1] as usize];
+            let destination_re = unsafe {
+                std::slice::from_raw_parts_mut(
+                    destination_re_plane.values.add(point_start),
+                    point_count,
+                )
+            };
+            let destination_im = unsafe {
+                std::slice::from_raw_parts_mut(
+                    destination_im_plane.values.add(point_start),
+                    point_count,
+                )
+            };
+            apply_complex_scaled(
+                destination_re,
+                destination_im,
+                source_re,
+                source_im,
+                factor_re,
+                factor_im,
+                attachment.operation == EAGER_DESTINATION_ACCUMULATE,
+            );
+        }
+    }
+}
+
+#[inline]
+fn apply_complex_scaled(
+    destination_re: &mut [f64],
+    destination_im: &mut [f64],
+    source_re: &[f64],
+    source_im: &[f64],
+    factor_re: f64,
+    factor_im: f64,
+    accumulate: bool,
+) {
+    debug_assert_eq!(destination_re.len(), destination_im.len());
+    debug_assert_eq!(destination_re.len(), source_re.len());
+    debug_assert_eq!(destination_re.len(), source_im.len());
+    #[cfg(target_arch = "x86_64")]
+    let mut point = apply_complex_scaled_x86_64(
+        destination_re,
+        destination_im,
+        source_re,
+        source_im,
+        factor_re,
+        factor_im,
+        accumulate,
+    );
+    #[cfg(target_arch = "aarch64")]
+    let mut point = apply_complex_scaled_aarch64(
+        destination_re,
+        destination_im,
+        source_re,
+        source_im,
+        factor_re,
+        factor_im,
+        accumulate,
+    );
+    #[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
+    let mut point = 0;
+    if accumulate {
+        while point < destination_re.len() {
+            let re = source_re[point];
+            let im = source_im[point];
+            destination_re[point] += re * factor_re - im * factor_im;
+            destination_im[point] += re * factor_im + im * factor_re;
+            point += 1;
+        }
+    } else {
+        while point < destination_re.len() {
+            let re = source_re[point];
+            let im = source_im[point];
+            destination_re[point] = re * factor_re - im * factor_im;
+            destination_im[point] = re * factor_im + im * factor_re;
+            point += 1;
+        }
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+#[inline]
+#[allow(clippy::too_many_arguments)]
+fn apply_complex_scaled_x86_64(
+    destination_re: &mut [f64],
+    destination_im: &mut [f64],
+    source_re: &[f64],
+    source_im: &[f64],
+    factor_re: f64,
+    factor_im: f64,
+    accumulate: bool,
+) -> usize {
+    let factor_re = f64x4::new([factor_re; 4]);
+    let factor_im = f64x4::new([factor_im; 4]);
+    let mut point = 0;
+    while destination_re.len() - point >= 4 {
+        let re = f64x4::new([
+            source_re[point],
+            source_re[point + 1],
+            source_re[point + 2],
+            source_re[point + 3],
+        ]);
+        let im = f64x4::new([
+            source_im[point],
+            source_im[point + 1],
+            source_im[point + 2],
+            source_im[point + 3],
+        ]);
+        let mut scaled_re = re * factor_re - im * factor_im;
+        let mut scaled_im = re * factor_im + im * factor_re;
+        if accumulate {
+            scaled_re += f64x4::new([
+                destination_re[point],
+                destination_re[point + 1],
+                destination_re[point + 2],
+                destination_re[point + 3],
+            ]);
+            scaled_im += f64x4::new([
+                destination_im[point],
+                destination_im[point + 1],
+                destination_im[point + 2],
+                destination_im[point + 3],
+            ]);
+        }
+        destination_re[point..point + 4].copy_from_slice(&scaled_re.to_array());
+        destination_im[point..point + 4].copy_from_slice(&scaled_im.to_array());
+        point += 4;
+    }
+    point
+}
+
+#[cfg(target_arch = "aarch64")]
+#[inline]
+#[allow(clippy::too_many_arguments)]
+fn apply_complex_scaled_aarch64(
+    destination_re: &mut [f64],
+    destination_im: &mut [f64],
+    source_re: &[f64],
+    source_im: &[f64],
+    factor_re: f64,
+    factor_im: f64,
+    accumulate: bool,
+) -> usize {
+    let factor_re = f64x2::new([factor_re; 2]);
+    let factor_im = f64x2::new([factor_im; 2]);
+    let mut point = 0;
+    while destination_re.len() - point >= 2 {
+        let re = f64x2::new([source_re[point], source_re[point + 1]]);
+        let im = f64x2::new([source_im[point], source_im[point + 1]]);
+        let mut scaled_re = re * factor_re - im * factor_im;
+        let mut scaled_im = re * factor_im + im * factor_re;
+        if accumulate {
+            scaled_re += f64x2::new([destination_re[point], destination_re[point + 1]]);
+            scaled_im += f64x2::new([destination_im[point], destination_im[point + 1]]);
+        }
+        destination_re[point..point + 2].copy_from_slice(&scaled_re.to_array());
+        destination_im[point..point + 2].copy_from_slice(&scaled_im.to_array());
+        point += 2;
+    }
+    point
+}
+
+#[cfg(feature = "f64-compiled")]
+fn native_metadata_text(
+    pointer: *const c_char,
+    label: &str,
+    display_path: &Path,
+) -> RusticolResult<String> {
+    if pointer.is_null() {
+        return Err(RusticolError::integrity(format!(
+            "native eager DirectTable {} has a null {label}",
+            display_path.display()
+        )));
+    }
+    unsafe { CStr::from_ptr(pointer) }
+        .to_str()
+        .map(str::to_owned)
+        .map_err(|error| {
+            RusticolError::integrity(format!(
+                "native eager DirectTable {} has non-UTF-8 {label}: {error}",
+                display_path.display()
+            ))
+        })
+}
+
+fn validate_c_symbol(symbol: &str) -> RusticolResult<()> {
+    let mut bytes = symbol.bytes();
+    let Some(first) = bytes.next() else {
+        return Err(RusticolError::artifact(
+            "native eager DirectTable symbol must not be empty",
+        ));
+    };
+    if !(first == b'_' || first.is_ascii_alphabetic())
+        || bytes.any(|byte| !(byte == b'_' || byte.is_ascii_alphanumeric()))
+    {
+        return Err(RusticolError::artifact(format!(
+            "native eager DirectTable symbol {symbol:?} is not a portable C identifier"
+        )));
+    }
+    Ok(())
+}
+
+fn bind_arena_plane(
+    arena: DirectArenaView,
+    binding: EagerDirectArenaPlaneBinding,
+) -> RusticolResult<EagerDirectPlane> {
+    let (base, shape, component, label) = match binding {
+        EagerDirectArenaPlaneBinding::CurrentReal(component) => (
+            arena.current_re,
+            arena.current_shape()?,
+            component,
+            "current real",
+        ),
+        EagerDirectArenaPlaneBinding::CurrentImag(component) => (
+            arena.current_im,
+            arena.current_shape()?,
+            component,
+            "current imaginary",
+        ),
+        EagerDirectArenaPlaneBinding::AmplitudeReal(component) => (
+            arena.amplitude_re,
+            arena.amplitude_shape()?,
+            component,
+            "amplitude real",
+        ),
+        EagerDirectArenaPlaneBinding::AmplitudeImag(component) => (
+            arena.amplitude_im,
+            arena.amplitude_shape()?,
+            component,
+            "amplitude imaginary",
+        ),
+    };
+    let range = shape.checked_component_range(component, 1, label)?;
+    Ok(EagerDirectPlane {
+        values: unsafe { base.add(range.start) },
+        len: range.len(),
+    })
+}
+
+fn table_row_count(
+    bytes: &[u8],
+    row_stride: u32,
+    label: &str,
+    allow_empty: bool,
+) -> RusticolResult<u32> {
+    let stride = row_stride as usize;
+    if stride == 0 || !bytes.len().is_multiple_of(stride) {
+        return Err(RusticolError::integrity(format!(
+            "eager Direct-Arena {label} table has {} bytes, not a whole number of {stride}-byte rows",
+            bytes.len()
+        )));
+    }
+    let count = u32::try_from(bytes.len() / stride).map_err(|_| {
+        RusticolError::integrity(format!("eager Direct-Arena {label} row count exceeds u32"))
+    })?;
+    if count == 0 && !allow_empty {
+        return Err(RusticolError::integrity(format!(
+            "eager Direct-Arena {label} table must not be empty"
+        )));
+    }
+    Ok(count)
+}
+
+fn map_direct_status(status: i32, path: &Path) -> RusticolResult<()> {
+    match status {
+        DIRECT_STATUS_OK => Ok(()),
+        DIRECT_STATUS_INVALID_ARGUMENT => Err(RusticolError::integrity(format!(
+            "eager Direct-Arena callable {} rejected its authenticated call view",
+            path.display()
+        ))),
+        DIRECT_STATUS_INVALID_CONTEXT => Err(RusticolError::internal(format!(
+            "eager Direct-Arena callable {} has an invalid context",
+            path.display()
+        ))),
+        DIRECT_STATUS_EXECUTION_FAILED => Err(RusticolError::evaluation(format!(
+            "eager Direct-Arena callable {} failed during generated execution",
+            path.display()
+        ))),
+        other => Err(RusticolError::evaluation(format!(
+            "eager Direct-Arena callable {} returned unknown status {other}",
+            path.display()
+        ))),
+    }
+}
+
+fn guard_dependency_panic<T>(
+    operation: impl FnOnce() -> T,
+    path: &Path,
+    action: &str,
+) -> RusticolResult<T> {
+    catch_unwind(AssertUnwindSafe(operation)).map_err(|payload| {
+        RusticolError::compatibility(format!(
+            "dependency panicked while trying to {action} eager Direct-Arena application {}: {}",
+            path.display(),
+            panic_detail(payload)
+        ))
+    })
+}
+
+fn panic_detail(payload: Box<dyn Any + Send>) -> String {
+    if let Some(message) = payload.downcast_ref::<&str>() {
+        (*message).to_string()
+    } else if let Some(message) = payload.downcast_ref::<String>() {
+        message.clone()
+    } else {
+        "non-string panic payload".to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::engine::count_allocations;
+    use std::mem;
+    use symjit::{Compiler, CompilerType, Config, Storage};
+
+    const MODEL: &str = "
+([('add', ('temp', 0), [('param', 0), ('param', 1)], 0),
+  ('assign', ('out', 0), ('temp', 0))],
+ 2,
+ [])
+";
+    const LENGTHS: &[usize] = &[1, 2, 3, 7, 8, 127, 128, 129, 1023, 1024, 1025];
+    const ODD_TAIL_LENGTHS: &[usize] = &[127, 129, 1023, 1025];
+
+    #[derive(Clone, Copy)]
+    #[repr(C)]
+    struct InvocationRow {
+        x_re: u32,
+        x_im: u32,
+        y_re: u32,
+        y_im: u32,
+        attachment_start: u32,
+        attachment_count: u32,
+    }
+
+    #[derive(Clone, Copy)]
+    #[repr(C)]
+    struct AttachmentRow {
+        destination_re: u32,
+        destination_im: u32,
+        factor: u32,
+        operation: u32,
+    }
+
+    fn source_bytes() -> Vec<u8> {
+        let mut config = Config::new(CompilerType::Native, 0).unwrap();
+        config.set_opt_level(2);
+        config.set_cse(true);
+        config.set_fastmath(true);
+        config.set_simd(true);
+        config.enable_simd512(false);
+        config.set_simd_branch(false);
+        config.set_complex(true);
+        config.set_fast_complex(false);
+        config.set_threads(false);
+        config.set_symbolica(true);
+        config.set_compact(true);
+        config.set_compress(true);
+        config.set_direct(false);
+        config.set_huge(false);
+        config.set_parallel_mul(true);
+        config.set_direct_arena(true);
+        config.set_direct_arena_operation(0);
+        config.set_direct_arena_identity_output(true);
+        let mut application = Compiler::with_config(config)
+            .translate(MODEL.to_string(), 2)
+            .unwrap();
+        application.prepare_simd();
+        let mut bytes = Vec::new();
+        application.save(&mut bytes).unwrap();
+        bytes
+    }
+
+    fn table_fixture(
+        point_capacity: u32,
+    ) -> (
+        LoadedSymjitEagerDirectTable,
+        EagerDirectTableRows,
+        EagerDirectTableWorkspace,
+    ) {
+        let source = source_bytes();
+        let descriptor = eager_direct_descriptor_for_source_application_bytes(
+            &source,
+            2,
+            1,
+            Path::new("eager-table-test.symjit"),
+        )
+        .unwrap();
+        let application = LoadedSymjitEagerDirectTable::load_prepared_application_bytes(
+            &source,
+            &descriptor,
+            PathBuf::from("eager-table-test.symjit"),
+            EAGER_DIRECT_SOURCE_APPLICATION_ABI,
+            EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+            EAGER_DIRECT_TABLE_BINDING_ABI,
+            2,
+            true,
+        )
+        .unwrap();
+        let invocations = [
+            InvocationRow {
+                x_re: 0,
+                x_im: 1,
+                y_re: 2,
+                y_im: 3,
+                attachment_start: 0,
+                attachment_count: 2,
+            },
+            InvocationRow {
+                x_re: 4,
+                x_im: 5,
+                y_re: 6,
+                y_im: 7,
+                attachment_start: 2,
+                attachment_count: 1,
+            },
+        ];
+        let attachments = [
+            AttachmentRow {
+                destination_re: 4,
+                destination_im: 5,
+                factor: 0,
+                operation: 0,
+            },
+            AttachmentRow {
+                destination_re: 6,
+                destination_im: 7,
+                factor: 1,
+                operation: 0,
+            },
+            AttachmentRow {
+                destination_re: 8,
+                destination_im: 9,
+                factor: 0,
+                operation: 0,
+            },
+        ];
+        let rows = application
+            .load_rows(rows_as_bytes(&invocations), rows_as_bytes(&attachments))
+            .unwrap();
+        let bindings = [
+            EagerDirectArenaPlaneBinding::CurrentReal(0),
+            EagerDirectArenaPlaneBinding::CurrentImag(0),
+            EagerDirectArenaPlaneBinding::CurrentReal(1),
+            EagerDirectArenaPlaneBinding::CurrentImag(1),
+            EagerDirectArenaPlaneBinding::CurrentReal(2),
+            EagerDirectArenaPlaneBinding::CurrentImag(2),
+            EagerDirectArenaPlaneBinding::CurrentReal(3),
+            EagerDirectArenaPlaneBinding::CurrentImag(3),
+            EagerDirectArenaPlaneBinding::AmplitudeReal(0),
+            EagerDirectArenaPlaneBinding::AmplitudeImag(0),
+        ];
+        let workspace = EagerDirectTableWorkspace::new(
+            4,
+            1,
+            point_capacity,
+            &bindings,
+            None,
+            Vec::new(),
+            vec![1.0, 0.5],
+            vec![0.0, 0.0],
+        )
+        .unwrap();
+        (application, rows, workspace)
+    }
+
+    fn shared_zero_fixture(
+        point_capacity: u32,
+    ) -> (
+        LoadedSymjitEagerDirectTable,
+        EagerDirectTableRows,
+        EagerDirectTableWorkspace,
+    ) {
+        let source = source_bytes();
+        let descriptor = eager_direct_descriptor_for_source_application_bytes(
+            &source,
+            2,
+            1,
+            Path::new("eager-shared-zero-test.symjit"),
+        )
+        .unwrap();
+        let application = LoadedSymjitEagerDirectTable::load_prepared_application_bytes(
+            &source,
+            &descriptor,
+            PathBuf::from("eager-shared-zero-test.symjit"),
+            EAGER_DIRECT_SOURCE_APPLICATION_ABI,
+            EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+            EAGER_DIRECT_TABLE_BINDING_ABI,
+            2,
+            true,
+        )
+        .unwrap();
+        let invocations = [InvocationRow {
+            x_re: 0,
+            x_im: 1,
+            y_re: 0,
+            y_im: 1,
+            attachment_start: 0,
+            attachment_count: 1,
+        }];
+        let attachments = [AttachmentRow {
+            destination_re: 2,
+            destination_im: 3,
+            factor: 0,
+            operation: 0,
+        }];
+        let rows = application
+            .load_rows(rows_as_bytes(&invocations), rows_as_bytes(&attachments))
+            .unwrap();
+        let bindings = [
+            EagerDirectArenaPlaneBinding::CurrentReal(0),
+            EagerDirectArenaPlaneBinding::CurrentImag(0),
+            EagerDirectArenaPlaneBinding::AmplitudeReal(0),
+            EagerDirectArenaPlaneBinding::AmplitudeImag(0),
+        ];
+        let workspace = EagerDirectTableWorkspace::new(
+            1,
+            1,
+            point_capacity,
+            &bindings,
+            Some(1),
+            Vec::new(),
+            vec![1.0],
+            vec![0.0],
+        )
+        .unwrap();
+        (application, rows, workspace)
+    }
+
+    fn rows_as_bytes<T: Copy>(rows: &[T]) -> Vec<u8> {
+        unsafe { std::slice::from_raw_parts(rows.as_ptr().cast::<u8>(), mem::size_of_val(rows)) }
+            .to_vec()
+    }
+
+    fn initialize_inputs(workspace: &mut EagerDirectTableWorkspace, points: usize) {
+        workspace.begin_tile(points as u32).unwrap();
+        let stride = workspace.arena().point_stride() as usize;
+        let (current_re, current_im, amplitude_re, amplitude_im) =
+            workspace.split_arena_slices_mut();
+        for point in 0..points {
+            current_re[point] = 1.0 + point as f64;
+            current_im[point] = -0.25 * point as f64;
+            current_re[stride + point] = 10.0 + 2.0 * point as f64;
+            current_im[stride + point] = 0.5 * point as f64;
+        }
+        current_re[2 * stride..4 * stride].fill(-99.0);
+        current_im[2 * stride..4 * stride].fill(77.0);
+        amplitude_re.fill(-55.0);
+        amplitude_im.fill(44.0);
+    }
+
+    fn assert_outputs(workspace: &EagerDirectTableWorkspace, points: usize) {
+        let stride = workspace.arena().point_stride() as usize;
+        let (current_re, current_im) = workspace.arena().current_slices();
+        let (amplitude_re, amplitude_im) = workspace.arena().amplitude_slices();
+        for point in 0..points {
+            let sum_re = 11.0 + 3.0 * point as f64;
+            let sum_im = 0.25 * point as f64;
+            assert_eq!(current_re[2 * stride + point], sum_re);
+            assert_eq!(current_im[2 * stride + point], sum_im);
+            assert_eq!(current_re[3 * stride + point], 0.5 * sum_re);
+            assert_eq!(current_im[3 * stride + point], 0.5 * sum_im);
+            assert_eq!(amplitude_re[point], 1.5 * sum_re);
+            assert_eq!(amplitude_im[point], 1.5 * sum_im);
+        }
+    }
+
+    #[test]
+    fn ordered_fanout_cross_row_dependency_and_odd_tails() {
+        let (application, rows, mut workspace) = table_fixture(1025);
+        for &points in LENGTHS {
+            initialize_inputs(&mut workspace, points);
+            application
+                .validate_call(&rows, &mut workspace, 0, points as u32)
+                .unwrap();
+            unsafe {
+                application
+                    .evaluate_validated_unchecked(&rows, &mut workspace, 0, points as u32)
+                    .unwrap();
+            }
+            assert_outputs(&workspace, points);
+            assert!(workspace.internal_scratch_bytes() > 0);
+        }
+    }
+
+    #[test]
+    fn complex_factors_and_accumulation_preserve_tails() {
+        let (application, _, mut workspace) = table_fixture(1025);
+        workspace.factor_re.copy_from_slice(&[0.5, -0.75]);
+        workspace.factor_im.copy_from_slice(&[-0.25, 0.5]);
+        let invocations = [InvocationRow {
+            x_re: 0,
+            x_im: 1,
+            y_re: 2,
+            y_im: 3,
+            attachment_start: 0,
+            attachment_count: 2,
+        }];
+        let attachments = [
+            AttachmentRow {
+                destination_re: 4,
+                destination_im: 5,
+                factor: 0,
+                operation: EAGER_DESTINATION_OVERWRITE,
+            },
+            AttachmentRow {
+                destination_re: 8,
+                destination_im: 9,
+                factor: 1,
+                operation: EAGER_DESTINATION_ACCUMULATE,
+            },
+        ];
+        let rows = application
+            .load_rows(rows_as_bytes(&invocations), rows_as_bytes(&attachments))
+            .unwrap();
+
+        for &points in LENGTHS {
+            initialize_inputs(&mut workspace, points);
+            application
+                .evaluate_checked(&rows, &mut workspace, 0, points as u32)
+                .unwrap();
+            let stride = workspace.arena().point_stride() as usize;
+            let (current_re, current_im) = workspace.arena().current_slices();
+            let (amplitude_re, amplitude_im) = workspace.arena().amplitude_slices();
+            for point in 0..points {
+                let source_re = 11.0 + 3.0 * point as f64;
+                let source_im = 0.25 * point as f64;
+                assert_eq!(
+                    current_re[2 * stride + point],
+                    0.5 * source_re + 0.25 * source_im
+                );
+                assert_eq!(
+                    current_im[2 * stride + point],
+                    0.5 * source_im - 0.25 * source_re
+                );
+                assert_eq!(
+                    amplitude_re[point],
+                    -55.0 - 0.75 * source_re - 0.5 * source_im
+                );
+                assert_eq!(
+                    amplitude_im[point],
+                    44.0 - 0.75 * source_im + 0.5 * source_re
+                );
+            }
+            if points < stride {
+                assert_eq!(current_re[2 * stride + points], -99.0);
+                assert_eq!(current_im[2 * stride + points], 77.0);
+                assert_eq!(amplitude_re[points], -55.0);
+                assert_eq!(amplitude_im[points], 44.0);
+            }
+            assert!(workspace.internal_scratch_bytes() > 0);
+        }
+    }
+
+    #[test]
+    fn duplicate_real_only_inputs_share_a_read_only_zero_plane() {
+        let (application, rows, mut workspace) = shared_zero_fixture(1025);
+        for &points in LENGTHS {
+            workspace.begin_tile(points as u32).unwrap();
+            let stride = workspace.arena().point_stride() as usize;
+            {
+                let (current_re, current_im, amplitude_re, amplitude_im) =
+                    workspace.split_arena_slices_mut();
+                current_re.fill(-77.0);
+                current_im.fill(0.0);
+                amplitude_re.fill(-55.0);
+                amplitude_im.fill(44.0);
+                for (point, value) in current_re[..points].iter_mut().enumerate() {
+                    *value = 1.0 + point as f64;
+                }
+            }
+            application
+                .validate_call(&rows, &mut workspace, 0, points as u32)
+                .unwrap();
+            unsafe {
+                application
+                    .evaluate_validated_unchecked(&rows, &mut workspace, 0, points as u32)
+                    .unwrap();
+            }
+            let (_, current_im) = workspace.arena().current_slices();
+            let (amplitude_re, amplitude_im) = workspace.arena().amplitude_slices();
+            assert!(
+                current_im.iter().all(|value| *value == 0.0),
+                "shared-zero plane changed for {points} points"
+            );
+            for point in 0..points {
+                assert_eq!(amplitude_re[point], 2.0 * (1.0 + point as f64));
+                assert_eq!(amplitude_im[point], 0.0);
+            }
+            assert!(
+                amplitude_re[points..stride]
+                    .iter()
+                    .all(|value| *value == -55.0),
+                "real sentinel tail changed for {points} points"
+            );
+            assert!(
+                amplitude_im[points..stride]
+                    .iter()
+                    .all(|value| *value == 44.0),
+                "imaginary sentinel tail changed for {points} points"
+            );
+        }
+    }
+
+    #[test]
+    fn shared_zero_destination_is_rejected_cold() {
+        let (application, _, mut workspace) = shared_zero_fixture(7);
+        let invocations = [InvocationRow {
+            x_re: 0,
+            x_im: 1,
+            y_re: 0,
+            y_im: 1,
+            attachment_start: 0,
+            attachment_count: 1,
+        }];
+        let attachments = [AttachmentRow {
+            destination_re: 1,
+            destination_im: 3,
+            factor: 0,
+            operation: 0,
+        }];
+        let rows = application
+            .load_rows(rows_as_bytes(&invocations), rows_as_bytes(&attachments))
+            .unwrap();
+        let error = application
+            .validate_call(&rows, &mut workspace, 0, 7)
+            .unwrap_err();
+        assert!(error.message().contains("read-only shared-zero plane"));
+    }
+
+    #[test]
+    fn same_row_input_destination_hazard_is_rejected() {
+        let (application, _, mut workspace) = table_fixture(7);
+        let invocations = [InvocationRow {
+            x_re: 0,
+            x_im: 1,
+            y_re: 2,
+            y_im: 3,
+            attachment_start: 0,
+            attachment_count: 1,
+        }];
+        let attachments = [AttachmentRow {
+            destination_re: 0,
+            destination_im: 1,
+            factor: 0,
+            operation: 0,
+        }];
+        let rows = application
+            .load_rows(rows_as_bytes(&invocations), rows_as_bytes(&attachments))
+            .unwrap();
+        let error = application
+            .validate_call(&rows, &mut workspace, 0, 7)
+            .unwrap_err();
+        assert!(error.message().contains("overlaps"));
+    }
+
+    #[test]
+    fn warmed_checked_and_validated_calls_allocate_zero() {
+        let (application, rows, mut workspace) = table_fixture(1025);
+        for &points in ODD_TAIL_LENGTHS {
+            initialize_inputs(&mut workspace, points);
+            application
+                .evaluate_checked(&rows, &mut workspace, 0, points as u32)
+                .unwrap();
+            application
+                .validate_call(&rows, &mut workspace, 0, points as u32)
+                .unwrap();
+            let (checked, checked_count, checked_bytes) = count_allocations(|| {
+                application.evaluate_checked(&rows, &mut workspace, 0, points as u32)
+            });
+            checked.unwrap();
+            assert_eq!(
+                (checked_count, checked_bytes),
+                (0, 0),
+                "checked eager call allocated for {points} points"
+            );
+            let (unchecked, unchecked_count, unchecked_bytes) = count_allocations(|| unsafe {
+                application.evaluate_validated_unchecked(&rows, &mut workspace, 0, points as u32)
+            });
+            unchecked.unwrap();
+            assert_eq!(
+                (unchecked_count, unchecked_bytes),
+                (0, 0),
+                "validated eager call allocated for {points} points"
+            );
+            assert_outputs(&workspace, points);
+        }
+    }
+
+    #[test]
+    fn authenticated_variant_optimization_level_mismatch_fails_closed() {
+        let source = source_bytes();
+        let descriptor = eager_direct_descriptor_for_source_application_bytes(
+            &source,
+            2,
+            1,
+            Path::new("descriptor.symjit"),
+        )
+        .unwrap();
+        let error = LoadedSymjitEagerDirectTable::load_prepared_application_bytes(
+            &source,
+            &descriptor,
+            PathBuf::from("wrong-optimization.symjit"),
+            EAGER_DIRECT_SOURCE_APPLICATION_ABI,
+            EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+            EAGER_DIRECT_TABLE_BINDING_ABI,
+            3,
+            true,
+        )
+        .err()
+        .expect("a variant/application optimization mismatch must fail closed");
+        assert!(error.message().contains("optimization level"));
+        assert!(
+            error
+                .message()
+                .contains("authenticated prepared-kernel variant")
+        );
+        assert!(error.message().contains("regenerate"));
+    }
+
+    #[test]
+    fn authenticated_manifest_compression_mismatch_fails_closed() {
+        let source = source_bytes();
+        let descriptor = eager_direct_descriptor_for_source_application_bytes(
+            &source,
+            2,
+            1,
+            Path::new("descriptor.symjit"),
+        )
+        .unwrap();
+        let error = LoadedSymjitEagerDirectTable::load_prepared_application_bytes(
+            &source,
+            &descriptor,
+            PathBuf::from("wrong-compression.symjit"),
+            EAGER_DIRECT_SOURCE_APPLICATION_ABI,
+            EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+            EAGER_DIRECT_TABLE_BINDING_ABI,
+            2,
+            false,
+        )
+        .err()
+        .expect("a manifest/application compression mismatch must fail closed");
+        assert!(error.message().contains("compression"));
+        assert!(error.message().contains("regenerate"));
+    }
+
+    #[test]
+    fn descriptor_authentication_and_predecessor_abis_fail_closed() {
+        let source = source_bytes();
+        let descriptor = eager_direct_descriptor_for_source_application_bytes(
+            &source,
+            2,
+            1,
+            Path::new("descriptor.symjit"),
+        )
+        .unwrap();
+        let mut tampered = descriptor.clone();
+        tampered[40] ^= 1;
+        let error = LoadedSymjitEagerDirectTable::load_prepared_application_bytes(
+            &source,
+            &tampered,
+            PathBuf::from("descriptor.symjit"),
+            EAGER_DIRECT_SOURCE_APPLICATION_ABI,
+            EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+            EAGER_DIRECT_TABLE_BINDING_ABI,
+            2,
+            true,
+        )
+        .err()
+        .unwrap();
+        assert!(error.message().contains("authenticate"));
+        let error = LoadedSymjitEagerDirectTable::load_prepared_application_bytes(
+            &source,
+            &descriptor,
+            PathBuf::from("old-binding.symjit"),
+            EAGER_DIRECT_SOURCE_APPLICATION_ABI,
+            EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+            concat!("pyamplicol-eager-plane-", "table-binding-v1"),
+            2,
+            true,
+        )
+        .err()
+        .expect("the predecessor eager binding ABI must fail closed");
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.message().contains("regenerate"));
+        let error = LoadedSymjitEagerDirectTable::load_prepared_application_bytes(
+            &source,
+            &descriptor,
+            PathBuf::from("old-source-application.symjit"),
+            "pyamplicol-symjit-plane-application-v1",
+            EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+            EAGER_DIRECT_TABLE_BINDING_ABI,
+            2,
+            true,
+        )
+        .err()
+        .expect("the predecessor plane-application ABI must fail closed");
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(error.message().contains("regenerate"));
+        let error = LoadedSymjitEagerDirectTable::load_prepared_application_bytes(
+            &source,
+            b"SJTD0001",
+            PathBuf::from("old.symjit"),
+            EAGER_DIRECT_SOURCE_APPLICATION_ABI,
+            EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+            EAGER_DIRECT_TABLE_BINDING_ABI,
+            2,
+            true,
+        )
+        .err()
+        .unwrap();
+        assert!(error.message().contains("regenerate"));
+    }
+
+    #[test]
+    fn dependency_panics_are_contained_with_eager_application_context() {
+        let error = guard_dependency_panic(
+            || panic!("synthetic table panic"),
+            Path::new("panic-probe.symjit"),
+            "exercise the panic-containment probe",
+        )
+        .unwrap_err();
+        assert_eq!(error.kind(), crate::RusticolErrorKind::Compatibility);
+        assert!(
+            error.message().contains(
+                "dependency panicked while trying to exercise the panic-containment probe"
+            )
+        );
+        assert!(error.message().contains("panic-probe.symjit"));
+        assert!(error.message().contains("synthetic table panic"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_plane.rs b/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_plane.rs
new file mode 100644
index 0000000000..b6031acc48
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/evaluator/symjit_plane.rs
@@ -0,0 +1,2175 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Standard SymJIT P-kernel loading, binding, and execution.
+//!
+//! The generic raw-plane extension applied to SymJIT 2.22 exposes the existing
+//! P-kernel machine code through a stable `#[repr(C)]` descriptor. Rusticol
+//! keeps those descriptors in a cold-built vector, so duplicate inputs and
+//! intentional input/output aliases never require overlapping Rust
+//! references. Scalar/SIMD dispatch and descriptor rebinding allocate nothing.
+
+use crate::{RusticolError, RusticolResult};
+use std::any::Any;
+use std::marker::PhantomData;
+use std::panic::{AssertUnwindSafe, catch_unwind};
+use std::path::{Path, PathBuf};
+use std::ptr::NonNull;
+#[cfg(any(test, feature = "python-generation-bridge"))]
+use symjit::Compiler;
+use symjit::{
+    Applet, Application, Compiled, CompiledPlaneFunc, CompilerType, Config, Defuns,
+    PlaneDescriptor as SymjitPlaneDescriptor, Storage,
+};
+
+const SYMJIT_APPLICATION_MAGIC: usize = 0x4056_8795_410d_08e9;
+const SYMJIT_APPLICATION_STORAGE_VERSION: usize = 3;
+const MAX_OPTIMIZATION_LEVEL: u8 = 3;
+
+type PlaneKernelFn = CompiledPlaneFunc<f64>;
+
+/// Logical shape of a plane-oriented SymJIT application.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct SymjitPlaneLayout {
+    input_count: usize,
+    output_count: usize,
+    complex: bool,
+}
+
+impl SymjitPlaneLayout {
+    #[cfg(test)]
+    pub(crate) const fn real(input_count: usize, output_count: usize) -> Self {
+        Self {
+            input_count,
+            output_count,
+            complex: false,
+        }
+    }
+
+    pub(crate) const fn complex(input_count: usize, output_count: usize) -> Self {
+        Self {
+            input_count,
+            output_count,
+            complex: true,
+        }
+    }
+
+    pub(crate) const fn is_complex(self) -> bool {
+        self.complex
+    }
+
+    pub(crate) fn input_plane_count(self) -> RusticolResult<usize> {
+        self.input_count
+            .checked_mul(if self.complex { 2 } else { 1 })
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("SymJIT input plane count overflows usize")
+            })
+    }
+
+    pub(crate) fn output_plane_count(self) -> RusticolResult<usize> {
+        self.output_count
+            .checked_mul(if self.complex { 2 } else { 1 })
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("SymJIT output plane count overflows usize")
+            })
+    }
+
+    pub(crate) fn plane_count(self) -> RusticolResult<usize> {
+        let components = if self.complex { 2 } else { 1 };
+        self.input_count
+            .checked_add(self.output_count)
+            .and_then(|count| count.checked_mul(components))
+            .ok_or_else(|| RusticolError::invalid_argument("SymJIT plane count overflows usize"))
+    }
+}
+
+/// A lifetime-tagged wrapper around SymJIT's stable raw plane descriptor.
+///
+/// Safe slice construction ties the tag to a real exclusive borrow. Runtime
+/// schedulers may instead use the unsafe cached constructor, whose `'static`
+/// tag permits owner-managed storage but does not extend any allocation's
+/// lifetime.
+#[derive(Debug)]
+#[repr(transparent)]
+pub(crate) struct SymjitRawPlane<'a> {
+    descriptor: SymjitPlaneDescriptor<f64>,
+    _lifetime: PhantomData<&'a mut [f64]>,
+}
+
+/// Single cold-path descriptor type used by Rusticol schedulers.
+pub(crate) type PlaneDescriptor<'a> = SymjitRawPlane<'a>;
+
+impl<'a> SymjitRawPlane<'a> {
+    #[cfg(test)]
+    pub(crate) fn from_slice(values: &'a mut [f64]) -> Self {
+        Self {
+            // SAFETY: The returned wrapper retains the exclusive slice
+            // lifetime, so the allocation outlives every use of the raw
+            // descriptor.
+            descriptor: unsafe {
+                SymjitPlaneDescriptor::from_raw_parts(values.as_mut_ptr(), values.len())
+            },
+            _lifetime: PhantomData,
+        }
+    }
+
+    /// Creates a cold-binding descriptor without creating a Rust reference.
+    ///
+    /// # Safety
+    ///
+    /// `pointer` must remain allocated, aligned, and writable for `len`
+    /// consecutive `f64` values during every invocation that receives this
+    /// descriptor. The caller must prevent every later invocation or
+    /// dereference after its allocation moves, reallocates, or drops, and
+    /// synchronize all accesses.
+    /// Duplicate descriptors and exact input/output aliases can be represented
+    /// because this wrapper never creates overlapping Rust references. A
+    /// complete kernel table rejects overlapping outputs and shifted or
+    /// otherwise partial input/output overlaps.
+    pub(crate) unsafe fn from_raw_parts(pointer: *mut f64, len: usize) -> RusticolResult<Self> {
+        let pointer = if len == 0 && pointer.is_null() {
+            NonNull::<f64>::dangling().as_ptr()
+        } else {
+            NonNull::new(pointer)
+                .ok_or_else(|| {
+                    RusticolError::invalid_argument(
+                        "a non-empty SymJIT plane has a null data pointer",
+                    )
+                })?
+                .as_ptr()
+        };
+        if pointer.addr() % std::mem::align_of::<f64>() != 0 {
+            return Err(RusticolError::invalid_argument(
+                "a SymJIT plane data pointer is not aligned for f64",
+            ));
+        }
+        Ok(Self {
+            descriptor: unsafe { SymjitPlaneDescriptor::from_raw_parts(pointer, len) },
+            _lifetime: PhantomData,
+        })
+    }
+
+    fn interval(&self) -> RusticolResult<Option<(usize, usize)>> {
+        if self.descriptor.len == 0 {
+            return Ok(None);
+        }
+        let start = self.descriptor.data.addr();
+        let bytes = self
+            .descriptor
+            .len
+            .checked_mul(std::mem::size_of::<f64>())
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("SymJIT plane byte length overflows usize")
+            })?;
+        let end = start.checked_add(bytes).ok_or_else(|| {
+            RusticolError::invalid_argument("SymJIT plane address range overflows usize")
+        })?;
+        Ok(Some((start, end)))
+    }
+
+    pub(crate) const fn len(&self) -> usize {
+        self.descriptor.len
+    }
+}
+
+impl SymjitRawPlane<'static> {
+    /// Creates a descriptor for an owner-managed, address-stable runtime cache.
+    ///
+    /// The returned `'static` tag is a storage convenience, not an allocation
+    /// lifetime claim.
+    ///
+    /// # Safety
+    ///
+    /// The owning runtime must prevent every invocation or descriptor
+    /// dereference after the backing allocation moves, reallocates, or drops;
+    /// keep the memory aligned and writable for `len` values during each
+    /// invocation; and synchronize all descriptor use. Rebinding must finish
+    /// before the old allocation is invalidated.
+    pub(crate) unsafe fn from_cached_raw_parts(
+        pointer: *mut f64,
+        len: usize,
+    ) -> RusticolResult<Self> {
+        unsafe { SymjitRawPlane::from_raw_parts(pointer, len) }
+    }
+}
+
+/// Loaded P-kernel code. The `Applet` owns the executable mappings referenced
+/// by the cached function pointers.
+pub(crate) struct SymjitPlaneKernel {
+    applet: Applet,
+    display_path: PathBuf,
+    layout: SymjitPlaneLayout,
+    optimization_level: u8,
+    compression: bool,
+    scalar: PlaneKernelFn,
+    simd: Option<PlaneKernelFn>,
+    simd_lanes: usize,
+}
+
+impl std::fmt::Debug for SymjitPlaneKernel {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("SymjitPlaneKernel")
+            .field("display_path", &self.display_path)
+            .field("layout", &self.layout)
+            .field("optimization_level", &self.optimization_level)
+            .field("compression", &self.compression)
+            .field("simd_lanes", &self.simd_lanes)
+            .finish_non_exhaustive()
+    }
+}
+
+impl SymjitPlaneKernel {
+    /// Loads, authenticates, recompiles, and seals a storage-v3 P-kernel.
+    pub(crate) fn load_bytes(
+        bytes: &[u8],
+        display_path: impl Into<PathBuf>,
+        layout: SymjitPlaneLayout,
+    ) -> RusticolResult<Self> {
+        let display_path = display_path.into();
+        authenticate_storage_v3(bytes, &display_path)?;
+
+        let mut loader_config = explicit_loader_config()?;
+        loader_config.set_defuns(Defuns::new());
+        let mut input = bytes;
+        let mut application = guard_symjit_panic(
+            || Application::load(&mut input, &loader_config),
+            || format!("load plane application {}", display_path.display()),
+        )?
+        .map_err(|error| {
+            RusticolError::compatibility(format!(
+                "could not load SymJIT storage-v3 plane application {}: {error}",
+                display_path.display()
+            ))
+        })?;
+        if !input.is_empty() {
+            return Err(RusticolError::integrity(format!(
+                "SymJIT plane application {} has {} unauthenticated trailing bytes",
+                display_path.display(),
+                input.len()
+            )));
+        }
+        let optimization_level = validate_application(&application, &display_path, layout)?;
+        let compression = application.config.compress();
+
+        // SIMD compilation is lazy in SymJIT. Calling this before sealing
+        // guarantees that a supported SIMD kernel is retained by the Applet.
+        guard_symjit_panic(
+            || application.prepare_simd(),
+            || {
+                format!(
+                    "prepare SIMD for plane application {}",
+                    display_path.display()
+                )
+            },
+        )?;
+        validate_compiled_kernels(&application, &display_path)?;
+
+        let applet = guard_symjit_panic(
+            || application.seal(),
+            || format!("seal plane application {}", display_path.display()),
+        )?
+        .map_err(|error| {
+            RusticolError::evaluation(format!(
+                "could not seal SymJIT plane application {}: {error}",
+                display_path.display()
+            ))
+        })?;
+        let scalar = applet.scalar_plane_kernel().ok_or_else(|| {
+            RusticolError::compatibility(format!(
+                "SymJIT plane application {} has no scalar raw-plane kernel",
+                display_path.display()
+            ))
+        })?;
+        let (simd, simd_lanes) = match applet.compiled_simd.as_ref() {
+            Some(compiled) if compiled.support_indirect() => {
+                (applet.simd_plane_kernel(), compiled.count_lanes())
+            }
+            _ => (None, 1),
+        };
+        validate_simd_lane_width(simd.is_some(), simd_lanes, &display_path)?;
+
+        Ok(Self {
+            applet,
+            display_path,
+            layout,
+            optimization_level,
+            compression,
+            scalar,
+            simd,
+            simd_lanes,
+        })
+    }
+
+    pub(crate) fn input_plane_count(&self) -> usize {
+        self.layout
+            .input_plane_count()
+            .expect("validated SymJIT input plane count")
+    }
+
+    pub(crate) fn output_plane_count(&self) -> usize {
+        self.layout
+            .output_plane_count()
+            .expect("validated SymJIT output plane count")
+    }
+
+    #[cfg(test)]
+    pub(crate) const fn simd_lanes(&self) -> usize {
+        self.simd_lanes
+    }
+
+    pub(crate) fn optimization_level(&self) -> u8 {
+        self.optimization_level
+    }
+
+    pub(crate) fn compression(&self) -> bool {
+        self.compression
+    }
+
+    /// Cold-binds safe, mutually disjoint slices into one stable descriptor
+    /// table. The vector is never resized on the execution path.
+    #[cfg(test)]
+    pub(crate) fn bind<'kernel, 'planes>(
+        &'kernel self,
+        planes: Vec<&'planes mut [f64]>,
+    ) -> RusticolResult<SymjitBoundPlaneKernel<'kernel, 'planes>> {
+        let table = self.build_table(planes)?;
+        Ok(SymjitBoundPlaneKernel {
+            kernel: self,
+            table,
+        })
+    }
+
+    /// Cold-builds a descriptor table which is independent of the kernel
+    /// borrow and can be cached by recurrence/eager runtimes.
+    #[cfg(test)]
+    pub(crate) fn build_table<'planes>(
+        &self,
+        planes: Vec<&'planes mut [f64]>,
+    ) -> RusticolResult<SymjitPlaneTable<'planes>> {
+        validate_slice_table(self.layout, &planes)?;
+        let point_count = planes.first().map_or(0, |plane| plane.len());
+        let descriptors = planes
+            .into_iter()
+            .map(|plane| {
+                // SAFETY: The table carries `'planes`, retaining each
+                // exclusive slice borrow for the descriptor's lifetime.
+                unsafe { SymjitPlaneDescriptor::from_raw_parts(plane.as_mut_ptr(), plane.len()) }
+            })
+            .collect();
+        Ok(SymjitPlaneTable {
+            descriptors,
+            point_count,
+            input_plane_count: self.input_plane_count(),
+            output_plane_count: self.output_plane_count(),
+            simd_safe: true,
+            _lifetime: PhantomData,
+        })
+    }
+
+    /// Cold-binds raw planes after validating their shape and address ranges.
+    /// Duplicate input planes and exact input/output aliases are valid.
+    #[cfg(test)]
+    pub(crate) fn bind_raw<'kernel, 'planes>(
+        &'kernel self,
+        planes: Vec<SymjitRawPlane<'planes>>,
+    ) -> RusticolResult<SymjitBoundPlaneKernel<'kernel, 'planes>> {
+        let table = self.build_raw_table(planes)?;
+        Ok(SymjitBoundPlaneKernel {
+            kernel: self,
+            table,
+        })
+    }
+
+    /// Cold-builds a reusable table from raw plane descriptors.
+    pub(crate) fn build_raw_table<'planes>(
+        &self,
+        planes: Vec<PlaneDescriptor<'planes>>,
+    ) -> RusticolResult<SymjitPlaneTable<'planes>> {
+        self.build_raw_table_from_descriptors(&planes)
+    }
+
+    /// Cold-builds a reusable table while retaining the caller's descriptor
+    /// vector and capacity for subsequent allocation-free row preparation.
+    pub(crate) fn build_raw_table_from_descriptors<'planes>(
+        &self,
+        planes: &[PlaneDescriptor<'planes>],
+    ) -> RusticolResult<SymjitPlaneTable<'planes>> {
+        validate_raw_table(self.layout, planes)?;
+        let point_count = planes.first().map_or(0, PlaneDescriptor::len);
+        let input_plane_count = self.input_plane_count();
+        let output_plane_count = self.output_plane_count();
+        let simd_safe = validate_raw_aliases(input_plane_count, output_plane_count, planes)?;
+        Ok(SymjitPlaneTable {
+            descriptors: planes.iter().map(|plane| plane.descriptor).collect(),
+            point_count,
+            input_plane_count,
+            output_plane_count,
+            simd_safe,
+            _lifetime: PhantomData,
+        })
+    }
+
+    pub(crate) fn execute_table(
+        &self,
+        table: &mut SymjitPlaneTable<'_>,
+        point_start: usize,
+        point_count: usize,
+    ) -> RusticolResult<()> {
+        if table.input_plane_count != self.input_plane_count()
+            || table.output_plane_count != self.output_plane_count()
+        {
+            return Err(RusticolError::invalid_argument(format!(
+                "SymJIT plane table shape ({}, {}) does not match kernel shape ({}, {})",
+                table.input_plane_count,
+                table.output_plane_count,
+                self.input_plane_count(),
+                self.output_plane_count()
+            )));
+        }
+        self.invoke_descriptors(table, point_start, point_count)
+    }
+
+    /// Validates a scheduler-owned raw descriptor slice on the cold path.
+    ///
+    /// Retained as the checked counterpart required by the generic unsafe raw
+    /// callable contract. Current schedulers perform equivalent validation
+    /// while constructing their authenticated row storage.
+    #[allow(dead_code)]
+    pub(crate) fn validate_raw_descriptors(
+        &self,
+        planes: &[PlaneDescriptor<'_>],
+    ) -> RusticolResult<usize> {
+        validate_raw_table(self.layout, planes)?;
+        let _ = validate_raw_aliases(self.input_plane_count(), self.output_plane_count(), planes)?;
+        Ok(planes.first().map_or(0, PlaneDescriptor::len))
+    }
+
+    /// Executes a scheduler-owned descriptor slice without allocating or
+    /// copying its entries.
+    ///
+    /// # Safety
+    ///
+    /// [`Self::validate_raw_descriptors`] or equivalent scheduler-owned cold
+    /// validation must previously have succeeded for the same descriptor
+    /// shape. Every pointed-to allocation must still be live, synchronized,
+    /// and cover `point_start..point_start + point_count`.
+    /// When this kernel has a SIMD callable, every input byte range must be
+    /// disjoint from every output byte range. A divergent SIMD block writes
+    /// its epilogue before returning the replay signal, so an aliased output
+    /// could otherwise destroy an input before scalar replay. Callers that
+    /// need input/output aliases must use a cold-built [`SymjitPlaneTable`],
+    /// which detects the overlap and disables SIMD.
+    pub(crate) unsafe fn execute_raw_descriptors_unchecked(
+        &self,
+        planes: &[PlaneDescriptor<'_>],
+        point_start: usize,
+        point_count: usize,
+    ) -> RusticolResult<()> {
+        if planes.len() != self.layout.plane_count()? {
+            return Err(RusticolError::invalid_argument(
+                "SymJIT raw descriptor shape changed after cold validation",
+            ));
+        }
+        let point_end = point_start.checked_add(point_count).ok_or_else(|| {
+            RusticolError::invalid_argument("SymJIT plane execution range overflows usize")
+        })?;
+        if point_end > planes.first().map_or(0, PlaneDescriptor::len) {
+            return Err(RusticolError::invalid_argument(
+                "SymJIT raw descriptor range exceeds its validated plane capacity",
+            ));
+        }
+        if point_count == 0 {
+            return Ok(());
+        }
+        // `SymjitRawPlane` is transparent over the upstream `#[repr(C)]`
+        // descriptor; the lifetime marker has no storage.
+        let table = planes.as_ptr().cast::<SymjitPlaneDescriptor<f64>>();
+        let failure = invoke_range(
+            self.scalar,
+            self.simd,
+            self.simd_lanes,
+            table,
+            self.applet.params.as_ptr(),
+            point_start,
+            point_end,
+        )?;
+        if let Some(failure) = failure {
+            return Err(RusticolError::evaluation(format!(
+                "SymJIT plane application {} returned status {} from its scalar kernel at point index {}",
+                self.display_path.display(),
+                failure.status,
+                failure.index
+            )));
+        }
+        Ok(())
+    }
+
+    /// Invokes a prebuilt, validated descriptor table without allocating or
+    /// changing its address. This is the only runtime method coupled to
+    /// SymJIT's raw P-kernel callable.
+    fn invoke_descriptors(
+        &self,
+        table: &SymjitPlaneTable<'_>,
+        point_start: usize,
+        point_count: usize,
+    ) -> RusticolResult<()> {
+        let point_end = point_start.checked_add(point_count).ok_or_else(|| {
+            RusticolError::invalid_argument("SymJIT plane execution range overflows usize")
+        })?;
+        if point_end > table.point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "SymJIT plane execution range {point_start}..{point_end} exceeds point capacity {}",
+                table.point_count
+            )));
+        }
+        if point_count == 0 {
+            return Ok(());
+        }
+
+        let failure = invoke_range(
+            self.scalar,
+            self.simd.filter(|_| table.simd_safe),
+            self.simd_lanes,
+            table.as_symjit_ptr(),
+            self.applet.params.as_ptr(),
+            point_start,
+            point_end,
+        )?;
+        if let Some(failure) = failure {
+            return Err(RusticolError::evaluation(format!(
+                "SymJIT plane application {} returned status {} from its scalar kernel at point index {}",
+                self.display_path.display(),
+                failure.status,
+                failure.index
+            )));
+        }
+        Ok(())
+    }
+}
+
+/// The single representation-sensitive descriptor table. Descriptors are
+/// allocated and validated on the cold path and never resized while bound.
+pub(crate) struct SymjitPlaneTable<'planes> {
+    descriptors: Vec<SymjitPlaneDescriptor<f64>>,
+    point_count: usize,
+    input_plane_count: usize,
+    output_plane_count: usize,
+    /// False when any input byte range overlaps any output byte range.
+    ///
+    /// SymJIT's vector epilogue runs before it returns a lane-divergence
+    /// signal. Such tables therefore use the scalar kernel from the outset so
+    /// replay can never observe inputs clobbered by a speculative epilogue.
+    simd_safe: bool,
+    _lifetime: PhantomData<&'planes mut [f64]>,
+}
+
+impl SymjitPlaneTable<'_> {
+    fn as_symjit_ptr(&self) -> *const SymjitPlaneDescriptor<f64> {
+        self.descriptors.as_ptr()
+    }
+
+    #[cfg(test)]
+    pub(crate) const fn point_count(&self) -> usize {
+        self.point_count
+    }
+
+    #[cfg(test)]
+    const fn simd_safe(&self) -> bool {
+        self.simd_safe
+    }
+}
+
+#[cfg(test)]
+impl<'planes> SymjitPlaneTable<'planes> {
+    /// Rebinds the existing descriptor allocation to a new set of raw planes.
+    ///
+    /// The vector allocation and address remain unchanged. Validation finishes
+    /// before any slot is replaced.
+    ///
+    /// # Safety
+    ///
+    /// Every descriptor must remain allocated and writable for `'planes`. No
+    /// execution may overlap this call, the old descriptors must no longer be
+    /// used after rebinding begins, and the caller must synchronize access to
+    /// the new storage until this table is rebound again or dropped. Any
+    /// input/output alias must cover exactly the same byte range and be valid
+    /// for the particular P-kernel operation being invoked.
+    pub(crate) unsafe fn rebind_raw(
+        &mut self,
+        planes: &[PlaneDescriptor<'planes>],
+    ) -> RusticolResult<()> {
+        validate_raw_plane_count_and_ranges(self.descriptors.len(), planes)?;
+        let simd_safe =
+            validate_raw_aliases(self.input_plane_count, self.output_plane_count, planes)?;
+
+        for (descriptor, plane) in self.descriptors.iter_mut().zip(planes) {
+            *descriptor = plane.descriptor;
+        }
+        self.point_count = planes.first().map_or(0, PlaneDescriptor::len);
+        self.simd_safe = simd_safe;
+        Ok(())
+    }
+}
+
+/// A stable, allocation-free hot binding of a P-kernel to split planes.
+#[cfg(test)]
+pub(crate) struct SymjitBoundPlaneKernel<'kernel, 'planes> {
+    // Keep the Applet reachable for at least as long as every machine-code
+    // function pointer invocation.
+    kernel: &'kernel SymjitPlaneKernel,
+    table: SymjitPlaneTable<'planes>,
+}
+
+#[cfg(test)]
+impl std::fmt::Debug for SymjitBoundPlaneKernel<'_, '_> {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("SymjitBoundPlaneKernel")
+            .field("kernel", &self.kernel)
+            .field("plane_count", &self.table.descriptors.len())
+            .field("point_count", &self.table.point_count)
+            .finish()
+    }
+}
+
+#[cfg(test)]
+impl SymjitBoundPlaneKernel<'_, '_> {
+    pub(crate) fn execute_all(&mut self) -> RusticolResult<()> {
+        self.execute_range(0, self.table.point_count)
+    }
+
+    /// Executes `[point_start, point_start + point_count)`.
+    ///
+    /// Scalar and SIMD calls both receive a point index. Unaligned heads and
+    /// incomplete tails are dispatched through the scalar kernel.
+    pub(crate) fn execute_range(
+        &mut self,
+        point_start: usize,
+        point_count: usize,
+    ) -> RusticolResult<()> {
+        self.kernel
+            .execute_table(&mut self.table, point_start, point_count)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct StatusFailure {
+    index: usize,
+    status: i32,
+}
+
+fn invoke_range(
+    scalar: PlaneKernelFn,
+    simd: Option<PlaneKernelFn>,
+    simd_lanes: usize,
+    table: *const SymjitPlaneDescriptor<f64>,
+    params: *const f64,
+    point_start: usize,
+    point_end: usize,
+) -> RusticolResult<Option<StatusFailure>> {
+    catch_unwind(AssertUnwindSafe(|| {
+        let mut point = point_start;
+
+        if let Some(simd) = simd.filter(|_| simd_lanes > 1) {
+            while point < point_end && !point.is_multiple_of(simd_lanes) {
+                // SAFETY: The caller has validated every descriptor and the
+                // point range; all allocations remain live for this call.
+                let status = unsafe { scalar(std::ptr::null(), table, point, params) };
+                if status != 0 {
+                    return Some(StatusFailure {
+                        index: point,
+                        status,
+                    });
+                }
+                point += 1;
+            }
+
+            while point_end - point >= simd_lanes {
+                // SAFETY: As above; the SIMD row index starts an aligned block
+                // wholly inside the validated interior.
+                let status = unsafe { simd(std::ptr::null(), table, point, params) };
+                if status != 0 {
+                    // A nonzero vector status is SymJIT's lane-divergence
+                    // signal when vector branching is disabled. Match the
+                    // standard Applet contract by replaying every lane with
+                    // the scalar kernel. Table callers disable SIMD for
+                    // input/output aliases, because the speculative vector
+                    // epilogue has already written outputs at this point.
+                    for replay_point in point..point + simd_lanes {
+                        // SAFETY: The aligned block lies entirely inside the
+                        // validated range and scalar replay uses point indices.
+                        let scalar_status =
+                            unsafe { scalar(std::ptr::null(), table, replay_point, params) };
+                        if scalar_status != 0 {
+                            return Some(StatusFailure {
+                                index: replay_point,
+                                status: scalar_status,
+                            });
+                        }
+                    }
+                }
+                point += simd_lanes;
+            }
+        }
+
+        while point < point_end {
+            // SAFETY: The scalar tail lies inside the validated point range.
+            let status = unsafe { scalar(std::ptr::null(), table, point, params) };
+            if status != 0 {
+                return Some(StatusFailure {
+                    index: point,
+                    status,
+                });
+            }
+            point += 1;
+        }
+        None
+    }))
+    .map_err(|payload| {
+        RusticolError::evaluation(format!(
+            "SymJIT panicked while executing a plane kernel: {}",
+            panic_detail(payload)
+        ))
+    })
+}
+
+/// Compiles `repr(Evaluator.get_instructions())` into a complex, SIMD-enabled,
+/// direct-arena SymJIT storage-v3 application.
+///
+/// This is deliberately a cold-path function. It constructs every SymJIT
+/// option explicitly so a process-local `symjit.toml` cannot alter generated
+/// artifacts.
+#[cfg(any(test, feature = "python-generation-bridge"))]
+pub(crate) fn compile_symbolica_program_to_plane_application_bytes(
+    program_repr: &str,
+    input_complex_count: usize,
+    output_complex_count: usize,
+    opt_level: u8,
+    compress: bool,
+) -> RusticolResult<Vec<u8>> {
+    if program_repr.trim().is_empty() {
+        return Err(RusticolError::invalid_argument(
+            "Symbolica instruction representation must not be empty",
+        ));
+    }
+    let layout = SymjitPlaneLayout::complex(input_complex_count, output_complex_count);
+    let config = explicit_plane_config(true, opt_level, compress)?;
+    let mut compiler = Compiler::with_config(config);
+    let mut application = guard_symjit_panic(
+        || compiler.translate(program_repr.to_owned(), input_complex_count),
+        || "translate Symbolica instructions to a SymJIT plane application".to_string(),
+    )?
+    .map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not translate Symbolica instructions to a SymJIT plane application: {error}"
+        ))
+    })?;
+    let display_path = Path::new("<generated Symbolica plane application>");
+    validate_application(&application, display_path, layout)?;
+    guard_symjit_panic(
+        || application.prepare_simd(),
+        || "prepare SIMD for generated SymJIT plane application".to_string(),
+    )?;
+    validate_compiled_kernels(&application, display_path)?;
+
+    let mut bytes = Vec::new();
+    guard_symjit_panic(
+        || application.save(&mut bytes),
+        || "serialize generated SymJIT plane application".to_string(),
+    )?
+    .map_err(|error| {
+        RusticolError::serialization(format!(
+            "could not serialize generated SymJIT plane application: {error}"
+        ))
+    })?;
+    authenticate_storage_v3(&bytes, display_path)?;
+    Ok(bytes)
+}
+
+fn explicit_plane_config(complex: bool, opt_level: u8, compress: bool) -> RusticolResult<Config> {
+    if opt_level > MAX_OPTIMIZATION_LEVEL {
+        return Err(RusticolError::invalid_argument(format!(
+            "SymJIT optimization level {opt_level} is unsupported; expected 0 through {MAX_OPTIMIZATION_LEVEL}"
+        )));
+    }
+    let mut config = Config::new(CompilerType::Native, 0).map_err(|error| {
+        RusticolError::internal(format!(
+            "could not construct explicit SymJIT native configuration: {error}"
+        ))
+    })?;
+    config.set_opt_level(opt_level);
+    config.set_cse(true);
+    config.set_fastmath(true);
+    config.set_simd(true);
+    // pyAmpliCol's portable direct-plane contract is f64x4 on x86 and
+    // f64x2 on AArch64. AVX-512 remains an explicit future ABI.
+    config.enable_simd512(false);
+    config.set_simd_branch(false);
+    config.set_complex(complex);
+    config.set_fast_complex(false);
+    config.set_threads(false);
+    config.set_symbolica(true);
+    config.set_compact(true);
+    config.set_compress(compress);
+    config.set_direct(false);
+    config.set_huge(false);
+    config.set_parallel_mul(true);
+    config.set_direct_arena(true);
+    // Standard P-kernels own only an identity overwrite. pyAmpliCol applies
+    // factors and accumulation in its alias-safe arena epilogues. Set the
+    // reserved operation option and the active 2.22 identity-output option
+    // explicitly so a future SymJIT implementation cannot silently change
+    // persisted application semantics.
+    config.set_direct_arena_operation(0);
+    config.set_direct_arena_identity_output(true);
+    Ok(config)
+}
+
+fn explicit_loader_config() -> RusticolResult<Config> {
+    let mut config = Config::new(CompilerType::Native, 0).map_err(|error| {
+        RusticolError::internal(format!(
+            "could not construct explicit SymJIT loader configuration: {error}"
+        ))
+    })?;
+    config.set_opt_level(0);
+    config.set_cse(false);
+    config.set_fastmath(false);
+    config.set_simd(false);
+    config.enable_simd512(false);
+    config.set_simd_branch(false);
+    config.set_complex(false);
+    config.set_fast_complex(false);
+    config.set_threads(false);
+    config.set_symbolica(false);
+    config.set_compact(false);
+    config.set_compress(false);
+    config.set_direct(false);
+    config.set_huge(false);
+    config.set_parallel_mul(false);
+    config.set_direct_arena(false);
+    Ok(config)
+}
+
+fn authenticate_storage_v3(bytes: &[u8], display_path: &Path) -> RusticolResult<()> {
+    let word = std::mem::size_of::<usize>();
+    let header_len = word
+        .checked_mul(2)
+        .ok_or_else(|| RusticolError::internal("SymJIT storage header length overflows usize"))?;
+    if word != 8 {
+        return Err(RusticolError::compatibility(
+            "SymJIT storage-v3 plane applications require a 64-bit target",
+        ));
+    }
+    if bytes.len() < header_len {
+        return Err(RusticolError::integrity(format!(
+            "SymJIT plane application {} is truncated before its storage-v3 header",
+            display_path.display()
+        )));
+    }
+    let magic = usize::from_le_bytes(
+        bytes[..word]
+            .try_into()
+            .map_err(|_| RusticolError::internal("could not decode SymJIT application magic"))?,
+    );
+    if magic != SYMJIT_APPLICATION_MAGIC {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT plane application {} has invalid application magic",
+            display_path.display()
+        )));
+    }
+    let version = usize::from_le_bytes(
+        bytes[word..header_len]
+            .try_into()
+            .map_err(|_| RusticolError::internal("could not decode SymJIT storage version"))?,
+    );
+    if version != SYMJIT_APPLICATION_STORAGE_VERSION {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT plane application {} uses storage version {version}, expected {SYMJIT_APPLICATION_STORAGE_VERSION}",
+            display_path.display()
+        )));
+    }
+    Ok(())
+}
+
+fn validate_application(
+    application: &Application,
+    display_path: &Path,
+    layout: SymjitPlaneLayout,
+) -> RusticolResult<u8> {
+    let config = &application.config;
+    if config.is_enabled_simd512() {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT plane application {} enables unsupported SIMD512 code generation; \
+             regenerate it for the portable scalar/f64x2/f64x4 arena ABI",
+            display_path.display()
+        )));
+    }
+    let optimization_level = canonical_plane_optimization_level(config, display_path, layout)?;
+    if !config.symbolica()
+        || !config.direct_arena()
+        || config.direct()
+        || config.direct_arena_operation() != 0
+        || !config.direct_arena_identity_output()
+    {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT application {} is not an identity-overwrite indirect Symbolica \
+             direct-arena P-kernel",
+            display_path.display()
+        )));
+    }
+    if config.is_complex() != layout.is_complex() {
+        return Err(RusticolError::integrity(format!(
+            "SymJIT plane application {} complex mode does not match its binding layout",
+            display_path.display()
+        )));
+    }
+    let input_plane_count = layout.input_plane_count()?;
+    let output_plane_count = layout.output_plane_count()?;
+    if application.count_states != input_plane_count {
+        return Err(RusticolError::integrity(format!(
+            "SymJIT plane application {} stores {} input planes, expected {}",
+            display_path.display(),
+            application.count_states,
+            input_plane_count
+        )));
+    }
+    if application.count_obs != output_plane_count {
+        return Err(RusticolError::integrity(format!(
+            "SymJIT plane application {} stores {} output planes, expected {}",
+            display_path.display(),
+            application.count_obs,
+            output_plane_count
+        )));
+    }
+    if application.count_params != 0 {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT plane application {} retains {} scalar parameters; direct-arena inputs must all be states",
+            display_path.display(),
+            application.count_params
+        )));
+    }
+    if application.count_diffs != 0 {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT plane application {} contains differential outputs",
+            display_path.display()
+        )));
+    }
+    Ok(optimization_level)
+}
+
+fn canonical_plane_optimization_level(
+    config: &Config,
+    display_path: &Path,
+    layout: SymjitPlaneLayout,
+) -> RusticolResult<u8> {
+    if config.ty != CompilerType::Native {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT plane application {} uses a non-native compiler target; \
+             regenerate it with the canonical pyAmpliCol plane configuration",
+            display_path.display()
+        )));
+    }
+    let mut canonical_optimization_level = None;
+    for optimization_level in 0..=MAX_OPTIMIZATION_LEVEL {
+        let expected =
+            explicit_plane_config(layout.is_complex(), optimization_level, config.compress())?;
+        if config.opt == expected.opt {
+            canonical_optimization_level = Some(optimization_level);
+            break;
+        }
+    }
+    canonical_optimization_level.ok_or_else(|| {
+        RusticolError::compatibility(format!(
+            "SymJIT plane application {} uses noncanonical compiler options; \
+             regenerate it with the canonical pyAmpliCol plane configuration",
+            display_path.display()
+        ))
+    })
+}
+
+fn validate_simd_lane_width(
+    has_simd_kernel: bool,
+    simd_lanes: usize,
+    display_path: &Path,
+) -> RusticolResult<()> {
+    let valid = if has_simd_kernel {
+        matches!(simd_lanes, 2 | 4)
+    } else {
+        simd_lanes == 1
+    };
+    if !valid {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT plane application {} reports unsupported SIMD lane width {simd_lanes}; \
+             expected scalar fallback, f64x2, or f64x4",
+            display_path.display()
+        )));
+    }
+    Ok(())
+}
+
+fn validate_compiled_kernels(application: &Application, display_path: &Path) -> RusticolResult<()> {
+    let scalar = application.compiled.as_ref().ok_or_else(|| {
+        RusticolError::compatibility(format!(
+            "SymJIT plane application {} has no scalar native kernel",
+            display_path.display()
+        ))
+    })?;
+    if !scalar.support_indirect() {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT plane application {} scalar kernel does not support indirect plane descriptors",
+            display_path.display()
+        )));
+    }
+    if let Some(simd) = application.compiled_simd.as_ref()
+        && (!simd.support_indirect() || simd.count_lanes() <= 1)
+    {
+        return Err(RusticolError::compatibility(format!(
+            "SymJIT plane application {} has an invalid indirect SIMD kernel",
+            display_path.display()
+        )));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+fn validate_slice_table(layout: SymjitPlaneLayout, planes: &[&mut [f64]]) -> RusticolResult<()> {
+    let expected = layout.plane_count()?;
+    if planes.len() != expected {
+        return Err(RusticolError::invalid_argument(format!(
+            "SymJIT plane table has {} planes, expected {expected}",
+            planes.len()
+        )));
+    }
+    let point_count = planes.first().map_or(0, |plane| plane.len());
+    if let Some((index, plane)) = planes
+        .iter()
+        .enumerate()
+        .find(|(_, plane)| plane.len() != point_count)
+    {
+        return Err(RusticolError::invalid_argument(format!(
+            "SymJIT plane {index} has length {}, expected {point_count}",
+            plane.len()
+        )));
+    }
+    Ok(())
+}
+
+fn validate_raw_table(
+    layout: SymjitPlaneLayout,
+    planes: &[SymjitRawPlane<'_>],
+) -> RusticolResult<()> {
+    let expected = layout.plane_count()?;
+    validate_raw_plane_count_and_ranges(expected, planes)
+}
+
+fn validate_raw_plane_count_and_ranges(
+    expected: usize,
+    planes: &[SymjitRawPlane<'_>],
+) -> RusticolResult<()> {
+    if planes.len() != expected {
+        return Err(RusticolError::invalid_argument(format!(
+            "SymJIT raw plane table has {} planes, expected {expected}",
+            planes.len()
+        )));
+    }
+    let point_count = planes.first().map_or(0, PlaneDescriptor::len);
+    for (index, plane) in planes.iter().enumerate() {
+        if plane.len() != point_count {
+            return Err(RusticolError::invalid_argument(format!(
+                "SymJIT raw plane {index} has length {}, expected {point_count}",
+                plane.len()
+            )));
+        }
+        let _ = plane.interval()?;
+    }
+    Ok(())
+}
+
+fn validate_raw_aliases(
+    input_plane_count: usize,
+    output_plane_count: usize,
+    planes: &[SymjitRawPlane<'_>],
+) -> RusticolResult<bool> {
+    let expected = input_plane_count
+        .checked_add(output_plane_count)
+        .ok_or_else(|| RusticolError::invalid_argument("SymJIT plane count overflows usize"))?;
+    if planes.len() != expected {
+        return Err(RusticolError::invalid_argument(format!(
+            "SymJIT raw plane table has {} planes, expected {expected}",
+            planes.len()
+        )));
+    }
+
+    let (inputs, outputs) = planes.split_at(input_plane_count);
+    for (index, output) in outputs.iter().enumerate() {
+        let Some(output_interval) = output.interval()? else {
+            continue;
+        };
+        for other in &outputs[index + 1..] {
+            let Some(other_interval) = other.interval()? else {
+                continue;
+            };
+            if output_interval.0 < other_interval.1 && other_interval.0 < output_interval.1 {
+                return Err(RusticolError::invalid_argument(
+                    "SymJIT output planes overlap; output planes must be mutually disjoint",
+                ));
+            }
+        }
+    }
+
+    let mut disjoint = true;
+    for input in inputs {
+        let Some(input_interval) = input.interval()? else {
+            continue;
+        };
+        for output in outputs {
+            let Some(output_interval) = output.interval()? else {
+                continue;
+            };
+            if input_interval.0 < output_interval.1 && output_interval.0 < input_interval.1 {
+                if input_interval == output_interval {
+                    disjoint = false;
+                    continue;
+                }
+                return Err(RusticolError::invalid_argument(
+                    "a SymJIT input/output plane pair partially overlaps; only disjoint planes or exact aliases are supported",
+                ));
+            }
+        }
+    }
+    Ok(disjoint)
+}
+
+fn guard_symjit_panic<T>(
+    operation: impl FnOnce() -> T,
+    action: impl FnOnce() -> String,
+) -> RusticolResult<T> {
+    catch_unwind(AssertUnwindSafe(operation)).map_err(|payload| {
+        RusticolError::compatibility(format!(
+            "SymJIT panicked while trying to {}: {}",
+            action(),
+            panic_detail(payload)
+        ))
+    })
+}
+
+fn panic_detail(payload: Box<dyn Any + Send>) -> String {
+    if let Some(message) = payload.downcast_ref::<&str>() {
+        (*message).to_string()
+    } else if let Some(message) = payload.downcast_ref::<String>() {
+        message.clone()
+    } else {
+        "non-string panic payload".to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::RusticolErrorKind;
+
+    const MODEL: &str = "
+([('fun', ('temp', 0), 'square', [], [('param', 0)], False),
+  ('add', ('temp', 1), [('temp', 0), ('param', 1)], 0),
+  ('assign', ('out', 0), ('temp', 1))],
+ 2,
+ [])
+";
+    const DIVERGENT_MODEL: &str = "
+([('if_else', ('param', 0), 2),
+  ('goto', 3),
+  ('label', 2),
+  ('label', 3),
+  ('join', ('out', 0), ('param', 0), ('param', 1), ('param', 2))],
+ 2,
+ [])
+";
+    const LENGTHS: &[usize] = &[1, 2, 3, 7, 8, 127, 128, 129, 1023, 1024, 1025];
+    const SENTINEL: f64 = -9.876_543_210_123_456e211;
+
+    fn application_bytes(complex: bool, opt_level: u8) -> Vec<u8> {
+        let config = explicit_plane_config(complex, opt_level, true).unwrap();
+        application_bytes_with_config(config)
+    }
+
+    fn application_bytes_with_config(config: Config) -> Vec<u8> {
+        let mut compiler = Compiler::with_config(config);
+        let mut application = compiler.translate(MODEL.to_string(), 2).unwrap();
+        application.prepare_simd();
+        let mut bytes = Vec::new();
+        application.save(&mut bytes).unwrap();
+        bytes
+    }
+
+    fn divergent_application_bytes() -> Vec<u8> {
+        let config = explicit_plane_config(false, 3, true).unwrap();
+        let mut compiler = Compiler::with_config(config);
+        let mut application = compiler.translate(DIVERGENT_MODEL.to_string(), 3).unwrap();
+        application.prepare_simd();
+        let mut bytes = Vec::new();
+        application.save(&mut bytes).unwrap();
+        bytes
+    }
+
+    fn guarded_plane(len: usize, values: impl Fn(usize) -> f64) -> Vec<f64> {
+        let mut plane = vec![SENTINEL; len + 2];
+        for index in 0..len {
+            plane[index + 1] = values(index);
+        }
+        plane
+    }
+
+    fn assert_guards(plane: &[f64]) {
+        assert_eq!(plane.first().copied(), Some(SENTINEL));
+        assert_eq!(plane.last().copied(), Some(SENTINEL));
+    }
+
+    fn assert_native_simd_lanes(kernel: &SymjitPlaneKernel) {
+        #[cfg(target_arch = "aarch64")]
+        assert_eq!(kernel.simd_lanes(), 2);
+        #[cfg(target_arch = "x86_64")]
+        assert_eq!(
+            kernel.simd_lanes(),
+            if std::is_x86_feature_detected!("avx") {
+                4
+            } else {
+                1
+            }
+        );
+        #[cfg(not(any(target_arch = "aarch64", target_arch = "x86_64")))]
+        assert_eq!(kernel.simd_lanes(), 1);
+    }
+
+    fn execute_forced_scalar(kernel: &SymjitPlaneKernel, table: &SymjitPlaneTable<'_>, len: usize) {
+        for point in 0..len {
+            let status = unsafe {
+                (kernel.scalar)(
+                    std::ptr::null(),
+                    table.as_symjit_ptr(),
+                    point,
+                    kernel.applet.params.as_ptr(),
+                )
+            };
+            assert_eq!(status, 0, "scalar status at point {point}");
+        }
+    }
+
+    fn execute_forced_simd(kernel: &SymjitPlaneKernel, table: &SymjitPlaneTable<'_>, len: usize) {
+        let mut point = 0;
+        let mut simd_call_count = 0;
+        if let Some(simd) = kernel.simd.filter(|_| kernel.simd_lanes() > 1) {
+            while len - point >= kernel.simd_lanes() {
+                let status = unsafe {
+                    simd(
+                        std::ptr::null(),
+                        table.as_symjit_ptr(),
+                        point,
+                        kernel.applet.params.as_ptr(),
+                    )
+                };
+                assert_eq!(status, 0, "SIMD status at row {point}");
+                point += kernel.simd_lanes();
+                simd_call_count += 1;
+            }
+        }
+        if kernel.simd_lanes() > 1 && len >= kernel.simd_lanes() {
+            assert!(simd_call_count > 0, "forced SIMD path executed no blocks");
+        }
+        while point < len {
+            let status = unsafe {
+                (kernel.scalar)(
+                    std::ptr::null(),
+                    table.as_symjit_ptr(),
+                    point,
+                    kernel.applet.params.as_ptr(),
+                )
+            };
+            assert_eq!(status, 0, "scalar tail status at point {point}");
+            point += 1;
+        }
+    }
+
+    #[test]
+    fn real_forced_scalar_and_simd_preserve_sentinels_for_all_lengths() {
+        let bytes = application_bytes(false, 3);
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "real-contract.symjit",
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap();
+        assert_eq!(kernel.input_plane_count(), 2);
+        assert_eq!(kernel.output_plane_count(), 1);
+        assert_native_simd_lanes(&kernel);
+
+        for &len in LENGTHS {
+            let mut x = guarded_plane(len, |i| i as f64 * 0.25 - 3.0);
+            let mut y = guarded_plane(len, |i| 7.0 - i as f64 * 0.125);
+            let mut scalar_out = guarded_plane(len, |_| f64::NAN);
+            let mut simd_out = guarded_plane(len, |_| f64::NAN);
+            {
+                let table = kernel
+                    .build_raw_table(vec![
+                        PlaneDescriptor::from_slice(&mut x[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut y[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut scalar_out[1..len + 1]),
+                    ])
+                    .unwrap();
+                assert_eq!(table.point_count(), len);
+                execute_forced_scalar(&kernel, &table, len);
+            }
+            {
+                let table = kernel
+                    .build_raw_table(vec![
+                        PlaneDescriptor::from_slice(&mut x[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut y[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut simd_out[1..len + 1]),
+                    ])
+                    .unwrap();
+                execute_forced_simd(&kernel, &table, len);
+            }
+            for index in 0..len {
+                let expected = x[index + 1] * x[index + 1] + y[index + 1];
+                assert_eq!(
+                    scalar_out[index + 1],
+                    expected,
+                    "scalar length {len}, point {index}"
+                );
+                assert_eq!(
+                    simd_out[index + 1],
+                    expected,
+                    "SIMD length {len}, point {index}"
+                );
+            }
+            assert_guards(&x);
+            assert_guards(&y);
+            assert_guards(&scalar_out);
+            assert_guards(&simd_out);
+        }
+    }
+
+    #[test]
+    fn complex_forced_scalar_and_simd_cover_every_length() {
+        let bytes =
+            compile_symbolica_program_to_plane_application_bytes(MODEL, 2, 1, 3, true).unwrap();
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "complex-contract.symjit",
+            SymjitPlaneLayout::complex(2, 1),
+        )
+        .unwrap();
+        assert_eq!(kernel.input_plane_count(), 4);
+        assert_eq!(kernel.output_plane_count(), 2);
+        assert_native_simd_lanes(&kernel);
+
+        for &len in LENGTHS {
+            let mut x_re = guarded_plane(len, |i| i as f64 * 0.25 - 1.0);
+            let mut x_im = guarded_plane(len, |i| 0.5 + i as f64 * 0.0625);
+            let mut y_re = guarded_plane(len, |i| 2.0 - i as f64 * 0.125);
+            let mut y_im = guarded_plane(len, |i| -0.75 + i as f64 * 0.03125);
+            let mut scalar_out_re = guarded_plane(len, |_| f64::NAN);
+            let mut scalar_out_im = guarded_plane(len, |_| f64::NAN);
+            let mut simd_out_re = guarded_plane(len, |_| f64::NAN);
+            let mut simd_out_im = guarded_plane(len, |_| f64::NAN);
+            {
+                let table = kernel
+                    .build_raw_table(vec![
+                        PlaneDescriptor::from_slice(&mut x_re[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut x_im[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut y_re[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut y_im[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut scalar_out_re[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut scalar_out_im[1..len + 1]),
+                    ])
+                    .unwrap();
+                execute_forced_scalar(&kernel, &table, len);
+            }
+            {
+                let table = kernel
+                    .build_raw_table(vec![
+                        PlaneDescriptor::from_slice(&mut x_re[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut x_im[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut y_re[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut y_im[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut simd_out_re[1..len + 1]),
+                        PlaneDescriptor::from_slice(&mut simd_out_im[1..len + 1]),
+                    ])
+                    .unwrap();
+                execute_forced_simd(&kernel, &table, len);
+            }
+            for index in 0..len {
+                let xr = x_re[index + 1];
+                let xi = x_im[index + 1];
+                let expected_re = xr * xr - xi * xi + y_re[index + 1];
+                let expected_im = 2.0 * xr * xi + y_im[index + 1];
+                for (lane, actual_re, actual_im) in [
+                    ("scalar", scalar_out_re[index + 1], scalar_out_im[index + 1]),
+                    ("SIMD", simd_out_re[index + 1], simd_out_im[index + 1]),
+                ] {
+                    assert_eq!(
+                        actual_re, expected_re,
+                        "{lane} length {len}, point {index}, real"
+                    );
+                    assert_eq!(
+                        actual_im, expected_im,
+                        "{lane} length {len}, point {index}, imaginary"
+                    );
+                }
+            }
+            for plane in [
+                &x_re,
+                &x_im,
+                &y_re,
+                &y_im,
+                &scalar_out_re,
+                &scalar_out_im,
+                &simd_out_re,
+                &simd_out_im,
+            ] {
+                assert_guards(plane);
+            }
+        }
+    }
+
+    #[test]
+    fn unaligned_subrange_uses_scalar_head_and_tail() {
+        let bytes = application_bytes(false, 2);
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "unaligned-contract.symjit",
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap();
+        let len = 19;
+        let mut x: Vec<f64> = (0..len).map(|i| i as f64 + 1.0).collect();
+        let mut y: Vec<f64> = (0..len).map(|i| i as f64 * 0.5).collect();
+        let mut out = vec![SENTINEL; len];
+        {
+            let mut bound = kernel
+                .bind(vec![x.as_mut_slice(), y.as_mut_slice(), out.as_mut_slice()])
+                .unwrap();
+            bound.execute_range(1, len - 3).unwrap();
+        }
+        assert_eq!(out[0], SENTINEL);
+        assert_eq!(out[len - 2], SENTINEL);
+        assert_eq!(out[len - 1], SENTINEL);
+        for index in 1..len - 2 {
+            assert_eq!(out[index], x[index] * x[index] + y[index]);
+        }
+    }
+
+    #[test]
+    fn raw_binding_executes_duplicate_inputs_without_overlapping_references() {
+        let bytes = application_bytes(false, 2);
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "duplicate-contract.symjit",
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap();
+        for &len in LENGTHS {
+            let mut input: Vec<f64> = (1..=len).map(|value| value as f64).collect();
+            let mut output = vec![0.0; len];
+            let duplicate = input.as_mut_ptr();
+            {
+                let mut bound = kernel
+                    .bind_raw(vec![
+                        // SAFETY: Both descriptors share live, synchronized
+                        // read-only input storage for the duration of execution.
+                        unsafe { PlaneDescriptor::from_raw_parts(duplicate, input.len()).unwrap() },
+                        unsafe { PlaneDescriptor::from_raw_parts(duplicate, input.len()).unwrap() },
+                        PlaneDescriptor::from_slice(output.as_mut_slice()),
+                    ])
+                    .unwrap();
+                bound.execute_all().unwrap();
+            }
+            for (index, value) in input.iter().copied().enumerate() {
+                assert_eq!(
+                    output[index],
+                    value * value + value,
+                    "length {len}, point {index}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn raw_binding_executes_input_output_alias_from_prologue_snapshot() {
+        let bytes = application_bytes(false, 2);
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "alias-contract.symjit",
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap();
+        for &len in LENGTHS {
+            let mut first: Vec<f64> = (1..=len).map(|value| value as f64).collect();
+            let original_first = first.clone();
+            let mut second: Vec<f64> = (0..len).map(|index| 10.0 + index as f64).collect();
+            let alias = first.as_mut_ptr();
+            {
+                let mut bound = kernel
+                    .bind_raw(vec![
+                        // SAFETY: The P-kernel snapshots its inputs in the
+                        // prologue before overwriting the aliased output.
+                        unsafe { PlaneDescriptor::from_raw_parts(alias, first.len()).unwrap() },
+                        PlaneDescriptor::from_slice(second.as_mut_slice()),
+                        unsafe { PlaneDescriptor::from_raw_parts(alias, first.len()).unwrap() },
+                    ])
+                    .unwrap();
+                assert!(!bound.table.simd_safe());
+                bound.execute_all().unwrap();
+            }
+            for index in 0..first.len() {
+                assert_eq!(
+                    first[index],
+                    original_first[index] * original_first[index] + second[index],
+                    "length {len}, point {index}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn complex_raw_binding_supports_duplicate_inputs_for_all_lengths() {
+        let bytes =
+            compile_symbolica_program_to_plane_application_bytes(MODEL, 2, 1, 2, true).unwrap();
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "complex-duplicate-contract.symjit",
+            SymjitPlaneLayout::complex(2, 1),
+        )
+        .unwrap();
+        for &len in LENGTHS {
+            let mut input_re: Vec<f64> = (0..len).map(|index| 0.5 + index as f64 * 0.25).collect();
+            let mut input_im: Vec<f64> =
+                (0..len).map(|index| -0.75 + index as f64 * 0.125).collect();
+            let mut output_re = vec![0.0; len];
+            let mut output_im = vec![0.0; len];
+            let input_re_pointer = input_re.as_mut_ptr();
+            let input_im_pointer = input_im.as_mut_ptr();
+            {
+                let mut bound = kernel
+                    .bind_raw(vec![
+                        unsafe {
+                            PlaneDescriptor::from_raw_parts(input_re_pointer, input_re.len())
+                                .unwrap()
+                        },
+                        unsafe {
+                            PlaneDescriptor::from_raw_parts(input_im_pointer, input_im.len())
+                                .unwrap()
+                        },
+                        unsafe {
+                            PlaneDescriptor::from_raw_parts(input_re_pointer, input_re.len())
+                                .unwrap()
+                        },
+                        unsafe {
+                            PlaneDescriptor::from_raw_parts(input_im_pointer, input_im.len())
+                                .unwrap()
+                        },
+                        PlaneDescriptor::from_slice(output_re.as_mut_slice()),
+                        PlaneDescriptor::from_slice(output_im.as_mut_slice()),
+                    ])
+                    .unwrap();
+                bound.execute_all().unwrap();
+            }
+            for index in 0..len {
+                let real = input_re[index];
+                let imaginary = input_im[index];
+                let expected_re = real * real - imaginary * imaginary + real;
+                let expected_im = 2.0 * real * imaginary + imaginary;
+                assert_eq!(
+                    output_re[index], expected_re,
+                    "length {len}, point {index}, real"
+                );
+                assert_eq!(
+                    output_im[index], expected_im,
+                    "length {len}, point {index}, imaginary"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn complex_raw_binding_supports_exact_output_aliases_for_all_lengths() {
+        let bytes =
+            compile_symbolica_program_to_plane_application_bytes(MODEL, 2, 1, 2, true).unwrap();
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "complex-alias-contract.symjit",
+            SymjitPlaneLayout::complex(2, 1),
+        )
+        .unwrap();
+        for &len in LENGTHS {
+            let mut first_re: Vec<f64> = (0..len).map(|index| 1.0 + index as f64 * 0.25).collect();
+            let mut first_im: Vec<f64> =
+                (0..len).map(|index| -0.5 + index as f64 * 0.125).collect();
+            let original_first: Vec<(f64, f64)> = first_re
+                .iter()
+                .copied()
+                .zip(first_im.iter().copied())
+                .collect();
+            let mut second_re: Vec<f64> =
+                (0..len).map(|index| 3.0 - index as f64 * 0.125).collect();
+            let mut second_im: Vec<f64> =
+                (0..len).map(|index| 0.25 + index as f64 * 0.0625).collect();
+            let first_re_pointer = first_re.as_mut_ptr();
+            let first_im_pointer = first_im.as_mut_ptr();
+            {
+                let mut bound = kernel
+                    .bind_raw(vec![
+                        unsafe {
+                            PlaneDescriptor::from_raw_parts(first_re_pointer, first_re.len())
+                                .unwrap()
+                        },
+                        unsafe {
+                            PlaneDescriptor::from_raw_parts(first_im_pointer, first_im.len())
+                                .unwrap()
+                        },
+                        PlaneDescriptor::from_slice(second_re.as_mut_slice()),
+                        PlaneDescriptor::from_slice(second_im.as_mut_slice()),
+                        unsafe {
+                            PlaneDescriptor::from_raw_parts(first_re_pointer, first_re.len())
+                                .unwrap()
+                        },
+                        unsafe {
+                            PlaneDescriptor::from_raw_parts(first_im_pointer, first_im.len())
+                                .unwrap()
+                        },
+                    ])
+                    .unwrap();
+                assert!(!bound.table.simd_safe());
+                bound.execute_all().unwrap();
+            }
+            for index in 0..len {
+                let (real, imaginary) = original_first[index];
+                let expected_re = real * real - imaginary * imaginary + second_re[index];
+                let expected_im = 2.0 * real * imaginary + second_im[index];
+                assert_eq!(
+                    first_re[index], expected_re,
+                    "length {len}, point {index}, real"
+                );
+                assert_eq!(
+                    first_im[index], expected_im,
+                    "length {len}, point {index}, imaginary"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn shifted_input_output_overlap_is_rejected() {
+        let bytes = application_bytes(false, 2);
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "partial-overlap-contract.symjit",
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap();
+        let len = 8;
+        let mut overlapping = vec![1.0; len + 1];
+        let base = overlapping.as_mut_ptr();
+        let checked = [
+            unsafe { PlaneDescriptor::from_raw_parts(base, len).unwrap() },
+            unsafe { PlaneDescriptor::from_raw_parts(base.add(1), len).unwrap() },
+            unsafe { PlaneDescriptor::from_raw_parts(base, len).unwrap() },
+        ];
+        let checked_error = kernel.validate_raw_descriptors(&checked).unwrap_err();
+        assert_eq!(checked_error.kind(), RusticolErrorKind::InvalidArgument);
+        assert!(checked_error.message().contains("partially overlaps"));
+
+        let error = kernel
+            .bind_raw(vec![
+                unsafe { PlaneDescriptor::from_raw_parts(base, len).unwrap() },
+                unsafe { PlaneDescriptor::from_raw_parts(base.add(1), len).unwrap() },
+                unsafe { PlaneDescriptor::from_raw_parts(base, len).unwrap() },
+            ])
+            .unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+        assert!(error.message().contains("partially overlaps"));
+        assert!(error.message().contains("exact aliases"));
+    }
+
+    #[test]
+    fn overlapping_output_planes_are_rejected() {
+        let len = 8;
+        let mut input = vec![1.0; len];
+        let mut overlapping_outputs = vec![0.0; len + 1];
+        let output_base = overlapping_outputs.as_mut_ptr();
+        let descriptors = [
+            PlaneDescriptor::from_slice(input.as_mut_slice()),
+            unsafe { PlaneDescriptor::from_raw_parts(output_base, len).unwrap() },
+            unsafe { PlaneDescriptor::from_raw_parts(output_base.add(1), len).unwrap() },
+        ];
+        let error = validate_raw_aliases(1, 2, &descriptors).unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+        assert!(error.message().contains("output planes overlap"));
+        assert!(error.message().contains("mutually disjoint"));
+    }
+
+    #[test]
+    fn divergent_simd_block_replays_every_lane_with_the_scalar_kernel() {
+        let bytes = divergent_application_bytes();
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "divergent-contract.symjit",
+            SymjitPlaneLayout::real(3, 1),
+        )
+        .unwrap();
+        let len = kernel.simd_lanes().max(2) * 2;
+        let mut condition: Vec<f64> = (0..len)
+            .map(|index| if index.is_multiple_of(2) { 1.0 } else { 0.0 })
+            .collect();
+        let mut if_true: Vec<f64> = (0..len).map(|index| 10.0 + index as f64).collect();
+        let mut if_false: Vec<f64> = (0..len).map(|index| -20.0 - index as f64).collect();
+        let mut output = vec![SENTINEL; len];
+
+        let mut table = kernel
+            .build_raw_table(vec![
+                PlaneDescriptor::from_slice(condition.as_mut_slice()),
+                PlaneDescriptor::from_slice(if_true.as_mut_slice()),
+                PlaneDescriptor::from_slice(if_false.as_mut_slice()),
+                PlaneDescriptor::from_slice(output.as_mut_slice()),
+            ])
+            .unwrap();
+        assert!(table.simd_safe());
+
+        if let Some(simd) = kernel.simd.filter(|_| kernel.simd_lanes() > 1) {
+            // Establish that this input really exercises SymJIT's nonzero
+            // lane-divergence status rather than only the scalar fallback.
+            let status = unsafe {
+                simd(
+                    std::ptr::null(),
+                    table.as_symjit_ptr(),
+                    0,
+                    kernel.applet.params.as_ptr(),
+                )
+            };
+            assert_ne!(status, 0);
+        }
+
+        kernel.execute_table(&mut table, 0, len).unwrap();
+        for index in 0..len {
+            assert_eq!(
+                output[index],
+                if condition[index] != 0.0 {
+                    if_true[index]
+                } else {
+                    if_false[index]
+                }
+            );
+        }
+    }
+
+    #[test]
+    fn divergent_input_output_alias_disables_simd_before_execution() {
+        let bytes = divergent_application_bytes();
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "divergent-alias-contract.symjit",
+            SymjitPlaneLayout::real(3, 1),
+        )
+        .unwrap();
+        let len = kernel.simd_lanes().max(2) * 2;
+        let mut condition_and_output: Vec<f64> = (0..len)
+            .map(|index| if index.is_multiple_of(2) { 1.0 } else { 0.0 })
+            .collect();
+        let original_condition = condition_and_output.clone();
+        let mut if_true: Vec<f64> = (0..len).map(|index| 30.0 + index as f64).collect();
+        let mut if_false: Vec<f64> = (0..len).map(|index| -40.0 - index as f64).collect();
+        let alias = condition_and_output.as_mut_ptr();
+
+        let mut table = kernel
+            .build_raw_table(vec![
+                unsafe {
+                    PlaneDescriptor::from_raw_parts(alias, condition_and_output.len()).unwrap()
+                },
+                PlaneDescriptor::from_slice(if_true.as_mut_slice()),
+                PlaneDescriptor::from_slice(if_false.as_mut_slice()),
+                unsafe {
+                    PlaneDescriptor::from_raw_parts(alias, condition_and_output.len()).unwrap()
+                },
+            ])
+            .unwrap();
+        assert!(!table.simd_safe());
+
+        kernel.execute_table(&mut table, 0, len).unwrap();
+        for index in 0..len {
+            assert_eq!(
+                condition_and_output[index],
+                if original_condition[index] != 0.0 {
+                    if_true[index]
+                } else {
+                    if_false[index]
+                }
+            );
+        }
+    }
+
+    #[test]
+    fn disjoint_raw_binding_executes_without_descriptor_repacking() {
+        let bytes = application_bytes(false, 2);
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "raw-contract.symjit",
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap();
+        let mut x = vec![2.0, 3.0, 4.0, 5.0];
+        let mut y = vec![1.0, 2.0, 3.0, 4.0];
+        let mut out = vec![0.0; 4];
+        {
+            let mut table = kernel
+                .build_raw_table(vec![
+                    PlaneDescriptor::from_slice(x.as_mut_slice()),
+                    PlaneDescriptor::from_slice(y.as_mut_slice()),
+                    PlaneDescriptor::from_slice(out.as_mut_slice()),
+                ])
+                .unwrap();
+            assert_eq!(table.point_count(), 4);
+            let table_address = table.as_symjit_ptr().addr();
+            kernel.execute_table(&mut table, 0, 4).unwrap();
+            assert_eq!(table_address, table.as_symjit_ptr().addr());
+        }
+        assert_eq!(out, [5.0, 11.0, 19.0, 29.0]);
+    }
+
+    #[test]
+    fn raw_table_rebind_preserves_descriptor_allocation_and_executes_new_planes() {
+        let bytes = application_bytes(false, 2);
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "raw-rebind-contract.symjit",
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap();
+        let mut first_x = vec![2.0, 3.0, 4.0, 5.0];
+        let mut first_y = vec![1.0, 2.0, 3.0, 4.0];
+        let mut first_out = vec![0.0; 4];
+        let mut second_x = vec![6.0, 7.0, 8.0, 9.0];
+        let mut second_y = vec![5.0, 6.0, 7.0, 8.0];
+        let mut second_out = vec![0.0; 4];
+
+        {
+            let mut table = kernel
+                .build_raw_table(vec![
+                    PlaneDescriptor::from_slice(first_x.as_mut_slice()),
+                    PlaneDescriptor::from_slice(first_y.as_mut_slice()),
+                    PlaneDescriptor::from_slice(first_out.as_mut_slice()),
+                ])
+                .unwrap();
+            let table_address = table.as_symjit_ptr().addr();
+            kernel.execute_table(&mut table, 0, 4).unwrap();
+
+            let replacement = [
+                // SAFETY: Each allocation is live, aligned, synchronized, and
+                // retains its length until the table is dropped.
+                unsafe {
+                    PlaneDescriptor::from_raw_parts(second_x.as_mut_ptr(), second_x.len()).unwrap()
+                },
+                unsafe {
+                    PlaneDescriptor::from_raw_parts(second_y.as_mut_ptr(), second_y.len()).unwrap()
+                },
+                unsafe {
+                    PlaneDescriptor::from_raw_parts(second_out.as_mut_ptr(), second_out.len())
+                        .unwrap()
+                },
+            ];
+            // SAFETY: No kernel invocation overlaps the rebind and all
+            // replacement allocations outlive the table.
+            unsafe { table.rebind_raw(&replacement) }.unwrap();
+            assert_eq!(table_address, table.as_symjit_ptr().addr());
+            kernel.execute_table(&mut table, 0, 4).unwrap();
+            assert_eq!(table_address, table.as_symjit_ptr().addr());
+        }
+
+        assert_eq!(first_out, [5.0, 11.0, 19.0, 29.0]);
+        assert_eq!(second_out, [41.0, 55.0, 71.0, 89.0]);
+    }
+
+    #[test]
+    fn raw_table_rebind_recomputes_input_output_alias_simd_safety() {
+        let bytes = application_bytes(false, 2);
+        let kernel = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "raw-rebind-alias-contract.symjit",
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap();
+        let mut x = vec![2.0, 3.0, 4.0, 5.0];
+        let mut y = vec![1.0, 2.0, 3.0, 4.0];
+        let mut first_output = vec![0.0; 4];
+        let mut second_output = vec![0.0; 4];
+        let x_pointer = x.as_mut_ptr();
+        let y_pointer = y.as_mut_ptr();
+        let first_output_pointer = first_output.as_mut_ptr();
+        let second_output_pointer = second_output.as_mut_ptr();
+
+        let mut table = kernel
+            .build_raw_table(vec![
+                unsafe { PlaneDescriptor::from_raw_parts(x_pointer, x.len()).unwrap() },
+                unsafe { PlaneDescriptor::from_raw_parts(y_pointer, y.len()).unwrap() },
+                unsafe {
+                    PlaneDescriptor::from_raw_parts(first_output_pointer, first_output.len())
+                        .unwrap()
+                },
+            ])
+            .unwrap();
+        assert!(table.simd_safe());
+
+        let aliased = [
+            unsafe { PlaneDescriptor::from_raw_parts(x_pointer, x.len()).unwrap() },
+            unsafe { PlaneDescriptor::from_raw_parts(y_pointer, y.len()).unwrap() },
+            unsafe { PlaneDescriptor::from_raw_parts(x_pointer, x.len()).unwrap() },
+        ];
+        unsafe { table.rebind_raw(&aliased) }.unwrap();
+        assert!(!table.simd_safe());
+
+        let disjoint = [
+            unsafe { PlaneDescriptor::from_raw_parts(x_pointer, x.len()).unwrap() },
+            unsafe { PlaneDescriptor::from_raw_parts(y_pointer, y.len()).unwrap() },
+            unsafe {
+                PlaneDescriptor::from_raw_parts(second_output_pointer, second_output.len()).unwrap()
+            },
+        ];
+        unsafe { table.rebind_raw(&disjoint) }.unwrap();
+        assert!(table.simd_safe());
+    }
+
+    unsafe fn status_kernel(
+        _mem: *const f64,
+        _states: *const SymjitPlaneDescriptor<f64>,
+        index: usize,
+        _params: *const f64,
+    ) -> i32 {
+        if index == 2 { 17 } else { 0 }
+    }
+
+    unsafe fn replay_scalar_kernel(
+        _mem: *const f64,
+        states: *const SymjitPlaneDescriptor<f64>,
+        index: usize,
+        _params: *const f64,
+    ) -> i32 {
+        unsafe {
+            let input = *(*states).data.add(index);
+            *(*states.add(1)).data.add(index) = input + 0.5;
+        }
+        0
+    }
+
+    unsafe fn divergent_vector_kernel(
+        _mem: *const f64,
+        states: *const SymjitPlaneDescriptor<f64>,
+        point: usize,
+        _params: *const f64,
+    ) -> i32 {
+        unsafe {
+            for lane in 0..4 {
+                *(*states.add(1)).data.add(point + lane) = SENTINEL;
+            }
+        }
+        1
+    }
+
+    #[test]
+    fn synthetic_divergence_status_replays_the_whole_simd_block() {
+        let mut input: Vec<f64> = (0..11).map(|index| index as f64).collect();
+        let mut output = vec![SENTINEL; input.len()];
+        let descriptors = [
+            unsafe { SymjitPlaneDescriptor::from_raw_parts(input.as_mut_ptr(), input.len()) },
+            unsafe { SymjitPlaneDescriptor::from_raw_parts(output.as_mut_ptr(), output.len()) },
+        ];
+
+        let failure = invoke_range(
+            replay_scalar_kernel,
+            Some(divergent_vector_kernel),
+            4,
+            descriptors.as_ptr(),
+            std::ptr::null(),
+            1,
+            input.len() - 1,
+        )
+        .unwrap();
+        assert_eq!(failure, None);
+        assert_eq!(output[0], SENTINEL);
+        assert_eq!(output[input.len() - 1], SENTINEL);
+        for index in 1..input.len() - 1 {
+            assert_eq!(output[index], input[index] + 0.5);
+        }
+    }
+
+    unsafe fn replay_status_kernel(
+        _mem: *const f64,
+        _states: *const SymjitPlaneDescriptor<f64>,
+        index: usize,
+        _params: *const f64,
+    ) -> i32 {
+        if index == 5 { 29 } else { 0 }
+    }
+
+    unsafe fn divergence_status_only_kernel(
+        _mem: *const f64,
+        _states: *const SymjitPlaneDescriptor<f64>,
+        _point: usize,
+        _params: *const f64,
+    ) -> i32 {
+        1
+    }
+
+    #[test]
+    fn scalar_status_during_divergent_replay_is_reported_at_the_point() {
+        let failure = invoke_range(
+            replay_status_kernel,
+            Some(divergence_status_only_kernel),
+            4,
+            std::ptr::null(),
+            std::ptr::null(),
+            4,
+            8,
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            failure,
+            StatusFailure {
+                index: 5,
+                status: 29,
+            }
+        );
+    }
+
+    #[test]
+    fn nonzero_kernel_status_is_contained() {
+        let failure = invoke_range(
+            status_kernel,
+            None,
+            1,
+            std::ptr::null(),
+            std::ptr::null(),
+            0,
+            4,
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            failure,
+            StatusFailure {
+                index: 2,
+                status: 17,
+            }
+        );
+    }
+
+    #[test]
+    fn symjit_panics_are_contained_with_dependency_context() {
+        let error = guard_symjit_panic(
+            || panic!("probe panic"),
+            || "exercise the panic-containment probe".to_string(),
+        )
+        .unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Compatibility);
+        assert!(
+            error
+                .message()
+                .contains("SymJIT panicked while trying to exercise the panic-containment probe")
+        );
+        assert!(error.message().contains("probe panic"));
+    }
+
+    #[test]
+    fn storage_header_dimensions_and_trailing_bytes_fail_closed() {
+        let bytes = application_bytes(false, 2);
+
+        let mut bad_magic = bytes.clone();
+        bad_magic[0] ^= 1;
+        let error = SymjitPlaneKernel::load_bytes(
+            &bad_magic,
+            "bad-magic.symjit",
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Compatibility);
+
+        let error = SymjitPlaneKernel::load_bytes(
+            &bytes,
+            "bad-shape.symjit",
+            SymjitPlaneLayout::real(3, 1),
+        )
+        .unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+
+        let mut trailing = bytes;
+        trailing.push(0);
+        let error = SymjitPlaneKernel::load_bytes(
+            &trailing,
+            "trailing.symjit",
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+    }
+
+    #[test]
+    fn migration_contract_rejects_stored_simd512_configuration() {
+        let mut config = explicit_plane_config(false, 2, true).unwrap();
+        config.enable_simd512(true);
+        let bytes = application_bytes_with_config(config);
+        let error =
+            SymjitPlaneKernel::load_bytes(&bytes, "simd512.symjit", SymjitPlaneLayout::real(2, 1))
+                .unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Compatibility);
+        assert!(error.message().contains("SIMD512"));
+    }
+
+    #[test]
+    fn migration_contract_rejects_noncanonical_stored_configuration() {
+        let mut config = explicit_plane_config(false, 2, true).unwrap();
+        config.set_simd(false);
+        let bytes = application_bytes_with_config(config);
+        let error =
+            SymjitPlaneKernel::load_bytes(&bytes, "scalar.symjit", SymjitPlaneLayout::real(2, 1))
+                .unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Compatibility);
+        assert!(error.message().contains("noncanonical compiler options"));
+        assert!(error.message().contains("regenerate"));
+    }
+
+    #[test]
+    fn migration_contract_rejects_non_native_compiler_target() {
+        let mut config = explicit_plane_config(false, 2, true).unwrap();
+        config.ty = CompilerType::ByteCode;
+        let error = canonical_plane_optimization_level(
+            &config,
+            Path::new("bytecode.symjit"),
+            SymjitPlaneLayout::real(2, 1),
+        )
+        .unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Compatibility);
+        assert!(error.message().contains("non-native compiler target"));
+        assert!(error.message().contains("regenerate"));
+    }
+
+    #[test]
+    fn migration_contract_accepts_only_scalar_f64x2_or_f64x4_runtime_lanes() {
+        let path = Path::new("lane-contract.symjit");
+        for (has_simd, lanes) in [(false, 1), (true, 2), (true, 4)] {
+            validate_simd_lane_width(has_simd, lanes, path).unwrap();
+        }
+        for (has_simd, lanes) in [(true, 1), (false, 2), (true, 8)] {
+            let error = validate_simd_lane_width(has_simd, lanes, path).unwrap_err();
+            assert_eq!(error.kind(), RusticolErrorKind::Compatibility);
+            assert!(error.message().contains("unsupported SIMD lane width"));
+        }
+    }
+
+    #[test]
+    fn compile_helper_rejects_invalid_cold_path_inputs() {
+        let error =
+            compile_symbolica_program_to_plane_application_bytes("", 2, 1, 2, false).unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+        let error = compile_symbolica_program_to_plane_application_bytes(MODEL, 2, 1, 4, false)
+            .unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/lib.rs b/pyamplicol/rust/crates/rusticol-core/src/lib.rs
new file mode 100644
index 0000000000..4ba3c3c56c
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/lib.rs
@@ -0,0 +1,237 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Python-independent Rusticol runtime core.
+
+#[cfg(not(any(
+    feature = "f64-compiled",
+    feature = "f64-symjit",
+    feature = "symbolica-runtime"
+)))]
+compile_error!("rusticol-core requires at least one evaluator runtime feature");
+
+mod artifact;
+pub mod direct_arena;
+pub mod eager_layout;
+mod eager_lowering_v3;
+mod eager_plan_v3_pacbin;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+mod eager_runtime;
+mod eager_tables;
+mod engine;
+mod error;
+mod metadata;
+pub mod pacbin;
+pub mod recurrence;
+
+pub use artifact::{
+    ArtifactKind, ArtifactManifest, ArtifactProcess, ArtifactSelection, Payload, PayloadRole,
+    ProcessAlias, ProcessGroupRelation, Target, VerifiedArtifact, runtime_target_info,
+};
+pub use eager_lowering_v3::*;
+pub use eager_plan_v3_pacbin::*;
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+pub use eager_runtime::{
+    DEFAULT_EAGER_POINT_TILE_SIZE, DEFAULT_EAGER_WORKSPACE_MIB,
+    EAGER_HOMOGENEOUS_LINEAR_CURRENT_PROOF, EAGER_INDEPENDENT_BLOCK_SIZE, EagerComplex64,
+    EagerDirectClosureSpec, EagerExecutionPlan, EagerExecutionRuntime, EagerKernelBackend,
+    EagerKernelCall, EagerKernelInput, EagerKernelRole, EagerKernelSpec, EagerPlanDefinition,
+    EagerPlanDimensions, EagerPlanPayloads, EagerReductionEntry, EagerReductionGroup,
+    EagerRuntimeOptions, EagerSelectorPayloads, EagerSelectorStagePayload, EagerStagePayload,
+};
+pub use eager_tables::{
+    EAGER_KERNEL_ABI, EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY,
+    EAGER_OUTPUT_FACTOR_COUPLING_IMAG, EAGER_OUTPUT_FACTOR_COUPLING_REAL, EAGER_OUTPUT_FACTOR_NONE,
+    EAGER_PLAN_ABI, EAGER_RUNTIME_CAPABILITY, EAGER_SELECTOR_DOMAINS_ABI, EagerAttachmentRow,
+    EagerClosureRow, EagerCouplingRow, EagerFinalizationRow, EagerInvocationRow,
+    EagerSelectorDomainIdRow, EagerSelectorDomainRow, EagerSelectorGroupRow, MISSING_U32,
+};
+#[cfg(feature = "f64-symjit")]
+pub use engine::eager_direct_descriptor_for_source_application_bytes;
+pub use engine::{
+    NativeColorComponent, NativeCorrelatedEvaluation, NativeCorrelatedRequest,
+    NativeDecimalEvaluation, NativeDecimalResolvedEvaluation, NativeEagerExactAttachment,
+    NativeEagerExactClosure, NativeEagerExactCoupling, NativeEagerExactFinalization,
+    NativeEagerExactInvocation, NativeEagerExactSections, NativeEagerExactStage,
+    NativeExternalParticle, NativeHelicityConfiguration, NativeModelParameter,
+    NativeProfiledEvaluation, NativeRationalFactor, NativeRecurrenceExactExecutor,
+    NativeRecurrenceExactFactor, NativeRecurrenceExactSections, NativeRecurrenceSelectorPlan,
+    NativeResolvedEvaluation, NativeRuntime, NativeRuntimeMetadata, NativeRuntimeProfile,
+    NativeSpinCorrelationVectors, RuntimeCapability, preflight_prepared_kernel_pack,
+    supported_runtime_capabilities,
+};
+#[cfg(feature = "on-the-fly-test-support")]
+pub use engine::{
+    NativeOnTheFlyArtifactProbeV1, NativeOnTheFlyCurrentProbeV1,
+    NativeOnTheFlyExecutionComponentV1, NativeOnTheFlyExecutionDiagnosticV1,
+    NativeOnTheFlyFamilyProbeV1, NativeOnTheFlyFamilyQueryProbeV1,
+};
+#[cfg(any(feature = "f64-compiled", feature = "f64-symjit"))]
+pub use engine::{
+    NativeOnTheFlyWarmUpEvent, NativeOnTheFlyWarmUpEventKind, NativeOnTheFlyWarmUpObserver,
+    NativeOnTheFlyWarmUpResult, NativeOnTheFlyWarmUpStage,
+};
+pub use error::{RusticolError, RusticolErrorKind, RusticolResult};
+pub use metadata::{
+    ColorAccuracy, ColorComponent, ContractedColor, Coverage, ExternalParticle, Helicity,
+    LcColorFlow, ModelParameter, ParameterKind, ParticleRole, ProcessPhysics, Reduction,
+    ReductionGroup, ReductionKind, SelectorCapabilities,
+};
+
+pub const PYTHON_API_VERSION: u32 = 1;
+pub const TOML_SCHEMA_VERSION: u32 = 1;
+pub const COMPILED_MODEL_SCHEMA_VERSION: u32 = 9;
+pub const PROCESS_ARTIFACT_SCHEMA_VERSION: u32 = 3;
+pub const RUNTIME_PHYSICS_SCHEMA_VERSION: u32 = 1;
+pub const C_ABI_VERSION: u32 = 1;
+pub const SYMBOLICA_SERIALIZATION_ABI: &str = "symbolica-bincode2-v1";
+
+/// Unstable implementation details shared with pyAmpliCol's private PyO3
+/// extension. This module is absent from ordinary/default rusticol-core builds.
+#[cfg(feature = "python-generation-bridge")]
+#[doc(hidden)]
+pub mod __private {
+    use crate::RusticolResult;
+    use crate::recurrence::template::{
+        OwnedRecurrenceTemplateInput, ValidatedRecurrenceTemplateInput,
+    };
+    use crate::recurrence::{PreparedDirectExecutorCatalog, SemanticDigest};
+
+    /// Unstable cold-path bridge for the private PyO3 artifact generator.
+    #[doc(hidden)]
+    pub fn compile_symbolica_program_to_plane_application_bytes(
+        program_repr: &str,
+        input_complex_count: usize,
+        output_complex_count: usize,
+        optimization_level: u8,
+        compress: bool,
+    ) -> RusticolResult<Vec<u8>> {
+        crate::engine::compile_symbolica_program_to_plane_application_bytes(
+            program_repr,
+            input_complex_count,
+            output_complex_count,
+            optimization_level,
+            compress,
+        )
+    }
+
+    /// Build one authenticated compact recurrence cold-load image from the
+    /// already staged, ordinary JSON payloads and typed payload inventory.
+    #[doc(hidden)]
+    pub fn build_recurrence_bootstrap_image_v1(
+        context_json: &[u8],
+        execution_json: &[u8],
+        physics_json: &[u8],
+    ) -> RusticolResult<Vec<u8>> {
+        crate::engine::build_recurrence_bootstrap_image_v1(
+            context_json,
+            execution_json,
+            physics_json,
+        )
+    }
+
+    /// Unstable cold-path bridge for constructing the compact private
+    /// on-the-fly process seed from source-only projection JSON.
+    #[doc(hidden)]
+    pub fn project_recurrence_template_catalog_json_v1(
+        value: &serde_json::Value,
+    ) -> RusticolResult<OwnedRecurrenceTemplateInput> {
+        crate::recurrence::template_json::project_recurrence_template_catalog_json_v1(value)
+    }
+
+    /// Unstable cold-path bridge for encoding ordered validated compact seeds.
+    #[doc(hidden)]
+    pub fn build_on_the_fly_process_seed_bytes_batch_v1(
+        ordered_source_projection_jsons: &[Vec<u8>],
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct_catalog: &PreparedDirectExecutorCatalog,
+        prepared_pack_digest: SemanticDigest,
+    ) -> RusticolResult<Vec<Vec<u8>>> {
+        let mut projections = Vec::new();
+        projections
+            .try_reserve_exact(ordered_source_projection_jsons.len())
+            .map_err(|error| {
+                crate::RusticolError::invalid_argument(format!(
+                    "process-projection allocation failed: {error}"
+                ))
+            })?;
+        for (index, source_projection_json) in ordered_source_projection_jsons.iter().enumerate() {
+            let projection =
+                crate::recurrence::on_the_fly::parse_on_the_fly_process_seed_projection_v1(
+                    source_projection_json,
+                )
+                .map_err(|error| {
+                    crate::RusticolError::with_kind(
+                        error.kind(),
+                        format!(
+                            "on-the-fly process seed projection at index {index} failed: {error}"
+                        ),
+                    )
+                })?;
+            projections.push(projection);
+        }
+        let seeds = crate::recurrence::on_the_fly::build_on_the_fly_process_seeds_v1(
+            projections,
+            templates,
+            direct_catalog,
+            prepared_pack_digest,
+        )?;
+        let mut encoded = Vec::new();
+        encoded.try_reserve_exact(seeds.len()).map_err(|error| {
+            crate::RusticolError::invalid_argument(format!(
+                "encoded process-seed allocation failed: {error}"
+            ))
+        })?;
+        for (index, seed) in seeds.iter().enumerate() {
+            encoded.push(
+                crate::recurrence::on_the_fly::seed_codec::encode_on_the_fly_process_seed_v1(seed)
+                    .map_err(|error| {
+                        crate::RusticolError::with_kind(
+                            error.kind(),
+                            format!(
+                                "on-the-fly process seed encoding at index {index} failed: {error}"
+                            ),
+                        )
+                    })?,
+            );
+        }
+        Ok(encoded)
+    }
+
+    /// Unstable singleton wrapper retained for the private PyO3 generator.
+    #[doc(hidden)]
+    pub fn build_on_the_fly_process_seed_bytes_v1(
+        source_projection_json: &[u8],
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct_catalog: &PreparedDirectExecutorCatalog,
+        prepared_pack_digest: SemanticDigest,
+    ) -> RusticolResult<Vec<u8>> {
+        let payloads = build_on_the_fly_process_seed_bytes_batch_v1(
+            &[source_projection_json.to_vec()],
+            templates,
+            direct_catalog,
+            prepared_pack_digest,
+        )?;
+        let [payload] = <[Vec<u8>; 1]>::try_from(payloads).map_err(|payloads| {
+            crate::RusticolError::internal(format!(
+                "singleton process-seed byte batch returned {} payloads",
+                payloads.len()
+            ))
+        })?;
+        Ok(payload)
+    }
+
+    /// Unstable cold-path bridge for inspecting one authoritative native
+    /// process seed without exposing the internal seed representation.
+    #[doc(hidden)]
+    pub fn inspect_on_the_fly_process_seed_identity_json_v1(
+        payload: &[u8],
+    ) -> RusticolResult<String> {
+        let seed = crate::recurrence::on_the_fly::decode_on_the_fly_process_seed_v1(payload)?;
+        serde_json::to_string(&seed.identity()).map_err(|error| {
+            crate::RusticolError::serialization(format!(
+                "could not serialize on-the-fly process-seed identity: {error}"
+            ))
+        })
+    }
+}
+pub const ARTIFACT_MANIFEST_FILE: &str = "artifact.json";
diff --git a/pyamplicol/rust/crates/rusticol-core/src/metadata.rs b/pyamplicol/rust/crates/rusticol-core/src/metadata.rs
new file mode 100644
index 0000000000..620072e96e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/metadata.rs
@@ -0,0 +1,581 @@
+// SPDX-License-Identifier: 0BSD
+
+use crate::{RUNTIME_PHYSICS_SCHEMA_VERSION, RusticolError, RusticolResult};
+use bincode::Decode;
+#[cfg(any(feature = "python-generation-bridge", test))]
+use bincode::Encode;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::collections::{BTreeMap, BTreeSet};
+
+#[derive(Clone, Copy, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "lowercase")]
+pub enum ColorAccuracy {
+    Lc,
+    Nlc,
+    Full,
+}
+
+impl ColorAccuracy {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Lc => "lc",
+            Self::Nlc => "nlc",
+            Self::Full => "full",
+        }
+    }
+}
+
+impl std::fmt::Display for ColorAccuracy {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str(self.as_str())
+    }
+}
+
+#[derive(Clone, Copy, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "lowercase")]
+pub enum ParticleRole {
+    Initial,
+    Final,
+}
+
+#[derive(Clone, Copy, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(rename_all = "kebab-case")]
+pub enum ParameterKind {
+    Normalization,
+    Mass,
+    Width,
+    Coupling,
+    External,
+    Derived,
+}
+
+#[derive(Clone, Copy, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+pub enum ReductionKind {
+    #[serde(rename = "lc-diagonal")]
+    LcDiagonal,
+    #[serde(rename = "contracted-color")]
+    ContractedColor,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub struct Coverage {
+    pub helicities: String,
+    pub color: String,
+    pub color_kind: String,
+    pub structural_zero_helicity_count: usize,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub struct ExternalParticle {
+    pub index: usize,
+    pub label: usize,
+    pub particle: String,
+    pub pdg: i32,
+    pub role: ParticleRole,
+    pub momentum_slot: usize,
+    pub momentum_components: [String; 4],
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub struct Helicity {
+    pub id: String,
+    pub index: usize,
+    pub values: Vec<i32>,
+    pub computed: bool,
+    pub structural_zero: bool,
+    pub representative_id: String,
+    pub coefficient: f64,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub struct LcColorFlow {
+    pub id: String,
+    pub index: usize,
+    pub word: Vec<usize>,
+    pub computed: bool,
+    pub representative_id: String,
+    pub coefficient: f64,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub struct ContractedColor {
+    pub id: String,
+    pub index: usize,
+    pub description: String,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(tag = "kind")]
+pub enum ColorComponent {
+    #[serde(rename = "lc-flow")]
+    LcFlow(LcColorFlow),
+    #[serde(rename = "contracted-color")]
+    ContractedColor(ContractedColor),
+}
+
+impl ColorComponent {
+    pub fn id(&self) -> &str {
+        match self {
+            Self::LcFlow(value) => &value.id,
+            Self::ContractedColor(value) => &value.id,
+        }
+    }
+
+    pub fn index(&self) -> usize {
+        match self {
+            Self::LcFlow(value) => value.index,
+            Self::ContractedColor(value) => value.index,
+        }
+    }
+
+    pub fn coefficient(&self) -> f64 {
+        match self {
+            Self::LcFlow(value) => value.coefficient,
+            Self::ContractedColor(_) => 1.0,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub struct ReductionGroup {
+    pub id: String,
+    pub representative_helicity_id: String,
+    pub representative_color_id: String,
+    pub physical_helicity_ids: Vec<String>,
+    pub physical_color_ids: Vec<String>,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub struct Reduction {
+    pub kind: ReductionKind,
+    pub groups: Vec<ReductionGroup>,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub struct ModelParameter {
+    pub name: String,
+    pub kind: ParameterKind,
+    pub default_real: f64,
+    pub default_imaginary: f64,
+    pub mutable: bool,
+}
+
+#[derive(Clone, Debug, Decode, Deserialize, Eq, PartialEq, Serialize)]
+#[cfg_attr(any(feature = "python-generation-bridge", test), derive(Encode))]
+#[serde(deny_unknown_fields)]
+pub struct SelectorCapabilities {
+    pub helicity: bool,
+    pub color_flow: bool,
+    pub contracted_color: bool,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct ProcessPhysics {
+    pub schema_version: u32,
+    pub kind: String,
+    pub process_id: String,
+    pub process: String,
+    pub color_accuracy: ColorAccuracy,
+    pub coverage: Coverage,
+    pub external_particles: Vec<ExternalParticle>,
+    pub helicities: Vec<Helicity>,
+    pub color_components: Vec<ColorComponent>,
+    pub reduction: Reduction,
+    pub model_parameters: Vec<ModelParameter>,
+    pub selectors: SelectorCapabilities,
+    #[serde(default)]
+    pub extensions: BTreeMap<String, Value>,
+}
+
+impl ProcessPhysics {
+    pub fn from_json(bytes: &[u8], path: &str) -> RusticolResult<Self> {
+        let value: Self = serde_json::from_slice(bytes).map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not parse runtime physics payload {path:?}: {error}"
+            ))
+        })?;
+        value.validate()?;
+        Ok(value)
+    }
+
+    pub fn validate(&self) -> RusticolResult<()> {
+        if self.schema_version != RUNTIME_PHYSICS_SCHEMA_VERSION
+            || self.kind != "pyamplicol-resolved-physics"
+        {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported runtime physics kind {:?} schema {}; regenerate the artifact with pyAmpliCol 0.1 or newer",
+                self.kind, self.schema_version
+            )));
+        }
+        if self.external_particles.len() < 3 || self.helicities.is_empty() {
+            return Err(RusticolError::artifact(
+                "runtime physics requires at least three particles and one helicity",
+            ));
+        }
+        if self.process.is_empty()
+            || !matches!(self.coverage.helicities.as_str(), "complete" | "selected")
+            || !matches!(
+                self.coverage.color.as_str(),
+                "complete" | "selected" | "contracted"
+            )
+            || !matches!(
+                self.coverage.color_kind.as_str(),
+                "physical-lc-flows" | "contracted-color"
+            )
+        {
+            return Err(RusticolError::artifact(
+                "runtime physics has an invalid process or coverage value",
+            ));
+        }
+        validate_public_id(&self.process_id, "process id")?;
+        let expected_components = ["E", "px", "py", "pz"];
+        let mut momentum_slots = BTreeSet::new();
+        for (index, particle) in self.external_particles.iter().enumerate() {
+            if particle.index != index || particle.label != index + 1 {
+                return Err(RusticolError::artifact(format!(
+                    "external particle {index} has inconsistent index/label metadata"
+                )));
+            }
+            if particle.particle.is_empty() {
+                return Err(RusticolError::artifact(format!(
+                    "external particle {index} has an empty particle name"
+                )));
+            }
+            if !momentum_slots.insert(particle.momentum_slot) {
+                return Err(RusticolError::artifact(format!(
+                    "external particle {index} reuses momentum slot {}",
+                    particle.momentum_slot
+                )));
+            }
+            if particle
+                .momentum_components
+                .iter()
+                .map(String::as_str)
+                .ne(expected_components)
+            {
+                return Err(RusticolError::artifact(format!(
+                    "external particle {index} must use momentum components [E, px, py, pz]"
+                )));
+            }
+        }
+        if momentum_slots != (0..self.external_particles.len()).collect() {
+            return Err(RusticolError::artifact(
+                "external particle momentum slots must form a complete zero-based permutation",
+            ));
+        }
+
+        let mut helicity_ids = BTreeMap::new();
+        for (index, helicity) in self.helicities.iter().enumerate() {
+            validate_public_id(&helicity.id, "helicity id")?;
+            validate_public_id(&helicity.representative_id, "representative helicity id")?;
+            if helicity.index != index || helicity.values.len() != self.external_particles.len() {
+                return Err(RusticolError::artifact(format!(
+                    "helicity {} has inconsistent index or particle count",
+                    helicity.id
+                )));
+            }
+            if !helicity.coefficient.is_finite() || helicity.coefficient < 0.0 {
+                return Err(RusticolError::artifact(format!(
+                    "helicity {} has an invalid reduction coefficient",
+                    helicity.id
+                )));
+            }
+            if helicity_ids
+                .insert(helicity.id.as_str(), helicity)
+                .is_some()
+            {
+                return Err(RusticolError::artifact(format!(
+                    "duplicate helicity id {:?}",
+                    helicity.id
+                )));
+            }
+        }
+        for helicity in &self.helicities {
+            if !helicity_ids.contains_key(helicity.representative_id.as_str()) {
+                return Err(RusticolError::artifact(format!(
+                    "helicity {} references unknown representative {:?}",
+                    helicity.id, helicity.representative_id
+                )));
+            }
+            if helicity.structural_zero && helicity.computed {
+                return Err(RusticolError::artifact(format!(
+                    "structural-zero helicity {} may not be marked computed",
+                    helicity.id
+                )));
+            }
+            if helicity.structural_zero && helicity.coefficient != 0.0 {
+                return Err(RusticolError::artifact(format!(
+                    "structural-zero helicity {} must have a zero reduction coefficient",
+                    helicity.id
+                )));
+            }
+            if !helicity.structural_zero {
+                if helicity.coefficient <= 0.0 {
+                    return Err(RusticolError::artifact(format!(
+                        "nonzero helicity {} must have a positive reduction coefficient",
+                        helicity.id
+                    )));
+                }
+                let representative = helicity_ids
+                    .get(helicity.representative_id.as_str())
+                    .expect("representative existence checked");
+                if !representative.computed || representative.structural_zero {
+                    return Err(RusticolError::artifact(format!(
+                        "helicity {} references a non-computed representative {:?}",
+                        helicity.id, helicity.representative_id
+                    )));
+                }
+                if helicity.computed && helicity.representative_id != helicity.id {
+                    return Err(RusticolError::artifact(format!(
+                        "computed helicity {} must represent itself",
+                        helicity.id
+                    )));
+                }
+            }
+        }
+        let structural_zeros = self
+            .helicities
+            .iter()
+            .filter(|helicity| helicity.structural_zero)
+            .count();
+        if structural_zeros != self.coverage.structural_zero_helicity_count {
+            return Err(RusticolError::artifact(format!(
+                "coverage declares {} structural-zero helicities, metadata contains {structural_zeros}",
+                self.coverage.structural_zero_helicity_count
+            )));
+        }
+
+        let mut color_ids = BTreeMap::new();
+        for (index, color) in self.color_components.iter().enumerate() {
+            validate_public_id(color.id(), "color id")?;
+            if color.index() != index
+                || !color.coefficient().is_finite()
+                || color.coefficient() < 0.0
+            {
+                return Err(RusticolError::artifact(format!(
+                    "color component {} has an invalid index or coefficient",
+                    color.id()
+                )));
+            }
+            if color_ids.insert(color.id(), color).is_some() {
+                return Err(RusticolError::artifact(format!(
+                    "duplicate color component id {:?}",
+                    color.id()
+                )));
+            }
+            if let ColorComponent::LcFlow(flow) = color {
+                if flow
+                    .word
+                    .iter()
+                    .any(|label| *label == 0 || *label > self.external_particles.len())
+                {
+                    return Err(RusticolError::artifact(format!(
+                        "LC color component {} contains an out-of-range external label",
+                        flow.id
+                    )));
+                }
+            } else if let ColorComponent::ContractedColor(color) = color
+                && color.description.is_empty()
+            {
+                return Err(RusticolError::artifact(format!(
+                    "contracted color component {} has an empty description",
+                    color.id
+                )));
+            }
+        }
+        for color in &self.color_components {
+            if let ColorComponent::LcFlow(flow) = color {
+                let Some(representative) = color_ids.get(flow.representative_id.as_str()) else {
+                    return Err(RusticolError::artifact(format!(
+                        "color component {} references unknown representative {:?}",
+                        flow.id, flow.representative_id
+                    )));
+                };
+                let ColorComponent::LcFlow(representative) = representative else {
+                    return Err(RusticolError::artifact(format!(
+                        "LC color component {} references a contracted representative",
+                        flow.id
+                    )));
+                };
+                if !representative.computed {
+                    return Err(RusticolError::artifact(format!(
+                        "LC color component {} references a non-computed representative {:?}",
+                        flow.id, flow.representative_id
+                    )));
+                }
+                if flow.computed && flow.representative_id != flow.id {
+                    return Err(RusticolError::artifact(format!(
+                        "computed LC color component {} must represent itself",
+                        flow.id
+                    )));
+                }
+            }
+        }
+        match self.color_accuracy {
+            ColorAccuracy::Lc => {
+                if self.color_components.is_empty()
+                    || self
+                        .color_components
+                        .iter()
+                        .any(|item| !matches!(item, ColorComponent::LcFlow(_)))
+                {
+                    return Err(RusticolError::artifact(
+                        "LC physics requires one or more physical LC color flows",
+                    ));
+                }
+                if self.reduction.kind != ReductionKind::LcDiagonal
+                    || self.coverage.color_kind != "physical-lc-flows"
+                    || !self.selectors.color_flow
+                    || self.selectors.contracted_color
+                {
+                    return Err(RusticolError::artifact(
+                        "LC physics has inconsistent reduction, coverage, or selector metadata",
+                    ));
+                }
+            }
+            ColorAccuracy::Nlc | ColorAccuracy::Full => {
+                if self.color_components.len() != 1
+                    || !matches!(
+                        self.color_components.first(),
+                        Some(ColorComponent::ContractedColor(ContractedColor {
+                            index: 0,
+                            ..
+                        }))
+                    )
+                {
+                    return Err(RusticolError::artifact(
+                        "NLC/full physics requires exactly one contracted color component",
+                    ));
+                }
+                if self.reduction.kind != ReductionKind::ContractedColor
+                    || self.coverage.color != "contracted"
+                    || self.coverage.color_kind != "contracted-color"
+                    || self.selectors.color_flow
+                    || self.selectors.contracted_color
+                {
+                    return Err(RusticolError::artifact(
+                        "NLC/full physics has inconsistent reduction, coverage, or selector metadata",
+                    ));
+                }
+            }
+        }
+
+        let mut parameter_names = BTreeSet::new();
+        for parameter in &self.model_parameters {
+            if parameter.name.is_empty()
+                || !parameter_names.insert(&parameter.name)
+                || !parameter.default_real.is_finite()
+                || !parameter.default_imaginary.is_finite()
+                || (parameter.kind == ParameterKind::Derived && parameter.mutable)
+            {
+                return Err(RusticolError::artifact(format!(
+                    "invalid or duplicate model parameter {:?}",
+                    parameter.name
+                )));
+            }
+        }
+
+        let mut seen_groups = BTreeSet::new();
+        for group in &self.reduction.groups {
+            validate_public_id(&group.id, "reduction group id")?;
+            if !seen_groups.insert(&group.id) {
+                return Err(RusticolError::artifact(format!(
+                    "duplicate reduction group id {:?}",
+                    group.id
+                )));
+            }
+            if group.physical_helicity_ids.is_empty() || group.physical_color_ids.is_empty() {
+                return Err(RusticolError::artifact(format!(
+                    "reduction group {} has an empty physical expansion",
+                    group.id
+                )));
+            }
+            let has_representative_helicity =
+                helicity_ids.contains_key(group.representative_helicity_id.as_str());
+            let has_representative_color =
+                color_ids.contains_key(group.representative_color_id.as_str());
+            if !has_representative_helicity || !has_representative_color {
+                return Err(RusticolError::artifact(format!(
+                    "reduction group {} references an unknown representative: helicity {:?} present={has_representative_helicity}, color {:?} present={has_representative_color}; available colors={:?}",
+                    group.id,
+                    group.representative_helicity_id,
+                    group.representative_color_id,
+                    color_ids.keys().collect::<Vec<_>>(),
+                )));
+            }
+            if !group
+                .physical_helicity_ids
+                .contains(&group.representative_helicity_id)
+                || !group
+                    .physical_color_ids
+                    .contains(&group.representative_color_id)
+            {
+                return Err(RusticolError::artifact(format!(
+                    "reduction group {} does not include its representative in its physical expansion",
+                    group.id
+                )));
+            }
+            let mut physical_helicities = BTreeSet::new();
+            for id in &group.physical_helicity_ids {
+                if !helicity_ids.contains_key(id.as_str()) || !physical_helicities.insert(id) {
+                    return Err(RusticolError::artifact(format!(
+                        "reduction group {} has an unknown or duplicate helicity {:?}",
+                        group.id, id
+                    )));
+                }
+            }
+            let mut physical_colors = BTreeSet::new();
+            for id in &group.physical_color_ids {
+                if !color_ids.contains_key(id.as_str()) || !physical_colors.insert(id) {
+                    return Err(RusticolError::artifact(format!(
+                        "reduction group {} has an unknown or duplicate color {:?}",
+                        group.id, id
+                    )));
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+fn validate_public_id(value: &str, description: &str) -> RusticolResult<()> {
+    let valid = !value.is_empty()
+        && value.len() <= 255
+        && value.bytes().enumerate().all(|(index, byte)| {
+            byte.is_ascii_alphanumeric()
+                || (index > 0 && matches!(byte, b'.' | b'_' | b':' | b'+' | b',' | b'~' | b'-'))
+        });
+    if !valid {
+        return Err(RusticolError::artifact(format!(
+            "invalid {description} {value:?}"
+        )));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "metadata_tests.rs"]
+mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/metadata_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/metadata_tests.rs
new file mode 100644
index 0000000000..5066c1a3a5
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/metadata_tests.rs
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+#[test]
+fn json_model_parameter_defaults_round_trip_binary64() {
+    let expected = f64::from_bits(0x3fdd_8fdb_d004_403d);
+    let encoded = serde_json::to_vec(&ModelParameter {
+        name: "derived_coupling_88".to_owned(),
+        kind: ParameterKind::Derived,
+        default_real: 0.0,
+        default_imaginary: expected,
+        mutable: false,
+    })
+    .expect("serialize model parameter");
+    let decoded: ModelParameter = serde_json::from_slice(&encoded).expect("parse model parameter");
+
+    assert_eq!(decoded.default_imaginary.to_bits(), expected.to_bits());
+}
+
+fn valid_physics() -> ProcessPhysics {
+    ProcessPhysics {
+        schema_version: RUNTIME_PHYSICS_SCHEMA_VERSION,
+        kind: "pyamplicol-resolved-physics".to_string(),
+        process_id: "p0".to_string(),
+        process: "a b > c".to_string(),
+        color_accuracy: ColorAccuracy::Full,
+        coverage: Coverage {
+            helicities: "complete".to_string(),
+            color: "contracted".to_string(),
+            color_kind: "contracted-color".to_string(),
+            structural_zero_helicity_count: 0,
+        },
+        external_particles: (0..3)
+            .map(|index| ExternalParticle {
+                index,
+                label: index + 1,
+                particle: format!("particle-{index}"),
+                pdg: index as i32 + 1,
+                role: if index < 2 {
+                    ParticleRole::Initial
+                } else {
+                    ParticleRole::Final
+                },
+                momentum_slot: index,
+                momentum_components: [
+                    "E".to_string(),
+                    "px".to_string(),
+                    "py".to_string(),
+                    "pz".to_string(),
+                ],
+            })
+            .collect(),
+        helicities: vec![Helicity {
+            id: "helicity:0".to_string(),
+            index: 0,
+            values: vec![1, -1, 1],
+            computed: true,
+            structural_zero: false,
+            representative_id: "helicity:0".to_string(),
+            coefficient: 1.0,
+        }],
+        color_components: vec![ColorComponent::ContractedColor(ContractedColor {
+            id: "contracted".to_string(),
+            index: 0,
+            description: "coherent contracted color".to_string(),
+        })],
+        reduction: Reduction {
+            kind: ReductionKind::ContractedColor,
+            groups: vec![ReductionGroup {
+                id: "group:0".to_string(),
+                representative_helicity_id: "helicity:0".to_string(),
+                representative_color_id: "contracted".to_string(),
+                physical_helicity_ids: vec!["helicity:0".to_string()],
+                physical_color_ids: vec!["contracted".to_string()],
+            }],
+        },
+        model_parameters: Vec::new(),
+        selectors: SelectorCapabilities {
+            helicity: true,
+            color_flow: false,
+            contracted_color: false,
+        },
+        extensions: BTreeMap::new(),
+    }
+}
+
+#[test]
+fn normative_physics_metadata_validates() {
+    valid_physics().validate().unwrap();
+}
+
+#[test]
+fn nonzero_members_require_computed_representatives() {
+    let mut physics = valid_physics();
+    physics.helicities[0].computed = false;
+
+    let error = physics.validate().unwrap_err();
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("non-computed representative"));
+}
+
+#[test]
+fn momentum_slots_must_be_a_complete_permutation() {
+    let mut physics = valid_physics();
+    physics.external_particles[2].momentum_slot = 1;
+
+    let error = physics.validate().unwrap_err();
+
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("momentum slot"));
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/pacbin.rs b/pyamplicol/rust/crates/rusticol-core/src/pacbin.rs
new file mode 100644
index 0000000000..cf72999a47
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/pacbin.rs
@@ -0,0 +1,1434 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Strict reader for portable pyAmpliCol evaluator containers.
+//!
+//! `pacbin-v1` stores fixed-size metadata, aligned uncompressed member
+//! payloads, a sorted variable-width index, and a footer. The index and every
+//! payload are authenticated with SHA-256. This module is intentionally
+//! independent of artifact loading: it owns one container as immutable bytes
+//! and provides indexed borrowed slices without extracting files.
+
+use crate::{RusticolError, RusticolResult};
+use sha2::{Digest, Sha256};
+use std::collections::BTreeSet;
+use std::ffi::OsString;
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::ops::Deref;
+#[cfg(unix)]
+use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
+use std::path::{Path, PathBuf};
+#[cfg(unix)]
+use std::ptr::NonNull;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+pub const PACBIN_VERSION: u16 = 1;
+pub const PACBIN_ALIGNMENT: u32 = 64;
+pub const PACBIN_DEFAULT_CHUNK_SIZE: usize = 1024 * 1024;
+pub const PACBIN_DEFAULT_MODE: u32 = 0o644;
+
+const HEADER_MAGIC: &[u8; 8] = b"PACBIN\0\0";
+const INDEX_MAGIC: &[u8; 8] = b"PACIDX\0\0";
+const FOOTER_MAGIC: &[u8; 8] = b"PACEND\0\0";
+const SUPPORTED_FLAGS: u32 = 0;
+const HEADER_SIZE: usize = 64;
+const INDEX_HEADER_SIZE: usize = 32;
+const INDEX_ENTRY_SIZE: usize = 56;
+const FOOTER_SIZE: usize = 64;
+const INDEX_ALIGNMENT: u64 = 8;
+const TEMPORARY_FILE_ATTEMPTS: u64 = 128;
+
+static NEXT_TEMPORARY_FILE: AtomicU64 = AtomicU64::new(0);
+
+/// Portable payload kinds defined by `pacbin-v1`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u16)]
+pub enum PacbinMemberKind {
+    SymjitApplication = 1,
+    SymbolicaExactState = 2,
+    NativeLibrary = 3,
+    EagerRuntimeMetadata = 4,
+    EagerRuntimeTable = 5,
+    RecurrenceDirectPlan = 7,
+    RecurrenceColorProjectionCertificate = 8,
+    OnTheFlyProcessSeed = 9,
+    ColorContraction = 10,
+}
+
+impl PacbinMemberKind {
+    fn parse(value: u16) -> RusticolResult<Self> {
+        match value {
+            1 => Ok(Self::SymjitApplication),
+            2 => Ok(Self::SymbolicaExactState),
+            3 => Ok(Self::NativeLibrary),
+            4 => Ok(Self::EagerRuntimeMetadata),
+            5 => Ok(Self::EagerRuntimeTable),
+            7 => Ok(Self::RecurrenceDirectPlan),
+            8 => Ok(Self::RecurrenceColorProjectionCertificate),
+            9 => Ok(Self::OnTheFlyProcessSeed),
+            10 => Ok(Self::ColorContraction),
+            _ => Err(compatibility(format!(
+                "unknown pacbin member kind: {value}"
+            ))),
+        }
+    }
+}
+
+/// One bounded source streamed into a `pacbin-v1` member.
+pub enum PacbinWriteSource<'a> {
+    Bytes(&'a [u8]),
+    Path(PathBuf),
+    Reader(&'a mut dyn Read),
+}
+
+/// One normalized member supplied to the deterministic Rust writer.
+pub struct PacbinWriteMember<'a> {
+    logical_path: String,
+    kind: PacbinMemberKind,
+    source: PacbinWriteSource<'a>,
+}
+
+impl<'a> PacbinWriteMember<'a> {
+    pub fn from_bytes(
+        logical_path: &str,
+        kind: PacbinMemberKind,
+        payload: &'a [u8],
+    ) -> RusticolResult<Self> {
+        Self::new(logical_path, kind, PacbinWriteSource::Bytes(payload))
+    }
+
+    pub fn from_path(
+        logical_path: &str,
+        kind: PacbinMemberKind,
+        source: impl Into<PathBuf>,
+    ) -> RusticolResult<Self> {
+        Self::new(logical_path, kind, PacbinWriteSource::Path(source.into()))
+    }
+
+    pub fn from_reader(
+        logical_path: &str,
+        kind: PacbinMemberKind,
+        source: &'a mut dyn Read,
+    ) -> RusticolResult<Self> {
+        Self::new(logical_path, kind, PacbinWriteSource::Reader(source))
+    }
+
+    fn new(
+        logical_path: &str,
+        kind: PacbinMemberKind,
+        source: PacbinWriteSource<'a>,
+    ) -> RusticolResult<Self> {
+        Ok(Self {
+            logical_path: normalize_logical_path(logical_path)?,
+            kind,
+            source,
+        })
+    }
+
+    pub fn logical_path(&self) -> &str {
+        &self.logical_path
+    }
+
+    pub fn kind(&self) -> PacbinMemberKind {
+        self.kind
+    }
+}
+
+/// Validated options for one atomic `pacbin-v1` publication.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct PacbinWriteOptions {
+    chunk_size: usize,
+    mode: u32,
+}
+
+impl PacbinWriteOptions {
+    pub fn new(chunk_size: usize, mode: u32) -> RusticolResult<Self> {
+        if chunk_size == 0 {
+            return Err(RusticolError::invalid_argument(
+                "pacbin chunk size must be a positive integer",
+            ));
+        }
+        if mode > 0o777 {
+            return Err(RusticolError::invalid_argument(
+                "pacbin publication mode must be between 0o000 and 0o777",
+            ));
+        }
+        Ok(Self { chunk_size, mode })
+    }
+
+    pub fn chunk_size(&self) -> usize {
+        self.chunk_size
+    }
+
+    pub fn mode(&self) -> u32 {
+        self.mode
+    }
+}
+
+impl Default for PacbinWriteOptions {
+    fn default() -> Self {
+        Self {
+            chunk_size: PACBIN_DEFAULT_CHUNK_SIZE,
+            mode: PACBIN_DEFAULT_MODE,
+        }
+    }
+}
+
+/// Validated metadata for one member.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PacbinMember {
+    logical_path: String,
+    kind: PacbinMemberKind,
+    offset: u64,
+    length: u64,
+    sha256: [u8; 32],
+}
+
+impl PacbinMember {
+    pub fn logical_path(&self) -> &str {
+        &self.logical_path
+    }
+
+    pub fn kind(&self) -> PacbinMemberKind {
+        self.kind
+    }
+
+    pub fn offset(&self) -> u64 {
+        self.offset
+    }
+
+    pub fn length(&self) -> u64 {
+        self.length
+    }
+
+    pub fn sha256(&self) -> &[u8; 32] {
+        &self.sha256
+    }
+}
+
+/// Validated top-level container metadata.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PacbinIndex {
+    version: u16,
+    index_offset: u64,
+    index_sha256: [u8; 32],
+    file_size: u64,
+    members: Vec<PacbinMember>,
+}
+
+impl PacbinIndex {
+    pub fn version(&self) -> u16 {
+        self.version
+    }
+
+    pub fn index_offset(&self) -> u64 {
+        self.index_offset
+    }
+
+    pub fn index_sha256(&self) -> &[u8; 32] {
+        &self.index_sha256
+    }
+
+    pub fn file_size(&self) -> u64 {
+        self.file_size
+    }
+
+    pub fn members(&self) -> &[PacbinMember] {
+        &self.members
+    }
+}
+
+/// An authenticated, indexed `pacbin-v1` container.
+///
+/// Files are copied into an anonymous read-only mapping on Unix so large
+/// evaluator packs remain outside the Rust heap without retaining a mutable
+/// relationship to the source file. Containers constructed from bytes retain
+/// owned storage.
+#[derive(Debug)]
+pub struct PacbinReader {
+    bytes: PacbinStorage,
+    index: PacbinIndex,
+}
+
+#[derive(Debug)]
+enum PacbinStorage {
+    Owned(Box<[u8]>),
+    #[cfg(unix)]
+    Mapped(ReadOnlyMmap),
+}
+
+impl AsRef<[u8]> for PacbinStorage {
+    fn as_ref(&self) -> &[u8] {
+        match self {
+            Self::Owned(bytes) => bytes,
+            #[cfg(unix)]
+            Self::Mapped(bytes) => bytes,
+        }
+    }
+}
+
+#[cfg(unix)]
+struct ReadOnlyMmap {
+    pointer: NonNull<u8>,
+    length: usize,
+}
+
+#[cfg(unix)]
+impl std::fmt::Debug for ReadOnlyMmap {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("ReadOnlyMmap")
+            .field("length", &self.length)
+            .finish_non_exhaustive()
+    }
+}
+
+#[cfg(unix)]
+impl ReadOnlyMmap {
+    fn snapshot(source: &mut File, path: &Path, length: usize) -> RusticolResult<(Self, [u8; 32])> {
+        if length == 0 {
+            return Err(RusticolError::artifact(format!(
+                "cannot map empty pacbin container {}",
+                path.display()
+            )));
+        }
+        // Anonymous memory is the only portable Unix backing store that never
+        // exposes a writable pathname or file descriptor. A temporary file,
+        // even after unlink, can still be mutated through a descriptor opened
+        // during its named lifetime. Copying directly into anonymous pages
+        // also ensures that the digest and parser consume one retained image.
+        let raw_pointer = unsafe {
+            libc::mmap(
+                std::ptr::null_mut(),
+                length,
+                libc::PROT_READ | libc::PROT_WRITE,
+                libc::MAP_PRIVATE | libc::MAP_ANON,
+                -1,
+                0,
+            )
+        };
+        if raw_pointer == libc::MAP_FAILED {
+            return Err(RusticolError::artifact(format!(
+                "could not allocate the {length}-byte anonymous immutable snapshot required for \
+                 pacbin container {}: {}. Ensure the process has at least {length} bytes of \
+                 available virtual memory and RAM or swap",
+                path.display(),
+                std::io::Error::last_os_error()
+            )));
+        }
+        let Some(pointer) = NonNull::new(raw_pointer.cast::<u8>()) else {
+            // SAFETY: this pointer/length pair came from mmap above and has
+            // not otherwise been retained.
+            unsafe {
+                libc::munmap(raw_pointer, length);
+            }
+            return Err(RusticolError::artifact(format!(
+                "anonymous memory-mapping returned a null pointer for pacbin container {}",
+                path.display()
+            )));
+        };
+        let snapshot = Self { pointer, length };
+
+        source.seek(SeekFrom::Start(0)).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not rewind pacbin container {}: {error}",
+                path.display()
+            ))
+        })?;
+        // SAFETY: `snapshot` exclusively owns a writable anonymous mapping of
+        // exactly `length` bytes until `mprotect` below.
+        let destination =
+            unsafe { std::slice::from_raw_parts_mut(snapshot.pointer.as_ptr(), snapshot.length) };
+        for chunk in destination.chunks_mut(PACBIN_DEFAULT_CHUNK_SIZE) {
+            source.read_exact(chunk).map_err(|error| {
+                RusticolError::artifact(format!(
+                    "could not snapshot pacbin container {} into anonymous memory: {error}",
+                    path.display()
+                ))
+            })?;
+        }
+        let mut trailing = [0_u8; 1];
+        let trailing_count = source.read(&mut trailing).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not finish snapshotting pacbin container {}: {error}",
+                path.display()
+            ))
+        })?;
+        if trailing_count != 0 {
+            return Err(RusticolError::artifact(format!(
+                "pacbin container {} grew while being snapshotted",
+                path.display()
+            )));
+        }
+
+        // Seal before authentication. No retained mutable reference exists,
+        // and mprotect removes write permission from the mapping itself. The
+        // SHA-256 digest and all parsing therefore address the same immutable
+        // bytes.
+        let protection_result =
+            unsafe { libc::mprotect(snapshot.pointer.as_ptr().cast(), length, libc::PROT_READ) };
+        if protection_result != 0 {
+            return Err(RusticolError::artifact(format!(
+                "could not make the anonymous pacbin snapshot for {} read-only: {}",
+                path.display(),
+                std::io::Error::last_os_error()
+            )));
+        }
+        let digest = Sha256::digest(&*snapshot).into();
+        Ok((snapshot, digest))
+    }
+}
+
+#[cfg(unix)]
+impl Deref for ReadOnlyMmap {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        // SAFETY: mmap established a read-only mapping of exactly `length`
+        // bytes and this object keeps it alive until Drop.
+        unsafe { std::slice::from_raw_parts(self.pointer.as_ptr(), self.length) }
+    }
+}
+
+#[cfg(unix)]
+unsafe impl Send for ReadOnlyMmap {}
+#[cfg(unix)]
+unsafe impl Sync for ReadOnlyMmap {}
+
+#[cfg(unix)]
+impl Drop for ReadOnlyMmap {
+    fn drop(&mut self) {
+        // SAFETY: this pointer/length pair came from the successful mmap in
+        // `map` and is unmapped exactly once here.
+        unsafe {
+            libc::munmap(self.pointer.as_ptr().cast(), self.length);
+        }
+    }
+}
+
+impl PacbinReader {
+    /// Open and fully authenticate one container file.
+    pub fn open(path: impl AsRef<Path>) -> RusticolResult<Self> {
+        Self::open_with_payload_verification(path, true)
+    }
+
+    /// Open and authenticate the exact mapped bytes against an enclosing
+    /// manifest digest. Hashing and parsing share one storage object, so a
+    /// path replacement cannot substitute a different container between them.
+    #[cfg(test)]
+    pub(crate) fn open_with_sha256(
+        path: impl AsRef<Path>,
+        expected_sha256: &[u8; 32],
+    ) -> RusticolResult<Self> {
+        let path = path.as_ref();
+        let file = File::open(path).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not open pacbin container {}: {error}",
+                path.display()
+            ))
+        })?;
+        Self::open_file_with_sha256(file, path, expected_sha256)
+    }
+
+    /// Authenticate and snapshot an already-open, metadata-checked container.
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    pub(crate) fn open_file_with_sha256(
+        file: File,
+        display_path: &Path,
+        expected_sha256: &[u8; 32],
+    ) -> RusticolResult<Self> {
+        let (storage, actual) = Self::open_file_storage(file, display_path)?;
+        if &actual != expected_sha256 {
+            return Err(RusticolError::integrity(format!(
+                "pacbin container {} payload digest mismatch",
+                display_path.display()
+            )));
+        }
+        Self::from_storage(storage, false)
+    }
+
+    fn open_with_payload_verification(
+        path: impl AsRef<Path>,
+        verify_payloads: bool,
+    ) -> RusticolResult<Self> {
+        let path = path.as_ref();
+        let file = File::open(path).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not open pacbin container {}: {error}",
+                path.display()
+            ))
+        })?;
+        let (storage, _) = Self::open_file_storage(file, path)?;
+        Self::from_storage(storage, verify_payloads)
+    }
+
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    fn open_file_storage(mut file: File, path: &Path) -> RusticolResult<(PacbinStorage, [u8; 32])> {
+        let expected_length = file
+            .metadata()
+            .map_err(|error| {
+                RusticolError::artifact(format!(
+                    "could not inspect pacbin container {}: {error}",
+                    path.display()
+                ))
+            })?
+            .len();
+        let capacity = usize::try_from(expected_length).map_err(|_| {
+            RusticolError::artifact(format!(
+                "pacbin container {} is too large for this platform",
+                path.display()
+            ))
+        })?;
+        #[cfg(unix)]
+        let (storage, digest) = ReadOnlyMmap::snapshot(&mut file, path, capacity)?;
+        #[cfg(unix)]
+        let storage = PacbinStorage::Mapped(storage);
+        #[cfg(not(unix))]
+        let (storage, digest) = {
+            let read_limit = expected_length.checked_add(1).ok_or_else(|| {
+                RusticolError::artifact(format!(
+                    "pacbin container {} exceeds the supported file size",
+                    path.display()
+                ))
+            })?;
+            let mut bytes = Vec::new();
+            bytes.try_reserve_exact(capacity).map_err(|error| {
+                RusticolError::artifact(format!(
+                    "could not allocate {capacity} bytes for pacbin container {}: {error}",
+                    path.display()
+                ))
+            })?;
+            file.take(read_limit)
+                .read_to_end(&mut bytes)
+                .map_err(|error| {
+                    RusticolError::artifact(format!(
+                        "could not read pacbin container {}: {error}",
+                        path.display()
+                    ))
+                })?;
+            if bytes.len() != capacity {
+                return Err(RusticolError::artifact(format!(
+                    "pacbin container {} changed while being read: expected {capacity} bytes, read {}",
+                    path.display(),
+                    bytes.len()
+                )));
+            }
+            let digest = Sha256::digest(&bytes).into();
+            (PacbinStorage::Owned(bytes.into_boxed_slice()), digest)
+        };
+        Ok((storage, digest))
+    }
+
+    /// Own and fully authenticate already-read container bytes.
+    pub fn from_bytes(bytes: Vec<u8>) -> RusticolResult<Self> {
+        Self::from_storage(PacbinStorage::Owned(bytes.into_boxed_slice()), true)
+    }
+
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    fn from_storage(bytes: PacbinStorage, verify_payloads: bool) -> RusticolResult<Self> {
+        let index = parse_and_validate(bytes.as_ref(), verify_payloads)?;
+        Ok(Self { bytes, index })
+    }
+
+    pub fn index(&self) -> &PacbinIndex {
+        &self.index
+    }
+
+    pub fn members(&self) -> &[PacbinMember] {
+        self.index.members()
+    }
+
+    /// Resolve a member by normalized logical path in logarithmic time.
+    pub fn member(&self, logical_path: &str) -> RusticolResult<&PacbinMember> {
+        let normalized = normalize_logical_path(logical_path)?;
+        self.index
+            .members
+            .binary_search_by(|member| member.logical_path.as_bytes().cmp(normalized.as_bytes()))
+            .map(|index| &self.index.members[index])
+            .map_err(|_| {
+                RusticolError::invalid_argument(format!("unknown pacbin member: {normalized}"))
+            })
+    }
+
+    /// Borrow a complete authenticated member without unpacking it.
+    pub fn member_bytes(&self, logical_path: &str) -> RusticolResult<&[u8]> {
+        let member = self.member(logical_path)?;
+        member_slice(self.bytes.as_ref(), member.offset, member.length)
+    }
+
+    /// Borrow a bounded range relative to one authenticated member.
+    pub fn member_range(
+        &self,
+        logical_path: &str,
+        offset: u64,
+        length: u64,
+    ) -> RusticolResult<&[u8]> {
+        let member = self.member(logical_path)?;
+        if offset > member.length || length > member.length - offset {
+            return Err(RusticolError::invalid_argument(
+                "member read exceeds indexed payload bounds",
+            ));
+        }
+        let absolute_offset = member
+            .offset
+            .checked_add(offset)
+            .ok_or_else(|| RusticolError::invalid_argument("member read offset exceeds u64"))?;
+        member_slice(self.bytes.as_ref(), absolute_offset, length)
+    }
+
+    /// Re-authenticate all member payloads held by this reader.
+    pub fn verify_payloads(&self) -> RusticolResult<()> {
+        verify_payload_digests(self.bytes.as_ref(), &self.index.members)
+    }
+
+    /// Return the total owned container size.
+    pub fn container_size(&self) -> usize {
+        self.bytes.as_ref().len()
+    }
+}
+
+/// Atomically stream and publish one deterministic `pacbin-v1` container.
+///
+/// Member metadata is retained in memory, while payload bytes are copied and
+/// hashed through one bounded buffer. The destination remains untouched until
+/// a complete temporary file has been flushed and synced.
+pub fn write_pacbin_atomic<'a>(
+    destination: impl AsRef<Path>,
+    members: impl IntoIterator<Item = PacbinWriteMember<'a>>,
+    options: PacbinWriteOptions,
+) -> RusticolResult<PacbinIndex> {
+    let destination = destination.as_ref();
+    let parent = destination
+        .parent()
+        .filter(|path| !path.as_os_str().is_empty())
+        .unwrap_or_else(|| Path::new("."));
+    if !parent.is_dir() {
+        return Err(RusticolError::invalid_argument(format!(
+            "pacbin destination directory does not exist: {}",
+            parent.display()
+        )));
+    }
+    let mut members = prepare_write_members(members)?;
+    let expected_index_size = validate_write_index_bounds(&members)?;
+    let (temporary_path, mut temporary_file) = create_temporary_file(destination, parent)?;
+
+    let result = (|| {
+        let index = write_pacbin_file(
+            &mut temporary_file,
+            &mut members,
+            options.chunk_size,
+            expected_index_size,
+        )?;
+        #[cfg(unix)]
+        temporary_file
+            .set_permissions(std::fs::Permissions::from_mode(options.mode))
+            .map_err(|error| artifact_io_error("set permissions on", &temporary_path, error))?;
+        temporary_file
+            .flush()
+            .map_err(|error| artifact_io_error("flush", &temporary_path, error))?;
+        temporary_file
+            .sync_all()
+            .map_err(|error| artifact_io_error("sync", &temporary_path, error))?;
+        drop(temporary_file);
+        std::fs::rename(&temporary_path, destination).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not atomically publish pacbin container {}: {error}",
+                destination.display()
+            ))
+        })?;
+        sync_directory_best_effort(parent);
+        Ok(index)
+    })();
+
+    if result.is_err() {
+        let _ = std::fs::remove_file(&temporary_path);
+    }
+    result
+}
+
+fn prepare_write_members<'a>(
+    members: impl IntoIterator<Item = PacbinWriteMember<'a>>,
+) -> RusticolResult<Vec<PacbinWriteMember<'a>>> {
+    let mut members: Vec<_> = members.into_iter().collect();
+    members.sort_by(|left, right| {
+        left.logical_path
+            .as_bytes()
+            .cmp(right.logical_path.as_bytes())
+    });
+    let mut seen_paths = BTreeSet::new();
+    let mut seen_folded = BTreeSet::new();
+    for member in &members {
+        if !seen_paths.insert(member.logical_path.clone()) {
+            return Err(RusticolError::invalid_argument(format!(
+                "duplicate pacbin member path: {}",
+                member.logical_path
+            )));
+        }
+        let folded = member.logical_path.to_ascii_lowercase();
+        if !seen_folded.insert(folded) {
+            return Err(RusticolError::invalid_argument(format!(
+                "case-colliding pacbin member path: {}",
+                member.logical_path
+            )));
+        }
+    }
+    Ok(members)
+}
+
+fn validate_write_index_bounds(members: &[PacbinWriteMember<'_>]) -> RusticolResult<u64> {
+    u64::try_from(members.len())
+        .map_err(|_| RusticolError::invalid_argument("pacbin member count exceeds u64"))?;
+    let mut index_size = INDEX_HEADER_SIZE as u64;
+    for member in members {
+        let path_length = u64::try_from(member.logical_path.len()).map_err(|_| {
+            RusticolError::invalid_argument("pacbin logical path exceeds u64 byte length")
+        })?;
+        if path_length > u64::from(u32::MAX) {
+            return Err(RusticolError::invalid_argument(format!(
+                "pacbin member path exceeds u32 byte length: {path_length} bytes"
+            )));
+        }
+        let record_size = (INDEX_ENTRY_SIZE as u64)
+            .checked_add(path_length)
+            .and_then(|value| value.checked_add(padding_length(value, INDEX_ALIGNMENT)))
+            .ok_or_else(|| RusticolError::invalid_argument("pacbin index size exceeds u64"))?;
+        index_size = index_size
+            .checked_add(record_size)
+            .ok_or_else(|| RusticolError::invalid_argument("pacbin index size exceeds u64"))?;
+    }
+    Ok(index_size)
+}
+
+pub(crate) fn create_temporary_file(
+    destination: &Path,
+    parent: &Path,
+) -> RusticolResult<(PathBuf, File)> {
+    let file_name = destination
+        .file_name()
+        .ok_or_else(|| RusticolError::invalid_argument("pacbin destination must name a file"))?;
+    for _ in 0..TEMPORARY_FILE_ATTEMPTS {
+        let sequence = NEXT_TEMPORARY_FILE.fetch_add(1, Ordering::Relaxed);
+        let mut temporary_name = OsString::from(".");
+        temporary_name.push(file_name);
+        temporary_name.push(format!(".{}.{}.tmp", std::process::id(), sequence));
+        let temporary_path = parent.join(temporary_name);
+        let mut options = OpenOptions::new();
+        options.read(true).write(true).create_new(true);
+        #[cfg(unix)]
+        options.mode(0o600);
+        match options.open(&temporary_path) {
+            Ok(file) => return Ok((temporary_path, file)),
+            Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => continue,
+            Err(error) => {
+                return Err(artifact_io_error(
+                    "create temporary pacbin container",
+                    &temporary_path,
+                    error,
+                ));
+            }
+        }
+    }
+    Err(RusticolError::artifact(format!(
+        "could not allocate a unique temporary pacbin path for {}",
+        destination.display()
+    )))
+}
+
+fn write_pacbin_file(
+    destination: &mut File,
+    members: &mut [PacbinWriteMember<'_>],
+    chunk_size: usize,
+    expected_index_size: u64,
+) -> RusticolResult<PacbinIndex> {
+    destination.seek(SeekFrom::Start(0)).map_err(|error| {
+        RusticolError::artifact(format!("could not seek pacbin output: {error}"))
+    })?;
+    destination.set_len(0).map_err(|error| {
+        RusticolError::artifact(format!("could not truncate pacbin output: {error}"))
+    })?;
+    write_all(destination, &[0; HEADER_SIZE], "pacbin header")?;
+
+    let mut buffer = Vec::new();
+    buffer.try_reserve_exact(chunk_size).map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not allocate {chunk_size} byte pacbin streaming buffer: {error}"
+        ))
+    })?;
+    buffer.resize(chunk_size, 0);
+
+    let mut indexed_members = Vec::new();
+    indexed_members
+        .try_reserve_exact(members.len())
+        .map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not allocate pacbin index for {} members: {error}",
+                members.len()
+            ))
+        })?;
+    for member in members {
+        write_alignment_padding(destination, u64::from(PACBIN_ALIGNMENT))?;
+        let offset = stream_position(destination, "pacbin member offset")?;
+        let (length, sha256) = match &mut member.source {
+            PacbinWriteSource::Bytes(payload) => {
+                let mut source = std::io::Cursor::new(*payload);
+                stream_member(&mut source, destination, &mut buffer, &member.logical_path)?
+            }
+            PacbinWriteSource::Path(path) => {
+                if !path.is_file() {
+                    return Err(RusticolError::invalid_argument(format!(
+                        "pacbin member source is not a file: {}",
+                        path.display()
+                    )));
+                }
+                let mut source = File::open(&*path)
+                    .map_err(|error| artifact_io_error("open pacbin member source", path, error))?;
+                stream_member(&mut source, destination, &mut buffer, &member.logical_path)?
+            }
+            PacbinWriteSource::Reader(source) => stream_member(
+                &mut **source,
+                destination,
+                &mut buffer,
+                &member.logical_path,
+            )?,
+        };
+        indexed_members.push(PacbinMember {
+            logical_path: member.logical_path.clone(),
+            kind: member.kind,
+            offset,
+            length,
+            sha256,
+        });
+    }
+
+    write_alignment_padding(destination, u64::from(PACBIN_ALIGNMENT))?;
+    let index_offset = stream_position(destination, "pacbin index offset")?;
+    let member_count = u64::try_from(indexed_members.len())
+        .map_err(|_| RusticolError::artifact("pacbin member count exceeds u64"))?;
+    let mut index_digest = Sha256::new();
+    let mut index_header = [0_u8; INDEX_HEADER_SIZE];
+    index_header[0..8].copy_from_slice(INDEX_MAGIC);
+    encode_u16(&mut index_header, 8, PACBIN_VERSION);
+    encode_u16(&mut index_header, 10, INDEX_HEADER_SIZE as u16);
+    encode_u32(&mut index_header, 12, SUPPORTED_FLAGS);
+    encode_u64(&mut index_header, 16, member_count);
+    write_hashed(
+        destination,
+        &mut index_digest,
+        &index_header,
+        "pacbin index",
+    )?;
+
+    for member in &indexed_members {
+        let path_bytes = member.logical_path.as_bytes();
+        let path_length = u32::try_from(path_bytes.len())
+            .map_err(|_| RusticolError::artifact("pacbin logical path exceeds u32 byte length"))?;
+        let mut entry = [0_u8; INDEX_ENTRY_SIZE];
+        encode_u32(&mut entry, 0, path_length);
+        encode_u16(&mut entry, 4, member.kind as u16);
+        encode_u16(&mut entry, 6, SUPPORTED_FLAGS as u16);
+        encode_u64(&mut entry, 8, member.offset);
+        encode_u64(&mut entry, 16, member.length);
+        entry[24..56].copy_from_slice(&member.sha256);
+        write_hashed(destination, &mut index_digest, &entry, "pacbin index")?;
+        write_hashed(destination, &mut index_digest, path_bytes, "pacbin index")?;
+        let record_length = (INDEX_ENTRY_SIZE as u64) + u64::from(path_length);
+        let padding = padding_length(record_length, INDEX_ALIGNMENT);
+        if padding != 0 {
+            let zeros = [0_u8; INDEX_ALIGNMENT as usize];
+            let padding = usize::try_from(padding)
+                .expect("pacbin index padding is smaller than INDEX_ALIGNMENT");
+            write_hashed(
+                destination,
+                &mut index_digest,
+                &zeros[..padding],
+                "pacbin index",
+            )?;
+        }
+    }
+    let actual_index_size = stream_position(destination, "pacbin index end")?
+        .checked_sub(index_offset)
+        .ok_or_else(|| RusticolError::artifact("pacbin index position underflow"))?;
+    if actual_index_size != expected_index_size {
+        return Err(RusticolError::integrity(
+            "pacbin index size disagrees with preflight",
+        ));
+    }
+    let index_sha256: [u8; 32] = index_digest.finalize().into();
+
+    let mut footer = [0_u8; FOOTER_SIZE];
+    footer[0..8].copy_from_slice(FOOTER_MAGIC);
+    encode_u16(&mut footer, 8, PACBIN_VERSION);
+    encode_u16(&mut footer, 10, FOOTER_SIZE as u16);
+    encode_u32(&mut footer, 12, SUPPORTED_FLAGS);
+    encode_u64(&mut footer, 16, index_offset);
+    encode_u64(&mut footer, 24, member_count);
+    footer[32..64].copy_from_slice(&index_sha256);
+    write_all(destination, &footer, "pacbin footer")?;
+    let file_size = stream_position(destination, "pacbin file size")?;
+
+    let mut header = [0_u8; HEADER_SIZE];
+    header[0..8].copy_from_slice(HEADER_MAGIC);
+    encode_u16(&mut header, 8, PACBIN_VERSION);
+    encode_u16(&mut header, 10, HEADER_SIZE as u16);
+    encode_u32(&mut header, 12, SUPPORTED_FLAGS);
+    encode_u32(&mut header, 16, PACBIN_ALIGNMENT);
+    encode_u64(&mut header, 24, index_offset);
+    encode_u64(&mut header, 32, member_count);
+    destination.seek(SeekFrom::Start(0)).map_err(|error| {
+        RusticolError::artifact(format!("could not seek pacbin output: {error}"))
+    })?;
+    write_all(destination, &header, "pacbin header")?;
+    destination
+        .seek(SeekFrom::Start(file_size))
+        .map_err(|error| {
+            RusticolError::artifact(format!("could not seek pacbin output: {error}"))
+        })?;
+    destination.set_len(file_size).map_err(|error| {
+        RusticolError::artifact(format!("could not truncate pacbin output: {error}"))
+    })?;
+
+    Ok(PacbinIndex {
+        version: PACBIN_VERSION,
+        index_offset,
+        index_sha256,
+        file_size,
+        members: indexed_members,
+    })
+}
+
+fn stream_member<R: Read + ?Sized>(
+    source: &mut R,
+    destination: &mut File,
+    buffer: &mut [u8],
+    logical_path: &str,
+) -> RusticolResult<(u64, [u8; 32])> {
+    let mut digest = Sha256::new();
+    let mut length = 0_u64;
+    loop {
+        let read = source.read(buffer).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not read pacbin member {logical_path}: {error}"
+            ))
+        })?;
+        if read == 0 {
+            break;
+        }
+        length = length
+            .checked_add(u64::try_from(read).expect("read byte count fits u64"))
+            .ok_or_else(|| RusticolError::artifact("pacbin member length exceeds u64"))?;
+        digest.update(&buffer[..read]);
+        write_all(destination, &buffer[..read], "pacbin member payload")?;
+    }
+    Ok((length, digest.finalize().into()))
+}
+
+fn write_alignment_padding(destination: &mut File, alignment: u64) -> RusticolResult<()> {
+    let position = stream_position(destination, "pacbin output position")?;
+    let padding = padding_length(position, alignment);
+    if padding != 0 {
+        let zeros = [0_u8; PACBIN_ALIGNMENT as usize];
+        let padding = usize::try_from(padding)
+            .expect("pacbin payload padding is smaller than PACBIN_ALIGNMENT");
+        write_all(destination, &zeros[..padding], "pacbin payload padding")?;
+    }
+    Ok(())
+}
+
+fn write_hashed(
+    destination: &mut File,
+    digest: &mut Sha256,
+    payload: &[u8],
+    label: &str,
+) -> RusticolResult<()> {
+    write_all(destination, payload, label)?;
+    digest.update(payload);
+    Ok(())
+}
+
+fn write_all(destination: &mut File, payload: &[u8], label: &str) -> RusticolResult<()> {
+    destination.write_all(payload).map_err(|error| {
+        RusticolError::artifact(format!("short write while writing {label}: {error}"))
+    })
+}
+
+fn stream_position(destination: &mut File, label: &str) -> RusticolResult<u64> {
+    destination
+        .stream_position()
+        .map_err(|error| RusticolError::artifact(format!("could not read {label}: {error}")))
+}
+
+fn encode_u16(bytes: &mut [u8], offset: usize, value: u16) {
+    bytes[offset..offset + 2].copy_from_slice(&value.to_le_bytes());
+}
+
+fn encode_u32(bytes: &mut [u8], offset: usize, value: u32) {
+    bytes[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
+}
+
+fn encode_u64(bytes: &mut [u8], offset: usize, value: u64) {
+    bytes[offset..offset + 8].copy_from_slice(&value.to_le_bytes());
+}
+
+fn artifact_io_error(action: &str, path: &Path, error: std::io::Error) -> RusticolError {
+    RusticolError::artifact(format!("could not {action} {}: {error}", path.display()))
+}
+
+#[cfg(unix)]
+fn sync_directory_best_effort(path: &Path) {
+    if let Ok(directory) = File::open(path) {
+        let _ = directory.sync_all();
+    }
+}
+
+#[cfg(not(unix))]
+fn sync_directory_best_effort(_path: &Path) {}
+
+/// Normalize a portable ASCII member path using the Python codec's POSIX rules.
+///
+/// Generated evaluator paths are ASCII. Rejecting non-ASCII input is
+/// intentional: without weakening Python's NFC and full Unicode case-folding
+/// collision guarantees, the runtime accepts the complete generated-path
+/// domain and fails closed for paths outside it.
+pub fn normalize_logical_path(value: &str) -> RusticolResult<String> {
+    normalize_logical_path_impl(value).map_err(RusticolError::invalid_argument)
+}
+
+fn normalize_logical_path_impl(value: &str) -> Result<String, String> {
+    if value.is_empty() || value.contains('\0') {
+        return Err("pacbin logical path must be non-empty and contain no NUL".to_string());
+    }
+    if !value.is_ascii() {
+        return Err(
+            "pacbin logical path must use the portable ASCII evaluator-path subset".to_string(),
+        );
+    }
+    if value.contains('\\') {
+        return Err("pacbin logical path must use POSIX '/' separators".to_string());
+    }
+    if value.starts_with('/') {
+        return Err("pacbin logical path must be relative".to_string());
+    }
+
+    let mut parts = Vec::new();
+    for part in value.split('/') {
+        if part.is_empty() || part == "." {
+            continue;
+        }
+        if part == ".." {
+            return Err("pacbin logical path must not contain '..'".to_string());
+        }
+        parts.push(part);
+    }
+    if parts.is_empty() {
+        return Err("pacbin logical path must name a member".to_string());
+    }
+    Ok(parts.join("/"))
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn parse_and_validate(bytes: &[u8], verify_payloads: bool) -> RusticolResult<PacbinIndex> {
+    let minimum_size = HEADER_SIZE
+        .checked_add(INDEX_HEADER_SIZE)
+        .and_then(|value| value.checked_add(FOOTER_SIZE))
+        .expect("pacbin fixed structure sizes fit usize");
+    if bytes.len() < minimum_size {
+        return Err(integrity("truncated pacbin container"));
+    }
+    let file_size =
+        u64::try_from(bytes.len()).map_err(|_| integrity("pacbin file size exceeds u64"))?;
+
+    let header = checked_slice(bytes, 0, HEADER_SIZE, "pacbin header")?;
+    if &header[0..8] != HEADER_MAGIC {
+        return Err(integrity("invalid pacbin header magic"));
+    }
+    let version = u16_at(header, 8, "pacbin header version")?;
+    let header_size = u16_at(header, 10, "pacbin header size")?;
+    let header_flags = u32_at(header, 12, "pacbin header flags")?;
+    validate_contract("header", version, header_size, HEADER_SIZE, header_flags)?;
+    let alignment = u32_at(header, 16, "pacbin payload alignment")?;
+    if alignment != PACBIN_ALIGNMENT {
+        return Err(compatibility(format!(
+            "unsupported pacbin payload alignment: {alignment}"
+        )));
+    }
+    if u32_at(header, 20, "pacbin header reserved field")? != 0
+        || header[40..64].iter().any(|value| *value != 0)
+    {
+        return Err(integrity("pacbin header reserved fields must be zero"));
+    }
+    let index_offset = u64_at(header, 24, "pacbin index offset")?;
+    let member_count = u64_at(header, 32, "pacbin member count")?;
+    if index_offset % u64::from(PACBIN_ALIGNMENT) != 0 {
+        return Err(integrity("pacbin index offset is not payload-aligned"));
+    }
+
+    let footer_offset = bytes
+        .len()
+        .checked_sub(FOOTER_SIZE)
+        .ok_or_else(|| integrity("truncated pacbin footer"))?;
+    let footer_offset_u64 =
+        u64::try_from(footer_offset).map_err(|_| integrity("pacbin footer offset exceeds u64"))?;
+    if index_offset < HEADER_SIZE as u64 || index_offset >= footer_offset_u64 {
+        return Err(integrity("pacbin index offset is out of bounds"));
+    }
+
+    let footer = checked_slice(bytes, footer_offset, FOOTER_SIZE, "pacbin footer")?;
+    if &footer[0..8] != FOOTER_MAGIC {
+        return Err(integrity("invalid pacbin footer magic"));
+    }
+    let footer_version = u16_at(footer, 8, "pacbin footer version")?;
+    let footer_size = u16_at(footer, 10, "pacbin footer size")?;
+    let footer_flags = u32_at(footer, 12, "pacbin footer flags")?;
+    validate_contract(
+        "footer",
+        footer_version,
+        footer_size,
+        FOOTER_SIZE,
+        footer_flags,
+    )?;
+    if u64_at(footer, 16, "pacbin footer index offset")? != index_offset {
+        return Err(integrity(
+            "pacbin footer index offset disagrees with header",
+        ));
+    }
+    if u64_at(footer, 24, "pacbin footer member count")? != member_count {
+        return Err(integrity(
+            "pacbin footer member count disagrees with header",
+        ));
+    }
+    let expected_index_digest: [u8; 32] = footer[32..64]
+        .try_into()
+        .map_err(|_| integrity("truncated pacbin footer digest"))?;
+
+    let index_offset_usize = usize::try_from(index_offset)
+        .map_err(|_| integrity("pacbin index offset exceeds platform bounds"))?;
+    let available_index_bytes = footer_offset_u64 - index_offset;
+    validate_index_bounds(member_count, available_index_bytes)?;
+    let index_bytes = checked_slice(
+        bytes,
+        index_offset_usize,
+        usize::try_from(available_index_bytes)
+            .map_err(|_| integrity("pacbin index size exceeds platform bounds"))?,
+        "pacbin index",
+    )?;
+    let actual_index_digest: [u8; 32] = Sha256::digest(index_bytes).into();
+
+    let index_header = checked_slice(index_bytes, 0, INDEX_HEADER_SIZE, "pacbin index header")?;
+    if &index_header[0..8] != INDEX_MAGIC {
+        return Err(integrity("invalid pacbin index magic"));
+    }
+    let index_version = u16_at(index_header, 8, "pacbin index version")?;
+    let index_header_size = u16_at(index_header, 10, "pacbin index size")?;
+    let index_flags = u32_at(index_header, 12, "pacbin index flags")?;
+    validate_contract(
+        "index",
+        index_version,
+        index_header_size,
+        INDEX_HEADER_SIZE,
+        index_flags,
+    )?;
+    if u64_at(index_header, 24, "pacbin index reserved field")? != 0 {
+        return Err(integrity("pacbin index reserved field must be zero"));
+    }
+    if u64_at(index_header, 16, "pacbin index member count")? != member_count {
+        return Err(integrity("pacbin index member count disagrees with header"));
+    }
+
+    let member_capacity = usize::try_from(member_count)
+        .map_err(|_| integrity("pacbin member count exceeds platform bounds"))?;
+    let mut members = Vec::new();
+    members
+        .try_reserve_exact(member_capacity)
+        .map_err(|error| {
+            integrity(format!(
+                "could not allocate pacbin index for {member_count} members: {error}"
+            ))
+        })?;
+    let mut seen_paths = BTreeSet::new();
+    let mut seen_folded_paths = BTreeSet::new();
+    let mut previous_path_bytes: Option<Vec<u8>> = None;
+    let mut cursor = INDEX_HEADER_SIZE;
+    for _ in 0..member_count {
+        let entry = checked_slice(index_bytes, cursor, INDEX_ENTRY_SIZE, "pacbin index entry")?;
+        let path_length = u32_at(entry, 0, "pacbin member path length")?;
+        let kind = PacbinMemberKind::parse(u16_at(entry, 4, "pacbin member kind")?)?;
+        let entry_flags = u16_at(entry, 6, "pacbin member flags")?;
+        if entry_flags != SUPPORTED_FLAGS as u16 {
+            return Err(compatibility(format!(
+                "unknown pacbin member flags: {entry_flags}"
+            )));
+        }
+        let offset = u64_at(entry, 8, "pacbin member offset")?;
+        let length = u64_at(entry, 16, "pacbin member length")?;
+        let sha256: [u8; 32] = entry[24..56]
+            .try_into()
+            .map_err(|_| integrity("truncated pacbin member digest"))?;
+        cursor = cursor
+            .checked_add(INDEX_ENTRY_SIZE)
+            .ok_or_else(|| integrity("pacbin index cursor overflow"))?;
+        let path_length_usize = usize::try_from(path_length)
+            .map_err(|_| integrity("pacbin member path length exceeds platform bounds"))?;
+        let path_bytes =
+            checked_slice(index_bytes, cursor, path_length_usize, "pacbin member path")?;
+        let logical_path = std::str::from_utf8(path_bytes)
+            .map_err(|_| integrity("pacbin member path is not valid UTF-8"))?;
+        let normalized = normalize_logical_path_impl(logical_path).map_err(integrity)?;
+        if normalized != logical_path {
+            return Err(integrity(format!(
+                "pacbin member path is not canonical: {logical_path:?}"
+            )));
+        }
+        let folded = logical_path.to_ascii_lowercase();
+        if !seen_paths.insert(logical_path.to_string()) {
+            return Err(integrity(format!(
+                "duplicate pacbin member path: {logical_path}"
+            )));
+        }
+        if !seen_folded_paths.insert(folded) {
+            return Err(integrity(format!(
+                "case-colliding pacbin member path: {logical_path}"
+            )));
+        }
+        if previous_path_bytes
+            .as_deref()
+            .is_some_and(|previous| path_bytes <= previous)
+        {
+            return Err(integrity("pacbin index paths are not strictly sorted"));
+        }
+        previous_path_bytes = Some(path_bytes.to_vec());
+        cursor = cursor
+            .checked_add(path_length_usize)
+            .ok_or_else(|| integrity("pacbin index cursor overflow"))?;
+        let record_length = (INDEX_ENTRY_SIZE as u64)
+            .checked_add(u64::from(path_length))
+            .ok_or_else(|| integrity("pacbin index record length exceeds u64"))?;
+        let padding = padding_length(record_length, INDEX_ALIGNMENT);
+        let padding_usize = usize::try_from(padding)
+            .map_err(|_| integrity("pacbin index padding exceeds platform bounds"))?;
+        let padding_bytes =
+            checked_slice(index_bytes, cursor, padding_usize, "pacbin index padding")?;
+        if padding_bytes.iter().any(|value| *value != 0) {
+            return Err(integrity("pacbin index padding must be zero"));
+        }
+        cursor = cursor
+            .checked_add(padding_usize)
+            .ok_or_else(|| integrity("pacbin index cursor overflow"))?;
+        members.push(PacbinMember {
+            logical_path: logical_path.to_string(),
+            kind,
+            offset,
+            length,
+            sha256,
+        });
+    }
+    if cursor != index_bytes.len() {
+        return Err(integrity("pacbin index has trailing or missing bytes"));
+    }
+    if actual_index_digest != expected_index_digest {
+        return Err(integrity("pacbin index digest mismatch"));
+    }
+
+    validate_canonical_payload_layout(bytes, &members, index_offset)?;
+    if verify_payloads {
+        verify_payload_digests(bytes, &members)?;
+    }
+    Ok(PacbinIndex {
+        version,
+        index_offset,
+        index_sha256: actual_index_digest,
+        file_size,
+        members,
+    })
+}
+
+fn validate_contract(
+    label: &str,
+    version: u16,
+    encoded_size: u16,
+    expected_size: usize,
+    flags: u32,
+) -> RusticolResult<()> {
+    if version != PACBIN_VERSION {
+        return Err(compatibility(format!(
+            "unsupported pacbin {label} version: {version}"
+        )));
+    }
+    if usize::from(encoded_size) != expected_size {
+        return Err(compatibility(format!(
+            "unsupported pacbin {label} size: {encoded_size}"
+        )));
+    }
+    if flags != SUPPORTED_FLAGS {
+        return Err(compatibility(format!(
+            "unknown pacbin {label} flags: {flags}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_index_bounds(member_count: u64, available_index_bytes: u64) -> RusticolResult<()> {
+    let minimum_record_size = (INDEX_ENTRY_SIZE as u64)
+        .checked_add(INDEX_ALIGNMENT)
+        .expect("pacbin minimum record size fits u64");
+    if member_count > available_index_bytes / minimum_record_size {
+        return Err(integrity("pacbin member count cannot fit in index"));
+    }
+    Ok(())
+}
+
+fn validate_canonical_payload_layout(
+    bytes: &[u8],
+    members: &[PacbinMember],
+    index_offset: u64,
+) -> RusticolResult<()> {
+    let mut expected_offset = HEADER_SIZE as u64;
+    for member in members {
+        member.offset.checked_add(member.length).ok_or_else(|| {
+            integrity(format!(
+                "pacbin member range overflows u64: {}",
+                member.logical_path
+            ))
+        })?;
+        let unaligned_offset = expected_offset;
+        let padding = padding_length(unaligned_offset, u64::from(PACBIN_ALIGNMENT));
+        expected_offset = expected_offset
+            .checked_add(padding)
+            .ok_or_else(|| integrity("pacbin payload alignment exceeds u64"))?;
+        if member.offset < expected_offset {
+            return Err(integrity(format!(
+                "overlapping pacbin member payload: {}",
+                member.logical_path
+            )));
+        }
+        if member.offset > expected_offset {
+            return Err(integrity(format!(
+                "non-canonical pacbin member gap: {}",
+                member.logical_path
+            )));
+        }
+        if member.offset % u64::from(PACBIN_ALIGNMENT) != 0 {
+            return Err(integrity(format!(
+                "unaligned pacbin member payload: {}",
+                member.logical_path
+            )));
+        }
+        let end = member.offset + member.length;
+        if end > index_offset {
+            return Err(integrity(format!(
+                "pacbin member payload is out of bounds: {}",
+                member.logical_path
+            )));
+        }
+        validate_zero_region(bytes, unaligned_offset, padding, "pacbin payload padding")?;
+        expected_offset = end;
+    }
+
+    let trailing_padding = padding_length(expected_offset, u64::from(PACBIN_ALIGNMENT));
+    let canonical_index_offset = expected_offset
+        .checked_add(trailing_padding)
+        .ok_or_else(|| integrity("pacbin payload region exceeds u64"))?;
+    if canonical_index_offset != index_offset {
+        if canonical_index_offset > index_offset {
+            return Err(integrity("pacbin payloads overlap the index"));
+        }
+        return Err(integrity(
+            "pacbin payload region has a non-canonical trailing gap",
+        ));
+    }
+    validate_zero_region(
+        bytes,
+        expected_offset,
+        trailing_padding,
+        "pacbin payload padding",
+    )?;
+    Ok(())
+}
+
+fn verify_payload_digests(bytes: &[u8], members: &[PacbinMember]) -> RusticolResult<()> {
+    for member in members {
+        let payload = member_slice(bytes, member.offset, member.length)?;
+        let digest: [u8; 32] = Sha256::digest(payload).into();
+        if digest != member.sha256 {
+            return Err(integrity(format!(
+                "pacbin member digest mismatch: {}",
+                member.logical_path
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn member_slice(bytes: &[u8], offset: u64, length: u64) -> RusticolResult<&[u8]> {
+    let start = usize::try_from(offset)
+        .map_err(|_| integrity("pacbin member offset exceeds platform bounds"))?;
+    let length = usize::try_from(length)
+        .map_err(|_| integrity("pacbin member length exceeds platform bounds"))?;
+    checked_slice(bytes, start, length, "pacbin member payload")
+}
+
+fn validate_zero_region(bytes: &[u8], offset: u64, length: u64, label: &str) -> RusticolResult<()> {
+    let start = usize::try_from(offset)
+        .map_err(|_| integrity(format!("{label} offset exceeds platform bounds")))?;
+    let length = usize::try_from(length)
+        .map_err(|_| integrity(format!("{label} length exceeds platform bounds")))?;
+    let region = checked_slice(bytes, start, length, label)?;
+    if region.iter().any(|value| *value != 0) {
+        return Err(integrity(format!("{label} must be zero")));
+    }
+    Ok(())
+}
+
+fn checked_slice<'a>(
+    bytes: &'a [u8],
+    offset: usize,
+    length: usize,
+    label: &str,
+) -> RusticolResult<&'a [u8]> {
+    let end = offset
+        .checked_add(length)
+        .ok_or_else(|| integrity(format!("{label} range overflow")))?;
+    bytes
+        .get(offset..end)
+        .ok_or_else(|| integrity(format!("truncated {label}")))
+}
+
+fn u16_at(bytes: &[u8], offset: usize, label: &str) -> RusticolResult<u16> {
+    let value: [u8; 2] = checked_slice(bytes, offset, 2, label)?
+        .try_into()
+        .map_err(|_| integrity(format!("truncated {label}")))?;
+    Ok(u16::from_le_bytes(value))
+}
+
+fn u32_at(bytes: &[u8], offset: usize, label: &str) -> RusticolResult<u32> {
+    let value: [u8; 4] = checked_slice(bytes, offset, 4, label)?
+        .try_into()
+        .map_err(|_| integrity(format!("truncated {label}")))?;
+    Ok(u32::from_le_bytes(value))
+}
+
+fn u64_at(bytes: &[u8], offset: usize, label: &str) -> RusticolResult<u64> {
+    let value: [u8; 8] = checked_slice(bytes, offset, 8, label)?
+        .try_into()
+        .map_err(|_| integrity(format!("truncated {label}")))?;
+    Ok(u64::from_le_bytes(value))
+}
+
+fn padding_length(position: u64, alignment: u64) -> u64 {
+    (alignment - position % alignment) % alignment
+}
+
+fn integrity(message: impl Into<String>) -> RusticolError {
+    RusticolError::integrity(message)
+}
+
+fn compatibility(message: impl Into<String>) -> RusticolError {
+    RusticolError::compatibility(message)
+}
+
+#[cfg(test)]
+#[path = "pacbin_tests.rs"]
+mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/pacbin_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/pacbin_tests.rs
new file mode 100644
index 0000000000..4afba1b5c4
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/pacbin_tests.rs
@@ -0,0 +1,902 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::RusticolErrorKind;
+use sha2::{Digest, Sha256};
+use std::fs;
+use std::io::{self, Read};
+use std::sync::atomic::{AtomicU64, Ordering};
+
+const PYTHON_GOLDEN_HEX: &str = concat!(
+    "50414342494e000001004000000000004000000000000000c000000000000000",
+    "0200000000000000000000000000000000000000000000000000000000000000",
+    "6a69742d76310000000000000000000000000000000000000000000000000000",
+    "0000000000000000000000000000000000000000000000000000000000000000",
+    "65786163742d7374617465000000000000000000000000000000000000000000",
+    "0000000000000000000000000000000000000000000000000000000000000000",
+    "5041434944580000010020000000000002000000000000000000000000000000",
+    "0c0000000100000040000000000000000600000000000000e9a628134c31e4a5",
+    "7771ecd7a1dd51c5c5bc7daca10a2553c83f8af1652d2587612f6a69742e7379",
+    "6d6a6974000000000b0000000200000080000000000000000b00000000000000",
+    "a9f46d72eb6f1c7e5d62e97d3d8e67b80605aeba2df022a8a25b51ca3fc89805",
+    "7a2f65786163742e62696e0000000000504143454e4400000100400000000000",
+    "c0000000000000000200000000000000263b30eb85e5b2a82600201822438767",
+    "c5f66d9eecf2e08a0202383aafe0e3c1",
+);
+
+#[derive(Clone)]
+struct TestMember<'a> {
+    path: &'a str,
+    kind: PacbinMemberKind,
+    payload: &'a [u8],
+}
+
+fn decode_hex(value: &str) -> Vec<u8> {
+    assert_eq!(value.len() % 2, 0);
+    value
+        .as_bytes()
+        .chunks_exact(2)
+        .map(|pair| {
+            let text = std::str::from_utf8(pair).expect("ASCII hex pair");
+            u8::from_str_radix(text, 16).expect("valid hex pair")
+        })
+        .collect()
+}
+
+fn put_u16(bytes: &mut [u8], offset: usize, value: u16) {
+    bytes[offset..offset + 2].copy_from_slice(&value.to_le_bytes());
+}
+
+fn put_u32(bytes: &mut [u8], offset: usize, value: u32) {
+    bytes[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
+}
+
+fn put_u64(bytes: &mut [u8], offset: usize, value: u64) {
+    bytes[offset..offset + 8].copy_from_slice(&value.to_le_bytes());
+}
+
+fn align(bytes: &mut Vec<u8>, alignment: usize) {
+    let padding = (alignment - bytes.len() % alignment) % alignment;
+    bytes.resize(bytes.len() + padding, 0);
+}
+
+fn build_container(members: &[TestMember<'_>]) -> Vec<u8> {
+    let mut bytes = vec![0; HEADER_SIZE];
+    let mut records = Vec::new();
+    for member in members {
+        align(&mut bytes, PACBIN_ALIGNMENT as usize);
+        let offset = bytes.len() as u64;
+        bytes.extend_from_slice(member.payload);
+        records.push((member, offset, Sha256::digest(member.payload)));
+    }
+    align(&mut bytes, PACBIN_ALIGNMENT as usize);
+    let index_offset = bytes.len() as u64;
+    bytes.extend_from_slice(INDEX_MAGIC);
+    bytes.extend_from_slice(&PACBIN_VERSION.to_le_bytes());
+    bytes.extend_from_slice(&(INDEX_HEADER_SIZE as u16).to_le_bytes());
+    bytes.extend_from_slice(&SUPPORTED_FLAGS.to_le_bytes());
+    bytes.extend_from_slice(&(records.len() as u64).to_le_bytes());
+    bytes.extend_from_slice(&0_u64.to_le_bytes());
+    for (member, offset, digest) in records {
+        let path = member.path.as_bytes();
+        bytes.extend_from_slice(&(path.len() as u32).to_le_bytes());
+        bytes.extend_from_slice(&(member.kind as u16).to_le_bytes());
+        bytes.extend_from_slice(&0_u16.to_le_bytes());
+        bytes.extend_from_slice(&offset.to_le_bytes());
+        bytes.extend_from_slice(&(member.payload.len() as u64).to_le_bytes());
+        bytes.extend_from_slice(&digest);
+        bytes.extend_from_slice(path);
+        align(&mut bytes, INDEX_ALIGNMENT as usize);
+    }
+    let index_digest = Sha256::digest(&bytes[index_offset as usize..]);
+    bytes.extend_from_slice(FOOTER_MAGIC);
+    bytes.extend_from_slice(&PACBIN_VERSION.to_le_bytes());
+    bytes.extend_from_slice(&(FOOTER_SIZE as u16).to_le_bytes());
+    bytes.extend_from_slice(&SUPPORTED_FLAGS.to_le_bytes());
+    bytes.extend_from_slice(&index_offset.to_le_bytes());
+    bytes.extend_from_slice(&(members.len() as u64).to_le_bytes());
+    bytes.extend_from_slice(&index_digest);
+
+    bytes[0..8].copy_from_slice(HEADER_MAGIC);
+    put_u16(&mut bytes, 8, PACBIN_VERSION);
+    put_u16(&mut bytes, 10, HEADER_SIZE as u16);
+    put_u32(&mut bytes, 12, SUPPORTED_FLAGS);
+    put_u32(&mut bytes, 16, PACBIN_ALIGNMENT);
+    put_u32(&mut bytes, 20, 0);
+    put_u64(&mut bytes, 24, index_offset);
+    put_u64(&mut bytes, 32, members.len() as u64);
+    bytes
+}
+
+fn index_offset(bytes: &[u8]) -> usize {
+    u64_at(bytes, 24, "test index offset").expect("index offset") as usize
+}
+
+fn footer_offset(bytes: &[u8]) -> usize {
+    bytes.len() - FOOTER_SIZE
+}
+
+fn entry_offsets(bytes: &[u8]) -> Vec<usize> {
+    let index = index_offset(bytes);
+    let footer = footer_offset(bytes);
+    let count = u64_at(bytes, 32, "test member count").expect("member count");
+    let mut cursor = index + INDEX_HEADER_SIZE;
+    let mut offsets = Vec::new();
+    for _ in 0..count {
+        offsets.push(cursor);
+        let path_length = u32_at(bytes, cursor, "test path length").expect("path length");
+        let record = INDEX_ENTRY_SIZE as u64 + u64::from(path_length);
+        cursor += (record + padding_length(record, INDEX_ALIGNMENT)) as usize;
+    }
+    assert!(cursor <= footer);
+    offsets
+}
+
+fn rewrite_index_digest(bytes: &mut [u8]) {
+    let index = index_offset(bytes);
+    let footer = footer_offset(bytes);
+    let digest = Sha256::digest(&bytes[index..footer]);
+    bytes[footer + 32..footer + 64].copy_from_slice(&digest);
+}
+
+fn error(bytes: Vec<u8>) -> (RusticolErrorKind, String) {
+    let error = PacbinReader::from_bytes(bytes).expect_err("container must be rejected");
+    (error.kind(), error.to_string())
+}
+
+fn assert_error(bytes: Vec<u8>, kind: RusticolErrorKind, message: &str) {
+    let (actual_kind, actual_message) = error(bytes);
+    assert_eq!(actual_kind, kind);
+    assert!(
+        actual_message.contains(message),
+        "expected {actual_message:?} to contain {message:?}"
+    );
+}
+
+#[test]
+fn python_golden_round_trips_and_supports_indexed_borrowed_ranges() {
+    let bytes = decode_hex(PYTHON_GOLDEN_HEX);
+    let reader = PacbinReader::from_bytes(bytes).expect("Python pacbin-v1 golden container");
+    assert_eq!(reader.index().version(), 1);
+    assert_eq!(reader.index().index_offset(), 192);
+    assert_eq!(reader.index().file_size(), 432);
+    assert_eq!(reader.container_size(), 432);
+    assert_eq!(reader.members().len(), 2);
+    assert_eq!(
+        reader.member("a//./jit.symjit").unwrap().kind(),
+        PacbinMemberKind::SymjitApplication
+    );
+    assert_eq!(reader.member_bytes("a/jit.symjit").unwrap(), b"jit-v1");
+    assert_eq!(reader.member_range("z/exact.bin", 2, 5).unwrap(), b"act-s");
+    reader.verify_payloads().unwrap();
+
+    let missing = reader.member("missing.bin").unwrap_err();
+    assert_eq!(missing.kind(), RusticolErrorKind::InvalidArgument);
+    assert_eq!(missing.to_string(), "unknown pacbin member: missing.bin");
+    let out_of_bounds = reader.member_range("a/jit.symjit", 5, 2).unwrap_err();
+    assert_eq!(out_of_bounds.kind(), RusticolErrorKind::InvalidArgument);
+    assert_eq!(
+        out_of_bounds.to_string(),
+        "member read exceeds indexed payload bounds"
+    );
+}
+
+#[test]
+fn open_keeps_one_immutable_snapshot_after_atomic_source_replacement() {
+    static NEXT_PATH: AtomicU64 = AtomicU64::new(0);
+    let path = std::env::temp_dir().join(format!(
+        "rusticol-pacbin-{}-{}.pacbin",
+        std::process::id(),
+        NEXT_PATH.fetch_add(1, Ordering::Relaxed)
+    ));
+    fs::write(&path, decode_hex(PYTHON_GOLDEN_HEX)).unwrap();
+    let reader = PacbinReader::open(&path).unwrap();
+    let replacement = path.with_extension("replacement");
+    fs::write(&replacement, b"replaced after open").unwrap();
+    fs::rename(&replacement, &path).unwrap();
+    assert_eq!(reader.member_bytes("a/jit.symjit").unwrap(), b"jit-v1");
+    fs::remove_file(path).unwrap();
+}
+
+#[test]
+fn expected_container_digest_authenticates_an_immutable_snapshot() {
+    static NEXT_PATH: AtomicU64 = AtomicU64::new(0);
+    let path = std::env::temp_dir().join(format!(
+        "rusticol-pacbin-authenticated-{}-{}.pacbin",
+        std::process::id(),
+        NEXT_PATH.fetch_add(1, Ordering::Relaxed)
+    ));
+    let bytes = decode_hex(PYTHON_GOLDEN_HEX);
+    let digest: [u8; 32] = Sha256::digest(&bytes).into();
+    fs::write(&path, &bytes).unwrap();
+    let reader = PacbinReader::open_with_sha256(&path, &digest).unwrap();
+
+    fs::write(&path, vec![0_u8; bytes.len()]).unwrap();
+    assert_eq!(reader.member_bytes("a/jit.symjit").unwrap(), b"jit-v1");
+    reader.verify_payloads().unwrap();
+    OpenOptions::new()
+        .write(true)
+        .open(&path)
+        .unwrap()
+        .set_len(0)
+        .unwrap();
+    assert_eq!(reader.member_bytes("a/jit.symjit").unwrap(), b"jit-v1");
+    reader.verify_payloads().unwrap();
+
+    let replacement = path.with_extension("replacement");
+    fs::write(&replacement, b"replaced after authenticated open").unwrap();
+    fs::rename(&replacement, &path).unwrap();
+    assert_eq!(reader.member_bytes("a/jit.symjit").unwrap(), b"jit-v1");
+
+    let error = PacbinReader::open_with_sha256(&path, &digest).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+    assert!(error.to_string().contains("payload digest mismatch"));
+    fs::remove_file(path).unwrap();
+}
+
+#[test]
+fn empty_and_zero_length_members_are_valid() {
+    let empty = PacbinReader::from_bytes(build_container(&[])).unwrap();
+    assert!(empty.members().is_empty());
+
+    let zero = build_container(&[
+        TestMember {
+            path: "a.empty",
+            kind: PacbinMemberKind::SymjitApplication,
+            payload: b"",
+        },
+        TestMember {
+            path: "b.empty",
+            kind: PacbinMemberKind::SymbolicaExactState,
+            payload: b"",
+        },
+    ]);
+    let zero = PacbinReader::from_bytes(zero).unwrap();
+    assert_eq!(zero.members()[0].offset(), zero.members()[1].offset());
+    assert_eq!(zero.member_bytes("b.empty").unwrap(), b"");
+}
+
+#[test]
+fn header_footer_and_index_contracts_are_strict() {
+    let golden = decode_hex(PYTHON_GOLDEN_HEX);
+    for (offset, replacement, kind, message) in [
+        (0, vec![b'X'], RusticolErrorKind::Integrity, "header magic"),
+        (
+            8,
+            2_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "header version",
+        ),
+        (
+            10,
+            1_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "header size",
+        ),
+        (
+            12,
+            1_u32.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "header flags",
+        ),
+        (
+            16,
+            32_u32.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "payload alignment",
+        ),
+        (
+            20,
+            1_u32.to_le_bytes().to_vec(),
+            RusticolErrorKind::Integrity,
+            "reserved fields",
+        ),
+    ] {
+        let mut bytes = golden.clone();
+        bytes[offset..offset + replacement.len()].copy_from_slice(&replacement);
+        assert_error(bytes, kind, message);
+    }
+    let mut reserved = golden.clone();
+    reserved[63] = 1;
+    assert_error(reserved, RusticolErrorKind::Integrity, "reserved fields");
+    let mut unaligned_index = golden.clone();
+    put_u64(&mut unaligned_index, 24, 193);
+    assert_error(
+        unaligned_index,
+        RusticolErrorKind::Integrity,
+        "index offset is not payload-aligned",
+    );
+    let mut out_of_bounds_index = golden.clone();
+    put_u64(&mut out_of_bounds_index, 24, 0);
+    let footer = footer_offset(&out_of_bounds_index);
+    put_u64(&mut out_of_bounds_index, footer + 16, 0);
+    assert_error(
+        out_of_bounds_index,
+        RusticolErrorKind::Integrity,
+        "index offset is out of bounds",
+    );
+
+    let footer = footer_offset(&golden);
+    for (offset, replacement, kind, message) in [
+        (
+            footer,
+            vec![b'X'],
+            RusticolErrorKind::Integrity,
+            "footer magic",
+        ),
+        (
+            footer + 8,
+            2_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "footer version",
+        ),
+        (
+            footer + 10,
+            1_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "footer size",
+        ),
+        (
+            footer + 12,
+            1_u32.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "footer flags",
+        ),
+        (
+            footer + 16,
+            0_u64.to_le_bytes().to_vec(),
+            RusticolErrorKind::Integrity,
+            "offset disagrees",
+        ),
+        (
+            footer + 24,
+            99_u64.to_le_bytes().to_vec(),
+            RusticolErrorKind::Integrity,
+            "count disagrees",
+        ),
+    ] {
+        let mut bytes = golden.clone();
+        bytes[offset..offset + replacement.len()].copy_from_slice(&replacement);
+        assert_error(bytes, kind, message);
+    }
+    let index = index_offset(&golden);
+    let mut index_count = golden.clone();
+    put_u64(&mut index_count, index + 16, 1);
+    rewrite_index_digest(&mut index_count);
+    assert_error(
+        index_count,
+        RusticolErrorKind::Integrity,
+        "index member count disagrees with header",
+    );
+
+    for (offset, replacement, kind, message) in [
+        (
+            index,
+            vec![b'X'],
+            RusticolErrorKind::Integrity,
+            "index magic",
+        ),
+        (
+            index + 8,
+            2_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "index version",
+        ),
+        (
+            index + 10,
+            1_u16.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "index size",
+        ),
+        (
+            index + 12,
+            1_u32.to_le_bytes().to_vec(),
+            RusticolErrorKind::Compatibility,
+            "index flags",
+        ),
+        (
+            index + 24,
+            1_u64.to_le_bytes().to_vec(),
+            RusticolErrorKind::Integrity,
+            "reserved field",
+        ),
+    ] {
+        let mut bytes = golden.clone();
+        bytes[offset..offset + replacement.len()].copy_from_slice(&replacement);
+        rewrite_index_digest(&mut bytes);
+        assert_error(bytes, kind, message);
+    }
+}
+
+#[test]
+fn count_and_index_size_bounds_fail_before_allocation() {
+    assert_error(
+        {
+            let mut bytes = decode_hex(PYTHON_GOLDEN_HEX);
+            put_u64(&mut bytes, 32, u64::MAX);
+            let footer = footer_offset(&bytes);
+            put_u64(&mut bytes, footer + 24, u64::MAX);
+            bytes
+        },
+        RusticolErrorKind::Integrity,
+        "member count cannot fit in index",
+    );
+    validate_index_bounds(0, 256 * 1024 * 1024 + 1).unwrap();
+    let impossible = validate_index_bounds(2, 64).unwrap_err();
+    assert_eq!(
+        impossible.to_string(),
+        "pacbin member count cannot fit in index"
+    );
+}
+
+#[test]
+fn member_contract_path_bounds_and_utf8_are_strict() {
+    let golden = decode_hex(PYTHON_GOLDEN_HEX);
+    let entry = entry_offsets(&golden)[0];
+    let mut kind = golden.clone();
+    put_u16(&mut kind, entry + 4, 99);
+    rewrite_index_digest(&mut kind);
+    assert_error(kind, RusticolErrorKind::Compatibility, "member kind");
+
+    let mut flags = golden.clone();
+    put_u16(&mut flags, entry + 6, 1);
+    rewrite_index_digest(&mut flags);
+    assert_error(flags, RusticolErrorKind::Compatibility, "member flags");
+
+    let mut path_bound = golden.clone();
+    put_u32(&mut path_bound, entry, u32::MAX);
+    rewrite_index_digest(&mut path_bound);
+    assert_error(
+        path_bound,
+        RusticolErrorKind::Integrity,
+        "pacbin member path",
+    );
+
+    let mut utf8 = golden.clone();
+    utf8[entry + INDEX_ENTRY_SIZE] = 0xff;
+    rewrite_index_digest(&mut utf8);
+    assert_error(utf8, RusticolErrorKind::Integrity, "not valid UTF-8");
+
+    let unicode = build_container(&[TestMember {
+        path: "café/state.bin",
+        kind: PacbinMemberKind::SymbolicaExactState,
+        payload: b"state",
+    }]);
+    assert_error(unicode, RusticolErrorKind::Integrity, "portable ASCII");
+}
+
+#[test]
+fn paths_must_be_canonical_unique_case_distinct_and_sorted() {
+    for (members, message) in [
+        (
+            vec![
+                TestMember {
+                    path: "same.bin",
+                    kind: PacbinMemberKind::SymjitApplication,
+                    payload: b"a",
+                },
+                TestMember {
+                    path: "same.bin",
+                    kind: PacbinMemberKind::NativeLibrary,
+                    payload: b"b",
+                },
+            ],
+            "duplicate",
+        ),
+        (
+            vec![
+                TestMember {
+                    path: "Case.bin",
+                    kind: PacbinMemberKind::SymjitApplication,
+                    payload: b"a",
+                },
+                TestMember {
+                    path: "case.bin",
+                    kind: PacbinMemberKind::NativeLibrary,
+                    payload: b"b",
+                },
+            ],
+            "case-colliding",
+        ),
+        (
+            vec![
+                TestMember {
+                    path: "z.bin",
+                    kind: PacbinMemberKind::SymjitApplication,
+                    payload: b"a",
+                },
+                TestMember {
+                    path: "a.bin",
+                    kind: PacbinMemberKind::NativeLibrary,
+                    payload: b"b",
+                },
+            ],
+            "strictly sorted",
+        ),
+    ] {
+        assert_error(
+            build_container(&members),
+            RusticolErrorKind::Integrity,
+            message,
+        );
+    }
+
+    let noncanonical = build_container(&[TestMember {
+        path: "../escape.bin",
+        kind: PacbinMemberKind::SymjitApplication,
+        payload: b"payload",
+    }]);
+    assert_error(
+        noncanonical,
+        RusticolErrorKind::Integrity,
+        "must not contain '..'",
+    );
+}
+
+#[test]
+fn index_padding_and_exact_coverage_are_enforced() {
+    let mut padding = decode_hex(PYTHON_GOLDEN_HEX);
+    let first = entry_offsets(&padding)[0];
+    let path_length = u32_at(&padding, first, "path length").unwrap() as usize;
+    padding[first + INDEX_ENTRY_SIZE + path_length] = 1;
+    rewrite_index_digest(&mut padding);
+    assert_error(padding, RusticolErrorKind::Integrity, "index padding");
+
+    let mut trailing = decode_hex(PYTHON_GOLDEN_HEX);
+    let footer = footer_offset(&trailing);
+    trailing.splice(footer..footer, [0_u8; 8]);
+    rewrite_index_digest(&mut trailing);
+    assert_error(
+        trailing,
+        RusticolErrorKind::Integrity,
+        "trailing or missing bytes",
+    );
+}
+
+#[test]
+fn payload_layout_rejects_overlap_gap_bounds_overflow_and_nonzero_padding() {
+    let golden = decode_hex(PYTHON_GOLDEN_HEX);
+    let entries = entry_offsets(&golden);
+    let first_offset = u64_at(&golden, entries[0] + 8, "first offset").unwrap();
+
+    let mut overlap = golden.clone();
+    put_u64(&mut overlap, entries[1] + 8, first_offset);
+    rewrite_index_digest(&mut overlap);
+    assert_error(overlap, RusticolErrorKind::Integrity, "overlapping");
+
+    let mut gap = golden.clone();
+    put_u64(&mut gap, entries[1] + 8, 192);
+    rewrite_index_digest(&mut gap);
+    assert_error(
+        gap,
+        RusticolErrorKind::Integrity,
+        "non-canonical pacbin member gap",
+    );
+
+    let mut out_of_bounds = golden.clone();
+    put_u64(&mut out_of_bounds, entries[0] + 16, 192);
+    rewrite_index_digest(&mut out_of_bounds);
+    assert_error(out_of_bounds, RusticolErrorKind::Integrity, "out of bounds");
+
+    let mut overflow = golden.clone();
+    put_u64(&mut overflow, entries[0] + 16, u64::MAX);
+    rewrite_index_digest(&mut overflow);
+    assert_error(overflow, RusticolErrorKind::Integrity, "overflows u64");
+
+    let mut padding = golden.clone();
+    padding[70] = 1;
+    assert_error(padding, RusticolErrorKind::Integrity, "payload padding");
+
+    let mut trailing_gap = golden.clone();
+    let old_index = index_offset(&trailing_gap);
+    trailing_gap.splice(old_index..old_index, [0_u8; PACBIN_ALIGNMENT as usize]);
+    let new_index = old_index as u64 + u64::from(PACBIN_ALIGNMENT);
+    put_u64(&mut trailing_gap, 24, new_index);
+    let footer = footer_offset(&trailing_gap);
+    put_u64(&mut trailing_gap, footer + 16, new_index);
+    rewrite_index_digest(&mut trailing_gap);
+    assert_error(
+        trailing_gap,
+        RusticolErrorKind::Integrity,
+        "non-canonical trailing gap",
+    );
+}
+
+#[test]
+fn payload_and_index_authentication_reject_corruption_and_truncation() {
+    let mut payload = decode_hex(PYTHON_GOLDEN_HEX);
+    payload[64] ^= 1;
+    assert_error(
+        payload,
+        RusticolErrorKind::Integrity,
+        "member digest mismatch",
+    );
+
+    let mut index = decode_hex(PYTHON_GOLDEN_HEX);
+    let footer = footer_offset(&index);
+    index[footer + 63] ^= 1;
+    assert_error(index, RusticolErrorKind::Integrity, "index digest mismatch");
+
+    let mut truncated = decode_hex(PYTHON_GOLDEN_HEX);
+    truncated.truncate(truncated.len() - 17);
+    let (_, message) = error(truncated);
+    assert!(message.contains("footer") || message.contains("truncated"));
+}
+
+#[test]
+fn normalization_follows_portable_python_posix_rules() {
+    assert_eq!(normalize_logical_path("a//./b.bin").unwrap(), "a/b.bin");
+    for (path, message) in [
+        ("", "non-empty"),
+        (".", "name a member"),
+        ("/absolute", "relative"),
+        ("safe/../escape", "must not contain"),
+        ("windows\\path", "POSIX"),
+        ("bad\0path", "NUL"),
+    ] {
+        let error = normalize_logical_path(path).unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+        assert!(error.to_string().contains(message));
+    }
+}
+
+fn temporary_directory(label: &str) -> std::path::PathBuf {
+    static NEXT_DIRECTORY: AtomicU64 = AtomicU64::new(0);
+    let path = std::env::temp_dir().join(format!(
+        "rusticol-pacbin-{label}-{}-{}",
+        std::process::id(),
+        NEXT_DIRECTORY.fetch_add(1, Ordering::Relaxed)
+    ));
+    fs::create_dir(&path).unwrap();
+    path
+}
+
+#[test]
+fn rust_writer_matches_python_golden_byte_for_byte() {
+    let directory = temporary_directory("python-golden");
+    let destination = directory.join("golden.pacbin");
+    let members = vec![
+        PacbinWriteMember::from_bytes(
+            "z/exact.bin",
+            PacbinMemberKind::SymbolicaExactState,
+            b"exact-state",
+        )
+        .unwrap(),
+        PacbinWriteMember::from_bytes(
+            "a//./jit.symjit",
+            PacbinMemberKind::SymjitApplication,
+            b"jit-v1",
+        )
+        .unwrap(),
+    ];
+    let index = write_pacbin_atomic(&destination, members, PacbinWriteOptions::default()).unwrap();
+    let bytes = fs::read(&destination).unwrap();
+    assert_eq!(bytes, decode_hex(PYTHON_GOLDEN_HEX));
+    assert_eq!(index.index_offset(), 192);
+    assert_eq!(index.file_size(), 432);
+    assert_eq!(index.members().len(), 2);
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn writer_is_deterministic_and_supports_runtime_member_kinds() {
+    let directory = temporary_directory("determinism");
+    let first = directory.join("first.pacbin");
+    let second = directory.join("second.pacbin");
+    for destination in [&first, &second] {
+        write_pacbin_atomic(
+            destination,
+            vec![
+                PacbinWriteMember::from_bytes(
+                    "tables/invocations.bin",
+                    PacbinMemberKind::EagerRuntimeTable,
+                    b"table-payload",
+                )
+                .unwrap(),
+                PacbinWriteMember::from_bytes(
+                    "metadata/runtime.bin",
+                    PacbinMemberKind::EagerRuntimeMetadata,
+                    b"metadata-payload",
+                )
+                .unwrap(),
+                PacbinWriteMember::from_bytes(
+                    "schedule/recurrence-direct-schedule-v2.bin",
+                    PacbinMemberKind::RecurrenceDirectPlan,
+                    b"recurrence-direct-plan-payload",
+                )
+                .unwrap(),
+                PacbinWriteMember::from_bytes(
+                    "compiled/color.pacrclr3",
+                    PacbinMemberKind::ColorContraction,
+                    b"compiled-color-contraction-payload",
+                )
+                .unwrap(),
+            ],
+            PacbinWriteOptions::new(3, 0o644).unwrap(),
+        )
+        .unwrap();
+    }
+    assert_eq!(fs::read(&first).unwrap(), fs::read(&second).unwrap());
+    let reader = PacbinReader::open(&first).unwrap();
+    assert_eq!(
+        reader.member("metadata/runtime.bin").unwrap().kind(),
+        PacbinMemberKind::EagerRuntimeMetadata
+    );
+    assert_eq!(
+        reader.member("tables/invocations.bin").unwrap().kind(),
+        PacbinMemberKind::EagerRuntimeTable
+    );
+    assert_eq!(
+        reader
+            .member("schedule/recurrence-direct-schedule-v2.bin")
+            .unwrap()
+            .kind(),
+        PacbinMemberKind::RecurrenceDirectPlan
+    );
+    assert_eq!(
+        reader.member("compiled/color.pacrclr3").unwrap().kind(),
+        PacbinMemberKind::ColorContraction
+    );
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn deleted_recurrence_v1_member_kind_is_not_a_compatibility_alias() {
+    assert!(PacbinMemberKind::parse(6).is_err());
+    assert_eq!(
+        PacbinMemberKind::parse(7).unwrap(),
+        PacbinMemberKind::RecurrenceDirectPlan
+    );
+    assert_eq!(
+        PacbinMemberKind::parse(8).unwrap(),
+        PacbinMemberKind::RecurrenceColorProjectionCertificate
+    );
+    assert_eq!(
+        PacbinMemberKind::parse(10).unwrap(),
+        PacbinMemberKind::ColorContraction
+    );
+}
+
+struct TrackingReader {
+    payload: Vec<u8>,
+    position: usize,
+    maximum_request: usize,
+    fail_at: Option<usize>,
+}
+
+impl TrackingReader {
+    fn new(payload: impl Into<Vec<u8>>) -> Self {
+        Self {
+            payload: payload.into(),
+            position: 0,
+            maximum_request: 0,
+            fail_at: None,
+        }
+    }
+
+    fn failing(payload: impl Into<Vec<u8>>, fail_at: usize) -> Self {
+        Self {
+            fail_at: Some(fail_at),
+            ..Self::new(payload)
+        }
+    }
+}
+
+impl Read for TrackingReader {
+    fn read(&mut self, buffer: &mut [u8]) -> io::Result<usize> {
+        self.maximum_request = self.maximum_request.max(buffer.len());
+        if self.fail_at.is_some_and(|limit| self.position >= limit) {
+            return Err(io::Error::other("injected member read failure"));
+        }
+        let remaining = self.payload.len().saturating_sub(self.position);
+        let mut length = remaining.min(buffer.len());
+        if let Some(limit) = self.fail_at {
+            length = length.min(limit.saturating_sub(self.position));
+        }
+        if length == 0 {
+            return Ok(0);
+        }
+        buffer[..length].copy_from_slice(&self.payload[self.position..self.position + length]);
+        self.position += length;
+        Ok(length)
+    }
+}
+
+#[test]
+fn writer_streams_reader_and_path_sources_in_bounded_chunks() {
+    let directory = temporary_directory("bounded-streaming");
+    let source_path = directory.join("source.bin");
+    fs::write(&source_path, b"path-source").unwrap();
+    let destination = directory.join("container.pacbin");
+    let mut source = TrackingReader::new(vec![0x5a; 100]);
+    write_pacbin_atomic(
+        &destination,
+        vec![
+            PacbinWriteMember::from_reader(
+                "a/reader.bin",
+                PacbinMemberKind::EagerRuntimeTable,
+                &mut source,
+            )
+            .unwrap(),
+            PacbinWriteMember::from_path(
+                "b/path.bin",
+                PacbinMemberKind::EagerRuntimeMetadata,
+                &source_path,
+            )
+            .unwrap(),
+        ],
+        PacbinWriteOptions::new(7, 0o600).unwrap(),
+    )
+    .unwrap();
+    assert_eq!(source.maximum_request, 7);
+    let reader = PacbinReader::open(&destination).unwrap();
+    assert_eq!(reader.member_bytes("a/reader.bin").unwrap(), &[0x5a; 100]);
+    assert_eq!(reader.member_bytes("b/path.bin").unwrap(), b"path-source");
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn atomic_writer_preserves_destination_and_cleans_temporary_file_on_error() {
+    let directory = temporary_directory("atomic-failure");
+    let destination = directory.join("container.pacbin");
+    fs::write(&destination, b"previous-container").unwrap();
+    let mut source = TrackingReader::failing(vec![0x41; 32], 8);
+    let error = write_pacbin_atomic(
+        &destination,
+        vec![
+            PacbinWriteMember::from_reader(
+                "tables/failing.bin",
+                PacbinMemberKind::EagerRuntimeTable,
+                &mut source,
+            )
+            .unwrap(),
+        ],
+        PacbinWriteOptions::new(4, 0o644).unwrap(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("injected member read failure"));
+    assert_eq!(fs::read(&destination).unwrap(), b"previous-container");
+    let names: Vec<_> = fs::read_dir(&directory)
+        .unwrap()
+        .map(|entry| entry.unwrap().file_name())
+        .collect();
+    assert_eq!(names, vec![std::ffi::OsString::from("container.pacbin")]);
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn writer_preflight_rejects_invalid_options_and_colliding_paths() {
+    assert!(PacbinWriteOptions::new(0, 0o644).is_err());
+    assert!(PacbinWriteOptions::new(1, 0o1000).is_err());
+    let directory = temporary_directory("preflight");
+    let destination = directory.join("container.pacbin");
+    let duplicate = write_pacbin_atomic(
+        &destination,
+        vec![
+            PacbinWriteMember::from_bytes("same.bin", PacbinMemberKind::EagerRuntimeMetadata, b"a")
+                .unwrap(),
+            PacbinWriteMember::from_bytes("same.bin", PacbinMemberKind::EagerRuntimeTable, b"b")
+                .unwrap(),
+        ],
+        PacbinWriteOptions::default(),
+    )
+    .unwrap_err();
+    assert_eq!(duplicate.kind(), RusticolErrorKind::InvalidArgument);
+    assert!(duplicate.to_string().contains("duplicate"));
+    let case_collision = write_pacbin_atomic(
+        &destination,
+        vec![
+            PacbinWriteMember::from_bytes("Case.bin", PacbinMemberKind::EagerRuntimeMetadata, b"a")
+                .unwrap(),
+            PacbinWriteMember::from_bytes("case.bin", PacbinMemberKind::EagerRuntimeTable, b"b")
+                .unwrap(),
+        ],
+        PacbinWriteOptions::default(),
+    )
+    .unwrap_err();
+    assert_eq!(case_collision.kind(), RusticolErrorKind::InvalidArgument);
+    assert!(case_collision.to_string().contains("case-colliding"));
+    assert!(!destination.exists());
+    fs::remove_dir_all(directory).unwrap();
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/arena.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/arena.rs
new file mode 100644
index 0000000000..948d3a9a79
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/arena.rs
@@ -0,0 +1,370 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Deterministic physical component-range assignment for direct recurrence arenas.
+//!
+//! Semantic current IDs remain stable in the authenticated plan. The direct
+//! runtime stores only simultaneously live currents in its split-complex
+//! workspace, so non-overlapping liveness intervals may share component
+//! planes. This module is independent of model and process semantics.
+
+use super::RecurrenceProgram;
+use crate::direct_arena::{
+    DirectArenaInterval as GenericDirectArenaInterval,
+    assign_direct_arena as assign_generic_direct_arena,
+};
+use crate::{RusticolError, RusticolResult};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+/// Inclusive liveness interval and required component-plane width.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct DirectArenaInterval {
+    pub semantic_current_id: u32,
+    pub first_use: u64,
+    pub last_use: u64,
+    pub component_count: u32,
+}
+
+impl DirectArenaInterval {
+    pub fn new(
+        semantic_current_id: u32,
+        first_use: u64,
+        last_use: u64,
+        component_count: u32,
+    ) -> RusticolResult<Self> {
+        if first_use > last_use {
+            return Err(invalid(format!(
+                "direct-arena current {semantic_current_id} starts at {first_use} after its last use {last_use}"
+            )));
+        }
+        if component_count == 0 {
+            return Err(invalid(format!(
+                "direct-arena current {semantic_current_id} has no components"
+            )));
+        }
+        Ok(Self {
+            semantic_current_id,
+            first_use,
+            last_use,
+            component_count,
+        })
+    }
+}
+
+/// One semantic current's physical range in the split-complex arena.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct DirectArenaAssignment {
+    pub semantic_current_id: u32,
+    pub component_base: u32,
+    pub component_count: u32,
+    pub first_use: u64,
+    pub last_use: u64,
+}
+
+impl DirectArenaAssignment {
+    pub fn component_stop(self) -> RusticolResult<u32> {
+        self.component_base
+            .checked_add(self.component_count)
+            .ok_or_else(|| invalid("direct-arena component range overflows u32"))
+    }
+}
+
+/// Deterministic interval-coloring result.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DirectArenaLayout {
+    assignments: Box<[DirectArenaAssignment]>,
+    component_count: u32,
+    total_semantic_components: u64,
+    reused_semantic_components: u64,
+}
+
+impl DirectArenaLayout {
+    pub fn assignments(&self) -> &[DirectArenaAssignment] {
+        &self.assignments
+    }
+
+    pub const fn component_count(&self) -> u32 {
+        self.component_count
+    }
+
+    pub const fn total_semantic_components(&self) -> u64 {
+        self.total_semantic_components
+    }
+
+    pub const fn reused_semantic_components(&self) -> u64 {
+        self.reused_semantic_components
+    }
+
+    pub fn assignment(&self, semantic_current_id: u32) -> Option<DirectArenaAssignment> {
+        self.assignments
+            .get(semantic_current_id as usize)
+            .copied()
+            .filter(|assignment| assignment.semantic_current_id == semantic_current_id)
+    }
+
+    pub fn validate(&self) -> RusticolResult<()> {
+        if self.assignments.is_empty() {
+            if self.component_count != 0
+                || self.total_semantic_components != 0
+                || self.reused_semantic_components != 0
+            {
+                return Err(invalid("empty direct-arena layout has nonempty accounting"));
+            }
+            return Ok(());
+        }
+
+        let mut semantic_components = 0u64;
+        for (index, assignment) in self.assignments.iter().copied().enumerate() {
+            if assignment.semantic_current_id != index as u32 {
+                return Err(invalid(format!(
+                    "direct-arena assignment row {index} has semantic current ID {}",
+                    assignment.semantic_current_id
+                )));
+            }
+            if assignment.component_count == 0 || assignment.first_use > assignment.last_use {
+                return Err(invalid(format!(
+                    "direct-arena assignment {index} has invalid width or liveness"
+                )));
+            }
+            if assignment.component_stop()? > self.component_count {
+                return Err(invalid(format!(
+                    "direct-arena assignment {index} exceeds the physical arena"
+                )));
+            }
+            semantic_components = semantic_components
+                .checked_add(u64::from(assignment.component_count))
+                .ok_or_else(|| invalid("direct-arena semantic component count overflows u64"))?;
+        }
+        if semantic_components != self.total_semantic_components {
+            return Err(invalid(format!(
+                "direct-arena semantic component total {} does not match recorded {}",
+                semantic_components, self.total_semantic_components
+            )));
+        }
+        if self
+            .total_semantic_components
+            .checked_sub(u64::from(self.component_count))
+            != Some(self.reused_semantic_components)
+        {
+            return Err(invalid(
+                "direct-arena reused component accounting is inconsistent",
+            ));
+        }
+
+        for (left_index, left) in self.assignments.iter().copied().enumerate() {
+            for right in self.assignments[left_index + 1..].iter().copied() {
+                let lifetimes_overlap =
+                    left.first_use <= right.last_use && right.first_use <= left.last_use;
+                if !lifetimes_overlap {
+                    continue;
+                }
+                let ranges_overlap = left.component_base < right.component_stop()?
+                    && right.component_base < left.component_stop()?;
+                if ranges_overlap {
+                    return Err(invalid(format!(
+                        "live direct-arena currents {} and {} overlap physical components",
+                        left.semantic_current_id, right.semantic_current_id
+                    )));
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Assign variable-width current intervals to reusable physical component ranges.
+///
+/// Inputs must use dense semantic current IDs. The allocator processes
+/// intervals by `(first_use, semantic_current_id)`, releases ranges whose
+/// inclusive lifetime ended before the next current starts, and chooses the
+/// smallest fitting free range with the lowest base as a deterministic tie
+/// breaker.
+pub fn assign_direct_arena(intervals: &[DirectArenaInterval]) -> RusticolResult<DirectArenaLayout> {
+    let generic_intervals = intervals
+        .iter()
+        .map(|interval| {
+            GenericDirectArenaInterval::new(
+                interval.semantic_current_id,
+                interval.first_use,
+                interval.last_use,
+                interval.component_count,
+            )
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let generic_layout = assign_generic_direct_arena(&generic_intervals)?;
+    let assignments = generic_layout
+        .assignments()
+        .iter()
+        .map(|assignment| DirectArenaAssignment {
+            semantic_current_id: assignment.semantic_value_id,
+            component_base: assignment.component_base,
+            component_count: assignment.component_count,
+            first_use: assignment.first_use,
+            last_use: assignment.last_use,
+        })
+        .collect::<Vec<_>>();
+    Ok(DirectArenaLayout {
+        assignments: assignments.into_boxed_slice(),
+        component_count: generic_layout.component_count(),
+        total_semantic_components: generic_layout.total_semantic_components(),
+        reused_semantic_components: generic_layout.reused_semantic_components(),
+    })
+}
+
+/// Derive conservative stage-granular liveness for a semantic recurrence program.
+///
+/// Direct contribution packets may interleave destinations within one stage,
+/// so every current produced in that stage is considered simultaneously live.
+/// A current remains live through the latest child stage that reads it or
+/// through the final closure event. This permits reuse between dependency
+/// stages without relying on packet ordering.
+pub fn recurrence_direct_arena_layout(
+    program: &RecurrenceProgram,
+    component_counts: &[u32],
+) -> RusticolResult<DirectArenaLayout> {
+    if component_counts.len() != program.currents().len() {
+        return Err(invalid(format!(
+            "direct-arena component-count catalog has {} rows for {} currents",
+            component_counts.len(),
+            program.currents().len()
+        )));
+    }
+
+    let current_stages = program
+        .currents()
+        .iter()
+        .map(|current| {
+            u64::try_from(current.key().support_source_slots().len())
+                .map_err(|_| invalid("direct-arena current stage exceeds u64"))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let maximum_stage = current_stages.iter().copied().max().unwrap_or(0);
+    let closure_event = maximum_stage
+        .checked_add(1)
+        .ok_or_else(|| invalid("direct-arena closure event overflows u64"))?;
+    let mut last_uses = current_stages.clone();
+
+    for contribution in program.contributions() {
+        let result_stage = *current_stages
+            .get(contribution.result_current_id() as usize)
+            .ok_or_else(|| invalid("direct-arena contribution result current is absent"))?;
+        for &parent_id in contribution.parent_current_ids() {
+            let last_use = last_uses
+                .get_mut(parent_id as usize)
+                .ok_or_else(|| invalid("direct-arena contribution parent current is absent"))?;
+            *last_use = (*last_use).max(result_stage);
+        }
+    }
+    for closure in program.closure_terms() {
+        for &parent_id in closure.parent_current_ids() {
+            let last_use = last_uses
+                .get_mut(parent_id as usize)
+                .ok_or_else(|| invalid("direct-arena closure parent current is absent"))?;
+            *last_use = closure_event;
+        }
+    }
+
+    let intervals = program
+        .currents()
+        .iter()
+        .zip(component_counts.iter().copied())
+        .enumerate()
+        .map(|(index, (current, component_count))| {
+            if current.id() as usize != index {
+                return Err(invalid(
+                    "direct-arena lowering requires dense semantic current IDs",
+                ));
+            }
+            DirectArenaInterval::new(
+                current.id(),
+                current_stages[index],
+                last_uses[index],
+                component_count,
+            )
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    assign_direct_arena(&intervals)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn interval(id: u32, first: u64, last: u64, count: u32) -> DirectArenaInterval {
+        DirectArenaInterval::new(id, first, last, count).unwrap()
+    }
+
+    #[test]
+    fn non_overlapping_currents_reuse_the_same_range() {
+        let layout = assign_direct_arena(&[
+            interval(0, 0, 2, 4),
+            interval(1, 3, 5, 4),
+            interval(2, 6, 8, 4),
+        ])
+        .unwrap();
+        assert_eq!(layout.component_count(), 4);
+        assert_eq!(layout.total_semantic_components(), 12);
+        assert_eq!(layout.reused_semantic_components(), 8);
+        assert_eq!(layout.assignment(0).unwrap().component_base, 0);
+        assert_eq!(layout.assignment(1).unwrap().component_base, 0);
+        assert_eq!(layout.assignment(2).unwrap().component_base, 0);
+    }
+
+    #[test]
+    fn inclusive_lifetimes_do_not_reuse_at_the_same_event() {
+        let layout = assign_direct_arena(&[interval(0, 0, 3, 2), interval(1, 3, 4, 3)]).unwrap();
+        assert_eq!(layout.component_count(), 5);
+        assert_eq!(layout.assignment(0).unwrap().component_base, 0);
+        assert_eq!(layout.assignment(1).unwrap().component_base, 2);
+    }
+
+    #[test]
+    fn allocator_chooses_the_smallest_fitting_range_deterministically() {
+        let layout = assign_direct_arena(&[
+            interval(0, 0, 1, 8),
+            interval(1, 0, 5, 2),
+            interval(2, 0, 1, 3),
+            interval(3, 2, 4, 2),
+            interval(4, 2, 4, 7),
+        ])
+        .unwrap();
+        assert_eq!(layout.assignment(3).unwrap().component_base, 10);
+        assert_eq!(layout.assignment(4).unwrap().component_base, 0);
+        assert_eq!(layout.component_count(), 13);
+    }
+
+    #[test]
+    fn allocator_rejects_sparse_or_duplicate_semantic_ids() {
+        assert!(assign_direct_arena(&[interval(1, 0, 1, 1)]).is_err());
+        assert!(assign_direct_arena(&[interval(0, 0, 1, 1), interval(0, 2, 3, 1)]).is_err());
+    }
+
+    #[test]
+    fn validation_rejects_overlapping_live_ranges() {
+        let layout = DirectArenaLayout {
+            assignments: vec![
+                DirectArenaAssignment {
+                    semantic_current_id: 0,
+                    component_base: 0,
+                    component_count: 2,
+                    first_use: 0,
+                    last_use: 2,
+                },
+                DirectArenaAssignment {
+                    semantic_current_id: 1,
+                    component_base: 1,
+                    component_count: 2,
+                    first_use: 1,
+                    last_use: 3,
+                },
+            ]
+            .into_boxed_slice(),
+            component_count: 3,
+            total_semantic_components: 4,
+            reused_semantic_components: 1,
+        };
+        assert!(layout.validate().is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/builder.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/builder.rs
new file mode 100644
index 0000000000..9aa5092662
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/builder.rs
@@ -0,0 +1,211 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Composite authentication and compact recurrence schedule construction.
+
+use super::process::{ProcessSemanticTemplateReference, ValidatedRecurrenceProcessInput};
+use super::template::{RecurrenceSemanticTemplateKind, ValidatedRecurrenceTemplateInput};
+use crate::{RusticolError, RusticolResult};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+/// Process and prepared-model inputs authenticated as one semantic unit.
+#[derive(Clone, Debug)]
+pub struct AuthenticatedRecurrenceBuilderInput {
+    process: ValidatedRecurrenceProcessInput,
+    template: ValidatedRecurrenceTemplateInput,
+}
+
+impl AuthenticatedRecurrenceBuilderInput {
+    pub fn new(
+        process: ValidatedRecurrenceProcessInput,
+        template: ValidatedRecurrenceTemplateInput,
+    ) -> RusticolResult<Self> {
+        let process_identity = process.semantic_identity();
+        let template_summary = template.summary();
+        if process_identity.model_catalog_digest() != template_summary.compiled_model_digest {
+            return Err(invalid(format!(
+                "recurrence process model-catalog digest {} does not match prepared model {}",
+                process_identity.model_catalog_digest(),
+                template_summary.compiled_model_digest,
+            )));
+        }
+        if process_identity.prepared_catalog_digest() != template_summary.catalog_digest {
+            return Err(invalid(format!(
+                "recurrence process prepared-catalog digest {} does not match template catalog {}",
+                process_identity.prepared_catalog_digest(),
+                template_summary.catalog_digest,
+            )));
+        }
+
+        let template_index = template.semantic_index()?;
+        for reference in process.template_references() {
+            authenticate_template_reference(reference, &template_index)?;
+        }
+        authenticate_singlet_closure_anchors(&process, &template)?;
+
+        Ok(Self { process, template })
+    }
+
+    pub const fn process(&self) -> &ValidatedRecurrenceProcessInput {
+        &self.process
+    }
+
+    pub const fn template(&self) -> &ValidatedRecurrenceTemplateInput {
+        &self.template
+    }
+
+    pub fn into_parts(
+        self,
+    ) -> (
+        ValidatedRecurrenceProcessInput,
+        ValidatedRecurrenceTemplateInput,
+    ) {
+        (self.process, self.template)
+    }
+
+    pub fn build(&self) -> RusticolResult<super::RecurrenceProgram> {
+        super::construct::build_recurrence_program(self)
+    }
+
+    pub fn build_with_progress(
+        &self,
+        progress: &mut dyn FnMut(super::RecurrenceBuildProgress) -> RusticolResult<()>,
+    ) -> RusticolResult<super::RecurrenceProgram> {
+        super::construct::build_recurrence_program_with_progress(self, progress)
+    }
+
+    /// Build while returning construction-only generation diagnostics.
+    #[doc(hidden)]
+    pub fn build_with_progress_and_telemetry(
+        &self,
+        progress: &mut dyn FnMut(super::RecurrenceBuildProgress) -> RusticolResult<()>,
+    ) -> RusticolResult<(
+        super::RecurrenceProgram,
+        super::RecurrenceGenerationTelemetry,
+    )> {
+        super::construct::build_recurrence_program_with_progress_and_telemetry(self, progress)
+    }
+}
+
+fn authenticate_singlet_closure_anchors(
+    process: &ValidatedRecurrenceProcessInput,
+    template: &ValidatedRecurrenceTemplateInput,
+) -> RusticolResult<()> {
+    let process_input = process.input();
+    let template_input = template.input();
+    let mut fermionic_source_slots = Vec::new();
+
+    for leg in &process_input.external_legs {
+        let declared_fermionic = match leg.is_fermionic {
+            0 => false,
+            1 => true,
+            value => {
+                return Err(invalid(format!(
+                    "source slot {} has invalid fermionic marker {value}",
+                    leg.source_slot
+                )));
+            }
+        };
+        let state_range = leg.source_state_range.as_usize_range(
+            process_input.source_states.len(),
+            "external source states during closure-anchor authentication",
+        )?;
+        let mut statistics = None;
+        for source_state in &process_input.source_states[state_range] {
+            let state = template_input
+                .current_states
+                .get(source_state.current_state_template_id as usize)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "source slot {} references absent current-state template {}",
+                        leg.source_slot, source_state.current_state_template_id
+                    ))
+                })?;
+            match statistics {
+                None => statistics = Some(state.statistics),
+                Some(previous) if previous == state.statistics => {}
+                Some(previous) => {
+                    return Err(invalid(format!(
+                        "source slot {} mixes particle statistics {previous} and {}",
+                        leg.source_slot, state.statistics
+                    )));
+                }
+            }
+        }
+        let template_fermionic = statistics == Some(1);
+        if template_fermionic != declared_fermionic {
+            return Err(invalid(format!(
+                "source slot {} fermionic marker does not match its authenticated current-state templates",
+                leg.source_slot
+            )));
+        }
+        if declared_fermionic {
+            fermionic_source_slots.push(leg.source_slot);
+        }
+    }
+
+    let expected_singlet_anchor = fermionic_source_slots.first().copied().unwrap_or(0);
+    for sector in &process_input.physical_lc_sectors {
+        let word = process_u32_sequence(
+            process_input,
+            sector.word_sequence_id,
+            "physical LC color word during closure-anchor authentication",
+        )?;
+        if word.is_empty() && sector.closure_source_slot != expected_singlet_anchor {
+            return Err(invalid(format!(
+                "all-singlet LC sector {} uses closure source slot {}, expected first fermionic source slot (or first source) {expected_singlet_anchor}",
+                sector.sector_id, sector.closure_source_slot
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn process_u32_sequence<'a>(
+    input: &'a super::process::OwnedRecurrenceProcessInput,
+    sequence_id: u32,
+    label: &str,
+) -> RusticolResult<&'a [u32]> {
+    let range = input
+        .u32_sequence_ranges
+        .get(sequence_id as usize)
+        .copied()
+        .ok_or_else(|| invalid(format!("{label} references absent sequence {sequence_id}")))?;
+    let range = range.as_usize_range(input.u32_sequence_values.len(), label)?;
+    Ok(&input.u32_sequence_values[range])
+}
+
+fn authenticate_template_reference(
+    reference: &ProcessSemanticTemplateReference,
+    template_index: &super::template::RecurrenceTemplateSemanticIndex,
+) -> RusticolResult<()> {
+    let kind = RecurrenceSemanticTemplateKind::parse(reference.typed_id.kind.as_str())?;
+    let Some(identity) = template_index.record(kind, reference.typed_id.template_id) else {
+        return Err(invalid(format!(
+            "recurrence process references absent prepared {} template {}",
+            kind.as_str(),
+            reference.typed_id.template_id,
+        )));
+    };
+    if identity.semantic_digest != reference.semantic_digest {
+        return Err(invalid(format!(
+            "recurrence process {} template {} has semantic digest {}, expected {}",
+            kind.as_str(),
+            reference.typed_id.template_id,
+            reference.semantic_digest,
+            identity.semantic_digest,
+        )));
+    }
+    if identity.prepared_kernel_id != reference.prepared_kernel_id {
+        return Err(invalid(format!(
+            "recurrence process {} template {} has prepared kernel {:?}, expected {:?}",
+            kind.as_str(),
+            reference.typed_id.template_id,
+            reference.prepared_kernel_id,
+            identity.prepared_kernel_id,
+        )));
+    }
+    Ok(())
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/color.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/color.rs
new file mode 100644
index 0000000000..4385ee64a0
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/color.rs
@@ -0,0 +1,963 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::collections::{BTreeSet, HashMap};
+
+use crate::{RusticolError, RusticolResult};
+
+use super::{DynamicLCColorStateId, ExactComplexRational, SemanticDigest};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+/// One ordered component in a dynamic partial LC color forest.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub enum LCColorComponentKind {
+    OpenString = 0,
+    AdjointSegment = 1,
+    Trace = 2,
+}
+
+impl TryFrom<u8> for LCColorComponentKind {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::OpenString),
+            1 => Ok(Self::AdjointSegment),
+            2 => Ok(Self::Trace),
+            _ => Err(invalid(format!(
+                "unsupported LC color component kind {value}"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub enum LCColorComponentRole {
+    Active = 0,
+    Passive = 1,
+    None = 2,
+}
+
+impl TryFrom<u8> for LCColorComponentRole {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Active),
+            1 => Ok(Self::Passive),
+            2 => Ok(Self::None),
+            _ => Err(invalid(format!(
+                "unsupported LC color component role {value}"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub enum LCColorSourceSeedOperation {
+    Empty = 0,
+    Singleton = 1,
+}
+
+impl TryFrom<u8> for LCColorSourceSeedOperation {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Empty),
+            1 => Ok(Self::Singleton),
+            _ => Err(invalid(format!(
+                "unsupported LC source seed operation {value}"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct LCColorSourceSeed {
+    operation: LCColorSourceSeedOperation,
+    output_color_shape_id: u32,
+    component_kind: Option<LCColorComponentKind>,
+    component_role: LCColorComponentRole,
+    proof_digest: SemanticDigest,
+}
+
+impl LCColorSourceSeed {
+    pub fn new(
+        operation: LCColorSourceSeedOperation,
+        output_color_shape_id: u32,
+        component_kind: Option<LCColorComponentKind>,
+        component_role: LCColorComponentRole,
+        proof_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        match operation {
+            LCColorSourceSeedOperation::Empty
+                if component_kind.is_some() || component_role != LCColorComponentRole::None =>
+            {
+                return Err(invalid(
+                    "an empty LC source seed cannot declare a component",
+                ));
+            }
+            LCColorSourceSeedOperation::Singleton
+                if component_kind.is_none() || component_role == LCColorComponentRole::None =>
+            {
+                return Err(invalid(
+                    "a singleton LC source seed requires component kind and role",
+                ));
+            }
+            _ => {}
+        }
+        Ok(Self {
+            operation,
+            output_color_shape_id,
+            component_kind,
+            component_role,
+            proof_digest,
+        })
+    }
+
+    pub fn instantiate(
+        self,
+        source_slot: u32,
+        color_representation: i32,
+    ) -> RusticolResult<DynamicLCColorState> {
+        match self.operation {
+            LCColorSourceSeedOperation::Empty => {
+                if color_representation != 1 {
+                    return Err(invalid(
+                        "an empty LC source seed requires the singlet representation",
+                    ));
+                }
+                DynamicLCColorState::new(self.output_color_shape_id, None, Vec::new())
+            }
+            LCColorSourceSeedOperation::Singleton => {
+                let component = LCColorComponent::new(
+                    self.component_kind
+                        .expect("validated singleton component kind"),
+                    vec![source_slot],
+                )?;
+                let result_port_bindings = match color_representation {
+                    3 => vec![LCColorPortBinding::new(0, LCColorEndpoint::Back)],
+                    -3 => vec![LCColorPortBinding::new(0, LCColorEndpoint::Front)],
+                    8 => vec![
+                        LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                        LCColorPortBinding::new(0, LCColorEndpoint::Front),
+                    ],
+                    value => {
+                        return Err(invalid(format!(
+                            "a singleton LC source seed has unsupported representation {value}",
+                        )));
+                    }
+                };
+                if self.component_role != LCColorComponentRole::Active {
+                    return Err(invalid(
+                        "a colored LC source seed must expose active result ports",
+                    ));
+                }
+                DynamicLCColorState::new_port_wired(
+                    self.output_color_shape_id,
+                    result_port_bindings,
+                    vec![component],
+                )
+            }
+        }
+    }
+
+    pub const fn proof_digest(self) -> SemanticDigest {
+        self.proof_digest
+    }
+}
+
+/// Canonical ordered colored-source word for one LC component.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct LCColorComponent {
+    kind: LCColorComponentKind,
+    source_slots: Box<[u32]>,
+}
+
+/// One endpoint of an ordered LC strand.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub enum LCColorEndpoint {
+    Front = 0,
+    Back = 1,
+}
+
+impl LCColorEndpoint {
+    const fn reversed(self) -> Self {
+        match self {
+            Self::Front => Self::Back,
+            Self::Back => Self::Front,
+        }
+    }
+
+    fn source_slot(self, component: &LCColorComponent) -> RusticolResult<u32> {
+        match self {
+            Self::Front => component.source_slots().first().copied(),
+            Self::Back => component.source_slots().last().copied(),
+        }
+        .ok_or_else(|| invalid("an LC color result port references an empty component"))
+    }
+}
+
+/// Binding from one ordered current-result color port to a strand endpoint.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct LCColorPortBinding {
+    component_index: u32,
+    endpoint: LCColorEndpoint,
+}
+
+impl LCColorPortBinding {
+    pub const fn new(component_index: u32, endpoint: LCColorEndpoint) -> Self {
+        Self {
+            component_index,
+            endpoint,
+        }
+    }
+
+    pub const fn component_index(self) -> u32 {
+        self.component_index
+    }
+
+    pub const fn endpoint(self) -> LCColorEndpoint {
+        self.endpoint
+    }
+}
+
+/// Reference to one result port of one of the two transition parents.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct LCColorParentPort {
+    parent_index: u8,
+    port_index: u8,
+}
+
+impl LCColorParentPort {
+    pub fn new(parent_index: u8, port_index: u8) -> RusticolResult<Self> {
+        if parent_index > 1 {
+            return Err(invalid(
+                "LC color parent-port parent index must be zero or one",
+            ));
+        }
+        Ok(Self {
+            parent_index,
+            port_index,
+        })
+    }
+
+    const fn parent_index(self) -> usize {
+        self.parent_index as usize
+    }
+
+    const fn port_index(self) -> usize {
+        self.port_index as usize
+    }
+}
+
+/// Exact port wiring certified for one local LC tensor term.
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct LCColorPortWiring {
+    component_parent_order: [u8; 2],
+    input_pairings: Box<[[LCColorParentPort; 2]]>,
+    result_port_bindings: Box<[LCColorParentPort]>,
+}
+
+impl LCColorPortWiring {
+    pub fn new(
+        component_parent_order: [u8; 2],
+        input_pairings: Vec<[LCColorParentPort; 2]>,
+        result_port_bindings: Vec<LCColorParentPort>,
+    ) -> RusticolResult<Self> {
+        if component_parent_order != [0, 1] && component_parent_order != [1, 0] {
+            return Err(invalid(
+                "LC color component parent order must be [0, 1] or [1, 0]",
+            ));
+        }
+        let mut consumed = BTreeSet::new();
+        for pairing in &input_pairings {
+            if pairing[0] == pairing[1] {
+                return Err(invalid("an LC color port cannot be paired with itself"));
+            }
+            for port in pairing {
+                if !consumed.insert(*port) {
+                    return Err(invalid(
+                        "an LC color parent port is consumed by more than one pairing",
+                    ));
+                }
+            }
+        }
+        for port in &result_port_bindings {
+            if !consumed.insert(*port) {
+                return Err(invalid(
+                    "an LC color parent port is both paired and exposed as a result port",
+                ));
+            }
+        }
+        Ok(Self {
+            component_parent_order,
+            input_pairings: input_pairings.into_boxed_slice(),
+            result_port_bindings: result_port_bindings.into_boxed_slice(),
+        })
+    }
+
+    pub fn apply(
+        &self,
+        left: &DynamicLCColorState,
+        right: &DynamicLCColorState,
+        result_color_shape_id: u32,
+    ) -> RusticolResult<DynamicLCColorState> {
+        let parents = [left, right];
+        let mut components = Vec::<Option<LCColorComponent>>::new();
+        let mut parent_ports = [Vec::new(), Vec::new()];
+        for parent_index in self.component_parent_order {
+            let parent = parents[parent_index as usize];
+            let offset = components.len() as u32;
+            components.extend(parent.components().iter().cloned().map(Some));
+            parent_ports[parent_index as usize] = parent
+                .result_port_bindings()
+                .iter()
+                .map(|binding| {
+                    Some(LCColorPortBinding::new(
+                        binding.component_index() + offset,
+                        binding.endpoint(),
+                    ))
+                })
+                .collect();
+        }
+
+        let expected_parent_ports = parent_ports[0].len() + parent_ports[1].len();
+        if expected_parent_ports != self.input_pairings.len() * 2 + self.result_port_bindings.len()
+        {
+            return Err(invalid(
+                "LC color wiring does not consume every parent result port exactly once",
+            ));
+        }
+        for pairing in self.input_pairings.iter().copied() {
+            let left_binding = take_parent_port(pairing[0], &mut parent_ports)?;
+            let right_binding = take_parent_port(pairing[1], &mut parent_ports)?;
+            join_color_endpoints(
+                &mut components,
+                &mut parent_ports,
+                left_binding,
+                right_binding,
+            )?;
+        }
+        let mut result_ports = Vec::with_capacity(self.result_port_bindings.len());
+        for reference in self.result_port_bindings.iter().copied() {
+            result_ports.push(take_parent_port(reference, &mut parent_ports)?);
+        }
+        if parent_ports.iter().flatten().any(Option::is_some) {
+            return Err(invalid(
+                "LC color wiring leaves an unconsumed parent result port",
+            ));
+        }
+
+        let mut remap = vec![u32::MAX; components.len()];
+        let mut compact = Vec::new();
+        for (old_index, component) in components.into_iter().enumerate() {
+            if let Some(component) = component {
+                remap[old_index] = compact.len() as u32;
+                compact.push(component);
+            }
+        }
+        for binding in &mut result_ports {
+            binding.component_index = *remap
+                .get(binding.component_index as usize)
+                .ok_or_else(|| invalid("LC color result port references an absent component"))?;
+            if binding.component_index == u32::MAX {
+                return Err(invalid(
+                    "LC color result port references a consumed component",
+                ));
+            }
+        }
+        DynamicLCColorState::new_port_wired(result_color_shape_id, result_ports, compact)
+    }
+}
+
+fn take_parent_port(
+    reference: LCColorParentPort,
+    parent_ports: &mut [Vec<Option<LCColorPortBinding>>; 2],
+) -> RusticolResult<LCColorPortBinding> {
+    parent_ports
+        .get_mut(reference.parent_index())
+        .and_then(|ports| ports.get_mut(reference.port_index()))
+        .ok_or_else(|| invalid("LC color wiring references an absent parent result port"))?
+        .take()
+        .ok_or_else(|| invalid("LC color wiring consumes one parent result port twice"))
+}
+
+fn join_color_endpoints(
+    components: &mut [Option<LCColorComponent>],
+    parent_ports: &mut [Vec<Option<LCColorPortBinding>>; 2],
+    left_binding: LCColorPortBinding,
+    right_binding: LCColorPortBinding,
+) -> RusticolResult<()> {
+    let left_index = left_binding.component_index() as usize;
+    let right_index = right_binding.component_index() as usize;
+    if left_index == right_index {
+        if left_binding.endpoint() == right_binding.endpoint() {
+            return Err(invalid(
+                "LC color wiring cannot join the same endpoint of one strand",
+            ));
+        }
+        if parent_ports.iter().flatten().any(|binding| {
+            binding
+                .as_ref()
+                .is_some_and(|binding| binding.component_index() as usize == left_index)
+        }) {
+            return Err(invalid(
+                "LC color wiring closes a strand that still exposes a result port",
+            ));
+        }
+        let component = components
+            .get_mut(left_index)
+            .and_then(Option::take)
+            .ok_or_else(|| invalid("LC color wiring closes an absent strand"))?;
+        components[left_index] = Some(LCColorComponent::new(
+            LCColorComponentKind::Trace,
+            component.source_slots().to_vec(),
+        )?);
+        return Ok(());
+    }
+
+    let mut left = components
+        .get_mut(left_index)
+        .and_then(Option::take)
+        .ok_or_else(|| invalid("LC color wiring joins an absent left strand"))?;
+    let mut right = components
+        .get_mut(right_index)
+        .and_then(Option::take)
+        .ok_or_else(|| invalid("LC color wiring joins an absent right strand"))?;
+    let reverse_left = left_binding.endpoint() == LCColorEndpoint::Front;
+    let reverse_right = right_binding.endpoint() == LCColorEndpoint::Back;
+    if reverse_left {
+        left = left.reversed()?;
+    }
+    if reverse_right {
+        right = right.reversed()?;
+    }
+    let result_kind = if left.kind() == LCColorComponentKind::OpenString
+        || right.kind() == LCColorComponentKind::OpenString
+    {
+        LCColorComponentKind::OpenString
+    } else {
+        LCColorComponentKind::AdjointSegment
+    };
+    let word = left
+        .source_slots()
+        .iter()
+        .chain(right.source_slots())
+        .copied()
+        .collect();
+    let retained_index = left_index.min(right_index);
+    components[retained_index] = Some(LCColorComponent::new(result_kind, word)?);
+
+    for binding in parent_ports.iter_mut().flatten().flatten() {
+        let component_index = binding.component_index() as usize;
+        if component_index == left_index {
+            binding.component_index = retained_index as u32;
+            if reverse_left {
+                binding.endpoint = binding.endpoint.reversed();
+            }
+        } else if component_index == right_index {
+            binding.component_index = retained_index as u32;
+            if reverse_right {
+                binding.endpoint = binding.endpoint.reversed();
+            }
+        }
+    }
+    Ok(())
+}
+
+impl LCColorComponent {
+    pub fn new(kind: LCColorComponentKind, source_slots: Vec<u32>) -> RusticolResult<Self> {
+        if source_slots.is_empty() {
+            return Err(invalid(
+                "an LC color component cannot have an empty source word",
+            ));
+        }
+        if source_slots.len() > u32::MAX as usize {
+            return Err(invalid("LC color component exceeds the u32 ABI domain"));
+        }
+        let mut seen = BTreeSet::new();
+        if source_slots.iter().any(|slot| !seen.insert(*slot)) {
+            return Err(invalid(
+                "an LC color component cannot contain a source slot more than once",
+            ));
+        }
+        let source_slots = if kind == LCColorComponentKind::Trace {
+            canonical_trace_rotation(source_slots)
+        } else {
+            source_slots
+        };
+        Ok(Self {
+            kind,
+            source_slots: source_slots.into_boxed_slice(),
+        })
+    }
+
+    pub const fn kind(&self) -> LCColorComponentKind {
+        self.kind
+    }
+
+    pub fn source_slots(&self) -> &[u32] {
+        &self.source_slots
+    }
+
+    fn reversed(&self) -> RusticolResult<Self> {
+        Self::new(self.kind, self.source_slots.iter().rev().copied().collect())
+    }
+}
+
+/// Internable dynamic LC state, independent of physical sector identity.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct DynamicLCColorState {
+    output_color_shape_id: u32,
+    active_component_index: Option<u32>,
+    result_port_bindings: Box<[LCColorPortBinding]>,
+    components: Box<[LCColorComponent]>,
+}
+
+impl DynamicLCColorState {
+    pub fn new(
+        output_color_shape_id: u32,
+        active_component_index: Option<u32>,
+        components: Vec<LCColorComponent>,
+    ) -> RusticolResult<Self> {
+        let result_port_bindings = active_component_index
+            .map(|index| LCColorPortBinding::new(index, LCColorEndpoint::Back))
+            .into_iter()
+            .collect();
+        Self::new_port_wired(output_color_shape_id, result_port_bindings, components)
+    }
+
+    pub const fn output_color_shape_id(&self) -> u32 {
+        self.output_color_shape_id
+    }
+
+    pub fn components(&self) -> &[LCColorComponent] {
+        &self.components
+    }
+
+    pub const fn active_component_index(&self) -> Option<u32> {
+        self.active_component_index
+    }
+
+    pub fn active_component(&self) -> Option<&LCColorComponent> {
+        self.active_component_index
+            .map(|index| &self.components[index as usize])
+    }
+
+    pub(crate) fn reversed(&self) -> RusticolResult<Self> {
+        let components = self
+            .components
+            .iter()
+            .rev()
+            .map(LCColorComponent::reversed)
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let result_port_bindings = self
+            .result_port_bindings
+            .iter()
+            .rev()
+            .map(|binding| {
+                LCColorPortBinding::new(
+                    self.components.len() as u32 - 1 - binding.component_index,
+                    binding.endpoint.reversed(),
+                )
+            })
+            .collect();
+        Self::new_port_wired(self.output_color_shape_id, result_port_bindings, components)
+    }
+
+    pub(crate) fn pure_adjoint_word(&self) -> Option<&[u32]> {
+        if self.components.len() != 1
+            || self.active_component_index != Some(0)
+            || self.result_port_bindings.len() != 2
+        {
+            return None;
+        }
+        let exposes_front = self.result_port_bindings.iter().any(|binding| {
+            binding.component_index() == 0 && binding.endpoint() == LCColorEndpoint::Front
+        });
+        let exposes_back = self.result_port_bindings.iter().any(|binding| {
+            binding.component_index() == 0 && binding.endpoint() == LCColorEndpoint::Back
+        });
+        if !exposes_front || !exposes_back {
+            return None;
+        }
+        let component = &self.components[0];
+        (component.kind() == LCColorComponentKind::AdjointSegment)
+            .then_some(component.source_slots())
+    }
+
+    pub fn new_port_wired(
+        output_color_shape_id: u32,
+        result_port_bindings: Vec<LCColorPortBinding>,
+        components: Vec<LCColorComponent>,
+    ) -> RusticolResult<Self> {
+        if components.len() > u32::MAX as usize {
+            return Err(invalid("LC color forest exceeds the u32 ABI domain"));
+        }
+        let mut seen_slots = BTreeSet::new();
+        for component in &components {
+            if component
+                .source_slots()
+                .iter()
+                .any(|slot| !seen_slots.insert(*slot))
+            {
+                return Err(invalid(
+                    "a dynamic LC color state cannot duplicate colored source slots",
+                ));
+            }
+        }
+        let mut seen_ports = BTreeSet::new();
+        for binding in &result_port_bindings {
+            let component = components
+                .get(binding.component_index as usize)
+                .ok_or_else(|| invalid("LC color result port is outside the color forest"))?;
+            if component.kind() == LCColorComponentKind::Trace {
+                return Err(invalid("a closed LC trace cannot expose a result port"));
+            }
+            if !seen_ports.insert(*binding) {
+                return Err(invalid(
+                    "two LC color result ports cannot bind the same strand endpoint",
+                ));
+            }
+        }
+        let active_component_index = result_port_bindings
+            .first()
+            .map(|binding| binding.component_index())
+            .filter(|index| {
+                result_port_bindings
+                    .iter()
+                    .all(|binding| binding.component_index() == *index)
+            });
+        Ok(Self {
+            output_color_shape_id,
+            active_component_index,
+            result_port_bindings: result_port_bindings.into_boxed_slice(),
+            components: components.into_boxed_slice(),
+        })
+    }
+
+    pub fn result_port_bindings(&self) -> &[LCColorPortBinding] {
+        &self.result_port_bindings
+    }
+
+    /// Source lineage exposed by this current's ordered result color ports.
+    ///
+    /// Closed neutral currents deliberately return an empty lineage.  Open
+    /// fermion and adjoint currents retain only the source endpoints that can
+    /// flow into a later recurrence, rather than the history of already closed
+    /// quark lines used to construct them.
+    pub fn result_port_lineage_source_slots(&self) -> RusticolResult<Vec<u32>> {
+        self.result_port_bindings
+            .iter()
+            .map(|binding| {
+                let component = self
+                    .components
+                    .get(binding.component_index() as usize)
+                    .ok_or_else(|| invalid("LC color result-port component disappeared"))?;
+                binding.endpoint().source_slot(component)
+            })
+            .collect()
+    }
+}
+
+/// Owns the only mapping from semantic LC color states to recurrence IDs.
+#[derive(Clone, Debug, Default)]
+pub struct DynamicLCColorStateInterner {
+    states: Vec<DynamicLCColorState>,
+    ids: HashMap<DynamicLCColorState, DynamicLCColorStateId>,
+}
+
+impl DynamicLCColorStateInterner {
+    pub fn intern(&mut self, state: DynamicLCColorState) -> RusticolResult<DynamicLCColorStateId> {
+        if let Some(id) = self.ids.get(&state) {
+            return Ok(*id);
+        }
+        let raw_id = u32::try_from(self.states.len())
+            .map_err(|_| invalid("dynamic LC color-state interner exceeds u32"))?;
+        let id = DynamicLCColorStateId::from_interner(raw_id);
+        self.states.push(state.clone());
+        self.ids.insert(state, id);
+        Ok(id)
+    }
+
+    pub fn get(&self, id: DynamicLCColorStateId) -> Option<&DynamicLCColorState> {
+        self.states.get(id.get() as usize)
+    }
+
+    pub fn len(&self) -> usize {
+        self.states.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.states.is_empty()
+    }
+
+    pub fn into_states(self) -> Vec<DynamicLCColorState> {
+        self.states
+    }
+}
+
+/// Exact operation performed by one compiler-certified LC transition term.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub enum LCColorComponentOperation {
+    ConcatenateJoin = 0,
+    ConcatenateKeep = 1,
+    InheritLeft = 2,
+    InheritRight = 3,
+    Empty = 4,
+    Close = 5,
+}
+
+impl TryFrom<u8> for LCColorComponentOperation {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::ConcatenateJoin),
+            1 => Ok(Self::ConcatenateKeep),
+            2 => Ok(Self::InheritLeft),
+            3 => Ok(Self::InheritRight),
+            4 => Ok(Self::Empty),
+            5 => Ok(Self::Close),
+            _ => Err(invalid(format!(
+                "unsupported LC color component operation {value}"
+            ))),
+        }
+    }
+}
+
+/// Executable color-state witness emitted by the model compiler.
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct LCColorTransitionWitness {
+    input_permutation: [u8; 2],
+    reverse_parent_mask: u8,
+    operation: LCColorComponentOperation,
+    result_component_kind: Option<LCColorComponentKind>,
+    result_component_role: LCColorComponentRole,
+    result_color_shape_id: Option<u32>,
+    port_wiring: LCColorPortWiring,
+    exact_factor: ExactComplexRational,
+    proof_digest: SemanticDigest,
+}
+
+impl LCColorTransitionWitness {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        input_permutation: [u8; 2],
+        reverse_parent_mask: u8,
+        operation: LCColorComponentOperation,
+        result_component_kind: Option<LCColorComponentKind>,
+        result_component_role: LCColorComponentRole,
+        result_color_shape_id: Option<u32>,
+        port_wiring: LCColorPortWiring,
+        exact_factor: ExactComplexRational,
+        proof_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        if input_permutation != [0, 1] && input_permutation != [1, 0] {
+            return Err(invalid(
+                "LC color witness input permutation must be [0, 1] or [1, 0]",
+            ));
+        }
+        if reverse_parent_mask > 0b11 {
+            return Err(invalid(
+                "LC color witness has an invalid parent-reversal mask",
+            ));
+        }
+        if exact_factor.is_zero() {
+            return Err(invalid(
+                "an executable LC color witness cannot have zero factor",
+            ));
+        }
+        match operation {
+            LCColorComponentOperation::Close => {
+                if result_component_role != LCColorComponentRole::None
+                    || result_color_shape_id.is_some()
+                {
+                    return Err(invalid(
+                        "an LC closure witness cannot declare an active result color state",
+                    ));
+                }
+            }
+            LCColorComponentOperation::ConcatenateJoin => {
+                if result_component_kind.is_none()
+                    || result_component_role == LCColorComponentRole::None
+                    || result_color_shape_id.is_none()
+                {
+                    return Err(invalid(
+                        "an LC join witness requires result component, role, and shape contracts",
+                    ));
+                }
+            }
+            LCColorComponentOperation::InheritLeft | LCColorComponentOperation::InheritRight => {
+                if result_component_kind.is_some()
+                    || result_component_role != LCColorComponentRole::Active
+                    || result_color_shape_id.is_none()
+                {
+                    return Err(invalid(
+                        "an LC inheritance witness requires an active result role and shape",
+                    ));
+                }
+            }
+            _ => {
+                if result_component_kind.is_some()
+                    || result_component_role != LCColorComponentRole::None
+                    || result_color_shape_id.is_none()
+                {
+                    return Err(invalid(
+                        "a passive LC witness requires only a result shape contract",
+                    ));
+                }
+            }
+        }
+        Ok(Self {
+            input_permutation,
+            reverse_parent_mask,
+            operation,
+            result_component_kind,
+            result_component_role,
+            result_color_shape_id,
+            port_wiring,
+            exact_factor,
+            proof_digest,
+        })
+    }
+
+    pub const fn exact_factor(&self) -> ExactComplexRational {
+        self.exact_factor
+    }
+
+    pub const fn proof_digest(&self) -> SemanticDigest {
+        self.proof_digest
+    }
+
+    pub fn apply(
+        &self,
+        left: &DynamicLCColorState,
+        right: &DynamicLCColorState,
+    ) -> RusticolResult<Option<DynamicLCColorState>> {
+        let mut parents = [left.clone(), right.clone()];
+        for (index, parent) in parents.iter_mut().enumerate() {
+            if self.reverse_parent_mask & (1 << index) != 0 {
+                *parent = parent.reversed()?;
+            }
+        }
+        if self.operation == LCColorComponentOperation::Close {
+            self.closed_components(&parents[0], &parents[1])?;
+            return Ok(None);
+        }
+        Ok(Some(
+            self.port_wiring.apply(
+                &parents[0],
+                &parents[1],
+                self.result_color_shape_id
+                    .expect("validated non-closure result color shape"),
+            )?,
+        ))
+    }
+
+    pub fn closed_components(
+        &self,
+        left: &DynamicLCColorState,
+        right: &DynamicLCColorState,
+    ) -> RusticolResult<Vec<LCColorComponent>> {
+        if self.operation != LCColorComponentOperation::Close {
+            return Err(invalid(
+                "closed-components is available only for an LC closure witness",
+            ));
+        }
+        let mut parents = [left.clone(), right.clone()];
+        for (index, parent) in parents.iter_mut().enumerate() {
+            if self.reverse_parent_mask & (1 << index) != 0 {
+                *parent = parent.reversed()?;
+            }
+        }
+        let closed = self.port_wiring.apply(&parents[0], &parents[1], 0)?;
+        if !closed.result_port_bindings().is_empty() {
+            return Err(invalid("an LC closure leaves an exposed color port"));
+        }
+        Ok(closed.components().to_vec())
+    }
+}
+
+fn canonical_trace_rotation(mut source_slots: Vec<u32>) -> Vec<u32> {
+    let length = source_slots.len();
+    if length < 2 {
+        return source_slots;
+    }
+
+    // Booth's least-rotation scan compares every cyclic suffix at most a
+    // constant number of times. This preserves the exact lexicographic
+    // canonical form without materializing all O(n) rotations.
+    let mut left = 0usize;
+    let mut right = 1usize;
+    let mut matched = 0usize;
+    while left < length && right < length && matched < length {
+        let left_value = source_slots[(left + matched) % length];
+        let right_value = source_slots[(right + matched) % length];
+        match left_value.cmp(&right_value) {
+            std::cmp::Ordering::Equal => matched += 1,
+            std::cmp::Ordering::Greater => {
+                left += matched + 1;
+                if left == right {
+                    left += 1;
+                }
+                matched = 0;
+            }
+            std::cmp::Ordering::Less => {
+                right += matched + 1;
+                if left == right {
+                    right += 1;
+                }
+                matched = 0;
+            }
+        }
+    }
+    source_slots.rotate_left(left.min(right) % length);
+    source_slots
+}
+
+#[cfg(test)]
+mod tests {
+    use super::canonical_trace_rotation;
+
+    fn reference_trace_rotation(source_slots: &[u32]) -> Vec<u32> {
+        (0..source_slots.len())
+            .map(|offset| {
+                source_slots[offset..]
+                    .iter()
+                    .chain(&source_slots[..offset])
+                    .copied()
+                    .collect::<Vec<_>>()
+            })
+            .min()
+            .unwrap_or_default()
+    }
+
+    #[test]
+    fn linear_trace_rotation_matches_exhaustive_reference() {
+        for length in 0..=8 {
+            let case_count = 3_usize.pow(length as u32);
+            for mut encoded in 0..case_count {
+                let mut source_slots = Vec::with_capacity(length);
+                for _ in 0..length {
+                    source_slots.push((encoded % 3) as u32);
+                    encoded /= 3;
+                }
+                assert_eq!(
+                    canonical_trace_rotation(source_slots.clone()),
+                    reference_trace_rotation(&source_slots),
+                    "source slots {source_slots:?}",
+                );
+            }
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/color_contraction.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/color_contraction.rs
new file mode 100644
index 0000000000..0f11fdbffd
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/color_contraction.rs
@@ -0,0 +1,3677 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Process-owned fixed-width recurrence color-contraction payload.
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::iter::FusedIterator;
+use std::sync::Arc;
+
+use sha2::{Digest, Sha256};
+
+use super::exact::{ExactComplexRational, ExactRational};
+use super::symmetric_group_fft::{
+    SymmetricGroupComplex64, SymmetricGroupFftPlan, SymmetricGroupFftWorkspace,
+};
+use crate::{RusticolError, RusticolResult};
+
+pub const RECURRENCE_COLOR_CONTRACTION_CODEC_ABI: &str =
+    "pyamplicol-recurrence-color-contraction-v3";
+
+const MAGIC: &[u8; 8] = b"PACRCLR3";
+const VERSION: u32 = 3;
+const HEADER_BYTES: usize = 120;
+const ENTRY_BYTES: usize = 36;
+const EXACT_FACTOR_BYTES: usize = 64;
+// The subgroup order must fit the codec's u32 local-group count.
+const MAX_FACTOR_RANK: u32 = u32::BITS - 1;
+const MAX_SYMMETRIC_GROUP_DEGREE: u32 = 10;
+// A batching target, not a resource limit: a single large lane and explicitly
+// requested workspace growth may exceed it.
+const TARGET_SYMMETRIC_GROUP_LANE_WORKSPACE_BYTES: usize = 512 * 1024 * 1024;
+const ZERO_SECTOR_OWNER: u32 = u32::MAX;
+const FLAG_INCLUDES_COLOR_FACTOR: u32 = 1 << 0;
+const KNOWN_FLAGS: u32 = FLAG_INCLUDES_COLOR_FACTOR;
+
+fn malformed(message: impl Into<String>) -> RusticolError {
+    RusticolError::artifact(format!(
+        "recurrence color-contraction codec: {}",
+        message.into()
+    ))
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u32)]
+pub enum RecurrenceColorAccuracy {
+    Nlc = 1,
+    Full = 2,
+}
+
+impl RecurrenceColorAccuracy {
+    fn decode(value: u32) -> RusticolResult<Self> {
+        match value {
+            1 => Ok(Self::Nlc),
+            2 => Ok(Self::Full),
+            _ => Err(malformed(format!(
+                "unknown color-accuracy discriminant {value}"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u32)]
+pub enum RecurrenceColorStorage {
+    Expanded = 1,
+    Repeated = 2,
+    ConvolutionKernels = 3,
+}
+
+impl RecurrenceColorStorage {
+    fn decode(value: u32) -> RusticolResult<Self> {
+        match value {
+            1 => Ok(Self::Expanded),
+            2 => Ok(Self::Repeated),
+            3 => Ok(Self::ConvolutionKernels),
+            _ => Err(malformed(format!(
+                "unknown color-contraction storage discriminant {value}"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct RawColorContractionEntry {
+    pub left_group_id: u32,
+    pub right_group_id: u32,
+    pub weight_re: f64,
+    pub weight_im: f64,
+    pub symmetry_factor: f64,
+    pub exact_factor_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct CanonicalColorContractionEntry {
+    pub left_group_id: u32,
+    pub right_group_id: u32,
+    pub left_destination_id: u32,
+    pub right_destination_id: u32,
+    pub weight_re: f64,
+    pub weight_im: f64,
+    pub symmetry_factor: f64,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct RuntimeColorContractionEntry {
+    pub left_destination_id: u32,
+    pub right_destination_id: u32,
+    pub coefficient_re: f64,
+    pub coefficient_im: f64,
+}
+
+impl RuntimeColorContractionEntry {
+    /// Evaluate `Re(coefficient * left * conj(right))` in the canonical
+    /// expanded-contraction operation order.
+    ///
+    /// The coefficient supplied by [`RecurrenceColorContraction::runtime_entries`]
+    /// already includes the upper-triangle symmetry factor.
+    #[inline(always)]
+    pub fn contract_real_bilinear(
+        self,
+        left_re: f64,
+        left_im: f64,
+        right_re: f64,
+        right_im: f64,
+    ) -> f64 {
+        let product_re = left_re.mul_add(right_re, left_im * right_im);
+        let product_im = left_im.mul_add(right_re, -left_re * right_im);
+        self.coefficient_re
+            .mul_add(product_re, -self.coefficient_im * product_im)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum FactorizedColorContractionKind {
+    KleinFourWalsh,
+    ElementaryAbelianWalsh,
+    SymmetricGroupFourier,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FactorizedColorContraction {
+    kind: FactorizedColorContractionKind,
+    rank: u32,
+    coset_count: usize,
+    coset_indices: Vec<u32>,
+}
+
+impl FactorizedColorContraction {
+    pub fn kind(&self) -> FactorizedColorContractionKind {
+        self.kind
+    }
+
+    pub fn rank(&self) -> u32 {
+        self.rank
+    }
+
+    pub fn subgroup_order(&self) -> usize {
+        match self.kind {
+            FactorizedColorContractionKind::KleinFourWalsh
+            | FactorizedColorContractionKind::ElementaryAbelianWalsh => 1usize << self.rank,
+            FactorizedColorContractionKind::SymmetricGroupFourier => {
+                checked_factorial(self.rank).expect("validated symmetric-group degree")
+            }
+        }
+    }
+
+    pub fn coset_count(&self) -> usize {
+        self.coset_count
+    }
+
+    pub fn coset(&self, index: usize) -> Option<&[u32]> {
+        let order = self.subgroup_order();
+        let start = index.checked_mul(order)?;
+        self.coset_indices.get(start..start.checked_add(order)?)
+    }
+
+    pub fn coset_indices(&self) -> &[u32] {
+        &self.coset_indices
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct RuntimeFactorizedColorContractionEntry {
+    pub left_group_index: u32,
+    pub right_group_index: u32,
+    pub coefficient_re: f64,
+    pub coefficient_im: f64,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct RuntimeFactorizedColorContraction {
+    subgroup_order: usize,
+    cosets: Vec<Vec<u32>>,
+    entries: Vec<RuntimeFactorizedColorContractionEntry>,
+    amplitude_scale: f64,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct RuntimeSymmetricGroupKernel {
+    left_channel_index: u32,
+    right_channel_index: u32,
+    pair_scale: f64,
+    fourier_coefficients: Box<[f64]>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+struct RuntimeSymmetricGroupLowRankBlock {
+    rank: usize,
+    /// Column-major `dimension x rank` real factor in the FFT block's
+    /// original Young-basis order.
+    factors: Box<[f64]>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+struct RuntimeSymmetricGroupLowRankKernel {
+    /// Block-aligned scalar factors for the corresponding dense kernel.
+    /// Empty for cross-channel kernels and diagonal kernels with no accepted
+    /// factor.
+    blocks: Box<[Option<RuntimeSymmetricGroupLowRankBlock>]>,
+}
+
+impl RuntimeSymmetricGroupKernel {
+    pub fn left_channel_index(&self) -> u32 {
+        self.left_channel_index
+    }
+
+    pub fn right_channel_index(&self) -> u32 {
+        self.right_channel_index
+    }
+
+    /// Upper-triangle channel-pair scale: one on the diagonal and two for a
+    /// cross-channel kernel whose Hermitian-adjoint partner is implicit.
+    pub fn pair_scale(&self) -> f64 {
+        self.pair_scale
+    }
+
+    /// Packed real Young blocks for the unnormalised transform of
+    /// `r -> k_cd(r^-1)`.  Blocks are column-major in the shared FFT plan's
+    /// canonical order.
+    pub fn fourier_coefficients(&self) -> &[f64] {
+        &self.fourier_coefficients
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct RuntimeSymmetricGroupColorContraction {
+    degree: u32,
+    group_order: usize,
+    channel_count: usize,
+    local_group_count: usize,
+    fft_plan: Arc<SymmetricGroupFftPlan>,
+    kernels: Arc<[RuntimeSymmetricGroupKernel]>,
+    scalar_same_channel_low_rank_kernels: Option<Arc<[RuntimeSymmetricGroupLowRankKernel]>>,
+    residual_entries: Arc<[RuntimeFactorizedColorContractionEntry]>,
+}
+
+impl PartialEq for RuntimeSymmetricGroupColorContraction {
+    fn eq(&self, other: &Self) -> bool {
+        self.degree == other.degree
+            && self.group_order == other.group_order
+            && self.channel_count == other.channel_count
+            && self.local_group_count == other.local_group_count
+            && self.kernels.as_ref() == other.kernels.as_ref()
+            && self.scalar_same_channel_low_rank_kernels
+                == other.scalar_same_channel_low_rank_kernels
+            && self.residual_entries.as_ref() == other.residual_entries.as_ref()
+    }
+}
+
+impl RuntimeSymmetricGroupColorContraction {
+    pub fn degree(&self) -> u32 {
+        self.degree
+    }
+
+    pub fn group_order(&self) -> usize {
+        self.group_order
+    }
+
+    pub fn channel_count(&self) -> usize {
+        self.channel_count
+    }
+
+    pub fn local_group_count(&self) -> usize {
+        self.local_group_count
+    }
+
+    pub fn kernels(&self) -> &[RuntimeSymmetricGroupKernel] {
+        self.kernels.as_ref()
+    }
+
+    pub fn residual_entries(&self) -> &[RuntimeFactorizedColorContractionEntry] {
+        self.residual_entries.as_ref()
+    }
+
+    pub(crate) fn workspace(
+        &self,
+        lane_capacity: usize,
+    ) -> RusticolResult<RuntimeSymmetricGroupColorWorkspace> {
+        RuntimeSymmetricGroupColorWorkspace::new(self, lane_capacity)
+    }
+
+    pub(crate) fn bounded_lane_capacity(&self, requested: usize) -> RusticolResult<usize> {
+        if requested == 0 {
+            return Err(RusticolError::invalid_argument(
+                "symmetric-group requested lane capacity must be positive",
+            ));
+        }
+        let complex_values_per_lane = self
+            .local_group_count
+            .checked_add(
+                self.channel_count
+                    .checked_mul(self.group_order)
+                    .ok_or_else(|| {
+                        malformed("symmetric-group transformed lane size overflows usize")
+                    })?,
+            )
+            .and_then(|value| value.checked_add(self.group_order))
+            .and_then(|value| {
+                value.checked_add(
+                    self.fft_plan
+                        .maximum_block_dimension()
+                        .checked_mul(self.fft_plan.maximum_block_dimension())?,
+                )
+            })
+            .ok_or_else(|| malformed("symmetric-group lane workspace size overflows usize"))?;
+        let bytes_per_lane = complex_values_per_lane
+            .checked_mul(std::mem::size_of::<SymmetricGroupComplex64>())
+            .and_then(|value| value.checked_add(std::mem::size_of::<f64>()))
+            .ok_or_else(|| malformed("symmetric-group lane workspace bytes overflow usize"))?;
+        let budget_lanes = (TARGET_SYMMETRIC_GROUP_LANE_WORKSPACE_BYTES / bytes_per_lane).max(1);
+        Ok(requested.min(budget_lanes))
+    }
+
+    /// Reduce one component/helicity tile.  A call that exceeds the retained
+    /// workspace high-water mark may grow it fallibly; repeated calls within
+    /// the retained capacity allocate nothing.  The amplitude accessor
+    /// receives a normalized local-group index and active lane.
+    pub(crate) fn reduce_lanes(
+        &self,
+        workspace: &mut RuntimeSymmetricGroupColorWorkspace,
+        lane_count: usize,
+        mut amplitude: impl FnMut(usize, usize) -> RusticolResult<SymmetricGroupComplex64>,
+    ) -> RusticolResult<()> {
+        workspace.ensure_lane_capacity(self, lane_count)?;
+        workspace.validate(self, lane_count)?;
+        workspace.reduced[..lane_count].fill(0.0);
+
+        for group in 0..self.local_group_count {
+            let start = group * lane_count;
+            for lane in 0..lane_count {
+                workspace.gathered[start + lane] = amplitude(group, lane)?;
+            }
+        }
+
+        // Residual and eligible/residual cross rows are contracted while the
+        // gathered amplitudes are still in their authenticated local order.
+        for entry in self.residual_entries.iter() {
+            let left = entry.left_group_index as usize * lane_count;
+            let right = entry.right_group_index as usize * lane_count;
+            for lane in 0..lane_count {
+                let left_value = workspace.gathered[left + lane];
+                let right_value = workspace.gathered[right + lane];
+                let product_re = left_value
+                    .0
+                    .mul_add(right_value.0, left_value.1 * right_value.1);
+                let product_im = left_value
+                    .1
+                    .mul_add(right_value.0, -left_value.0 * right_value.1);
+                workspace.reduced[lane] += entry
+                    .coefficient_re
+                    .mul_add(product_re, -entry.coefficient_im * product_im);
+            }
+        }
+
+        let channel_stride = self.group_order * lane_count;
+        for channel in 0..self.channel_count {
+            let start = channel * channel_stride;
+            self.fft_plan.forward_lanes(
+                lane_count,
+                &workspace.gathered[start..start + channel_stride],
+                &mut workspace.transformed[start..start + channel_stride],
+                &mut workspace.fft,
+            )?;
+        }
+
+        if let Some(low_rank_kernels) = self.scalar_same_channel_low_rank_kernels.as_deref() {
+            self.reduce_transformed_low_rank(
+                workspace,
+                lane_count,
+                channel_stride,
+                low_rank_kernels,
+            );
+        } else {
+            self.reduce_transformed_dense(workspace, lane_count, channel_stride);
+        }
+        Ok(())
+    }
+
+    #[inline(never)]
+    fn reduce_transformed_dense(
+        &self,
+        workspace: &mut RuntimeSymmetricGroupColorWorkspace,
+        lane_count: usize,
+        channel_stride: usize,
+    ) {
+        let normalization = 1.0 / self.group_order as f64;
+        for kernel in self.kernels.iter() {
+            let left_channel = kernel.left_channel_index as usize;
+            let right_channel = kernel.right_channel_index as usize;
+            let left = &workspace.transformed
+                [left_channel * channel_stride..(left_channel + 1) * channel_stride];
+            let right = &workspace.transformed
+                [right_channel * channel_stride..(right_channel + 1) * channel_stride];
+            for block in self.fft_plan.blocks() {
+                let dimension = block.dimension();
+                let offset = block.coefficient_offset();
+                let coefficients =
+                    &kernel.fourier_coefficients[offset..offset + block.coefficient_count()];
+                let block_weight = dimension as f64 * normalization * kernel.pair_scale;
+                if left_channel == right_channel {
+                    contract_real_hermitian_same_channel_block(
+                        left,
+                        coefficients,
+                        dimension,
+                        offset,
+                        lane_count,
+                        lane_count,
+                        block_weight,
+                        &mut workspace.reduced,
+                    );
+                } else {
+                    contract_general_cross_block(
+                        left,
+                        right,
+                        coefficients,
+                        dimension,
+                        offset,
+                        lane_count,
+                        lane_count,
+                        block_weight,
+                        &mut workspace.reduced,
+                    );
+                }
+            }
+        }
+    }
+
+    #[inline(never)]
+    fn reduce_transformed_low_rank(
+        &self,
+        workspace: &mut RuntimeSymmetricGroupColorWorkspace,
+        lane_count: usize,
+        channel_stride: usize,
+        low_rank_kernels: &[RuntimeSymmetricGroupLowRankKernel],
+    ) {
+        debug_assert_eq!(low_rank_kernels.len(), self.kernels.len());
+        let normalization = 1.0 / self.group_order as f64;
+        for (kernel_index, kernel) in self.kernels.iter().enumerate() {
+            let left_channel = kernel.left_channel_index as usize;
+            let right_channel = kernel.right_channel_index as usize;
+            let left = &workspace.transformed
+                [left_channel * channel_stride..(left_channel + 1) * channel_stride];
+            let right = &workspace.transformed
+                [right_channel * channel_stride..(right_channel + 1) * channel_stride];
+            if left_channel == right_channel {
+                let scalar_blocks: &[Option<RuntimeSymmetricGroupLowRankBlock>] = low_rank_kernels
+                    .get(kernel_index)
+                    .map(|kernel| kernel.blocks.as_ref())
+                    .unwrap_or_default();
+                if scalar_blocks.is_empty() {
+                    for block in self.fft_plan.blocks() {
+                        let dimension = block.dimension();
+                        let offset = block.coefficient_offset();
+                        let coefficients = &kernel.fourier_coefficients
+                            [offset..offset + block.coefficient_count()];
+                        let block_weight = dimension as f64 * normalization * kernel.pair_scale;
+                        contract_real_hermitian_same_channel_block(
+                            left,
+                            coefficients,
+                            dimension,
+                            offset,
+                            lane_count,
+                            lane_count,
+                            block_weight,
+                            &mut workspace.reduced,
+                        );
+                    }
+                } else {
+                    for (block_index, block) in self.fft_plan.blocks().enumerate() {
+                        let dimension = block.dimension();
+                        let offset = block.coefficient_offset();
+                        let coefficients = &kernel.fourier_coefficients
+                            [offset..offset + block.coefficient_count()];
+                        let block_weight = dimension as f64 * normalization * kernel.pair_scale;
+                        contract_real_hermitian_same_channel_block_opportunistic(
+                            left,
+                            coefficients,
+                            scalar_blocks.get(block_index).and_then(Option::as_ref),
+                            dimension,
+                            offset,
+                            lane_count,
+                            lane_count,
+                            block_weight,
+                            &mut workspace.reduced,
+                        );
+                    }
+                }
+            } else {
+                for block in self.fft_plan.blocks() {
+                    let dimension = block.dimension();
+                    let offset = block.coefficient_offset();
+                    let coefficients =
+                        &kernel.fourier_coefficients[offset..offset + block.coefficient_count()];
+                    let block_weight = dimension as f64 * normalization * kernel.pair_scale;
+                    contract_general_cross_block(
+                        left,
+                        right,
+                        coefficients,
+                        dimension,
+                        offset,
+                        lane_count,
+                        lane_count,
+                        block_weight,
+                        &mut workspace.reduced,
+                    );
+                }
+            }
+        }
+    }
+}
+
+/// Process-local mutable storage shared by the recurrence and on-the-fly
+/// contraction seams. Capacity starts at the first positive reduction size,
+/// grows fallibly up to the bounded point-tile high-water mark, and never
+/// shrinks; every transform keeps the point lane as its innermost coordinate.
+#[derive(Debug)]
+pub(crate) struct RuntimeSymmetricGroupColorWorkspace {
+    degree: u32,
+    group_order: usize,
+    channel_count: usize,
+    local_group_count: usize,
+    lane_capacity: usize,
+    gathered: Vec<SymmetricGroupComplex64>,
+    transformed: Vec<SymmetricGroupComplex64>,
+    reduced: Vec<f64>,
+    fft: SymmetricGroupFftWorkspace,
+}
+
+impl RuntimeSymmetricGroupColorWorkspace {
+    fn new(
+        contraction: &RuntimeSymmetricGroupColorContraction,
+        lane_capacity: usize,
+    ) -> RusticolResult<Self> {
+        if lane_capacity == 0 {
+            return Err(RusticolError::invalid_argument(
+                "symmetric-group color workspace lane capacity must be positive",
+            ));
+        }
+        let gathered_count = contraction
+            .local_group_count
+            .checked_mul(lane_capacity)
+            .ok_or_else(|| malformed("symmetric-group gathered workspace size overflows usize"))?;
+        let transformed_count = contraction
+            .channel_count
+            .checked_mul(contraction.group_order)
+            .and_then(|value| value.checked_mul(lane_capacity))
+            .ok_or_else(|| {
+                malformed("symmetric-group transformed workspace size overflows usize")
+            })?;
+        let mut gathered = Vec::new();
+        gathered
+            .try_reserve_exact(gathered_count)
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "symmetric-group gathered workspace allocation failed: {error}"
+                ))
+            })?;
+        gathered.resize(gathered_count, (0.0, 0.0));
+        let mut transformed = Vec::new();
+        transformed
+            .try_reserve_exact(transformed_count)
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "symmetric-group transformed workspace allocation failed: {error}"
+                ))
+            })?;
+        transformed.resize(transformed_count, (0.0, 0.0));
+        let mut reduced = Vec::new();
+        reduced.try_reserve_exact(lane_capacity).map_err(|error| {
+            RusticolError::internal(format!(
+                "symmetric-group reduced workspace allocation failed: {error}"
+            ))
+        })?;
+        reduced.resize(lane_capacity, 0.0);
+        let fft = contraction.fft_plan.workspace(lane_capacity)?;
+        Ok(Self {
+            degree: contraction.degree,
+            group_order: contraction.group_order,
+            channel_count: contraction.channel_count,
+            local_group_count: contraction.local_group_count,
+            lane_capacity,
+            gathered,
+            transformed,
+            reduced,
+            fft,
+        })
+    }
+
+    fn validate(
+        &self,
+        contraction: &RuntimeSymmetricGroupColorContraction,
+        lane_count: usize,
+    ) -> RusticolResult<()> {
+        if lane_count == 0 || lane_count > self.lane_capacity {
+            return Err(RusticolError::invalid_argument(
+                "symmetric-group color reduction exceeds its positive lane capacity",
+            ));
+        }
+        if self.degree != contraction.degree
+            || self.group_order != contraction.group_order
+            || self.channel_count != contraction.channel_count
+            || self.local_group_count != contraction.local_group_count
+        {
+            return Err(RusticolError::integrity(
+                "symmetric-group color workspace does not match its contraction plan",
+            ));
+        }
+        Ok(())
+    }
+
+    pub(crate) fn ensure_lane_capacity(
+        &mut self,
+        contraction: &RuntimeSymmetricGroupColorContraction,
+        lane_count: usize,
+    ) -> RusticolResult<()> {
+        if lane_count <= self.lane_capacity {
+            return Ok(());
+        }
+        *self = Self::new(contraction, lane_count)?;
+        Ok(())
+    }
+
+    #[cfg(test)]
+    pub(crate) const fn lane_capacity(&self) -> usize {
+        self.lane_capacity
+    }
+
+    pub(crate) fn reduced(&self, lane_count: usize) -> RusticolResult<&[f64]> {
+        if lane_count == 0 || lane_count > self.lane_capacity {
+            return Err(RusticolError::invalid_argument(
+                "symmetric-group reduced lane view is outside its workspace",
+            ));
+        }
+        Ok(&self.reduced[..lane_count])
+    }
+}
+
+const LOW_RANK_PIVOT_TOLERANCE_MULTIPLIER: f64 = 64.0;
+const LOW_RANK_MODE_BLOCK: usize = 4;
+
+fn compile_scalar_same_channel_low_rank_block(
+    kernel: &[f64],
+    dimension: usize,
+) -> Option<RuntimeSymmetricGroupLowRankBlock> {
+    if dimension == 0 || kernel.len() != dimension.checked_mul(dimension)? {
+        return None;
+    }
+
+    // The scalar dense evaluator pairs K_ci and K_ic.  Factor exactly that
+    // effective real-symmetric matrix rather than either rounded triangle.
+    let mut effective = vec![0.0; kernel.len()];
+    for column in 0..dimension {
+        for row in 0..=column {
+            let value = if row == column {
+                kernel[column * dimension + row]
+            } else {
+                0.5 * kernel[column * dimension + row] + 0.5 * kernel[row * dimension + column]
+            };
+            if !value.is_finite() {
+                return None;
+            }
+            effective[column * dimension + row] = value;
+            effective[row * dimension + column] = value;
+        }
+    }
+
+    let scale = (0..dimension)
+        .map(|index| effective[index * dimension + index])
+        .fold(f64::NEG_INFINITY, f64::max);
+    if !scale.is_finite() || scale < 0.0 {
+        return None;
+    }
+    let tolerance = LOW_RANK_PIVOT_TOLERANCE_MULTIPLIER * f64::EPSILON * dimension as f64 * scale;
+    if !tolerance.is_finite() {
+        return None;
+    }
+
+    let mut residual_diagonal = (0..dimension)
+        .map(|index| effective[index * dimension + index])
+        .collect::<Vec<_>>();
+    if residual_diagonal.iter().any(|&value| value < -tolerance) {
+        return None;
+    }
+    for value in &mut residual_diagonal {
+        if *value < 0.0 {
+            *value = 0.0;
+        }
+    }
+
+    let mut selected = vec![false; dimension];
+    let mut factors = Vec::<f64>::with_capacity(kernel.len());
+    let mut rank = 0usize;
+    loop {
+        // Ascending traversal plus strict comparison makes equal pivots choose
+        // the lowest original Young-basis index deterministically.
+        let mut pivot = None;
+        for index in 0..dimension {
+            if selected[index] {
+                continue;
+            }
+            if residual_diagonal[index] < -tolerance {
+                return None;
+            }
+            if pivot.is_none_or(|best| residual_diagonal[index] > residual_diagonal[best]) {
+                pivot = Some(index);
+            }
+        }
+        let Some(pivot) = pivot else {
+            break;
+        };
+        let pivot_value = residual_diagonal[pivot];
+        if pivot_value <= tolerance {
+            break;
+        }
+        let pivot_root = pivot_value.sqrt();
+        if !pivot_root.is_finite() || pivot_root == 0.0 {
+            return None;
+        }
+
+        let mut factor_column = vec![0.0; dimension];
+        factor_column[pivot] = pivot_root;
+        for row in 0..dimension {
+            if row == pivot || selected[row] {
+                continue;
+            }
+            let mut value = effective[pivot * dimension + row];
+            for previous in 0..rank {
+                value = (-factors[previous * dimension + row])
+                    .mul_add(factors[previous * dimension + pivot], value);
+            }
+            value /= pivot_root;
+            if !value.is_finite() {
+                return None;
+            }
+            factor_column[row] = value;
+        }
+
+        selected[pivot] = true;
+        residual_diagonal[pivot] = 0.0;
+        for row in 0..dimension {
+            if selected[row] {
+                continue;
+            }
+            let value = factor_column[row];
+            let updated = (-value).mul_add(value, residual_diagonal[row]);
+            if !updated.is_finite() || updated < -tolerance {
+                return None;
+            }
+            residual_diagonal[row] = if updated < 0.0 { 0.0 } else { updated };
+        }
+        factors.extend_from_slice(&factor_column);
+        rank += 1;
+        // Factor cost grows monotonically with rank. Once this block cannot
+        // clear the conservative warm-work gate, no later pivot can recover.
+        if !low_rank_scalar_cost_is_profitable(dimension, rank) {
+            return None;
+        }
+    }
+
+    if !low_rank_scalar_cost_is_profitable(dimension, rank)
+        || !low_rank_factor_reconstructs_effective_kernel(
+            &effective, dimension, rank, &factors, tolerance,
+        )
+    {
+        return None;
+    }
+    Some(RuntimeSymmetricGroupLowRankBlock {
+        rank,
+        factors: factors.into_boxed_slice(),
+    })
+}
+
+fn low_rank_scalar_cost_is_profitable(dimension: usize, rank: usize) -> bool {
+    let dimension = dimension as u128;
+    let rank = rank as u128;
+    let factor_cost = dimension * rank * (dimension + 1);
+    let dense_cost = dimension * (dimension + 1) * (dimension + 1) / 2;
+    factor_cost * 10 <= dense_cost * 9
+}
+
+fn compact_scalar_same_channel_blocks(
+    blocks: Vec<Option<RuntimeSymmetricGroupLowRankBlock>>,
+) -> Box<[Option<RuntimeSymmetricGroupLowRankBlock>]> {
+    if blocks.iter().all(Option::is_none) {
+        Box::default()
+    } else {
+        blocks.into_boxed_slice()
+    }
+}
+
+fn low_rank_factor_reconstructs_effective_kernel(
+    effective: &[f64],
+    dimension: usize,
+    rank: usize,
+    factors: &[f64],
+    pivot_tolerance: f64,
+) -> bool {
+    if effective.len() != dimension.saturating_mul(dimension)
+        || factors.len() != dimension.saturating_mul(rank)
+    {
+        return false;
+    }
+    if !pivot_tolerance.is_finite() {
+        return false;
+    }
+    for column in 0..dimension {
+        for row in 0..dimension {
+            let mut reconstructed = 0.0;
+            for mode in 0..rank {
+                reconstructed = factors[mode * dimension + row]
+                    .mul_add(factors[mode * dimension + column], reconstructed);
+            }
+            let residual = effective[column * dimension + row] - reconstructed;
+            if !residual.is_finite() || residual.abs() > pivot_tolerance {
+                return false;
+            }
+        }
+    }
+    true
+}
+
+#[allow(clippy::too_many_arguments)]
+fn contract_real_hermitian_same_channel_block_opportunistic(
+    amplitudes: &[SymmetricGroupComplex64],
+    kernel: &[f64],
+    low_rank: Option<&RuntimeSymmetricGroupLowRankBlock>,
+    dimension: usize,
+    coefficient_offset: usize,
+    lane_capacity: usize,
+    lane_count: usize,
+    weight: f64,
+    reduced: &mut [f64],
+) {
+    if lane_count == 1
+        && let Some(low_rank) = low_rank
+        && low_rank.factors.len() == dimension.saturating_mul(low_rank.rank)
+    {
+        contract_real_hermitian_same_channel_low_rank_block_scalar(
+            amplitudes,
+            low_rank,
+            dimension,
+            coefficient_offset,
+            lane_capacity,
+            weight,
+            reduced,
+        );
+        return;
+    }
+    contract_real_hermitian_same_channel_block(
+        amplitudes,
+        kernel,
+        dimension,
+        coefficient_offset,
+        lane_capacity,
+        lane_count,
+        weight,
+        reduced,
+    );
+}
+
+#[allow(clippy::too_many_arguments)]
+fn contract_real_hermitian_same_channel_low_rank_block_scalar(
+    amplitudes: &[SymmetricGroupComplex64],
+    low_rank: &RuntimeSymmetricGroupLowRankBlock,
+    dimension: usize,
+    coefficient_offset: usize,
+    lane_capacity: usize,
+    weight: f64,
+    reduced: &mut [f64],
+) {
+    let mut norm = 0.0;
+    for row in 0..dimension {
+        for mode_start in (0..low_rank.rank).step_by(LOW_RANK_MODE_BLOCK) {
+            let mode_width = (low_rank.rank - mode_start).min(LOW_RANK_MODE_BLOCK);
+            let mut projected_re = [0.0; LOW_RANK_MODE_BLOCK];
+            let mut projected_im = [0.0; LOW_RANK_MODE_BLOCK];
+            for column in 0..dimension {
+                let amplitude =
+                    amplitudes[(coefficient_offset + column * dimension + row) * lane_capacity];
+                for mode_local in 0..mode_width {
+                    let factor = low_rank.factors[(mode_start + mode_local) * dimension + column];
+                    projected_re[mode_local] =
+                        factor.mul_add(amplitude.0, projected_re[mode_local]);
+                    projected_im[mode_local] =
+                        factor.mul_add(amplitude.1, projected_im[mode_local]);
+                }
+            }
+            for mode_local in 0..mode_width {
+                norm = projected_re[mode_local].mul_add(
+                    projected_re[mode_local],
+                    projected_im[mode_local].mul_add(projected_im[mode_local], norm),
+                );
+            }
+        }
+    }
+    reduced[0] = weight.mul_add(norm, reduced[0]);
+}
+
+#[allow(clippy::too_many_arguments)]
+fn contract_real_hermitian_same_channel_block(
+    amplitudes: &[SymmetricGroupComplex64],
+    kernel: &[f64],
+    dimension: usize,
+    coefficient_offset: usize,
+    lane_capacity: usize,
+    lane_count: usize,
+    weight: f64,
+    reduced: &mut [f64],
+) {
+    // Diagonal channel kernels are authenticated at load as real and
+    // inversion-Hermitian.  Their Young blocks are therefore real symmetric,
+    // while Re(A_c^dagger A_i) is symmetric even in the presence of harmless
+    // transform roundoff.  Pairing K_ci and K_ic preserves the previous dense
+    // arithmetic for either representation and evaluates each overlap once.
+    if lane_count == 1 {
+        contract_real_hermitian_same_channel_block_scalar(
+            amplitudes,
+            kernel,
+            dimension,
+            coefficient_offset,
+            lane_capacity,
+            weight,
+            reduced,
+        );
+        return;
+    }
+
+    for column in 0..dimension {
+        let diagonal_kernel = kernel[column * dimension + column] * weight;
+        if diagonal_kernel != 0.0 {
+            for row in 0..dimension {
+                let value = (coefficient_offset + column * dimension + row) * lane_capacity;
+                for lane in 0..lane_count {
+                    let amplitude = amplitudes[value + lane];
+                    let norm = amplitude.0.mul_add(amplitude.0, amplitude.1 * amplitude.1);
+                    reduced[lane] = diagonal_kernel.mul_add(norm, reduced[lane]);
+                }
+            }
+        }
+
+        for inner in column + 1..dimension {
+            let paired_kernel =
+                (kernel[column * dimension + inner] + kernel[inner * dimension + column]) * weight;
+            if paired_kernel == 0.0 {
+                continue;
+            }
+            for row in 0..dimension {
+                let left = (coefficient_offset + column * dimension + row) * lane_capacity;
+                let right = (coefficient_offset + inner * dimension + row) * lane_capacity;
+                for lane in 0..lane_count {
+                    let left_value = amplitudes[left + lane];
+                    let right_value = amplitudes[right + lane];
+                    let product_re = left_value
+                        .0
+                        .mul_add(right_value.0, left_value.1 * right_value.1);
+                    reduced[lane] = paired_kernel.mul_add(product_re, reduced[lane]);
+                }
+            }
+        }
+    }
+}
+
+const HERMITIAN_COLUMN_BLOCK: usize = 4;
+
+#[allow(clippy::too_many_arguments)]
+fn contract_real_hermitian_same_channel_block_scalar(
+    amplitudes: &[SymmetricGroupComplex64],
+    kernel: &[f64],
+    dimension: usize,
+    coefficient_offset: usize,
+    lane_capacity: usize,
+    weight: f64,
+    reduced: &mut [f64],
+) {
+    let mut result = reduced[0];
+    for left_start in (0..dimension).step_by(HERMITIAN_COLUMN_BLOCK) {
+        let left_width = (dimension - left_start).min(HERMITIAN_COLUMN_BLOCK);
+        for right_start in (left_start..dimension).step_by(HERMITIAN_COLUMN_BLOCK) {
+            let right_width = (dimension - right_start).min(HERMITIAN_COLUMN_BLOCK);
+            let diagonal_block = left_start == right_start;
+            let mut overlaps = [[0.0_f64; HERMITIAN_COLUMN_BLOCK]; HERMITIAN_COLUMN_BLOCK];
+
+            // Four simultaneous unit-stride column streams reuse each loaded
+            // amplitude for all overlaps in the opposing four-column block.
+            for row in 0..dimension {
+                let mut left_values = [(0.0, 0.0); HERMITIAN_COLUMN_BLOCK];
+                for (local, value) in left_values[..left_width].iter_mut().enumerate() {
+                    let column = left_start + local;
+                    *value =
+                        amplitudes[(coefficient_offset + column * dimension + row) * lane_capacity];
+                }
+                let mut right_values = [(0.0, 0.0); HERMITIAN_COLUMN_BLOCK];
+                if diagonal_block {
+                    right_values = left_values;
+                } else {
+                    for (local, value) in right_values[..right_width].iter_mut().enumerate() {
+                        let column = right_start + local;
+                        *value = amplitudes
+                            [(coefficient_offset + column * dimension + row) * lane_capacity];
+                    }
+                }
+
+                for left_local in 0..left_width {
+                    let first_right = if diagonal_block { left_local } else { 0 };
+                    let left_value = left_values[left_local];
+                    for right_local in first_right..right_width {
+                        let right_value = right_values[right_local];
+                        overlaps[left_local][right_local] = left_value.0.mul_add(
+                            right_value.0,
+                            left_value
+                                .1
+                                .mul_add(right_value.1, overlaps[left_local][right_local]),
+                        );
+                    }
+                }
+            }
+
+            for (left_local, overlap_row) in overlaps[..left_width].iter().enumerate() {
+                let column = left_start + left_local;
+                let first_right = if diagonal_block { left_local } else { 0 };
+                for (right_local, overlap) in overlap_row[first_right..right_width]
+                    .iter()
+                    .copied()
+                    .enumerate()
+                {
+                    let inner_local = first_right + right_local;
+                    let inner = right_start + inner_local;
+                    let kernel_value = if column == inner {
+                        kernel[column * dimension + column]
+                    } else {
+                        kernel[column * dimension + inner] + kernel[inner * dimension + column]
+                    } * weight;
+                    result = kernel_value.mul_add(overlap, result);
+                }
+            }
+        }
+    }
+    reduced[0] = result;
+}
+
+#[allow(clippy::too_many_arguments)]
+fn contract_general_cross_block(
+    left_amplitudes: &[SymmetricGroupComplex64],
+    right_amplitudes: &[SymmetricGroupComplex64],
+    kernel: &[f64],
+    dimension: usize,
+    coefficient_offset: usize,
+    lane_capacity: usize,
+    lane_count: usize,
+    weight: f64,
+    reduced: &mut [f64],
+) {
+    for column in 0..dimension {
+        for inner in 0..dimension {
+            let kernel_value = kernel[column * dimension + inner] * weight;
+            for row in 0..dimension {
+                let left = (coefficient_offset + column * dimension + row) * lane_capacity;
+                let right = (coefficient_offset + inner * dimension + row) * lane_capacity;
+                for lane in 0..lane_count {
+                    let left_value = left_amplitudes[left + lane];
+                    let right_value = right_amplitudes[right + lane];
+                    let product_re = left_value
+                        .0
+                        .mul_add(right_value.0, left_value.1 * right_value.1);
+                    reduced[lane] = kernel_value.mul_add(product_re, reduced[lane]);
+                }
+            }
+        }
+    }
+}
+
+/// Runtime reduction shape.  The symmetric-group variant deliberately owns
+/// only authenticated raw kernels in codec phase one; lane integration adds a
+/// shared immutable FFT plan without changing the payload or public C ABI.
+#[derive(Clone, Debug, PartialEq)]
+pub enum RuntimeColorContractionReducer {
+    Walsh(RuntimeFactorizedColorContraction),
+    SymmetricGroupFourier(RuntimeSymmetricGroupColorContraction),
+}
+
+impl RuntimeFactorizedColorContraction {
+    pub fn subgroup_order(&self) -> usize {
+        self.subgroup_order
+    }
+
+    pub fn cosets(&self) -> &[Vec<u32>] {
+        &self.cosets
+    }
+
+    pub fn entries(&self) -> &[RuntimeFactorizedColorContractionEntry] {
+        &self.entries
+    }
+
+    pub fn amplitude_scale(&self) -> f64 {
+        self.amplitude_scale
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct RecurrenceColorContraction {
+    accuracy: RecurrenceColorAccuracy,
+    storage: RecurrenceColorStorage,
+    includes_color_factor: bool,
+    group_count: u32,
+    sector_count: u32,
+    component_count: u32,
+    local_group_count: u32,
+    destination_count: u32,
+    stored_entry_count: usize,
+    stored_logical_entry_count: usize,
+    entries: Vec<RawColorContractionEntry>,
+    exact_factors: Vec<ExactComplexRational>,
+    ordered_group_ids: Vec<u32>,
+    destination_by_group: Vec<u32>,
+    sector_by_group: Vec<u32>,
+    component_by_group: Vec<u32>,
+    owner_by_sector: Vec<u32>,
+    ordered_destination_ids: Vec<u32>,
+    factorization: Option<FactorizedColorContraction>,
+    runtime_reducer: Option<RuntimeColorContractionReducer>,
+}
+
+impl RecurrenceColorContraction {
+    pub fn accuracy(&self) -> RecurrenceColorAccuracy {
+        self.accuracy
+    }
+
+    pub fn storage(&self) -> RecurrenceColorStorage {
+        self.storage
+    }
+
+    pub fn includes_color_factor(&self) -> bool {
+        self.includes_color_factor
+    }
+
+    pub fn group_count(&self) -> u32 {
+        self.group_count
+    }
+
+    pub fn sector_count(&self) -> u32 {
+        self.sector_count
+    }
+
+    pub fn component_count(&self) -> u32 {
+        self.component_count
+    }
+
+    pub fn local_group_count(&self) -> u32 {
+        self.local_group_count
+    }
+
+    pub fn destination_count(&self) -> u32 {
+        self.destination_count
+    }
+
+    pub fn entries(&self) -> &[RawColorContractionEntry] {
+        &self.entries
+    }
+
+    pub(crate) fn stored_entry_count(&self) -> usize {
+        self.stored_entry_count
+    }
+
+    pub fn exact_factors(&self) -> &[ExactComplexRational] {
+        &self.exact_factors
+    }
+
+    pub fn ordered_group_ids(&self) -> &[u32] {
+        &self.ordered_group_ids
+    }
+
+    pub fn destination_by_group(&self) -> &[u32] {
+        &self.destination_by_group
+    }
+
+    pub fn sector_by_group(&self) -> &[u32] {
+        &self.sector_by_group
+    }
+
+    pub fn component_by_group(&self) -> &[u32] {
+        &self.component_by_group
+    }
+
+    pub fn owner_by_sector(&self) -> &[u32] {
+        &self.owner_by_sector
+    }
+
+    pub fn active_sector_count(&self) -> usize {
+        self.owner_by_sector
+            .iter()
+            .enumerate()
+            .filter(|(sector, owner)| *sector == **owner as usize)
+            .count()
+    }
+
+    pub fn factorization(&self) -> Option<&FactorizedColorContraction> {
+        self.factorization.as_ref()
+    }
+
+    pub fn runtime_factorization(&self) -> Option<&RuntimeFactorizedColorContraction> {
+        match self.runtime_reducer.as_ref() {
+            Some(RuntimeColorContractionReducer::Walsh(value)) => Some(value),
+            _ => None,
+        }
+    }
+
+    pub fn runtime_reducer(&self) -> Option<&RuntimeColorContractionReducer> {
+        self.runtime_reducer.as_ref()
+    }
+
+    pub fn ordered_destination_id(
+        &self,
+        local_group_index: usize,
+        component_index: usize,
+    ) -> Option<u32> {
+        let ordered_index = local_group_index
+            .checked_mul(self.component_count as usize)?
+            .checked_add(component_index)?;
+        self.ordered_destination_ids.get(ordered_index).copied()
+    }
+
+    pub fn logical_entry_count(&self) -> usize {
+        self.stored_logical_entry_count
+    }
+
+    /// Iterate canonical logical entries without allocating.
+    pub fn canonical_logical_entries(&self) -> CanonicalColorContractionEntries<'_> {
+        assert_ne!(
+            self.storage,
+            RecurrenceColorStorage::ConvolutionKernels,
+            "convolution-kernel storage is not a dense logical color matrix; use its runtime reducer",
+        );
+        CanonicalColorContractionEntries {
+            plan: self,
+            next_index: 0,
+            entry_count: self.logical_entry_count(),
+        }
+    }
+
+    /// Iterate symmetry-folded Direct-Arena rows without allocating.
+    pub fn runtime_entries(&self) -> RuntimeColorContractionEntries<'_> {
+        RuntimeColorContractionEntries {
+            inner: self.canonical_logical_entries(),
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn expanded_identity_for_runtime_test() -> Self {
+        Self {
+            accuracy: RecurrenceColorAccuracy::Full,
+            storage: RecurrenceColorStorage::Expanded,
+            includes_color_factor: true,
+            group_count: 1,
+            sector_count: 1,
+            component_count: 1,
+            local_group_count: 1,
+            destination_count: 1,
+            stored_entry_count: 1,
+            stored_logical_entry_count: 1,
+            entries: vec![RawColorContractionEntry {
+                left_group_id: 0,
+                right_group_id: 0,
+                weight_re: 1.0,
+                weight_im: 0.0,
+                symmetry_factor: 1.0,
+                exact_factor_id: 0,
+            }],
+            exact_factors: vec![ExactComplexRational::ONE],
+            ordered_group_ids: vec![0],
+            destination_by_group: vec![0],
+            sector_by_group: vec![0],
+            component_by_group: vec![0],
+            owner_by_sector: vec![0],
+            ordered_destination_ids: vec![0],
+            factorization: None,
+            runtime_reducer: None,
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn symmetric_group_s3_for_runtime_test(
+        destination_by_group: Vec<u32>,
+        destination_count: u32,
+    ) -> Self {
+        assert_eq!(destination_by_group.len(), 13);
+        assert!(
+            destination_by_group
+                .iter()
+                .all(|destination| *destination < destination_count)
+        );
+        let diagonal_left = [6.0, 1.0, 2.0, 3.0, 3.0, 4.0];
+        let cross = [1.0, 2.0, 0.0, -1.0, 0.5, 3.0];
+        let diagonal_right = [7.0, 0.0, 2.0, -1.0, -1.0, 0.0];
+        let mut entries = Vec::new();
+        let mut push = |left_group_id, right_group_id, weight_re, symmetry_factor| {
+            entries.push(RawColorContractionEntry {
+                left_group_id,
+                right_group_id,
+                weight_re,
+                weight_im: 0.0,
+                symmetry_factor,
+                exact_factor_id: 0,
+            });
+        };
+        for (relative, weight) in diagonal_left.into_iter().enumerate() {
+            push(0, relative as u32, weight, 1.0);
+        }
+        for (relative, weight) in cross.into_iter().enumerate() {
+            push(0, 6 + relative as u32, weight, 2.0);
+        }
+        for (relative, weight) in diagonal_right.into_iter().enumerate() {
+            push(6, 6 + relative as u32, weight, 1.0);
+        }
+        push(0, 12, 0.25, 2.0);
+        for left in 1..12 {
+            push(left, 12, 0.0, 2.0);
+        }
+        push(12, 12, 5.0, 1.0);
+        let factorization = FactorizedColorContraction {
+            kind: FactorizedColorContractionKind::SymmetricGroupFourier,
+            rank: 3,
+            coset_count: 2,
+            coset_indices: (0..12).collect(),
+        };
+        let runtime = build_runtime_symmetric_group_convolution(&factorization, 13, &entries)
+            .expect("valid symmetric-group runtime fixture");
+        let stored_entry_count = entries.len();
+        let ordered_group_ids = (0..13).collect::<Vec<_>>();
+        let ordered_destination_ids = destination_by_group.clone();
+        Self {
+            accuracy: RecurrenceColorAccuracy::Full,
+            storage: RecurrenceColorStorage::ConvolutionKernels,
+            includes_color_factor: true,
+            group_count: 13,
+            sector_count: 13,
+            component_count: 1,
+            local_group_count: 13,
+            destination_count,
+            stored_entry_count,
+            stored_logical_entry_count: stored_entry_count,
+            entries: Vec::new(),
+            exact_factors: Vec::new(),
+            ordered_group_ids,
+            destination_by_group,
+            sector_by_group: (0..13).collect(),
+            component_by_group: vec![0; 13],
+            owner_by_sector: (0..13).collect(),
+            ordered_destination_ids,
+            factorization: Some(factorization),
+            runtime_reducer: Some(RuntimeColorContractionReducer::SymmetricGroupFourier(
+                runtime,
+            )),
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn with_sparse_sector_domain_for_runtime_test(mut self) -> Self {
+        self.sector_count = 27;
+        self.sector_by_group = self
+            .sector_by_group
+            .iter()
+            .map(|sector| 2 * sector + 1)
+            .collect();
+        self.owner_by_sector = vec![ZERO_SECTOR_OWNER; self.sector_count as usize];
+        for sector in &self.sector_by_group {
+            self.owner_by_sector[*sector as usize] = *sector;
+        }
+        self
+    }
+
+    /// Evaluate the complete dense quadratic form owned by the synthetic S3
+    /// runtime fixture without entering the symmetric-group reducer.
+    ///
+    /// The input is group-major and lane-minor.  This deliberately retains the
+    /// original convolution kernels, both cross-channel orientations, and the
+    /// eligible/residual plus residual/residual rows so native lane tests have
+    /// an oracle independent of the transformed execution path.
+    #[cfg(test)]
+    pub(crate) fn symmetric_group_s3_dense_for_runtime_test(
+        amplitudes: &[(f64, f64)],
+        lane_count: usize,
+    ) -> Vec<f64> {
+        assert!(lane_count > 0);
+        assert_eq!(amplitudes.len(), 13 * lane_count);
+
+        let diagonal_left = [6.0, 1.0, 2.0, 3.0, 3.0, 4.0];
+        let cross = [1.0, 2.0, 0.0, -1.0, 0.5, 3.0];
+        let diagonal_right = [7.0, 0.0, 2.0, -1.0, -1.0, 0.0];
+        let kernels = [&diagonal_left[..], &cross[..], &diagonal_right[..]];
+        let channel_pairs = [(0usize, 0usize), (0, 1), (1, 1)];
+        let permutations = [
+            [0usize, 1, 2],
+            [0, 2, 1],
+            [1, 0, 2],
+            [1, 2, 0],
+            [2, 0, 1],
+            [2, 1, 0],
+        ];
+        let mut expected = vec![0.0; lane_count];
+        for lane in 0..lane_count {
+            for ((left_channel, right_channel), kernel) in channel_pairs.into_iter().zip(kernels) {
+                let mut value = (0.0, 0.0);
+                for left_relative in 0..6 {
+                    let mut inverse_left = [0usize; 3];
+                    for (position, image) in permutations[left_relative].iter().copied().enumerate()
+                    {
+                        inverse_left[image] = position;
+                    }
+                    for right_relative in 0..6 {
+                        let relative =
+                            permutations[right_relative].map(|image| inverse_left[image]);
+                        let relative_index = permutations
+                            .iter()
+                            .position(|candidate| *candidate == relative)
+                            .unwrap();
+                        let left =
+                            amplitudes[(left_channel * 6 + left_relative) * lane_count + lane];
+                        let right =
+                            amplitudes[(right_channel * 6 + right_relative) * lane_count + lane];
+                        let product_re = left.0.mul_add(right.0, left.1 * right.1);
+                        let product_im = left.0.mul_add(right.1, -left.1 * right.0);
+                        value.0 += kernel[relative_index] * product_re;
+                        value.1 += kernel[relative_index] * product_im;
+                    }
+                }
+                expected[lane] += if left_channel == right_channel {
+                    value.0
+                } else {
+                    2.0 * value.0
+                };
+            }
+
+            // The fixture's residual suffix contains group 12.  Its complete
+            // direct rows are 2 * 0.25 * Re(A0 conj(A12)) plus
+            // 5 * |A12|^2; the intervening cross rows are exact zeros.
+            let first = amplitudes[lane];
+            let residual = amplitudes[12 * lane_count + lane];
+            expected[lane] += 0.5 * first.0.mul_add(residual.0, first.1 * residual.1);
+            expected[lane] += 5.0 * residual.0.mul_add(residual.0, residual.1 * residual.1);
+        }
+        expected
+    }
+}
+
+pub struct CanonicalColorContractionEntries<'a> {
+    plan: &'a RecurrenceColorContraction,
+    next_index: usize,
+    entry_count: usize,
+}
+
+impl Iterator for CanonicalColorContractionEntries<'_> {
+    type Item = CanonicalColorContractionEntry;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.next_index >= self.entry_count {
+            return None;
+        }
+        let logical_index = self.next_index;
+        self.next_index += 1;
+        let (entry, left_group_id, right_group_id) = match self.plan.storage {
+            RecurrenceColorStorage::Expanded => {
+                let entry = *self.plan.entries.get(logical_index)?;
+                (entry, entry.left_group_id, entry.right_group_id)
+            }
+            RecurrenceColorStorage::Repeated | RecurrenceColorStorage::ConvolutionKernels => {
+                let template_count = self.plan.entries.len();
+                if template_count == 0 {
+                    return None;
+                }
+                let component_index = logical_index / template_count;
+                let entry = *self.plan.entries.get(logical_index % template_count)?;
+                let component_count = self.plan.component_count as usize;
+                let left_index = entry.left_group_id as usize * component_count + component_index;
+                let right_index = entry.right_group_id as usize * component_count + component_index;
+                (
+                    entry,
+                    *self.plan.ordered_group_ids.get(left_index)?,
+                    *self.plan.ordered_group_ids.get(right_index)?,
+                )
+            }
+        };
+        Some(CanonicalColorContractionEntry {
+            left_group_id,
+            right_group_id,
+            left_destination_id: self.plan.destination_by_group[left_group_id as usize],
+            right_destination_id: self.plan.destination_by_group[right_group_id as usize],
+            weight_re: entry.weight_re,
+            weight_im: entry.weight_im,
+            symmetry_factor: entry.symmetry_factor,
+        })
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = self.entry_count.saturating_sub(self.next_index);
+        (remaining, Some(remaining))
+    }
+}
+
+impl ExactSizeIterator for CanonicalColorContractionEntries<'_> {}
+impl FusedIterator for CanonicalColorContractionEntries<'_> {}
+
+pub struct RuntimeColorContractionEntries<'a> {
+    inner: CanonicalColorContractionEntries<'a>,
+}
+
+impl Iterator for RuntimeColorContractionEntries<'_> {
+    type Item = RuntimeColorContractionEntry;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let raw = self.inner.next()?;
+        Some(RuntimeColorContractionEntry {
+            left_destination_id: raw.left_destination_id,
+            right_destination_id: raw.right_destination_id,
+            coefficient_re: raw.weight_re * raw.symmetry_factor,
+            coefficient_im: raw.weight_im * raw.symmetry_factor,
+        })
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl ExactSizeIterator for RuntimeColorContractionEntries<'_> {}
+impl FusedIterator for RuntimeColorContractionEntries<'_> {}
+
+/// Decode and fully validate a caller-authenticated process payload.
+pub fn decode_recurrence_color_contraction_v3(
+    bytes: &[u8],
+) -> RusticolResult<RecurrenceColorContraction> {
+    let mut reader = Reader::new(bytes);
+    if reader.take(8, "magic")? != MAGIC {
+        return Err(malformed("invalid payload magic"));
+    }
+    if reader.u32("version")? != VERSION {
+        return Err(malformed("unsupported payload version"));
+    }
+    if reader.u32("header size")? as usize != HEADER_BYTES {
+        return Err(malformed("header size does not match codec v3"));
+    }
+    let storage = RecurrenceColorStorage::decode(reader.u32("storage")?)?;
+    let accuracy = RecurrenceColorAccuracy::decode(reader.u32("color accuracy")?)?;
+    let flags = reader.u32("flags")?;
+    if flags & !KNOWN_FLAGS != 0 {
+        return Err(malformed("payload declares unknown flags"));
+    }
+    let group_count = reader.u32("group count")?;
+    let sector_count = reader.u32("sector count")?;
+    let component_count = reader.u32("component count")?;
+    let local_group_count = reader.u32("local group count")?;
+    let destination_count = reader.u32("destination count")?;
+    let factor_kind = reader.u32("factorization kind")?;
+    let factor_rank = reader.u32("factorization rank")?;
+    if reader.u32("entry stride")? as usize != ENTRY_BYTES {
+        return Err(malformed("entry stride does not match codec v3"));
+    }
+    if reader.u32("exact factor stride")? as usize != EXACT_FACTOR_BYTES {
+        return Err(malformed("exact factor stride does not match codec v3"));
+    }
+    let entry_count = reader.count("entry count")?;
+    let exact_factor_count = reader.count("exact factor count")?;
+    let coset_count = reader.count("coset count")?;
+    let coset_index_count = reader.count("coset index count")?;
+    let declared_logical_entry_count = reader.count("logical entry count")?;
+    let owner_map_count = reader.count("physical sector owner map count")?;
+    let payload_bytes = reader.count("payload byte count")?;
+
+    if group_count == 0 || sector_count == 0 || component_count == 0 || destination_count == 0 {
+        return Err(malformed(
+            "group, sector, component, and destination counts must be positive",
+        ));
+    }
+    if owner_map_count != sector_count as usize {
+        return Err(malformed(
+            "physical sector owner map count does not match sector_count",
+        ));
+    }
+    let expected_payload_bytes = entry_count
+        .checked_mul(ENTRY_BYTES)
+        .and_then(|value| value.checked_add(exact_factor_count.checked_mul(EXACT_FACTOR_BYTES)?))
+        .and_then(|value| value.checked_add((group_count as usize).checked_mul(16)?))
+        .and_then(|value| value.checked_add(owner_map_count.checked_mul(4)?))
+        .and_then(|value| value.checked_add(coset_index_count.checked_mul(4)?))
+        .ok_or_else(|| malformed("payload byte count overflows usize"))?;
+    if payload_bytes != expected_payload_bytes
+        || Some(bytes.len()) != HEADER_BYTES.checked_add(payload_bytes)
+    {
+        return Err(malformed(
+            "declared payload size does not match its fixed-width sections",
+        ));
+    }
+
+    let entry_domain = match storage {
+        RecurrenceColorStorage::Expanded => group_count,
+        RecurrenceColorStorage::Repeated | RecurrenceColorStorage::ConvolutionKernels => {
+            local_group_count
+        }
+    };
+    let mut entries = Vec::with_capacity(entry_count);
+    let mut seen_entry_pairs = BTreeSet::new();
+    for index in 0..entry_count {
+        let entry = RawColorContractionEntry {
+            left_group_id: reader.u32("entry left group ID")?,
+            right_group_id: reader.u32("entry right group ID")?,
+            weight_re: reader.f64("entry real weight")?,
+            weight_im: reader.f64("entry imaginary weight")?,
+            symmetry_factor: reader.f64("entry symmetry factor")?,
+            exact_factor_id: reader.u32("entry exact factor ID")?,
+        };
+        validate_raw_entry(index, entry, entry_domain, &mut seen_entry_pairs)?;
+        entries.push(entry);
+    }
+    let mut exact_factors = Vec::with_capacity(exact_factor_count);
+    for index in 0..exact_factor_count {
+        let factor = ExactComplexRational::new(
+            ExactRational::new(
+                reader.i128("exact real numerator")?,
+                reader.i128("exact real denominator")?,
+            )
+            .map_err(|error| malformed(format!("exact color factor {index} real part: {error}")))?,
+            ExactRational::new(
+                reader.i128("exact imaginary numerator")?,
+                reader.i128("exact imaginary denominator")?,
+            )
+            .map_err(|error| {
+                malformed(format!(
+                    "exact color factor {index} imaginary part: {error}"
+                ))
+            })?,
+        );
+        exact_factors.push(factor);
+    }
+    if entries
+        .iter()
+        .any(|entry| entry.exact_factor_id as usize >= exact_factors.len())
+    {
+        return Err(malformed(
+            "entry references an out-of-bounds exact color factor",
+        ));
+    }
+    for (index, entry) in entries.iter().copied().enumerate() {
+        validate_exact_matches_f64(index, entry, exact_factors[entry.exact_factor_id as usize])?;
+    }
+    let ordered_group_ids = reader.u32_vec(group_count as usize, "ordered group ID")?;
+    let destination_by_group =
+        reader.u32_vec(group_count as usize, "Direct-Arena destination ID")?;
+    let sector_by_group = reader.u32_vec(group_count as usize, "group physical-sector ID")?;
+    let component_by_group = reader.u32_vec(group_count as usize, "group resolved-helicity ID")?;
+    let owner_by_sector = reader.u32_vec(owner_map_count, "physical sector owner ID")?;
+    let coset_indices = reader.u32_vec(coset_index_count, "factorization coset index")?;
+    if !reader.is_finished() {
+        return Err(malformed("payload contains trailing bytes"));
+    }
+
+    validate_permutation(&ordered_group_ids, group_count, "ordered group map")?;
+    validate_destination_map(&destination_by_group, destination_count)?;
+    validate_group_identities(
+        &sector_by_group,
+        &component_by_group,
+        sector_count,
+        component_count,
+    )?;
+    validate_sector_owners(&owner_by_sector, &sector_by_group, sector_count)?;
+
+    let expected_logical_entry_count = match storage {
+        RecurrenceColorStorage::Expanded => {
+            if local_group_count != 0
+                || factor_kind != 0
+                || factor_rank != 0
+                || coset_count != 0
+                || coset_index_count != 0
+            {
+                return Err(malformed(
+                    "expanded storage is mixed with repeated/factorized fields",
+                ));
+            }
+            validate_expanded_components(&entries, &component_by_group)?;
+            entry_count
+        }
+        RecurrenceColorStorage::Repeated => {
+            if component_count < 2 {
+                return Err(malformed(
+                    "repeated storage requires at least two components",
+                ));
+            }
+            if local_group_count == 0
+                || local_group_count.checked_mul(component_count) != Some(group_count)
+            {
+                return Err(malformed(
+                    "repeated local, sector, component, and group counts are inconsistent",
+                ));
+            }
+            validate_repeated_group_identities(
+                &ordered_group_ids,
+                &sector_by_group,
+                &component_by_group,
+                local_group_count,
+                component_count,
+            )?;
+            entry_count
+                .checked_mul(component_count as usize)
+                .ok_or_else(|| malformed("logical entry count overflows usize"))?
+        }
+        RecurrenceColorStorage::ConvolutionKernels => {
+            if local_group_count == 0
+                || local_group_count.checked_mul(component_count) != Some(group_count)
+            {
+                return Err(malformed(
+                    "convolution-kernel local, component, and group counts are inconsistent",
+                ));
+            }
+            validate_repeated_group_identities(
+                &ordered_group_ids,
+                &sector_by_group,
+                &component_by_group,
+                local_group_count,
+                component_count,
+            )?;
+            entry_count
+                .checked_mul(component_count as usize)
+                .ok_or_else(|| malformed("logical entry count overflows usize"))?
+        }
+    };
+    if declared_logical_entry_count != expected_logical_entry_count {
+        return Err(malformed(
+            "declared logical entry count is inconsistent with storage",
+        ));
+    }
+
+    let factorization = decode_factorization(
+        storage,
+        factor_kind,
+        factor_rank,
+        coset_count,
+        coset_indices,
+        local_group_count,
+        &entries,
+    )?;
+    let runtime_reducer = factorization
+        .as_ref()
+        .map(|factorization| match factorization.kind() {
+            FactorizedColorContractionKind::KleinFourWalsh
+            | FactorizedColorContractionKind::ElementaryAbelianWalsh => {
+                build_runtime_factorization(factorization, local_group_count, &entries)
+                    .map(RuntimeColorContractionReducer::Walsh)
+            }
+            FactorizedColorContractionKind::SymmetricGroupFourier => {
+                build_runtime_symmetric_group_convolution(
+                    factorization,
+                    local_group_count,
+                    &entries,
+                )
+                .map(RuntimeColorContractionReducer::SymmetricGroupFourier)
+            }
+        })
+        .transpose()?;
+    let ordered_destination_ids = ordered_group_ids
+        .iter()
+        .map(|group_id| destination_by_group[*group_id as usize])
+        .collect();
+
+    let retain_wire_catalog = storage != RecurrenceColorStorage::ConvolutionKernels;
+    Ok(RecurrenceColorContraction {
+        accuracy,
+        storage,
+        includes_color_factor: flags & FLAG_INCLUDES_COLOR_FACTOR != 0,
+        group_count,
+        sector_count,
+        component_count,
+        local_group_count,
+        destination_count,
+        stored_entry_count: entry_count,
+        stored_logical_entry_count: declared_logical_entry_count,
+        entries: if retain_wire_catalog {
+            entries
+        } else {
+            Default::default()
+        },
+        exact_factors: if retain_wire_catalog {
+            exact_factors
+        } else {
+            Default::default()
+        },
+        ordered_group_ids,
+        destination_by_group,
+        sector_by_group,
+        component_by_group,
+        owner_by_sector,
+        ordered_destination_ids,
+        factorization,
+        runtime_reducer,
+    })
+}
+
+/// Return the caller-owned deterministic SHA-256 digest of canonical bytes.
+pub fn recurrence_color_contraction_digest(bytes: &[u8]) -> [u8; 32] {
+    Sha256::digest(bytes).into()
+}
+
+fn validate_raw_entry(
+    index: usize,
+    entry: RawColorContractionEntry,
+    group_count: u32,
+    seen_pairs: &mut BTreeSet<(u32, u32)>,
+) -> RusticolResult<()> {
+    if entry.left_group_id >= group_count || entry.right_group_id >= group_count {
+        return Err(malformed(format!(
+            "entry {index} references an out-of-bounds group"
+        )));
+    }
+    if entry.left_group_id > entry.right_group_id {
+        return Err(malformed(format!(
+            "entry {index} is not canonical upper triangular"
+        )));
+    }
+    if !seen_pairs.insert((entry.left_group_id, entry.right_group_id)) {
+        return Err(malformed(format!(
+            "entry {index} duplicates a canonical group pair"
+        )));
+    }
+    if !entry.weight_re.is_finite()
+        || !entry.weight_im.is_finite()
+        || !entry.symmetry_factor.is_finite()
+    {
+        return Err(malformed(format!(
+            "entry {index} contains a non-finite f64"
+        )));
+    }
+    if !(entry.weight_re * entry.symmetry_factor).is_finite()
+        || !(entry.weight_im * entry.symmetry_factor).is_finite()
+    {
+        return Err(malformed(format!(
+            "entry {index} overflows after symmetry folding"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_exact_matches_f64(
+    index: usize,
+    entry: RawColorContractionEntry,
+    factor: ExactComplexRational,
+) -> RusticolResult<()> {
+    let actual = [
+        entry.weight_re * entry.symmetry_factor,
+        entry.weight_im * entry.symmetry_factor,
+    ];
+    let expected = [
+        factor.real().numerator() as f64 / factor.real().denominator() as f64,
+        factor.imag().numerator() as f64 / factor.imag().denominator() as f64,
+    ];
+    for (component, actual, expected) in ["real", "imaginary"]
+        .into_iter()
+        .zip(actual)
+        .zip(expected)
+        .map(|((component, actual), expected)| (component, actual, expected))
+    {
+        let tolerance = f64_ulp(actual).max(f64_ulp(expected));
+        if (actual - expected).abs() > tolerance {
+            return Err(malformed(format!(
+                "entry {index} {component} f64 coefficient disagrees with its exact color factor",
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn f64_ulp(value: f64) -> f64 {
+    if value == 0.0 {
+        return f64::from_bits(1);
+    }
+    let magnitude = value.abs();
+    if !magnitude.is_finite() {
+        return f64::INFINITY;
+    }
+    f64::from_bits(magnitude.to_bits() + 1) - magnitude
+}
+
+fn validate_permutation(values: &[u32], count: u32, label: &str) -> RusticolResult<()> {
+    let mut seen = vec![false; count as usize];
+    for value in values {
+        let Some(slot) = seen.get_mut(*value as usize) else {
+            return Err(malformed(format!("{label} contains an out-of-bounds ID")));
+        };
+        if *slot {
+            return Err(malformed(format!("{label} contains a duplicate ID")));
+        }
+        *slot = true;
+    }
+    if seen.iter().any(|value| !value) {
+        return Err(malformed(format!("{label} is not a complete permutation")));
+    }
+    Ok(())
+}
+
+fn validate_destination_map(values: &[u32], destination_count: u32) -> RusticolResult<()> {
+    let mut seen = BTreeSet::new();
+    for value in values {
+        if *value >= destination_count {
+            return Err(malformed(
+                "destination map references an out-of-bounds Direct-Arena destination",
+            ));
+        }
+        if !seen.insert(*value) {
+            return Err(malformed(
+                "destination map contains a duplicate Direct-Arena destination",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn validate_expanded_components(
+    entries: &[RawColorContractionEntry],
+    component_by_group: &[u32],
+) -> RusticolResult<()> {
+    for entry in entries {
+        if component_by_group[entry.left_group_id as usize]
+            != component_by_group[entry.right_group_id as usize]
+        {
+            return Err(malformed(
+                "expanded entry couples groups from different components",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn validate_group_identities(
+    sector_by_group: &[u32],
+    component_by_group: &[u32],
+    sector_count: u32,
+    component_count: u32,
+) -> RusticolResult<()> {
+    if sector_by_group.len() != component_by_group.len() {
+        return Err(malformed("group identity maps have different lengths"));
+    }
+    let mut identities = BTreeSet::new();
+    for (group_id, (&sector_id, &component_id)) in
+        sector_by_group.iter().zip(component_by_group).enumerate()
+    {
+        if sector_id >= sector_count || component_id >= component_count {
+            return Err(malformed(format!(
+                "group {group_id} identity references an out-of-bounds sector or component"
+            )));
+        }
+        if !identities.insert((sector_id, component_id)) {
+            return Err(malformed(
+                "group identity maps repeat a sector/component pair",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn validate_sector_owners(
+    owner_by_sector: &[u32],
+    sector_by_group: &[u32],
+    sector_count: u32,
+) -> RusticolResult<()> {
+    if owner_by_sector.len() != sector_count as usize {
+        return Err(malformed("physical sector owner map has the wrong length"));
+    }
+    let mut fixed_points = BTreeSet::new();
+    for (sector_id, owner_id) in owner_by_sector.iter().copied().enumerate() {
+        if owner_id == ZERO_SECTOR_OWNER {
+            continue;
+        }
+        if owner_id >= sector_count
+            || owner_id as usize > sector_id
+            || owner_by_sector[owner_id as usize] != owner_id
+        {
+            return Err(malformed(format!(
+                "physical sector {sector_id} has an invalid canonical owner",
+            )));
+        }
+        if owner_id as usize == sector_id {
+            fixed_points.insert(owner_id);
+        }
+    }
+    let active = sector_by_group.iter().copied().collect::<BTreeSet<_>>();
+    if active != fixed_points {
+        return Err(malformed(
+            "active recurrence sectors are not exactly the authenticated owner sectors",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_repeated_group_identities(
+    ordered_group_ids: &[u32],
+    sector_by_group: &[u32],
+    component_by_group: &[u32],
+    local_group_count: u32,
+    component_count: u32,
+) -> RusticolResult<()> {
+    for local_group in 0..local_group_count as usize {
+        let start = local_group
+            .checked_mul(component_count as usize)
+            .ok_or_else(|| malformed("repeated group identity offset overflows usize"))?;
+        let stop = start
+            .checked_add(component_count as usize)
+            .ok_or_else(|| malformed("repeated group identity range overflows usize"))?;
+        let group_ids = ordered_group_ids
+            .get(start..stop)
+            .ok_or_else(|| malformed("repeated group identity range is truncated"))?;
+        let first = *group_ids
+            .first()
+            .ok_or_else(|| malformed("repeated group identity row is empty"))?;
+        let sector_id = sector_by_group[first as usize];
+        for (component_id, group_id) in group_ids.iter().copied().enumerate() {
+            if sector_by_group[group_id as usize] != sector_id
+                || component_by_group[group_id as usize] != component_id as u32
+            {
+                return Err(malformed(
+                    "repeated group identities are not local-color-major/component-minor",
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn decode_factorization(
+    storage: RecurrenceColorStorage,
+    factor_kind: u32,
+    factor_rank: u32,
+    coset_count: usize,
+    coset_indices: Vec<u32>,
+    local_group_count: u32,
+    entries: &[RawColorContractionEntry],
+) -> RusticolResult<Option<FactorizedColorContraction>> {
+    if factor_kind == 0 {
+        if factor_rank != 0 || coset_count != 0 || !coset_indices.is_empty() {
+            return Err(malformed(
+                "factorization-none carries rank or coset metadata",
+            ));
+        }
+        if storage == RecurrenceColorStorage::ConvolutionKernels {
+            return Err(malformed(
+                "convolution-kernel storage requires symmetric-group Fourier metadata",
+            ));
+        }
+        return Ok(None);
+    }
+    let kind = match factor_kind {
+        1 => {
+            if storage != RecurrenceColorStorage::Repeated {
+                return Err(malformed(
+                    "Walsh factorization requires repeated color storage",
+                ));
+            }
+            if factor_rank != 2 {
+                return Err(malformed("Klein-four factorization must have rank two"));
+            }
+            FactorizedColorContractionKind::KleinFourWalsh
+        }
+        2 => {
+            if storage != RecurrenceColorStorage::Repeated {
+                return Err(malformed(
+                    "Walsh factorization requires repeated color storage",
+                ));
+            }
+            if !(3..=MAX_FACTOR_RANK).contains(&factor_rank) {
+                return Err(malformed(format!(
+                    "elementary-Abelian factorization rank must be in [3, {MAX_FACTOR_RANK}]"
+                )));
+            }
+            FactorizedColorContractionKind::ElementaryAbelianWalsh
+        }
+        3 => {
+            if storage != RecurrenceColorStorage::ConvolutionKernels {
+                return Err(malformed(
+                    "symmetric-group Fourier factorization requires convolution-kernel storage",
+                ));
+            }
+            if !(2..=MAX_SYMMETRIC_GROUP_DEGREE).contains(&factor_rank) {
+                return Err(malformed(format!(
+                    "symmetric-group Fourier degree must be in [2, {MAX_SYMMETRIC_GROUP_DEGREE}]"
+                )));
+            }
+            FactorizedColorContractionKind::SymmetricGroupFourier
+        }
+        _ => {
+            return Err(malformed(format!(
+                "unknown factorization discriminant {factor_kind}"
+            )));
+        }
+    };
+    let subgroup_order = match kind {
+        FactorizedColorContractionKind::KleinFourWalsh
+        | FactorizedColorContractionKind::ElementaryAbelianWalsh => 1usize
+            .checked_shl(factor_rank)
+            .ok_or_else(|| malformed("factorization subgroup order overflows usize"))?,
+        FactorizedColorContractionKind::SymmetricGroupFourier => checked_factorial(factor_rank)
+            .ok_or_else(|| malformed("symmetric-group order overflows usize"))?,
+    };
+    if coset_count == 0 || coset_count.checked_mul(subgroup_order) != Some(coset_indices.len()) {
+        return Err(malformed(
+            "factorization channel shape does not match its group order",
+        ));
+    }
+    match kind {
+        FactorizedColorContractionKind::KleinFourWalsh
+        | FactorizedColorContractionKind::ElementaryAbelianWalsh => {
+            if coset_indices.len() != local_group_count as usize {
+                return Err(malformed(
+                    "Walsh cosets do not cover every local color group",
+                ));
+            }
+            validate_permutation(&coset_indices, local_group_count, "factorization coset map")?;
+            validate_walsh_invariance(&coset_indices, coset_count, subgroup_order, entries)?;
+        }
+        FactorizedColorContractionKind::SymmetricGroupFourier => {
+            validate_symmetric_group_convolution(
+                factor_rank,
+                &coset_indices,
+                coset_count,
+                subgroup_order,
+                local_group_count,
+                entries,
+            )?;
+        }
+    }
+    Ok(Some(FactorizedColorContraction {
+        kind,
+        rank: factor_rank,
+        coset_count,
+        coset_indices,
+    }))
+}
+
+fn validate_walsh_invariance(
+    coset_indices: &[u32],
+    coset_count: usize,
+    subgroup_order: usize,
+    entries: &[RawColorContractionEntry],
+) -> RusticolResult<()> {
+    let mut matrix = BTreeMap::new();
+    for entry in entries {
+        if entry.weight_im != 0.0 {
+            return Err(malformed(
+                "factorized color contraction requires real weights",
+            ));
+        }
+        let mut coefficient = entry.weight_re * entry.symmetry_factor;
+        if entry.left_group_id != entry.right_group_id {
+            coefficient *= 0.5;
+        }
+        if !coefficient.is_finite() {
+            return Err(malformed(
+                "factorized color contraction matrix coefficient is not finite",
+            ));
+        }
+        matrix.insert((entry.left_group_id, entry.right_group_id), coefficient);
+    }
+    let matrix_value = |left: u32, right: u32| {
+        let pair = if left <= right {
+            (left, right)
+        } else {
+            (right, left)
+        };
+        matrix.get(&pair).copied().unwrap_or(0.0)
+    };
+    for left_coset_index in 0..coset_count {
+        let left_start = left_coset_index * subgroup_order;
+        let left_coset = &coset_indices[left_start..left_start + subgroup_order];
+        for right_coset_index in 0..coset_count {
+            let right_start = right_coset_index * subgroup_order;
+            let right_coset = &coset_indices[right_start..right_start + subgroup_order];
+            for left_index in 0..subgroup_order {
+                for right_index in 0..subgroup_order {
+                    let actual = matrix_value(left_coset[left_index], right_coset[right_index]);
+                    let expected =
+                        matrix_value(left_coset[0], right_coset[left_index ^ right_index]);
+                    if actual != expected {
+                        return Err(malformed(
+                            "factorization cosets are inconsistent with the canonical color matrix",
+                        ));
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_symmetric_group_convolution(
+    _degree: u32,
+    channel_indices: &[u32],
+    channel_count: usize,
+    group_order: usize,
+    local_group_count: u32,
+    entries: &[RawColorContractionEntry],
+) -> RusticolResult<()> {
+    let eligible_group_count = channel_count
+        .checked_mul(group_order)
+        .ok_or_else(|| malformed("symmetric-group eligible group count overflows usize"))?;
+    if eligible_group_count > local_group_count as usize {
+        return Err(malformed(
+            "symmetric-group channels exceed the local group domain",
+        ));
+    }
+    if channel_indices
+        .iter()
+        .copied()
+        .enumerate()
+        .any(|(expected, actual)| actual as usize != expected)
+    {
+        return Err(malformed(
+            "symmetric-group channels are not canonical channel-major/permutation-major indices",
+        ));
+    }
+    let channel_pair_count = channel_count
+        .checked_mul(channel_count + 1)
+        .and_then(|value| value.checked_div(2))
+        .ok_or_else(|| malformed("symmetric-group channel-pair count overflows usize"))?;
+    let kernel_entry_count = channel_pair_count
+        .checked_mul(group_order)
+        .ok_or_else(|| malformed("symmetric-group kernel entry count overflows usize"))?;
+    if entries.len() < kernel_entry_count {
+        return Err(malformed(
+            "symmetric-group kernel rows do not cover every channel pair",
+        ));
+    }
+
+    let mut offset = 0usize;
+    for left_channel in 0..channel_count {
+        let left_identity = (left_channel * group_order) as u32;
+        for right_channel in left_channel..channel_count {
+            let right_start = right_channel * group_order;
+            let expected_symmetry = if left_channel == right_channel {
+                1.0
+            } else {
+                2.0
+            };
+            for relative_index in 0..group_order {
+                let entry = entries[offset];
+                if entry.left_group_id != left_identity
+                    || entry.right_group_id as usize != right_start + relative_index
+                    || entry.symmetry_factor != expected_symmetry
+                {
+                    return Err(malformed(
+                        "symmetric-group kernel rows are not canonical (channel, channel, relative-permutation) records",
+                    ));
+                }
+                if entry.weight_im != 0.0 {
+                    return Err(malformed(
+                        "symmetric-group color kernel contains a complex coefficient",
+                    ));
+                }
+                offset += 1;
+            }
+        }
+    }
+
+    let residual_entries = &entries[kernel_entry_count..];
+    let total_pair_count = (local_group_count as usize)
+        .checked_mul(local_group_count as usize + 1)
+        .and_then(|value| value.checked_div(2))
+        .ok_or_else(|| malformed("symmetric-group residual pair count overflows usize"))?;
+    let eligible_pair_count = eligible_group_count
+        .checked_mul(eligible_group_count + 1)
+        .and_then(|value| value.checked_div(2))
+        .ok_or_else(|| malformed("symmetric-group eligible pair count overflows usize"))?;
+    let expected_residual_count = total_pair_count - eligible_pair_count;
+    if residual_entries.len() != expected_residual_count {
+        return Err(malformed(
+            "symmetric-group residual rows do not cover every pair touching the residual suffix",
+        ));
+    }
+    let mut residual_offset = 0usize;
+    for left in 0..local_group_count {
+        for right in left..local_group_count {
+            if right < eligible_group_count as u32 {
+                continue;
+            }
+            let entry = residual_entries[residual_offset];
+            let pair = (left, right);
+            if (entry.left_group_id, entry.right_group_id) != pair {
+                return Err(malformed(
+                    "symmetric-group residual rows are not the exhaustive canonical pair sequence",
+                ));
+            }
+            residual_offset += 1;
+            if entry.weight_im != 0.0 {
+                return Err(malformed(
+                    "symmetric-group residual row contains a complex coefficient",
+                ));
+            }
+            let expected_symmetry = if pair.0 == pair.1 { 1.0 } else { 2.0 };
+            if entry.symmetry_factor != expected_symmetry {
+                return Err(malformed(
+                    "symmetric-group residual row has a noncanonical symmetry factor",
+                ));
+            }
+        }
+    }
+    debug_assert_eq!(residual_offset, residual_entries.len());
+    Ok(())
+}
+
+fn checked_factorial(value: u32) -> Option<usize> {
+    (2..=value).try_fold(1usize, |result, factor| result.checked_mul(factor as usize))
+}
+
+fn build_runtime_factorization(
+    factorization: &FactorizedColorContraction,
+    local_group_count: u32,
+    entries: &[RawColorContractionEntry],
+) -> RusticolResult<RuntimeFactorizedColorContraction> {
+    let subgroup_order = factorization.subgroup_order();
+    let cosets = (0..factorization.coset_count())
+        .map(|index| {
+            factorization
+                .coset(index)
+                .expect("validated factorization coset")
+                .to_vec()
+        })
+        .collect::<Vec<_>>();
+    let mut matrix = BTreeMap::new();
+    for entry in entries {
+        let mut coefficient = entry.weight_re * entry.symmetry_factor;
+        if entry.left_group_id != entry.right_group_id {
+            coefficient *= 0.5;
+        }
+        matrix.insert((entry.left_group_id, entry.right_group_id), coefficient);
+    }
+    let matrix_value = |left: u32, right: u32| {
+        let pair = if left <= right {
+            (left, right)
+        } else {
+            (right, left)
+        };
+        matrix.get(&pair).copied().unwrap_or(0.0)
+    };
+
+    let amplitude_scale = match factorization.kind() {
+        FactorizedColorContractionKind::KleinFourWalsh => 0.5,
+        FactorizedColorContractionKind::ElementaryAbelianWalsh => 1.0,
+        FactorizedColorContractionKind::SymmetricGroupFourier => {
+            return Err(malformed(
+                "symmetric-group convolution cannot use the Walsh runtime builder",
+            ));
+        }
+    };
+    let weight_scale = match factorization.kind() {
+        FactorizedColorContractionKind::KleinFourWalsh => 1.0,
+        FactorizedColorContractionKind::ElementaryAbelianWalsh => 1.0 / subgroup_order as f64,
+        FactorizedColorContractionKind::SymmetricGroupFourier => unreachable!(),
+    };
+    let mut transformed_entries = Vec::new();
+    for left_coset_index in 0..cosets.len() {
+        for right_coset_index in left_coset_index..cosets.len() {
+            let left_coset = &cosets[left_coset_index];
+            let right_coset = &cosets[right_coset_index];
+            let mut weights = (0..subgroup_order)
+                .map(|subgroup_index| matrix_value(left_coset[0], right_coset[subgroup_index]))
+                .collect::<Vec<_>>();
+            walsh_butterfly_f64(&mut weights);
+            for (character_index, weight) in weights.into_iter().enumerate() {
+                let mut coefficient = weight * weight_scale;
+                if left_coset_index != right_coset_index {
+                    coefficient *= 2.0;
+                }
+                if coefficient == 0.0 {
+                    continue;
+                }
+                if !coefficient.is_finite() {
+                    return Err(malformed(
+                        "runtime factorized color coefficient is not finite",
+                    ));
+                }
+                transformed_entries.push(RuntimeFactorizedColorContractionEntry {
+                    left_group_index: left_coset[character_index],
+                    right_group_index: right_coset[character_index],
+                    coefficient_re: coefficient,
+                    coefficient_im: 0.0,
+                });
+            }
+        }
+    }
+    if cosets
+        .iter()
+        .flat_map(|coset| coset.iter())
+        .any(|group| *group >= local_group_count)
+    {
+        return Err(malformed(
+            "runtime factorization references an out-of-bounds local group",
+        ));
+    }
+    Ok(RuntimeFactorizedColorContraction {
+        subgroup_order,
+        cosets,
+        entries: transformed_entries,
+        amplitude_scale,
+    })
+}
+
+fn build_runtime_symmetric_group_convolution(
+    factorization: &FactorizedColorContraction,
+    local_group_count: u32,
+    entries: &[RawColorContractionEntry],
+) -> RusticolResult<RuntimeSymmetricGroupColorContraction> {
+    if factorization.kind() != FactorizedColorContractionKind::SymmetricGroupFourier {
+        return Err(malformed(
+            "non-symmetric factorization reached the symmetric-group runtime builder",
+        ));
+    }
+    let fft_plan = SymmetricGroupFftPlan::new(factorization.rank() as usize).map_err(|error| {
+        malformed(format!(
+            "could not construct the authenticated symmetric-group FFT plan: {error}"
+        ))
+    })?;
+    let group_order = fft_plan.order();
+    if group_order != factorization.subgroup_order() {
+        return Err(malformed(
+            "symmetric-group FFT order disagrees with factorization metadata",
+        ));
+    }
+    let channel_count = factorization.coset_count();
+    let kernel_entry_count = channel_count
+        .checked_mul(channel_count + 1)
+        .and_then(|value| value.checked_div(2))
+        .and_then(|value| value.checked_mul(group_order))
+        .ok_or_else(|| malformed("symmetric-group runtime kernel count overflows usize"))?;
+    let mut kernels = Vec::with_capacity(channel_count * (channel_count + 1) / 2);
+    let mut scalar_same_channel_low_rank_kernels =
+        Vec::with_capacity(channel_count * (channel_count + 1) / 2);
+    let mut has_scalar_same_channel_low_rank = false;
+    let mut inverse_kernel = vec![(0.0, 0.0); group_order];
+    let mut transformed_kernel = vec![(0.0, 0.0); group_order];
+    let inverse_relative_indices = (0..group_order)
+        .map(|index| {
+            fft_plan
+                .inverse_lexicographic_index(index)
+                .map_err(|error| {
+                    malformed(format!(
+                        "could not invert a symmetric-group relative index: {error}"
+                    ))
+                })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let mut fft_workspace = fft_plan.workspace(1).map_err(|error| {
+        malformed(format!(
+            "could not allocate the authenticated symmetric-group FFT workspace: {error}"
+        ))
+    })?;
+    let mut offset = 0usize;
+    for left_channel_index in 0..channel_count {
+        for right_channel_index in left_channel_index..channel_count {
+            let raw_kernel = &entries[offset..offset + group_order];
+            if left_channel_index == right_channel_index {
+                for (relative_index, entry) in raw_kernel.iter().enumerate() {
+                    let inverse_index = inverse_relative_indices[relative_index];
+                    if entry.weight_re != raw_kernel[inverse_index].weight_re {
+                        return Err(malformed(
+                            "symmetric-group diagonal kernel violates inverse Hermiticity",
+                        ));
+                    }
+                }
+            }
+            for (relative_index, value) in inverse_kernel.iter_mut().enumerate() {
+                let inverse_index = inverse_relative_indices[relative_index];
+                *value = (raw_kernel[inverse_index].weight_re, 0.0);
+            }
+            fft_plan
+                .forward(&inverse_kernel, &mut transformed_kernel, &mut fft_workspace)
+                .map_err(|error| {
+                    malformed(format!(
+                        "could not transform an authenticated symmetric-group kernel: {error}"
+                    ))
+                })?;
+            if transformed_kernel
+                .iter()
+                .any(|value| value.1 != 0.0 || !value.0.is_finite())
+            {
+                return Err(malformed(
+                    "symmetric-group kernel transform did not produce finite real Young blocks",
+                ));
+            }
+            // Canonical zero rows remain mandatory on wire and participate in
+            // exact-factor authentication above.  Once their transform is
+            // certified zero, retaining a runtime block would only add warmed
+            // traffic and immutable RSS.
+            if transformed_kernel.iter().any(|value| value.0 != 0.0) {
+                let fourier_coefficients = transformed_kernel
+                    .iter()
+                    .map(|value| value.0)
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice();
+                let scalar_same_channel_blocks = if left_channel_index == right_channel_index {
+                    let blocks = fft_plan
+                        .blocks()
+                        .map(|block| {
+                            let start = block.coefficient_offset();
+                            let end = start + block.coefficient_count();
+                            compile_scalar_same_channel_low_rank_block(
+                                &fourier_coefficients[start..end],
+                                block.dimension(),
+                            )
+                        })
+                        .collect::<Vec<_>>();
+                    compact_scalar_same_channel_blocks(blocks)
+                } else {
+                    Box::default()
+                };
+                has_scalar_same_channel_low_rank |=
+                    scalar_same_channel_blocks.iter().any(Option::is_some);
+                kernels.push(RuntimeSymmetricGroupKernel {
+                    left_channel_index: left_channel_index as u32,
+                    right_channel_index: right_channel_index as u32,
+                    pair_scale: if left_channel_index == right_channel_index {
+                        1.0
+                    } else {
+                        2.0
+                    },
+                    fourier_coefficients,
+                });
+                scalar_same_channel_low_rank_kernels.push(RuntimeSymmetricGroupLowRankKernel {
+                    blocks: scalar_same_channel_blocks,
+                });
+            }
+            offset += group_order;
+        }
+    }
+    debug_assert_eq!(offset, kernel_entry_count);
+    debug_assert_eq!(scalar_same_channel_low_rank_kernels.len(), kernels.len());
+    let scalar_same_channel_low_rank_kernels: Option<Arc<[RuntimeSymmetricGroupLowRankKernel]>> =
+        has_scalar_same_channel_low_rank.then(|| Arc::from(scalar_same_channel_low_rank_kernels));
+    let residual_entries: Vec<RuntimeFactorizedColorContractionEntry> = entries
+        [kernel_entry_count..]
+        .iter()
+        .filter_map(|entry| {
+            let coefficient_re = entry.weight_re * entry.symmetry_factor;
+            let coefficient_im = entry.weight_im * entry.symmetry_factor;
+            (coefficient_re != 0.0 || coefficient_im != 0.0).then_some(
+                RuntimeFactorizedColorContractionEntry {
+                    left_group_index: entry.left_group_id,
+                    right_group_index: entry.right_group_id,
+                    coefficient_re,
+                    coefficient_im,
+                },
+            )
+        })
+        .collect();
+    let eligible_group_count = channel_count
+        .checked_mul(group_order)
+        .ok_or_else(|| malformed("symmetric-group eligible group count overflows usize"))?;
+    if eligible_group_count > local_group_count as usize {
+        return Err(malformed(
+            "runtime symmetric-group channel references an out-of-bounds local group",
+        ));
+    }
+    Ok(RuntimeSymmetricGroupColorContraction {
+        degree: factorization.rank(),
+        group_order,
+        channel_count,
+        local_group_count: local_group_count as usize,
+        fft_plan: Arc::new(fft_plan),
+        kernels: kernels.into(),
+        scalar_same_channel_low_rank_kernels,
+        residual_entries: residual_entries.into(),
+    })
+}
+
+fn walsh_butterfly_f64(values: &mut [f64]) {
+    debug_assert!(values.len().is_power_of_two());
+    let mut stride = 1;
+    while stride < values.len() {
+        for start in (0..values.len()).step_by(stride * 2) {
+            for offset in 0..stride {
+                let left = values[start + offset];
+                let right = values[start + stride + offset];
+                values[start + offset] = left + right;
+                values[start + stride + offset] = left - right;
+            }
+        }
+        stride *= 2;
+    }
+}
+
+struct Reader<'a> {
+    bytes: &'a [u8],
+    offset: usize,
+}
+
+impl<'a> Reader<'a> {
+    fn new(bytes: &'a [u8]) -> Self {
+        Self { bytes, offset: 0 }
+    }
+
+    fn take(&mut self, count: usize, label: &str) -> RusticolResult<&'a [u8]> {
+        let end = self
+            .offset
+            .checked_add(count)
+            .ok_or_else(|| malformed(format!("{label} offset overflows usize")))?;
+        let result = self.bytes.get(self.offset..end).ok_or_else(|| {
+            malformed(format!(
+                "truncated {label} at byte {}: need {count}, have {}",
+                self.offset,
+                self.bytes.len().saturating_sub(self.offset)
+            ))
+        })?;
+        self.offset = end;
+        Ok(result)
+    }
+
+    fn u32(&mut self, label: &str) -> RusticolResult<u32> {
+        Ok(u32::from_le_bytes(
+            self.take(4, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn u64(&mut self, label: &str) -> RusticolResult<u64> {
+        Ok(u64::from_le_bytes(
+            self.take(8, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn i128(&mut self, label: &str) -> RusticolResult<i128> {
+        Ok(i128::from_le_bytes(
+            self.take(16, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn f64(&mut self, label: &str) -> RusticolResult<f64> {
+        Ok(f64::from_le_bytes(
+            self.take(8, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn count(&mut self, label: &str) -> RusticolResult<usize> {
+        let value = self.u64(label)?;
+        usize::try_from(value).map_err(|_| malformed(format!("{label} exceeds usize")))
+    }
+
+    fn u32_vec(&mut self, count: usize, label: &str) -> RusticolResult<Vec<u32>> {
+        (0..count).map(|_| self.u32(label)).collect()
+    }
+
+    fn is_finished(&self) -> bool {
+        self.offset == self.bytes.len()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(Clone)]
+    struct TestWire {
+        storage: u32,
+        accuracy: u32,
+        flags: u32,
+        group_count: u32,
+        sector_count: u32,
+        component_count: u32,
+        local_group_count: u32,
+        destination_count: u32,
+        factor_kind: u32,
+        factor_rank: u32,
+        entries: Vec<RawColorContractionEntry>,
+        exact_factors: Vec<ExactComplexRational>,
+        ordered_group_ids: Vec<u32>,
+        destination_by_group: Vec<u32>,
+        sector_by_group: Vec<u32>,
+        component_by_group: Vec<u32>,
+        owner_by_sector: Vec<u32>,
+        cosets: Vec<Vec<u32>>,
+        logical_entry_count: u64,
+    }
+
+    impl TestWire {
+        fn expanded() -> Self {
+            Self {
+                storage: 1,
+                accuracy: 1,
+                flags: FLAG_INCLUDES_COLOR_FACTOR,
+                group_count: 2,
+                sector_count: 2,
+                component_count: 1,
+                local_group_count: 0,
+                destination_count: 12,
+                factor_kind: 0,
+                factor_rank: 0,
+                entries: vec![
+                    RawColorContractionEntry {
+                        left_group_id: 0,
+                        right_group_id: 0,
+                        weight_re: 3.0,
+                        weight_im: 0.0,
+                        symmetry_factor: 1.0,
+                        exact_factor_id: 0,
+                    },
+                    RawColorContractionEntry {
+                        left_group_id: 0,
+                        right_group_id: 1,
+                        weight_re: 2.0,
+                        weight_im: 0.5,
+                        symmetry_factor: 2.0,
+                        exact_factor_id: 1,
+                    },
+                ],
+                exact_factors: vec![
+                    ExactComplexRational::new(
+                        ExactRational::new(3, 1).unwrap(),
+                        ExactRational::ZERO,
+                    ),
+                    ExactComplexRational::new(
+                        ExactRational::new(4, 1).unwrap(),
+                        ExactRational::new(1, 1).unwrap(),
+                    ),
+                ],
+                ordered_group_ids: vec![0, 1],
+                destination_by_group: vec![7, 9],
+                sector_by_group: vec![0, 1],
+                component_by_group: vec![0, 0],
+                owner_by_sector: vec![0, 1],
+                cosets: Vec::new(),
+                logical_entry_count: 2,
+            }
+        }
+
+        fn repeated_k4() -> Self {
+            Self {
+                storage: 2,
+                accuracy: 2,
+                flags: FLAG_INCLUDES_COLOR_FACTOR,
+                group_count: 8,
+                sector_count: 4,
+                component_count: 2,
+                local_group_count: 4,
+                destination_count: 20,
+                factor_kind: 1,
+                factor_rank: 2,
+                entries: (0..4)
+                    .map(|index| RawColorContractionEntry {
+                        left_group_id: index,
+                        right_group_id: index,
+                        weight_re: 1.0,
+                        weight_im: 0.0,
+                        symmetry_factor: 1.0,
+                        exact_factor_id: 0,
+                    })
+                    .collect(),
+                exact_factors: vec![ExactComplexRational::ONE],
+                ordered_group_ids: vec![0, 4, 1, 5, 2, 6, 3, 7],
+                destination_by_group: vec![8, 9, 10, 11, 12, 13, 14, 15],
+                sector_by_group: vec![0, 1, 2, 3, 0, 1, 2, 3],
+                component_by_group: vec![0, 0, 0, 0, 1, 1, 1, 1],
+                owner_by_sector: vec![0, 1, 2, 3],
+                cosets: vec![vec![0, 1, 2, 3]],
+                logical_entry_count: 8,
+            }
+        }
+
+        fn repeated_k4_multicoset() -> Self {
+            let diagonal_blocks = [[2.0, 1.0, 0.0, -1.0], [3.0, 0.5, -0.5, 1.5]];
+            let cross_block = [1.0, 2.0, -1.0, 0.25];
+            let matrix_value = |left: usize, right: usize| {
+                let left_coset = left / 4;
+                let right_coset = right / 4;
+                let xor = (left % 4) ^ (right % 4);
+                if left_coset == right_coset {
+                    diagonal_blocks[left_coset][xor]
+                } else {
+                    cross_block[xor]
+                }
+            };
+            let mut entries = Vec::new();
+            let mut exact_factors = Vec::new();
+            for left in 0..8 {
+                for right in left..8 {
+                    let weight = matrix_value(left, right);
+                    if weight == 0.0 {
+                        continue;
+                    }
+                    let symmetry = if left == right { 1.0 } else { 2.0 };
+                    let coefficient = weight * symmetry;
+                    let exact_factor_id = exact_factors.len() as u32;
+                    exact_factors.push(ExactComplexRational::new(
+                        ExactRational::from_f64_exact(coefficient).unwrap(),
+                        ExactRational::ZERO,
+                    ));
+                    entries.push(RawColorContractionEntry {
+                        left_group_id: left as u32,
+                        right_group_id: right as u32,
+                        weight_re: weight,
+                        weight_im: 0.0,
+                        symmetry_factor: symmetry,
+                        exact_factor_id,
+                    });
+                }
+            }
+            let logical_entry_count = (2 * entries.len()) as u64;
+            Self {
+                storage: 2,
+                accuracy: 2,
+                flags: FLAG_INCLUDES_COLOR_FACTOR,
+                group_count: 16,
+                sector_count: 8,
+                component_count: 2,
+                local_group_count: 8,
+                destination_count: 16,
+                factor_kind: 1,
+                factor_rank: 2,
+                entries,
+                exact_factors,
+                ordered_group_ids: (0..16).collect(),
+                destination_by_group: (0..16).collect(),
+                sector_by_group: (0..8).flat_map(|sector| [sector, sector]).collect(),
+                component_by_group: (0..8).flat_map(|_| [0, 1]).collect(),
+                owner_by_sector: (0..8).collect(),
+                cosets: vec![vec![0, 1, 2, 3], vec![4, 5, 6, 7]],
+                logical_entry_count,
+            }
+        }
+
+        fn convolution_s3_with_residual() -> Self {
+            let diagonal_left = [6.0, 1.0, 2.0, 3.0, 3.0, 4.0];
+            let cross = [1.0, 2.0, 0.0, -1.0, 0.5, 3.0];
+            let diagonal_right = [7.0, 0.0, 2.0, -1.0, -1.0, 0.0];
+            let mut entries = Vec::new();
+            let mut exact_factors = Vec::new();
+            let mut push = |left: u32, right: u32, weight: f64, symmetry: f64| {
+                let exact_factor_id = exact_factors.len() as u32;
+                exact_factors.push(ExactComplexRational::new(
+                    ExactRational::from_f64_exact(weight * symmetry).unwrap(),
+                    ExactRational::ZERO,
+                ));
+                entries.push(RawColorContractionEntry {
+                    left_group_id: left,
+                    right_group_id: right,
+                    weight_re: weight,
+                    weight_im: 0.0,
+                    symmetry_factor: symmetry,
+                    exact_factor_id,
+                });
+            };
+            for (relative, weight) in diagonal_left.into_iter().enumerate() {
+                push(0, relative as u32, weight, 1.0);
+            }
+            for (relative, weight) in cross.into_iter().enumerate() {
+                push(0, 6 + relative as u32, weight, 2.0);
+            }
+            for (relative, weight) in diagonal_right.into_iter().enumerate() {
+                push(6, 6 + relative as u32, weight, 1.0);
+            }
+            // Ordinary direct rows touching the residual suffix follow kernels.
+            push(0, 12, 0.25, 2.0);
+            for left in 1..12 {
+                push(left, 12, 0.0, 2.0);
+            }
+            push(12, 12, 5.0, 1.0);
+            let logical_entry_count = entries.len() as u64;
+            Self {
+                storage: 3,
+                accuracy: 2,
+                flags: FLAG_INCLUDES_COLOR_FACTOR,
+                group_count: 13,
+                sector_count: 13,
+                component_count: 1,
+                local_group_count: 13,
+                destination_count: 20,
+                factor_kind: 3,
+                factor_rank: 3,
+                entries,
+                exact_factors,
+                ordered_group_ids: (0..13).collect(),
+                destination_by_group: (0..13).map(|value| value + 2).collect(),
+                sector_by_group: (0..13).collect(),
+                component_by_group: vec![0; 13],
+                owner_by_sector: (0..13).collect(),
+                cosets: vec![(0..6).collect(), (6..12).collect()],
+                logical_entry_count,
+            }
+        }
+
+        fn encode(&self) -> Vec<u8> {
+            let flattened_cosets = self.cosets.iter().flatten().copied().collect::<Vec<_>>();
+            let payload_bytes = self.entries.len() * ENTRY_BYTES
+                + self.exact_factors.len() * EXACT_FACTOR_BYTES
+                + self.ordered_group_ids.len() * 4
+                + self.destination_by_group.len() * 4
+                + self.sector_by_group.len() * 4
+                + self.component_by_group.len() * 4
+                + self.owner_by_sector.len() * 4
+                + flattened_cosets.len() * 4;
+            let mut bytes = Vec::with_capacity(HEADER_BYTES + payload_bytes);
+            bytes.extend_from_slice(MAGIC);
+            for value in [
+                VERSION,
+                HEADER_BYTES as u32,
+                self.storage,
+                self.accuracy,
+                self.flags,
+                self.group_count,
+                self.sector_count,
+                self.component_count,
+                self.local_group_count,
+                self.destination_count,
+                self.factor_kind,
+                self.factor_rank,
+                ENTRY_BYTES as u32,
+                EXACT_FACTOR_BYTES as u32,
+            ] {
+                bytes.extend_from_slice(&value.to_le_bytes());
+            }
+            for value in [
+                self.entries.len() as u64,
+                self.exact_factors.len() as u64,
+                self.cosets.len() as u64,
+                flattened_cosets.len() as u64,
+                self.logical_entry_count,
+                self.owner_by_sector.len() as u64,
+                payload_bytes as u64,
+            ] {
+                bytes.extend_from_slice(&value.to_le_bytes());
+            }
+            assert_eq!(bytes.len(), HEADER_BYTES);
+            for entry in &self.entries {
+                bytes.extend_from_slice(&entry.left_group_id.to_le_bytes());
+                bytes.extend_from_slice(&entry.right_group_id.to_le_bytes());
+                bytes.extend_from_slice(&entry.weight_re.to_le_bytes());
+                bytes.extend_from_slice(&entry.weight_im.to_le_bytes());
+                bytes.extend_from_slice(&entry.symmetry_factor.to_le_bytes());
+                bytes.extend_from_slice(&entry.exact_factor_id.to_le_bytes());
+            }
+            for factor in &self.exact_factors {
+                for value in [
+                    factor.real().numerator(),
+                    factor.real().denominator(),
+                    factor.imag().numerator(),
+                    factor.imag().denominator(),
+                ] {
+                    bytes.extend_from_slice(&value.to_le_bytes());
+                }
+            }
+            for value in self
+                .ordered_group_ids
+                .iter()
+                .chain(&self.destination_by_group)
+                .chain(&self.sector_by_group)
+                .chain(&self.component_by_group)
+                .chain(&self.owner_by_sector)
+                .chain(&flattened_cosets)
+            {
+                bytes.extend_from_slice(&value.to_le_bytes());
+            }
+            bytes
+        }
+    }
+
+    fn error_contains(bytes: &[u8], expected: &str) {
+        let error = decode_recurrence_color_contraction_v3(bytes).unwrap_err();
+        assert!(
+            error.message().contains(expected),
+            "expected {expected:?} in {:?}",
+            error.message()
+        );
+    }
+
+    #[test]
+    fn expanded_payload_preserves_raw_and_derives_runtime_entries() {
+        let bytes = TestWire::expanded().encode();
+        let plan = decode_recurrence_color_contraction_v3(&bytes).unwrap();
+        assert_eq!(plan.accuracy(), RecurrenceColorAccuracy::Nlc);
+        assert_eq!(plan.storage(), RecurrenceColorStorage::Expanded);
+        assert!(plan.includes_color_factor());
+        assert_eq!(plan.sector_count(), 2);
+        assert_eq!(plan.component_count(), 1);
+        assert_eq!(plan.ordered_group_ids(), [0, 1]);
+        assert_eq!(plan.destination_by_group(), [7, 9]);
+        let raw = plan.canonical_logical_entries().collect::<Vec<_>>();
+        assert_eq!(raw[1].weight_re, 2.0);
+        assert_eq!(raw[1].weight_im, 0.5);
+        assert_eq!(raw[1].symmetry_factor, 2.0);
+        let runtime = plan.runtime_entries().collect::<Vec<_>>();
+        assert_eq!(runtime[1].left_destination_id, 7);
+        assert_eq!(runtime[1].right_destination_id, 9);
+        assert_eq!(runtime[1].coefficient_re, 4.0);
+        assert_eq!(runtime[1].coefficient_im, 1.0);
+        assert_eq!(
+            recurrence_color_contraction_digest(&bytes),
+            recurrence_color_contraction_digest(&bytes)
+        );
+    }
+
+    #[test]
+    fn runtime_entry_contracts_complex_upper_triangle_row() {
+        let plan = decode_recurrence_color_contraction_v3(&TestWire::expanded().encode()).unwrap();
+        let runtime = plan.runtime_entries().collect::<Vec<_>>();
+
+        // The diagonal row contributes 3 * |1 + 2i|^2.
+        assert_eq!(runtime[0].contract_real_bilinear(1.0, 2.0, 1.0, 2.0), 15.0);
+        // The stored upper-triangle row has raw coefficient 2 + 0.5i and
+        // symmetry factor two, hence runtime coefficient 4 + i.
+        assert_eq!(runtime[1].contract_real_bilinear(1.0, 2.0, 3.0, 4.0), 42.0);
+    }
+
+    #[test]
+    fn repeated_k4_payload_expands_logical_rows_without_runtime_allocation() {
+        let bytes = TestWire::repeated_k4().encode();
+        let plan = decode_recurrence_color_contraction_v3(&bytes).unwrap();
+        assert_eq!(plan.storage(), RecurrenceColorStorage::Repeated);
+        assert_eq!(plan.logical_entry_count(), 8);
+        let factor = plan.factorization().unwrap();
+        assert_eq!(
+            factor.kind(),
+            FactorizedColorContractionKind::KleinFourWalsh
+        );
+        assert_eq!(factor.coset(0), Some(&[0, 1, 2, 3][..]));
+        let runtime_factor = plan.runtime_factorization().unwrap();
+        assert_eq!(runtime_factor.subgroup_order(), 4);
+        assert_eq!(runtime_factor.cosets(), [vec![0, 1, 2, 3]]);
+        assert_eq!(runtime_factor.amplitude_scale(), 0.5);
+        assert_eq!(runtime_factor.entries().len(), 4);
+        assert!(runtime_factor.entries().iter().all(|entry| {
+            entry.left_group_index == entry.right_group_index
+                && entry.coefficient_re == 1.0
+                && entry.coefficient_im == 0.0
+        }));
+        assert_eq!(plan.ordered_destination_id(0, 0), Some(8));
+        assert_eq!(plan.ordered_destination_id(0, 1), Some(12));
+        assert_eq!(plan.ordered_destination_id(3, 1), Some(15));
+        let mut entries = plan.canonical_logical_entries();
+        assert_eq!(entries.len(), 8);
+        assert_eq!(entries.next().unwrap().left_group_id, 0);
+        assert_eq!(entries.next().unwrap().left_group_id, 1);
+        assert_eq!(entries.next().unwrap().left_group_id, 2);
+        assert_eq!(entries.next().unwrap().left_group_id, 3);
+        assert_eq!(entries.next().unwrap().left_group_id, 4);
+        assert_eq!(entries.len(), 3);
+    }
+
+    #[test]
+    fn repeated_multicoset_k4_preserves_the_nontrivial_quadratic_form() {
+        let plan =
+            decode_recurrence_color_contraction_v3(&TestWire::repeated_k4_multicoset().encode())
+                .unwrap();
+        let amplitudes = [0.5, -1.25, 2.0, 0.75, -0.4, 1.1, 0.2, -0.9];
+        let direct = plan
+            .entries()
+            .iter()
+            .map(|entry| {
+                entry.weight_re
+                    * entry.symmetry_factor
+                    * amplitudes[entry.left_group_id as usize]
+                    * amplitudes[entry.right_group_id as usize]
+            })
+            .sum::<f64>();
+
+        let factorized = plan.runtime_factorization().unwrap();
+        assert_eq!(factorized.cosets().len(), 2);
+        let mut transformed = [0.0; 8];
+        for coset in factorized.cosets() {
+            let mut values = coset
+                .iter()
+                .map(|index| amplitudes[*index as usize])
+                .collect::<Vec<_>>();
+            walsh_butterfly_f64(&mut values);
+            for (index, value) in coset.iter().zip(values) {
+                transformed[*index as usize] = value * factorized.amplitude_scale();
+            }
+        }
+        let transformed_value = factorized
+            .entries()
+            .iter()
+            .map(|entry| {
+                entry.coefficient_re
+                    * transformed[entry.left_group_index as usize]
+                    * transformed[entry.right_group_index as usize]
+            })
+            .sum::<f64>();
+        assert!((direct - transformed_value).abs() <= 32.0 * f64::EPSILON);
+    }
+
+    #[test]
+    fn symmetric_group_payload_preserves_kernel_orientation_and_residual_rows() {
+        let plan = decode_recurrence_color_contraction_v3(
+            &TestWire::convolution_s3_with_residual().encode(),
+        )
+        .unwrap();
+        assert_eq!(plan.storage(), RecurrenceColorStorage::ConvolutionKernels);
+        let factorization = plan.factorization().unwrap();
+        assert_eq!(
+            factorization.kind(),
+            FactorizedColorContractionKind::SymmetricGroupFourier
+        );
+        assert_eq!(factorization.rank(), 3);
+        assert_eq!(factorization.subgroup_order(), 6);
+        assert_eq!(factorization.coset(0), Some(&[0, 1, 2, 3, 4, 5][..]));
+        assert_eq!(factorization.coset(1), Some(&[6, 7, 8, 9, 10, 11][..]));
+        let RuntimeColorContractionReducer::SymmetricGroupFourier(runtime) =
+            plan.runtime_reducer().unwrap()
+        else {
+            panic!("expected symmetric-group runtime reducer")
+        };
+        assert_eq!(runtime.degree(), 3);
+        assert_eq!(runtime.group_order(), 6);
+        assert_eq!(runtime.channel_count(), 2);
+        assert_eq!(runtime.local_group_count(), 13);
+        assert_eq!(runtime.kernels().len(), 3);
+        assert_eq!(runtime.kernels()[1].left_channel_index(), 0);
+        assert_eq!(runtime.kernels()[1].right_channel_index(), 1);
+        assert_eq!(runtime.kernels()[0].pair_scale(), 1.0);
+        assert_eq!(runtime.kernels()[1].pair_scale(), 2.0);
+        let fft_plan = SymmetricGroupFftPlan::new(3).unwrap();
+        assert!(runtime.scalar_same_channel_low_rank_kernels.is_none());
+        let raw_cross = [1.0, 2.0, 0.0, -1.0, 0.5, 3.0];
+        let inverse_cross = (0..fft_plan.order())
+            .map(|index| {
+                (
+                    raw_cross[fft_plan.inverse_lexicographic_index(index).unwrap()],
+                    0.0,
+                )
+            })
+            .collect::<Vec<_>>();
+        let mut expected_fourier = vec![(0.0, 0.0); fft_plan.order()];
+        let mut fft_workspace = fft_plan.workspace(1).unwrap();
+        fft_plan
+            .forward(&inverse_cross, &mut expected_fourier, &mut fft_workspace)
+            .unwrap();
+        assert_eq!(
+            runtime.kernels()[1].fourier_coefficients(),
+            expected_fourier
+                .iter()
+                .map(|value| value.0)
+                .collect::<Vec<_>>()
+        );
+        assert_eq!(runtime.residual_entries().len(), 2);
+        assert_eq!(runtime.residual_entries()[0].left_group_index, 0);
+        assert_eq!(runtime.residual_entries()[0].right_group_index, 12);
+        assert_eq!(runtime.residual_entries()[0].coefficient_re, 0.5);
+        assert_eq!(plan.stored_entry_count(), 31);
+        assert_eq!(plan.logical_entry_count(), 31);
+        assert!(plan.entries().is_empty());
+        assert!(plan.exact_factors().is_empty());
+    }
+
+    fn test_low_rank_effective_kernel() -> (usize, Vec<f64>) {
+        let dimension = 5;
+        let root_two = 2.0_f64.sqrt();
+        let columns = [
+            [root_two, 0.0, 1.0 / root_two, 0.0, 0.0],
+            [0.0, root_two, 0.0, 1.0 / root_two, 0.0],
+        ];
+        let mut kernel = vec![0.0; dimension * dimension];
+        for column in 0..dimension {
+            for row in 0..dimension {
+                kernel[column * dimension + row] = columns
+                    .iter()
+                    .map(|factor| factor[column] * factor[row])
+                    .sum();
+            }
+        }
+        // Only the effective symmetric part is contracted. Opposite skew
+        // perturbations must therefore leave the derived factor unchanged.
+        kernel[2] += 0.125;
+        kernel[2 * dimension] -= 0.125;
+        (dimension, kernel)
+    }
+
+    #[test]
+    fn scalar_low_rank_factorization_is_deterministic_scale_relative_and_certified() {
+        let (dimension, kernel) = test_low_rank_effective_kernel();
+        let factor = compile_scalar_same_channel_low_rank_block(&kernel, dimension).unwrap();
+        assert_eq!(factor.rank, 2);
+        // Equal leading residual diagonals choose original index zero first
+        // and original index one second.
+        assert!((factor.factors[0] - 2.0_f64.sqrt()).abs() <= 8.0 * f64::EPSILON);
+        assert_eq!(factor.factors[1], 0.0);
+        assert_eq!(factor.factors[dimension], 0.0);
+        assert!((factor.factors[dimension + 1] - 2.0_f64.sqrt()).abs() <= 8.0 * f64::EPSILON);
+
+        let tiny_scale = 1.0e-200;
+        let mut tiny = vec![0.0; dimension * dimension];
+        tiny[0] = tiny_scale;
+        let tiny_factor = compile_scalar_same_channel_low_rank_block(&tiny, dimension).unwrap();
+        assert_eq!(tiny_factor.rank, 1);
+        assert!(tiny_factor.factors[0] > 0.0);
+        assert!(tiny_factor.factors[0] < 1.0e-90);
+
+        let mut effective = kernel.clone();
+        let symmetric = 0.5 * kernel[2] + 0.5 * kernel[2 * dimension];
+        effective[2] = symmetric;
+        effective[2 * dimension] = symmetric;
+        let scale = (0..dimension)
+            .map(|index| effective[index * dimension + index])
+            .fold(f64::NEG_INFINITY, f64::max);
+        let tolerance =
+            LOW_RANK_PIVOT_TOLERANCE_MULTIPLIER * f64::EPSILON * dimension as f64 * scale;
+        assert!(low_rank_factor_reconstructs_effective_kernel(
+            &effective,
+            dimension,
+            factor.rank,
+            &factor.factors,
+            tolerance,
+        ));
+        let mut corrupted = factor.factors.to_vec();
+        corrupted[0] += 1.0e-5;
+        assert!(!low_rank_factor_reconstructs_effective_kernel(
+            &effective,
+            dimension,
+            factor.rank,
+            &corrupted,
+            tolerance,
+        ));
+    }
+
+    #[test]
+    fn scalar_low_rank_factorization_falls_back_for_invalid_or_unprofitable_blocks() {
+        let dimension = 5;
+        let zero = vec![0.0; dimension * dimension];
+        let zero_factor = compile_scalar_same_channel_low_rank_block(&zero, dimension).unwrap();
+        assert_eq!(zero_factor.rank, 0);
+        assert!(zero_factor.factors.is_empty());
+
+        let mut negative_diagonal = zero;
+        negative_diagonal[0] = -1.0;
+        assert!(
+            compile_scalar_same_channel_low_rank_block(&negative_diagonal, dimension).is_none()
+        );
+
+        let mut indefinite = vec![0.0; dimension * dimension];
+        for index in 0..dimension {
+            indefinite[index * dimension + index] = 1.0;
+        }
+        indefinite[1] = 2.0;
+        indefinite[dimension] = 2.0;
+        assert!(compile_scalar_same_channel_low_rank_block(&indefinite, dimension).is_none());
+
+        let mut nonfinite = indefinite;
+        nonfinite[0] = f64::NAN;
+        assert!(compile_scalar_same_channel_low_rank_block(&nonfinite, dimension).is_none());
+
+        let mut full_rank = vec![0.0; dimension * dimension];
+        for index in 0..dimension {
+            full_rank[index * dimension + index] = 1.0;
+        }
+        assert!(compile_scalar_same_channel_low_rank_block(&full_rank, dimension).is_none());
+        assert!(!low_rank_scalar_cost_is_profitable(dimension, dimension));
+        assert!(low_rank_scalar_cost_is_profitable(dimension, 2));
+
+        let compacted = compact_scalar_same_channel_blocks(vec![None, None]);
+        assert!(compacted.is_empty());
+        let compacted = compact_scalar_same_channel_blocks(vec![Some(zero_factor), None]);
+        assert_eq!(compacted.len(), 2);
+        assert!(compacted[0].is_some());
+        assert!(compacted[1].is_none());
+    }
+
+    #[test]
+    fn scalar_low_rank_contraction_matches_dense_and_batches_fall_back_exactly() {
+        let (dimension, kernel) = test_low_rank_effective_kernel();
+        let factor = compile_scalar_same_channel_low_rank_block(&kernel, dimension).unwrap();
+        let coefficient_offset = 3;
+        let lane_capacity = 2;
+        let amplitudes = (0..(coefficient_offset + dimension * dimension) * lane_capacity)
+            .map(|index| {
+                (
+                    ((index * 17 + 5) % 31) as f64 / 11.0 - 1.2,
+                    ((index * 13 + 3) % 29) as f64 / 9.0 - 0.8,
+                )
+            })
+            .collect::<Vec<_>>();
+        let weight = 0.375;
+        let mut dense = [0.25, -0.5];
+        let mut low_rank = dense;
+        contract_real_hermitian_same_channel_block(
+            &amplitudes,
+            &kernel,
+            dimension,
+            coefficient_offset,
+            lane_capacity,
+            1,
+            weight,
+            &mut dense,
+        );
+        contract_real_hermitian_same_channel_block_opportunistic(
+            &amplitudes,
+            &kernel,
+            Some(&factor),
+            dimension,
+            coefficient_offset,
+            lane_capacity,
+            1,
+            weight,
+            &mut low_rank,
+        );
+        let scale = dense[0].abs().max(1.0);
+        assert!((low_rank[0] - dense[0]).abs() <= 2.0e-12 * scale);
+        assert_eq!(low_rank[1], dense[1]);
+
+        let mut dense_batch = [0.25, -0.5];
+        let mut fallback_batch = dense_batch;
+        contract_real_hermitian_same_channel_block(
+            &amplitudes,
+            &kernel,
+            dimension,
+            coefficient_offset,
+            lane_capacity,
+            2,
+            weight,
+            &mut dense_batch,
+        );
+        contract_real_hermitian_same_channel_block_opportunistic(
+            &amplitudes,
+            &kernel,
+            Some(&factor),
+            dimension,
+            coefficient_offset,
+            lane_capacity,
+            2,
+            weight,
+            &mut fallback_batch,
+        );
+        assert_eq!(fallback_batch, dense_batch);
+
+        let malformed_factor = RuntimeSymmetricGroupLowRankBlock {
+            rank: factor.rank,
+            factors: factor.factors[..factor.factors.len() - 1]
+                .to_vec()
+                .into_boxed_slice(),
+        };
+        let mut malformed_fallback = [0.25, -0.5];
+        contract_real_hermitian_same_channel_block_opportunistic(
+            &amplitudes,
+            &kernel,
+            Some(&malformed_factor),
+            dimension,
+            coefficient_offset,
+            lane_capacity,
+            1,
+            weight,
+            &mut malformed_fallback,
+        );
+        assert_eq!(malformed_fallback, dense);
+    }
+
+    #[test]
+    fn real_hermitian_same_channel_microkernel_matches_dense_complex_form() {
+        for &(dimension, lane_count, lane_capacity) in &[(1, 1, 2), (5, 1, 3), (9, 3, 4)] {
+            let coefficient_offset = 2;
+            let weight = 0.375;
+            let amplitude_count = (coefficient_offset + dimension * dimension) * lane_capacity;
+            let amplitudes = (0..amplitude_count)
+                .map(|index| {
+                    (
+                        ((index * 17 + 3) % 31) as f64 / 11.0 - 1.2,
+                        ((index * 13 + 7) % 29) as f64 / 9.0 - 0.7,
+                    )
+                })
+                .collect::<Vec<_>>();
+            // The loader certifies mathematical symmetry.  Keeping a tiny
+            // representational asymmetry here verifies that pairing K_ci and
+            // K_ic still reproduces the previous full dense traversal.
+            let kernel = (0..dimension * dimension)
+                .map(|index| {
+                    let row = index % dimension;
+                    let column = index / dimension;
+                    0.25 * (row + column + 1) as f64 + if row < column { 3.0e-14 } else { 0.0 }
+                })
+                .collect::<Vec<_>>();
+            let initial = (0..lane_capacity)
+                .map(|lane| lane as f64 * 0.125 - 0.25)
+                .collect::<Vec<_>>();
+            let mut expected = initial.clone();
+            for column in 0..dimension {
+                for inner in 0..dimension {
+                    let kernel_value = kernel[column * dimension + inner] * weight;
+                    for row in 0..dimension {
+                        let left = (coefficient_offset + column * dimension + row) * lane_capacity;
+                        let right = (coefficient_offset + inner * dimension + row) * lane_capacity;
+                        for lane in 0..lane_count {
+                            let left_value = amplitudes[left + lane];
+                            let right_value = amplitudes[right + lane];
+                            let product_re = left_value
+                                .0
+                                .mul_add(right_value.0, left_value.1 * right_value.1);
+                            expected[lane] = kernel_value.mul_add(product_re, expected[lane]);
+                        }
+                    }
+                }
+            }
+
+            let mut actual = initial;
+            let amplitude_pointer = amplitudes.as_ptr();
+            let kernel_pointer = kernel.as_ptr();
+            let reduced_pointer = actual.as_ptr();
+            contract_real_hermitian_same_channel_block(
+                &amplitudes,
+                &kernel,
+                dimension,
+                coefficient_offset,
+                lane_capacity,
+                lane_count,
+                weight,
+                &mut actual,
+            );
+            assert_eq!(amplitudes.as_ptr(), amplitude_pointer);
+            assert_eq!(kernel.as_ptr(), kernel_pointer);
+            assert_eq!(actual.as_ptr(), reduced_pointer);
+            for lane in 0..lane_count {
+                let scale = expected[lane].abs().max(1.0);
+                assert!(
+                    (actual[lane] - expected[lane]).abs() <= 2.0e-12 * scale,
+                    "dimension={dimension}, lane={lane}: {} != {}",
+                    actual[lane],
+                    expected[lane]
+                );
+            }
+            assert_eq!(&actual[lane_count..], &expected[lane_count..]);
+        }
+    }
+
+    #[test]
+    fn symmetric_group_reducer_matches_dense_complex_multichannel_metric_and_reuses_scratch() {
+        let wire = TestWire::convolution_s3_with_residual();
+        let plan = decode_recurrence_color_contraction_v3(&wire.encode()).unwrap();
+        let RuntimeColorContractionReducer::SymmetricGroupFourier(reducer) =
+            plan.runtime_reducer().unwrap()
+        else {
+            panic!("expected symmetric-group runtime reducer")
+        };
+        let covered_group_count = reducer.channel_count() * reducer.group_order();
+        assert!(reducer.channel_count() > 0);
+        assert!(reducer.local_group_count() > covered_group_count);
+        assert!(reducer.residual_entries().iter().any(|entry| {
+            entry.left_group_index < covered_group_count as u32
+                && entry.right_group_index >= covered_group_count as u32
+        }));
+        let lane_count = 3;
+        let amplitudes = (0..reducer.local_group_count() * lane_count)
+            .map(|index| {
+                let real = ((index * 17 + 5) % 29) as f64 / 7.0 - 1.5;
+                let imaginary = ((index * 11 + 3) % 23) as f64 / 9.0 - 0.8;
+                (real, imaginary)
+            })
+            .collect::<Vec<_>>();
+        // Native lanes allocate their bounded full-tile capacity before warm
+        // execution.  A full tile followed by an odd tail must reuse every
+        // backing allocation.
+        let mut workspace = reducer.workspace(lane_count).unwrap();
+        assert_eq!(workspace.lane_capacity, lane_count);
+        assert_eq!(
+            workspace.gathered.len(),
+            reducer.local_group_count() * lane_count
+        );
+        reducer
+            .reduce_lanes(&mut workspace, lane_count, |group, lane| {
+                Ok(amplitudes[group * lane_count + lane])
+            })
+            .unwrap();
+
+        let expected = RecurrenceColorContraction::symmetric_group_s3_dense_for_runtime_test(
+            &amplitudes,
+            lane_count,
+        );
+        for (actual, expected) in workspace.reduced(lane_count).unwrap().iter().zip(expected) {
+            let scale = expected.abs().max(1.0);
+            assert!((actual - expected).abs() <= 2.0e-11 * scale);
+        }
+
+        let gathered_pointer = workspace.gathered.as_ptr();
+        let transformed_pointer = workspace.transformed.as_ptr();
+        let reduced_pointer = workspace.reduced.as_ptr();
+        reducer
+            .reduce_lanes(&mut workspace, 2, |group, lane| {
+                Ok(amplitudes[group * lane_count + lane])
+            })
+            .unwrap();
+        assert_eq!(workspace.lane_capacity, lane_count);
+        assert_eq!(workspace.gathered.as_ptr(), gathered_pointer);
+        assert_eq!(workspace.transformed.as_ptr(), transformed_pointer);
+        assert_eq!(workspace.reduced.as_ptr(), reduced_pointer);
+    }
+
+    #[test]
+    fn symmetric_group_runtime_drops_authenticated_all_zero_kernel_blocks() {
+        let mut wire = TestWire::convolution_s3_with_residual();
+        for entry in &mut wire.entries[6..12] {
+            entry.weight_re = 0.0;
+            wire.exact_factors[entry.exact_factor_id as usize] = ExactComplexRational::ZERO;
+        }
+        let plan = decode_recurrence_color_contraction_v3(&wire.encode()).unwrap();
+        let RuntimeColorContractionReducer::SymmetricGroupFourier(reducer) =
+            plan.runtime_reducer().unwrap()
+        else {
+            panic!("expected symmetric-group runtime reducer")
+        };
+        assert_eq!(reducer.kernels().len(), 2);
+        assert!(
+            reducer
+                .kernels()
+                .iter()
+                .all(|kernel| kernel.left_channel_index() == kernel.right_channel_index())
+        );
+        assert_eq!(plan.stored_entry_count(), wire.entries.len());
+    }
+
+    #[test]
+    fn symmetric_group_clones_share_immutable_data_and_keep_workspaces_isolated() {
+        let plan = decode_recurrence_color_contraction_v3(
+            &TestWire::convolution_s3_with_residual().encode(),
+        )
+        .unwrap();
+        let RuntimeColorContractionReducer::SymmetricGroupFourier(reducer) =
+            plan.runtime_reducer().unwrap()
+        else {
+            panic!("expected symmetric-group runtime reducer")
+        };
+        let first = reducer.clone();
+        let second = reducer.clone();
+        assert!(Arc::ptr_eq(&first.fft_plan, &second.fft_plan));
+        assert!(Arc::ptr_eq(&first.kernels, &second.kernels));
+        assert!(Arc::ptr_eq(
+            &first.residual_entries,
+            &second.residual_entries
+        ));
+
+        let run = |reducer: RuntimeSymmetricGroupColorContraction, scale: f64| {
+            std::thread::spawn(move || {
+                let mut workspace = reducer.workspace(1).unwrap();
+                reducer
+                    .reduce_lanes(&mut workspace, 1, |group, _| {
+                        Ok((scale * (group + 1) as f64, -0.25 * scale))
+                    })
+                    .unwrap();
+                workspace.reduced(1).unwrap()[0]
+            })
+        };
+        let first_value = run(first, 1.0).join().unwrap();
+        let second_value = run(second, 2.0).join().unwrap();
+        let scale = first_value.abs().max(1.0);
+        assert!((second_value - 4.0 * first_value).abs() <= 2.0e-11 * scale);
+    }
+
+    #[test]
+    fn decoder_rejects_symmetric_group_kernel_and_residual_tampering() {
+        let mut missing_zero = TestWire::convolution_s3_with_residual();
+        missing_zero.entries.remove(8);
+        missing_zero.logical_entry_count -= 1;
+        error_contains(&missing_zero.encode(), "canonical");
+
+        let mut bad_symmetry = TestWire::convolution_s3_with_residual();
+        bad_symmetry.entries[6].symmetry_factor = 1.0;
+        bad_symmetry.entries[6].exact_factor_id = bad_symmetry.exact_factors.len() as u32;
+        bad_symmetry.exact_factors.push(ExactComplexRational::ONE);
+        error_contains(&bad_symmetry.encode(), "canonical");
+
+        let mut non_hermitian = TestWire::convolution_s3_with_residual();
+        non_hermitian.entries[3].weight_re = 9.0;
+        non_hermitian.entries[3].exact_factor_id = non_hermitian.exact_factors.len() as u32;
+        non_hermitian.exact_factors.push(ExactComplexRational::new(
+            ExactRational::new(9, 1).unwrap(),
+            ExactRational::ZERO,
+        ));
+        error_contains(&non_hermitian.encode(), "inverse Hermiticity");
+
+        let mut eligible_only_residual = TestWire::convolution_s3_with_residual();
+        eligible_only_residual.entries[18].left_group_id = 1;
+        eligible_only_residual.entries[18].right_group_id = 11;
+        error_contains(&eligible_only_residual.encode(), "residual row");
+
+        let mut complex_residual = TestWire::convolution_s3_with_residual();
+        complex_residual.entries[18].weight_im = 0.5;
+        complex_residual.entries[18].exact_factor_id = complex_residual.exact_factors.len() as u32;
+        complex_residual
+            .exact_factors
+            .push(ExactComplexRational::new(
+                ExactRational::new(1, 2).unwrap(),
+                ExactRational::new(1, 1).unwrap(),
+            ));
+        error_contains(&complex_residual.encode(), "complex coefficient");
+
+        let mut bad_residual_symmetry = TestWire::convolution_s3_with_residual();
+        bad_residual_symmetry.entries[18].symmetry_factor = 1.0;
+        bad_residual_symmetry.entries[18].exact_factor_id =
+            bad_residual_symmetry.exact_factors.len() as u32;
+        bad_residual_symmetry
+            .exact_factors
+            .push(ExactComplexRational::new(
+                ExactRational::new(1, 4).unwrap(),
+                ExactRational::ZERO,
+            ));
+        error_contains(&bad_residual_symmetry.encode(), "symmetry factor");
+    }
+
+    #[test]
+    fn decoder_rejects_mixed_duplicate_out_of_bounds_and_nonfinite_data() {
+        let mut mixed = TestWire::expanded();
+        mixed.factor_kind = 1;
+        mixed.factor_rank = 2;
+        mixed.cosets = vec![vec![0, 1, 2, 3]];
+        error_contains(&mixed.encode(), "mixed");
+
+        let mut duplicate = TestWire::expanded();
+        duplicate.entries.push(duplicate.entries[0]);
+        duplicate.logical_entry_count += 1;
+        error_contains(&duplicate.encode(), "duplicates");
+
+        let mut out_of_bounds = TestWire::expanded();
+        out_of_bounds.entries[0].left_group_id = 2;
+        error_contains(&out_of_bounds.encode(), "out-of-bounds");
+
+        let mut nonfinite = TestWire::expanded();
+        nonfinite.entries[0].weight_re = f64::NAN;
+        error_contains(&nonfinite.encode(), "non-finite");
+
+        let mut duplicate_destination = TestWire::expanded();
+        duplicate_destination.destination_by_group = vec![7, 7];
+        error_contains(&duplicate_destination.encode(), "duplicate Direct-Arena");
+    }
+
+    #[test]
+    fn decoder_rejects_inconsistent_factorization_map_and_matrix() {
+        let mut duplicate_coset = TestWire::repeated_k4();
+        duplicate_coset.cosets[0][3] = 2;
+        error_contains(&duplicate_coset.encode(), "duplicate ID");
+
+        let mut non_invariant = TestWire::repeated_k4();
+        non_invariant.entries[0].weight_re = 2.0;
+        non_invariant.entries[0].exact_factor_id = 1;
+        non_invariant.exact_factors.push(ExactComplexRational::new(
+            ExactRational::new(2, 1).unwrap(),
+            ExactRational::ZERO,
+        ));
+        error_contains(&non_invariant.encode(), "inconsistent");
+    }
+
+    #[test]
+    fn decoder_rejects_incomplete_or_noncanonical_sector_ownership() {
+        let mut missing_owner = TestWire::expanded();
+        missing_owner.owner_by_sector = vec![0, 0];
+        error_contains(&missing_owner.encode(), "owner sectors");
+
+        let mut forward_owner = TestWire::expanded();
+        forward_owner.owner_by_sector = vec![1, 1];
+        error_contains(&forward_owner.encode(), "invalid canonical owner");
+    }
+
+    #[test]
+    fn decoder_rejects_cross_component_expanded_entries_and_trailing_bytes() {
+        let mut cross_component = TestWire::expanded();
+        cross_component.sector_count = 1;
+        cross_component.component_count = 2;
+        cross_component.sector_by_group = vec![0, 0];
+        cross_component.component_by_group = vec![0, 1];
+        cross_component.owner_by_sector = vec![0];
+        error_contains(&cross_component.encode(), "different components");
+
+        let mut trailing = TestWire::expanded().encode();
+        trailing.push(0);
+        error_contains(&trailing, "fixed-width sections");
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/construct.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/construct.rs
new file mode 100644
index 0000000000..bd3b309662
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/construct.rs
@@ -0,0 +1,16738 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Compact model-generic recurrence construction.
+
+use std::cell::{Cell, RefCell};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
+use std::iter::Peekable;
+use std::rc::Rc;
+use std::time::{Duration, Instant};
+
+use sha2::{Digest, Sha256};
+
+use super::contact_orbit_owner::{
+    PreparedContactOrbitTransition, prepare_contact_orbit_transition,
+    selected_contact_orbit_owner_tokens,
+};
+use super::fermion_ordering::{
+    FermionOrderingContext, authenticated_source_requires_exterior_sign, fermion_ordering_factor,
+};
+use super::layout::RuntimeSourceVariantBinding;
+use super::process::{
+    FermionPairingEndpointPairRow, FermionPairingRuleRow, OwnedRecurrenceProcessInput,
+    ProcessLCSectorKind, ProcessPhysicalLCSectorRow, ProcessSourceStateRow,
+    ValidatedFermionPairingCatalog,
+};
+use super::program::closure_candidate_identity_digest_v1;
+use super::template::{
+    ClosureRow, ColorContractionRow, CurrentOrientation, EvaluatorCallableKind,
+    EvaluatorContractKind, LCColorTransitionWitnessRow, OutputFactorSource,
+    OwnedRecurrenceTemplateInput, ParticleStatistics, QuantumFlowRow, RuntimeHelicityContractRow,
+    RuntimeHelicityVariantRow, SourceRow, TransitionRow,
+};
+use super::{
+    AuthenticatedRecurrenceBuilderInput, CanonicalMomentumLinearForm, CheckedTableRange,
+    ClosureCandidateDomainCertificateV1, ClosureExecutionProofGroupV2, ClosureProofContributionV2,
+    ClosureProofMetadataV2, ClosureTargetDomainCertificateV1, ContributionKey, CurrentCoreKey,
+    CurrentHelicityIdentity, CurrentSourceBinding, DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS,
+    DynamicLCColorState, DynamicLCColorStateId, DynamicLCColorStateInterner, ExactComplexRational,
+    ExactRational, LCColorComponent, LCColorComponentKind, LCColorComponentOperation,
+    LCColorComponentRole, LCColorParentPort, LCColorPortWiring, LCColorSourceSeed,
+    LCColorSourceSeedOperation, LCColorTransitionWitness, LCColorWitnessTermId, MomentumTerm,
+    RecurrenceAmplitudeDestination, RecurrenceClosureTerm, RecurrenceContribution,
+    RecurrenceCurrent, RecurrenceFinalization, RecurrenceNodeKind, RecurrenceProgram,
+    RecurrenceReplayTarget, RecurrenceResolvedHelicity, RecurrenceStrategy,
+    ReflectionCertificateV1, SemanticDigest, SourceStateAssignment,
+    ThreeLineTraversalCertificateV1, ThreeLineTraversalKindV1, closure_component_factor_digest_v2,
+    closure_selector_domain_digest_v2,
+};
+use crate::{RusticolError, RusticolResult};
+
+const MISSING_U32: u32 = u32::MAX;
+const PROGRESS_PAIR_INTERVAL: usize = 16_384;
+const PROGRESS_TIME_INTERVAL: Duration = Duration::from_millis(250);
+const PURE_MASSLESS_ADJOINT_HELICITY_SUPPORT_ROLE: &str =
+    "helicity-support:pure-massless-adjoint-tree-v1";
+const GLOBAL_HELICITY_FLIP_EQUIVALENCE_ROLE: &str = "helicity-equivalence:global-flip-v1";
+const CYCLIC_TRACE_CLOSURE_ANCHOR_ALGORITHM: &str = "canonical-lc-closure-anchor-v4";
+const REFLECTION_PROOF_ALGORITHM_ID: u32 = 1;
+const THREE_LINE_DIRECT_CERTIFICATE_ID: u32 = 0;
+const THREE_LINE_PARTNER_CERTIFICATE_ID: u32 = 1;
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+thread_local! {
+    static ESTABLISHED_PAIRING_OWNER_OBSERVATION_ACTIVE: Cell<bool> = const { Cell::new(false) };
+    static ESTABLISHED_PAIRING_OWNER_OBSERVATION:
+        RefCell<Option<RusticolResult<Vec<Option<u32>>>>> = const { RefCell::new(None) };
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+#[allow(dead_code)]
+pub(crate) fn begin_established_pairing_owner_observation() {
+    ESTABLISHED_PAIRING_OWNER_OBSERVATION_ACTIVE.with(|active| active.set(true));
+    ESTABLISHED_PAIRING_OWNER_OBSERVATION.with(|observation| {
+        *observation.borrow_mut() = None;
+    });
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+#[allow(dead_code)]
+pub(crate) fn take_established_pairing_owner_observation() -> RusticolResult<Vec<Option<u32>>> {
+    ESTABLISHED_PAIRING_OWNER_OBSERVATION_ACTIVE.with(|active| active.set(false));
+    ESTABLISHED_PAIRING_OWNER_OBSERVATION.with(|observation| {
+        observation.borrow_mut().take().ok_or_else(|| {
+            invalid("established builder did not publish its retained pairing owner")
+        })?
+    })
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+fn observe_established_pairing_owner(
+    selected_domain: Option<&(u32, Box<[SourceStateAssignment]>)>,
+    projection: Option<&PendingColorProjection>,
+    pending_closures: &BTreeMap<PendingClosureKey, PendingClosureGroup>,
+) {
+    if !ESTABLISHED_PAIRING_OWNER_OBSERVATION_ACTIVE.with(Cell::get) {
+        return;
+    }
+    let result = (|| {
+        let (selected_sector, selected_source_states) = selected_domain.ok_or_else(|| {
+            invalid("established pairing-owner observation has no selected closure domain")
+        })?;
+        let owner_for_group = |group: &PendingClosureGroup| -> RusticolResult<Option<u32>> {
+            let rule_ids = group
+                .contributions
+                .iter()
+                .flat_map(|contribution| contribution.pairing_certificate_ids.iter().copied())
+                .collect::<BTreeSet<_>>();
+            match rule_ids.len() {
+                0 => Ok(None),
+                1 => Ok(rule_ids.iter().next().copied()),
+                _ => Err(invalid(format!(
+                    "established retained closure has {} pairing owners, expected exactly one",
+                    rule_ids.len(),
+                ))),
+            }
+        };
+        let mut owners = Vec::new();
+        if let Some(projection) = projection {
+            for projected in projection.closures.values().filter(|projected| {
+                projected.identity.target_sector_id == *selected_sector
+                    && projected.identity.complete_source_states.as_ref()
+                        == selected_source_states.as_ref()
+            }) {
+                owners.push(owner_for_group(&projected.representative_group)?);
+            }
+        } else {
+            for group in pending_closures
+                .iter()
+                .filter(|(key, group)| {
+                    key.target_sector_id == *selected_sector
+                        && key.complete_source_states.as_ref() == selected_source_states.as_ref()
+                        && !group.exact_factor.is_zero()
+                })
+                .map(|(_, group)| group)
+            {
+                owners.push(owner_for_group(group)?);
+            }
+        }
+        if owners.is_empty() {
+            return Err(invalid(
+                "established selected closure domain has no retained pairing owners",
+            ));
+        }
+        Ok(owners)
+    })();
+    ESTABLISHED_PAIRING_OWNER_OBSERVATION_ACTIVE.with(|active| active.set(false));
+    ESTABLISHED_PAIRING_OWNER_OBSERVATION.with(|observation| {
+        *observation.borrow_mut() = Some(result);
+    });
+}
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+fn hash_exact_factor(hash: &mut Sha256, factor: ExactComplexRational) {
+    for rational in [factor.real(), factor.imag()] {
+        hash.update(rational.numerator().to_le_bytes());
+        hash.update(rational.denominator().to_le_bytes());
+    }
+}
+
+fn semantic_digest_from_u32_fields(
+    domain: &[u8],
+    values: impl IntoIterator<Item = u32>,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(domain);
+    for value in values {
+        hash.update(value.to_le_bytes());
+    }
+    SemanticDigest::new(hash.finalize().into())
+}
+
+fn hash_digest_sequence(hash: &mut Sha256, values: &[SemanticDigest]) -> RusticolResult<()> {
+    hash.update(
+        u64::try_from(values.len())
+            .map_err(|_| invalid("reflection proof digest count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for value in values {
+        hash.update(value.as_bytes());
+    }
+    Ok(())
+}
+
+pub(super) fn dynamic_color_identity_digest(
+    color: &DynamicLCColorState,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-dynamic-lc-color-identity-v1\0");
+    hash.update(color.output_color_shape_id().to_le_bytes());
+    hash.update(
+        color
+            .active_component_index()
+            .unwrap_or(u32::MAX)
+            .to_le_bytes(),
+    );
+    hash.update(
+        u64::try_from(color.components().len())
+            .map_err(|_| invalid("dynamic LC color component count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for component in color.components() {
+        hash.update([component.kind() as u8]);
+        hash.update(
+            u64::try_from(component.source_slots().len())
+                .map_err(|_| invalid("dynamic LC color word length exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for source_slot in component.source_slots() {
+            hash.update(source_slot.to_le_bytes());
+        }
+    }
+    hash.update(
+        u64::try_from(color.result_port_bindings().len())
+            .map_err(|_| invalid("dynamic LC color port count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for binding in color.result_port_bindings() {
+        hash.update(binding.component_index().to_le_bytes());
+        hash.update([binding.endpoint() as u8]);
+    }
+    SemanticDigest::new(hash.finalize().into())
+}
+
+fn source_reflection_proof_root(
+    source_slot: u32,
+    source_seed_proof: SemanticDigest,
+    result_color_identity: SemanticDigest,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-source-color-reflection-root-v1\0");
+    hash.update(source_slot.to_le_bytes());
+    hash.update(source_seed_proof.as_bytes());
+    hash.update(result_color_identity.as_bytes());
+    SemanticDigest::new(hash.finalize().into())
+}
+
+fn transition_reflection_proof_digest(
+    phase: ExactComplexRational,
+    semantic_digests: &[SemanticDigest],
+    witness_digests: &[SemanticDigest],
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-transition-reflection-proof-v1\0");
+    hash_exact_factor(&mut hash, phase);
+    hash_digest_sequence(&mut hash, semantic_digests)?;
+    hash_digest_sequence(&mut hash, witness_digests)?;
+    SemanticDigest::new(hash.finalize().into())
+}
+
+fn current_reflection_proof_digest(
+    phase: ExactComplexRational,
+    lineage_roots: &[SemanticDigest],
+    result_color_identity: SemanticDigest,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-current-reflection-proof-v1\0");
+    hash_exact_factor(&mut hash, phase);
+    hash_digest_sequence(&mut hash, lineage_roots)?;
+    hash.update(result_color_identity.as_bytes());
+    SemanticDigest::new(hash.finalize().into())
+}
+
+fn pending_reflection_certificate_digest(
+    canonical_old_current_id: u32,
+    reflected_old_current_id: u32,
+    canonical: &CurrentReflectionProof,
+    reflected: &CurrentReflectionProof,
+    source_permutation: &[u32],
+    fixed_point: bool,
+    orbit_size: u32,
+) -> RusticolResult<SemanticDigest> {
+    pending_reflection_certificate_fields_digest(
+        canonical_old_current_id,
+        reflected_old_current_id,
+        canonical.result_color_identity(),
+        reflected.result_color_identity(),
+        canonical.phase(),
+        reflected.phase(),
+        canonical.proof_digest(),
+        reflected.proof_digest(),
+        source_permutation,
+        fixed_point,
+        orbit_size,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn pending_reflection_certificate_fields_digest(
+    canonical_old_current_id: u32,
+    reflected_old_current_id: u32,
+    canonical_color_identity: SemanticDigest,
+    reflected_color_identity: SemanticDigest,
+    canonical_phase: ExactComplexRational,
+    reflected_phase: ExactComplexRational,
+    canonical_lineage_digest: SemanticDigest,
+    reflected_lineage_digest: SemanticDigest,
+    source_permutation: &[u32],
+    fixed_point: bool,
+    orbit_size: u32,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-pending-reflection-certificate-v1\0");
+    hash.update(canonical_old_current_id.to_le_bytes());
+    hash.update(reflected_old_current_id.to_le_bytes());
+    hash.update(canonical_color_identity.as_bytes());
+    hash.update(reflected_color_identity.as_bytes());
+    hash_exact_factor(&mut hash, canonical_phase);
+    hash_exact_factor(&mut hash, reflected_phase);
+    hash.update(canonical_lineage_digest.as_bytes());
+    hash.update(reflected_lineage_digest.as_bytes());
+    hash.update(
+        u64::try_from(source_permutation.len())
+            .map_err(|_| invalid("reflection source permutation length exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for source_slot in source_permutation {
+        hash.update(source_slot.to_le_bytes());
+    }
+    hash.update([u8::from(fixed_point)]);
+    hash.update(orbit_size.to_le_bytes());
+    SemanticDigest::new(hash.finalize().into())
+}
+
+/// One rate-limited snapshot of compact recurrence construction.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceBuildProgress {
+    pub phase: &'static str,
+    pub phase_index: usize,
+    pub phase_total: usize,
+    pub stage_index: Option<usize>,
+    pub stage_total: usize,
+    pub subset_size: Option<usize>,
+    pub candidate_parent_pair_count: usize,
+    pub candidate_parent_pair_total: Option<usize>,
+    pub current_count: usize,
+    pub contribution_count: usize,
+    pub dynamic_color_state_count: usize,
+    pub color_target_prune_count: usize,
+}
+
+/// Construction-only recurrence-generation telemetry.
+///
+/// This diagnostic record is deliberately excluded from recurrence programs,
+/// runtime plans, persisted payloads, and their semantic digests.
+#[doc(hidden)]
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct RecurrenceGenerationTelemetry {
+    pub transition_catalog_nanoseconds: u64,
+    pub structural_feasibility_nanoseconds: u64,
+    pub color_target_index_nanoseconds: u64,
+    pub structural_demand_nanoseconds: u64,
+    pub support_indexing_nanoseconds: u64,
+    pub candidate_processing_nanoseconds: u64,
+    pub closure_processing_nanoseconds: u64,
+    pub canonical_emission_nanoseconds: u64,
+    pub support_bucket_count: usize,
+    pub support_bucket_probe_count: usize,
+    pub support_bucket_cache_hit_count: usize,
+    pub support_bucket_cache_miss_count: usize,
+    pub candidate_parent_pair_theoretical_count: usize,
+    pub candidate_parent_pair_visited_count: usize,
+    pub structural_feasible_support_count: usize,
+    pub structural_decomposition_count: usize,
+    pub structural_forward_transition_probe_count: usize,
+    pub structural_demand_support_count: usize,
+    pub structural_demand_state_count: usize,
+    pub structural_reject_count: usize,
+    pub transition_index_hit_count: usize,
+    pub transition_index_miss_count: usize,
+    pub transition_candidate_count: usize,
+    pub quantum_match_count: usize,
+    pub coupling_match_count: usize,
+    pub transition_accept_count: usize,
+    pub color_shape_match_count: usize,
+    pub color_result_count: usize,
+    pub color_target_accept_count: usize,
+    pub color_target_reject_count: usize,
+    pub color_acceptance_cache_hit_count: usize,
+    pub color_acceptance_cache_miss_count: usize,
+    pub color_fragment_bucket_count: usize,
+    pub color_fragment_hash_lookup_count: usize,
+    pub color_posting_incidence_count: usize,
+    pub color_sparse_posting_bucket_count: usize,
+    pub color_dense_posting_bucket_count: usize,
+    pub color_sparse_posting_bytes: usize,
+    pub color_dense_posting_bytes: usize,
+    pub accepted_parent_key_clone_count: usize,
+    pub current_key_lookup_count: usize,
+    pub current_key_hit_count: usize,
+    pub current_insert_count: usize,
+    pub current_key_clone_count: usize,
+    pub indexed_hash_lookup_count: usize,
+    pub contribution_attempt_count: usize,
+    pub contribution_insert_count: usize,
+    pub contribution_merge_count: usize,
+    pub closure_candidate_theoretical_count: usize,
+    pub closure_candidate_count: usize,
+    pub closure_state_match_count: usize,
+    pub closure_support_lookup_count: usize,
+    /// Exact number of successful-path color-witness closure evaluations,
+    /// including repeated component forests.
+    pub closure_color_attempt_count: usize,
+    pub closure_group_count: usize,
+    pub closure_proof_contribution_count: usize,
+    pub constructed_current_count: usize,
+    pub constructed_contribution_count: usize,
+    pub constructed_interaction_count: usize,
+    pub constructed_dynamic_color_state_count: usize,
+    pub emitted_current_count: usize,
+    pub emitted_contribution_count: usize,
+    pub emitted_interaction_count: usize,
+    pub emitted_finalization_count: usize,
+    pub emitted_closure_count: usize,
+}
+
+impl RecurrenceBuildProgress {
+    #[allow(clippy::too_many_arguments)]
+    fn snapshot(
+        phase: &'static str,
+        phase_index: usize,
+        phase_total: usize,
+        stage_index: Option<usize>,
+        stage_total: usize,
+        subset_size: Option<usize>,
+        candidate_parent_pair_count: usize,
+        candidate_parent_pair_total: Option<usize>,
+        current_count: usize,
+        contribution_count: usize,
+        dynamic_color_state_count: usize,
+        color_target_prune_count: usize,
+    ) -> Self {
+        Self {
+            phase,
+            phase_index,
+            phase_total,
+            stage_index,
+            stage_total,
+            subset_size,
+            candidate_parent_pair_count,
+            candidate_parent_pair_total,
+            current_count,
+            contribution_count,
+            dynamic_color_state_count,
+            color_target_prune_count,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct PendingContributionKey {
+    parent_current_ids: Box<[u32]>,
+    key: ContributionKey,
+}
+
+#[derive(Clone, Debug)]
+struct PendingCurrent {
+    key: CurrentCoreKey,
+    source_exact_factor: Option<ExactComplexRational>,
+    contributions: BTreeMap<PendingContributionKey, ExactComplexRational>,
+    realized_pairing_rule_ids: BTreeSet<u32>,
+    reflection: CurrentReflection,
+    reflection_certificate_id: Option<u32>,
+}
+
+/// Construction-only exact current lookup.
+///
+/// Canonical order is owned exclusively by the `currents` vector and ordered
+/// contribution maps. This index is only cloned, queried, inserted into, and
+/// pruned; its randomized iteration order is never observed.
+type TransientCurrentIdIndex = HashMap<CurrentCoreKey, u32>;
+
+/// Exact runtime-value identity after erasing only dynamic LC colour.
+///
+/// The physical-sector domain is part of the identity.  Without it, folding
+/// two colour fragments from disjoint selector domains would make every
+/// contribution of either fragment live in both domains.
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ProjectedCurrentIdentity {
+    color_erased_key: CurrentCoreKey,
+    selector_sector_ids: Box<[u32]>,
+    source_builder_id: Option<u32>,
+}
+
+/// Exact contribution identity after mapping parents to projected values.
+///
+/// `color_witness_term_id` is deliberately absent.  Every remaining runtime
+/// field and the exact coefficient participates in equality.
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ProjectedContributionIdentity {
+    destination_projection_id: u32,
+    transition_template_id: u32,
+    parent_projection_ids: Box<[u32]>,
+    parent_state_template_ids: Box<[u32]>,
+    parent_momenta: Box<[CanonicalMomentumLinearForm]>,
+    result_state_template_id: u32,
+    quantum_flow_witness_id: u32,
+    runtime_coupling_binding_digest: SemanticDigest,
+    output_projection_id: u32,
+    exact_factor: ExactComplexRational,
+}
+
+#[derive(Clone, Debug)]
+struct PendingProjectedContribution {
+    identity: ProjectedContributionIdentity,
+    representative_destination_builder_id: u32,
+    representative_key: ContributionKey,
+    destination_builder_ids: BTreeSet<u32>,
+    builder_parent_tuples: BTreeSet<Box<[u32]>>,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ProjectedClosureIdentity {
+    target_sector_id: u32,
+    complete_source_states: Box<[SourceStateAssignment]>,
+    closure_template_id: u32,
+    quantum_flow_template_id: Option<u32>,
+    parent_projection_ids: Box<[u32]>,
+    exact_factor: ExactComplexRational,
+}
+
+#[derive(Clone, Debug)]
+struct PendingProjectedClosure {
+    identity: ProjectedClosureIdentity,
+    representative_key: PendingClosureKey,
+    representative_group: PendingClosureGroup,
+    builder_parent_tuples: BTreeSet<Box<[u32]>>,
+}
+
+#[derive(Clone, Debug)]
+struct PendingColorProjection {
+    old_to_projection: BTreeMap<u32, u32>,
+    projection_members: Vec<Box<[u32]>>,
+    projection_sector_ids: Vec<Box<[u32]>>,
+    contributions: BTreeMap<ProjectedContributionIdentity, PendingProjectedContribution>,
+    closures: BTreeMap<ProjectedClosureIdentity, PendingProjectedClosure>,
+}
+
+struct MaterializedPendingRows {
+    remap: BTreeMap<u32, u32>,
+    currents: Vec<RecurrenceCurrent>,
+    contributions: Vec<RecurrenceContribution>,
+    finalizations: Vec<RecurrenceFinalization>,
+}
+
+fn materialize_live_pending_rows(
+    pending: &[PendingCurrent],
+    live: &BTreeSet<u32>,
+) -> RusticolResult<MaterializedPendingRows> {
+    let remap = live
+        .iter()
+        .copied()
+        .enumerate()
+        .map(|(new, old)| {
+            u32::try_from(new)
+                .map(|new| (old, new))
+                .map_err(|_| invalid("live recurrence current count exceeds u32"))
+        })
+        .collect::<RusticolResult<BTreeMap<_, _>>>()?;
+    let mut currents = Vec::with_capacity(live.len());
+    let mut contributions = Vec::new();
+    let mut finalizations = Vec::new();
+    for old_id in live.iter().copied() {
+        let pending_current = &pending[old_id as usize];
+        let start = u64::try_from(contributions.len())
+            .map_err(|_| invalid("recurrence contribution count exceeds u64"))?;
+        for (pending_key, factor) in &pending_current.contributions {
+            if factor.is_zero() {
+                continue;
+            }
+            let parent_ids = pending_key
+                .parent_current_ids
+                .iter()
+                .map(|id| {
+                    remap
+                        .get(id)
+                        .copied()
+                        .ok_or_else(|| invalid("live parent is absent"))
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let old_key = &pending_key.key;
+            let key = ContributionKey::new(
+                old_key.transition_template_id(),
+                parent_ids.clone(),
+                old_key.parent_state_template_ids().to_vec(),
+                old_key.parent_momenta().to_vec(),
+                old_key.result_state_template_id(),
+                old_key.quantum_flow_witness_id(),
+                old_key.color_witness_term_id(),
+                old_key.runtime_coupling_binding_digest(),
+                old_key.output_projection_id(),
+            )?;
+            contributions.push(RecurrenceContribution::new(
+                u32::try_from(contributions.len())
+                    .map_err(|_| invalid("recurrence contribution count exceeds u32"))?,
+                remap[&old_id],
+                parent_ids,
+                key,
+                *factor,
+            )?);
+        }
+        let count = u64::try_from(contributions.len())
+            .map_err(|_| invalid("recurrence contribution count exceeds u64"))?
+            .checked_sub(start)
+            .ok_or_else(|| invalid("recurrence contribution range underflows"))?;
+        let finalization_id = if pending_current.key.node_kind() == RecurrenceNodeKind::Current {
+            let id = u32::try_from(finalizations.len())
+                .map_err(|_| invalid("recurrence finalization count exceeds u32"))?;
+            finalizations.push(RecurrenceFinalization::new(
+                id,
+                remap[&old_id],
+                pending_current.key.propagator_template_id(),
+                ExactComplexRational::ONE,
+            )?);
+            Some(id)
+        } else {
+            None
+        };
+        currents.push(RecurrenceCurrent::new(
+            remap[&old_id],
+            pending_current.key.clone(),
+            pending_current.source_exact_factor,
+            CheckedTableRange::new(start, count),
+            finalization_id,
+        )?);
+    }
+    Ok(MaterializedPendingRows {
+        remap,
+        currents,
+        contributions,
+        finalizations,
+    })
+}
+
+fn materialize_projected_pending_rows(
+    pending: &[PendingCurrent],
+    projection: &PendingColorProjection,
+) -> RusticolResult<MaterializedPendingRows> {
+    let mut currents = Vec::with_capacity(projection.projection_members.len());
+    let mut contributions = Vec::with_capacity(projection.contributions.len());
+    let mut finalizations = Vec::new();
+    for (projection_index, members) in projection.projection_members.iter().enumerate() {
+        let projection_id = u32::try_from(projection_index)
+            .map_err(|_| invalid("projected recurrence current count exceeds u32"))?;
+        let representative_id = *members
+            .first()
+            .ok_or_else(|| invalid("projected recurrence current class is empty"))?;
+        let representative = pending
+            .get(representative_id as usize)
+            .ok_or_else(|| invalid("projected recurrence representative is absent"))?;
+        let start = u64::try_from(contributions.len())
+            .map_err(|_| invalid("projected recurrence contribution count exceeds u64"))?;
+        for projected in projection
+            .contributions
+            .values()
+            .filter(|row| row.identity.destination_projection_id == projection_id)
+        {
+            if !projected.destination_builder_ids.iter().all(|builder_id| {
+                projection.old_to_projection.get(builder_id) == Some(&projection_id)
+            }) {
+                return Err(invalid(
+                    "projected contribution destinations cross projection classes",
+                ));
+            }
+            let parent_ids = projected.identity.parent_projection_ids.to_vec();
+            let witness = &projected.representative_key;
+            let key = ContributionKey::new(
+                projected.identity.transition_template_id,
+                parent_ids.clone(),
+                projected.identity.parent_state_template_ids.to_vec(),
+                projected.identity.parent_momenta.to_vec(),
+                projected.identity.result_state_template_id,
+                projected.identity.quantum_flow_witness_id,
+                witness.color_witness_term_id(),
+                projected.identity.runtime_coupling_binding_digest,
+                projected.identity.output_projection_id,
+            )?;
+            contributions.push(RecurrenceContribution::new(
+                u32::try_from(contributions.len())
+                    .map_err(|_| invalid("projected recurrence contribution count exceeds u32"))?,
+                projection_id,
+                parent_ids,
+                key,
+                projected.identity.exact_factor,
+            )?);
+        }
+        let count = u64::try_from(contributions.len())
+            .map_err(|_| invalid("projected recurrence contribution count exceeds u64"))?
+            .checked_sub(start)
+            .ok_or_else(|| invalid("projected recurrence contribution range underflows"))?;
+        let finalization_id = if representative.key.node_kind() == RecurrenceNodeKind::Current {
+            let id = u32::try_from(finalizations.len())
+                .map_err(|_| invalid("projected recurrence finalization count exceeds u32"))?;
+            finalizations.push(RecurrenceFinalization::new(
+                id,
+                projection_id,
+                representative.key.propagator_template_id(),
+                ExactComplexRational::ONE,
+            )?);
+            Some(id)
+        } else {
+            None
+        };
+        currents.push(RecurrenceCurrent::new(
+            projection_id,
+            representative.key.clone(),
+            representative.source_exact_factor,
+            CheckedTableRange::new(start, count),
+            finalization_id,
+        )?);
+    }
+    Ok(MaterializedPendingRows {
+        remap: projection.old_to_projection.clone(),
+        currents,
+        contributions,
+        finalizations,
+    })
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct CurrentReflectionProof {
+    phase: ExactComplexRational,
+    lineage_roots: Box<[SemanticDigest]>,
+    result_color_identity: SemanticDigest,
+    proof_digest: SemanticDigest,
+}
+
+impl CurrentReflectionProof {
+    pub(super) fn new(
+        phase: ExactComplexRational,
+        lineage_roots: impl IntoIterator<Item = SemanticDigest>,
+        result_color_identity: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        if phase.is_zero() {
+            return Err(invalid("current reflection proof has zero phase"));
+        }
+        let mut lineage_roots = lineage_roots.into_iter().collect::<Vec<_>>();
+        lineage_roots.sort_unstable();
+        lineage_roots.dedup();
+        if lineage_roots.is_empty() {
+            return Err(invalid("current reflection proof has empty lineage"));
+        }
+        let proof_digest =
+            current_reflection_proof_digest(phase, &lineage_roots, result_color_identity)?;
+        Ok(Self {
+            phase,
+            lineage_roots: lineage_roots.into_boxed_slice(),
+            result_color_identity,
+            proof_digest,
+        })
+    }
+
+    pub(super) const fn phase(&self) -> ExactComplexRational {
+        self.phase
+    }
+
+    pub(super) fn lineage_roots(&self) -> &[SemanticDigest] {
+        &self.lineage_roots
+    }
+
+    pub(super) const fn result_color_identity(&self) -> SemanticDigest {
+        self.result_color_identity
+    }
+
+    pub(super) const fn proof_digest(&self) -> SemanticDigest {
+        self.proof_digest
+    }
+
+    fn merged_with(&self, other: &Self) -> RusticolResult<Option<Self>> {
+        if self.phase != other.phase || self.result_color_identity != other.result_color_identity {
+            return Ok(None);
+        }
+        Self::new(
+            self.phase,
+            self.lineage_roots
+                .iter()
+                .copied()
+                .chain(other.lineage_roots.iter().copied()),
+            self.result_color_identity,
+        )
+        .map(Some)
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) enum CurrentReflection {
+    Unavailable,
+    Proven(CurrentReflectionProof),
+}
+
+impl CurrentReflection {
+    pub(super) fn phase(&self) -> Option<ExactComplexRational> {
+        match self {
+            Self::Unavailable => None,
+            Self::Proven(proof) => Some(proof.phase()),
+        }
+    }
+
+    pub(super) fn proof(&self) -> Option<&CurrentReflectionProof> {
+        match self {
+            Self::Unavailable => None,
+            Self::Proven(proof) => Some(proof),
+        }
+    }
+
+    pub(super) fn include(
+        &mut self,
+        candidate: Option<CurrentReflectionProof>,
+    ) -> RusticolResult<()> {
+        let merged = match (&*self, candidate) {
+            (Self::Proven(existing), Some(candidate)) => existing.merged_with(&candidate)?,
+            _ => None,
+        };
+        match merged {
+            Some(proof) => *self = Self::Proven(proof),
+            None => *self = Self::Unavailable,
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct TransitionReflectionProof {
+    phase: ExactComplexRational,
+    semantic_digests: Box<[SemanticDigest]>,
+    witness_digests: Box<[SemanticDigest]>,
+    proof_digest: SemanticDigest,
+}
+
+impl TransitionReflectionProof {
+    fn new(
+        phase: ExactComplexRational,
+        semantic_digests: impl IntoIterator<Item = SemanticDigest>,
+        witness_digests: impl IntoIterator<Item = SemanticDigest>,
+    ) -> RusticolResult<Self> {
+        if phase.is_zero() {
+            return Err(invalid("transition reflection proof has zero phase"));
+        }
+        let mut semantic_digests = semantic_digests.into_iter().collect::<Vec<_>>();
+        semantic_digests.sort_unstable();
+        semantic_digests.dedup();
+        let mut witness_digests = witness_digests.into_iter().collect::<Vec<_>>();
+        witness_digests.sort_unstable();
+        witness_digests.dedup();
+        if semantic_digests.is_empty() || witness_digests.is_empty() {
+            return Err(invalid(
+                "transition reflection proof requires semantic and witness digests",
+            ));
+        }
+        let proof_digest =
+            transition_reflection_proof_digest(phase, &semantic_digests, &witness_digests)?;
+        Ok(Self {
+            phase,
+            semantic_digests: semantic_digests.into_boxed_slice(),
+            witness_digests: witness_digests.into_boxed_slice(),
+            proof_digest,
+        })
+    }
+
+    pub(super) const fn phase(&self) -> ExactComplexRational {
+        self.phase
+    }
+
+    #[cfg(feature = "on-the-fly-test-support")]
+    pub(super) const fn proof_digest(&self) -> SemanticDigest {
+        self.proof_digest
+    }
+
+    fn lineage_roots(&self) -> impl Iterator<Item = SemanticDigest> + '_ {
+        self.semantic_digests
+            .iter()
+            .chain(self.witness_digests.iter())
+            .copied()
+            .chain(std::iter::once(self.proof_digest))
+    }
+
+    fn merged_with(&self, other: &Self) -> RusticolResult<Option<Self>> {
+        if self.phase != other.phase {
+            return Ok(None);
+        }
+        Self::new(
+            self.phase,
+            self.semantic_digests
+                .iter()
+                .copied()
+                .chain(other.semantic_digests.iter().copied()),
+            self.witness_digests
+                .iter()
+                .copied()
+                .chain(other.witness_digests.iter().copied()),
+        )
+        .map(Some)
+    }
+}
+
+/// Cold proof record emitted before folded stage-local current IDs are compacted.
+///
+/// This deliberately remains local until the orchestrator-owned program proof
+/// API accepts reciprocal reflection orbits.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct PendingReflectionCertificate {
+    id: u32,
+    canonical_old_current_id: u32,
+    reflected_old_current_id: u32,
+    canonical_color_identity: SemanticDigest,
+    reflected_color_identity: SemanticDigest,
+    canonical_phase: ExactComplexRational,
+    reflected_phase: ExactComplexRational,
+    canonical_lineage_digest: SemanticDigest,
+    reflected_lineage_digest: SemanticDigest,
+    source_permutation: Box<[u32]>,
+    fixed_point: bool,
+    orbit_size: u32,
+    proof_digest: SemanticDigest,
+}
+
+impl PendingReflectionCertificate {
+    // The pair constructor authenticates both orbit members and both color
+    // witnesses explicitly; retaining the parallel arguments makes swaps visible.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn reciprocal_pair(
+        id: u32,
+        canonical_old_current_id: u32,
+        reflected_old_current_id: u32,
+        canonical: &CurrentReflectionProof,
+        reflected: &CurrentReflectionProof,
+        canonical_color: &DynamicLCColorState,
+        reflected_color: &DynamicLCColorState,
+        source_count: usize,
+    ) -> RusticolResult<Self> {
+        if canonical_old_current_id == reflected_old_current_id
+            || canonical.result_color_identity() == reflected.result_color_identity()
+        {
+            return Err(invalid(
+                "folded reflection certificate requires two distinct orbit members",
+            ));
+        }
+        if canonical.phase().checked_mul(reflected.phase())? != ExactComplexRational::ONE {
+            return Err(invalid(
+                "folded reflection certificate phases are not reciprocal",
+            ));
+        }
+        let source_permutation =
+            reflection_source_permutation(canonical_color, reflected_color, source_count)?;
+        let proof_digest = pending_reflection_certificate_digest(
+            canonical_old_current_id,
+            reflected_old_current_id,
+            canonical,
+            reflected,
+            &source_permutation,
+            false,
+            2,
+        )?;
+        Ok(Self {
+            id,
+            canonical_old_current_id,
+            reflected_old_current_id,
+            canonical_color_identity: canonical.result_color_identity(),
+            reflected_color_identity: reflected.result_color_identity(),
+            canonical_phase: canonical.phase(),
+            reflected_phase: reflected.phase(),
+            canonical_lineage_digest: canonical.proof_digest(),
+            reflected_lineage_digest: reflected.proof_digest(),
+            source_permutation: source_permutation.into_boxed_slice(),
+            fixed_point: false,
+            orbit_size: 2,
+            proof_digest,
+        })
+    }
+
+    pub(super) const fn canonical_color_identity(&self) -> SemanticDigest {
+        self.canonical_color_identity
+    }
+
+    pub(super) const fn canonical_phase(&self) -> ExactComplexRational {
+        self.canonical_phase
+    }
+
+    pub(super) const fn canonical_lineage_digest(&self) -> SemanticDigest {
+        self.canonical_lineage_digest
+    }
+
+    pub(super) fn source_permutation(&self) -> &[u32] {
+        &self.source_permutation
+    }
+
+    pub(super) const fn is_reciprocal_two_cycle(&self) -> bool {
+        !self.fixed_point && self.orbit_size == 2
+    }
+}
+
+fn reflection_source_permutation(
+    canonical_color: &DynamicLCColorState,
+    reflected_color: &DynamicLCColorState,
+    source_count: usize,
+) -> RusticolResult<Vec<u32>> {
+    let canonical = canonical_color
+        .pure_adjoint_word()
+        .ok_or_else(|| invalid("canonical reflection color has no adjoint word"))?;
+    let reflected = reflected_color
+        .pure_adjoint_word()
+        .ok_or_else(|| invalid("reflected reflection color has no adjoint word"))?;
+    if canonical.len() != reflected.len() {
+        return Err(invalid(
+            "reflection color words have inconsistent source counts",
+        ));
+    }
+    let mut permutation = (0..source_count)
+        .map(|slot| u32::try_from(slot).map_err(|_| invalid("reflection source count exceeds u32")))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    for (source, target) in canonical.iter().copied().zip(reflected.iter().copied()) {
+        let destination = permutation
+            .get_mut(source as usize)
+            .ok_or_else(|| invalid("reflection word references an absent source slot"))?;
+        *destination = target;
+    }
+    let mut ordered = permutation.clone();
+    ordered.sort_unstable();
+    if ordered
+        != (0..source_count)
+            .map(|slot| u32::try_from(slot).expect("source count checked above"))
+            .collect::<Vec<_>>()
+    {
+        return Err(invalid(
+            "reflection source mapping is not a complete permutation",
+        ));
+    }
+    Ok(permutation)
+}
+
+fn current_color_for_index<'a>(
+    color_states: &'a DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+    current_index: usize,
+) -> RusticolResult<&'a DynamicLCColorState> {
+    let current = currents
+        .get(current_index)
+        .ok_or_else(|| invalid("reflection current index is absent"))?;
+    color_states
+        .get(current.key.dynamic_lc_color_state_id())
+        .ok_or_else(|| invalid("reflection current color disappeared"))
+}
+
+fn validate_pending_reflection_certificates(
+    certificates: &[PendingReflectionCertificate],
+) -> RusticolResult<()> {
+    for (index, certificate) in certificates.iter().enumerate() {
+        if certificate.id != index as u32 {
+            return Err(invalid(format!(
+                "pending reflection certificate row {index} has non-dense id {}",
+                certificate.id
+            )));
+        }
+        if certificate.canonical_old_current_id == certificate.reflected_old_current_id
+            || certificate.canonical_color_identity == certificate.reflected_color_identity
+        {
+            return Err(invalid(format!(
+                "pending reflection certificate {index} does not identify two orbit members"
+            )));
+        }
+        if certificate.fixed_point || certificate.orbit_size != 2 {
+            return Err(invalid(format!(
+                "pending folded reflection certificate {index} is not a reciprocal two-cycle"
+            )));
+        }
+        if certificate
+            .canonical_phase
+            .checked_mul(certificate.reflected_phase)?
+            != ExactComplexRational::ONE
+        {
+            return Err(invalid(format!(
+                "pending reflection certificate {index} phases are not reciprocal"
+            )));
+        }
+        let expected = pending_reflection_certificate_fields_digest(
+            certificate.canonical_old_current_id,
+            certificate.reflected_old_current_id,
+            certificate.canonical_color_identity,
+            certificate.reflected_color_identity,
+            certificate.canonical_phase,
+            certificate.reflected_phase,
+            certificate.canonical_lineage_digest,
+            certificate.reflected_lineage_digest,
+            &certificate.source_permutation,
+            certificate.fixed_point,
+            certificate.orbit_size,
+        )?;
+        if expected != certificate.proof_digest {
+            return Err(invalid(format!(
+                "pending reflection certificate {index} proof digest is stale"
+            )));
+        }
+    }
+    Ok(())
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum HelicitySupportRule {
+    None,
+    PureMasslessAdjointTree,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum GlobalHelicityFlipRule {
+    None,
+    Proven,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct PendingClosureKey {
+    target_sector_id: u32,
+    complete_source_states: Box<[SourceStateAssignment]>,
+    closure_template_id: u32,
+    quantum_flow_template_id: Option<u32>,
+    parent_current_ids: Box<[u32]>,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct PendingThreeLineTraversalCertificate {
+    sector_id: u32,
+    kind: u8,
+    sink_block_ordinal: u32,
+    reference_block_order: Box<[u32]>,
+    witness_block_order: Box<[u32]>,
+    block_permutation: Box<[u32]>,
+    reference_source_order: Box<[u32]>,
+    witness_source_order: Box<[u32]>,
+    source_position_permutation: Box<[u32]>,
+    closure_anchor_source_slot: u32,
+    pairing_rule_id: u32,
+    proof_digest: SemanticDigest,
+}
+
+/// One compiler/model-certified closure witness before equal runtime rows are
+/// combined. These records are cold proof data and never enter the numeric
+/// Direct-Arena loop.
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct PendingClosureProofContribution {
+    construction_parent_ids: [u32; 2],
+    construction_parent_permutation: [u32; 2],
+    reconstruction_parent_permutation: [u32; 2],
+    evaluator_parent_permutation: [u32; 2],
+    closure_template_semantic_digest: SemanticDigest,
+    color_witness_term_id: u32,
+    color_witness_proof_digest: SemanticDigest,
+    three_line_certificate: Option<PendingThreeLineTraversalCertificate>,
+    pairing_certificate_ids: Box<[u32]>,
+    reflection_certificate_id: Option<u32>,
+    exact_factor: ExactComplexRational,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct PendingClosureGroup {
+    contributions: Vec<PendingClosureProofContribution>,
+    exact_factor: ExactComplexRational,
+}
+
+/// Closure rows together with the physical sectors exhaustively visited by
+/// their native construction pass.  Keeping the domain separate from the row
+/// map prevents a later consumer from treating a missing row as proof that a
+/// sector is zero.
+#[derive(Debug, Eq, PartialEq)]
+struct ExhaustiveClosureDomain {
+    groups: BTreeMap<PendingClosureKey, PendingClosureGroup>,
+    physical_sector_ids: BTreeSet<u32>,
+    physical_sector_owner_ids: BTreeMap<u32, u32>,
+}
+
+impl std::ops::Deref for ExhaustiveClosureDomain {
+    type Target = BTreeMap<PendingClosureKey, PendingClosureGroup>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.groups
+    }
+}
+
+impl ExhaustiveClosureDomain {
+    fn new(
+        groups: BTreeMap<PendingClosureKey, PendingClosureGroup>,
+        physical_sector_ids: &BTreeSet<u32>,
+        physical_sector_owner_ids: BTreeMap<u32, u32>,
+    ) -> RusticolResult<Self> {
+        if groups
+            .keys()
+            .any(|key| !physical_sector_ids.contains(&key.target_sector_id))
+        {
+            return Err(invalid(
+                "closure result lies outside its exhaustive physical-sector domain",
+            ));
+        }
+        if physical_sector_owner_ids
+            .keys()
+            .copied()
+            .collect::<BTreeSet<_>>()
+            != *physical_sector_ids
+            || physical_sector_owner_ids
+                .iter()
+                .any(|(sector_id, owner_id)| {
+                    !physical_sector_ids.contains(owner_id)
+                        || owner_id > sector_id
+                        || physical_sector_owner_ids.get(owner_id) != Some(owner_id)
+                })
+        {
+            return Err(invalid(
+                "closure result has an invalid physical-sector owner domain",
+            ));
+        }
+        Ok(Self {
+            groups,
+            physical_sector_ids: physical_sector_ids.clone(),
+            physical_sector_owner_ids,
+        })
+    }
+}
+
+type ClosureColorAttemptDiagnostic = Vec<(LCColorComponentKind, Vec<u32>)>;
+
+impl Default for PendingClosureGroup {
+    fn default() -> Self {
+        Self {
+            contributions: Vec::new(),
+            exact_factor: ExactComplexRational::ZERO,
+        }
+    }
+}
+
+impl PendingClosureGroup {
+    fn include(&mut self, contribution: PendingClosureProofContribution) -> RusticolResult<()> {
+        aggregate_factor(&mut self.exact_factor, contribution.exact_factor)?;
+        self.contributions.push(contribution);
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+struct StageConstructionDiagnostics {
+    target_size: usize,
+    candidate_parent_pair_count: usize,
+    support_bucket_count: usize,
+    support_bucket_probe_count: usize,
+    support_bucket_cache_hit_count: usize,
+    parent_pair_count: usize,
+    transition_index_hit_count: usize,
+    transition_candidate_count: usize,
+    state_order_count: usize,
+    quantum_match_count: usize,
+    coupling_match_count: usize,
+    structural_reject_count: usize,
+    transition_accept_count: usize,
+    color_shape_match_count: usize,
+    color_result_count: usize,
+    color_target_prune_count: usize,
+    accepted_parent_key_clone_count: usize,
+    current_key_lookup_count: usize,
+    current_key_hit_count: usize,
+    current_insert_count: usize,
+    current_key_clone_count: usize,
+    contribution_attempt_count: usize,
+    contribution_insert_count: usize,
+    contribution_merge_count: usize,
+    support_indexing_nanoseconds: u64,
+    candidate_processing_nanoseconds: u64,
+}
+
+fn duration_nanoseconds(duration: Duration) -> u64 {
+    u64::try_from(duration.as_nanos()).unwrap_or(u64::MAX)
+}
+
+fn add_elapsed_nanoseconds(total: &mut u64, started: Instant) {
+    *total = total.saturating_add(duration_nanoseconds(started.elapsed()));
+}
+
+fn telemetry_timer(collect_telemetry: bool) -> Option<Instant> {
+    collect_telemetry.then(Instant::now)
+}
+
+fn add_optional_elapsed_nanoseconds(total: &mut u64, started: Option<Instant>) {
+    if let Some(started) = started {
+        add_elapsed_nanoseconds(total, started);
+    }
+}
+
+impl RecurrenceGenerationTelemetry {
+    fn include_stage(&mut self, stage: &StageConstructionDiagnostics) -> RusticolResult<()> {
+        for (target, value, label) in [
+            (
+                &mut self.support_bucket_count,
+                stage.support_bucket_count,
+                "telemetry support-bucket count",
+            ),
+            (
+                &mut self.support_bucket_probe_count,
+                stage.support_bucket_probe_count,
+                "telemetry support-bucket probe count",
+            ),
+            (
+                &mut self.support_bucket_cache_hit_count,
+                stage.support_bucket_cache_hit_count,
+                "telemetry support-bucket cache-hit count",
+            ),
+            (
+                &mut self.candidate_parent_pair_theoretical_count,
+                stage.candidate_parent_pair_count,
+                "telemetry theoretical parent-pair count",
+            ),
+            (
+                &mut self.candidate_parent_pair_visited_count,
+                stage.parent_pair_count,
+                "telemetry visited parent-pair count",
+            ),
+            (
+                &mut self.structural_reject_count,
+                stage.structural_reject_count,
+                "telemetry structural-reject count",
+            ),
+            (
+                &mut self.transition_index_hit_count,
+                stage.transition_index_hit_count,
+                "telemetry transition-index hit count",
+            ),
+            (
+                &mut self.transition_candidate_count,
+                stage.transition_candidate_count,
+                "telemetry transition-candidate count",
+            ),
+            (
+                &mut self.quantum_match_count,
+                stage.quantum_match_count,
+                "telemetry quantum-match count",
+            ),
+            (
+                &mut self.coupling_match_count,
+                stage.coupling_match_count,
+                "telemetry coupling-match count",
+            ),
+            (
+                &mut self.transition_accept_count,
+                stage.transition_accept_count,
+                "telemetry transition-accept count",
+            ),
+            (
+                &mut self.color_shape_match_count,
+                stage.color_shape_match_count,
+                "telemetry color-shape-match count",
+            ),
+            (
+                &mut self.color_result_count,
+                stage.color_result_count,
+                "telemetry color-result count",
+            ),
+            (
+                &mut self.color_target_reject_count,
+                stage.color_target_prune_count,
+                "telemetry color-target-reject count",
+            ),
+            (
+                &mut self.accepted_parent_key_clone_count,
+                stage.accepted_parent_key_clone_count,
+                "telemetry accepted-parent-key clone count",
+            ),
+            (
+                &mut self.current_key_lookup_count,
+                stage.current_key_lookup_count,
+                "telemetry current-key lookup count",
+            ),
+            (
+                &mut self.current_key_hit_count,
+                stage.current_key_hit_count,
+                "telemetry current-key hit count",
+            ),
+            (
+                &mut self.current_insert_count,
+                stage.current_insert_count,
+                "telemetry current-insert count",
+            ),
+            (
+                &mut self.current_key_clone_count,
+                stage.current_key_clone_count,
+                "telemetry current-key clone count",
+            ),
+            (
+                &mut self.contribution_attempt_count,
+                stage.contribution_attempt_count,
+                "telemetry contribution-attempt count",
+            ),
+            (
+                &mut self.contribution_insert_count,
+                stage.contribution_insert_count,
+                "telemetry contribution-insert count",
+            ),
+            (
+                &mut self.contribution_merge_count,
+                stage.contribution_merge_count,
+                "telemetry contribution-merge count",
+            ),
+        ] {
+            checked_diagnostic_add(target, value, label)?;
+        }
+        checked_diagnostic_add(
+            &mut self.support_bucket_cache_miss_count,
+            stage
+                .support_bucket_probe_count
+                .checked_sub(stage.support_bucket_cache_hit_count)
+                .ok_or_else(|| invalid("support-bucket cache-hit count exceeds probes"))?,
+            "telemetry support-bucket cache-miss count",
+        )?;
+        checked_diagnostic_add(
+            &mut self.transition_index_miss_count,
+            stage
+                .parent_pair_count
+                .checked_sub(stage.transition_index_hit_count)
+                .ok_or_else(|| invalid("transition-index hit count exceeds parent pairs"))?,
+            "telemetry transition-index miss count",
+        )?;
+        checked_diagnostic_add(
+            &mut self.color_target_accept_count,
+            stage
+                .color_result_count
+                .checked_sub(stage.color_target_prune_count)
+                .ok_or_else(|| invalid("color-target prune count exceeds color results"))?,
+            "telemetry color-target-accept count",
+        )?;
+        self.support_indexing_nanoseconds = self
+            .support_indexing_nanoseconds
+            .saturating_add(stage.support_indexing_nanoseconds);
+        self.candidate_processing_nanoseconds = self
+            .candidate_processing_nanoseconds
+            .saturating_add(stage.candidate_processing_nanoseconds);
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+#[derive(Clone, Copy, Debug)]
+struct IndexedTransition {
+    row: TransitionRow,
+    input_states: [u32; 2],
+}
+
+#[cfg(test)]
+impl IndexedTransition {
+    fn parent_ids(
+        self,
+        left_state: u32,
+        right_state: u32,
+        left_id: u32,
+        right_id: u32,
+    ) -> RusticolResult<[u32; 2]> {
+        if self.input_states == [left_state, right_state] {
+            return Ok([left_id, right_id]);
+        }
+        if left_state != right_state && self.input_states == [right_state, left_state] {
+            return Ok([right_id, left_id]);
+        }
+        Err(invalid("recurrence transition state index is inconsistent"))
+    }
+}
+
+#[cfg(test)]
+#[derive(Debug, Default)]
+struct TransitionStateIndex {
+    rows_by_state_pair: BTreeMap<(u32, u32), Vec<IndexedTransition>>,
+}
+
+#[cfg(test)]
+impl TransitionStateIndex {
+    fn new(
+        template: &OwnedRecurrenceTemplateInput,
+        catalog: &TemplateCatalog<'_>,
+    ) -> RusticolResult<Self> {
+        let mut result = Self::default();
+        for transition in &template.transitions {
+            let input_states = catalog.u32_sequence(
+                transition.input_state_sequence_id,
+                "transition input states",
+            )?;
+            let input_states: [u32; 2] = input_states
+                .try_into()
+                .map_err(|_| invalid("direct recurrence requires binary prepared transitions"))?;
+            result.insert(*transition, input_states);
+        }
+        Ok(result)
+    }
+
+    fn insert(&mut self, row: TransitionRow, input_states: [u32; 2]) {
+        self.rows_by_state_pair
+            .entry(canonical_state_pair(input_states))
+            .or_default()
+            .push(IndexedTransition { row, input_states });
+    }
+
+    fn rows(&self, left_state: u32, right_state: u32) -> &[IndexedTransition] {
+        self.rows_by_state_pair
+            .get(&canonical_state_pair([left_state, right_state]))
+            .map(Vec::as_slice)
+            .unwrap_or_default()
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct PreparedTransitionWitness {
+    row: LCColorTransitionWitnessRow,
+    witness: LCColorTransitionWitness,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+enum PreparedFlavourFlow {
+    Constant(Box<[i32]>),
+    AppendLeft(i32),
+    AppendRight(i32),
+    ConcatLeftRight(i32),
+}
+
+impl PreparedFlavourFlow {
+    fn new(quantum: QuantumFlowRow, catalog: &TemplateCatalog<'_>) -> RusticolResult<Self> {
+        let operation = catalog.string(
+            quantum.flavour_flow_operation_string_id,
+            "quantum-flow flavour operation",
+        )?;
+        let static_result = catalog.flavour_flow(
+            quantum.result_flavour_flow_id,
+            "quantum-flow result flavour",
+        )?;
+        let result_particle = *static_result
+            .last()
+            .ok_or_else(|| invalid("quantum-flow result flavour ancestry is empty"))?;
+        match operation {
+            "constant-result" => Ok(Self::Constant(static_result.into())),
+            "append-left-result" => Ok(Self::AppendLeft(result_particle)),
+            "append-right-result" => Ok(Self::AppendRight(result_particle)),
+            "concat-left-right-result" => Ok(Self::ConcatLeftRight(result_particle)),
+            value => Err(invalid(format!(
+                "unsupported quantum-flow flavour operation {value:?}"
+            ))),
+        }
+    }
+
+    fn result_particle(&self) -> i32 {
+        match self {
+            Self::Constant(result) => *result
+                .last()
+                .expect("prepared constant flavour flow is nonempty"),
+            Self::AppendLeft(result_particle)
+            | Self::AppendRight(result_particle)
+            | Self::ConcatLeftRight(result_particle) => *result_particle,
+        }
+    }
+
+    fn apply(&self, parents: &[&CurrentCoreKey; 2]) -> Vec<i32> {
+        // Runtime-helicity unions intentionally collapse construction ancestry
+        // to the physical result species.
+        if parents
+            .iter()
+            .all(|parent| parent.helicity_identity().strategy() == RecurrenceStrategy::AllFlowUnion)
+        {
+            return vec![self.result_particle()];
+        }
+
+        let append_result = |parent: &CurrentCoreKey, result_particle| {
+            let mut result = parent.flavour_flow().to_vec();
+            if result.last().copied() != Some(result_particle) {
+                result.push(result_particle);
+            }
+            result
+        };
+
+        match self {
+            Self::Constant(result) => result.to_vec(),
+            Self::AppendLeft(result_particle) => append_result(parents[0], *result_particle),
+            Self::AppendRight(result_particle) => append_result(parents[1], *result_particle),
+            Self::ConcatLeftRight(result_particle) => {
+                let mut result = Vec::with_capacity(
+                    parents[0]
+                        .flavour_flow()
+                        .len()
+                        .saturating_add(parents[1].flavour_flow().len())
+                        .saturating_add(1),
+                );
+                result.extend_from_slice(parents[0].flavour_flow());
+                result.extend_from_slice(parents[1].flavour_flow());
+                result.push(*result_particle);
+                result
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct PreparedTransition {
+    row: TransitionRow,
+    input_states: [u32; 2],
+    quantum: QuantumFlowRow,
+    quantum_input_states: [u32; 2],
+    quantum_input_spins: [i32; 2],
+    local_coupling_orders: Box<[u32]>,
+    contraction: ColorContractionRow,
+    canonical_input_order: [u32; 2],
+    input_exchange_factor: Option<ExactComplexRational>,
+    transition_exact_factor: ExactComplexRational,
+    contraction_exact_factor: ExactComplexRational,
+    coupling_authenticated: bool,
+    binding_coupling: ExactComplexRational,
+    output_factor_source: u8,
+    result_flavour: PreparedFlavourFlow,
+    quantum_semantic_digest: SemanticDigest,
+    #[cfg(feature = "on-the-fly-test-support")]
+    transition_semantic_digest: SemanticDigest,
+    #[cfg(feature = "on-the-fly-test-support")]
+    evaluator_binding_semantic_digest: SemanticDigest,
+    contact_orbit: Option<PreparedContactOrbitTransition>,
+    witnesses: Box<[PreparedTransitionWitness]>,
+}
+
+impl PreparedTransition {
+    fn new(
+        row: TransitionRow,
+        template: &OwnedRecurrenceTemplateInput,
+        catalog: &TemplateCatalog<'_>,
+    ) -> RusticolResult<Self> {
+        let input_states =
+            catalog.u32_sequence(row.input_state_sequence_id, "transition input states")?;
+        let input_states: [u32; 2] = input_states
+            .try_into()
+            .map_err(|_| invalid("direct recurrence requires binary prepared transitions"))?;
+        let quantum = template
+            .quantum_flows
+            .get(row.quantum_flow_template_id as usize)
+            .copied()
+            .ok_or_else(|| invalid("transition quantum-flow template is absent"))?;
+        let quantum_input_states =
+            catalog.u32_sequence(quantum.input_state_sequence_id, "quantum input states")?;
+        let quantum_input_spins =
+            catalog.i32_sequence(quantum.input_spin_sequence_id, "quantum input spins")?;
+        let quantum_input_flavour_ids = catalog.u32_sequence(
+            quantum.input_flavour_sequence_id,
+            "quantum input flavour flows",
+        )?;
+        let quantum_input_number_ids = catalog.u32_sequence(
+            quantum.input_quantum_sequence_id,
+            "quantum input number flows",
+        )?;
+        if quantum_input_states.len() != 2
+            || quantum_input_spins.len() != 2
+            || quantum_input_flavour_ids.len() != 2
+            || quantum_input_number_ids.len() != 2
+        {
+            return Err(invalid(
+                "direct recurrence requires binary quantum-flow contracts",
+            ));
+        }
+        let quantum_input_states = [quantum_input_states[0], quantum_input_states[1]];
+        let quantum_input_spins = [quantum_input_spins[0], quantum_input_spins[1]];
+        let quantum_input_flavour_ids =
+            [quantum_input_flavour_ids[0], quantum_input_flavour_ids[1]];
+        for flavour_id in quantum_input_flavour_ids {
+            let _ = catalog.flavour_flow(flavour_id, "quantum parent flavour")?;
+        }
+        let _quantum_input_number_ids = [quantum_input_number_ids[0], quantum_input_number_ids[1]];
+
+        let local_coupling_orders = catalog
+            .coupling_orders(row.coupling_order_set_id)?
+            .into_boxed_slice();
+        let contraction = template
+            .color_contractions
+            .get(row.color_contraction_template_id as usize)
+            .copied()
+            .ok_or_else(|| invalid("transition color contraction is absent"))?;
+        let quantum_coupling = catalog.factor(
+            quantum.exact_coupling_factor_id,
+            "transition quantum-flow coupling",
+        )?;
+        let binding_coupling = catalog.factor(
+            row.binding_coupling_factor_id,
+            "transition binding coupling",
+        )?;
+        let canonical_input_order = match catalog.u32_sequence(
+            row.canonical_input_order_sequence_id,
+            "transition canonical input order",
+        )? {
+            [0, 1] => [0, 1],
+            [1, 0] => [1, 0],
+            _ => {
+                return Err(invalid(
+                    "transition canonical input order is not a binary permutation",
+                ));
+            }
+        };
+        let input_exchange_factor = if row.input_exchange_factor_id == MISSING_U32 {
+            None
+        } else {
+            Some(catalog.factor(row.input_exchange_factor_id, "transition input-exchange")?)
+        };
+        let transition_exact_factor = catalog.factor(row.exact_factor_id, "transition exact")?;
+        let contraction_exact_factor =
+            catalog.factor(contraction.exact_coefficient_factor_id, "color contraction")?;
+        let result_flavour = PreparedFlavourFlow::new(quantum, catalog)?;
+        let quantum_semantic_digest =
+            catalog.digest(quantum.semantic_digest_id, "quantum-flow semantic")?;
+        #[cfg(feature = "on-the-fly-test-support")]
+        let transition_semantic_digest =
+            catalog.digest(row.semantic_digest_id, "transition semantic")?;
+        #[cfg(feature = "on-the-fly-test-support")]
+        let evaluator_binding_semantic_digest = {
+            let binding = template
+                .evaluator_bindings
+                .get(row.evaluator_binding_id as usize)
+                .ok_or_else(|| invalid("transition evaluator binding is absent"))?;
+            if binding.id != row.evaluator_binding_id {
+                return Err(invalid("transition evaluator binding is not canonical"));
+            }
+            catalog.digest(binding.semantic_digest_id, "transition evaluator binding")?
+        };
+        let witness_rows = catalog.witness_rows(row.color_contraction_template_id)?;
+        let contact_orbit = prepare_contact_orbit_transition(
+            template,
+            catalog,
+            row,
+            quantum_semantic_digest,
+            &local_coupling_orders,
+            binding_coupling,
+            transition_exact_factor,
+            contraction_exact_factor,
+            input_exchange_factor,
+            witness_rows,
+        )?;
+        let witnesses = witness_rows
+            .iter()
+            .copied()
+            .map(|witness_row| {
+                Ok(PreparedTransitionWitness {
+                    row: witness_row,
+                    witness: catalog.witness(witness_row)?,
+                })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        Ok(Self {
+            row,
+            input_states,
+            quantum,
+            quantum_input_states,
+            quantum_input_spins,
+            local_coupling_orders,
+            contraction,
+            canonical_input_order,
+            input_exchange_factor,
+            transition_exact_factor,
+            contraction_exact_factor,
+            coupling_authenticated: quantum_coupling == binding_coupling,
+            binding_coupling,
+            output_factor_source: row.output_factor_source,
+            result_flavour,
+            quantum_semantic_digest,
+            #[cfg(feature = "on-the-fly-test-support")]
+            transition_semantic_digest,
+            #[cfg(feature = "on-the-fly-test-support")]
+            evaluator_binding_semantic_digest,
+            contact_orbit,
+            witnesses,
+        })
+    }
+
+    fn parent_ids(
+        &self,
+        left_state: u32,
+        right_state: u32,
+        left_id: u32,
+        right_id: u32,
+    ) -> RusticolResult<[u32; 2]> {
+        if self.input_states == [left_state, right_state] {
+            return Ok([left_id, right_id]);
+        }
+        if left_state != right_state && self.input_states == [right_state, left_state] {
+            return Ok([right_id, left_id]);
+        }
+        Err(invalid("recurrence transition state index is inconsistent"))
+    }
+
+    fn quantum_flow_matches(&self, parents: &[&CurrentCoreKey; 2]) -> bool {
+        (0..2).all(|index| {
+            self.quantum_input_states[index] == parents[index].current_state_template_id()
+                && quantum_parent_spin_matches(self.quantum_input_spins[index], parents[index])
+        })
+    }
+
+    fn canonical_evaluator_parents(
+        &self,
+        concrete_parent_ids: [u32; 2],
+    ) -> ([u32; 2], ExactComplexRational) {
+        let mut ordered = match self.canonical_input_order {
+            [0, 1] => concrete_parent_ids,
+            [1, 0] => [concrete_parent_ids[1], concrete_parent_ids[0]],
+            _ => unreachable!("validated prepared transition input order"),
+        };
+        let mut factor = ExactComplexRational::ONE;
+        if let Some(exchange_factor) = self.input_exchange_factor
+            && ordered[1] < ordered[0]
+        {
+            ordered.swap(0, 1);
+            factor = exchange_factor;
+        }
+        (ordered, factor)
+    }
+
+    fn result_flavour_flow(&self, parents: &[&CurrentCoreKey; 2]) -> Vec<i32> {
+        self.result_flavour.apply(parents)
+    }
+
+    fn output_factor(&self) -> RusticolResult<ExactComplexRational> {
+        if !self.coupling_authenticated {
+            return Err(invalid(
+                "transition binding coupling does not match its quantum-flow coupling witness",
+            ));
+        }
+        output_factor_from_binding(
+            self.binding_coupling,
+            self.output_factor_source,
+            "transition",
+        )
+    }
+
+    fn structural_transition(&self) -> RusticolResult<StructuralTransition> {
+        if self.quantum.result_state_template_id != self.row.result_state_template_id {
+            return Err(invalid(
+                "structural-demand transition and quantum-flow result states differ",
+            ));
+        }
+        Ok(StructuralTransition {
+            parents: [
+                StructuralState::new(self.quantum_input_states[0], self.quantum_input_spins[0]),
+                StructuralState::new(self.quantum_input_states[1], self.quantum_input_spins[1]),
+            ],
+            result: StructuralState::new(
+                self.quantum.result_state_template_id,
+                self.quantum.result_spin_state,
+            ),
+        })
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct PreparedTransitionLocation {
+    transition_id: u32,
+    state_pair: (u32, u32),
+    row_index: usize,
+}
+
+fn reserve_prepared_transition_locations(
+    locations: &mut Vec<PreparedTransitionLocation>,
+    count: usize,
+) -> RusticolResult<()> {
+    locations.try_reserve_exact(count).map_err(|error| {
+        RusticolError::internal(format!(
+            "prepared transition-location allocation failed: {error}"
+        ))
+    })
+}
+
+#[derive(Debug, Default)]
+struct PreparedTransitionCatalog {
+    rows_by_state_pair: BTreeMap<(u32, u32), Vec<PreparedTransition>>,
+    transition_locations: Vec<PreparedTransitionLocation>,
+    structural_transitions: Box<[StructuralTransition]>,
+    decoded_transition_count: usize,
+    decoded_witness_count: usize,
+}
+
+impl PreparedTransitionCatalog {
+    fn new(
+        template: &OwnedRecurrenceTemplateInput,
+        catalog: &TemplateCatalog<'_>,
+    ) -> RusticolResult<Self> {
+        let mut rows_by_state_pair = BTreeMap::<(u32, u32), Vec<PreparedTransition>>::new();
+        let mut transition_locations = Vec::new();
+        reserve_prepared_transition_locations(
+            &mut transition_locations,
+            template.transitions.len(),
+        )?;
+        let mut structural_transitions = BTreeSet::new();
+        let mut decoded_transition_count = 0usize;
+        let mut decoded_witness_count = 0usize;
+        for row in template.transitions.iter().copied() {
+            let prepared = PreparedTransition::new(row, template, catalog)?;
+            decoded_transition_count += 1;
+            decoded_witness_count += prepared.witnesses.len();
+            structural_transitions.insert(prepared.structural_transition()?);
+            let state_pair = canonical_state_pair(prepared.input_states);
+            let row_index = rows_by_state_pair.get(&state_pair).map_or(0, Vec::len);
+            transition_locations.push(PreparedTransitionLocation {
+                transition_id: prepared.row.id,
+                state_pair,
+                row_index,
+            });
+            rows_by_state_pair
+                .entry(state_pair)
+                .or_default()
+                .push(prepared);
+        }
+        // Template transition rows retain their authenticated source order in
+        // `rows_by_state_pair`.  Only this private lookup side index needs ID
+        // order for binary search, so sort the already-reserved locator rows
+        // without perturbing ordinary transition iteration or IDs.
+        transition_locations.sort_unstable_by_key(|location| location.transition_id);
+        if !transition_locations
+            .windows(2)
+            .all(|rows| rows[0].transition_id < rows[1].transition_id)
+        {
+            return Err(invalid(
+                "prepared transition-location index contains duplicate IDs",
+            ));
+        }
+        let result = Self {
+            rows_by_state_pair,
+            transition_locations,
+            structural_transitions: structural_transitions
+                .into_iter()
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            decoded_transition_count,
+            decoded_witness_count,
+        };
+        debug_assert_eq!(
+            result.decoded_transition_count(),
+            template.transitions.len()
+        );
+        debug_assert_eq!(
+            result.decoded_witness_count(),
+            result
+                .rows_by_state_pair
+                .values()
+                .flatten()
+                .map(|transition| transition.witnesses.len())
+                .sum::<usize>()
+        );
+        Ok(result)
+    }
+
+    fn rows(&self, left_state: u32, right_state: u32) -> &[PreparedTransition] {
+        self.rows_by_state_pair
+            .get(&canonical_state_pair([left_state, right_state]))
+            .map(Vec::as_slice)
+            .unwrap_or_default()
+    }
+
+    fn contact_orbit(&self, transition_id: u32) -> Option<&PreparedContactOrbitTransition> {
+        let location = self
+            .transition_locations
+            .binary_search_by_key(&transition_id, |location| location.transition_id)
+            .ok()
+            .and_then(|index| self.transition_locations.get(index))?;
+        self.rows_by_state_pair
+            .get(&location.state_pair)
+            .and_then(|rows| rows.get(location.row_index))
+            .filter(|row| row.row.id == transition_id)
+            .and_then(|row| row.contact_orbit.as_ref())
+    }
+
+    fn structural_transitions(&self) -> &[StructuralTransition] {
+        &self.structural_transitions
+    }
+
+    fn decoded_transition_count(&self) -> usize {
+        self.decoded_transition_count
+    }
+
+    fn decoded_witness_count(&self) -> usize {
+        self.decoded_witness_count
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct EstablishedContactContributionToken {
+    destination_id: usize,
+    contribution_ordinal: usize,
+}
+
+#[derive(Debug)]
+struct EstablishedContactOwnerPlan {
+    stage_current_start: usize,
+    selected_tokens: Vec<EstablishedContactContributionToken>,
+    staged_contribution_count: usize,
+    retained_contribution_count: usize,
+    resident_contribution_count_after_commit: usize,
+}
+
+impl EstablishedContactOwnerPlan {
+    /// Commit a completely validated owner plan without allocating or failing.
+    ///
+    /// The plan owns the complete selected-token output and every fallible
+    /// candidate/decode/count operation has already succeeded. `retain` keeps
+    /// the canonical `BTreeMap` order and performs no allocation, so live
+    /// construction state changes only in this final infallible phase.
+    fn commit(self, currents: &mut [PendingCurrent], resident_contribution_count: &mut usize) {
+        let mut selected_index = 0usize;
+        let mut observed_count = 0usize;
+        let mut retained_count = 0usize;
+        for (destination_id, current) in currents
+            .iter_mut()
+            .enumerate()
+            .skip(self.stage_current_start)
+        {
+            let mut contribution_ordinal = 0usize;
+            current.contributions.retain(|_, _| {
+                let token = EstablishedContactContributionToken {
+                    destination_id,
+                    contribution_ordinal,
+                };
+                contribution_ordinal += 1;
+                observed_count += 1;
+                let selected = self.selected_tokens.get(selected_index) == Some(&token);
+                if selected {
+                    selected_index += 1;
+                    retained_count += 1;
+                }
+                selected
+            });
+        }
+        debug_assert_eq!(observed_count, self.staged_contribution_count);
+        debug_assert_eq!(retained_count, self.retained_contribution_count);
+        debug_assert_eq!(selected_index, self.selected_tokens.len());
+        *resident_contribution_count = self.resident_contribution_count_after_commit;
+    }
+}
+
+/// Plan exact established-path contact ownership over the complete stage fan-in.
+///
+/// Uncertified contributions are represented by `None` candidates and pass
+/// through unchanged. The stable token is a snapshot of the canonical
+/// destination/current order plus the contribution's ordered-map ordinal.
+/// Every allocation and error-capable proof lookup happens before the caller
+/// replaces any live contribution storage or resident-count telemetry.
+fn plan_established_contact_orbit_owners(
+    stage_current_start: usize,
+    prepared_transitions: &PreparedTransitionCatalog,
+    currents: &[PendingCurrent],
+    resident_contribution_count: usize,
+) -> RusticolResult<Option<EstablishedContactOwnerPlan>> {
+    plan_established_contact_orbit_owners_with_resolver(
+        stage_current_start,
+        currents,
+        resident_contribution_count,
+        |transition_id| prepared_transitions.contact_orbit(transition_id),
+    )
+}
+
+fn reserve_established_contact_candidates<T>(
+    candidates: &mut Vec<T>,
+    count: usize,
+) -> RusticolResult<()> {
+    candidates.try_reserve_exact(count).map_err(|error| {
+        RusticolError::internal(format!(
+            "established contact-orbit candidate allocation failed: {error}"
+        ))
+    })
+}
+
+fn plan_established_contact_orbit_owners_with_resolver<'a, F>(
+    stage_current_start: usize,
+    currents: &'a [PendingCurrent],
+    resident_contribution_count: usize,
+    mut contact_orbit: F,
+) -> RusticolResult<Option<EstablishedContactOwnerPlan>>
+where
+    F: FnMut(u32) -> Option<&'a PreparedContactOrbitTransition>,
+{
+    if stage_current_start > currents.len() {
+        return Err(invalid(
+            "contact-orbit stage current boundary exceeds current storage",
+        ));
+    }
+    let has_certified_contact = currents[stage_current_start..].iter().any(|current| {
+        current
+            .contributions
+            .keys()
+            .any(|pending| contact_orbit(pending.key.transition_template_id()).is_some())
+    });
+    if !has_certified_contact {
+        return Ok(None);
+    }
+    let staged_contribution_count =
+        currents[stage_current_start..]
+            .iter()
+            .try_fold(0usize, |count, current| {
+                count
+                    .checked_add(current.contributions.len())
+                    .ok_or_else(|| invalid("contact-orbit staged contribution count exceeds usize"))
+            })?;
+    let mut candidates = Vec::new();
+    reserve_established_contact_candidates(&mut candidates, staged_contribution_count)?;
+    for (destination_id, current) in currents.iter().enumerate().skip(stage_current_start) {
+        for (contribution_ordinal, pending) in current.contributions.keys().enumerate() {
+            let token = EstablishedContactContributionToken {
+                destination_id,
+                contribution_ordinal,
+            };
+            let candidate =
+                if let Some(contact_orbit) = contact_orbit(pending.key.transition_template_id()) {
+                    let [left_id, right_id] = pending.parent_current_ids.as_ref() else {
+                        return Err(invalid(
+                            "certified contact-orbit contribution is not binary",
+                        ));
+                    };
+                    let left = currents
+                        .get(*left_id as usize)
+                        .ok_or_else(|| invalid("contact-orbit left parent is absent"))?;
+                    let right = currents
+                        .get(*right_id as usize)
+                        .ok_or_else(|| invalid("contact-orbit right parent is absent"))?;
+                    Some(contact_orbit.owner_candidate(
+                        &current.key,
+                        [&left.key, &right.key],
+                        pending.key.color_witness_term_id(),
+                    )?)
+                } else {
+                    None
+                };
+            candidates.push((token, candidate));
+        }
+    }
+    if candidates.len() != staged_contribution_count {
+        return Err(invalid(
+            "contact-orbit staged contribution snapshot changed length",
+        ));
+    }
+    let selected_tokens = selected_contact_orbit_owner_tokens(candidates)?;
+    let retained_contribution_count = selected_tokens.len();
+    let removed_contribution_count = staged_contribution_count
+        .checked_sub(retained_contribution_count)
+        .ok_or_else(|| invalid("contact-orbit retained contribution count exceeds snapshot"))?;
+    let resident_contribution_count_after_commit = resident_contribution_count
+        .checked_sub(removed_contribution_count)
+        .ok_or_else(|| invalid("contact-orbit resident contribution count underflows"))?;
+    Ok(Some(EstablishedContactOwnerPlan {
+        stage_current_start,
+        selected_tokens,
+        staged_contribution_count,
+        retained_contribution_count,
+        resident_contribution_count_after_commit,
+    }))
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct PreparedClosureWitness {
+    row: LCColorTransitionWitnessRow,
+    witness: LCColorTransitionWitness,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct PreparedClosureQuantumFlow {
+    row: Option<QuantumFlowRow>,
+    input_states: Option<[u32; 2]>,
+    input_spins: Option<[i32; 2]>,
+    coupling_authenticated: bool,
+    binding_coupling: ExactComplexRational,
+    output_factor_source: u8,
+}
+
+impl PreparedClosureQuantumFlow {
+    fn unbound(closure: ClosureRow, catalog: &TemplateCatalog<'_>) -> RusticolResult<Self> {
+        let binding_coupling = catalog.factor(
+            closure.binding_coupling_factor_id,
+            "closure binding coupling",
+        )?;
+        Ok(Self {
+            row: None,
+            input_states: None,
+            input_spins: None,
+            coupling_authenticated: true,
+            binding_coupling,
+            output_factor_source: closure.output_factor_source,
+        })
+    }
+
+    fn bound(
+        closure: ClosureRow,
+        quantum: QuantumFlowRow,
+        catalog: &TemplateCatalog<'_>,
+    ) -> RusticolResult<Self> {
+        let input_states =
+            catalog.u32_sequence(quantum.input_state_sequence_id, "quantum input states")?;
+        let input_spins =
+            catalog.i32_sequence(quantum.input_spin_sequence_id, "quantum input spins")?;
+        let input_flavours = catalog.u32_sequence(
+            quantum.input_flavour_sequence_id,
+            "quantum input flavour flows",
+        )?;
+        let input_quantum_numbers = catalog.u32_sequence(
+            quantum.input_quantum_sequence_id,
+            "quantum input number flows",
+        )?;
+        if input_states.len() != 2
+            || input_spins.len() != 2
+            || input_flavours.len() != 2
+            || input_quantum_numbers.len() != 2
+        {
+            return Err(invalid(
+                "direct recurrence requires binary quantum-flow contracts",
+            ));
+        }
+        for flavour_id in input_flavours {
+            let _ = catalog.flavour_flow(*flavour_id, "quantum parent flavour")?;
+        }
+        let quantum_coupling = catalog.factor(
+            quantum.exact_coupling_factor_id,
+            "closure quantum-flow coupling",
+        )?;
+        let binding_coupling = catalog.factor(
+            closure.binding_coupling_factor_id,
+            "closure binding coupling",
+        )?;
+        Ok(Self {
+            row: Some(quantum),
+            input_states: Some([input_states[0], input_states[1]]),
+            input_spins: Some([input_spins[0], input_spins[1]]),
+            coupling_authenticated: quantum_coupling == binding_coupling,
+            binding_coupling,
+            output_factor_source: closure.output_factor_source,
+        })
+    }
+
+    fn matches(&self, parents: &[&CurrentCoreKey; 2]) -> bool {
+        let (Some(input_states), Some(input_spins)) = (self.input_states, self.input_spins) else {
+            return true;
+        };
+        (0..2).all(|index| {
+            input_states[index] == parents[index].current_state_template_id()
+                && quantum_parent_spin_matches(input_spins[index], parents[index])
+        })
+    }
+
+    fn template_id(&self) -> Option<u32> {
+        self.row.map(|row| row.id)
+    }
+
+    fn output_factor(&self) -> RusticolResult<ExactComplexRational> {
+        if !self.coupling_authenticated {
+            return Err(invalid(
+                "closure binding coupling does not match its quantum-flow coupling witness",
+            ));
+        }
+        output_factor_from_binding(self.binding_coupling, self.output_factor_source, "closure")
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct PreparedClosure {
+    row: ClosureRow,
+    input_states: [u32; 2],
+    quantum_flows: Box<[PreparedClosureQuantumFlow]>,
+    contraction: ColorContractionRow,
+    canonical_input_order: [u32; 2],
+    input_exchange_factor: Option<ExactComplexRational>,
+    closure_exact_factor: ExactComplexRational,
+    contraction_exact_factor: ExactComplexRational,
+    semantic_digest: SemanticDigest,
+    witnesses: Box<[PreparedClosureWitness]>,
+}
+
+impl PreparedClosure {
+    fn new(
+        row: ClosureRow,
+        template: &OwnedRecurrenceTemplateInput,
+        catalog: &TemplateCatalog<'_>,
+    ) -> RusticolResult<Self> {
+        let input_states =
+            catalog.u32_sequence(row.input_state_sequence_id, "closure input states")?;
+        let input_states: [u32; 2] = input_states
+            .try_into()
+            .map_err(|_| invalid("direct recurrence requires binary prepared closures"))?;
+        let eligible = catalog.u32_sequence(
+            row.eligible_quantum_flow_sequence_id,
+            "closure eligible quantum flows",
+        )?;
+        let quantum_flows = if eligible.is_empty() {
+            vec![PreparedClosureQuantumFlow::unbound(row, catalog)?]
+        } else {
+            eligible
+                .iter()
+                .copied()
+                .map(|quantum_id| {
+                    let quantum = template
+                        .quantum_flows
+                        .get(quantum_id as usize)
+                        .copied()
+                        .ok_or_else(|| invalid("closure quantum flow is absent"))?;
+                    PreparedClosureQuantumFlow::bound(row, quantum, catalog)
+                })
+                .collect::<RusticolResult<Vec<_>>>()?
+        }
+        .into_boxed_slice();
+        let contraction = template
+            .color_contractions
+            .get(row.color_contraction_template_id as usize)
+            .copied()
+            .ok_or_else(|| invalid("closure color contraction is absent"))?;
+        let canonical_input_order = match catalog.u32_sequence(
+            row.canonical_input_order_sequence_id,
+            "closure canonical input order",
+        )? {
+            [0, 1] => [0, 1],
+            [1, 0] => [1, 0],
+            _ => {
+                return Err(invalid(
+                    "closure canonical input order is not a binary permutation",
+                ));
+            }
+        };
+        let input_exchange_factor = if row.input_exchange_factor_id == MISSING_U32 {
+            None
+        } else {
+            Some(catalog.factor(row.input_exchange_factor_id, "closure input-exchange")?)
+        };
+        let witnesses = catalog
+            .witness_rows(row.color_contraction_template_id)?
+            .iter()
+            .copied()
+            .map(|witness_row| {
+                Ok(PreparedClosureWitness {
+                    row: witness_row,
+                    witness: catalog.witness(witness_row)?,
+                })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        Ok(Self {
+            row,
+            input_states,
+            quantum_flows,
+            contraction,
+            canonical_input_order,
+            input_exchange_factor,
+            closure_exact_factor: catalog.factor(row.exact_factor_id, "closure exact")?,
+            contraction_exact_factor: catalog
+                .factor(contraction.exact_coefficient_factor_id, "closure color")?,
+            semantic_digest: catalog.digest(row.semantic_digest_id, "closure semantic")?,
+            witnesses,
+        })
+    }
+
+    fn parent_ids(
+        &self,
+        anchor_state: u32,
+        complement_state: u32,
+        anchor_id: u32,
+        complement_id: u32,
+    ) -> RusticolResult<[u32; 2]> {
+        if self.input_states == [complement_state, anchor_state] {
+            return Ok([complement_id, anchor_id]);
+        }
+        if anchor_state != complement_state && self.input_states == [anchor_state, complement_state]
+        {
+            return Ok([anchor_id, complement_id]);
+        }
+        Err(invalid("recurrence closure state index is inconsistent"))
+    }
+
+    fn canonical_evaluator_parents(
+        &self,
+        parent_ids: [u32; 2],
+    ) -> ([u32; 2], ExactComplexRational) {
+        let mut ordered = match self.canonical_input_order {
+            [0, 1] => parent_ids,
+            [1, 0] => [parent_ids[1], parent_ids[0]],
+            _ => unreachable!("validated prepared closure input order"),
+        };
+        let mut factor = ExactComplexRational::ONE;
+        if let Some(exchange_factor) = self.input_exchange_factor
+            && ordered[1] < ordered[0]
+        {
+            ordered.swap(0, 1);
+            factor = exchange_factor;
+        }
+        (ordered, factor)
+    }
+}
+
+#[derive(Debug, Default)]
+struct PreparedClosureCatalog {
+    rows_by_state_pair: BTreeMap<(u32, u32), Vec<PreparedClosure>>,
+    row_count: usize,
+}
+
+impl PreparedClosureCatalog {
+    fn new(
+        template: &OwnedRecurrenceTemplateInput,
+        catalog: &TemplateCatalog<'_>,
+    ) -> RusticolResult<Self> {
+        let mut rows_by_state_pair = BTreeMap::<(u32, u32), Vec<PreparedClosure>>::new();
+        for row in template.closures.iter().copied() {
+            let prepared = PreparedClosure::new(row, template, catalog)?;
+            rows_by_state_pair
+                .entry(canonical_state_pair(prepared.input_states))
+                .or_default()
+                .push(prepared);
+        }
+        Ok(Self {
+            rows_by_state_pair,
+            row_count: template.closures.len(),
+        })
+    }
+
+    fn rows(&self, left_state: u32, right_state: u32) -> &[PreparedClosure] {
+        self.rows_by_state_pair
+            .get(&canonical_state_pair([left_state, right_state]))
+            .map(Vec::as_slice)
+            .unwrap_or_default()
+    }
+
+    fn row_count(&self) -> usize {
+        self.row_count
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct PreparedClosureSector {
+    row: ProcessPhysicalLCSectorRow,
+    expected_components: Box<[LCColorComponent]>,
+    contracted_color_canonical_owner: bool,
+    anchor_support: Box<[u32]>,
+    complement_support: Box<[u32]>,
+}
+
+#[derive(Debug, Default)]
+struct PreparedClosureSectorCatalog {
+    sectors: BTreeMap<u32, PreparedClosureSector>,
+    v4_trace_sector_by_anchored_word: BTreeMap<Box<[u32]>, u32>,
+}
+
+impl PreparedClosureSectorCatalog {
+    fn new(
+        strategy: RecurrenceStrategy,
+        process: &OwnedRecurrenceProcessInput,
+        catalog: &ProcessCatalog<'_>,
+        materialized_sector_ids: &BTreeSet<u32>,
+    ) -> RusticolResult<Self> {
+        let source_count = process.external_legs.len();
+        let full_support = (0..source_count as u32).collect::<Vec<_>>();
+        let mut sectors = BTreeMap::new();
+        let mut v4_trace_sector_by_anchored_word = BTreeMap::new();
+        let mut contracted_open_forests = HashSet::<Box<[LCColorComponent]>>::new();
+        for row in process.physical_lc_sectors.iter().copied() {
+            if !materialized_sector_ids.contains(&row.sector_id)
+                && strategy != RecurrenceStrategy::ContractedColorUnion
+            {
+                continue;
+            }
+            let expected_components = expected_sector_components(row, process, catalog)?;
+            let contracted_color_canonical_owner = if strategy
+                == RecurrenceStrategy::ContractedColorUnion
+                && row.kind()? == ProcessLCSectorKind::OpenLines
+            {
+                let mut canonical = expected_components.clone();
+                canonical.sort_unstable();
+                contracted_open_forests.insert(canonical.into_boxed_slice())
+            } else {
+                true
+            };
+            if !materialized_sector_ids.contains(&row.sector_id) {
+                continue;
+            }
+            let complement_support = full_support
+                .iter()
+                .copied()
+                .filter(|slot| *slot != row.closure_source_slot)
+                .collect::<Vec<_>>()
+                .into_boxed_slice();
+            let prepared = PreparedClosureSector {
+                row,
+                expected_components: expected_components.into_boxed_slice(),
+                contracted_color_canonical_owner,
+                anchor_support: vec![row.closure_source_slot].into_boxed_slice(),
+                complement_support,
+            };
+            if sectors.insert(row.sector_id, prepared).is_some() {
+                return Err(invalid(
+                    "prepared closure sector catalog contains a duplicate sector",
+                ));
+            }
+            if row.kind()? == ProcessLCSectorKind::SingleTrace
+                && catalog.string(
+                    row.closure_proof_algorithm_string_id,
+                    "prepared closure-anchor algorithm",
+                )? == CYCLIC_TRACE_CLOSURE_ANCHOR_ALGORITHM
+            {
+                let word = catalog
+                    .u32_sequence(row.word_sequence_id, "prepared v4 physical LC sector word")?;
+                let key = anchored_cyclic_trace_word(word, row.closure_source_slot)?;
+                if v4_trace_sector_by_anchored_word
+                    .insert(key, row.sector_id)
+                    .is_some()
+                {
+                    return Err(invalid(
+                        "prepared v4 closure sectors contain an ambiguous cyclic trace word",
+                    ));
+                }
+            }
+        }
+        if sectors.len() != materialized_sector_ids.len() {
+            return Err(invalid(
+                "prepared closure sector catalog omits a materialized sector",
+            ));
+        }
+        Ok(Self {
+            sectors,
+            v4_trace_sector_by_anchored_word,
+        })
+    }
+
+    fn get(&self, sector_id: u32) -> RusticolResult<&PreparedClosureSector> {
+        self.sectors
+            .get(&sector_id)
+            .ok_or_else(|| invalid("prepared closure sector is absent"))
+    }
+
+    fn reflected_v4_sector(
+        &self,
+        mapped_word: &[u32],
+        closure_source_slot: u32,
+    ) -> RusticolResult<Option<u32>> {
+        let key = anchored_cyclic_trace_word(mapped_word, closure_source_slot)?;
+        Ok(self.v4_trace_sector_by_anchored_word.get(&key).copied())
+    }
+}
+
+fn closure_domain_sector_owners(
+    strategy: RecurrenceStrategy,
+    prepared_sectors: &PreparedClosureSectorCatalog,
+    physical_sector_ids: &BTreeSet<u32>,
+) -> RusticolResult<BTreeMap<u32, u32>> {
+    let mut owner_by_open_forest = BTreeMap::<Box<[LCColorComponent]>, u32>::new();
+    let mut result = BTreeMap::new();
+    for sector_id in physical_sector_ids.iter().copied() {
+        let sector = prepared_sectors.get(sector_id)?;
+        let owner_id = if strategy == RecurrenceStrategy::ContractedColorUnion
+            && sector.row.kind()? == ProcessLCSectorKind::OpenLines
+        {
+            let mut canonical = sector.expected_components.to_vec();
+            canonical.sort_unstable();
+            let owner_id = *owner_by_open_forest
+                .entry(canonical.into_boxed_slice())
+                .or_insert(sector_id);
+            if sector.contracted_color_canonical_owner != (owner_id == sector_id) {
+                return Err(invalid(
+                    "contracted closure-sector owner classification is inconsistent",
+                ));
+            }
+            owner_id
+        } else {
+            sector_id
+        };
+        result.insert(sector_id, owner_id);
+    }
+    Ok(result)
+}
+
+#[derive(Debug, Default)]
+pub(super) struct TransitionReflectionIndex {
+    proofs_by_transition: BTreeMap<u32, TransitionReflectionProof>,
+}
+
+impl TransitionReflectionIndex {
+    pub(super) fn new(
+        template: &OwnedRecurrenceTemplateInput,
+        catalog: &TemplateCatalog<'_>,
+    ) -> RusticolResult<Self> {
+        let transitions_by_subject = template
+            .transitions
+            .iter()
+            .map(|row| (row.template_string_id, row.id))
+            .collect::<BTreeMap<_, _>>();
+        let mut result = Self::default();
+        for proof in &template.symmetry_proofs {
+            if catalog.string(proof.proof_algorithm_string_id, "symmetry proof algorithm")?
+                != "canonical-current-word-reversal-v1"
+            {
+                continue;
+            }
+            let subjects = catalog.u32_sequence(
+                proof.subject_template_sequence_id,
+                "current-word reversal proof subjects",
+            )?;
+            let [subject] = subjects else {
+                return Err(invalid(
+                    "current-word reversal proof must reference one transition",
+                ));
+            };
+            let transition_id = transitions_by_subject
+                .get(subject)
+                .copied()
+                .ok_or_else(|| {
+                    invalid("current-word reversal proof subject is not a transition")
+                })?;
+            if catalog.u32_sequence(
+                proof.input_permutation_sequence_id,
+                "current-word reversal proof permutation",
+            )? != [1, 0]
+            {
+                return Err(invalid(
+                    "current-word reversal proof must exchange two transition inputs",
+                ));
+            }
+            let phase =
+                catalog.factor(proof.exact_phase_factor_id, "current-word reversal proof")?;
+            let candidate = TransitionReflectionProof::new(
+                phase,
+                [catalog.digest(
+                    proof.semantic_digest_id,
+                    "current-word reversal semantic proof",
+                )?],
+                [catalog.digest(
+                    proof.witness_digest_id,
+                    "current-word reversal witness proof",
+                )?],
+            )?;
+            match result.proofs_by_transition.entry(transition_id) {
+                std::collections::btree_map::Entry::Vacant(entry) => {
+                    entry.insert(candidate);
+                }
+                std::collections::btree_map::Entry::Occupied(mut entry) => {
+                    let Some(merged) = entry.get().merged_with(&candidate)? else {
+                        return Err(invalid(
+                            "transition has conflicting current-word reversal phases",
+                        ));
+                    };
+                    entry.insert(merged);
+                }
+            }
+        }
+        Ok(result)
+    }
+
+    pub(super) fn proof(&self, transition_id: u32) -> Option<&TransitionReflectionProof> {
+        self.proofs_by_transition.get(&transition_id)
+    }
+}
+
+fn canonical_state_pair([left, right]: [u32; 2]) -> (u32, u32) {
+    if left <= right {
+        (left, right)
+    } else {
+        (right, left)
+    }
+}
+
+/// Necessary physical-sector compatibility for a partial LC color forest.
+///
+/// Recurrence witnesses can join or explicitly reverse ordered components, but
+/// they never split or internally permute an existing component. A partial
+/// component must therefore occur as an oriented contiguous word in at least
+/// one materialized representative sector. Pure-adjoint reversed words are
+/// admitted transiently for one construction stage so reflection proofs can be
+/// finalized over the complete fan-in. A stage-final reconciliation then
+/// removes only exactly certified aliases. This cheap forward filter prevents
+/// the builder from interning unrelated color words; final backward liveness
+/// remains authoritative.
+#[derive(Clone, Debug, Eq, PartialEq)]
+enum SectorPostingStorage {
+    Sparse(Box<[u32]>),
+    Dense(Box<[u64]>),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct SectorPosting {
+    cardinality: usize,
+    storage: SectorPostingStorage,
+}
+
+impl SectorPosting {
+    fn from_sorted_unique_sector_ids(sector_ids: Vec<u32>, sector_count: usize) -> Self {
+        debug_assert!(!sector_ids.is_empty());
+        debug_assert!(sector_ids.windows(2).all(|pair| pair[0] < pair[1]));
+        debug_assert!(
+            sector_ids
+                .last()
+                .is_none_or(|sector_id| (*sector_id as usize) < sector_count)
+        );
+        let cardinality = sector_ids.len();
+        let sparse_bytes = cardinality
+            .checked_mul(std::mem::size_of::<u32>())
+            .expect("allocated sparse posting byte size exceeds usize");
+        let dense_word_count = sector_count.div_ceil(u64::BITS as usize);
+        let dense_bytes = dense_word_count
+            .checked_mul(std::mem::size_of::<u64>())
+            .expect("allocated dense posting byte size exceeds usize");
+        let storage = if dense_bytes < sparse_bytes {
+            let mut words = vec![0_u64; dense_word_count];
+            for sector_id in sector_ids {
+                let sector_index = sector_id as usize;
+                words[sector_index / u64::BITS as usize] |=
+                    1_u64 << (sector_index % u64::BITS as usize);
+            }
+            SectorPostingStorage::Dense(words.into_boxed_slice())
+        } else {
+            SectorPostingStorage::Sparse(sector_ids.into_boxed_slice())
+        };
+        Self {
+            cardinality,
+            storage,
+        }
+    }
+
+    fn cardinality(&self) -> usize {
+        self.cardinality
+    }
+
+    fn contains(&self, sector_id: u32) -> bool {
+        match &self.storage {
+            SectorPostingStorage::Sparse(sector_ids) => {
+                sector_ids.binary_search(&sector_id).is_ok()
+            }
+            SectorPostingStorage::Dense(words) => {
+                let sector_index = sector_id as usize;
+                words
+                    .get(sector_index / u64::BITS as usize)
+                    .is_some_and(|word| word & (1_u64 << (sector_index % u64::BITS as usize)) != 0)
+            }
+        }
+    }
+
+    fn any_sector(&self, mut predicate: impl FnMut(u32) -> bool) -> bool {
+        match &self.storage {
+            SectorPostingStorage::Sparse(sector_ids) => sector_ids.iter().copied().any(predicate),
+            SectorPostingStorage::Dense(words) => {
+                for (word_index, word) in words.iter().copied().enumerate() {
+                    let mut remaining = word;
+                    while remaining != 0 {
+                        let bit_index = remaining.trailing_zeros() as usize;
+                        let sector_index = word_index * u64::BITS as usize + bit_index;
+                        let sector_id =
+                            u32::try_from(sector_index).expect("sector posting exceeds u32");
+                        if predicate(sector_id) {
+                            return true;
+                        }
+                        remaining &= remaining - 1;
+                    }
+                }
+                false
+            }
+        }
+    }
+
+    fn payload_bytes(&self) -> usize {
+        match &self.storage {
+            SectorPostingStorage::Sparse(sector_ids) => sector_ids
+                .len()
+                .checked_mul(std::mem::size_of::<u32>())
+                .expect("allocated sparse posting byte size exceeds usize"),
+            SectorPostingStorage::Dense(words) => words
+                .len()
+                .checked_mul(std::mem::size_of::<u64>())
+                .expect("allocated dense posting byte size exceeds usize"),
+        }
+    }
+
+    fn dense_words(&self) -> Option<&[u64]> {
+        match &self.storage {
+            SectorPostingStorage::Sparse(_) => None,
+            SectorPostingStorage::Dense(words) => Some(words),
+        }
+    }
+
+    fn is_sparse(&self) -> bool {
+        matches!(&self.storage, SectorPostingStorage::Sparse(_))
+    }
+}
+
+#[derive(Debug)]
+struct MaterializedColorTargets {
+    collect_telemetry: bool,
+    non_trace_fragment_sectors: HashMap<Box<[u32]>, SectorPosting>,
+    trace_component_sectors: HashMap<Box<[u32]>, SectorPosting>,
+    accepted_component_forests: RefCell<HashSet<Box<[LCColorComponent]>>>,
+    acceptance_cache_hit_count: Cell<usize>,
+    acceptance_cache_miss_count: Cell<usize>,
+    acceptance_accept_count: Cell<usize>,
+    acceptance_reject_count: Cell<usize>,
+    fragment_hash_lookup_count: Cell<usize>,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+struct MaterializedColorTargetTelemetry {
+    fragment_bucket_count: usize,
+    acceptance_cache_hit_count: usize,
+    acceptance_cache_miss_count: usize,
+    acceptance_accept_count: usize,
+    acceptance_reject_count: usize,
+    fragment_hash_lookup_count: usize,
+    posting_incidence_count: usize,
+    sparse_posting_bucket_count: usize,
+    dense_posting_bucket_count: usize,
+    sparse_posting_bytes: usize,
+    dense_posting_bytes: usize,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct PendingConstructionDomain {
+    shared_source_end: usize,
+    lane_internal_start: usize,
+    lane_internal_end: usize,
+}
+
+impl PendingConstructionDomain {
+    fn contains(self, current_id: usize) -> bool {
+        current_id < self.shared_source_end
+            || (self.lane_internal_start..self.lane_internal_end).contains(&current_id)
+    }
+}
+
+#[derive(Debug, Default)]
+struct LaneClosureSupportIndex<'a> {
+    current_ids_by_support: BTreeMap<&'a [u32], Vec<u32>>,
+}
+
+impl<'a> LaneClosureSupportIndex<'a> {
+    fn new(
+        currents: &'a [PendingCurrent],
+        construction_domain: Option<PendingConstructionDomain>,
+    ) -> RusticolResult<Self> {
+        let mut current_ids_by_support = BTreeMap::<&[u32], Vec<u32>>::new();
+        for (current_id, current) in currents.iter().enumerate() {
+            if construction_domain.is_some_and(|domain| !domain.contains(current_id)) {
+                continue;
+            }
+            current_ids_by_support
+                .entry(current.key.support_source_slots())
+                .or_default()
+                .push(
+                    u32::try_from(current_id)
+                        .map_err(|_| invalid("closure current ID exceeds u32"))?,
+                );
+        }
+        Ok(Self {
+            current_ids_by_support,
+        })
+    }
+
+    fn current_ids(&self, support: &[u32]) -> &[u32] {
+        self.current_ids_by_support
+            .get(support)
+            .map(Vec::as_slice)
+            .unwrap_or_default()
+    }
+}
+
+impl MaterializedColorTargets {
+    #[cfg(test)]
+    fn new(
+        materialized_sector_ids: &BTreeSet<u32>,
+        process: &OwnedRecurrenceProcessInput,
+        catalog: &ProcessCatalog<'_>,
+    ) -> RusticolResult<Self> {
+        Self::new_with_telemetry(materialized_sector_ids, process, catalog, false)
+    }
+
+    #[cfg(test)]
+    fn new_with_telemetry(
+        materialized_sector_ids: &BTreeSet<u32>,
+        process: &OwnedRecurrenceProcessInput,
+        catalog: &ProcessCatalog<'_>,
+        collect_telemetry: bool,
+    ) -> RusticolResult<Self> {
+        let sectors = materialized_sector_ids
+            .iter()
+            .copied()
+            .map(|sector_id| {
+                let sector = process
+                    .physical_lc_sectors
+                    .get(sector_id as usize)
+                    .copied()
+                    .ok_or_else(|| invalid("materialized LC sector is absent"))?;
+                expected_sector_components(sector, process, catalog)
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        Self::from_sectors_with_telemetry(sectors, collect_telemetry)
+    }
+
+    fn new_with_prepared_sectors(
+        materialized_sector_ids: &BTreeSet<u32>,
+        sectors: &PreparedClosureSectorCatalog,
+        collect_telemetry: bool,
+    ) -> RusticolResult<Self> {
+        let sectors = materialized_sector_ids
+            .iter()
+            .copied()
+            .map(|sector_id| Ok(sectors.get(sector_id)?.expected_components.to_vec()))
+            .collect::<RusticolResult<Vec<_>>>()?;
+        Self::from_sectors_with_telemetry(sectors, collect_telemetry)
+    }
+
+    #[cfg(test)]
+    fn from_sectors(sectors: Vec<Vec<LCColorComponent>>) -> RusticolResult<Self> {
+        Self::from_sectors_with_telemetry(sectors, false)
+    }
+
+    fn from_sectors_with_telemetry(
+        sectors: Vec<Vec<LCColorComponent>>,
+        collect_telemetry: bool,
+    ) -> RusticolResult<Self> {
+        if sectors.is_empty() {
+            return Err(invalid(
+                "recurrence construction has no materialized LC sector",
+            ));
+        }
+        let sector_count = sectors.len();
+        let mut non_trace_fragment_sector_ids = HashMap::<Box<[u32]>, Vec<u32>>::new();
+        let mut trace_component_sector_ids = HashMap::<Box<[u32]>, Vec<u32>>::new();
+        for (sector_index, sector) in sectors.iter().enumerate() {
+            let sector_id = u32::try_from(sector_index)
+                .map_err(|_| invalid("materialized LC sector index exceeds u32"))?;
+            for target in sector {
+                match target.kind() {
+                    LCColorComponentKind::Trace => {
+                        Self::include_fragment(
+                            &mut trace_component_sector_ids,
+                            target.source_slots(),
+                            sector_id,
+                        );
+                        Self::include_cyclic_fragments(
+                            &mut non_trace_fragment_sector_ids,
+                            target.source_slots(),
+                            sector_id,
+                        );
+                    }
+                    LCColorComponentKind::OpenString | LCColorComponentKind::AdjointSegment => {
+                        Self::include_linear_fragments(
+                            &mut non_trace_fragment_sector_ids,
+                            target.source_slots(),
+                            sector_id,
+                        );
+                    }
+                }
+            }
+        }
+        Ok(Self {
+            collect_telemetry,
+            non_trace_fragment_sectors: Self::freeze_posting_index(
+                non_trace_fragment_sector_ids,
+                sector_count,
+            ),
+            trace_component_sectors: Self::freeze_posting_index(
+                trace_component_sector_ids,
+                sector_count,
+            ),
+            accepted_component_forests: RefCell::new(HashSet::new()),
+            acceptance_cache_hit_count: Cell::new(0),
+            acceptance_cache_miss_count: Cell::new(0),
+            acceptance_accept_count: Cell::new(0),
+            acceptance_reject_count: Cell::new(0),
+            fragment_hash_lookup_count: Cell::new(0),
+        })
+    }
+
+    fn accepts(&self, state: &DynamicLCColorState) -> bool {
+        if self
+            .accepted_component_forests
+            .borrow()
+            .contains(state.components())
+        {
+            if self.collect_telemetry {
+                self.acceptance_cache_hit_count
+                    .set(self.acceptance_cache_hit_count.get().saturating_add(1));
+                self.acceptance_accept_count
+                    .set(self.acceptance_accept_count.get().saturating_add(1));
+            }
+            return true;
+        }
+        if self.collect_telemetry {
+            self.acceptance_cache_miss_count
+                .set(self.acceptance_cache_miss_count.get().saturating_add(1));
+        }
+        let accepted = self.accepts_uncached(state);
+        if accepted {
+            if self.collect_telemetry {
+                self.acceptance_accept_count
+                    .set(self.acceptance_accept_count.get().saturating_add(1));
+            }
+            self.accepted_component_forests
+                .borrow_mut()
+                .insert(state.components().into());
+        } else if self.collect_telemetry {
+            self.acceptance_reject_count
+                .set(self.acceptance_reject_count.get().saturating_add(1));
+        }
+        accepted
+    }
+
+    fn accepts_up_to_reflection(&self, state: &DynamicLCColorState) -> RusticolResult<bool> {
+        if self.accepts(state) {
+            return Ok(true);
+        }
+        if state.pure_adjoint_word().is_none() {
+            return Ok(false);
+        }
+        Ok(self.accepts(&state.reversed()?))
+    }
+
+    fn accepts_uncached(&self, state: &DynamicLCColorState) -> bool {
+        if state.components().is_empty() {
+            return true;
+        }
+        let mut component_postings = Vec::with_capacity(state.components().len());
+        for partial in state.components() {
+            if self.collect_telemetry {
+                self.fragment_hash_lookup_count
+                    .set(self.fragment_hash_lookup_count.get().saturating_add(1));
+            }
+            let fragment_sectors = if partial.kind() == LCColorComponentKind::Trace {
+                self.trace_component_sectors.get(partial.source_slots())
+            } else {
+                self.non_trace_fragment_sectors.get(partial.source_slots())
+            };
+            let Some(fragment_sectors) = fragment_sectors else {
+                return false;
+            };
+            component_postings.push(fragment_sectors);
+        }
+        if component_postings.len() == 1 {
+            return true;
+        }
+        if component_postings
+            .iter()
+            .all(|posting| posting.dense_words().is_some())
+        {
+            let word_count = component_postings[0]
+                .dense_words()
+                .expect("all color postings are dense")
+                .len();
+            debug_assert!(component_postings.iter().all(|posting| {
+                posting
+                    .dense_words()
+                    .is_some_and(|words| words.len() == word_count)
+            }));
+            return (0..word_count).any(|word_index| {
+                component_postings
+                    .iter()
+                    .fold(u64::MAX, |intersection, posting| {
+                        intersection
+                            & posting.dense_words().expect("all color postings are dense")
+                                [word_index]
+                    })
+                    != 0
+            });
+        }
+        let (candidate_posting_index, candidate_posting) = component_postings
+            .iter()
+            .enumerate()
+            .min_by_key(|(_, posting)| posting.cardinality())
+            .expect("non-empty color forest has at least one posting");
+        candidate_posting.any_sector(|sector_id| {
+            component_postings
+                .iter()
+                .enumerate()
+                .all(|(posting_index, posting)| {
+                    posting_index == candidate_posting_index || posting.contains(sector_id)
+                })
+        })
+    }
+
+    fn telemetry(&self) -> RusticolResult<MaterializedColorTargetTelemetry> {
+        let postings = self
+            .non_trace_fragment_sectors
+            .values()
+            .chain(self.trace_component_sectors.values());
+        let mut posting_incidence_count = 0usize;
+        let mut sparse_posting_bucket_count = 0usize;
+        let mut dense_posting_bucket_count = 0usize;
+        let mut sparse_posting_bytes = 0usize;
+        let mut dense_posting_bytes = 0usize;
+        for posting in postings {
+            posting_incidence_count = posting_incidence_count
+                .checked_add(posting.cardinality())
+                .ok_or_else(|| invalid("color-posting incidence count exceeds usize"))?;
+            if posting.is_sparse() {
+                sparse_posting_bucket_count = sparse_posting_bucket_count
+                    .checked_add(1)
+                    .ok_or_else(|| invalid("sparse color-posting bucket count exceeds usize"))?;
+                sparse_posting_bytes = sparse_posting_bytes
+                    .checked_add(posting.payload_bytes())
+                    .ok_or_else(|| invalid("sparse color-posting bytes exceed usize"))?;
+            } else {
+                dense_posting_bucket_count = dense_posting_bucket_count
+                    .checked_add(1)
+                    .ok_or_else(|| invalid("dense color-posting bucket count exceeds usize"))?;
+                dense_posting_bytes = dense_posting_bytes
+                    .checked_add(posting.payload_bytes())
+                    .ok_or_else(|| invalid("dense color-posting bytes exceed usize"))?;
+            }
+        }
+        Ok(MaterializedColorTargetTelemetry {
+            fragment_bucket_count: self
+                .non_trace_fragment_sectors
+                .len()
+                .checked_add(self.trace_component_sectors.len())
+                .ok_or_else(|| invalid("color-fragment bucket count exceeds usize"))?,
+            acceptance_cache_hit_count: self.acceptance_cache_hit_count.get(),
+            acceptance_cache_miss_count: self.acceptance_cache_miss_count.get(),
+            acceptance_accept_count: self.acceptance_accept_count.get(),
+            acceptance_reject_count: self.acceptance_reject_count.get(),
+            fragment_hash_lookup_count: self.fragment_hash_lookup_count.get(),
+            posting_incidence_count,
+            sparse_posting_bucket_count,
+            dense_posting_bucket_count,
+            sparse_posting_bytes,
+            dense_posting_bytes,
+        })
+    }
+
+    fn include_linear_fragments(
+        index: &mut HashMap<Box<[u32]>, Vec<u32>>,
+        source_slots: &[u32],
+        sector_id: u32,
+    ) {
+        for start in 0..source_slots.len() {
+            for end in start + 1..=source_slots.len() {
+                Self::include_fragment(index, &source_slots[start..end], sector_id);
+            }
+        }
+    }
+
+    fn include_cyclic_fragments(
+        index: &mut HashMap<Box<[u32]>, Vec<u32>>,
+        source_slots: &[u32],
+        sector_id: u32,
+    ) {
+        for start in 0..source_slots.len() {
+            let mut fragment = Vec::with_capacity(source_slots.len());
+            for offset in 0..source_slots.len() {
+                fragment.push(source_slots[(start + offset) % source_slots.len()]);
+                Self::include_fragment(index, &fragment, sector_id);
+            }
+        }
+    }
+
+    fn include_fragment(
+        index: &mut HashMap<Box<[u32]>, Vec<u32>>,
+        source_slots: &[u32],
+        sector_id: u32,
+    ) {
+        if let Some(sector_ids) = index.get_mut(source_slots) {
+            if sector_ids.last().copied() != Some(sector_id) {
+                sector_ids.push(sector_id);
+            }
+        } else {
+            index.insert(source_slots.to_vec().into_boxed_slice(), vec![sector_id]);
+        }
+    }
+
+    fn freeze_posting_index(
+        index: HashMap<Box<[u32]>, Vec<u32>>,
+        sector_count: usize,
+    ) -> HashMap<Box<[u32]>, SectorPosting> {
+        index
+            .into_iter()
+            .map(|(fragment, sector_ids)| {
+                (
+                    fragment,
+                    SectorPosting::from_sorted_unique_sector_ids(sector_ids, sector_count),
+                )
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+fn component_can_embed(partial: &LCColorComponent, target: &LCColorComponent) -> bool {
+    if partial.kind() == LCColorComponentKind::Trace {
+        return target.kind() == LCColorComponentKind::Trace
+            && partial.source_slots().len() == target.source_slots().len()
+            && cyclic_word_contains(target.source_slots(), partial.source_slots());
+    }
+    match target.kind() {
+        LCColorComponentKind::Trace => {
+            cyclic_word_contains(target.source_slots(), partial.source_slots())
+        }
+        LCColorComponentKind::OpenString | LCColorComponentKind::AdjointSegment => {
+            linear_word_contains(target.source_slots(), partial.source_slots())
+        }
+    }
+}
+
+#[cfg(test)]
+fn linear_word_contains(target: &[u32], partial: &[u32]) -> bool {
+    !partial.is_empty()
+        && partial.len() <= target.len()
+        && target
+            .windows(partial.len())
+            .any(|window| window == partial)
+}
+
+#[cfg(test)]
+fn cyclic_word_contains(target: &[u32], partial: &[u32]) -> bool {
+    !partial.is_empty()
+        && partial.len() <= target.len()
+        && (0..target.len()).any(|start| {
+            (0..partial.len())
+                .all(|offset| target[(start + offset) % target.len()] == partial[offset])
+        })
+}
+
+pub(super) struct TemplateCatalog<'a> {
+    input: &'a OwnedRecurrenceTemplateInput,
+    strings: Vec<&'a str>,
+    digests: Vec<SemanticDigest>,
+    factors: Vec<ExactComplexRational>,
+    coupling_names: Vec<&'a str>,
+}
+
+impl<'a> TemplateCatalog<'a> {
+    pub(super) fn new(input: &'a OwnedRecurrenceTemplateInput) -> RusticolResult<Self> {
+        let strings = decode_strings(
+            &input.string_ranges,
+            &input.string_bytes,
+            "recurrence template string",
+        )?;
+        let digests = input
+            .digest_catalog
+            .iter()
+            .map(|row| SemanticDigest::new(row.value))
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let factors = decode_template_factors(input, &strings)?;
+        let coupling_names = input
+            .coupling_order_terms
+            .iter()
+            .map(|row| required_string(&strings, row.name_string_id, "coupling-order name"))
+            .collect::<RusticolResult<BTreeSet<_>>>()?
+            .into_iter()
+            .collect();
+        Ok(Self {
+            input,
+            strings,
+            digests,
+            factors,
+            coupling_names,
+        })
+    }
+
+    pub(super) fn string(&self, id: u32, label: &str) -> RusticolResult<&'a str> {
+        required_string(&self.strings, id, label)
+    }
+
+    pub(super) fn digest(&self, id: u32, label: &str) -> RusticolResult<SemanticDigest> {
+        self.digests
+            .get(id as usize)
+            .copied()
+            .ok_or_else(|| invalid(format!("{label} digest {id} is absent")))
+    }
+
+    pub(super) fn factor(&self, id: u32, label: &str) -> RusticolResult<ExactComplexRational> {
+        self.factors
+            .get(id as usize)
+            .copied()
+            .ok_or_else(|| invalid(format!("{label} factor {id} is absent")))
+    }
+
+    pub(super) fn u32_sequence(&self, id: u32, label: &str) -> RusticolResult<&'a [u32]> {
+        indexed_sequence(
+            &self.input.u32_sequence_ranges,
+            &self.input.u32_sequence_values,
+            id,
+            label,
+        )
+    }
+
+    pub(super) fn i32_sequence(&self, id: u32, label: &str) -> RusticolResult<&'a [i32]> {
+        indexed_sequence(
+            &self.input.i32_sequence_ranges,
+            &self.input.i32_sequence_values,
+            id,
+            label,
+        )
+    }
+
+    pub(super) fn flavour_flow(&self, id: u32, label: &str) -> RusticolResult<&'a [i32]> {
+        indexed_sequence(
+            &self.input.flavour_flow_ranges,
+            &self.input.flavour_flow_values,
+            id,
+            label,
+        )
+    }
+
+    pub(super) fn source_seed(&self, row: SourceRow) -> RusticolResult<LCColorSourceSeed> {
+        let operation = LCColorSourceSeedOperation::try_from(row.lc_color_seed_operation)?;
+        let kind = (row.lc_color_seed_component_kind != u8::MAX)
+            .then(|| LCColorComponentKind::try_from(row.lc_color_seed_component_kind))
+            .transpose()?;
+        LCColorSourceSeed::new(
+            operation,
+            row.lc_color_seed_shape_string_id,
+            kind,
+            LCColorComponentRole::try_from(row.lc_color_seed_component_role)?,
+            self.digest(row.lc_color_seed_proof_digest_id, "source color proof")?,
+        )
+    }
+
+    pub(super) fn witness(
+        &self,
+        row: LCColorTransitionWitnessRow,
+    ) -> RusticolResult<LCColorTransitionWitness> {
+        let permutation = match row.input_permutation {
+            0 => [0, 1],
+            1 => [1, 0],
+            value => return Err(invalid(format!("invalid LC witness permutation {value}"))),
+        };
+        let kind = (row.result_component_kind != u8::MAX)
+            .then(|| LCColorComponentKind::try_from(row.result_component_kind))
+            .transpose()?;
+        let shape =
+            (row.result_shape_string_id != MISSING_U32).then_some(row.result_shape_string_id);
+        let pairing_values = self.u32_sequence(
+            row.input_port_pairing_sequence_id,
+            "LC witness input-port pairings",
+        )?;
+        if pairing_values.len() % 4 != 0 {
+            return Err(invalid(
+                "LC witness input-port pairing sequence is not divisible by four",
+            ));
+        }
+        let input_pairings = pairing_values
+            .chunks_exact(4)
+            .map(|chunk| {
+                Ok([
+                    LCColorParentPort::new(
+                        u8::try_from(chunk[0])
+                            .map_err(|_| invalid("LC witness parent index exceeds u8"))?,
+                        u8::try_from(chunk[1])
+                            .map_err(|_| invalid("LC witness local port index exceeds u8"))?,
+                    )?,
+                    LCColorParentPort::new(
+                        u8::try_from(chunk[2])
+                            .map_err(|_| invalid("LC witness parent index exceeds u8"))?,
+                        u8::try_from(chunk[3])
+                            .map_err(|_| invalid("LC witness local port index exceeds u8"))?,
+                    )?,
+                ])
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let binding_values = self.u32_sequence(
+            row.result_port_binding_sequence_id,
+            "LC witness result-port bindings",
+        )?;
+        if binding_values.len() % 2 != 0 {
+            return Err(invalid(
+                "LC witness result-port binding sequence is not divisible by two",
+            ));
+        }
+        let result_port_bindings = binding_values
+            .chunks_exact(2)
+            .map(|chunk| {
+                LCColorParentPort::new(
+                    u8::try_from(chunk[0])
+                        .map_err(|_| invalid("LC witness parent index exceeds u8"))?,
+                    u8::try_from(chunk[1])
+                        .map_err(|_| invalid("LC witness local port index exceeds u8"))?,
+                )
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let component_parent_order = match row.input_permutation {
+            0 => [0, 1],
+            1 => [1, 0],
+            value => return Err(invalid(format!("invalid LC witness permutation {value}"))),
+        };
+        LCColorTransitionWitness::new(
+            permutation,
+            row.reverse_parent_mask,
+            LCColorComponentOperation::try_from(row.component_operation)?,
+            kind,
+            LCColorComponentRole::try_from(row.result_component_role)?,
+            shape,
+            LCColorPortWiring::new(component_parent_order, input_pairings, result_port_bindings)?,
+            self.factor(row.exact_factor_id, "LC witness")?,
+            self.digest(row.proof_digest_id, "LC witness proof")?,
+        )
+    }
+
+    pub(super) fn witness_rows(
+        &self,
+        color_contraction_id: u32,
+    ) -> RusticolResult<&'a [LCColorTransitionWitnessRow]> {
+        let row = self
+            .input
+            .color_contractions
+            .get(color_contraction_id as usize)
+            .ok_or_else(|| invalid("color-contraction template is absent"))?;
+        let range = CheckedTableRange::new(row.witness_start, row.witness_count).as_usize_range(
+            self.input.lc_color_transition_witnesses.len(),
+            "LC witnesses",
+        )?;
+        Ok(&self.input.lc_color_transition_witnesses[range])
+    }
+
+    pub(super) fn coupling_orders(&self, set_id: u32) -> RusticolResult<Vec<u32>> {
+        let range = self
+            .input
+            .coupling_order_ranges
+            .get(set_id as usize)
+            .ok_or_else(|| invalid(format!("coupling-order set {set_id} is absent")))?
+            .range
+            .as_usize_range(self.input.coupling_order_terms.len(), "coupling-order set")?;
+        let mut result = vec![0_u32; self.coupling_names.len()];
+        for term in &self.input.coupling_order_terms[range] {
+            let name = self.string(term.name_string_id, "coupling-order term")?;
+            let index = self
+                .coupling_names
+                .binary_search(&name)
+                .map_err(|_| invalid("coupling-order name disappeared"))?;
+            result[index] = term.power;
+        }
+        Ok(result)
+    }
+
+    pub(super) fn coupling_order_dimension(&self) -> usize {
+        self.coupling_names.len()
+    }
+
+    #[allow(dead_code)]
+    pub(super) fn coupling_order_names(&self) -> &[&'a str] {
+        &self.coupling_names
+    }
+}
+
+struct ProcessCatalog<'a> {
+    input: &'a OwnedRecurrenceProcessInput,
+    strings: Vec<&'a str>,
+    factors: Vec<ExactComplexRational>,
+}
+
+impl<'a> ProcessCatalog<'a> {
+    fn new(input: &'a OwnedRecurrenceProcessInput) -> RusticolResult<Self> {
+        let strings = decode_strings(
+            &input.string_ranges,
+            &input.string_bytes,
+            "recurrence process string",
+        )?;
+        let factors = decode_process_factors(input, &strings)?;
+        Ok(Self {
+            input,
+            strings,
+            factors,
+        })
+    }
+
+    fn string(&self, id: u32, label: &str) -> RusticolResult<&'a str> {
+        required_string(&self.strings, id, label)
+    }
+
+    fn factor(&self, id: u32, label: &str) -> RusticolResult<ExactComplexRational> {
+        self.factors
+            .get(id as usize)
+            .copied()
+            .ok_or_else(|| invalid(format!("{label} factor {id} is absent")))
+    }
+
+    fn u32_sequence(&self, id: u32, label: &str) -> RusticolResult<&'a [u32]> {
+        let range = self
+            .input
+            .u32_sequence_ranges
+            .get(id as usize)
+            .copied()
+            .ok_or_else(|| invalid(format!("{label} sequence {id} is absent")))?;
+        let range = range.as_usize_range(self.input.u32_sequence_values.len(), label)?;
+        Ok(&self.input.u32_sequence_values[range])
+    }
+
+    fn public_helicities(
+        &self,
+        source_states: &[SourceStateAssignment],
+    ) -> RusticolResult<Vec<i32>> {
+        if source_states.len() != self.input.external_legs.len() {
+            return Err(invalid(
+                "resolved helicity does not cover every external source slot",
+            ));
+        }
+        source_states
+            .iter()
+            .copied()
+            .enumerate()
+            .map(|(source_slot, assignment)| {
+                if assignment.source_slot() as usize != source_slot {
+                    return Err(invalid(
+                        "resolved-helicity source-state ancestry is not canonical",
+                    ));
+                }
+                let leg = self.input.external_legs[source_slot];
+                if u64::from(assignment.state_index()) >= leg.source_state_range.count {
+                    return Err(invalid(format!(
+                        "resolved helicity references absent state {} for source slot {source_slot}",
+                        assignment.state_index()
+                    )));
+                }
+                let row_index = leg
+                    .source_state_range
+                    .start
+                    .checked_add(u64::from(assignment.state_index()))
+                    .ok_or_else(|| invalid("resolved-helicity source-state index overflows"))?;
+                let row_index = usize::try_from(row_index)
+                    .map_err(|_| invalid("resolved-helicity source-state index exceeds usize"))?;
+                let state = self
+                    .input
+                    .source_states
+                    .get(row_index)
+                    .ok_or_else(|| invalid("resolved-helicity source state is absent"))?;
+                if state.source_slot as usize != source_slot
+                    || state.state_index != assignment.state_index()
+                {
+                    return Err(invalid(
+                        "resolved-helicity source-state catalog is inconsistent",
+                    ));
+                }
+                Ok(state.public_helicity)
+            })
+            .collect()
+    }
+}
+
+fn validate_cyclic_trace_closure_anchor_contracts(
+    process: &OwnedRecurrenceProcessInput,
+    process_catalog: &ProcessCatalog<'_>,
+    template: &OwnedRecurrenceTemplateInput,
+    template_catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<()> {
+    let mut has_cyclic_trace_anchor = false;
+    for sector in &process.physical_lc_sectors {
+        if process_catalog.string(
+            sector.closure_proof_algorithm_string_id,
+            "closure-anchor proof algorithm",
+        )? == CYCLIC_TRACE_CLOSURE_ANCHOR_ALGORITHM
+        {
+            has_cyclic_trace_anchor = true;
+            break;
+        }
+    }
+    if !has_cyclic_trace_anchor {
+        return Ok(());
+    }
+
+    // The authenticated process catalog already proves that every source is
+    // nonfermionic and uses this same, nonempty current-state contract.
+    let state_template_id = process
+        .source_states
+        .first()
+        .ok_or_else(|| invalid("cyclic trace closure state contract is absent"))?
+        .current_state_template_id;
+    let state = template
+        .current_states
+        .get(state_template_id as usize)
+        .copied()
+        .ok_or_else(|| invalid("cyclic trace closure current state is absent"))?;
+    let color_shape = template_catalog.string(
+        state.lc_color_shape_string_id,
+        "cyclic trace closure current-state color shape",
+    )?;
+    if CurrentOrientation::try_from(state.orientation)? != CurrentOrientation::SelfConjugate
+        || ParticleStatistics::try_from(state.statistics)? != ParticleStatistics::Boson
+        || state.particle_id != state.anti_particle_id
+        || state.color_representation != 8
+        || color_shape != "adjoint-segment"
+        || state.auxiliary_kind_string_id != MISSING_U32
+    {
+        return Err(invalid(
+            "cyclic trace closure anchoring requires one non-auxiliary, bosonic, self-conjugate adjoint state",
+        ));
+    }
+
+    let mut has_direct_closure = false;
+    for closure in template.closures.iter().copied() {
+        let input_states = template_catalog.u32_sequence(
+            closure.input_state_sequence_id,
+            "cyclic trace closure input states",
+        )?;
+        let coupling_order_set = template
+            .coupling_order_ranges
+            .get(closure.coupling_order_set_id as usize)
+            .ok_or_else(|| invalid("cyclic trace closure coupling-order set is absent"))?;
+        if input_states != [state_template_id, state_template_id]
+            || closure.result_state_template_id != MISSING_U32
+            || !template_catalog
+                .u32_sequence(
+                    closure.coupling_parameter_sequence_id,
+                    "cyclic trace closure coupling parameters",
+                )?
+                .is_empty()
+            || coupling_order_set.range.count != 0
+            || !template_catalog
+                .u32_sequence(
+                    closure.eligible_quantum_flow_sequence_id,
+                    "cyclic trace closure quantum flows",
+                )?
+                .is_empty()
+            || OutputFactorSource::try_from(closure.output_factor_source)?
+                != OutputFactorSource::None
+            || template_catalog.string(
+                closure.equivalence_class_string_id,
+                "cyclic trace closure equivalence class",
+            )? != "direct-contraction"
+        {
+            continue;
+        }
+        let evaluator = template
+            .evaluator_bindings
+            .get(closure.evaluator_binding_id as usize)
+            .copied()
+            .ok_or_else(|| invalid("cyclic trace closure evaluator is absent"))?;
+        if EvaluatorCallableKind::try_from(evaluator.callable_kind)?
+            != EvaluatorCallableKind::RusticolTemplate
+            || EvaluatorContractKind::try_from(evaluator.contract_kind)?
+                != EvaluatorContractKind::Closure
+        {
+            continue;
+        }
+        let color = template
+            .color_contractions
+            .get(closure.color_contraction_template_id as usize)
+            .copied()
+            .ok_or_else(|| invalid("cyclic trace closure color contract is absent"))?;
+        if template_catalog.i32_sequence(
+            color.input_representation_sequence_id,
+            "cyclic trace closure input representations",
+        )? == [8, 8]
+            && color.has_output_representation == 0
+        {
+            has_direct_closure = true;
+            break;
+        }
+    }
+    if !has_direct_closure {
+        return Err(invalid(
+            "cyclic trace closure anchoring requires an exact direct binary adjoint closure",
+        ));
+    }
+    Ok(())
+}
+
+/// Construction-only exact support identity.
+///
+/// Runtime and persisted current keys continue to carry canonical source-slot
+/// vectors. This sidecar uses one machine-friendly scalar for ordinary
+/// processes and falls back to an exact arbitrary-width bitset when required.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+enum TransientSupportKey {
+    Inline {
+        source_count: usize,
+        bits: u128,
+    },
+    Wide {
+        source_count: usize,
+        words: Box<[u64]>,
+    },
+}
+
+impl TransientSupportKey {
+    fn from_source_slots(source_count: usize, source_slots: &[u32]) -> RusticolResult<Self> {
+        if source_count <= u128::BITS as usize {
+            let mut bits = 0_u128;
+            for source_slot in source_slots.iter().copied() {
+                let source_slot = usize::try_from(source_slot)
+                    .map_err(|_| invalid("transient support source slot exceeds usize"))?;
+                if source_slot >= source_count {
+                    return Err(invalid(
+                        "transient support references an absent source slot",
+                    ));
+                }
+                let bit = 1_u128 << source_slot;
+                if bits & bit != 0 {
+                    return Err(invalid(
+                        "transient support contains a duplicate source slot",
+                    ));
+                }
+                bits |= bit;
+            }
+            let result = Self::Inline { source_count, bits };
+            result.validate()?;
+            return Ok(result);
+        }
+
+        let mut words = vec![0_u64; source_count.div_ceil(u64::BITS as usize)];
+        for source_slot in source_slots.iter().copied() {
+            let source_slot = usize::try_from(source_slot)
+                .map_err(|_| invalid("transient support source slot exceeds usize"))?;
+            if source_slot >= source_count {
+                return Err(invalid(
+                    "transient support references an absent source slot",
+                ));
+            }
+            let word = source_slot / u64::BITS as usize;
+            let bit = 1_u64 << (source_slot % u64::BITS as usize);
+            if words[word] & bit != 0 {
+                return Err(invalid(
+                    "transient support contains a duplicate source slot",
+                ));
+            }
+            words[word] |= bit;
+        }
+        let result = Self::Wide {
+            source_count,
+            words: words.into_boxed_slice(),
+        };
+        result.validate()?;
+        Ok(result)
+    }
+
+    fn full(source_count: usize) -> RusticolResult<Self> {
+        if source_count <= u128::BITS as usize {
+            let bits = match source_count {
+                0 => 0,
+                count if count == u128::BITS as usize => u128::MAX,
+                count => (1_u128 << count) - 1,
+            };
+            let result = Self::Inline { source_count, bits };
+            result.validate()?;
+            return Ok(result);
+        }
+        let mut words =
+            vec![u64::MAX; source_count.div_ceil(u64::BITS as usize)].into_boxed_slice();
+        let trailing_bits = source_count % u64::BITS as usize;
+        if trailing_bits != 0 {
+            *words
+                .last_mut()
+                .expect("non-inline support has at least three words") =
+                (1_u64 << trailing_bits) - 1;
+        }
+        let result = Self::Wide {
+            source_count,
+            words,
+        };
+        result.validate()?;
+        Ok(result)
+    }
+
+    fn singleton(source_count: usize, source_slot: u32) -> RusticolResult<Self> {
+        Self::from_source_slots(source_count, &[source_slot])
+    }
+
+    const fn source_count(&self) -> usize {
+        match self {
+            Self::Inline { source_count, .. } | Self::Wide { source_count, .. } => *source_count,
+        }
+    }
+
+    fn validate(&self) -> RusticolResult<()> {
+        match self {
+            Self::Inline { source_count, bits } => {
+                if *source_count > u128::BITS as usize {
+                    return Err(invalid(
+                        "inline transient support exceeds its source domain",
+                    ));
+                }
+                let domain_mask = match *source_count {
+                    0 => 0,
+                    count if count == u128::BITS as usize => u128::MAX,
+                    count => (1_u128 << count) - 1,
+                };
+                if bits & !domain_mask != 0 {
+                    return Err(invalid(
+                        "inline transient support has bits outside its source domain",
+                    ));
+                }
+            }
+            Self::Wide {
+                source_count,
+                words,
+            } => {
+                if *source_count <= u128::BITS as usize {
+                    return Err(invalid(
+                        "wide transient support does not require wide storage",
+                    ));
+                }
+                let expected_word_count = source_count.div_ceil(u64::BITS as usize);
+                if words.len() != expected_word_count {
+                    return Err(invalid(
+                        "wide transient support word count disagrees with its source domain",
+                    ));
+                }
+                let trailing_bits = source_count % u64::BITS as usize;
+                if trailing_bits != 0 {
+                    let domain_mask = (1_u64 << trailing_bits) - 1;
+                    if words
+                        .last()
+                        .is_some_and(|last_word| last_word & !domain_mask != 0)
+                    {
+                        return Err(invalid(
+                            "wide transient support has padding bits outside its source domain",
+                        ));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn without_source_slot(&self, source_slot: u32) -> RusticolResult<Self> {
+        self.validate()?;
+        let source_slot = usize::try_from(source_slot)
+            .map_err(|_| invalid("transient support source slot exceeds usize"))?;
+        if source_slot >= self.source_count() {
+            return Err(invalid(
+                "transient support references an absent source slot",
+            ));
+        }
+        match self {
+            Self::Inline { source_count, bits } => Ok(Self::Inline {
+                source_count: *source_count,
+                bits: bits & !(1_u128 << source_slot),
+            }),
+            Self::Wide {
+                source_count,
+                words,
+            } => {
+                let word = source_slot / u64::BITS as usize;
+                let mut result = words.clone();
+                result[word] &= !(1_u64 << (source_slot % u64::BITS as usize));
+                Ok(Self::Wide {
+                    source_count: *source_count,
+                    words: result,
+                })
+            }
+        }
+    }
+
+    fn cardinality(&self) -> usize {
+        match self {
+            Self::Inline { bits, .. } => bits.count_ones() as usize,
+            Self::Wide { words, .. } => words.iter().map(|word| word.count_ones() as usize).sum(),
+        }
+    }
+
+    fn is_disjoint(&self, other: &Self) -> RusticolResult<bool> {
+        self.validate()?;
+        other.validate()?;
+        if self.source_count() != other.source_count() {
+            return Err(invalid(
+                "transient support keys use inconsistent source domains",
+            ));
+        }
+        match (self, other) {
+            (Self::Inline { bits: left, .. }, Self::Inline { bits: right, .. }) => {
+                Ok(left & right == 0)
+            }
+            (Self::Wide { words: left, .. }, Self::Wide { words: right, .. }) => Ok(left.len()
+                == right.len()
+                && left
+                    .iter()
+                    .zip(right.iter())
+                    .all(|(left, right)| left & right == 0)),
+            _ => Err(invalid(
+                "transient support representations disagree for one source domain",
+            )),
+        }
+    }
+
+    fn union_disjoint(&self, other: &Self) -> RusticolResult<Self> {
+        if !self.is_disjoint(other)? {
+            return Err(invalid(
+                "recurrence parents have overlapping source support",
+            ));
+        }
+        let result = match (self, other) {
+            (
+                Self::Inline {
+                    source_count,
+                    bits: left,
+                },
+                Self::Inline { bits: right, .. },
+            ) => Self::Inline {
+                source_count: *source_count,
+                bits: left | right,
+            },
+            (
+                Self::Wide {
+                    source_count,
+                    words: left,
+                },
+                Self::Wide { words: right, .. },
+            ) => Self::Wide {
+                source_count: *source_count,
+                words: left
+                    .iter()
+                    .zip(right.iter())
+                    .map(|(left, right)| left | right)
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice(),
+            },
+            _ => Err(invalid(
+                "transient support representations use inconsistent source domains",
+            ))?,
+        };
+        result.validate()?;
+        Ok(result)
+    }
+
+    #[cfg(test)]
+    fn source_slots(&self) -> Vec<u32> {
+        match self {
+            Self::Inline { source_count, bits } => (0..*source_count)
+                .filter(|slot| bits & (1_u128 << slot) != 0)
+                .map(|slot| u32::try_from(slot).expect("test support source slot fits u32"))
+                .collect(),
+            Self::Wide {
+                source_count,
+                words,
+            } => words
+                .iter()
+                .copied()
+                .enumerate()
+                .flat_map(|(word_index, word)| {
+                    (0..u64::BITS).filter_map(move |bit_index| {
+                        let source_slot = word_index * u64::BITS as usize + bit_index as usize;
+                        (source_slot < *source_count && word & (1_u64 << bit_index) != 0).then_some(
+                            u32::try_from(source_slot).expect("test support source slot fits u32"),
+                        )
+                    })
+                })
+                .collect(),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct TransientCurrentSupportKeys {
+    source_count: usize,
+    keys_by_current: Vec<TransientSupportKey>,
+}
+
+impl TransientCurrentSupportKeys {
+    fn from_currents(source_count: usize, currents: &[PendingCurrent]) -> RusticolResult<Self> {
+        let keys_by_current = currents
+            .iter()
+            .map(|current| {
+                TransientSupportKey::from_source_slots(
+                    source_count,
+                    current.key.support_source_slots(),
+                )
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        Ok(Self {
+            source_count,
+            keys_by_current,
+        })
+    }
+
+    fn get(&self, current_id: u32) -> RusticolResult<&TransientSupportKey> {
+        self.keys_by_current
+            .get(current_id as usize)
+            .ok_or_else(|| invalid("transient current support key is absent"))
+    }
+
+    fn push(&mut self, current_id: u32, support_key: TransientSupportKey) -> RusticolResult<()> {
+        if current_id as usize != self.keys_by_current.len() {
+            return Err(invalid(
+                "transient current support keys are not dense by current ID",
+            ));
+        }
+        self.keys_by_current.push(support_key);
+        Ok(())
+    }
+
+    fn reconcile_stage_tail(
+        &mut self,
+        stage_start: usize,
+        currents: &[PendingCurrent],
+    ) -> RusticolResult<()> {
+        if stage_start > currents.len() || stage_start > self.keys_by_current.len() {
+            return Err(invalid(
+                "transient current support reconciliation has an invalid stage boundary",
+            ));
+        }
+        self.keys_by_current.truncate(stage_start);
+        for current in &currents[stage_start..] {
+            self.keys_by_current
+                .push(TransientSupportKey::from_source_slots(
+                    self.source_count,
+                    current.key.support_source_slots(),
+                )?);
+        }
+        if self.keys_by_current.len() != currents.len() {
+            return Err(invalid(
+                "transient current support reconciliation is not dense",
+            ));
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct StructuralState {
+    state_template_id: u32,
+    spin_state_class: i32,
+}
+
+impl StructuralState {
+    const fn new(state_template_id: u32, spin_state_class: i32) -> Self {
+        Self {
+            state_template_id,
+            spin_state_class,
+        }
+    }
+
+    fn from_current(current: &PendingCurrent) -> Self {
+        Self::new(
+            current.key.current_state_template_id(),
+            current.key.spin_state_class(),
+        )
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct StructuralTransition {
+    parents: [StructuralState; 2],
+    result: StructuralState,
+}
+
+fn structural_state_matches(required: StructuralState, actual: StructuralState) -> bool {
+    required.state_template_id == actual.state_template_id
+        && (required.spin_state_class == actual.spin_state_class
+            || actual.spin_state_class == DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS)
+}
+
+fn structural_parent_states_match(
+    required: [StructuralState; 2],
+    actual: [StructuralState; 2],
+) -> bool {
+    structural_state_matches(required[0], actual[0])
+        && structural_state_matches(required[1], actual[1])
+}
+
+/// Allocation-heavy reference implementation retained for exact-equivalence
+/// tests of the split production indexes below.
+#[cfg(test)]
+#[derive(Debug)]
+struct LazyStructuralDemandIndex {
+    demanded: BTreeSet<(Vec<u32>, StructuralState)>,
+}
+
+#[cfg(test)]
+impl LazyStructuralDemandIndex {
+    fn new(
+        process: &OwnedRecurrenceProcessInput,
+        template: &OwnedRecurrenceTemplateInput,
+        catalog: &TemplateCatalog<'_>,
+        prepared_transitions: &PreparedTransitionCatalog,
+        materialized_sectors: &BTreeSet<u32>,
+        source_currents: &[PendingCurrent],
+    ) -> RusticolResult<Self> {
+        let transitions = prepared_transitions.structural_transitions();
+        let mut feasible = BTreeMap::<Vec<u32>, BTreeSet<StructuralState>>::new();
+        for current in source_currents
+            .iter()
+            .filter(|current| current.key.node_kind() == RecurrenceNodeKind::Source)
+        {
+            feasible
+                .entry(current.key.support_source_slots().to_vec())
+                .or_default()
+                .insert(StructuralState::from_current(current));
+        }
+        if feasible.is_empty() {
+            return Err(invalid(
+                "recurrence structural-demand construction has no source states",
+            ));
+        }
+
+        let source_count = process.external_legs.len();
+        for target_size in 2..source_count {
+            let prior = feasible
+                .iter()
+                .filter(|(support, _)| support.len() < target_size)
+                .map(|(support, states)| {
+                    (support.clone(), states.iter().copied().collect::<Vec<_>>())
+                })
+                .collect::<Vec<_>>();
+            let mut additions = BTreeMap::<Vec<u32>, BTreeSet<StructuralState>>::new();
+            for left_index in 0..prior.len() {
+                for right_index in left_index + 1..prior.len() {
+                    let (left_support, left_states) = &prior[left_index];
+                    let (right_support, right_states) = &prior[right_index];
+                    if left_support.len() + right_support.len() != target_size
+                        || !disjoint_support(left_support, right_support)
+                    {
+                        continue;
+                    }
+                    let support = merged_support(left_support, right_support)?;
+                    for left in left_states.iter().copied() {
+                        for right in right_states.iter().copied() {
+                            for transition in transitions {
+                                if structural_parent_states_match(transition.parents, [left, right])
+                                    || structural_parent_states_match(
+                                        transition.parents,
+                                        [right, left],
+                                    )
+                                {
+                                    additions
+                                        .entry(support.clone())
+                                        .or_default()
+                                        .insert(transition.result);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            for (support, states) in additions {
+                feasible.entry(support).or_default().extend(states);
+            }
+        }
+
+        let full_support = (0..source_count as u32).collect::<Vec<_>>();
+        let mut demanded = BTreeSet::<(Vec<u32>, StructuralState)>::new();
+        for sector_id in materialized_sectors.iter().copied() {
+            let sector = process
+                .physical_lc_sectors
+                .get(sector_id as usize)
+                .copied()
+                .ok_or_else(|| invalid("structural-demand LC sector is absent"))?;
+            let anchor_support = vec![sector.closure_source_slot];
+            let complement_support = full_support
+                .iter()
+                .copied()
+                .filter(|slot| *slot != sector.closure_source_slot)
+                .collect::<Vec<_>>();
+            let anchor_states = feasible
+                .get(&anchor_support)
+                .ok_or_else(|| invalid("structural-demand closure anchor is infeasible"))?;
+            let complement_states = feasible
+                .get(&complement_support)
+                .ok_or_else(|| invalid("structural-demand closure complement is infeasible"))?;
+            let mut sector_has_root = false;
+            for anchor in anchor_states.iter().copied() {
+                for complement in complement_states.iter().copied() {
+                    for closure in &template.closures {
+                        let closure_states = catalog.u32_sequence(
+                            closure.input_state_sequence_id,
+                            "structural-demand closure input states",
+                        )?;
+                        if closure_states.len() != 2 {
+                            return Err(invalid(
+                                "direct recurrence requires binary prepared closures",
+                            ));
+                        }
+                        let ordered = if closure_states
+                            == [complement.state_template_id, anchor.state_template_id]
+                        {
+                            Some([complement, anchor])
+                        } else if closure_states
+                            == [anchor.state_template_id, complement.state_template_id]
+                            && anchor.state_template_id != complement.state_template_id
+                        {
+                            Some([anchor, complement])
+                        } else {
+                            None
+                        };
+                        let Some(ordered) = ordered else {
+                            continue;
+                        };
+                        if structural_closure_admits(*closure, ordered, template, catalog)? {
+                            demanded.insert((complement_support.clone(), complement));
+                            sector_has_root = true;
+                        }
+                    }
+                }
+            }
+            if !sector_has_root {
+                return Err(invalid(format!(
+                    "recurrence structural-demand grammar found no closure root for LC sector {sector_id}"
+                )));
+            }
+        }
+
+        for target_size in (2..source_count).rev() {
+            let targets = demanded
+                .iter()
+                .filter(|(support, _)| support.len() == target_size)
+                .cloned()
+                .collect::<Vec<_>>();
+            for (target_support, target_state) in targets {
+                let feasible_rows = feasible.iter().collect::<Vec<_>>();
+                for left_index in 0..feasible_rows.len() {
+                    for right_index in left_index + 1..feasible_rows.len() {
+                        let (left_support, left_states) = feasible_rows[left_index];
+                        let (right_support, right_states) = feasible_rows[right_index];
+                        if left_support.len() + right_support.len() != target_size
+                            || !disjoint_support(left_support, right_support)
+                            || merged_support(left_support, right_support)? != target_support
+                        {
+                            continue;
+                        }
+                        for left in left_states.iter().copied() {
+                            for right in right_states.iter().copied() {
+                                for transition in transitions
+                                    .iter()
+                                    .filter(|transition| transition.result == target_state)
+                                {
+                                    if structural_parent_states_match(
+                                        transition.parents,
+                                        [left, right],
+                                    ) || structural_parent_states_match(
+                                        transition.parents,
+                                        [right, left],
+                                    ) {
+                                        demanded.insert((left_support.clone(), left));
+                                        demanded.insert((right_support.clone(), right));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(Self { demanded })
+    }
+
+    fn accepts(
+        &self,
+        support_source_slots: &[u32],
+        state_template_id: u32,
+        spin_state_class: i32,
+    ) -> bool {
+        self.demanded.contains(&(
+            support_source_slots.to_vec(),
+            StructuralState::new(state_template_id, spin_state_class),
+        ))
+    }
+}
+
+/// Process-global forward state/spin grammar.
+///
+/// This half is independent of the materialized color lane. It is built once
+/// from source states and the prepared transition catalog, then shared by all
+/// lane-specific backward-demand passes. Together those passes form a
+/// conservative exact filter: color, coupling, flavour, pairing, and proof
+/// contracts remain authenticated by normal construction, while a full
+/// current is never interned for a state/spin branch that cannot close.
+#[derive(Debug)]
+struct StructuralFeasibilityIndex {
+    source_count: usize,
+    feasible: BTreeMap<TransientSupportKey, BTreeSet<StructuralState>>,
+    decompositions: BTreeMap<TransientSupportKey, Vec<[TransientSupportKey; 2]>>,
+    forward_transition_probe_count: usize,
+}
+
+impl StructuralFeasibilityIndex {
+    fn new(
+        source_count: usize,
+        prepared_transitions: &PreparedTransitionCatalog,
+        source_currents: &[PendingCurrent],
+    ) -> RusticolResult<Self> {
+        let transitions = prepared_transitions.structural_transitions();
+        let mut feasible = BTreeMap::<TransientSupportKey, BTreeSet<StructuralState>>::new();
+        for current in source_currents
+            .iter()
+            .filter(|current| current.key.node_kind() == RecurrenceNodeKind::Source)
+        {
+            feasible
+                .entry(TransientSupportKey::from_source_slots(
+                    source_count,
+                    current.key.support_source_slots(),
+                )?)
+                .or_default()
+                .insert(StructuralState::from_current(current));
+        }
+        if feasible.is_empty() {
+            return Err(invalid(
+                "recurrence structural-demand construction has no source states",
+            ));
+        }
+
+        let mut decompositions =
+            BTreeMap::<TransientSupportKey, Vec<[TransientSupportKey; 2]>>::new();
+        let mut forward_transition_probe_count = 0usize;
+        for target_size in 2..source_count {
+            let prior = feasible
+                .iter()
+                .filter(|(support, _)| support.cardinality() < target_size)
+                .map(|(support, states)| {
+                    (support.clone(), states.iter().copied().collect::<Vec<_>>())
+                })
+                .collect::<Vec<_>>();
+            let mut additions = BTreeMap::<TransientSupportKey, BTreeSet<StructuralState>>::new();
+            for left_index in 0..prior.len() {
+                for right_index in left_index + 1..prior.len() {
+                    let (left_support, left_states) = &prior[left_index];
+                    let (right_support, right_states) = &prior[right_index];
+                    if left_support.cardinality() + right_support.cardinality() != target_size
+                        || !left_support.is_disjoint(right_support)?
+                    {
+                        continue;
+                    }
+                    let support = left_support.union_disjoint(right_support)?;
+                    decompositions
+                        .entry(support.clone())
+                        .or_default()
+                        .push([left_support.clone(), right_support.clone()]);
+                    for left in left_states.iter().copied() {
+                        for right in right_states.iter().copied() {
+                            for transition in transitions {
+                                forward_transition_probe_count =
+                                    forward_transition_probe_count.checked_add(1).ok_or_else(
+                                        || {
+                                            invalid(
+                                                "structural forward transition-probe count exceeds usize",
+                                            )
+                                        },
+                                    )?;
+                                if structural_parent_states_match(transition.parents, [left, right])
+                                    || structural_parent_states_match(
+                                        transition.parents,
+                                        [right, left],
+                                    )
+                                {
+                                    additions
+                                        .entry(support.clone())
+                                        .or_default()
+                                        .insert(transition.result);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            for (support, states) in additions {
+                feasible.entry(support).or_default().extend(states);
+            }
+        }
+
+        let result = Self {
+            source_count,
+            feasible,
+            decompositions,
+            forward_transition_probe_count,
+        };
+        debug_assert_eq!(result.feasible_support_count(), result.feasible.len());
+        debug_assert_eq!(
+            result.decomposition_count(),
+            result.decompositions.values().map(Vec::len).sum::<usize>()
+        );
+        debug_assert_eq!(
+            result.forward_transition_probe_count(),
+            forward_transition_probe_count
+        );
+        Ok(result)
+    }
+
+    fn feasible_states(&self, support: &TransientSupportKey) -> Option<&BTreeSet<StructuralState>> {
+        self.feasible.get(support)
+    }
+
+    fn decompositions(&self, support: &TransientSupportKey) -> &[[TransientSupportKey; 2]] {
+        self.decompositions
+            .get(support)
+            .map(Vec::as_slice)
+            .unwrap_or_default()
+    }
+
+    fn feasible_support_count(&self) -> usize {
+        self.feasible.len()
+    }
+
+    fn decomposition_count(&self) -> usize {
+        self.decompositions.values().map(Vec::len).sum()
+    }
+
+    fn forward_transition_probe_count(&self) -> usize {
+        self.forward_transition_probe_count
+    }
+}
+
+#[derive(Debug)]
+struct StructuralDemandIndex {
+    demanded: BTreeMap<TransientSupportKey, BTreeSet<StructuralState>>,
+}
+
+impl StructuralDemandIndex {
+    fn new(
+        process: &OwnedRecurrenceProcessInput,
+        template: &OwnedRecurrenceTemplateInput,
+        catalog: &TemplateCatalog<'_>,
+        prepared_transitions: &PreparedTransitionCatalog,
+        feasibility: &StructuralFeasibilityIndex,
+        materialized_sectors: &BTreeSet<u32>,
+    ) -> RusticolResult<Self> {
+        if process.external_legs.len() != feasibility.source_count {
+            return Err(invalid(
+                "structural-demand source domain disagrees with forward feasibility",
+            ));
+        }
+        let transitions = prepared_transitions.structural_transitions();
+        let full_support = TransientSupportKey::full(feasibility.source_count)?;
+        let mut demanded = BTreeMap::<TransientSupportKey, BTreeSet<StructuralState>>::new();
+        for sector_id in materialized_sectors.iter().copied() {
+            let sector = process
+                .physical_lc_sectors
+                .get(sector_id as usize)
+                .copied()
+                .ok_or_else(|| invalid("structural-demand LC sector is absent"))?;
+            let anchor_support = TransientSupportKey::singleton(
+                feasibility.source_count,
+                sector.closure_source_slot,
+            )?;
+            let complement_support =
+                full_support.without_source_slot(sector.closure_source_slot)?;
+            let anchor_states = feasibility
+                .feasible_states(&anchor_support)
+                .ok_or_else(|| invalid("structural-demand closure anchor is infeasible"))?;
+            let complement_states = feasibility
+                .feasible_states(&complement_support)
+                .ok_or_else(|| invalid("structural-demand closure complement is infeasible"))?;
+            let mut sector_has_root = false;
+            for anchor in anchor_states.iter().copied() {
+                for complement in complement_states.iter().copied() {
+                    for closure in &template.closures {
+                        let closure_states = catalog.u32_sequence(
+                            closure.input_state_sequence_id,
+                            "structural-demand closure input states",
+                        )?;
+                        if closure_states.len() != 2 {
+                            return Err(invalid(
+                                "direct recurrence requires binary prepared closures",
+                            ));
+                        }
+                        let ordered = if closure_states
+                            == [complement.state_template_id, anchor.state_template_id]
+                        {
+                            Some([complement, anchor])
+                        } else if closure_states
+                            == [anchor.state_template_id, complement.state_template_id]
+                            && anchor.state_template_id != complement.state_template_id
+                        {
+                            Some([anchor, complement])
+                        } else {
+                            None
+                        };
+                        let Some(ordered) = ordered else {
+                            continue;
+                        };
+                        if structural_closure_admits(*closure, ordered, template, catalog)? {
+                            demanded
+                                .entry(complement_support.clone())
+                                .or_default()
+                                .insert(complement);
+                            sector_has_root = true;
+                        }
+                    }
+                }
+            }
+            if !sector_has_root {
+                return Err(invalid(format!(
+                    "recurrence structural-demand grammar found no closure root for LC sector {sector_id}"
+                )));
+            }
+        }
+
+        for target_size in (2..feasibility.source_count).rev() {
+            let targets = demanded
+                .iter()
+                .filter(|(support, _)| support.cardinality() == target_size)
+                .flat_map(|(support, states)| {
+                    states.iter().copied().map(|state| (support.clone(), state))
+                })
+                .collect::<Vec<_>>();
+            for (target_support, target_state) in targets {
+                for [left_support, right_support] in feasibility.decompositions(&target_support) {
+                    let left_states = feasibility
+                        .feasible_states(left_support)
+                        .expect("forward decomposition left support is feasible");
+                    let right_states = feasibility
+                        .feasible_states(right_support)
+                        .expect("forward decomposition right support is feasible");
+                    for left in left_states.iter().copied() {
+                        for right in right_states.iter().copied() {
+                            for transition in transitions
+                                .iter()
+                                .filter(|transition| transition.result == target_state)
+                            {
+                                if structural_parent_states_match(transition.parents, [left, right])
+                                    || structural_parent_states_match(
+                                        transition.parents,
+                                        [right, left],
+                                    )
+                                {
+                                    demanded
+                                        .entry(left_support.clone())
+                                        .or_default()
+                                        .insert(left);
+                                    demanded
+                                        .entry(right_support.clone())
+                                        .or_default()
+                                        .insert(right);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(Self { demanded })
+    }
+
+    fn accepts(
+        &self,
+        support: &TransientSupportKey,
+        state_template_id: u32,
+        spin_state_class: i32,
+    ) -> bool {
+        self.demanded.get(support).is_some_and(|states| {
+            states.contains(&StructuralState::new(state_template_id, spin_state_class))
+        })
+    }
+
+    fn demanded_support_count(&self) -> usize {
+        self.demanded.len()
+    }
+
+    fn demanded_state_count(&self) -> usize {
+        self.demanded.values().map(BTreeSet::len).sum()
+    }
+
+    #[cfg(test)]
+    fn demanded_rows(&self) -> BTreeSet<(Vec<u32>, StructuralState)> {
+        self.demanded
+            .iter()
+            .flat_map(|(support, states)| {
+                states
+                    .iter()
+                    .copied()
+                    .map(|state| (support.source_slots(), state))
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+fn structural_transitions(
+    template: &OwnedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<Vec<StructuralTransition>> {
+    let transitions = template
+        .transitions
+        .iter()
+        .map(|transition| {
+            let quantum = template
+                .quantum_flows
+                .get(transition.quantum_flow_template_id as usize)
+                .copied()
+                .ok_or_else(|| invalid("structural-demand quantum flow is absent"))?;
+            let states =
+                catalog.u32_sequence(quantum.input_state_sequence_id, "quantum input states")?;
+            let spins =
+                catalog.i32_sequence(quantum.input_spin_sequence_id, "quantum input spins")?;
+            if states.len() != 2 || spins.len() != 2 {
+                return Err(invalid(
+                    "direct recurrence requires binary quantum-flow contracts",
+                ));
+            }
+            if quantum.result_state_template_id != transition.result_state_template_id {
+                return Err(invalid(
+                    "structural-demand transition and quantum-flow result states differ",
+                ));
+            }
+            Ok(StructuralTransition {
+                parents: [
+                    StructuralState::new(states[0], spins[0]),
+                    StructuralState::new(states[1], spins[1]),
+                ],
+                result: StructuralState::new(
+                    quantum.result_state_template_id,
+                    quantum.result_spin_state,
+                ),
+            })
+        })
+        .collect::<RusticolResult<BTreeSet<_>>>()?;
+    Ok(transitions.into_iter().collect())
+}
+
+fn structural_closure_admits(
+    closure: ClosureRow,
+    ordered_parents: [StructuralState; 2],
+    template: &OwnedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<bool> {
+    let eligible = catalog.u32_sequence(
+        closure.eligible_quantum_flow_sequence_id,
+        "structural-demand closure quantum flows",
+    )?;
+    if eligible.is_empty() {
+        return Ok(true);
+    }
+    for quantum_id in eligible {
+        let quantum = template
+            .quantum_flows
+            .get(*quantum_id as usize)
+            .copied()
+            .ok_or_else(|| invalid("structural-demand closure quantum flow is absent"))?;
+        let states =
+            catalog.u32_sequence(quantum.input_state_sequence_id, "quantum input states")?;
+        let spins = catalog.i32_sequence(quantum.input_spin_sequence_id, "quantum input spins")?;
+        if states.len() != 2 || spins.len() != 2 {
+            return Err(invalid(
+                "direct recurrence requires binary quantum-flow contracts",
+            ));
+        }
+        if structural_parent_states_match(
+            [
+                StructuralState::new(states[0], spins[0]),
+                StructuralState::new(states[1], spins[1]),
+            ],
+            ordered_parents,
+        ) {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
+fn compatible_pairing_rules_for_current(
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+    template: &OwnedRecurrenceTemplateInput,
+    current_state_template_id: u32,
+    support_source_slots: &[u32],
+) -> RusticolResult<BTreeSet<u32>> {
+    let Some(pairing_catalog) = pairing_catalog else {
+        return Ok(BTreeSet::new());
+    };
+    let state = template
+        .current_states
+        .get(current_state_template_id as usize)
+        .ok_or_else(|| invalid("pairing support references an absent current state"))?;
+    let carries_colored_fermion_line = state.statistics == 1 && state.color_representation != 1;
+    let support = support_source_slots
+        .iter()
+        .copied()
+        .collect::<BTreeSet<_>>();
+    let mut result = BTreeSet::new();
+    for rule in pairing_catalog.rules().iter().copied() {
+        let crossing_count = pairing_catalog
+            .endpoint_pairings(rule)?
+            .iter()
+            .filter(|pair| {
+                support.contains(&pair.fundamental_source_slot)
+                    != support.contains(&pair.antifundamental_source_slot)
+            })
+            .count();
+        let compatible = if carries_colored_fermion_line {
+            crossing_count == 1
+        } else {
+            crossing_count == 0
+        };
+        if compatible {
+            result.insert(rule.rule_id);
+        }
+    }
+    Ok(result)
+}
+
+fn realized_pairing_rules_for_transition(
+    compatible_result_rules: BTreeSet<u32>,
+    parent_rules: [&BTreeSet<u32>; 2],
+) -> BTreeSet<u32> {
+    compatible_result_rules
+        .into_iter()
+        .filter(|rule_id| parent_rules[0].contains(rule_id) && parent_rules[1].contains(rule_id))
+        .collect()
+}
+
+pub(super) fn build_recurrence_program(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+) -> RusticolResult<RecurrenceProgram> {
+    build_recurrence_program_impl(authenticated, &mut |_| Ok(()), false).map(|(program, _)| program)
+}
+
+pub(super) fn build_recurrence_program_with_progress(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    progress: &mut dyn FnMut(RecurrenceBuildProgress) -> RusticolResult<()>,
+) -> RusticolResult<RecurrenceProgram> {
+    build_recurrence_program_impl(authenticated, progress, false).map(|(program, _)| program)
+}
+
+pub(super) fn build_recurrence_program_with_progress_and_telemetry(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    progress: &mut dyn FnMut(RecurrenceBuildProgress) -> RusticolResult<()>,
+) -> RusticolResult<(RecurrenceProgram, RecurrenceGenerationTelemetry)> {
+    build_recurrence_program_impl(authenticated, progress, true)
+}
+
+fn established_fermion_ordering_context(
+    process: &OwnedRecurrenceProcessInput,
+    template: &OwnedRecurrenceTemplateInput,
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+) -> RusticolResult<FermionOrderingContext> {
+    let mut authenticated_colored_endpoints = vec![false; process.external_legs.len()];
+    if let Some(pairing_catalog) = pairing_catalog {
+        for endpoint in pairing_catalog.endpoints().iter().copied() {
+            let selected = authenticated_colored_endpoints
+                .get_mut(endpoint.source_slot as usize)
+                .ok_or_else(|| invalid("fermion-ordering endpoint source slot is absent"))?;
+            if *selected {
+                return Err(invalid(
+                    "fermion-ordering endpoint source slot is authenticated twice",
+                ));
+            }
+            *selected = true;
+        }
+    }
+
+    let mut source_requires_exterior_sign = Vec::with_capacity(process.external_legs.len());
+    for (source_slot, leg) in process.external_legs.iter().copied().enumerate() {
+        let source_slot = u32::try_from(source_slot)
+            .map_err(|_| invalid("fermion-ordering source slot exceeds u32"))?;
+        if leg.source_slot != source_slot {
+            return Err(invalid(
+                "fermion-ordering source slot disagrees with the process table",
+            ));
+        }
+        let state_range = leg.source_state_range.as_usize_range(
+            process.source_states.len(),
+            "fermion-ordering source-state range",
+        )?;
+        let color_representations = process.source_states[state_range]
+            .iter()
+            .map(|source_state| {
+                if source_state.source_slot != source_slot {
+                    return Err(invalid(
+                        "fermion-ordering source state belongs to a different source slot",
+                    ));
+                }
+                template
+                    .current_states
+                    .get(source_state.current_state_template_id as usize)
+                    .map(|state| state.color_representation)
+                    .ok_or_else(|| {
+                        invalid("fermion-ordering source current state is absent from the template")
+                    })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        source_requires_exterior_sign.push(authenticated_source_requires_exterior_sign(
+            leg.is_fermionic == 1,
+            authenticated_colored_endpoints[source_slot as usize],
+            color_representations,
+        )?);
+    }
+    Ok(FermionOrderingContext::new(source_requires_exterior_sign))
+}
+
+fn build_recurrence_program_impl(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    progress: &mut dyn FnMut(RecurrenceBuildProgress) -> RusticolResult<()>,
+    collect_telemetry: bool,
+) -> RusticolResult<(RecurrenceProgram, RecurrenceGenerationTelemetry)> {
+    #[cfg(feature = "on-the-fly-test-support")]
+    super::on_the_fly::reject_forbidden_work_if_probed(
+        super::on_the_fly::OnTheFlyForbiddenWorkV1::EstablishedBuilder,
+    )?;
+    let mut telemetry = RecurrenceGenerationTelemetry::default();
+    let strategy = authenticated.process().summary().strategy();
+    let catalog_digest = authenticated.template().summary().catalog_digest;
+    let process_input = authenticated.process().input();
+    let pairing_catalog = authenticated.process().fermion_pairing_catalog();
+    let template_input = authenticated.template().input();
+    let fermion_ordering =
+        established_fermion_ordering_context(process_input, template_input, pairing_catalog)?;
+    let process_catalog = ProcessCatalog::new(process_input)?;
+    let helicity_support_rule = helicity_support_rule(authenticated)?;
+    let global_helicity_flip_rule = global_helicity_flip_rule(authenticated)?;
+    let retained_helicity_count = retained_helicity_count(process_input)?;
+    let template_catalog = TemplateCatalog::new(template_input)?;
+    validate_cyclic_trace_closure_anchor_contracts(
+        process_input,
+        &process_catalog,
+        template_input,
+        &template_catalog,
+    )?;
+    let coupling_limits = coupling_limits(&process_catalog, &template_catalog)?;
+    let propagators = propagator_by_state(template_input)?;
+    let transition_reflections = TransitionReflectionIndex::new(template_input, &template_catalog)?;
+    let replay_targets = build_replay_targets(strategy, process_input, &process_catalog)?;
+    let materialized_sectors = materialized_sector_ids(strategy, process_input, &replay_targets);
+    let mut color_states = DynamicLCColorStateInterner::default();
+    let mut currents = Vec::<PendingCurrent>::new();
+    let mut current_ids = TransientCurrentIdIndex::new();
+    let mut currents_by_size = vec![Vec::<u32>::new(); process_input.external_legs.len()];
+    let mut reflection_certificates = Vec::<PendingReflectionCertificate>::new();
+
+    build_sources(
+        strategy,
+        catalog_digest,
+        process_input,
+        &process_catalog,
+        pairing_catalog,
+        template_input,
+        &template_catalog,
+        &mut color_states,
+        &mut currents,
+        &mut current_ids,
+        &mut currents_by_size,
+    )?;
+    let stage_count_per_lane = process_input.external_legs.len().saturating_sub(2);
+    let construction_sector_groups =
+        construction_sector_groups(strategy, &materialized_sectors, &replay_targets);
+    let stage_total = stage_count_per_lane
+        .checked_mul(construction_sector_groups.len())
+        .ok_or_else(|| invalid("recurrence construction stage count exceeds usize"))?;
+    let phase_total = stage_total.saturating_add(3);
+    progress(RecurrenceBuildProgress::snapshot(
+        "source construction",
+        1,
+        phase_total,
+        None,
+        stage_total,
+        Some(1),
+        0,
+        None,
+        currents.len(),
+        0,
+        color_states.len(),
+        0,
+    ))?;
+    let transition_catalog_started = telemetry_timer(collect_telemetry);
+    let prepared_transitions = PreparedTransitionCatalog::new(template_input, &template_catalog)?;
+    let prepared_closures = PreparedClosureCatalog::new(template_input, &template_catalog)?;
+    let prepared_closure_sectors = PreparedClosureSectorCatalog::new(
+        strategy,
+        process_input,
+        &process_catalog,
+        &materialized_sectors,
+    )?;
+    add_optional_elapsed_nanoseconds(
+        &mut telemetry.transition_catalog_nanoseconds,
+        transition_catalog_started,
+    );
+    let source_current_count = currents.len();
+    let structural_feasibility_started = telemetry_timer(collect_telemetry);
+    let structural_feasibility = StructuralFeasibilityIndex::new(
+        process_input.external_legs.len(),
+        &prepared_transitions,
+        &currents[..source_current_count],
+    )?;
+    add_optional_elapsed_nanoseconds(
+        &mut telemetry.structural_feasibility_nanoseconds,
+        structural_feasibility_started,
+    );
+    if collect_telemetry {
+        telemetry.structural_feasible_support_count =
+            structural_feasibility.feasible_support_count();
+        telemetry.structural_decomposition_count = structural_feasibility.decomposition_count();
+        telemetry.structural_forward_transition_probe_count =
+            structural_feasibility.forward_transition_probe_count();
+    }
+    let mut current_support_keys =
+        TransientCurrentSupportKeys::from_currents(process_input.external_legs.len(), &currents)?;
+    let source_current_ids = current_ids;
+    let source_bucket = currents_by_size
+        .first()
+        .cloned()
+        .ok_or_else(|| invalid("recurrence construction has no source bucket"))?;
+    let isolate_replay_lanes = construction_sector_groups.len() > 1;
+    let mut resident_contribution_count = 0usize;
+    let mut stage_diagnostics = Vec::new();
+    let mut closures = BTreeMap::new();
+    let mut exhaustive_closure_sector_ids = BTreeSet::new();
+    let mut exhaustive_closure_sector_owner_ids = BTreeMap::new();
+    for (lane_index, construction_sectors) in construction_sector_groups.into_iter().enumerate() {
+        let stage_index_offset = lane_index
+            .checked_mul(stage_count_per_lane)
+            .ok_or_else(|| invalid("recurrence construction stage offset exceeds usize"))?;
+        let color_target_index_started = telemetry_timer(collect_telemetry);
+        let color_targets = MaterializedColorTargets::new_with_prepared_sectors(
+            &construction_sectors,
+            &prepared_closure_sectors,
+            collect_telemetry,
+        )?;
+        add_optional_elapsed_nanoseconds(
+            &mut telemetry.color_target_index_nanoseconds,
+            color_target_index_started,
+        );
+        let structural_demand_started = telemetry_timer(collect_telemetry);
+        let structural_demands = StructuralDemandIndex::new(
+            process_input,
+            template_input,
+            &template_catalog,
+            &prepared_transitions,
+            &structural_feasibility,
+            &construction_sectors,
+        )?;
+        add_optional_elapsed_nanoseconds(
+            &mut telemetry.structural_demand_nanoseconds,
+            structural_demand_started,
+        );
+        if collect_telemetry {
+            checked_diagnostic_add(
+                &mut telemetry.structural_demand_support_count,
+                structural_demands.demanded_support_count(),
+                "telemetry structural-demand support count",
+            )?;
+            checked_diagnostic_add(
+                &mut telemetry.structural_demand_state_count,
+                structural_demands.demanded_state_count(),
+                "telemetry structural-demand state count",
+            )?;
+        }
+        let mut lane_current_ids = source_current_ids.clone();
+        let mut lane_currents_by_size = vec![Vec::<u32>::new(); process_input.external_legs.len()];
+        lane_currents_by_size[0] = source_bucket.clone();
+        let lane_internal_start = currents.len();
+        let mut build_lane = || {
+            build_internal_currents(
+                catalog_digest,
+                process_input,
+                pairing_catalog,
+                template_input,
+                &fermion_ordering,
+                &prepared_transitions,
+                &transition_reflections,
+                &coupling_limits,
+                &propagators,
+                &color_targets,
+                &structural_demands,
+                &mut color_states,
+                &mut currents,
+                &mut lane_current_ids,
+                &mut lane_currents_by_size,
+                &mut current_support_keys,
+                &mut reflection_certificates,
+                &mut resident_contribution_count,
+                stage_index_offset,
+                stage_total,
+                phase_total,
+                &mut telemetry,
+                collect_telemetry,
+                progress,
+            )
+        };
+        #[cfg(feature = "on-the-fly-test-support")]
+        let lane_stage_diagnostics =
+            super::diagnostic::with_transition_diagnostic_materialized_sector(
+                (construction_sectors.len() == 1)
+                    .then(|| construction_sectors.first().copied())
+                    .flatten(),
+                build_lane,
+            )?;
+        #[cfg(not(feature = "on-the-fly-test-support"))]
+        let lane_stage_diagnostics = build_lane()?;
+        if collect_telemetry {
+            let color_target_telemetry = color_targets.telemetry()?;
+            for (target, value, label) in [
+                (
+                    &mut telemetry.color_fragment_bucket_count,
+                    color_target_telemetry.fragment_bucket_count,
+                    "telemetry color-fragment bucket count",
+                ),
+                (
+                    &mut telemetry.color_acceptance_cache_hit_count,
+                    color_target_telemetry.acceptance_cache_hit_count,
+                    "telemetry color-acceptance cache-hit count",
+                ),
+                (
+                    &mut telemetry.color_acceptance_cache_miss_count,
+                    color_target_telemetry.acceptance_cache_miss_count,
+                    "telemetry color-acceptance cache-miss count",
+                ),
+                (
+                    &mut telemetry.color_fragment_hash_lookup_count,
+                    color_target_telemetry.fragment_hash_lookup_count,
+                    "telemetry color-fragment hash-lookup count",
+                ),
+                (
+                    &mut telemetry.color_posting_incidence_count,
+                    color_target_telemetry.posting_incidence_count,
+                    "telemetry color-posting incidence count",
+                ),
+                (
+                    &mut telemetry.color_sparse_posting_bucket_count,
+                    color_target_telemetry.sparse_posting_bucket_count,
+                    "telemetry sparse color-posting bucket count",
+                ),
+                (
+                    &mut telemetry.color_dense_posting_bucket_count,
+                    color_target_telemetry.dense_posting_bucket_count,
+                    "telemetry dense color-posting bucket count",
+                ),
+                (
+                    &mut telemetry.color_sparse_posting_bytes,
+                    color_target_telemetry.sparse_posting_bytes,
+                    "telemetry sparse color-posting bytes",
+                ),
+                (
+                    &mut telemetry.color_dense_posting_bytes,
+                    color_target_telemetry.dense_posting_bytes,
+                    "telemetry dense color-posting bytes",
+                ),
+            ] {
+                checked_diagnostic_add(target, value, label)?;
+            }
+            debug_assert_eq!(
+                color_target_telemetry
+                    .acceptance_accept_count
+                    .saturating_add(color_target_telemetry.acceptance_reject_count),
+                color_target_telemetry
+                    .acceptance_cache_hit_count
+                    .saturating_add(color_target_telemetry.acceptance_cache_miss_count),
+            );
+        }
+        let lane_internal_end = currents.len();
+        let lane_domain = isolate_replay_lanes.then_some(PendingConstructionDomain {
+            shared_source_end: source_current_count,
+            lane_internal_start,
+            lane_internal_end,
+        });
+        let closure_processing_started = telemetry_timer(collect_telemetry);
+        let lane_closure_domain = build_closures(
+            strategy,
+            process_input,
+            &process_catalog,
+            template_input,
+            &fermion_ordering,
+            pairing_catalog,
+            &prepared_closures,
+            &prepared_closure_sectors,
+            &color_states,
+            &currents,
+            &construction_sectors,
+            &lane_stage_diagnostics,
+            &reflection_certificates,
+            lane_domain,
+            &mut telemetry,
+            collect_telemetry,
+        )?;
+        for sector_id in lane_closure_domain.physical_sector_ids {
+            if !exhaustive_closure_sector_ids.insert(sector_id) {
+                return Err(invalid(
+                    "recurrence closure construction visited one physical sector twice",
+                ));
+            }
+        }
+        for (sector_id, owner_id) in lane_closure_domain.physical_sector_owner_ids {
+            if exhaustive_closure_sector_owner_ids
+                .insert(sector_id, owner_id)
+                .is_some()
+            {
+                return Err(invalid(
+                    "recurrence closure construction assigned one physical-sector owner twice",
+                ));
+            }
+        }
+        let lane_closures = lane_closure_domain.groups;
+        let lane_closures = if lane_domain.is_some() {
+            retain_supported_pending_closures(
+                strategy,
+                &process_catalog,
+                &replay_targets,
+                lane_closures,
+                helicity_support_rule,
+                global_helicity_flip_rule,
+            )?
+        } else {
+            lane_closures
+        };
+        if let Some(domain) = lane_domain {
+            prune_inactive_lane_contributions(
+                &mut currents,
+                domain,
+                &lane_closures,
+                &mut resident_contribution_count,
+            )?;
+        }
+        for (key, group) in lane_closures {
+            if closures.insert(key, group).is_some() {
+                return Err(invalid(
+                    "isolated recurrence construction produced a duplicate closure",
+                ));
+            }
+        }
+        add_optional_elapsed_nanoseconds(
+            &mut telemetry.closure_processing_nanoseconds,
+            closure_processing_started,
+        );
+        stage_diagnostics.extend(lane_stage_diagnostics);
+    }
+    if pending_contribution_entry_count(&currents)? != resident_contribution_count {
+        return Err(invalid(
+            "resident recurrence contribution count disagrees with pending storage",
+        ));
+    }
+    let color_target_prune_count = stage_diagnostics
+        .iter()
+        .map(|stage| stage.color_target_prune_count)
+        .try_fold(0usize, |total, count| {
+            total
+                .checked_add(count)
+                .ok_or_else(|| invalid("recurrence color-target prune count exceeds usize"))
+        })?;
+    progress(RecurrenceBuildProgress::snapshot(
+        "amplitude closure",
+        stage_total.saturating_add(2),
+        phase_total,
+        None,
+        stage_total,
+        None,
+        0,
+        None,
+        currents.len(),
+        resident_contribution_count,
+        color_states.len(),
+        color_target_prune_count,
+    ))?;
+    progress(RecurrenceBuildProgress::snapshot(
+        "schedule finalization",
+        phase_total,
+        phase_total,
+        None,
+        stage_total,
+        None,
+        0,
+        None,
+        currents.len(),
+        resident_contribution_count,
+        color_states.len(),
+        color_target_prune_count,
+    ))?;
+    if collect_telemetry {
+        telemetry.constructed_current_count = currents.len();
+        telemetry.constructed_contribution_count = resident_contribution_count;
+        telemetry.constructed_interaction_count = resident_contribution_count;
+        telemetry.constructed_dynamic_color_state_count = color_states.len();
+        telemetry.indexed_hash_lookup_count = telemetry
+            .support_bucket_probe_count
+            .checked_add(telemetry.color_acceptance_cache_hit_count)
+            .and_then(|count| count.checked_add(telemetry.color_acceptance_cache_miss_count))
+            .and_then(|count| count.checked_add(telemetry.color_fragment_hash_lookup_count))
+            .ok_or_else(|| invalid("telemetry indexed hash-lookup count exceeds usize"))?;
+    }
+    let canonical_emission_started = telemetry_timer(collect_telemetry);
+    let program = finish_program(
+        strategy,
+        &process_catalog,
+        color_states.into_states(),
+        currents,
+        closures,
+        exhaustive_closure_sector_ids,
+        exhaustive_closure_sector_owner_ids,
+        replay_targets,
+        retained_helicity_count,
+        if isolate_replay_lanes {
+            HelicitySupportRule::None
+        } else {
+            helicity_support_rule
+        },
+        if isolate_replay_lanes {
+            GlobalHelicityFlipRule::None
+        } else {
+            global_helicity_flip_rule
+        },
+        reflection_certificates,
+    )?;
+    add_optional_elapsed_nanoseconds(
+        &mut telemetry.canonical_emission_nanoseconds,
+        canonical_emission_started,
+    );
+    if collect_telemetry {
+        telemetry.emitted_current_count = program.currents().len();
+        telemetry.emitted_contribution_count = program.contributions().len();
+        telemetry.emitted_interaction_count = program.contributions().len();
+        telemetry.emitted_finalization_count = program.finalizations().len();
+        telemetry.emitted_closure_count = program.closure_terms().len();
+    }
+    Ok((program, telemetry))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_sources(
+    strategy: RecurrenceStrategy,
+    catalog_digest: SemanticDigest,
+    process: &OwnedRecurrenceProcessInput,
+    process_catalog: &ProcessCatalog<'_>,
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+    template: &OwnedRecurrenceTemplateInput,
+    template_catalog: &TemplateCatalog<'_>,
+    color_states: &mut DynamicLCColorStateInterner,
+    currents: &mut Vec<PendingCurrent>,
+    current_ids: &mut TransientCurrentIdIndex,
+    currents_by_size: &mut [Vec<u32>],
+) -> RusticolResult<()> {
+    let zero_orders = vec![0_u32; template_catalog.coupling_names.len()];
+    for leg in &process.external_legs {
+        let range = leg
+            .source_state_range
+            .as_usize_range(process.source_states.len(), "recurrence source-state range")?;
+        let retained_state_indices = retained_source_state_indices(process, leg.source_slot)?;
+        let retained_states = retained_state_indices
+            .into_iter()
+            .map(|state_index| {
+                process
+                    .source_states
+                    .get(range.start + state_index as usize)
+                    .ok_or_else(|| invalid("retained recurrence source state is absent"))
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        for process_state in &retained_states {
+            let source = *template
+                .sources
+                .get(process_state.source_template_id as usize)
+                .ok_or_else(|| invalid("source template is absent"))?;
+            validate_crossed_source_state(leg.is_initial != 0, process_state, source, template)?;
+        }
+
+        match strategy {
+            RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion => {
+                for process_state in retained_states {
+                    let source = *template
+                        .sources
+                        .get(process_state.source_template_id as usize)
+                        .ok_or_else(|| invalid("source template is absent"))?;
+                    let color_id = source_color_state_id(
+                        leg.source_slot,
+                        source,
+                        template,
+                        template_catalog,
+                        color_states,
+                    )?;
+                    let reflection = source_reflection(
+                        color_states,
+                        color_id,
+                        leg.source_slot,
+                        template_catalog.source_seed(source)?.proof_digest(),
+                    )?;
+                    let helicity_identity = match strategy {
+                        RecurrenceStrategy::TopologyReplay => {
+                            CurrentHelicityIdentity::topology_replay(
+                                process_state.spin_state,
+                                vec![SourceStateAssignment::new(
+                                    leg.source_slot,
+                                    process_state.state_index,
+                                )],
+                            )?
+                        }
+                        RecurrenceStrategy::ContractedColorUnion => {
+                            CurrentHelicityIdentity::contracted_color_union(
+                                process_state.spin_state,
+                                vec![SourceStateAssignment::new(
+                                    leg.source_slot,
+                                    process_state.state_index,
+                                )],
+                            )?
+                        }
+                        RecurrenceStrategy::AllFlowUnion => unreachable!(),
+                    };
+                    insert_source_current(
+                        catalog_digest,
+                        process_state.current_state_template_id,
+                        color_id,
+                        leg.source_slot,
+                        process_state.momentum_sign,
+                        helicity_identity,
+                        source,
+                        reflection,
+                        CurrentSourceBinding::FixedTemplate(process_state.source_template_id),
+                        Some(process_catalog.factor(
+                            process_state.crossing_phase_factor_id,
+                            "source crossing phase",
+                        )?),
+                        &zero_orders,
+                        pairing_catalog,
+                        template_catalog,
+                        currents,
+                        current_ids,
+                        currents_by_size,
+                    )?;
+                }
+            }
+            RecurrenceStrategy::AllFlowUnion => {
+                let groups = union_source_dispatch_groups(
+                    &retained_states,
+                    process_catalog,
+                    template,
+                    template_catalog,
+                )?;
+                for group in groups {
+                    let source = group.representative_source;
+                    let color_id = source_color_state_id(
+                        leg.source_slot,
+                        source,
+                        template,
+                        template_catalog,
+                        color_states,
+                    )?;
+                    let reflection = source_reflection(
+                        color_states,
+                        color_id,
+                        leg.source_slot,
+                        template_catalog.source_seed(source)?.proof_digest(),
+                    )?;
+                    insert_source_current(
+                        catalog_digest,
+                        group.full_state_template_id,
+                        color_id,
+                        leg.source_slot,
+                        group.momentum_sign,
+                        CurrentHelicityIdentity::all_flow_union(group.full_spin_state_class),
+                        source,
+                        reflection,
+                        CurrentSourceBinding::runtime_dispatch_with_variants(
+                            group.contract_id,
+                            group.variants,
+                        )?,
+                        None,
+                        &zero_orders,
+                        pairing_catalog,
+                        template_catalog,
+                        currents,
+                        current_ids,
+                        currents_by_size,
+                    )?;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn source_color_state_id(
+    source_slot: u32,
+    source: SourceRow,
+    template: &OwnedRecurrenceTemplateInput,
+    template_catalog: &TemplateCatalog<'_>,
+    color_states: &mut DynamicLCColorStateInterner,
+) -> RusticolResult<super::DynamicLCColorStateId> {
+    let dynamic_state = template_catalog.source_seed(source)?.instantiate(
+        source_slot,
+        template
+            .current_states
+            .get(source.state_template_id as usize)
+            .ok_or_else(|| invalid("source current-state template is absent"))?
+            .color_representation,
+    )?;
+    color_states.intern(dynamic_state)
+}
+
+#[derive(Debug)]
+struct UnionSourceDispatchGroup {
+    contract_id: u32,
+    full_state_template_id: u32,
+    full_spin_state_class: i32,
+    momentum_sign: i32,
+    representative_source: SourceRow,
+    variants: Vec<RuntimeSourceVariantBinding>,
+}
+
+fn union_source_dispatch_groups(
+    retained_states: &[&ProcessSourceStateRow],
+    process_catalog: &ProcessCatalog<'_>,
+    template: &OwnedRecurrenceTemplateInput,
+    template_catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<Vec<UnionSourceDispatchGroup>> {
+    let mut grouped = BTreeMap::<
+        u32,
+        (
+            RuntimeHelicityContractRow,
+            Vec<(ProcessSourceStateRow, RuntimeHelicityVariantRow)>,
+        ),
+    >::new();
+    for process_state in retained_states {
+        let (contract, variant) =
+            runtime_helicity_variant_for_source(template, process_state.source_template_id)?;
+        if variant.source_state_template_id
+            != template.sources[process_state.source_template_id as usize].state_template_id
+        {
+            return Err(invalid(format!(
+                "runtime-helicity variant {} source-state contract is stale",
+                variant.id
+            )));
+        }
+        grouped
+            .entry(contract.id)
+            .or_insert_with(|| (contract, Vec::new()))
+            .1
+            .push((**process_state, variant));
+    }
+    if grouped.is_empty() {
+        return Err(invalid(
+            "all-flow-union source has no certified runtime-helicity dispatch domain",
+        ));
+    }
+
+    grouped
+        .into_values()
+        .map(|(contract, mut entries)| {
+            entries.sort_by_key(|(state, _)| state.state_index);
+            if entries
+                .windows(2)
+                .any(|pair| pair[0].0.state_index == pair[1].0.state_index)
+            {
+                return Err(invalid(format!(
+                    "runtime-helicity contract {} has an ambiguous process source-state mapping",
+                    contract.id
+                )));
+            }
+            let full_state = template
+                .current_states
+                .get(contract.full_state_template_id as usize)
+                .ok_or_else(|| invalid("runtime-helicity full state is absent"))?;
+            let representative_state = entries[0].0;
+            let representative_source =
+                template.sources[representative_state.source_template_id as usize];
+            let momentum_sign = representative_state.momentum_sign;
+            for (process_state, variant) in &entries {
+                let source = template.sources[process_state.source_template_id as usize];
+                validate_union_source_family(
+                    representative_source,
+                    source,
+                    contract,
+                    *variant,
+                    *process_state,
+                    full_state,
+                    template,
+                    template_catalog,
+                )?;
+                if process_state.momentum_sign != momentum_sign {
+                    return Err(invalid(format!(
+                        "runtime-helicity contract {} mixes source momentum signs",
+                        contract.id
+                    )));
+                }
+            }
+            let full_spin_state_class =
+                union_full_spin_state_class(contract, &entries, template, template_catalog)?;
+            let variants = entries
+                .into_iter()
+                .map(|(process_state, variant)| {
+                    RuntimeSourceVariantBinding::new(
+                        process_state.state_index,
+                        process_state.public_helicity,
+                        variant.id,
+                        variant.source_template_id,
+                        variant.source_state_template_id,
+                        process_state.current_state_template_id,
+                        process_state.spin_state,
+                        process_catalog.factor(
+                            process_state.crossing_phase_factor_id,
+                            "runtime source crossing phase",
+                        )?,
+                    )
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(UnionSourceDispatchGroup {
+                contract_id: contract.id,
+                full_state_template_id: contract.full_state_template_id,
+                full_spin_state_class,
+                momentum_sign,
+                representative_source,
+                variants,
+            })
+        })
+        .collect()
+}
+
+fn runtime_helicity_variant_for_source(
+    template: &OwnedRecurrenceTemplateInput,
+    source_template_id: u32,
+) -> RusticolResult<(RuntimeHelicityContractRow, RuntimeHelicityVariantRow)> {
+    let mut found = None;
+    for contract in template.runtime_helicity_contracts.iter().copied() {
+        let range = contract.variant_range.as_usize_range(
+            template.runtime_helicity_variants.len(),
+            "runtime-helicity variants",
+        )?;
+        for variant in template.runtime_helicity_variants[range].iter().copied() {
+            if variant.source_template_id != source_template_id {
+                continue;
+            }
+            if found.replace((contract, variant)).is_some() {
+                return Err(invalid(format!(
+                    "source template {source_template_id} belongs to ambiguous runtime-helicity variants"
+                )));
+            }
+        }
+    }
+    found.ok_or_else(|| {
+        invalid(format!(
+            "source template {source_template_id} has no certified runtime-helicity variant"
+        ))
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn validate_union_source_family(
+    representative: SourceRow,
+    source: SourceRow,
+    contract: RuntimeHelicityContractRow,
+    variant: RuntimeHelicityVariantRow,
+    process_state: ProcessSourceStateRow,
+    full_state: &super::template::CurrentStateRow,
+    template: &OwnedRecurrenceTemplateInput,
+    template_catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<()> {
+    if variant.contract_id != contract.id
+        || variant.source_template_id != source.id
+        || variant.source_state_template_id != source.state_template_id
+    {
+        return Err(invalid(format!(
+            "runtime-helicity variant {} is inconsistent with source template {}",
+            variant.id, source.id
+        )));
+    }
+    let effective = template
+        .current_states
+        .get(process_state.current_state_template_id as usize)
+        .ok_or_else(|| invalid("runtime source effective state is absent"))?;
+    let full_state_is_compatible = full_state.particle_id == effective.particle_id
+        && full_state.anti_particle_id == effective.anti_particle_id
+        && full_state.species_string_id == effective.species_string_id
+        && full_state.orientation == effective.orientation
+        && full_state.statistics == effective.statistics
+        && full_state.color_representation == effective.color_representation
+        && full_state.lc_color_shape_string_id == effective.lc_color_shape_string_id
+        && full_state.auxiliary_kind_string_id == effective.auxiliary_kind_string_id
+        && full_state.mass_parameter_id == effective.mass_parameter_id
+        && full_state.width_parameter_id == effective.width_parameter_id;
+    if !full_state_is_compatible {
+        return Err(invalid(format!(
+            "runtime-helicity full state {} is not crossing-compatible with process state {}",
+            contract.full_state_template_id, process_state.current_state_template_id
+        )));
+    }
+    if !same_union_source_dispatch_semantics(representative, source)
+        || template_catalog.flavour_flow(
+            representative.flavour_flow_id,
+            "runtime source flavour flow",
+        )? != template_catalog
+            .flavour_flow(source.flavour_flow_id, "runtime source flavour flow")?
+    {
+        return Err(invalid(format!(
+            "runtime-helicity contract {} mixes incompatible source semantics",
+            contract.id
+        )));
+    }
+    Ok(())
+}
+
+fn same_union_source_dispatch_semantics(left: SourceRow, right: SourceRow) -> bool {
+    left.crossing_string_id == right.crossing_string_id
+        && left.wavefunction_family_string_id == right.wavefunction_family_string_id
+        && left.flavour_flow_id == right.flavour_flow_id
+        && left.quantum_number_flow_id == right.quantum_number_flow_id
+        && left.lc_color_seed_operation == right.lc_color_seed_operation
+        && left.lc_color_seed_shape_string_id == right.lc_color_seed_shape_string_id
+        && left.lc_color_seed_component_kind == right.lc_color_seed_component_kind
+        && left.lc_color_seed_component_role == right.lc_color_seed_component_role
+        && left.lc_color_seed_provenance_sequence_id == right.lc_color_seed_provenance_sequence_id
+        && left.mass_parameter_id == right.mass_parameter_id
+        && left.width_parameter_id == right.width_parameter_id
+}
+
+fn union_full_spin_state_class(
+    contract: RuntimeHelicityContractRow,
+    entries: &[(ProcessSourceStateRow, RuntimeHelicityVariantRow)],
+    template: &OwnedRecurrenceTemplateInput,
+    _catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<i32> {
+    let mut result_spins = BTreeSet::new();
+    for flow in &template.quantum_flows {
+        if flow.result_state_template_id == contract.full_state_template_id {
+            result_spins.insert(flow.result_spin_state);
+        }
+    }
+    if result_spins.is_empty() {
+        result_spins.extend(entries.iter().map(|(state, _)| state.spin_state));
+    }
+    union_spin_state_class(contract.id, &result_spins)
+}
+
+fn union_spin_state_class(contract_id: u32, result_spins: &BTreeSet<i32>) -> RusticolResult<i32> {
+    if result_spins.is_empty() {
+        return Err(invalid(format!(
+            "runtime-helicity contract {} has no full-state spin class",
+            contract_id
+        )));
+    }
+    if result_spins.contains(&DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS) {
+        return Err(invalid(format!(
+            "runtime-helicity contract {} contains the reserved dynamic source-spin sentinel",
+            contract_id
+        )));
+    }
+    Ok(if result_spins.len() == 1 {
+        *result_spins.iter().next().expect("checked nonempty")
+    } else {
+        // One all-flow source current stores the full runtime-helicity vector.
+        // Its selected chiral embedding is populated at execution time, so a
+        // static source spin class would incorrectly discard the other
+        // certified branch during recurrence construction.
+        DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn insert_source_current(
+    catalog_digest: SemanticDigest,
+    current_state_template_id: u32,
+    color_id: super::DynamicLCColorStateId,
+    source_slot: u32,
+    momentum_sign: i32,
+    helicity_identity: CurrentHelicityIdentity,
+    source: SourceRow,
+    reflection: CurrentReflection,
+    source_binding: CurrentSourceBinding,
+    source_factor: Option<ExactComplexRational>,
+    zero_orders: &[u32],
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+    template_catalog: &TemplateCatalog<'_>,
+    currents: &mut Vec<PendingCurrent>,
+    current_ids: &mut TransientCurrentIdIndex,
+    currents_by_size: &mut [Vec<u32>],
+) -> RusticolResult<()> {
+    let key = CurrentCoreKey::new(
+        catalog_digest,
+        RecurrenceNodeKind::Source,
+        current_state_template_id,
+        color_id,
+        vec![source_slot],
+        CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+            source_slot,
+            coefficient: momentum_sign,
+        }])?,
+        helicity_identity,
+        template_catalog
+            .flavour_flow(source.flavour_flow_id, "source flavour flow")?
+            .to_vec(),
+        source.quantum_number_flow_id,
+        zero_orders.to_vec(),
+        source_binding,
+        None,
+    )?;
+    let realized_pairing_rule_ids = compatible_pairing_rules_for_current(
+        pairing_catalog,
+        template_catalog.input,
+        current_state_template_id,
+        &[source_slot],
+    )?;
+    if let Some(existing) = current_ids.get(&key).copied() {
+        if currents[existing as usize].source_exact_factor != source_factor {
+            return Err(invalid(
+                "equivalent source currents have different exact factors",
+            ));
+        }
+        currents[existing as usize]
+            .reflection
+            .include(reflection.proof().cloned())?;
+        currents[existing as usize]
+            .realized_pairing_rule_ids
+            .extend(realized_pairing_rule_ids);
+        return Ok(());
+    }
+    let id = u32::try_from(currents.len())
+        .map_err(|_| invalid("recurrence current count exceeds u32"))?;
+    current_ids.insert(key.clone(), id);
+    currents.push(PendingCurrent {
+        key,
+        source_exact_factor: source_factor,
+        contributions: BTreeMap::new(),
+        realized_pairing_rule_ids,
+        reflection,
+        reflection_certificate_id: None,
+    });
+    currents_by_size[0].push(id);
+    Ok(())
+}
+
+pub(super) fn source_reflection(
+    color_states: &DynamicLCColorStateInterner,
+    color_id: super::DynamicLCColorStateId,
+    source_slot: u32,
+    source_seed_proof: SemanticDigest,
+) -> RusticolResult<CurrentReflection> {
+    let color = color_states
+        .get(color_id)
+        .ok_or_else(|| invalid("source dynamic color state disappeared"))?;
+    Ok(if color.pure_adjoint_word().is_some() {
+        let color_identity = dynamic_color_identity_digest(color)?;
+        let root = source_reflection_proof_root(source_slot, source_seed_proof, color_identity)?;
+        CurrentReflection::Proven(CurrentReflectionProof::new(
+            ExactComplexRational::ONE,
+            [root],
+            color_identity,
+        )?)
+    } else {
+        CurrentReflection::Unavailable
+    })
+}
+
+pub(super) fn validate_crossed_source_state(
+    is_initial: bool,
+    process_state: &super::process::ProcessSourceStateRow,
+    source: SourceRow,
+    template: &OwnedRecurrenceTemplateInput,
+) -> RusticolResult<()> {
+    let canonical = template
+        .current_states
+        .get(source.state_template_id as usize)
+        .ok_or_else(|| invalid("source canonical current-state template is absent"))?;
+    let effective = template
+        .current_states
+        .get(process_state.current_state_template_id as usize)
+        .ok_or_else(|| invalid("source effective current-state template is absent"))?;
+    if effective.chirality != process_state.chirality {
+        return Err(invalid(format!(
+            "process source chirality {} does not match effective current-state chirality {}",
+            process_state.chirality, effective.chirality,
+        )));
+    }
+    let compatible = canonical.particle_id == effective.particle_id
+        && canonical.anti_particle_id == effective.anti_particle_id
+        && canonical.species_string_id == effective.species_string_id
+        && canonical.orientation == effective.orientation
+        && canonical.statistics == effective.statistics
+        && canonical.color_representation == effective.color_representation
+        && canonical.basis_string_id == effective.basis_string_id
+        && canonical.tensor_ordering_sequence_id == effective.tensor_ordering_sequence_id
+        && canonical.dimension == effective.dimension
+        && canonical.lc_color_shape_string_id == effective.lc_color_shape_string_id
+        && canonical.auxiliary_kind_string_id == effective.auxiliary_kind_string_id
+        && canonical.mass_parameter_id == effective.mass_parameter_id
+        && canonical.width_parameter_id == effective.width_parameter_id;
+    if !compatible || (!is_initial && canonical.id != effective.id) {
+        return Err(invalid(format!(
+            "source template {} and effective current-state template {} are not crossing-compatible",
+            process_state.source_template_id, process_state.current_state_template_id,
+        )));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+fn parent_pairs_for_target(
+    target_size: usize,
+    prior_currents_by_size: &[Vec<u32>],
+) -> impl Iterator<Item = [u32; 2]> + '_ {
+    (1..=target_size / 2).flat_map(move |left_size| {
+        let right_size = target_size - left_size;
+        let same_size = left_size == right_size;
+        prior_currents_by_size[left_size - 1]
+            .iter()
+            .copied()
+            .flat_map(move |left_id| {
+                prior_currents_by_size[right_size - 1]
+                    .iter()
+                    .copied()
+                    .filter_map(move |right_id| match left_id.cmp(&right_id) {
+                        std::cmp::Ordering::Less => Some([left_id, right_id]),
+                        std::cmp::Ordering::Equal => None,
+                        std::cmp::Ordering::Greater if same_size => None,
+                        std::cmp::Ordering::Greater => Some([right_id, left_id]),
+                    })
+            })
+    })
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct OrderedCurrentId {
+    current_id: u32,
+    bucket_position: usize,
+}
+
+#[derive(Debug, Default)]
+struct SupportBucketIndex {
+    ordered_supports: Vec<TransientSupportKey>,
+    current_ids_by_support: HashMap<TransientSupportKey, Vec<OrderedCurrentId>>,
+    disjoint_current_cache: HashMap<TransientSupportKey, Rc<[OrderedCurrentId]>>,
+    entry_count: usize,
+}
+
+impl SupportBucketIndex {
+    fn insert(&mut self, current_id: u32, support: &TransientSupportKey) {
+        use std::collections::hash_map::Entry;
+
+        let ordered = OrderedCurrentId {
+            current_id,
+            bucket_position: self.entry_count,
+        };
+        self.entry_count += 1;
+        match self.current_ids_by_support.entry(support.clone()) {
+            Entry::Occupied(mut entry) => entry.get_mut().push(ordered),
+            Entry::Vacant(entry) => {
+                self.ordered_supports.push(support.clone());
+                entry.insert(vec![ordered]);
+            }
+        }
+        self.disjoint_current_cache = HashMap::new();
+    }
+
+    fn disjoint_current_ids(
+        &mut self,
+        left_support: &TransientSupportKey,
+    ) -> RusticolResult<(Rc<[OrderedCurrentId]>, bool)> {
+        if let Some(cached) = self.disjoint_current_cache.get(left_support) {
+            return Ok((Rc::clone(cached), true));
+        }
+        let mut result = Vec::new();
+        // Emission never depends on HashMap iteration order. The support order
+        // is the first-current order of the original size bucket, and final
+        // positions restore that bucket's exact current-ID order.
+        for right_support in &self.ordered_supports {
+            if !left_support.is_disjoint(right_support)? {
+                continue;
+            }
+            result.extend(
+                self.current_ids_by_support
+                    .get(right_support)
+                    .expect("ordered support has an ID bucket")
+                    .iter()
+                    .copied(),
+            );
+        }
+        result.sort_unstable_by_key(|entry| entry.bucket_position);
+        let result = Rc::<[OrderedCurrentId]>::from(result);
+        self.disjoint_current_cache
+            .insert(left_support.clone(), Rc::clone(&result));
+        Ok((result, false))
+    }
+
+    fn clear_disjoint_cache(&mut self) {
+        self.disjoint_current_cache = HashMap::new();
+    }
+}
+
+#[derive(Debug)]
+struct LaneSupportBuckets {
+    buckets_by_size: Vec<SupportBucketIndex>,
+}
+
+impl LaneSupportBuckets {
+    fn new(
+        currents_by_size: &[Vec<u32>],
+        support_keys: &TransientCurrentSupportKeys,
+    ) -> RusticolResult<Self> {
+        let mut buckets_by_size = (0..currents_by_size.len())
+            .map(|_| SupportBucketIndex::default())
+            .collect::<Vec<_>>();
+        for (size_index, current_ids) in currents_by_size.iter().enumerate() {
+            for current_id in current_ids.iter().copied() {
+                buckets_by_size[size_index].insert(current_id, support_keys.get(current_id)?);
+            }
+        }
+        Ok(Self { buckets_by_size })
+    }
+
+    fn bucket_mut(&mut self, support_size: usize) -> RusticolResult<&mut SupportBucketIndex> {
+        self.buckets_by_size
+            .get_mut(
+                support_size
+                    .checked_sub(1)
+                    .ok_or_else(|| invalid("transient support bucket size is zero"))?,
+            )
+            .ok_or_else(|| invalid("transient support bucket is absent"))
+    }
+
+    fn replace_bucket(
+        &mut self,
+        support_size: usize,
+        current_ids: &[u32],
+        support_keys: &TransientCurrentSupportKeys,
+    ) -> RusticolResult<()> {
+        let bucket = self.bucket_mut(support_size)?;
+        *bucket = SupportBucketIndex::default();
+        for current_id in current_ids.iter().copied() {
+            bucket.insert(current_id, support_keys.get(current_id)?);
+        }
+        Ok(())
+    }
+
+    fn clear_disjoint_caches(&mut self) {
+        for bucket in &mut self.buckets_by_size {
+            bucket.clear_disjoint_cache();
+        }
+    }
+
+    #[cfg(test)]
+    fn cached_disjoint_query_count(&self) -> usize {
+        self.buckets_by_size
+            .iter()
+            .map(|bucket| bucket.disjoint_current_cache.len())
+            .sum()
+    }
+
+    #[cfg(test)]
+    fn cached_disjoint_capacity(&self) -> usize {
+        self.buckets_by_size
+            .iter()
+            .map(|bucket| bucket.disjoint_current_cache.capacity())
+            .sum()
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum CandidateOrdinalMap {
+    SameSize {
+        first_greater_position: usize,
+    },
+    DifferentSize {
+        equal_start: usize,
+        equal_end: usize,
+    },
+}
+
+impl CandidateOrdinalMap {
+    fn offset(self, right_position: usize) -> Option<usize> {
+        match self {
+            Self::SameSize {
+                first_greater_position,
+            } => right_position.checked_sub(first_greater_position),
+            Self::DifferentSize {
+                equal_start,
+                equal_end,
+            } => {
+                if (equal_start..equal_end).contains(&right_position) {
+                    None
+                } else if right_position < equal_start {
+                    Some(right_position)
+                } else {
+                    Some(right_position - (equal_end - equal_start))
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+struct ParentPairPlan {
+    left_id: u32,
+    right_ids: Rc<[OrderedCurrentId]>,
+    same_size: bool,
+    candidate_base: usize,
+    ordinal_map: CandidateOrdinalMap,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct OrderedDisjointParentPair {
+    parent_ids: [u32; 2],
+    theoretical_candidate_count: usize,
+}
+
+#[derive(Debug)]
+struct DisjointParentPairs {
+    plans: std::vec::IntoIter<ParentPairPlan>,
+    current_plan: Option<ParentPairPlan>,
+    right_index: usize,
+}
+
+impl Iterator for DisjointParentPairs {
+    type Item = RusticolResult<OrderedDisjointParentPair>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if self.current_plan.is_none() {
+                self.current_plan = self.plans.next();
+                self.right_index = 0;
+            }
+            let plan = self.current_plan.as_ref()?;
+            let Some(right) = plan.right_ids.get(self.right_index).copied() else {
+                self.current_plan = None;
+                continue;
+            };
+            self.right_index += 1;
+            let Some(candidate_offset) = plan.ordinal_map.offset(right.bucket_position) else {
+                continue;
+            };
+            let parent_ids = match plan.left_id.cmp(&right.current_id) {
+                std::cmp::Ordering::Less => [plan.left_id, right.current_id],
+                std::cmp::Ordering::Equal => continue,
+                std::cmp::Ordering::Greater if plan.same_size => continue,
+                std::cmp::Ordering::Greater => [right.current_id, plan.left_id],
+            };
+            let theoretical_candidate_count = match plan
+                .candidate_base
+                .checked_add(candidate_offset)
+                .and_then(|count| count.checked_add(1))
+            {
+                Some(count) => count,
+                None => {
+                    return Some(Err(invalid(
+                        "recurrence candidate parent-pair count exceeds usize",
+                    )));
+                }
+            };
+            return Some(Ok(OrderedDisjointParentPair {
+                parent_ids,
+                theoretical_candidate_count,
+            }));
+        }
+    }
+}
+
+#[derive(Debug)]
+struct DisjointParentPairSchedule {
+    pairs: DisjointParentPairs,
+    theoretical_candidate_count: usize,
+    support_bucket_count: usize,
+    support_bucket_probe_count: usize,
+    support_bucket_cache_hit_count: usize,
+}
+
+fn disjoint_parent_pairs_for_target(
+    target_size: usize,
+    prior_currents_by_size: &[Vec<u32>],
+    support_keys: &TransientCurrentSupportKeys,
+    support_buckets: &mut LaneSupportBuckets,
+) -> RusticolResult<DisjointParentPairSchedule> {
+    let mut plans = Vec::new();
+    let mut theoretical_candidate_count = 0usize;
+    let mut support_bucket_count = 0usize;
+    let mut support_bucket_probe_count = 0usize;
+    let mut support_bucket_cache_hit_count = 0usize;
+    for left_size in 1..=target_size / 2 {
+        let right_size = target_size - left_size;
+        let same_size = left_size == right_size;
+        let right_bucket = &prior_currents_by_size[right_size - 1];
+        let indexed_right_bucket = support_buckets.bucket_mut(right_size)?;
+        support_bucket_count = support_bucket_count
+            .checked_add(indexed_right_bucket.ordered_supports.len())
+            .ok_or_else(|| invalid("support-bucket count exceeds usize"))?;
+        debug_assert!(right_bucket.iter().copied().is_sorted());
+        for left_id in prior_currents_by_size[left_size - 1].iter().copied() {
+            let equal_start = right_bucket.partition_point(|right_id| *right_id < left_id);
+            let equal_end = right_bucket.partition_point(|right_id| *right_id <= left_id);
+            let (ordinal_map, candidate_count) = if same_size {
+                (
+                    CandidateOrdinalMap::SameSize {
+                        first_greater_position: equal_end,
+                    },
+                    right_bucket.len() - equal_end,
+                )
+            } else {
+                (
+                    CandidateOrdinalMap::DifferentSize {
+                        equal_start,
+                        equal_end,
+                    },
+                    right_bucket.len() - (equal_end - equal_start),
+                )
+            };
+            let (right_ids, cache_hit) =
+                indexed_right_bucket.disjoint_current_ids(support_keys.get(left_id)?)?;
+            support_bucket_probe_count = support_bucket_probe_count
+                .checked_add(1)
+                .ok_or_else(|| invalid("support-bucket probe count exceeds usize"))?;
+            if cache_hit {
+                support_bucket_cache_hit_count = support_bucket_cache_hit_count
+                    .checked_add(1)
+                    .ok_or_else(|| invalid("support-bucket cache-hit count exceeds usize"))?;
+            }
+            plans.push(ParentPairPlan {
+                left_id,
+                right_ids,
+                same_size,
+                candidate_base: theoretical_candidate_count,
+                ordinal_map,
+            });
+            theoretical_candidate_count = theoretical_candidate_count
+                .checked_add(candidate_count)
+                .ok_or_else(|| invalid("recurrence parent-pair total exceeds usize"))?;
+        }
+    }
+    // The plans retain their shared lists until this stage finishes. Drop the
+    // bucket-owned cache references now so no list survives into later stages.
+    support_buckets.clear_disjoint_caches();
+    Ok(DisjointParentPairSchedule {
+        pairs: DisjointParentPairs {
+            plans: plans.into_iter(),
+            current_plan: None,
+            right_index: 0,
+        },
+        theoretical_candidate_count,
+        support_bucket_count,
+        support_bucket_probe_count,
+        support_bucket_cache_hit_count,
+    })
+}
+
+fn parent_pair_total_for_target(
+    target_size: usize,
+    prior_currents_by_size: &[Vec<u32>],
+) -> RusticolResult<usize> {
+    (1..=target_size / 2).try_fold(0usize, |total, left_size| {
+        let right_size = target_size - left_size;
+        let left_count = prior_currents_by_size[left_size - 1].len();
+        let right_count = prior_currents_by_size[right_size - 1].len();
+        let pair_count = if left_size == right_size {
+            left_count
+                .checked_mul(left_count.saturating_sub(1))
+                .and_then(|value| value.checked_div(2))
+        } else {
+            left_count.checked_mul(right_count)
+        }
+        .ok_or_else(|| invalid("recurrence parent-pair total exceeds usize"))?;
+        total
+            .checked_add(pair_count)
+            .ok_or_else(|| invalid("recurrence parent-pair total exceeds usize"))
+    })
+}
+
+fn checked_diagnostic_add(counter: &mut usize, amount: usize, label: &str) -> RusticolResult<()> {
+    *counter = counter
+        .checked_add(amount)
+        .ok_or_else(|| invalid(format!("{label} exceeds usize")))?;
+    Ok(())
+}
+
+fn pending_contribution_entry_count(currents: &[PendingCurrent]) -> RusticolResult<usize> {
+    currents.iter().try_fold(0usize, |total, current| {
+        total
+            .checked_add(current.contributions.len())
+            .ok_or_else(|| invalid("resident recurrence contribution count exceeds usize"))
+    })
+}
+
+fn prune_inactive_lane_contributions(
+    currents: &mut [PendingCurrent],
+    domain: PendingConstructionDomain,
+    closures: &BTreeMap<PendingClosureKey, PendingClosureGroup>,
+    resident_contribution_count: &mut usize,
+) -> RusticolResult<()> {
+    if domain.shared_source_end > domain.lane_internal_start
+        || domain.lane_internal_start > domain.lane_internal_end
+        || domain.lane_internal_end > currents.len()
+    {
+        return Err(invalid(
+            "recurrence lane contribution compaction has an invalid domain",
+        ));
+    }
+    let mut live = BTreeSet::new();
+    let mut queue = VecDeque::new();
+    for (key, group) in closures {
+        if group.exact_factor.is_zero() {
+            continue;
+        }
+        for parent_id in key.parent_current_ids.iter().copied() {
+            if !domain.contains(parent_id as usize) {
+                return Err(invalid(
+                    "recurrence lane closure references another construction lane",
+                ));
+            }
+            if live.insert(parent_id) {
+                queue.push_back(parent_id);
+            }
+        }
+    }
+    while let Some(current_id) = queue.pop_front() {
+        let current = currents
+            .get(current_id as usize)
+            .ok_or_else(|| invalid("recurrence lane liveness references an absent current"))?;
+        for (contribution, factor) in &current.contributions {
+            if factor.is_zero() {
+                continue;
+            }
+            for parent_id in contribution.parent_current_ids.iter().copied() {
+                if !domain.contains(parent_id as usize) {
+                    return Err(invalid(
+                        "recurrence lane contribution references another construction lane",
+                    ));
+                }
+                if live.insert(parent_id) {
+                    queue.push_back(parent_id);
+                }
+            }
+        }
+    }
+
+    for (current_id, current) in currents
+        .iter_mut()
+        .enumerate()
+        .take(domain.lane_internal_end)
+        .skip(domain.lane_internal_start)
+    {
+        let current_id_u32 = u32::try_from(current_id)
+            .map_err(|_| invalid("recurrence lane current ID exceeds u32"))?;
+        let before = current.contributions.len();
+        if live.contains(&current_id_u32) {
+            current.contributions.retain(|_, factor| !factor.is_zero());
+        } else {
+            current.contributions.clear();
+        }
+        let removed = before
+            .checked_sub(current.contributions.len())
+            .ok_or_else(|| invalid("recurrence lane contribution compaction underflowed"))?;
+        *resident_contribution_count = resident_contribution_count
+            .checked_sub(removed)
+            .ok_or_else(|| invalid("resident recurrence contribution count underflowed"))?;
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_internal_currents(
+    catalog_digest: SemanticDigest,
+    process: &OwnedRecurrenceProcessInput,
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+    template: &OwnedRecurrenceTemplateInput,
+    fermion_ordering: &FermionOrderingContext,
+    prepared_transitions: &PreparedTransitionCatalog,
+    transition_reflections: &TransitionReflectionIndex,
+    coupling_limits: &[Option<u32>],
+    propagators: &BTreeMap<u32, Option<u32>>,
+    color_targets: &MaterializedColorTargets,
+    structural_demands: &StructuralDemandIndex,
+    color_states: &mut DynamicLCColorStateInterner,
+    currents: &mut Vec<PendingCurrent>,
+    current_ids: &mut TransientCurrentIdIndex,
+    currents_by_size: &mut [Vec<u32>],
+    current_support_keys: &mut TransientCurrentSupportKeys,
+    reflection_certificates: &mut Vec<PendingReflectionCertificate>,
+    resident_contribution_count: &mut usize,
+    stage_index_offset: usize,
+    reported_stage_total: usize,
+    phase_total: usize,
+    telemetry: &mut RecurrenceGenerationTelemetry,
+    collect_telemetry: bool,
+    progress: &mut dyn FnMut(RecurrenceBuildProgress) -> RusticolResult<()>,
+) -> RusticolResult<Vec<StageConstructionDiagnostics>> {
+    if current_support_keys.source_count != process.external_legs.len() {
+        return Err(invalid(
+            "transient current support domain disagrees with the process",
+        ));
+    }
+    let initial_support_index_started = telemetry_timer(collect_telemetry);
+    let mut support_buckets = LaneSupportBuckets::new(currents_by_size, current_support_keys)?;
+    add_optional_elapsed_nanoseconds(
+        &mut telemetry.support_indexing_nanoseconds,
+        initial_support_index_started,
+    );
+    let mut diagnostics = Vec::new();
+    let mut completed_color_target_prune_count = 0usize;
+    for target_size in 2..process.external_legs.len() {
+        let stage_current_start = currents.len();
+        let stage_contribution_start = *resident_contribution_count;
+        let mut stage = StageConstructionDiagnostics {
+            target_size,
+            ..StageConstructionDiagnostics::default()
+        };
+        let (prior_buckets, target_and_later) = currents_by_size.split_at_mut(target_size - 1);
+        debug_assert!(prior_buckets.iter().flatten().copied().is_sorted());
+        let target_bucket = &mut target_and_later[0];
+        let candidate_parent_pair_total = parent_pair_total_for_target(target_size, prior_buckets)?;
+        let stage_index = stage_index_offset
+            .checked_add(target_size - 1)
+            .ok_or_else(|| invalid("recurrence construction stage index exceeds usize"))?;
+        progress(RecurrenceBuildProgress::snapshot(
+            "recurrence stage",
+            stage_index.saturating_add(1),
+            phase_total,
+            Some(stage_index),
+            reported_stage_total,
+            Some(target_size),
+            0,
+            Some(candidate_parent_pair_total),
+            currents.len(),
+            *resident_contribution_count,
+            color_states.len(),
+            completed_color_target_prune_count,
+        ))?;
+        let mut last_progress = Instant::now();
+        let support_index_started = telemetry_timer(collect_telemetry);
+        let pair_schedule = disjoint_parent_pairs_for_target(
+            target_size,
+            prior_buckets,
+            current_support_keys,
+            &mut support_buckets,
+        )?;
+        add_optional_elapsed_nanoseconds(
+            &mut stage.support_indexing_nanoseconds,
+            support_index_started,
+        );
+        debug_assert_eq!(
+            pair_schedule.theoretical_candidate_count,
+            candidate_parent_pair_total
+        );
+        stage.support_bucket_count = pair_schedule.support_bucket_count;
+        stage.support_bucket_probe_count = pair_schedule.support_bucket_probe_count;
+        stage.support_bucket_cache_hit_count = pair_schedule.support_bucket_cache_hit_count;
+        let mut next_progress_candidate = PROGRESS_PAIR_INTERVAL;
+        let candidate_processing_started = telemetry_timer(collect_telemetry);
+        for pair in pair_schedule.pairs {
+            let pair = pair?;
+            let [left_id, right_id] = pair.parent_ids;
+            stage.candidate_parent_pair_count = pair.theoretical_candidate_count;
+            if stage.candidate_parent_pair_count >= next_progress_candidate {
+                if last_progress.elapsed() >= PROGRESS_TIME_INTERVAL {
+                    progress(RecurrenceBuildProgress::snapshot(
+                        "recurrence stage",
+                        stage_index.saturating_add(1),
+                        phase_total,
+                        Some(stage_index),
+                        reported_stage_total,
+                        Some(target_size),
+                        stage.candidate_parent_pair_count,
+                        Some(candidate_parent_pair_total),
+                        currents.len(),
+                        *resident_contribution_count,
+                        color_states.len(),
+                        completed_color_target_prune_count
+                            .saturating_add(stage.color_target_prune_count),
+                    ))?;
+                    last_progress = Instant::now();
+                }
+                next_progress_candidate = stage
+                    .candidate_parent_pair_count
+                    .checked_div(PROGRESS_PAIR_INTERVAL)
+                    .and_then(|interval| interval.checked_add(1))
+                    .and_then(|interval| interval.checked_mul(PROGRESS_PAIR_INTERVAL))
+                    .unwrap_or(usize::MAX);
+            }
+            checked_diagnostic_add(
+                &mut stage.parent_pair_count,
+                1,
+                "recurrence parent-pair count",
+            )?;
+            let left_state = currents[left_id as usize].key.current_state_template_id();
+            let right_state = currents[right_id as usize].key.current_state_template_id();
+            let indexed_transitions = prepared_transitions.rows(left_state, right_state);
+            if !indexed_transitions.is_empty() {
+                checked_diagnostic_add(
+                    &mut stage.transition_index_hit_count,
+                    1,
+                    "recurrence transition-index hit count",
+                )?;
+            }
+            checked_diagnostic_add(
+                &mut stage.transition_candidate_count,
+                indexed_transitions.len(),
+                "recurrence transition-candidate count",
+            )?;
+            if indexed_transitions.is_empty() {
+                continue;
+            }
+            let merged_support_key = current_support_keys
+                .get(left_id)?
+                .union_disjoint(current_support_keys.get(right_id)?)?;
+            let mut merged_support_source_slots = None;
+            for prepared in indexed_transitions {
+                checked_diagnostic_add(
+                    &mut stage.state_order_count,
+                    1,
+                    "recurrence state-order count",
+                )?;
+                add_transition_contributions(
+                    catalog_digest,
+                    prepared,
+                    prepared.parent_ids(left_state, right_state, left_id, right_id)?,
+                    &merged_support_key,
+                    &mut merged_support_source_slots,
+                    target_size + 1 < process.external_legs.len(),
+                    pairing_catalog,
+                    template,
+                    fermion_ordering,
+                    transition_reflections,
+                    coupling_limits,
+                    propagators,
+                    color_targets,
+                    structural_demands,
+                    color_states,
+                    currents,
+                    current_ids,
+                    target_bucket,
+                    current_support_keys,
+                    &mut stage,
+                    resident_contribution_count,
+                    collect_telemetry,
+                )?;
+            }
+        }
+        if let Some(contact_owner_plan) = plan_established_contact_orbit_owners(
+            stage_current_start,
+            prepared_transitions,
+            currents,
+            *resident_contribution_count,
+        )? {
+            contact_owner_plan.commit(currents, resident_contribution_count);
+        }
+        add_optional_elapsed_nanoseconds(
+            &mut stage.candidate_processing_nanoseconds,
+            candidate_processing_started,
+        );
+        stage.candidate_parent_pair_count = candidate_parent_pair_total;
+        if collect_telemetry {
+            stage.current_insert_count = currents
+                .len()
+                .checked_sub(stage_current_start)
+                .ok_or_else(|| invalid("stage current insertion count underflowed"))?;
+            stage.current_key_clone_count = stage.current_insert_count;
+            stage.current_key_lookup_count = stage
+                .color_result_count
+                .checked_sub(stage.color_target_prune_count)
+                .ok_or_else(|| invalid("stage color-target acceptance count underflowed"))?;
+            stage.current_key_hit_count = stage
+                .current_key_lookup_count
+                .checked_sub(stage.current_insert_count)
+                .ok_or_else(|| invalid("stage current-key hit count underflowed"))?;
+            debug_assert_eq!(stage.accepted_parent_key_clone_count, 0);
+            stage.structural_reject_count = stage
+                .coupling_match_count
+                .checked_sub(stage.transition_accept_count)
+                .ok_or_else(|| invalid("stage structural-reject count underflowed"))?;
+            stage.contribution_insert_count = resident_contribution_count
+                .checked_sub(stage_contribution_start)
+                .ok_or_else(|| invalid("stage contribution insertion count underflowed"))?;
+            stage.contribution_merge_count = stage
+                .contribution_attempt_count
+                .checked_sub(stage.contribution_insert_count)
+                .ok_or_else(|| invalid("stage contribution merge count underflowed"))?;
+        }
+        progress(RecurrenceBuildProgress::snapshot(
+            "recurrence stage",
+            stage_index.saturating_add(1),
+            phase_total,
+            Some(stage_index),
+            reported_stage_total,
+            Some(target_size),
+            stage.candidate_parent_pair_count,
+            Some(candidate_parent_pair_total),
+            currents.len(),
+            *resident_contribution_count,
+            color_states.len(),
+            completed_color_target_prune_count.saturating_add(stage.color_target_prune_count),
+        ))?;
+        // Target-size currents cannot parent another current in this stage, so
+        // their support index is materialized only once after ID reconciliation.
+        debug_assert_eq!(support_buckets.bucket_mut(target_size)?.entry_count, 0);
+        reconcile_stage_reflections(
+            stage_current_start,
+            color_states,
+            currents,
+            current_ids,
+            target_bucket,
+            reflection_certificates,
+            process.external_legs.len(),
+            resident_contribution_count,
+        )?;
+        current_support_keys.reconcile_stage_tail(stage_current_start, currents)?;
+        let support_index_started = telemetry_timer(collect_telemetry);
+        support_buckets.replace_bucket(target_size, target_bucket, current_support_keys)?;
+        add_optional_elapsed_nanoseconds(
+            &mut stage.support_indexing_nanoseconds,
+            support_index_started,
+        );
+        debug_assert_eq!(stage.target_size, target_size);
+        debug_assert_eq!(stage.transition_candidate_count, stage.state_order_count);
+        completed_color_target_prune_count = completed_color_target_prune_count
+            .checked_add(stage.color_target_prune_count)
+            .ok_or_else(|| invalid("recurrence color-target prune count exceeds usize"))?;
+        progress(RecurrenceBuildProgress::snapshot(
+            "recurrence stage",
+            stage_index.saturating_add(1),
+            phase_total,
+            Some(stage_index),
+            reported_stage_total,
+            Some(target_size),
+            stage.candidate_parent_pair_count,
+            Some(candidate_parent_pair_total),
+            currents.len(),
+            *resident_contribution_count,
+            color_states.len(),
+            completed_color_target_prune_count,
+        ))?;
+        if collect_telemetry {
+            telemetry.include_stage(&stage)?;
+        }
+        diagnostics.push(stage);
+    }
+    Ok(diagnostics)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn add_transition_contributions(
+    catalog_digest: SemanticDigest,
+    prepared: &PreparedTransition,
+    parent_ids: [u32; 2],
+    support_key: &TransientSupportKey,
+    merged_support_source_slots: &mut Option<Vec<u32>>,
+    propagate_result: bool,
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+    template: &OwnedRecurrenceTemplateInput,
+    fermion_ordering: &FermionOrderingContext,
+    transition_reflections: &TransitionReflectionIndex,
+    coupling_limits: &[Option<u32>],
+    propagators: &BTreeMap<u32, Option<u32>>,
+    color_targets: &MaterializedColorTargets,
+    structural_demands: &StructuralDemandIndex,
+    color_states: &mut DynamicLCColorStateInterner,
+    currents: &mut Vec<PendingCurrent>,
+    current_ids: &mut TransientCurrentIdIndex,
+    target_bucket: &mut Vec<u32>,
+    current_support_keys: &mut TransientCurrentSupportKeys,
+    diagnostics: &mut StageConstructionDiagnostics,
+    resident_contribution_count: &mut usize,
+    collect_telemetry: bool,
+) -> RusticolResult<()> {
+    let transition = prepared.row;
+    let quantum = prepared.quantum;
+    let coupling_orders = {
+        let parents = [
+            &currents[parent_ids[0] as usize].key,
+            &currents[parent_ids[1] as usize].key,
+        ];
+        if let Some(contact_orbit) = prepared.contact_orbit.as_ref()
+            && !contact_orbit.accepts_parent_domain(parents)?
+        {
+            return Ok(());
+        }
+        if !prepared.quantum_flow_matches(&parents) {
+            return Ok(());
+        }
+        checked_diagnostic_add(
+            &mut diagnostics.quantum_match_count,
+            1,
+            "recurrence quantum-match count",
+        )?;
+        let Some(coupling_orders) = combined_coupling_orders(
+            parents[0].coupling_orders(),
+            parents[1].coupling_orders(),
+            &prepared.local_coupling_orders,
+            coupling_limits,
+        )?
+        else {
+            return Ok(());
+        };
+        checked_diagnostic_add(
+            &mut diagnostics.coupling_match_count,
+            1,
+            "recurrence coupling-match count",
+        )?;
+        if parents[0].helicity_identity().strategy() != parents[1].helicity_identity().strategy() {
+            return Err(invalid(
+                "cannot merge recurrence helicity identities from different strategies",
+            ));
+        }
+        if !structural_demands.accepts(
+            support_key,
+            transition.result_state_template_id,
+            quantum.result_spin_state,
+        ) {
+            return Ok(());
+        }
+        if collect_telemetry {
+            checked_diagnostic_add(
+                &mut diagnostics.transition_accept_count,
+                1,
+                "recurrence transition-accept count",
+            )?;
+        }
+        coupling_orders
+    };
+    let (evaluator_parent_ids, exchange_factor) = prepared.canonical_evaluator_parents(parent_ids);
+    let output_factor = prepared.output_factor()?;
+    let fermion_factor = fermion_ordering_factor(
+        &template.current_states,
+        [
+            currents[parent_ids[0] as usize]
+                .key
+                .current_state_template_id(),
+            currents[parent_ids[1] as usize]
+                .key
+                .current_state_template_id(),
+        ],
+        [
+            currents[parent_ids[0] as usize].key.support_source_slots(),
+            currents[parent_ids[1] as usize].key.support_source_slots(),
+        ],
+        fermion_ordering,
+    )?;
+    let base_factor = multiply_factors(&[
+        prepared.transition_exact_factor,
+        exchange_factor,
+        prepared.contraction_exact_factor,
+        output_factor,
+        fermion_factor,
+    ])?;
+    let parent_reflections = [
+        currents[parent_ids[0] as usize].reflection.clone(),
+        currents[parent_ids[1] as usize].reflection.clone(),
+    ];
+    let parent_colors = [
+        color_states
+            .get(
+                currents[parent_ids[0] as usize]
+                    .key
+                    .dynamic_lc_color_state_id(),
+            )
+            .ok_or_else(|| invalid("left dynamic color state disappeared"))?
+            .clone(),
+        color_states
+            .get(
+                currents[parent_ids[1] as usize]
+                    .key
+                    .dynamic_lc_color_state_id(),
+            )
+            .ok_or_else(|| invalid("right dynamic color state disappeared"))?
+            .clone(),
+    ];
+    let reversal_masks = current_reversal_masks(&parent_colors, &parent_reflections);
+    let local_reflection_proof = transition_reflections.proof(transition.id);
+    let propagator_template_id = if propagate_result {
+        propagators
+            .get(&transition.result_state_template_id)
+            .copied()
+            .flatten()
+    } else {
+        None
+    };
+    let mut result_core_fields = None;
+
+    for prepared_witness in prepared.witnesses.iter() {
+        let witness_row = prepared_witness.row;
+        if witness_row.left_shape_string_id != parent_colors[0].output_color_shape_id()
+            || witness_row.right_shape_string_id != parent_colors[1].output_color_shape_id()
+        {
+            continue;
+        }
+        checked_diagnostic_add(
+            &mut diagnostics.color_shape_match_count,
+            1,
+            "recurrence color-shape-match count",
+        )?;
+        let witness = &prepared_witness.witness;
+        for reversal_mask in reversal_masks.iter().copied() {
+            let mut variant_colors = parent_colors.clone();
+            let mut reversal_factor = ExactComplexRational::ONE;
+            for index in 0..2 {
+                if reversal_mask & (1 << index) == 0 {
+                    continue;
+                }
+                variant_colors[index] = variant_colors[index].reversed()?;
+                reversal_factor = reversal_factor.checked_mul(
+                    parent_reflections[index]
+                        .phase()
+                        .expect("reversal mask requires a proven parent phase"),
+                )?;
+            }
+            let Some(result_color) = witness.apply(&variant_colors[0], &variant_colors[1])? else {
+                continue;
+            };
+            checked_diagnostic_add(
+                &mut diagnostics.color_result_count,
+                1,
+                "recurrence color-result count",
+            )?;
+            if !color_targets.accepts_up_to_reflection(&result_color)? {
+                checked_diagnostic_add(
+                    &mut diagnostics.color_target_prune_count,
+                    1,
+                    "recurrence color-target prune count",
+                )?;
+                continue;
+            }
+            let result_reflection = current_reflection_candidate(
+                &result_color,
+                &parent_reflections,
+                local_reflection_proof,
+            )?;
+            #[cfg(feature = "on-the-fly-test-support")]
+            let diagnostic_result_reflection = result_reflection.clone();
+            let result_color_id = color_states.intern(result_color)?;
+            if merged_support_source_slots.is_none() {
+                *merged_support_source_slots = Some(merged_disjoint_support(
+                    currents[parent_ids[0] as usize].key.support_source_slots(),
+                    currents[parent_ids[1] as usize].key.support_source_slots(),
+                ));
+            }
+            let support_source_slots = merged_support_source_slots
+                .as_ref()
+                .expect("merged support was initialized after color acceptance");
+            debug_assert_eq!(support_source_slots.len(), support_key.cardinality());
+            if result_core_fields.is_none() {
+                let parents = [
+                    &currents[parent_ids[0] as usize].key,
+                    &currents[parent_ids[1] as usize].key,
+                ];
+                result_core_fields = Some((
+                    merged_helicity_identity(
+                        parents[0].helicity_identity(),
+                        parents[1].helicity_identity(),
+                        quantum.result_spin_state,
+                    )?,
+                    prepared.result_flavour_flow(&parents),
+                    merged_momentum(parents[0].momentum(), parents[1].momentum())?,
+                ));
+            }
+            let (helicity_identity, result_flavour_flow, result_momentum) = result_core_fields
+                .as_ref()
+                .expect("result current fields were initialized after color acceptance");
+            let key = CurrentCoreKey::new(
+                catalog_digest,
+                RecurrenceNodeKind::Current,
+                transition.result_state_template_id,
+                result_color_id,
+                support_source_slots.to_vec(),
+                result_momentum.clone(),
+                helicity_identity.clone(),
+                result_flavour_flow.clone(),
+                quantum.result_quantum_number_flow_id,
+                coupling_orders.clone(),
+                CurrentSourceBinding::None,
+                propagator_template_id,
+            )?;
+            let realized_pairing_rule_ids = realized_pairing_rules_for_transition(
+                compatible_pairing_rules_for_current(
+                    pairing_catalog,
+                    template,
+                    transition.result_state_template_id,
+                    key.support_source_slots(),
+                )?,
+                [
+                    &currents[parent_ids[0] as usize].realized_pairing_rule_ids,
+                    &currents[parent_ids[1] as usize].realized_pairing_rule_ids,
+                ],
+            );
+            let result_id = if let Some(id) = current_ids.get(&key).copied() {
+                debug_assert_eq!(
+                    current_support_keys
+                        .get(id)
+                        .expect("existing current has a transient support key"),
+                    support_key
+                );
+                currents[id as usize]
+                    .reflection
+                    .include(result_reflection)?;
+                currents[id as usize]
+                    .realized_pairing_rule_ids
+                    .extend(realized_pairing_rule_ids);
+                id
+            } else {
+                let id = u32::try_from(currents.len())
+                    .map_err(|_| invalid("recurrence current count exceeds u32"))?;
+                current_ids.insert(key.clone(), id);
+                currents.push(PendingCurrent {
+                    key,
+                    source_exact_factor: None,
+                    contributions: BTreeMap::new(),
+                    realized_pairing_rule_ids,
+                    reflection: result_reflection
+                        .map_or(CurrentReflection::Unavailable, CurrentReflection::Proven),
+                    reflection_certificate_id: None,
+                });
+                target_bucket.push(id);
+                current_support_keys.push(id, support_key.clone())?;
+                id
+            };
+            let contribution_key = ContributionKey::new(
+                transition.id,
+                evaluator_parent_ids.to_vec(),
+                evaluator_parent_ids
+                    .iter()
+                    .map(|id| currents[*id as usize].key.current_state_template_id())
+                    .collect(),
+                evaluator_parent_ids
+                    .iter()
+                    .map(|id| currents[*id as usize].key.momentum().clone())
+                    .collect(),
+                transition.result_state_template_id,
+                quantum.id,
+                LCColorWitnessTermId::new(
+                    transition.color_contraction_template_id,
+                    witness_row.ordinal,
+                ),
+                prepared.quantum_semantic_digest,
+                transition.output_projection_string_id,
+            )?;
+            let pending_key = PendingContributionKey {
+                parent_current_ids: evaluator_parent_ids.into(),
+                key: contribution_key,
+            };
+            let factor = base_factor
+                .checked_mul(witness.exact_factor())?
+                .checked_mul(reversal_factor)?;
+            let pending_factor = match currents[result_id as usize]
+                .contributions
+                .entry(pending_key)
+            {
+                std::collections::btree_map::Entry::Occupied(entry) => entry.into_mut(),
+                std::collections::btree_map::Entry::Vacant(entry) => {
+                    checked_diagnostic_add(
+                        resident_contribution_count,
+                        1,
+                        "resident recurrence contribution count",
+                    )?;
+                    entry.insert(ExactComplexRational::ZERO)
+                }
+            };
+            aggregate_factor(pending_factor, factor)?;
+            #[cfg(feature = "on-the-fly-test-support")]
+            let aggregate_factor_after = *pending_factor;
+            checked_diagnostic_add(
+                &mut diagnostics.contribution_attempt_count,
+                1,
+                "recurrence contribution-attempt count",
+            )?;
+            #[cfg(feature = "on-the-fly-test-support")]
+            'transition_diagnostic: {
+                if !super::diagnostic::transition_diagnostic_observation_active() {
+                    break 'transition_diagnostic;
+                }
+                use super::diagnostic::{
+                    ConstructionTransitionDiagnosticRowV1, observe_transition_diagnostic,
+                };
+
+                let digest = |current_id: u32| -> RusticolResult<SemanticDigest> {
+                    let current = currents
+                        .get(current_id as usize)
+                        .ok_or_else(|| invalid("diagnostic current is absent"))?;
+                    let color = color_states
+                        .get(current.key.dynamic_lc_color_state_id())
+                        .ok_or_else(|| invalid("diagnostic current color is absent"))?;
+                    super::on_the_fly::hash_current_key(&current.key, color)
+                };
+                let result_color = color_states
+                    .get(currents[result_id as usize].key.dynamic_lc_color_state_id())
+                    .ok_or_else(|| invalid("diagnostic result color is absent"))?;
+                observe_transition_diagnostic(ConstructionTransitionDiagnosticRowV1 {
+                    materialized_sector_id: None,
+                    output_current_digest: digest(result_id)?,
+                    ordered_parent_digests: [
+                        digest(evaluator_parent_ids[0])?,
+                        digest(evaluator_parent_ids[1])?,
+                    ],
+                    transition_template_id: transition.id,
+                    transition_semantic_digest: prepared.transition_semantic_digest,
+                    evaluator_binding_semantic_digest: prepared.evaluator_binding_semantic_digest,
+                    result_state_template_id: transition.result_state_template_id,
+                    quantum_flow_witness_id: quantum.id,
+                    quantum_semantic_digest: prepared.quantum_semantic_digest,
+                    color_contraction_template_id: transition.color_contraction_template_id,
+                    color_witness_ordinal: witness_row.ordinal,
+                    color_witness_proof_digest: witness.proof_digest(),
+                    output_projection_id: transition.output_projection_string_id,
+                    transition_factor: prepared.transition_exact_factor,
+                    contraction_factor: prepared.contraction_exact_factor,
+                    output_factor,
+                    exchange_factor,
+                    witness_factor: witness.exact_factor(),
+                    reversal_mask,
+                    reversal_factor,
+                    candidate_factor: factor,
+                    aggregate_factor_after,
+                    parent_reflection_proof_digests: [
+                        parent_reflections[0]
+                            .proof()
+                            .map(CurrentReflectionProof::proof_digest),
+                        parent_reflections[1]
+                            .proof()
+                            .map(CurrentReflectionProof::proof_digest),
+                    ],
+                    parent_reflection_phases: [
+                        parent_reflections[0].phase(),
+                        parent_reflections[1].phase(),
+                    ],
+                    local_reflection_proof_digest: local_reflection_proof
+                        .map(|proof| proof.proof_digest),
+                    local_reflection_phase: local_reflection_proof
+                        .map(TransitionReflectionProof::phase),
+                    result_reflection_proof_digest: diagnostic_result_reflection
+                        .as_ref()
+                        .map(CurrentReflectionProof::proof_digest),
+                    result_reflection_phase: diagnostic_result_reflection
+                        .as_ref()
+                        .map(CurrentReflectionProof::phase),
+                    output_color_orientation: format!("{result_color:?}"),
+                });
+            }
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn current_key_with_dynamic_color(
+    key: &CurrentCoreKey,
+    dynamic_lc_color_state_id: DynamicLCColorStateId,
+) -> RusticolResult<CurrentCoreKey> {
+    CurrentCoreKey::new(
+        key.catalog_digest(),
+        key.node_kind(),
+        key.current_state_template_id(),
+        dynamic_lc_color_state_id,
+        key.support_source_slots().to_vec(),
+        key.momentum().clone(),
+        key.helicity_identity().clone(),
+        key.flavour_flow().to_vec(),
+        key.quantum_number_flow_id(),
+        key.coupling_orders().to_vec(),
+        key.source_binding().clone(),
+        key.propagator_template_id(),
+    )
+}
+
+pub(super) fn reciprocal_reflection_proof(
+    left: &CurrentReflection,
+    right: &CurrentReflection,
+) -> RusticolResult<bool> {
+    let (Some(left), Some(right)) = (left.phase(), right.phase()) else {
+        return Ok(false);
+    };
+    Ok(left.checked_mul(right)? == ExactComplexRational::ONE)
+}
+
+/// Finalize pure-adjoint reflection aliases after every contribution to the
+/// stage's currents has been seen.
+///
+/// A contribution that lacks a reflection proof downgrades the whole current.
+/// Both orientations are then retained as exact residual states. Only a pair
+/// with reciprocal, complete fan-in proofs is compacted to its canonical
+/// orientation. Stage currents cannot depend on one another, so compacting the
+/// stage tail cannot invalidate any stored parent current ID.
+#[allow(clippy::too_many_arguments)]
+fn reconcile_stage_reflections(
+    stage_start: usize,
+    color_states: &mut DynamicLCColorStateInterner,
+    currents: &mut Vec<PendingCurrent>,
+    current_ids: &mut TransientCurrentIdIndex,
+    target_bucket: &mut Vec<u32>,
+    reflection_certificates: &mut Vec<PendingReflectionCertificate>,
+    source_count: usize,
+    resident_contribution_count: &mut usize,
+) -> RusticolResult<()> {
+    if stage_start > currents.len() {
+        return Err(invalid(
+            "recurrence reflection stage starts beyond current storage",
+        ));
+    }
+    let stage_end = currents.len();
+    let mut visited = vec![false; stage_end - stage_start];
+    let mut prune = vec![false; stage_end - stage_start];
+
+    for current_index in stage_start..stage_end {
+        let local_index = current_index - stage_start;
+        if visited[local_index] {
+            continue;
+        }
+        let key = currents[current_index].key.clone();
+        let color = color_states
+            .get(key.dynamic_lc_color_state_id())
+            .ok_or_else(|| invalid("reflection current color state disappeared"))?
+            .clone();
+        let Some(word) = color.pure_adjoint_word() else {
+            continue;
+        };
+        if word.len() < 2 {
+            continue;
+        }
+        let canonical = pure_adjoint_word_is_canonical(word);
+        let reversed_color_id = color_states.intern(color.reversed()?)?;
+        if reversed_color_id == key.dynamic_lc_color_state_id() {
+            currents[current_index].reflection = CurrentReflection::Unavailable;
+            continue;
+        }
+        let reversed_key = current_key_with_dynamic_color(&key, reversed_color_id)?;
+        let Some(reversed_id) = current_ids.get(&reversed_key).copied() else {
+            currents[current_index].reflection = CurrentReflection::Unavailable;
+            continue;
+        };
+        let reversed_index = reversed_id as usize;
+        if !(stage_start..stage_end).contains(&reversed_index) {
+            currents[current_index].reflection = CurrentReflection::Unavailable;
+            continue;
+        }
+        let reversed_local_index = reversed_index - stage_start;
+        visited[local_index] = true;
+        visited[reversed_local_index] = true;
+
+        let reversed_color = color_states
+            .get(reversed_color_id)
+            .ok_or_else(|| invalid("reversed reflection color state disappeared"))?;
+        let Some(reversed_word) = reversed_color.pure_adjoint_word() else {
+            currents[current_index].reflection = CurrentReflection::Unavailable;
+            currents[reversed_index].reflection = CurrentReflection::Unavailable;
+            continue;
+        };
+        let reversed_canonical = pure_adjoint_word_is_canonical(reversed_word);
+        let proof_is_complete = reciprocal_reflection_proof(
+            &currents[current_index].reflection,
+            &currents[reversed_index].reflection,
+        )?;
+        if !proof_is_complete || canonical == reversed_canonical {
+            currents[current_index].reflection = CurrentReflection::Unavailable;
+            currents[reversed_index].reflection = CurrentReflection::Unavailable;
+            continue;
+        }
+        let (canonical_index, reflected_index, pruned_local_index) = if canonical {
+            (current_index, reversed_index, reversed_local_index)
+        } else {
+            (reversed_index, current_index, local_index)
+        };
+        let canonical_proof = currents[canonical_index]
+            .reflection
+            .proof()
+            .cloned()
+            .ok_or_else(|| invalid("canonical reflection proof disappeared"))?;
+        let reflected_proof = currents[reflected_index]
+            .reflection
+            .proof()
+            .cloned()
+            .ok_or_else(|| invalid("reflected reflection proof disappeared"))?;
+        for (label, current_index, proof) in [
+            ("canonical", canonical_index, &canonical_proof),
+            ("reflected", reflected_index, &reflected_proof),
+        ] {
+            let current_color = color_states
+                .get(currents[current_index].key.dynamic_lc_color_state_id())
+                .ok_or_else(|| invalid(format!("{label} reflection color disappeared")))?;
+            if dynamic_color_identity_digest(current_color)? != proof.result_color_identity() {
+                return Err(invalid(format!(
+                    "{label} reflection proof carries a stale dynamic color identity"
+                )));
+            }
+        }
+        let certificate_id = u32::try_from(reflection_certificates.len())
+            .map_err(|_| invalid("pending reflection certificate count exceeds u32"))?;
+        reflection_certificates.push(PendingReflectionCertificate::reciprocal_pair(
+            certificate_id,
+            u32::try_from(canonical_index)
+                .map_err(|_| invalid("canonical reflection current ID exceeds u32"))?,
+            u32::try_from(reflected_index)
+                .map_err(|_| invalid("reflected reflection current ID exceeds u32"))?,
+            &canonical_proof,
+            &reflected_proof,
+            current_color_for_index(color_states, currents, canonical_index)?,
+            current_color_for_index(color_states, currents, reflected_index)?,
+            source_count,
+        )?);
+        currents[canonical_index].reflection_certificate_id = Some(certificate_id);
+        prune[pruned_local_index] = true;
+    }
+
+    for current in &currents[stage_start..] {
+        current_ids.remove(&current.key);
+    }
+    let stage_currents = currents.split_off(stage_start);
+    target_bucket.clear();
+    for (local_index, current) in stage_currents.into_iter().enumerate() {
+        if prune[local_index] {
+            *resident_contribution_count = resident_contribution_count
+                .checked_sub(current.contributions.len())
+                .ok_or_else(|| invalid("resident recurrence contribution count underflowed"))?;
+            continue;
+        }
+        if current
+            .contributions
+            .keys()
+            .flat_map(|contribution| contribution.parent_current_ids.iter().copied())
+            .any(|parent_id| parent_id as usize >= stage_start)
+        {
+            return Err(invalid(
+                "recurrence stage current depends on another current in the same stage",
+            ));
+        }
+        let current_id = u32::try_from(currents.len())
+            .map_err(|_| invalid("recurrence current count exceeds u32"))?;
+        if current_ids
+            .insert(current.key.clone(), current_id)
+            .is_some()
+        {
+            return Err(invalid(
+                "recurrence reflection reconciliation produced a duplicate current",
+            ));
+        }
+        target_bucket.push(current_id);
+        currents.push(current);
+    }
+    Ok(())
+}
+
+pub(super) fn current_reversal_masks(
+    colors: &[DynamicLCColorState; 2],
+    reflections: &[CurrentReflection; 2],
+) -> Vec<u8> {
+    let mut masks = vec![0_u8];
+    for index in 0..2 {
+        if reflections[index].phase().is_none()
+            || colors[index]
+                .pure_adjoint_word()
+                .is_none_or(|word| word.len() < 2)
+        {
+            continue;
+        }
+        let bit = 1_u8 << index;
+        masks.extend(masks.clone().into_iter().map(|mask| mask | bit));
+    }
+    masks
+}
+
+pub(super) fn current_reflection_candidate(
+    result_color: &DynamicLCColorState,
+    parent_reflections: &[CurrentReflection; 2],
+    local_proof: Option<&TransitionReflectionProof>,
+) -> RusticolResult<Option<CurrentReflectionProof>> {
+    if result_color.pure_adjoint_word().is_none() {
+        return Ok(None);
+    }
+    let Some(local_proof) = local_proof else {
+        return Ok(None);
+    };
+    let Some(left) = parent_reflections[0].proof() else {
+        return Ok(None);
+    };
+    let Some(right) = parent_reflections[1].proof() else {
+        return Ok(None);
+    };
+    let phase = left
+        .phase()
+        .checked_mul(right.phase())?
+        .checked_mul(local_proof.phase())?;
+    let color_identity = dynamic_color_identity_digest(result_color)?;
+    CurrentReflectionProof::new(
+        phase,
+        left.lineage_roots()
+            .iter()
+            .copied()
+            .chain(right.lineage_roots().iter().copied())
+            .chain(local_proof.lineage_roots()),
+        color_identity,
+    )
+    .map(Some)
+}
+
+pub(super) fn pure_adjoint_word_is_canonical(word: &[u32]) -> bool {
+    if word.len() < 2 {
+        return true;
+    }
+    let (minimum_index, _) = word
+        .iter()
+        .enumerate()
+        .min_by_key(|(_, slot)| *slot)
+        .expect("nonempty pure-adjoint word");
+    let (maximum_index, _) = word
+        .iter()
+        .enumerate()
+        .max_by_key(|(_, slot)| *slot)
+        .expect("nonempty pure-adjoint word");
+    minimum_index < maximum_index
+}
+
+fn two_parent_permutation(
+    construction_parent_ids: [u32; 2],
+    ordered_parent_ids: [u32; 2],
+    label: &str,
+) -> RusticolResult<[u32; 2]> {
+    if construction_parent_ids[0] == construction_parent_ids[1] {
+        return Err(invalid(format!(
+            "{label} cannot derive a permutation from duplicate parent IDs"
+        )));
+    }
+    let mut result = [0_u32; 2];
+    for (target, parent_id) in ordered_parent_ids.into_iter().enumerate() {
+        let source = construction_parent_ids
+            .iter()
+            .position(|candidate| *candidate == parent_id)
+            .ok_or_else(|| invalid(format!("{label} references a foreign parent ID")))?;
+        result[target] =
+            u32::try_from(source).map_err(|_| invalid(format!("{label} index exceeds u32")))?;
+    }
+    if result[0] == result[1] {
+        return Err(invalid(format!("{label} is not a permutation")));
+    }
+    Ok(result)
+}
+
+fn three_line_traversal_certificate(
+    closed: &[LCColorComponent],
+    sector: ProcessPhysicalLCSectorRow,
+    expected: &[LCColorComponent],
+    catalog: &ProcessCatalog<'_>,
+    pairing_rule_id: Option<u32>,
+) -> RusticolResult<Option<PendingThreeLineTraversalCertificate>> {
+    if sector.kind()? != ProcessLCSectorKind::OpenLines || sector.open_string_range.count != 3 {
+        return Ok(None);
+    }
+    let pairing_rule_id = pairing_rule_id
+        .ok_or_else(|| invalid("three-line traversal lacks a physical fermion pairing rule"))?;
+    if expected.len() != 3 || closed.len() != 3 {
+        return Err(invalid(
+            "three-line closure does not contain exactly three complete line blocks",
+        ));
+    }
+    let blocks = expected
+        .iter()
+        .map(|component| component.source_slots().to_vec())
+        .collect::<Vec<_>>();
+    let sector_word = catalog.u32_sequence(sector.word_sequence_id, "three-line sector word")?;
+    let mut reference_order = Vec::<u32>::with_capacity(3);
+    let mut used_reference = [false; 3];
+    let mut offset = 0usize;
+    while offset < sector_word.len() {
+        let matches = blocks
+            .iter()
+            .enumerate()
+            .filter_map(|(index, block)| {
+                (!used_reference[index] && sector_word[offset..].starts_with(block))
+                    .then_some(index)
+            })
+            .collect::<Vec<_>>();
+        let [block_index] = matches.as_slice() else {
+            return Err(invalid(
+                "three-line sector word is not an unambiguous concatenation of its line blocks",
+            ));
+        };
+        used_reference[*block_index] = true;
+        reference_order.push(
+            u32::try_from(*block_index)
+                .map_err(|_| invalid("three-line block index exceeds u32"))?,
+        );
+        offset = offset
+            .checked_add(blocks[*block_index].len())
+            .ok_or_else(|| invalid("three-line sector word offset overflows"))?;
+    }
+    if reference_order.len() != 3 || offset != sector_word.len() {
+        return Err(invalid(
+            "three-line sector word does not cover exactly three line blocks",
+        ));
+    }
+    let mut used = [false; 3];
+    let mut witness_order = Vec::<u32>::with_capacity(3);
+    for component in closed {
+        let index = expected
+            .iter()
+            .enumerate()
+            .find_map(|(index, candidate)| {
+                (!used[index] && candidate == component).then_some(index)
+            })
+            .ok_or_else(|| invalid("three-line closure contains a foreign line block"))?;
+        used[index] = true;
+        witness_order
+            .push(u32::try_from(index).map_err(|_| invalid("three-line index exceeds u32"))?);
+    }
+    let sink_candidates = expected
+        .iter()
+        .enumerate()
+        .filter_map(|(index, component)| {
+            (component.source_slots().last() == Some(&sector.closure_source_slot)).then_some(index)
+        })
+        .collect::<Vec<_>>();
+    let [sink_index] = sink_candidates.as_slice() else {
+        return Err(invalid(
+            "three-line closure anchor does not identify exactly one line block",
+        ));
+    };
+    let sink_index =
+        u32::try_from(*sink_index).map_err(|_| invalid("three-line sink index exceeds u32"))?;
+    let rotate_sink_last = |order: &mut Vec<u32>| -> RusticolResult<()> {
+        let sink_position = order
+            .iter()
+            .position(|index| *index == sink_index)
+            .ok_or_else(|| invalid("three-line closure traversal omits its anchor block"))?;
+        let order_len = order.len();
+        order.rotate_left((sink_position + 1) % order_len);
+        Ok(())
+    };
+    rotate_sink_last(&mut reference_order)?;
+    rotate_sink_last(&mut witness_order)?;
+    let kind = if witness_order == reference_order {
+        THREE_LINE_DIRECT_CERTIFICATE_ID as u8
+    } else {
+        let mut partner = reference_order.clone();
+        partner.swap(0, 1);
+        if witness_order != partner {
+            return Err(invalid(
+                "three-line closure traversal is neither the direct nor partner cyclic obligation",
+            ));
+        }
+        THREE_LINE_PARTNER_CERTIFICATE_ID as u8
+    };
+    let block_permutation = witness_order
+        .iter()
+        .map(|block| {
+            reference_order
+                .iter()
+                .position(|candidate| candidate == block)
+                .map(|position| {
+                    u32::try_from(position)
+                        .map_err(|_| invalid("three-line block permutation exceeds u32"))
+                })
+                .transpose()?
+                .ok_or_else(|| invalid("three-line witness references a foreign block"))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let flatten = |order: &[u32]| -> RusticolResult<Vec<u32>> {
+        let mut sources = Vec::new();
+        for block_index in order {
+            sources.extend_from_slice(
+                blocks
+                    .get(*block_index as usize)
+                    .ok_or_else(|| invalid("three-line block order is out of range"))?,
+            );
+        }
+        Ok(sources)
+    };
+    let reference_source_order = flatten(&reference_order)?;
+    let witness_source_order = flatten(&witness_order)?;
+    let source_position_permutation = witness_source_order
+        .iter()
+        .map(|source| {
+            reference_source_order
+                .iter()
+                .position(|candidate| candidate == source)
+                .map(|position| {
+                    u32::try_from(position)
+                        .map_err(|_| invalid("three-line source permutation exceeds u32"))
+                })
+                .transpose()?
+                .ok_or_else(|| invalid("three-line witness references a foreign source"))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-three-line-traversal-v1\0");
+    hash.update(sector.sector_id.to_le_bytes());
+    hash.update([kind]);
+    hash.update(sink_index.to_le_bytes());
+    for values in [
+        reference_order.as_slice(),
+        witness_order.as_slice(),
+        block_permutation.as_slice(),
+        reference_source_order.as_slice(),
+        witness_source_order.as_slice(),
+        source_position_permutation.as_slice(),
+    ] {
+        hash.update(
+            u64::try_from(values.len())
+                .map_err(|_| invalid("three-line certificate sequence length exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for value in values {
+            hash.update(value.to_le_bytes());
+        }
+    }
+    hash.update(sector.closure_source_slot.to_le_bytes());
+    hash.update(pairing_rule_id.to_le_bytes());
+    let proof_digest = SemanticDigest::new(hash.finalize().into())?;
+    Ok(Some(PendingThreeLineTraversalCertificate {
+        sector_id: sector.sector_id,
+        kind,
+        sink_block_ordinal: sink_index,
+        reference_block_order: reference_order.into_boxed_slice(),
+        witness_block_order: witness_order.into_boxed_slice(),
+        block_permutation: block_permutation.into_boxed_slice(),
+        reference_source_order: reference_source_order.into_boxed_slice(),
+        witness_source_order: witness_source_order.into_boxed_slice(),
+        source_position_permutation: source_position_permutation.into_boxed_slice(),
+        closure_anchor_source_slot: sector.closure_source_slot,
+        pairing_rule_id,
+        proof_digest,
+    }))
+}
+
+fn closure_pairing_certificate_ids(
+    currents: &[PendingCurrent],
+    parent_ids: [u32; 2],
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+) -> RusticolResult<Vec<u32>> {
+    let left = currents
+        .get(parent_ids[0] as usize)
+        .ok_or_else(|| invalid("closure pairing proof left parent is absent"))?;
+    let right = currents
+        .get(parent_ids[1] as usize)
+        .ok_or_else(|| invalid("closure pairing proof right parent is absent"))?;
+    let realized = left
+        .realized_pairing_rule_ids
+        .intersection(&right.realized_pairing_rule_ids)
+        .copied()
+        .collect::<BTreeSet<_>>();
+    match pairing_catalog {
+        None if realized.is_empty() => Ok(Vec::new()),
+        None => Err(invalid(
+            "closure realizes fermion pairings without a pairing catalog",
+        )),
+        Some(catalog) => canonical_pairing_owner_id(realized.into_iter().map(|rule_id| {
+            let rule = catalog
+                .rules()
+                .get(rule_id as usize)
+                .copied()
+                .filter(|rule| rule.rule_id == rule_id)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "closure parent lineage references absent pairing rule {rule_id}"
+                    ))
+                })?;
+            Ok((rule_id, catalog.endpoint_pairings(rule)?))
+        }))?
+        .map(|rule_id| vec![rule_id])
+        .ok_or_else(|| invalid("closure parent lineage realizes no fermion pairing rule")),
+    }
+}
+
+fn canonical_pairing_owner_id<'a>(
+    candidates: impl IntoIterator<Item = RusticolResult<(u32, &'a [FermionPairingEndpointPairRow])>>,
+) -> RusticolResult<Option<u32>> {
+    let mut selected = None::<(u32, &'a [FermionPairingEndpointPairRow])>;
+    for candidate in candidates {
+        let (rule_id, endpoint_pairs) = candidate?;
+        let candidate_precedes_selected = selected.is_none_or(|(selected_id, selected_pairs)| {
+            endpoint_pairs
+                .iter()
+                .map(|pair| {
+                    (
+                        pair.fundamental_source_slot,
+                        pair.antifundamental_source_slot,
+                    )
+                })
+                .cmp(selected_pairs.iter().map(|pair| {
+                    (
+                        pair.fundamental_source_slot,
+                        pair.antifundamental_source_slot,
+                    )
+                }))
+                .then_with(|| rule_id.cmp(&selected_id))
+                .is_lt()
+        });
+        if candidate_precedes_selected {
+            selected = Some((rule_id, endpoint_pairs));
+        }
+    }
+    Ok(selected.map(|(rule_id, _)| rule_id))
+}
+
+fn pairing_rule_for_certificate(
+    certificate_ids: &[u32],
+    catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+) -> RusticolResult<Option<FermionPairingRuleRow>> {
+    let Some(catalog) = catalog else {
+        if !certificate_ids.is_empty() {
+            return Err(invalid(
+                "closure pairing certificate has no pairing catalog",
+            ));
+        }
+        return Ok(None);
+    };
+    let [rule_id] = certificate_ids else {
+        return Err(invalid(
+            "closure requires exactly one fermion pairing certificate",
+        ));
+    };
+    catalog
+        .rules()
+        .iter()
+        .copied()
+        .find(|rule| rule.rule_id == *rule_id)
+        .map(Some)
+        .ok_or_else(|| invalid(format!("closure references absent pairing rule {rule_id}")))
+}
+
+fn pairing_reconstruction_factor(_rule: Option<FermionPairingRuleRow>) -> ExactComplexRational {
+    // Canonical color-line construction already carries the exchange parity
+    // of colored Wick lineages.  The exterior-algebra pass separately owns
+    // color-singlet fermions, so multiplying pairing parity here would count
+    // the colored sign twice.
+    ExactComplexRational::ONE
+}
+
+// Closure certification deliberately receives each authenticated catalog and
+// proof table separately so that no unchecked aggregate can cross this boundary.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct ClosureReflectionProjection {
+    certificate_id: u32,
+    partner_sector_id: Option<u32>,
+    partner_phase: ExactComplexRational,
+}
+
+#[allow(clippy::too_many_arguments)]
+fn closure_reflection_projection(
+    sector: ProcessPhysicalLCSectorRow,
+    closed: &[LCColorComponent],
+    process: &OwnedRecurrenceProcessInput,
+    process_catalog: &ProcessCatalog<'_>,
+    color_states: &DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+    parent_ids: [u32; 2],
+    certificates: &[PendingReflectionCertificate],
+    prepared_sectors: &PreparedClosureSectorCatalog,
+    materialized_sectors: &BTreeSet<u32>,
+) -> RusticolResult<Option<ClosureReflectionProjection>> {
+    let mut certified_parents = Vec::new();
+    for parent_id in parent_ids {
+        let current = currents
+            .get(parent_id as usize)
+            .ok_or_else(|| invalid("closure reflection parent is absent"))?;
+        let Some(certificate_id) = current.reflection_certificate_id else {
+            continue;
+        };
+        let certificate = certificates
+            .get(certificate_id as usize)
+            .filter(|certificate| certificate.id == certificate_id)
+            .ok_or_else(|| invalid("closure reflection certificate is absent"))?;
+        let proof = current
+            .reflection
+            .proof()
+            .ok_or_else(|| invalid("certified closure reflection parent has no lineage proof"))?;
+        if proof.proof_digest() != certificate.canonical_lineage_digest {
+            return Err(invalid(
+                "closure reflection parent lineage does not match its certificate",
+            ));
+        }
+        let color = color_states
+            .get(current.key.dynamic_lc_color_state_id())
+            .ok_or_else(|| invalid("closure reflection parent color is absent"))?;
+        if dynamic_color_identity_digest(color)? != certificate.canonical_color_identity {
+            return Err(invalid(
+                "closure reflection parent color does not match its certificate",
+            ));
+        }
+        certified_parents.push(certificate_id);
+    }
+    match certified_parents.len() {
+        0 => return Ok(None),
+        1 => {}
+        _ => {
+            return Err(invalid(
+                "one closure references multiple folded reflection orbits",
+            ));
+        }
+    }
+    if sector.kind()? != ProcessLCSectorKind::SingleTrace {
+        return Ok(None);
+    }
+    let construction_word =
+        process_catalog.u32_sequence(sector.word_sequence_id, "reflection construction word")?;
+    if construction_word.len() <= 2 {
+        return Ok(None);
+    }
+    let [closed_trace] = closed else {
+        return Ok(None);
+    };
+    if closed_trace.kind() != LCColorComponentKind::Trace
+        || closed_trace.source_slots().len() != construction_word.len()
+    {
+        return Ok(None);
+    }
+    let certificate_id = certified_parents[0];
+    let certificate = certificates
+        .get(certificate_id as usize)
+        .filter(|certificate| certificate.id == certificate_id)
+        .ok_or_else(|| invalid("closure reflection certificate is absent"))?;
+    if certificate.fixed_point
+        || certificate.orbit_size != 2
+        || certificate.canonical_color_identity == certificate.reflected_color_identity
+    {
+        return Err(invalid(
+            "closure reflection certificate does not describe a reciprocal two-cycle",
+        ));
+    }
+    let mapped_word = construction_word
+        .iter()
+        .map(|source_slot| {
+            certificate
+                .source_permutation
+                .get(*source_slot as usize)
+                .copied()
+                .ok_or_else(|| {
+                    invalid("closure reflection permutation does not cover its trace word")
+                })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    if cyclic_words_equal(construction_word, &mapped_word) {
+        return Err(invalid(
+            "closure reflection maps a trace to a cyclic fixed point",
+        ));
+    }
+    let closure_algorithm = process_catalog.string(
+        sector.closure_proof_algorithm_string_id,
+        "reflection closure-anchor algorithm",
+    )?;
+    if closure_algorithm == CYCLIC_TRACE_CLOSURE_ANCHOR_ALGORITHM
+        && let Some(partner_sector_id) =
+            prepared_sectors.reflected_v4_sector(&mapped_word, sector.closure_source_slot)?
+        && materialized_sectors.contains(&partner_sector_id)
+    {
+        if partner_sector_id == sector.sector_id {
+            return Err(invalid(
+                "closure reflection maps a v4 trace sector onto itself",
+            ));
+        }
+        return Ok(Some(ClosureReflectionProjection {
+            certificate_id,
+            partner_sector_id: Some(partner_sector_id),
+            partner_phase: certificate.canonical_phase,
+        }));
+    }
+
+    let mut matching_public_flows = Vec::new();
+    for flow in retained_public_flows(process)?
+        .into_iter()
+        .filter(|flow| flow.construction_sector_id == sector.sector_id)
+    {
+        let word =
+            process_catalog.u32_sequence(flow.word_sequence_id, "reflected public LC flow")?;
+        if cyclic_words_equal(word, &mapped_word) {
+            matching_public_flows.push(flow.flow_id);
+        }
+    }
+    match matching_public_flows.as_slice() {
+        [_] => Ok(Some(ClosureReflectionProjection {
+            certificate_id,
+            partner_sector_id: None,
+            partner_phase: certificate.canonical_phase,
+        })),
+        [] => Ok(None),
+        _ => Err(invalid(
+            "closure reflection maps to multiple retained public LC flows",
+        )),
+    }
+}
+
+fn cyclic_words_equal(left: &[u32], right: &[u32]) -> bool {
+    if left.len() != right.len() {
+        return false;
+    }
+    if left.is_empty() {
+        return true;
+    }
+    (0..left.len()).any(|offset| {
+        left.iter()
+            .enumerate()
+            .all(|(index, value)| *value == right[(index + offset) % right.len()])
+    })
+}
+
+fn anchored_cyclic_trace_word(word: &[u32], anchor: u32) -> RusticolResult<Box<[u32]>> {
+    let mut positions = word
+        .iter()
+        .enumerate()
+        .filter_map(|(index, source_slot)| (*source_slot == anchor).then_some(index));
+    let position = positions
+        .next()
+        .ok_or_else(|| invalid("v4 cyclic trace word omits its closure anchor"))?;
+    if positions.next().is_some() {
+        return Err(invalid("v4 cyclic trace word repeats its closure anchor"));
+    }
+    Ok(word[position..]
+        .iter()
+        .chain(&word[..position])
+        .copied()
+        .collect::<Vec<_>>()
+        .into_boxed_slice())
+}
+
+fn include_closure_with_reflection(
+    result: &mut BTreeMap<PendingClosureKey, PendingClosureGroup>,
+    key: PendingClosureKey,
+    contribution: PendingClosureProofContribution,
+    reflection: Option<ClosureReflectionProjection>,
+) -> RusticolResult<()> {
+    result
+        .entry(key.clone())
+        .or_default()
+        .include(contribution.clone())?;
+    if let Some(reflection) = reflection
+        && let Some(partner_sector_id) = reflection.partner_sector_id
+    {
+        let mut partner_key = key;
+        partner_key.target_sector_id = partner_sector_id;
+        let mut partner_contribution = contribution;
+        partner_contribution.exact_factor = partner_contribution
+            .exact_factor
+            .checked_mul(reflection.partner_phase)?;
+        result
+            .entry(partner_key)
+            .or_default()
+            .include(partner_contribution)?;
+    }
+    Ok(())
+}
+
+fn materialize_reflection_certificates(
+    certificates: &[PendingReflectionCertificate],
+) -> RusticolResult<Vec<ReflectionCertificateV1>> {
+    certificates
+        .iter()
+        .map(|certificate| {
+            ReflectionCertificateV1::new(
+                certificate.id,
+                certificate.canonical_color_identity,
+                certificate.reflected_color_identity,
+                certificate.source_permutation.to_vec(),
+                certificate.canonical_phase,
+                certificate.fixed_point,
+                certificate.orbit_size,
+                REFLECTION_PROOF_ALGORITHM_ID,
+                certificate.proof_digest,
+            )
+        })
+        .collect()
+}
+
+fn materialize_three_line_certificates(
+    certificate_ids: &BTreeMap<PendingThreeLineTraversalCertificate, u32>,
+) -> RusticolResult<Vec<ThreeLineTraversalCertificateV1>> {
+    let mut rows = certificate_ids
+        .iter()
+        .map(|(certificate, id)| {
+            ThreeLineTraversalCertificateV1::new(
+                *id,
+                certificate.sector_id,
+                ThreeLineTraversalKindV1::try_from(u32::from(certificate.kind))?,
+                certificate.sink_block_ordinal,
+                certificate.reference_block_order.to_vec(),
+                certificate.witness_block_order.to_vec(),
+                certificate.block_permutation.to_vec(),
+                certificate.reference_source_order.to_vec(),
+                certificate.witness_source_order.to_vec(),
+                certificate.source_position_permutation.to_vec(),
+                certificate.closure_anchor_source_slot,
+                certificate.pairing_rule_id,
+                certificate.proof_digest,
+            )
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    rows.sort_unstable_by_key(ThreeLineTraversalCertificateV1::id);
+    Ok(rows)
+}
+
+type ClosureSupportBucketKey = (Box<[u32]>, Box<[u32]>);
+
+#[derive(Debug, Default)]
+struct ContractedClosureSupportBucket {
+    sector_ids: Vec<u32>,
+    ordered_sector_ids_by_components: BTreeMap<Box<[LCColorComponent]>, Vec<u32>>,
+    open_line_sector_ids_by_components: BTreeMap<Box<[LCColorComponent]>, Vec<u32>>,
+}
+
+impl ContractedClosureSupportBucket {
+    fn include(
+        &mut self,
+        strategy: RecurrenceStrategy,
+        sector: &PreparedClosureSector,
+    ) -> RusticolResult<()> {
+        self.sector_ids.push(sector.row.sector_id);
+        match sector.row.kind()? {
+            ProcessLCSectorKind::Singlet | ProcessLCSectorKind::SingleTrace => {
+                self.ordered_sector_ids_by_components
+                    .entry(sector.expected_components.clone())
+                    .or_default()
+                    .push(sector.row.sector_id);
+            }
+            ProcessLCSectorKind::OpenLines
+                if strategy == RecurrenceStrategy::AllFlowUnion
+                    || sector.contracted_color_canonical_owner =>
+            {
+                let mut canonical = sector.expected_components.to_vec();
+                canonical.sort_unstable();
+                self.open_line_sector_ids_by_components
+                    .entry(canonical.into_boxed_slice())
+                    .or_default()
+                    .push(sector.row.sector_id);
+            }
+            ProcessLCSectorKind::OpenLines => {}
+        }
+        Ok(())
+    }
+
+    fn matching_sector_ids(&self, closed: &[LCColorComponent]) -> Vec<u32> {
+        let mut matching = self
+            .ordered_sector_ids_by_components
+            .get(closed)
+            .into_iter()
+            .flatten()
+            .copied()
+            .collect::<Vec<_>>();
+        if !self.open_line_sector_ids_by_components.is_empty() {
+            let mut canonical = closed.to_vec();
+            canonical.sort_unstable();
+            if let Some(open_line_sectors) = self
+                .open_line_sector_ids_by_components
+                .get(canonical.as_slice())
+            {
+                matching.extend(open_line_sectors.iter().copied());
+            }
+        }
+        matching
+    }
+}
+
+#[derive(Debug)]
+struct ContractedClosureAttempt {
+    closed_components: Box<[LCColorComponent]>,
+    key: PendingClosureKey,
+    contribution: PendingClosureProofContribution,
+    pairing_rule_id: Option<u32>,
+}
+
+fn contracted_closure_support_buckets(
+    strategy: RecurrenceStrategy,
+    prepared_sectors: &PreparedClosureSectorCatalog,
+    materialized_sectors: &BTreeSet<u32>,
+) -> RusticolResult<BTreeMap<ClosureSupportBucketKey, ContractedClosureSupportBucket>> {
+    if !matches!(
+        strategy,
+        RecurrenceStrategy::AllFlowUnion | RecurrenceStrategy::ContractedColorUnion
+    ) {
+        return Err(invalid(
+            "bulk closure support buckets require an all-flow or contracted-color union",
+        ));
+    }
+    let mut buckets = BTreeMap::<ClosureSupportBucketKey, ContractedClosureSupportBucket>::new();
+    for sector_id in materialized_sectors.iter().copied() {
+        let sector = prepared_sectors.get(sector_id)?;
+        buckets
+            .entry((
+                sector.anchor_support.clone(),
+                sector.complement_support.clone(),
+            ))
+            .or_default()
+            .include(strategy, sector)?;
+    }
+    Ok(buckets)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn include_bulk_color_union_closure_attempt(
+    strategy: RecurrenceStrategy,
+    sector: &PreparedClosureSector,
+    attempt: &ContractedClosureAttempt,
+    process: &OwnedRecurrenceProcessInput,
+    process_catalog: &ProcessCatalog<'_>,
+    color_states: &DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+    reflection_certificates: &[PendingReflectionCertificate],
+    prepared_sectors: &PreparedClosureSectorCatalog,
+    materialized_sectors: &BTreeSet<u32>,
+    result: &mut BTreeMap<PendingClosureKey, PendingClosureGroup>,
+) -> RusticolResult<()> {
+    if !closed_components_match_prepared_sector(strategy, &attempt.closed_components, sector)? {
+        return Err(invalid(format!(
+            "bulk color-union closure routing selected non-matching sector {}",
+            sector.row.sector_id
+        )));
+    }
+    let reflection = closure_reflection_projection(
+        sector.row,
+        &attempt.closed_components,
+        process,
+        process_catalog,
+        color_states,
+        currents,
+        attempt.contribution.construction_parent_ids,
+        reflection_certificates,
+        prepared_sectors,
+        materialized_sectors,
+    )?;
+    let mut key = attempt.key.clone();
+    key.target_sector_id = sector.row.sector_id;
+    let mut contribution = attempt.contribution.clone();
+    contribution.three_line_certificate = three_line_traversal_certificate(
+        &attempt.closed_components,
+        sector.row,
+        &sector.expected_components,
+        process_catalog,
+        attempt.pairing_rule_id,
+    )?;
+    contribution.reflection_certificate_id = reflection.map(|row| row.certificate_id);
+    include_closure_with_reflection(result, key, contribution, reflection)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_bulk_color_union_closures(
+    strategy: RecurrenceStrategy,
+    process: &OwnedRecurrenceProcessInput,
+    process_catalog: &ProcessCatalog<'_>,
+    template: &OwnedRecurrenceTemplateInput,
+    fermion_ordering: &FermionOrderingContext,
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+    prepared_closures: &PreparedClosureCatalog,
+    prepared_sectors: &PreparedClosureSectorCatalog,
+    color_states: &DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+    materialized_sectors: &BTreeSet<u32>,
+    reflection_certificates: &[PendingReflectionCertificate],
+    construction_domain: Option<PendingConstructionDomain>,
+    telemetry: &mut RecurrenceGenerationTelemetry,
+    collect_telemetry: bool,
+) -> RusticolResult<ExhaustiveClosureDomain> {
+    if !matches!(
+        strategy,
+        RecurrenceStrategy::AllFlowUnion | RecurrenceStrategy::ContractedColorUnion
+    ) {
+        return Err(invalid(
+            "bulk closure construction requires an all-flow or contracted-color union",
+        ));
+    }
+    let support_index = LaneClosureSupportIndex::new(currents, construction_domain)?;
+    let support_buckets =
+        contracted_closure_support_buckets(strategy, prepared_sectors, materialized_sectors)?;
+    let mut attempts = Vec::<ContractedClosureAttempt>::new();
+    let mut attempt_indices_by_sector = BTreeMap::<u32, Vec<usize>>::new();
+
+    for ((anchor_support, complement_support), bucket) in &support_buckets {
+        let anchor_ids = support_index
+            .current_ids(anchor_support)
+            .iter()
+            .copied()
+            .filter(|current_id| {
+                currents[*current_id as usize].key.node_kind() == RecurrenceNodeKind::Source
+            })
+            .collect::<Vec<_>>();
+        let complement_ids = support_index.current_ids(complement_support);
+        let anchor_count = anchor_ids.len();
+        let complement_count = complement_ids.len();
+        if collect_telemetry {
+            checked_diagnostic_add(
+                &mut telemetry.closure_support_lookup_count,
+                2,
+                "telemetry closure-support lookup count",
+            )?;
+            let theoretical_count = anchor_count
+                .checked_mul(complement_count)
+                .and_then(|count| count.checked_mul(prepared_closures.row_count()))
+                .and_then(|count| count.checked_mul(bucket.sector_ids.len()))
+                .ok_or_else(|| invalid("theoretical closure-candidate count exceeds usize"))?;
+            checked_diagnostic_add(
+                &mut telemetry.closure_candidate_theoretical_count,
+                theoretical_count,
+                "telemetry theoretical closure-candidate count",
+            )?;
+        }
+        for anchor_id in anchor_ids.iter().copied() {
+            let anchor_state = currents[anchor_id as usize].key.current_state_template_id();
+            for &complement_id in complement_ids {
+                let complement_state = currents[complement_id as usize]
+                    .key
+                    .current_state_template_id();
+                let matching_closures = prepared_closures.rows(anchor_state, complement_state);
+                if collect_telemetry {
+                    checked_diagnostic_add(
+                        &mut telemetry.closure_candidate_count,
+                        matching_closures.len(),
+                        "telemetry closure-candidate count",
+                    )?;
+                    checked_diagnostic_add(
+                        &mut telemetry.closure_state_match_count,
+                        matching_closures.len(),
+                        "telemetry closure-state-match count",
+                    )?;
+                }
+                for closure in matching_closures {
+                    let parent_ids = closure.parent_ids(
+                        anchor_state,
+                        complement_state,
+                        anchor_id,
+                        complement_id,
+                    )?;
+                    let parents = [
+                        &currents[parent_ids[0] as usize].key,
+                        &currents[parent_ids[1] as usize].key,
+                    ];
+                    let pairing_certificate_ids =
+                        closure_pairing_certificate_ids(currents, parent_ids, pairing_catalog)?;
+                    let pairing_rule =
+                        pairing_rule_for_certificate(&pairing_certificate_ids, pairing_catalog)?;
+                    for quantum in closure
+                        .quantum_flows
+                        .iter()
+                        .filter(|quantum| quantum.matches(&parents))
+                    {
+                        let output_factor = quantum.output_factor()?;
+                        let (evaluator_parent_ids, exchange_factor) =
+                            closure.canonical_evaluator_parents(parent_ids);
+                        let evaluator_parent_permutation = two_parent_permutation(
+                            parent_ids,
+                            evaluator_parent_ids,
+                            "closure evaluator order",
+                        )?;
+                        let fermion_factor = fermion_ordering_factor(
+                            &template.current_states,
+                            [
+                                parents[0].current_state_template_id(),
+                                parents[1].current_state_template_id(),
+                            ],
+                            [
+                                parents[0].support_source_slots(),
+                                parents[1].support_source_slots(),
+                            ],
+                            fermion_ordering,
+                        )?;
+                        let base_factor = multiply_factors(&[
+                            closure.closure_exact_factor,
+                            exchange_factor,
+                            closure.contraction_exact_factor,
+                            output_factor,
+                            fermion_factor,
+                            pairing_reconstruction_factor(pairing_rule),
+                        ])?;
+                        let left = color_states
+                            .get(parents[0].dynamic_lc_color_state_id())
+                            .ok_or_else(|| invalid("closure left color state disappeared"))?;
+                        let right = color_states
+                            .get(parents[1].dynamic_lc_color_state_id())
+                            .ok_or_else(|| invalid("closure right color state disappeared"))?;
+                        for witness in &closure.witnesses {
+                            if witness.row.left_shape_string_id != left.output_color_shape_id()
+                                || witness.row.right_shape_string_id
+                                    != right.output_color_shape_id()
+                            {
+                                continue;
+                            }
+                            let closed = witness.witness.closed_components(left, right)?;
+                            if collect_telemetry {
+                                checked_diagnostic_add(
+                                    &mut telemetry.closure_color_attempt_count,
+                                    1,
+                                    "telemetry closure-color-attempt count",
+                                )?;
+                            }
+                            let matching_sector_ids = bucket.matching_sector_ids(&closed);
+                            if matching_sector_ids.is_empty() {
+                                continue;
+                            }
+                            if pairing_catalog.is_some() && pairing_certificate_ids.is_empty() {
+                                return Err(invalid(format!(
+                                    "closure witness {} for bulk color-union support bucket has no exactly realized fermion pairing",
+                                    witness.row.ordinal
+                                )));
+                            }
+                            let reconstruction_parent_permutation = match witness
+                                .row
+                                .input_permutation
+                            {
+                                0 => [0, 1],
+                                1 => [1, 0],
+                                value => {
+                                    return Err(invalid(format!(
+                                        "closure color witness has invalid parent permutation {value}"
+                                    )));
+                                }
+                            };
+                            let color_witness_term_id = closure
+                                .contraction
+                                .witness_start
+                                .checked_add(u64::from(witness.row.ordinal))
+                                .ok_or_else(|| {
+                                    invalid("closure color-witness term ID overflows")
+                                })?;
+                            let color_witness_term_id = u32::try_from(color_witness_term_id)
+                                .map_err(|_| {
+                                    invalid("closure color-witness term ID exceeds u32")
+                                })?;
+                            let attempt_index = attempts.len();
+                            attempts.push(ContractedClosureAttempt {
+                                closed_components: closed.into_boxed_slice(),
+                                key: PendingClosureKey {
+                                    target_sector_id: MISSING_U32,
+                                    complete_source_states: complete_closure_source_states(
+                                        parents,
+                                        process.external_legs.len(),
+                                    )?,
+                                    closure_template_id: closure.row.id,
+                                    quantum_flow_template_id: quantum.template_id(),
+                                    parent_current_ids: evaluator_parent_ids
+                                        .to_vec()
+                                        .into_boxed_slice(),
+                                },
+                                contribution: PendingClosureProofContribution {
+                                    construction_parent_ids: parent_ids,
+                                    construction_parent_permutation: [0, 1],
+                                    reconstruction_parent_permutation,
+                                    evaluator_parent_permutation,
+                                    closure_template_semantic_digest: closure.semantic_digest,
+                                    color_witness_term_id,
+                                    color_witness_proof_digest: witness.witness.proof_digest(),
+                                    three_line_certificate: None,
+                                    pairing_certificate_ids: pairing_certificate_ids
+                                        .clone()
+                                        .into_boxed_slice(),
+                                    reflection_certificate_id: None,
+                                    exact_factor: base_factor
+                                        .checked_mul(witness.witness.exact_factor())?,
+                                },
+                                pairing_rule_id: pairing_rule.map(|rule| rule.rule_id),
+                            });
+                            for sector_id in matching_sector_ids {
+                                attempt_indices_by_sector
+                                    .entry(sector_id)
+                                    .or_default()
+                                    .push(attempt_index);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let mut result = BTreeMap::new();
+    for sector_id in materialized_sectors.iter().copied() {
+        let sector = prepared_sectors.get(sector_id)?;
+        for attempt_index in attempt_indices_by_sector
+            .get(&sector_id)
+            .into_iter()
+            .flatten()
+            .copied()
+        {
+            let attempt = &attempts[attempt_index];
+            include_bulk_color_union_closure_attempt(
+                strategy,
+                sector,
+                attempt,
+                process,
+                process_catalog,
+                color_states,
+                currents,
+                reflection_certificates,
+                prepared_sectors,
+                materialized_sectors,
+                &mut result,
+            )?;
+        }
+    }
+    if strategy == RecurrenceStrategy::AllFlowUnion {
+        let covered_sector_ids = result
+            .keys()
+            .map(|key| key.target_sector_id)
+            .collect::<BTreeSet<_>>();
+        if let Some(sector_id) = materialized_sectors
+            .iter()
+            .copied()
+            .find(|sector_id| !covered_sector_ids.contains(sector_id))
+        {
+            return Err(invalid(format!(
+                "recurrence builder found no exact closure for physical LC sector {sector_id} after bulk all-flow closure routing"
+            )));
+        }
+    }
+    validate_pending_closure_obligations(&result, pairing_catalog, prepared_sectors)?;
+    if collect_telemetry {
+        checked_diagnostic_add(
+            &mut telemetry.closure_group_count,
+            result.len(),
+            "telemetry closure-group count",
+        )?;
+        checked_diagnostic_add(
+            &mut telemetry.closure_proof_contribution_count,
+            result.values().try_fold(0usize, |total, group| {
+                total
+                    .checked_add(group.contributions.len())
+                    .ok_or_else(|| invalid("closure proof-contribution count exceeds usize"))
+            })?,
+            "telemetry closure-proof-contribution count",
+        )?;
+    }
+    ExhaustiveClosureDomain::new(
+        result,
+        materialized_sectors,
+        closure_domain_sector_owners(strategy, prepared_sectors, materialized_sectors)?,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_closures(
+    strategy: RecurrenceStrategy,
+    process: &OwnedRecurrenceProcessInput,
+    process_catalog: &ProcessCatalog<'_>,
+    template: &OwnedRecurrenceTemplateInput,
+    fermion_ordering: &FermionOrderingContext,
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+    prepared_closures: &PreparedClosureCatalog,
+    prepared_sectors: &PreparedClosureSectorCatalog,
+    color_states: &DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+    materialized_sectors: &BTreeSet<u32>,
+    stage_diagnostics: &[StageConstructionDiagnostics],
+    reflection_certificates: &[PendingReflectionCertificate],
+    construction_domain: Option<PendingConstructionDomain>,
+    telemetry: &mut RecurrenceGenerationTelemetry,
+    collect_telemetry: bool,
+) -> RusticolResult<ExhaustiveClosureDomain> {
+    if matches!(
+        strategy,
+        RecurrenceStrategy::AllFlowUnion | RecurrenceStrategy::ContractedColorUnion
+    ) {
+        return build_bulk_color_union_closures(
+            strategy,
+            process,
+            process_catalog,
+            template,
+            fermion_ordering,
+            pairing_catalog,
+            prepared_closures,
+            prepared_sectors,
+            color_states,
+            currents,
+            materialized_sectors,
+            reflection_certificates,
+            construction_domain,
+            telemetry,
+            collect_telemetry,
+        );
+    }
+    build_closures_per_sector(
+        strategy,
+        process,
+        process_catalog,
+        template,
+        fermion_ordering,
+        pairing_catalog,
+        prepared_closures,
+        prepared_sectors,
+        color_states,
+        currents,
+        materialized_sectors,
+        stage_diagnostics,
+        reflection_certificates,
+        construction_domain,
+        telemetry,
+        collect_telemetry,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_closures_per_sector(
+    strategy: RecurrenceStrategy,
+    process: &OwnedRecurrenceProcessInput,
+    process_catalog: &ProcessCatalog<'_>,
+    template: &OwnedRecurrenceTemplateInput,
+    fermion_ordering: &FermionOrderingContext,
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+    prepared_closures: &PreparedClosureCatalog,
+    prepared_sectors: &PreparedClosureSectorCatalog,
+    color_states: &DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+    materialized_sectors: &BTreeSet<u32>,
+    stage_diagnostics: &[StageConstructionDiagnostics],
+    reflection_certificates: &[PendingReflectionCertificate],
+    construction_domain: Option<PendingConstructionDomain>,
+    telemetry: &mut RecurrenceGenerationTelemetry,
+    collect_telemetry: bool,
+) -> RusticolResult<ExhaustiveClosureDomain> {
+    let support_index = LaneClosureSupportIndex::new(currents, construction_domain)?;
+    let mut result = BTreeMap::new();
+    let mut covered_sector_ids = BTreeSet::new();
+    for sector_id in materialized_sectors.iter().copied() {
+        let sector = prepared_sectors.get(sector_id)?;
+        let anchor_ids = support_index
+            .current_ids(&sector.anchor_support)
+            .iter()
+            .copied()
+            .filter(|current_id| {
+                currents[*current_id as usize].key.node_kind() == RecurrenceNodeKind::Source
+            })
+            .collect::<Vec<_>>();
+        let complement_ids = support_index.current_ids(&sector.complement_support);
+        let anchor_count = anchor_ids.len();
+        let complement_count = complement_ids.len();
+        if collect_telemetry {
+            checked_diagnostic_add(
+                &mut telemetry.closure_support_lookup_count,
+                2,
+                "telemetry closure-support lookup count",
+            )?;
+            let theoretical_count = anchor_count
+                .checked_mul(complement_count)
+                .and_then(|count| count.checked_mul(prepared_closures.row_count()))
+                .ok_or_else(|| invalid("theoretical closure-candidate count exceeds usize"))?;
+            checked_diagnostic_add(
+                &mut telemetry.closure_candidate_theoretical_count,
+                theoretical_count,
+                "telemetry theoretical closure-candidate count",
+            )?;
+        }
+        let mut state_matched_attempts = 0usize;
+        let sector_result_start = result.len();
+        for anchor_id in anchor_ids.iter().copied() {
+            let anchor_state = currents[anchor_id as usize].key.current_state_template_id();
+            for &complement_id in complement_ids {
+                let complement_state = currents[complement_id as usize]
+                    .key
+                    .current_state_template_id();
+                let matching_closures = prepared_closures.rows(anchor_state, complement_state);
+                if collect_telemetry {
+                    checked_diagnostic_add(
+                        &mut telemetry.closure_candidate_count,
+                        matching_closures.len(),
+                        "telemetry closure-candidate count",
+                    )?;
+                    checked_diagnostic_add(
+                        &mut telemetry.closure_state_match_count,
+                        matching_closures.len(),
+                        "telemetry closure-state-match count",
+                    )?;
+                }
+                state_matched_attempts = state_matched_attempts
+                    .checked_add(matching_closures.len())
+                    .ok_or_else(|| invalid("closure-attempt count exceeds usize"))?;
+                for closure in matching_closures {
+                    let parent_ids = closure.parent_ids(
+                        anchor_state,
+                        complement_state,
+                        anchor_id,
+                        complement_id,
+                    )?;
+                    add_closure_terms(
+                        strategy,
+                        sector,
+                        closure,
+                        parent_ids,
+                        process,
+                        process_catalog,
+                        template,
+                        fermion_ordering,
+                        color_states,
+                        currents,
+                        pairing_catalog,
+                        reflection_certificates,
+                        prepared_sectors,
+                        materialized_sectors,
+                        &mut result,
+                        &mut covered_sector_ids,
+                        telemetry,
+                        collect_telemetry,
+                    )?;
+                }
+            }
+        }
+        if result.len() == sector_result_start && strategy != RecurrenceStrategy::AllFlowUnion {
+            if strategy == RecurrenceStrategy::ContractedColorUnion {
+                continue;
+            }
+            let closure_color_attempts = collect_closure_color_attempts(
+                prepared_closures,
+                color_states,
+                currents,
+                &anchor_ids,
+                complement_ids,
+            )?;
+            let mut support_histogram = BTreeMap::<usize, usize>::new();
+            let mut support_signatures = BTreeSet::new();
+            for (id, current) in currents.iter().enumerate() {
+                if construction_domain.is_some_and(|domain| !domain.contains(id)) {
+                    continue;
+                }
+                *support_histogram
+                    .entry(current.key.support_source_slots().len())
+                    .or_default() += 1;
+                support_signatures.insert((
+                    current.key.support_source_slots().len(),
+                    current.key.current_state_template_id(),
+                    current.key.spin_state_class(),
+                    current.key.flavour_flow().to_vec(),
+                    current.key.quantum_number_flow_id(),
+                    current.key.coupling_orders().to_vec(),
+                ));
+            }
+            return Err(invalid(format!(
+                "recurrence builder found no exact closure for physical LC sector {sector_id} \
+                 (anchors={anchor_count}, complement_currents={complement_count}, \
+                 state_matched_attempts={state_matched_attempts}, \
+                 currents_by_support_size={support_histogram:?}, \
+                 stage_diagnostics={stage_diagnostics:?}, \
+                 expected_color_components={:?}, \
+                 closure_color_attempts={closure_color_attempts:?}, \
+                 support_signatures={support_signatures:?})",
+                sector.expected_components,
+            )));
+        }
+    }
+    // Do not reject an all-flow sector until every possible direct owner has
+    // run.  Physical sector identifiers need not place a reflection owner
+    // before its partner; only the authenticated certificate establishes that
+    // relationship.  Coverage is recorded exclusively after the corresponding
+    // exact row (and optional phase-bearing partner row) was inserted above.
+    if strategy == RecurrenceStrategy::AllFlowUnion
+        && let Some(sector_id) = materialized_sectors
+            .iter()
+            .copied()
+            .find(|sector_id| !covered_sector_ids.contains(sector_id))
+    {
+        let sector = prepared_sectors.get(sector_id)?;
+        let anchor_ids = support_index
+            .current_ids(&sector.anchor_support)
+            .iter()
+            .copied()
+            .filter(|current_id| {
+                currents[*current_id as usize].key.node_kind() == RecurrenceNodeKind::Source
+            })
+            .collect::<Vec<_>>();
+        let complement_ids = support_index.current_ids(&sector.complement_support);
+        let anchor_count = anchor_ids.len();
+        let complement_count = complement_ids.len();
+        let mut state_matched_attempts = 0usize;
+        for anchor_id in anchor_ids.iter().copied() {
+            let anchor_state = currents[anchor_id as usize].key.current_state_template_id();
+            for complement_id in complement_ids.iter().copied() {
+                let complement_state = currents[complement_id as usize]
+                    .key
+                    .current_state_template_id();
+                state_matched_attempts = state_matched_attempts
+                    .checked_add(prepared_closures.rows(anchor_state, complement_state).len())
+                    .ok_or_else(|| invalid("closure-attempt count exceeds usize"))?;
+            }
+        }
+        let closure_color_attempts = collect_closure_color_attempts(
+            prepared_closures,
+            color_states,
+            currents,
+            &anchor_ids,
+            complement_ids,
+        )?;
+        let mut support_histogram = BTreeMap::<usize, usize>::new();
+        let mut support_signatures = BTreeSet::new();
+        for (id, current) in currents.iter().enumerate() {
+            if construction_domain.is_some_and(|domain| !domain.contains(id)) {
+                continue;
+            }
+            *support_histogram
+                .entry(current.key.support_source_slots().len())
+                .or_default() += 1;
+            support_signatures.insert((
+                current.key.support_source_slots().len(),
+                current.key.current_state_template_id(),
+                current.key.spin_state_class(),
+                current.key.flavour_flow().to_vec(),
+                current.key.quantum_number_flow_id(),
+                current.key.coupling_orders().to_vec(),
+            ));
+        }
+        return Err(invalid(format!(
+            "recurrence builder found no exact closure for physical LC sector {sector_id} \
+             (anchors={anchor_count}, complement_currents={complement_count}, \
+             state_matched_attempts={state_matched_attempts}, \
+             currents_by_support_size={support_histogram:?}, \
+             stage_diagnostics={stage_diagnostics:?}, \
+             expected_color_components={:?}, \
+             closure_color_attempts={closure_color_attempts:?}, \
+             support_signatures={support_signatures:?})",
+            sector.expected_components,
+        )));
+    }
+    validate_pending_closure_obligations(&result, pairing_catalog, prepared_sectors)?;
+    if collect_telemetry {
+        checked_diagnostic_add(
+            &mut telemetry.closure_group_count,
+            result.len(),
+            "telemetry closure-group count",
+        )?;
+        checked_diagnostic_add(
+            &mut telemetry.closure_proof_contribution_count,
+            result.values().try_fold(0usize, |total, group| {
+                total
+                    .checked_add(group.contributions.len())
+                    .ok_or_else(|| invalid("closure proof-contribution count exceeds usize"))
+            })?,
+            "telemetry closure-proof-contribution count",
+        )?;
+    }
+    ExhaustiveClosureDomain::new(
+        result,
+        materialized_sectors,
+        closure_domain_sector_owners(strategy, prepared_sectors, materialized_sectors)?,
+    )
+}
+
+fn collect_closure_color_attempts(
+    prepared_closures: &PreparedClosureCatalog,
+    color_states: &DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+    anchor_ids: &[u32],
+    complement_ids: &[u32],
+) -> RusticolResult<BTreeSet<ClosureColorAttemptDiagnostic>> {
+    let mut attempts = BTreeSet::new();
+    for anchor_id in anchor_ids.iter().copied() {
+        let anchor_state = currents[anchor_id as usize].key.current_state_template_id();
+        for complement_id in complement_ids.iter().copied() {
+            let complement_state = currents[complement_id as usize]
+                .key
+                .current_state_template_id();
+            for closure in prepared_closures.rows(anchor_state, complement_state) {
+                let parent_ids =
+                    closure.parent_ids(anchor_state, complement_state, anchor_id, complement_id)?;
+                let parents = [
+                    &currents[parent_ids[0] as usize].key,
+                    &currents[parent_ids[1] as usize].key,
+                ];
+                if !closure
+                    .quantum_flows
+                    .iter()
+                    .any(|quantum| quantum.matches(&parents))
+                {
+                    continue;
+                }
+                let left = color_states
+                    .get(parents[0].dynamic_lc_color_state_id())
+                    .ok_or_else(|| invalid("closure left color state disappeared"))?;
+                let right = color_states
+                    .get(parents[1].dynamic_lc_color_state_id())
+                    .ok_or_else(|| invalid("closure right color state disappeared"))?;
+                for witness in closure.witnesses.iter().filter(|witness| {
+                    witness.row.left_shape_string_id == left.output_color_shape_id()
+                        && witness.row.right_shape_string_id == right.output_color_shape_id()
+                }) {
+                    let closed = witness.witness.closed_components(left, right)?;
+                    attempts.insert(
+                        closed
+                            .iter()
+                            .map(|component| (component.kind(), component.source_slots().to_vec()))
+                            .collect(),
+                    );
+                }
+            }
+        }
+    }
+    Ok(attempts)
+}
+
+fn validate_pending_closure_obligations(
+    closures: &BTreeMap<PendingClosureKey, PendingClosureGroup>,
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+    prepared_sectors: &PreparedClosureSectorCatalog,
+) -> RusticolResult<()> {
+    let Some(pairing_catalog) = pairing_catalog else {
+        return Ok(());
+    };
+    let destinations = closures
+        .keys()
+        .map(|key| (key.target_sector_id, key.complete_source_states.clone()))
+        .collect::<BTreeSet<_>>();
+    for (sector_id, source_states) in destinations {
+        let prepared_sector = prepared_sectors.get(sector_id)?;
+        let sector = prepared_sector.row;
+        let rows = closures
+            .iter()
+            .filter(|(key, _)| {
+                key.target_sector_id == sector_id && key.complete_source_states == source_states
+            })
+            .flat_map(|(_, group)| group.contributions.iter())
+            .collect::<Vec<_>>();
+        let realized_pairings = rows
+            .iter()
+            .flat_map(|row| row.pairing_certificate_ids.iter().copied())
+            .collect::<BTreeSet<_>>();
+        if realized_pairings.is_empty() {
+            return Err(invalid(format!(
+                "closure destination for sector {sector_id} realizes no fermion pairing rule"
+            )));
+        }
+        for pairing_id in &realized_pairings {
+            if pairing_catalog
+                .rules()
+                .iter()
+                .all(|rule| rule.rule_id != *pairing_id)
+            {
+                return Err(invalid(format!(
+                    "closure destination for sector {sector_id} references absent pairing rule {pairing_id}"
+                )));
+            }
+        }
+        if sector.kind()? == ProcessLCSectorKind::OpenLines && sector.open_string_range.count == 3 {
+            for pairing_id in realized_pairings.iter().copied() {
+                let matching_rows = rows
+                    .iter()
+                    .filter(|row| row.pairing_certificate_ids.contains(&pairing_id))
+                    .collect::<Vec<_>>();
+                if matching_rows
+                    .iter()
+                    .any(|row| row.three_line_certificate.is_none())
+                {
+                    return Err(invalid(format!(
+                        "three-line closure sector {sector_id} pairing {pairing_id} has an uncertified traversal"
+                    )));
+                }
+                let traversal_kinds = matching_rows
+                    .into_iter()
+                    .map(|row| {
+                        let certificate = row
+                            .three_line_certificate
+                            .as_ref()
+                            .expect("presence checked above");
+                        if certificate.sector_id != sector_id
+                            || certificate.pairing_rule_id != pairing_id
+                        {
+                            return Err(invalid(format!(
+                                "three-line closure sector {sector_id} pairing {pairing_id} \
+                                 has a traversal certificate for sector {} pairing {}",
+                                certificate.sector_id, certificate.pairing_rule_id,
+                            )));
+                        }
+                        match u32::from(certificate.kind) {
+                            THREE_LINE_DIRECT_CERTIFICATE_ID
+                            | THREE_LINE_PARTNER_CERTIFICATE_ID => Ok(u32::from(certificate.kind)),
+                            kind => Err(invalid(format!(
+                                "three-line closure sector {sector_id} pairing {pairing_id} \
+                                 has invalid traversal kind {kind}"
+                            ))),
+                        }
+                    })
+                    .collect::<RusticolResult<BTreeSet<_>>>()?;
+                if traversal_kinds.is_empty() {
+                    return Err(invalid(format!(
+                        "three-line closure sector {sector_id} pairing {pairing_id} \
+                         realizes no certified traversal"
+                    )));
+                }
+            }
+        }
+        if prepared_sector.expected_components.len() != sector.open_string_range.count as usize
+            && sector.kind()? == ProcessLCSectorKind::OpenLines
+        {
+            return Err(invalid(
+                "closure obligation open-line component count is inconsistent",
+            ));
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn add_closure_terms(
+    strategy: RecurrenceStrategy,
+    sector: &PreparedClosureSector,
+    closure: &PreparedClosure,
+    parent_ids: [u32; 2],
+    process: &OwnedRecurrenceProcessInput,
+    process_catalog: &ProcessCatalog<'_>,
+    template: &OwnedRecurrenceTemplateInput,
+    fermion_ordering: &FermionOrderingContext,
+    color_states: &DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+    pairing_catalog: Option<ValidatedFermionPairingCatalog<'_>>,
+    reflection_certificates: &[PendingReflectionCertificate],
+    prepared_sectors: &PreparedClosureSectorCatalog,
+    materialized_sectors: &BTreeSet<u32>,
+    result: &mut BTreeMap<PendingClosureKey, PendingClosureGroup>,
+    covered_sector_ids: &mut BTreeSet<u32>,
+    telemetry: &mut RecurrenceGenerationTelemetry,
+    collect_telemetry: bool,
+) -> RusticolResult<()> {
+    let parents = [
+        &currents[parent_ids[0] as usize].key,
+        &currents[parent_ids[1] as usize].key,
+    ];
+    let pairing_certificate_ids =
+        closure_pairing_certificate_ids(currents, parent_ids, pairing_catalog)?;
+    let pairing_rule = pairing_rule_for_certificate(&pairing_certificate_ids, pairing_catalog)?;
+    for quantum in closure
+        .quantum_flows
+        .iter()
+        .filter(|quantum| quantum.matches(&parents))
+    {
+        let output_factor = quantum.output_factor()?;
+        let (evaluator_parent_ids, exchange_factor) =
+            closure.canonical_evaluator_parents(parent_ids);
+        let evaluator_parent_permutation =
+            two_parent_permutation(parent_ids, evaluator_parent_ids, "closure evaluator order")?;
+        let fermion_factor = fermion_ordering_factor(
+            &template.current_states,
+            [
+                parents[0].current_state_template_id(),
+                parents[1].current_state_template_id(),
+            ],
+            [
+                parents[0].support_source_slots(),
+                parents[1].support_source_slots(),
+            ],
+            fermion_ordering,
+        )?;
+        let base_factor = multiply_factors(&[
+            closure.closure_exact_factor,
+            exchange_factor,
+            closure.contraction_exact_factor,
+            output_factor,
+            fermion_factor,
+            pairing_reconstruction_factor(pairing_rule),
+        ])?;
+        for witness in &closure.witnesses {
+            let left = color_states
+                .get(parents[0].dynamic_lc_color_state_id())
+                .ok_or_else(|| invalid("closure left color state disappeared"))?;
+            let right = color_states
+                .get(parents[1].dynamic_lc_color_state_id())
+                .ok_or_else(|| invalid("closure right color state disappeared"))?;
+            if witness.row.left_shape_string_id != left.output_color_shape_id()
+                || witness.row.right_shape_string_id != right.output_color_shape_id()
+            {
+                continue;
+            }
+            let closed = witness.witness.closed_components(left, right)?;
+            if collect_telemetry {
+                checked_diagnostic_add(
+                    &mut telemetry.closure_color_attempt_count,
+                    1,
+                    "telemetry closure-color-attempt count",
+                )?;
+            }
+            if !closed_components_match_prepared_sector(strategy, &closed, sector)? {
+                continue;
+            }
+            if pairing_catalog.is_some() && pairing_certificate_ids.is_empty() {
+                return Err(invalid(format!(
+                    "closure witness {} for sector {} has no exactly realized fermion pairing",
+                    witness.row.ordinal, sector.row.sector_id
+                )));
+            }
+            let reconstruction_parent_permutation = match witness.row.input_permutation {
+                0 => [0, 1],
+                1 => [1, 0],
+                value => {
+                    return Err(invalid(format!(
+                        "closure color witness has invalid parent permutation {value}"
+                    )));
+                }
+            };
+            let color_witness_term_id = closure
+                .contraction
+                .witness_start
+                .checked_add(u64::from(witness.row.ordinal))
+                .ok_or_else(|| invalid("closure color-witness term ID overflows"))?;
+            let color_witness_term_id = u32::try_from(color_witness_term_id)
+                .map_err(|_| invalid("closure color-witness term ID exceeds u32"))?;
+            let key = PendingClosureKey {
+                target_sector_id: sector.row.sector_id,
+                complete_source_states: complete_closure_source_states(
+                    parents,
+                    process.external_legs.len(),
+                )?,
+                closure_template_id: closure.row.id,
+                quantum_flow_template_id: quantum.template_id(),
+                parent_current_ids: evaluator_parent_ids.into(),
+            };
+            let factor = base_factor.checked_mul(witness.witness.exact_factor())?;
+            let reflection = closure_reflection_projection(
+                sector.row,
+                &closed,
+                process,
+                process_catalog,
+                color_states,
+                currents,
+                parent_ids,
+                reflection_certificates,
+                prepared_sectors,
+                materialized_sectors,
+            )?;
+            let contribution = PendingClosureProofContribution {
+                construction_parent_ids: parent_ids,
+                construction_parent_permutation: [0, 1],
+                reconstruction_parent_permutation,
+                evaluator_parent_permutation,
+                closure_template_semantic_digest: closure.semantic_digest,
+                color_witness_term_id,
+                color_witness_proof_digest: witness.witness.proof_digest(),
+                three_line_certificate: three_line_traversal_certificate(
+                    &closed,
+                    sector.row,
+                    &sector.expected_components,
+                    process_catalog,
+                    pairing_rule.map(|rule| rule.rule_id),
+                )?,
+                pairing_certificate_ids: pairing_certificate_ids.clone().into_boxed_slice(),
+                reflection_certificate_id: reflection.map(|row| row.certificate_id),
+                exact_factor: factor,
+            };
+            let partner_sector_id = reflection.and_then(|row| row.partner_sector_id);
+            include_closure_with_reflection(result, key, contribution, reflection)?;
+            covered_sector_ids.insert(sector.row.sector_id);
+            if let Some(partner_sector_id) = partner_sector_id {
+                covered_sector_ids.insert(partner_sector_id);
+            }
+        }
+    }
+    Ok(())
+}
+
+fn closure_selector_proof_words(
+    sector_id: u32,
+    target_helicity_id: Option<u32>,
+    source_states: &[SourceStateAssignment],
+) -> RusticolResult<Vec<u64>> {
+    let mut words = Vec::with_capacity(
+        3usize
+            .checked_add(source_states.len().saturating_mul(2))
+            .ok_or_else(|| invalid("closure selector-proof word count overflows usize"))?,
+    );
+    words.push(u64::from(sector_id));
+    words.push(u64::from(target_helicity_id.unwrap_or(MISSING_U32)));
+    words.push(
+        u64::try_from(source_states.len())
+            .map_err(|_| invalid("closure selector source-state count exceeds u64"))?,
+    );
+    for assignment in source_states {
+        words.push(u64::from(assignment.source_slot()));
+        words.push(u64::from(assignment.state_index()));
+    }
+    Ok(words)
+}
+
+fn pending_closure_candidate_identity_digest(
+    key: &PendingClosureKey,
+    contribution: &PendingClosureProofContribution,
+    target_helicity_id: Option<u32>,
+    pending: &[PendingCurrent],
+    dynamic_color_states: &[DynamicLCColorState],
+    reflection_certificates: &[PendingReflectionCertificate],
+) -> RusticolResult<SemanticDigest> {
+    let selector_words = closure_selector_proof_words(
+        key.target_sector_id,
+        target_helicity_id,
+        &key.complete_source_states,
+    )?;
+    let selector_domain_digest = closure_selector_domain_digest_v2(&selector_words)?;
+    let mut parent_semantic_digests =
+        Vec::with_capacity(contribution.construction_parent_ids.len());
+    let mut parent_color_digests = Vec::with_capacity(contribution.construction_parent_ids.len());
+    for old_id in contribution.construction_parent_ids {
+        let current = pending
+            .get(old_id as usize)
+            .ok_or_else(|| invalid("closure candidate source parent is absent"))?;
+        parent_semantic_digests.push(semantic_digest_from_u32_fields(
+            b"recurrence-closure-parent-current-v2\0",
+            [
+                old_id,
+                current.key.current_state_template_id(),
+                current.key.dynamic_lc_color_state_id().get(),
+            ],
+        )?);
+        parent_color_digests.push(dynamic_color_identity_digest(
+            dynamic_color_states
+                .get(current.key.dynamic_lc_color_state_id().get() as usize)
+                .ok_or_else(|| invalid("closure candidate parent color state is absent"))?,
+        )?);
+    }
+    let reflection_proof_digest = contribution
+        .reflection_certificate_id
+        .map(|certificate_id| {
+            reflection_certificates
+                .get(certificate_id as usize)
+                .map(|certificate| certificate.proof_digest)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "closure candidate references absent reflection certificate {certificate_id}"
+                    ))
+                })
+        })
+        .transpose()?;
+    closure_candidate_identity_digest_v1(
+        selector_domain_digest,
+        key.target_sector_id,
+        key.closure_template_id,
+        contribution.closure_template_semantic_digest,
+        key.quantum_flow_template_id,
+        &contribution.construction_parent_ids,
+        &parent_semantic_digests,
+        &parent_color_digests,
+        &contribution.construction_parent_permutation,
+        &contribution.reconstruction_parent_permutation,
+        &contribution.evaluator_parent_permutation,
+        contribution.color_witness_term_id,
+        contribution.color_witness_proof_digest,
+        contribution
+            .three_line_certificate
+            .as_ref()
+            .map(|certificate| certificate.proof_digest),
+        &contribution.pairing_certificate_ids,
+        reflection_proof_digest,
+        contribution.exact_factor,
+        1,
+    )
+}
+
+fn pending_selector_sector_domains(
+    pending: &[PendingCurrent],
+    pending_closures: &BTreeMap<PendingClosureKey, PendingClosureGroup>,
+) -> RusticolResult<Vec<BTreeSet<u32>>> {
+    let mut domains = vec![BTreeSet::new(); pending.len()];
+    let mut queue = VecDeque::new();
+    for (key, group) in pending_closures {
+        if group.exact_factor.is_zero() {
+            continue;
+        }
+        for parent in key.parent_current_ids.iter().copied() {
+            let domain = domains
+                .get_mut(parent as usize)
+                .ok_or_else(|| invalid("closure references an absent pending current"))?;
+            if domain.insert(key.target_sector_id) {
+                queue.push_back(parent);
+            }
+        }
+    }
+    while let Some(current_id) = queue.pop_front() {
+        let sectors = domains
+            .get(current_id as usize)
+            .ok_or_else(|| invalid("selector-domain queue references an absent current"))?
+            .clone();
+        for (contribution, factor) in &pending[current_id as usize].contributions {
+            if factor.is_zero() {
+                continue;
+            }
+            for parent in contribution.parent_current_ids.iter().copied() {
+                let domain = domains
+                    .get_mut(parent as usize)
+                    .ok_or_else(|| invalid("contribution references an absent pending parent"))?;
+                let before = domain.len();
+                domain.extend(sectors.iter().copied());
+                if domain.len() != before {
+                    queue.push_back(parent);
+                }
+            }
+        }
+    }
+    Ok(domains)
+}
+
+fn projected_contribution_identity(
+    destination_projection_id: u32,
+    pending_key: &PendingContributionKey,
+    exact_factor: ExactComplexRational,
+    old_to_projection: &BTreeMap<u32, u32>,
+) -> RusticolResult<ProjectedContributionIdentity> {
+    let parent_projection_ids = pending_key
+        .parent_current_ids
+        .iter()
+        .map(|old_id| {
+            old_to_projection
+                .get(old_id)
+                .copied()
+                .ok_or_else(|| invalid("projected contribution has a dead parent"))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let key = &pending_key.key;
+    Ok(ProjectedContributionIdentity {
+        destination_projection_id,
+        transition_template_id: key.transition_template_id(),
+        parent_projection_ids: parent_projection_ids.into_boxed_slice(),
+        parent_state_template_ids: key.parent_state_template_ids().into(),
+        parent_momenta: key.parent_momenta().into(),
+        result_state_template_id: key.result_state_template_id(),
+        quantum_flow_witness_id: key.quantum_flow_witness_id(),
+        runtime_coupling_binding_digest: key.runtime_coupling_binding_digest(),
+        output_projection_id: key.output_projection_id(),
+        exact_factor,
+    })
+}
+
+fn rectangular_parent_domain_is_complete(
+    parent_projection_ids: &[u32],
+    builder_parent_tuples: &BTreeSet<Box<[u32]>>,
+    old_to_projection: &BTreeMap<u32, u32>,
+    projection_members: &[Box<[u32]>],
+) -> RusticolResult<bool> {
+    let expected_count =
+        parent_projection_ids
+            .iter()
+            .try_fold(1usize, |count, projection_id| {
+                let member_count = projection_members
+                    .get(*projection_id as usize)
+                    .ok_or_else(|| {
+                        invalid("rectangular proof references an absent projection class")
+                    })?
+                    .len();
+                count
+                    .checked_mul(member_count)
+                    .ok_or_else(|| invalid("rectangular parent-product count exceeds usize"))
+            })?;
+    if expected_count != builder_parent_tuples.len() {
+        return Ok(false);
+    }
+    for tuple in builder_parent_tuples {
+        if tuple.len() != parent_projection_ids.len() {
+            return Err(invalid(
+                "rectangular proof parent tuple has inconsistent arity",
+            ));
+        }
+        for (old_id, expected_projection_id) in tuple.iter().zip(parent_projection_ids.iter()) {
+            if old_to_projection.get(old_id) != Some(expected_projection_id) {
+                return Ok(false);
+            }
+        }
+    }
+    // The tuples are unique by construction.  Membership in the declared
+    // classes plus cardinality equal to the complete Cartesian product proves
+    // that no combination is missing.
+    Ok(true)
+}
+
+fn plan_topology_replay_color_projection(
+    pending: &[PendingCurrent],
+    pending_closures: &BTreeMap<PendingClosureKey, PendingClosureGroup>,
+) -> RusticolResult<Option<PendingColorProjection>> {
+    let selector_domains = pending_selector_sector_domains(pending, pending_closures)?;
+    let canonical_color_id = DynamicLCColorStateId::from_interner(0);
+    let mut identity_to_projection = BTreeMap::<ProjectedCurrentIdentity, u32>::new();
+    let mut old_to_projection = BTreeMap::new();
+    let mut projection_members = Vec::<Vec<u32>>::new();
+    let mut projection_sector_ids = Vec::<Box<[u32]>>::new();
+
+    for (old_id, current) in pending.iter().enumerate() {
+        let sectors = &selector_domains[old_id];
+        if sectors.is_empty() {
+            continue;
+        }
+        let old_id =
+            u32::try_from(old_id).map_err(|_| invalid("pending current ID exceeds u32"))?;
+        let identity = ProjectedCurrentIdentity {
+            color_erased_key: current_key_with_dynamic_color(&current.key, canonical_color_id)?,
+            selector_sector_ids: sectors.iter().copied().collect(),
+            source_builder_id: (current.key.node_kind() == RecurrenceNodeKind::Source)
+                .then_some(old_id),
+        };
+        let projection_id =
+            if let Some(projection_id) = identity_to_projection.get(&identity).copied() {
+                projection_id
+            } else {
+                let projection_id = u32::try_from(projection_members.len())
+                    .map_err(|_| invalid("projected current count exceeds u32"))?;
+                projection_sector_ids.push(identity.selector_sector_ids.clone());
+                projection_members.push(Vec::new());
+                identity_to_projection.insert(identity, projection_id);
+                projection_id
+            };
+        projection_members[projection_id as usize].push(old_id);
+        old_to_projection.insert(old_id, projection_id);
+    }
+    if projection_members.iter().all(|members| members.len() == 1) {
+        return Ok(None);
+    }
+    let projection_members = projection_members
+        .into_iter()
+        .map(Vec::into_boxed_slice)
+        .collect::<Vec<_>>();
+
+    let mut contributions =
+        BTreeMap::<ProjectedContributionIdentity, PendingProjectedContribution>::new();
+    for (old_id, projection_id) in &old_to_projection {
+        for (pending_key, factor) in &pending[*old_id as usize].contributions {
+            if factor.is_zero() {
+                continue;
+            }
+            let identity = projected_contribution_identity(
+                *projection_id,
+                pending_key,
+                *factor,
+                &old_to_projection,
+            )?;
+            let parent_tuple = pending_key.parent_current_ids.clone();
+            match contributions.entry(identity.clone()) {
+                std::collections::btree_map::Entry::Vacant(entry) => {
+                    entry.insert(PendingProjectedContribution {
+                        identity,
+                        representative_destination_builder_id: *old_id,
+                        representative_key: pending_key.key.clone(),
+                        destination_builder_ids: BTreeSet::from([*old_id]),
+                        builder_parent_tuples: BTreeSet::from([parent_tuple]),
+                    });
+                }
+                std::collections::btree_map::Entry::Occupied(mut entry) => {
+                    let projected = entry.get_mut();
+                    projected.destination_builder_ids.insert(*old_id);
+                    if !projected.builder_parent_tuples.insert(parent_tuple) {
+                        // Two builder rows with the same complete numeric
+                        // identity and old-parent tuple are additive, not an
+                        // alias.  Retain the unprojected program.
+                        return Ok(None);
+                    }
+                }
+            }
+        }
+    }
+    for projected in contributions.values() {
+        if !rectangular_parent_domain_is_complete(
+            &projected.identity.parent_projection_ids,
+            &projected.builder_parent_tuples,
+            &old_to_projection,
+            &projection_members,
+        )? {
+            return Ok(None);
+        }
+    }
+
+    let mut closures = BTreeMap::<ProjectedClosureIdentity, PendingProjectedClosure>::new();
+    for (key, group) in pending_closures {
+        if group.exact_factor.is_zero() {
+            continue;
+        }
+        let parent_projection_ids = key
+            .parent_current_ids
+            .iter()
+            .map(|old_id| {
+                old_to_projection
+                    .get(old_id)
+                    .copied()
+                    .ok_or_else(|| invalid("projected closure has a dead parent"))
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let identity = ProjectedClosureIdentity {
+            target_sector_id: key.target_sector_id,
+            complete_source_states: key.complete_source_states.clone(),
+            closure_template_id: key.closure_template_id,
+            quantum_flow_template_id: key.quantum_flow_template_id,
+            parent_projection_ids: parent_projection_ids.into_boxed_slice(),
+            exact_factor: group.exact_factor,
+        };
+        let parent_tuple = key.parent_current_ids.clone();
+        match closures.entry(identity.clone()) {
+            std::collections::btree_map::Entry::Vacant(entry) => {
+                entry.insert(PendingProjectedClosure {
+                    identity,
+                    representative_key: key.clone(),
+                    representative_group: group.clone(),
+                    builder_parent_tuples: BTreeSet::from([parent_tuple]),
+                });
+            }
+            std::collections::btree_map::Entry::Occupied(mut entry) => {
+                if !entry.get_mut().builder_parent_tuples.insert(parent_tuple) {
+                    return Ok(None);
+                }
+            }
+        }
+    }
+    for projected in closures.values() {
+        if !rectangular_parent_domain_is_complete(
+            &projected.identity.parent_projection_ids,
+            &projected.builder_parent_tuples,
+            &old_to_projection,
+            &projection_members,
+        )? {
+            return Ok(None);
+        }
+    }
+
+    Ok(Some(PendingColorProjection {
+        old_to_projection,
+        projection_members,
+        projection_sector_ids,
+        contributions,
+        closures,
+    }))
+}
+
+const COLOR_PROJECTION_CERTIFICATE_BODY_MAGIC: &[u8; 32] = b"PYAMP-COLOR-PROJECTION-BODY-V1\0\0";
+
+fn certificate_push_len(output: &mut Vec<u8>, len: usize, label: &str) -> RusticolResult<()> {
+    output.extend_from_slice(
+        &u64::try_from(len)
+            .map_err(|_| invalid(format!("{label} length exceeds u64")))?
+            .to_le_bytes(),
+    );
+    Ok(())
+}
+
+fn certificate_push_u32_sequence(
+    output: &mut Vec<u8>,
+    values: &[u32],
+    label: &str,
+) -> RusticolResult<()> {
+    certificate_push_len(output, values.len(), label)?;
+    for value in values {
+        output.extend_from_slice(&value.to_le_bytes());
+    }
+    Ok(())
+}
+
+fn certificate_push_builder_tuples(
+    output: &mut Vec<u8>,
+    tuples: &BTreeSet<Box<[u32]>>,
+    label: &str,
+) -> RusticolResult<()> {
+    certificate_push_len(output, tuples.len(), label)?;
+    for tuple in tuples {
+        certificate_push_u32_sequence(output, tuple, label)?;
+    }
+    Ok(())
+}
+
+fn hash_u32_sequence(hash: &mut Sha256, values: &[u32], label: &str) -> RusticolResult<()> {
+    hash.update(
+        u64::try_from(values.len())
+            .map_err(|_| invalid(format!("{label} length exceeds u64")))?
+            .to_le_bytes(),
+    );
+    for value in values {
+        hash.update(value.to_le_bytes());
+    }
+    Ok(())
+}
+
+fn hash_i32_sequence(hash: &mut Sha256, values: &[i32], label: &str) -> RusticolResult<()> {
+    hash.update(
+        u64::try_from(values.len())
+            .map_err(|_| invalid(format!("{label} length exceeds u64")))?
+            .to_le_bytes(),
+    );
+    for value in values {
+        hash.update(value.to_le_bytes());
+    }
+    Ok(())
+}
+
+fn hash_momentum(hash: &mut Sha256, momentum: &CanonicalMomentumLinearForm) -> RusticolResult<()> {
+    hash.update(
+        u64::try_from(momentum.terms().len())
+            .map_err(|_| invalid("projection-certificate momentum length exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for term in momentum.terms() {
+        hash.update(term.source_slot.to_le_bytes());
+        hash.update(term.coefficient.to_le_bytes());
+    }
+    Ok(())
+}
+
+fn projected_current_identity_digest(
+    identity: &ProjectedCurrentIdentity,
+) -> RusticolResult<SemanticDigest> {
+    let key = &identity.color_erased_key;
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-color-projected-current-v1\0");
+    hash.update(key.catalog_digest().as_bytes());
+    hash.update((key.node_kind() as u32).to_le_bytes());
+    hash.update(key.current_state_template_id().to_le_bytes());
+    hash_u32_sequence(
+        &mut hash,
+        key.support_source_slots(),
+        "projection-certificate support source slots",
+    )?;
+    hash_momentum(&mut hash, key.momentum())?;
+    hash.update((key.helicity_identity().strategy() as u32).to_le_bytes());
+    hash.update(key.helicity_identity().spin_state_class().to_le_bytes());
+    hash.update(
+        u64::try_from(key.helicity_identity().local_source_states().len())
+            .map_err(|_| invalid("projection-certificate helicity ancestry exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for assignment in key.helicity_identity().local_source_states() {
+        hash.update(assignment.source_slot().to_le_bytes());
+        hash.update(assignment.state_index().to_le_bytes());
+    }
+    hash_i32_sequence(
+        &mut hash,
+        key.flavour_flow(),
+        "projection-certificate flavour flow",
+    )?;
+    hash.update(key.quantum_number_flow_id().to_le_bytes());
+    hash_u32_sequence(
+        &mut hash,
+        key.coupling_orders(),
+        "projection-certificate coupling orders",
+    )?;
+    match key.source_binding() {
+        CurrentSourceBinding::None => hash.update(0_u32.to_le_bytes()),
+        CurrentSourceBinding::FixedTemplate(template_id) => {
+            hash.update(1_u32.to_le_bytes());
+            hash.update(template_id.to_le_bytes());
+        }
+        CurrentSourceBinding::RuntimeDispatch {
+            domain,
+            source_template_ids,
+            variant_bindings,
+        } => {
+            hash.update(2_u32.to_le_bytes());
+            hash.update(domain.to_le_bytes());
+            hash_u32_sequence(
+                &mut hash,
+                source_template_ids,
+                "projection-certificate runtime source templates",
+            )?;
+            hash.update(
+                u64::try_from(variant_bindings.len())
+                    .map_err(|_| {
+                        invalid("projection-certificate runtime source variants exceed u64")
+                    })?
+                    .to_le_bytes(),
+            );
+            for variant in variant_bindings {
+                hash.update(variant.source_state_index().to_le_bytes());
+                hash.update(variant.public_helicity().to_le_bytes());
+                hash.update(variant.runtime_variant_id().to_le_bytes());
+                hash.update(variant.source_template_id().to_le_bytes());
+                hash.update(variant.source_state_template_id().to_le_bytes());
+                hash.update(variant.crossed_state_template_id().to_le_bytes());
+                hash.update(variant.crossed_spin_state_class().to_le_bytes());
+                hash_exact_factor(&mut hash, variant.crossing_factor());
+            }
+        }
+    }
+    hash.update(
+        key.propagator_template_id()
+            .unwrap_or(MISSING_U32)
+            .to_le_bytes(),
+    );
+    hash_u32_sequence(
+        &mut hash,
+        &identity.selector_sector_ids,
+        "projection-certificate selector sectors",
+    )?;
+    hash.update(
+        identity
+            .source_builder_id
+            .unwrap_or(MISSING_U32)
+            .to_le_bytes(),
+    );
+    SemanticDigest::new(hash.finalize().into())
+}
+
+fn projected_contribution_identity_digest(
+    identity: &ProjectedContributionIdentity,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-color-projected-contribution-v1\0");
+    hash.update(identity.destination_projection_id.to_le_bytes());
+    hash.update(identity.transition_template_id.to_le_bytes());
+    hash_u32_sequence(
+        &mut hash,
+        &identity.parent_projection_ids,
+        "projection-certificate contribution parents",
+    )?;
+    hash_u32_sequence(
+        &mut hash,
+        &identity.parent_state_template_ids,
+        "projection-certificate contribution parent states",
+    )?;
+    hash.update(
+        u64::try_from(identity.parent_momenta.len())
+            .map_err(|_| invalid("projection-certificate parent momenta exceed u64"))?
+            .to_le_bytes(),
+    );
+    for momentum in &identity.parent_momenta {
+        hash_momentum(&mut hash, momentum)?;
+    }
+    hash.update(identity.result_state_template_id.to_le_bytes());
+    hash.update(identity.quantum_flow_witness_id.to_le_bytes());
+    hash.update(identity.runtime_coupling_binding_digest.as_bytes());
+    hash.update(identity.output_projection_id.to_le_bytes());
+    hash_exact_factor(&mut hash, identity.exact_factor);
+    SemanticDigest::new(hash.finalize().into())
+}
+
+fn projected_closure_identity_digest(
+    identity: &ProjectedClosureIdentity,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-color-projected-closure-v1\0");
+    hash.update(identity.target_sector_id.to_le_bytes());
+    hash.update(
+        u64::try_from(identity.complete_source_states.len())
+            .map_err(|_| invalid("projection-certificate closure source states exceed u64"))?
+            .to_le_bytes(),
+    );
+    for assignment in &identity.complete_source_states {
+        hash.update(assignment.source_slot().to_le_bytes());
+        hash.update(assignment.state_index().to_le_bytes());
+    }
+    hash.update(identity.closure_template_id.to_le_bytes());
+    hash.update(
+        identity
+            .quantum_flow_template_id
+            .unwrap_or(MISSING_U32)
+            .to_le_bytes(),
+    );
+    hash_u32_sequence(
+        &mut hash,
+        &identity.parent_projection_ids,
+        "projection-certificate closure parents",
+    )?;
+    hash_exact_factor(&mut hash, identity.exact_factor);
+    SemanticDigest::new(hash.finalize().into())
+}
+
+fn encode_color_projection_certificate_body(
+    pending: &[PendingCurrent],
+    dynamic_color_states: &[DynamicLCColorState],
+    projection: &PendingColorProjection,
+    original_candidate_identity_digests: &[SemanticDigest],
+) -> RusticolResult<Vec<u8>> {
+    let mut output = Vec::new();
+    output.extend_from_slice(COLOR_PROJECTION_CERTIFICATE_BODY_MAGIC);
+    output.extend_from_slice(&1_u32.to_le_bytes());
+    output.extend_from_slice(
+        &u64::try_from(projection.old_to_projection.len())
+            .map_err(|_| invalid("projection-certificate old current count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    output.extend_from_slice(
+        &u64::try_from(projection.projection_members.len())
+            .map_err(|_| invalid("projection-certificate current count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    output.extend_from_slice(
+        &u64::try_from(projection.contributions.len())
+            .map_err(|_| invalid("projection-certificate contribution count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    output.extend_from_slice(
+        &u64::try_from(projection.closures.len())
+            .map_err(|_| invalid("projection-certificate closure count exceeds u64"))?
+            .to_le_bytes(),
+    );
+
+    for (projection_index, members) in projection.projection_members.iter().enumerate() {
+        let projection_id = u32::try_from(projection_index)
+            .map_err(|_| invalid("projection-certificate current ID exceeds u32"))?;
+        output.extend_from_slice(&projection_id.to_le_bytes());
+        let representative_id = *members
+            .first()
+            .ok_or_else(|| invalid("projection-certificate current class is empty"))?;
+        let representative = pending
+            .get(representative_id as usize)
+            .ok_or_else(|| invalid("projection-certificate current representative is absent"))?;
+        let identity = ProjectedCurrentIdentity {
+            color_erased_key: current_key_with_dynamic_color(
+                &representative.key,
+                DynamicLCColorStateId::from_interner(0),
+            )?,
+            selector_sector_ids: projection.projection_sector_ids[projection_index].clone(),
+            source_builder_id: (representative.key.node_kind() == RecurrenceNodeKind::Source)
+                .then_some(representative_id),
+        };
+        output.extend_from_slice(projected_current_identity_digest(&identity)?.as_bytes());
+        certificate_push_u32_sequence(
+            &mut output,
+            &projection.projection_sector_ids[projection_index],
+            "projection-certificate current selector sectors",
+        )?;
+        certificate_push_len(
+            &mut output,
+            members.len(),
+            "projection-certificate current members",
+        )?;
+        for old_id in members {
+            output.extend_from_slice(&old_id.to_le_bytes());
+            let current = pending
+                .get(*old_id as usize)
+                .ok_or_else(|| invalid("projection-certificate current member is absent"))?;
+            let color_state = dynamic_color_states
+                .get(current.key.dynamic_lc_color_state_id().get() as usize)
+                .ok_or_else(|| invalid("projection-certificate color state is absent"))?;
+            output.extend_from_slice(dynamic_color_identity_digest(color_state)?.as_bytes());
+        }
+    }
+
+    for projected in projection.contributions.values() {
+        output.extend_from_slice(
+            projected_contribution_identity_digest(&projected.identity)?.as_bytes(),
+        );
+        output.extend_from_slice(&projected.identity.destination_projection_id.to_le_bytes());
+        output.extend_from_slice(
+            &projected
+                .representative_destination_builder_id
+                .to_le_bytes(),
+        );
+        let witness = projected.representative_key.color_witness_term_id();
+        output.extend_from_slice(&witness.color_contraction_template_id().to_le_bytes());
+        output.extend_from_slice(&witness.witness_ordinal().to_le_bytes());
+        certificate_push_u32_sequence(
+            &mut output,
+            &projected.identity.parent_projection_ids,
+            "projection-certificate contribution projected parents",
+        )?;
+        certificate_push_len(
+            &mut output,
+            projected.destination_builder_ids.len(),
+            "projection-certificate contribution destinations",
+        )?;
+        for destination_id in &projected.destination_builder_ids {
+            output.extend_from_slice(&destination_id.to_le_bytes());
+        }
+        certificate_push_builder_tuples(
+            &mut output,
+            &projected.builder_parent_tuples,
+            "projection-certificate contribution parent tuples",
+        )?;
+        for rational in [
+            projected.identity.exact_factor.real(),
+            projected.identity.exact_factor.imag(),
+        ] {
+            output.extend_from_slice(&rational.numerator().to_le_bytes());
+            output.extend_from_slice(&rational.denominator().to_le_bytes());
+        }
+    }
+
+    for projected in projection.closures.values() {
+        output
+            .extend_from_slice(projected_closure_identity_digest(&projected.identity)?.as_bytes());
+        output.extend_from_slice(&projected.identity.target_sector_id.to_le_bytes());
+        output.extend_from_slice(&projected.identity.closure_template_id.to_le_bytes());
+        output.extend_from_slice(
+            &projected
+                .identity
+                .quantum_flow_template_id
+                .unwrap_or(MISSING_U32)
+                .to_le_bytes(),
+        );
+        certificate_push_u32_sequence(
+            &mut output,
+            &projected.identity.parent_projection_ids,
+            "projection-certificate closure projected parents",
+        )?;
+        certificate_push_u32_sequence(
+            &mut output,
+            &projected.representative_key.parent_current_ids,
+            "projection-certificate closure representative parents",
+        )?;
+        certificate_push_builder_tuples(
+            &mut output,
+            &projected.builder_parent_tuples,
+            "projection-certificate closure parent tuples",
+        )?;
+        for rational in [
+            projected.identity.exact_factor.real(),
+            projected.identity.exact_factor.imag(),
+        ] {
+            output.extend_from_slice(&rational.numerator().to_le_bytes());
+            output.extend_from_slice(&rational.denominator().to_le_bytes());
+        }
+    }
+
+    let mut candidate_digests = original_candidate_identity_digests.to_vec();
+    candidate_digests.sort_unstable();
+    certificate_push_len(
+        &mut output,
+        candidate_digests.len(),
+        "projection-certificate original closure candidates",
+    )?;
+    for digest in candidate_digests {
+        output.extend_from_slice(digest.as_bytes());
+    }
+    let digest: [u8; 32] = Sha256::digest(&output).into();
+    output.extend_from_slice(&digest);
+    Ok(output)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn append_closure_proof_group(
+    key: &PendingClosureKey,
+    group: &PendingClosureGroup,
+    pending: &[PendingCurrent],
+    dynamic_color_states: &[DynamicLCColorState],
+    remap: &BTreeMap<u32, u32>,
+    target_destination_id: Option<u32>,
+    target_helicity_id: Option<u32>,
+    runtime_term_id: Option<u32>,
+    three_line_certificate_ids: &BTreeMap<PendingThreeLineTraversalCertificate, u32>,
+    closure_proof_contributions: &mut Vec<ClosureProofContributionV2>,
+    closure_proof_groups: &mut Vec<ClosureExecutionProofGroupV2>,
+) -> RusticolResult<()> {
+    if group.exact_factor.is_zero() != runtime_term_id.is_none() {
+        return Err(invalid(
+            "closure proof runtime binding does not match its exact aggregate factor",
+        ));
+    }
+    if runtime_term_id.is_some() && target_destination_id.is_none() {
+        return Err(invalid(
+            "nonzero closure proof group has no amplitude destination",
+        ));
+    }
+    let proof_start = u64::try_from(closure_proof_contributions.len())
+        .map_err(|_| invalid("closure proof contribution count exceeds u64"))?;
+    let mut component_factors = Vec::with_capacity(group.contributions.len());
+    for contribution in &group.contributions {
+        let builder_parent_ids = contribution.construction_parent_ids.to_vec();
+        let runtime_parent_ids = contribution
+            .construction_parent_ids
+            .iter()
+            .map(|old_id| remap.get(old_id).copied())
+            .collect::<Vec<_>>();
+        if runtime_term_id.is_some() && runtime_parent_ids.iter().any(Option::is_none) {
+            return Err(invalid(
+                "nonzero closure proof contribution has a dead runtime parent",
+            ));
+        }
+        let mut parent_semantic_digests =
+            Vec::with_capacity(contribution.construction_parent_ids.len());
+        let mut parent_color_digests =
+            Vec::with_capacity(contribution.construction_parent_ids.len());
+        for old_id in contribution.construction_parent_ids {
+            let current = pending
+                .get(old_id as usize)
+                .ok_or_else(|| invalid("closure proof source parent is absent"))?;
+            parent_semantic_digests.push(semantic_digest_from_u32_fields(
+                b"recurrence-closure-parent-current-v2\0",
+                [
+                    old_id,
+                    current.key.current_state_template_id(),
+                    current.key.dynamic_lc_color_state_id().get(),
+                ],
+            )?);
+            parent_color_digests.push(dynamic_color_identity_digest(
+                dynamic_color_states
+                    .get(current.key.dynamic_lc_color_state_id().get() as usize)
+                    .ok_or_else(|| invalid("closure proof parent color state is absent"))?,
+            )?);
+        }
+        let proof_id = u32::try_from(closure_proof_contributions.len())
+            .map_err(|_| invalid("closure proof contribution count exceeds u32"))?;
+        closure_proof_contributions.push(ClosureProofContributionV2::new(
+            proof_id,
+            key.target_sector_id,
+            target_destination_id,
+            target_helicity_id,
+            key.closure_template_id,
+            contribution.closure_template_semantic_digest,
+            key.quantum_flow_template_id,
+            builder_parent_ids,
+            runtime_parent_ids,
+            parent_semantic_digests,
+            parent_color_digests,
+            contribution.construction_parent_permutation.to_vec(),
+            contribution.reconstruction_parent_permutation.to_vec(),
+            contribution.evaluator_parent_permutation.to_vec(),
+            contribution.color_witness_term_id,
+            contribution.color_witness_proof_digest,
+            contribution
+                .three_line_certificate
+                .as_ref()
+                .map(|certificate| three_line_certificate_ids[certificate]),
+            contribution.pairing_certificate_ids.to_vec(),
+            contribution.reflection_certificate_id,
+            contribution.exact_factor,
+            1,
+        )?);
+        component_factors.push(contribution.exact_factor);
+    }
+    let proof_count = u64::try_from(closure_proof_contributions.len())
+        .map_err(|_| invalid("closure proof contribution count exceeds u64"))?
+        .checked_sub(proof_start)
+        .ok_or_else(|| invalid("closure proof contribution range underflows"))?;
+    let selector_words = closure_selector_proof_words(
+        key.target_sector_id,
+        target_helicity_id,
+        &key.complete_source_states,
+    )?;
+    closure_proof_groups.push(ClosureExecutionProofGroupV2::new(
+        u32::try_from(closure_proof_groups.len())
+            .map_err(|_| invalid("closure proof group count exceeds u32"))?,
+        runtime_term_id,
+        None,
+        CheckedTableRange::new(proof_start, proof_count),
+        group.exact_factor,
+        closure_component_factor_digest_v2(&component_factors)?,
+        closure_selector_domain_digest_v2(&selector_words)?,
+    )?);
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+fn observe_established_selected_transition_slice(
+    process_catalog: &ProcessCatalog<'_>,
+    pending: &[PendingCurrent],
+    pending_closures: &BTreeMap<PendingClosureKey, PendingClosureGroup>,
+    replay_targets: &[RecurrenceReplayTarget],
+    dynamic_color_states: &[DynamicLCColorState],
+) -> RusticolResult<Option<(u32, Box<[SourceStateAssignment]>)>> {
+    let Some(selection) = super::diagnostic::transition_diagnostic_selection() else {
+        return Ok(None);
+    };
+    let replay_target = replay_targets
+        .iter()
+        .find(|target| target.target_sector_id() == selection.public_flow_id)
+        .ok_or_else(|| {
+            invalid(format!(
+                "transition diagnostic public flow {} has no replay target",
+                selection.public_flow_id
+            ))
+        })?;
+    let source_states = super::diagnostic::representative_source_states_for_public_helicities(
+        replay_target.source_slot_permutation(),
+        &selection.public_helicities,
+        |representative_slot, public_helicity| {
+            let leg = process_catalog
+                .input
+                .external_legs
+                .get(representative_slot as usize)
+                .ok_or_else(|| {
+                    invalid("transition diagnostic representative source leg is absent")
+                })?;
+            let range = leg.source_state_range.as_usize_range(
+                process_catalog.input.source_states.len(),
+                "transition diagnostic representative source states",
+            )?;
+            let mut matches = process_catalog.input.source_states[range]
+                .iter()
+                .filter(|state| {
+                    state.source_slot == representative_slot
+                        && state.public_helicity == public_helicity
+                });
+            let state = matches.next().ok_or_else(|| {
+                invalid(format!(
+                    "transition diagnostic representative source slot {representative_slot} has no state for transported public helicity {public_helicity}"
+                ))
+            })?;
+            if matches.next().is_some() {
+                return Err(invalid(format!(
+                    "transition diagnostic representative source slot {representative_slot} has multiple states for transported public helicity {public_helicity}"
+                )));
+            }
+            Ok(state.state_index)
+        },
+    )?
+    .into_boxed_slice();
+    let materialized_sector_id = replay_target.materialized_sector_id();
+    let mut live = BTreeSet::new();
+    let mut queue = VecDeque::new();
+    for (key, _group) in pending_closures.iter().filter(|(key, group)| {
+        key.target_sector_id == materialized_sector_id
+            && key.complete_source_states == source_states
+            && !group.exact_factor.is_zero()
+    }) {
+        for parent in key.parent_current_ids.iter().copied() {
+            if live.insert(parent) {
+                queue.push_back(parent);
+            }
+        }
+    }
+    if live.is_empty() {
+        return Err(invalid(format!(
+            "transition diagnostic flow {} and source states {:?} have no established closure",
+            selection.public_flow_id, source_states
+        )));
+    }
+    while let Some(current_id) = queue.pop_front() {
+        let current = pending
+            .get(current_id as usize)
+            .ok_or_else(|| invalid("transition diagnostic current is absent"))?;
+        for (contribution, factor) in &current.contributions {
+            if factor.is_zero() {
+                continue;
+            }
+            for parent in contribution.parent_current_ids.iter().copied() {
+                if live.insert(parent) {
+                    queue.push_back(parent);
+                }
+            }
+        }
+    }
+    let digests = live
+        .into_iter()
+        .map(|current_id| {
+            let current = pending
+                .get(current_id as usize)
+                .ok_or_else(|| invalid("transition diagnostic live current is absent"))?;
+            let color = dynamic_color_states
+                .get(current.key.dynamic_lc_color_state_id().get() as usize)
+                .ok_or_else(|| invalid("transition diagnostic live color is absent"))?;
+            super::on_the_fly::hash_current_key(&current.key, color)
+        })
+        .collect::<RusticolResult<BTreeSet<_>>>()?;
+    super::diagnostic::observe_transition_live_current_digests(digests)?;
+    Ok(Some((materialized_sector_id, source_states)))
+}
+
+fn consume_ordered_closure_destination<I, Row, Destination, Emit>(
+    rows: &mut Peekable<I>,
+    sector_id: u32,
+    source_states: &[SourceStateAssignment],
+    destination: Destination,
+    mut emit: Emit,
+) -> RusticolResult<()>
+where
+    I: Iterator<Item = Row>,
+    Destination: for<'row> Fn(&'row Row) -> (u32, &'row [SourceStateAssignment]),
+    Emit: FnMut(Row) -> RusticolResult<()>,
+{
+    while let Some(row) = rows.peek() {
+        let (row_sector_id, row_source_states) = destination(row);
+        let ordering = row_sector_id
+            .cmp(&sector_id)
+            .then_with(|| row_source_states.cmp(source_states));
+        match ordering {
+            std::cmp::Ordering::Less => {
+                return Err(invalid(
+                    "ordered closure emission skipped a destination prefix",
+                ));
+            }
+            std::cmp::Ordering::Equal => emit(
+                rows.next()
+                    .expect("peeked closure destination row disappeared"),
+            )?,
+            std::cmp::Ordering::Greater => break,
+        }
+    }
+    Ok(())
+}
+
+fn require_ordered_closure_destinations_exhausted<I>(rows: &mut Peekable<I>) -> RusticolResult<()>
+where
+    I: Iterator,
+{
+    if rows.peek().is_some() {
+        return Err(invalid(
+            "ordered closure emission left a destination prefix unconsumed",
+        ));
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn complete_closure_target_domain_certificate(
+    strategy: RecurrenceStrategy,
+    process: &OwnedRecurrenceProcessInput,
+    sector_count: usize,
+    exhaustive_closure_sector_ids: &BTreeSet<u32>,
+    exhaustive_closure_sector_owner_ids: &BTreeMap<u32, u32>,
+    replay_targets: &[RecurrenceReplayTarget],
+    helicity_ids: &BTreeMap<Box<[SourceStateAssignment]>, u32>,
+    pending_closures: &BTreeMap<PendingClosureKey, PendingClosureGroup>,
+    candidate_identity_digests_by_group: &[Vec<SemanticDigest>],
+) -> RusticolResult<Option<ClosureTargetDomainCertificateV1>> {
+    if strategy != RecurrenceStrategy::ContractedColorUnion {
+        return Ok(None);
+    }
+    let physical_sector_count = u32::try_from(sector_count)
+        .map_err(|_| invalid("closure target-domain physical-sector count exceeds u32"))?;
+    let expected_sector_ids = (0..physical_sector_count).collect::<BTreeSet<_>>();
+    if exhaustive_closure_sector_owner_ids
+        .keys()
+        .copied()
+        .collect::<BTreeSet<_>>()
+        != *exhaustive_closure_sector_ids
+        || exhaustive_closure_sector_owner_ids
+            .iter()
+            .any(|(sector_id, owner_id)| {
+                !exhaustive_closure_sector_ids.contains(owner_id)
+                    || owner_id > sector_id
+                    || exhaustive_closure_sector_owner_ids.get(owner_id) != Some(owner_id)
+            })
+    {
+        return Err(invalid(
+            "contracted closure target-domain certificate has an invalid owner partition",
+        ));
+    }
+    let resolved_helicity_count = u32::try_from(helicity_ids.len())
+        .map_err(|_| invalid("closure target-domain resolved-helicity count exceeds u32"))?;
+    if resolved_helicity_count == 0 {
+        return Err(invalid(
+            "contracted closure target-domain certificate has no resolved helicities",
+        ));
+    }
+    if candidate_identity_digests_by_group.len() != pending_closures.len() {
+        return Err(invalid(
+            "closure target-domain candidate groups do not match pending closures",
+        ));
+    }
+
+    let mut ordered_helicities = helicity_ids
+        .iter()
+        .map(|(states, helicity_id)| (*helicity_id, states.as_ref()))
+        .collect::<Vec<_>>();
+    ordered_helicities.sort_unstable_by_key(|(helicity_id, _)| *helicity_id);
+    if ordered_helicities
+        .iter()
+        .enumerate()
+        .any(|(index, (helicity_id, _))| *helicity_id != index as u32)
+    {
+        return Err(invalid(
+            "closure target-domain resolved-helicity IDs are not dense",
+        ));
+    }
+
+    let mut closure_source_sector_ids = BTreeMap::<u32, u32>::new();
+    let mut representative_helicity_ids_by_target = BTreeMap::<u32, Vec<u32>>::new();
+    if replay_targets.is_empty() {
+        if exhaustive_closure_sector_ids != &expected_sector_ids {
+            return Err(invalid(
+                "contracted closure target-domain certificate lacks exhaustive physical-sector coverage",
+            ));
+        }
+        let identity_helicity_ids = (0..resolved_helicity_count).collect::<Vec<_>>();
+        for sector_id in expected_sector_ids.iter().copied() {
+            closure_source_sector_ids
+                .insert(sector_id, exhaustive_closure_sector_owner_ids[&sector_id]);
+            representative_helicity_ids_by_target.insert(sector_id, identity_helicity_ids.clone());
+        }
+    } else {
+        if replay_targets.len() != sector_count {
+            return Err(invalid(
+                "contracted closure target-domain replay does not cover every physical sector",
+            ));
+        }
+        let replay_materialized_sector_ids = replay_targets
+            .iter()
+            .map(RecurrenceReplayTarget::materialized_sector_id)
+            .collect::<BTreeSet<_>>();
+        if replay_materialized_sector_ids != *exhaustive_closure_sector_ids {
+            return Err(invalid(
+                "contracted closure target-domain replay representatives disagree with the exhaustive closure domain",
+            ));
+        }
+
+        let mut source_template_by_state = BTreeMap::<(u32, u32), u32>::new();
+        let mut source_state_by_template = BTreeMap::<(u32, u32), u32>::new();
+        for state in &process.source_states {
+            if source_template_by_state
+                .insert(
+                    (state.source_slot, state.state_index),
+                    state.source_template_id,
+                )
+                .is_some()
+                || source_state_by_template
+                    .insert(
+                        (state.source_slot, state.source_template_id),
+                        state.state_index,
+                    )
+                    .is_some()
+            {
+                return Err(invalid(
+                    "contracted closure target-domain replay source states are not bijective",
+                ));
+            }
+        }
+        let source_count = process.external_legs.len();
+        for (target_index, target) in replay_targets.iter().enumerate() {
+            let target_sector_id = u32::try_from(target_index)
+                .map_err(|_| invalid("closure target-domain replay target exceeds u32"))?;
+            if target.id() != target_sector_id
+                || target.target_sector_id() != target_sector_id
+                || !exhaustive_closure_sector_ids.contains(&target.materialized_sector_id())
+            {
+                return Err(invalid(
+                    "contracted closure target-domain replay targets are not canonical",
+                ));
+            }
+            let mut permutation = target.source_slot_permutation().to_vec();
+            permutation.sort_unstable();
+            if permutation.len() != source_count
+                || permutation
+                    .iter()
+                    .copied()
+                    .enumerate()
+                    .any(|(slot, value)| value as usize != slot)
+                || target.source_momentum_signs().len() != source_count
+            {
+                return Err(invalid(
+                    "contracted closure target-domain replay source mapping is not bijective",
+                ));
+            }
+
+            let mut inverse_helicity_ids = vec![MISSING_U32; helicity_ids.len()];
+            for (representative_helicity_id, source_states) in &ordered_helicities {
+                let mut mapped = vec![None; source_count];
+                for assignment in *source_states {
+                    let representative_slot = assignment.source_slot();
+                    let source_template_id = source_template_by_state
+                        .get(&(representative_slot, assignment.state_index()))
+                        .copied()
+                        .ok_or_else(|| {
+                            invalid("closure target-domain replay helicity has no source template")
+                        })?;
+                    let target_slot = target
+                        .source_slot_permutation()
+                        .get(representative_slot as usize)
+                        .copied()
+                        .ok_or_else(|| {
+                            invalid(
+                                "closure target-domain replay source permutation is out of bounds",
+                            )
+                        })?;
+                    let target_state_index = source_state_by_template
+                        .get(&(target_slot, source_template_id))
+                        .copied()
+                        .ok_or_else(|| {
+                            invalid(
+                                "closure target-domain replay cannot transport a source template",
+                            )
+                        })?;
+                    let target_index = usize::try_from(target_slot)
+                        .map_err(|_| invalid("closure replay source slot exceeds usize"))?;
+                    let target_state = mapped.get_mut(target_index).ok_or_else(|| {
+                        invalid("closure target-domain replay target slot is out of bounds")
+                    })?;
+                    if target_state
+                        .replace(SourceStateAssignment::new(target_slot, target_state_index))
+                        .is_some()
+                    {
+                        return Err(invalid(
+                            "closure target-domain replay helicity mapping is not bijective",
+                        ));
+                    }
+                }
+                let mapped = mapped
+                    .into_iter()
+                    .collect::<Option<Vec<_>>>()
+                    .ok_or_else(|| {
+                        invalid("closure target-domain replay does not map every source state")
+                    })?;
+                let mapped_helicity_id = helicity_ids.get(mapped.as_slice()).copied().ok_or_else(
+                    || {
+                        invalid(
+                            "closure target-domain replay maps outside retained helicity coverage",
+                        )
+                    },
+                )?;
+                let inverse_slot = inverse_helicity_ids
+                    .get_mut(mapped_helicity_id as usize)
+                    .ok_or_else(|| {
+                        invalid("closure target-domain replay helicity ID is out of bounds")
+                    })?;
+                if *inverse_slot != MISSING_U32 {
+                    return Err(invalid(
+                        "closure target-domain replay helicity mapping is not one-to-one",
+                    ));
+                }
+                *inverse_slot = *representative_helicity_id;
+            }
+            if inverse_helicity_ids.contains(&MISSING_U32) {
+                return Err(invalid(
+                    "closure target-domain replay helicity mapping is incomplete",
+                ));
+            }
+            closure_source_sector_ids.insert(
+                target_sector_id,
+                exhaustive_closure_sector_owner_ids[&target.materialized_sector_id()],
+            );
+            representative_helicity_ids_by_target.insert(target_sector_id, inverse_helicity_ids);
+        }
+        if closure_source_sector_ids
+            .keys()
+            .copied()
+            .collect::<BTreeSet<_>>()
+            != expected_sector_ids
+        {
+            return Err(invalid(
+                "contracted closure target-domain replay target IDs are not dense",
+            ));
+        }
+    }
+
+    let mut groups_by_target = BTreeMap::<(u32, u32), Vec<usize>>::new();
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-complete-recurrence-closure-target-domain-v1\0");
+    hash.update(physical_sector_count.to_le_bytes());
+    hash.update(resolved_helicity_count.to_le_bytes());
+    hash.update(
+        u64::try_from(exhaustive_closure_sector_ids.len())
+            .map_err(|_| invalid("closure target-domain exhaustive sector count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for sector_id in exhaustive_closure_sector_ids {
+        hash.update(sector_id.to_le_bytes());
+        hash.update(exhaustive_closure_sector_owner_ids[sector_id].to_le_bytes());
+    }
+    hash.update(
+        u64::try_from(replay_targets.len())
+            .map_err(|_| invalid("closure target-domain replay-target count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for target in replay_targets {
+        hash.update(target.id().to_le_bytes());
+        hash.update(target.materialized_sector_id().to_le_bytes());
+        hash.update(target.target_sector_id().to_le_bytes());
+        hash.update(
+            u64::try_from(target.source_slot_permutation().len())
+                .map_err(|_| invalid("closure replay source count exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for source_slot in target.source_slot_permutation() {
+            hash.update(source_slot.to_le_bytes());
+        }
+        for momentum_sign in target.source_momentum_signs() {
+            hash.update(momentum_sign.to_le_bytes());
+        }
+        hash_exact_factor(&mut hash, target.amplitude_factor());
+    }
+    for (helicity_id, source_states) in &ordered_helicities {
+        hash.update(helicity_id.to_le_bytes());
+        hash.update(
+            u64::try_from(source_states.len())
+                .map_err(|_| invalid("closure target-domain source-state count exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for assignment in *source_states {
+            hash.update(assignment.source_slot().to_le_bytes());
+            hash.update(assignment.state_index().to_le_bytes());
+        }
+    }
+
+    hash.update(
+        u64::try_from(pending_closures.len())
+            .map_err(|_| invalid("closure target-domain group count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for (group_index, ((key, group), candidate_digests)) in pending_closures
+        .iter()
+        .zip(candidate_identity_digests_by_group)
+        .enumerate()
+    {
+        if candidate_digests.len() != group.contributions.len() || candidate_digests.is_empty() {
+            return Err(invalid(
+                "closure target-domain candidate identities do not match their proof group",
+            ));
+        }
+        hash.update(key.target_sector_id.to_le_bytes());
+        hash.update(
+            u64::try_from(key.complete_source_states.len())
+                .map_err(|_| invalid("closure target-domain source-state count exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for assignment in &key.complete_source_states {
+            hash.update(assignment.source_slot().to_le_bytes());
+            hash.update(assignment.state_index().to_le_bytes());
+        }
+        hash.update(key.closure_template_id.to_le_bytes());
+        hash.update(
+            key.quantum_flow_template_id
+                .unwrap_or(MISSING_U32)
+                .to_le_bytes(),
+        );
+        hash.update(
+            u64::try_from(key.parent_current_ids.len())
+                .map_err(|_| invalid("closure target-domain parent count exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for parent_id in &key.parent_current_ids {
+            hash.update(parent_id.to_le_bytes());
+        }
+        hash_exact_factor(&mut hash, group.exact_factor);
+        let mut candidate_digests = candidate_digests.clone();
+        candidate_digests.sort_unstable();
+        hash.update(
+            u64::try_from(candidate_digests.len())
+                .map_err(|_| invalid("closure target-domain candidate count exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for digest in candidate_digests {
+            hash.update(digest.as_bytes());
+        }
+        if let Some(helicity_id) = helicity_ids.get(&key.complete_source_states).copied() {
+            groups_by_target
+                .entry((key.target_sector_id, helicity_id))
+                .or_default()
+                .push(group_index);
+        } else if !group.exact_factor.is_zero() {
+            return Err(invalid(
+                "nonzero contracted closure group is outside the resolved-helicity domain",
+            ));
+        }
+    }
+
+    let pending_groups = pending_closures.values().collect::<Vec<_>>();
+    let mut structural_zero_sector_ids = Vec::new();
+    for sector_id in 0..physical_sector_count {
+        let closure_source_sector_id = closure_source_sector_ids[&sector_id];
+        let representative_helicity_ids = &representative_helicity_ids_by_target[&sector_id];
+        let mut sector_has_nonzero_group = false;
+        for target_helicity_id in 0..resolved_helicity_count {
+            let representative_helicity_id =
+                representative_helicity_ids[target_helicity_id as usize];
+            let group_indices = groups_by_target
+                .get(&(closure_source_sector_id, representative_helicity_id))
+                .map(Vec::as_slice)
+                .unwrap_or_default();
+            hash.update(sector_id.to_le_bytes());
+            hash.update(closure_source_sector_id.to_le_bytes());
+            hash.update(target_helicity_id.to_le_bytes());
+            hash.update(representative_helicity_id.to_le_bytes());
+            hash.update(
+                u64::try_from(group_indices.len())
+                    .map_err(|_| invalid("closure target-domain target group count exceeds u64"))?
+                    .to_le_bytes(),
+            );
+            for group_index in group_indices {
+                hash.update(
+                    u64::try_from(*group_index)
+                        .map_err(|_| invalid("closure target-domain group index exceeds u64"))?
+                        .to_le_bytes(),
+                );
+                sector_has_nonzero_group |= !pending_groups[*group_index].exact_factor.is_zero();
+            }
+        }
+        if !sector_has_nonzero_group {
+            structural_zero_sector_ids.push(sector_id);
+        }
+    }
+    let semantic_digest = SemanticDigest::new(hash.finalize().into())?;
+    ClosureTargetDomainCertificateV1::new(
+        physical_sector_count,
+        resolved_helicity_count,
+        structural_zero_sector_ids,
+        semantic_digest,
+    )
+    .map(Some)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn finish_program(
+    strategy: RecurrenceStrategy,
+    process_catalog: &ProcessCatalog<'_>,
+    dynamic_color_states: Vec<DynamicLCColorState>,
+    pending: Vec<PendingCurrent>,
+    mut pending_closures: BTreeMap<PendingClosureKey, PendingClosureGroup>,
+    exhaustive_closure_sector_ids: BTreeSet<u32>,
+    exhaustive_closure_sector_owner_ids: BTreeMap<u32, u32>,
+    replay_targets: Vec<RecurrenceReplayTarget>,
+    retained_helicity_count: u64,
+    helicity_support_rule: HelicitySupportRule,
+    global_helicity_flip_rule: GlobalHelicityFlipRule,
+    reflection_certificates: Vec<PendingReflectionCertificate>,
+) -> RusticolResult<RecurrenceProgram> {
+    validate_pending_reflection_certificates(&reflection_certificates)?;
+
+    pending_closures = retain_supported_pending_closures(
+        strategy,
+        process_catalog,
+        &replay_targets,
+        pending_closures,
+        helicity_support_rule,
+        global_helicity_flip_rule,
+    )?;
+    let sector_count = match strategy {
+        RecurrenceStrategy::TopologyReplay => process_catalog
+            .input
+            .physical_lc_sectors
+            .len()
+            .max(replay_targets.len()),
+        RecurrenceStrategy::AllFlowUnion | RecurrenceStrategy::ContractedColorUnion => {
+            process_catalog.input.physical_lc_sectors.len()
+        }
+    };
+    let helicity_keys = pending_closures
+        .iter()
+        .filter(|(key, group)| {
+            !key.complete_source_states.is_empty() && !group.exact_factor.is_zero()
+        })
+        .map(|(key, _)| key)
+        .map(|key| key.complete_source_states.clone())
+        .collect::<BTreeSet<_>>();
+    let helicity_ids = helicity_keys
+        .iter()
+        .cloned()
+        .enumerate()
+        .map(|(id, key)| (key, id as u32))
+        .collect::<BTreeMap<_, _>>();
+    let resolved_helicities = helicity_keys
+        .into_iter()
+        .enumerate()
+        .map(|(id, source_states)| {
+            let public_helicities = process_catalog.public_helicities(&source_states)?;
+            RecurrenceResolvedHelicity::new(id as u32, source_states.into(), public_helicities)
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    let diagnostic_selected_closure_domain = observe_established_selected_transition_slice(
+        process_catalog,
+        &pending,
+        &pending_closures,
+        &replay_targets,
+        &dynamic_color_states,
+    )?;
+    let mut live = BTreeSet::new();
+    let mut queue = VecDeque::new();
+    for (key, group) in &pending_closures {
+        if group.exact_factor.is_zero() {
+            continue;
+        }
+        for parent in key.parent_current_ids.iter().copied() {
+            if live.insert(parent) {
+                queue.push_back(parent);
+            }
+        }
+    }
+    while let Some(current_id) = queue.pop_front() {
+        for (contribution, factor) in &pending[current_id as usize].contributions {
+            if factor.is_zero() {
+                continue;
+            }
+            for parent in contribution.parent_current_ids.iter().copied() {
+                if live.insert(parent) {
+                    queue.push_back(parent);
+                }
+            }
+        }
+    }
+    let color_projection = if strategy == RecurrenceStrategy::TopologyReplay {
+        plan_topology_replay_color_projection(&pending, &pending_closures)?
+    } else {
+        None
+    };
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    observe_established_pairing_owner(
+        diagnostic_selected_closure_domain.as_ref(),
+        color_projection.as_ref(),
+        &pending_closures,
+    );
+    let materialized = if let Some(projection) = color_projection.as_ref() {
+        materialize_projected_pending_rows(&pending, projection)?
+    } else {
+        materialize_live_pending_rows(&pending, &live)?
+    };
+    let MaterializedPendingRows {
+        remap,
+        currents,
+        contributions,
+        finalizations,
+    } = materialized;
+
+    let destination_keys = pending_closures
+        .iter()
+        .filter(|(_, group)| !group.exact_factor.is_zero())
+        .map(|(key, _)| (key.target_sector_id, key.complete_source_states.clone()))
+        .collect::<BTreeSet<_>>();
+    let mut closure_terms = Vec::new();
+    let mut closure_proof_contributions = Vec::new();
+    let mut closure_proof_groups = Vec::new();
+    let pending_three_line_certificates = pending_closures
+        .values()
+        .flat_map(|group| group.contributions.iter())
+        .filter_map(|contribution| contribution.three_line_certificate.clone())
+        .collect::<BTreeSet<_>>();
+    let three_line_certificate_ids = pending_three_line_certificates
+        .iter()
+        .cloned()
+        .enumerate()
+        .map(|(id, certificate)| {
+            u32::try_from(id)
+                .map(|id| (certificate, id))
+                .map_err(|_| invalid("three-line certificate count exceeds u32"))
+        })
+        .collect::<RusticolResult<BTreeMap<_, _>>>()?;
+    let mut candidate_identity_digests_by_group = Vec::with_capacity(pending_closures.len());
+    for (key, group) in &pending_closures {
+        let target_helicity_id = if key.complete_source_states.is_empty() {
+            None
+        } else {
+            helicity_ids.get(&key.complete_source_states).copied()
+        };
+        let mut group_candidate_identity_digests = Vec::with_capacity(group.contributions.len());
+        for contribution in &group.contributions {
+            group_candidate_identity_digests.push(pending_closure_candidate_identity_digest(
+                key,
+                contribution,
+                target_helicity_id,
+                &pending,
+                &dynamic_color_states,
+                &reflection_certificates,
+            )?);
+        }
+        candidate_identity_digests_by_group.push(group_candidate_identity_digests);
+    }
+    let original_candidate_identity_digests = candidate_identity_digests_by_group
+        .iter()
+        .flatten()
+        .copied()
+        .collect::<Vec<_>>();
+    let closure_target_domain_certificate = complete_closure_target_domain_certificate(
+        strategy,
+        process_catalog.input,
+        sector_count,
+        &exhaustive_closure_sector_ids,
+        &exhaustive_closure_sector_owner_ids,
+        &replay_targets,
+        &helicity_ids,
+        &pending_closures,
+        &candidate_identity_digests_by_group,
+    )?;
+    let mut accepted_candidate_identity_digests = Vec::new();
+    if let Some(projection) = color_projection.as_ref() {
+        for projected in projection.closures.values() {
+            let key = &projected.representative_key;
+            let target_helicity_id = if key.complete_source_states.is_empty() {
+                None
+            } else {
+                helicity_ids.get(&key.complete_source_states).copied()
+            };
+            for contribution in &projected.representative_group.contributions {
+                accepted_candidate_identity_digests.push(
+                    pending_closure_candidate_identity_digest(
+                        key,
+                        contribution,
+                        target_helicity_id,
+                        &pending,
+                        &dynamic_color_states,
+                        &reflection_certificates,
+                    )?,
+                );
+            }
+        }
+        for (key, group) in pending_closures
+            .iter()
+            .filter(|(_, group)| group.exact_factor.is_zero())
+        {
+            let target_helicity_id = if key.complete_source_states.is_empty() {
+                None
+            } else {
+                helicity_ids.get(&key.complete_source_states).copied()
+            };
+            for contribution in &group.contributions {
+                accepted_candidate_identity_digests.push(
+                    pending_closure_candidate_identity_digest(
+                        key,
+                        contribution,
+                        target_helicity_id,
+                        &pending,
+                        &dynamic_color_states,
+                        &reflection_certificates,
+                    )?,
+                );
+            }
+        }
+    } else {
+        accepted_candidate_identity_digests = original_candidate_identity_digests.clone();
+    }
+    let candidate_domain_certificate = ClosureCandidateDomainCertificateV1::from_identity_digests(
+        accepted_candidate_identity_digests,
+    )?;
+    let mut pending_closure_rows = pending_closures
+        .iter()
+        .filter(|(_, group)| !group.exact_factor.is_zero())
+        .peekable();
+    let mut projected_closure_rows = color_projection
+        .as_ref()
+        .map(|projection| projection.closures.values().peekable());
+    let mut amplitude_destinations = Vec::with_capacity(destination_keys.len());
+    let mut destination_ids = BTreeMap::new();
+    for (destination_id, (sector_id, source_states)) in destination_keys.into_iter().enumerate() {
+        let destination_id = u32::try_from(destination_id)
+            .map_err(|_| invalid("closure destination ID exceeds u32"))?;
+        destination_ids.insert((sector_id, source_states.clone()), destination_id);
+        let start = closure_terms.len() as u64;
+        let target_helicity_id = if source_states.is_empty() {
+            None
+        } else {
+            Some(
+                *helicity_ids
+                    .get(&source_states)
+                    .ok_or_else(|| invalid("resolved-helicity destination disappeared"))?,
+            )
+        };
+        if let Some(rows) = projected_closure_rows.as_mut() {
+            consume_ordered_closure_destination(
+                rows,
+                sector_id,
+                &source_states,
+                |projected| {
+                    (
+                        projected.identity.target_sector_id,
+                        projected.identity.complete_source_states.as_ref(),
+                    )
+                },
+                |projected| {
+                    let key = &projected.representative_key;
+                    let group = &projected.representative_group;
+                    let runtime_term_id = u32::try_from(closure_terms.len())
+                        .map_err(|_| invalid("runtime closure-term count exceeds u32"))?;
+                    closure_terms.push(RecurrenceClosureTerm::new(
+                        runtime_term_id,
+                        destination_id,
+                        projected.identity.closure_template_id,
+                        projected.identity.quantum_flow_template_id,
+                        projected.identity.parent_projection_ids.to_vec(),
+                        projected.identity.exact_factor,
+                    )?);
+                    append_closure_proof_group(
+                        key,
+                        group,
+                        &pending,
+                        &dynamic_color_states,
+                        &remap,
+                        Some(destination_id),
+                        target_helicity_id,
+                        Some(runtime_term_id),
+                        &three_line_certificate_ids,
+                        &mut closure_proof_contributions,
+                        &mut closure_proof_groups,
+                    )?;
+                    Ok(())
+                },
+            )?;
+        } else {
+            consume_ordered_closure_destination(
+                &mut pending_closure_rows,
+                sector_id,
+                &source_states,
+                |(key, _)| (key.target_sector_id, key.complete_source_states.as_ref()),
+                |(key, group)| {
+                    let parents = key
+                        .parent_current_ids
+                        .iter()
+                        .map(|id| {
+                            remap
+                                .get(id)
+                                .copied()
+                                .ok_or_else(|| invalid("closure parent is absent"))
+                        })
+                        .collect::<RusticolResult<Vec<_>>>()?;
+                    let runtime_term_id = u32::try_from(closure_terms.len())
+                        .map_err(|_| invalid("runtime closure-term count exceeds u32"))?;
+                    closure_terms.push(RecurrenceClosureTerm::new(
+                        runtime_term_id,
+                        destination_id,
+                        key.closure_template_id,
+                        key.quantum_flow_template_id,
+                        parents,
+                        group.exact_factor,
+                    )?);
+                    append_closure_proof_group(
+                        key,
+                        group,
+                        &pending,
+                        &dynamic_color_states,
+                        &remap,
+                        Some(destination_id),
+                        target_helicity_id,
+                        Some(runtime_term_id),
+                        &three_line_certificate_ids,
+                        &mut closure_proof_contributions,
+                        &mut closure_proof_groups,
+                    )?;
+                    Ok(())
+                },
+            )?;
+        }
+        amplitude_destinations.push(RecurrenceAmplitudeDestination::new(
+            destination_id,
+            sector_id,
+            target_helicity_id,
+            CheckedTableRange::new(start, closure_terms.len() as u64 - start),
+        )?);
+    }
+    if let Some(rows) = projected_closure_rows.as_mut() {
+        require_ordered_closure_destinations_exhausted(rows)?;
+    } else {
+        require_ordered_closure_destinations_exhausted(&mut pending_closure_rows)?;
+    }
+    for (key, group) in pending_closures
+        .iter()
+        .filter(|(_, group)| group.exact_factor.is_zero())
+    {
+        let target_destination_id = destination_ids
+            .get(&(key.target_sector_id, key.complete_source_states.clone()))
+            .copied();
+        let target_helicity_id = if key.complete_source_states.is_empty() {
+            None
+        } else {
+            helicity_ids.get(&key.complete_source_states).copied()
+        };
+        append_closure_proof_group(
+            key,
+            group,
+            &pending,
+            &dynamic_color_states,
+            &remap,
+            target_destination_id,
+            target_helicity_id,
+            None,
+            &three_line_certificate_ids,
+            &mut closure_proof_contributions,
+            &mut closure_proof_groups,
+        )?;
+    }
+    let closure_proofs =
+        ClosureProofMetadataV2::new_with_three_line_certificates_and_candidate_domain(
+            closure_proof_contributions,
+            closure_proof_groups,
+            materialize_reflection_certificates(&reflection_certificates)?,
+            materialize_three_line_certificates(&three_line_certificate_ids)?,
+            candidate_domain_certificate,
+        )?;
+    let mut program = RecurrenceProgram::new_with_closure_proofs(
+        strategy,
+        u32::try_from(sector_count).map_err(|_| invalid("physical sector count exceeds u32"))?,
+        retained_helicity_count,
+        dynamic_color_states,
+        currents,
+        contributions,
+        finalizations,
+        replay_targets,
+        resolved_helicities,
+        amplitude_destinations,
+        closure_terms,
+        closure_proofs,
+    )?;
+    if let Some(certificate) = closure_target_domain_certificate {
+        program = program.with_closure_target_domain_certificate(certificate)?;
+    }
+    if let Some(projection) = color_projection.as_ref() {
+        let body = encode_color_projection_certificate_body(
+            &pending,
+            program.dynamic_color_states(),
+            projection,
+            &original_candidate_identity_digests,
+        )?;
+        program.with_color_projection_certificate_body(body)
+    } else {
+        Ok(program)
+    }
+}
+
+fn helicity_support_rule(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+) -> RusticolResult<HelicitySupportRule> {
+    let extensions = authenticated
+        .process()
+        .semantic_identity()
+        .extension_digests();
+    let mut rule = HelicitySupportRule::None;
+    for role in extensions
+        .keys()
+        .filter(|role| role.starts_with("helicity-support:"))
+    {
+        let candidate = match role.as_str() {
+            PURE_MASSLESS_ADJOINT_HELICITY_SUPPORT_ROLE => {
+                HelicitySupportRule::PureMasslessAdjointTree
+            }
+            _ => {
+                return Err(invalid(format!(
+                    "unsupported recurrence helicity-support proof {role:?}"
+                )));
+            }
+        };
+        if rule != HelicitySupportRule::None {
+            return Err(invalid(
+                "recurrence process carries more than one helicity-support proof",
+            ));
+        }
+        rule = candidate;
+    }
+    Ok(rule)
+}
+
+fn global_helicity_flip_rule(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+) -> RusticolResult<GlobalHelicityFlipRule> {
+    let extensions = authenticated
+        .process()
+        .semantic_identity()
+        .extension_digests();
+    let mut rule = GlobalHelicityFlipRule::None;
+    for role in extensions
+        .keys()
+        .filter(|role| role.starts_with("helicity-equivalence:"))
+    {
+        let candidate = match role.as_str() {
+            GLOBAL_HELICITY_FLIP_EQUIVALENCE_ROLE => GlobalHelicityFlipRule::Proven,
+            _ => {
+                return Err(invalid(format!(
+                    "unsupported recurrence helicity-equivalence proof {role:?}"
+                )));
+            }
+        };
+        if rule != GlobalHelicityFlipRule::None {
+            return Err(invalid(
+                "recurrence process carries more than one helicity-equivalence proof",
+            ));
+        }
+        rule = candidate;
+    }
+    Ok(rule)
+}
+
+fn retain_supported_pending_closures(
+    strategy: RecurrenceStrategy,
+    process_catalog: &ProcessCatalog<'_>,
+    replay_targets: &[RecurrenceReplayTarget],
+    pending_closures: BTreeMap<PendingClosureKey, PendingClosureGroup>,
+    helicity_support_rule: HelicitySupportRule,
+    global_helicity_flip_rule: GlobalHelicityFlipRule,
+) -> RusticolResult<BTreeMap<PendingClosureKey, PendingClosureGroup>> {
+    let pending_closures = if helicity_support_rule == HelicitySupportRule::None {
+        pending_closures
+    } else {
+        pending_closures
+            .into_iter()
+            .filter_map(|(key, group)| {
+                match closure_helicity_is_supported(
+                    helicity_support_rule,
+                    process_catalog,
+                    &key.complete_source_states,
+                ) {
+                    Ok(true) => Some(Ok((key, group))),
+                    Ok(false) => None,
+                    Err(error) => Some(Err(error)),
+                }
+            })
+            .collect::<RusticolResult<BTreeMap<_, _>>>()?
+    };
+    if global_helicity_flip_rule == GlobalHelicityFlipRule::Proven
+        && strategy != RecurrenceStrategy::AllFlowUnion
+    {
+        retain_global_helicity_flip_representatives(
+            strategy,
+            process_catalog,
+            replay_targets,
+            pending_closures,
+        )
+    } else {
+        Ok(pending_closures)
+    }
+}
+
+fn retain_global_helicity_flip_representatives(
+    strategy: RecurrenceStrategy,
+    process_catalog: &ProcessCatalog<'_>,
+    replay_targets: &[RecurrenceReplayTarget],
+    pending_closures: BTreeMap<PendingClosureKey, PendingClosureGroup>,
+) -> RusticolResult<BTreeMap<PendingClosureKey, PendingClosureGroup>> {
+    let source_count = process_catalog.input.external_legs.len();
+    let anchor_slot = if strategy == RecurrenceStrategy::TopologyReplay {
+        (0..source_count)
+            .find(|slot| {
+                replay_targets.iter().all(|target| {
+                    target.source_slot_permutation().get(*slot).copied()
+                        == u32::try_from(*slot).ok()
+                })
+            })
+            .ok_or_else(|| {
+                invalid(
+                    "global-helicity-flip topology replay has no permutation-fixed source anchor",
+                )
+            })?
+    } else {
+        0
+    };
+    let mut source_states_by_public =
+        BTreeMap::<(u32, Vec<i32>), Box<[SourceStateAssignment]>>::new();
+    for key in pending_closures.keys() {
+        if key.complete_source_states.is_empty() {
+            continue;
+        }
+        let public = process_catalog.public_helicities(&key.complete_source_states)?;
+        let map_key = (key.target_sector_id, public);
+        if source_states_by_public
+            .insert(map_key, key.complete_source_states.clone())
+            .is_some_and(|previous| previous != key.complete_source_states)
+        {
+            return Err(invalid(
+                "global-helicity-flip proof maps one public helicity to multiple source assignments",
+            ));
+        }
+    }
+
+    let mut retained_public = BTreeSet::new();
+    for (sector_and_public, source_states) in &source_states_by_public {
+        let (sector_id, public) = sector_and_public;
+        let flipped = public.iter().map(|value| -*value).collect::<Vec<_>>();
+        if flipped == *public {
+            return Err(invalid(
+                "global-helicity-flip proof encountered a fixed public-helicity assignment",
+            ));
+        }
+        let flipped_key = (*sector_id, flipped.clone());
+        if !source_states_by_public.contains_key(&flipped_key) {
+            return Err(invalid(format!(
+                "global-helicity-flip proof has no partner for sector {sector_id} helicity {public:?}",
+            )));
+        }
+        let anchor_helicity = *public
+            .get(anchor_slot)
+            .ok_or_else(|| invalid("global-helicity-flip anchor is outside the public axis"))?;
+        if anchor_helicity == 0 {
+            return Err(invalid(
+                "global-helicity-flip anchor has a self-conjugate public helicity",
+            ));
+        }
+        if anchor_helicity < 0 {
+            retained_public.insert((*sector_id, public.clone()));
+            let partner_states = &source_states_by_public[&flipped_key];
+            if partner_states == source_states {
+                return Err(invalid(
+                    "global-helicity-flip pair reuses one source-state assignment",
+                ));
+            }
+        }
+    }
+    if retained_public
+        .len()
+        .checked_mul(2)
+        .is_none_or(|count| count != source_states_by_public.len())
+    {
+        return Err(invalid(
+            "global-helicity-flip proof does not partition closure destinations into two-cycles",
+        ));
+    }
+
+    pending_closures
+        .into_iter()
+        .filter_map(|(key, group)| {
+            if key.complete_source_states.is_empty() {
+                return Some(Ok((key, group)));
+            }
+            let public = match process_catalog.public_helicities(&key.complete_source_states) {
+                Ok(public) => public,
+                Err(error) => return Some(Err(error)),
+            };
+            retained_public
+                .contains(&(key.target_sector_id, public))
+                .then_some(Ok((key, group)))
+        })
+        .collect()
+}
+
+fn closure_helicity_is_supported(
+    rule: HelicitySupportRule,
+    process_catalog: &ProcessCatalog<'_>,
+    source_states: &[SourceStateAssignment],
+) -> RusticolResult<bool> {
+    if rule == HelicitySupportRule::None || source_states.is_empty() {
+        return Ok(true);
+    }
+    let public_helicities = process_catalog.public_helicities(source_states)?;
+    let mut positive = 0usize;
+    let mut negative = 0usize;
+    for (leg, helicity) in process_catalog
+        .input
+        .external_legs
+        .iter()
+        .zip(public_helicities)
+    {
+        let physical = if leg.is_initial == 1 {
+            -helicity
+        } else {
+            helicity
+        };
+        match physical {
+            1 => positive += 1,
+            -1 => negative += 1,
+            value => {
+                return Err(invalid(format!(
+                    "pure-massless-adjoint helicity proof received unsupported helicity {value}"
+                )));
+            }
+        }
+    }
+    Ok(positive >= 2 && negative >= 2)
+}
+
+fn retained_helicity_count(process: &OwnedRecurrenceProcessInput) -> RusticolResult<u64> {
+    process.external_legs.iter().try_fold(1_u64, |count, leg| {
+        let retained =
+            u64::try_from(retained_source_state_indices(process, leg.source_slot)?.len())
+                .map_err(|_| invalid("retained source-state count exceeds u64"))?;
+        count
+            .checked_mul(retained)
+            .ok_or_else(|| invalid("retained public-helicity count exceeds u64"))
+    })
+}
+
+fn retained_source_state_indices(
+    process: &OwnedRecurrenceProcessInput,
+    source_slot: u32,
+) -> RusticolResult<Vec<u32>> {
+    let leg = process
+        .external_legs
+        .get(source_slot as usize)
+        .ok_or_else(|| invalid("recurrence source slot is absent"))?;
+    if !process.header[0].selected_source_mode()? {
+        return (0..leg.source_state_range.count)
+            .map(|index| {
+                u32::try_from(index)
+                    .map_err(|_| invalid("source-state index exceeds the u32 ID domain"))
+            })
+            .collect();
+    }
+    let retained = process
+        .selected_source_coverage
+        .iter()
+        .filter(|row| row.source_slot == source_slot)
+        .map(|row| row.source_state_index)
+        .collect::<Vec<_>>();
+    if retained.is_empty() {
+        return Err(invalid(format!(
+            "generation-selected recurrence coverage has no state for source slot {source_slot}"
+        )));
+    }
+    Ok(retained)
+}
+
+fn complete_closure_source_states(
+    parents: [&CurrentCoreKey; 2],
+    source_count: usize,
+) -> RusticolResult<Box<[SourceStateAssignment]>> {
+    match (
+        parents[0].helicity_identity(),
+        parents[1].helicity_identity(),
+    ) {
+        (
+            CurrentHelicityIdentity::TopologyReplay {
+                local_source_states: left,
+                ..
+            },
+            CurrentHelicityIdentity::TopologyReplay {
+                local_source_states: right,
+                ..
+            },
+        ) => {
+            let mut result = left.iter().chain(right.iter()).copied().collect::<Vec<_>>();
+            result.sort_unstable();
+            if result.len() != source_count {
+                return Err(invalid(
+                    "topology-replay closure ancestry does not cover every external source",
+                ));
+            }
+            for (source_slot, assignment) in result.iter().copied().enumerate() {
+                if assignment.source_slot() as usize != source_slot {
+                    return Err(invalid(
+                        "topology-replay closure ancestry is incomplete or overlapping",
+                    ));
+                }
+            }
+            Ok(result.into_boxed_slice())
+        }
+        (
+            CurrentHelicityIdentity::AllFlowUnion { .. },
+            CurrentHelicityIdentity::AllFlowUnion { .. },
+        ) => Ok(Box::new([])),
+        (
+            CurrentHelicityIdentity::ContractedColorUnion {
+                local_source_states: left,
+                ..
+            },
+            CurrentHelicityIdentity::ContractedColorUnion {
+                local_source_states: right,
+                ..
+            },
+        ) => {
+            let mut result = left.iter().chain(right.iter()).copied().collect::<Vec<_>>();
+            result.sort_unstable();
+            if result.len() != source_count {
+                return Err(invalid(
+                    "contracted-color closure ancestry does not cover every external source",
+                ));
+            }
+            for (source_slot, assignment) in result.iter().copied().enumerate() {
+                if assignment.source_slot() as usize != source_slot {
+                    return Err(invalid(
+                        "contracted-color closure ancestry is incomplete or overlapping",
+                    ));
+                }
+            }
+            Ok(result.into_boxed_slice())
+        }
+        _ => Err(invalid(
+            "closure parents use incompatible recurrence helicity strategies",
+        )),
+    }
+}
+
+#[cfg(test)]
+fn quantum_flow_matches(
+    quantum: QuantumFlowRow,
+    parents: &[&CurrentCoreKey; 2],
+    catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<bool> {
+    let states = catalog.u32_sequence(quantum.input_state_sequence_id, "quantum input states")?;
+    let spins = catalog.i32_sequence(quantum.input_spin_sequence_id, "quantum input spins")?;
+    let flavours = catalog.u32_sequence(
+        quantum.input_flavour_sequence_id,
+        "quantum input flavour flows",
+    )?;
+    let quantum_numbers = catalog.u32_sequence(
+        quantum.input_quantum_sequence_id,
+        "quantum input number flows",
+    )?;
+    if states.len() != 2 || spins.len() != 2 || flavours.len() != 2 || quantum_numbers.len() != 2 {
+        return Err(invalid(
+            "direct recurrence requires binary quantum-flow contracts",
+        ));
+    }
+    for index in 0..2 {
+        // The authenticated model contract proves that branch admission is
+        // independent of accumulated flavour and quantum-number ancestry.
+        // Those template columns describe the seed probe used to certify the
+        // branch, while state and spin remain the actual admission keys.
+        let _ = catalog.flavour_flow(flavours[index], "quantum parent flavour")?;
+        let _ = quantum_numbers[index];
+        if states[index] != parents[index].current_state_template_id()
+            || !quantum_parent_spin_matches(spins[index], parents[index])
+        {
+            return Ok(false);
+        }
+    }
+    Ok(true)
+}
+
+pub(super) fn quantum_parent_spin_matches(required_spin: i32, parent: &CurrentCoreKey) -> bool {
+    required_spin == parent.spin_state_class()
+        || (parent.node_kind() == RecurrenceNodeKind::Source
+            && parent.helicity_identity().strategy() == RecurrenceStrategy::AllFlowUnion
+            && parent.spin_state_class() == DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS)
+}
+
+#[cfg(test)]
+fn quantum_flow_result_flavour(
+    quantum: QuantumFlowRow,
+    parents: &[&CurrentCoreKey; 2],
+    catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<Vec<i32>> {
+    let operation = catalog.string(
+        quantum.flavour_flow_operation_string_id,
+        "quantum-flow flavour operation",
+    )?;
+    let static_result = catalog.flavour_flow(
+        quantum.result_flavour_flow_id,
+        "quantum-flow result flavour",
+    )?;
+    let result_particle = *static_result
+        .last()
+        .ok_or_else(|| invalid("quantum-flow result flavour ancestry is empty"))?;
+
+    // The prepared recurrence contract has already proved that transition
+    // admission and kernel selection are independent of accumulated flavour
+    // ancestry.  In the runtime-helicity union, retaining the construction
+    // history would nevertheless split one physical current into many
+    // numerically accumulated copies.  Canonicalize it to the result species,
+    // matching the compact all-flow recurrence identity.
+    if parents
+        .iter()
+        .all(|parent| parent.helicity_identity().strategy() == RecurrenceStrategy::AllFlowUnion)
+    {
+        return Ok(vec![result_particle]);
+    }
+
+    let append_result = |parent: &CurrentCoreKey| {
+        let mut result = parent.flavour_flow().to_vec();
+        if result.last().copied() != Some(result_particle) {
+            result.push(result_particle);
+        }
+        result
+    };
+
+    match operation {
+        "constant-result" => Ok(static_result.to_vec()),
+        "append-left-result" => Ok(append_result(parents[0])),
+        "append-right-result" => Ok(append_result(parents[1])),
+        "concat-left-right-result" => {
+            let mut result = Vec::with_capacity(
+                parents[0]
+                    .flavour_flow()
+                    .len()
+                    .saturating_add(parents[1].flavour_flow().len())
+                    .saturating_add(1),
+            );
+            result.extend_from_slice(parents[0].flavour_flow());
+            result.extend_from_slice(parents[1].flavour_flow());
+            result.push(result_particle);
+            Ok(result)
+        }
+        value => Err(invalid(format!(
+            "unsupported quantum-flow flavour operation {value:?}"
+        ))),
+    }
+}
+
+fn expected_sector_components(
+    sector: ProcessPhysicalLCSectorRow,
+    process: &OwnedRecurrenceProcessInput,
+    catalog: &ProcessCatalog<'_>,
+) -> RusticolResult<Vec<LCColorComponent>> {
+    let mut result = Vec::new();
+    match sector.kind()? {
+        ProcessLCSectorKind::Singlet => {}
+        ProcessLCSectorKind::SingleTrace => result.push(LCColorComponent::new(
+            LCColorComponentKind::Trace,
+            catalog
+                .u32_sequence(sector.trace_sequence_id, "physical LC trace")?
+                .to_vec(),
+        )?),
+        ProcessLCSectorKind::OpenLines => {
+            let range = sector
+                .open_string_range
+                .as_usize_range(process.lc_open_strings.len(), "physical LC open strings")?;
+            for row in &process.lc_open_strings[range] {
+                let mut word = vec![row.fundamental_source_slot];
+                word.extend_from_slice(
+                    catalog.u32_sequence(
+                        row.adjoint_sequence_id,
+                        "physical LC open-string adjoints",
+                    )?,
+                );
+                word.push(row.antifundamental_source_slot);
+                result.push(LCColorComponent::new(
+                    LCColorComponentKind::OpenString,
+                    word,
+                )?);
+            }
+        }
+    }
+    Ok(result)
+}
+
+fn closed_components_match_prepared_sector(
+    strategy: RecurrenceStrategy,
+    closed: &[LCColorComponent],
+    sector: &PreparedClosureSector,
+) -> RusticolResult<bool> {
+    if sector.row.kind()? != ProcessLCSectorKind::OpenLines {
+        return Ok(closed == sector.expected_components.as_ref());
+    }
+    if !unordered_color_components_match(closed, &sector.expected_components) {
+        return Ok(false);
+    }
+    if strategy == RecurrenceStrategy::ContractedColorUnion
+        && !sector.contracted_color_canonical_owner
+    {
+        return Ok(false);
+    }
+    Ok(true)
+}
+
+fn unordered_color_components_match(left: &[LCColorComponent], right: &[LCColorComponent]) -> bool {
+    if left.len() != right.len() {
+        return false;
+    }
+    let mut matched = vec![false; right.len()];
+    for component in left {
+        let Some(index) = right.iter().enumerate().find_map(|(index, candidate)| {
+            (!matched[index] && candidate == component).then_some(index)
+        }) else {
+            return false;
+        };
+        matched[index] = true;
+    }
+    true
+}
+
+fn materialized_sector_ids(
+    strategy: RecurrenceStrategy,
+    process: &OwnedRecurrenceProcessInput,
+    replay_targets: &[RecurrenceReplayTarget],
+) -> BTreeSet<u32> {
+    match strategy {
+        RecurrenceStrategy::AllFlowUnion => process
+            .physical_lc_sectors
+            .iter()
+            .map(|sector| sector.sector_id)
+            .collect(),
+        RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion
+            if !replay_targets.is_empty() =>
+        {
+            replay_targets
+                .iter()
+                .map(RecurrenceReplayTarget::materialized_sector_id)
+                .collect()
+        }
+        RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion => process
+            .physical_lc_sectors
+            .iter()
+            .map(|sector| sector.sector_id)
+            .collect(),
+    }
+}
+
+fn construction_sector_groups(
+    strategy: RecurrenceStrategy,
+    materialized_sectors: &BTreeSet<u32>,
+    replay_targets: &[RecurrenceReplayTarget],
+) -> Vec<BTreeSet<u32>> {
+    if strategy.uses_topology_replay_targets()
+        && !replay_targets.is_empty()
+        && materialized_sectors.len() > 1
+    {
+        materialized_sectors
+            .iter()
+            .copied()
+            .map(|sector_id| BTreeSet::from([sector_id]))
+            .collect()
+    } else {
+        vec![materialized_sectors.clone()]
+    }
+}
+
+fn build_replay_targets(
+    strategy: RecurrenceStrategy,
+    process: &OwnedRecurrenceProcessInput,
+    catalog: &ProcessCatalog<'_>,
+) -> RusticolResult<Vec<RecurrenceReplayTarget>> {
+    if !strategy.uses_topology_replay_targets()
+        || (strategy == RecurrenceStrategy::ContractedColorUnion
+            && process.replay_partitions.is_empty())
+    {
+        // Contracted color is replay-capable, but only an authenticated
+        // partition certificate activates replay.  Synthesizing identity
+        // targets here would incorrectly materialize ordering aliases that
+        // contracted construction coherently accumulates in an owner sector.
+        return Ok(Vec::new());
+    }
+    let source_momentum_signs = external_source_momentum_signs(process)?;
+    let retained_flows = retained_public_flows(process)?;
+    let retained_sectors = retained_flows
+        .iter()
+        .map(|flow| flow.construction_sector_id)
+        .collect::<BTreeSet<_>>();
+    let mut base_by_sector = BTreeMap::<u32, (u32, Vec<u32>, ExactComplexRational)>::new();
+    for partition in &process.replay_partitions {
+        let range = partition
+            .target_range
+            .as_usize_range(process.replay_targets.len(), "recurrence replay targets")?;
+        for target in &process.replay_targets[range] {
+            if !retained_sectors.contains(&target.sector_id) {
+                continue;
+            }
+            let mut factor = catalog.factor(
+                target.amplitude_phase_factor_id,
+                "recurrence replay amplitude phase",
+            )?;
+            if target.fermion_sign == -1 {
+                factor = factor.checked_neg()?;
+            }
+            let previous = base_by_sector.insert(
+                target.sector_id,
+                (
+                    partition.materialized_sector_id,
+                    catalog
+                        .u32_sequence(
+                            target.source_slot_permutation_sequence_id,
+                            "recurrence replay source permutation",
+                        )?
+                        .to_vec(),
+                    factor,
+                ),
+            );
+            if previous.is_some() {
+                return Err(invalid(format!(
+                    "construction sector {} has multiple recurrence replay targets",
+                    target.sector_id
+                )));
+            }
+        }
+    }
+    let identity = (0..process.external_legs.len())
+        .map(|slot| u32::try_from(slot).map_err(|_| invalid("source-slot count exceeds u32")))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    for sector_id in retained_sectors {
+        base_by_sector
+            .entry(sector_id)
+            .or_insert_with(|| (sector_id, identity.clone(), ExactComplexRational::ONE));
+    }
+    retained_flows
+        .into_iter()
+        .enumerate()
+        .map(|(target_sector_id, flow)| {
+            let (materialized, construction_permutation, factor) = base_by_sector
+                .get(&flow.construction_sector_id)
+                .ok_or_else(|| invalid("public flow construction replay target is absent"))?;
+            let public_permutation = catalog.u32_sequence(
+                flow.source_slot_permutation_sequence_id,
+                "public LC flow source permutation",
+            )?;
+            if construction_permutation.len() != public_permutation.len() {
+                return Err(invalid(
+                    "public LC flow and construction replay permutations have different sizes",
+                ));
+            }
+            let permutation =
+                compose_gather_permutations(construction_permutation, public_permutation)?;
+            let replay_momentum_signs =
+                replay_momentum_signs(&source_momentum_signs, &permutation)?;
+            RecurrenceReplayTarget::new(
+                u32::try_from(target_sector_id)
+                    .map_err(|_| invalid("replay-target count exceeds u32"))?,
+                *materialized,
+                u32::try_from(target_sector_id)
+                    .map_err(|_| invalid("public-flow target ID exceeds u32"))?,
+                permutation,
+                replay_momentum_signs,
+                *factor,
+            )
+        })
+        .collect()
+}
+
+fn external_source_momentum_signs(
+    process: &OwnedRecurrenceProcessInput,
+) -> RusticolResult<Vec<i32>> {
+    process
+        .external_legs
+        .iter()
+        .enumerate()
+        .map(|(source_slot, leg)| {
+            let range = leg.source_state_range.as_usize_range(
+                process.source_states.len(),
+                "external source momentum signs",
+            )?;
+            let mut signs = process.source_states[range]
+                .iter()
+                .map(|state| {
+                    if state.source_slot as usize != source_slot
+                        || !matches!(state.momentum_sign, -1 | 1)
+                    {
+                        return Err(invalid(format!(
+                            "source slot {source_slot} has an invalid momentum-sign contract"
+                        )));
+                    }
+                    Ok(state.momentum_sign)
+                })
+                .collect::<RusticolResult<BTreeSet<_>>>()?;
+            if signs.len() != 1 {
+                return Err(invalid(format!(
+                    "source slot {source_slot} has helicity-dependent momentum crossing"
+                )));
+            }
+            signs
+                .pop_first()
+                .ok_or_else(|| invalid(format!("source slot {source_slot} has no source states")))
+        })
+        .collect()
+}
+
+fn replay_momentum_signs(
+    source_momentum_signs: &[i32],
+    representative_to_public: &[u32],
+) -> RusticolResult<Vec<i32>> {
+    representative_to_public
+        .iter()
+        .copied()
+        .enumerate()
+        .map(|(representative_slot, public_slot)| {
+            let representative_sign = source_momentum_signs
+                .get(representative_slot)
+                .copied()
+                .filter(|sign| matches!(sign, -1 | 1))
+                .ok_or_else(|| invalid("representative source momentum sign is absent"))?;
+            let public_sign = source_momentum_signs
+                .get(public_slot as usize)
+                .copied()
+                .filter(|sign| matches!(sign, -1 | 1))
+                .ok_or_else(|| invalid("public source momentum sign is absent"))?;
+            Ok(representative_sign * public_sign)
+        })
+        .collect()
+}
+
+fn compose_gather_permutations(
+    representative_to_construction: &[u32],
+    construction_to_public: &[u32],
+) -> RusticolResult<Vec<u32>> {
+    if representative_to_construction.len() != construction_to_public.len() {
+        return Err(invalid(
+            "public LC flow and construction replay permutations have different sizes",
+        ));
+    }
+    representative_to_construction
+        .iter()
+        .map(|construction_slot| {
+            construction_to_public
+                .get(*construction_slot as usize)
+                .copied()
+                .ok_or_else(|| invalid("construction replay permutation is out of range"))
+        })
+        .collect()
+}
+
+fn retained_public_flows(
+    process: &OwnedRecurrenceProcessInput,
+) -> RusticolResult<Vec<&super::process::ProcessPublicLCFlowRow>> {
+    if !process.header[0].selected_flow_mode()? {
+        return Ok(process.public_lc_flows.iter().collect());
+    }
+    let selected = process
+        .selected_public_flow_coverage
+        .iter()
+        .map(|row| row.flow_id)
+        .collect::<BTreeSet<_>>();
+    Ok(process
+        .public_lc_flows
+        .iter()
+        .filter(|flow| selected.contains(&flow.flow_id))
+        .collect())
+}
+
+fn propagator_by_state(
+    template: &OwnedRecurrenceTemplateInput,
+) -> RusticolResult<BTreeMap<u32, Option<u32>>> {
+    let mut result = BTreeMap::new();
+    for row in &template.propagators {
+        let value = (row.applies_propagator != 0).then_some(row.id);
+        if result.insert(row.state_template_id, value).is_some() {
+            return Err(invalid(format!(
+                "current-state template {} has multiple propagators",
+                row.state_template_id
+            )));
+        }
+    }
+    Ok(result)
+}
+
+fn coupling_limits(
+    process: &ProcessCatalog<'_>,
+    template: &TemplateCatalog<'_>,
+) -> RusticolResult<Vec<Option<u32>>> {
+    let mut limits = vec![None; template.coupling_names.len()];
+    for row in &process.input.coupling_limits {
+        let name = process.string(row.name_string_id, "process coupling limit")?;
+        if let Ok(index) = template.coupling_names.binary_search(&name) {
+            limits[index] = Some(row.maximum);
+        }
+    }
+    Ok(limits)
+}
+
+pub(super) fn combined_coupling_orders(
+    left: &[u32],
+    right: &[u32],
+    local: &[u32],
+    limits: &[Option<u32>],
+) -> RusticolResult<Option<Vec<u32>>> {
+    if left.len() != right.len() || left.len() != local.len() || left.len() != limits.len() {
+        return Err(invalid(
+            "coupling-order vectors have inconsistent dimensions",
+        ));
+    }
+    let mut result = Vec::with_capacity(left.len());
+    for index in 0..left.len() {
+        let value = left[index]
+            .checked_add(right[index])
+            .and_then(|value| value.checked_add(local[index]))
+            .ok_or_else(|| invalid("coupling order exceeds u32"))?;
+        if limits[index].is_some_and(|maximum| value > maximum) {
+            return Ok(None);
+        }
+        result.push(value);
+    }
+    Ok(Some(result))
+}
+
+pub(super) fn merged_helicity_identity(
+    left: &CurrentHelicityIdentity,
+    right: &CurrentHelicityIdentity,
+    result_spin: i32,
+) -> RusticolResult<CurrentHelicityIdentity> {
+    match (left, right) {
+        (
+            CurrentHelicityIdentity::TopologyReplay {
+                local_source_states: left,
+                ..
+            },
+            CurrentHelicityIdentity::TopologyReplay {
+                local_source_states: right,
+                ..
+            },
+        ) => {
+            let mut values = left.iter().chain(right.iter()).copied().collect::<Vec<_>>();
+            values.sort_unstable();
+            CurrentHelicityIdentity::topology_replay(result_spin, values)
+        }
+        (
+            CurrentHelicityIdentity::AllFlowUnion { .. },
+            CurrentHelicityIdentity::AllFlowUnion { .. },
+        ) => Ok(CurrentHelicityIdentity::all_flow_union(result_spin)),
+        (
+            CurrentHelicityIdentity::ContractedColorUnion {
+                local_source_states: left,
+                ..
+            },
+            CurrentHelicityIdentity::ContractedColorUnion {
+                local_source_states: right,
+                ..
+            },
+        ) => {
+            let mut values = left.iter().chain(right.iter()).copied().collect::<Vec<_>>();
+            values.sort_unstable();
+            CurrentHelicityIdentity::contracted_color_union(result_spin, values)
+        }
+        _ => Err(invalid(
+            "cannot merge recurrence helicity identities from different strategies",
+        )),
+    }
+}
+
+fn merged_disjoint_support(left: &[u32], right: &[u32]) -> Vec<u32> {
+    debug_assert!(left.iter().copied().is_sorted());
+    debug_assert!(right.iter().copied().is_sorted());
+    let mut result = Vec::with_capacity(left.len() + right.len());
+    let mut left_index = 0;
+    let mut right_index = 0;
+    while left_index < left.len() && right_index < right.len() {
+        match left[left_index].cmp(&right[right_index]) {
+            std::cmp::Ordering::Less => {
+                result.push(left[left_index]);
+                left_index += 1;
+            }
+            std::cmp::Ordering::Greater => {
+                result.push(right[right_index]);
+                right_index += 1;
+            }
+            std::cmp::Ordering::Equal => {
+                unreachable!("compact support index emitted overlapping parents")
+            }
+        }
+    }
+    result.extend_from_slice(&left[left_index..]);
+    result.extend_from_slice(&right[right_index..]);
+    result
+}
+
+#[cfg(test)]
+fn merged_support(left: &[u32], right: &[u32]) -> RusticolResult<Vec<u32>> {
+    if !disjoint_support(left, right) {
+        return Err(invalid(
+            "recurrence parents have overlapping source support",
+        ));
+    }
+    let mut result = left.iter().chain(right).copied().collect::<Vec<_>>();
+    result.sort_unstable();
+    Ok(result)
+}
+
+#[cfg(test)]
+fn disjoint_support(left: &[u32], right: &[u32]) -> bool {
+    left.iter().all(|slot| right.binary_search(slot).is_err())
+}
+
+pub(super) fn merged_momentum(
+    left: &CanonicalMomentumLinearForm,
+    right: &CanonicalMomentumLinearForm,
+) -> RusticolResult<CanonicalMomentumLinearForm> {
+    let mut terms = left
+        .terms()
+        .iter()
+        .chain(right.terms())
+        .copied()
+        .collect::<Vec<_>>();
+    terms.sort_unstable_by_key(|term| term.source_slot);
+    CanonicalMomentumLinearForm::new(terms)
+}
+
+#[cfg(test)]
+fn authenticate_runtime_coupling(
+    catalog: &TemplateCatalog<'_>,
+    quantum: QuantumFlowRow,
+    binding_coupling_factor_id: u32,
+    label: &str,
+) -> RusticolResult<ExactComplexRational> {
+    let quantum_coupling = catalog.factor(
+        quantum.exact_coupling_factor_id,
+        &format!("{label} quantum-flow coupling"),
+    )?;
+    let binding_coupling = catalog.factor(
+        binding_coupling_factor_id,
+        &format!("{label} binding coupling"),
+    )?;
+    if quantum_coupling != binding_coupling {
+        return Err(invalid(format!(
+            "{label} binding coupling does not match its quantum-flow coupling witness"
+        )));
+    }
+    Ok(binding_coupling)
+}
+
+pub(super) fn output_factor_from_binding(
+    binding_coupling: ExactComplexRational,
+    output_factor_source: u8,
+    label: &str,
+) -> RusticolResult<ExactComplexRational> {
+    let component = match OutputFactorSource::try_from(output_factor_source)? {
+        OutputFactorSource::None => return Ok(ExactComplexRational::ONE),
+        OutputFactorSource::CouplingReal => binding_coupling.real(),
+        OutputFactorSource::CouplingImag => binding_coupling.imag(),
+    };
+    if component.is_zero() {
+        return Err(invalid(format!(
+            "{label} selects a zero binding-coupling component"
+        )));
+    }
+    Ok(ExactComplexRational::new(component, ExactRational::ZERO))
+}
+
+#[cfg(test)]
+fn canonical_evaluator_parents(
+    concrete_parent_ids: [u32; 2],
+    canonical_input_order: &[u32],
+    input_exchange_factor_id: u32,
+    catalog: &TemplateCatalog<'_>,
+    label: &str,
+) -> RusticolResult<([u32; 2], ExactComplexRational)> {
+    let mut ordered = match canonical_input_order {
+        [0, 1] => concrete_parent_ids,
+        [1, 0] => [concrete_parent_ids[1], concrete_parent_ids[0]],
+        _ => {
+            return Err(invalid(format!(
+                "{label} canonical input order is not a binary permutation"
+            )));
+        }
+    };
+    let mut factor = ExactComplexRational::ONE;
+    if input_exchange_factor_id != MISSING_U32 && ordered[1] < ordered[0] {
+        ordered.swap(0, 1);
+        factor = catalog.factor(input_exchange_factor_id, &format!("{label} input-exchange"))?;
+    }
+    Ok((ordered, factor))
+}
+
+pub(super) fn multiply_factors(
+    values: &[ExactComplexRational],
+) -> RusticolResult<ExactComplexRational> {
+    values
+        .iter()
+        .copied()
+        .try_fold(ExactComplexRational::ONE, ExactComplexRational::checked_mul)
+}
+
+pub(super) fn aggregate_factor(
+    target: &mut ExactComplexRational,
+    value: ExactComplexRational,
+) -> RusticolResult<()> {
+    *target = target.checked_add(value)?;
+    Ok(())
+}
+
+fn decode_strings<'a>(
+    ranges: &[CheckedTableRange],
+    bytes: &'a [u8],
+    label: &str,
+) -> RusticolResult<Vec<&'a str>> {
+    ranges
+        .iter()
+        .copied()
+        .enumerate()
+        .map(|(index, range)| {
+            let range = range.as_usize_range(bytes.len(), &format!("{label} {index}"))?;
+            std::str::from_utf8(&bytes[range])
+                .map_err(|error| invalid(format!("{label} {index} is not UTF-8: {error}")))
+        })
+        .collect()
+}
+
+fn required_string<'a>(strings: &[&'a str], id: u32, label: &str) -> RusticolResult<&'a str> {
+    strings
+        .get(id as usize)
+        .copied()
+        .ok_or_else(|| invalid(format!("{label} string {id} is absent")))
+}
+
+fn indexed_sequence<'a, T>(
+    ranges: &[super::template::IndexedRangeRow],
+    values: &'a [T],
+    id: u32,
+    label: &str,
+) -> RusticolResult<&'a [T]> {
+    let range = ranges
+        .get(id as usize)
+        .ok_or_else(|| invalid(format!("{label} sequence {id} is absent")))?
+        .range
+        .as_usize_range(values.len(), label)?;
+    Ok(&values[range])
+}
+
+fn decode_template_factors(
+    input: &OwnedRecurrenceTemplateInput,
+    strings: &[&str],
+) -> RusticolResult<Vec<ExactComplexRational>> {
+    input
+        .exact_factors
+        .iter()
+        .map(|row| {
+            ExactComplexRational::parse_parts(
+                required_string(strings, row.real_numerator_string_id, "factor numerator")?,
+                required_string(
+                    strings,
+                    row.real_denominator_string_id,
+                    "factor denominator",
+                )?,
+                required_string(strings, row.imag_numerator_string_id, "factor numerator")?,
+                required_string(
+                    strings,
+                    row.imag_denominator_string_id,
+                    "factor denominator",
+                )?,
+            )
+        })
+        .collect()
+}
+
+fn decode_process_factors(
+    input: &OwnedRecurrenceProcessInput,
+    strings: &[&str],
+) -> RusticolResult<Vec<ExactComplexRational>> {
+    input
+        .exact_factors
+        .iter()
+        .map(|row| {
+            ExactComplexRational::parse_parts(
+                required_string(strings, row.real_numerator_string_id, "factor numerator")?,
+                required_string(
+                    strings,
+                    row.real_denominator_string_id,
+                    "factor denominator",
+                )?,
+                required_string(strings, row.imag_numerator_string_id, "factor numerator")?,
+                required_string(
+                    strings,
+                    row.imag_denominator_string_id,
+                    "factor denominator",
+                )?,
+            )
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::{BTreeMap, BTreeSet};
+
+    use super::super::contact_orbit_owner::{
+        ContactOrbitStepProof, contact_orbit_application_for_test,
+        final_contact_orbit_step_for_test, partial_contact_orbit_step_for_test,
+        prepared_contact_orbit_transition_for_test,
+    };
+    use super::super::process::{
+        ProcessExternalLegRow, ProcessHeaderRow, ProcessLCOpenStringRow,
+        ProcessPhysicalLCSectorRow, ProcessPublicLCFlowRow, ProcessSourceStateRow,
+    };
+    use super::super::template::{
+        ColorContractionRow, DigestCatalogRow, ExactFactorRow, IndexedRangeRow,
+        LCColorTransitionWitnessRow, PropagatorRow, QuantumFlowRow,
+    };
+    use super::super::{LCColorEndpoint, LCColorPortBinding};
+    use super::*;
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).expect("test digest must be nonzero")
+    }
+
+    #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+    struct OrderedClosureTestRow {
+        sector_id: u32,
+        source_states: Box<[SourceStateAssignment]>,
+        ordinal: u32,
+    }
+
+    #[test]
+    fn ordered_closure_destination_cursor_preserves_filter_order_and_fails_closed() {
+        let states =
+            |state_index| vec![SourceStateAssignment::new(0, state_index)].into_boxed_slice();
+        let mut rows = [
+            OrderedClosureTestRow {
+                sector_id: 2,
+                source_states: states(0),
+                ordinal: 4,
+            },
+            OrderedClosureTestRow {
+                sector_id: 0,
+                source_states: states(1),
+                ordinal: 1,
+            },
+            OrderedClosureTestRow {
+                sector_id: 0,
+                source_states: states(1),
+                ordinal: 0,
+            },
+            OrderedClosureTestRow {
+                sector_id: 1,
+                source_states: states(0),
+                ordinal: 3,
+            },
+            OrderedClosureTestRow {
+                sector_id: 0,
+                source_states: states(0),
+                ordinal: 2,
+            },
+        ];
+        rows.sort_unstable();
+        let destinations = rows
+            .iter()
+            .map(|row| (row.sector_id, row.source_states.clone()))
+            .collect::<BTreeSet<_>>();
+        let expected = destinations
+            .iter()
+            .flat_map(|(sector_id, source_states)| {
+                rows.iter()
+                    .filter(move |row| {
+                        row.sector_id == *sector_id
+                            && row.source_states.as_ref() == source_states.as_ref()
+                    })
+                    .map(|row| row.ordinal)
+            })
+            .collect::<Vec<_>>();
+
+        let mut cursor = rows.iter().peekable();
+        let mut observed = Vec::new();
+        for (sector_id, source_states) in &destinations {
+            consume_ordered_closure_destination(
+                &mut cursor,
+                *sector_id,
+                source_states,
+                |row: &&OrderedClosureTestRow| (row.sector_id, row.source_states.as_ref()),
+                |row| {
+                    observed.push(row.ordinal);
+                    Ok(())
+                },
+            )
+            .unwrap();
+        }
+        require_ordered_closure_destinations_exhausted(&mut cursor).unwrap();
+        assert_eq!(observed, expected);
+        assert_eq!(observed, [2, 0, 1, 3, 4]);
+
+        let mut skipped_prefix = rows.iter().peekable();
+        assert!(
+            consume_ordered_closure_destination(
+                &mut skipped_prefix,
+                1,
+                &states(0),
+                |row: &&OrderedClosureTestRow| (row.sector_id, row.source_states.as_ref()),
+                |_| Ok(()),
+            )
+            .is_err()
+        );
+
+        let mut unconsumed_suffix = rows.iter().peekable();
+        consume_ordered_closure_destination(
+            &mut unconsumed_suffix,
+            0,
+            &states(0),
+            |row: &&OrderedClosureTestRow| (row.sector_id, row.source_states.as_ref()),
+            |_| Ok(()),
+        )
+        .unwrap();
+        assert!(require_ordered_closure_destinations_exhausted(&mut unconsumed_suffix).is_err());
+    }
+
+    fn proven_reflection(
+        color: &DynamicLCColorState,
+        phase: ExactComplexRational,
+        root: u8,
+    ) -> CurrentReflection {
+        CurrentReflection::Proven(
+            CurrentReflectionProof::new(
+                phase,
+                [digest(root)],
+                dynamic_color_identity_digest(color).unwrap(),
+            )
+            .unwrap(),
+        )
+    }
+
+    fn proven_interned_reflection(
+        colors: &DynamicLCColorStateInterner,
+        color_id: DynamicLCColorStateId,
+        phase: ExactComplexRational,
+        root: u8,
+    ) -> CurrentReflection {
+        proven_reflection(colors.get(color_id).unwrap(), phase, root)
+    }
+
+    fn transition(id: u32) -> TransitionRow {
+        TransitionRow {
+            id,
+            template_string_id: 0,
+            input_state_sequence_id: 0,
+            result_state_template_id: 0,
+            quantum_flow_template_id: 0,
+            evaluator_binding_id: 0,
+            canonical_input_order_sequence_id: 0,
+            momentum_convention_sequence_id: 0,
+            coupling_parameter_sequence_id: 0,
+            coupling_order_set_id: 0,
+            color_contraction_template_id: 0,
+            binding_coupling_factor_id: 0,
+            exact_factor_id: 0,
+            output_factor_source: 0,
+            equivalence_class_string_id: 0,
+            input_exchange_factor_id: MISSING_U32,
+            output_projection_string_id: 0,
+            contact_orbit_step_sequence_id: 0,
+            contact_orbit_step_semantic_digest_sequence_id: 0,
+            semantic_digest_id: 0,
+        }
+    }
+
+    fn source(id: u32) -> SourceRow {
+        SourceRow {
+            id,
+            template_string_id: 1,
+            state_template_id: id,
+            crossing_string_id: 2,
+            wavefunction_family_string_id: 3,
+            helicity: if id == 0 { -1 } else { 1 },
+            spin_state: if id == 0 { -1 } else { 1 },
+            flavour_flow_id: 4,
+            quantum_number_flow_id: 5,
+            lc_color_seed_operation: 6,
+            lc_color_seed_shape_string_id: 7,
+            lc_color_seed_component_kind: 8,
+            lc_color_seed_component_role: 9,
+            lc_color_seed_proof_digest_id: 10 + id,
+            lc_color_seed_provenance_sequence_id: 11,
+            wavefunction_expression_digest_id: 12 + id,
+            evaluator_binding_id: 13 + id,
+            mass_parameter_id: 14,
+            width_parameter_id: 15,
+            semantic_digest_id: 16 + id,
+        }
+    }
+
+    #[test]
+    fn union_source_dispatch_ignores_proof_instance_identity_only() {
+        let left = source(0);
+        let right = source(1);
+        assert_ne!(
+            left.lc_color_seed_proof_digest_id,
+            right.lc_color_seed_proof_digest_id
+        );
+        assert!(same_union_source_dispatch_semantics(left, right));
+
+        let mut incompatible = right;
+        incompatible.crossing_string_id += 1;
+        assert!(!same_union_source_dispatch_semantics(left, incompatible));
+
+        let mut incompatible = right;
+        incompatible.lc_color_seed_provenance_sequence_id += 1;
+        assert!(!same_union_source_dispatch_semantics(left, incompatible));
+    }
+
+    #[test]
+    fn all_flow_union_source_spin_class_is_dynamic_for_chiral_variants() {
+        assert_eq!(
+            union_spin_state_class(25, &BTreeSet::from([-1, 1])).unwrap(),
+            DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS
+        );
+        assert_eq!(
+            union_spin_state_class(25, &BTreeSet::from([-1])).unwrap(),
+            -1
+        );
+        assert!(
+            union_spin_state_class(25, &BTreeSet::from([DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS]),)
+                .is_err()
+        );
+
+        let mut colors = DynamicLCColorStateInterner::default();
+        let color_id = colors
+            .intern(DynamicLCColorState::new(0, None, vec![]).unwrap())
+            .unwrap();
+        let source = CurrentCoreKey::new(
+            digest(202),
+            RecurrenceNodeKind::Source,
+            17,
+            color_id,
+            vec![0],
+            CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                source_slot: 0,
+                coefficient: 1,
+            }])
+            .unwrap(),
+            CurrentHelicityIdentity::all_flow_union(DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS),
+            vec![0],
+            0,
+            vec![],
+            CurrentSourceBinding::runtime_dispatch(25, vec![0, 1]).unwrap(),
+            None,
+        )
+        .unwrap();
+
+        assert!(quantum_parent_spin_matches(-1, &source));
+        assert!(quantum_parent_spin_matches(1, &source));
+        assert!(structural_parent_states_match(
+            [StructuralState::new(17, -1), StructuralState::new(19, 0),],
+            [
+                StructuralState::new(17, DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS),
+                StructuralState::new(19, 0),
+            ],
+        ));
+    }
+
+    #[test]
+    fn pure_adjoint_reflection_masks_require_exact_parent_proofs() {
+        let left = DynamicLCColorState::new_port_wired(
+            1,
+            vec![
+                LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                LCColorPortBinding::new(0, LCColorEndpoint::Front),
+            ],
+            vec![LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![1, 4]).unwrap()],
+        )
+        .unwrap();
+        let right = DynamicLCColorState::new_port_wired(
+            1,
+            vec![
+                LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                LCColorPortBinding::new(0, LCColorEndpoint::Front),
+            ],
+            vec![LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![2, 3]).unwrap()],
+        )
+        .unwrap();
+        let minus_one = ExactComplexRational::ONE.checked_neg().unwrap();
+        let reflections = [
+            proven_reflection(&left, minus_one, 40),
+            proven_reflection(&right, minus_one, 41),
+        ];
+
+        assert_eq!(
+            current_reversal_masks(&[left.clone(), right.clone()], &reflections),
+            [0, 1, 2, 3],
+        );
+        let partial_reflections = [
+            proven_reflection(&left, minus_one, 42),
+            CurrentReflection::Unavailable,
+        ];
+        assert_eq!(
+            current_reversal_masks(&[left, right], &partial_reflections),
+            [0, 1],
+        );
+    }
+
+    #[test]
+    fn source_reflection_lineage_is_deterministic_and_color_bound() {
+        let mut colors = DynamicLCColorStateInterner::default();
+        let first_color = colors
+            .intern(
+                DynamicLCColorState::new_port_wired(
+                    1,
+                    vec![
+                        LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                        LCColorPortBinding::new(0, LCColorEndpoint::Front),
+                    ],
+                    vec![
+                        LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![3])
+                            .unwrap(),
+                    ],
+                )
+                .unwrap(),
+            )
+            .unwrap();
+        let second_color = colors
+            .intern(
+                DynamicLCColorState::new_port_wired(
+                    2,
+                    vec![
+                        LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                        LCColorPortBinding::new(0, LCColorEndpoint::Front),
+                    ],
+                    vec![
+                        LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![3])
+                            .unwrap(),
+                    ],
+                )
+                .unwrap(),
+            )
+            .unwrap();
+        let seed = digest(39);
+        let first = source_reflection(&colors, first_color, 3, seed)
+            .unwrap()
+            .proof()
+            .unwrap()
+            .clone();
+        let repeated = source_reflection(&colors, first_color, 3, seed)
+            .unwrap()
+            .proof()
+            .unwrap()
+            .clone();
+        let changed_slot = source_reflection(&colors, first_color, 4, seed)
+            .unwrap()
+            .proof()
+            .unwrap()
+            .clone();
+        let changed_color = source_reflection(&colors, second_color, 3, seed)
+            .unwrap()
+            .proof()
+            .unwrap()
+            .clone();
+
+        assert_eq!(first, repeated);
+        assert_ne!(first.proof_digest(), changed_slot.proof_digest());
+        assert_ne!(first.proof_digest(), changed_color.proof_digest());
+        assert_ne!(
+            first.result_color_identity(),
+            changed_color.result_color_identity()
+        );
+    }
+
+    #[test]
+    fn pure_adjoint_result_reflection_is_phase_composed_and_canonical() {
+        let result = DynamicLCColorState::new_port_wired(
+            1,
+            vec![
+                LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                LCColorPortBinding::new(0, LCColorEndpoint::Front),
+            ],
+            vec![
+                LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![1, 3, 2]).unwrap(),
+            ],
+        )
+        .unwrap();
+        let minus_one = ExactComplexRational::ONE.checked_neg().unwrap();
+        let left = proven_reflection(&result, minus_one, 43);
+        let right = proven_reflection(&result, minus_one, 44);
+        let local = TransitionReflectionProof::new(minus_one, [digest(45)], [digest(46)]).unwrap();
+        let proof = current_reflection_candidate(&result, &[left, right], Some(&local))
+            .unwrap()
+            .unwrap();
+        assert_eq!(proof.phase(), minus_one);
+        assert_eq!(
+            proof.result_color_identity(),
+            dynamic_color_identity_digest(&result).unwrap()
+        );
+        assert!(proof.lineage_roots().contains(&digest(43)));
+        assert!(proof.lineage_roots().contains(&digest(44)));
+        assert!(proof.lineage_roots().contains(&digest(45)));
+        assert!(proof.lineage_roots().contains(&digest(46)));
+        assert!(proof.lineage_roots().contains(&local.proof_digest));
+        assert!(pure_adjoint_word_is_canonical(
+            result.pure_adjoint_word().unwrap()
+        ));
+        assert!(!pure_adjoint_word_is_canonical(&[3, 2, 1]));
+    }
+
+    fn reflection_test_current(
+        color_id: DynamicLCColorStateId,
+        reflection: CurrentReflection,
+    ) -> PendingCurrent {
+        PendingCurrent {
+            key: CurrentCoreKey::new(
+                digest(201),
+                RecurrenceNodeKind::Current,
+                0,
+                color_id,
+                vec![0, 1, 2],
+                CanonicalMomentumLinearForm::new(vec![
+                    MomentumTerm {
+                        source_slot: 0,
+                        coefficient: 1,
+                    },
+                    MomentumTerm {
+                        source_slot: 1,
+                        coefficient: 1,
+                    },
+                    MomentumTerm {
+                        source_slot: 2,
+                        coefficient: 1,
+                    },
+                ])
+                .unwrap(),
+                CurrentHelicityIdentity::all_flow_union(0),
+                vec![0],
+                0,
+                vec![],
+                CurrentSourceBinding::None,
+                None,
+            )
+            .unwrap(),
+            source_exact_factor: None,
+            contributions: BTreeMap::new(),
+            realized_pairing_rule_ids: BTreeSet::new(),
+            reflection,
+            reflection_certificate_id: None,
+        }
+    }
+
+    fn reflection_test_states() -> (
+        DynamicLCColorStateInterner,
+        DynamicLCColorStateId,
+        DynamicLCColorStateId,
+    ) {
+        let canonical = DynamicLCColorState::new_port_wired(
+            1,
+            vec![
+                LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                LCColorPortBinding::new(0, LCColorEndpoint::Front),
+            ],
+            vec![
+                LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![1, 3, 2]).unwrap(),
+            ],
+        )
+        .unwrap();
+        let reversed = canonical.reversed().unwrap();
+        let mut states = DynamicLCColorStateInterner::default();
+        let canonical_id = states.intern(canonical).unwrap();
+        let reversed_id = states.intern(reversed).unwrap();
+        (states, canonical_id, reversed_id)
+    }
+
+    #[test]
+    fn late_unproved_reflection_keeps_both_stage_orientations() {
+        let minus_one = ExactComplexRational::ONE.checked_neg().unwrap();
+        let (mut color_states, canonical_id, reversed_id) = reflection_test_states();
+        let mut late_downgrade =
+            proven_interned_reflection(&color_states, reversed_id, minus_one, 51);
+        late_downgrade.include(None).unwrap();
+        let mut currents = vec![
+            reflection_test_current(
+                canonical_id,
+                proven_interned_reflection(&color_states, canonical_id, minus_one, 50),
+            ),
+            reflection_test_current(reversed_id, late_downgrade),
+        ];
+        let mut current_ids = currents
+            .iter()
+            .enumerate()
+            .map(|(id, current)| (current.key.clone(), id as u32))
+            .collect::<TransientCurrentIdIndex>();
+        let mut target_bucket = vec![0, 1];
+        let mut certificates = Vec::new();
+        let mut resident_contribution_count = 0;
+
+        reconcile_stage_reflections(
+            0,
+            &mut color_states,
+            &mut currents,
+            &mut current_ids,
+            &mut target_bucket,
+            &mut certificates,
+            4,
+            &mut resident_contribution_count,
+        )
+        .unwrap();
+
+        assert_eq!(currents.len(), 2);
+        assert_eq!(target_bucket, [0, 1]);
+        assert_eq!(current_ids.len(), 2);
+        assert!(certificates.is_empty());
+        assert!(
+            currents
+                .iter()
+                .all(|current| current.reflection == CurrentReflection::Unavailable)
+        );
+    }
+
+    #[test]
+    fn late_conflicting_reflection_keeps_both_stage_orientations() {
+        let minus_one = ExactComplexRational::ONE.checked_neg().unwrap();
+        let (mut color_states, canonical_id, reversed_id) = reflection_test_states();
+        let mut late_downgrade =
+            proven_interned_reflection(&color_states, reversed_id, minus_one, 53);
+        late_downgrade
+            .include(Some(
+                CurrentReflectionProof::new(minus_one, [digest(54)], digest(55)).unwrap(),
+            ))
+            .unwrap();
+        let mut currents = vec![
+            reflection_test_current(
+                canonical_id,
+                proven_interned_reflection(&color_states, canonical_id, minus_one, 52),
+            ),
+            reflection_test_current(reversed_id, late_downgrade),
+        ];
+        let mut current_ids = currents
+            .iter()
+            .enumerate()
+            .map(|(id, current)| (current.key.clone(), id as u32))
+            .collect::<TransientCurrentIdIndex>();
+        let mut target_bucket = vec![0, 1];
+        let mut certificates = Vec::new();
+        let mut resident_contribution_count = 0;
+
+        reconcile_stage_reflections(
+            0,
+            &mut color_states,
+            &mut currents,
+            &mut current_ids,
+            &mut target_bucket,
+            &mut certificates,
+            4,
+            &mut resident_contribution_count,
+        )
+        .unwrap();
+
+        assert_eq!(currents.len(), 2);
+        assert_eq!(target_bucket, [0, 1]);
+        assert_eq!(current_ids.len(), 2);
+        assert!(certificates.is_empty());
+        assert!(
+            currents
+                .iter()
+                .all(|current| current.reflection == CurrentReflection::Unavailable)
+        );
+    }
+
+    #[test]
+    fn nonreciprocal_reflection_proofs_keep_both_stage_orientations() {
+        let minus_one = ExactComplexRational::ONE.checked_neg().unwrap();
+        let (mut color_states, canonical_id, reversed_id) = reflection_test_states();
+        let mut currents = vec![
+            reflection_test_current(
+                canonical_id,
+                proven_interned_reflection(&color_states, canonical_id, minus_one, 56),
+            ),
+            reflection_test_current(
+                reversed_id,
+                proven_interned_reflection(
+                    &color_states,
+                    reversed_id,
+                    ExactComplexRational::ONE,
+                    57,
+                ),
+            ),
+        ];
+        let mut current_ids = currents
+            .iter()
+            .enumerate()
+            .map(|(id, current)| (current.key.clone(), id as u32))
+            .collect::<TransientCurrentIdIndex>();
+        let mut target_bucket = vec![0, 1];
+        let mut certificates = Vec::new();
+        let mut resident_contribution_count = 0;
+
+        reconcile_stage_reflections(
+            0,
+            &mut color_states,
+            &mut currents,
+            &mut current_ids,
+            &mut target_bucket,
+            &mut certificates,
+            4,
+            &mut resident_contribution_count,
+        )
+        .unwrap();
+
+        assert_eq!(currents.len(), 2);
+        assert_eq!(target_bucket, [0, 1]);
+        assert_eq!(current_ids.len(), 2);
+        assert!(certificates.is_empty());
+        assert!(
+            currents
+                .iter()
+                .all(|current| current.reflection == CurrentReflection::Unavailable)
+        );
+    }
+
+    #[test]
+    fn complete_reciprocal_reflection_prunes_only_noncanonical_orientation() {
+        let minus_one = ExactComplexRational::ONE.checked_neg().unwrap();
+        let (mut color_states, canonical_id, reversed_id) = reflection_test_states();
+        let mut currents = vec![
+            reflection_test_current(
+                canonical_id,
+                proven_interned_reflection(&color_states, canonical_id, minus_one, 58),
+            ),
+            reflection_test_current(
+                reversed_id,
+                proven_interned_reflection(&color_states, reversed_id, minus_one, 59),
+            ),
+        ];
+        let mut current_ids = currents
+            .iter()
+            .enumerate()
+            .map(|(id, current)| (current.key.clone(), id as u32))
+            .collect::<TransientCurrentIdIndex>();
+        let mut target_bucket = vec![0, 1];
+        let mut certificates = Vec::new();
+        let mut resident_contribution_count = 0;
+        let mut support_keys = TransientCurrentSupportKeys::from_currents(4, &currents).unwrap();
+        let mut support_buckets =
+            LaneSupportBuckets::new(&[vec![], vec![], vec![0, 1], vec![]], &support_keys).unwrap();
+
+        reconcile_stage_reflections(
+            0,
+            &mut color_states,
+            &mut currents,
+            &mut current_ids,
+            &mut target_bucket,
+            &mut certificates,
+            4,
+            &mut resident_contribution_count,
+        )
+        .unwrap();
+        support_keys.reconcile_stage_tail(0, &currents).unwrap();
+        support_buckets
+            .replace_bucket(3, &target_bucket, &support_keys)
+            .unwrap();
+
+        assert_eq!(currents.len(), 1);
+        assert_eq!(target_bucket, [0]);
+        assert_eq!(current_ids.len(), 1);
+        assert_eq!(support_keys.keys_by_current.len(), 1);
+        let disjoint = support_buckets
+            .bucket_mut(3)
+            .unwrap()
+            .disjoint_current_ids(&TransientSupportKey::singleton(4, 3).unwrap())
+            .unwrap()
+            .0;
+        assert_eq!(
+            disjoint
+                .iter()
+                .map(|entry| entry.current_id)
+                .collect::<Vec<_>>(),
+            [0]
+        );
+        assert_eq!(certificates.len(), 1);
+        let certificate = &certificates[0];
+        assert_eq!(certificate.id, 0);
+        assert_eq!(certificate.canonical_old_current_id, 0);
+        assert_eq!(certificate.reflected_old_current_id, 1);
+        assert_eq!(certificate.canonical_phase, minus_one);
+        assert_eq!(certificate.reflected_phase, minus_one);
+        assert_eq!(certificate.source_permutation.as_ref(), [0, 2, 1, 3]);
+        assert!(!certificate.fixed_point);
+        assert_eq!(certificate.orbit_size, 2);
+        validate_pending_reflection_certificates(&certificates).unwrap();
+        let mut stale_lineage = certificates.clone();
+        stale_lineage[0].canonical_lineage_digest = digest(60);
+        assert!(validate_pending_reflection_certificates(&stale_lineage).is_err());
+        assert_eq!(currents[0].reflection.phase(), Some(minus_one));
+        let color = color_states
+            .get(currents[0].key.dynamic_lc_color_state_id())
+            .unwrap();
+        assert!(pure_adjoint_word_is_canonical(
+            color.pure_adjoint_word().unwrap()
+        ));
+    }
+
+    #[test]
+    fn transient_current_index_insertion_order_cannot_change_canonical_reconciliation() {
+        let run = |reverse_index_insertion: bool| {
+            let minus_one = ExactComplexRational::ONE.checked_neg().unwrap();
+            let (mut color_states, canonical_id, reversed_id) = reflection_test_states();
+            let mut currents = vec![
+                reflection_test_current(
+                    canonical_id,
+                    proven_interned_reflection(&color_states, canonical_id, minus_one, 91),
+                ),
+                reflection_test_current(
+                    reversed_id,
+                    proven_interned_reflection(&color_states, reversed_id, minus_one, 92),
+                ),
+            ];
+            let mut insertion_order = [0_usize, 1];
+            if reverse_index_insertion {
+                insertion_order.reverse();
+            }
+            let mut current_ids = TransientCurrentIdIndex::new();
+            for current_id in insertion_order {
+                assert!(
+                    current_ids
+                        .insert(currents[current_id].key.clone(), current_id as u32)
+                        .is_none()
+                );
+            }
+            let mut target_bucket = vec![0, 1];
+            let mut certificates = Vec::new();
+            let mut resident_contribution_count = 0;
+            reconcile_stage_reflections(
+                0,
+                &mut color_states,
+                &mut currents,
+                &mut current_ids,
+                &mut target_bucket,
+                &mut certificates,
+                4,
+                &mut resident_contribution_count,
+            )
+            .unwrap();
+            (
+                currents
+                    .into_iter()
+                    .map(|current| current.key)
+                    .collect::<Vec<_>>(),
+                target_bucket,
+                certificates,
+                resident_contribution_count,
+            )
+        };
+
+        assert_eq!(run(false), run(true));
+    }
+
+    #[test]
+    fn reflected_closure_emission_reuses_parents_and_applies_exact_phase() {
+        let factor = ExactComplexRational::parse_parts("2", "1", "0", "1").unwrap();
+        let minus_one = ExactComplexRational::ONE.checked_neg().unwrap();
+        let key = PendingClosureKey {
+            target_sector_id: 119,
+            complete_source_states: Vec::new().into_boxed_slice(),
+            closure_template_id: 3,
+            quantum_flow_template_id: Some(5),
+            parent_current_ids: vec![7, 9].into_boxed_slice(),
+        };
+        let contribution = PendingClosureProofContribution {
+            construction_parent_ids: [7, 9],
+            construction_parent_permutation: [0, 1],
+            reconstruction_parent_permutation: [0, 1],
+            evaluator_parent_permutation: [0, 1],
+            closure_template_semantic_digest: digest(111),
+            color_witness_term_id: 13,
+            color_witness_proof_digest: digest(112),
+            three_line_certificate: None,
+            pairing_certificate_ids: Vec::new().into_boxed_slice(),
+            reflection_certificate_id: Some(17),
+            exact_factor: factor,
+        };
+        let projection = ClosureReflectionProjection {
+            certificate_id: 17,
+            partner_sector_id: Some(153),
+            partner_phase: minus_one,
+        };
+        let mut closures = BTreeMap::new();
+
+        include_closure_with_reflection(&mut closures, key, contribution, Some(projection))
+            .unwrap();
+
+        assert_eq!(closures.len(), 2);
+        let canonical = closures
+            .iter()
+            .find(|(key, _)| key.target_sector_id == 119)
+            .unwrap();
+        let reflected = closures
+            .iter()
+            .find(|(key, _)| key.target_sector_id == 153)
+            .unwrap();
+        assert_eq!(canonical.1.exact_factor, factor);
+        assert_eq!(
+            reflected.1.exact_factor,
+            factor.checked_mul(minus_one).unwrap()
+        );
+        assert_eq!(
+            canonical.0.parent_current_ids,
+            reflected.0.parent_current_ids
+        );
+        assert_eq!(canonical.1.contributions[0].construction_parent_ids, [7, 9]);
+        assert_eq!(reflected.1.contributions[0].construction_parent_ids, [7, 9]);
+        assert_eq!(
+            reflected.1.contributions[0].reflection_certificate_id,
+            Some(17)
+        );
+
+        let mut ineligible = BTreeMap::new();
+        include_closure_with_reflection(
+            &mut ineligible,
+            canonical.0.clone(),
+            canonical.1.contributions[0].clone(),
+            None,
+        )
+        .unwrap();
+        assert_eq!(ineligible.len(), 1);
+    }
+
+    fn buffered_parent_pairs(target_size: usize, currents_by_size: &[Vec<u32>]) -> Vec<[u32; 2]> {
+        let mut pairs = Vec::new();
+        for left_size in 1..target_size {
+            let right_size = target_size - left_size;
+            for &left_id in &currents_by_size[left_size - 1] {
+                for &right_id in &currents_by_size[right_size - 1] {
+                    if left_id < right_id {
+                        pairs.push([left_id, right_id]);
+                    }
+                }
+            }
+        }
+        pairs.sort_unstable();
+        pairs.dedup();
+        pairs
+    }
+
+    #[test]
+    fn streamed_parent_pairs_match_buffered_reference_order() {
+        let fixtures = [
+            (2, vec![vec![0, 1, 2, 3]]),
+            (3, vec![vec![0, 1, 2, 3], vec![4, 5, 6, 7, 8, 9]]),
+            (
+                4,
+                vec![
+                    vec![0, 1, 2, 3],
+                    vec![4, 5, 6, 7, 8, 9],
+                    vec![10, 11, 12, 13],
+                ],
+            ),
+        ];
+        for (target_size, currents_by_size) in fixtures {
+            assert_eq!(
+                parent_pairs_for_target(target_size, &currents_by_size).collect::<Vec<_>>(),
+                buffered_parent_pairs(target_size, &currents_by_size),
+                "support size {target_size}",
+            );
+        }
+    }
+
+    #[test]
+    fn streamed_parent_pair_totals_match_iteration() {
+        for (target_size, currents_by_size) in [
+            (2, vec![vec![0, 1, 2, 3]]),
+            (3, vec![vec![0, 1, 2, 3], vec![4, 5, 6, 7, 8, 9]]),
+            (
+                4,
+                vec![
+                    vec![0, 1, 2, 3],
+                    vec![4, 5, 6, 7, 8, 9],
+                    vec![10, 11, 12, 13],
+                ],
+            ),
+        ] {
+            assert_eq!(
+                parent_pair_total_for_target(target_size, &currents_by_size).unwrap(),
+                parent_pairs_for_target(target_size, &currents_by_size).count(),
+                "support size {target_size}",
+            );
+        }
+    }
+
+    fn compact_pair_schedule(
+        source_count: usize,
+        target_size: usize,
+        currents_by_size: &[Vec<u32>],
+        source_slots_by_current: &[Vec<u32>],
+    ) -> DisjointParentPairSchedule {
+        let support_keys = TransientCurrentSupportKeys {
+            source_count,
+            keys_by_current: source_slots_by_current
+                .iter()
+                .map(|source_slots| {
+                    TransientSupportKey::from_source_slots(source_count, source_slots).unwrap()
+                })
+                .collect(),
+        };
+        let mut support_buckets = LaneSupportBuckets::new(currents_by_size, &support_keys).unwrap();
+        disjoint_parent_pairs_for_target(
+            target_size,
+            currents_by_size,
+            &support_keys,
+            &mut support_buckets,
+        )
+        .unwrap()
+    }
+
+    fn reference_disjoint_parent_pairs(
+        target_size: usize,
+        currents_by_size: &[Vec<u32>],
+        source_slots_by_current: &[Vec<u32>],
+    ) -> Vec<[u32; 2]> {
+        reference_disjoint_parent_pair_schedule(
+            target_size,
+            currents_by_size,
+            source_slots_by_current,
+        )
+        .into_iter()
+        .map(|pair| pair.parent_ids)
+        .collect()
+    }
+
+    fn reference_disjoint_parent_pair_schedule(
+        target_size: usize,
+        currents_by_size: &[Vec<u32>],
+        source_slots_by_current: &[Vec<u32>],
+    ) -> Vec<OrderedDisjointParentPair> {
+        parent_pairs_for_target(target_size, currents_by_size)
+            .enumerate()
+            .filter_map(|(candidate_index, parent_ids)| {
+                let [left_id, right_id] = parent_ids;
+                disjoint_support(
+                    &source_slots_by_current[left_id as usize],
+                    &source_slots_by_current[right_id as usize],
+                )
+                .then_some(OrderedDisjointParentPair {
+                    parent_ids,
+                    theoretical_candidate_count: candidate_index + 1,
+                })
+            })
+            .collect()
+    }
+
+    fn next_random(seed: &mut u64) -> u64 {
+        *seed = seed
+            .wrapping_mul(6_364_136_223_846_793_005)
+            .wrapping_add(1_442_695_040_888_963_407);
+        *seed
+    }
+
+    fn random_support(seed: &mut u64, source_count: usize, size: usize) -> Vec<u32> {
+        let mut support = BTreeSet::new();
+        while support.len() < size {
+            support.insert((next_random(seed) as usize % source_count) as u32);
+        }
+        support.into_iter().collect()
+    }
+
+    #[test]
+    fn compact_disjoint_parent_pairs_match_randomized_reference_order() {
+        let mut seed = 0x6a09_e667_f3bc_c909;
+        for case_index in 0..160 {
+            let source_count = 4 + next_random(&mut seed) as usize % 7;
+            let target_size = 2 + next_random(&mut seed) as usize % (source_count - 2);
+            let mut currents_by_size = vec![Vec::new(); target_size - 1];
+            let mut source_slots_by_current = Vec::new();
+            for support_size in 1..target_size {
+                let current_count = 2 + next_random(&mut seed) as usize % 9;
+                for _ in 0..current_count {
+                    let source_slots = random_support(&mut seed, source_count, support_size);
+                    let current_id = source_slots_by_current.len() as u32;
+                    source_slots_by_current.push(source_slots);
+                    currents_by_size[support_size - 1].push(current_id);
+                }
+            }
+
+            let reference = reference_disjoint_parent_pair_schedule(
+                target_size,
+                &currents_by_size,
+                &source_slots_by_current,
+            );
+            let unfiltered_count = parent_pairs_for_target(target_size, &currents_by_size).count();
+            let schedule = compact_pair_schedule(
+                source_count,
+                target_size,
+                &currents_by_size,
+                &source_slots_by_current,
+            );
+            assert_eq!(
+                schedule.theoretical_candidate_count, unfiltered_count,
+                "case {case_index}",
+            );
+            let emitted = schedule.pairs.map(|pair| pair.unwrap()).collect::<Vec<_>>();
+            assert_eq!(
+                emitted, reference,
+                "case {case_index}, source_count={source_count}, target_size={target_size}",
+            );
+        }
+    }
+
+    #[test]
+    fn compact_disjoint_parent_pairs_preserve_duplicates_and_wide_supports() {
+        let source_count = 137;
+        let currents_by_size = vec![vec![0, 1, 2, 3], vec![4, 5, 6, 7]];
+        let source_slots_by_current = vec![
+            vec![0],
+            vec![128],
+            vec![128],
+            vec![136],
+            vec![0, 64],
+            vec![1, 128],
+            vec![64, 136],
+            vec![1, 128],
+        ];
+        assert!(matches!(
+            TransientSupportKey::from_source_slots(source_count, &[0, 64, 128, 136]).unwrap(),
+            TransientSupportKey::Wide { .. }
+        ));
+        let left = TransientSupportKey::from_source_slots(source_count, &[0, 128]).unwrap();
+        let right = TransientSupportKey::from_source_slots(source_count, &[64, 136]).unwrap();
+        assert_eq!(
+            left.union_disjoint(&right).unwrap().source_slots(),
+            [0, 64, 128, 136]
+        );
+
+        let reference =
+            reference_disjoint_parent_pairs(3, &currents_by_size, &source_slots_by_current);
+        let schedule =
+            compact_pair_schedule(source_count, 3, &currents_by_size, &source_slots_by_current);
+        assert!(schedule.support_bucket_cache_hit_count > 0);
+        assert_eq!(
+            schedule
+                .pairs
+                .map(|pair| pair.unwrap().parent_ids)
+                .collect::<Vec<_>>(),
+            reference
+        );
+    }
+
+    #[test]
+    fn disjoint_pair_schedule_releases_bucket_cache_before_emission() {
+        let source_count = 6;
+        let currents_by_size = vec![vec![0, 1, 2, 3], vec![4, 5, 6, 7]];
+        let source_slots_by_current = vec![
+            vec![0],
+            vec![0],
+            vec![1],
+            vec![2],
+            vec![0, 1],
+            vec![2, 3],
+            vec![3, 4],
+            vec![1, 5],
+        ];
+        let support_keys = TransientCurrentSupportKeys {
+            source_count,
+            keys_by_current: source_slots_by_current
+                .iter()
+                .map(|support| {
+                    TransientSupportKey::from_source_slots(source_count, support).unwrap()
+                })
+                .collect(),
+        };
+        let mut support_buckets =
+            LaneSupportBuckets::new(&currents_by_size, &support_keys).unwrap();
+        let schedule = disjoint_parent_pairs_for_target(
+            3,
+            &currents_by_size,
+            &support_keys,
+            &mut support_buckets,
+        )
+        .unwrap();
+
+        assert!(schedule.support_bucket_cache_hit_count > 0);
+        assert_eq!(support_buckets.cached_disjoint_query_count(), 0);
+        assert_eq!(support_buckets.cached_disjoint_capacity(), 0);
+        assert_eq!(
+            schedule
+                .pairs
+                .map(|pair| pair.unwrap().parent_ids)
+                .collect::<Vec<_>>(),
+            reference_disjoint_parent_pairs(3, &currents_by_size, &source_slots_by_current),
+        );
+        assert_eq!(support_buckets.cached_disjoint_query_count(), 0);
+        assert_eq!(support_buckets.cached_disjoint_capacity(), 0);
+    }
+
+    #[test]
+    fn transient_wide_support_validates_padding_and_source_domain() {
+        let exact = TransientSupportKey::from_source_slots(129, &[0, 64, 128]).unwrap();
+        assert_eq!(exact.source_count(), 129);
+        assert_eq!(exact.source_slots(), [0, 64, 128]);
+        assert!(
+            TransientSupportKey::full(129)
+                .unwrap()
+                .without_source_slot(129)
+                .is_err()
+        );
+
+        let padding_bit = TransientSupportKey::Wide {
+            source_count: 129,
+            words: vec![0, 0, 2].into_boxed_slice(),
+        };
+        assert!(padding_bit.validate().is_err());
+        let truncated = TransientSupportKey::Wide {
+            source_count: 129,
+            words: vec![0, 0].into_boxed_slice(),
+        };
+        assert!(truncated.validate().is_err());
+
+        let left = TransientSupportKey::from_source_slots(129, &[0]).unwrap();
+        let other_domain = TransientSupportKey::from_source_slots(130, &[1]).unwrap();
+        assert!(left.is_disjoint(&other_domain).is_err());
+        assert!(left.union_disjoint(&other_domain).is_err());
+        assert_ne!(left, other_domain);
+    }
+
+    #[test]
+    fn state_index_preserves_interleaved_reference_transition_order() {
+        let rows = [
+            (transition(0), [1, 2]),
+            (transition(1), [2, 1]),
+            (transition(2), [1, 2]),
+            (transition(3), [3, 4]),
+            (transition(4), [2, 1]),
+        ];
+        let mut index = TransitionStateIndex::default();
+        for (row, input_states) in rows {
+            index.insert(row, input_states);
+        }
+
+        let actual = index
+            .rows(1, 2)
+            .iter()
+            .map(|indexed| Ok((indexed.row.id, indexed.parent_ids(1, 2, 10, 20)?)))
+            .collect::<RusticolResult<Vec<_>>>()
+            .unwrap();
+        let reference = rows
+            .iter()
+            .flat_map(|(row, input_states)| {
+                let mut applications = Vec::new();
+                if *input_states == [1, 2] {
+                    applications.push((row.id, [10, 20]));
+                }
+                if *input_states == [2, 1] {
+                    applications.push((row.id, [20, 10]));
+                }
+                applications
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(actual, reference);
+        assert_eq!(
+            actual,
+            [(0, [10, 20]), (1, [20, 10]), (2, [10, 20]), (4, [20, 10])]
+        );
+    }
+
+    fn encoded_strings(values: &[&str]) -> (Vec<CheckedTableRange>, Vec<u8>) {
+        let mut ranges = Vec::new();
+        let mut bytes = Vec::new();
+        for value in values {
+            ranges.push(CheckedTableRange::new(
+                bytes.len() as u64,
+                value.len() as u64,
+            ));
+            bytes.extend_from_slice(value.as_bytes());
+        }
+        (ranges, bytes)
+    }
+
+    fn indexed_u32_sequences(sequences: &[&[u32]]) -> (Vec<IndexedRangeRow>, Vec<u32>) {
+        let mut ranges = Vec::new();
+        let mut values = Vec::new();
+        for (id, sequence) in sequences.iter().enumerate() {
+            ranges.push(IndexedRangeRow {
+                id: id as u32,
+                range: CheckedTableRange::new(values.len() as u64, sequence.len() as u64),
+            });
+            values.extend_from_slice(sequence);
+        }
+        (ranges, values)
+    }
+
+    fn append_u32_sequence(template: &mut OwnedRecurrenceTemplateInput, sequence: &[u32]) -> u32 {
+        let id = template.u32_sequence_ranges.len() as u32;
+        template.u32_sequence_ranges.push(IndexedRangeRow {
+            id,
+            range: CheckedTableRange::new(
+                template.u32_sequence_values.len() as u64,
+                sequence.len() as u64,
+            ),
+        });
+        template.u32_sequence_values.extend_from_slice(sequence);
+        id
+    }
+
+    fn append_template_string(template: &mut OwnedRecurrenceTemplateInput, value: &str) -> u32 {
+        let id = template.string_ranges.len() as u32;
+        template.string_ranges.push(CheckedTableRange::new(
+            template.string_bytes.len() as u64,
+            value.len() as u64,
+        ));
+        template.string_bytes.extend_from_slice(value.as_bytes());
+        id
+    }
+
+    fn scalar_reference_template() -> OwnedRecurrenceTemplateInput {
+        const EMPTY: u32 = 0;
+        const STATE_PAIR: u32 = 1;
+        const CANONICAL_ORDER: u32 = 2;
+        const PARENT_FLAVOURS: u32 = 3;
+        const PARENT_QUANTUM_NUMBERS: u32 = 4;
+
+        let (string_ranges, string_bytes) = encoded_strings(&["0", "1", "constant-result"]);
+        let (u32_sequence_ranges, u32_sequence_values) =
+            indexed_u32_sequences(&[&[], &[0, 0], &[0, 1], &[0, 0], &[0, 0]]);
+        OwnedRecurrenceTemplateInput {
+            input_abi: "scalar-reference-template-v1".to_owned(),
+            catalog_digest: digest(1),
+            compiled_model_digest: digest(2),
+            prepared_kernel_pack_digest: digest(3),
+            catalog_header: vec![],
+            coupling_order_ranges: vec![IndexedRangeRow {
+                id: 0,
+                range: CheckedTableRange::new(0, 0),
+            }],
+            coupling_order_terms: vec![],
+            contact_orbit_certificates: vec![],
+            contact_orbit_steps: vec![],
+            current_states: vec![],
+            digest_catalog: vec![DigestCatalogRow {
+                id: 0,
+                value: [4; 32],
+            }],
+            evaluator_bindings: vec![],
+            exact_factors: vec![ExactFactorRow {
+                id: 0,
+                real_numerator_string_id: 1,
+                real_denominator_string_id: 1,
+                imag_numerator_string_id: 0,
+                imag_denominator_string_id: 1,
+            }],
+            flavour_flow_ranges: vec![IndexedRangeRow {
+                id: 0,
+                range: CheckedTableRange::new(0, 1),
+            }],
+            flavour_flow_values: vec![0],
+            i32_sequence_ranges: vec![IndexedRangeRow {
+                id: 0,
+                range: CheckedTableRange::new(0, 2),
+            }],
+            i32_sequence_values: vec![0, 0],
+            parameters: vec![],
+            propagators: vec![],
+            quantum_flows: vec![QuantumFlowRow {
+                id: 0,
+                template_string_id: 0,
+                input_state_sequence_id: STATE_PAIR,
+                input_spin_sequence_id: 0,
+                input_flavour_sequence_id: PARENT_FLAVOURS,
+                input_quantum_sequence_id: PARENT_QUANTUM_NUMBERS,
+                flavour_flow_operation_string_id: 2,
+                quantum_number_flow_operation_string_id: 2,
+                coupling_order_set_id: 0,
+                result_state_template_id: 0,
+                result_spin_state: 0,
+                result_flavour_flow_id: 0,
+                result_quantum_number_flow_id: 0,
+                exact_coupling_factor_id: 0,
+                predicate_digest_id: 0,
+                semantic_digest_id: 0,
+            }],
+            quantum_number_flow_ranges: vec![],
+            quantum_number_flow_terms: vec![],
+            runtime_helicity_contracts: vec![],
+            runtime_helicity_variants: vec![],
+            runtime_helicity_embeddings: vec![],
+            runtime_helicity_projections: vec![],
+            sources: vec![],
+            string_ranges,
+            string_bytes,
+            symmetry_proofs: vec![],
+            transitions: vec![TransitionRow {
+                input_state_sequence_id: STATE_PAIR,
+                canonical_input_order_sequence_id: CANONICAL_ORDER,
+                input_exchange_factor_id: MISSING_U32,
+                ..transition(0)
+            }],
+            closures: vec![ClosureRow {
+                id: 0,
+                template_string_id: 0,
+                input_state_sequence_id: STATE_PAIR,
+                result_state_template_id: MISSING_U32,
+                evaluator_binding_id: 0,
+                canonical_input_order_sequence_id: CANONICAL_ORDER,
+                coupling_parameter_sequence_id: EMPTY,
+                coupling_order_set_id: 0,
+                eligible_quantum_flow_sequence_id: EMPTY,
+                color_contraction_template_id: 1,
+                binding_coupling_factor_id: 0,
+                exact_factor_id: 0,
+                output_factor_source: 0,
+                equivalence_class_string_id: 0,
+                input_exchange_factor_id: MISSING_U32,
+                projection_string_id: 0,
+                component_coefficient_sequence_id: EMPTY,
+                chirality_relation_string_id: 0,
+                metric_signature_string_id: 0,
+                semantic_digest_id: 0,
+            }],
+            color_contractions: vec![
+                ColorContractionRow {
+                    id: 0,
+                    template_string_id: 0,
+                    rule_kind_string_id: 0,
+                    input_representation_sequence_id: EMPTY,
+                    has_output_representation: 1,
+                    output_representation: 1,
+                    ordered_open_string_arity: 0,
+                    exact_coefficient_factor_id: 0,
+                    witness_start: 0,
+                    witness_count: 1,
+                    nc_term_start: 0,
+                    nc_term_count: 0,
+                    expression_digest_id: 0,
+                    semantic_digest_id: 0,
+                },
+                ColorContractionRow {
+                    id: 1,
+                    template_string_id: 0,
+                    rule_kind_string_id: 0,
+                    input_representation_sequence_id: EMPTY,
+                    has_output_representation: 0,
+                    output_representation: 0,
+                    ordered_open_string_arity: 0,
+                    exact_coefficient_factor_id: 0,
+                    witness_start: 1,
+                    witness_count: 1,
+                    nc_term_start: 0,
+                    nc_term_count: 0,
+                    expression_digest_id: 0,
+                    semantic_digest_id: 0,
+                },
+            ],
+            lc_color_transition_witnesses: vec![
+                LCColorTransitionWitnessRow {
+                    color_contraction_id: 0,
+                    ordinal: 0,
+                    left_shape_string_id: 0,
+                    right_shape_string_id: 0,
+                    input_permutation: 0,
+                    reverse_parent_mask: 0,
+                    component_operation: LCColorComponentOperation::Empty as u8,
+                    result_component_kind: u8::MAX,
+                    result_component_role: LCColorComponentRole::None as u8,
+                    result_shape_string_id: 0,
+                    exact_factor_id: 0,
+                    proof_digest_id: 0,
+                    input_port_pairing_sequence_id: EMPTY,
+                    result_port_binding_sequence_id: EMPTY,
+                    provenance_sequence_id: EMPTY,
+                },
+                LCColorTransitionWitnessRow {
+                    color_contraction_id: 1,
+                    ordinal: 0,
+                    left_shape_string_id: 0,
+                    right_shape_string_id: 0,
+                    input_permutation: 0,
+                    reverse_parent_mask: 0,
+                    component_operation: LCColorComponentOperation::Close as u8,
+                    result_component_kind: u8::MAX,
+                    result_component_role: LCColorComponentRole::None as u8,
+                    result_shape_string_id: MISSING_U32,
+                    exact_factor_id: 0,
+                    proof_digest_id: 0,
+                    input_port_pairing_sequence_id: EMPTY,
+                    result_port_binding_sequence_id: EMPTY,
+                    provenance_sequence_id: EMPTY,
+                },
+            ],
+            color_nc_terms: vec![],
+            u32_sequence_ranges,
+            u32_sequence_values,
+        }
+    }
+
+    #[test]
+    fn established_prepared_transition_binds_only_certified_contact_metadata() {
+        use crate::recurrence::contact_orbit_owner::{
+            ContactOrbitTestBinding, contact_orbit_test_template,
+        };
+
+        let none = contact_orbit_test_template(ContactOrbitTestBinding::None)
+            .validate()
+            .unwrap();
+        let none_catalog = TemplateCatalog::new(none.input()).unwrap();
+        let none_prepared = PreparedTransitionCatalog::new(none.input(), &none_catalog).unwrap();
+        assert!(none_prepared.rows(0, 0)[0].contact_orbit.is_none());
+        assert!(none_prepared.contact_orbit(0).is_none());
+
+        let one = contact_orbit_test_template(ContactOrbitTestBinding::One)
+            .validate()
+            .unwrap();
+        let one_catalog = TemplateCatalog::new(one.input()).unwrap();
+        let one_prepared = PreparedTransitionCatalog::new(one.input(), &one_catalog).unwrap();
+        assert!(one_prepared.rows(0, 0)[0].contact_orbit.is_some());
+        assert!(one_prepared.contact_orbit(0).is_some());
+        assert!(one_prepared.contact_orbit(u32::MAX).is_none());
+
+        let mut currents = vec![
+            projection_test_current(RecurrenceNodeKind::Source, 0, 0, &[0]),
+            projection_test_current(RecurrenceNodeKind::Source, 0, 1, &[1]),
+            projection_test_current(RecurrenceNodeKind::Current, 0, 2, &[0, 1]),
+        ];
+        add_projection_test_contribution(&mut currents, 2, 0, [0, 1], 0);
+        let plan = plan_established_contact_orbit_owners(2, &one_prepared, &currents, 1)
+            .unwrap()
+            .expect("certified transition must enter established owner planning");
+        let mut resident = 1;
+        plan.commit(&mut currents, &mut resident);
+        assert_eq!(resident, 1);
+        assert_eq!(established_contact_transition_ids(&currents[2]), [0]);
+    }
+
+    #[test]
+    fn prepared_transition_catalog_matches_lazy_reference_metadata_and_order() {
+        let mut template = scalar_reference_template();
+        let seed = template.transitions[0];
+        template.transitions = [2, 0, 1]
+            .map(|id| TransitionRow {
+                id,
+                input_exchange_factor_id: 0,
+                ..seed
+            })
+            .to_vec();
+        let catalog = TemplateCatalog::new(&template).unwrap();
+        let lazy_index = TransitionStateIndex::new(&template, &catalog).unwrap();
+        let prepared_catalog = PreparedTransitionCatalog::new(&template, &catalog).unwrap();
+
+        assert_eq!(
+            prepared_catalog.decoded_transition_count(),
+            template.transitions.len()
+        );
+        assert_eq!(prepared_catalog.decoded_witness_count(), 3);
+        assert_eq!(
+            prepared_catalog.structural_transitions(),
+            structural_transitions(&template, &catalog)
+                .unwrap()
+                .as_slice()
+        );
+
+        let lazy_rows = lazy_index.rows(0, 0);
+        let prepared_rows = prepared_catalog.rows(0, 0);
+        assert_eq!(
+            prepared_rows
+                .iter()
+                .map(|prepared| prepared.row.id)
+                .collect::<Vec<_>>(),
+            [2, 0, 1]
+        );
+        assert!(
+            [2, 0, 1]
+                .into_iter()
+                .all(|transition_id| prepared_catalog.contact_orbit(transition_id).is_none())
+        );
+        let mut uncertified_currents = vec![
+            projection_test_current(RecurrenceNodeKind::Source, 0, 0, &[0]),
+            projection_test_current(RecurrenceNodeKind::Source, 0, 1, &[1]),
+            projection_test_current(RecurrenceNodeKind::Current, 0, 2, &[0, 1]),
+        ];
+        add_projection_test_contribution(&mut uncertified_currents, 2, 0, [0, 1], 0);
+        assert!(
+            plan_established_contact_orbit_owners(2, &prepared_catalog, &uncertified_currents, 1,)
+                .unwrap()
+                .is_none()
+        );
+        assert_eq!(prepared_rows.len(), lazy_rows.len());
+
+        let mut color_states = DynamicLCColorStateInterner::default();
+        let color_id = color_states
+            .intern(DynamicLCColorState::new(0, None, vec![]).unwrap())
+            .unwrap();
+        let parent = |source_slot, state_template_id, spin_state| {
+            CurrentCoreKey::new(
+                template.catalog_digest,
+                RecurrenceNodeKind::Source,
+                state_template_id,
+                color_id,
+                vec![source_slot],
+                CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                    source_slot,
+                    coefficient: 1,
+                }])
+                .unwrap(),
+                CurrentHelicityIdentity::all_flow_union(spin_state),
+                vec![0],
+                0,
+                vec![],
+                CurrentSourceBinding::runtime_dispatch(source_slot, vec![source_slot]).unwrap(),
+                None,
+            )
+            .unwrap()
+        };
+        let left = parent(0, 0, 0);
+        let right = parent(1, 0, 0);
+        let parents = [&left, &right];
+
+        for (lazy, prepared) in lazy_rows.iter().zip(prepared_rows) {
+            assert_eq!(prepared.row, lazy.row);
+            assert_eq!(prepared.input_states, lazy.input_states);
+            assert_eq!(
+                prepared.parent_ids(0, 0, 20, 10).unwrap(),
+                lazy.parent_ids(0, 0, 20, 10).unwrap()
+            );
+            let quantum = template.quantum_flows[prepared.row.quantum_flow_template_id as usize];
+            assert_eq!(prepared.quantum, quantum);
+            assert_eq!(
+                prepared.quantum_input_states.as_slice(),
+                catalog
+                    .u32_sequence(quantum.input_state_sequence_id, "quantum input states")
+                    .unwrap()
+            );
+            assert_eq!(
+                prepared.quantum_input_spins.as_slice(),
+                catalog
+                    .i32_sequence(quantum.input_spin_sequence_id, "quantum input spins")
+                    .unwrap()
+            );
+            assert_eq!(
+                prepared.quantum_flow_matches(&parents),
+                quantum_flow_matches(quantum, &parents, &catalog).unwrap()
+            );
+            assert_eq!(
+                prepared.result_flavour_flow(&parents),
+                quantum_flow_result_flavour(quantum, &parents, &catalog).unwrap()
+            );
+            assert_eq!(
+                prepared.local_coupling_orders.as_ref(),
+                catalog
+                    .coupling_orders(prepared.row.coupling_order_set_id)
+                    .unwrap()
+            );
+            assert_eq!(
+                prepared.contraction,
+                template.color_contractions[prepared.row.color_contraction_template_id as usize]
+            );
+            assert_eq!(
+                prepared.canonical_evaluator_parents([20, 10]),
+                canonical_evaluator_parents(
+                    [20, 10],
+                    catalog
+                        .u32_sequence(
+                            prepared.row.canonical_input_order_sequence_id,
+                            "transition canonical input order",
+                        )
+                        .unwrap(),
+                    prepared.row.input_exchange_factor_id,
+                    &catalog,
+                    "transition",
+                )
+                .unwrap()
+            );
+            let (_, prepared_exchange_factor) = prepared.canonical_evaluator_parents([20, 10]);
+            let (_, lazy_exchange_factor) = canonical_evaluator_parents(
+                [20, 10],
+                catalog
+                    .u32_sequence(
+                        prepared.row.canonical_input_order_sequence_id,
+                        "transition canonical input order",
+                    )
+                    .unwrap(),
+                prepared.row.input_exchange_factor_id,
+                &catalog,
+                "transition",
+            )
+            .unwrap();
+            assert_eq!(
+                prepared.transition_exact_factor,
+                catalog
+                    .factor(prepared.row.exact_factor_id, "transition exact")
+                    .unwrap()
+            );
+            assert_eq!(
+                prepared.contraction_exact_factor,
+                catalog
+                    .factor(
+                        prepared.contraction.exact_coefficient_factor_id,
+                        "color contraction",
+                    )
+                    .unwrap()
+            );
+            let binding_coupling = authenticate_runtime_coupling(
+                &catalog,
+                quantum,
+                prepared.row.binding_coupling_factor_id,
+                "transition",
+            )
+            .unwrap();
+            assert_eq!(
+                prepared.output_factor().unwrap(),
+                output_factor_from_binding(
+                    binding_coupling,
+                    prepared.row.output_factor_source,
+                    "transition",
+                )
+                .unwrap()
+            );
+            assert_eq!(
+                multiply_factors(&[
+                    prepared.transition_exact_factor,
+                    prepared_exchange_factor,
+                    prepared.contraction_exact_factor,
+                    prepared.output_factor().unwrap(),
+                ])
+                .unwrap(),
+                multiply_factors(&[
+                    catalog
+                        .factor(prepared.row.exact_factor_id, "transition exact")
+                        .unwrap(),
+                    lazy_exchange_factor,
+                    catalog
+                        .factor(
+                            prepared.contraction.exact_coefficient_factor_id,
+                            "color contraction",
+                        )
+                        .unwrap(),
+                    output_factor_from_binding(
+                        binding_coupling,
+                        prepared.row.output_factor_source,
+                        "transition",
+                    )
+                    .unwrap(),
+                ])
+                .unwrap()
+            );
+            assert_eq!(
+                prepared.quantum_semantic_digest,
+                catalog
+                    .digest(quantum.semantic_digest_id, "quantum-flow semantic")
+                    .unwrap()
+            );
+            let lazy_witnesses = catalog
+                .witness_rows(prepared.row.color_contraction_template_id)
+                .unwrap()
+                .iter()
+                .copied()
+                .map(|row| PreparedTransitionWitness {
+                    row,
+                    witness: catalog.witness(row).unwrap(),
+                })
+                .collect::<Vec<_>>();
+            assert_eq!(prepared.witnesses.as_ref(), lazy_witnesses.as_slice());
+        }
+    }
+
+    #[test]
+    fn prepared_closure_catalog_matches_lazy_reference_order_orientation_factors_and_witnesses() {
+        let mut template = scalar_reference_template();
+        let state_01 = append_u32_sequence(&mut template, &[0, 1]);
+        let state_10 = append_u32_sequence(&mut template, &[1, 0]);
+        let reverse_order = append_u32_sequence(&mut template, &[1, 0]);
+        let minus_one_string = append_template_string(&mut template, "-1");
+        template.exact_factors.push(ExactFactorRow {
+            id: 1,
+            real_numerator_string_id: minus_one_string,
+            real_denominator_string_id: 1,
+            imag_numerator_string_id: 0,
+            imag_denominator_string_id: 1,
+        });
+        template.lc_color_transition_witnesses[1].input_permutation = 1;
+        template.lc_color_transition_witnesses[1].exact_factor_id = 1;
+        let seed = template.closures[0];
+        template.closures = vec![
+            ClosureRow {
+                id: 7,
+                input_state_sequence_id: state_01,
+                canonical_input_order_sequence_id: reverse_order,
+                input_exchange_factor_id: 1,
+                exact_factor_id: 1,
+                ..seed
+            },
+            ClosureRow {
+                id: 3,
+                input_state_sequence_id: state_10,
+                canonical_input_order_sequence_id: reverse_order,
+                input_exchange_factor_id: 1,
+                exact_factor_id: 1,
+                ..seed
+            },
+            ClosureRow {
+                id: 9,
+                input_state_sequence_id: state_01,
+                canonical_input_order_sequence_id: reverse_order,
+                input_exchange_factor_id: 1,
+                exact_factor_id: 1,
+                ..seed
+            },
+        ];
+        let catalog = TemplateCatalog::new(&template).unwrap();
+        let prepared = PreparedClosureCatalog::new(&template, &catalog).unwrap();
+
+        for (anchor_state, complement_state, anchor_id, complement_id) in [
+            (0, 1, 10, 20),
+            (1, 0, 30, 40),
+            (0, 0, 50, 60),
+            (2, 3, 70, 80),
+        ] {
+            let actual = prepared
+                .rows(anchor_state, complement_state)
+                .iter()
+                .map(|closure| {
+                    Ok((
+                        closure.row.id,
+                        closure.parent_ids(
+                            anchor_state,
+                            complement_state,
+                            anchor_id,
+                            complement_id,
+                        )?,
+                    ))
+                })
+                .collect::<RusticolResult<Vec<_>>>()
+                .unwrap();
+            let reference = template
+                .closures
+                .iter()
+                .flat_map(|closure| {
+                    let input_states = catalog
+                        .u32_sequence(closure.input_state_sequence_id, "closure input states")
+                        .unwrap();
+                    let mut applications = Vec::new();
+                    if input_states == [complement_state, anchor_state] {
+                        applications.push((closure.id, [complement_id, anchor_id]));
+                    }
+                    if input_states == [anchor_state, complement_state]
+                        && anchor_state != complement_state
+                    {
+                        applications.push((closure.id, [anchor_id, complement_id]));
+                    }
+                    applications
+                })
+                .collect::<Vec<_>>();
+            assert_eq!(actual, reference);
+        }
+        assert_eq!(
+            prepared
+                .rows(0, 1)
+                .iter()
+                .map(|closure| closure.row.id)
+                .collect::<Vec<_>>(),
+            [7, 3, 9],
+        );
+
+        let closure = &prepared.rows(0, 1)[0];
+        let parent_ids = closure.parent_ids(0, 1, 10, 20).unwrap();
+        assert_eq!(parent_ids, [10, 20]);
+        let (prepared_evaluator_parents, prepared_exchange_factor) =
+            closure.canonical_evaluator_parents(parent_ids);
+        let (lazy_evaluator_parents, lazy_exchange_factor) = canonical_evaluator_parents(
+            parent_ids,
+            catalog
+                .u32_sequence(
+                    closure.row.canonical_input_order_sequence_id,
+                    "closure canonical input order",
+                )
+                .unwrap(),
+            closure.row.input_exchange_factor_id,
+            &catalog,
+            "closure",
+        )
+        .unwrap();
+        assert_eq!(prepared_evaluator_parents, lazy_evaluator_parents);
+        assert_eq!(prepared_exchange_factor, lazy_exchange_factor);
+        assert_eq!(
+            prepared_exchange_factor,
+            ExactComplexRational::ONE.checked_neg().unwrap(),
+        );
+        assert_eq!(
+            closure.witnesses[0].row,
+            template.lc_color_transition_witnesses[1],
+        );
+        assert_eq!(
+            closure.witnesses[0].witness,
+            catalog
+                .witness(template.lc_color_transition_witnesses[1])
+                .unwrap(),
+        );
+        let prepared_factor = multiply_factors(&[
+            closure.closure_exact_factor,
+            prepared_exchange_factor,
+            closure.contraction_exact_factor,
+            closure.quantum_flows[0].output_factor().unwrap(),
+            closure.witnesses[0].witness.exact_factor(),
+        ])
+        .unwrap();
+        let binding_coupling = catalog
+            .factor(
+                closure.row.binding_coupling_factor_id,
+                "closure binding coupling",
+            )
+            .unwrap();
+        let lazy_factor = multiply_factors(&[
+            catalog
+                .factor(closure.row.exact_factor_id, "closure exact")
+                .unwrap(),
+            lazy_exchange_factor,
+            catalog
+                .factor(
+                    template.color_contractions[closure.row.color_contraction_template_id as usize]
+                        .exact_coefficient_factor_id,
+                    "closure color",
+                )
+                .unwrap(),
+            output_factor_from_binding(
+                binding_coupling,
+                closure.row.output_factor_source,
+                "closure",
+            )
+            .unwrap(),
+            catalog
+                .witness(template.lc_color_transition_witnesses[1])
+                .unwrap()
+                .exact_factor(),
+        ])
+        .unwrap();
+        assert_eq!(prepared_factor, lazy_factor);
+        assert_eq!(
+            prepared_factor,
+            ExactComplexRational::ONE.checked_neg().unwrap(),
+        );
+    }
+
+    #[test]
+    fn failure_only_closure_color_diagnostics_match_the_lazy_reference() {
+        let template = scalar_reference_template();
+        let catalog = TemplateCatalog::new(&template).unwrap();
+        let prepared = PreparedClosureCatalog::new(&template, &catalog).unwrap();
+        let currents = scalar_structural_sources(&template, 2);
+        let mut color_states = DynamicLCColorStateInterner::default();
+        assert_eq!(
+            color_states
+                .intern(DynamicLCColorState::new(0, None, vec![]).unwrap())
+                .unwrap()
+                .get(),
+            0,
+        );
+
+        let actual =
+            collect_closure_color_attempts(&prepared, &color_states, &currents, &[0], &[1])
+                .unwrap();
+        let parents = [&currents[1].key, &currents[0].key];
+        let left = color_states
+            .get(parents[0].dynamic_lc_color_state_id())
+            .unwrap();
+        let right = color_states
+            .get(parents[1].dynamic_lc_color_state_id())
+            .unwrap();
+        let reference = catalog
+            .witness_rows(template.closures[0].color_contraction_template_id)
+            .unwrap()
+            .iter()
+            .filter(|row| {
+                row.left_shape_string_id == left.output_color_shape_id()
+                    && row.right_shape_string_id == right.output_color_shape_id()
+            })
+            .map(|row| {
+                catalog
+                    .witness(*row)
+                    .unwrap()
+                    .closed_components(left, right)
+                    .unwrap()
+                    .iter()
+                    .map(|component| (component.kind(), component.source_slots().to_vec()))
+                    .collect::<Vec<_>>()
+            })
+            .collect::<BTreeSet<_>>();
+        assert_eq!(actual, reference);
+        assert_eq!(actual, BTreeSet::from([Vec::new()]));
+    }
+
+    #[test]
+    fn prepared_flavour_flow_preserves_parent_orientation_and_union_collapse() {
+        let mut color_states = DynamicLCColorStateInterner::default();
+        let color_id = color_states
+            .intern(DynamicLCColorState::new(0, None, vec![]).unwrap())
+            .unwrap();
+        let parent = |source_slot, flavour_flow, helicity_identity| {
+            CurrentCoreKey::new(
+                digest(211),
+                RecurrenceNodeKind::Current,
+                0,
+                color_id,
+                vec![source_slot],
+                CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                    source_slot,
+                    coefficient: 1,
+                }])
+                .unwrap(),
+                helicity_identity,
+                flavour_flow,
+                0,
+                vec![],
+                CurrentSourceBinding::None,
+                None,
+            )
+            .unwrap()
+        };
+        let left = parent(
+            0,
+            vec![10, 20],
+            CurrentHelicityIdentity::topology_replay(0, vec![SourceStateAssignment::new(0, 0)])
+                .unwrap(),
+        );
+        let right = parent(
+            1,
+            vec![30, 40],
+            CurrentHelicityIdentity::topology_replay(0, vec![SourceStateAssignment::new(1, 0)])
+                .unwrap(),
+        );
+        let parents = [&left, &right];
+        let reversed = [&right, &left];
+
+        for (prepared, expected, reversed_expected) in [
+            (
+                PreparedFlavourFlow::Constant(vec![7, 9].into_boxed_slice()),
+                vec![7, 9],
+                vec![7, 9],
+            ),
+            (
+                PreparedFlavourFlow::AppendLeft(9),
+                vec![10, 20, 9],
+                vec![30, 40, 9],
+            ),
+            (
+                PreparedFlavourFlow::AppendRight(9),
+                vec![30, 40, 9],
+                vec![10, 20, 9],
+            ),
+            (
+                PreparedFlavourFlow::ConcatLeftRight(9),
+                vec![10, 20, 30, 40, 9],
+                vec![30, 40, 10, 20, 9],
+            ),
+        ] {
+            assert_eq!(prepared.apply(&parents), expected);
+            assert_eq!(prepared.apply(&reversed), reversed_expected);
+
+            let union_left = parent(0, vec![10, 20], CurrentHelicityIdentity::all_flow_union(0));
+            let union_right = parent(1, vec![30, 40], CurrentHelicityIdentity::all_flow_union(0));
+            assert_eq!(prepared.apply(&[&union_left, &union_right]), [9]);
+        }
+    }
+
+    #[test]
+    fn prepared_transition_catalog_preserves_lazy_binary_contract_errors() {
+        let mut non_binary_transition = scalar_reference_template();
+        non_binary_transition.u32_sequence_ranges[1].range = CheckedTableRange::new(0, 1);
+        let catalog = TemplateCatalog::new(&non_binary_transition).unwrap();
+        assert_eq!(
+            PreparedTransitionCatalog::new(&non_binary_transition, &catalog).unwrap_err(),
+            TransitionStateIndex::new(&non_binary_transition, &catalog).unwrap_err()
+        );
+
+        let mut non_binary_quantum = scalar_reference_template();
+        non_binary_quantum.i32_sequence_ranges[0].range = CheckedTableRange::new(0, 1);
+        let catalog = TemplateCatalog::new(&non_binary_quantum).unwrap();
+        assert_eq!(
+            PreparedTransitionCatalog::new(&non_binary_quantum, &catalog).unwrap_err(),
+            structural_transitions(&non_binary_quantum, &catalog).unwrap_err()
+        );
+    }
+
+    #[test]
+    fn prepared_transition_catalog_preserves_lazy_metadata_errors() {
+        let mut invalid_order = scalar_reference_template();
+        invalid_order.u32_sequence_values[2..4].copy_from_slice(&[0, 0]);
+        let catalog = TemplateCatalog::new(&invalid_order).unwrap();
+        let row = invalid_order.transitions[0];
+        let lazy_error = canonical_evaluator_parents(
+            [20, 10],
+            catalog
+                .u32_sequence(
+                    row.canonical_input_order_sequence_id,
+                    "transition canonical input order",
+                )
+                .unwrap(),
+            row.input_exchange_factor_id,
+            &catalog,
+            "transition",
+        )
+        .unwrap_err();
+        assert_eq!(
+            PreparedTransitionCatalog::new(&invalid_order, &catalog).unwrap_err(),
+            lazy_error
+        );
+
+        let mut invalid_witness = scalar_reference_template();
+        invalid_witness.lc_color_transition_witnesses[0].input_permutation = 2;
+        let catalog = TemplateCatalog::new(&invalid_witness).unwrap();
+        let lazy_error = catalog
+            .witness(invalid_witness.lc_color_transition_witnesses[0])
+            .unwrap_err();
+        assert_eq!(
+            PreparedTransitionCatalog::new(&invalid_witness, &catalog).unwrap_err(),
+            lazy_error
+        );
+    }
+
+    fn scalar_reference_process(external_count: usize) -> OwnedRecurrenceProcessInput {
+        OwnedRecurrenceProcessInput {
+            input_abi: "scalar-reference-process-v1".to_owned(),
+            declared_input_digest: digest(5),
+            fermion_pairing: None,
+            bitset_ranges: vec![],
+            bitset_words: vec![],
+            coupling_limits: vec![],
+            digest_catalog: vec![],
+            exact_factors: vec![],
+            external_legs: (0..external_count)
+                .map(|slot| ProcessExternalLegRow {
+                    source_slot: slot as u32,
+                    public_label: slot as u32 + 1,
+                    physical_pdg: 0,
+                    outgoing_pdg: 0,
+                    is_initial: 0,
+                    is_fermionic: 0,
+                    source_state_range: CheckedTableRange::new(0, 0),
+                    momentum_mask_id: 0,
+                    support_mask_id: 0,
+                })
+                .collect(),
+            header: vec![],
+            header_digests: vec![],
+            lc_open_strings: vec![],
+            normalization: vec![],
+            parameter_projection: vec![],
+            physical_lc_sectors: vec![ProcessPhysicalLCSectorRow {
+                sector_id: 0,
+                public_id_string_id: 0,
+                kind: ProcessLCSectorKind::Singlet as u8,
+                closure_source_slot: 0,
+                closure_proof_algorithm_string_id: 0,
+                closure_proof_digest_id: 0,
+                open_string_range: CheckedTableRange::new(0, 0),
+                trace_sequence_id: 0,
+                singlet_sequence_id: 0,
+                word_sequence_id: 0,
+                support_mask_id: 0,
+            }],
+            public_lc_flows: vec![],
+            replay_partitions: vec![],
+            replay_targets: vec![],
+            selected_public_flow_coverage: vec![],
+            selected_source_coverage: vec![],
+            semantic_template_references: vec![],
+            source_states: vec![],
+            string_ranges: vec![],
+            string_bytes: vec![],
+            u32_sequence_ranges: vec![CheckedTableRange::new(0, 0)],
+            u32_sequence_values: vec![],
+        }
+    }
+
+    fn cyclic_trace_anchor_contract_fixture()
+    -> (OwnedRecurrenceProcessInput, OwnedRecurrenceTemplateInput) {
+        let mut template = scalar_reference_template();
+        let color_shape_string_id = append_template_string(&mut template, "adjoint-segment");
+        let direct_closure_string_id = append_template_string(&mut template, "direct-contraction");
+        template.current_states = vec![crate::recurrence::template::CurrentStateRow {
+            id: 0,
+            template_string_id: 0,
+            particle_id: 21,
+            anti_particle_id: 21,
+            species_string_id: 0,
+            orientation: CurrentOrientation::SelfConjugate as u8,
+            statistics: ParticleStatistics::Boson as u8,
+            color_representation: 8,
+            basis_string_id: 0,
+            tensor_ordering_sequence_id: 0,
+            dimension: 4,
+            chirality: 0,
+            lc_color_shape_string_id: color_shape_string_id,
+            auxiliary_kind_string_id: MISSING_U32,
+            mass_parameter_id: MISSING_U32,
+            width_parameter_id: MISSING_U32,
+            semantic_digest_id: 0,
+        }];
+        template.evaluator_bindings = vec![crate::recurrence::template::EvaluatorBindingRow {
+            id: 0,
+            resolver_key_string_id: 0,
+            prepared_kernel_id: MISSING_U32,
+            contract_kind: EvaluatorContractKind::Closure as u8,
+            callable_signature_digest_id: 0,
+            input_state_sequence_id: 1,
+            output_state_template_id: MISSING_U32,
+            input_layout_sequence_id: 0,
+            output_layout_sequence_id: 0,
+            exact_expression_digest_sequence_id: 0,
+            semantic_template_sequence_id: 0,
+            callable_kind: EvaluatorCallableKind::RusticolTemplate as u8,
+            runtime_template_string_id: 0,
+            semantic_digest_id: 0,
+        }];
+        template.closures[0].equivalence_class_string_id = direct_closure_string_id;
+        template.i32_sequence_values = vec![8, 8];
+
+        let mut process = scalar_reference_process(4);
+        let (string_ranges, string_bytes) =
+            encoded_strings(&[CYCLIC_TRACE_CLOSURE_ANCHOR_ALGORITHM]);
+        process.string_ranges = string_ranges;
+        process.string_bytes = string_bytes;
+        process.u32_sequence_ranges =
+            vec![CheckedTableRange::new(0, 0), CheckedTableRange::new(0, 4)];
+        process.u32_sequence_values = vec![0, 1, 2, 3];
+        process.physical_lc_sectors[0] = ProcessPhysicalLCSectorRow {
+            kind: ProcessLCSectorKind::SingleTrace as u8,
+            closure_source_slot: 0,
+            closure_proof_algorithm_string_id: 0,
+            trace_sequence_id: 1,
+            singlet_sequence_id: 0,
+            word_sequence_id: 1,
+            ..process.physical_lc_sectors[0]
+        };
+        process.source_states = (0..4)
+            .map(|source_slot| ProcessSourceStateRow {
+                source_slot,
+                state_index: 0,
+                public_helicity: 1,
+                chirality: 0,
+                spin_state: 1,
+                current_state_template_id: 0,
+                source_template_id: source_slot,
+                momentum_sign: 1,
+                crossing_phase_factor_id: 0,
+            })
+            .collect();
+        for (source_slot, leg) in process.external_legs.iter_mut().enumerate() {
+            leg.physical_pdg = 21;
+            leg.outgoing_pdg = 21;
+            leg.source_state_range = CheckedTableRange::new(source_slot as u64, 1);
+        }
+        (process, template)
+    }
+
+    #[test]
+    fn cyclic_trace_anchor_constructor_authenticates_template_contracts() {
+        let (process, template) = cyclic_trace_anchor_contract_fixture();
+        let process_catalog = ProcessCatalog::new(&process).unwrap();
+        let template_catalog = TemplateCatalog::new(&template).unwrap();
+        validate_cyclic_trace_closure_anchor_contracts(
+            &process,
+            &process_catalog,
+            &template,
+            &template_catalog,
+        )
+        .expect("authenticated adjoint trace closure contract must pass");
+
+        let mut non_adjoint = template.clone();
+        non_adjoint.current_states[0].color_representation = 3;
+        let catalog = TemplateCatalog::new(&non_adjoint).unwrap();
+        assert!(
+            validate_cyclic_trace_closure_anchor_contracts(
+                &process,
+                &process_catalog,
+                &non_adjoint,
+                &catalog,
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("self-conjugate adjoint")
+        );
+
+        let mut missing_direct_closure = template.clone();
+        missing_direct_closure.closures[0].result_state_template_id = 0;
+        let catalog = TemplateCatalog::new(&missing_direct_closure).unwrap();
+        assert!(
+            validate_cyclic_trace_closure_anchor_contracts(
+                &process,
+                &process_catalog,
+                &missing_direct_closure,
+                &catalog,
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("exact direct binary adjoint closure")
+        );
+
+        let mut coupling_order_closure = template.clone();
+        let coupling_order_name = append_template_string(&mut coupling_order_closure, "QCD");
+        coupling_order_closure.coupling_order_ranges[0].range = CheckedTableRange::new(0, 1);
+        coupling_order_closure.coupling_order_terms =
+            vec![crate::recurrence::template::CouplingOrderTermRow {
+                set_id: 0,
+                name_string_id: coupling_order_name,
+                power: 1,
+            }];
+        let catalog = TemplateCatalog::new(&coupling_order_closure).unwrap();
+        assert!(
+            validate_cyclic_trace_closure_anchor_contracts(
+                &process,
+                &process_catalog,
+                &coupling_order_closure,
+                &catalog,
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("exact direct binary adjoint closure")
+        );
+
+        let mut established_process = process.clone();
+        let (string_ranges, string_bytes) = encoded_strings(&["canonical-lc-closure-anchor-v2"]);
+        established_process.string_ranges = string_ranges;
+        established_process.string_bytes = string_bytes;
+        let catalog = ProcessCatalog::new(&established_process).unwrap();
+        validate_cyclic_trace_closure_anchor_contracts(
+            &established_process,
+            &catalog,
+            &non_adjoint,
+            &TemplateCatalog::new(&non_adjoint).unwrap(),
+        )
+        .expect("non-v4 recurrence contracts must remain untouched");
+    }
+
+    fn scalar_structural_sources(
+        template: &OwnedRecurrenceTemplateInput,
+        external_count: usize,
+    ) -> Vec<PendingCurrent> {
+        let mut color_states = DynamicLCColorStateInterner::default();
+        let color_id = color_states
+            .intern(DynamicLCColorState::new(0, None, vec![]).unwrap())
+            .unwrap();
+        (0..external_count as u32)
+            .map(|source_slot| {
+                let key = CurrentCoreKey::new(
+                    template.catalog_digest,
+                    RecurrenceNodeKind::Source,
+                    0,
+                    color_id,
+                    vec![source_slot],
+                    CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                        source_slot,
+                        coefficient: 1,
+                    }])
+                    .unwrap(),
+                    CurrentHelicityIdentity::all_flow_union(0),
+                    vec![0],
+                    0,
+                    vec![],
+                    CurrentSourceBinding::runtime_dispatch(source_slot, vec![source_slot]).unwrap(),
+                    None,
+                )
+                .unwrap();
+                PendingCurrent {
+                    key,
+                    source_exact_factor: None,
+                    contributions: BTreeMap::new(),
+                    realized_pairing_rule_ids: BTreeSet::new(),
+                    reflection: CurrentReflection::Unavailable,
+                    reflection_certificate_id: None,
+                }
+            })
+            .collect()
+    }
+
+    #[test]
+    fn lane_closure_support_index_matches_reference_filter_and_preserves_current_id_order() {
+        let template = scalar_reference_template();
+        let mut currents = scalar_structural_sources(&template, 4);
+        let color_id = currents[0].key.dynamic_lc_color_state_id();
+        let internal = |support: Vec<u32>| {
+            let momentum = CanonicalMomentumLinearForm::new(
+                support
+                    .iter()
+                    .copied()
+                    .map(|source_slot| MomentumTerm {
+                        source_slot,
+                        coefficient: 1,
+                    })
+                    .collect(),
+            )
+            .unwrap();
+            PendingCurrent {
+                key: CurrentCoreKey::new(
+                    template.catalog_digest,
+                    RecurrenceNodeKind::Current,
+                    0,
+                    color_id,
+                    support,
+                    momentum,
+                    CurrentHelicityIdentity::all_flow_union(0),
+                    vec![0],
+                    0,
+                    vec![],
+                    CurrentSourceBinding::None,
+                    None,
+                )
+                .unwrap(),
+                source_exact_factor: None,
+                contributions: BTreeMap::new(),
+                realized_pairing_rule_ids: BTreeSet::new(),
+                reflection: CurrentReflection::Unavailable,
+                reflection_certificate_id: None,
+            }
+        };
+        currents.push(internal(vec![1, 2, 3]));
+        currents.push(internal(vec![1, 2, 3]));
+        currents.push(internal(vec![0, 2]));
+
+        let global = LaneClosureSupportIndex::new(&currents, None).unwrap();
+        assert_eq!(global.current_ids(&[0]), [0]);
+        assert_eq!(global.current_ids(&[1, 2, 3]), [4, 5]);
+        assert_eq!(global.current_ids(&[0, 2]), [6]);
+
+        let domain = PendingConstructionDomain {
+            shared_source_end: 4,
+            lane_internal_start: 5,
+            lane_internal_end: 7,
+        };
+        let lane = LaneClosureSupportIndex::new(&currents, Some(domain)).unwrap();
+        for support in [&[0][..], &[1, 2, 3][..], &[0, 2][..], &[0, 3][..]] {
+            let reference = currents
+                .iter()
+                .enumerate()
+                .filter(|(current_id, current)| {
+                    domain.contains(*current_id) && current.key.support_source_slots() == support
+                })
+                .map(|(current_id, _)| current_id as u32)
+                .collect::<Vec<_>>();
+            assert_eq!(lane.current_ids(support), reference);
+        }
+    }
+
+    #[test]
+    fn shared_structural_feasibility_matches_lazy_multi_lane_demands() {
+        let template = scalar_reference_template();
+        let catalog = TemplateCatalog::new(&template).unwrap();
+        let prepared = PreparedTransitionCatalog::new(&template, &catalog).unwrap();
+        let mut process = scalar_reference_process(4);
+        let mut second_sector = process.physical_lc_sectors[0];
+        second_sector.sector_id = 1;
+        second_sector.closure_source_slot = 1;
+        process.physical_lc_sectors.push(second_sector);
+        let sources = scalar_structural_sources(&template, 4);
+        let feasibility = StructuralFeasibilityIndex::new(4, &prepared, &sources).unwrap();
+
+        assert!(feasibility.feasible_support_count() > sources.len());
+        assert!(feasibility.decomposition_count() > 0);
+        assert!(feasibility.forward_transition_probe_count() > 0);
+        for materialized_sectors in [
+            BTreeSet::from([0]),
+            BTreeSet::from([1]),
+            BTreeSet::from([0, 1]),
+        ] {
+            let lazy = LazyStructuralDemandIndex::new(
+                &process,
+                &template,
+                &catalog,
+                &prepared,
+                &materialized_sectors,
+                &sources,
+            )
+            .unwrap();
+            let indexed = StructuralDemandIndex::new(
+                &process,
+                &template,
+                &catalog,
+                &prepared,
+                &feasibility,
+                &materialized_sectors,
+            )
+            .unwrap();
+            assert_eq!(indexed.demanded_rows(), lazy.demanded);
+            for (support, state) in &lazy.demanded {
+                let support_key = TransientSupportKey::from_source_slots(4, support).unwrap();
+                assert_eq!(
+                    indexed.accepts(
+                        &support_key,
+                        state.state_template_id,
+                        state.spin_state_class,
+                    ),
+                    lazy.accepts(support, state.state_template_id, state.spin_state_class,)
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn contracted_color_without_replay_proof_keeps_the_direct_destination_domain() {
+        let mut process = scalar_reference_process(2);
+        process.header = vec![ProcessHeaderRow {
+            schema_version: 1,
+            abi_string_id: 0,
+            process_id_string_id: 0,
+            layout: u8::try_from(RecurrenceStrategy::ContractedColorUnion.as_u32())
+                .expect("strategy discriminant fits u8"),
+            selected_flow_mode: 0,
+            selected_source_mode: 0,
+            external_leg_count: 2,
+            physical_sector_count: 1,
+            public_flow_count: 1,
+            replay_partition_count: 0,
+            coupling_limit_count: 0,
+            parameter_projection_count: 0,
+            process_support_mask_id: 0,
+        }];
+        process.external_legs[0].source_state_range = CheckedTableRange::new(0, 1);
+        process.external_legs[1].source_state_range = CheckedTableRange::new(1, 1);
+        process.source_states = vec![
+            ProcessSourceStateRow {
+                source_slot: 0,
+                state_index: 0,
+                public_helicity: -1,
+                chirality: -1,
+                spin_state: -1,
+                current_state_template_id: 0,
+                source_template_id: 0,
+                momentum_sign: 1,
+                crossing_phase_factor_id: 0,
+            },
+            ProcessSourceStateRow {
+                source_slot: 1,
+                state_index: 0,
+                public_helicity: 1,
+                chirality: 1,
+                spin_state: 1,
+                current_state_template_id: 0,
+                source_template_id: 0,
+                momentum_sign: 1,
+                crossing_phase_factor_id: 0,
+            },
+        ];
+        process.public_lc_flows = vec![ProcessPublicLCFlowRow {
+            flow_id: 0,
+            public_id_string_id: 0,
+            construction_sector_id: 0,
+            word_sequence_id: 0,
+            source_slot_permutation_sequence_id: 0,
+            reduction_weight_factor_id: 0,
+        }];
+        process.u32_sequence_ranges = vec![CheckedTableRange::new(0, 2)];
+        process.u32_sequence_values = vec![0, 1];
+        let catalog = ProcessCatalog::new(&process).unwrap();
+
+        assert!(
+            build_replay_targets(RecurrenceStrategy::ContractedColorUnion, &process, &catalog,)
+                .unwrap()
+                .is_empty()
+        );
+    }
+
+    #[test]
+    fn contracted_closure_index_preserves_open_line_canonical_owner() {
+        let mut process = scalar_reference_process(4);
+        process.lc_open_strings = vec![
+            ProcessLCOpenStringRow {
+                sector_id: 0,
+                ordinal: 0,
+                fundamental_source_slot: 0,
+                antifundamental_source_slot: 1,
+                adjoint_sequence_id: 0,
+                singlet_sequence_id: 0,
+            },
+            ProcessLCOpenStringRow {
+                sector_id: 0,
+                ordinal: 1,
+                fundamental_source_slot: 2,
+                antifundamental_source_slot: 3,
+                adjoint_sequence_id: 0,
+                singlet_sequence_id: 0,
+            },
+            ProcessLCOpenStringRow {
+                sector_id: 1,
+                ordinal: 0,
+                fundamental_source_slot: 2,
+                antifundamental_source_slot: 3,
+                adjoint_sequence_id: 0,
+                singlet_sequence_id: 0,
+            },
+            ProcessLCOpenStringRow {
+                sector_id: 1,
+                ordinal: 1,
+                fundamental_source_slot: 0,
+                antifundamental_source_slot: 1,
+                adjoint_sequence_id: 0,
+                singlet_sequence_id: 0,
+            },
+        ];
+        let seed = process.physical_lc_sectors[0];
+        process.physical_lc_sectors = vec![
+            ProcessPhysicalLCSectorRow {
+                kind: ProcessLCSectorKind::OpenLines as u8,
+                closure_source_slot: 1,
+                open_string_range: CheckedTableRange::new(0, 2),
+                ..seed
+            },
+            ProcessPhysicalLCSectorRow {
+                sector_id: 1,
+                kind: ProcessLCSectorKind::OpenLines as u8,
+                closure_source_slot: 1,
+                open_string_range: CheckedTableRange::new(2, 2),
+                ..seed
+            },
+        ];
+        let catalog = ProcessCatalog::new(&process).unwrap();
+        let sector_ids = BTreeSet::from([0, 1]);
+        let contracted = PreparedClosureSectorCatalog::new(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            &catalog,
+            &sector_ids,
+        )
+        .unwrap();
+        let first = contracted.get(0).unwrap();
+        let alias = contracted.get(1).unwrap();
+        assert!(first.contracted_color_canonical_owner);
+        assert!(!alias.contracted_color_canonical_owner);
+        assert!(unordered_color_components_match(
+            &first.expected_components,
+            &alias.expected_components,
+        ));
+        assert!(
+            closed_components_match_prepared_sector(
+                RecurrenceStrategy::ContractedColorUnion,
+                &first.expected_components,
+                first,
+            )
+            .unwrap()
+        );
+        assert!(
+            !closed_components_match_prepared_sector(
+                RecurrenceStrategy::ContractedColorUnion,
+                &alias.expected_components,
+                alias,
+            )
+            .unwrap()
+        );
+        assert_eq!(first.anchor_support.as_ref(), [1]);
+        assert_eq!(first.complement_support.as_ref(), [0, 2, 3]);
+        let buckets = contracted_closure_support_buckets(
+            RecurrenceStrategy::ContractedColorUnion,
+            &contracted,
+            &sector_ids,
+        )
+        .unwrap();
+        let bucket = buckets.values().next().unwrap();
+        assert_eq!(buckets.len(), 1);
+        assert_eq!(bucket.sector_ids, [0, 1]);
+        assert_eq!(bucket.matching_sector_ids(&first.expected_components), [0]);
+        assert_eq!(bucket.matching_sector_ids(&alias.expected_components), [0]);
+
+        // Canonical ownership is established against the complete process
+        // catalog, not merely the materialized subset.  An alias-only replay
+        // therefore remains suppressed instead of becoming a local fallback.
+        let alias_only_ids = BTreeSet::from([1]);
+        let alias_only = PreparedClosureSectorCatalog::new(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            &catalog,
+            &alias_only_ids,
+        )
+        .unwrap();
+        let alias_bucket = contracted_closure_support_buckets(
+            RecurrenceStrategy::ContractedColorUnion,
+            &alias_only,
+            &alias_only_ids,
+        )
+        .unwrap()
+        .into_values()
+        .next()
+        .unwrap();
+        assert!(
+            alias_bucket
+                .matching_sector_ids(&alias.expected_components)
+                .is_empty()
+        );
+
+        let topology = PreparedClosureSectorCatalog::new(
+            RecurrenceStrategy::TopologyReplay,
+            &process,
+            &catalog,
+            &sector_ids,
+        )
+        .unwrap();
+        assert!(topology.get(0).unwrap().contracted_color_canonical_owner);
+        assert!(topology.get(1).unwrap().contracted_color_canonical_owner);
+
+        let all_flow = PreparedClosureSectorCatalog::new(
+            RecurrenceStrategy::AllFlowUnion,
+            &process,
+            &catalog,
+            &sector_ids,
+        )
+        .unwrap();
+        let all_flow_bucket = contracted_closure_support_buckets(
+            RecurrenceStrategy::AllFlowUnion,
+            &all_flow,
+            &sector_ids,
+        )
+        .unwrap()
+        .into_values()
+        .next()
+        .unwrap();
+        assert_eq!(
+            all_flow_bucket.matching_sector_ids(&first.expected_components),
+            [0, 1]
+        );
+    }
+
+    #[test]
+    fn precomputed_three_line_components_preserve_direct_and_partner_witness_order() {
+        let mut process = scalar_reference_process(6);
+        process.lc_open_strings = (0..3)
+            .map(|ordinal| ProcessLCOpenStringRow {
+                sector_id: 0,
+                ordinal,
+                fundamental_source_slot: ordinal * 2,
+                antifundamental_source_slot: ordinal * 2 + 1,
+                adjoint_sequence_id: 0,
+                singlet_sequence_id: 0,
+            })
+            .collect();
+        process.u32_sequence_ranges =
+            vec![CheckedTableRange::new(0, 0), CheckedTableRange::new(0, 6)];
+        process.u32_sequence_values = vec![0, 1, 2, 3, 4, 5];
+        process.physical_lc_sectors[0] = ProcessPhysicalLCSectorRow {
+            kind: ProcessLCSectorKind::OpenLines as u8,
+            closure_source_slot: 5,
+            open_string_range: CheckedTableRange::new(0, 3),
+            word_sequence_id: 1,
+            ..process.physical_lc_sectors[0]
+        };
+        let catalog = ProcessCatalog::new(&process).unwrap();
+        let prepared = PreparedClosureSectorCatalog::new(
+            RecurrenceStrategy::TopologyReplay,
+            &process,
+            &catalog,
+            &BTreeSet::from([0]),
+        )
+        .unwrap();
+        let sector = prepared.get(0).unwrap();
+        let direct = three_line_traversal_certificate(
+            &sector.expected_components,
+            sector.row,
+            &sector.expected_components,
+            &catalog,
+            Some(17),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(u32::from(direct.kind), THREE_LINE_DIRECT_CERTIFICATE_ID);
+        assert_eq!(direct.pairing_rule_id, 17);
+        assert_eq!(direct.reference_block_order.as_ref(), [0, 1, 2]);
+        assert_eq!(direct.witness_block_order.as_ref(), [0, 1, 2]);
+
+        let partner_components = vec![
+            sector.expected_components[1].clone(),
+            sector.expected_components[0].clone(),
+            sector.expected_components[2].clone(),
+        ];
+        let partner = three_line_traversal_certificate(
+            &partner_components,
+            sector.row,
+            &sector.expected_components,
+            &catalog,
+            Some(17),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(u32::from(partner.kind), THREE_LINE_PARTNER_CERTIFICATE_ID);
+        assert_eq!(partner.reference_block_order.as_ref(), [0, 1, 2]);
+        assert_eq!(partner.witness_block_order.as_ref(), [1, 0, 2]);
+        assert_ne!(direct.proof_digest, partner.proof_digest);
+    }
+
+    #[test]
+    fn multi_realized_closure_selects_semantic_pairing_owner_independent_of_rule_id() {
+        let later = [
+            FermionPairingEndpointPairRow {
+                fundamental_source_slot: 0,
+                antifundamental_source_slot: 7,
+            },
+            FermionPairingEndpointPairRow {
+                fundamental_source_slot: 2,
+                antifundamental_source_slot: 5,
+            },
+        ];
+        let canonical = [
+            FermionPairingEndpointPairRow {
+                fundamental_source_slot: 0,
+                antifundamental_source_slot: 3,
+            },
+            FermionPairingEndpointPairRow {
+                fundamental_source_slot: 2,
+                antifundamental_source_slot: 7,
+            },
+        ];
+
+        for candidates in [
+            vec![Ok((1, later.as_slice())), Ok((9, canonical.as_slice()))],
+            vec![Ok((9, canonical.as_slice())), Ok((1, later.as_slice()))],
+        ] {
+            assert_eq!(canonical_pairing_owner_id(candidates).unwrap(), Some(9));
+        }
+        assert_eq!(
+            canonical_pairing_owner_id([Ok((4, later.as_slice()))]).unwrap(),
+            Some(4)
+        );
+        assert_eq!(
+            canonical_pairing_owner_id(std::iter::empty()).unwrap(),
+            None
+        );
+    }
+
+    fn scalar_reference_program(
+        external_count: usize,
+    ) -> (
+        RecurrenceProgram,
+        Vec<StageConstructionDiagnostics>,
+        (usize, usize, usize),
+        RecurrenceGenerationTelemetry,
+    ) {
+        let template = scalar_reference_template();
+        let template_catalog = TemplateCatalog::new(&template).unwrap();
+        let prepared_transitions =
+            PreparedTransitionCatalog::new(&template, &template_catalog).unwrap();
+        let prepared_closures = PreparedClosureCatalog::new(&template, &template_catalog).unwrap();
+        let process = scalar_reference_process(external_count);
+        let process_catalog = ProcessCatalog::new(&process).unwrap();
+        let fermion_ordering =
+            established_fermion_ordering_context(&process, &template, None).unwrap();
+        let materialized_sectors = BTreeSet::from([0]);
+        let prepared_closure_sectors = PreparedClosureSectorCatalog::new(
+            RecurrenceStrategy::AllFlowUnion,
+            &process,
+            &process_catalog,
+            &materialized_sectors,
+        )
+        .unwrap();
+        let color_targets =
+            MaterializedColorTargets::new(&materialized_sectors, &process, &process_catalog)
+                .unwrap();
+        let mut color_states = DynamicLCColorStateInterner::default();
+        let color_id = color_states
+            .intern(DynamicLCColorState::new(0, None, vec![]).unwrap())
+            .unwrap();
+        let mut currents = Vec::new();
+        let mut current_ids = TransientCurrentIdIndex::new();
+        let mut currents_by_size = vec![Vec::new(); external_count];
+        for slot in 0..external_count as u32 {
+            let key = CurrentCoreKey::new(
+                template.catalog_digest,
+                RecurrenceNodeKind::Source,
+                0,
+                color_id,
+                vec![slot],
+                CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                    source_slot: slot,
+                    coefficient: 1,
+                }])
+                .unwrap(),
+                CurrentHelicityIdentity::all_flow_union(0),
+                vec![0],
+                0,
+                vec![],
+                CurrentSourceBinding::runtime_dispatch(slot, vec![slot]).unwrap(),
+                None,
+            )
+            .unwrap();
+            let id = currents.len() as u32;
+            assert!(current_ids.insert(key.clone(), id).is_none());
+            currents.push(PendingCurrent {
+                key,
+                source_exact_factor: None,
+                contributions: BTreeMap::new(),
+                realized_pairing_rule_ids: BTreeSet::new(),
+                reflection: CurrentReflection::Unavailable,
+                reflection_certificate_id: None,
+            });
+            currents_by_size[0].push(id);
+        }
+
+        let mut reflection_certificates = Vec::new();
+        let mut resident_contribution_count = 0;
+        let mut generation_telemetry = RecurrenceGenerationTelemetry::default();
+        let structural_feasibility =
+            StructuralFeasibilityIndex::new(external_count, &prepared_transitions, &currents)
+                .unwrap();
+        let mut current_support_keys =
+            TransientCurrentSupportKeys::from_currents(external_count, &currents).unwrap();
+        let structural_demands = StructuralDemandIndex::new(
+            &process,
+            &template,
+            &template_catalog,
+            &prepared_transitions,
+            &structural_feasibility,
+            &BTreeSet::from([0]),
+        )
+        .unwrap();
+        let stage_diagnostics = build_internal_currents(
+            template.catalog_digest,
+            &process,
+            None,
+            &template,
+            &fermion_ordering,
+            &prepared_transitions,
+            &TransitionReflectionIndex::new(&template, &template_catalog).unwrap(),
+            &[],
+            &BTreeMap::new(),
+            &color_targets,
+            &structural_demands,
+            &mut color_states,
+            &mut currents,
+            &mut current_ids,
+            &mut currents_by_size,
+            &mut current_support_keys,
+            &mut reflection_certificates,
+            &mut resident_contribution_count,
+            0,
+            external_count.saturating_sub(2),
+            external_count.saturating_add(1),
+            &mut generation_telemetry,
+            true,
+            &mut |_| Ok(()),
+        )
+        .unwrap();
+        let closures = build_closures(
+            RecurrenceStrategy::AllFlowUnion,
+            &process,
+            &process_catalog,
+            &template,
+            &fermion_ordering,
+            None,
+            &prepared_closures,
+            &prepared_closure_sectors,
+            &color_states,
+            &currents,
+            &materialized_sectors,
+            &stage_diagnostics,
+            &reflection_certificates,
+            None,
+            &mut generation_telemetry,
+            true,
+        )
+        .unwrap();
+        let constructed_counts = (
+            currents.len(),
+            currents
+                .iter()
+                .map(|current| current.contributions.len())
+                .sum(),
+            closures.len(),
+        );
+        assert_eq!(resident_contribution_count, constructed_counts.1);
+        let program = finish_program(
+            RecurrenceStrategy::AllFlowUnion,
+            &process_catalog,
+            color_states.into_states(),
+            currents,
+            closures.groups,
+            closures.physical_sector_ids,
+            closures.physical_sector_owner_ids,
+            vec![],
+            1,
+            HelicitySupportRule::None,
+            GlobalHelicityFlipRule::None,
+            reflection_certificates,
+        )
+        .unwrap();
+        (
+            program,
+            stage_diagnostics,
+            constructed_counts,
+            generation_telemetry,
+        )
+    }
+
+    #[test]
+    fn materialized_color_targets_keep_only_embeddable_ordered_words() {
+        let target_open =
+            LCColorComponent::new(LCColorComponentKind::OpenString, vec![0, 2, 3, 4, 1]).unwrap();
+        let targets = MaterializedColorTargets::from_sectors(vec![vec![target_open]]).unwrap();
+        let state = |slots: Vec<u32>| {
+            DynamicLCColorState::new(
+                0,
+                Some(0),
+                vec![LCColorComponent::new(LCColorComponentKind::AdjointSegment, slots).unwrap()],
+            )
+            .unwrap()
+        };
+        let adjoint_state = |slots: Vec<u32>| {
+            DynamicLCColorState::new_port_wired(
+                0,
+                vec![
+                    LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                    LCColorPortBinding::new(0, LCColorEndpoint::Front),
+                ],
+                vec![LCColorComponent::new(LCColorComponentKind::AdjointSegment, slots).unwrap()],
+            )
+            .unwrap()
+        };
+
+        assert!(targets.accepts(&state(vec![2, 3, 4])));
+        assert!(!targets.accepts(&state(vec![4, 3, 2])));
+        assert!(
+            targets
+                .accepts_up_to_reflection(&adjoint_state(vec![4, 3, 2]))
+                .unwrap()
+        );
+        assert!(!targets.accepts(&state(vec![2, 4])));
+        assert!(
+            !targets
+                .accepts_up_to_reflection(&state(vec![2, 4]))
+                .unwrap()
+        );
+        assert!(!targets.accepts(&state(vec![0, 3])));
+        assert!(targets.accepts(&DynamicLCColorState::new(0, None, vec![]).unwrap()));
+    }
+
+    #[test]
+    fn materialized_color_targets_accept_cyclic_trace_segments() {
+        let target_trace =
+            LCColorComponent::new(LCColorComponentKind::Trace, vec![1, 2, 3, 4]).unwrap();
+        let targets = MaterializedColorTargets::from_sectors(vec![vec![target_trace]]).unwrap();
+        let state = |kind, slots: Vec<u32>| {
+            DynamicLCColorState::new(
+                0,
+                (kind != LCColorComponentKind::Trace).then_some(0),
+                vec![LCColorComponent::new(kind, slots).unwrap()],
+            )
+            .unwrap()
+        };
+
+        assert!(targets.accepts(&state(LCColorComponentKind::AdjointSegment, vec![4, 1, 2],)));
+        assert!(!targets.accepts(&state(LCColorComponentKind::AdjointSegment, vec![2, 1, 4],)));
+        assert!(!targets.accepts(&state(LCColorComponentKind::AdjointSegment, vec![1, 3],)));
+        assert!(!targets.accepts(&state(LCColorComponentKind::Trace, vec![4, 3, 2, 1],)));
+        assert!(!targets.accepts(&state(LCColorComponentKind::Trace, vec![1, 2, 3],)));
+    }
+
+    fn reference_color_targets_accept(
+        sectors: &[Vec<LCColorComponent>],
+        state: &DynamicLCColorState,
+    ) -> bool {
+        if state.components().is_empty() {
+            return true;
+        }
+        sectors.iter().any(|sector| {
+            state.components().iter().all(|partial| {
+                sector
+                    .iter()
+                    .any(|target| component_can_embed(partial, target))
+            })
+        })
+    }
+
+    fn unique_source_words(source_slots: &[u32]) -> Vec<Vec<u32>> {
+        fn extend(
+            source_slots: &[u32],
+            used: &mut [bool],
+            prefix: &mut Vec<u32>,
+            result: &mut Vec<Vec<u32>>,
+        ) {
+            for index in 0..source_slots.len() {
+                if used[index] {
+                    continue;
+                }
+                used[index] = true;
+                prefix.push(source_slots[index]);
+                result.push(prefix.clone());
+                extend(source_slots, used, prefix, result);
+                prefix.pop();
+                used[index] = false;
+            }
+        }
+
+        let mut result = Vec::new();
+        extend(
+            source_slots,
+            &mut vec![false; source_slots.len()],
+            &mut Vec::new(),
+            &mut result,
+        );
+        result
+    }
+
+    fn exhaustive_color_components(source_slots: &[u32]) -> Vec<LCColorComponent> {
+        let mut result = BTreeSet::new();
+        for kind in [
+            LCColorComponentKind::OpenString,
+            LCColorComponentKind::AdjointSegment,
+            LCColorComponentKind::Trace,
+        ] {
+            for word in unique_source_words(source_slots) {
+                result.insert(LCColorComponent::new(kind, word).unwrap());
+            }
+        }
+        result.into_iter().collect()
+    }
+
+    fn components_are_disjoint(left: &LCColorComponent, right: &LCColorComponent) -> bool {
+        left.source_slots()
+            .iter()
+            .all(|slot| !right.source_slots().contains(slot))
+    }
+
+    #[test]
+    fn indexed_color_targets_match_exhaustive_single_component_reference() {
+        let components = exhaustive_color_components(&[0, 1, 2, 3]);
+        for target in &components {
+            let sectors = vec![vec![target.clone()]];
+            let targets = MaterializedColorTargets::from_sectors(sectors.clone()).unwrap();
+            for partial in &components {
+                let state = DynamicLCColorState::new(0, None, vec![partial.clone()]).unwrap();
+                assert_eq!(
+                    targets.accepts(&state),
+                    reference_color_targets_accept(&sectors, &state),
+                    "partial {partial:?}, target {target:?}",
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn indexed_color_targets_match_exhaustive_sector_intersection_reference() {
+        let sectors = vec![
+            vec![
+                LCColorComponent::new(LCColorComponentKind::OpenString, vec![0, 1]).unwrap(),
+                LCColorComponent::new(LCColorComponentKind::Trace, vec![2, 3]).unwrap(),
+            ],
+            vec![
+                LCColorComponent::new(LCColorComponentKind::OpenString, vec![0, 2]).unwrap(),
+                LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![1, 3]).unwrap(),
+            ],
+            vec![
+                LCColorComponent::new(LCColorComponentKind::Trace, vec![0, 3]).unwrap(),
+                LCColorComponent::new(LCColorComponentKind::OpenString, vec![1, 2]).unwrap(),
+            ],
+        ];
+        let targets = MaterializedColorTargets::from_sectors(sectors.clone()).unwrap();
+        let components = exhaustive_color_components(&[0, 1, 2, 3]);
+        let empty = DynamicLCColorState::new(0, None, vec![]).unwrap();
+        assert_eq!(
+            targets.accepts(&empty),
+            reference_color_targets_accept(&sectors, &empty)
+        );
+        for left in &components {
+            let state = DynamicLCColorState::new(0, None, vec![left.clone()]).unwrap();
+            assert_eq!(
+                targets.accepts(&state),
+                reference_color_targets_accept(&sectors, &state),
+                "single partial {left:?}",
+            );
+            for right in &components {
+                if !components_are_disjoint(left, right) {
+                    continue;
+                }
+                let state =
+                    DynamicLCColorState::new(0, None, vec![left.clone(), right.clone()]).unwrap();
+                assert_eq!(
+                    targets.accepts(&state),
+                    reference_color_targets_accept(&sectors, &state),
+                    "partial forest [{left:?}, {right:?}]",
+                );
+            }
+        }
+
+        let split_sectors = vec![
+            vec![LCColorComponent::new(LCColorComponentKind::OpenString, vec![0, 1]).unwrap()],
+            vec![LCColorComponent::new(LCColorComponentKind::OpenString, vec![2, 3]).unwrap()],
+        ];
+        let split_targets = MaterializedColorTargets::from_sectors(split_sectors.clone()).unwrap();
+        let split_state = DynamicLCColorState::new(
+            0,
+            None,
+            vec![
+                LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![0, 1]).unwrap(),
+                LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![2, 3]).unwrap(),
+            ],
+        )
+        .unwrap();
+        assert!(!reference_color_targets_accept(
+            &split_sectors,
+            &split_state
+        ));
+        assert!(!split_targets.accepts(&split_state));
+    }
+
+    #[test]
+    fn indexed_color_target_postings_span_multiple_words() {
+        let sectors = (0..130_u32)
+            .map(|source_slot| {
+                vec![
+                    LCColorComponent::new(LCColorComponentKind::OpenString, vec![source_slot])
+                        .unwrap(),
+                ]
+            })
+            .collect::<Vec<_>>();
+        let targets = MaterializedColorTargets::from_sectors(sectors.clone()).unwrap();
+        for source_slot in [0, 63, 64, 127, 129, 130] {
+            let state = DynamicLCColorState::new(
+                0,
+                None,
+                vec![
+                    LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![source_slot])
+                        .unwrap(),
+                ],
+            )
+            .unwrap();
+            assert_eq!(
+                targets.accepts(&state),
+                reference_color_targets_accept(&sectors, &state),
+                "source slot {source_slot}",
+            );
+        }
+    }
+
+    #[test]
+    fn sector_postings_use_dense_storage_only_when_strictly_cheaper() {
+        let sparse_on_tie = SectorPosting::from_sorted_unique_sector_ids((0..6_u32).collect(), 130);
+        assert!(sparse_on_tie.is_sparse());
+        assert_eq!(sparse_on_tie.cardinality(), 6);
+        assert_eq!(sparse_on_tie.payload_bytes(), 24);
+
+        let dense = SectorPosting::from_sorted_unique_sector_ids((0..7_u32).collect(), 130);
+        assert!(!dense.is_sparse());
+        assert_eq!(dense.cardinality(), 7);
+        assert_eq!(dense.payload_bytes(), 24);
+        assert!(dense.contains(0));
+        assert!(dense.contains(6));
+        assert!(!dense.contains(7));
+        assert!(!dense.contains(130));
+    }
+
+    #[test]
+    fn adaptive_color_postings_match_reference_and_account_exact_storage() {
+        let component = |source_slot| {
+            LCColorComponent::new(LCColorComponentKind::OpenString, vec![source_slot]).unwrap()
+        };
+        let partial_state = |source_slots: &[u32]| {
+            DynamicLCColorState::new(
+                0,
+                None,
+                source_slots
+                    .iter()
+                    .copied()
+                    .map(|source_slot| {
+                        LCColorComponent::new(
+                            LCColorComponentKind::AdjointSegment,
+                            vec![source_slot],
+                        )
+                        .unwrap()
+                    })
+                    .collect(),
+            )
+            .unwrap()
+        };
+
+        let mut sectors = vec![Vec::new(); 256];
+        for sector in &mut sectors[..128] {
+            sector.push(component(2_000));
+        }
+        sectors[5].push(component(1_000));
+        sectors[5].push(component(1_000));
+        sectors[200].push(component(1_000));
+        sectors[200].push(component(3_000));
+
+        let targets =
+            MaterializedColorTargets::from_sectors_with_telemetry(sectors.clone(), true).unwrap();
+        let storage = targets.telemetry().unwrap();
+        assert_eq!(storage.fragment_bucket_count, 3);
+        assert_eq!(storage.posting_incidence_count, 131);
+        assert_eq!(storage.sparse_posting_bucket_count, 2);
+        assert_eq!(storage.dense_posting_bucket_count, 1);
+        assert_eq!(storage.sparse_posting_bytes, 12);
+        assert_eq!(storage.dense_posting_bytes, 32);
+        let dense_only_baseline_bytes = storage
+            .fragment_bucket_count
+            .checked_mul(256_usize.div_ceil(u64::BITS as usize))
+            .and_then(|words| words.checked_mul(std::mem::size_of::<u64>()))
+            .unwrap();
+        assert_eq!(dense_only_baseline_bytes, 96);
+        assert_eq!(
+            storage
+                .sparse_posting_bytes
+                .checked_add(storage.dense_posting_bytes),
+            Some(44),
+        );
+
+        for source_slots in [
+            &[][..],
+            &[1_000][..],
+            &[2_000][..],
+            &[3_000][..],
+            &[1_000, 2_000][..],
+            &[1_000, 3_000][..],
+            &[1_000, 2_000, 3_000][..],
+            &[4_000][..],
+        ] {
+            let state = partial_state(source_slots);
+            assert_eq!(
+                targets.accepts(&state),
+                reference_color_targets_accept(&sectors, &state),
+                "partial source slots {source_slots:?}",
+            );
+        }
+
+        let memo_targets =
+            MaterializedColorTargets::from_sectors_with_telemetry(sectors.clone(), true).unwrap();
+        let accepted = partial_state(&[1_000, 2_000]);
+        let rejected = partial_state(&[1_000, 2_000, 3_000]);
+        assert!(memo_targets.accepts(&accepted));
+        assert_eq!(memo_targets.accepted_component_forests.borrow().len(), 1);
+        assert!(memo_targets.accepts(&accepted));
+        assert_eq!(memo_targets.accepted_component_forests.borrow().len(), 1);
+        assert!(!memo_targets.accepts(&rejected));
+        assert!(!memo_targets.accepts(&rejected));
+        assert_eq!(memo_targets.accepted_component_forests.borrow().len(), 1);
+        let memo = memo_targets.telemetry().unwrap();
+        assert_eq!(memo.acceptance_cache_hit_count, 1);
+        assert_eq!(memo.acceptance_cache_miss_count, 3);
+        assert_eq!(memo.acceptance_accept_count, 2);
+        assert_eq!(memo.acceptance_reject_count, 2);
+    }
+
+    #[test]
+    fn all_dense_color_postings_match_exact_wordwise_intersection_reference() {
+        let component = |source_slot| {
+            LCColorComponent::new(LCColorComponentKind::OpenString, vec![source_slot]).unwrap()
+        };
+        let mut sectors = vec![Vec::new(); 256];
+        for sector in sectors.iter_mut().take(192) {
+            sector.push(component(10));
+        }
+        for sector in sectors.iter_mut().take(256).skip(64) {
+            sector.push(component(20));
+        }
+        for sector in sectors.iter_mut().take(256).step_by(2) {
+            sector.push(component(30));
+        }
+        for sector in &mut sectors[192..] {
+            sector.push(component(40));
+        }
+        let targets = MaterializedColorTargets::from_sectors(sectors.clone()).unwrap();
+        assert!(
+            targets
+                .non_trace_fragment_sectors
+                .values()
+                .all(|posting| !posting.is_sparse())
+        );
+
+        for source_slots in [
+            &[10, 20][..],
+            &[10, 30][..],
+            &[20, 30][..],
+            &[10, 20, 30][..],
+            &[10, 40][..],
+            &[20, 40][..],
+        ] {
+            let state = DynamicLCColorState::new(
+                0,
+                None,
+                source_slots
+                    .iter()
+                    .map(|source_slot| {
+                        LCColorComponent::new(
+                            LCColorComponentKind::AdjointSegment,
+                            vec![*source_slot],
+                        )
+                        .unwrap()
+                    })
+                    .collect(),
+            )
+            .unwrap();
+            assert_eq!(
+                targets.accepts(&state),
+                reference_color_targets_accept(&sectors, &state),
+                "all-dense partial source slots {source_slots:?}",
+            );
+        }
+    }
+
+    #[test]
+    fn indexed_color_targets_match_exhaustive_reflection_reference() {
+        let sectors = vec![
+            vec![
+                LCColorComponent::new(LCColorComponentKind::OpenString, vec![0, 1, 2, 3]).unwrap(),
+            ],
+            vec![LCColorComponent::new(LCColorComponentKind::Trace, vec![0, 2, 3, 1]).unwrap()],
+        ];
+        let targets = MaterializedColorTargets::from_sectors(sectors.clone()).unwrap();
+        let mut accepted = 0usize;
+        let mut rejected = 0usize;
+        for word in unique_source_words(&[0, 1, 2, 3]) {
+            let state = DynamicLCColorState::new_port_wired(
+                0,
+                vec![
+                    LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                    LCColorPortBinding::new(0, LCColorEndpoint::Front),
+                ],
+                vec![LCColorComponent::new(LCColorComponentKind::AdjointSegment, word).unwrap()],
+            )
+            .unwrap();
+            let expected = reference_color_targets_accept(&sectors, &state)
+                || reference_color_targets_accept(&sectors, &state.reversed().unwrap());
+            assert_eq!(
+                targets.accepts_up_to_reflection(&state).unwrap(),
+                expected,
+                "pure-adjoint state {state:?}",
+            );
+            if expected {
+                accepted += 1;
+            } else {
+                rejected += 1;
+            }
+        }
+        assert!(accepted > 0);
+        assert!(rejected > 0);
+    }
+
+    #[test]
+    fn color_target_memo_retains_only_accepted_forests_without_changing_reflection_eligibility() {
+        let targets = MaterializedColorTargets::from_sectors(vec![vec![
+            LCColorComponent::new(LCColorComponentKind::OpenString, vec![0, 1, 2]).unwrap(),
+        ]])
+        .unwrap();
+        let component =
+            LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![2, 1]).unwrap();
+        let non_reflectable =
+            DynamicLCColorState::new(0, Some(0), vec![component.clone()]).unwrap();
+        assert!(!targets.accepts_up_to_reflection(&non_reflectable).unwrap());
+        assert!(targets.accepted_component_forests.borrow().is_empty());
+        assert!(!targets.accepts_up_to_reflection(&non_reflectable).unwrap());
+        assert!(targets.accepted_component_forests.borrow().is_empty());
+
+        let reflectable = DynamicLCColorState::new_port_wired(
+            99,
+            vec![
+                LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                LCColorPortBinding::new(0, LCColorEndpoint::Front),
+            ],
+            vec![component],
+        )
+        .unwrap();
+        assert!(targets.accepts_up_to_reflection(&reflectable).unwrap());
+        assert_eq!(targets.accepted_component_forests.borrow().len(), 1);
+        assert!(targets.accepts_up_to_reflection(&reflectable).unwrap());
+        assert_eq!(targets.accepted_component_forests.borrow().len(), 1);
+    }
+
+    #[test]
+    fn replay_construction_isolates_authenticated_representatives() {
+        let replay_targets = [
+            RecurrenceReplayTarget::new(0, 4, 0, vec![0, 1], vec![1, 1], ExactComplexRational::ONE)
+                .unwrap(),
+            RecurrenceReplayTarget::new(1, 9, 1, vec![1, 0], vec![1, 1], ExactComplexRational::ONE)
+                .unwrap(),
+        ];
+        let sectors = BTreeSet::from([4, 9]);
+        assert_eq!(
+            construction_sector_groups(
+                RecurrenceStrategy::ContractedColorUnion,
+                &sectors,
+                &replay_targets,
+            ),
+            [BTreeSet::from([4]), BTreeSet::from([9])]
+        );
+        assert_eq!(
+            construction_sector_groups(RecurrenceStrategy::AllFlowUnion, &sectors, &[]),
+            std::slice::from_ref(&sectors)
+        );
+
+        let first_lane = PendingConstructionDomain {
+            shared_source_end: 4,
+            lane_internal_start: 4,
+            lane_internal_end: 10,
+        };
+        assert!(first_lane.contains(0));
+        assert!(first_lane.contains(9));
+        assert!(!first_lane.contains(10));
+    }
+
+    #[test]
+    fn scalar_reference_fixtures_keep_structural_schedule_counts() {
+        // Closure-rooted admission materializes no current or contribution
+        // outside the final exact schedule for this scalar grammar.
+        for (name, external_count, expected_constructed, expected_schedule) in [
+            ("three-point", 3, (4, 1, 1), (4, 1, 1)),
+            ("four-point", 4, (8, 6, 1), (8, 6, 1)),
+        ] {
+            let (program, _, constructed_counts, _) = scalar_reference_program(external_count);
+            assert_eq!(
+                constructed_counts, expected_constructed,
+                "{name} scalar construction fixture",
+            );
+            assert_eq!(
+                (
+                    program.currents().len(),
+                    program.contributions().len(),
+                    program.closure_terms().len(),
+                ),
+                expected_schedule,
+                "{name} scalar reference fixture",
+            );
+        }
+    }
+
+    #[test]
+    fn scalar_reference_fixture_reports_streaming_selectivity() {
+        let (_, diagnostics, _, _) = scalar_reference_program(4);
+        assert_eq!(diagnostics.len(), 2);
+        assert_eq!(
+            diagnostics
+                .iter()
+                .map(|stage| (
+                    stage.target_size,
+                    stage.candidate_parent_pair_count,
+                    stage.parent_pair_count,
+                    stage.transition_index_hit_count,
+                    stage.transition_candidate_count,
+                    stage.contribution_attempt_count,
+                ))
+                .collect::<Vec<_>>(),
+            [(2, 6, 6, 6, 6, 3), (3, 12, 6, 6, 6, 3)],
+        );
+    }
+
+    #[test]
+    fn scalar_reference_fixture_reports_exact_closure_index_counters() {
+        let (_, _, _, telemetry) = scalar_reference_program(4);
+        assert_eq!(telemetry.closure_support_lookup_count, 2);
+        assert_eq!(telemetry.closure_candidate_theoretical_count, 1);
+        assert_eq!(telemetry.closure_candidate_count, 1);
+        assert_eq!(telemetry.closure_state_match_count, 1);
+        assert_eq!(telemetry.closure_color_attempt_count, 1);
+        assert_eq!(telemetry.closure_group_count, 1);
+        assert_eq!(telemetry.closure_proof_contribution_count, 1);
+    }
+
+    #[test]
+    fn contracted_closure_buckets_match_legacy_rows_and_collapse_executed_attempts() {
+        let template = scalar_reference_template();
+        let template_catalog = TemplateCatalog::new(&template).unwrap();
+        let prepared_closures = PreparedClosureCatalog::new(&template, &template_catalog).unwrap();
+        let mut process = scalar_reference_process(2);
+        process
+            .physical_lc_sectors
+            .push(ProcessPhysicalLCSectorRow {
+                sector_id: 1,
+                ..process.physical_lc_sectors[0]
+            });
+        let process_catalog = ProcessCatalog::new(&process).unwrap();
+        let materialized_sectors = BTreeSet::from([0, 1]);
+        let prepared_sectors = PreparedClosureSectorCatalog::new(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            &process_catalog,
+            &materialized_sectors,
+        )
+        .unwrap();
+        let fermion_ordering =
+            established_fermion_ordering_context(&process, &template, None).unwrap();
+        let mut color_states = DynamicLCColorStateInterner::default();
+        let color_id = color_states
+            .intern(DynamicLCColorState::new(0, None, vec![]).unwrap())
+            .unwrap();
+        let currents = (0..2_u32)
+            .map(|source_slot| {
+                let key = CurrentCoreKey::new(
+                    template.catalog_digest,
+                    RecurrenceNodeKind::Source,
+                    0,
+                    color_id,
+                    vec![source_slot],
+                    CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                        source_slot,
+                        coefficient: 1,
+                    }])
+                    .unwrap(),
+                    CurrentHelicityIdentity::contracted_color_union(
+                        0,
+                        vec![SourceStateAssignment::new(source_slot, 0)],
+                    )
+                    .unwrap(),
+                    vec![0],
+                    0,
+                    vec![],
+                    CurrentSourceBinding::FixedTemplate(source_slot),
+                    None,
+                )
+                .unwrap();
+                PendingCurrent {
+                    key,
+                    source_exact_factor: Some(ExactComplexRational::ONE),
+                    contributions: BTreeMap::new(),
+                    realized_pairing_rule_ids: BTreeSet::new(),
+                    reflection: CurrentReflection::Unavailable,
+                    reflection_certificate_id: None,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let mut bucketed_telemetry = RecurrenceGenerationTelemetry::default();
+        let bucketed = build_closures(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            &process_catalog,
+            &template,
+            &fermion_ordering,
+            None,
+            &prepared_closures,
+            &prepared_sectors,
+            &color_states,
+            &currents,
+            &materialized_sectors,
+            &[],
+            &[],
+            None,
+            &mut bucketed_telemetry,
+            true,
+        )
+        .unwrap();
+        let mut legacy_telemetry = RecurrenceGenerationTelemetry::default();
+        let legacy = build_closures_per_sector(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            &process_catalog,
+            &template,
+            &fermion_ordering,
+            None,
+            &prepared_closures,
+            &prepared_sectors,
+            &color_states,
+            &currents,
+            &materialized_sectors,
+            &[],
+            &[],
+            None,
+            &mut legacy_telemetry,
+            true,
+        )
+        .unwrap();
+
+        // PendingClosureGroup equality covers key identity, aggregate exact
+        // factors, and every proof contribution field in vector order.
+        assert_eq!(bucketed, legacy);
+        assert_eq!(
+            bucketed
+                .keys()
+                .map(|key| key.target_sector_id)
+                .collect::<Vec<_>>(),
+            [0, 1]
+        );
+        assert_eq!(bucketed_telemetry.closure_candidate_theoretical_count, 2);
+        assert_eq!(
+            bucketed_telemetry.closure_candidate_theoretical_count,
+            legacy_telemetry.closure_candidate_theoretical_count
+        );
+        assert_eq!(bucketed_telemetry.closure_support_lookup_count, 2);
+        assert_eq!(legacy_telemetry.closure_support_lookup_count, 4);
+        assert_eq!(bucketed_telemetry.closure_candidate_count, 1);
+        assert_eq!(legacy_telemetry.closure_candidate_count, 2);
+        assert_eq!(bucketed_telemetry.closure_state_match_count, 1);
+        assert_eq!(legacy_telemetry.closure_state_match_count, 2);
+        assert_eq!(bucketed_telemetry.closure_color_attempt_count, 1);
+        assert_eq!(legacy_telemetry.closure_color_attempt_count, 2);
+        assert_eq!(bucketed_telemetry.closure_group_count, 2);
+        assert_eq!(bucketed_telemetry.closure_proof_contribution_count, 2);
+    }
+
+    #[test]
+    fn complete_closure_target_domain_certifies_only_an_exhaustive_empty_owner_class() {
+        let process = scalar_reference_process(2);
+        let sector_ids = BTreeSet::from([0, 1]);
+        let owner_ids = BTreeMap::from([(0, 0), (1, 0)]);
+        let helicity_ids = BTreeMap::from([(
+            vec![
+                SourceStateAssignment::new(0, 0),
+                SourceStateAssignment::new(1, 0),
+            ]
+            .into_boxed_slice(),
+            0,
+        )]);
+        let pending_closures = BTreeMap::new();
+        let certificate = complete_closure_target_domain_certificate(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            2,
+            &sector_ids,
+            &owner_ids,
+            &[],
+            &helicity_ids,
+            &pending_closures,
+            &[],
+        )
+        .unwrap()
+        .unwrap();
+
+        assert_eq!(certificate.physical_sector_count(), 2);
+        assert_eq!(certificate.resolved_helicity_count(), 1);
+        assert_eq!(
+            certificate.certified_structural_zero_physical_sector_ids(),
+            [0, 1]
+        );
+        assert_eq!(
+            complete_closure_target_domain_certificate(
+                RecurrenceStrategy::ContractedColorUnion,
+                &process,
+                2,
+                &sector_ids,
+                &owner_ids,
+                &[],
+                &helicity_ids,
+                &pending_closures,
+                &[],
+            )
+            .unwrap()
+            .unwrap()
+            .semantic_digest(),
+            certificate.semantic_digest(),
+        );
+
+        let missing = complete_closure_target_domain_certificate(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            2,
+            &BTreeSet::from([0]),
+            &BTreeMap::from([(0, 0)]),
+            &[],
+            &helicity_ids,
+            &pending_closures,
+            &[],
+        )
+        .unwrap_err();
+        assert!(
+            missing
+                .message()
+                .contains("lacks exhaustive physical-sector coverage")
+        );
+    }
+
+    #[test]
+    fn complete_closure_target_domain_expands_authenticated_replay_representatives() {
+        let mut process = scalar_reference_process(2);
+        process.source_states = vec![
+            ProcessSourceStateRow {
+                source_slot: 0,
+                state_index: 0,
+                public_helicity: 1,
+                chirality: 0,
+                spin_state: 1,
+                current_state_template_id: 0,
+                source_template_id: 0,
+                momentum_sign: 1,
+                crossing_phase_factor_id: 0,
+            },
+            ProcessSourceStateRow {
+                source_slot: 1,
+                state_index: 0,
+                public_helicity: 1,
+                chirality: 0,
+                spin_state: 1,
+                current_state_template_id: 0,
+                source_template_id: 0,
+                momentum_sign: 1,
+                crossing_phase_factor_id: 0,
+            },
+        ];
+        let helicity_ids = BTreeMap::from([(
+            vec![
+                SourceStateAssignment::new(0, 0),
+                SourceStateAssignment::new(1, 0),
+            ]
+            .into_boxed_slice(),
+            0,
+        )]);
+        let replay_targets = vec![
+            RecurrenceReplayTarget::new(0, 0, 0, vec![0, 1], vec![1, 1], ExactComplexRational::ONE)
+                .unwrap(),
+            RecurrenceReplayTarget::new(1, 0, 1, vec![1, 0], vec![1, 1], ExactComplexRational::ONE)
+                .unwrap(),
+        ];
+        let certificate = complete_closure_target_domain_certificate(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            2,
+            &BTreeSet::from([0]),
+            &BTreeMap::from([(0, 0)]),
+            &replay_targets,
+            &helicity_ids,
+            &BTreeMap::new(),
+            &[],
+        )
+        .unwrap()
+        .unwrap();
+
+        assert_eq!(
+            certificate.certified_structural_zero_physical_sector_ids(),
+            [0, 1]
+        );
+        assert!(
+            complete_closure_target_domain_certificate(
+                RecurrenceStrategy::ContractedColorUnion,
+                &process,
+                2,
+                &BTreeSet::from([0]),
+                &BTreeMap::from([(0, 0)]),
+                &replay_targets[..1],
+                &helicity_ids,
+                &BTreeMap::new(),
+                &[],
+            )
+            .unwrap_err()
+            .message()
+            .contains("does not cover every physical sector")
+        );
+    }
+
+    #[test]
+    fn contracted_and_all_flow_closures_preserve_v4_reflection_partner_rows() {
+        let (mut process, mut template) = cyclic_trace_anchor_contract_fixture();
+        let closure_pairings = append_u32_sequence(&mut template, &[0, 0, 1, 1, 0, 1, 1, 0]);
+        template.lc_color_transition_witnesses[1].input_port_pairing_sequence_id = closure_pairings;
+        let reflected_word_id = process.u32_sequence_ranges.len() as u32;
+        process.u32_sequence_ranges.push(CheckedTableRange::new(
+            process.u32_sequence_values.len() as u64,
+            4,
+        ));
+        process.u32_sequence_values.extend_from_slice(&[0, 3, 2, 1]);
+        process
+            .physical_lc_sectors
+            .push(ProcessPhysicalLCSectorRow {
+                sector_id: 1,
+                trace_sequence_id: reflected_word_id,
+                word_sequence_id: reflected_word_id,
+                ..process.physical_lc_sectors[0]
+            });
+
+        let template_catalog = TemplateCatalog::new(&template).unwrap();
+        let prepared_closures = PreparedClosureCatalog::new(&template, &template_catalog).unwrap();
+        let process_catalog = ProcessCatalog::new(&process).unwrap();
+        let materialized_sectors = BTreeSet::from([0, 1]);
+        let prepared_sectors = PreparedClosureSectorCatalog::new(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            &process_catalog,
+            &materialized_sectors,
+        )
+        .unwrap();
+        let fermion_ordering =
+            established_fermion_ordering_context(&process, &template, None).unwrap();
+
+        let adjoint =
+            |word| LCColorComponent::new(LCColorComponentKind::AdjointSegment, word).unwrap();
+        let color = |word| {
+            DynamicLCColorState::new_port_wired(
+                0,
+                vec![
+                    LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                    LCColorPortBinding::new(0, LCColorEndpoint::Front),
+                ],
+                vec![adjoint(word)],
+            )
+            .unwrap()
+        };
+        let anchor_color = color(vec![0]);
+        let complement_color = color(vec![1, 2, 3]);
+        let reflected_color = color(vec![3, 2, 1]);
+        let minus_one = ExactComplexRational::ONE.checked_neg().unwrap();
+        let canonical_proof = CurrentReflectionProof::new(
+            minus_one,
+            [digest(180)],
+            dynamic_color_identity_digest(&complement_color).unwrap(),
+        )
+        .unwrap();
+        let reflected_proof = CurrentReflectionProof::new(
+            minus_one,
+            [digest(181)],
+            dynamic_color_identity_digest(&reflected_color).unwrap(),
+        )
+        .unwrap();
+        let reflection_certificate = PendingReflectionCertificate::reciprocal_pair(
+            0,
+            1,
+            2,
+            &canonical_proof,
+            &reflected_proof,
+            &complement_color,
+            &reflected_color,
+            4,
+        )
+        .unwrap();
+        let mut color_states = DynamicLCColorStateInterner::default();
+        let anchor_color_id = color_states.intern(anchor_color).unwrap();
+        let complement_color_id = color_states.intern(complement_color).unwrap();
+        let current = |strategy,
+                       node_kind,
+                       color_id,
+                       support: &[u32],
+                       reflection,
+                       reflection_certificate_id| {
+            let helicity_identity = match strategy {
+                RecurrenceStrategy::AllFlowUnion => CurrentHelicityIdentity::all_flow_union(0),
+                RecurrenceStrategy::ContractedColorUnion => {
+                    CurrentHelicityIdentity::contracted_color_union(
+                        0,
+                        support
+                            .iter()
+                            .copied()
+                            .map(|slot| SourceStateAssignment::new(slot, 0))
+                            .collect(),
+                    )
+                    .unwrap()
+                }
+                RecurrenceStrategy::TopologyReplay => unreachable!("test fixture strategy"),
+            };
+            let source_binding = if node_kind != RecurrenceNodeKind::Source {
+                CurrentSourceBinding::None
+            } else if strategy == RecurrenceStrategy::AllFlowUnion {
+                CurrentSourceBinding::runtime_dispatch(support[0], vec![support[0]]).unwrap()
+            } else {
+                CurrentSourceBinding::FixedTemplate(support[0])
+            };
+            let key = CurrentCoreKey::new(
+                template.catalog_digest,
+                node_kind,
+                0,
+                color_id,
+                support.to_vec(),
+                CanonicalMomentumLinearForm::new(
+                    support
+                        .iter()
+                        .copied()
+                        .map(|source_slot| MomentumTerm {
+                            source_slot,
+                            coefficient: 1,
+                        })
+                        .collect(),
+                )
+                .unwrap(),
+                helicity_identity,
+                vec![0],
+                0,
+                vec![],
+                source_binding,
+                None,
+            )
+            .unwrap();
+            PendingCurrent {
+                key,
+                source_exact_factor: (node_kind == RecurrenceNodeKind::Source
+                    && strategy != RecurrenceStrategy::AllFlowUnion)
+                    .then_some(ExactComplexRational::ONE),
+                contributions: BTreeMap::new(),
+                realized_pairing_rule_ids: BTreeSet::new(),
+                reflection,
+                reflection_certificate_id,
+            }
+        };
+        let currents = vec![
+            current(
+                RecurrenceStrategy::ContractedColorUnion,
+                RecurrenceNodeKind::Source,
+                anchor_color_id,
+                &[0],
+                CurrentReflection::Unavailable,
+                None,
+            ),
+            current(
+                RecurrenceStrategy::ContractedColorUnion,
+                RecurrenceNodeKind::Current,
+                complement_color_id,
+                &[1, 2, 3],
+                CurrentReflection::Proven(canonical_proof.clone()),
+                Some(0),
+            ),
+        ];
+        let reflection_certificates = [reflection_certificate];
+
+        let mut bucketed_telemetry = RecurrenceGenerationTelemetry::default();
+        let bucketed = build_closures(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            &process_catalog,
+            &template,
+            &fermion_ordering,
+            None,
+            &prepared_closures,
+            &prepared_sectors,
+            &color_states,
+            &currents,
+            &materialized_sectors,
+            &[],
+            &reflection_certificates,
+            None,
+            &mut bucketed_telemetry,
+            true,
+        )
+        .unwrap();
+        let mut legacy_telemetry = RecurrenceGenerationTelemetry::default();
+        let legacy = build_closures_per_sector(
+            RecurrenceStrategy::ContractedColorUnion,
+            &process,
+            &process_catalog,
+            &template,
+            &fermion_ordering,
+            None,
+            &prepared_closures,
+            &prepared_sectors,
+            &color_states,
+            &currents,
+            &materialized_sectors,
+            &[],
+            &reflection_certificates,
+            None,
+            &mut legacy_telemetry,
+            true,
+        )
+        .unwrap();
+
+        assert_eq!(bucketed, legacy);
+        assert_eq!(bucketed.len(), 2);
+        let canonical = bucketed
+            .iter()
+            .find(|(key, _)| key.target_sector_id == 0)
+            .unwrap();
+        let reflected = bucketed
+            .iter()
+            .find(|(key, _)| key.target_sector_id == 1)
+            .unwrap();
+        assert_eq!(canonical.1.exact_factor, ExactComplexRational::ONE);
+        assert_eq!(reflected.1.exact_factor, minus_one);
+        assert_eq!(
+            reflected.1.contributions[0].reflection_certificate_id,
+            Some(0)
+        );
+        assert_eq!(bucketed_telemetry.closure_color_attempt_count, 1);
+        assert_eq!(legacy_telemetry.closure_color_attempt_count, 2);
+
+        // The all-flow lane retains the same canonical complement and emits
+        // the reverse physical trace through the authenticated reflection
+        // certificate.  Completeness is therefore per physical target, not
+        // per-sector growth of the shared closure map.
+        let all_flow_sectors = PreparedClosureSectorCatalog::new(
+            RecurrenceStrategy::AllFlowUnion,
+            &process,
+            &process_catalog,
+            &materialized_sectors,
+        )
+        .unwrap();
+        let all_flow_currents = vec![
+            current(
+                RecurrenceStrategy::AllFlowUnion,
+                RecurrenceNodeKind::Source,
+                anchor_color_id,
+                &[0],
+                CurrentReflection::Unavailable,
+                None,
+            ),
+            current(
+                RecurrenceStrategy::AllFlowUnion,
+                RecurrenceNodeKind::Current,
+                complement_color_id,
+                &[1, 2, 3],
+                CurrentReflection::Proven(canonical_proof),
+                Some(0),
+            ),
+        ];
+        let mut all_flow_telemetry = RecurrenceGenerationTelemetry::default();
+        let all_flow = build_closures(
+            RecurrenceStrategy::AllFlowUnion,
+            &process,
+            &process_catalog,
+            &template,
+            &fermion_ordering,
+            None,
+            &prepared_closures,
+            &all_flow_sectors,
+            &color_states,
+            &all_flow_currents,
+            &materialized_sectors,
+            &[],
+            &reflection_certificates,
+            None,
+            &mut all_flow_telemetry,
+            true,
+        )
+        .unwrap();
+        let mut all_flow_legacy_telemetry = RecurrenceGenerationTelemetry::default();
+        let all_flow_legacy = build_closures_per_sector(
+            RecurrenceStrategy::AllFlowUnion,
+            &process,
+            &process_catalog,
+            &template,
+            &fermion_ordering,
+            None,
+            &prepared_closures,
+            &all_flow_sectors,
+            &color_states,
+            &all_flow_currents,
+            &materialized_sectors,
+            &[],
+            &reflection_certificates,
+            None,
+            &mut all_flow_legacy_telemetry,
+            true,
+        )
+        .unwrap();
+
+        assert_eq!(all_flow, all_flow_legacy);
+        assert_eq!(all_flow.len(), 2);
+        let canonical = all_flow
+            .iter()
+            .find(|(key, _)| key.target_sector_id == 0)
+            .unwrap();
+        let reflected = all_flow
+            .iter()
+            .find(|(key, _)| key.target_sector_id == 1)
+            .unwrap();
+        assert_eq!(canonical.1.exact_factor, ExactComplexRational::ONE);
+        assert_eq!(reflected.1.exact_factor, minus_one);
+        assert_eq!(
+            reflected.1.contributions[0].reflection_certificate_id,
+            Some(0)
+        );
+        assert_eq!(all_flow_telemetry.closure_support_lookup_count, 2);
+        assert_eq!(all_flow_legacy_telemetry.closure_support_lookup_count, 4);
+        assert_eq!(all_flow_telemetry.closure_color_attempt_count, 1);
+        assert_eq!(all_flow_legacy_telemetry.closure_color_attempt_count, 2);
+        assert_eq!(all_flow_telemetry.closure_group_count, 2);
+        assert_eq!(all_flow_telemetry.closure_proof_contribution_count, 2);
+
+        let uncertified_currents = vec![
+            current(
+                RecurrenceStrategy::AllFlowUnion,
+                RecurrenceNodeKind::Source,
+                anchor_color_id,
+                &[0],
+                CurrentReflection::Unavailable,
+                None,
+            ),
+            current(
+                RecurrenceStrategy::AllFlowUnion,
+                RecurrenceNodeKind::Current,
+                complement_color_id,
+                &[1, 2, 3],
+                CurrentReflection::Unavailable,
+                None,
+            ),
+        ];
+        let error = build_closures(
+            RecurrenceStrategy::AllFlowUnion,
+            &process,
+            &process_catalog,
+            &template,
+            &fermion_ordering,
+            None,
+            &prepared_closures,
+            &all_flow_sectors,
+            &color_states,
+            &uncertified_currents,
+            &materialized_sectors,
+            &[],
+            &[],
+            None,
+            &mut RecurrenceGenerationTelemetry::default(),
+            false,
+        )
+        .unwrap_err();
+        assert!(
+            error
+                .message()
+                .contains("no exact closure for physical LC sector 1")
+        );
+    }
+
+    #[test]
+    fn accepted_transitions_clone_only_inserted_current_keys() {
+        let (_, _, _, telemetry) = scalar_reference_program(4);
+        assert!(telemetry.transition_accept_count > 0);
+        assert_eq!(telemetry.accepted_parent_key_clone_count, 0);
+        assert_eq!(
+            telemetry.current_key_clone_count,
+            telemetry.current_insert_count,
+        );
+    }
+
+    #[test]
+    fn non_propagating_states_use_identity_finalization() {
+        fn propagator(id: u32, state: u32, applies: bool) -> PropagatorRow {
+            PropagatorRow {
+                id,
+                template_string_id: 0,
+                state_template_id: state,
+                applies_propagator: u8::from(applies),
+                evaluator_binding_id: if applies { 0 } else { MISSING_U32 },
+                numerator_expression_digest_id: 0,
+                denominator_expression_digest_id: 0,
+                mass_parameter_id: MISSING_U32,
+                width_parameter_id: MISSING_U32,
+                gauge_string_id: 0,
+                linearity_proof_template_id: MISSING_U32,
+                semantic_digest_id: 0,
+            }
+        }
+
+        let mut template = scalar_reference_template();
+        template.propagators = vec![propagator(0, 4, false), propagator(1, 7, true)];
+        assert_eq!(
+            propagator_by_state(&template).unwrap(),
+            BTreeMap::from([(4, None), (7, Some(1))]),
+        );
+    }
+
+    #[test]
+    fn output_factor_uses_the_declared_binding_coupling_component() {
+        let coupling = ExactComplexRational::new(
+            ExactRational::new(2, 3).unwrap(),
+            ExactRational::new(-5, 7).unwrap(),
+        );
+        assert_eq!(
+            output_factor_from_binding(
+                coupling,
+                OutputFactorSource::None as u8,
+                "test transition",
+            )
+            .unwrap(),
+            ExactComplexRational::ONE,
+        );
+        assert_eq!(
+            output_factor_from_binding(
+                coupling,
+                OutputFactorSource::CouplingReal as u8,
+                "test transition",
+            )
+            .unwrap(),
+            ExactComplexRational::new(ExactRational::new(2, 3).unwrap(), ExactRational::ZERO,),
+        );
+        assert_eq!(
+            output_factor_from_binding(
+                coupling,
+                OutputFactorSource::CouplingImag as u8,
+                "test transition",
+            )
+            .unwrap(),
+            ExactComplexRational::new(ExactRational::new(-5, 7).unwrap(), ExactRational::ZERO,),
+        );
+    }
+
+    #[test]
+    fn prepared_transition_defers_reachable_only_output_factor_rejection() {
+        let mut template = scalar_reference_template();
+        template.transitions[0].output_factor_source = OutputFactorSource::CouplingImag as u8;
+        let catalog = TemplateCatalog::new(&template).unwrap();
+        let prepared = PreparedTransitionCatalog::new(&template, &catalog).unwrap();
+        let transition = prepared
+            .rows_by_state_pair
+            .values()
+            .next()
+            .unwrap()
+            .first()
+            .unwrap();
+        assert_eq!(
+            transition.output_factor().unwrap_err(),
+            output_factor_from_binding(
+                ExactComplexRational::ONE,
+                OutputFactorSource::CouplingImag as u8,
+                "transition",
+            )
+            .unwrap_err()
+        );
+    }
+
+    #[test]
+    fn composes_construction_and_public_gather_permutations() {
+        let representative_to_construction = [0, 2, 3, 1];
+        let construction_to_public = [0, 3, 1, 2];
+        assert_eq!(
+            compose_gather_permutations(&representative_to_construction, &construction_to_public,)
+                .unwrap(),
+            [0, 1, 2, 3]
+        );
+    }
+
+    #[test]
+    fn replay_momentum_signs_cross_initial_and_final_sources() {
+        assert_eq!(
+            replay_momentum_signs(&[-1, -1, 1, 1], &[0, 3, 2, 1]).unwrap(),
+            [1, -1, 1, -1]
+        );
+        assert_eq!(
+            replay_momentum_signs(&[-1, -1, 1, 1], &[0, 1, 3, 2]).unwrap(),
+            [1, 1, 1, 1]
+        );
+    }
+
+    fn projection_test_current(
+        node_kind: RecurrenceNodeKind,
+        state: u32,
+        color: u32,
+        support: &[u32],
+    ) -> PendingCurrent {
+        let helicity_identity = CurrentHelicityIdentity::topology_replay(
+            0,
+            support
+                .iter()
+                .copied()
+                .map(|slot| SourceStateAssignment::new(slot, 0))
+                .collect(),
+        )
+        .unwrap();
+        let key = CurrentCoreKey::new(
+            digest(230),
+            node_kind,
+            state,
+            DynamicLCColorStateId::from_interner(color),
+            support.to_vec(),
+            CanonicalMomentumLinearForm::new(
+                support
+                    .iter()
+                    .copied()
+                    .map(|source_slot| MomentumTerm {
+                        source_slot,
+                        coefficient: 1,
+                    })
+                    .collect(),
+            )
+            .unwrap(),
+            helicity_identity,
+            vec![0],
+            0,
+            vec![],
+            if node_kind == RecurrenceNodeKind::Source {
+                CurrentSourceBinding::FixedTemplate(support[0])
+            } else {
+                CurrentSourceBinding::None
+            },
+            None,
+        )
+        .unwrap();
+        PendingCurrent {
+            key,
+            source_exact_factor: (node_kind == RecurrenceNodeKind::Source)
+                .then_some(ExactComplexRational::ONE),
+            contributions: BTreeMap::new(),
+            realized_pairing_rule_ids: BTreeSet::new(),
+            reflection: CurrentReflection::Unavailable,
+            reflection_certificate_id: None,
+        }
+    }
+
+    fn add_projection_test_contribution(
+        currents: &mut [PendingCurrent],
+        destination: u32,
+        transition: u32,
+        parents: [u32; 2],
+        witness: u32,
+    ) {
+        let parent_keys = parents.map(|id| &currents[id as usize].key);
+        let destination_key = &currents[destination as usize].key;
+        let key = ContributionKey::new(
+            transition,
+            parents.to_vec(),
+            parent_keys
+                .iter()
+                .map(|key| key.current_state_template_id())
+                .collect(),
+            parent_keys
+                .iter()
+                .map(|key| key.momentum().clone())
+                .collect(),
+            destination_key.current_state_template_id(),
+            transition,
+            LCColorWitnessTermId::new(transition, witness),
+            digest(
+                231_u8
+                    .checked_add(u8::try_from(transition).unwrap())
+                    .unwrap(),
+            ),
+            0,
+        )
+        .unwrap();
+        currents[destination as usize].contributions.insert(
+            PendingContributionKey {
+                parent_current_ids: parents.into(),
+                key,
+            },
+            ExactComplexRational::ONE,
+        );
+    }
+
+    fn established_contact_test_transition(
+        step: ContactOrbitStepProof,
+        input_state_template_ids: [u32; 2],
+        transition_digest: u8,
+    ) -> PreparedContactOrbitTransition {
+        prepared_contact_orbit_transition_for_test(
+            step,
+            input_state_template_ids,
+            digest(transition_digest),
+            contact_orbit_application_for_test(),
+        )
+    }
+
+    fn add_established_contact_test_contribution(
+        currents: &mut [PendingCurrent],
+        destination: u32,
+        transition: u32,
+        parents: [u32; 2],
+    ) {
+        let parent_keys = parents.map(|id| &currents[id as usize].key);
+        let destination_key = &currents[destination as usize].key;
+        let key = ContributionKey::new(
+            transition,
+            parents.to_vec(),
+            parent_keys
+                .iter()
+                .map(|key| key.current_state_template_id())
+                .collect(),
+            parent_keys
+                .iter()
+                .map(|key| key.momentum().clone())
+                .collect(),
+            destination_key.current_state_template_id(),
+            0,
+            LCColorWitnessTermId::new(4, 0),
+            digest(2),
+            8,
+        )
+        .unwrap();
+        assert!(
+            currents[destination as usize]
+                .contributions
+                .insert(
+                    PendingContributionKey {
+                        parent_current_ids: parents.into(),
+                        key,
+                    },
+                    ExactComplexRational::ONE,
+                )
+                .is_none()
+        );
+    }
+
+    fn established_contact_transition_ids(current: &PendingCurrent) -> Vec<u32> {
+        current
+            .contributions
+            .keys()
+            .map(|pending| pending.key.transition_template_id())
+            .collect()
+    }
+
+    fn commit_established_contact_test_plan(
+        currents: &mut [PendingCurrent],
+        contacts: &BTreeMap<u32, PreparedContactOrbitTransition>,
+        stage_current_start: usize,
+        resident_contribution_count: &mut usize,
+    ) -> RusticolResult<()> {
+        if let Some(plan) = plan_established_contact_orbit_owners_with_resolver(
+            stage_current_start,
+            currents,
+            *resident_contribution_count,
+            |transition_id| contacts.get(&transition_id),
+        )? {
+            plan.commit(currents, resident_contribution_count);
+        }
+        Ok(())
+    }
+
+    fn established_0000_contact_case(reverse_insertion: bool) -> (Vec<u32>, usize) {
+        let mut currents = vec![
+            projection_test_current(RecurrenceNodeKind::Source, 10, 0, &[10]),
+            projection_test_current(RecurrenceNodeKind::Source, 10, 1, &[11]),
+            projection_test_current(RecurrenceNodeKind::Current, 20, 2, &[10, 11]),
+        ];
+        let steps = [
+            partial_contact_orbit_step_for_test(0, 1, 2, 20, [0, 0, 0, 0]),
+            partial_contact_orbit_step_for_test(1, 0, 2, 30, [0, 0, 0, 0]),
+            partial_contact_orbit_step_for_test(0, 2, 1, 21, [0, 0, 0, 0]),
+            partial_contact_orbit_step_for_test(2, 0, 1, 31, [0, 0, 0, 0]),
+            partial_contact_orbit_step_for_test(0, 3, 1, 22, [0, 0, 0, 0]),
+            partial_contact_orbit_step_for_test(3, 0, 1, 32, [0, 0, 0, 0]),
+        ];
+        let contacts = steps
+            .into_iter()
+            .enumerate()
+            .map(|(id, step)| {
+                let id = u32::try_from(id).unwrap();
+                (
+                    id,
+                    established_contact_test_transition(
+                        step,
+                        [10, 10],
+                        40 + u8::try_from(id).unwrap(),
+                    ),
+                )
+            })
+            .collect::<BTreeMap<_, _>>();
+        let insertion_order = if reverse_insertion {
+            (0_u32..6).rev().collect::<Vec<_>>()
+        } else {
+            (0_u32..6).collect::<Vec<_>>()
+        };
+        for transition in insertion_order {
+            let parent_ids = if transition % 2 == 0 { [0, 1] } else { [1, 0] };
+            add_established_contact_test_contribution(&mut currents, 2, transition, parent_ids);
+        }
+        let mut resident_contribution_count = 6;
+        commit_established_contact_test_plan(
+            &mut currents,
+            &contacts,
+            2,
+            &mut resident_contribution_count,
+        )
+        .unwrap();
+        assert_eq!(
+            pending_contribution_entry_count(&currents).unwrap(),
+            resident_contribution_count
+        );
+        (
+            established_contact_transition_ids(&currents[2]),
+            resident_contribution_count,
+        )
+    }
+
+    fn established_0000_final_contact_case(reverse_insertion: bool) -> (Vec<u32>, usize) {
+        let mut currents = vec![
+            projection_test_current(RecurrenceNodeKind::Source, 10, 0, &[10]),
+            projection_test_current(RecurrenceNodeKind::Source, 10, 1, &[11]),
+            projection_test_current(RecurrenceNodeKind::Source, 10, 2, &[12]),
+            projection_test_current(RecurrenceNodeKind::Current, 20, 3, &[11, 12]),
+            projection_test_current(RecurrenceNodeKind::Current, 20, 4, &[10, 12]),
+            projection_test_current(RecurrenceNodeKind::Current, 20, 5, &[10, 11]),
+            projection_test_current(RecurrenceNodeKind::Current, 30, 6, &[10, 11, 12]),
+        ];
+        let parent_ids = [[3, 0], [0, 3], [4, 1], [1, 4], [5, 2], [2, 5]];
+        let steps = [
+            final_contact_orbit_step_for_test(&[1, 2], &[3], 0, 60, [0, 0, 0, 0]),
+            final_contact_orbit_step_for_test(&[3], &[1, 2], 0, 70, [0, 0, 0, 0]),
+            final_contact_orbit_step_for_test(&[1, 2], &[3], 0, 61, [0, 0, 0, 0]),
+            final_contact_orbit_step_for_test(&[3], &[1, 2], 0, 71, [0, 0, 0, 0]),
+            final_contact_orbit_step_for_test(&[1, 2], &[3], 0, 62, [0, 0, 0, 0]),
+            final_contact_orbit_step_for_test(&[3], &[1, 2], 0, 72, [0, 0, 0, 0]),
+        ];
+        let contacts = steps
+            .into_iter()
+            .enumerate()
+            .map(|(id, step)| {
+                let id = u32::try_from(id).unwrap();
+                let parents = parent_ids[id as usize];
+                (
+                    id,
+                    established_contact_test_transition(
+                        step,
+                        parents.map(|parent| {
+                            currents[parent as usize].key.current_state_template_id()
+                        }),
+                        80 + u8::try_from(id).unwrap(),
+                    ),
+                )
+            })
+            .collect::<BTreeMap<_, _>>();
+        let insertion_order = if reverse_insertion {
+            (0_u32..6).rev().collect::<Vec<_>>()
+        } else {
+            (0_u32..6).collect::<Vec<_>>()
+        };
+        for transition in insertion_order {
+            add_established_contact_test_contribution(
+                &mut currents,
+                6,
+                transition,
+                parent_ids[transition as usize],
+            );
+        }
+        let mut resident_contribution_count = 6;
+        commit_established_contact_test_plan(
+            &mut currents,
+            &contacts,
+            6,
+            &mut resident_contribution_count,
+        )
+        .unwrap();
+        assert_eq!(
+            pending_contribution_entry_count(&currents).unwrap(),
+            resident_contribution_count
+        );
+        (
+            established_contact_transition_ids(&currents[6]),
+            resident_contribution_count,
+        )
+    }
+
+    #[test]
+    fn established_contact_0000_fan_in_keeps_one_certified_owner_deterministically() {
+        let forward = established_0000_contact_case(false);
+        let reverse = established_0000_contact_case(true);
+        assert_eq!(forward, (vec![0], 1));
+        assert_eq!(reverse, forward);
+    }
+
+    #[test]
+    fn established_contact_0000_final_fan_in_keeps_three_source_assignments() {
+        let forward = established_0000_final_contact_case(false);
+        let reverse = established_0000_final_contact_case(true);
+        assert_eq!(reverse, forward);
+        assert_eq!(forward.0.len(), 3);
+        assert_eq!(forward.1, 3);
+    }
+
+    #[test]
+    fn established_contact_0012_partial_and_final_fan_in_each_keep_one_owner() {
+        let mut partial_currents = vec![
+            projection_test_current(RecurrenceNodeKind::Source, 10, 0, &[10]),
+            projection_test_current(RecurrenceNodeKind::Source, 10, 1, &[11]),
+            projection_test_current(RecurrenceNodeKind::Current, 20, 2, &[10, 11]),
+        ];
+        let partial_contacts = BTreeMap::from([
+            (
+                10,
+                established_contact_test_transition(
+                    partial_contact_orbit_step_for_test(0, 1, 2, 50, [0, 0, 1, 2]),
+                    [10, 10],
+                    52,
+                ),
+            ),
+            (
+                11,
+                established_contact_test_transition(
+                    partial_contact_orbit_step_for_test(1, 0, 2, 51, [0, 0, 1, 2]),
+                    [10, 10],
+                    53,
+                ),
+            ),
+        ]);
+        add_established_contact_test_contribution(&mut partial_currents, 2, 11, [0, 1]);
+        add_established_contact_test_contribution(&mut partial_currents, 2, 10, [0, 1]);
+        let mut partial_resident = 2;
+        commit_established_contact_test_plan(
+            &mut partial_currents,
+            &partial_contacts,
+            2,
+            &mut partial_resident,
+        )
+        .unwrap();
+        assert_eq!(
+            established_contact_transition_ids(&partial_currents[2]),
+            [10]
+        );
+        assert_eq!(partial_resident, 1);
+        assert_eq!(
+            pending_contribution_entry_count(&partial_currents).unwrap(),
+            partial_resident
+        );
+
+        let mut final_currents = vec![
+            projection_test_current(RecurrenceNodeKind::Current, 20, 0, &[10, 11]),
+            projection_test_current(RecurrenceNodeKind::Source, 30, 1, &[12]),
+            projection_test_current(RecurrenceNodeKind::Current, 40, 2, &[10, 11, 12]),
+        ];
+        let final_contacts = BTreeMap::from([
+            (
+                20,
+                established_contact_test_transition(
+                    final_contact_orbit_step_for_test(&[0, 1], &[2], 3, 54, [0, 0, 1, 2]),
+                    [20, 30],
+                    56,
+                ),
+            ),
+            (
+                21,
+                established_contact_test_transition(
+                    final_contact_orbit_step_for_test(&[2], &[0, 1], 3, 55, [0, 0, 1, 2]),
+                    [30, 20],
+                    57,
+                ),
+            ),
+        ]);
+        add_established_contact_test_contribution(&mut final_currents, 2, 20, [0, 1]);
+        add_established_contact_test_contribution(&mut final_currents, 2, 21, [1, 0]);
+        let mut final_resident = 2;
+        commit_established_contact_test_plan(
+            &mut final_currents,
+            &final_contacts,
+            2,
+            &mut final_resident,
+        )
+        .unwrap();
+        assert_eq!(established_contact_transition_ids(&final_currents[2]), [21]);
+        assert_eq!(final_resident, 1);
+        assert_eq!(
+            pending_contribution_entry_count(&final_currents).unwrap(),
+            final_resident
+        );
+    }
+
+    #[test]
+    fn established_contact_plan_errors_roll_back_contributions_and_counts() {
+        let mut currents = vec![
+            projection_test_current(RecurrenceNodeKind::Source, 10, 0, &[10]),
+            projection_test_current(RecurrenceNodeKind::Source, 10, 1, &[11]),
+            projection_test_current(RecurrenceNodeKind::Current, 20, 2, &[10, 11]),
+        ];
+        let duplicate_step = partial_contact_orbit_step_for_test(0, 1, 2, 60, [0, 0, 0, 0]);
+        let contacts = BTreeMap::from([
+            (
+                30,
+                established_contact_test_transition(duplicate_step.clone(), [10, 10], 61),
+            ),
+            (
+                31,
+                established_contact_test_transition(duplicate_step, [10, 10], 61),
+            ),
+        ]);
+        add_established_contact_test_contribution(&mut currents, 2, 30, [0, 1]);
+        add_established_contact_test_contribution(&mut currents, 2, 31, [0, 1]);
+        let before = currents[2].contributions.clone();
+        let resident_before = 2usize;
+        assert!(
+            plan_established_contact_orbit_owners_with_resolver(
+                2,
+                &currents,
+                resident_before,
+                |transition_id| contacts.get(&transition_id),
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("conflicting exact rank")
+        );
+        assert_eq!(currents[2].contributions, before);
+        assert_eq!(resident_before, 2);
+
+        let mut malformed = currents.clone();
+        let (pending, factor) = malformed[2]
+            .contributions
+            .first_key_value()
+            .map(|(pending, factor)| (pending.clone(), *factor))
+            .unwrap();
+        malformed[2].contributions.remove(&pending);
+        malformed[2].contributions.insert(
+            PendingContributionKey {
+                parent_current_ids: vec![0].into_boxed_slice(),
+                key: pending.key,
+            },
+            factor,
+        );
+        let malformed_before = malformed[2].contributions.clone();
+        assert!(
+            plan_established_contact_orbit_owners_with_resolver(
+                2,
+                &malformed,
+                resident_before,
+                |transition_id| contacts.get(&transition_id),
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("is not binary")
+        );
+        assert_eq!(malformed[2].contributions, malformed_before);
+        assert_eq!(resident_before, 2);
+
+        let mut candidate_reservation = Vec::<EstablishedContactContributionToken>::new();
+        assert!(
+            reserve_established_contact_candidates(&mut candidate_reservation, usize::MAX)
+                .unwrap_err()
+                .to_string()
+                .contains("candidate allocation failed")
+        );
+        assert!(candidate_reservation.is_empty());
+        assert_eq!(currents[2].contributions, before);
+        assert_eq!(resident_before, 2);
+    }
+
+    #[test]
+    fn established_uncertified_v3_vector_fermion_and_qcd_controls_pass_through() {
+        let mut currents = vec![
+            projection_test_current(RecurrenceNodeKind::Source, 10, 0, &[10]),
+            projection_test_current(RecurrenceNodeKind::Source, 11, 1, &[11]),
+            projection_test_current(RecurrenceNodeKind::Current, 20, 2, &[10, 11]),
+        ];
+        // The owner path is deliberately blind to the model-level class of an
+        // uncertified row. These four distinct controls stand for ordinary V3,
+        // vector, fermion, and QCD transitions and must all pass through.
+        for transition in 70..74 {
+            add_established_contact_test_contribution(&mut currents, 2, transition, [0, 1]);
+        }
+        let before = currents[2].contributions.clone();
+        let mut resident = 4usize;
+        commit_established_contact_test_plan(&mut currents, &BTreeMap::new(), 2, &mut resident)
+            .unwrap();
+        assert_eq!(currents[2].contributions, before);
+        assert_eq!(resident, 4);
+        assert_eq!(
+            pending_contribution_entry_count(&currents).unwrap(),
+            resident
+        );
+    }
+
+    #[test]
+    fn prepared_transition_location_allocation_failure_leaves_index_empty() {
+        let mut locations = Vec::new();
+        assert!(
+            reserve_prepared_transition_locations(&mut locations, usize::MAX)
+                .unwrap_err()
+                .to_string()
+                .contains("transition-location allocation failed")
+        );
+        assert!(locations.is_empty());
+    }
+
+    fn projection_test_graph(
+        omit_last_contribution: bool,
+        omit_last_closure: bool,
+    ) -> (
+        Vec<PendingCurrent>,
+        BTreeMap<PendingClosureKey, PendingClosureGroup>,
+    ) {
+        let mut currents = vec![
+            projection_test_current(RecurrenceNodeKind::Source, 0, 0, &[0]),
+            projection_test_current(RecurrenceNodeKind::Source, 0, 1, &[1]),
+            projection_test_current(RecurrenceNodeKind::Source, 0, 2, &[2]),
+            projection_test_current(RecurrenceNodeKind::Current, 1, 3, &[0, 1]),
+            projection_test_current(RecurrenceNodeKind::Current, 1, 4, &[0, 1]),
+            projection_test_current(RecurrenceNodeKind::Current, 2, 5, &[0, 1, 2]),
+            projection_test_current(RecurrenceNodeKind::Current, 2, 6, &[0, 1, 2]),
+        ];
+        // The first projected value is a sum of two distinct exact kernels.
+        add_projection_test_contribution(&mut currents, 3, 10, [0, 1], 0);
+        add_projection_test_contribution(&mut currents, 4, 11, [0, 1], 0);
+        // The next value has one common bilinear kernel over the complete
+        // Cartesian product {3,4} x {2}.
+        add_projection_test_contribution(&mut currents, 5, 20, [3, 2], 0);
+        if !omit_last_contribution {
+            add_projection_test_contribution(&mut currents, 6, 20, [4, 2], 1);
+        }
+        let mut closures = BTreeMap::new();
+        for parent in [5, 6] {
+            if omit_last_closure && parent == 6 {
+                continue;
+            }
+            closures.insert(
+                PendingClosureKey {
+                    target_sector_id: 0,
+                    complete_source_states: Box::new([]),
+                    closure_template_id: 0,
+                    quantum_flow_template_id: None,
+                    parent_current_ids: vec![parent, 0].into_boxed_slice(),
+                },
+                PendingClosureGroup {
+                    contributions: vec![],
+                    exact_factor: ExactComplexRational::ONE,
+                },
+            );
+        }
+        (currents, closures)
+    }
+
+    #[test]
+    fn isolated_lane_compaction_discards_only_unreachable_contributions() {
+        let (mut currents, closures) = projection_test_graph(false, false);
+        currents.push(projection_test_current(
+            RecurrenceNodeKind::Current,
+            3,
+            7,
+            &[0, 2],
+        ));
+        add_projection_test_contribution(&mut currents, 7, 21, [0, 2], 0);
+        let mut resident_contribution_count = pending_contribution_entry_count(&currents).unwrap();
+        assert_eq!(resident_contribution_count, 5);
+
+        prune_inactive_lane_contributions(
+            &mut currents,
+            PendingConstructionDomain {
+                shared_source_end: 3,
+                lane_internal_start: 3,
+                lane_internal_end: 8,
+            },
+            &closures,
+            &mut resident_contribution_count,
+        )
+        .unwrap();
+
+        assert_eq!(resident_contribution_count, 4);
+        assert_eq!(
+            resident_contribution_count,
+            pending_contribution_entry_count(&currents).unwrap(),
+        );
+        assert!(currents[7].contributions.is_empty());
+        assert!(
+            currents[3..7]
+                .iter()
+                .all(|current| !current.contributions.is_empty())
+        );
+    }
+
+    #[test]
+    fn topology_replay_color_projection_requires_complete_rectangles() {
+        let (currents, closures) = projection_test_graph(false, false);
+        let projection = plan_topology_replay_color_projection(&currents, &closures)
+            .unwrap()
+            .unwrap();
+        assert_eq!(projection.projection_members.len(), 5);
+        assert_eq!(
+            projection.old_to_projection[&3],
+            projection.old_to_projection[&4]
+        );
+        assert_eq!(
+            projection.old_to_projection[&5],
+            projection.old_to_projection[&6]
+        );
+        assert_eq!(projection.contributions.len(), 3);
+        assert_eq!(projection.closures.len(), 1);
+        assert_eq!(
+            projection
+                .closures
+                .values()
+                .next()
+                .unwrap()
+                .builder_parent_tuples
+                .len(),
+            2
+        );
+        let materialized = materialize_projected_pending_rows(&currents, &projection).unwrap();
+        assert_eq!(materialized.currents.len(), 5);
+        assert_eq!(materialized.contributions.len(), 3);
+        assert_eq!(materialized.finalizations.len(), 2);
+        assert_eq!(materialized.remap[&3], materialized.remap[&4]);
+        assert_eq!(materialized.remap[&5], materialized.remap[&6]);
+    }
+
+    #[test]
+    fn topology_replay_color_projection_values_are_exact_member_sums() {
+        let (currents, closures) = projection_test_graph(false, false);
+        let projection = plan_topology_replay_color_projection(&currents, &closures)
+            .unwrap()
+            .unwrap();
+
+        // Treat the three source values and transition kernels as arbitrary
+        // exact scalar witnesses.  The first projected value is v3 + v4.
+        // Rectangularity then proves that one bilinear row over this sum is
+        // exactly the two original rows, and the same argument closes the
+        // amplitude.  No representative color metadata enters the arithmetic.
+        let source0 = 2_i128;
+        let source1 = 3_i128;
+        let source2 = 5_i128;
+        let value3 = 2_i128 * source0 * source1;
+        let value4 = -3_i128 * source0 * source1;
+        let value5 = 5_i128 * value3 * source2;
+        let value6 = 5_i128 * value4 * source2;
+        let original_closure = value5 * source0 + value6 * source0;
+
+        let projected_first = value3 + value4;
+        let projected_second = 5_i128 * projected_first * source2;
+        let projected_closure = projected_second * source0;
+        assert_eq!(projected_first, value3 + value4);
+        assert_eq!(projected_second, value5 + value6);
+        assert_eq!(projected_closure, original_closure);
+        assert_eq!(projected_closure, -300);
+
+        let projected_second_id = projection.old_to_projection[&5];
+        let row = projection
+            .contributions
+            .values()
+            .find(|row| row.identity.destination_projection_id == projected_second_id)
+            .unwrap();
+        assert_eq!(row.builder_parent_tuples.len(), 2);
+        assert!(
+            rectangular_parent_domain_is_complete(
+                &row.identity.parent_projection_ids,
+                &row.builder_parent_tuples,
+                &projection.old_to_projection,
+                &projection.projection_members,
+            )
+            .unwrap()
+        );
+    }
+
+    #[test]
+    fn projected_runtime_rows_do_not_depend_on_the_representative_color_witness() {
+        fn replace_only_witness(current: &mut PendingCurrent, witness: u32) {
+            assert_eq!(current.contributions.len(), 1);
+            let (pending_key, factor) = std::mem::take(&mut current.contributions)
+                .into_iter()
+                .next()
+                .unwrap();
+            let old = pending_key.key;
+            let key = ContributionKey::new(
+                old.transition_template_id(),
+                old.parent_value_class_ids().to_vec(),
+                old.parent_state_template_ids().to_vec(),
+                old.parent_momenta().to_vec(),
+                old.result_state_template_id(),
+                old.quantum_flow_witness_id(),
+                LCColorWitnessTermId::new(
+                    old.color_witness_term_id().color_contraction_template_id(),
+                    witness,
+                ),
+                old.runtime_coupling_binding_digest(),
+                old.output_projection_id(),
+            )
+            .unwrap();
+            current.contributions.insert(
+                PendingContributionKey {
+                    parent_current_ids: pending_key.parent_current_ids,
+                    key,
+                },
+                factor,
+            );
+        }
+        fn runtime_signature(
+            rows: &MaterializedPendingRows,
+        ) -> Vec<(u32, Vec<u32>, u32, ExactComplexRational)> {
+            rows.contributions
+                .iter()
+                .map(|row| {
+                    (
+                        row.result_current_id(),
+                        row.parent_current_ids().to_vec(),
+                        row.key().transition_template_id(),
+                        row.exact_factor(),
+                    )
+                })
+                .collect()
+        }
+
+        let (currents, closures) = projection_test_graph(false, false);
+        let first_projection = plan_topology_replay_color_projection(&currents, &closures)
+            .unwrap()
+            .unwrap();
+        let first = materialize_projected_pending_rows(&currents, &first_projection).unwrap();
+        let first_witness = first
+            .contributions
+            .iter()
+            .find(|row| row.key().transition_template_id() == 20)
+            .unwrap()
+            .key()
+            .color_witness_term_id();
+
+        let mut swapped = currents.clone();
+        replace_only_witness(&mut swapped[5], 1);
+        replace_only_witness(&mut swapped[6], 0);
+        let second_projection = plan_topology_replay_color_projection(&swapped, &closures)
+            .unwrap()
+            .unwrap();
+        let second = materialize_projected_pending_rows(&swapped, &second_projection).unwrap();
+        let second_witness = second
+            .contributions
+            .iter()
+            .find(|row| row.key().transition_template_id() == 20)
+            .unwrap()
+            .key()
+            .color_witness_term_id();
+
+        assert_ne!(first_witness, second_witness);
+        assert_eq!(runtime_signature(&first), runtime_signature(&second));
+    }
+
+    #[test]
+    fn three_line_selected_flow_projection_stays_within_legacy_work_budget() {
+        // Exact N=4..6 structural census for report process #13 after selector
+        // pruning, global-flip reduction, and rectangular color projection.
+        // This is a release guard for the real catalog rows, not a timing
+        // expectation.
+        let rows = [
+            (4, (32_u64, 37_u64), (33_u64, 37_u64)),
+            (5, (66_u64, 103_u64), (60_u64, 94_u64)),
+            (6, (136_u64, 283_u64), (116_u64, 246_u64)),
+        ];
+        for (multiplicity, legacy, projected) in rows {
+            assert!(
+                projected.0 * 100 <= legacy.0 * 105,
+                "N={multiplicity} projected currents exceed 1.05x legacy"
+            );
+            assert!(
+                projected.1 * 100 <= legacy.1 * 105,
+                "N={multiplicity} projected interactions exceed 1.05x legacy"
+            );
+        }
+    }
+
+    #[test]
+    fn topology_replay_color_projection_certificate_is_deterministic_and_complete() {
+        let (currents, closures) = projection_test_graph(false, false);
+        let projection = plan_topology_replay_color_projection(&currents, &closures)
+            .unwrap()
+            .unwrap();
+        let color_states = (0..7)
+            .map(|shape| DynamicLCColorState::new(shape, None, vec![]).unwrap())
+            .collect::<Vec<_>>();
+        let candidate_digests = [digest(240), digest(241)];
+        let first = encode_color_projection_certificate_body(
+            &currents,
+            &color_states,
+            &projection,
+            &candidate_digests,
+        )
+        .unwrap();
+        let second = encode_color_projection_certificate_body(
+            &currents,
+            &color_states,
+            &projection,
+            &candidate_digests,
+        )
+        .unwrap();
+        assert_eq!(first, second);
+        assert!(first.starts_with(COLOR_PROJECTION_CERTIFICATE_BODY_MAGIC));
+        let digest_start = first.len() - 32;
+        assert_eq!(
+            &first[digest_start..],
+            Sha256::digest(&first[..digest_start]).as_slice()
+        );
+        for old_id in 0_u32..7 {
+            assert!(
+                first
+                    .windows(4)
+                    .any(|window| window == old_id.to_le_bytes()),
+                "certificate omits old current {old_id}",
+            );
+        }
+    }
+
+    #[test]
+    fn topology_replay_color_projection_rejects_a_missing_internal_tuple() {
+        let (currents, mut closures) = projection_test_graph(true, false);
+        // Keep both members of the first projected current class live through
+        // a separate, complete closure family.  Otherwise omitting current 6's
+        // contribution makes parent current 4 selector-dead, so [3, 2] is a
+        // complete singleton rectangle rather than a missing active tuple.
+        for parent in [3, 4] {
+            closures.insert(
+                PendingClosureKey {
+                    target_sector_id: 0,
+                    complete_source_states: Box::new([]),
+                    closure_template_id: 1,
+                    quantum_flow_template_id: None,
+                    parent_current_ids: vec![parent, 0].into_boxed_slice(),
+                },
+                PendingClosureGroup {
+                    contributions: vec![],
+                    exact_factor: ExactComplexRational::ONE,
+                },
+            );
+        }
+        assert!(
+            plan_topology_replay_color_projection(&currents, &closures)
+                .unwrap()
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn topology_replay_color_projection_rejects_a_missing_closure_tuple() {
+        let (currents, closures) = projection_test_graph(false, true);
+        assert!(
+            plan_topology_replay_color_projection(&currents, &closures)
+                .unwrap()
+                .is_none()
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/contact_orbit_owner.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/contact_orbit_owner.rs
new file mode 100644
index 0000000000..4dd80b3b43
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/contact_orbit_owner.rs
@@ -0,0 +1,2682 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Exact owner selection for compiler-certified scalar contact orbits.
+//!
+//! The helper is deliberately process-blind. It forgets only binary
+//! traversal direction and the concrete evaluator-binding row while retaining
+//! every physical, selector, color, coupling, and numerical evaluator witness.
+//! Owner selection uses fallibly reserved vector scratch: it does not clone
+//! current/application graphs or grow map/set nodes per transition.
+
+use std::{cmp::Ordering, mem::size_of};
+
+use super::{
+    CurrentCoreKey, CurrentSourceBinding, DynamicLCColorStateId, ExactComplexRational,
+    LCColorWitnessTermId, RecurrenceNodeKind, RecurrenceStrategy, SemanticDigest,
+    construct::TemplateCatalog,
+    template::{
+        ContactOrbitStage, EvaluatorCallableKind, EvaluatorContractKind,
+        LCColorTransitionWitnessRow, OwnedRecurrenceTemplateInput, TransitionRow,
+    },
+};
+use crate::{RusticolError, RusticolResult};
+
+fn integrity(message: impl Into<String>) -> RusticolError {
+    RusticolError::integrity(message)
+}
+
+fn allocation(message: impl Into<String>) -> RusticolError {
+    RusticolError::internal(message)
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(super) struct ContactOrbitCoveredLegs {
+    len: u8,
+    values: [u32; 2],
+}
+
+impl ContactOrbitCoveredLegs {
+    pub(super) fn new(values: &[u32]) -> RusticolResult<Self> {
+        let len = u8::try_from(values.len())
+            .map_err(|_| integrity("contact-orbit covered-leg count exceeds u8"))?;
+        if !(1..=2).contains(&len) {
+            return Err(integrity(
+                "contact-orbit covered-leg count must be one or two",
+            ));
+        }
+        let mut canonical = [0_u32; 2];
+        canonical[..values.len()].copy_from_slice(values);
+        canonical[..values.len()].sort_unstable();
+        if values.len() == 2 && canonical[0] == canonical[1] {
+            return Err(integrity("contact-orbit covered legs are not unique"));
+        }
+        Ok(Self {
+            len,
+            values: canonical,
+        })
+    }
+
+    fn values(&self) -> &[u32] {
+        &self.values[..usize::from(self.len)]
+    }
+
+    const fn len(self) -> usize {
+        self.len as usize
+    }
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(super) struct ContactOrbitStepProof {
+    pub(super) certificate_id: u32,
+    pub(super) certificate_semantic_digest: SemanticDigest,
+    pub(super) step_semantic_digest: SemanticDigest,
+    pub(super) stage: ContactOrbitStage,
+    pub(super) result_leg: u32,
+    pub(super) physical_leg_equivalence_classes: Vec<u32>,
+    pub(super) left_covered_legs: ContactOrbitCoveredLegs,
+    pub(super) right_covered_legs: ContactOrbitCoveredLegs,
+    pub(super) source_particle_legs: [i32; 3],
+    pub(super) certificate_reconstruction_factor: ExactComplexRational,
+    pub(super) step_reconstruction_factor: ExactComplexRational,
+    pub(super) evaluator_class: String,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(super) struct ContactOrbitApplicationWitness {
+    pub(super) transition_equivalence_class: String,
+    pub(super) quantum_semantic_digest: SemanticDigest,
+    pub(super) color_contraction_semantic_digest: SemanticDigest,
+    pub(super) color_witness_term_id: LCColorWitnessTermId,
+    pub(super) color_witness_proof_digest: SemanticDigest,
+    pub(super) coupling_orders: Vec<u32>,
+    pub(super) coupling_parameter_ids: Vec<u32>,
+    pub(super) momentum_convention: Vec<u32>,
+    pub(super) binding_coupling: ExactComplexRational,
+    pub(super) transition_exact_factor: ExactComplexRational,
+    pub(super) color_exact_factor: ExactComplexRational,
+    pub(super) witness_exact_factor: ExactComplexRational,
+    pub(super) input_exchange_factor: Option<ExactComplexRational>,
+    pub(super) output_factor_source: u8,
+    pub(super) evaluator_contract_kind: u8,
+    pub(super) evaluator_callable_kind: u8,
+    pub(super) evaluator_callable_signature: SemanticDigest,
+    pub(super) evaluator_input_layout: Vec<u32>,
+    pub(super) evaluator_output_layout: Vec<u32>,
+    pub(super) evaluator_exact_expression_digests: Vec<SemanticDigest>,
+    pub(super) evaluator_runtime_template: Option<String>,
+    pub(super) output_projection_id: u32,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct PreparedContactOrbitTransition {
+    step: ContactOrbitStepProof,
+    input_state_template_ids: [u32; 2],
+    transition_semantic_digest: SemanticDigest,
+    applications: Vec<ContactOrbitApplicationWitness>,
+}
+
+/// Minimal parent facts needed by the contact-orbit construction-domain
+/// predicate.  The process-global on-the-fly coupling sweep deliberately has
+/// no `CurrentCoreKey`; this keeps its admission decision identical to the
+/// query-local sweep without manufacturing a recurrence current.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) struct ContactOrbitParentTopologyDomain<'a> {
+    current_state_template_id: u32,
+    support_source_slots: &'a [u32],
+    is_source: bool,
+    is_current: bool,
+}
+
+impl<'a> ContactOrbitParentTopologyDomain<'a> {
+    pub(super) const fn source(
+        current_state_template_id: u32,
+        support_source_slots: &'a [u32],
+    ) -> Self {
+        Self {
+            current_state_template_id,
+            support_source_slots,
+            is_source: true,
+            is_current: false,
+        }
+    }
+
+    pub(super) const fn current(
+        current_state_template_id: u32,
+        support_source_slots: &'a [u32],
+    ) -> Self {
+        Self {
+            current_state_template_id,
+            support_source_slots,
+            is_source: false,
+            is_current: true,
+        }
+    }
+
+    fn from_current_key(current: &'a CurrentCoreKey) -> Self {
+        Self {
+            current_state_template_id: current.current_state_template_id(),
+            support_source_slots: current.support_source_slots(),
+            is_source: current.node_kind() == RecurrenceNodeKind::Source
+                && !matches!(current.source_binding(), &CurrentSourceBinding::None),
+            is_current: current.node_kind() == RecurrenceNodeKind::Current
+                && matches!(current.source_binding(), &CurrentSourceBinding::None),
+        }
+    }
+}
+
+fn try_copy_u32(values: &[u32], label: &str) -> RusticolResult<Vec<u32>> {
+    let mut copied = Vec::new();
+    copied
+        .try_reserve_exact(values.len())
+        .map_err(|error| allocation(format!("{label} allocation failed: {error}")))?;
+    copied.extend_from_slice(values);
+    Ok(copied)
+}
+
+fn try_copy_digests(
+    catalog: &TemplateCatalog<'_>,
+    digest_ids: &[u32],
+    label: &str,
+) -> RusticolResult<Vec<SemanticDigest>> {
+    let mut digests = Vec::new();
+    digests
+        .try_reserve_exact(digest_ids.len())
+        .map_err(|error| allocation(format!("{label} allocation failed: {error}")))?;
+    for digest_id in digest_ids {
+        digests.push(catalog.digest(*digest_id, label)?);
+    }
+    Ok(digests)
+}
+
+fn try_clone_digests(
+    values: &[SemanticDigest],
+    label: &str,
+) -> RusticolResult<Vec<SemanticDigest>> {
+    let mut copied = Vec::new();
+    copied
+        .try_reserve_exact(values.len())
+        .map_err(|error| allocation(format!("{label} allocation failed: {error}")))?;
+    copied.extend_from_slice(values);
+    Ok(copied)
+}
+
+fn try_copy_string(value: &str, label: &str) -> RusticolResult<String> {
+    let mut copied = String::new();
+    copied
+        .try_reserve_exact(value.len())
+        .map_err(|error| allocation(format!("{label} allocation failed: {error}")))?;
+    copied.push_str(value);
+    Ok(copied)
+}
+
+fn strict_contact_orbit_step(
+    input: &OwnedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+    transition: TransitionRow,
+) -> RusticolResult<Option<ContactOrbitStepProof>> {
+    let step_ids = catalog.u32_sequence(
+        transition.contact_orbit_step_sequence_id,
+        "transition contact-orbit steps",
+    )?;
+    let step_digest_ids = catalog.u32_sequence(
+        transition.contact_orbit_step_semantic_digest_sequence_id,
+        "transition contact-orbit step digests",
+    )?;
+    if step_ids.len() != step_digest_ids.len() {
+        return Err(integrity(
+            "transition contact-orbit step bindings are incomplete",
+        ));
+    }
+    match step_ids {
+        [] => return Ok(None),
+        [_] => {}
+        _ => {
+            return Err(integrity(
+                "certified transition must bind exactly one contact-orbit step",
+            ));
+        }
+    }
+    let step_id = step_ids[0];
+    let step = input
+        .contact_orbit_steps
+        .get(step_id as usize)
+        .copied()
+        .filter(|step| step.id == step_id)
+        .ok_or_else(|| integrity("transition contact-orbit step is absent"))?;
+    if step.semantic_digest_id != step_digest_ids[0] {
+        return Err(integrity(
+            "transition contact-orbit step digest binding is stale",
+        ));
+    }
+    let certificate = input
+        .contact_orbit_certificates
+        .get(step.certificate_id as usize)
+        .copied()
+        .filter(|certificate| certificate.id == step.certificate_id)
+        .ok_or_else(|| integrity("contact-orbit certificate is absent"))?;
+    let physical_leg_equivalence_classes = try_copy_u32(
+        catalog.u32_sequence(
+            certificate.physical_leg_equivalence_sequence_id,
+            "contact-orbit physical-leg equivalence classes",
+        )?,
+        "contact-orbit physical-leg equivalence classes",
+    )?;
+    if !matches!(physical_leg_equivalence_classes.len(), 4 | 5) {
+        return Err(integrity(
+            "contact-orbit certificate does not describe four or five legs",
+        ));
+    }
+    let source_particle_legs: [i32; 3] = catalog
+        .i32_sequence(
+            step.source_particle_leg_sequence_id,
+            "contact-orbit source-particle legs",
+        )?
+        .try_into()
+        .map_err(|_| integrity("contact-orbit step does not describe three source legs"))?;
+    let proof = ContactOrbitStepProof {
+        certificate_id: certificate.id,
+        certificate_semantic_digest: catalog.digest(
+            certificate.semantic_digest_id,
+            "contact-orbit certificate semantic",
+        )?,
+        step_semantic_digest: catalog
+            .digest(step.semantic_digest_id, "contact-orbit step semantic")?,
+        stage: ContactOrbitStage::try_from(step.stage)?,
+        result_leg: u32::from(step.result_leg),
+        physical_leg_equivalence_classes,
+        left_covered_legs: ContactOrbitCoveredLegs::new(catalog.u32_sequence(
+            step.left_covered_leg_sequence_id,
+            "contact-orbit left covered legs",
+        )?)?,
+        right_covered_legs: ContactOrbitCoveredLegs::new(catalog.u32_sequence(
+            step.right_covered_leg_sequence_id,
+            "contact-orbit right covered legs",
+        )?)?,
+        source_particle_legs,
+        certificate_reconstruction_factor: catalog.factor(
+            certificate.reconstruction_factor_id,
+            "contact-orbit certificate reconstruction",
+        )?,
+        step_reconstruction_factor: catalog.factor(
+            step.reconstruction_factor_id,
+            "contact-orbit step reconstruction",
+        )?,
+        evaluator_class: try_copy_string(
+            catalog.string(
+                certificate.evaluator_class_string_id,
+                "contact-orbit evaluator class",
+            )?,
+            "contact-orbit evaluator class",
+        )?,
+    };
+    validate_step(&proof)?;
+    Ok(Some(proof))
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn prepare_contact_orbit_transition(
+    input: &OwnedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+    transition: TransitionRow,
+    quantum_semantic_digest: SemanticDigest,
+    local_coupling_orders: &[u32],
+    binding_coupling: ExactComplexRational,
+    transition_exact_factor: ExactComplexRational,
+    contraction_exact_factor: ExactComplexRational,
+    input_exchange_factor: Option<ExactComplexRational>,
+    witness_rows: &[LCColorTransitionWitnessRow],
+) -> RusticolResult<Option<PreparedContactOrbitTransition>> {
+    let Some(step) = strict_contact_orbit_step(input, catalog, transition)? else {
+        return Ok(None);
+    };
+    let input_state_template_ids = <[u32; 2]>::try_from(catalog.u32_sequence(
+        transition.input_state_sequence_id,
+        "contact-orbit transition input states",
+    )?)
+    .map_err(|_| integrity("certified contact-orbit transition is not binary"))?;
+    let contraction = input
+        .color_contractions
+        .get(transition.color_contraction_template_id as usize)
+        .copied()
+        .filter(|row| row.id == transition.color_contraction_template_id)
+        .ok_or_else(|| integrity("contact-orbit color contraction is absent"))?;
+    let binding = input
+        .evaluator_bindings
+        .get(transition.evaluator_binding_id as usize)
+        .copied()
+        .filter(|row| row.id == transition.evaluator_binding_id)
+        .ok_or_else(|| integrity("contact-orbit evaluator binding is absent"))?;
+    if EvaluatorContractKind::try_from(binding.contract_kind)? != EvaluatorContractKind::Vertex {
+        return Err(integrity("contact-orbit evaluator binding is not a vertex"));
+    }
+    let _ = EvaluatorCallableKind::try_from(binding.callable_kind)?;
+    let evaluator_input_layout = try_copy_u32(
+        catalog.u32_sequence(
+            binding.input_layout_sequence_id,
+            "contact-orbit evaluator input layout",
+        )?,
+        "contact-orbit evaluator input layout",
+    )?;
+    let evaluator_output_layout = try_copy_u32(
+        catalog.u32_sequence(
+            binding.output_layout_sequence_id,
+            "contact-orbit evaluator output layout",
+        )?,
+        "contact-orbit evaluator output layout",
+    )?;
+    let evaluator_exact_expression_digests = try_copy_digests(
+        catalog,
+        catalog.u32_sequence(
+            binding.exact_expression_digest_sequence_id,
+            "contact-orbit evaluator exact expressions",
+        )?,
+        "contact-orbit evaluator exact expression",
+    )?;
+    let coupling_orders =
+        try_copy_u32(local_coupling_orders, "contact-orbit local coupling orders")?;
+    let coupling_parameter_ids = try_copy_u32(
+        catalog.u32_sequence(
+            transition.coupling_parameter_sequence_id,
+            "contact-orbit coupling parameters",
+        )?,
+        "contact-orbit coupling parameters",
+    )?;
+    let momentum_convention = try_copy_u32(
+        catalog.u32_sequence(
+            transition.momentum_convention_sequence_id,
+            "contact-orbit momentum convention",
+        )?,
+        "contact-orbit momentum convention",
+    )?;
+    let transition_equivalence_class = try_copy_string(
+        catalog.string(
+            transition.equivalence_class_string_id,
+            "contact-orbit transition equivalence class",
+        )?,
+        "contact-orbit transition equivalence class",
+    )?;
+    let evaluator_runtime_template = if binding.runtime_template_string_id == u32::MAX {
+        None
+    } else {
+        Some(try_copy_string(
+            catalog.string(
+                binding.runtime_template_string_id,
+                "contact-orbit evaluator runtime template",
+            )?,
+            "contact-orbit evaluator runtime template",
+        )?)
+    };
+    let color_contraction_semantic_digest = catalog.digest(
+        contraction.semantic_digest_id,
+        "contact-orbit color-contraction semantic",
+    )?;
+    let evaluator_callable_signature = catalog.digest(
+        binding.callable_signature_digest_id,
+        "contact-orbit evaluator callable signature",
+    )?;
+    let mut applications = Vec::new();
+    applications
+        .try_reserve_exact(witness_rows.len())
+        .map_err(|error| {
+            allocation(format!(
+                "contact-orbit application allocation failed: {error}"
+            ))
+        })?;
+    for witness in witness_rows {
+        if witness.color_contraction_id != contraction.id {
+            return Err(integrity(
+                "contact-orbit witness belongs to another color contraction",
+            ));
+        }
+        applications.push(ContactOrbitApplicationWitness {
+            transition_equivalence_class: try_copy_string(
+                &transition_equivalence_class,
+                "contact-orbit transition equivalence class",
+            )?,
+            quantum_semantic_digest,
+            color_contraction_semantic_digest,
+            color_witness_term_id: LCColorWitnessTermId::new(contraction.id, witness.ordinal),
+            color_witness_proof_digest: catalog
+                .digest(witness.proof_digest_id, "contact-orbit color witness proof")?,
+            coupling_orders: try_copy_u32(&coupling_orders, "contact-orbit local coupling orders")?,
+            coupling_parameter_ids: try_copy_u32(
+                &coupling_parameter_ids,
+                "contact-orbit coupling parameters",
+            )?,
+            momentum_convention: try_copy_u32(
+                &momentum_convention,
+                "contact-orbit momentum convention",
+            )?,
+            binding_coupling,
+            transition_exact_factor,
+            color_exact_factor: contraction_exact_factor,
+            witness_exact_factor: catalog
+                .factor(witness.exact_factor_id, "contact-orbit color witness")?,
+            input_exchange_factor,
+            output_factor_source: transition.output_factor_source,
+            evaluator_contract_kind: binding.contract_kind,
+            evaluator_callable_kind: binding.callable_kind,
+            evaluator_callable_signature,
+            evaluator_input_layout: try_copy_u32(
+                &evaluator_input_layout,
+                "contact-orbit evaluator input layout",
+            )?,
+            evaluator_output_layout: try_copy_u32(
+                &evaluator_output_layout,
+                "contact-orbit evaluator output layout",
+            )?,
+            evaluator_exact_expression_digests: try_clone_digests(
+                &evaluator_exact_expression_digests,
+                "contact-orbit evaluator exact expressions",
+            )?,
+            evaluator_runtime_template: evaluator_runtime_template
+                .as_deref()
+                .map(|value| try_copy_string(value, "contact-orbit evaluator runtime template"))
+                .transpose()?,
+            output_projection_id: transition.output_projection_string_id,
+        });
+    }
+    Ok(Some(PreparedContactOrbitTransition {
+        step,
+        input_state_template_ids,
+        transition_semantic_digest: catalog.digest(
+            transition.semantic_digest_id,
+            "contact-orbit transition semantic",
+        )?,
+        applications,
+    }))
+}
+
+impl PreparedContactOrbitTransition {
+    /// Topology-only counterpart of [`Self::accepts_parent_domain`].  It is
+    /// used by the process-global on-the-fly coupling sweep, which retains no
+    /// recurrence-current payload beyond the exact admission facts below.
+    pub(super) fn accepts_parent_topology_domain(
+        &self,
+        parents: [ContactOrbitParentTopologyDomain<'_>; 2],
+    ) -> RusticolResult<bool> {
+        validate_step(&self.step)?;
+        Ok(contact_orbit_parent_topology_mapping(
+            &self.step,
+            parents,
+            self.input_state_template_ids,
+        )?
+        .is_some())
+    }
+
+    /// Whether these concrete parents belong to the certified contact step's
+    /// physical construction domain.
+    ///
+    /// The established builder reaches this point only after its process-wide
+    /// structural-demand filter, so a missing mapping remains an integrity
+    /// error in [`Self::owner_candidate`].  The query-local on-the-fly sweep
+    /// deliberately has no such global demand graph and uses this predicate to
+    /// avoid instantiating a certified auxiliary step on wider, otherwise
+    /// state-compatible currents.
+    pub(super) fn accepts_parent_domain(
+        &self,
+        parents: [&CurrentCoreKey; 2],
+    ) -> RusticolResult<bool> {
+        self.accepts_parent_topology_domain(
+            parents.map(ContactOrbitParentTopologyDomain::from_current_key),
+        )
+    }
+
+    pub(super) fn owner_candidate<'a>(
+        &'a self,
+        destination: &'a CurrentCoreKey,
+        parents: [&'a CurrentCoreKey; 2],
+        color_witness_term_id: LCColorWitnessTermId,
+    ) -> RusticolResult<ContactOrbitOwnerCandidate<'a>> {
+        let mut matches = self
+            .applications
+            .iter()
+            .filter(|application| application.color_witness_term_id == color_witness_term_id);
+        let application = matches
+            .next()
+            .ok_or_else(|| integrity("certified contact-orbit color witness is absent"))?;
+        if matches.next().is_some() {
+            return Err(integrity(
+                "certified contact-orbit color witness is ambiguous",
+            ));
+        }
+        contact_orbit_owner_candidate(
+            Some(&self.step),
+            destination,
+            parents,
+            self.input_state_template_ids,
+            application,
+            self.transition_semantic_digest,
+        )?
+        .ok_or_else(|| integrity("certified contact-orbit owner candidate disappeared"))
+    }
+}
+
+#[cfg(test)]
+pub(super) fn prepared_contact_orbit_transition_for_test(
+    step: ContactOrbitStepProof,
+    input_state_template_ids: [u32; 2],
+    transition_semantic_digest: SemanticDigest,
+    application: ContactOrbitApplicationWitness,
+) -> PreparedContactOrbitTransition {
+    PreparedContactOrbitTransition {
+        step,
+        input_state_template_ids,
+        transition_semantic_digest,
+        applications: vec![application],
+    }
+}
+
+#[cfg(test)]
+fn contact_orbit_test_digest(byte: u8) -> SemanticDigest {
+    SemanticDigest::new([byte; 32]).expect("test digest must be nonzero")
+}
+
+#[cfg(test)]
+pub(super) fn contact_orbit_application_for_test() -> ContactOrbitApplicationWitness {
+    ContactOrbitApplicationWitness {
+        transition_equivalence_class: "constant-scalar-contact".into(),
+        quantum_semantic_digest: contact_orbit_test_digest(2),
+        color_contraction_semantic_digest: contact_orbit_test_digest(3),
+        color_witness_term_id: LCColorWitnessTermId::new(4, 0),
+        color_witness_proof_digest: contact_orbit_test_digest(5),
+        coupling_orders: vec![1],
+        coupling_parameter_ids: vec![2],
+        momentum_convention: vec![0, 1],
+        binding_coupling: ExactComplexRational::ONE,
+        transition_exact_factor: ExactComplexRational::ONE,
+        color_exact_factor: ExactComplexRational::ONE,
+        witness_exact_factor: ExactComplexRational::ONE,
+        input_exchange_factor: None,
+        output_factor_source: 0,
+        evaluator_contract_kind: EvaluatorContractKind::Vertex as u8,
+        evaluator_callable_kind: EvaluatorCallableKind::PreparedKernel as u8,
+        evaluator_callable_signature: contact_orbit_test_digest(6),
+        evaluator_input_layout: vec![10, 11],
+        evaluator_output_layout: vec![12],
+        evaluator_exact_expression_digests: vec![contact_orbit_test_digest(7)],
+        evaluator_runtime_template: None,
+        output_projection_id: 8,
+    }
+}
+
+#[cfg(test)]
+pub(super) fn partial_contact_orbit_step_for_test(
+    left: u32,
+    right: u32,
+    result: u32,
+    digest_byte: u8,
+    equivalence_classes: [u32; 4],
+) -> ContactOrbitStepProof {
+    ContactOrbitStepProof {
+        certificate_id: 0,
+        certificate_semantic_digest: contact_orbit_test_digest(9),
+        step_semantic_digest: contact_orbit_test_digest(digest_byte),
+        stage: ContactOrbitStage::Partial,
+        result_leg: result,
+        physical_leg_equivalence_classes: equivalence_classes.to_vec(),
+        left_covered_legs: ContactOrbitCoveredLegs::new(&[left]).unwrap(),
+        right_covered_legs: ContactOrbitCoveredLegs::new(&[right]).unwrap(),
+        source_particle_legs: [left as i32, right as i32, -1],
+        certificate_reconstruction_factor: ExactComplexRational::ONE,
+        step_reconstruction_factor: ExactComplexRational::ONE,
+        evaluator_class: "constant-scalar-contact-v1".into(),
+    }
+}
+
+#[cfg(test)]
+pub(super) fn final_contact_orbit_step_for_test(
+    left: &[u32],
+    right: &[u32],
+    result: u32,
+    digest_byte: u8,
+    equivalence_classes: [u32; 4],
+) -> ContactOrbitStepProof {
+    ContactOrbitStepProof {
+        certificate_id: 0,
+        certificate_semantic_digest: contact_orbit_test_digest(9),
+        step_semantic_digest: contact_orbit_test_digest(digest_byte),
+        stage: ContactOrbitStage::Final,
+        result_leg: result,
+        physical_leg_equivalence_classes: equivalence_classes.to_vec(),
+        left_covered_legs: ContactOrbitCoveredLegs::new(left).unwrap(),
+        right_covered_legs: ContactOrbitCoveredLegs::new(right).unwrap(),
+        source_particle_legs: [
+            if left.len() == 2 { -1 } else { left[0] as i32 },
+            if right.len() == 2 {
+                -1
+            } else {
+                right[0] as i32
+            },
+            result as i32,
+        ],
+        certificate_reconstruction_factor: ExactComplexRational::ONE,
+        step_reconstruction_factor: ExactComplexRational::ONE,
+        evaluator_class: "constant-scalar-contact-v1".into(),
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct PhysicalLegAssignments {
+    len: u8,
+    values: [u32; 2],
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ContactOrbitPhysicalAssignment {
+    physical_leg_assignments: PhysicalLegAssignments,
+    source_particle_equivalence_class: Option<u32>,
+}
+
+/// Physics identity retained while quotienting a certified contact traversal orbit.
+///
+/// A certified physical source leg remains bound to its concrete external
+/// source slot.  Auxiliary support must also remain in the key: at five points
+/// the final HEFT node can join two auxiliaries, and their support partition is
+/// the physical identical-particle assignment whose multiplicity is carried by
+/// the compiler-generated kernel.  Forgetting it collapses distinct Hgggg
+/// assignments.  Every other current distinction stays in the owner key too.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ContactOrbitCurrentPhysics<'a> {
+    catalog_digest: SemanticDigest,
+    node_kind: RecurrenceNodeKind,
+    current_state_template_id: u32,
+    dynamic_lc_color_state_id: DynamicLCColorStateId,
+    recurrence_strategy: RecurrenceStrategy,
+    spin_state_class: i32,
+    flavour_flow: &'a [i32],
+    quantum_number_flow_id: u32,
+    coupling_orders: &'a [u32],
+    source_binding: &'a CurrentSourceBinding,
+    propagator_template_id: Option<u32>,
+    support_source_slots: &'a [u32],
+}
+
+impl<'a> ContactOrbitCurrentPhysics<'a> {
+    fn from_current(current: &'a CurrentCoreKey) -> Self {
+        Self {
+            catalog_digest: current.catalog_digest(),
+            node_kind: current.node_kind(),
+            current_state_template_id: current.current_state_template_id(),
+            dynamic_lc_color_state_id: current.dynamic_lc_color_state_id(),
+            recurrence_strategy: current.helicity_identity().strategy(),
+            spin_state_class: current.spin_state_class(),
+            flavour_flow: current.flavour_flow(),
+            quantum_number_flow_id: current.quantum_number_flow_id(),
+            coupling_orders: current.coupling_orders(),
+            source_binding: current.source_binding(),
+            propagator_template_id: current.propagator_template_id(),
+            support_source_slots: current.support_source_slots(),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ContactOrbitParentGroup<'a> {
+    current: ContactOrbitCurrentPhysics<'a>,
+    assignment: ContactOrbitPhysicalAssignment,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct ContactOrbitParentSide {
+    expected_state_template_id: u32,
+    covered_legs: ContactOrbitCoveredLegs,
+    source_particle_leg: i32,
+    assignment: ContactOrbitPhysicalAssignment,
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ContactOrbitOwnerGroupKey<'a> {
+    certificate_id: u32,
+    certificate_semantic_digest: SemanticDigest,
+    stage: ContactOrbitStage,
+    result_leg_equivalence_class: u32,
+    destination: &'a CurrentCoreKey,
+    parents: [ContactOrbitParentGroup<'a>; 2],
+    output_source_particle_equivalence_class: Option<u32>,
+    evaluator_class: &'a str,
+    coupling_parameter_ids: &'a [u32],
+    binding_coupling: ExactComplexRational,
+    application_exact_factor: ExactComplexRational,
+    input_exchange_factor: Option<ExactComplexRational>,
+    certificate_reconstruction_factor: ExactComplexRational,
+    step_reconstruction_factor: ExactComplexRational,
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ContactOrbitOwnerRank<'a> {
+    destination: &'a CurrentCoreKey,
+    parents: [&'a CurrentCoreKey; 2],
+    oriented_covered_legs: [ContactOrbitCoveredLegs; 2],
+    oriented_source_particle_legs: [i32; 3],
+    application: &'a ContactOrbitApplicationWitness,
+    step_semantic_digest: SemanticDigest,
+    transition_semantic_digest: SemanticDigest,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) struct ContactOrbitOwnerCandidate<'a> {
+    group: ContactOrbitOwnerGroupKey<'a>,
+    rank: ContactOrbitOwnerRank<'a>,
+}
+
+fn canonical_physical_assignment(
+    covered_legs: ContactOrbitCoveredLegs,
+    equivalence_classes: &[u32],
+    source_particle_leg: i32,
+) -> RusticolResult<ContactOrbitPhysicalAssignment> {
+    let mut assignments = [0_u32; 2];
+    for (index, leg) in covered_legs.values().iter().copied().enumerate() {
+        assignments[index] = *equivalence_classes
+            .get(leg as usize)
+            .ok_or_else(|| integrity("contact-orbit covered leg is outside arity"))?;
+    }
+    assignments[..covered_legs.len()].sort_unstable();
+    let source_particle_equivalence_class = match source_particle_leg {
+        -1 => None,
+        leg if leg >= 0 => Some(
+            *equivalence_classes
+                .get(leg as usize)
+                .ok_or_else(|| integrity("contact-orbit source particle leg is outside arity"))?,
+        ),
+        _ => {
+            return Err(integrity(
+                "contact-orbit source particle leg uses an unknown sentinel",
+            ));
+        }
+    };
+    Ok(ContactOrbitPhysicalAssignment {
+        physical_leg_assignments: PhysicalLegAssignments {
+            len: covered_legs.len,
+            values: assignments,
+        },
+        source_particle_equivalence_class,
+    })
+}
+
+fn physical_leg_equivalence_class(
+    leg: i32,
+    equivalence_classes: &[u32],
+    label: &str,
+) -> RusticolResult<Option<u32>> {
+    match leg {
+        -1 => Ok(None),
+        leg if leg >= 0 => equivalence_classes
+            .get(leg as usize)
+            .copied()
+            .map(Some)
+            .ok_or_else(|| integrity(format!("contact-orbit {label} is outside arity"))),
+        _ => Err(integrity(format!(
+            "contact-orbit {label} uses an unknown sentinel"
+        ))),
+    }
+}
+
+fn validate_step(step: &ContactOrbitStepProof) -> RusticolResult<()> {
+    if step.certificate_reconstruction_factor != ExactComplexRational::ONE
+        || step.step_reconstruction_factor != ExactComplexRational::ONE
+    {
+        return Err(integrity(
+            "contact-orbit owner requires exact unit reconstruction",
+        ));
+    }
+    let arity = step.physical_leg_equivalence_classes.len();
+    if !matches!(arity, 4 | 5) {
+        return Err(integrity(
+            "contact-orbit certificate does not describe four or five legs",
+        ));
+    }
+    let result_index = usize::try_from(step.result_leg)
+        .ok()
+        .filter(|index| *index < arity)
+        .ok_or_else(|| integrity("contact-orbit result leg is outside arity"))?;
+    let mut covered = vec![false; arity];
+    for leg in step
+        .left_covered_legs
+        .values()
+        .iter()
+        .chain(step.right_covered_legs.values())
+        .copied()
+    {
+        let index = usize::try_from(leg)
+            .ok()
+            .filter(|index| *index < arity)
+            .ok_or_else(|| integrity("contact-orbit covered leg is outside arity"))?;
+        if index == result_index || covered[index] {
+            return Err(integrity("contact-orbit covered-leg partition is invalid"));
+        }
+        covered[index] = true;
+    }
+    match step.stage {
+        ContactOrbitStage::Partial => {
+            if step.left_covered_legs.len() != 1
+                || step.right_covered_legs.len() != 1
+                || step.source_particle_legs
+                    != [
+                        step.left_covered_legs.values()[0] as i32,
+                        step.right_covered_legs.values()[0] as i32,
+                        -1,
+                    ]
+            {
+                return Err(integrity(
+                    "contact-orbit partial owner lineage is inconsistent",
+                ));
+            }
+        }
+        ContactOrbitStage::Final => {
+            let expected_sources = [
+                if step.left_covered_legs.len() > 1 {
+                    -1
+                } else {
+                    step.left_covered_legs.values()[0] as i32
+                },
+                if step.right_covered_legs.len() > 1 {
+                    -1
+                } else {
+                    step.right_covered_legs.values()[0] as i32
+                },
+                step.result_leg as i32,
+            ];
+            if step.left_covered_legs.len() > 2
+                || step.right_covered_legs.len() > 2
+                || step.source_particle_legs != expected_sources
+                || covered
+                    .iter()
+                    .enumerate()
+                    .any(|(index, value)| *value != (index != result_index))
+            {
+                return Err(integrity(
+                    "contact-orbit final owner lineage is inconsistent",
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_support_union(
+    destination: &CurrentCoreKey,
+    parents: [&CurrentCoreKey; 2],
+) -> RusticolResult<()> {
+    let left = parents[0].support_source_slots();
+    let right = parents[1].support_source_slots();
+    let destination_support = destination.support_source_slots();
+    if left
+        .len()
+        .checked_add(right.len())
+        .filter(|combined| *combined == destination_support.len())
+        .is_none()
+    {
+        return Err(integrity(
+            "contact-orbit parent supports do not reproduce the destination",
+        ));
+    }
+    let (mut left_index, mut right_index) = (0_usize, 0_usize);
+    for expected in destination_support.iter().copied() {
+        let next = match (left.get(left_index), right.get(right_index)) {
+            (Some(left_value), Some(right_value)) => match left_value.cmp(right_value) {
+                Ordering::Less => {
+                    left_index += 1;
+                    *left_value
+                }
+                Ordering::Greater => {
+                    right_index += 1;
+                    *right_value
+                }
+                Ordering::Equal => {
+                    return Err(integrity("contact-orbit parent supports are not disjoint"));
+                }
+            },
+            (Some(left_value), None) => {
+                left_index += 1;
+                *left_value
+            }
+            (None, Some(right_value)) => {
+                right_index += 1;
+                *right_value
+            }
+            (None, None) => {
+                return Err(integrity(
+                    "contact-orbit parent supports do not reproduce the destination",
+                ));
+            }
+        };
+        if next != expected {
+            return Err(integrity(
+                "contact-orbit parent supports do not reproduce the destination",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn topology_domain_matches_contact_orbit_side(
+    parent: ContactOrbitParentTopologyDomain<'_>,
+    side: ContactOrbitParentSide,
+) -> bool {
+    if parent.current_state_template_id != side.expected_state_template_id
+        || parent.support_source_slots.is_empty()
+    {
+        return false;
+    }
+    match side.source_particle_leg {
+        -1 => parent.is_current,
+        // A physical contact leg may be fed either by an external source or by
+        // an ordinary off-shell current.  Its certified leg number identifies
+        // a vertex slot, not an external-process source slot.
+        leg if leg >= 0 => parent.is_source || parent.is_current,
+        _ => false,
+    }
+}
+
+fn contact_orbit_parent_topology_mapping(
+    step: &ContactOrbitStepProof,
+    parents: [ContactOrbitParentTopologyDomain<'_>; 2],
+    input_state_template_ids: [u32; 2],
+) -> RusticolResult<Option<([ContactOrbitParentSide; 2], [usize; 2])>> {
+    let sides = [
+        ContactOrbitParentSide {
+            expected_state_template_id: input_state_template_ids[0],
+            covered_legs: step.left_covered_legs,
+            source_particle_leg: step.source_particle_legs[0],
+            assignment: canonical_physical_assignment(
+                step.left_covered_legs,
+                &step.physical_leg_equivalence_classes,
+                step.source_particle_legs[0],
+            )?,
+        },
+        ContactOrbitParentSide {
+            expected_state_template_id: input_state_template_ids[1],
+            covered_legs: step.right_covered_legs,
+            source_particle_leg: step.source_particle_legs[1],
+            assignment: canonical_physical_assignment(
+                step.right_covered_legs,
+                &step.physical_leg_equivalence_classes,
+                step.source_particle_legs[1],
+            )?,
+        },
+    ];
+    let direct = topology_domain_matches_contact_orbit_side(parents[0], sides[0])
+        && topology_domain_matches_contact_orbit_side(parents[1], sides[1]);
+    let exchanged = topology_domain_matches_contact_orbit_side(parents[1], sides[0])
+        && topology_domain_matches_contact_orbit_side(parents[0], sides[1]);
+    let parent_by_side = match (direct, exchanged) {
+        (true, false) => [0_usize, 1_usize],
+        (false, true) => [1_usize, 0_usize],
+        (true, true)
+            if sides[0].expected_state_template_id == sides[1].expected_state_template_id
+                && sides[0].assignment == sides[1].assignment =>
+        {
+            [0_usize, 1_usize]
+        }
+        (true, true) => {
+            return Err(integrity(
+                "contact-orbit parent-to-side mapping is ambiguous across distinct physical assignments",
+            ));
+        }
+        (false, false) => return Ok(None),
+    };
+    Ok(Some((sides, parent_by_side)))
+}
+
+fn contact_orbit_parent_mapping(
+    step: &ContactOrbitStepProof,
+    parents: [&CurrentCoreKey; 2],
+    input_state_template_ids: [u32; 2],
+) -> RusticolResult<Option<([ContactOrbitParentSide; 2], [usize; 2])>> {
+    contact_orbit_parent_topology_mapping(
+        step,
+        parents.map(ContactOrbitParentTopologyDomain::from_current_key),
+        input_state_template_ids,
+    )
+}
+
+pub(super) fn contact_orbit_owner_candidate<'a>(
+    step: Option<&'a ContactOrbitStepProof>,
+    destination: &'a CurrentCoreKey,
+    parents: [&'a CurrentCoreKey; 2],
+    input_state_template_ids: [u32; 2],
+    application: &'a ContactOrbitApplicationWitness,
+    transition_semantic_digest: SemanticDigest,
+) -> RusticolResult<Option<ContactOrbitOwnerCandidate<'a>>> {
+    let Some(step) = step else {
+        return Ok(None);
+    };
+    validate_step(step)?;
+    validate_support_union(destination, parents)?;
+    let (sides, parent_by_side) =
+        contact_orbit_parent_mapping(step, parents, input_state_template_ids)?
+            .ok_or_else(|| integrity("contact-orbit parent-to-side mapping is absent"))?;
+    let mut canonical_parents = [
+        ContactOrbitParentGroup {
+            current: ContactOrbitCurrentPhysics::from_current(parents[parent_by_side[0]]),
+            assignment: sides[0].assignment,
+        },
+        ContactOrbitParentGroup {
+            current: ContactOrbitCurrentPhysics::from_current(parents[parent_by_side[1]]),
+            assignment: sides[1].assignment,
+        },
+    ];
+    canonical_parents.sort_unstable();
+    let result_leg_equivalence_class =
+        step.physical_leg_equivalence_classes[step.result_leg as usize];
+    let application_exact_factor = application
+        .transition_exact_factor
+        .checked_mul(application.color_exact_factor)?
+        .checked_mul(application.witness_exact_factor)?;
+    Ok(Some(ContactOrbitOwnerCandidate {
+        group: ContactOrbitOwnerGroupKey {
+            certificate_id: step.certificate_id,
+            certificate_semantic_digest: step.certificate_semantic_digest,
+            stage: step.stage,
+            result_leg_equivalence_class,
+            destination,
+            parents: canonical_parents,
+            output_source_particle_equivalence_class: physical_leg_equivalence_class(
+                step.source_particle_legs[2],
+                &step.physical_leg_equivalence_classes,
+                "output source particle leg",
+            )?,
+            evaluator_class: &step.evaluator_class,
+            coupling_parameter_ids: &application.coupling_parameter_ids,
+            binding_coupling: application.binding_coupling,
+            application_exact_factor,
+            input_exchange_factor: application.input_exchange_factor,
+            certificate_reconstruction_factor: step.certificate_reconstruction_factor,
+            step_reconstruction_factor: step.step_reconstruction_factor,
+        },
+        rank: ContactOrbitOwnerRank {
+            destination,
+            parents,
+            oriented_covered_legs: [step.left_covered_legs, step.right_covered_legs],
+            oriented_source_particle_legs: step.source_particle_legs,
+            application,
+            step_semantic_digest: step.step_semantic_digest,
+            transition_semantic_digest,
+        },
+    }))
+}
+
+fn compare_items<T: Ord>(
+    left: &(T, Option<ContactOrbitOwnerCandidate<'_>>),
+    right: &(T, Option<ContactOrbitOwnerCandidate<'_>>),
+) -> Ordering {
+    match (&left.1, &right.1) {
+        (None, None) => left.0.cmp(&right.0),
+        (None, Some(_)) => Ordering::Less,
+        (Some(_), None) => Ordering::Greater,
+        (Some(left_candidate), Some(right_candidate)) => left_candidate
+            .group
+            .cmp(&right_candidate.group)
+            .then_with(|| left_candidate.rank.cmp(&right_candidate.rank))
+            .then_with(|| left.0.cmp(&right.0)),
+    }
+}
+
+/// Select one exact owner per certified group without mutating caller state.
+///
+/// The exact-size iterator is copied into one fallibly reserved scratch vector,
+/// then sorted in place. The returned token vector is separately reserved
+/// before any selection, so every allocation failure occurs before caller-owned
+/// construction state can be replaced.
+pub(super) fn selected_contact_orbit_owner_tokens<'a, T, I>(items: I) -> RusticolResult<Vec<T>>
+where
+    T: Ord,
+    I: IntoIterator<Item = (T, Option<ContactOrbitOwnerCandidate<'a>>)>,
+    I::IntoIter: ExactSizeIterator,
+{
+    let iterator = items.into_iter();
+    let item_count = iterator.len();
+    item_count
+        .checked_mul(size_of::<(T, Option<ContactOrbitOwnerCandidate<'a>>)>())
+        .ok_or_else(|| integrity("contact-orbit owner scratch byte size overflows usize"))?;
+    let mut scratch = Vec::new();
+    scratch.try_reserve_exact(item_count).map_err(|error| {
+        allocation(format!(
+            "contact-orbit owner scratch allocation failed: {error}"
+        ))
+    })?;
+    for item in iterator {
+        if scratch.len() == item_count {
+            return Err(integrity(
+                "contact-orbit exact-size owner iterator exceeded its declared length",
+            ));
+        }
+        scratch.push(item);
+    }
+    if scratch.len() != item_count {
+        return Err(integrity(
+            "contact-orbit exact-size owner iterator changed length",
+        ));
+    }
+
+    let mut selected = Vec::new();
+    selected.try_reserve_exact(item_count).map_err(|error| {
+        allocation(format!(
+            "contact-orbit selected-owner allocation failed: {error}"
+        ))
+    })?;
+    scratch.sort_unstable_by(compare_items);
+    let mut iterator = scratch.into_iter().peekable();
+    while let Some((token, candidate)) = iterator.next() {
+        let Some(candidate) = candidate else {
+            selected.push(token);
+            continue;
+        };
+        while let Some((next_token, Some(next_candidate))) = iterator.peek() {
+            if next_candidate.group != candidate.group {
+                break;
+            }
+            if next_candidate.rank == candidate.rank && next_token != &token {
+                return Err(integrity(
+                    "contact-orbit owner candidates have a conflicting exact rank",
+                ));
+            }
+            iterator.next();
+        }
+        selected.push(token);
+    }
+    selected.sort_unstable();
+    if selected.windows(2).any(|pair| pair[0] == pair[1]) {
+        return Err(integrity(
+            "contact-orbit owner selection produced duplicate tokens",
+        ));
+    }
+    Ok(selected)
+}
+
+#[cfg(test)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum ContactOrbitTestBinding {
+    None,
+    One,
+    Two,
+    MissingStep,
+    DigestMismatch,
+}
+
+#[cfg(test)]
+pub(super) fn contact_orbit_test_template(
+    binding: ContactOrbitTestBinding,
+) -> OwnedRecurrenceTemplateInput {
+    use super::{
+        template::{ContactOrbitCertificateRow, ContactOrbitStepRow, DigestCatalogRow},
+        validated_template_fixture,
+    };
+
+    fn string_id(input: &OwnedRecurrenceTemplateInput, value: &str) -> u32 {
+        input
+            .string_ranges
+            .iter()
+            .position(|range| {
+                let range = range
+                    .as_usize_range(input.string_bytes.len(), "test string")
+                    .unwrap();
+                input.string_bytes[range] == *value.as_bytes()
+            })
+            .unwrap() as u32
+    }
+
+    fn u32_sequence_id(input: &OwnedRecurrenceTemplateInput, values: &[u32]) -> u32 {
+        input
+            .u32_sequence_ranges
+            .iter()
+            .position(|row| {
+                let range = row
+                    .range
+                    .as_usize_range(input.u32_sequence_values.len(), "test u32 sequence")
+                    .unwrap();
+                &input.u32_sequence_values[range] == values
+            })
+            .unwrap() as u32
+    }
+
+    fn i32_sequence_id(input: &OwnedRecurrenceTemplateInput, values: &[i32]) -> u32 {
+        input
+            .i32_sequence_ranges
+            .iter()
+            .position(|row| {
+                let range = row
+                    .range
+                    .as_usize_range(input.i32_sequence_values.len(), "test i32 sequence")
+                    .unwrap();
+                &input.i32_sequence_values[range] == values
+            })
+            .unwrap() as u32
+    }
+
+    fn append_digest(input: &mut OwnedRecurrenceTemplateInput, byte: u8) -> u32 {
+        let id = input.digest_catalog.len() as u32;
+        input.digest_catalog.push(DigestCatalogRow {
+            id,
+            value: [byte; 32],
+        });
+        id
+    }
+
+    let mut input = validated_template_fixture().into_input();
+    if binding == ContactOrbitTestBinding::None {
+        return input;
+    }
+
+    let algorithm = string_id(&input, "compiler-certified-contact-orbit");
+    let evaluator_class = string_id(
+        &input,
+        "constant-scalar-literal-singlet-self-conjugate-boson",
+    );
+    let certificate_template = string_id(&input, "any");
+    let first_step_template = string_id(&input, "basis");
+    let second_step_template = string_id(&input, "component");
+    let particle = string_id(&input, "scalar");
+    let vertex = particle;
+    let particles = u32_sequence_id(&input, &[particle, particle, particle, particle]);
+    let equivalence = u32_sequence_id(&input, &[0, 0, 0, 0]);
+    let left_first = u32_sequence_id(&input, &[0]);
+    let right_first = u32_sequence_id(&input, &[1]);
+    let left_second = right_first;
+    let right_second = left_first;
+    let source_first = i32_sequence_id(&input, &[0, 1, -1]);
+    let source_second = i32_sequence_id(&input, &[1, 0, -1]);
+    let certificate_digest = append_digest(&mut input, 26);
+    let first_step_digest = append_digest(&mut input, 27);
+    let second_step_digest = append_digest(&mut input, 28);
+    input.contact_orbit_certificates = vec![ContactOrbitCertificateRow {
+        id: 0,
+        template_string_id: certificate_template,
+        algorithm_string_id: algorithm,
+        algorithm_version: 2,
+        term_id: 0,
+        vertex_string_id: vertex,
+        particle_string_sequence_id: particles,
+        evaluator_class_string_id: evaluator_class,
+        physical_leg_equivalence_sequence_id: equivalence,
+        reconstruction_factor_id: 0,
+        semantic_digest_id: certificate_digest,
+    }];
+    input.contact_orbit_steps = vec![
+        ContactOrbitStepRow {
+            id: 0,
+            template_string_id: first_step_template,
+            certificate_id: 0,
+            stage: ContactOrbitStage::Partial as u8,
+            result_leg: 2,
+            left_covered_leg_sequence_id: left_first,
+            right_covered_leg_sequence_id: right_first,
+            source_particle_leg_sequence_id: source_first,
+            reconstruction_factor_id: 0,
+            semantic_digest_id: first_step_digest,
+        },
+        ContactOrbitStepRow {
+            id: 1,
+            template_string_id: second_step_template,
+            certificate_id: 0,
+            stage: ContactOrbitStage::Partial as u8,
+            result_leg: 2,
+            left_covered_leg_sequence_id: left_second,
+            right_covered_leg_sequence_id: right_second,
+            source_particle_leg_sequence_id: source_second,
+            reconstruction_factor_id: 0,
+            semantic_digest_id: second_step_digest,
+        },
+    ];
+    input.catalog_header[0].contact_orbit_certificate_count = 1;
+    input.catalog_header[0].contact_orbit_step_count = 2;
+    let (step_ids, digest_ids) = match binding {
+        ContactOrbitTestBinding::None => unreachable!(),
+        ContactOrbitTestBinding::One => (vec![0], vec![first_step_digest]),
+        ContactOrbitTestBinding::Two => (vec![0, 1], vec![first_step_digest, second_step_digest]),
+        ContactOrbitTestBinding::MissingStep => (vec![2], vec![first_step_digest]),
+        ContactOrbitTestBinding::DigestMismatch => (vec![0], vec![second_step_digest]),
+    };
+    input.transitions[0].contact_orbit_step_sequence_id = u32_sequence_id(&input, &step_ids);
+    input.transitions[0].contact_orbit_step_semantic_digest_sequence_id =
+        u32_sequence_id(&input, &digest_ids);
+    input
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::{
+        CanonicalMomentumLinearForm, CurrentHelicityIdentity, CurrentSourceBinding,
+        DynamicLCColorStateId, ExactRational, MomentumTerm, RecurrenceNodeKind,
+        SourceStateAssignment,
+    };
+
+    fn digest(value: u8) -> SemanticDigest {
+        SemanticDigest::new([value; 32]).unwrap()
+    }
+
+    fn exact(value: i128) -> ExactComplexRational {
+        ExactComplexRational::new(ExactRational::new(value, 1).unwrap(), ExactRational::ZERO)
+    }
+
+    fn exact_ratio(numerator: i128, denominator: i128) -> ExactComplexRational {
+        ExactComplexRational::new(
+            ExactRational::new(numerator, denominator).unwrap(),
+            ExactRational::ZERO,
+        )
+    }
+
+    fn current(state: u32, color: u32, support: &[u32]) -> CurrentCoreKey {
+        let is_source = support.len() == 1;
+        current_with_physics(
+            if is_source {
+                RecurrenceNodeKind::Source
+            } else {
+                RecurrenceNodeKind::Current
+            },
+            state,
+            color,
+            support,
+            if is_source {
+                RecurrenceStrategy::TopologyReplay
+            } else {
+                RecurrenceStrategy::AllFlowUnion
+            },
+            0,
+            vec![state as i32],
+            0,
+            vec![0],
+            if is_source {
+                CurrentSourceBinding::FixedTemplate(support[0])
+            } else {
+                CurrentSourceBinding::None
+            },
+            None,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn current_with_physics(
+        node_kind: RecurrenceNodeKind,
+        state: u32,
+        color: u32,
+        support: &[u32],
+        strategy: RecurrenceStrategy,
+        spin_state_class: i32,
+        flavour_flow: Vec<i32>,
+        quantum_number_flow_id: u32,
+        coupling_orders: Vec<u32>,
+        source_binding: CurrentSourceBinding,
+        propagator_template_id: Option<u32>,
+    ) -> CurrentCoreKey {
+        let helicity_identity = match strategy {
+            RecurrenceStrategy::TopologyReplay => CurrentHelicityIdentity::topology_replay(
+                spin_state_class,
+                support
+                    .iter()
+                    .copied()
+                    .map(|source_slot| SourceStateAssignment::new(source_slot, 0))
+                    .collect(),
+            )
+            .unwrap(),
+            RecurrenceStrategy::AllFlowUnion => {
+                CurrentHelicityIdentity::all_flow_union(spin_state_class)
+            }
+            RecurrenceStrategy::ContractedColorUnion => {
+                CurrentHelicityIdentity::contracted_color_union(
+                    spin_state_class,
+                    support
+                        .iter()
+                        .copied()
+                        .map(|source_slot| SourceStateAssignment::new(source_slot, 0))
+                        .collect(),
+                )
+                .unwrap()
+            }
+        };
+        CurrentCoreKey::new(
+            digest(1),
+            node_kind,
+            state,
+            DynamicLCColorStateId::from_interner(color),
+            support.to_vec(),
+            CanonicalMomentumLinearForm::new(
+                support
+                    .iter()
+                    .copied()
+                    .map(|source_slot| MomentumTerm {
+                        source_slot,
+                        coefficient: 1,
+                    })
+                    .collect(),
+            )
+            .unwrap(),
+            helicity_identity,
+            flavour_flow,
+            quantum_number_flow_id,
+            coupling_orders,
+            source_binding,
+            propagator_template_id,
+        )
+        .unwrap()
+    }
+
+    fn topology_current(state: u32, color: u32, support: &[u32]) -> CurrentCoreKey {
+        let is_source = support.len() == 1;
+        current_with_physics(
+            if is_source {
+                RecurrenceNodeKind::Source
+            } else {
+                RecurrenceNodeKind::Current
+            },
+            state,
+            color,
+            support,
+            RecurrenceStrategy::TopologyReplay,
+            0,
+            vec![state as i32],
+            0,
+            vec![0],
+            if is_source {
+                CurrentSourceBinding::FixedTemplate(0)
+            } else {
+                CurrentSourceBinding::None
+            },
+            None,
+        )
+    }
+
+    fn topology_source(source_slot: u32, source_template_id: u32) -> CurrentCoreKey {
+        current_with_physics(
+            RecurrenceNodeKind::Source,
+            1,
+            1,
+            &[source_slot],
+            RecurrenceStrategy::TopologyReplay,
+            0,
+            vec![1],
+            0,
+            vec![0],
+            CurrentSourceBinding::FixedTemplate(source_template_id),
+            None,
+        )
+    }
+
+    fn application() -> ContactOrbitApplicationWitness {
+        ContactOrbitApplicationWitness {
+            transition_equivalence_class: "constant-scalar-contact".into(),
+            quantum_semantic_digest: digest(2),
+            color_contraction_semantic_digest: digest(3),
+            color_witness_term_id: LCColorWitnessTermId::new(4, 0),
+            color_witness_proof_digest: digest(5),
+            coupling_orders: vec![1],
+            coupling_parameter_ids: vec![2],
+            momentum_convention: vec![0, 1],
+            binding_coupling: ExactComplexRational::ONE,
+            transition_exact_factor: ExactComplexRational::ONE,
+            color_exact_factor: ExactComplexRational::ONE,
+            witness_exact_factor: ExactComplexRational::ONE,
+            input_exchange_factor: None,
+            output_factor_source: 0,
+            evaluator_contract_kind: EvaluatorContractKind::Vertex as u8,
+            evaluator_callable_kind: EvaluatorCallableKind::PreparedKernel as u8,
+            evaluator_callable_signature: digest(6),
+            evaluator_input_layout: vec![10, 11],
+            evaluator_output_layout: vec![12],
+            evaluator_exact_expression_digests: vec![digest(7)],
+            evaluator_runtime_template: None,
+            output_projection_id: 8,
+        }
+    }
+
+    fn prepare_test_contact_orbit(
+        input: &OwnedRecurrenceTemplateInput,
+    ) -> RusticolResult<Option<PreparedContactOrbitTransition>> {
+        let catalog = TemplateCatalog::new(input)?;
+        let transition = input.transitions[0];
+        let quantum = input.quantum_flows[transition.quantum_flow_template_id as usize];
+        let contraction =
+            input.color_contractions[transition.color_contraction_template_id as usize];
+        prepare_contact_orbit_transition(
+            input,
+            &catalog,
+            transition,
+            catalog.digest(quantum.semantic_digest_id, "test quantum semantic")?,
+            &catalog.coupling_orders(transition.coupling_order_set_id)?,
+            catalog.factor(
+                transition.binding_coupling_factor_id,
+                "test binding coupling",
+            )?,
+            catalog.factor(transition.exact_factor_id, "test transition exact")?,
+            catalog.factor(
+                contraction.exact_coefficient_factor_id,
+                "test contraction exact",
+            )?,
+            None,
+            catalog.witness_rows(transition.color_contraction_template_id)?,
+        )
+    }
+
+    #[test]
+    fn strict_prepared_contact_orbit_decode_is_zero_or_one_and_fail_closed() {
+        let none = contact_orbit_test_template(ContactOrbitTestBinding::None);
+        assert!(prepare_test_contact_orbit(&none).unwrap().is_none());
+
+        let one = contact_orbit_test_template(ContactOrbitTestBinding::One)
+            .validate()
+            .unwrap();
+        assert!(prepare_test_contact_orbit(one.input()).unwrap().is_some());
+
+        let two = contact_orbit_test_template(ContactOrbitTestBinding::Two)
+            .validate()
+            .unwrap();
+        assert!(
+            prepare_test_contact_orbit(two.input())
+                .unwrap_err()
+                .to_string()
+                .contains("exactly one contact-orbit step")
+        );
+
+        let missing = contact_orbit_test_template(ContactOrbitTestBinding::MissingStep);
+        assert!(
+            prepare_test_contact_orbit(&missing)
+                .unwrap_err()
+                .to_string()
+                .contains("contact-orbit step is absent")
+        );
+
+        let mismatch = contact_orbit_test_template(ContactOrbitTestBinding::DigestMismatch);
+        assert!(
+            prepare_test_contact_orbit(&mismatch)
+                .unwrap_err()
+                .to_string()
+                .contains("digest binding is stale")
+        );
+    }
+
+    fn partial_step(left: u32, right: u32, result: u32, digest_byte: u8) -> ContactOrbitStepProof {
+        ContactOrbitStepProof {
+            certificate_id: 0,
+            certificate_semantic_digest: digest(9),
+            step_semantic_digest: digest(digest_byte),
+            stage: ContactOrbitStage::Partial,
+            result_leg: result,
+            physical_leg_equivalence_classes: vec![0, 0, 0, 0],
+            left_covered_legs: ContactOrbitCoveredLegs::new(&[left]).unwrap(),
+            right_covered_legs: ContactOrbitCoveredLegs::new(&[right]).unwrap(),
+            source_particle_legs: [left as i32, right as i32, -1],
+            certificate_reconstruction_factor: ExactComplexRational::ONE,
+            step_reconstruction_factor: ExactComplexRational::ONE,
+            evaluator_class: "constant-scalar-contact-v1".into(),
+        }
+    }
+
+    fn final_step(
+        left: &[u32],
+        right: &[u32],
+        result: u32,
+        digest_byte: u8,
+        equivalence_classes: [u32; 4],
+    ) -> ContactOrbitStepProof {
+        ContactOrbitStepProof {
+            certificate_id: 0,
+            certificate_semantic_digest: digest(9),
+            step_semantic_digest: digest(digest_byte),
+            stage: ContactOrbitStage::Final,
+            result_leg: result,
+            physical_leg_equivalence_classes: equivalence_classes.to_vec(),
+            left_covered_legs: ContactOrbitCoveredLegs::new(left).unwrap(),
+            right_covered_legs: ContactOrbitCoveredLegs::new(right).unwrap(),
+            source_particle_legs: [
+                if left.len() == 2 { -1 } else { left[0] as i32 },
+                if right.len() == 2 {
+                    -1
+                } else {
+                    right[0] as i32
+                },
+                result as i32,
+            ],
+            certificate_reconstruction_factor: ExactComplexRational::ONE,
+            step_reconstruction_factor: ExactComplexRational::ONE,
+            evaluator_class: "constant-scalar-contact-v1".into(),
+        }
+    }
+
+    fn five_leg_final_step(
+        left: &[u32],
+        right: &[u32],
+        result: u32,
+        digest_byte: u8,
+    ) -> ContactOrbitStepProof {
+        ContactOrbitStepProof {
+            certificate_id: 0,
+            certificate_semantic_digest: digest(9),
+            step_semantic_digest: digest(digest_byte),
+            stage: ContactOrbitStage::Final,
+            result_leg: result,
+            physical_leg_equivalence_classes: vec![0, 0, 0, 0, 1],
+            left_covered_legs: ContactOrbitCoveredLegs::new(left).unwrap(),
+            right_covered_legs: ContactOrbitCoveredLegs::new(right).unwrap(),
+            source_particle_legs: [-1, -1, result as i32],
+            certificate_reconstruction_factor: ExactComplexRational::ONE,
+            step_reconstruction_factor: ExactComplexRational::ONE,
+            evaluator_class: "scalar-heft-colored-contact-tree".into(),
+        }
+    }
+
+    fn candidate<'a>(
+        step: &'a ContactOrbitStepProof,
+        destination: &'a CurrentCoreKey,
+        parents: [&'a CurrentCoreKey; 2],
+        application: &'a ContactOrbitApplicationWitness,
+        transition_digest: u8,
+    ) -> ContactOrbitOwnerCandidate<'a> {
+        contact_orbit_owner_candidate(
+            Some(step),
+            destination,
+            parents,
+            parents.map(|parent| parent.current_state_template_id()),
+            application,
+            digest(transition_digest),
+        )
+        .unwrap()
+        .unwrap()
+    }
+
+    fn candidate_with_input_states<'a>(
+        step: &'a ContactOrbitStepProof,
+        destination: &'a CurrentCoreKey,
+        parents: [&'a CurrentCoreKey; 2],
+        input_state_template_ids: [u32; 2],
+        application: &'a ContactOrbitApplicationWitness,
+        transition_digest: u8,
+    ) -> RusticolResult<Option<ContactOrbitOwnerCandidate<'a>>> {
+        contact_orbit_owner_candidate(
+            Some(step),
+            destination,
+            parents,
+            input_state_template_ids,
+            application,
+            digest(transition_digest),
+        )
+    }
+
+    #[test]
+    fn owner_group_forgets_only_left_right_traversal() {
+        let left = current(1, 1, &[10]);
+        let right = current(1, 1, &[11]);
+        let destination = current(2, 2, &[10, 11]);
+        let application = application();
+        let forward_step = partial_step(0, 1, 2, 10);
+        let reverse_step = partial_step(1, 0, 2, 11);
+        let forward = candidate(
+            &forward_step,
+            &destination,
+            [&left, &right],
+            &application,
+            12,
+        );
+        let reverse = candidate(
+            &reverse_step,
+            &destination,
+            [&right, &left],
+            &application,
+            13,
+        );
+
+        assert_eq!(forward.group, reverse.group);
+        assert_ne!(forward.rank, reverse.rank);
+        assert_eq!(
+            selected_contact_orbit_owner_tokens([(1_u32, Some(reverse)), (0_u32, Some(forward)),])
+                .unwrap(),
+            vec![0],
+        );
+        assert_eq!(
+            selected_contact_orbit_owner_tokens([(0_u32, Some(forward)), (1_u32, Some(reverse)),])
+                .unwrap(),
+            vec![0],
+        );
+    }
+
+    #[test]
+    fn parent_assignment_binds_evaluator_swaps_to_certified_final_sides() {
+        let pair = current(20, 2, &[10, 11]);
+        let source = current(30, 1, &[12]);
+        let destination = current(40, 3, &[10, 11, 12]);
+        let application = application();
+        let forward_step = final_step(&[0, 1], &[2], 3, 20, [0, 0, 1, 2]);
+        let mirror_step = final_step(&[2], &[0, 1], 3, 21, [0, 0, 1, 2]);
+
+        let forward = candidate_with_input_states(
+            &forward_step,
+            &destination,
+            [&source, &pair],
+            [20, 30],
+            &application,
+            22,
+        )
+        .unwrap()
+        .unwrap();
+        let mirror = candidate_with_input_states(
+            &mirror_step,
+            &destination,
+            [&pair, &source],
+            [30, 20],
+            &application,
+            23,
+        )
+        .unwrap()
+        .unwrap();
+
+        assert_eq!(forward.group, mirror.group);
+        assert_ne!(forward.rank, mirror.rank);
+    }
+
+    #[test]
+    fn parent_assignment_handles_distinct_states_and_identical_ambiguity() {
+        let left = current(10, 1, &[10]);
+        let right = current(20, 1, &[11]);
+        let destination = current(30, 2, &[10, 11]);
+        let application = application();
+        let distinct_step = partial_step(0, 1, 2, 24);
+        let direct = candidate_with_input_states(
+            &distinct_step,
+            &destination,
+            [&left, &right],
+            [10, 20],
+            &application,
+            25,
+        )
+        .unwrap()
+        .unwrap();
+        let swapped = candidate_with_input_states(
+            &distinct_step,
+            &destination,
+            [&right, &left],
+            [10, 20],
+            &application,
+            26,
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(direct.group, swapped.group);
+
+        let identical_right = current(10, 1, &[11]);
+        let identical_step = partial_step(0, 1, 2, 27);
+        assert!(
+            candidate_with_input_states(
+                &identical_step,
+                &destination,
+                [&left, &identical_right],
+                [10, 10],
+                &application,
+                28,
+            )
+            .unwrap()
+            .is_some()
+        );
+    }
+
+    #[test]
+    fn parent_assignment_rejects_ambiguous_or_invalid_side_semantics() {
+        let left = current(10, 1, &[10]);
+        let right = current(10, 1, &[11]);
+        let destination = current(30, 2, &[10, 11]);
+        let application = application();
+        let mut non_equivalent = partial_step(0, 1, 2, 29);
+        non_equivalent.physical_leg_equivalence_classes = vec![0, 1, 2, 3];
+        assert!(
+            candidate_with_input_states(
+                &non_equivalent,
+                &destination,
+                [&left, &right],
+                [10, 10],
+                &application,
+                30,
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("mapping is ambiguous")
+        );
+
+        let step = partial_step(0, 1, 2, 31);
+        assert!(
+            candidate_with_input_states(
+                &step,
+                &destination,
+                [&left, &right],
+                [90, 91],
+                &application,
+                32,
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("mapping is absent")
+        );
+        let internal_leg = current_with_physics(
+            RecurrenceNodeKind::Current,
+            10,
+            1,
+            &[10],
+            RecurrenceStrategy::TopologyReplay,
+            0,
+            vec![10],
+            0,
+            vec![0],
+            CurrentSourceBinding::None,
+            None,
+        );
+        assert!(
+            candidate_with_input_states(
+                &step,
+                &destination,
+                [&internal_leg, &right],
+                [10, 10],
+                &application,
+                33,
+            )
+            .unwrap()
+            .is_some()
+        );
+        let pair = current(10, 1, &[11, 12]);
+        let wide_destination = current(30, 2, &[10, 11, 12]);
+        assert!(
+            candidate_with_input_states(
+                &step,
+                &wide_destination,
+                [&left, &pair],
+                [10, 10],
+                &application,
+                34,
+            )
+            .unwrap()
+            .is_some()
+        );
+    }
+
+    #[test]
+    fn prepared_parent_domain_accepts_sources_and_internal_physical_legs() {
+        let source_a = current(10, 1, &[10]);
+        let source_b = current(10, 1, &[11]);
+        let source_c = current(10, 1, &[12]);
+        let composite_scalar = current(10, 1, &[10, 11]);
+        let auxiliary_pair = current(20, 1, &[10, 11]);
+
+        let partial = prepared_contact_orbit_transition_for_test(
+            partial_step(0, 1, 2, 35),
+            [10, 10],
+            digest(36),
+            application(),
+        );
+        assert!(
+            partial
+                .accepts_parent_domain([&source_a, &source_b])
+                .unwrap()
+        );
+        assert!(
+            partial
+                .accepts_parent_domain([&composite_scalar, &source_c])
+                .unwrap()
+        );
+        for parents in [[&source_a, &source_b], [&composite_scalar, &source_c]] {
+            assert_eq!(
+                partial.accepts_parent_domain(parents).unwrap(),
+                partial
+                    .accepts_parent_topology_domain(
+                        parents.map(ContactOrbitParentTopologyDomain::from_current_key),
+                    )
+                    .unwrap(),
+                "query-local and process-global topology admission diverged"
+            );
+        }
+
+        let final_transition = prepared_contact_orbit_transition_for_test(
+            final_step(&[0, 1], &[2], 3, 37, [0, 0, 0, 0]),
+            [20, 10],
+            digest(38),
+            application(),
+        );
+        assert!(
+            final_transition
+                .accepts_parent_domain([&auxiliary_pair, &source_c])
+                .unwrap()
+        );
+
+        let mut ambiguous_step = partial_step(0, 1, 2, 39);
+        ambiguous_step.physical_leg_equivalence_classes = vec![0, 1, 2, 3];
+        let ambiguous = prepared_contact_orbit_transition_for_test(
+            ambiguous_step,
+            [10, 10],
+            digest(40),
+            application(),
+        );
+        assert!(
+            ambiguous
+                .accepts_parent_domain([&source_a, &source_b])
+                .unwrap_err()
+                .to_string()
+                .contains("mapping is ambiguous")
+        );
+    }
+
+    #[test]
+    fn certified_four_identical_scalar_channels_keep_assignment_multiplicity() {
+        let left = current(1, 1, &[10]);
+        let right = current(1, 1, &[11]);
+        let destination = current(2, 2, &[10, 11]);
+        let application = application();
+        let forward_steps = [
+            partial_step(0, 1, 2, 20),
+            partial_step(0, 2, 1, 21),
+            partial_step(0, 3, 1, 22),
+        ];
+        let reverse_steps = [
+            partial_step(1, 0, 2, 30),
+            partial_step(2, 0, 1, 31),
+            partial_step(3, 0, 1, 32),
+        ];
+        let candidates = [
+            (
+                0_u32,
+                Some(candidate(
+                    &forward_steps[0],
+                    &destination,
+                    [&left, &right],
+                    &application,
+                    40,
+                )),
+            ),
+            (
+                1_u32,
+                Some(candidate(
+                    &reverse_steps[0],
+                    &destination,
+                    [&right, &left],
+                    &application,
+                    41,
+                )),
+            ),
+            (
+                2_u32,
+                Some(candidate(
+                    &forward_steps[1],
+                    &destination,
+                    [&left, &right],
+                    &application,
+                    42,
+                )),
+            ),
+            (
+                3_u32,
+                Some(candidate(
+                    &reverse_steps[1],
+                    &destination,
+                    [&right, &left],
+                    &application,
+                    43,
+                )),
+            ),
+            (
+                4_u32,
+                Some(candidate(
+                    &forward_steps[2],
+                    &destination,
+                    [&left, &right],
+                    &application,
+                    44,
+                )),
+            ),
+            (
+                5_u32,
+                Some(candidate(
+                    &reverse_steps[2],
+                    &destination,
+                    [&right, &left],
+                    &application,
+                    45,
+                )),
+            ),
+        ];
+        assert_eq!(
+            candidates
+                .iter()
+                .map(|(_, value)| value.unwrap().group)
+                .collect::<std::collections::BTreeSet<_>>()
+                .len(),
+            1,
+        );
+        assert_eq!(
+            selected_contact_orbit_owner_tokens(candidates).unwrap(),
+            vec![0],
+        );
+
+        let singles = [
+            current(3, 3, &[10]),
+            current(3, 3, &[11]),
+            current(3, 3, &[12]),
+        ];
+        let pairs = [
+            current(4, 4, &[11, 12]),
+            current(4, 4, &[10, 12]),
+            current(4, 4, &[10, 11]),
+        ];
+        let final_destination = current(5, 5, &[10, 11, 12]);
+        let final_forward = final_step(&[3], &[1, 2], 0, 60, [0, 0, 0, 0]);
+        let final_reverse = final_step(&[1, 2], &[3], 0, 70, [0, 0, 0, 0]);
+        let final_candidates = singles
+            .iter()
+            .zip(pairs.iter())
+            .enumerate()
+            .flat_map(|(index, (single, pair))| {
+                let index = u32::try_from(index).unwrap();
+                [
+                    (
+                        2 * index,
+                        Some(candidate(
+                            &final_forward,
+                            &final_destination,
+                            [single, pair],
+                            &application,
+                            80 + index as u8,
+                        )),
+                    ),
+                    (
+                        2 * index + 1,
+                        Some(candidate(
+                            &final_reverse,
+                            &final_destination,
+                            [pair, single],
+                            &application,
+                            90 + index as u8,
+                        )),
+                    ),
+                ]
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(
+            final_candidates[0].1.unwrap().group,
+            final_candidates[1].1.unwrap().group
+        );
+        assert_eq!(
+            final_candidates[2].1.unwrap().group,
+            final_candidates[3].1.unwrap().group
+        );
+        assert_eq!(
+            final_candidates[4].1.unwrap().group,
+            final_candidates[5].1.unwrap().group
+        );
+        assert_ne!(
+            final_candidates[0].1.unwrap().group,
+            final_candidates[2].1.unwrap().group
+        );
+        assert_ne!(
+            final_candidates[0].1.unwrap().group,
+            final_candidates[4].1.unwrap().group
+        );
+        assert_ne!(
+            final_candidates[2].1.unwrap().group,
+            final_candidates[4].1.unwrap().group
+        );
+        let forward_selection =
+            selected_contact_orbit_owner_tokens(final_candidates.iter().copied()).unwrap();
+        let reverse_selection =
+            selected_contact_orbit_owner_tokens(final_candidates.iter().rev().copied()).unwrap();
+        assert_eq!(forward_selection, reverse_selection);
+        assert_eq!(forward_selection.len(), 3,);
+    }
+
+    #[test]
+    fn five_leg_auxiliary_partitions_keep_physical_assignment_multiplicity() {
+        let application = application();
+        let destination = current(40, 4, &[10, 11, 12, 13]);
+        let first_left = current(20, 2, &[10, 11]);
+        let first_right = current(30, 2, &[12, 13]);
+        let second_left = current(20, 2, &[10, 12]);
+        let second_right = current(30, 2, &[11, 13]);
+        let forward_step = five_leg_final_step(&[0, 1], &[2, 3], 4, 100);
+        let mirror_step = five_leg_final_step(&[2, 3], &[0, 1], 4, 101);
+
+        let first = candidate_with_input_states(
+            &forward_step,
+            &destination,
+            [&first_left, &first_right],
+            [20, 30],
+            &application,
+            102,
+        )
+        .unwrap()
+        .unwrap();
+        let first_mirror = candidate_with_input_states(
+            &mirror_step,
+            &destination,
+            [&first_right, &first_left],
+            [30, 20],
+            &application,
+            103,
+        )
+        .unwrap()
+        .unwrap();
+        let second = candidate_with_input_states(
+            &forward_step,
+            &destination,
+            [&second_left, &second_right],
+            [20, 30],
+            &application,
+            104,
+        )
+        .unwrap()
+        .unwrap();
+
+        assert_eq!(first.group, first_mirror.group);
+        assert_ne!(first.group, second.group);
+        assert_eq!(
+            selected_contact_orbit_owner_tokens([
+                (0_u32, Some(first)),
+                (1_u32, Some(first_mirror)),
+                (2_u32, Some(second)),
+            ])
+            .unwrap(),
+            vec![0, 2],
+        );
+    }
+
+    #[test]
+    fn certified_owner_preserves_concrete_destination_across_contact_stages() {
+        let application = application();
+        let partial = partial_step(0, 1, 2, 10);
+        let first_left = topology_current(1, 1, &[10]);
+        let first_right = topology_current(1, 1, &[11]);
+        let first_destination = topology_current(2, 2, &[10, 11]);
+        let second_left = topology_current(1, 1, &[20]);
+        let second_right = topology_current(1, 1, &[21]);
+        let second_destination = topology_current(2, 2, &[20, 21]);
+        let first = candidate(
+            &partial,
+            &first_destination,
+            [&first_left, &first_right],
+            &application,
+            12,
+        );
+        let second = candidate(
+            &partial,
+            &second_destination,
+            [&second_left, &second_right],
+            &application,
+            12,
+        );
+
+        assert_ne!(first.group, second.group);
+        assert_ne!(first.rank, second.rank);
+        assert_eq!(
+            selected_contact_orbit_owner_tokens([(0_u32, Some(first)), (1_u32, Some(second)),])
+                .unwrap(),
+            vec![0, 1],
+        );
+
+        let final_step = final_step(&[0], &[1, 2], 3, 20, [0, 0, 0, 0]);
+        let first_pair = topology_current(3, 3, &[11, 12]);
+        let first_final_destination = topology_current(4, 4, &[10, 11, 12]);
+        let second_pair = topology_current(3, 3, &[21, 22]);
+        let second_final_destination = topology_current(4, 4, &[20, 21, 22]);
+        let first_final = candidate(
+            &final_step,
+            &first_final_destination,
+            [&first_left, &first_pair],
+            &application,
+            22,
+        );
+        let second_final = candidate(
+            &final_step,
+            &second_final_destination,
+            [&second_left, &second_pair],
+            &application,
+            22,
+        );
+
+        assert_ne!(first_final.group, second_final.group);
+        assert_ne!(first_final.rank, second_final.rank);
+        assert_eq!(
+            selected_contact_orbit_owner_tokens([
+                (0_u32, Some(first_final)),
+                (1_u32, Some(second_final)),
+            ])
+            .unwrap(),
+            vec![0, 1],
+        );
+    }
+
+    #[test]
+    fn same_order_singleton_rows_collapse_partial_and_final_scalar_0012_aliases() {
+        let scalar0_left = current(10, 1, &[10]);
+        let scalar0_right = current(10, 1, &[11]);
+        let partial_destination = current(20, 2, &[10, 11]);
+        let application = application();
+        let mut partial_forward = partial_step(0, 1, 2, 50);
+        partial_forward.physical_leg_equivalence_classes = vec![0, 0, 1, 2];
+        let mut partial_reverse = partial_step(1, 0, 2, 51);
+        partial_reverse.physical_leg_equivalence_classes = vec![0, 0, 1, 2];
+        let partial_forward = candidate(
+            &partial_forward,
+            &partial_destination,
+            [&scalar0_left, &scalar0_right],
+            &application,
+            52,
+        );
+        let partial_reverse = candidate(
+            &partial_reverse,
+            &partial_destination,
+            [&scalar0_right, &scalar0_left],
+            &application,
+            53,
+        );
+        assert_eq!(partial_forward.group, partial_reverse.group);
+        assert_eq!(
+            selected_contact_orbit_owner_tokens([
+                (0_u32, Some(partial_forward)),
+                (1_u32, Some(partial_reverse)),
+            ])
+            .unwrap(),
+            vec![0],
+        );
+        assert_eq!(
+            selected_contact_orbit_owner_tokens([
+                (1_u32, Some(partial_reverse)),
+                (0_u32, Some(partial_forward)),
+            ])
+            .unwrap(),
+            vec![0],
+        );
+
+        let pair = current(20, 2, &[10, 11]);
+        let scalar1 = current(30, 3, &[12]);
+        let final_destination = current(40, 4, &[10, 11, 12]);
+        let final_forward = final_step(&[0, 1], &[2], 3, 54, [0, 0, 1, 2]);
+        let final_reverse = final_step(&[2], &[0, 1], 3, 55, [0, 0, 1, 2]);
+        let final_forward = candidate(
+            &final_forward,
+            &final_destination,
+            [&pair, &scalar1],
+            &application,
+            56,
+        );
+        let final_reverse = candidate(
+            &final_reverse,
+            &final_destination,
+            [&scalar1, &pair],
+            &application,
+            57,
+        );
+        assert_eq!(final_forward.group, final_reverse.group);
+        // The concrete rank orders the source-first mirror traversal first;
+        // owner choice therefore stays deterministic independently of insertion.
+        assert_eq!(
+            selected_contact_orbit_owner_tokens([
+                (0_u32, Some(final_forward)),
+                (1_u32, Some(final_reverse)),
+            ])
+            .unwrap(),
+            vec![1],
+        );
+        assert_eq!(
+            selected_contact_orbit_owner_tokens([
+                (1_u32, Some(final_reverse)),
+                (0_u32, Some(final_forward)),
+            ])
+            .unwrap(),
+            vec![1],
+        );
+    }
+
+    #[test]
+    fn owner_current_projection_retains_non_traversal_physics() {
+        let destination = current(2, 2, &[10, 11]);
+        let base = ContactOrbitCurrentPhysics::from_current(&destination);
+        let mut changed = base;
+        changed.current_state_template_id = 3;
+        assert_ne!(base, changed);
+        changed = base;
+        changed.dynamic_lc_color_state_id = DynamicLCColorStateId::from_interner(3);
+        assert_ne!(base, changed);
+        changed = base;
+        changed.recurrence_strategy = RecurrenceStrategy::TopologyReplay;
+        assert_ne!(base, changed);
+        changed = base;
+        changed.spin_state_class = 1;
+        assert_ne!(base, changed);
+        let different_flavour = [3];
+        changed = base;
+        changed.flavour_flow = &different_flavour;
+        assert_ne!(base, changed);
+        changed = base;
+        changed.quantum_number_flow_id = 1;
+        assert_ne!(base, changed);
+        let different_orders = [1];
+        changed = base;
+        changed.coupling_orders = &different_orders;
+        assert_ne!(base, changed);
+        changed = base;
+        changed.propagator_template_id = Some(1);
+        assert_ne!(base, changed);
+
+        let source_a = topology_source(10, 7);
+        let source_b = topology_source(20, 8);
+        assert_ne!(
+            ContactOrbitCurrentPhysics::from_current(&source_a),
+            ContactOrbitCurrentPhysics::from_current(&source_b),
+        );
+    }
+
+    #[test]
+    fn owner_group_quotients_application_metadata_but_keeps_physics_boundaries() {
+        let left = current(1, 1, &[10]);
+        let right = current(1, 1, &[11]);
+        let destination = current(2, 2, &[10, 11]);
+        let step = partial_step(0, 1, 2, 10);
+        let base_application = application();
+        let base = candidate(&step, &destination, [&left, &right], &base_application, 12);
+
+        let mut traversal_application = base_application.clone();
+        traversal_application.transition_equivalence_class = "alternate-traversal".into();
+        traversal_application.quantum_semantic_digest = digest(20);
+        traversal_application.color_contraction_semantic_digest = digest(21);
+        traversal_application.color_witness_term_id = LCColorWitnessTermId::new(4, 1);
+        traversal_application.color_witness_proof_digest = digest(22);
+        traversal_application.momentum_convention = vec![1, 0];
+        traversal_application.output_factor_source = 1;
+        traversal_application.evaluator_contract_kind = EvaluatorContractKind::Closure as u8;
+        traversal_application.evaluator_callable_kind =
+            EvaluatorCallableKind::RusticolTemplate as u8;
+        traversal_application.evaluator_callable_signature = digest(23);
+        traversal_application.evaluator_input_layout = vec![13, 14];
+        traversal_application.evaluator_output_layout = vec![15];
+        traversal_application.evaluator_exact_expression_digests = vec![digest(24)];
+        traversal_application.evaluator_runtime_template =
+            Some("alternate-runtime-template".into());
+        traversal_application.output_projection_id = 9;
+        let traversal = candidate(
+            &step,
+            &destination,
+            [&left, &right],
+            &traversal_application,
+            13,
+        );
+
+        assert_eq!(base.group, traversal.group);
+        assert_ne!(base.rank, traversal.rank);
+        let forward =
+            selected_contact_orbit_owner_tokens([(0_u32, Some(base)), (1_u32, Some(traversal))])
+                .unwrap();
+        let reverse =
+            selected_contact_orbit_owner_tokens([(1_u32, Some(traversal)), (0_u32, Some(base))])
+                .unwrap();
+        assert_eq!(forward, reverse);
+        assert_eq!(forward.len(), 1);
+
+        let mut redistributed_factors = base_application.clone();
+        redistributed_factors.transition_exact_factor = exact(2);
+        redistributed_factors.color_exact_factor = exact(3);
+        redistributed_factors.witness_exact_factor = exact_ratio(1, 6);
+        let redistributed = candidate(
+            &step,
+            &destination,
+            [&left, &right],
+            &redistributed_factors,
+            12,
+        );
+        assert_eq!(base.group, redistributed.group);
+        assert_ne!(base.rank, redistributed.rank);
+        let forward = selected_contact_orbit_owner_tokens([
+            (0_u32, Some(base)),
+            (1_u32, Some(redistributed)),
+        ])
+        .unwrap();
+        let reverse = selected_contact_orbit_owner_tokens([
+            (1_u32, Some(redistributed)),
+            (0_u32, Some(base)),
+        ])
+        .unwrap();
+        assert_eq!(forward, reverse);
+        assert_eq!(forward.len(), 1);
+
+        let mut different_product = redistributed_factors.clone();
+        different_product.witness_exact_factor = exact_ratio(1, 5);
+        assert_ne!(
+            base.group,
+            candidate(&step, &destination, [&left, &right], &different_product, 12,).group,
+        );
+        let mut different_binding = base_application.clone();
+        different_binding.binding_coupling = exact(2);
+        assert_ne!(
+            base.group,
+            candidate(&step, &destination, [&left, &right], &different_binding, 12,).group,
+        );
+        let mut different_exchange = base_application.clone();
+        different_exchange.input_exchange_factor = Some(exact(-1));
+        assert_ne!(
+            base.group,
+            candidate(
+                &step,
+                &destination,
+                [&left, &right],
+                &different_exchange,
+                12,
+            )
+            .group,
+        );
+
+        let mut different_parameters = base_application.clone();
+        different_parameters.coupling_parameter_ids = vec![99];
+        assert_ne!(
+            base.group,
+            candidate(
+                &step,
+                &destination,
+                [&left, &right],
+                &different_parameters,
+                12,
+            )
+            .group,
+        );
+
+        let mut certificate_row = step.clone();
+        certificate_row.certificate_id = 1;
+        assert_ne!(
+            base.group,
+            candidate(
+                &certificate_row,
+                &destination,
+                [&left, &right],
+                &base_application,
+                12,
+            )
+            .group,
+        );
+        let mut certificate = step.clone();
+        certificate.certificate_semantic_digest = digest(30);
+        assert_ne!(
+            base.group,
+            candidate(
+                &certificate,
+                &destination,
+                [&left, &right],
+                &base_application,
+                12,
+            )
+            .group,
+        );
+        let mut equivalence = step.clone();
+        equivalence.physical_leg_equivalence_classes[step.result_leg as usize] = 1;
+        assert_ne!(
+            base.group,
+            candidate(
+                &equivalence,
+                &destination,
+                [&left, &right],
+                &base_application,
+                12,
+            )
+            .group,
+        );
+        let mut parent_equivalence = step.clone();
+        parent_equivalence.physical_leg_equivalence_classes[1] = 1;
+        assert!(
+            candidate_with_input_states(
+                &parent_equivalence,
+                &destination,
+                [&left, &right],
+                [
+                    left.current_state_template_id(),
+                    right.current_state_template_id(),
+                ],
+                &base_application,
+                12,
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("mapping is ambiguous"),
+        );
+        let mut evaluator_class = step.clone();
+        evaluator_class.evaluator_class = "different-contact-class".into();
+        assert_ne!(
+            base.group,
+            candidate(
+                &evaluator_class,
+                &destination,
+                [&left, &right],
+                &base_application,
+                12,
+            )
+            .group,
+        );
+
+        let mut invalid_reconstruction = step.clone();
+        invalid_reconstruction.certificate_reconstruction_factor = exact(2);
+        assert!(
+            contact_orbit_owner_candidate(
+                Some(&invalid_reconstruction),
+                &destination,
+                [&left, &right],
+                [
+                    left.current_state_template_id(),
+                    right.current_state_template_id()
+                ],
+                &base_application,
+                digest(12),
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("exact unit reconstruction")
+        );
+        invalid_reconstruction.certificate_reconstruction_factor = ExactComplexRational::ONE;
+        invalid_reconstruction.step_reconstruction_factor = exact(2);
+        assert!(
+            contact_orbit_owner_candidate(
+                Some(&invalid_reconstruction),
+                &destination,
+                [&left, &right],
+                [
+                    left.current_state_template_id(),
+                    right.current_state_template_id()
+                ],
+                &base_application,
+                digest(12),
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("exact unit reconstruction")
+        );
+
+        let mut changed_stage = base;
+        changed_stage.group.stage = ContactOrbitStage::Final;
+        assert_ne!(base.group, changed_stage.group);
+        let mut changed_output_source = base;
+        changed_output_source
+            .group
+            .output_source_particle_equivalence_class = Some(2);
+        assert_ne!(base.group, changed_output_source.group);
+    }
+
+    #[test]
+    fn passthrough_rank_conflict_duplicate_token_and_capacity_fail_closed() {
+        assert_eq!(
+            selected_contact_orbit_owner_tokens([(7_u32, None)]).unwrap(),
+            vec![7],
+        );
+
+        let left = current(1, 1, &[10]);
+        let right = current(1, 1, &[11]);
+        let destination = current(2, 2, &[10, 11]);
+        let application = application();
+        let step = partial_step(0, 1, 2, 10);
+        let duplicate = candidate(&step, &destination, [&left, &right], &application, 12);
+        let error = selected_contact_orbit_owner_tokens([
+            (0_u32, Some(duplicate)),
+            (1_u32, Some(duplicate)),
+        ])
+        .unwrap_err();
+        assert!(error.to_string().contains("conflicting exact rank"));
+
+        let mut different_group_step = step.clone();
+        different_group_step.evaluator_class = "different-contact-class".into();
+        let different_group = candidate(
+            &different_group_step,
+            &destination,
+            [&left, &right],
+            &application,
+            13,
+        );
+        let error = selected_contact_orbit_owner_tokens([
+            (0_u32, Some(duplicate)),
+            (0_u32, Some(different_group)),
+        ])
+        .unwrap_err();
+        assert!(error.to_string().contains("duplicate tokens"));
+
+        struct ImpossibleExactSize<'a> {
+            remaining: usize,
+            marker: std::marker::PhantomData<ContactOrbitOwnerCandidate<'a>>,
+        }
+        impl<'a> Iterator for ImpossibleExactSize<'a> {
+            type Item = (u64, Option<ContactOrbitOwnerCandidate<'a>>);
+
+            fn next(&mut self) -> Option<Self::Item> {
+                None
+            }
+
+            fn size_hint(&self) -> (usize, Option<usize>) {
+                (self.remaining, Some(self.remaining))
+            }
+        }
+        impl ExactSizeIterator for ImpossibleExactSize<'_> {
+            fn len(&self) -> usize {
+                self.remaining
+            }
+        }
+        let error = selected_contact_orbit_owner_tokens(ImpossibleExactSize {
+            remaining: usize::MAX,
+            marker: std::marker::PhantomData,
+        })
+        .unwrap_err();
+        assert!(error.to_string().contains("byte size overflows usize"));
+
+        struct UnderreportedExactSize {
+            emitted: u8,
+        }
+        impl Iterator for UnderreportedExactSize {
+            type Item = (u64, Option<ContactOrbitOwnerCandidate<'static>>);
+
+            fn next(&mut self) -> Option<Self::Item> {
+                if self.emitted == 2 {
+                    return None;
+                }
+                let token = u64::from(self.emitted);
+                self.emitted += 1;
+                Some((token, None))
+            }
+
+            fn size_hint(&self) -> (usize, Option<usize>) {
+                (1, Some(1))
+            }
+        }
+        impl ExactSizeIterator for UnderreportedExactSize {
+            fn len(&self) -> usize {
+                1
+            }
+        }
+        let error =
+            selected_contact_orbit_owner_tokens(UnderreportedExactSize { emitted: 0 }).unwrap_err();
+        assert!(error.to_string().contains("exceeded its declared length"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/diagnostic.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/diagnostic.rs
new file mode 100644
index 0000000000..4be1738db7
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/diagnostic.rs
@@ -0,0 +1,318 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Feature-only construction observer used to diagnose compact/established
+//! recurrence disagreements.  Nothing in this module is compiled into default
+//! or release builds and none of its records participate in artifact identity.
+
+use std::cell::RefCell;
+use std::collections::BTreeSet;
+
+use super::{ExactComplexRational, SemanticDigest, SourceStateAssignment};
+use crate::{RusticolError, RusticolResult};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[doc(hidden)]
+pub struct ConstructionTransitionDiagnosticRowV1 {
+    pub materialized_sector_id: Option<u32>,
+    pub output_current_digest: SemanticDigest,
+    pub ordered_parent_digests: [SemanticDigest; 2],
+    pub transition_template_id: u32,
+    pub transition_semantic_digest: SemanticDigest,
+    pub evaluator_binding_semantic_digest: SemanticDigest,
+    pub result_state_template_id: u32,
+    pub quantum_flow_witness_id: u32,
+    pub quantum_semantic_digest: SemanticDigest,
+    pub color_contraction_template_id: u32,
+    pub color_witness_ordinal: u32,
+    pub color_witness_proof_digest: SemanticDigest,
+    pub output_projection_id: u32,
+    pub transition_factor: ExactComplexRational,
+    pub contraction_factor: ExactComplexRational,
+    pub output_factor: ExactComplexRational,
+    pub exchange_factor: ExactComplexRational,
+    pub witness_factor: ExactComplexRational,
+    pub reversal_mask: u8,
+    pub reversal_factor: ExactComplexRational,
+    pub candidate_factor: ExactComplexRational,
+    pub aggregate_factor_after: ExactComplexRational,
+    pub parent_reflection_proof_digests: [Option<SemanticDigest>; 2],
+    pub parent_reflection_phases: [Option<ExactComplexRational>; 2],
+    pub local_reflection_proof_digest: Option<SemanticDigest>,
+    pub local_reflection_phase: Option<ExactComplexRational>,
+    pub result_reflection_proof_digest: Option<SemanticDigest>,
+    pub result_reflection_phase: Option<ExactComplexRational>,
+    pub output_color_orientation: String,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct ConstructionDiagnosticSelectionV1 {
+    pub(crate) public_flow_id: u32,
+    pub(crate) public_helicities: Vec<i32>,
+}
+
+pub(crate) fn representative_source_states_for_public_helicities(
+    representative_to_public: &[u32],
+    public_helicities: &[i32],
+    mut state_index_for_public_helicity: impl FnMut(u32, i32) -> RusticolResult<u32>,
+) -> RusticolResult<Vec<SourceStateAssignment>> {
+    if representative_to_public.len() != public_helicities.len() {
+        return Err(RusticolError::integrity(
+            "transition diagnostic replay permutation and public-helicity axis have different sizes",
+        ));
+    }
+    let mut seen_public_slots = vec![false; public_helicities.len()];
+    representative_to_public
+        .iter()
+        .copied()
+        .enumerate()
+        .map(|(representative_slot, public_slot)| {
+            let public_index = usize::try_from(public_slot).map_err(|_| {
+                RusticolError::integrity("transition diagnostic public source slot exceeds usize")
+            })?;
+            let seen = seen_public_slots.get_mut(public_index).ok_or_else(|| {
+                RusticolError::integrity(
+                    "transition diagnostic replay permutation is out of bounds",
+                )
+            })?;
+            if *seen {
+                return Err(RusticolError::integrity(
+                    "transition diagnostic replay permutation repeats a public source slot",
+                ));
+            }
+            *seen = true;
+            let representative_slot = u32::try_from(representative_slot).map_err(|_| {
+                RusticolError::integrity(
+                    "transition diagnostic representative source slot exceeds u32",
+                )
+            })?;
+            let state_index = state_index_for_public_helicity(
+                representative_slot,
+                public_helicities[public_index],
+            )?;
+            Ok(SourceStateAssignment::new(representative_slot, state_index))
+        })
+        .collect()
+}
+
+#[derive(Debug)]
+struct ConstructionDiagnosticObserverV1 {
+    rows: Vec<ConstructionTransitionDiagnosticRowV1>,
+    selection: Option<ConstructionDiagnosticSelectionV1>,
+    live_current_digests: Option<BTreeSet<SemanticDigest>>,
+    active_materialized_sector_id: Option<u32>,
+}
+
+thread_local! {
+    static TRANSITION_OBSERVER: RefCell<Option<ConstructionDiagnosticObserverV1>> =
+        const { RefCell::new(None) };
+}
+
+pub(crate) fn begin_transition_diagnostic_observation(
+    selection: Option<ConstructionDiagnosticSelectionV1>,
+) -> RusticolResult<()> {
+    TRANSITION_OBSERVER.with(|slot| {
+        let mut slot = slot.borrow_mut();
+        if slot.is_some() {
+            return Err(RusticolError::integrity(
+                "recurrence transition diagnostic observation is already active",
+            ));
+        }
+        *slot = Some(ConstructionDiagnosticObserverV1 {
+            rows: Vec::new(),
+            selection,
+            live_current_digests: None,
+            active_materialized_sector_id: None,
+        });
+        Ok(())
+    })
+}
+
+pub(crate) fn transition_diagnostic_observation_active() -> bool {
+    TRANSITION_OBSERVER.with(|slot| slot.borrow().is_some())
+}
+
+#[allow(dead_code)]
+pub(crate) fn observe_transition_diagnostic(mut row: ConstructionTransitionDiagnosticRowV1) {
+    TRANSITION_OBSERVER.with(|slot| {
+        if let Some(observer) = slot.borrow_mut().as_mut() {
+            row.materialized_sector_id = observer.active_materialized_sector_id;
+            observer.rows.push(row);
+        }
+    });
+}
+
+pub(crate) fn with_transition_diagnostic_materialized_sector<T>(
+    materialized_sector_id: Option<u32>,
+    build: impl FnOnce() -> RusticolResult<T>,
+) -> RusticolResult<T> {
+    let activated = TRANSITION_OBSERVER.with(|slot| {
+        let mut slot = slot.borrow_mut();
+        let Some(observer) = slot.as_mut() else {
+            return Ok(false);
+        };
+        let materialized_sector_id = materialized_sector_id.ok_or_else(|| {
+            RusticolError::integrity(
+                "transition diagnostic construction group is not one materialized sector",
+            )
+        })?;
+        if observer
+            .active_materialized_sector_id
+            .replace(materialized_sector_id)
+            .is_some()
+        {
+            return Err(RusticolError::integrity(
+                "transition diagnostic materialized-sector context is already active",
+            ));
+        }
+        Ok(true)
+    })?;
+    let result = build();
+    if activated {
+        TRANSITION_OBSERVER.with(|slot| {
+            if let Some(observer) = slot.borrow_mut().as_mut() {
+                observer.active_materialized_sector_id = None;
+            }
+        });
+    }
+    result
+}
+
+pub(crate) fn retain_materialized_sector_rows<T>(
+    rows: Vec<T>,
+    materialized_sector_id: u32,
+    sector_of: impl Fn(&T) -> Option<u32>,
+) -> Vec<T> {
+    rows.into_iter()
+        .filter(|row| sector_of(row) == Some(materialized_sector_id))
+        .collect()
+}
+
+pub(crate) fn transition_diagnostic_selection() -> Option<ConstructionDiagnosticSelectionV1> {
+    TRANSITION_OBSERVER.with(|slot| {
+        slot.borrow()
+            .as_ref()
+            .and_then(|observer| observer.selection.clone())
+    })
+}
+
+pub(crate) fn observe_transition_live_current_digests(
+    digests: BTreeSet<SemanticDigest>,
+) -> RusticolResult<()> {
+    TRANSITION_OBSERVER.with(|slot| {
+        let mut slot = slot.borrow_mut();
+        let observer = slot.as_mut().ok_or_else(|| {
+            RusticolError::integrity("recurrence transition diagnostic observation was not active")
+        })?;
+        if observer.live_current_digests.replace(digests).is_some() {
+            return Err(RusticolError::integrity(
+                "recurrence transition diagnostic live slice was recorded twice",
+            ));
+        }
+        Ok(())
+    })
+}
+
+pub(crate) fn take_transition_diagnostic_observation() -> RusticolResult<(
+    Vec<ConstructionTransitionDiagnosticRowV1>,
+    Option<BTreeSet<SemanticDigest>>,
+)> {
+    TRANSITION_OBSERVER.with(|slot| {
+        let observer = slot.borrow_mut().take().ok_or_else(|| {
+            RusticolError::integrity("recurrence transition diagnostic observation was not active")
+        })?;
+        Ok((observer.rows, observer.live_current_digests))
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn state_index_for_public_helicity(
+        _source_slot: u32,
+        public_helicity: i32,
+    ) -> RusticolResult<u32> {
+        match public_helicity {
+            -1 => Ok(0),
+            1 => Ok(1),
+            value => Err(RusticolError::integrity(format!(
+                "test source has no state for public helicity {value}"
+            ))),
+        }
+    }
+
+    #[test]
+    fn diagnostic_identity_replay_keeps_public_helicity_assignments() {
+        let assignments = representative_source_states_for_public_helicities(
+            &[0, 1],
+            &[-1, 1],
+            state_index_for_public_helicity,
+        )
+        .unwrap();
+        assert_eq!(
+            assignments,
+            [
+                SourceStateAssignment::new(0, 0),
+                SourceStateAssignment::new(1, 1)
+            ]
+        );
+    }
+
+    #[test]
+    fn diagnostic_nonidentity_replay_transports_opposite_public_helicities() {
+        // The two representative slots have the same state contract.  The
+        // composed replay map swaps them, so representative state ancestry
+        // must be selected from the opposite public coordinate.
+        let assignments = representative_source_states_for_public_helicities(
+            &[1, 0],
+            &[-1, 1],
+            state_index_for_public_helicity,
+        )
+        .unwrap();
+        assert_eq!(
+            assignments,
+            [
+                SourceStateAssignment::new(0, 1),
+                SourceStateAssignment::new(1, 0)
+            ]
+        );
+    }
+
+    #[test]
+    fn diagnostic_lane_filter_keeps_selected_duplicates_without_digest_leakage() {
+        let shared_digest = "same-semantic-current";
+        let rows = vec![
+            (shared_digest, 6, 0),
+            (shared_digest, 8, 0),
+            (shared_digest, 8, 1),
+        ];
+        let selected = retain_materialized_sector_rows(rows, 8, |row| Some(row.1));
+        assert_eq!(selected, [(shared_digest, 8, 0), (shared_digest, 8, 1)]);
+    }
+
+    #[test]
+    fn diagnostic_observer_active_query_tracks_scope() {
+        assert!(!transition_diagnostic_observation_active());
+        begin_transition_diagnostic_observation(None).unwrap();
+        assert!(transition_diagnostic_observation_active());
+        take_transition_diagnostic_observation().unwrap();
+        assert!(!transition_diagnostic_observation_active());
+    }
+
+    #[test]
+    fn diagnostic_lane_context_fails_closed_and_resets_after_build_error() {
+        begin_transition_diagnostic_observation(None).unwrap();
+        let nonsingleton = with_transition_diagnostic_materialized_sector(None, || Ok(()));
+        assert!(nonsingleton.is_err());
+
+        let failed: RusticolResult<()> =
+            with_transition_diagnostic_materialized_sector(Some(8), || {
+                Err(RusticolError::integrity(
+                    "injected diagnostic build failure",
+                ))
+            });
+        assert!(failed.is_err());
+        with_transition_diagnostic_materialized_sector(Some(6), || Ok(())).unwrap();
+        take_transition_diagnostic_observation().unwrap();
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_backend.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_backend.rs
new file mode 100644
index 0000000000..b1b5aa7cb6
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_backend.rs
@@ -0,0 +1,5063 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Direct-arena prepared executor ABI for compact recurrence schedules.
+//!
+//! This module deliberately does not depend on the eager runtime. Direct
+//! executors consume fixed-width recurrence rows and persistent split-complex
+//! arenas. They never receive a packed evaluator input or output buffer.
+
+use super::RecurrenceStrategy;
+use super::SemanticDigest;
+use super::direct_plan::{
+    DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE, DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+    DIRECT_NONE_U32, DirectClosureRow, DirectContributionRow, DirectCurrentDescriptor,
+    DirectExecutorRole, DirectFinalizationRow, DirectNodeKind, DirectRecurrencePlan,
+    DirectRowGroupDescriptor, DirectSourceRow,
+};
+pub use super::direct_plan::{
+    DirectResolvedSourceSelection, DirectSourceDispatchVariantDescriptor, DirectSourceEmbeddingRow,
+};
+use crate::direct_arena::{DirectArenaTrafficCounters, clear_split_active_range};
+pub use crate::direct_arena::{
+    DirectArenaView, DirectFactorView, DirectMomentumView, DirectParameterView,
+};
+use crate::{RusticolError, RusticolResult};
+use std::cell::RefCell;
+use std::collections::{BTreeMap, BTreeSet};
+use std::ffi::{c_int, c_void};
+use std::mem::size_of;
+use std::time::{Duration, Instant};
+
+pub const RECURRENCE_DIRECT_BACKEND_ABI: &str = "rusticol.recurrence-direct-backend.v1";
+
+pub const DIRECT_STATUS_OK: c_int = 0;
+
+thread_local! {
+    static DIRECT_EXECUTOR_ERROR_DETAIL: RefCell<Option<RusticolError>> = const { RefCell::new(None) };
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    static DIRECT_CURRENT_OBSERVATION: RefCell<Option<DirectCurrentObservation>> = const { RefCell::new(None) };
+}
+
+/// One test-only semantic-current observation from the authenticated direct
+/// runtime.  This is deliberately absent from release builds and public ABIs.
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct DirectObservedCurrentValue {
+    pub descriptor: super::direct_plan::DirectCurrentDescriptor,
+    /// Split-complex values in component-major, then point-major order.
+    pub values: Vec<(f64, f64)>,
+}
+
+/// Test-only capture of the current values produced for one exact direct-plan
+/// execution.  The two plan digests and selected sector bind the values to the
+/// authenticated schedule and query which produced them.
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct DirectCurrentObservation {
+    pub plan_semantic_digest: SemanticDigest,
+    pub runtime_layout_digest: SemanticDigest,
+    pub selected_sector_id: Option<u32>,
+    pub point_count: u32,
+    pub currents: BTreeMap<u32, DirectObservedCurrentValue>,
+    /// Representative amplitudes captured after closures and before replay
+    /// phase/multiplicity scaling, keyed by DirectPlan destination ID.
+    pub amplitudes_before_replay: BTreeMap<u32, Vec<(f64, f64)>>,
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+pub(crate) fn begin_direct_current_observation(
+    plan: &DirectRecurrencePlan,
+    selected_sector_id: Option<u32>,
+    point_count: u32,
+) -> RusticolResult<()> {
+    if point_count == 0 {
+        return Err(RusticolError::invalid_argument(
+            "direct current observation requires at least one point",
+        ));
+    }
+    DIRECT_CURRENT_OBSERVATION.with(|slot| {
+        let mut slot = slot.borrow_mut();
+        if slot.is_some() {
+            return Err(RusticolError::invalid_argument(
+                "direct current observation is already active on this thread",
+            ));
+        }
+        *slot = Some(DirectCurrentObservation {
+            plan_semantic_digest: plan.semantic_digest(),
+            runtime_layout_digest: plan.runtime_layout_digest(),
+            selected_sector_id,
+            point_count,
+            currents: BTreeMap::new(),
+            amplitudes_before_replay: BTreeMap::new(),
+        });
+        Ok(())
+    })
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+pub(crate) fn take_direct_current_observation() -> RusticolResult<DirectCurrentObservation> {
+    DIRECT_CURRENT_OBSERVATION.with(|slot| {
+        slot.borrow_mut().take().ok_or_else(|| {
+            RusticolError::invalid_argument(
+                "direct current observation is not active on this thread",
+            )
+        })
+    })
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+fn direct_current_observation_active() -> bool {
+    DIRECT_CURRENT_OBSERVATION.with(|slot| slot.borrow().is_some())
+}
+
+#[cfg(not(any(test, feature = "on-the-fly-test-support")))]
+const fn direct_current_observation_active() -> bool {
+    false
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+pub(super) fn observe_direct_amplitudes_before_replay(
+    plan: &DirectRecurrencePlan,
+    selected_sector_id: Option<u32>,
+    workspace: &DirectWorkspace<'_>,
+    point_count: u32,
+) -> RusticolResult<()> {
+    let active = DIRECT_CURRENT_OBSERVATION.with(|slot| slot.borrow().is_some());
+    if !active {
+        return Ok(());
+    }
+    DIRECT_CURRENT_OBSERVATION.with(|slot| {
+        let mut slot = slot.borrow_mut();
+        let observation = slot.as_mut().ok_or_else(|| {
+            RusticolError::integrity("direct current observation disappeared before amplitudes")
+        })?;
+        if observation.plan_semantic_digest != plan.semantic_digest()
+            || observation.runtime_layout_digest != plan.runtime_layout_digest()
+            || observation.selected_sector_id != selected_sector_id
+            || observation.point_count != point_count
+        {
+            return Err(RusticolError::integrity(
+                "direct amplitude observation does not match this plan execution",
+            ));
+        }
+        let stride = workspace.point_stride as usize;
+        let active_points = point_count as usize;
+        for destination in plan.amplitude_destinations().iter().filter(|destination| {
+            selected_sector_id.is_none_or(|sector| destination.target_sector_id == sector)
+        }) {
+            let start = destination.id as usize * stride;
+            let end = start.checked_add(active_points).ok_or_else(|| {
+                RusticolError::integrity("direct amplitude observation range overflows usize")
+            })?;
+            let real = workspace.amplitude_re.get(start..end).ok_or_else(|| {
+                RusticolError::integrity("direct amplitude observation real range is absent")
+            })?;
+            let imag = workspace.amplitude_im.get(start..end).ok_or_else(|| {
+                RusticolError::integrity("direct amplitude observation imaginary range is absent")
+            })?;
+            observation.amplitudes_before_replay.insert(
+                destination.id,
+                real.iter().copied().zip(imag.iter().copied()).collect(),
+            );
+        }
+        Ok(())
+    })
+}
+
+/// Clear the synchronous detail channel before executing one direct plan.
+pub(crate) fn clear_direct_executor_error_detail() {
+    DIRECT_EXECUTOR_ERROR_DETAIL.with(|detail| *detail.borrow_mut() = None);
+}
+
+/// Preserve the first concrete callback failure across the narrow
+/// integer-status ABI.
+pub(crate) fn record_direct_executor_error_detail(detail: RusticolError) {
+    DIRECT_EXECUTOR_ERROR_DETAIL.with(|slot| {
+        let mut slot = slot.borrow_mut();
+        if slot.is_none() {
+            *slot = Some(detail);
+        }
+    });
+}
+
+fn take_direct_executor_error_detail() -> Option<RusticolError> {
+    DIRECT_EXECUTOR_ERROR_DETAIL.with(|detail| detail.borrow_mut().take())
+}
+
+pub type DirectSourceExecutor = unsafe extern "C" fn(
+    *const c_void,
+    DirectArenaView,
+    DirectMomentumView,
+    DirectParameterView,
+    DirectFactorView,
+    *const DirectSourceRow,
+    u32,
+    u32,
+) -> c_int;
+
+/// Runtime-helicity source dispatcher used only by all-flow-union plans.
+///
+/// Unlike a static source executor, this callable receives one authenticated
+/// resolved selection plus the process-bound variant and embedding catalogs.
+/// It fills every full source current before the remaining direct schedule is
+/// executed. The pointed-to tables and context must outlive the call.
+pub type DirectUnionSourceDispatchExecutor = unsafe extern "C" fn(
+    *const c_void,
+    DirectArenaView,
+    DirectMomentumView,
+    DirectParameterView,
+    DirectFactorView,
+    *const DirectSourceRow,
+    u32,
+    *const DirectSourceDispatchVariantDescriptor,
+    u32,
+    *const DirectSourceEmbeddingRow,
+    u32,
+    *const DirectResolvedSourceSelection,
+    u32,
+    u32,
+) -> c_int;
+
+/// Typed handle for one immutable all-flow-union source dispatcher.
+#[derive(Clone, Copy)]
+pub struct DirectUnionSourceDispatchHandle {
+    pub call: DirectUnionSourceDispatchExecutor,
+    pub context: *const c_void,
+}
+
+pub type DirectContributionExecutor = unsafe extern "C" fn(
+    *const c_void,
+    DirectArenaView,
+    DirectMomentumView,
+    DirectParameterView,
+    DirectFactorView,
+    *const DirectContributionRow,
+    u32,
+    u32,
+) -> c_int;
+
+pub(crate) type DirectContributionFanoutExecutor = for<'a> unsafe fn(
+    *const c_void,
+    DirectArenaView,
+    DirectMomentumView,
+    DirectParameterView,
+    DirectFactorView,
+    DirectContributionFanoutBatch<'a>,
+) -> RusticolResult<()>;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[allow(clippy::enum_variant_names)]
+pub(crate) enum DirectInteractionIntrinsicKind {
+    ColorOrderedThreeVector,
+    VectorWedgeVector,
+    AntisymmetricTensorVector,
+}
+
+pub(crate) type DirectInteractionBundleExecutor = for<'a> unsafe fn(
+    DirectInteractionExecutorContexts,
+    DirectArenaView,
+    DirectMomentumView,
+    DirectParameterView,
+    DirectFactorView,
+    DirectInteractionBundleBatch<'a>,
+) -> RusticolResult<()>;
+
+#[derive(Clone, Copy)]
+pub(crate) struct DirectInteractionExecutorContexts {
+    pub(crate) color: *const c_void,
+    pub(crate) vector_wedge_vector: *const c_void,
+    pub(crate) antisymmetric_tensor_vector: *const c_void,
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct DirectContributionFanoutExecutorHandle {
+    pub(crate) call: DirectContributionFanoutExecutor,
+    pub(crate) context: *const c_void,
+    pub(crate) destination_component_count: u32,
+    pub(crate) parent_component_counts: [u32; 2],
+    pub(crate) requires_two_momenta: bool,
+    pub(crate) required_parameter_count: u32,
+    pub(crate) interaction_kind: DirectInteractionIntrinsicKind,
+    pub(crate) interaction_call: Option<DirectInteractionBundleExecutor>,
+}
+
+pub type DirectFinalizationExecutor = unsafe extern "C" fn(
+    *const c_void,
+    DirectArenaView,
+    DirectMomentumView,
+    DirectParameterView,
+    DirectFactorView,
+    *const DirectFinalizationRow,
+    u32,
+    u32,
+) -> c_int;
+
+pub type DirectClosureExecutor = unsafe extern "C" fn(
+    *const c_void,
+    DirectArenaView,
+    DirectMomentumView,
+    DirectParameterView,
+    DirectFactorView,
+    *const DirectClosureRow,
+    u32,
+    u32,
+) -> c_int;
+
+#[derive(Clone, Copy)]
+pub enum DirectExecutorHandle {
+    Source {
+        call: DirectSourceExecutor,
+        context: *const c_void,
+    },
+    Contribution {
+        call: DirectContributionExecutor,
+        context: *const c_void,
+    },
+    Finalization {
+        call: DirectFinalizationExecutor,
+        context: *const c_void,
+    },
+    Closure {
+        call: DirectClosureExecutor,
+        context: *const c_void,
+    },
+}
+
+impl DirectExecutorHandle {
+    pub(crate) const fn role(self) -> DirectExecutorRole {
+        match self {
+            Self::Source { .. } => DirectExecutorRole::Source,
+            Self::Contribution { .. } => DirectExecutorRole::Contribution,
+            Self::Finalization { .. } => DirectExecutorRole::Finalization,
+            Self::Closure { .. } => DirectExecutorRole::Closure,
+        }
+    }
+}
+
+pub struct DirectExecutorCatalog {
+    handles: Box<[Option<DirectExecutorHandle>]>,
+    contribution_metadata: Box<[Option<DirectContributionExecutionMetadata>]>,
+    contribution_fanout: Box<[Option<DirectContributionFanoutExecutorHandle>]>,
+    packed_singleton_capable: bool,
+    plan_layout_digest: SemanticDigest,
+    direct_template_catalog_digest: SemanticDigest,
+}
+
+/// Authenticated contribution shape and row-local scalar dependency.
+///
+/// `exact_factor_is_kernel_input` is fail-closed. It is false only when the
+/// prepared template proves that the exact factor is applied exclusively by
+/// the destination adapter (currently Rusticol contribution intrinsics).
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct DirectContributionExecutionMetadata {
+    pub(crate) destination_component_count: u32,
+    pub(crate) exact_factor_is_kernel_input: bool,
+}
+
+impl DirectContributionExecutionMetadata {
+    pub(crate) fn new(
+        destination_component_count: u32,
+        exact_factor_is_kernel_input: bool,
+    ) -> RusticolResult<Self> {
+        if destination_component_count == 0 {
+            return Err(RusticolError::integrity(
+                "direct contribution executor has zero destination components",
+            ));
+        }
+        Ok(Self {
+            destination_component_count,
+            exact_factor_is_kernel_input,
+        })
+    }
+}
+
+impl DirectExecutorCatalog {
+    pub fn new(
+        plan: &DirectRecurrencePlan,
+        direct_template_catalog_digest: SemanticDigest,
+        handles: Vec<DirectExecutorHandle>,
+    ) -> RusticolResult<Self> {
+        let sparse_handles = handles.into_iter().map(Some).collect::<Vec<_>>();
+        let metadata = conservative_contribution_metadata(plan, sparse_handles.len())?;
+        Self::new_sparse_with_metadata(
+            plan,
+            direct_template_catalog_digest,
+            sparse_handles,
+            metadata,
+        )
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn new_sparse(
+        plan: &DirectRecurrencePlan,
+        direct_template_catalog_digest: SemanticDigest,
+        handles: Vec<Option<DirectExecutorHandle>>,
+    ) -> RusticolResult<Self> {
+        let metadata = conservative_contribution_metadata(plan, handles.len())?;
+        Self::new_sparse_with_metadata(plan, direct_template_catalog_digest, handles, metadata)
+    }
+
+    pub(crate) fn new_sparse_with_metadata(
+        plan: &DirectRecurrencePlan,
+        direct_template_catalog_digest: SemanticDigest,
+        handles: Vec<Option<DirectExecutorHandle>>,
+        contribution_metadata: Vec<Option<DirectContributionExecutionMetadata>>,
+    ) -> RusticolResult<Self> {
+        let contribution_fanout = vec![None; handles.len()];
+        Self::new_sparse_with_metadata_and_fanout(
+            plan,
+            direct_template_catalog_digest,
+            handles,
+            contribution_metadata,
+            contribution_fanout,
+        )
+    }
+
+    pub(crate) fn new_sparse_with_metadata_and_fanout(
+        plan: &DirectRecurrencePlan,
+        direct_template_catalog_digest: SemanticDigest,
+        handles: Vec<Option<DirectExecutorHandle>>,
+        contribution_metadata: Vec<Option<DirectContributionExecutionMetadata>>,
+        contribution_fanout: Vec<Option<DirectContributionFanoutExecutorHandle>>,
+    ) -> RusticolResult<Self> {
+        if handles.is_empty() {
+            return Err(RusticolError::invalid_argument(
+                "direct recurrence executor catalog must not be empty",
+            ));
+        }
+        if contribution_metadata.len() != handles.len() {
+            return Err(RusticolError::integrity(
+                "direct contribution metadata does not cover the executor catalog",
+            ));
+        }
+        if contribution_fanout.len() != handles.len() {
+            return Err(RusticolError::integrity(
+                "direct contribution fanout capabilities do not cover the executor catalog",
+            ));
+        }
+        for (executor_id, capability) in contribution_fanout.iter().copied().enumerate() {
+            let Some(capability) = capability else {
+                continue;
+            };
+            if !matches!(
+                handles[executor_id],
+                Some(DirectExecutorHandle::Contribution { .. })
+            ) {
+                return Err(RusticolError::integrity(format!(
+                    "direct fused fanout capability {executor_id} is not a loaded contribution executor"
+                )));
+            }
+            let metadata = contribution_metadata[executor_id].ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "direct fused fanout capability {executor_id} has no contribution metadata"
+                ))
+            })?;
+            if metadata.exact_factor_is_kernel_input
+                || metadata.destination_component_count != capability.destination_component_count
+            {
+                return Err(RusticolError::integrity(format!(
+                    "direct fused fanout capability {executor_id} is incompatible with its contribution metadata"
+                )));
+            }
+        }
+        if direct_template_catalog_digest != plan.direct_template_catalog_digest() {
+            return Err(RusticolError::integrity(format!(
+                "loaded direct-template catalog digest {direct_template_catalog_digest} does not match plan {}",
+                plan.direct_template_catalog_digest()
+            )));
+        }
+        let catalog = Self {
+            handles: handles.into_boxed_slice(),
+            contribution_metadata: contribution_metadata.into_boxed_slice(),
+            contribution_fanout: contribution_fanout.into_boxed_slice(),
+            packed_singleton_capable: false,
+            plan_layout_digest: plan.runtime_layout_digest(),
+            direct_template_catalog_digest,
+        };
+        catalog.validate_for_plan(plan)?;
+        Ok(catalog)
+    }
+
+    pub(crate) const fn packed_singleton_capable(&self) -> bool {
+        self.packed_singleton_capable
+    }
+
+    pub(crate) fn mark_packed_singleton_capable(mut self) -> Self {
+        self.packed_singleton_capable = true;
+        self
+    }
+
+    fn contribution_metadata(
+        &self,
+        executor_id: u32,
+    ) -> RusticolResult<DirectContributionExecutionMetadata> {
+        self.contribution_metadata
+            .get(executor_id as usize)
+            .and_then(|metadata| *metadata)
+            .ok_or_else(|| {
+                RusticolError::integrity(format!(
+                    "direct contribution executor {executor_id} has no authenticated execution metadata"
+                ))
+            })
+    }
+
+    fn contribution_fanout(
+        &self,
+        executor_id: u32,
+    ) -> Option<DirectContributionFanoutExecutorHandle> {
+        self.contribution_fanout
+            .get(executor_id as usize)
+            .and_then(|capability| *capability)
+    }
+
+    fn require(
+        &self,
+        executor_id: u32,
+        role: DirectExecutorRole,
+    ) -> RusticolResult<DirectExecutorHandle> {
+        let handle = self
+            .handles
+            .get(executor_id as usize)
+            .and_then(|handle| *handle)
+            .ok_or_else(|| {
+                RusticolError::evaluation(format!(
+                    "direct recurrence executor {executor_id} is not loaded"
+                ))
+            })?;
+        if handle.role() != role {
+            return Err(RusticolError::integrity(format!(
+                "direct recurrence executor {executor_id} has role {:?}, expected {role:?}",
+                handle.role()
+            )));
+        }
+        Ok(handle)
+    }
+
+    fn validate_for_plan(&self, plan: &DirectRecurrencePlan) -> RusticolResult<()> {
+        if self.handles.len() != plan.direct_executor_count() as usize {
+            return Err(RusticolError::integrity(format!(
+                "direct recurrence executor catalog has {} entries, expected {}",
+                self.handles.len(),
+                plan.direct_executor_count()
+            )));
+        }
+        if self.contribution_metadata.len() != self.handles.len() {
+            return Err(RusticolError::integrity(
+                "direct contribution metadata has the wrong executor domain",
+            ));
+        }
+        if self.contribution_fanout.len() != self.handles.len() {
+            return Err(RusticolError::integrity(
+                "direct contribution fanout capabilities have the wrong executor domain",
+            ));
+        }
+        if self.direct_template_catalog_digest != plan.direct_template_catalog_digest() {
+            return Err(RusticolError::integrity(
+                "direct recurrence executor catalog belongs to a different prepared template catalog",
+            ));
+        }
+        for descriptor in plan.row_groups() {
+            if descriptor.role == DirectExecutorRole::Source
+                && descriptor.direct_executor_id == DIRECT_NONE_U32
+                && plan.strategy() == RecurrenceStrategy::AllFlowUnion
+            {
+                continue;
+            }
+            if descriptor.role == DirectExecutorRole::Contribution
+                && descriptor.direct_executor_id == DIRECT_NONE_U32
+            {
+                continue;
+            }
+            self.require(descriptor.direct_executor_id, descriptor.role)?;
+            if descriptor.role == DirectExecutorRole::Contribution {
+                self.contribution_metadata(descriptor.direct_executor_id)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+fn conservative_contribution_metadata(
+    plan: &DirectRecurrencePlan,
+    executor_count: usize,
+) -> RusticolResult<Vec<Option<DirectContributionExecutionMetadata>>> {
+    let current_components = plan
+        .currents()
+        .iter()
+        .filter(|current| current.node_kind == DirectNodeKind::Current)
+        .map(|current| {
+            (
+                (current.stage, current.component_base),
+                u32::from(current.component_count),
+            )
+        })
+        .collect::<BTreeMap<_, _>>();
+    let mut metadata = vec![None; executor_count];
+    for descriptor in plan.row_groups().iter().filter(|descriptor| {
+        descriptor.role == DirectExecutorRole::Contribution
+            && descriptor.direct_executor_id != DIRECT_NONE_U32
+    }) {
+        let start = usize::try_from(descriptor.row_start).map_err(|_| {
+            RusticolError::integrity("direct contribution row-group start exceeds usize")
+        })?;
+        let end = start
+            .checked_add(descriptor.row_count as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity("direct contribution row-group range overflows usize")
+            })?;
+        let rows = plan.contributions().get(start..end).ok_or_else(|| {
+            RusticolError::integrity("direct contribution row-group range is out of bounds")
+        })?;
+        for row in rows {
+            let component_count = current_components
+                .get(&(descriptor.stage, row.destination_component_base))
+                .copied()
+                .ok_or_else(|| {
+                    RusticolError::integrity("direct contribution destination current is absent")
+                })?;
+            let candidate = DirectContributionExecutionMetadata::new(component_count, true)?;
+            let slot = metadata
+                .get_mut(descriptor.direct_executor_id as usize)
+                .ok_or_else(|| {
+                    RusticolError::integrity("direct contribution executor is outside its catalog")
+                })?;
+            if slot.is_some_and(|existing| existing != candidate) {
+                return Err(RusticolError::integrity(format!(
+                    "direct contribution executor {} has inconsistent destination shapes",
+                    descriptor.direct_executor_id
+                )));
+            }
+            *slot = Some(candidate);
+        }
+    }
+    Ok(metadata)
+}
+
+const DIRECT_CONTRIBUTION_FANOUT_BATCH_CAPACITY: usize = 64;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct DirectContributionFanoutRun {
+    pub(crate) row_start: u64,
+    pub(crate) row_count: u32,
+    pub(crate) scratch_component_base: u32,
+    pub(crate) bundle_start: u64,
+    pub(crate) bundle_count: u32,
+}
+
+/// Maximal consecutive fanout outputs which share their effective scale.
+///
+/// `DIRECT_NONE_U32` denotes unity because factor-consuming executors already
+/// applied the authenticated row factor while producing the representative.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct DirectContributionFanoutBundle {
+    pub(crate) row_start: u64,
+    pub(crate) row_count: u32,
+    pub(crate) effective_factor_id_or_sentinel: u32,
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct DirectContributionFanoutBatch<'a> {
+    pub(crate) rows: &'a [DirectContributionRow],
+    pub(crate) runs: &'a [DirectContributionFanoutRun],
+    pub(crate) bundles: &'a [DirectContributionFanoutBundle],
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum DirectInteractionVectorParent {
+    Parent0,
+    Parent1,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct DirectInteractionOperand {
+    pub(crate) tensor_component_base: u32,
+    pub(crate) vector_parent: DirectInteractionVectorParent,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum DirectInteractionOperands {
+    None,
+    One(DirectInteractionOperand),
+    Two([DirectInteractionOperand; 2]),
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct DirectInteractionAnchor {
+    pub(crate) parent_component_bases: [u32; 2],
+    pub(crate) parent_momentum_form_ids: [u32; 2],
+    pub(crate) operands: DirectInteractionOperands,
+    pub(crate) output_start: u32,
+    pub(crate) output_end: u32,
+    pub(crate) tensor_output_start: u32,
+    pub(crate) tensor_output_end: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct DirectInteractionOutput {
+    pub(crate) destination_component_base: u32,
+    /// Color, followed by the zero, one, or two tensor-vector factors in the
+    /// cold-authenticated contribution order. Unused tail entries are ignored.
+    pub(crate) exact_factor_ids: [u32; 3],
+    pub(crate) initialize: bool,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct DirectInteractionTensorOutput {
+    pub(crate) destination_component_base: u32,
+    pub(crate) exact_factor_id: u32,
+    pub(crate) initialize: bool,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct DirectInteractionTerminalClosure {
+    pub(crate) root_component_base: u32,
+    pub(crate) amplitude_destination_id: u32,
+    pub(crate) exact_factor_id: u32,
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct DirectInteractionTerminalBatch<'a> {
+    pub(crate) partner_component_base: u32,
+    pub(crate) component_factor_start: u32,
+    pub(crate) amplitude_destination_count: u32,
+    pub(crate) closures: &'a [DirectInteractionTerminalClosure],
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct DirectInteractionRuntimeRequirements {
+    pub(crate) current_component_count: u32,
+    pub(crate) momentum_form_count: u32,
+    pub(crate) parameter_count: u32,
+    pub(crate) factor_count: u32,
+}
+
+impl DirectInteractionRuntimeRequirements {
+    fn include_current_span(&mut self, base: u32, component_count: u32) -> Option<()> {
+        self.current_component_count = self
+            .current_component_count
+            .max(base.checked_add(component_count)?);
+        Some(())
+    }
+
+    fn include_momentum(&mut self, momentum_form_id: u32) -> Option<()> {
+        self.momentum_form_count = self
+            .momentum_form_count
+            .max(momentum_form_id.checked_add(1)?);
+        Some(())
+    }
+
+    fn include_factor(&mut self, exact_factor_id: u32) -> Option<()> {
+        self.factor_count = self.factor_count.max(exact_factor_id.checked_add(1)?);
+        Some(())
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct DirectInteractionBundleBatch<'a> {
+    pub(crate) anchors: &'a [DirectInteractionAnchor],
+    pub(crate) outputs: &'a [DirectInteractionOutput],
+    pub(crate) tensor_outputs: &'a [DirectInteractionTensorOutput],
+    pub(crate) terminal: Option<DirectInteractionTerminalBatch<'a>>,
+    pub(crate) requirements: DirectInteractionRuntimeRequirements,
+    pub(crate) atv_before_color: bool,
+}
+
+/// Authenticated native fanout capability for one contribution executor.
+///
+/// Only intrinsic executors expose this metadata/handle pair. The generic
+/// fanout schedule uses the fused handle directly; the interaction schedule
+/// additionally requires its optional interaction call. Prepared SymJIT/native
+/// calls and nonmatching model/process combinations retain the ordinary row
+/// executor path.
+#[derive(Clone, Copy)]
+pub(crate) struct DirectInteractionExecutorCapability {
+    metadata: DirectContributionExecutionMetadata,
+    fanout: DirectContributionFanoutExecutorHandle,
+}
+
+impl DirectInteractionExecutorCapability {
+    pub(crate) fn new(
+        handle: DirectExecutorHandle,
+        metadata: DirectContributionExecutionMetadata,
+        fanout: DirectContributionFanoutExecutorHandle,
+    ) -> RusticolResult<Self> {
+        if handle.role() != DirectExecutorRole::Contribution {
+            return Err(RusticolError::integrity(
+                "direct interaction capability is attached to a non-contribution executor",
+            ));
+        }
+        if metadata.exact_factor_is_kernel_input
+            || metadata.destination_component_count != fanout.destination_component_count
+        {
+            return Err(RusticolError::integrity(
+                "direct interaction capability conflicts with authenticated contribution metadata",
+            ));
+        }
+        Ok(Self { metadata, fanout })
+    }
+}
+
+#[cfg(test)]
+mod interaction_capability_tests {
+    use super::*;
+
+    unsafe extern "C" fn contribution_stub(
+        _context: *const c_void,
+        _arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        _rows: *const DirectContributionRow,
+        _row_count: u32,
+        _point_count: u32,
+    ) -> c_int {
+        DIRECT_STATUS_OK
+    }
+
+    unsafe extern "C" fn source_stub(
+        _context: *const c_void,
+        _arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        _rows: *const DirectSourceRow,
+        _row_count: u32,
+        _point_count: u32,
+    ) -> c_int {
+        DIRECT_STATUS_OK
+    }
+
+    unsafe fn fanout_stub(
+        _context: *const c_void,
+        _arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        _batch: DirectContributionFanoutBatch<'_>,
+    ) -> RusticolResult<()> {
+        Ok(())
+    }
+
+    fn fanout(destination_component_count: u32) -> DirectContributionFanoutExecutorHandle {
+        DirectContributionFanoutExecutorHandle {
+            call: fanout_stub,
+            context: std::ptr::null(),
+            destination_component_count,
+            parent_component_counts: [4, 4],
+            requires_two_momenta: true,
+            required_parameter_count: 0,
+            interaction_kind: DirectInteractionIntrinsicKind::ColorOrderedThreeVector,
+            interaction_call: None,
+        }
+    }
+
+    #[test]
+    fn interaction_capability_requires_authenticated_output_only_contribution_shape() {
+        let contribution = DirectExecutorHandle::Contribution {
+            call: contribution_stub,
+            context: std::ptr::null(),
+        };
+        let output_only = DirectContributionExecutionMetadata::new(4, false).unwrap();
+        assert!(
+            DirectInteractionExecutorCapability::new(contribution, output_only, fanout(4)).is_ok()
+        );
+        assert!(
+            DirectInteractionExecutorCapability::new(
+                contribution,
+                DirectContributionExecutionMetadata::new(4, true).unwrap(),
+                fanout(4),
+            )
+            .is_err()
+        );
+        assert!(
+            DirectInteractionExecutorCapability::new(contribution, output_only, fanout(6)).is_err()
+        );
+        assert!(
+            DirectInteractionExecutorCapability::new(
+                DirectExecutorHandle::Source {
+                    call: source_stub,
+                    context: std::ptr::null(),
+                },
+                output_only,
+                fanout(4),
+            )
+            .is_err()
+        );
+    }
+}
+
+#[derive(Clone, Copy)]
+enum DirectInteractionRowsView<'a> {
+    Contribution(&'a [DirectContributionRow]),
+    Closure(&'a [DirectClosureRow]),
+    Other,
+}
+
+/// Zero-copy view of one authenticated schedule group.
+#[derive(Clone, Copy)]
+pub(crate) struct DirectInteractionGroupView<'a> {
+    stage: u32,
+    role: DirectExecutorRole,
+    direct_executor_id: u32,
+    handle: Option<DirectExecutorHandle>,
+    capability: Option<DirectInteractionExecutorCapability>,
+    rows: DirectInteractionRowsView<'a>,
+}
+
+impl<'a> DirectInteractionGroupView<'a> {
+    pub(crate) const fn contribution(
+        stage: u32,
+        direct_executor_id: u32,
+        handle: Option<DirectExecutorHandle>,
+        capability: Option<DirectInteractionExecutorCapability>,
+        rows: &'a [DirectContributionRow],
+    ) -> Self {
+        Self {
+            stage,
+            role: DirectExecutorRole::Contribution,
+            direct_executor_id,
+            handle,
+            capability,
+            rows: DirectInteractionRowsView::Contribution(rows),
+        }
+    }
+
+    pub(crate) const fn closure(
+        stage: u32,
+        direct_executor_id: u32,
+        handle: DirectExecutorHandle,
+        rows: &'a [DirectClosureRow],
+    ) -> Self {
+        Self {
+            stage,
+            role: DirectExecutorRole::Closure,
+            direct_executor_id,
+            handle: Some(handle),
+            capability: None,
+            rows: DirectInteractionRowsView::Closure(rows),
+        }
+    }
+
+    pub(crate) const fn other(
+        stage: u32,
+        role: DirectExecutorRole,
+        direct_executor_id: u32,
+        handle: Option<DirectExecutorHandle>,
+    ) -> Self {
+        Self {
+            stage,
+            role,
+            direct_executor_id,
+            handle,
+            capability: None,
+            rows: DirectInteractionRowsView::Other,
+        }
+    }
+
+    fn contributions(self) -> Option<&'a [DirectContributionRow]> {
+        match self.rows {
+            DirectInteractionRowsView::Contribution(rows) => Some(rows),
+            DirectInteractionRowsView::Closure(_) | DirectInteractionRowsView::Other => None,
+        }
+    }
+
+    fn closures(self) -> Option<&'a [DirectClosureRow]> {
+        match self.rows {
+            DirectInteractionRowsView::Closure(rows) => Some(rows),
+            DirectInteractionRowsView::Contribution(_) | DirectInteractionRowsView::Other => None,
+        }
+    }
+}
+
+/// Borrowed authenticated inputs needed by the native interaction compiler.
+/// Row storage remains owned by the direct plan or prepared OTF family.
+pub(crate) struct DirectInteractionScheduleView<'a> {
+    strategy: RecurrenceStrategy,
+    groups: &'a [DirectInteractionGroupView<'a>],
+    currents: &'a [DirectCurrentDescriptor],
+    contribution_row_count: usize,
+}
+
+impl<'a> DirectInteractionScheduleView<'a> {
+    pub(crate) const fn new(
+        strategy: RecurrenceStrategy,
+        groups: &'a [DirectInteractionGroupView<'a>],
+        currents: &'a [DirectCurrentDescriptor],
+        contribution_row_count: usize,
+    ) -> Self {
+        Self {
+            strategy,
+            groups,
+            currents,
+            contribution_row_count,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum DirectContributionFanoutStep {
+    Direct {
+        row_start: u64,
+        row_count: u32,
+    },
+    Fanout {
+        row_start: u64,
+        row_count: u32,
+        representative_start: u64,
+        representative_count: u32,
+        run_start: u64,
+        run_count: u32,
+        destination_component_count: u32,
+    },
+}
+
+impl DirectContributionFanoutStep {
+    const fn row_start(self) -> u64 {
+        match self {
+            Self::Direct { row_start, .. } | Self::Fanout { row_start, .. } => row_start,
+        }
+    }
+
+    const fn row_count(self) -> u32 {
+        match self {
+            Self::Direct { row_count, .. } | Self::Fanout { row_count, .. } => row_count,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct DirectContributionFanoutGroup {
+    stage: u16,
+    direct_executor_id: u32,
+    row_start: u64,
+    row_count: u32,
+    step_start: u64,
+    step_count: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum DirectSingletonFanoutStep {
+    Direct {
+        row_start: u32,
+        row_count: u32,
+    },
+    Fanout {
+        row_start: u32,
+        row_count: u32,
+        run_start: u64,
+        run_count: u32,
+    },
+}
+
+impl DirectSingletonFanoutStep {
+    const fn row_start(self) -> u32 {
+        match self {
+            Self::Direct { row_start, .. } | Self::Fanout { row_start, .. } => row_start,
+        }
+    }
+
+    const fn row_count(self) -> u32 {
+        match self {
+            Self::Direct { row_count, .. } | Self::Fanout { row_count, .. } => row_count,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+struct DirectSingletonFanoutGroup {
+    direct_executor_id: u32,
+    row_count: u32,
+    step_start: u64,
+    step_count: u32,
+    raw: DirectExecutorHandle,
+    fused: DirectContributionFanoutExecutorHandle,
+}
+
+/// Cold family-local native fanout schedule for singleton-point execution.
+///
+/// Unlike [`DirectContributionFanoutProgram`], this needs no private arena
+/// suffix: authenticated intrinsic fanout executors evaluate one input class
+/// and write every destination directly.  Batched point execution remains on
+/// the ordinary row executor path.
+pub(crate) struct DirectSingletonContributionFanoutProgram {
+    groups: Box<[Option<DirectSingletonFanoutGroup>]>,
+    steps: Box<[DirectSingletonFanoutStep]>,
+    runs: Box<[DirectContributionFanoutRun]>,
+    bundles: Box<[DirectContributionFanoutBundle]>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum DirectInteractionGroupAction {
+    Normal,
+    Execute(u32),
+    Consumed,
+}
+
+struct DirectInteractionStage {
+    group_indices: Box<[u32]>,
+    closure_group_index: Option<u32>,
+    call: DirectInteractionBundleExecutor,
+    contexts: DirectInteractionExecutorContexts,
+    atv_before_color: bool,
+    anchors: Box<[DirectInteractionAnchor]>,
+    outputs: Box<[DirectInteractionOutput]>,
+    tensor_outputs: Box<[DirectInteractionTensorOutput]>,
+    terminal: Option<DirectInteractionTerminalProgram>,
+    requirements: DirectInteractionRuntimeRequirements,
+    logical_row_count: u64,
+}
+
+struct DirectInteractionTerminalProgram {
+    partner_component_base: u32,
+    component_factor_start: u32,
+    amplitude_destination_count: u32,
+    closures: Box<[DirectInteractionTerminalClosure]>,
+}
+
+/// Cold, schedule-local native interaction rewrite shared by persisted direct
+/// plans and dynamically prepared on-the-fly families.
+pub(crate) struct DirectInteractionProgram {
+    actions: Box<[DirectInteractionGroupAction]>,
+    stages: Box<[DirectInteractionStage]>,
+}
+
+/// Immutable, plan-local execution rewrite for contribution kinematics.
+///
+/// Rows remain the authoritative cold schedule. This program copies only the
+/// compact input, destination, and live-factor metadata needed to evaluate
+/// each authenticated input class once and replay its deterministic writes.
+pub(crate) struct DirectContributionFanoutProgram {
+    plan_layout_digest: SemanticDigest,
+    groups: Box<[DirectContributionFanoutGroup]>,
+    steps: Box<[DirectContributionFanoutStep]>,
+    representatives: Box<[DirectContributionRow]>,
+    runs: Box<[DirectContributionFanoutRun]>,
+    bundles: Box<[DirectContributionFanoutBundle]>,
+    scratch_component_base: u32,
+    scratch_component_count: u32,
+    unit_factor_id: u32,
+    needs_unit_factor: bool,
+    interactions: DirectInteractionProgram,
+    full_singleton_steps: Box<[DirectFullSingletonStep]>,
+}
+
+/// Cold-authenticated dispatch for the common full, unselected singleton.
+///
+/// The persisted plan remains authoritative. These steps retain only handles
+/// and already-validated row offsets, avoiding a warmed catalog lookup and
+/// row-range reconstruction for every small group. Selected, observed, and
+/// multi-point execution continue through the generic schedule.
+#[derive(Clone, Copy)]
+enum DirectFullSingletonStep {
+    Interaction {
+        stage_index: u32,
+    },
+    Call {
+        direct_executor_id: u32,
+        handle: DirectExecutorHandle,
+        row_start: usize,
+        row_count: u32,
+    },
+    CertifiedReuse {
+        row_start: usize,
+        row_count: u32,
+    },
+    Fanout {
+        group_index: u32,
+        call: DirectContributionExecutor,
+        context: *const c_void,
+        fused: Option<DirectContributionFanoutExecutorHandle>,
+    },
+}
+
+impl DirectContributionFanoutProgram {
+    pub(crate) fn build(
+        plan: &DirectRecurrencePlan,
+        executors: &DirectExecutorCatalog,
+    ) -> RusticolResult<Self> {
+        if executors.plan_layout_digest != plan.runtime_layout_digest() {
+            return Err(RusticolError::integrity(
+                "direct fanout executor catalog belongs to a different plan",
+            ));
+        }
+        let scratch_component_base = plan.current_arena_components();
+        let unit_factor_id = u32::try_from(plan.exact_factors().len())
+            .map_err(|_| RusticolError::integrity("direct exact-factor catalog exceeds u32"))?;
+        let mut groups = Vec::new();
+        let mut steps = Vec::new();
+        let mut representatives = Vec::new();
+        let mut runs = Vec::new();
+        let mut bundles = Vec::new();
+        let mut scratch_component_count = 0_u32;
+        let mut needs_unit_factor = false;
+        let destination_component_counts = plan
+            .currents()
+            .iter()
+            .filter(|current| current.node_kind == DirectNodeKind::Current)
+            .map(|current| {
+                (
+                    (current.stage, current.component_base),
+                    u32::from(current.component_count),
+                )
+            })
+            .collect::<BTreeMap<_, _>>();
+        let arena_component_count = plan.current_arena_components();
+        let momentum_form_count = u32::try_from(plan.momentum_forms().len())
+            .map_err(|_| RusticolError::integrity("direct momentum-form count exceeds u32"))?;
+
+        for descriptor in plan.row_groups().iter().filter(|descriptor| {
+            descriptor.role == DirectExecutorRole::Contribution
+                && descriptor.direct_executor_id != DIRECT_NONE_U32
+        }) {
+            let metadata = executors.contribution_metadata(descriptor.direct_executor_id)?;
+            let fused = executors.contribution_fanout(descriptor.direct_executor_id);
+            let group_step_start = u64::try_from(steps.len())
+                .map_err(|_| RusticolError::integrity("direct fanout step count exceeds u64"))?;
+            let start = usize::try_from(descriptor.row_start).map_err(|_| {
+                RusticolError::integrity("direct fanout row-group start exceeds usize")
+            })?;
+            let end = start
+                .checked_add(descriptor.row_count as usize)
+                .ok_or_else(|| {
+                    RusticolError::integrity("direct fanout row-group range overflows usize")
+                })?;
+            let descriptor_rows = plan.contributions().get(start..end).ok_or_else(|| {
+                RusticolError::integrity("direct fanout row-group range is out of bounds")
+            })?;
+            for row in descriptor_rows {
+                let authenticated_component_count = destination_component_counts
+                    .get(&(descriptor.stage, row.destination_component_base))
+                    .copied()
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "direct fanout contribution destination current is absent",
+                        )
+                    })?;
+                if metadata.destination_component_count != authenticated_component_count {
+                    return Err(RusticolError::integrity(format!(
+                        "direct contribution executor {} declares {} destination components, expected {authenticated_component_count}",
+                        descriptor.direct_executor_id, metadata.destination_component_count
+                    )));
+                }
+                if let Some(fused) = fused {
+                    validate_fused_fanout_row(
+                        *row,
+                        fused.parent_component_counts,
+                        fused.requires_two_momenta,
+                        arena_component_count,
+                        momentum_form_count,
+                    )?;
+                }
+            }
+            let mut selector_offset = 0_usize;
+            while selector_offset < descriptor_rows.len() {
+                let selector_domain_id = descriptor_rows[selector_offset].selector_domain_id;
+                let selector_start = selector_offset;
+                while selector_offset < descriptor_rows.len()
+                    && descriptor_rows[selector_offset].selector_domain_id == selector_domain_id
+                {
+                    selector_offset += 1;
+                }
+                let selector_end = selector_offset;
+                let segment_step_start = steps.len();
+                let mut pending_runs = Vec::<(usize, usize)>::new();
+                let mut offset = selector_start;
+                while offset < selector_end {
+                    let run_start = offset;
+                    offset += 1;
+                    while offset < selector_end
+                        && contribution_fanout_inputs_equal(
+                            descriptor_rows[run_start],
+                            descriptor_rows[offset],
+                            metadata.exact_factor_is_kernel_input,
+                        )
+                    {
+                        offset += 1;
+                    }
+                    let run_count = offset - run_start;
+                    if run_count == 1 {
+                        flush_pending_fanout_batch(
+                            plan,
+                            descriptor,
+                            metadata,
+                            scratch_component_base,
+                            unit_factor_id,
+                            &mut pending_runs,
+                            &mut steps,
+                            &mut representatives,
+                            &mut runs,
+                            &mut bundles,
+                            &mut scratch_component_count,
+                            &mut needs_unit_factor,
+                        )?;
+                        push_direct_fanout_step(
+                            &mut steps,
+                            segment_step_start,
+                            descriptor.row_start + run_start as u64,
+                            1,
+                        )?;
+                    } else {
+                        pending_runs.push((run_start, run_count));
+                        if pending_runs.len() == DIRECT_CONTRIBUTION_FANOUT_BATCH_CAPACITY {
+                            flush_pending_fanout_batch(
+                                plan,
+                                descriptor,
+                                metadata,
+                                scratch_component_base,
+                                unit_factor_id,
+                                &mut pending_runs,
+                                &mut steps,
+                                &mut representatives,
+                                &mut runs,
+                                &mut bundles,
+                                &mut scratch_component_count,
+                                &mut needs_unit_factor,
+                            )?;
+                        }
+                    }
+                }
+                flush_pending_fanout_batch(
+                    plan,
+                    descriptor,
+                    metadata,
+                    scratch_component_base,
+                    unit_factor_id,
+                    &mut pending_runs,
+                    &mut steps,
+                    &mut representatives,
+                    &mut runs,
+                    &mut bundles,
+                    &mut scratch_component_count,
+                    &mut needs_unit_factor,
+                )?;
+            }
+            groups.push(DirectContributionFanoutGroup {
+                stage: descriptor.stage,
+                direct_executor_id: descriptor.direct_executor_id,
+                row_start: descriptor.row_start,
+                row_count: descriptor.row_count,
+                step_start: group_step_start,
+                step_count: u32::try_from(steps.len() as u64 - group_step_start).map_err(|_| {
+                    RusticolError::integrity("direct fanout group step count exceeds u32")
+                })?,
+            });
+        }
+        let interactions = DirectInteractionProgram::build_for_direct_plan(plan, executors)?;
+        let mut program = Self {
+            plan_layout_digest: plan.runtime_layout_digest(),
+            groups: groups.into_boxed_slice(),
+            steps: steps.into_boxed_slice(),
+            representatives: representatives.into_boxed_slice(),
+            runs: runs.into_boxed_slice(),
+            bundles: bundles.into_boxed_slice(),
+            scratch_component_base,
+            scratch_component_count,
+            unit_factor_id,
+            needs_unit_factor,
+            interactions,
+            full_singleton_steps: Box::new([]),
+        };
+        program.full_singleton_steps = program.compile_full_singleton_steps(plan, executors)?;
+        Ok(program)
+    }
+
+    fn compile_full_singleton_steps(
+        &self,
+        plan: &DirectRecurrencePlan,
+        executors: &DirectExecutorCatalog,
+    ) -> RusticolResult<Box<[DirectFullSingletonStep]>> {
+        let mut compiled = Vec::with_capacity(plan.row_groups().len());
+        for (group_index, descriptor) in plan.row_groups().iter().enumerate() {
+            match self.interactions.action(group_index) {
+                DirectInteractionGroupAction::Consumed => continue,
+                DirectInteractionGroupAction::Execute(stage_index) => {
+                    compiled.push(DirectFullSingletonStep::Interaction { stage_index });
+                    continue;
+                }
+                DirectInteractionGroupAction::Normal => {}
+            }
+            if descriptor.role == DirectExecutorRole::Source
+                && descriptor.direct_executor_id == DIRECT_NONE_U32
+                && plan.strategy() == RecurrenceStrategy::AllFlowUnion
+            {
+                continue;
+            }
+            let row_start = usize::try_from(descriptor.row_start).map_err(|_| {
+                RusticolError::integrity("flattened direct row-group start exceeds usize")
+            })?;
+            let row_end = row_start
+                .checked_add(descriptor.row_count as usize)
+                .ok_or_else(|| {
+                    RusticolError::integrity("flattened direct row-group range overflows usize")
+                })?;
+            let authoritative_len = match descriptor.role {
+                DirectExecutorRole::Source => plan.sources().len(),
+                DirectExecutorRole::Contribution => plan.contributions().len(),
+                DirectExecutorRole::Finalization => plan.finalizations().len(),
+                DirectExecutorRole::Closure => plan.closures().len(),
+            };
+            if row_end > authoritative_len {
+                return Err(RusticolError::integrity(
+                    "flattened direct row-group range is out of bounds",
+                ));
+            }
+            if descriptor.role == DirectExecutorRole::Contribution
+                && descriptor.direct_executor_id == DIRECT_NONE_U32
+            {
+                compiled.push(DirectFullSingletonStep::CertifiedReuse {
+                    row_start,
+                    row_count: descriptor.row_count,
+                });
+                continue;
+            }
+            let handle = executors.require(descriptor.direct_executor_id, descriptor.role)?;
+            if descriptor.role == DirectExecutorRole::Contribution {
+                let steps = self.group_steps(descriptor)?;
+                if steps
+                    .iter()
+                    .all(|step| matches!(step, DirectContributionFanoutStep::Direct { .. }))
+                {
+                    compiled.push(DirectFullSingletonStep::Call {
+                        direct_executor_id: descriptor.direct_executor_id,
+                        handle,
+                        row_start,
+                        row_count: descriptor.row_count,
+                    });
+                    continue;
+                }
+                let DirectExecutorHandle::Contribution { call, context } = handle else {
+                    return Err(RusticolError::integrity(
+                        "flattened direct contribution handle changed role",
+                    ));
+                };
+                compiled.push(DirectFullSingletonStep::Fanout {
+                    group_index: u32::try_from(group_index).map_err(|_| {
+                        RusticolError::integrity("flattened direct group index exceeds u32")
+                    })?,
+                    call,
+                    context,
+                    fused: executors.contribution_fanout(descriptor.direct_executor_id),
+                });
+                continue;
+            }
+            compiled.push(DirectFullSingletonStep::Call {
+                direct_executor_id: descriptor.direct_executor_id,
+                handle,
+                row_start,
+                row_count: descriptor.row_count,
+            });
+        }
+        Ok(compiled.into_boxed_slice())
+    }
+
+    fn execute_full_singleton_unprofiled(
+        &self,
+        plan: &DirectRecurrencePlan,
+        executors: &DirectExecutorCatalog,
+        workspace: &mut DirectWorkspace<'_>,
+    ) -> RusticolResult<()> {
+        clear_direct_executor_error_detail();
+        workspace.validate(1)?;
+        if executors.plan_layout_digest != plan.runtime_layout_digest()
+            || self.plan_layout_digest != plan.runtime_layout_digest()
+        {
+            return Err(RusticolError::integrity(
+                "flattened direct execution belongs to a different plan",
+            ));
+        }
+        let (arena, momenta, parameters, factors) = workspace.raw_views()?;
+        for step in &self.full_singleton_steps {
+            match *step {
+                DirectFullSingletonStep::Interaction { stage_index } => {
+                    self.interactions.execute::<false>(
+                        stage_index,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                    )?;
+                }
+                DirectFullSingletonStep::Call {
+                    direct_executor_id,
+                    handle,
+                    row_start,
+                    row_count,
+                } => {
+                    let status = unsafe {
+                        match handle {
+                            DirectExecutorHandle::Source { call, context } => call(
+                                context,
+                                arena,
+                                momenta,
+                                parameters,
+                                factors,
+                                plan.sources().as_ptr().add(row_start),
+                                row_count,
+                                1,
+                            ),
+                            DirectExecutorHandle::Contribution { call, context } => call(
+                                context,
+                                arena,
+                                momenta,
+                                parameters,
+                                factors,
+                                plan.contributions().as_ptr().add(row_start),
+                                row_count,
+                                1,
+                            ),
+                            DirectExecutorHandle::Finalization { call, context } => call(
+                                context,
+                                arena,
+                                momenta,
+                                parameters,
+                                factors,
+                                plan.finalizations().as_ptr().add(row_start),
+                                row_count,
+                                1,
+                            ),
+                            DirectExecutorHandle::Closure { call, context } => call(
+                                context,
+                                arena,
+                                momenta,
+                                parameters,
+                                factors,
+                                plan.closures().as_ptr().add(row_start),
+                                row_count,
+                                1,
+                            ),
+                        }
+                    };
+                    check_status(handle.role(), direct_executor_id, status)?;
+                }
+                DirectFullSingletonStep::CertifiedReuse {
+                    row_start,
+                    row_count,
+                } => {
+                    let row_end = row_start + row_count as usize;
+                    execute_certified_reuse_rows(
+                        &plan.contributions()[row_start..row_end],
+                        workspace,
+                        1,
+                    )?;
+                }
+                DirectFullSingletonStep::Fanout {
+                    group_index,
+                    call,
+                    context,
+                    fused,
+                } => {
+                    let descriptor = &plan.row_groups()[group_index as usize];
+                    execute_contribution_group_with_fanout(
+                        plan, descriptor, self, call, context, fused, workspace, 1,
+                    )?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) const fn scratch_component_count(&self) -> u32 {
+        self.scratch_component_count
+    }
+
+    pub(crate) const fn needs_unit_factor(&self) -> bool {
+        self.needs_unit_factor
+    }
+
+    #[cfg(test)]
+    pub(crate) fn row_counts(&self) -> (u64, u64) {
+        let logical = self
+            .groups
+            .iter()
+            .map(|group| u64::from(group.row_count))
+            .sum();
+        let evaluated = self
+            .steps
+            .iter()
+            .map(|step| match step {
+                DirectContributionFanoutStep::Direct { row_count, .. } => u64::from(*row_count),
+                DirectContributionFanoutStep::Fanout {
+                    representative_count,
+                    ..
+                } => u64::from(*representative_count),
+            })
+            .sum();
+        (logical, evaluated)
+    }
+
+    #[cfg(test)]
+    pub(crate) fn scatter_bundle_counts(&self) -> (u64, u64) {
+        (
+            self.runs.iter().map(|run| u64::from(run.row_count)).sum(),
+            self.bundles.len() as u64,
+        )
+    }
+
+    fn group_steps(
+        &self,
+        descriptor: &DirectRowGroupDescriptor,
+    ) -> RusticolResult<&[DirectContributionFanoutStep]> {
+        if descriptor.role != DirectExecutorRole::Contribution
+            || descriptor.direct_executor_id == DIRECT_NONE_U32
+        {
+            return Err(RusticolError::integrity(
+                "direct fanout requested for a non-callable contribution group",
+            ));
+        }
+        let requested_end = descriptor
+            .row_start
+            .checked_add(u64::from(descriptor.row_count))
+            .ok_or_else(|| RusticolError::integrity("direct fanout row range overflows u64"))?;
+        // Groups retain the authenticated row-group order, so locate the one
+        // containing a selected subrange without a warmed linear catalog scan.
+        let group_index = self
+            .groups
+            .partition_point(|group| group.row_start <= descriptor.row_start)
+            .checked_sub(1)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "direct contribution row group is absent from its fanout program",
+                )
+            })?;
+        let group = self
+            .groups
+            .get(group_index)
+            .filter(|group| {
+                let group_end = group.row_start + u64::from(group.row_count);
+                group.stage == descriptor.stage
+                    && group.direct_executor_id == descriptor.direct_executor_id
+                    && descriptor.row_start >= group.row_start
+                    && requested_end <= group_end
+            })
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "direct contribution row group is absent from its fanout program",
+                )
+            })?;
+        let step_start = usize::try_from(group.step_start)
+            .map_err(|_| RusticolError::integrity("direct fanout step start exceeds usize"))?;
+        let step_end = step_start
+            .checked_add(group.step_count as usize)
+            .ok_or_else(|| RusticolError::integrity("direct fanout step range overflows usize"))?;
+        let group_steps = self.steps.get(step_start..step_end).ok_or_else(|| {
+            RusticolError::integrity("direct fanout group step range is out of bounds")
+        })?;
+        let first = group_steps
+            .iter()
+            .position(|step| step.row_start() == descriptor.row_start)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "selected direct fanout range does not begin on a step boundary",
+                )
+            })?;
+        let mut stop = first;
+        let mut covered = descriptor.row_start;
+        while stop < group_steps.len() && covered < requested_end {
+            let step = group_steps[stop];
+            if step.row_start() != covered {
+                return Err(RusticolError::integrity(
+                    "direct fanout steps do not continuously cover their row group",
+                ));
+            }
+            covered = covered
+                .checked_add(u64::from(step.row_count()))
+                .ok_or_else(|| {
+                    RusticolError::integrity("direct fanout step coverage overflows u64")
+                })?;
+            stop += 1;
+        }
+        if covered != requested_end {
+            return Err(RusticolError::integrity(
+                "selected direct fanout range does not end on a step boundary",
+            ));
+        }
+        Ok(&group_steps[first..stop])
+    }
+}
+
+impl DirectSingletonContributionFanoutProgram {
+    pub(crate) fn build(
+        schedule_groups: &[DirectInteractionGroupView<'_>],
+        arena_component_count: u32,
+        momentum_form_count: u32,
+        parameter_count: u32,
+        factor_count: u32,
+    ) -> RusticolResult<Self> {
+        let mut groups = vec![None; schedule_groups.len()];
+        let mut steps = Vec::new();
+        let mut runs = Vec::new();
+        let mut bundles = Vec::new();
+        for (group_index, group) in schedule_groups.iter().copied().enumerate() {
+            let Some(rows) = group.contributions() else {
+                continue;
+            };
+            let Some(capability) = group.capability else {
+                continue;
+            };
+            let fanout = capability.fanout;
+            if rows.is_empty()
+                || rows.len() > u32::MAX as usize
+                || fanout.required_parameter_count > parameter_count
+                || rows.iter().any(|row| {
+                    row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0
+                        || row.exact_factor_id >= factor_count
+                        || row
+                            .destination_component_base
+                            .checked_add(fanout.destination_component_count)
+                            .is_none_or(|end| end > arena_component_count)
+                })
+            {
+                continue;
+            }
+            for row in rows {
+                validate_fused_fanout_row(
+                    *row,
+                    fanout.parent_component_counts,
+                    fanout.requires_two_momenta,
+                    arena_component_count,
+                    momentum_form_count,
+                )?;
+            }
+
+            let step_start = u64::try_from(steps.len())
+                .map_err(|_| RusticolError::integrity("singleton fanout step count exceeds u64"))?;
+            let mut pending_runs = Vec::<(u32, u32)>::new();
+            let mut offset = 0_usize;
+            while offset < rows.len() {
+                let run_start = offset;
+                offset += 1;
+                while offset < rows.len()
+                    && contribution_fanout_inputs_equal(rows[run_start], rows[offset], false)
+                {
+                    offset += 1;
+                }
+                let run_count = offset - run_start;
+                if run_count == 1 {
+                    flush_singleton_fanout_batch(
+                        rows,
+                        &mut pending_runs,
+                        &mut steps,
+                        &mut runs,
+                        &mut bundles,
+                    )?;
+                    push_singleton_direct_step(
+                        &mut steps,
+                        step_start as usize,
+                        u32::try_from(run_start).map_err(|_| {
+                            RusticolError::integrity(
+                                "singleton fanout direct-row start exceeds u32",
+                            )
+                        })?,
+                        1,
+                    )?;
+                } else {
+                    pending_runs.push((
+                        u32::try_from(run_start).map_err(|_| {
+                            RusticolError::integrity("singleton fanout run start exceeds u32")
+                        })?,
+                        u32::try_from(run_count).map_err(|_| {
+                            RusticolError::integrity("singleton fanout run count exceeds u32")
+                        })?,
+                    ));
+                    if pending_runs.len() == DIRECT_CONTRIBUTION_FANOUT_BATCH_CAPACITY {
+                        flush_singleton_fanout_batch(
+                            rows,
+                            &mut pending_runs,
+                            &mut steps,
+                            &mut runs,
+                            &mut bundles,
+                        )?;
+                    }
+                }
+            }
+            flush_singleton_fanout_batch(
+                rows,
+                &mut pending_runs,
+                &mut steps,
+                &mut runs,
+                &mut bundles,
+            )?;
+            let step_count = u32::try_from(steps.len() as u64 - step_start).map_err(|_| {
+                RusticolError::integrity("singleton fanout group step count exceeds u32")
+            })?;
+            let group_steps = &steps[step_start as usize..];
+            if !group_steps
+                .iter()
+                .any(|step| matches!(step, DirectSingletonFanoutStep::Fanout { .. }))
+            {
+                steps.truncate(step_start as usize);
+                continue;
+            }
+            let raw = group.handle.ok_or_else(|| {
+                RusticolError::integrity("singleton fanout group has no raw contribution handle")
+            })?;
+            if raw.role() != DirectExecutorRole::Contribution {
+                return Err(RusticolError::integrity(
+                    "singleton fanout group has a non-contribution raw handle",
+                ));
+            }
+            groups[group_index] = Some(DirectSingletonFanoutGroup {
+                direct_executor_id: group.direct_executor_id,
+                row_count: rows.len() as u32,
+                step_start,
+                step_count,
+                raw,
+                fused: fanout,
+            });
+        }
+        Ok(Self {
+            groups: groups.into_boxed_slice(),
+            steps: steps.into_boxed_slice(),
+            runs: runs.into_boxed_slice(),
+            bundles: bundles.into_boxed_slice(),
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn execute_group(
+        &self,
+        group_index: usize,
+        rows: &[DirectContributionRow],
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+        factors: DirectFactorView,
+        point_count: u32,
+    ) -> RusticolResult<bool> {
+        if point_count != 1 {
+            return Ok(false);
+        }
+        let Some(group) = self.groups.get(group_index).and_then(|group| *group) else {
+            return Ok(false);
+        };
+        if rows.len() != group.row_count as usize {
+            return Err(RusticolError::integrity(
+                "singleton fanout rows changed after cold compilation",
+            ));
+        }
+        let step_start = usize::try_from(group.step_start)
+            .map_err(|_| RusticolError::integrity("singleton fanout step start exceeds usize"))?;
+        let step_end = step_start
+            .checked_add(group.step_count as usize)
+            .ok_or_else(|| RusticolError::integrity("singleton fanout step range overflows"))?;
+        let steps = self.steps.get(step_start..step_end).ok_or_else(|| {
+            RusticolError::integrity("singleton fanout step range is out of bounds")
+        })?;
+        let DirectExecutorHandle::Contribution { call, context } = group.raw else {
+            return Err(RusticolError::integrity(
+                "singleton fanout raw handle changed role",
+            ));
+        };
+        let mut covered = 0_u32;
+        for step in steps {
+            if step.row_start() != covered {
+                return Err(RusticolError::integrity(
+                    "singleton fanout steps do not continuously cover their row group",
+                ));
+            }
+            match *step {
+                DirectSingletonFanoutStep::Direct {
+                    row_start,
+                    row_count,
+                } => {
+                    let start = row_start as usize;
+                    let end = start.checked_add(row_count as usize).ok_or_else(|| {
+                        RusticolError::integrity("singleton fanout direct range overflows")
+                    })?;
+                    let direct_rows = rows.get(start..end).ok_or_else(|| {
+                        RusticolError::integrity("singleton fanout direct range is out of bounds")
+                    })?;
+                    let status = unsafe {
+                        call(
+                            context,
+                            arena,
+                            momenta,
+                            parameters,
+                            factors,
+                            direct_rows.as_ptr(),
+                            row_count,
+                            1,
+                        )
+                    };
+                    check_status(
+                        DirectExecutorRole::Contribution,
+                        group.direct_executor_id,
+                        status,
+                    )?;
+                }
+                DirectSingletonFanoutStep::Fanout {
+                    run_start,
+                    run_count,
+                    ..
+                } => {
+                    let start = usize::try_from(run_start).map_err(|_| {
+                        RusticolError::integrity("singleton fanout run start exceeds usize")
+                    })?;
+                    let end = start.checked_add(run_count as usize).ok_or_else(|| {
+                        RusticolError::integrity("singleton fanout run range overflows")
+                    })?;
+                    let runs = self.runs.get(start..end).ok_or_else(|| {
+                        RusticolError::integrity("singleton fanout run range is out of bounds")
+                    })?;
+                    unsafe {
+                        (group.fused.call)(
+                            group.fused.context,
+                            arena,
+                            momenta,
+                            parameters,
+                            factors,
+                            DirectContributionFanoutBatch {
+                                rows,
+                                runs,
+                                bundles: &self.bundles,
+                            },
+                        )
+                    }?;
+                }
+            }
+            covered = covered.checked_add(step.row_count()).ok_or_else(|| {
+                RusticolError::integrity("singleton fanout step coverage overflows u32")
+            })?;
+        }
+        if covered != group.row_count {
+            return Err(RusticolError::integrity(
+                "singleton fanout steps do not cover their row group",
+            ));
+        }
+        Ok(true)
+    }
+
+    #[cfg(test)]
+    pub(crate) fn row_counts(&self) -> (u64, u64) {
+        let logical = self
+            .groups
+            .iter()
+            .flatten()
+            .map(|group| u64::from(group.row_count))
+            .sum();
+        let evaluated = self
+            .steps
+            .iter()
+            .map(|step| match step {
+                DirectSingletonFanoutStep::Direct { row_count, .. } => u64::from(*row_count),
+                DirectSingletonFanoutStep::Fanout { run_count, .. } => u64::from(*run_count),
+            })
+            .sum();
+        (logical, evaluated)
+    }
+}
+
+#[derive(Clone, Copy)]
+struct DirectInteractionRawRun {
+    row_start: u32,
+    row_count: u32,
+}
+
+type DirectInteractionInputKey = (u32, u32, u32, u32, u32);
+
+fn interaction_input_key(row: DirectContributionRow) -> DirectInteractionInputKey {
+    (
+        row.selector_domain_id,
+        row.parent0_component_base,
+        row.parent1_component_base_or_sentinel,
+        row.parent0_momentum_form_id,
+        row.parent1_momentum_form_id_or_sentinel,
+    )
+}
+
+fn interaction_raw_runs(rows: &[DirectContributionRow]) -> Option<Vec<DirectInteractionRawRun>> {
+    if rows
+        .iter()
+        .any(|row| row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0)
+    {
+        return None;
+    }
+    let mut runs = Vec::new();
+    let mut offset = 0_usize;
+    while offset < rows.len() {
+        let run_start = offset;
+        let key = interaction_input_key(rows[offset]);
+        offset += 1;
+        while offset < rows.len() && interaction_input_key(rows[offset]) == key {
+            offset += 1;
+        }
+        runs.push(DirectInteractionRawRun {
+            row_start: u32::try_from(run_start).ok()?,
+            row_count: u32::try_from(offset - run_start).ok()?,
+        });
+    }
+    Some(runs)
+}
+
+fn interaction_rows(
+    rows: &[DirectContributionRow],
+    run: DirectInteractionRawRun,
+) -> Option<&[DirectContributionRow]> {
+    let start = run.row_start as usize;
+    rows.get(start..start.checked_add(run.row_count as usize)?)
+}
+
+fn interaction_destination_offsets(rows: &[DirectContributionRow]) -> Option<BTreeMap<u32, u32>> {
+    let destinations = rows
+        .iter()
+        .enumerate()
+        .map(|(offset, row)| Some((row.destination_component_base, u32::try_from(offset).ok()?)))
+        .collect::<Option<BTreeMap<_, _>>>()?;
+    (destinations.len() == rows.len()).then_some(destinations)
+}
+
+fn interaction_destination_bijection(
+    color: &BTreeMap<u32, u32>,
+    atv: &BTreeMap<u32, u32>,
+) -> Option<Vec<u32>> {
+    if color.len() != atv.len() || !color.keys().eq(atv.keys()) {
+        return None;
+    }
+    let mut row_offsets = vec![DIRECT_NONE_U32; color.len()];
+    for (&destination, &color_offset) in color {
+        let atv_offset = *atv.get(&destination)?;
+        *row_offsets.get_mut(color_offset as usize)? = atv_offset;
+    }
+    (!row_offsets.contains(&DIRECT_NONE_U32)).then_some(row_offsets)
+}
+
+fn interaction_vector_initialization_is_canonical(
+    ordered_groups: &[&[DirectContributionRow]],
+) -> bool {
+    let mut seen = BTreeSet::new();
+    ordered_groups
+        .iter()
+        .flat_map(|rows| rows.iter())
+        .all(|row| {
+            let first = seen.insert(row.destination_component_base);
+            let initializes = row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0;
+            initializes == first
+        })
+}
+
+#[cfg(test)]
+mod interaction_initialization_tests {
+    use super::*;
+
+    fn row(destination_component_base: u32, initializes: bool) -> DirectContributionRow {
+        DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 4,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 1,
+            destination_component_base,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: if initializes {
+                DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+            } else {
+                0
+            },
+        }
+    }
+
+    #[test]
+    fn interaction_initialization_requires_the_first_authoritative_write() {
+        let first_group = [row(20, true), row(24, true), row(20, false)];
+        let second_group = [row(24, false)];
+        assert!(interaction_vector_initialization_is_canonical(&[
+            &first_group,
+            &second_group,
+        ]));
+
+        let late_initializer = [row(20, false), row(20, true)];
+        assert!(!interaction_vector_initialization_is_canonical(&[
+            &late_initializer,
+        ]));
+        let duplicate_initializer = [row(20, true), row(20, true)];
+        assert!(!interaction_vector_initialization_is_canonical(&[
+            &duplicate_initializer,
+        ]));
+    }
+}
+
+fn interaction_kind(
+    group: DirectInteractionGroupView<'_>,
+) -> Option<DirectInteractionIntrinsicKind> {
+    if group.role != DirectExecutorRole::Contribution
+        || group.direct_executor_id == DIRECT_NONE_U32
+        || group.capability?.metadata.exact_factor_is_kernel_input
+    {
+        return None;
+    }
+    Some(group.capability?.fanout.interaction_kind)
+}
+
+fn direct_interaction_group_views<'a>(
+    plan: &'a DirectRecurrencePlan,
+    executors: &DirectExecutorCatalog,
+) -> RusticolResult<Vec<DirectInteractionGroupView<'a>>> {
+    let mut groups = Vec::with_capacity(plan.row_groups().len());
+    for descriptor in plan.row_groups() {
+        let start = usize::try_from(descriptor.row_start)
+            .map_err(|_| RusticolError::integrity("direct interaction row start exceeds usize"))?;
+        let end = start
+            .checked_add(descriptor.row_count as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity("direct interaction row range overflows usize")
+            })?;
+        let stage = u32::from(descriptor.stage);
+        groups.push(match descriptor.role {
+            DirectExecutorRole::Contribution => {
+                let rows = plan.contributions().get(start..end).ok_or_else(|| {
+                    RusticolError::integrity("direct interaction contribution rows are absent")
+                })?;
+                let handle = (descriptor.direct_executor_id != DIRECT_NONE_U32)
+                    .then(|| {
+                        executors.require(
+                            descriptor.direct_executor_id,
+                            DirectExecutorRole::Contribution,
+                        )
+                    })
+                    .transpose()?;
+                let capability = executors
+                    .contribution_fanout(descriptor.direct_executor_id)
+                    .map(|fanout| {
+                        let handle = handle.ok_or_else(|| {
+                            RusticolError::integrity(
+                                "direct interaction capability has no contribution handle",
+                            )
+                        })?;
+                        DirectInteractionExecutorCapability::new(
+                            handle,
+                            executors.contribution_metadata(descriptor.direct_executor_id)?,
+                            fanout,
+                        )
+                    })
+                    .transpose()?;
+                DirectInteractionGroupView::contribution(
+                    stage,
+                    descriptor.direct_executor_id,
+                    handle,
+                    capability,
+                    rows,
+                )
+            }
+            DirectExecutorRole::Closure => {
+                let rows = plan.closures().get(start..end).ok_or_else(|| {
+                    RusticolError::integrity("direct interaction closure rows are absent")
+                })?;
+                DirectInteractionGroupView::closure(
+                    stage,
+                    descriptor.direct_executor_id,
+                    executors.require(descriptor.direct_executor_id, descriptor.role)?,
+                    rows,
+                )
+            }
+            role => DirectInteractionGroupView::other(
+                stage,
+                role,
+                descriptor.direct_executor_id,
+                (descriptor.direct_executor_id != DIRECT_NONE_U32)
+                    .then(|| executors.require(descriptor.direct_executor_id, role))
+                    .transpose()?,
+            ),
+        });
+    }
+    Ok(groups)
+}
+
+impl DirectInteractionProgram {
+    fn build_for_direct_plan(
+        plan: &DirectRecurrencePlan,
+        executors: &DirectExecutorCatalog,
+    ) -> RusticolResult<Self> {
+        let groups = direct_interaction_group_views(plan, executors)?;
+        let schedule = DirectInteractionScheduleView::new(
+            plan.strategy(),
+            &groups,
+            plan.currents(),
+            plan.contributions().len(),
+        );
+        Self::build(schedule)
+    }
+
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    pub(crate) fn build(schedule: DirectInteractionScheduleView<'_>) -> RusticolResult<Self> {
+        let mut actions = vec![DirectInteractionGroupAction::Normal; schedule.groups.len()];
+        let mut stages = Vec::new();
+        let mut stage_groups = BTreeMap::<u32, Vec<usize>>::new();
+        for (group_index, group) in schedule.groups.iter().enumerate() {
+            if group.role == DirectExecutorRole::Contribution {
+                stage_groups
+                    .entry(group.stage)
+                    .or_default()
+                    .push(group_index);
+            }
+        }
+        let raw_runs = schedule
+            .groups
+            .iter()
+            .enumerate()
+            .filter_map(|(group_index, &group)| {
+                interaction_kind(group)?;
+                Some((group_index, interaction_raw_runs(group.contributions()?)?))
+            })
+            .collect::<BTreeMap<_, _>>();
+
+        for group_indices in stage_groups.values() {
+            let Some(candidate) = match_interaction_stage(&schedule, group_indices, &raw_runs)
+            else {
+                continue;
+            };
+            let stage_index = u32::try_from(stages.len()).map_err(|_| {
+                RusticolError::integrity("direct interaction stage count exceeds u32")
+            })?;
+            let first_group = *candidate
+                .group_indices
+                .iter()
+                .min()
+                .expect("interaction has contribution groups");
+            for &group_index in &candidate.group_indices {
+                actions[group_index] = if group_index == first_group {
+                    DirectInteractionGroupAction::Execute(stage_index)
+                } else {
+                    DirectInteractionGroupAction::Consumed
+                };
+            }
+            if let Some(group_index) = candidate.closure_group_index {
+                actions[group_index] = DirectInteractionGroupAction::Consumed;
+            }
+            let stored_group_indices = candidate
+                .group_indices
+                .iter()
+                .copied()
+                .map(|group_index| {
+                    u32::try_from(group_index).map_err(|_| {
+                        RusticolError::integrity("direct interaction group index exceeds u32")
+                    })
+                })
+                .collect::<RusticolResult<Vec<_>>>()?
+                .into_boxed_slice();
+            let closure_group_index = candidate
+                .closure_group_index
+                .map(|group_index| {
+                    u32::try_from(group_index).map_err(|_| {
+                        RusticolError::integrity("direct terminal closure group index exceeds u32")
+                    })
+                })
+                .transpose()?;
+            stages.push(DirectInteractionStage {
+                group_indices: stored_group_indices,
+                closure_group_index,
+                call: candidate.call,
+                contexts: candidate.contexts,
+                atv_before_color: candidate.atv_before_color,
+                anchors: candidate.anchors.into_boxed_slice(),
+                outputs: candidate.outputs.into_boxed_slice(),
+                tensor_outputs: candidate.tensor_outputs.into_boxed_slice(),
+                terminal: candidate.terminal,
+                requirements: candidate.requirements,
+                logical_row_count: candidate.logical_row_count,
+            });
+        }
+
+        Ok(Self {
+            actions: actions.into_boxed_slice(),
+            stages: stages.into_boxed_slice(),
+        })
+    }
+
+    pub(crate) fn action(&self, group_index: usize) -> DirectInteractionGroupAction {
+        self.actions
+            .get(group_index)
+            .copied()
+            .unwrap_or(DirectInteractionGroupAction::Normal)
+    }
+
+    pub(crate) fn execute<const PROFILE: bool>(
+        &self,
+        stage_index: u32,
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+        factors: DirectFactorView,
+    ) -> RusticolResult<Duration> {
+        let stage = self.stages.get(stage_index as usize).ok_or_else(|| {
+            RusticolError::integrity("direct interaction stage index is out of bounds")
+        })?;
+        execute_direct_interaction_stage_views::<PROFILE>(
+            stage, arena, momenta, parameters, factors,
+        )
+    }
+
+    pub(crate) fn logical_groups(
+        &self,
+        stage_index: u32,
+    ) -> RusticolResult<(&[u32], Option<u32>, u64)> {
+        let stage = self.stages.get(stage_index as usize).ok_or_else(|| {
+            RusticolError::integrity("direct interaction stage index is out of bounds")
+        })?;
+        Ok((
+            &stage.group_indices,
+            stage.closure_group_index,
+            stage.logical_row_count,
+        ))
+    }
+}
+
+struct DirectInteractionStageCandidate {
+    group_indices: Vec<usize>,
+    closure_group_index: Option<usize>,
+    call: DirectInteractionBundleExecutor,
+    contexts: DirectInteractionExecutorContexts,
+    atv_before_color: bool,
+    logical_row_count: u64,
+    anchors: Vec<DirectInteractionAnchor>,
+    outputs: Vec<DirectInteractionOutput>,
+    tensor_outputs: Vec<DirectInteractionTensorOutput>,
+    terminal: Option<DirectInteractionTerminalProgram>,
+    requirements: DirectInteractionRuntimeRequirements,
+}
+
+struct DirectInteractionMatchedSupplement {
+    row_start: u32,
+    vector_parent_side: u8,
+    row_offsets: Vec<u32>,
+}
+
+// The sibling-wedge rewrite adds enough hot code to pay for itself only on
+// large schedules. Keep the narrower color/ATV interaction rewrite below this
+// cold, process-independent workload boundary. Terminal scalarization is a
+// separate win: once the cold liveness proof succeeds it removes an entire
+// four-component root/closure round trip, including on small schedules.
+const DIRECT_LARGE_SCHEDULE_INTERACTION_MIN_ROWS: usize = 1_000_000;
+
+#[inline]
+fn direct_large_schedule_interaction_rewrite_enabled(
+    strategy: RecurrenceStrategy,
+    contribution_row_count: usize,
+) -> bool {
+    strategy == RecurrenceStrategy::ContractedColorUnion
+        && contribution_row_count >= DIRECT_LARGE_SCHEDULE_INTERACTION_MIN_ROWS
+}
+
+#[inline]
+fn direct_terminal_interaction_rewrite_enabled(strategy: RecurrenceStrategy) -> bool {
+    strategy == RecurrenceStrategy::ContractedColorUnion
+}
+
+fn match_interaction_stage(
+    schedule: &DirectInteractionScheduleView<'_>,
+    group_indices: &[usize],
+    raw_runs: &BTreeMap<usize, Vec<DirectInteractionRawRun>>,
+) -> Option<DirectInteractionStageCandidate> {
+    if !(2..=3).contains(&group_indices.len())
+        || !group_indices.windows(2).all(|pair| pair[1] == pair[0] + 1)
+    {
+        return None;
+    }
+    let mut color = None;
+    let mut wedge = None;
+    let mut atv = None;
+    for &group_index in group_indices {
+        let group = schedule.groups[group_index];
+        let slot = match interaction_kind(group)? {
+            DirectInteractionIntrinsicKind::ColorOrderedThreeVector => &mut color,
+            DirectInteractionIntrinsicKind::VectorWedgeVector => &mut wedge,
+            DirectInteractionIntrinsicKind::AntisymmetricTensorVector => &mut atv,
+        };
+        if slot.replace(group_index).is_some() {
+            return None;
+        }
+    }
+    let (color_index, atv_index) = (color?, atv?);
+    if wedge.is_some() != (group_indices.len() == 3) {
+        return None;
+    }
+    let color = schedule.groups[color_index];
+    let atv = schedule.groups[atv_index];
+    let color_group_rows = color.contributions()?;
+    let atv_group_rows = atv.contributions()?;
+    let ordered_vector_groups = if color_index < atv_index {
+        [color_group_rows, atv_group_rows]
+    } else {
+        [atv_group_rows, color_group_rows]
+    };
+    if !interaction_vector_initialization_is_canonical(&ordered_vector_groups) {
+        return None;
+    }
+    let color_capability = color.capability?.fanout;
+    let atv_capability = atv.capability?.fanout;
+    let call = color_capability.interaction_call?;
+    let color_runs = raw_runs.get(&color_index)?.clone();
+    let atv_runs = raw_runs.get(&atv_index)?;
+    let fuse_wedge = direct_large_schedule_interaction_rewrite_enabled(
+        schedule.strategy,
+        schedule.contribution_row_count,
+    );
+    let wedge_program = if let Some(wedge_index) = wedge.filter(|_| fuse_wedge) {
+        let group = schedule.groups[wedge_index];
+        let capability = group.capability?.fanout;
+        if capability.destination_component_count != 6
+            || capability.parent_component_counts != [4, 4]
+            || capability.requires_two_momenta
+        {
+            return None;
+        }
+        let wedge_runs = raw_runs.get(&wedge_index)?.clone();
+        if wedge_runs.len() != color_runs.len() {
+            return None;
+        }
+        for (&color_run, &wedge_run) in color_runs.iter().zip(&wedge_runs) {
+            let color_rows = interaction_rows(color_group_rows, color_run)?;
+            let wedge_rows = interaction_rows(group.contributions()?, wedge_run)?;
+            if color_run.row_count != wedge_run.row_count
+                || interaction_input_key(*color_rows.first()?)
+                    != interaction_input_key(*wedge_rows.first()?)
+                || !color_rows
+                    .iter()
+                    .zip(wedge_rows)
+                    .all(|(color_row, wedge_row)| {
+                        color_row.exact_factor_id == wedge_row.exact_factor_id
+                    })
+            {
+                return None;
+            }
+        }
+        Some((capability, wedge_runs))
+    } else {
+        None
+    };
+
+    type AssociationKey = (u32, u32, u32, u32, u32, u32);
+    let mut anchors_by_vector = BTreeMap::<AssociationKey, Vec<(usize, u8)>>::new();
+    let mut color_destination_offsets = Vec::with_capacity(color_runs.len());
+    for (anchor_index, run) in color_runs.iter().copied().enumerate() {
+        let rows = interaction_rows(color_group_rows, run)?;
+        let first = *rows.first()?;
+        let destinations = interaction_destination_offsets(rows)?;
+        let minimum_destination = *destinations.keys().next()?;
+        let maximum_destination = *destinations.keys().next_back()?;
+        for (side, base, momentum) in [
+            (
+                0_u8,
+                first.parent0_component_base,
+                first.parent0_momentum_form_id,
+            ),
+            (
+                1_u8,
+                first.parent1_component_base_or_sentinel,
+                first.parent1_momentum_form_id_or_sentinel,
+            ),
+        ] {
+            anchors_by_vector
+                .entry((
+                    first.selector_domain_id,
+                    base,
+                    momentum,
+                    run.row_count,
+                    minimum_destination,
+                    maximum_destination,
+                ))
+                .or_default()
+                .push((anchor_index, side));
+        }
+        color_destination_offsets.push(destinations);
+    }
+    let mut matched_supplements = (0..color_runs.len())
+        .map(|_| Vec::new())
+        .collect::<Vec<Vec<DirectInteractionMatchedSupplement>>>();
+    let mut used_sides = vec![[false; 2]; color_runs.len()];
+    for &atv_run in atv_runs {
+        let atv_rows = interaction_rows(atv_group_rows, atv_run)?;
+        let representative = *atv_rows.first()?;
+        let atv_destination_offsets = interaction_destination_offsets(atv_rows)?;
+        let minimum_destination = *atv_destination_offsets.keys().next()?;
+        let maximum_destination = *atv_destination_offsets.keys().next_back()?;
+        let candidates = anchors_by_vector.get(&(
+            representative.selector_domain_id,
+            representative.parent1_component_base_or_sentinel,
+            representative.parent1_momentum_form_id_or_sentinel,
+            atv_run.row_count,
+            minimum_destination,
+            maximum_destination,
+        ))?;
+        let mut matches = candidates.iter().copied().filter(|(anchor_index, _)| {
+            color_destination_offsets[*anchor_index]
+                .keys()
+                .eq(atv_destination_offsets.keys())
+        });
+        let (anchor_index, vector_parent_side) = matches.next()?;
+        if matches.next().is_some() || used_sides[anchor_index][vector_parent_side as usize] {
+            return None;
+        }
+        used_sides[anchor_index][vector_parent_side as usize] = true;
+        let row_offsets = interaction_destination_bijection(
+            &color_destination_offsets[anchor_index],
+            &atv_destination_offsets,
+        )?;
+        matched_supplements[anchor_index].push(DirectInteractionMatchedSupplement {
+            row_start: atv_run.row_start,
+            vector_parent_side,
+            row_offsets,
+        });
+    }
+    if matched_supplements.iter().flatten().count() == 0 {
+        return None;
+    }
+
+    // Identical destination ranges are expected across formula groups and
+    // repeated interactions. Distinct partially-overlapping ranges would make
+    // a single aggregated write ambiguous, so reject that stage.
+    let mut destination_widths = BTreeMap::<u32, u32>::new();
+    for &group_index in group_indices {
+        let group = schedule.groups[group_index];
+        let capability = group.capability?.fanout;
+        let rows = group.contributions()?;
+        for row in rows {
+            if destination_widths
+                .insert(
+                    row.destination_component_base,
+                    capability.destination_component_count,
+                )
+                .is_some_and(|width| width != capability.destination_component_count)
+            {
+                return None;
+            }
+        }
+    }
+    let mut previous_end = 0_u32;
+    for (&base, &width) in &destination_widths {
+        if base < previous_end {
+            return None;
+        }
+        previous_end = base.checked_add(width)?;
+    }
+
+    let mut seen_vector_destinations = BTreeSet::new();
+    let mut candidate_anchors = Vec::with_capacity(color_runs.len());
+    let mut candidate_outputs = Vec::with_capacity(color_group_rows.len());
+    let mut candidate_tensor_outputs = Vec::with_capacity(
+        wedge
+            .and_then(|group_index| schedule.groups[group_index].contributions())
+            .map_or(0, <[DirectContributionRow]>::len),
+    );
+    let mut requirements = DirectInteractionRuntimeRequirements {
+        parameter_count: color_capability
+            .required_parameter_count
+            .max(atv_capability.required_parameter_count),
+        ..DirectInteractionRuntimeRequirements::default()
+    };
+    if let Some((capability, _)) = &wedge_program {
+        requirements.parameter_count = requirements
+            .parameter_count
+            .max(capability.required_parameter_count);
+    }
+    for (anchor_index, color_run) in color_runs.into_iter().enumerate() {
+        let color_rows = interaction_rows(color_group_rows, color_run)?;
+        let representative = *color_rows.first()?;
+        requirements.include_current_span(
+            representative.parent0_component_base,
+            color_capability.parent_component_counts[0],
+        )?;
+        requirements.include_current_span(
+            representative.parent1_component_base_or_sentinel,
+            color_capability.parent_component_counts[1],
+        )?;
+        requirements.include_momentum(representative.parent0_momentum_form_id)?;
+        requirements.include_momentum(representative.parent1_momentum_form_id_or_sentinel)?;
+
+        let supplements_for_anchor = &matched_supplements[anchor_index];
+        if supplements_for_anchor.len() > 2 {
+            return None;
+        }
+        let mut compiled_operands = [DirectInteractionOperand {
+            tensor_component_base: 0,
+            vector_parent: DirectInteractionVectorParent::Parent0,
+        }; 2];
+        let mut supplement_rows = [None; 2];
+        for (slot, supplement) in supplements_for_anchor.iter().enumerate() {
+            let rows = interaction_rows(
+                atv_group_rows,
+                DirectInteractionRawRun {
+                    row_start: supplement.row_start,
+                    row_count: color_run.row_count,
+                },
+            )?;
+            let atv_representative = *rows.first()?;
+            let vector_parent = match supplement.vector_parent_side {
+                0 => DirectInteractionVectorParent::Parent0,
+                1 => DirectInteractionVectorParent::Parent1,
+                _ => return None,
+            };
+            requirements.include_current_span(
+                atv_representative.parent0_component_base,
+                atv_capability.parent_component_counts[0],
+            )?;
+            compiled_operands[slot] = DirectInteractionOperand {
+                tensor_component_base: atv_representative.parent0_component_base,
+                vector_parent,
+            };
+            supplement_rows[slot] = Some(rows);
+        }
+        let operands = match supplements_for_anchor.len() {
+            0 => DirectInteractionOperands::None,
+            1 => DirectInteractionOperands::One(compiled_operands[0]),
+            2 => DirectInteractionOperands::Two(compiled_operands),
+            _ => unreachable!("interaction supplement count was bounded above"),
+        };
+
+        let output_start = u32::try_from(candidate_outputs.len()).ok()?;
+        for (offset, color_row) in color_rows.iter().enumerate() {
+            requirements.include_current_span(
+                color_row.destination_component_base,
+                color_capability.destination_component_count,
+            )?;
+            requirements.include_factor(color_row.exact_factor_id)?;
+            let mut exact_factor_ids = [color_row.exact_factor_id, 0, 0];
+            for (slot, supplement) in supplements_for_anchor.iter().enumerate() {
+                let atv_offset = *supplement.row_offsets.get(offset)?;
+                let atv_row = *supplement_rows[slot]?.get(atv_offset as usize)?;
+                if atv_row.destination_component_base != color_row.destination_component_base {
+                    return None;
+                }
+                requirements.include_factor(atv_row.exact_factor_id)?;
+                exact_factor_ids[slot + 1] = atv_row.exact_factor_id;
+            }
+            candidate_outputs.push(DirectInteractionOutput {
+                destination_component_base: color_row.destination_component_base,
+                exact_factor_ids,
+                initialize: seen_vector_destinations.insert(color_row.destination_component_base),
+            });
+        }
+        let output_end = u32::try_from(candidate_outputs.len()).ok()?;
+        let tensor_output_start = u32::try_from(candidate_tensor_outputs.len()).ok()?;
+        if let Some((wedge_capability, wedge_runs)) = &wedge_program {
+            let wedge_rows = interaction_rows(
+                schedule.groups[wedge?].contributions()?,
+                *wedge_runs.get(anchor_index)?,
+            )?;
+            for wedge_row in wedge_rows {
+                requirements.include_current_span(
+                    wedge_row.destination_component_base,
+                    wedge_capability.destination_component_count,
+                )?;
+                requirements.include_factor(wedge_row.exact_factor_id)?;
+                candidate_tensor_outputs.push(DirectInteractionTensorOutput {
+                    destination_component_base: wedge_row.destination_component_base,
+                    exact_factor_id: wedge_row.exact_factor_id,
+                    initialize: wedge_row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+                        != 0,
+                });
+            }
+        }
+        let tensor_output_end = u32::try_from(candidate_tensor_outputs.len()).ok()?;
+        candidate_anchors.push(DirectInteractionAnchor {
+            parent_component_bases: [
+                representative.parent0_component_base,
+                representative.parent1_component_base_or_sentinel,
+            ],
+            parent_momentum_form_ids: [
+                representative.parent0_momentum_form_id,
+                representative.parent1_momentum_form_id_or_sentinel,
+            ],
+            operands,
+            output_start,
+            output_end,
+            tensor_output_start,
+            tensor_output_end,
+        });
+    }
+
+    let tensor_destinations = candidate_tensor_outputs
+        .iter()
+        .map(|output| output.destination_component_base)
+        .collect::<BTreeSet<_>>();
+    if candidate_anchors
+        .iter()
+        .any(|anchor| match anchor.operands {
+            DirectInteractionOperands::None => false,
+            DirectInteractionOperands::One(operand) => {
+                tensor_destinations.contains(&operand.tensor_component_base)
+            }
+            DirectInteractionOperands::Two(operands) => operands
+                .iter()
+                .any(|operand| tensor_destinations.contains(&operand.tensor_component_base)),
+        })
+    {
+        return None;
+    }
+
+    let mut native_group_indices = vec![color_index, atv_index];
+    if let Some(wedge_index) = wedge.filter(|_| fuse_wedge) {
+        native_group_indices.push(wedge_index);
+    }
+    native_group_indices.sort_unstable();
+    let logical_row_count = native_group_indices
+        .iter()
+        .map(|&group_index| {
+            schedule.groups[group_index]
+                .contributions()
+                .map(|rows| rows.len() as u64)
+                .unwrap_or(0)
+        })
+        .sum();
+    let mut candidate = DirectInteractionStageCandidate {
+        group_indices: native_group_indices,
+        closure_group_index: None,
+        call,
+        contexts: DirectInteractionExecutorContexts {
+            color: color_capability.context,
+            vector_wedge_vector: wedge_program
+                .as_ref()
+                .map_or(std::ptr::null(), |(capability, _)| capability.context),
+            antisymmetric_tensor_vector: atv_capability.context,
+        },
+        atv_before_color: atv_index < color_index,
+        logical_row_count,
+        anchors: candidate_anchors,
+        outputs: candidate_outputs,
+        tensor_outputs: candidate_tensor_outputs,
+        terminal: None,
+        requirements,
+    };
+    attach_terminal_interaction_program(schedule, &mut candidate);
+    Some(candidate)
+}
+
+fn attach_terminal_interaction_program(
+    schedule: &DirectInteractionScheduleView<'_>,
+    candidate: &mut DirectInteractionStageCandidate,
+) {
+    let Some((closure_group_index, terminal)) =
+        compile_terminal_interaction_program(schedule, candidate)
+    else {
+        return;
+    };
+    let mut requirements = candidate.requirements;
+    if requirements
+        .include_current_span(terminal.partner_component_base, 4)
+        .is_none()
+    {
+        return;
+    }
+    for component in 0..4 {
+        let Some(factor_id) = terminal.component_factor_start.checked_add(component) else {
+            return;
+        };
+        if requirements.include_factor(factor_id).is_none() {
+            return;
+        }
+    }
+    for closure in terminal.closures.iter() {
+        if requirements
+            .include_factor(closure.exact_factor_id)
+            .is_none()
+        {
+            return;
+        }
+    }
+    candidate.requirements = requirements;
+    candidate.closure_group_index = Some(closure_group_index);
+    candidate.terminal = Some(terminal);
+}
+
+fn compile_terminal_interaction_program(
+    schedule: &DirectInteractionScheduleView<'_>,
+    candidate: &DirectInteractionStageCandidate,
+) -> Option<(usize, DirectInteractionTerminalProgram)> {
+    if !direct_terminal_interaction_rewrite_enabled(schedule.strategy)
+        || !candidate.tensor_outputs.is_empty()
+        || candidate.group_indices.len() != 2
+        || candidate.outputs.is_empty()
+        || schedule.currents.is_empty()
+    {
+        return None;
+    }
+    let mut closure_groups = schedule
+        .groups
+        .iter()
+        .enumerate()
+        .filter(|(_, group)| group.role == DirectExecutorRole::Closure);
+    let (closure_group_index, closure_group) = closure_groups.next()?;
+    if closure_groups.next().is_some() {
+        return None;
+    }
+    let DirectExecutorHandle::Closure { call, .. } = closure_group.handle? else {
+        return None;
+    };
+    if !std::ptr::fn_addr_eq(
+        call,
+        crate::engine::execute_closure_reduce_rows as DirectClosureExecutor,
+    ) {
+        return None;
+    }
+    let interaction_stage = schedule.groups[*candidate.group_indices.first()?].stage;
+    if candidate
+        .group_indices
+        .iter()
+        .any(|&group_index| schedule.groups[group_index].stage != interaction_stage)
+        || interaction_stage.checked_add(1)? != closure_group.stage
+    {
+        return None;
+    }
+    let closure_event = closure_group.stage;
+
+    let current_by_stage_and_base = schedule
+        .currents
+        .iter()
+        .filter(|current| current.node_kind == DirectNodeKind::Current)
+        .map(|current| ((u32::from(current.stage), current.component_base), current))
+        .collect::<BTreeMap<_, _>>();
+    let root_bases = candidate
+        .outputs
+        .iter()
+        .map(|output| output.destination_component_base)
+        .collect::<BTreeSet<_>>();
+    let mut root_semantic_ids = BTreeSet::new();
+    for &base in &root_bases {
+        let root = *current_by_stage_and_base.get(&(interaction_stage, base))?;
+        if root.component_count != 4
+            || root.finalization_row_or_sentinel != DIRECT_NONE_U32
+            || root.last_use != closure_event
+        {
+            return None;
+        }
+        root_semantic_ids.insert(root.semantic_current_id);
+    }
+
+    // Every write to a scalarized root must belong to this native stage.
+    // Otherwise the scalar scratch would omit a contribution or close before
+    // the final writer.
+    let consumed_groups = candidate
+        .group_indices
+        .iter()
+        .copied()
+        .collect::<BTreeSet<_>>();
+    for (group_index, group) in schedule.groups.iter().enumerate().filter(|(_, group)| {
+        group.role == DirectExecutorRole::Contribution && group.stage == interaction_stage
+    }) {
+        if group.contributions()?.iter().any(|row| {
+            root_bases.contains(&row.destination_component_base)
+                && !consumed_groups.contains(&group_index)
+        }) {
+            return None;
+        }
+    }
+    // No scalarized root may feed another contribution at this or a later
+    // stage; the closure group below must be its only remaining consumer.
+    for group in schedule.groups.iter().filter(|group| {
+        group.role == DirectExecutorRole::Contribution && group.stage >= interaction_stage
+    }) {
+        if group.contributions()?.iter().any(|row| {
+            root_bases.contains(&row.parent0_component_base)
+                || root_bases.contains(&row.parent1_component_base_or_sentinel)
+        }) {
+            return None;
+        }
+    }
+
+    // At the closure event arena liveness makes these bases unambiguous even
+    // though the arena is reused between earlier stages.
+    let mut live_current_by_base = BTreeMap::new();
+    for current in schedule
+        .currents
+        .iter()
+        .filter(|current| current.last_use == closure_event)
+    {
+        if live_current_by_base
+            .insert(current.component_base, current)
+            .is_some()
+        {
+            return None;
+        }
+    }
+    let mut partner = None;
+    let mut component_factor_start = None;
+    let mut attached_roots = BTreeSet::new();
+    let mut amplitude_destinations = BTreeSet::new();
+    let mut amplitude_destination_count = 0_u32;
+    let closure_rows = closure_group.closures()?;
+    if closure_rows.is_empty() {
+        return None;
+    }
+    let mut closures = Vec::with_capacity(closure_rows.len());
+    for row in closure_rows {
+        if row.component_count != 4 || !amplitude_destinations.insert(row.amplitude_destination_id)
+        {
+            return None;
+        }
+        amplitude_destination_count =
+            amplitude_destination_count.max(row.amplitude_destination_id.checked_add(1)?);
+        let parent0 = *live_current_by_base.get(&row.parent0_component_base)?;
+        let parent1 = *live_current_by_base.get(&row.parent1_component_base_or_sentinel)?;
+        let parent0_is_root = root_semantic_ids.contains(&parent0.semantic_current_id);
+        let parent1_is_root = root_semantic_ids.contains(&parent1.semantic_current_id);
+        if parent0_is_root == parent1_is_root {
+            return None;
+        }
+        let (root, terminal_partner) = if parent0_is_root {
+            (parent0, parent1)
+        } else {
+            (parent1, parent0)
+        };
+        if terminal_partner.component_count != 4
+            || u32::from(terminal_partner.stage) >= interaction_stage
+            || terminal_partner.last_use != closure_event
+            || terminal_partner.finalization_row_or_sentinel != DIRECT_NONE_U32
+        {
+            return None;
+        }
+        let partner_key = (
+            terminal_partner.semantic_current_id,
+            terminal_partner.component_base,
+        );
+        if partner
+            .replace(partner_key)
+            .is_some_and(|seen| seen != partner_key)
+            || component_factor_start
+                .replace(row.component_factor_start)
+                .is_some_and(|seen| seen != row.component_factor_start)
+        {
+            return None;
+        }
+        attached_roots.insert(root.semantic_current_id);
+        closures.push(DirectInteractionTerminalClosure {
+            root_component_base: root.component_base,
+            amplitude_destination_id: row.amplitude_destination_id,
+            exact_factor_id: row.exact_factor_id,
+        });
+    }
+    if attached_roots != root_semantic_ids {
+        return None;
+    }
+    Some((
+        closure_group_index,
+        DirectInteractionTerminalProgram {
+            partner_component_base: partner?.1,
+            component_factor_start: component_factor_start?,
+            amplitude_destination_count,
+            closures: closures.into_boxed_slice(),
+        },
+    ))
+}
+
+#[cfg(test)]
+mod terminal_current_descriptor_tests {
+    use super::*;
+
+    unsafe fn interaction_stub(
+        _contexts: DirectInteractionExecutorContexts,
+        _arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        _batch: DirectInteractionBundleBatch<'_>,
+    ) -> RusticolResult<()> {
+        Ok(())
+    }
+
+    fn candidate() -> DirectInteractionStageCandidate {
+        DirectInteractionStageCandidate {
+            group_indices: vec![0, 1],
+            closure_group_index: None,
+            call: interaction_stub,
+            contexts: DirectInteractionExecutorContexts {
+                color: std::ptr::null(),
+                vector_wedge_vector: std::ptr::null(),
+                antisymmetric_tensor_vector: std::ptr::null(),
+            },
+            atv_before_color: false,
+            logical_row_count: 2,
+            anchors: Vec::new(),
+            outputs: vec![DirectInteractionOutput {
+                destination_component_base: 20,
+                exact_factor_ids: [0; 3],
+                initialize: true,
+            }],
+            tensor_outputs: Vec::new(),
+            terminal: None,
+            requirements: DirectInteractionRuntimeRequirements::default(),
+        }
+    }
+
+    #[test]
+    fn terminal_compiler_requires_and_consumes_current_descriptors() {
+        let contribution = DirectContributionRow {
+            parent0_component_base: 4,
+            parent1_component_base_or_sentinel: 8,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 1,
+            destination_component_base: 20,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+        };
+        let closure = DirectClosureRow {
+            parent0_component_base: 20,
+            parent1_component_base_or_sentinel: 0,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 0,
+            amplitude_destination_id: 0,
+            exact_factor_id: 0,
+            component_factor_start: 0,
+            component_count: 4,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        let contribution0 = [contribution];
+        let contribution1 = [DirectContributionRow {
+            flags: 0,
+            ..contribution
+        }];
+        let closures = [closure];
+        let groups = [
+            DirectInteractionGroupView::contribution(1, 1, None, None, &contribution0),
+            DirectInteractionGroupView::contribution(1, 2, None, None, &contribution1),
+            DirectInteractionGroupView::closure(
+                2,
+                3,
+                DirectExecutorHandle::Closure {
+                    call: crate::engine::execute_closure_reduce_rows,
+                    context: std::ptr::null(),
+                },
+                &closures,
+            ),
+        ];
+        let currents = [
+            DirectCurrentDescriptor {
+                semantic_current_id: 0,
+                node_kind: DirectNodeKind::Current,
+                state_template_id: 0,
+                component_base: 20,
+                component_count: 4,
+                momentum_form_id: 0,
+                stage: 1,
+                selector_domain_id: 0,
+                first_use: 1,
+                last_use: 2,
+                source_row_or_sentinel: DIRECT_NONE_U32,
+                finalization_row_or_sentinel: DIRECT_NONE_U32,
+            },
+            DirectCurrentDescriptor {
+                semantic_current_id: 1,
+                node_kind: DirectNodeKind::Source,
+                state_template_id: 0,
+                component_base: 0,
+                component_count: 4,
+                momentum_form_id: 0,
+                stage: 0,
+                selector_domain_id: 0,
+                first_use: 0,
+                last_use: 2,
+                source_row_or_sentinel: 0,
+                finalization_row_or_sentinel: DIRECT_NONE_U32,
+            },
+        ];
+        let without_currents = DirectInteractionScheduleView::new(
+            RecurrenceStrategy::ContractedColorUnion,
+            &groups,
+            &[],
+            2,
+        );
+        assert!(compile_terminal_interaction_program(&without_currents, &candidate()).is_none());
+
+        let with_currents = DirectInteractionScheduleView::new(
+            RecurrenceStrategy::ContractedColorUnion,
+            &groups,
+            &currents,
+            2,
+        );
+        let (closure_group, terminal) =
+            compile_terminal_interaction_program(&with_currents, &candidate()).unwrap();
+        assert_eq!(closure_group, 2);
+        assert_eq!(terminal.partner_component_base, 0);
+        assert_eq!(terminal.closures.len(), 1);
+        assert_eq!(terminal.closures[0].root_component_base, 20);
+    }
+}
+
+fn validate_fused_fanout_row(
+    row: DirectContributionRow,
+    parent_component_counts: [u32; 2],
+    requires_two_momenta: bool,
+    arena_component_count: u32,
+    momentum_form_count: u32,
+) -> RusticolResult<()> {
+    for (base, required) in [
+        (row.parent0_component_base, parent_component_counts[0]),
+        (
+            row.parent1_component_base_or_sentinel,
+            parent_component_counts[1],
+        ),
+    ] {
+        if base == DIRECT_NONE_U32
+            || base
+                .checked_add(required)
+                .is_none_or(|end| end > arena_component_count)
+        {
+            return Err(RusticolError::integrity(
+                "direct fused fanout parent component span is incompatible with its intrinsic",
+            ));
+        }
+    }
+    if requires_two_momenta
+        && (row.parent0_momentum_form_id >= momentum_form_count
+            || row.parent1_momentum_form_id_or_sentinel >= momentum_form_count)
+    {
+        return Err(RusticolError::integrity(
+            "direct fused fanout momentum forms are incompatible with its intrinsic",
+        ));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod fused_fanout_validation_tests {
+    use super::*;
+
+    fn interaction_row(destination_component_base: u32) -> DirectContributionRow {
+        DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 4,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 1,
+            destination_component_base,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        }
+    }
+
+    #[test]
+    fn interaction_destination_bijection_accepts_nonidentity_and_rejects_nonsets() {
+        let color = [interaction_row(8), interaction_row(16), interaction_row(24)];
+        let permuted = [interaction_row(24), interaction_row(8), interaction_row(16)];
+        let color = interaction_destination_offsets(&color).unwrap();
+        let permuted = interaction_destination_offsets(&permuted).unwrap();
+        assert_eq!(
+            interaction_destination_bijection(&color, &permuted).unwrap(),
+            [1, 2, 0]
+        );
+
+        assert!(
+            interaction_destination_offsets(&[interaction_row(8), interaction_row(8),]).is_none()
+        );
+        let different = interaction_destination_offsets(&[
+            interaction_row(8),
+            interaction_row(16),
+            interaction_row(28),
+        ])
+        .unwrap();
+        assert!(interaction_destination_bijection(&color, &different).is_none());
+    }
+
+    #[test]
+    fn rejects_short_parent_spans_and_missing_momentum_forms() {
+        let row = DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 4,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: 1,
+            destination_component_base: 8,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        assert!(validate_fused_fanout_row(row, [9, 4], false, 8, 2).is_err());
+        assert!(validate_fused_fanout_row(row, [4, 4], true, 8, 1).is_err());
+        validate_fused_fanout_row(row, [4, 4], true, 8, 2).unwrap();
+    }
+
+    #[test]
+    fn interaction_execution_gate_is_full_unselected_single_point_only() {
+        let plan = crate::recurrence::direct_plan::tests::valid_plan();
+        let groups = plan.row_groups();
+        assert!(direct_interaction_execution_enabled::<true>(
+            RecurrenceStrategy::TopologyReplay,
+            groups,
+            groups,
+            None,
+            1,
+        ));
+        assert!(!direct_interaction_execution_enabled::<false>(
+            RecurrenceStrategy::TopologyReplay,
+            groups,
+            groups,
+            None,
+            1,
+        ));
+        assert!(!direct_interaction_execution_enabled::<true>(
+            RecurrenceStrategy::TopologyReplay,
+            groups,
+            groups,
+            None,
+            2,
+        ));
+        assert!(!direct_interaction_execution_enabled::<true>(
+            RecurrenceStrategy::TopologyReplay,
+            groups,
+            groups,
+            Some(0),
+            1,
+        ));
+        assert!(!direct_interaction_execution_enabled::<true>(
+            RecurrenceStrategy::AllFlowUnion,
+            groups,
+            groups,
+            None,
+            1,
+        ));
+        assert!(!direct_interaction_execution_enabled::<true>(
+            RecurrenceStrategy::ContractedColorUnion,
+            groups,
+            &groups[1..],
+            None,
+            1,
+        ));
+    }
+
+    #[test]
+    fn large_schedule_interaction_rewrite_uses_only_strategy_and_row_count() {
+        assert!(!direct_large_schedule_interaction_rewrite_enabled(
+            RecurrenceStrategy::ContractedColorUnion,
+            DIRECT_LARGE_SCHEDULE_INTERACTION_MIN_ROWS - 1,
+        ));
+        assert!(direct_large_schedule_interaction_rewrite_enabled(
+            RecurrenceStrategy::ContractedColorUnion,
+            DIRECT_LARGE_SCHEDULE_INTERACTION_MIN_ROWS,
+        ));
+        assert!(!direct_large_schedule_interaction_rewrite_enabled(
+            RecurrenceStrategy::TopologyReplay,
+            DIRECT_LARGE_SCHEDULE_INTERACTION_MIN_ROWS,
+        ));
+        assert!(!direct_large_schedule_interaction_rewrite_enabled(
+            RecurrenceStrategy::AllFlowUnion,
+            usize::MAX,
+        ));
+        assert!(direct_terminal_interaction_rewrite_enabled(
+            RecurrenceStrategy::ContractedColorUnion,
+        ));
+        assert!(!direct_terminal_interaction_rewrite_enabled(
+            RecurrenceStrategy::TopologyReplay,
+        ));
+        assert!(!direct_terminal_interaction_rewrite_enabled(
+            RecurrenceStrategy::AllFlowUnion,
+        ));
+    }
+}
+
+fn push_singleton_direct_step(
+    steps: &mut Vec<DirectSingletonFanoutStep>,
+    group_step_start: usize,
+    row_start: u32,
+    row_count: u32,
+) -> RusticolResult<()> {
+    if steps.len() > group_step_start
+        && let Some(DirectSingletonFanoutStep::Direct {
+            row_start: previous_start,
+            row_count: previous_count,
+        }) = steps.last_mut()
+        && previous_start
+            .checked_add(*previous_count)
+            .is_some_and(|end| end == row_start)
+    {
+        *previous_count = previous_count.checked_add(row_count).ok_or_else(|| {
+            RusticolError::integrity("singleton fanout direct-step count exceeds u32")
+        })?;
+        return Ok(());
+    }
+    steps.push(DirectSingletonFanoutStep::Direct {
+        row_start,
+        row_count,
+    });
+    Ok(())
+}
+
+fn flush_singleton_fanout_batch(
+    rows: &[DirectContributionRow],
+    pending_runs: &mut Vec<(u32, u32)>,
+    steps: &mut Vec<DirectSingletonFanoutStep>,
+    runs: &mut Vec<DirectContributionFanoutRun>,
+    bundles: &mut Vec<DirectContributionFanoutBundle>,
+) -> RusticolResult<()> {
+    let Some(&(first_row_start, _)) = pending_runs.first() else {
+        return Ok(());
+    };
+    let run_start = u64::try_from(runs.len())
+        .map_err(|_| RusticolError::integrity("singleton fanout run count exceeds u64"))?;
+    let mut logical_row_count = 0_u32;
+    let mut expected_start = first_row_start;
+    for &(row_start, row_count) in pending_runs.iter() {
+        if row_count < 2 || row_start != expected_start {
+            return Err(RusticolError::integrity(
+                "singleton fanout pending runs are not contiguous reusable classes",
+            ));
+        }
+        push_output_only_fanout_run(rows, u64::from(row_start), row_count, 0, runs, bundles)?;
+        logical_row_count = logical_row_count.checked_add(row_count).ok_or_else(|| {
+            RusticolError::integrity("singleton fanout batch row count exceeds u32")
+        })?;
+        expected_start = expected_start.checked_add(row_count).ok_or_else(|| {
+            RusticolError::integrity("singleton fanout pending-run coverage exceeds u32")
+        })?;
+    }
+    steps.push(DirectSingletonFanoutStep::Fanout {
+        row_start: first_row_start,
+        row_count: logical_row_count,
+        run_start,
+        run_count: u32::try_from(pending_runs.len()).map_err(|_| {
+            RusticolError::integrity("singleton fanout batch run count exceeds u32")
+        })?,
+    });
+    pending_runs.clear();
+    Ok(())
+}
+
+/// Append the shared run/bundle representation used by both persisted direct
+/// plans and family-local singleton fanout. Output-only contribution kernels
+/// leave the authenticated exact factor for this destination replay step.
+fn push_output_only_fanout_run(
+    rows: &[DirectContributionRow],
+    row_start: u64,
+    row_count: u32,
+    scratch_component_base: u32,
+    runs: &mut Vec<DirectContributionFanoutRun>,
+    bundles: &mut Vec<DirectContributionFanoutBundle>,
+) -> RusticolResult<()> {
+    let start = usize::try_from(row_start)
+        .map_err(|_| RusticolError::integrity("direct fanout row start exceeds usize"))?;
+    let end = start
+        .checked_add(row_count as usize)
+        .ok_or_else(|| RusticolError::integrity("direct fanout row range overflows usize"))?;
+    let run_rows = rows
+        .get(start..end)
+        .ok_or_else(|| RusticolError::integrity("direct fanout row range is out of bounds"))?;
+    let bundle_start = u64::try_from(bundles.len())
+        .map_err(|_| RusticolError::integrity("direct fanout bundle count exceeds u64"))?;
+    let mut offset = 0_usize;
+    while offset < run_rows.len() {
+        let factor_id = run_rows[offset].exact_factor_id;
+        let first = offset;
+        offset += 1;
+        while offset < run_rows.len() && run_rows[offset].exact_factor_id == factor_id {
+            offset += 1;
+        }
+        bundles.push(DirectContributionFanoutBundle {
+            row_start: row_start
+                .checked_add(u64::try_from(first).map_err(|_| {
+                    RusticolError::integrity("direct fanout bundle offset exceeds u64")
+                })?)
+                .ok_or_else(|| RusticolError::integrity("direct fanout bundle start overflows"))?,
+            row_count: u32::try_from(offset - first)
+                .map_err(|_| RusticolError::integrity("direct fanout factor bundle exceeds u32"))?,
+            effective_factor_id_or_sentinel: factor_id,
+        });
+    }
+    let bundle_count = u32::try_from(
+        u64::try_from(bundles.len())
+            .map_err(|_| RusticolError::integrity("direct fanout bundle count exceeds u64"))?
+            .checked_sub(bundle_start)
+            .ok_or_else(|| RusticolError::integrity("direct fanout bundle range underflows"))?,
+    )
+    .map_err(|_| RusticolError::integrity("direct fanout run bundle count exceeds u32"))?;
+    runs.push(DirectContributionFanoutRun {
+        row_start,
+        row_count,
+        scratch_component_base,
+        bundle_start,
+        bundle_count,
+    });
+    Ok(())
+}
+
+fn contribution_fanout_inputs_equal(
+    left: DirectContributionRow,
+    right: DirectContributionRow,
+    exact_factor_is_kernel_input: bool,
+) -> bool {
+    left.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE == 0
+        && right.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE == 0
+        && left.selector_domain_id == right.selector_domain_id
+        && left.parent0_component_base == right.parent0_component_base
+        && left.parent1_component_base_or_sentinel == right.parent1_component_base_or_sentinel
+        && left.parent0_momentum_form_id == right.parent0_momentum_form_id
+        && left.parent1_momentum_form_id_or_sentinel == right.parent1_momentum_form_id_or_sentinel
+        && (!exact_factor_is_kernel_input || left.exact_factor_id == right.exact_factor_id)
+}
+
+fn push_direct_fanout_step(
+    steps: &mut Vec<DirectContributionFanoutStep>,
+    segment_step_start: usize,
+    row_start: u64,
+    row_count: u32,
+) -> RusticolResult<()> {
+    if steps.len() > segment_step_start
+        && let Some(DirectContributionFanoutStep::Direct {
+            row_start: previous_start,
+            row_count: previous_count,
+        }) = steps.last_mut()
+        && previous_start
+            .checked_add(u64::from(*previous_count))
+            .is_some_and(|end| end == row_start)
+    {
+        *previous_count = previous_count.checked_add(row_count).ok_or_else(|| {
+            RusticolError::integrity("direct fanout direct-step row count exceeds u32")
+        })?;
+        return Ok(());
+    }
+    steps.push(DirectContributionFanoutStep::Direct {
+        row_start,
+        row_count,
+    });
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn flush_pending_fanout_batch(
+    plan: &DirectRecurrencePlan,
+    descriptor: &DirectRowGroupDescriptor,
+    metadata: DirectContributionExecutionMetadata,
+    scratch_component_base: u32,
+    unit_factor_id: u32,
+    pending_runs: &mut Vec<(usize, usize)>,
+    steps: &mut Vec<DirectContributionFanoutStep>,
+    representatives: &mut Vec<DirectContributionRow>,
+    runs: &mut Vec<DirectContributionFanoutRun>,
+    bundles: &mut Vec<DirectContributionFanoutBundle>,
+    scratch_component_count: &mut u32,
+    needs_unit_factor: &mut bool,
+) -> RusticolResult<()> {
+    if pending_runs.is_empty() {
+        return Ok(());
+    }
+    let representative_start = u64::try_from(representatives.len())
+        .map_err(|_| RusticolError::integrity("direct fanout representative count exceeds u64"))?;
+    let run_table_start = u64::try_from(runs.len())
+        .map_err(|_| RusticolError::integrity("direct fanout run count exceeds u64"))?;
+    let first_row_start = descriptor
+        .row_start
+        .checked_add(pending_runs[0].0 as u64)
+        .ok_or_else(|| RusticolError::integrity("direct fanout row start overflows u64"))?;
+    let mut logical_row_count = 0_u32;
+    for (slot, &(relative_start, run_count)) in pending_runs.iter().enumerate() {
+        let row_index = usize::try_from(descriptor.row_start)
+            .ok()
+            .and_then(|start| start.checked_add(relative_start))
+            .ok_or_else(|| RusticolError::integrity("direct fanout row index overflows usize"))?;
+        let mut representative = *plan.contributions().get(row_index).ok_or_else(|| {
+            RusticolError::integrity("direct fanout representative row is out of bounds")
+        })?;
+        let slot_base = u32::try_from(slot)
+            .ok()
+            .and_then(|slot| slot.checked_mul(metadata.destination_component_count))
+            .and_then(|offset| scratch_component_base.checked_add(offset))
+            .ok_or_else(|| {
+                RusticolError::integrity("direct fanout scratch component base exceeds u32")
+            })?;
+        representative.destination_component_base = slot_base;
+        representative.flags = DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION;
+        if !metadata.exact_factor_is_kernel_input {
+            representative.exact_factor_id = unit_factor_id;
+            *needs_unit_factor = true;
+        }
+        representatives.push(representative);
+        let run_row_start = descriptor
+            .row_start
+            .checked_add(relative_start as u64)
+            .ok_or_else(|| RusticolError::integrity("direct fanout run start overflows u64"))?;
+        let run_row_count = u32::try_from(run_count)
+            .map_err(|_| RusticolError::integrity("direct fanout run exceeds u32"))?;
+        if metadata.exact_factor_is_kernel_input {
+            let bundle_start = u64::try_from(bundles.len())
+                .map_err(|_| RusticolError::integrity("direct fanout bundle count exceeds u64"))?;
+            bundles.push(DirectContributionFanoutBundle {
+                row_start: run_row_start,
+                row_count: run_row_count,
+                effective_factor_id_or_sentinel: DIRECT_NONE_U32,
+            });
+            runs.push(DirectContributionFanoutRun {
+                row_start: run_row_start,
+                row_count: run_row_count,
+                scratch_component_base: slot_base,
+                bundle_start,
+                bundle_count: 1,
+            });
+        } else {
+            push_output_only_fanout_run(
+                plan.contributions(),
+                run_row_start,
+                run_row_count,
+                slot_base,
+                runs,
+                bundles,
+            )?;
+        }
+        logical_row_count = logical_row_count
+            .checked_add(u32::try_from(run_count).map_err(|_| {
+                RusticolError::integrity("direct fanout logical run count exceeds u32")
+            })?)
+            .ok_or_else(|| RusticolError::integrity("direct fanout batch row count exceeds u32"))?;
+    }
+    let representative_count = u32::try_from(pending_runs.len())
+        .map_err(|_| RusticolError::integrity("direct fanout batch exceeds u32"))?;
+    let required_scratch = representative_count
+        .checked_mul(metadata.destination_component_count)
+        .ok_or_else(|| RusticolError::integrity("direct fanout scratch size exceeds u32"))?;
+    *scratch_component_count = (*scratch_component_count).max(required_scratch);
+    steps.push(DirectContributionFanoutStep::Fanout {
+        row_start: first_row_start,
+        row_count: logical_row_count,
+        representative_start,
+        representative_count,
+        run_start: run_table_start,
+        run_count: representative_count,
+        destination_component_count: metadata.destination_component_count,
+    });
+    pending_runs.clear();
+    Ok(())
+}
+
+pub struct DirectWorkspace<'a> {
+    pub current_re: &'a mut [f64],
+    pub current_im: &'a mut [f64],
+    pub amplitude_re: &'a mut [f64],
+    pub amplitude_im: &'a mut [f64],
+    pub momenta: &'a [f64],
+    pub momentum_form_count: u32,
+    pub lorentz_component_count: u16,
+    pub parameters_re: &'a [f64],
+    pub parameters_im: &'a [f64],
+    pub factors_re: &'a [f64],
+    pub factors_im: &'a [f64],
+    pub point_stride: u32,
+}
+
+impl DirectWorkspace<'_> {
+    fn validate(&self, point_count: u32) -> RusticolResult<()> {
+        if point_count == 0 || self.point_stride == 0 || point_count > self.point_stride {
+            return Err(RusticolError::invalid_argument(
+                "direct recurrence point count must be within the workspace stride",
+            ));
+        }
+        if self.current_re.len() != self.current_im.len() {
+            return Err(RusticolError::invalid_argument(
+                "direct recurrence current real and imaginary arenas differ in length",
+            ));
+        }
+        if self.amplitude_re.len() != self.amplitude_im.len() {
+            return Err(RusticolError::invalid_argument(
+                "direct recurrence amplitude real and imaginary arenas differ in length",
+            ));
+        }
+        let point_stride = self.point_stride as usize;
+        if !self.current_re.len().is_multiple_of(point_stride)
+            || !self.amplitude_re.len().is_multiple_of(point_stride)
+        {
+            return Err(RusticolError::invalid_argument(
+                "direct recurrence arena does not contain whole point-stride planes",
+            ));
+        }
+        if self.parameters_re.len() != self.parameters_im.len()
+            || self.factors_re.len() != self.factors_im.len()
+        {
+            return Err(RusticolError::invalid_argument(
+                "direct recurrence split-complex catalogs differ in length",
+            ));
+        }
+        let expected_momenta = usize::try_from(self.momentum_form_count)
+            .ok()
+            .and_then(|forms| forms.checked_mul(usize::from(self.lorentz_component_count)))
+            .and_then(|planes| planes.checked_mul(self.point_stride as usize))
+            .ok_or_else(|| {
+                RusticolError::invalid_argument("direct recurrence momentum arena overflows")
+            })?;
+        if self.momenta.len() != expected_momenta {
+            return Err(RusticolError::invalid_argument(
+                "direct recurrence momentum arena has an inconsistent length",
+            ));
+        }
+        Ok(())
+    }
+
+    fn raw_views(
+        &mut self,
+    ) -> RusticolResult<(
+        DirectArenaView,
+        DirectMomentumView,
+        DirectParameterView,
+        DirectFactorView,
+    )> {
+        let current_scalar_len = u64::try_from(self.current_re.len()).map_err(|_| {
+            RusticolError::invalid_argument("direct recurrence current arena exceeds u64")
+        })?;
+        let amplitude_scalar_len = u64::try_from(self.amplitude_re.len()).map_err(|_| {
+            RusticolError::invalid_argument("direct recurrence amplitude arena exceeds u64")
+        })?;
+        let momentum_scalar_len = u64::try_from(self.momenta.len()).map_err(|_| {
+            RusticolError::invalid_argument("direct recurrence momentum arena exceeds u64")
+        })?;
+        let parameter_count = u32::try_from(self.parameters_re.len()).map_err(|_| {
+            RusticolError::invalid_argument("direct recurrence parameter catalog exceeds u32")
+        })?;
+        let factor_count = u32::try_from(self.factors_re.len()).map_err(|_| {
+            RusticolError::invalid_argument("direct recurrence factor catalog exceeds u32")
+        })?;
+        Ok((
+            DirectArenaView {
+                current_re: self.current_re.as_mut_ptr(),
+                current_im: self.current_im.as_mut_ptr(),
+                current_scalar_len,
+                amplitude_re: self.amplitude_re.as_mut_ptr(),
+                amplitude_im: self.amplitude_im.as_mut_ptr(),
+                amplitude_scalar_len,
+                point_stride: self.point_stride,
+            },
+            DirectMomentumView {
+                values: self.momenta.as_ptr(),
+                scalar_len: momentum_scalar_len,
+                form_count: self.momentum_form_count,
+                lorentz_component_count: self.lorentz_component_count,
+                point_stride: self.point_stride,
+            },
+            DirectParameterView {
+                values_re: self.parameters_re.as_ptr(),
+                values_im: self.parameters_im.as_ptr(),
+                value_count: parameter_count,
+            },
+            DirectFactorView {
+                values_re: self.factors_re.as_ptr(),
+                values_im: self.factors_im.as_ptr(),
+                value_count: factor_count,
+            },
+        ))
+    }
+
+    fn clear_current_stage(
+        &mut self,
+        plan: &DirectRecurrencePlan,
+        stage: u16,
+        point_count: u32,
+        selected_sector_id: Option<u32>,
+    ) -> RusticolResult<()> {
+        let current_plane_count = u32::try_from(self.current_re.len() / self.point_stride as usize)
+            .map_err(|_| {
+                RusticolError::integrity(
+                    "direct recurrence current plane count exceeds u32 during stage clear",
+                )
+            })?;
+        for current in plan.currents().iter().filter(|current| {
+            current.node_kind == DirectNodeKind::Current && current.stage == stage
+        }) {
+            if let Some(sector_id) = selected_sector_id
+                && !plan.selector_domain_contains(current.selector_domain_id, sector_id)?
+            {
+                continue;
+            }
+            clear_split_active_range(
+                self.current_re,
+                self.current_im,
+                current_plane_count,
+                self.point_stride,
+                point_count,
+                current.component_base,
+                u32::from(current.component_count),
+                "recurrence current arena",
+            )?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct DirectExecutionCounters {
+    pub source_calls: u64,
+    pub source_rows: u64,
+    pub contribution_calls: u64,
+    pub contribution_rows: u64,
+    pub finalization_calls: u64,
+    pub finalization_rows: u64,
+    pub closure_calls: u64,
+    pub closure_rows: u64,
+    pub packed_input_bytes: u64,
+    pub packed_output_bytes: u64,
+    pub scatter_bytes: u64,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct DirectExecutionRoleTimings {
+    pub source: Duration,
+    pub contribution: Duration,
+    pub finalization: Duration,
+    pub closure: Duration,
+}
+
+pub fn execute_direct_plan(
+    plan: &DirectRecurrencePlan,
+    executors: &DirectExecutorCatalog,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+    counters: &mut DirectExecutionCounters,
+) -> RusticolResult<()> {
+    let mut unused_timings = DirectExecutionRoleTimings::default();
+    execute_direct_plan_impl::<true, true>(
+        plan,
+        plan.row_groups(),
+        None,
+        executors,
+        None,
+        workspace,
+        point_count,
+        counters,
+        &mut unused_timings,
+        None,
+    )
+}
+
+pub fn execute_direct_plan_profiled(
+    plan: &DirectRecurrencePlan,
+    executors: &DirectExecutorCatalog,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+    counters: &mut DirectExecutionCounters,
+    timings: &mut DirectExecutionRoleTimings,
+) -> RusticolResult<()> {
+    execute_direct_plan_impl::<true, true>(
+        plan,
+        plan.row_groups(),
+        None,
+        executors,
+        None,
+        workspace,
+        point_count,
+        counters,
+        timings,
+        None,
+    )
+}
+
+#[allow(dead_code)]
+pub(crate) fn execute_direct_plan_profiled_with_traffic(
+    plan: &DirectRecurrencePlan,
+    executors: &DirectExecutorCatalog,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+    counters: &mut DirectExecutionCounters,
+    timings: &mut DirectExecutionRoleTimings,
+    traffic: &mut DirectArenaTrafficCounters,
+) -> RusticolResult<()> {
+    execute_direct_plan_impl::<true, true>(
+        plan,
+        plan.row_groups(),
+        None,
+        executors,
+        None,
+        workspace,
+        point_count,
+        counters,
+        timings,
+        Some(traffic),
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn execute_direct_plan_profiled_with_fanout_and_traffic(
+    plan: &DirectRecurrencePlan,
+    executors: &DirectExecutorCatalog,
+    fanout: &DirectContributionFanoutProgram,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+    counters: &mut DirectExecutionCounters,
+    timings: &mut DirectExecutionRoleTimings,
+    traffic: &mut DirectArenaTrafficCounters,
+) -> RusticolResult<()> {
+    execute_direct_plan_impl::<true, true>(
+        plan,
+        plan.row_groups(),
+        None,
+        executors,
+        Some(fanout),
+        workspace,
+        point_count,
+        counters,
+        timings,
+        Some(traffic),
+    )
+}
+
+/// Execute the authenticated schedule without touching profiling counters.
+///
+/// This is a distinct const-generic specialization so release builds remove
+/// every role-counter branch from the ordinary native evaluation path.
+pub fn execute_direct_plan_unprofiled(
+    plan: &DirectRecurrencePlan,
+    executors: &DirectExecutorCatalog,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+) -> RusticolResult<()> {
+    let mut unused = DirectExecutionCounters::default();
+    let mut unused_timings = DirectExecutionRoleTimings::default();
+    execute_direct_plan_impl::<false, true>(
+        plan,
+        plan.row_groups(),
+        None,
+        executors,
+        None,
+        workspace,
+        point_count,
+        &mut unused,
+        &mut unused_timings,
+        None,
+    )
+}
+
+pub(crate) fn execute_direct_plan_unprofiled_with_fanout(
+    plan: &DirectRecurrencePlan,
+    executors: &DirectExecutorCatalog,
+    fanout: &DirectContributionFanoutProgram,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+) -> RusticolResult<()> {
+    if point_count == 1
+        && plan.strategy() != RecurrenceStrategy::AllFlowUnion
+        && !direct_current_observation_active()
+    {
+        return fanout.execute_full_singleton_unprofiled(plan, executors, workspace);
+    }
+    let mut unused = DirectExecutionCounters::default();
+    let mut unused_timings = DirectExecutionRoleTimings::default();
+    execute_direct_plan_impl::<false, true>(
+        plan,
+        plan.row_groups(),
+        None,
+        executors,
+        Some(fanout),
+        workspace,
+        point_count,
+        &mut unused,
+        &mut unused_timings,
+        None,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+#[allow(dead_code)]
+pub(crate) fn execute_direct_plan_selected_profiled_with_traffic(
+    plan: &DirectRecurrencePlan,
+    row_groups: &[DirectRowGroupDescriptor],
+    selected_sector_id: u32,
+    executors: &DirectExecutorCatalog,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+    counters: &mut DirectExecutionCounters,
+    timings: &mut DirectExecutionRoleTimings,
+    traffic: &mut DirectArenaTrafficCounters,
+) -> RusticolResult<()> {
+    execute_direct_plan_impl::<true, false>(
+        plan,
+        row_groups,
+        Some(selected_sector_id),
+        executors,
+        None,
+        workspace,
+        point_count,
+        counters,
+        timings,
+        Some(traffic),
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn execute_direct_plan_selected_profiled_with_fanout_and_traffic(
+    plan: &DirectRecurrencePlan,
+    row_groups: &[DirectRowGroupDescriptor],
+    selected_sector_id: u32,
+    executors: &DirectExecutorCatalog,
+    fanout: &DirectContributionFanoutProgram,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+    counters: &mut DirectExecutionCounters,
+    timings: &mut DirectExecutionRoleTimings,
+    traffic: &mut DirectArenaTrafficCounters,
+) -> RusticolResult<()> {
+    execute_direct_plan_impl::<true, false>(
+        plan,
+        row_groups,
+        Some(selected_sector_id),
+        executors,
+        Some(fanout),
+        workspace,
+        point_count,
+        counters,
+        timings,
+        Some(traffic),
+    )
+}
+
+#[allow(dead_code)]
+pub(crate) fn execute_direct_plan_selected_unprofiled(
+    plan: &DirectRecurrencePlan,
+    row_groups: &[DirectRowGroupDescriptor],
+    selected_sector_id: u32,
+    executors: &DirectExecutorCatalog,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+) -> RusticolResult<()> {
+    let mut unused = DirectExecutionCounters::default();
+    let mut unused_timings = DirectExecutionRoleTimings::default();
+    execute_direct_plan_impl::<false, false>(
+        plan,
+        row_groups,
+        Some(selected_sector_id),
+        executors,
+        None,
+        workspace,
+        point_count,
+        &mut unused,
+        &mut unused_timings,
+        None,
+    )
+}
+
+pub(crate) fn execute_direct_plan_selected_unprofiled_with_fanout(
+    plan: &DirectRecurrencePlan,
+    row_groups: &[DirectRowGroupDescriptor],
+    selected_sector_id: u32,
+    executors: &DirectExecutorCatalog,
+    fanout: &DirectContributionFanoutProgram,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+) -> RusticolResult<()> {
+    let mut unused = DirectExecutionCounters::default();
+    let mut unused_timings = DirectExecutionRoleTimings::default();
+    execute_direct_plan_impl::<false, false>(
+        plan,
+        row_groups,
+        Some(selected_sector_id),
+        executors,
+        Some(fanout),
+        workspace,
+        point_count,
+        &mut unused,
+        &mut unused_timings,
+        None,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn execute_direct_plan_impl<const PROFILE: bool, const ALLOW_INTERACTION_REWRITE: bool>(
+    plan: &DirectRecurrencePlan,
+    row_groups: &[DirectRowGroupDescriptor],
+    selected_sector_id: Option<u32>,
+    executors: &DirectExecutorCatalog,
+    fanout: Option<&DirectContributionFanoutProgram>,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+    counters: &mut DirectExecutionCounters,
+    timings: &mut DirectExecutionRoleTimings,
+    traffic: Option<&mut DirectArenaTrafficCounters>,
+) -> RusticolResult<()> {
+    execute_direct_plan_with_clears_impl::<PROFILE, ALLOW_INTERACTION_REWRITE, false>(
+        plan,
+        row_groups,
+        selected_sector_id,
+        executors,
+        fanout,
+        workspace,
+        point_count,
+        counters,
+        timings,
+        traffic,
+        None,
+    )
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct DirectCurrentClearRange {
+    pub(crate) component_base: u32,
+    pub(crate) component_count: u32,
+}
+
+pub(crate) struct DirectStageClearRanges {
+    pub(crate) stage: u16,
+    pub(crate) ranges: Box<[DirectCurrentClearRange]>,
+}
+
+/// Restricted destination closures are prepared once. Their row runs may cut
+/// through a full-plan fanout step, so execute the authenticated raw rows and
+/// clear only dependency-closed stage spans whose first retained contribution
+/// does not initialize them, with no current-table scan.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn execute_direct_plan_destination_selected<const PROFILE: bool>(
+    plan: &DirectRecurrencePlan,
+    row_groups: &[DirectRowGroupDescriptor],
+    selected_sector_id: u32,
+    current_clear_stages: &[DirectStageClearRanges],
+    executors: &DirectExecutorCatalog,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+    counters: &mut DirectExecutionCounters,
+    timings: &mut DirectExecutionRoleTimings,
+    traffic: &mut DirectArenaTrafficCounters,
+) -> RusticolResult<()> {
+    execute_direct_plan_with_clears_impl::<PROFILE, false, true>(
+        plan,
+        row_groups,
+        Some(selected_sector_id),
+        executors,
+        None,
+        workspace,
+        point_count,
+        counters,
+        timings,
+        PROFILE.then_some(traffic),
+        Some(current_clear_stages),
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn execute_direct_plan_with_clears_impl<
+    const PROFILE: bool,
+    const ALLOW_INTERACTION_REWRITE: bool,
+    const PREPARED_CLEARS: bool,
+>(
+    plan: &DirectRecurrencePlan,
+    row_groups: &[DirectRowGroupDescriptor],
+    selected_sector_id: Option<u32>,
+    executors: &DirectExecutorCatalog,
+    fanout: Option<&DirectContributionFanoutProgram>,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+    counters: &mut DirectExecutionCounters,
+    timings: &mut DirectExecutionRoleTimings,
+    mut traffic: Option<&mut DirectArenaTrafficCounters>,
+    current_clear_stages: Option<&[DirectStageClearRanges]>,
+) -> RusticolResult<()> {
+    clear_direct_executor_error_detail();
+    workspace.validate(point_count)?;
+    if executors.plan_layout_digest != plan.runtime_layout_digest() {
+        return Err(RusticolError::integrity(
+            "direct recurrence executor catalog belongs to a different plan",
+        ));
+    }
+    if fanout.is_some_and(|fanout| fanout.plan_layout_digest != plan.runtime_layout_digest()) {
+        return Err(RusticolError::integrity(
+            "direct contribution fanout program belongs to a different plan",
+        ));
+    }
+    let observation_active = direct_current_observation_active();
+    let interaction_enabled = direct_interaction_execution_enabled::<ALLOW_INTERACTION_REWRITE>(
+        plan.strategy(),
+        plan.row_groups(),
+        row_groups,
+        selected_sector_id,
+        point_count,
+    ) && !observation_active;
+    // Observations promise materialized semantic currents. Bypass both native
+    // interaction rewrites and generic fanout scratch/replay while a capture
+    // is active so every authenticated row writes its ordinary destination.
+    let fanout = if observation_active { None } else { fanout };
+    // The existing dependency-closure preparation omits currents whose first
+    // retained contribution already overwrites their destination. Most fixed-
+    // source selections therefore need no stage clear at all. Unrestricted
+    // selection and all-flow-union retain their existing clearing semantics.
+    let requires_contribution_stage_clear = (selected_sector_id.is_some()
+        || plan.strategy() == RecurrenceStrategy::AllFlowUnion)
+        && (!PREPARED_CLEARS || current_clear_stages.is_none_or(|stages| !stages.is_empty()));
+    let mut initialized_contribution_stage = None;
+    for (group_index, descriptor) in row_groups.iter().enumerate() {
+        if descriptor.role == DirectExecutorRole::Source
+            && descriptor.direct_executor_id == DIRECT_NONE_U32
+            && plan.strategy() == RecurrenceStrategy::AllFlowUnion
+        {
+            // The selected union source variants were filled once by
+            // `DirectRecurrenceExecutionRuntime` before entering this static
+            // contribution/finalization/closure schedule.
+            continue;
+        }
+        if interaction_enabled && let Some(fanout) = fanout {
+            match fanout.interactions.action(group_index) {
+                DirectInteractionGroupAction::Normal => {}
+                DirectInteractionGroupAction::Consumed => continue,
+                DirectInteractionGroupAction::Execute(stage_index) => {
+                    let (logical_groups, closure_group_index, logical_row_count) =
+                        fanout.interactions.logical_groups(stage_index)?;
+                    let started = PROFILE.then(Instant::now);
+                    let (arena, momenta, parameters, factors) = workspace.raw_views()?;
+                    let closure_elapsed = fanout.interactions.execute::<PROFILE>(
+                        stage_index,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                    )?;
+                    if PROFILE {
+                        counters.contribution_calls += logical_groups.len() as u64;
+                        counters.contribution_rows += logical_row_count;
+                        if let Some(closure_group_index) = closure_group_index {
+                            let closure = &row_groups[closure_group_index as usize];
+                            counters.closure_calls += 1;
+                            counters.closure_rows += u64::from(closure.row_count);
+                        }
+                        let elapsed = started
+                            .expect("profiled interaction stage has a start time")
+                            .elapsed();
+                        timings.contribution += elapsed.saturating_sub(closure_elapsed);
+                        timings.closure += closure_elapsed;
+                        if let Some(traffic) = traffic.as_deref_mut() {
+                            for &logical_group in logical_groups {
+                                let logical_group = logical_group as usize;
+                                let logical = &row_groups[logical_group];
+                                traffic.record_call(logical.row_count, point_count);
+                            }
+                            if let Some(closure_group_index) = closure_group_index {
+                                let closure = &row_groups[closure_group_index as usize];
+                                traffic.record_call(closure.row_count, point_count);
+                            }
+                        }
+                    }
+                    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+                    for &logical_group in logical_groups {
+                        let logical_group = logical_group as usize;
+                        let logical = &row_groups[logical_group];
+                        let start = usize::try_from(logical.row_start).map_err(|_| {
+                            RusticolError::integrity(
+                                "direct interaction observation row start exceeds usize",
+                            )
+                        })?;
+                        let end =
+                            start
+                                .checked_add(logical.row_count as usize)
+                                .ok_or_else(|| {
+                                    RusticolError::integrity(
+                                        "direct interaction observation row range overflows usize",
+                                    )
+                                })?;
+                        observe_direct_current_rows(
+                            plan,
+                            logical,
+                            start,
+                            end,
+                            selected_sector_id,
+                            workspace,
+                            point_count,
+                        )?;
+                    }
+                    continue;
+                }
+            }
+        }
+        // A full topology/contracted schedule executes every authenticated
+        // initializer, so its writes replace the stage clear. All-flow-union
+        // sources are prepared outside this static row schedule and may leave
+        // additive destinations relying on the clear even without a selected
+        // sector. Selected execution likewise visits only a logical subset.
+        if requires_contribution_stage_clear
+            && descriptor.role == DirectExecutorRole::Contribution
+            && initialized_contribution_stage != Some(descriptor.stage)
+        {
+            if PREPARED_CLEARS {
+                let stages = current_clear_stages.ok_or_else(|| {
+                    RusticolError::integrity("selected recurrence has no prepared stage clears")
+                })?;
+                if let Ok(stage_index) =
+                    stages.binary_search_by_key(&descriptor.stage, |entry| entry.stage)
+                {
+                    let current_plane_count =
+                        u32::try_from(workspace.current_re.len() / workspace.point_stride as usize)
+                            .map_err(|_| {
+                                RusticolError::integrity(
+                                    "selected recurrence current plane count exceeds u32",
+                                )
+                            })?;
+                    for range in stages[stage_index].ranges.iter() {
+                        clear_split_active_range(
+                            workspace.current_re,
+                            workspace.current_im,
+                            current_plane_count,
+                            workspace.point_stride,
+                            point_count,
+                            range.component_base,
+                            range.component_count,
+                            "selected recurrence current arena",
+                        )?;
+                    }
+                }
+            } else {
+                workspace.clear_current_stage(
+                    plan,
+                    descriptor.stage,
+                    point_count,
+                    selected_sector_id,
+                )?;
+            }
+            initialized_contribution_stage = Some(descriptor.stage);
+        }
+        let start = usize::try_from(descriptor.row_start).map_err(|_| {
+            RusticolError::integrity("direct recurrence row-group start exceeds usize")
+        })?;
+        let count = usize::try_from(descriptor.row_count).map_err(|_| {
+            RusticolError::integrity("direct recurrence row-group count exceeds usize")
+        })?;
+        let end = start.checked_add(count).ok_or_else(|| {
+            RusticolError::integrity("direct recurrence row-group range overflows usize")
+        })?;
+        if descriptor.role == DirectExecutorRole::Contribution
+            && descriptor.direct_executor_id == DIRECT_NONE_U32
+        {
+            let rows = plan.contributions().get(start..end).ok_or_else(|| {
+                RusticolError::integrity("certified-reuse contribution row group is out of bounds")
+            })?;
+            let started = PROFILE.then(Instant::now);
+            execute_certified_reuse_rows(rows, workspace, point_count)?;
+            #[cfg(any(test, feature = "on-the-fly-test-support"))]
+            observe_direct_current_rows(
+                plan,
+                descriptor,
+                start,
+                end,
+                selected_sector_id,
+                workspace,
+                point_count,
+            )?;
+            if PROFILE {
+                counters.contribution_calls += 1;
+                counters.contribution_rows += u64::from(descriptor.row_count);
+                timings.contribution += started
+                    .expect("profiled certified-reuse group has a start time")
+                    .elapsed();
+                if let Some(traffic) = traffic.as_deref_mut() {
+                    traffic.record_call(descriptor.row_count, point_count);
+                }
+            }
+            continue;
+        }
+        if descriptor.role == DirectExecutorRole::Contribution
+            && let Some(fanout) = fanout
+        {
+            let handle = executors.require(
+                descriptor.direct_executor_id,
+                DirectExecutorRole::Contribution,
+            )?;
+            let DirectExecutorHandle::Contribution { call, context } = handle else {
+                return Err(RusticolError::integrity(
+                    "direct fanout executor does not have the contribution role",
+                ));
+            };
+            if PROFILE && let Some(traffic) = traffic.as_deref_mut() {
+                traffic.record_call(descriptor.row_count, point_count);
+            }
+            let started = PROFILE.then(Instant::now);
+            let scatter_bytes = execute_contribution_group_with_fanout(
+                plan,
+                descriptor,
+                fanout,
+                call,
+                context,
+                executors.contribution_fanout(descriptor.direct_executor_id),
+                workspace,
+                point_count,
+            )?;
+            if PROFILE {
+                counters.contribution_calls += 1;
+                counters.contribution_rows += u64::from(descriptor.row_count);
+                counters.scatter_bytes = counters.scatter_bytes.saturating_add(scatter_bytes);
+                timings.contribution += started
+                    .expect("profiled direct fanout group has a start time")
+                    .elapsed();
+            }
+            #[cfg(any(test, feature = "on-the-fly-test-support"))]
+            observe_direct_current_rows(
+                plan,
+                descriptor,
+                start,
+                end,
+                selected_sector_id,
+                workspace,
+                point_count,
+            )?;
+            continue;
+        }
+        let (arena, momenta, parameters, factors) = workspace.raw_views()?;
+        let handle = executors.require(descriptor.direct_executor_id, descriptor.role)?;
+        if PROFILE && let Some(traffic) = traffic.as_deref_mut() {
+            traffic.record_call(descriptor.row_count, point_count);
+        }
+        let started = PROFILE.then(Instant::now);
+        let status = unsafe {
+            match handle {
+                DirectExecutorHandle::Source { call, context } => {
+                    let rows = plan.sources().get(start..end).ok_or_else(|| {
+                        RusticolError::integrity(
+                            "direct recurrence source row group is out of bounds",
+                        )
+                    })?;
+                    if PROFILE {
+                        counters.source_calls += 1;
+                        counters.source_rows += u64::from(descriptor.row_count);
+                    }
+                    call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        rows.as_ptr(),
+                        descriptor.row_count,
+                        point_count,
+                    )
+                }
+                DirectExecutorHandle::Contribution { call, context } => {
+                    let rows = plan.contributions().get(start..end).ok_or_else(|| {
+                        RusticolError::integrity(
+                            "direct recurrence contribution row group is out of bounds",
+                        )
+                    })?;
+                    if PROFILE {
+                        counters.contribution_calls += 1;
+                        counters.contribution_rows += u64::from(descriptor.row_count);
+                    }
+                    call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        rows.as_ptr(),
+                        descriptor.row_count,
+                        point_count,
+                    )
+                }
+                DirectExecutorHandle::Finalization { call, context } => {
+                    let rows = plan.finalizations().get(start..end).ok_or_else(|| {
+                        RusticolError::integrity(
+                            "direct recurrence finalization row group is out of bounds",
+                        )
+                    })?;
+                    if PROFILE {
+                        counters.finalization_calls += 1;
+                        counters.finalization_rows += u64::from(descriptor.row_count);
+                    }
+                    call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        rows.as_ptr(),
+                        descriptor.row_count,
+                        point_count,
+                    )
+                }
+                DirectExecutorHandle::Closure { call, context } => {
+                    let rows = plan.closures().get(start..end).ok_or_else(|| {
+                        RusticolError::integrity(
+                            "direct recurrence closure row group is out of bounds",
+                        )
+                    })?;
+                    if PROFILE {
+                        counters.closure_calls += 1;
+                        counters.closure_rows += u64::from(descriptor.row_count);
+                    }
+                    call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        rows.as_ptr(),
+                        descriptor.row_count,
+                        point_count,
+                    )
+                }
+            }
+        };
+        if PROFILE {
+            let elapsed = started
+                .expect("profiled direct row group has a start time")
+                .elapsed();
+            match descriptor.role {
+                DirectExecutorRole::Source => timings.source += elapsed,
+                DirectExecutorRole::Contribution => timings.contribution += elapsed,
+                DirectExecutorRole::Finalization => timings.finalization += elapsed,
+                DirectExecutorRole::Closure => timings.closure += elapsed,
+            }
+        }
+        check_status(descriptor.role, descriptor.direct_executor_id, status)?;
+        #[cfg(any(test, feature = "on-the-fly-test-support"))]
+        observe_direct_current_rows(
+            plan,
+            descriptor,
+            start,
+            end,
+            selected_sector_id,
+            workspace,
+            point_count,
+        )?;
+    }
+    Ok(())
+}
+
+#[inline(always)]
+fn direct_interaction_execution_enabled<const ALLOW_INTERACTION_REWRITE: bool>(
+    strategy: RecurrenceStrategy,
+    authoritative_groups: &[DirectRowGroupDescriptor],
+    requested_groups: &[DirectRowGroupDescriptor],
+    selected_sector_id: Option<u32>,
+    point_count: u32,
+) -> bool {
+    ALLOW_INTERACTION_REWRITE
+        && point_count == 1
+        && selected_sector_id.is_none()
+        && strategy != RecurrenceStrategy::AllFlowUnion
+        && requested_groups.len() == authoritative_groups.len()
+        && std::ptr::eq(requested_groups.as_ptr(), authoritative_groups.as_ptr())
+}
+
+fn execute_direct_interaction_stage_views<const PROFILE: bool>(
+    stage: &DirectInteractionStage,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+) -> RusticolResult<Duration> {
+    let terminal = stage
+        .terminal
+        .as_ref()
+        .map(|terminal| DirectInteractionTerminalBatch {
+            partner_component_base: terminal.partner_component_base,
+            component_factor_start: terminal.component_factor_start,
+            amplitude_destination_count: terminal.amplitude_destination_count,
+            closures: &terminal.closures,
+        });
+    unsafe {
+        (stage.call)(
+            stage.contexts,
+            arena,
+            momenta,
+            parameters,
+            factors,
+            DirectInteractionBundleBatch {
+                anchors: &stage.anchors,
+                outputs: &stage.outputs,
+                tensor_outputs: &stage.tensor_outputs,
+                terminal,
+                requirements: stage.requirements,
+                atv_before_color: stage.atv_before_color,
+            },
+        )?;
+    }
+    let closure_started = (PROFILE && terminal.is_some()).then(Instant::now);
+    if let Some(terminal) = terminal {
+        unsafe {
+            crate::engine::execute_interaction_terminal_closures(arena, factors, terminal)?;
+        }
+    }
+    Ok(closure_started.map_or(Duration::ZERO, |started| started.elapsed()))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn execute_contribution_group_with_fanout(
+    plan: &DirectRecurrencePlan,
+    descriptor: &DirectRowGroupDescriptor,
+    fanout: &DirectContributionFanoutProgram,
+    call: DirectContributionExecutor,
+    context: *const c_void,
+    fused: Option<DirectContributionFanoutExecutorHandle>,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+) -> RusticolResult<u64> {
+    let current_plane_count = u32::try_from(
+        workspace.current_re.len() / workspace.point_stride as usize,
+    )
+    .map_err(|_| RusticolError::integrity("direct fanout current plane count exceeds u32"))?;
+    let scratch_end = fanout
+        .scratch_component_base
+        .checked_add(fanout.scratch_component_count)
+        .ok_or_else(|| RusticolError::integrity("direct fanout scratch range overflows u32"))?;
+    if fanout.scratch_component_base != plan.current_arena_components()
+        || scratch_end > current_plane_count
+    {
+        return Err(RusticolError::integrity(
+            "direct fanout scratch range is outside its private current arena",
+        ));
+    }
+    if fanout.needs_unit_factor {
+        let factor = fanout.unit_factor_id as usize;
+        if workspace
+            .factors_re
+            .get(factor)
+            .map(|value| value.to_bits())
+            != Some(1.0_f64.to_bits())
+            || workspace
+                .factors_im
+                .get(factor)
+                .map(|value| value.to_bits())
+                != Some(0.0_f64.to_bits())
+        {
+            return Err(RusticolError::integrity(
+                "direct fanout private exact factor is not complex unity",
+            ));
+        }
+    }
+    let steps = fanout.group_steps(descriptor)?;
+    let (arena, momenta, parameters, factors) = workspace.raw_views()?;
+    let mut scatter_bytes = 0_u64;
+    for step in steps {
+        match *step {
+            DirectContributionFanoutStep::Direct {
+                row_start,
+                row_count,
+            } => {
+                let start = usize::try_from(row_start).map_err(|_| {
+                    RusticolError::integrity("direct fanout direct-row start exceeds usize")
+                })?;
+                let end = start.checked_add(row_count as usize).ok_or_else(|| {
+                    RusticolError::integrity("direct fanout direct-row range overflows usize")
+                })?;
+                let rows = plan.contributions().get(start..end).ok_or_else(|| {
+                    RusticolError::integrity("direct fanout direct-row range is out of bounds")
+                })?;
+                let status = unsafe {
+                    call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        rows.as_ptr(),
+                        row_count,
+                        point_count,
+                    )
+                };
+                check_status(
+                    DirectExecutorRole::Contribution,
+                    descriptor.direct_executor_id,
+                    status,
+                )?;
+            }
+            DirectContributionFanoutStep::Fanout {
+                row_count,
+                representative_start,
+                representative_count,
+                run_start,
+                run_count,
+                destination_component_count,
+                ..
+            } => {
+                if point_count == 1
+                    && let Some(fused) = fused
+                {
+                    let start = usize::try_from(run_start).map_err(|_| {
+                        RusticolError::integrity("direct fanout run start exceeds usize")
+                    })?;
+                    let end = start.checked_add(run_count as usize).ok_or_else(|| {
+                        RusticolError::integrity("direct fanout run range overflows usize")
+                    })?;
+                    let runs = fanout.runs.get(start..end).ok_or_else(|| {
+                        RusticolError::integrity("direct fanout run range is out of bounds")
+                    })?;
+                    debug_assert_eq!(
+                        fused.destination_component_count,
+                        destination_component_count
+                    );
+                    unsafe {
+                        (fused.call)(
+                            fused.context,
+                            arena,
+                            momenta,
+                            parameters,
+                            factors,
+                            DirectContributionFanoutBatch {
+                                rows: plan.contributions(),
+                                runs,
+                                bundles: &fanout.bundles,
+                            },
+                        )
+                    }?;
+                    continue;
+                }
+                let representative_start = usize::try_from(representative_start).map_err(|_| {
+                    RusticolError::integrity("direct fanout representative start exceeds usize")
+                })?;
+                let representative_end = representative_start
+                    .checked_add(representative_count as usize)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "direct fanout representative range overflows usize",
+                        )
+                    })?;
+                let representatives = fanout
+                    .representatives
+                    .get(representative_start..representative_end)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "direct fanout representative range is out of bounds",
+                        )
+                    })?;
+                let status = unsafe {
+                    call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        representatives.as_ptr(),
+                        representative_count,
+                        point_count,
+                    )
+                };
+                check_status(
+                    DirectExecutorRole::Contribution,
+                    descriptor.direct_executor_id,
+                    status,
+                )?;
+                let run_start = usize::try_from(run_start).map_err(|_| {
+                    RusticolError::integrity("direct fanout run start exceeds usize")
+                })?;
+                let run_end = run_start.checked_add(run_count as usize).ok_or_else(|| {
+                    RusticolError::integrity("direct fanout run range overflows usize")
+                })?;
+                let batch_runs = fanout.runs.get(run_start..run_end).ok_or_else(|| {
+                    RusticolError::integrity("direct fanout run range is out of bounds")
+                })?;
+                debug_assert_eq!(run_count, representative_count);
+                debug_assert_eq!(
+                    batch_runs
+                        .iter()
+                        .map(|run| u64::from(run.row_count))
+                        .sum::<u64>(),
+                    u64::from(row_count)
+                );
+                for run in batch_runs {
+                    scatter_contribution_fanout_run(
+                        plan,
+                        fanout,
+                        *run,
+                        destination_component_count,
+                        workspace,
+                        point_count,
+                    )?;
+                }
+                scatter_bytes = scatter_bytes.saturating_add(
+                    u64::from(row_count)
+                        .saturating_mul(u64::from(destination_component_count))
+                        .saturating_mul(u64::from(point_count))
+                        .saturating_mul(4 * size_of::<f64>() as u64),
+                );
+            }
+        }
+    }
+    Ok(scatter_bytes)
+}
+
+#[derive(Clone, Copy)]
+pub(crate) enum DirectContributionFanoutScale {
+    Unity,
+    NegativeUnity,
+    Real(f64),
+    Imaginary(f64),
+    Complex(f64, f64),
+}
+
+impl DirectContributionFanoutScale {
+    #[inline(always)]
+    pub(crate) fn new(real: f64, imaginary: f64) -> Self {
+        if imaginary == 0.0 {
+            if real == 1.0 {
+                Self::Unity
+            } else if real == -1.0 {
+                Self::NegativeUnity
+            } else {
+                Self::Real(real)
+            }
+        } else if real == 0.0 {
+            Self::Imaginary(imaginary)
+        } else {
+            Self::Complex(real, imaginary)
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn apply(self, real: f64, imaginary: f64) -> (f64, f64) {
+        match self {
+            Self::Unity => (real, imaginary),
+            Self::NegativeUnity => (-real, -imaginary),
+            Self::Real(scale) => (real * scale, imaginary * scale),
+            Self::Imaginary(scale) => (-imaginary * scale, real * scale),
+            Self::Complex(scale_re, scale_im) => (
+                real * scale_re - imaginary * scale_im,
+                real * scale_im + imaginary * scale_re,
+            ),
+        }
+    }
+}
+
+fn scatter_contribution_fanout_run(
+    plan: &DirectRecurrencePlan,
+    fanout: &DirectContributionFanoutProgram,
+    run: DirectContributionFanoutRun,
+    destination_component_count: u32,
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+) -> RusticolResult<()> {
+    let stride = workspace.point_stride as usize;
+    let active_points = point_count as usize;
+    let source_end = run
+        .scratch_component_base
+        .checked_add(destination_component_count)
+        .ok_or_else(|| RusticolError::integrity("direct fanout source range overflows u32"))?;
+    let current_plane_count = u32::try_from(workspace.current_re.len() / stride)
+        .map_err(|_| RusticolError::integrity("direct fanout current plane count exceeds u32"))?;
+    if run.scratch_component_base < fanout.scratch_component_base
+        || source_end > current_plane_count
+    {
+        return Err(RusticolError::integrity(
+            "direct fanout source range is outside its private current arena",
+        ));
+    }
+    let bundle_start = usize::try_from(run.bundle_start)
+        .map_err(|_| RusticolError::integrity("direct fanout bundle start exceeds usize"))?;
+    let bundle_end = bundle_start
+        .checked_add(run.bundle_count as usize)
+        .ok_or_else(|| RusticolError::integrity("direct fanout bundle range overflows usize"))?;
+    let bundles = fanout
+        .bundles
+        .get(bundle_start..bundle_end)
+        .ok_or_else(|| RusticolError::integrity("direct fanout bundle range is out of bounds"))?;
+    debug_assert_eq!(
+        bundles
+            .iter()
+            .map(|bundle| u64::from(bundle.row_count))
+            .sum::<u64>(),
+        u64::from(run.row_count)
+    );
+
+    let current_re = workspace.current_re.as_mut_ptr();
+    let current_im = workspace.current_im.as_mut_ptr();
+    for bundle in bundles {
+        let start = usize::try_from(bundle.row_start).map_err(|_| {
+            RusticolError::integrity("direct fanout bundle row start exceeds usize")
+        })?;
+        let end = start
+            .checked_add(bundle.row_count as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity("direct fanout bundle row range overflows usize")
+            })?;
+        let rows = plan.contributions().get(start..end).ok_or_else(|| {
+            RusticolError::integrity("direct fanout bundle row range is out of bounds")
+        })?;
+        let scale = if bundle.effective_factor_id_or_sentinel == DIRECT_NONE_U32 {
+            DirectContributionFanoutScale::Unity
+        } else {
+            let factor = bundle.effective_factor_id_or_sentinel as usize;
+            DirectContributionFanoutScale::new(
+                *workspace.factors_re.get(factor).ok_or_else(|| {
+                    RusticolError::integrity("direct fanout scatter factor is out of bounds")
+                })?,
+                *workspace.factors_im.get(factor).ok_or_else(|| {
+                    RusticolError::integrity("direct fanout scatter factor is out of bounds")
+                })?,
+            )
+        };
+        for component in 0..destination_component_count {
+            let source_start = (run.scratch_component_base as usize + component as usize) * stride;
+            for point in 0..active_points {
+                let source = source_start + point;
+                // SAFETY: the source run is checked against the runtime arena
+                // above. The destination rows and their full component spans
+                // were authenticated by `DirectRecurrencePlan` and matched to
+                // this executor's destination shape when the fanout program
+                // was built. `workspace.validate` established point < stride.
+                let (scaled_re, scaled_im) =
+                    unsafe { scale.apply(*current_re.add(source), *current_im.add(source)) };
+                for row in rows {
+                    let destination =
+                        (row.destination_component_base as usize + component as usize) * stride
+                            + point;
+                    // SAFETY: see the source/destination proof immediately
+                    // above. Scratch components form a private suffix, so none
+                    // of these writes can alias the representative source.
+                    unsafe {
+                        if row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0 {
+                            *current_re.add(destination) = scaled_re;
+                            *current_im.add(destination) = scaled_im;
+                        } else {
+                            *current_re.add(destination) += scaled_re;
+                            *current_im.add(destination) += scaled_im;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+#[allow(clippy::too_many_arguments)]
+fn observe_direct_current_rows(
+    plan: &DirectRecurrencePlan,
+    descriptor: &DirectRowGroupDescriptor,
+    start: usize,
+    end: usize,
+    selected_sector_id: Option<u32>,
+    workspace: &DirectWorkspace<'_>,
+    point_count: u32,
+) -> RusticolResult<()> {
+    let active = DIRECT_CURRENT_OBSERVATION.with(|slot| slot.borrow().is_some());
+    if !active || descriptor.role == DirectExecutorRole::Closure {
+        return Ok(());
+    }
+
+    let affected = match descriptor.role {
+        DirectExecutorRole::Source => plan
+            .currents()
+            .iter()
+            .filter(|current| {
+                current.source_row_or_sentinel != DIRECT_NONE_U32
+                    && (start..end).contains(&(current.source_row_or_sentinel as usize))
+            })
+            .map(|current| current.semantic_current_id)
+            .collect::<BTreeSet<_>>(),
+        DirectExecutorRole::Contribution => {
+            let destinations = plan
+                .contributions()
+                .get(start..end)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "direct current observation contribution range is out of bounds",
+                    )
+                })?
+                .iter()
+                .map(|row| row.destination_component_base)
+                .collect::<BTreeSet<_>>();
+            plan.currents()
+                .iter()
+                .filter(|current| {
+                    current.node_kind == DirectNodeKind::Current
+                        && current.stage == descriptor.stage
+                        && destinations.iter().any(|destination| {
+                            *destination >= current.component_base
+                                && *destination
+                                    < current.component_base + u32::from(current.component_count)
+                        })
+                })
+                .map(|current| current.semantic_current_id)
+                .collect::<BTreeSet<_>>()
+        }
+        DirectExecutorRole::Finalization => plan
+            .currents()
+            .iter()
+            .filter(|current| {
+                current.finalization_row_or_sentinel != DIRECT_NONE_U32
+                    && (start..end).contains(&(current.finalization_row_or_sentinel as usize))
+            })
+            .map(|current| current.semantic_current_id)
+            .collect::<BTreeSet<_>>(),
+        DirectExecutorRole::Closure => BTreeSet::new(),
+    };
+    if affected.is_empty() {
+        return Ok(());
+    }
+
+    DIRECT_CURRENT_OBSERVATION.with(|slot| {
+        let mut slot = slot.borrow_mut();
+        let observation = slot.as_mut().ok_or_else(|| {
+            RusticolError::integrity("direct current observation disappeared during execution")
+        })?;
+        if observation.plan_semantic_digest != plan.semantic_digest()
+            || observation.runtime_layout_digest != plan.runtime_layout_digest()
+            || observation.selected_sector_id != selected_sector_id
+            || observation.point_count != point_count
+        {
+            return Err(RusticolError::integrity(
+                "direct current observation does not match this plan execution",
+            ));
+        }
+        let stride = workspace.point_stride as usize;
+        let active_points = point_count as usize;
+        for semantic_current_id in affected {
+            let current = plan
+                .currents()
+                .get(semantic_current_id as usize)
+                .filter(|current| current.semantic_current_id == semantic_current_id)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "direct current observation semantic current is absent",
+                    )
+                })?;
+            if let Some(sector_id) = selected_sector_id
+                && !plan.selector_domain_contains(current.selector_domain_id, sector_id)?
+            {
+                continue;
+            }
+            let mut values = Vec::with_capacity(
+                usize::from(current.component_count)
+                    .checked_mul(active_points)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "direct current observation value count overflows usize",
+                        )
+                    })?,
+            );
+            for component in 0..usize::from(current.component_count) {
+                let plane = (current.component_base as usize)
+                    .checked_add(component)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "direct current observation component range overflows usize",
+                        )
+                    })?;
+                let begin = plane.checked_mul(stride).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "direct current observation arena range overflows usize",
+                    )
+                })?;
+                let finish = begin.checked_add(active_points).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "direct current observation arena range overflows usize",
+                    )
+                })?;
+                let real = workspace.current_re.get(begin..finish).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "direct current observation real range is out of bounds",
+                    )
+                })?;
+                let imaginary = workspace.current_im.get(begin..finish).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "direct current observation imaginary range is out of bounds",
+                    )
+                })?;
+                values.extend(real.iter().copied().zip(imaginary.iter().copied()));
+            }
+            observation.currents.insert(
+                semantic_current_id,
+                DirectObservedCurrentValue {
+                    descriptor: *current,
+                    values,
+                },
+            );
+        }
+        Ok(())
+    })
+}
+
+pub(crate) fn execute_certified_reuse_rows(
+    rows: &[DirectContributionRow],
+    workspace: &mut DirectWorkspace<'_>,
+    point_count: u32,
+) -> RusticolResult<()> {
+    let stride = workspace.point_stride as usize;
+    let point_count = point_count as usize;
+    for (index, row) in rows.iter().enumerate() {
+        if row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE == 0
+            || row.parent1_component_base_or_sentinel != DIRECT_NONE_U32
+            || row.parent1_momentum_form_id_or_sentinel != DIRECT_NONE_U32
+        {
+            return Err(RusticolError::integrity(format!(
+                "certified-reuse row {index} has an invalid relation encoding"
+            )));
+        }
+        let component_count = row.parent0_momentum_form_id as usize;
+        if component_count == 0 {
+            return Err(RusticolError::integrity(format!(
+                "certified-reuse row {index} has zero components"
+            )));
+        }
+        let factor_index = row.exact_factor_id as usize;
+        let factor_re = *workspace
+            .factors_re
+            .get(factor_index)
+            .ok_or_else(|| RusticolError::integrity("certified-reuse factor is out of bounds"))?;
+        let factor_im = *workspace
+            .factors_im
+            .get(factor_index)
+            .ok_or_else(|| RusticolError::integrity("certified-reuse factor is out of bounds"))?;
+        for component in 0..component_count {
+            let source_plane = row.parent0_component_base as usize + component;
+            let destination_plane = row.destination_component_base as usize + component;
+            let source_start = source_plane.checked_mul(stride).ok_or_else(|| {
+                RusticolError::integrity("certified-reuse source range overflows usize")
+            })?;
+            let destination_start = destination_plane.checked_mul(stride).ok_or_else(|| {
+                RusticolError::integrity("certified-reuse destination range overflows usize")
+            })?;
+            let source_end = source_start.checked_add(point_count).ok_or_else(|| {
+                RusticolError::integrity("certified-reuse source range overflows usize")
+            })?;
+            let destination_end = destination_start.checked_add(point_count).ok_or_else(|| {
+                RusticolError::integrity("certified-reuse destination range overflows usize")
+            })?;
+            if source_end > workspace.current_re.len()
+                || source_end > workspace.current_im.len()
+                || destination_end > workspace.current_re.len()
+                || destination_end > workspace.current_im.len()
+            {
+                return Err(RusticolError::integrity(
+                    "certified-reuse source or destination range is out of bounds",
+                ));
+            }
+            // Certified reuse is an exact algebraic scale-copy. In
+            // particular, an exact zero factor overwrites with zero even when
+            // the representative aliases a freshly initialized destination.
+            // Do not evaluate `NaN * 0.0`: without the former unconditional
+            // stage clear that would preserve stale arena payloads instead of
+            // materializing the certified zero current.
+            if factor_re == 0.0 && factor_im == 0.0 {
+                workspace.current_re[destination_start..destination_end].fill(0.0);
+                workspace.current_im[destination_start..destination_end].fill(0.0);
+                continue;
+            }
+            for point in 0..point_count {
+                let source_index = source_start + point;
+                let destination_index = destination_start + point;
+                let source_re = *workspace.current_re.get(source_index).ok_or_else(|| {
+                    RusticolError::integrity("certified-reuse source real range is out of bounds")
+                })?;
+                let source_im = *workspace.current_im.get(source_index).ok_or_else(|| {
+                    RusticolError::integrity(
+                        "certified-reuse source imaginary range is out of bounds",
+                    )
+                })?;
+                *workspace
+                    .current_re
+                    .get_mut(destination_index)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "certified-reuse destination real range is out of bounds",
+                        )
+                    })? = source_re * factor_re - source_im * factor_im;
+                *workspace
+                    .current_im
+                    .get_mut(destination_index)
+                    .ok_or_else(|| {
+                        RusticolError::integrity(
+                            "certified-reuse destination imaginary range is out of bounds",
+                        )
+                    })? = source_re * factor_im + source_im * factor_re;
+            }
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn check_status(
+    role: DirectExecutorRole,
+    executor_id: u32,
+    status: c_int,
+) -> RusticolResult<()> {
+    if status == DIRECT_STATUS_OK {
+        return Ok(());
+    }
+    if let Some(detail) = take_direct_executor_error_detail() {
+        Err(RusticolError::with_kind(
+            detail.kind(),
+            format!(
+                "direct recurrence {role:?} executor {executor_id} failed: {}",
+                detail.message()
+            ),
+        ))
+    } else {
+        Err(RusticolError::evaluation(format!(
+            "direct recurrence {role:?} executor {executor_id} returned status {status}"
+        )))
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_backend_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_backend_tests.rs
new file mode 100644
index 0000000000..8c2afba696
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_backend_tests.rs
@@ -0,0 +1,571 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::direct_backend::*;
+use super::direct_plan::{
+    DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE, DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+    DIRECT_NONE_U32, DirectClosureRow, DirectContributionRow, DirectExecutorRole,
+    DirectFinalizationRow, DirectRecurrencePlan, DirectSourceRow,
+};
+use super::exact::{ExactComplexRational, ExactRational};
+use crate::RusticolErrorKind;
+use std::ffi::c_void;
+
+const STATUS_BOUNDS: i32 = 2;
+
+#[test]
+fn executor_status_success_keeps_first_failure_detail_until_an_actual_failure() {
+    clear_direct_executor_error_detail();
+    record_direct_executor_error_detail(crate::RusticolError::integrity(
+        "descriptor row 789823 is invalid",
+    ));
+    record_direct_executor_error_detail(crate::RusticolError::internal(
+        "later detail must not replace the first failure",
+    ));
+
+    assert!(check_status(DirectExecutorRole::Source, 7, DIRECT_STATUS_OK).is_ok());
+
+    let error = check_status(DirectExecutorRole::Contribution, 312, 4).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Integrity);
+    assert_eq!(
+        error.message(),
+        "direct recurrence Contribution executor 312 failed: descriptor row 789823 is invalid"
+    );
+
+    let generic = check_status(DirectExecutorRole::Contribution, 312, 4).unwrap_err();
+    assert_eq!(generic.kind(), RusticolErrorKind::Evaluation);
+    assert_eq!(
+        generic.message(),
+        "direct recurrence Contribution executor 312 returned status 4"
+    );
+}
+
+#[test]
+fn executor_status_entry_clear_prevents_stale_detail_leakage() {
+    record_direct_executor_error_detail(crate::RusticolError::integrity(
+        "detail from an earlier schedule",
+    ));
+    clear_direct_executor_error_detail();
+
+    let error = check_status(DirectExecutorRole::Closure, 41, 9).unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Evaluation);
+    assert_eq!(
+        error.message(),
+        "direct recurrence Closure executor 41 returned status 9"
+    );
+}
+
+unsafe extern "C" fn fill_sources(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    _factors: DirectFactorView,
+    rows: *const DirectSourceRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        for point in 0..point_count as usize {
+            let source = (row.momentum_form_id as usize
+                * momenta.lorentz_component_count as usize
+                * momenta.point_stride as usize)
+                + point;
+            let destination =
+                row.destination_component_base as usize * arena.point_stride as usize + point;
+            if source >= momenta.scalar_len as usize
+                || destination >= arena.current_scalar_len as usize
+            {
+                return STATUS_BOUNDS;
+            }
+            unsafe {
+                *arena.current_re.add(destination) = *momenta.values.add(source);
+                *arena.current_im.add(destination) = 0.0;
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+unsafe extern "C" fn accumulate_contributions(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        if row.exact_factor_id >= factors.value_count || parameters.value_count == 0 {
+            return STATUS_BOUNDS;
+        }
+        let factor_re = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        let factor_im = unsafe { *factors.values_im.add(row.exact_factor_id as usize) };
+        let parameter_re = unsafe { *parameters.values_re };
+        let parameter_im = unsafe { *parameters.values_im };
+        let scale_re = factor_re * parameter_re - factor_im * parameter_im;
+        let scale_im = factor_re * parameter_im + factor_im * parameter_re;
+        for point in 0..point_count as usize {
+            let source = row.parent0_component_base as usize * arena.point_stride as usize + point;
+            let destination =
+                row.destination_component_base as usize * arena.point_stride as usize + point;
+            if source >= arena.current_scalar_len as usize
+                || destination >= arena.current_scalar_len as usize
+            {
+                return STATUS_BOUNDS;
+            }
+            let source_re = unsafe { *arena.current_re.add(source) };
+            let source_im = unsafe { *arena.current_im.add(source) };
+            unsafe {
+                *arena.current_re.add(destination) += source_re * scale_re - source_im * scale_im;
+                *arena.current_im.add(destination) += source_re * scale_im + source_im * scale_re;
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+unsafe extern "C" fn finalize_currents(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectFinalizationRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        if row.exact_factor_id >= factors.value_count {
+            return STATUS_BOUNDS;
+        }
+        let scale = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        for component in 0..usize::from(row.component_count) {
+            for point in 0..point_count as usize {
+                let destination =
+                    (row.component_base as usize + component) * arena.point_stride as usize + point;
+                if destination >= arena.current_scalar_len as usize {
+                    return STATUS_BOUNDS;
+                }
+                unsafe {
+                    *arena.current_re.add(destination) *= scale;
+                    *arena.current_im.add(destination) *= scale;
+                }
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+unsafe extern "C" fn accumulate_closures(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectClosureRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        if row.exact_factor_id >= factors.value_count {
+            return STATUS_BOUNDS;
+        }
+        let scale = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        for point in 0..point_count as usize {
+            let source = row.parent0_component_base as usize * arena.point_stride as usize + point;
+            let destination =
+                row.amplitude_destination_id as usize * arena.point_stride as usize + point;
+            if source >= arena.current_scalar_len as usize
+                || destination >= arena.amplitude_scalar_len as usize
+            {
+                return STATUS_BOUNDS;
+            }
+            unsafe {
+                *arena.amplitude_re.add(destination) += *arena.current_re.add(source) * scale;
+                *arena.amplitude_im.add(destination) += *arena.current_im.add(source) * scale;
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+#[test]
+fn synthetic_program_reads_rows_and_accumulates_directly_into_arenas() {
+    let source_rows = [DirectSourceRow {
+        source_slot: 0,
+        destination_component_base: 0,
+        momentum_form_id: 0,
+        source_template_or_dispatch_domain: 0,
+        spin_state_class: 1,
+        exact_factor_id: 0,
+        selector_domain_id: 0,
+    }];
+    let contribution_rows = [DirectContributionRow {
+        parent0_component_base: 0,
+        parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+        parent0_momentum_form_id: 0,
+        parent1_momentum_form_id_or_sentinel: u32::MAX,
+        destination_component_base: 1,
+        exact_factor_id: 0,
+        selector_domain_id: 0,
+        flags: 0,
+    }];
+    let finalization_rows = [DirectFinalizationRow {
+        component_base: 1,
+        component_count: 1,
+        momentum_form_id: 0,
+        exact_factor_id: 1,
+        selector_domain_id: 0,
+        flags: 0,
+    }];
+    let closure_rows = [DirectClosureRow {
+        parent0_component_base: 1,
+        parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+        parent0_momentum_form_id: 0,
+        parent1_momentum_form_id_or_sentinel: u32::MAX,
+        amplitude_destination_id: 0,
+        exact_factor_id: 2,
+        component_factor_start: 0,
+        component_count: 1,
+        selector_domain_id: 0,
+        flags: 0,
+    }];
+    let mut parts = super::direct_plan::tests::valid_parts();
+    parts.current_arena_components = 2;
+    parts.currents[0].component_count = 1;
+    parts.currents[1].component_base = 1;
+    parts.sources = source_rows.to_vec();
+    parts.contributions = contribution_rows.to_vec();
+    parts.finalizations = finalization_rows.to_vec();
+    parts.closures = closure_rows.to_vec();
+    parts.exact_factors = vec![ExactComplexRational::ONE; 3];
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        vec![
+            DirectExecutorHandle::Source {
+                call: fill_sources,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Contribution {
+                call: accumulate_contributions,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Finalization {
+                call: finalize_currents,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Closure {
+                call: accumulate_closures,
+                context: std::ptr::null(),
+            },
+        ],
+    )
+    .unwrap();
+
+    // `DirectWorkspace` is the compatibility-facing public adapter. It keeps
+    // accepting ordinary Rust slices and the pre-substrate stride contract;
+    // the owned generic workspace used by the runtime enforces 64-byte planes.
+    let mut current_re = [0.0; 8];
+    let mut current_im = [0.0; 8];
+    let mut amplitude_re = [0.0; 4];
+    let mut amplitude_im = [0.0; 4];
+    let momenta = [1.0, 2.0, 3.0, 4.0];
+    let parameters_re = [3.0];
+    let parameters_im = [0.0];
+    let factors_re = [2.0, 0.5, -1.0];
+    let factors_im = [0.0; 3];
+    let mut workspace = DirectWorkspace {
+        current_re: &mut current_re,
+        current_im: &mut current_im,
+        amplitude_re: &mut amplitude_re,
+        amplitude_im: &mut amplitude_im,
+        momenta: &momenta,
+        momentum_form_count: 1,
+        lorentz_component_count: 1,
+        parameters_re: &parameters_re,
+        parameters_im: &parameters_im,
+        factors_re: &factors_re,
+        factors_im: &factors_im,
+        point_stride: 4,
+    };
+    let current_re_pointer = workspace.current_re.as_ptr();
+    let amplitude_re_pointer = workspace.amplitude_re.as_ptr();
+    let mut counters = DirectExecutionCounters::default();
+
+    begin_direct_current_observation(&plan, None, 4).unwrap();
+    execute_direct_plan(&plan, &executors, &mut workspace, 4, &mut counters).unwrap();
+    let observation = take_direct_current_observation().unwrap();
+
+    assert_eq!(workspace.current_re.as_ptr(), current_re_pointer);
+    assert_eq!(workspace.amplitude_re.as_ptr(), amplitude_re_pointer);
+    assert_eq!(workspace.current_re[0..4], momenta);
+    assert_eq!(workspace.current_re[4..8], [3.0, 6.0, 9.0, 12.0]);
+    assert_eq!(workspace.amplitude_re, &[-3.0, -6.0, -9.0, -12.0]);
+    assert!(workspace.current_im.iter().all(|value| *value == 0.0));
+    assert!(workspace.amplitude_im.iter().all(|value| *value == 0.0));
+    assert_eq!(observation.plan_semantic_digest, plan.semantic_digest());
+    assert_eq!(
+        observation.runtime_layout_digest,
+        plan.runtime_layout_digest()
+    );
+    assert_eq!(observation.selected_sector_id, None);
+    assert_eq!(observation.point_count, 4);
+    assert_eq!(
+        observation.currents[&0].values,
+        [(1.0, 0.0), (2.0, 0.0), (3.0, 0.0), (4.0, 0.0)]
+    );
+    assert_eq!(
+        observation.currents[&1].values,
+        [(3.0, 0.0), (6.0, 0.0), (9.0, 0.0), (12.0, 0.0)]
+    );
+    assert_eq!(
+        counters,
+        DirectExecutionCounters {
+            source_calls: 1,
+            source_rows: 1,
+            contribution_calls: 1,
+            contribution_rows: 1,
+            finalization_calls: 1,
+            finalization_rows: 1,
+            closure_calls: 1,
+            closure_rows: 1,
+            packed_input_bytes: 0,
+            packed_output_bytes: 0,
+            scatter_bytes: 0,
+        }
+    );
+}
+
+#[test]
+fn certified_reuse_row_scale_copies_without_calling_an_interaction_executor() {
+    let mut parts = super::direct_plan::tests::valid_parts();
+    parts.currents[0].component_count = 1;
+    parts.contributions[0] = DirectContributionRow {
+        parent0_component_base: 0,
+        parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+        // The certified-reuse encoding stores component count here.
+        parent0_momentum_form_id: 1,
+        parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+        destination_component_base: 2,
+        exact_factor_id: 0,
+        selector_domain_id: 0,
+        flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+            | DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE,
+    };
+    parts.row_groups[1].direct_executor_id = DIRECT_NONE_U32;
+    parts.finalizations[0].exact_factor_id = 1;
+    parts.closures[0].exact_factor_id = 1;
+    parts.closures[0].component_factor_start = 1;
+    parts.exact_factors = vec![
+        ExactComplexRational::new(
+            ExactRational::new(2, 1).unwrap(),
+            ExactRational::new(1, 1).unwrap(),
+        ),
+        ExactComplexRational::ONE,
+    ];
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        vec![
+            DirectExecutorHandle::Source {
+                call: fill_sources,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Contribution {
+                call: accumulate_contributions,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Finalization {
+                call: finalize_currents,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Closure {
+                call: accumulate_closures,
+                context: std::ptr::null(),
+            },
+        ],
+    )
+    .unwrap();
+
+    let mut current_re = [0.0; 12];
+    let mut current_im = [0.0; 12];
+    let mut amplitude_re = [0.0; 4];
+    let mut amplitude_im = [0.0; 4];
+    let momenta = [1.0, 2.0, 3.0, 4.0];
+    let parameters_re = [1.0];
+    let parameters_im = [0.0];
+    let factors_re = [2.0, 1.0];
+    let factors_im = [1.0, 0.0];
+    let mut workspace = DirectWorkspace {
+        current_re: &mut current_re,
+        current_im: &mut current_im,
+        amplitude_re: &mut amplitude_re,
+        amplitude_im: &mut amplitude_im,
+        momenta: &momenta,
+        momentum_form_count: 1,
+        lorentz_component_count: 1,
+        parameters_re: &parameters_re,
+        parameters_im: &parameters_im,
+        factors_re: &factors_re,
+        factors_im: &factors_im,
+        point_stride: 4,
+    };
+    let mut counters = DirectExecutionCounters::default();
+    execute_direct_plan(&plan, &executors, &mut workspace, 4, &mut counters).unwrap();
+
+    assert_eq!(workspace.current_re[8..12], [2.0, 4.0, 6.0, 8.0]);
+    assert_eq!(workspace.current_im[8..12], [1.0, 2.0, 3.0, 4.0]);
+    assert_eq!(counters.contribution_calls, 1);
+    assert_eq!(counters.contribution_rows, 1);
+}
+
+#[test]
+fn zero_self_reuse_clears_stale_destination_before_scale_copy() {
+    let mut parts = super::direct_plan::tests::valid_parts();
+    parts.currents[0].component_count = 1;
+    parts.contributions[0] = DirectContributionRow {
+        // A certified zero current legitimately uses its own just-cleared
+        // destination as the execution representative.
+        parent0_component_base: 2,
+        parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+        parent0_momentum_form_id: 1,
+        parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+        destination_component_base: 2,
+        exact_factor_id: 0,
+        selector_domain_id: 0,
+        flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+            | DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE,
+    };
+    parts.row_groups[1].direct_executor_id = DIRECT_NONE_U32;
+    parts.finalizations[0].exact_factor_id = 1;
+    parts.closures[0].exact_factor_id = 1;
+    parts.closures[0].component_factor_start = 1;
+    parts.exact_factors = vec![ExactComplexRational::ZERO, ExactComplexRational::ONE];
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        vec![
+            DirectExecutorHandle::Source {
+                call: fill_sources,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Contribution {
+                call: accumulate_contributions,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Finalization {
+                call: finalize_currents,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Closure {
+                call: accumulate_closures,
+                context: std::ptr::null(),
+            },
+        ],
+    )
+    .unwrap();
+
+    let mut current_re = [f64::NAN; 12];
+    let mut current_im = [f64::NAN; 12];
+    let mut amplitude_re = [0.0; 4];
+    let mut amplitude_im = [0.0; 4];
+    let momenta = [1.0, 2.0, 3.0, 4.0];
+    let parameters_re = [1.0];
+    let parameters_im = [0.0];
+    let factors_re = [0.0, 1.0];
+    let factors_im = [0.0, 0.0];
+    let mut workspace = DirectWorkspace {
+        current_re: &mut current_re,
+        current_im: &mut current_im,
+        amplitude_re: &mut amplitude_re,
+        amplitude_im: &mut amplitude_im,
+        momenta: &momenta,
+        momentum_form_count: 1,
+        lorentz_component_count: 1,
+        parameters_re: &parameters_re,
+        parameters_im: &parameters_im,
+        factors_re: &factors_re,
+        factors_im: &factors_im,
+        point_stride: 4,
+    };
+    let mut counters = DirectExecutionCounters::default();
+
+    execute_direct_plan(&plan, &executors, &mut workspace, 4, &mut counters).unwrap();
+
+    assert_eq!(workspace.current_re[8..12], [0.0; 4]);
+    assert_eq!(workspace.current_im[8..12], [0.0; 4]);
+    assert_eq!(counters.contribution_calls, 1);
+    assert_eq!(counters.contribution_rows, 1);
+    assert_eq!(
+        plan.row_groups()[1].direct_executor_id,
+        DIRECT_NONE_U32,
+        "certified zero reuse must not call an interaction executor"
+    );
+}
+
+#[test]
+fn direct_backend_source_contains_no_eager_packing_or_batch_evaluator_route() {
+    let source = include_str!("direct_backend.rs");
+    for forbidden in [
+        "EagerKernelInput",
+        "EagerKernelBackend",
+        "EagerKernelCall",
+        "evaluate_batch",
+    ] {
+        assert!(
+            !source.contains(forbidden),
+            "direct backend must not contain {forbidden}"
+        );
+    }
+}
+
+#[test]
+fn executor_catalog_authenticates_catalog_digest_and_stable_roles() {
+    let plan = super::direct_plan::tests::valid_plan();
+    let handles = || {
+        vec![
+            DirectExecutorHandle::Source {
+                call: fill_sources,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Contribution {
+                call: accumulate_contributions,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Finalization {
+                call: finalize_currents,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Closure {
+                call: accumulate_closures,
+                context: std::ptr::null(),
+            },
+        ]
+    };
+    let wrong_digest = crate::recurrence::SemanticDigest::new([0x44; 32]).unwrap();
+    let error = DirectExecutorCatalog::new(&plan, wrong_digest, handles())
+        .err()
+        .unwrap();
+    assert!(error.to_string().contains("catalog digest"));
+
+    let mut wrong_roles = handles();
+    wrong_roles[1] = DirectExecutorHandle::Source {
+        call: fill_sources,
+        context: std::ptr::null(),
+    };
+    let error =
+        DirectExecutorCatalog::new(&plan, plan.direct_template_catalog_digest(), wrong_roles)
+            .err()
+            .unwrap();
+    assert!(error.to_string().contains("expected Contribution"));
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_codec.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_codec.rs
new file mode 100644
index 0000000000..fae09835d3
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_codec.rs
@@ -0,0 +1,1169 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Deterministic little-endian codec for recurrence direct-plan v2.
+
+use super::direct_plan::{
+    DirectAmplitudeDestinationDescriptor, DirectClosureRow, DirectContributionRow,
+    DirectCurrentDescriptor, DirectDestinationOperation, DirectExecutorRole, DirectFinalizationRow,
+    DirectMomentumFormDescriptor, DirectMomentumTerm, DirectNodeKind, DirectRecurrencePlan,
+    DirectRecurrencePlanParts, DirectReplayTargetDescriptor, DirectResolvedHelicityDescriptor,
+    DirectResolvedSourceSelection, DirectRowGroupDescriptor, DirectSelectorDomainDescriptor,
+    DirectSourceDispatchVariantDescriptor, DirectSourceEmbeddingRow, DirectSourceProjectionRow,
+    DirectSourceRow, DirectSourceStateAssignment,
+};
+use super::{
+    CheckedTableRange, ClosureCandidateDomainCertificateV1, ClosureExecutionProofGroupV2,
+    ClosureProofContributionV2, ClosureProofMetadataV2, ExactComplexRational, ExactRational,
+    RecurrenceStrategy, ReflectionCertificateV1, SemanticDigest, ThreeLineTraversalCertificateV1,
+    ThreeLineTraversalKindV1,
+};
+use crate::{RusticolError, RusticolResult};
+use std::io::Write;
+
+const MAGIC: &[u8; 8] = b"PACRDAP2";
+const VERSION: u32 = 2;
+const MAX_ROWS: u64 = u32::MAX as u64;
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(format!("recurrence direct-plan codec: {}", message.into()))
+}
+
+struct Writer<W> {
+    destination: W,
+    bytes_written: u64,
+}
+
+impl<W: Write> Writer<W> {
+    fn new(destination: W) -> Self {
+        Self {
+            destination,
+            bytes_written: 0,
+        }
+    }
+
+    #[cfg(test)]
+    fn with_bytes_written(destination: W, bytes_written: u64) -> Self {
+        Self {
+            destination,
+            bytes_written,
+        }
+    }
+
+    fn raw(&mut self, bytes: &[u8]) -> RusticolResult<()> {
+        let byte_count =
+            u64::try_from(bytes.len()).map_err(|_| invalid("payload write length exceeds u64"))?;
+        let end = self
+            .bytes_written
+            .checked_add(byte_count)
+            .ok_or_else(|| invalid("payload length overflows u64"))?;
+        self.destination.write_all(bytes).map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not stream recurrence direct-plan payload: {error}"
+            ))
+        })?;
+        self.bytes_written = end;
+        Ok(())
+    }
+
+    fn u16(&mut self, value: u16) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn u32(&mut self, value: u32) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn i32(&mut self, value: i32) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn u64(&mut self, value: u64) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn i128(&mut self, value: i128) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn digest(&mut self, digest: SemanticDigest) -> RusticolResult<()> {
+        self.raw(digest.as_bytes())
+    }
+
+    fn optional_u32(&mut self, value: Option<u32>) -> RusticolResult<()> {
+        self.u32(value.unwrap_or(u32::MAX))
+    }
+
+    fn exact(&mut self, value: ExactComplexRational) -> RusticolResult<()> {
+        for rational in [value.real(), value.imag()] {
+            self.i128(rational.numerator())?;
+            self.i128(rational.denominator())?;
+        }
+        Ok(())
+    }
+
+    fn u32_slice(&mut self, label: &str, values: &[u32]) -> RusticolResult<()> {
+        self.count(label, values.len())?;
+        for value in values {
+            self.u32(*value)?;
+        }
+        Ok(())
+    }
+
+    fn optional_u32_slice(&mut self, label: &str, values: &[Option<u32>]) -> RusticolResult<()> {
+        self.count(label, values.len())?;
+        for value in values {
+            self.optional_u32(*value)?;
+        }
+        Ok(())
+    }
+
+    fn digest_slice(&mut self, label: &str, values: &[SemanticDigest]) -> RusticolResult<()> {
+        self.count(label, values.len())?;
+        for value in values {
+            self.digest(*value)?;
+        }
+        Ok(())
+    }
+
+    fn count(&mut self, label: &str, count: usize) -> RusticolResult<()> {
+        let count =
+            u64::try_from(count).map_err(|_| invalid(format!("{label} count exceeds u64")))?;
+        if count > MAX_ROWS {
+            return Err(invalid(format!("{label} count exceeds the u32 ID domain")));
+        }
+        self.u64(count)
+    }
+}
+
+struct Reader<'a> {
+    bytes: &'a [u8],
+    offset: usize,
+}
+
+impl<'a> Reader<'a> {
+    fn new(bytes: &'a [u8]) -> RusticolResult<Self> {
+        Ok(Self { bytes, offset: 0 })
+    }
+
+    fn take(&mut self, count: usize, label: &str) -> RusticolResult<&'a [u8]> {
+        let end = self
+            .offset
+            .checked_add(count)
+            .ok_or_else(|| invalid(format!("{label} offset overflows usize")))?;
+        let bytes = self.bytes.get(self.offset..end).ok_or_else(|| {
+            invalid(format!(
+                "truncated {label} at byte {}: need {count}, have {}",
+                self.offset,
+                self.bytes.len().saturating_sub(self.offset)
+            ))
+        })?;
+        self.offset = end;
+        Ok(bytes)
+    }
+
+    fn u16(&mut self, label: &str) -> RusticolResult<u16> {
+        Ok(u16::from_le_bytes(
+            self.take(2, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn u32(&mut self, label: &str) -> RusticolResult<u32> {
+        Ok(u32::from_le_bytes(
+            self.take(4, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn i32(&mut self, label: &str) -> RusticolResult<i32> {
+        Ok(i32::from_le_bytes(
+            self.take(4, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn u64(&mut self, label: &str) -> RusticolResult<u64> {
+        Ok(u64::from_le_bytes(
+            self.take(8, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn i128(&mut self, label: &str) -> RusticolResult<i128> {
+        Ok(i128::from_le_bytes(
+            self.take(16, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn digest(&mut self, label: &str) -> RusticolResult<SemanticDigest> {
+        let bytes: [u8; 32] = self.take(32, label)?.try_into().expect("checked read");
+        SemanticDigest::new(bytes).map_err(|error| invalid(error.message()))
+    }
+
+    fn optional_u32(&mut self, label: &str) -> RusticolResult<Option<u32>> {
+        let value = self.u32(label)?;
+        Ok((value != u32::MAX).then_some(value))
+    }
+
+    fn exact(&mut self, label: &str) -> RusticolResult<ExactComplexRational> {
+        Ok(ExactComplexRational::new(
+            read_rational(self, &format!("{label} real"))?,
+            read_rational(self, &format!("{label} imaginary"))?,
+        ))
+    }
+
+    fn u32_vec(&mut self, label: &str) -> RusticolResult<Vec<u32>> {
+        let count = self.count(label, 4)?;
+        (0..count)
+            .map(|_| self.u32(label))
+            .collect::<RusticolResult<Vec<_>>>()
+    }
+
+    fn optional_u32_vec(&mut self, label: &str) -> RusticolResult<Vec<Option<u32>>> {
+        let count = self.count(label, 4)?;
+        (0..count)
+            .map(|_| self.optional_u32(label))
+            .collect::<RusticolResult<Vec<_>>>()
+    }
+
+    fn digest_vec(&mut self, label: &str) -> RusticolResult<Vec<SemanticDigest>> {
+        let count = self.count(label, 32)?;
+        (0..count)
+            .map(|_| self.digest(label))
+            .collect::<RusticolResult<Vec<_>>>()
+    }
+
+    fn count(&mut self, label: &str, row_bytes: usize) -> RusticolResult<usize> {
+        let count = self.u64(&format!("{label} count"))?;
+        if count > MAX_ROWS {
+            return Err(invalid(format!("{label} count exceeds the u32 ID domain")));
+        }
+        let count =
+            usize::try_from(count).map_err(|_| invalid(format!("{label} count exceeds usize")))?;
+        if row_bytes != 0 && count > self.bytes.len().saturating_sub(self.offset) / row_bytes {
+            return Err(invalid(format!(
+                "{label} count cannot fit in the remaining payload"
+            )));
+        }
+        Ok(count)
+    }
+
+    fn finish(self) -> RusticolResult<()> {
+        if self.offset != self.bytes.len() {
+            return Err(invalid(format!(
+                "payload contains {} trailing bytes",
+                self.bytes.len() - self.offset
+            )));
+        }
+        Ok(())
+    }
+}
+
+pub fn encode_recurrence_direct_plan_v2(plan: &DirectRecurrencePlan) -> RusticolResult<Vec<u8>> {
+    let mut payload = Vec::new();
+    encode_recurrence_direct_plan_v2_to_writer(plan, &mut payload)?;
+    Ok(payload)
+}
+
+pub(crate) fn encode_recurrence_direct_plan_v2_to_writer<W: Write>(
+    plan: &DirectRecurrencePlan,
+    destination: W,
+) -> RusticolResult<u64> {
+    plan.ensure_serializable()?;
+    let mut writer = Writer::new(destination);
+    writer.raw(MAGIC)?;
+    writer.u32(VERSION)?;
+    writer.u32(0)?;
+    writer.u32(plan.strategy().as_u32())?;
+    writer.u32(plan.point_tile_size())?;
+    writer.u32(plan.workspace_mib())?;
+    writer.u32(plan.current_arena_components())?;
+    writer.u32(plan.physical_sector_count())?;
+    writer.u64(plan.retained_helicity_count())?;
+    writer.u32(plan.amplitude_destination_count())?;
+    writer.u32(plan.parameter_value_count())?;
+    writer.u32(plan.external_source_count())?;
+    writer.u32(plan.state_template_count())?;
+    writer.u32(plan.source_template_count())?;
+    writer.u32(plan.source_template_or_dispatch_count())?;
+    writer.u32(plan.runtime_helicity_contract_count())?;
+    writer.u32(plan.runtime_helicity_variant_count())?;
+    writer.u32(plan.direct_executor_count())?;
+    writer.digest(plan.semantic_digest())?;
+    writer.digest(plan.prepared_pack_digest())?;
+    writer.digest(plan.direct_template_catalog_digest())?;
+    writer.digest(plan.runtime_layout_digest())?;
+    writer.digest(
+        plan.closure_proofs()
+            .expected_semantic_completeness_digest(),
+    )?;
+    writer.u64(
+        plan.closure_proofs()
+            .candidate_domain_certificate()
+            .accepted_candidate_count(),
+    )?;
+    writer.digest(
+        plan.closure_proofs()
+            .candidate_domain_certificate()
+            .accepted_candidate_digest(),
+    )?;
+
+    writer.count("currents", plan.currents().len())?;
+    writer.count("sources", plan.sources().len())?;
+    writer.count("contributions", plan.contributions().len())?;
+    writer.count("finalizations", plan.finalizations().len())?;
+    writer.count("closures", plan.closures().len())?;
+    writer.count("row groups", plan.row_groups().len())?;
+    writer.count("momentum forms", plan.momentum_forms().len())?;
+    writer.count("momentum terms", plan.momentum_terms().len())?;
+    writer.count("selector domains", plan.selector_domains().len())?;
+    writer.count("selector words", plan.selector_words().len())?;
+    writer.count("replay targets", plan.replay_targets().len())?;
+    writer.count("source permutations", plan.source_permutations().len())?;
+    writer.count("replay momentum signs", plan.replay_momentum_signs().len())?;
+    writer.count("replay helicity map", plan.replay_helicity_map().len())?;
+    writer.count(
+        "amplitude destinations",
+        plan.amplitude_destinations().len(),
+    )?;
+    writer.count("resolved helicities", plan.resolved_helicities().len())?;
+    writer.count(
+        "source-state assignments",
+        plan.source_state_assignments().len(),
+    )?;
+    writer.count(
+        "source dispatch variants",
+        plan.source_dispatch_variants().len(),
+    )?;
+    writer.count("source embeddings", plan.source_embeddings().len())?;
+    writer.count("source projections", plan.source_projections().len())?;
+    writer.count(
+        "resolved source selections",
+        plan.resolved_source_selections().len(),
+    )?;
+    writer.count("public helicities", plan.public_helicities().len())?;
+    writer.count("exact factors", plan.exact_factors().len())?;
+    writer.count(
+        "closure proof contributions",
+        plan.closure_proofs().contributions().len(),
+    )?;
+    writer.count("closure proof groups", plan.closure_proofs().groups().len())?;
+    writer.count(
+        "reflection certificates",
+        plan.closure_proofs().reflection_certificates().len(),
+    )?;
+    writer.count(
+        "three-line traversal certificates",
+        plan.closure_proofs()
+            .three_line_traversal_certificates()
+            .len(),
+    )?;
+
+    for row in plan.currents() {
+        writer.u32(row.semantic_current_id)?;
+        writer.u16(row.node_kind as u16)?;
+        writer.u16(row.stage)?;
+        writer.u32(row.state_template_id)?;
+        writer.u32(row.component_base)?;
+        writer.u16(row.component_count)?;
+        writer.u16(0)?;
+        writer.u32(row.momentum_form_id)?;
+        writer.u32(row.selector_domain_id)?;
+        writer.u32(row.first_use)?;
+        writer.u32(row.last_use)?;
+        writer.u32(row.source_row_or_sentinel)?;
+        writer.u32(row.finalization_row_or_sentinel)?;
+    }
+    for row in plan.sources() {
+        writer.u32(row.source_slot)?;
+        writer.u32(row.destination_component_base)?;
+        writer.u32(row.momentum_form_id)?;
+        writer.u32(row.source_template_or_dispatch_domain)?;
+        writer.i32(row.spin_state_class)?;
+        writer.u32(row.exact_factor_id)?;
+        writer.u32(row.selector_domain_id)?;
+    }
+    for row in plan.contributions() {
+        for value in [
+            row.parent0_component_base,
+            row.parent1_component_base_or_sentinel,
+            row.parent0_momentum_form_id,
+            row.parent1_momentum_form_id_or_sentinel,
+            row.destination_component_base,
+            row.exact_factor_id,
+            row.selector_domain_id,
+            row.flags,
+        ] {
+            writer.u32(value)?;
+        }
+    }
+    for row in plan.finalizations() {
+        writer.u32(row.component_base)?;
+        writer.u16(row.component_count)?;
+        writer.u16(0)?;
+        for value in [
+            row.momentum_form_id,
+            row.exact_factor_id,
+            row.selector_domain_id,
+            row.flags,
+        ] {
+            writer.u32(value)?;
+        }
+    }
+    for row in plan.closures() {
+        for value in [
+            row.parent0_component_base,
+            row.parent1_component_base_or_sentinel,
+            row.parent0_momentum_form_id,
+            row.parent1_momentum_form_id_or_sentinel,
+            row.amplitude_destination_id,
+            row.exact_factor_id,
+            row.component_factor_start,
+        ] {
+            writer.u32(value)?;
+        }
+        writer.u16(row.component_count)?;
+        writer.u16(0)?;
+        writer.u32(row.selector_domain_id)?;
+        writer.u32(row.flags)?;
+    }
+    for row in plan.row_groups() {
+        writer.u16(row.stage)?;
+        writer.u16(row.role as u16)?;
+        writer.u16(row.destination_operation as u16)?;
+        writer.u16(0)?;
+        writer.u32(row.direct_executor_id)?;
+        writer.u64(row.row_start)?;
+        writer.u32(row.row_count)?;
+        writer.u32(0)?;
+    }
+    for row in plan.momentum_forms() {
+        writer.u64(row.term_start)?;
+        writer.u32(row.term_count)?;
+        writer.u32(0)?;
+    }
+    for row in plan.momentum_terms() {
+        writer.u32(row.source_slot)?;
+        writer.i32(row.coefficient)?;
+    }
+    for row in plan.selector_domains() {
+        writer.u64(row.word_start)?;
+        writer.u32(row.word_count)?;
+        writer.u32(0)?;
+    }
+    for value in plan.selector_words() {
+        writer.u64(*value)?;
+    }
+    for row in plan.replay_targets() {
+        writer.u32(row.public_flow_id)?;
+        writer.u32(row.representative_id)?;
+        writer.u64(row.source_permutation_start)?;
+        writer.u32(row.source_permutation_count)?;
+        writer.u64(row.helicity_map_start)?;
+        writer.u32(row.helicity_map_count)?;
+        writer.u32(row.phase_exact_factor_id)?;
+        writer.u32(row.multiplicity)?;
+        writer.u32(row.selector_domain_id)?;
+    }
+    for value in plan.source_permutations() {
+        writer.u32(*value)?;
+    }
+    for value in plan.replay_momentum_signs() {
+        writer.i32(*value)?;
+    }
+    for value in plan.replay_helicity_map() {
+        writer.u32(*value)?;
+    }
+    for row in plan.amplitude_destinations() {
+        writer.u64(row.closure_row_start)?;
+        writer.u32(row.id)?;
+        writer.u32(row.target_sector_id)?;
+        writer.u32(row.target_helicity_id_or_sentinel)?;
+        writer.u32(row.closure_row_count)?;
+        writer.u32(row.selector_domain_id)?;
+        writer.u32(0)?;
+    }
+    for row in plan.resolved_helicities() {
+        writer.u64(row.source_state_start)?;
+        writer.u64(row.source_selection_start)?;
+        writer.u64(row.public_helicity_start)?;
+        writer.u32(row.id)?;
+        writer.u32(row.source_state_count)?;
+        writer.u32(row.source_selection_count)?;
+        writer.u32(row.public_helicity_count)?;
+        writer.u32(row.selector_domain_id)?;
+    }
+    for row in plan.source_state_assignments() {
+        writer.u32(row.source_slot)?;
+        writer.u32(row.state_index)?;
+    }
+    for row in plan.source_dispatch_variants() {
+        writer.u64(row.embedding_start)?;
+        writer.u64(row.projection_start)?;
+        for value in [
+            row.source_row_id,
+            row.dispatch_domain_id,
+            row.runtime_variant_id,
+            row.source_state_index,
+            row.source_template_id,
+            row.source_state_template_id,
+            row.crossed_state_template_id,
+        ] {
+            writer.u32(value)?;
+        }
+        writer.i32(row.crossed_spin_state_class)?;
+        for value in [
+            row.direct_executor_id,
+            row.crossing_exact_factor_id,
+            row.embedding_count,
+            row.projection_count,
+        ] {
+            writer.u32(value)?;
+        }
+    }
+    for row in plan.source_embeddings() {
+        writer.u32(row.full_component)?;
+        writer.u32(row.source_component_or_sentinel)?;
+        writer.u32(row.exact_factor_id)?;
+    }
+    for row in plan.source_projections() {
+        writer.u32(row.source_component)?;
+        writer.u32(row.full_component)?;
+    }
+    for row in plan.resolved_source_selections() {
+        writer.u32(row.source_slot)?;
+        writer.u32(row.dispatch_variant_id)?;
+    }
+    for value in plan.public_helicities() {
+        writer.i32(*value)?;
+    }
+    for value in plan.exact_factors() {
+        writer.exact(*value)?;
+    }
+    for row in plan.closure_proofs().contributions() {
+        writer.u32(row.id())?;
+        writer.u32(row.target_sector_id())?;
+        writer.optional_u32(row.target_destination_id())?;
+        writer.optional_u32(row.target_helicity_id())?;
+        writer.u32(row.closure_template_id())?;
+        writer.digest(row.closure_template_semantic_digest())?;
+        writer.optional_u32(row.quantum_flow_template_id())?;
+        writer.u32_slice(
+            "closure construction builder-parent IDs",
+            row.construction_parent_builder_ids(),
+        )?;
+        writer.optional_u32_slice(
+            "closure construction runtime-parent IDs",
+            row.construction_parent_runtime_ids(),
+        )?;
+        writer.digest_slice(
+            "closure construction parent semantic digests",
+            row.construction_parent_semantic_digests(),
+        )?;
+        writer.digest_slice(
+            "closure construction parent color digests",
+            row.construction_parent_color_digests(),
+        )?;
+        writer.u32_slice(
+            "closure construction parent permutation",
+            row.construction_parent_permutation(),
+        )?;
+        writer.u32_slice(
+            "closure reconstruction parent permutation",
+            row.reconstruction_parent_permutation(),
+        )?;
+        writer.u32_slice(
+            "closure evaluator parent permutation",
+            row.evaluator_parent_permutation(),
+        )?;
+        writer.u32(row.color_witness_term_id())?;
+        writer.digest(row.color_witness_proof_digest())?;
+        writer.optional_u32(row.three_line_certificate_id())?;
+        writer.u32_slice(
+            "closure pairing certificates",
+            row.pairing_certificate_ids(),
+        )?;
+        writer.optional_u32(row.reflection_certificate_id())?;
+        writer.exact(row.exact_factor())?;
+        writer.u32(row.multiplicity())?;
+    }
+    for row in plan.closure_proofs().groups() {
+        writer.u32(row.id())?;
+        writer.optional_u32(row.emitted_runtime_closure_term_id())?;
+        writer.optional_u32(row.emitted_direct_closure_row_id())?;
+        writer.u64(row.contribution_range().start)?;
+        writer.u64(row.contribution_range().count)?;
+        writer.exact(row.exact_summed_factor())?;
+        writer.digest(row.component_factor_digest())?;
+        writer.digest(row.candidate_selector_domain_digest())?;
+        writer.digest(row.selector_domain_digest())?;
+    }
+    for row in plan.closure_proofs().reflection_certificates() {
+        writer.u32(row.id())?;
+        writer.digest(row.orbit_identity())?;
+        writer.digest(row.reciprocal_identity())?;
+        writer.u32_slice("reflection source permutation", row.source_permutation())?;
+        writer.exact(row.exact_phase())?;
+        writer.u32(u32::from(row.fixed_point()))?;
+        writer.u32(row.orbit_size())?;
+        writer.u32(row.proof_algorithm_id())?;
+        writer.digest(row.proof_digest())?;
+    }
+    for row in plan.closure_proofs().three_line_traversal_certificates() {
+        writer.u32(row.id())?;
+        writer.u32(row.sector_id())?;
+        writer.u32(row.kind().code())?;
+        writer.u32(row.sink_block_ordinal())?;
+        writer.u32_slice(
+            "three-line reference block order",
+            row.reference_block_order(),
+        )?;
+        writer.u32_slice("three-line witness block order", row.witness_block_order())?;
+        writer.u32_slice("three-line block permutation", row.block_permutation())?;
+        writer.u32_slice(
+            "three-line reference source order",
+            row.reference_source_order(),
+        )?;
+        writer.u32_slice(
+            "three-line witness source order",
+            row.witness_source_order(),
+        )?;
+        writer.u32_slice(
+            "three-line source-position permutation",
+            row.source_position_permutation(),
+        )?;
+        writer.u32(row.closure_anchor_source_slot())?;
+        writer.u32(row.pairing_rule_id())?;
+        writer.digest(row.proof_digest())?;
+    }
+    Ok(writer.bytes_written)
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+#[cfg_attr(target_vendor = "apple", cold)]
+pub fn decode_recurrence_direct_plan_v2(bytes: &[u8]) -> RusticolResult<DirectRecurrencePlan> {
+    #[cfg(feature = "on-the-fly-test-support")]
+    super::on_the_fly::reject_forbidden_work_if_probed(
+        super::on_the_fly::OnTheFlyForbiddenWorkV1::DirectPlanDecode,
+    )?;
+    let mut reader = Reader::new(bytes)?;
+    if reader.take(8, "magic")? != MAGIC {
+        return Err(invalid(
+            "unsupported recurrence payload; regenerate with direct-plan v2",
+        ));
+    }
+    if reader.u32("version")? != VERSION {
+        return Err(invalid(
+            "unsupported recurrence version; regenerate with direct-plan v2",
+        ));
+    }
+    if reader.u32("header flags")? != 0 {
+        return Err(invalid("unsupported nonzero header flags"));
+    }
+    let strategy = RecurrenceStrategy::try_from(reader.u32("strategy")?)
+        .map_err(|error| invalid(error.message()))?;
+    let point_tile_size = reader.u32("point tile size")?;
+    let workspace_mib = reader.u32("workspace MiB")?;
+    let current_arena_components = reader.u32("current arena components")?;
+    let physical_sector_count = reader.u32("physical LC sectors")?;
+    let retained_helicity_count = reader.u64("retained helicities")?;
+    let amplitude_destination_count = reader.u32("amplitude destinations")?;
+    let parameter_value_count = reader.u32("parameter values")?;
+    let external_source_count = reader.u32("external sources")?;
+    let state_template_count = reader.u32("state templates")?;
+    let source_template_count = reader.u32("source templates")?;
+    let source_template_or_dispatch_count = reader.u32("source templates or dispatch domains")?;
+    let runtime_helicity_contract_count = reader.u32("runtime-helicity contracts")?;
+    let runtime_helicity_variant_count = reader.u32("runtime-helicity variants")?;
+    let direct_executor_count = reader.u32("direct executors")?;
+    let semantic_digest = reader.digest("semantic digest")?;
+    let prepared_pack_digest = reader.digest("prepared-pack digest")?;
+    let direct_template_catalog_digest = reader.digest("direct-template catalog digest")?;
+    let expected_runtime_layout_digest = reader.digest("runtime-layout digest")?;
+    let expected_closure_proof_digest =
+        reader.digest("closure-proof semantic completeness digest")?;
+    let closure_candidate_domain_certificate = ClosureCandidateDomainCertificateV1::new(
+        reader.u64("closure candidate-domain count")?,
+        reader.digest("closure candidate-domain digest")?,
+    );
+
+    let current_count = reader.count("currents", 44)?;
+    let source_count = reader.count("sources", 28)?;
+    let contribution_count = reader.count("contributions", 32)?;
+    let finalization_count = reader.count("finalizations", 24)?;
+    let closure_count = reader.count("closures", 40)?;
+    let row_group_count = reader.count("row groups", 28)?;
+    let momentum_form_count = reader.count("momentum forms", 16)?;
+    let momentum_term_count = reader.count("momentum terms", 8)?;
+    let selector_domain_count = reader.count("selector domains", 16)?;
+    let selector_word_count = reader.count("selector words", 8)?;
+    let replay_target_count = reader.count("replay targets", 44)?;
+    let source_permutation_count = reader.count("source permutations", 4)?;
+    let replay_momentum_sign_count = reader.count("replay momentum signs", 4)?;
+    let replay_helicity_map_count = reader.count("replay helicity map", 4)?;
+    let amplitude_destination_descriptor_count = reader.count("amplitude destinations", 32)?;
+    let resolved_helicity_count = reader.count("resolved helicities", 44)?;
+    let source_state_assignment_count = reader.count("source-state assignments", 8)?;
+    let source_dispatch_variant_count = reader.count("source dispatch variants", 64)?;
+    let source_embedding_count = reader.count("source embeddings", 12)?;
+    let source_projection_count = reader.count("source projections", 8)?;
+    let resolved_source_selection_count = reader.count("resolved source selections", 8)?;
+    let public_helicity_count = reader.count("public helicities", 4)?;
+    let exact_factor_count = reader.count("exact factors", 64)?;
+    let closure_proof_contribution_count = reader.count("closure proof contributions", 0)?;
+    let closure_proof_group_count = reader.count("closure proof groups", 0)?;
+    let reflection_certificate_count = reader.count("reflection certificates", 0)?;
+    let three_line_traversal_certificate_count =
+        reader.count("three-line traversal certificates", 0)?;
+
+    let mut currents = Vec::with_capacity(current_count);
+    for _ in 0..current_count {
+        let semantic_current_id = reader.u32("current semantic ID")?;
+        let node_kind = DirectNodeKind::try_from(reader.u16("current node kind")?)?;
+        let stage = reader.u16("current stage")?;
+        let state_template_id = reader.u32("current state template")?;
+        let component_base = reader.u32("current component base")?;
+        let component_count = reader.u16("current component count")?;
+        require_zero(reader.u16("current reserved")?, "current reserved")?;
+        currents.push(DirectCurrentDescriptor {
+            semantic_current_id,
+            node_kind,
+            state_template_id,
+            component_base,
+            component_count,
+            momentum_form_id: reader.u32("current momentum form")?,
+            stage,
+            selector_domain_id: reader.u32("current selector domain")?,
+            first_use: reader.u32("current first use")?,
+            last_use: reader.u32("current last use")?,
+            source_row_or_sentinel: reader.u32("current source row")?,
+            finalization_row_or_sentinel: reader.u32("current finalization row")?,
+        });
+    }
+    let mut sources = Vec::with_capacity(source_count);
+    for _ in 0..source_count {
+        let source_slot = reader.u32("source slot")?;
+        let destination_component_base = reader.u32("source destination")?;
+        let momentum_form_id = reader.u32("source momentum form")?;
+        let source_template_or_dispatch_domain = reader.u32("source template")?;
+        let spin_state_class = reader.i32("source spin state")?;
+        sources.push(DirectSourceRow {
+            source_slot,
+            destination_component_base,
+            momentum_form_id,
+            source_template_or_dispatch_domain,
+            spin_state_class,
+            exact_factor_id: reader.u32("source exact factor")?,
+            selector_domain_id: reader.u32("source selector domain")?,
+        });
+    }
+    let mut contributions = Vec::with_capacity(contribution_count);
+    for _ in 0..contribution_count {
+        contributions.push(DirectContributionRow {
+            parent0_component_base: reader.u32("contribution parent 0")?,
+            parent1_component_base_or_sentinel: reader.u32("contribution parent 1")?,
+            parent0_momentum_form_id: reader.u32("contribution momentum 0")?,
+            parent1_momentum_form_id_or_sentinel: reader.u32("contribution momentum 1")?,
+            destination_component_base: reader.u32("contribution destination")?,
+            exact_factor_id: reader.u32("contribution exact factor")?,
+            selector_domain_id: reader.u32("contribution selector domain")?,
+            flags: reader.u32("contribution flags")?,
+        });
+    }
+    let mut finalizations = Vec::with_capacity(finalization_count);
+    for _ in 0..finalization_count {
+        let component_base = reader.u32("finalization component base")?;
+        let component_count = reader.u16("finalization component count")?;
+        require_zero(
+            reader.u16("finalization reserved")?,
+            "finalization reserved",
+        )?;
+        finalizations.push(DirectFinalizationRow {
+            component_base,
+            component_count,
+            momentum_form_id: reader.u32("finalization momentum form")?,
+            exact_factor_id: reader.u32("finalization exact factor")?,
+            selector_domain_id: reader.u32("finalization selector domain")?,
+            flags: reader.u32("finalization flags")?,
+        });
+    }
+    let mut closures = Vec::with_capacity(closure_count);
+    for _ in 0..closure_count {
+        closures.push(DirectClosureRow {
+            parent0_component_base: reader.u32("closure parent 0")?,
+            parent1_component_base_or_sentinel: reader.u32("closure parent 1")?,
+            parent0_momentum_form_id: reader.u32("closure momentum 0")?,
+            parent1_momentum_form_id_or_sentinel: reader.u32("closure momentum 1")?,
+            amplitude_destination_id: reader.u32("closure destination")?,
+            exact_factor_id: reader.u32("closure exact factor")?,
+            component_factor_start: reader.u32("closure component-factor start")?,
+            component_count: {
+                let count = reader.u16("closure component count")?;
+                require_zero(reader.u16("closure reserved")?, "closure reserved")?;
+                count
+            },
+            selector_domain_id: reader.u32("closure selector domain")?,
+            flags: reader.u32("closure flags")?,
+        });
+    }
+    let mut row_groups = Vec::with_capacity(row_group_count);
+    for _ in 0..row_group_count {
+        let stage = reader.u16("row-group stage")?;
+        let role = DirectExecutorRole::try_from(reader.u16("row-group role")?)?;
+        let destination_operation =
+            DirectDestinationOperation::try_from(reader.u16("row-group operation")?)?;
+        require_zero(reader.u16("row-group reserved")?, "row-group reserved")?;
+        let direct_executor_id = reader.u32("row-group executor")?;
+        let row_start = reader.u64("row-group row start")?;
+        let row_count = reader.u32("row-group row count")?;
+        require_zero(
+            reader.u32("row-group trailing reserved")?,
+            "row-group reserved",
+        )?;
+        row_groups.push(DirectRowGroupDescriptor {
+            stage,
+            role,
+            destination_operation,
+            direct_executor_id,
+            row_start,
+            row_count,
+        });
+    }
+    let mut momentum_forms = Vec::with_capacity(momentum_form_count);
+    for _ in 0..momentum_form_count {
+        let term_start = reader.u64("momentum-form term start")?;
+        let term_count = reader.u32("momentum-form term count")?;
+        require_zero(
+            reader.u32("momentum-form reserved")?,
+            "momentum-form reserved",
+        )?;
+        momentum_forms.push(DirectMomentumFormDescriptor {
+            term_start,
+            term_count,
+        });
+    }
+    let mut momentum_terms = Vec::with_capacity(momentum_term_count);
+    for _ in 0..momentum_term_count {
+        momentum_terms.push(DirectMomentumTerm {
+            source_slot: reader.u32("momentum-term source")?,
+            coefficient: reader.i32("momentum-term coefficient")?,
+        });
+    }
+    let mut selector_domains = Vec::with_capacity(selector_domain_count);
+    for _ in 0..selector_domain_count {
+        let word_start = reader.u64("selector-domain word start")?;
+        let word_count = reader.u32("selector-domain word count")?;
+        require_zero(
+            reader.u32("selector-domain reserved")?,
+            "selector-domain reserved",
+        )?;
+        selector_domains.push(DirectSelectorDomainDescriptor {
+            word_start,
+            word_count,
+        });
+    }
+    let mut selector_words = Vec::with_capacity(selector_word_count);
+    for _ in 0..selector_word_count {
+        selector_words.push(reader.u64("selector word")?);
+    }
+    let mut replay_targets = Vec::with_capacity(replay_target_count);
+    for _ in 0..replay_target_count {
+        replay_targets.push(DirectReplayTargetDescriptor {
+            public_flow_id: reader.u32("replay public flow")?,
+            representative_id: reader.u32("replay representative")?,
+            source_permutation_start: reader.u64("replay permutation start")?,
+            source_permutation_count: reader.u32("replay permutation count")?,
+            helicity_map_start: reader.u64("replay helicity-map start")?,
+            helicity_map_count: reader.u32("replay helicity-map count")?,
+            phase_exact_factor_id: reader.u32("replay phase factor")?,
+            multiplicity: reader.u32("replay multiplicity")?,
+            selector_domain_id: reader.u32("replay selector domain")?,
+        });
+    }
+    let mut source_permutations = Vec::with_capacity(source_permutation_count);
+    for _ in 0..source_permutation_count {
+        source_permutations.push(reader.u32("source permutation")?);
+    }
+    let mut replay_momentum_signs = Vec::with_capacity(replay_momentum_sign_count);
+    for _ in 0..replay_momentum_sign_count {
+        replay_momentum_signs.push(reader.i32("replay momentum sign")?);
+    }
+    let mut replay_helicity_map = Vec::with_capacity(replay_helicity_map_count);
+    for _ in 0..replay_helicity_map_count {
+        replay_helicity_map.push(reader.u32("replay helicity map")?);
+    }
+    let mut amplitude_destinations = Vec::with_capacity(amplitude_destination_descriptor_count);
+    for _ in 0..amplitude_destination_descriptor_count {
+        let closure_row_start = reader.u64("amplitude destination closure start")?;
+        let id = reader.u32("amplitude destination ID")?;
+        let target_sector_id = reader.u32("amplitude destination sector")?;
+        let target_helicity_id_or_sentinel = reader.u32("amplitude destination helicity")?;
+        let closure_row_count = reader.u32("amplitude destination closure count")?;
+        let selector_domain_id = reader.u32("amplitude destination selector domain")?;
+        require_zero(
+            reader.u32("amplitude destination reserved")?,
+            "amplitude destination reserved",
+        )?;
+        amplitude_destinations.push(DirectAmplitudeDestinationDescriptor {
+            closure_row_start,
+            id,
+            target_sector_id,
+            target_helicity_id_or_sentinel,
+            closure_row_count,
+            selector_domain_id,
+        });
+    }
+    let mut resolved_helicities = Vec::with_capacity(resolved_helicity_count);
+    for _ in 0..resolved_helicity_count {
+        resolved_helicities.push(DirectResolvedHelicityDescriptor {
+            source_state_start: reader.u64("resolved-helicity source-state start")?,
+            source_selection_start: reader.u64("resolved-helicity source-selection start")?,
+            public_helicity_start: reader.u64("resolved-helicity public-value start")?,
+            id: reader.u32("resolved-helicity ID")?,
+            source_state_count: reader.u32("resolved-helicity source-state count")?,
+            source_selection_count: reader.u32("resolved-helicity source-selection count")?,
+            public_helicity_count: reader.u32("resolved-helicity public-value count")?,
+            selector_domain_id: reader.u32("resolved-helicity selector domain")?,
+        });
+    }
+    let mut source_state_assignments = Vec::with_capacity(source_state_assignment_count);
+    for _ in 0..source_state_assignment_count {
+        source_state_assignments.push(DirectSourceStateAssignment {
+            source_slot: reader.u32("source-state source slot")?,
+            state_index: reader.u32("source-state index")?,
+        });
+    }
+    let mut source_dispatch_variants = Vec::with_capacity(source_dispatch_variant_count);
+    for _ in 0..source_dispatch_variant_count {
+        source_dispatch_variants.push(DirectSourceDispatchVariantDescriptor {
+            embedding_start: reader.u64("source-dispatch embedding start")?,
+            projection_start: reader.u64("source-dispatch projection start")?,
+            source_row_id: reader.u32("source-dispatch source row")?,
+            dispatch_domain_id: reader.u32("source-dispatch domain")?,
+            runtime_variant_id: reader.u32("source-dispatch runtime variant")?,
+            source_state_index: reader.u32("source-dispatch source-state index")?,
+            source_template_id: reader.u32("source-dispatch source template")?,
+            source_state_template_id: reader.u32("source-dispatch source state")?,
+            crossed_state_template_id: reader.u32("source-dispatch crossed state")?,
+            crossed_spin_state_class: reader.i32("source-dispatch crossed spin state")?,
+            direct_executor_id: reader.u32("source-dispatch direct executor")?,
+            crossing_exact_factor_id: reader.u32("source-dispatch crossing factor")?,
+            embedding_count: reader.u32("source-dispatch embedding count")?,
+            projection_count: reader.u32("source-dispatch projection count")?,
+        });
+    }
+    let mut source_embeddings = Vec::with_capacity(source_embedding_count);
+    for _ in 0..source_embedding_count {
+        source_embeddings.push(DirectSourceEmbeddingRow {
+            full_component: reader.u32("source embedding full component")?,
+            source_component_or_sentinel: reader.u32("source embedding source component")?,
+            exact_factor_id: reader.u32("source embedding factor")?,
+        });
+    }
+    let mut source_projections = Vec::with_capacity(source_projection_count);
+    for _ in 0..source_projection_count {
+        source_projections.push(DirectSourceProjectionRow {
+            source_component: reader.u32("source projection source component")?,
+            full_component: reader.u32("source projection full component")?,
+        });
+    }
+    let mut resolved_source_selections = Vec::with_capacity(resolved_source_selection_count);
+    for _ in 0..resolved_source_selection_count {
+        resolved_source_selections.push(DirectResolvedSourceSelection {
+            source_slot: reader.u32("resolved source-selection slot")?,
+            dispatch_variant_id: reader.u32("resolved source-selection variant")?,
+        });
+    }
+    let mut public_helicities = Vec::with_capacity(public_helicity_count);
+    for _ in 0..public_helicity_count {
+        public_helicities.push(reader.i32("public helicity")?);
+    }
+    let mut exact_factors = Vec::with_capacity(exact_factor_count);
+    for _ in 0..exact_factor_count {
+        exact_factors.push(reader.exact("exact factor")?);
+    }
+    let mut closure_proof_contributions = Vec::with_capacity(closure_proof_contribution_count);
+    for _ in 0..closure_proof_contribution_count {
+        closure_proof_contributions.push(ClosureProofContributionV2::new(
+            reader.u32("closure proof contribution ID")?,
+            reader.u32("closure proof target sector")?,
+            reader.optional_u32("closure proof target destination")?,
+            reader.optional_u32("closure proof target helicity")?,
+            reader.u32("closure proof template")?,
+            reader.digest("closure proof template semantic digest")?,
+            reader.optional_u32("closure proof quantum flow")?,
+            reader.u32_vec("closure construction builder-parent IDs")?,
+            reader.optional_u32_vec("closure construction runtime-parent IDs")?,
+            reader.digest_vec("closure construction parent semantic digests")?,
+            reader.digest_vec("closure construction parent color digests")?,
+            reader.u32_vec("closure construction parent permutation")?,
+            reader.u32_vec("closure reconstruction parent permutation")?,
+            reader.u32_vec("closure evaluator parent permutation")?,
+            reader.u32("closure color witness term")?,
+            reader.digest("closure color witness proof digest")?,
+            reader.optional_u32("closure three-line certificate")?,
+            reader.u32_vec("closure pairing certificates")?,
+            reader.optional_u32("closure reflection certificate")?,
+            reader.exact("closure proof contribution factor")?,
+            reader.u32("closure proof contribution multiplicity")?,
+        )?);
+    }
+    let mut closure_proof_groups = Vec::with_capacity(closure_proof_group_count);
+    for _ in 0..closure_proof_group_count {
+        closure_proof_groups.push(
+            ClosureExecutionProofGroupV2::new_with_candidate_selector_domain(
+                reader.u32("closure proof group ID")?,
+                reader.optional_u32("closure proof group runtime term")?,
+                reader.optional_u32("closure proof group direct row")?,
+                CheckedTableRange::new(
+                    reader.u64("closure proof group contribution start")?,
+                    reader.u64("closure proof group contribution count")?,
+                ),
+                reader.exact("closure proof group summed factor")?,
+                reader.digest("closure proof group component-factor digest")?,
+                reader.digest("closure proof group candidate-selector digest")?,
+                reader.digest("closure proof group selector-domain digest")?,
+            )?,
+        );
+    }
+    let mut reflection_certificates = Vec::with_capacity(reflection_certificate_count);
+    for _ in 0..reflection_certificate_count {
+        let id = reader.u32("reflection certificate ID")?;
+        let orbit_identity = reader.digest("reflection orbit identity")?;
+        let reciprocal_identity = reader.digest("reflection reciprocal identity")?;
+        let source_permutation = reader.u32_vec("reflection source permutation")?;
+        let exact_phase = reader.exact("reflection exact phase")?;
+        let fixed_point = match reader.u32("reflection fixed-point flag")? {
+            0 => false,
+            1 => true,
+            value => {
+                return Err(invalid(format!(
+                    "reflection fixed-point flag must be 0 or 1, found {value}"
+                )));
+            }
+        };
+        reflection_certificates.push(ReflectionCertificateV1::new(
+            id,
+            orbit_identity,
+            reciprocal_identity,
+            source_permutation,
+            exact_phase,
+            fixed_point,
+            reader.u32("reflection orbit size")?,
+            reader.u32("reflection proof algorithm")?,
+            reader.digest("reflection proof digest")?,
+        )?);
+    }
+    let mut three_line_traversal_certificates =
+        Vec::with_capacity(three_line_traversal_certificate_count);
+    for _ in 0..three_line_traversal_certificate_count {
+        let id = reader.u32("three-line traversal certificate ID")?;
+        let sector_id = reader.u32("three-line traversal sector")?;
+        let kind = ThreeLineTraversalKindV1::try_from(reader.u32("three-line traversal kind")?)
+            .map_err(|error| invalid(error.message()))?;
+        let sink_block_ordinal = reader.u32("three-line traversal sink block")?;
+        let reference_block_order = reader.u32_vec("three-line reference block order")?;
+        let witness_block_order = reader.u32_vec("three-line witness block order")?;
+        let block_permutation = reader.u32_vec("three-line block permutation")?;
+        let reference_source_order = reader.u32_vec("three-line reference source order")?;
+        let witness_source_order = reader.u32_vec("three-line witness source order")?;
+        let source_position_permutation =
+            reader.u32_vec("three-line source-position permutation")?;
+        three_line_traversal_certificates.push(ThreeLineTraversalCertificateV1::new(
+            id,
+            sector_id,
+            kind,
+            sink_block_ordinal,
+            reference_block_order,
+            witness_block_order,
+            block_permutation,
+            reference_source_order,
+            witness_source_order,
+            source_position_permutation,
+            reader.u32("three-line closure anchor source slot")?,
+            reader.u32("three-line pairing rule")?,
+            reader.digest("three-line traversal proof digest")?,
+        )?);
+    }
+    reader.finish()?;
+    let closure_proofs =
+        ClosureProofMetadataV2::new_with_three_line_certificates_candidate_domain_and_expected_digest(
+            closure_proof_contributions,
+            closure_proof_groups,
+            reflection_certificates,
+            three_line_traversal_certificates,
+            closure_candidate_domain_certificate,
+            expected_closure_proof_digest,
+        )?;
+
+    let plan = DirectRecurrencePlan::new(DirectRecurrencePlanParts {
+        strategy,
+        semantic_digest,
+        prepared_pack_digest,
+        direct_template_catalog_digest,
+        point_tile_size,
+        workspace_mib,
+        current_arena_components,
+        physical_sector_count,
+        retained_helicity_count,
+        amplitude_destination_count,
+        parameter_value_count,
+        external_source_count,
+        state_template_count,
+        source_template_count,
+        source_template_or_dispatch_count,
+        runtime_helicity_contract_count,
+        runtime_helicity_variant_count,
+        direct_executor_count,
+        currents,
+        sources,
+        contributions,
+        finalizations,
+        closures,
+        row_groups,
+        momentum_forms,
+        momentum_terms,
+        selector_domains,
+        selector_words,
+        replay_targets,
+        source_permutations,
+        replay_momentum_signs,
+        replay_helicity_map,
+        amplitude_destinations,
+        resolved_helicities,
+        source_state_assignments,
+        source_dispatch_variants,
+        source_embeddings,
+        source_projections,
+        resolved_source_selections,
+        public_helicities,
+        exact_factors,
+        closure_proofs,
+    })?;
+    if plan.runtime_layout_digest() != expected_runtime_layout_digest {
+        return Err(invalid("runtime-layout digest mismatch"));
+    }
+    Ok(plan)
+}
+
+fn read_rational(reader: &mut Reader<'_>, label: &str) -> RusticolResult<ExactRational> {
+    let numerator = reader.i128(&format!("{label} numerator"))?;
+    let denominator = reader.i128(&format!("{label} denominator"))?;
+    let value =
+        ExactRational::new(numerator, denominator).map_err(|error| invalid(error.message()))?;
+    if value.numerator() != numerator || value.denominator() != denominator {
+        return Err(invalid(format!("{label} is not canonically reduced")));
+    }
+    Ok(value)
+}
+
+fn require_zero<T>(value: T, label: &str) -> RusticolResult<()>
+where
+    T: Default + PartialEq + std::fmt::Display,
+{
+    if value != T::default() {
+        return Err(invalid(format!("{label} must be zero, found {value}")));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "direct_codec_tests.rs"]
+mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_codec_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_codec_tests.rs
new file mode 100644
index 0000000000..0fdeb55c44
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_codec_tests.rs
@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::recurrence::direct_plan::tests::valid_plan;
+use std::io::{self, Write};
+
+#[derive(Default)]
+struct CountingWriter {
+    written: u64,
+}
+
+impl Write for CountingWriter {
+    fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
+        self.written += bytes.len() as u64;
+        Ok(bytes.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[test]
+fn direct_codec_round_trips_deterministically() {
+    let plan = valid_plan();
+    let first = encode_recurrence_direct_plan_v2(&plan).unwrap();
+    let second = encode_recurrence_direct_plan_v2(&plan).unwrap();
+    assert_eq!(first, second);
+    let decoded = decode_recurrence_direct_plan_v2(&first).unwrap();
+    assert_eq!(
+        decoded
+            .closure_proofs()
+            .three_line_traversal_certificates()
+            .len(),
+        1
+    );
+    assert_eq!(decoded, plan);
+}
+
+#[test]
+fn direct_codec_stream_matches_the_vec_adapter() {
+    let plan = valid_plan();
+    let expected = encode_recurrence_direct_plan_v2(&plan).unwrap();
+    let mut streamed = Vec::new();
+    let byte_count = encode_recurrence_direct_plan_v2_to_writer(&plan, &mut streamed).unwrap();
+    assert_eq!(streamed, expected);
+    assert_eq!(byte_count, expected.len() as u64);
+}
+
+#[test]
+fn direct_codec_rejects_runtime_compacted_plans() {
+    let complete = valid_plan();
+    let runtime_layout_digest = complete.runtime_layout_digest();
+    let closure_proof_digest = complete
+        .closure_proofs()
+        .expected_semantic_completeness_digest();
+    let plan = complete.into_runtime_compacted();
+    assert_eq!(plan.runtime_layout_digest(), runtime_layout_digest);
+    assert_eq!(
+        plan.closure_proofs()
+            .expected_semantic_completeness_digest(),
+        closure_proof_digest
+    );
+    assert!(plan.closure_proofs().contributions().is_empty());
+    assert!(plan.closure_proofs().groups().is_empty());
+    assert!(
+        encode_recurrence_direct_plan_v2(&plan)
+            .unwrap_err()
+            .to_string()
+            .contains("runtime-compacted plan cannot be serialized")
+    );
+}
+
+#[test]
+fn direct_codec_stream_crosses_the_former_eight_gib_boundary_without_allocating() {
+    const EIGHT_GIB: u64 = 8 * 1024 * 1024 * 1024;
+    let mut writer = Writer::with_bytes_written(CountingWriter::default(), EIGHT_GIB - 1);
+    writer.raw(&[1, 2]).unwrap();
+    assert_eq!(writer.bytes_written, EIGHT_GIB + 1);
+    assert_eq!(writer.destination.written, 2);
+}
+
+#[test]
+fn direct_codec_stream_rejects_only_true_u64_length_overflow() {
+    let mut writer = Writer::with_bytes_written(CountingWriter::default(), u64::MAX);
+    let error = writer.raw(&[1]).unwrap_err();
+    assert!(error.to_string().contains("payload length overflows u64"));
+    assert_eq!(writer.destination.written, 0);
+}
+
+#[test]
+fn direct_codec_rejects_every_tested_truncation_boundary() {
+    let bytes = encode_recurrence_direct_plan_v2(&valid_plan()).unwrap();
+    for length in [0, 1, 7, 8, 15, 64, bytes.len() / 2, bytes.len() - 1] {
+        let error = decode_recurrence_direct_plan_v2(&bytes[..length]).unwrap_err();
+        assert!(
+            error.to_string().contains("truncated")
+                || error.to_string().contains("unsupported recurrence")
+                || error.to_string().contains("cannot fit"),
+            "unexpected error at truncation {length}: {error}"
+        );
+    }
+}
+
+#[test]
+fn direct_codec_rejects_old_v1_magic_explicitly() {
+    let mut bytes = encode_recurrence_direct_plan_v2(&valid_plan()).unwrap();
+    bytes[..8].copy_from_slice(b"PACRPLAN");
+    let error = decode_recurrence_direct_plan_v2(&bytes).unwrap_err();
+    assert!(error.to_string().contains("regenerate with direct-plan v2"));
+}
+
+#[test]
+fn direct_codec_detects_a_valid_field_mutation_through_layout_digest() {
+    let mut bytes = encode_recurrence_direct_plan_v2(&valid_plan()).unwrap();
+    // Header offset 20 is point_tile_size. Keep it nonzero and structurally
+    // valid so the authenticated layout digest is the rejecting invariant.
+    bytes[20..24].copy_from_slice(&128_u32.to_le_bytes());
+    let error = decode_recurrence_direct_plan_v2(&bytes).unwrap_err();
+    assert!(error.to_string().contains("runtime-layout digest mismatch"));
+}
+
+#[test]
+fn direct_codec_rejects_nonzero_reserved_fields() {
+    let mut bytes = encode_recurrence_direct_plan_v2(&valid_plan()).unwrap();
+    bytes[12..16].copy_from_slice(&1_u32.to_le_bytes());
+    let error = decode_recurrence_direct_plan_v2(&bytes).unwrap_err();
+    assert!(error.to_string().contains("header flags"));
+}
+
+#[test]
+fn direct_codec_authenticates_three_line_traversal_payloads() {
+    let mut bytes = encode_recurrence_direct_plan_v2(&valid_plan()).unwrap();
+    let last = bytes
+        .last_mut()
+        .expect("encoded three-line proof payload is nonempty");
+    *last ^= 1;
+    let error = decode_recurrence_direct_plan_v2(&bytes).unwrap_err();
+    assert!(
+        error
+            .to_string()
+            .contains("three-line traversal proof digest mismatch")
+    );
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_helicity_dispatch.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_helicity_dispatch.rs
new file mode 100644
index 0000000000..6c0e6888f5
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_helicity_dispatch.rs
@@ -0,0 +1,1104 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Authenticated helicity dispatch for one persisted all-flow direct plan.
+//!
+//! The direct-plan-v2 tables remain the canonical physical-color schedule.
+//! This sidecar partitions their non-source rows into maximal
+//! uniform-helicity runs and stores one canonical run-ID list per resolved
+//! helicity.  A cold selector bind can therefore copy only its active rows,
+//! rederive destination initialization, and build schedule-local fanout and
+//! interaction programs.  Warm execution never consults this metadata.
+
+use std::collections::BTreeSet;
+use std::io::{BufWriter, Write};
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+use std::path::Path;
+
+use super::direct_plan::{DIRECT_NONE_U32, DirectExecutorRole, DirectRecurrencePlan};
+use super::{RecurrenceStrategy, SemanticDigest};
+use crate::pacbin::{PACBIN_DEFAULT_CHUNK_SIZE, create_temporary_file};
+use crate::{RusticolError, RusticolResult};
+use sha2::{Digest, Sha256};
+
+pub const RECURRENCE_HELICITY_DISPATCH_ABI: &str = "pyamplicol-recurrence-helicity-dispatch-v1";
+
+const MAGIC: &[u8; 8] = b"PACRHDS1";
+const VERSION: u32 = 1;
+const MAX_TABLE_ROWS: u64 = u32::MAX as u64;
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(format!("recurrence helicity dispatch: {}", message.into()))
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectHelicitySupportDomainDescriptor {
+    pub word_start: u64,
+    pub word_count: u32,
+}
+
+/// One contiguous base-plan row run with a uniform helicity support mask.
+///
+/// Source rows are deliberately absent.  The all-flow source dispatcher
+/// already consumes the exact per-helicity source-selection table.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectHelicityRowGroupDescriptor {
+    pub stage: u16,
+    pub role: DirectExecutorRole,
+    pub direct_executor_id: u32,
+    pub row_start: u64,
+    pub row_count: u32,
+    pub support_domain_id: u32,
+}
+
+/// Canonical range into [`DirectHelicityDispatch::dispatch_group_ids`].
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectHelicityDispatchDescriptor {
+    pub resolved_helicity_id: u32,
+    pub group_id_start: u64,
+    pub group_id_count: u32,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DirectHelicityDispatchParts {
+    pub runtime_layout_digest: SemanticDigest,
+    pub source_row_count: u64,
+    pub contribution_row_count: u64,
+    pub finalization_row_count: u64,
+    pub closure_row_count: u64,
+    pub amplitude_destination_count: u32,
+    pub direct_executor_count: u32,
+    pub resolved_helicity_count: u32,
+    pub support_domains: Vec<DirectHelicitySupportDomainDescriptor>,
+    pub support_words: Vec<u64>,
+    pub row_groups: Vec<DirectHelicityRowGroupDescriptor>,
+    pub dispatches: Vec<DirectHelicityDispatchDescriptor>,
+    pub dispatch_group_ids: Vec<u32>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DirectHelicityDispatch {
+    parts: DirectHelicityDispatchParts,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct RecurrenceHelicityDispatchMetadata {
+    pub size_bytes: u64,
+    pub sha256: [u8; 32],
+}
+
+impl DirectHelicityDispatch {
+    pub fn new(parts: DirectHelicityDispatchParts) -> RusticolResult<Self> {
+        validate_parts(&parts)?;
+        Ok(Self { parts })
+    }
+
+    pub const fn runtime_layout_digest(&self) -> SemanticDigest {
+        self.parts.runtime_layout_digest
+    }
+
+    pub const fn source_row_count(&self) -> u64 {
+        self.parts.source_row_count
+    }
+
+    pub const fn contribution_row_count(&self) -> u64 {
+        self.parts.contribution_row_count
+    }
+
+    pub const fn finalization_row_count(&self) -> u64 {
+        self.parts.finalization_row_count
+    }
+
+    pub const fn closure_row_count(&self) -> u64 {
+        self.parts.closure_row_count
+    }
+
+    pub const fn amplitude_destination_count(&self) -> u32 {
+        self.parts.amplitude_destination_count
+    }
+
+    pub const fn direct_executor_count(&self) -> u32 {
+        self.parts.direct_executor_count
+    }
+
+    pub const fn resolved_helicity_count(&self) -> u32 {
+        self.parts.resolved_helicity_count
+    }
+
+    pub fn support_domains(&self) -> &[DirectHelicitySupportDomainDescriptor] {
+        &self.parts.support_domains
+    }
+
+    pub fn support_words(&self) -> &[u64] {
+        &self.parts.support_words
+    }
+
+    pub fn row_groups(&self) -> &[DirectHelicityRowGroupDescriptor] {
+        &self.parts.row_groups
+    }
+
+    pub fn dispatches(&self) -> &[DirectHelicityDispatchDescriptor] {
+        &self.parts.dispatches
+    }
+
+    pub fn dispatch_group_ids(&self) -> &[u32] {
+        &self.parts.dispatch_group_ids
+    }
+
+    pub fn group_ids_for_helicity(&self, resolved_helicity_id: u32) -> RusticolResult<&[u32]> {
+        let descriptor = self
+            .parts
+            .dispatches
+            .get(resolved_helicity_id as usize)
+            .filter(|descriptor| descriptor.resolved_helicity_id == resolved_helicity_id)
+            .ok_or_else(|| {
+                invalid(format!(
+                    "resolved helicity {resolved_helicity_id} is absent"
+                ))
+            })?;
+        let start = usize::try_from(descriptor.group_id_start)
+            .map_err(|_| invalid("dispatch group-ID start exceeds usize"))?;
+        let end = start
+            .checked_add(descriptor.group_id_count as usize)
+            .ok_or_else(|| invalid("dispatch group-ID range overflows usize"))?;
+        self.parts
+            .dispatch_group_ids
+            .get(start..end)
+            .ok_or_else(|| invalid("dispatch group-ID range is out of bounds"))
+    }
+
+    pub fn support_domain_contains(
+        &self,
+        support_domain_id: u32,
+        resolved_helicity_id: u32,
+    ) -> RusticolResult<bool> {
+        support_domain_contains_parts(&self.parts, support_domain_id, resolved_helicity_id)
+    }
+
+    /// Pair the sidecar with its exact all-flow direct plan.
+    ///
+    /// Container/member SHA-256 authenticates the bytes. This check establishes
+    /// the semantic pairing once, at the authoritative load boundary.
+    pub fn validate_for_plan(&self, plan: &DirectRecurrencePlan) -> RusticolResult<()> {
+        if plan.strategy() != RecurrenceStrategy::AllFlowUnion {
+            return Err(invalid(
+                "helicity dispatch requires an all-flow-union direct plan",
+            ));
+        }
+        if self.runtime_layout_digest() != plan.runtime_layout_digest() {
+            return Err(RusticolError::integrity(
+                "recurrence helicity dispatch runtime-layout digest does not match its plan",
+            ));
+        }
+        let expected_counts = [
+            u64::try_from(plan.sources().len())
+                .map_err(|_| invalid("plan source-row count exceeds u64"))?,
+            u64::try_from(plan.contributions().len())
+                .map_err(|_| invalid("plan contribution-row count exceeds u64"))?,
+            u64::try_from(plan.finalizations().len())
+                .map_err(|_| invalid("plan finalization-row count exceeds u64"))?,
+            u64::try_from(plan.closures().len())
+                .map_err(|_| invalid("plan closure-row count exceeds u64"))?,
+        ];
+        let actual_counts = [
+            self.source_row_count(),
+            self.contribution_row_count(),
+            self.finalization_row_count(),
+            self.closure_row_count(),
+        ];
+        if actual_counts != expected_counts
+            || self.amplitude_destination_count() != plan.amplitude_destination_count()
+            || self.direct_executor_count() != plan.direct_executor_count()
+            || self.resolved_helicity_count() as usize != plan.resolved_helicities().len()
+            || u64::from(self.resolved_helicity_count()) != plan.retained_helicity_count()
+        {
+            return Err(RusticolError::integrity(
+                "recurrence helicity dispatch dimensions do not match its plan",
+            ));
+        }
+        validate_base_row_group_partition(plan, &self.parts.row_groups)
+    }
+
+    pub fn into_parts(self) -> DirectHelicityDispatchParts {
+        self.parts
+    }
+}
+
+fn checked_u32_table_count(label: &str, value: u64) -> RusticolResult<()> {
+    if value > MAX_TABLE_ROWS {
+        return Err(invalid(format!("{label} count exceeds the u32 ID domain")));
+    }
+    Ok(())
+}
+
+fn support_domain_words(
+    parts: &DirectHelicityDispatchParts,
+    support_domain_id: u32,
+) -> RusticolResult<&[u64]> {
+    let descriptor = parts
+        .support_domains
+        .get(support_domain_id as usize)
+        .ok_or_else(|| invalid("support-domain ID is out of bounds"))?;
+    let start = usize::try_from(descriptor.word_start)
+        .map_err(|_| invalid("support-domain word start exceeds usize"))?;
+    let end = start
+        .checked_add(descriptor.word_count as usize)
+        .ok_or_else(|| invalid("support-domain word range overflows usize"))?;
+    parts
+        .support_words
+        .get(start..end)
+        .ok_or_else(|| invalid("support-domain word range is out of bounds"))
+}
+
+fn support_domain_contains_parts(
+    parts: &DirectHelicityDispatchParts,
+    support_domain_id: u32,
+    resolved_helicity_id: u32,
+) -> RusticolResult<bool> {
+    if resolved_helicity_id >= parts.resolved_helicity_count {
+        return Err(invalid("resolved helicity is out of bounds"));
+    }
+    let words = support_domain_words(parts, support_domain_id)?;
+    let word = resolved_helicity_id as usize / 64;
+    let bit = resolved_helicity_id % 64;
+    Ok(words
+        .get(word)
+        .is_some_and(|value| value & (1_u64 << bit) != 0))
+}
+
+fn validate_parts(parts: &DirectHelicityDispatchParts) -> RusticolResult<()> {
+    for (label, count) in [
+        ("source row", parts.source_row_count),
+        ("contribution row", parts.contribution_row_count),
+        ("finalization row", parts.finalization_row_count),
+        ("closure row", parts.closure_row_count),
+        ("support domain", parts.support_domains.len() as u64),
+        ("support word", parts.support_words.len() as u64),
+        ("split row group", parts.row_groups.len() as u64),
+        ("dispatch group ID", parts.dispatch_group_ids.len() as u64),
+    ] {
+        checked_u32_table_count(label, count)?;
+    }
+    if parts.source_row_count == 0
+        || parts.contribution_row_count == 0
+        || parts.closure_row_count == 0
+        || parts.amplitude_destination_count == 0
+        || parts.direct_executor_count == 0
+        || parts.resolved_helicity_count == 0
+        || parts.support_domains.is_empty()
+        || parts.row_groups.is_empty()
+    {
+        return Err(invalid(
+            "dispatch requires nonempty source, contribution, closure, destination, executor, helicity, support-domain, and row-group tables",
+        ));
+    }
+    if parts.dispatches.len() != parts.resolved_helicity_count as usize {
+        return Err(invalid(
+            "dispatch descriptor table does not cover every resolved helicity",
+        ));
+    }
+
+    validate_support_domains(parts)?;
+    validate_split_row_groups(parts)?;
+    validate_dispatch_csr(parts)
+}
+
+fn validate_support_domains(parts: &DirectHelicityDispatchParts) -> RusticolResult<()> {
+    let maximum_words = parts.resolved_helicity_count.div_ceil(64) as usize;
+    let mut next = 0_u64;
+    let mut unique = BTreeSet::<Vec<u64>>::new();
+    for (domain_id, descriptor) in parts.support_domains.iter().enumerate() {
+        if descriptor.word_start != next {
+            return Err(invalid(format!(
+                "support domain {domain_id} does not continue the packed word table"
+            )));
+        }
+        let words = support_domain_words(parts, domain_id as u32)?;
+        if words.len() > maximum_words || words.last() == Some(&0) {
+            return Err(invalid(format!(
+                "support domain {domain_id} is not a canonical compact helicity mask"
+            )));
+        }
+        if words.len() == maximum_words && !parts.resolved_helicity_count.is_multiple_of(64) {
+            let live_bits = parts.resolved_helicity_count % 64;
+            let high_mask = !((1_u64 << live_bits) - 1);
+            if words.last().is_some_and(|word| word & high_mask != 0) {
+                return Err(invalid(format!(
+                    "support domain {domain_id} sets bits outside the resolved-helicity axis"
+                )));
+            }
+        }
+        if !unique.insert(words.to_vec()) {
+            return Err(invalid(format!(
+                "support domain {domain_id} duplicates an earlier interned mask"
+            )));
+        }
+        next = next
+            .checked_add(u64::from(descriptor.word_count))
+            .ok_or_else(|| invalid("support-domain word partition overflows u64"))?;
+    }
+    if next != parts.support_words.len() as u64 {
+        return Err(invalid(
+            "support domains do not partition the support-word table",
+        ));
+    }
+    Ok(())
+}
+
+fn role_partition_index(role: DirectExecutorRole) -> RusticolResult<usize> {
+    match role {
+        DirectExecutorRole::Contribution => Ok(0),
+        DirectExecutorRole::Finalization => Ok(1),
+        DirectExecutorRole::Closure => Ok(2),
+        DirectExecutorRole::Source => Err(invalid(
+            "static source groups must not appear in helicity dispatch",
+        )),
+    }
+}
+
+fn validate_split_row_groups(parts: &DirectHelicityDispatchParts) -> RusticolResult<()> {
+    let mut next = [0_u64; 3];
+    let mut previous_order = None;
+    for (group_id, group) in parts.row_groups.iter().enumerate() {
+        if group.row_count == 0 {
+            return Err(invalid(format!("split row group {group_id} is empty")));
+        }
+        let role_index = role_partition_index(group.role)?;
+        if group.direct_executor_id != DIRECT_NONE_U32
+            && group.direct_executor_id >= parts.direct_executor_count
+        {
+            return Err(invalid(format!(
+                "split row group {group_id} executor is out of bounds"
+            )));
+        }
+        if group.direct_executor_id == DIRECT_NONE_U32
+            && group.role != DirectExecutorRole::Contribution
+        {
+            return Err(invalid(format!(
+                "split row group {group_id} has a missing non-contribution executor"
+            )));
+        }
+        if group.support_domain_id as usize >= parts.support_domains.len() {
+            return Err(invalid(format!(
+                "split row group {group_id} support domain is out of bounds"
+            )));
+        }
+        let order = (group.stage, group.role);
+        if previous_order.is_some_and(|previous| order < previous) {
+            return Err(invalid(
+                "split row groups are not in canonical schedule order",
+            ));
+        }
+        previous_order = Some(order);
+        if group.row_start != next[role_index] {
+            return Err(invalid(format!(
+                "split row group {group_id} does not continue its role's row table"
+            )));
+        }
+        next[role_index] = group
+            .row_start
+            .checked_add(u64::from(group.row_count))
+            .ok_or_else(|| invalid("split row-group range overflows u64"))?;
+    }
+    let expected = [
+        parts.contribution_row_count,
+        parts.finalization_row_count,
+        parts.closure_row_count,
+    ];
+    if next != expected {
+        return Err(invalid(
+            "split row groups do not partition every non-source base-plan row",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_dispatch_csr(parts: &DirectHelicityDispatchParts) -> RusticolResult<()> {
+    let mut next = 0_u64;
+    let mut starts = Vec::with_capacity(parts.dispatches.len());
+    let mut ends = Vec::with_capacity(parts.dispatches.len());
+    for (helicity_id, descriptor) in parts.dispatches.iter().enumerate() {
+        if descriptor.resolved_helicity_id != helicity_id as u32
+            || descriptor.group_id_start != next
+        {
+            return Err(invalid(format!(
+                "resolved-helicity dispatch {helicity_id} is not canonical"
+            )));
+        }
+        let start = usize::try_from(descriptor.group_id_start)
+            .map_err(|_| invalid("dispatch group-ID start exceeds usize"))?;
+        let end = start
+            .checked_add(descriptor.group_id_count as usize)
+            .ok_or_else(|| invalid("dispatch group-ID range overflows usize"))?;
+        let group_ids = parts
+            .dispatch_group_ids
+            .get(start..end)
+            .ok_or_else(|| invalid("dispatch group-ID range is out of bounds"))?;
+        if group_ids
+            .iter()
+            .any(|group_id| *group_id as usize >= parts.row_groups.len())
+            || !group_ids.windows(2).all(|pair| pair[0] < pair[1])
+        {
+            return Err(invalid(format!(
+                "resolved-helicity dispatch {helicity_id} has invalid or unordered group IDs"
+            )));
+        }
+        starts.push(start);
+        ends.push(end);
+        next = next
+            .checked_add(u64::from(descriptor.group_id_count))
+            .ok_or_else(|| invalid("dispatch group-ID partition overflows u64"))?;
+    }
+    if next != parts.dispatch_group_ids.len() as u64 {
+        return Err(invalid(
+            "resolved-helicity dispatches do not partition the group-ID table",
+        ));
+    }
+
+    // The masks are the audit representation and the CSR is the cold-bind
+    // accelerator. Establish their exact equivalence once without allocating
+    // an H-by-group matrix.
+    let mut cursors = starts;
+    for (group_id, group) in parts.row_groups.iter().enumerate() {
+        for (word_index, mut word) in support_domain_words(parts, group.support_domain_id)?
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            while word != 0 {
+                let bit = word.trailing_zeros() as usize;
+                let helicity_id = word_index * 64 + bit;
+                let cursor = cursors
+                    .get_mut(helicity_id)
+                    .ok_or_else(|| invalid("support mask exceeds the helicity axis"))?;
+                let actual = parts.dispatch_group_ids.get(*cursor).copied();
+                if actual != Some(group_id as u32) {
+                    return Err(invalid(format!(
+                        "resolved-helicity dispatch {helicity_id} disagrees with support masks at group {group_id}"
+                    )));
+                }
+                *cursor += 1;
+                word &= word - 1;
+            }
+        }
+    }
+    if cursors != ends {
+        return Err(invalid(
+            "resolved-helicity dispatch contains groups absent from its support masks",
+        ));
+    }
+    Ok(())
+}
+
+fn validate_base_row_group_partition(
+    plan: &DirectRecurrencePlan,
+    groups: &[DirectHelicityRowGroupDescriptor],
+) -> RusticolResult<()> {
+    let mut group_index = 0usize;
+    for base in plan
+        .row_groups()
+        .iter()
+        .filter(|descriptor| descriptor.role != DirectExecutorRole::Source)
+    {
+        let base_end = base
+            .row_start
+            .checked_add(u64::from(base.row_count))
+            .ok_or_else(|| invalid("base row-group range overflows u64"))?;
+        let mut next = base.row_start;
+        while next < base_end {
+            let group = groups.get(group_index).ok_or_else(|| {
+                RusticolError::integrity(
+                    "recurrence helicity dispatch omits a base-plan row-group suffix",
+                )
+            })?;
+            if group.stage != base.stage
+                || group.role != base.role
+                || group.direct_executor_id != base.direct_executor_id
+                || group.row_start != next
+            {
+                return Err(RusticolError::integrity(
+                    "recurrence helicity dispatch split group does not match its base row group",
+                ));
+            }
+            next = next
+                .checked_add(u64::from(group.row_count))
+                .ok_or_else(|| invalid("split row-group range overflows u64"))?;
+            if next > base_end {
+                return Err(RusticolError::integrity(
+                    "recurrence helicity dispatch split group crosses a base row-group boundary",
+                ));
+            }
+            group_index += 1;
+        }
+    }
+    if group_index != groups.len() {
+        return Err(RusticolError::integrity(
+            "recurrence helicity dispatch has groups beyond the base-plan schedule",
+        ));
+    }
+    Ok(())
+}
+
+struct Writer<W> {
+    destination: W,
+    bytes_written: u64,
+}
+
+impl<W: Write> Writer<W> {
+    fn new(destination: W) -> Self {
+        Self {
+            destination,
+            bytes_written: 0,
+        }
+    }
+
+    fn raw(&mut self, bytes: &[u8]) -> RusticolResult<()> {
+        let count =
+            u64::try_from(bytes.len()).map_err(|_| invalid("payload write length exceeds u64"))?;
+        self.bytes_written = self
+            .bytes_written
+            .checked_add(count)
+            .ok_or_else(|| invalid("payload length overflows u64"))?;
+        self.destination.write_all(bytes).map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not stream recurrence helicity dispatch: {error}"
+            ))
+        })
+    }
+
+    fn u16(&mut self, value: u16) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn u32(&mut self, value: u32) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn u64(&mut self, value: u64) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn digest(&mut self, value: SemanticDigest) -> RusticolResult<()> {
+        self.raw(value.as_bytes())
+    }
+}
+
+pub fn encode_recurrence_helicity_dispatch_v1(
+    dispatch: &DirectHelicityDispatch,
+) -> RusticolResult<Vec<u8>> {
+    let mut payload = Vec::new();
+    encode_recurrence_helicity_dispatch_v1_to_writer(dispatch, &mut payload)?;
+    Ok(payload)
+}
+
+pub(crate) fn encode_recurrence_helicity_dispatch_v1_to_writer<W: Write>(
+    dispatch: &DirectHelicityDispatch,
+    destination: W,
+) -> RusticolResult<u64> {
+    let parts = &dispatch.parts;
+    let mut writer = Writer::new(destination);
+    writer.raw(MAGIC)?;
+    writer.u32(VERSION)?;
+    writer.u32(0)?;
+    writer.digest(parts.runtime_layout_digest)?;
+    writer.u64(parts.source_row_count)?;
+    writer.u64(parts.contribution_row_count)?;
+    writer.u64(parts.finalization_row_count)?;
+    writer.u64(parts.closure_row_count)?;
+    writer.u32(parts.amplitude_destination_count)?;
+    writer.u32(parts.direct_executor_count)?;
+    writer.u32(parts.resolved_helicity_count)?;
+    writer.u32(parts.support_domains.len() as u32)?;
+    writer.u32(parts.row_groups.len() as u32)?;
+    writer.u32(parts.dispatches.len() as u32)?;
+    writer.u64(parts.support_words.len() as u64)?;
+    writer.u64(parts.dispatch_group_ids.len() as u64)?;
+
+    for descriptor in &parts.support_domains {
+        writer.u64(descriptor.word_start)?;
+        writer.u32(descriptor.word_count)?;
+        writer.u32(0)?;
+    }
+    for word in &parts.support_words {
+        writer.u64(*word)?;
+    }
+    for group in &parts.row_groups {
+        writer.u16(group.stage)?;
+        writer.u16(group.role as u16)?;
+        writer.u32(group.direct_executor_id)?;
+        writer.u64(group.row_start)?;
+        writer.u32(group.row_count)?;
+        writer.u32(group.support_domain_id)?;
+    }
+    for descriptor in &parts.dispatches {
+        writer.u32(descriptor.resolved_helicity_id)?;
+        writer.u32(0)?;
+        writer.u64(descriptor.group_id_start)?;
+        writer.u32(descriptor.group_id_count)?;
+        writer.u32(0)?;
+    }
+    for group_id in &parts.dispatch_group_ids {
+        writer.u32(*group_id)?;
+    }
+    Ok(writer.bytes_written)
+}
+
+struct HashingWriter<W> {
+    inner: W,
+    digest: Sha256,
+}
+
+impl<W> HashingWriter<W> {
+    fn new(inner: W) -> Self {
+        Self {
+            inner,
+            digest: Sha256::new(),
+        }
+    }
+}
+
+impl<W: Write> Write for HashingWriter<W> {
+    fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
+        let written = self.inner.write(bytes)?;
+        self.digest.update(&bytes[..written]);
+        Ok(written)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+/// Stream one dispatch sidecar to a same-directory temporary file and publish
+/// it atomically. The returned digest is computed over the bytes being written,
+/// so callers need no second read or hashing pass.
+pub fn write_recurrence_helicity_dispatch_v1_atomic(
+    destination: impl AsRef<Path>,
+    dispatch: &DirectHelicityDispatch,
+) -> RusticolResult<RecurrenceHelicityDispatchMetadata> {
+    let destination = destination.as_ref();
+    let parent = destination
+        .parent()
+        .filter(|path| !path.as_os_str().is_empty())
+        .unwrap_or_else(|| Path::new("."));
+    if !parent.is_dir() {
+        return Err(invalid(format!(
+            "destination directory does not exist: {}",
+            parent.display()
+        )));
+    }
+    let (temporary_path, temporary_file) = create_temporary_file(destination, parent)?;
+    let result = (|| {
+        let buffered = BufWriter::with_capacity(PACBIN_DEFAULT_CHUNK_SIZE, temporary_file);
+        let mut writer = HashingWriter::new(buffered);
+        let size_bytes = encode_recurrence_helicity_dispatch_v1_to_writer(dispatch, &mut writer)?;
+        writer.flush().map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not flush recurrence helicity dispatch {}: {error}",
+                temporary_path.display()
+            ))
+        })?;
+        #[cfg(unix)]
+        writer
+            .inner
+            .get_ref()
+            .set_permissions(std::fs::Permissions::from_mode(0o644))
+            .map_err(|error| {
+                RusticolError::artifact(format!(
+                    "could not set recurrence helicity dispatch permissions {}: {error}",
+                    temporary_path.display()
+                ))
+            })?;
+        writer.inner.get_ref().sync_all().map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not sync recurrence helicity dispatch {}: {error}",
+                temporary_path.display()
+            ))
+        })?;
+        let HashingWriter { inner, digest } = writer;
+        let sha256: [u8; 32] = digest.finalize().into();
+        drop(inner);
+        std::fs::rename(&temporary_path, destination).map_err(|error| {
+            RusticolError::artifact(format!(
+                "could not atomically publish recurrence helicity dispatch {}: {error}",
+                destination.display()
+            ))
+        })?;
+        // The containing artifact root is content-addressed. Best-effort
+        // directory sync mirrors PACBIN publication without adding another
+        // platform-specific durability contract.
+        if let Ok(directory) = std::fs::File::open(parent) {
+            let _ = directory.sync_all();
+        }
+        Ok(RecurrenceHelicityDispatchMetadata { size_bytes, sha256 })
+    })();
+    if result.is_err() {
+        let _ = std::fs::remove_file(&temporary_path);
+    }
+    result
+}
+
+struct Reader<'a> {
+    bytes: &'a [u8],
+    offset: usize,
+}
+
+impl<'a> Reader<'a> {
+    fn new(bytes: &'a [u8]) -> Self {
+        Self { bytes, offset: 0 }
+    }
+
+    fn take(&mut self, count: usize, label: &str) -> RusticolResult<&'a [u8]> {
+        let end = self
+            .offset
+            .checked_add(count)
+            .ok_or_else(|| invalid(format!("{label} offset overflows usize")))?;
+        let bytes = self.bytes.get(self.offset..end).ok_or_else(|| {
+            invalid(format!(
+                "truncated {label} at byte {}: need {count}, have {}",
+                self.offset,
+                self.bytes.len().saturating_sub(self.offset)
+            ))
+        })?;
+        self.offset = end;
+        Ok(bytes)
+    }
+
+    fn u16(&mut self, label: &str) -> RusticolResult<u16> {
+        Ok(u16::from_le_bytes(
+            self.take(2, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn u32(&mut self, label: &str) -> RusticolResult<u32> {
+        Ok(u32::from_le_bytes(
+            self.take(4, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn u64(&mut self, label: &str) -> RusticolResult<u64> {
+        Ok(u64::from_le_bytes(
+            self.take(8, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn digest(&mut self, label: &str) -> RusticolResult<SemanticDigest> {
+        let bytes = self.take(32, label)?.try_into().expect("checked read");
+        SemanticDigest::new(bytes).map_err(|error| invalid(error.message()))
+    }
+
+    fn reserved_u32(&mut self, label: &str) -> RusticolResult<()> {
+        let value = self.u32(label)?;
+        if value != 0 {
+            return Err(invalid(format!("{label} must be zero, found {value}")));
+        }
+        Ok(())
+    }
+
+    fn checked_count(&self, value: u64, row_bytes: usize, label: &str) -> RusticolResult<usize> {
+        checked_u32_table_count(label, value)?;
+        let count =
+            usize::try_from(value).map_err(|_| invalid(format!("{label} count exceeds usize")))?;
+        if count > self.bytes.len().saturating_sub(self.offset) / row_bytes {
+            return Err(invalid(format!(
+                "{label} count cannot fit in the remaining payload"
+            )));
+        }
+        Ok(count)
+    }
+
+    fn finish(self) -> RusticolResult<()> {
+        if self.offset != self.bytes.len() {
+            return Err(invalid(format!(
+                "payload contains {} trailing bytes",
+                self.bytes.len() - self.offset
+            )));
+        }
+        Ok(())
+    }
+}
+
+pub fn decode_recurrence_helicity_dispatch_v1(
+    bytes: &[u8],
+) -> RusticolResult<DirectHelicityDispatch> {
+    let mut reader = Reader::new(bytes);
+    if reader.take(MAGIC.len(), "magic")? != MAGIC {
+        return Err(invalid("payload has the wrong magic"));
+    }
+    if reader.u32("version")? != VERSION {
+        return Err(invalid("payload has an unsupported version"));
+    }
+    reader.reserved_u32("header reserved")?;
+    let runtime_layout_digest = reader.digest("runtime-layout digest")?;
+    let source_row_count = reader.u64("source-row count")?;
+    let contribution_row_count = reader.u64("contribution-row count")?;
+    let finalization_row_count = reader.u64("finalization-row count")?;
+    let closure_row_count = reader.u64("closure-row count")?;
+    let amplitude_destination_count = reader.u32("amplitude-destination count")?;
+    let direct_executor_count = reader.u32("direct-executor count")?;
+    let resolved_helicity_count = reader.u32("resolved-helicity count")?;
+    let support_domain_count = reader.u32("support-domain count")? as usize;
+    let row_group_count = reader.u32("split row-group count")? as usize;
+    let dispatch_count = reader.u32("dispatch count")? as usize;
+    let support_word_count = reader.u64("support-word count")?;
+    let dispatch_group_id_count = reader.u64("dispatch group-ID count")?;
+
+    reader.checked_count(support_domain_count as u64, 16, "support domain")?;
+    let mut support_domains = Vec::with_capacity(support_domain_count);
+    for _ in 0..support_domain_count {
+        let word_start = reader.u64("support-domain word start")?;
+        let word_count = reader.u32("support-domain word count")?;
+        reader.reserved_u32("support-domain reserved")?;
+        support_domains.push(DirectHelicitySupportDomainDescriptor {
+            word_start,
+            word_count,
+        });
+    }
+    let support_word_count = reader.checked_count(support_word_count, 8, "support word")?;
+    let mut support_words = Vec::with_capacity(support_word_count);
+    for _ in 0..support_word_count {
+        support_words.push(reader.u64("support word")?);
+    }
+    reader.checked_count(row_group_count as u64, 24, "split row group")?;
+    let mut row_groups = Vec::with_capacity(row_group_count);
+    for _ in 0..row_group_count {
+        row_groups.push(DirectHelicityRowGroupDescriptor {
+            stage: reader.u16("split row-group stage")?,
+            role: DirectExecutorRole::try_from(reader.u16("split row-group role")?)?,
+            direct_executor_id: reader.u32("split row-group executor")?,
+            row_start: reader.u64("split row-group row start")?,
+            row_count: reader.u32("split row-group row count")?,
+            support_domain_id: reader.u32("split row-group support domain")?,
+        });
+    }
+    reader.checked_count(dispatch_count as u64, 24, "dispatch")?;
+    let mut dispatches = Vec::with_capacity(dispatch_count);
+    for _ in 0..dispatch_count {
+        let resolved_helicity_id = reader.u32("dispatch helicity ID")?;
+        reader.reserved_u32("dispatch leading reserved")?;
+        let group_id_start = reader.u64("dispatch group-ID start")?;
+        let group_id_count = reader.u32("dispatch group-ID count")?;
+        reader.reserved_u32("dispatch trailing reserved")?;
+        dispatches.push(DirectHelicityDispatchDescriptor {
+            resolved_helicity_id,
+            group_id_start,
+            group_id_count,
+        });
+    }
+    let dispatch_group_id_count =
+        reader.checked_count(dispatch_group_id_count, 4, "dispatch group ID")?;
+    let mut dispatch_group_ids = Vec::with_capacity(dispatch_group_id_count);
+    for _ in 0..dispatch_group_id_count {
+        dispatch_group_ids.push(reader.u32("dispatch group ID")?);
+    }
+    reader.finish()?;
+
+    DirectHelicityDispatch::new(DirectHelicityDispatchParts {
+        runtime_layout_digest,
+        source_row_count,
+        contribution_row_count,
+        finalization_row_count,
+        closure_row_count,
+        amplitude_destination_count,
+        direct_executor_count,
+        resolved_helicity_count,
+        support_domains,
+        support_words,
+        row_groups,
+        dispatches,
+        dispatch_group_ids,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    fn valid_parts() -> DirectHelicityDispatchParts {
+        DirectHelicityDispatchParts {
+            runtime_layout_digest: digest(0x22),
+            source_row_count: 2,
+            contribution_row_count: 4,
+            finalization_row_count: 2,
+            closure_row_count: 2,
+            amplitude_destination_count: 2,
+            direct_executor_count: 6,
+            resolved_helicity_count: 3,
+            // Domain 0 is exact zero, 1 is H={0,2}, 2 is H={1}, and 3 is universal.
+            support_domains: vec![
+                DirectHelicitySupportDomainDescriptor {
+                    word_start: 0,
+                    word_count: 0,
+                },
+                DirectHelicitySupportDomainDescriptor {
+                    word_start: 0,
+                    word_count: 1,
+                },
+                DirectHelicitySupportDomainDescriptor {
+                    word_start: 1,
+                    word_count: 1,
+                },
+                DirectHelicitySupportDomainDescriptor {
+                    word_start: 2,
+                    word_count: 1,
+                },
+            ],
+            support_words: vec![0b101, 0b010, 0b111],
+            row_groups: vec![
+                DirectHelicityRowGroupDescriptor {
+                    stage: 1,
+                    role: DirectExecutorRole::Contribution,
+                    direct_executor_id: 1,
+                    row_start: 0,
+                    row_count: 2,
+                    support_domain_id: 1,
+                },
+                DirectHelicityRowGroupDescriptor {
+                    stage: 1,
+                    role: DirectExecutorRole::Contribution,
+                    direct_executor_id: 1,
+                    row_start: 2,
+                    row_count: 1,
+                    support_domain_id: 2,
+                },
+                DirectHelicityRowGroupDescriptor {
+                    stage: 1,
+                    role: DirectExecutorRole::Contribution,
+                    direct_executor_id: 2,
+                    row_start: 3,
+                    row_count: 1,
+                    support_domain_id: 3,
+                },
+                DirectHelicityRowGroupDescriptor {
+                    stage: 1,
+                    role: DirectExecutorRole::Finalization,
+                    direct_executor_id: 3,
+                    row_start: 0,
+                    row_count: 2,
+                    support_domain_id: 3,
+                },
+                DirectHelicityRowGroupDescriptor {
+                    stage: 1,
+                    role: DirectExecutorRole::Closure,
+                    direct_executor_id: 4,
+                    row_start: 0,
+                    row_count: 1,
+                    support_domain_id: 1,
+                },
+                DirectHelicityRowGroupDescriptor {
+                    stage: 1,
+                    role: DirectExecutorRole::Closure,
+                    direct_executor_id: 4,
+                    row_start: 1,
+                    row_count: 1,
+                    support_domain_id: 2,
+                },
+            ],
+            dispatches: vec![
+                DirectHelicityDispatchDescriptor {
+                    resolved_helicity_id: 0,
+                    group_id_start: 0,
+                    group_id_count: 4,
+                },
+                DirectHelicityDispatchDescriptor {
+                    resolved_helicity_id: 1,
+                    group_id_start: 4,
+                    group_id_count: 4,
+                },
+                DirectHelicityDispatchDescriptor {
+                    resolved_helicity_id: 2,
+                    group_id_start: 8,
+                    group_id_count: 4,
+                },
+            ],
+            dispatch_group_ids: vec![0, 2, 3, 4, 1, 2, 3, 5, 0, 2, 3, 4],
+        }
+    }
+
+    #[test]
+    fn dispatch_codec_round_trips_canonical_support_and_csr() {
+        let dispatch = DirectHelicityDispatch::new(valid_parts()).unwrap();
+        let bytes = encode_recurrence_helicity_dispatch_v1(&dispatch).unwrap();
+        let decoded = decode_recurrence_helicity_dispatch_v1(&bytes).unwrap();
+        assert_eq!(decoded, dispatch);
+        assert_eq!(decoded.group_ids_for_helicity(1).unwrap(), &[1, 2, 3, 5]);
+        assert!(decoded.support_domain_contains(1, 2).unwrap());
+        assert!(!decoded.support_domain_contains(1, 1).unwrap());
+        assert_eq!(
+            encode_recurrence_helicity_dispatch_v1(&decoded).unwrap(),
+            bytes
+        );
+    }
+
+    #[test]
+    fn atomic_writer_reports_the_published_payload_identity() {
+        let dispatch = DirectHelicityDispatch::new(valid_parts()).unwrap();
+        let path = std::env::temp_dir().join(format!(
+            "rusticol-helicity-dispatch-{}-{}.bin",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        let metadata = write_recurrence_helicity_dispatch_v1_atomic(&path, &dispatch).unwrap();
+        let bytes = std::fs::read(&path).unwrap();
+        let expected_sha256: [u8; 32] = Sha256::digest(&bytes).into();
+        assert_eq!(metadata.size_bytes, bytes.len() as u64);
+        assert_eq!(metadata.sha256, expected_sha256);
+        assert_eq!(
+            decode_recurrence_helicity_dispatch_v1(&bytes).unwrap(),
+            dispatch
+        );
+        std::fs::remove_file(path).unwrap();
+    }
+
+    #[test]
+    fn dispatch_rejects_csr_that_disagrees_with_support_masks() {
+        let mut parts = valid_parts();
+        parts.dispatch_group_ids[4] = 0;
+        let error = DirectHelicityDispatch::new(parts).unwrap_err();
+        assert!(error.message().contains("disagrees with support masks"));
+    }
+
+    #[test]
+    fn dispatch_rejects_static_source_groups() {
+        let mut parts = valid_parts();
+        parts.row_groups[0].role = DirectExecutorRole::Source;
+        let error = DirectHelicityDispatch::new(parts).unwrap_err();
+        assert!(error.message().contains("static source groups"));
+    }
+
+    #[test]
+    fn dispatch_rejects_noncanonical_support_masks_and_trailing_bytes() {
+        let mut parts = valid_parts();
+        parts.support_words[2] |= 1 << 63;
+        let error = DirectHelicityDispatch::new(parts).unwrap_err();
+        assert!(
+            error
+                .message()
+                .contains("outside the resolved-helicity axis")
+        );
+
+        let dispatch = DirectHelicityDispatch::new(valid_parts()).unwrap();
+        let mut bytes = encode_recurrence_helicity_dispatch_v1(&dispatch).unwrap();
+        bytes.push(0);
+        let error = decode_recurrence_helicity_dispatch_v1(&bytes).unwrap_err();
+        assert!(error.message().contains("trailing bytes"));
+    }
+
+    #[test]
+    fn plan_pairing_fails_closed_before_accepting_a_non_union_plan() {
+        let dispatch = DirectHelicityDispatch::new(valid_parts()).unwrap();
+        let plan = crate::recurrence::valid_direct_plan_fixture();
+        let error = dispatch.validate_for_plan(&plan).unwrap_err();
+        assert!(error.message().contains("all-flow-union"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_lowering.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_lowering.rs
new file mode 100644
index 0000000000..42c76a1b17
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_lowering.rs
@@ -0,0 +1,3824 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Deterministic lowering from a validated semantic recurrence program to the
+//! direct-arena layout.
+//!
+//! This is deliberately a lowering-only slice. It creates immutable row-group
+//! descriptors and direct-arena rows; it does not construct or invoke a
+//! prepared runtime backend.
+
+use std::borrow::Cow;
+use std::collections::{BTreeMap, BTreeSet};
+
+use super::arena::{DirectArenaLayout, recurrence_direct_arena_layout};
+use super::direct_helicity_dispatch::{
+    DirectHelicityDispatch, DirectHelicityDispatchDescriptor, DirectHelicityDispatchParts,
+    DirectHelicityRowGroupDescriptor, DirectHelicitySupportDomainDescriptor,
+};
+use super::direct_plan::{
+    DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE, DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+    DIRECT_NONE_U32, DirectAmplitudeDestinationDescriptor, DirectClosureRow, DirectContributionRow,
+    DirectCurrentDescriptor, DirectDestinationOperation, DirectExecutorRole, DirectFinalizationRow,
+    DirectMomentumFormDescriptor, DirectMomentumTerm, DirectNodeKind, DirectRecurrencePlan,
+    DirectRecurrencePlanParts, DirectReplayTargetDescriptor, DirectResolvedHelicityDescriptor,
+    DirectResolvedSourceSelection, DirectRowGroupDescriptor, DirectSelectorDomainDescriptor,
+    DirectSourceDispatchVariantDescriptor, DirectSourceEmbeddingRow, DirectSourceProjectionRow,
+    DirectSourceRow, DirectSourceStateAssignment,
+};
+use super::helicity_support::{
+    AllFlowHelicityMask, AllFlowHelicitySupportProjection, project_all_flow_helicity_support,
+};
+use super::layout::RuntimeSourceVariantBinding;
+use super::relation::{
+    RecurrenceCurrentRelationCertificate, RecurrenceRelationDiscoveryMode,
+    RecurrenceRelationDiscoveryOptions, RecurrenceRelationDiscoveryOutcome,
+    RecurrenceRelationDiscoveryReport, RelationCurrentContract, RelationCurrentInput,
+    RelationTermInput, discover_recurrence_current_relations, relation_certificate_algorithm,
+};
+use super::template::{
+    EvaluatorContractKind, MISSING_U32, OwnedRecurrenceTemplateInput, RuntimeHelicityVariantRow,
+    ValidatedRecurrenceTemplateInput,
+};
+use super::{
+    CanonicalMomentumLinearForm, ClosureProofMetadataV2, CurrentSourceBinding,
+    ExactComplexRational, RecurrenceCurrent, RecurrenceNodeKind, RecurrenceProgram,
+    RecurrenceStrategy, SemanticDigest, SourceStateAssignment, closure_component_factor_digest_v2,
+    closure_selector_domain_digest_v2,
+};
+use crate::{RusticolError, RusticolResult};
+
+const UNIVERSAL_SELECTOR_DOMAIN_ID: u32 = 0;
+const DIRECT_ROW_FLAGS_NONE: u32 = 0;
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(format!("recurrence direct lowering: {}", message.into()))
+}
+
+fn is_sha256(value: &str) -> bool {
+    value.len() == 64
+        && value
+            .bytes()
+            .all(|character| character.is_ascii_digit() || (b'a'..=b'f').contains(&character))
+}
+
+/// Runtime sizing recorded in the immutable direct plan.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct DirectRecurrenceRuntimeOptions {
+    pub point_tile_size: u32,
+    pub workspace_mib: u32,
+}
+
+impl DirectRecurrenceRuntimeOptions {
+    pub fn new(point_tile_size: u32, workspace_mib: u32) -> RusticolResult<Self> {
+        if point_tile_size == 0 {
+            return Err(invalid("point tile size must be positive"));
+        }
+        if workspace_mib == 0 {
+            return Err(invalid("workspace MiB must be positive"));
+        }
+        Ok(Self {
+            point_tile_size,
+            workspace_mib,
+        })
+    }
+}
+
+/// Stable semantic key exported by prepared direct-template-v1.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub enum PreparedDirectExecutorKey {
+    Evaluator {
+        role: DirectExecutorRole,
+        evaluator_binding_id: u32,
+    },
+    IdentityFinalizer,
+}
+
+impl PreparedDirectExecutorKey {
+    const fn role(self) -> DirectExecutorRole {
+        match self {
+            Self::Evaluator { role, .. } => role,
+            Self::IdentityFinalizer => DirectExecutorRole::Finalization,
+        }
+    }
+}
+
+/// One authenticated prepared direct-template mapping.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct PreparedDirectExecutorBinding {
+    pub key: PreparedDirectExecutorKey,
+    pub direct_executor_id: u32,
+    pub parent_permutation: [u8; 2],
+}
+
+impl PreparedDirectExecutorBinding {
+    pub const fn evaluator(
+        role: DirectExecutorRole,
+        evaluator_binding_id: u32,
+        direct_executor_id: u32,
+    ) -> Self {
+        Self {
+            key: PreparedDirectExecutorKey::Evaluator {
+                role,
+                evaluator_binding_id,
+            },
+            direct_executor_id,
+            parent_permutation: [0, 1],
+        }
+    }
+
+    pub const fn evaluator_with_parent_permutation(
+        role: DirectExecutorRole,
+        evaluator_binding_id: u32,
+        direct_executor_id: u32,
+        parent_permutation: [u8; 2],
+    ) -> Self {
+        Self {
+            key: PreparedDirectExecutorKey::Evaluator {
+                role,
+                evaluator_binding_id,
+            },
+            direct_executor_id,
+            parent_permutation,
+        }
+    }
+
+    pub const fn identity_finalizer(direct_executor_id: u32) -> Self {
+        Self {
+            key: PreparedDirectExecutorKey::IdentityFinalizer,
+            direct_executor_id,
+            parent_permutation: [0, 1],
+        }
+    }
+}
+
+/// Authenticated model-level direct executor resolver.
+///
+/// IDs are the globally stable dense IDs owned by the complete loaded
+/// direct-template catalog. Lowering never compacts or renumbers a
+/// process-specific subset.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PreparedDirectExecutorCatalog {
+    direct_template_catalog_digest: SemanticDigest,
+    bindings: BTreeMap<PreparedDirectExecutorKey, PreparedDirectExecutorBinding>,
+    executor_roles: Box<[DirectExecutorRole]>,
+}
+
+impl PreparedDirectExecutorCatalog {
+    pub fn new(
+        direct_template_catalog_digest: SemanticDigest,
+        bindings: Vec<PreparedDirectExecutorBinding>,
+    ) -> RusticolResult<Self> {
+        if bindings.is_empty() {
+            return Err(invalid(
+                "prepared direct-template executor catalog must not be empty",
+            ));
+        }
+        let mut by_key = BTreeMap::new();
+        let mut roles_by_id = BTreeMap::new();
+        for binding in bindings {
+            if matches!(
+                binding.key,
+                PreparedDirectExecutorKey::Evaluator {
+                    evaluator_binding_id: MISSING_U32,
+                    ..
+                }
+            ) {
+                return Err(invalid(
+                    "prepared direct-template mapping uses the missing evaluator-binding sentinel",
+                ));
+            }
+            if !matches!(binding.parent_permutation, [0, 1] | [1, 0])
+                || (binding.parent_permutation != [0, 1]
+                    && binding.key.role() != DirectExecutorRole::Contribution)
+            {
+                return Err(invalid(
+                    "prepared direct-template mapping has an invalid parent permutation",
+                ));
+            }
+            if by_key.insert(binding.key, binding).is_some() {
+                return Err(invalid(format!(
+                    "prepared direct-template mapping repeats key {:?}",
+                    binding.key
+                )));
+            }
+            let role = binding.key.role();
+            if let Some(previous) = roles_by_id.insert(binding.direct_executor_id, role)
+                && previous != role
+            {
+                return Err(invalid(format!(
+                    "prepared direct executor {} is assigned both {previous:?} and {role:?} roles",
+                    binding.direct_executor_id
+                )));
+            }
+        }
+        for (expected, actual) in roles_by_id.keys().copied().enumerate() {
+            if actual != u32_len("prepared direct executor", expected)? {
+                return Err(invalid(format!(
+                    "prepared direct executor IDs are not dense zero-based at {actual}"
+                )));
+            }
+        }
+        let executor_roles = roles_by_id
+            .into_values()
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+        Ok(Self {
+            direct_template_catalog_digest,
+            bindings: by_key,
+            executor_roles,
+        })
+    }
+
+    pub const fn direct_template_catalog_digest(&self) -> SemanticDigest {
+        self.direct_template_catalog_digest
+    }
+
+    pub fn direct_executor_count(&self) -> u32 {
+        self.executor_roles.len() as u32
+    }
+
+    pub fn resolve_evaluator(
+        &self,
+        role: DirectExecutorRole,
+        evaluator_binding_id: u32,
+    ) -> RusticolResult<u32> {
+        let key = PreparedDirectExecutorKey::Evaluator {
+            role,
+            evaluator_binding_id,
+        };
+        if let Some(binding) = self.bindings.get(&key) {
+            return Ok(binding.direct_executor_id);
+        }
+        if self.bindings.keys().any(|key| {
+            matches!(
+                key,
+                PreparedDirectExecutorKey::Evaluator {
+                    evaluator_binding_id: candidate,
+                    ..
+                } if *candidate == evaluator_binding_id
+            )
+        }) {
+            return Err(invalid(format!(
+                "prepared direct-template mapping for evaluator binding {evaluator_binding_id} has a role mismatch; expected {role:?}"
+            )));
+        }
+        Err(invalid(format!(
+            "prepared direct-template catalog has no {role:?} mapping for evaluator binding {evaluator_binding_id}"
+        )))
+    }
+
+    pub fn resolve_contribution(
+        &self,
+        evaluator_binding_id: u32,
+    ) -> RusticolResult<(u32, [u8; 2])> {
+        let key = PreparedDirectExecutorKey::Evaluator {
+            role: DirectExecutorRole::Contribution,
+            evaluator_binding_id,
+        };
+        let binding = self.bindings.get(&key).ok_or_else(|| {
+            invalid(format!(
+                "prepared direct-template catalog has no Contribution mapping for evaluator binding {evaluator_binding_id}"
+            ))
+        })?;
+        Ok((binding.direct_executor_id, binding.parent_permutation))
+    }
+
+    pub fn resolve_identity_finalizer(&self) -> RusticolResult<u32> {
+        self.bindings
+            .get(&PreparedDirectExecutorKey::IdentityFinalizer)
+            .map(|binding| binding.direct_executor_id)
+            .ok_or_else(|| {
+                invalid(
+                    "prepared direct-template catalog has no generic identity-finalizer binding",
+                )
+            })
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct SourceDraft {
+    stage: u16,
+    executor_id: u32,
+    semantic_current_id: u32,
+    row: DirectSourceRow,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct ContributionDraft {
+    stage: u16,
+    executor_id: u32,
+    semantic_contribution_id: u32,
+    semantic_result_current_id: u32,
+    semantic_parent_current_ids: [u32; 2],
+    semantic_parent_count: u8,
+    row: DirectContributionRow,
+}
+
+/// Authenticated runtime inputs which determine one contribution callable's
+/// kinematic result before its row-local destination/factor application.
+///
+/// The prepared executor ID fixes the callable, component layouts, coupling,
+/// and model-parameter projections. Physical current/momentum coordinates fix
+/// every remaining kinematic operand. Exact factors are ordered inside this
+/// key rather than being part of it: intrinsic output-only executors may fan
+/// out across factors, while prepared callables conservatively split the
+/// adjacent run by factor at load time when the factor is a kernel input.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ContributionFanoutOrderKey {
+    stage: u32,
+    executor_id: u32,
+    selector_domain_id: u32,
+    parent0_component_base: u32,
+    parent1_component_base_or_sentinel: u32,
+    parent0_momentum_form_id: u32,
+    parent1_momentum_form_id_or_sentinel: u32,
+}
+
+fn contribution_fanout_order_key_parts(
+    stage: u32,
+    executor_id: u32,
+    row: DirectContributionRow,
+) -> ContributionFanoutOrderKey {
+    ContributionFanoutOrderKey {
+        stage,
+        executor_id,
+        selector_domain_id: row.selector_domain_id,
+        parent0_component_base: row.parent0_component_base,
+        parent1_component_base_or_sentinel: row.parent1_component_base_or_sentinel,
+        parent0_momentum_form_id: row.parent0_momentum_form_id,
+        parent1_momentum_form_id_or_sentinel: row.parent1_momentum_form_id_or_sentinel,
+    }
+}
+
+#[cfg(test)]
+fn contribution_fanout_order_key(draft: &ContributionDraft) -> ContributionFanoutOrderKey {
+    contribution_fanout_order_key_parts(u32::from(draft.stage), draft.executor_id, draft.row)
+}
+
+/// Place repeated kinematic inputs before singleton inputs and make every
+/// reusable class contiguous. This is a deliberate deterministic change to
+/// floating-point accumulation order, not a physics approximation: each
+/// destination still receives every exact-factor-scaled contribution once,
+/// with its first row initialized and all later rows added. Exact/high-
+/// precision execution remains driven by the semantic schedule.
+/// Certified copies retain their incoming topological order within each
+/// stage/executor/domain: recycled arena addresses are not dependency ranks.
+pub(crate) fn order_contributions_for_runtime_fanout_by<T, Tie>(
+    drafts: &mut [T],
+    parts: impl Fn(&T) -> (u32, u32, DirectContributionRow, Tie),
+) where
+    Tie: Ord,
+{
+    let mut multiplicity = BTreeMap::<ContributionFanoutOrderKey, usize>::new();
+    for draft in drafts.iter() {
+        let (stage, executor_id, row, _) = parts(draft);
+        if executor_id != DIRECT_NONE_U32
+            && row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE == 0
+        {
+            *multiplicity
+                .entry(contribution_fanout_order_key_parts(stage, executor_id, row))
+                .or_default() += 1;
+        }
+    }
+    drafts.sort_by_key(|draft| {
+        let (stage, executor_id, row, tie) = parts(draft);
+        let key = contribution_fanout_order_key_parts(stage, executor_id, row);
+        let certified_copy = row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0;
+        let reusable = executor_id != DIRECT_NONE_U32
+            && !certified_copy
+            && multiplicity.get(&key).copied().unwrap_or(0) > 1;
+        (
+            stage,
+            executor_id,
+            row.selector_domain_id,
+            !reusable,
+            (!certified_copy).then_some((
+                key.parent0_component_base,
+                key.parent1_component_base_or_sentinel,
+                key.parent0_momentum_form_id,
+                key.parent1_momentum_form_id_or_sentinel,
+                row.exact_factor_id,
+                tie,
+            )),
+        )
+    });
+}
+
+fn order_contributions_for_runtime_fanout(drafts: &mut [ContributionDraft]) {
+    order_contributions_for_runtime_fanout_by(drafts, |draft| {
+        (
+            u32::from(draft.stage),
+            draft.executor_id,
+            draft.row,
+            draft.semantic_contribution_id,
+        )
+    });
+}
+
+/// Temporary generation-time locality information. Only the resulting row
+/// order is persisted: loading or selecting helicities does not run this pass.
+#[derive(Debug)]
+struct FixedHelicityDemands {
+    word_count: usize,
+    words: Vec<u64>,
+}
+
+impl FixedHelicityDemands {
+    fn current(&self, current_id: u32) -> &[u64] {
+        let start = current_id as usize * self.word_count;
+        &self.words[start..start + self.word_count]
+    }
+}
+
+fn fixed_helicity_demands(
+    current_count: usize,
+    helicity_count: usize,
+    contributions: &[ContributionDraft],
+    seeds: impl Iterator<Item = (u32, u32)>,
+) -> RusticolResult<FixedHelicityDemands> {
+    let word_count = helicity_count.div_ceil(64);
+    let scalar_count = current_count
+        .checked_mul(word_count)
+        .ok_or_else(|| invalid("fixed-helicity locality mask size overflows usize"))?;
+    let mut demands = FixedHelicityDemands {
+        word_count,
+        words: vec![0; scalar_count],
+    };
+    for (current_id, helicity_id) in seeds {
+        if current_id as usize >= current_count || helicity_id as usize >= helicity_count {
+            return Err(invalid(
+                "fixed-helicity locality seed is outside the program",
+            ));
+        }
+        demands.words[current_id as usize * word_count + helicity_id as usize / 64] |=
+            1_u64 << (helicity_id % 64);
+    }
+
+    // Use the actual lowered edges, including certified numerical copies, not
+    // the original source-state ancestry. Flat linked row lists avoid making
+    // a second collection of all parent IDs or allocating one list per current.
+    let mut first_contribution = vec![usize::MAX; current_count];
+    let mut next_contribution = vec![usize::MAX; contributions.len()];
+    for (row_id, draft) in contributions.iter().enumerate() {
+        let result = draft.semantic_result_current_id as usize;
+        if result >= current_count {
+            return Err(invalid(
+                "fixed-helicity locality result is outside the program",
+            ));
+        }
+        let parents = draft
+            .semantic_parent_current_ids
+            .get(..usize::from(draft.semantic_parent_count))
+            .ok_or_else(|| invalid("fixed-helicity locality parent count is invalid"))?;
+        if parents.iter().any(|&parent| {
+            parent as usize > result
+                || (parent as usize == result
+                    && draft.row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE == 0)
+        }) {
+            return Err(invalid(
+                "fixed-helicity locality requires topologically ordered current dependencies",
+            ));
+        }
+        next_contribution[row_id] = first_contribution[result];
+        first_contribution[result] = row_id;
+    }
+    for result in (0..current_count).rev() {
+        let mut row_id = first_contribution[result];
+        let (earlier, current_and_later) = demands.words.split_at_mut(result * word_count);
+        let result_words = &current_and_later[..word_count];
+        while row_id != usize::MAX {
+            let draft = &contributions[row_id];
+            for &parent in
+                &draft.semantic_parent_current_ids[..usize::from(draft.semantic_parent_count)]
+            {
+                // A certified zero current may keep a self-copy row. It
+                // introduces no additional dependency or demanded helicity.
+                if parent as usize == result {
+                    continue;
+                }
+                let start = parent as usize * word_count;
+                for (word, demanded) in earlier[start..start + word_count]
+                    .iter_mut()
+                    .zip(result_words)
+                {
+                    *word |= *demanded;
+                }
+            }
+            row_id = next_contribution[row_id];
+        }
+    }
+    Ok(demands)
+}
+
+fn topology_replay_helicity_demands(
+    program: &RecurrenceProgram,
+    contributions: &[ContributionDraft],
+) -> RusticolResult<Option<FixedHelicityDemands>> {
+    if program.strategy() != RecurrenceStrategy::TopologyReplay
+        || program.resolved_helicities().len() <= 1
+        || program
+            .amplitude_destinations()
+            .iter()
+            .any(|destination| destination.target_helicity_id().is_none())
+    {
+        return Ok(None);
+    }
+    let seeds = program.closure_terms().iter().flat_map(|closure| {
+        let helicity = program.amplitude_destinations()[closure.target_destination_id() as usize]
+            .target_helicity_id()
+            .expect("validated topology-replay destinations specify their helicity");
+        closure
+            .parent_current_ids()
+            .iter()
+            .map(move |&current| (current, helicity))
+    });
+    fixed_helicity_demands(
+        program.currents().len(),
+        program.resolved_helicities().len(),
+        contributions,
+        seeds,
+    )
+    .map(Some)
+}
+
+/// Improve selected-helicity locality without splitting an existing reusable
+/// parent-input class. This follows the ordinary fanout ordering and leaves
+/// each class's exact-factor/destination order intact. Same-stage certified
+/// copies are left in their existing order to preserve copy dependencies.
+fn order_contributions_for_helicity_locality(
+    drafts: &mut [ContributionDraft],
+    demands: &FixedHelicityDemands,
+) {
+    let mut group_start = 0;
+    while group_start < drafts.len() {
+        let first = &drafts[group_start];
+        let primary = (first.stage, first.executor_id, first.row.selector_domain_id);
+        let mut group_end = group_start + 1;
+        while group_end < drafts.len() {
+            let next = &drafts[group_end];
+            if (next.stage, next.executor_id, next.row.selector_domain_id) != primary {
+                break;
+            }
+            group_end += 1;
+        }
+        let group = &mut drafts[group_start..group_end];
+        if primary.1 != DIRECT_NONE_U32
+            && !group
+                .iter()
+                .any(|draft| draft.row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0)
+        {
+            let mut blocks = Vec::new();
+            let mut start = 0;
+            while start < group.len() {
+                let first = &group[start];
+                let key = contribution_fanout_order_key_parts(
+                    u32::from(first.stage),
+                    first.executor_id,
+                    first.row,
+                );
+                let mut end = start + 1;
+                while end < group.len()
+                    && contribution_fanout_order_key_parts(
+                        u32::from(group[end].stage),
+                        group[end].executor_id,
+                        group[end].row,
+                    ) == key
+                {
+                    end += 1;
+                }
+                let mut support = Cow::Borrowed(demands.current(first.semantic_result_current_id));
+                for draft in &group[start + 1..end] {
+                    let next = demands.current(draft.semantic_result_current_id);
+                    if support.as_ref() != next {
+                        for (word, demanded) in support.to_mut().iter_mut().zip(next) {
+                            *word |= *demanded;
+                        }
+                    }
+                }
+                blocks.push((start..end, support));
+                start = end;
+            }
+            // Preserve the original repeated-input-before-singleton policy.
+            // Stable sorting retains the old order within equal support masks.
+            if !blocks.is_sorted_by(|left, right| {
+                (left.0.len() == 1, &left.1) <= (right.0.len() == 1, &right.1)
+            }) {
+                blocks.sort_by(|left, right| {
+                    (left.0.len() == 1)
+                        .cmp(&(right.0.len() == 1))
+                        .then_with(|| left.1.cmp(&right.1))
+                });
+                let reordered = blocks
+                    .iter()
+                    .flat_map(|(range, _)| group[range.clone()].iter().copied())
+                    .collect::<Vec<_>>();
+                group.copy_from_slice(&reordered);
+            }
+        }
+        group_start = group_end;
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct FinalizationDraft {
+    stage: u16,
+    executor_id: u32,
+    semantic_current_id: u32,
+    row: DirectFinalizationRow,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct ClosureDraft {
+    stage: u16,
+    executor_id: u32,
+    semantic_closure_id: u32,
+    amplitude_destination_id: u32,
+    row: DirectClosureRow,
+}
+
+#[derive(Debug)]
+struct LoweredHelicityRowSupport {
+    resolved_helicity_count: u32,
+    contributions: Vec<Vec<u64>>,
+    finalizations: Vec<Vec<u64>>,
+    closures: Vec<Vec<u64>>,
+}
+
+struct LoweredSelectorDomains {
+    descriptors: Vec<DirectSelectorDomainDescriptor>,
+    words: Vec<u64>,
+    current_domain_ids: Vec<u32>,
+    closure_domain_ids: Vec<u32>,
+    destination_domain_ids: Vec<u32>,
+    sector_domain_ids: Vec<Option<u32>>,
+}
+
+fn canonical_selector_words(domain: &[u64]) -> &[u64] {
+    let mut retained = domain
+        .iter()
+        .rposition(|word| *word != 0)
+        .map_or(0, |index| index + 1);
+    // Direct-plan v2 reserves the one-word [u64::MAX] encoding for the
+    // universal selector.  For a wider physical-sector domain, a legitimate
+    // selector containing only sectors 0..63 must retain one trailing zero so
+    // it cannot alias that sentinel.
+    if retained == 1 && domain.len() > 1 && domain[0] == u64::MAX {
+        retained = 2;
+    }
+    &domain[..retained]
+}
+
+fn lower_selector_domains(program: &RecurrenceProgram) -> RusticolResult<LoweredSelectorDomains> {
+    // Keep the historical universal row first.  Besides making complete-color
+    // plans byte-for-byte stable, this is the backwards-compatible
+    // direct-plan-v2 encoding recognized by the runtime.
+    let mut descriptors = vec![DirectSelectorDomainDescriptor {
+        word_start: 0,
+        word_count: 1,
+    }];
+    let mut words = vec![u64::MAX];
+    if !program.strategy().uses_topology_replay_targets() || program.replay_targets().is_empty() {
+        return Ok(LoweredSelectorDomains {
+            descriptors,
+            words,
+            current_domain_ids: vec![UNIVERSAL_SELECTOR_DOMAIN_ID; program.currents().len()],
+            closure_domain_ids: vec![UNIVERSAL_SELECTOR_DOMAIN_ID; program.closure_terms().len()],
+            destination_domain_ids: vec![
+                UNIVERSAL_SELECTOR_DOMAIN_ID;
+                program.amplitude_destinations().len()
+            ],
+            sector_domain_ids: vec![
+                Some(UNIVERSAL_SELECTOR_DOMAIN_ID);
+                program.physical_sector_count() as usize
+            ],
+        });
+    }
+
+    let sector_count = program.physical_sector_count() as usize;
+    let word_count = sector_count
+        .checked_add(u64::BITS as usize - 1)
+        .ok_or_else(|| invalid("selector-domain sector count overflows usize"))?
+        / u64::BITS as usize;
+    if word_count == 0 {
+        return Err(invalid(
+            "topology-replay selector domains require physical sectors",
+        ));
+    }
+    let mut current_words = vec![vec![0_u64; word_count]; program.currents().len()];
+    let mut closure_words = Vec::with_capacity(program.closure_terms().len());
+    for closure in program.closure_terms() {
+        let destination = program
+            .amplitude_destinations()
+            .get(closure.target_destination_id() as usize)
+            .ok_or_else(|| invalid("closure selector destination is absent"))?;
+        let sector_id = destination.target_sector_id() as usize;
+        if sector_id >= sector_count {
+            return Err(invalid("closure selector sector is out of bounds"));
+        }
+        let mut domain = vec![0_u64; word_count];
+        domain[sector_id / u64::BITS as usize] |= 1_u64 << (sector_id % u64::BITS as usize);
+        for parent_id in closure.parent_current_ids() {
+            let parent = current_words
+                .get_mut(*parent_id as usize)
+                .ok_or_else(|| invalid("closure selector parent current is absent"))?;
+            for (parent_word, sector_word) in parent.iter_mut().zip(&domain) {
+                *parent_word |= *sector_word;
+            }
+        }
+        closure_words.push(domain);
+    }
+
+    // Current IDs are topological.  Walking backwards propagates every
+    // selected closure sector through exactly the parent currents needed to
+    // construct it, retaining sharing as the union of dependent sectors.
+    for current in program.currents().iter().rev() {
+        let domain = current_words
+            .get(current.id() as usize)
+            .ok_or_else(|| invalid("selector current is absent"))?
+            .clone();
+        // Builder programs may retain structurally valid dead currents.  Keep
+        // their fixed-width all-zero domain: full execution remains
+        // byte-for-byte compatible, while selected replay can omit them.
+        let contributions = current.contribution_range().as_usize_range(
+            program.contributions().len(),
+            "selector current contribution",
+        )?;
+        for contribution in &program.contributions()[contributions] {
+            for parent_id in contribution.parent_current_ids() {
+                let parent = current_words
+                    .get_mut(*parent_id as usize)
+                    .ok_or_else(|| invalid("selector contribution parent current is absent"))?;
+                for (parent_word, current_word) in parent.iter_mut().zip(&domain) {
+                    *parent_word |= *current_word;
+                }
+            }
+        }
+    }
+
+    let mut interned = BTreeMap::<Vec<u64>, u32>::new();
+    interned.insert(vec![u64::MAX], UNIVERSAL_SELECTOR_DOMAIN_ID);
+    let mut intern = |domain: &[u64]| -> RusticolResult<u32> {
+        let domain = canonical_selector_words(domain);
+        if let Some(id) = interned.get(domain) {
+            return Ok(*id);
+        }
+        let id = u32::try_from(descriptors.len())
+            .map_err(|_| invalid("selector-domain count exceeds u32"))?;
+        let word_start = u64::try_from(words.len())
+            .map_err(|_| invalid("selector-domain word table exceeds u64"))?;
+        let word_count = u32::try_from(domain.len())
+            .map_err(|_| invalid("selector-domain word count exceeds u32"))?;
+        words.extend_from_slice(domain);
+        descriptors.push(DirectSelectorDomainDescriptor {
+            word_start,
+            word_count,
+        });
+        interned.insert(domain.to_vec(), id);
+        Ok(id)
+    };
+
+    let referenced_sector_ids = program
+        .amplitude_destinations()
+        .iter()
+        .map(|destination| destination.target_sector_id())
+        .chain(
+            program
+                .replay_targets()
+                .iter()
+                .map(|target| target.materialized_sector_id()),
+        )
+        .collect::<BTreeSet<_>>();
+    let mut sector_domain_ids = vec![None; sector_count];
+    for sector_id in referenced_sector_ids {
+        let sector_index = sector_id as usize;
+        if sector_index >= sector_count {
+            return Err(invalid("referenced selector sector is out of bounds"));
+        }
+        let mut domain = vec![0_u64; word_count];
+        domain[sector_index / u64::BITS as usize] |= 1_u64 << (sector_index % u64::BITS as usize);
+        sector_domain_ids[sector_index] = Some(intern(&domain)?);
+    }
+    let current_domain_ids = current_words
+        .iter()
+        .map(|domain| intern(domain))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let closure_domain_ids = closure_words
+        .iter()
+        .map(|domain| intern(domain))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let destination_domain_ids = program
+        .amplitude_destinations()
+        .iter()
+        .map(|destination| {
+            sector_domain_ids
+                .get(destination.target_sector_id() as usize)
+                .copied()
+                .flatten()
+                .ok_or_else(|| invalid("amplitude selector sector is out of bounds"))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    Ok(LoweredSelectorDomains {
+        descriptors,
+        words,
+        current_domain_ids,
+        closure_domain_ids,
+        destination_domain_ids,
+        sector_domain_ids,
+    })
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(super) struct DirectParents {
+    pub(super) parent0_component_base: u32,
+    pub(super) parent1_component_base_or_sentinel: u32,
+    pub(super) parent0_momentum_form_id: u32,
+    pub(super) parent1_momentum_form_id_or_sentinel: u32,
+}
+
+impl DirectParents {
+    pub(super) fn permuted(self, permutation: [u8; 2]) -> RusticolResult<Self> {
+        match permutation {
+            [0, 1] => Ok(self),
+            [1, 0] if self.parent1_component_base_or_sentinel != DIRECT_NONE_U32 => Ok(Self {
+                parent0_component_base: self.parent1_component_base_or_sentinel,
+                parent1_component_base_or_sentinel: self.parent0_component_base,
+                parent0_momentum_form_id: self.parent1_momentum_form_id_or_sentinel,
+                parent1_momentum_form_id_or_sentinel: self.parent0_momentum_form_id,
+            }),
+            [1, 0] => Err(invalid(
+                "binary contribution parent permutation references an absent second parent",
+            )),
+            _ => Err(invalid(
+                "direct contribution has an invalid parent permutation",
+            )),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(super) struct RuntimeSourceChoice {
+    pub(super) source_state_index: u32,
+    pub(super) public_helicity: i32,
+    pub(super) dispatch_variant_id: u32,
+}
+
+#[derive(Debug, Default)]
+struct LoweredRuntimeSources {
+    variants: Vec<DirectSourceDispatchVariantDescriptor>,
+    embeddings: Vec<DirectSourceEmbeddingRow>,
+    projections: Vec<DirectSourceProjectionRow>,
+    choices_by_source: Vec<Vec<RuntimeSourceChoice>>,
+}
+
+/// Lower one validated recurrence program to validated plan-v2 parts.
+///
+/// `semantic_digest` authenticates the process semantic plan.
+/// `prepared_pack_digest` must authenticate the prepared pack whose evaluator
+/// bindings are present in `templates`. `direct_template_catalog_digest`
+/// authenticates `direct_executors`.
+pub fn lower_recurrence_direct_v2(
+    program: &RecurrenceProgram,
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct_executors: &PreparedDirectExecutorCatalog,
+    semantic_digest: SemanticDigest,
+    prepared_pack_digest: SemanticDigest,
+    direct_template_catalog_digest: SemanticDigest,
+    runtime_options: DirectRecurrenceRuntimeOptions,
+) -> RusticolResult<DirectRecurrencePlanParts> {
+    let (parts, _, _) = build_direct_parts(
+        program,
+        templates,
+        direct_executors,
+        semantic_digest,
+        prepared_pack_digest,
+        direct_template_catalog_digest,
+        runtime_options,
+        &RecurrenceRelationDiscoveryOptions::off(),
+        None,
+    )?;
+    DirectRecurrencePlan::new(parts).map(DirectRecurrencePlan::into_parts)
+}
+
+/// Lower one validated recurrence program directly to an immutable plan.
+pub fn lower_recurrence_direct_plan_v2(
+    program: &RecurrenceProgram,
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct_executors: &PreparedDirectExecutorCatalog,
+    semantic_digest: SemanticDigest,
+    prepared_pack_digest: SemanticDigest,
+    direct_template_catalog_digest: SemanticDigest,
+    runtime_options: DirectRecurrenceRuntimeOptions,
+) -> RusticolResult<DirectRecurrencePlan> {
+    let (parts, _, _) = build_direct_parts(
+        program,
+        templates,
+        direct_executors,
+        semantic_digest,
+        prepared_pack_digest,
+        direct_template_catalog_digest,
+        runtime_options,
+        &RecurrenceRelationDiscoveryOptions::off(),
+        None,
+    )?;
+    DirectRecurrencePlan::new(parts)
+}
+
+/// Lower one physical all-flow program together with its exact persisted
+/// helicity-dispatch sidecar.
+///
+/// The ordinary DirectPlan remains unchanged and executable on its own.  The
+/// companion sidecar selects dependency-closed non-source row runs for one
+/// resolved helicity during cold schedule binding; warm execution uses only
+/// that already-specialized schedule.
+pub fn lower_recurrence_direct_plan_v2_with_helicity_dispatch(
+    program: &RecurrenceProgram,
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct_executors: &PreparedDirectExecutorCatalog,
+    semantic_digest: SemanticDigest,
+    prepared_pack_digest: SemanticDigest,
+    direct_template_catalog_digest: SemanticDigest,
+    runtime_options: DirectRecurrenceRuntimeOptions,
+) -> RusticolResult<(DirectRecurrencePlan, DirectHelicityDispatch)> {
+    let projection = project_all_flow_helicity_support(program, templates)?;
+    let (parts, _, lowered_support) = build_direct_parts(
+        program,
+        templates,
+        direct_executors,
+        semantic_digest,
+        prepared_pack_digest,
+        direct_template_catalog_digest,
+        runtime_options,
+        &RecurrenceRelationDiscoveryOptions::off(),
+        Some(&projection),
+    )?;
+    let lowered_support = lowered_support
+        .ok_or_else(|| invalid("all-flow helicity support disappeared during direct lowering"))?;
+    let plan = DirectRecurrencePlan::new(parts)?;
+    let dispatch = lower_direct_helicity_dispatch(&plan, lowered_support)?;
+    dispatch.validate_for_plan(&plan)?;
+    Ok((plan, dispatch))
+}
+
+/// Lower recurrence with opt-in relation diagnostics or certified scale-copy
+/// reuse. The returned report is absent only when the mode is `off`.
+#[allow(clippy::too_many_arguments)]
+pub fn lower_recurrence_direct_plan_v2_with_relation_discovery(
+    program: &RecurrenceProgram,
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct_executors: &PreparedDirectExecutorCatalog,
+    semantic_digest: SemanticDigest,
+    prepared_pack_digest: SemanticDigest,
+    direct_template_catalog_digest: SemanticDigest,
+    runtime_options: DirectRecurrenceRuntimeOptions,
+    relation_options: &RecurrenceRelationDiscoveryOptions,
+) -> RusticolResult<(
+    DirectRecurrencePlan,
+    Option<RecurrenceRelationDiscoveryReport>,
+)> {
+    let (parts, report, _) = build_direct_parts(
+        program,
+        templates,
+        direct_executors,
+        semantic_digest,
+        prepared_pack_digest,
+        direct_template_catalog_digest,
+        runtime_options,
+        relation_options,
+        None,
+    )?;
+    Ok((DirectRecurrencePlan::new(parts)?, report))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_direct_parts(
+    program: &RecurrenceProgram,
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct_executors: &PreparedDirectExecutorCatalog,
+    semantic_digest: SemanticDigest,
+    prepared_pack_digest: SemanticDigest,
+    direct_template_catalog_digest: SemanticDigest,
+    runtime_options: DirectRecurrenceRuntimeOptions,
+    relation_options: &RecurrenceRelationDiscoveryOptions,
+    helicity_support: Option<&AllFlowHelicitySupportProjection>,
+) -> RusticolResult<(
+    DirectRecurrencePlanParts,
+    Option<RecurrenceRelationDiscoveryReport>,
+    Option<LoweredHelicityRowSupport>,
+)> {
+    validate_lowering_boundary(
+        program,
+        templates,
+        direct_executors,
+        prepared_pack_digest,
+        direct_template_catalog_digest,
+        runtime_options,
+    )?;
+
+    let input = templates.input();
+    let external_source_count = external_source_count(program)?;
+    let component_counts = component_counts(program, templates)?;
+    let arena = recurrence_direct_arena_layout(program, &component_counts)?;
+    let selector_domains = lower_selector_domains(program)?;
+
+    let (momentum_ids, momentum_forms, momentum_terms) =
+        intern_momentum_forms(program, external_source_count)?;
+    let (mut exact_factors, mut exact_factor_ids) = intern_exact_factors(program)?;
+    let mut closure_factor_blocks = BTreeMap::new();
+
+    let mut source_drafts = Vec::new();
+    let mut runtime_sources = LoweredRuntimeSources {
+        choices_by_source: vec![Vec::new(); external_source_count as usize],
+        ..LoweredRuntimeSources::default()
+    };
+    for current in program
+        .currents()
+        .iter()
+        .filter(|current| current.is_source())
+    {
+        let assignment = arena_assignment(&arena, current.id())?;
+        let source_slot = only_source_slot(current)?;
+        match (program.strategy(), current.key().source_binding()) {
+            (
+                RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion,
+                CurrentSourceBinding::FixedTemplate(source_template_id),
+            ) => {
+                let source_factor = current.source_exact_factor().ok_or_else(|| {
+                    invalid(format!(
+                        "{} source current {} has no exact source factor",
+                        program.strategy(),
+                        current.id(),
+                    ))
+                })?;
+                let source = input
+                    .sources
+                    .get(*source_template_id as usize)
+                    .ok_or_else(|| {
+                        invalid(format!(
+                            "source current {} references absent source template {source_template_id}",
+                            current.id()
+                        ))
+                    })?;
+                let current_state =
+                    state_row(templates, current.key().current_state_template_id())?;
+                let source_state = state_row(templates, source.state_template_id)?;
+                if current_state.dimension != source_state.dimension {
+                    return Err(invalid(format!(
+                        "source current {} and source template {source_template_id} have different component dimensions",
+                        current.id()
+                    )));
+                }
+                let evaluator_binding_id = validated_evaluator_binding_id(
+                    templates,
+                    source.evaluator_binding_id,
+                    EvaluatorContractKind::Source,
+                    "source",
+                )?;
+                let executor_id = direct_executors
+                    .resolve_evaluator(DirectExecutorRole::Source, evaluator_binding_id)?;
+                source_drafts.push(SourceDraft {
+                    stage: current_stage(current)?,
+                    executor_id,
+                    semantic_current_id: current.id(),
+                    row: DirectSourceRow {
+                        source_slot,
+                        destination_component_base: assignment.component_base,
+                        momentum_form_id: momentum_id(&momentum_ids, current.key().momentum())?,
+                        source_template_or_dispatch_domain: *source_template_id,
+                        spin_state_class: current.key().spin_state_class(),
+                        exact_factor_id: exact_factor_id(&exact_factor_ids, source_factor)?,
+                        selector_domain_id: selector_domains.current_domain_ids
+                            [current.id() as usize],
+                    },
+                });
+            }
+            (
+                RecurrenceStrategy::AllFlowUnion,
+                CurrentSourceBinding::RuntimeDispatch {
+                    domain,
+                    source_template_ids,
+                    variant_bindings,
+                },
+            ) => {
+                lower_union_source(
+                    current,
+                    source_slot,
+                    *domain,
+                    source_template_ids,
+                    variant_bindings,
+                    templates,
+                    direct_executors,
+                    &arena,
+                    &momentum_ids,
+                    &mut exact_factors,
+                    &mut exact_factor_ids,
+                    &mut source_drafts,
+                    &mut runtime_sources,
+                )?;
+            }
+            (RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion, _) => {
+                return Err(invalid(format!(
+                    "{} source current {} does not use one fixed source template",
+                    program.strategy(),
+                    current.id(),
+                )));
+            }
+            (RecurrenceStrategy::AllFlowUnion, _) => {
+                return Err(invalid(format!(
+                    "all-flow-union source current {} does not use runtime dispatch",
+                    current.id()
+                )));
+            }
+        }
+    }
+
+    let mut contribution_drafts = Vec::with_capacity(program.contributions().len());
+    for contribution in program.contributions() {
+        validate_direct_arity(
+            "contribution",
+            contribution.id(),
+            contribution.parent_current_ids().len(),
+        )?;
+        let result = program
+            .currents()
+            .get(contribution.result_current_id() as usize)
+            .ok_or_else(|| invalid("contribution result current is absent"))?;
+        let transition_id = contribution.key().transition_template_id();
+        let transition = input
+            .transitions
+            .get(transition_id as usize)
+            .ok_or_else(|| {
+                invalid(format!(
+                    "contribution {} references absent transition template {transition_id}",
+                    contribution.id()
+                ))
+            })?;
+        let expected_parent_states = template_u32_sequence(
+            templates,
+            transition.input_state_sequence_id,
+            "transition input states",
+        )?;
+        let canonical_input_order = template_u32_sequence(
+            templates,
+            transition.canonical_input_order_sequence_id,
+            "transition canonical input order",
+        )?;
+        let actual_parent_states =
+            parent_state_template_ids(program, contribution.parent_current_ids())?;
+        if !parent_state_contract_matches(
+            expected_parent_states,
+            canonical_input_order,
+            transition.input_exchange_factor_id != MISSING_U32,
+            &actual_parent_states,
+        )? || contribution.key().parent_state_template_ids() != actual_parent_states
+        {
+            return Err(invalid(format!(
+                "contribution {} parent-state contract does not match transition {transition_id}",
+                contribution.id()
+            )));
+        }
+        if transition.result_state_template_id != result.key().current_state_template_id()
+            || transition.result_state_template_id != contribution.key().result_state_template_id()
+        {
+            return Err(invalid(format!(
+                "contribution {} result-state contract does not match transition {transition_id}",
+                contribution.id()
+            )));
+        }
+        if transition.quantum_flow_template_id != contribution.key().quantum_flow_witness_id() {
+            return Err(invalid(format!(
+                "contribution {} quantum-flow witness does not match transition {transition_id}",
+                contribution.id()
+            )));
+        }
+        validate_coupling_digest(templates, contribution)?;
+        if transition.output_projection_string_id != contribution.key().output_projection_id() {
+            return Err(invalid(format!(
+                "contribution {} output projection does not match transition {transition_id}",
+                contribution.id()
+            )));
+        }
+        let color_witness = contribution.key().color_witness_term_id();
+        if color_witness.color_contraction_template_id() != transition.color_contraction_template_id
+        {
+            return Err(invalid(format!(
+                "contribution {} color witness does not belong to transition {transition_id}",
+                contribution.id()
+            )));
+        }
+        let contraction = input
+            .color_contractions
+            .get(transition.color_contraction_template_id as usize)
+            .ok_or_else(|| invalid("transition color contraction is absent"))?;
+        if u64::from(color_witness.witness_ordinal()) >= contraction.witness_count {
+            return Err(invalid(format!(
+                "contribution {} color-witness ordinal is out of bounds",
+                contribution.id()
+            )));
+        }
+        validate_parent_momentum_contract(program, contribution)?;
+        let parents = direct_parents(
+            program,
+            contribution.parent_current_ids(),
+            &arena,
+            &momentum_ids,
+        )?;
+        let evaluator_binding_id = validated_evaluator_binding_id(
+            templates,
+            transition.evaluator_binding_id,
+            EvaluatorContractKind::Vertex,
+            "contribution",
+        )?;
+        let (executor_id, parent_permutation) =
+            direct_executors.resolve_contribution(evaluator_binding_id)?;
+        let parents = parents.permuted(parent_permutation)?;
+        let mut semantic_parent_current_ids = [DIRECT_NONE_U32; 2];
+        for (slot, parent_id) in contribution
+            .parent_current_ids()
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            semantic_parent_current_ids[slot] = parent_id;
+        }
+        if contribution.parent_current_ids().len() == 2 && parent_permutation == [1, 0] {
+            semantic_parent_current_ids.swap(0, 1);
+        }
+        contribution_drafts.push(ContributionDraft {
+            stage: current_stage(result)?,
+            executor_id,
+            semantic_contribution_id: contribution.id(),
+            semantic_result_current_id: result.id(),
+            semantic_parent_current_ids,
+            semantic_parent_count: u8::try_from(contribution.parent_current_ids().len())
+                .map_err(|_| invalid("contribution parent count exceeds u8"))?,
+            row: DirectContributionRow {
+                parent0_component_base: parents.parent0_component_base,
+                parent1_component_base_or_sentinel: parents.parent1_component_base_or_sentinel,
+                parent0_momentum_form_id: parents.parent0_momentum_form_id,
+                parent1_momentum_form_id_or_sentinel: parents.parent1_momentum_form_id_or_sentinel,
+                destination_component_base: arena_assignment(&arena, result.id())?.component_base,
+                exact_factor_id: exact_factor_id(&exact_factor_ids, contribution.exact_factor())?,
+                selector_domain_id: selector_domains.current_domain_ids[result.id() as usize],
+                flags: DIRECT_ROW_FLAGS_NONE,
+            },
+        });
+    }
+
+    let mut finalization_drafts = Vec::with_capacity(program.finalizations().len());
+    for finalization in program.finalizations() {
+        let current = program
+            .currents()
+            .get(finalization.current_id() as usize)
+            .ok_or_else(|| invalid("finalization current is absent"))?;
+        if finalization.propagator_template_id().is_none()
+            && finalization.exact_factor() == ExactComplexRational::ONE
+        {
+            continue;
+        }
+        let executor_id = if let Some(propagator_template_id) =
+            finalization.propagator_template_id()
+        {
+            let propagator = input
+                .propagators
+                .get(propagator_template_id as usize)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "finalization {} references absent propagator template {propagator_template_id}",
+                        finalization.id()
+                    ))
+                })?;
+            if propagator.applies_propagator == 0
+                || propagator.state_template_id != current.key().current_state_template_id()
+            {
+                return Err(invalid(format!(
+                    "finalization {} does not match an active propagator for current {}",
+                    finalization.id(),
+                    current.id()
+                )));
+            }
+            let evaluator_binding_id = validated_evaluator_binding_id(
+                templates,
+                propagator.evaluator_binding_id,
+                EvaluatorContractKind::Propagator,
+                "finalization",
+            )?;
+            direct_executors
+                .resolve_evaluator(DirectExecutorRole::Finalization, evaluator_binding_id)?
+        } else {
+            direct_executors.resolve_identity_finalizer()?
+        };
+        let assignment = arena_assignment(&arena, current.id())?;
+        finalization_drafts.push(FinalizationDraft {
+            stage: current_stage(current)?,
+            executor_id,
+            semantic_current_id: current.id(),
+            row: DirectFinalizationRow {
+                component_base: assignment.component_base,
+                component_count: u16::try_from(assignment.component_count).map_err(|_| {
+                    invalid(format!(
+                        "current {} component count exceeds u16",
+                        current.id()
+                    ))
+                })?,
+                momentum_form_id: momentum_id(&momentum_ids, current.key().momentum())?,
+                exact_factor_id: exact_factor_id(&exact_factor_ids, finalization.exact_factor())?,
+                selector_domain_id: selector_domains.current_domain_ids[current.id() as usize],
+                flags: DIRECT_ROW_FLAGS_NONE,
+            },
+        });
+    }
+
+    let closure_component_coefficients = templates.closure_component_coefficient_catalog()?;
+    let closure_stage = program
+        .currents()
+        .iter()
+        .map(current_stage)
+        .collect::<RusticolResult<Vec<_>>>()?
+        .into_iter()
+        .max()
+        .unwrap_or(0)
+        .checked_add(1)
+        .ok_or_else(|| invalid("closure stage exceeds u16"))?;
+    let mut closure_drafts = Vec::with_capacity(program.closure_terms().len());
+    for closure in program.closure_terms() {
+        validate_direct_arity("closure", closure.id(), closure.parent_current_ids().len())?;
+        let closure_template_id = closure.closure_template_id();
+        let template = input
+            .closures
+            .get(closure_template_id as usize)
+            .ok_or_else(|| {
+                invalid(format!(
+                    "closure {} references absent closure template {closure_template_id}",
+                    closure.id()
+                ))
+            })?;
+        let expected_parent_states = template_u32_sequence(
+            templates,
+            template.input_state_sequence_id,
+            "closure input states",
+        )?;
+        let canonical_input_order = template_u32_sequence(
+            templates,
+            template.canonical_input_order_sequence_id,
+            "closure canonical input order",
+        )?;
+        let actual_parent_states =
+            parent_state_template_ids(program, closure.parent_current_ids())?;
+        if !parent_state_contract_matches(
+            expected_parent_states,
+            canonical_input_order,
+            template.input_exchange_factor_id != MISSING_U32,
+            &actual_parent_states,
+        )? {
+            return Err(invalid(format!(
+                "closure {} parent-state contract does not match template {closure_template_id}",
+                closure.id()
+            )));
+        }
+        let eligible_flows = template_u32_sequence(
+            templates,
+            template.eligible_quantum_flow_sequence_id,
+            "closure eligible quantum flows",
+        )?;
+        match closure.quantum_flow_template_id() {
+            Some(flow_id) if eligible_flows.binary_search(&flow_id).is_ok() => {}
+            Some(flow_id) => {
+                return Err(invalid(format!(
+                    "closure {} quantum-flow witness {flow_id} is not eligible for template {closure_template_id}",
+                    closure.id()
+                )));
+            }
+            None if eligible_flows.is_empty() => {}
+            None => {
+                return Err(invalid(format!(
+                    "closure {} omits the quantum-flow witness required by template {closure_template_id}",
+                    closure.id()
+                )));
+            }
+        }
+        let evaluator_binding_id = validated_evaluator_binding_id(
+            templates,
+            template.evaluator_binding_id,
+            EvaluatorContractKind::Closure,
+            "closure",
+        )?;
+        let executor_id = direct_executors
+            .resolve_evaluator(DirectExecutorRole::Closure, evaluator_binding_id)?;
+        let parents = direct_parents(program, closure.parent_current_ids(), &arena, &momentum_ids)?;
+        let component_coefficients = closure_component_coefficients
+            .get(closure_template_id as usize)
+            .ok_or_else(|| {
+                invalid(format!(
+                    "closure {} references absent component coefficients for template {closure_template_id}",
+                    closure.id()
+                ))
+            })?;
+        let parent0_id = closure.parent_current_ids()[0] as usize;
+        let component_count = *component_counts
+            .get(parent0_id)
+            .ok_or_else(|| invalid("closure parent 0 component count is absent"))?;
+        if let Some(parent1_id) = closure.parent_current_ids().get(1) {
+            let parent1_component_count = *component_counts
+                .get(*parent1_id as usize)
+                .ok_or_else(|| invalid("closure parent 1 component count is absent"))?;
+            if parent1_component_count != component_count {
+                return Err(invalid(format!(
+                    "closure {} parent component counts differ",
+                    closure.id()
+                )));
+            }
+        }
+        if component_coefficients.len() != component_count as usize {
+            return Err(invalid(format!(
+                "closure {} has {} component coefficients for {component_count} current components",
+                closure.id(),
+                component_coefficients.len()
+            )));
+        }
+        let (component_factor_start, component_count) = intern_closure_factor_block(
+            component_coefficients,
+            &mut exact_factors,
+            &mut closure_factor_blocks,
+        )?;
+        closure_drafts.push(ClosureDraft {
+            stage: closure_stage,
+            executor_id,
+            semantic_closure_id: closure.id(),
+            amplitude_destination_id: closure.target_destination_id(),
+            row: DirectClosureRow {
+                parent0_component_base: parents.parent0_component_base,
+                parent1_component_base_or_sentinel: parents.parent1_component_base_or_sentinel,
+                parent0_momentum_form_id: parents.parent0_momentum_form_id,
+                parent1_momentum_form_id_or_sentinel: parents.parent1_momentum_form_id_or_sentinel,
+                amplitude_destination_id: closure.target_destination_id(),
+                exact_factor_id: exact_factor_id(&exact_factor_ids, closure.exact_factor())?,
+                component_factor_start,
+                component_count,
+                selector_domain_id: selector_domains.closure_domain_ids[closure.id() as usize],
+                flags: DIRECT_ROW_FLAGS_NONE,
+            },
+        });
+    }
+
+    let relation_report = apply_recurrence_relation_discovery(
+        program,
+        semantic_digest,
+        &arena,
+        &momentum_ids,
+        &selector_domains.current_domain_ids,
+        &mut contribution_drafts,
+        &finalization_drafts,
+        &mut exact_factors,
+        &mut exact_factor_ids,
+        relation_options,
+    )?;
+
+    let helicity_demands = topology_replay_helicity_demands(program, &contribution_drafts)?;
+    source_drafts.sort_by(|left, right| {
+        (left.stage, left.executor_id, left.row.selector_domain_id)
+            .cmp(&(right.stage, right.executor_id, right.row.selector_domain_id))
+            .then_with(|| {
+                helicity_demands
+                    .as_ref()
+                    .map_or(std::cmp::Ordering::Equal, |demands| {
+                        demands
+                            .current(left.semantic_current_id)
+                            .cmp(demands.current(right.semantic_current_id))
+                    })
+            })
+            .then_with(|| left.semantic_current_id.cmp(&right.semantic_current_id))
+    });
+    order_contributions_for_runtime_fanout(&mut contribution_drafts);
+    if let Some(demands) = &helicity_demands {
+        order_contributions_for_helicity_locality(&mut contribution_drafts, demands);
+    }
+    let mut initialized_currents = BTreeSet::new();
+    for draft in &mut contribution_drafts {
+        if initialized_currents.insert(draft.semantic_result_current_id) {
+            draft.row.flags |= DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION;
+        }
+    }
+    finalization_drafts.sort_by(|left, right| {
+        (left.stage, left.executor_id, left.row.selector_domain_id)
+            .cmp(&(right.stage, right.executor_id, right.row.selector_domain_id))
+            .then_with(|| {
+                helicity_demands
+                    .as_ref()
+                    .map_or(std::cmp::Ordering::Equal, |demands| {
+                        demands
+                            .current(left.semantic_current_id)
+                            .cmp(demands.current(right.semantic_current_id))
+                    })
+            })
+            .then_with(|| left.semantic_current_id.cmp(&right.semantic_current_id))
+    });
+    drop(helicity_demands);
+    // Destination ownership is primary. Each destination retains exactly one
+    // contiguous closure range; executor changes create additional row groups.
+    closure_drafts.sort_by_key(|draft| {
+        (
+            draft.amplitude_destination_id,
+            draft.stage,
+            draft.executor_id,
+            draft.semantic_closure_id,
+        )
+    });
+    let lowered_helicity_support = helicity_support
+        .map(|projection| {
+            lower_semantic_helicity_support(
+                program,
+                projection,
+                &contribution_drafts,
+                &finalization_drafts,
+                &closure_drafts,
+            )
+        })
+        .transpose()?;
+    let mut closure_row_by_term = vec![DIRECT_NONE_U32; program.closure_terms().len()];
+    let mut proof_group_by_term = vec![None; program.closure_terms().len()];
+    for group in program.closure_proofs().groups() {
+        if let Some(term_id) = group.emitted_runtime_closure_term_id() {
+            let slot = proof_group_by_term
+                .get_mut(term_id as usize)
+                .ok_or_else(|| invalid("closure proof group references an absent runtime term"))?;
+            *slot = Some(group.id());
+        }
+    }
+    let mut lowered_proof_groups = program.closure_proofs().groups().to_vec();
+    for (row_index, draft) in closure_drafts.iter_mut().enumerate() {
+        let row_id = u32_len("closure row", row_index)?;
+        let term_slot = closure_row_by_term
+            .get_mut(draft.semantic_closure_id as usize)
+            .ok_or_else(|| invalid("closure draft semantic term ID is out of bounds"))?;
+        if *term_slot != DIRECT_NONE_U32 {
+            return Err(invalid(format!(
+                "semantic closure term {} lowered more than once",
+                draft.semantic_closure_id
+            )));
+        }
+        *term_slot = row_id;
+        let group_id = proof_group_by_term
+            .get(draft.semantic_closure_id as usize)
+            .copied()
+            .flatten()
+            .ok_or_else(|| {
+                invalid(format!(
+                    "semantic closure term {} has no proof group",
+                    draft.semantic_closure_id
+                ))
+            })?;
+        let group = program
+            .closure_proofs()
+            .groups()
+            .get(group_id as usize)
+            .filter(|group| group.id() == group_id)
+            .ok_or_else(|| invalid("closure proof group ID is not dense"))?;
+        draft.row.flags = group.id();
+        let component_start = draft.row.component_factor_start as usize;
+        let component_end = component_start
+            .checked_add(draft.row.component_count as usize)
+            .ok_or_else(|| invalid("closure component-factor range exceeds usize"))?;
+        let component_digest = closure_component_factor_digest_v2(
+            exact_factors
+                .get(component_start..component_end)
+                .ok_or_else(|| invalid("closure component-factor range is out of bounds"))?,
+        )
+        .map_err(|error| invalid(error.message()))?;
+        let selector = selector_domains
+            .descriptors
+            .get(draft.row.selector_domain_id as usize)
+            .ok_or_else(|| invalid("lowered closure selector domain is absent"))?;
+        let selector_start = selector.word_start as usize;
+        let selector_end = selector_start
+            .checked_add(selector.word_count as usize)
+            .ok_or_else(|| invalid("lowered closure selector range overflows usize"))?;
+        let selector_digest = closure_selector_domain_digest_v2(
+            selector_domains
+                .words
+                .get(selector_start..selector_end)
+                .ok_or_else(|| invalid("lowered closure selector range is out of bounds"))?,
+        )
+        .map_err(|error| invalid(error.message()))?;
+        lowered_proof_groups[group.id() as usize] =
+            group.with_direct_closure_binding(Some(row_id), component_digest, selector_digest)?;
+    }
+    if closure_row_by_term.contains(&DIRECT_NONE_U32) {
+        return Err(invalid(
+            "not every semantic closure term was lowered to a direct row",
+        ));
+    }
+    let closure_proofs =
+        ClosureProofMetadataV2::new_with_three_line_certificates_and_candidate_domain(
+            program.closure_proofs().contributions().to_vec(),
+            lowered_proof_groups,
+            program.closure_proofs().reflection_certificates().to_vec(),
+            program
+                .closure_proofs()
+                .three_line_traversal_certificates()
+                .to_vec(),
+            program.closure_proofs().candidate_domain_certificate(),
+        )
+        .map_err(|error| invalid(error.message()))?;
+
+    let mut source_row_by_current = vec![DIRECT_NONE_U32; program.currents().len()];
+    for (row_index, draft) in source_drafts.iter().enumerate() {
+        source_row_by_current[draft.semantic_current_id as usize] =
+            u32_len("source row", row_index)?;
+    }
+    let mut finalization_row_by_current = vec![DIRECT_NONE_U32; program.currents().len()];
+    for (row_index, draft) in finalization_drafts.iter().enumerate() {
+        finalization_row_by_current[draft.semantic_current_id as usize] =
+            u32_len("finalization row", row_index)?;
+    }
+
+    let currents = program
+        .currents()
+        .iter()
+        .map(|current| {
+            let assignment = arena_assignment(&arena, current.id())?;
+            Ok(DirectCurrentDescriptor {
+                semantic_current_id: current.id(),
+                node_kind: match current.key().node_kind() {
+                    RecurrenceNodeKind::Source => DirectNodeKind::Source,
+                    RecurrenceNodeKind::Current => DirectNodeKind::Current,
+                },
+                state_template_id: current.key().current_state_template_id(),
+                component_base: assignment.component_base,
+                component_count: u16::try_from(assignment.component_count).map_err(|_| {
+                    invalid(format!(
+                        "current {} component count exceeds u16",
+                        current.id()
+                    ))
+                })?,
+                momentum_form_id: momentum_id(&momentum_ids, current.key().momentum())?,
+                stage: current_stage(current)?,
+                selector_domain_id: selector_domains.current_domain_ids[current.id() as usize],
+                first_use: direct_event(assignment.first_use, "arena first use")?,
+                last_use: direct_event(assignment.last_use, "arena last use")?,
+                source_row_or_sentinel: source_row_by_current[current.id() as usize],
+                finalization_row_or_sentinel: finalization_row_by_current[current.id() as usize],
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let mut row_groups = Vec::new();
+    append_row_groups(
+        source_drafts
+            .iter()
+            .map(|draft| (draft.stage, draft.executor_id)),
+        DirectExecutorRole::Source,
+        DirectDestinationOperation::Initialize,
+        &mut row_groups,
+    )?;
+    append_row_groups(
+        contribution_drafts
+            .iter()
+            .map(|draft| (draft.stage, draft.executor_id)),
+        DirectExecutorRole::Contribution,
+        DirectDestinationOperation::Add,
+        &mut row_groups,
+    )?;
+    append_row_groups(
+        finalization_drafts
+            .iter()
+            .map(|draft| (draft.stage, draft.executor_id)),
+        DirectExecutorRole::Finalization,
+        DirectDestinationOperation::FinalizeInPlace,
+        &mut row_groups,
+    )?;
+    append_row_groups(
+        closure_drafts
+            .iter()
+            .map(|draft| (draft.stage, draft.executor_id)),
+        DirectExecutorRole::Closure,
+        DirectDestinationOperation::ClosureAdd,
+        &mut row_groups,
+    )?;
+    row_groups.sort_by_key(|row_group| (row_group.stage, row_group.role, row_group.row_start));
+
+    let amplitude_destinations = lower_amplitude_destinations(
+        program,
+        &closure_drafts,
+        &selector_domains.destination_domain_ids,
+    )?;
+    let (
+        resolved_helicities,
+        source_state_assignments,
+        resolved_source_selections,
+        public_helicities,
+    ) = match program.strategy() {
+        RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion => {
+            let (descriptors, source_states, public_helicities) =
+                lower_resolved_helicities(program)?;
+            (descriptors, source_states, Vec::new(), public_helicities)
+        }
+        RecurrenceStrategy::AllFlowUnion => lower_union_resolved_helicities(
+            &runtime_sources.choices_by_source,
+            program.retained_helicity_count(),
+        )?,
+    };
+    let (replay_targets, source_permutations, replay_momentum_signs, replay_helicity_map) =
+        lower_replay_targets(
+            program,
+            &exact_factor_ids,
+            &selector_domains.sector_domain_ids,
+        )?;
+
+    let state_template_count = u32_len("state template", input.current_states.len())?;
+    let source_template_count = u32_len("source template", input.sources.len())?;
+    let direct_executor_count = direct_executors.direct_executor_count();
+    if state_template_count == 0 || source_template_count == 0 || direct_executor_count == 0 {
+        return Err(invalid(
+            "direct lowering requires nonempty state, source, and executor catalogs",
+        ));
+    }
+
+    let parts = DirectRecurrencePlanParts {
+        strategy: program.strategy(),
+        semantic_digest,
+        prepared_pack_digest,
+        direct_template_catalog_digest,
+        point_tile_size: runtime_options.point_tile_size,
+        workspace_mib: runtime_options.workspace_mib,
+        current_arena_components: arena.component_count(),
+        physical_sector_count: program.physical_sector_count(),
+        retained_helicity_count: program.retained_helicity_count(),
+        amplitude_destination_count: u32_len(
+            "amplitude destination",
+            program.amplitude_destinations().len(),
+        )?,
+        parameter_value_count: templates.summary().parameter_count,
+        external_source_count,
+        state_template_count,
+        source_template_count,
+        source_template_or_dispatch_count: match program.strategy() {
+            RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion => {
+                source_template_count
+            }
+            RecurrenceStrategy::AllFlowUnion => templates.summary().runtime_helicity_contract_count,
+        },
+        runtime_helicity_contract_count: match program.strategy() {
+            RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion => 0,
+            RecurrenceStrategy::AllFlowUnion => templates.summary().runtime_helicity_contract_count,
+        },
+        runtime_helicity_variant_count: match program.strategy() {
+            RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion => 0,
+            RecurrenceStrategy::AllFlowUnion => u32_len(
+                "runtime-helicity variant",
+                input.runtime_helicity_variants.len(),
+            )?,
+        },
+        direct_executor_count,
+        currents,
+        sources: source_drafts.iter().map(|draft| draft.row).collect(),
+        contributions: contribution_drafts.iter().map(|draft| draft.row).collect(),
+        finalizations: finalization_drafts.iter().map(|draft| draft.row).collect(),
+        closures: closure_drafts.iter().map(|draft| draft.row).collect(),
+        row_groups,
+        momentum_forms,
+        momentum_terms,
+        // Topology replay persists one dependency-closed domain per physical
+        // sector. Other strategies retain the historical universal domain.
+        selector_domains: selector_domains.descriptors,
+        selector_words: selector_domains.words,
+        replay_targets,
+        source_permutations,
+        replay_momentum_signs,
+        replay_helicity_map,
+        amplitude_destinations,
+        resolved_helicities,
+        source_state_assignments,
+        source_dispatch_variants: runtime_sources.variants,
+        source_embeddings: runtime_sources.embeddings,
+        source_projections: runtime_sources.projections,
+        resolved_source_selections,
+        public_helicities,
+        exact_factors,
+        closure_proofs,
+    };
+    Ok((parts, relation_report, lowered_helicity_support))
+}
+
+fn checked_projection_mask(
+    mask: &AllFlowHelicityMask,
+    expected_word_count: usize,
+    label: &str,
+) -> RusticolResult<Vec<u64>> {
+    if mask.words().len() != expected_word_count {
+        return Err(invalid(format!(
+            "{label} support mask has {} words, expected {expected_word_count}",
+            mask.words().len()
+        )));
+    }
+    Ok(mask.words().to_vec())
+}
+
+fn lower_semantic_helicity_support(
+    program: &RecurrenceProgram,
+    projection: &AllFlowHelicitySupportProjection,
+    contribution_drafts: &[ContributionDraft],
+    finalization_drafts: &[FinalizationDraft],
+    closure_drafts: &[ClosureDraft],
+) -> RusticolResult<LoweredHelicityRowSupport> {
+    if program.strategy() != RecurrenceStrategy::AllFlowUnion
+        || u64::from(projection.resolved_helicity_count()) != program.retained_helicity_count()
+    {
+        return Err(invalid(
+            "semantic helicity support does not match the all-flow program axis",
+        ));
+    }
+    let word_count = projection.resolved_helicity_count().div_ceil(64) as usize;
+    let mut contributions = Vec::with_capacity(contribution_drafts.len());
+    for draft in contribution_drafts {
+        let mask = if draft.row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0 {
+            let result = projection
+                .current_demand()
+                .get(draft.semantic_result_current_id as usize)
+                .ok_or_else(|| invalid("certified-reuse result current support is absent"))?;
+            let representative_id = draft.semantic_parent_current_ids[0];
+            if representative_id == DIRECT_NONE_U32 {
+                return Err(invalid(
+                    "certified-reuse contribution has no representative current",
+                ));
+            }
+            let representative = projection
+                .current_availability()
+                .get(representative_id as usize)
+                .ok_or_else(|| {
+                    invalid("certified-reuse representative current support is absent")
+                })?;
+            if result.words().len() != word_count || representative.words().len() != word_count {
+                return Err(invalid(
+                    "certified-reuse current support mask has the wrong width",
+                ));
+            }
+            result
+                .words()
+                .iter()
+                .zip(representative.words())
+                .map(|(result, representative)| result & representative)
+                .collect()
+        } else {
+            let mask = projection
+                .contribution_support()
+                .get(draft.semantic_contribution_id as usize)
+                .ok_or_else(|| invalid("semantic contribution support is absent"))?;
+            checked_projection_mask(mask, word_count, "contribution")?
+        };
+        contributions.push(mask);
+    }
+
+    let finalizations = finalization_drafts
+        .iter()
+        .map(|draft| {
+            let finalization_id = program
+                .currents()
+                .get(draft.semantic_current_id as usize)
+                .ok_or_else(|| invalid("finalization current is absent"))?
+                .finalization_id()
+                .ok_or_else(|| invalid("finalization current has no semantic finalization"))?;
+            let mask = projection
+                .finalization_support()
+                .get(finalization_id as usize)
+                .ok_or_else(|| invalid("semantic finalization support is absent"))?;
+            checked_projection_mask(mask, word_count, "finalization")
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let closures = closure_drafts
+        .iter()
+        .map(|draft| {
+            let mask = projection
+                .closure_support()
+                .get(draft.semantic_closure_id as usize)
+                .ok_or_else(|| invalid("semantic closure support is absent"))?;
+            checked_projection_mask(mask, word_count, "closure")
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    Ok(LoweredHelicityRowSupport {
+        resolved_helicity_count: projection.resolved_helicity_count(),
+        contributions,
+        finalizations,
+        closures,
+    })
+}
+
+#[derive(Default)]
+struct HelicitySupportDomainInterner {
+    ids: BTreeMap<Vec<u64>, u32>,
+    descriptors: Vec<DirectHelicitySupportDomainDescriptor>,
+    words: Vec<u64>,
+}
+
+impl HelicitySupportDomainInterner {
+    fn intern(&mut self, words: &[u64]) -> RusticolResult<u32> {
+        let retained = words
+            .iter()
+            .rposition(|word| *word != 0)
+            .map_or(0, |index| index + 1);
+        let canonical = &words[..retained];
+        if let Some(domain_id) = self.ids.get(canonical) {
+            return Ok(*domain_id);
+        }
+        let domain_id = u32_len("helicity support domain", self.descriptors.len())?;
+        let word_start = u64::try_from(self.words.len())
+            .map_err(|_| invalid("helicity support-word table exceeds u64"))?;
+        let word_count = u32_len("helicity support word", canonical.len())?;
+        self.words.extend_from_slice(canonical);
+        self.descriptors
+            .push(DirectHelicitySupportDomainDescriptor {
+                word_start,
+                word_count,
+            });
+        self.ids.insert(canonical.to_vec(), domain_id);
+        Ok(domain_id)
+    }
+}
+
+fn role_helicity_support(
+    support: &LoweredHelicityRowSupport,
+    role: DirectExecutorRole,
+) -> RusticolResult<&[Vec<u64>]> {
+    match role {
+        DirectExecutorRole::Contribution => Ok(&support.contributions),
+        DirectExecutorRole::Finalization => Ok(&support.finalizations),
+        DirectExecutorRole::Closure => Ok(&support.closures),
+        DirectExecutorRole::Source => Err(invalid(
+            "source rows must not be lowered into helicity-dispatch groups",
+        )),
+    }
+}
+
+fn lower_direct_helicity_dispatch(
+    plan: &DirectRecurrencePlan,
+    support: LoweredHelicityRowSupport,
+) -> RusticolResult<DirectHelicityDispatch> {
+    if plan.strategy() != RecurrenceStrategy::AllFlowUnion
+        || support.resolved_helicity_count as usize != plan.resolved_helicities().len()
+    {
+        return Err(invalid(
+            "helicity dispatch lowering requires one matching all-flow resolved axis",
+        ));
+    }
+    for (label, actual, expected) in [
+        (
+            "contribution",
+            support.contributions.len(),
+            plan.contributions().len(),
+        ),
+        (
+            "finalization",
+            support.finalizations.len(),
+            plan.finalizations().len(),
+        ),
+        ("closure", support.closures.len(), plan.closures().len()),
+    ] {
+        if actual != expected {
+            return Err(invalid(format!(
+                "helicity {label} support has {actual} rows, expected {expected}"
+            )));
+        }
+    }
+
+    let mut interner = HelicitySupportDomainInterner::default();
+    let mut row_groups = Vec::new();
+    let mut group_masks = Vec::<Vec<u64>>::new();
+    for base in plan
+        .row_groups()
+        .iter()
+        .filter(|group| group.role != DirectExecutorRole::Source)
+    {
+        let role_support = role_helicity_support(&support, base.role)?;
+        let start = usize::try_from(base.row_start)
+            .map_err(|_| invalid("base helicity row-group start exceeds usize"))?;
+        let end = start
+            .checked_add(base.row_count as usize)
+            .ok_or_else(|| invalid("base helicity row-group range overflows usize"))?;
+        let rows = role_support
+            .get(start..end)
+            .ok_or_else(|| invalid("base helicity row-group range is out of bounds"))?;
+        let mut run_start = 0usize;
+        while run_start < rows.len() {
+            let mut run_end = run_start + 1;
+            while run_end < rows.len() && rows[run_end] == rows[run_start] {
+                run_end += 1;
+            }
+            let support_domain_id = interner.intern(&rows[run_start])?;
+            row_groups.push(DirectHelicityRowGroupDescriptor {
+                stage: base.stage,
+                role: base.role,
+                direct_executor_id: base.direct_executor_id,
+                row_start: base
+                    .row_start
+                    .checked_add(run_start as u64)
+                    .ok_or_else(|| invalid("split helicity row-group start overflows u64"))?,
+                row_count: u32_len("split helicity row-group row", run_end - run_start)?,
+                support_domain_id,
+            });
+            group_masks.push(rows[run_start].clone());
+            run_start = run_end;
+        }
+    }
+
+    let resolved_count = support.resolved_helicity_count as usize;
+    let mut groups_by_helicity = vec![Vec::<u32>::new(); resolved_count];
+    for (group_id, words) in group_masks.iter().enumerate() {
+        for (word_index, mut word) in words.iter().copied().enumerate() {
+            while word != 0 {
+                let bit = word.trailing_zeros() as usize;
+                let helicity_id = word_index
+                    .checked_mul(u64::BITS as usize)
+                    .and_then(|base| base.checked_add(bit))
+                    .ok_or_else(|| invalid("helicity support bit index overflows usize"))?;
+                let groups = groups_by_helicity
+                    .get_mut(helicity_id)
+                    .ok_or_else(|| invalid("helicity support mask exceeds the resolved axis"))?;
+                groups.push(u32_len("split helicity row-group", group_id)?);
+                word &= word - 1;
+            }
+        }
+    }
+    let mut dispatches = Vec::with_capacity(resolved_count);
+    let mut dispatch_group_ids = Vec::new();
+    for (helicity_id, group_ids) in groups_by_helicity.into_iter().enumerate() {
+        let group_id_start = u64::try_from(dispatch_group_ids.len())
+            .map_err(|_| invalid("helicity dispatch CSR exceeds u64"))?;
+        let group_id_count = u32_len("helicity dispatch group ID", group_ids.len())?;
+        dispatch_group_ids.extend(group_ids);
+        dispatches.push(DirectHelicityDispatchDescriptor {
+            resolved_helicity_id: u32_len("resolved helicity", helicity_id)?,
+            group_id_start,
+            group_id_count,
+        });
+    }
+
+    DirectHelicityDispatch::new(DirectHelicityDispatchParts {
+        runtime_layout_digest: plan.runtime_layout_digest(),
+        source_row_count: plan.sources().len() as u64,
+        contribution_row_count: plan.contributions().len() as u64,
+        finalization_row_count: plan.finalizations().len() as u64,
+        closure_row_count: plan.closures().len() as u64,
+        amplitude_destination_count: plan.amplitude_destination_count(),
+        direct_executor_count: plan.direct_executor_count(),
+        resolved_helicity_count: support.resolved_helicity_count,
+        support_domains: interner.descriptors,
+        support_words: interner.words,
+        row_groups,
+        dispatches,
+        dispatch_group_ids,
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn apply_recurrence_relation_discovery(
+    program: &RecurrenceProgram,
+    semantic_digest: SemanticDigest,
+    arena: &DirectArenaLayout,
+    momentum_ids: &BTreeMap<CanonicalMomentumLinearForm, u32>,
+    current_selector_domain_ids: &[u32],
+    contribution_drafts: &mut Vec<ContributionDraft>,
+    finalization_drafts: &[FinalizationDraft],
+    exact_factors: &mut Vec<ExactComplexRational>,
+    exact_factor_ids: &mut BTreeMap<ExactComplexRational, u32>,
+    options: &RecurrenceRelationDiscoveryOptions,
+) -> RusticolResult<Option<RecurrenceRelationDiscoveryReport>> {
+    if options.mode == RecurrenceRelationDiscoveryMode::Off {
+        return Ok(None);
+    }
+    let contribution_count_before = contribution_drafts.len();
+    let mut contribution_by_current =
+        vec![Vec::<RelationTermInput>::new(); program.currents().len()];
+    for draft in contribution_drafts.iter() {
+        let parent_count = usize::from(draft.semantic_parent_count);
+        let parent_current_ids = draft
+            .semantic_parent_current_ids
+            .get(..parent_count)
+            .ok_or_else(|| invalid("relation draft parent range is invalid"))?
+            .to_vec();
+        let parent_momentum_form_ids = match parent_count {
+            1 => vec![draft.row.parent0_momentum_form_id],
+            2 => vec![
+                draft.row.parent0_momentum_form_id,
+                draft.row.parent1_momentum_form_id_or_sentinel,
+            ],
+            _ => {
+                return Err(invalid(format!(
+                    "relation draft {} has unsupported arity {parent_count}",
+                    draft.semantic_contribution_id
+                )));
+            }
+        };
+        contribution_by_current
+            .get_mut(draft.semantic_result_current_id as usize)
+            .ok_or_else(|| invalid("relation result current is absent"))?
+            .push(RelationTermInput {
+                executor_id: draft.executor_id,
+                parent_current_ids: parent_current_ids.into_boxed_slice(),
+                parent_momentum_form_ids: parent_momentum_form_ids.into_boxed_slice(),
+                exact_factor: *exact_factors
+                    .get(draft.row.exact_factor_id as usize)
+                    .ok_or_else(|| invalid("relation contribution factor is absent"))?,
+            });
+    }
+    let finalization_by_current = finalization_drafts
+        .iter()
+        .map(|draft| (draft.semantic_current_id, draft))
+        .collect::<BTreeMap<_, _>>();
+    let inputs = program
+        .currents()
+        .iter()
+        .map(|current| {
+            let assignment = arena_assignment(arena, current.id())?;
+            let finalization = finalization_by_current.get(&current.id()).copied();
+            Ok(RelationCurrentInput {
+                current_id: current.id(),
+                is_source: current.is_source(),
+                contract: RelationCurrentContract {
+                    stage: current_stage(current)?,
+                    state_template_id: current.key().current_state_template_id(),
+                    component_count: u16::try_from(assignment.component_count).map_err(|_| {
+                        invalid(format!(
+                            "relation current {} component count exceeds u16",
+                            current.id()
+                        ))
+                    })?,
+                    momentum_form_id: momentum_id(momentum_ids, current.key().momentum())?,
+                    selector_domain_id: *current_selector_domain_ids
+                        .get(current.id() as usize)
+                        .ok_or_else(|| invalid("relation selector domain is absent"))?,
+                    finalization_executor_id: finalization
+                        .map(|draft| draft.executor_id)
+                        .unwrap_or(DIRECT_NONE_U32),
+                    finalization_momentum_form_id: finalization
+                        .map(|draft| draft.row.momentum_form_id)
+                        .unwrap_or(DIRECT_NONE_U32),
+                    finalization_exact_factor: finalization
+                        .map(|draft| {
+                            exact_factors
+                                .get(draft.row.exact_factor_id as usize)
+                                .copied()
+                                .ok_or_else(|| invalid("relation finalization factor is absent"))
+                        })
+                        .transpose()?
+                        .unwrap_or(ExactComplexRational::ONE),
+                },
+                terms: std::mem::take(
+                    contribution_by_current
+                        .get_mut(current.id() as usize)
+                        .ok_or_else(|| invalid("relation current term vector is absent"))?,
+                )
+                .into_boxed_slice(),
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let (outcome, certificate_algorithm, tested_hypothesis_count, verification_rejected_count) =
+        if let Some(evidence) = options.numerical_evidence.as_ref() {
+            if evidence.schedule_semantic_digest != semantic_digest.to_string() {
+                return Err(invalid(
+                    "numerical evidence selects a different semantic schedule",
+                ));
+            }
+            let expected_candidate_count = evidence
+                .mappings
+                .len()
+                .checked_add(evidence.verification_rejected_count)
+                .ok_or_else(|| invalid("numerical evidence candidate count overflows usize"))?;
+            if evidence.numerical_candidate_count != expected_candidate_count
+                || evidence.tested_hypothesis_count < evidence.numerical_candidate_count
+                || evidence.precision_digits != options.precision_digits
+                || evidence.probe_count != options.probe_count
+                || evidence.verification_probe_count != options.verification_probe_count
+                || evidence.relative_tolerance.to_bits() != options.relative_tolerance.to_bits()
+                || evidence.absolute_tolerance.to_bits() != options.absolute_tolerance.to_bits()
+                || evidence.seed != options.seed
+            {
+                return Err(invalid(
+                    "numerical evidence probe contract or counters are inconsistent",
+                ));
+            }
+            for (label, value) in [
+                (
+                    "baseline runtime-layout digest",
+                    evidence.baseline_runtime_layout_digest.as_str(),
+                ),
+                (
+                    "source-semantics digest",
+                    evidence.source_semantics_sha256.as_str(),
+                ),
+                (
+                    "certificate-set digest",
+                    evidence.certificate_set_sha256.as_str(),
+                ),
+                (
+                    "runtime-parameter-schema digest",
+                    evidence.runtime_parameter_schema_sha256.as_str(),
+                ),
+                (
+                    "candidate observation-batch digest",
+                    evidence.candidate_observation_batch_sha256.as_str(),
+                ),
+                (
+                    "verification observation-batch digest",
+                    evidence.verification_observation_batch_sha256.as_str(),
+                ),
+                ("decision digest", evidence.decision_sha256.as_str()),
+                (
+                    "rejection decision digest",
+                    evidence.rejection_decision_sha256.as_str(),
+                ),
+            ] {
+                if !is_sha256(value) {
+                    return Err(invalid(format!(
+                        "numerical evidence {label} is not a lowercase SHA-256"
+                    )));
+                }
+            }
+            if evidence
+                .mappings
+                .windows(2)
+                .any(|pair| pair[0].current_id >= pair[1].current_id)
+            {
+                return Err(invalid(
+                    "numerical evidence mappings are not in increasing current order",
+                ));
+            }
+            let mut relations = Vec::with_capacity(evidence.mappings.len());
+            for mapping in &evidence.mappings {
+                let current = inputs
+                    .get(mapping.current_id as usize)
+                    .ok_or_else(|| invalid("numerical evidence current is absent"))?;
+                let representative = inputs
+                    .get(mapping.execution_representative_id as usize)
+                    .ok_or_else(|| {
+                        invalid("numerical evidence execution representative is absent")
+                    })?;
+                if current.current_id != mapping.current_id
+                    || current.is_source
+                    || representative.current_id != mapping.execution_representative_id
+                    || current.contract != representative.contract
+                    || mapping.current_dimension != current.contract.component_count
+                    || !is_sha256(&mapping.certificate_proof_sha256)
+                    || !is_sha256(&mapping.candidate_observations_sha256)
+                    || !is_sha256(&mapping.verification_observations_sha256)
+                {
+                    return Err(invalid(
+                        "numerical evidence violates its exact current contract",
+                    ));
+                }
+                let expected_factor = match mapping.relation_kind.as_str() {
+                    "equal" => ExactComplexRational::ONE,
+                    "opposite" => ExactComplexRational::ONE.checked_neg()?,
+                    "zero" => ExactComplexRational::ZERO,
+                    _ => {
+                        return Err(invalid("numerical evidence relation kind is unsupported"));
+                    }
+                };
+                if mapping.factor != expected_factor {
+                    return Err(invalid(
+                        "numerical evidence relation factor is not exact ±1/zero",
+                    ));
+                }
+                if mapping.relation_kind == "zero" {
+                    if mapping.representative_id.is_some()
+                        || mapping.execution_representative_id > mapping.current_id
+                    {
+                        return Err(invalid(
+                            "zero-current evidence has an invalid representative",
+                        ));
+                    }
+                } else if mapping.representative_id != Some(mapping.execution_representative_id)
+                    || mapping.execution_representative_id >= mapping.current_id
+                {
+                    return Err(invalid(
+                        "equal/opposite evidence is not topologically ordered",
+                    ));
+                }
+                relations.push(RecurrenceCurrentRelationCertificate {
+                    current_id: mapping.current_id,
+                    representative_id: mapping.execution_representative_id,
+                    factor: mapping.factor,
+                    current_expression_sha256: mapping.candidate_observations_sha256.clone(),
+                    representative_expression_sha256: mapping
+                        .verification_observations_sha256
+                        .clone(),
+                    proof_sha256: mapping.certificate_proof_sha256.clone(),
+                });
+            }
+            (
+                RecurrenceRelationDiscoveryOutcome {
+                    relations,
+                    numerical_candidate_count: evidence.numerical_candidate_count,
+                    uncertified_candidate_count: evidence.verification_rejected_count,
+                    rejected_hypothesis_count: evidence.rejected_hypothesis_count,
+                    rejected_candidates: Vec::new(),
+                    rejected_decision_sha256: evidence.rejection_decision_sha256.clone(),
+                    effective_projection_count: options
+                        .probe_count
+                        .checked_add(options.verification_probe_count)
+                        .ok_or_else(|| invalid("numerical probe count overflows u32"))?,
+                },
+                evidence.certificate_algorithm.clone(),
+                evidence.tested_hypothesis_count,
+                evidence.verification_rejected_count,
+            )
+        } else {
+            let outcome = discover_recurrence_current_relations(&inputs, options)?;
+            (outcome, relation_certificate_algorithm().to_owned(), 0, 0)
+        };
+
+    // Keep the complete independently verified evidence and report, including
+    // signed relations. Only their application is restricted: numerical
+    // opposite-current reuse is not enabled for contracted binary64 colour
+    // sums. Equal and zero currents do not require that signed rewrite, and
+    // must not be disabled merely because another certificate is opposite.
+    // Exact symbolic relations and diagnostic projections remain unchanged.
+    let restrict_numerical_sign = options.mode.applies_reuse()
+        && options.numerical_evidence.is_some()
+        && program.strategy() == RecurrenceStrategy::ContractedColorUnion;
+    let projected_relations = outcome.relations.iter().filter(|certificate| {
+        !restrict_numerical_sign
+            || certificate.factor == ExactComplexRational::ONE
+            || certificate.factor == ExactComplexRational::ZERO
+    });
+    let projected_relation_count = projected_relations.clone().count();
+    let applied_relation_count = if options.mode.applies_reuse() {
+        projected_relation_count
+    } else {
+        0
+    };
+    let removed_contribution_count = if applied_relation_count != 0 {
+        let relation_by_current = projected_relations
+            .clone()
+            .map(|certificate| (certificate.current_id, certificate))
+            .collect::<BTreeMap<_, _>>();
+        let original_len = contribution_drafts.len();
+        contribution_drafts
+            .retain(|draft| !relation_by_current.contains_key(&draft.semantic_result_current_id));
+        let removed_contribution_count = original_len - contribution_drafts.len();
+        for certificate in projected_relations.clone() {
+            let current = program
+                .currents()
+                .get(certificate.current_id as usize)
+                .ok_or_else(|| invalid("certified current is absent"))?;
+            let representative = program
+                .currents()
+                .get(certificate.representative_id as usize)
+                .ok_or_else(|| invalid("certified representative is absent"))?;
+            let current_assignment = arena_assignment(arena, current.id())?;
+            let representative_assignment = arena_assignment(arena, representative.id())?;
+            if current_stage(current)? != current_stage(representative)?
+                || current_assignment.component_count != representative_assignment.component_count
+            {
+                return Err(invalid(format!(
+                    "certificate {} -> {} violates scale-copy layout",
+                    current.id(),
+                    representative.id()
+                )));
+            }
+            let component_count = current_assignment.component_count;
+            contribution_drafts.push(ContributionDraft {
+                stage: current_stage(current)?,
+                executor_id: DIRECT_NONE_U32,
+                semantic_contribution_id: current.id(),
+                semantic_result_current_id: current.id(),
+                semantic_parent_current_ids: [representative.id(), DIRECT_NONE_U32],
+                semantic_parent_count: 1,
+                row: DirectContributionRow {
+                    parent0_component_base: representative_assignment.component_base,
+                    parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+                    // Certified-reuse rows interpret this field as the
+                    // component count; no momentum plane is read.
+                    parent0_momentum_form_id: component_count,
+                    parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+                    destination_component_base: current_assignment.component_base,
+                    exact_factor_id: intern_direct_factor(
+                        certificate.factor,
+                        exact_factors,
+                        exact_factor_ids,
+                    )?,
+                    selector_domain_id: *current_selector_domain_ids
+                        .get(current.id() as usize)
+                        .ok_or_else(|| invalid("certified selector domain is absent"))?,
+                    flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+                        | DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE,
+                },
+            });
+        }
+        removed_contribution_count
+    } else {
+        projected_relations
+            .clone()
+            .try_fold(0usize, |total, certificate| {
+                let count = usize::try_from(
+                    program
+                        .currents()
+                        .get(certificate.current_id as usize)
+                        .ok_or_else(|| invalid("diagnostic relation current is absent"))?
+                        .fan_in(),
+                )
+                .map_err(|_| invalid("diagnostic current fan-in exceeds usize"))?;
+                total
+                    .checked_add(count)
+                    .ok_or_else(|| invalid("diagnostic saved contribution count overflows"))
+            })?
+    };
+
+    let projected_contribution_count = contribution_count_before
+        .checked_sub(removed_contribution_count)
+        .and_then(|count| count.checked_add(projected_relation_count))
+        .ok_or_else(|| invalid("relation contribution count overflows usize"))?;
+    let projected_interaction_count = contribution_count_before
+        .checked_sub(removed_contribution_count)
+        .ok_or_else(|| invalid("relation interaction count underflows"))?;
+    let applied = applied_relation_count != 0;
+    Ok(Some(RecurrenceRelationDiscoveryReport {
+        requested_mode: options.mode,
+        state: if applied {
+            "exact-certified-applied"
+        } else {
+            "diagnostic-only"
+        },
+        strategy: program.strategy(),
+        color_accuracy: options.color_accuracy.clone(),
+        precision_digits: options.precision_digits,
+        probe_count: options.probe_count,
+        verification_probe_count: options.verification_probe_count,
+        seed: options.seed,
+        certificate_algorithm,
+        authenticated_certificate_set_sha256: options
+            .numerical_evidence
+            .as_ref()
+            .map(|evidence| evidence.certificate_set_sha256.clone()),
+        authenticated_runtime_parameter_schema_sha256: options
+            .numerical_evidence
+            .as_ref()
+            .map(|evidence| evidence.runtime_parameter_schema_sha256.clone()),
+        authenticated_candidate_observation_batch_sha256: options
+            .numerical_evidence
+            .as_ref()
+            .map(|evidence| evidence.candidate_observation_batch_sha256.clone()),
+        authenticated_verification_observation_batch_sha256: options
+            .numerical_evidence
+            .as_ref()
+            .map(|evidence| evidence.verification_observation_batch_sha256.clone()),
+        authenticated_decision_sha256: options
+            .numerical_evidence
+            .as_ref()
+            .map(|evidence| evidence.decision_sha256.clone()),
+        rejected_decision_sha256: outcome.rejected_decision_sha256,
+        tested_hypothesis_count,
+        verification_rejected_count,
+        rejected_hypothesis_count: outcome.rejected_hypothesis_count,
+        effective_projection_count: outcome.effective_projection_count,
+        numerical_candidate_count: outcome.numerical_candidate_count,
+        uncertified_candidate_count: outcome.uncertified_candidate_count,
+        exact_certified_relation_count: outcome.relations.len(),
+        applied_relation_count,
+        current_count_before: program.currents().len(),
+        // Direct-plan-v2 requires dense semantic current IDs and exact
+        // closure-proof bindings. Scale-copy reuse removes interaction work
+        // while retaining those descriptors.
+        current_count_after: program.currents().len(),
+        contribution_count_before,
+        contribution_count_after: projected_contribution_count,
+        interaction_evaluation_count_before: contribution_count_before,
+        interaction_evaluation_count_after: projected_interaction_count,
+        scale_copy_row_count: applied_relation_count,
+        certificates: outcome.relations,
+        rejected_candidates: outcome.rejected_candidates,
+    }))
+}
+
+fn validate_lowering_boundary(
+    program: &RecurrenceProgram,
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct_executors: &PreparedDirectExecutorCatalog,
+    prepared_pack_digest: SemanticDigest,
+    direct_template_catalog_digest: SemanticDigest,
+    runtime_options: DirectRecurrenceRuntimeOptions,
+) -> RusticolResult<()> {
+    if runtime_options.point_tile_size == 0 || runtime_options.workspace_mib == 0 {
+        return Err(invalid(
+            "point tile size and workspace MiB must both be positive",
+        ));
+    }
+    let summary = templates.summary();
+    if prepared_pack_digest != summary.prepared_kernel_pack_digest {
+        return Err(invalid(format!(
+            "prepared-pack digest {prepared_pack_digest} does not match validated template pack {}",
+            summary.prepared_kernel_pack_digest
+        )));
+    }
+    if direct_template_catalog_digest != direct_executors.direct_template_catalog_digest() {
+        return Err(invalid(format!(
+            "direct-template catalog digest {direct_template_catalog_digest} does not match resolver catalog {}",
+            direct_executors.direct_template_catalog_digest()
+        )));
+    }
+    validate_prepared_parameter_catalog(templates)?;
+    validate_direct_executor_catalog(templates, direct_executors)?;
+    for current in program.currents() {
+        if current.key().catalog_digest() != summary.catalog_digest {
+            return Err(invalid(format!(
+                "current {} template-catalog digest does not match the validated catalog",
+                current.id()
+            )));
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn lower_union_source(
+    current: &RecurrenceCurrent,
+    source_slot: u32,
+    dispatch_domain: u32,
+    advertised_source_templates: &[u32],
+    variant_bindings: &[RuntimeSourceVariantBinding],
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct_executors: &PreparedDirectExecutorCatalog,
+    arena: &DirectArenaLayout,
+    momentum_ids: &BTreeMap<CanonicalMomentumLinearForm, u32>,
+    exact_factors: &mut Vec<ExactComplexRational>,
+    exact_factor_ids: &mut BTreeMap<ExactComplexRational, u32>,
+    source_drafts: &mut Vec<SourceDraft>,
+    runtime_sources: &mut LoweredRuntimeSources,
+) -> RusticolResult<()> {
+    if current.source_exact_factor().is_some() {
+        return Err(invalid(format!(
+            "all-flow-union source current {} must take its factor from runtime dispatch",
+            current.id()
+        )));
+    }
+    if variant_bindings.is_empty() {
+        return Err(invalid(format!(
+            "all-flow-union source current {} has no runtime variants",
+            current.id()
+        )));
+    }
+    let input = templates.input();
+    let contract = input
+        .runtime_helicity_contracts
+        .get(dispatch_domain as usize)
+        .ok_or_else(|| {
+            invalid(format!(
+                "source current {} references absent runtime-helicity contract {dispatch_domain}",
+                current.id()
+            ))
+        })?;
+    if contract.id != dispatch_domain {
+        return Err(invalid(format!(
+            "runtime-helicity contract {dispatch_domain} has noncanonical ID {}",
+            contract.id
+        )));
+    }
+    if contract.full_state_template_id != current.key().current_state_template_id() {
+        return Err(invalid(format!(
+            "source current {} state does not match runtime-helicity contract {dispatch_domain}",
+            current.id()
+        )));
+    }
+    let contract_variant_range = contract.variant_range.as_usize_range(
+        input.runtime_helicity_variants.len(),
+        "runtime-helicity contract variants",
+    )?;
+    let assignment = arena_assignment(arena, current.id())?;
+    let full_state = state_row(templates, contract.full_state_template_id)?;
+    if assignment.component_count != full_state.dimension {
+        return Err(invalid(format!(
+            "source current {} arena width does not match runtime-helicity full state",
+            current.id()
+        )));
+    }
+    let source_row_id = u32_len("source row", source_drafts.len())?;
+    let source_choices = runtime_sources
+        .choices_by_source
+        .get_mut(source_slot as usize)
+        .ok_or_else(|| invalid(format!("source slot {source_slot} is out of range")))?;
+    if !source_choices.is_empty() {
+        return Err(invalid(format!(
+            "all-flow-union source slot {source_slot} has more than one dispatch current"
+        )));
+    }
+    source_drafts.push(SourceDraft {
+        stage: current_stage(current)?,
+        executor_id: DIRECT_NONE_U32,
+        semantic_current_id: current.id(),
+        row: DirectSourceRow {
+            source_slot,
+            destination_component_base: assignment.component_base,
+            momentum_form_id: momentum_id(momentum_ids, current.key().momentum())?,
+            source_template_or_dispatch_domain: dispatch_domain,
+            spin_state_class: current.key().spin_state_class(),
+            exact_factor_id: intern_direct_factor(
+                ExactComplexRational::ONE,
+                exact_factors,
+                exact_factor_ids,
+            )?,
+            selector_domain_id: UNIVERSAL_SELECTOR_DOMAIN_ID,
+        },
+    });
+
+    for binding in variant_bindings.iter().copied() {
+        if advertised_source_templates
+            .binary_search(&binding.source_template_id())
+            .is_err()
+        {
+            return Err(invalid(format!(
+                "source current {} runtime variant {} is absent from its advertised source-template catalog",
+                current.id(),
+                binding.runtime_variant_id()
+            )));
+        }
+        let variant_index = usize::try_from(binding.runtime_variant_id())
+            .map_err(|_| invalid("runtime-helicity variant ID exceeds usize"))?;
+        if !contract_variant_range.contains(&variant_index) {
+            return Err(invalid(format!(
+                "source current {} runtime variant {} is outside contract {dispatch_domain}",
+                current.id(),
+                binding.runtime_variant_id()
+            )));
+        }
+        let variant = input
+            .runtime_helicity_variants
+            .get(variant_index)
+            .ok_or_else(|| invalid("runtime-helicity variant is absent"))?;
+        if variant.id != binding.runtime_variant_id()
+            || variant.contract_id != dispatch_domain
+            || variant.source_template_id != binding.source_template_id()
+            || variant.source_state_template_id != binding.source_state_template_id()
+        {
+            return Err(invalid(format!(
+                "source current {} runtime variant {} disagrees with its prepared contract",
+                current.id(),
+                binding.runtime_variant_id()
+            )));
+        }
+        let source = input
+            .sources
+            .get(binding.source_template_id() as usize)
+            .ok_or_else(|| invalid("runtime source template is absent"))?;
+        if source.id != binding.source_template_id()
+            || source.state_template_id != binding.source_state_template_id()
+        {
+            return Err(invalid(format!(
+                "runtime source template {} has a stale state contract",
+                binding.source_template_id()
+            )));
+        }
+        state_row(templates, binding.crossed_state_template_id())?;
+        let evaluator_binding_id = validated_evaluator_binding_id(
+            templates,
+            source.evaluator_binding_id,
+            EvaluatorContractKind::Source,
+            "runtime source",
+        )?;
+        let direct_executor_id =
+            direct_executors.resolve_evaluator(DirectExecutorRole::Source, evaluator_binding_id)?;
+
+        let effective_variant = effective_runtime_helicity_variant(
+            input,
+            contract_variant_range.clone(),
+            binding.crossed_state_template_id(),
+        )?;
+        let embedding_start = u64::try_from(runtime_sources.embeddings.len())
+            .map_err(|_| invalid("runtime source embeddings exceed u64"))?;
+        let embedding_range = effective_variant.embedding_range.as_usize_range(
+            input.runtime_helicity_embeddings.len(),
+            "runtime source embeddings",
+        )?;
+        for embedding in &input.runtime_helicity_embeddings[embedding_range] {
+            if embedding.variant_id != effective_variant.id {
+                return Err(invalid(format!(
+                    "runtime variant {} owns a stale embedding row",
+                    effective_variant.id
+                )));
+            }
+            let factor = template_exact_factor(templates, embedding.factor_id)?;
+            runtime_sources.embeddings.push(DirectSourceEmbeddingRow {
+                full_component: embedding.full_component,
+                source_component_or_sentinel: if embedding.source_component == MISSING_U32 {
+                    DIRECT_NONE_U32
+                } else {
+                    embedding.source_component
+                },
+                exact_factor_id: intern_direct_factor(factor, exact_factors, exact_factor_ids)?,
+            });
+        }
+
+        let projection_start = u64::try_from(runtime_sources.projections.len())
+            .map_err(|_| invalid("runtime source projections exceed u64"))?;
+        let projection_range = effective_variant.projection_range.as_usize_range(
+            input.runtime_helicity_projections.len(),
+            "runtime source projections",
+        )?;
+        for projection in &input.runtime_helicity_projections[projection_range] {
+            if projection.variant_id != effective_variant.id {
+                return Err(invalid(format!(
+                    "runtime variant {} owns a stale projection row",
+                    effective_variant.id
+                )));
+            }
+            runtime_sources.projections.push(DirectSourceProjectionRow {
+                source_component: projection.source_component,
+                full_component: projection.full_component,
+            });
+        }
+
+        let dispatch_variant_id = u32_len(
+            "lowered source dispatch variant",
+            runtime_sources.variants.len(),
+        )?;
+        runtime_sources
+            .variants
+            .push(DirectSourceDispatchVariantDescriptor {
+                embedding_start,
+                projection_start,
+                source_row_id,
+                dispatch_domain_id: dispatch_domain,
+                runtime_variant_id: binding.runtime_variant_id(),
+                source_state_index: binding.source_state_index(),
+                source_template_id: binding.source_template_id(),
+                source_state_template_id: binding.source_state_template_id(),
+                crossed_state_template_id: binding.crossed_state_template_id(),
+                crossed_spin_state_class: binding.crossed_spin_state_class(),
+                direct_executor_id,
+                crossing_exact_factor_id: intern_direct_factor(
+                    binding.crossing_factor(),
+                    exact_factors,
+                    exact_factor_ids,
+                )?,
+                embedding_count: u32_len(
+                    "runtime source embedding",
+                    runtime_sources.embeddings.len()
+                        - usize::try_from(embedding_start)
+                            .map_err(|_| invalid("embedding start exceeds usize"))?,
+                )?,
+                projection_count: u32_len(
+                    "runtime source projection",
+                    runtime_sources.projections.len()
+                        - usize::try_from(projection_start)
+                            .map_err(|_| invalid("projection start exceeds usize"))?,
+                )?,
+            });
+        source_choices.push(RuntimeSourceChoice {
+            source_state_index: binding.source_state_index(),
+            public_helicity: binding.public_helicity(),
+            dispatch_variant_id,
+        });
+    }
+    source_choices.sort_by_key(|choice| choice.source_state_index);
+    if source_choices
+        .windows(2)
+        .any(|pair| pair[0].source_state_index == pair[1].source_state_index)
+    {
+        return Err(invalid(format!(
+            "all-flow-union source slot {source_slot} repeats a source-state variant"
+        )));
+    }
+    Ok(())
+}
+
+pub(super) fn effective_runtime_helicity_variant(
+    input: &OwnedRecurrenceTemplateInput,
+    contract_variant_range: std::ops::Range<usize>,
+    crossed_state_template_id: u32,
+) -> RusticolResult<RuntimeHelicityVariantRow> {
+    let candidates = input.runtime_helicity_variants[contract_variant_range]
+        .iter()
+        .copied()
+        .filter(|variant| variant.source_state_template_id == crossed_state_template_id)
+        .collect::<Vec<_>>();
+    let Some(representative) = candidates.first().copied() else {
+        return Err(invalid(format!(
+            "runtime-helicity contract has no embedding for crossed state {crossed_state_template_id}"
+        )));
+    };
+    for candidate in candidates.iter().copied().skip(1) {
+        if !runtime_helicity_variants_share_embedding(input, representative, candidate)? {
+            return Err(invalid(format!(
+                "runtime-helicity contract gives crossed state {crossed_state_template_id} incompatible embeddings"
+            )));
+        }
+    }
+    Ok(representative)
+}
+
+fn runtime_helicity_variants_share_embedding(
+    input: &OwnedRecurrenceTemplateInput,
+    left: RuntimeHelicityVariantRow,
+    right: RuntimeHelicityVariantRow,
+) -> RusticolResult<bool> {
+    let left_embeddings = left.embedding_range.as_usize_range(
+        input.runtime_helicity_embeddings.len(),
+        "left runtime source embeddings",
+    )?;
+    let right_embeddings = right.embedding_range.as_usize_range(
+        input.runtime_helicity_embeddings.len(),
+        "right runtime source embeddings",
+    )?;
+    let left_embeddings = &input.runtime_helicity_embeddings[left_embeddings];
+    let right_embeddings = &input.runtime_helicity_embeddings[right_embeddings];
+    if left_embeddings.len() != right_embeddings.len()
+        || !left_embeddings
+            .iter()
+            .zip(right_embeddings)
+            .all(|(left, right)| {
+                left.full_component == right.full_component
+                    && left.source_component == right.source_component
+                    && left.factor_id == right.factor_id
+            })
+    {
+        return Ok(false);
+    }
+
+    let left_projections = left.projection_range.as_usize_range(
+        input.runtime_helicity_projections.len(),
+        "left runtime source projections",
+    )?;
+    let right_projections = right.projection_range.as_usize_range(
+        input.runtime_helicity_projections.len(),
+        "right runtime source projections",
+    )?;
+    let left_projections = &input.runtime_helicity_projections[left_projections];
+    let right_projections = &input.runtime_helicity_projections[right_projections];
+    Ok(left_projections.len() == right_projections.len()
+        && left_projections
+            .iter()
+            .zip(right_projections)
+            .all(|(left, right)| {
+                left.source_component == right.source_component
+                    && left.full_component == right.full_component
+            }))
+}
+
+fn validate_prepared_parameter_catalog(
+    templates: &ValidatedRecurrenceTemplateInput,
+) -> RusticolResult<()> {
+    let input = templates.input();
+    // Prepared IDs address the model-wide parameter arena. A process may
+    // reference only a sparse subset of those slots, especially for UFO
+    // models, so only bounded uniqueness is required here.
+    let prepared_parameter_count = input.parameters.len();
+    let mut seen = vec![false; prepared_parameter_count];
+    for parameter in &input.parameters {
+        if parameter.prepared_parameter_id == MISSING_U32 {
+            continue;
+        }
+        let slot = usize::try_from(parameter.prepared_parameter_id)
+            .map_err(|_| invalid("prepared parameter slot exceeds usize"))?;
+        let present = seen.get_mut(slot).ok_or_else(|| {
+            invalid(format!(
+                "parameter template {} prepared runtime slot {} is out of bounds {prepared_parameter_count}",
+                parameter.id, parameter.prepared_parameter_id
+            ))
+        })?;
+        if std::mem::replace(present, true) {
+            return Err(invalid(format!(
+                "prepared runtime parameter slot {} is assigned more than once",
+                parameter.prepared_parameter_id
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_direct_executor_catalog(
+    templates: &ValidatedRecurrenceTemplateInput,
+    catalog: &PreparedDirectExecutorCatalog,
+) -> RusticolResult<()> {
+    let evaluators = &templates.input().evaluator_bindings;
+    for key in catalog.bindings.keys().copied() {
+        let PreparedDirectExecutorKey::Evaluator {
+            role,
+            evaluator_binding_id,
+        } = key
+        else {
+            continue;
+        };
+        let evaluator = evaluators
+            .get(evaluator_binding_id as usize)
+            .ok_or_else(|| {
+                invalid(format!(
+                    "prepared direct-template mapping references absent evaluator binding {evaluator_binding_id}"
+                ))
+            })?;
+        let expected_role = direct_role_for_contract(EvaluatorContractKind::try_from(
+            evaluator.contract_kind,
+        )?)?
+        .ok_or_else(|| {
+            invalid(format!(
+                "model-parameter evaluator binding {evaluator_binding_id} cannot be a direct row executor"
+            ))
+        })?;
+        if role != expected_role {
+            return Err(invalid(format!(
+                "prepared direct-template mapping for evaluator binding {evaluator_binding_id} has role {role:?}, expected {expected_role:?}"
+            )));
+        }
+    }
+    for evaluator in evaluators {
+        let Some(role) =
+            direct_role_for_contract(EvaluatorContractKind::try_from(evaluator.contract_kind)?)?
+        else {
+            continue;
+        };
+        catalog.resolve_evaluator(role, evaluator.id)?;
+    }
+    Ok(())
+}
+
+fn direct_role_for_contract(
+    contract: EvaluatorContractKind,
+) -> RusticolResult<Option<DirectExecutorRole>> {
+    Ok(match contract {
+        EvaluatorContractKind::Source => Some(DirectExecutorRole::Source),
+        EvaluatorContractKind::Vertex => Some(DirectExecutorRole::Contribution),
+        EvaluatorContractKind::Propagator => Some(DirectExecutorRole::Finalization),
+        EvaluatorContractKind::Closure => Some(DirectExecutorRole::Closure),
+        EvaluatorContractKind::ModelParameter => None,
+    })
+}
+
+fn component_counts(
+    program: &RecurrenceProgram,
+    templates: &ValidatedRecurrenceTemplateInput,
+) -> RusticolResult<Vec<u32>> {
+    program
+        .currents()
+        .iter()
+        .map(|current| {
+            let dimension =
+                state_row(templates, current.key().current_state_template_id())?.dimension;
+            u16::try_from(dimension).map_err(|_| {
+                invalid(format!(
+                    "current {} state dimension {dimension} exceeds the direct-row u16 component domain",
+                    current.id()
+                ))
+            })?;
+            Ok(dimension)
+        })
+        .collect()
+}
+
+fn state_row(
+    templates: &ValidatedRecurrenceTemplateInput,
+    state_template_id: u32,
+) -> RusticolResult<&super::template::CurrentStateRow> {
+    templates
+        .input()
+        .current_states
+        .get(state_template_id as usize)
+        .ok_or_else(|| {
+            invalid(format!(
+                "state template {state_template_id} is absent from the validated catalog"
+            ))
+        })
+}
+
+fn validated_evaluator_binding_id(
+    templates: &ValidatedRecurrenceTemplateInput,
+    evaluator_binding_id: u32,
+    expected_contract: EvaluatorContractKind,
+    role: &str,
+) -> RusticolResult<u32> {
+    if evaluator_binding_id == MISSING_U32 {
+        return Err(invalid(format!(
+            "{role} has no prepared evaluator binding to use as a provisional direct executor"
+        )));
+    }
+    let binding = templates
+        .input()
+        .evaluator_bindings
+        .get(evaluator_binding_id as usize)
+        .ok_or_else(|| {
+            invalid(format!(
+                "{role} references absent evaluator binding {evaluator_binding_id}"
+            ))
+        })?;
+    if binding.id != evaluator_binding_id
+        || EvaluatorContractKind::try_from(binding.contract_kind)? != expected_contract
+    {
+        return Err(invalid(format!(
+            "{role} evaluator binding {evaluator_binding_id} has the wrong direct role"
+        )));
+    }
+
+    Ok(evaluator_binding_id)
+}
+
+fn template_u32_sequence<'a>(
+    templates: &'a ValidatedRecurrenceTemplateInput,
+    sequence_id: u32,
+    label: &str,
+) -> RusticolResult<&'a [u32]> {
+    let input = templates.input();
+    let range = input
+        .u32_sequence_ranges
+        .get(sequence_id as usize)
+        .ok_or_else(|| invalid(format!("{label} sequence {sequence_id} is absent")))?;
+    if range.id != sequence_id {
+        return Err(invalid(format!(
+            "{label} sequence {sequence_id} has noncanonical ID {}",
+            range.id
+        )));
+    }
+    let range = range
+        .range
+        .as_usize_range(input.u32_sequence_values.len(), label)?;
+    Ok(&input.u32_sequence_values[range])
+}
+
+fn validate_coupling_digest(
+    templates: &ValidatedRecurrenceTemplateInput,
+    contribution: &super::RecurrenceContribution,
+) -> RusticolResult<()> {
+    let flow_id = contribution.key().quantum_flow_witness_id();
+    let flow = templates
+        .input()
+        .quantum_flows
+        .get(flow_id as usize)
+        .ok_or_else(|| {
+            invalid(format!(
+                "contribution {} references absent quantum-flow witness {flow_id}",
+                contribution.id()
+            ))
+        })?;
+    let digest = templates
+        .input()
+        .digest_catalog
+        .get(flow.semantic_digest_id as usize)
+        .ok_or_else(|| invalid("quantum-flow semantic digest is absent"))?;
+    let digest = SemanticDigest::new(digest.value)?;
+    if digest != contribution.key().runtime_coupling_binding_digest() {
+        return Err(invalid(format!(
+            "contribution {} runtime coupling digest does not match quantum flow {flow_id}",
+            contribution.id()
+        )));
+    }
+    Ok(())
+}
+
+fn parent_state_template_ids(
+    program: &RecurrenceProgram,
+    parent_ids: &[u32],
+) -> RusticolResult<Vec<u32>> {
+    parent_ids
+        .iter()
+        .map(|&parent_id| {
+            program
+                .currents()
+                .get(parent_id as usize)
+                .map(|parent| parent.key().current_state_template_id())
+                .ok_or_else(|| invalid(format!("parent current {parent_id} is absent")))
+        })
+        .collect()
+}
+
+fn parent_state_contract_matches(
+    concrete_states: &[u32],
+    canonical_input_order: &[u32],
+    exchange_is_proven: bool,
+    actual_states: &[u32],
+) -> RusticolResult<bool> {
+    let [left, right] = concrete_states else {
+        return Err(invalid("direct parent-state contract is not binary"));
+    };
+    let canonical = match canonical_input_order {
+        [0, 1] => [*left, *right],
+        [1, 0] => [*right, *left],
+        _ => {
+            return Err(invalid(
+                "direct canonical input order is not a binary permutation",
+            ));
+        }
+    };
+    Ok(actual_states == canonical
+        || (exchange_is_proven && actual_states == [canonical[1], canonical[0]]))
+}
+
+fn validate_parent_momentum_contract(
+    program: &RecurrenceProgram,
+    contribution: &super::RecurrenceContribution,
+) -> RusticolResult<()> {
+    if contribution.key().parent_momenta().len() != contribution.parent_current_ids().len() {
+        return Err(invalid(format!(
+            "contribution {} parent-momentum arity is inconsistent",
+            contribution.id()
+        )));
+    }
+    for (ordinal, (&parent_id, expected)) in contribution
+        .parent_current_ids()
+        .iter()
+        .zip(contribution.key().parent_momenta())
+        .enumerate()
+    {
+        let parent = program
+            .currents()
+            .get(parent_id as usize)
+            .ok_or_else(|| invalid(format!("parent current {parent_id} is absent")))?;
+        if parent.key().momentum() != expected {
+            return Err(invalid(format!(
+                "contribution {} parent {ordinal} momentum does not match current {parent_id}",
+                contribution.id()
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_direct_arity(label: &str, id: u32, arity: usize) -> RusticolResult<()> {
+    if !(1..=2).contains(&arity) {
+        return Err(invalid(format!(
+            "{label} {id} has unsupported parent arity {arity}; direct plan-v2 supports only one or two parents"
+        )));
+    }
+    Ok(())
+}
+
+fn direct_parents(
+    program: &RecurrenceProgram,
+    parent_ids: &[u32],
+    arena: &DirectArenaLayout,
+    momentum_ids: &BTreeMap<CanonicalMomentumLinearForm, u32>,
+) -> RusticolResult<DirectParents> {
+    validate_direct_arity("direct row", 0, parent_ids.len())?;
+    let parent0 = program
+        .currents()
+        .get(parent_ids[0] as usize)
+        .ok_or_else(|| invalid("direct parent 0 current is absent"))?;
+    let parent0_assignment = arena_assignment(arena, parent0.id())?;
+    let (parent1_component_base_or_sentinel, parent1_momentum_form_id_or_sentinel) =
+        if let Some(&parent1_id) = parent_ids.get(1) {
+            let parent1 = program
+                .currents()
+                .get(parent1_id as usize)
+                .ok_or_else(|| invalid("direct parent 1 current is absent"))?;
+            (
+                arena_assignment(arena, parent1.id())?.component_base,
+                momentum_id(momentum_ids, parent1.key().momentum())?,
+            )
+        } else {
+            (DIRECT_NONE_U32, DIRECT_NONE_U32)
+        };
+    Ok(DirectParents {
+        parent0_component_base: parent0_assignment.component_base,
+        parent1_component_base_or_sentinel,
+        parent0_momentum_form_id: momentum_id(momentum_ids, parent0.key().momentum())?,
+        parent1_momentum_form_id_or_sentinel,
+    })
+}
+
+fn external_source_count(program: &RecurrenceProgram) -> RusticolResult<u32> {
+    let slots = program
+        .currents()
+        .iter()
+        .filter(|current| current.is_source())
+        .map(only_source_slot)
+        .collect::<RusticolResult<BTreeSet<_>>>()?;
+    let count = slots
+        .iter()
+        .next_back()
+        .copied()
+        .and_then(|slot| slot.checked_add(1))
+        .ok_or_else(|| invalid("semantic program contains no source currents"))?;
+    if slots.iter().copied().ne(0..count) {
+        return Err(invalid(
+            "source currents do not cover a contiguous external-source domain",
+        ));
+    }
+    Ok(count)
+}
+
+fn only_source_slot(current: &RecurrenceCurrent) -> RusticolResult<u32> {
+    let [source_slot] = current.key().support_source_slots() else {
+        return Err(invalid(format!(
+            "source current {} does not cover exactly one source slot",
+            current.id()
+        )));
+    };
+    Ok(*source_slot)
+}
+
+fn current_stage(current: &RecurrenceCurrent) -> RusticolResult<u16> {
+    let stage = current
+        .key()
+        .support_source_slots()
+        .len()
+        .checked_sub(1)
+        .ok_or_else(|| invalid(format!("current {} has empty source support", current.id())))?;
+    u16::try_from(stage).map_err(|_| invalid(format!("current {} stage exceeds u16", current.id())))
+}
+
+fn direct_event(event: u64, label: &str) -> RusticolResult<u32> {
+    let event = event
+        .checked_sub(1)
+        .ok_or_else(|| invalid(format!("{label} precedes direct stage zero")))?;
+    u32::try_from(event).map_err(|_| invalid(format!("{label} exceeds u32")))
+}
+
+fn arena_assignment(
+    arena: &DirectArenaLayout,
+    current_id: u32,
+) -> RusticolResult<super::DirectArenaAssignment> {
+    arena.assignment(current_id).ok_or_else(|| {
+        invalid(format!(
+            "arena assignment for semantic current {current_id} is absent"
+        ))
+    })
+}
+
+type DirectMomentumTables = (
+    BTreeMap<CanonicalMomentumLinearForm, u32>,
+    Vec<DirectMomentumFormDescriptor>,
+    Vec<DirectMomentumTerm>,
+);
+
+fn intern_momentum_forms(
+    program: &RecurrenceProgram,
+    external_source_count: u32,
+) -> RusticolResult<DirectMomentumTables> {
+    let forms = program
+        .currents()
+        .iter()
+        .map(|current| current.key().momentum().clone())
+        .collect::<BTreeSet<_>>();
+    let mut ids = BTreeMap::new();
+    let mut descriptors = Vec::with_capacity(forms.len());
+    let mut terms = Vec::new();
+    for form in forms {
+        for term in form.terms() {
+            if term.source_slot >= external_source_count {
+                return Err(invalid(format!(
+                    "momentum form references source slot {} outside the source domain",
+                    term.source_slot
+                )));
+            }
+        }
+        let id = u32_len("momentum form", descriptors.len())?;
+        let term_start =
+            u64::try_from(terms.len()).map_err(|_| invalid("momentum term table exceeds u64"))?;
+        terms.extend(form.terms().iter().map(|term| DirectMomentumTerm {
+            source_slot: term.source_slot,
+            coefficient: term.coefficient,
+        }));
+        descriptors.push(DirectMomentumFormDescriptor {
+            term_start,
+            term_count: u32_len("momentum term", form.terms().len())?,
+        });
+        ids.insert(form, id);
+    }
+    Ok((ids, descriptors, terms))
+}
+
+fn momentum_id(
+    ids: &BTreeMap<CanonicalMomentumLinearForm, u32>,
+    form: &CanonicalMomentumLinearForm,
+) -> RusticolResult<u32> {
+    ids.get(form)
+        .copied()
+        .ok_or_else(|| invalid("semantic momentum form was not interned"))
+}
+
+fn intern_exact_factors(
+    program: &RecurrenceProgram,
+) -> RusticolResult<(
+    Vec<ExactComplexRational>,
+    BTreeMap<ExactComplexRational, u32>,
+)> {
+    let mut unique = BTreeSet::from([ExactComplexRational::ONE]);
+    unique.extend(
+        program
+            .currents()
+            .iter()
+            .filter_map(RecurrenceCurrent::source_exact_factor),
+    );
+    unique.extend(
+        program
+            .contributions()
+            .iter()
+            .map(super::RecurrenceContribution::exact_factor),
+    );
+    unique.extend(
+        program
+            .finalizations()
+            .iter()
+            .map(super::RecurrenceFinalization::exact_factor),
+    );
+    unique.extend(
+        program
+            .closure_terms()
+            .iter()
+            .map(super::RecurrenceClosureTerm::exact_factor),
+    );
+    unique.extend(
+        program
+            .replay_targets()
+            .iter()
+            .map(super::RecurrenceReplayTarget::amplitude_factor),
+    );
+
+    let mut factors = vec![ExactComplexRational::ONE];
+    factors.extend(
+        unique
+            .into_iter()
+            .filter(|factor| *factor != ExactComplexRational::ONE),
+    );
+    let ids = factors
+        .iter()
+        .copied()
+        .enumerate()
+        .map(|(id, factor)| Ok((factor, u32_len("exact factor", id)?)))
+        .collect::<RusticolResult<BTreeMap<_, _>>>()?;
+    Ok((factors, ids))
+}
+
+fn exact_factor_id(
+    ids: &BTreeMap<ExactComplexRational, u32>,
+    factor: ExactComplexRational,
+) -> RusticolResult<u32> {
+    ids.get(&factor)
+        .copied()
+        .ok_or_else(|| invalid("semantic exact factor was not interned"))
+}
+
+fn intern_direct_factor(
+    factor: ExactComplexRational,
+    factors: &mut Vec<ExactComplexRational>,
+    ids: &mut BTreeMap<ExactComplexRational, u32>,
+) -> RusticolResult<u32> {
+    if let Some(id) = ids.get(&factor).copied() {
+        return Ok(id);
+    }
+    let id = u32_len("exact factor", factors.len())?;
+    factors.push(factor);
+    ids.insert(factor, id);
+    Ok(id)
+}
+
+fn template_exact_factor(
+    templates: &ValidatedRecurrenceTemplateInput,
+    factor_id: u32,
+) -> RusticolResult<ExactComplexRational> {
+    let input = templates.input();
+    let row = input
+        .exact_factors
+        .get(factor_id as usize)
+        .ok_or_else(|| invalid(format!("template exact factor {factor_id} is absent")))?;
+    if row.id != factor_id {
+        return Err(invalid(format!(
+            "template exact factor {factor_id} has noncanonical ID {}",
+            row.id
+        )));
+    }
+    ExactComplexRational::parse_parts(
+        template_string(input, row.real_numerator_string_id, "exact real numerator")?,
+        template_string(
+            input,
+            row.real_denominator_string_id,
+            "exact real denominator",
+        )?,
+        template_string(
+            input,
+            row.imag_numerator_string_id,
+            "exact imaginary numerator",
+        )?,
+        template_string(
+            input,
+            row.imag_denominator_string_id,
+            "exact imaginary denominator",
+        )?,
+    )
+    .map_err(|error| {
+        invalid(format!(
+            "template exact factor {factor_id} is invalid: {error}"
+        ))
+    })
+}
+
+fn template_string<'a>(
+    input: &'a super::template::OwnedRecurrenceTemplateInput,
+    string_id: u32,
+    label: &str,
+) -> RusticolResult<&'a str> {
+    let range = input
+        .string_ranges
+        .get(string_id as usize)
+        .ok_or_else(|| invalid(format!("{label} string {string_id} is absent")))?;
+    let bytes = &input.string_bytes[range.as_usize_range(input.string_bytes.len(), label)?];
+    std::str::from_utf8(bytes)
+        .map_err(|error| invalid(format!("{label} string {string_id} is not UTF-8: {error}")))
+}
+
+fn intern_closure_factor_block(
+    coefficients: &[ExactComplexRational],
+    factors: &mut Vec<ExactComplexRational>,
+    blocks: &mut BTreeMap<Vec<ExactComplexRational>, (u32, u16)>,
+) -> RusticolResult<(u32, u16)> {
+    if let Some(block) = blocks.get(coefficients) {
+        return Ok(*block);
+    }
+    let start = u32_len("closure component-factor start", factors.len())?;
+    let count = u16::try_from(coefficients.len())
+        .map_err(|_| invalid("closure component count exceeds u16"))?;
+    if count == 0 {
+        return Err(invalid("closure component-factor block is empty"));
+    }
+    factors.extend_from_slice(coefficients);
+    let block = (start, count);
+    blocks.insert(coefficients.to_vec(), block);
+    Ok(block)
+}
+
+fn lower_amplitude_destinations(
+    program: &RecurrenceProgram,
+    closures: &[ClosureDraft],
+    destination_domain_ids: &[u32],
+) -> RusticolResult<Vec<DirectAmplitudeDestinationDescriptor>> {
+    let mut next_closure = 0usize;
+    let mut result = Vec::with_capacity(program.amplitude_destinations().len());
+    for destination in program.amplitude_destinations().iter().copied() {
+        let start = next_closure;
+        while next_closure < closures.len()
+            && closures[next_closure].amplitude_destination_id == destination.id()
+        {
+            next_closure += 1;
+        }
+        let count = next_closure - start;
+        if count as u64 != destination.closure_range().count {
+            return Err(invalid(format!(
+                "amplitude destination {} lowered {count} closure rows, expected {}",
+                destination.id(),
+                destination.closure_range().count
+            )));
+        }
+        result.push(DirectAmplitudeDestinationDescriptor {
+            closure_row_start: u64::try_from(start)
+                .map_err(|_| invalid("closure row start exceeds u64"))?,
+            id: destination.id(),
+            target_sector_id: destination.target_sector_id(),
+            target_helicity_id_or_sentinel: destination
+                .target_helicity_id()
+                .unwrap_or(DIRECT_NONE_U32),
+            closure_row_count: u32_len("amplitude-destination closure row", count)?,
+            selector_domain_id: *destination_domain_ids
+                .get(destination.id() as usize)
+                .ok_or_else(|| invalid("amplitude destination selector domain is absent"))?,
+        });
+    }
+    if next_closure != closures.len() {
+        return Err(invalid(
+            "closure rows are not fully owned by amplitude destinations",
+        ));
+    }
+    Ok(result)
+}
+
+type DirectReplayTables = (
+    Vec<DirectReplayTargetDescriptor>,
+    Vec<u32>,
+    Vec<i32>,
+    Vec<u32>,
+);
+
+fn lower_replay_targets(
+    program: &RecurrenceProgram,
+    exact_factor_ids: &BTreeMap<ExactComplexRational, u32>,
+    sector_domain_ids: &[Option<u32>],
+) -> RusticolResult<DirectReplayTables> {
+    if !program.strategy().uses_topology_replay_targets() {
+        if !program.replay_targets().is_empty() {
+            return Err(invalid(
+                "non-replay recurrence program unexpectedly carries replay targets",
+            ));
+        }
+        return Ok((Vec::new(), Vec::new(), Vec::new(), Vec::new()));
+    }
+
+    let mut source_template_by_state = BTreeMap::<(u32, u32), u32>::new();
+    let mut source_state_by_template = BTreeMap::<(u32, u32), u32>::new();
+    for current in program
+        .currents()
+        .iter()
+        .filter(|current| current.is_source())
+    {
+        let source_slot = only_source_slot(current)?;
+        let source_template_id = match current.key().source_binding() {
+            CurrentSourceBinding::FixedTemplate(source_template_id) => *source_template_id,
+            _ => {
+                return Err(invalid(format!(
+                    "topology-replay source current {} has no fixed source template",
+                    current.id()
+                )));
+            }
+        };
+        let ancestry = current.key().helicity_identity().local_source_states();
+        if ancestry.len() != 1 || ancestry[0].source_slot() != source_slot {
+            return Err(invalid(format!(
+                "topology-replay source current {} has invalid local source ancestry",
+                current.id()
+            )));
+        }
+        let state_index = ancestry[0].state_index();
+        if source_template_by_state
+            .insert((source_slot, state_index), source_template_id)
+            .is_some_and(|previous| previous != source_template_id)
+        {
+            return Err(invalid(format!(
+                "source slot {source_slot} state {state_index} has inconsistent source templates"
+            )));
+        }
+        if source_state_by_template
+            .insert((source_slot, source_template_id), state_index)
+            .is_some_and(|previous| previous != state_index)
+        {
+            return Err(invalid(format!(
+                "source slot {source_slot} template {source_template_id} is not a unique source state"
+            )));
+        }
+    }
+
+    let resolved_by_states = program
+        .resolved_helicities()
+        .iter()
+        .map(|helicity| (helicity.source_states().to_vec(), helicity.id()))
+        .collect::<BTreeMap<_, _>>();
+    if resolved_by_states.len() != program.resolved_helicities().len() {
+        return Err(invalid(
+            "topology-replay program repeats a resolved source-state assignment",
+        ));
+    }
+
+    let source_count = usize::try_from(external_source_count(program)?)
+        .map_err(|_| invalid("external source count exceeds usize"))?;
+    let mut source_permutations = Vec::new();
+    let mut replay_momentum_signs = Vec::new();
+    let mut replay_helicity_map = Vec::new();
+    let mut replay_targets = Vec::with_capacity(program.replay_targets().len());
+    for target in program.replay_targets() {
+        let source_permutation_start = u64::try_from(source_permutations.len())
+            .map_err(|_| invalid("source permutation table exceeds u64"))?;
+        source_permutations.extend_from_slice(target.source_slot_permutation());
+        replay_momentum_signs.extend_from_slice(target.source_momentum_signs());
+
+        let helicity_map_start = u64::try_from(replay_helicity_map.len())
+            .map_err(|_| invalid("replay helicity-map table exceeds u64"))?;
+        for helicity in program.resolved_helicities() {
+            let mut mapped = vec![None; source_count];
+            for assignment in helicity.source_states().iter().copied() {
+                let representative_slot = assignment.source_slot();
+                let source_template_id = source_template_by_state
+                    .get(&(representative_slot, assignment.state_index()))
+                    .copied()
+                    .ok_or_else(|| {
+                        invalid(format!(
+                            "resolved helicity {} source slot {representative_slot} state {} has no source template",
+                            helicity.id(),
+                            assignment.state_index()
+                        ))
+                    })?;
+                let target_slot = target
+                    .source_slot_permutation()
+                    .get(representative_slot as usize)
+                    .copied()
+                    .ok_or_else(|| invalid("replay source permutation is out of bounds"))?;
+                let target_state_index = source_state_by_template
+                    .get(&(target_slot, source_template_id))
+                    .copied()
+                    .ok_or_else(|| {
+                        invalid(format!(
+                            "replay target {} cannot transport source template {source_template_id} from slot {representative_slot} to slot {target_slot}",
+                            target.target_sector_id()
+                        ))
+                    })?;
+                let target_index = usize::try_from(target_slot)
+                    .map_err(|_| invalid("replay target source slot exceeds usize"))?;
+                if target_index >= source_count || mapped[target_index].is_some() {
+                    return Err(invalid(format!(
+                        "replay target {} source mapping is not bijective",
+                        target.target_sector_id()
+                    )));
+                }
+                mapped[target_index] =
+                    Some(SourceStateAssignment::new(target_slot, target_state_index));
+            }
+            let mapped = mapped
+                .into_iter()
+                .collect::<Option<Vec<_>>>()
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "replay target {} does not map every source state",
+                        target.target_sector_id()
+                    ))
+                })?;
+            let mapped_id = resolved_by_states.get(&mapped).copied().ok_or_else(|| {
+                invalid(format!(
+                    "replay target {} maps resolved helicity {} outside retained source-state coverage",
+                    target.target_sector_id(),
+                    helicity.id()
+                ))
+            })?;
+            replay_helicity_map.push(mapped_id);
+        }
+
+        replay_targets.push(DirectReplayTargetDescriptor {
+            public_flow_id: target.target_sector_id(),
+            representative_id: target.materialized_sector_id(),
+            source_permutation_start,
+            source_permutation_count: u32_len(
+                "replay source permutation",
+                target.source_slot_permutation().len(),
+            )?,
+            helicity_map_start,
+            helicity_map_count: u32_len(
+                "replay helicity map",
+                program.resolved_helicities().len(),
+            )?,
+            phase_exact_factor_id: exact_factor_id(exact_factor_ids, target.amplitude_factor())?,
+            // RecurrenceProgram stores one exact row per public target and has
+            // no separate orbit-multiplicity field.
+            multiplicity: 1,
+            selector_domain_id: *sector_domain_ids
+                .get(target.materialized_sector_id() as usize)
+                .and_then(Option::as_ref)
+                .ok_or_else(|| invalid("replay representative selector domain is absent"))?,
+        });
+    }
+    Ok((
+        replay_targets,
+        source_permutations,
+        replay_momentum_signs,
+        replay_helicity_map,
+    ))
+}
+
+fn lower_resolved_helicities(
+    program: &RecurrenceProgram,
+) -> RusticolResult<(
+    Vec<DirectResolvedHelicityDescriptor>,
+    Vec<DirectSourceStateAssignment>,
+    Vec<i32>,
+)> {
+    let mut descriptors = Vec::with_capacity(program.resolved_helicities().len());
+    let mut source_states = Vec::new();
+    let mut public_helicities = Vec::new();
+    for helicity in program.resolved_helicities() {
+        let source_state_start = u64::try_from(source_states.len())
+            .map_err(|_| invalid("resolved-helicity source states exceed u64"))?;
+        let public_helicity_start = u64::try_from(public_helicities.len())
+            .map_err(|_| invalid("resolved-helicity public values exceed u64"))?;
+        source_states.extend(helicity.source_states().iter().map(|assignment| {
+            DirectSourceStateAssignment {
+                source_slot: assignment.source_slot(),
+                state_index: assignment.state_index(),
+            }
+        }));
+        public_helicities.extend_from_slice(helicity.public_helicities());
+        descriptors.push(DirectResolvedHelicityDescriptor {
+            source_state_start,
+            source_selection_start: 0,
+            public_helicity_start,
+            id: helicity.id(),
+            source_state_count: u32_len(
+                "resolved-helicity source state",
+                helicity.source_states().len(),
+            )?,
+            source_selection_count: 0,
+            public_helicity_count: u32_len(
+                "resolved-helicity public value",
+                helicity.public_helicities().len(),
+            )?,
+            selector_domain_id: UNIVERSAL_SELECTOR_DOMAIN_ID,
+        });
+    }
+    Ok((descriptors, source_states, public_helicities))
+}
+
+type DirectUnionResolvedHelicityTables = (
+    Vec<DirectResolvedHelicityDescriptor>,
+    Vec<DirectSourceStateAssignment>,
+    Vec<DirectResolvedSourceSelection>,
+    Vec<i32>,
+);
+
+pub(super) fn lower_union_resolved_helicities(
+    choices_by_source: &[Vec<RuntimeSourceChoice>],
+    retained_helicity_count: u64,
+) -> RusticolResult<DirectUnionResolvedHelicityTables> {
+    if choices_by_source.is_empty() || choices_by_source.iter().any(Vec::is_empty) {
+        return Err(invalid(
+            "all-flow-union runtime source choices do not cover every external source",
+        ));
+    }
+    let cartesian_count = choices_by_source.iter().try_fold(1_u64, |count, choices| {
+        count
+            .checked_mul(
+                u64::try_from(choices.len())
+                    .map_err(|_| invalid("runtime source-choice count exceeds u64"))?,
+            )
+            .ok_or_else(|| invalid("resolved-helicity Cartesian product exceeds u64"))
+    })?;
+    if cartesian_count != retained_helicity_count {
+        return Err(invalid(format!(
+            "all-flow-union runtime source choices span {cartesian_count} helicities, expected {retained_helicity_count}"
+        )));
+    }
+    let descriptor_capacity = usize::try_from(cartesian_count)
+        .map_err(|_| invalid("resolved-helicity count exceeds usize"))?;
+    let mut descriptors = Vec::with_capacity(descriptor_capacity);
+    let mut source_states = Vec::with_capacity(
+        descriptor_capacity
+            .checked_mul(choices_by_source.len())
+            .ok_or_else(|| invalid("resolved source-state capacity exceeds usize"))?,
+    );
+    let mut source_selections = Vec::with_capacity(source_states.capacity());
+    let mut public_helicities = Vec::with_capacity(source_states.capacity());
+    let mut indices = vec![0usize; choices_by_source.len()];
+
+    for id in 0..descriptor_capacity {
+        let source_state_start = u64::try_from(source_states.len())
+            .map_err(|_| invalid("resolved source states exceed u64"))?;
+        let source_selection_start = u64::try_from(source_selections.len())
+            .map_err(|_| invalid("resolved source selections exceed u64"))?;
+        let public_helicity_start = u64::try_from(public_helicities.len())
+            .map_err(|_| invalid("resolved public helicities exceed u64"))?;
+        for (source_slot, (&choice_index, choices)) in
+            indices.iter().zip(choices_by_source).enumerate()
+        {
+            let choice = choices[choice_index];
+            let source_slot = u32_len("resolved source slot", source_slot)?;
+            source_states.push(DirectSourceStateAssignment {
+                source_slot,
+                state_index: choice.source_state_index,
+            });
+            source_selections.push(DirectResolvedSourceSelection {
+                source_slot,
+                dispatch_variant_id: choice.dispatch_variant_id,
+            });
+            public_helicities.push(choice.public_helicity);
+        }
+        let source_count = u32_len("resolved source", choices_by_source.len())?;
+        descriptors.push(DirectResolvedHelicityDescriptor {
+            source_state_start,
+            source_selection_start,
+            public_helicity_start,
+            id: u32_len("resolved helicity", id)?,
+            source_state_count: source_count,
+            source_selection_count: source_count,
+            public_helicity_count: source_count,
+            selector_domain_id: UNIVERSAL_SELECTOR_DOMAIN_ID,
+        });
+
+        for source_slot in (0..indices.len()).rev() {
+            indices[source_slot] += 1;
+            if indices[source_slot] < choices_by_source[source_slot].len() {
+                break;
+            }
+            indices[source_slot] = 0;
+        }
+    }
+    Ok((
+        descriptors,
+        source_states,
+        source_selections,
+        public_helicities,
+    ))
+}
+
+fn append_row_groups(
+    keys: impl IntoIterator<Item = (u16, u32)>,
+    role: DirectExecutorRole,
+    destination_operation: DirectDestinationOperation,
+    row_groups: &mut Vec<DirectRowGroupDescriptor>,
+) -> RusticolResult<()> {
+    let keys = keys.into_iter().collect::<Vec<_>>();
+    let mut start = 0usize;
+    while start < keys.len() {
+        let (stage, direct_executor_id) = keys[start];
+        let mut stop = start + 1;
+        while stop < keys.len() && keys[stop] == (stage, direct_executor_id) {
+            stop += 1;
+        }
+        row_groups.push(DirectRowGroupDescriptor {
+            stage,
+            role,
+            destination_operation,
+            direct_executor_id,
+            row_start: u64::try_from(start)
+                .map_err(|_| invalid("direct row_group row start exceeds u64"))?,
+            row_count: u32_len("direct row_group row", stop - start)?,
+        });
+        start = stop;
+    }
+    Ok(())
+}
+
+fn u32_len(label: &str, value: usize) -> RusticolResult<u32> {
+    u32::try_from(value).map_err(|_| invalid(format!("{label} count exceeds u32")))
+}
+
+#[cfg(test)]
+#[path = "direct_lowering_tests.rs"]
+mod tests;
+#[cfg(test)]
+pub(crate) use tests::validated_template as validated_template_fixture;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_lowering_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_lowering_tests.rs
new file mode 100644
index 0000000000..c37bfaac76
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_lowering_tests.rs
@@ -0,0 +1,2877 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::collections::BTreeMap;
+
+use super::*;
+use crate::recurrence::direct_lowering::{
+    DirectParents, RuntimeSourceChoice, effective_runtime_helicity_variant,
+    lower_union_resolved_helicities,
+};
+use crate::recurrence::direct_plan::{
+    DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE, DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+};
+use crate::recurrence::layout::RuntimeSourceVariantBinding;
+use crate::recurrence::template::{
+    CatalogHeaderRow, ClosureRow, ColorContractionRow, CurrentOrientation, CurrentStateRow,
+    DigestCatalogRow, EvaluatorBindingRow, EvaluatorCallableKind, EvaluatorContractKind,
+    ExactFactorRow, IndexedRangeRow, LCColorTransitionWitnessRow, MISSING_U32,
+    OwnedRecurrenceTemplateInput, ParticleStatistics, PropagatorRow, QuantumFlowRow,
+    RECURRENCE_TEMPLATE_CANONICALIZATION_ABI, RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI,
+    RECURRENCE_TEMPLATE_INPUT_ABI, RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION,
+    RuntimeHelicityContractRow, RuntimeHelicityEmbeddingRow, RuntimeHelicityProjectionRow,
+    RuntimeHelicityVariantRow, SourceRow, TransitionRow, ValidatedRecurrenceTemplateInput,
+};
+use crate::recurrence::{
+    CanonicalMomentumLinearForm, CheckedTableRange, ContributionKey, CurrentCoreKey,
+    CurrentHelicityIdentity, CurrentSourceBinding, DynamicLCColorState, DynamicLCColorStateId,
+    ExactRational, LCColorComponentOperation, LCColorComponentRole, LCColorSourceSeedOperation,
+    LCColorWitnessTermId, MomentumTerm, NUMERICAL_RELATION_CERTIFICATE_ALGORITHM,
+    RECURRENCE_TEMPLATE_ABI, RecurrenceAmplitudeDestination, RecurrenceClosureTerm,
+    RecurrenceContribution, RecurrenceCurrent, RecurrenceFinalization,
+    RecurrenceNumericalCurrentMapping, RecurrenceNumericalRelationEvidence, RecurrenceReplayTarget,
+    RecurrenceResolvedHelicity, RecurrenceStrategy, SourceStateAssignment,
+    load_recurrence_direct_plan_pacbin, write_recurrence_direct_plan_pacbin,
+};
+
+const CATALOG_DIGEST_SEED: u8 = 3;
+const QUANTUM_FLOW_DIGEST_SEED: u8 = 6;
+
+fn digest(seed: u8) -> SemanticDigest {
+    SemanticDigest::new([seed; 32]).unwrap()
+}
+
+fn rational(numerator: i128) -> ExactComplexRational {
+    ExactComplexRational::new(
+        ExactRational::new(numerator, 1).unwrap(),
+        ExactRational::ZERO,
+    )
+}
+
+fn encoded_strings(values: &[&str]) -> (Vec<CheckedTableRange>, Vec<u8>) {
+    let mut values = values.to_vec();
+    values.sort_unstable();
+    values.dedup();
+    let mut ranges = Vec::new();
+    let mut bytes = Vec::new();
+    for value in values {
+        ranges.push(CheckedTableRange::new(
+            bytes.len() as u64,
+            value.len() as u64,
+        ));
+        bytes.extend_from_slice(value.as_bytes());
+    }
+    (ranges, bytes)
+}
+
+fn string_id(strings: &[&str], value: &str) -> u32 {
+    let mut strings = strings.to_vec();
+    strings.sort_unstable();
+    strings.dedup();
+    strings
+        .iter()
+        .position(|candidate| *candidate == value)
+        .unwrap() as u32
+}
+
+fn indexed_u32_sequences(
+    sequences: &[Vec<u32>],
+) -> (Vec<IndexedRangeRow>, Vec<u32>, BTreeMap<Vec<u32>, u32>) {
+    let mut sequences = sequences.to_vec();
+    sequences.sort();
+    sequences.dedup();
+    let mut ranges = Vec::new();
+    let mut values = Vec::new();
+    let mut ids = BTreeMap::new();
+    for (id, sequence) in sequences.into_iter().enumerate() {
+        ranges.push(IndexedRangeRow {
+            id: id as u32,
+            range: CheckedTableRange::new(values.len() as u64, sequence.len() as u64),
+        });
+        values.extend_from_slice(&sequence);
+        ids.insert(sequence, id as u32);
+    }
+    (ranges, values, ids)
+}
+
+fn indexed_i32_sequences(sequences: &[Vec<i32>]) -> (Vec<IndexedRangeRow>, Vec<i32>) {
+    let mut sequences = sequences.to_vec();
+    sequences.sort();
+    sequences.dedup();
+    let mut ranges = Vec::new();
+    let mut values = Vec::new();
+    for (id, sequence) in sequences.into_iter().enumerate() {
+        ranges.push(IndexedRangeRow {
+            id: id as u32,
+            range: CheckedTableRange::new(values.len() as u64, sequence.len() as u64),
+        });
+        values.extend_from_slice(&sequence);
+    }
+    (ranges, values)
+}
+
+pub(crate) fn validated_template() -> ValidatedRecurrenceTemplateInput {
+    let strings = [
+        "0",
+        "1",
+        "a-source-resolver",
+        "any",
+        "b-vertex-resolver",
+        "basis",
+        "c-propagator-resolver",
+        "closure-a",
+        "closure-b",
+        "a-color-transition",
+        "b-color-close",
+        "component",
+        "compiler-certified-contact-orbit",
+        "constant-scalar-literal-singlet-self-conjugate-boson",
+        "constant-result",
+        "crossing",
+        "d-closure-a-resolver",
+        "e-closure-b-resolver",
+        "equivalence",
+        "input-layout",
+        "momentum",
+        "particle-static-result",
+        "projection",
+        "propagator",
+        "quantum-flow",
+        "rule",
+        "scalar",
+        "singlet-forest",
+        "source",
+        "species",
+        "state",
+        "transition",
+        RECURRENCE_TEMPLATE_ABI,
+        RECURRENCE_TEMPLATE_CANONICALIZATION_ABI,
+        RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI,
+        RECURRENCE_TEMPLATE_INPUT_ABI,
+    ];
+    let sid = |value| string_id(&strings, value);
+    let empty = vec![];
+    let state = vec![0];
+    let state_pair = vec![0, 0];
+    let order_pair = vec![0, 1];
+    let momentum_pair = vec![sid("momentum"), sid("momentum")];
+    let component = vec![sid("component")];
+    let input_layout = vec![sid("input-layout")];
+    let eligible_flow = vec![0];
+    let source_semantic = vec![sid("source")];
+    let transition_semantic = vec![sid("transition")];
+    let propagator_semantic = vec![sid("propagator")];
+    let closure_a_semantic = vec![sid("closure-a")];
+    let closure_b_semantic = vec![sid("closure-b")];
+    let expression_source = vec![16];
+    let expression_vertex = vec![17];
+    let expression_propagator = vec![19];
+    let expression_closure_a = vec![10];
+    let expression_closure_b = vec![11];
+    let contact_particles = vec![sid("scalar"); 4];
+    let contact_equivalence = vec![0, 0, 0, 0];
+    let contact_right_leg = vec![1];
+    let contact_missing_step = vec![2];
+    let contact_first_digest = vec![26];
+    let contact_two_digests = vec![26, 27];
+    let contact_second_digest = vec![27];
+    let sequences = vec![
+        empty.clone(),
+        state.clone(),
+        state_pair.clone(),
+        order_pair.clone(),
+        momentum_pair.clone(),
+        component.clone(),
+        input_layout.clone(),
+        eligible_flow.clone(),
+        source_semantic.clone(),
+        transition_semantic.clone(),
+        propagator_semantic.clone(),
+        closure_a_semantic.clone(),
+        closure_b_semantic.clone(),
+        expression_source.clone(),
+        expression_vertex.clone(),
+        expression_propagator.clone(),
+        expression_closure_a.clone(),
+        expression_closure_b.clone(),
+        contact_particles,
+        contact_equivalence,
+        contact_right_leg,
+        contact_missing_step,
+        contact_first_digest,
+        contact_two_digests,
+        contact_second_digest,
+    ];
+    let (u32_sequence_ranges, u32_sequence_values, sequence_ids) =
+        indexed_u32_sequences(&sequences);
+    let seq = |value: &Vec<u32>| *sequence_ids.get(value).unwrap();
+    let (i32_sequence_ranges, i32_sequence_values) =
+        indexed_i32_sequences(&[vec![0, 0], vec![1, 1], vec![0, 1, -1], vec![1, 0, -1]]);
+    let i32_seq = |value: &[i32]| {
+        i32_sequence_ranges
+            .iter()
+            .position(|range| {
+                let rows = range
+                    .range
+                    .as_usize_range(i32_sequence_values.len(), "test i32 sequence")
+                    .unwrap();
+                &i32_sequence_values[rows] == value
+            })
+            .unwrap() as u32
+    };
+    let spin_pair_sequence_id = i32_seq(&[0, 0]);
+    let singlet_pair_sequence_id = i32_seq(&[1, 1]);
+    let (string_ranges, string_bytes) = encoded_strings(&strings);
+    let digest_catalog = (1_u8..=25)
+        .map(|seed| DigestCatalogRow {
+            id: u32::from(seed - 1),
+            value: [seed; 32],
+        })
+        .collect::<Vec<_>>();
+    let digest_id = |seed: u8| u32::from(seed - 1);
+    let evaluator = |id: u32,
+                     resolver: &'static str,
+                     prepared_kernel_id: u32,
+                     contract_kind: EvaluatorContractKind,
+                     input_states: &Vec<u32>,
+                     output_state: u32,
+                     exact_expression: &Vec<u32>,
+                     semantic_template: &Vec<u32>,
+                     signature_seed: u8,
+                     semantic_seed: u8| EvaluatorBindingRow {
+        id,
+        resolver_key_string_id: sid(resolver),
+        prepared_kernel_id,
+        contract_kind: contract_kind as u8,
+        callable_signature_digest_id: digest_id(signature_seed),
+        input_state_sequence_id: seq(input_states),
+        output_state_template_id: output_state,
+        input_layout_sequence_id: seq(&input_layout),
+        output_layout_sequence_id: seq(&component),
+        exact_expression_digest_sequence_id: seq(exact_expression),
+        semantic_template_sequence_id: seq(semantic_template),
+        callable_kind: EvaluatorCallableKind::PreparedKernel as u8,
+        runtime_template_string_id: MISSING_U32,
+        semantic_digest_id: digest_id(semantic_seed),
+    };
+
+    OwnedRecurrenceTemplateInput {
+        input_abi: RECURRENCE_TEMPLATE_INPUT_ABI.to_owned(),
+        catalog_digest: digest(CATALOG_DIGEST_SEED),
+        compiled_model_digest: digest(1),
+        prepared_kernel_pack_digest: digest(2),
+        catalog_header: vec![CatalogHeaderRow {
+            schema_version: RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION,
+            abi_string_id: sid(RECURRENCE_TEMPLATE_ABI),
+            canonicalization_abi_string_id: sid(RECURRENCE_TEMPLATE_CANONICALIZATION_ABI),
+            exact_scalar_abi_string_id: sid(RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI),
+            compiled_model_digest_id: digest_id(1),
+            prepared_kernel_pack_digest_id: digest_id(2),
+            catalog_digest_id: digest_id(3),
+            parameter_count: 0,
+            current_state_count: 1,
+            source_count: 1,
+            quantum_flow_count: 1,
+            contact_orbit_certificate_count: 0,
+            contact_orbit_step_count: 0,
+            transition_count: 1,
+            propagator_count: 1,
+            closure_count: 2,
+            color_contraction_count: 2,
+            symmetry_proof_count: 0,
+            runtime_helicity_contract_count: 0,
+            evaluator_binding_count: 5,
+        }],
+        coupling_order_ranges: vec![IndexedRangeRow {
+            id: 0,
+            range: CheckedTableRange::new(0, 0),
+        }],
+        coupling_order_terms: vec![],
+        contact_orbit_certificates: vec![],
+        contact_orbit_steps: vec![],
+        current_states: vec![CurrentStateRow {
+            id: 0,
+            template_string_id: sid("state"),
+            particle_id: 1,
+            anti_particle_id: 1,
+            species_string_id: sid("species"),
+            orientation: CurrentOrientation::SelfConjugate as u8,
+            statistics: ParticleStatistics::Boson as u8,
+            color_representation: 1,
+            basis_string_id: sid("basis"),
+            tensor_ordering_sequence_id: seq(&component),
+            dimension: 1,
+            chirality: 0,
+            lc_color_shape_string_id: sid("singlet-forest"),
+            auxiliary_kind_string_id: MISSING_U32,
+            mass_parameter_id: MISSING_U32,
+            width_parameter_id: MISSING_U32,
+            semantic_digest_id: digest_id(4),
+        }],
+        digest_catalog,
+        evaluator_bindings: vec![
+            evaluator(
+                0,
+                "a-source-resolver",
+                0,
+                EvaluatorContractKind::Source,
+                &empty,
+                0,
+                &expression_source,
+                &source_semantic,
+                20,
+                13,
+            ),
+            evaluator(
+                1,
+                "b-vertex-resolver",
+                1,
+                EvaluatorContractKind::Vertex,
+                &state_pair,
+                0,
+                &expression_vertex,
+                &transition_semantic,
+                21,
+                14,
+            ),
+            evaluator(
+                2,
+                "c-propagator-resolver",
+                2,
+                EvaluatorContractKind::Propagator,
+                &state,
+                0,
+                &expression_propagator,
+                &propagator_semantic,
+                22,
+                15,
+            ),
+            evaluator(
+                3,
+                "d-closure-a-resolver",
+                3,
+                EvaluatorContractKind::Closure,
+                &state_pair,
+                MISSING_U32,
+                &expression_closure_a,
+                &closure_a_semantic,
+                23,
+                16,
+            ),
+            evaluator(
+                4,
+                "e-closure-b-resolver",
+                4,
+                EvaluatorContractKind::Closure,
+                &state_pair,
+                MISSING_U32,
+                &expression_closure_b,
+                &closure_b_semantic,
+                24,
+                17,
+            ),
+        ],
+        exact_factors: vec![ExactFactorRow {
+            id: 0,
+            real_numerator_string_id: sid("1"),
+            real_denominator_string_id: sid("1"),
+            imag_numerator_string_id: sid("0"),
+            imag_denominator_string_id: sid("1"),
+        }],
+        flavour_flow_ranges: vec![IndexedRangeRow {
+            id: 0,
+            range: CheckedTableRange::new(0, 1),
+        }],
+        flavour_flow_values: vec![1],
+        i32_sequence_ranges,
+        i32_sequence_values,
+        parameters: vec![],
+        propagators: vec![PropagatorRow {
+            id: 0,
+            template_string_id: sid("propagator"),
+            state_template_id: 0,
+            applies_propagator: 1,
+            evaluator_binding_id: 2,
+            numerator_expression_digest_id: digest_id(18),
+            denominator_expression_digest_id: digest_id(19),
+            mass_parameter_id: MISSING_U32,
+            width_parameter_id: MISSING_U32,
+            gauge_string_id: MISSING_U32,
+            linearity_proof_template_id: MISSING_U32,
+            semantic_digest_id: digest_id(10),
+        }],
+        quantum_flows: vec![QuantumFlowRow {
+            id: 0,
+            template_string_id: sid("quantum-flow"),
+            input_state_sequence_id: seq(&state_pair),
+            input_spin_sequence_id: spin_pair_sequence_id,
+            input_flavour_sequence_id: seq(&state_pair),
+            input_quantum_sequence_id: seq(&state_pair),
+            flavour_flow_operation_string_id: sid("constant-result"),
+            quantum_number_flow_operation_string_id: sid("particle-static-result"),
+            coupling_order_set_id: 0,
+            result_state_template_id: 0,
+            result_spin_state: 0,
+            result_flavour_flow_id: 0,
+            result_quantum_number_flow_id: 0,
+            exact_coupling_factor_id: 0,
+            predicate_digest_id: digest_id(17),
+            semantic_digest_id: digest_id(QUANTUM_FLOW_DIGEST_SEED),
+        }],
+        quantum_number_flow_ranges: vec![IndexedRangeRow {
+            id: 0,
+            range: CheckedTableRange::new(0, 0),
+        }],
+        quantum_number_flow_terms: vec![],
+        runtime_helicity_contracts: vec![],
+        runtime_helicity_variants: vec![],
+        runtime_helicity_embeddings: vec![],
+        runtime_helicity_projections: vec![],
+        sources: vec![SourceRow {
+            id: 0,
+            template_string_id: sid("source"),
+            state_template_id: 0,
+            crossing_string_id: sid("crossing"),
+            wavefunction_family_string_id: sid("scalar"),
+            helicity: 0,
+            spin_state: 50_000,
+            flavour_flow_id: 0,
+            quantum_number_flow_id: 0,
+            lc_color_seed_operation: LCColorSourceSeedOperation::Empty as u8,
+            lc_color_seed_shape_string_id: sid("singlet-forest"),
+            lc_color_seed_component_kind: u8::MAX,
+            lc_color_seed_component_role: LCColorComponentRole::None as u8,
+            lc_color_seed_proof_digest_id: digest_id(17),
+            lc_color_seed_provenance_sequence_id: seq(&empty),
+            wavefunction_expression_digest_id: digest_id(17),
+            evaluator_binding_id: 0,
+            mass_parameter_id: MISSING_U32,
+            width_parameter_id: MISSING_U32,
+            semantic_digest_id: digest_id(5),
+        }],
+        string_ranges,
+        string_bytes,
+        symmetry_proofs: vec![],
+        transitions: vec![TransitionRow {
+            id: 0,
+            template_string_id: sid("transition"),
+            input_state_sequence_id: seq(&state_pair),
+            result_state_template_id: 0,
+            quantum_flow_template_id: 0,
+            evaluator_binding_id: 1,
+            canonical_input_order_sequence_id: seq(&order_pair),
+            momentum_convention_sequence_id: seq(&momentum_pair),
+            coupling_parameter_sequence_id: seq(&empty),
+            coupling_order_set_id: 0,
+            color_contraction_template_id: 0,
+            binding_coupling_factor_id: 0,
+            exact_factor_id: 0,
+            output_factor_source: 0,
+            equivalence_class_string_id: sid("equivalence"),
+            input_exchange_factor_id: MISSING_U32,
+            output_projection_string_id: sid("projection"),
+            contact_orbit_step_sequence_id: 0,
+            contact_orbit_step_semantic_digest_sequence_id: 0,
+            semantic_digest_id: digest_id(9),
+        }],
+        closures: vec![
+            ClosureRow {
+                id: 0,
+                template_string_id: sid("closure-a"),
+                input_state_sequence_id: seq(&state_pair),
+                result_state_template_id: 0,
+                evaluator_binding_id: 3,
+                canonical_input_order_sequence_id: seq(&order_pair),
+                coupling_parameter_sequence_id: seq(&empty),
+                coupling_order_set_id: 0,
+                eligible_quantum_flow_sequence_id: seq(&eligible_flow),
+                color_contraction_template_id: 1,
+                binding_coupling_factor_id: 0,
+                exact_factor_id: 0,
+                output_factor_source: 0,
+                equivalence_class_string_id: sid("equivalence"),
+                input_exchange_factor_id: MISSING_U32,
+                projection_string_id: sid("projection"),
+                component_coefficient_sequence_id: seq(&eligible_flow),
+                chirality_relation_string_id: sid("any"),
+                metric_signature_string_id: MISSING_U32,
+                semantic_digest_id: digest_id(7),
+            },
+            ClosureRow {
+                id: 1,
+                template_string_id: sid("closure-b"),
+                input_state_sequence_id: seq(&state_pair),
+                result_state_template_id: 0,
+                evaluator_binding_id: 4,
+                canonical_input_order_sequence_id: seq(&order_pair),
+                coupling_parameter_sequence_id: seq(&empty),
+                coupling_order_set_id: 0,
+                eligible_quantum_flow_sequence_id: seq(&eligible_flow),
+                color_contraction_template_id: 1,
+                binding_coupling_factor_id: 0,
+                exact_factor_id: 0,
+                output_factor_source: 0,
+                equivalence_class_string_id: sid("equivalence"),
+                input_exchange_factor_id: MISSING_U32,
+                projection_string_id: sid("projection"),
+                component_coefficient_sequence_id: seq(&eligible_flow),
+                chirality_relation_string_id: sid("any"),
+                metric_signature_string_id: MISSING_U32,
+                semantic_digest_id: digest_id(8),
+            },
+        ],
+        color_contractions: vec![
+            ColorContractionRow {
+                id: 0,
+                template_string_id: sid("a-color-transition"),
+                rule_kind_string_id: sid("rule"),
+                input_representation_sequence_id: singlet_pair_sequence_id,
+                has_output_representation: 1,
+                output_representation: 1,
+                ordered_open_string_arity: 0,
+                exact_coefficient_factor_id: 0,
+                witness_start: 0,
+                witness_count: 1,
+                nc_term_start: 0,
+                nc_term_count: 0,
+                expression_digest_id: digest_id(17),
+                semantic_digest_id: digest_id(11),
+            },
+            ColorContractionRow {
+                id: 1,
+                template_string_id: sid("b-color-close"),
+                rule_kind_string_id: sid("rule"),
+                input_representation_sequence_id: singlet_pair_sequence_id,
+                has_output_representation: 0,
+                output_representation: 0,
+                ordered_open_string_arity: 0,
+                exact_coefficient_factor_id: 0,
+                witness_start: 1,
+                witness_count: 1,
+                nc_term_start: 0,
+                nc_term_count: 0,
+                expression_digest_id: digest_id(17),
+                semantic_digest_id: digest_id(12),
+            },
+        ],
+        lc_color_transition_witnesses: vec![
+            LCColorTransitionWitnessRow {
+                color_contraction_id: 0,
+                ordinal: 0,
+                left_shape_string_id: sid("singlet-forest"),
+                right_shape_string_id: sid("singlet-forest"),
+                input_permutation: 0,
+                reverse_parent_mask: 0,
+                component_operation: LCColorComponentOperation::Empty as u8,
+                result_component_kind: u8::MAX,
+                result_component_role: LCColorComponentRole::None as u8,
+                result_shape_string_id: sid("singlet-forest"),
+                exact_factor_id: 0,
+                proof_digest_id: digest_id(17),
+                input_port_pairing_sequence_id: seq(&empty),
+                result_port_binding_sequence_id: seq(&empty),
+                provenance_sequence_id: seq(&empty),
+            },
+            LCColorTransitionWitnessRow {
+                color_contraction_id: 1,
+                ordinal: 0,
+                left_shape_string_id: sid("singlet-forest"),
+                right_shape_string_id: sid("singlet-forest"),
+                input_permutation: 0,
+                reverse_parent_mask: 0,
+                component_operation: LCColorComponentOperation::Close as u8,
+                result_component_kind: u8::MAX,
+                result_component_role: LCColorComponentRole::None as u8,
+                result_shape_string_id: MISSING_U32,
+                exact_factor_id: 0,
+                proof_digest_id: digest_id(17),
+                input_port_pairing_sequence_id: seq(&empty),
+                result_port_binding_sequence_id: seq(&empty),
+                provenance_sequence_id: seq(&empty),
+            },
+        ],
+        color_nc_terms: vec![],
+        u32_sequence_ranges,
+        u32_sequence_values,
+    }
+    .validate()
+    .unwrap()
+}
+
+fn validated_union_template() -> ValidatedRecurrenceTemplateInput {
+    let mut input = validated_template().into_input();
+    input.catalog_header[0].runtime_helicity_contract_count = 1;
+    let source_resolver_string_id = input.evaluator_bindings[0].resolver_key_string_id;
+    let proof_string_id = input.transitions[0].equivalence_class_string_id;
+    let proof_digest_id = input.evaluator_bindings[0].callable_signature_digest_id;
+    input.runtime_helicity_contracts = vec![RuntimeHelicityContractRow {
+        id: 0,
+        template_string_id: source_resolver_string_id,
+        full_state_template_id: 0,
+        variant_range: CheckedTableRange::new(0, 1),
+        proof_algorithm_string_id: proof_string_id,
+        proof_digest_id,
+        semantic_digest_id: proof_digest_id,
+    }];
+    input.runtime_helicity_variants = vec![RuntimeHelicityVariantRow {
+        id: 0,
+        contract_id: 0,
+        source_template_id: 0,
+        source_state_template_id: 0,
+        embedding_range: CheckedTableRange::new(0, 1),
+        projection_range: CheckedTableRange::new(0, 1),
+        proof_digest_id,
+    }];
+    input.runtime_helicity_embeddings = vec![RuntimeHelicityEmbeddingRow {
+        variant_id: 0,
+        full_component: 0,
+        source_component: 0,
+        factor_id: 0,
+    }];
+    input.runtime_helicity_projections = vec![RuntimeHelicityProjectionRow {
+        variant_id: 0,
+        source_component: 0,
+        full_component: 0,
+    }];
+    input.validate().unwrap()
+}
+
+#[test]
+fn union_crossing_uses_the_effective_state_embedding() {
+    let mut input = validated_union_template().into_input();
+    input
+        .runtime_helicity_variants
+        .push(RuntimeHelicityVariantRow {
+            id: 1,
+            contract_id: 0,
+            source_template_id: 0,
+            source_state_template_id: 17,
+            embedding_range: CheckedTableRange::new(1, 1),
+            projection_range: CheckedTableRange::new(1, 1),
+            proof_digest_id: 0,
+        });
+    input
+        .runtime_helicity_embeddings
+        .push(RuntimeHelicityEmbeddingRow {
+            variant_id: 1,
+            full_component: 0,
+            source_component: MISSING_U32,
+            factor_id: 0,
+        });
+    input
+        .runtime_helicity_projections
+        .push(RuntimeHelicityProjectionRow {
+            variant_id: 1,
+            source_component: 0,
+            full_component: 1,
+        });
+
+    let effective = effective_runtime_helicity_variant(&input, 0..2, 17).unwrap();
+    assert_eq!(effective.id, 1);
+    assert_eq!(effective.source_state_template_id, 17);
+
+    input
+        .runtime_helicity_variants
+        .push(RuntimeHelicityVariantRow {
+            id: 2,
+            contract_id: 0,
+            source_template_id: 0,
+            source_state_template_id: 17,
+            embedding_range: CheckedTableRange::new(2, 1),
+            projection_range: CheckedTableRange::new(2, 1),
+            proof_digest_id: 1,
+        });
+    input
+        .runtime_helicity_embeddings
+        .push(RuntimeHelicityEmbeddingRow {
+            variant_id: 2,
+            full_component: 0,
+            source_component: MISSING_U32,
+            factor_id: 0,
+        });
+    input
+        .runtime_helicity_projections
+        .push(RuntimeHelicityProjectionRow {
+            variant_id: 2,
+            source_component: 0,
+            full_component: 1,
+        });
+    assert_eq!(
+        effective_runtime_helicity_variant(&input, 0..3, 17)
+            .unwrap()
+            .id,
+        1
+    );
+
+    input.runtime_helicity_embeddings[2].source_component = 0;
+    assert!(effective_runtime_helicity_variant(&input, 0..3, 17).is_err());
+}
+
+fn momentum(slots: &[u32]) -> CanonicalMomentumLinearForm {
+    CanonicalMomentumLinearForm::new(
+        slots
+            .iter()
+            .copied()
+            .map(|source_slot| MomentumTerm {
+                source_slot,
+                coefficient: 1,
+            })
+            .collect(),
+    )
+    .unwrap()
+}
+
+fn source_key(slot: u32) -> CurrentCoreKey {
+    CurrentCoreKey::new(
+        digest(CATALOG_DIGEST_SEED),
+        RecurrenceNodeKind::Source,
+        0,
+        DynamicLCColorStateId::from_interner(slot),
+        vec![slot],
+        momentum(&[slot]),
+        CurrentHelicityIdentity::topology_replay(50_000, vec![SourceStateAssignment::new(slot, 0)])
+            .unwrap(),
+        vec![1],
+        0,
+        vec![],
+        CurrentSourceBinding::FixedTemplate(0),
+        None,
+    )
+    .unwrap()
+}
+
+fn propagated_key(id: u32, slots: &[u32]) -> CurrentCoreKey {
+    CurrentCoreKey::new(
+        digest(CATALOG_DIGEST_SEED),
+        RecurrenceNodeKind::Current,
+        0,
+        DynamicLCColorStateId::from_interner(id),
+        slots.to_vec(),
+        momentum(slots),
+        CurrentHelicityIdentity::topology_replay(
+            0,
+            slots
+                .iter()
+                .copied()
+                .map(|slot| SourceStateAssignment::new(slot, 0))
+                .collect(),
+        )
+        .unwrap(),
+        vec![1],
+        0,
+        vec![],
+        CurrentSourceBinding::None,
+        Some(0),
+    )
+    .unwrap()
+}
+
+fn contribution_key(
+    parent_ids: &[u32],
+    parents: &[&CurrentCoreKey],
+    output_projection_id: u32,
+) -> ContributionKey {
+    ContributionKey::new(
+        0,
+        parent_ids.to_vec(),
+        vec![0; parents.len()],
+        parents
+            .iter()
+            .map(|parent| parent.momentum().clone())
+            .collect(),
+        0,
+        0,
+        LCColorWitnessTermId::new(0, 0),
+        digest(QUANTUM_FLOW_DIGEST_SEED),
+        output_projection_id,
+    )
+    .unwrap()
+}
+
+fn count_fixture_program(
+    templates: &ValidatedRecurrenceTemplateInput,
+    external_count: usize,
+    current_count: usize,
+    contribution_count: usize,
+    closure_count: usize,
+    physical_sector_count: u32,
+) -> RecurrenceProgram {
+    let source_keys = (0..external_count)
+        .map(|slot| source_key(slot as u32))
+        .collect::<Vec<_>>();
+    let mut propagated_specs = Vec::<(Vec<u32>, Vec<u32>)>::new();
+    if external_count == 4 {
+        propagated_specs.push((vec![0, 1], vec![0, 1]));
+        propagated_specs.push((vec![2, 3], vec![2, 3]));
+    } else {
+        propagated_specs.push((vec![0, 1], vec![0, 1]));
+        propagated_specs.push((vec![2, 3], vec![2, 3]));
+        propagated_specs.push((vec![2, 3, 4], vec![(external_count + 1) as u32, 4]));
+    }
+    while propagated_specs.len() < current_count - external_count {
+        let pair = if propagated_specs.len().is_multiple_of(2) {
+            vec![0, 1]
+        } else {
+            vec![2, 3]
+        };
+        propagated_specs.push((pair.clone(), pair));
+    }
+    let propagated_keys = propagated_specs
+        .iter()
+        .enumerate()
+        .map(|(index, (support, _))| propagated_key((external_count + index) as u32, support))
+        .collect::<Vec<_>>();
+
+    let output_projection_id = templates.input().transitions[0].output_projection_string_id;
+    let non_source_count = current_count - external_count;
+    let extra_contributions = contribution_count - non_source_count;
+    let mut contributions = Vec::with_capacity(contribution_count);
+    let mut currents = source_keys
+        .iter()
+        .enumerate()
+        .map(|(id, key)| {
+            RecurrenceCurrent::new(
+                id as u32,
+                key.clone(),
+                Some(ExactComplexRational::ONE),
+                CheckedTableRange::new(0, 0),
+                None,
+            )
+            .unwrap()
+        })
+        .collect::<Vec<_>>();
+    let all_keys = source_keys
+        .iter()
+        .chain(propagated_keys.iter())
+        .collect::<Vec<_>>();
+    let mut finalizations = Vec::with_capacity(non_source_count);
+    for (index, (support, parent_ids)) in propagated_specs.iter().enumerate() {
+        let current_id = (external_count + index) as u32;
+        let start = contributions.len() as u64;
+        let fan_in = 1 + usize::from(index < extra_contributions);
+        for _ in 0..fan_in {
+            let parent_keys = parent_ids
+                .iter()
+                .map(|id| all_keys[*id as usize])
+                .collect::<Vec<_>>();
+            contributions.push(
+                RecurrenceContribution::new(
+                    contributions.len() as u32,
+                    current_id,
+                    parent_ids.clone(),
+                    contribution_key(parent_ids, &parent_keys, output_projection_id),
+                    ExactComplexRational::ONE,
+                )
+                .unwrap(),
+            );
+        }
+        finalizations.push(
+            RecurrenceFinalization::new(
+                index as u32,
+                current_id,
+                Some(0),
+                ExactComplexRational::ONE,
+            )
+            .unwrap(),
+        );
+        currents.push(
+            RecurrenceCurrent::new(
+                current_id,
+                propagated_keys[index].clone(),
+                None,
+                CheckedTableRange::new(start, fan_in as u64),
+                Some(index as u32),
+            )
+            .unwrap(),
+        );
+        assert_eq!(support, propagated_keys[index].support_source_slots());
+    }
+
+    let closure_parents = if external_count == 4 {
+        vec![external_count as u32, external_count as u32 + 1]
+    } else {
+        vec![external_count as u32, external_count as u32 + 2]
+    };
+    let closure_terms = (0..closure_count)
+        .map(|id| {
+            RecurrenceClosureTerm::new(
+                id as u32,
+                0,
+                (id % 2) as u32,
+                Some(0),
+                closure_parents.clone(),
+                if id % 3 == 0 {
+                    rational(-1)
+                } else {
+                    ExactComplexRational::ONE
+                },
+            )
+            .unwrap()
+        })
+        .collect::<Vec<_>>();
+    let replay_targets = (0..physical_sector_count)
+        .map(|target| {
+            let mut permutation = (0..external_count as u32).collect::<Vec<_>>();
+            if target != 0 {
+                permutation.swap(external_count - 2, external_count - 1);
+            }
+            RecurrenceReplayTarget::new(
+                target,
+                0,
+                target,
+                permutation,
+                vec![1; external_count],
+                if target == 0 {
+                    ExactComplexRational::ONE
+                } else {
+                    rational(-1)
+                },
+            )
+            .unwrap()
+        })
+        .collect();
+    let resolved_helicities = vec![
+        RecurrenceResolvedHelicity::new(
+            0,
+            (0..external_count as u32)
+                .map(|slot| SourceStateAssignment::new(slot, 0))
+                .collect(),
+            vec![0; external_count],
+        )
+        .unwrap(),
+    ];
+    RecurrenceProgram::new(
+        RecurrenceStrategy::TopologyReplay,
+        physical_sector_count,
+        1,
+        (0..current_count)
+            .map(|id| DynamicLCColorState::new(id as u32, None, vec![]).unwrap())
+            .collect(),
+        currents,
+        contributions,
+        finalizations,
+        replay_targets,
+        resolved_helicities,
+        vec![
+            RecurrenceAmplitudeDestination::new(
+                0,
+                0,
+                Some(0),
+                CheckedTableRange::new(0, closure_count as u64),
+            )
+            .unwrap(),
+        ],
+        closure_terms,
+    )
+    .unwrap()
+}
+
+fn union_key(key: &CurrentCoreKey, runtime_variant_id: u32) -> CurrentCoreKey {
+    let source_binding = if key.node_kind() == RecurrenceNodeKind::Source {
+        CurrentSourceBinding::runtime_dispatch_with_variants(
+            0,
+            vec![
+                RuntimeSourceVariantBinding::new(
+                    0,
+                    0,
+                    runtime_variant_id,
+                    0,
+                    0,
+                    0,
+                    0,
+                    ExactComplexRational::ONE,
+                )
+                .unwrap(),
+            ],
+        )
+        .unwrap()
+    } else {
+        CurrentSourceBinding::None
+    };
+    CurrentCoreKey::new(
+        key.catalog_digest(),
+        key.node_kind(),
+        key.current_state_template_id(),
+        key.dynamic_lc_color_state_id(),
+        key.support_source_slots().to_vec(),
+        key.momentum().clone(),
+        CurrentHelicityIdentity::all_flow_union(if key.node_kind() == RecurrenceNodeKind::Source {
+            crate::recurrence::DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS
+        } else {
+            key.spin_state_class()
+        }),
+        key.flavour_flow().to_vec(),
+        key.quantum_number_flow_id(),
+        key.coupling_orders().to_vec(),
+        source_binding,
+        key.propagator_template_id(),
+    )
+    .unwrap()
+}
+
+fn zgg_union_program(
+    templates: &ValidatedRecurrenceTemplateInput,
+    runtime_variant_id: u32,
+) -> RecurrenceProgram {
+    let base = count_fixture_program(templates, 5, 69, 126, 24, 2);
+    let currents = base
+        .currents()
+        .iter()
+        .map(|current| {
+            RecurrenceCurrent::new(
+                current.id(),
+                union_key(current.key(), runtime_variant_id),
+                None,
+                current.contribution_range(),
+                current.finalization_id(),
+            )
+            .unwrap()
+        })
+        .collect::<Vec<_>>();
+    let closures = base
+        .closure_terms()
+        .iter()
+        .enumerate()
+        .map(|(index, closure)| {
+            RecurrenceClosureTerm::new(
+                closure.id(),
+                u32::from(index >= 12),
+                closure.closure_template_id(),
+                closure.quantum_flow_template_id(),
+                closure.parent_current_ids().to_vec(),
+                closure.exact_factor(),
+            )
+            .unwrap()
+        })
+        .collect::<Vec<_>>();
+    RecurrenceProgram::new(
+        RecurrenceStrategy::AllFlowUnion,
+        2,
+        1,
+        base.dynamic_color_states().to_vec(),
+        currents,
+        base.contributions().to_vec(),
+        base.finalizations().to_vec(),
+        vec![],
+        vec![],
+        vec![
+            RecurrenceAmplitudeDestination::new(0, 0, None, CheckedTableRange::new(0, 12)).unwrap(),
+            RecurrenceAmplitudeDestination::new(1, 1, None, CheckedTableRange::new(12, 12))
+                .unwrap(),
+        ],
+        closures,
+    )
+    .unwrap()
+}
+
+fn runtime_options() -> DirectRecurrenceRuntimeOptions {
+    DirectRecurrenceRuntimeOptions::new(128, 16).unwrap()
+}
+
+fn direct_catalog(catalog_digest: SemanticDigest) -> PreparedDirectExecutorCatalog {
+    PreparedDirectExecutorCatalog::new(
+        catalog_digest,
+        vec![
+            PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Source, 0, 0),
+            PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Contribution, 1, 1),
+            PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Finalization, 2, 2),
+            PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Closure, 3, 3),
+            PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Closure, 4, 4),
+            PreparedDirectExecutorBinding::identity_finalizer(5),
+        ],
+    )
+    .unwrap()
+}
+
+fn lower(
+    program: &RecurrenceProgram,
+    templates: &ValidatedRecurrenceTemplateInput,
+    semantic_digest: SemanticDigest,
+) -> crate::RusticolResult<DirectRecurrencePlanParts> {
+    let catalog_digest = digest(40);
+    lower_recurrence_direct_v2(
+        program,
+        templates,
+        &direct_catalog(catalog_digest),
+        semantic_digest,
+        digest(2),
+        catalog_digest,
+        runtime_options(),
+    )
+}
+
+#[test]
+fn deterministic_lowering_uses_stable_prepared_executor_ids_and_i32_spin() {
+    let templates = validated_template();
+    let program = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let first = lower(&program, &templates, digest(30)).unwrap();
+    let second = lower(&program, &templates, digest(30)).unwrap();
+    assert_eq!(first, second);
+    assert_eq!(first.direct_executor_count, 6);
+    assert_eq!(first.direct_template_catalog_digest, digest(40));
+    assert_eq!(first.sources[0].spin_state_class, 50_000);
+    assert_eq!(
+        first
+            .row_groups
+            .iter()
+            .find(|row_group| row_group.role == DirectExecutorRole::Source)
+            .unwrap()
+            .direct_executor_id,
+        0
+    );
+    assert!(first.row_groups.iter().any(|row_group| {
+        row_group.role == DirectExecutorRole::Contribution && row_group.direct_executor_id == 1
+    }));
+    assert!(first.row_groups.iter().any(|row_group| {
+        row_group.role == DirectExecutorRole::Finalization && row_group.direct_executor_id == 2
+    }));
+}
+
+#[test]
+fn contribution_fanout_preserves_copy_dependencies_with_recycled_arena_addresses() {
+    let copy = |parent, destination, factor| DirectContributionRow {
+        parent0_component_base: parent,
+        parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+        parent0_momentum_form_id: 4,
+        parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+        destination_component_base: destination,
+        exact_factor_id: factor,
+        selector_domain_id: 5,
+        flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+            | DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE,
+    };
+    // A is at 100, B at 10, C at 50. Validated semantic order is A -> B -> C,
+    // but best-fit arena reuse need not assign increasing physical addresses.
+    // Sorting by the parent address would read B before its copy from A.
+    let expected = vec![copy(100, 10, 1), copy(10, 50, 2), copy(5, 5, 0)];
+    let mut rows = expected.clone();
+    order_contributions_for_runtime_fanout_by(&mut rows, |row| {
+        (
+            3,
+            DIRECT_NONE_U32,
+            *row,
+            (row.destination_component_base, row.exact_factor_id),
+        )
+    });
+    // The address-based tie is also used by persisted selected families;
+    // certified zero self-copies must preserve their position as well.
+    assert_eq!(rows, expected);
+}
+
+#[test]
+fn contribution_fanout_order_uses_only_authenticated_kinematic_inputs() {
+    fn draft(
+        semantic_id: u32,
+        parent_base: u32,
+        destination_base: u32,
+        exact_factor_id: u32,
+        flags: u32,
+    ) -> ContributionDraft {
+        ContributionDraft {
+            stage: 3,
+            executor_id: 7,
+            semantic_contribution_id: semantic_id,
+            semantic_result_current_id: destination_base,
+            semantic_parent_current_ids: [parent_base, DIRECT_NONE_U32],
+            semantic_parent_count: 1,
+            row: DirectContributionRow {
+                parent0_component_base: parent_base,
+                parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+                parent0_momentum_form_id: 9,
+                parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+                destination_component_base: destination_base,
+                exact_factor_id,
+                selector_domain_id: 5,
+                flags,
+            },
+        }
+    }
+
+    let mut drafts = vec![
+        draft(10, 2, 100, 2, 0),
+        draft(20, 4, 200, 1, 0),
+        draft(8, 2, 300, 0, DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE),
+        draft(
+            11,
+            2,
+            101,
+            1,
+            DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+        ),
+        draft(21, 4, 201, 1, 0),
+        draft(9, 2, 102, 1, 0),
+        draft(30, 6, 400, 1, 0),
+    ];
+    order_contributions_for_runtime_fanout(&mut drafts);
+
+    let semantic_ids = drafts
+        .iter()
+        .map(|draft| draft.semantic_contribution_id)
+        .collect::<Vec<_>>();
+    assert_eq!(&semantic_ids[..5], &[9, 11, 10, 20, 21]);
+    assert_eq!(
+        semantic_ids[5..].iter().copied().collect::<BTreeSet<_>>(),
+        BTreeSet::from([8, 30])
+    );
+    assert!(
+        drafts[..3]
+            .windows(2)
+            .all(|pair| contribution_fanout_order_key(&pair[0])
+                == contribution_fanout_order_key(&pair[1]))
+    );
+    assert_ne!(
+        contribution_fanout_order_key(&drafts[2]),
+        contribution_fanout_order_key(&drafts[3])
+    );
+    assert!(
+        drafts
+            .iter()
+            .find(|draft| draft.semantic_contribution_id == 8)
+            .unwrap()
+            .row
+            .flags
+            & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE
+            != 0
+    );
+
+    let base = draft(40, 12, 500, 1, 0);
+    let mut output_local = base;
+    output_local.row.destination_component_base = 999;
+    output_local.row.exact_factor_id = 17;
+    output_local.row.flags = DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION;
+    assert_eq!(
+        contribution_fanout_order_key(&base),
+        contribution_fanout_order_key(&output_local)
+    );
+    for changed in [
+        {
+            let mut changed = base;
+            changed.stage += 1;
+            changed
+        },
+        {
+            let mut changed = base;
+            changed.executor_id += 1;
+            changed
+        },
+        {
+            let mut changed = base;
+            changed.row.selector_domain_id += 1;
+            changed
+        },
+        {
+            let mut changed = base;
+            changed.row.parent0_component_base += 1;
+            changed
+        },
+        {
+            let mut changed = base;
+            changed.row.parent1_component_base_or_sentinel = 7;
+            changed
+        },
+        {
+            let mut changed = base;
+            changed.row.parent0_momentum_form_id += 1;
+            changed
+        },
+        {
+            let mut changed = base;
+            changed.row.parent1_momentum_form_id_or_sentinel = 8;
+            changed
+        },
+    ] {
+        assert_ne!(
+            contribution_fanout_order_key(&base),
+            contribution_fanout_order_key(&changed)
+        );
+    }
+}
+
+#[test]
+fn fixed_helicity_locality_follows_certified_reuse_and_multiple_mask_words() {
+    let mut copied = locality_draft(3, 5, &[4], 2, 0);
+    copied.executor_id = DIRECT_NONE_U32;
+    copied.row.flags = DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE;
+    let contributions = [
+        locality_draft(0, 2, &[0], 1, 0),
+        locality_draft(1, 3, &[1], 1, 0),
+        locality_draft(2, 4, &[2], 2, 0),
+        copied,
+        locality_draft(4, 6, &[3], 2, 0),
+    ];
+    let demands =
+        fixed_helicity_demands(8, 71, &contributions, [(5, 70), (6, 1), (4, 2)].into_iter())
+            .unwrap();
+    for id in [0, 2, 4] {
+        assert_eq!(demands.current(id), &[1 << 2, 1 << 6]);
+    }
+    assert_eq!(demands.current(5), &[0, 1 << 6]);
+    for id in [1, 3, 6] {
+        assert_eq!(demands.current(id), &[1 << 1, 0]);
+    }
+    assert_eq!(demands.current(7), &[0, 0]);
+
+    let mut zero_self_copy = locality_draft(5, 7, &[7], 2, 0);
+    zero_self_copy.executor_id = DIRECT_NONE_U32;
+    zero_self_copy.row.flags = DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE;
+    let zero_demand =
+        fixed_helicity_demands(8, 71, &[zero_self_copy], [(7, 70)].into_iter()).unwrap();
+    assert_eq!(zero_demand.current(7), &[0, 1 << 6]);
+    assert!(zero_demand.words[..7 * 2].iter().all(|&word| word == 0));
+
+    let repeated = fixed_helicity_demands(
+        8,
+        71,
+        &contributions,
+        [(4, 2), (6, 1), (5, 70), (5, 70)].into_iter(),
+    )
+    .unwrap();
+    assert_eq!(demands.words, repeated.words);
+    assert!(fixed_helicity_demands(8, 71, &contributions, [(5, 71)].into_iter()).is_err());
+    let mut invalid_copy = copied;
+    invalid_copy.semantic_parent_current_ids[0] = 7;
+    assert!(
+        fixed_helicity_demands(8, 71, &[invalid_copy], [(5, 70)].into_iter())
+            .unwrap_err()
+            .to_string()
+            .contains("topologically ordered")
+    );
+}
+
+fn locality_draft(
+    id: u32,
+    result: u32,
+    parents: &[u32],
+    stage: u16,
+    selector_domain_id: u32,
+) -> ContributionDraft {
+    let second = parents.get(1).copied().unwrap_or(DIRECT_NONE_U32);
+    ContributionDraft {
+        stage,
+        executor_id: 7,
+        semantic_contribution_id: id,
+        semantic_result_current_id: result,
+        semantic_parent_current_ids: [parents[0], second],
+        semantic_parent_count: parents.len() as u8,
+        row: DirectContributionRow {
+            parent0_component_base: parents[0],
+            parent1_component_base_or_sentinel: second,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            destination_component_base: result,
+            exact_factor_id: id % 3,
+            selector_domain_id,
+            flags: 0,
+        },
+    }
+}
+
+#[test]
+fn fixed_helicity_locality_preserves_fanout_classes_rows_and_primary_groups() {
+    let mut drafts = vec![
+        locality_draft(0, 4, &[0], 1, 0),
+        locality_draft(1, 5, &[0], 1, 0),
+        locality_draft(2, 6, &[1], 1, 0),
+        locality_draft(3, 7, &[2], 1, 0),
+        locality_draft(4, 8, &[3], 1, 0),
+        locality_draft(5, 9, &[3], 1, 0),
+        locality_draft(6, 10, &[0], 1, 1),
+        locality_draft(7, 11, &[0], 2, 0),
+    ];
+    let demands = fixed_helicity_demands(
+        12,
+        5,
+        &drafts,
+        [
+            (4, 4),
+            (5, 0),
+            (6, 0),
+            (7, 1),
+            (8, 2),
+            (9, 2),
+            (10, 0),
+            (11, 0),
+        ]
+        .into_iter(),
+    )
+    .unwrap();
+    order_contributions_for_runtime_fanout(&mut drafts);
+    let original = drafts.clone();
+    order_contributions_for_helicity_locality(&mut drafts, &demands);
+    assert_eq!(
+        drafts
+            .iter()
+            .map(|draft| draft.semantic_result_current_id)
+            .collect::<Vec<_>>(),
+        // Intact repeated classes first, ordered by union demand: {2}, {0,4}.
+        // Singleton classes follow, ordered by their own demand: {0}, {1}.
+        vec![8, 9, 4, 5, 6, 7, 10, 11]
+    );
+    for pair in [&drafts[..2], &drafts[2..4]] {
+        assert_eq!(
+            contribution_fanout_order_key(&pair[0]),
+            contribution_fanout_order_key(&pair[1])
+        );
+    }
+    for draft in &drafts {
+        let before = original
+            .iter()
+            .find(|before| before.semantic_contribution_id == draft.semantic_contribution_id)
+            .unwrap();
+        assert_eq!(draft.row, before.row);
+        assert_eq!(draft.stage, before.stage);
+        assert_eq!(draft.executor_id, before.executor_id);
+        assert_eq!(
+            draft.semantic_parent_current_ids,
+            before.semantic_parent_current_ids
+        );
+    }
+    assert_eq!(drafts.len(), original.len());
+    let first_order = drafts
+        .iter()
+        .map(|draft| draft.semantic_contribution_id)
+        .collect::<Vec<_>>();
+    order_contributions_for_helicity_locality(&mut drafts, &demands);
+    assert_eq!(
+        first_order,
+        drafts
+            .iter()
+            .map(|draft| draft.semantic_contribution_id)
+            .collect::<Vec<_>>()
+    );
+    let mut repeated = original.clone();
+    order_contributions_for_helicity_locality(&mut repeated, &demands);
+    assert_eq!(
+        first_order,
+        repeated
+            .iter()
+            .map(|draft| draft.semantic_contribution_id)
+            .collect::<Vec<_>>()
+    );
+}
+
+#[test]
+fn fixed_helicity_locality_does_not_reorder_same_stage_copies() {
+    let mut drafts = vec![
+        locality_draft(0, 4, &[2], 2, 0),
+        locality_draft(1, 5, &[4], 2, 0),
+    ];
+    for draft in &mut drafts {
+        draft.executor_id = DIRECT_NONE_U32;
+        draft.row.flags = DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE;
+    }
+    let demands = fixed_helicity_demands(6, 2, &drafts, [(4, 1), (5, 0)].into_iter()).unwrap();
+    order_contributions_for_helicity_locality(&mut drafts, &demands);
+    assert_eq!(drafts[0].semantic_result_current_id, 4);
+    assert_eq!(drafts[1].semantic_result_current_id, 5);
+}
+
+#[test]
+fn prepared_executor_ids_do_not_depend_on_process_encounter_order() {
+    let templates = validated_template();
+    let program = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let catalog_digest = digest(43);
+    let catalog = PreparedDirectExecutorCatalog::new(
+        catalog_digest,
+        vec![
+            PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Closure, 4, 0),
+            PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Closure, 3, 1),
+            PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Contribution, 1, 2),
+            PreparedDirectExecutorBinding::identity_finalizer(3),
+            PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Source, 0, 4),
+            PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Finalization, 2, 5),
+        ],
+    )
+    .unwrap();
+    let parts = lower_recurrence_direct_v2(
+        &program,
+        &templates,
+        &catalog,
+        digest(44),
+        digest(2),
+        catalog_digest,
+        runtime_options(),
+    )
+    .unwrap();
+
+    assert!(parts.row_groups.iter().any(|group| {
+        group.role == DirectExecutorRole::Source && group.direct_executor_id == 4
+    }));
+    assert!(parts.row_groups.iter().any(|group| {
+        group.role == DirectExecutorRole::Contribution && group.direct_executor_id == 2
+    }));
+    assert!(parts.row_groups.iter().any(|group| {
+        group.role == DirectExecutorRole::Finalization && group.direct_executor_id == 5
+    }));
+    assert!(parts.row_groups.iter().any(|group| {
+        group.role == DirectExecutorRole::Closure && matches!(group.direct_executor_id, 0 | 1)
+    }));
+}
+
+#[test]
+fn zg_and_zgg_gate_counts_are_preserved_exactly() {
+    let templates = validated_template();
+    for (external, currents, contributions, closures, sectors) in
+        [(4, 31, 34, 12, 1), (5, 69, 126, 24, 2)]
+    {
+        let program = count_fixture_program(
+            &templates,
+            external,
+            currents,
+            contributions,
+            closures,
+            sectors,
+        );
+        let parts = lower(&program, &templates, digest(31)).unwrap();
+        assert_eq!(parts.currents.len(), currents);
+        assert_eq!(parts.contributions.len(), contributions);
+        assert_eq!(parts.finalizations.len(), currents - external);
+        assert_eq!(parts.closures.len(), closures);
+    }
+}
+
+#[test]
+fn topology_replay_persists_dependency_closed_selector_work() {
+    let templates = validated_template();
+    let program = count_fixture_program(&templates, 5, 69, 126, 24, 2);
+    let parts = lower(&program, &templates, digest(47)).unwrap();
+    assert!(parts.selector_domains.len() > 1);
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let selected = plan.selector_work_summary(0).unwrap();
+
+    assert!(selected.current_count < plan.currents().len() as u64);
+    assert!(selected.contribution_count < plan.contributions().len() as u64);
+    assert_eq!(selected.closure_count, plan.closures().len() as u64);
+    assert!(
+        selected.row_count()
+            < (plan.sources().len()
+                + plan.contributions().len()
+                + plan.finalizations().len()
+                + plan.closures().len()) as u64
+    );
+}
+
+#[test]
+fn topology_replay_interns_only_referenced_canonical_selector_domains() {
+    let templates = validated_template();
+    let base = count_fixture_program(&templates, 5, 69, 126, 24, 130);
+    let replay_targets = base
+        .replay_targets()
+        .iter()
+        .map(|target| {
+            RecurrenceReplayTarget::new(
+                target.id(),
+                0,
+                target.target_sector_id(),
+                target.source_slot_permutation().to_vec(),
+                target.source_momentum_signs().to_vec(),
+                target.amplitude_factor(),
+            )
+            .unwrap()
+        })
+        .collect();
+    let program = RecurrenceProgram::new(
+        base.strategy(),
+        base.physical_sector_count(),
+        base.retained_helicity_count(),
+        base.dynamic_color_states().to_vec(),
+        base.currents().to_vec(),
+        base.contributions().to_vec(),
+        base.finalizations().to_vec(),
+        replay_targets,
+        base.resolved_helicities().to_vec(),
+        base.amplitude_destinations().to_vec(),
+        base.closure_terms().to_vec(),
+    )
+    .unwrap();
+
+    let selectors = lower_selector_domains(&program).unwrap();
+    assert_eq!(
+        selectors
+            .sector_domain_ids
+            .iter()
+            .filter(|domain| domain.is_some())
+            .count(),
+        1
+    );
+    assert!(selectors.sector_domain_ids[0].is_some());
+    assert!(selectors.sector_domain_ids[1..].iter().all(Option::is_none));
+    assert_eq!(selectors.words, [u64::MAX, 1]);
+    let encoded_domains = selectors
+        .descriptors
+        .iter()
+        .map(|descriptor| {
+            let start = descriptor.word_start as usize;
+            let end = start + descriptor.word_count as usize;
+            &selectors.words[start..end]
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(
+        encoded_domains
+            .iter()
+            .filter(|domain| **domain == [u64::MAX])
+            .count(),
+        1
+    );
+    assert_eq!(
+        encoded_domains
+            .iter()
+            .filter(|domain| **domain == [1])
+            .count(),
+        1
+    );
+    assert_eq!(
+        encoded_domains
+            .iter()
+            .filter(|domain| domain.is_empty())
+            .count(),
+        1
+    );
+
+    let singleton_domain_id = selectors.sector_domain_ids[0].unwrap();
+    let plan = DirectRecurrencePlan::new(lower(&program, &templates, digest(48)).unwrap()).unwrap();
+    let encoded = crate::recurrence::encode_recurrence_direct_plan_v2(&plan).unwrap();
+    let decoded = crate::recurrence::decode_recurrence_direct_plan_v2(&encoded).unwrap();
+    assert!(
+        decoded
+            .selector_domain_contains(singleton_domain_id, 0)
+            .unwrap()
+    );
+    assert!(
+        !decoded
+            .selector_domain_contains(singleton_domain_id, 64)
+            .unwrap()
+    );
+    assert!(
+        !decoded
+            .selector_domain_contains(singleton_domain_id, 129)
+            .unwrap()
+    );
+}
+
+#[test]
+fn selector_domain_canonicalization_preserves_the_universal_sentinel() {
+    assert!(
+        canonical_selector_words(&[0, 0, 0]).is_empty(),
+        "all-zero selector words canonicalize to an empty slice"
+    );
+    assert_eq!(canonical_selector_words(&[1, 0, 0]), [1]);
+    assert_eq!(canonical_selector_words(&[u64::MAX]), [u64::MAX]);
+    assert_eq!(canonical_selector_words(&[u64::MAX, 0, 0]), [u64::MAX, 0]);
+}
+
+fn contracted_fixture_program(base: &RecurrenceProgram) -> RecurrenceProgram {
+    let currents = base
+        .currents()
+        .iter()
+        .map(|current| {
+            let key = current.key();
+            let contracted_key = CurrentCoreKey::new(
+                key.catalog_digest(),
+                key.node_kind(),
+                key.current_state_template_id(),
+                key.dynamic_lc_color_state_id(),
+                key.support_source_slots().to_vec(),
+                key.momentum().clone(),
+                CurrentHelicityIdentity::contracted_color_union(
+                    key.spin_state_class(),
+                    key.helicity_identity().local_source_states().to_vec(),
+                )
+                .unwrap(),
+                key.flavour_flow().to_vec(),
+                key.quantum_number_flow_id(),
+                key.coupling_orders().to_vec(),
+                key.source_binding().clone(),
+                key.propagator_template_id(),
+            )
+            .unwrap();
+            RecurrenceCurrent::new(
+                current.id(),
+                contracted_key,
+                current.source_exact_factor(),
+                current.contribution_range(),
+                current.finalization_id(),
+            )
+            .unwrap()
+        })
+        .collect();
+    RecurrenceProgram::new(
+        RecurrenceStrategy::ContractedColorUnion,
+        base.physical_sector_count(),
+        base.retained_helicity_count(),
+        base.dynamic_color_states().to_vec(),
+        currents,
+        base.contributions().to_vec(),
+        base.finalizations().to_vec(),
+        base.replay_targets().to_vec(),
+        base.resolved_helicities().to_vec(),
+        base.amplitude_destinations().to_vec(),
+        base.closure_terms().to_vec(),
+    )
+    .unwrap()
+}
+
+#[test]
+fn contracted_replay_uses_dependency_closed_selector_work() {
+    let templates = validated_template();
+    let base = count_fixture_program(&templates, 5, 69, 126, 24, 2);
+    let program = contracted_fixture_program(&base);
+    let parts = lower(&program, &templates, digest(48)).unwrap();
+    assert!(parts.selector_domains.len() > 1);
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let selected = plan.selector_work_summary(0).unwrap();
+    assert!(selected.current_count < plan.currents().len() as u64);
+    assert!(selected.contribution_count < plan.contributions().len() as u64);
+}
+
+#[test]
+fn zgg_all_flow_union_lowers_runtime_sources_without_replay_expansion() {
+    let templates = validated_union_template();
+    let program = zgg_union_program(&templates, 0);
+    let first = lower(&program, &templates, digest(46)).unwrap();
+    let second = lower(&program, &templates, digest(46)).unwrap();
+
+    assert_eq!(first, second);
+    assert_eq!(first.strategy, RecurrenceStrategy::AllFlowUnion);
+    assert_eq!(first.currents.len(), 69);
+    assert_eq!(first.contributions.len(), 126);
+    assert_eq!(first.closures.len(), 24);
+    assert_eq!(first.amplitude_destinations.len(), 2);
+    assert_eq!(
+        first
+            .amplitude_destinations
+            .iter()
+            .map(|destination| destination.target_sector_id)
+            .collect::<Vec<_>>(),
+        [0, 1]
+    );
+    assert!(first.replay_targets.is_empty());
+    assert!(first.source_permutations.is_empty());
+    assert_eq!(first.sources.len(), 5);
+    assert_eq!(first.source_dispatch_variants.len(), 5);
+    assert_eq!(first.resolved_helicities.len(), 1);
+    assert_eq!(first.resolved_source_selections.len(), 5);
+    assert_eq!(first.source_state_assignments.len(), 5);
+    assert_eq!(first.public_helicities, [0; 5]);
+    assert_eq!(first.selector_domains.len(), 1);
+    assert_eq!(first.selector_words, [u64::MAX]);
+    assert!(
+        first
+            .currents
+            .iter()
+            .all(|current| current.selector_domain_id == 0)
+    );
+    assert!(first.row_groups.iter().any(|group| {
+        group.role == DirectExecutorRole::Source
+            && group.direct_executor_id == DIRECT_NONE_U32
+            && group.row_count == 5
+    }));
+    for (source_slot, selection) in first.resolved_source_selections.iter().enumerate() {
+        assert_eq!(selection.source_slot, source_slot as u32);
+        let variant = first.source_dispatch_variants[selection.dispatch_variant_id as usize];
+        assert_eq!(
+            first.sources[variant.source_row_id as usize].source_slot,
+            source_slot as u32
+        );
+        assert_eq!(
+            first.exact_factors[variant.crossing_exact_factor_id as usize],
+            ExactComplexRational::ONE
+        );
+        assert_eq!(variant.embedding_count, 1);
+        assert_eq!(variant.projection_count, 1);
+    }
+}
+
+#[test]
+fn all_flow_helicity_dispatch_lowering_preserves_the_base_plan_and_splits_exact_support() {
+    let templates = validated_union_template();
+    let program = zgg_union_program(&templates, 0);
+    let catalog_digest = digest(40);
+    let catalog = direct_catalog(catalog_digest);
+    let ordinary = lower_recurrence_direct_plan_v2(
+        &program,
+        &templates,
+        &catalog,
+        digest(49),
+        digest(2),
+        catalog_digest,
+        runtime_options(),
+    )
+    .unwrap();
+    let (plan, dispatch) = lower_recurrence_direct_plan_v2_with_helicity_dispatch(
+        &program,
+        &templates,
+        &catalog,
+        digest(49),
+        digest(2),
+        catalog_digest,
+        runtime_options(),
+    )
+    .unwrap();
+
+    assert_eq!(plan, ordinary);
+    dispatch.validate_for_plan(&plan).unwrap();
+    assert_eq!(dispatch.resolved_helicity_count(), 1);
+    assert_eq!(dispatch.dispatches().len(), 1);
+    assert!(
+        dispatch.row_groups().len()
+            >= plan
+                .row_groups()
+                .iter()
+                .filter(|group| group.role != DirectExecutorRole::Source)
+                .count()
+    );
+    assert!(
+        dispatch.group_ids_for_helicity(0).unwrap().len() < dispatch.row_groups().len(),
+        "the synthetic union contains dead rows which backward demand must omit"
+    );
+}
+
+#[test]
+fn union_resolved_helicities_are_a_deterministic_source_cartesian_product() {
+    let choices = vec![
+        vec![
+            RuntimeSourceChoice {
+                source_state_index: 0,
+                public_helicity: -1,
+                dispatch_variant_id: 4,
+            },
+            RuntimeSourceChoice {
+                source_state_index: 1,
+                public_helicity: 1,
+                dispatch_variant_id: 5,
+            },
+        ],
+        vec![
+            RuntimeSourceChoice {
+                source_state_index: 0,
+                public_helicity: 0,
+                dispatch_variant_id: 8,
+            },
+            RuntimeSourceChoice {
+                source_state_index: 1,
+                public_helicity: 1,
+                dispatch_variant_id: 9,
+            },
+        ],
+    ];
+    let (descriptors, states, selections, public) =
+        lower_union_resolved_helicities(&choices, 4).unwrap();
+    assert_eq!(descriptors.len(), 4);
+    assert_eq!(
+        public
+            .chunks_exact(2)
+            .map(|values| values.to_vec())
+            .collect::<Vec<_>>(),
+        [vec![-1, 0], vec![-1, 1], vec![1, 0], vec![1, 1]]
+    );
+    assert_eq!(
+        states
+            .chunks_exact(2)
+            .map(|values| values.iter().map(|row| row.state_index).collect::<Vec<_>>())
+            .collect::<Vec<_>>(),
+        [vec![0, 0], vec![0, 1], vec![1, 0], vec![1, 1]]
+    );
+    assert_eq!(
+        selections
+            .chunks_exact(2)
+            .map(|values| {
+                values
+                    .iter()
+                    .map(|row| row.dispatch_variant_id)
+                    .collect::<Vec<_>>()
+            })
+            .collect::<Vec<_>>(),
+        [vec![4, 8], vec![4, 9], vec![5, 8], vec![5, 9]]
+    );
+}
+
+#[test]
+fn union_runtime_variant_outside_its_prepared_contract_fails_closed() {
+    let templates = validated_union_template();
+    let program = zgg_union_program(&templates, 1);
+    let error = lower(&program, &templates, digest(47))
+        .unwrap_err()
+        .to_string();
+    assert!(
+        error.contains("runtime variant 1 is outside contract 0"),
+        "{error}"
+    );
+}
+
+#[test]
+fn union_source_choice_count_must_match_retained_helicity_count() {
+    let choices = vec![vec![RuntimeSourceChoice {
+        source_state_index: 0,
+        public_helicity: 0,
+        dispatch_variant_id: 0,
+    }]];
+    let error = lower_union_resolved_helicities(&choices, 2)
+        .unwrap_err()
+        .to_string();
+    assert!(error.contains("span 1 helicities, expected 2"), "{error}");
+}
+
+#[test]
+fn closure_ranges_remain_destination_contiguous_with_extra_executor_groups() {
+    let templates = validated_template();
+    let base = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let mut closures = base.closure_terms().to_vec();
+    for (id, closure) in closures.iter_mut().enumerate() {
+        *closure = RecurrenceClosureTerm::new(
+            id as u32,
+            u32::from(id >= 6),
+            (id % 2) as u32,
+            Some(0),
+            closure.parent_current_ids().to_vec(),
+            closure.exact_factor(),
+        )
+        .unwrap();
+    }
+    let program = RecurrenceProgram::new(
+        base.strategy(),
+        base.physical_sector_count(),
+        base.retained_helicity_count(),
+        base.dynamic_color_states().to_vec(),
+        base.currents().to_vec(),
+        base.contributions().to_vec(),
+        base.finalizations().to_vec(),
+        base.replay_targets().to_vec(),
+        base.resolved_helicities().to_vec(),
+        vec![
+            RecurrenceAmplitudeDestination::new(0, 0, Some(0), CheckedTableRange::new(0, 6))
+                .unwrap(),
+            RecurrenceAmplitudeDestination::new(1, 0, Some(0), CheckedTableRange::new(6, 6))
+                .unwrap(),
+        ],
+        closures,
+    )
+    .unwrap();
+    let parts = lower(&program, &templates, digest(32)).unwrap();
+    assert_eq!(
+        parts
+            .amplitude_destinations
+            .iter()
+            .map(|row| (row.closure_row_start, row.closure_row_count))
+            .collect::<Vec<_>>(),
+        [(0, 6), (6, 6)]
+    );
+    assert!(
+        parts.closures[..6]
+            .iter()
+            .all(|row| row.amplitude_destination_id == 0)
+    );
+    assert!(
+        parts.closures[6..]
+            .iter()
+            .all(|row| row.amplitude_destination_id == 1)
+    );
+    assert_eq!(
+        parts
+            .row_groups
+            .iter()
+            .filter(|row_group| row_group.role == DirectExecutorRole::Closure)
+            .count(),
+        4
+    );
+}
+
+#[test]
+fn unsupported_parent_arity_fails_closed() {
+    let templates = validated_template();
+    let base = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let result_id = 4_u32;
+    let result = &base.currents()[result_id as usize];
+    let parent_ids = vec![0, 1, 2];
+    let parent_keys = parent_ids
+        .iter()
+        .map(|id| base.currents()[*id as usize].key())
+        .collect::<Vec<_>>();
+    let mut contributions = base.contributions().to_vec();
+    contributions[0] = RecurrenceContribution::new(
+        0,
+        result_id,
+        parent_ids.clone(),
+        contribution_key(
+            &parent_ids,
+            &parent_keys,
+            templates.input().transitions[0].output_projection_string_id,
+        ),
+        ExactComplexRational::ONE,
+    )
+    .unwrap();
+    let program = RecurrenceProgram::new(
+        base.strategy(),
+        base.physical_sector_count(),
+        base.retained_helicity_count(),
+        base.dynamic_color_states().to_vec(),
+        base.currents().to_vec(),
+        contributions,
+        base.finalizations().to_vec(),
+        base.replay_targets().to_vec(),
+        base.resolved_helicities().to_vec(),
+        base.amplitude_destinations().to_vec(),
+        base.closure_terms().to_vec(),
+    )
+    .unwrap();
+    let error = lower(&program, &templates, digest(33))
+        .unwrap_err()
+        .to_string();
+    assert!(error.contains("unsupported parent arity 3"));
+    assert_eq!(result.key().support_source_slots(), &[0, 1]);
+}
+
+#[test]
+fn non_unit_source_factor_is_interned_and_referenced_by_the_source_row() {
+    let templates = validated_template();
+    let base = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let mut currents = base.currents().to_vec();
+    currents[0] = RecurrenceCurrent::new(
+        0,
+        currents[0].key().clone(),
+        Some(rational(-1)),
+        CheckedTableRange::new(0, 0),
+        None,
+    )
+    .unwrap();
+    let program = RecurrenceProgram::new(
+        base.strategy(),
+        base.physical_sector_count(),
+        base.retained_helicity_count(),
+        base.dynamic_color_states().to_vec(),
+        currents,
+        base.contributions().to_vec(),
+        base.finalizations().to_vec(),
+        base.replay_targets().to_vec(),
+        base.resolved_helicities().to_vec(),
+        base.amplitude_destinations().to_vec(),
+        base.closure_terms().to_vec(),
+    )
+    .unwrap();
+    let parts = lower(&program, &templates, digest(34)).unwrap();
+    let factor_id = parts.sources[0].exact_factor_id as usize;
+    assert_eq!(parts.exact_factors[factor_id], rational(-1));
+}
+
+#[test]
+fn prepared_pack_digest_must_match_the_validated_catalog() {
+    let templates = validated_template();
+    let program = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let catalog_digest = digest(40);
+    let error = lower_recurrence_direct_v2(
+        &program,
+        &templates,
+        &direct_catalog(catalog_digest),
+        digest(35),
+        digest(36),
+        catalog_digest,
+        runtime_options(),
+    )
+    .unwrap_err()
+    .to_string();
+    assert!(error.contains("does not match validated template pack"));
+}
+
+#[test]
+fn direct_template_catalog_digest_must_match_the_prepared_resolver() {
+    let templates = validated_template();
+    let program = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let error = lower_recurrence_direct_v2(
+        &program,
+        &templates,
+        &direct_catalog(digest(40)),
+        digest(35),
+        digest(2),
+        digest(41),
+        runtime_options(),
+    )
+    .unwrap_err()
+    .to_string();
+    assert!(error.contains("does not match resolver catalog"));
+}
+
+fn with_first_identity_finalizer(
+    base: &RecurrenceProgram,
+    exact_factor: ExactComplexRational,
+) -> RecurrenceProgram {
+    let mut finalizations = base.finalizations().to_vec();
+    let current_id = finalizations[0].current_id();
+    finalizations[0] =
+        RecurrenceFinalization::new(finalizations[0].id(), current_id, None, exact_factor).unwrap();
+    let mut currents = base.currents().to_vec();
+    let current = &currents[current_id as usize];
+    let key = current.key();
+    let identity_key = CurrentCoreKey::new(
+        key.catalog_digest(),
+        key.node_kind(),
+        key.current_state_template_id(),
+        key.dynamic_lc_color_state_id(),
+        key.support_source_slots().to_vec(),
+        key.momentum().clone(),
+        key.helicity_identity().clone(),
+        key.flavour_flow().to_vec(),
+        key.quantum_number_flow_id(),
+        key.coupling_orders().to_vec(),
+        key.source_binding().clone(),
+        None,
+    )
+    .unwrap();
+    currents[current_id as usize] = RecurrenceCurrent::new(
+        current.id(),
+        identity_key,
+        current.source_exact_factor(),
+        current.contribution_range(),
+        current.finalization_id(),
+    )
+    .unwrap();
+    RecurrenceProgram::new(
+        base.strategy(),
+        base.physical_sector_count(),
+        base.retained_helicity_count(),
+        base.dynamic_color_states().to_vec(),
+        currents,
+        base.contributions().to_vec(),
+        finalizations,
+        base.replay_targets().to_vec(),
+        base.resolved_helicities().to_vec(),
+        base.amplitude_destinations().to_vec(),
+        base.closure_terms().to_vec(),
+    )
+    .unwrap()
+}
+
+#[test]
+fn unit_identity_finalizer_is_elided() {
+    let templates = validated_template();
+    let base = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let current_id = base.finalizations()[0].current_id();
+    let program = with_first_identity_finalizer(&base, ExactComplexRational::ONE);
+
+    let parts = lower(&program, &templates, digest(42)).unwrap();
+    assert_eq!(
+        parts.currents[current_id as usize].finalization_row_or_sentinel,
+        DIRECT_NONE_U32
+    );
+    assert_eq!(parts.finalizations.len(), base.finalizations().len() - 1);
+    assert!(!parts.row_groups.iter().any(|group| {
+        group.role == DirectExecutorRole::Finalization && group.direct_executor_id == 5
+    }));
+}
+
+#[test]
+fn nonunit_identity_and_nonidentity_finalizers_are_preserved() {
+    let templates = validated_template();
+    let base = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let identity = with_first_identity_finalizer(&base, rational(2));
+    let identity_parts = lower(&identity, &templates, digest(43)).unwrap();
+    assert_eq!(
+        identity_parts.finalizations.len(),
+        base.finalizations().len()
+    );
+    assert!(identity_parts.row_groups.iter().any(|group| {
+        group.role == DirectExecutorRole::Finalization && group.direct_executor_id == 5
+    }));
+
+    let propagated_parts = lower(&base, &templates, digest(44)).unwrap();
+    assert_eq!(
+        propagated_parts.finalizations.len(),
+        base.finalizations().len()
+    );
+    assert!(propagated_parts.row_groups.iter().any(|group| {
+        group.role == DirectExecutorRole::Finalization && group.direct_executor_id == 2
+    }));
+}
+
+#[test]
+fn lowering_marks_exactly_one_initializing_contribution_per_destination() {
+    let templates = validated_template();
+    let program = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let parts = lower(&program, &templates, digest(45)).unwrap();
+    let mut initialization_counts = BTreeMap::<(u16, u32), usize>::new();
+    let mut contribution_counts = BTreeMap::<(u16, u32), usize>::new();
+    for group in parts
+        .row_groups
+        .iter()
+        .filter(|group| group.role == DirectExecutorRole::Contribution)
+    {
+        let start = group.row_start as usize;
+        let end = start + group.row_count as usize;
+        for row in &parts.contributions[start..end] {
+            let key = (group.stage, row.destination_component_base);
+            *contribution_counts.entry(key).or_default() += 1;
+            if row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0 {
+                *initialization_counts.entry(key).or_default() += 1;
+            }
+        }
+    }
+    assert!(
+        contribution_counts.values().any(|count| *count > 1),
+        "fixture must exercise a multi-contribution destination"
+    );
+    assert!(
+        contribution_counts
+            .keys()
+            .all(|key| initialization_counts.get(key) == Some(&1))
+    );
+}
+#[test]
+fn certified_parent_permutation_swaps_arena_and_momentum_operands() {
+    let parents = DirectParents {
+        parent0_component_base: 11,
+        parent1_component_base_or_sentinel: 22,
+        parent0_momentum_form_id: 33,
+        parent1_momentum_form_id_or_sentinel: 44,
+    };
+    assert_eq!(parents.permuted([0, 1]).unwrap().parent0_component_base, 11);
+    let swapped = parents.permuted([1, 0]).unwrap();
+    assert_eq!(swapped.parent0_component_base, 22);
+    assert_eq!(swapped.parent1_component_base_or_sentinel, 11);
+    assert_eq!(swapped.parent0_momentum_form_id, 44);
+    assert_eq!(swapped.parent1_momentum_form_id_or_sentinel, 33);
+}
+
+#[test]
+fn certified_parent_permutation_fails_closed_for_nonbinary_rows() {
+    let parents = DirectParents {
+        parent0_component_base: 11,
+        parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+        parent0_momentum_form_id: 33,
+        parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+    };
+    assert!(parents.permuted([1, 0]).is_err());
+    assert!(parents.permuted([0, 0]).is_err());
+}
+
+#[test]
+fn certified_relation_lowering_produces_a_round_trippable_tiny_artifact() {
+    let templates = validated_template();
+    let program = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let catalog_digest = digest(40);
+    let catalog = direct_catalog(catalog_digest);
+    let baseline = lower_recurrence_direct_plan_v2(
+        &program,
+        &templates,
+        &catalog,
+        digest(51),
+        digest(2),
+        catalog_digest,
+        runtime_options(),
+    )
+    .unwrap();
+    let diagnostic_options = RecurrenceRelationDiscoveryOptions::new(
+        RecurrenceRelationDiscoveryMode::Diagnostic,
+        96,
+        4,
+        4,
+        1.0e-70,
+        1.0e-80,
+        0x5059_414d,
+        "lc",
+    )
+    .unwrap();
+    let (diagnostic_plan, diagnostic_report) =
+        lower_recurrence_direct_plan_v2_with_relation_discovery(
+            &program,
+            &templates,
+            &catalog,
+            digest(51),
+            digest(2),
+            catalog_digest,
+            runtime_options(),
+            &diagnostic_options,
+        )
+        .unwrap();
+    assert_eq!(diagnostic_plan, baseline);
+    assert_eq!(
+        diagnostic_report.unwrap().state,
+        "diagnostic-only",
+        "diagnostic mode must report without mutating the plan"
+    );
+
+    let options = RecurrenceRelationDiscoveryOptions::new(
+        RecurrenceRelationDiscoveryMode::CertifiedReuse,
+        96,
+        4,
+        4,
+        1.0e-70,
+        1.0e-80,
+        0x5059_414d,
+        "lc",
+    )
+    .unwrap();
+    let (plan, report) = lower_recurrence_direct_plan_v2_with_relation_discovery(
+        &program,
+        &templates,
+        &catalog,
+        digest(51),
+        digest(2),
+        catalog_digest,
+        runtime_options(),
+        &options,
+    )
+    .unwrap();
+    let report = report.expect("certified lowering report");
+    assert_eq!(
+        report.requested_mode,
+        RecurrenceRelationDiscoveryMode::CertifiedReuse
+    );
+    assert_eq!(report.state, "exact-certified-applied");
+    assert_eq!(report.current_count_before, plan.currents().len());
+    assert!(report.exact_certified_relation_count > 0);
+    assert_eq!(
+        report.applied_relation_count,
+        report.exact_certified_relation_count
+    );
+    assert_eq!(report.contribution_count_after, plan.contributions().len());
+    assert!(report.interaction_evaluation_count_after < report.interaction_evaluation_count_before);
+    assert_eq!(
+        plan.contributions()
+            .iter()
+            .filter(|row| row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0)
+            .count(),
+        report.scale_copy_row_count
+    );
+    assert_eq!(report.effective_projection_count, 7);
+
+    let directory = std::env::temp_dir().join(format!(
+        "rusticol-recurrence-relation-producer-{}",
+        std::process::id()
+    ));
+    let _ = std::fs::remove_dir_all(&directory);
+    std::fs::create_dir(&directory).unwrap();
+    let path = directory.join("recurrence-runtime.pacbin");
+    write_recurrence_direct_plan_pacbin(&path, &plan).unwrap();
+    assert_eq!(load_recurrence_direct_plan_pacbin(&path).unwrap(), plan);
+    std::fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn authenticated_numerical_evidence_applies_only_its_verified_mapping() {
+    let templates = validated_template();
+    let program = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let catalog_digest = digest(40);
+    let catalog = direct_catalog(catalog_digest);
+    let semantic_digest = digest(51);
+    let diagnostic_options = RecurrenceRelationDiscoveryOptions::new(
+        RecurrenceRelationDiscoveryMode::Diagnostic,
+        96,
+        4,
+        4,
+        1.0e-70,
+        1.0e-80,
+        0x5059_414d,
+        "lc",
+    )
+    .unwrap();
+    let (diagnostic_plan, diagnostic_report) =
+        lower_recurrence_direct_plan_v2_with_relation_discovery(
+            &program,
+            &templates,
+            &catalog,
+            semantic_digest,
+            digest(2),
+            catalog_digest,
+            runtime_options(),
+            &diagnostic_options,
+        )
+        .unwrap();
+    let structural_certificate = diagnostic_report
+        .unwrap()
+        .certificates
+        .into_iter()
+        .next()
+        .expect("fixture must expose at least one compatible exact mapping");
+    let current = diagnostic_plan
+        .currents()
+        .get(structural_certificate.current_id as usize)
+        .unwrap();
+    let evidence = RecurrenceNumericalRelationEvidence {
+        requested_mode: RecurrenceRelationDiscoveryMode::CertifiedReuse,
+        schedule_semantic_digest: semantic_digest.to_string(),
+        baseline_runtime_layout_digest: diagnostic_plan.runtime_layout_digest().to_string(),
+        source_semantics_sha256: crate::recurrence::recurrence_numerical_source_semantics_sha256(
+            &diagnostic_plan,
+            "authenticated-numerical-test",
+        )
+        .unwrap(),
+        runtime_parameter_schema_sha256: digest(60).to_string(),
+        candidate_observation_batch_sha256: digest(61).to_string(),
+        verification_observation_batch_sha256: digest(62).to_string(),
+        decision_sha256: digest(64).to_string(),
+        rejection_decision_sha256: digest(65).to_string(),
+        certificate_algorithm: NUMERICAL_RELATION_CERTIFICATE_ALGORITHM.to_owned(),
+        certificate_set_sha256: digest(63).to_string(),
+        precision_digits: 96,
+        probe_count: 4,
+        verification_probe_count: 4,
+        relative_tolerance: 1.0e-70,
+        absolute_tolerance: 1.0e-80,
+        seed: 0x5059_414d,
+        numerical_candidate_count: 4,
+        verification_rejected_count: 3,
+        rejected_hypothesis_count: 46,
+        tested_hypothesis_count: 47,
+        mappings: vec![RecurrenceNumericalCurrentMapping {
+            current_id: structural_certificate.current_id,
+            representative_id: Some(structural_certificate.representative_id),
+            execution_representative_id: structural_certificate.representative_id,
+            relation_kind: if structural_certificate.factor == ExactComplexRational::ONE {
+                "equal".to_owned()
+            } else {
+                "opposite".to_owned()
+            },
+            factor: structural_certificate.factor,
+            current_dimension: current.component_count,
+            certificate_proof_sha256: structural_certificate.proof_sha256,
+            candidate_observations_sha256: structural_certificate.current_expression_sha256,
+            verification_observations_sha256: structural_certificate
+                .representative_expression_sha256,
+        }],
+    };
+    crate::recurrence::authenticate_recurrence_numerical_relation_provenance(
+        &evidence,
+        &diagnostic_plan,
+        "authenticated-numerical-test",
+    )
+    .unwrap();
+    let mut stale_layout = evidence.clone();
+    stale_layout.baseline_runtime_layout_digest = digest(61).to_string();
+    assert!(
+        crate::recurrence::authenticate_recurrence_numerical_relation_provenance(
+            &stale_layout,
+            &diagnostic_plan,
+            "authenticated-numerical-test",
+        )
+        .unwrap_err()
+        .to_string()
+        .contains("runtime-layout digest")
+    );
+    let mut stale_source = evidence.clone();
+    stale_source.source_semantics_sha256 = digest(62).to_string();
+    assert!(
+        crate::recurrence::authenticate_recurrence_numerical_relation_provenance(
+            &stale_source,
+            &diagnostic_plan,
+            "authenticated-numerical-test",
+        )
+        .unwrap_err()
+        .to_string()
+        .contains("source-semantics digest")
+    );
+    let options = RecurrenceRelationDiscoveryOptions::new(
+        RecurrenceRelationDiscoveryMode::CertifiedReuse,
+        96,
+        4,
+        4,
+        1.0e-70,
+        1.0e-80,
+        0x5059_414d,
+        "lc",
+    )
+    .unwrap()
+    .with_numerical_evidence(evidence)
+    .unwrap();
+    let (plan, report) = lower_recurrence_direct_plan_v2_with_relation_discovery(
+        &program,
+        &templates,
+        &catalog,
+        semantic_digest,
+        digest(2),
+        catalog_digest,
+        runtime_options(),
+        &options,
+    )
+    .unwrap();
+    let report = report.unwrap();
+    assert_eq!(
+        report.certificate_algorithm,
+        NUMERICAL_RELATION_CERTIFICATE_ALGORITHM
+    );
+    assert_eq!(report.tested_hypothesis_count, 47);
+    assert_eq!(report.verification_rejected_count, 3);
+    assert_eq!(report.numerical_candidate_count, 4);
+    assert_eq!(report.exact_certified_relation_count, 1);
+    assert_eq!(report.applied_relation_count, 1);
+    assert_eq!(report.scale_copy_row_count, 1);
+    assert_eq!(
+        plan.contributions()
+            .iter()
+            .filter(|row| row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0)
+            .count(),
+        1
+    );
+
+    // Signed numerical reuse remains available outside contracted colour.
+    let mut opposite_options = options.clone();
+    let opposite = &mut opposite_options
+        .numerical_evidence
+        .as_mut()
+        .unwrap()
+        .mappings[0];
+    opposite.relation_kind = "opposite".to_owned();
+    opposite.factor = rational(-1);
+    let (opposite_plan, opposite_report) = lower_recurrence_direct_plan_v2_with_relation_discovery(
+        &program,
+        &templates,
+        &catalog,
+        semantic_digest,
+        digest(2),
+        catalog_digest,
+        runtime_options(),
+        &opposite_options,
+    )
+    .unwrap();
+    assert_eq!(opposite_report.unwrap().applied_relation_count, 1);
+    let opposite_copy = opposite_plan
+        .contributions()
+        .iter()
+        .find(|row| row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0)
+        .unwrap();
+    assert_eq!(
+        opposite_plan.exact_factors()[opposite_copy.exact_factor_id as usize],
+        rational(-1)
+    );
+
+    let mut zero_options = options.clone();
+    let zero_mapping = &mut zero_options.numerical_evidence.as_mut().unwrap().mappings[0];
+    zero_mapping.representative_id = None;
+    zero_mapping.execution_representative_id = zero_mapping.current_id;
+    zero_mapping.relation_kind = "zero".to_owned();
+    zero_mapping.factor = ExactComplexRational::ZERO;
+    let (zero_plan, zero_report) = lower_recurrence_direct_plan_v2_with_relation_discovery(
+        &program,
+        &templates,
+        &catalog,
+        semantic_digest,
+        digest(2),
+        catalog_digest,
+        runtime_options(),
+        &zero_options,
+    )
+    .unwrap();
+    let zero_report = zero_report.unwrap();
+    assert_eq!(zero_report.applied_relation_count, 1);
+    assert_eq!(zero_report.scale_copy_row_count, 1);
+    assert!(
+        zero_report.interaction_evaluation_count_after
+            < zero_report.interaction_evaluation_count_before
+    );
+    let zero_row = zero_plan
+        .contributions()
+        .iter()
+        .find(|row| row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0)
+        .unwrap();
+    assert_eq!(
+        zero_row.parent0_component_base, zero_row.destination_component_base,
+        "a certified zero current must self-reference its cleared stage destination"
+    );
+    assert_eq!(
+        zero_plan.exact_factors()[zero_row.exact_factor_id as usize],
+        ExactComplexRational::ZERO
+    );
+
+    let mut mismatched = options.clone();
+    mismatched
+        .numerical_evidence
+        .as_mut()
+        .unwrap()
+        .schedule_semantic_digest = digest(64).to_string();
+    assert!(
+        lower_recurrence_direct_plan_v2_with_relation_discovery(
+            &program,
+            &templates,
+            &catalog,
+            semantic_digest,
+            digest(2),
+            catalog_digest,
+            runtime_options(),
+            &mismatched,
+        )
+        .unwrap_err()
+        .to_string()
+        .contains("different semantic schedule")
+    );
+
+    let mut inconsistent_counters = options.clone();
+    inconsistent_counters
+        .numerical_evidence
+        .as_mut()
+        .unwrap()
+        .verification_rejected_count = 0;
+    assert!(
+        lower_recurrence_direct_plan_v2_with_relation_discovery(
+            &program,
+            &templates,
+            &catalog,
+            semantic_digest,
+            digest(2),
+            catalog_digest,
+            runtime_options(),
+            &inconsistent_counters,
+        )
+        .unwrap_err()
+        .to_string()
+        .contains("counters are inconsistent")
+    );
+
+    let mut source_representative = options.clone();
+    let mapping = &mut source_representative
+        .numerical_evidence
+        .as_mut()
+        .unwrap()
+        .mappings[0];
+    mapping.representative_id = Some(0);
+    mapping.execution_representative_id = 0;
+    assert!(
+        lower_recurrence_direct_plan_v2_with_relation_discovery(
+            &program,
+            &templates,
+            &catalog,
+            semantic_digest,
+            digest(2),
+            catalog_digest,
+            runtime_options(),
+            &source_representative,
+        )
+        .unwrap_err()
+        .to_string()
+        .contains("exact current contract")
+    );
+
+    let mut source_target = options;
+    let mapping = &mut source_target.numerical_evidence.as_mut().unwrap().mappings[0];
+    mapping.current_id = 0;
+    mapping.representative_id = None;
+    mapping.execution_representative_id = 0;
+    mapping.relation_kind = "zero".to_owned();
+    mapping.factor = ExactComplexRational::ZERO;
+    mapping.current_dimension = diagnostic_plan.currents()[0].component_count;
+    assert!(
+        lower_recurrence_direct_plan_v2_with_relation_discovery(
+            &program,
+            &templates,
+            &catalog,
+            semantic_digest,
+            digest(2),
+            catalog_digest,
+            runtime_options(),
+            &source_target,
+        )
+        .unwrap_err()
+        .to_string()
+        .contains("exact current contract")
+    );
+}
+
+#[test]
+fn contracted_numerical_reuse_applies_equal_and_zero_without_discarding_signed_evidence() {
+    let templates = validated_template();
+    let base = count_fixture_program(&templates, 4, 31, 34, 12, 1);
+    let program = contracted_fixture_program(&base);
+    let catalog_digest = digest(40);
+    let catalog = direct_catalog(catalog_digest);
+    let semantic_digest = digest(51);
+    let options = RecurrenceRelationDiscoveryOptions::new(
+        RecurrenceRelationDiscoveryMode::Diagnostic,
+        96,
+        4,
+        4,
+        1.0e-70,
+        1.0e-80,
+        0x5059_414d,
+        "full",
+    )
+    .unwrap();
+    let lower = |options: &RecurrenceRelationDiscoveryOptions| {
+        lower_recurrence_direct_plan_v2_with_relation_discovery(
+            &program,
+            &templates,
+            &catalog,
+            semantic_digest,
+            digest(2),
+            catalog_digest,
+            runtime_options(),
+            options,
+        )
+    };
+    let (baseline, structural) = lower(&options).unwrap();
+    let structural = structural.unwrap();
+    assert!(structural.certificates.len() >= 3);
+    let opposite = &structural.certificates[0];
+    let equal = structural
+        .certificates
+        .iter()
+        .find(|certificate| {
+            certificate.current_id > opposite.current_id
+                && certificate.representative_id == opposite.representative_id
+        })
+        .expect("fixture contains a later equal current with the same original representative");
+    let zero = structural
+        .certificates
+        .iter()
+        .find(|certificate| certificate.current_id > equal.current_id)
+        .expect("fixture contains another later current");
+    let mappings = [opposite, equal, zero]
+        .into_iter()
+        .enumerate()
+        .map(|(index, certificate)| {
+            let zero = index == 2;
+            let representative = if index == 1 {
+                opposite.current_id
+            } else {
+                certificate.representative_id
+            };
+            RecurrenceNumericalCurrentMapping {
+                current_id: certificate.current_id,
+                representative_id: (!zero).then_some(representative),
+                execution_representative_id: if zero {
+                    certificate.current_id
+                } else {
+                    representative
+                },
+                relation_kind: ["opposite", "equal", "zero"][index].to_owned(),
+                factor: [
+                    rational(-1),
+                    ExactComplexRational::ONE,
+                    ExactComplexRational::ZERO,
+                ][index],
+                current_dimension: baseline.currents()[certificate.current_id as usize]
+                    .component_count,
+                certificate_proof_sha256: certificate.proof_sha256.clone(),
+                candidate_observations_sha256: certificate.current_expression_sha256.clone(),
+                verification_observations_sha256: certificate
+                    .representative_expression_sha256
+                    .clone(),
+            }
+        })
+        .collect::<Vec<_>>();
+    let removed = [1, 2]
+        .into_iter()
+        .map(|index| program.currents()[mappings[index].current_id as usize].fan_in() as usize)
+        .sum::<usize>();
+    let opposite_base = baseline.currents()[mappings[0].current_id as usize].component_base;
+    let evidence = RecurrenceNumericalRelationEvidence {
+        requested_mode: RecurrenceRelationDiscoveryMode::CertifiedReuse,
+        schedule_semantic_digest: semantic_digest.to_string(),
+        baseline_runtime_layout_digest: baseline.runtime_layout_digest().to_string(),
+        source_semantics_sha256: crate::recurrence::recurrence_numerical_source_semantics_sha256(
+            &baseline,
+            "contracted-subset-test",
+        )
+        .unwrap(),
+        runtime_parameter_schema_sha256: digest(60).to_string(),
+        candidate_observation_batch_sha256: digest(61).to_string(),
+        verification_observation_batch_sha256: digest(62).to_string(),
+        decision_sha256: digest(64).to_string(),
+        rejection_decision_sha256: digest(65).to_string(),
+        certificate_algorithm: NUMERICAL_RELATION_CERTIFICATE_ALGORITHM.to_owned(),
+        certificate_set_sha256: digest(63).to_string(),
+        precision_digits: 96,
+        probe_count: 4,
+        verification_probe_count: 4,
+        relative_tolerance: 1.0e-70,
+        absolute_tolerance: 1.0e-80,
+        seed: 0x5059_414d,
+        numerical_candidate_count: 3,
+        verification_rejected_count: 0,
+        rejected_hypothesis_count: 0,
+        tested_hypothesis_count: 3,
+        mappings,
+    };
+    let mut apply = options.clone();
+    apply.mode = RecurrenceRelationDiscoveryMode::CertifiedReuse;
+    apply = apply.with_numerical_evidence(evidence).unwrap();
+    let (plan, report) = lower(&apply).unwrap();
+    let report = report.unwrap();
+    assert_eq!(report.exact_certified_relation_count, 3);
+    assert_eq!(report.certificates.len(), 3);
+    assert_eq!(report.certificates[0].factor, rational(-1));
+    assert_eq!(
+        report.authenticated_certificate_set_sha256,
+        Some(digest(63).to_string())
+    );
+    assert_eq!(report.applied_relation_count, 2);
+    assert_eq!(report.scale_copy_row_count, 2);
+    assert_eq!(
+        report.contribution_count_after,
+        baseline.contributions().len() - removed + 2
+    );
+    assert_eq!(report.contribution_count_after, plan.contributions().len());
+    assert_eq!(
+        report.interaction_evaluation_count_after,
+        baseline.contributions().len() - removed
+    );
+    let copies = plan
+        .contributions()
+        .iter()
+        .filter(|row| row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0)
+        .collect::<Vec<_>>();
+    assert_eq!(copies.len(), 2);
+    assert!(copies.iter().all(|row| {
+        let factor = plan.exact_factors()[row.exact_factor_id as usize];
+        factor == ExactComplexRational::ONE || factor == ExactComplexRational::ZERO
+    }));
+    assert_eq!(
+        plan.contributions()
+            .iter()
+            .filter(|row| row.destination_component_base == opposite_base)
+            .count(),
+        baseline
+            .contributions()
+            .iter()
+            .filter(|row| row.destination_component_base == opposite_base)
+            .count(),
+        "the suppressed opposite current keeps its original interactions",
+    );
+    assert!(
+        copies
+            .iter()
+            .all(|row| row.destination_component_base != opposite_base)
+    );
+    assert!(
+        copies.iter().any(|row| {
+            row.parent0_component_base == opposite_base
+                && plan.exact_factors()[row.exact_factor_id as usize] == ExactComplexRational::ONE
+        }),
+        "an applied equal relation may read an opposite current whose original work was retained"
+    );
+
+    // The non-applied certificate is still authenticated, not discarded.
+    let mut invalid = apply.clone();
+    invalid.numerical_evidence.as_mut().unwrap().mappings[0].current_dimension += 1;
+    assert!(
+        lower(&invalid)
+            .unwrap_err()
+            .to_string()
+            .contains("exact current contract")
+    );
+
+    let mut diagnostic = apply.clone();
+    diagnostic.mode = RecurrenceRelationDiscoveryMode::Diagnostic;
+    diagnostic
+        .numerical_evidence
+        .as_mut()
+        .unwrap()
+        .requested_mode = diagnostic.mode;
+    let (unchanged, diagnostic_report) = lower(&diagnostic).unwrap();
+    assert_eq!(unchanged, baseline);
+    let diagnostic_report = diagnostic_report.unwrap();
+    assert_eq!(diagnostic_report.certificates, report.certificates);
+    assert_eq!(diagnostic_report.applied_relation_count, 0);
+
+    let mut opposite_only = apply;
+    let evidence = opposite_only.numerical_evidence.as_mut().unwrap();
+    evidence.mappings = vec![evidence.mappings[0].clone()];
+    evidence.numerical_candidate_count = 1;
+    evidence.tested_hypothesis_count = 1;
+    let (unchanged, suppressed) = lower(&opposite_only).unwrap();
+    let suppressed = suppressed.unwrap();
+    assert_eq!(unchanged, baseline);
+    assert_eq!(suppressed.certificates.len(), 1);
+    assert_eq!(suppressed.state, "diagnostic-only");
+    assert_eq!(suppressed.applied_relation_count, 0);
+    assert_eq!(suppressed.scale_copy_row_count, 0);
+    assert_eq!(
+        suppressed.contribution_count_after,
+        baseline.contributions().len()
+    );
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_pacbin.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_pacbin.rs
new file mode 100644
index 0000000000..1ed1e5d9dd
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_pacbin.rs
@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: 0BSD
+
+//! PACBIN publication and authenticated loading for direct-plan v2.
+
+use std::io::{BufWriter, Write};
+use std::path::{Path, PathBuf};
+
+#[cfg(test)]
+use super::direct_codec::encode_recurrence_direct_plan_v2;
+use super::direct_codec::{
+    decode_recurrence_direct_plan_v2, encode_recurrence_direct_plan_v2_to_writer,
+};
+use super::direct_plan::DirectRecurrencePlan;
+use crate::pacbin::{
+    PACBIN_DEFAULT_CHUNK_SIZE, PacbinMemberKind, PacbinReader, PacbinWriteMember,
+    PacbinWriteOptions, create_temporary_file, write_pacbin_atomic,
+};
+use crate::{RusticolError, RusticolResult};
+use sha2::{Digest, Sha256};
+
+pub const RECURRENCE_DIRECT_SCHEDULE_MEMBER: &str = "schedule/recurrence-direct-schedule-v2.bin";
+pub const RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER: &str =
+    "proof/recurrence-color-projection-v1.bin";
+const COLOR_PROJECTION_CERTIFICATE_BODY_MAGIC: &[u8] = b"PYAMP-COLOR-PROJECTION-BODY-V1\0\0";
+
+struct TemporaryPlanPayload(PathBuf);
+
+impl Drop for TemporaryPlanPayload {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_file(&self.0);
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceDirectPacbinMetadata {
+    pub container_size: u64,
+    pub member_count: u64,
+    pub unpacked_size_bytes: u64,
+    pub index_sha256: [u8; 32],
+    pub plan_payload_size: u64,
+    pub plan_sha256: [u8; 32],
+    pub projection_certificate_payload_size: Option<u64>,
+    pub projection_certificate_sha256: Option<[u8; 32]>,
+}
+
+pub fn write_recurrence_direct_plan_pacbin(
+    destination: impl AsRef<Path>,
+    plan: &DirectRecurrencePlan,
+) -> RusticolResult<RecurrenceDirectPacbinMetadata> {
+    write_recurrence_direct_plan_pacbin_with_projection_certificate(destination, plan, None)
+}
+
+pub fn write_recurrence_direct_plan_pacbin_with_projection_certificate(
+    destination: impl AsRef<Path>,
+    plan: &DirectRecurrencePlan,
+    projection_certificate: Option<&[u8]>,
+) -> RusticolResult<RecurrenceDirectPacbinMetadata> {
+    let destination = destination.as_ref();
+    let parent = destination
+        .parent()
+        .filter(|path| !path.as_os_str().is_empty())
+        .unwrap_or_else(|| Path::new("."));
+    let (payload_path, payload_file) = create_temporary_file(destination, parent)?;
+    let payload_guard = TemporaryPlanPayload(payload_path);
+    let mut payload_writer = BufWriter::with_capacity(PACBIN_DEFAULT_CHUNK_SIZE, payload_file);
+    let encoded_payload_size =
+        encode_recurrence_direct_plan_v2_to_writer(plan, &mut payload_writer)?;
+    payload_writer.flush().map_err(|error| {
+        RusticolError::artifact(format!(
+            "could not flush recurrence direct-plan temporary payload {}: {error}",
+            payload_guard.0.display()
+        ))
+    })?;
+    drop(payload_writer);
+    let plan_member = PacbinWriteMember::from_path(
+        RECURRENCE_DIRECT_SCHEDULE_MEMBER,
+        PacbinMemberKind::RecurrenceDirectPlan,
+        &payload_guard.0,
+    )?;
+    let mut members = vec![plan_member];
+    if let Some(certificate) = projection_certificate {
+        validate_recurrence_color_projection_certificate(certificate)?;
+        members.push(PacbinWriteMember::from_bytes(
+            RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER,
+            PacbinMemberKind::RecurrenceColorProjectionCertificate,
+            certificate,
+        )?);
+    }
+    let index = write_pacbin_atomic(destination, members, PacbinWriteOptions::default())?;
+    let indexed = index
+        .members()
+        .iter()
+        .find(|member| member.logical_path() == RECURRENCE_DIRECT_SCHEDULE_MEMBER)
+        .ok_or_else(|| RusticolError::artifact("direct recurrence PACBIN has no plan member"))?;
+    let projection_indexed = index
+        .members()
+        .iter()
+        .find(|member| member.logical_path() == RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER);
+    if indexed.length() != encoded_payload_size {
+        return Err(RusticolError::artifact(format!(
+            "direct recurrence PACBIN plan length differs from the streamed payload: encoded={encoded_payload_size}, indexed={}",
+            indexed.length()
+        )));
+    }
+    Ok(RecurrenceDirectPacbinMetadata {
+        container_size: index.file_size(),
+        member_count: index.members().len() as u64,
+        unpacked_size_bytes: index.members().iter().map(|member| member.length()).sum(),
+        index_sha256: *index.index_sha256(),
+        plan_payload_size: indexed.length(),
+        plan_sha256: *indexed.sha256(),
+        projection_certificate_payload_size: projection_indexed.map(|member| member.length()),
+        projection_certificate_sha256: projection_indexed.map(|member| *member.sha256()),
+    })
+}
+
+fn validate_projection_certificate_body(body: &[u8]) -> RusticolResult<()> {
+    let minimum = COLOR_PROJECTION_CERTIFICATE_BODY_MAGIC.len() + 4 + 32;
+    if body.len() < minimum
+        || !body.starts_with(COLOR_PROJECTION_CERTIFICATE_BODY_MAGIC)
+        || body[COLOR_PROJECTION_CERTIFICATE_BODY_MAGIC.len()
+            ..COLOR_PROJECTION_CERTIFICATE_BODY_MAGIC.len() + 4]
+            != 1_u32.to_le_bytes()
+    {
+        return Err(RusticolError::integrity(
+            "recurrence color-projection certificate body has invalid framing",
+        ));
+    }
+    let digest_start = body.len() - 32;
+    let actual: [u8; 32] = Sha256::digest(&body[..digest_start]).into();
+    if body[digest_start..] != actual {
+        return Err(RusticolError::integrity(
+            "recurrence color-projection certificate body digest mismatch",
+        ));
+    }
+    Ok(())
+}
+
+pub(crate) fn validate_recurrence_color_projection_certificate(
+    payload: &[u8],
+) -> RusticolResult<()> {
+    validate_projection_certificate_body(payload)
+}
+
+pub fn load_recurrence_direct_plan_pacbin(
+    source: impl AsRef<Path>,
+) -> RusticolResult<DirectRecurrencePlan> {
+    let reader = PacbinReader::open(source)?;
+    if !matches!(reader.members().len(), 1 | 2) {
+        return Err(RusticolError::compatibility(format!(
+            "direct recurrence PACBIN must contain one plan and at most one projection certificate, found {} members",
+            reader.members().len()
+        )));
+    }
+    let member = reader
+        .member(RECURRENCE_DIRECT_SCHEDULE_MEMBER)
+        .map_err(|_| {
+            RusticolError::compatibility(
+                "unsupported recurrence payload; regenerate with direct-plan v2",
+            )
+        })?;
+    if member.kind() != PacbinMemberKind::RecurrenceDirectPlan {
+        return Err(RusticolError::compatibility(
+            "direct recurrence plan has the wrong PACBIN member kind",
+        ));
+    }
+    if reader.members().len() == 2 {
+        let certificate = reader
+            .member(RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER)
+            .map_err(|_| {
+                RusticolError::compatibility(
+                    "direct recurrence PACBIN has an unsupported second member",
+                )
+            })?;
+        if certificate.kind() != PacbinMemberKind::RecurrenceColorProjectionCertificate {
+            return Err(RusticolError::compatibility(
+                "recurrence color-projection certificate has the wrong PACBIN member kind",
+            ));
+        }
+        validate_recurrence_color_projection_certificate(
+            reader.member_bytes(RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER)?,
+        )?;
+    }
+    decode_recurrence_direct_plan_v2(reader.member_bytes(RECURRENCE_DIRECT_SCHEDULE_MEMBER)?)
+}
+
+#[cfg(test)]
+#[path = "direct_pacbin_tests.rs"]
+mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_pacbin_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_pacbin_tests.rs
new file mode 100644
index 0000000000..6fae5979d2
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_pacbin_tests.rs
@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::fs;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use sha2::{Digest, Sha256};
+
+use super::*;
+use crate::pacbin::{
+    PacbinMemberKind, PacbinReader, PacbinWriteMember, PacbinWriteOptions, write_pacbin_atomic,
+};
+use crate::recurrence::direct_plan::tests::valid_plan;
+
+fn temporary_directory(label: &str) -> std::path::PathBuf {
+    static NEXT: AtomicU64 = AtomicU64::new(0);
+    let module = module_path!().replace("::", "-");
+    let path = std::env::temp_dir().join(format!(
+        "rusticol-recurrence-direct-{module}-{label}-{}-{}",
+        std::process::id(),
+        NEXT.fetch_add(1, Ordering::Relaxed)
+    ));
+    fs::create_dir(&path).unwrap();
+    path
+}
+
+fn projection_certificate() -> Vec<u8> {
+    let mut body = COLOR_PROJECTION_CERTIFICATE_BODY_MAGIC.to_vec();
+    body.extend_from_slice(&1_u32.to_le_bytes());
+    body.extend_from_slice(b"deterministic-structural-proof");
+    let digest: [u8; 32] = Sha256::digest(&body).into();
+    body.extend_from_slice(&digest);
+    body
+}
+
+#[test]
+fn direct_pacbin_round_trips_with_one_aligned_indexed_member() {
+    let directory = temporary_directory("roundtrip");
+    let path = directory.join("recurrence-runtime.pacbin");
+    let plan = valid_plan();
+    let metadata = write_recurrence_direct_plan_pacbin(&path, &plan).unwrap();
+    assert_eq!(load_recurrence_direct_plan_pacbin(&path).unwrap(), plan);
+
+    let reader = PacbinReader::open(&path).unwrap();
+    let member = reader.member(RECURRENCE_DIRECT_SCHEDULE_MEMBER).unwrap();
+    assert_eq!(member.kind(), PacbinMemberKind::RecurrenceDirectPlan);
+    assert_eq!(member.offset() % 64, 0);
+    assert_eq!(member.length(), metadata.plan_payload_size);
+    assert_eq!(member.sha256(), &metadata.plan_sha256);
+    assert_eq!(
+        reader
+            .member_range(RECURRENCE_DIRECT_SCHEDULE_MEMBER, 0, 8)
+            .unwrap(),
+        b"PACRDAP2"
+    );
+    let retained: Vec<_> = fs::read_dir(&directory)
+        .unwrap()
+        .map(|entry| entry.unwrap().file_name())
+        .collect();
+    assert_eq!(
+        retained,
+        [std::ffi::OsString::from("recurrence-runtime.pacbin")]
+    );
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn direct_pacbin_is_deterministic() {
+    let directory = temporary_directory("deterministic");
+    let first = directory.join("first.pacbin");
+    let second = directory.join("second.pacbin");
+    write_recurrence_direct_plan_pacbin(&first, &valid_plan()).unwrap();
+    write_recurrence_direct_plan_pacbin(&second, &valid_plan()).unwrap();
+    assert_eq!(fs::read(&first).unwrap(), fs::read(&second).unwrap());
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn direct_pacbin_removes_the_streaming_temporary_payload_on_error() {
+    let directory = temporary_directory("stream-cleanup");
+    let path = directory.join("recurrence-runtime.pacbin");
+    let error = write_recurrence_direct_plan_pacbin_with_projection_certificate(
+        &path,
+        &valid_plan(),
+        Some(b"invalid certificate"),
+    )
+    .unwrap_err();
+    assert!(error.to_string().contains("certificate"));
+    assert_eq!(fs::read_dir(&directory).unwrap().count(), 0);
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn direct_pacbin_round_trips_with_a_structural_projection_certificate() {
+    let directory = temporary_directory("projection-certificate");
+    let path = directory.join("recurrence-runtime.pacbin");
+    let plan = valid_plan();
+    let certificate = projection_certificate();
+    let metadata = write_recurrence_direct_plan_pacbin_with_projection_certificate(
+        &path,
+        &plan,
+        Some(&certificate),
+    )
+    .unwrap();
+    assert_eq!(metadata.member_count, 2);
+    assert_eq!(
+        metadata.projection_certificate_payload_size,
+        Some(certificate.len() as u64)
+    );
+    assert_eq!(load_recurrence_direct_plan_pacbin(&path).unwrap(), plan);
+    let reader = PacbinReader::open(&path).unwrap();
+    let member = reader
+        .member(RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER)
+        .unwrap();
+    assert_eq!(
+        member.kind(),
+        PacbinMemberKind::RecurrenceColorProjectionCertificate
+    );
+    assert_eq!(
+        reader
+            .member_bytes(RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER)
+            .unwrap(),
+        certificate
+    );
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn direct_pacbin_rejects_a_corrupt_projection_certificate() {
+    let directory = temporary_directory("projection-certificate-corrupt");
+    let path = directory.join("recurrence-runtime.pacbin");
+    let payload = encode_recurrence_direct_plan_v2(&valid_plan()).unwrap();
+    let mut certificate = projection_certificate();
+    certificate[COLOR_PROJECTION_CERTIFICATE_BODY_MAGIC.len() + 12] ^= 1;
+    write_pacbin_atomic(
+        &path,
+        [
+            PacbinWriteMember::from_bytes(
+                RECURRENCE_DIRECT_SCHEDULE_MEMBER,
+                PacbinMemberKind::RecurrenceDirectPlan,
+                &payload,
+            )
+            .unwrap(),
+            PacbinWriteMember::from_bytes(
+                RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER,
+                PacbinMemberKind::RecurrenceColorProjectionCertificate,
+                &certificate,
+            )
+            .unwrap(),
+        ],
+        PacbinWriteOptions::default(),
+    )
+    .unwrap();
+    assert!(load_recurrence_direct_plan_pacbin(&path).is_err());
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn direct_pacbin_rejects_truncation_and_payload_corruption() {
+    let directory = temporary_directory("corruption");
+    let path = directory.join("recurrence-runtime.pacbin");
+    write_recurrence_direct_plan_pacbin(&path, &valid_plan()).unwrap();
+    let original = fs::read(&path).unwrap();
+
+    fs::write(&path, &original[..original.len() - 1]).unwrap();
+    assert!(load_recurrence_direct_plan_pacbin(&path).is_err());
+
+    fs::write(&path, &original).unwrap();
+    let reader = PacbinReader::open(&path).unwrap();
+    let payload_offset = usize::try_from(
+        reader
+            .member(RECURRENCE_DIRECT_SCHEDULE_MEMBER)
+            .unwrap()
+            .offset(),
+    )
+    .unwrap();
+    drop(reader);
+    let mut corrupted = original;
+    corrupted[payload_offset + 20] ^= 1;
+    fs::write(&path, corrupted).unwrap();
+    assert!(load_recurrence_direct_plan_pacbin(&path).is_err());
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn direct_pacbin_rejects_old_v1_path_without_aliasing() {
+    let directory = temporary_directory("old-path");
+    let path = directory.join("recurrence-runtime.pacbin");
+    let payload = encode_recurrence_direct_plan_v2(&valid_plan()).unwrap();
+    write_pacbin_atomic(
+        &path,
+        [PacbinWriteMember::from_bytes(
+            "plan/recurrence-plan-v1.bin",
+            PacbinMemberKind::RecurrenceDirectPlan,
+            &payload,
+        )
+        .unwrap()],
+        PacbinWriteOptions::default(),
+    )
+    .unwrap();
+    let error = load_recurrence_direct_plan_pacbin(&path).unwrap_err();
+    assert!(error.to_string().contains("regenerate with direct-plan v2"));
+    fs::remove_dir_all(directory).unwrap();
+}
+
+#[test]
+fn direct_pacbin_rejects_wrong_member_kind_and_extra_members() {
+    let directory = temporary_directory("allowlist");
+    let path = directory.join("recurrence-runtime.pacbin");
+    let payload = encode_recurrence_direct_plan_v2(&valid_plan()).unwrap();
+    write_pacbin_atomic(
+        &path,
+        [PacbinWriteMember::from_bytes(
+            RECURRENCE_DIRECT_SCHEDULE_MEMBER,
+            PacbinMemberKind::EagerRuntimeTable,
+            &payload,
+        )
+        .unwrap()],
+        PacbinWriteOptions::default(),
+    )
+    .unwrap();
+    assert!(
+        load_recurrence_direct_plan_pacbin(&path)
+            .unwrap_err()
+            .to_string()
+            .contains("wrong PACBIN member kind")
+    );
+
+    write_pacbin_atomic(
+        &path,
+        [
+            PacbinWriteMember::from_bytes(
+                RECURRENCE_DIRECT_SCHEDULE_MEMBER,
+                PacbinMemberKind::RecurrenceDirectPlan,
+                &payload,
+            )
+            .unwrap(),
+            PacbinWriteMember::from_bytes(
+                "metadata/extra.bin",
+                PacbinMemberKind::EagerRuntimeMetadata,
+                b"unexpected",
+            )
+            .unwrap(),
+        ],
+        PacbinWriteOptions::default(),
+    )
+    .unwrap();
+    assert!(
+        load_recurrence_direct_plan_pacbin(&path)
+            .unwrap_err()
+            .to_string()
+            .contains("unsupported second member")
+    );
+    fs::remove_dir_all(directory).unwrap();
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_plan.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_plan.rs
new file mode 100644
index 0000000000..8fd1d13fa1
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_plan.rs
@@ -0,0 +1,2424 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Immutable direct-arena recurrence plan.
+//!
+//! Semantic current IDs are deliberately distinct from physical arena
+//! component ranges. The latter may be reused after interval coloring.
+
+use std::collections::BTreeSet;
+
+use sha2::{Digest, Sha256};
+
+use super::{
+    ClosureProofMetadataV2, ExactComplexRational, RecurrenceStrategy, SemanticDigest,
+    closure_component_factor_digest_v2, closure_selector_domain_digest_v2,
+};
+use crate::{RusticolError, RusticolResult};
+
+pub const RECURRENCE_DIRECT_PLAN_ABI: &str = "pyamplicol-recurrence-plan-v2";
+pub const RECURRENCE_DIRECT_RUNTIME_LAYOUT_ABI: &str = "pyamplicol-recurrence-runtime-layout-v2";
+pub const RECURRENCE_DIRECT_TEMPLATE_ABI: &str = "pyamplicol-recurrence-direct-template-v1";
+pub const RECURRENCE_DIRECT_RUNTIME_CAPABILITY: &str =
+    "rusticol.recurrence-direct-arena.complex-f64.v1";
+pub const DIRECT_NONE_U32: u32 = u32::MAX;
+pub const DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION: u32 = 1 << 0;
+/// The row scale-copies a certified representative current. For these rows
+/// `parent0_momentum_form_id` stores the component count; no momentum is read.
+pub const DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE: u32 = 1 << 1;
+const DIRECT_CONTRIBUTION_FLAGS_KNOWN: u32 =
+    DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION | DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE;
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(format!("recurrence direct plan: {}", message.into()))
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u16)]
+pub enum DirectNodeKind {
+    Source = 0,
+    Current = 1,
+}
+
+impl TryFrom<u16> for DirectNodeKind {
+    type Error = RusticolError;
+
+    fn try_from(value: u16) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Source),
+            1 => Ok(Self::Current),
+            _ => Err(invalid(format!("unknown node-kind discriminant {value}"))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, bincode::Encode, bincode::Decode)]
+#[repr(u16)]
+pub enum DirectExecutorRole {
+    Source = 0,
+    Contribution = 1,
+    Finalization = 2,
+    Closure = 3,
+}
+
+impl TryFrom<u16> for DirectExecutorRole {
+    type Error = RusticolError;
+
+    fn try_from(value: u16) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Source),
+            1 => Ok(Self::Contribution),
+            2 => Ok(Self::Finalization),
+            3 => Ok(Self::Closure),
+            _ => Err(invalid(format!(
+                "unknown direct-executor-role discriminant {value}"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u16)]
+pub enum DirectDestinationOperation {
+    Initialize = 0,
+    Add = 1,
+    FinalizeInPlace = 2,
+    ClosureAdd = 3,
+}
+
+impl TryFrom<u16> for DirectDestinationOperation {
+    type Error = RusticolError;
+
+    fn try_from(value: u16) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Initialize),
+            1 => Ok(Self::Add),
+            2 => Ok(Self::FinalizeInPlace),
+            3 => Ok(Self::ClosureAdd),
+            _ => Err(invalid(format!(
+                "unknown destination-operation discriminant {value}"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectCurrentDescriptor {
+    pub semantic_current_id: u32,
+    pub node_kind: DirectNodeKind,
+    pub state_template_id: u32,
+    pub component_base: u32,
+    pub component_count: u16,
+    pub momentum_form_id: u32,
+    pub stage: u16,
+    pub selector_domain_id: u32,
+    pub first_use: u32,
+    pub last_use: u32,
+    pub source_row_or_sentinel: u32,
+    pub finalization_row_or_sentinel: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, bincode::Encode, bincode::Decode)]
+#[repr(C)]
+pub struct DirectSourceRow {
+    pub source_slot: u32,
+    pub destination_component_base: u32,
+    pub momentum_form_id: u32,
+    pub source_template_or_dispatch_domain: u32,
+    pub spin_state_class: i32,
+    pub exact_factor_id: u32,
+    pub selector_domain_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, bincode::Encode, bincode::Decode)]
+#[repr(C)]
+pub struct DirectContributionRow {
+    pub parent0_component_base: u32,
+    pub parent1_component_base_or_sentinel: u32,
+    pub parent0_momentum_form_id: u32,
+    pub parent1_momentum_form_id_or_sentinel: u32,
+    pub destination_component_base: u32,
+    pub exact_factor_id: u32,
+    pub selector_domain_id: u32,
+    pub flags: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, bincode::Encode, bincode::Decode)]
+#[repr(C)]
+pub struct DirectFinalizationRow {
+    pub component_base: u32,
+    pub component_count: u16,
+    pub momentum_form_id: u32,
+    pub exact_factor_id: u32,
+    pub selector_domain_id: u32,
+    pub flags: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, bincode::Encode, bincode::Decode)]
+#[repr(C)]
+pub struct DirectClosureRow {
+    pub parent0_component_base: u32,
+    pub parent1_component_base_or_sentinel: u32,
+    pub parent0_momentum_form_id: u32,
+    pub parent1_momentum_form_id_or_sentinel: u32,
+    pub amplitude_destination_id: u32,
+    pub exact_factor_id: u32,
+    pub component_factor_start: u32,
+    pub component_count: u16,
+    pub selector_domain_id: u32,
+    /// Cold closure-proof group ID. Runtime executors deliberately ignore it.
+    ///
+    /// This occupies the former unused closure flags word, preserving the
+    /// native 40-byte row layout.
+    pub flags: u32,
+}
+
+impl DirectClosureRow {
+    pub const fn proof_group_id(&self) -> u32 {
+        self.flags
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectRowGroupDescriptor {
+    pub stage: u16,
+    pub role: DirectExecutorRole,
+    pub destination_operation: DirectDestinationOperation,
+    pub direct_executor_id: u32,
+    pub row_start: u64,
+    pub row_count: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectMomentumFormDescriptor {
+    pub term_start: u64,
+    pub term_count: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectMomentumTerm {
+    pub source_slot: u32,
+    pub coefficient: i32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectSelectorDomainDescriptor {
+    pub word_start: u64,
+    pub word_count: u32,
+}
+
+/// Auditable amount of persisted direct work active for one physical sector.
+///
+/// Topology-replay artifacts retain one union plan so public flows can share
+/// currents.  These counters make the distinction between that persisted
+/// union and the rows actually executed by a selected-flow call explicit.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct DirectSelectorWorkSummary {
+    pub physical_sector_id: u32,
+    pub current_count: u64,
+    pub semantic_component_count: u64,
+    pub source_row_count: u64,
+    pub contribution_count: u64,
+    pub finalization_count: u64,
+    pub closure_count: u64,
+    pub amplitude_destination_count: u64,
+}
+
+impl DirectSelectorWorkSummary {
+    pub const fn row_count(&self) -> u64 {
+        self.source_row_count
+            + self.contribution_count
+            + self.finalization_count
+            + self.closure_count
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectReplayTargetDescriptor {
+    pub public_flow_id: u32,
+    pub representative_id: u32,
+    pub source_permutation_start: u64,
+    pub source_permutation_count: u32,
+    pub helicity_map_start: u64,
+    pub helicity_map_count: u32,
+    pub phase_exact_factor_id: u32,
+    pub multiplicity: u32,
+    pub selector_domain_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectAmplitudeDestinationDescriptor {
+    pub closure_row_start: u64,
+    pub id: u32,
+    pub target_sector_id: u32,
+    pub target_helicity_id_or_sentinel: u32,
+    pub closure_row_count: u32,
+    pub selector_domain_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectResolvedHelicityDescriptor {
+    pub source_state_start: u64,
+    pub source_selection_start: u64,
+    pub public_helicity_start: u64,
+    pub id: u32,
+    pub source_state_count: u32,
+    pub source_selection_count: u32,
+    pub public_helicity_count: u32,
+    pub selector_domain_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectSourceStateAssignment {
+    pub source_slot: u32,
+    pub state_index: u32,
+}
+
+/// One concrete process-bound source variant referenced by resolved helicities.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectSourceDispatchVariantDescriptor {
+    pub embedding_start: u64,
+    pub projection_start: u64,
+    pub source_row_id: u32,
+    pub dispatch_domain_id: u32,
+    pub runtime_variant_id: u32,
+    pub source_state_index: u32,
+    pub source_template_id: u32,
+    pub source_state_template_id: u32,
+    pub crossed_state_template_id: u32,
+    pub crossed_spin_state_class: i32,
+    pub direct_executor_id: u32,
+    pub crossing_exact_factor_id: u32,
+    pub embedding_count: u32,
+    pub projection_count: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectSourceEmbeddingRow {
+    pub full_component: u32,
+    pub source_component_or_sentinel: u32,
+    pub exact_factor_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectSourceProjectionRow {
+    pub source_component: u32,
+    pub full_component: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub struct DirectResolvedSourceSelection {
+    pub source_slot: u32,
+    pub dispatch_variant_id: u32,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DirectRecurrencePlanParts {
+    pub strategy: RecurrenceStrategy,
+    pub semantic_digest: SemanticDigest,
+    pub prepared_pack_digest: SemanticDigest,
+    pub direct_template_catalog_digest: SemanticDigest,
+    pub point_tile_size: u32,
+    pub workspace_mib: u32,
+    pub current_arena_components: u32,
+    pub physical_sector_count: u32,
+    pub retained_helicity_count: u64,
+    pub amplitude_destination_count: u32,
+    pub parameter_value_count: u32,
+    pub external_source_count: u32,
+    pub state_template_count: u32,
+    pub source_template_count: u32,
+    pub source_template_or_dispatch_count: u32,
+    pub runtime_helicity_contract_count: u32,
+    pub runtime_helicity_variant_count: u32,
+    pub direct_executor_count: u32,
+    pub currents: Vec<DirectCurrentDescriptor>,
+    pub sources: Vec<DirectSourceRow>,
+    pub contributions: Vec<DirectContributionRow>,
+    pub finalizations: Vec<DirectFinalizationRow>,
+    pub closures: Vec<DirectClosureRow>,
+    pub row_groups: Vec<DirectRowGroupDescriptor>,
+    pub momentum_forms: Vec<DirectMomentumFormDescriptor>,
+    pub momentum_terms: Vec<DirectMomentumTerm>,
+    pub selector_domains: Vec<DirectSelectorDomainDescriptor>,
+    pub selector_words: Vec<u64>,
+    pub replay_targets: Vec<DirectReplayTargetDescriptor>,
+    pub source_permutations: Vec<u32>,
+    pub replay_momentum_signs: Vec<i32>,
+    pub replay_helicity_map: Vec<u32>,
+    pub amplitude_destinations: Vec<DirectAmplitudeDestinationDescriptor>,
+    pub resolved_helicities: Vec<DirectResolvedHelicityDescriptor>,
+    pub source_state_assignments: Vec<DirectSourceStateAssignment>,
+    pub source_dispatch_variants: Vec<DirectSourceDispatchVariantDescriptor>,
+    pub source_embeddings: Vec<DirectSourceEmbeddingRow>,
+    pub source_projections: Vec<DirectSourceProjectionRow>,
+    pub resolved_source_selections: Vec<DirectResolvedSourceSelection>,
+    pub public_helicities: Vec<i32>,
+    pub exact_factors: Vec<ExactComplexRational>,
+    pub closure_proofs: ClosureProofMetadataV2,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DirectRecurrencePlan {
+    parts: DirectRecurrencePlanParts,
+    runtime_layout_digest: SemanticDigest,
+    closure_proof_rows_retained: bool,
+}
+
+fn selector_domain_contains_parts(
+    parts: &DirectRecurrencePlanParts,
+    selector_domain_id: u32,
+    physical_sector_id: u32,
+) -> RusticolResult<bool> {
+    if physical_sector_id >= parts.physical_sector_count {
+        return Err(invalid("physical selector sector is out of bounds"));
+    }
+    let descriptor = parts
+        .selector_domains
+        .get(selector_domain_id as usize)
+        .ok_or_else(|| invalid("selector domain is absent"))?;
+    let start = usize::try_from(descriptor.word_start)
+        .map_err(|_| invalid("selector-domain word start exceeds usize"))?;
+    let end = start
+        .checked_add(descriptor.word_count as usize)
+        .ok_or_else(|| invalid("selector-domain word range overflows usize"))?;
+    let words = parts
+        .selector_words
+        .get(start..end)
+        .ok_or_else(|| invalid("selector-domain word range is out of bounds"))?;
+    if words == [u64::MAX] {
+        return Ok(true);
+    }
+    let word = physical_sector_id as usize / u64::BITS as usize;
+    let bit = physical_sector_id % u64::BITS;
+    Ok(words
+        .get(word)
+        .is_some_and(|value| value & (1_u64 << bit) != 0))
+}
+
+impl DirectRecurrencePlan {
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    pub fn new(mut parts: DirectRecurrencePlanParts) -> RusticolResult<Self> {
+        #[cfg(feature = "on-the-fly-test-support")]
+        super::on_the_fly::reject_forbidden_work_if_probed(
+            super::on_the_fly::OnTheFlyForbiddenWorkV1::DirectPlanMaterialization,
+        )?;
+        canonicalize_contribution_initialization(&mut parts)?;
+        validate_parts(&parts)?;
+        let runtime_layout_digest = digest_parts(&parts)?;
+        Ok(Self {
+            parts,
+            runtime_layout_digest,
+            closure_proof_rows_retained: true,
+        })
+    }
+
+    pub(crate) fn into_runtime_compacted(mut self) -> Self {
+        self.parts.closure_proofs.discard_rows_for_runtime();
+        self.closure_proof_rows_retained = false;
+        self
+    }
+
+    pub(crate) fn ensure_serializable(&self) -> RusticolResult<()> {
+        if !self.closure_proof_rows_retained {
+            return Err(invalid(
+                "runtime-compacted plan cannot be serialized without closure-proof rows",
+            ));
+        }
+        Ok(())
+    }
+
+    pub const fn strategy(&self) -> RecurrenceStrategy {
+        self.parts.strategy
+    }
+
+    pub const fn semantic_digest(&self) -> SemanticDigest {
+        self.parts.semantic_digest
+    }
+
+    pub const fn prepared_pack_digest(&self) -> SemanticDigest {
+        self.parts.prepared_pack_digest
+    }
+
+    pub const fn direct_template_catalog_digest(&self) -> SemanticDigest {
+        self.parts.direct_template_catalog_digest
+    }
+
+    pub const fn runtime_layout_digest(&self) -> SemanticDigest {
+        self.runtime_layout_digest
+    }
+
+    pub const fn point_tile_size(&self) -> u32 {
+        self.parts.point_tile_size
+    }
+
+    pub const fn workspace_mib(&self) -> u32 {
+        self.parts.workspace_mib
+    }
+
+    pub const fn current_arena_components(&self) -> u32 {
+        self.parts.current_arena_components
+    }
+
+    pub const fn physical_sector_count(&self) -> u32 {
+        self.parts.physical_sector_count
+    }
+
+    pub const fn retained_helicity_count(&self) -> u64 {
+        self.parts.retained_helicity_count
+    }
+
+    pub const fn amplitude_destination_count(&self) -> u32 {
+        self.parts.amplitude_destination_count
+    }
+
+    pub const fn parameter_value_count(&self) -> u32 {
+        self.parts.parameter_value_count
+    }
+
+    pub const fn external_source_count(&self) -> u32 {
+        self.parts.external_source_count
+    }
+
+    pub const fn state_template_count(&self) -> u32 {
+        self.parts.state_template_count
+    }
+
+    pub const fn source_template_count(&self) -> u32 {
+        self.parts.source_template_count
+    }
+
+    pub const fn source_template_or_dispatch_count(&self) -> u32 {
+        self.parts.source_template_or_dispatch_count
+    }
+
+    pub const fn runtime_helicity_contract_count(&self) -> u32 {
+        self.parts.runtime_helicity_contract_count
+    }
+
+    pub const fn runtime_helicity_variant_count(&self) -> u32 {
+        self.parts.runtime_helicity_variant_count
+    }
+
+    pub const fn direct_executor_count(&self) -> u32 {
+        self.parts.direct_executor_count
+    }
+
+    pub fn currents(&self) -> &[DirectCurrentDescriptor] {
+        &self.parts.currents
+    }
+
+    pub fn sources(&self) -> &[DirectSourceRow] {
+        &self.parts.sources
+    }
+
+    pub fn contributions(&self) -> &[DirectContributionRow] {
+        &self.parts.contributions
+    }
+
+    pub fn finalizations(&self) -> &[DirectFinalizationRow] {
+        &self.parts.finalizations
+    }
+
+    pub fn closures(&self) -> &[DirectClosureRow] {
+        &self.parts.closures
+    }
+
+    pub fn row_groups(&self) -> &[DirectRowGroupDescriptor] {
+        &self.parts.row_groups
+    }
+
+    pub fn momentum_forms(&self) -> &[DirectMomentumFormDescriptor] {
+        &self.parts.momentum_forms
+    }
+
+    pub fn momentum_terms(&self) -> &[DirectMomentumTerm] {
+        &self.parts.momentum_terms
+    }
+
+    pub fn selector_domains(&self) -> &[DirectSelectorDomainDescriptor] {
+        &self.parts.selector_domains
+    }
+
+    pub fn selector_words(&self) -> &[u64] {
+        &self.parts.selector_words
+    }
+
+    /// Return whether one physical selector bit belongs to a persisted domain.
+    ///
+    /// Direct-plan-v2 artifacts produced before selector-aware lowering used
+    /// one literal `[u64::MAX]` domain for every row, even when a process had
+    /// more than 64 physical sectors.  Preserve that encoding as the
+    /// backwards-compatible universal domain while allowing newer plans to
+    /// persist ordinary multiword sector masks.
+    pub fn selector_domain_contains(
+        &self,
+        selector_domain_id: u32,
+        physical_sector_id: u32,
+    ) -> RusticolResult<bool> {
+        selector_domain_contains_parts(&self.parts, selector_domain_id, physical_sector_id)
+    }
+
+    /// Count the persisted currents and executor rows active for one sector.
+    ///
+    /// This is derived only from authenticated plan tables and therefore forms
+    /// a compact structural certificate for selected-flow pruning.
+    pub fn selector_work_summary(
+        &self,
+        physical_sector_id: u32,
+    ) -> RusticolResult<DirectSelectorWorkSummary> {
+        if physical_sector_id >= self.parts.physical_sector_count {
+            return Err(invalid("physical selector sector is out of bounds"));
+        }
+        let mut summary = DirectSelectorWorkSummary {
+            physical_sector_id,
+            ..DirectSelectorWorkSummary::default()
+        };
+        for current in &self.parts.currents {
+            if self.selector_domain_contains(current.selector_domain_id, physical_sector_id)? {
+                summary.current_count = summary
+                    .current_count
+                    .checked_add(1)
+                    .ok_or_else(|| invalid("selector current count overflows u64"))?;
+                summary.semantic_component_count = summary
+                    .semantic_component_count
+                    .checked_add(u64::from(current.component_count))
+                    .ok_or_else(|| invalid("selector semantic component count overflows u64"))?;
+            }
+        }
+        for row in &self.parts.sources {
+            if self.selector_domain_contains(row.selector_domain_id, physical_sector_id)? {
+                summary.source_row_count += 1;
+            }
+        }
+        for row in &self.parts.contributions {
+            if self.selector_domain_contains(row.selector_domain_id, physical_sector_id)? {
+                summary.contribution_count += 1;
+            }
+        }
+        for row in &self.parts.finalizations {
+            if self.selector_domain_contains(row.selector_domain_id, physical_sector_id)? {
+                summary.finalization_count += 1;
+            }
+        }
+        for row in &self.parts.closures {
+            if self.selector_domain_contains(row.selector_domain_id, physical_sector_id)? {
+                summary.closure_count += 1;
+            }
+        }
+        for destination in &self.parts.amplitude_destinations {
+            if self.selector_domain_contains(destination.selector_domain_id, physical_sector_id)? {
+                summary.amplitude_destination_count += 1;
+            }
+        }
+        Ok(summary)
+    }
+
+    pub fn replay_targets(&self) -> &[DirectReplayTargetDescriptor] {
+        &self.parts.replay_targets
+    }
+
+    pub fn source_permutations(&self) -> &[u32] {
+        &self.parts.source_permutations
+    }
+
+    pub fn replay_momentum_signs(&self) -> &[i32] {
+        &self.parts.replay_momentum_signs
+    }
+
+    pub fn replay_helicity_map(&self) -> &[u32] {
+        &self.parts.replay_helicity_map
+    }
+
+    pub fn amplitude_destinations(&self) -> &[DirectAmplitudeDestinationDescriptor] {
+        &self.parts.amplitude_destinations
+    }
+
+    pub fn resolved_helicities(&self) -> &[DirectResolvedHelicityDescriptor] {
+        &self.parts.resolved_helicities
+    }
+
+    pub fn source_state_assignments(&self) -> &[DirectSourceStateAssignment] {
+        &self.parts.source_state_assignments
+    }
+
+    pub fn source_dispatch_variants(&self) -> &[DirectSourceDispatchVariantDescriptor] {
+        &self.parts.source_dispatch_variants
+    }
+
+    pub fn source_embeddings(&self) -> &[DirectSourceEmbeddingRow] {
+        &self.parts.source_embeddings
+    }
+
+    pub fn source_projections(&self) -> &[DirectSourceProjectionRow] {
+        &self.parts.source_projections
+    }
+
+    pub fn resolved_source_selections(&self) -> &[DirectResolvedSourceSelection] {
+        &self.parts.resolved_source_selections
+    }
+
+    pub fn public_helicities(&self) -> &[i32] {
+        &self.parts.public_helicities
+    }
+
+    pub fn exact_factors(&self) -> &[ExactComplexRational] {
+        &self.parts.exact_factors
+    }
+
+    pub const fn closure_proofs(&self) -> &ClosureProofMetadataV2 {
+        &self.parts.closure_proofs
+    }
+
+    pub fn into_parts(self) -> DirectRecurrencePlanParts {
+        assert!(
+            self.closure_proof_rows_retained,
+            "runtime-compacted DirectRecurrencePlan cannot be converted back into complete parts"
+        );
+        self.parts
+    }
+}
+
+fn canonicalize_contribution_initialization(
+    parts: &mut DirectRecurrencePlanParts,
+) -> RusticolResult<()> {
+    let current_by_stage_and_base = parts
+        .currents
+        .iter()
+        .filter(|current| current.node_kind == DirectNodeKind::Current)
+        .map(|current| {
+            (
+                (current.stage, current.component_base),
+                current.semantic_current_id,
+            )
+        })
+        .collect::<std::collections::BTreeMap<_, _>>();
+    let mut first_row_by_current = std::collections::BTreeMap::<u32, usize>::new();
+    let mut initialization_count_by_current = std::collections::BTreeMap::<u32, u32>::new();
+
+    for row_group in parts
+        .row_groups
+        .iter()
+        .filter(|row_group| row_group.role == DirectExecutorRole::Contribution)
+    {
+        let start = usize::try_from(row_group.row_start)
+            .map_err(|_| invalid("contribution row-group start exceeds usize"))?;
+        let Some(end) = start.checked_add(row_group.row_count as usize) else {
+            continue;
+        };
+        let Some(rows) = parts.contributions.get(start..end) else {
+            continue;
+        };
+        for (offset, row) in rows.iter().enumerate() {
+            let Some(current_id) = current_by_stage_and_base
+                .get(&(row_group.stage, row.destination_component_base))
+                .copied()
+            else {
+                continue;
+            };
+            first_row_by_current
+                .entry(current_id)
+                .or_insert(start + offset);
+            if row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0 {
+                *initialization_count_by_current
+                    .entry(current_id)
+                    .or_default() += 1;
+            }
+        }
+    }
+
+    for (current_id, row_index) in first_row_by_current {
+        if initialization_count_by_current
+            .get(&current_id)
+            .copied()
+            .unwrap_or(0)
+            == 0
+        {
+            parts.contributions[row_index].flags |= DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION;
+        }
+    }
+    Ok(())
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+#[cfg_attr(target_vendor = "apple", cold)]
+fn validate_parts(parts: &DirectRecurrencePlanParts) -> RusticolResult<()> {
+    if parts.point_tile_size == 0 {
+        return Err(invalid("point tile size must be positive"));
+    }
+    if parts.workspace_mib == 0 {
+        return Err(invalid("workspace MiB must be positive"));
+    }
+    if parts.current_arena_components == 0 {
+        return Err(invalid("current arena must contain at least one component"));
+    }
+    if parts.physical_sector_count == 0 {
+        return Err(invalid("plan must retain at least one physical LC sector"));
+    }
+    if parts.retained_helicity_count == 0 {
+        return Err(invalid("plan must retain at least one physical helicity"));
+    }
+    if parts.amplitude_destination_count == 0 {
+        return Err(invalid(
+            "plan must contain at least one amplitude destination",
+        ));
+    }
+    if usize::try_from(parts.amplitude_destination_count).ok()
+        != Some(parts.amplitude_destinations.len())
+    {
+        return Err(invalid(
+            "amplitude destination count does not match its descriptor catalog",
+        ));
+    }
+    if parts.external_source_count == 0 {
+        return Err(invalid("plan must contain at least one external source"));
+    }
+    for (label, count) in [
+        ("state templates", parts.state_template_count),
+        ("source templates", parts.source_template_count),
+        (
+            "source templates or dispatch domains",
+            parts.source_template_or_dispatch_count,
+        ),
+        ("direct executors", parts.direct_executor_count),
+    ] {
+        if count == 0 {
+            return Err(invalid(format!("{label} catalog must not be empty")));
+        }
+    }
+    if parts.strategy == RecurrenceStrategy::AllFlowUnion
+        && (parts.runtime_helicity_contract_count == 0 || parts.runtime_helicity_variant_count == 0)
+    {
+        return Err(invalid(
+            "all-flow-union requires runtime-helicity contracts and variants",
+        ));
+    }
+    if parts.momentum_forms.is_empty() {
+        return Err(invalid("plan must contain at least one momentum form"));
+    }
+    if parts.selector_domains.is_empty() {
+        return Err(invalid("plan must contain at least one selector domain"));
+    }
+    if parts.exact_factors.is_empty() {
+        return Err(invalid("plan must contain at least one exact factor"));
+    }
+    if parts.replay_momentum_signs.len() != parts.source_permutations.len()
+        || parts
+            .replay_momentum_signs
+            .iter()
+            .any(|sign| !matches!(sign, -1 | 1))
+    {
+        return Err(invalid(
+            "replay momentum signs must align one-to-one with source permutations",
+        ));
+    }
+
+    validate_ranges(
+        "momentum form",
+        parts
+            .momentum_forms
+            .iter()
+            .map(|row| (row.term_start, row.term_count)),
+        parts.momentum_terms.len(),
+        true,
+    )?;
+    validate_ranges(
+        "selector domain",
+        parts
+            .selector_domains
+            .iter()
+            .map(|row| (row.word_start, row.word_count)),
+        parts.selector_words.len(),
+        true,
+    )?;
+    validate_ranges(
+        "replay source permutation",
+        parts
+            .replay_targets
+            .iter()
+            .map(|row| (row.source_permutation_start, row.source_permutation_count)),
+        parts.source_permutations.len(),
+        true,
+    )?;
+    validate_ranges(
+        "replay helicity map",
+        parts
+            .replay_targets
+            .iter()
+            .map(|row| (row.helicity_map_start, row.helicity_map_count)),
+        parts.replay_helicity_map.len(),
+        true,
+    )?;
+    validate_ranges(
+        "amplitude destination closure",
+        parts
+            .amplitude_destinations
+            .iter()
+            .map(|row| (row.closure_row_start, row.closure_row_count)),
+        parts.closures.len(),
+        true,
+    )?;
+    validate_ranges(
+        "resolved-helicity source state",
+        parts
+            .resolved_helicities
+            .iter()
+            .map(|row| (row.source_state_start, row.source_state_count)),
+        parts.source_state_assignments.len(),
+        true,
+    )?;
+    validate_ranges(
+        "resolved-helicity source selection",
+        parts
+            .resolved_helicities
+            .iter()
+            .map(|row| (row.source_selection_start, row.source_selection_count)),
+        parts.resolved_source_selections.len(),
+        true,
+    )?;
+    validate_ranges(
+        "resolved-helicity public value",
+        parts
+            .resolved_helicities
+            .iter()
+            .map(|row| (row.public_helicity_start, row.public_helicity_count)),
+        parts.public_helicities.len(),
+        true,
+    )?;
+    validate_ranges(
+        "source dispatch embedding",
+        parts
+            .source_dispatch_variants
+            .iter()
+            .map(|row| (row.embedding_start, row.embedding_count)),
+        parts.source_embeddings.len(),
+        true,
+    )?;
+    validate_ranges(
+        "source dispatch projection",
+        parts
+            .source_dispatch_variants
+            .iter()
+            .map(|row| (row.projection_start, row.projection_count)),
+        parts.source_projections.len(),
+        true,
+    )?;
+
+    let momentum_count = u32_len("momentum forms", parts.momentum_forms.len())?;
+    let selector_count = u32_len("selector domains", parts.selector_domains.len())?;
+    let exact_factor_count = u32_len("exact factors", parts.exact_factors.len())?;
+    let finalization_count = u32_len("finalizations", parts.finalizations.len())?;
+    let resolved_helicity_count = u32_len("resolved helicities", parts.resolved_helicities.len())?;
+    let source_dispatch_variant_count = u32_len(
+        "source dispatch variants",
+        parts.source_dispatch_variants.len(),
+    )?;
+
+    let mut current_slots = BTreeSet::new();
+    let mut current_by_source_row = vec![None; parts.sources.len()];
+    let mut current_by_finalization_row = vec![None; parts.finalizations.len()];
+    for (index, current) in parts.currents.iter().enumerate() {
+        if current.semantic_current_id != index as u32 {
+            return Err(invalid(format!(
+                "current {index} has non-canonical semantic ID {}",
+                current.semantic_current_id
+            )));
+        }
+        if current.component_count == 0 {
+            return Err(invalid(format!("current {index} has zero components")));
+        }
+        require_ref(
+            "current state template",
+            current.state_template_id,
+            parts.state_template_count,
+        )?;
+        let end = current
+            .component_base
+            .checked_add(u32::from(current.component_count))
+            .ok_or_else(|| invalid(format!("current {index} component range overflows u32")))?;
+        if end > parts.current_arena_components {
+            return Err(invalid(format!(
+                "current {index} component range exceeds the arena"
+            )));
+        }
+        require_ref(
+            "current momentum form",
+            current.momentum_form_id,
+            momentum_count,
+        )?;
+        require_ref(
+            "current selector domain",
+            current.selector_domain_id,
+            selector_count,
+        )?;
+        if current.first_use > current.last_use {
+            return Err(invalid(format!(
+                "current {index} has an inverted liveness interval"
+            )));
+        }
+        if !current_slots.insert((current.stage, current.component_base)) {
+            return Err(invalid(format!(
+                "stage {} has duplicate current component base {}",
+                current.stage, current.component_base
+            )));
+        }
+        match current.node_kind {
+            DirectNodeKind::Source => {
+                if current.source_row_or_sentinel == DIRECT_NONE_U32 {
+                    return Err(invalid(format!("source current {index} has no source row")));
+                }
+                if current.finalization_row_or_sentinel != DIRECT_NONE_U32 {
+                    return Err(invalid(format!(
+                        "source current {index} must not have a finalization row"
+                    )));
+                }
+                let slot = current_by_source_row
+                    .get_mut(current.source_row_or_sentinel as usize)
+                    .ok_or_else(|| {
+                        invalid(format!("source current {index} row is out of bounds"))
+                    })?;
+                if slot.replace(index).is_some() {
+                    return Err(invalid(format!(
+                        "source row {} is referenced more than once",
+                        current.source_row_or_sentinel
+                    )));
+                }
+            }
+            DirectNodeKind::Current => {
+                if current.source_row_or_sentinel != DIRECT_NONE_U32 {
+                    return Err(invalid(format!(
+                        "propagated current {index} must not have a source row"
+                    )));
+                }
+                if current.finalization_row_or_sentinel != DIRECT_NONE_U32 {
+                    require_ref(
+                        "current finalization",
+                        current.finalization_row_or_sentinel,
+                        finalization_count,
+                    )?;
+                    let slot = current_by_finalization_row
+                        .get_mut(current.finalization_row_or_sentinel as usize)
+                        .expect("finalization reference was bounds checked");
+                    if slot.replace(index).is_some() {
+                        return Err(invalid(format!(
+                            "finalization row {} is referenced more than once",
+                            current.finalization_row_or_sentinel
+                        )));
+                    }
+                }
+            }
+        }
+    }
+    if current_by_source_row.iter().any(Option::is_none) {
+        return Err(invalid("not every source row is referenced exactly once"));
+    }
+    if current_by_finalization_row.iter().any(Option::is_none) {
+        return Err(invalid(
+            "not every finalization row is referenced exactly once",
+        ));
+    }
+    validate_arena_liveness(parts)?;
+
+    for (index, source) in parts.sources.iter().enumerate() {
+        require_ref(
+            "source external slot",
+            source.source_slot,
+            parts.external_source_count,
+        )?;
+        require_ref(
+            "source momentum form",
+            source.momentum_form_id,
+            momentum_count,
+        )?;
+        require_ref(
+            "source selector domain",
+            source.selector_domain_id,
+            selector_count,
+        )?;
+        require_ref(
+            "source exact factor",
+            source.exact_factor_id,
+            exact_factor_count,
+        )?;
+        require_ref(
+            "source template or dispatch domain",
+            source.source_template_or_dispatch_domain,
+            parts.source_template_or_dispatch_count,
+        )?;
+        let current = &parts.currents[current_by_source_row[index].expect("source row is bound")];
+        if source.destination_component_base != current.component_base
+            || source.momentum_form_id != current.momentum_form_id
+            || source.selector_domain_id != current.selector_domain_id
+        {
+            return Err(invalid(format!(
+                "source row {index} does not match its current descriptor"
+            )));
+        }
+    }
+    match parts.strategy {
+        RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion => {
+            if !parts.source_dispatch_variants.is_empty()
+                || !parts.source_embeddings.is_empty()
+                || !parts.source_projections.is_empty()
+                || !parts.resolved_source_selections.is_empty()
+            {
+                return Err(invalid(
+                    "fixed-source recurrence must not carry runtime source-dispatch tables",
+                ));
+            }
+        }
+        RecurrenceStrategy::AllFlowUnion => {
+            if parts.source_dispatch_variants.is_empty()
+                || parts.resolved_source_selections.is_empty()
+            {
+                return Err(invalid(
+                    "all-flow-union requires runtime source-dispatch tables",
+                ));
+            }
+        }
+    }
+    let mut source_variant_keys = BTreeSet::new();
+    let mut referenced_source_rows = BTreeSet::new();
+    for (index, variant) in parts.source_dispatch_variants.iter().enumerate() {
+        require_ref(
+            "source-dispatch source row",
+            variant.source_row_id,
+            u32_len("sources", parts.sources.len())?,
+        )?;
+        require_ref(
+            "source-dispatch domain",
+            variant.dispatch_domain_id,
+            parts.runtime_helicity_contract_count,
+        )?;
+        require_ref(
+            "source-dispatch runtime variant",
+            variant.runtime_variant_id,
+            parts.runtime_helicity_variant_count,
+        )?;
+        require_ref(
+            "source-dispatch concrete template",
+            variant.source_template_id,
+            parts.source_template_count,
+        )?;
+        require_ref(
+            "source-dispatch source state",
+            variant.source_state_template_id,
+            parts.state_template_count,
+        )?;
+        require_ref(
+            "source-dispatch crossed state",
+            variant.crossed_state_template_id,
+            parts.state_template_count,
+        )?;
+        require_ref(
+            "source-dispatch executor",
+            variant.direct_executor_id,
+            parts.direct_executor_count,
+        )?;
+        require_ref(
+            "source-dispatch crossing factor",
+            variant.crossing_exact_factor_id,
+            exact_factor_count,
+        )?;
+        if parts.exact_factors[variant.crossing_exact_factor_id as usize].is_zero() {
+            return Err(invalid(format!(
+                "source-dispatch variant {index} has a zero crossing factor"
+            )));
+        }
+        let source = &parts.sources[variant.source_row_id as usize];
+        if source.source_template_or_dispatch_domain != variant.dispatch_domain_id {
+            return Err(invalid(format!(
+                "source-dispatch variant {index} does not match source row {} domain",
+                variant.source_row_id
+            )));
+        }
+        let current = &parts.currents[current_by_source_row[variant.source_row_id as usize]
+            .expect("source-dispatch row is bound")];
+        if variant.embedding_count != u32::from(current.component_count) {
+            return Err(invalid(format!(
+                "source-dispatch variant {index} embedding does not cover its full current"
+            )));
+        }
+        let embedding_start = usize::try_from(variant.embedding_start)
+            .map_err(|_| invalid("source embedding start exceeds usize"))?;
+        let embedding_end = embedding_start
+            .checked_add(variant.embedding_count as usize)
+            .ok_or_else(|| invalid("source embedding range overflows usize"))?;
+        let projection_start = usize::try_from(variant.projection_start)
+            .map_err(|_| invalid("source projection start exceeds usize"))?;
+        let projection_end = projection_start
+            .checked_add(variant.projection_count as usize)
+            .ok_or_else(|| invalid("source projection range overflows usize"))?;
+        let embeddings = &parts.source_embeddings[embedding_start..embedding_end];
+        let projections = &parts.source_projections[projection_start..projection_end];
+        for (full_component, embedding) in embeddings.iter().enumerate() {
+            if embedding.full_component != full_component as u32 {
+                return Err(invalid(format!(
+                    "source-dispatch variant {index} embedding is not in full-component order"
+                )));
+            }
+            require_ref(
+                "source embedding factor",
+                embedding.exact_factor_id,
+                exact_factor_count,
+            )?;
+            let factor = parts.exact_factors[embedding.exact_factor_id as usize];
+            if (embedding.source_component_or_sentinel == DIRECT_NONE_U32) != factor.is_zero() {
+                return Err(invalid(format!(
+                    "source-dispatch variant {index} has inconsistent zero embedding"
+                )));
+            }
+            if embedding.source_component_or_sentinel != DIRECT_NONE_U32
+                && embedding.source_component_or_sentinel >= variant.projection_count
+            {
+                return Err(invalid(format!(
+                    "source-dispatch variant {index} embedding source component is out of bounds"
+                )));
+            }
+        }
+        for (source_component, projection) in projections.iter().enumerate() {
+            if projection.source_component != source_component as u32
+                || projection.full_component >= variant.embedding_count
+                || embeddings[projection.full_component as usize].source_component_or_sentinel
+                    != projection.source_component
+            {
+                return Err(invalid(format!(
+                    "source-dispatch variant {index} projection does not invert its embedding"
+                )));
+            }
+        }
+        if !source_variant_keys.insert((
+            source.source_slot,
+            variant.source_state_index,
+            variant.source_row_id,
+        )) {
+            return Err(invalid(format!(
+                "source-dispatch variant {index} repeats a source-state mapping"
+            )));
+        }
+        referenced_source_rows.insert(variant.source_row_id);
+    }
+    if parts.strategy == RecurrenceStrategy::AllFlowUnion
+        && referenced_source_rows.len() != parts.sources.len()
+    {
+        return Err(invalid(
+            "not every all-flow-union source row has dispatch variants",
+        ));
+    }
+    for (index, term) in parts.momentum_terms.iter().enumerate() {
+        if term.source_slot >= parts.external_source_count {
+            return Err(invalid(format!(
+                "momentum term {index} source slot is out of bounds"
+            )));
+        }
+        if term.coefficient == 0 {
+            return Err(invalid(format!(
+                "momentum term {index} has a zero coefficient"
+            )));
+        }
+    }
+
+    let arena_bases = parts
+        .currents
+        .iter()
+        .map(|current| current.component_base)
+        .collect::<BTreeSet<_>>();
+    for (index, row) in parts.contributions.iter().enumerate() {
+        if row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0 {
+            require_arena_base(
+                &arena_bases,
+                row.parent0_component_base,
+                "certified-reuse source",
+                index,
+            )?;
+            if row.parent1_component_base_or_sentinel != DIRECT_NONE_U32
+                || row.parent1_momentum_form_id_or_sentinel != DIRECT_NONE_U32
+            {
+                return Err(invalid(format!(
+                    "certified-reuse contribution {index} must not carry a second parent"
+                )));
+            }
+            if row.parent0_momentum_form_id == 0 {
+                return Err(invalid(format!(
+                    "certified-reuse contribution {index} has zero components"
+                )));
+            }
+            require_arena_base(
+                &arena_bases,
+                row.destination_component_base,
+                "certified-reuse destination",
+                index,
+            )?;
+            require_ref(
+                "certified-reuse exact factor",
+                row.exact_factor_id,
+                exact_factor_count,
+            )?;
+            require_ref(
+                "certified-reuse selector domain",
+                row.selector_domain_id,
+                selector_count,
+            )?;
+            let component_count = u16::try_from(row.parent0_momentum_form_id).map_err(|_| {
+                invalid(format!(
+                    "certified-reuse contribution {index} component count exceeds u16"
+                ))
+            })?;
+            if !parts.currents.iter().any(|current| {
+                current.component_base == row.parent0_component_base
+                    && current.component_count == component_count
+            }) || !parts.currents.iter().any(|current| {
+                current.component_base == row.destination_component_base
+                    && current.component_count == component_count
+            }) {
+                return Err(invalid(format!(
+                    "certified-reuse contribution {index} component count disagrees with its source or destination current"
+                )));
+            }
+            continue;
+        }
+        require_arena_base(
+            &arena_bases,
+            row.parent0_component_base,
+            "contribution parent 0",
+            index,
+        )?;
+        require_optional_pair(
+            row.parent1_component_base_or_sentinel,
+            row.parent1_momentum_form_id_or_sentinel,
+            "contribution parent 1",
+            index,
+        )?;
+        if row.parent1_component_base_or_sentinel != DIRECT_NONE_U32 {
+            require_arena_base(
+                &arena_bases,
+                row.parent1_component_base_or_sentinel,
+                "contribution parent 1",
+                index,
+            )?;
+            require_ref(
+                "contribution parent 1 momentum form",
+                row.parent1_momentum_form_id_or_sentinel,
+                momentum_count,
+            )?;
+        }
+        require_ref(
+            "contribution parent 0 momentum form",
+            row.parent0_momentum_form_id,
+            momentum_count,
+        )?;
+        require_arena_base(
+            &arena_bases,
+            row.destination_component_base,
+            "contribution destination",
+            index,
+        )?;
+        require_ref(
+            "contribution exact factor",
+            row.exact_factor_id,
+            exact_factor_count,
+        )?;
+        require_ref(
+            "contribution selector domain",
+            row.selector_domain_id,
+            selector_count,
+        )?;
+    }
+
+    for (index, row) in parts.finalizations.iter().enumerate() {
+        require_arena_base(
+            &arena_bases,
+            row.component_base,
+            "finalization component",
+            index,
+        )?;
+        if row.component_count == 0 {
+            return Err(invalid(format!("finalization {index} has zero components")));
+        }
+        require_ref(
+            "finalization momentum form",
+            row.momentum_form_id,
+            momentum_count,
+        )?;
+        require_ref(
+            "finalization exact factor",
+            row.exact_factor_id,
+            exact_factor_count,
+        )?;
+        require_ref(
+            "finalization selector domain",
+            row.selector_domain_id,
+            selector_count,
+        )?;
+        let current =
+            &parts.currents[current_by_finalization_row[index].expect("finalization row is bound")];
+        if row.component_base != current.component_base
+            || row.component_count != current.component_count
+            || row.momentum_form_id != current.momentum_form_id
+            || row.selector_domain_id != current.selector_domain_id
+        {
+            return Err(invalid(format!(
+                "finalization {index} does not match its current descriptor"
+            )));
+        }
+    }
+
+    for (index, row) in parts.closures.iter().enumerate() {
+        require_arena_base(
+            &arena_bases,
+            row.parent0_component_base,
+            "closure parent 0",
+            index,
+        )?;
+        require_optional_pair(
+            row.parent1_component_base_or_sentinel,
+            row.parent1_momentum_form_id_or_sentinel,
+            "closure parent 1",
+            index,
+        )?;
+        if row.parent1_component_base_or_sentinel != DIRECT_NONE_U32 {
+            require_arena_base(
+                &arena_bases,
+                row.parent1_component_base_or_sentinel,
+                "closure parent 1",
+                index,
+            )?;
+            require_ref(
+                "closure parent 1 momentum form",
+                row.parent1_momentum_form_id_or_sentinel,
+                momentum_count,
+            )?;
+        }
+        require_ref(
+            "closure parent 0 momentum form",
+            row.parent0_momentum_form_id,
+            momentum_count,
+        )?;
+        require_ref(
+            "closure exact factor",
+            row.exact_factor_id,
+            exact_factor_count,
+        )?;
+        if row.component_count == 0 {
+            return Err(invalid(format!(
+                "closure {index} has zero contraction components"
+            )));
+        }
+        let component_factor_end = row
+            .component_factor_start
+            .checked_add(u32::from(row.component_count))
+            .ok_or_else(|| {
+                invalid(format!(
+                    "closure {index} component-factor range overflows u32"
+                ))
+            })?;
+        if component_factor_end > exact_factor_count {
+            return Err(invalid(format!(
+                "closure {index} component-factor range is out of bounds"
+            )));
+        }
+        require_ref(
+            "closure selector domain",
+            row.selector_domain_id,
+            selector_count,
+        )?;
+        if row.amplitude_destination_id >= parts.amplitude_destination_count {
+            return Err(invalid(format!(
+                "closure {index} amplitude destination is out of bounds"
+            )));
+        }
+    }
+
+    for (index, target) in parts.replay_targets.iter().enumerate() {
+        require_ref(
+            "replay public flow",
+            target.public_flow_id,
+            parts.physical_sector_count,
+        )?;
+        require_ref(
+            "replay representative flow",
+            target.representative_id,
+            parts.physical_sector_count,
+        )?;
+        require_ref(
+            "replay phase exact factor",
+            target.phase_exact_factor_id,
+            exact_factor_count,
+        )?;
+        require_ref(
+            "replay selector domain",
+            target.selector_domain_id,
+            selector_count,
+        )?;
+        if !selector_domain_contains_parts(
+            parts,
+            target.selector_domain_id,
+            target.representative_id,
+        )? {
+            return Err(invalid(format!(
+                "replay target {index} selector domain excludes its representative sector"
+            )));
+        }
+        if target.multiplicity == 0 {
+            return Err(invalid(format!(
+                "replay target {index} has zero multiplicity"
+            )));
+        }
+        if target.source_permutation_count != parts.external_source_count {
+            return Err(invalid(format!(
+                "replay target {index} does not map every external source"
+            )));
+        }
+        let start = usize::try_from(target.source_permutation_start)
+            .map_err(|_| invalid("replay permutation start exceeds usize"))?;
+        let count = usize::try_from(target.source_permutation_count)
+            .map_err(|_| invalid("replay permutation count exceeds usize"))?;
+        let end = start
+            .checked_add(count)
+            .ok_or_else(|| invalid("replay permutation range overflows usize"))?;
+        let values = &parts.source_permutations[start..end];
+        let unique = values.iter().copied().collect::<BTreeSet<_>>();
+        let external_source_count = usize::try_from(parts.external_source_count)
+            .map_err(|_| invalid("external source count exceeds usize"))?;
+        if unique.len() != external_source_count
+            || unique.iter().copied().ne(0..parts.external_source_count)
+        {
+            return Err(invalid(format!(
+                "replay target {index} source mapping is not a permutation"
+            )));
+        }
+        match parts.strategy {
+            RecurrenceStrategy::TopologyReplay => {
+                if target.helicity_map_count != resolved_helicity_count {
+                    return Err(invalid(format!(
+                        "replay target {index} helicity map covers {} of {resolved_helicity_count} resolved helicities",
+                        target.helicity_map_count
+                    )));
+                }
+                let start = usize::try_from(target.helicity_map_start)
+                    .map_err(|_| invalid("replay helicity-map start exceeds usize"))?;
+                let count = usize::try_from(target.helicity_map_count)
+                    .map_err(|_| invalid("replay helicity-map count exceeds usize"))?;
+                let end = start
+                    .checked_add(count)
+                    .ok_or_else(|| invalid("replay helicity-map range overflows usize"))?;
+                let values = &parts.replay_helicity_map[start..end];
+                let unique = values.iter().copied().collect::<BTreeSet<_>>();
+                if unique.len() != count || unique.iter().copied().ne(0..resolved_helicity_count) {
+                    return Err(invalid(format!(
+                        "replay target {index} helicity mapping is not a bijection"
+                    )));
+                }
+            }
+            RecurrenceStrategy::AllFlowUnion => {
+                if target.helicity_map_count != 0 {
+                    return Err(invalid(format!(
+                        "all-flow-union replay target {index} carries a helicity map"
+                    )));
+                }
+            }
+            RecurrenceStrategy::ContractedColorUnion => {
+                if target.helicity_map_count != resolved_helicity_count {
+                    return Err(invalid(format!(
+                        "contracted replay target {index} helicity map covers {} of {resolved_helicity_count} resolved helicities",
+                        target.helicity_map_count
+                    )));
+                }
+                let start = usize::try_from(target.helicity_map_start)
+                    .map_err(|_| invalid("replay helicity-map start exceeds usize"))?;
+                let count = usize::try_from(target.helicity_map_count)
+                    .map_err(|_| invalid("replay helicity-map count exceeds usize"))?;
+                let end = start
+                    .checked_add(count)
+                    .ok_or_else(|| invalid("replay helicity-map range overflows usize"))?;
+                let values = &parts.replay_helicity_map[start..end];
+                let unique = values.iter().copied().collect::<BTreeSet<_>>();
+                if unique.len() != count || unique.iter().copied().ne(0..resolved_helicity_count) {
+                    return Err(invalid(format!(
+                        "contracted replay target {index} helicity mapping is not a bijection"
+                    )));
+                }
+            }
+        }
+    }
+
+    for (index, destination) in parts.amplitude_destinations.iter().enumerate() {
+        if destination.id != index as u32 {
+            return Err(invalid(format!(
+                "amplitude destination {index} has non-canonical ID {}",
+                destination.id
+            )));
+        }
+        require_ref(
+            "amplitude destination physical sector",
+            destination.target_sector_id,
+            parts.physical_sector_count,
+        )?;
+        if destination.target_helicity_id_or_sentinel != DIRECT_NONE_U32 {
+            require_ref(
+                "amplitude destination resolved helicity",
+                destination.target_helicity_id_or_sentinel,
+                resolved_helicity_count,
+            )?;
+        }
+        require_ref(
+            "amplitude destination selector domain",
+            destination.selector_domain_id,
+            selector_count,
+        )?;
+        if !selector_domain_contains_parts(
+            parts,
+            destination.selector_domain_id,
+            destination.target_sector_id,
+        )? {
+            return Err(invalid(format!(
+                "amplitude destination {index} selector domain excludes its target sector"
+            )));
+        }
+        let start = usize::try_from(destination.closure_row_start)
+            .map_err(|_| invalid("amplitude destination closure start exceeds usize"))?;
+        let count = usize::try_from(destination.closure_row_count)
+            .map_err(|_| invalid("amplitude destination closure count exceeds usize"))?;
+        let end = start
+            .checked_add(count)
+            .ok_or_else(|| invalid("amplitude destination closure range overflows usize"))?;
+        if parts.closures[start..end]
+            .iter()
+            .any(|row| row.amplitude_destination_id != destination.id)
+        {
+            return Err(invalid(format!(
+                "amplitude destination {index} does not own every closure in its range"
+            )));
+        }
+        if parts.closures[start..end]
+            .iter()
+            .any(|row| row.selector_domain_id != destination.selector_domain_id)
+        {
+            return Err(invalid(format!(
+                "amplitude destination {index} disagrees with a closure selector domain"
+            )));
+        }
+    }
+
+    for (index, helicity) in parts.resolved_helicities.iter().enumerate() {
+        if helicity.id != index as u32 {
+            return Err(invalid(format!(
+                "resolved helicity {index} has non-canonical ID {}",
+                helicity.id
+            )));
+        }
+        if helicity.source_state_count != parts.external_source_count
+            || helicity.public_helicity_count != parts.external_source_count
+        {
+            return Err(invalid(format!(
+                "resolved helicity {index} does not cover every external source"
+            )));
+        }
+        match parts.strategy {
+            RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::ContractedColorUnion
+                if helicity.source_selection_count != 0 =>
+            {
+                return Err(invalid(format!(
+                    "fixed-source resolved helicity {index} carries source dispatch selections"
+                )));
+            }
+            RecurrenceStrategy::AllFlowUnion
+                if helicity.source_selection_count != parts.external_source_count =>
+            {
+                return Err(invalid(format!(
+                    "all-flow-union resolved helicity {index} does not select every external source"
+                )));
+            }
+            _ => {}
+        }
+        require_ref(
+            "resolved-helicity selector domain",
+            helicity.selector_domain_id,
+            selector_count,
+        )?;
+        let start = usize::try_from(helicity.source_state_start)
+            .map_err(|_| invalid("resolved-helicity source-state start exceeds usize"))?;
+        let count = usize::try_from(helicity.source_state_count)
+            .map_err(|_| invalid("resolved-helicity source-state count exceeds usize"))?;
+        let end = start
+            .checked_add(count)
+            .ok_or_else(|| invalid("resolved-helicity source-state range overflows usize"))?;
+        for (source_slot, assignment) in parts.source_state_assignments[start..end]
+            .iter()
+            .enumerate()
+        {
+            if assignment.source_slot != source_slot as u32 {
+                return Err(invalid(format!(
+                    "resolved helicity {index} source states are not in source-slot order"
+                )));
+            }
+        }
+        let selection_start = usize::try_from(helicity.source_selection_start)
+            .map_err(|_| invalid("resolved-helicity source-selection start exceeds usize"))?;
+        let selection_count = usize::try_from(helicity.source_selection_count)
+            .map_err(|_| invalid("resolved-helicity source-selection count exceeds usize"))?;
+        let selection_end = selection_start
+            .checked_add(selection_count)
+            .ok_or_else(|| invalid("resolved-helicity source-selection range overflows usize"))?;
+        for (source_slot, selection) in parts.resolved_source_selections
+            [selection_start..selection_end]
+            .iter()
+            .enumerate()
+        {
+            if selection.source_slot != source_slot as u32 {
+                return Err(invalid(format!(
+                    "resolved helicity {index} source selections are not in source-slot order"
+                )));
+            }
+            require_ref(
+                "resolved-helicity source dispatch variant",
+                selection.dispatch_variant_id,
+                source_dispatch_variant_count,
+            )?;
+            let variant = parts.source_dispatch_variants[selection.dispatch_variant_id as usize];
+            let source = parts.sources[variant.source_row_id as usize];
+            let assignment = parts.source_state_assignments[start + source_slot];
+            if source.source_slot != selection.source_slot
+                || variant.source_state_index != assignment.state_index
+            {
+                return Err(invalid(format!(
+                    "resolved helicity {index} source selection does not match its public source-state assignment"
+                )));
+            }
+        }
+    }
+    if parts.strategy == RecurrenceStrategy::AllFlowUnion
+        && parts.resolved_helicities.len() as u64 != parts.retained_helicity_count
+    {
+        return Err(invalid(
+            "all-flow-union resolved-helicity catalog does not cover retained helicities",
+        ));
+    }
+
+    validate_row_groups(parts)?;
+    validate_contribution_initialization(parts)?;
+    validate_closure_proofs(parts)?;
+    Ok(())
+}
+
+#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+#[cfg_attr(target_vendor = "apple", inline(never))]
+fn validate_closure_proofs(parts: &DirectRecurrencePlanParts) -> RusticolResult<()> {
+    parts
+        .closure_proofs
+        .validate_tables()
+        .map_err(|error| invalid(error.message()))?;
+    let current_bases = parts
+        .currents
+        .iter()
+        .map(|current| (current.semantic_current_id, current.component_base))
+        .collect::<std::collections::BTreeMap<_, _>>();
+    let mut row_owner = vec![None; parts.closures.len()];
+    let mut term_owner = vec![None; parts.closures.len()];
+
+    for group in parts.closure_proofs.groups() {
+        let Some(term_id) = group.emitted_runtime_closure_term_id() else {
+            if group.emitted_direct_closure_row_id().is_some() {
+                return Err(invalid(format!(
+                    "exact-zero closure proof group {} references a direct closure row",
+                    group.id()
+                )));
+            }
+            continue;
+        };
+        let term_slot = term_owner.get_mut(term_id as usize).ok_or_else(|| {
+            invalid(format!(
+                "closure proof group {} references out-of-range runtime term {term_id}",
+                group.id()
+            ))
+        })?;
+        if term_slot.replace(group.id()).is_some() {
+            return Err(invalid(format!(
+                "runtime closure term {term_id} belongs to multiple proof groups"
+            )));
+        }
+        let row_id = group.emitted_direct_closure_row_id().ok_or_else(|| {
+            invalid(format!(
+                "nonzero closure proof group {} has no direct closure row",
+                group.id()
+            ))
+        })?;
+        let row = parts.closures.get(row_id as usize).ok_or_else(|| {
+            invalid(format!(
+                "closure proof group {} references out-of-range direct row {row_id}",
+                group.id()
+            ))
+        })?;
+        if row_owner[row_id as usize].replace(group.id()).is_some() {
+            return Err(invalid(format!(
+                "direct closure row {row_id} belongs to multiple proof groups"
+            )));
+        }
+        if row.proof_group_id() != group.id() {
+            return Err(invalid(format!(
+                "direct closure row {row_id} names proof group {}, expected {}",
+                row.proof_group_id(),
+                group.id()
+            )));
+        }
+        let runtime_factor = parts.exact_factors[row.exact_factor_id as usize];
+        if runtime_factor != group.exact_summed_factor() {
+            return Err(invalid(format!(
+                "direct closure row {row_id} factor does not match proof group {}",
+                group.id()
+            )));
+        }
+
+        let component_start = row.component_factor_start as usize;
+        let component_end = component_start
+            .checked_add(row.component_count as usize)
+            .ok_or_else(|| invalid("closure component-factor range overflows usize"))?;
+        let component_factors = parts
+            .exact_factors
+            .get(component_start..component_end)
+            .ok_or_else(|| invalid("closure component-factor range is out of bounds"))?;
+        if closure_component_factor_digest_v2(component_factors)
+            .map_err(|error| invalid(error.message()))?
+            != group.component_factor_digest()
+        {
+            return Err(invalid(format!(
+                "direct closure row {row_id} component-factor digest does not match proof group {}",
+                group.id()
+            )));
+        }
+
+        let selector = parts
+            .selector_domains
+            .get(row.selector_domain_id as usize)
+            .ok_or_else(|| invalid("closure selector domain is absent"))?;
+        let selector_start = selector.word_start as usize;
+        let selector_end = selector_start
+            .checked_add(selector.word_count as usize)
+            .ok_or_else(|| invalid("closure selector-domain range overflows usize"))?;
+        let selector_words = parts
+            .selector_words
+            .get(selector_start..selector_end)
+            .ok_or_else(|| invalid("closure selector-domain range is out of bounds"))?;
+        if closure_selector_domain_digest_v2(selector_words)
+            .map_err(|error| invalid(error.message()))?
+            != group.selector_domain_digest()
+        {
+            return Err(invalid(format!(
+                "direct closure row {row_id} selector-domain digest does not match proof group {}",
+                group.id()
+            )));
+        }
+
+        let contribution_range = group
+            .contribution_range()
+            .as_usize_range(
+                parts.closure_proofs.contributions().len(),
+                &format!("closure proof group {} contribution", group.id()),
+            )
+            .map_err(|error| invalid(error.message()))?;
+        let contributions = &parts.closure_proofs.contributions()[contribution_range];
+        let representative = &contributions[0];
+        if Some(row.amplitude_destination_id) != representative.target_destination_id() {
+            return Err(invalid(format!(
+                "direct closure row {row_id} destination does not match proof group {}",
+                group.id()
+            )));
+        }
+        let parent_ids = representative
+            .evaluator_parent_runtime_ids()
+            .ok_or_else(|| {
+                invalid(format!(
+                    "nonzero closure proof group {} has no complete runtime-parent binding",
+                    group.id()
+                ))
+            })?;
+        let expected_parent0 = *current_bases.get(&parent_ids[0]).ok_or_else(|| {
+            invalid(format!(
+                "closure proof group {} references absent semantic parent {}",
+                group.id(),
+                parent_ids[0]
+            ))
+        })?;
+        let expected_parent1 = parent_ids
+            .get(1)
+            .map(|parent_id| {
+                current_bases.get(parent_id).copied().ok_or_else(|| {
+                    invalid(format!(
+                        "closure proof group {} references absent semantic parent {parent_id}",
+                        group.id()
+                    ))
+                })
+            })
+            .transpose()?
+            .unwrap_or(DIRECT_NONE_U32);
+        if parent_ids.len() > 2
+            || row.parent0_component_base != expected_parent0
+            || row.parent1_component_base_or_sentinel != expected_parent1
+        {
+            return Err(invalid(format!(
+                "direct closure row {row_id} parents do not match proof group {}",
+                group.id()
+            )));
+        }
+    }
+
+    if let Some((row_id, _)) = row_owner
+        .iter()
+        .enumerate()
+        .find(|(_, owner)| owner.is_none())
+    {
+        return Err(invalid(format!(
+            "direct closure row {row_id} has no closure proof group"
+        )));
+    }
+    if let Some((term_id, _)) = term_owner
+        .iter()
+        .enumerate()
+        .find(|(_, owner)| owner.is_none())
+    {
+        return Err(invalid(format!(
+            "runtime closure term {term_id} has no closure proof group"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_row_groups(parts: &DirectRecurrencePlanParts) -> RusticolResult<()> {
+    let mut next = [0_u64; 4];
+    let mut previous = None;
+    for (index, row_group) in parts.row_groups.iter().enumerate() {
+        if row_group.row_count == 0 {
+            return Err(invalid(format!("row group {index} has zero rows")));
+        }
+        if (row_group.role == DirectExecutorRole::Source
+            && parts.strategy == RecurrenceStrategy::AllFlowUnion)
+            || (row_group.role == DirectExecutorRole::Contribution
+                && row_group.direct_executor_id == DIRECT_NONE_U32)
+        {
+            if row_group.direct_executor_id != DIRECT_NONE_U32 {
+                return Err(invalid(format!(
+                    "internal row group {index} must use the missing-executor sentinel"
+                )));
+            }
+            if row_group.role == DirectExecutorRole::Contribution {
+                let start = usize::try_from(row_group.row_start)
+                    .map_err(|_| invalid("certified-reuse row-group start exceeds usize"))?;
+                let end = start
+                    .checked_add(row_group.row_count as usize)
+                    .ok_or_else(|| invalid("certified-reuse row-group range overflows usize"))?;
+                let rows = parts.contributions.get(start..end).ok_or_else(|| {
+                    invalid(format!(
+                        "certified-reuse row-group {index} range is out of bounds"
+                    ))
+                })?;
+                if !rows
+                    .iter()
+                    .all(|row| row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE != 0)
+                {
+                    return Err(invalid(format!(
+                        "internal contribution row group {index} contains an uncertified row"
+                    )));
+                }
+            }
+        } else {
+            require_ref(
+                "row-group direct executor",
+                row_group.direct_executor_id,
+                parts.direct_executor_count,
+            )?;
+        }
+        let order = (row_group.stage, row_group.role);
+        if previous.is_some_and(|previous| order < previous) {
+            return Err(invalid(
+                "row groups are not in deterministic stage/role order",
+            ));
+        }
+        previous = Some(order);
+        let role_index = row_group.role as usize;
+        if row_group.row_start != next[role_index] {
+            return Err(invalid(format!(
+                "row group {index} does not continue its role's row partition"
+            )));
+        }
+        next[role_index] = row_group
+            .row_start
+            .checked_add(u64::from(row_group.row_count))
+            .ok_or_else(|| invalid(format!("row group {index} row range overflows u64")))?;
+        let start = usize::try_from(row_group.row_start)
+            .map_err(|_| invalid(format!("row group {index} row start exceeds usize")))?;
+        let end = start
+            .checked_add(row_group.row_count as usize)
+            .ok_or_else(|| invalid(format!("row group {index} row range overflows usize")))?;
+        let expected_operation = match row_group.role {
+            DirectExecutorRole::Source => DirectDestinationOperation::Initialize,
+            DirectExecutorRole::Contribution => DirectDestinationOperation::Add,
+            DirectExecutorRole::Finalization => DirectDestinationOperation::FinalizeInPlace,
+            DirectExecutorRole::Closure => DirectDestinationOperation::ClosureAdd,
+        };
+        if row_group.destination_operation != expected_operation {
+            return Err(invalid(format!(
+                "row group {index} has an operation incompatible with its role"
+            )));
+        }
+        let role_row_count = match row_group.role {
+            DirectExecutorRole::Source => parts.sources.len(),
+            DirectExecutorRole::Contribution => parts.contributions.len(),
+            DirectExecutorRole::Finalization => parts.finalizations.len(),
+            DirectExecutorRole::Closure => parts.closures.len(),
+        };
+        if end > role_row_count {
+            return Err(invalid(format!(
+                "row group {index} range is out of bounds for its role"
+            )));
+        }
+    }
+    let expected = [
+        parts.sources.len(),
+        parts.contributions.len(),
+        parts.finalizations.len(),
+        parts.closures.len(),
+    ];
+    for (index, expected) in expected.into_iter().enumerate() {
+        if next[index] != expected as u64 {
+            return Err(invalid(format!(
+                "row groups do not partition role {index}: covered {}, expected {expected}",
+                next[index]
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_contribution_initialization(parts: &DirectRecurrencePlanParts) -> RusticolResult<()> {
+    let current_by_stage_and_base = parts
+        .currents
+        .iter()
+        .filter(|current| current.node_kind == DirectNodeKind::Current)
+        .map(|current| {
+            (
+                (current.stage, current.component_base),
+                current.semantic_current_id,
+            )
+        })
+        .collect::<std::collections::BTreeMap<_, _>>();
+    let mut contribution_counts = vec![0_u32; parts.currents.len()];
+    let mut initialization_counts = vec![0_u32; parts.currents.len()];
+
+    for row_group in parts
+        .row_groups
+        .iter()
+        .filter(|row_group| row_group.role == DirectExecutorRole::Contribution)
+    {
+        let start = usize::try_from(row_group.row_start)
+            .map_err(|_| invalid("contribution row-group start exceeds usize"))?;
+        let end = start
+            .checked_add(row_group.row_count as usize)
+            .ok_or_else(|| invalid("contribution row-group range overflows usize"))?;
+        for (offset, row) in parts.contributions[start..end].iter().enumerate() {
+            if row.flags & !DIRECT_CONTRIBUTION_FLAGS_KNOWN != 0 {
+                return Err(invalid(format!(
+                    "contribution {} has unknown flags {:#x}",
+                    start + offset,
+                    row.flags
+                )));
+            }
+            let current_id = current_by_stage_and_base
+                .get(&(row_group.stage, row.destination_component_base))
+                .copied()
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "contribution {} does not target a current in stage {}",
+                        start + offset,
+                        row_group.stage
+                    ))
+                })? as usize;
+            contribution_counts[current_id] = contribution_counts[current_id]
+                .checked_add(1)
+                .ok_or_else(|| invalid("contribution count overflows u32"))?;
+            if row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0 {
+                initialization_counts[current_id] = initialization_counts[current_id]
+                    .checked_add(1)
+                    .ok_or_else(|| invalid("contribution initialization count overflows u32"))?;
+            }
+        }
+    }
+
+    for current in parts
+        .currents
+        .iter()
+        .filter(|current| current.node_kind == DirectNodeKind::Current)
+    {
+        let current_id = current.semantic_current_id as usize;
+        if contribution_counts[current_id] == 0 {
+            return Err(invalid(format!(
+                "current {} has no contribution rows",
+                current.semantic_current_id
+            )));
+        }
+        if initialization_counts[current_id] != 1 {
+            return Err(invalid(format!(
+                "current {} must have exactly one destination-initializing contribution, found {}",
+                current.semantic_current_id, initialization_counts[current_id]
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_arena_liveness(parts: &DirectRecurrencePlanParts) -> RusticolResult<()> {
+    let component_count = usize::try_from(parts.current_arena_components)
+        .map_err(|_| invalid("current arena component count exceeds usize"))?;
+    let mut intervals = vec![Vec::<(u32, u32, u32)>::new(); component_count];
+    for current in &parts.currents {
+        let end = current.component_base + u32::from(current.component_count);
+        for component in current.component_base..end {
+            let component = usize::try_from(component)
+                .map_err(|_| invalid("current arena component ID exceeds usize"))?;
+            intervals[component].push((
+                current.first_use,
+                current.last_use,
+                current.semantic_current_id,
+            ));
+        }
+    }
+    for (component, intervals) in intervals.iter_mut().enumerate() {
+        intervals.sort_unstable();
+        for pair in intervals.windows(2) {
+            let (_, left_last, left_id) = pair[0];
+            let (right_first, _, right_id) = pair[1];
+            if left_last >= right_first {
+                return Err(invalid(format!(
+                    "arena component {component} is shared by live currents {left_id} and {right_id}"
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_ranges(
+    label: &str,
+    ranges: impl IntoIterator<Item = (u64, u32)>,
+    item_count: usize,
+    require_partition: bool,
+) -> RusticolResult<()> {
+    let item_count = u64::try_from(item_count)
+        .map_err(|_| invalid(format!("{label} item count exceeds u64")))?;
+    let mut next = 0_u64;
+    for (index, (start, count)) in ranges.into_iter().enumerate() {
+        let end = start
+            .checked_add(u64::from(count))
+            .ok_or_else(|| invalid(format!("{label} range {index} overflows u64")))?;
+        if end > item_count {
+            return Err(invalid(format!("{label} range {index} is out of bounds")));
+        }
+        if require_partition && start != next {
+            return Err(invalid(format!(
+                "{label} range {index} does not continue the canonical partition"
+            )));
+        }
+        if require_partition {
+            next = end;
+        }
+    }
+    if require_partition && next != item_count {
+        return Err(invalid(format!(
+            "{label} ranges cover {next} items, expected {item_count}"
+        )));
+    }
+    Ok(())
+}
+
+fn require_ref(label: &str, value: u32, count: u32) -> RusticolResult<()> {
+    if value >= count {
+        return Err(invalid(format!("{label} {value} is out of bounds {count}")));
+    }
+    Ok(())
+}
+
+fn require_arena_base(
+    bases: &BTreeSet<u32>,
+    value: u32,
+    label: &str,
+    index: usize,
+) -> RusticolResult<()> {
+    if !bases.contains(&value) {
+        return Err(invalid(format!(
+            "{label} in row {index} does not name a current arena base"
+        )));
+    }
+    Ok(())
+}
+
+fn require_optional_pair(left: u32, right: u32, label: &str, index: usize) -> RusticolResult<()> {
+    if (left == DIRECT_NONE_U32) != (right == DIRECT_NONE_U32) {
+        return Err(invalid(format!(
+            "{label} in row {index} has mismatched optional fields"
+        )));
+    }
+    Ok(())
+}
+
+fn u32_len(label: &str, length: usize) -> RusticolResult<u32> {
+    u32::try_from(length).map_err(|_| invalid(format!("{label} length exceeds u32")))
+}
+
+fn digest_parts(parts: &DirectRecurrencePlanParts) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-runtime-layout-v2\0");
+    hash.update(parts.strategy.as_u32().to_le_bytes());
+    hash.update(parts.semantic_digest.as_bytes());
+    hash.update(parts.prepared_pack_digest.as_bytes());
+    hash.update(parts.direct_template_catalog_digest.as_bytes());
+    for value in [
+        parts.point_tile_size,
+        parts.workspace_mib,
+        parts.current_arena_components,
+        parts.physical_sector_count,
+        parts.amplitude_destination_count,
+        parts.parameter_value_count,
+        parts.external_source_count,
+        parts.state_template_count,
+        parts.source_template_count,
+        parts.source_template_or_dispatch_count,
+        parts.runtime_helicity_contract_count,
+        parts.runtime_helicity_variant_count,
+        parts.direct_executor_count,
+    ] {
+        hash.update(value.to_le_bytes());
+    }
+    hash.update(parts.retained_helicity_count.to_le_bytes());
+    macro_rules! count {
+        ($rows:expr) => {
+            hash.update(
+                u64::try_from($rows.len())
+                    .map_err(|_| invalid("digest row count exceeds u64"))?
+                    .to_le_bytes(),
+            );
+        };
+    }
+    count!(parts.currents);
+    for row in &parts.currents {
+        hash.update(row.semantic_current_id.to_le_bytes());
+        hash.update((row.node_kind as u16).to_le_bytes());
+        hash.update(row.state_template_id.to_le_bytes());
+        hash.update(row.component_base.to_le_bytes());
+        hash.update(row.component_count.to_le_bytes());
+        hash.update(row.momentum_form_id.to_le_bytes());
+        hash.update(row.stage.to_le_bytes());
+        hash.update(row.selector_domain_id.to_le_bytes());
+        hash.update(row.first_use.to_le_bytes());
+        hash.update(row.last_use.to_le_bytes());
+        hash.update(row.source_row_or_sentinel.to_le_bytes());
+        hash.update(row.finalization_row_or_sentinel.to_le_bytes());
+    }
+    macro_rules! hash_u32s {
+        ($($value:expr),+ $(,)?) => {
+            $(hash.update($value.to_le_bytes());)+
+        };
+    }
+    count!(parts.sources);
+    for row in &parts.sources {
+        hash_u32s!(
+            row.source_slot,
+            row.destination_component_base,
+            row.momentum_form_id,
+            row.source_template_or_dispatch_domain,
+        );
+        hash.update(row.spin_state_class.to_le_bytes());
+        hash.update(row.exact_factor_id.to_le_bytes());
+        hash.update(row.selector_domain_id.to_le_bytes());
+    }
+    count!(parts.contributions);
+    for row in &parts.contributions {
+        hash_u32s!(
+            row.parent0_component_base,
+            row.parent1_component_base_or_sentinel,
+            row.parent0_momentum_form_id,
+            row.parent1_momentum_form_id_or_sentinel,
+            row.destination_component_base,
+            row.exact_factor_id,
+            row.selector_domain_id,
+            row.flags,
+        );
+    }
+    count!(parts.finalizations);
+    for row in &parts.finalizations {
+        hash.update(row.component_base.to_le_bytes());
+        hash.update(row.component_count.to_le_bytes());
+        hash_u32s!(
+            row.momentum_form_id,
+            row.exact_factor_id,
+            row.selector_domain_id,
+            row.flags,
+        );
+    }
+    count!(parts.closures);
+    for row in &parts.closures {
+        hash_u32s!(
+            row.parent0_component_base,
+            row.parent1_component_base_or_sentinel,
+            row.parent0_momentum_form_id,
+            row.parent1_momentum_form_id_or_sentinel,
+            row.amplitude_destination_id,
+            row.exact_factor_id,
+            row.component_factor_start,
+        );
+        hash.update(row.component_count.to_le_bytes());
+        hash_u32s!(row.selector_domain_id, row.flags,);
+    }
+    count!(parts.row_groups);
+    for row in &parts.row_groups {
+        hash.update(row.stage.to_le_bytes());
+        hash.update((row.role as u16).to_le_bytes());
+        hash.update((row.destination_operation as u16).to_le_bytes());
+        hash.update(row.direct_executor_id.to_le_bytes());
+        hash.update(row.row_start.to_le_bytes());
+        hash.update(row.row_count.to_le_bytes());
+    }
+    count!(parts.momentum_forms);
+    for row in &parts.momentum_forms {
+        hash.update(row.term_start.to_le_bytes());
+        hash.update(row.term_count.to_le_bytes());
+    }
+    count!(parts.momentum_terms);
+    for row in &parts.momentum_terms {
+        hash.update(row.source_slot.to_le_bytes());
+        hash.update(row.coefficient.to_le_bytes());
+    }
+    count!(parts.selector_domains);
+    for row in &parts.selector_domains {
+        hash.update(row.word_start.to_le_bytes());
+        hash.update(row.word_count.to_le_bytes());
+    }
+    count!(parts.selector_words);
+    for value in &parts.selector_words {
+        hash.update(value.to_le_bytes());
+    }
+    count!(parts.replay_targets);
+    for row in &parts.replay_targets {
+        hash_u32s!(row.public_flow_id, row.representative_id);
+        hash.update(row.source_permutation_start.to_le_bytes());
+        hash.update(row.helicity_map_start.to_le_bytes());
+        hash_u32s!(
+            row.source_permutation_count,
+            row.helicity_map_count,
+            row.phase_exact_factor_id,
+            row.multiplicity,
+            row.selector_domain_id,
+        );
+    }
+    count!(parts.source_permutations);
+    for value in &parts.source_permutations {
+        hash.update(value.to_le_bytes());
+    }
+    count!(parts.replay_momentum_signs);
+    for value in &parts.replay_momentum_signs {
+        hash.update(value.to_le_bytes());
+    }
+    count!(parts.replay_helicity_map);
+    for value in &parts.replay_helicity_map {
+        hash.update(value.to_le_bytes());
+    }
+    count!(parts.amplitude_destinations);
+    for row in &parts.amplitude_destinations {
+        hash.update(row.closure_row_start.to_le_bytes());
+        hash_u32s!(
+            row.id,
+            row.target_sector_id,
+            row.target_helicity_id_or_sentinel,
+            row.closure_row_count,
+            row.selector_domain_id,
+        );
+    }
+    count!(parts.resolved_helicities);
+    for row in &parts.resolved_helicities {
+        hash.update(row.source_state_start.to_le_bytes());
+        hash.update(row.source_selection_start.to_le_bytes());
+        hash.update(row.public_helicity_start.to_le_bytes());
+        hash_u32s!(
+            row.id,
+            row.source_state_count,
+            row.source_selection_count,
+            row.public_helicity_count,
+            row.selector_domain_id,
+        );
+    }
+    count!(parts.source_state_assignments);
+    for row in &parts.source_state_assignments {
+        hash_u32s!(row.source_slot, row.state_index);
+    }
+    count!(parts.source_dispatch_variants);
+    for row in &parts.source_dispatch_variants {
+        hash.update(row.embedding_start.to_le_bytes());
+        hash.update(row.projection_start.to_le_bytes());
+        hash_u32s!(
+            row.source_row_id,
+            row.dispatch_domain_id,
+            row.runtime_variant_id,
+            row.source_state_index,
+            row.source_template_id,
+            row.source_state_template_id,
+            row.crossed_state_template_id,
+        );
+        hash.update(row.crossed_spin_state_class.to_le_bytes());
+        hash_u32s!(
+            row.direct_executor_id,
+            row.crossing_exact_factor_id,
+            row.embedding_count,
+            row.projection_count,
+        );
+    }
+    count!(parts.source_embeddings);
+    for row in &parts.source_embeddings {
+        hash_u32s!(
+            row.full_component,
+            row.source_component_or_sentinel,
+            row.exact_factor_id,
+        );
+    }
+    count!(parts.source_projections);
+    for row in &parts.source_projections {
+        hash_u32s!(row.source_component, row.full_component);
+    }
+    count!(parts.resolved_source_selections);
+    for row in &parts.resolved_source_selections {
+        hash_u32s!(row.source_slot, row.dispatch_variant_id);
+    }
+    count!(parts.public_helicities);
+    for value in &parts.public_helicities {
+        hash.update(value.to_le_bytes());
+    }
+    count!(parts.exact_factors);
+    for factor in &parts.exact_factors {
+        for rational in [factor.real(), factor.imag()] {
+            hash.update(rational.numerator().to_le_bytes());
+            hash.update(rational.denominator().to_le_bytes());
+        }
+    }
+    hash.update(
+        parts
+            .closure_proofs
+            .expected_semantic_completeness_digest()
+            .as_bytes(),
+    );
+    SemanticDigest::new(hash.finalize().into())
+}
+
+#[cfg(test)]
+#[path = "direct_plan_tests.rs"]
+pub(crate) mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_plan_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_plan_tests.rs
new file mode 100644
index 0000000000..952c38ca87
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_plan_tests.rs
@@ -0,0 +1,809 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::recurrence::direct_plan::{
+    DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION, DirectResolvedSourceSelection,
+    DirectSourceDispatchVariantDescriptor, DirectSourceEmbeddingRow, DirectSourceProjectionRow,
+};
+use crate::recurrence::{
+    CheckedTableRange, ClosureExecutionProofGroupV2, ClosureProofContributionV2, ExactRational,
+    ThreeLineTraversalCertificateV1, ThreeLineTraversalKindV1,
+    three_line_traversal_proof_digest_v1,
+};
+
+pub(crate) fn valid_three_line_traversal_certificate() -> ThreeLineTraversalCertificateV1 {
+    let reference_block_order = vec![0, 1, 2];
+    let witness_block_order = vec![1, 0, 2];
+    let block_permutation = vec![1, 0, 2];
+    let reference_source_order = vec![10, 11, 12];
+    let witness_source_order = vec![11, 10, 12];
+    let source_position_permutation = vec![1, 0, 2];
+    let proof_digest = three_line_traversal_proof_digest_v1(
+        0,
+        ThreeLineTraversalKindV1::Partner,
+        2,
+        &reference_block_order,
+        &witness_block_order,
+        &block_permutation,
+        &reference_source_order,
+        &witness_source_order,
+        &source_position_permutation,
+        12,
+        7,
+    )
+    .unwrap();
+    ThreeLineTraversalCertificateV1::new(
+        0,
+        0,
+        ThreeLineTraversalKindV1::Partner,
+        2,
+        reference_block_order,
+        witness_block_order,
+        block_permutation,
+        reference_source_order,
+        witness_source_order,
+        source_position_permutation,
+        12,
+        7,
+        proof_digest,
+    )
+    .unwrap()
+}
+
+pub(crate) fn valid_parts() -> DirectRecurrencePlanParts {
+    let identity = vec![0];
+    let proof_contribution = ClosureProofContributionV2::new(
+        0,
+        0,
+        Some(0),
+        Some(0),
+        0,
+        SemanticDigest::new([0x41; 32]).unwrap(),
+        None,
+        vec![1],
+        vec![Some(1)],
+        vec![SemanticDigest::new([0x42; 32]).unwrap()],
+        vec![SemanticDigest::new([0x43; 32]).unwrap()],
+        identity.clone(),
+        identity.clone(),
+        identity,
+        0,
+        SemanticDigest::new([0x44; 32]).unwrap(),
+        Some(0),
+        vec![],
+        None,
+        ExactComplexRational::ONE,
+        1,
+    )
+    .unwrap();
+    let proof_group = ClosureExecutionProofGroupV2::new(
+        0,
+        Some(0),
+        Some(0),
+        CheckedTableRange::new(0, 1),
+        ExactComplexRational::ONE,
+        closure_component_factor_digest_v2(&[ExactComplexRational::ONE]).unwrap(),
+        closure_selector_domain_digest_v2(&[1]).unwrap(),
+    )
+    .unwrap();
+    DirectRecurrencePlanParts {
+        strategy: RecurrenceStrategy::TopologyReplay,
+        semantic_digest: SemanticDigest::new([0x11; 32]).unwrap(),
+        prepared_pack_digest: SemanticDigest::new([0x22; 32]).unwrap(),
+        direct_template_catalog_digest: SemanticDigest::new([0x33; 32]).unwrap(),
+        point_tile_size: 1024,
+        workspace_mib: 256,
+        current_arena_components: 3,
+        physical_sector_count: 1,
+        retained_helicity_count: 1,
+        amplitude_destination_count: 1,
+        parameter_value_count: 1,
+        external_source_count: 1,
+        state_template_count: 2,
+        source_template_count: 8,
+        source_template_or_dispatch_count: 8,
+        runtime_helicity_contract_count: 0,
+        runtime_helicity_variant_count: 0,
+        direct_executor_count: 4,
+        currents: vec![
+            DirectCurrentDescriptor {
+                semantic_current_id: 0,
+                node_kind: DirectNodeKind::Source,
+                state_template_id: 0,
+                component_base: 0,
+                component_count: 2,
+                momentum_form_id: 0,
+                stage: 0,
+                selector_domain_id: 0,
+                first_use: 0,
+                last_use: 1,
+                source_row_or_sentinel: 0,
+                finalization_row_or_sentinel: DIRECT_NONE_U32,
+            },
+            DirectCurrentDescriptor {
+                semantic_current_id: 1,
+                node_kind: DirectNodeKind::Current,
+                state_template_id: 1,
+                component_base: 2,
+                component_count: 1,
+                momentum_form_id: 0,
+                stage: 1,
+                selector_domain_id: 0,
+                first_use: 1,
+                last_use: 2,
+                source_row_or_sentinel: DIRECT_NONE_U32,
+                finalization_row_or_sentinel: 0,
+            },
+        ],
+        sources: vec![DirectSourceRow {
+            source_slot: 0,
+            destination_component_base: 0,
+            momentum_form_id: 0,
+            source_template_or_dispatch_domain: 7,
+            spin_state_class: -1,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+        }],
+        contributions: vec![DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            destination_component_base: 2,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+        }],
+        finalizations: vec![DirectFinalizationRow {
+            component_base: 2,
+            component_count: 1,
+            momentum_form_id: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        }],
+        closures: vec![DirectClosureRow {
+            parent0_component_base: 2,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            amplitude_destination_id: 0,
+            exact_factor_id: 0,
+            component_factor_start: 0,
+            component_count: 1,
+            selector_domain_id: 0,
+            flags: 0,
+        }],
+        row_groups: vec![
+            DirectRowGroupDescriptor {
+                stage: 0,
+                role: DirectExecutorRole::Source,
+                destination_operation: DirectDestinationOperation::Initialize,
+                direct_executor_id: 0,
+                row_start: 0,
+                row_count: 1,
+            },
+            DirectRowGroupDescriptor {
+                stage: 1,
+                role: DirectExecutorRole::Contribution,
+                destination_operation: DirectDestinationOperation::Add,
+                direct_executor_id: 1,
+                row_start: 0,
+                row_count: 1,
+            },
+            DirectRowGroupDescriptor {
+                stage: 1,
+                role: DirectExecutorRole::Finalization,
+                destination_operation: DirectDestinationOperation::FinalizeInPlace,
+                direct_executor_id: 2,
+                row_start: 0,
+                row_count: 1,
+            },
+            DirectRowGroupDescriptor {
+                stage: 2,
+                role: DirectExecutorRole::Closure,
+                destination_operation: DirectDestinationOperation::ClosureAdd,
+                direct_executor_id: 3,
+                row_start: 0,
+                row_count: 1,
+            },
+        ],
+        momentum_forms: vec![DirectMomentumFormDescriptor {
+            term_start: 0,
+            term_count: 1,
+        }],
+        momentum_terms: vec![DirectMomentumTerm {
+            source_slot: 0,
+            coefficient: 1,
+        }],
+        selector_domains: vec![DirectSelectorDomainDescriptor {
+            word_start: 0,
+            word_count: 1,
+        }],
+        selector_words: vec![1],
+        replay_targets: vec![DirectReplayTargetDescriptor {
+            public_flow_id: 0,
+            representative_id: 0,
+            source_permutation_start: 0,
+            source_permutation_count: 1,
+            helicity_map_start: 0,
+            helicity_map_count: 1,
+            phase_exact_factor_id: 0,
+            multiplicity: 1,
+            selector_domain_id: 0,
+        }],
+        source_permutations: vec![0],
+        replay_momentum_signs: vec![1],
+        replay_helicity_map: vec![0],
+        amplitude_destinations: vec![DirectAmplitudeDestinationDescriptor {
+            closure_row_start: 0,
+            id: 0,
+            target_sector_id: 0,
+            target_helicity_id_or_sentinel: 0,
+            closure_row_count: 1,
+            selector_domain_id: 0,
+        }],
+        resolved_helicities: vec![DirectResolvedHelicityDescriptor {
+            source_state_start: 0,
+            source_selection_start: 0,
+            public_helicity_start: 0,
+            id: 0,
+            source_state_count: 1,
+            source_selection_count: 0,
+            public_helicity_count: 1,
+            selector_domain_id: 0,
+        }],
+        source_state_assignments: vec![DirectSourceStateAssignment {
+            source_slot: 0,
+            state_index: 0,
+        }],
+        source_dispatch_variants: vec![],
+        source_embeddings: vec![],
+        source_projections: vec![],
+        resolved_source_selections: vec![],
+        public_helicities: vec![-1],
+        exact_factors: vec![ExactComplexRational::ONE],
+        closure_proofs: ClosureProofMetadataV2::new_with_three_line_certificates(
+            vec![proof_contribution],
+            vec![proof_group],
+            vec![],
+            vec![valid_three_line_traversal_certificate()],
+        )
+        .unwrap(),
+    }
+}
+
+pub(crate) fn valid_plan() -> DirectRecurrencePlan {
+    DirectRecurrencePlan::new(valid_parts()).unwrap()
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[test]
+fn genuine_probe_direct_plan_materialization_is_poisoned() {
+    let guard = crate::recurrence::on_the_fly::OnTheFlyForbiddenWorkGuardV1::begin().unwrap();
+    assert!(
+        DirectRecurrencePlan::new(valid_parts())
+            .unwrap_err()
+            .to_string()
+            .contains("DirectRecurrencePlan materialization is poisoned")
+    );
+    let counts = guard.finish().unwrap();
+    assert_eq!(counts.direct_plan_load_attempts, 0);
+    assert_eq!(counts.direct_plan_decode_attempts, 0);
+    assert_eq!(counts.direct_plan_materialization_attempts, 1);
+    assert_eq!(counts.established_builder_attempts, 0);
+    assert!(DirectRecurrencePlan::new(valid_parts()).is_ok());
+}
+
+#[test]
+fn direct_descriptor_native_layouts_are_fixed_width() {
+    assert_eq!(std::mem::size_of::<DirectCurrentDescriptor>(), 48);
+    assert_eq!(std::mem::size_of::<DirectSourceRow>(), 28);
+    assert_eq!(std::mem::size_of::<DirectContributionRow>(), 32);
+    assert_eq!(std::mem::size_of::<DirectFinalizationRow>(), 24);
+    assert_eq!(std::mem::size_of::<DirectClosureRow>(), 40);
+    assert_eq!(std::mem::size_of::<DirectRowGroupDescriptor>(), 32);
+    assert_eq!(std::mem::size_of::<DirectMomentumFormDescriptor>(), 16);
+    assert_eq!(std::mem::size_of::<DirectMomentumTerm>(), 8);
+    assert_eq!(std::mem::size_of::<DirectSelectorDomainDescriptor>(), 16);
+    assert_eq!(std::mem::size_of::<DirectReplayTargetDescriptor>(), 48);
+    assert_eq!(
+        std::mem::size_of::<DirectAmplitudeDestinationDescriptor>(),
+        32
+    );
+    assert_eq!(std::mem::size_of::<DirectResolvedHelicityDescriptor>(), 48);
+    assert_eq!(std::mem::size_of::<DirectSourceStateAssignment>(), 8);
+    assert_eq!(
+        std::mem::size_of::<DirectSourceDispatchVariantDescriptor>(),
+        64
+    );
+    assert_eq!(std::mem::size_of::<DirectSourceEmbeddingRow>(), 12);
+    assert_eq!(std::mem::size_of::<DirectSourceProjectionRow>(), 8);
+    assert_eq!(std::mem::size_of::<DirectResolvedSourceSelection>(), 8);
+}
+
+#[test]
+fn direct_plan_validates_and_has_a_stable_nonzero_layout_digest() {
+    let first = valid_plan();
+    let second = valid_plan();
+    assert_eq!(first, second);
+    assert_eq!(
+        first.runtime_layout_digest(),
+        second.runtime_layout_digest()
+    );
+    assert_ne!(first.runtime_layout_digest().as_bytes(), &[0; 32]);
+}
+
+#[test]
+fn selector_work_summary_reports_active_rows_and_components() {
+    let plan = valid_plan();
+    let summary = plan.selector_work_summary(0).unwrap();
+    assert_eq!(summary.physical_sector_id, 0);
+    assert_eq!(summary.current_count, 2);
+    assert_eq!(summary.semantic_component_count, 3);
+    assert_eq!(summary.source_row_count, 1);
+    assert_eq!(summary.contribution_count, 1);
+    assert_eq!(summary.finalization_count, 1);
+    assert_eq!(summary.closure_count, 1);
+    assert_eq!(summary.amplitude_destination_count, 1);
+    assert_eq!(summary.row_count(), 4);
+}
+
+#[test]
+fn selector_domains_support_multiword_masks_and_legacy_universal_encoding() {
+    let mut parts = valid_parts();
+    parts.physical_sector_count = 71;
+    parts.selector_domains.extend([
+        DirectSelectorDomainDescriptor {
+            word_start: 1,
+            word_count: 2,
+        },
+        DirectSelectorDomainDescriptor {
+            word_start: 3,
+            word_count: 1,
+        },
+    ]);
+    parts.selector_words.extend([0, 1_u64 << 6, u64::MAX]);
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+
+    assert!(!plan.selector_domain_contains(1, 63).unwrap());
+    assert!(plan.selector_domain_contains(1, 70).unwrap());
+    assert!(plan.selector_domain_contains(2, 70).unwrap());
+    assert!(plan.selector_domain_contains(2, 0).unwrap());
+    assert!(
+        plan.selector_domain_contains(2, 71)
+            .unwrap_err()
+            .to_string()
+            .contains("out of bounds")
+    );
+}
+
+#[test]
+fn direct_plan_rejects_selector_domains_inconsistent_with_bound_rows() {
+    let mut parts = valid_parts();
+    parts.selector_domains.push(DirectSelectorDomainDescriptor {
+        word_start: 1,
+        word_count: 1,
+    });
+    parts.selector_words.push(0);
+    parts.sources[0].selector_domain_id = 1;
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("does not match its current"));
+
+    let mut parts = valid_parts();
+    parts.selector_domains.push(DirectSelectorDomainDescriptor {
+        word_start: 1,
+        word_count: 1,
+    });
+    parts.selector_words.push(0);
+    parts.amplitude_destinations[0].selector_domain_id = 1;
+    parts.closures[0].selector_domain_id = 1;
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("excludes its target sector"));
+}
+
+#[test]
+fn direct_plan_accepts_an_elided_identity_finalization() {
+    let mut parts = valid_parts();
+    parts.currents[1].finalization_row_or_sentinel = DIRECT_NONE_U32;
+    parts.finalizations.clear();
+    parts
+        .row_groups
+        .retain(|group| group.role != DirectExecutorRole::Finalization);
+    DirectRecurrencePlan::new(parts).unwrap();
+}
+
+#[test]
+fn direct_plan_canonicalizes_a_missing_initialization_marker() {
+    let mut parts = valid_parts();
+    parts.contributions[0].flags = 0;
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    assert_eq!(
+        plan.contributions()[0].flags,
+        DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+    );
+}
+
+#[test]
+fn direct_plan_rejects_multiple_initialization_markers_for_one_current() {
+    let mut parts = valid_parts();
+    parts.contributions.push(parts.contributions[0]);
+    parts.row_groups[1].row_count = 2;
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("exactly one"));
+}
+
+#[test]
+fn direct_plan_rejects_invalid_arena_and_optional_parent_references() {
+    let mut parts = valid_parts();
+    parts.contributions[0].destination_component_base = 99;
+    assert!(
+        DirectRecurrencePlan::new(parts)
+            .unwrap_err()
+            .to_string()
+            .contains("arena base")
+    );
+
+    let mut parts = valid_parts();
+    parts.contributions[0].parent1_component_base_or_sentinel = 0;
+    assert!(
+        DirectRecurrencePlan::new(parts)
+            .unwrap_err()
+            .to_string()
+            .contains("mismatched optional")
+    );
+}
+
+#[test]
+fn direct_plan_rejects_overlapping_live_arena_ranges() {
+    let mut parts = valid_parts();
+    parts.currents[1].component_base = 1;
+    parts.contributions[0].destination_component_base = 1;
+    parts.finalizations[0].component_base = 1;
+    parts.closures[0].parent0_component_base = 1;
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("shared by live currents"));
+}
+
+#[test]
+fn direct_plan_rejects_row_group_gaps_and_role_operation_mismatch() {
+    let mut parts = valid_parts();
+    parts.row_groups[1].row_start = 1;
+    assert!(
+        DirectRecurrencePlan::new(parts)
+            .unwrap_err()
+            .to_string()
+            .contains("row partition")
+    );
+
+    let mut parts = valid_parts();
+    parts.row_groups[1].destination_operation = DirectDestinationOperation::Initialize;
+    assert!(
+        DirectRecurrencePlan::new(parts)
+            .unwrap_err()
+            .to_string()
+            .contains("incompatible")
+    );
+}
+
+#[test]
+fn direct_plan_rejects_non_permutation_replay_mappings() {
+    let mut parts = valid_parts();
+    parts.external_source_count = 2;
+    parts.replay_targets[0].source_permutation_count = 2;
+    parts.source_permutations = vec![0, 0];
+    parts.replay_momentum_signs = vec![1, 1];
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("not a permutation"));
+}
+
+#[test]
+fn direct_plan_rejects_incomplete_or_out_of_range_replay_helicity_maps() {
+    let mut parts = valid_parts();
+    parts.replay_targets[0].helicity_map_count = 0;
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("helicity map ranges cover"));
+
+    let mut parts = valid_parts();
+    parts.replay_helicity_map[0] = 1;
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("not a bijection"));
+}
+
+#[test]
+fn direct_plan_rejects_invalid_replay_momentum_signs() {
+    let mut parts = valid_parts();
+    parts.replay_momentum_signs.clear();
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("momentum signs"));
+
+    let mut parts = valid_parts();
+    parts.replay_momentum_signs[0] = 0;
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("momentum signs"));
+}
+
+#[test]
+fn direct_plan_requires_packed_replay_tables() {
+    let mut parts = valid_parts();
+    parts.source_permutations.push(0);
+    parts.replay_momentum_signs.push(1);
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("ranges cover"));
+
+    let mut parts = valid_parts();
+    parts.replay_helicity_map.push(0);
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("ranges cover"));
+
+    let mut parts = valid_parts();
+    let mut overlapping = parts.replay_targets[0];
+    overlapping.public_flow_id = 1;
+    overlapping.helicity_map_start = 1;
+    parts.replay_targets.push(overlapping);
+    parts.source_permutations.push(0);
+    parts.replay_momentum_signs.push(1);
+    parts.replay_helicity_map.push(0);
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("canonical partition"));
+
+    let mut parts = valid_parts();
+    let mut gapped = parts.replay_targets[0];
+    gapped.public_flow_id = 1;
+    gapped.source_permutation_start = 2;
+    gapped.helicity_map_start = 1;
+    parts.replay_targets.push(gapped);
+    parts.source_permutations.extend_from_slice(&[0, 0]);
+    parts.replay_momentum_signs.extend_from_slice(&[1, 1]);
+    parts.replay_helicity_map.push(0);
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("canonical partition"));
+}
+
+#[test]
+fn direct_plan_authenticates_resolved_helicity_and_destination_contracts() {
+    let mut parts = valid_parts();
+    parts.amplitude_destinations[0].target_sector_id = 1;
+    assert!(
+        DirectRecurrencePlan::new(parts)
+            .unwrap_err()
+            .to_string()
+            .contains("physical sector")
+    );
+
+    let mut parts = valid_parts();
+    parts.resolved_helicities[0].source_state_count = 0;
+    assert!(
+        DirectRecurrencePlan::new(parts)
+            .unwrap_err()
+            .to_string()
+            .contains("source state")
+    );
+
+    let mut parts = valid_parts();
+    parts.amplitude_destinations[0].target_helicity_id_or_sentinel = 1;
+    assert!(
+        DirectRecurrencePlan::new(parts)
+            .unwrap_err()
+            .to_string()
+            .contains("resolved helicity")
+    );
+}
+
+#[test]
+fn changing_physical_layout_changes_only_the_layout_digest() {
+    let first = valid_plan();
+    let mut parts = valid_parts();
+    parts.point_tile_size = 128;
+    let second = DirectRecurrencePlan::new(parts).unwrap();
+    assert_eq!(first.semantic_digest(), second.semantic_digest());
+    assert_ne!(
+        first.runtime_layout_digest(),
+        second.runtime_layout_digest()
+    );
+}
+
+fn rebuild_proof_group(
+    parts: &DirectRecurrencePlanParts,
+    direct_row_id: Option<u32>,
+    component_factor_digest: SemanticDigest,
+    selector_domain_digest: SemanticDigest,
+) -> ClosureProofMetadataV2 {
+    let group = &parts.closure_proofs.groups()[0];
+    ClosureProofMetadataV2::new_with_three_line_certificates(
+        parts.closure_proofs.contributions().to_vec(),
+        vec![
+            ClosureExecutionProofGroupV2::new(
+                group.id(),
+                group.emitted_runtime_closure_term_id(),
+                direct_row_id,
+                group.contribution_range(),
+                group.exact_summed_factor(),
+                component_factor_digest,
+                selector_domain_digest,
+            )
+            .unwrap(),
+        ],
+        parts.closure_proofs.reflection_certificates().to_vec(),
+        parts
+            .closure_proofs
+            .three_line_traversal_certificates()
+            .to_vec(),
+    )
+    .unwrap()
+}
+
+#[test]
+fn direct_plan_rejects_missing_or_misbound_runtime_closure_rows() {
+    let mut parts = valid_parts();
+    parts.closure_proofs = rebuild_proof_group(
+        &parts,
+        None,
+        parts.closure_proofs.groups()[0].component_factor_digest(),
+        parts.closure_proofs.groups()[0].selector_domain_digest(),
+    );
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("no direct closure row"));
+
+    let mut parts = valid_parts();
+    parts.closures[0].flags = 1;
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("names proof group"));
+}
+
+#[test]
+fn direct_plan_rejects_mutated_runtime_factor_parent_and_cold_digests() {
+    let mut parts = valid_parts();
+    parts.exact_factors.push(ExactComplexRational::new(
+        ExactRational::new(-1, 1).unwrap(),
+        ExactRational::ZERO,
+    ));
+    parts.closures[0].exact_factor_id = 1;
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("factor does not match"));
+
+    let mut parts = valid_parts();
+    let original = &parts.closure_proofs.contributions()[0];
+    let parent_mutation = ClosureProofContributionV2::new(
+        original.id(),
+        original.target_sector_id(),
+        original.target_destination_id(),
+        original.target_helicity_id(),
+        original.closure_template_id(),
+        original.closure_template_semantic_digest(),
+        original.quantum_flow_template_id(),
+        vec![0],
+        vec![Some(0)],
+        original.construction_parent_semantic_digests().to_vec(),
+        original.construction_parent_color_digests().to_vec(),
+        original.construction_parent_permutation().to_vec(),
+        original.reconstruction_parent_permutation().to_vec(),
+        original.evaluator_parent_permutation().to_vec(),
+        original.color_witness_term_id(),
+        original.color_witness_proof_digest(),
+        original.three_line_certificate_id(),
+        original.pairing_certificate_ids().to_vec(),
+        original.reflection_certificate_id(),
+        original.exact_factor(),
+        original.multiplicity(),
+    )
+    .unwrap();
+    parts.closure_proofs = ClosureProofMetadataV2::new_with_three_line_certificates(
+        vec![parent_mutation],
+        parts.closure_proofs.groups().to_vec(),
+        vec![],
+        parts
+            .closure_proofs
+            .three_line_traversal_certificates()
+            .to_vec(),
+    )
+    .unwrap();
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("parents do not match"));
+
+    let mut parts = valid_parts();
+    parts.closure_proofs = rebuild_proof_group(
+        &parts,
+        Some(0),
+        SemanticDigest::new([0x51; 32]).unwrap(),
+        parts.closure_proofs.groups()[0].selector_domain_digest(),
+    );
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("component-factor digest"));
+
+    let mut parts = valid_parts();
+    parts.closure_proofs = rebuild_proof_group(
+        &parts,
+        Some(0),
+        parts.closure_proofs.groups()[0].component_factor_digest(),
+        SemanticDigest::new([0x52; 32]).unwrap(),
+    );
+    let error = DirectRecurrencePlan::new(parts).unwrap_err();
+    assert!(error.to_string().contains("selector-domain digest"));
+}
+
+#[test]
+fn direct_plan_accepts_cold_exact_zero_groups_without_runtime_rows() {
+    let mut parts = valid_parts();
+    let original = parts.closure_proofs.contributions()[0].clone();
+    let negative = ClosureProofContributionV2::new(
+        2,
+        original.target_sector_id(),
+        None,
+        original.target_helicity_id(),
+        original.closure_template_id(),
+        original.closure_template_semantic_digest(),
+        original.quantum_flow_template_id(),
+        original.construction_parent_builder_ids().to_vec(),
+        vec![None],
+        original.construction_parent_semantic_digests().to_vec(),
+        original.construction_parent_color_digests().to_vec(),
+        original.construction_parent_permutation().to_vec(),
+        original.reconstruction_parent_permutation().to_vec(),
+        original.evaluator_parent_permutation().to_vec(),
+        original.color_witness_term_id(),
+        original.color_witness_proof_digest(),
+        original.three_line_certificate_id(),
+        original.pairing_certificate_ids().to_vec(),
+        original.reflection_certificate_id(),
+        ExactComplexRational::new(ExactRational::new(-1, 1).unwrap(), ExactRational::ZERO),
+        1,
+    )
+    .unwrap();
+    let positive = ClosureProofContributionV2::new(
+        1,
+        original.target_sector_id(),
+        None,
+        original.target_helicity_id(),
+        original.closure_template_id(),
+        original.closure_template_semantic_digest(),
+        original.quantum_flow_template_id(),
+        original.construction_parent_builder_ids().to_vec(),
+        vec![None],
+        original.construction_parent_semantic_digests().to_vec(),
+        original.construction_parent_color_digests().to_vec(),
+        original.construction_parent_permutation().to_vec(),
+        original.reconstruction_parent_permutation().to_vec(),
+        original.evaluator_parent_permutation().to_vec(),
+        original.color_witness_term_id(),
+        original.color_witness_proof_digest(),
+        original.three_line_certificate_id(),
+        original.pairing_certificate_ids().to_vec(),
+        original.reflection_certificate_id(),
+        ExactComplexRational::ONE,
+        1,
+    )
+    .unwrap();
+    parts.closure_proofs = ClosureProofMetadataV2::new_with_three_line_certificates(
+        vec![original, positive, negative],
+        vec![
+            ClosureExecutionProofGroupV2::new(
+                0,
+                Some(0),
+                Some(0),
+                CheckedTableRange::new(0, 1),
+                ExactComplexRational::ONE,
+                closure_component_factor_digest_v2(&[ExactComplexRational::ONE]).unwrap(),
+                closure_selector_domain_digest_v2(&[1]).unwrap(),
+            )
+            .unwrap(),
+            ClosureExecutionProofGroupV2::new(
+                1,
+                None,
+                None,
+                CheckedTableRange::new(1, 2),
+                ExactComplexRational::ZERO,
+                SemanticDigest::new([0x53; 32]).unwrap(),
+                SemanticDigest::new([0x54; 32]).unwrap(),
+            )
+            .unwrap(),
+        ],
+        vec![],
+        parts
+            .closure_proofs
+            .three_line_traversal_certificates()
+            .to_vec(),
+    )
+    .unwrap();
+    DirectRecurrencePlan::new(parts).unwrap();
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_runtime.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_runtime.rs
new file mode 100644
index 0000000000..a49aeabbf1
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_runtime.rs
@@ -0,0 +1,2669 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Owned workspace for direct-arena recurrence execution.
+//!
+//! Ordinary construction performs every allocation needed by a point tile.
+//! Packed-singleton-capable runtimes allocate only their scalar point storage
+//! initially and materialize the aligned tiled storage on first use. Callers
+//! fill the persistent momentum and parameter arenas, then execute the
+//! authenticated direct plan without resizing the active runtime storage.
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::mem::size_of;
+use std::ops::Range;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+use super::direct_backend::observe_direct_amplitudes_before_replay;
+use super::direct_backend::{
+    DIRECT_STATUS_OK, DirectContributionFanoutProgram, DirectCurrentClearRange,
+    DirectExecutionCounters, DirectExecutionRoleTimings, DirectExecutorCatalog, DirectFactorView,
+    DirectMomentumView, DirectParameterView, DirectStageClearRanges,
+    DirectUnionSourceDispatchHandle, DirectWorkspace, execute_direct_plan_destination_selected,
+    execute_direct_plan_profiled_with_fanout_and_traffic,
+    execute_direct_plan_selected_profiled_with_fanout_and_traffic,
+    execute_direct_plan_selected_unprofiled_with_fanout,
+    execute_direct_plan_unprofiled_with_fanout,
+};
+use super::direct_plan::{
+    DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE, DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+    DirectAmplitudeDestinationDescriptor, DirectExecutorRole, DirectRecurrencePlan,
+    DirectResolvedHelicityDescriptor, DirectRowGroupDescriptor,
+};
+use super::{DIRECT_NONE_U32, DirectNodeKind, RecurrenceStrategy, SemanticDigest};
+use crate::direct_arena::{
+    AlignedF64Buffer, DIRECT_ARENA_ALIGNMENT, DirectArenaAllocationCounters,
+    DirectArenaTrafficCounters, DirectArenaWorkspace, checked_plane_scalar_len,
+    deterministic_point_tile_size, validate_direct_views,
+};
+use crate::{RusticolError, RusticolResult};
+
+/// Alignment used for the SIMD-facing numeric arenas.
+pub const DIRECT_RUNTIME_ARENA_ALIGNMENT: usize = DIRECT_ARENA_ALIGNMENT;
+const DIRECT_RUNTIME_CACHE_TARGET_BYTES: usize = 4 * 1024 * 1024;
+
+/// Borrowed component-major amplitude output for the most recent tile.
+#[derive(Clone, Copy, Debug)]
+pub struct DirectRecurrenceTileOutput<'a> {
+    amplitude_re: &'a [f64],
+    amplitude_im: &'a [f64],
+    amplitude_destinations: &'a [DirectAmplitudeDestinationDescriptor],
+    point_count: u32,
+    point_stride: u32,
+    destination_count: u32,
+    public_flow_id: Option<u32>,
+    representative_flow_id: Option<u32>,
+    selected_destination_ids: Option<&'a [u32]>,
+}
+
+/// One already-selected amplitude and its active point planes. The public
+/// random-access methods retain their independent selector checks; internal
+/// reductions can consume this borrowed view without repeating those checks.
+pub(crate) struct DirectRecurrenceAmplitudeView<'a> {
+    pub(crate) destination: &'a DirectAmplitudeDestinationDescriptor,
+    pub(crate) real: &'a [f64],
+    pub(crate) imaginary: &'a [f64],
+}
+
+impl<'a> DirectRecurrenceTileOutput<'a> {
+    pub const fn point_count(&self) -> u32 {
+        self.point_count
+    }
+
+    pub const fn point_stride(&self) -> u32 {
+        self.point_stride
+    }
+
+    pub const fn destination_count(&self) -> u32 {
+        self.destination_count
+    }
+
+    pub const fn public_flow_id(&self) -> Option<u32> {
+        self.public_flow_id
+    }
+
+    pub const fn representative_flow_id(&self) -> Option<u32> {
+        self.representative_flow_id
+    }
+
+    /// Full persistent real arena, including inactive tile tails.
+    pub const fn storage_re(&self) -> &'a [f64] {
+        self.amplitude_re
+    }
+
+    /// Full persistent imaginary arena, including inactive tile tails.
+    pub const fn storage_im(&self) -> &'a [f64] {
+        self.amplitude_im
+    }
+
+    pub fn destination_re(&self, destination_id: u32) -> Option<&[f64]> {
+        self.destination(self.amplitude_re, destination_id)
+    }
+
+    pub fn destination_im(&self, destination_id: u32) -> Option<&[f64]> {
+        self.destination(self.amplitude_im, destination_id)
+    }
+
+    pub fn selected_destination_ids(&self) -> impl Iterator<Item = u32> + '_ {
+        let unrestricted = if self.selected_destination_ids.is_some() {
+            &[][..]
+        } else {
+            self.amplitude_destinations
+        };
+        self.selected_destination_ids
+            .unwrap_or_default()
+            .iter()
+            .copied()
+            .chain(
+                unrestricted
+                    .iter()
+                    .filter(|destination| {
+                        self.representative_flow_id.is_none_or(|representative| {
+                            destination.target_sector_id == representative
+                        })
+                    })
+                    .map(|destination| destination.id),
+            )
+    }
+
+    pub(crate) fn selected_amplitudes(
+        &self,
+    ) -> impl Iterator<Item = RusticolResult<DirectRecurrenceAmplitudeView<'_>>> + '_ {
+        self.selected_destination_ids().map(|destination_id| {
+            // Explicit destination selections were checked against the
+            // representative when their selector was prepared. Unrestricted
+            // iteration above already filters by that representative.
+            let destination = self
+                .amplitude_destinations
+                .get(destination_id as usize)
+                .ok_or_else(|| invalid("selected amplitude descriptor is absent"))?;
+            let start = (destination_id as usize)
+                .checked_mul(self.point_stride as usize)
+                .ok_or_else(|| invalid("selected amplitude offset exceeds usize"))?;
+            let end = start
+                .checked_add(self.point_count as usize)
+                .ok_or_else(|| invalid("selected amplitude range exceeds usize"))?;
+            let real = self
+                .amplitude_re
+                .get(start..end)
+                .ok_or_else(|| invalid("selected real amplitude plane is absent"))?;
+            let imaginary = self
+                .amplitude_im
+                .get(start..end)
+                .ok_or_else(|| invalid("selected imaginary amplitude plane is absent"))?;
+            Ok(DirectRecurrenceAmplitudeView {
+                destination,
+                real,
+                imaginary,
+            })
+        })
+    }
+
+    fn destination<'b>(&self, values: &'b [f64], destination_id: u32) -> Option<&'b [f64]> {
+        if destination_id >= self.destination_count {
+            return None;
+        }
+        if self
+            .selected_destination_ids
+            .is_some_and(|ids| ids.binary_search(&destination_id).is_err())
+        {
+            return None;
+        }
+        let descriptor = self.amplitude_destinations.get(destination_id as usize)?;
+        if self
+            .representative_flow_id
+            .is_some_and(|representative| descriptor.target_sector_id != representative)
+        {
+            return None;
+        }
+        let start = destination_id as usize * self.point_stride as usize;
+        values.get(start..start + self.point_count as usize)
+    }
+}
+
+/// Prepared, plan-authenticated topology-replay selection.
+#[derive(Clone)]
+pub struct DirectReplaySelectorPlan {
+    runtime_layout_digest: SemanticDigest,
+    public_flow_id: u32,
+    representative_flow_id: u32,
+    source_permutation: Arc<[u32]>,
+    source_momentum_signs: Arc<[i32]>,
+    helicity_map: Arc<[u32]>,
+    phase_re: f64,
+    phase_im: f64,
+    multiplicity: u32,
+    row_groups: Arc<[DirectRowGroupDescriptor]>,
+    amplitude_clear_ranges: Arc<[Range<usize>]>,
+    destination_program: Option<Arc<DirectReplayDestinationProgram>>,
+}
+
+/// A cold dependency closure, reusable across flows with the same representative.
+struct DirectReplayDestinationProgram {
+    destination_ids: Arc<[u32]>,
+    row_groups: Box<[DirectRowGroupDescriptor]>,
+    amplitude_clear_ranges: Box<[Range<usize>]>,
+    current_clear_stages: Box<[DirectStageClearRanges]>,
+}
+
+/// Prepared, plan-authenticated all-flow-union helicity selection.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct DirectUnionHelicitySelectorPlan {
+    runtime_layout_digest: SemanticDigest,
+    resolved_helicity_id: u32,
+    source_selection_start: usize,
+    source_selection_count: usize,
+}
+
+impl DirectUnionHelicitySelectorPlan {
+    pub const fn resolved_helicity_id(&self) -> u32 {
+        self.resolved_helicity_id
+    }
+}
+
+impl DirectReplaySelectorPlan {
+    pub const fn public_flow_id(&self) -> u32 {
+        self.public_flow_id
+    }
+
+    pub const fn representative_flow_id(&self) -> u32 {
+        self.representative_flow_id
+    }
+
+    pub const fn phase(&self) -> (f64, f64) {
+        (self.phase_re, self.phase_im)
+    }
+
+    pub const fn multiplicity(&self) -> u32 {
+        self.multiplicity
+    }
+
+    pub fn mapped_external_source_slot(&self, representative_source_slot: u32) -> Option<u32> {
+        self.source_permutation
+            .get(representative_source_slot as usize)
+            .copied()
+    }
+
+    pub(crate) fn helicity_map(&self) -> &[u32] {
+        &self.helicity_map
+    }
+
+    pub fn selected_row_group_count(&self) -> usize {
+        self.selected_row_groups().len()
+    }
+
+    pub fn selected_row_count(&self) -> u64 {
+        self.selected_row_groups()
+            .iter()
+            .map(|group| u64::from(group.row_count))
+            .sum()
+    }
+
+    fn selected_row_groups(&self) -> &[DirectRowGroupDescriptor] {
+        self.destination_program
+            .as_ref()
+            .map_or(self.row_groups.as_ref(), |program| {
+                program.row_groups.as_ref()
+            })
+    }
+
+    fn identity(&self) -> DirectReplaySelectorIdentity {
+        DirectReplaySelectorIdentity {
+            runtime_layout_digest: self.runtime_layout_digest,
+            public_flow_id: self.public_flow_id,
+            representative_flow_id: self.representative_flow_id,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct DirectRuntimeActivityCounters {
+    pub momentum_fill_calls: u64,
+    pub momentum_forms_filled: u64,
+    pub momentum_terms_filled: u64,
+    pub momentum_scalar_values_filled: u64,
+    pub schedule_executions: u64,
+    pub replay_schedule_executions: u64,
+    pub replay_output_values_scaled: u64,
+    pub union_source_dispatch_calls: u64,
+    pub union_source_rows: u64,
+    pub union_schedule_executions: u64,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct DirectRuntimePhaseTimings {
+    pub momentum_fill: Duration,
+    pub union_source_fill: Duration,
+    pub direct_execution: Duration,
+    pub replay_output_mapping: Duration,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct DirectReplaySelectorIdentity {
+    runtime_layout_digest: SemanticDigest,
+    public_flow_id: u32,
+    representative_flow_id: u32,
+}
+
+struct DirectPointStorage {
+    arena: DirectArenaWorkspace,
+    momenta: AlignedF64Buffer,
+}
+
+#[allow(clippy::too_many_arguments)]
+fn allocate_point_storage(
+    current_component_count: u32,
+    amplitude_destination_count: u32,
+    momentum_plane_count: u32,
+    momentum_form_count: u32,
+    lorentz_component_count: u16,
+    tile_capacity: u32,
+    packed_singleton: bool,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+) -> RusticolResult<DirectPointStorage> {
+    let mut arena = if packed_singleton {
+        DirectArenaWorkspace::new_packed_singleton(
+            current_component_count,
+            amplitude_destination_count,
+        )?
+    } else {
+        DirectArenaWorkspace::new(
+            current_component_count,
+            amplitude_destination_count,
+            tile_capacity,
+        )?
+    };
+    let point_stride = arena.point_stride();
+    arena.begin_tile(if packed_singleton { 1 } else { tile_capacity })?;
+    let momentum_label = if packed_singleton {
+        "packed singleton momentum arena"
+    } else {
+        "momentum arena"
+    };
+    let momenta = AlignedF64Buffer::zeroed(
+        checked_plane_scalar_len(momentum_plane_count, point_stride, momentum_label)?,
+        if packed_singleton {
+            "packed singleton momentum"
+        } else {
+            "momentum"
+        },
+    )?;
+    validate_direct_views(
+        arena.view()?,
+        DirectMomentumView {
+            values: momenta.as_ptr(),
+            scalar_len: u64::try_from(momenta.len())
+                .map_err(|_| invalid("momentum arena exceeds u64"))?,
+            form_count: momentum_form_count,
+            lorentz_component_count,
+            point_stride,
+        },
+        parameters,
+        factors,
+    )?;
+    Ok(DirectPointStorage { arena, momenta })
+}
+
+/// One owned, thread-local direct recurrence execution workspace.
+pub struct DirectRecurrenceExecutionRuntime {
+    plan: DirectRecurrencePlan,
+    executors: DirectExecutorCatalog,
+    arena: DirectArenaWorkspace,
+    momenta: AlignedF64Buffer,
+    parameters_re: AlignedF64Buffer,
+    parameters_im: AlignedF64Buffer,
+    factors_re: AlignedF64Buffer,
+    factors_im: AlignedF64Buffer,
+    contribution_fanout: DirectContributionFanoutProgram,
+    union_source_dispatch: Option<DirectUnionSourceDispatchHandle>,
+    additive_amplitude_ranges: Vec<Range<usize>>,
+    momentum_form_count: u32,
+    lorentz_component_count: u16,
+    runtime_current_component_count: u32,
+    momentum_plane_count: u32,
+    tile_capacity: u32,
+    point_stride: u32,
+    alternate_point_storage: Option<DirectPointStorage>,
+    packed_singleton_active: bool,
+    momenta_are_compact: bool,
+    momentum_filled_points: u32,
+    momentum_replay_selector: Option<DirectReplaySelectorIdentity>,
+    last_point_count: u32,
+    last_public_flow_id: Option<u32>,
+    last_representative_flow_id: Option<u32>,
+    last_selected_destination_ids: Option<Arc<[u32]>>,
+    counters: DirectExecutionCounters,
+    allocation_counters: DirectArenaAllocationCounters,
+    traffic_counters: DirectArenaTrafficCounters,
+    role_timings: DirectExecutionRoleTimings,
+    activity_counters: DirectRuntimeActivityCounters,
+    timings: DirectRuntimePhaseTimings,
+}
+
+impl DirectRecurrenceExecutionRuntime {
+    /// Allocate the initial workspace and convert the plan's exact factors to
+    /// their persistent binary64 split-complex catalog. Packed-capable
+    /// runtimes defer aligned tiled point storage until it is needed.
+    pub fn new(
+        plan: DirectRecurrencePlan,
+        executors: DirectExecutorCatalog,
+        lorentz_component_count: u16,
+    ) -> RusticolResult<Self> {
+        Self::new_inner(plan, executors, lorentz_component_count, None)
+    }
+
+    /// Construct an all-flow-union workspace with its authenticated SourceIR
+    /// dispatcher. The dispatcher context is owned by the same loaded backend
+    /// owner that backs `executors` and must outlive this runtime.
+    pub fn new_with_union_source_dispatch(
+        plan: DirectRecurrencePlan,
+        executors: DirectExecutorCatalog,
+        lorentz_component_count: u16,
+        union_source_dispatch: DirectUnionSourceDispatchHandle,
+    ) -> RusticolResult<Self> {
+        if plan.strategy() != RecurrenceStrategy::AllFlowUnion {
+            return Err(invalid(
+                "union source dispatch requires an all-flow-union recurrence plan",
+            ));
+        }
+        Self::new_inner(
+            plan,
+            executors,
+            lorentz_component_count,
+            Some(union_source_dispatch),
+        )
+    }
+
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    fn new_inner(
+        plan: DirectRecurrencePlan,
+        executors: DirectExecutorCatalog,
+        lorentz_component_count: u16,
+        union_source_dispatch: Option<DirectUnionSourceDispatchHandle>,
+    ) -> RusticolResult<Self> {
+        if lorentz_component_count == 0 {
+            return Err(invalid("Lorentz component count must be positive"));
+        }
+
+        let contribution_fanout = DirectContributionFanoutProgram::build(&plan, &executors)?;
+        let runtime_current_component_count = plan
+            .current_arena_components()
+            .checked_add(contribution_fanout.scratch_component_count())
+            .ok_or_else(|| invalid("direct fanout current arena exceeds u32"))?;
+
+        let momentum_form_count = u32::try_from(plan.momentum_forms().len())
+            .map_err(|_| invalid("momentum form count exceeds u32"))?;
+        let split_complex_scalar_count = usize::try_from(runtime_current_component_count)
+            .ok()
+            .and_then(|current| current.checked_mul(2))
+            .and_then(|current| {
+                usize::try_from(plan.amplitude_destination_count())
+                    .ok()
+                    .and_then(|amplitude| amplitude.checked_mul(2))
+                    .and_then(|amplitude| current.checked_add(amplitude))
+            })
+            .ok_or_else(|| invalid("split-complex per-point workspace size overflows usize"))?;
+        let cache_split_complex_scalar_count = replay_cache_split_complex_scalar_count(
+            &plan,
+            split_complex_scalar_count,
+            contribution_fanout.scratch_component_count(),
+        )?;
+        let momentum_scalar_count = usize::try_from(momentum_form_count)
+            .ok()
+            .and_then(|forms| forms.checked_mul(usize::from(lorentz_component_count)))
+            .ok_or_else(|| invalid("per-point momentum workspace size overflows usize"))?;
+        let per_point_scalar_count = split_complex_scalar_count
+            .checked_add(momentum_scalar_count)
+            .ok_or_else(|| invalid("per-point workspace size overflows usize"))?;
+        let workspace_bytes = usize::try_from(plan.workspace_mib())
+            .ok()
+            .and_then(|mib| mib.checked_mul(1024 * 1024))
+            .ok_or_else(|| invalid("workspace byte target overflows usize"))?;
+        let workspace_tile = deterministic_point_tile_size(
+            plan.point_tile_size(),
+            workspace_bytes,
+            usize::MAX,
+            per_point_scalar_count,
+        )?;
+        let split_complex_per_point_bytes = cache_split_complex_scalar_count
+            .checked_mul(size_of::<f64>())
+            .filter(|bytes| *bytes != 0)
+            .ok_or_else(|| invalid("split-complex per-point bytes overflow usize"))?;
+        let cache_tile = greatest_power_of_two_not_exceeding(
+            DIRECT_RUNTIME_CACHE_TARGET_BYTES / split_complex_per_point_bytes,
+        );
+        // The accepted recurrence cache policy is deliberately lane-local:
+        // it counts current+amplitude split halves, while the workspace
+        // target above counts those halves plus every momentum plane.
+        // Fill at least one already allocated aligned pitch when the request
+        // allows it, rather than repeatedly running a few lanes.
+        let minimum_tiled_points = (DIRECT_RUNTIME_ARENA_ALIGNMENT / size_of::<f64>()) as u32;
+        let packed_singleton_capable = executors.packed_singleton_capable();
+        let tile_capacity = workspace_tile.min(
+            u32::try_from(cache_tile)
+                .unwrap_or(u32::MAX)
+                .max(minimum_tiled_points),
+        );
+        let momentum_plane_count = usize::try_from(momentum_form_count)
+            .ok()
+            .and_then(|forms| forms.checked_mul(usize::from(lorentz_component_count)))
+            .ok_or_else(|| invalid("momentum plane count overflows usize"))?;
+        let momentum_plane_count_u32 = u32::try_from(momentum_plane_count)
+            .map_err(|_| invalid("momentum plane count exceeds u32"))?;
+        let parameter_len = usize::try_from(plan.parameter_value_count())
+            .map_err(|_| invalid("parameter value count exceeds usize"))?;
+        let factor_len = plan
+            .exact_factors()
+            .len()
+            .checked_add(usize::from(contribution_fanout.needs_unit_factor()))
+            .ok_or_else(|| invalid("direct fanout factor catalog exceeds usize"))?;
+
+        let additive_amplitude_ranges = amplitude_clear_ranges(&plan)?;
+        let parameters_re = AlignedF64Buffer::zeroed(parameter_len, "parameter real")?;
+        let parameters_im = AlignedF64Buffer::zeroed(parameter_len, "parameter imaginary")?;
+        let mut factors_re = AlignedF64Buffer::zeroed(factor_len, "factor real")?;
+        let mut factors_im = AlignedF64Buffer::zeroed(factor_len, "factor imaginary")?;
+        for ((factor_re, factor_im), factor) in factors_re
+            .as_mut_slice()
+            .iter_mut()
+            .zip(factors_im.as_mut_slice())
+            .zip(plan.exact_factors())
+        {
+            *factor_re = factor.real().numerator() as f64 / factor.real().denominator() as f64;
+            *factor_im = factor.imag().numerator() as f64 / factor.imag().denominator() as f64;
+        }
+        if contribution_fanout.needs_unit_factor() {
+            let unit = plan.exact_factors().len();
+            factors_re.as_mut_slice()[unit] = 1.0;
+            factors_im.as_mut_slice()[unit] = 0.0;
+        }
+        let parameter_view = DirectParameterView {
+            values_re: parameters_re.as_ptr(),
+            values_im: parameters_im.as_ptr(),
+            value_count: u32::try_from(parameters_re.len())
+                .map_err(|_| invalid("parameter catalog exceeds u32"))?,
+        };
+        let factor_view = DirectFactorView {
+            values_re: factors_re.as_ptr(),
+            values_im: factors_im.as_ptr(),
+            value_count: u32::try_from(factors_re.len())
+                .map_err(|_| invalid("factor catalog exceeds u32"))?,
+        };
+        let point_storage = allocate_point_storage(
+            runtime_current_component_count,
+            plan.amplitude_destination_count(),
+            momentum_plane_count_u32,
+            momentum_form_count,
+            lorentz_component_count,
+            tile_capacity,
+            packed_singleton_capable,
+            parameter_view,
+            factor_view,
+        )?;
+        let DirectPointStorage { arena, momenta } = point_storage;
+        let point_stride = arena.point_stride();
+        let allocation_counters = [
+            momenta.allocation_counters(),
+            parameters_re.allocation_counters(),
+            parameters_im.allocation_counters(),
+            factors_re.allocation_counters(),
+            factors_im.allocation_counters(),
+        ]
+        .into_iter()
+        .try_fold(arena.allocation_counters(), |total, counters| {
+            total.checked_add(counters)
+        })?;
+
+        Ok(Self {
+            plan,
+            executors,
+            arena,
+            momenta,
+            parameters_re,
+            parameters_im,
+            factors_re,
+            factors_im,
+            contribution_fanout,
+            union_source_dispatch,
+            additive_amplitude_ranges,
+            momentum_form_count,
+            lorentz_component_count,
+            runtime_current_component_count,
+            momentum_plane_count: momentum_plane_count_u32,
+            tile_capacity,
+            point_stride,
+            alternate_point_storage: None,
+            packed_singleton_active: packed_singleton_capable,
+            momenta_are_compact: false,
+            momentum_filled_points: 0,
+            momentum_replay_selector: None,
+            last_point_count: 0,
+            last_public_flow_id: None,
+            last_representative_flow_id: None,
+            last_selected_destination_ids: None,
+            counters: DirectExecutionCounters::default(),
+            allocation_counters,
+            traffic_counters: DirectArenaTrafficCounters::default(),
+            role_timings: DirectExecutionRoleTimings::default(),
+            activity_counters: DirectRuntimeActivityCounters::default(),
+            timings: DirectRuntimePhaseTimings::default(),
+        })
+    }
+
+    pub const fn plan(&self) -> &DirectRecurrencePlan {
+        &self.plan
+    }
+
+    pub const fn point_tile_size(&self) -> u32 {
+        self.tile_capacity
+    }
+
+    /// Physical component-plane pitch passed through every direct ABI view.
+    /// This is `1` while packed singleton storage is active and changes to the
+    /// aligned tiled pitch after a successful layout transition.
+    pub const fn point_stride(&self) -> u32 {
+        self.point_stride
+    }
+
+    pub const fn momentum_form_count(&self) -> u32 {
+        self.momentum_form_count
+    }
+
+    pub const fn lorentz_component_count(&self) -> u16 {
+        self.lorentz_component_count
+    }
+
+    /// Resolve one physical flow once. The returned selector owns its fixed
+    /// source permutation and can be reused for every tile without allocation.
+    pub fn prepare_replay_selector(
+        &self,
+        public_flow_id: u32,
+    ) -> RusticolResult<DirectReplaySelectorPlan> {
+        if !self.plan.strategy().uses_topology_replay_targets() {
+            return Err(invalid(
+                "replay selectors require a replay-capable recurrence plan",
+            ));
+        }
+        let mut matches = self
+            .plan
+            .replay_targets()
+            .iter()
+            .filter(|target| target.public_flow_id == public_flow_id);
+        let target = matches
+            .next()
+            .ok_or_else(|| invalid(format!("public flow {public_flow_id} is not retained")))?;
+        if matches.next().is_some() {
+            return Err(RusticolError::integrity(format!(
+                "direct recurrence public flow {public_flow_id} has multiple replay targets"
+            )));
+        }
+        if !self
+            .plan
+            .amplitude_destinations()
+            .iter()
+            .any(|destination| destination.target_sector_id == target.representative_id)
+        {
+            return Err(RusticolError::integrity(format!(
+                "direct recurrence replay representative {} has no amplitude destination",
+                target.representative_id
+            )));
+        }
+
+        let start = usize::try_from(target.source_permutation_start).map_err(|_| {
+            RusticolError::integrity(
+                "direct recurrence replay source permutation start exceeds usize",
+            )
+        })?;
+        let count = usize::try_from(target.source_permutation_count).map_err(|_| {
+            RusticolError::integrity(
+                "direct recurrence replay source permutation count exceeds usize",
+            )
+        })?;
+        let end = start.checked_add(count).ok_or_else(|| {
+            RusticolError::integrity(
+                "direct recurrence replay source permutation range overflows usize",
+            )
+        })?;
+        let permutation = self
+            .plan
+            .source_permutations()
+            .get(start..end)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "direct recurrence replay source permutation is out of bounds",
+                )
+            })?;
+        let mut source_permutation = Vec::new();
+        source_permutation
+            .try_reserve_exact(permutation.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate direct recurrence replay selector: {error}"
+                ))
+            })?;
+        source_permutation.extend_from_slice(permutation);
+        let momentum_signs = self
+            .plan
+            .replay_momentum_signs()
+            .get(start..end)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "direct recurrence replay momentum-sign map is out of bounds",
+                )
+            })?;
+        let mut source_momentum_signs = Vec::new();
+        source_momentum_signs
+            .try_reserve_exact(momentum_signs.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate direct recurrence replay momentum signs: {error}"
+                ))
+            })?;
+        source_momentum_signs.extend_from_slice(momentum_signs);
+        let helicity_start = usize::try_from(target.helicity_map_start).map_err(|_| {
+            RusticolError::integrity("direct recurrence replay helicity-map start exceeds usize")
+        })?;
+        let helicity_count = usize::try_from(target.helicity_map_count).map_err(|_| {
+            RusticolError::integrity("direct recurrence replay helicity-map count exceeds usize")
+        })?;
+        let helicity_end = helicity_start.checked_add(helicity_count).ok_or_else(|| {
+            RusticolError::integrity("direct recurrence replay helicity-map range overflows usize")
+        })?;
+        let mapped_helicities = self
+            .plan
+            .replay_helicity_map()
+            .get(helicity_start..helicity_end)
+            .ok_or_else(|| {
+                RusticolError::integrity("direct recurrence replay helicity map is out of bounds")
+            })?;
+        let mut helicity_map = Vec::new();
+        helicity_map
+            .try_reserve_exact(mapped_helicities.len())
+            .map_err(|error| {
+                RusticolError::internal(format!(
+                    "could not allocate direct recurrence replay helicity map: {error}"
+                ))
+            })?;
+        helicity_map.extend_from_slice(mapped_helicities);
+
+        let phase = *self
+            .plan
+            .exact_factors()
+            .get(target.phase_exact_factor_id as usize)
+            .ok_or_else(|| {
+                RusticolError::integrity("direct recurrence replay phase factor is out of bounds")
+            })?;
+        let row_groups = selected_replay_row_groups(&self.plan, target.representative_id)?;
+        let amplitude_clear_ranges =
+            selected_amplitude_clear_ranges(&self.plan, target.representative_id)?;
+        Ok(DirectReplaySelectorPlan {
+            runtime_layout_digest: self.plan.runtime_layout_digest(),
+            public_flow_id,
+            representative_flow_id: target.representative_id,
+            source_permutation: source_permutation.into(),
+            source_momentum_signs: source_momentum_signs.into(),
+            helicity_map: helicity_map.into(),
+            phase_re: phase.real().numerator() as f64 / phase.real().denominator() as f64,
+            phase_im: phase.imag().numerator() as f64 / phase.imag().denominator() as f64,
+            multiplicity: target.multiplicity,
+            row_groups: row_groups.into(),
+            amplitude_clear_ranges: amplitude_clear_ranges.into(),
+            destination_program: None,
+        })
+    }
+
+    /// Prepare just the dependency closure of the requested representative
+    /// amplitude destinations. Sources remain helicity-generic in the plan;
+    /// numerical current identities, including identities between helicities,
+    /// are followed through their real parent dependencies here.
+    pub fn prepare_replay_selector_for_destinations(
+        &self,
+        base: &DirectReplaySelectorPlan,
+        needed_destinations: &[u32],
+    ) -> RusticolResult<DirectReplaySelectorPlan> {
+        self.validate_replay_selector(base)?;
+        let mut selector = base.clone();
+        selector.destination_program = Some(Arc::new(selected_replay_destination_program(
+            &self.plan,
+            selector.representative_flow_id,
+            &selector.row_groups,
+            needed_destinations,
+        )?));
+        Ok(selector)
+    }
+
+    /// Reuse an already prepared closure for another public flow represented
+    /// by the same sector. Only the momentum/helicity replay mapping differs.
+    pub fn prepare_replay_selector_with_destination_program(
+        &self,
+        base: &DirectReplaySelectorPlan,
+        prepared: &DirectReplaySelectorPlan,
+    ) -> RusticolResult<DirectReplaySelectorPlan> {
+        self.validate_replay_selector(base)?;
+        self.validate_replay_selector(prepared)?;
+        let mut selector = base.clone();
+        if selector.representative_flow_id != prepared.representative_flow_id {
+            return Err(invalid(
+                "replay destination program has a different representative",
+            ));
+        }
+        selector.destination_program = Some(Arc::clone(
+            prepared
+                .destination_program
+                .as_ref()
+                .ok_or_else(|| invalid("replay selector has no restricted destination program"))?,
+        ));
+        Ok(selector)
+    }
+
+    /// Resolve one retained helicity once for all-flow-union execution.
+    ///
+    /// The returned selector is a pair of authenticated ranges into the
+    /// immutable plan. Reusing it for later tiles performs no allocation.
+    pub fn prepare_union_helicity_selector(
+        &self,
+        resolved_helicity_id: u32,
+    ) -> RusticolResult<DirectUnionHelicitySelectorPlan> {
+        if self.plan.strategy() != RecurrenceStrategy::AllFlowUnion {
+            return Err(invalid(
+                "union helicity selectors require an all-flow-union recurrence plan",
+            ));
+        }
+        if self.union_source_dispatch.is_none() {
+            return Err(invalid(
+                "all-flow-union recurrence runtime has no source dispatcher",
+            ));
+        }
+        let descriptor = self
+            .plan
+            .resolved_helicities()
+            .get(resolved_helicity_id as usize)
+            .filter(|descriptor| descriptor.id == resolved_helicity_id)
+            .ok_or_else(|| {
+                invalid(format!(
+                    "resolved helicity {resolved_helicity_id} is not retained"
+                ))
+            })?;
+        let (source_selection_start, source_selection_count) =
+            self.validate_union_helicity_descriptor(descriptor)?;
+        Ok(DirectUnionHelicitySelectorPlan {
+            runtime_layout_digest: self.plan.runtime_layout_digest(),
+            resolved_helicity_id,
+            source_selection_start,
+            source_selection_count,
+        })
+    }
+
+    /// Mutable form-major, Lorentz-component-major momentum arena using the
+    /// compatibility-facing semantic tile pitch returned by
+    /// [`Self::point_tile_size`].
+    ///
+    /// The generic Direct-Arena ABI uses [`Self::point_stride`] internally.
+    /// When alignment padding separates physical planes, this accessor
+    /// compacts active plane storage in place and restores it before the next
+    /// direct call. A packed runtime allocates its aligned tiled storage on
+    /// first legacy access; no auxiliary packet buffer is involved.
+    pub fn momenta_mut(&mut self) -> RusticolResult<&mut [f64]> {
+        self.force_tiled_layout()?;
+        self.compact_momenta_for_legacy_access();
+        self.momentum_filled_points = self.tile_capacity;
+        self.momentum_replay_selector = None;
+        let compact_len = self.compact_momentum_len();
+        Ok(&mut self.momenta.as_mut_slice()[..compact_len])
+    }
+
+    /// Mutable physical Direct-Arena momentum storage.
+    ///
+    /// Plane starts use [`Self::point_stride`], including alignment padding.
+    /// A packed runtime allocates its aligned tiled storage on first access.
+    pub fn physical_momenta_mut(&mut self) -> RusticolResult<&mut [f64]> {
+        self.force_tiled_layout()?;
+        self.restore_physical_momenta();
+        self.momentum_filled_points = self.tile_capacity;
+        self.momentum_replay_selector = None;
+        Ok(self.momenta.as_mut_slice())
+    }
+
+    /// One persistent momentum plane using the compatibility-facing semantic
+    /// tile pitch, including its inactive semantic tile tail. A packed runtime
+    /// allocates its aligned tiled storage on first valid access.
+    pub fn momentum_plane_mut(
+        &mut self,
+        momentum_form_id: u32,
+        lorentz_component: u16,
+    ) -> RusticolResult<Option<&mut [f64]>> {
+        if momentum_form_id >= self.momentum_form_count
+            || lorentz_component >= self.lorentz_component_count
+        {
+            return Ok(None);
+        }
+        self.force_tiled_layout()?;
+        self.compact_momenta_for_legacy_access();
+        self.momentum_filled_points = self.tile_capacity;
+        self.momentum_replay_selector = None;
+        let plane = momentum_form_id as usize * usize::from(self.lorentz_component_count)
+            + usize::from(lorentz_component);
+        let start = plane * self.tile_capacity as usize;
+        Ok(self
+            .momenta
+            .as_mut_slice()
+            .get_mut(start..start + self.tile_capacity as usize))
+    }
+
+    /// Fill every canonical momentum form from point-major external
+    /// `[point][source_slot][lorentz_component]` four-momenta.
+    pub fn fill_momenta_from_external(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<()> {
+        self.fill_momenta_from_external_impl::<true, false>(
+            selector,
+            point_count,
+            external_four_momenta,
+        )
+    }
+
+    pub fn fill_momenta_from_external_unprofiled(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<()> {
+        self.fill_momenta_from_external_impl::<false, false>(
+            selector,
+            point_count,
+            external_four_momenta,
+        )
+    }
+
+    fn fill_momenta_from_external_impl<const PROFILE: bool, const SOURCE_MAJOR: bool>(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<()> {
+        self.validate_replay_selector(selector)?;
+        self.validate_point_count(point_count)?;
+        if self.lorentz_component_count != 4 {
+            return Err(invalid(format!(
+                "external four-momentum fill requires 4 Lorentz components, runtime has {}",
+                self.lorentz_component_count
+            )));
+        }
+        let source_count = usize::try_from(self.plan.external_source_count())
+            .map_err(|_| invalid("external source count exceeds usize"))?;
+        let expected_len = (point_count as usize)
+            .checked_mul(source_count)
+            .and_then(|values| values.checked_mul(4))
+            .ok_or_else(|| invalid("point-major external momentum length overflows usize"))?;
+        if external_four_momenta.len() != expected_len {
+            return Err(invalid(format!(
+                "point-major external momentum length is {}, expected {expected_len}",
+                external_four_momenta.len()
+            )));
+        }
+
+        self.activate_point_layout(point_count)?;
+        self.restore_physical_momenta();
+        let started = PROFILE.then(Instant::now);
+        let point_stride = self.point_stride as usize;
+        let active_points = point_count as usize;
+        let previous_points = self.momentum_filled_points as usize;
+        let form_count = self.plan.momentum_forms().len();
+        let terms = self.plan.momentum_terms();
+        let momenta = self.momenta.as_mut_slice();
+        for (form_id, form) in self.plan.momentum_forms().iter().enumerate() {
+            // The immutable plan has already validated term ranges, source
+            // slots and replay maps. Consume those persisted instructions once
+            // per term, not once per component and phase-space point.
+            let term_start = form.term_start as usize;
+            let form_terms = &terms[term_start..term_start + form.term_count as usize];
+            let form_start = form_id * 4 * point_stride;
+            fill_momentum_form_from_external::<SOURCE_MAJOR>(
+                &mut momenta[form_start..form_start + 4 * point_stride],
+                point_stride,
+                active_points,
+                external_four_momenta,
+                source_count,
+                form_terms.iter().map(|term| {
+                    let slot = term.source_slot as usize;
+                    (
+                        selector.source_permutation[slot] as usize,
+                        f64::from(term.coefficient)
+                            * f64::from(selector.source_momentum_signs[slot]),
+                    )
+                }),
+            );
+        }
+        if active_points < previous_points {
+            for plane in 0..form_count * 4 {
+                let start = plane * point_stride + active_points;
+                let end = plane * point_stride + previous_points;
+                momenta[start..end].fill(0.0);
+            }
+        }
+
+        self.momentum_filled_points = point_count;
+        self.momentum_replay_selector = Some(selector.identity());
+        if PROFILE {
+            self.activity_counters.momentum_fill_calls =
+                self.activity_counters.momentum_fill_calls.saturating_add(1);
+            self.activity_counters.momentum_forms_filled = self
+                .activity_counters
+                .momentum_forms_filled
+                .saturating_add(form_count as u64);
+            self.activity_counters.momentum_terms_filled = self
+                .activity_counters
+                .momentum_terms_filled
+                .saturating_add(terms.len() as u64);
+            let scalar_values = (form_count as u64)
+                .saturating_mul(4)
+                .saturating_mul(u64::from(point_count));
+            self.activity_counters.momentum_scalar_values_filled = self
+                .activity_counters
+                .momentum_scalar_values_filled
+                .saturating_add(scalar_values);
+            self.timings.momentum_fill += started
+                .expect("profiled momentum fill has a start time")
+                .elapsed();
+        }
+        Ok(())
+    }
+
+    /// Fill canonical momentum forms without a replay permutation.
+    fn fill_identity_momenta_from_external<const PROFILE: bool, const SOURCE_MAJOR: bool>(
+        &mut self,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<()> {
+        if !self.plan.strategy().materializes_all_color_sectors() {
+            return Err(invalid(
+                "identity momentum fill requires a complete-color recurrence plan",
+            ));
+        }
+        self.validate_point_count(point_count)?;
+        if self.lorentz_component_count != 4 {
+            return Err(invalid(format!(
+                "external four-momentum fill requires 4 Lorentz components, runtime has {}",
+                self.lorentz_component_count
+            )));
+        }
+        let source_count = usize::try_from(self.plan.external_source_count())
+            .map_err(|_| invalid("external source count exceeds usize"))?;
+        let expected_len = (point_count as usize)
+            .checked_mul(source_count)
+            .and_then(|values| values.checked_mul(4))
+            .ok_or_else(|| invalid("point-major external momentum length overflows usize"))?;
+        if external_four_momenta.len() != expected_len {
+            return Err(invalid(format!(
+                "point-major external momentum length is {}, expected {expected_len}",
+                external_four_momenta.len()
+            )));
+        }
+
+        self.activate_point_layout(point_count)?;
+        self.restore_physical_momenta();
+        let started = PROFILE.then(Instant::now);
+        let point_stride = self.point_stride as usize;
+        let active_points = point_count as usize;
+        let previous_points = self.momentum_filled_points as usize;
+        let form_count = self.plan.momentum_forms().len();
+        let terms = self.plan.momentum_terms();
+        let momenta = self.momenta.as_mut_slice();
+        for (form_id, form) in self.plan.momentum_forms().iter().enumerate() {
+            let term_start = form.term_start as usize;
+            let form_terms = &terms[term_start..term_start + form.term_count as usize];
+            let form_start = form_id * 4 * point_stride;
+            fill_momentum_form_from_external::<SOURCE_MAJOR>(
+                &mut momenta[form_start..form_start + 4 * point_stride],
+                point_stride,
+                active_points,
+                external_four_momenta,
+                source_count,
+                form_terms
+                    .iter()
+                    .map(|term| (term.source_slot as usize, f64::from(term.coefficient))),
+            );
+        }
+        if active_points < previous_points {
+            for plane in 0..form_count * 4 {
+                let start = plane * point_stride + active_points;
+                let end = plane * point_stride + previous_points;
+                momenta[start..end].fill(0.0);
+            }
+        }
+
+        self.momentum_filled_points = point_count;
+        self.momentum_replay_selector = None;
+        if PROFILE {
+            self.activity_counters.momentum_fill_calls =
+                self.activity_counters.momentum_fill_calls.saturating_add(1);
+            self.activity_counters.momentum_forms_filled = self
+                .activity_counters
+                .momentum_forms_filled
+                .saturating_add(form_count as u64);
+            self.activity_counters.momentum_terms_filled = self
+                .activity_counters
+                .momentum_terms_filled
+                .saturating_add(terms.len() as u64);
+            self.activity_counters.momentum_scalar_values_filled = self
+                .activity_counters
+                .momentum_scalar_values_filled
+                .saturating_add(
+                    (form_count as u64)
+                        .saturating_mul(4)
+                        .saturating_mul(u64::from(point_count)),
+                );
+            self.timings.momentum_fill += started
+                .expect("profiled union momentum fill has a start time")
+                .elapsed();
+        }
+        Ok(())
+    }
+
+    pub fn parameters_mut(&mut self) -> (&mut [f64], &mut [f64]) {
+        (
+            self.parameters_re.as_mut_slice(),
+            self.parameters_im.as_mut_slice(),
+        )
+    }
+
+    pub fn factors_mut(&mut self) -> (&mut [f64], &mut [f64]) {
+        let public_count = self.plan.exact_factors().len();
+        (
+            &mut self.factors_re.as_mut_slice()[..public_count],
+            &mut self.factors_im.as_mut_slice()[..public_count],
+        )
+    }
+
+    pub fn set_parameters(&mut self, values_re: &[f64], values_im: &[f64]) -> RusticolResult<()> {
+        validate_split_values("parameter", self.parameters_re.len(), values_re, values_im)?;
+        self.parameters_re.as_mut_slice().copy_from_slice(values_re);
+        self.parameters_im.as_mut_slice().copy_from_slice(values_im);
+        Ok(())
+    }
+
+    pub fn set_factors(&mut self, values_re: &[f64], values_im: &[f64]) -> RusticolResult<()> {
+        let public_count = self.plan.exact_factors().len();
+        validate_split_values("factor", public_count, values_re, values_im)?;
+        self.factors_re.as_mut_slice()[..public_count].copy_from_slice(values_re);
+        self.factors_im.as_mut_slice()[..public_count].copy_from_slice(values_im);
+        Ok(())
+    }
+
+    /// Current planes in the active packed or tiled physical layout.
+    pub fn current_arenas(&self) -> (&[f64], &[f64]) {
+        let (real, imaginary) = self.arena.current_slices();
+        let public_len = self.plan.current_arena_components() as usize * self.point_stride as usize;
+        (&real[..public_len], &imaginary[..public_len])
+    }
+
+    /// Amplitude planes in the active packed or tiled physical layout.
+    pub fn amplitude_arenas(&self) -> (&[f64], &[f64]) {
+        self.arena.amplitude_slices()
+    }
+
+    /// Cumulative direct calls and rows since construction or the last reset.
+    pub const fn counters(&self) -> DirectExecutionCounters {
+        self.counters
+    }
+
+    pub const fn activity_counters(&self) -> DirectRuntimeActivityCounters {
+        self.activity_counters
+    }
+
+    pub const fn allocation_counters(&self) -> DirectArenaAllocationCounters {
+        self.allocation_counters
+    }
+
+    pub const fn traffic_counters(&self) -> DirectArenaTrafficCounters {
+        self.traffic_counters
+    }
+
+    pub const fn role_timings(&self) -> DirectExecutionRoleTimings {
+        self.role_timings
+    }
+
+    pub const fn phase_timings(&self) -> DirectRuntimePhaseTimings {
+        self.timings
+    }
+
+    pub fn reset_counters(&mut self) {
+        self.counters = DirectExecutionCounters::default();
+        self.traffic_counters = DirectArenaTrafficCounters::default();
+        self.role_timings = DirectExecutionRoleTimings::default();
+        self.activity_counters = DirectRuntimeActivityCounters::default();
+        self.timings = DirectRuntimePhaseTimings::default();
+    }
+
+    pub fn outputs(&self) -> Option<DirectRecurrenceTileOutput<'_>> {
+        (self.last_point_count != 0).then(|| {
+            self.borrowed_output(
+                self.last_point_count,
+                self.last_public_flow_id,
+                self.last_representative_flow_id,
+            )
+        })
+    }
+
+    /// Execute one tile using the persistent inputs already held by this
+    /// workspace.
+    pub fn execute_tile(
+        &mut self,
+        point_count: u32,
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        if self.plan.strategy() == RecurrenceStrategy::AllFlowUnion {
+            return Err(invalid(
+                "all-flow-union execution requires a prepared runtime helicity selector",
+            ));
+        }
+        self.execute_direct_tile(point_count)?;
+        self.last_point_count = point_count;
+        self.last_public_flow_id = None;
+        self.last_representative_flow_id = None;
+        Ok(self.borrowed_output(point_count, None, None))
+    }
+
+    /// Execute a tile whose momentum forms were filled for `selector`, then
+    /// map representative amplitudes in place to the public flow convention.
+    pub fn execute_replay_tile(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        point_count: u32,
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.execute_replay_tile_impl::<true>(selector, point_count)
+    }
+
+    pub fn execute_replay_tile_unprofiled(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        point_count: u32,
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.execute_replay_tile_impl::<false>(selector, point_count)
+    }
+
+    fn execute_replay_tile_impl<const PROFILE: bool>(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        point_count: u32,
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.validate_replay_selector(selector)?;
+        self.validate_point_count(point_count)?;
+        self.activate_point_layout(point_count)?;
+        if self.momentum_filled_points != point_count
+            || self.momentum_replay_selector != Some(selector.identity())
+        {
+            return Err(invalid(
+                "replay tile momentum forms were not filled for this selector and point count",
+            ));
+        }
+
+        self.execute_selected_direct_tile_impl::<PROFILE>(selector, point_count)?;
+        self.scale_replay_amplitudes::<PROFILE>(
+            selector,
+            selector
+                .destination_program
+                .as_ref()
+                .map(|program| program.destination_ids.as_ref()),
+            point_count,
+        )?;
+        self.last_point_count = point_count;
+        self.last_public_flow_id = Some(selector.public_flow_id);
+        self.last_representative_flow_id = Some(selector.representative_flow_id);
+        self.last_selected_destination_ids = selector
+            .destination_program
+            .as_ref()
+            .map(|program| Arc::clone(&program.destination_ids));
+        Ok(self.borrowed_output(
+            point_count,
+            self.last_public_flow_id,
+            self.last_representative_flow_id,
+        ))
+    }
+
+    fn scale_replay_amplitudes<const PROFILE: bool>(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        selected_destination_ids: Option<&[u32]>,
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        let started = PROFILE.then(Instant::now);
+        let scale_re = selector.phase_re * f64::from(selector.multiplicity);
+        let scale_im = selector.phase_im * f64::from(selector.multiplicity);
+        let point_stride = self.point_stride as usize;
+        let active_points = point_count as usize;
+        let mut scaled_values = 0_u64;
+        let (_, _, amplitude_re, amplitude_im) = self.arena.split_slices_mut();
+        let unrestricted = if selected_destination_ids.is_some() {
+            0
+        } else {
+            self.plan.amplitude_destinations().len()
+        };
+        for destination_id in selected_destination_ids
+            .unwrap_or_default()
+            .iter()
+            .map(|&id| id as usize)
+            .chain(0..unrestricted)
+        {
+            let destination = self.plan.amplitude_destinations()[destination_id];
+            if destination.target_sector_id != selector.representative_flow_id {
+                continue;
+            }
+            let start = destination_id * point_stride;
+            let end = start + active_points;
+            let values_re = &mut amplitude_re[start..end];
+            let values_im = &mut amplitude_im[start..end];
+            for point in 0..active_points {
+                let value_re = values_re[point];
+                let value_im = values_im[point];
+                values_re[point] = value_re * scale_re - value_im * scale_im;
+                values_im[point] = value_re * scale_im + value_im * scale_re;
+            }
+            scaled_values = scaled_values.saturating_add(u64::from(point_count));
+        }
+        if PROFILE {
+            self.activity_counters.replay_schedule_executions = self
+                .activity_counters
+                .replay_schedule_executions
+                .saturating_add(1);
+            self.activity_counters.replay_output_values_scaled = self
+                .activity_counters
+                .replay_output_values_scaled
+                .saturating_add(scaled_values);
+            self.timings.replay_output_mapping += started
+                .expect("profiled replay mapping has a start time")
+                .elapsed();
+        }
+        Ok(())
+    }
+
+    /// Fill and execute one selected replay tile without any intermediate
+    /// momentum-form materialization by the caller.
+    pub fn execute_replay_tile_from_external(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.fill_momenta_from_external(selector, point_count, external_four_momenta)?;
+        self.execute_replay_tile(selector, point_count)
+    }
+
+    pub fn execute_replay_tile_from_external_unprofiled(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.fill_momenta_from_external_unprofiled(selector, point_count, external_four_momenta)?;
+        self.execute_replay_tile_unprofiled(selector, point_count)
+    }
+
+    /// Internal lane input is `[source][component][point]`, written directly
+    /// into its existing external-input workspace. The public point-major
+    /// entrypoints remain unchanged; this adds no preparation or transpose.
+    pub(crate) fn execute_replay_tile_from_external_planes<const PROFILE: bool>(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.fill_momenta_from_external_impl::<PROFILE, true>(
+            selector,
+            point_count,
+            external_four_momenta,
+        )?;
+        self.execute_replay_tile_impl::<PROFILE>(selector, point_count)
+    }
+
+    /// Fill one runtime helicity's union sources and execute the compact
+    /// all-flow schedule exactly once.
+    pub fn execute_union_tile_from_external(
+        &mut self,
+        selector: &DirectUnionHelicitySelectorPlan,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.execute_union_tile_from_external_impl::<true, false>(
+            selector,
+            point_count,
+            external_four_momenta,
+        )
+    }
+
+    pub fn execute_union_tile_from_external_unprofiled(
+        &mut self,
+        selector: &DirectUnionHelicitySelectorPlan,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.execute_union_tile_from_external_impl::<false, false>(
+            selector,
+            point_count,
+            external_four_momenta,
+        )
+    }
+
+    pub(crate) fn execute_union_tile_from_external_planes<const PROFILE: bool>(
+        &mut self,
+        selector: &DirectUnionHelicitySelectorPlan,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.execute_union_tile_from_external_impl::<PROFILE, true>(
+            selector,
+            point_count,
+            external_four_momenta,
+        )
+    }
+
+    fn execute_union_tile_from_external_impl<const PROFILE: bool, const SOURCE_MAJOR: bool>(
+        &mut self,
+        selector: &DirectUnionHelicitySelectorPlan,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.validate_union_selector(selector)?;
+        self.fill_identity_momenta_from_external::<PROFILE, SOURCE_MAJOR>(
+            point_count,
+            external_four_momenta,
+        )?;
+        self.execute_union_sources::<PROFILE>(selector, point_count)?;
+        self.execute_direct_tile_impl::<PROFILE>(point_count)?;
+        if PROFILE {
+            self.activity_counters.union_schedule_executions = self
+                .activity_counters
+                .union_schedule_executions
+                .saturating_add(1);
+        }
+        self.last_point_count = point_count;
+        self.last_public_flow_id = None;
+        self.last_representative_flow_id = None;
+        Ok(self.borrowed_output(point_count, None, None))
+    }
+
+    /// Execute a complete contracted-color schedule with fixed source templates.
+    pub fn execute_contracted_tile_from_external(
+        &mut self,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.execute_contracted_tile_from_external_impl::<true, false>(
+            point_count,
+            external_four_momenta,
+        )
+    }
+
+    pub fn execute_contracted_tile_from_external_unprofiled(
+        &mut self,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.execute_contracted_tile_from_external_impl::<false, false>(
+            point_count,
+            external_four_momenta,
+        )
+    }
+
+    pub(crate) fn execute_contracted_tile_from_external_planes<const PROFILE: bool>(
+        &mut self,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        self.execute_contracted_tile_from_external_impl::<PROFILE, true>(
+            point_count,
+            external_four_momenta,
+        )
+    }
+
+    fn execute_contracted_tile_from_external_impl<const PROFILE: bool, const SOURCE_MAJOR: bool>(
+        &mut self,
+        point_count: u32,
+        external_four_momenta: &[f64],
+    ) -> RusticolResult<DirectRecurrenceTileOutput<'_>> {
+        if self.plan.strategy() != RecurrenceStrategy::ContractedColorUnion {
+            return Err(invalid(
+                "contracted-color execution requires a contracted-color recurrence plan",
+            ));
+        }
+        self.fill_identity_momenta_from_external::<PROFILE, SOURCE_MAJOR>(
+            point_count,
+            external_four_momenta,
+        )?;
+        self.execute_direct_tile_impl::<PROFILE>(point_count)?;
+        self.last_point_count = point_count;
+        self.last_public_flow_id = None;
+        self.last_representative_flow_id = None;
+        Ok(self.borrowed_output(point_count, None, None))
+    }
+
+    fn execute_union_sources<const PROFILE: bool>(
+        &mut self,
+        selector: &DirectUnionHelicitySelectorPlan,
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        self.restore_physical_momenta();
+        let handle = self
+            .union_source_dispatch
+            .ok_or_else(|| invalid("all-flow-union recurrence runtime has no source dispatcher"))?;
+        let selection_end = selector
+            .source_selection_start
+            .checked_add(selector.source_selection_count)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "direct recurrence union source-selection range overflows usize",
+                )
+            })?;
+        let selections = self
+            .plan
+            .resolved_source_selections()
+            .get(selector.source_selection_start..selection_end)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "direct recurrence union source-selection range is out of bounds",
+                )
+            })?;
+
+        let momentum_scalar_len =
+            u64::try_from(self.momenta.len()).map_err(|_| invalid("momentum arena exceeds u64"))?;
+        let parameter_count = u32::try_from(self.parameters_re.len())
+            .map_err(|_| invalid("parameter catalog exceeds u32"))?;
+        let factor_count = u32::try_from(self.factors_re.len())
+            .map_err(|_| invalid("factor catalog exceeds u32"))?;
+        let source_count = u32::try_from(self.plan.sources().len())
+            .map_err(|_| invalid("source row count exceeds u32"))?;
+        let variant_count = u32::try_from(self.plan.source_dispatch_variants().len())
+            .map_err(|_| invalid("source-dispatch variant count exceeds u32"))?;
+        let embedding_count = u32::try_from(self.plan.source_embeddings().len())
+            .map_err(|_| invalid("source embedding count exceeds u32"))?;
+        let selection_count = u32::try_from(selections.len())
+            .map_err(|_| invalid("source selection count exceeds u32"))?;
+
+        self.arena.begin_tile(point_count)?;
+        let arena = self.arena.view()?;
+        let momenta = DirectMomentumView {
+            values: self.momenta.as_ptr(),
+            scalar_len: momentum_scalar_len,
+            form_count: self.momentum_form_count,
+            lorentz_component_count: self.lorentz_component_count,
+            point_stride: self.point_stride,
+        };
+        let parameters = DirectParameterView {
+            values_re: self.parameters_re.as_ptr(),
+            values_im: self.parameters_im.as_ptr(),
+            value_count: parameter_count,
+        };
+        let factors = DirectFactorView {
+            values_re: self.factors_re.as_ptr(),
+            values_im: self.factors_im.as_ptr(),
+            value_count: factor_count,
+        };
+        validate_direct_views(arena, momenta, parameters, factors)?;
+
+        let started = PROFILE.then(Instant::now);
+        if PROFILE {
+            self.traffic_counters
+                .record_call(selection_count, point_count);
+        }
+        let status = unsafe {
+            (handle.call)(
+                handle.context,
+                arena,
+                momenta,
+                parameters,
+                factors,
+                self.plan.sources().as_ptr(),
+                source_count,
+                self.plan.source_dispatch_variants().as_ptr(),
+                variant_count,
+                self.plan.source_embeddings().as_ptr(),
+                embedding_count,
+                selections.as_ptr(),
+                selection_count,
+                point_count,
+            )
+        };
+        if PROFILE {
+            self.timings.union_source_fill += started
+                .expect("profiled union source fill has a start time")
+                .elapsed();
+        }
+        if status != DIRECT_STATUS_OK {
+            return Err(RusticolError::evaluation(format!(
+                "direct recurrence union source dispatcher returned status {status}"
+            )));
+        }
+        if PROFILE {
+            self.counters.source_calls = self.counters.source_calls.saturating_add(1);
+            self.counters.source_rows = self
+                .counters
+                .source_rows
+                .saturating_add(u64::from(selection_count));
+            self.activity_counters.union_source_dispatch_calls = self
+                .activity_counters
+                .union_source_dispatch_calls
+                .saturating_add(1);
+            self.activity_counters.union_source_rows = self
+                .activity_counters
+                .union_source_rows
+                .saturating_add(u64::from(selection_count));
+        }
+        Ok(())
+    }
+
+    fn execute_direct_tile(&mut self, point_count: u32) -> RusticolResult<()> {
+        self.execute_direct_tile_impl::<true>(point_count)
+    }
+
+    fn execute_direct_tile_impl<const PROFILE: bool>(
+        &mut self,
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        self.execute_direct_tile_rows_impl::<PROFILE>(point_count, None)
+    }
+
+    fn execute_selected_direct_tile_impl<const PROFILE: bool>(
+        &mut self,
+        selector: &DirectReplaySelectorPlan,
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        self.execute_direct_tile_rows_impl::<PROFILE>(point_count, Some(selector))
+    }
+
+    fn execute_direct_tile_rows_impl<const PROFILE: bool>(
+        &mut self,
+        point_count: u32,
+        selector: Option<&DirectReplaySelectorPlan>,
+    ) -> RusticolResult<()> {
+        self.validate_point_count(point_count)?;
+        self.activate_point_layout(point_count)?;
+        self.restore_physical_momenta();
+        self.arena.begin_tile(point_count)?;
+        self.last_point_count = 0;
+        self.last_public_flow_id = None;
+        self.last_representative_flow_id = None;
+        // `execute_direct_plan` initializes every current stage exactly once
+        self.last_selected_destination_ids = None;
+        // before its first contribution group. Re-clearing all current planes
+        // here only duplicates that work.
+        let amplitude_ranges =
+            selector.map_or(self.additive_amplitude_ranges.as_slice(), |selector| {
+                selector
+                    .destination_program
+                    .as_ref()
+                    .map_or(selector.amplitude_clear_ranges.as_ref(), |program| {
+                        program.amplitude_clear_ranges.as_ref()
+                    })
+            });
+        for range in amplitude_ranges {
+            let component_base = u32::try_from(range.start).map_err(|_| {
+                RusticolError::integrity("direct recurrence amplitude clear base exceeds u32")
+            })?;
+            let component_count = u32::try_from(range.end - range.start).map_err(|_| {
+                RusticolError::integrity("direct recurrence amplitude clear count exceeds u32")
+            })?;
+            self.arena
+                .clear_amplitude_active(component_base, component_count)?;
+        }
+
+        {
+            let (current_re, current_im, amplitude_re, amplitude_im) =
+                self.arena.split_slices_mut();
+            let mut workspace = DirectWorkspace {
+                current_re,
+                current_im,
+                amplitude_re,
+                amplitude_im,
+                momenta: self.momenta.as_slice(),
+                momentum_form_count: self.momentum_form_count,
+                lorentz_component_count: self.lorentz_component_count,
+                parameters_re: self.parameters_re.as_slice(),
+                parameters_im: self.parameters_im.as_slice(),
+                factors_re: self.factors_re.as_slice(),
+                factors_im: self.factors_im.as_slice(),
+                point_stride: self.point_stride,
+            };
+            let started = PROFILE.then(Instant::now);
+            let result = if let Some((selector, program)) = selector.and_then(|selector| {
+                selector
+                    .destination_program
+                    .as_ref()
+                    .map(|program| (selector, program))
+            }) {
+                execute_direct_plan_destination_selected::<PROFILE>(
+                    &self.plan,
+                    &program.row_groups,
+                    selector.representative_flow_id,
+                    &program.current_clear_stages,
+                    &self.executors,
+                    &mut workspace,
+                    point_count,
+                    &mut self.counters,
+                    &mut self.role_timings,
+                    &mut self.traffic_counters,
+                )
+            } else {
+                match (PROFILE, selector) {
+                    (true, Some(selector)) => {
+                        execute_direct_plan_selected_profiled_with_fanout_and_traffic(
+                            &self.plan,
+                            &selector.row_groups,
+                            selector.representative_flow_id,
+                            &self.executors,
+                            &self.contribution_fanout,
+                            &mut workspace,
+                            point_count,
+                            &mut self.counters,
+                            &mut self.role_timings,
+                            &mut self.traffic_counters,
+                        )
+                    }
+                    (false, Some(selector)) => execute_direct_plan_selected_unprofiled_with_fanout(
+                        &self.plan,
+                        &selector.row_groups,
+                        selector.representative_flow_id,
+                        &self.executors,
+                        &self.contribution_fanout,
+                        &mut workspace,
+                        point_count,
+                    ),
+                    (true, None) => execute_direct_plan_profiled_with_fanout_and_traffic(
+                        &self.plan,
+                        &self.executors,
+                        &self.contribution_fanout,
+                        &mut workspace,
+                        point_count,
+                        &mut self.counters,
+                        &mut self.role_timings,
+                        &mut self.traffic_counters,
+                    ),
+                    (false, None) => execute_direct_plan_unprofiled_with_fanout(
+                        &self.plan,
+                        &self.executors,
+                        &self.contribution_fanout,
+                        &mut workspace,
+                        point_count,
+                    ),
+                }
+            };
+            if PROFILE {
+                self.timings.direct_execution += started
+                    .expect("profiled direct execution has a start time")
+                    .elapsed();
+            }
+            result?;
+            #[cfg(any(test, feature = "on-the-fly-test-support"))]
+            observe_direct_amplitudes_before_replay(
+                &self.plan,
+                selector.map(DirectReplaySelectorPlan::representative_flow_id),
+                &workspace,
+                point_count,
+            )?;
+        }
+
+        if PROFILE {
+            self.activity_counters.schedule_executions =
+                self.activity_counters.schedule_executions.saturating_add(1);
+        }
+        Ok(())
+    }
+
+    fn borrowed_output(
+        &self,
+        point_count: u32,
+        public_flow_id: Option<u32>,
+        representative_flow_id: Option<u32>,
+    ) -> DirectRecurrenceTileOutput<'_> {
+        let (amplitude_re, amplitude_im) = self.arena.amplitude_slices();
+        DirectRecurrenceTileOutput {
+            amplitude_re,
+            amplitude_im,
+            amplitude_destinations: self.plan.amplitude_destinations(),
+            point_count,
+            point_stride: self.point_stride,
+            destination_count: self.plan.amplitude_destination_count(),
+            public_flow_id,
+            representative_flow_id,
+            selected_destination_ids: self.last_selected_destination_ids.as_deref(),
+        }
+    }
+
+    fn validate_point_count(&self, point_count: u32) -> RusticolResult<()> {
+        if point_count == 0 {
+            return Err(invalid("point count must be positive"));
+        }
+        if point_count > self.tile_capacity {
+            return Err(invalid(format!(
+                "point count {point_count} exceeds point tile size {}",
+                self.tile_capacity
+            )));
+        }
+        Ok(())
+    }
+
+    fn compact_momentum_len(&self) -> usize {
+        self.momentum_form_count as usize
+            * usize::from(self.lorentz_component_count)
+            * self.tile_capacity as usize
+    }
+
+    fn activate_point_layout(&mut self, point_count: u32) -> RusticolResult<()> {
+        let packed = point_count == 1;
+        if packed == self.packed_singleton_active || !self.executors.packed_singleton_capable() {
+            return Ok(());
+        }
+        if !packed {
+            self.ensure_tiled_point_storage()?;
+        }
+        if self.alternate_point_storage.is_none() {
+            return Ok(());
+        }
+        if packed {
+            self.restore_physical_momenta();
+            self.copy_momentum_point_zero_to_alternate();
+            let exact_singleton = self.momentum_filled_points == 1;
+            let legacy_full_tile = self.momentum_replay_selector.is_none()
+                && self.momentum_filled_points == self.tile_capacity;
+            let replay_selector = exact_singleton
+                .then_some(self.momentum_replay_selector)
+                .flatten();
+            self.swap_point_storage();
+            self.momentum_filled_points = u32::from(exact_singleton || legacy_full_tile);
+            self.momentum_replay_selector = replay_selector;
+            return Ok(());
+        }
+        self.copy_momentum_point_zero_to_alternate();
+        self.swap_point_storage();
+        Ok(())
+    }
+
+    fn force_tiled_layout(&mut self) -> RusticolResult<()> {
+        if self.packed_singleton_active {
+            self.ensure_tiled_point_storage()?;
+            self.copy_momentum_point_zero_to_alternate();
+            self.swap_point_storage();
+        }
+        Ok(())
+    }
+
+    fn ensure_tiled_point_storage(&mut self) -> RusticolResult<()> {
+        if self.alternate_point_storage.is_some() {
+            return Ok(());
+        }
+        let parameter_view = DirectParameterView {
+            values_re: self.parameters_re.as_ptr(),
+            values_im: self.parameters_im.as_ptr(),
+            value_count: u32::try_from(self.parameters_re.len())
+                .map_err(|_| invalid("parameter catalog exceeds u32"))?,
+        };
+        let factor_view = DirectFactorView {
+            values_re: self.factors_re.as_ptr(),
+            values_im: self.factors_im.as_ptr(),
+            value_count: u32::try_from(self.factors_re.len())
+                .map_err(|_| invalid("factor catalog exceeds u32"))?,
+        };
+        let storage = allocate_point_storage(
+            self.runtime_current_component_count,
+            self.plan.amplitude_destination_count(),
+            self.momentum_plane_count,
+            self.momentum_form_count,
+            self.lorentz_component_count,
+            self.tile_capacity,
+            false,
+            parameter_view,
+            factor_view,
+        )?;
+        let allocation_counters = self
+            .allocation_counters
+            .checked_add(storage.arena.allocation_counters())?
+            .checked_add(storage.momenta.allocation_counters())?;
+        self.alternate_point_storage = Some(storage);
+        self.allocation_counters = allocation_counters;
+        Ok(())
+    }
+
+    fn copy_momentum_point_zero_to_alternate(&mut self) {
+        let source_stride = self.point_stride as usize;
+        let alternate = self
+            .alternate_point_storage
+            .as_mut()
+            .expect("point-zero copy requires alternate point storage");
+        let destination_stride = alternate.arena.point_stride() as usize;
+        let plane_count = self.momentum_plane_count as usize;
+        assert_eq!(
+            self.momenta.len(),
+            plane_count * source_stride,
+            "active momentum storage must cover every physical plane"
+        );
+        assert_eq!(
+            alternate.momenta.len(),
+            plane_count * destination_stride,
+            "alternate momentum storage must cover every physical plane"
+        );
+        let source = self.momenta.as_slice();
+        let destination = alternate.momenta.as_mut_slice();
+        for plane in 0..plane_count {
+            destination[plane * destination_stride] = source[plane * source_stride];
+        }
+    }
+
+    fn swap_point_storage(&mut self) {
+        let alternate = self
+            .alternate_point_storage
+            .as_mut()
+            .expect("layout switching requires alternate point storage");
+        std::mem::swap(&mut self.arena, &mut alternate.arena);
+        std::mem::swap(&mut self.momenta, &mut alternate.momenta);
+        self.point_stride = self.arena.point_stride();
+        self.momenta_are_compact = false;
+        self.momentum_filled_points = 0;
+        self.momentum_replay_selector = None;
+        self.packed_singleton_active = !self.packed_singleton_active;
+        self.last_point_count = 0;
+        self.last_public_flow_id = None;
+        self.last_representative_flow_id = None;
+    }
+
+    fn compact_momenta_for_legacy_access(&mut self) {
+        if self.momenta_are_compact {
+            return;
+        }
+        let plane_count =
+            self.momentum_form_count as usize * usize::from(self.lorentz_component_count);
+        let tile_capacity = self.tile_capacity as usize;
+        let point_stride = self.point_stride as usize;
+        if tile_capacity != point_stride {
+            let momenta = self.momenta.as_mut_slice();
+            for plane in 0..plane_count {
+                let source_start = plane * point_stride;
+                let destination_start = plane * tile_capacity;
+                momenta.copy_within(
+                    source_start..source_start + tile_capacity,
+                    destination_start,
+                );
+            }
+        }
+        self.momenta_are_compact = true;
+    }
+
+    fn restore_physical_momenta(&mut self) {
+        if !self.momenta_are_compact {
+            return;
+        }
+        let plane_count =
+            self.momentum_form_count as usize * usize::from(self.lorentz_component_count);
+        let tile_capacity = self.tile_capacity as usize;
+        let point_stride = self.point_stride as usize;
+        if tile_capacity != point_stride {
+            let momenta = self.momenta.as_mut_slice();
+            for plane in (0..plane_count).rev() {
+                let source_start = plane * tile_capacity;
+                let destination_start = plane * point_stride;
+                momenta.copy_within(
+                    source_start..source_start + tile_capacity,
+                    destination_start,
+                );
+            }
+        }
+        self.momenta_are_compact = false;
+    }
+
+    fn validate_replay_selector(&self, selector: &DirectReplaySelectorPlan) -> RusticolResult<()> {
+        if selector.runtime_layout_digest != self.plan.runtime_layout_digest() {
+            return Err(RusticolError::integrity(
+                "direct recurrence replay selector belongs to a different plan",
+            ));
+        }
+        if selector.source_permutation.len() != self.plan.external_source_count() as usize {
+            return Err(RusticolError::integrity(
+                "direct recurrence replay selector source permutation has an inconsistent length",
+            ));
+        }
+        if selector.source_momentum_signs.len() != selector.source_permutation.len() {
+            return Err(RusticolError::integrity(
+                "direct recurrence replay selector has inconsistent momentum-sign coverage",
+            ));
+        }
+        Ok(())
+    }
+
+    fn validate_union_helicity_descriptor(
+        &self,
+        descriptor: &DirectResolvedHelicityDescriptor,
+    ) -> RusticolResult<(usize, usize)> {
+        let start = usize::try_from(descriptor.source_selection_start).map_err(|_| {
+            RusticolError::integrity("direct recurrence union source-selection start exceeds usize")
+        })?;
+        let count = usize::try_from(descriptor.source_selection_count).map_err(|_| {
+            RusticolError::integrity("direct recurrence union source-selection count exceeds usize")
+        })?;
+        if count != self.plan.external_source_count() as usize {
+            return Err(RusticolError::integrity(
+                "direct recurrence union helicity does not select every external source",
+            ));
+        }
+        let end = start.checked_add(count).ok_or_else(|| {
+            RusticolError::integrity(
+                "direct recurrence union source-selection range overflows usize",
+            )
+        })?;
+        let selections = self
+            .plan
+            .resolved_source_selections()
+            .get(start..end)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "direct recurrence union source-selection range is out of bounds",
+                )
+            })?;
+        for (source_slot, selection) in selections.iter().enumerate() {
+            if selection.source_slot != source_slot as u32 {
+                return Err(RusticolError::integrity(
+                    "direct recurrence union source selections are not in source-slot order",
+                ));
+            }
+            let variant = self
+                .plan
+                .source_dispatch_variants()
+                .get(selection.dispatch_variant_id as usize)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "direct recurrence union source selection references an absent variant",
+                    )
+                })?;
+            let source = self
+                .plan
+                .sources()
+                .get(variant.source_row_id as usize)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "direct recurrence union source variant references an absent row",
+                    )
+                })?;
+            if source.source_slot != selection.source_slot
+                || source.source_template_or_dispatch_domain != variant.dispatch_domain_id
+            {
+                return Err(RusticolError::integrity(
+                    "direct recurrence union source selection disagrees with its variant",
+                ));
+            }
+            let embedding_start = usize::try_from(variant.embedding_start).map_err(|_| {
+                RusticolError::integrity(
+                    "direct recurrence union source embedding start exceeds usize",
+                )
+            })?;
+            let embedding_end = embedding_start
+                .checked_add(variant.embedding_count as usize)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "direct recurrence union source embedding range overflows usize",
+                    )
+                })?;
+            if self
+                .plan
+                .source_embeddings()
+                .get(embedding_start..embedding_end)
+                .is_none()
+            {
+                return Err(RusticolError::integrity(
+                    "direct recurrence union source embedding range is out of bounds",
+                ));
+            }
+        }
+        Ok((start, count))
+    }
+
+    fn validate_union_selector(
+        &self,
+        selector: &DirectUnionHelicitySelectorPlan,
+    ) -> RusticolResult<()> {
+        if self.plan.strategy() != RecurrenceStrategy::AllFlowUnion {
+            return Err(invalid(
+                "union helicity selector requires an all-flow-union recurrence plan",
+            ));
+        }
+        if selector.runtime_layout_digest != self.plan.runtime_layout_digest() {
+            return Err(RusticolError::integrity(
+                "direct recurrence union helicity selector belongs to a different plan",
+            ));
+        }
+        let descriptor = self
+            .plan
+            .resolved_helicities()
+            .get(selector.resolved_helicity_id as usize)
+            .filter(|descriptor| descriptor.id == selector.resolved_helicity_id)
+            .ok_or_else(|| {
+                RusticolError::integrity(
+                    "direct recurrence union helicity selector references an absent helicity",
+                )
+            })?;
+        let (start, count) = self.validate_union_helicity_descriptor(descriptor)?;
+        if start != selector.source_selection_start || count != selector.source_selection_count {
+            return Err(RusticolError::integrity(
+                "direct recurrence union helicity selector ranges do not match the plan",
+            ));
+        }
+        Ok(())
+    }
+}
+
+fn replay_cache_split_complex_scalar_count(
+    plan: &DirectRecurrencePlan,
+    persisted_split_complex_scalar_count: usize,
+    fanout_scratch_component_count: u32,
+) -> RusticolResult<usize> {
+    if plan.strategy() != RecurrenceStrategy::TopologyReplay {
+        return Ok(persisted_split_complex_scalar_count);
+    }
+    let representative_sectors = plan
+        .replay_targets()
+        .iter()
+        .map(|target| target.representative_id)
+        .collect::<BTreeSet<_>>();
+    if representative_sectors.is_empty() {
+        return Ok(persisted_split_complex_scalar_count);
+    }
+    let current_arena_components = u64::from(plan.current_arena_components());
+    let mut maximum = 0_u64;
+    for representative_sector_id in representative_sectors {
+        let summary = plan.selector_work_summary(representative_sector_id)?;
+        let active_current_components = summary
+            .semantic_component_count
+            .min(current_arena_components);
+        let active_complex_planes = active_current_components
+            .checked_add(summary.amplitude_destination_count)
+            .and_then(|count| count.checked_add(u64::from(fanout_scratch_component_count)))
+            .ok_or_else(|| invalid("selected replay cache plane count overflows u64"))?;
+        let active_split_scalars = active_complex_planes
+            .checked_mul(2)
+            .ok_or_else(|| invalid("selected replay cache scalar count overflows u64"))?;
+        maximum = maximum.max(active_split_scalars);
+    }
+    let maximum = usize::try_from(maximum)
+        .map_err(|_| invalid("selected replay cache scalar count exceeds usize"))?;
+    if maximum == 0 {
+        return Err(invalid(
+            "topology-replay selector domains expose no cache-resident work",
+        ));
+    }
+    Ok(maximum.min(persisted_split_complex_scalar_count))
+}
+
+fn greatest_power_of_two_not_exceeding(value: usize) -> usize {
+    if value == 0 {
+        return 1;
+    }
+    1_usize << (usize::BITS - 1 - value.leading_zeros())
+}
+
+/// Component storage can be recycled after a current's last use. Resolve
+/// parents by lifetime, not by their physical component address alone.
+struct ReplayCurrentIndex {
+    by_stage_and_base: BTreeMap<(u16, u32), usize>,
+    by_base: BTreeMap<u32, Vec<usize>>,
+}
+
+impl ReplayCurrentIndex {
+    fn new(plan: &DirectRecurrencePlan) -> RusticolResult<Self> {
+        let mut by_stage_and_base = BTreeMap::new();
+        let mut by_base = BTreeMap::<u32, Vec<usize>>::new();
+        for (id, current) in plan.currents().iter().enumerate() {
+            if by_stage_and_base
+                .insert((current.stage, current.component_base), id)
+                .is_some()
+            {
+                return Err(invalid("replay current address is repeated within a stage"));
+            }
+            by_base.entry(current.component_base).or_default().push(id);
+        }
+        for ids in by_base.values_mut() {
+            ids.sort_unstable_by_key(|&id| {
+                let current = &plan.currents()[id];
+                (current.first_use, current.last_use, id)
+            });
+        }
+        Ok(Self {
+            by_stage_and_base,
+            by_base,
+        })
+    }
+
+    fn destination(&self, stage: u16, base: u32) -> RusticolResult<usize> {
+        self.by_stage_and_base
+            .get(&(stage, base))
+            .copied()
+            .ok_or_else(|| invalid("replay contribution has no current at its stage"))
+    }
+
+    fn parent(&self, plan: &DirectRecurrencePlan, stage: u16, base: u32) -> RusticolResult<usize> {
+        let ids = self
+            .by_base
+            .get(&base)
+            .ok_or_else(|| invalid("replay parent current address is absent"))?;
+        let end = ids.partition_point(|&id| plan.currents()[id].first_use <= u32::from(stage));
+        ids.get(end.wrapping_sub(1))
+            .copied()
+            .filter(|&id| plan.currents()[id].last_use >= u32::from(stage))
+            .ok_or_else(|| invalid("replay parent current is not live at its use stage"))
+    }
+}
+
+fn selected_replay_destination_program(
+    plan: &DirectRecurrencePlan,
+    representative: u32,
+    flow_groups: &[DirectRowGroupDescriptor],
+    destination_ids: &[u32],
+) -> RusticolResult<DirectReplayDestinationProgram> {
+    if destination_ids.windows(2).any(|pair| pair[0] >= pair[1]) {
+        return Err(invalid(
+            "replay amplitude destination IDs must be sorted and unique",
+        ));
+    }
+    let mut amplitude_marks =
+        zeroed_marks(plan.amplitude_destinations().len(), "destination selection")?;
+    for &id in destination_ids {
+        let destination = plan
+            .amplitude_destinations()
+            .get(id as usize)
+            .filter(|destination| destination.target_sector_id == representative)
+            .ok_or_else(|| {
+                invalid("replay amplitude destination is outside the selected representative")
+            })?;
+        amplitude_marks[destination.id as usize] = 1;
+    }
+
+    let index = ReplayCurrentIndex::new(plan)?;
+    let mut source_marks = zeroed_marks(plan.sources().len(), "source selection")?;
+    let mut contribution_marks =
+        zeroed_marks(plan.contributions().len(), "contribution selection")?;
+    let mut finalization_marks =
+        zeroed_marks(plan.finalizations().len(), "finalization selection")?;
+    let mut closure_marks = zeroed_marks(plan.closures().len(), "closure selection")?;
+    let mut current_marks = zeroed_marks(plan.currents().len(), "current selection")?;
+    let mut contributions_by_current = vec![Vec::<(usize, u16)>::new(); plan.currents().len()];
+    let mut finalizations_by_current = vec![Vec::<usize>::new(); plan.currents().len()];
+    let mut pending = Vec::new();
+    for group in flow_groups {
+        let start = group.row_start as usize;
+        let end = start + group.row_count as usize;
+        match group.role {
+            DirectExecutorRole::Contribution => {
+                for row_id in start..end {
+                    let row = &plan.contributions()[row_id];
+                    let current = index.destination(group.stage, row.destination_component_base)?;
+                    contributions_by_current[current].push((row_id, group.stage));
+                }
+            }
+            DirectExecutorRole::Finalization => {
+                for row_id in start..end {
+                    let row = &plan.finalizations()[row_id];
+                    let current = index.destination(group.stage, row.component_base)?;
+                    finalizations_by_current[current].push(row_id);
+                }
+            }
+            DirectExecutorRole::Closure => {
+                for (row, mark) in plan.closures()[start..end]
+                    .iter()
+                    .zip(&mut closure_marks[start..end])
+                {
+                    if amplitude_marks[row.amplitude_destination_id as usize] == 0 {
+                        continue;
+                    }
+                    *mark = 1;
+                    pending.push(index.parent(plan, group.stage, row.parent0_component_base)?);
+                    if row.parent1_component_base_or_sentinel != DIRECT_NONE_U32 {
+                        pending.push(index.parent(
+                            plan,
+                            group.stage,
+                            row.parent1_component_base_or_sentinel,
+                        )?);
+                    }
+                }
+            }
+            DirectExecutorRole::Source => {}
+        }
+    }
+    while let Some(current_id) = pending.pop() {
+        if current_marks[current_id] != 0 {
+            continue;
+        }
+        current_marks[current_id] = 1;
+        let current = &plan.currents()[current_id];
+        if current.source_row_or_sentinel != DIRECT_NONE_U32 {
+            source_marks[current.source_row_or_sentinel as usize] = 1;
+        }
+        for &row_id in &finalizations_by_current[current_id] {
+            finalization_marks[row_id] = 1;
+        }
+        for &(row_id, stage) in &contributions_by_current[current_id] {
+            let row = &plan.contributions()[row_id];
+            contribution_marks[row_id] = 1;
+            pending.push(index.parent(plan, stage, row.parent0_component_base)?);
+            if row.parent1_component_base_or_sentinel != DIRECT_NONE_U32 {
+                pending.push(index.parent(plan, stage, row.parent1_component_base_or_sentinel)?);
+            }
+        }
+    }
+
+    let mut row_groups = Vec::new();
+    for group in flow_groups {
+        let marks = match group.role {
+            DirectExecutorRole::Source => &source_marks,
+            DirectExecutorRole::Contribution => &contribution_marks,
+            DirectExecutorRole::Finalization => &finalization_marks,
+            DirectExecutorRole::Closure => &closure_marks,
+        };
+        let end = group.row_start as usize + group.row_count as usize;
+        let mut row = group.row_start as usize;
+        while row < end {
+            if marks[row] == 0 {
+                row += 1;
+                continue;
+            }
+            let start = row;
+            while row < end && marks[row] != 0 {
+                row += 1;
+            }
+            row_groups.push(DirectRowGroupDescriptor {
+                row_start: start as u64,
+                row_count: (row - start) as u32,
+                ..*group
+            });
+        }
+    }
+    let mut clear_by_stage = BTreeMap::<u16, Vec<Range<u32>>>::new();
+    for (id, current) in plan.currents().iter().enumerate() {
+        if current_marks[id] == 0 || current.node_kind != DirectNodeKind::Current {
+            continue;
+        }
+        // Dependency closure retains every contribution to a live current in
+        // this flow selection, in its persisted execution order. When that
+        // first retained row overwrites the destination, clearing it would
+        // duplicate the write. Check the already-built row list here rather
+        // than adding a separate analysis or any work to tile execution.
+        // A valid custom plan may select away the global initializer through
+        // a narrower row selector domain; retain its ordinary clear below.
+        if contributions_by_current[id]
+            .first()
+            .is_some_and(|&(row_id, _)| {
+                let row = &plan.contributions()[row_id];
+                if row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION == 0 {
+                    return false;
+                }
+                // Retain self-read clears even for a persisted zero factor:
+                // the low-level runtime allows callers to replace factors.
+                // Native output widths were checked during runtime loading;
+                // copy widths live in the row and must cover the full target.
+                row.parent0_component_base != row.destination_component_base
+                    && row.parent1_component_base_or_sentinel != row.destination_component_base
+                    && (row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE == 0
+                        || row.parent0_momentum_form_id == u32::from(current.component_count))
+            })
+        {
+            continue;
+        }
+        clear_by_stage.entry(current.stage).or_default().push(
+            current.component_base..current.component_base + u32::from(current.component_count),
+        );
+    }
+    let current_clear_stages = clear_by_stage
+        .into_iter()
+        .map(|(stage, mut ranges)| {
+            ranges.sort_unstable_by_key(|range| range.start);
+            let mut merged = Vec::<DirectCurrentClearRange>::new();
+            for range in ranges {
+                if let Some(last) = merged.last_mut()
+                    && range.start <= last.component_base + last.component_count
+                {
+                    last.component_count = (last.component_base + last.component_count)
+                        .max(range.end)
+                        - last.component_base;
+                    continue;
+                }
+                merged.push(DirectCurrentClearRange {
+                    component_base: range.start,
+                    component_count: range.end - range.start,
+                });
+            }
+            DirectStageClearRanges {
+                stage,
+                ranges: merged.into_boxed_slice(),
+            }
+        })
+        .collect::<Vec<_>>();
+    Ok(DirectReplayDestinationProgram {
+        destination_ids: Arc::from(destination_ids),
+        row_groups: row_groups.into_boxed_slice(),
+        amplitude_clear_ranges: compact_ranges(&amplitude_marks, "destination selection")?
+            .into_boxed_slice(),
+        current_clear_stages: current_clear_stages.into_boxed_slice(),
+    })
+}
+
+fn selected_replay_row_groups(
+    plan: &DirectRecurrencePlan,
+    representative_sector_id: u32,
+) -> RusticolResult<Vec<DirectRowGroupDescriptor>> {
+    let mut selected = Vec::new();
+    for descriptor in plan.row_groups() {
+        let start = usize::try_from(descriptor.row_start).map_err(|_| {
+            RusticolError::integrity("direct recurrence row-group start exceeds usize")
+        })?;
+        let count = descriptor.row_count as usize;
+        let mut offset = 0usize;
+        while offset < count {
+            let run_start = offset;
+            let selector_domain_id =
+                row_selector_domain_id(plan, descriptor.role, start + run_start)?;
+            while offset < count
+                && row_selector_domain_id(plan, descriptor.role, start + offset)?
+                    == selector_domain_id
+            {
+                offset += 1;
+            }
+            // Preserve selector-domain boundaries even when adjacent domains
+            // are both active, so full-flow fanout runs retain their original
+            // authenticated partitions.
+            if !plan.selector_domain_contains(selector_domain_id, representative_sector_id)? {
+                continue;
+            }
+            let mut run = *descriptor;
+            run.row_start = descriptor
+                .row_start
+                .checked_add(run_start as u64)
+                .ok_or_else(|| {
+                    RusticolError::integrity(
+                        "direct recurrence selected row-group start overflows u64",
+                    )
+                })?;
+            run.row_count = u32::try_from(offset - run_start).map_err(|_| {
+                RusticolError::integrity("direct recurrence selected row-group count exceeds u32")
+            })?;
+            selected.push(run);
+        }
+    }
+    if selected.is_empty() {
+        return Err(RusticolError::integrity(format!(
+            "direct recurrence representative sector {representative_sector_id} has no executable rows"
+        )));
+    }
+    Ok(selected)
+}
+
+fn row_selector_domain_id(
+    plan: &DirectRecurrencePlan,
+    role: DirectExecutorRole,
+    row_index: usize,
+) -> RusticolResult<u32> {
+    match role {
+        DirectExecutorRole::Source => plan
+            .sources()
+            .get(row_index)
+            .map(|row| row.selector_domain_id),
+        DirectExecutorRole::Contribution => plan
+            .contributions()
+            .get(row_index)
+            .map(|row| row.selector_domain_id),
+        DirectExecutorRole::Finalization => plan
+            .finalizations()
+            .get(row_index)
+            .map(|row| row.selector_domain_id),
+        DirectExecutorRole::Closure => plan
+            .closures()
+            .get(row_index)
+            .map(|row| row.selector_domain_id),
+    }
+    .ok_or_else(|| RusticolError::integrity("direct recurrence selected row is out of bounds"))
+}
+
+fn selected_amplitude_clear_ranges(
+    plan: &DirectRecurrencePlan,
+    representative_sector_id: u32,
+) -> RusticolResult<Vec<Range<usize>>> {
+    let destination_count = usize::try_from(plan.amplitude_destination_count())
+        .map_err(|_| invalid("amplitude destination count exceeds usize"))?;
+    let mut marked = zeroed_marks(destination_count, "selected amplitude clear map")?;
+    for destination in plan.amplitude_destinations() {
+        if plan
+            .selector_domain_contains(destination.selector_domain_id, representative_sector_id)?
+        {
+            mark_range(
+                &mut marked,
+                destination.id as usize,
+                1,
+                "selected amplitude",
+            )?;
+        }
+    }
+    compact_ranges(&marked, "selected amplitude")
+}
+
+fn amplitude_clear_ranges(plan: &DirectRecurrencePlan) -> RusticolResult<Vec<Range<usize>>> {
+    let destination_count = usize::try_from(plan.amplitude_destination_count())
+        .map_err(|_| invalid("amplitude destination count exceeds usize"))?;
+    let mut marked = zeroed_marks(destination_count, "amplitude clear map")?;
+    for row in plan.closures() {
+        mark_range(
+            &mut marked,
+            row.amplitude_destination_id as usize,
+            1,
+            "amplitude",
+        )?;
+    }
+    compact_ranges(&marked, "amplitude")
+}
+
+fn zeroed_marks(len: usize, label: &str) -> RusticolResult<Vec<u8>> {
+    let mut values = Vec::new();
+    values.try_reserve_exact(len).map_err(|error| {
+        RusticolError::internal(format!(
+            "could not allocate direct recurrence {label}: {error}"
+        ))
+    })?;
+    values.resize(len, 0);
+    Ok(values)
+}
+
+fn mark_range(marked: &mut [u8], start: usize, count: usize, label: &str) -> RusticolResult<()> {
+    let end = start
+        .checked_add(count)
+        .ok_or_else(|| RusticolError::integrity(format!("{label} clear range overflows usize")))?;
+    let range = marked.get_mut(start..end).ok_or_else(|| {
+        RusticolError::integrity(format!("{label} clear range exceeds its arena"))
+    })?;
+    range.fill(1);
+    Ok(())
+}
+
+fn compact_ranges(marked: &[u8], label: &str) -> RusticolResult<Vec<Range<usize>>> {
+    let mut ranges = Vec::new();
+    ranges.try_reserve_exact(marked.len()).map_err(|error| {
+        RusticolError::internal(format!(
+            "could not allocate direct recurrence {label} clear ranges: {error}"
+        ))
+    })?;
+    let mut index = 0;
+    while index < marked.len() {
+        if marked[index] == 0 {
+            index += 1;
+            continue;
+        }
+        let start = index;
+        while index < marked.len() && marked[index] != 0 {
+            index += 1;
+        }
+        ranges.push(start..index);
+    }
+    Ok(ranges)
+}
+
+/// Interpret an already validated, generation-time momentum form. Only
+/// independent phase-space points are reordered: each point keeps its original
+/// initial addition and term order, including cancellation and signed zero.
+/// There is no auxiliary input buffer or selection-dependent preparation.
+#[inline]
+fn fill_momentum_form_from_external<const SOURCE_MAJOR: bool>(
+    form_planes: &mut [f64],
+    point_stride: usize,
+    active_points: usize,
+    external_four_momenta: &[f64],
+    source_count: usize,
+    mut terms: impl Iterator<Item = (usize, f64)>,
+) {
+    let Some(first) = terms.next() else {
+        for plane in form_planes.chunks_exact_mut(point_stride) {
+            plane[..active_points].fill(0.0);
+        }
+        return;
+    };
+    fill_external_momentum_term::<true, SOURCE_MAJOR>(
+        form_planes,
+        point_stride,
+        active_points,
+        external_four_momenta,
+        source_count,
+        first,
+    );
+    for term in terms {
+        fill_external_momentum_term::<false, SOURCE_MAJOR>(
+            form_planes,
+            point_stride,
+            active_points,
+            external_four_momenta,
+            source_count,
+            term,
+        );
+    }
+}
+
+#[inline]
+fn fill_external_momentum_term<const INITIALIZE: bool, const SOURCE_MAJOR: bool>(
+    form_planes: &mut [f64],
+    point_stride: usize,
+    active_points: usize,
+    external_four_momenta: &[f64],
+    source_count: usize,
+    (external_slot, coefficient): (usize, f64),
+) {
+    let external_point_stride = source_count * 4;
+    for (component, plane) in form_planes.chunks_exact_mut(point_stride).enumerate() {
+        if SOURCE_MAJOR {
+            let input_start = (external_slot * 4 + component) * active_points;
+            for (value, source) in plane[..active_points]
+                .iter_mut()
+                .zip(&external_four_momenta[input_start..input_start + active_points])
+            {
+                if INITIALIZE {
+                    *value = 0.0 + coefficient * source;
+                } else {
+                    *value += coefficient * source;
+                }
+            }
+        } else {
+            let input_start = external_slot * 4 + component;
+            for (value, source) in plane[..active_points].iter_mut().zip(
+                external_four_momenta[input_start..]
+                    .iter()
+                    .step_by(external_point_stride),
+            ) {
+                if INITIALIZE {
+                    *value = 0.0 + coefficient * source;
+                } else {
+                    *value += coefficient * source;
+                }
+            }
+        }
+    }
+}
+
+fn validate_split_values(
+    label: &str,
+    expected_len: usize,
+    values_re: &[f64],
+    values_im: &[f64],
+) -> RusticolResult<()> {
+    if values_re.len() != expected_len || values_im.len() != expected_len {
+        return Err(invalid(format!(
+            "{label} split-complex lengths are {}, {}, expected {expected_len}",
+            values_re.len(),
+            values_im.len()
+        )));
+    }
+    Ok(())
+}
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(format!(
+        "direct recurrence execution runtime: {}",
+        message.into()
+    ))
+}
+
+#[cfg(test)]
+#[path = "direct_runtime_tests.rs"]
+mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_runtime_tests.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_runtime_tests.rs
new file mode 100644
index 0000000000..5828acc188
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/direct_runtime_tests.rs
@@ -0,0 +1,3178 @@
+// SPDX-License-Identifier: 0BSD
+
+use crate::recurrence::direct_backend::{
+    DIRECT_STATUS_OK, DirectArenaView, DirectContributionExecutionMetadata,
+    DirectContributionExecutor, DirectContributionFanoutBatch,
+    DirectContributionFanoutExecutorHandle, DirectContributionFanoutProgram,
+    DirectExecutionCounters, DirectExecutorCatalog, DirectExecutorHandle, DirectFactorView,
+    DirectFinalizationExecutor, DirectInteractionBundleBatch, DirectInteractionExecutorContexts,
+    DirectInteractionIntrinsicKind, DirectInteractionOperands, DirectInteractionVectorParent,
+    DirectMomentumView, DirectParameterView, DirectSourceExecutor, DirectWorkspace,
+    begin_direct_current_observation, execute_direct_plan,
+    execute_direct_plan_unprofiled_with_fanout, take_direct_current_observation,
+};
+use crate::recurrence::direct_plan::{
+    DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION, DirectClosureRow, DirectContributionRow,
+    DirectFinalizationRow, DirectMomentumTerm, DirectRecurrencePlan, DirectReplayTargetDescriptor,
+    DirectSourceRow, DirectSourceStateAssignment,
+};
+use crate::recurrence::direct_runtime::{
+    DIRECT_RUNTIME_ARENA_ALIGNMENT, DirectRecurrenceExecutionRuntime, DirectRecurrenceTileOutput,
+    DirectRuntimeActivityCounters, replay_cache_split_complex_scalar_count,
+};
+use crate::recurrence::exact::{ExactComplexRational, ExactRational};
+#[allow(unused_imports)]
+use crate::recurrence::{
+    CheckedTableRange, ClosureExecutionProofGroupV2, ClosureProofContributionV2,
+    ClosureProofMetadataV2, DIRECT_NONE_U32, DirectAmplitudeDestinationDescriptor,
+    DirectCurrentDescriptor, DirectDestinationOperation, DirectExecutorRole,
+    DirectMomentumFormDescriptor, DirectNodeKind, DirectResolvedHelicityDescriptor,
+    DirectRowGroupDescriptor, DirectSelectorDomainDescriptor, RecurrenceStrategy, SemanticDigest,
+    closure_component_factor_digest_v2, closure_selector_domain_digest_v2,
+};
+use std::ffi::c_void;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+const STATUS_BOUNDS: i32 = 2;
+
+fn direct_executor_handles() -> Vec<DirectExecutorHandle> {
+    vec![
+        DirectExecutorHandle::Source {
+            call: fill_sources as DirectSourceExecutor,
+            context: std::ptr::null(),
+        },
+        DirectExecutorHandle::Contribution {
+            call: accumulate_contributions as DirectContributionExecutor,
+            context: std::ptr::null(),
+        },
+        DirectExecutorHandle::Finalization {
+            call: finalize_currents as DirectFinalizationExecutor,
+            context: std::ptr::null(),
+        },
+        DirectExecutorHandle::Closure {
+            call: accumulate_closures,
+            context: std::ptr::null(),
+        },
+    ]
+}
+
+unsafe extern "C" fn fill_sources(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    _factors: DirectFactorView,
+    rows: *const DirectSourceRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        for point in 0..point_count as usize {
+            let source = row.momentum_form_id as usize
+                * momenta.lorentz_component_count as usize
+                * momenta.point_stride as usize
+                + point;
+            let destination =
+                row.destination_component_base as usize * arena.point_stride as usize + point;
+            if source >= momenta.scalar_len as usize
+                || destination >= arena.current_scalar_len as usize
+            {
+                return STATUS_BOUNDS;
+            }
+            unsafe {
+                *arena.current_re.add(destination) = *momenta.values.add(source);
+                *arena.current_im.add(destination) = 0.0;
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+unsafe extern "C" fn accumulate_contributions(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        if row.exact_factor_id >= factors.value_count || parameters.value_count == 0 {
+            return STATUS_BOUNDS;
+        }
+        let factor_re = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        let factor_im = unsafe { *factors.values_im.add(row.exact_factor_id as usize) };
+        let parameter_re = unsafe { *parameters.values_re };
+        let parameter_im = unsafe { *parameters.values_im };
+        let scale_re = factor_re * parameter_re - factor_im * parameter_im;
+        let scale_im = factor_re * parameter_im + factor_im * parameter_re;
+        for point in 0..point_count as usize {
+            let source = row.parent0_component_base as usize * arena.point_stride as usize + point;
+            let destination =
+                row.destination_component_base as usize * arena.point_stride as usize + point;
+            if source >= arena.current_scalar_len as usize
+                || destination >= arena.current_scalar_len as usize
+            {
+                return STATUS_BOUNDS;
+            }
+            let source_re = unsafe { *arena.current_re.add(source) };
+            let source_im = unsafe { *arena.current_im.add(source) };
+            let value_re = source_re * scale_re - source_im * scale_im;
+            let value_im = source_re * scale_im + source_im * scale_re;
+            unsafe {
+                if row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0 {
+                    *arena.current_re.add(destination) = value_re;
+                    *arena.current_im.add(destination) = value_im;
+                } else {
+                    *arena.current_re.add(destination) += value_re;
+                    *arena.current_im.add(destination) += value_im;
+                }
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+#[derive(Default)]
+struct ContributionCallCensus {
+    calls: AtomicU64,
+    rows: AtomicU64,
+}
+
+#[derive(Default)]
+struct InteractionDispatchCensus {
+    calls: AtomicU64,
+}
+
+unsafe extern "C" fn counted_accumulate_contributions(
+    context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    if context.is_null() {
+        return STATUS_BOUNDS;
+    }
+    let census = unsafe { &*context.cast::<ContributionCallCensus>() };
+    census.calls.fetch_add(1, Ordering::Relaxed);
+    census
+        .rows
+        .fetch_add(u64::from(row_count), Ordering::Relaxed);
+    unsafe {
+        accumulate_contributions(
+            std::ptr::null(),
+            arena,
+            momenta,
+            parameters,
+            factors,
+            rows,
+            row_count,
+            point_count,
+        )
+    }
+}
+
+unsafe fn unexpected_single_point_fanout(
+    _context: *const c_void,
+    _arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    _factors: DirectFactorView,
+    _batch: DirectContributionFanoutBatch<'_>,
+) -> crate::RusticolResult<()> {
+    panic!("single-point contribution fanout bypassed the interaction action")
+}
+
+unsafe fn inspect_nonidentity_interaction_dispatch(
+    contexts: DirectInteractionExecutorContexts,
+    _arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    _factors: DirectFactorView,
+    batch: DirectInteractionBundleBatch<'_>,
+) -> crate::RusticolResult<()> {
+    assert!(!contexts.color.is_null());
+    assert_eq!(contexts.color, contexts.antisymmetric_tensor_vector);
+    assert_eq!(batch.anchors.len(), 1);
+    assert_eq!(batch.outputs.len(), 2);
+    assert!(batch.atv_before_color);
+
+    let anchor = batch.anchors[0];
+    assert_eq!(anchor.output_start, 0);
+    assert_eq!(anchor.output_end, 2);
+    assert!(matches!(
+        anchor.operands,
+        DirectInteractionOperands::One(operand)
+            if operand.tensor_component_base == 1
+                && operand.vector_parent == DirectInteractionVectorParent::Parent0
+    ));
+    assert_eq!(
+        batch
+            .outputs
+            .iter()
+            .map(|output| output.destination_component_base)
+            .collect::<Vec<_>>(),
+        [3, 2]
+    );
+    assert!(batch.outputs.iter().all(|output| output.initialize));
+
+    let census = unsafe { &*contexts.color.cast::<InteractionDispatchCensus>() };
+    census.calls.fetch_add(1, Ordering::Relaxed);
+    Ok(())
+}
+
+unsafe extern "C" fn finalize_currents(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectFinalizationRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        if row.exact_factor_id >= factors.value_count {
+            return STATUS_BOUNDS;
+        }
+        let factor = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        for component in 0..usize::from(row.component_count) {
+            for point in 0..point_count as usize {
+                let destination =
+                    (row.component_base as usize + component) * arena.point_stride as usize + point;
+                if destination >= arena.current_scalar_len as usize {
+                    return STATUS_BOUNDS;
+                }
+                unsafe {
+                    *arena.current_re.add(destination) *= factor;
+                    *arena.current_im.add(destination) *= factor;
+                }
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+unsafe extern "C" fn accumulate_closures(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectClosureRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        if row.exact_factor_id >= factors.value_count {
+            return STATUS_BOUNDS;
+        }
+        let factor = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        for point in 0..point_count as usize {
+            let source = row.parent0_component_base as usize * arena.point_stride as usize + point;
+            let destination =
+                row.amplitude_destination_id as usize * arena.point_stride as usize + point;
+            if source >= arena.current_scalar_len as usize
+                || destination >= arena.amplitude_scalar_len as usize
+            {
+                return STATUS_BOUNDS;
+            }
+            unsafe {
+                *arena.amplitude_re.add(destination) += *arena.current_re.add(source) * factor;
+                *arena.amplitude_im.add(destination) += *arena.current_im.add(source) * factor;
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+fn rational(numerator: i128, denominator: i128) -> ExactComplexRational {
+    complex_rational(numerator, denominator, 0, 1)
+}
+
+fn complex_rational(
+    real_numerator: i128,
+    real_denominator: i128,
+    imag_numerator: i128,
+    imag_denominator: i128,
+) -> ExactComplexRational {
+    ExactComplexRational::new(
+        ExactRational::new(real_numerator, real_denominator).unwrap(),
+        ExactRational::new(imag_numerator, imag_denominator).unwrap(),
+    )
+}
+
+fn replace_single_closure_proof_factor(
+    parts: &mut crate::recurrence::DirectRecurrencePlanParts,
+    exact_factor: ExactComplexRational,
+    runtime_parent_ids: Option<Vec<Option<u32>>>,
+) {
+    let contribution = &parts.closure_proofs.contributions()[0];
+    let contribution = ClosureProofContributionV2::new(
+        contribution.id(),
+        contribution.target_sector_id(),
+        contribution.target_destination_id(),
+        contribution.target_helicity_id(),
+        contribution.closure_template_id(),
+        contribution.closure_template_semantic_digest(),
+        contribution.quantum_flow_template_id(),
+        contribution.construction_parent_builder_ids().to_vec(),
+        runtime_parent_ids
+            .unwrap_or_else(|| contribution.construction_parent_runtime_ids().to_vec()),
+        contribution.construction_parent_semantic_digests().to_vec(),
+        contribution.construction_parent_color_digests().to_vec(),
+        contribution.construction_parent_permutation().to_vec(),
+        contribution.reconstruction_parent_permutation().to_vec(),
+        contribution.evaluator_parent_permutation().to_vec(),
+        contribution.color_witness_term_id(),
+        contribution.color_witness_proof_digest(),
+        contribution.three_line_certificate_id(),
+        contribution.pairing_certificate_ids().to_vec(),
+        contribution.reflection_certificate_id(),
+        exact_factor,
+        contribution.multiplicity(),
+    )
+    .unwrap();
+    let group = &parts.closure_proofs.groups()[0];
+    let closure = &parts.closures[group.emitted_direct_closure_row_id().unwrap() as usize];
+    let component_start = closure.component_factor_start as usize;
+    let component_end = component_start + closure.component_count as usize;
+    let component_factor_digest =
+        closure_component_factor_digest_v2(&parts.exact_factors[component_start..component_end])
+            .unwrap();
+    let group = ClosureExecutionProofGroupV2::new_with_candidate_selector_domain(
+        group.id(),
+        group.emitted_runtime_closure_term_id(),
+        group.emitted_direct_closure_row_id(),
+        group.contribution_range(),
+        exact_factor,
+        component_factor_digest,
+        group.candidate_selector_domain_digest(),
+        group.selector_domain_digest(),
+    )
+    .unwrap();
+    parts.closure_proofs = ClosureProofMetadataV2::new_with_three_line_certificates(
+        vec![contribution],
+        vec![group],
+        parts.closure_proofs.reflection_certificates().to_vec(),
+        parts
+            .closure_proofs
+            .three_line_traversal_certificates()
+            .to_vec(),
+    )
+    .unwrap();
+}
+
+#[cfg(any())]
+fn synthetic_plan_and_executors() -> (DirectRecurrencePlan, DirectExecutorCatalog) {
+    let plan = DirectRecurrencePlan::new(DirectRecurrencePlanParts {
+        strategy: RecurrenceStrategy::TopologyReplay,
+        semantic_digest: SemanticDigest::new([0x11; 32]).unwrap(),
+        prepared_pack_digest: SemanticDigest::new([0x22; 32]).unwrap(),
+        direct_template_catalog_digest: SemanticDigest::new([0x33; 32]).unwrap(),
+        point_tile_size: 4,
+        workspace_mib: 1,
+        current_arena_components: 2,
+        physical_sector_count: 2,
+        retained_helicity_count: 2,
+        amplitude_destination_count: 1,
+        parameter_value_count: 1,
+        external_source_count: 2,
+        state_template_count: 2,
+        source_template_or_dispatch_count: 1,
+        direct_executor_count: 4,
+        currents: vec![
+            DirectCurrentDescriptor {
+                semantic_current_id: 0,
+                node_kind: DirectNodeKind::Source,
+                state_template_id: 0,
+                component_base: 0,
+                component_count: 1,
+                momentum_form_id: 0,
+                stage: 0,
+                selector_domain_id: 0,
+                first_use: 0,
+                last_use: 1,
+                source_row_or_sentinel: 0,
+                finalization_row_or_sentinel: DIRECT_NONE_U32,
+            },
+            DirectCurrentDescriptor {
+                semantic_current_id: 1,
+                node_kind: DirectNodeKind::Current,
+                state_template_id: 1,
+                component_base: 1,
+                component_count: 1,
+                momentum_form_id: 0,
+                stage: 1,
+                selector_domain_id: 0,
+                first_use: 1,
+                last_use: 2,
+                source_row_or_sentinel: DIRECT_NONE_U32,
+                finalization_row_or_sentinel: 0,
+            },
+        ],
+        sources: vec![DirectSourceRow {
+            source_slot: 0,
+            destination_component_base: 0,
+            momentum_form_id: 0,
+            source_template_or_dispatch_domain: 0,
+            spin_state_class: 1,
+            exact_factor_id: 3,
+            selector_domain_id: 0,
+        }],
+        contributions: vec![DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            destination_component_base: 1,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        }],
+        finalizations: vec![DirectFinalizationRow {
+            component_base: 1,
+            component_count: 1,
+            momentum_form_id: 0,
+            exact_factor_id: 1,
+            selector_domain_id: 0,
+            flags: 0,
+        }],
+        closures: vec![DirectClosureRow {
+            parent0_component_base: 1,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            amplitude_destination_id: 0,
+            exact_factor_id: 2,
+            component_factor_start: 0,
+            component_count: 1,
+            selector_domain_id: 0,
+            flags: 0,
+        }],
+        row_groups: vec![
+            DirectRowGroupDescriptor {
+                stage: 0,
+                role: DirectExecutorRole::Source,
+                destination_operation: DirectDestinationOperation::Initialize,
+                direct_executor_id: 0,
+                row_start: 0,
+                row_count: 1,
+            },
+            DirectRowGroupDescriptor {
+                stage: 1,
+                role: DirectExecutorRole::Contribution,
+                destination_operation: DirectDestinationOperation::Add,
+                direct_executor_id: 1,
+                row_start: 0,
+                row_count: 1,
+            },
+            DirectRowGroupDescriptor {
+                stage: 1,
+                role: DirectExecutorRole::Finalization,
+                destination_operation: DirectDestinationOperation::FinalizeInPlace,
+                direct_executor_id: 2,
+                row_start: 0,
+                row_count: 1,
+            },
+            DirectRowGroupDescriptor {
+                stage: 2,
+                role: DirectExecutorRole::Closure,
+                destination_operation: DirectDestinationOperation::ClosureAdd,
+                direct_executor_id: 3,
+                row_start: 0,
+                row_count: 1,
+            },
+        ],
+        momentum_forms: vec![DirectMomentumFormDescriptor {
+            term_start: 0,
+            term_count: 2,
+        }],
+        momentum_terms: vec![
+            DirectMomentumTerm {
+                source_slot: 0,
+                coefficient: 1,
+            },
+            DirectMomentumTerm {
+                source_slot: 1,
+                coefficient: 2,
+            },
+        ],
+        selector_domains: vec![DirectSelectorDomainDescriptor {
+            word_start: 0,
+            word_count: 1,
+        }],
+        selector_words: vec![1],
+        replay_targets: vec![
+            DirectReplayTargetDescriptor {
+                public_flow_id: 0,
+                representative_id: 0,
+                source_permutation_start: 0,
+                source_permutation_count: 2,
+                helicity_map_start: 0,
+                helicity_map_count: 1,
+                phase_exact_factor_id: 3,
+                multiplicity: 1,
+                selector_domain_id: 0,
+            },
+            DirectReplayTargetDescriptor {
+                public_flow_id: 1,
+                representative_id: 0,
+                source_permutation_start: 2,
+                source_permutation_count: 2,
+                helicity_map_start: 1,
+                helicity_map_count: 1,
+                phase_exact_factor_id: 4,
+                multiplicity: 2,
+                selector_domain_id: 0,
+            },
+        ],
+        source_permutations: vec![0, 1, 1, 0],
+        replay_momentum_signs: vec![1, 1, 1, 1],
+        replay_helicity_map: vec![0, 0],
+        amplitude_destinations: vec![DirectAmplitudeDestinationDescriptor {
+            closure_row_start: 0,
+            id: 0,
+            target_sector_id: 0,
+            target_helicity_id_or_sentinel: 0,
+            closure_row_count: 1,
+            selector_domain_id: 0,
+        }],
+        resolved_helicities: vec![DirectResolvedHelicityDescriptor {
+            source_state_start: 0,
+            public_helicity_start: 0,
+            id: 0,
+            source_state_count: 2,
+            public_helicity_count: 2,
+            selector_domain_id: 0,
+        }],
+        source_state_assignments: vec![
+            DirectSourceStateAssignment {
+                source_slot: 0,
+                state_index: 0,
+            },
+            DirectSourceStateAssignment {
+                source_slot: 1,
+                state_index: 0,
+            },
+        ],
+        public_helicities: vec![-1, 1],
+        exact_factors: vec![
+            rational(2, 1),
+            rational(1, 2),
+            rational(-1, 1),
+            ExactComplexRational::ONE,
+            complex_rational(0, 1, 1, 1),
+        ],
+    })
+    .unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    (plan, executors)
+}
+
+fn synthetic_plan_and_executors() -> (DirectRecurrencePlan, DirectExecutorCatalog) {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.point_tile_size = 4;
+    parts.current_arena_components = 2;
+    parts.physical_sector_count = 2;
+    parts.retained_helicity_count = 2;
+    parts.external_source_count = 2;
+    parts.currents[0].component_count = 1;
+    parts.currents[1].component_base = 1;
+    parts.sources[0].destination_component_base = 0;
+    parts.contributions[0].destination_component_base = 1;
+    parts.contributions[0].exact_factor_id = 0;
+    parts.finalizations[0].component_base = 1;
+    parts.finalizations[0].exact_factor_id = 1;
+    parts.closures[0].parent0_component_base = 1;
+    parts.closures[0].exact_factor_id = 2;
+    parts.momentum_forms[0].term_count = 2;
+    parts.momentum_terms.push(DirectMomentumTerm {
+        source_slot: 1,
+        coefficient: 2,
+    });
+    parts.replay_targets = vec![
+        DirectReplayTargetDescriptor {
+            public_flow_id: 0,
+            representative_id: 0,
+            source_permutation_start: 0,
+            source_permutation_count: 2,
+            helicity_map_start: 0,
+            helicity_map_count: 1,
+            phase_exact_factor_id: 3,
+            multiplicity: 1,
+            selector_domain_id: 0,
+        },
+        DirectReplayTargetDescriptor {
+            public_flow_id: 1,
+            representative_id: 0,
+            source_permutation_start: 2,
+            source_permutation_count: 2,
+            helicity_map_start: 1,
+            helicity_map_count: 1,
+            phase_exact_factor_id: 4,
+            multiplicity: 2,
+            selector_domain_id: 0,
+        },
+    ];
+    parts.source_permutations = vec![0, 1, 1, 0];
+    parts.replay_momentum_signs = vec![1, 1, 1, 1];
+    parts.replay_helicity_map = vec![0, 0];
+    parts.resolved_helicities[0].source_state_count = 2;
+    parts.resolved_helicities[0].public_helicity_count = 2;
+    parts.source_state_assignments = vec![
+        DirectSourceStateAssignment {
+            source_slot: 0,
+            state_index: 0,
+        },
+        DirectSourceStateAssignment {
+            source_slot: 1,
+            state_index: 0,
+        },
+    ];
+    parts.public_helicities = vec![-1, 1];
+    parts.exact_factors = vec![
+        rational(2, 1),
+        rational(1, 2),
+        rational(-1, 1),
+        ExactComplexRational::ONE,
+        complex_rational(0, 1, 1, 1),
+    ];
+    replace_single_closure_proof_factor(&mut parts, rational(-1, 1), None);
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    (plan, executors)
+}
+
+fn synthetic_runtime_with_lorentz(
+    lorentz_component_count: u16,
+) -> DirectRecurrenceExecutionRuntime {
+    let (plan, executors) = synthetic_plan_and_executors();
+    let mut runtime =
+        DirectRecurrenceExecutionRuntime::new(plan, executors, lorentz_component_count).unwrap();
+    runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+    runtime
+}
+
+fn synthetic_packed_runtime_with_lorentz(
+    lorentz_component_count: u16,
+) -> DirectRecurrenceExecutionRuntime {
+    let (plan, executors) = synthetic_plan_and_executors();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(
+        plan,
+        executors.mark_packed_singleton_capable(),
+        lorentz_component_count,
+    )
+    .unwrap();
+    runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+    runtime
+}
+
+fn synthetic_runtime() -> DirectRecurrenceExecutionRuntime {
+    synthetic_runtime_with_lorentz(1)
+}
+
+fn fanout_test_plan() -> DirectRecurrencePlan {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.point_tile_size = 8;
+    parts.exact_factors = vec![
+        ExactComplexRational::ONE,
+        rational(-1, 1),
+        complex_rational(0, 1, 1, 1),
+        complex_rational(0, 1, -1, 1),
+        rational(5, 7),
+        complex_rational(0, 1, 2, 5),
+        complex_rational(11, 13, -7, 17),
+        complex_rational(10_000, 1, 3, 1),
+        complex_rational(-10_000, 1, -3, 1),
+    ];
+    let prototype = parts.contributions[0];
+    parts.contributions = (0_u32..=8)
+        .flat_map(|exact_factor_id| [exact_factor_id; 2])
+        .enumerate()
+        .map(|(row_index, exact_factor_id)| DirectContributionRow {
+            exact_factor_id,
+            flags: u32::from(row_index == 0) * DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            ..prototype
+        })
+        .collect();
+    parts
+        .row_groups
+        .iter_mut()
+        .find(|group| group.role == DirectExecutorRole::Contribution)
+        .unwrap()
+        .row_count = parts.contributions.len() as u32;
+    DirectRecurrencePlan::new(parts).unwrap()
+}
+
+fn fanout_test_catalog(
+    plan: &DirectRecurrencePlan,
+    census: &ContributionCallCensus,
+    exact_factor_is_kernel_input: bool,
+) -> DirectExecutorCatalog {
+    let mut handles = direct_executor_handles();
+    handles[1] = DirectExecutorHandle::Contribution {
+        call: counted_accumulate_contributions,
+        context: census as *const ContributionCallCensus as *const c_void,
+    };
+    DirectExecutorCatalog::new_sparse_with_metadata(
+        plan,
+        plan.direct_template_catalog_digest(),
+        handles.into_iter().map(Some).collect(),
+        vec![
+            None,
+            Some(
+                DirectContributionExecutionMetadata::new(1, exact_factor_is_kernel_input).unwrap(),
+            ),
+            None,
+            None,
+        ],
+    )
+    .unwrap()
+}
+
+fn interaction_dispatch_test_plan() -> DirectRecurrencePlan {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.strategy = RecurrenceStrategy::TopologyReplay;
+    parts.point_tile_size = 4;
+    parts.current_arena_components = 4;
+    parts.direct_executor_count = 5;
+
+    let source = parts.currents[0];
+    let current = parts.currents[1];
+    parts.currents[0].component_count = 1;
+    parts.currents[1] = DirectCurrentDescriptor {
+        semantic_current_id: 2,
+        component_base: 2,
+        component_count: 1,
+        last_use: 1,
+        ..current
+    };
+    parts.currents.insert(
+        1,
+        DirectCurrentDescriptor {
+            semantic_current_id: 1,
+            component_base: 1,
+            component_count: 1,
+            source_row_or_sentinel: 1,
+            last_use: 2,
+            ..source
+        },
+    );
+    parts.currents.push(DirectCurrentDescriptor {
+        semantic_current_id: 3,
+        component_base: 3,
+        component_count: 1,
+        last_use: 1,
+        finalization_row_or_sentinel: DIRECT_NONE_U32,
+        ..current
+    });
+
+    let source_row = parts.sources[0];
+    parts.sources.push(DirectSourceRow {
+        destination_component_base: 1,
+        ..source_row
+    });
+
+    let contribution = parts.contributions[0];
+    parts.contributions = vec![
+        DirectContributionRow {
+            parent0_component_base: 1,
+            parent1_component_base_or_sentinel: 0,
+            parent1_momentum_form_id_or_sentinel: 0,
+            destination_component_base: 2,
+            flags: 0,
+            ..contribution
+        },
+        DirectContributionRow {
+            parent0_component_base: 1,
+            parent1_component_base_or_sentinel: 0,
+            parent1_momentum_form_id_or_sentinel: 0,
+            destination_component_base: 3,
+            flags: 0,
+            ..contribution
+        },
+        DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 1,
+            parent1_momentum_form_id_or_sentinel: 0,
+            destination_component_base: 3,
+            flags: 0,
+            ..contribution
+        },
+        DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: 1,
+            parent1_momentum_form_id_or_sentinel: 0,
+            destination_component_base: 2,
+            flags: 0,
+            ..contribution
+        },
+    ];
+    parts.finalizations[0].component_base = 2;
+    parts.closures[0].parent0_component_base = 1;
+    parts.row_groups[0].row_count = 2;
+    parts.row_groups[1].row_count = 2;
+    parts.row_groups.insert(
+        2,
+        DirectRowGroupDescriptor {
+            direct_executor_id: 4,
+            row_start: 2,
+            row_count: 2,
+            ..parts.row_groups[1]
+        },
+    );
+    DirectRecurrencePlan::new(parts).unwrap()
+}
+
+fn interaction_dispatch_test_catalog(
+    plan: &DirectRecurrencePlan,
+    ordinary: &ContributionCallCensus,
+    interaction: &InteractionDispatchCensus,
+) -> DirectExecutorCatalog {
+    let ordinary_context = ordinary as *const ContributionCallCensus as *const c_void;
+    let interaction_context = interaction as *const InteractionDispatchCensus as *const c_void;
+    let mut handles = direct_executor_handles();
+    handles[1] = DirectExecutorHandle::Contribution {
+        call: counted_accumulate_contributions,
+        context: ordinary_context,
+    };
+    handles.push(DirectExecutorHandle::Contribution {
+        call: counted_accumulate_contributions,
+        context: ordinary_context,
+    });
+    let mut metadata = vec![None; 5];
+    metadata[1] = Some(DirectContributionExecutionMetadata::new(1, false).unwrap());
+    metadata[4] = Some(DirectContributionExecutionMetadata::new(1, false).unwrap());
+    let mut fanout = vec![None; 5];
+    fanout[1] = Some(DirectContributionFanoutExecutorHandle {
+        call: unexpected_single_point_fanout,
+        context: interaction_context,
+        destination_component_count: 1,
+        parent_component_counts: [1, 1],
+        requires_two_momenta: false,
+        required_parameter_count: 0,
+        interaction_kind: DirectInteractionIntrinsicKind::AntisymmetricTensorVector,
+        interaction_call: None,
+    });
+    fanout[4] = Some(DirectContributionFanoutExecutorHandle {
+        call: unexpected_single_point_fanout,
+        context: interaction_context,
+        destination_component_count: 1,
+        parent_component_counts: [1, 1],
+        requires_two_momenta: false,
+        required_parameter_count: 0,
+        interaction_kind: DirectInteractionIntrinsicKind::ColorOrderedThreeVector,
+        interaction_call: Some(inspect_nonidentity_interaction_dispatch),
+    });
+    DirectExecutorCatalog::new_sparse_with_metadata_and_fanout(
+        plan,
+        plan.direct_template_catalog_digest(),
+        handles.into_iter().map(Some).collect(),
+        metadata,
+        fanout,
+    )
+    .unwrap()
+}
+
+fn direct_baseline(
+    plan: &DirectRecurrencePlan,
+    executors: &DirectExecutorCatalog,
+    point_stride: u32,
+    point_count: u32,
+    momenta: &[f64],
+    parameter: (f64, f64),
+) -> Vec<(f64, f64)> {
+    let mut current_re =
+        vec![0.0; plan.current_arena_components() as usize * point_stride as usize];
+    let mut current_im = vec![0.0; current_re.len()];
+    let mut amplitude_re =
+        vec![0.0; plan.amplitude_destination_count() as usize * point_stride as usize];
+    let mut amplitude_im = vec![0.0; amplitude_re.len()];
+    let factors_re = plan
+        .exact_factors()
+        .iter()
+        .map(|factor| factor.real().numerator() as f64 / factor.real().denominator() as f64)
+        .collect::<Vec<_>>();
+    let factors_im = plan
+        .exact_factors()
+        .iter()
+        .map(|factor| factor.imag().numerator() as f64 / factor.imag().denominator() as f64)
+        .collect::<Vec<_>>();
+    let mut workspace = DirectWorkspace {
+        current_re: &mut current_re,
+        current_im: &mut current_im,
+        amplitude_re: &mut amplitude_re,
+        amplitude_im: &mut amplitude_im,
+        momenta,
+        momentum_form_count: plan.momentum_forms().len() as u32,
+        lorentz_component_count: 1,
+        parameters_re: &[parameter.0],
+        parameters_im: &[parameter.1],
+        factors_re: &factors_re,
+        factors_im: &factors_im,
+        point_stride,
+    };
+    let mut counters = DirectExecutionCounters::default();
+    execute_direct_plan(plan, executors, &mut workspace, point_count, &mut counters).unwrap();
+    assert_eq!(
+        counters.contribution_rows,
+        plan.contributions().len() as u64
+    );
+    amplitude_re[..point_count as usize]
+        .iter()
+        .copied()
+        .zip(amplitude_im[..point_count as usize].iter().copied())
+        .collect()
+}
+
+fn assert_scale_relative_complex_parity(baseline: &[(f64, f64)], candidate: &[(f64, f64)]) {
+    assert_eq!(baseline.len(), candidate.len());
+    for (point, (&expected, &observed)) in baseline.iter().zip(candidate).enumerate() {
+        let error = (expected.0 - observed.0).hypot(expected.1 - observed.1);
+        let scale = expected
+            .0
+            .hypot(expected.1)
+            .max(observed.0.hypot(observed.1))
+            .max(1.0);
+        assert!(
+            error <= 1.0e-10 * scale,
+            "point {point} differs by {error:e} at scale {scale:e}: expected {expected:?}, observed {observed:?}"
+        );
+    }
+}
+
+#[test]
+fn sparse_executor_catalog_resolves_arbitrary_referenced_ids_and_keeps_unused_holes() {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.direct_executor_count = 8;
+    let selected_ids = [6_u32, 1, 7, 3];
+    for (descriptor, executor_id) in parts.row_groups.iter_mut().zip(selected_ids) {
+        descriptor.direct_executor_id = executor_id;
+    }
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let dense_handles = direct_executor_handles();
+    let mut sparse_handles = vec![None; plan.direct_executor_count() as usize];
+    for (handle, executor_id) in dense_handles.into_iter().zip(selected_ids) {
+        sparse_handles[executor_id as usize] = Some(handle);
+    }
+
+    DirectExecutorCatalog::new_sparse(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        sparse_handles.clone(),
+    )
+    .unwrap();
+
+    sparse_handles[selected_ids[2] as usize] = None;
+    let error = DirectExecutorCatalog::new_sparse(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        sparse_handles,
+    )
+    .err()
+    .unwrap();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::Evaluation);
+    assert!(error.to_string().contains("executor 7 is not loaded"));
+}
+
+#[test]
+fn interaction_dispatch_uses_nonidentity_bijection_and_multipoint_falls_back() {
+    let plan = interaction_dispatch_test_plan();
+    let ordinary = ContributionCallCensus::default();
+    let interaction = InteractionDispatchCensus::default();
+    let catalog = interaction_dispatch_test_catalog(&plan, &ordinary, &interaction);
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, catalog, 1).unwrap();
+    runtime.set_parameters(&[1.0], &[0.0]).unwrap();
+
+    runtime.execute_tile(1).unwrap();
+    assert_eq!(interaction.calls.load(Ordering::Relaxed), 1);
+    assert_eq!(ordinary.calls.load(Ordering::Relaxed), 0);
+
+    runtime.execute_tile(2).unwrap();
+    assert_eq!(interaction.calls.load(Ordering::Relaxed), 1);
+    assert_eq!(ordinary.calls.load(Ordering::Relaxed), 2);
+    assert_eq!(ordinary.rows.load(Ordering::Relaxed), 2);
+
+    begin_direct_current_observation(runtime.plan(), None, 1).unwrap();
+    runtime.execute_tile(1).unwrap();
+    let observation = take_direct_current_observation().unwrap();
+    assert!(!observation.currents.is_empty());
+    assert_eq!(interaction.calls.load(Ordering::Relaxed), 1);
+    assert_eq!(ordinary.calls.load(Ordering::Relaxed), 4);
+    assert_eq!(ordinary.rows.load(Ordering::Relaxed), 6);
+}
+
+#[test]
+fn output_only_contribution_fanout_matches_direct_under_complex_cancellation() {
+    let plan = fanout_test_plan();
+    let point_stride = 8;
+    let point_count = 7;
+    let momenta = [0.125, -0.875, 1.75, -3.5, 0.0625, 7.25, -11.0, 0.0];
+    let parameter = (0.375, -1.125);
+
+    let factor_norm_sum = plan
+        .exact_factors()
+        .iter()
+        .skip(1)
+        .map(|factor| {
+            let real = factor.real().numerator() as f64 / factor.real().denominator() as f64;
+            let imaginary = factor.imag().numerator() as f64 / factor.imag().denominator() as f64;
+            real.hypot(imaginary)
+        })
+        .sum::<f64>();
+    let factor_sum = plan
+        .exact_factors()
+        .iter()
+        .skip(1)
+        .fold((0.0_f64, 0.0_f64), |sum, factor| {
+            (
+                sum.0 + factor.real().numerator() as f64 / factor.real().denominator() as f64,
+                sum.1 + factor.imag().numerator() as f64 / factor.imag().denominator() as f64,
+            )
+        });
+    assert!(factor_norm_sum > 1_000.0 * factor_sum.0.hypot(factor_sum.1));
+
+    let baseline_census = ContributionCallCensus::default();
+    let baseline_catalog = fanout_test_catalog(&plan, &baseline_census, false);
+    let baseline = direct_baseline(
+        &plan,
+        &baseline_catalog,
+        point_stride,
+        point_count,
+        &momenta,
+        parameter,
+    );
+    assert_eq!(baseline_census.calls.load(Ordering::Relaxed), 1);
+    assert_eq!(baseline_census.rows.load(Ordering::Relaxed), 18);
+
+    let optimized_census = ContributionCallCensus::default();
+    let optimized_catalog = fanout_test_catalog(&plan, &optimized_census, false);
+    let fanout = DirectContributionFanoutProgram::build(&plan, &optimized_catalog).unwrap();
+    assert_eq!(fanout.row_counts(), (18, 1));
+    assert_eq!(fanout.scatter_bundle_counts(), (18, 9));
+    assert_eq!(fanout.scratch_component_count(), 1);
+    assert!(fanout.needs_unit_factor());
+    let mut runtime =
+        DirectRecurrenceExecutionRuntime::new(plan.clone(), optimized_catalog, 1).unwrap();
+    runtime
+        .set_parameters(&[parameter.0], &[parameter.1])
+        .unwrap();
+    runtime
+        .momentum_plane_mut(0, 0)
+        .unwrap()
+        .unwrap()
+        .copy_from_slice(&momenta);
+    assert_eq!(runtime.factors_mut().0.len(), plan.exact_factors().len());
+    assert_eq!(
+        runtime.current_arenas().0.len(),
+        plan.current_arena_components() as usize * runtime.point_stride() as usize
+    );
+    let storage = storage_identity(&mut runtime);
+    let output = runtime.execute_tile(point_count).unwrap();
+    let candidate = output
+        .destination_re(0)
+        .unwrap()
+        .iter()
+        .copied()
+        .zip(output.destination_im(0).unwrap().iter().copied())
+        .collect::<Vec<_>>();
+    assert_scale_relative_complex_parity(&baseline, &candidate);
+    assert_eq!(optimized_census.calls.load(Ordering::Relaxed), 1);
+    assert_eq!(optimized_census.rows.load(Ordering::Relaxed), 1);
+
+    runtime.execute_tile(point_count).unwrap();
+    assert_eq!(storage_identity(&mut runtime), storage);
+    assert_eq!(optimized_census.calls.load(Ordering::Relaxed), 2);
+    assert_eq!(optimized_census.rows.load(Ordering::Relaxed), 2);
+
+    let tail_count = 5;
+    let tail_baseline = direct_baseline(
+        &plan,
+        &baseline_catalog,
+        point_stride,
+        tail_count,
+        &momenta,
+        parameter,
+    );
+    let tail_output = runtime.execute_tile(tail_count).unwrap();
+    let tail_candidate = tail_output
+        .destination_re(0)
+        .unwrap()
+        .iter()
+        .copied()
+        .zip(tail_output.destination_im(0).unwrap().iter().copied())
+        .collect::<Vec<_>>();
+    assert_scale_relative_complex_parity(&tail_baseline, &tail_candidate);
+    assert_eq!(storage_identity(&mut runtime), storage);
+}
+
+#[test]
+fn full_fanout_execution_overwrites_poisoned_destination_without_stage_clear() {
+    let plan = fanout_test_plan();
+    let point_stride = 8_u32;
+    let point_count = 7_u32;
+    let momenta = [0.125, -0.875, 1.75, -3.5, 0.0625, 7.25, -11.0, 0.0];
+    let parameter = (0.375, -1.125);
+    let census = ContributionCallCensus::default();
+    let catalog = fanout_test_catalog(&plan, &census, false);
+    let fanout = DirectContributionFanoutProgram::build(&plan, &catalog).unwrap();
+    let current_plane_count = plan.current_arena_components() + fanout.scratch_component_count();
+    let mut current_re = vec![f64::NAN; current_plane_count as usize * point_stride as usize];
+    let mut current_im = vec![f64::NAN; current_re.len()];
+    let mut amplitude_re = vec![0.0; point_stride as usize];
+    let mut amplitude_im = vec![0.0; point_stride as usize];
+    let mut factors_re = plan
+        .exact_factors()
+        .iter()
+        .map(|factor| factor.real().numerator() as f64 / factor.real().denominator() as f64)
+        .collect::<Vec<_>>();
+    let mut factors_im = plan
+        .exact_factors()
+        .iter()
+        .map(|factor| factor.imag().numerator() as f64 / factor.imag().denominator() as f64)
+        .collect::<Vec<_>>();
+    factors_re.push(1.0);
+    factors_im.push(0.0);
+
+    let execute = |current_re: &mut [f64],
+                   current_im: &mut [f64],
+                   amplitude_re: &mut [f64],
+                   amplitude_im: &mut [f64]| {
+        let mut workspace = DirectWorkspace {
+            current_re,
+            current_im,
+            amplitude_re,
+            amplitude_im,
+            momenta: &momenta,
+            momentum_form_count: plan.momentum_forms().len() as u32,
+            lorentz_component_count: 1,
+            parameters_re: &[parameter.0],
+            parameters_im: &[parameter.1],
+            factors_re: &factors_re,
+            factors_im: &factors_im,
+            point_stride,
+        };
+        execute_direct_plan_unprofiled_with_fanout(
+            &plan,
+            &catalog,
+            &fanout,
+            &mut workspace,
+            point_count,
+        )
+        .unwrap();
+    };
+
+    execute(
+        &mut current_re,
+        &mut current_im,
+        &mut amplitude_re,
+        &mut amplitude_im,
+    );
+    let first = amplitude_re[..point_count as usize]
+        .iter()
+        .copied()
+        .zip(amplitude_im[..point_count as usize].iter().copied())
+        .collect::<Vec<_>>();
+    current_re.fill(f64::NAN);
+    current_im.fill(f64::NAN);
+    amplitude_re.fill(0.0);
+    amplitude_im.fill(0.0);
+    execute(
+        &mut current_re,
+        &mut current_im,
+        &mut amplitude_re,
+        &mut amplitude_im,
+    );
+    let second = amplitude_re[..point_count as usize]
+        .iter()
+        .copied()
+        .zip(amplitude_im[..point_count as usize].iter().copied())
+        .collect::<Vec<_>>();
+
+    assert!(
+        second
+            .iter()
+            .all(|(real, imaginary)| real.is_finite() && imaginary.is_finite())
+    );
+    assert_scale_relative_complex_parity(&first, &second);
+}
+
+#[test]
+fn factor_consuming_contribution_fanout_is_fail_closed() {
+    let plan = fanout_test_plan();
+    let census = ContributionCallCensus::default();
+    let catalog = fanout_test_catalog(&plan, &census, true);
+    let fanout = DirectContributionFanoutProgram::build(&plan, &catalog).unwrap();
+    assert_eq!(fanout.row_counts(), (18, 9));
+    assert_eq!(fanout.scatter_bundle_counts(), (18, 9));
+    assert_eq!(fanout.scratch_component_count(), 9);
+    assert!(!fanout.needs_unit_factor());
+
+    let mut bad_metadata = vec![None; plan.direct_executor_count() as usize];
+    bad_metadata[1] = Some(DirectContributionExecutionMetadata::new(2, false).unwrap());
+    let error = DirectExecutorCatalog::new_sparse_with_metadata(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles().into_iter().map(Some).collect(),
+        bad_metadata,
+    )
+    .and_then(|catalog| DirectContributionFanoutProgram::build(&plan, &catalog))
+    .err()
+    .unwrap();
+    assert!(
+        error
+            .to_string()
+            .contains("declares 2 destination components")
+    );
+}
+
+#[test]
+fn direct_plan_rejects_a_row_group_executor_outside_the_catalog_domain() {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.row_groups[0].direct_executor_id = parts.direct_executor_count;
+    let error = DirectRecurrencePlan::new(parts).err().unwrap();
+    assert_eq!(error.kind(), crate::RusticolErrorKind::InvalidArgument);
+}
+
+#[test]
+fn low_footprint_runtime_retains_the_requested_point_tile() {
+    let (plan, executors) = synthetic_plan_and_executors();
+    assert_eq!(plan.point_tile_size(), 4);
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 1).unwrap();
+    assert_eq!(runtime.point_tile_size(), 4);
+    assert_eq!(runtime.point_stride(), 8);
+    assert_eq!(runtime.momenta_mut().unwrap().len(), 4);
+    assert_eq!(runtime.physical_momenta_mut().unwrap().len(), 8);
+}
+
+#[test]
+fn packed_singleton_is_exact_and_scalar_batch_scalar_keeps_tiled_tail() {
+    let mut aligned = synthetic_runtime_with_lorentz(4);
+    let mut dual = synthetic_packed_runtime_with_lorentz(4);
+    assert!(dual.packed_singleton_active);
+    assert!(dual.alternate_point_storage.is_none());
+    assert_eq!(dual.point_stride(), 1);
+    let packed_allocation_counters = dual.allocation_counters();
+    let aligned_selector = aligned.prepare_replay_selector(0).unwrap();
+    let dual_selector = dual.prepare_replay_selector(0).unwrap();
+    let one = &external_two_point_momenta()[..8];
+
+    let aligned_scalar = aligned
+        .execute_replay_tile_from_external(&aligned_selector, 1, one)
+        .unwrap();
+    assert_eq!(aligned_scalar.point_stride(), 8);
+    let aligned_scalar = (
+        aligned_scalar.destination_re(0).unwrap().to_vec(),
+        aligned_scalar.destination_im(0).unwrap().to_vec(),
+    );
+    let dual_scalar = dual
+        .execute_replay_tile_from_external(&dual_selector, 1, one)
+        .unwrap();
+    assert_eq!(dual_scalar.point_stride(), 1);
+    assert_eq!(
+        (
+            dual_scalar.destination_re(0).unwrap(),
+            dual_scalar.destination_im(0).unwrap(),
+        ),
+        (aligned_scalar.0.as_slice(), aligned_scalar.1.as_slice())
+    );
+    assert!(dual.alternate_point_storage.is_none());
+    assert_eq!(dual.allocation_counters(), packed_allocation_counters);
+
+    let four = [external_two_point_momenta(), external_two_point_momenta()].concat();
+    let aligned_batch = aligned
+        .execute_replay_tile_from_external(&aligned_selector, 4, &four)
+        .unwrap();
+    let aligned_batch = (
+        aligned_batch.destination_re(0).unwrap().to_vec(),
+        aligned_batch.destination_im(0).unwrap().to_vec(),
+    );
+    let dual_batch = dual
+        .execute_replay_tile_from_external(&dual_selector, 4, &four)
+        .unwrap();
+    assert_eq!(dual_batch.point_stride(), 8);
+    let dual_batch = (
+        dual_batch.destination_re(0).unwrap().to_vec(),
+        dual_batch.destination_im(0).unwrap().to_vec(),
+        dual_batch.storage_re()[2..4].to_vec(),
+    );
+    assert!(!dual.packed_singleton_active);
+    assert!(dual.alternate_point_storage.is_some());
+    assert_eq!(
+        dual.allocation_counters().allocation_requests,
+        packed_allocation_counters.allocation_requests + 5
+    );
+    assert_eq!(dual_batch.0, aligned_batch.0);
+    assert_eq!(dual_batch.1, aligned_batch.1);
+    let retained_tail = dual_batch.2;
+
+    let dual_tail = dual
+        .execute_replay_tile_from_external(&dual_selector, 2, &external_two_point_momenta())
+        .unwrap();
+    assert_eq!(dual_tail.point_stride(), 8);
+    assert_eq!(&dual_tail.storage_re()[2..4], retained_tail.as_slice());
+
+    let second_one = &external_two_point_momenta()[8..];
+    let aligned_scalar = aligned
+        .execute_replay_tile_from_external(&aligned_selector, 1, second_one)
+        .unwrap();
+    let aligned_scalar = (
+        aligned_scalar.destination_re(0).unwrap().to_vec(),
+        aligned_scalar.destination_im(0).unwrap().to_vec(),
+    );
+    let dual_scalar = dual
+        .execute_replay_tile_from_external(&dual_selector, 1, second_one)
+        .unwrap();
+    assert_eq!(dual_scalar.point_stride(), 1);
+    assert_eq!(
+        dual_scalar.destination_re(0).unwrap(),
+        aligned_scalar.0.as_slice()
+    );
+    assert_eq!(
+        dual_scalar.destination_im(0).unwrap(),
+        aligned_scalar.1.as_slice()
+    );
+
+    let tiled_stride = aligned.point_stride() as usize;
+    let expected_point_zero = {
+        let momenta = aligned.physical_momenta_mut().unwrap();
+        (0..4)
+            .map(|plane| momenta[plane * tiled_stride])
+            .collect::<Vec<_>>()
+    };
+    {
+        let momenta = dual.physical_momenta_mut().unwrap();
+        for plane in 0..4 {
+            assert_eq!(momenta[plane * tiled_stride], expected_point_zero[plane]);
+            let point_one = 100.0 + plane as f64;
+            momenta[plane * tiled_stride + 1] = point_one;
+        }
+    }
+    assert!(dual.outputs().is_none());
+    {
+        let momenta = aligned.physical_momenta_mut().unwrap();
+        for plane in 0..4 {
+            momenta[plane * tiled_stride + 1] = 100.0 + plane as f64;
+        }
+    }
+    assert_eq!(dual.point_stride() as usize, tiled_stride);
+    let aligned_tiled = aligned.execute_tile(2).unwrap();
+    let aligned_tiled = (
+        aligned_tiled.destination_re(0).unwrap().to_vec(),
+        aligned_tiled.destination_im(0).unwrap().to_vec(),
+    );
+    let dual_tiled = dual.execute_tile(2).unwrap();
+    assert_eq!(
+        dual_tiled.destination_re(0).unwrap(),
+        aligned_tiled.0.as_slice()
+    );
+    assert_eq!(
+        dual_tiled.destination_im(0).unwrap(),
+        aligned_tiled.1.as_slice()
+    );
+}
+
+#[test]
+fn packed_singleton_legacy_access_promotes_once_and_preserves_point_zero() {
+    let mut runtime = synthetic_packed_runtime_with_lorentz(4);
+    let selector = runtime.prepare_replay_selector(0).unwrap();
+    let one = &external_two_point_momenta()[..8];
+    runtime
+        .execute_replay_tile_from_external(&selector, 1, one)
+        .unwrap();
+    let packed_allocation_counters = runtime.allocation_counters();
+    assert!(runtime.outputs().is_some());
+    assert!(runtime.momentum_plane_mut(u32::MAX, 0).unwrap().is_none());
+    assert!(runtime.momentum_plane_mut(0, u16::MAX).unwrap().is_none());
+    assert!(runtime.packed_singleton_active);
+    assert!(runtime.alternate_point_storage.is_none());
+    assert_eq!(runtime.allocation_counters(), packed_allocation_counters);
+
+    let tiled_stride = (runtime.point_tile_size().div_ceil(8) * 8) as usize;
+    let momenta = runtime.physical_momenta_mut().unwrap();
+    for (component, expected) in [9.0, 90.0, 900.0, 9000.0].into_iter().enumerate() {
+        assert_eq!(momenta[component * tiled_stride], expected);
+    }
+    assert_eq!(runtime.point_stride() as usize, tiled_stride);
+    assert!(!runtime.packed_singleton_active);
+    assert!(runtime.outputs().is_none());
+    assert_eq!(
+        runtime.allocation_counters().allocation_requests,
+        packed_allocation_counters.allocation_requests + 5
+    );
+
+    let promoted_allocation_counters = runtime.allocation_counters();
+    runtime.physical_momenta_mut().unwrap();
+    assert_eq!(runtime.allocation_counters(), promoted_allocation_counters);
+}
+
+#[test]
+fn replay_cache_footprint_uses_authenticated_active_selector_work() {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.current_arena_components = 128;
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let persisted_split_scalars =
+        2 * (plan.current_arena_components() + plan.amplitude_destination_count()) as usize;
+
+    assert_eq!(persisted_split_scalars, 258);
+    assert_eq!(
+        replay_cache_split_complex_scalar_count(&plan, persisted_split_scalars, 0).unwrap(),
+        8
+    );
+}
+
+#[test]
+fn legacy_flat_momentum_access_round_trips_every_padded_plane_in_place() {
+    let (plan, executors) = synthetic_plan_and_executors();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    let tile_capacity = runtime.point_tile_size() as usize;
+    let point_stride = runtime.point_stride() as usize;
+    assert_eq!(tile_capacity, 4);
+    assert_eq!(point_stride, 8);
+
+    let compact = runtime.momenta_mut().unwrap();
+    for plane in 0..4 {
+        for point in 0..tile_capacity {
+            compact[plane * tile_capacity + point] = (plane * 10 + point) as f64;
+        }
+    }
+    let physical = runtime.physical_momenta_mut().unwrap();
+    for plane in 0..4 {
+        for point in 0..tile_capacity {
+            assert_eq!(
+                physical[plane * point_stride + point],
+                (plane * 10 + point) as f64
+            );
+        }
+    }
+
+    let compact = runtime.momenta_mut().unwrap();
+    for plane in 0..4 {
+        for point in 0..tile_capacity {
+            assert_eq!(
+                compact[plane * tile_capacity + point],
+                (plane * 10 + point) as f64
+            );
+        }
+    }
+}
+
+#[test]
+fn high_footprint_runtime_uses_a_power_of_two_cache_tile() {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.strategy = RecurrenceStrategy::ContractedColorUnion;
+    parts.point_tile_size = 1024;
+    parts.workspace_mib = 256;
+    parts.current_arena_components = 4_000;
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    assert_eq!(plan.point_tile_size(), 1024);
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    assert_eq!(runtime.point_tile_size(), 64);
+}
+
+#[test]
+fn cache_tile_fills_one_aligned_pitch_without_overriding_request_or_workspace() {
+    for (requested_points, workspace_mib, expected_points) in [
+        (1, 256, 1),
+        (2, 256, 2),
+        (4, 256, 4),
+        (8, 256, 8),
+        (1024, 256, 8),
+        (1024, 17, 8),
+    ] {
+        let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+        parts.strategy = RecurrenceStrategy::ContractedColorUnion;
+        parts.point_tile_size = requested_points;
+        parts.workspace_mib = workspace_mib;
+        parts.current_arena_components = 131_071;
+        // Including the one amplitude, the split-complex footprint is exactly
+        // 2 MiB per point. The old 4 MiB cache target admitted only two lanes,
+        // although every tiled arena already allocated an eight-lane pitch.
+        assert_eq!(parts.amplitude_destination_count, 1);
+        let plan = DirectRecurrencePlan::new(parts).unwrap();
+        let executors = DirectExecutorCatalog::new(
+            &plan,
+            plan.direct_template_catalog_digest(),
+            direct_executor_handles(),
+        )
+        .unwrap();
+        let runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+        assert_eq!(runtime.point_tile_size(), expected_points);
+        assert_eq!(runtime.point_stride(), 8);
+        let (current_re, current_im) = runtime.current_arenas();
+        let (amplitude_re, amplitude_im) = runtime.amplitude_arenas();
+        assert_eq!(current_re.len(), 131_071 * 8);
+        assert_eq!(current_im.len(), current_re.len());
+        assert_eq!(amplitude_re.len(), 8);
+        assert_eq!(amplitude_im.len(), amplitude_re.len());
+    }
+}
+
+#[test]
+fn cache_target_never_rejects_a_point_that_fits_the_workspace_limit() {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.point_tile_size = 1024;
+    parts.workspace_mib = 64;
+    parts.current_arena_components = 262_144;
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    assert_eq!(runtime.point_tile_size(), 8);
+    assert_eq!(runtime.point_stride(), 8);
+}
+
+#[test]
+fn workspace_target_allows_the_minimum_aligned_physical_pitch() {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.point_tile_size = 1024;
+    parts.workspace_mib = 8;
+    parts.current_arena_components = 262_144;
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    assert_eq!(runtime.point_tile_size(), 8);
+    assert_eq!(runtime.point_stride(), 8);
+}
+
+#[test]
+fn packed_singleton_can_switch_to_tiles_larger_than_the_workspace_target() {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.point_tile_size = 1024;
+    parts.workspace_mib = 8;
+    parts.current_arena_components = 262_144;
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let ordinary_executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let ordinary_runtime =
+        DirectRecurrenceExecutionRuntime::new(plan.clone(), ordinary_executors, 4).unwrap();
+    let packed_executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap()
+    .mark_packed_singleton_capable();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, packed_executors, 4).unwrap();
+    assert_eq!(
+        runtime.point_tile_size(),
+        ordinary_runtime.point_tile_size()
+    );
+    assert_eq!(runtime.point_stride(), 1);
+    assert!(runtime.packed_singleton_active);
+    assert!(runtime.alternate_point_storage.is_none());
+
+    runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+    let output = runtime.execute_tile(1).unwrap();
+    assert_eq!(output.destination_re(0).unwrap(), &[0.0]);
+    assert_eq!(output.destination_im(0).unwrap(), &[0.0]);
+    assert!(runtime.outputs().is_some());
+
+    runtime.execute_tile(2).unwrap();
+    assert!(runtime.outputs().is_some());
+    assert!(!runtime.packed_singleton_active);
+    assert!(runtime.alternate_point_storage.is_some());
+    runtime.physical_momenta_mut().unwrap();
+
+    runtime.execute_tile(1).unwrap();
+}
+
+fn storage_identity(runtime: &mut DirectRecurrenceExecutionRuntime) -> ([usize; 9], [usize; 9]) {
+    let ((current_re_pointer, current_re_len), (current_im_pointer, current_im_len)) = {
+        let (current_re, current_im) = runtime.current_arenas();
+        (
+            (current_re.as_ptr() as usize, current_re.len()),
+            (current_im.as_ptr() as usize, current_im.len()),
+        )
+    };
+    let ((amplitude_re_pointer, amplitude_re_len), (amplitude_im_pointer, amplitude_im_len)) = {
+        let (amplitude_re, amplitude_im) = runtime.amplitude_arenas();
+        (
+            (amplitude_re.as_ptr() as usize, amplitude_re.len()),
+            (amplitude_im.as_ptr() as usize, amplitude_im.len()),
+        )
+    };
+    let (momenta_pointer, momenta_len) = {
+        let values = runtime.momenta_mut().unwrap();
+        (values.as_ptr() as usize, values.len())
+    };
+    let ((parameters_re_pointer, parameters_re_len), (parameters_im_pointer, parameters_im_len)) = {
+        let (parameters_re, parameters_im) = runtime.parameters_mut();
+        (
+            (parameters_re.as_ptr() as usize, parameters_re.len()),
+            (parameters_im.as_ptr() as usize, parameters_im.len()),
+        )
+    };
+    let ((factors_re_pointer, factors_re_len), (factors_im_pointer, factors_im_len)) = {
+        let (factors_re, factors_im) = runtime.factors_mut();
+        (
+            (factors_re.as_ptr() as usize, factors_re.len()),
+            (factors_im.as_ptr() as usize, factors_im.len()),
+        )
+    };
+    (
+        [
+            current_re_pointer,
+            current_im_pointer,
+            amplitude_re_pointer,
+            amplitude_im_pointer,
+            momenta_pointer,
+            parameters_re_pointer,
+            parameters_im_pointer,
+            factors_re_pointer,
+            factors_im_pointer,
+        ],
+        [
+            current_re_len,
+            current_im_len,
+            amplitude_re_len,
+            amplitude_im_len,
+            momenta_len,
+            parameters_re_len,
+            parameters_im_len,
+            factors_re_len,
+            factors_im_len,
+        ],
+    )
+}
+
+fn external_two_point_momenta() -> [f64; 16] {
+    [
+        1.0, 10.0, 100.0, 1000.0, 4.0, 40.0, 400.0, 4000.0, 2.0, 20.0, 200.0, 2000.0, 5.0, 50.0,
+        500.0, 5000.0,
+    ]
+}
+
+fn external_three_point_momenta() -> [f64; 24] {
+    [
+        1.0, 10.0, 100.0, 1000.0, 4.0, 40.0, 400.0, 4000.0, 2.0, 20.0, 200.0, 2000.0, 5.0, 50.0,
+        500.0, 5000.0, 7.0, 70.0, 700.0, 7000.0, 8.0, 80.0, 800.0, 8000.0,
+    ]
+}
+
+#[test]
+fn warmed_tiles_reuse_stable_aligned_storage_and_return_correct_borrowed_outputs() {
+    let mut runtime = synthetic_runtime();
+    let identity = storage_identity(&mut runtime);
+    assert!(
+        identity
+            .0
+            .iter()
+            .all(|pointer| pointer.is_multiple_of(DIRECT_RUNTIME_ARENA_ALIGNMENT))
+    );
+
+    for _ in 0..8 {
+        runtime
+            .momentum_plane_mut(0, 0)
+            .unwrap()
+            .unwrap()
+            .copy_from_slice(&[1.0, 2.0, 3.0, 4.0]);
+        let output = runtime.execute_tile(4).unwrap();
+        assert_eq!(
+            output.destination_re(0).unwrap(),
+            &[-3.0, -6.0, -9.0, -12.0]
+        );
+        assert_eq!(output.destination_im(0).unwrap(), &[-1.0, -2.0, -3.0, -4.0]);
+        assert_eq!(output.destination_re(1), None);
+        assert_eq!(storage_identity(&mut runtime), identity);
+    }
+
+    let (current_re, current_im) = runtime.current_arenas();
+    assert_eq!(&current_re[0..4], &[1.0, 2.0, 3.0, 4.0]);
+    let point_stride = runtime.point_stride() as usize;
+    assert_eq!(
+        &current_re[point_stride..point_stride + 4],
+        &[3.0, 6.0, 9.0, 12.0]
+    );
+    assert_eq!(&current_im[0..4], &[0.0; 4]);
+    assert_eq!(
+        &current_im[point_stride..point_stride + 4],
+        &[1.0, 2.0, 3.0, 4.0]
+    );
+    let counters = runtime.counters();
+    assert_eq!(counters.source_calls, 8);
+    assert_eq!(counters.source_rows, 8);
+    assert_eq!(counters.contribution_calls, 8);
+    assert_eq!(counters.contribution_rows, 8);
+    assert_eq!(counters.finalization_calls, 8);
+    assert_eq!(counters.finalization_rows, 8);
+    assert_eq!(counters.closure_calls, 8);
+    assert_eq!(counters.closure_rows, 8);
+    assert_eq!(counters.packed_input_bytes, 0);
+    assert_eq!(counters.packed_output_bytes, 0);
+    assert_eq!(counters.scatter_bytes, 0);
+    let allocation_counters = runtime.allocation_counters();
+    assert_eq!(allocation_counters.allocation_requests, 9);
+    assert!(allocation_counters.requested_bytes != 0);
+    let traffic = runtime.traffic_counters();
+    assert_eq!(traffic.calls, 32);
+    assert_eq!(traffic.rows, 32);
+    assert_eq!(traffic.points, 128);
+    traffic.validate_direct().unwrap();
+}
+
+#[test]
+fn elided_identity_finalizer_remains_correct_across_repeated_evaluations() {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.point_tile_size = 2;
+    parts.currents[1].finalization_row_or_sentinel = DIRECT_NONE_U32;
+    parts.finalizations.clear();
+    parts
+        .row_groups
+        .retain(|group| group.role != DirectExecutorRole::Finalization);
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 1).unwrap();
+    runtime.set_parameters(&[1.0], &[0.0]).unwrap();
+
+    for values in [[2.0, 3.0], [5.0, 7.0], [11.0, 13.0]] {
+        runtime
+            .momentum_plane_mut(0, 0)
+            .unwrap()
+            .unwrap()
+            .copy_from_slice(&values);
+        let output = runtime.execute_tile(2).unwrap();
+        assert_eq!(output.destination_re(0).unwrap(), values.as_slice());
+        assert_eq!(output.destination_im(0).unwrap(), &[0.0, 0.0]);
+    }
+    assert_eq!(runtime.counters().finalization_calls, 0);
+    assert_eq!(runtime.counters().finalization_rows, 0);
+}
+
+#[test]
+fn a_reused_source_slot_is_cleared_before_the_later_current_accumulates() {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.point_tile_size = 1;
+    parts.current_arena_components = 2;
+    parts.currents[0].component_count = 1;
+    parts.currents[0].last_use = 1;
+    parts.currents[1].component_base = 1;
+    parts.currents[1].first_use = 1;
+    parts.currents[1].last_use = 2;
+    parts.currents.push(DirectCurrentDescriptor {
+        semantic_current_id: 2,
+        node_kind: DirectNodeKind::Current,
+        state_template_id: 1,
+        component_base: 0,
+        component_count: 1,
+        momentum_form_id: 0,
+        stage: 2,
+        selector_domain_id: 0,
+        first_use: 2,
+        last_use: 3,
+        source_row_or_sentinel: DIRECT_NONE_U32,
+        finalization_row_or_sentinel: 1,
+    });
+    parts.contributions[0].destination_component_base = 1;
+    parts.contributions.push(DirectContributionRow {
+        parent0_component_base: 1,
+        parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+        parent0_momentum_form_id: 0,
+        parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+        destination_component_base: 0,
+        exact_factor_id: 0,
+        selector_domain_id: 0,
+        flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+    });
+    parts.finalizations[0].component_base = 1;
+    parts.finalizations.push(DirectFinalizationRow {
+        component_base: 0,
+        component_count: 1,
+        momentum_form_id: 0,
+        exact_factor_id: 0,
+        selector_domain_id: 0,
+        flags: 0,
+    });
+    parts.closures[0].parent0_component_base = 0;
+    replace_single_closure_proof_factor(&mut parts, ExactComplexRational::ONE, Some(vec![Some(2)]));
+    parts.row_groups = vec![
+        DirectRowGroupDescriptor {
+            stage: 0,
+            role: DirectExecutorRole::Source,
+            destination_operation: DirectDestinationOperation::Initialize,
+            direct_executor_id: 0,
+            row_start: 0,
+            row_count: 1,
+        },
+        DirectRowGroupDescriptor {
+            stage: 1,
+            role: DirectExecutorRole::Contribution,
+            destination_operation: DirectDestinationOperation::Add,
+            direct_executor_id: 1,
+            row_start: 0,
+            row_count: 1,
+        },
+        DirectRowGroupDescriptor {
+            stage: 1,
+            role: DirectExecutorRole::Finalization,
+            destination_operation: DirectDestinationOperation::FinalizeInPlace,
+            direct_executor_id: 2,
+            row_start: 0,
+            row_count: 1,
+        },
+        DirectRowGroupDescriptor {
+            stage: 2,
+            role: DirectExecutorRole::Contribution,
+            destination_operation: DirectDestinationOperation::Add,
+            direct_executor_id: 1,
+            row_start: 1,
+            row_count: 1,
+        },
+        DirectRowGroupDescriptor {
+            stage: 2,
+            role: DirectExecutorRole::Finalization,
+            destination_operation: DirectDestinationOperation::FinalizeInPlace,
+            direct_executor_id: 2,
+            row_start: 1,
+            row_count: 1,
+        },
+        DirectRowGroupDescriptor {
+            stage: 3,
+            role: DirectExecutorRole::Closure,
+            destination_operation: DirectDestinationOperation::ClosureAdd,
+            direct_executor_id: 3,
+            row_start: 0,
+            row_count: 1,
+        },
+    ];
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 1).unwrap();
+    runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+    runtime.momentum_plane_mut(0, 0).unwrap().unwrap()[0] = 2.0;
+
+    let output = runtime.execute_tile(1).unwrap();
+    assert_eq!(output.destination_re(0).unwrap(), &[16.0]);
+    assert_eq!(output.destination_im(0).unwrap(), &[12.0]);
+}
+
+#[test]
+fn external_momentum_planes_keep_bitwise_term_order_and_untouched_padding() {
+    let values = [0.0, -0.0, 1.0e16, 1.0, -1.0e16, f64::MIN_POSITIVE, -3.5];
+    for source_count in [1, 2, 5] {
+        for active_points in [1, 3, 4, 7, 8, 9, 31, 128] {
+            let point_stride = active_points + 8;
+            let external = (0..active_points * source_count * 4)
+                .map(|index| values[index % values.len()])
+                .collect::<Vec<_>>();
+            let mut external_planes = vec![0.0; external.len()];
+            for source in 0..source_count {
+                for component in 0..4 {
+                    for point in 0..active_points {
+                        external_planes[(source * 4 + component) * active_points + point] =
+                            external[(point * source_count + source) * 4 + component];
+                    }
+                }
+            }
+            for reverse in [false, true] {
+                // Repeated sources deliberately exercise non-associative
+                // cancellation: the new loop may not reorder any terms.
+                let terms = [(0, 1_i32), (source_count - 1, -2), (0, -1)];
+                for term_count in 0..=terms.len() {
+                    let mut observed = vec![17.0; 4 * point_stride];
+                    let permutation = |slot| {
+                        if reverse {
+                            source_count - 1 - slot
+                        } else {
+                            slot
+                        }
+                    };
+                    let sign = |slot| if reverse && slot % 2 == 0 { -1_i32 } else { 1 };
+                    super::fill_momentum_form_from_external::<false>(
+                        &mut observed,
+                        point_stride,
+                        active_points,
+                        &external,
+                        source_count,
+                        terms[..term_count].iter().map(|&(slot, coefficient)| {
+                            (
+                                permutation(slot),
+                                f64::from(coefficient) * f64::from(sign(slot)),
+                            )
+                        }),
+                    );
+                    let mut observed_planes = vec![17.0; 4 * point_stride];
+                    super::fill_momentum_form_from_external::<true>(
+                        &mut observed_planes,
+                        point_stride,
+                        active_points,
+                        &external_planes,
+                        source_count,
+                        terms[..term_count].iter().map(|&(slot, coefficient)| {
+                            (
+                                permutation(slot),
+                                f64::from(coefficient) * f64::from(sign(slot)),
+                            )
+                        }),
+                    );
+                    assert_eq!(
+                        observed
+                            .iter()
+                            .map(|value| value.to_bits())
+                            .collect::<Vec<_>>(),
+                        observed_planes
+                            .iter()
+                            .map(|value| value.to_bits())
+                            .collect::<Vec<_>>()
+                    );
+                    for component in 0..4 {
+                        for point in 0..active_points {
+                            let mut expected = 0.0_f64;
+                            for &(slot, coefficient) in &terms[..term_count] {
+                                let source =
+                                    (point * source_count + permutation(slot)) * 4 + component;
+                                expected += f64::from(coefficient)
+                                    * f64::from(sign(slot))
+                                    * external[source];
+                            }
+                            assert_eq!(
+                                observed[component * point_stride + point].to_bits(),
+                                expected.to_bits(),
+                                "sources={source_count}, points={active_points}, reverse={reverse}, terms={term_count}, component={component}, point={point}"
+                            );
+                        }
+                        assert!(
+                            observed[component * point_stride + active_points
+                                ..(component + 1) * point_stride]
+                                .iter()
+                                .all(|&value| value == 17.0)
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn external_momentum_planes_profiled_and_unprofiled_execution_match_point_major() {
+    fn bits(output: DirectRecurrenceTileOutput<'_>) -> (Vec<u64>, Vec<u64>) {
+        (
+            output
+                .storage_re()
+                .iter()
+                .map(|value| value.to_bits())
+                .collect(),
+            output
+                .storage_im()
+                .iter()
+                .map(|value| value.to_bits())
+                .collect(),
+        )
+    }
+    for contracted in [false, true] {
+        let (base, _) = synthetic_plan_and_executors();
+        let mut parts = base.into_parts();
+        if contracted {
+            parts.strategy = RecurrenceStrategy::ContractedColorUnion;
+        }
+        parts.replay_momentum_signs = vec![-1, 1, 1, -1];
+        let plan = DirectRecurrencePlan::new(parts).unwrap();
+        let executors = DirectExecutorCatalog::new(
+            &plan,
+            plan.direct_template_catalog_digest(),
+            direct_executor_handles(),
+        )
+        .unwrap();
+        let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+        runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+        for count in [4, 3, 1, 4] {
+            let point_major = (0..count * 8)
+                .map(|index| {
+                    if index % 7 == 0 {
+                        -0.0
+                    } else {
+                        index as f64 + 0.25
+                    }
+                })
+                .collect::<Vec<_>>();
+            let mut planes = vec![0.0; point_major.len()];
+            for source in 0..2 {
+                for component in 0..4 {
+                    for point in 0..count {
+                        planes[(source * 4 + component) * count + point] =
+                            point_major[(point * 2 + source) * 4 + component];
+                    }
+                }
+            }
+            for flow in 0..2 {
+                let selector = runtime.prepare_replay_selector(flow).unwrap();
+                let expected = bits(if contracted {
+                    runtime
+                        .execute_contracted_tile_from_external(count as u32, &point_major)
+                        .unwrap()
+                } else {
+                    runtime
+                        .execute_replay_tile_from_external(&selector, count as u32, &point_major)
+                        .unwrap()
+                });
+                let profiled = bits(if contracted {
+                    runtime
+                        .execute_contracted_tile_from_external_planes::<true>(count as u32, &planes)
+                        .unwrap()
+                } else {
+                    runtime
+                        .execute_replay_tile_from_external_planes::<true>(
+                            &selector,
+                            count as u32,
+                            &planes,
+                        )
+                        .unwrap()
+                });
+                assert_eq!(profiled, expected);
+                let before_unprofiled = runtime.activity_counters();
+                let unprofiled = bits(if contracted {
+                    runtime
+                        .execute_contracted_tile_from_external_planes::<false>(
+                            count as u32,
+                            &planes,
+                        )
+                        .unwrap()
+                } else {
+                    runtime
+                        .execute_replay_tile_from_external_planes::<false>(
+                            &selector,
+                            count as u32,
+                            &planes,
+                        )
+                        .unwrap()
+                });
+                assert_eq!(unprofiled, expected);
+                assert_eq!(runtime.activity_counters(), before_unprofiled);
+            }
+        }
+    }
+}
+
+#[test]
+fn external_momentum_fill_crossings_and_identity_preserve_bits_across_tile_tails() {
+    let (base, _) = synthetic_plan_and_executors();
+    let mut parts = base.into_parts();
+    parts.strategy = RecurrenceStrategy::ContractedColorUnion;
+    parts.point_tile_size = 9;
+    parts.momentum_terms[1].coefficient = -2;
+    parts.replay_momentum_signs = vec![-1, 1, 1, -1];
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    let selectors = [
+        runtime.prepare_replay_selector(0).unwrap(),
+        runtime.prepare_replay_selector(1).unwrap(),
+    ];
+    let values = [-0.0, 0.0, 1.0e16, 1.0, -1.0e16, f64::MIN_POSITIVE];
+    for point_count in [9, 7, 1, 9, 3] {
+        let external = (0..point_count as usize * 8)
+            .map(|index| values[index % values.len()])
+            .collect::<Vec<_>>();
+        for selector in [Some(&selectors[0]), Some(&selectors[1]), None] {
+            if let Some(selector) = selector {
+                runtime
+                    .fill_momenta_from_external_unprofiled(selector, point_count, &external)
+                    .unwrap();
+            } else {
+                runtime
+                    .fill_identity_momenta_from_external::<true, false>(point_count, &external)
+                    .unwrap();
+            }
+            let stride = runtime.point_stride() as usize;
+            for component in 0..4 {
+                for point in 0..point_count as usize {
+                    let mut expected = 0.0_f64;
+                    for term in runtime.plan.momentum_terms() {
+                        let slot = term.source_slot as usize;
+                        let (external_slot, coefficient) =
+                            selector.map_or((slot, f64::from(term.coefficient)), |selector| {
+                                (
+                                    selector.source_permutation[slot] as usize,
+                                    f64::from(term.coefficient)
+                                        * f64::from(selector.source_momentum_signs[slot]),
+                                )
+                            });
+                        expected +=
+                            coefficient * external[(point * 2 + external_slot) * 4 + component];
+                    }
+                    assert_eq!(
+                        runtime.momenta.as_slice()[component * stride + point].to_bits(),
+                        expected.to_bits()
+                    );
+                }
+                assert!(
+                    runtime.momenta.as_slice()[component * stride + point_count as usize
+                        ..component * stride + runtime.point_tile_size() as usize]
+                        .iter()
+                        .all(|value| value.to_bits() == 0.0_f64.to_bits())
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn external_momentum_fill_resolves_forms_once_and_clears_newly_inactive_tails() {
+    let mut runtime = synthetic_runtime_with_lorentz(4);
+    let flow_zero = runtime.prepare_replay_selector(0).unwrap();
+    let flow_one = runtime.prepare_replay_selector(1).unwrap();
+    let identity = storage_identity(&mut runtime);
+
+    assert!(
+        runtime
+            .fill_momenta_from_external(&flow_zero, 3, &external_two_point_momenta())
+            .unwrap_err()
+            .to_string()
+            .contains("expected 24")
+    );
+    runtime
+        .fill_momenta_from_external(&flow_zero, 3, &external_three_point_momenta())
+        .unwrap();
+    let point_stride = runtime.point_tile_size() as usize;
+    assert_eq!(runtime.momenta_mut().unwrap().len(), 4 * point_stride);
+    assert_eq!(
+        &runtime.momenta_mut().unwrap()[0..4],
+        &[9.0, 12.0, 23.0, 0.0]
+    );
+    assert_eq!(
+        &runtime.momenta_mut().unwrap()[point_stride..point_stride + 4],
+        &[90.0, 120.0, 230.0, 0.0]
+    );
+    assert_eq!(
+        &runtime.momenta_mut().unwrap()[2 * point_stride..2 * point_stride + 4],
+        &[900.0, 1200.0, 2300.0, 0.0]
+    );
+    assert_eq!(
+        &runtime.momenta_mut().unwrap()[3 * point_stride..3 * point_stride + 4],
+        &[9000.0, 12000.0, 23000.0, 0.0]
+    );
+
+    runtime
+        .fill_momenta_from_external(&flow_one, 2, &external_two_point_momenta())
+        .unwrap();
+    assert_eq!(&runtime.momenta_mut().unwrap()[0..4], &[6.0, 9.0, 0.0, 0.0]);
+    for plane in 0..4 {
+        assert_eq!(
+            runtime.momenta_mut().unwrap()[plane * point_stride + 2],
+            0.0
+        );
+    }
+    assert_eq!(storage_identity(&mut runtime), identity);
+    assert_eq!(
+        runtime.activity_counters(),
+        DirectRuntimeActivityCounters {
+            momentum_fill_calls: 2,
+            momentum_forms_filled: 2,
+            momentum_terms_filled: 4,
+            momentum_scalar_values_filled: 20,
+            ..DirectRuntimeActivityCounters::default()
+        }
+    );
+
+    let mut scalar_runtime = synthetic_runtime();
+    let scalar_selector = scalar_runtime.prepare_replay_selector(0).unwrap();
+    assert!(
+        scalar_runtime
+            .fill_momenta_from_external(&scalar_selector, 2, &external_two_point_momenta(),)
+            .unwrap_err()
+            .to_string()
+            .contains("requires 4 Lorentz components")
+    );
+}
+
+#[test]
+fn prepared_replay_selectors_cover_both_physical_flows_without_regeneration() {
+    let mut runtime = synthetic_runtime_with_lorentz(4);
+    let flow_zero = runtime.prepare_replay_selector(0).unwrap();
+    let flow_one = runtime.prepare_replay_selector(1).unwrap();
+    assert_eq!(flow_zero.mapped_external_source_slot(0), Some(0));
+    assert_eq!(flow_zero.mapped_external_source_slot(1), Some(1));
+    assert_eq!(flow_one.mapped_external_source_slot(0), Some(1));
+    assert_eq!(flow_one.mapped_external_source_slot(1), Some(0));
+    assert_eq!(flow_zero.phase(), (1.0, 0.0));
+    assert_eq!(flow_one.phase(), (0.0, 1.0));
+    assert_eq!(flow_one.multiplicity(), 2);
+    let identity = storage_identity(&mut runtime);
+
+    let output = runtime
+        .execute_replay_tile_from_external(&flow_zero, 2, &external_two_point_momenta())
+        .unwrap();
+    assert_eq!(output.public_flow_id(), Some(0));
+    assert_eq!(output.representative_flow_id(), Some(0));
+    assert_eq!(
+        output.selected_destination_ids().collect::<Vec<_>>(),
+        vec![0]
+    );
+    assert_eq!(output.destination_re(0).unwrap(), &[-27.0, -36.0]);
+    assert_eq!(output.destination_im(0).unwrap(), &[-9.0, -12.0]);
+
+    runtime
+        .fill_momenta_from_external(&flow_zero, 2, &external_two_point_momenta())
+        .unwrap();
+    assert!(
+        runtime
+            .execute_replay_tile(&flow_one, 2)
+            .unwrap_err()
+            .to_string()
+            .contains("were not filled for this selector")
+    );
+
+    let output = runtime
+        .execute_replay_tile_from_external(&flow_one, 2, &external_two_point_momenta())
+        .unwrap();
+    assert_eq!(output.public_flow_id(), Some(1));
+    assert_eq!(output.representative_flow_id(), Some(0));
+    assert_eq!(output.destination_re(0).unwrap(), &[12.0, 18.0]);
+    assert_eq!(output.destination_im(0).unwrap(), &[-36.0, -54.0]);
+    assert_eq!(storage_identity(&mut runtime), identity);
+
+    let direct = runtime.counters();
+    assert_eq!(direct.source_calls, 2);
+    assert_eq!(direct.contribution_calls, 2);
+    assert_eq!(direct.finalization_calls, 2);
+    assert_eq!(direct.closure_calls, 2);
+    assert_eq!(direct.packed_input_bytes, 0);
+    assert_eq!(direct.packed_output_bytes, 0);
+    assert_eq!(direct.scatter_bytes, 0);
+    let activity = runtime.activity_counters();
+    assert_eq!(activity.momentum_fill_calls, 3);
+    assert_eq!(activity.schedule_executions, 2);
+    assert_eq!(activity.replay_schedule_executions, 2);
+    assert_eq!(activity.replay_output_values_scaled, 4);
+}
+
+#[test]
+fn replay_observation_captures_representative_amplitude_before_single_public_scaling() {
+    let mut runtime = synthetic_runtime_with_lorentz(4);
+    let selector = runtime.prepare_replay_selector(1).unwrap();
+    begin_direct_current_observation(runtime.plan(), Some(selector.representative_flow_id()), 2)
+        .unwrap();
+
+    let output = runtime
+        .execute_replay_tile_from_external(&selector, 2, &external_two_point_momenta())
+        .unwrap();
+    let public = output
+        .destination_re(0)
+        .unwrap()
+        .iter()
+        .copied()
+        .zip(output.destination_im(0).unwrap().iter().copied())
+        .collect::<Vec<_>>();
+    let observation = take_direct_current_observation().unwrap();
+    let representative = &observation.amplitudes_before_replay[&0];
+
+    assert_eq!(representative, &[(-18.0, -6.0), (-27.0, -9.0)]);
+    let phase = selector.phase();
+    let multiplicity = f64::from(selector.multiplicity());
+    let expected_public = representative
+        .iter()
+        .map(|&(value_re, value_im)| {
+            let scale_re = phase.0 * multiplicity;
+            let scale_im = phase.1 * multiplicity;
+            (
+                value_re * scale_re - value_im * scale_im,
+                value_re * scale_im + value_im * scale_re,
+            )
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(public, expected_public);
+    assert_eq!(public, [(12.0, -36.0), (18.0, -54.0)]);
+}
+
+#[test]
+fn replay_selector_executes_only_its_dependency_closed_rows() {
+    let (base_plan, _) = synthetic_plan_and_executors();
+    let mut parts = base_plan.into_parts();
+    parts.current_arena_components = 3;
+    parts.selector_domains.push(DirectSelectorDomainDescriptor {
+        word_start: 1,
+        word_count: 1,
+    });
+    parts.selector_words.push(2);
+
+    let mut inactive_current = parts.currents[0];
+    inactive_current.semantic_current_id = 2;
+    inactive_current.component_base = 2;
+    inactive_current.selector_domain_id = 1;
+    inactive_current.source_row_or_sentinel = 1;
+    parts.currents.push(inactive_current);
+
+    let mut inactive_source = parts.sources[0];
+    inactive_source.destination_component_base = 2;
+    inactive_source.selector_domain_id = 1;
+    parts.sources.push(inactive_source);
+    parts
+        .row_groups
+        .iter_mut()
+        .find(|group| group.role == DirectExecutorRole::Source)
+        .unwrap()
+        .row_count = 2;
+
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+    let selector = runtime.prepare_replay_selector(0).unwrap();
+
+    assert_eq!(selector.selected_row_group_count(), 4);
+    assert_eq!(selector.selected_row_count(), 4);
+    let output = runtime
+        .execute_replay_tile_from_external(&selector, 2, &external_two_point_momenta())
+        .unwrap();
+    assert_eq!(output.destination_re(0).unwrap(), &[-27.0, -36.0]);
+    assert_eq!(runtime.counters().source_rows, 1);
+}
+
+/// The second helicity uses a numerically identified current from the first,
+/// copied into the storage formerly occupied by its (now dead) source.
+fn two_helicity_reused_storage_runtime() -> DirectRecurrenceExecutionRuntime {
+    let (plan, _) = synthetic_plan_and_executors();
+    let mut parts = plan.into_parts();
+    parts.amplitude_destination_count = 2;
+    parts.currents.push(DirectCurrentDescriptor {
+        semantic_current_id: 2,
+        component_base: 0,
+        stage: 2,
+        first_use: 2,
+        last_use: 3,
+        finalization_row_or_sentinel: DIRECT_NONE_U32,
+        ..parts.currents[1]
+    });
+    parts.contributions.push(DirectContributionRow {
+        parent0_component_base: 1,
+        parent0_momentum_form_id: 1, // certified-reuse component count
+        destination_component_base: 0,
+        exact_factor_id: 3,
+        flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+            | crate::recurrence::direct_plan::DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE,
+        ..parts.contributions[0]
+    });
+    parts.row_groups.insert(
+        3,
+        DirectRowGroupDescriptor {
+            stage: 2,
+            row_start: 1,
+            direct_executor_id: DIRECT_NONE_U32,
+            ..parts.row_groups[1]
+        },
+    );
+    parts.closures.push(DirectClosureRow {
+        parent0_component_base: 0,
+        amplitude_destination_id: 1,
+        flags: 1,
+        ..parts.closures[0]
+    });
+    parts.row_groups.push(DirectRowGroupDescriptor {
+        stage: 3,
+        row_start: 1,
+        ..parts.row_groups[4]
+    });
+    parts
+        .amplitude_destinations
+        .push(DirectAmplitudeDestinationDescriptor {
+            id: 1,
+            target_helicity_id_or_sentinel: 1,
+            closure_row_start: 1,
+            ..parts.amplitude_destinations[0]
+        });
+    parts
+        .resolved_helicities
+        .push(DirectResolvedHelicityDescriptor {
+            id: 1,
+            source_state_start: 2,
+            public_helicity_start: 2,
+            ..parts.resolved_helicities[0]
+        });
+    parts.source_state_assignments.extend_from_within(0..2);
+    parts.public_helicities.extend([1, -1]);
+    parts.replay_helicity_map = vec![0, 1, 0, 1];
+    parts.replay_targets[0].helicity_map_count = 2;
+    parts.replay_targets[1].helicity_map_start = 2;
+    parts.replay_targets[1].helicity_map_count = 2;
+    let prototype = &parts.closure_proofs.contributions()[0];
+    let contribution = ClosureProofContributionV2::new(
+        1,
+        0,
+        Some(1),
+        Some(1),
+        prototype.closure_template_id(),
+        prototype.closure_template_semantic_digest(),
+        prototype.quantum_flow_template_id(),
+        vec![2],
+        vec![Some(2)],
+        prototype.construction_parent_semantic_digests().to_vec(),
+        prototype.construction_parent_color_digests().to_vec(),
+        vec![0],
+        vec![0],
+        vec![0],
+        prototype.color_witness_term_id(),
+        prototype.color_witness_proof_digest(),
+        prototype.three_line_certificate_id(),
+        prototype.pairing_certificate_ids().to_vec(),
+        prototype.reflection_certificate_id(),
+        prototype.exact_factor(),
+        prototype.multiplicity(),
+    )
+    .unwrap();
+    let old_group = &parts.closure_proofs.groups()[0];
+    let group = ClosureExecutionProofGroupV2::new_with_candidate_selector_domain(
+        1,
+        Some(1),
+        Some(1),
+        CheckedTableRange::new(1, 1),
+        old_group.exact_summed_factor(),
+        old_group.component_factor_digest(),
+        old_group.candidate_selector_domain_digest(),
+        old_group.selector_domain_digest(),
+    )
+    .unwrap();
+    parts.closure_proofs = ClosureProofMetadataV2::new_with_three_line_certificates(
+        vec![prototype.clone(), contribution],
+        vec![old_group.clone(), group],
+        parts.closure_proofs.reflection_certificates().to_vec(),
+        parts
+            .closure_proofs
+            .three_line_traversal_certificates()
+            .to_vec(),
+    )
+    .unwrap();
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+    runtime
+}
+
+#[test]
+fn selected_amplitude_views_match_public_accessors_and_check_active_ranges() {
+    let runtime = two_helicity_reused_storage_runtime();
+    let mut destinations = runtime.plan().amplitude_destinations().to_vec();
+    destinations.push(DirectAmplitudeDestinationDescriptor {
+        id: 2,
+        target_sector_id: 1,
+        ..destinations[0]
+    });
+    let real = (0..12).map(|value| value as f64).collect::<Vec<_>>();
+    let imaginary = real.iter().map(|value| -value).collect::<Vec<_>>();
+    for point_count in [1, 3, 4] {
+        for (representative, selection, expected_ids) in [
+            (None, None, &[0, 1, 2][..]),
+            (Some(0), None, &[0, 1][..]),
+            (Some(1), None, &[2][..]),
+            (Some(0), Some(&[1][..]), &[1][..]),
+            (Some(0), Some(&[][..]), &[][..]),
+        ] {
+            let output = DirectRecurrenceTileOutput {
+                amplitude_re: &real,
+                amplitude_im: &imaginary,
+                amplitude_destinations: &destinations,
+                point_count,
+                point_stride: 4,
+                destination_count: 3,
+                public_flow_id: representative,
+                representative_flow_id: representative,
+                selected_destination_ids: selection,
+            };
+            let views = output
+                .selected_amplitudes()
+                .collect::<crate::RusticolResult<Vec<_>>>()
+                .unwrap();
+            assert_eq!(
+                views
+                    .iter()
+                    .map(|view| view.destination.id)
+                    .collect::<Vec<_>>(),
+                expected_ids
+            );
+            for view in views {
+                let id = view.destination.id;
+                assert_eq!(view.real, output.destination_re(id).unwrap());
+                assert_eq!(view.imaginary, output.destination_im(id).unwrap());
+                assert_eq!(
+                    view.real.as_ptr(),
+                    output.destination_re(id).unwrap().as_ptr()
+                );
+                assert_eq!(
+                    view.imaginary.as_ptr(),
+                    output.destination_im(id).unwrap().as_ptr()
+                );
+                assert_eq!(view.destination, &destinations[id as usize]);
+            }
+        }
+    }
+    let malformed = DirectRecurrenceTileOutput {
+        amplitude_re: &real,
+        amplitude_im: &imaginary[..2],
+        amplitude_destinations: &destinations,
+        point_count: 3,
+        point_stride: 4,
+        destination_count: 3,
+        public_flow_id: Some(0),
+        representative_flow_id: Some(0),
+        selected_destination_ids: Some(&[0]),
+    };
+    assert!(malformed.selected_amplitudes().next().unwrap().is_err());
+}
+
+#[test]
+fn destination_replay_preserves_shared_helicity_currents_and_recycled_storage() {
+    let mut runtime = two_helicity_reused_storage_runtime();
+    let all = runtime.prepare_replay_selector(0).unwrap();
+    let selected = [
+        runtime
+            .prepare_replay_selector_for_destinations(&all, &[0])
+            .unwrap(),
+        runtime
+            .prepare_replay_selector_for_destinations(&all, &[1])
+            .unwrap(),
+    ];
+    assert_eq!(all.selected_row_count(), 6);
+    assert_eq!(selected[0].selected_row_count(), 4);
+    assert_eq!(selected[1].selected_row_count(), 5);
+    let empty = runtime
+        .prepare_replay_selector_for_destinations(&all, &[])
+        .unwrap();
+    let both = runtime
+        .prepare_replay_selector_for_destinations(&all, &[0, 1])
+        .unwrap();
+    for selector in [&selected[0], &selected[1], &empty, &both] {
+        assert!(
+            selector
+                .destination_program
+                .as_ref()
+                .unwrap()
+                .current_clear_stages
+                .is_empty()
+        );
+    }
+    let momenta = external_two_point_momenta();
+    let expected = {
+        let output = runtime
+            .execute_replay_tile_from_external(&all, 2, &momenta)
+            .unwrap();
+        [0, 1].map(|id| {
+            (
+                output.destination_re(id).unwrap().to_vec(),
+                output.destination_im(id).unwrap().to_vec(),
+            )
+        })
+    };
+    let allocations = runtime.allocation_counters();
+    for id in [0, 1, 0, 1] {
+        let output = runtime
+            .execute_replay_tile_from_external(&selected[id], 2, &momenta)
+            .unwrap();
+        assert_eq!(
+            output.selected_destination_ids().collect::<Vec<_>>(),
+            vec![id as u32]
+        );
+        assert_eq!(output.destination_re(id as u32).unwrap(), expected[id].0);
+        assert_eq!(output.destination_im(id as u32).unwrap(), expected[id].1);
+        assert!(output.destination_re(1 - id as u32).is_none());
+    }
+    let output = runtime
+        .execute_replay_tile_from_external(&empty, 2, &momenta)
+        .unwrap();
+    assert_eq!(output.selected_destination_ids().count(), 0);
+    assert!(output.destination_re(0).is_none());
+    let output = runtime
+        .execute_replay_tile_from_external(&both, 2, &momenta)
+        .unwrap();
+    for id in [0, 1] {
+        assert_eq!(output.destination_re(id).unwrap(), expected[id as usize].0);
+    }
+    assert_eq!(runtime.allocation_counters(), allocations);
+    assert!(
+        runtime
+            .prepare_replay_selector_for_destinations(&all, &[1, 0])
+            .is_err()
+    );
+    assert!(
+        runtime
+            .prepare_replay_selector_for_destinations(&all, &[0, 0])
+            .is_err()
+    );
+    assert!(
+        runtime
+            .prepare_replay_selector_for_destinations(&all, &[2])
+            .is_err()
+    );
+}
+
+#[test]
+fn destination_replay_initializers_overwrite_poisoned_recycled_storage_and_tile_tails() {
+    let mut runtime = two_helicity_reused_storage_runtime();
+    let all = runtime.prepare_replay_selector(0).unwrap();
+    let momenta = [1.25, -3.5, 7.0, 0.125]
+        .into_iter()
+        .flat_map(|energy| [energy, 0.0, 0.0, 0.0, energy * 0.5, 0.0, 0.0, 0.0])
+        .collect::<Vec<_>>();
+    for destination_ids in [&[0][..], &[1][..], &[0, 1][..]] {
+        let selected = runtime
+            .prepare_replay_selector_for_destinations(&all, destination_ids)
+            .unwrap();
+        assert!(
+            selected
+                .destination_program
+                .as_ref()
+                .unwrap()
+                .current_clear_stages
+                .is_empty()
+        );
+        for point_count in [4, 3, 1, 4] {
+            let input = &momenta[..point_count as usize * 8];
+            let expected = {
+                let output = runtime
+                    .execute_replay_tile_from_external(&all, point_count, input)
+                    .unwrap();
+                destination_ids
+                    .iter()
+                    .map(|&id| {
+                        (
+                            output.destination_re(id).unwrap().to_vec(),
+                            output.destination_im(id).unwrap().to_vec(),
+                        )
+                    })
+                    .collect::<Vec<_>>()
+            };
+            for profiled in [true, false] {
+                let (current_re, current_im, _, _) = runtime.arena.split_slices_mut();
+                current_re.fill(f64::NAN);
+                current_im.fill(f64::NAN);
+                let output = if profiled {
+                    runtime.execute_replay_tile_from_external(&selected, point_count, input)
+                } else {
+                    runtime.execute_replay_tile_from_external_unprofiled(
+                        &selected,
+                        point_count,
+                        input,
+                    )
+                }
+                .unwrap();
+                for (&id, (real, imaginary)) in destination_ids.iter().zip(&expected) {
+                    assert_eq!(output.destination_re(id).unwrap(), real);
+                    assert_eq!(output.destination_im(id).unwrap(), imaginary);
+                }
+                let stride = runtime.point_stride() as usize;
+                let (current_re, current_im) = runtime.current_arenas();
+                for plane in current_re
+                    .chunks_exact(stride)
+                    .chain(current_im.chunks_exact(stride))
+                {
+                    assert!(
+                        plane[point_count as usize..]
+                            .iter()
+                            .all(|value| value.is_nan())
+                    );
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn destination_replay_retains_clear_when_row_selector_omits_the_initializer() {
+    let mut parts = two_helicity_reused_storage_runtime()
+        .plan()
+        .clone()
+        .into_parts();
+    parts.selector_domains.push(DirectSelectorDomainDescriptor {
+        word_start: parts.selector_words.len() as u64,
+        word_count: 1,
+    });
+    parts.selector_words.push(2);
+    let mut additive = parts.contributions[0];
+    additive.flags = 0;
+    parts.contributions[0].selector_domain_id = 1;
+    parts.contributions.insert(1, additive);
+    parts.row_groups[1].row_count = 2;
+    parts.row_groups[3].row_start = 2;
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+    let all = runtime.prepare_replay_selector(0).unwrap();
+    let selected = runtime
+        .prepare_replay_selector_for_destinations(&all, &[0, 1])
+        .unwrap();
+    let stages = &selected
+        .destination_program
+        .as_ref()
+        .unwrap()
+        .current_clear_stages;
+    assert_eq!(stages.len(), 1);
+    assert_eq!(stages[0].stage, 1);
+    assert_eq!(stages[0].ranges.len(), 1);
+    assert_eq!(stages[0].ranges[0].component_base, 1);
+    assert_eq!(stages[0].ranges[0].component_count, 1);
+    let momenta = external_two_point_momenta();
+    for point_count in [2, 1, 2] {
+        let input = &momenta[..point_count as usize * 8];
+        let expected = {
+            let output = runtime
+                .execute_replay_tile_from_external(&all, point_count, input)
+                .unwrap();
+            [0, 1].map(|id| {
+                (
+                    output.destination_re(id).unwrap().to_vec(),
+                    output.destination_im(id).unwrap().to_vec(),
+                )
+            })
+        };
+        for profiled in [true, false] {
+            let (current_re, current_im, _, _) = runtime.arena.split_slices_mut();
+            current_re.fill(f64::NAN);
+            current_im.fill(f64::NAN);
+            let output = if profiled {
+                runtime.execute_replay_tile_from_external(&selected, point_count, input)
+            } else {
+                runtime.execute_replay_tile_from_external_unprofiled(&selected, point_count, input)
+            }
+            .unwrap();
+            for (id, (real, imaginary)) in expected.iter().enumerate() {
+                assert_eq!(output.destination_re(id as u32).unwrap(), real);
+                assert_eq!(output.destination_im(id as u32).unwrap(), imaginary);
+            }
+        }
+    }
+}
+
+#[test]
+fn destination_replay_self_copy_preserves_clear_for_mutable_zero_factor() {
+    let mut parts = two_helicity_reused_storage_runtime()
+        .plan()
+        .clone()
+        .into_parts();
+    parts.contributions[1].parent0_component_base =
+        parts.contributions[1].destination_component_base;
+    parts.contributions[1].exact_factor_id = parts.exact_factors.len() as u32;
+    parts.exact_factors.push(ExactComplexRational::ZERO);
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+    let all = runtime.prepare_replay_selector(0).unwrap();
+    let selected = runtime
+        .prepare_replay_selector_for_destinations(&all, &[1])
+        .unwrap();
+    let stages = &selected
+        .destination_program
+        .as_ref()
+        .unwrap()
+        .current_clear_stages;
+    assert_eq!(stages.len(), 1);
+    assert_eq!(stages[0].stage, 2);
+    let momenta = external_two_point_momenta();
+    let factor_id = runtime.plan().contributions()[1].exact_factor_id as usize;
+    for (point_count, factor) in [(2, 0.0), (1, 1.0), (2, 0.0)] {
+        runtime.factors_mut().0[factor_id] = factor;
+        for profiled in [true, false] {
+            runtime.activate_point_layout(point_count).unwrap();
+            let (current_re, current_im, _, _) = runtime.arena.split_slices_mut();
+            current_re.fill(f64::NAN);
+            current_im.fill(f64::NAN);
+            let input = &momenta[..point_count as usize * 8];
+            let output = if profiled {
+                runtime.execute_replay_tile_from_external(&selected, point_count, input)
+            } else {
+                runtime.execute_replay_tile_from_external_unprofiled(&selected, point_count, input)
+            }
+            .unwrap();
+            assert!(
+                output
+                    .destination_re(1)
+                    .unwrap()
+                    .iter()
+                    .all(|&value| value == 0.0)
+            );
+            assert!(
+                output
+                    .destination_im(1)
+                    .unwrap()
+                    .iter()
+                    .all(|&value| value == 0.0)
+            );
+        }
+    }
+}
+
+#[test]
+fn destination_replay_partial_copy_retains_the_entire_target_clear() {
+    let mut parts = two_helicity_reused_storage_runtime()
+        .plan()
+        .clone()
+        .into_parts();
+    // The later current has a wider span than the old source occupying its
+    // first slot. Such a custom copy remains valid, but initializes only the
+    // copied prefix and therefore still needs the full current clear.
+    parts.current_arena_components = 3;
+    parts.currents[1].component_base = 2;
+    parts.currents[2].component_count = 2;
+    parts.contributions[0].destination_component_base = 2;
+    parts.finalizations[0].component_base = 2;
+    parts.closures[0].parent0_component_base = 2;
+    parts.contributions[1].parent0_component_base = 2;
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+    let all = runtime.prepare_replay_selector(0).unwrap();
+    let selected = runtime
+        .prepare_replay_selector_for_destinations(&all, &[1])
+        .unwrap();
+    let stages = &selected
+        .destination_program
+        .as_ref()
+        .unwrap()
+        .current_clear_stages;
+    assert_eq!(stages.len(), 1);
+    assert_eq!(stages[0].stage, 2);
+    assert_eq!(stages[0].ranges[0].component_base, 0);
+    assert_eq!(stages[0].ranges[0].component_count, 2);
+    let (current_re, current_im, _, _) = runtime.arena.split_slices_mut();
+    current_re.fill(f64::NAN);
+    current_im.fill(f64::NAN);
+    runtime
+        .execute_replay_tile_from_external(&selected, 2, &external_two_point_momenta())
+        .unwrap();
+    let stride = runtime.point_stride() as usize;
+    let (current_re, current_im) = runtime.current_arenas();
+    assert_eq!(&current_re[stride..stride + 2], &[0.0, 0.0]);
+    assert_eq!(&current_im[stride..stride + 2], &[0.0, 0.0]);
+}
+
+#[test]
+fn destination_replay_shared_program_preserves_public_flow_phase() {
+    let mut runtime = synthetic_runtime_with_lorentz(4);
+    let base = runtime.prepare_replay_selector(0).unwrap();
+    let unrestricted = runtime.prepare_replay_selector(1).unwrap();
+    let first = runtime
+        .prepare_replay_selector_for_destinations(&base, &[0])
+        .unwrap();
+    let second = runtime
+        .prepare_replay_selector_with_destination_program(&unrestricted, &first)
+        .unwrap();
+    // Adding selected helicities must not duplicate the full helicity map,
+    // immutable source mapping, or unrestricted per-flow row schedule.
+    for (base, selected) in [(&base, &first), (&unrestricted, &second)] {
+        assert!(std::sync::Arc::ptr_eq(
+            &base.source_permutation,
+            &selected.source_permutation
+        ));
+        assert!(std::sync::Arc::ptr_eq(
+            &base.source_momentum_signs,
+            &selected.source_momentum_signs
+        ));
+        assert!(std::sync::Arc::ptr_eq(
+            &base.helicity_map,
+            &selected.helicity_map
+        ));
+        assert!(std::sync::Arc::ptr_eq(
+            &base.row_groups,
+            &selected.row_groups
+        ));
+        assert!(std::sync::Arc::ptr_eq(
+            &base.amplitude_clear_ranges,
+            &selected.amplitude_clear_ranges
+        ));
+    }
+    assert!(std::sync::Arc::ptr_eq(
+        first.destination_program.as_ref().unwrap(),
+        second.destination_program.as_ref().unwrap()
+    ));
+    let momenta = external_two_point_momenta();
+    let expected = {
+        let output = runtime
+            .execute_replay_tile_from_external(&unrestricted, 2, &momenta)
+            .unwrap();
+        (
+            output.destination_re(0).unwrap().to_vec(),
+            output.destination_im(0).unwrap().to_vec(),
+        )
+    };
+    let output = runtime
+        .execute_replay_tile_from_external(&second, 2, &momenta)
+        .unwrap();
+    assert_eq!(output.destination_re(0).unwrap(), expected.0);
+    assert_eq!(output.destination_im(0).unwrap(), expected.1);
+}
+
+#[test]
+fn destination_replay_matches_fanout_under_complex_cancellation() {
+    let plan = fanout_test_plan();
+    let census = ContributionCallCensus::default();
+    let catalog = fanout_test_catalog(&plan, &census, false);
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, catalog, 4).unwrap();
+    runtime.set_parameters(&[0.375], &[-1.125]).unwrap();
+    let all = runtime.prepare_replay_selector(0).unwrap();
+    let selected = runtime
+        .prepare_replay_selector_for_destinations(&all, &[0])
+        .unwrap();
+    let momenta = [0.125, -0.875, 1.75, -3.5, 0.0625, 7.25, -11.0]
+        .into_iter()
+        .flat_map(|energy| [energy, 0.0, 0.0, 0.0])
+        .collect::<Vec<_>>();
+    let expected = {
+        let output = runtime
+            .execute_replay_tile_from_external(&all, 7, &momenta)
+            .unwrap();
+        output
+            .destination_re(0)
+            .unwrap()
+            .iter()
+            .copied()
+            .zip(output.destination_im(0).unwrap().iter().copied())
+            .collect::<Vec<_>>()
+    };
+    assert_eq!(census.rows.load(Ordering::Relaxed), 1);
+    let output = runtime
+        .execute_replay_tile_from_external_unprofiled(&selected, 7, &momenta)
+        .unwrap();
+    let observed = output
+        .destination_re(0)
+        .unwrap()
+        .iter()
+        .copied()
+        .zip(output.destination_im(0).unwrap().iter().copied())
+        .collect::<Vec<_>>();
+    assert_scale_relative_complex_parity(&expected, &observed);
+    assert_eq!(census.rows.load(Ordering::Relaxed), 19);
+}
+
+#[test]
+fn tile_execution_clears_only_active_additive_regions() {
+    let mut runtime = synthetic_runtime();
+    runtime
+        .momentum_plane_mut(0, 0)
+        .unwrap()
+        .unwrap()
+        .copy_from_slice(&[2.0, 4.0, 100.0, 200.0]);
+    runtime.execute_tile(4).unwrap();
+    let point_stride = runtime.point_stride() as usize;
+    let (prior_current_re_tail, prior_current_im_tail) = {
+        let (current_re, current_im) = runtime.current_arenas();
+        (
+            current_re[point_stride + 2..point_stride + 4].to_vec(),
+            current_im[point_stride + 2..point_stride + 4].to_vec(),
+        )
+    };
+    let (prior_amplitude_re_tail, prior_amplitude_im_tail) = {
+        let (amplitude_re, amplitude_im) = runtime.amplitude_arenas();
+        (amplitude_re[2..4].to_vec(), amplitude_im[2..4].to_vec())
+    };
+
+    let output = runtime.execute_tile(2).unwrap();
+    assert_eq!(output.destination_re(0).unwrap(), &[-6.0, -12.0]);
+    assert_eq!(output.destination_im(0).unwrap(), &[-2.0, -4.0]);
+    assert_eq!(&output.storage_re()[2..4], prior_amplitude_re_tail);
+    assert_eq!(&output.storage_im()[2..4], prior_amplitude_im_tail);
+    let (current_re, current_im) = runtime.current_arenas();
+    assert_eq!(&current_re[point_stride..point_stride + 2], &[6.0, 12.0]);
+    assert_eq!(
+        &current_re[point_stride + 2..point_stride + 4],
+        prior_current_re_tail
+    );
+    assert_eq!(
+        &current_im[point_stride + 2..point_stride + 4],
+        prior_current_im_tail
+    );
+}
+
+#[test]
+fn tile_bounds_fail_before_direct_execution() {
+    let mut runtime = synthetic_runtime();
+    assert!(
+        runtime
+            .execute_tile(0)
+            .unwrap_err()
+            .to_string()
+            .contains("must be positive")
+    );
+    assert!(
+        runtime
+            .execute_tile(5)
+            .unwrap_err()
+            .to_string()
+            .contains("exceeds point tile size 4")
+    );
+    assert!(
+        runtime
+            .set_parameters(&[], &[])
+            .unwrap_err()
+            .to_string()
+            .contains("expected 1")
+    );
+    assert!(
+        runtime
+            .set_parameters(&[1.0], &[0.0, 0.0])
+            .unwrap_err()
+            .to_string()
+            .contains("expected 1")
+    );
+    assert!(runtime.outputs().is_none());
+    assert_eq!(runtime.counters(), DirectExecutionCounters::default());
+
+    let (plan, executors) = synthetic_plan_and_executors();
+    let error = DirectRecurrenceExecutionRuntime::new(plan, executors, 0)
+        .err()
+        .unwrap();
+    assert!(error.to_string().contains("Lorentz component count"));
+}
+
+#[test]
+fn runtime_parameter_storage_is_sized_from_the_authenticated_plan() {
+    let (plan, executors) = synthetic_plan_and_executors();
+    assert_eq!(plan.parameter_value_count(), 1);
+    let mut runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 1).unwrap();
+    let (parameters_re, parameters_im) = runtime.parameters_mut();
+    assert_eq!(parameters_re.len(), 1);
+    assert_eq!(parameters_im.len(), 1);
+}
+
+#[test]
+fn runtime_clamps_the_effective_tile_but_accepts_a_point_above_the_target() {
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.point_tile_size = 1024;
+    parts.workspace_mib = 1;
+    parts.current_arena_components = 256;
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    let per_point_bytes = (256 * 2 + 2 + 4) * std::mem::size_of::<f64>();
+    let expected_tile = ((1024 * 1024 / per_point_bytes) / 8 * 8) as u32;
+    assert_eq!(runtime.point_tile_size(), expected_tile);
+    assert_eq!(runtime.point_stride(), expected_tile);
+    assert!(runtime.point_tile_size() < 1024);
+
+    let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+    parts.point_tile_size = 1024;
+    parts.workspace_mib = 1;
+    parts.current_arena_components = 70_000;
+    let plan = DirectRecurrencePlan::new(parts).unwrap();
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap();
+    let runtime = DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap();
+    assert_eq!(runtime.point_tile_size(), 8);
+    assert_eq!(runtime.point_stride(), 8);
+
+    let plan = DirectRecurrencePlan::new({
+        let mut parts = crate::recurrence::direct_plan::tests::valid_parts();
+        parts.point_tile_size = 1024;
+        parts.workspace_mib = 1;
+        parts.current_arena_components = 70_000;
+        parts
+    })
+    .unwrap();
+    let packed_executors = DirectExecutorCatalog::new(
+        &plan,
+        plan.direct_template_catalog_digest(),
+        direct_executor_handles(),
+    )
+    .unwrap()
+    .mark_packed_singleton_capable();
+    let runtime = DirectRecurrenceExecutionRuntime::new(plan, packed_executors, 4).unwrap();
+    assert_eq!(runtime.point_tile_size(), 8);
+    assert_eq!(runtime.point_stride(), 1);
+}
+
+#[test]
+fn runtime_source_has_no_eager_or_scatter_execution_route() {
+    let source = include_str!("direct_runtime.rs");
+    for forbidden in [
+        "EagerKernelInput",
+        "EagerKernelBackend",
+        "EagerKernelCall",
+        "evaluate_batch",
+        "Attachment",
+    ] {
+        assert!(
+            !source.contains(forbidden),
+            "direct runtime must not contain {forbidden}"
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/exact.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/exact.rs
new file mode 100644
index 0000000000..e6f1a17ab3
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/exact.rs
@@ -0,0 +1,481 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::cmp::Ordering;
+use std::fmt;
+use std::str::FromStr;
+
+use crate::{RusticolError, RusticolResult};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+fn gcd(mut left: u128, mut right: u128) -> u128 {
+    while right != 0 {
+        let remainder = left % right;
+        left = right;
+        right = remainder;
+    }
+    left
+}
+
+fn checked_i128(value: u128, negative: bool, context: &str) -> RusticolResult<i128> {
+    if value > i128::MAX as u128 {
+        return Err(invalid(format!(
+            "{context} exceeds the dependency-free exact i128 domain"
+        )));
+    }
+    let value = value as i128;
+    if negative {
+        value
+            .checked_neg()
+            .ok_or_else(|| invalid(format!("{context} cannot be negated exactly")))
+    } else {
+        Ok(value)
+    }
+}
+
+fn checked_divisor(value: u128, context: &str) -> RusticolResult<i128> {
+    i128::try_from(value).map_err(|_| {
+        invalid(format!(
+            "{context} exceeds the dependency-free exact i128 domain"
+        ))
+    })
+}
+
+/// A canonical exact rational in the dependency-free, checked i128 domain.
+///
+/// Operations never round.  Values or intermediate results outside this
+/// domain fail closed; callers must not replace such failures with binary64
+/// arithmetic.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, bincode::Encode)]
+pub struct ExactRational {
+    numerator: i128,
+    denominator: i128,
+}
+
+impl<Context> bincode::Decode<Context> for ExactRational {
+    fn decode<D: bincode::de::Decoder<Context = Context>>(
+        decoder: &mut D,
+    ) -> Result<Self, bincode::error::DecodeError> {
+        let numerator = bincode::Decode::decode(decoder)?;
+        let denominator = bincode::Decode::decode(decoder)?;
+        Self::new(numerator, denominator)
+            .map_err(|error| bincode::error::DecodeError::OtherString(error.to_string()))
+    }
+}
+
+bincode::impl_borrow_decode!(ExactRational);
+
+impl ExactRational {
+    pub const ZERO: Self = Self {
+        numerator: 0,
+        denominator: 1,
+    };
+    pub const ONE: Self = Self {
+        numerator: 1,
+        denominator: 1,
+    };
+
+    pub fn new(numerator: i128, denominator: i128) -> RusticolResult<Self> {
+        if denominator <= 0 {
+            return Err(invalid("exact rational denominator must be positive"));
+        }
+        if numerator == 0 {
+            return Ok(Self::ZERO);
+        }
+        if numerator == i128::MIN {
+            return Err(invalid(
+                "exact rational numerator exceeds the symmetric dependency-free i128 domain",
+            ));
+        }
+        let divisor = gcd(numerator.unsigned_abs(), denominator as u128);
+        let divisor = checked_divisor(divisor, "exact rational gcd")?;
+        Ok(Self {
+            numerator: numerator / divisor,
+            denominator: denominator / divisor,
+        })
+    }
+
+    pub fn parse_parts(numerator: &str, denominator: &str) -> RusticolResult<Self> {
+        let numerator = parse_signed_decimal(numerator, "numerator")?;
+        let denominator = parse_positive_decimal(denominator, "denominator")?;
+        Self::new(numerator, denominator)
+    }
+
+    /// Convert a finite binary64 value to its exact dyadic rational whenever
+    /// that rational fits in the checked i128 domain.
+    pub fn from_f64_exact(value: f64) -> RusticolResult<Self> {
+        if !value.is_finite() {
+            return Err(invalid("exact rational source must be finite binary64"));
+        }
+        let bits = value.to_bits();
+        let negative = bits >> 63 != 0;
+        let exponent_bits = ((bits >> 52) & 0x7ff) as i32;
+        let fraction = bits & ((1_u64 << 52) - 1);
+        if exponent_bits == 0 && fraction == 0 {
+            return Ok(Self::ZERO);
+        }
+
+        let (mut significand, mut exponent) = if exponent_bits == 0 {
+            (u128::from(fraction), -1074_i32)
+        } else {
+            (
+                u128::from((1_u64 << 52) | fraction),
+                exponent_bits - 1023 - 52,
+            )
+        };
+        let trailing = significand.trailing_zeros() as i32;
+        significand >>= trailing;
+        exponent += trailing;
+
+        if exponent >= 0 {
+            let shifted = significand
+                .checked_shl(exponent as u32)
+                .ok_or_else(|| invalid("binary64 numerator exceeds exact i128 domain"))?;
+            return Self::new(checked_i128(shifted, negative, "binary64 numerator")?, 1);
+        }
+
+        let denominator = 1_u128
+            .checked_shl((-exponent) as u32)
+            .ok_or_else(|| invalid("binary64 denominator exceeds exact i128 domain"))?;
+        Self::new(
+            checked_i128(significand, negative, "binary64 numerator")?,
+            checked_divisor(denominator, "binary64 denominator")?,
+        )
+    }
+
+    pub const fn numerator(self) -> i128 {
+        self.numerator
+    }
+
+    pub const fn denominator(self) -> i128 {
+        self.denominator
+    }
+
+    pub const fn is_zero(self) -> bool {
+        self.numerator == 0
+    }
+
+    pub const fn is_one(self) -> bool {
+        self.numerator == 1 && self.denominator == 1
+    }
+
+    pub fn checked_neg(self) -> RusticolResult<Self> {
+        Self::new(
+            self.numerator
+                .checked_neg()
+                .ok_or_else(|| invalid("exact rational negation overflow"))?,
+            self.denominator,
+        )
+    }
+
+    pub fn checked_add(self, right: Self) -> RusticolResult<Self> {
+        let common = checked_divisor(
+            gcd(self.denominator as u128, right.denominator as u128),
+            "exact rational denominator gcd",
+        )?;
+        let left_factor = right.denominator / common;
+        let right_factor = self.denominator / common;
+        let left = self
+            .numerator
+            .checked_mul(left_factor)
+            .ok_or_else(|| invalid("exact rational addition numerator overflow"))?;
+        let right_term = right
+            .numerator
+            .checked_mul(right_factor)
+            .ok_or_else(|| invalid("exact rational addition numerator overflow"))?;
+        let numerator = left
+            .checked_add(right_term)
+            .ok_or_else(|| invalid("exact rational addition numerator overflow"))?;
+        let denominator = right_factor
+            .checked_mul(right.denominator)
+            .ok_or_else(|| invalid("exact rational addition denominator overflow"))?;
+        Self::new(numerator, denominator)
+    }
+
+    pub fn checked_sub(self, right: Self) -> RusticolResult<Self> {
+        self.checked_add(right.checked_neg()?)
+    }
+
+    pub fn checked_mul(self, right: Self) -> RusticolResult<Self> {
+        if self.is_zero() || right.is_zero() {
+            return Ok(Self::ZERO);
+        }
+        let left_cross = checked_divisor(
+            gcd(self.numerator.unsigned_abs(), right.denominator as u128),
+            "exact rational multiplication cross-gcd",
+        )?;
+        let right_cross = checked_divisor(
+            gcd(right.numerator.unsigned_abs(), self.denominator as u128),
+            "exact rational multiplication cross-gcd",
+        )?;
+        let numerator = (self.numerator / left_cross)
+            .checked_mul(right.numerator / right_cross)
+            .ok_or_else(|| invalid("exact rational multiplication numerator overflow"))?;
+        let denominator = (self.denominator / right_cross)
+            .checked_mul(right.denominator / left_cross)
+            .ok_or_else(|| invalid("exact rational multiplication denominator overflow"))?;
+        Self::new(numerator, denominator)
+    }
+
+    pub fn checked_div(self, right: Self) -> RusticolResult<Self> {
+        if right.is_zero() {
+            return Err(invalid("exact rational division by zero"));
+        }
+        let reciprocal_numerator = if right.numerator < 0 {
+            right
+                .denominator
+                .checked_neg()
+                .ok_or_else(|| invalid("exact rational reciprocal overflow"))?
+        } else {
+            right.denominator
+        };
+        let reciprocal_denominator = checked_divisor(
+            right.numerator.unsigned_abs(),
+            "exact rational reciprocal denominator",
+        )?;
+        self.checked_mul(Self::new(reciprocal_numerator, reciprocal_denominator)?)
+    }
+
+    pub fn checked_square(self) -> RusticolResult<Self> {
+        self.checked_mul(self)
+    }
+}
+
+impl Ord for ExactRational {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self.numerator.signum(), other.numerator.signum()) {
+            (left, right) if left != right => left.cmp(&right),
+            (0, 0) => Ordering::Equal,
+            (1, 1) => compare_positive(
+                self.numerator as u128,
+                self.denominator as u128,
+                other.numerator as u128,
+                other.denominator as u128,
+            ),
+            (-1, -1) => compare_positive(
+                self.numerator.unsigned_abs(),
+                self.denominator as u128,
+                other.numerator.unsigned_abs(),
+                other.denominator as u128,
+            )
+            .reverse(),
+            _ => unreachable!("i128 signum has only -1, 0, and 1"),
+        }
+    }
+}
+
+impl PartialOrd for ExactRational {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl fmt::Display for ExactRational {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(formatter, "{}/{}", self.numerator, self.denominator)
+    }
+}
+
+impl FromStr for ExactRational {
+    type Err = RusticolError;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        let (numerator, denominator) = value
+            .split_once('/')
+            .ok_or_else(|| invalid("exact rational must use numerator/denominator syntax"))?;
+        if denominator.contains('/') {
+            return Err(invalid(
+                "exact rational must contain exactly one slash separator",
+            ));
+        }
+        Self::parse_parts(numerator, denominator)
+    }
+}
+
+/// Canonical exact complex rational used by recurrence proof coefficients.
+#[derive(
+    Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, bincode::Encode, bincode::Decode,
+)]
+pub struct ExactComplexRational {
+    real: ExactRational,
+    imag: ExactRational,
+}
+
+impl ExactComplexRational {
+    pub const ZERO: Self = Self {
+        real: ExactRational::ZERO,
+        imag: ExactRational::ZERO,
+    };
+    pub const ONE: Self = Self {
+        real: ExactRational::ONE,
+        imag: ExactRational::ZERO,
+    };
+
+    pub const fn new(real: ExactRational, imag: ExactRational) -> Self {
+        Self { real, imag }
+    }
+
+    pub fn parse_parts(
+        real_numerator: &str,
+        real_denominator: &str,
+        imag_numerator: &str,
+        imag_denominator: &str,
+    ) -> RusticolResult<Self> {
+        Ok(Self::new(
+            ExactRational::parse_parts(real_numerator, real_denominator)?,
+            ExactRational::parse_parts(imag_numerator, imag_denominator)?,
+        ))
+    }
+
+    pub const fn real(self) -> ExactRational {
+        self.real
+    }
+
+    pub const fn imag(self) -> ExactRational {
+        self.imag
+    }
+
+    pub const fn is_zero(self) -> bool {
+        self.real.is_zero() && self.imag.is_zero()
+    }
+
+    pub fn checked_neg(self) -> RusticolResult<Self> {
+        Ok(Self::new(
+            self.real.checked_neg()?,
+            self.imag.checked_neg()?,
+        ))
+    }
+
+    pub fn checked_add(self, right: Self) -> RusticolResult<Self> {
+        Ok(Self::new(
+            self.real.checked_add(right.real)?,
+            self.imag.checked_add(right.imag)?,
+        ))
+    }
+
+    pub fn checked_sub(self, right: Self) -> RusticolResult<Self> {
+        Ok(Self::new(
+            self.real.checked_sub(right.real)?,
+            self.imag.checked_sub(right.imag)?,
+        ))
+    }
+
+    pub fn checked_mul(self, right: Self) -> RusticolResult<Self> {
+        let real = self
+            .real
+            .checked_mul(right.real)?
+            .checked_sub(self.imag.checked_mul(right.imag)?)?;
+        let imag = self
+            .real
+            .checked_mul(right.imag)?
+            .checked_add(self.imag.checked_mul(right.real)?)?;
+        Ok(Self::new(real, imag))
+    }
+
+    pub fn checked_div(self, right: Self) -> RusticolResult<Self> {
+        if right.is_zero() {
+            return Err(invalid("exact complex rational division by zero"));
+        }
+        let denominator = right
+            .real
+            .checked_square()?
+            .checked_add(right.imag.checked_square()?)?;
+        let real = self
+            .real
+            .checked_mul(right.real)?
+            .checked_add(self.imag.checked_mul(right.imag)?)?
+            .checked_div(denominator)?;
+        let imag = self
+            .imag
+            .checked_mul(right.real)?
+            .checked_sub(self.real.checked_mul(right.imag)?)?
+            .checked_div(denominator)?;
+        Ok(Self::new(real, imag))
+    }
+
+    pub fn conjugate(self) -> RusticolResult<Self> {
+        Ok(Self::new(self.real, self.imag.checked_neg()?))
+    }
+}
+
+fn parse_signed_decimal(value: &str, field: &str) -> RusticolResult<i128> {
+    if value.is_empty() || value.trim() != value || value.as_bytes().contains(&b'_') {
+        return Err(invalid(format!(
+            "exact rational {field} must be an unseparated decimal integer"
+        )));
+    }
+    let parsed = value.parse::<i128>().map_err(|_| {
+        invalid(format!(
+            "exact rational {field} exceeds the dependency-free exact i128 domain"
+        ))
+    })?;
+    if parsed == i128::MIN {
+        return Err(invalid(format!(
+            "exact rational {field} exceeds the symmetric dependency-free i128 domain"
+        )));
+    }
+    Ok(parsed)
+}
+
+fn parse_positive_decimal(value: &str, field: &str) -> RusticolResult<i128> {
+    if value.starts_with('-') {
+        return Err(invalid(format!("exact rational {field} must be positive")));
+    }
+    let parsed = parse_signed_decimal(value, field)?;
+    if parsed <= 0 {
+        return Err(invalid(format!("exact rational {field} must be positive")));
+    }
+    Ok(parsed)
+}
+
+/// Compare positive fractions without cross multiplication, so ordering stays
+/// exact even when the cross-products exceed i128/u128.
+fn compare_positive(
+    mut left_numerator: u128,
+    mut left_denominator: u128,
+    mut right_numerator: u128,
+    mut right_denominator: u128,
+) -> Ordering {
+    let mut reverse = false;
+    loop {
+        let left_quotient = left_numerator / left_denominator;
+        let right_quotient = right_numerator / right_denominator;
+        let quotient_order = left_quotient.cmp(&right_quotient);
+        if quotient_order != Ordering::Equal {
+            return if reverse {
+                quotient_order.reverse()
+            } else {
+                quotient_order
+            };
+        }
+
+        let left_remainder = left_numerator % left_denominator;
+        let right_remainder = right_numerator % right_denominator;
+        match (left_remainder == 0, right_remainder == 0) {
+            (true, true) => return Ordering::Equal,
+            (true, false) => {
+                return if reverse {
+                    Ordering::Greater
+                } else {
+                    Ordering::Less
+                };
+            }
+            (false, true) => {
+                return if reverse {
+                    Ordering::Less
+                } else {
+                    Ordering::Greater
+                };
+            }
+            (false, false) => {}
+        }
+
+        left_numerator = left_denominator;
+        left_denominator = left_remainder;
+        right_numerator = right_denominator;
+        right_denominator = right_remainder;
+        reverse = !reverse;
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/fermion_ordering.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/fermion_ordering.rs
new file mode 100644
index 0000000000..db49cf59bd
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/fermion_ordering.rs
@@ -0,0 +1,343 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Cold construction-time exterior-algebra signs for external fermions.
+
+use super::ExactComplexRational;
+use super::template::{CurrentOrientation, CurrentStateRow, ParticleStatistics};
+use crate::{RusticolError, RusticolResult};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct FermionOrderingContext {
+    source_requires_exterior_sign: Box<[bool]>,
+    active: bool,
+}
+
+impl FermionOrderingContext {
+    pub(super) fn new(source_requires_exterior_sign: Vec<bool>) -> Self {
+        let active = source_requires_exterior_sign
+            .iter()
+            .copied()
+            .any(|value| value);
+        Self {
+            source_requires_exterior_sign: source_requires_exterior_sign.into_boxed_slice(),
+            active,
+        }
+    }
+
+    fn source_requires_exterior_sign(&self, source_slot: u32) -> RusticolResult<bool> {
+        self.source_requires_exterior_sign
+            .get(source_slot as usize)
+            .copied()
+            .ok_or_else(|| invalid("fermion-ordering source slot is absent"))
+    }
+}
+
+pub(super) fn authenticated_source_requires_exterior_sign(
+    is_fermionic: bool,
+    is_authenticated_colored_endpoint: bool,
+    color_representations: impl IntoIterator<Item = i32>,
+) -> RusticolResult<bool> {
+    if !is_fermionic {
+        if is_authenticated_colored_endpoint {
+            return Err(invalid(
+                "fermion-ordering endpoint authentication selected a bosonic source",
+            ));
+        }
+        return Ok(false);
+    }
+    let mut expected_ownership = None;
+    for color_representation in color_representations {
+        let ownership = match color_representation {
+            1 => true,
+            3 | -3 => false,
+            value => {
+                return Err(invalid(format!(
+                    "external-fermion ordering does not support fermion color representation \
+                     {value}"
+                )));
+            }
+        };
+        if expected_ownership.is_some_and(|expected| expected != ownership) {
+            return Err(invalid(
+                "external-fermion ordering source states have mixed color-sign ownership",
+            ));
+        }
+        expected_ownership = Some(ownership);
+    }
+    let requires_exterior_sign = expected_ownership.ok_or_else(|| {
+        invalid("external-fermion ordering fermion source has no authenticated state")
+    })?;
+    if is_authenticated_colored_endpoint == requires_exterior_sign {
+        return Err(invalid(if is_authenticated_colored_endpoint {
+            "fermion-ordering authenticated colored endpoint has singlet source states"
+        } else {
+            "fermion-ordering fundamental source lacks authenticated endpoint ownership"
+        }));
+    }
+    Ok(requires_exterior_sign)
+}
+
+fn external_support_sign(
+    left_support: &[u32],
+    right_support: &[u32],
+    context: &FermionOrderingContext,
+) -> RusticolResult<i32> {
+    let mut odd = false;
+    for left in left_support.iter().copied() {
+        if !context.source_requires_exterior_sign(left)? {
+            continue;
+        }
+        for right in right_support.iter().copied() {
+            if left > right && context.source_requires_exterior_sign(right)? {
+                odd = !odd;
+            }
+        }
+    }
+    Ok(if odd { -1 } else { 1 })
+}
+
+fn input_orientation_sign(left: CurrentStateRow, right: CurrentStateRow) -> RusticolResult<i32> {
+    let left_statistics = ParticleStatistics::try_from(left.statistics)?;
+    let right_statistics = ParticleStatistics::try_from(right.statistics)?;
+    if left_statistics != ParticleStatistics::Fermion
+        || right_statistics != ParticleStatistics::Fermion
+    {
+        return Ok(1);
+    }
+    let left_requires_exterior_sign = match left.color_representation {
+        1 => true,
+        3 | -3 => false,
+        value => {
+            return Err(invalid(format!(
+                "external-fermion ordering does not support fermion color representation {value}"
+            )));
+        }
+    };
+    let right_requires_exterior_sign = match right.color_representation {
+        1 => true,
+        3 | -3 => false,
+        value => {
+            return Err(invalid(format!(
+                "external-fermion ordering does not support fermion color representation {value}"
+            )));
+        }
+    };
+    if left_requires_exterior_sign != right_requires_exterior_sign {
+        return Err(invalid(
+            "external-fermion ordering encountered mixed color-sign ownership",
+        ));
+    }
+    if !left_requires_exterior_sign {
+        return Ok(1);
+    }
+    let left_orientation = CurrentOrientation::try_from(left.orientation)?;
+    let right_orientation = CurrentOrientation::try_from(right.orientation)?;
+    match (left_orientation, right_orientation) {
+        (CurrentOrientation::Antiparticle, CurrentOrientation::Particle) => Ok(1),
+        (CurrentOrientation::Particle, CurrentOrientation::Antiparticle) => Ok(-1),
+        (CurrentOrientation::SelfConjugate, _) | (_, CurrentOrientation::SelfConjugate) => Err(
+            invalid("external-fermion ordering does not support self-conjugate fermion currents"),
+        ),
+        _ => Err(invalid(
+            "external-fermion ordering requires opposite Dirac orientations",
+        )),
+    }
+}
+
+/// Return the exact sign for one construction-ordered binary current merge.
+pub(super) fn fermion_ordering_factor(
+    current_states: &[CurrentStateRow],
+    parent_state_ids: [u32; 2],
+    parent_supports: [&[u32]; 2],
+    context: &FermionOrderingContext,
+) -> RusticolResult<ExactComplexRational> {
+    if !context.active {
+        return Ok(ExactComplexRational::ONE);
+    }
+    let left_state = current_states
+        .get(parent_state_ids[0] as usize)
+        .copied()
+        .ok_or_else(|| invalid("fermion-ordering left current state is absent"))?;
+    let right_state = current_states
+        .get(parent_state_ids[1] as usize)
+        .copied()
+        .ok_or_else(|| invalid("fermion-ordering right current state is absent"))?;
+    let sign = external_support_sign(parent_supports[0], parent_supports[1], context)?
+        * input_orientation_sign(left_state, right_state)?;
+    match sign {
+        1 => Ok(ExactComplexRational::ONE),
+        -1 => ExactComplexRational::ONE.checked_neg(),
+        _ => unreachable!("the product of two parities is a parity"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn state(
+        id: u32,
+        statistics: ParticleStatistics,
+        orientation: CurrentOrientation,
+        color_representation: i32,
+    ) -> CurrentStateRow {
+        CurrentStateRow {
+            id,
+            template_string_id: id,
+            particle_id: id as i32,
+            anti_particle_id: id as i32,
+            species_string_id: id,
+            orientation: orientation as u8,
+            statistics: statistics as u8,
+            color_representation,
+            basis_string_id: id,
+            tensor_ordering_sequence_id: id,
+            dimension: 1,
+            chirality: 0,
+            lc_color_shape_string_id: id,
+            auxiliary_kind_string_id: u32::MAX,
+            mass_parameter_id: u32::MAX,
+            width_parameter_id: u32::MAX,
+            semantic_digest_id: id,
+        }
+    }
+
+    #[test]
+    fn direct_and_exchanged_dirac_pairings_have_opposite_cached_products() {
+        let anti = state(
+            0,
+            ParticleStatistics::Fermion,
+            CurrentOrientation::Antiparticle,
+            1,
+        );
+        let particle = state(
+            1,
+            ParticleStatistics::Fermion,
+            CurrentOrientation::Particle,
+            1,
+        );
+        let boson = state(
+            2,
+            ParticleStatistics::Boson,
+            CurrentOrientation::SelfConjugate,
+            1,
+        );
+        let states = [anti, particle, boson];
+        let context = FermionOrderingContext::new(vec![true; 4]);
+
+        let direct_first =
+            fermion_ordering_factor(&states, [0, 1], [&[0], &[1]], &context).unwrap();
+        let direct_attach =
+            fermion_ordering_factor(&states, [2, 0], [&[0, 1], &[2]], &context).unwrap();
+        let exchange_first =
+            fermion_ordering_factor(&states, [1, 0], [&[1], &[2]], &context).unwrap();
+        let exchange_attach =
+            fermion_ordering_factor(&states, [0, 2], [&[0], &[1, 2]], &context).unwrap();
+
+        assert_eq!(
+            direct_first.checked_mul(direct_attach).unwrap(),
+            ExactComplexRational::ONE
+        );
+        assert_eq!(
+            exchange_first.checked_mul(exchange_attach).unwrap(),
+            ExactComplexRational::ONE.checked_neg().unwrap()
+        );
+    }
+
+    #[test]
+    fn bosonic_sources_do_not_participate_in_support_parity() {
+        let boson = state(
+            0,
+            ParticleStatistics::Boson,
+            CurrentOrientation::SelfConjugate,
+            1,
+        );
+        let context = FermionOrderingContext::new(vec![true, true, true, false]);
+        let factor = fermion_ordering_factor(&[boson], [0, 0], [&[3], &[0]], &context).unwrap();
+        assert_eq!(factor, ExactComplexRational::ONE);
+    }
+
+    #[test]
+    fn authenticated_source_filter_separates_singlets_from_colored_endpoints() {
+        assert!(authenticated_source_requires_exterior_sign(true, false, [1, 1]).unwrap());
+        assert!(!authenticated_source_requires_exterior_sign(true, true, [3, -3]).unwrap());
+        assert!(!authenticated_source_requires_exterior_sign(false, false, [8]).unwrap());
+    }
+
+    #[test]
+    fn authenticated_source_filter_fails_closed_on_mixed_or_unauthenticated_color() {
+        for error in [
+            authenticated_source_requires_exterior_sign(true, false, [1, 3]).unwrap_err(),
+            authenticated_source_requires_exterior_sign(true, false, [3, 3]).unwrap_err(),
+            authenticated_source_requires_exterior_sign(true, true, [1, 1]).unwrap_err(),
+            authenticated_source_requires_exterior_sign(true, false, [8, 8]).unwrap_err(),
+        ] {
+            assert!(
+                error.to_string().contains("fermion-ordering")
+                    || error.to_string().contains("external-fermion ordering")
+            );
+        }
+    }
+
+    #[test]
+    fn colored_open_line_orientation_is_not_counted_twice() {
+        let anti = state(
+            0,
+            ParticleStatistics::Fermion,
+            CurrentOrientation::Antiparticle,
+            -3,
+        );
+        let particle = state(
+            1,
+            ParticleStatistics::Fermion,
+            CurrentOrientation::Particle,
+            3,
+        );
+        let context = FermionOrderingContext::new(vec![false, false]);
+        let factor =
+            fermion_ordering_factor(&[anti, particle], [1, 0], [&[1], &[0]], &context).unwrap();
+        assert_eq!(factor, ExactComplexRational::ONE);
+    }
+
+    #[test]
+    fn mixed_current_ownership_fails_during_construction() {
+        let singlet = state(
+            0,
+            ParticleStatistics::Fermion,
+            CurrentOrientation::Antiparticle,
+            1,
+        );
+        let colored = state(
+            1,
+            ParticleStatistics::Fermion,
+            CurrentOrientation::Particle,
+            3,
+        );
+        let context = FermionOrderingContext::new(vec![true, false]);
+        let error = fermion_ordering_factor(&[singlet, colored], [0, 1], [&[0], &[1]], &context)
+            .unwrap_err();
+        assert!(error.to_string().contains("mixed color-sign ownership"));
+    }
+
+    #[test]
+    fn same_dirac_orientation_fails_during_construction() {
+        for orientation in [
+            CurrentOrientation::Particle,
+            CurrentOrientation::Antiparticle,
+        ] {
+            let state = state(0, ParticleStatistics::Fermion, orientation, 1);
+            let context = FermionOrderingContext::new(vec![true, true]);
+            let error =
+                fermion_ordering_factor(&[state], [0, 0], [&[0], &[1]], &context).unwrap_err();
+            assert!(
+                error
+                    .to_string()
+                    .contains("requires opposite Dirac orientations")
+            );
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/helicity_support.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/helicity_support.rs
new file mode 100644
index 0000000000..3cd23011e2
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/helicity_support.rs
@@ -0,0 +1,1077 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Exact resolved-helicity support for one physical all-flow recurrence.
+//!
+//! All-flow construction deliberately erases source-helicity ancestry from
+//! current identity.  That makes the semantic graph compact, but executing
+//! every retained row for every resolved helicity loses the principal warm
+//! benefit of the concrete on-the-fly schedules.  This module recovers the
+//! exact row support without rebuilding one graph per helicity:
+//!
+//! 1. enumerate the all-flow source-dispatch Cartesian product;
+//! 2. propagate availability forward, admitting a transition/closure only
+//!    when every dynamic source parent has the selected crossed spin required
+//!    by its authenticated quantum-flow witness; and
+//! 3. propagate demand backwards from physically materialized closure rows.
+//!
+//! The result is semantic and independent of DirectPlan row ordering.  Direct
+//! lowering maps these masks through its deterministic row reordering and
+//! interns the final sidecar domains once.
+
+use std::collections::BTreeMap;
+
+use super::template::{MISSING_U32, ValidatedRecurrenceTemplateInput};
+use super::{
+    CurrentSourceBinding, RecurrenceCurrent, RecurrenceNodeKind, RecurrenceProgram,
+    RecurrenceStrategy,
+};
+use crate::{RusticolError, RusticolResult};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(format!(
+        "recurrence all-flow helicity support: {}",
+        message.into()
+    ))
+}
+
+/// One temporary fixed-width mask over the auxiliary all-flow plan's own
+/// canonical resolved-helicity axis.
+///
+/// These masks intentionally retain equal widths while semantic projection is
+/// in progress.  The direct helicity-dispatch lowering is the sole authority
+/// which compacts and interns the persisted domains.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AllFlowHelicityMask {
+    words: Box<[u64]>,
+}
+
+impl AllFlowHelicityMask {
+    pub fn words(&self) -> &[u64] {
+        &self.words
+    }
+
+    pub fn contains(&self, resolved_helicity_id: u32) -> bool {
+        let word = resolved_helicity_id as usize / u64::BITS as usize;
+        let bit = resolved_helicity_id % u64::BITS;
+        self.words
+            .get(word)
+            .is_some_and(|value| value & (1_u64 << bit) != 0)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.words.iter().all(|word| *word == 0)
+    }
+}
+
+/// Semantic support masks for one physical [`RecurrenceStrategy::AllFlowUnion`]
+/// program.
+///
+/// Table indices are the corresponding dense semantic IDs.  `current_demand`
+/// is the final live-current support after backward projection; for source
+/// currents it is also the exact source-row support.  Contribution masks have
+/// already been intersected with result demand, and finalization masks equal
+/// their owning current's final demand.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AllFlowHelicitySupportProjection {
+    resolved_helicity_count: u32,
+    current_availability: Box<[AllFlowHelicityMask]>,
+    current_demand: Box<[AllFlowHelicityMask]>,
+    contribution_support: Box<[AllFlowHelicityMask]>,
+    finalization_support: Box<[AllFlowHelicityMask]>,
+    closure_support: Box<[AllFlowHelicityMask]>,
+}
+
+impl AllFlowHelicitySupportProjection {
+    pub const fn resolved_helicity_count(&self) -> u32 {
+        self.resolved_helicity_count
+    }
+
+    pub fn current_availability(&self) -> &[AllFlowHelicityMask] {
+        &self.current_availability
+    }
+
+    pub fn current_demand(&self) -> &[AllFlowHelicityMask] {
+        &self.current_demand
+    }
+
+    pub fn contribution_support(&self) -> &[AllFlowHelicityMask] {
+        &self.contribution_support
+    }
+
+    pub fn finalization_support(&self) -> &[AllFlowHelicityMask] {
+        &self.finalization_support
+    }
+
+    pub fn closure_support(&self) -> &[AllFlowHelicityMask] {
+        &self.closure_support
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct SourceChoice {
+    source_state_index: u32,
+    crossed_spin_state_class: i32,
+}
+
+#[derive(Debug)]
+struct SourceAxis {
+    current_id: u32,
+    choices: Vec<SourceChoice>,
+    spin_domains: BTreeMap<i32, Vec<u64>>,
+}
+
+fn zero_mask(word_count: usize) -> Vec<u64> {
+    vec![0; word_count]
+}
+
+fn full_mask(resolved_helicity_count: u32, word_count: usize) -> Vec<u64> {
+    let mut words = vec![u64::MAX; word_count];
+    if let Some(last) = words.last_mut()
+        && !resolved_helicity_count.is_multiple_of(u64::BITS)
+    {
+        *last = (1_u64 << (resolved_helicity_count % u64::BITS)) - 1;
+    }
+    words
+}
+
+fn mask_and_assign(destination: &mut [u64], source: &[u64]) {
+    debug_assert_eq!(destination.len(), source.len());
+    for (destination, source) in destination.iter_mut().zip(source) {
+        *destination &= *source;
+    }
+}
+
+fn mask_or_assign(destination: &mut [u64], source: &[u64]) {
+    debug_assert_eq!(destination.len(), source.len());
+    for (destination, source) in destination.iter_mut().zip(source) {
+        *destination |= *source;
+    }
+}
+
+fn mask_intersection(left: &[u64], right: &[u64]) -> Vec<u64> {
+    debug_assert_eq!(left.len(), right.len());
+    left.iter()
+        .zip(right)
+        .map(|(left, right)| left & right)
+        .collect()
+}
+
+fn boxed_masks(rows: Vec<Vec<u64>>) -> Box<[AllFlowHelicityMask]> {
+    rows.into_iter()
+        .map(|words| AllFlowHelicityMask {
+            words: words.into_boxed_slice(),
+        })
+        .collect::<Vec<_>>()
+        .into_boxed_slice()
+}
+
+fn only_source_slot(current: &RecurrenceCurrent) -> RusticolResult<u32> {
+    match current.key().support_source_slots() {
+        [source_slot] => Ok(*source_slot),
+        _ => Err(invalid(format!(
+            "source current {} does not own exactly one source slot",
+            current.id()
+        ))),
+    }
+}
+
+fn source_axes(program: &RecurrenceProgram) -> RusticolResult<(Vec<SourceAxis>, u32, usize)> {
+    let source_count = program
+        .currents()
+        .iter()
+        .filter(|current| current.is_source())
+        .count();
+    if source_count == 0 {
+        return Err(invalid("all-flow program has no source currents"));
+    }
+    let mut axes = (0..source_count)
+        .map(|_| None)
+        .collect::<Vec<Option<SourceAxis>>>();
+    for current in program
+        .currents()
+        .iter()
+        .filter(|current| current.is_source())
+    {
+        let source_slot = only_source_slot(current)?;
+        let axis = axes.get_mut(source_slot as usize).ok_or_else(|| {
+            invalid(format!(
+                "source current {} uses non-dense source slot {source_slot}",
+                current.id()
+            ))
+        })?;
+        if axis.is_some() {
+            return Err(invalid(format!(
+                "source slot {source_slot} has more than one all-flow dispatch current"
+            )));
+        }
+        let CurrentSourceBinding::RuntimeDispatch {
+            variant_bindings, ..
+        } = current.key().source_binding()
+        else {
+            return Err(invalid(format!(
+                "source current {} has no runtime dispatch binding",
+                current.id()
+            )));
+        };
+        if variant_bindings.is_empty() {
+            return Err(invalid(format!(
+                "source current {} has no runtime source choices",
+                current.id()
+            )));
+        }
+        let mut choices = variant_bindings
+            .iter()
+            .map(|binding| SourceChoice {
+                source_state_index: binding.source_state_index(),
+                crossed_spin_state_class: binding.crossed_spin_state_class(),
+            })
+            .collect::<Vec<_>>();
+        if choices.iter().any(|choice| {
+            choice.crossed_spin_state_class == super::DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS
+        }) {
+            return Err(invalid(format!(
+                "source slot {source_slot} has a non-concrete crossed-spin choice"
+            )));
+        }
+        choices.sort_by_key(|choice| choice.source_state_index);
+        if choices
+            .windows(2)
+            .any(|pair| pair[0].source_state_index == pair[1].source_state_index)
+        {
+            return Err(invalid(format!(
+                "source slot {source_slot} repeats a source-state choice"
+            )));
+        }
+        *axis = Some(SourceAxis {
+            current_id: current.id(),
+            choices,
+            spin_domains: BTreeMap::new(),
+        });
+    }
+    let mut axes = axes
+        .into_iter()
+        .enumerate()
+        .map(|(source_slot, axis)| {
+            axis.ok_or_else(|| invalid(format!("source slot {source_slot} is absent")))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let cartesian_count = axes.iter().try_fold(1_u64, |count, axis| {
+        count
+            .checked_mul(
+                u64::try_from(axis.choices.len())
+                    .map_err(|_| invalid("runtime source-choice count exceeds u64"))?,
+            )
+            .ok_or_else(|| invalid("resolved-helicity Cartesian product exceeds u64"))
+    })?;
+    if cartesian_count != program.retained_helicity_count() {
+        return Err(invalid(format!(
+            "runtime source choices span {cartesian_count} helicities, expected {}",
+            program.retained_helicity_count()
+        )));
+    }
+    let resolved_helicity_count = u32::try_from(cartesian_count)
+        .map_err(|_| invalid("resolved-helicity count exceeds the u32 sidecar domain"))?;
+    let word_count = usize::try_from(resolved_helicity_count.div_ceil(u64::BITS))
+        .map_err(|_| invalid("resolved-helicity mask width exceeds usize"))?;
+
+    for axis in &mut axes {
+        for choice in &axis.choices {
+            axis.spin_domains
+                .entry(choice.crossed_spin_state_class)
+                .or_insert_with(|| zero_mask(word_count));
+        }
+    }
+    let mut indices = vec![0usize; axes.len()];
+    for helicity_id in 0..resolved_helicity_count {
+        for (axis, choice_index) in axes.iter_mut().zip(&indices) {
+            let choice = axis.choices[*choice_index];
+            let words = axis
+                .spin_domains
+                .get_mut(&choice.crossed_spin_state_class)
+                .expect("source spin domain was reserved");
+            words[helicity_id as usize / u64::BITS as usize] |= 1_u64 << (helicity_id % u64::BITS);
+        }
+        for source_slot in (0..indices.len()).rev() {
+            indices[source_slot] += 1;
+            if indices[source_slot] < axes[source_slot].choices.len() {
+                break;
+            }
+            indices[source_slot] = 0;
+        }
+    }
+    Ok((axes, resolved_helicity_count, word_count))
+}
+
+fn template_u32_sequence<'a>(
+    templates: &'a ValidatedRecurrenceTemplateInput,
+    sequence_id: u32,
+    label: &str,
+) -> RusticolResult<&'a [u32]> {
+    let input = templates.input();
+    let range = input
+        .u32_sequence_ranges
+        .get(sequence_id as usize)
+        .filter(|range| range.id == sequence_id)
+        .ok_or_else(|| invalid(format!("{label} sequence {sequence_id} is absent")))?;
+    let range = range
+        .range
+        .as_usize_range(input.u32_sequence_values.len(), label)?;
+    Ok(&input.u32_sequence_values[range])
+}
+
+fn template_i32_sequence<'a>(
+    templates: &'a ValidatedRecurrenceTemplateInput,
+    sequence_id: u32,
+    label: &str,
+) -> RusticolResult<&'a [i32]> {
+    let input = templates.input();
+    let range = input
+        .i32_sequence_ranges
+        .get(sequence_id as usize)
+        .filter(|range| range.id == sequence_id)
+        .ok_or_else(|| invalid(format!("{label} sequence {sequence_id} is absent")))?;
+    let range = range
+        .range
+        .as_usize_range(input.i32_sequence_values.len(), label)?;
+    Ok(&input.i32_sequence_values[range])
+}
+
+fn quantum_flow_contract(
+    templates: &ValidatedRecurrenceTemplateInput,
+    quantum_flow_id: u32,
+) -> RusticolResult<(&[u32], &[i32])> {
+    let flow = templates
+        .input()
+        .quantum_flows
+        .get(quantum_flow_id as usize)
+        .filter(|flow| flow.id == quantum_flow_id)
+        .ok_or_else(|| invalid(format!("quantum flow {quantum_flow_id} is absent")))?;
+    let states = template_u32_sequence(
+        templates,
+        flow.input_state_sequence_id,
+        "quantum-flow input state",
+    )?;
+    let spins = template_i32_sequence(
+        templates,
+        flow.input_spin_sequence_id,
+        "quantum-flow input spin",
+    )?;
+    if states.len() != 2 || spins.len() != 2 {
+        return Err(invalid(format!(
+            "quantum flow {quantum_flow_id} is not binary"
+        )));
+    }
+    Ok((states, spins))
+}
+
+fn construction_parent_orders_for_evaluator_tuple(
+    evaluator_parents: [u32; 2],
+    parent_states: [u32; 2],
+    transition_input_states: [u32; 2],
+    canonical_input_order: [u32; 2],
+    exchange_is_proven: bool,
+) -> Vec<[u32; 2]> {
+    let mut orders = Vec::new();
+    for construction in [
+        evaluator_parents,
+        [evaluator_parents[1], evaluator_parents[0]],
+    ] {
+        let construction_states = construction.map(|parent_id| {
+            if parent_id == evaluator_parents[0] {
+                parent_states[0]
+            } else {
+                parent_states[1]
+            }
+        });
+        if construction_states != transition_input_states {
+            continue;
+        }
+        let mut evaluator = [
+            construction[canonical_input_order[0] as usize],
+            construction[canonical_input_order[1] as usize],
+        ];
+        if exchange_is_proven && evaluator[1] < evaluator[0] {
+            evaluator.swap(0, 1);
+        }
+        if evaluator == evaluator_parents && !orders.contains(&construction) {
+            orders.push(construction);
+        }
+    }
+    orders
+}
+
+fn contribution_construction_parent_orders(
+    program: &RecurrenceProgram,
+    templates: &ValidatedRecurrenceTemplateInput,
+    contribution_id: u32,
+) -> RusticolResult<Vec<[u32; 2]>> {
+    let contribution = program
+        .contributions()
+        .get(contribution_id as usize)
+        .filter(|row| row.id() == contribution_id)
+        .ok_or_else(|| invalid(format!("contribution {contribution_id} is absent")))?;
+    let [first, second] = contribution.parent_current_ids() else {
+        return Err(invalid(format!(
+            "contribution {contribution_id} is not binary"
+        )));
+    };
+    let transition_id = contribution.key().transition_template_id();
+    let transition = templates
+        .input()
+        .transitions
+        .get(transition_id as usize)
+        .filter(|transition| transition.id == transition_id)
+        .ok_or_else(|| invalid(format!("transition {transition_id} is absent")))?;
+    if transition.quantum_flow_template_id != contribution.key().quantum_flow_witness_id() {
+        return Err(invalid(format!(
+            "contribution {contribution_id} quantum-flow witness disagrees with transition {transition_id}"
+        )));
+    }
+    let input_states = template_u32_sequence(
+        templates,
+        transition.input_state_sequence_id,
+        "transition input state",
+    )?;
+    let [left_state, right_state] = input_states else {
+        return Err(invalid(format!("transition {transition_id} is not binary")));
+    };
+    let canonical_input_order = template_u32_sequence(
+        templates,
+        transition.canonical_input_order_sequence_id,
+        "transition canonical input order",
+    )?;
+    let canonical_input_order = match canonical_input_order {
+        [0, 1] => [0, 1],
+        [1, 0] => [1, 0],
+        _ => {
+            return Err(invalid(format!(
+                "transition {transition_id} canonical input order is not binary"
+            )));
+        }
+    };
+    let first_state = program.currents()[*first as usize]
+        .key()
+        .current_state_template_id();
+    let second_state = program.currents()[*second as usize]
+        .key()
+        .current_state_template_id();
+    let orders = construction_parent_orders_for_evaluator_tuple(
+        [*first, *second],
+        [first_state, second_state],
+        [*left_state, *right_state],
+        canonical_input_order,
+        transition.input_exchange_factor_id != MISSING_U32,
+    );
+    if orders.is_empty() {
+        return Err(invalid(format!(
+            "contribution {contribution_id} parents cannot reconstruct transition {transition_id} input order"
+        )));
+    }
+    Ok(orders)
+}
+
+fn flow_gate(
+    program: &RecurrenceProgram,
+    source_axis_by_current: &[Option<usize>],
+    source_axes: &[SourceAxis],
+    parent_ids: [u32; 2],
+    required_states: &[u32],
+    required_spins: &[i32],
+    word_count: usize,
+) -> RusticolResult<Vec<u64>> {
+    let mut gate = vec![u64::MAX; word_count];
+    for (ordinal, parent_id) in parent_ids.into_iter().enumerate() {
+        let parent = program
+            .currents()
+            .get(parent_id as usize)
+            .ok_or_else(|| invalid(format!("flow parent current {parent_id} is absent")))?;
+        if parent.key().current_state_template_id() != required_states[ordinal] {
+            gate.fill(0);
+            return Ok(gate);
+        }
+        if parent.key().node_kind() == RecurrenceNodeKind::Source
+            && parent.key().spin_state_class() == super::DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS
+        {
+            let axis_id = source_axis_by_current
+                .get(parent_id as usize)
+                .copied()
+                .flatten()
+                .ok_or_else(|| invalid(format!("source current {parent_id} has no source axis")))?;
+            let axis = &source_axes[axis_id];
+            if let Some(spin_domain) = axis.spin_domains.get(&required_spins[ordinal]) {
+                mask_and_assign(&mut gate, spin_domain);
+            } else {
+                gate.fill(0);
+            }
+        } else if parent.key().spin_state_class() != required_spins[ordinal] {
+            gate.fill(0);
+            return Ok(gate);
+        }
+    }
+    Ok(gate)
+}
+
+fn parent_availability(
+    parent_ids: &[u32],
+    current_availability: &[Vec<u64>],
+    word_count: usize,
+) -> RusticolResult<Vec<u64>> {
+    let mut availability = vec![u64::MAX; word_count];
+    for parent_id in parent_ids {
+        let parent = current_availability
+            .get(*parent_id as usize)
+            .ok_or_else(|| invalid(format!("parent current {parent_id} is absent")))?;
+        mask_and_assign(&mut availability, parent);
+    }
+    Ok(availability)
+}
+
+fn closure_construction_parent_orders(
+    program: &RecurrenceProgram,
+    closure_id: u32,
+) -> RusticolResult<Vec<[u32; 2]>> {
+    let group = program
+        .closure_proofs()
+        .groups()
+        .iter()
+        .find(|group| group.emitted_runtime_closure_term_id() == Some(closure_id))
+        .ok_or_else(|| invalid(format!("closure term {closure_id} has no proof group")))?;
+    let range = group.contribution_range().as_usize_range(
+        program.closure_proofs().contributions().len(),
+        "closure support proof contribution",
+    )?;
+    let mut orders = Vec::new();
+    for contribution in &program.closure_proofs().contributions()[range] {
+        let [left, right] = contribution.construction_parent_runtime_ids() else {
+            return Err(invalid(format!(
+                "closure term {closure_id} has a non-binary construction proof"
+            )));
+        };
+        let (Some(left), Some(right)) = (*left, *right) else {
+            return Err(invalid(format!(
+                "closure term {closure_id} proof lacks runtime parents"
+            )));
+        };
+        let order = [left, right];
+        if !orders.contains(&order) {
+            orders.push(order);
+        }
+    }
+    if orders.is_empty() {
+        return Err(invalid(format!(
+            "closure term {closure_id} proof group is empty"
+        )));
+    }
+    Ok(orders)
+}
+
+/// Compute exact per-resolved-helicity support for a physical all-flow graph.
+///
+/// This function is deliberately pure and lowering-order independent.  It
+/// performs no topology replay, no numerical evaluation, and no per-sector
+/// recurrence construction.
+pub fn project_all_flow_helicity_support(
+    program: &RecurrenceProgram,
+    templates: &ValidatedRecurrenceTemplateInput,
+) -> RusticolResult<AllFlowHelicitySupportProjection> {
+    if program.strategy() != RecurrenceStrategy::AllFlowUnion {
+        return Err(invalid("projection requires an all-flow-union program"));
+    }
+    if !program.replay_targets().is_empty() || !program.resolved_helicities().is_empty() {
+        return Err(invalid(
+            "physical all-flow support must not use topology replay or fixed-helicity destinations",
+        ));
+    }
+    if program
+        .amplitude_destinations()
+        .iter()
+        .any(|destination| destination.target_helicity_id().is_some())
+    {
+        return Err(invalid(
+            "physical all-flow amplitude destinations must remain helicity-parametric",
+        ));
+    }
+
+    let (source_axes, resolved_helicity_count, word_count) = source_axes(program)?;
+    let all_helicities = full_mask(resolved_helicity_count, word_count);
+    let mut source_axis_by_current = vec![None; program.currents().len()];
+    for (axis_id, axis) in source_axes.iter().enumerate() {
+        source_axis_by_current[axis.current_id as usize] = Some(axis_id);
+    }
+
+    let mut current_availability = vec![zero_mask(word_count); program.currents().len()];
+    let mut contribution_support = vec![zero_mask(word_count); program.contributions().len()];
+    for current in program.currents() {
+        if current.is_source() {
+            current_availability[current.id() as usize].clone_from(&all_helicities);
+            continue;
+        }
+        let range = current.contribution_range().as_usize_range(
+            program.contributions().len(),
+            "current helicity-support contribution",
+        )?;
+        let mut result_availability = zero_mask(word_count);
+        for contribution in &program.contributions()[range] {
+            let construction_parent_orders =
+                contribution_construction_parent_orders(program, templates, contribution.id())?;
+            let (required_states, required_spins) =
+                quantum_flow_contract(templates, contribution.key().quantum_flow_witness_id())?;
+            let mut availability = parent_availability(
+                contribution.parent_current_ids(),
+                &current_availability,
+                word_count,
+            )?;
+            let mut aggregate_gate = zero_mask(word_count);
+            for construction_parents in construction_parent_orders {
+                let gate = flow_gate(
+                    program,
+                    &source_axis_by_current,
+                    &source_axes,
+                    construction_parents,
+                    required_states,
+                    required_spins,
+                    word_count,
+                )?;
+                mask_or_assign(&mut aggregate_gate, &gate);
+            }
+            mask_and_assign(&mut availability, &aggregate_gate);
+            contribution_support[contribution.id() as usize].clone_from(&availability);
+            mask_or_assign(&mut result_availability, &availability);
+        }
+        current_availability[current.id() as usize] = result_availability;
+    }
+
+    let mut closure_support = vec![zero_mask(word_count); program.closure_terms().len()];
+    let mut current_demand = vec![zero_mask(word_count); program.currents().len()];
+    for closure in program.closure_terms() {
+        let mut support = parent_availability(
+            closure.parent_current_ids(),
+            &current_availability,
+            word_count,
+        )?;
+        if let Some(flow_id) = closure.quantum_flow_template_id() {
+            let (required_states, required_spins) = quantum_flow_contract(templates, flow_id)?;
+            let mut aggregate_gate = zero_mask(word_count);
+            for construction_parents in closure_construction_parent_orders(program, closure.id())? {
+                let gate = flow_gate(
+                    program,
+                    &source_axis_by_current,
+                    &source_axes,
+                    construction_parents,
+                    required_states,
+                    required_spins,
+                    word_count,
+                )?;
+                mask_or_assign(&mut aggregate_gate, &gate);
+            }
+            mask_and_assign(&mut support, &aggregate_gate);
+        }
+        closure_support[closure.id() as usize].clone_from(&support);
+        for parent_id in closure.parent_current_ids() {
+            mask_or_assign(&mut current_demand[*parent_id as usize], &support);
+        }
+    }
+
+    // Current IDs are topological, so reverse traversal always propagates
+    // demand to parents which have not yet been finalized.
+    for current in program.currents().iter().rev() {
+        let current_id = current.id() as usize;
+        let live = mask_intersection(
+            &current_demand[current_id],
+            &current_availability[current_id],
+        );
+        current_demand[current_id] = live.clone();
+        if current.is_source() {
+            continue;
+        }
+        let range = current.contribution_range().as_usize_range(
+            program.contributions().len(),
+            "backward helicity-support contribution",
+        )?;
+        for contribution in &program.contributions()[range] {
+            let contribution_id = contribution.id() as usize;
+            let live_contribution =
+                mask_intersection(&contribution_support[contribution_id], &live);
+            contribution_support[contribution_id] = live_contribution.clone();
+            for parent_id in contribution.parent_current_ids() {
+                mask_or_assign(&mut current_demand[*parent_id as usize], &live_contribution);
+            }
+        }
+    }
+
+    let mut finalization_support = vec![zero_mask(word_count); program.finalizations().len()];
+    for finalization in program.finalizations() {
+        finalization_support[finalization.id() as usize]
+            .clone_from(&current_demand[finalization.current_id() as usize]);
+    }
+
+    Ok(AllFlowHelicitySupportProjection {
+        resolved_helicity_count,
+        current_availability: boxed_masks(current_availability),
+        current_demand: boxed_masks(current_demand),
+        contribution_support: boxed_masks(contribution_support),
+        finalization_support: boxed_masks(finalization_support),
+        closure_support: boxed_masks(closure_support),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::layout::RuntimeSourceVariantBinding;
+    use crate::recurrence::{
+        CanonicalMomentumLinearForm, CheckedTableRange, ContributionKey, CurrentCoreKey,
+        CurrentHelicityIdentity, DynamicLCColorState, DynamicLCColorStateId, ExactComplexRational,
+        LCColorWitnessTermId, MomentumTerm, RecurrenceAmplitudeDestination, RecurrenceClosureTerm,
+        RecurrenceContribution, RecurrenceCurrent, RecurrenceFinalization, SemanticDigest,
+    };
+
+    fn digest(seed: u8) -> SemanticDigest {
+        SemanticDigest::new([seed; 32]).unwrap()
+    }
+
+    fn momentum(slots: &[u32]) -> CanonicalMomentumLinearForm {
+        CanonicalMomentumLinearForm::new(
+            slots
+                .iter()
+                .map(|source_slot| MomentumTerm {
+                    source_slot: *source_slot,
+                    coefficient: 1,
+                })
+                .collect(),
+        )
+        .unwrap()
+    }
+
+    fn source_key_with_spins(
+        slot: u32,
+        source_spin_state_class: i32,
+        crossed_spin_state_classes: [i32; 2],
+    ) -> CurrentCoreKey {
+        CurrentCoreKey::new(
+            digest(3),
+            RecurrenceNodeKind::Source,
+            0,
+            DynamicLCColorStateId::from_interner(slot),
+            vec![slot],
+            momentum(&[slot]),
+            CurrentHelicityIdentity::all_flow_union(source_spin_state_class),
+            vec![1],
+            0,
+            vec![],
+            CurrentSourceBinding::runtime_dispatch_with_variants(
+                0,
+                vec![
+                    RuntimeSourceVariantBinding::new(
+                        0,
+                        -1,
+                        0,
+                        0,
+                        0,
+                        0,
+                        crossed_spin_state_classes[0],
+                        ExactComplexRational::ONE,
+                    )
+                    .unwrap(),
+                    RuntimeSourceVariantBinding::new(
+                        1,
+                        1,
+                        1,
+                        0,
+                        0,
+                        0,
+                        crossed_spin_state_classes[1],
+                        ExactComplexRational::ONE,
+                    )
+                    .unwrap(),
+                ],
+            )
+            .unwrap(),
+            None,
+        )
+        .unwrap()
+    }
+
+    fn source_key(slot: u32) -> CurrentCoreKey {
+        source_key_with_spins(
+            slot,
+            super::super::DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS,
+            [0, 1],
+        )
+    }
+
+    fn internal_key(id: u32, slots: &[u32]) -> CurrentCoreKey {
+        CurrentCoreKey::new(
+            digest(3),
+            RecurrenceNodeKind::Current,
+            0,
+            DynamicLCColorStateId::from_interner(id),
+            slots.to_vec(),
+            momentum(slots),
+            CurrentHelicityIdentity::all_flow_union(0),
+            vec![1],
+            0,
+            vec![],
+            CurrentSourceBinding::None,
+            Some(0),
+        )
+        .unwrap()
+    }
+
+    fn contribution(
+        id: u32,
+        result_id: u32,
+        parents: [u32; 2],
+        currents: &[RecurrenceCurrent],
+    ) -> RecurrenceContribution {
+        RecurrenceContribution::new(
+            id,
+            result_id,
+            parents.to_vec(),
+            ContributionKey::new(
+                0,
+                parents.to_vec(),
+                vec![0, 0],
+                parents
+                    .iter()
+                    .map(|parent| currents[*parent as usize].key().momentum().clone())
+                    .collect(),
+                0,
+                0,
+                LCColorWitnessTermId::new(0, 0),
+                digest(6),
+                0,
+            )
+            .unwrap(),
+            ExactComplexRational::ONE,
+        )
+        .unwrap()
+    }
+
+    fn physical_union_program_with_source_keys(
+        source_keys: [CurrentCoreKey; 3],
+    ) -> RecurrenceProgram {
+        let sources = source_keys
+            .into_iter()
+            .enumerate()
+            .map(|(id, key)| {
+                RecurrenceCurrent::new(id as u32, key, None, CheckedTableRange::new(0, 0), None)
+                    .unwrap()
+            })
+            .collect::<Vec<_>>();
+        let mut currents = sources;
+        currents.push(
+            RecurrenceCurrent::new(
+                3,
+                internal_key(3, &[0, 1]),
+                None,
+                CheckedTableRange::new(0, 1),
+                Some(0),
+            )
+            .unwrap(),
+        );
+        currents.push(
+            RecurrenceCurrent::new(
+                4,
+                internal_key(4, &[0, 2]),
+                None,
+                CheckedTableRange::new(1, 1),
+                Some(1),
+            )
+            .unwrap(),
+        );
+        let contributions = vec![
+            contribution(0, 3, [0, 1], &currents),
+            contribution(1, 4, [0, 2], &currents),
+        ];
+        RecurrenceProgram::new(
+            RecurrenceStrategy::AllFlowUnion,
+            1,
+            8,
+            (0..5)
+                .map(|id| DynamicLCColorState::new(id, None, vec![]).unwrap())
+                .collect(),
+            currents,
+            contributions,
+            vec![
+                RecurrenceFinalization::new(0, 3, Some(0), ExactComplexRational::ONE).unwrap(),
+                RecurrenceFinalization::new(1, 4, Some(0), ExactComplexRational::ONE).unwrap(),
+            ],
+            vec![],
+            vec![],
+            vec![
+                RecurrenceAmplitudeDestination::new(0, 0, None, CheckedTableRange::new(0, 1))
+                    .unwrap(),
+            ],
+            vec![
+                RecurrenceClosureTerm::new(0, 0, 0, Some(0), vec![3, 2], ExactComplexRational::ONE)
+                    .unwrap(),
+            ],
+        )
+        .unwrap()
+    }
+
+    fn physical_union_program() -> RecurrenceProgram {
+        physical_union_program_with_source_keys([source_key(0), source_key(1), source_key(2)])
+    }
+
+    fn bits(mask: &AllFlowHelicityMask) -> Vec<u32> {
+        (0..8).filter(|id| mask.contains(*id)).collect()
+    }
+
+    #[test]
+    fn forward_availability_and_backward_demand_prune_exact_helicity_rows() {
+        let templates = super::super::validated_template_fixture();
+        let projection =
+            project_all_flow_helicity_support(&physical_union_program(), &templates).unwrap();
+
+        assert_eq!(projection.resolved_helicity_count(), 8);
+        assert_eq!(bits(&projection.current_availability()[3]), [0, 1]);
+        assert_eq!(bits(&projection.current_availability()[4]), [0, 2]);
+        assert_eq!(bits(&projection.closure_support()[0]), [0]);
+
+        assert_eq!(bits(&projection.current_demand()[0]), [0]);
+        assert_eq!(bits(&projection.current_demand()[1]), [0]);
+        assert_eq!(bits(&projection.current_demand()[2]), [0]);
+        assert_eq!(bits(&projection.current_demand()[3]), [0]);
+        assert!(projection.current_demand()[4].is_empty());
+        assert_eq!(bits(&projection.contribution_support()[0]), [0]);
+        assert!(projection.contribution_support()[1].is_empty());
+        assert_eq!(bits(&projection.finalization_support()[0]), [0]);
+        assert!(projection.finalization_support()[1].is_empty());
+    }
+
+    #[test]
+    fn fixed_and_dynamic_sources_share_exact_transition_and_open_line_support() {
+        let templates = super::super::validated_template_fixture();
+        let program = physical_union_program_with_source_keys([
+            source_key_with_spins(0, 0, [0, 1]),
+            source_key(1),
+            source_key_with_spins(2, 0, [0, 1]),
+        ]);
+        let projection = project_all_flow_helicity_support(&program, &templates).unwrap();
+
+        assert_eq!(projection.resolved_helicity_count(), 8);
+        // Source 0 is a fixed full-state representation even though its
+        // embedded source-evaluator variants retain distinct crossed spins.
+        // Source 1 is dynamically gated by the transition witness, while
+        // source 2 is unconstrained until closure.
+        assert_eq!(bits(&projection.current_availability()[3]), [0, 1, 4, 5]);
+        // Both source parents of this otherwise dead current are fixed.
+        assert_eq!(
+            bits(&projection.current_availability()[4]),
+            (0..8).collect::<Vec<_>>()
+        );
+        // The physical closure owns source 2 directly, exercising the open-line
+        // source-parent path without applying a dynamic mask to its fixed spin.
+        assert_eq!(bits(&projection.closure_support()[0]), [0, 1, 4, 5]);
+        assert_eq!(bits(&projection.current_demand()[0]), [0, 1, 4, 5]);
+        assert_eq!(bits(&projection.current_demand()[1]), [0, 1, 4, 5]);
+        assert_eq!(bits(&projection.current_demand()[2]), [0, 1, 4, 5]);
+        assert_eq!(bits(&projection.current_demand()[3]), [0, 1, 4, 5]);
+        assert!(projection.current_demand()[4].is_empty());
+    }
+
+    #[test]
+    fn source_axis_rejects_a_reserved_dynamic_crossed_spin_choice() {
+        let templates = super::super::validated_template_fixture();
+        let program = physical_union_program_with_source_keys([
+            source_key_with_spins(
+                0,
+                super::super::DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS,
+                [0, super::super::DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS],
+            ),
+            source_key(1),
+            source_key(2),
+        ]);
+        let error = project_all_flow_helicity_support(&program, &templates)
+            .unwrap_err()
+            .to_string();
+        assert!(
+            error.contains("source slot 0 has a non-concrete crossed-spin choice"),
+            "{error}"
+        );
+    }
+
+    #[test]
+    fn equal_state_evaluator_order_is_inverted_before_unequal_spin_gating() {
+        let program = physical_union_program();
+        let (source_axes, resolved_helicity_count, word_count) = source_axes(&program).unwrap();
+        let mut source_axis_by_current = vec![None; program.currents().len()];
+        for (axis_id, axis) in source_axes.iter().enumerate() {
+            source_axis_by_current[axis.current_id as usize] = Some(axis_id);
+        }
+
+        // Construction [0, 1] is persisted as evaluator [1, 0] by a reversed
+        // canonical input order.  Quantum-flow spins remain in construction
+        // order and therefore must not be applied directly to the stored row.
+        let orders =
+            construction_parent_orders_for_evaluator_tuple([1, 0], [0, 0], [0, 0], [1, 0], false);
+        assert_eq!(orders, [[0, 1]]);
+        let gate = flow_gate(
+            &program,
+            &source_axis_by_current,
+            &source_axes,
+            orders[0],
+            &[0, 0],
+            &[0, 1],
+            word_count,
+        )
+        .unwrap();
+        let gate = AllFlowHelicityMask {
+            words: gate.into_boxed_slice(),
+        };
+        assert_eq!(resolved_helicity_count, 8);
+        assert_eq!(bits(&gate), [2, 3]);
+
+        // A certified exchange collapses both reciprocal construction orders
+        // to the same ascending evaluator tuple.  The stored row is live on
+        // the union of both exact spin assignments.
+        let exchange_orders =
+            construction_parent_orders_for_evaluator_tuple([0, 1], [0, 0], [0, 0], [0, 1], true);
+        assert_eq!(exchange_orders, [[0, 1], [1, 0]]);
+        let mut exchange_gate = zero_mask(word_count);
+        for order in exchange_orders {
+            let gate = flow_gate(
+                &program,
+                &source_axis_by_current,
+                &source_axes,
+                order,
+                &[0, 0],
+                &[0, 1],
+                word_count,
+            )
+            .unwrap();
+            mask_or_assign(&mut exchange_gate, &gate);
+        }
+        let exchange_gate = AllFlowHelicityMask {
+            words: exchange_gate.into_boxed_slice(),
+        };
+        assert_eq!(bits(&exchange_gate), [2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn projection_rejects_a_noncanonical_resolved_helicity_axis() {
+        let templates = super::super::validated_template_fixture();
+        let base = physical_union_program();
+        let program = RecurrenceProgram::new(
+            RecurrenceStrategy::AllFlowUnion,
+            base.physical_sector_count(),
+            7,
+            base.dynamic_color_states().to_vec(),
+            base.currents().to_vec(),
+            base.contributions().to_vec(),
+            base.finalizations().to_vec(),
+            vec![],
+            vec![],
+            base.amplitude_destinations().to_vec(),
+            base.closure_terms().to_vec(),
+        )
+        .unwrap();
+        let error = project_all_flow_helicity_support(&program, &templates)
+            .unwrap_err()
+            .to_string();
+        assert!(error.contains("span 8 helicities, expected 7"), "{error}");
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/input.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/input.rs
new file mode 100644
index 0000000000..3310b8057e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/input.rs
@@ -0,0 +1,473 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::ops::Range;
+
+use sha2::{Digest, Sha256};
+
+use super::{
+    RECURRENCE_BUILDER_INPUT_ABI, RECURRENCE_BUILDER_RESULT_ABI,
+    RECURRENCE_CONTRACTED_COLOR_CAPABILITY, RECURRENCE_INPUT_ENDIANNESS,
+    RECURRENCE_LC_COLOR_CAPABILITY, RECURRENCE_PLAN_ABI, RECURRENCE_RUNTIME_CAPABILITY,
+    RECURRENCE_RUNTIME_KIND, RECURRENCE_RUNTIME_LAYOUT_ABI, RECURRENCE_TEMPLATE_ABI,
+    RecurrenceStrategy, SemanticDigest,
+};
+use crate::{RusticolError, RusticolResult};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+/// Checked offset/count pair used by all flat recurrence catalogs.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct CheckedTableRange {
+    pub start: u64,
+    pub count: u64,
+}
+
+impl CheckedTableRange {
+    pub const fn new(start: u64, count: u64) -> Self {
+        Self { start, count }
+    }
+
+    pub fn end(self, label: &str) -> RusticolResult<u64> {
+        self.start.checked_add(self.count).ok_or_else(|| {
+            invalid(format!(
+                "{label} range start {} plus count {} exceeds u64",
+                self.start, self.count
+            ))
+        })
+    }
+
+    pub fn as_usize_range(self, value_len: usize, label: &str) -> RusticolResult<Range<usize>> {
+        let end = self.end(label)?;
+        let start = checked_usize(self.start, label)?;
+        let end = checked_usize(end, label)?;
+        if end > value_len {
+            return Err(invalid(format!(
+                "{label} range {}..{} exceeds table length {value_len}",
+                self.start,
+                self.start + self.count
+            )));
+        }
+        Ok(start..end)
+    }
+}
+
+/// Borrowed canonical multiword-mask catalog.
+///
+/// Words are little-endian by significance.  Zero is encoded as an empty
+/// range and nonzero masks must not contain a trailing zero word.
+#[derive(Clone, Copy, Debug)]
+pub struct MultiwordMaskCatalogView<'a> {
+    pub ranges: &'a [CheckedTableRange],
+    pub populations: &'a [u64],
+    pub words: &'a [u64],
+}
+
+impl<'a> MultiwordMaskCatalogView<'a> {
+    pub fn validate(self, require_strict_order: bool) -> RusticolResult<()> {
+        validate_equal_column_lengths(
+            "multiword mask catalog",
+            &[
+                ("ranges", self.ranges.len()),
+                ("populations", self.populations.len()),
+            ],
+        )?;
+        validate_packed_ranges("multiword mask", self.ranges, self.words.len())?;
+
+        let mut previous: Option<&[u64]> = None;
+        for (index, (range, expected_population)) in self
+            .ranges
+            .iter()
+            .copied()
+            .zip(self.populations.iter().copied())
+            .enumerate()
+        {
+            let words = &self.words
+                [range.as_usize_range(self.words.len(), &format!("multiword mask {index}"))?];
+            if words.last() == Some(&0) {
+                return Err(invalid(format!(
+                    "multiword mask {index} has a noncanonical trailing zero word"
+                )));
+            }
+            let population = words.iter().try_fold(0_u64, |total, word| {
+                total
+                    .checked_add(u64::from(word.count_ones()))
+                    .ok_or_else(|| invalid("multiword mask population exceeds u64"))
+            })?;
+            if population != expected_population {
+                return Err(invalid(format!(
+                    "multiword mask {index} declares population {expected_population}, found {population}"
+                )));
+            }
+            if require_strict_order
+                && let Some(previous) = previous
+                && compare_masks(previous, words) != std::cmp::Ordering::Less
+            {
+                return Err(invalid(format!(
+                    "multiword mask catalog is not in strict canonical order at row {index}"
+                )));
+            }
+            previous = Some(words);
+        }
+        Ok(())
+    }
+
+    pub fn words(self, mask_id: u32) -> RusticolResult<&'a [u64]> {
+        let row = self.ranges.get(mask_id as usize).ok_or_else(|| {
+            invalid(format!(
+                "multiword mask id {mask_id} exceeds catalog length {}",
+                self.ranges.len()
+            ))
+        })?;
+        let range = row.as_usize_range(self.words.len(), "multiword mask")?;
+        Ok(&self.words[range])
+    }
+
+    pub fn contains(self, mask_id: u32, bit: u64) -> RusticolResult<bool> {
+        let words = self.words(mask_id)?;
+        let word_index = checked_usize(bit / 64, "multiword mask bit index")?;
+        Ok(words
+            .get(word_index)
+            .is_some_and(|word| word & (1_u64 << (bit % 64)) != 0))
+    }
+}
+
+/// A named, fixed-row-width little-endian builder-input section.
+#[derive(Clone, Copy, Debug)]
+pub struct CanonicalInputSection<'a> {
+    pub name: &'a str,
+    pub row_width: u32,
+    pub row_count: u64,
+    pub bytes: &'a [u8],
+}
+
+impl CanonicalInputSection<'_> {
+    pub fn validate(self) -> RusticolResult<()> {
+        validate_section_name(self.name)?;
+        if self.row_width == 0 {
+            return Err(invalid(format!(
+                "recurrence input section {:?} has zero row width",
+                self.name
+            )));
+        }
+        let expected = u64::from(self.row_width)
+            .checked_mul(self.row_count)
+            .ok_or_else(|| {
+                invalid(format!(
+                    "recurrence input section {:?} byte count exceeds u64",
+                    self.name
+                ))
+            })?;
+        let actual = checked_u64_len(self.bytes.len(), self.name)?;
+        if actual != expected {
+            return Err(invalid(format!(
+                "recurrence input section {:?} expects {expected} bytes, found {actual}",
+                self.name
+            )));
+        }
+        Ok(())
+    }
+}
+
+/// Deterministic header for `pyamplicol-recurrence-builder-input-v2`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceBuilderInputHeader {
+    pub template_abi: String,
+    pub builder_input_abi: String,
+    pub builder_result_abi: String,
+    pub plan_abi: String,
+    pub runtime_layout_abi: String,
+    pub runtime_kind: String,
+    pub runtime_capability: String,
+    pub color_capability: String,
+    pub endianness: String,
+    pub strategy: RecurrenceStrategy,
+    pub section_count: u32,
+    pub template_catalog_digest: SemanticDigest,
+    pub process_digest: SemanticDigest,
+    pub semantic_digest: SemanticDigest,
+    pub input_digest: SemanticDigest,
+}
+
+impl RecurrenceBuilderInputHeader {
+    pub fn canonical(
+        strategy: RecurrenceStrategy,
+        section_count: u32,
+        template_catalog_digest: SemanticDigest,
+        process_digest: SemanticDigest,
+        semantic_digest: SemanticDigest,
+        input_digest: SemanticDigest,
+    ) -> Self {
+        Self {
+            template_abi: RECURRENCE_TEMPLATE_ABI.to_owned(),
+            builder_input_abi: RECURRENCE_BUILDER_INPUT_ABI.to_owned(),
+            builder_result_abi: RECURRENCE_BUILDER_RESULT_ABI.to_owned(),
+            plan_abi: RECURRENCE_PLAN_ABI.to_owned(),
+            runtime_layout_abi: RECURRENCE_RUNTIME_LAYOUT_ABI.to_owned(),
+            runtime_kind: RECURRENCE_RUNTIME_KIND.to_owned(),
+            runtime_capability: RECURRENCE_RUNTIME_CAPABILITY.to_owned(),
+            color_capability: match strategy {
+                RecurrenceStrategy::ContractedColorUnion => RECURRENCE_CONTRACTED_COLOR_CAPABILITY,
+                RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::AllFlowUnion => {
+                    RECURRENCE_LC_COLOR_CAPABILITY
+                }
+            }
+            .to_owned(),
+            endianness: RECURRENCE_INPUT_ENDIANNESS.to_owned(),
+            strategy,
+            section_count,
+            template_catalog_digest,
+            process_digest,
+            semantic_digest,
+            input_digest,
+        }
+    }
+
+    pub fn validate_identity(&self) -> RusticolResult<()> {
+        validate_constant("template ABI", &self.template_abi, RECURRENCE_TEMPLATE_ABI)?;
+        validate_constant(
+            "builder input ABI",
+            &self.builder_input_abi,
+            RECURRENCE_BUILDER_INPUT_ABI,
+        )?;
+        validate_constant(
+            "builder result ABI",
+            &self.builder_result_abi,
+            RECURRENCE_BUILDER_RESULT_ABI,
+        )?;
+        validate_constant("plan ABI", &self.plan_abi, RECURRENCE_PLAN_ABI)?;
+        validate_constant(
+            "runtime layout ABI",
+            &self.runtime_layout_abi,
+            RECURRENCE_RUNTIME_LAYOUT_ABI,
+        )?;
+        validate_constant("runtime kind", &self.runtime_kind, RECURRENCE_RUNTIME_KIND)?;
+        validate_constant(
+            "runtime capability",
+            &self.runtime_capability,
+            RECURRENCE_RUNTIME_CAPABILITY,
+        )?;
+        let expected_color_capability = match self.strategy {
+            RecurrenceStrategy::ContractedColorUnion => RECURRENCE_CONTRACTED_COLOR_CAPABILITY,
+            RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::AllFlowUnion => {
+                RECURRENCE_LC_COLOR_CAPABILITY
+            }
+        };
+        validate_constant(
+            "color capability",
+            &self.color_capability,
+            expected_color_capability,
+        )?;
+        validate_constant(
+            "input endianness",
+            &self.endianness,
+            RECURRENCE_INPUT_ENDIANNESS,
+        )?;
+        Ok(())
+    }
+}
+
+pub fn checked_u32_len(length: usize, label: &str) -> RusticolResult<u32> {
+    u32::try_from(length).map_err(|_| invalid(format!("{label} length {length} exceeds u32")))
+}
+
+pub fn checked_u64_len(length: usize, label: &str) -> RusticolResult<u64> {
+    u64::try_from(length).map_err(|_| invalid(format!("{label} length {length} exceeds u64")))
+}
+
+pub fn checked_usize(value: u64, label: &str) -> RusticolResult<usize> {
+    usize::try_from(value).map_err(|_| invalid(format!("{label} value {value} exceeds usize")))
+}
+
+pub fn validate_equal_column_lengths(
+    table: &str,
+    columns: &[(&str, usize)],
+) -> RusticolResult<usize> {
+    let Some((first_name, expected)) = columns.first().copied() else {
+        return Err(invalid(format!("{table} has no columns")));
+    };
+    checked_u32_len(expected, &format!("{table}.{first_name}"))?;
+    for (name, length) in columns.iter().copied().skip(1) {
+        checked_u32_len(length, &format!("{table}.{name}"))?;
+        if length != expected {
+            return Err(invalid(format!(
+                "{table} column {name:?} has length {length}, expected {expected} from {first_name:?}"
+            )));
+        }
+    }
+    Ok(expected)
+}
+
+pub fn validate_u32_references(
+    values: &[u32],
+    target_len: usize,
+    label: &str,
+) -> RusticolResult<()> {
+    checked_u32_len(target_len, &format!("{label} target"))?;
+    for (row, value) in values.iter().copied().enumerate() {
+        let value_index = usize::try_from(value).map_err(|_| {
+            invalid(format!(
+                "{label} row {row} id {value} exceeds usize on this platform"
+            ))
+        })?;
+        if value_index >= target_len {
+            return Err(invalid(format!(
+                "{label} row {row} references id {value}, target length is {target_len}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+pub fn validate_ranges_within(
+    label: &str,
+    ranges: &[CheckedTableRange],
+    value_len: usize,
+) -> RusticolResult<()> {
+    checked_u32_len(ranges.len(), &format!("{label} ranges"))?;
+    for (index, range) in ranges.iter().copied().enumerate() {
+        range.as_usize_range(value_len, &format!("{label} {index}"))?;
+    }
+    Ok(())
+}
+
+pub fn validate_packed_ranges(
+    label: &str,
+    ranges: &[CheckedTableRange],
+    value_len: usize,
+) -> RusticolResult<()> {
+    validate_ranges_within(label, ranges, value_len)?;
+    let mut expected_start = 0_u64;
+    for (index, range) in ranges.iter().copied().enumerate() {
+        if range.start != expected_start {
+            return Err(invalid(format!(
+                "{label} range {index} starts at {}, expected packed offset {expected_start}",
+                range.start
+            )));
+        }
+        expected_start = range.end(&format!("{label} {index}"))?;
+    }
+    if checked_usize(expected_start, label)? != value_len {
+        return Err(invalid(format!(
+            "{label} packed ranges cover {expected_start} values, table contains {value_len}"
+        )));
+    }
+    Ok(())
+}
+
+pub fn canonical_input_digest(
+    header: &RecurrenceBuilderInputHeader,
+    sections: &[CanonicalInputSection<'_>],
+) -> RusticolResult<SemanticDigest> {
+    header.validate_identity()?;
+    validate_sections(sections)?;
+    let actual_section_count = checked_u32_len(sections.len(), "recurrence input sections")?;
+    if header.section_count != actual_section_count {
+        return Err(invalid(format!(
+            "recurrence input header declares {} sections, found {actual_section_count}",
+            header.section_count
+        )));
+    }
+    let mut digest = Sha256::new();
+    digest_field(&mut digest, RECURRENCE_BUILDER_INPUT_ABI.as_bytes())?;
+    digest_field(&mut digest, RECURRENCE_TEMPLATE_ABI.as_bytes())?;
+    digest_field(&mut digest, RECURRENCE_PLAN_ABI.as_bytes())?;
+    digest_field(&mut digest, RECURRENCE_RUNTIME_LAYOUT_ABI.as_bytes())?;
+    digest.update(header.strategy.as_u32().to_le_bytes());
+    digest.update(header.section_count.to_le_bytes());
+    digest.update(header.template_catalog_digest.as_bytes());
+    digest.update(header.process_digest.as_bytes());
+    digest.update(header.semantic_digest.as_bytes());
+    for section in sections {
+        digest_field(&mut digest, section.name.as_bytes())?;
+        digest.update(section.row_width.to_le_bytes());
+        digest.update(section.row_count.to_le_bytes());
+        digest_field(&mut digest, section.bytes)?;
+    }
+    SemanticDigest::new(digest.finalize().into())
+}
+
+pub fn validate_header_and_sections(
+    header: &RecurrenceBuilderInputHeader,
+    sections: &[CanonicalInputSection<'_>],
+) -> RusticolResult<()> {
+    header.validate_identity()?;
+    let actual_count = checked_u32_len(sections.len(), "recurrence input sections")?;
+    if header.section_count != actual_count {
+        return Err(invalid(format!(
+            "recurrence input header declares {} sections, found {actual_count}",
+            header.section_count
+        )));
+    }
+    let actual = canonical_input_digest(header, sections)?;
+    if actual != header.input_digest {
+        return Err(invalid(format!(
+            "recurrence input digest mismatch: expected {}, found {}",
+            header.input_digest, actual
+        )));
+    }
+    Ok(())
+}
+
+fn validate_sections(sections: &[CanonicalInputSection<'_>]) -> RusticolResult<()> {
+    checked_u32_len(sections.len(), "recurrence input sections")?;
+    let mut previous = None;
+    for section in sections {
+        section.validate()?;
+        if let Some(previous) = previous
+            && previous >= section.name
+        {
+            return Err(invalid(format!(
+                "recurrence input sections are not in strict canonical name order at {:?}",
+                section.name
+            )));
+        }
+        previous = Some(section.name);
+    }
+    Ok(())
+}
+
+fn validate_section_name(name: &str) -> RusticolResult<()> {
+    if name.is_empty()
+        || name.len() > 255
+        || !name.bytes().all(|byte| {
+            byte.is_ascii_lowercase()
+                || byte.is_ascii_digit()
+                || matches!(byte, b'_' | b'-' | b'.' | b'/')
+        })
+        || name.starts_with('/')
+        || name.ends_with('/')
+        || name.contains("//")
+        || name
+            .split('/')
+            .any(|component| component == "." || component == "..")
+    {
+        return Err(invalid(format!(
+            "invalid recurrence input section name {name:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_constant(label: &str, value: &str, expected: &str) -> RusticolResult<()> {
+    if value != expected {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported recurrence {label} {value:?}; expected {expected:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn digest_field(digest: &mut Sha256, bytes: &[u8]) -> RusticolResult<()> {
+    let length = checked_u64_len(bytes.len(), "recurrence digest field")?;
+    digest.update(length.to_le_bytes());
+    digest.update(bytes);
+    Ok(())
+}
+
+fn compare_masks(left: &[u64], right: &[u64]) -> std::cmp::Ordering {
+    left.len()
+        .cmp(&right.len())
+        .then_with(|| left.iter().rev().cmp(right.iter().rev()))
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/layout.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/layout.rs
new file mode 100644
index 0000000000..105b237eef
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/layout.rs
@@ -0,0 +1,765 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::fmt;
+
+use super::ExactComplexRational;
+use crate::{RusticolError, RusticolResult};
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+/// A nonzero SHA-256 semantic digest.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, bincode::Encode)]
+pub struct SemanticDigest([u8; 32]);
+
+impl<Context> bincode::Decode<Context> for SemanticDigest {
+    fn decode<D: bincode::de::Decoder<Context = Context>>(
+        decoder: &mut D,
+    ) -> Result<Self, bincode::error::DecodeError> {
+        Self::new(bincode::Decode::decode(decoder)?)
+            .map_err(|error| bincode::error::DecodeError::OtherString(error.to_string()))
+    }
+}
+
+bincode::impl_borrow_decode!(SemanticDigest);
+
+impl SemanticDigest {
+    pub fn new(bytes: [u8; 32]) -> RusticolResult<Self> {
+        if bytes == [0; 32] {
+            return Err(invalid("semantic digest must not be all zero"));
+        }
+        Ok(Self(bytes))
+    }
+
+    pub const fn as_bytes(&self) -> &[u8; 32] {
+        &self.0
+    }
+}
+
+impl fmt::Display for SemanticDigest {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for byte in self.0 {
+            write!(formatter, "{byte:02x}")?;
+        }
+        Ok(())
+    }
+}
+
+/// Workload-specific recurrence schedule strategy.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(u32)]
+pub enum RecurrenceStrategy {
+    TopologyReplay = 0,
+    AllFlowUnion = 1,
+    ContractedColorUnion = 2,
+}
+
+impl RecurrenceStrategy {
+    pub const fn as_u32(self) -> u32 {
+        self as u32
+    }
+
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::TopologyReplay => "topology-replay",
+            Self::AllFlowUnion => "all-flow-union",
+            Self::ContractedColorUnion => "contracted-color-union",
+        }
+    }
+
+    pub const fn uses_runtime_source_dispatch(self) -> bool {
+        matches!(self, Self::AllFlowUnion)
+    }
+
+    pub const fn retains_local_source_ancestry(self) -> bool {
+        !self.uses_runtime_source_dispatch()
+    }
+
+    pub const fn materializes_all_color_sectors(self) -> bool {
+        !matches!(self, Self::TopologyReplay)
+    }
+
+    pub const fn uses_topology_replay_targets(self) -> bool {
+        matches!(self, Self::TopologyReplay | Self::ContractedColorUnion)
+    }
+}
+
+impl TryFrom<u32> for RecurrenceStrategy {
+    type Error = RusticolError;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::TopologyReplay),
+            1 => Ok(Self::AllFlowUnion),
+            2 => Ok(Self::ContractedColorUnion),
+            _ => Err(invalid(format!(
+                "unknown recurrence strategy discriminant {value}"
+            ))),
+        }
+    }
+}
+
+impl fmt::Display for RecurrenceStrategy {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(self.as_str())
+    }
+}
+
+/// Semantic kind of recurrence state.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(u32)]
+pub enum RecurrenceNodeKind {
+    Source = 0,
+    Current = 1,
+}
+
+/// Identifier issued only by the dynamic LC color-state interner.
+///
+/// This newtype prevents physical sector IDs from accidentally becoming
+/// recurrence current identity.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct DynamicLCColorStateId(u32);
+
+impl DynamicLCColorStateId {
+    pub(crate) const fn from_interner(value: u32) -> Self {
+        Self(value)
+    }
+
+    pub const fn get(self) -> u32 {
+        self.0
+    }
+}
+
+/// One exact term of one prepared LC color-transition witness.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct LCColorWitnessTermId {
+    color_contraction_template_id: u32,
+    witness_ordinal: u32,
+}
+
+impl LCColorWitnessTermId {
+    pub const fn new(color_contraction_template_id: u32, witness_ordinal: u32) -> Self {
+        Self {
+            color_contraction_template_id,
+            witness_ordinal,
+        }
+    }
+
+    pub const fn color_contraction_template_id(self) -> u32 {
+        self.color_contraction_template_id
+    }
+
+    pub const fn witness_ordinal(self) -> u32 {
+        self.witness_ordinal
+    }
+}
+
+/// One source-state choice in a topology-replay current's local ancestry.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct SourceStateAssignment {
+    source_slot: u32,
+    state_index: u32,
+}
+
+impl SourceStateAssignment {
+    pub const fn new(source_slot: u32, state_index: u32) -> Self {
+        Self {
+            source_slot,
+            state_index,
+        }
+    }
+
+    pub const fn source_slot(self) -> u32 {
+        self.source_slot
+    }
+
+    pub const fn state_index(self) -> u32 {
+        self.state_index
+    }
+}
+
+/// Layout-specific helicity identity of one recurrence current.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum CurrentHelicityIdentity {
+    /// Static spin class plus one retained source state for every local source.
+    TopologyReplay {
+        spin_state_class: i32,
+        local_source_states: Box<[SourceStateAssignment]>,
+    },
+    /// Static transition spin class with source helicities selected at runtime.
+    AllFlowUnion { spin_state_class: i32 },
+    /// Static spin class and local source ancestry across the complete color basis.
+    ContractedColorUnion {
+        spin_state_class: i32,
+        local_source_states: Box<[SourceStateAssignment]>,
+    },
+}
+
+impl CurrentHelicityIdentity {
+    pub fn topology_replay(
+        spin_state_class: i32,
+        local_source_states: Vec<SourceStateAssignment>,
+    ) -> RusticolResult<Self> {
+        validate_sequence_len("local source-state ancestry", local_source_states.len())?;
+        let source_slots = local_source_states
+            .iter()
+            .map(|assignment| assignment.source_slot)
+            .collect::<Vec<_>>();
+        validate_strict_u32_sequence("local source-state ancestry", &source_slots)?;
+        Ok(Self::TopologyReplay {
+            spin_state_class,
+            local_source_states: local_source_states.into_boxed_slice(),
+        })
+    }
+
+    pub const fn all_flow_union(spin_state_class: i32) -> Self {
+        Self::AllFlowUnion { spin_state_class }
+    }
+
+    pub fn contracted_color_union(
+        spin_state_class: i32,
+        local_source_states: Vec<SourceStateAssignment>,
+    ) -> RusticolResult<Self> {
+        validate_sequence_len("local source-state ancestry", local_source_states.len())?;
+        let source_slots = local_source_states
+            .iter()
+            .map(|assignment| assignment.source_slot)
+            .collect::<Vec<_>>();
+        validate_strict_u32_sequence("local source-state ancestry", &source_slots)?;
+        Ok(Self::ContractedColorUnion {
+            spin_state_class,
+            local_source_states: local_source_states.into_boxed_slice(),
+        })
+    }
+
+    pub const fn strategy(&self) -> RecurrenceStrategy {
+        match self {
+            Self::TopologyReplay { .. } => RecurrenceStrategy::TopologyReplay,
+            Self::AllFlowUnion { .. } => RecurrenceStrategy::AllFlowUnion,
+            Self::ContractedColorUnion { .. } => RecurrenceStrategy::ContractedColorUnion,
+        }
+    }
+
+    pub const fn spin_state_class(&self) -> i32 {
+        match self {
+            Self::TopologyReplay {
+                spin_state_class, ..
+            }
+            | Self::AllFlowUnion { spin_state_class }
+            | Self::ContractedColorUnion {
+                spin_state_class, ..
+            } => *spin_state_class,
+        }
+    }
+
+    pub fn local_source_states(&self) -> &[SourceStateAssignment] {
+        match self {
+            Self::TopologyReplay {
+                local_source_states,
+                ..
+            } => local_source_states,
+            Self::AllFlowUnion { .. } => &[],
+            Self::ContractedColorUnion {
+                local_source_states,
+                ..
+            } => local_source_states,
+        }
+    }
+}
+
+/// One process-bound runtime source variant for an all-flow-union source.
+///
+/// The complete variant catalog belongs to the source dispatch domain. No
+/// selected numerical helicity enters the current identity.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct RuntimeSourceVariantBinding {
+    source_state_index: u32,
+    public_helicity: i32,
+    runtime_variant_id: u32,
+    source_template_id: u32,
+    source_state_template_id: u32,
+    crossed_state_template_id: u32,
+    crossed_spin_state_class: i32,
+    crossing_factor: ExactComplexRational,
+}
+
+impl RuntimeSourceVariantBinding {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        source_state_index: u32,
+        public_helicity: i32,
+        runtime_variant_id: u32,
+        source_template_id: u32,
+        source_state_template_id: u32,
+        crossed_state_template_id: u32,
+        crossed_spin_state_class: i32,
+        crossing_factor: ExactComplexRational,
+    ) -> RusticolResult<Self> {
+        if runtime_variant_id == u32::MAX
+            || source_template_id == u32::MAX
+            || source_state_template_id == u32::MAX
+            || crossed_state_template_id == u32::MAX
+        {
+            return Err(invalid(
+                "runtime source variant reserves the u32 missing-value sentinel",
+            ));
+        }
+        if crossing_factor.is_zero() {
+            return Err(invalid(
+                "runtime source variant requires a nonzero crossing factor",
+            ));
+        }
+        Ok(Self {
+            source_state_index,
+            public_helicity,
+            runtime_variant_id,
+            source_template_id,
+            source_state_template_id,
+            crossed_state_template_id,
+            crossed_spin_state_class,
+            crossing_factor,
+        })
+    }
+
+    pub const fn source_state_index(self) -> u32 {
+        self.source_state_index
+    }
+
+    pub const fn public_helicity(self) -> i32 {
+        self.public_helicity
+    }
+
+    pub const fn runtime_variant_id(self) -> u32 {
+        self.runtime_variant_id
+    }
+
+    pub const fn source_template_id(self) -> u32 {
+        self.source_template_id
+    }
+
+    pub const fn source_state_template_id(self) -> u32 {
+        self.source_state_template_id
+    }
+
+    pub const fn crossed_state_template_id(self) -> u32 {
+        self.crossed_state_template_id
+    }
+
+    pub const fn crossed_spin_state_class(self) -> i32 {
+        self.crossed_spin_state_class
+    }
+
+    pub const fn crossing_factor(self) -> ExactComplexRational {
+        self.crossing_factor
+    }
+}
+
+/// Source semantics referenced by a recurrence key.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum CurrentSourceBinding {
+    None,
+    FixedTemplate(u32),
+    RuntimeDispatch {
+        domain: u32,
+        source_template_ids: Box<[u32]>,
+        variant_bindings: Box<[RuntimeSourceVariantBinding]>,
+    },
+}
+
+impl CurrentSourceBinding {
+    pub fn runtime_dispatch(domain: u32, source_template_ids: Vec<u32>) -> RusticolResult<Self> {
+        validate_sequence_len(
+            "runtime source-template variants",
+            source_template_ids.len(),
+        )?;
+        validate_strict_u32_sequence("runtime source-template variants", &source_template_ids)?;
+        if source_template_ids.contains(&u32::MAX) {
+            return Err(invalid(
+                "runtime source-template variants reserve the u32 sentinel",
+            ));
+        }
+        Ok(Self::RuntimeDispatch {
+            domain,
+            source_template_ids: source_template_ids.into_boxed_slice(),
+            variant_bindings: Box::new([]),
+        })
+    }
+
+    pub fn runtime_dispatch_with_variants(
+        domain: u32,
+        variants: Vec<RuntimeSourceVariantBinding>,
+    ) -> RusticolResult<Self> {
+        if domain == u32::MAX {
+            return Err(invalid(
+                "runtime source-dispatch domain reserves the u32 sentinel",
+            ));
+        }
+        validate_sequence_len("runtime source variants", variants.len())?;
+        if variants.is_empty() {
+            return Err(invalid(
+                "runtime source-dispatch domain requires concrete variants",
+            ));
+        }
+        let state_indices = variants
+            .iter()
+            .map(|variant| variant.source_state_index)
+            .collect::<Vec<_>>();
+        validate_strict_u32_sequence("runtime source-state variants", &state_indices)?;
+        let mut runtime_variant_ids = variants
+            .iter()
+            .map(|variant| variant.runtime_variant_id)
+            .collect::<Vec<_>>();
+        runtime_variant_ids.sort_unstable();
+        validate_strict_u32_sequence("runtime-helicity variant IDs", &runtime_variant_ids)?;
+        let mut source_template_ids = variants
+            .iter()
+            .map(|variant| variant.source_template_id)
+            .collect::<Vec<_>>();
+        source_template_ids.sort_unstable();
+        source_template_ids.dedup();
+        validate_strict_u32_sequence("runtime source-template variants", &source_template_ids)?;
+        Ok(Self::RuntimeDispatch {
+            domain,
+            source_template_ids: source_template_ids.into_boxed_slice(),
+            variant_bindings: variants.into_boxed_slice(),
+        })
+    }
+}
+
+impl TryFrom<u32> for RecurrenceNodeKind {
+    type Error = RusticolError;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Source),
+            1 => Ok(Self::Current),
+            _ => Err(invalid(format!(
+                "unknown recurrence node-kind discriminant {value}"
+            ))),
+        }
+    }
+}
+
+/// One canonical term in a momentum linear form.
+#[derive(
+    Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, bincode::Encode, bincode::Decode,
+)]
+pub struct MomentumTerm {
+    pub source_slot: u32,
+    pub coefficient: i32,
+}
+
+/// Canonical source-slot-ordered momentum linear form.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, bincode::Encode)]
+pub struct CanonicalMomentumLinearForm(Box<[MomentumTerm]>);
+
+impl<Context> bincode::Decode<Context> for CanonicalMomentumLinearForm {
+    fn decode<D: bincode::de::Decoder<Context = Context>>(
+        decoder: &mut D,
+    ) -> Result<Self, bincode::error::DecodeError> {
+        Self::new(bincode::Decode::decode(decoder)?)
+            .map_err(|error| bincode::error::DecodeError::OtherString(error.to_string()))
+    }
+}
+
+bincode::impl_borrow_decode!(CanonicalMomentumLinearForm);
+
+impl CanonicalMomentumLinearForm {
+    pub fn new(terms: Vec<MomentumTerm>) -> RusticolResult<Self> {
+        validate_sequence_len("momentum terms", terms.len())?;
+        let mut previous = None;
+        for (index, term) in terms.iter().enumerate() {
+            if term.coefficient == 0 {
+                return Err(invalid(format!(
+                    "momentum term {index} has zero coefficient"
+                )));
+            }
+            if let Some(previous) = previous
+                && previous >= term.source_slot
+            {
+                return Err(invalid(format!(
+                    "momentum terms are not strictly source-slot ordered at row {index}"
+                )));
+            }
+            previous = Some(term.source_slot);
+        }
+        Ok(Self(terms.into_boxed_slice()))
+    }
+
+    pub fn terms(&self) -> &[MomentumTerm] {
+        &self.0
+    }
+}
+
+/// Exact semantic identity before contribution-vector comparison.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct CurrentCoreKey {
+    catalog_digest: SemanticDigest,
+    node_kind: RecurrenceNodeKind,
+    current_state_template_id: u32,
+    dynamic_lc_color_state_id: DynamicLCColorStateId,
+    support_source_slots: Box<[u32]>,
+    momentum: CanonicalMomentumLinearForm,
+    helicity_identity: CurrentHelicityIdentity,
+    flavour_flow: Box<[i32]>,
+    quantum_number_flow_id: u32,
+    coupling_orders: Box<[u32]>,
+    source_binding: CurrentSourceBinding,
+    propagator_template_id: Option<u32>,
+}
+
+impl CurrentCoreKey {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        catalog_digest: SemanticDigest,
+        node_kind: RecurrenceNodeKind,
+        current_state_template_id: u32,
+        dynamic_lc_color_state_id: DynamicLCColorStateId,
+        support_source_slots: Vec<u32>,
+        momentum: CanonicalMomentumLinearForm,
+        helicity_identity: CurrentHelicityIdentity,
+        flavour_flow: Vec<i32>,
+        quantum_number_flow_id: u32,
+        coupling_orders: Vec<u32>,
+        source_binding: CurrentSourceBinding,
+        propagator_template_id: Option<u32>,
+    ) -> RusticolResult<Self> {
+        validate_sequence_len("support source slots", support_source_slots.len())?;
+        validate_sequence_len("flavour flow", flavour_flow.len())?;
+        validate_sequence_len("coupling orders", coupling_orders.len())?;
+        validate_strict_u32_sequence("support source slots", &support_source_slots)?;
+        let ancestry_slots = helicity_identity
+            .local_source_states()
+            .iter()
+            .map(|assignment| assignment.source_slot)
+            .collect::<Vec<_>>();
+        if helicity_identity.strategy().retains_local_source_ancestry()
+            && ancestry_slots != support_source_slots
+        {
+            return Err(invalid(
+                "topology-replay helicity ancestry must cover every local source slot",
+            ));
+        }
+        match (node_kind, helicity_identity.strategy(), &source_binding) {
+            (
+                RecurrenceNodeKind::Source,
+                RecurrenceStrategy::TopologyReplay,
+                CurrentSourceBinding::FixedTemplate(_),
+            )
+            | (
+                RecurrenceNodeKind::Source,
+                RecurrenceStrategy::ContractedColorUnion,
+                CurrentSourceBinding::FixedTemplate(_),
+            )
+            | (
+                RecurrenceNodeKind::Source,
+                RecurrenceStrategy::AllFlowUnion,
+                CurrentSourceBinding::RuntimeDispatch { .. },
+            )
+            | (RecurrenceNodeKind::Current, _, CurrentSourceBinding::None) => {}
+            (RecurrenceNodeKind::Source, RecurrenceStrategy::TopologyReplay, _) => {
+                return Err(invalid(
+                    "topology-replay source requires one fixed source template",
+                ));
+            }
+            (RecurrenceNodeKind::Source, RecurrenceStrategy::ContractedColorUnion, _) => {
+                return Err(invalid(
+                    "contracted-color-union source requires one fixed source template",
+                ));
+            }
+            (RecurrenceNodeKind::Source, RecurrenceStrategy::AllFlowUnion, _) => {
+                return Err(invalid(
+                    "all-flow-union source requires a runtime dispatch domain",
+                ));
+            }
+            (RecurrenceNodeKind::Current, _, _) => {
+                return Err(invalid(
+                    "non-source recurrence key must not carry source binding state",
+                ));
+            }
+        }
+        if node_kind == RecurrenceNodeKind::Source && support_source_slots.len() != 1 {
+            return Err(invalid(
+                "source recurrence key must cover exactly one external source slot",
+            ));
+        }
+        Ok(Self {
+            catalog_digest,
+            node_kind,
+            current_state_template_id,
+            dynamic_lc_color_state_id,
+            support_source_slots: support_source_slots.into_boxed_slice(),
+            momentum,
+            helicity_identity,
+            flavour_flow: flavour_flow.into_boxed_slice(),
+            quantum_number_flow_id,
+            coupling_orders: coupling_orders.into_boxed_slice(),
+            source_binding,
+            propagator_template_id,
+        })
+    }
+
+    pub const fn catalog_digest(&self) -> SemanticDigest {
+        self.catalog_digest
+    }
+
+    pub const fn node_kind(&self) -> RecurrenceNodeKind {
+        self.node_kind
+    }
+
+    pub const fn current_state_template_id(&self) -> u32 {
+        self.current_state_template_id
+    }
+
+    pub const fn dynamic_lc_color_state_id(&self) -> DynamicLCColorStateId {
+        self.dynamic_lc_color_state_id
+    }
+
+    pub fn support_source_slots(&self) -> &[u32] {
+        &self.support_source_slots
+    }
+
+    pub const fn momentum(&self) -> &CanonicalMomentumLinearForm {
+        &self.momentum
+    }
+
+    pub const fn helicity_identity(&self) -> &CurrentHelicityIdentity {
+        &self.helicity_identity
+    }
+
+    pub const fn spin_state_class(&self) -> i32 {
+        self.helicity_identity.spin_state_class()
+    }
+
+    pub fn flavour_flow(&self) -> &[i32] {
+        &self.flavour_flow
+    }
+
+    pub const fn quantum_number_flow_id(&self) -> u32 {
+        self.quantum_number_flow_id
+    }
+
+    pub fn coupling_orders(&self) -> &[u32] {
+        &self.coupling_orders
+    }
+
+    pub const fn source_binding(&self) -> &CurrentSourceBinding {
+        &self.source_binding
+    }
+
+    pub const fn propagator_template_id(&self) -> Option<u32> {
+        self.propagator_template_id
+    }
+}
+
+/// Exact identity of one contribution before coefficient aggregation.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ContributionKey {
+    transition_template_id: u32,
+    parent_value_class_ids: Box<[u32]>,
+    parent_state_template_ids: Box<[u32]>,
+    parent_momenta: Box<[CanonicalMomentumLinearForm]>,
+    result_state_template_id: u32,
+    quantum_flow_witness_id: u32,
+    color_witness_term_id: LCColorWitnessTermId,
+    runtime_coupling_binding_digest: SemanticDigest,
+    output_projection_id: u32,
+}
+
+impl ContributionKey {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        transition_template_id: u32,
+        parent_value_class_ids: Vec<u32>,
+        parent_state_template_ids: Vec<u32>,
+        parent_momenta: Vec<CanonicalMomentumLinearForm>,
+        result_state_template_id: u32,
+        quantum_flow_witness_id: u32,
+        color_witness_term_id: LCColorWitnessTermId,
+        runtime_coupling_binding_digest: SemanticDigest,
+        output_projection_id: u32,
+    ) -> RusticolResult<Self> {
+        let parent_count = parent_value_class_ids.len();
+        if parent_count == 0 {
+            return Err(invalid(
+                "recurrence contribution requires at least one parent",
+            ));
+        }
+        if parent_state_template_ids.len() != parent_count || parent_momenta.len() != parent_count {
+            return Err(invalid(format!(
+                "recurrence contribution parent columns have lengths {parent_count}, {}, and {}",
+                parent_state_template_ids.len(),
+                parent_momenta.len()
+            )));
+        }
+        u32::try_from(parent_count)
+            .map_err(|_| invalid("recurrence contribution parent count exceeds u32"))?;
+        Ok(Self {
+            transition_template_id,
+            parent_value_class_ids: parent_value_class_ids.into_boxed_slice(),
+            parent_state_template_ids: parent_state_template_ids.into_boxed_slice(),
+            parent_momenta: parent_momenta.into_boxed_slice(),
+            result_state_template_id,
+            quantum_flow_witness_id,
+            color_witness_term_id,
+            runtime_coupling_binding_digest,
+            output_projection_id,
+        })
+    }
+
+    pub const fn transition_template_id(&self) -> u32 {
+        self.transition_template_id
+    }
+
+    pub fn parent_value_class_ids(&self) -> &[u32] {
+        &self.parent_value_class_ids
+    }
+
+    pub fn parent_state_template_ids(&self) -> &[u32] {
+        &self.parent_state_template_ids
+    }
+
+    pub fn parent_momenta(&self) -> &[CanonicalMomentumLinearForm] {
+        &self.parent_momenta
+    }
+
+    pub const fn result_state_template_id(&self) -> u32 {
+        self.result_state_template_id
+    }
+
+    pub const fn quantum_flow_witness_id(&self) -> u32 {
+        self.quantum_flow_witness_id
+    }
+
+    pub const fn color_witness_term_id(&self) -> LCColorWitnessTermId {
+        self.color_witness_term_id
+    }
+
+    pub const fn runtime_coupling_binding_digest(&self) -> SemanticDigest {
+        self.runtime_coupling_binding_digest
+    }
+
+    pub const fn output_projection_id(&self) -> u32 {
+        self.output_projection_id
+    }
+}
+
+fn validate_strict_u32_sequence(label: &str, values: &[u32]) -> RusticolResult<()> {
+    let mut previous = None;
+    for (index, value) in values.iter().copied().enumerate() {
+        if let Some(previous) = previous
+            && previous >= value
+        {
+            return Err(invalid(format!(
+                "{label} are not strictly ordered at row {index}"
+            )));
+        }
+        previous = Some(value);
+    }
+    Ok(())
+}
+
+fn validate_sequence_len(label: &str, length: usize) -> RusticolResult<u32> {
+    u32::try_from(length).map_err(|_| invalid(format!("{label} length {length} exceeds u32")))
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/mod.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/mod.rs
new file mode 100644
index 0000000000..3fbb3c1e3e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/mod.rs
@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Model-generic compact recurrence construction and execution.
+
+mod arena;
+mod builder;
+mod color;
+mod color_contraction;
+mod construct;
+mod contact_orbit_owner;
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+mod diagnostic;
+pub mod direct_backend;
+mod direct_codec;
+mod direct_helicity_dispatch;
+mod direct_lowering;
+mod direct_pacbin;
+mod direct_plan;
+pub mod direct_runtime;
+mod exact;
+mod fermion_ordering;
+mod helicity_support;
+mod input;
+mod layout;
+pub(crate) mod on_the_fly;
+pub mod process;
+mod program;
+mod relation;
+mod symmetric_group_fft;
+pub mod template;
+pub(crate) mod template_json;
+
+pub use arena::{
+    DirectArenaAssignment, DirectArenaInterval, DirectArenaLayout, assign_direct_arena,
+    recurrence_direct_arena_layout,
+};
+pub use builder::AuthenticatedRecurrenceBuilderInput;
+pub use color::{
+    DynamicLCColorState, DynamicLCColorStateInterner, LCColorComponent, LCColorComponentKind,
+    LCColorComponentOperation, LCColorComponentRole, LCColorEndpoint, LCColorParentPort,
+    LCColorPortBinding, LCColorPortWiring, LCColorSourceSeed, LCColorSourceSeedOperation,
+    LCColorTransitionWitness,
+};
+pub(crate) use color_contraction::RuntimeSymmetricGroupColorWorkspace;
+pub use color_contraction::{
+    CanonicalColorContractionEntries, CanonicalColorContractionEntry, FactorizedColorContraction,
+    FactorizedColorContractionKind, RECURRENCE_COLOR_CONTRACTION_CODEC_ABI,
+    RawColorContractionEntry, RecurrenceColorAccuracy, RecurrenceColorContraction,
+    RecurrenceColorStorage, RuntimeColorContractionEntries, RuntimeColorContractionEntry,
+    RuntimeColorContractionReducer, RuntimeFactorizedColorContraction,
+    RuntimeFactorizedColorContractionEntry, RuntimeSymmetricGroupColorContraction,
+    RuntimeSymmetricGroupKernel, decode_recurrence_color_contraction_v3,
+    recurrence_color_contraction_digest,
+};
+pub use construct::RecurrenceBuildProgress;
+#[doc(hidden)]
+pub use construct::RecurrenceGenerationTelemetry;
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+#[doc(hidden)]
+pub use diagnostic::ConstructionTransitionDiagnosticRowV1;
+pub use direct_codec::{decode_recurrence_direct_plan_v2, encode_recurrence_direct_plan_v2};
+pub use direct_helicity_dispatch::{
+    DirectHelicityDispatch, DirectHelicityDispatchDescriptor, DirectHelicityDispatchParts,
+    DirectHelicityRowGroupDescriptor, DirectHelicitySupportDomainDescriptor,
+    RECURRENCE_HELICITY_DISPATCH_ABI, RecurrenceHelicityDispatchMetadata,
+    decode_recurrence_helicity_dispatch_v1, encode_recurrence_helicity_dispatch_v1,
+    write_recurrence_helicity_dispatch_v1_atomic,
+};
+#[cfg(test)]
+pub(crate) use direct_lowering::validated_template_fixture;
+pub use direct_lowering::{
+    DirectRecurrenceRuntimeOptions, PreparedDirectExecutorBinding, PreparedDirectExecutorCatalog,
+    PreparedDirectExecutorKey, lower_recurrence_direct_plan_v2,
+    lower_recurrence_direct_plan_v2_with_helicity_dispatch,
+    lower_recurrence_direct_plan_v2_with_relation_discovery, lower_recurrence_direct_v2,
+};
+pub(crate) use direct_pacbin::validate_recurrence_color_projection_certificate;
+pub use direct_pacbin::{
+    RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER, RECURRENCE_DIRECT_SCHEDULE_MEMBER,
+    RecurrenceDirectPacbinMetadata, load_recurrence_direct_plan_pacbin,
+    write_recurrence_direct_plan_pacbin,
+    write_recurrence_direct_plan_pacbin_with_projection_certificate,
+};
+pub(crate) use direct_plan::DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION;
+#[cfg(test)]
+pub(crate) use direct_plan::tests::{
+    valid_parts as valid_direct_plan_parts_fixture, valid_plan as valid_direct_plan_fixture,
+};
+pub use direct_plan::{
+    DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE, DIRECT_NONE_U32,
+    DirectAmplitudeDestinationDescriptor, DirectClosureRow, DirectContributionRow,
+    DirectCurrentDescriptor, DirectDestinationOperation, DirectExecutorRole, DirectFinalizationRow,
+    DirectMomentumFormDescriptor, DirectMomentumTerm, DirectNodeKind, DirectRecurrencePlan,
+    DirectRecurrencePlanParts, DirectReplayTargetDescriptor, DirectResolvedHelicityDescriptor,
+    DirectResolvedSourceSelection, DirectRowGroupDescriptor, DirectSelectorDomainDescriptor,
+    DirectSelectorWorkSummary, DirectSourceDispatchVariantDescriptor, DirectSourceEmbeddingRow,
+    DirectSourceProjectionRow, DirectSourceRow, DirectSourceStateAssignment,
+    RECURRENCE_DIRECT_PLAN_ABI, RECURRENCE_DIRECT_RUNTIME_CAPABILITY,
+    RECURRENCE_DIRECT_RUNTIME_LAYOUT_ABI, RECURRENCE_DIRECT_TEMPLATE_ABI,
+};
+pub use exact::{ExactComplexRational, ExactRational};
+pub use helicity_support::{
+    AllFlowHelicityMask, AllFlowHelicitySupportProjection, project_all_flow_helicity_support,
+};
+pub use input::{
+    CanonicalInputSection, CheckedTableRange, MultiwordMaskCatalogView,
+    RecurrenceBuilderInputHeader, canonical_input_digest, checked_u32_len, checked_u64_len,
+    checked_usize, validate_equal_column_lengths, validate_header_and_sections,
+    validate_packed_ranges, validate_ranges_within, validate_u32_references,
+};
+pub use layout::{
+    CanonicalMomentumLinearForm, ContributionKey, CurrentCoreKey, CurrentHelicityIdentity,
+    CurrentSourceBinding, DynamicLCColorStateId, LCColorWitnessTermId, MomentumTerm,
+    RecurrenceNodeKind, RecurrenceStrategy, SemanticDigest, SourceStateAssignment,
+};
+#[cfg(feature = "on-the-fly-test-support")]
+#[doc(hidden)]
+pub use on_the_fly::{
+    OnTheFlyQueryFamilyCensusV1, OnTheFlyTestSupportReportV1, on_the_fly_query_family_census_v1,
+    on_the_fly_test_support_probe_v1,
+};
+pub use program::{
+    CLOSURE_TARGET_DOMAIN_PROOF_KIND, ClosureCandidateDomainCertificateV1,
+    ClosureExecutionProofGroupV2, ClosureProofContributionV2, ClosureProofMetadataV2,
+    ClosureTargetDomainCertificateV1, RecurrenceAmplitudeDestination, RecurrenceClosureTerm,
+    RecurrenceContribution, RecurrenceCurrent, RecurrenceFinalization, RecurrenceProgram,
+    RecurrenceReplayTarget, RecurrenceResolvedHelicity, ReflectionCertificateV1,
+    ThreeLineTraversalCertificateV1, ThreeLineTraversalKindV1, closure_component_factor_digest_v2,
+    closure_proof_semantic_completeness_digest_v2,
+    closure_proof_semantic_completeness_digest_with_three_line_v2,
+    closure_selector_domain_digest_v2, three_line_traversal_proof_digest_v1,
+};
+pub use relation::{
+    NUMERICAL_RELATION_CERTIFICATE_ALGORITHM, RecurrenceCurrentRelationCertificate,
+    RecurrenceNumericalCurrentMapping, RecurrenceNumericalRelationEvidence,
+    RecurrenceRelationDiscoveryMode, RecurrenceRelationDiscoveryOptions,
+    RecurrenceRelationDiscoveryReport, authenticate_recurrence_numerical_relation_provenance,
+    recurrence_numerical_source_semantics_sha256, relation_certificate_algorithm,
+};
+pub use symmetric_group_fft::{
+    MAX_SYMMETRIC_GROUP_FFT_DEGREE, SymmetricGroupComplex64, SymmetricGroupFftBlock,
+    SymmetricGroupFftPlan, SymmetricGroupFftWorkspace,
+};
+/// Semantic prepared-model companion ABI.
+pub const RECURRENCE_TEMPLATE_ABI: &str = "pyamplicol-recurrence-template-v1";
+/// Python-to-Rust recurrence builder input ABI.
+pub const RECURRENCE_BUILDER_INPUT_ABI: &str = "pyamplicol-recurrence-builder-input-v2";
+/// Bounded Rust-to-Python recurrence builder result ABI.
+pub const RECURRENCE_BUILDER_RESULT_ABI: &str = "pyamplicol-recurrence-builder-result-v2";
+/// Direct-arena recurrence plan ABI.
+pub const RECURRENCE_PLAN_ABI: &str = RECURRENCE_DIRECT_PLAN_ABI;
+/// Direct-arena native recurrence layout ABI.
+pub const RECURRENCE_RUNTIME_LAYOUT_ABI: &str = RECURRENCE_DIRECT_RUNTIME_LAYOUT_ABI;
+/// Process runtime kind stored in execution metadata.
+pub const RECURRENCE_RUNTIME_KIND: &str = "pyamplicol-runtime-recurrence-execution";
+/// Native complex-f64 recurrence capability.
+pub const RECURRENCE_RUNTIME_CAPABILITY: &str = RECURRENCE_DIRECT_RUNTIME_CAPABILITY;
+/// LC color capability required by recurrence.
+pub const RECURRENCE_LC_COLOR_CAPABILITY: &str = "rusticol.recurrence-color.lc.v1";
+/// Contracted NLC/full-color capability required by recurrence.
+pub const RECURRENCE_CONTRACTED_COLOR_CAPABILITY: &str = "rusticol.recurrence-color.contracted.v1";
+/// The builder input always consists of explicitly little-endian columns.
+pub const RECURRENCE_INPUT_ENDIANNESS: &str = "little";
+
+/// Internal all-flow source marker; authenticated model/process inputs must
+/// never carry this value as an ordinary concrete spin state.
+pub(super) const DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS: i32 = i32::MIN;
+
+fn validate_concrete_spin_state(value: i32, context: &str) -> crate::RusticolResult<()> {
+    if value == DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS {
+        return Err(crate::RusticolError::invalid_argument(format!(
+            "{context} uses the reserved dynamic-union source-spin sentinel"
+        )));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod direct_backend_tests;
+#[cfg(test)]
+mod tests;
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/coupling_policy.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/coupling_policy.rs
new file mode 100644
index 0000000000..c4d36cfb84
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/coupling_policy.rs
@@ -0,0 +1,999 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Selector-independent resolution of the process coupling-order policy.
+//!
+//! The public minimal policy is process-global.  Resolving it from one chosen
+//! helicity or colour selector can accidentally promote a higher-order branch
+//! when the true leading-order amplitude vanishes only for that selector.  The
+//! cold sweep below therefore erases public helicity labels while retaining
+//! every structural contract that controls reachability: source support,
+//! current state and spin, flavour/quantum ancestry, exact LC colour state,
+//! and fermion-pairing lineage.  It never constructs a public colour-flow
+//! table, a recurrence DAG, or executable contributions.
+
+use std::collections::BTreeMap;
+
+use super::*;
+use crate::recurrence::contact_orbit_owner::ContactOrbitParentTopologyDomain;
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, bincode::Encode, bincode::Decode)]
+pub(crate) struct OnTheFlyCouplingPolicyCensusV1 {
+    pub(crate) source_topology_count: u64,
+    pub(crate) retained_topology_count: u64,
+    pub(crate) transition_witness_attempt_count: u64,
+    pub(crate) closure_witness_attempt_count: u64,
+    pub(crate) viable_total_order_count: u64,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, bincode::Encode, bincode::Decode)]
+pub(crate) struct OnTheFlyResolvedCouplingPolicyV1 {
+    seed_digest: SemanticDigest,
+    effective_limits: Box<[Option<u32>]>,
+    census: OnTheFlyCouplingPolicyCensusV1,
+}
+
+impl OnTheFlyResolvedCouplingPolicyV1 {
+    pub(crate) const fn seed_digest(&self) -> SemanticDigest {
+        self.seed_digest
+    }
+
+    pub(crate) fn effective_limits(&self) -> &[Option<u32>] {
+        &self.effective_limits
+    }
+
+    #[allow(dead_code)] // Retained for the feature-only structural census API.
+    pub(crate) const fn census(&self) -> OnTheFlyCouplingPolicyCensusV1 {
+        self.census
+    }
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct GlobalTopologyKey {
+    support: Box<[u32]>,
+    current_state_template_id: u32,
+    spin_state: i32,
+    flavour_flow: Box<[i32]>,
+    quantum_number_flow_id: u32,
+    color: DynamicLCColorState,
+    pairing_lineage: PendingPairingLineage,
+}
+
+#[derive(Clone, Debug)]
+struct GlobalTopologyNode {
+    key: GlobalTopologyKey,
+    /// Componentwise Pareto-minimal order vectors reaching this exact state.
+    orders: Vec<Box<[u32]>>,
+}
+
+/// Index the structural condition on parent sizes before inspecting their
+/// exact colour states. Many states share one support size, and scanning all
+/// pairs of those states only to reject their sizes makes the cold sweep
+/// unnecessarily quadratic in its largest, already-complete currents.
+struct SupportSizePairIndex {
+    by_size: BTreeMap<usize, Vec<usize>>,
+}
+
+impl SupportSizePairIndex {
+    fn new(sizes: impl IntoIterator<Item = usize>) -> Self {
+        let mut by_size = BTreeMap::<usize, Vec<usize>>::new();
+        for (index, size) in sizes.into_iter().enumerate() {
+            by_size.entry(size).or_default().push(index);
+        }
+        Self { by_size }
+    }
+
+    fn partners_after(&self, left_index: usize, left_size: usize, total_size: usize) -> &[usize] {
+        let Some(right_size) = total_size.checked_sub(left_size) else {
+            return &[];
+        };
+        let Some(indices) = self.by_size.get(&right_size) else {
+            return &[];
+        };
+        // Stable insertion order preserves the original left-major,
+        // increasing-right enumeration, including equal-size parent pairs.
+        &indices[indices.partition_point(|&index| index <= left_index)..]
+    }
+}
+
+fn checked_increment(value: &mut u64, label: &str) -> RusticolResult<()> {
+    *value = value
+        .checked_add(1)
+        .ok_or_else(|| invalid(format!("{label} exceeds u64")))?;
+    Ok(())
+}
+
+fn weakly_dominates(left: &[u32], right: &[u32]) -> bool {
+    left.len() == right.len()
+        && left
+            .iter()
+            .zip(right.iter())
+            .all(|(left, right)| left <= right)
+}
+
+fn insert_pareto_order(orders: &mut Vec<Box<[u32]>>, candidate: Vec<u32>) -> bool {
+    if orders
+        .iter()
+        .any(|existing| weakly_dominates(existing, &candidate))
+    {
+        return false;
+    }
+    orders.retain(|existing| !weakly_dominates(&candidate, existing));
+    orders.push(candidate.into_boxed_slice());
+    orders.sort_unstable();
+    true
+}
+
+fn insert_topology_order(
+    nodes: &mut Vec<GlobalTopologyNode>,
+    node_ids: &mut BTreeMap<GlobalTopologyKey, usize>,
+    key: GlobalTopologyKey,
+    orders: Vec<u32>,
+) -> RusticolResult<()> {
+    if let Some(id) = node_ids.get(&key).copied() {
+        insert_pareto_order(&mut nodes[id].orders, orders);
+        return Ok(());
+    }
+    let id = nodes.len();
+    nodes
+        .try_reserve(1)
+        .map_err(|error| invalid(format!("global topology allocation failed: {error}")))?;
+    let mut retained_orders = Vec::new();
+    retained_orders
+        .try_reserve_exact(1)
+        .map_err(|error| invalid(format!("global coupling-order allocation failed: {error}")))?;
+    retained_orders.push(orders.into_boxed_slice());
+    node_ids.insert(key.clone(), id);
+    nodes.push(GlobalTopologyNode {
+        key,
+        orders: retained_orders,
+    });
+    Ok(())
+}
+
+fn ordered_transition_parents<'a>(
+    prepared: &PreparedTransition,
+    left: &'a GlobalTopologyKey,
+    right: &'a GlobalTopologyKey,
+) -> Option<[&'a GlobalTopologyKey; 2]> {
+    prepared
+        .parent_ids(
+            left.current_state_template_id,
+            right.current_state_template_id,
+            0,
+            1,
+        )
+        .map(|ids| {
+            let parents = [left, right];
+            [parents[ids[0] as usize], parents[ids[1] as usize]]
+        })
+}
+
+fn ordered_closure_parents<'a>(
+    prepared: &PreparedClosure,
+    left: &'a GlobalTopologyKey,
+    right: &'a GlobalTopologyKey,
+) -> Option<[&'a GlobalTopologyKey; 2]> {
+    prepared
+        .parent_ids(
+            left.current_state_template_id,
+            right.current_state_template_id,
+            0,
+            1,
+        )
+        .map(|ids| {
+            let parents = [left, right];
+            [parents[ids[0] as usize], parents[ids[1] as usize]]
+        })
+}
+
+fn topology_quantum_matches(
+    states: [u32; 2],
+    spins: [i32; 2],
+    parents: [&GlobalTopologyKey; 2],
+) -> bool {
+    (0..2).all(|index| {
+        states[index] == parents[index].current_state_template_id
+            && spins[index] == parents[index].spin_state
+    })
+}
+
+fn contact_orbit_topology_domain(
+    parent: &GlobalTopologyKey,
+) -> ContactOrbitParentTopologyDomain<'_> {
+    if parent.support.len() == 1 {
+        ContactOrbitParentTopologyDomain::source(parent.current_state_template_id, &parent.support)
+    } else {
+        ContactOrbitParentTopologyDomain::current(parent.current_state_template_id, &parent.support)
+    }
+}
+
+fn closure_quantum_matches_topology(
+    quantum: &PreparedClosureQuantum,
+    parents: [&GlobalTopologyKey; 2],
+) -> bool {
+    match (quantum.input_states, quantum.input_spins) {
+        (None, None) => true,
+        (Some(states), Some(spins)) => topology_quantum_matches(states, spins, parents),
+        _ => false,
+    }
+}
+
+fn insert_all_sources(
+    seed: &OnTheFlyProcessSeedV1,
+    grammar: &PreparedOnTheFlyGrammarV1,
+    nodes: &mut Vec<GlobalTopologyNode>,
+    node_ids: &mut BTreeMap<GlobalTopologyKey, usize>,
+) -> RusticolResult<u64> {
+    let zero_orders = vec![0_u32; seed.explicit_coupling_limits().len()];
+    let mut source_topology_count = 0_u64;
+    for anchor in &seed.source_anchors {
+        for state in &anchor.states {
+            let contract = grammar
+                .sources
+                .get(&(state.source_template_id, state.current_state_template_id))
+                .ok_or_else(|| integrity("global source has no prepared source contract"))?;
+            let color = contract.color_seed.instantiate(
+                anchor.source_slot,
+                contract.current_state.color_representation,
+            )?;
+            let key = GlobalTopologyKey {
+                support: vec![anchor.source_slot].into_boxed_slice(),
+                current_state_template_id: state.current_state_template_id,
+                spin_state: state.spin_state,
+                flavour_flow: state.flavour_flow.clone(),
+                quantum_number_flow_id: state.quantum_number_flow_id,
+                color,
+                pairing_lineage: PendingPairingLineage::source(seed, anchor.source_slot),
+            };
+            let previous = nodes.len();
+            insert_topology_order(nodes, node_ids, key, zero_orders.clone())?;
+            if nodes.len() != previous {
+                checked_increment(&mut source_topology_count, "source topology count")?;
+            }
+        }
+    }
+    Ok(source_topology_count)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn apply_transition(
+    templates: &ValidatedRecurrenceTemplateInput,
+    prepared: &PreparedTransition,
+    left: &GlobalTopologyNode,
+    right: &GlobalTopologyNode,
+    source_count: usize,
+    seed: &OnTheFlyProcessSeedV1,
+    hard_limits: &[Option<u32>],
+    nodes: &mut Vec<GlobalTopologyNode>,
+    node_ids: &mut BTreeMap<GlobalTopologyKey, usize>,
+    census: &mut OnTheFlyCouplingPolicyCensusV1,
+) -> RusticolResult<()> {
+    let Some(parents) = ordered_transition_parents(prepared, &left.key, &right.key) else {
+        return Ok(());
+    };
+    if !topology_quantum_matches(prepared.input_states, prepared.input_spins, parents) {
+        return Ok(());
+    }
+    if let Some(contact_orbit) = prepared.contact_orbit.as_ref()
+        && !contact_orbit.accepts_parent_topology_domain([
+            contact_orbit_topology_domain(parents[0]),
+            contact_orbit_topology_domain(parents[1]),
+        ])?
+    {
+        return Ok(());
+    }
+    // Contact-orbit certificates choose one amplitude owner among the
+    // admitted equivalent contributions. Retaining all certified owner
+    // orientations cannot introduce a distinct coupling-order vector.
+    let _ = prepared.output_factor()?;
+    let support = merge_disjoint_support(&parents[0].support, &parents[1].support)?;
+    if support.len() >= source_count {
+        return Ok(());
+    }
+    let result_state = templates
+        .input()
+        .current_states
+        .get(prepared.row.result_state_template_id as usize)
+        .ok_or_else(|| integrity("global topology result state is absent"))?;
+    let carries_colored_fermion_line =
+        result_state.statistics == 1 && result_state.color_representation != 1;
+    let pairing_lineages = combine_pairing_lineage_sets(
+        // Each topology key carries one exact lineage alternative.  Keeping
+        // it in the key prevents an invalid endpoint pairing from borrowing
+        // the coupling order of another alternative.
+        //
+        // No public selector enters this operation.
+        seed,
+        std::slice::from_ref(&parents[0].pairing_lineage),
+        std::slice::from_ref(&parents[1].pairing_lineage),
+        carries_colored_fermion_line,
+    )?;
+    if pairing_lineages.is_empty() {
+        return Ok(());
+    }
+    let flavour = prepared
+        .flavour
+        .apply_flows(&parents[0].flavour_flow, &parents[1].flavour_flow);
+    for witness in &prepared.witnesses {
+        if witness.row.left_shape_string_id != parents[0].color.output_color_shape_id()
+            || witness.row.right_shape_string_id != parents[1].color.output_color_shape_id()
+        {
+            continue;
+        }
+        checked_increment(
+            &mut census.transition_witness_attempt_count,
+            "global transition witness-attempt count",
+        )?;
+        let Some(color) = witness
+            .witness
+            .apply(&parents[0].color, &parents[1].color)?
+        else {
+            continue;
+        };
+        for lineage in &pairing_lineages {
+            let key = GlobalTopologyKey {
+                support: support.clone().into_boxed_slice(),
+                current_state_template_id: prepared.row.result_state_template_id,
+                spin_state: prepared.quantum.result_spin_state,
+                flavour_flow: flavour.clone().into_boxed_slice(),
+                quantum_number_flow_id: prepared.quantum.result_quantum_number_flow_id,
+                color: color.clone(),
+                pairing_lineage: lineage.clone(),
+            };
+            for left_orders in &left.orders {
+                for right_orders in &right.orders {
+                    let Some(orders) = combined_coupling_orders(
+                        left_orders,
+                        right_orders,
+                        &prepared.local_orders,
+                        hard_limits,
+                    )?
+                    else {
+                        continue;
+                    };
+                    insert_topology_order(nodes, node_ids, key.clone(), orders)?;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn build_global_topologies(
+    templates: &ValidatedRecurrenceTemplateInput,
+    seed: &OnTheFlyProcessSeedV1,
+    grammar: &PreparedOnTheFlyGrammarV1,
+    census: &mut OnTheFlyCouplingPolicyCensusV1,
+) -> RusticolResult<Vec<GlobalTopologyNode>> {
+    let source_count = seed.source_anchors.len();
+    let hard_limits = seed.explicit_coupling_limits();
+    let mut nodes = Vec::new();
+    let mut node_ids = BTreeMap::new();
+    census.source_topology_count = insert_all_sources(seed, grammar, &mut nodes, &mut node_ids)?;
+
+    for target_size in 2..source_count {
+        // New nodes produced at this stage have support `target_size`, so a
+        // stable snapshot of smaller parents is complete for the stage.
+        let parents = nodes
+            .iter()
+            .filter(|node| node.key.support.len() < target_size)
+            .cloned()
+            .collect::<Vec<_>>();
+        let pair_index =
+            SupportSizePairIndex::new(parents.iter().map(|node| node.key.support.len()));
+        for (left_index, left) in parents.iter().enumerate() {
+            for &right_index in
+                pair_index.partners_after(left_index, left.key.support.len(), target_size)
+            {
+                let right = &parents[right_index];
+                if !supports_are_disjoint(&left.key.support, &right.key.support) {
+                    continue;
+                }
+                let Some(rows) = grammar.transitions.get(&canonical_state_pair(
+                    left.key.current_state_template_id,
+                    right.key.current_state_template_id,
+                )) else {
+                    continue;
+                };
+                for prepared in rows {
+                    apply_transition(
+                        templates,
+                        prepared,
+                        left,
+                        right,
+                        source_count,
+                        seed,
+                        hard_limits,
+                        &mut nodes,
+                        &mut node_ids,
+                        census,
+                    )?;
+                }
+            }
+        }
+    }
+    census.retained_topology_count = u64::try_from(nodes.len())
+        .map_err(|_| invalid("global retained-topology count exceeds u64"))?;
+    Ok(nodes)
+}
+
+fn closure_has_canonical_anchor(
+    left: &GlobalTopologyKey,
+    right: &GlobalTopologyKey,
+    anchor: u32,
+    source_count: usize,
+) -> bool {
+    (left.support.as_ref() == [anchor] && right.support.len() + 1 == source_count)
+        || (right.support.as_ref() == [anchor] && left.support.len() + 1 == source_count)
+}
+
+fn collect_viable_total_orders(
+    seed: &OnTheFlyProcessSeedV1,
+    grammar: &PreparedOnTheFlyGrammarV1,
+    nodes: &[GlobalTopologyNode],
+    census: &mut OnTheFlyCouplingPolicyCensusV1,
+) -> RusticolResult<Vec<Box<[u32]>>> {
+    let source_count = seed.source_anchors.len();
+    let mut totals = Vec::new();
+    let pair_index = SupportSizePairIndex::new(nodes.iter().map(|node| node.key.support.len()));
+    for (left_index, left) in nodes.iter().enumerate() {
+        // Physical closure below requires a singleton canonical anchor.
+        // Reject impossible size classes before visiting their colour states;
+        // the exact anchor and colour/pairing checks remain unchanged.
+        if left.key.support.len() != 1
+            && left.key.support.len().checked_add(1) != Some(source_count)
+        {
+            continue;
+        }
+        for &right_index in
+            pair_index.partners_after(left_index, left.key.support.len(), source_count)
+        {
+            let right = &nodes[right_index];
+            if !supports_are_disjoint(&left.key.support, &right.key.support) {
+                continue;
+            }
+            let Some(rows) = grammar.closures.get(&canonical_state_pair(
+                left.key.current_state_template_id,
+                right.key.current_state_template_id,
+            )) else {
+                continue;
+            };
+            for closure in rows {
+                let Some(parents) = ordered_closure_parents(closure, &left.key, &right.key) else {
+                    continue;
+                };
+                let pairing_lineages = combine_pairing_lineage_sets(
+                    seed,
+                    std::slice::from_ref(&parents[0].pairing_lineage),
+                    std::slice::from_ref(&parents[1].pairing_lineage),
+                    false,
+                )?;
+                if !pairing_lineages
+                    .iter()
+                    .try_fold(false, |complete, lineage| {
+                        Ok::<_, RusticolError>(complete || complete_pairing_lineage(seed, lineage)?)
+                    })?
+                {
+                    continue;
+                }
+                for quantum in closure
+                    .quantum_flows
+                    .iter()
+                    .filter(|quantum| closure_quantum_matches_topology(quantum, parents))
+                {
+                    let _ = quantum.output_factor()?;
+                    for witness in &closure.witnesses {
+                        if witness.row.left_shape_string_id
+                            != parents[0].color.output_color_shape_id()
+                            || witness.row.right_shape_string_id
+                                != parents[1].color.output_color_shape_id()
+                        {
+                            continue;
+                        }
+                        checked_increment(
+                            &mut census.closure_witness_attempt_count,
+                            "global closure witness-attempt count",
+                        )?;
+                        let closed = witness
+                            .witness
+                            .closed_components(&parents[0].color, &parents[1].color)?;
+                        let Some(anchor) = grammar.closure_anchor_for_components(seed, &closed)
+                        else {
+                            continue;
+                        };
+                        if !closure_has_canonical_anchor(
+                            &left.key,
+                            &right.key,
+                            anchor,
+                            source_count,
+                        ) {
+                            continue;
+                        }
+                        for left_orders in &left.orders {
+                            for right_orders in &right.orders {
+                                let Some(total) = combined_coupling_orders(
+                                    left_orders,
+                                    right_orders,
+                                    &closure.local_orders,
+                                    seed.explicit_coupling_limits(),
+                                )?
+                                else {
+                                    continue;
+                                };
+                                insert_pareto_order(&mut totals, total);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    census.viable_total_order_count = u64::try_from(totals.len())
+        .map_err(|_| invalid("global viable-total-order count exceeds u64"))?;
+    Ok(totals)
+}
+
+fn hierarchy_degree(orders: &[u32], hierarchies: &[u32]) -> RusticolResult<u64> {
+    if orders.len() != hierarchies.len() {
+        return Err(integrity(
+            "global coupling order and hierarchy dimensions disagree",
+        ));
+    }
+    orders
+        .iter()
+        .zip(hierarchies.iter())
+        .try_fold(0_u64, |total, (order, hierarchy)| {
+            total
+                .checked_add(u64::from(*order) * u64::from(*hierarchy))
+                .ok_or_else(|| invalid("hierarchy-weighted coupling degree exceeds u64"))
+        })
+}
+
+fn minimal_envelope(
+    totals: &[Box<[u32]>],
+    hierarchies: &[u32],
+) -> RusticolResult<Option<Vec<Option<u32>>>> {
+    let Some(minimum) = totals
+        .iter()
+        .map(|orders| hierarchy_degree(orders, hierarchies))
+        .collect::<RusticolResult<Vec<_>>>()?
+        .into_iter()
+        .min()
+    else {
+        return Ok(None);
+    };
+    let mut envelope = vec![0_u32; hierarchies.len()];
+    for orders in totals {
+        if hierarchy_degree(orders, hierarchies)? != minimum {
+            continue;
+        }
+        for (maximum, value) in envelope.iter_mut().zip(orders.iter()) {
+            *maximum = (*maximum).max(*value);
+        }
+    }
+    Ok(Some(envelope.into_iter().map(Some).collect()))
+}
+
+#[allow(dead_code)] // Compatibility entry point for query-local/test-support callers.
+pub(crate) fn resolve_on_the_fly_coupling_policy_v1(
+    templates: &ValidatedRecurrenceTemplateInput,
+    seed: &OnTheFlyProcessSeedV1,
+) -> RusticolResult<OnTheFlyResolvedCouplingPolicyV1> {
+    let catalog = validate_seed_against_templates(templates, seed)?;
+    let grammar = prepare_on_the_fly_grammar_v1(templates, &catalog, seed)?;
+    resolve_on_the_fly_coupling_policy_from_grammar_v1(templates, seed, &grammar)
+}
+
+pub(super) fn resolve_on_the_fly_coupling_policy_from_grammar_v1(
+    templates: &ValidatedRecurrenceTemplateInput,
+    seed: &OnTheFlyProcessSeedV1,
+    grammar: &PreparedOnTheFlyGrammarV1,
+) -> RusticolResult<OnTheFlyResolvedCouplingPolicyV1> {
+    if seed.coupling_order_policy() == OnTheFlyCouplingOrderPolicyV1::Explicit {
+        return Ok(OnTheFlyResolvedCouplingPolicyV1 {
+            seed_digest: seed.semantic_digest(),
+            effective_limits: seed.explicit_coupling_limits().to_vec().into_boxed_slice(),
+            census: OnTheFlyCouplingPolicyCensusV1::default(),
+        });
+    }
+    let mut census = OnTheFlyCouplingPolicyCensusV1::default();
+    let nodes = build_global_topologies(templates, seed, grammar, &mut census)?;
+    let totals = collect_viable_total_orders(seed, grammar, &nodes, &mut census)?;
+    let effective_limits = minimal_envelope(&totals, seed.coupling_hierarchies())?
+        .unwrap_or_else(|| seed.explicit_coupling_limits().to_vec());
+    Ok(OnTheFlyResolvedCouplingPolicyV1 {
+        seed_digest: seed.semantic_digest(),
+        effective_limits: effective_limits.into_boxed_slice(),
+        census,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::template::{CouplingOrderTermRow, IndexedRangeRow};
+    use crate::recurrence::{CheckedTableRange, validated_template_fixture};
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    #[test]
+    fn support_size_index_matches_exhaustive_parent_order() {
+        let cases = [
+            vec![],
+            vec![0],
+            vec![1, 1],
+            vec![1, 2, 1, 3, 2, 1, 4, 3],
+            vec![0, 2, 0, 1, 3, 0, 2],
+            vec![usize::MAX, 0, 1, usize::MAX, 2],
+        ];
+        for sizes in cases {
+            let index = SupportSizePairIndex::new(sizes.iter().copied());
+            for target in (0..=9).chain([usize::MAX]) {
+                let exhaustive = sizes
+                    .iter()
+                    .enumerate()
+                    .flat_map(|(left, &left_size)| {
+                        sizes.iter().enumerate().skip(left + 1).filter_map(
+                            move |(right, &right_size)| {
+                                (left_size.checked_add(right_size) == Some(target))
+                                    .then_some((left, right))
+                            },
+                        )
+                    })
+                    .collect::<Vec<_>>();
+                let indexed = sizes
+                    .iter()
+                    .enumerate()
+                    .flat_map(|(left, &size)| {
+                        index
+                            .partners_after(left, size, target)
+                            .iter()
+                            .map(move |&right| (left, right))
+                    })
+                    .collect::<Vec<_>>();
+                assert_eq!(indexed, exhaustive, "sizes={sizes:?}, target={target}");
+
+                // Closure's early size filter must remove exactly the pairs
+                // that cannot possibly contain its singleton anchor. For two
+                // sources it must not duplicate the symmetric singleton pair.
+                let expected_closure = exhaustive
+                    .iter()
+                    .copied()
+                    .filter(|&(left, right)| sizes[left] == 1 || sizes[right] == 1)
+                    .collect::<Vec<_>>();
+                let indexed_closure = sizes
+                    .iter()
+                    .enumerate()
+                    .filter(|&(_, &size)| size == 1 || size.checked_add(1) == Some(target))
+                    .flat_map(|(left, &size)| {
+                        index
+                            .partners_after(left, size, target)
+                            .iter()
+                            .map(move |&right| (left, right))
+                    })
+                    .collect::<Vec<_>>();
+                assert_eq!(indexed_closure, expected_closure);
+            }
+        }
+    }
+
+    #[test]
+    fn support_size_index_does_not_scan_pairs_of_complete_currents() {
+        let sizes = std::iter::repeat_n(1, 4)
+            .chain(std::iter::repeat_n(8, 10_000))
+            .collect::<Vec<_>>();
+        let index = SupportSizePairIndex::new(sizes.iter().copied());
+        let candidate_count = sizes
+            .iter()
+            .enumerate()
+            .map(|(left, &size)| index.partners_after(left, size, 9).len())
+            .sum::<usize>();
+        assert_eq!(candidate_count, 40_000);
+        assert!(index.partners_after(0, 10, 9).is_empty());
+        assert!(index.partners_after(0, 1, 8).is_empty());
+    }
+
+    fn scalar_templates() -> ValidatedRecurrenceTemplateInput {
+        let mut input = validated_template_fixture().into_input();
+        let spin_start = u64::try_from(input.i32_sequence_values.len()).unwrap();
+        let spin_sequence_id = u32::try_from(input.i32_sequence_ranges.len()).unwrap();
+        input.i32_sequence_ranges.push(IndexedRangeRow {
+            id: spin_sequence_id,
+            range: CheckedTableRange::new(spin_start, 2),
+        });
+        input.i32_sequence_values.extend([50_000, 50_000]);
+        input.quantum_flows[0].input_spin_sequence_id = spin_sequence_id;
+        input.coupling_order_ranges.push(IndexedRangeRow {
+            id: 1,
+            range: CheckedTableRange::new(0, 1),
+        });
+        input.coupling_order_terms.push(CouplingOrderTermRow {
+            set_id: 1,
+            name_string_id: 0,
+            power: 1,
+        });
+        input.validate().unwrap()
+    }
+
+    fn with_policy(
+        seed: OnTheFlyProcessSeedV1,
+        policy: OnTheFlyCouplingOrderPolicyV1,
+        hierarchies: Vec<u32>,
+        limits: Vec<Option<u32>>,
+    ) -> OnTheFlyProcessSeedV1 {
+        let OnTheFlyProcessSeedV1 {
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest,
+            normalization_convention,
+            source_anchors,
+            external_permutation,
+            coupling_order_policy: _,
+            coupling_hierarchies: _,
+            coupling_limits: _,
+            pairing_classes,
+            semantic_digest: _,
+        } = seed;
+        OnTheFlyProcessSeedV1::new(
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest,
+            normalization_convention,
+            ExactComplexRational::ONE,
+            source_anchors.into_vec(),
+            external_permutation.into_vec(),
+            policy,
+            hierarchies,
+            limits,
+            pairing_classes.into_vec(),
+        )
+        .unwrap()
+    }
+
+    fn with_selector_local_zero(seed: OnTheFlyProcessSeedV1) -> OnTheFlyProcessSeedV1 {
+        let OnTheFlyProcessSeedV1 {
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest,
+            normalization_convention,
+            source_anchors,
+            external_permutation,
+            coupling_order_policy,
+            coupling_hierarchies,
+            coupling_limits,
+            pairing_classes,
+            semantic_digest: _,
+        } = seed;
+        let anchors = source_anchors
+            .into_vec()
+            .into_iter()
+            .map(|anchor| {
+                let OnTheFlySourceAnchorV1 {
+                    source_slot,
+                    external_label,
+                    is_initial,
+                    color_role,
+                    is_fermionic,
+                    pairing_source_contract_digest,
+                    states,
+                } = anchor;
+                let mut states = states.into_vec();
+                let mut zero = states[0].clone();
+                zero.state_index = 1;
+                zero.public_helicity = 1;
+                zero.spin_state = 50_001;
+                states.push(zero);
+                OnTheFlySourceAnchorV1::new(
+                    source_slot,
+                    external_label,
+                    is_initial,
+                    color_role,
+                    is_fermionic,
+                    pairing_source_contract_digest,
+                    states,
+                )
+            })
+            .collect::<RusticolResult<Vec<_>>>()
+            .unwrap();
+        OnTheFlyProcessSeedV1::new(
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest,
+            normalization_convention,
+            ExactComplexRational::ONE,
+            anchors,
+            external_permutation.into_vec(),
+            coupling_order_policy,
+            coupling_hierarchies.into_vec(),
+            coupling_limits.into_vec(),
+            pairing_classes.into_vec(),
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn explicit_policy_is_returned_without_a_structural_sweep() {
+        let templates = scalar_templates();
+        let summary = templates.summary();
+        let seed = scalar_adapter_test_seed(
+            summary.compiled_model_digest,
+            summary.catalog_digest,
+            summary.prepared_kernel_pack_digest,
+            digest(80),
+        )
+        .unwrap();
+        let catalog = validate_seed_against_templates(&templates, &seed).unwrap();
+        let grammar = prepare_on_the_fly_grammar_v1(&templates, &catalog, &seed).unwrap();
+        let policy =
+            resolve_on_the_fly_coupling_policy_from_grammar_v1(&templates, &seed, &grammar)
+                .unwrap();
+
+        assert_eq!(
+            policy.effective_limits(),
+            [Some(0)],
+            "census={:?}",
+            policy.census()
+        );
+        assert_eq!(policy.census(), OnTheFlyCouplingPolicyCensusV1::default());
+    }
+
+    #[test]
+    fn minimal_scalar_policy_is_inferred_from_all_sources_and_physical_closure() {
+        let templates = scalar_templates();
+        let summary = templates.summary();
+        let seed = with_policy(
+            scalar_adapter_test_seed(
+                summary.compiled_model_digest,
+                summary.catalog_digest,
+                summary.prepared_kernel_pack_digest,
+                digest(81),
+            )
+            .unwrap(),
+            OnTheFlyCouplingOrderPolicyV1::Minimal,
+            vec![1],
+            vec![None],
+        );
+        let catalog = validate_seed_against_templates(&templates, &seed).unwrap();
+        let grammar = prepare_on_the_fly_grammar_v1(&templates, &catalog, &seed).unwrap();
+        let policy =
+            resolve_on_the_fly_coupling_policy_from_grammar_v1(&templates, &seed, &grammar)
+                .unwrap();
+
+        assert_eq!(policy.effective_limits(), [Some(0)]);
+        assert_eq!(
+            policy.census(),
+            OnTheFlyCouplingPolicyCensusV1 {
+                source_topology_count: 2,
+                retained_topology_count: 2,
+                transition_witness_attempt_count: 0,
+                closure_witness_attempt_count: 2,
+                viable_total_order_count: 1,
+            }
+        );
+    }
+
+    #[test]
+    fn global_leading_order_is_not_promoted_by_a_selector_local_zero() {
+        // Think of [2, 0] as the process-global QCD LO path.  The chosen
+        // selector happens to vanish there and has only the higher weighted
+        // [0, 1] electroweak path.  Resolving globally keeps QED=0, so the
+        // selected trace is a structural zero instead of silently promoting
+        // the process definition to its selector-local higher order.
+        let global_totals = vec![
+            vec![2_u32, 0].into_boxed_slice(),
+            vec![0, 1].into_boxed_slice(),
+        ];
+        let global = minimal_envelope(&global_totals, &[1, 3]).unwrap().unwrap();
+        let selector_only = minimal_envelope(&global_totals[1..], &[1, 3])
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(global, [Some(2), Some(0)]);
+        assert_eq!(selector_only, [Some(0), Some(1)]);
+        assert!(
+            combined_coupling_orders(&[0, 0], &[0, 0], &[0, 1], &global)
+                .unwrap()
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn cached_minimal_policy_is_selector_global_when_one_helicity_is_zero() {
+        let templates = scalar_templates();
+        let summary = templates.summary();
+        let seed = with_selector_local_zero(with_policy(
+            scalar_adapter_test_seed(
+                summary.compiled_model_digest,
+                summary.catalog_digest,
+                summary.prepared_kernel_pack_digest,
+                digest(82),
+            )
+            .unwrap(),
+            OnTheFlyCouplingOrderPolicyV1::Minimal,
+            vec![1],
+            vec![None],
+        ));
+        let catalog = validate_seed_against_templates(&templates, &seed).unwrap();
+        let grammar = prepare_on_the_fly_grammar_v1(&templates, &catalog, &seed).unwrap();
+        let policy =
+            resolve_on_the_fly_coupling_policy_from_grammar_v1(&templates, &seed, &grammar)
+                .unwrap();
+        assert_eq!(policy.effective_limits(), [Some(0)]);
+
+        let nonzero =
+            DecodedLcQueryV1::new(&seed, vec![0, 1], &[0, 0], OnTheFlyLcSelectorV1::Singlet)
+                .unwrap();
+        let selector_zero =
+            DecodedLcQueryV1::new(&seed, vec![0, 1], &[1, 1], OnTheFlyLcSelectorV1::Singlet)
+                .unwrap();
+        assert!(
+            build_selected_lc_trace_impl(
+                &templates,
+                &seed,
+                &grammar,
+                policy.effective_limits(),
+                &nonzero,
+                false,
+                false,
+                false,
+            )
+            .unwrap()
+            .is_some()
+        );
+        assert!(
+            build_selected_lc_trace_impl(
+                &templates,
+                &seed,
+                &grammar,
+                policy.effective_limits(),
+                &selector_zero,
+                false,
+                false,
+                false,
+            )
+            .unwrap()
+            .is_none()
+        );
+        assert_eq!(policy.effective_limits(), [Some(0)]);
+    }
+
+    #[test]
+    fn equal_minimum_hierarchy_paths_form_a_componentwise_envelope() {
+        let totals = vec![
+            vec![2_u32, 0].into_boxed_slice(),
+            vec![0, 1].into_boxed_slice(),
+            vec![4, 0].into_boxed_slice(),
+        ];
+        assert_eq!(
+            minimal_envelope(&totals, &[1, 2]).unwrap().unwrap(),
+            [Some(2), Some(1)]
+        );
+    }
+
+    #[test]
+    fn pareto_front_discards_only_componentwise_higher_orders() {
+        let mut orders = Vec::new();
+        assert!(insert_pareto_order(&mut orders, vec![2, 0]));
+        assert!(insert_pareto_order(&mut orders, vec![0, 2]));
+        assert!(!insert_pareto_order(&mut orders, vec![3, 1]));
+        assert!(insert_pareto_order(&mut orders, vec![1, 0]));
+        assert_eq!(
+            orders,
+            [vec![0, 2].into_boxed_slice(), vec![1, 0].into_boxed_slice()]
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/family.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/family.rs
new file mode 100644
index 0000000000..eea838cdeb
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/family.rs
@@ -0,0 +1,5649 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Feature-only structural union and execution for requested LC query families.
+//!
+//! Independently constructed query-local traces are merged into stable boxed
+//! Direct-Arena rows, one shared numeric workspace, and an ordered grouped
+//! invocation schedule. Optional cache snapshots persist these same rows,
+//! without introducing a different evaluation plan. Release/default builds do
+//! not retain the cold contribution identities consumed here.
+
+use super::trace::{OnTheFlyTraceContributionProofRowV1, OnTheFlyTraceOperationV1};
+use super::*;
+use crate::recurrence::PreparedDirectExecutorCatalog;
+use crate::recurrence::construct::current_key_with_dynamic_color;
+use sha2::{Digest, Sha256};
+use std::ops::Range;
+
+pub(crate) mod snapshot;
+
+const STREAMED_QUERY_FAMILY_IDENTITY_DOMAIN: &[u8] =
+    b"pyamplicol-on-the-fly-streamed-query-family-v1\0";
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct FamilySourceIdentity {
+    executor: OnTheFlyExecutorKeyV1,
+    source_slot: u32,
+    momentum: CanonicalMomentumLinearForm,
+    source_template_or_dispatch_domain: u32,
+    spin_state_class: i32,
+    exact_factor: ExactComplexRational,
+    selector_domain_id: u32,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct FamilyContributionIdentity {
+    executor: OnTheFlyExecutorKeyV1,
+    key: ContributionKey,
+    exact_factor: ExactComplexRational,
+    selector_domain_id: u32,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct FamilyFinalizationIdentity {
+    executor: OnTheFlyExecutorKeyV1,
+    momentum: CanonicalMomentumLinearForm,
+    component_count: u16,
+    exact_factor: ExactComplexRational,
+    selector_domain_id: u32,
+    flags: u32,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct FamilyClosureIdentity {
+    seed_digest: SemanticDigest,
+    query_digest: SemanticDigest,
+    stage: u32,
+    executor: OnTheFlyExecutorKeyV1,
+    parent_current_ids: [u32; 2],
+    parent_momenta: [CanonicalMomentumLinearForm; 2],
+    exact_factor: ExactComplexRational,
+    component_factors: Box<[ExactComplexRational]>,
+    component_count: u16,
+    selector_domain_id: u32,
+    proof_group_id: u32,
+    amplitude_destination_id: u32,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct FamilyCurrentDefinition {
+    component_count: u32,
+    source: Option<FamilySourceIdentity>,
+    contributions: BTreeSet<FamilyContributionIdentity>,
+    finalization: Option<FamilyFinalizationIdentity>,
+}
+
+struct FamilyUnionCurrentRecord {
+    id: u32,
+    definition: Option<FamilyCurrentDefinition>,
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct QueryFamilyTraceInput<'a> {
+    pub(crate) trace: &'a OnTheFlyStructuralTraceV1,
+    pub(crate) projection: OnTheFlyProjectionProbeV1,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+enum QueryFamilyCacheIdentityV1 {
+    /// A restored family is addressed by its retained lane handle. A new
+    /// selection always obtains its ordinary exact or streamed identity.
+    Restored,
+    Exact {
+        direct_catalog: PreparedDirectExecutorCatalog,
+        queries: Box<
+            [(
+                SemanticDigest,
+                SemanticDigest,
+                SemanticDigest,
+                OnTheFlyProjectionProbeV1,
+            )],
+        >,
+    },
+    Streamed {
+        direct_catalog_digest: SemanticDigest,
+        query_count: u32,
+        ordered_query_digest: SemanticDigest,
+    },
+}
+
+#[derive(Debug, Eq, PartialEq, bincode::Encode, bincode::Decode)]
+enum OnTheFlyFamilyRowsV1 {
+    Source(Box<[DirectSourceRow]>),
+    Contribution(Box<[DirectContributionRow]>),
+    Finalization(Box<[DirectFinalizationRow]>),
+    Closure(Box<[DirectClosureRow]>),
+}
+
+impl OnTheFlyFamilyRowsV1 {
+    fn len(&self) -> usize {
+        match self {
+            Self::Source(rows) => rows.len(),
+            Self::Contribution(rows) => rows.len(),
+            Self::Finalization(rows) => rows.len(),
+            Self::Closure(rows) => rows.len(),
+        }
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, bincode::Encode, bincode::Decode)]
+struct OnTheFlyFamilyRowGroupV1 {
+    seed_digest: SemanticDigest,
+    stage: u32,
+    role: DirectExecutorRole,
+    direct_executor_id: u32,
+    representative_key: OnTheFlyExecutorKeyV1,
+    member_bindings: Box<[(OnTheFlyExecutorKeyV1, [u8; 2])]>,
+    rows: OnTheFlyFamilyRowsV1,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+struct OnTheFlyBuiltQueryFamilyV1 {
+    census: OnTheFlyQueryFamilyCensusV1,
+    source_count: u32,
+    lorentz_component_count: u16,
+    parameter_count: u32,
+    current_component_count: u32,
+    amplitude_destination_count: u32,
+    momentum_forms: Box<[CanonicalMomentumLinearForm]>,
+    exact_factors: Box<[ExactComplexRational]>,
+    row_groups: Box<[OnTheFlyFamilyRowGroupV1]>,
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    observed_currents: Box<[OnTheFlyFamilyObservedCurrentDescriptorV1]>,
+}
+
+/// Opaque, fully materialized streamed family.  Its compact cache identity is
+/// computed while chunks are consumed, so no query-local identity table
+/// survives the cold construction boundary.
+#[derive(Debug)]
+pub(crate) struct OnTheFlyStreamedQueryFamilyCandidateV1 {
+    identity: QueryFamilyCacheIdentityV1,
+    family: OnTheFlyBuiltQueryFamilyV1,
+}
+
+/// Synchronous chunk consumer used by contracted color construction.  A
+/// producer may create and bind a bounded batch of query-local traces, hand
+/// borrowed inputs to this interface, and immediately drop the whole batch.
+/// Returned destinations are dense across every previously consumed chunk.
+pub(crate) trait OnTheFlyQueryFamilyChunkConsumerV1 {
+    fn push_chunk(&mut self, selected: &[QueryFamilyTraceInput<'_>]) -> RusticolResult<Range<u32>>;
+}
+
+impl<F> OnTheFlyQueryFamilyChunkConsumerV1 for F
+where
+    F: for<'trace> FnMut(&[QueryFamilyTraceInput<'trace>]) -> RusticolResult<Range<u32>>,
+{
+    fn push_chunk(&mut self, selected: &[QueryFamilyTraceInput<'_>]) -> RusticolResult<Range<u32>> {
+        self(selected)
+    }
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct OnTheFlyFamilyObservedCurrentDescriptorV1 {
+    semantic_digest: SemanticDigest,
+    stage: u32,
+    component_base: u32,
+    component_count: u32,
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct OnTheFlyFamilyObservedCurrentV1 {
+    pub(crate) semantic_digest: SemanticDigest,
+    pub(crate) stage: u32,
+    pub(crate) values: Vec<(f64, f64)>,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct OnTheFlyQueryFamilyExecutionReportV1 {
+    pub(crate) cache_hit: bool,
+    pub(crate) source_calls: u32,
+    pub(crate) source_rows: u32,
+    pub(crate) contribution_calls: u32,
+    pub(crate) contribution_rows: u32,
+    pub(crate) finalization_calls: u32,
+    pub(crate) finalization_rows: u32,
+    pub(crate) closure_calls: u32,
+    pub(crate) closure_rows: u32,
+}
+
+#[derive(Clone, Debug)]
+struct FamilySourceDraft {
+    seed_digest: SemanticDigest,
+    stage: u32,
+    direct_executor_id: u32,
+    key: OnTheFlyExecutorKeyV1,
+    row: DirectSourceRow,
+}
+
+#[derive(Clone, Debug)]
+struct FamilyContributionDraft {
+    seed_digest: SemanticDigest,
+    stage: u32,
+    destination_current_id: u32,
+    direct_executor_id: u32,
+    key: OnTheFlyExecutorKeyV1,
+    parent_permutation: [u8; 2],
+    row: DirectContributionRow,
+}
+
+#[derive(Clone, Debug)]
+struct FamilyFinalizationDraft {
+    seed_digest: SemanticDigest,
+    stage: u32,
+    direct_executor_id: u32,
+    key: OnTheFlyExecutorKeyV1,
+    row: DirectFinalizationRow,
+}
+
+#[derive(Clone, Debug)]
+struct FamilyClosureDraft {
+    seed_digest: SemanticDigest,
+    stage: u32,
+    direct_executor_id: u32,
+    key: OnTheFlyExecutorKeyV1,
+    row: DirectClosureRow,
+}
+
+impl FamilyCurrentDefinition {
+    const fn new(component_count: u32) -> Self {
+        Self {
+            component_count,
+            source: None,
+            contributions: BTreeSet::new(),
+            finalization: None,
+        }
+    }
+}
+
+/// Cold projection of both today's serialized-query execution and a
+/// proof-identical query-family union.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, bincode::Encode, bincode::Decode)]
+#[doc(hidden)]
+pub struct OnTheFlyQueryFamilyCensusV1 {
+    pub query_count: u32,
+    pub source_frame_partition_count: u32,
+    pub projection_applied_query_count: u32,
+    pub projection_pre_current_count: u32,
+    pub projection_pre_contribution_count: u32,
+    pub projection_pre_closure_count: u32,
+    pub projection_post_current_count: u32,
+    pub projection_post_contribution_count: u32,
+    pub projection_post_closure_count: u32,
+    pub dynamic_current_occurrence_count: u32,
+    pub dynamic_current_component_occurrence_count: u32,
+    pub dynamic_source_rows: u32,
+    pub dynamic_contribution_rows: u32,
+    pub dynamic_finalization_rows: u32,
+    pub dynamic_closure_rows: u32,
+    pub dynamic_source_calls: u32,
+    pub dynamic_contribution_calls: u32,
+    pub dynamic_finalization_calls: u32,
+    pub dynamic_closure_calls: u32,
+    pub union_unique_current_count: u32,
+    pub union_unique_current_component_count: u32,
+    pub union_source_rows: u32,
+    pub union_contribution_rows: u32,
+    pub union_finalization_rows: u32,
+    pub union_closure_rows: u32,
+    pub union_amplitude_destination_count: u32,
+    pub union_source_executor_call_groups: u32,
+    pub union_contribution_executor_call_groups: u32,
+    pub union_finalization_executor_call_groups: u32,
+    pub union_closure_executor_call_groups: u32,
+}
+
+impl OnTheFlyQueryFamilyCensusV1 {
+    #[allow(dead_code)] // Exposed by the non-default structural census feature.
+    pub(crate) fn union_kernel_application_count(self) -> RusticolResult<u32> {
+        self.union_source_rows
+            .checked_add(self.union_contribution_rows)
+            .and_then(|value| value.checked_add(self.union_finalization_rows))
+            .and_then(|value| value.checked_add(self.union_closure_rows))
+            .ok_or_else(|| integrity("query-family union kernel-application count exceeds u32"))
+    }
+}
+
+fn add(value: &mut u32, increment: u32, label: &str) -> RusticolResult<()> {
+    *value = value
+        .checked_add(increment)
+        .ok_or_else(|| invalid(format!("{label} exceeds u32")))?;
+    Ok(())
+}
+
+fn trace_factor(
+    trace: &OnTheFlyStructuralTraceV1,
+    factor_id: u32,
+    label: &str,
+) -> RusticolResult<ExactComplexRational> {
+    trace
+        .exact_factors
+        .get(factor_id as usize)
+        .copied()
+        .ok_or_else(|| integrity(format!("{label} exact factor is absent")))
+}
+
+fn trace_momentum(
+    trace: &OnTheFlyStructuralTraceV1,
+    momentum_id: u32,
+    label: &str,
+) -> RusticolResult<CanonicalMomentumLinearForm> {
+    trace
+        .momentum_forms
+        .get(momentum_id as usize)
+        .cloned()
+        .ok_or_else(|| integrity(format!("{label} momentum form is absent")))
+}
+
+fn remapped_contribution_key(
+    row: &OnTheFlyTraceContributionProofRowV1,
+    local_to_union: &[u32],
+) -> RusticolResult<ContributionKey> {
+    if row.key.parent_value_class_ids() != row.parent_current_ids {
+        return Err(integrity(
+            "cold contribution identity does not retain its local parent IDs",
+        ));
+    }
+    let parent_ids = row
+        .parent_current_ids
+        .iter()
+        .map(|id| {
+            local_to_union
+                .get(*id as usize)
+                .copied()
+                .ok_or_else(|| integrity("contribution parent current is absent"))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    ContributionKey::new(
+        row.key.transition_template_id(),
+        parent_ids,
+        row.key.parent_state_template_ids().to_vec(),
+        row.key.parent_momenta().to_vec(),
+        row.key.result_state_template_id(),
+        row.key.quantum_flow_witness_id(),
+        row.key.color_witness_term_id(),
+        row.key.runtime_coupling_binding_digest(),
+        row.key.output_projection_id(),
+    )
+}
+
+fn current_id_by_component_base(
+    bases: &BTreeMap<u32, u32>,
+    base: u32,
+    label: &str,
+) -> RusticolResult<u32> {
+    bases
+        .get(&base)
+        .copied()
+        .ok_or_else(|| integrity(format!("{label} current component base is absent")))
+}
+
+fn prepared_executor_id(
+    catalog: &PreparedDirectExecutorCatalog,
+    key: OnTheFlyExecutorKeyV1,
+) -> RusticolResult<u32> {
+    if key.direct_catalog_digest() != catalog.direct_template_catalog_digest() {
+        return Err(integrity(
+            "query-family executor key belongs to a different prepared catalog",
+        ));
+    }
+    match key.evaluator_binding_id() {
+        Some(binding_id) => catalog.resolve_evaluator(key.role(), binding_id),
+        None => catalog.resolve_identity_finalizer(),
+    }
+}
+
+fn current_stage(key: &CurrentCoreKey) -> RusticolResult<u32> {
+    u32::try_from(
+        key.support_source_slots()
+            .len()
+            .checked_sub(1)
+            .ok_or_else(|| integrity("query-family current has empty source support"))?,
+    )
+    .map_err(|_| invalid("query-family current stage exceeds u32"))
+}
+
+fn intern_factor(
+    ids: &mut BTreeMap<ExactComplexRational, u32>,
+    factors: &mut Vec<ExactComplexRational>,
+    value: ExactComplexRational,
+) -> RusticolResult<u32> {
+    if let Some(id) = ids.get(&value).copied() {
+        return Ok(id);
+    }
+    let id = checked_u32(factors.len(), "query-family exact-factor ID")?;
+    factors.try_reserve(1).map_err(|error| {
+        invalid(format!(
+            "query-family exact-factor allocation failed: {error}"
+        ))
+    })?;
+    factors.push(value);
+    ids.insert(value, id);
+    Ok(id)
+}
+
+fn intern_factor_block(
+    block_ids: &mut BTreeMap<Box<[ExactComplexRational]>, u32>,
+    scalar_ids: &mut BTreeMap<ExactComplexRational, u32>,
+    factors: &mut Vec<ExactComplexRational>,
+    block: &[ExactComplexRational],
+) -> RusticolResult<u32> {
+    if block.is_empty() {
+        return Err(integrity("query-family exact-factor block is empty"));
+    }
+    if let Some(start) = block_ids.get(block).copied() {
+        return Ok(start);
+    }
+    let start = checked_u32(factors.len(), "query-family exact-factor block start")?;
+    let _end = factors
+        .len()
+        .checked_add(block.len())
+        .and_then(|end| u32::try_from(end).ok())
+        .ok_or_else(|| invalid("query-family exact-factor block exceeds u32"))?;
+    factors.try_reserve(block.len()).map_err(|error| {
+        invalid(format!(
+            "query-family exact-factor block allocation failed: {error}"
+        ))
+    })?;
+    for (offset, value) in block.iter().copied().enumerate() {
+        let id = start
+            .checked_add(checked_u32(
+                offset,
+                "query-family exact-factor block offset",
+            )?)
+            .ok_or_else(|| invalid("query-family exact-factor block ID exceeds u32"))?;
+        factors.push(value);
+        scalar_ids.entry(value).or_insert(id);
+    }
+    block_ids.insert(block.to_vec().into_boxed_slice(), start);
+    Ok(start)
+}
+
+fn intern_momentum(
+    ids: &mut BTreeMap<CanonicalMomentumLinearForm, u32>,
+    forms: &mut Vec<CanonicalMomentumLinearForm>,
+    form: &CanonicalMomentumLinearForm,
+) -> RusticolResult<u32> {
+    if let Some(id) = ids.get(form).copied() {
+        return Ok(id);
+    }
+    let id = checked_u32(forms.len(), "query-family momentum-form ID")?;
+    forms.try_reserve(1).map_err(|error| {
+        invalid(format!(
+            "query-family momentum-form allocation failed: {error}"
+        ))
+    })?;
+    forms.push(form.clone());
+    ids.insert(form.clone(), id);
+    Ok(id)
+}
+
+fn prepared_binding(
+    catalog: &PreparedDirectExecutorCatalog,
+    key: OnTheFlyExecutorKeyV1,
+) -> RusticolResult<(u32, [u8; 2])> {
+    if key.direct_catalog_digest() != catalog.direct_template_catalog_digest() {
+        return Err(integrity(
+            "query-family executor key belongs to a different prepared catalog",
+        ));
+    }
+    match key.evaluator_binding_id() {
+        Some(binding_id) if key.role() == DirectExecutorRole::Contribution => {
+            catalog.resolve_contribution(binding_id)
+        }
+        Some(binding_id) => Ok((catalog.resolve_evaluator(key.role(), binding_id)?, [0, 1])),
+        None => Ok((catalog.resolve_identity_finalizer()?, [0, 1])),
+    }
+}
+
+/// Analyze the exact traces requested by one existing selector-family call.
+///
+/// Equal normalized [`CurrentCoreKey`] values are merged only when their
+/// complete source/contribution/finalization definitions agree.  Conflicting
+/// duplicates fail closed.  Closures remain distinct per requested query so a
+/// future executable union cannot lose an amplitude destination.
+fn build_query_family_from_chunks(
+    direct_catalog: &PreparedDirectExecutorCatalog,
+    produce: impl FnOnce(&mut dyn OnTheFlyQueryFamilyChunkConsumerV1) -> RusticolResult<()>,
+) -> RusticolResult<Option<(OnTheFlyBuiltQueryFamilyV1, SemanticDigest)>> {
+    let mut layout = None;
+    let mut seen_queries = BTreeSet::new();
+    let mut seed_partitions = BTreeSet::new();
+    let mut colors = DynamicLCColorStateInterner::default();
+    let mut union_currents =
+        BTreeMap::<(SemanticDigest, CurrentCoreKey), FamilyUnionCurrentRecord>::new();
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    let mut observed_current_identities = BTreeMap::<u32, (SemanticDigest, u32, u32)>::new();
+    let mut closure_definitions = Vec::<FamilyClosureIdentity>::new();
+    let mut source_groups = BTreeSet::new();
+    let mut contribution_groups = BTreeSet::new();
+    let mut finalization_groups = BTreeSet::new();
+    let mut closure_groups = BTreeSet::new();
+    let mut census = OnTheFlyQueryFamilyCensusV1 {
+        query_count: 0,
+        source_frame_partition_count: 0,
+        projection_applied_query_count: 0,
+        projection_pre_current_count: 0,
+        projection_pre_contribution_count: 0,
+        projection_pre_closure_count: 0,
+        projection_post_current_count: 0,
+        projection_post_contribution_count: 0,
+        projection_post_closure_count: 0,
+        dynamic_current_occurrence_count: 0,
+        dynamic_current_component_occurrence_count: 0,
+        dynamic_source_rows: 0,
+        dynamic_contribution_rows: 0,
+        dynamic_finalization_rows: 0,
+        dynamic_closure_rows: 0,
+        dynamic_source_calls: 0,
+        dynamic_contribution_calls: 0,
+        dynamic_finalization_calls: 0,
+        dynamic_closure_calls: 0,
+        union_unique_current_count: 0,
+        union_unique_current_component_count: 0,
+        union_source_rows: 0,
+        union_contribution_rows: 0,
+        union_finalization_rows: 0,
+        union_closure_rows: 0,
+        union_amplitude_destination_count: 0,
+        union_source_executor_call_groups: 0,
+        union_contribution_executor_call_groups: 0,
+        union_finalization_executor_call_groups: 0,
+        union_closure_executor_call_groups: 0,
+    };
+    let mut identity_hash = Sha256::new();
+    identity_hash.update(STREAMED_QUERY_FAMILY_IDENTITY_DOMAIN);
+    identity_hash.update(direct_catalog.direct_template_catalog_digest().as_bytes());
+
+    {
+        let mut consume = |selected: &[QueryFamilyTraceInput<'_>]| -> RusticolResult<Range<u32>> {
+            let first_destination = census.query_count;
+            for selected_query in selected {
+                let query_index = census.query_count as usize;
+                let trace = selected_query.trace;
+                let trace_layout = (
+                    trace.layout.source_count,
+                    trace.layout.lorentz_component_count,
+                    trace.layout.parameter_count,
+                );
+                if layout.is_some_and(|established| established != trace_layout) {
+                    return Err(integrity(
+                        "query-family traces do not share one source-frame workspace shape",
+                    ));
+                }
+                layout.get_or_insert(trace_layout);
+                identity_hash.update(trace.seed_digest.as_bytes());
+                identity_hash.update(trace.query_digest.as_bytes());
+                identity_hash.update(trace.semantic_digest().as_bytes());
+                identity_hash.update([u8::from(selected_query.projection.enabled)]);
+                identity_hash.update([u8::from(selected_query.projection.applied)]);
+                for value in selected_query
+                    .projection
+                    .pre
+                    .into_iter()
+                    .chain(selected_query.projection.post)
+                {
+                    identity_hash.update(value.to_le_bytes());
+                }
+                seed_partitions.insert(trace.seed_digest);
+                if !seen_queries.insert(trace.query_digest) {
+                    return Err(invalid("query-family repeats a selected query"));
+                }
+                if trace.layout.amplitude_component_count != 1 {
+                    return Err(integrity(
+                        "query-local trace does not expose exactly one amplitude destination",
+                    ));
+                }
+                if selected_query.projection.applied {
+                    add(
+                        &mut census.projection_applied_query_count,
+                        1,
+                        "projection-applied query count",
+                    )?;
+                }
+                for (target, value, label) in [
+                    (
+                        &mut census.projection_pre_current_count,
+                        selected_query.projection.pre[0],
+                        "projection pre-current count",
+                    ),
+                    (
+                        &mut census.projection_pre_contribution_count,
+                        selected_query.projection.pre[1],
+                        "projection pre-contribution count",
+                    ),
+                    (
+                        &mut census.projection_pre_closure_count,
+                        selected_query.projection.pre[2],
+                        "projection pre-closure count",
+                    ),
+                    (
+                        &mut census.projection_post_current_count,
+                        selected_query.projection.post[0],
+                        "projection post-current count",
+                    ),
+                    (
+                        &mut census.projection_post_contribution_count,
+                        selected_query.projection.post[1],
+                        "projection post-contribution count",
+                    ),
+                    (
+                        &mut census.projection_post_closure_count,
+                        selected_query.projection.post[2],
+                        "projection post-closure count",
+                    ),
+                ] {
+                    add(target, value, label)?;
+                }
+                if selected_query.projection.post
+                    != [
+                        trace.proof.current_count(),
+                        trace.proof.contribution_count(),
+                        trace.proof.closure_count(),
+                    ]
+                {
+                    return Err(integrity(
+                        "query-local projection proof does not describe its retained trace",
+                    ));
+                }
+                let current_count = trace.current_keys.len();
+                if current_count != trace.current_colors.len()
+                    || current_count != trace.current_component_ranges.len()
+                    || current_count != trace.proof.current_count() as usize
+                {
+                    return Err(integrity(
+                        "query-local current identity columns have inconsistent lengths",
+                    ));
+                }
+                add(
+                    &mut census.dynamic_current_occurrence_count,
+                    checked_u32(current_count, "dynamic current occurrence count")?,
+                    "dynamic current occurrence count",
+                )?;
+
+                let mut local_to_union = Vec::new();
+                local_to_union
+                    .try_reserve_exact(current_count)
+                    .map_err(|error| {
+                        invalid(format!(
+                            "query-family current map allocation failed: {error}"
+                        ))
+                    })?;
+                let mut normalized_keys = Vec::new();
+                normalized_keys
+                    .try_reserve_exact(current_count)
+                    .map_err(|error| {
+                        invalid(format!(
+                            "query-family current key allocation failed: {error}"
+                        ))
+                    })?;
+                let mut bases = BTreeMap::new();
+                for (local_id, ((key, color), [base, count])) in trace
+                    .current_keys
+                    .iter()
+                    .zip(trace.current_colors.iter())
+                    .zip(trace.current_component_ranges.iter().copied())
+                    .enumerate()
+                {
+                    if count == 0 || bases.insert(base, local_id as u32).is_some() {
+                        return Err(integrity(
+                            "query-local current component ranges are empty or ambiguous",
+                        ));
+                    }
+                    add(
+                        &mut census.dynamic_current_component_occurrence_count,
+                        count,
+                        "dynamic current component occurrence count",
+                    )?;
+                    let color_id = colors.intern(color.clone())?;
+                    let normalized = current_key_with_dynamic_color(key, color_id)?;
+                    let family_key = (trace.seed_digest, normalized);
+                    let next =
+                        checked_u32(union_currents.len(), "query-family union current count")?;
+                    let union_id = match union_currents.entry(family_key.clone()) {
+                        std::collections::btree_map::Entry::Vacant(entry) => {
+                            entry.insert(FamilyUnionCurrentRecord {
+                                id: next,
+                                definition: None,
+                            });
+                            next
+                        }
+                        std::collections::btree_map::Entry::Occupied(entry) => entry.get().id,
+                    };
+                    local_to_union.push(union_id);
+                    normalized_keys.push(family_key);
+                }
+                #[cfg(any(test, feature = "on-the-fly-test-support"))]
+                {
+                    if trace.current_semantic_digests.len() != local_to_union.len() {
+                        return Err(integrity(
+                            "query-local current semantic identities have an inconsistent length",
+                        ));
+                    }
+                    for (local_id, union_id) in local_to_union.iter().copied().enumerate() {
+                        let semantic_digest = trace.current_semantic_digests[local_id];
+                        let stage = current_stage(&trace.current_keys[local_id])?;
+                        let component_count = trace.current_component_ranges[local_id][1];
+                        match observed_current_identities.entry(union_id) {
+                            std::collections::btree_map::Entry::Vacant(entry) => {
+                                entry.insert((semantic_digest, stage, component_count));
+                            }
+                            std::collections::btree_map::Entry::Occupied(entry)
+                                if *entry.get() == (semantic_digest, stage, component_count) => {}
+                            std::collections::btree_map::Entry::Occupied(_) => {
+                                return Err(integrity(
+                                    "query-family union current has inconsistent observed identity",
+                                ));
+                            }
+                        }
+                    }
+                }
+
+                let mut local_definitions = trace
+                    .current_component_ranges
+                    .iter()
+                    .map(|range| FamilyCurrentDefinition::new(range[1]))
+                    .collect::<Vec<_>>();
+                let mut contribution_proofs = trace.contribution_proof_rows.iter();
+                for operation in trace.operations.iter() {
+                    match operation {
+                        OnTheFlyTraceOperationV1::Source { key, row } => {
+                            let current_id = current_id_by_component_base(
+                                &bases,
+                                row.destination_component_base,
+                                "source destination",
+                            )?;
+                            let definition = &mut local_definitions[current_id as usize];
+                            let identity = FamilySourceIdentity {
+                                executor: *key,
+                                source_slot: row.source_slot,
+                                momentum: trace_momentum(trace, row.momentum_form_id, "source")?,
+                                source_template_or_dispatch_domain: row
+                                    .source_template_or_dispatch_domain,
+                                spin_state_class: row.spin_state_class,
+                                exact_factor: trace_factor(trace, row.exact_factor_id, "source")?,
+                                selector_domain_id: row.selector_domain_id,
+                            };
+                            if definition.source.replace(identity).is_some() {
+                                return Err(integrity(
+                                    "query-local current repeats its source row",
+                                ));
+                            }
+                            add(&mut census.dynamic_source_rows, 1, "dynamic source rows")?;
+                        }
+                        OnTheFlyTraceOperationV1::Contribution { key: executor, row } => {
+                            let proof = contribution_proofs.next().ok_or_else(|| {
+                                integrity("query-local contribution has no cold semantic identity")
+                            })?;
+                            let result = current_id_by_component_base(
+                                &bases,
+                                row.destination_component_base,
+                                "contribution destination",
+                            )?;
+                            if result != proof.result_current_id
+                                || trace_factor(trace, row.exact_factor_id, "contribution")?
+                                    != proof.exact_factor
+                            {
+                                return Err(integrity(
+                                    "query-local contribution row disagrees with its cold identity",
+                                ));
+                            }
+                            let mut physical_parents = [
+                                current_id_by_component_base(
+                                    &bases,
+                                    row.parent0_component_base,
+                                    "contribution parent 0",
+                                )?,
+                                current_id_by_component_base(
+                                    &bases,
+                                    row.parent1_component_base_or_sentinel,
+                                    "contribution parent 1",
+                                )?,
+                            ];
+                            let mut semantic_parents = proof.parent_current_ids;
+                            physical_parents.sort_unstable();
+                            semantic_parents.sort_unstable();
+                            if physical_parents != semantic_parents
+                                || !matches!(
+                                    row.flags,
+                                    0 | DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+                                )
+                            {
+                                return Err(integrity(
+                                    "query-local contribution physical row is not its semantic binary row",
+                                ));
+                            }
+                            let identity = FamilyContributionIdentity {
+                                executor: *executor,
+                                key: remapped_contribution_key(proof, &local_to_union)?,
+                                exact_factor: proof.exact_factor,
+                                selector_domain_id: row.selector_domain_id,
+                            };
+                            if !local_definitions[result as usize]
+                                .contributions
+                                .insert(identity)
+                            {
+                                return Err(integrity(
+                                    "query-local current repeats an exact contribution row",
+                                ));
+                            }
+                            add(
+                                &mut census.dynamic_contribution_rows,
+                                1,
+                                "dynamic contribution rows",
+                            )?;
+                        }
+                        OnTheFlyTraceOperationV1::Finalization { key, row } => {
+                            let current_id = current_id_by_component_base(
+                                &bases,
+                                row.component_base,
+                                "finalization destination",
+                            )?;
+                            let identity = FamilyFinalizationIdentity {
+                                executor: *key,
+                                momentum: trace_momentum(
+                                    trace,
+                                    row.momentum_form_id,
+                                    "finalization",
+                                )?,
+                                component_count: row.component_count,
+                                exact_factor: trace_factor(
+                                    trace,
+                                    row.exact_factor_id,
+                                    "finalization",
+                                )?,
+                                selector_domain_id: row.selector_domain_id,
+                                flags: row.flags,
+                            };
+                            let definition = &mut local_definitions[current_id as usize];
+                            if u32::from(row.component_count) != definition.component_count
+                                || definition.finalization.replace(identity).is_some()
+                            {
+                                return Err(integrity(
+                                    "query-local current has an invalid finalization row",
+                                ));
+                            }
+                            add(
+                                &mut census.dynamic_finalization_rows,
+                                1,
+                                "dynamic finalization rows",
+                            )?;
+                        }
+                        OnTheFlyTraceOperationV1::Closure { key, row } => {
+                            if row.amplitude_destination_id != 0 {
+                                return Err(integrity(
+                                    "query-local closure does not target its sole amplitude",
+                                ));
+                            }
+                            let parent0 = current_id_by_component_base(
+                                &bases,
+                                row.parent0_component_base,
+                                "closure parent 0",
+                            )?;
+                            let parent1 = current_id_by_component_base(
+                                &bases,
+                                row.parent1_component_base_or_sentinel,
+                                "closure parent 1",
+                            )?;
+                            let component_start = row.component_factor_start as usize;
+                            let component_end = component_start
+                                .checked_add(usize::from(row.component_count))
+                                .ok_or_else(|| {
+                                    integrity("closure component-factor span overflows")
+                                })?;
+                            let component_factors = trace
+                                .exact_factors
+                                .get(component_start..component_end)
+                                .ok_or_else(|| {
+                                    integrity("closure component-factor span is absent")
+                                })?
+                                .to_vec()
+                                .into_boxed_slice();
+                            let amplitude_destination_id =
+                                checked_u32(query_index, "query-family amplitude destination ID")?;
+                            closure_definitions.push(FamilyClosureIdentity {
+                                seed_digest: trace.seed_digest,
+                                query_digest: trace.query_digest,
+                                stage: current_stage(&trace.current_keys[parent0 as usize])?
+                                    .max(current_stage(&trace.current_keys[parent1 as usize])?),
+                                executor: *key,
+                                parent_current_ids: [
+                                    local_to_union[parent0 as usize],
+                                    local_to_union[parent1 as usize],
+                                ],
+                                parent_momenta: [
+                                    trace_momentum(
+                                        trace,
+                                        row.parent0_momentum_form_id,
+                                        "closure parent 0",
+                                    )?,
+                                    trace_momentum(
+                                        trace,
+                                        row.parent1_momentum_form_id_or_sentinel,
+                                        "closure parent 1",
+                                    )?,
+                                ],
+                                exact_factor: trace_factor(trace, row.exact_factor_id, "closure")?,
+                                component_factors,
+                                component_count: row.component_count,
+                                selector_domain_id: row.selector_domain_id,
+                                proof_group_id: row.flags,
+                                amplitude_destination_id,
+                            });
+                            closure_groups.insert((
+                                trace.seed_digest,
+                                current_stage(&trace.current_keys[parent0 as usize])?
+                                    .max(current_stage(&trace.current_keys[parent1 as usize])?),
+                                prepared_executor_id(direct_catalog, *key)?,
+                            ));
+                            add(&mut census.dynamic_closure_rows, 1, "dynamic closure rows")?;
+                        }
+                    }
+                }
+                if contribution_proofs.next().is_some() {
+                    return Err(integrity(
+                        "query-local cold contribution identities outnumber direct rows",
+                    ));
+                }
+
+                for ((family_key, definition), union_id) in normalized_keys
+                    .into_iter()
+                    .zip(local_definitions)
+                    .zip(local_to_union)
+                {
+                    let key = &family_key.1;
+                    match key.node_kind() {
+                        RecurrenceNodeKind::Source
+                            if definition.source.is_none()
+                                || !definition.contributions.is_empty()
+                                || definition.finalization.is_some() =>
+                        {
+                            return Err(integrity(
+                                "query-family source current has a non-source definition",
+                            ));
+                        }
+                        RecurrenceNodeKind::Current
+                            if definition.source.is_some()
+                                || definition.contributions.is_empty() =>
+                        {
+                            return Err(integrity(
+                                "query-family non-source current has no contribution definition",
+                            ));
+                        }
+                        _ => {}
+                    }
+                    let record = union_currents.get_mut(&family_key).ok_or_else(|| {
+                        integrity("query-family normalized current lost its union identity")
+                    })?;
+                    if record.id != union_id {
+                        return Err(integrity(
+                            "query-family normalized current changed its union identity",
+                        ));
+                    }
+                    match record.definition.as_ref() {
+                        None => record.definition = Some(definition),
+                        Some(established) if established == &definition => {}
+                        Some(_) => {
+                            return Err(integrity(format!(
+                                "query-family semantic current {union_id} has conflicting definitions"
+                            )));
+                        }
+                    }
+                }
+                add(&mut census.query_count, 1, "query-family query count")?;
+                add(
+                    &mut census.union_amplitude_destination_count,
+                    1,
+                    "query-family amplitude destination count",
+                )?;
+            }
+            Ok(first_destination..census.query_count)
+        };
+        produce(&mut consume)?;
+    }
+
+    let Some((source_count, lorentz_component_count, parameter_count)) = layout else {
+        return Ok(None);
+    };
+    identity_hash.update(census.query_count.to_le_bytes());
+    let ordered_query_digest = SemanticDigest::new(identity_hash.finalize().into())?;
+
+    census.source_frame_partition_count =
+        checked_u32(seed_partitions.len(), "source-frame partition count")?;
+    let closure_queries = closure_definitions
+        .iter()
+        .map(|closure| closure.query_digest)
+        .collect::<BTreeSet<_>>();
+    let closure_destinations = closure_definitions
+        .iter()
+        .map(|closure| closure.amplitude_destination_id)
+        .collect::<BTreeSet<_>>();
+    if closure_queries != seen_queries
+        || closure_destinations.len() != census.query_count as usize
+        || closure_destinations
+            .iter()
+            .copied()
+            .enumerate()
+            .any(|(expected, actual)| actual as usize != expected)
+    {
+        return Err(integrity(
+            "query-family closures do not retain one distinct destination per requested query",
+        ));
+    }
+    for ((seed_digest, key), record) in &union_currents {
+        let definition = record
+            .definition
+            .as_ref()
+            .ok_or_else(|| integrity("query-family union current has no semantic definition"))?;
+        add(
+            &mut census.union_unique_current_component_count,
+            definition.component_count,
+            "union current component count",
+        )?;
+        let stage = u32::try_from(
+            key.support_source_slots()
+                .len()
+                .checked_sub(1)
+                .ok_or_else(|| integrity("query-family current has empty source support"))?,
+        )
+        .map_err(|_| invalid("query-family current stage exceeds u32"))?;
+        if let Some(source) = &definition.source {
+            add(&mut census.union_source_rows, 1, "union source rows")?;
+            source_groups.insert((
+                *seed_digest,
+                stage,
+                prepared_executor_id(direct_catalog, source.executor)?,
+            ));
+        }
+        for contribution in &definition.contributions {
+            add(
+                &mut census.union_contribution_rows,
+                1,
+                "union contribution rows",
+            )?;
+            contribution_groups.insert((
+                *seed_digest,
+                stage,
+                prepared_executor_id(direct_catalog, contribution.executor)?,
+            ));
+        }
+        if let Some(finalization) = &definition.finalization {
+            add(
+                &mut census.union_finalization_rows,
+                1,
+                "union finalization rows",
+            )?;
+            finalization_groups.insert((
+                *seed_digest,
+                stage,
+                prepared_executor_id(direct_catalog, finalization.executor)?,
+            ));
+        }
+    }
+    census.union_unique_current_count = checked_u32(union_currents.len(), "union current count")?;
+    census.union_closure_rows = census.dynamic_closure_rows;
+    census.union_source_executor_call_groups =
+        checked_u32(source_groups.len(), "union source executor groups")?;
+    census.union_contribution_executor_call_groups = checked_u32(
+        contribution_groups.len(),
+        "union contribution executor groups",
+    )?;
+    census.union_finalization_executor_call_groups = checked_u32(
+        finalization_groups.len(),
+        "union finalization executor groups",
+    )?;
+    census.union_closure_executor_call_groups =
+        checked_u32(closure_groups.len(), "union closure executor groups")?;
+    census.dynamic_source_calls = census.dynamic_source_rows;
+    census.dynamic_contribution_calls = census.dynamic_contribution_rows;
+    census.dynamic_finalization_calls = census.dynamic_finalization_rows;
+    census.dynamic_closure_calls = census.dynamic_closure_rows;
+
+    if census.projection_post_current_count != census.dynamic_current_occurrence_count
+        || census.projection_post_contribution_count != census.dynamic_contribution_rows
+        || census.projection_post_closure_count != census.dynamic_closure_rows
+        || census.union_unique_current_count > census.dynamic_current_occurrence_count
+        || census.union_unique_current_component_count
+            > census.dynamic_current_component_occurrence_count
+        || census.union_source_rows > census.dynamic_source_rows
+        || census.union_contribution_rows > census.dynamic_contribution_rows
+        || census.union_finalization_rows > census.dynamic_finalization_rows
+    {
+        return Err(integrity(
+            "query-family union census is inconsistent with its local traces",
+        ));
+    }
+    let family = materialize_query_family(
+        direct_catalog,
+        census,
+        source_count,
+        lorentz_component_count,
+        parameter_count,
+        union_currents,
+        closure_definitions,
+        #[cfg(any(test, feature = "on-the-fly-test-support"))]
+        observed_current_identities,
+    )?;
+    Ok(Some((family, ordered_query_digest)))
+}
+
+fn build_query_family_from_traces(
+    direct_catalog: &PreparedDirectExecutorCatalog,
+    selected: &[QueryFamilyTraceInput<'_>],
+) -> RusticolResult<OnTheFlyBuiltQueryFamilyV1> {
+    build_query_family_from_chunks(direct_catalog, |consumer| {
+        let destinations = consumer.push_chunk(selected)?;
+        if destinations.start != 0 || destinations.end as usize != selected.len() {
+            return Err(integrity(
+                "query-family one-shot destination range is inconsistent",
+            ));
+        }
+        Ok(())
+    })?
+    .map(|(family, _)| family)
+    .ok_or_else(|| invalid("query-family census requires at least one query"))
+}
+
+pub(crate) fn build_streamed_query_family_candidate_v1(
+    direct_catalog: &PreparedDirectExecutorCatalog,
+    produce: impl FnOnce(&mut dyn OnTheFlyQueryFamilyChunkConsumerV1) -> RusticolResult<()>,
+) -> RusticolResult<Option<OnTheFlyStreamedQueryFamilyCandidateV1>> {
+    let direct_catalog_digest = direct_catalog.direct_template_catalog_digest();
+    build_query_family_from_chunks(direct_catalog, produce).map(|candidate| {
+        candidate.map(
+            |(family, ordered_query_digest)| OnTheFlyStreamedQueryFamilyCandidateV1 {
+                identity: QueryFamilyCacheIdentityV1::Streamed {
+                    direct_catalog_digest,
+                    query_count: family.census.query_count,
+                    ordered_query_digest,
+                },
+                family,
+            },
+        )
+    })
+}
+
+#[allow(dead_code)] // Used only by the feature-only query-family census API.
+fn query_family_census_from_traces(
+    direct_catalog: &PreparedDirectExecutorCatalog,
+    selected: &[QueryFamilyTraceInput<'_>],
+) -> RusticolResult<OnTheFlyQueryFamilyCensusV1> {
+    Ok(build_query_family_from_traces(direct_catalog, selected)?.census)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn materialize_query_family(
+    direct_catalog: &PreparedDirectExecutorCatalog,
+    census: OnTheFlyQueryFamilyCensusV1,
+    source_count: u32,
+    lorentz_component_count: u16,
+    parameter_count: u32,
+    union_currents: BTreeMap<(SemanticDigest, CurrentCoreKey), FamilyUnionCurrentRecord>,
+    closure_definitions: Vec<FamilyClosureIdentity>,
+    #[cfg(any(test, feature = "on-the-fly-test-support"))] observed_current_identities: BTreeMap<
+        u32,
+        (SemanticDigest, u32, u32),
+    >,
+) -> RusticolResult<OnTheFlyBuiltQueryFamilyV1> {
+    type GroupKey = (SemanticDigest, u32);
+    let mut records = std::iter::repeat_with(|| None)
+        .take(union_currents.len())
+        .collect::<Vec<Option<(SemanticDigest, CurrentCoreKey, FamilyCurrentDefinition)>>>();
+    for (family_key, record) in union_currents {
+        let definition = record
+            .definition
+            .ok_or_else(|| integrity("query-family union current has no semantic definition"))?;
+        let slot = records
+            .get_mut(record.id as usize)
+            .ok_or_else(|| integrity("query-family union current ID is out of bounds"))?;
+        if slot
+            .replace((family_key.0, family_key.1, definition))
+            .is_some()
+        {
+            return Err(integrity(
+                "query-family union current ID repeats a definition",
+            ));
+        }
+    }
+    if records.iter().any(Option::is_none) {
+        return Err(integrity(
+            "query-family union current IDs are not dense zero-based",
+        ));
+    }
+    let mut component_bases = Vec::new();
+    let mut component_counts = Vec::new();
+    let mut stages = Vec::new();
+    let mut current_component_count = 0_u32;
+    component_bases
+        .try_reserve_exact(records.len())
+        .map_err(|error| {
+            invalid(format!(
+                "query-family component-base allocation failed: {error}"
+            ))
+        })?;
+    component_counts
+        .try_reserve_exact(records.len())
+        .map_err(|error| {
+            invalid(format!(
+                "query-family component-count allocation failed: {error}"
+            ))
+        })?;
+    stages
+        .try_reserve_exact(records.len())
+        .map_err(|error| invalid(format!("query-family stage allocation failed: {error}")))?;
+    for record in &records {
+        let (_, key, definition) = record
+            .as_ref()
+            .expect("validated dense query-family record");
+        component_bases.push(current_component_count);
+        component_counts.push(definition.component_count);
+        current_component_count = current_component_count
+            .checked_add(definition.component_count)
+            .ok_or_else(|| invalid("query-family current component count exceeds u32"))?;
+        stages.push(current_stage(key)?);
+    }
+    if current_component_count != census.union_unique_current_component_count {
+        return Err(integrity(
+            "query-family materialized current shape differs from its census",
+        ));
+    }
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    let observed_currents = component_bases
+        .iter()
+        .copied()
+        .enumerate()
+        .map(|(current_id, component_base)| {
+            let current_id = checked_u32(current_id, "observed query-family current ID")?;
+            let (semantic_digest, stage, component_count) = observed_current_identities
+                .get(&current_id)
+                .copied()
+                .ok_or_else(|| integrity("query-family observed current identity is absent"))?;
+            Ok(OnTheFlyFamilyObservedCurrentDescriptorV1 {
+                semantic_digest,
+                stage,
+                component_base,
+                component_count,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?
+        .into_boxed_slice();
+
+    let mut momentum_ids = BTreeMap::new();
+    let mut momentum_forms = Vec::new();
+    let mut factor_ids = BTreeMap::new();
+    let mut factor_block_ids = BTreeMap::new();
+    let mut exact_factors = Vec::new();
+    let mut source_groups = BTreeMap::<GroupKey, Vec<FamilySourceDraft>>::new();
+    let mut contribution_groups =
+        BTreeMap::<u32, BTreeMap<GroupKey, Vec<FamilyContributionDraft>>>::new();
+    let mut finalization_groups =
+        BTreeMap::<u32, BTreeMap<GroupKey, Vec<FamilyFinalizationDraft>>>::new();
+    let mut closure_groups = BTreeMap::<u32, BTreeMap<GroupKey, Vec<FamilyClosureDraft>>>::new();
+
+    // Consume semantic definitions as their compact executable drafts are
+    // produced, rather than retaining both complete representations until
+    // closure materialization.
+    for (current_id, record) in records.into_iter().enumerate() {
+        let (seed_digest, _key, definition) = record.expect("validated dense query-family record");
+        let current_id = checked_u32(current_id, "query-family current ID")?;
+        let stage = stages[current_id as usize];
+        let destination_component_base = component_bases[current_id as usize];
+        if let Some(source) = &definition.source {
+            if stage != 0 {
+                return Err(integrity(
+                    "query-family source current is not in support stage zero",
+                ));
+            }
+            let (direct_executor_id, parent_permutation) =
+                prepared_binding(direct_catalog, source.executor)?;
+            if parent_permutation != [0, 1] {
+                return Err(integrity(
+                    "query-family source executor has a parent permutation",
+                ));
+            }
+            let row = DirectSourceRow {
+                source_slot: source.source_slot,
+                destination_component_base,
+                momentum_form_id: intern_momentum(
+                    &mut momentum_ids,
+                    &mut momentum_forms,
+                    &source.momentum,
+                )?,
+                source_template_or_dispatch_domain: source.source_template_or_dispatch_domain,
+                spin_state_class: source.spin_state_class,
+                exact_factor_id: intern_factor(
+                    &mut factor_ids,
+                    &mut exact_factors,
+                    source.exact_factor,
+                )?,
+                selector_domain_id: source.selector_domain_id,
+            };
+            source_groups
+                .entry((seed_digest, direct_executor_id))
+                .or_default()
+                .push(FamilySourceDraft {
+                    seed_digest,
+                    stage,
+                    direct_executor_id,
+                    key: source.executor,
+                    row,
+                });
+        }
+        for contribution in &definition.contributions {
+            let parent_ids = contribution.key.parent_value_class_ids();
+            let parent_momenta = contribution.key.parent_momenta();
+            if parent_ids.len() != 2 || parent_momenta.len() != 2 {
+                return Err(integrity("query-family direct contribution is not binary"));
+            }
+            let mut parent_ids = [parent_ids[0], parent_ids[1]];
+            let mut parent_momenta = [&parent_momenta[0], &parent_momenta[1]];
+            for parent_id in parent_ids {
+                let parent_stage = stages
+                    .get(parent_id as usize)
+                    .copied()
+                    .ok_or_else(|| integrity("query-family contribution parent is absent"))?;
+                if parent_stage >= stage {
+                    return Err(integrity(
+                        "query-family contribution parent is not in an earlier support stage",
+                    ));
+                }
+            }
+            let (direct_executor_id, parent_permutation) =
+                prepared_binding(direct_catalog, contribution.executor)?;
+            match parent_permutation {
+                [0, 1] => {}
+                [1, 0] => {
+                    parent_ids.swap(0, 1);
+                    parent_momenta.swap(0, 1);
+                }
+                _ => {
+                    return Err(integrity(
+                        "query-family contribution has an invalid prepared parent permutation",
+                    ));
+                }
+            }
+            let row = DirectContributionRow {
+                parent0_component_base: component_bases[parent_ids[0] as usize],
+                parent1_component_base_or_sentinel: component_bases[parent_ids[1] as usize],
+                parent0_momentum_form_id: intern_momentum(
+                    &mut momentum_ids,
+                    &mut momentum_forms,
+                    parent_momenta[0],
+                )?,
+                parent1_momentum_form_id_or_sentinel: intern_momentum(
+                    &mut momentum_ids,
+                    &mut momentum_forms,
+                    parent_momenta[1],
+                )?,
+                destination_component_base,
+                exact_factor_id: intern_factor(
+                    &mut factor_ids,
+                    &mut exact_factors,
+                    contribution.exact_factor,
+                )?,
+                selector_domain_id: contribution.selector_domain_id,
+                flags: 0,
+            };
+            contribution_groups
+                .entry(stage)
+                .or_default()
+                .entry((seed_digest, direct_executor_id))
+                .or_default()
+                .push(FamilyContributionDraft {
+                    seed_digest,
+                    stage,
+                    destination_current_id: current_id,
+                    direct_executor_id,
+                    key: contribution.executor,
+                    parent_permutation,
+                    row,
+                });
+        }
+        if let Some(finalization) = &definition.finalization {
+            let (direct_executor_id, parent_permutation) =
+                prepared_binding(direct_catalog, finalization.executor)?;
+            if parent_permutation != [0, 1] {
+                return Err(integrity(
+                    "query-family finalization executor has a parent permutation",
+                ));
+            }
+            let row = DirectFinalizationRow {
+                component_base: destination_component_base,
+                component_count: finalization.component_count,
+                momentum_form_id: intern_momentum(
+                    &mut momentum_ids,
+                    &mut momentum_forms,
+                    &finalization.momentum,
+                )?,
+                exact_factor_id: intern_factor(
+                    &mut factor_ids,
+                    &mut exact_factors,
+                    finalization.exact_factor,
+                )?,
+                selector_domain_id: finalization.selector_domain_id,
+                flags: finalization.flags,
+            };
+            finalization_groups
+                .entry(stage)
+                .or_default()
+                .entry((seed_digest, direct_executor_id))
+                .or_default()
+                .push(FamilyFinalizationDraft {
+                    seed_digest,
+                    stage,
+                    direct_executor_id,
+                    key: finalization.executor,
+                    row,
+                });
+        }
+    }
+    for closure in closure_definitions {
+        let [parent0, parent1] = closure.parent_current_ids;
+        let parent0_count = component_counts
+            .get(parent0 as usize)
+            .copied()
+            .ok_or_else(|| integrity("query-family closure parent 0 is absent"))?;
+        let parent1_count = component_counts
+            .get(parent1 as usize)
+            .copied()
+            .ok_or_else(|| integrity("query-family closure parent 1 is absent"))?;
+        if parent0_count != u32::from(closure.component_count)
+            || parent1_count != u32::from(closure.component_count)
+            || closure.component_factors.len() != usize::from(closure.component_count)
+        {
+            return Err(integrity(
+                "query-family closure component shape disagrees with its parents",
+            ));
+        }
+        let (direct_executor_id, parent_permutation) =
+            prepared_binding(direct_catalog, closure.executor)?;
+        if parent_permutation != [0, 1] {
+            return Err(integrity(
+                "query-family closure executor has a parent permutation",
+            ));
+        }
+        let exact_factor_id =
+            intern_factor(&mut factor_ids, &mut exact_factors, closure.exact_factor)?;
+        let component_factor_start = intern_factor_block(
+            &mut factor_block_ids,
+            &mut factor_ids,
+            &mut exact_factors,
+            &closure.component_factors,
+        )?;
+        let stage = stages[parent0 as usize].max(stages[parent1 as usize]);
+        if stage != closure.stage {
+            return Err(integrity(
+                "query-family closure stage changed after current remapping",
+            ));
+        }
+        let row = DirectClosureRow {
+            parent0_component_base: component_bases[parent0 as usize],
+            parent1_component_base_or_sentinel: component_bases[parent1 as usize],
+            parent0_momentum_form_id: intern_momentum(
+                &mut momentum_ids,
+                &mut momentum_forms,
+                &closure.parent_momenta[0],
+            )?,
+            parent1_momentum_form_id_or_sentinel: intern_momentum(
+                &mut momentum_ids,
+                &mut momentum_forms,
+                &closure.parent_momenta[1],
+            )?,
+            amplitude_destination_id: closure.amplitude_destination_id,
+            exact_factor_id,
+            component_factor_start,
+            component_count: closure.component_count,
+            selector_domain_id: closure.selector_domain_id,
+            flags: closure.proof_group_id,
+        };
+        closure_groups
+            .entry(stage)
+            .or_default()
+            .entry((closure.seed_digest, direct_executor_id))
+            .or_default()
+            .push(FamilyClosureDraft {
+                seed_digest: closure.seed_digest,
+                stage,
+                direct_executor_id,
+                key: closure.executor,
+                row,
+            });
+    }
+
+    let row_groups = ordered_family_row_groups(
+        source_groups,
+        contribution_groups,
+        finalization_groups,
+        closure_groups,
+    )?;
+    validate_ordered_family_schedule(&row_groups)?;
+    let group_count = |role| row_groups.iter().filter(|group| group.role == role).count();
+    if checked_u32(
+        group_count(DirectExecutorRole::Source),
+        "source group count",
+    )? != census.union_source_executor_call_groups
+        || checked_u32(
+            group_count(DirectExecutorRole::Contribution),
+            "contribution group count",
+        )? != census.union_contribution_executor_call_groups
+        || checked_u32(
+            group_count(DirectExecutorRole::Finalization),
+            "finalization group count",
+        )? != census.union_finalization_executor_call_groups
+        || checked_u32(
+            group_count(DirectExecutorRole::Closure),
+            "closure group count",
+        )? != census.union_closure_executor_call_groups
+    {
+        return Err(integrity(
+            "query-family executable groups differ from the structural census",
+        ));
+    }
+
+    Ok(OnTheFlyBuiltQueryFamilyV1 {
+        census,
+        source_count,
+        lorentz_component_count,
+        parameter_count,
+        current_component_count,
+        amplitude_destination_count: census.union_amplitude_destination_count,
+        momentum_forms: momentum_forms.into_boxed_slice(),
+        exact_factors: exact_factors.into_boxed_slice(),
+        row_groups: row_groups.into_boxed_slice(),
+        #[cfg(any(test, feature = "on-the-fly-test-support"))]
+        observed_currents,
+    })
+}
+
+fn validate_ordered_family_schedule(groups: &[OnTheFlyFamilyRowGroupV1]) -> RusticolResult<()> {
+    let mut group_keys = BTreeSet::new();
+    let mut saw_non_source = false;
+    let mut saw_closure = false;
+    let mut current_stage = 0_u32;
+    let mut finalization_seen_in_stage = false;
+    for group in groups {
+        if group.rows.len() == 0
+            || !group_keys.insert((
+                group.seed_digest,
+                group.stage,
+                group.role,
+                group.direct_executor_id,
+            ))
+        {
+            return Err(integrity(
+                "query-family schedule has an empty or duplicate row group",
+            ));
+        }
+        match group.role {
+            DirectExecutorRole::Source => {
+                if saw_non_source || group.stage != 0 {
+                    return Err(integrity(
+                        "query-family sources are not the first stage-zero groups",
+                    ));
+                }
+            }
+            DirectExecutorRole::Contribution => {
+                saw_non_source = true;
+                if saw_closure || group.stage < current_stage {
+                    return Err(integrity(
+                        "query-family contribution stages are not topological",
+                    ));
+                }
+                if group.stage > current_stage {
+                    current_stage = group.stage;
+                    finalization_seen_in_stage = false;
+                }
+                if finalization_seen_in_stage {
+                    return Err(integrity(
+                        "query-family contribution follows finalization in one stage",
+                    ));
+                }
+            }
+            DirectExecutorRole::Finalization => {
+                saw_non_source = true;
+                if saw_closure || group.stage < current_stage {
+                    return Err(integrity(
+                        "query-family finalization stages are not topological",
+                    ));
+                }
+                if group.stage > current_stage {
+                    current_stage = group.stage;
+                }
+                finalization_seen_in_stage = true;
+            }
+            DirectExecutorRole::Closure => {
+                saw_non_source = true;
+                saw_closure = true;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn binding_members(
+    bindings: impl IntoIterator<Item = (OnTheFlyExecutorKeyV1, [u8; 2])>,
+) -> Box<[(OnTheFlyExecutorKeyV1, [u8; 2])]> {
+    bindings
+        .into_iter()
+        .collect::<BTreeSet<_>>()
+        .into_iter()
+        .collect::<Vec<_>>()
+        .into_boxed_slice()
+}
+
+fn ordered_family_row_groups(
+    source_groups: BTreeMap<(SemanticDigest, u32), Vec<FamilySourceDraft>>,
+    mut contribution_groups: BTreeMap<
+        u32,
+        BTreeMap<(SemanticDigest, u32), Vec<FamilyContributionDraft>>,
+    >,
+    mut finalization_groups: BTreeMap<
+        u32,
+        BTreeMap<(SemanticDigest, u32), Vec<FamilyFinalizationDraft>>,
+    >,
+    closure_groups: BTreeMap<u32, BTreeMap<(SemanticDigest, u32), Vec<FamilyClosureDraft>>>,
+) -> RusticolResult<Vec<OnTheFlyFamilyRowGroupV1>> {
+    let mut groups = Vec::new();
+    for ((seed_digest, direct_executor_id), mut drafts) in source_groups {
+        drafts.sort_by_key(|draft| {
+            (
+                draft.row.destination_component_base,
+                draft.row.source_slot,
+                draft.key,
+            )
+        });
+        let representative = drafts
+            .first()
+            .ok_or_else(|| integrity("query-family source group is empty"))?;
+        if drafts.iter().any(|draft| {
+            draft.seed_digest != seed_digest
+                || draft.stage != 0
+                || draft.direct_executor_id != direct_executor_id
+        }) {
+            return Err(integrity("query-family source group key is inconsistent"));
+        }
+        groups.push(OnTheFlyFamilyRowGroupV1 {
+            seed_digest,
+            stage: 0,
+            role: DirectExecutorRole::Source,
+            direct_executor_id,
+            representative_key: representative.key,
+            member_bindings: binding_members(drafts.iter().map(|draft| (draft.key, [0, 1]))),
+            rows: OnTheFlyFamilyRowsV1::Source(
+                drafts
+                    .into_iter()
+                    .map(|draft| draft.row)
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice(),
+            ),
+        });
+    }
+
+    let mut schedule_stages = contribution_groups
+        .keys()
+        .chain(finalization_groups.keys())
+        .copied()
+        .collect::<BTreeSet<_>>();
+    let mut initialized_destinations = BTreeSet::<u32>::new();
+    for stage in std::mem::take(&mut schedule_stages) {
+        for ((seed_digest, direct_executor_id), mut drafts) in
+            contribution_groups.remove(&stage).unwrap_or_default()
+        {
+            crate::recurrence::direct_lowering::order_contributions_for_runtime_fanout_by(
+                &mut drafts,
+                |draft| {
+                    (
+                        draft.stage,
+                        draft.direct_executor_id,
+                        draft.row,
+                        (draft.destination_current_id, draft.key),
+                    )
+                },
+            );
+            if drafts.iter().any(|draft| {
+                draft.seed_digest != seed_digest
+                    || draft.stage != stage
+                    || draft.direct_executor_id != direct_executor_id
+            }) {
+                return Err(integrity(
+                    "query-family contribution group key is inconsistent",
+                ));
+            }
+            for draft in &mut drafts {
+                draft.row.flags = if initialized_destinations.insert(draft.destination_current_id) {
+                    DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+                } else {
+                    0
+                };
+            }
+            let representative = drafts
+                .first()
+                .ok_or_else(|| integrity("query-family contribution group is empty"))?;
+            groups.push(OnTheFlyFamilyRowGroupV1 {
+                seed_digest,
+                stage,
+                role: DirectExecutorRole::Contribution,
+                direct_executor_id,
+                representative_key: representative.key,
+                member_bindings: binding_members(
+                    drafts
+                        .iter()
+                        .map(|draft| (draft.key, draft.parent_permutation)),
+                ),
+                rows: OnTheFlyFamilyRowsV1::Contribution(
+                    drafts
+                        .into_iter()
+                        .map(|draft| draft.row)
+                        .collect::<Vec<_>>()
+                        .into_boxed_slice(),
+                ),
+            });
+        }
+        for ((seed_digest, direct_executor_id), mut drafts) in
+            finalization_groups.remove(&stage).unwrap_or_default()
+        {
+            drafts.sort_by_key(|draft| (draft.row.component_base, draft.key));
+            let representative = drafts
+                .first()
+                .ok_or_else(|| integrity("query-family finalization group is empty"))?;
+            if drafts.iter().any(|draft| {
+                draft.seed_digest != seed_digest
+                    || draft.stage != stage
+                    || draft.direct_executor_id != direct_executor_id
+            }) {
+                return Err(integrity(
+                    "query-family finalization group key is inconsistent",
+                ));
+            }
+            groups.push(OnTheFlyFamilyRowGroupV1 {
+                seed_digest,
+                stage,
+                role: DirectExecutorRole::Finalization,
+                direct_executor_id,
+                representative_key: representative.key,
+                member_bindings: binding_members(drafts.iter().map(|draft| (draft.key, [0, 1]))),
+                rows: OnTheFlyFamilyRowsV1::Finalization(
+                    drafts
+                        .into_iter()
+                        .map(|draft| draft.row)
+                        .collect::<Vec<_>>()
+                        .into_boxed_slice(),
+                ),
+            });
+        }
+    }
+    if !contribution_groups.is_empty() || !finalization_groups.is_empty() {
+        return Err(integrity(
+            "query-family stage schedule did not consume every row group",
+        ));
+    }
+
+    for (stage, stage_groups) in closure_groups {
+        for ((seed_digest, direct_executor_id), mut drafts) in stage_groups {
+            drafts.sort_by_key(|draft| {
+                (
+                    draft.row.amplitude_destination_id,
+                    draft.row.parent0_component_base,
+                    draft.row.parent1_component_base_or_sentinel,
+                    draft.key,
+                )
+            });
+            let representative = drafts
+                .first()
+                .ok_or_else(|| integrity("query-family closure group is empty"))?;
+            if drafts.iter().any(|draft| {
+                draft.seed_digest != seed_digest
+                    || draft.stage != stage
+                    || draft.direct_executor_id != direct_executor_id
+            }) {
+                return Err(integrity("query-family closure group key is inconsistent"));
+            }
+            groups.push(OnTheFlyFamilyRowGroupV1 {
+                seed_digest,
+                stage,
+                role: DirectExecutorRole::Closure,
+                direct_executor_id,
+                representative_key: representative.key,
+                member_bindings: binding_members(drafts.iter().map(|draft| (draft.key, [0, 1]))),
+                rows: OnTheFlyFamilyRowsV1::Closure(
+                    drafts
+                        .into_iter()
+                        .map(|draft| draft.row)
+                        .collect::<Vec<_>>()
+                        .into_boxed_slice(),
+                ),
+            });
+        }
+    }
+    Ok(groups)
+}
+
+fn family_factor_parts(value: ExactComplexRational) -> RusticolResult<(f64, f64)> {
+    let real = value.real().numerator() as f64 / value.real().denominator() as f64;
+    let imag = value.imag().numerator() as f64 / value.imag().denominator() as f64;
+    if !real.is_finite() || !imag.is_finite() {
+        return Err(invalid(
+            "query-family exact factor cannot be represented as finite binary64",
+        ));
+    }
+    Ok((real, imag))
+}
+
+fn family_scalar_len(planes: u32, stride: u32, label: &str) -> RusticolResult<usize> {
+    usize::try_from(planes)
+        .ok()
+        .and_then(|planes| planes.checked_mul(stride as usize))
+        .ok_or_else(|| invalid(format!("query-family {label} scalar length exceeds usize")))
+}
+
+struct OnTheFlyFamilyWorkspaceV1 {
+    current_re: AlignedF64Buffer,
+    current_im: AlignedF64Buffer,
+    amplitude_re: AlignedF64Buffer,
+    amplitude_im: AlignedF64Buffer,
+    momenta: AlignedF64Buffer,
+    parameters_re: AlignedF64Buffer,
+    parameters_im: AlignedF64Buffer,
+    factors_re: AlignedF64Buffer,
+    factors_im: AlignedF64Buffer,
+    logical_point_capacity: u32,
+    active_point_count: u32,
+    source_count: u32,
+    momentum_form_count: u32,
+    lorentz_component_count: u16,
+    point_stride: u32,
+}
+
+impl OnTheFlyFamilyWorkspaceV1 {
+    fn new(
+        family: &OnTheFlyBuiltQueryFamilyV1,
+        logical_point_capacity: u32,
+        packed_singleton_capable: bool,
+    ) -> RusticolResult<Self> {
+        if family.source_count == 0
+            || family.lorentz_component_count == 0
+            || logical_point_capacity == 0
+            || family.momentum_forms.is_empty()
+            || family.exact_factors.is_empty()
+            || family.current_component_count == 0
+            || family.amplitude_destination_count == 0
+        {
+            return Err(integrity(
+                "query-family has an empty authenticated workspace shape",
+            ));
+        }
+        let point_stride = if logical_point_capacity == 1 && packed_singleton_capable {
+            1
+        } else {
+            checked_aligned_point_stride(logical_point_capacity)?
+        };
+        let current_len = family_scalar_len(
+            family.current_component_count,
+            point_stride,
+            "current arena",
+        )?;
+        let amplitude_len = family_scalar_len(
+            family.amplitude_destination_count,
+            point_stride,
+            "amplitude arena",
+        )?;
+        let momentum_form_count = checked_u32(
+            family.momentum_forms.len(),
+            "query-family momentum-form count",
+        )?;
+        let momentum_planes = momentum_form_count
+            .checked_mul(u32::from(family.lorentz_component_count))
+            .ok_or_else(|| invalid("query-family momentum plane count exceeds u32"))?;
+        let momentum_len = family_scalar_len(momentum_planes, point_stride, "momentum arena")?;
+        // The family is immutable after preparation. Check its momentum
+        // sources here rather than once per term and phase-space point on
+        // every warmed evaluation.
+        if family
+            .momentum_forms
+            .iter()
+            .flat_map(CanonicalMomentumLinearForm::terms)
+            .any(|term| term.source_slot >= family.source_count)
+        {
+            return Err(integrity(
+                "query-family momentum source slot is out of bounds",
+            ));
+        }
+        let mut factors_re =
+            AlignedF64Buffer::zeroed(family.exact_factors.len(), "query-family factor real")?;
+        let mut factors_im =
+            AlignedF64Buffer::zeroed(family.exact_factors.len(), "query-family factor imaginary")?;
+        for (index, factor) in family.exact_factors.iter().copied().enumerate() {
+            let (real, imag) = family_factor_parts(factor)?;
+            factors_re.as_mut_slice()[index] = real;
+            factors_im.as_mut_slice()[index] = imag;
+        }
+        let parameter_count = usize::try_from(family.parameter_count)
+            .map_err(|_| invalid("query-family parameter count exceeds usize"))?;
+        Ok(Self {
+            current_re: AlignedF64Buffer::zeroed(current_len, "query-family current real")?,
+            current_im: AlignedF64Buffer::zeroed(current_len, "query-family current imaginary")?,
+            amplitude_re: AlignedF64Buffer::zeroed(amplitude_len, "query-family amplitude real")?,
+            amplitude_im: AlignedF64Buffer::zeroed(
+                amplitude_len,
+                "query-family amplitude imaginary",
+            )?,
+            momenta: AlignedF64Buffer::zeroed(momentum_len, "query-family momenta")?,
+            parameters_re: AlignedF64Buffer::zeroed(
+                parameter_count,
+                "query-family parameter real",
+            )?,
+            parameters_im: AlignedF64Buffer::zeroed(
+                parameter_count,
+                "query-family parameter imaginary",
+            )?,
+            factors_re,
+            factors_im,
+            logical_point_capacity,
+            active_point_count: 0,
+            source_count: family.source_count,
+            momentum_form_count,
+            lorentz_component_count: family.lorentz_component_count,
+            point_stride,
+        })
+    }
+
+    fn refresh_inputs(
+        &mut self,
+        family: &OnTheFlyBuiltQueryFamilyV1,
+        external_momenta: &[f64],
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        self.active_point_count = 0;
+        if point_count == 0 || point_count > self.logical_point_capacity {
+            return Err(invalid(
+                "query-family active point count is outside the workspace",
+            ));
+        }
+        let expected = usize::try_from(self.source_count)
+            .ok()
+            .and_then(|sources| sources.checked_mul(usize::from(self.lorentz_component_count)))
+            .and_then(|planes| planes.checked_mul(point_count as usize))
+            .ok_or_else(|| invalid("query-family external momentum shape exceeds usize"))?;
+        if external_momenta.len() != expected {
+            return Err(invalid(format!(
+                "query-family received {} momentum scalars, expected {expected}",
+                external_momenta.len()
+            )));
+        }
+        let point_count = point_count as usize;
+        let lorentz_count = usize::from(self.lorentz_component_count);
+        let point_stride = self.point_stride as usize;
+        for (form, form_planes) in family.momentum_forms.iter().zip(
+            self.momenta
+                .as_mut_slice()
+                .chunks_exact_mut(lorentz_count * point_stride),
+        ) {
+            for (lorentz, plane) in form_planes.chunks_exact_mut(point_stride).enumerate() {
+                let output = &mut plane[..point_count];
+                let Some((first, remaining)) = form.terms().split_first() else {
+                    output.fill(0.0);
+                    continue;
+                };
+                let input_start =
+                    (first.source_slot as usize * lorentz_count + lorentz) * point_count;
+                let coefficient = f64::from(first.coefficient);
+                for (value, source) in output
+                    .iter_mut()
+                    .zip(&external_momenta[input_start..input_start + point_count])
+                {
+                    // Retain the original initial addition, including its
+                    // treatment of signed zero. Terms remain in their original
+                    // order; only independent phase-space points are grouped.
+                    *value = 0.0 + coefficient * source;
+                }
+                for term in remaining {
+                    let input_start =
+                        (term.source_slot as usize * lorentz_count + lorentz) * point_count;
+                    let coefficient = f64::from(term.coefficient);
+                    for (value, source) in output
+                        .iter_mut()
+                        .zip(&external_momenta[input_start..input_start + point_count])
+                    {
+                        *value += coefficient * source;
+                    }
+                }
+            }
+        }
+        // Source rows overwrite their complete destination and family lowering
+        // marks exactly the first contribution to every recursive current with
+        // INITIALIZE_DESTINATION. Finalization is in-place only after that
+        // write. Clearing the current arena here therefore duplicates writes
+        // on every warmed evaluation. Closures accumulate into amplitudes, so
+        // their active prefix must still start at zero.
+        for plane in 0..self.amplitude_re.len() / self.point_stride as usize {
+            let start = plane * self.point_stride as usize;
+            let end = start + point_count;
+            self.amplitude_re.as_mut_slice()[start..end].fill(0.0);
+            self.amplitude_im.as_mut_slice()[start..end].fill(0.0);
+        }
+        Ok(())
+    }
+
+    fn refresh_parameters(&mut self, parameters: &[(f64, f64)]) -> RusticolResult<()> {
+        self.active_point_count = 0;
+        if parameters.len() != self.parameters_re.len() {
+            return Err(invalid(format!(
+                "query-family received {} parameters, expected {}",
+                parameters.len(),
+                self.parameters_re.len()
+            )));
+        }
+        for (index, &(real, imag)) in parameters.iter().enumerate() {
+            if !real.is_finite() || !imag.is_finite() {
+                return Err(invalid("query-family parameter value is not finite"));
+            }
+            self.parameters_re.as_mut_slice()[index] = real;
+            self.parameters_im.as_mut_slice()[index] = imag;
+        }
+        Ok(())
+    }
+
+    fn raw_views(
+        &mut self,
+    ) -> RusticolResult<(
+        DirectArenaView,
+        DirectMomentumView,
+        DirectParameterView,
+        DirectFactorView,
+    )> {
+        let arena = DirectArenaView {
+            current_re: self.current_re.as_mut_ptr(),
+            current_im: self.current_im.as_mut_ptr(),
+            current_scalar_len: self.current_re.len() as u64,
+            amplitude_re: self.amplitude_re.as_mut_ptr(),
+            amplitude_im: self.amplitude_im.as_mut_ptr(),
+            amplitude_scalar_len: self.amplitude_re.len() as u64,
+            point_stride: self.point_stride,
+        };
+        let momenta = DirectMomentumView {
+            values: self.momenta.as_ptr(),
+            scalar_len: self.momenta.len() as u64,
+            form_count: self.momentum_form_count,
+            lorentz_component_count: self.lorentz_component_count,
+            point_stride: self.point_stride,
+        };
+        let parameters = DirectParameterView {
+            values_re: self.parameters_re.as_ptr(),
+            values_im: self.parameters_im.as_ptr(),
+            value_count: self.parameters_re.len() as u32,
+        };
+        let factors = DirectFactorView {
+            values_re: self.factors_re.as_ptr(),
+            values_im: self.factors_im.as_ptr(),
+            value_count: self.factors_re.len() as u32,
+        };
+        validate_direct_views(arena, momenta, parameters, factors)?;
+        Ok((arena, momenta, parameters, factors))
+    }
+
+    fn write_outputs(
+        &self,
+        destination_count: u32,
+        point_count: u32,
+        outputs: &mut [(f64, f64)],
+    ) -> RusticolResult<()> {
+        if self.active_point_count != point_count || destination_count == 0 {
+            return Err(integrity(
+                "query-family outputs do not belong to the last successful execution",
+            ));
+        }
+        Self::validate_output_shape(destination_count, point_count, outputs.len())?;
+        for destination in 0..destination_count {
+            for point in 0..point_count {
+                let arena_index = usize::try_from(destination)
+                    .ok()
+                    .and_then(|destination| destination.checked_mul(self.point_stride as usize))
+                    .and_then(|base| base.checked_add(point as usize))
+                    .ok_or_else(|| integrity("query-family amplitude index exceeds usize"))?;
+                let output_index = usize::try_from(destination)
+                    .ok()
+                    .and_then(|destination| destination.checked_mul(point_count as usize))
+                    .and_then(|base| base.checked_add(point as usize))
+                    .ok_or_else(|| integrity("query-family output index exceeds usize"))?;
+                outputs[output_index] = (
+                    *self
+                        .amplitude_re
+                        .as_slice()
+                        .get(arena_index)
+                        .ok_or_else(|| integrity("query-family amplitude real value is absent"))?,
+                    *self
+                        .amplitude_im
+                        .as_slice()
+                        .get(arena_index)
+                        .ok_or_else(|| {
+                            integrity("query-family amplitude imaginary value is absent")
+                        })?,
+                );
+            }
+        }
+        Ok(())
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    fn observed_currents(
+        &self,
+        descriptors: &[OnTheFlyFamilyObservedCurrentDescriptorV1],
+        point_index: u32,
+    ) -> RusticolResult<Vec<OnTheFlyFamilyObservedCurrentV1>> {
+        if point_index >= self.active_point_count {
+            return Err(invalid(
+                "query-family observed current point is outside the last successful execution",
+            ));
+        }
+        let stride = self.point_stride as usize;
+        let point_index = point_index as usize;
+        descriptors
+            .iter()
+            .map(|descriptor| {
+                let mut values = Vec::new();
+                values
+                    .try_reserve_exact(descriptor.component_count as usize)
+                    .map_err(|error| {
+                        invalid(format!(
+                            "query-family observed current allocation failed: {error}"
+                        ))
+                    })?;
+                for component in 0..descriptor.component_count as usize {
+                    let plane = descriptor.component_base as usize + component;
+                    let index = plane
+                        .checked_mul(stride)
+                        .and_then(|base| base.checked_add(point_index))
+                        .ok_or_else(|| {
+                            integrity("query-family observed current index exceeds usize")
+                        })?;
+                    values.push((
+                        *self.current_re.as_slice().get(index).ok_or_else(|| {
+                            integrity("query-family observed current real value is absent")
+                        })?,
+                        *self.current_im.as_slice().get(index).ok_or_else(|| {
+                            integrity("query-family observed current imaginary value is absent")
+                        })?,
+                    ));
+                }
+                Ok(OnTheFlyFamilyObservedCurrentV1 {
+                    semantic_digest: descriptor.semantic_digest,
+                    stage: descriptor.stage,
+                    values,
+                })
+            })
+            .collect()
+    }
+
+    fn validate_output_shape(
+        destination_count: u32,
+        point_count: u32,
+        output_len: usize,
+    ) -> RusticolResult<()> {
+        if destination_count == 0 || point_count == 0 {
+            return Err(integrity("query-family output shape is empty"));
+        }
+        let expected = usize::try_from(destination_count)
+            .ok()
+            .and_then(|destinations| destinations.checked_mul(point_count as usize))
+            .ok_or_else(|| invalid("query-family output shape exceeds usize"))?;
+        if output_len != expected {
+            return Err(invalid(format!(
+                "query-family output has {} complex values, expected {expected}",
+                output_len
+            )));
+        }
+        Ok(())
+    }
+}
+
+struct BoundOnTheFlyQueryFamilyV1 {
+    identity: QueryFamilyCacheIdentityV1,
+    strategy: RecurrenceStrategy,
+    // Single ownership keeps every row address stable for prepared descriptor caches.
+    family: OnTheFlyBuiltQueryFamilyV1,
+    workspace: OnTheFlyFamilyWorkspaceV1,
+    resolved_groups: Box<[ResolvedOnTheFlyExecutor]>,
+    /// Cold, process-bound conjunction over every executor used by this
+    /// family. It is reused when a retained workspace grows, so a packed
+    /// singleton can never survive a later batched activation.
+    packed_singleton_capable: bool,
+    interaction_program: DirectInteractionProgram,
+    singleton_fanout_program: DirectSingletonContributionFanoutProgram,
+    applied_parameter_version: u64,
+    descriptor_exposed: bool,
+}
+
+/// Runtime-private stable address of one successfully warmed family.  The
+/// generation prevents a handle retained above this executor from aliasing a
+/// different family after replacement or `clear_families` resets the arena.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct OnTheFlyQueryFamilyHandleV1 {
+    generation: u64,
+    index: usize,
+}
+
+pub(crate) struct OnTheFlyQueryFamilyExecutorV1<R: OnTheFlyPreparedExecutorResolver> {
+    // Field order is part of the ownership contract. Retained and pending rows
+    // must disappear before the resolver drops the prepared contexts that
+    // their copied handles address.
+    families: Vec<BoundOnTheFlyQueryFamilyV1>,
+    last_used: Option<usize>,
+    pending: Option<BoundOnTheFlyQueryFamilyV1>,
+    resolver: R,
+    parameter_state: Vec<(f64, f64)>,
+    parameter_version: u64,
+    family_generation: u64,
+}
+
+impl<R: OnTheFlyPreparedExecutorResolver> OnTheFlyQueryFamilyExecutorV1<R> {
+    pub(crate) const fn new(resolver: R) -> Self {
+        Self {
+            families: Vec::new(),
+            last_used: None,
+            pending: None,
+            resolver,
+            parameter_state: Vec::new(),
+            parameter_version: 0,
+            family_generation: 0,
+        }
+    }
+
+    pub(crate) const fn resolver(&self) -> &R {
+        &self.resolver
+    }
+
+    pub(crate) const fn resolver_mut(&mut self) -> &mut R {
+        &mut self.resolver
+    }
+
+    pub(crate) fn set_parameters(&mut self, parameters: &[(f64, f64)]) -> RusticolResult<()> {
+        if parameters
+            .iter()
+            .any(|(real, imag)| !real.is_finite() || !imag.is_finite())
+        {
+            return Err(invalid("query-family parameter value is not finite"));
+        }
+        if self.parameter_state == parameters {
+            return Ok(());
+        }
+        let mut replacement = Vec::new();
+        replacement
+            .try_reserve_exact(parameters.len())
+            .map_err(|error| {
+                invalid(format!(
+                    "query-family parameter-state allocation failed: {error}"
+                ))
+            })?;
+        replacement.extend_from_slice(parameters);
+        self.parameter_state = replacement;
+        self.parameter_version = self
+            .parameter_version
+            .checked_add(1)
+            .ok_or_else(|| invalid("query-family parameter version exceeds u64"))?;
+        Ok(())
+    }
+
+    /// Exact census of the row family selected by the last cold prepare.
+    pub(crate) fn prepared_census(&self) -> Option<OnTheFlyQueryFamilyCensusV1> {
+        self.pending
+            .as_ref()
+            .or_else(|| self.last_used.and_then(|index| self.families.get(index)))
+            .map(|family| family.family.census)
+    }
+
+    #[allow(dead_code)] // Test-support inspection seam.
+    pub(crate) const fn retained_family_count(&self) -> usize {
+        self.families.len()
+    }
+
+    pub(crate) fn active_retained_handle(&self) -> Option<OnTheFlyQueryFamilyHandleV1> {
+        self.pending.is_none().then_some(())?;
+        Some(OnTheFlyQueryFamilyHandleV1 {
+            generation: self.family_generation,
+            index: self.last_used?,
+        })
+    }
+
+    fn cache_identity(
+        direct_catalog: &PreparedDirectExecutorCatalog,
+        selected: &[QueryFamilyTraceInput<'_>],
+    ) -> QueryFamilyCacheIdentityV1 {
+        QueryFamilyCacheIdentityV1::Exact {
+            direct_catalog: direct_catalog.clone(),
+            queries: selected
+                .iter()
+                .map(|selected| {
+                    (
+                        selected.trace.seed_digest,
+                        selected.trace.query_digest,
+                        selected.trace.semantic_digest(),
+                        selected.projection,
+                    )
+                })
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+        }
+    }
+
+    fn matches_inputs(
+        family: &BoundOnTheFlyQueryFamilyV1,
+        direct_catalog: &PreparedDirectExecutorCatalog,
+        selected: &[QueryFamilyTraceInput<'_>],
+    ) -> bool {
+        let QueryFamilyCacheIdentityV1::Exact {
+            direct_catalog: cached_catalog,
+            queries,
+        } = &family.identity
+        else {
+            return false;
+        };
+        *cached_catalog == *direct_catalog
+            && queries.len() == selected.len()
+            && queries.iter().zip(selected).all(|(cached, selected)| {
+                *cached
+                    == (
+                        selected.trace.seed_digest,
+                        selected.trace.query_digest,
+                        selected.trace.semantic_digest(),
+                        selected.projection,
+                    )
+            })
+    }
+
+    fn bind_groups(
+        &self,
+        family: &OnTheFlyBuiltQueryFamilyV1,
+    ) -> RusticolResult<Box<[ResolvedOnTheFlyExecutor]>> {
+        family
+            .row_groups
+            .iter()
+            .map(|group| {
+                let mut all_members_are_packed_singleton_capable = true;
+                for &(key, expected_permutation) in group.member_bindings.iter() {
+                    let resolved = self.resolver.resolve(key)?;
+                    if resolved.direct_executor_id != group.direct_executor_id
+                        || resolved.handle.role() != group.role
+                        || resolved.parent_permutation != expected_permutation
+                    {
+                        return Err(integrity(
+                            "query-family prepared executor binding changed after row materialization",
+                        ));
+                    }
+                    all_members_are_packed_singleton_capable &=
+                        resolved.packed_singleton_capable;
+                }
+                let mut resolved = self.resolver.resolve(group.representative_key)?;
+                if resolved.direct_executor_id != group.direct_executor_id
+                    || resolved.handle.role() != group.role
+                {
+                    return Err(integrity(
+                        "query-family representative executor differs from its row group",
+                    ));
+                }
+                resolved.packed_singleton_capable &=
+                    all_members_are_packed_singleton_capable;
+                Ok(resolved)
+            })
+            .collect::<RusticolResult<Vec<_>>>()
+            .map(Vec::into_boxed_slice)
+    }
+
+    fn resolved_groups_are_packed_singleton_capable(
+        family: &OnTheFlyBuiltQueryFamilyV1,
+        resolved_groups: &[ResolvedOnTheFlyExecutor],
+    ) -> bool {
+        !family.row_groups.is_empty()
+            && family.row_groups.len() == resolved_groups.len()
+            && family
+                .row_groups
+                .iter()
+                .zip(resolved_groups)
+                .all(|(group, resolved)| {
+                    resolved.packed_singleton_capable
+                        && resolved.direct_executor_id == group.direct_executor_id
+                        && resolved.handle.role() == group.role
+                })
+    }
+
+    fn direct_group_views<'a>(
+        family: &'a OnTheFlyBuiltQueryFamilyV1,
+        resolved_groups: &[ResolvedOnTheFlyExecutor],
+    ) -> RusticolResult<(Vec<DirectInteractionGroupView<'a>>, usize)> {
+        if family.row_groups.len() != resolved_groups.len() {
+            return Err(integrity(
+                "query-family direct-program binding has the wrong group count",
+            ));
+        }
+        let mut groups = Vec::with_capacity(family.row_groups.len());
+        let mut contribution_row_count = 0_usize;
+        for (group, resolved) in family.row_groups.iter().zip(resolved_groups) {
+            groups.push(match &group.rows {
+                OnTheFlyFamilyRowsV1::Contribution(rows) => {
+                    contribution_row_count = contribution_row_count
+                        .checked_add(rows.len())
+                        .ok_or_else(|| invalid("query-family contribution count exceeds usize"))?;
+                    DirectInteractionGroupView::contribution(
+                        group.stage,
+                        group.direct_executor_id,
+                        Some(resolved.handle),
+                        resolved.interaction_capability,
+                        rows,
+                    )
+                }
+                OnTheFlyFamilyRowsV1::Closure(rows) => DirectInteractionGroupView::closure(
+                    group.stage,
+                    group.direct_executor_id,
+                    resolved.handle,
+                    rows,
+                ),
+                OnTheFlyFamilyRowsV1::Source(_) | OnTheFlyFamilyRowsV1::Finalization(_) => {
+                    DirectInteractionGroupView::other(
+                        group.stage,
+                        group.role,
+                        group.direct_executor_id,
+                        Some(resolved.handle),
+                    )
+                }
+            });
+        }
+        Ok((groups, contribution_row_count))
+    }
+
+    fn bind_interaction_program(
+        family: &OnTheFlyBuiltQueryFamilyV1,
+        resolved_groups: &[ResolvedOnTheFlyExecutor],
+        strategy: RecurrenceStrategy,
+    ) -> RusticolResult<DirectInteractionProgram> {
+        let (groups, contribution_row_count) = Self::direct_group_views(family, resolved_groups)?;
+        // OTF families do not persist authenticated liveness descriptors.
+        // Empty currents deliberately keep the terminal scalarization rewrite
+        // disabled while sharing the base color/ATV interaction program.
+        DirectInteractionProgram::build(DirectInteractionScheduleView::new(
+            strategy,
+            &groups,
+            &[],
+            contribution_row_count,
+        ))
+    }
+
+    fn bind_singleton_fanout_program(
+        family: &OnTheFlyBuiltQueryFamilyV1,
+        resolved_groups: &[ResolvedOnTheFlyExecutor],
+    ) -> RusticolResult<DirectSingletonContributionFanoutProgram> {
+        let (groups, _) = Self::direct_group_views(family, resolved_groups)?;
+        DirectSingletonContributionFanoutProgram::build(
+            &groups,
+            family.current_component_count,
+            checked_u32(
+                family.momentum_forms.len(),
+                "query-family momentum-form count",
+            )?,
+            family.parameter_count,
+            checked_u32(
+                family.exact_factors.len(),
+                "query-family exact-factor count",
+            )?,
+        )
+    }
+
+    fn invalidate_exposed_row_tables(&mut self) -> RusticolResult<()> {
+        if !self.families.iter().any(|family| family.descriptor_exposed)
+            && !self
+                .pending
+                .as_ref()
+                .is_some_and(|family| family.descriptor_exposed)
+        {
+            return Ok(());
+        }
+        self.resolver.invalidate_row_tables()?;
+        for family in &mut self.families {
+            family.descriptor_exposed = false;
+        }
+        if let Some(pending) = &mut self.pending {
+            pending.descriptor_exposed = false;
+        }
+        Ok(())
+    }
+
+    /// Drop every retained selector family while keeping the loaded executor
+    /// pool and parameter state. Descriptor invalidation happens first so no
+    /// prepared kernel can retain a pointer into the rows being dropped.
+    pub(crate) fn clear_families(&mut self) -> RusticolResult<()> {
+        let next_generation = self
+            .family_generation
+            .checked_add(1)
+            .ok_or_else(|| invalid("query-family generation exceeds u64"))?;
+        self.invalidate_exposed_row_tables()?;
+        self.pending = None;
+        self.last_used = None;
+        self.families.clear();
+        self.family_generation = next_generation;
+        Ok(())
+    }
+
+    /// Abandon a cold candidate without disturbing the last successfully
+    /// retained family. Any exposed candidate rows are invalidated before
+    /// their owner is dropped.
+    pub(crate) fn discard_pending_family(&mut self) -> RusticolResult<()> {
+        if self.pending.is_none() {
+            return Ok(());
+        }
+        self.invalidate_exposed_row_tables()?;
+        self.pending = None;
+        Ok(())
+    }
+
+    fn commit_pending_family(&mut self) -> RusticolResult<()> {
+        let next_generation = self
+            .family_generation
+            .checked_add(1)
+            .ok_or_else(|| invalid("query-family generation exceeds u64"))?;
+        // A different family was invalidated before the candidate became
+        // pending. Be defensive if an exposed retained owner is nevertheless
+        // present: invalidate it before replacement drops its rows.
+        if self.families.iter().any(|family| family.descriptor_exposed) {
+            self.invalidate_exposed_row_tables()?;
+        }
+        let candidate = self
+            .pending
+            .take()
+            .ok_or_else(|| integrity("query-family commit has no pending candidate"))?;
+        self.families.clear();
+        self.families.push(candidate);
+        self.last_used = Some(0);
+        self.family_generation = next_generation;
+        Ok(())
+    }
+
+    fn activate_retained_index(
+        &mut self,
+        index: usize,
+        logical_point_capacity: u32,
+    ) -> RusticolResult<bool> {
+        let replacement = self
+            .families
+            .get(index)
+            .ok_or_else(|| integrity("query-family handle index is absent"))?
+            .workspace
+            .logical_point_capacity
+            .lt(&logical_point_capacity)
+            .then(|| {
+                OnTheFlyFamilyWorkspaceV1::new(
+                    &self.families[index].family,
+                    logical_point_capacity,
+                    self.families[index].packed_singleton_capable,
+                )
+            })
+            .transpose()?;
+        if self
+            .pending
+            .as_ref()
+            .is_some_and(|pending| pending.descriptor_exposed)
+            || replacement.is_some() && self.families[index].descriptor_exposed
+            || self.last_used != Some(index)
+                && self.families.iter().any(|family| family.descriptor_exposed)
+        {
+            self.invalidate_exposed_row_tables()?;
+        }
+        self.pending = None;
+        self.last_used = Some(index);
+        if let Some(replacement) = replacement {
+            let family = self
+                .families
+                .get_mut(index)
+                .expect("validated query-family handle disappeared");
+            family.workspace = replacement;
+            family.applied_parameter_version = u64::MAX;
+        }
+        Ok(true)
+    }
+
+    pub(crate) fn activate_retained_family(
+        &mut self,
+        handle: OnTheFlyQueryFamilyHandleV1,
+        logical_point_capacity: u32,
+    ) -> RusticolResult<bool> {
+        if handle.generation != self.family_generation {
+            return Err(integrity(
+                "query-family handle belongs to a replaced or cleared arena",
+            ));
+        }
+        self.activate_retained_index(handle.index, logical_point_capacity)
+    }
+
+    pub(crate) fn resize_active_family(
+        &mut self,
+        logical_point_capacity: u32,
+    ) -> RusticolResult<bool> {
+        if let Some(pending) = self.pending.as_ref() {
+            if logical_point_capacity <= pending.workspace.logical_point_capacity {
+                return Ok(false);
+            }
+            let replacement = OnTheFlyFamilyWorkspaceV1::new(
+                &pending.family,
+                logical_point_capacity,
+                pending.packed_singleton_capable,
+            )?;
+            self.invalidate_exposed_row_tables()?;
+            let pending = self
+                .pending
+                .as_mut()
+                .expect("query-family pending state disappeared");
+            pending.workspace = replacement;
+            pending.applied_parameter_version = u64::MAX;
+            return Ok(false);
+        }
+        let index = self
+            .last_used
+            .ok_or_else(|| invalid("query-family resize requires a cold prepare"))?;
+        self.activate_retained_index(index, logical_point_capacity)
+    }
+
+    /// Cold family selection/binding. This must remain outside warmed timing.
+    pub(crate) fn prepare(
+        &mut self,
+        direct_catalog: &PreparedDirectExecutorCatalog,
+        selected: &[QueryFamilyTraceInput<'_>],
+        logical_point_capacity: u32,
+    ) -> RusticolResult<bool> {
+        // The only retained family is the complete cache. A selector evicted
+        // by a later successful cold execution is deliberately rebuilt.
+        let retained = self.last_used.filter(|&index| {
+            self.families
+                .get(index)
+                .is_some_and(|family| Self::matches_inputs(family, direct_catalog, selected))
+        });
+        if let Some(index) = retained {
+            return self.activate_retained_index(index, logical_point_capacity);
+        }
+
+        let identity = Self::cache_identity(direct_catalog, selected);
+        if self
+            .pending
+            .as_ref()
+            .is_some_and(|pending| pending.identity == identity)
+        {
+            let replacement = self
+                .pending
+                .as_ref()
+                .filter(|pending| logical_point_capacity > pending.workspace.logical_point_capacity)
+                .map(|pending| {
+                    OnTheFlyFamilyWorkspaceV1::new(
+                        &pending.family,
+                        logical_point_capacity,
+                        pending.packed_singleton_capable,
+                    )
+                })
+                .transpose()?;
+            if let Some(replacement) = replacement {
+                self.invalidate_exposed_row_tables()?;
+                let pending = self
+                    .pending
+                    .as_mut()
+                    .expect("matching pending query family disappeared");
+                pending.workspace = replacement;
+                pending.applied_parameter_version = u64::MAX;
+            }
+            return Ok(false);
+        }
+
+        // A superseded or failed candidate must never accumulate alongside a
+        // new one. This leaves the last successful family and its handle valid.
+        self.discard_pending_family()?;
+
+        let family = build_query_family_from_traces(direct_catalog, selected)?;
+        if family.census.source_frame_partition_count != 1 {
+            return Err(invalid(
+                "executable query families currently require one compact source frame",
+            ));
+        }
+        let resolved_groups = self.bind_groups(&family)?;
+        let packed_singleton_capable =
+            Self::resolved_groups_are_packed_singleton_capable(&family, &resolved_groups);
+        let workspace = OnTheFlyFamilyWorkspaceV1::new(
+            &family,
+            logical_point_capacity,
+            packed_singleton_capable,
+        )?;
+        let interaction_program = Self::bind_interaction_program(
+            &family,
+            &resolved_groups,
+            RecurrenceStrategy::TopologyReplay,
+        )?;
+        let singleton_fanout_program =
+            Self::bind_singleton_fanout_program(&family, &resolved_groups)?;
+        if self.families.capacity() == 0 {
+            self.families.try_reserve_exact(1).map_err(|error| {
+                invalid(format!(
+                    "query-family retained-family allocation failed: {error}"
+                ))
+            })?;
+        }
+        let candidate = BoundOnTheFlyQueryFamilyV1 {
+            identity,
+            strategy: RecurrenceStrategy::TopologyReplay,
+            family,
+            workspace,
+            resolved_groups,
+            packed_singleton_capable,
+            interaction_program,
+            singleton_fanout_program,
+            applied_parameter_version: u64::MAX,
+            descriptor_exposed: false,
+        };
+        // Keep every old pointer owner alive until both the replacement rows
+        // and workspace exist, then clear every prepared SymJIT row table
+        // before exposing the pending candidate.
+        self.invalidate_exposed_row_tables()?;
+        self.pending = Some(candidate);
+        Ok(false)
+    }
+
+    /// Install one bounded-memory streamed candidate.  Unlike the LC seam,
+    /// its cache identity is a compact ordered digest produced together with
+    /// the materialized family, so no H x S query identity table is retained.
+    pub(crate) fn prepare_streamed_candidate(
+        &mut self,
+        candidate: OnTheFlyStreamedQueryFamilyCandidateV1,
+        logical_point_capacity: u32,
+    ) -> RusticolResult<bool> {
+        let OnTheFlyStreamedQueryFamilyCandidateV1 { identity, family } = candidate;
+        if let Some(index) = self.last_used.filter(|&index| {
+            self.families
+                .get(index)
+                .is_some_and(|family| family.identity == identity)
+        }) {
+            return self.activate_retained_index(index, logical_point_capacity);
+        }
+        if self
+            .pending
+            .as_ref()
+            .is_some_and(|pending| pending.identity == identity)
+        {
+            let replacement = self
+                .pending
+                .as_ref()
+                .filter(|pending| logical_point_capacity > pending.workspace.logical_point_capacity)
+                .map(|pending| {
+                    OnTheFlyFamilyWorkspaceV1::new(
+                        &pending.family,
+                        logical_point_capacity,
+                        pending.packed_singleton_capable,
+                    )
+                })
+                .transpose()?;
+            if let Some(replacement) = replacement {
+                self.invalidate_exposed_row_tables()?;
+                let pending = self
+                    .pending
+                    .as_mut()
+                    .expect("matching streamed query family disappeared");
+                pending.workspace = replacement;
+                pending.applied_parameter_version = u64::MAX;
+            }
+            return Ok(false);
+        }
+
+        self.discard_pending_family()?;
+        if family.census.source_frame_partition_count != 1 {
+            return Err(invalid(
+                "executable query families currently require one compact source frame",
+            ));
+        }
+        let resolved_groups = self.bind_groups(&family)?;
+        let packed_singleton_capable =
+            Self::resolved_groups_are_packed_singleton_capable(&family, &resolved_groups);
+        let workspace = OnTheFlyFamilyWorkspaceV1::new(
+            &family,
+            logical_point_capacity,
+            packed_singleton_capable,
+        )?;
+        let interaction_program = Self::bind_interaction_program(
+            &family,
+            &resolved_groups,
+            RecurrenceStrategy::ContractedColorUnion,
+        )?;
+        let singleton_fanout_program =
+            Self::bind_singleton_fanout_program(&family, &resolved_groups)?;
+        if self.families.capacity() == 0 {
+            self.families.try_reserve_exact(1).map_err(|error| {
+                invalid(format!(
+                    "query-family retained-family allocation failed: {error}"
+                ))
+            })?;
+        }
+        let candidate = BoundOnTheFlyQueryFamilyV1 {
+            identity,
+            strategy: RecurrenceStrategy::ContractedColorUnion,
+            family,
+            workspace,
+            resolved_groups,
+            packed_singleton_capable,
+            interaction_program,
+            singleton_fanout_program,
+            applied_parameter_version: u64::MAX,
+            descriptor_exposed: false,
+        };
+        self.invalidate_exposed_row_tables()?;
+        self.pending = Some(candidate);
+        Ok(false)
+    }
+
+    /// Allocation-free warmed execution after one cold [`Self::prepare`] call.
+    pub(crate) fn execute_into(
+        &mut self,
+        external_momenta: &[f64],
+        point_count: u32,
+        outputs: &mut [(f64, f64)],
+    ) -> RusticolResult<OnTheFlyQueryFamilyExecutionReportV1> {
+        let cache_hit = self.pending.is_none();
+        let mut report = self.execute_into_impl(
+            external_momenta,
+            point_count,
+            outputs,
+            OnTheFlyQueryFamilyExecutionReportV1::default(),
+            |report, role, row_count| match role {
+                DirectExecutorRole::Source => {
+                    add(&mut report.source_calls, 1, "executed source calls")?;
+                    add(&mut report.source_rows, row_count, "executed source rows")
+                }
+                DirectExecutorRole::Contribution => {
+                    add(
+                        &mut report.contribution_calls,
+                        1,
+                        "executed contribution calls",
+                    )?;
+                    add(
+                        &mut report.contribution_rows,
+                        row_count,
+                        "executed contribution rows",
+                    )
+                }
+                DirectExecutorRole::Finalization => {
+                    add(
+                        &mut report.finalization_calls,
+                        1,
+                        "executed finalization calls",
+                    )?;
+                    add(
+                        &mut report.finalization_rows,
+                        row_count,
+                        "executed finalization rows",
+                    )
+                }
+                DirectExecutorRole::Closure => {
+                    add(&mut report.closure_calls, 1, "executed closure calls")?;
+                    add(&mut report.closure_rows, row_count, "executed closure rows")
+                }
+            },
+        )?;
+        report.cache_hit = cache_hit;
+        Ok(report)
+    }
+
+    /// Allocation-free warmed execution without diagnostic report counters.
+    pub(crate) fn execute_into_unprofiled(
+        &mut self,
+        external_momenta: &[f64],
+        point_count: u32,
+        outputs: &mut [(f64, f64)],
+    ) -> RusticolResult<()> {
+        self.execute_into_impl(external_momenta, point_count, outputs, (), |_, _, _| Ok(()))
+    }
+
+    fn execute_into_impl<Report, RecordGroup>(
+        &mut self,
+        external_momenta: &[f64],
+        point_count: u32,
+        outputs: &mut [(f64, f64)],
+        report: Report,
+        record_group: RecordGroup,
+    ) -> RusticolResult<Report>
+    where
+        RecordGroup: FnMut(&mut Report, DirectExecutorRole, u32) -> RusticolResult<()>,
+    {
+        let pending = self.pending.is_some();
+        let result = (|| {
+            let family = if pending {
+                self.pending
+                    .as_mut()
+                    .expect("pending query family disappeared before execution")
+            } else {
+                self.last_used
+                    .and_then(|index| self.families.get_mut(index))
+                    .ok_or_else(|| invalid("query-family execute requires a cold prepare"))?
+            };
+            OnTheFlyFamilyWorkspaceV1::validate_output_shape(
+                family.family.amplitude_destination_count,
+                point_count,
+                outputs.len(),
+            )?;
+            if family.applied_parameter_version != self.parameter_version {
+                family.workspace.refresh_parameters(&self.parameter_state)?;
+                family.applied_parameter_version = self.parameter_version;
+            }
+            family
+                .workspace
+                .refresh_inputs(&family.family, external_momenta, point_count)?;
+            family.descriptor_exposed = true;
+            let report = execute_bound_family(family, point_count, report, record_group)?;
+            family.workspace.write_outputs(
+                family.family.amplitude_destination_count,
+                point_count,
+                outputs,
+            )?;
+            Ok(report)
+        })();
+
+        match result {
+            Ok(report) => {
+                if pending {
+                    self.commit_pending_family()?;
+                }
+                Ok(report)
+            }
+            Err(error) => {
+                if pending {
+                    self.discard_pending_family()?;
+                }
+                Err(error)
+            }
+        }
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    pub(crate) fn observed_currents(
+        &self,
+        point_index: u32,
+    ) -> RusticolResult<Vec<OnTheFlyFamilyObservedCurrentV1>> {
+        let family = self
+            .pending
+            .as_ref()
+            .or_else(|| self.last_used.and_then(|index| self.families.get(index)))
+            .ok_or_else(|| invalid("query-family observation requires a prepared execution"))?;
+        family
+            .workspace
+            .observed_currents(&family.family.observed_currents, point_index)
+    }
+}
+
+impl<R: OnTheFlyPreparedExecutorResolver> Drop for OnTheFlyQueryFamilyExecutorV1<R> {
+    fn drop(&mut self) {
+        if self.invalidate_exposed_row_tables().is_ok() {
+            return;
+        }
+        // Fail closed if a prepared context is unexpectedly borrowed during
+        // teardown: leaked private storage is safer than dangling row tables.
+        for family in self.families.drain(..) {
+            if family.descriptor_exposed {
+                std::mem::forget(family);
+            }
+        }
+        if self
+            .pending
+            .as_ref()
+            .is_some_and(|family| family.descriptor_exposed)
+            && let Some(pending) = self.pending.take()
+        {
+            std::mem::forget(pending);
+        }
+    }
+}
+
+fn execute_bound_family<Report, RecordGroup>(
+    cached: &mut BoundOnTheFlyQueryFamilyV1,
+    point_count: u32,
+    mut report: Report,
+    mut record_group: RecordGroup,
+) -> RusticolResult<Report>
+where
+    RecordGroup: FnMut(&mut Report, DirectExecutorRole, u32) -> RusticolResult<()>,
+{
+    clear_direct_executor_error_detail();
+    let (arena, momenta, parameters, factors) = cached.workspace.raw_views()?;
+    for (group_index, (group, resolved)) in cached
+        .family
+        .row_groups
+        .iter()
+        .zip(cached.resolved_groups.iter().copied())
+        .enumerate()
+    {
+        let row_count = checked_u32(group.rows.len(), "query-family row-group count")?;
+        record_group(&mut report, group.role, row_count)?;
+        // The native bundle intentionally specializes point zero. Preserve
+        // the ordinary authenticated row path for every batched execution.
+        if point_count == 1 {
+            match cached.interaction_program.action(group_index) {
+                DirectInteractionGroupAction::Normal => {
+                    if let OnTheFlyFamilyRowsV1::Contribution(rows) = &group.rows
+                        && cached.singleton_fanout_program.execute_group(
+                            group_index,
+                            rows,
+                            arena,
+                            momenta,
+                            parameters,
+                            factors,
+                            point_count,
+                        )?
+                    {
+                        continue;
+                    }
+                }
+                DirectInteractionGroupAction::Consumed => continue,
+                DirectInteractionGroupAction::Execute(stage_index) => {
+                    cached.interaction_program.execute::<false>(
+                        stage_index,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                    )?;
+                    continue;
+                }
+            }
+        }
+        let status: c_int = unsafe {
+            match (&group.rows, resolved.handle) {
+                (
+                    OnTheFlyFamilyRowsV1::Source(rows),
+                    DirectExecutorHandle::Source { call, context },
+                ) => call(
+                    context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    rows.as_ptr(),
+                    row_count,
+                    point_count,
+                ),
+                (
+                    OnTheFlyFamilyRowsV1::Contribution(rows),
+                    DirectExecutorHandle::Contribution { call, context },
+                ) => call(
+                    context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    rows.as_ptr(),
+                    row_count,
+                    point_count,
+                ),
+                (
+                    OnTheFlyFamilyRowsV1::Finalization(rows),
+                    DirectExecutorHandle::Finalization { call, context },
+                ) => call(
+                    context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    rows.as_ptr(),
+                    row_count,
+                    point_count,
+                ),
+                (
+                    OnTheFlyFamilyRowsV1::Closure(rows),
+                    DirectExecutorHandle::Closure { call, context },
+                ) => call(
+                    context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    rows.as_ptr(),
+                    row_count,
+                    point_count,
+                ),
+                _ => {
+                    return Err(integrity(
+                        "query-family resolved handle differs from its row storage",
+                    ));
+                }
+            }
+        };
+        crate::recurrence::direct_backend::check_status(
+            group.role,
+            group.direct_executor_id,
+            status,
+        )?;
+    }
+    cached.workspace.active_point_count = point_count;
+    Ok(report)
+}
+
+/// Build exactly the requested LC queries with the existing query-local
+/// machinery, then compute their cold structural union census.
+#[doc(hidden)]
+#[cfg(feature = "on-the-fly-test-support")]
+pub fn on_the_fly_query_family_census_v1(
+    authenticated: &crate::recurrence::AuthenticatedRecurrenceBuilderInput,
+    direct_catalog: &PreparedDirectExecutorCatalog,
+    queries: &[(u32, Vec<i32>)],
+    enable_projection: bool,
+) -> RusticolResult<OnTheFlyQueryFamilyCensusV1> {
+    let selected = queries
+        .iter()
+        .map(|(flow, helicities)| {
+            super::test_support::build_on_the_fly_selected_trace_v1(
+                authenticated,
+                direct_catalog,
+                *flow,
+                helicities,
+                enable_projection,
+            )
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    for selected_query in &selected {
+        if selected_query.seed.semantic_digest() != selected_query.trace.seed_digest
+            || selected_query.query.semantic_digest() != selected_query.trace.query_digest
+        {
+            return Err(integrity(
+                "selected query-family trace is detached from its compact inputs",
+            ));
+        }
+    }
+    let traces = selected
+        .iter()
+        .map(|selected_query| QueryFamilyTraceInput {
+            trace: &selected_query.trace,
+            projection: selected_query.projection,
+        })
+        .collect::<Vec<_>>();
+    Ok(build_query_family_from_traces(direct_catalog, &traces)?.census)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::direct_backend::{
+        DIRECT_STATUS_OK, DirectContributionExecutionMetadata, DirectContributionFanoutBatch,
+        DirectContributionFanoutExecutorHandle, DirectInteractionBundleBatch,
+        DirectInteractionExecutorContexts, DirectInteractionIntrinsicKind,
+    };
+    use crate::recurrence::direct_plan::DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE;
+    use crate::recurrence::{
+        ExactRational, PreparedDirectExecutorBinding, PreparedDirectExecutorCatalog,
+    };
+    use std::cell::{Cell, RefCell};
+    use std::ffi::c_void;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    const TEST_STATUS_BOUNDS: c_int = 2;
+    const TEST_STATUS_FAILED: c_int = 4;
+
+    #[derive(Default)]
+    struct ProbeState {
+        calls: RefCell<Vec<(DirectExecutorRole, usize, u32)>>,
+        fail_role: Cell<Option<DirectExecutorRole>>,
+        record_failure_detail: Cell<bool>,
+        invalidations: Cell<u32>,
+    }
+
+    #[derive(Default)]
+    struct InteractionPathCensus {
+        native_calls: AtomicU64,
+        raw_calls: AtomicU64,
+        raw_rows: AtomicU64,
+    }
+
+    #[derive(Default)]
+    struct FanoutPathCensus {
+        native_calls: AtomicU64,
+        native_runs: AtomicU64,
+        raw_calls: AtomicU64,
+        raw_rows: AtomicU64,
+    }
+
+    unsafe fn execute_fanout_test_rows(
+        arena: DirectArenaView,
+        factors: DirectFactorView,
+        rows: &[DirectContributionRow],
+        point_count: u32,
+    ) -> c_int {
+        let stride = arena.point_stride as usize;
+        for row in rows {
+            if row.exact_factor_id >= factors.value_count {
+                return TEST_STATUS_BOUNDS;
+            }
+            let factor = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+            for point in 0..point_count as usize {
+                let parent0 = row.parent0_component_base as usize * stride + point;
+                let parent1 = row.parent1_component_base_or_sentinel as usize * stride + point;
+                let destination = row.destination_component_base as usize * stride + point;
+                if parent0 >= arena.current_scalar_len as usize
+                    || parent1 >= arena.current_scalar_len as usize
+                    || destination >= arena.current_scalar_len as usize
+                {
+                    return TEST_STATUS_BOUNDS;
+                }
+                let value = unsafe {
+                    (10.0 * *arena.current_re.add(parent0) + *arena.current_re.add(parent1))
+                        * factor
+                };
+                unsafe {
+                    if row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0 {
+                        *arena.current_re.add(destination) = value;
+                        *arena.current_im.add(destination) = 0.0;
+                    } else {
+                        *arena.current_re.add(destination) += value;
+                    }
+                }
+            }
+        }
+        DIRECT_STATUS_OK
+    }
+
+    unsafe extern "C" fn fanout_test_raw(
+        context: *const c_void,
+        arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        factors: DirectFactorView,
+        rows: *const DirectContributionRow,
+        row_count: u32,
+        point_count: u32,
+    ) -> c_int {
+        let census = unsafe { &*context.cast::<FanoutPathCensus>() };
+        census.raw_calls.fetch_add(1, Ordering::Relaxed);
+        census
+            .raw_rows
+            .fetch_add(u64::from(row_count), Ordering::Relaxed);
+        let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+        unsafe { execute_fanout_test_rows(arena, factors, rows, point_count) }
+    }
+
+    unsafe fn fanout_test_native(
+        context: *const c_void,
+        arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        factors: DirectFactorView,
+        batch: DirectContributionFanoutBatch<'_>,
+    ) -> RusticolResult<()> {
+        let census = unsafe { &*context.cast::<FanoutPathCensus>() };
+        census.native_calls.fetch_add(1, Ordering::Relaxed);
+        census
+            .native_runs
+            .fetch_add(batch.runs.len() as u64, Ordering::Relaxed);
+        for run in batch.runs {
+            let start = run.row_start as usize;
+            let end = start + run.row_count as usize;
+            let rows = batch
+                .rows
+                .get(start..end)
+                .ok_or_else(|| integrity("test native fanout run is outside its row group"))?;
+            let representative = *rows
+                .first()
+                .ok_or_else(|| integrity("test native fanout run is empty"))?;
+            let stride = arena.point_stride as usize;
+            let parent0 = representative.parent0_component_base as usize * stride;
+            let parent1 = representative.parent1_component_base_or_sentinel as usize * stride;
+            let value =
+                unsafe { 10.0 * *arena.current_re.add(parent0) + *arena.current_re.add(parent1) };
+            let bundle_start = run.bundle_start as usize;
+            let bundle_end = bundle_start + run.bundle_count as usize;
+            for bundle in batch
+                .bundles
+                .get(bundle_start..bundle_end)
+                .ok_or_else(|| integrity("test native fanout bundle range is out of bounds"))?
+            {
+                let factor = unsafe {
+                    *factors
+                        .values_re
+                        .add(bundle.effective_factor_id_or_sentinel as usize)
+                };
+                let start = bundle.row_start as usize;
+                let end = start + bundle.row_count as usize;
+                for row in batch
+                    .rows
+                    .get(start..end)
+                    .ok_or_else(|| integrity("test native fanout rows are out of bounds"))?
+                {
+                    let destination = row.destination_component_base as usize * stride;
+                    unsafe {
+                        if row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0 {
+                            *arena.current_re.add(destination) = value * factor;
+                            *arena.current_im.add(destination) = 0.0;
+                        } else {
+                            *arena.current_re.add(destination) += value * factor;
+                        }
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    unsafe extern "C" fn interaction_raw_contributions(
+        context: *const c_void,
+        _arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        _rows: *const DirectContributionRow,
+        row_count: u32,
+        _point_count: u32,
+    ) -> c_int {
+        let census = unsafe { &*context.cast::<InteractionPathCensus>() };
+        census.raw_calls.fetch_add(1, Ordering::Relaxed);
+        census
+            .raw_rows
+            .fetch_add(u64::from(row_count), Ordering::Relaxed);
+        DIRECT_STATUS_OK
+    }
+
+    unsafe fn interaction_fanout_unreachable(
+        _context: *const c_void,
+        _arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        _batch: DirectContributionFanoutBatch<'_>,
+    ) -> RusticolResult<()> {
+        panic!("OTF interaction dispatch unexpectedly used generic contribution fanout")
+    }
+
+    unsafe fn count_otf_interaction(
+        contexts: DirectInteractionExecutorContexts,
+        _arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        batch: DirectInteractionBundleBatch<'_>,
+    ) -> RusticolResult<()> {
+        assert_eq!(contexts.color, contexts.antisymmetric_tensor_vector);
+        assert_eq!(batch.anchors.len(), 1);
+        assert_eq!(batch.outputs.len(), 2);
+        assert!(batch.atv_before_color);
+        let census = unsafe { &*contexts.color.cast::<InteractionPathCensus>() };
+        census.native_calls.fetch_add(1, Ordering::Relaxed);
+        Ok(())
+    }
+
+    impl ProbeState {
+        fn record(&self, role: DirectExecutorRole, rows: *const c_void, row_count: u32) -> bool {
+            self.calls
+                .borrow_mut()
+                .push((role, rows as usize, row_count));
+            let failed = self.fail_role.get() == Some(role);
+            if failed && self.record_failure_detail.get() {
+                crate::recurrence::direct_backend::record_direct_executor_error_detail(
+                    crate::RusticolError::integrity(format!("probe {role:?} first failure detail")),
+                );
+                crate::recurrence::direct_backend::record_direct_executor_error_detail(
+                    crate::RusticolError::internal(
+                        "later probe detail must not replace the first failure",
+                    ),
+                );
+            }
+            failed
+        }
+    }
+
+    unsafe fn probe_state<'a>(context: *const c_void) -> &'a ProbeState {
+        unsafe { &*context.cast::<ProbeState>() }
+    }
+
+    unsafe extern "C" fn probe_sources(
+        context: *const c_void,
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        factors: DirectFactorView,
+        rows: *const DirectSourceRow,
+        row_count: u32,
+        point_count: u32,
+    ) -> c_int {
+        let state = unsafe { probe_state(context) };
+        if state.record(DirectExecutorRole::Source, rows.cast(), row_count) {
+            return TEST_STATUS_FAILED;
+        }
+        let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+        for row in rows {
+            if row.exact_factor_id >= factors.value_count {
+                return TEST_STATUS_BOUNDS;
+            }
+            let factor = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+            for point in 0..point_count as usize {
+                let source = row.momentum_form_id as usize
+                    * momenta.lorentz_component_count as usize
+                    * momenta.point_stride as usize
+                    + point;
+                let destination =
+                    row.destination_component_base as usize * arena.point_stride as usize + point;
+                if source >= momenta.scalar_len as usize
+                    || destination >= arena.current_scalar_len as usize
+                {
+                    return TEST_STATUS_BOUNDS;
+                }
+                unsafe {
+                    *arena.current_re.add(destination) = *momenta.values.add(source) * factor;
+                    *arena.current_im.add(destination) = 0.0;
+                }
+            }
+        }
+        crate::recurrence::direct_backend::DIRECT_STATUS_OK
+    }
+
+    unsafe extern "C" fn probe_contributions(
+        context: *const c_void,
+        arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        factors: DirectFactorView,
+        rows: *const DirectContributionRow,
+        row_count: u32,
+        point_count: u32,
+    ) -> c_int {
+        let state = unsafe { probe_state(context) };
+        if state.record(DirectExecutorRole::Contribution, rows.cast(), row_count) {
+            return TEST_STATUS_FAILED;
+        }
+        let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+        for row in rows {
+            if row.exact_factor_id >= factors.value_count {
+                return TEST_STATUS_BOUNDS;
+            }
+            let factor = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+            for point in 0..point_count as usize {
+                let parent0 =
+                    row.parent0_component_base as usize * arena.point_stride as usize + point;
+                let parent1 = row.parent1_component_base_or_sentinel as usize
+                    * arena.point_stride as usize
+                    + point;
+                let destination =
+                    row.destination_component_base as usize * arena.point_stride as usize + point;
+                if parent0 >= arena.current_scalar_len as usize
+                    || parent1 >= arena.current_scalar_len as usize
+                    || destination >= arena.current_scalar_len as usize
+                {
+                    return TEST_STATUS_BOUNDS;
+                }
+                let contribution = unsafe {
+                    (10.0 * *arena.current_re.add(parent0) + *arena.current_re.add(parent1))
+                        * factor
+                };
+                unsafe {
+                    if row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0 {
+                        *arena.current_re.add(destination) = contribution;
+                        *arena.current_im.add(destination) = 0.0;
+                    } else {
+                        *arena.current_re.add(destination) += contribution;
+                    }
+                }
+            }
+        }
+        crate::recurrence::direct_backend::DIRECT_STATUS_OK
+    }
+
+    unsafe extern "C" fn probe_finalizations(
+        context: *const c_void,
+        arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+        factors: DirectFactorView,
+        rows: *const DirectFinalizationRow,
+        row_count: u32,
+        point_count: u32,
+    ) -> c_int {
+        let state = unsafe { probe_state(context) };
+        if state.record(DirectExecutorRole::Finalization, rows.cast(), row_count) {
+            return TEST_STATUS_FAILED;
+        }
+        let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+        let parameter = if parameters.value_count == 0 {
+            1.0
+        } else {
+            unsafe { *parameters.values_re }
+        };
+        for row in rows {
+            if row.exact_factor_id >= factors.value_count {
+                return TEST_STATUS_BOUNDS;
+            }
+            let factor = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+            for component in 0..usize::from(row.component_count) {
+                for point in 0..point_count as usize {
+                    let destination = (row.component_base as usize + component)
+                        * arena.point_stride as usize
+                        + point;
+                    if destination >= arena.current_scalar_len as usize {
+                        return TEST_STATUS_BOUNDS;
+                    }
+                    unsafe {
+                        *arena.current_re.add(destination) *= factor * parameter;
+                        *arena.current_im.add(destination) *= factor * parameter;
+                    }
+                }
+            }
+        }
+        crate::recurrence::direct_backend::DIRECT_STATUS_OK
+    }
+
+    unsafe extern "C" fn probe_closures(
+        context: *const c_void,
+        arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        factors: DirectFactorView,
+        rows: *const DirectClosureRow,
+        row_count: u32,
+        point_count: u32,
+    ) -> c_int {
+        let state = unsafe { probe_state(context) };
+        if state.record(DirectExecutorRole::Closure, rows.cast(), row_count) {
+            return TEST_STATUS_FAILED;
+        }
+        let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+        for row in rows {
+            let factor_end = match row
+                .component_factor_start
+                .checked_add(u32::from(row.component_count))
+            {
+                Some(value) => value,
+                None => return TEST_STATUS_BOUNDS,
+            };
+            if row.exact_factor_id >= factors.value_count || factor_end > factors.value_count {
+                return TEST_STATUS_BOUNDS;
+            }
+            let common = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+            for component in 0..usize::from(row.component_count) {
+                let component_factor = unsafe {
+                    *factors
+                        .values_re
+                        .add(row.component_factor_start as usize + component)
+                };
+                for point in 0..point_count as usize {
+                    let parent0 = (row.parent0_component_base as usize + component)
+                        * arena.point_stride as usize
+                        + point;
+                    let parent1 = (row.parent1_component_base_or_sentinel as usize + component)
+                        * arena.point_stride as usize
+                        + point;
+                    let destination =
+                        row.amplitude_destination_id as usize * arena.point_stride as usize + point;
+                    if parent0 >= arena.current_scalar_len as usize
+                        || parent1 >= arena.current_scalar_len as usize
+                        || destination >= arena.amplitude_scalar_len as usize
+                    {
+                        return TEST_STATUS_BOUNDS;
+                    }
+                    unsafe {
+                        *arena.amplitude_re.add(destination) += *arena.current_re.add(parent0)
+                            * *arena.current_re.add(parent1)
+                            * common
+                            * component_factor;
+                    }
+                }
+            }
+        }
+        crate::recurrence::direct_backend::DIRECT_STATUS_OK
+    }
+
+    struct ProbeResolver {
+        catalog: PreparedDirectExecutorCatalog,
+        state: Box<ProbeState>,
+        packed_singleton_capabilities: [bool; 4],
+    }
+
+    impl ProbeResolver {
+        fn new(catalog: PreparedDirectExecutorCatalog) -> Self {
+            Self {
+                catalog,
+                state: Box::new(ProbeState::default()),
+                packed_singleton_capabilities: [false; 4],
+            }
+        }
+
+        fn packed_singleton(catalog: PreparedDirectExecutorCatalog) -> Self {
+            Self {
+                catalog,
+                state: Box::new(ProbeState::default()),
+                packed_singleton_capabilities: [true; 4],
+            }
+        }
+
+        fn role_index(role: DirectExecutorRole) -> usize {
+            match role {
+                DirectExecutorRole::Source => 0,
+                DirectExecutorRole::Contribution => 1,
+                DirectExecutorRole::Finalization => 2,
+                DirectExecutorRole::Closure => 3,
+            }
+        }
+
+        fn disable_packed_singleton_role(&mut self, role: DirectExecutorRole) {
+            self.packed_singleton_capabilities[Self::role_index(role)] = false;
+        }
+    }
+
+    impl OnTheFlyPreparedExecutorResolver for ProbeResolver {
+        fn resolve(&self, key: OnTheFlyExecutorKeyV1) -> RusticolResult<ResolvedOnTheFlyExecutor> {
+            let (direct_executor_id, parent_permutation) = prepared_binding(&self.catalog, key)?;
+            let context = (&*self.state as *const ProbeState).cast::<c_void>();
+            let handle = match key.role() {
+                DirectExecutorRole::Source => DirectExecutorHandle::Source {
+                    call: probe_sources,
+                    context,
+                },
+                DirectExecutorRole::Contribution => DirectExecutorHandle::Contribution {
+                    call: probe_contributions,
+                    context,
+                },
+                DirectExecutorRole::Finalization => DirectExecutorHandle::Finalization {
+                    call: probe_finalizations,
+                    context,
+                },
+                DirectExecutorRole::Closure => DirectExecutorHandle::Closure {
+                    call: probe_closures,
+                    context,
+                },
+            };
+            Ok(ResolvedOnTheFlyExecutor {
+                direct_executor_id,
+                handle,
+                parent_permutation,
+                packed_singleton_capable: self.packed_singleton_capabilities
+                    [Self::role_index(key.role())],
+                interaction_capability: None,
+            })
+        }
+
+        fn invalidate_row_tables(&self) -> RusticolResult<()> {
+            self.state
+                .invalidations
+                .set(self.state.invalidations.get() + 1);
+            Ok(())
+        }
+    }
+
+    fn factor(numerator: i128) -> ExactComplexRational {
+        ExactComplexRational::new(
+            ExactRational::new(numerator, 1).unwrap(),
+            ExactRational::ZERO,
+        )
+    }
+
+    fn direct_catalog() -> PreparedDirectExecutorCatalog {
+        let digest = SemanticDigest::new([0x71; 32]).unwrap();
+        PreparedDirectExecutorCatalog::new(
+            digest,
+            vec![
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Source, 0, 0),
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Source, 1, 0),
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Contribution, 2, 1),
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Finalization, 3, 2),
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Closure, 4, 3),
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Contribution, 5, 4),
+                PreparedDirectExecutorBinding::evaluator_with_parent_permutation(
+                    DirectExecutorRole::Contribution,
+                    6,
+                    1,
+                    [1, 0],
+                ),
+            ],
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn family_contributions_use_direct_fanout_order_before_first_write_flags() {
+        let seed_digest = SemanticDigest::new([0x31; 32]).unwrap();
+        let catalog_digest = SemanticDigest::new([0x32; 32]).unwrap();
+        let operation_digest = SemanticDigest::new([0x33; 32]).unwrap();
+        let binding_digest = SemanticDigest::new([0x34; 32]).unwrap();
+        let executor_key = OnTheFlyExecutorKeyV1::PreparedOperation {
+            direct_catalog_digest: catalog_digest,
+            role: DirectExecutorRole::Contribution,
+            operation_kind: OnTheFlyOperationKindV1::Transition,
+            operation_id: 7,
+            operation_semantic_digest: operation_digest,
+            evaluator_binding_id: 9,
+            evaluator_binding_semantic_digest: binding_digest,
+        };
+        let row = |parents: [u32; 2], destination: u32, factor: u32| DirectContributionRow {
+            parent0_component_base: parents[0],
+            parent1_component_base_or_sentinel: parents[1],
+            parent0_momentum_form_id: parents[0] / 4,
+            parent1_momentum_form_id_or_sentinel: parents[1] / 4,
+            destination_component_base: destination,
+            exact_factor_id: factor,
+            selector_domain_id: 0,
+            flags: 0,
+        };
+        // A and C are reusable input classes; B is deliberately interleaved
+        // in the cold semantic input to catch destination-major ordering.
+        let specs = [
+            ([0, 4], 20, 1),
+            ([8, 12], 24, 2),
+            ([0, 4], 28, 1),
+            ([16, 20], 20, 4),
+            ([16, 20], 24, 0),
+        ];
+        let drafts = specs
+            .iter()
+            .map(|&(parents, destination, factor)| FamilyContributionDraft {
+                seed_digest,
+                stage: 1,
+                destination_current_id: destination,
+                direct_executor_id: 2,
+                key: executor_key,
+                parent_permutation: [0, 1],
+                row: row(parents, destination, factor),
+            })
+            .collect::<Vec<_>>();
+        let expected_multiset = drafts
+            .iter()
+            .map(|draft| {
+                let row = draft.row;
+                (
+                    row.parent0_component_base,
+                    row.parent1_component_base_or_sentinel,
+                    row.parent0_momentum_form_id,
+                    row.parent1_momentum_form_id_or_sentinel,
+                    row.destination_component_base,
+                    row.exact_factor_id,
+                    row.selector_domain_id,
+                )
+            })
+            .collect::<BTreeSet<_>>();
+        let mut contribution_groups = BTreeMap::new();
+        contribution_groups.insert(1, BTreeMap::from([((seed_digest, 2), drafts)]));
+        let groups = ordered_family_row_groups(
+            BTreeMap::new(),
+            contribution_groups,
+            BTreeMap::new(),
+            BTreeMap::new(),
+        )
+        .unwrap();
+        let [group] = groups.as_slice() else {
+            panic!("expected one contribution row group");
+        };
+        let OnTheFlyFamilyRowsV1::Contribution(rows) = &group.rows else {
+            panic!("expected contribution rows");
+        };
+        let actual_multiset = rows
+            .iter()
+            .map(|row| {
+                (
+                    row.parent0_component_base,
+                    row.parent1_component_base_or_sentinel,
+                    row.parent0_momentum_form_id,
+                    row.parent1_momentum_form_id_or_sentinel,
+                    row.destination_component_base,
+                    row.exact_factor_id,
+                    row.selector_domain_id,
+                )
+            })
+            .collect::<BTreeSet<_>>();
+        assert_eq!(actual_multiset, expected_multiset);
+        assert_eq!(
+            rows.iter()
+                .map(|row| (
+                    row.parent0_component_base,
+                    row.destination_component_base,
+                    row.exact_factor_id,
+                ))
+                .collect::<Vec<_>>(),
+            vec![(0, 20, 1), (0, 28, 1), (16, 24, 0), (16, 20, 4), (8, 24, 2)],
+        );
+
+        let input_key = |row: &DirectContributionRow| {
+            (
+                row.selector_domain_id,
+                row.parent0_component_base,
+                row.parent1_component_base_or_sentinel,
+                row.parent0_momentum_form_id,
+                row.parent1_momentum_form_id_or_sentinel,
+            )
+        };
+        let mut positions = BTreeMap::<_, Vec<usize>>::new();
+        for (index, row) in rows.iter().enumerate() {
+            positions.entry(input_key(row)).or_default().push(index);
+        }
+        for indices in positions.values() {
+            assert_eq!(indices.last().unwrap() - indices[0] + 1, indices.len());
+        }
+        let repeated_end = positions
+            .values()
+            .filter(|indices| indices.len() > 1)
+            .flat_map(|indices| indices.iter().copied())
+            .max()
+            .unwrap();
+        let singleton_start = positions
+            .values()
+            .filter(|indices| indices.len() == 1)
+            .map(|indices| indices[0])
+            .min()
+            .unwrap();
+        assert!(repeated_end < singleton_start);
+
+        let mut initialize_counts = BTreeMap::<u32, usize>::new();
+        let mut seen_destinations = BTreeSet::new();
+        for row in rows {
+            let initializes = row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0;
+            assert_eq!(
+                initializes,
+                seen_destinations.insert(row.destination_component_base)
+            );
+            if initializes {
+                *initialize_counts
+                    .entry(row.destination_component_base)
+                    .or_default() += 1;
+            }
+        }
+        assert_eq!(
+            initialize_counts,
+            BTreeMap::from([(20, 1), (24, 1), (28, 1)])
+        );
+    }
+
+    #[test]
+    fn otf_singleton_fanout_preserves_values_and_batched_raw_fallback() {
+        let catalog = direct_catalog();
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let mut family = build_query_family_from_traces(
+            &catalog,
+            &[QueryFamilyTraceInput {
+                trace: &trace,
+                projection,
+            }],
+        )
+        .unwrap();
+        let seed_digest = trace.seed_digest;
+        let key = OnTheFlyExecutorKeyV1::PreparedOperation {
+            direct_catalog_digest: catalog.direct_template_catalog_digest(),
+            role: DirectExecutorRole::Contribution,
+            operation_kind: OnTheFlyOperationKindV1::Transition,
+            operation_id: 0,
+            operation_semantic_digest: SemanticDigest::new([0x82; 32]).unwrap(),
+            evaluator_binding_id: 1,
+            evaluator_binding_semantic_digest: SemanticDigest::new([0x83; 32]).unwrap(),
+        };
+        let row = |parents: [u32; 2], destination_component_base, exact_factor_id| {
+            DirectContributionRow {
+                parent0_component_base: parents[0],
+                parent1_component_base_or_sentinel: parents[1],
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 0,
+                destination_component_base,
+                exact_factor_id,
+                selector_domain_id: 0,
+                flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            }
+        };
+        family.source_count = 1;
+        family.lorentz_component_count = 1;
+        family.parameter_count = 0;
+        family.current_component_count = 5;
+        family.amplitude_destination_count = 1;
+        family.momentum_forms = vec![
+            CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                source_slot: 0,
+                coefficient: 1,
+            }])
+            .unwrap(),
+        ]
+        .into_boxed_slice();
+        family.exact_factors = vec![factor(1), factor(2)].into_boxed_slice();
+        family.row_groups = vec![OnTheFlyFamilyRowGroupV1 {
+            seed_digest,
+            stage: 1,
+            role: DirectExecutorRole::Contribution,
+            direct_executor_id: 2,
+            representative_key: key,
+            member_bindings: vec![(key, [0, 1])].into_boxed_slice(),
+            rows: OnTheFlyFamilyRowsV1::Contribution(
+                vec![row([0, 1], 2, 0), row([0, 1], 3, 1), row([1, 0], 4, 0)].into_boxed_slice(),
+            ),
+        }]
+        .into_boxed_slice();
+        #[cfg(any(test, feature = "on-the-fly-test-support"))]
+        {
+            family.observed_currents = Box::new([]);
+        }
+
+        let census = FanoutPathCensus::default();
+        let context = (&census as *const FanoutPathCensus).cast::<c_void>();
+        let raw_handle = DirectExecutorHandle::Contribution {
+            call: fanout_test_raw,
+            context,
+        };
+        let capability = DirectInteractionExecutorCapability::new(
+            raw_handle,
+            DirectContributionExecutionMetadata::new(1, false).unwrap(),
+            DirectContributionFanoutExecutorHandle {
+                call: fanout_test_native,
+                context,
+                destination_component_count: 1,
+                parent_component_counts: [1, 1],
+                requires_two_momenta: false,
+                required_parameter_count: 0,
+                interaction_kind: DirectInteractionIntrinsicKind::VectorWedgeVector,
+                interaction_call: None,
+            },
+        )
+        .unwrap();
+        let raw_only_groups = vec![ResolvedOnTheFlyExecutor {
+            direct_executor_id: 2,
+            handle: raw_handle,
+            parent_permutation: [0, 1],
+            packed_singleton_capable: false,
+            interaction_capability: None,
+        }]
+        .into_boxed_slice();
+        let raw_only_program =
+            OnTheFlyQueryFamilyExecutorV1::<ProbeResolver>::bind_singleton_fanout_program(
+                &family,
+                &raw_only_groups,
+            )
+            .unwrap();
+        assert_eq!(raw_only_program.row_counts(), (0, 0));
+        let resolved_groups = vec![ResolvedOnTheFlyExecutor {
+            direct_executor_id: 2,
+            handle: raw_handle,
+            parent_permutation: [0, 1],
+            packed_singleton_capable: false,
+            interaction_capability: Some(capability),
+        }]
+        .into_boxed_slice();
+        let OnTheFlyFamilyRowsV1::Contribution(rows) = &mut family.row_groups[0].rows else {
+            panic!("expected contribution rows");
+        };
+        rows[0].flags |= DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE;
+        let reuse_program =
+            OnTheFlyQueryFamilyExecutorV1::<ProbeResolver>::bind_singleton_fanout_program(
+                &family,
+                &resolved_groups,
+            )
+            .unwrap();
+        assert_eq!(reuse_program.row_counts(), (0, 0));
+        let OnTheFlyFamilyRowsV1::Contribution(rows) = &mut family.row_groups[0].rows else {
+            unreachable!();
+        };
+        rows[0].flags &= !DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE;
+        let workspace = OnTheFlyFamilyWorkspaceV1::new(&family, 2, false).unwrap();
+        let interaction_program =
+            OnTheFlyQueryFamilyExecutorV1::<ProbeResolver>::bind_interaction_program(
+                &family,
+                &resolved_groups,
+                RecurrenceStrategy::ContractedColorUnion,
+            )
+            .unwrap();
+        assert_eq!(
+            interaction_program.action(0),
+            DirectInteractionGroupAction::Normal
+        );
+        let singleton_fanout_program =
+            OnTheFlyQueryFamilyExecutorV1::<ProbeResolver>::bind_singleton_fanout_program(
+                &family,
+                &resolved_groups,
+            )
+            .unwrap();
+        assert_eq!(singleton_fanout_program.row_counts(), (3, 2));
+        let mut bound = BoundOnTheFlyQueryFamilyV1 {
+            identity: QueryFamilyCacheIdentityV1::Streamed {
+                direct_catalog_digest: catalog.direct_template_catalog_digest(),
+                query_count: 1,
+                ordered_query_digest: SemanticDigest::new([0x84; 32]).unwrap(),
+            },
+            strategy: RecurrenceStrategy::ContractedColorUnion,
+            family,
+            workspace,
+            resolved_groups,
+            packed_singleton_capable: false,
+            interaction_program,
+            singleton_fanout_program,
+            applied_parameter_version: 0,
+            descriptor_exposed: false,
+        };
+        let record = |report: &mut OnTheFlyQueryFamilyExecutionReportV1, role, row_count| {
+            assert_eq!(role, DirectExecutorRole::Contribution);
+            add(&mut report.contribution_calls, 1, "test contribution calls")?;
+            add(
+                &mut report.contribution_rows,
+                row_count,
+                "test contribution rows",
+            )
+        };
+        let stride = bound.workspace.point_stride as usize;
+
+        bound.workspace.current_re.as_mut_slice()[0] = 3.0;
+        bound.workspace.current_re.as_mut_slice()[stride] = 4.0;
+        let singleton = execute_bound_family(
+            &mut bound,
+            1,
+            OnTheFlyQueryFamilyExecutionReportV1::default(),
+            record,
+        )
+        .unwrap();
+        assert_eq!(
+            (singleton.contribution_calls, singleton.contribution_rows),
+            (1, 3)
+        );
+        assert_eq!(census.native_calls.load(Ordering::Relaxed), 1);
+        assert_eq!(census.native_runs.load(Ordering::Relaxed), 1);
+        assert_eq!(census.raw_calls.load(Ordering::Relaxed), 1);
+        assert_eq!(census.raw_rows.load(Ordering::Relaxed), 1);
+        assert_eq!(bound.workspace.current_re.as_slice()[2 * stride], 34.0);
+        assert_eq!(bound.workspace.current_re.as_slice()[3 * stride], 68.0);
+        assert_eq!(bound.workspace.current_re.as_slice()[4 * stride], 43.0);
+
+        bound.workspace.current_re.as_mut_slice().fill(0.0);
+        bound.workspace.current_im.as_mut_slice().fill(0.0);
+        bound.workspace.current_re.as_mut_slice()[0] = 3.0;
+        bound.workspace.current_re.as_mut_slice()[1] = 5.0;
+        bound.workspace.current_re.as_mut_slice()[stride] = 4.0;
+        bound.workspace.current_re.as_mut_slice()[stride + 1] = 6.0;
+        let batched = execute_bound_family(
+            &mut bound,
+            2,
+            OnTheFlyQueryFamilyExecutionReportV1::default(),
+            record,
+        )
+        .unwrap();
+        assert_eq!(
+            (batched.contribution_calls, batched.contribution_rows),
+            (1, 3)
+        );
+        assert_eq!(census.native_calls.load(Ordering::Relaxed), 1);
+        assert_eq!(census.native_runs.load(Ordering::Relaxed), 1);
+        assert_eq!(census.raw_calls.load(Ordering::Relaxed), 2);
+        assert_eq!(census.raw_rows.load(Ordering::Relaxed), 4);
+        assert_eq!(
+            &bound.workspace.current_re.as_slice()[2 * stride..2 * stride + 2],
+            &[34.0, 56.0]
+        );
+        assert_eq!(
+            &bound.workspace.current_re.as_slice()[3 * stride..3 * stride + 2],
+            &[68.0, 112.0]
+        );
+        assert_eq!(
+            &bound.workspace.current_re.as_slice()[4 * stride..4 * stride + 2],
+            &[43.0, 65.0]
+        );
+    }
+
+    #[test]
+    fn otf_interaction_dispatch_is_singleton_only_and_preserves_logical_counters() {
+        let catalog = direct_catalog();
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x91, factor(1));
+        let mut family = build_query_family_from_traces(
+            &catalog,
+            &[QueryFamilyTraceInput {
+                trace: &trace,
+                projection,
+            }],
+        )
+        .unwrap();
+        let seed_digest = trace.seed_digest;
+        let key = OnTheFlyExecutorKeyV1::PreparedOperation {
+            direct_catalog_digest: catalog.direct_template_catalog_digest(),
+            role: DirectExecutorRole::Contribution,
+            operation_kind: OnTheFlyOperationKindV1::Transition,
+            operation_id: 0,
+            operation_semantic_digest: SemanticDigest::new([0x92; 32]).unwrap(),
+            evaluator_binding_id: 1,
+            evaluator_binding_semantic_digest: SemanticDigest::new([0x93; 32]).unwrap(),
+        };
+        let row = |parents: [u32; 2], destination_component_base: u32, initializes: bool| {
+            DirectContributionRow {
+                parent0_component_base: parents[0],
+                parent1_component_base_or_sentinel: parents[1],
+                parent0_momentum_form_id: 0,
+                parent1_momentum_form_id_or_sentinel: 0,
+                destination_component_base,
+                exact_factor_id: 0,
+                selector_domain_id: 0,
+                flags: if initializes {
+                    DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+                } else {
+                    0
+                },
+            }
+        };
+        family.source_count = 1;
+        family.lorentz_component_count = 1;
+        family.parameter_count = 0;
+        family.current_component_count = 4;
+        family.amplitude_destination_count = 1;
+        family.momentum_forms = vec![
+            CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                source_slot: 0,
+                coefficient: 1,
+            }])
+            .unwrap(),
+        ]
+        .into_boxed_slice();
+        family.exact_factors = vec![ExactComplexRational::ONE].into_boxed_slice();
+        family.row_groups = vec![
+            OnTheFlyFamilyRowGroupV1 {
+                seed_digest,
+                stage: 1,
+                role: DirectExecutorRole::Contribution,
+                direct_executor_id: 2,
+                representative_key: key,
+                member_bindings: vec![(key, [0, 1])].into_boxed_slice(),
+                rows: OnTheFlyFamilyRowsV1::Contribution(
+                    vec![row([1, 0], 2, true), row([1, 0], 3, true)].into_boxed_slice(),
+                ),
+            },
+            OnTheFlyFamilyRowGroupV1 {
+                seed_digest,
+                stage: 1,
+                role: DirectExecutorRole::Contribution,
+                direct_executor_id: 5,
+                representative_key: key,
+                member_bindings: vec![(key, [0, 1])].into_boxed_slice(),
+                rows: OnTheFlyFamilyRowsV1::Contribution(
+                    vec![row([0, 1], 3, false), row([0, 1], 2, false)].into_boxed_slice(),
+                ),
+            },
+        ]
+        .into_boxed_slice();
+        #[cfg(any(test, feature = "on-the-fly-test-support"))]
+        {
+            family.observed_currents = Box::new([]);
+        }
+
+        let census = InteractionPathCensus::default();
+        let context = (&census as *const InteractionPathCensus).cast::<c_void>();
+        let raw_handle = DirectExecutorHandle::Contribution {
+            call: interaction_raw_contributions,
+            context,
+        };
+        let capability = |kind, interaction_call| {
+            DirectInteractionExecutorCapability::new(
+                raw_handle,
+                DirectContributionExecutionMetadata::new(1, false).unwrap(),
+                DirectContributionFanoutExecutorHandle {
+                    call: interaction_fanout_unreachable,
+                    context,
+                    destination_component_count: 1,
+                    parent_component_counts: [1, 1],
+                    requires_two_momenta: false,
+                    required_parameter_count: 0,
+                    interaction_kind: kind,
+                    interaction_call,
+                },
+            )
+            .unwrap()
+        };
+        let resolved_groups = vec![
+            ResolvedOnTheFlyExecutor {
+                direct_executor_id: 2,
+                handle: raw_handle,
+                parent_permutation: [0, 1],
+                packed_singleton_capable: false,
+                interaction_capability: Some(capability(
+                    DirectInteractionIntrinsicKind::AntisymmetricTensorVector,
+                    None,
+                )),
+            },
+            ResolvedOnTheFlyExecutor {
+                direct_executor_id: 5,
+                handle: raw_handle,
+                parent_permutation: [0, 1],
+                packed_singleton_capable: false,
+                interaction_capability: Some(capability(
+                    DirectInteractionIntrinsicKind::ColorOrderedThreeVector,
+                    Some(count_otf_interaction),
+                )),
+            },
+        ]
+        .into_boxed_slice();
+        let workspace = OnTheFlyFamilyWorkspaceV1::new(&family, 2, false).unwrap();
+        let interaction_program =
+            OnTheFlyQueryFamilyExecutorV1::<ProbeResolver>::bind_interaction_program(
+                &family,
+                &resolved_groups,
+                RecurrenceStrategy::ContractedColorUnion,
+            )
+            .unwrap();
+        let singleton_fanout_program =
+            OnTheFlyQueryFamilyExecutorV1::<ProbeResolver>::bind_singleton_fanout_program(
+                &family,
+                &resolved_groups,
+            )
+            .unwrap();
+        let mut bound = BoundOnTheFlyQueryFamilyV1 {
+            identity: QueryFamilyCacheIdentityV1::Streamed {
+                direct_catalog_digest: catalog.direct_template_catalog_digest(),
+                query_count: 1,
+                ordered_query_digest: SemanticDigest::new([0x94; 32]).unwrap(),
+            },
+            strategy: RecurrenceStrategy::ContractedColorUnion,
+            family,
+            workspace,
+            resolved_groups,
+            packed_singleton_capable: false,
+            interaction_program,
+            singleton_fanout_program,
+            applied_parameter_version: 0,
+            descriptor_exposed: false,
+        };
+        let record = |report: &mut OnTheFlyQueryFamilyExecutionReportV1, role, row_count| {
+            assert_eq!(role, DirectExecutorRole::Contribution);
+            add(&mut report.contribution_calls, 1, "test contribution calls")?;
+            add(
+                &mut report.contribution_rows,
+                row_count,
+                "test contribution rows",
+            )
+        };
+
+        let singleton = execute_bound_family(
+            &mut bound,
+            1,
+            OnTheFlyQueryFamilyExecutionReportV1::default(),
+            record,
+        )
+        .unwrap();
+        assert_eq!(
+            (singleton.contribution_calls, singleton.contribution_rows),
+            (2, 4)
+        );
+        assert_eq!(census.native_calls.load(Ordering::Relaxed), 1);
+        assert_eq!(census.raw_calls.load(Ordering::Relaxed), 0);
+
+        let batched = execute_bound_family(
+            &mut bound,
+            2,
+            OnTheFlyQueryFamilyExecutionReportV1::default(),
+            record,
+        )
+        .unwrap();
+        assert_eq!(
+            (batched.contribution_calls, batched.contribution_rows),
+            (2, 4)
+        );
+        assert_eq!(census.native_calls.load(Ordering::Relaxed), 1);
+        assert_eq!(census.raw_calls.load(Ordering::Relaxed), 2);
+        assert_eq!(census.raw_rows.load(Ordering::Relaxed), 4);
+    }
+
+    fn streamed_pair_candidate(
+        catalog: &PreparedDirectExecutorCatalog,
+        first: &OnTheFlyStructuralTraceV1,
+        first_projection: OnTheFlyProjectionProbeV1,
+        second: &OnTheFlyStructuralTraceV1,
+        second_projection: OnTheFlyProjectionProbeV1,
+        split: bool,
+    ) -> OnTheFlyStreamedQueryFamilyCandidateV1 {
+        build_streamed_query_family_candidate_v1(catalog, |consumer| {
+            if split {
+                assert_eq!(
+                    consumer.push_chunk(&[QueryFamilyTraceInput {
+                        trace: first,
+                        projection: first_projection,
+                    }])?,
+                    0..1
+                );
+                assert_eq!(
+                    consumer.push_chunk(&[QueryFamilyTraceInput {
+                        trace: second,
+                        projection: second_projection,
+                    }])?,
+                    1..2
+                );
+            } else {
+                assert_eq!(
+                    consumer.push_chunk(&[
+                        QueryFamilyTraceInput {
+                            trace: first,
+                            projection: first_projection,
+                        },
+                        QueryFamilyTraceInput {
+                            trace: second,
+                            projection: second_projection,
+                        },
+                    ])?,
+                    0..2
+                );
+            }
+            Ok(())
+        })
+        .unwrap()
+        .expect("two nonzero traces must materialize one streamed family")
+    }
+
+    #[test]
+    fn streamed_query_family_is_chunk_boundary_independent_and_warm_reusable() {
+        let catalog = direct_catalog();
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let (mut second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(1));
+        second.test_remap_dynamic_color_id(7);
+
+        let monolithic = streamed_pair_candidate(
+            &catalog,
+            &first,
+            first_projection,
+            &second,
+            second_projection,
+            false,
+        );
+        let exact_lc_family = build_query_family_from_traces(
+            &catalog,
+            &[
+                QueryFamilyTraceInput {
+                    trace: &first,
+                    projection: first_projection,
+                },
+                QueryFamilyTraceInput {
+                    trace: &second,
+                    projection: second_projection,
+                },
+            ],
+        )
+        .unwrap();
+        let chunked = streamed_pair_candidate(
+            &catalog,
+            &first,
+            first_projection,
+            &second,
+            second_projection,
+            true,
+        );
+        assert_eq!(exact_lc_family, monolithic.family);
+        assert_eq!(monolithic.identity, chunked.identity);
+        assert_eq!(monolithic.family, chunked.family);
+
+        let reversed = build_streamed_query_family_candidate_v1(&catalog, |consumer| {
+            assert_eq!(
+                consumer.push_chunk(&[
+                    QueryFamilyTraceInput {
+                        trace: &second,
+                        projection: second_projection,
+                    },
+                    QueryFamilyTraceInput {
+                        trace: &first,
+                        projection: first_projection,
+                    },
+                ])?,
+                0..2
+            );
+            Ok(())
+        })
+        .unwrap()
+        .unwrap();
+        assert_ne!(chunked.identity, reversed.identity);
+
+        let mut monolithic_executor =
+            OnTheFlyQueryFamilyExecutorV1::new(ProbeResolver::new(catalog.clone()));
+        let mut chunked_executor =
+            OnTheFlyQueryFamilyExecutorV1::new(ProbeResolver::new(catalog.clone()));
+        monolithic_executor
+            .prepare_streamed_candidate(monolithic, 1)
+            .unwrap();
+        chunked_executor
+            .prepare_streamed_candidate(chunked, 1)
+            .unwrap();
+        let mut monolithic_outputs = [(0.0, 0.0); 2];
+        let mut chunked_outputs = [(0.0, 0.0); 2];
+        let monolithic_report = monolithic_executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut monolithic_outputs)
+            .unwrap();
+        let chunked_report = chunked_executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut chunked_outputs)
+            .unwrap();
+        assert_eq!(monolithic_report, chunked_report);
+        assert_eq!(monolithic_outputs, chunked_outputs);
+        assert_eq!(chunked_outputs, [(46.0, 0.0), (46.0, 0.0)]);
+        assert_eq!(chunked_executor.retained_family_count(), 1);
+        let retained_handle = chunked_executor.active_retained_handle().unwrap();
+        assert!(matches!(
+            chunked_executor.families[0].identity,
+            QueryFamilyCacheIdentityV1::Streamed { query_count: 2, .. }
+        ));
+
+        let same_candidate = streamed_pair_candidate(
+            &catalog,
+            &first,
+            first_projection,
+            &second,
+            second_projection,
+            true,
+        );
+        assert!(
+            chunked_executor
+                .prepare_streamed_candidate(same_candidate, 1)
+                .unwrap()
+        );
+        assert_eq!(
+            chunked_executor.active_retained_handle(),
+            Some(retained_handle)
+        );
+        assert_eq!(chunked_executor.retained_family_count(), 1);
+        assert!(
+            chunked_executor
+                .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut chunked_outputs)
+                .unwrap()
+                .cache_hit
+        );
+    }
+
+    #[test]
+    fn streamed_query_family_rejects_cross_chunk_duplicates_and_conflicts() {
+        let catalog = direct_catalog();
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let repeated = build_streamed_query_family_candidate_v1(&catalog, |consumer| {
+            consumer.push_chunk(&[QueryFamilyTraceInput {
+                trace: &first,
+                projection: first_projection,
+            }])?;
+            consumer.push_chunk(&[QueryFamilyTraceInput {
+                trace: &first,
+                projection: first_projection,
+            }])?;
+            Ok(())
+        })
+        .unwrap_err();
+        assert!(repeated.to_string().contains("repeats a selected query"));
+
+        let (second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(2));
+        let conflicting = build_streamed_query_family_candidate_v1(&catalog, |consumer| {
+            consumer.push_chunk(&[QueryFamilyTraceInput {
+                trace: &first,
+                projection: first_projection,
+            }])?;
+            consumer.push_chunk(&[QueryFamilyTraceInput {
+                trace: &second,
+                projection: second_projection,
+            }])?;
+            Ok(())
+        })
+        .unwrap_err();
+        assert!(conflicting.to_string().contains("conflicting definitions"));
+    }
+
+    #[test]
+    fn query_family_union_interns_exact_currents_and_retains_destinations() {
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let (mut second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(1));
+        second.test_remap_dynamic_color_id(7);
+        let census = query_family_census_from_traces(
+            &direct_catalog(),
+            &[
+                QueryFamilyTraceInput {
+                    trace: &first,
+                    projection: first_projection,
+                },
+                QueryFamilyTraceInput {
+                    trace: &second,
+                    projection: second_projection,
+                },
+            ],
+        )
+        .unwrap();
+
+        assert_eq!(census.query_count, 2);
+        assert_eq!(census.source_frame_partition_count, 1);
+        assert_eq!(census.projection_applied_query_count, 0);
+        assert_eq!(census.projection_pre_current_count, 6);
+        assert_eq!(census.projection_pre_contribution_count, 2);
+        assert_eq!(census.projection_pre_closure_count, 2);
+        assert_eq!(census.projection_post_current_count, 6);
+        assert_eq!(census.projection_post_contribution_count, 2);
+        assert_eq!(census.projection_post_closure_count, 2);
+        assert_eq!(census.dynamic_current_occurrence_count, 6);
+        assert_eq!(census.dynamic_current_component_occurrence_count, 6);
+        assert_eq!(census.dynamic_source_rows, 4);
+        assert_eq!(census.dynamic_contribution_rows, 2);
+        assert_eq!(census.dynamic_finalization_rows, 2);
+        assert_eq!(census.dynamic_closure_rows, 2);
+        assert_eq!(census.dynamic_source_calls, 4);
+        assert_eq!(census.dynamic_contribution_calls, 2);
+        assert_eq!(census.dynamic_finalization_calls, 2);
+        assert_eq!(census.dynamic_closure_calls, 2);
+        assert_eq!(census.union_unique_current_count, 3);
+        assert_eq!(census.union_unique_current_component_count, 3);
+        assert_eq!(census.union_source_rows, 2);
+        assert_eq!(census.union_contribution_rows, 1);
+        assert_eq!(census.union_finalization_rows, 1);
+        assert_eq!(census.union_closure_rows, 2);
+        assert_eq!(census.union_kernel_application_count().unwrap(), 6);
+        assert_eq!(census.union_amplitude_destination_count, 2);
+        assert_eq!(census.union_source_executor_call_groups, 1);
+        assert_eq!(census.union_contribution_executor_call_groups, 1);
+        assert_eq!(census.union_finalization_executor_call_groups, 1);
+        assert_eq!(census.union_closure_executor_call_groups, 1);
+    }
+
+    #[test]
+    fn query_family_groups_distinct_semantic_operations_by_prepared_executor() {
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let census = query_family_census_from_traces(
+            &direct_catalog(),
+            &[QueryFamilyTraceInput {
+                trace: &trace,
+                projection,
+            }],
+        )
+        .unwrap();
+
+        // The two source operations have different authenticated operation and
+        // evaluator-binding identities, but the prepared catalog deliberately
+        // maps both onto one Direct-Arena source executor.
+        assert_eq!(census.union_source_rows, 2);
+        assert_eq!(census.union_source_executor_call_groups, 1);
+    }
+
+    #[test]
+    fn query_family_union_rejects_conflicting_semantic_current_definitions() {
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let (second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(2));
+        let error = query_family_census_from_traces(
+            &direct_catalog(),
+            &[
+                QueryFamilyTraceInput {
+                    trace: &first,
+                    projection: first_projection,
+                },
+                QueryFamilyTraceInput {
+                    trace: &second,
+                    projection: second_projection,
+                },
+            ],
+        )
+        .unwrap_err();
+        assert!(error.to_string().contains("conflicting definitions"));
+    }
+
+    #[test]
+    fn query_family_union_keeps_distinct_source_frame_partitions() {
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let (mut second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(1));
+        second.seed_digest = SemanticDigest::new([0x83; 32]).unwrap();
+
+        let census = query_family_census_from_traces(
+            &direct_catalog(),
+            &[
+                QueryFamilyTraceInput {
+                    trace: &first,
+                    projection: first_projection,
+                },
+                QueryFamilyTraceInput {
+                    trace: &second,
+                    projection: second_projection,
+                },
+            ],
+        )
+        .unwrap();
+        assert_eq!(census.source_frame_partition_count, 2);
+        assert_eq!(census.union_unique_current_count, 6);
+        assert_eq!(census.union_source_rows, 4);
+        assert_eq!(census.union_contribution_rows, 2);
+        assert_eq!(census.union_finalization_rows, 2);
+        assert_eq!(census.union_closure_rows, 2);
+        assert_eq!(census.union_source_executor_call_groups, 2);
+        assert_eq!(census.union_contribution_executor_call_groups, 2);
+        assert_eq!(census.union_finalization_executor_call_groups, 2);
+        assert_eq!(census.union_closure_executor_call_groups, 2);
+    }
+
+    #[test]
+    fn query_family_union_rejects_repeated_queries_and_stale_projection_proofs() {
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let repeated = query_family_census_from_traces(
+            &direct_catalog(),
+            &[
+                QueryFamilyTraceInput {
+                    trace: &trace,
+                    projection,
+                },
+                QueryFamilyTraceInput {
+                    trace: &trace,
+                    projection,
+                },
+            ],
+        )
+        .unwrap_err();
+        assert!(repeated.to_string().contains("repeats a selected query"));
+
+        let stale = OnTheFlyProjectionProbeV1 {
+            post: [2, 1, 1],
+            ..projection
+        };
+        let error = query_family_census_from_traces(
+            &direct_catalog(),
+            &[QueryFamilyTraceInput {
+                trace: &trace,
+                projection: stale,
+            }],
+        )
+        .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("projection proof does not describe")
+        );
+    }
+
+    fn one_point_momenta(source0: f64, source1: f64) -> Vec<f64> {
+        vec![source0, 0.0, 0.0, 0.0, source1, 0.0, 0.0, 0.0]
+    }
+
+    fn source_major_momenta(source0: &[f64], source1: &[f64]) -> Vec<f64> {
+        assert_eq!(source0.len(), source1.len());
+        let point_count = source0.len();
+        let mut momenta = Vec::with_capacity(8 * point_count);
+        for source in [source0, source1] {
+            momenta.extend_from_slice(source);
+            momenta.extend(std::iter::repeat_n(0.0, 3 * point_count));
+        }
+        momenta
+    }
+
+    #[test]
+    fn momentum_plane_refresh_preserves_scalar_order_and_inactive_lanes() {
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let mut family = build_query_family_from_traces(
+            &direct_catalog(),
+            &[QueryFamilyTraceInput {
+                trace: &trace,
+                projection,
+            }],
+        )
+        .unwrap();
+        family.source_count = 3;
+        family.momentum_forms = [
+            vec![],
+            vec![(0, -1)],
+            vec![(0, 1), (1, 1), (2, 1)],
+            vec![(0, 3), (1, -2), (2, 7)],
+        ]
+        .into_iter()
+        .map(|terms| {
+            CanonicalMomentumLinearForm::new(
+                terms
+                    .into_iter()
+                    .map(|(source_slot, coefficient)| MomentumTerm {
+                        source_slot,
+                        coefficient,
+                    })
+                    .collect(),
+            )
+            .unwrap()
+        })
+        .collect::<Vec<_>>()
+        .into_boxed_slice();
+        let mut workspace = OnTheFlyFamilyWorkspaceV1::new(&family, 9, false).unwrap();
+        let stride = workspace.point_stride as usize;
+        let lorentz_count = usize::from(family.lorentz_component_count);
+        for point_count in [1, 9, 3, 5, 1] {
+            let mut inputs = Vec::new();
+            for source in 0..family.source_count as usize {
+                for lorentz in 0..lorentz_count {
+                    for point in 0..point_count {
+                        inputs.push(match lorentz {
+                            0 => [1.0e16, -1.0e16, 1.0][source] * (point + 1) as f64,
+                            1 if (point + source) % 2 == 0 => -0.0,
+                            1 => 0.0,
+                            2 => (source + point + 1) as f64 * f64::MIN_POSITIVE,
+                            _ => (source * 31 + point * 7) as f64 / 13.0,
+                        });
+                    }
+                }
+            }
+            workspace.momenta.as_mut_slice().fill(31.0);
+            workspace.amplitude_re.as_mut_slice().fill(37.0);
+            workspace.amplitude_im.as_mut_slice().fill(41.0);
+            workspace.current_re.as_mut_slice().fill(43.0);
+            workspace.current_im.as_mut_slice().fill(47.0);
+            workspace
+                .refresh_inputs(&family, &inputs, point_count as u32)
+                .unwrap();
+            for (form_id, form) in family.momentum_forms.iter().enumerate() {
+                for lorentz in 0..lorentz_count {
+                    let plane = (form_id * lorentz_count + lorentz) * stride;
+                    for point in 0..point_count {
+                        let mut expected = 0.0_f64;
+                        for term in form.terms() {
+                            let source = (term.source_slot as usize * lorentz_count + lorentz)
+                                * point_count
+                                + point;
+                            expected += f64::from(term.coefficient) * inputs[source];
+                        }
+                        assert_eq!(
+                            workspace.momenta.as_slice()[plane + point].to_bits(),
+                            expected.to_bits(),
+                        );
+                    }
+                    assert!(
+                        workspace.momenta.as_slice()[plane + point_count..plane + stride]
+                            .iter()
+                            .all(|value| *value == 31.0)
+                    );
+                }
+            }
+            for (amplitudes, sentinel) in [
+                (&workspace.amplitude_re, 37.0),
+                (&workspace.amplitude_im, 41.0),
+            ] {
+                for plane in amplitudes.as_slice().chunks_exact(stride) {
+                    assert!(plane[..point_count].iter().all(|value| *value == 0.0));
+                    assert!(plane[point_count..].iter().all(|value| *value == sentinel));
+                }
+            }
+            assert!(
+                workspace
+                    .current_re
+                    .as_slice()
+                    .iter()
+                    .all(|value| *value == 43.0)
+            );
+            assert!(
+                workspace
+                    .current_im
+                    .as_slice()
+                    .iter()
+                    .all(|value| *value == 47.0)
+            );
+        }
+        assert!(workspace.refresh_inputs(&family, &[], 1).is_err());
+        assert!(workspace.refresh_inputs(&family, &[], 0).is_err());
+        assert!(workspace.refresh_inputs(&family, &[], 10).is_err());
+
+        family.momentum_forms = vec![
+            CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                source_slot: family.source_count,
+                coefficient: 1,
+            }])
+            .unwrap(),
+        ]
+        .into_boxed_slice();
+        let error = OnTheFlyFamilyWorkspaceV1::new(&family, 1, false)
+            .err()
+            .expect("out-of-bounds sources must fail during preparation");
+        assert!(
+            error
+                .to_string()
+                .contains("momentum source slot is out of bounds")
+        );
+    }
+
+    #[test]
+    fn packed_singleton_family_requires_every_executor_role() {
+        let catalog = direct_catalog();
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let selected = [QueryFamilyTraceInput {
+            trace: &trace,
+            projection,
+        }];
+
+        for missing_role in [
+            DirectExecutorRole::Source,
+            DirectExecutorRole::Contribution,
+            DirectExecutorRole::Finalization,
+            DirectExecutorRole::Closure,
+        ] {
+            let mut resolver = ProbeResolver::packed_singleton(catalog.clone());
+            resolver.disable_packed_singleton_role(missing_role);
+            let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+            assert!(!executor.prepare(&catalog, &selected, 1).unwrap());
+            let pending = executor.pending.as_ref().unwrap();
+            assert!(
+                !pending.packed_singleton_capable,
+                "missing {missing_role:?}"
+            );
+            assert_eq!(
+                pending.workspace.point_stride,
+                checked_aligned_point_stride(1).unwrap(),
+                "missing {missing_role:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn packed_singleton_family_promotes_once_for_batched_execution() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::packed_singleton(catalog.clone());
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let selected = [QueryFamilyTraceInput {
+            trace: &trace,
+            projection,
+        }];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+
+        assert!(!executor.prepare(&catalog, &selected, 1).unwrap());
+        let pending = executor.pending.as_ref().unwrap();
+        assert!(pending.packed_singleton_capable);
+        assert_eq!(pending.workspace.point_stride, 1);
+        let mut scalar_output = [(0.0, 0.0)];
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut scalar_output)
+            .unwrap();
+        assert_eq!(scalar_output, [(46.0, 0.0)]);
+        assert_eq!(executor.resolver().state.invalidations.get(), 0);
+
+        assert!(executor.resize_active_family(2).unwrap());
+        assert_eq!(executor.resolver().state.invalidations.get(), 1);
+        let retained = &executor.families[executor.last_used.unwrap()];
+        assert!(retained.packed_singleton_capable);
+        assert_eq!(retained.workspace.logical_point_capacity, 2);
+        assert_eq!(
+            retained.workspace.point_stride,
+            checked_aligned_point_stride(2).unwrap()
+        );
+
+        let mut batched_output = [(0.0, 0.0); 2];
+        executor
+            .execute_into(
+                &source_major_momenta(&[2.0, 4.0], &[3.0, 5.0]),
+                2,
+                &mut batched_output,
+            )
+            .unwrap();
+        assert_eq!(batched_output, [(46.0, 0.0), (180.0, 0.0)]);
+
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut scalar_output)
+            .unwrap();
+        assert_eq!(scalar_output, [(46.0, 0.0)]);
+        assert_eq!(
+            executor.families[executor.last_used.unwrap()]
+                .workspace
+                .point_stride,
+            checked_aligned_point_stride(2).unwrap()
+        );
+    }
+
+    #[test]
+    fn query_family_snapshot_reuses_rows_with_new_inputs_and_ignores_pending_candidate() {
+        let catalog = direct_catalog();
+        let (first, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let mut source =
+            OnTheFlyQueryFamilyExecutorV1::new(ProbeResolver::packed_singleton(catalog.clone()));
+        assert!(source.snapshot().unwrap().is_none());
+        source
+            .prepare(
+                &catalog,
+                &[QueryFamilyTraceInput {
+                    trace: &first,
+                    projection,
+                }],
+                1,
+            )
+            .unwrap();
+        // A constructed but unevaluated candidate is not a completed cache.
+        assert!(source.snapshot().unwrap().is_none());
+        let mut first_output = [(0.0, 0.0)];
+        source
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut first_output)
+            .unwrap();
+        assert_eq!(first_output, [(46.0, 0.0)]);
+        let (second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(2));
+        source
+            .prepare(
+                &catalog,
+                &[QueryFamilyTraceInput {
+                    trace: &second,
+                    projection: second_projection,
+                }],
+                1,
+            )
+            .unwrap();
+        let bytes = bincode::encode_to_vec(source.snapshot().unwrap(), bincode::config::standard())
+            .unwrap();
+        let (saved, used): (Option<snapshot::OnTheFlyFamilySnapshotV1>, usize) =
+            bincode::decode_from_slice(&bytes, bincode::config::standard()).unwrap();
+        assert_eq!(used, bytes.len());
+        let mut restored =
+            OnTheFlyQueryFamilyExecutorV1::new(ProbeResolver::packed_singleton(catalog));
+        let handle = restored.restore_snapshot(saved.unwrap(), 1).unwrap();
+        assert!(restored.activate_retained_family(handle, 2).unwrap());
+        let mut outputs = [(0.0, 0.0); 2];
+        let report = restored
+            .execute_into(
+                &source_major_momenta(&[2.0, 4.0], &[3.0, 5.0]),
+                2,
+                &mut outputs,
+            )
+            .unwrap();
+        assert!(report.cache_hit);
+        assert_eq!(outputs, [(46.0, 0.0), (180.0, 0.0)]);
+        assert!(restored.snapshot().unwrap().is_some());
+
+        // Even the counter-exhaustion boundary preserves the old cache.
+        let (saved, _): (Option<snapshot::OnTheFlyFamilySnapshotV1>, usize) =
+            bincode::decode_from_slice(&bytes, bincode::config::standard()).unwrap();
+        restored.family_generation = u64::MAX;
+        assert!(restored.restore_snapshot(saved.unwrap(), 1).is_err());
+        assert!(restored.pending.is_none());
+        let report = restored
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut first_output)
+            .unwrap();
+        assert!(report.cache_hit);
+        assert_eq!(first_output, [(46.0, 0.0)]);
+    }
+
+    #[test]
+    fn query_family_executes_union_once_and_reuses_stable_warm_rows() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (mut first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let (mut second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(1));
+        first.layout.parameter_count = 1;
+        second.layout.parameter_count = 1;
+        second.test_remap_dynamic_color_id(7);
+        let selected = [
+            QueryFamilyTraceInput {
+                trace: &first,
+                projection: first_projection,
+            },
+            QueryFamilyTraceInput {
+                trace: &second,
+                projection: second_projection,
+            },
+        ];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        assert!(!executor.prepare(&catalog, &selected, 3).unwrap());
+        let census = executor.prepared_census().unwrap();
+        assert_eq!(census.union_unique_current_count, 3);
+        assert_eq!(census.union_amplitude_destination_count, 2);
+        executor.set_parameters(&[(1.0, 0.0)]).unwrap();
+        let momenta = source_major_momenta(&[2.0, 4.0, -1.0], &[3.0, 5.0, 2.0]);
+        let mut outputs = [(0.0, 0.0); 6];
+        let cold = executor.execute_into(&momenta, 3, &mut outputs).unwrap();
+        assert!(!cold.cache_hit);
+        assert_eq!(
+            cold,
+            OnTheFlyQueryFamilyExecutionReportV1 {
+                cache_hit: false,
+                source_calls: 1,
+                source_rows: 2,
+                contribution_calls: 1,
+                contribution_rows: 1,
+                finalization_calls: 1,
+                finalization_rows: 1,
+                closure_calls: 1,
+                closure_rows: 2,
+            }
+        );
+        assert_eq!(
+            outputs,
+            [
+                (46.0, 0.0),
+                (180.0, 0.0),
+                (8.0, 0.0),
+                (46.0, 0.0),
+                (180.0, 0.0),
+                (8.0, 0.0),
+            ]
+        );
+        let first_calls = executor.resolver().state.calls.borrow().clone();
+        assert_eq!(
+            first_calls.iter().map(|call| call.0).collect::<Vec<_>>(),
+            vec![
+                DirectExecutorRole::Source,
+                DirectExecutorRole::Contribution,
+                DirectExecutorRole::Finalization,
+                DirectExecutorRole::Closure,
+            ]
+        );
+
+        assert!(executor.prepare(&catalog, &selected, 3).unwrap());
+        executor.set_parameters(&[(2.0, 0.0)]).unwrap();
+        let retained = executor
+            .last_used
+            .and_then(|index| executor.families.get_mut(index))
+            .expect("cold execution did not retain its query family");
+        retained.workspace.current_re.as_mut_slice().fill(f64::NAN);
+        retained.workspace.current_im.as_mut_slice().fill(f64::NAN);
+        let warm = executor.execute_into(&momenta, 3, &mut outputs).unwrap();
+        assert!(warm.cache_hit);
+        assert_eq!(
+            outputs,
+            [
+                (92.0, 0.0),
+                (360.0, 0.0),
+                (16.0, 0.0),
+                (92.0, 0.0),
+                (360.0, 0.0),
+                (16.0, 0.0),
+            ]
+        );
+        let calls = executor.resolver().state.calls.borrow();
+        assert_eq!(calls.len(), 8);
+        assert_eq!(
+            calls[..4]
+                .iter()
+                .map(|call| (call.0, call.1, call.2))
+                .collect::<Vec<_>>(),
+            calls[4..]
+                .iter()
+                .map(|call| (call.0, call.1, call.2))
+                .collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn query_family_interns_shared_scalars_and_exact_component_blocks() {
+        let mut factors = Vec::new();
+        let mut scalar_ids = BTreeMap::new();
+        let mut block_ids = BTreeMap::new();
+        let one = factor(1);
+        let two = factor(2);
+        assert_eq!(
+            intern_factor(&mut scalar_ids, &mut factors, one).unwrap(),
+            0
+        );
+        assert_eq!(
+            intern_factor(&mut scalar_ids, &mut factors, one).unwrap(),
+            0
+        );
+        let forward =
+            intern_factor_block(&mut block_ids, &mut scalar_ids, &mut factors, &[one, two])
+                .unwrap();
+        assert_eq!(forward, 1);
+        assert_eq!(
+            intern_factor_block(&mut block_ids, &mut scalar_ids, &mut factors, &[one, two],)
+                .unwrap(),
+            forward
+        );
+        let reversed =
+            intern_factor_block(&mut block_ids, &mut scalar_ids, &mut factors, &[two, one])
+                .unwrap();
+        assert_eq!(reversed, 3);
+        assert_eq!(factors, vec![one, one, two, two, one]);
+
+        let catalog = direct_catalog();
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, one);
+        let (mut second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, one);
+        second.test_remap_dynamic_color_id(7);
+        let family = build_query_family_from_traces(
+            &catalog,
+            &[
+                QueryFamilyTraceInput {
+                    trace: &first,
+                    projection: first_projection,
+                },
+                QueryFamilyTraceInput {
+                    trace: &second,
+                    projection: second_projection,
+                },
+            ],
+        )
+        .unwrap();
+        assert_eq!(family.exact_factors.as_ref(), &[one, one]);
+        let starts = family
+            .row_groups
+            .iter()
+            .flat_map(|group| match &group.rows {
+                OnTheFlyFamilyRowsV1::Closure(rows) => rows
+                    .iter()
+                    .map(|row| row.component_factor_start)
+                    .collect::<Vec<_>>(),
+                _ => Vec::new(),
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(starts, vec![1, 1]);
+    }
+
+    #[test]
+    fn query_family_initializes_once_across_executor_groups() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (mut trace, mut projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        trace.test_add_query_family_contribution(5, 5, factor(1));
+        projection.pre[1] = 2;
+        projection.post[1] = 2;
+        let selected = [QueryFamilyTraceInput {
+            trace: &trace,
+            projection,
+        }];
+        let family = build_query_family_from_traces(&catalog, &selected).unwrap();
+        let contribution_groups = family
+            .row_groups
+            .iter()
+            .filter_map(|group| match &group.rows {
+                OnTheFlyFamilyRowsV1::Contribution(rows) => Some(rows.as_ref()),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(contribution_groups.len(), 2);
+        assert_eq!(
+            contribution_groups
+                .iter()
+                .flat_map(|rows| rows.iter())
+                .filter(|row| row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0)
+                .count(),
+            1
+        );
+
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        assert!(!executor.prepare(&catalog, &selected, 1).unwrap());
+        let mut output = [(0.0, 0.0)];
+        let report = executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert_eq!(report.contribution_calls, 2);
+        assert_eq!(report.contribution_rows, 2);
+        assert_eq!(output, [(92.0, 0.0)]);
+    }
+
+    #[test]
+    fn query_family_applies_each_prepared_parent_permutation_before_grouping() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (mut trace, mut projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        trace.test_add_query_family_contribution(6, 6, factor(1));
+        trace.test_set_last_contribution_selector_domain(17);
+        projection.pre[1] = 2;
+        projection.post[1] = 2;
+        let selected = [QueryFamilyTraceInput {
+            trace: &trace,
+            projection,
+        }];
+        let family = build_query_family_from_traces(&catalog, &selected).unwrap();
+        let rows = family
+            .row_groups
+            .iter()
+            .find_map(|group| match &group.rows {
+                OnTheFlyFamilyRowsV1::Contribution(rows) => Some(rows.as_ref()),
+                _ => None,
+            })
+            .unwrap();
+        assert_eq!(rows.len(), 2);
+        assert_eq!(
+            rows.iter()
+                .map(|row| row.selector_domain_id)
+                .collect::<BTreeSet<_>>(),
+            BTreeSet::from([0, 17])
+        );
+        assert_eq!(
+            rows.iter()
+                .map(|row| {
+                    (
+                        row.parent0_component_base,
+                        row.parent1_component_base_or_sentinel,
+                    )
+                })
+                .collect::<BTreeSet<_>>(),
+            BTreeSet::from([(0, 1), (1, 0)])
+        );
+
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        executor.prepare(&catalog, &selected, 1).unwrap();
+        let mut output = [(0.0, 0.0)];
+        let report = executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert_eq!(report.contribution_calls, 1);
+        assert_eq!(report.contribution_rows, 2);
+        assert_eq!(output, [(110.0, 0.0)]);
+    }
+
+    #[test]
+    fn query_family_rejects_non_topological_group_order() {
+        let catalog = direct_catalog();
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let mut family = build_query_family_from_traces(
+            &catalog,
+            &[QueryFamilyTraceInput {
+                trace: &trace,
+                projection,
+            }],
+        )
+        .unwrap();
+        let contribution = family
+            .row_groups
+            .iter()
+            .position(|group| group.role == DirectExecutorRole::Contribution)
+            .unwrap();
+        let finalization = family
+            .row_groups
+            .iter()
+            .position(|group| group.role == DirectExecutorRole::Finalization)
+            .unwrap();
+        family.row_groups.swap(contribution, finalization);
+        let error = validate_ordered_family_schedule(&family.row_groups).unwrap_err();
+        assert!(error.to_string().contains("follows finalization"));
+    }
+
+    #[test]
+    fn failed_execution_discards_candidate_and_same_family_can_be_prepared_again() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let selected = [QueryFamilyTraceInput {
+            trace: &trace,
+            projection,
+        }];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        executor.prepare(&catalog, &selected, 1).unwrap();
+        executor
+            .resolver_mut()
+            .state
+            .fail_role
+            .set(Some(DirectExecutorRole::Contribution));
+        executor.resolver().state.record_failure_detail.set(true);
+        crate::recurrence::direct_backend::record_direct_executor_error_detail(
+            crate::RusticolError::integrity("stale detail from an earlier family schedule"),
+        );
+        let mut output = [(123.0, 456.0)];
+        let error = executor
+            .execute_into_unprofiled(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("probe Contribution first failure detail")
+        );
+        assert!(!error.to_string().contains("stale detail"));
+        assert!(!error.to_string().contains("later probe detail"));
+        assert_eq!(output, [(123.0, 456.0)]);
+        assert!(executor.pending.is_none());
+        assert_eq!(executor.retained_family_count(), 0);
+        assert_eq!(executor.resolver().state.invalidations.get(), 1);
+
+        executor.resolver().state.fail_role.set(None);
+        assert!(!executor.prepare(&catalog, &selected, 1).unwrap());
+        let report = executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert!(!report.cache_hit);
+        assert_eq!(output, [(46.0, 0.0)]);
+    }
+
+    #[test]
+    fn partially_failed_family_is_invalidated_before_switching_rows() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let first_selected = [QueryFamilyTraceInput {
+            trace: &first,
+            projection: first_projection,
+        }];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        executor.prepare(&catalog, &first_selected, 1).unwrap();
+        executor
+            .resolver()
+            .state
+            .fail_role
+            .set(Some(DirectExecutorRole::Finalization));
+        let mut output = [(0.0, 0.0)];
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap_err();
+        assert_eq!(executor.retained_family_count(), 0);
+        assert!(executor.pending.is_none());
+        let failed_calls = executor.resolver().state.calls.borrow().clone();
+        assert_eq!(failed_calls.len(), 3);
+        assert_eq!(executor.resolver().state.invalidations.get(), 1);
+
+        let (second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(1));
+        let second_selected = [QueryFamilyTraceInput {
+            trace: &second,
+            projection: second_projection,
+        }];
+        assert!(!executor.prepare(&catalog, &second_selected, 1).unwrap());
+        assert_eq!(executor.resolver().state.invalidations.get(), 1);
+        executor.resolver().state.fail_role.set(None);
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert_eq!(executor.retained_family_count(), 1);
+        assert_eq!(output, [(46.0, 0.0)]);
+        let calls = executor.resolver().state.calls.borrow();
+        assert_ne!(failed_calls[0].1, calls[3].1);
+        assert_ne!(failed_calls[1].1, calls[4].1);
+    }
+
+    #[test]
+    fn successful_cached_family_is_invalidated_before_new_candidate_runs() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let first_selected = [QueryFamilyTraceInput {
+            trace: &first,
+            projection: first_projection,
+        }];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        executor.prepare(&catalog, &first_selected, 1).unwrap();
+        let mut output = [(0.0, 0.0)];
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert_eq!(executor.resolver().state.invalidations.get(), 0);
+        let calls_before_prepare = executor.resolver().state.calls.borrow().len();
+
+        let (second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(1));
+        let second_selected = [QueryFamilyTraceInput {
+            trace: &second,
+            projection: second_projection,
+        }];
+        executor.prepare(&catalog, &second_selected, 1).unwrap();
+        assert_eq!(executor.resolver().state.invalidations.get(), 1);
+        assert_eq!(
+            executor.resolver().state.calls.borrow().len(),
+            calls_before_prepare
+        );
+        assert!(
+            executor
+                .families
+                .iter()
+                .all(|family| !family.descriptor_exposed)
+        );
+        let report = executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert!(!report.cache_hit);
+        assert_eq!(output, [(46.0, 0.0)]);
+    }
+
+    #[test]
+    fn failed_candidate_restores_observation_of_last_successful_family() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let first_selected = [QueryFamilyTraceInput {
+            trace: &first,
+            projection: first_projection,
+        }];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        let mut output = [(0.0, 0.0)];
+        executor.prepare(&catalog, &first_selected, 1).unwrap();
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        let first_handle = executor.active_retained_handle().unwrap();
+        assert!(!executor.observed_currents(0).unwrap().is_empty());
+
+        let (second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(2));
+        let second_selected = [QueryFamilyTraceInput {
+            trace: &second,
+            projection: second_projection,
+        }];
+        executor.prepare(&catalog, &second_selected, 1).unwrap();
+        let prepared_error = executor.observed_currents(0).unwrap_err();
+        assert!(
+            prepared_error
+                .to_string()
+                .contains("outside the last successful execution")
+        );
+
+        executor
+            .resolver()
+            .state
+            .fail_role
+            .set(Some(DirectExecutorRole::Contribution));
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap_err();
+        assert!(executor.pending.is_none());
+        assert!(!executor.observed_currents(0).unwrap().is_empty());
+        assert_eq!(executor.retained_family_count(), 1);
+        executor.resolver().state.fail_role.set(None);
+        assert!(executor.activate_retained_family(first_handle, 1).unwrap());
+        let report = executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert!(report.cache_hit);
+        assert_eq!(output, [(46.0, 0.0)]);
+
+        executor.clear_families().unwrap();
+        assert!(
+            executor
+                .observed_currents(0)
+                .unwrap_err()
+                .to_string()
+                .contains("requires a prepared execution")
+        );
+    }
+
+    #[test]
+    fn last_family_only_makes_evicted_a_cold_again_across_a_b_a() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let first_selected = [QueryFamilyTraceInput {
+            trace: &first,
+            projection: first_projection,
+        }];
+        let (second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(2));
+        let second_selected = [QueryFamilyTraceInput {
+            trace: &second,
+            projection: second_projection,
+        }];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        let mut output = [(0.0, 0.0)];
+
+        assert!(!executor.prepare(&catalog, &first_selected, 1).unwrap());
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        let first_output = output;
+        let first_schedule = executor
+            .resolver()
+            .state
+            .calls
+            .borrow()
+            .iter()
+            .map(|(role, _, row_count)| (*role, *row_count))
+            .collect::<Vec<_>>();
+        let first_handle = executor.active_retained_handle().unwrap();
+        executor.resolver().state.calls.borrow_mut().clear();
+
+        assert!(!executor.prepare(&catalog, &second_selected, 1).unwrap());
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert_ne!(output, first_output);
+        assert_eq!(executor.retained_family_count(), 1);
+        executor.resolver().state.calls.borrow_mut().clear();
+
+        assert!(
+            executor
+                .activate_retained_family(first_handle, 1)
+                .unwrap_err()
+                .to_string()
+                .contains("cleared arena")
+        );
+        assert!(!executor.prepare(&catalog, &first_selected, 1).unwrap());
+        let report = executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert!(!report.cache_hit);
+        assert_eq!(output, first_output);
+        assert_eq!(executor.retained_family_count(), 1);
+        let rebuilt_schedule = executor
+            .resolver()
+            .state
+            .calls
+            .borrow()
+            .iter()
+            .map(|(role, _, row_count)| (*role, *row_count))
+            .collect::<Vec<_>>();
+        assert_eq!(rebuilt_schedule, first_schedule);
+        assert_eq!(executor.resolver().state.invalidations.get(), 2);
+    }
+
+    #[test]
+    fn clear_invalidates_rows_before_dropping_all_retained_families() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let selected = [QueryFamilyTraceInput {
+            trace: &trace,
+            projection,
+        }];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        let mut output = [(0.0, 0.0)];
+        executor.prepare(&catalog, &selected, 1).unwrap();
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert_eq!(executor.retained_family_count(), 1);
+        let handle = executor.active_retained_handle().unwrap();
+
+        executor.clear_families().unwrap();
+        assert_eq!(executor.resolver().state.invalidations.get(), 1);
+        assert_eq!(executor.retained_family_count(), 0);
+        assert!(executor.prepared_census().is_none());
+        assert!(
+            executor
+                .activate_retained_family(handle, 1)
+                .unwrap_err()
+                .to_string()
+                .contains("cleared arena")
+        );
+        assert!(!executor.prepare(&catalog, &selected, 1).unwrap());
+    }
+
+    #[test]
+    fn wrong_output_shape_fails_before_rows_are_exposed() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (trace, projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let selected = [QueryFamilyTraceInput {
+            trace: &trace,
+            projection,
+        }];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        executor.prepare(&catalog, &selected, 1).unwrap();
+        let error = executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut [])
+            .unwrap_err();
+        assert!(error.to_string().contains("expected 1"));
+        assert!(executor.resolver().state.calls.borrow().is_empty());
+        assert!(executor.pending.is_none());
+
+        let mut output = [(0.0, 0.0)];
+        assert!(!executor.prepare(&catalog, &selected, 1).unwrap());
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert_eq!(output, [(46.0, 0.0)]);
+    }
+
+    #[test]
+    fn failed_candidate_prepare_keeps_last_valid_family_and_handle() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let first_selected = [QueryFamilyTraceInput {
+            trace: &first,
+            projection: first_projection,
+        }];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        let mut output = [(0.0, 0.0)];
+        executor.prepare(&catalog, &first_selected, 1).unwrap();
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        let first_handle = executor.active_retained_handle().unwrap();
+
+        let (mut second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(1));
+        second.seed_digest = SemanticDigest::new([0x83; 32]).unwrap();
+        let error = executor
+            .prepare(
+                &catalog,
+                &[
+                    QueryFamilyTraceInput {
+                        trace: &first,
+                        projection: first_projection,
+                    },
+                    QueryFamilyTraceInput {
+                        trace: &second,
+                        projection: second_projection,
+                    },
+                ],
+                1,
+            )
+            .unwrap_err();
+        assert!(error.to_string().contains("one compact source frame"));
+        assert!(executor.pending.is_none());
+        assert_eq!(executor.retained_family_count(), 1);
+        assert!(executor.activate_retained_family(first_handle, 1).unwrap());
+        let report = executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert!(report.cache_hit);
+        assert_eq!(output, [(46.0, 0.0)]);
+    }
+
+    #[test]
+    fn failed_streamed_candidate_prepare_keeps_last_valid_family_and_handle() {
+        let catalog = direct_catalog();
+        let resolver = ProbeResolver::new(catalog.clone());
+        let (first, first_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x81, factor(1));
+        let first_selected = [QueryFamilyTraceInput {
+            trace: &first,
+            projection: first_projection,
+        }];
+        let mut executor = OnTheFlyQueryFamilyExecutorV1::new(resolver);
+        let mut output = [(0.0, 0.0)];
+        executor.prepare(&catalog, &first_selected, 1).unwrap();
+        executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        let first_handle = executor.active_retained_handle().unwrap();
+
+        let (mut second, second_projection) =
+            OnTheFlyStructuralTraceV1::test_query_family_trace(0x82, factor(1));
+        second.seed_digest = SemanticDigest::new([0x83; 32]).unwrap();
+        let streamed = streamed_pair_candidate(
+            &catalog,
+            &first,
+            first_projection,
+            &second,
+            second_projection,
+            true,
+        );
+        let error = executor
+            .prepare_streamed_candidate(streamed, 1)
+            .unwrap_err();
+        assert!(error.to_string().contains("one compact source frame"));
+        assert!(executor.pending.is_none());
+        assert_eq!(executor.retained_family_count(), 1);
+        assert!(executor.activate_retained_family(first_handle, 1).unwrap());
+        let report = executor
+            .execute_into(&one_point_momenta(2.0, 3.0), 1, &mut output)
+            .unwrap();
+        assert!(report.cache_hit);
+        assert_eq!(output, [(46.0, 0.0)]);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/family/snapshot.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/family/snapshot.rs
new file mode 100644
index 0000000000..e17254fabb
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/family/snapshot.rs
@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Portable rows only: no kernel pointers, descriptor caches, or numeric workspaces.
+
+use super::*;
+
+#[derive(bincode::Encode, bincode::Decode)]
+pub(crate) struct OnTheFlyFamilySnapshotV1 {
+    strategy: u32,
+    census: OnTheFlyQueryFamilyCensusV1,
+    source_count: u32,
+    lorentz_component_count: u16,
+    parameter_count: u32,
+    current_component_count: u32,
+    amplitude_destination_count: u32,
+    momentum_forms: Box<[CanonicalMomentumLinearForm]>,
+    exact_factors: Box<[ExactComplexRational]>,
+    row_groups: Box<[OnTheFlyFamilyRowGroupV1]>,
+}
+
+/// Same wire layout as the owned decoder, borrowing the potentially large rows.
+#[derive(bincode::Encode)]
+pub(crate) struct OnTheFlyFamilySnapshotRefV1<'a> {
+    strategy: u32,
+    census: OnTheFlyQueryFamilyCensusV1,
+    source_count: u32,
+    lorentz_component_count: u16,
+    parameter_count: u32,
+    current_component_count: u32,
+    amplitude_destination_count: u32,
+    momentum_forms: &'a [CanonicalMomentumLinearForm],
+    exact_factors: &'a [ExactComplexRational],
+    row_groups: &'a [OnTheFlyFamilyRowGroupV1],
+}
+
+impl OnTheFlyFamilySnapshotV1 {
+    pub(crate) fn executor_keys(&self) -> impl Iterator<Item = OnTheFlyExecutorKeyV1> + '_ {
+        self.row_groups.iter().flat_map(|group| {
+            std::iter::once(group.representative_key)
+                .chain(group.member_bindings.iter().map(|(key, _)| *key))
+        })
+    }
+
+    pub(crate) const fn census(&self) -> OnTheFlyQueryFamilyCensusV1 {
+        self.census
+    }
+
+    pub(crate) const fn amplitude_destination_count(&self) -> usize {
+        self.amplitude_destination_count as usize
+    }
+
+    fn into_family(self) -> RusticolResult<(RecurrenceStrategy, OnTheFlyBuiltQueryFamilyV1)> {
+        let strategy = match self.strategy {
+            0 => RecurrenceStrategy::TopologyReplay,
+            2 => RecurrenceStrategy::ContractedColorUnion,
+            _ => return Err(integrity("saved OTF family has an unsupported strategy")),
+        };
+        let family = OnTheFlyBuiltQueryFamilyV1 {
+            census: self.census,
+            source_count: self.source_count,
+            lorentz_component_count: self.lorentz_component_count,
+            parameter_count: self.parameter_count,
+            current_component_count: self.current_component_count,
+            amplitude_destination_count: self.amplitude_destination_count,
+            momentum_forms: self.momentum_forms,
+            exact_factors: self.exact_factors,
+            row_groups: self.row_groups,
+            #[cfg(any(test, feature = "on-the-fly-test-support"))]
+            observed_currents: Box::new([]),
+        };
+        validate_ordered_family_schedule(&family.row_groups)?;
+        if family.census.source_frame_partition_count != 1
+            || family.census.union_amplitude_destination_count != family.amplitude_destination_count
+            || family.census.union_unique_current_component_count != family.current_component_count
+        {
+            return Err(integrity(
+                "saved OTF family dimensions disagree with its census",
+            ));
+        }
+        Ok((strategy, family))
+    }
+}
+
+impl<R: OnTheFlyPreparedExecutorResolver> OnTheFlyQueryFamilyExecutorV1<R> {
+    pub(crate) fn snapshot(&self) -> RusticolResult<Option<OnTheFlyFamilySnapshotRefV1<'_>>> {
+        if self.families.len() > 1 {
+            return Err(integrity(
+                "OTF family retention policy changed; update the cache format",
+            ));
+        }
+        Ok(self.families.first().map(|bound| {
+            let family = &bound.family;
+            OnTheFlyFamilySnapshotRefV1 {
+                strategy: bound.strategy.as_u32(),
+                census: family.census,
+                source_count: family.source_count,
+                lorentz_component_count: family.lorentz_component_count,
+                parameter_count: family.parameter_count,
+                current_component_count: family.current_component_count,
+                amplitude_destination_count: family.amplitude_destination_count,
+                momentum_forms: &family.momentum_forms,
+                exact_factors: &family.exact_factors,
+                row_groups: &family.row_groups,
+            }
+        }))
+    }
+
+    /// All fallible allocation and binding happens before replacing the old
+    /// committed owner. No execution or numeric input is required to restore it.
+    pub(crate) fn restore_snapshot(
+        &mut self,
+        snapshot: OnTheFlyFamilySnapshotV1,
+        logical_point_capacity: u32,
+    ) -> RusticolResult<OnTheFlyQueryFamilyHandleV1> {
+        let (strategy, family) = snapshot.into_family()?;
+        if family.parameter_count as usize != self.parameter_state.len() {
+            return Err(integrity(
+                "saved OTF parameter layout differs from the loaded model",
+            ));
+        }
+        let resolved_groups = self.bind_groups(&family)?;
+        let packed_singleton_capable =
+            Self::resolved_groups_are_packed_singleton_capable(&family, &resolved_groups);
+        let workspace = OnTheFlyFamilyWorkspaceV1::new(
+            &family,
+            logical_point_capacity,
+            packed_singleton_capable,
+        )?;
+        let interaction_program =
+            Self::bind_interaction_program(&family, &resolved_groups, strategy)?;
+        let singleton_fanout_program =
+            Self::bind_singleton_fanout_program(&family, &resolved_groups)?;
+        if self.families.capacity() == 0 {
+            self.families.try_reserve_exact(1).map_err(|error| {
+                invalid(format!("OTF restored-family allocation failed: {error}"))
+            })?;
+        }
+        let candidate = BoundOnTheFlyQueryFamilyV1 {
+            identity: QueryFamilyCacheIdentityV1::Restored,
+            strategy,
+            family,
+            workspace,
+            resolved_groups,
+            packed_singleton_capable,
+            interaction_program,
+            singleton_fanout_program,
+            applied_parameter_version: u64::MAX,
+            descriptor_exposed: false,
+        };
+        self.invalidate_exposed_row_tables()?;
+        self.pending = Some(candidate);
+        if let Err(error) = self.commit_pending_family() {
+            // The fresh candidate has never exposed a row pointer. In
+            // particular, generation-counter exhaustion must not leave it
+            // selected after a failed restore of a previously warm runner.
+            self.pending = None;
+            return Err(error);
+        }
+        self.active_retained_handle()
+            .ok_or_else(|| integrity("restored OTF family has no handle"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn snapshot_decode_keeps_canonical_type_invariants() {
+        let config = bincode::config::standard();
+        for denominator in [0_i128, -1] {
+            let bytes = bincode::encode_to_vec((1_i128, denominator), config).unwrap();
+            assert!(
+                bincode::decode_from_slice::<crate::recurrence::ExactRational, _>(&bytes, config)
+                    .is_err()
+            );
+        }
+        let bytes = bincode::encode_to_vec([0_u8; 32], config).unwrap();
+        assert!(bincode::decode_from_slice::<SemanticDigest, _>(&bytes, config).is_err());
+        let bytes = bincode::encode_to_vec(
+            vec![crate::recurrence::MomentumTerm {
+                source_slot: 0,
+                coefficient: 0,
+            }],
+            config,
+        )
+        .unwrap();
+        assert!(
+            bincode::decode_from_slice::<CanonicalMomentumLinearForm, _>(&bytes, config).is_err()
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/interpreter.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/interpreter.rs
new file mode 100644
index 0000000000..d174c18f87
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/interpreter.rs
@@ -0,0 +1,569 @@
+// SPDX-License-Identifier: 0BSD
+
+#![allow(dead_code)] // Query-local compatibility path; production uses persisted families.
+
+use super::*;
+use crate::recurrence::{
+    DirectResolvedSourceSelection, DirectSourceDispatchVariantDescriptor, DirectSourceEmbeddingRow,
+};
+
+/// Borrowed authenticated tables used to cold-bind one selected-helicity
+/// source program.
+///
+/// The direct plan remains the serialized authority.  A process-owned source
+/// resolver consumes this view once when a persisted helicity family is
+/// prepared and returns compact executable rows; no table from this view is
+/// retained by the warm program.
+#[derive(Clone, Copy)]
+pub(crate) struct OnTheFlyUnionSourceBindingView<'a> {
+    pub(crate) sources: &'a [DirectSourceRow],
+    pub(crate) variants: &'a [DirectSourceDispatchVariantDescriptor],
+    pub(crate) embeddings: &'a [DirectSourceEmbeddingRow],
+    pub(crate) selections: &'a [DirectResolvedSourceSelection],
+    pub(crate) exact_factors: &'a [ExactComplexRational],
+    pub(crate) current_component_count: u32,
+    pub(crate) momentum_form_count: u32,
+    pub(crate) parameter_count: u32,
+}
+
+/// Opaque, family-local source program produced by one cold authenticated
+/// binding.  Implementations own every template and embedding descriptor they
+/// need, so execution neither borrows the direct plan nor searches a source
+/// domain.
+pub(crate) trait OnTheFlyBoundUnionSourceProgram {
+    /// Execute against views already authenticated by `validate_direct_views`.
+    ///
+    /// # Safety
+    ///
+    /// The caller must provide live, nonaliasing Direct-Arena views whose
+    /// declared shapes match the plan used for cold binding.
+    unsafe fn execute(
+        &self,
+        arena: DirectArenaView,
+        momenta: DirectMomentumView,
+        parameters: DirectParameterView,
+        point_count: u32,
+    ) -> RusticolResult<()>;
+}
+
+/// Resolved prepared executor borrowed from a lane-owned pool/binding.
+#[derive(Clone, Copy)]
+pub(crate) struct ResolvedOnTheFlyExecutor {
+    pub(crate) direct_executor_id: u32,
+    pub(crate) handle: DirectExecutorHandle,
+    pub(crate) parent_permutation: [u8; 2],
+    /// Exact process-bound proof that this prepared callback accepts a
+    /// singleton arena whose physical point stride is one. Query families
+    /// use the packed layout only when every resolved row-group member
+    /// carries this capability.
+    pub(crate) packed_singleton_capable: bool,
+    /// Authenticated intrinsic-only native contribution capability used by
+    /// fanout and interaction rewrites. SymJIT, compiled-native, source,
+    /// finalization, and closure bindings keep None.
+    pub(crate) interaction_capability: Option<DirectInteractionExecutorCapability>,
+}
+
+/// Semantic resolver implemented by the lane-owned prepared executor pool.
+pub(crate) trait OnTheFlyPreparedExecutorResolver {
+    fn resolve(&self, key: OnTheFlyExecutorKeyV1) -> RusticolResult<ResolvedOnTheFlyExecutor>;
+
+    /// Resolve an executor already authenticated by a persisted direct plan.
+    /// Query-local traces use [`Self::resolve`]; persisted helicity families
+    /// need no second semantic-key catalog because the plan layout owns the
+    /// dense executor IDs and row parent order.
+    fn resolve_direct_executor(
+        &self,
+        _direct_executor_id: u32,
+        _role: DirectExecutorRole,
+    ) -> RusticolResult<ResolvedOnTheFlyExecutor> {
+        Err(integrity(
+            "prepared executor resolver does not support persisted direct-plan IDs",
+        ))
+    }
+
+    /// Runtime-helicity source dispatcher owned beside the prepared pool.
+    fn union_source_dispatch(&self) -> RusticolResult<DirectUnionSourceDispatchHandle> {
+        Err(integrity(
+            "prepared executor resolver has no all-flow-union source dispatcher",
+        ))
+    }
+
+    /// Cold-bind one selected all-flow source schedule.  The default keeps
+    /// query-only resolvers deliberately incapable of executing a persisted
+    /// selector family.
+    fn bind_union_source_program(
+        &self,
+        _view: OnTheFlyUnionSourceBindingView<'_>,
+    ) -> RusticolResult<Box<dyn OnTheFlyBoundUnionSourceProgram>> {
+        Err(integrity(
+            "prepared executor resolver cannot cold-bind all-flow-union sources",
+        ))
+    }
+
+    fn union_source_packed_singleton_capable(&self) -> bool {
+        false
+    }
+
+    /// Invalidate any prepared-context caches that borrow row or arena pointers.
+    /// Native/Rust callbacks retain no such pointers and need no work here.
+    fn invalidate_row_tables(&self) -> RusticolResult<()>;
+}
+
+fn checked_scalar_len(planes: u32, stride: u32, label: &str) -> RusticolResult<usize> {
+    usize::try_from(planes)
+        .ok()
+        .and_then(|planes| planes.checked_mul(stride as usize))
+        .ok_or_else(|| invalid(format!("{label} scalar length exceeds usize")))
+}
+
+fn exact_factor_parts(value: ExactComplexRational) -> RusticolResult<(f64, f64)> {
+    let real = value.real().numerator() as f64 / value.real().denominator() as f64;
+    let imag = value.imag().numerator() as f64 / value.imag().denominator() as f64;
+    if !real.is_finite() || !imag.is_finite() {
+        return Err(invalid(
+            "exact factor cannot be represented as finite binary64",
+        ));
+    }
+    Ok((real, imag))
+}
+
+/// Owned aligned numeric state for one on-the-fly lane.  Structural traces do
+/// not own this storage and parameter mutation never rebuilds them.
+pub(crate) struct OnTheFlyWorkspaceV1 {
+    current_re: AlignedF64Buffer,
+    current_im: AlignedF64Buffer,
+    amplitude_re: AlignedF64Buffer,
+    amplitude_im: AlignedF64Buffer,
+    momenta: AlignedF64Buffer,
+    parameters_re: AlignedF64Buffer,
+    parameters_im: AlignedF64Buffer,
+    factors_re: AlignedF64Buffer,
+    factors_im: AlignedF64Buffer,
+    trace_digest: SemanticDigest,
+    source_count: u32,
+    logical_point_capacity: u32,
+    active_point_count: u32,
+    momentum_form_count: u32,
+    lorentz_component_count: u16,
+    point_stride: u32,
+}
+
+impl OnTheFlyWorkspaceV1 {
+    pub(crate) fn new(
+        trace: &OnTheFlyStructuralTraceV1,
+        logical_point_capacity: u32,
+    ) -> RusticolResult<Self> {
+        let layout = trace.layout;
+        if layout.source_count == 0
+            || logical_point_capacity == 0
+            || layout.lorentz_component_count == 0
+        {
+            return Err(integrity(
+                "trace has an empty authenticated workspace shape",
+            ));
+        }
+        if trace.layout.momentum_form_count == 0
+            || trace.layout.exact_factor_count as usize != trace.exact_factors.len()
+        {
+            return Err(integrity("trace workspace layout is inconsistent"));
+        }
+        let point_stride = checked_aligned_point_stride(logical_point_capacity)?;
+        let current_len = checked_scalar_len(
+            trace.layout.current_component_count,
+            point_stride,
+            "current arena",
+        )?;
+        let amplitude_len = checked_scalar_len(
+            trace.layout.amplitude_component_count,
+            point_stride,
+            "amplitude arena",
+        )?;
+        let momentum_planes = trace
+            .layout
+            .momentum_form_count
+            .checked_mul(u32::from(layout.lorentz_component_count))
+            .ok_or_else(|| invalid("momentum plane count exceeds u32"))?;
+        let momentum_len = checked_scalar_len(momentum_planes, point_stride, "momentum arena")?;
+        let factor_count = trace.exact_factors.len();
+        let mut factors_re = AlignedF64Buffer::zeroed(factor_count, "on-the-fly factor real")?;
+        let mut factors_im = AlignedF64Buffer::zeroed(factor_count, "on-the-fly factor imaginary")?;
+        for (index, factor) in trace.exact_factors.iter().copied().enumerate() {
+            let (real, imag) = exact_factor_parts(factor)?;
+            factors_re.as_mut_slice()[index] = real;
+            factors_im.as_mut_slice()[index] = imag;
+        }
+        Ok(Self {
+            current_re: AlignedF64Buffer::zeroed(current_len, "on-the-fly current real")?,
+            current_im: AlignedF64Buffer::zeroed(current_len, "on-the-fly current imaginary")?,
+            amplitude_re: AlignedF64Buffer::zeroed(amplitude_len, "on-the-fly amplitude real")?,
+            amplitude_im: AlignedF64Buffer::zeroed(
+                amplitude_len,
+                "on-the-fly amplitude imaginary",
+            )?,
+            momenta: AlignedF64Buffer::zeroed(momentum_len, "on-the-fly momenta")?,
+            parameters_re: AlignedF64Buffer::zeroed(
+                usize::try_from(layout.parameter_count)
+                    .map_err(|_| invalid("parameter count exceeds usize"))?,
+                "on-the-fly parameter real",
+            )?,
+            parameters_im: AlignedF64Buffer::zeroed(
+                usize::try_from(layout.parameter_count)
+                    .map_err(|_| invalid("parameter count exceeds usize"))?,
+                "on-the-fly parameter imaginary",
+            )?,
+            factors_re,
+            factors_im,
+            trace_digest: trace.semantic_digest(),
+            source_count: layout.source_count,
+            logical_point_capacity,
+            active_point_count: 0,
+            momentum_form_count: trace.layout.momentum_form_count,
+            lorentz_component_count: layout.lorentz_component_count,
+            point_stride,
+        })
+    }
+
+    pub(crate) const fn point_stride(&self) -> u32 {
+        self.point_stride
+    }
+
+    pub(crate) fn set_parameter(
+        &mut self,
+        parameter_id: u32,
+        real: f64,
+        imag: f64,
+    ) -> RusticolResult<()> {
+        self.active_point_count = 0;
+        if !real.is_finite() || !imag.is_finite() {
+            return Err(invalid("runtime parameter value must be finite"));
+        }
+        let index = parameter_id as usize;
+        *self
+            .parameters_re
+            .as_mut_slice()
+            .get_mut(index)
+            .ok_or_else(|| invalid("runtime parameter ID is out of bounds"))? = real;
+        *self
+            .parameters_im
+            .as_mut_slice()
+            .get_mut(index)
+            .ok_or_else(|| invalid("runtime parameter ID is out of bounds"))? = imag;
+        Ok(())
+    }
+
+    pub(crate) fn set_momentum_value(
+        &mut self,
+        momentum_form_id: u32,
+        lorentz_component: u16,
+        point_index: u32,
+        value: f64,
+    ) -> RusticolResult<()> {
+        self.active_point_count = 0;
+        if !value.is_finite()
+            || momentum_form_id >= self.momentum_form_count
+            || lorentz_component >= self.lorentz_component_count
+            || point_index >= self.logical_point_capacity
+        {
+            return Err(invalid("momentum workspace coordinate or value is invalid"));
+        }
+        let plane = usize::try_from(momentum_form_id)
+            .ok()
+            .and_then(|form| form.checked_mul(usize::from(self.lorentz_component_count)))
+            .and_then(|base| base.checked_add(usize::from(lorentz_component)))
+            .ok_or_else(|| invalid("momentum plane index exceeds usize"))?;
+        let index = plane
+            .checked_mul(self.point_stride as usize)
+            .and_then(|base| base.checked_add(point_index as usize))
+            .ok_or_else(|| invalid("momentum scalar index exceeds usize"))?;
+        self.momenta.as_mut_slice()[index] = value;
+        Ok(())
+    }
+
+    pub(crate) fn fill_momenta_from_external(
+        &mut self,
+        trace: &OnTheFlyStructuralTraceV1,
+        external_momenta: &[f64],
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        self.active_point_count = 0;
+        if self.trace_digest != trace.semantic_digest() {
+            return Err(integrity(
+                "workspace belongs to a different structural trace",
+            ));
+        }
+        if point_count == 0 || point_count > self.logical_point_capacity {
+            return Err(invalid("active point count is outside the workspace"));
+        }
+        let expected = usize::try_from(self.source_count)
+            .ok()
+            .and_then(|sources| sources.checked_mul(usize::from(self.lorentz_component_count)))
+            .and_then(|planes| planes.checked_mul(point_count as usize))
+            .ok_or_else(|| invalid("external momentum shape exceeds usize"))?;
+        if external_momenta.len() != expected {
+            return Err(invalid(format!(
+                "external momentum input has {} scalars, expected {expected}",
+                external_momenta.len()
+            )));
+        }
+        for (form_id, form) in trace.momentum_forms.iter().enumerate() {
+            for lorentz in 0..usize::from(self.lorentz_component_count) {
+                for point in 0..point_count as usize {
+                    let mut value = 0.0;
+                    for term in form.terms() {
+                        if term.source_slot >= self.source_count {
+                            return Err(integrity("momentum form source slot is out of bounds"));
+                        }
+                        let input_index = (term.source_slot as usize
+                            * usize::from(self.lorentz_component_count)
+                            + lorentz)
+                            * point_count as usize
+                            + point;
+                        value += f64::from(term.coefficient) * external_momenta[input_index];
+                    }
+                    self.set_momentum_value(form_id as u32, lorentz as u16, point as u32, value)?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn amplitude(&self, point_index: u32) -> RusticolResult<(f64, f64)> {
+        if point_index >= self.active_point_count {
+            return Err(invalid(
+                "amplitude point is outside the last successful execution",
+            ));
+        }
+        let index = point_index as usize;
+        Ok((
+            self.amplitude_re.as_slice()[index],
+            self.amplitude_im.as_slice()[index],
+        ))
+    }
+
+    fn clear_active(&mut self, point_count: u32) -> RusticolResult<()> {
+        if point_count == 0 || point_count > self.logical_point_capacity {
+            return Err(invalid("active point count is outside the workspace"));
+        }
+        for (real, imag) in [
+            (&mut self.current_re, &mut self.current_im),
+            (&mut self.amplitude_re, &mut self.amplitude_im),
+        ] {
+            for plane in 0..real.len() / self.point_stride as usize {
+                let start = plane * self.point_stride as usize;
+                let end = start + point_count as usize;
+                real.as_mut_slice()[start..end].fill(0.0);
+                imag.as_mut_slice()[start..end].fill(0.0);
+            }
+        }
+        Ok(())
+    }
+
+    fn raw_views(
+        &mut self,
+    ) -> RusticolResult<(
+        DirectArenaView,
+        DirectMomentumView,
+        DirectParameterView,
+        DirectFactorView,
+    )> {
+        let arena = DirectArenaView {
+            current_re: self.current_re.as_mut_ptr(),
+            current_im: self.current_im.as_mut_ptr(),
+            current_scalar_len: self.current_re.len() as u64,
+            amplitude_re: self.amplitude_re.as_mut_ptr(),
+            amplitude_im: self.amplitude_im.as_mut_ptr(),
+            amplitude_scalar_len: self.amplitude_re.len() as u64,
+            point_stride: self.point_stride,
+        };
+        let momenta = DirectMomentumView {
+            values: self.momenta.as_ptr(),
+            scalar_len: self.momenta.len() as u64,
+            form_count: self.momentum_form_count,
+            lorentz_component_count: self.lorentz_component_count,
+            point_stride: self.point_stride,
+        };
+        let parameters = DirectParameterView {
+            values_re: self.parameters_re.as_ptr(),
+            values_im: self.parameters_im.as_ptr(),
+            value_count: self.parameters_re.len() as u32,
+        };
+        let factors = DirectFactorView {
+            values_re: self.factors_re.as_ptr(),
+            values_im: self.factors_im.as_ptr(),
+            value_count: self.factors_re.len() as u32,
+        };
+        validate_direct_views(arena, momenta, parameters, factors)?;
+        Ok((arena, momenta, parameters, factors))
+    }
+}
+
+fn validate_resolved_executor(
+    key: OnTheFlyExecutorKeyV1,
+    resolved: ResolvedOnTheFlyExecutor,
+) -> RusticolResult<()> {
+    if resolved.handle.role() != key.role() {
+        return Err(integrity(
+            "resolved executor role differs from its semantic key",
+        ));
+    }
+    match key.role() {
+        DirectExecutorRole::Contribution => match resolved.parent_permutation {
+            [0, 1] | [1, 0] => {}
+            _ => {
+                return Err(integrity(
+                    "resolved binary executor has an invalid permutation",
+                ));
+            }
+        },
+        DirectExecutorRole::Source
+        | DirectExecutorRole::Finalization
+        | DirectExecutorRole::Closure => {
+            if resolved.parent_permutation != [0, 1] {
+                return Err(integrity(
+                    "unary executor unexpectedly permutes parent rows",
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Direct structural interpreter.  It resolves every operation by semantic
+/// identity and invokes genuine prepared Direct-Arena kernels without a plan.
+pub(crate) struct OnTheFlyStructuralInterpreter;
+
+impl OnTheFlyStructuralInterpreter {
+    pub(crate) fn execute(
+        trace: &OnTheFlyStructuralTraceV1,
+        resolver: &impl OnTheFlyPreparedExecutorResolver,
+        workspace: &mut OnTheFlyWorkspaceV1,
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        if !trace.prepared_executor_rows_bound() {
+            return Err(integrity(
+                "prepared executor parent order is not bound into stable trace rows",
+            ));
+        }
+        if workspace.trace_digest != trace.semantic_digest() {
+            return Err(integrity(
+                "workspace belongs to a different structural trace",
+            ));
+        }
+        workspace.active_point_count = 0;
+        workspace.clear_active(point_count)?;
+        let (arena, momenta, parameters, factors) = workspace.raw_views()?;
+        for operation in trace.operations.iter() {
+            let key = operation.key();
+            let resolved = resolver.resolve(key)?;
+            validate_resolved_executor(key, resolved)?;
+            clear_direct_executor_error_detail();
+            let status: c_int = unsafe {
+                match (operation, resolved.handle) {
+                    (
+                        OnTheFlyTraceOperationV1::Source { row, .. },
+                        DirectExecutorHandle::Source { call, context },
+                    ) => call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        row,
+                        1,
+                        point_count,
+                    ),
+                    (
+                        OnTheFlyTraceOperationV1::Contribution { row, .. },
+                        DirectExecutorHandle::Contribution { call, context },
+                    ) => call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        row,
+                        1,
+                        point_count,
+                    ),
+                    (
+                        OnTheFlyTraceOperationV1::Finalization { row, .. },
+                        DirectExecutorHandle::Finalization { call, context },
+                    ) => call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        row,
+                        1,
+                        point_count,
+                    ),
+                    (
+                        OnTheFlyTraceOperationV1::Closure { row, .. },
+                        DirectExecutorHandle::Closure { call, context },
+                    ) => call(
+                        context,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                        row,
+                        1,
+                        point_count,
+                    ),
+                    _ => {
+                        return Err(integrity(
+                            "resolved executor handle variant differs from trace operation",
+                        ));
+                    }
+                }
+            };
+            crate::recurrence::direct_backend::check_status(
+                key.role(),
+                resolved.direct_executor_id,
+                status,
+            )?;
+        }
+        workspace.active_point_count = point_count;
+        Ok(())
+    }
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+impl OnTheFlyWorkspaceV1 {
+    pub(crate) fn observed_current_components(
+        &self,
+        trace: &OnTheFlyStructuralTraceV1,
+        current_id: u32,
+        point_index: u32,
+    ) -> RusticolResult<Vec<(f64, f64)>> {
+        if self.trace_digest != trace.semantic_digest() || point_index >= self.active_point_count {
+            return Err(invalid(
+                "current observation does not match the last successful trace execution",
+            ));
+        }
+        let [component_base, component_count] = trace.current_component_range(current_id)?;
+        (0..component_count)
+            .map(|component_offset| {
+                let plane = component_base
+                    .checked_add(component_offset)
+                    .ok_or_else(|| integrity("current observation plane overflows"))?;
+                let index = usize::try_from(plane)
+                    .ok()
+                    .and_then(|plane| plane.checked_mul(self.point_stride as usize))
+                    .and_then(|base| base.checked_add(point_index as usize))
+                    .ok_or_else(|| integrity("current observation index exceeds usize"))?;
+                Ok((
+                    *self
+                        .current_re
+                        .as_slice()
+                        .get(index)
+                        .ok_or_else(|| integrity("current observation real value is absent"))?,
+                    *self.current_im.as_slice().get(index).ok_or_else(|| {
+                        integrity("current observation imaginary value is absent")
+                    })?,
+                ))
+            })
+            .collect()
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/mod.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/mod.rs
new file mode 100644
index 0000000000..6eb8d95519
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/mod.rs
@@ -0,0 +1,791 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Private query-local LC recurrence construction and direct interpretation.
+//!
+//! This module deliberately consumes one decoded physical LC selector.  It
+//! never constructs a process-wide color plan, selector projection, replay
+//! catalog, feasibility index, or [`super::DirectRecurrencePlan`].
+
+use std::collections::{BTreeMap, BTreeSet, VecDeque};
+use std::ffi::c_int;
+
+use rayon::prelude::*;
+use sha2::{Digest, Sha256};
+
+use super::construct::{
+    TemplateCatalog, aggregate_factor, combined_coupling_orders, merged_helicity_identity,
+    merged_momentum, multiply_factors, output_factor_from_binding, quantum_parent_spin_matches,
+    validate_crossed_source_state,
+};
+use super::contact_orbit_owner::{
+    PreparedContactOrbitTransition, prepare_contact_orbit_transition,
+    selected_contact_orbit_owner_tokens,
+};
+use super::direct_backend::{
+    DirectExecutorHandle, DirectInteractionExecutorCapability, DirectInteractionGroupAction,
+    DirectInteractionGroupView, DirectInteractionProgram, DirectInteractionScheduleView,
+    DirectSingletonContributionFanoutProgram, DirectUnionSourceDispatchHandle,
+    clear_direct_executor_error_detail,
+};
+use super::direct_plan::{
+    DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION, DirectClosureRow, DirectContributionRow,
+    DirectExecutorRole, DirectFinalizationRow, DirectSourceRow,
+};
+use super::process::ProcessSourceStateRow;
+use super::template::{
+    ClosureRow, CurrentStateRow, EvaluatorContractKind, LCColorTransitionWitnessRow,
+    QuantumFlowRow, SourceRow, TransitionRow, ValidatedRecurrenceTemplateInput,
+};
+use super::{
+    CanonicalMomentumLinearForm, ContributionKey, CurrentCoreKey, CurrentHelicityIdentity,
+    CurrentSourceBinding, DynamicLCColorState, DynamicLCColorStateInterner, ExactComplexRational,
+    LCColorComponent, LCColorComponentKind, LCColorSourceSeed, LCColorWitnessTermId, MomentumTerm,
+    PreparedDirectExecutorBinding, PreparedDirectExecutorCatalog, RecurrenceNodeKind,
+    RecurrenceStrategy, SemanticDigest, SourceStateAssignment,
+};
+use crate::direct_arena::{
+    AlignedF64Buffer, DirectArenaView, DirectFactorView, DirectMomentumView, DirectParameterView,
+    checked_aligned_point_stride, validate_direct_views,
+};
+use crate::{RusticolError, RusticolResult};
+
+const MISSING_U32: u32 = u32::MAX;
+const ON_THE_FLY_PROOF_DOMAIN: &[u8] = b"pyamplicol-on-the-fly-structural-proof-v1\0";
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(format!("on-the-fly recurrence: {}", message.into()))
+}
+
+fn integrity(message: impl Into<String>) -> RusticolError {
+    RusticolError::integrity(format!("on-the-fly recurrence: {}", message.into()))
+}
+
+#[allow(dead_code)] // Query-local compatibility and probe error constructor.
+fn evaluation(message: impl Into<String>) -> RusticolError {
+    RusticolError::evaluation(format!("on-the-fly recurrence: {}", message.into()))
+}
+
+fn checked_u32(value: usize, label: &str) -> RusticolResult<u32> {
+    u32::try_from(value).map_err(|_| invalid(format!("{label} exceeds u32")))
+}
+
+fn hash_len(hash: &mut Sha256, value: usize, label: &str) -> RusticolResult<()> {
+    hash.update(
+        u64::try_from(value)
+            .map_err(|_| invalid(format!("{label} length exceeds u64")))?
+            .to_le_bytes(),
+    );
+    Ok(())
+}
+
+fn hash_digest(hash: &mut Sha256, digest: SemanticDigest) {
+    hash.update(digest.as_bytes());
+}
+
+fn hash_exact(hash: &mut Sha256, value: ExactComplexRational) {
+    for part in [value.real(), value.imag()] {
+        hash.update(part.numerator().to_le_bytes());
+        hash.update(part.denominator().to_le_bytes());
+    }
+}
+
+fn final_digest(hash: Sha256) -> RusticolResult<SemanticDigest> {
+    SemanticDigest::new(hash.finalize().into())
+}
+
+mod coupling_policy;
+mod family;
+mod interpreter;
+mod persisted;
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+mod probe_guard;
+mod projection;
+mod public_query;
+pub(crate) mod seed_codec;
+mod source_builder;
+mod source_seed;
+mod sweep;
+mod templates;
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+mod test_support;
+mod trace;
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+pub(crate) use coupling_policy::OnTheFlyCouplingPolicyCensusV1;
+pub(crate) use coupling_policy::OnTheFlyResolvedCouplingPolicyV1;
+pub use family::OnTheFlyQueryFamilyCensusV1;
+#[cfg(feature = "on-the-fly-test-support")]
+pub use family::on_the_fly_query_family_census_v1;
+pub(crate) use family::snapshot::{OnTheFlyFamilySnapshotRefV1, OnTheFlyFamilySnapshotV1};
+pub(crate) use family::{
+    OnTheFlyQueryFamilyExecutionReportV1, OnTheFlyQueryFamilyExecutorV1,
+    OnTheFlyQueryFamilyHandleV1, QueryFamilyTraceInput, build_streamed_query_family_candidate_v1,
+};
+#[allow(unused_imports)] // Query-local interpreter remains available to opt-in test support.
+pub(crate) use interpreter::{
+    OnTheFlyBoundUnionSourceProgram, OnTheFlyPreparedExecutorResolver,
+    OnTheFlyStructuralInterpreter, OnTheFlyUnionSourceBindingView, OnTheFlyWorkspaceV1,
+    ResolvedOnTheFlyExecutor,
+};
+pub(crate) use persisted::{
+    PersistedHelicityAmplitudeTileV1, PersistedHelicityFamilyCacheCensusV1,
+    PersistedHelicityFamilyExecutionReportV1, PersistedHelicityFamilyExecutorV1,
+    PersistedHelicityFamilyInspectionCensusV1,
+};
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+pub(crate) use probe_guard::OnTheFlyForbiddenWorkGuardV1;
+#[cfg(feature = "on-the-fly-test-support")]
+pub(crate) use probe_guard::{OnTheFlyForbiddenWorkV1, reject_forbidden_work_if_probed};
+use projection::*;
+use public_query::OnTheFlyClosureAnchorPolicyV1;
+pub(crate) use public_query::OnTheFlyLcSelectorV1;
+pub(crate) use public_query::{DecodedLcQueryV1, OnTheFlySelectedSourceV1};
+pub(crate) use seed_codec::decode_on_the_fly_process_seed_v1;
+#[allow(unused_imports)] // Generation-only entries share this runtime validation seam.
+pub(crate) use source_builder::{
+    build_on_the_fly_process_seed_v1, build_on_the_fly_process_seeds_v1,
+    parse_on_the_fly_process_seed_projection_v1, validate_on_the_fly_source_mass_bindings_v1,
+};
+#[cfg(test)]
+pub(crate) use source_seed::scalar_adapter_test_seed;
+#[allow(unused_imports)] // Pairing records are consumed by nested generation/test modules.
+pub(crate) use source_seed::{
+    ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI, OnTheFlyCouplingOrderPolicyV1,
+    OnTheFlyExternalColorRoleV1, OnTheFlyPairingClassV1, OnTheFlyPairingEndpointV1,
+    OnTheFlyProcessSeedIdentityV1, OnTheFlyProcessSeedV1, OnTheFlySourceAnchorV1,
+    OnTheFlySourceExecutionSpecV1, OnTheFlySourceOrientationV1, OnTheFlySourceStateV1,
+    OnTheFlySourceWavefunctionFamilyV1,
+};
+use sweep::*;
+pub(crate) use templates::PreparedOnTheFlyGrammarV1;
+use templates::*;
+#[cfg(feature = "on-the-fly-test-support")]
+pub use test_support::{OnTheFlyTestSupportReportV1, on_the_fly_test_support_probe_v1};
+#[cfg(feature = "on-the-fly-test-support")]
+pub(crate) use test_support::{
+    build_on_the_fly_selected_trace_against_seed_v1, build_on_the_fly_selected_trace_v1,
+};
+#[cfg(feature = "on-the-fly-test-support")]
+pub(crate) use trace::ON_THE_FLY_WORK_CENSUS_BASIS_V1;
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+pub(crate) use trace::hash_current_key;
+#[cfg(test)]
+pub(crate) use trace::scalar_adapter_test_trace;
+use trace::*;
+pub(crate) use trace::{
+    OnTheFlyExecutorKeyV1, OnTheFlyStructuralTraceV1, authenticated_prepared_executor_binding,
+};
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct OnTheFlyProjectionProbeV1 {
+    pub(crate) enabled: bool,
+    pub(crate) applied: bool,
+    pub(crate) pre: [u32; 3],
+    pub(crate) post: [u32; 3],
+}
+
+/// One compact, selector-local LC trace ready for prepared-executor binding.
+///
+/// This production seam owns no global recurrence builder or direct plan. Its
+/// inputs are precisely the compact process seed, one already-decoded public
+/// query, and the authenticated prepared template catalogs.
+pub(crate) struct OnTheFlySelectedQueryTraceV1 {
+    pub(crate) query: DecodedLcQueryV1,
+    pub(crate) trace: OnTheFlyStructuralTraceV1,
+    pub(crate) projection: OnTheFlyProjectionProbeV1,
+}
+
+#[allow(clippy::large_enum_variant)] // Cold-path trace ownership avoids an extra allocation.
+pub(crate) enum OnTheFlySelectedQueryOutcomeV1 {
+    Trace(OnTheFlySelectedQueryTraceV1),
+    StructuralZero { query: DecodedLcQueryV1 },
+}
+
+#[allow(dead_code)] // Compatibility entry point for the query-local probe path.
+pub(crate) fn build_selected_lc_query_trace_v1(
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct: &PreparedDirectExecutorCatalog,
+    seed: &OnTheFlyProcessSeedV1,
+    coupling_policy: &OnTheFlyResolvedCouplingPolicyV1,
+    query: DecodedLcQueryV1,
+) -> RusticolResult<OnTheFlySelectedQueryOutcomeV1> {
+    let catalog = validate_seed_against_templates(templates, seed)?;
+    let grammar = prepare_on_the_fly_grammar_v1(templates, &catalog, seed)?;
+    let query = grammar.canonicalize_query(seed, query)?;
+    build_selected_lc_query_trace_impl(
+        templates,
+        direct,
+        seed,
+        coupling_policy,
+        &grammar,
+        query,
+        true,
+        false,
+    )
+}
+
+/// Prepare the immutable process grammar and process-global coupling policy
+/// in one pass over the validated template catalog.  Runtime load deliberately
+/// does not call this; the first genuinely cold query family does.
+pub(crate) fn prepare_on_the_fly_process_v1(
+    templates: &ValidatedRecurrenceTemplateInput,
+    seed: &OnTheFlyProcessSeedV1,
+) -> RusticolResult<(PreparedOnTheFlyGrammarV1, OnTheFlyResolvedCouplingPolicyV1)> {
+    let catalog = validate_seed_against_templates(templates, seed)?;
+    let grammar = prepare_on_the_fly_grammar_v1(templates, &catalog, seed)?;
+    let policy = coupling_policy::resolve_on_the_fly_coupling_policy_from_grammar_v1(
+        templates, seed, &grammar,
+    )?;
+    Ok((grammar, policy))
+}
+
+/// Recreate model-only grammar while retaining the saved process-global
+/// coupling decision; in particular, do not repeat the topology sweep.
+pub(crate) fn restore_on_the_fly_grammar_v1(
+    templates: &ValidatedRecurrenceTemplateInput,
+    seed: &OnTheFlyProcessSeedV1,
+    policy: &OnTheFlyResolvedCouplingPolicyV1,
+) -> RusticolResult<PreparedOnTheFlyGrammarV1> {
+    if policy.seed_digest() != seed.semantic_digest()
+        || policy.effective_limits().len() != seed.explicit_coupling_limits().len()
+    {
+        return Err(integrity(
+            "saved on-the-fly coupling policy belongs to a different process",
+        ));
+    }
+    let catalog = validate_seed_against_templates(templates, seed)?;
+    prepare_on_the_fly_grammar_v1(templates, &catalog, seed)
+}
+
+fn resolve_indexed_query_results<T>(outcomes: Vec<RusticolResult<T>>) -> RusticolResult<Vec<T>> {
+    outcomes.into_iter().collect()
+}
+
+/// One cold, bounded construction pool reused across every streamed query
+/// chunk.  Keeping the pool outside the chunk loop avoids creating O(H x S)
+/// thread pools while retaining deterministic indexed outcomes.
+pub(crate) struct OnTheFlyQueryConstructionPoolV1 {
+    pool: Option<rayon::ThreadPool>,
+    thread_count: usize,
+}
+
+impl OnTheFlyQueryConstructionPoolV1 {
+    pub(crate) fn new(thread_count: usize) -> RusticolResult<Self> {
+        if thread_count == 0 {
+            return Err(invalid(
+                "on-the-fly query construction thread count must be positive",
+            ));
+        }
+        let pool = (thread_count > 1)
+            .then(|| {
+                rayon::ThreadPoolBuilder::new()
+                    .num_threads(thread_count)
+                    .build()
+                    .map_err(|error| {
+                        RusticolError::internal(format!(
+                            "could not create bounded on-the-fly query construction pool: {error}"
+                        ))
+                    })
+            })
+            .transpose()?;
+        Ok(Self { pool, thread_count })
+    }
+
+    pub(crate) const fn chunk_capacity(&self) -> usize {
+        self.thread_count
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn build_chunk(
+        &self,
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct: &PreparedDirectExecutorCatalog,
+        seed: &OnTheFlyProcessSeedV1,
+        coupling_policy: &OnTheFlyResolvedCouplingPolicyV1,
+        grammar: &PreparedOnTheFlyGrammarV1,
+        enable_cyclic_trace_reflection: bool,
+        queries: Vec<DecodedLcQueryV1>,
+    ) -> RusticolResult<Vec<OnTheFlySelectedQueryOutcomeV1>> {
+        if queries.len() > self.thread_count {
+            return Err(invalid(
+                "streamed on-the-fly query chunk exceeds its bounded construction pool",
+            ));
+        }
+        let build = |query| {
+            build_selected_lc_query_trace_impl(
+                templates,
+                direct,
+                seed,
+                coupling_policy,
+                grammar,
+                query,
+                true,
+                enable_cyclic_trace_reflection,
+            )
+        };
+        let outcomes = if let Some(pool) = &self.pool {
+            pool.install(|| queries.into_par_iter().map(build).collect::<Vec<_>>())
+        } else {
+            queries.into_iter().map(build).collect::<Vec<_>>()
+        };
+        resolve_indexed_query_results(outcomes)
+    }
+}
+
+fn build_selected_lc_query_family_serial_v1(
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct: &PreparedDirectExecutorCatalog,
+    seed: &OnTheFlyProcessSeedV1,
+    coupling_policy: &OnTheFlyResolvedCouplingPolicyV1,
+    grammar: &PreparedOnTheFlyGrammarV1,
+    enable_cyclic_trace_reflection: bool,
+    queries: impl IntoIterator<Item = DecodedLcQueryV1>,
+) -> RusticolResult<Vec<OnTheFlySelectedQueryOutcomeV1>> {
+    queries
+        .into_iter()
+        .map(|query| {
+            build_selected_lc_query_trace_impl(
+                templates,
+                direct,
+                seed,
+                coupling_policy,
+                grammar,
+                query,
+                true,
+                enable_cyclic_trace_reflection,
+            )
+        })
+        .collect()
+}
+
+/// Build one exact public query family while sharing all immutable grammar
+/// preparation.  Independent query-local sweeps run in parallel; their
+/// outcomes and errors retain public selector order.
+#[allow(clippy::too_many_arguments)] // Explicit cold-build context and execution policy.
+pub(crate) fn build_selected_lc_query_family_v1(
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct: &PreparedDirectExecutorCatalog,
+    seed: &OnTheFlyProcessSeedV1,
+    coupling_policy: &OnTheFlyResolvedCouplingPolicyV1,
+    grammar: &PreparedOnTheFlyGrammarV1,
+    enable_cyclic_trace_reflection: bool,
+    query_construction_threads: usize,
+    queries: impl IntoIterator<Item = DecodedLcQueryV1>,
+) -> RusticolResult<Vec<OnTheFlySelectedQueryOutcomeV1>> {
+    if query_construction_threads == 0 {
+        return Err(invalid(
+            "on-the-fly query construction thread count must be positive",
+        ));
+    }
+    if query_construction_threads == 1 {
+        return build_selected_lc_query_family_serial_v1(
+            templates,
+            direct,
+            seed,
+            coupling_policy,
+            grammar,
+            enable_cyclic_trace_reflection,
+            queries,
+        );
+    }
+
+    let queries = queries.into_iter().collect::<Vec<_>>();
+    if queries.len() < 2 {
+        return build_selected_lc_query_family_serial_v1(
+            templates,
+            direct,
+            seed,
+            coupling_policy,
+            grammar,
+            enable_cyclic_trace_reflection,
+            queries,
+        );
+    }
+
+    let pool = rayon::ThreadPoolBuilder::new()
+        .num_threads(query_construction_threads.min(queries.len()))
+        .build()
+        .map_err(|error| {
+            RusticolError::internal(format!(
+                "could not create bounded on-the-fly query construction pool: {error}"
+            ))
+        })?;
+    let outcomes = pool.install(|| {
+        queries
+            .into_par_iter()
+            .map(|query| {
+                build_selected_lc_query_trace_impl(
+                    templates,
+                    direct,
+                    seed,
+                    coupling_policy,
+                    grammar,
+                    query,
+                    true,
+                    enable_cyclic_trace_reflection,
+                )
+            })
+            .collect::<Vec<_>>()
+    });
+    resolve_indexed_query_results(outcomes)
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+#[allow(dead_code)] // Feature-only probe entry point.
+pub(crate) fn build_selected_lc_query_trace_for_probe_v1(
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct: &PreparedDirectExecutorCatalog,
+    seed: &OnTheFlyProcessSeedV1,
+    query: DecodedLcQueryV1,
+    enable_projection: bool,
+    enable_cyclic_trace_reflection: bool,
+) -> RusticolResult<OnTheFlySelectedQueryTraceV1> {
+    let (grammar, coupling_policy) = prepare_on_the_fly_process_v1(templates, seed)?;
+    let query = grammar.canonicalize_query(seed, query)?;
+    match build_selected_lc_query_trace_impl(
+        templates,
+        direct,
+        seed,
+        &coupling_policy,
+        &grammar,
+        query,
+        enable_projection,
+        enable_cyclic_trace_reflection,
+    )? {
+        OnTheFlySelectedQueryOutcomeV1::Trace(selected) => Ok(selected),
+        OnTheFlySelectedQueryOutcomeV1::StructuralZero { .. } => Err(evaluation(
+            "selected probe query is an exact structural zero",
+        )),
+    }
+}
+
+#[allow(clippy::too_many_arguments)] // Explicit cold-build context and probe switches.
+fn build_selected_lc_query_trace_impl(
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct: &PreparedDirectExecutorCatalog,
+    seed: &OnTheFlyProcessSeedV1,
+    coupling_policy: &OnTheFlyResolvedCouplingPolicyV1,
+    grammar: &PreparedOnTheFlyGrammarV1,
+    query: DecodedLcQueryV1,
+    enable_projection: bool,
+    enable_cyclic_trace_reflection: bool,
+) -> RusticolResult<OnTheFlySelectedQueryOutcomeV1> {
+    if seed.direct_catalog_digest() != direct.direct_template_catalog_digest() {
+        return Err(integrity(
+            "compact query direct-template catalog differs from its prepared catalog",
+        ));
+    }
+    if coupling_policy.seed_digest() != seed.semantic_digest()
+        || coupling_policy.effective_limits().len() != seed.explicit_coupling_limits().len()
+    {
+        return Err(integrity(
+            "resolved coupling policy belongs to a different compact seed",
+        ));
+    }
+    grammar.authenticate_canonical_query(seed, &query)?;
+    let Some((trace, projection)) = build_selected_lc_trace_impl(
+        templates,
+        seed,
+        grammar,
+        coupling_policy.effective_limits(),
+        &query,
+        enable_projection,
+        enable_cyclic_trace_reflection,
+        true,
+    )?
+    else {
+        return Ok(OnTheFlySelectedQueryOutcomeV1::StructuralZero { query });
+    };
+    Ok(OnTheFlySelectedQueryOutcomeV1::Trace(
+        OnTheFlySelectedQueryTraceV1 {
+            query,
+            trace,
+            projection: projection
+                .ok_or_else(|| integrity("compact query projection proof was not collected"))?,
+        },
+    ))
+}
+
+fn selected_graph_counts(
+    currents: &[PendingCurrent],
+    closures: &[PendingClosure],
+    live: &BTreeSet<u32>,
+) -> RusticolResult<[u32; 3]> {
+    let contributions = live.iter().try_fold(0usize, |total, id| {
+        let count = currents
+            .get(*id as usize)
+            .ok_or_else(|| integrity("selected graph current is absent"))?
+            .contributions
+            .values()
+            .filter(|factor| !factor.is_zero())
+            .count();
+        total
+            .checked_add(count)
+            .ok_or_else(|| invalid("selected graph contribution count exceeds usize"))
+    })?;
+    Ok([
+        checked_u32(live.len(), "selected graph current count")?,
+        checked_u32(contributions, "selected graph contribution count")?,
+        checked_u32(closures.len(), "selected graph closure count")?,
+    ])
+}
+
+/// Build one selected LC structural trace without constructing any global
+/// recurrence/process projection.
+#[allow(dead_code)] // Compatibility entry point for the query-local probe path.
+pub(crate) fn build_selected_lc_trace(
+    templates: &ValidatedRecurrenceTemplateInput,
+    seed: &OnTheFlyProcessSeedV1,
+    query: &DecodedLcQueryV1,
+) -> RusticolResult<OnTheFlyStructuralTraceV1> {
+    let (grammar, coupling_policy) = prepare_on_the_fly_process_v1(templates, seed)?;
+    let query = grammar.canonicalize_query(seed, query.clone())?;
+    build_selected_lc_trace_impl(
+        templates,
+        seed,
+        &grammar,
+        coupling_policy.effective_limits(),
+        &query,
+        true,
+        false,
+        false,
+    )?
+    .map(|(trace, _)| trace)
+    .ok_or_else(|| evaluation("selected query is an exact structural zero"))
+}
+
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+#[allow(dead_code)] // Feature-only probe entry point.
+pub(crate) fn build_selected_lc_trace_for_probe(
+    templates: &ValidatedRecurrenceTemplateInput,
+    seed: &OnTheFlyProcessSeedV1,
+    query: &DecodedLcQueryV1,
+    enable_projection: bool,
+) -> RusticolResult<(OnTheFlyStructuralTraceV1, OnTheFlyProjectionProbeV1)> {
+    let (grammar, coupling_policy) = prepare_on_the_fly_process_v1(templates, seed)?;
+    let query = grammar.canonicalize_query(seed, query.clone())?;
+    let (trace, probe) = build_selected_lc_trace_impl(
+        templates,
+        seed,
+        &grammar,
+        coupling_policy.effective_limits(),
+        &query,
+        enable_projection,
+        false,
+        true,
+    )?
+    .ok_or_else(|| evaluation("selected probe query is an exact structural zero"))?;
+    Ok((
+        trace,
+        probe.ok_or_else(|| integrity("projection probe was not collected"))?,
+    ))
+}
+
+#[allow(clippy::too_many_arguments)] // Explicit cold-build context and probe switches.
+fn build_selected_lc_trace_impl(
+    templates: &ValidatedRecurrenceTemplateInput,
+    seed: &OnTheFlyProcessSeedV1,
+    grammar: &PreparedOnTheFlyGrammarV1,
+    coupling_limits: &[Option<u32>],
+    query: &DecodedLcQueryV1,
+    enable_projection: bool,
+    enable_cyclic_trace_reflection: bool,
+    collect_projection_probe: bool,
+) -> RusticolResult<Option<(OnTheFlyStructuralTraceV1, Option<OnTheFlyProjectionProbeV1>)>> {
+    if query.seed_digest != seed.semantic_digest() {
+        return Err(integrity(
+            "decoded query belongs to a different compact seed",
+        ));
+    }
+    let mut colors = DynamicLCColorStateInterner::default();
+    let mut currents = Vec::new();
+    let mut current_ids = BTreeMap::new();
+    let enable_cyclic_trace_reflection = enable_cyclic_trace_reflection
+        && grammar
+            .closure_anchor_policy
+            .certifies_cyclic_trace_reflection(seed, query);
+    insert_selected_sources(
+        grammar,
+        seed,
+        coupling_limits,
+        query,
+        enable_cyclic_trace_reflection,
+        &mut colors,
+        &mut currents,
+        &mut current_ids,
+    )?;
+    build_forward_currents(
+        templates,
+        &grammar.transitions,
+        &grammar.transition_reflections,
+        &grammar.contact_orbits,
+        enable_cyclic_trace_reflection,
+        seed,
+        &grammar.fermion_ordering,
+        query.closure_anchor_slot,
+        coupling_limits,
+        &grammar.propagators,
+        &mut colors,
+        &mut currents,
+        &mut current_ids,
+    )?;
+    let constructed_contribution_count = currents
+        .iter()
+        .map(|current| current.contributions.len())
+        .try_fold(0usize, |total, count| {
+            total
+                .checked_add(count)
+                .ok_or_else(|| invalid("constructed contribution count exceeds usize"))
+        })?;
+    let Some(selected_closures) = build_selected_closures(
+        templates,
+        &grammar.closures,
+        seed,
+        &grammar.fermion_ordering,
+        query,
+        enable_cyclic_trace_reflection,
+        &colors,
+        &currents,
+    )?
+    else {
+        return Ok(None);
+    };
+    let live = live_current_ids(&currents, &selected_closures)?;
+    let pre_counts = collect_projection_probe
+        .then(|| selected_graph_counts(&currents, &selected_closures, &live))
+        .transpose()?;
+    let projected = enable_projection
+        .then(|| project_query_local_color_aliases(&currents, &selected_closures, &live))
+        .transpose()?
+        .flatten();
+    let projection_applied = projected.is_some();
+    let (currents, selected_closures, live) = match projected {
+        Some(projected) => {
+            let live = (0..projected.currents.len())
+                .map(|index| checked_u32(index, "projected query-local current ID"))
+                .collect::<RusticolResult<BTreeSet<_>>>()?;
+            (projected.currents, projected.closures, live)
+        }
+        None => (currents, selected_closures, live),
+    };
+    let post_counts = collect_projection_probe
+        .then(|| selected_graph_counts(&currents, &selected_closures, &live))
+        .transpose()?;
+    let pairing_owners = resolve_projected_pairing_owners(seed, &selected_closures)?;
+    let trace = lower_trace(
+        templates,
+        grammar,
+        seed,
+        query,
+        &colors,
+        &currents,
+        &selected_closures,
+        pairing_owners,
+        &live,
+        constructed_contribution_count,
+    )?;
+    Ok(Some((
+        trace,
+        pre_counts
+            .zip(post_counts)
+            .map(|(pre, post)| OnTheFlyProjectionProbeV1 {
+                enabled: enable_projection,
+                applied: projection_applied,
+                pre,
+                post,
+            }),
+    )))
+}
+
+#[cfg(test)]
+mod structural_zero_tests {
+    use super::*;
+    use crate::recurrence::validated_template_fixture;
+
+    #[test]
+    fn indexed_query_results_keep_order_and_report_the_lowest_error() {
+        let pool = rayon::ThreadPoolBuilder::new()
+            .num_threads(4)
+            .build()
+            .unwrap();
+        let ordered = pool.install(|| {
+            (0..32_u32)
+                .into_par_iter()
+                .map(Ok::<_, RusticolError>)
+                .collect::<Vec<_>>()
+        });
+        assert_eq!(
+            resolve_indexed_query_results(ordered).unwrap(),
+            (0..32_u32).collect::<Vec<_>>()
+        );
+
+        let failures = pool.install(|| {
+            (0..32_u32)
+                .into_par_iter()
+                .map(|index| match index {
+                    5 | 19 => Err(invalid(format!("query index {index}"))),
+                    _ => Ok(index),
+                })
+                .collect::<Vec<_>>()
+        });
+        let error = resolve_indexed_query_results(failures).unwrap_err();
+        assert!(error.to_string().contains("query index 5"));
+    }
+
+    #[test]
+    fn selected_closure_domain_fails_closed_when_missing_or_inconsistent() {
+        let templates = validated_template_fixture();
+        let summary = templates.summary();
+        let seed = scalar_adapter_test_seed(
+            summary.compiled_model_digest,
+            summary.catalog_digest,
+            summary.prepared_kernel_pack_digest,
+            SemanticDigest::new([0x7d; 32]).unwrap(),
+        )
+        .unwrap();
+        let query =
+            DecodedLcQueryV1::new(&seed, vec![0, 1], &[0, 0], OnTheFlyLcSelectorV1::Singlet)
+                .unwrap();
+        let catalog = TemplateCatalog::new(templates.input()).unwrap();
+        let grammar = prepare_on_the_fly_grammar_v1(&templates, &catalog, &seed).unwrap();
+        let mut colors = DynamicLCColorStateInterner::default();
+        let mut currents = Vec::new();
+        let mut current_ids = BTreeMap::new();
+        insert_selected_sources(
+            &grammar,
+            &seed,
+            seed.explicit_coupling_limits(),
+            &query,
+            false,
+            &mut colors,
+            &mut currents,
+            &mut current_ids,
+        )
+        .unwrap();
+
+        let absent = BTreeMap::new();
+        let error = validate_prepared_closure_domain(&templates, &catalog, &absent).unwrap_err();
+        assert!(error.to_string().contains("prepared closure domain"));
+
+        let mut inconsistent = prepared_closures(&templates, &catalog).unwrap();
+        let rows = inconsistent.values_mut().next().unwrap();
+        rows[0].input_states = [4, 9];
+        let error =
+            validate_prepared_closure_domain(&templates, &catalog, &inconsistent).unwrap_err();
+        assert!(error.to_string().contains("parent-state pair"));
+
+        currents.clear();
+        let complete = prepared_closures(&templates, &catalog).unwrap();
+        let error = build_selected_closures(
+            &templates,
+            &complete,
+            &seed,
+            &grammar.fermion_ordering,
+            &query,
+            false,
+            &colors,
+            &currents,
+        )
+        .unwrap_err();
+        assert!(error.to_string().contains("closure anchor"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/persisted.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/persisted.rs
new file mode 100644
index 0000000000..27e8f826f6
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/persisted.rs
@@ -0,0 +1,2506 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Cold-bound helicity families projected from one persisted all-flow plan.
+//!
+//! The sidecar's CSR is consulted only by [`PersistedHelicityFamilyExecutorV1::prepare`].
+//! Each retained helicity owns compact boxed non-source rows with authoritative
+//! initialization flags and the same schedule-local singleton fanout and
+//! interaction programs used by query-built families. Warm execution invokes
+//! one cold-bound exact union-source program followed by those rows; it
+//! performs no support-mask scan, selector branch, or source-catalog lookup.
+
+use super::*;
+use crate::direct_arena::{
+    AlignedF64Buffer, DirectArenaView, DirectFactorView, DirectMomentumView, DirectParameterView,
+    checked_aligned_point_stride, validate_direct_views,
+};
+#[cfg(test)]
+use crate::recurrence::direct_backend::DIRECT_STATUS_OK;
+use crate::recurrence::direct_backend::{
+    DirectWorkspace, check_status, execute_certified_reuse_rows,
+};
+use crate::recurrence::{
+    DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE, DIRECT_NONE_U32, DirectHelicityDispatch,
+    DirectRecurrencePlan, DirectResolvedHelicityDescriptor, DirectResolvedSourceSelection,
+    DirectSourceDispatchVariantDescriptor, DirectSourceEmbeddingRow,
+};
+
+#[derive(Debug, Eq, PartialEq)]
+enum PersistedFamilyRowsV1 {
+    Contribution(Box<[DirectContributionRow]>),
+    Finalization(Box<[DirectFinalizationRow]>),
+    Closure(Box<[DirectClosureRow]>),
+}
+
+impl PersistedFamilyRowsV1 {
+    fn len(&self) -> usize {
+        match self {
+            Self::Contribution(rows) => rows.len(),
+            Self::Finalization(rows) => rows.len(),
+            Self::Closure(rows) => rows.len(),
+        }
+    }
+}
+
+enum PersistedFamilyRowsDraftV1 {
+    Contribution(Vec<DirectContributionRow>),
+    Finalization(Vec<DirectFinalizationRow>),
+    Closure(Vec<DirectClosureRow>),
+}
+
+impl PersistedFamilyRowsDraftV1 {
+    const fn role(&self) -> DirectExecutorRole {
+        match self {
+            Self::Contribution(_) => DirectExecutorRole::Contribution,
+            Self::Finalization(_) => DirectExecutorRole::Finalization,
+            Self::Closure(_) => DirectExecutorRole::Closure,
+        }
+    }
+
+    fn append_from_plan(
+        &mut self,
+        plan: &DirectRecurrencePlan,
+        role: DirectExecutorRole,
+        row_start: u64,
+        row_count: u32,
+    ) -> RusticolResult<()> {
+        let start = usize::try_from(row_start)
+            .map_err(|_| integrity("persisted family row start exceeds usize"))?;
+        let end = start
+            .checked_add(row_count as usize)
+            .ok_or_else(|| integrity("persisted family row range overflows usize"))?;
+        match (self, role) {
+            (Self::Contribution(destination), DirectExecutorRole::Contribution) => destination
+                .extend_from_slice(
+                    plan.contributions().get(start..end).ok_or_else(|| {
+                        integrity("persisted family contribution range is absent")
+                    })?,
+                ),
+            (Self::Finalization(destination), DirectExecutorRole::Finalization) => destination
+                .extend_from_slice(
+                    plan.finalizations().get(start..end).ok_or_else(|| {
+                        integrity("persisted family finalization range is absent")
+                    })?,
+                ),
+            (Self::Closure(destination), DirectExecutorRole::Closure) => destination
+                .extend_from_slice(
+                    plan.closures()
+                        .get(start..end)
+                        .ok_or_else(|| integrity("persisted family closure range is absent"))?,
+                ),
+            (_, DirectExecutorRole::Source) => {
+                return Err(integrity(
+                    "persisted family must not contain static source rows",
+                ));
+            }
+            _ => {
+                return Err(integrity(
+                    "persisted family row storage differs from its role",
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    fn freeze(self) -> PersistedFamilyRowsV1 {
+        match self {
+            Self::Contribution(rows) => {
+                PersistedFamilyRowsV1::Contribution(rows.into_boxed_slice())
+            }
+            Self::Finalization(rows) => {
+                PersistedFamilyRowsV1::Finalization(rows.into_boxed_slice())
+            }
+            Self::Closure(rows) => PersistedFamilyRowsV1::Closure(rows.into_boxed_slice()),
+        }
+    }
+}
+
+struct PersistedFamilyGroupDraftV1 {
+    stage: u32,
+    direct_executor_id: u32,
+    rows: PersistedFamilyRowsDraftV1,
+}
+
+impl PersistedFamilyGroupDraftV1 {
+    fn accepts(&self, stage: u32, role: DirectExecutorRole, direct_executor_id: u32) -> bool {
+        self.stage == stage
+            && self.rows.role() == role
+            && self.direct_executor_id == direct_executor_id
+    }
+}
+
+struct PersistedFamilyGroupV1 {
+    stage: u32,
+    role: DirectExecutorRole,
+    direct_executor_id: u32,
+    rows: PersistedFamilyRowsV1,
+}
+
+#[allow(dead_code)] // Retains authenticated helicity descriptors for inspection/probe builds.
+struct PersistedPlanLayoutV1 {
+    runtime_layout_digest: SemanticDigest,
+    dispatch_address: usize,
+    source_count: u32,
+    lorentz_component_count: u16,
+    parameter_count: u32,
+    current_component_count: u32,
+    amplitude_destination_count: u32,
+    resolved_helicity_count: u32,
+    resolved_helicities: Box<[DirectResolvedHelicityDescriptor]>,
+    public_helicities: Box<[i32]>,
+    momentum_forms: Box<[CanonicalMomentumLinearForm]>,
+    exact_factors: Box<[ExactComplexRational]>,
+    sources: Box<[DirectSourceRow]>,
+    source_dispatch_variants: Box<[DirectSourceDispatchVariantDescriptor]>,
+    source_embeddings: Box<[DirectSourceEmbeddingRow]>,
+}
+
+impl PersistedPlanLayoutV1 {
+    fn new(
+        plan: &DirectRecurrencePlan,
+        dispatch: &DirectHelicityDispatch,
+        lorentz_component_count: u16,
+    ) -> RusticolResult<Self> {
+        if lorentz_component_count == 0 {
+            return Err(invalid(
+                "persisted helicity family Lorentz component count is zero",
+            ));
+        }
+        let mut momentum_forms = Vec::with_capacity(plan.momentum_forms().len());
+        for descriptor in plan.momentum_forms() {
+            let start = usize::try_from(descriptor.term_start)
+                .map_err(|_| integrity("persisted momentum-form start exceeds usize"))?;
+            let end = start
+                .checked_add(descriptor.term_count as usize)
+                .ok_or_else(|| integrity("persisted momentum-form range overflows usize"))?;
+            let terms = plan
+                .momentum_terms()
+                .get(start..end)
+                .ok_or_else(|| integrity("persisted momentum-form term range is out of bounds"))?;
+            momentum_forms.push(CanonicalMomentumLinearForm::new(
+                terms
+                    .iter()
+                    .map(|term| MomentumTerm {
+                        source_slot: term.source_slot,
+                        coefficient: term.coefficient,
+                    })
+                    .collect(),
+            )?);
+        }
+        Ok(Self {
+            runtime_layout_digest: plan.runtime_layout_digest(),
+            dispatch_address: std::ptr::from_ref(dispatch).addr(),
+            source_count: plan.external_source_count(),
+            lorentz_component_count,
+            parameter_count: plan.parameter_value_count(),
+            current_component_count: plan.current_arena_components(),
+            amplitude_destination_count: plan.amplitude_destination_count(),
+            resolved_helicity_count: u32::try_from(plan.resolved_helicities().len())
+                .map_err(|_| integrity("persisted resolved-helicity count exceeds u32"))?,
+            resolved_helicities: plan.resolved_helicities().to_vec().into_boxed_slice(),
+            public_helicities: plan.public_helicities().to_vec().into_boxed_slice(),
+            momentum_forms: momentum_forms.into_boxed_slice(),
+            exact_factors: plan.exact_factors().to_vec().into_boxed_slice(),
+            sources: plan.sources().to_vec().into_boxed_slice(),
+            source_dispatch_variants: plan.source_dispatch_variants().to_vec().into_boxed_slice(),
+            source_embeddings: plan.source_embeddings().to_vec().into_boxed_slice(),
+        })
+    }
+}
+
+struct PersistedHelicityFamilyV1 {
+    resolved_helicity_id: u32,
+    source_selections: Box<[DirectResolvedSourceSelection]>,
+    groups: Box<[PersistedFamilyGroupV1]>,
+    unique_current_count: u32,
+    unique_current_component_count: u32,
+}
+
+struct BoundPersistedHelicityFamilyV1 {
+    family: PersistedHelicityFamilyV1,
+    workspace: PersistedHelicityWorkspaceV1,
+    resolved_groups: Box<[Option<ResolvedOnTheFlyExecutor>]>,
+    union_source_program: Box<dyn OnTheFlyBoundUnionSourceProgram>,
+    packed_singleton_capable: bool,
+    interaction_program: DirectInteractionProgram,
+    singleton_fanout_program: DirectSingletonContributionFanoutProgram,
+    applied_parameter_version: u64,
+    descriptor_exposed: bool,
+    last_execution_report: Option<PersistedHelicityFamilyExecutionReportV1>,
+}
+
+/// Borrowed dense physical-color amplitude tile for one selected helicity.
+#[derive(Clone, Copy, Debug)]
+#[allow(dead_code)] // Accessors are consumed by runtime adapters outside default core builds.
+pub(crate) struct PersistedHelicityAmplitudeTileV1<'a> {
+    amplitude_re: &'a [f64],
+    amplitude_im: &'a [f64],
+    destination_count: u32,
+    point_count: u32,
+    point_stride: u32,
+    resolved_helicity_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct PersistedHelicityFamilyExecutionReportV1 {
+    pub(crate) cache_hit: bool,
+    pub(crate) source_calls: u32,
+    pub(crate) source_rows: u32,
+    pub(crate) contribution_calls: u32,
+    pub(crate) contribution_rows: u32,
+    pub(crate) finalization_calls: u32,
+    pub(crate) finalization_rows: u32,
+    pub(crate) closure_calls: u32,
+    pub(crate) closure_rows: u32,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct PersistedHelicityFamilyCacheCensusV1 {
+    pub(crate) resolved_helicity_count: u32,
+    pub(crate) retained_family_count: u32,
+    pub(crate) retained_row_count: u64,
+    pub(crate) active_resolved_helicity_id: Option<u32>,
+}
+
+/// Legacy query-family-shaped census for the retained persisted family.
+///
+/// This is derived at cold bind plus the most recent execution. Inspecting it
+/// never revisits the dispatch CSR or scans support masks.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct PersistedHelicityFamilyInspectionCensusV1 {
+    pub(crate) query_count: u32,
+    pub(crate) union_unique_current_count: u32,
+    pub(crate) union_unique_current_component_count: u32,
+    pub(crate) union_source_rows: u32,
+    pub(crate) union_contribution_rows: u32,
+    pub(crate) union_finalization_rows: u32,
+    pub(crate) union_closure_rows: u32,
+    pub(crate) union_amplitude_destination_count: u32,
+    pub(crate) union_source_executor_call_groups: u32,
+    pub(crate) union_contribution_executor_call_groups: u32,
+    pub(crate) union_finalization_executor_call_groups: u32,
+    pub(crate) union_closure_executor_call_groups: u32,
+    pub(crate) semantic_executor_binding_count: u32,
+}
+
+#[allow(dead_code)] // Accessors are consumed by runtime adapters outside default core builds.
+impl<'a> PersistedHelicityAmplitudeTileV1<'a> {
+    pub(crate) const fn amplitude_re(self) -> &'a [f64] {
+        self.amplitude_re
+    }
+
+    pub(crate) const fn amplitude_im(self) -> &'a [f64] {
+        self.amplitude_im
+    }
+
+    pub(crate) const fn destination_count(self) -> u32 {
+        self.destination_count
+    }
+
+    pub(crate) const fn point_count(self) -> u32 {
+        self.point_count
+    }
+
+    pub(crate) const fn point_stride(self) -> u32 {
+        self.point_stride
+    }
+
+    pub(crate) const fn resolved_helicity_id(self) -> u32 {
+        self.resolved_helicity_id
+    }
+
+    pub(crate) fn destination_re(self, destination_id: u32) -> RusticolResult<&'a [f64]> {
+        let start = destination_id as usize * self.point_stride as usize;
+        let end = start
+            .checked_add(self.point_count as usize)
+            .ok_or_else(|| integrity("persisted amplitude destination range overflows usize"))?;
+        self.amplitude_re
+            .get(start..end)
+            .ok_or_else(|| integrity("persisted amplitude real destination is out of bounds"))
+    }
+
+    pub(crate) fn destination_im(self, destination_id: u32) -> RusticolResult<&'a [f64]> {
+        let start = destination_id as usize * self.point_stride as usize;
+        let end = start
+            .checked_add(self.point_count as usize)
+            .ok_or_else(|| integrity("persisted amplitude destination range overflows usize"))?;
+        self.amplitude_im
+            .get(start..end)
+            .ok_or_else(|| integrity("persisted amplitude imaginary destination is out of bounds"))
+    }
+}
+
+fn scalar_len(planes: u32, stride: u32, label: &str) -> RusticolResult<usize> {
+    usize::try_from(planes)
+        .ok()
+        .and_then(|planes| planes.checked_mul(stride as usize))
+        .ok_or_else(|| invalid(format!("persisted helicity {label} size exceeds usize")))
+}
+
+fn factor_parts(value: ExactComplexRational) -> RusticolResult<(f64, f64)> {
+    let real = value.real().numerator() as f64 / value.real().denominator() as f64;
+    let imag = value.imag().numerator() as f64 / value.imag().denominator() as f64;
+    if !real.is_finite() || !imag.is_finite() {
+        return Err(invalid(
+            "persisted helicity exact factor is not finite in binary64",
+        ));
+    }
+    Ok((real, imag))
+}
+
+struct PersistedHelicityWorkspaceV1 {
+    current_re: AlignedF64Buffer,
+    current_im: AlignedF64Buffer,
+    amplitude_re: AlignedF64Buffer,
+    amplitude_im: AlignedF64Buffer,
+    momenta: AlignedF64Buffer,
+    parameters_re: AlignedF64Buffer,
+    parameters_im: AlignedF64Buffer,
+    factors_re: AlignedF64Buffer,
+    factors_im: AlignedF64Buffer,
+    logical_point_capacity: u32,
+    active_point_count: u32,
+    point_stride: u32,
+}
+
+impl PersistedHelicityWorkspaceV1 {
+    fn new(
+        layout: &PersistedPlanLayoutV1,
+        logical_point_capacity: u32,
+        packed_singleton_capable: bool,
+    ) -> RusticolResult<Self> {
+        if layout.source_count == 0
+            || layout.lorentz_component_count == 0
+            || layout.current_component_count == 0
+            || layout.amplitude_destination_count == 0
+            || layout.momentum_forms.is_empty()
+            || layout.exact_factors.is_empty()
+            || logical_point_capacity == 0
+        {
+            return Err(integrity(
+                "persisted helicity family has an empty workspace shape",
+            ));
+        }
+        let point_stride = if logical_point_capacity == 1 && packed_singleton_capable {
+            1
+        } else {
+            checked_aligned_point_stride(logical_point_capacity)?
+        };
+        let current_len = scalar_len(
+            layout.current_component_count,
+            point_stride,
+            "current arena",
+        )?;
+        let amplitude_len = scalar_len(
+            layout.amplitude_destination_count,
+            point_stride,
+            "amplitude arena",
+        )?;
+        let momentum_form_count = u32::try_from(layout.momentum_forms.len())
+            .map_err(|_| invalid("persisted helicity momentum-form count exceeds u32"))?;
+        let momentum_planes = momentum_form_count
+            .checked_mul(u32::from(layout.lorentz_component_count))
+            .ok_or_else(|| invalid("persisted helicity momentum-plane count exceeds u32"))?;
+        let momentum_len = scalar_len(momentum_planes, point_stride, "momentum arena")?;
+        let mut factors_re =
+            AlignedF64Buffer::zeroed(layout.exact_factors.len(), "persisted helicity factor real")?;
+        let mut factors_im = AlignedF64Buffer::zeroed(
+            layout.exact_factors.len(),
+            "persisted helicity factor imaginary",
+        )?;
+        for (index, factor) in layout.exact_factors.iter().copied().enumerate() {
+            let (real, imag) = factor_parts(factor)?;
+            factors_re.as_mut_slice()[index] = real;
+            factors_im.as_mut_slice()[index] = imag;
+        }
+        let parameter_count = usize::try_from(layout.parameter_count)
+            .map_err(|_| invalid("persisted helicity parameter count exceeds usize"))?;
+        Ok(Self {
+            current_re: AlignedF64Buffer::zeroed(current_len, "persisted helicity current real")?,
+            current_im: AlignedF64Buffer::zeroed(
+                current_len,
+                "persisted helicity current imaginary",
+            )?,
+            amplitude_re: AlignedF64Buffer::zeroed(
+                amplitude_len,
+                "persisted helicity amplitude real",
+            )?,
+            amplitude_im: AlignedF64Buffer::zeroed(
+                amplitude_len,
+                "persisted helicity amplitude imaginary",
+            )?,
+            momenta: AlignedF64Buffer::zeroed(momentum_len, "persisted helicity momenta")?,
+            parameters_re: AlignedF64Buffer::zeroed(
+                parameter_count,
+                "persisted helicity parameter real",
+            )?,
+            parameters_im: AlignedF64Buffer::zeroed(
+                parameter_count,
+                "persisted helicity parameter imaginary",
+            )?,
+            factors_re,
+            factors_im,
+            logical_point_capacity,
+            active_point_count: 0,
+            point_stride,
+        })
+    }
+
+    fn refresh_parameters(&mut self, parameters: &[(f64, f64)]) -> RusticolResult<()> {
+        self.active_point_count = 0;
+        if parameters.len() != self.parameters_re.len() {
+            return Err(invalid(format!(
+                "persisted helicity received {} parameters, expected {}",
+                parameters.len(),
+                self.parameters_re.len()
+            )));
+        }
+        for (index, &(real, imag)) in parameters.iter().enumerate() {
+            if !real.is_finite() || !imag.is_finite() {
+                return Err(invalid("persisted helicity parameter value is not finite"));
+            }
+            self.parameters_re.as_mut_slice()[index] = real;
+            self.parameters_im.as_mut_slice()[index] = imag;
+        }
+        Ok(())
+    }
+
+    fn refresh_inputs(
+        &mut self,
+        layout: &PersistedPlanLayoutV1,
+        external_momenta: &[f64],
+        point_count: u32,
+    ) -> RusticolResult<()> {
+        self.active_point_count = 0;
+        if point_count == 0 || point_count > self.logical_point_capacity {
+            return Err(invalid(
+                "persisted helicity point count is outside its workspace",
+            ));
+        }
+        let expected = usize::try_from(layout.source_count)
+            .ok()
+            .and_then(|sources| sources.checked_mul(usize::from(layout.lorentz_component_count)))
+            .and_then(|planes| planes.checked_mul(point_count as usize))
+            .ok_or_else(|| invalid("persisted helicity external momentum shape exceeds usize"))?;
+        if external_momenta.len() != expected {
+            return Err(invalid(format!(
+                "persisted helicity received {} momentum scalars, expected {expected}",
+                external_momenta.len()
+            )));
+        }
+        for (form_id, form) in layout.momentum_forms.iter().enumerate() {
+            for lorentz in 0..usize::from(layout.lorentz_component_count) {
+                for point in 0..point_count as usize {
+                    let mut value = 0.0;
+                    for term in form.terms() {
+                        if term.source_slot >= layout.source_count {
+                            return Err(integrity(
+                                "persisted momentum source slot is out of bounds",
+                            ));
+                        }
+                        // Recurrence lanes expose point-major external input:
+                        // [point][source][Lorentz]. Keep that contract here so
+                        // the persisted companion needs no transpose scratch.
+                        let input_index = (point * layout.source_count as usize
+                            + term.source_slot as usize)
+                            * usize::from(layout.lorentz_component_count)
+                            + lorentz;
+                        value += f64::from(term.coefficient) * external_momenta[input_index];
+                    }
+                    let plane = form_id
+                        .checked_mul(usize::from(layout.lorentz_component_count))
+                        .and_then(|base| base.checked_add(lorentz))
+                        .ok_or_else(|| invalid("persisted momentum plane exceeds usize"))?;
+                    let index = plane
+                        .checked_mul(self.point_stride as usize)
+                        .and_then(|base| base.checked_add(point))
+                        .ok_or_else(|| invalid("persisted momentum index exceeds usize"))?;
+                    self.momenta.as_mut_slice()[index] = value;
+                }
+            }
+        }
+        // A selected H may have no live closure for a physical destination.
+        // Clear every physical-color plane, not merely the selected closure
+        // list, so H=A -> H=B -> H=A cannot expose a stale amplitude.
+        for destination in 0..layout.amplitude_destination_count as usize {
+            let start = destination * self.point_stride as usize;
+            let end = start + point_count as usize;
+            self.amplitude_re.as_mut_slice()[start..end].fill(0.0);
+            self.amplitude_im.as_mut_slice()[start..end].fill(0.0);
+        }
+        Ok(())
+    }
+
+    fn raw_views(
+        &mut self,
+        layout: &PersistedPlanLayoutV1,
+    ) -> RusticolResult<(
+        DirectArenaView,
+        DirectMomentumView,
+        DirectParameterView,
+        DirectFactorView,
+    )> {
+        let arena = DirectArenaView {
+            current_re: self.current_re.as_mut_ptr(),
+            current_im: self.current_im.as_mut_ptr(),
+            current_scalar_len: self.current_re.len() as u64,
+            amplitude_re: self.amplitude_re.as_mut_ptr(),
+            amplitude_im: self.amplitude_im.as_mut_ptr(),
+            amplitude_scalar_len: self.amplitude_re.len() as u64,
+            point_stride: self.point_stride,
+        };
+        let momenta = DirectMomentumView {
+            values: self.momenta.as_ptr(),
+            scalar_len: self.momenta.len() as u64,
+            form_count: u32::try_from(layout.momentum_forms.len())
+                .map_err(|_| integrity("persisted momentum-form count exceeds u32"))?,
+            lorentz_component_count: layout.lorentz_component_count,
+            point_stride: self.point_stride,
+        };
+        let parameters = DirectParameterView {
+            values_re: self.parameters_re.as_ptr(),
+            values_im: self.parameters_im.as_ptr(),
+            value_count: self.parameters_re.len() as u32,
+        };
+        let factors = DirectFactorView {
+            values_re: self.factors_re.as_ptr(),
+            values_im: self.factors_im.as_ptr(),
+            value_count: self.factors_re.len() as u32,
+        };
+        validate_direct_views(arena, momenta, parameters, factors)?;
+        Ok((arena, momenta, parameters, factors))
+    }
+
+    fn direct_workspace(&mut self, layout: &PersistedPlanLayoutV1) -> DirectWorkspace<'_> {
+        DirectWorkspace {
+            current_re: self.current_re.as_mut_slice(),
+            current_im: self.current_im.as_mut_slice(),
+            amplitude_re: self.amplitude_re.as_mut_slice(),
+            amplitude_im: self.amplitude_im.as_mut_slice(),
+            momenta: self.momenta.as_slice(),
+            momentum_form_count: layout.momentum_forms.len() as u32,
+            lorentz_component_count: layout.lorentz_component_count,
+            parameters_re: self.parameters_re.as_slice(),
+            parameters_im: self.parameters_im.as_slice(),
+            factors_re: self.factors_re.as_slice(),
+            factors_im: self.factors_im.as_slice(),
+            point_stride: self.point_stride,
+        }
+    }
+
+    fn tile(
+        &self,
+        layout: &PersistedPlanLayoutV1,
+        resolved_helicity_id: u32,
+        point_count: u32,
+    ) -> RusticolResult<PersistedHelicityAmplitudeTileV1<'_>> {
+        if self.active_point_count != point_count {
+            return Err(integrity(
+                "persisted helicity tile is not the last successful execution",
+            ));
+        }
+        Ok(PersistedHelicityAmplitudeTileV1 {
+            amplitude_re: self.amplitude_re.as_slice(),
+            amplitude_im: self.amplitude_im.as_slice(),
+            destination_count: layout.amplitude_destination_count,
+            point_count,
+            point_stride: self.point_stride,
+            resolved_helicity_id,
+        })
+    }
+}
+
+fn selected_source_rows(
+    plan: &DirectRecurrencePlan,
+    resolved_helicity_id: u32,
+) -> RusticolResult<Box<[DirectResolvedSourceSelection]>> {
+    let descriptor = plan
+        .resolved_helicities()
+        .get(resolved_helicity_id as usize)
+        .filter(|descriptor| descriptor.id == resolved_helicity_id)
+        .ok_or_else(|| integrity("persisted resolved helicity is absent from its plan"))?;
+    let start = usize::try_from(descriptor.source_selection_start)
+        .map_err(|_| integrity("persisted source-selection start exceeds usize"))?;
+    let end = start
+        .checked_add(descriptor.source_selection_count as usize)
+        .ok_or_else(|| integrity("persisted source-selection range overflows usize"))?;
+    let selections = plan
+        .resolved_source_selections()
+        .get(start..end)
+        .ok_or_else(|| integrity("persisted source-selection range is out of bounds"))?;
+    if selections.is_empty() {
+        return Err(integrity(
+            "persisted resolved helicity has no source selections",
+        ));
+    }
+    Ok(selections.to_vec().into_boxed_slice())
+}
+
+fn new_rows_draft(role: DirectExecutorRole) -> RusticolResult<PersistedFamilyRowsDraftV1> {
+    match role {
+        DirectExecutorRole::Contribution => {
+            Ok(PersistedFamilyRowsDraftV1::Contribution(Vec::new()))
+        }
+        DirectExecutorRole::Finalization => {
+            Ok(PersistedFamilyRowsDraftV1::Finalization(Vec::new()))
+        }
+        DirectExecutorRole::Closure => Ok(PersistedFamilyRowsDraftV1::Closure(Vec::new())),
+        DirectExecutorRole::Source => Err(integrity(
+            "persisted helicity dispatch contains a static source group",
+        )),
+    }
+}
+
+fn rederive_contribution_initialization(groups: &mut [PersistedFamilyGroupDraftV1]) {
+    let mut initialized = BTreeSet::<(u32, u32)>::new();
+    for group in groups {
+        let PersistedFamilyRowsDraftV1::Contribution(rows) = &mut group.rows else {
+            continue;
+        };
+        for row in rows {
+            row.flags &= !DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION;
+            if initialized.insert((group.stage, row.destination_component_base)) {
+                row.flags |= DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION;
+            }
+        }
+    }
+}
+
+fn order_contributions_for_fanout(groups: &mut [PersistedFamilyGroupDraftV1]) {
+    for group in groups {
+        let PersistedFamilyRowsDraftV1::Contribution(rows) = &mut group.rows else {
+            continue;
+        };
+        let stage = group.stage;
+        let executor_id = group.direct_executor_id;
+        crate::recurrence::direct_lowering::order_contributions_for_runtime_fanout_by(
+            rows,
+            |row| {
+                (
+                    stage,
+                    executor_id,
+                    *row,
+                    (
+                        row.destination_component_base,
+                        row.exact_factor_id,
+                        row.flags & !DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+                    ),
+                )
+            },
+        );
+    }
+}
+
+/// Cold semantic lookup over a physically reused Direct-Arena layout.
+///
+/// A component base is unique only among currents live in the same stage. The
+/// persisted family census therefore must not treat it as a global current ID.
+struct PersistedCurrentIndexV1 {
+    current_by_source_row: BTreeMap<u32, u32>,
+    current_by_stage_and_base: BTreeMap<(u32, u32), u32>,
+    currents_by_base: BTreeMap<u32, Vec<u32>>,
+}
+
+impl PersistedCurrentIndexV1 {
+    fn new(plan: &DirectRecurrencePlan) -> RusticolResult<Self> {
+        let mut current_by_source_row = BTreeMap::new();
+        let mut current_by_stage_and_base = BTreeMap::new();
+        let mut currents_by_base = BTreeMap::<u32, Vec<u32>>::new();
+        for current in plan.currents() {
+            let current_id = current.semantic_current_id;
+            if current_by_stage_and_base
+                .insert(
+                    (u32::from(current.stage), current.component_base),
+                    current_id,
+                )
+                .is_some()
+            {
+                return Err(integrity(
+                    "persisted plan repeats a current component base within one stage",
+                ));
+            }
+            if current.source_row_or_sentinel != DIRECT_NONE_U32
+                && current_by_source_row
+                    .insert(current.source_row_or_sentinel, current_id)
+                    .is_some()
+            {
+                return Err(integrity(
+                    "persisted plan repeats a source-row current binding",
+                ));
+            }
+            currents_by_base
+                .entry(current.component_base)
+                .or_default()
+                .push(current_id);
+        }
+        for current_ids in currents_by_base.values_mut() {
+            current_ids.sort_unstable_by_key(|current_id| {
+                let current = &plan.currents()[*current_id as usize];
+                (current.first_use, current.last_use, *current_id)
+            });
+        }
+        Ok(Self {
+            current_by_source_row,
+            current_by_stage_and_base,
+            currents_by_base,
+        })
+    }
+
+    fn source_current(&self, source_row_id: u32, label: &str) -> RusticolResult<u32> {
+        self.current_by_source_row
+            .get(&source_row_id)
+            .copied()
+            .ok_or_else(|| integrity(format!("persisted {label} has no semantic source current")))
+    }
+
+    fn destination_current(
+        &self,
+        stage: u32,
+        component_base: u32,
+        label: &str,
+    ) -> RusticolResult<u32> {
+        self.current_by_stage_and_base
+            .get(&(stage, component_base))
+            .copied()
+            .ok_or_else(|| {
+                integrity(format!(
+                    "persisted {label} references no current defined at its stage"
+                ))
+            })
+    }
+
+    fn live_current(
+        &self,
+        plan: &DirectRecurrencePlan,
+        stage: u32,
+        component_base: u32,
+        label: &str,
+    ) -> RusticolResult<u32> {
+        let current_ids = self.currents_by_base.get(&component_base).ok_or_else(|| {
+            integrity(format!(
+                "persisted {label} references a missing current component base"
+            ))
+        })?;
+        let end = current_ids
+            .partition_point(|current_id| plan.currents()[*current_id as usize].first_use <= stage);
+        let current_id = current_ids
+            .get(end.saturating_sub(1))
+            .copied()
+            .filter(|_| end != 0)
+            .ok_or_else(|| {
+                integrity(format!(
+                    "persisted {label} references no current live at its stage"
+                ))
+            })?;
+        let current = plan
+            .currents()
+            .get(current_id as usize)
+            .filter(|current| current.semantic_current_id == current_id)
+            .ok_or_else(|| integrity("persisted current index has a noncanonical semantic ID"))?;
+        if stage > current.last_use {
+            return Err(integrity(format!(
+                "persisted {label} references no current live at its stage"
+            )));
+        }
+        Ok(current_id)
+    }
+}
+
+fn family_current_census(
+    plan: &DirectRecurrencePlan,
+    source_selections: &[DirectResolvedSourceSelection],
+    groups: &[PersistedFamilyGroupV1],
+) -> RusticolResult<(u32, u32)> {
+    let current_index = PersistedCurrentIndexV1::new(plan)?;
+    let mut active_currents = BTreeSet::<u32>::new();
+
+    for selection in source_selections {
+        let variant = plan
+            .source_dispatch_variants()
+            .get(selection.dispatch_variant_id as usize)
+            .ok_or_else(|| integrity("persisted source selection has no dispatch variant"))?;
+        let source = plan
+            .sources()
+            .get(variant.source_row_id as usize)
+            .ok_or_else(|| integrity("persisted source dispatch has no source row"))?;
+        let current_id = current_index.source_current(variant.source_row_id, "source row")?;
+        let current = &plan.currents()[current_id as usize];
+        if current.component_base != source.destination_component_base {
+            return Err(integrity(
+                "persisted source row differs from its semantic current binding",
+            ));
+        }
+        active_currents.insert(current_id);
+    }
+    for group in groups {
+        match &group.rows {
+            PersistedFamilyRowsV1::Contribution(rows) => {
+                for row in rows {
+                    active_currents.insert(current_index.live_current(
+                        plan,
+                        group.stage,
+                        row.parent0_component_base,
+                        "contribution parent",
+                    )?);
+                    if row.parent1_component_base_or_sentinel != DIRECT_NONE_U32 {
+                        active_currents.insert(current_index.live_current(
+                            plan,
+                            group.stage,
+                            row.parent1_component_base_or_sentinel,
+                            "contribution parent",
+                        )?);
+                    }
+                    active_currents.insert(current_index.destination_current(
+                        group.stage,
+                        row.destination_component_base,
+                        "contribution destination",
+                    )?);
+                }
+            }
+            PersistedFamilyRowsV1::Finalization(rows) => {
+                for row in rows {
+                    active_currents.insert(current_index.destination_current(
+                        group.stage,
+                        row.component_base,
+                        "finalization row",
+                    )?);
+                }
+            }
+            PersistedFamilyRowsV1::Closure(rows) => {
+                for row in rows {
+                    active_currents.insert(current_index.live_current(
+                        plan,
+                        group.stage,
+                        row.parent0_component_base,
+                        "closure parent",
+                    )?);
+                    if row.parent1_component_base_or_sentinel != DIRECT_NONE_U32 {
+                        active_currents.insert(current_index.live_current(
+                            plan,
+                            group.stage,
+                            row.parent1_component_base_or_sentinel,
+                            "closure parent",
+                        )?);
+                    }
+                }
+            }
+        }
+    }
+
+    let unique_current_count = u32::try_from(active_currents.len())
+        .map_err(|_| integrity("persisted active current count exceeds u32"))?;
+    let unique_current_component_count =
+        active_currents
+            .into_iter()
+            .try_fold(0u32, |count, current_id| {
+                count
+                    .checked_add(u32::from(
+                        plan.currents()[current_id as usize].component_count,
+                    ))
+                    .ok_or_else(|| {
+                        integrity("persisted active current component count exceeds u32")
+                    })
+            })?;
+    Ok((unique_current_count, unique_current_component_count))
+}
+
+fn build_family(
+    plan: &DirectRecurrencePlan,
+    dispatch: &DirectHelicityDispatch,
+    resolved_helicity_id: u32,
+) -> RusticolResult<PersistedHelicityFamilyV1> {
+    let mut drafts = Vec::<PersistedFamilyGroupDraftV1>::new();
+    for &group_id in dispatch.group_ids_for_helicity(resolved_helicity_id)? {
+        let descriptor = dispatch
+            .row_groups()
+            .get(group_id as usize)
+            .ok_or_else(|| integrity("persisted helicity group ID is out of bounds"))?;
+        let stage = u32::from(descriptor.stage);
+        if !drafts.last().is_some_and(|draft| {
+            draft.accepts(stage, descriptor.role, descriptor.direct_executor_id)
+        }) {
+            drafts.push(PersistedFamilyGroupDraftV1 {
+                stage,
+                direct_executor_id: descriptor.direct_executor_id,
+                rows: new_rows_draft(descriptor.role)?,
+            });
+        }
+        drafts
+            .last_mut()
+            .expect("persisted group draft was just inserted")
+            .rows
+            .append_from_plan(
+                plan,
+                descriptor.role,
+                descriptor.row_start,
+                descriptor.row_count,
+            )?;
+    }
+    // A resolved helicity can be a certified structural zero. Its empty CSR
+    // is executable: source dispatch remains exact and the full amplitude
+    // clear below produces a deterministic dense zero tile.
+    order_contributions_for_fanout(&mut drafts);
+    rederive_contribution_initialization(&mut drafts);
+    let groups = drafts
+        .into_iter()
+        .map(|draft| PersistedFamilyGroupV1 {
+            stage: draft.stage,
+            role: draft.rows.role(),
+            direct_executor_id: draft.direct_executor_id,
+            rows: draft.rows.freeze(),
+        })
+        .collect::<Vec<_>>()
+        .into_boxed_slice();
+    let source_selections = selected_source_rows(plan, resolved_helicity_id)?;
+    let (unique_current_count, unique_current_component_count) =
+        family_current_census(plan, &source_selections, &groups)?;
+    Ok(PersistedHelicityFamilyV1 {
+        resolved_helicity_id,
+        source_selections,
+        groups,
+        unique_current_count,
+        unique_current_component_count,
+    })
+}
+
+fn bind_groups<R: OnTheFlyPreparedExecutorResolver>(
+    resolver: &R,
+    family: &PersistedHelicityFamilyV1,
+) -> RusticolResult<Box<[Option<ResolvedOnTheFlyExecutor>]>> {
+    family
+        .groups
+        .iter()
+        .map(|group| {
+            if group.role == DirectExecutorRole::Contribution
+                && group.direct_executor_id == DIRECT_NONE_U32
+            {
+                let PersistedFamilyRowsV1::Contribution(rows) = &group.rows else {
+                    return Err(integrity(
+                        "certified-reuse persisted group has non-contribution storage",
+                    ));
+                };
+                if rows
+                    .iter()
+                    .any(|row| row.flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE == 0)
+                {
+                    return Err(integrity(
+                        "missing-executor persisted group is not certified reuse",
+                    ));
+                }
+                return Ok(None);
+            }
+            let resolved =
+                resolver.resolve_direct_executor(group.direct_executor_id, group.role)?;
+            if resolved.direct_executor_id != group.direct_executor_id
+                || resolved.handle.role() != group.role
+            {
+                return Err(integrity(
+                    "persisted family executor binding differs from its direct row group",
+                ));
+            }
+            Ok(Some(resolved))
+        })
+        .collect::<RusticolResult<Vec<_>>>()
+        .map(Vec::into_boxed_slice)
+}
+
+fn direct_group_views<'a>(
+    family: &'a PersistedHelicityFamilyV1,
+    resolved_groups: &[Option<ResolvedOnTheFlyExecutor>],
+) -> RusticolResult<(Vec<DirectInteractionGroupView<'a>>, usize)> {
+    if family.groups.len() != resolved_groups.len() {
+        return Err(integrity(
+            "persisted family resolved group count is inconsistent",
+        ));
+    }
+    let mut views = Vec::with_capacity(family.groups.len());
+    let mut contribution_count = 0usize;
+    for (group, resolved) in family.groups.iter().zip(resolved_groups) {
+        views.push(match &group.rows {
+            PersistedFamilyRowsV1::Contribution(rows) => {
+                contribution_count =
+                    contribution_count.checked_add(rows.len()).ok_or_else(|| {
+                        integrity("persisted family contribution count exceeds usize")
+                    })?;
+                DirectInteractionGroupView::contribution(
+                    group.stage,
+                    group.direct_executor_id,
+                    resolved.map(|resolved| resolved.handle),
+                    resolved.and_then(|resolved| resolved.interaction_capability),
+                    rows,
+                )
+            }
+            PersistedFamilyRowsV1::Finalization(_) => DirectInteractionGroupView::other(
+                group.stage,
+                group.role,
+                group.direct_executor_id,
+                resolved.map(|resolved| resolved.handle),
+            ),
+            PersistedFamilyRowsV1::Closure(rows) => {
+                let resolved = resolved
+                    .ok_or_else(|| integrity("persisted closure group has no resolved executor"))?;
+                DirectInteractionGroupView::closure(
+                    group.stage,
+                    group.direct_executor_id,
+                    resolved.handle,
+                    rows,
+                )
+            }
+        });
+    }
+    Ok((views, contribution_count))
+}
+
+fn bind_programs(
+    plan: &DirectRecurrencePlan,
+    layout: &PersistedPlanLayoutV1,
+    family: &PersistedHelicityFamilyV1,
+    resolved_groups: &[Option<ResolvedOnTheFlyExecutor>],
+) -> RusticolResult<(
+    DirectInteractionProgram,
+    DirectSingletonContributionFanoutProgram,
+)> {
+    let (views, contribution_count) = direct_group_views(family, resolved_groups)?;
+    let schedule = DirectInteractionScheduleView::new(
+        RecurrenceStrategy::ContractedColorUnion,
+        &views,
+        plan.currents(),
+        contribution_count,
+    );
+    let interaction = DirectInteractionProgram::build(schedule)?;
+    let fanout = DirectSingletonContributionFanoutProgram::build(
+        &views,
+        layout.current_component_count,
+        u32::try_from(layout.momentum_forms.len())
+            .map_err(|_| integrity("persisted momentum-form count exceeds u32"))?,
+        layout.parameter_count,
+        u32::try_from(layout.exact_factors.len())
+            .map_err(|_| integrity("persisted exact-factor count exceeds u32"))?,
+    )?;
+    Ok((interaction, fanout))
+}
+
+fn increment(value: &mut u32, by: u32, label: &str) -> RusticolResult<()> {
+    *value = value
+        .checked_add(by)
+        .ok_or_else(|| integrity(format!("persisted helicity {label} exceeds u32")))?;
+    Ok(())
+}
+
+fn record_profiled_group(
+    report: &mut PersistedHelicityFamilyExecutionReportV1,
+    role: DirectExecutorRole,
+    row_count: u32,
+) -> RusticolResult<()> {
+    match role {
+        DirectExecutorRole::Source => {
+            increment(&mut report.source_calls, 1, "source calls")?;
+            increment(&mut report.source_rows, row_count, "source rows")
+        }
+        DirectExecutorRole::Contribution => {
+            increment(&mut report.contribution_calls, 1, "contribution calls")?;
+            increment(
+                &mut report.contribution_rows,
+                row_count,
+                "contribution rows",
+            )
+        }
+        DirectExecutorRole::Finalization => {
+            increment(&mut report.finalization_calls, 1, "finalization calls")?;
+            increment(
+                &mut report.finalization_rows,
+                row_count,
+                "finalization rows",
+            )
+        }
+        DirectExecutorRole::Closure => {
+            increment(&mut report.closure_calls, 1, "closure calls")?;
+            increment(&mut report.closure_rows, row_count, "closure rows")
+        }
+    }
+}
+
+fn execute_union_source(
+    program: &dyn OnTheFlyBoundUnionSourceProgram,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    point_count: u32,
+) -> RusticolResult<()> {
+    // `raw_views` authenticated the descriptor bundle immediately before this
+    // call. The source program authenticated every plan-owned table and bound
+    // all catalog lookups during `prepare`.
+    unsafe { program.execute(arena, momenta, parameters, point_count) }
+}
+
+fn execute_bound_family<Report, RecordGroup>(
+    layout: &PersistedPlanLayoutV1,
+    cached: &mut BoundPersistedHelicityFamilyV1,
+    point_count: u32,
+    mut report: Report,
+    mut record_group: RecordGroup,
+) -> RusticolResult<Report>
+where
+    RecordGroup: FnMut(&mut Report, DirectExecutorRole, u32) -> RusticolResult<()>,
+{
+    clear_direct_executor_error_detail();
+    // The workspace shape is immutable while a family is bound. Authenticate
+    // its raw descriptors once per tile, then reuse the Copy views for the
+    // source dispatcher and every row group, exactly as the OTF family path
+    // does. Revalidating their pointer ranges inside each group is redundant.
+    let (arena, momenta, parameters, factors) = cached.workspace.raw_views(layout)?;
+    execute_union_source(
+        cached.union_source_program.as_ref(),
+        arena,
+        momenta,
+        parameters,
+        point_count,
+    )?;
+    let source_row_count = u32::try_from(cached.family.source_selections.len())
+        .map_err(|_| integrity("persisted source-selection count exceeds u32"))?;
+    record_group(&mut report, DirectExecutorRole::Source, source_row_count)?;
+
+    for (group_index, (group, resolved)) in cached
+        .family
+        .groups
+        .iter()
+        .zip(cached.resolved_groups.iter().copied())
+        .enumerate()
+    {
+        let row_count = u32::try_from(group.rows.len())
+            .map_err(|_| integrity("persisted row-group count exceeds u32"))?;
+        if group.role == DirectExecutorRole::Source {
+            return Err(integrity(
+                "persisted non-source schedule contains a source group",
+            ));
+        }
+        record_group(&mut report, group.role, row_count)?;
+
+        if point_count == 1 {
+            match cached.interaction_program.action(group_index) {
+                DirectInteractionGroupAction::Normal => {
+                    if let PersistedFamilyRowsV1::Contribution(rows) = &group.rows
+                        && group.direct_executor_id != DIRECT_NONE_U32
+                        && cached.singleton_fanout_program.execute_group(
+                            group_index,
+                            rows,
+                            arena,
+                            momenta,
+                            parameters,
+                            factors,
+                            point_count,
+                        )?
+                    {
+                        continue;
+                    }
+                }
+                DirectInteractionGroupAction::Consumed => continue,
+                DirectInteractionGroupAction::Execute(stage_index) => {
+                    cached.interaction_program.execute::<false>(
+                        stage_index,
+                        arena,
+                        momenta,
+                        parameters,
+                        factors,
+                    )?;
+                    continue;
+                }
+            }
+        }
+
+        if group.role == DirectExecutorRole::Contribution
+            && group.direct_executor_id == DIRECT_NONE_U32
+        {
+            let PersistedFamilyRowsV1::Contribution(rows) = &group.rows else {
+                return Err(integrity("certified-reuse group has non-contribution rows"));
+            };
+            let mut workspace = cached.workspace.direct_workspace(layout);
+            execute_certified_reuse_rows(rows, &mut workspace, point_count)?;
+            continue;
+        }
+
+        let resolved = resolved
+            .ok_or_else(|| integrity("persisted callable row group has no resolved executor"))?;
+        let status = unsafe {
+            match (&group.rows, resolved.handle) {
+                (
+                    PersistedFamilyRowsV1::Contribution(rows),
+                    DirectExecutorHandle::Contribution { call, context },
+                ) => call(
+                    context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    rows.as_ptr(),
+                    row_count,
+                    point_count,
+                ),
+                (
+                    PersistedFamilyRowsV1::Finalization(rows),
+                    DirectExecutorHandle::Finalization { call, context },
+                ) => call(
+                    context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    rows.as_ptr(),
+                    row_count,
+                    point_count,
+                ),
+                (
+                    PersistedFamilyRowsV1::Closure(rows),
+                    DirectExecutorHandle::Closure { call, context },
+                ) => call(
+                    context,
+                    arena,
+                    momenta,
+                    parameters,
+                    factors,
+                    rows.as_ptr(),
+                    row_count,
+                    point_count,
+                ),
+                _ => {
+                    return Err(integrity(
+                        "persisted family handle differs from its row storage",
+                    ));
+                }
+            }
+        };
+        check_status(group.role, group.direct_executor_id, status)?;
+    }
+    cached.workspace.active_point_count = point_count;
+    Ok(report)
+}
+
+/// One retained cold binding for the active auxiliary-plan helicity.
+/// Repeated calls for that H stay on the bound row/program path and never
+/// revisit the dispatch CSR. Switching H replaces this workspace deliberately
+/// instead of multiplying recurrence arenas by the full helicity count.
+pub(crate) struct PersistedHelicityFamilyExecutorV1<R: OnTheFlyPreparedExecutorResolver> {
+    family: Option<BoundPersistedHelicityFamilyV1>,
+    layout: Option<PersistedPlanLayoutV1>,
+    resolver: R,
+    parameter_state: Vec<(f64, f64)>,
+    parameter_version: u64,
+    active_cache_hit: bool,
+}
+
+#[allow(dead_code)] // Inspection/control methods are used by feature-specific runtime adapters.
+impl<R: OnTheFlyPreparedExecutorResolver> PersistedHelicityFamilyExecutorV1<R> {
+    pub(crate) const fn new(resolver: R) -> Self {
+        Self {
+            family: None,
+            layout: None,
+            resolver,
+            parameter_state: Vec::new(),
+            parameter_version: 0,
+            active_cache_hit: false,
+        }
+    }
+
+    pub(crate) const fn resolver(&self) -> &R {
+        &self.resolver
+    }
+
+    pub(crate) const fn resolver_mut(&mut self) -> &mut R {
+        &mut self.resolver
+    }
+
+    fn invalidate_exposed_row_tables(&mut self) -> RusticolResult<()> {
+        if !self
+            .family
+            .as_ref()
+            .is_some_and(|family| family.descriptor_exposed)
+        {
+            return Ok(());
+        }
+        self.resolver.invalidate_row_tables()?;
+        if let Some(family) = &mut self.family {
+            family.descriptor_exposed = false;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn clear_families(&mut self) -> RusticolResult<()> {
+        self.invalidate_exposed_row_tables()?;
+        self.family = None;
+        self.layout = None;
+        self.active_cache_hit = false;
+        Ok(())
+    }
+
+    pub(crate) fn cache_census(&self) -> PersistedHelicityFamilyCacheCensusV1 {
+        PersistedHelicityFamilyCacheCensusV1 {
+            resolved_helicity_count: self
+                .layout
+                .as_ref()
+                .map_or(0, |layout| layout.resolved_helicity_count),
+            retained_family_count: u32::from(self.family.is_some()),
+            retained_row_count: self
+                .family
+                .as_ref()
+                .into_iter()
+                .flat_map(|family| family.family.groups.iter())
+                .map(|group| group.rows.len() as u64)
+                .sum(),
+            active_resolved_helicity_id: self
+                .family
+                .as_ref()
+                .map(|family| family.family.resolved_helicity_id),
+        }
+    }
+
+    pub(crate) fn active_family_inspection_census(
+        &self,
+    ) -> Option<PersistedHelicityFamilyInspectionCensusV1> {
+        let layout = self.layout.as_ref()?;
+        let cached = self.family.as_ref()?;
+        // The option is the successful-execution marker. Derive diagnostic
+        // counts only when inspection is requested so ordinary unprofiled
+        // evaluation does no per-group report bookkeeping.
+        cached.last_execution_report?;
+        let mut report = PersistedHelicityFamilyExecutionReportV1 {
+            source_calls: 1,
+            source_rows: u32::try_from(cached.family.source_selections.len()).ok()?,
+            ..PersistedHelicityFamilyExecutionReportV1::default()
+        };
+        let mut executor_ids = BTreeSet::<u32>::new();
+        for selection in &cached.family.source_selections {
+            let variant = layout
+                .source_dispatch_variants
+                .get(selection.dispatch_variant_id as usize)?;
+            if variant.direct_executor_id != DIRECT_NONE_U32 {
+                executor_ids.insert(variant.direct_executor_id);
+            }
+        }
+        for group in &cached.family.groups {
+            let row_count = u32::try_from(group.rows.len()).ok()?;
+            match group.role {
+                DirectExecutorRole::Source => return None,
+                DirectExecutorRole::Contribution => {
+                    increment(&mut report.contribution_calls, 1, "contribution calls").ok()?;
+                    increment(
+                        &mut report.contribution_rows,
+                        row_count,
+                        "contribution rows",
+                    )
+                    .ok()?;
+                }
+                DirectExecutorRole::Finalization => {
+                    increment(&mut report.finalization_calls, 1, "finalization calls").ok()?;
+                    increment(
+                        &mut report.finalization_rows,
+                        row_count,
+                        "finalization rows",
+                    )
+                    .ok()?;
+                }
+                DirectExecutorRole::Closure => {
+                    increment(&mut report.closure_calls, 1, "closure calls").ok()?;
+                    increment(&mut report.closure_rows, row_count, "closure rows").ok()?;
+                }
+            }
+            if group.direct_executor_id != DIRECT_NONE_U32 {
+                executor_ids.insert(group.direct_executor_id);
+            }
+        }
+        let semantic_executor_binding_count = u32::try_from(executor_ids.len()).ok()?;
+        Some(PersistedHelicityFamilyInspectionCensusV1 {
+            query_count: layout.amplitude_destination_count,
+            union_unique_current_count: cached.family.unique_current_count,
+            union_unique_current_component_count: cached.family.unique_current_component_count,
+            union_source_rows: report.source_rows,
+            union_contribution_rows: report.contribution_rows,
+            union_finalization_rows: report.finalization_rows,
+            union_closure_rows: report.closure_rows,
+            union_amplitude_destination_count: layout.amplitude_destination_count,
+            union_source_executor_call_groups: report.source_calls,
+            union_contribution_executor_call_groups: report.contribution_calls,
+            union_finalization_executor_call_groups: report.finalization_calls,
+            union_closure_executor_call_groups: report.closure_calls,
+            semantic_executor_binding_count,
+        })
+    }
+
+    pub(crate) fn resolved_helicities(
+        &self,
+    ) -> RusticolResult<&[DirectResolvedHelicityDescriptor]> {
+        self.layout
+            .as_ref()
+            .map(|layout| layout.resolved_helicities.as_ref())
+            .ok_or_else(|| invalid("persisted helicity descriptors require a cold prepare"))
+    }
+
+    pub(crate) fn public_helicities(&self) -> RusticolResult<&[i32]> {
+        self.layout
+            .as_ref()
+            .map(|layout| layout.public_helicities.as_ref())
+            .ok_or_else(|| invalid("persisted public helicities require a cold prepare"))
+    }
+
+    pub(crate) fn set_parameters(&mut self, parameters: &[(f64, f64)]) -> RusticolResult<()> {
+        if parameters
+            .iter()
+            .any(|(real, imag)| !real.is_finite() || !imag.is_finite())
+        {
+            return Err(invalid("persisted helicity parameter value is not finite"));
+        }
+        if self.parameter_state == parameters {
+            return Ok(());
+        }
+        let mut replacement = Vec::new();
+        replacement
+            .try_reserve_exact(parameters.len())
+            .map_err(|error| {
+                invalid(format!(
+                    "persisted helicity parameter allocation failed: {error}"
+                ))
+            })?;
+        replacement.extend_from_slice(parameters);
+        self.parameter_state = replacement;
+        self.parameter_version = self
+            .parameter_version
+            .checked_add(1)
+            .ok_or_else(|| invalid("persisted helicity parameter version exceeds u64"))?;
+        Ok(())
+    }
+
+    /// Update from the recurrence lane's persistent split-complex parameter
+    /// planes. Equality is checked in place; unchanged warm preparation does
+    /// not allocate or rewrite any retained workspace.
+    pub(crate) fn set_parameter_planes(
+        &mut self,
+        parameters_re: &[f64],
+        parameters_im: &[f64],
+    ) -> RusticolResult<()> {
+        if parameters_re.len() != parameters_im.len() {
+            return Err(invalid(
+                "persisted helicity parameter planes have different lengths",
+            ));
+        }
+        if parameters_re
+            .iter()
+            .zip(parameters_im)
+            .any(|(real, imag)| !real.is_finite() || !imag.is_finite())
+        {
+            return Err(invalid("persisted helicity parameter value is not finite"));
+        }
+        if self.parameter_state.len() == parameters_re.len()
+            && self
+                .parameter_state
+                .iter()
+                .zip(parameters_re.iter().zip(parameters_im))
+                .all(|(&(cached_re, cached_im), (&real, &imag))| {
+                    cached_re == real && cached_im == imag
+                })
+        {
+            return Ok(());
+        }
+        let mut replacement = Vec::new();
+        replacement
+            .try_reserve_exact(parameters_re.len())
+            .map_err(|error| {
+                invalid(format!(
+                    "persisted helicity parameter allocation failed: {error}"
+                ))
+            })?;
+        replacement.extend(
+            parameters_re
+                .iter()
+                .copied()
+                .zip(parameters_im.iter().copied()),
+        );
+        self.parameter_state = replacement;
+        self.parameter_version = self
+            .parameter_version
+            .checked_add(1)
+            .ok_or_else(|| invalid("persisted helicity parameter version exceeds u64"))?;
+        Ok(())
+    }
+
+    fn ensure_layout(
+        &mut self,
+        plan: &DirectRecurrencePlan,
+        dispatch: &DirectHelicityDispatch,
+        lorentz_component_count: u16,
+    ) -> RusticolResult<()> {
+        let matches = self.layout.as_ref().is_some_and(|layout| {
+            layout.runtime_layout_digest == plan.runtime_layout_digest()
+                && layout.dispatch_address == std::ptr::from_ref(dispatch).addr()
+                && layout.lorentz_component_count == lorentz_component_count
+        });
+        if matches {
+            return Ok(());
+        }
+        dispatch.validate_for_plan(plan)?;
+        self.clear_families()?;
+        self.layout = Some(PersistedPlanLayoutV1::new(
+            plan,
+            dispatch,
+            lorentz_component_count,
+        )?);
+        Ok(())
+    }
+
+    /// Cold-select one full auxiliary-plan resolved helicity.
+    ///
+    /// Returns true when the optimized family was already retained. All CSR
+    /// traversal, row copying, INIT derivation, and program construction occur
+    /// here and are absent from warmed execution.
+    pub(crate) fn prepare(
+        &mut self,
+        plan: &DirectRecurrencePlan,
+        dispatch: &DirectHelicityDispatch,
+        resolved_helicity_id: u32,
+        lorentz_component_count: u16,
+        logical_point_capacity: u32,
+    ) -> RusticolResult<bool> {
+        self.ensure_layout(plan, dispatch, lorentz_component_count)?;
+        let layout = self
+            .layout
+            .as_ref()
+            .expect("persisted layout was just established");
+        if resolved_helicity_id >= layout.resolved_helicity_count {
+            return Err(invalid(
+                "persisted resolved helicity is outside the auxiliary plan",
+            ));
+        }
+
+        if self
+            .family
+            .as_ref()
+            .is_some_and(|family| family.family.resolved_helicity_id == resolved_helicity_id)
+        {
+            let needs_resize = self.family.as_ref().is_some_and(|family| {
+                logical_point_capacity > family.workspace.logical_point_capacity
+            });
+            if needs_resize {
+                let family = self
+                    .family
+                    .as_ref()
+                    .expect("retained persisted family disappeared");
+                let replacement = PersistedHelicityWorkspaceV1::new(
+                    layout,
+                    logical_point_capacity,
+                    family.packed_singleton_capable,
+                )?;
+                self.invalidate_exposed_row_tables()?;
+                let family = self
+                    .family
+                    .as_mut()
+                    .expect("retained persisted family disappeared after invalidation");
+                family.workspace = replacement;
+                family.applied_parameter_version = u64::MAX;
+            }
+            self.active_cache_hit = true;
+            return Ok(true);
+        }
+
+        let family = build_family(plan, dispatch, resolved_helicity_id)?;
+        let resolved_groups = bind_groups(&self.resolver, &family)?;
+        let packed_singleton_capable = self.resolver.union_source_packed_singleton_capable()
+            && resolved_groups
+                .iter()
+                .flatten()
+                .all(|resolved| resolved.packed_singleton_capable);
+        let workspace = PersistedHelicityWorkspaceV1::new(
+            layout,
+            logical_point_capacity,
+            packed_singleton_capable,
+        )?;
+        let (interaction_program, singleton_fanout_program) =
+            bind_programs(plan, layout, &family, &resolved_groups)?;
+        let union_source_program =
+            self.resolver
+                .bind_union_source_program(OnTheFlyUnionSourceBindingView {
+                    sources: &layout.sources,
+                    variants: &layout.source_dispatch_variants,
+                    embeddings: &layout.source_embeddings,
+                    selections: &family.source_selections,
+                    exact_factors: &layout.exact_factors,
+                    current_component_count: layout.current_component_count,
+                    momentum_form_count: u32::try_from(layout.momentum_forms.len())
+                        .map_err(|_| integrity("persisted momentum-form count exceeds u32"))?,
+                    parameter_count: layout.parameter_count,
+                })?;
+        let bound = BoundPersistedHelicityFamilyV1 {
+            family,
+            workspace,
+            resolved_groups,
+            union_source_program,
+            packed_singleton_capable,
+            interaction_program,
+            singleton_fanout_program,
+            applied_parameter_version: u64::MAX,
+            descriptor_exposed: false,
+            last_execution_report: None,
+        };
+        self.invalidate_exposed_row_tables()?;
+        self.family = Some(bound);
+        self.active_cache_hit = false;
+        Ok(false)
+    }
+
+    fn execute_active<Report, RecordGroup>(
+        &mut self,
+        external_momenta: &[f64],
+        point_count: u32,
+        report: Report,
+        record_group: RecordGroup,
+    ) -> RusticolResult<Report>
+    where
+        RecordGroup: FnMut(&mut Report, DirectExecutorRole, u32) -> RusticolResult<()>,
+    {
+        let layout = self
+            .layout
+            .as_ref()
+            .ok_or_else(|| invalid("persisted helicity execution requires a cold prepare"))?;
+        let family = self
+            .family
+            .as_mut()
+            .ok_or_else(|| integrity("active persisted helicity family is absent"))?;
+        if family.applied_parameter_version != self.parameter_version {
+            family.workspace.refresh_parameters(&self.parameter_state)?;
+            family.applied_parameter_version = self.parameter_version;
+        }
+        family
+            .workspace
+            .refresh_inputs(layout, external_momenta, point_count)?;
+        family.descriptor_exposed = true;
+        let report = execute_bound_family(layout, family, point_count, report, record_group)?;
+        self.active_cache_hit = true;
+        Ok(report)
+    }
+
+    fn mark_execution_report(&mut self, report: PersistedHelicityFamilyExecutionReportV1) {
+        self.family
+            .as_mut()
+            .expect("successful persisted execution lost its active family")
+            .last_execution_report = Some(report);
+    }
+
+    pub(crate) fn execute_tile_unprofiled(
+        &mut self,
+        external_momenta: &[f64],
+        point_count: u32,
+    ) -> RusticolResult<PersistedHelicityAmplitudeTileV1<'_>> {
+        self.execute_active(external_momenta, point_count, (), |_, _, _| Ok(()))?;
+        self.mark_execution_report(PersistedHelicityFamilyExecutionReportV1::default());
+        self.active_tile(point_count)
+    }
+
+    pub(crate) fn execute_tile_profiled(
+        &mut self,
+        external_momenta: &[f64],
+        point_count: u32,
+    ) -> RusticolResult<(
+        PersistedHelicityAmplitudeTileV1<'_>,
+        PersistedHelicityFamilyExecutionReportV1,
+    )> {
+        let report = self.execute_active(
+            external_momenta,
+            point_count,
+            PersistedHelicityFamilyExecutionReportV1 {
+                cache_hit: self.active_cache_hit,
+                ..PersistedHelicityFamilyExecutionReportV1::default()
+            },
+            record_profiled_group,
+        )?;
+        self.mark_execution_report(report);
+        let tile = self.active_tile(point_count)?;
+        Ok((tile, report))
+    }
+
+    fn active_tile(
+        &self,
+        point_count: u32,
+    ) -> RusticolResult<PersistedHelicityAmplitudeTileV1<'_>> {
+        let layout = self
+            .layout
+            .as_ref()
+            .ok_or_else(|| integrity("persisted helicity layout disappeared"))?;
+        let family = self
+            .family
+            .as_ref()
+            .ok_or_else(|| integrity("persisted helicity active family is absent"))?;
+        family
+            .workspace
+            .tile(layout, family.family.resolved_helicity_id, point_count)
+    }
+
+    fn validate_output_shape(
+        &self,
+        point_count: u32,
+        output_re: &[f64],
+        output_im: &[f64],
+    ) -> RusticolResult<()> {
+        let destination_count = self
+            .layout
+            .as_ref()
+            .ok_or_else(|| invalid("persisted helicity output requires a cold prepare"))?
+            .amplitude_destination_count;
+        let expected = destination_count as usize * point_count as usize;
+        if output_re.len() != expected || output_im.len() != expected {
+            return Err(invalid(format!(
+                "persisted helicity outputs have shapes ({}, {}), expected ({expected}, {expected})",
+                output_re.len(),
+                output_im.len()
+            )));
+        }
+        Ok(())
+    }
+
+    fn copy_active_outputs(
+        &self,
+        point_count: u32,
+        output_re: &mut [f64],
+        output_im: &mut [f64],
+    ) -> RusticolResult<()> {
+        self.validate_output_shape(point_count, output_re, output_im)?;
+        let tile = self.active_tile(point_count)?;
+        for destination in 0..tile.destination_count() as usize {
+            let source_start = destination * tile.point_stride() as usize;
+            let source_end = source_start + point_count as usize;
+            let destination_start = destination * point_count as usize;
+            let destination_end = destination_start + point_count as usize;
+            output_re[destination_start..destination_end]
+                .copy_from_slice(&tile.amplitude_re()[source_start..source_end]);
+            output_im[destination_start..destination_end]
+                .copy_from_slice(&tile.amplitude_im()[source_start..source_end]);
+        }
+        Ok(())
+    }
+
+    pub(crate) fn execute_into_unprofiled(
+        &mut self,
+        external_momenta: &[f64],
+        point_count: u32,
+        output_re: &mut [f64],
+        output_im: &mut [f64],
+    ) -> RusticolResult<()> {
+        self.validate_output_shape(point_count, output_re, output_im)?;
+        self.execute_active(external_momenta, point_count, (), |_, _, _| Ok(()))?;
+        self.mark_execution_report(PersistedHelicityFamilyExecutionReportV1::default());
+        self.copy_active_outputs(point_count, output_re, output_im)
+    }
+
+    pub(crate) fn execute_into_profiled(
+        &mut self,
+        external_momenta: &[f64],
+        point_count: u32,
+        output_re: &mut [f64],
+        output_im: &mut [f64],
+    ) -> RusticolResult<PersistedHelicityFamilyExecutionReportV1> {
+        self.validate_output_shape(point_count, output_re, output_im)?;
+        let mut report = PersistedHelicityFamilyExecutionReportV1 {
+            cache_hit: self.active_cache_hit,
+            ..PersistedHelicityFamilyExecutionReportV1::default()
+        };
+        report =
+            self.execute_active(external_momenta, point_count, report, record_profiled_group)?;
+        self.mark_execution_report(report);
+        self.copy_active_outputs(point_count, output_re, output_im)?;
+        Ok(report)
+    }
+}
+
+impl<R: OnTheFlyPreparedExecutorResolver> Drop for PersistedHelicityFamilyExecutorV1<R> {
+    fn drop(&mut self) {
+        if self.invalidate_exposed_row_tables().is_ok() {
+            return;
+        }
+        // A callback unexpectedly retaining row pointers is safer with leaked
+        // private rows than with a dangling descriptor during teardown.
+        if let Some(family) = self.family.take()
+            && family.descriptor_exposed
+        {
+            std::mem::forget(family);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::{
+        DirectHelicityDispatchDescriptor, DirectHelicityDispatchParts,
+        DirectHelicityRowGroupDescriptor, DirectHelicitySupportDomainDescriptor,
+        DirectSourceProjectionRow,
+    };
+    use std::cell::Cell;
+    use std::ffi::c_void;
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    fn test_layout() -> PersistedPlanLayoutV1 {
+        PersistedPlanLayoutV1 {
+            runtime_layout_digest: digest(0x44),
+            dispatch_address: 0,
+            source_count: 2,
+            lorentz_component_count: 2,
+            parameter_count: 0,
+            current_component_count: 4,
+            amplitude_destination_count: 2,
+            resolved_helicity_count: 2,
+            resolved_helicities: Box::new([]),
+            public_helicities: Box::new([]),
+            momentum_forms: vec![
+                CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                    source_slot: 0,
+                    coefficient: 1,
+                }])
+                .unwrap(),
+                CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                    source_slot: 1,
+                    coefficient: -1,
+                }])
+                .unwrap(),
+            ]
+            .into_boxed_slice(),
+            exact_factors: vec![ExactComplexRational::ONE].into_boxed_slice(),
+            sources: Box::new([]),
+            source_dispatch_variants: Box::new([]),
+            source_embeddings: Box::new([]),
+        }
+    }
+
+    fn contribution(destination: u32, flags: u32) -> DirectContributionRow {
+        DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 1,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            destination_component_base: destination,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags,
+        }
+    }
+
+    struct ProbeBoundUnionSourceProgram {
+        value: f64,
+    }
+
+    impl OnTheFlyBoundUnionSourceProgram for ProbeBoundUnionSourceProgram {
+        unsafe fn execute(
+            &self,
+            arena: DirectArenaView,
+            _momenta: DirectMomentumView,
+            _parameters: DirectParameterView,
+            point_count: u32,
+        ) -> RusticolResult<()> {
+            let current_re = unsafe {
+                std::slice::from_raw_parts_mut(arena.current_re, arena.current_scalar_len as usize)
+            };
+            let current_im = unsafe {
+                std::slice::from_raw_parts_mut(arena.current_im, arena.current_scalar_len as usize)
+            };
+            for component in 0..2usize {
+                for point in 0..point_count as usize {
+                    let index = component * arena.point_stride as usize + point;
+                    current_re[index] = self.value;
+                    current_im[index] = 0.0;
+                }
+            }
+            Ok(())
+        }
+    }
+
+    unsafe extern "C" fn contribution_copy(
+        _context: *const c_void,
+        arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        rows: *const DirectContributionRow,
+        row_count: u32,
+        point_count: u32,
+    ) -> c_int {
+        let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+        let current_re = unsafe {
+            std::slice::from_raw_parts_mut(arena.current_re, arena.current_scalar_len as usize)
+        };
+        let current_im = unsafe {
+            std::slice::from_raw_parts_mut(arena.current_im, arena.current_scalar_len as usize)
+        };
+        for row in rows {
+            for point in 0..point_count as usize {
+                let source =
+                    row.parent0_component_base as usize * arena.point_stride as usize + point;
+                let destination =
+                    row.destination_component_base as usize * arena.point_stride as usize + point;
+                if row.flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION != 0 {
+                    current_re[destination] = current_re[source];
+                    current_im[destination] = current_im[source];
+                } else {
+                    current_re[destination] += current_re[source];
+                    current_im[destination] += current_im[source];
+                }
+            }
+        }
+        DIRECT_STATUS_OK
+    }
+
+    unsafe extern "C" fn finalize_noop(
+        _context: *const c_void,
+        _arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        _rows: *const DirectFinalizationRow,
+        _row_count: u32,
+        _point_count: u32,
+    ) -> c_int {
+        DIRECT_STATUS_OK
+    }
+
+    unsafe extern "C" fn close_copy(
+        _context: *const c_void,
+        arena: DirectArenaView,
+        _momenta: DirectMomentumView,
+        _parameters: DirectParameterView,
+        _factors: DirectFactorView,
+        rows: *const DirectClosureRow,
+        row_count: u32,
+        point_count: u32,
+    ) -> c_int {
+        let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+        let current_re = unsafe {
+            std::slice::from_raw_parts(arena.current_re, arena.current_scalar_len as usize)
+        };
+        let current_im = unsafe {
+            std::slice::from_raw_parts(arena.current_im, arena.current_scalar_len as usize)
+        };
+        let amplitude_re = unsafe {
+            std::slice::from_raw_parts_mut(arena.amplitude_re, arena.amplitude_scalar_len as usize)
+        };
+        let amplitude_im = unsafe {
+            std::slice::from_raw_parts_mut(arena.amplitude_im, arena.amplitude_scalar_len as usize)
+        };
+        for row in rows {
+            for point in 0..point_count as usize {
+                let source =
+                    row.parent0_component_base as usize * arena.point_stride as usize + point;
+                let destination =
+                    row.amplitude_destination_id as usize * arena.point_stride as usize + point;
+                amplitude_re[destination] += current_re[source];
+                amplitude_im[destination] += current_im[source];
+            }
+        }
+        DIRECT_STATUS_OK
+    }
+
+    struct ProbeResolver {
+        invalidations: Cell<u32>,
+        source_bindings: Cell<u32>,
+    }
+
+    impl OnTheFlyPreparedExecutorResolver for ProbeResolver {
+        fn resolve(&self, _key: OnTheFlyExecutorKeyV1) -> RusticolResult<ResolvedOnTheFlyExecutor> {
+            Err(integrity("semantic resolver is unused by persisted test"))
+        }
+
+        fn resolve_direct_executor(
+            &self,
+            direct_executor_id: u32,
+            role: DirectExecutorRole,
+        ) -> RusticolResult<ResolvedOnTheFlyExecutor> {
+            let handle = match (direct_executor_id, role) {
+                (1, DirectExecutorRole::Contribution) => DirectExecutorHandle::Contribution {
+                    call: contribution_copy,
+                    context: std::ptr::null(),
+                },
+                (2, DirectExecutorRole::Finalization) => DirectExecutorHandle::Finalization {
+                    call: finalize_noop,
+                    context: std::ptr::null(),
+                },
+                (3, DirectExecutorRole::Closure) => DirectExecutorHandle::Closure {
+                    call: close_copy,
+                    context: std::ptr::null(),
+                },
+                _ => return Err(integrity("unexpected persisted test executor")),
+            };
+            Ok(ResolvedOnTheFlyExecutor {
+                direct_executor_id,
+                handle,
+                parent_permutation: [0, 1],
+                packed_singleton_capable: true,
+                interaction_capability: None,
+            })
+        }
+
+        fn bind_union_source_program(
+            &self,
+            view: OnTheFlyUnionSourceBindingView<'_>,
+        ) -> RusticolResult<Box<dyn OnTheFlyBoundUnionSourceProgram>> {
+            let selection = view
+                .selections
+                .first()
+                .ok_or_else(|| integrity("persisted test source selection is absent"))?;
+            self.source_bindings.set(self.source_bindings.get() + 1);
+            Ok(Box::new(ProbeBoundUnionSourceProgram {
+                value: selection.dispatch_variant_id as f64 + 1.0,
+            }))
+        }
+
+        fn union_source_packed_singleton_capable(&self) -> bool {
+            true
+        }
+
+        fn invalidate_row_tables(&self) -> RusticolResult<()> {
+            self.invalidations.set(self.invalidations.get() + 1);
+            Ok(())
+        }
+    }
+
+    fn all_flow_plan() -> DirectRecurrencePlan {
+        let mut parts = crate::recurrence::valid_direct_plan_parts_fixture();
+        parts.strategy = RecurrenceStrategy::AllFlowUnion;
+        parts.retained_helicity_count = 2;
+        parts.runtime_helicity_contract_count = 1;
+        parts.runtime_helicity_variant_count = 2;
+        parts.sources[0].source_template_or_dispatch_domain = 0;
+        parts.row_groups[0].direct_executor_id = DIRECT_NONE_U32;
+        parts.replay_targets[0].helicity_map_count = 0;
+        parts.replay_helicity_map.clear();
+        parts.amplitude_destinations[0].target_helicity_id_or_sentinel = DIRECT_NONE_U32;
+        parts.resolved_helicities = vec![
+            DirectResolvedHelicityDescriptor {
+                source_state_start: 0,
+                source_selection_start: 0,
+                public_helicity_start: 0,
+                id: 0,
+                source_state_count: 1,
+                source_selection_count: 1,
+                public_helicity_count: 1,
+                selector_domain_id: 0,
+            },
+            DirectResolvedHelicityDescriptor {
+                source_state_start: 1,
+                source_selection_start: 1,
+                public_helicity_start: 1,
+                id: 1,
+                source_state_count: 1,
+                source_selection_count: 1,
+                public_helicity_count: 1,
+                selector_domain_id: 0,
+            },
+        ];
+        parts.source_state_assignments = vec![
+            crate::recurrence::DirectSourceStateAssignment {
+                source_slot: 0,
+                state_index: 0,
+            },
+            crate::recurrence::DirectSourceStateAssignment {
+                source_slot: 0,
+                state_index: 1,
+            },
+        ];
+        parts.public_helicities = vec![-1, 1];
+        parts.source_dispatch_variants = (0..2)
+            .map(|id| DirectSourceDispatchVariantDescriptor {
+                embedding_start: id * 2,
+                projection_start: id * 2,
+                source_row_id: 0,
+                dispatch_domain_id: 0,
+                runtime_variant_id: id as u32,
+                source_state_index: id as u32,
+                source_template_id: 0,
+                source_state_template_id: 0,
+                crossed_state_template_id: 0,
+                crossed_spin_state_class: id as i32,
+                direct_executor_id: 0,
+                crossing_exact_factor_id: 0,
+                embedding_count: 2,
+                projection_count: 2,
+            })
+            .collect();
+        parts.source_embeddings = vec![
+            DirectSourceEmbeddingRow {
+                full_component: 0,
+                source_component_or_sentinel: 0,
+                exact_factor_id: 0,
+            },
+            DirectSourceEmbeddingRow {
+                full_component: 1,
+                source_component_or_sentinel: 1,
+                exact_factor_id: 0,
+            },
+            DirectSourceEmbeddingRow {
+                full_component: 0,
+                source_component_or_sentinel: 0,
+                exact_factor_id: 0,
+            },
+            DirectSourceEmbeddingRow {
+                full_component: 1,
+                source_component_or_sentinel: 1,
+                exact_factor_id: 0,
+            },
+        ];
+        parts.source_projections = vec![
+            DirectSourceProjectionRow {
+                source_component: 0,
+                full_component: 0,
+            },
+            DirectSourceProjectionRow {
+                source_component: 1,
+                full_component: 1,
+            },
+            DirectSourceProjectionRow {
+                source_component: 0,
+                full_component: 0,
+            },
+            DirectSourceProjectionRow {
+                source_component: 1,
+                full_component: 1,
+            },
+        ];
+        parts.resolved_source_selections = vec![
+            DirectResolvedSourceSelection {
+                source_slot: 0,
+                dispatch_variant_id: 0,
+            },
+            DirectResolvedSourceSelection {
+                source_slot: 0,
+                dispatch_variant_id: 1,
+            },
+        ];
+        DirectRecurrencePlan::new(parts).unwrap()
+    }
+
+    fn all_flow_dispatch(plan: &DirectRecurrencePlan) -> DirectHelicityDispatch {
+        DirectHelicityDispatch::new(DirectHelicityDispatchParts {
+            runtime_layout_digest: plan.runtime_layout_digest(),
+            source_row_count: 1,
+            contribution_row_count: 1,
+            finalization_row_count: 1,
+            closure_row_count: 1,
+            amplitude_destination_count: 1,
+            direct_executor_count: 4,
+            resolved_helicity_count: 2,
+            support_domains: vec![DirectHelicitySupportDomainDescriptor {
+                word_start: 0,
+                word_count: 1,
+            }],
+            support_words: vec![0b01],
+            row_groups: vec![
+                DirectHelicityRowGroupDescriptor {
+                    stage: 1,
+                    role: DirectExecutorRole::Contribution,
+                    direct_executor_id: 1,
+                    row_start: 0,
+                    row_count: 1,
+                    support_domain_id: 0,
+                },
+                DirectHelicityRowGroupDescriptor {
+                    stage: 1,
+                    role: DirectExecutorRole::Finalization,
+                    direct_executor_id: 2,
+                    row_start: 0,
+                    row_count: 1,
+                    support_domain_id: 0,
+                },
+                DirectHelicityRowGroupDescriptor {
+                    stage: 2,
+                    role: DirectExecutorRole::Closure,
+                    direct_executor_id: 3,
+                    row_start: 0,
+                    row_count: 1,
+                    support_domain_id: 0,
+                },
+            ],
+            dispatches: vec![
+                DirectHelicityDispatchDescriptor {
+                    resolved_helicity_id: 0,
+                    group_id_start: 0,
+                    group_id_count: 3,
+                },
+                DirectHelicityDispatchDescriptor {
+                    resolved_helicity_id: 1,
+                    group_id_start: 3,
+                    group_id_count: 0,
+                },
+            ],
+            dispatch_group_ids: vec![0, 1, 2],
+        })
+        .unwrap()
+    }
+
+    fn all_flow_plan_with_reused_component_base() -> DirectRecurrencePlan {
+        let mut parts = all_flow_plan().into_parts();
+        parts.current_arena_components = 2;
+        parts.currents[0].last_use = 0;
+        parts.currents[1].component_base = 0;
+        parts.contributions[0].destination_component_base = 0;
+        parts.finalizations[0].component_base = 0;
+        parts.closures[0].parent0_component_base = 0;
+        DirectRecurrencePlan::new(parts).unwrap()
+    }
+
+    #[test]
+    fn persisted_census_distinguishes_reused_component_bases_by_liveness() {
+        let plan = all_flow_plan_with_reused_component_base();
+        let index = PersistedCurrentIndexV1::new(&plan).unwrap();
+        assert_eq!(index.source_current(0, "test source").unwrap(), 0);
+        assert_eq!(
+            index.live_current(&plan, 0, 0, "test stage zero").unwrap(),
+            0
+        );
+        assert_eq!(
+            index.live_current(&plan, 1, 0, "test stage one").unwrap(),
+            1
+        );
+
+        let dispatch = all_flow_dispatch(&plan);
+        let family = build_family(&plan, &dispatch, 0).unwrap();
+        assert_eq!(family.unique_current_count, 2);
+        assert_eq!(family.unique_current_component_count, 3);
+    }
+
+    #[test]
+    fn selected_rows_rederive_init_without_dropping_certified_reuse() {
+        let mut groups = vec![
+            PersistedFamilyGroupDraftV1 {
+                stage: 1,
+                direct_executor_id: DIRECT_NONE_U32,
+                rows: PersistedFamilyRowsDraftV1::Contribution(vec![contribution(
+                    8,
+                    DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE,
+                )]),
+            },
+            PersistedFamilyGroupDraftV1 {
+                stage: 1,
+                direct_executor_id: 2,
+                rows: PersistedFamilyRowsDraftV1::Contribution(vec![
+                    contribution(8, DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION),
+                    contribution(12, 0),
+                ]),
+            },
+        ];
+        rederive_contribution_initialization(&mut groups);
+        let PersistedFamilyRowsDraftV1::Contribution(first) = &groups[0].rows else {
+            panic!("wrong row kind")
+        };
+        let PersistedFamilyRowsDraftV1::Contribution(second) = &groups[1].rows else {
+            panic!("wrong row kind")
+        };
+        assert_ne!(first[0].flags & DIRECT_CONTRIBUTION_FLAG_CERTIFIED_REUSE, 0);
+        assert_ne!(
+            first[0].flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            0
+        );
+        assert_eq!(
+            second[0].flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            0
+        );
+        assert_ne!(
+            second[1].flags & DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+            0
+        );
+    }
+
+    #[test]
+    fn point_major_batch_input_builds_asymmetric_momentum_planes() {
+        let layout = test_layout();
+        let mut workspace = PersistedHelicityWorkspaceV1::new(&layout, 2, false).unwrap();
+        // [p0: s0=(1,2), s1=(3,4)], [p1: s0=(10,20), s1=(30,40)]
+        workspace
+            .refresh_inputs(&layout, &[1.0, 2.0, 3.0, 4.0, 10.0, 20.0, 30.0, 40.0], 2)
+            .unwrap();
+        let stride = workspace.point_stride as usize;
+        let momenta = workspace.momenta.as_slice();
+        assert_eq!(&momenta[0..2], &[1.0, 10.0]);
+        assert_eq!(&momenta[stride..stride + 2], &[2.0, 20.0]);
+        assert_eq!(&momenta[2 * stride..2 * stride + 2], &[-3.0, -30.0]);
+        assert_eq!(&momenta[3 * stride..3 * stride + 2], &[-4.0, -40.0]);
+    }
+
+    #[test]
+    fn full_destination_clear_prevents_a_b_a_stale_outputs() {
+        let layout = test_layout();
+        let mut workspace = PersistedHelicityWorkspaceV1::new(&layout, 1, true).unwrap();
+        let input = [1.0, 2.0, 3.0, 4.0];
+
+        // H=A writes both destinations.
+        workspace.refresh_inputs(&layout, &input, 1).unwrap();
+        workspace.amplitude_re.as_mut_slice()[0] = 7.0;
+        workspace.amplitude_re.as_mut_slice()[1] = 11.0;
+
+        // H=B has no closure for destination 1; it must observe zero there.
+        workspace.refresh_inputs(&layout, &input, 1).unwrap();
+        workspace.amplitude_re.as_mut_slice()[0] = 13.0;
+        assert_eq!(workspace.amplitude_re.as_slice(), &[13.0, 0.0]);
+        assert_eq!(workspace.amplitude_im.as_slice(), &[0.0, 0.0]);
+
+        // Returning to A also starts from a completely clean dense C tile.
+        workspace.refresh_inputs(&layout, &input, 1).unwrap();
+        workspace.amplitude_re.as_mut_slice()[1] = 17.0;
+        assert_eq!(workspace.amplitude_re.as_slice(), &[0.0, 17.0]);
+    }
+
+    #[test]
+    fn unprofiled_execution_defers_diagnostic_counts_until_inspection() {
+        let plan = all_flow_plan();
+        let dispatch = all_flow_dispatch(&plan);
+        let resolver = ProbeResolver {
+            invalidations: Cell::new(0),
+            source_bindings: Cell::new(0),
+        };
+        let mut executor = PersistedHelicityFamilyExecutorV1::new(resolver);
+        executor.set_parameter_planes(&[4.0], &[-2.0]).unwrap();
+        assert!(!executor.prepare(&plan, &dispatch, 0, 4, 1).unwrap());
+
+        let input = [10.0, 20.0, 30.0, 40.0];
+        let tile = executor.execute_tile_unprofiled(&input, 1).unwrap();
+        assert_eq!(tile.destination_re(0).unwrap(), &[1.0]);
+        assert_eq!(
+            executor.family.as_ref().unwrap().last_execution_report,
+            Some(PersistedHelicityFamilyExecutionReportV1::default())
+        );
+
+        // Inspection reconstructs the exact logical census outside the warm
+        // execution path even though the unprofiled marker has no counters.
+        let census = executor.active_family_inspection_census().unwrap();
+        assert_eq!(census.union_source_executor_call_groups, 1);
+        assert_eq!(census.union_contribution_executor_call_groups, 1);
+        assert_eq!(census.union_finalization_executor_call_groups, 1);
+        assert_eq!(census.union_closure_executor_call_groups, 1);
+        assert_eq!(census.union_source_rows, 1);
+        assert_eq!(census.union_contribution_rows, 1);
+        assert_eq!(census.union_finalization_rows, 1);
+        assert_eq!(census.union_closure_rows, 1);
+
+        let (_, report) = executor.execute_tile_profiled(&input, 1).unwrap();
+        assert!(report.cache_hit);
+        assert_eq!(report.source_calls, 1);
+        assert_eq!(report.contribution_calls, 1);
+        assert_eq!(report.finalization_calls, 1);
+        assert_eq!(report.closure_calls, 1);
+        assert_eq!(
+            executor.family.as_ref().unwrap().last_execution_report,
+            Some(report)
+        );
+        assert_eq!(executor.resolver().source_bindings.get(), 1);
+    }
+
+    #[test]
+    fn persisted_executor_retains_one_h_and_keeps_warm_execution_borrowed() {
+        let plan = all_flow_plan();
+        let dispatch = all_flow_dispatch(&plan);
+        dispatch.validate_for_plan(&plan).unwrap();
+        let resolver = ProbeResolver {
+            invalidations: Cell::new(0),
+            source_bindings: Cell::new(0),
+        };
+        let mut executor = PersistedHelicityFamilyExecutorV1::new(resolver);
+
+        executor.set_parameter_planes(&[3.0], &[-2.0]).unwrap();
+        let parameter_pointer = executor.parameter_state.as_ptr();
+        let parameter_capacity = executor.parameter_state.capacity();
+        let parameter_version = executor.parameter_version;
+        executor.set_parameter_planes(&[3.0], &[-2.0]).unwrap();
+        assert_eq!(executor.parameter_state.as_ptr(), parameter_pointer);
+        assert_eq!(executor.parameter_state.capacity(), parameter_capacity);
+        assert_eq!(executor.parameter_version, parameter_version);
+        executor.set_parameter_planes(&[4.0], &[-2.0]).unwrap();
+        assert_ne!(executor.parameter_state.as_ptr(), parameter_pointer);
+        assert_eq!(executor.parameter_version, parameter_version + 1);
+
+        let input = [10.0, 20.0, 30.0, 40.0];
+        assert!(!executor.prepare(&plan, &dispatch, 0, 4, 1).unwrap());
+        assert_eq!(executor.resolver().source_bindings.get(), 1);
+        assert_eq!(
+            executor.cache_census(),
+            PersistedHelicityFamilyCacheCensusV1 {
+                resolved_helicity_count: 2,
+                retained_family_count: 1,
+                retained_row_count: 3,
+                active_resolved_helicity_id: Some(0),
+            }
+        );
+        let (tile, report) = executor.execute_tile_profiled(&input, 1).unwrap();
+        assert_eq!(tile.resolved_helicity_id(), 0);
+        assert_eq!(tile.destination_count(), 1);
+        assert_eq!(tile.point_count(), 1);
+        assert_eq!(tile.point_stride(), 1);
+        assert_eq!(tile.destination_re(0).unwrap(), &[1.0]);
+        assert_eq!(tile.destination_im(0).unwrap(), &[0.0]);
+        assert_eq!(
+            report,
+            PersistedHelicityFamilyExecutionReportV1 {
+                cache_hit: false,
+                source_calls: 1,
+                source_rows: 1,
+                contribution_calls: 1,
+                contribution_rows: 1,
+                finalization_calls: 1,
+                finalization_rows: 1,
+                closure_calls: 1,
+                closure_rows: 1,
+            }
+        );
+        let census = executor.active_family_inspection_census().unwrap();
+        assert_eq!(census.query_count, 1);
+        assert!(census.union_unique_current_count > 0);
+        assert!(census.union_unique_current_count <= census.union_unique_current_component_count);
+        assert_eq!(census.union_source_rows, 1);
+        assert_eq!(census.union_contribution_rows, 1);
+        assert_eq!(census.union_finalization_rows, 1);
+        assert_eq!(census.union_closure_rows, 1);
+        assert_eq!(census.union_amplitude_destination_count, 1);
+        assert_eq!(census.union_source_executor_call_groups, 1);
+        assert_eq!(census.union_contribution_executor_call_groups, 1);
+        assert_eq!(census.union_finalization_executor_call_groups, 1);
+        assert_eq!(census.union_closure_executor_call_groups, 1);
+        assert_eq!(census.semantic_executor_binding_count, 4);
+
+        assert!(executor.prepare(&plan, &dispatch, 0, 4, 1).unwrap());
+        assert_eq!(executor.resolver().source_bindings.get(), 1);
+        let (tile, report) = executor.execute_tile_profiled(&input, 1).unwrap();
+        assert!(report.cache_hit);
+        assert_eq!(tile.destination_re(0).unwrap(), &[1.0]);
+
+        // H=1 has exact source dispatch but no live non-source rows. Replacing
+        // H=0 still retains one family and leaves the dense destination zero.
+        assert!(!executor.prepare(&plan, &dispatch, 1, 4, 1).unwrap());
+        assert_eq!(executor.resolver().source_bindings.get(), 2);
+        assert_eq!(
+            executor.cache_census(),
+            PersistedHelicityFamilyCacheCensusV1 {
+                resolved_helicity_count: 2,
+                retained_family_count: 1,
+                retained_row_count: 0,
+                active_resolved_helicity_id: Some(1),
+            }
+        );
+        let tile = executor.execute_tile_unprofiled(&input, 1).unwrap();
+        assert_eq!(tile.destination_re(0).unwrap(), &[0.0]);
+        assert_eq!(tile.destination_im(0).unwrap(), &[0.0]);
+        let census = executor.active_family_inspection_census().unwrap();
+        assert_eq!(census.union_source_rows, 1);
+        assert_eq!(census.union_contribution_rows, 0);
+        assert_eq!(census.union_finalization_rows, 0);
+        assert_eq!(census.union_closure_rows, 0);
+        assert_eq!(census.semantic_executor_binding_count, 1);
+
+        // A -> B -> A is a cold switch, but never multiplies retained arenas.
+        assert!(!executor.prepare(&plan, &dispatch, 0, 4, 1).unwrap());
+        assert_eq!(executor.resolver().source_bindings.get(), 3);
+        assert_eq!(executor.cache_census().retained_family_count, 1);
+        let tile = executor.execute_tile_unprofiled(&input, 1).unwrap();
+        assert_eq!(tile.destination_re(0).unwrap(), &[1.0]);
+        assert!(executor.resolver().invalidations.get() >= 2);
+
+        executor.clear_families().unwrap();
+        assert_eq!(
+            executor.cache_census(),
+            PersistedHelicityFamilyCacheCensusV1::default()
+        );
+        assert!(executor.active_family_inspection_census().is_none());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/probe_guard.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/probe_guard.rs
new file mode 100644
index 0000000000..e14c466acc
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/probe_guard.rs
@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: 0BSD
+
+#![allow(dead_code)] // Poison hooks are exercised only by the opt-in probe harness.
+
+//! Feature-only poison guard for the genuine on-the-fly artifact probe.
+
+use super::*;
+use std::cell::RefCell;
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct OnTheFlyForbiddenWorkCountsV1 {
+    pub(crate) direct_plan_load_attempts: u32,
+    pub(crate) direct_plan_decode_attempts: u32,
+    pub(crate) direct_plan_materialization_attempts: u32,
+    pub(crate) established_builder_attempts: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum OnTheFlyForbiddenWorkV1 {
+    DirectPlanLoad,
+    DirectPlanDecode,
+    DirectPlanMaterialization,
+    EstablishedBuilder,
+}
+
+thread_local! {
+    static ACTIVE_PROBE: RefCell<Option<OnTheFlyForbiddenWorkCountsV1>> = const {
+        RefCell::new(None)
+    };
+}
+
+pub(crate) struct OnTheFlyForbiddenWorkGuardV1 {
+    active: bool,
+}
+
+impl OnTheFlyForbiddenWorkGuardV1 {
+    pub(crate) fn begin() -> RusticolResult<Self> {
+        ACTIVE_PROBE.with(|slot| {
+            let mut slot = slot.borrow_mut();
+            if slot.is_some() {
+                return Err(invalid("a forbidden-work probe is already active"));
+            }
+            *slot = Some(OnTheFlyForbiddenWorkCountsV1::default());
+            Ok(Self { active: true })
+        })
+    }
+
+    pub(crate) fn finish(mut self) -> RusticolResult<OnTheFlyForbiddenWorkCountsV1> {
+        self.active = false;
+        ACTIVE_PROBE.with(|slot| {
+            slot.borrow_mut()
+                .take()
+                .ok_or_else(|| integrity("forbidden-work probe state disappeared"))
+        })
+    }
+}
+
+impl Drop for OnTheFlyForbiddenWorkGuardV1 {
+    fn drop(&mut self) {
+        if self.active {
+            ACTIVE_PROBE.with(|slot| {
+                slot.borrow_mut().take();
+            });
+        }
+    }
+}
+
+pub(crate) fn reject_forbidden_work_if_probed(kind: OnTheFlyForbiddenWorkV1) -> RusticolResult<()> {
+    ACTIVE_PROBE.with(|slot| {
+        let mut slot = slot.borrow_mut();
+        let Some(counts) = slot.as_mut() else {
+            return Ok(());
+        };
+        let (counter, label) = match kind {
+            OnTheFlyForbiddenWorkV1::DirectPlanLoad => (
+                &mut counts.direct_plan_load_attempts,
+                "DirectRecurrencePlan loading",
+            ),
+            OnTheFlyForbiddenWorkV1::DirectPlanDecode => (
+                &mut counts.direct_plan_decode_attempts,
+                "DirectRecurrencePlan deserialization",
+            ),
+            OnTheFlyForbiddenWorkV1::DirectPlanMaterialization => (
+                &mut counts.direct_plan_materialization_attempts,
+                "DirectRecurrencePlan materialization",
+            ),
+            OnTheFlyForbiddenWorkV1::EstablishedBuilder => (
+                &mut counts.established_builder_attempts,
+                "established global recurrence construction",
+            ),
+        };
+        *counter = counter
+            .checked_add(1)
+            .ok_or_else(|| integrity("forbidden-work attempt counter overflowed"))?;
+        Err(invalid(format!(
+            "{label} is poisoned inside the genuine on-the-fly artifact probe"
+        )))
+    })
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/projection.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/projection.rs
new file mode 100644
index 0000000000..0b7392e79e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/projection.rs
@@ -0,0 +1,604 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Query-local counterpart of the established topology-replay color projection.
+//!
+//! The compact builder may discover multiple dynamic-color witnesses for one
+//! color-erased current.  They are aliases only when their selected-query
+//! contribution and closure domains form the same complete rectangular proof
+//! used by the materialized builder.  This pass proves that condition before
+//! retaining one representative; otherwise it leaves the trace unprojected.
+
+use super::*;
+use crate::recurrence::DynamicLCColorStateId;
+use crate::recurrence::construct::current_key_with_dynamic_color;
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ProjectedCurrentIdentity {
+    color_erased_key: CurrentCoreKey,
+    source_builder_id: Option<u32>,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ProjectedContributionIdentity {
+    destination_projection_id: u32,
+    transition_template_id: u32,
+    parent_projection_ids: [u32; 2],
+    parent_state_template_ids: Box<[u32]>,
+    parent_momenta: Box<[CanonicalMomentumLinearForm]>,
+    result_state_template_id: u32,
+    quantum_flow_witness_id: u32,
+    runtime_coupling_binding_digest: SemanticDigest,
+    output_projection_id: u32,
+    exact_factor: ExactComplexRational,
+}
+
+#[derive(Clone, Debug)]
+struct ProjectedContribution {
+    identity: ProjectedContributionIdentity,
+    representative_key: ContributionKey,
+    destination_builder_ids: BTreeSet<u32>,
+    builder_parent_tuples: BTreeSet<[u32; 2]>,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ProjectedClosureIdentity {
+    closure_template_id: u32,
+    quantum_flow_template_id: Option<u32>,
+    parent_projection_ids: [u32; 2],
+    exact_factor: ExactComplexRational,
+    component_coefficients: Box<[ExactComplexRational]>,
+}
+
+#[derive(Debug)]
+struct ProjectedClosure {
+    identity: ProjectedClosureIdentity,
+    representative_order: ProjectedClosureRepresentativeOrder,
+    representative_key: PendingClosureKey,
+    builder_parent_tuples: BTreeSet<[u32; 2]>,
+    pairing_lineages: Vec<PendingPairingLineage>,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct ProjectedClosureRepresentativeOrder {
+    closure_template_id: u32,
+    quantum_flow_template_id: Option<u32>,
+    parent_keys: Box<[CurrentCoreKey]>,
+    color_witness_term_id: LCColorWitnessTermId,
+}
+
+fn closure_representative_order(
+    pending: &[PendingCurrent],
+    closure: &PendingClosure,
+) -> RusticolResult<ProjectedClosureRepresentativeOrder> {
+    let parent_keys = closure
+        .key
+        .parent_current_ids
+        .iter()
+        .map(|id| {
+            pending
+                .get(*id as usize)
+                .map(|current| current.key.clone())
+                .ok_or_else(|| integrity("projected closure representative parent is absent"))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?
+        .into_boxed_slice();
+    Ok(ProjectedClosureRepresentativeOrder {
+        closure_template_id: closure.key.closure_template_id,
+        quantum_flow_template_id: closure.key.quantum_flow_template_id,
+        parent_keys,
+        color_witness_term_id: closure.key.color_witness_term_id,
+    })
+}
+
+pub(super) struct QueryLocalColorProjection {
+    pub(super) currents: Vec<PendingCurrent>,
+    pub(super) closures: Vec<PendingClosure>,
+}
+
+fn parent_rectangle_is_complete(
+    parent_projection_ids: [u32; 2],
+    builder_parent_tuples: &BTreeSet<[u32; 2]>,
+    old_to_projection: &BTreeMap<u32, u32>,
+    projection_members: &[Vec<u32>],
+) -> RusticolResult<bool> {
+    let expected = parent_projection_ids
+        .iter()
+        .try_fold(1usize, |count, projection_id| {
+            count
+                .checked_mul(
+                    projection_members
+                        .get(*projection_id as usize)
+                        .ok_or_else(|| integrity("projected parent class is absent"))?
+                        .len(),
+                )
+                .ok_or_else(|| invalid("projected parent-product count exceeds usize"))
+        })?;
+    if expected != builder_parent_tuples.len() {
+        return Ok(false);
+    }
+    Ok(builder_parent_tuples.iter().all(|tuple| {
+        tuple
+            .iter()
+            .zip(parent_projection_ids.iter())
+            .all(|(builder_id, projection_id)| {
+                old_to_projection.get(builder_id) == Some(projection_id)
+            })
+    }))
+}
+
+fn contribution_identity(
+    destination_projection_id: u32,
+    key: &PendingContributionKey,
+    factor: ExactComplexRational,
+    old_to_projection: &BTreeMap<u32, u32>,
+) -> RusticolResult<ProjectedContributionIdentity> {
+    let parent_projection_ids = key
+        .parent_current_ids
+        .map(|id| {
+            old_to_projection
+                .get(&id)
+                .copied()
+                .ok_or_else(|| integrity("projected contribution has a dead parent"))
+        })
+        .into_iter()
+        .collect::<RusticolResult<Vec<_>>>()?
+        .try_into()
+        .map_err(|_| integrity("projected contribution is not binary"))?;
+    Ok(ProjectedContributionIdentity {
+        destination_projection_id,
+        transition_template_id: key.key.transition_template_id(),
+        parent_projection_ids,
+        parent_state_template_ids: key.key.parent_state_template_ids().into(),
+        parent_momenta: key.key.parent_momenta().into(),
+        result_state_template_id: key.key.result_state_template_id(),
+        quantum_flow_witness_id: key.key.quantum_flow_witness_id(),
+        runtime_coupling_binding_digest: key.key.runtime_coupling_binding_digest(),
+        output_projection_id: key.key.output_projection_id(),
+        exact_factor: factor,
+    })
+}
+
+pub(super) fn project_query_local_color_aliases(
+    pending: &[PendingCurrent],
+    pending_closures: &[PendingClosure],
+    live: &BTreeSet<u32>,
+) -> RusticolResult<Option<QueryLocalColorProjection>> {
+    let canonical_color_id = DynamicLCColorStateId::from_interner(0);
+    let mut identity_to_projection = BTreeMap::<ProjectedCurrentIdentity, u32>::new();
+    let mut old_to_projection = BTreeMap::<u32, u32>::new();
+    let mut projection_members = Vec::<Vec<u32>>::new();
+    for old_id in live.iter().copied() {
+        let current = pending
+            .get(old_id as usize)
+            .ok_or_else(|| integrity("live query-local current is absent"))?;
+        let identity = ProjectedCurrentIdentity {
+            color_erased_key: current_key_with_dynamic_color(&current.key, canonical_color_id)?,
+            source_builder_id: (current.key.node_kind() == RecurrenceNodeKind::Source)
+                .then_some(old_id),
+        };
+        let projection_id = if let Some(id) = identity_to_projection.get(&identity).copied() {
+            id
+        } else {
+            let id = checked_u32(projection_members.len(), "query-local projection class")?;
+            projection_members.push(Vec::new());
+            identity_to_projection.insert(identity, id);
+            id
+        };
+        projection_members[projection_id as usize].push(old_id);
+        old_to_projection.insert(old_id, projection_id);
+    }
+    if projection_members.iter().all(|members| members.len() == 1) {
+        return Ok(None);
+    }
+
+    let mut contributions = BTreeMap::<ProjectedContributionIdentity, ProjectedContribution>::new();
+    for (old_id, projection_id) in &old_to_projection {
+        for (key, factor) in &pending[*old_id as usize].contributions {
+            if factor.is_zero() {
+                continue;
+            }
+            let identity = contribution_identity(*projection_id, key, *factor, &old_to_projection)?;
+            match contributions.entry(identity.clone()) {
+                std::collections::btree_map::Entry::Vacant(entry) => {
+                    entry.insert(ProjectedContribution {
+                        identity,
+                        representative_key: key.key.clone(),
+                        destination_builder_ids: BTreeSet::from([*old_id]),
+                        builder_parent_tuples: BTreeSet::from([key.parent_current_ids]),
+                    });
+                }
+                std::collections::btree_map::Entry::Occupied(mut entry) => {
+                    let row = entry.get_mut();
+                    row.destination_builder_ids.insert(*old_id);
+                    if !row.builder_parent_tuples.insert(key.parent_current_ids) {
+                        return Ok(None);
+                    }
+                }
+            }
+        }
+    }
+    for row in contributions.values() {
+        let destination_members = projection_members
+            .get(row.identity.destination_projection_id as usize)
+            .ok_or_else(|| integrity("projected contribution destination class is absent"))?;
+        if row.destination_builder_ids.len() != destination_members.len()
+            || !destination_members
+                .iter()
+                .all(|builder_id| row.destination_builder_ids.contains(builder_id))
+        {
+            return Ok(None);
+        }
+        if !parent_rectangle_is_complete(
+            row.identity.parent_projection_ids,
+            &row.builder_parent_tuples,
+            &old_to_projection,
+            &projection_members,
+        )? {
+            return Ok(None);
+        }
+    }
+
+    let mut closures = BTreeMap::<ProjectedClosureIdentity, ProjectedClosure>::new();
+    for closure in pending_closures {
+        let parent_projection_ids = closure
+            .key
+            .parent_current_ids
+            .map(|id| {
+                old_to_projection
+                    .get(&id)
+                    .copied()
+                    .ok_or_else(|| integrity("projected closure has a dead parent"))
+            })
+            .into_iter()
+            .collect::<RusticolResult<Vec<_>>>()?
+            .try_into()
+            .map_err(|_| integrity("projected closure is not binary"))?;
+        let identity = ProjectedClosureIdentity {
+            closure_template_id: closure.key.closure_template_id,
+            quantum_flow_template_id: closure.key.quantum_flow_template_id,
+            parent_projection_ids,
+            exact_factor: closure.factor,
+            component_coefficients: closure.component_coefficients.clone(),
+        };
+        let representative_order = closure_representative_order(pending, closure)?;
+        match closures.entry(identity.clone()) {
+            std::collections::btree_map::Entry::Vacant(entry) => {
+                entry.insert(ProjectedClosure {
+                    identity,
+                    representative_order,
+                    representative_key: closure.key.clone(),
+                    builder_parent_tuples: BTreeSet::from([closure.key.parent_current_ids]),
+                    pairing_lineages: try_clone_pairing_lineages(&closure.pairing_lineages)?,
+                });
+            }
+            std::collections::btree_map::Entry::Occupied(mut entry) => {
+                if !entry
+                    .get_mut()
+                    .builder_parent_tuples
+                    .insert(closure.key.parent_current_ids)
+                {
+                    return Ok(None);
+                }
+                // Pairing lineage is proof owned by the canonical root-bearing
+                // representative, not an additive property of color aliases.
+                // Keep the same semantic/current ordering regardless of input
+                // enumeration and never union a later alias's Wick lineage.
+                if representative_order < entry.get().representative_order {
+                    let projected = entry.get_mut();
+                    projected.representative_order = representative_order;
+                    projected.representative_key = closure.key.clone();
+                    projected.pairing_lineages =
+                        try_clone_pairing_lineages(&closure.pairing_lineages)?;
+                }
+            }
+        }
+    }
+    for row in closures.values() {
+        if !parent_rectangle_is_complete(
+            row.identity.parent_projection_ids,
+            &row.builder_parent_tuples,
+            &old_to_projection,
+            &projection_members,
+        )? {
+            return Ok(None);
+        }
+    }
+
+    let mut projected_currents = Vec::with_capacity(projection_members.len());
+    for (projection_index, members) in projection_members.iter().enumerate() {
+        let projection_id = checked_u32(projection_index, "projected query-local current ID")?;
+        let representative_id = *members
+            .first()
+            .ok_or_else(|| integrity("query-local projection class is empty"))?;
+        let representative = &pending[representative_id as usize];
+        let mut projected = PendingCurrent {
+            key: representative.key.clone(),
+            source_factor: representative.source_factor,
+            contributions: BTreeMap::new(),
+            pairing_lineages: Vec::new(),
+            stage: representative.stage,
+            reflection: crate::recurrence::construct::CurrentReflection::Unavailable,
+            reflection_certificate: None,
+        };
+        for member in members {
+            extend_pairing_lineages(
+                &mut projected.pairing_lineages,
+                &pending[*member as usize].pairing_lineages,
+            )?;
+        }
+        for row in contributions
+            .values()
+            .filter(|row| row.identity.destination_projection_id == projection_id)
+        {
+            if !row
+                .destination_builder_ids
+                .iter()
+                .all(|builder_id| old_to_projection.get(builder_id) == Some(&projection_id))
+            {
+                return Err(integrity(
+                    "projected contribution destinations cross projection classes",
+                ));
+            }
+            let identity = &row.identity;
+            let key = ContributionKey::new(
+                identity.transition_template_id,
+                identity.parent_projection_ids.to_vec(),
+                identity.parent_state_template_ids.to_vec(),
+                identity.parent_momenta.to_vec(),
+                identity.result_state_template_id,
+                identity.quantum_flow_witness_id,
+                row.representative_key.color_witness_term_id(),
+                identity.runtime_coupling_binding_digest,
+                identity.output_projection_id,
+            )?;
+            projected.contributions.insert(
+                PendingContributionKey {
+                    parent_current_ids: identity.parent_projection_ids,
+                    key,
+                },
+                identity.exact_factor,
+            );
+        }
+        projected_currents.push(projected);
+    }
+
+    let projected_closures = closures
+        .into_values()
+        .map(|row| {
+            Ok(PendingClosure {
+                key: PendingClosureKey {
+                    closure_template_id: row.identity.closure_template_id,
+                    quantum_flow_template_id: row.identity.quantum_flow_template_id,
+                    parent_current_ids: row.identity.parent_projection_ids,
+                    color_witness_term_id: row.representative_key.color_witness_term_id,
+                },
+                factor: row.identity.exact_factor,
+                component_coefficients: row.identity.component_coefficients,
+                pairing_lineages: row.pairing_lineages,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    Ok(Some(QueryLocalColorProjection {
+        currents: projected_currents,
+        closures: projected_closures,
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    fn current(state: u32, color: u32, support: u32) -> PendingCurrent {
+        PendingCurrent {
+            key: CurrentCoreKey::new(
+                digest(1),
+                RecurrenceNodeKind::Current,
+                state,
+                DynamicLCColorStateId::from_interner(color),
+                vec![support],
+                CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                    source_slot: support,
+                    coefficient: 1,
+                }])
+                .unwrap(),
+                CurrentHelicityIdentity::topology_replay(
+                    0,
+                    vec![SourceStateAssignment::new(support, 0)],
+                )
+                .unwrap(),
+                vec![state as i32],
+                0,
+                vec![0],
+                CurrentSourceBinding::None,
+                None,
+            )
+            .unwrap(),
+            source_factor: None,
+            contributions: BTreeMap::new(),
+            pairing_lineages: vec![PendingPairingLineage {
+                completed_pairs: Vec::new(),
+                unmatched_endpoint: None,
+            }],
+            stage: 0,
+            reflection: crate::recurrence::construct::CurrentReflection::Unavailable,
+            reflection_certificate: None,
+        }
+    }
+
+    fn closure(alias_parent: u32) -> PendingClosure {
+        closure_with_lineage(alias_parent, Vec::new())
+    }
+
+    fn closure_with_lineage(alias_parent: u32, completed_pairs: Vec<[u32; 2]>) -> PendingClosure {
+        PendingClosure {
+            key: PendingClosureKey {
+                closure_template_id: 7,
+                quantum_flow_template_id: None,
+                parent_current_ids: [0, alias_parent],
+                color_witness_term_id: LCColorWitnessTermId::new(9, 0),
+            },
+            factor: ExactComplexRational::ONE,
+            component_coefficients: vec![ExactComplexRational::ONE].into_boxed_slice(),
+            pairing_lineages: vec![PendingPairingLineage {
+                completed_pairs,
+                unmatched_endpoint: None,
+            }],
+        }
+    }
+
+    fn add_contribution(
+        pending: &mut [PendingCurrent],
+        destination: u32,
+        parents: [u32; 2],
+        witness_ordinal: u32,
+        factor: ExactComplexRational,
+    ) {
+        let destination_key = &pending[destination as usize].key;
+        let parent_keys = parents.map(|id| &pending[id as usize].key);
+        let key = ContributionKey::new(
+            11,
+            parents.to_vec(),
+            parent_keys
+                .iter()
+                .map(|key| key.current_state_template_id())
+                .collect(),
+            parent_keys
+                .iter()
+                .map(|key| key.momentum().clone())
+                .collect(),
+            destination_key.current_state_template_id(),
+            3,
+            LCColorWitnessTermId::new(5, witness_ordinal),
+            digest(7),
+            13,
+        )
+        .unwrap();
+        assert!(
+            pending[destination as usize]
+                .contributions
+                .insert(
+                    PendingContributionKey {
+                        parent_current_ids: parents,
+                        key,
+                    },
+                    factor,
+                )
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn query_local_projection_requires_a_complete_parent_rectangle() {
+        let pending = vec![current(1, 0, 0), current(2, 1, 1), current(2, 2, 1)];
+        let live = BTreeSet::from([0, 1, 2]);
+        assert!(
+            project_query_local_color_aliases(&pending, &[closure(1)], &live)
+                .unwrap()
+                .is_none(),
+            "one of two alias parents is not a complete rectangular proof",
+        );
+
+        let projected =
+            project_query_local_color_aliases(&pending, &[closure(1), closure(2)], &live)
+                .unwrap()
+                .expect("complete alias rectangle projects");
+        assert_eq!(projected.currents.len(), 2);
+        assert_eq!(projected.closures.len(), 1);
+        assert_eq!(projected.closures[0].key.parent_current_ids, [0, 1]);
+    }
+
+    #[test]
+    fn query_local_projection_requires_each_contribution_on_every_destination_alias() {
+        let mut pending = vec![current(1, 0, 0), current(2, 1, 1), current(2, 2, 1)];
+        add_contribution(&mut pending, 1, [0, 0], 0, ExactComplexRational::ONE);
+        add_contribution(
+            &mut pending,
+            2,
+            [0, 0],
+            1,
+            ExactComplexRational::ONE.checked_neg().unwrap(),
+        );
+        let live = BTreeSet::from([0, 1, 2]);
+
+        assert!(
+            project_query_local_color_aliases(&pending, &[], &live)
+                .unwrap()
+                .is_none(),
+            "reciprocal destination aliases with distinct exact fan-ins are not one equation",
+        );
+    }
+
+    #[test]
+    fn query_local_projection_retains_a_complete_destination_and_parent_domain() {
+        let mut pending = vec![
+            current(1, 0, 0),
+            current(2, 1, 1),
+            current(2, 2, 1),
+            current(3, 3, 2),
+            current(3, 4, 2),
+        ];
+        add_contribution(&mut pending, 3, [0, 1], 0, ExactComplexRational::ONE);
+        add_contribution(&mut pending, 4, [0, 2], 1, ExactComplexRational::ONE);
+        let live = BTreeSet::from([0, 1, 2, 3, 4]);
+
+        let projected = project_query_local_color_aliases(&pending, &[], &live)
+            .unwrap()
+            .expect("complete destination and parent domains project");
+        assert_eq!(projected.currents.len(), 3);
+        assert_eq!(projected.currents[2].contributions.len(), 1);
+    }
+
+    #[test]
+    fn query_local_projection_ignores_poison_outside_the_selected_live_set() {
+        let base = vec![current(1, 0, 0), current(2, 1, 1), current(2, 2, 1)];
+        let live = BTreeSet::from([0, 1, 2]);
+        let expected = project_query_local_color_aliases(&base, &[closure(1), closure(2)], &live)
+            .unwrap()
+            .unwrap();
+        let mut poisoned = base;
+        poisoned.push(current(99, u32::MAX, 99));
+        let observed =
+            project_query_local_color_aliases(&poisoned, &[closure(1), closure(2)], &live)
+                .unwrap()
+                .unwrap();
+        assert_eq!(observed.currents.len(), expected.currents.len());
+        assert_eq!(observed.closures.len(), expected.closures.len());
+        assert!(
+            observed
+                .currents
+                .iter()
+                .all(|row| row.key.current_state_template_id() != 99)
+        );
+    }
+
+    #[test]
+    fn projected_pairing_owner_uses_semantic_representative_not_input_order() {
+        let pending = vec![current(1, 0, 0), current(2, 2, 1), current(2, 1, 1)];
+        let live = BTreeSet::from([0, 1, 2]);
+        for closures in [
+            vec![
+                closure_with_lineage(1, vec![[0, 5]]),
+                closure_with_lineage(2, vec![[0, 3]]),
+            ],
+            vec![
+                closure_with_lineage(2, vec![[0, 3]]),
+                closure_with_lineage(1, vec![[0, 5]]),
+            ],
+        ] {
+            let projected = project_query_local_color_aliases(&pending, &closures, &live)
+                .unwrap()
+                .expect("complete alias rectangle projects");
+            assert_eq!(
+                projected.closures[0].pairing_lineages,
+                vec![PendingPairingLineage {
+                    completed_pairs: vec![[0, 3]],
+                    unmatched_endpoint: None,
+                }]
+            );
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/public_query.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/public_query.rs
new file mode 100644
index 0000000000..c33a6fca4c
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/public_query.rs
@@ -0,0 +1,955 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::source_seed::validate_permutation;
+use super::*;
+
+/// One selected source state in a decoded query.  Source slots are always in
+/// construction order after applying the seed's authenticated gather map.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(crate) struct OnTheFlySelectedSourceV1 {
+    pub(crate) source_slot: u32,
+    pub(crate) state_index: u32,
+    pub(crate) public_helicity: i32,
+}
+
+/// One already-decoded public LC selector.  Slots use public external order;
+/// [`DecodedLcQueryV1::new`] authenticates and maps them to construction order.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum OnTheFlyLcSelectorV1 {
+    Singlet,
+    SingleTrace { public_word: Box<[u32]> },
+    OpenLines { public_blocks: Box<[Box<[u32]>]> },
+}
+
+impl OnTheFlyLcSelectorV1 {
+    pub(crate) fn single_trace(public_word: Vec<u32>) -> Self {
+        Self::SingleTrace {
+            public_word: public_word.into_boxed_slice(),
+        }
+    }
+
+    pub(crate) fn open_lines(public_blocks: Vec<Vec<u32>>) -> Self {
+        Self::OpenLines {
+            public_blocks: public_blocks
+                .into_iter()
+                .map(Vec::into_boxed_slice)
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+        }
+    }
+}
+
+/// One exact physical LC selector.  It contains only the selected structural
+/// values; selector identity is their digest and never a process-wide flow ID.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct DecodedLcQueryV1 {
+    pub(super) seed_digest: SemanticDigest,
+    pub(super) external_permutation: Box<[u32]>,
+    pub(super) selected_sources: Box<[OnTheFlySelectedSourceV1]>,
+    pub(super) target_components: Box<[LCColorComponent]>,
+    pub(super) closure_anchor_slot: u32,
+    pub(super) selector_digest: SemanticDigest,
+    pub(super) semantic_digest: SemanticDigest,
+}
+
+impl DecodedLcQueryV1 {
+    pub(crate) fn new(
+        seed: &OnTheFlyProcessSeedV1,
+        external_permutation: Vec<u32>,
+        public_helicities: &[i32],
+        selector: OnTheFlyLcSelectorV1,
+    ) -> RusticolResult<Self> {
+        if external_permutation.as_slice() != seed.external_permutation.as_ref() {
+            return Err(integrity(
+                "query external permutation differs from its compact seed",
+            ));
+        }
+        validate_permutation(
+            &external_permutation,
+            seed.source_anchors.len(),
+            "query external permutation",
+        )?;
+        if public_helicities.len() != seed.source_anchors.len() {
+            return Err(invalid(
+                "public-helicity selector does not cover every external slot exactly once",
+            ));
+        }
+        let inverse_permutation = inverse_permutation(&external_permutation)?;
+        let selected_sources = selected_sources(seed, public_helicities)?;
+        let decoded = decode_selector(seed, &inverse_permutation, selector)?;
+        let seed_digest = seed.semantic_digest();
+        let mut query = Self {
+            seed_digest,
+            external_permutation: external_permutation.into_boxed_slice(),
+            selected_sources: selected_sources.into_boxed_slice(),
+            target_components: decoded.target_components.into_boxed_slice(),
+            closure_anchor_slot: decoded.closure_anchor_slot,
+            selector_digest: decoded.selector_digest,
+            semantic_digest: SemanticDigest::new([1; 32])?,
+        };
+        query.semantic_digest = query.compute_digest()?;
+        Ok(query)
+    }
+
+    fn compute_digest(&self) -> RusticolResult<SemanticDigest> {
+        let mut hash = Sha256::new();
+        hash.update(b"pyamplicol-on-the-fly-decoded-lc-query-v2\0");
+        hash_digest(&mut hash, self.seed_digest);
+        hash_digest(&mut hash, self.selector_digest);
+        hash_len(
+            &mut hash,
+            self.external_permutation.len(),
+            "query external permutation",
+        )?;
+        for source_slot in &self.external_permutation {
+            hash.update(source_slot.to_le_bytes());
+        }
+        hash.update(self.closure_anchor_slot.to_le_bytes());
+        hash_len(&mut hash, self.selected_sources.len(), "selected sources")?;
+        for selected in &self.selected_sources {
+            hash.update(selected.source_slot.to_le_bytes());
+            hash.update(selected.state_index.to_le_bytes());
+            hash.update(selected.public_helicity.to_le_bytes());
+        }
+        hash_len(&mut hash, self.target_components.len(), "target components")?;
+        for component in &self.target_components {
+            hash.update([component.kind() as u8]);
+            hash_len(&mut hash, component.source_slots().len(), "component word")?;
+            for slot in component.source_slots() {
+                hash.update(slot.to_le_bytes());
+            }
+        }
+        final_digest(hash)
+    }
+
+    pub(crate) const fn semantic_digest(&self) -> SemanticDigest {
+        self.semantic_digest
+    }
+
+    pub(crate) const fn process_seed_digest(&self) -> SemanticDigest {
+        self.seed_digest
+    }
+
+    fn with_closure_anchor_slot(mut self, closure_anchor_slot: u32) -> RusticolResult<Self> {
+        if !self
+            .selected_sources
+            .iter()
+            .any(|source| source.source_slot == closure_anchor_slot)
+        {
+            return Err(integrity(
+                "certified query closure anchor is outside its selected source domain",
+            ));
+        }
+        if self.closure_anchor_slot != closure_anchor_slot {
+            self.closure_anchor_slot = closure_anchor_slot;
+            self.semantic_digest = self.compute_digest()?;
+        }
+        Ok(self)
+    }
+}
+
+/// Authenticated private choice of closure ancestry for one prepared process.
+///
+/// The ordinary selector endpoint remains authoritative for every ineligible
+/// generic, open-line, singlet, or heterogeneous shape.  Residual/cross is a
+/// downstream color-metric classification, so eligible pure-adjoint trace
+/// groups use the cyclic minimum regardless of that grouping.  A prepared
+/// grammar enables it only after proving the same homogeneous adjoint state
+/// and direct binary closure contract used by recurrence v4 sectors.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) struct OnTheFlyClosureAnchorPolicyV1 {
+    cyclic_trace_minimum_source_slot: Option<u32>,
+}
+
+impl OnTheFlyClosureAnchorPolicyV1 {
+    pub(super) const fn selector_endpoint() -> Self {
+        Self {
+            cyclic_trace_minimum_source_slot: None,
+        }
+    }
+
+    pub(super) const fn certified_cyclic_minimum(source_slot: u32) -> Self {
+        Self {
+            cyclic_trace_minimum_source_slot: Some(source_slot),
+        }
+    }
+
+    pub(super) fn closure_anchor_for_components(
+        self,
+        seed: &OnTheFlyProcessSeedV1,
+        components: &[LCColorComponent],
+    ) -> Option<u32> {
+        let selector_endpoint = physical_lc_selector_closure_anchor(seed, components)?;
+        let Some(minimum) = self.cyclic_trace_minimum_source_slot else {
+            return Some(selector_endpoint);
+        };
+        let [component] = components else {
+            return Some(selector_endpoint);
+        };
+        if component.kind() != LCColorComponentKind::Trace
+            || component.source_slots().len() != seed.source_anchors.len()
+            || seed
+                .source_anchors
+                .iter()
+                .any(|anchor| anchor.color_role != OnTheFlyExternalColorRoleV1::Adjoint)
+            || component.source_slots().iter().copied().min() != Some(minimum)
+        {
+            return Some(selector_endpoint);
+        }
+        Some(minimum)
+    }
+
+    pub(super) fn canonicalize_query(
+        self,
+        seed: &OnTheFlyProcessSeedV1,
+        query: DecodedLcQueryV1,
+    ) -> RusticolResult<DecodedLcQueryV1> {
+        let closure_anchor_slot = self
+            .closure_anchor_for_components(seed, &query.target_components)
+            .ok_or_else(|| integrity("decoded query lost its physical selector shape"))?;
+        query.with_closure_anchor_slot(closure_anchor_slot)
+    }
+
+    pub(super) fn authenticate_canonical_query(
+        self,
+        seed: &OnTheFlyProcessSeedV1,
+        query: &DecodedLcQueryV1,
+    ) -> RusticolResult<()> {
+        if &self.canonicalize_query(seed, query.clone())? != query {
+            return Err(integrity(
+                "decoded query was not canonicalized at its prepared-grammar boundary",
+            ));
+        }
+        Ok(())
+    }
+
+    pub(super) fn certifies_cyclic_trace_reflection(
+        self,
+        seed: &OnTheFlyProcessSeedV1,
+        query: &DecodedLcQueryV1,
+    ) -> bool {
+        let Some(minimum) = self.cyclic_trace_minimum_source_slot else {
+            return false;
+        };
+        let [component] = query.target_components.as_ref() else {
+            return false;
+        };
+        query.seed_digest == seed.semantic_digest()
+            && query.closure_anchor_slot == minimum
+            && component.kind() == LCColorComponentKind::Trace
+            && component.source_slots().len() == seed.source_anchors.len()
+            && component.source_slots().iter().copied().min() == Some(minimum)
+            && seed
+                .source_anchors
+                .iter()
+                .all(|anchor| anchor.color_role == OnTheFlyExternalColorRoleV1::Adjoint)
+            && self.closure_anchor_for_components(seed, &query.target_components) == Some(minimum)
+    }
+}
+
+struct DecodedSelector {
+    target_components: Vec<LCColorComponent>,
+    closure_anchor_slot: u32,
+    selector_digest: SemanticDigest,
+}
+
+fn selected_sources(
+    seed: &OnTheFlyProcessSeedV1,
+    public_helicities: &[i32],
+) -> RusticolResult<Vec<OnTheFlySelectedSourceV1>> {
+    seed.source_anchors
+        .iter()
+        .map(|anchor| {
+            let public_slot = *seed
+                .external_permutation
+                .get(anchor.source_slot as usize)
+                .ok_or_else(|| integrity("external permutation source slot is absent"))?;
+            let public_helicity = public_helicities[public_slot as usize];
+            let matches = anchor
+                .states
+                .iter()
+                .filter(|state| state.public_helicity == public_helicity)
+                .collect::<Vec<_>>();
+            let [state] = matches.as_slice() else {
+                return Err(invalid(format!(
+                    "source slot {} has {} states for public helicity {public_helicity}, expected exactly one",
+                    anchor.source_slot,
+                    matches.len(),
+                )));
+            };
+            Ok(OnTheFlySelectedSourceV1 {
+                source_slot: anchor.source_slot,
+                state_index: state.state_index,
+                public_helicity,
+            })
+        })
+        .collect()
+}
+
+fn inverse_permutation(permutation: &[u32]) -> RusticolResult<Vec<u32>> {
+    let mut inverse = vec![MISSING_U32; permutation.len()];
+    for (construction_slot, public_slot) in permutation.iter().copied().enumerate() {
+        let entry = inverse
+            .get_mut(public_slot as usize)
+            .ok_or_else(|| invalid("external permutation public slot is out of bounds"))?;
+        if *entry != MISSING_U32 {
+            return Err(invalid("external permutation repeats a public slot"));
+        }
+        *entry = checked_u32(construction_slot, "construction source slot")?;
+    }
+    if inverse.contains(&MISSING_U32) {
+        return Err(invalid("external permutation omits a public slot"));
+    }
+    Ok(inverse)
+}
+
+fn map_public_word(word: &[u32], inverse: &[u32], label: &str) -> RusticolResult<Vec<u32>> {
+    if word.is_empty() {
+        return Err(invalid(format!("{label} is empty")));
+    }
+    word.iter()
+        .map(|public_slot| {
+            inverse
+                .get(*public_slot as usize)
+                .copied()
+                .ok_or_else(|| invalid(format!("{label} public slot is out of bounds")))
+        })
+        .collect()
+}
+
+fn colored_source_slots(seed: &OnTheFlyProcessSeedV1) -> BTreeSet<u32> {
+    seed.source_anchors
+        .iter()
+        .filter(|anchor| anchor.color_role.is_colored())
+        .map(|anchor| anchor.source_slot)
+        .collect()
+}
+
+fn require_exact_colored_coverage(
+    seed: &OnTheFlyProcessSeedV1,
+    words: &[Vec<u32>],
+) -> RusticolResult<()> {
+    let mut observed = BTreeSet::new();
+    for slot in words.iter().flatten().copied() {
+        if !observed.insert(slot) {
+            return Err(invalid("decoded selector repeats a colored source slot"));
+        }
+    }
+    if observed != colored_source_slots(seed) {
+        return Err(invalid(
+            "decoded selector does not cover every colored source exactly once",
+        ));
+    }
+    Ok(())
+}
+
+/// Whether closed LC components form any physical selector admitted by this
+/// compact process seed.  This is deliberately selector-independent: the
+/// cold minimal-coupling sweep uses it to prove that a structural closure can
+/// feed at least one public query without constructing a public-flow table.
+pub(super) fn components_match_physical_lc_selector(
+    seed: &OnTheFlyProcessSeedV1,
+    components: &[LCColorComponent],
+) -> bool {
+    let expected = colored_source_slots(seed);
+    let mut observed = BTreeSet::new();
+    if components
+        .iter()
+        .flat_map(|component| component.source_slots().iter().copied())
+        .any(|slot| !observed.insert(slot))
+        || observed != expected
+    {
+        return false;
+    }
+
+    if expected.is_empty() {
+        return components.is_empty() && seed.pairing_classes.is_empty();
+    }
+    if seed.pairing_classes.is_empty() {
+        return components.len() == 1
+            && components[0].kind() == LCColorComponentKind::Trace
+            && components[0].source_slots().iter().all(|slot| {
+                seed.source_anchors[*slot as usize].color_role
+                    == OnTheFlyExternalColorRoleV1::Adjoint
+            });
+    }
+    !components.is_empty()
+        && components.iter().all(|component| {
+            let slots = component.source_slots();
+            component.kind() == LCColorComponentKind::OpenString
+                && slots.len() >= 2
+                && seed.source_anchors[slots[0] as usize].color_role
+                    == OnTheFlyExternalColorRoleV1::Fundamental
+                && seed.source_anchors[*slots.last().expect("nonempty") as usize].color_role
+                    == OnTheFlyExternalColorRoleV1::Antifundamental
+                && slots[1..slots.len() - 1].iter().all(|slot| {
+                    seed.source_anchors[*slot as usize].color_role
+                        == OnTheFlyExternalColorRoleV1::Adjoint
+                })
+        })
+}
+
+/// Recover the same private closure anchor that query decoding chooses for a
+/// valid physical selector.  `None` means the components are not a selector
+/// admitted by this process seed.
+pub(super) fn physical_lc_selector_closure_anchor(
+    seed: &OnTheFlyProcessSeedV1,
+    components: &[LCColorComponent],
+) -> Option<u32> {
+    if !components_match_physical_lc_selector(seed, components) {
+        return None;
+    }
+    if components.is_empty() {
+        return Some(
+            seed.source_anchors
+                .iter()
+                .find(|anchor| anchor.is_fermionic)
+                .unwrap_or(&seed.source_anchors[0])
+                .source_slot,
+        );
+    }
+    if seed.pairing_classes.is_empty() {
+        return components[0].source_slots().last().copied();
+    }
+
+    let minimum_colored_slot = colored_source_slots(seed).into_iter().next()?;
+    let mut blocks = components
+        .iter()
+        .map(LCColorComponent::source_slots)
+        .collect::<Vec<_>>();
+    blocks.sort_unstable_by(|left, right| left[0].cmp(&right[0]).then_with(|| left.cmp(right)));
+    let first = blocks
+        .iter()
+        .position(|block| block.contains(&minimum_colored_slot))?;
+    blocks.rotate_left(first);
+    blocks.last()?.last().copied()
+}
+
+fn decode_selector(
+    seed: &OnTheFlyProcessSeedV1,
+    inverse: &[u32],
+    selector: OnTheFlyLcSelectorV1,
+) -> RusticolResult<DecodedSelector> {
+    match selector {
+        OnTheFlyLcSelectorV1::Singlet => decode_singlet(seed),
+        OnTheFlyLcSelectorV1::SingleTrace { public_word } => {
+            decode_single_trace(seed, inverse, &public_word)
+        }
+        OnTheFlyLcSelectorV1::OpenLines { public_blocks } => {
+            decode_open_lines(seed, inverse, &public_blocks)
+        }
+    }
+}
+
+fn decode_singlet(seed: &OnTheFlyProcessSeedV1) -> RusticolResult<DecodedSelector> {
+    if seed
+        .source_anchors
+        .iter()
+        .any(|anchor| anchor.color_role.is_colored())
+    {
+        return Err(invalid(
+            "singlet selector is invalid for a process with colored external sources",
+        ));
+    }
+    if !seed.pairing_classes.is_empty() {
+        return Err(integrity(
+            "singlet seed unexpectedly contains pairing classes",
+        ));
+    }
+    let closure_anchor_slot = seed
+        .source_anchors
+        .iter()
+        .find(|anchor| anchor.is_fermionic)
+        .unwrap_or(&seed.source_anchors[0])
+        .source_slot;
+    let selector_digest = selector_digest(&[])?;
+    if !components_match_physical_lc_selector(seed, &[]) {
+        return Err(integrity(
+            "singlet selector failed its physical-shape proof",
+        ));
+    }
+    Ok(DecodedSelector {
+        target_components: Vec::new(),
+        closure_anchor_slot,
+        selector_digest,
+    })
+}
+
+fn decode_single_trace(
+    seed: &OnTheFlyProcessSeedV1,
+    inverse: &[u32],
+    public_word: &[u32],
+) -> RusticolResult<DecodedSelector> {
+    if !seed.pairing_classes.is_empty() {
+        return Err(invalid(
+            "single-trace selector is invalid for a seed with open-line pairing classes",
+        ));
+    }
+    let word = map_public_word(public_word, inverse, "single-trace word")?;
+    require_exact_colored_coverage(seed, std::slice::from_ref(&word))?;
+    if word.iter().any(|slot| {
+        seed.source_anchors[*slot as usize].color_role != OnTheFlyExternalColorRoleV1::Adjoint
+    }) {
+        return Err(invalid(
+            "single-trace selector contains a non-adjoint external source",
+        ));
+    }
+    let component = LCColorComponent::new(LCColorComponentKind::Trace, word)?;
+    if !components_match_physical_lc_selector(seed, std::slice::from_ref(&component)) {
+        return Err(integrity(
+            "single-trace selector failed its physical-shape proof",
+        ));
+    }
+    let closure_anchor_slot = *component
+        .source_slots()
+        .last()
+        .ok_or_else(|| invalid("single-trace word is empty"))?;
+    let selector_digest = selector_digest(std::slice::from_ref(&component))?;
+    Ok(DecodedSelector {
+        target_components: vec![component],
+        closure_anchor_slot,
+        selector_digest,
+    })
+}
+
+fn decode_open_lines(
+    seed: &OnTheFlyProcessSeedV1,
+    inverse: &[u32],
+    public_blocks: &[Box<[u32]>],
+) -> RusticolResult<DecodedSelector> {
+    if seed.pairing_classes.is_empty() || public_blocks.is_empty() {
+        return Err(invalid(
+            "open-line selector requires pairing classes and nonempty blocks",
+        ));
+    }
+    let mut blocks = public_blocks
+        .iter()
+        .map(|word| map_public_word(word, inverse, "open-line block"))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    require_exact_colored_coverage(seed, &blocks)?;
+    for block in &blocks {
+        if block.len() < 2
+            || seed.source_anchors[block[0] as usize].color_role
+                != OnTheFlyExternalColorRoleV1::Fundamental
+            || seed.source_anchors[*block.last().expect("nonempty") as usize].color_role
+                != OnTheFlyExternalColorRoleV1::Antifundamental
+            || block[1..block.len() - 1].iter().any(|slot| {
+                seed.source_anchors[*slot as usize].color_role
+                    != OnTheFlyExternalColorRoleV1::Adjoint
+            })
+        {
+            return Err(invalid(
+                "open-line block must be fundamental, zero or more adjoints, antifundamental",
+            ));
+        }
+    }
+
+    // Public callers may enumerate the same tensor product in any block
+    // order.  Map into construction slots first, then recover the canonical
+    // product order used by the established LC builder before choosing its
+    // cyclic closure anchor.  Reversing a block remains a distinct (and
+    // invalid above) selector; only whole-block enumeration order is erased.
+    blocks.sort_unstable_by(|left, right| left[0].cmp(&right[0]).then_with(|| left.cmp(right)));
+
+    let minimum_colored_slot = colored_source_slots(seed)
+        .into_iter()
+        .next()
+        .ok_or_else(|| invalid("open-line selector has no colored source"))?;
+    let first_block = blocks
+        .iter()
+        .position(|block| block.contains(&minimum_colored_slot))
+        .ok_or_else(|| integrity("minimum colored source is absent from open-line blocks"))?;
+    blocks.rotate_left(first_block);
+    let closure_anchor_slot = *blocks
+        .last()
+        .and_then(|block| block.last())
+        .ok_or_else(|| invalid("open-line selector has no closure anchor"))?;
+    let mut components = blocks
+        .into_iter()
+        .map(|block| LCColorComponent::new(LCColorComponentKind::OpenString, block))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    components.sort_unstable();
+    if !components_match_physical_lc_selector(seed, &components) {
+        return Err(integrity(
+            "open-line selector failed its physical-shape proof",
+        ));
+    }
+    let selector_digest = selector_digest(&components)?;
+    Ok(DecodedSelector {
+        target_components: components,
+        closure_anchor_slot,
+        selector_digest,
+    })
+}
+
+fn selector_digest(components: &[LCColorComponent]) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-on-the-fly-structural-selector-v1\0");
+    hash_len(&mut hash, components.len(), "selector components")?;
+    for component in components {
+        hash.update([component.kind() as u8]);
+        hash_len(&mut hash, component.source_slots().len(), "selector word")?;
+        for source_slot in component.source_slots() {
+            hash.update(source_slot.to_le_bytes());
+        }
+    }
+    final_digest(hash)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    fn anchor(
+        source_slot: u32,
+        role: OnTheFlyExternalColorRoleV1,
+        contract: Option<SemanticDigest>,
+    ) -> OnTheFlySourceAnchorV1 {
+        let fermionic = role.is_pairing_endpoint();
+        let family = if fermionic {
+            OnTheFlySourceWavefunctionFamilyV1::DiracFermion
+        } else {
+            OnTheFlySourceWavefunctionFamilyV1::Vector
+        };
+        let orientation = match role {
+            OnTheFlyExternalColorRoleV1::Fundamental => OnTheFlySourceOrientationV1::Particle,
+            OnTheFlyExternalColorRoleV1::Antifundamental => {
+                OnTheFlySourceOrientationV1::Antiparticle
+            }
+            OnTheFlyExternalColorRoleV1::Singlet | OnTheFlyExternalColorRoleV1::Adjoint => {
+                OnTheFlySourceOrientationV1::SelfConjugate
+            }
+        };
+        let state = OnTheFlySourceStateV1::new(
+            0,
+            1,
+            1,
+            source_slot,
+            source_slot,
+            digest(20 + source_slot as u8),
+            digest(40 + source_slot as u8),
+            1,
+            ExactComplexRational::ONE,
+            1,
+            0,
+            vec![source_slot as i32 + 1],
+            source_slot,
+            digest(60 + source_slot as u8),
+            family,
+            orientation,
+            None,
+        )
+        .unwrap();
+        OnTheFlySourceAnchorV1::new(
+            source_slot,
+            100 + source_slot,
+            false,
+            role,
+            fermionic,
+            contract,
+            vec![state],
+        )
+        .unwrap()
+    }
+
+    fn seed(
+        roles: &[OnTheFlyExternalColorRoleV1],
+        external_permutation: Vec<u32>,
+    ) -> OnTheFlyProcessSeedV1 {
+        let anchors = roles
+            .iter()
+            .copied()
+            .enumerate()
+            .map(|(slot, role)| {
+                let contract = role.is_pairing_endpoint().then(|| digest(100 + slot as u8));
+                anchor(slot as u32, role, contract)
+            })
+            .collect::<Vec<_>>();
+        let fundamental = anchors
+            .iter()
+            .filter(|anchor| anchor.color_role == OnTheFlyExternalColorRoleV1::Fundamental)
+            .map(|anchor| OnTheFlyPairingEndpointV1 {
+                source_slot: anchor.source_slot,
+                source_contract_digest: anchor.pairing_source_contract_digest.unwrap(),
+            })
+            .collect::<Vec<_>>();
+        let antifundamental = anchors
+            .iter()
+            .filter(|anchor| anchor.color_role == OnTheFlyExternalColorRoleV1::Antifundamental)
+            .map(|anchor| OnTheFlyPairingEndpointV1 {
+                source_slot: anchor.source_slot,
+                source_contract_digest: anchor.pairing_source_contract_digest.unwrap(),
+            })
+            .collect::<Vec<_>>();
+        let classes = if fundamental.is_empty() {
+            Vec::new()
+        } else {
+            vec![
+                OnTheFlyPairingClassV1::new("q", digest(88), fundamental, antifundamental).unwrap(),
+            ]
+        };
+        OnTheFlyProcessSeedV1::new(
+            digest(1),
+            digest(2),
+            digest(3),
+            digest(4),
+            digest(5),
+            digest(6),
+            "raw amplitude",
+            ExactComplexRational::ONE,
+            anchors,
+            external_permutation,
+            OnTheFlyCouplingOrderPolicyV1::Explicit,
+            vec![1],
+            vec![Some(2)],
+            classes,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn inverse_permutation_binds_public_and_construction_slots_exactly() {
+        assert_eq!(inverse_permutation(&[2, 0, 3, 1]).unwrap(), [1, 3, 0, 2]);
+        assert!(inverse_permutation(&[0, 0]).is_err());
+        assert!(inverse_permutation(&[0, 2]).is_err());
+    }
+
+    #[test]
+    fn selector_domains_are_derived_from_external_roles() {
+        let singlet_seed = seed(
+            &[
+                OnTheFlyExternalColorRoleV1::Singlet,
+                OnTheFlyExternalColorRoleV1::Singlet,
+            ],
+            vec![1, 0],
+        );
+        let singlet = DecodedLcQueryV1::new(
+            &singlet_seed,
+            vec![1, 0],
+            &[1, 1],
+            OnTheFlyLcSelectorV1::Singlet,
+        )
+        .unwrap();
+        assert!(singlet.target_components.is_empty());
+        assert_eq!(singlet.closure_anchor_slot, 0);
+
+        let trace_seed = seed(
+            &[
+                OnTheFlyExternalColorRoleV1::Adjoint,
+                OnTheFlyExternalColorRoleV1::Adjoint,
+            ],
+            vec![1, 0],
+        );
+        assert!(
+            DecodedLcQueryV1::new(
+                &trace_seed,
+                vec![1, 0],
+                &[1, 1],
+                OnTheFlyLcSelectorV1::Singlet,
+            )
+            .is_err()
+        );
+        let trace = DecodedLcQueryV1::new(
+            &trace_seed,
+            vec![1, 0],
+            &[1, 1],
+            OnTheFlyLcSelectorV1::single_trace(vec![1, 0]),
+        )
+        .unwrap();
+        assert_eq!(trace.target_components[0].source_slots(), [0, 1]);
+        assert_eq!(trace.closure_anchor_slot, 1);
+    }
+
+    #[test]
+    fn single_trace_anchor_is_cyclic_invariant_but_reversal_remains_distinct() {
+        let trace_seed = seed(
+            &[
+                OnTheFlyExternalColorRoleV1::Adjoint,
+                OnTheFlyExternalColorRoleV1::Adjoint,
+                OnTheFlyExternalColorRoleV1::Adjoint,
+            ],
+            vec![0, 1, 2],
+        );
+        let decode = |word| {
+            DecodedLcQueryV1::new(
+                &trace_seed,
+                vec![0, 1, 2],
+                &[1, 1, 1],
+                OnTheFlyLcSelectorV1::single_trace(word),
+            )
+            .unwrap()
+        };
+        let canonical = decode(vec![0, 1, 2]);
+        let rotated = decode(vec![1, 2, 0]);
+        let reversed = decode(vec![0, 2, 1]);
+        assert_eq!(canonical.target_components, rotated.target_components);
+        assert_eq!(canonical.closure_anchor_slot, rotated.closure_anchor_slot);
+        assert_eq!(canonical.selector_digest, rotated.selector_digest);
+        assert_eq!(canonical.semantic_digest(), rotated.semantic_digest());
+        assert_ne!(canonical.target_components, reversed.target_components);
+        assert_ne!(canonical.selector_digest, reversed.selector_digest);
+        assert_ne!(canonical.closure_anchor_slot, reversed.closure_anchor_slot);
+    }
+
+    #[test]
+    fn certified_cyclic_policy_shares_one_anchor_without_touching_generic_shapes() {
+        let trace_seed = seed(
+            &[
+                OnTheFlyExternalColorRoleV1::Adjoint,
+                OnTheFlyExternalColorRoleV1::Adjoint,
+                OnTheFlyExternalColorRoleV1::Adjoint,
+                OnTheFlyExternalColorRoleV1::Adjoint,
+            ],
+            vec![0, 1, 2, 3],
+        );
+        let decode_trace = |word| {
+            DecodedLcQueryV1::new(
+                &trace_seed,
+                vec![0, 1, 2, 3],
+                &[1, 1, 1, 1],
+                OnTheFlyLcSelectorV1::single_trace(word),
+            )
+            .unwrap()
+        };
+        let queries = [
+            vec![0, 1, 2, 3],
+            vec![0, 1, 3, 2],
+            vec![0, 2, 1, 3],
+            vec![0, 2, 3, 1],
+            vec![0, 3, 1, 2],
+            vec![0, 3, 2, 1],
+        ]
+        .map(decode_trace);
+        assert_eq!(
+            queries
+                .iter()
+                .map(|query| query.closure_anchor_slot)
+                .collect::<BTreeSet<_>>(),
+            BTreeSet::from([1, 2, 3]),
+        );
+
+        let fallback = OnTheFlyClosureAnchorPolicyV1::selector_endpoint();
+        for query in &queries {
+            assert_eq!(
+                fallback
+                    .canonicalize_query(&trace_seed, query.clone())
+                    .unwrap(),
+                query.clone(),
+            );
+        }
+        let fixed = OnTheFlyClosureAnchorPolicyV1::certified_cyclic_minimum(0);
+        let error = fixed
+            .authenticate_canonical_query(&trace_seed, &queries[0])
+            .unwrap_err();
+        assert!(error.to_string().contains("prepared-grammar boundary"));
+        let fixed_queries =
+            queries.map(|query| fixed.canonicalize_query(&trace_seed, query).unwrap());
+        assert!(
+            fixed_queries
+                .iter()
+                .all(|query| query.closure_anchor_slot == 0)
+        );
+        for query in &fixed_queries {
+            fixed
+                .authenticate_canonical_query(&trace_seed, query)
+                .unwrap();
+            assert!(fixed.certifies_cyclic_trace_reflection(&trace_seed, query));
+            assert!(!fallback.certifies_cyclic_trace_reflection(&trace_seed, query));
+        }
+        assert_eq!(
+            fixed_queries
+                .iter()
+                .map(DecodedLcQueryV1::semantic_digest)
+                .collect::<BTreeSet<_>>()
+                .len(),
+            6,
+        );
+
+        let open_seed = seed(
+            &[
+                OnTheFlyExternalColorRoleV1::Fundamental,
+                OnTheFlyExternalColorRoleV1::Adjoint,
+                OnTheFlyExternalColorRoleV1::Antifundamental,
+            ],
+            vec![0, 1, 2],
+        );
+        let open = DecodedLcQueryV1::new(
+            &open_seed,
+            vec![0, 1, 2],
+            &[1, 1, 1],
+            OnTheFlyLcSelectorV1::open_lines(vec![vec![0, 1, 2]]),
+        )
+        .unwrap();
+        assert_eq!(open.closure_anchor_slot, 2);
+        assert_eq!(
+            fixed.canonicalize_query(&open_seed, open.clone()).unwrap(),
+            open,
+        );
+        assert!(!fixed.certifies_cyclic_trace_reflection(&open_seed, &open));
+    }
+
+    #[test]
+    fn open_line_selector_binds_only_the_selected_color_tensor() {
+        let open_seed = seed(
+            &[
+                OnTheFlyExternalColorRoleV1::Fundamental,
+                OnTheFlyExternalColorRoleV1::Adjoint,
+                OnTheFlyExternalColorRoleV1::Antifundamental,
+            ],
+            vec![2, 0, 1],
+        );
+        let query = DecodedLcQueryV1::new(
+            &open_seed,
+            vec![2, 0, 1],
+            &[1, 1, 1],
+            OnTheFlyLcSelectorV1::open_lines(vec![vec![2, 0, 1]]),
+        )
+        .unwrap();
+        assert_eq!(query.target_components[0].source_slots(), [0, 1, 2]);
+        assert_eq!(query.closure_anchor_slot, 2);
+    }
+
+    #[test]
+    fn multi_open_line_block_order_is_canonical_after_public_alias_permutation() {
+        let roles = [
+            OnTheFlyExternalColorRoleV1::Fundamental,
+            OnTheFlyExternalColorRoleV1::Adjoint,
+            OnTheFlyExternalColorRoleV1::Antifundamental,
+            OnTheFlyExternalColorRoleV1::Fundamental,
+            OnTheFlyExternalColorRoleV1::Adjoint,
+            OnTheFlyExternalColorRoleV1::Antifundamental,
+        ];
+        // Construction slot -> public slot. The two physical open strings are
+        // [0,1,2] and [3,4,5], hence [3,0,5] and [2,1,4] publicly.
+        let permutation = vec![3, 0, 5, 2, 1, 4];
+        let open_seed = seed(&roles, permutation.clone());
+        let decode = |blocks| {
+            DecodedLcQueryV1::new(
+                &open_seed,
+                permutation.clone(),
+                &[1; 6],
+                OnTheFlyLcSelectorV1::open_lines(blocks),
+            )
+            .unwrap()
+        };
+        let forward = decode(vec![vec![3, 0, 5], vec![2, 1, 4]]);
+        let reversed_blocks = decode(vec![vec![2, 1, 4], vec![3, 0, 5]]);
+
+        assert_eq!(forward.target_components, reversed_blocks.target_components);
+        assert_eq!(forward.selector_digest, reversed_blocks.selector_digest);
+        assert_eq!(forward.semantic_digest(), reversed_blocks.semantic_digest());
+        assert_eq!(forward.closure_anchor_slot, 5);
+        assert_eq!(
+            forward
+                .target_components
+                .iter()
+                .map(|component| component.source_slots())
+                .collect::<Vec<_>>(),
+            vec![&[0, 1, 2][..], &[3, 4, 5][..]],
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/seed_codec.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/seed_codec.rs
new file mode 100644
index 0000000000..8a32124fef
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/seed_codec.rs
@@ -0,0 +1,1038 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Canonical private payload codec for the compact on-the-fly process seed.
+//!
+//! The eventual PACBIN member owns payload hashing and authentication. This
+//! codec therefore carries only the seed's semantic inputs; derived semantic
+//! digests are recomputed by the existing constructors during decoding. The
+//! raw-amplitude normalization factor is exact one by seed construction, so
+//! schema v1 implies it instead of storing a redundant field.
+
+use std::io::{self, Write};
+use std::str;
+
+use super::source_seed::{
+    OnTheFlyCouplingOrderPolicyV1, OnTheFlyExternalColorRoleV1, OnTheFlyPairingClassV1,
+    OnTheFlyPairingEndpointV1, OnTheFlyProcessSeedV1, OnTheFlySourceAnchorV1,
+    OnTheFlySourceOrientationV1, OnTheFlySourceStateV1, OnTheFlySourceWavefunctionFamilyV1,
+};
+use crate::recurrence::{ExactComplexRational, ExactRational, SemanticDigest};
+use crate::{RusticolError, RusticolResult};
+
+const MAGIC: &[u8; 8] = b"PACOTFSD";
+const SCHEMA_VERSION: u32 = 1;
+const SEMANTIC_HASH_REVISION: u32 = 2;
+#[cfg(test)]
+const RETAINED_DIGEST_COUNT: u64 = 6;
+const DIGEST_BYTES: u64 = 32;
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(format!("on-the-fly process-seed codec: {}", message.into()))
+}
+
+struct Writer<W> {
+    destination: W,
+    bytes_written: u64,
+}
+
+impl<W: Write> Writer<W> {
+    fn new(destination: W) -> Self {
+        Self {
+            destination,
+            bytes_written: 0,
+        }
+    }
+
+    #[cfg(test)]
+    fn with_bytes_written(destination: W, bytes_written: u64) -> Self {
+        Self {
+            destination,
+            bytes_written,
+        }
+    }
+
+    fn raw(&mut self, bytes: &[u8]) -> RusticolResult<()> {
+        let byte_count =
+            u64::try_from(bytes.len()).map_err(|_| invalid("payload write length exceeds u64"))?;
+        let end = self
+            .bytes_written
+            .checked_add(byte_count)
+            .ok_or_else(|| invalid("payload byte accounting overflows u64"))?;
+        self.destination.write_all(bytes).map_err(|error| {
+            RusticolError::serialization(format!(
+                "could not stream on-the-fly process-seed payload: {error}"
+            ))
+        })?;
+        self.bytes_written = end;
+        Ok(())
+    }
+
+    fn u8(&mut self, value: u8) -> RusticolResult<()> {
+        self.raw(&[value])
+    }
+
+    fn u32(&mut self, value: u32) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn i32(&mut self, value: i32) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn u64(&mut self, value: u64) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn i128(&mut self, value: i128) -> RusticolResult<()> {
+        self.raw(&value.to_le_bytes())
+    }
+
+    fn count(&mut self, value: usize, label: &str) -> RusticolResult<()> {
+        self.u64(u64::try_from(value).map_err(|_| invalid(format!("{label} count exceeds u64")))?)
+    }
+
+    fn boolean(&mut self, value: bool) -> RusticolResult<()> {
+        self.u8(u8::from(value))
+    }
+
+    fn digest(&mut self, value: SemanticDigest) -> RusticolResult<()> {
+        self.raw(value.as_bytes())
+    }
+
+    fn optional_digest(&mut self, value: Option<SemanticDigest>) -> RusticolResult<()> {
+        match value {
+            None => self.u8(0),
+            Some(value) => {
+                self.u8(1)?;
+                self.digest(value)
+            }
+        }
+    }
+
+    fn optional_u32(&mut self, value: Option<u32>) -> RusticolResult<()> {
+        match value {
+            None => self.u8(0),
+            Some(value) => {
+                self.u8(1)?;
+                self.u32(value)
+            }
+        }
+    }
+
+    fn exact(&mut self, value: ExactComplexRational) -> RusticolResult<()> {
+        for part in [value.real(), value.imag()] {
+            self.i128(part.numerator())?;
+            self.i128(part.denominator())?;
+        }
+        Ok(())
+    }
+
+    fn string(&mut self, value: &str, label: &str) -> RusticolResult<()> {
+        self.count(value.len(), label)?;
+        self.raw(value.as_bytes())
+    }
+}
+
+struct Reader<'a> {
+    bytes: &'a [u8],
+    offset: u64,
+    length: u64,
+}
+
+impl<'a> Reader<'a> {
+    fn new(bytes: &'a [u8]) -> RusticolResult<Self> {
+        Ok(Self {
+            bytes,
+            offset: 0,
+            length: u64::try_from(bytes.len())
+                .map_err(|_| invalid("payload length exceeds u64"))?,
+        })
+    }
+
+    fn take(&mut self, count: u64, label: &str) -> RusticolResult<&'a [u8]> {
+        let end = self
+            .offset
+            .checked_add(count)
+            .ok_or_else(|| invalid(format!("{label} byte range overflows u64")))?;
+        if end > self.length {
+            return Err(invalid(format!(
+                "truncated {label} at byte {}: need {count}, have {}",
+                self.offset,
+                self.length.saturating_sub(self.offset)
+            )));
+        }
+        let start = usize::try_from(self.offset)
+            .map_err(|_| invalid(format!("{label} offset exceeds usize")))?;
+        let end = usize::try_from(end)
+            .map_err(|_| invalid(format!("{label} end offset exceeds usize")))?;
+        let result = self
+            .bytes
+            .get(start..end)
+            .ok_or_else(|| invalid(format!("{label} byte range is outside the payload")))?;
+        self.offset =
+            u64::try_from(end).map_err(|_| invalid(format!("{label} end offset exceeds u64")))?;
+        Ok(result)
+    }
+
+    fn u8(&mut self, label: &str) -> RusticolResult<u8> {
+        Ok(self.take(1, label)?[0])
+    }
+
+    fn u32(&mut self, label: &str) -> RusticolResult<u32> {
+        Ok(u32::from_le_bytes(
+            self.take(4, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn i32(&mut self, label: &str) -> RusticolResult<i32> {
+        Ok(i32::from_le_bytes(
+            self.take(4, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn u64(&mut self, label: &str) -> RusticolResult<u64> {
+        Ok(u64::from_le_bytes(
+            self.take(8, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn i128(&mut self, label: &str) -> RusticolResult<i128> {
+        Ok(i128::from_le_bytes(
+            self.take(16, label)?.try_into().expect("checked read"),
+        ))
+    }
+
+    fn count(&mut self, minimum_item_bytes: u64, label: &str) -> RusticolResult<usize> {
+        let count = self.u64(&format!("{label} count"))?;
+        let minimum_bytes = count
+            .checked_mul(minimum_item_bytes)
+            .ok_or_else(|| invalid(format!("{label} minimum byte length overflows u64")))?;
+        if minimum_bytes > self.length.saturating_sub(self.offset) {
+            return Err(invalid(format!(
+                "{label} count cannot fit in the remaining payload"
+            )));
+        }
+        usize::try_from(count).map_err(|_| invalid(format!("{label} count exceeds usize")))
+    }
+
+    fn boolean(&mut self, label: &str) -> RusticolResult<bool> {
+        match self.u8(label)? {
+            0 => Ok(false),
+            1 => Ok(true),
+            value => Err(invalid(format!(
+                "{label} has malformed boolean discriminant {value}"
+            ))),
+        }
+    }
+
+    fn digest(&mut self, label: &str) -> RusticolResult<SemanticDigest> {
+        let value: [u8; 32] = self
+            .take(DIGEST_BYTES, label)?
+            .try_into()
+            .expect("checked read");
+        SemanticDigest::new(value).map_err(|error| invalid(error.message()))
+    }
+
+    fn optional_digest(&mut self, label: &str) -> RusticolResult<Option<SemanticDigest>> {
+        match self.u8(&format!("{label} presence"))? {
+            0 => Ok(None),
+            1 => Ok(Some(self.digest(label)?)),
+            value => Err(invalid(format!(
+                "{label} has malformed optional discriminant {value}"
+            ))),
+        }
+    }
+
+    fn optional_u32(&mut self, label: &str) -> RusticolResult<Option<u32>> {
+        match self.u8(&format!("{label} presence"))? {
+            0 => Ok(None),
+            1 => Ok(Some(self.u32(label)?)),
+            value => Err(invalid(format!(
+                "{label} has malformed optional discriminant {value}"
+            ))),
+        }
+    }
+
+    fn exact(&mut self, label: &str) -> RusticolResult<ExactComplexRational> {
+        Ok(ExactComplexRational::new(
+            self.rational(&format!("{label} real"))?,
+            self.rational(&format!("{label} imaginary"))?,
+        ))
+    }
+
+    fn rational(&mut self, label: &str) -> RusticolResult<ExactRational> {
+        let numerator = self.i128(&format!("{label} numerator"))?;
+        let denominator = self.i128(&format!("{label} denominator"))?;
+        let value =
+            ExactRational::new(numerator, denominator).map_err(|error| invalid(error.message()))?;
+        if value.numerator() != numerator || value.denominator() != denominator {
+            return Err(invalid(format!("{label} is not canonically reduced")));
+        }
+        Ok(value)
+    }
+
+    fn string(&mut self, label: &str) -> RusticolResult<String> {
+        let byte_count = self.u64(&format!("{label} byte count"))?;
+        let bytes = self.take(byte_count, label)?;
+        let value = str::from_utf8(bytes)
+            .map_err(|error| invalid(format!("{label} is not UTF-8: {error}")))?;
+        let byte_count = usize::try_from(byte_count)
+            .map_err(|_| invalid(format!("{label} byte count exceeds usize")))?;
+        let mut owned = String::new();
+        owned.try_reserve_exact(byte_count).map_err(|error| {
+            invalid(format!(
+                "could not reserve {byte_count} bytes for {label}: {error}"
+            ))
+        })?;
+        owned.push_str(value);
+        Ok(owned)
+    }
+
+    fn finish(self) -> RusticolResult<()> {
+        if self.offset != self.length {
+            return Err(invalid(format!(
+                "payload contains {} trailing bytes",
+                self.length - self.offset
+            )));
+        }
+        Ok(())
+    }
+}
+
+fn reserved_vec<T>(count: usize, label: &str) -> RusticolResult<Vec<T>> {
+    let mut result = Vec::new();
+    result.try_reserve_exact(count).map_err(|error| {
+        invalid(format!(
+            "could not reserve {count} rows for {label}: {error}"
+        ))
+    })?;
+    Ok(result)
+}
+
+fn encode_to_writer<W: Write>(seed: &OnTheFlyProcessSeedV1, destination: W) -> RusticolResult<u64> {
+    let mut writer = Writer::new(destination);
+    writer.raw(MAGIC)?;
+    writer.u32(SCHEMA_VERSION)?;
+    writer.u32(SEMANTIC_HASH_REVISION)?;
+    for digest in [
+        seed.process_digest,
+        seed.model_digest,
+        seed.template_catalog_digest,
+        seed.prepared_pack_digest,
+        seed.direct_catalog_digest,
+        seed.normalization_semantic_digest,
+    ] {
+        writer.digest(digest)?;
+    }
+    writer.string(&seed.normalization_convention, "normalization convention")?;
+    writer.count(seed.source_anchors.len(), "source anchors")?;
+    for anchor in &seed.source_anchors {
+        writer.u32(anchor.source_slot)?;
+        writer.u32(anchor.external_label)?;
+        writer.boolean(anchor.is_initial)?;
+        writer.u8(anchor.color_role as u8)?;
+        writer.boolean(anchor.is_fermionic)?;
+        writer.optional_digest(anchor.pairing_source_contract_digest)?;
+        writer.count(anchor.states.len(), "source states")?;
+        for state in &anchor.states {
+            writer.u32(state.state_index)?;
+            writer.i32(state.public_helicity)?;
+            writer.i32(state.source_helicity)?;
+            writer.u32(state.source_template_id)?;
+            writer.u32(state.current_state_template_id)?;
+            writer.digest(state.source_semantic_digest)?;
+            writer.digest(state.current_state_semantic_digest)?;
+            writer.i32(state.momentum_sign)?;
+            writer.exact(state.crossing_phase)?;
+            writer.i32(state.spin_state)?;
+            writer.i32(state.chirality)?;
+            writer.count(state.flavour_flow.len(), "source flavour flow")?;
+            for flavour in &state.flavour_flow {
+                writer.i32(*flavour)?;
+            }
+            writer.u32(state.quantum_number_flow_id)?;
+            writer.digest(state.color_seed_proof_digest)?;
+            writer.u8(state.source_family as u8)?;
+            writer.u8(state.source_orientation as u8)?;
+            writer.optional_u32(state.prepared_mass_parameter_slot)?;
+        }
+    }
+    writer.count(
+        seed.external_permutation.len(),
+        "external gather permutation",
+    )?;
+    for slot in &seed.external_permutation {
+        writer.u32(*slot)?;
+    }
+    writer.u8(seed.coupling_order_policy as u8)?;
+    writer.count(seed.coupling_limits.len(), "coupling policy rows")?;
+    for (hierarchy, limit) in seed
+        .coupling_hierarchies
+        .iter()
+        .zip(seed.coupling_limits.iter())
+    {
+        writer.u32(*hierarchy)?;
+        writer.optional_u32(*limit)?;
+    }
+    writer.count(seed.pairing_classes.len(), "pairing classes")?;
+    for pairing_class in &seed.pairing_classes {
+        writer.string(&pairing_class.species, "pairing species")?;
+        writer.digest(pairing_class.species_semantic_digest)?;
+        for (label, endpoints) in [
+            (
+                "fundamental pairing endpoints",
+                pairing_class.fundamental_endpoints.as_ref(),
+            ),
+            (
+                "antifundamental pairing endpoints",
+                pairing_class.antifundamental_endpoints.as_ref(),
+            ),
+        ] {
+            writer.count(endpoints.len(), label)?;
+            for endpoint in endpoints {
+                writer.u32(endpoint.source_slot)?;
+                writer.digest(endpoint.source_contract_digest)?;
+            }
+        }
+    }
+    Ok(writer.bytes_written)
+}
+
+/// Encode the canonical schema-v1 payload for a compact semantic seed.
+///
+/// This remains crate-private until the PACBIN member integration owns it.
+#[allow(dead_code)]
+pub(crate) fn encode_on_the_fly_process_seed_v1(
+    seed: &OnTheFlyProcessSeedV1,
+) -> RusticolResult<Vec<u8>> {
+    let byte_count = encode_to_writer(seed, io::sink())?;
+    let capacity =
+        usize::try_from(byte_count).map_err(|_| invalid("encoded payload length exceeds usize"))?;
+    let mut payload = Vec::new();
+    payload.try_reserve_exact(capacity).map_err(|error| {
+        invalid(format!(
+            "could not reserve {capacity} bytes for encoded payload: {error}"
+        ))
+    })?;
+    let actual = encode_to_writer(seed, &mut payload)?;
+    if actual != byte_count || payload.len() != capacity {
+        return Err(RusticolError::internal(
+            "on-the-fly process-seed encoder produced an inconsistent byte count",
+        ));
+    }
+    Ok(payload)
+}
+
+fn read_color_role(reader: &mut Reader<'_>) -> RusticolResult<OnTheFlyExternalColorRoleV1> {
+    match reader.u8("source anchor color role")? {
+        0 => Ok(OnTheFlyExternalColorRoleV1::Singlet),
+        1 => Ok(OnTheFlyExternalColorRoleV1::Fundamental),
+        2 => Ok(OnTheFlyExternalColorRoleV1::Antifundamental),
+        3 => Ok(OnTheFlyExternalColorRoleV1::Adjoint),
+        value => Err(invalid(format!(
+            "malformed source anchor color-role discriminant {value}"
+        ))),
+    }
+}
+
+fn read_source_family(
+    reader: &mut Reader<'_>,
+) -> RusticolResult<OnTheFlySourceWavefunctionFamilyV1> {
+    match reader.u8("source wavefunction family")? {
+        0 => Ok(OnTheFlySourceWavefunctionFamilyV1::Scalar),
+        1 => Ok(OnTheFlySourceWavefunctionFamilyV1::WeylFermion),
+        2 => Ok(OnTheFlySourceWavefunctionFamilyV1::DiracFermion),
+        3 => Ok(OnTheFlySourceWavefunctionFamilyV1::Vector),
+        4 => Ok(OnTheFlySourceWavefunctionFamilyV1::Spin2),
+        value => Err(invalid(format!(
+            "malformed source wavefunction-family discriminant {value}"
+        ))),
+    }
+}
+
+fn read_source_orientation(reader: &mut Reader<'_>) -> RusticolResult<OnTheFlySourceOrientationV1> {
+    match reader.u8("source orientation")? {
+        0 => Ok(OnTheFlySourceOrientationV1::Particle),
+        1 => Ok(OnTheFlySourceOrientationV1::Antiparticle),
+        2 => Ok(OnTheFlySourceOrientationV1::SelfConjugate),
+        value => Err(invalid(format!(
+            "malformed source-orientation discriminant {value}"
+        ))),
+    }
+}
+
+fn read_coupling_order_policy(
+    reader: &mut Reader<'_>,
+) -> RusticolResult<OnTheFlyCouplingOrderPolicyV1> {
+    match reader.u8("coupling-order policy")? {
+        0 => Ok(OnTheFlyCouplingOrderPolicyV1::Minimal),
+        1 => Ok(OnTheFlyCouplingOrderPolicyV1::Explicit),
+        value => Err(invalid(format!(
+            "malformed coupling-order policy discriminant {value}"
+        ))),
+    }
+}
+
+fn read_source_state(reader: &mut Reader<'_>) -> RusticolResult<OnTheFlySourceStateV1> {
+    let state_index = reader.u32("source state index")?;
+    let public_helicity = reader.i32("source state public helicity")?;
+    let source_helicity = reader.i32("source state source helicity")?;
+    let source_template_id = reader.u32("source state source-template ID")?;
+    let current_state_template_id = reader.u32("source state current-template ID")?;
+    let source_semantic_digest = reader.digest("source state source semantic digest")?;
+    let current_state_semantic_digest = reader.digest("source state current semantic digest")?;
+    let momentum_sign = reader.i32("source state momentum sign")?;
+    let crossing_phase = reader.exact("source state crossing phase")?;
+    let spin_state = reader.i32("source state spin state")?;
+    let chirality = reader.i32("source state chirality")?;
+    let flavour_count = reader.count(4, "source flavour flow")?;
+    let mut flavour_flow = reserved_vec(flavour_count, "source flavour flow")?;
+    for _ in 0..flavour_count {
+        flavour_flow.push(reader.i32("source flavour-flow entry")?);
+    }
+    let quantum_number_flow_id = reader.u32("source state quantum-number flow ID")?;
+    let color_seed_proof_digest = reader.digest("source state color-seed proof digest")?;
+    let source_family = read_source_family(reader)?;
+    let source_orientation = read_source_orientation(reader)?;
+    let prepared_mass_parameter_slot =
+        reader.optional_u32("source state prepared-mass parameter slot")?;
+    OnTheFlySourceStateV1::new(
+        state_index,
+        public_helicity,
+        source_helicity,
+        source_template_id,
+        current_state_template_id,
+        source_semantic_digest,
+        current_state_semantic_digest,
+        momentum_sign,
+        crossing_phase,
+        spin_state,
+        chirality,
+        flavour_flow,
+        quantum_number_flow_id,
+        color_seed_proof_digest,
+        source_family,
+        source_orientation,
+        prepared_mass_parameter_slot,
+    )
+}
+
+fn read_pairing_endpoints(
+    reader: &mut Reader<'_>,
+    label: &str,
+) -> RusticolResult<Vec<OnTheFlyPairingEndpointV1>> {
+    const MINIMUM_ENDPOINT_BYTES: u64 = 4 + DIGEST_BYTES;
+    let count = reader.count(MINIMUM_ENDPOINT_BYTES, label)?;
+    let mut endpoints = reserved_vec(count, label)?;
+    let mut previous_slot = None;
+    for _ in 0..count {
+        let source_slot = reader.u32(&format!("{label} source slot"))?;
+        if previous_slot.is_some_and(|previous| previous >= source_slot) {
+            return Err(invalid(format!(
+                "{label} keys are not in canonical strict order"
+            )));
+        }
+        previous_slot = Some(source_slot);
+        endpoints.push(OnTheFlyPairingEndpointV1 {
+            source_slot,
+            source_contract_digest: reader.digest(&format!("{label} source-contract digest"))?,
+        });
+    }
+    Ok(endpoints)
+}
+
+/// Decode exactly one canonical schema-v1 compact semantic seed payload.
+///
+/// Version mismatches are rejected rather than guessed, leaving a clean seam
+/// for a future schema that carries NLC/full-color seed fields.
+#[allow(dead_code)]
+pub(crate) fn decode_on_the_fly_process_seed_v1(
+    bytes: &[u8],
+) -> RusticolResult<OnTheFlyProcessSeedV1> {
+    const MINIMUM_STATE_BYTES: u64 =
+        5 * 4 + 2 * DIGEST_BYTES + 4 + 4 * 16 + 2 * 4 + 8 + 4 + DIGEST_BYTES + 1 + 1 + 1 + 4;
+    const MINIMUM_ANCHOR_BYTES: u64 = 4 + 4 + 1 + 1 + 1 + 1 + 8 + MINIMUM_STATE_BYTES;
+    const MINIMUM_ENDPOINT_BYTES: u64 = 4 + DIGEST_BYTES;
+    const MINIMUM_PAIRING_CLASS_BYTES: u64 =
+        8 + 1 + DIGEST_BYTES + 8 + MINIMUM_ENDPOINT_BYTES + 8 + MINIMUM_ENDPOINT_BYTES;
+
+    let mut reader = Reader::new(bytes)?;
+    if reader.take(8, "magic")? != MAGIC {
+        return Err(invalid(
+            "unsupported payload magic; expected on-the-fly process-seed schema v1",
+        ));
+    }
+    let schema_version = reader.u32("schema version")?;
+    if schema_version != SCHEMA_VERSION {
+        return Err(invalid(format!(
+            "unsupported on-the-fly process-seed schema version {schema_version}; expected {SCHEMA_VERSION}"
+        )));
+    }
+    let semantic_hash_revision = reader.u32("semantic hash revision")?;
+    if semantic_hash_revision != SEMANTIC_HASH_REVISION {
+        return Err(invalid(format!(
+            "unsupported on-the-fly process-seed semantic hash revision {semantic_hash_revision}; expected {SEMANTIC_HASH_REVISION}"
+        )));
+    }
+
+    let process_digest = reader.digest("process digest")?;
+    let model_digest = reader.digest("model digest")?;
+    let template_catalog_digest = reader.digest("template-catalog digest")?;
+    let prepared_pack_digest = reader.digest("prepared-pack digest")?;
+    let direct_catalog_digest = reader.digest("direct-catalog digest")?;
+    let normalization_semantic_digest = reader.digest("normalization semantic digest")?;
+    let normalization_convention = reader.string("normalization convention")?;
+
+    let anchor_count = reader.count(MINIMUM_ANCHOR_BYTES, "source anchors")?;
+    let mut source_anchors = reserved_vec(anchor_count, "source anchors")?;
+    for anchor_index in 0..anchor_count {
+        let source_slot = reader.u32("source anchor slot")?;
+        let expected_slot = u32::try_from(anchor_index)
+            .map_err(|_| invalid("source anchor index exceeds its u32 semantic domain"))?;
+        if source_slot != expected_slot {
+            return Err(invalid(
+                "source anchor keys are not in canonical dense order",
+            ));
+        }
+        let external_label = reader.u32("source anchor external label")?;
+        let is_initial = reader.boolean("source anchor initial-state flag")?;
+        let color_role = read_color_role(&mut reader)?;
+        let is_fermionic = reader.boolean("source anchor fermion flag")?;
+        let pairing_source_contract_digest =
+            reader.optional_digest("source anchor pairing-source contract digest")?;
+        let state_count = reader.count(MINIMUM_STATE_BYTES, "source states")?;
+        let mut states = reserved_vec(state_count, "source states")?;
+        let mut previous_state_index = None;
+        for _ in 0..state_count {
+            let state = read_source_state(&mut reader)?;
+            if previous_state_index.is_some_and(|previous| previous >= state.state_index) {
+                return Err(invalid(
+                    "source state keys are not in canonical strict order",
+                ));
+            }
+            previous_state_index = Some(state.state_index);
+            states.push(state);
+        }
+        source_anchors.push(OnTheFlySourceAnchorV1::new(
+            source_slot,
+            external_label,
+            is_initial,
+            color_role,
+            is_fermionic,
+            pairing_source_contract_digest,
+            states,
+        )?);
+    }
+
+    let permutation_count = reader.count(4, "external gather permutation")?;
+    let mut external_permutation = reserved_vec(permutation_count, "external gather permutation")?;
+    for _ in 0..permutation_count {
+        external_permutation.push(reader.u32("external gather-permutation slot")?);
+    }
+
+    let coupling_order_policy = read_coupling_order_policy(&mut reader)?;
+    let coupling_row_count = reader.count(1, "coupling policy rows")?;
+    let mut coupling_hierarchies = reserved_vec(coupling_row_count, "coupling hierarchies")?;
+    let mut coupling_limits = reserved_vec(coupling_row_count, "coupling limits")?;
+    for _ in 0..coupling_row_count {
+        coupling_hierarchies.push(reader.u32("coupling hierarchy")?);
+        coupling_limits.push(reader.optional_u32("explicit coupling limit")?);
+    }
+
+    let pairing_class_count = reader.count(MINIMUM_PAIRING_CLASS_BYTES, "pairing classes")?;
+    let mut pairing_classes = reserved_vec(pairing_class_count, "pairing classes")?;
+    for _ in 0..pairing_class_count {
+        let species = reader.string("pairing species")?;
+        if pairing_classes
+            .last()
+            .is_some_and(|previous: &OnTheFlyPairingClassV1| {
+                previous.species.as_ref() >= species.as_str()
+            })
+        {
+            return Err(invalid(
+                "pairing class species keys are not in canonical strict order",
+            ));
+        }
+        let species_semantic_digest = reader.digest("pairing species semantic digest")?;
+        let fundamental_endpoints =
+            read_pairing_endpoints(&mut reader, "fundamental pairing endpoints")?;
+        let antifundamental_endpoints =
+            read_pairing_endpoints(&mut reader, "antifundamental pairing endpoints")?;
+        pairing_classes.push(OnTheFlyPairingClassV1::new(
+            species,
+            species_semantic_digest,
+            fundamental_endpoints,
+            antifundamental_endpoints,
+        )?);
+    }
+    reader.finish()?;
+
+    OnTheFlyProcessSeedV1::new(
+        process_digest,
+        model_digest,
+        template_catalog_digest,
+        prepared_pack_digest,
+        direct_catalog_digest,
+        normalization_semantic_digest,
+        normalization_convention,
+        ExactComplexRational::ONE,
+        source_anchors,
+        external_permutation,
+        coupling_order_policy,
+        coupling_hierarchies,
+        coupling_limits,
+        pairing_classes,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::on_the_fly::{
+        ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI, OnTheFlyProcessSeedIdentityV1,
+        scalar_adapter_test_seed,
+    };
+
+    #[derive(Default)]
+    struct CountingWriter {
+        bytes_written: u64,
+    }
+
+    impl Write for CountingWriter {
+        fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
+            self.bytes_written += bytes.len() as u64;
+            Ok(bytes.len())
+        }
+
+        fn flush(&mut self) -> io::Result<()> {
+            Ok(())
+        }
+    }
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    fn state(source_slot: u32, state_index: u32) -> OnTheFlySourceStateV1 {
+        let crossing_phase = if source_slot == 0 && state_index == 0 {
+            ExactComplexRational::new(
+                ExactRational::new(-1, 2).unwrap(),
+                ExactRational::new(1, 3).unwrap(),
+            )
+        } else {
+            ExactComplexRational::ONE
+        };
+        OnTheFlySourceStateV1::new(
+            state_index,
+            if state_index == 0 { -1 } else { 1 },
+            if source_slot.is_multiple_of(2) { -1 } else { 1 },
+            100 + source_slot * 2 + state_index,
+            200 + source_slot * 2 + state_index,
+            digest(20 + (source_slot * 2 + state_index) as u8),
+            digest(30 + (source_slot * 2 + state_index) as u8),
+            if source_slot.is_multiple_of(2) { -1 } else { 1 },
+            crossing_phase,
+            50_000 + source_slot as i32,
+            if source_slot.is_multiple_of(2) { -1 } else { 1 },
+            if state_index == 0 {
+                vec![11 + source_slot as i32, 21 + source_slot as i32]
+            } else {
+                vec![31 + source_slot as i32]
+            },
+            300 + source_slot,
+            digest(40 + source_slot as u8),
+            OnTheFlySourceWavefunctionFamilyV1::DiracFermion,
+            if source_slot.is_multiple_of(2) {
+                OnTheFlySourceOrientationV1::Particle
+            } else {
+                OnTheFlySourceOrientationV1::Antiparticle
+            },
+            (state_index == 0).then_some(400 + source_slot),
+        )
+        .unwrap()
+    }
+
+    fn ordinary_seed(reverse_inputs: bool) -> OnTheFlyProcessSeedV1 {
+        ordinary_seed_with_limits(reverse_inputs, vec![Some(0), Some(3)])
+    }
+
+    fn ordinary_seed_with_limits(
+        reverse_inputs: bool,
+        coupling_limits: Vec<Option<u32>>,
+    ) -> OnTheFlyProcessSeedV1 {
+        let contracts = [digest(60), digest(61), digest(62), digest(63)];
+        let roles = [
+            OnTheFlyExternalColorRoleV1::Fundamental,
+            OnTheFlyExternalColorRoleV1::Antifundamental,
+            OnTheFlyExternalColorRoleV1::Fundamental,
+            OnTheFlyExternalColorRoleV1::Antifundamental,
+        ];
+        let mut anchors = (0..4)
+            .map(|source_slot| {
+                let mut states = vec![state(source_slot, 0)];
+                if source_slot == 0 {
+                    states.push(state(source_slot, 1));
+                }
+                if reverse_inputs {
+                    states.reverse();
+                }
+                OnTheFlySourceAnchorV1::new(
+                    source_slot,
+                    10 + source_slot,
+                    source_slot < 2,
+                    roles[source_slot as usize],
+                    true,
+                    Some(contracts[source_slot as usize]),
+                    states,
+                )
+                .unwrap()
+            })
+            .collect::<Vec<_>>();
+        if reverse_inputs {
+            anchors.reverse();
+        }
+        let alpha = OnTheFlyPairingClassV1::new(
+            "alpha",
+            digest(70),
+            vec![OnTheFlyPairingEndpointV1 {
+                source_slot: 0,
+                source_contract_digest: contracts[0],
+            }],
+            vec![OnTheFlyPairingEndpointV1 {
+                source_slot: 1,
+                source_contract_digest: contracts[1],
+            }],
+        )
+        .unwrap();
+        let bravo = OnTheFlyPairingClassV1::new(
+            "bravo",
+            digest(71),
+            vec![OnTheFlyPairingEndpointV1 {
+                source_slot: 2,
+                source_contract_digest: contracts[2],
+            }],
+            vec![OnTheFlyPairingEndpointV1 {
+                source_slot: 3,
+                source_contract_digest: contracts[3],
+            }],
+        )
+        .unwrap();
+        let pairing_classes = if reverse_inputs {
+            vec![bravo, alpha]
+        } else {
+            vec![alpha, bravo]
+        };
+        OnTheFlyProcessSeedV1::new(
+            digest(1),
+            digest(2),
+            digest(3),
+            digest(4),
+            digest(5),
+            digest(6),
+            "raw-amplitude-v1",
+            ExactComplexRational::ONE,
+            anchors,
+            vec![2, 0, 3, 1],
+            OnTheFlyCouplingOrderPolicyV1::Minimal,
+            vec![1, 2],
+            coupling_limits,
+            pairing_classes,
+        )
+        .unwrap()
+    }
+
+    fn little_u64(bytes: &[u8], offset: usize) -> u64 {
+        u64::from_le_bytes(bytes[offset..offset + 8].try_into().unwrap())
+    }
+
+    fn normalization_length_offset() -> usize {
+        MAGIC.len() + 4 + 4 + (RETAINED_DIGEST_COUNT * DIGEST_BYTES) as usize
+    }
+
+    fn source_anchor_count_offset(bytes: &[u8]) -> usize {
+        let normalization_length_offset = normalization_length_offset();
+        normalization_length_offset + 8 + little_u64(bytes, normalization_length_offset) as usize
+    }
+
+    fn first_source_anchor_offset(bytes: &[u8]) -> usize {
+        source_anchor_count_offset(bytes) + 8
+    }
+
+    fn find_unique_bytes(bytes: &[u8], needle: &[u8]) -> usize {
+        let mut matches = bytes
+            .windows(needle.len())
+            .enumerate()
+            .filter_map(|(offset, window)| (window == needle).then_some(offset));
+        let offset = matches.next().unwrap();
+        assert!(matches.next().is_none(), "test needle is not unique");
+        offset
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_round_trips_deterministically() {
+        let canonical = ordinary_seed(false);
+        let reordered_inputs = ordinary_seed(true);
+        assert_eq!(canonical, reordered_inputs);
+        let first = encode_on_the_fly_process_seed_v1(&canonical).unwrap();
+        let second = encode_on_the_fly_process_seed_v1(&reordered_inputs).unwrap();
+        assert_eq!(first, second);
+        let decoded = decode_on_the_fly_process_seed_v1(&first).unwrap();
+        assert_eq!(decoded, canonical);
+        let identity = decoded.identity();
+        assert_eq!(identity.abi, ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI);
+        assert_eq!(identity.process_digest, digest(1).to_string());
+        assert_eq!(identity.external_permutation, [2, 0, 3, 1]);
+        assert_eq!(identity.external_sources.len(), 4);
+        assert_eq!(identity.external_sources[0].states.len(), 2);
+        assert_eq!(
+            identity.external_sources[0].states[0].prepared_mass_parameter_slot,
+            Some(400)
+        );
+        let encoded_identity = serde_json::to_string(&identity).unwrap();
+        let decoded_identity: OnTheFlyProcessSeedIdentityV1 =
+            serde_json::from_str(&encoded_identity).unwrap();
+        assert_eq!(decoded_identity, identity);
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_round_trips_multiple_unbounded_orders() {
+        let seed = ordinary_seed_with_limits(false, vec![None, None]);
+        let bytes = encode_on_the_fly_process_seed_v1(&seed).unwrap();
+        let decoded = decode_on_the_fly_process_seed_v1(&bytes).unwrap();
+
+        assert_eq!(decoded.explicit_coupling_limits(), [None, None]);
+        assert_eq!(decoded, seed);
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_preserves_live_scalar_seed_identity() {
+        let original =
+            scalar_adapter_test_seed(digest(81), digest(82), digest(83), digest(84)).unwrap();
+        let payload = encode_on_the_fly_process_seed_v1(&original).unwrap();
+        let decoded = decode_on_the_fly_process_seed_v1(&payload).unwrap();
+
+        assert_eq!(decoded.semantic_digest(), original.semantic_digest());
+        assert_eq!(decoded, original);
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_decode_encode_is_byte_identical() {
+        let bytes = encode_on_the_fly_process_seed_v1(&ordinary_seed(false)).unwrap();
+        let decoded = decode_on_the_fly_process_seed_v1(&bytes).unwrap();
+        assert_eq!(encode_on_the_fly_process_seed_v1(&decoded).unwrap(), bytes);
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_rejects_representative_truncations() {
+        let bytes = encode_on_the_fly_process_seed_v1(&ordinary_seed(false)).unwrap();
+        for length in [
+            0,
+            1,
+            MAGIC.len() - 1,
+            MAGIC.len(),
+            MAGIC.len() + 4,
+            MAGIC.len() + 8,
+            normalization_length_offset(),
+            bytes.len() / 2,
+            bytes.len() - 1,
+        ] {
+            assert!(
+                decode_on_the_fly_process_seed_v1(&bytes[..length]).is_err(),
+                "truncation at byte {length} was accepted"
+            );
+        }
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_rejects_trailing_bytes() {
+        let mut bytes = encode_on_the_fly_process_seed_v1(&ordinary_seed(false)).unwrap();
+        bytes.push(0xa5);
+        let error = decode_on_the_fly_process_seed_v1(&bytes).unwrap_err();
+        assert!(error.to_string().contains("trailing bytes"));
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_rejects_future_schema_and_hash_revisions() {
+        let bytes = encode_on_the_fly_process_seed_v1(&ordinary_seed(false)).unwrap();
+        let mut future_schema = bytes.clone();
+        future_schema[MAGIC.len()..MAGIC.len() + 4]
+            .copy_from_slice(&(SCHEMA_VERSION + 1).to_le_bytes());
+        assert!(
+            decode_on_the_fly_process_seed_v1(&future_schema)
+                .unwrap_err()
+                .to_string()
+                .contains("schema version")
+        );
+        let mut future_hash = bytes;
+        future_hash[MAGIC.len() + 4..MAGIC.len() + 8]
+            .copy_from_slice(&(SEMANTIC_HASH_REVISION + 1).to_le_bytes());
+        assert!(
+            decode_on_the_fly_process_seed_v1(&future_hash)
+                .unwrap_err()
+                .to_string()
+                .contains("semantic hash revision")
+        );
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_rejects_malformed_discriminants() {
+        let bytes = encode_on_the_fly_process_seed_v1(&ordinary_seed(false)).unwrap();
+        let anchor = first_source_anchor_offset(&bytes);
+        for (offset, expected) in [
+            (anchor + 8, "boolean discriminant"),
+            (anchor + 9, "color-role discriminant"),
+            (anchor + 11, "optional discriminant"),
+        ] {
+            let mut malformed = bytes.clone();
+            malformed[offset] = 0xff;
+            let error = decode_on_the_fly_process_seed_v1(&malformed).unwrap_err();
+            assert!(
+                error.to_string().contains(expected),
+                "unexpected malformed-discriminant error: {error}"
+            );
+        }
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_rejects_duplicate_and_noncanonical_pairing_keys() {
+        let bytes = encode_on_the_fly_process_seed_v1(&ordinary_seed(false)).unwrap();
+        let alpha = find_unique_bytes(&bytes, b"alpha");
+        let bravo = find_unique_bytes(&bytes, b"bravo");
+        for (offset, replacement) in [(bravo, b"alpha"), (alpha, b"zebra")] {
+            let mut malformed = bytes.clone();
+            malformed[offset..offset + replacement.len()].copy_from_slice(replacement);
+            let error = decode_on_the_fly_process_seed_v1(&malformed).unwrap_err();
+            assert!(
+                error.to_string().contains("canonical strict order"),
+                "unexpected pairing-key error: {error}"
+            );
+        }
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_rejects_u64_count_overflow_before_allocation() {
+        let mut bytes = encode_on_the_fly_process_seed_v1(&ordinary_seed(false)).unwrap();
+        let offset = source_anchor_count_offset(&bytes);
+        bytes[offset..offset + 8].copy_from_slice(&u64::MAX.to_le_bytes());
+        let error = decode_on_the_fly_process_seed_v1(&bytes).unwrap_err();
+        assert!(error.to_string().contains("overflows u64"));
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_rejects_count_that_cannot_fit_before_allocation() {
+        let mut bytes = encode_on_the_fly_process_seed_v1(&ordinary_seed(false)).unwrap();
+        let offset = source_anchor_count_offset(&bytes);
+        let hostile_count = u64::try_from(bytes.len()).unwrap() + 1;
+        bytes[offset..offset + 8].copy_from_slice(&hostile_count.to_le_bytes());
+        let error = decode_on_the_fly_process_seed_v1(&bytes).unwrap_err();
+        assert!(error.to_string().contains("cannot fit"));
+    }
+
+    #[test]
+    fn on_the_fly_seed_codec_checked_writer_rejects_injected_u64_overflow() {
+        let mut writer = Writer::with_bytes_written(CountingWriter::default(), u64::MAX - 1);
+        let error = writer.raw(&[1, 2]).unwrap_err();
+        assert!(error.to_string().contains("accounting overflows u64"));
+        assert_eq!(writer.destination.bytes_written, 0);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/source_builder.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/source_builder.rs
new file mode 100644
index 0000000000..f85e1dbb94
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/source_builder.rs
@@ -0,0 +1,1725 @@
+// SPDX-License-Identifier: 0BSD
+
+#![allow(dead_code)] // Generation-bridge helpers are absent from default runtime builds.
+
+//! Cold-path construction of the compact on-the-fly process seed.
+//!
+//! The source projection is process-owned but contains no materialized
+//! recurrence graph, color plan, public-flow table, or direct plan. Model
+//! semantics are recovered from the already validated recurrence-template and
+//! prepared direct-executor catalogs before the existing seed codec is used.
+
+#[cfg(test)]
+use std::cell::Cell;
+use std::collections::BTreeMap;
+
+use serde::Deserialize;
+
+use super::source_seed::{
+    OnTheFlyCouplingOrderPolicyV1, OnTheFlyExternalColorRoleV1, OnTheFlyPairingClassV1,
+    OnTheFlyPairingEndpointV1, OnTheFlyProcessSeedV1, OnTheFlySourceAnchorV1,
+    OnTheFlySourceOrientationV1, OnTheFlySourceStateV1, OnTheFlySourceWavefunctionFamilyV1,
+    validate_permutation,
+};
+use super::{TemplateCatalog, integrity, invalid};
+use crate::recurrence::process::ProcessSourceStateRow;
+use crate::recurrence::template::{
+    CurrentOrientation, CurrentStateRow, MISSING_U32, ParameterValueType, ParticleStatistics,
+    SourceRow, ValidatedRecurrenceTemplateInput,
+};
+use crate::recurrence::{
+    DirectExecutorRole, ExactComplexRational, PreparedDirectExecutorCatalog, SemanticDigest,
+};
+use crate::{RusticolError, RusticolResult};
+
+const SOURCE_PROJECTION_SCHEMA_VERSION: u32 = 1;
+
+#[cfg(test)]
+thread_local! {
+    static PROCESS_SEED_TEMPLATE_CATALOG_BUILD_COUNT: Cell<usize> = const { Cell::new(0) };
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct OnTheFlyProcessSeedProjectionV1 {
+    schema_version: u32,
+    process_digest: String,
+    external_permutation: Vec<u32>,
+    external_sources: Vec<SourceAnchorProjection>,
+    parameter_projection: Vec<ParameterProjection>,
+    coupling_order_policy: CouplingOrderPolicyProjection,
+    coupling_hierarchies: Vec<CouplingHierarchyProjection>,
+    coupling_limits: Vec<CouplingLimitProjection>,
+    fermion_pairing: Option<FermionPairingProjection>,
+    normalization: NormalizationProjection,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct SourceAnchorProjection {
+    source_slot: u32,
+    public_label: u32,
+    is_initial: bool,
+    states: Vec<SourceStateProjection>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct SourceStateProjection {
+    state_index: u32,
+    public_helicity: i32,
+    source_helicity: i32,
+    source_template_id: u32,
+    current_state_template_id: u32,
+    momentum_sign: i32,
+    crossing_phase: ExactFactorProjection,
+    spin_state: i32,
+    chirality: i32,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ParameterProjection {
+    parameter_template_id: u32,
+    prepared_parameter_id: Option<u32>,
+    component: u32,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct CouplingLimitProjection {
+    name: String,
+    maximum: u32,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(rename_all = "snake_case")]
+enum CouplingOrderPolicyProjection {
+    Minimal,
+    Explicit,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct CouplingHierarchyProjection {
+    name: String,
+    hierarchy: u32,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct FermionPairingProjection {
+    endpoints: Vec<PairingEndpointProjection>,
+    classes: Vec<PairingClassProjection>,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(rename_all = "snake_case")]
+enum PairingEndpointOrientation {
+    Fundamental,
+    Antifundamental,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct PairingEndpointProjection {
+    source_slot: u32,
+    color_orientation: PairingEndpointOrientation,
+    contract_digest: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct PairingClassProjection {
+    species: String,
+    proof_digest: String,
+    fundamental_source_slots: Vec<u32>,
+    antifundamental_source_slots: Vec<u32>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct NormalizationProjection {
+    factor: ExactFactorProjection,
+    convention: String,
+    semantic_digest: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ExactFactorProjection {
+    real_numerator: String,
+    real_denominator: String,
+    imag_numerator: String,
+    imag_denominator: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct SourceCrossingProjection {
+    momentum_transform: SourceMomentumTransformProjection,
+    helicity_factor: i32,
+    chirality_factor: i32,
+    spin_state_factor: i32,
+    phase: ExactFactorProjection,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+enum SourceMomentumTransformProjection {
+    #[serde(rename = "identity")]
+    Identity,
+    #[serde(rename = "negate-four-momentum")]
+    NegateFourMomentum,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct AppliedSourceCrossing {
+    momentum_sign: i32,
+    helicity_factor: i32,
+    chirality_factor: i32,
+    spin_state_factor: i32,
+    phase: ExactComplexRational,
+}
+
+impl AppliedSourceCrossing {
+    const IDENTITY: Self = Self {
+        momentum_sign: 1,
+        helicity_factor: 1,
+        chirality_factor: 1,
+        spin_state_factor: 1,
+        phase: ExactComplexRational::ONE,
+    };
+}
+
+impl ExactFactorProjection {
+    fn exact(&self, label: &str) -> RusticolResult<ExactComplexRational> {
+        ExactComplexRational::parse_parts(
+            &self.real_numerator,
+            &self.real_denominator,
+            &self.imag_numerator,
+            &self.imag_denominator,
+        )
+        .map_err(|error| invalid(format!("{label} is invalid: {error}")))
+    }
+}
+
+pub(crate) fn parse_on_the_fly_process_seed_projection_v1(
+    bytes: &[u8],
+) -> RusticolResult<OnTheFlyProcessSeedProjectionV1> {
+    if bytes.is_empty() {
+        return Err(invalid(
+            "on-the-fly source projection JSON must not be empty",
+        ));
+    }
+    let projection: OnTheFlyProcessSeedProjectionV1 =
+        serde_json::from_slice(bytes).map_err(|error| {
+            invalid(format!(
+                "invalid on-the-fly source projection JSON: {error}"
+            ))
+        })?;
+    if projection.schema_version != SOURCE_PROJECTION_SCHEMA_VERSION {
+        return Err(invalid(format!(
+            "unsupported on-the-fly source projection schema version {}",
+            projection.schema_version
+        )));
+    }
+    Ok(projection)
+}
+
+/// Build one compact process seed from source-only process projection and
+/// already validated model-wide catalogs.
+///
+/// This deliberately has no argument capable of carrying the established
+/// recurrence builder, a color-flow plan, a DAG, or a `DirectRecurrencePlan`.
+pub(crate) fn build_on_the_fly_process_seed_v1(
+    projection: OnTheFlyProcessSeedProjectionV1,
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct: &PreparedDirectExecutorCatalog,
+    prepared_pack_digest: SemanticDigest,
+) -> RusticolResult<OnTheFlyProcessSeedV1> {
+    let mut seeds = build_on_the_fly_process_seeds_v1(
+        vec![projection],
+        templates,
+        direct,
+        prepared_pack_digest,
+    )?;
+    seeds
+        .pop()
+        .ok_or_else(|| RusticolError::internal("singleton process-seed batch returned no seed"))
+}
+
+/// Build ordered compact process seeds while authenticating and indexing the
+/// shared model catalogs exactly once.
+pub(crate) fn build_on_the_fly_process_seeds_v1(
+    projections: Vec<OnTheFlyProcessSeedProjectionV1>,
+    templates: &ValidatedRecurrenceTemplateInput,
+    direct: &PreparedDirectExecutorCatalog,
+    prepared_pack_digest: SemanticDigest,
+) -> RusticolResult<Vec<OnTheFlyProcessSeedV1>> {
+    let summary = templates.summary();
+    if prepared_pack_digest != summary.prepared_kernel_pack_digest {
+        return Err(integrity(
+            "on-the-fly source projection names a different prepared-kernel pack",
+        ));
+    }
+
+    #[cfg(test)]
+    PROCESS_SEED_TEMPLATE_CATALOG_BUILD_COUNT.with(|count| count.set(count.get() + 1));
+    let template_catalog = TemplateCatalog::new(templates.input())?;
+    let mut seeds = Vec::new();
+    seeds
+        .try_reserve_exact(projections.len())
+        .map_err(|error| invalid(format!("process-seed allocation failed: {error}")))?;
+    for (index, projection) in projections.into_iter().enumerate() {
+        let process_digest = projection.process_digest.clone();
+        let seed = build_on_the_fly_process_seed_from_catalog_v1(
+            projection,
+            templates,
+            &template_catalog,
+            direct,
+            prepared_pack_digest,
+        )
+        .map_err(|error| {
+            RusticolError::with_kind(
+                error.kind(),
+                format!(
+                    "on-the-fly process seed at index {index} (process digest {process_digest:?}) failed: {error}"
+                ),
+            )
+        })?;
+        seeds.push(seed);
+    }
+    Ok(seeds)
+}
+
+fn build_on_the_fly_process_seed_from_catalog_v1(
+    projection: OnTheFlyProcessSeedProjectionV1,
+    templates: &ValidatedRecurrenceTemplateInput,
+    template_catalog: &TemplateCatalog<'_>,
+    direct: &PreparedDirectExecutorCatalog,
+    prepared_pack_digest: SemanticDigest,
+) -> RusticolResult<OnTheFlyProcessSeedV1> {
+    let summary = templates.summary();
+    validate_permutation(
+        &projection.external_permutation,
+        projection.external_sources.len(),
+        "source-projection external permutation",
+    )?;
+
+    let endpoint_contracts = pairing_endpoint_contracts(projection.fermion_pairing.as_ref())?;
+    validate_parameter_projection(&projection.parameter_projection)?;
+    let source_anchors = source_anchors(
+        &projection.external_sources,
+        templates,
+        template_catalog,
+        direct,
+        &endpoint_contracts,
+        &projection.parameter_projection,
+    )?;
+    let pairing_classes =
+        pairing_classes(projection.fermion_pairing.as_ref(), &endpoint_contracts)?;
+    let (coupling_order_policy, coupling_hierarchies, coupling_limits) = coupling_policy(
+        projection.coupling_order_policy,
+        &projection.coupling_hierarchies,
+        &projection.coupling_limits,
+        template_catalog,
+    )?;
+    let normalization_factor = projection
+        .normalization
+        .factor
+        .exact("on-the-fly normalization factor")?;
+
+    OnTheFlyProcessSeedV1::new(
+        parse_digest(&projection.process_digest, "process digest")?,
+        summary.compiled_model_digest,
+        summary.catalog_digest,
+        prepared_pack_digest,
+        direct.direct_template_catalog_digest(),
+        parse_digest(
+            &projection.normalization.semantic_digest,
+            "normalization semantic digest",
+        )?,
+        projection.normalization.convention,
+        normalization_factor,
+        source_anchors,
+        projection.external_permutation,
+        coupling_order_policy,
+        coupling_hierarchies,
+        coupling_limits,
+        pairing_classes,
+    )
+}
+
+fn source_anchors(
+    projections: &[SourceAnchorProjection],
+    templates: &ValidatedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+    direct: &PreparedDirectExecutorCatalog,
+    endpoint_contracts: &BTreeMap<u32, (OnTheFlyExternalColorRoleV1, SemanticDigest)>,
+    parameter_projection: &[ParameterProjection],
+) -> RusticolResult<Vec<OnTheFlySourceAnchorV1>> {
+    let input = templates.input();
+    let mut anchors = Vec::new();
+    anchors
+        .try_reserve_exact(projections.len())
+        .map_err(|error| invalid(format!("source-anchor allocation failed: {error}")))?;
+    for projection in projections {
+        let mut states = Vec::new();
+        states
+            .try_reserve_exact(projection.states.len())
+            .map_err(|error| invalid(format!("source-state allocation failed: {error}")))?;
+        let mut role = None;
+        let mut anchor_fermionic = None;
+        let mut pairing_contract = None;
+        for state in &projection.states {
+            let source = canonical_source(input, state.source_template_id)?;
+            let current_state = canonical_current_state(input, state.current_state_template_id)?;
+            validate_source_projection(
+                projection.source_slot,
+                projection.is_initial,
+                state,
+                source,
+                current_state,
+                input,
+                catalog,
+            )?;
+            direct.resolve_evaluator(DirectExecutorRole::Source, source.evaluator_binding_id)?;
+            let family = source_family(catalog, source, current_state)?;
+            let (state_role, state_pairing_contract) = color_role(
+                current_state.color_representation,
+                endpoint_contracts.get(&projection.source_slot).copied(),
+            )?;
+            merge_equal(&mut role, state_role, "one source anchor mixes color roles")?;
+            merge_equal(
+                &mut anchor_fermionic,
+                family.is_fermionic(),
+                "one source anchor mixes statistics",
+            )?;
+            merge_equal_option(
+                &mut pairing_contract,
+                state_pairing_contract,
+                "one source anchor mixes pairing contracts",
+            )?;
+            let color_seed = catalog.source_seed(source)?;
+            states.push(OnTheFlySourceStateV1::new(
+                state.state_index,
+                state.public_helicity,
+                state.source_helicity,
+                source.id,
+                current_state.id,
+                catalog.digest(source.semantic_digest_id, "source semantic")?,
+                catalog.digest(current_state.semantic_digest_id, "current-state semantic")?,
+                state.momentum_sign,
+                state.crossing_phase.exact("source crossing phase")?,
+                state.spin_state,
+                state.chirality,
+                catalog
+                    .flavour_flow(source.flavour_flow_id, "source flavour flow")?
+                    .to_vec(),
+                source.quantum_number_flow_id,
+                color_seed.proof_digest(),
+                family,
+                source_orientation(current_state)?,
+                resolve_prepared_mass_slot(
+                    source,
+                    current_state,
+                    input,
+                    catalog,
+                    parameter_projection.iter().map(|row| {
+                        (
+                            row.parameter_template_id,
+                            row.prepared_parameter_id,
+                            row.component,
+                        )
+                    }),
+                )?,
+            )?);
+        }
+        anchors.push(OnTheFlySourceAnchorV1::new(
+            projection.source_slot,
+            projection.public_label,
+            projection.is_initial,
+            role.ok_or_else(|| integrity("source anchor is empty"))?,
+            anchor_fermionic.ok_or_else(|| integrity("source statistics are absent"))?,
+            pairing_contract,
+            states,
+        )?);
+    }
+    Ok(anchors)
+}
+
+fn canonical_source(
+    input: &crate::recurrence::template::OwnedRecurrenceTemplateInput,
+    source_template_id: u32,
+) -> RusticolResult<SourceRow> {
+    let source = *input
+        .sources
+        .get(source_template_id as usize)
+        .ok_or_else(|| integrity("source template is absent"))?;
+    if source.id != source_template_id {
+        return Err(integrity("source-template catalog is not canonical"));
+    }
+    Ok(source)
+}
+
+fn canonical_current_state(
+    input: &crate::recurrence::template::OwnedRecurrenceTemplateInput,
+    current_state_template_id: u32,
+) -> RusticolResult<CurrentStateRow> {
+    let state = *input
+        .current_states
+        .get(current_state_template_id as usize)
+        .ok_or_else(|| integrity("current-state template is absent"))?;
+    if state.id != current_state_template_id {
+        return Err(integrity("current-state catalog is not canonical"));
+    }
+    Ok(state)
+}
+
+fn validate_source_projection(
+    source_slot: u32,
+    is_initial: bool,
+    projected: &SourceStateProjection,
+    source: SourceRow,
+    effective: CurrentStateRow,
+    input: &crate::recurrence::template::OwnedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<()> {
+    let canonical = canonical_current_state(input, source.state_template_id)?;
+    super::validate_crossed_source_state(
+        is_initial,
+        &ProcessSourceStateRow {
+            source_slot,
+            state_index: projected.state_index,
+            public_helicity: projected.public_helicity,
+            chirality: projected.chirality,
+            spin_state: projected.spin_state,
+            current_state_template_id: projected.current_state_template_id,
+            source_template_id: projected.source_template_id,
+            momentum_sign: projected.momentum_sign,
+            crossing_phase_factor_id: 0,
+        },
+        source,
+        input,
+    )?;
+
+    let crossing = applied_source_crossing(is_initial, source, catalog)?;
+    let expected_helicity = source
+        .helicity
+        .checked_mul(crossing.helicity_factor)
+        .ok_or_else(|| integrity("source crossing overflows the helicity state"))?;
+    let expected_chirality = canonical
+        .chirality
+        .checked_mul(crossing.chirality_factor)
+        .ok_or_else(|| integrity("source crossing overflows the chirality state"))?;
+    let expected_spin_state = source
+        .spin_state
+        .checked_mul(crossing.spin_state_factor)
+        .ok_or_else(|| integrity("source crossing overflows the spin state"))?;
+    let projected_phase = projected.crossing_phase.exact("source crossing phase")?;
+    if projected.public_helicity != expected_helicity
+        || projected.source_helicity != expected_helicity
+        || projected.chirality != expected_chirality
+        || effective.chirality != expected_chirality
+        || projected.spin_state != expected_spin_state
+        || projected.momentum_sign != crossing.momentum_sign
+        || projected_phase != crossing.phase
+    {
+        return Err(integrity(
+            "crossed source execution values disagree with their prepared source/current templates",
+        ));
+    }
+    Ok(())
+}
+
+fn applied_source_crossing(
+    is_initial: bool,
+    source: SourceRow,
+    catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<AppliedSourceCrossing> {
+    if !is_initial {
+        return Ok(AppliedSourceCrossing::IDENTITY);
+    }
+    let encoded = catalog.string(source.crossing_string_id, "source crossing")?;
+    let crossing: SourceCrossingProjection = serde_json::from_str(encoded)
+        .map_err(|error| integrity(format!("source crossing contract is invalid: {error}")))?;
+    if !matches!(crossing.helicity_factor, -1 | 1)
+        || !matches!(crossing.chirality_factor, -1 | 1)
+        || !matches!(crossing.spin_state_factor, -1 | 1)
+    {
+        return Err(integrity(
+            "source crossing contract has a non-sign state factor",
+        ));
+    }
+    let phase = crossing.phase.exact("source crossing phase")?;
+    if phase.is_zero() {
+        return Err(integrity("source crossing phase is zero"));
+    }
+    Ok(AppliedSourceCrossing {
+        momentum_sign: match crossing.momentum_transform {
+            SourceMomentumTransformProjection::Identity => 1,
+            SourceMomentumTransformProjection::NegateFourMomentum => -1,
+        },
+        helicity_factor: crossing.helicity_factor,
+        chirality_factor: crossing.chirality_factor,
+        spin_state_factor: crossing.spin_state_factor,
+        phase,
+    })
+}
+
+fn source_family(
+    catalog: &TemplateCatalog<'_>,
+    source: SourceRow,
+    current_state: CurrentStateRow,
+) -> RusticolResult<OnTheFlySourceWavefunctionFamilyV1> {
+    let family = catalog.string(
+        source.wavefunction_family_string_id,
+        "source wavefunction family",
+    )?;
+    let statistics = ParticleStatistics::try_from(current_state.statistics)?;
+    match (family, statistics, current_state.dimension) {
+        ("scalar", ParticleStatistics::Boson, 1) => Ok(OnTheFlySourceWavefunctionFamilyV1::Scalar),
+        ("fermion", ParticleStatistics::Fermion, 2) => {
+            Ok(OnTheFlySourceWavefunctionFamilyV1::WeylFermion)
+        }
+        ("fermion", ParticleStatistics::Fermion, 4) => {
+            Ok(OnTheFlySourceWavefunctionFamilyV1::DiracFermion)
+        }
+        ("vector", ParticleStatistics::Boson, 4) => Ok(OnTheFlySourceWavefunctionFamilyV1::Vector),
+        ("spin2", ParticleStatistics::Boson, 16) => Ok(OnTheFlySourceWavefunctionFamilyV1::Spin2),
+        ("ghost" | "auxiliary", _, _) => Err(invalid(
+            "on-the-fly source execution does not support ghost or auxiliary external states",
+        )),
+        _ => Err(integrity(
+            "source family, statistics, and component dimension disagree",
+        )),
+    }
+}
+
+fn source_orientation(
+    current_state: CurrentStateRow,
+) -> RusticolResult<OnTheFlySourceOrientationV1> {
+    Ok(
+        match CurrentOrientation::try_from(current_state.orientation)? {
+            CurrentOrientation::Particle => OnTheFlySourceOrientationV1::Particle,
+            CurrentOrientation::Antiparticle => OnTheFlySourceOrientationV1::Antiparticle,
+            CurrentOrientation::SelfConjugate => OnTheFlySourceOrientationV1::SelfConjugate,
+        },
+    )
+}
+
+fn color_role(
+    representation: i32,
+    endpoint: Option<(OnTheFlyExternalColorRoleV1, SemanticDigest)>,
+) -> RusticolResult<(OnTheFlyExternalColorRoleV1, Option<SemanticDigest>)> {
+    match (representation, endpoint) {
+        (1, None) => Ok((OnTheFlyExternalColorRoleV1::Singlet, None)),
+        (8, None) => Ok((OnTheFlyExternalColorRoleV1::Adjoint, None)),
+        (3, Some((OnTheFlyExternalColorRoleV1::Fundamental, digest))) => {
+            Ok((OnTheFlyExternalColorRoleV1::Fundamental, Some(digest)))
+        }
+        (-3, Some((OnTheFlyExternalColorRoleV1::Antifundamental, digest))) => {
+            Ok((OnTheFlyExternalColorRoleV1::Antifundamental, Some(digest)))
+        }
+        _ => Err(integrity(
+            "source color representation disagrees with the compact pairing endpoints",
+        )),
+    }
+}
+
+fn validate_parameter_projection(rows: &[ParameterProjection]) -> RusticolResult<()> {
+    let mut result = BTreeMap::new();
+    for row in rows.iter().filter(|row| row.component == 0) {
+        let Some(prepared) = row.prepared_parameter_id else {
+            continue;
+        };
+        if result.insert(row.parameter_template_id, prepared).is_some() {
+            return Err(integrity(
+                "parameter projection repeats a real prepared parameter",
+            ));
+        }
+    }
+    Ok(())
+}
+
+/// Resolve the prepared real-parameter slot used by one authenticated source.
+///
+/// Explicit template IDs remain authoritative. Legacy catalogs in which both
+/// source rows omit that ID may recover it only from the exact canonical
+/// particle-mass parameter name authenticated by the current-state
+/// orientation. Keeping this resolver shared with the feature-only oracle
+/// prevents diagnostic reconstruction from silently using different mass
+/// semantics than the compact production seed.
+pub(super) fn resolve_prepared_mass_slot(
+    source: SourceRow,
+    current_state: CurrentStateRow,
+    input: &crate::recurrence::template::OwnedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+    projection: impl IntoIterator<Item = (u32, Option<u32>, u32)>,
+) -> RusticolResult<Option<u32>> {
+    if source.mass_parameter_id != current_state.mass_parameter_id {
+        return Err(integrity(
+            "source and current state disagree on their mass parameter",
+        ));
+    }
+
+    let parameter_id = if source.mass_parameter_id != MISSING_U32 {
+        source.mass_parameter_id
+    } else {
+        let canonical_particle = match CurrentOrientation::try_from(current_state.orientation)? {
+            CurrentOrientation::Particle => current_state.particle_id,
+            CurrentOrientation::Antiparticle => current_state.anti_particle_id,
+            CurrentOrientation::SelfConjugate => {
+                if current_state.particle_id != current_state.anti_particle_id {
+                    return Err(integrity(
+                        "self-conjugate source mass orientation has distinct particle labels",
+                    ));
+                }
+                current_state.particle_id
+            }
+        };
+        let expected_name = format!("particle.{canonical_particle}.mass");
+        let mut match_id = None;
+        for (index, parameter) in input.parameters.iter().enumerate() {
+            if usize::try_from(parameter.id).ok() != Some(index) {
+                return Err(integrity("mass parameter catalog is not canonical"));
+            }
+            if catalog.string(parameter.name_string_id, "mass parameter name")? != expected_name {
+                continue;
+            }
+            if match_id.replace(parameter.id).is_some() {
+                return Err(integrity(format!(
+                    "canonical source mass parameter {expected_name:?} is ambiguous"
+                )));
+            }
+        }
+        let Some(parameter_id) = match_id else {
+            return Ok(None);
+        };
+        parameter_id
+    };
+
+    let parameter = input
+        .parameters
+        .get(parameter_id as usize)
+        .ok_or_else(|| integrity("source mass parameter is absent"))?;
+    if parameter.id != parameter_id {
+        return Err(integrity("source mass parameter catalog is not canonical"));
+    }
+    if ParameterValueType::try_from(parameter.value_type)? != ParameterValueType::Real {
+        return Err(integrity("source mass parameter is not real"));
+    }
+    let catalog_prepared = parameter.prepared_parameter_id;
+    if catalog_prepared == MISSING_U32 {
+        return Err(invalid(
+            "source mass parameter has no prepared execution slot",
+        ));
+    }
+    let prepared_slot = usize::try_from(catalog_prepared)
+        .map_err(|_| integrity("source mass prepared slot exceeds usize"))?;
+    if prepared_slot >= input.parameters.len() {
+        return Err(integrity(
+            "source mass prepared slot is outside the dense parameter arena",
+        ));
+    }
+    if input
+        .parameters
+        .iter()
+        .filter(|candidate| candidate.prepared_parameter_id == catalog_prepared)
+        .count()
+        != 1
+    {
+        return Err(integrity(
+            "source mass prepared slot has conflicting catalog owners",
+        ));
+    }
+
+    let matches = projection
+        .into_iter()
+        .filter(|(projected_id, _, component)| *projected_id == parameter_id && *component == 0)
+        .collect::<Vec<_>>();
+    let [(_, projected_prepared, _)] = matches.as_slice() else {
+        return Err(integrity(format!(
+            "source mass parameter has {} component-0 projections, expected one",
+            matches.len()
+        )));
+    };
+    let projected_prepared = (*projected_prepared)
+        .ok_or_else(|| invalid("source mass parameter has no prepared real projection"))?;
+    if projected_prepared != catalog_prepared {
+        return Err(integrity(
+            "source mass projection disagrees with the prepared template catalog",
+        ));
+    }
+    Ok(Some(catalog_prepared))
+}
+
+/// Rebind every decoded seed source to the authenticated model-wide parameter
+/// catalog before the runtime turns its prepared slots into executor inputs.
+/// This is a cold load-time check; selected-query execution never reaches it.
+pub(crate) fn validate_on_the_fly_source_mass_bindings_v1(
+    seed: &OnTheFlyProcessSeedV1,
+    templates: &ValidatedRecurrenceTemplateInput,
+    parameter_projection: &[(u32, Option<u32>, u32)],
+) -> RusticolResult<()> {
+    let input = templates.input();
+    let catalog = TemplateCatalog::new(input)?;
+    for anchor in seed.source_anchors() {
+        for state in anchor.states() {
+            let source = canonical_source(input, state.source_template_id)?;
+            let current_state = canonical_current_state(input, state.current_state_template_id)?;
+            let expected = resolve_prepared_mass_slot(
+                source,
+                current_state,
+                input,
+                &catalog,
+                parameter_projection.iter().copied(),
+            )?;
+            if state.prepared_mass_parameter_slot != expected {
+                return Err(integrity(
+                    "on-the-fly source prepared mass slot disagrees with the authenticated recurrence template",
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn coupling_policy(
+    policy: CouplingOrderPolicyProjection,
+    hierarchy_rows: &[CouplingHierarchyProjection],
+    limit_rows: &[CouplingLimitProjection],
+    templates: &TemplateCatalog<'_>,
+) -> RusticolResult<(OnTheFlyCouplingOrderPolicyV1, Vec<u32>, Vec<Option<u32>>)> {
+    let mut hierarchies_by_name = BTreeMap::new();
+    for row in hierarchy_rows {
+        if row.name.is_empty()
+            || row.hierarchy == 0
+            || hierarchies_by_name
+                .insert(row.name.as_str(), row.hierarchy)
+                .is_some()
+        {
+            return Err(invalid(
+                "coupling hierarchies require nonempty unique names and positive weights",
+            ));
+        }
+    }
+    let mut limits_by_name = BTreeMap::new();
+    for row in limit_rows {
+        if row.name.is_empty()
+            || limits_by_name
+                .insert(row.name.as_str(), row.maximum)
+                .is_some()
+        {
+            return Err(invalid(
+                "coupling limits require nonempty unique model-order names",
+            ));
+        }
+    }
+    let expected = templates.coupling_order_names();
+    if limit_rows
+        .iter()
+        .any(|row| expected.binary_search(&row.name.as_str()).is_err())
+    {
+        return Err(integrity(
+            "source projection names a coupling limit absent from the template catalog",
+        ));
+    }
+    let hierarchies = expected
+        .iter()
+        .map(|name| {
+            hierarchies_by_name.get(name).copied().ok_or_else(|| {
+                integrity(format!(
+                    "source projection has no coupling hierarchy for model order {name:?}"
+                ))
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let limits = expected
+        .iter()
+        .map(|name| limits_by_name.get(name).copied())
+        .collect::<Vec<_>>();
+    if hierarchies_by_name.len() != expected.len() || limits_by_name.len() > expected.len() {
+        return Err(integrity(
+            "source projection names a coupling hierarchy or limit absent from the template catalog",
+        ));
+    }
+    Ok((
+        match policy {
+            CouplingOrderPolicyProjection::Minimal => OnTheFlyCouplingOrderPolicyV1::Minimal,
+            CouplingOrderPolicyProjection::Explicit => OnTheFlyCouplingOrderPolicyV1::Explicit,
+        },
+        hierarchies,
+        limits,
+    ))
+}
+
+fn pairing_endpoint_contracts(
+    pairing: Option<&FermionPairingProjection>,
+) -> RusticolResult<BTreeMap<u32, (OnTheFlyExternalColorRoleV1, SemanticDigest)>> {
+    let Some(pairing) = pairing else {
+        return Ok(BTreeMap::new());
+    };
+    let mut result = BTreeMap::new();
+    for endpoint in &pairing.endpoints {
+        let role = match endpoint.color_orientation {
+            PairingEndpointOrientation::Fundamental => OnTheFlyExternalColorRoleV1::Fundamental,
+            PairingEndpointOrientation::Antifundamental => {
+                OnTheFlyExternalColorRoleV1::Antifundamental
+            }
+        };
+        let digest = parse_digest(
+            &endpoint.contract_digest,
+            "pairing endpoint contract digest",
+        )?;
+        if result
+            .insert(endpoint.source_slot, (role, digest))
+            .is_some()
+        {
+            return Err(integrity("pairing endpoint repeats a source slot"));
+        }
+    }
+    Ok(result)
+}
+
+fn pairing_classes(
+    pairing: Option<&FermionPairingProjection>,
+    contracts: &BTreeMap<u32, (OnTheFlyExternalColorRoleV1, SemanticDigest)>,
+) -> RusticolResult<Vec<OnTheFlyPairingClassV1>> {
+    let Some(pairing) = pairing else {
+        if contracts.is_empty() {
+            return Ok(Vec::new());
+        }
+        return Err(integrity("pairing endpoints have no pairing classes"));
+    };
+    pairing
+        .classes
+        .iter()
+        .map(|class| {
+            let endpoints = |slots: &[u32],
+                             role: OnTheFlyExternalColorRoleV1|
+             -> RusticolResult<Vec<OnTheFlyPairingEndpointV1>> {
+                slots
+                    .iter()
+                    .copied()
+                    .map(|source_slot| {
+                        let (actual_role, digest) = contracts
+                            .get(&source_slot)
+                            .copied()
+                            .ok_or_else(|| integrity("pairing class endpoint is absent"))?;
+                        if actual_role != role {
+                            return Err(integrity("pairing class endpoint role changed"));
+                        }
+                        Ok(OnTheFlyPairingEndpointV1 {
+                            source_slot,
+                            source_contract_digest: digest,
+                        })
+                    })
+                    .collect()
+            };
+            OnTheFlyPairingClassV1::new(
+                class.species.as_str(),
+                parse_digest(&class.proof_digest, "pairing class proof digest")?,
+                endpoints(
+                    &class.fundamental_source_slots,
+                    OnTheFlyExternalColorRoleV1::Fundamental,
+                )?,
+                endpoints(
+                    &class.antifundamental_source_slots,
+                    OnTheFlyExternalColorRoleV1::Antifundamental,
+                )?,
+            )
+        })
+        .collect()
+}
+
+fn parse_digest(value: &str, label: &str) -> RusticolResult<SemanticDigest> {
+    if value.len() != 64
+        || !value
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f'))
+    {
+        return Err(invalid(format!(
+            "{label} must be a lowercase SHA-256 digest"
+        )));
+    }
+    let mut bytes = [0_u8; 32];
+    for (index, byte) in bytes.iter_mut().enumerate() {
+        let offset = index * 2;
+        *byte = u8::from_str_radix(&value[offset..offset + 2], 16)
+            .map_err(|_| invalid(format!("{label} is not hexadecimal")))?;
+    }
+    SemanticDigest::new(bytes).map_err(|error| RusticolError::integrity(error.message()))
+}
+
+fn merge_equal<T: Copy + Eq>(slot: &mut Option<T>, value: T, message: &str) -> RusticolResult<()> {
+    match slot {
+        None => *slot = Some(value),
+        Some(previous) if *previous == value => {}
+        Some(_) => return Err(integrity(message)),
+    }
+    Ok(())
+}
+
+fn merge_equal_option<T: Copy + Eq>(
+    slot: &mut Option<T>,
+    value: Option<T>,
+    message: &str,
+) -> RusticolResult<()> {
+    match (*slot, value) {
+        (None, Some(value)) => *slot = Some(value),
+        (None, None) | (Some(_), None) => {}
+        (Some(previous), Some(value)) if previous == value => {}
+        (Some(_), Some(_)) => return Err(integrity(message)),
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::on_the_fly::seed_codec::{
+        decode_on_the_fly_process_seed_v1, encode_on_the_fly_process_seed_v1,
+    };
+    use crate::recurrence::on_the_fly::{OnTheFlyForbiddenWorkGuardV1, scalar_adapter_test_seed};
+    use crate::recurrence::template::{
+        CouplingOrderTermRow, IndexedRangeRow, ParameterKind, ParameterRow, ParameterValueType,
+    };
+    use crate::recurrence::{
+        CheckedTableRange, PreparedDirectExecutorBinding, validated_template_fixture,
+    };
+    use serde_json::{Value, json};
+
+    fn digest(seed: u8) -> SemanticDigest {
+        SemanticDigest::new([seed; 32]).unwrap()
+    }
+
+    fn scalar_inputs() -> (
+        Value,
+        ValidatedRecurrenceTemplateInput,
+        PreparedDirectExecutorCatalog,
+    ) {
+        let mut input = validated_template_fixture().into_input();
+        input.coupling_order_ranges.push(IndexedRangeRow {
+            id: 1,
+            range: CheckedTableRange::new(0, 1),
+        });
+        input.coupling_order_terms.push(CouplingOrderTermRow {
+            set_id: 1,
+            name_string_id: 0,
+            power: 1,
+        });
+        let templates = input.validate().unwrap();
+        let direct = PreparedDirectExecutorCatalog::new(
+            digest(40),
+            vec![
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Source, 0, 0),
+                PreparedDirectExecutorBinding::evaluator(DirectExecutorRole::Closure, 3, 1),
+                PreparedDirectExecutorBinding::identity_finalizer(2),
+            ],
+        )
+        .unwrap();
+        let source = json!({
+            "schema_version": 1,
+            "process_digest": digest(91).to_string(),
+            "external_permutation": [0, 1],
+            "external_sources": [
+                {
+                    "source_slot": 0,
+                    "public_label": 0,
+                    "is_initial": false,
+                    "states": [{
+                        "state_index": 0,
+                        "public_helicity": 0,
+                        "source_helicity": 0,
+                        "source_template_id": 0,
+                        "current_state_template_id": 0,
+                        "momentum_sign": 1,
+                        "crossing_phase": {
+                            "real_numerator": "1", "real_denominator": "1",
+                            "imag_numerator": "0", "imag_denominator": "1"
+                        },
+                        "spin_state": 50000,
+                        "chirality": 0
+                    }]
+                },
+                {
+                    "source_slot": 1,
+                    "public_label": 1,
+                    "is_initial": false,
+                    "states": [{
+                        "state_index": 0,
+                        "public_helicity": 0,
+                        "source_helicity": 0,
+                        "source_template_id": 0,
+                        "current_state_template_id": 0,
+                        "momentum_sign": 1,
+                        "crossing_phase": {
+                            "real_numerator": "1", "real_denominator": "1",
+                            "imag_numerator": "0", "imag_denominator": "1"
+                        },
+                        "spin_state": 50000,
+                        "chirality": 0
+                    }]
+                }
+            ],
+            "parameter_projection": [],
+            "coupling_order_policy": "explicit",
+            "coupling_hierarchies": [{"name": "0", "hierarchy": 1}],
+            "coupling_limits": [{"name": "0", "maximum": 0}],
+            "fermion_pairing": null,
+            "normalization": {
+                "factor": {
+                    "real_numerator": "1", "real_denominator": "1",
+                    "imag_numerator": "0", "imag_denominator": "1"
+                },
+                "convention": "raw-amplitude-test",
+                "semantic_digest": digest(92).to_string()
+            }
+        });
+        (source, templates, direct)
+    }
+
+    fn crossed_scalar_inputs() -> (
+        Value,
+        ValidatedRecurrenceTemplateInput,
+        PreparedDirectExecutorCatalog,
+    ) {
+        let (mut projection, templates, direct) = scalar_inputs();
+        let mut input = templates.into_input();
+        let crossing = serde_json::to_vec(&json!({
+            "chirality_factor": -1,
+            "helicity_factor": -1,
+            "momentum_transform": "negate-four-momentum",
+            "phase": {
+                "imag_denominator": "1",
+                "imag_numerator": "0",
+                "real_denominator": "1",
+                "real_numerator": "-1"
+            },
+            "spin_state_factor": -1
+        }))
+        .unwrap();
+        let previous = input.string_ranges.last().unwrap();
+        let previous = previous
+            .as_usize_range(input.string_bytes.len(), "template string")
+            .unwrap();
+        assert!(&input.string_bytes[previous] < crossing.as_slice());
+        let crossing_string_id = u32::try_from(input.string_ranges.len()).unwrap();
+        input.string_ranges.push(CheckedTableRange::new(
+            u64::try_from(input.string_bytes.len()).unwrap(),
+            u64::try_from(crossing.len()).unwrap(),
+        ));
+        input.string_bytes.extend_from_slice(&crossing);
+        input.sources[0].crossing_string_id = crossing_string_id;
+        input.sources[0].helicity = 1;
+        let templates = input.validate().unwrap();
+
+        for source_slot in 0..2 {
+            projection["external_sources"][source_slot]["is_initial"] = json!(true);
+            let state = &mut projection["external_sources"][source_slot]["states"][0];
+            state["public_helicity"] = json!(-1);
+            state["source_helicity"] = json!(-1);
+            state["momentum_sign"] = json!(-1);
+            state["crossing_phase"]["real_numerator"] = json!("-1");
+            state["spin_state"] = json!(-50_000);
+        }
+        (projection, templates, direct)
+    }
+
+    fn mass_bound_scalar_inputs() -> (
+        Value,
+        ValidatedRecurrenceTemplateInput,
+        PreparedDirectExecutorCatalog,
+    ) {
+        let (mut projection, templates, direct) = scalar_inputs();
+        let mut input = templates.into_input();
+        let source_evaluator = input.evaluator_bindings[0];
+        input.catalog_header[0].parameter_count = 1;
+        input.parameters.push(ParameterRow {
+            id: 0,
+            template_string_id: source_evaluator.resolver_key_string_id,
+            name_string_id: source_evaluator.resolver_key_string_id,
+            kind: ParameterKind::External as u8,
+            value_type: ParameterValueType::Real as u8,
+            mutable: 1,
+            default_factor_id: 0,
+            exact_expression_digest_id: MISSING_U32,
+            dependency_sequence_id: source_evaluator.input_state_sequence_id,
+            prepared_parameter_id: 0,
+            semantic_digest_id: source_evaluator.callable_signature_digest_id,
+        });
+        input.current_states[0].mass_parameter_id = 0;
+        input.sources[0].mass_parameter_id = 0;
+        projection["parameter_projection"] = json!([{
+            "parameter_template_id": 0,
+            "prepared_parameter_id": 0,
+            "component": 0
+        }]);
+        (projection, input.validate().unwrap(), direct)
+    }
+
+    fn replace_template_string(
+        input: &mut crate::recurrence::template::OwnedRecurrenceTemplateInput,
+        old: &str,
+        new: &str,
+    ) -> u32 {
+        let mut strings = input
+            .string_ranges
+            .iter()
+            .map(|range| {
+                let range = range
+                    .as_usize_range(input.string_bytes.len(), "test template string")
+                    .unwrap();
+                std::str::from_utf8(&input.string_bytes[range])
+                    .unwrap()
+                    .to_owned()
+            })
+            .collect::<Vec<_>>();
+        let id = strings.iter().position(|value| value == old).unwrap();
+        strings[id] = new.to_owned();
+        assert!(strings.windows(2).all(|pair| pair[0] < pair[1]));
+
+        input.string_ranges.clear();
+        input.string_bytes.clear();
+        for value in strings {
+            input.string_ranges.push(CheckedTableRange::new(
+                u64::try_from(input.string_bytes.len()).unwrap(),
+                u64::try_from(value.len()).unwrap(),
+            ));
+            input.string_bytes.extend_from_slice(value.as_bytes());
+        }
+        u32::try_from(id).unwrap()
+    }
+
+    fn legacy_null_mass_inputs(
+        particle_id: i32,
+        anti_particle_id: i32,
+        orientation: CurrentOrientation,
+    ) -> (
+        Value,
+        ValidatedRecurrenceTemplateInput,
+        PreparedDirectExecutorCatalog,
+    ) {
+        let (mut projection, templates, direct) = scalar_inputs();
+        let mut input = templates.into_input();
+        let source_evaluator = input.evaluator_bindings[0];
+        let mass_name_string_id =
+            replace_template_string(&mut input, "projection", "particle.6.mass");
+        input.catalog_header[0].parameter_count = 1;
+        input.parameters.push(ParameterRow {
+            id: 0,
+            template_string_id: source_evaluator.resolver_key_string_id,
+            name_string_id: mass_name_string_id,
+            kind: ParameterKind::External as u8,
+            value_type: ParameterValueType::Real as u8,
+            mutable: 1,
+            default_factor_id: 0,
+            exact_expression_digest_id: MISSING_U32,
+            dependency_sequence_id: source_evaluator.input_state_sequence_id,
+            prepared_parameter_id: 0,
+            semantic_digest_id: source_evaluator.callable_signature_digest_id,
+        });
+        input.current_states[0].particle_id = particle_id;
+        input.current_states[0].anti_particle_id = anti_particle_id;
+        input.current_states[0].orientation = orientation as u8;
+        input.flavour_flow_values[0] = particle_id;
+        assert_eq!(input.current_states[0].mass_parameter_id, MISSING_U32);
+        assert_eq!(input.sources[0].mass_parameter_id, MISSING_U32);
+        projection["parameter_projection"] = json!([{
+            "parameter_template_id": 0,
+            "prepared_parameter_id": 0,
+            "component": 0
+        }]);
+        (projection, input.validate().unwrap(), direct)
+    }
+
+    fn build_test_seed(
+        source: &Value,
+        templates: &ValidatedRecurrenceTemplateInput,
+        direct: &PreparedDirectExecutorCatalog,
+    ) -> RusticolResult<OnTheFlyProcessSeedV1> {
+        build_on_the_fly_process_seed_v1(
+            parse_on_the_fly_process_seed_projection_v1(&serde_json::to_vec(source).unwrap())?,
+            templates,
+            direct,
+            templates.summary().prepared_kernel_pack_digest,
+        )
+    }
+
+    #[test]
+    fn compact_projection_matches_the_established_seed_codec_exactly() {
+        let (source, templates, direct) = scalar_inputs();
+        let bytes = serde_json::to_vec(&source).unwrap();
+        let projection = parse_on_the_fly_process_seed_projection_v1(&bytes).unwrap();
+        let guard = OnTheFlyForbiddenWorkGuardV1::begin().unwrap();
+        let seed = build_on_the_fly_process_seed_v1(
+            projection,
+            &templates,
+            &direct,
+            templates.summary().prepared_kernel_pack_digest,
+        )
+        .unwrap();
+        let forbidden = guard.finish().unwrap();
+        assert_eq!(forbidden.direct_plan_load_attempts, 0);
+        assert_eq!(forbidden.direct_plan_decode_attempts, 0);
+        assert_eq!(forbidden.direct_plan_materialization_attempts, 0);
+        assert_eq!(forbidden.established_builder_attempts, 0);
+
+        let expected = scalar_adapter_test_seed(
+            templates.summary().compiled_model_digest,
+            templates.summary().catalog_digest,
+            templates.summary().prepared_kernel_pack_digest,
+            direct.direct_template_catalog_digest(),
+        )
+        .unwrap();
+        assert_eq!(seed, expected);
+        assert_eq!(
+            encode_on_the_fly_process_seed_v1(&seed).unwrap(),
+            encode_on_the_fly_process_seed_v1(&expected).unwrap()
+        );
+    }
+
+    #[test]
+    fn crossed_execution_state_is_authenticated_and_round_trips_exactly() {
+        let (source, templates, direct) = crossed_scalar_inputs();
+        let build = |value: &Value| {
+            build_on_the_fly_process_seed_v1(
+                parse_on_the_fly_process_seed_projection_v1(&serde_json::to_vec(value).unwrap())?,
+                &templates,
+                &direct,
+                templates.summary().prepared_kernel_pack_digest,
+            )
+        };
+        let seed = build(&source).unwrap();
+        for anchor in seed.source_anchors() {
+            let state = &anchor.states()[0];
+            assert!(anchor.is_initial());
+            assert_eq!(state.public_helicity, -1);
+            assert_eq!(state.source_helicity, -1);
+            assert_eq!(state.spin_state, -50_000);
+            assert_eq!(state.momentum_sign, -1);
+            assert_eq!(
+                state.crossing_phase,
+                ExactComplexRational::ONE.checked_neg().unwrap()
+            );
+        }
+        let encoded = encode_on_the_fly_process_seed_v1(&seed).unwrap();
+        let decoded = decode_on_the_fly_process_seed_v1(&encoded).unwrap();
+        assert_eq!(decoded, seed);
+        assert_eq!(
+            encode_on_the_fly_process_seed_v1(&decoded).unwrap(),
+            encoded
+        );
+
+        for (field, stale) in [
+            ("public_helicity", json!(1)),
+            ("source_helicity", json!(1)),
+            ("spin_state", json!(50_000)),
+            ("momentum_sign", json!(1)),
+        ] {
+            let mut tampered = source.clone();
+            tampered["external_sources"][0]["states"][0][field] = stale;
+            assert!(
+                build(&tampered)
+                    .unwrap_err()
+                    .message()
+                    .contains("crossed source execution values disagree")
+            );
+        }
+        let mut stale_phase = source.clone();
+        stale_phase["external_sources"][0]["states"][0]["crossing_phase"]["real_numerator"] =
+            json!("1");
+        assert!(
+            build(&stale_phase)
+                .unwrap_err()
+                .message()
+                .contains("crossed source execution values disagree")
+        );
+        let mut stale_chirality = source.clone();
+        stale_chirality["external_sources"][0]["states"][0]["chirality"] = json!(1);
+        assert!(
+            build(&stale_chirality)
+                .unwrap_err()
+                .message()
+                .contains("process source chirality")
+        );
+    }
+
+    #[test]
+    fn compact_mass_binding_projects_one_prepared_slot_and_fails_closed() {
+        let (source, templates, direct) = mass_bound_scalar_inputs();
+        let build = |value: &Value| {
+            build_on_the_fly_process_seed_v1(
+                parse_on_the_fly_process_seed_projection_v1(&serde_json::to_vec(value).unwrap())?,
+                &templates,
+                &direct,
+                templates.summary().prepared_kernel_pack_digest,
+            )
+        };
+
+        let seed = build(&source).unwrap();
+        assert!(seed.source_anchors().iter().all(|anchor| {
+            anchor
+                .states()
+                .iter()
+                .all(|state| state.prepared_mass_parameter_slot == Some(0))
+        }));
+        let encoded = encode_on_the_fly_process_seed_v1(&seed).unwrap();
+        assert_eq!(decode_on_the_fly_process_seed_v1(&encoded).unwrap(), seed);
+
+        let mut missing = source.clone();
+        missing["parameter_projection"] = json!([]);
+        assert!(
+            build(&missing)
+                .unwrap_err()
+                .message()
+                .contains("component-0 projections")
+        );
+
+        let mut mismatched = source;
+        mismatched["parameter_projection"][0]["prepared_parameter_id"] = json!(2);
+        assert!(
+            build(&mismatched)
+                .unwrap_err()
+                .message()
+                .contains("mass projection disagrees with the prepared template catalog")
+        );
+    }
+
+    #[test]
+    fn cold_mass_binding_rejects_wrong_unique_and_missing_prepared_slots() {
+        let (source, templates, direct) = mass_bound_scalar_inputs();
+        let mut seed = build_test_seed(&source, &templates, &direct).unwrap();
+        let mut input = templates.into_input();
+        let second_evaluator = input.evaluator_bindings[1];
+        let mut second_parameter = input.parameters[0];
+        second_parameter.id = 1;
+        second_parameter.template_string_id = second_evaluator.resolver_key_string_id;
+        second_parameter.prepared_parameter_id = 1;
+        second_parameter.semantic_digest_id = second_evaluator.callable_signature_digest_id;
+        input.parameters.push(second_parameter);
+        input.catalog_header[0].parameter_count = 2;
+        let templates = input.validate().unwrap();
+        let projection = [(0, Some(0), 0), (1, Some(1), 0)];
+
+        validate_on_the_fly_source_mass_bindings_v1(&seed, &templates, &projection)
+            .expect("the source mass parameter owns prepared slot zero");
+
+        seed.source_anchors[0].states[0].prepared_mass_parameter_slot = Some(1);
+        let wrong = validate_on_the_fly_source_mass_bindings_v1(&seed, &templates, &projection)
+            .expect_err("another uniquely owned prepared slot is not this source's mass");
+        assert!(
+            wrong
+                .to_string()
+                .contains("authenticated recurrence template")
+        );
+
+        seed.source_anchors[0].states[0].prepared_mass_parameter_slot = None;
+        let missing = validate_on_the_fly_source_mass_bindings_v1(&seed, &templates, &projection)
+            .expect_err("an explicit source mass parameter cannot lose its slot");
+        assert!(
+            missing
+                .to_string()
+                .contains("authenticated recurrence template")
+        );
+    }
+
+    #[test]
+    fn legacy_null_mass_binding_uses_authenticated_orientation_without_abs_shortcuts() {
+        for (particle, anti_particle, orientation, expected) in [
+            (6, -6, CurrentOrientation::Particle, Some(0)),
+            (-6, 6, CurrentOrientation::Antiparticle, Some(0)),
+            (-6, 6, CurrentOrientation::Particle, None),
+            (1, -1, CurrentOrientation::Particle, None),
+            (21, 21, CurrentOrientation::SelfConjugate, None),
+        ] {
+            let (source, templates, direct) =
+                legacy_null_mass_inputs(particle, anti_particle, orientation);
+            let seed = build_test_seed(&source, &templates, &direct).unwrap();
+            assert!(seed.source_anchors().iter().all(|anchor| {
+                anchor
+                    .states()
+                    .iter()
+                    .all(|state| state.prepared_mass_parameter_slot == expected)
+            }));
+            let encoded = encode_on_the_fly_process_seed_v1(&seed).unwrap();
+            assert_eq!(decode_on_the_fly_process_seed_v1(&encoded).unwrap(), seed);
+        }
+    }
+
+    #[test]
+    fn legacy_null_mass_binding_fails_closed_on_ambiguity_type_and_orientation_conflicts() {
+        let (source, templates, direct) =
+            legacy_null_mass_inputs(6, -6, CurrentOrientation::Particle);
+
+        let mut ambiguous_input = templates.clone().into_input();
+        let second_evaluator = ambiguous_input.evaluator_bindings[1];
+        let mut second_parameter = ambiguous_input.parameters[0];
+        second_parameter.id = 1;
+        second_parameter.template_string_id = second_evaluator.resolver_key_string_id;
+        second_parameter.prepared_parameter_id = 1;
+        second_parameter.semantic_digest_id = second_evaluator.callable_signature_digest_id;
+        ambiguous_input.parameters.push(second_parameter);
+        ambiguous_input.catalog_header[0].parameter_count = 2;
+        let ambiguous_templates = ambiguous_input.validate().unwrap();
+        let error = build_test_seed(&source, &ambiguous_templates, &direct).unwrap_err();
+        assert!(
+            error
+                .message()
+                .contains("mass parameter \"particle.6.mass\" is ambiguous")
+        );
+
+        let mut complex_input = templates.clone().into_input();
+        complex_input.parameters[0].value_type = ParameterValueType::Complex as u8;
+        let complex_templates = complex_input.validate().unwrap();
+        assert!(
+            build_test_seed(&source, &complex_templates, &direct)
+                .unwrap_err()
+                .message()
+                .contains("mass parameter is not real")
+        );
+
+        let mut out_of_range_source = source.clone();
+        out_of_range_source["parameter_projection"][0]["prepared_parameter_id"] = json!(1);
+        let mut out_of_range_input = templates.clone().into_input();
+        out_of_range_input.parameters[0].prepared_parameter_id = 1;
+        let out_of_range_templates = out_of_range_input.validate().unwrap();
+        assert!(
+            build_test_seed(&out_of_range_source, &out_of_range_templates, &direct)
+                .unwrap_err()
+                .message()
+                .contains("outside the dense parameter arena")
+        );
+
+        let (self_conjugate_source, self_conjugate_templates, self_conjugate_direct) =
+            legacy_null_mass_inputs(21, 22, CurrentOrientation::SelfConjugate);
+        assert!(
+            build_test_seed(
+                &self_conjugate_source,
+                &self_conjugate_templates,
+                &self_conjugate_direct,
+            )
+            .unwrap_err()
+            .message()
+            .contains("self-conjugate source mass orientation")
+        );
+
+        let mut mismatched_input = templates.into_input();
+        mismatched_input.sources[0].mass_parameter_id = 0;
+        let mismatched_templates = mismatched_input.validate().unwrap();
+        assert!(
+            build_test_seed(&source, &mismatched_templates, &direct)
+                .unwrap_err()
+                .message()
+                .contains("source and current state disagree")
+        );
+    }
+
+    #[test]
+    fn minimal_projection_keeps_unspecified_model_orders_unbounded_for_cold_resolution() {
+        let (mut source, templates, direct) = scalar_inputs();
+        source["coupling_order_policy"] = json!("minimal");
+        source["coupling_limits"] = json!([]);
+        let projection =
+            parse_on_the_fly_process_seed_projection_v1(&serde_json::to_vec(&source).unwrap())
+                .unwrap();
+        let seed = build_on_the_fly_process_seed_v1(
+            projection,
+            &templates,
+            &direct,
+            templates.summary().prepared_kernel_pack_digest,
+        )
+        .unwrap();
+
+        assert_eq!(
+            seed.coupling_order_policy(),
+            OnTheFlyCouplingOrderPolicyV1::Minimal
+        );
+        assert_eq!(seed.coupling_hierarchies(), [1]);
+        assert_eq!(seed.explicit_coupling_limits(), [None]);
+    }
+
+    #[test]
+    fn ordered_process_seed_batch_is_deterministic_and_builds_one_template_catalog() {
+        let (first_source, templates, direct) = scalar_inputs();
+        let mut second_source = first_source.clone();
+        second_source["process_digest"] = json!(digest(93).to_string());
+        let pack_digest = templates.summary().prepared_kernel_pack_digest;
+        let parse = |value: &Value| {
+            parse_on_the_fly_process_seed_projection_v1(&serde_json::to_vec(value).unwrap())
+                .unwrap()
+        };
+        let singleton_bytes = |value: &Value| {
+            encode_on_the_fly_process_seed_v1(
+                &build_on_the_fly_process_seed_v1(parse(value), &templates, &direct, pack_digest)
+                    .unwrap(),
+            )
+            .unwrap()
+        };
+        let expected = [
+            singleton_bytes(&second_source),
+            singleton_bytes(&first_source),
+        ];
+
+        PROCESS_SEED_TEMPLATE_CATALOG_BUILD_COUNT.with(|count| count.set(0));
+        let guard = OnTheFlyForbiddenWorkGuardV1::begin().unwrap();
+        let first = build_on_the_fly_process_seeds_v1(
+            vec![parse(&second_source), parse(&first_source)],
+            &templates,
+            &direct,
+            pack_digest,
+        )
+        .unwrap()
+        .iter()
+        .map(encode_on_the_fly_process_seed_v1)
+        .collect::<RusticolResult<Vec<_>>>()
+        .unwrap();
+        let forbidden = guard.finish().unwrap();
+        PROCESS_SEED_TEMPLATE_CATALOG_BUILD_COUNT.with(|count| assert_eq!(count.get(), 1));
+
+        PROCESS_SEED_TEMPLATE_CATALOG_BUILD_COUNT.with(|count| count.set(0));
+        let second = build_on_the_fly_process_seeds_v1(
+            vec![parse(&second_source), parse(&first_source)],
+            &templates,
+            &direct,
+            pack_digest,
+        )
+        .unwrap()
+        .iter()
+        .map(encode_on_the_fly_process_seed_v1)
+        .collect::<RusticolResult<Vec<_>>>()
+        .unwrap();
+        PROCESS_SEED_TEMPLATE_CATALOG_BUILD_COUNT.with(|count| assert_eq!(count.get(), 1));
+
+        assert_eq!(first, expected);
+        assert_eq!(second, expected);
+        assert_eq!(forbidden.direct_plan_load_attempts, 0);
+        assert_eq!(forbidden.direct_plan_decode_attempts, 0);
+        assert_eq!(forbidden.direct_plan_materialization_attempts, 0);
+        assert_eq!(forbidden.established_builder_attempts, 0);
+    }
+
+    #[test]
+    fn ordered_process_seed_batch_attributes_failure_to_index_and_identity() {
+        let (source, templates, direct) = scalar_inputs();
+        let mut invalid_source = source.clone();
+        invalid_source["process_digest"] = json!(digest(93).to_string());
+        invalid_source["external_sources"][0]["states"][0]["source_template_id"] = json!(99);
+        let parse = |value: &Value| {
+            parse_on_the_fly_process_seed_projection_v1(&serde_json::to_vec(value).unwrap())
+                .unwrap()
+        };
+
+        let error = build_on_the_fly_process_seeds_v1(
+            vec![parse(&source), parse(&invalid_source)],
+            &templates,
+            &direct,
+            templates.summary().prepared_kernel_pack_digest,
+        )
+        .unwrap_err();
+
+        assert!(error.message().contains("process seed at index 1"));
+        assert!(error.message().contains(&digest(93).to_string()));
+        assert!(error.message().contains("source template is absent"));
+    }
+
+    #[cfg(feature = "python-generation-bridge")]
+    #[test]
+    fn process_seed_byte_singleton_matches_one_element_batch_exactly() {
+        let (source, templates, direct) = scalar_inputs();
+        let source_bytes = serde_json::to_vec(&source).unwrap();
+        let pack_digest = templates.summary().prepared_kernel_pack_digest;
+
+        let singleton = crate::__private::build_on_the_fly_process_seed_bytes_v1(
+            &source_bytes,
+            &templates,
+            &direct,
+            pack_digest,
+        )
+        .unwrap();
+        let batch = crate::__private::build_on_the_fly_process_seed_bytes_batch_v1(
+            &[source_bytes],
+            &templates,
+            &direct,
+            pack_digest,
+        )
+        .unwrap();
+        assert_eq!(batch, vec![singleton]);
+
+        let malformed = b"{".to_vec();
+        let singleton_error = crate::__private::build_on_the_fly_process_seed_bytes_v1(
+            &malformed,
+            &templates,
+            &direct,
+            pack_digest,
+        )
+        .unwrap_err();
+        let batch_error = crate::__private::build_on_the_fly_process_seed_bytes_batch_v1(
+            &[malformed],
+            &templates,
+            &direct,
+            pack_digest,
+        )
+        .unwrap_err();
+        assert_eq!(singleton_error, batch_error);
+    }
+
+    #[cfg(feature = "python-generation-bridge")]
+    #[test]
+    fn empty_process_seed_byte_batch_builds_one_template_catalog() {
+        let (_, templates, direct) = scalar_inputs();
+        PROCESS_SEED_TEMPLATE_CATALOG_BUILD_COUNT.with(|count| count.set(0));
+
+        let batch = crate::__private::build_on_the_fly_process_seed_bytes_batch_v1(
+            &[],
+            &templates,
+            &direct,
+            templates.summary().prepared_kernel_pack_digest,
+        )
+        .unwrap();
+
+        assert!(batch.is_empty());
+        PROCESS_SEED_TEMPLATE_CATALOG_BUILD_COUNT.with(|count| assert_eq!(count.get(), 1));
+    }
+
+    #[test]
+    fn compact_projection_is_deterministic_and_tampering_fails_closed() {
+        let (source, templates, direct) = scalar_inputs();
+        let build = |value: &Value| {
+            let projection =
+                parse_on_the_fly_process_seed_projection_v1(&serde_json::to_vec(value).unwrap())?;
+            let seed = build_on_the_fly_process_seed_v1(
+                projection,
+                &templates,
+                &direct,
+                templates.summary().prepared_kernel_pack_digest,
+            )?;
+            encode_on_the_fly_process_seed_v1(&seed)
+        };
+        assert_eq!(build(&source).unwrap(), build(&source).unwrap());
+
+        let mut stale_source = source.clone();
+        stale_source["external_sources"][0]["states"][0]["source_template_id"] = json!(99);
+        assert!(build(&stale_source).is_err());
+
+        let mut stale_pack = templates
+            .summary()
+            .prepared_kernel_pack_digest
+            .as_bytes()
+            .to_owned();
+        stale_pack[0] ^= 0xff;
+        let projection =
+            parse_on_the_fly_process_seed_projection_v1(&serde_json::to_vec(&source).unwrap())
+                .unwrap();
+        assert!(
+            build_on_the_fly_process_seed_v1(
+                projection,
+                &templates,
+                &direct,
+                SemanticDigest::new(stale_pack).unwrap(),
+            )
+            .is_err()
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/source_seed.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/source_seed.rs
new file mode 100644
index 0000000000..9e617f9d1b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/source_seed.rs
@@ -0,0 +1,947 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+pub(crate) const ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI: &str =
+    "pyamplicol-on-the-fly-process-seed-identity-v1";
+
+/// Compact publicable identity of one decoded process-seed source state.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct OnTheFlyProcessSeedStateIdentityV1 {
+    pub(crate) state_index: u32,
+    pub(crate) public_helicity: i32,
+    pub(crate) prepared_mass_parameter_slot: Option<u32>,
+}
+
+/// Compact publicable identity of one decoded process-seed source anchor.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct OnTheFlyProcessSeedSourceIdentityV1 {
+    pub(crate) source_slot: u32,
+    pub(crate) public_label: u32,
+    pub(crate) is_initial: bool,
+    pub(crate) states: Vec<OnTheFlyProcessSeedStateIdentityV1>,
+}
+
+/// Exact compact identity embedded beside the sole native process seed.
+///
+/// This is derived only from a successfully decoded seed.  It deliberately
+/// records source-domain facts rather than reproducing the binary seed.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct OnTheFlyProcessSeedIdentityV1 {
+    pub(crate) abi: String,
+    pub(crate) process_digest: String,
+    pub(crate) compiled_model_digest: String,
+    pub(crate) recurrence_template_catalog_digest: String,
+    pub(crate) prepared_kernel_pack_digest: String,
+    pub(crate) recurrence_direct_template_catalog_digest: String,
+    pub(crate) semantic_digest: String,
+    pub(crate) external_permutation: Vec<u32>,
+    pub(crate) external_sources: Vec<OnTheFlyProcessSeedSourceIdentityV1>,
+}
+
+/// Model-neutral source family needed by the private direct-source adapter.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub(crate) enum OnTheFlySourceWavefunctionFamilyV1 {
+    Scalar = 0,
+    WeylFermion = 1,
+    DiracFermion = 2,
+    Vector = 3,
+    Spin2 = 4,
+}
+impl OnTheFlySourceWavefunctionFamilyV1 {
+    pub(super) const fn is_fermionic(self) -> bool {
+        matches!(self, Self::WeylFermion | Self::DiracFermion)
+    }
+}
+
+/// Model-neutral particle orientation retained by one source state.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub(crate) enum OnTheFlySourceOrientationV1 {
+    Particle = 0,
+    Antiparticle = 1,
+    SelfConjugate = 2,
+}
+
+/// Exact external LC role; this is structural input, not a public-flow row.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub(crate) enum OnTheFlyExternalColorRoleV1 {
+    Singlet = 0,
+    Fundamental = 1,
+    Antifundamental = 2,
+    Adjoint = 3,
+}
+
+impl OnTheFlyExternalColorRoleV1 {
+    pub(super) const fn is_colored(self) -> bool {
+        !matches!(self, Self::Singlet)
+    }
+
+    pub(super) const fn is_pairing_endpoint(self) -> bool {
+        matches!(self, Self::Fundamental | Self::Antifundamental)
+    }
+}
+
+/// One authenticated source execution row exposed to the eventual engine
+/// adapter. Source-template IDs may be sparse; callers must retain them.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct OnTheFlySourceExecutionSpecV1 {
+    pub(crate) source_slot: u32,
+    pub(crate) source_template_id: u32,
+    pub(crate) spin_state_class: i32,
+    pub(crate) family: OnTheFlySourceWavefunctionFamilyV1,
+    pub(crate) orientation: OnTheFlySourceOrientationV1,
+    pub(crate) helicity: i32,
+    pub(crate) chirality: i32,
+    pub(crate) prepared_mass_parameter_slot: Option<u32>,
+}
+
+/// One concrete selected-helicity source state retained in the compact seed.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct OnTheFlySourceStateV1 {
+    pub(super) state_index: u32,
+    pub(super) public_helicity: i32,
+    pub(super) source_helicity: i32,
+    pub(super) source_template_id: u32,
+    pub(super) current_state_template_id: u32,
+    pub(super) source_semantic_digest: SemanticDigest,
+    pub(super) current_state_semantic_digest: SemanticDigest,
+    pub(super) momentum_sign: i32,
+    pub(super) crossing_phase: ExactComplexRational,
+    pub(super) spin_state: i32,
+    pub(super) chirality: i32,
+    pub(super) flavour_flow: Box<[i32]>,
+    pub(super) quantum_number_flow_id: u32,
+    pub(super) color_seed_proof_digest: SemanticDigest,
+    pub(super) source_family: OnTheFlySourceWavefunctionFamilyV1,
+    pub(super) source_orientation: OnTheFlySourceOrientationV1,
+    pub(super) prepared_mass_parameter_slot: Option<u32>,
+}
+
+impl OnTheFlySourceStateV1 {
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn new(
+        state_index: u32,
+        public_helicity: i32,
+        source_helicity: i32,
+        source_template_id: u32,
+        current_state_template_id: u32,
+        source_semantic_digest: SemanticDigest,
+        current_state_semantic_digest: SemanticDigest,
+        momentum_sign: i32,
+        crossing_phase: ExactComplexRational,
+        spin_state: i32,
+        chirality: i32,
+        flavour_flow: Vec<i32>,
+        quantum_number_flow_id: u32,
+        color_seed_proof_digest: SemanticDigest,
+        source_family: OnTheFlySourceWavefunctionFamilyV1,
+        source_orientation: OnTheFlySourceOrientationV1,
+        prepared_mass_parameter_slot: Option<u32>,
+    ) -> RusticolResult<Self> {
+        if source_template_id == MISSING_U32 || current_state_template_id == MISSING_U32 {
+            return Err(invalid("source state reserves the missing u32 sentinel"));
+        }
+        if momentum_sign != -1 && momentum_sign != 1 {
+            return Err(invalid("source momentum sign must be -1 or +1"));
+        }
+        if crossing_phase.is_zero() || flavour_flow.is_empty() {
+            return Err(invalid(
+                "source state requires a nonzero crossing phase and flavour ancestry",
+            ));
+        }
+        if source_family.is_fermionic()
+            && source_orientation == OnTheFlySourceOrientationV1::SelfConjugate
+        {
+            return Err(invalid(
+                "fermion source state cannot have self-conjugate orientation",
+            ));
+        }
+        Ok(Self {
+            state_index,
+            public_helicity,
+            source_helicity,
+            source_template_id,
+            current_state_template_id,
+            source_semantic_digest,
+            current_state_semantic_digest,
+            momentum_sign,
+            crossing_phase,
+            spin_state,
+            chirality,
+            flavour_flow: flavour_flow.into_boxed_slice(),
+            quantum_number_flow_id,
+            color_seed_proof_digest,
+            source_family,
+            source_orientation,
+            prepared_mass_parameter_slot,
+        })
+    }
+
+    pub(crate) const fn state_index(&self) -> u32 {
+        self.state_index
+    }
+
+    pub(crate) const fn public_helicity(&self) -> i32 {
+        self.public_helicity
+    }
+
+    pub(crate) const fn prepared_mass_parameter_slot(&self) -> Option<u32> {
+        self.prepared_mass_parameter_slot
+    }
+}
+
+/// All concrete source alternatives for one external source slot.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct OnTheFlySourceAnchorV1 {
+    pub(super) source_slot: u32,
+    pub(super) external_label: u32,
+    pub(super) is_initial: bool,
+    pub(super) color_role: OnTheFlyExternalColorRoleV1,
+    pub(super) is_fermionic: bool,
+    pub(super) pairing_source_contract_digest: Option<SemanticDigest>,
+    pub(super) states: Box<[OnTheFlySourceStateV1]>,
+}
+
+impl OnTheFlySourceAnchorV1 {
+    pub(crate) fn new(
+        source_slot: u32,
+        external_label: u32,
+        is_initial: bool,
+        color_role: OnTheFlyExternalColorRoleV1,
+        is_fermionic: bool,
+        pairing_source_contract_digest: Option<SemanticDigest>,
+        mut states: Vec<OnTheFlySourceStateV1>,
+    ) -> RusticolResult<Self> {
+        if states.is_empty() {
+            return Err(invalid("source anchor has no concrete state"));
+        }
+        states.sort_unstable_by_key(|state| state.state_index);
+        if states
+            .windows(2)
+            .any(|pair| pair[0].state_index == pair[1].state_index)
+        {
+            return Err(invalid("source anchor repeats a state index"));
+        }
+        if states
+            .iter()
+            .any(|state| state.source_family.is_fermionic() != is_fermionic)
+        {
+            return Err(invalid(
+                "source anchor statistics disagree with its execution states",
+            ));
+        }
+        if color_role.is_pairing_endpoint() != pairing_source_contract_digest.is_some()
+            || (color_role.is_pairing_endpoint() && !is_fermionic)
+        {
+            return Err(invalid(
+                "open-line endpoint role requires one fermionic source contract",
+            ));
+        }
+        Ok(Self {
+            source_slot,
+            external_label,
+            is_initial,
+            color_role,
+            is_fermionic,
+            pairing_source_contract_digest,
+            states: states.into_boxed_slice(),
+        })
+    }
+
+    pub(super) fn selected(
+        &self,
+        state_index: u32,
+        public_helicity: i32,
+    ) -> RusticolResult<&OnTheFlySourceStateV1> {
+        self.states
+            .iter()
+            .find(|state| {
+                state.state_index == state_index && state.public_helicity == public_helicity
+            })
+            .ok_or_else(|| {
+                invalid(format!(
+                    "source slot {} has no state {state_index} with public helicity {public_helicity}",
+                    self.source_slot
+                ))
+            })
+    }
+
+    pub(crate) const fn source_slot(&self) -> u32 {
+        self.source_slot
+    }
+
+    pub(crate) const fn external_label(&self) -> u32 {
+        self.external_label
+    }
+
+    pub(crate) const fn is_initial(&self) -> bool {
+        self.is_initial
+    }
+
+    pub(crate) const fn color_role(&self) -> OnTheFlyExternalColorRoleV1 {
+        self.color_role
+    }
+
+    pub(crate) fn states(&self) -> &[OnTheFlySourceStateV1] {
+        &self.states
+    }
+}
+
+/// One explicit endpoint in a compact species pairing class.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(crate) struct OnTheFlyPairingEndpointV1 {
+    pub(crate) source_slot: u32,
+    pub(crate) source_contract_digest: SemanticDigest,
+}
+
+/// O(external-leg) pairing-class input. Rules and permutations are never
+/// enumerated: one selected permutation is validated from Lehmer digits.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct OnTheFlyPairingClassV1 {
+    pub(super) species: Box<str>,
+    pub(super) species_semantic_digest: SemanticDigest,
+    pub(super) fundamental_endpoints: Box<[OnTheFlyPairingEndpointV1]>,
+    pub(super) antifundamental_endpoints: Box<[OnTheFlyPairingEndpointV1]>,
+    pub(super) semantic_digest: SemanticDigest,
+}
+
+impl OnTheFlyPairingClassV1 {
+    pub(crate) fn new(
+        species: impl Into<Box<str>>,
+        species_semantic_digest: SemanticDigest,
+        mut fundamental_endpoints: Vec<OnTheFlyPairingEndpointV1>,
+        mut antifundamental_endpoints: Vec<OnTheFlyPairingEndpointV1>,
+    ) -> RusticolResult<Self> {
+        let species = species.into();
+        if species.is_empty() {
+            return Err(invalid("pairing class species identity is empty"));
+        }
+        fundamental_endpoints.sort_unstable_by_key(|endpoint| endpoint.source_slot);
+        antifundamental_endpoints.sort_unstable_by_key(|endpoint| endpoint.source_slot);
+        if fundamental_endpoints.is_empty()
+            || fundamental_endpoints.len() != antifundamental_endpoints.len()
+            || fundamental_endpoints
+                .windows(2)
+                .any(|pair| pair[0].source_slot == pair[1].source_slot)
+            || antifundamental_endpoints
+                .windows(2)
+                .any(|pair| pair[0].source_slot == pair[1].source_slot)
+        {
+            return Err(invalid(
+                "pairing class endpoints must be nonempty, balanced, and unique",
+            ));
+        }
+        let mut result = Self {
+            species,
+            species_semantic_digest,
+            fundamental_endpoints: fundamental_endpoints.into_boxed_slice(),
+            antifundamental_endpoints: antifundamental_endpoints.into_boxed_slice(),
+            semantic_digest: SemanticDigest::new([1; 32])?,
+        };
+        result.semantic_digest = result.compute_digest()?;
+        Ok(result)
+    }
+
+    pub(crate) fn fundamental_endpoints(&self) -> &[OnTheFlyPairingEndpointV1] {
+        &self.fundamental_endpoints
+    }
+
+    pub(crate) fn antifundamental_endpoints(&self) -> &[OnTheFlyPairingEndpointV1] {
+        &self.antifundamental_endpoints
+    }
+
+    fn compute_digest(&self) -> RusticolResult<SemanticDigest> {
+        let mut hash = Sha256::new();
+        hash.update(b"pyamplicol-on-the-fly-pairing-class-v1\0");
+        hash_len(&mut hash, self.species.len(), "pairing species")?;
+        hash.update(self.species.as_bytes());
+        hash_digest(&mut hash, self.species_semantic_digest);
+        for endpoints in [&self.fundamental_endpoints, &self.antifundamental_endpoints] {
+            hash_len(&mut hash, endpoints.len(), "pairing endpoints")?;
+            for endpoint in endpoints.iter() {
+                hash.update(endpoint.source_slot.to_le_bytes());
+                hash_digest(&mut hash, endpoint.source_contract_digest);
+            }
+        }
+        final_digest(hash)
+    }
+}
+
+/// Compact immutable process input for one on-the-fly lane.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub(crate) enum OnTheFlyCouplingOrderPolicyV1 {
+    Minimal = 0,
+    Explicit = 1,
+}
+
+/// Compact immutable process input for one on-the-fly lane.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct OnTheFlyProcessSeedV1 {
+    pub(super) process_digest: SemanticDigest,
+    pub(super) model_digest: SemanticDigest,
+    pub(super) template_catalog_digest: SemanticDigest,
+    pub(super) prepared_pack_digest: SemanticDigest,
+    pub(super) direct_catalog_digest: SemanticDigest,
+    pub(super) normalization_semantic_digest: SemanticDigest,
+    pub(super) normalization_convention: Box<str>,
+    pub(super) source_anchors: Box<[OnTheFlySourceAnchorV1]>,
+    /// Gather map: construction source slot i receives public external slot
+    /// external_permutation[i].
+    pub(super) external_permutation: Box<[u32]>,
+    pub(super) coupling_order_policy: OnTheFlyCouplingOrderPolicyV1,
+    pub(super) coupling_hierarchies: Box<[u32]>,
+    /// User-supplied maxima only. `None` means that this model order has no
+    /// explicit hard cap; it never means that the default minimal policy has
+    /// already been resolved.
+    pub(super) coupling_limits: Box<[Option<u32>]>,
+    pub(super) pairing_classes: Box<[OnTheFlyPairingClassV1]>,
+    pub(super) semantic_digest: SemanticDigest,
+}
+
+impl OnTheFlyProcessSeedV1 {
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn new(
+        process_digest: SemanticDigest,
+        model_digest: SemanticDigest,
+        template_catalog_digest: SemanticDigest,
+        prepared_pack_digest: SemanticDigest,
+        direct_catalog_digest: SemanticDigest,
+        normalization_semantic_digest: SemanticDigest,
+        normalization_convention: impl Into<Box<str>>,
+        normalization_factor: ExactComplexRational,
+        mut source_anchors: Vec<OnTheFlySourceAnchorV1>,
+        external_permutation: Vec<u32>,
+        coupling_order_policy: OnTheFlyCouplingOrderPolicyV1,
+        coupling_hierarchies: Vec<u32>,
+        coupling_limits: Vec<Option<u32>>,
+        mut pairing_classes: Vec<OnTheFlyPairingClassV1>,
+    ) -> RusticolResult<Self> {
+        if normalization_factor != ExactComplexRational::ONE {
+            return Err(integrity(
+                "raw-amplitude seed normalization factor must be exact one",
+            ));
+        }
+        let normalization_convention = normalization_convention.into();
+        if normalization_convention.is_empty() {
+            return Err(invalid("normalization convention is empty"));
+        }
+        source_anchors.sort_unstable_by_key(|anchor| anchor.source_slot);
+        if source_anchors.len() < 2
+            || source_anchors
+                .iter()
+                .enumerate()
+                .any(|(index, anchor)| anchor.source_slot as usize != index)
+        {
+            return Err(invalid(
+                "source anchors must form a dense domain with at least two slots",
+            ));
+        }
+        if coupling_limits.is_empty()
+            || coupling_hierarchies.len() != coupling_limits.len()
+            || coupling_hierarchies.contains(&0)
+        {
+            return Err(invalid(
+                "on-the-fly coupling policy requires one positive hierarchy and optional hard cap per model order",
+            ));
+        }
+        validate_permutation(
+            &external_permutation,
+            source_anchors.len(),
+            "external source permutation",
+        )?;
+        pairing_classes.sort_unstable_by(|left, right| {
+            left.species
+                .cmp(&right.species)
+                .then_with(|| left.semantic_digest.cmp(&right.semantic_digest))
+        });
+        if pairing_classes
+            .windows(2)
+            .any(|pair| pair[0].species == pair[1].species)
+        {
+            return Err(invalid("pairing class repeats a species identity"));
+        }
+        let mut covered_endpoints = BTreeSet::new();
+        for pairing_class in &pairing_classes {
+            for (endpoints, role) in [
+                (
+                    pairing_class.fundamental_endpoints.as_ref(),
+                    OnTheFlyExternalColorRoleV1::Fundamental,
+                ),
+                (
+                    pairing_class.antifundamental_endpoints.as_ref(),
+                    OnTheFlyExternalColorRoleV1::Antifundamental,
+                ),
+            ] {
+                for endpoint in endpoints {
+                    let anchor = source_anchors
+                        .get(endpoint.source_slot as usize)
+                        .ok_or_else(|| invalid("pairing endpoint is outside the source domain"))?;
+                    if anchor.color_role != role
+                        || anchor.pairing_source_contract_digest
+                            != Some(endpoint.source_contract_digest)
+                        || !covered_endpoints.insert(endpoint.source_slot)
+                    {
+                        return Err(integrity(
+                            "pairing endpoint role or source-contract identity is inconsistent",
+                        ));
+                    }
+                }
+            }
+        }
+        let required_endpoints = source_anchors
+            .iter()
+            .filter(|anchor| anchor.color_role.is_pairing_endpoint())
+            .map(|anchor| anchor.source_slot)
+            .collect::<BTreeSet<_>>();
+        if covered_endpoints != required_endpoints {
+            return Err(integrity(
+                "pairing classes do not cover every open-line endpoint exactly once",
+            ));
+        }
+
+        let mut result = Self {
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest,
+            normalization_convention,
+            source_anchors: source_anchors.into_boxed_slice(),
+            external_permutation: external_permutation.into_boxed_slice(),
+            coupling_order_policy,
+            coupling_hierarchies: coupling_hierarchies.into_boxed_slice(),
+            coupling_limits: coupling_limits.into_boxed_slice(),
+            pairing_classes: pairing_classes.into_boxed_slice(),
+            semantic_digest: SemanticDigest::new([1; 32])?,
+        };
+        result.semantic_digest = result.compute_digest()?;
+        Ok(result)
+    }
+
+    #[cfg(test)]
+    pub(crate) fn with_selector_local_zero(self) -> RusticolResult<Self> {
+        let Self {
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest,
+            normalization_convention,
+            source_anchors,
+            external_permutation,
+            coupling_order_policy,
+            coupling_hierarchies,
+            coupling_limits,
+            pairing_classes,
+            semantic_digest: _,
+        } = self;
+        let source_anchors = source_anchors
+            .into_vec()
+            .into_iter()
+            .map(|anchor| {
+                let OnTheFlySourceAnchorV1 {
+                    source_slot,
+                    external_label,
+                    is_initial,
+                    color_role,
+                    is_fermionic,
+                    pairing_source_contract_digest,
+                    states,
+                } = anchor;
+                let mut states = states.into_vec();
+                let mut zero = states[0].clone();
+                zero.state_index = 1;
+                zero.public_helicity = 1;
+                zero.spin_state = 50_001;
+                states.push(zero);
+                OnTheFlySourceAnchorV1::new(
+                    source_slot,
+                    external_label,
+                    is_initial,
+                    color_role,
+                    is_fermionic,
+                    pairing_source_contract_digest,
+                    states,
+                )
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        Self::new(
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest,
+            normalization_convention,
+            ExactComplexRational::ONE,
+            source_anchors,
+            external_permutation.into_vec(),
+            coupling_order_policy,
+            coupling_hierarchies.into_vec(),
+            coupling_limits.into_vec(),
+            pairing_classes.into_vec(),
+        )
+    }
+
+    fn compute_digest(&self) -> RusticolResult<SemanticDigest> {
+        let mut hash = Sha256::new();
+        hash.update(b"pyamplicol-on-the-fly-process-seed-v2\0");
+        for digest in [
+            self.process_digest,
+            self.model_digest,
+            self.template_catalog_digest,
+            self.prepared_pack_digest,
+            self.direct_catalog_digest,
+            self.normalization_semantic_digest,
+        ] {
+            hash_digest(&mut hash, digest);
+        }
+        hash_len(
+            &mut hash,
+            self.normalization_convention.len(),
+            "normalization convention",
+        )?;
+        hash.update(self.normalization_convention.as_bytes());
+        hash_len(&mut hash, self.source_anchors.len(), "source anchors")?;
+        for anchor in &self.source_anchors {
+            hash.update(anchor.source_slot.to_le_bytes());
+            hash.update(anchor.external_label.to_le_bytes());
+            hash.update([
+                anchor.color_role as u8,
+                u8::from(anchor.is_fermionic),
+                u8::from(anchor.is_initial),
+            ]);
+            match anchor.pairing_source_contract_digest {
+                None => hash.update([0]),
+                Some(value) => {
+                    hash.update([1]);
+                    hash_digest(&mut hash, value);
+                }
+            }
+            hash_len(&mut hash, anchor.states.len(), "source states")?;
+            for state in &anchor.states {
+                hash.update(state.state_index.to_le_bytes());
+                hash.update(state.public_helicity.to_le_bytes());
+                hash.update(state.source_helicity.to_le_bytes());
+                hash.update(state.source_template_id.to_le_bytes());
+                hash.update(state.current_state_template_id.to_le_bytes());
+                hash_digest(&mut hash, state.source_semantic_digest);
+                hash_digest(&mut hash, state.current_state_semantic_digest);
+                hash.update(state.momentum_sign.to_le_bytes());
+                hash_exact(&mut hash, state.crossing_phase);
+                hash.update(state.spin_state.to_le_bytes());
+                hash.update(state.chirality.to_le_bytes());
+                hash_len(&mut hash, state.flavour_flow.len(), "source flavour flow")?;
+                for flavour in &state.flavour_flow {
+                    hash.update(flavour.to_le_bytes());
+                }
+                hash.update(state.quantum_number_flow_id.to_le_bytes());
+                hash_digest(&mut hash, state.color_seed_proof_digest);
+                hash.update([state.source_family as u8, state.source_orientation as u8]);
+                match state.prepared_mass_parameter_slot {
+                    None => hash.update([0]),
+                    Some(slot) => {
+                        hash.update([1]);
+                        hash.update(slot.to_le_bytes());
+                    }
+                }
+            }
+        }
+        hash_len(
+            &mut hash,
+            self.external_permutation.len(),
+            "external permutation",
+        )?;
+        for slot in &self.external_permutation {
+            hash.update(slot.to_le_bytes());
+        }
+        hash.update([self.coupling_order_policy as u8]);
+        hash_len(
+            &mut hash,
+            self.coupling_hierarchies.len(),
+            "coupling hierarchies",
+        )?;
+        for (hierarchy, limit) in self
+            .coupling_hierarchies
+            .iter()
+            .zip(self.coupling_limits.iter())
+        {
+            hash.update(hierarchy.to_le_bytes());
+            match limit {
+                None => hash.update([0]),
+                Some(limit) => {
+                    hash.update([1]);
+                    hash.update(limit.to_le_bytes());
+                }
+            }
+        }
+        hash_len(&mut hash, self.pairing_classes.len(), "pairing classes")?;
+        for pairing_class in &self.pairing_classes {
+            hash_digest(&mut hash, pairing_class.semantic_digest);
+        }
+        final_digest(hash)
+    }
+
+    pub(crate) const fn semantic_digest(&self) -> SemanticDigest {
+        self.semantic_digest
+    }
+
+    pub(crate) const fn process_digest(&self) -> SemanticDigest {
+        self.process_digest
+    }
+
+    pub(crate) fn identity(&self) -> OnTheFlyProcessSeedIdentityV1 {
+        OnTheFlyProcessSeedIdentityV1 {
+            abi: ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI.to_owned(),
+            process_digest: self.process_digest().to_string(),
+            compiled_model_digest: self.model_digest().to_string(),
+            recurrence_template_catalog_digest: self.template_catalog_digest().to_string(),
+            prepared_kernel_pack_digest: self.prepared_pack_digest().to_string(),
+            recurrence_direct_template_catalog_digest: self.direct_catalog_digest().to_string(),
+            semantic_digest: self.semantic_digest().to_string(),
+            external_permutation: self.external_permutation().to_vec(),
+            external_sources: self
+                .source_anchors()
+                .iter()
+                .map(|anchor| OnTheFlyProcessSeedSourceIdentityV1 {
+                    source_slot: anchor.source_slot(),
+                    public_label: anchor.external_label(),
+                    is_initial: anchor.is_initial(),
+                    states: anchor
+                        .states()
+                        .iter()
+                        .map(|state| OnTheFlyProcessSeedStateIdentityV1 {
+                            state_index: state.state_index(),
+                            public_helicity: state.public_helicity(),
+                            prepared_mass_parameter_slot: state.prepared_mass_parameter_slot(),
+                        })
+                        .collect(),
+                })
+                .collect(),
+        }
+    }
+
+    pub(crate) fn external_permutation(&self) -> &[u32] {
+        &self.external_permutation
+    }
+
+    pub(crate) fn source_anchors(&self) -> &[OnTheFlySourceAnchorV1] {
+        &self.source_anchors
+    }
+
+    pub(crate) fn pairing_classes(&self) -> &[OnTheFlyPairingClassV1] {
+        &self.pairing_classes
+    }
+
+    pub(crate) const fn coupling_order_policy(&self) -> OnTheFlyCouplingOrderPolicyV1 {
+        self.coupling_order_policy
+    }
+
+    pub(crate) fn coupling_hierarchies(&self) -> &[u32] {
+        &self.coupling_hierarchies
+    }
+
+    pub(crate) fn explicit_coupling_limits(&self) -> &[Option<u32>] {
+        &self.coupling_limits
+    }
+
+    pub(crate) const fn model_digest(&self) -> SemanticDigest {
+        self.model_digest
+    }
+
+    pub(crate) const fn template_catalog_digest(&self) -> SemanticDigest {
+        self.template_catalog_digest
+    }
+
+    pub(crate) const fn prepared_pack_digest(&self) -> SemanticDigest {
+        self.prepared_pack_digest
+    }
+
+    pub(crate) const fn direct_catalog_digest(&self) -> SemanticDigest {
+        self.direct_catalog_digest
+    }
+
+    pub(crate) fn source_execution_specs(
+        &self,
+    ) -> impl Iterator<Item = OnTheFlySourceExecutionSpecV1> + '_ {
+        self.source_anchors.iter().flat_map(|anchor| {
+            anchor
+                .states
+                .iter()
+                .map(move |state| OnTheFlySourceExecutionSpecV1 {
+                    source_slot: anchor.source_slot,
+                    source_template_id: state.source_template_id,
+                    spin_state_class: state.spin_state,
+                    family: state.source_family,
+                    orientation: state.source_orientation,
+                    helicity: state.source_helicity,
+                    chirality: state.chirality,
+                    prepared_mass_parameter_slot: state.prepared_mass_parameter_slot,
+                })
+        })
+    }
+}
+
+#[cfg(test)]
+pub(crate) fn scalar_adapter_test_seed(
+    model_digest: SemanticDigest,
+    template_catalog_digest: SemanticDigest,
+    prepared_pack_digest: SemanticDigest,
+    direct_catalog_digest: SemanticDigest,
+) -> RusticolResult<OnTheFlyProcessSeedV1> {
+    let source_semantic_digest = SemanticDigest::new([5; 32])?;
+    let current_semantic_digest = SemanticDigest::new([4; 32])?;
+    let color_seed_digest = SemanticDigest::new([17; 32])?;
+    let anchors = (0..2)
+        .map(|source_slot| {
+            let state = OnTheFlySourceStateV1::new(
+                0,
+                0,
+                0,
+                0,
+                0,
+                source_semantic_digest,
+                current_semantic_digest,
+                1,
+                ExactComplexRational::ONE,
+                50_000,
+                0,
+                vec![1],
+                0,
+                color_seed_digest,
+                OnTheFlySourceWavefunctionFamilyV1::Scalar,
+                OnTheFlySourceOrientationV1::SelfConjugate,
+                None,
+            )?;
+            OnTheFlySourceAnchorV1::new(
+                source_slot,
+                source_slot,
+                false,
+                OnTheFlyExternalColorRoleV1::Singlet,
+                false,
+                None,
+                vec![state],
+            )
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    OnTheFlyProcessSeedV1::new(
+        SemanticDigest::new([91; 32])?,
+        model_digest,
+        template_catalog_digest,
+        prepared_pack_digest,
+        direct_catalog_digest,
+        SemanticDigest::new([92; 32])?,
+        "raw-amplitude-test",
+        ExactComplexRational::ONE,
+        anchors,
+        vec![0, 1],
+        OnTheFlyCouplingOrderPolicyV1::Explicit,
+        vec![1],
+        vec![Some(0)],
+        Vec::new(),
+    )
+}
+
+pub(super) fn validate_permutation(
+    values: &[u32],
+    expected_len: usize,
+    label: &str,
+) -> RusticolResult<()> {
+    if values.len() != expected_len {
+        return Err(invalid(format!(
+            "{label} has length {}, expected {expected_len}",
+            values.len(),
+        )));
+    }
+    let mut sorted = values.to_vec();
+    sorted.sort_unstable();
+    if sorted
+        != (0..expected_len)
+            .map(|value| checked_u32(value, label))
+            .collect::<RusticolResult<Vec<_>>>()?
+    {
+        return Err(invalid(format!("{label} is not a bijection")));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rebuild_with_coupling_policy(
+        seed: OnTheFlyProcessSeedV1,
+        coupling_hierarchies: Vec<u32>,
+        coupling_limits: Vec<Option<u32>>,
+    ) -> RusticolResult<OnTheFlyProcessSeedV1> {
+        let OnTheFlyProcessSeedV1 {
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest,
+            normalization_convention,
+            source_anchors,
+            external_permutation,
+            coupling_order_policy,
+            coupling_hierarchies: _,
+            coupling_limits: _,
+            pairing_classes,
+            semantic_digest: _,
+        } = seed;
+        OnTheFlyProcessSeedV1::new(
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest,
+            normalization_convention,
+            ExactComplexRational::ONE,
+            source_anchors.into_vec(),
+            external_permutation.into_vec(),
+            coupling_order_policy,
+            coupling_hierarchies,
+            coupling_limits,
+            pairing_classes.into_vec(),
+        )
+    }
+
+    #[test]
+    fn genuine_probe_explicit_model_order_limits_fail_closed() {
+        let seed = scalar_adapter_test_seed(
+            SemanticDigest::new([1; 32]).unwrap(),
+            SemanticDigest::new([2; 32]).unwrap(),
+            SemanticDigest::new([3; 32]).unwrap(),
+            SemanticDigest::new([4; 32]).unwrap(),
+        )
+        .unwrap();
+        for (hierarchies, limits) in [
+            (vec![], vec![]),
+            (vec![1], vec![Some(0), None]),
+            (vec![1, 0], vec![Some(0), None]),
+        ] {
+            assert!(
+                rebuild_with_coupling_policy(seed.clone(), hierarchies, limits)
+                    .unwrap_err()
+                    .to_string()
+                    .contains("one positive hierarchy and optional hard cap")
+            );
+        }
+        assert!(rebuild_with_coupling_policy(seed.clone(), vec![1], vec![Some(3)]).is_ok());
+        assert!(
+            rebuild_with_coupling_policy(seed.clone(), vec![1, 2], vec![Some(0), None]).is_ok()
+        );
+        assert!(rebuild_with_coupling_policy(seed, vec![1, 2], vec![Some(0), Some(3)]).is_ok());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/sweep.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/sweep.rs
new file mode 100644
index 0000000000..4db258cd63
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/sweep.rs
@@ -0,0 +1,3815 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::source_seed::validate_permutation;
+use super::*;
+use crate::recurrence::construct::{
+    CurrentReflection, PendingReflectionCertificate, TransitionReflectionIndex,
+    current_key_with_dynamic_color, current_reflection_candidate, current_reversal_masks,
+    dynamic_color_identity_digest, pure_adjoint_word_is_canonical, reciprocal_reflection_proof,
+    source_reflection,
+};
+use crate::recurrence::fermion_ordering::{FermionOrderingContext, fermion_ordering_factor};
+
+fn on_the_fly_source_requires_exterior_sign(
+    is_fermionic: bool,
+    color_role: OnTheFlyExternalColorRoleV1,
+) -> RusticolResult<bool> {
+    if !is_fermionic {
+        if color_role.is_pairing_endpoint() {
+            return Err(integrity(
+                "fermion-ordering endpoint role belongs to a bosonic source",
+            ));
+        }
+        return Ok(false);
+    }
+    match color_role {
+        OnTheFlyExternalColorRoleV1::Singlet => Ok(true),
+        OnTheFlyExternalColorRoleV1::Fundamental | OnTheFlyExternalColorRoleV1::Antifundamental => {
+            Ok(false)
+        }
+        OnTheFlyExternalColorRoleV1::Adjoint => Err(invalid(
+            "external-fermion ordering does not support adjoint fermion sources",
+        )),
+    }
+}
+
+pub(super) fn on_the_fly_fermion_ordering_context(
+    seed: &OnTheFlyProcessSeedV1,
+) -> RusticolResult<FermionOrderingContext> {
+    let mut source_requires_exterior_sign = Vec::with_capacity(seed.source_anchors.len());
+    for (source_slot, anchor) in seed.source_anchors.iter().enumerate() {
+        let source_slot = checked_u32(source_slot, "fermion-ordering source slot")?;
+        if anchor.source_slot != source_slot {
+            return Err(integrity(
+                "fermion-ordering source anchor disagrees with its slot",
+            ));
+        }
+        source_requires_exterior_sign.push(on_the_fly_source_requires_exterior_sign(
+            anchor.is_fermionic,
+            anchor.color_role,
+        )?);
+    }
+    Ok(FermionOrderingContext::new(source_requires_exterior_sign))
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(super) struct PendingContributionKey {
+    pub(super) parent_current_ids: [u32; 2],
+    pub(super) key: ContributionKey,
+}
+
+#[derive(Debug)]
+pub(super) struct PendingCurrent {
+    pub(super) key: CurrentCoreKey,
+    pub(super) source_factor: Option<ExactComplexRational>,
+    pub(super) contributions: BTreeMap<PendingContributionKey, ExactComplexRational>,
+    /// Canonical proof-only lineage alternatives.  As in the established
+    /// builder's realized-rule set, exact contribution factors remain owned
+    /// by `contributions`; lineage does not multiply or normalize amplitudes.
+    pub(super) pairing_lineages: Vec<PendingPairingLineage>,
+    pub(super) stage: u32,
+    /// Exact reflection lineage is populated only for the certified cyclic
+    /// pure-adjoint companion lane. Generic/direct construction leaves it
+    /// unavailable and therefore cannot enter the fold.
+    pub(super) reflection: CurrentReflection,
+    /// Cold reciprocal-orbit proof retained only on the canonical member
+    /// until reflected public closures have been resolved.
+    pub(super) reflection_certificate: Option<PendingReflectionCertificate>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct PreparedContactOrbitLocation {
+    transition_id: u32,
+    state_pair: (u32, u32),
+    row_index: usize,
+}
+
+#[derive(Debug, Default, Eq, PartialEq)]
+pub(super) struct PreparedContactOrbitIndex {
+    locations: Vec<PreparedContactOrbitLocation>,
+}
+
+fn reserve_on_the_fly_contact_locations<T>(
+    locations: &mut Vec<T>,
+    count: usize,
+) -> RusticolResult<()> {
+    locations.try_reserve_exact(count).map_err(|error| {
+        invalid(format!(
+            "contact-orbit transition-index allocation failed: {error}"
+        ))
+    })
+}
+
+impl PreparedContactOrbitIndex {
+    pub(super) fn new(
+        transitions: &BTreeMap<(u32, u32), Vec<PreparedTransition>>,
+    ) -> RusticolResult<Self> {
+        let transition_count = transitions.values().try_fold(0usize, |count, rows| {
+            count
+                .checked_add(rows.len())
+                .ok_or_else(|| invalid("contact-orbit transition count exceeds usize"))
+        })?;
+        let contact_count = transitions
+            .values()
+            .flatten()
+            .filter(|prepared| prepared.contact_orbit.is_some())
+            .count();
+        if contact_count == 0 {
+            return Ok(Self::default());
+        }
+        let mut transition_ids = Vec::new();
+        reserve_on_the_fly_contact_locations(&mut transition_ids, transition_count)?;
+        let mut locations = Vec::new();
+        reserve_on_the_fly_contact_locations(&mut locations, contact_count)?;
+        for (state_pair, rows) in transitions {
+            for (row_index, prepared) in rows.iter().enumerate() {
+                transition_ids.push(prepared.row.id);
+                if prepared.contact_orbit.is_some() {
+                    locations.push(PreparedContactOrbitLocation {
+                        transition_id: prepared.row.id,
+                        state_pair: *state_pair,
+                        row_index,
+                    });
+                }
+            }
+        }
+        transition_ids.sort_unstable();
+        if transition_ids.windows(2).any(|rows| rows[0] == rows[1]) {
+            return Err(integrity(
+                "contact-orbit transition index contains duplicate IDs",
+            ));
+        }
+        locations.sort_unstable_by_key(|location| location.transition_id);
+        Ok(Self { locations })
+    }
+
+    fn is_empty(&self) -> bool {
+        self.locations.is_empty()
+    }
+
+    fn get<'a>(
+        &self,
+        transitions: &'a BTreeMap<(u32, u32), Vec<PreparedTransition>>,
+        transition_id: u32,
+    ) -> Option<&'a PreparedContactOrbitTransition> {
+        self.locations
+            .binary_search_by_key(&transition_id, |location| location.transition_id)
+            .ok()
+            .and_then(|index| self.locations.get(index))
+            .and_then(|location| {
+                transitions
+                    .get(&location.state_pair)
+                    .and_then(|rows| rows.get(location.row_index))
+            })
+            .filter(|prepared| prepared.row.id == transition_id)
+            .and_then(|prepared| prepared.contact_orbit.as_ref())
+    }
+
+    #[cfg(test)]
+    fn len(&self) -> usize {
+        self.locations.len()
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct OnTheFlyContactContributionToken {
+    destination_id: usize,
+    contribution_ordinal: usize,
+}
+
+#[derive(Debug)]
+struct OnTheFlyContactOwnerPlan {
+    stage_current_start: usize,
+    selected_tokens: Vec<OnTheFlyContactContributionToken>,
+    staged_contribution_count: usize,
+    retained_contribution_count: usize,
+}
+
+impl OnTheFlyContactOwnerPlan {
+    /// Apply a completely selected plan without allocating or failing.
+    fn commit(self, currents: &mut [PendingCurrent]) {
+        let mut selected_index = 0usize;
+        let mut observed_count = 0usize;
+        let mut retained_count = 0usize;
+        for (destination_id, current) in currents
+            .iter_mut()
+            .enumerate()
+            .skip(self.stage_current_start)
+        {
+            let mut contribution_ordinal = 0usize;
+            current.contributions.retain(|_, _| {
+                let token = OnTheFlyContactContributionToken {
+                    destination_id,
+                    contribution_ordinal,
+                };
+                contribution_ordinal += 1;
+                observed_count += 1;
+                let selected = self.selected_tokens.get(selected_index) == Some(&token);
+                if selected {
+                    selected_index += 1;
+                    retained_count += 1;
+                }
+                selected
+            });
+        }
+        debug_assert_eq!(observed_count, self.staged_contribution_count);
+        debug_assert_eq!(retained_count, self.retained_contribution_count);
+        debug_assert_eq!(selected_index, self.selected_tokens.len());
+    }
+}
+
+fn reserve_on_the_fly_contact_candidates<T>(
+    candidates: &mut Vec<T>,
+    count: usize,
+) -> RusticolResult<()> {
+    candidates.try_reserve_exact(count).map_err(|error| {
+        invalid(format!(
+            "contact-orbit candidate allocation failed: {error}"
+        ))
+    })
+}
+
+fn plan_on_the_fly_contact_orbit_owners(
+    stage_current_start: usize,
+    transitions: &BTreeMap<(u32, u32), Vec<PreparedTransition>>,
+    contact_orbits: &PreparedContactOrbitIndex,
+    currents: &[PendingCurrent],
+) -> RusticolResult<Option<OnTheFlyContactOwnerPlan>> {
+    plan_on_the_fly_contact_orbit_owners_with_resolver(
+        stage_current_start,
+        currents,
+        |transition_id| contact_orbits.get(transitions, transition_id),
+    )
+}
+
+fn plan_on_the_fly_contact_orbit_owners_with_resolver<'a, F>(
+    stage_current_start: usize,
+    currents: &'a [PendingCurrent],
+    mut contact_orbit: F,
+) -> RusticolResult<Option<OnTheFlyContactOwnerPlan>>
+where
+    F: FnMut(u32) -> Option<&'a PreparedContactOrbitTransition>,
+{
+    if stage_current_start > currents.len() {
+        return Err(invalid(
+            "contact-orbit stage current boundary exceeds current storage",
+        ));
+    }
+    let has_certified_contact = currents[stage_current_start..].iter().any(|current| {
+        current
+            .contributions
+            .keys()
+            .any(|pending| contact_orbit(pending.key.transition_template_id()).is_some())
+    });
+    if !has_certified_contact {
+        return Ok(None);
+    }
+    let staged_contribution_count =
+        currents[stage_current_start..]
+            .iter()
+            .try_fold(0usize, |count, current| {
+                count
+                    .checked_add(current.contributions.len())
+                    .ok_or_else(|| invalid("contact-orbit staged contribution count exceeds usize"))
+            })?;
+    let mut candidates = Vec::new();
+    reserve_on_the_fly_contact_candidates(&mut candidates, staged_contribution_count)?;
+    for (destination_id, current) in currents.iter().enumerate().skip(stage_current_start) {
+        for (contribution_ordinal, pending) in current.contributions.keys().enumerate() {
+            let token = OnTheFlyContactContributionToken {
+                destination_id,
+                contribution_ordinal,
+            };
+            let candidate = contact_orbit(pending.key.transition_template_id())
+                .map(|contact_orbit| {
+                    let left = currents
+                        .get(pending.parent_current_ids[0] as usize)
+                        .map(|parent| &parent.key)
+                        .ok_or_else(|| integrity("contact-orbit left parent is absent"))?;
+                    let right = currents
+                        .get(pending.parent_current_ids[1] as usize)
+                        .map(|parent| &parent.key)
+                        .ok_or_else(|| integrity("contact-orbit right parent is absent"))?;
+                    contact_orbit.owner_candidate(
+                        &current.key,
+                        [left, right],
+                        pending.key.color_witness_term_id(),
+                    )
+                })
+                .transpose()?;
+            candidates.push((token, candidate));
+        }
+    }
+    if candidates.len() != staged_contribution_count {
+        return Err(integrity(
+            "contact-orbit staged contribution snapshot changed length",
+        ));
+    }
+    let selected_tokens = selected_contact_orbit_owner_tokens(candidates)?;
+    let retained_contribution_count = selected_tokens.len();
+    if retained_contribution_count > staged_contribution_count {
+        return Err(integrity(
+            "contact-orbit retained contribution count exceeds snapshot",
+        ));
+    }
+    Ok(Some(OnTheFlyContactOwnerPlan {
+        stage_current_start,
+        selected_tokens,
+        staged_contribution_count,
+        retained_contribution_count,
+    }))
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(super) struct PendingPairingLineage {
+    pub(super) completed_pairs: Vec<[u32; 2]>,
+    pub(super) unmatched_endpoint: Option<u32>,
+}
+
+impl PendingPairingLineage {
+    pub(super) fn source(seed: &OnTheFlyProcessSeedV1, source_slot: u32) -> Self {
+        let unmatched_endpoint = seed.source_anchors[source_slot as usize]
+            .color_role
+            .is_pairing_endpoint()
+            .then_some(source_slot);
+        Self {
+            completed_pairs: Vec::new(),
+            unmatched_endpoint,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(super) struct PendingClosureKey {
+    pub(super) closure_template_id: u32,
+    pub(super) quantum_flow_template_id: Option<u32>,
+    pub(super) parent_current_ids: [u32; 2],
+    pub(super) color_witness_term_id: LCColorWitnessTermId,
+}
+
+#[derive(Debug)]
+pub(super) struct PendingClosure {
+    pub(super) key: PendingClosureKey,
+    pub(super) factor: ExactComplexRational,
+    pub(super) component_coefficients: Box<[ExactComplexRational]>,
+    pub(super) pairing_lineages: Vec<PendingPairingLineage>,
+}
+
+/// Query-local Wick-lineage proof selected only after physical closure and
+/// complete-rectangle color-alias projection have identified a canonical
+/// root-bearing representative.
+#[derive(Debug, Eq, PartialEq)]
+pub(super) struct ResolvedPairingOwnerV1 {
+    pub(super) endpoint_pairs: Vec<[u32; 2]>,
+    pub(super) proof_digest: Option<SemanticDigest>,
+    pub(super) source_slot_permutation: Vec<u32>,
+    pub(super) source_lineage: Vec<u32>,
+    pub(super) fermion_parity: i32,
+}
+
+fn checked_pairing_capacity(left: usize, right: usize, extra: usize) -> RusticolResult<usize> {
+    left.checked_add(right)
+        .and_then(|combined| combined.checked_add(extra))
+        .ok_or_else(|| invalid("pairing-lineage length exceeds usize"))
+}
+
+fn try_copy_pairing_pairs(source: &[[u32; 2]]) -> RusticolResult<Vec<[u32; 2]>> {
+    let mut copied = Vec::new();
+    copied
+        .try_reserve_exact(source.len())
+        .map_err(|error| invalid(format!("pairing-lineage allocation failed: {error}")))?;
+    copied.extend_from_slice(source);
+    Ok(copied)
+}
+
+fn try_clone_pairing_lineage(
+    source: &PendingPairingLineage,
+) -> RusticolResult<PendingPairingLineage> {
+    Ok(PendingPairingLineage {
+        completed_pairs: try_copy_pairing_pairs(&source.completed_pairs)?,
+        unmatched_endpoint: source.unmatched_endpoint,
+    })
+}
+
+pub(super) fn try_clone_pairing_lineages(
+    source: &[PendingPairingLineage],
+) -> RusticolResult<Vec<PendingPairingLineage>> {
+    let mut copied = Vec::new();
+    copied
+        .try_reserve_exact(source.len())
+        .map_err(|error| invalid(format!("pairing-lineage set allocation failed: {error}")))?;
+    for lineage in source {
+        copied.push(try_clone_pairing_lineage(lineage)?);
+    }
+    Ok(copied)
+}
+
+fn pairing_endpoint_class(
+    seed: &OnTheFlyProcessSeedV1,
+    source_slot: u32,
+) -> RusticolResult<(OnTheFlyExternalColorRoleV1, SemanticDigest)> {
+    let anchor = seed
+        .source_anchors
+        .get(source_slot as usize)
+        .ok_or_else(|| integrity("pairing-lineage endpoint is outside the source domain"))?;
+    let contract = anchor
+        .pairing_source_contract_digest
+        .ok_or_else(|| integrity("pairing-lineage endpoint lacks its source contract"))?;
+    let class = seed
+        .pairing_classes
+        .iter()
+        .find(|class| {
+            class
+                .fundamental_endpoints
+                .iter()
+                .chain(class.antifundamental_endpoints.iter())
+                .any(|endpoint| endpoint.source_slot == source_slot)
+        })
+        .ok_or_else(|| integrity("pairing-lineage endpoint lacks its compact class"))?;
+    let class_endpoint = class
+        .fundamental_endpoints
+        .iter()
+        .chain(class.antifundamental_endpoints.iter())
+        .find(|endpoint| endpoint.source_slot == source_slot)
+        .ok_or_else(|| integrity("pairing-lineage endpoint disappeared from its class"))?;
+    if class_endpoint.source_contract_digest != contract {
+        return Err(integrity(
+            "pairing-lineage endpoint source contract differs from its class",
+        ));
+    }
+    Ok((anchor.color_role, class.semantic_digest))
+}
+
+fn close_pairing_endpoints(
+    seed: &OnTheFlyProcessSeedV1,
+    left: u32,
+    right: u32,
+) -> RusticolResult<Option<[u32; 2]>> {
+    let (left_role, left_class) = pairing_endpoint_class(seed, left)?;
+    let (right_role, right_class) = pairing_endpoint_class(seed, right)?;
+    if left_class != right_class {
+        return Ok(None);
+    }
+    Ok(match (left_role, right_role) {
+        (
+            OnTheFlyExternalColorRoleV1::Fundamental,
+            OnTheFlyExternalColorRoleV1::Antifundamental,
+        ) => Some([left, right]),
+        (
+            OnTheFlyExternalColorRoleV1::Antifundamental,
+            OnTheFlyExternalColorRoleV1::Fundamental,
+        ) => Some([right, left]),
+        _ => None,
+    })
+}
+
+fn combine_pairing_lineage(
+    seed: &OnTheFlyProcessSeedV1,
+    left: &PendingPairingLineage,
+    right: &PendingPairingLineage,
+    carries_colored_fermion_line: bool,
+) -> RusticolResult<Option<PendingPairingLineage>> {
+    let possible_new_pair = usize::from(
+        left.unmatched_endpoint.is_some()
+            && right.unmatched_endpoint.is_some()
+            && !carries_colored_fermion_line,
+    );
+    let capacity = checked_pairing_capacity(
+        left.completed_pairs.len(),
+        right.completed_pairs.len(),
+        possible_new_pair,
+    )?;
+    let mut completed_pairs = Vec::new();
+    completed_pairs
+        .try_reserve_exact(capacity)
+        .map_err(|error| invalid(format!("pairing-lineage allocation failed: {error}")))?;
+    completed_pairs.extend_from_slice(&left.completed_pairs);
+    completed_pairs.extend_from_slice(&right.completed_pairs);
+    let unmatched_endpoint = match (
+        left.unmatched_endpoint,
+        right.unmatched_endpoint,
+        carries_colored_fermion_line,
+    ) {
+        (Some(endpoint), None, true) | (None, Some(endpoint), true) => Some(endpoint),
+        (None, None, false) => None,
+        (Some(left), Some(right), false) => {
+            let Some(pair) = close_pairing_endpoints(seed, left, right)? else {
+                return Ok(None);
+            };
+            completed_pairs.push(pair);
+            None
+        }
+        _ => return Ok(None),
+    };
+    completed_pairs.sort_unstable();
+    if completed_pairs.windows(2).any(|pair| pair[0] == pair[1]) {
+        return Err(integrity(
+            "pairing lineage repeats a completed endpoint pair",
+        ));
+    }
+    Ok(Some(PendingPairingLineage {
+        completed_pairs,
+        unmatched_endpoint,
+    }))
+}
+
+pub(super) fn combine_pairing_lineage_sets(
+    seed: &OnTheFlyProcessSeedV1,
+    left: &[PendingPairingLineage],
+    right: &[PendingPairingLineage],
+    carries_colored_fermion_line: bool,
+) -> RusticolResult<Vec<PendingPairingLineage>> {
+    let capacity = left
+        .len()
+        .checked_mul(right.len())
+        .ok_or_else(|| invalid("pairing-lineage product exceeds usize"))?;
+    let mut result = Vec::new();
+    result
+        .try_reserve_exact(capacity)
+        .map_err(|error| invalid(format!("pairing-lineage allocation failed: {error}")))?;
+    for left in left {
+        for right in right {
+            if let Some(lineage) =
+                combine_pairing_lineage(seed, left, right, carries_colored_fermion_line)?
+            {
+                result.push(lineage);
+            }
+        }
+    }
+    result.sort_unstable();
+    result.dedup();
+    Ok(result)
+}
+
+pub(super) fn extend_pairing_lineages(
+    target: &mut Vec<PendingPairingLineage>,
+    source: &[PendingPairingLineage],
+) -> RusticolResult<()> {
+    let mut additions = try_clone_pairing_lineages(source)?;
+    target
+        .try_reserve(additions.len())
+        .map_err(|error| invalid(format!("pairing-lineage merge allocation failed: {error}")))?;
+    target.append(&mut additions);
+    target.sort_unstable();
+    target.dedup();
+    Ok(())
+}
+
+fn retain_canonical_pairing_lineage(
+    lineages: &mut Vec<PendingPairingLineage>,
+) -> RusticolResult<()> {
+    if lineages.is_empty() {
+        return Err(integrity(
+            "physical closure has no complete Wick-lineage owner",
+        ));
+    }
+    // Pairing lineage is cold proof state, not an additive amplitude term.
+    // Equal runtime closures therefore retain one semantic witness without
+    // duplicating or rescaling their already aggregated numerical factor.
+    lineages.sort_unstable();
+    lineages.dedup();
+    lineages.truncate(1);
+    Ok(())
+}
+
+pub(super) fn complete_pairing_lineage(
+    seed: &OnTheFlyProcessSeedV1,
+    lineage: &PendingPairingLineage,
+) -> RusticolResult<bool> {
+    if lineage.unmatched_endpoint.is_some() {
+        return Ok(false);
+    }
+    let expected_endpoint_count = seed
+        .source_anchors
+        .iter()
+        .filter(|anchor| anchor.color_role.is_pairing_endpoint())
+        .count();
+    let observed_endpoint_count = lineage
+        .completed_pairs
+        .len()
+        .checked_mul(2)
+        .ok_or_else(|| invalid("pairing endpoint count exceeds usize"))?;
+    if observed_endpoint_count != expected_endpoint_count {
+        return Ok(false);
+    }
+    for (index, pair) in lineage.completed_pairs.iter().copied().enumerate() {
+        if close_pairing_endpoints(seed, pair[0], pair[1])? != Some(pair) {
+            return Ok(false);
+        }
+        if lineage.completed_pairs[..index]
+            .iter()
+            .flatten()
+            .any(|endpoint| *endpoint == pair[0] || *endpoint == pair[1])
+        {
+            return Ok(false);
+        }
+    }
+    Ok(true)
+}
+
+fn identity_source_permutation(source_count: usize) -> RusticolResult<Vec<u32>> {
+    let mut result = Vec::new();
+    result
+        .try_reserve_exact(source_count)
+        .map_err(|error| invalid(format!("pairing identity allocation failed: {error}")))?;
+    for value in 0..source_count {
+        result.push(checked_u32(value, "pairing identity source slot")?);
+    }
+    Ok(result)
+}
+
+fn lehmer_digits(reference: &[u32], selected: &[u32]) -> RusticolResult<Vec<u32>> {
+    if reference.len() != selected.len() {
+        return Err(invalid(
+            "discovered pairing length differs from its compact class",
+        ));
+    }
+    let mut remaining = Vec::new();
+    remaining
+        .try_reserve_exact(reference.len())
+        .map_err(|error| invalid(format!("pairing permutation allocation failed: {error}")))?;
+    remaining.extend_from_slice(reference);
+    let mut digits = Vec::new();
+    digits
+        .try_reserve_exact(selected.len())
+        .map_err(|error| invalid(format!("pairing Lehmer allocation failed: {error}")))?;
+    for selected_slot in selected {
+        let position = remaining
+            .iter()
+            .position(|candidate| candidate == selected_slot)
+            .ok_or_else(|| {
+                invalid("discovered pairing is not a permutation of its compact class")
+            })?;
+        digits.push(checked_u32(position, "pairing Lehmer digit")?);
+        remaining.remove(position);
+    }
+    if !remaining.is_empty() {
+        return Err(invalid("discovered pairing omits a compact-class endpoint"));
+    }
+    Ok(digits)
+}
+
+fn resolve_pairing_owner(
+    seed: &OnTheFlyProcessSeedV1,
+    owner: &PendingPairingLineage,
+) -> RusticolResult<ResolvedPairingOwnerV1> {
+    let mut source_slot_permutation = identity_source_permutation(seed.source_anchors.len())?;
+    let mut source_lineage = Vec::new();
+    source_lineage
+        .try_reserve_exact(seed.source_anchors.len())
+        .map_err(|error| invalid(format!("pairing source-lineage allocation failed: {error}")))?;
+    source_lineage.resize(seed.source_anchors.len(), MISSING_U32);
+    if seed.pairing_classes.is_empty() {
+        if owner
+            != &(PendingPairingLineage {
+                completed_pairs: Vec::new(),
+                unmatched_endpoint: None,
+            })
+        {
+            return Err(integrity(
+                "pairing-free query retained a nontrivial closure lineage",
+            ));
+        }
+        return Ok(ResolvedPairingOwnerV1 {
+            endpoint_pairs: Vec::new(),
+            proof_digest: None,
+            source_slot_permutation,
+            source_lineage,
+            fermion_parity: 1,
+        });
+    }
+    if !complete_pairing_lineage(seed, owner)? {
+        return Err(integrity(
+            "canonical projected closure has an incomplete Wick lineage",
+        ));
+    }
+    let endpoint_pairs = try_copy_pairing_pairs(&owner.completed_pairs)?;
+    if endpoint_pairs.iter().enumerate().any(|(index, pair)| {
+        endpoint_pairs[..index]
+            .iter()
+            .any(|other| other[0] == pair[0])
+    }) {
+        return Err(integrity(
+            "canonical projected closure repeats a fundamental endpoint",
+        ));
+    }
+    let mut parity = 1_i32;
+    let mut proof_hash = Sha256::new();
+    proof_hash.update(b"pyamplicol-on-the-fly-discovered-pairing-owner-v1\0");
+    for pairing_class in &seed.pairing_classes {
+        let mut reference = Vec::new();
+        reference
+            .try_reserve_exact(pairing_class.antifundamental_endpoints.len())
+            .map_err(|error| invalid(format!("pairing reference allocation failed: {error}")))?;
+        reference.extend(
+            pairing_class
+                .antifundamental_endpoints
+                .iter()
+                .map(|endpoint| endpoint.source_slot),
+        );
+        let mut selected = Vec::new();
+        selected
+            .try_reserve_exact(pairing_class.fundamental_endpoints.len())
+            .map_err(|error| invalid(format!("selected pairing allocation failed: {error}")))?;
+        for endpoint in &pairing_class.fundamental_endpoints {
+            let selected_slot = endpoint_pairs
+                .iter()
+                .find(|pair| pair[0] == endpoint.source_slot)
+                .map(|pair| pair[1])
+                .ok_or_else(|| {
+                    integrity("canonical Wick lineage omits a pairing-class fundamental")
+                })?;
+            selected.push(selected_slot);
+        }
+        let digits = lehmer_digits(&reference, &selected)?;
+        if digits.iter().map(|digit| u64::from(*digit)).sum::<u64>() % 2 == 1 {
+            parity = -parity;
+        }
+        hash_digest(&mut proof_hash, pairing_class.semantic_digest);
+        hash_len(&mut proof_hash, selected.len(), "discovered pairing class")?;
+        for (reference_slot, selected_slot) in
+            reference.iter().copied().zip(selected.iter().copied())
+        {
+            source_slot_permutation[reference_slot as usize] = selected_slot;
+            proof_hash.update(reference_slot.to_le_bytes());
+            proof_hash.update(selected_slot.to_le_bytes());
+        }
+        for digit in digits {
+            proof_hash.update(digit.to_le_bytes());
+        }
+    }
+    validate_permutation(
+        &source_slot_permutation,
+        seed.source_anchors.len(),
+        "discovered pairing source permutation",
+    )?;
+    for (line_id, pair) in endpoint_pairs.iter().copied().enumerate() {
+        let line_id = checked_u32(line_id, "discovered pairing line ID")?;
+        for source_slot in pair {
+            let entry = source_lineage
+                .get_mut(source_slot as usize)
+                .ok_or_else(|| integrity("discovered pairing endpoint is out of range"))?;
+            if *entry != MISSING_U32 {
+                return Err(integrity(
+                    "discovered pairing endpoint belongs to multiple lines",
+                ));
+            }
+            *entry = line_id;
+        }
+    }
+    proof_hash.update(parity.to_le_bytes());
+    Ok(ResolvedPairingOwnerV1 {
+        endpoint_pairs,
+        proof_digest: Some(final_digest(proof_hash)?),
+        source_slot_permutation,
+        source_lineage,
+        fermion_parity: parity,
+    })
+}
+
+fn projected_pairing_lineages(
+    closures: &[PendingClosure],
+) -> RusticolResult<Vec<&PendingPairingLineage>> {
+    if closures.is_empty() {
+        return Err(integrity("canonical projected closure has no Wick lineage"));
+    }
+    let mut lineages = Vec::new();
+    lineages
+        .try_reserve_exact(closures.len())
+        .map_err(|error| {
+            invalid(format!(
+                "projected pairing-owner allocation failed: {error}"
+            ))
+        })?;
+    for closure in closures {
+        let [lineage] = closure.pairing_lineages.as_slice() else {
+            return Err(integrity(format!(
+                "canonical projected closure has {} Wick lineages, expected exactly one",
+                closure.pairing_lineages.len(),
+            )));
+        };
+        lineages.push(lineage);
+    }
+    Ok(lineages)
+}
+
+pub(super) fn resolve_projected_pairing_owners(
+    seed: &OnTheFlyProcessSeedV1,
+    closures: &[PendingClosure],
+) -> RusticolResult<Vec<ResolvedPairingOwnerV1>> {
+    projected_pairing_lineages(closures)?
+        .into_iter()
+        .map(|lineage| resolve_pairing_owner(seed, lineage))
+        .collect()
+}
+
+pub(super) fn supports_are_disjoint(left: &[u32], right: &[u32]) -> bool {
+    let mut left_index = 0usize;
+    let mut right_index = 0usize;
+    while left_index < left.len() && right_index < right.len() {
+        match left[left_index].cmp(&right[right_index]) {
+            std::cmp::Ordering::Less => left_index += 1,
+            std::cmp::Ordering::Greater => right_index += 1,
+            std::cmp::Ordering::Equal => return false,
+        }
+    }
+    true
+}
+
+pub(super) fn merge_disjoint_support(left: &[u32], right: &[u32]) -> RusticolResult<Vec<u32>> {
+    if !supports_are_disjoint(left, right) {
+        return Err(invalid(
+            "query-local parents have overlapping source support",
+        ));
+    }
+    let mut result = left.iter().chain(right).copied().collect::<Vec<_>>();
+    result.sort_unstable();
+    Ok(result)
+}
+
+fn selected_source_state(
+    seed: &OnTheFlyProcessSeedV1,
+    selected: OnTheFlySelectedSourceV1,
+) -> RusticolResult<(&OnTheFlySourceAnchorV1, &OnTheFlySourceStateV1)> {
+    let anchor = seed
+        .source_anchors
+        .get(selected.source_slot as usize)
+        .ok_or_else(|| invalid("selected source slot is absent from the compact seed"))?;
+    let state = anchor.selected(selected.state_index, selected.public_helicity)?;
+    Ok((anchor, state))
+}
+
+pub(super) fn validate_seed_against_templates<'a>(
+    templates: &'a ValidatedRecurrenceTemplateInput,
+    seed: &OnTheFlyProcessSeedV1,
+) -> RusticolResult<TemplateCatalog<'a>> {
+    let summary = templates.summary();
+    if summary.catalog_digest != seed.template_catalog_digest
+        || summary.compiled_model_digest != seed.model_digest
+        || summary.prepared_kernel_pack_digest != seed.prepared_pack_digest
+    {
+        return Err(integrity(
+            "compact seed belongs to a different model/template/prepared catalog",
+        ));
+    }
+    let catalog = TemplateCatalog::new(templates.input())?;
+    if catalog.coupling_order_dimension() != seed.explicit_coupling_limits().len() {
+        return Err(integrity(
+            "compact coupling-limit dimension differs from the template catalog",
+        ));
+    }
+    Ok(catalog)
+}
+
+pub(super) fn validate_source_contract(
+    templates: &ValidatedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+    anchor: &OnTheFlySourceAnchorV1,
+    state: &OnTheFlySourceStateV1,
+) -> RusticolResult<(SourceRow, crate::recurrence::template::CurrentStateRow)> {
+    let input = templates.input();
+    let source = *input
+        .sources
+        .get(state.source_template_id as usize)
+        .ok_or_else(|| integrity("compact source template is absent"))?;
+    let current_state = *input
+        .current_states
+        .get(state.current_state_template_id as usize)
+        .ok_or_else(|| integrity("compact current-state template is absent"))?;
+    if source.id != state.source_template_id
+        || current_state.id != state.current_state_template_id
+        || source.flavour_flow_id as usize >= input.flavour_flow_ranges.len()
+        || source.quantum_number_flow_id != state.quantum_number_flow_id
+        || current_state.chirality != state.chirality
+    {
+        return Err(integrity("compact source-state contract is stale"));
+    }
+    if catalog.flavour_flow(source.flavour_flow_id, "source flavour flow")?
+        != state.flavour_flow.as_ref()
+        || catalog.digest(source.semantic_digest_id, "source semantic")?
+            != state.source_semantic_digest
+        || catalog.digest(current_state.semantic_digest_id, "current-state semantic")?
+            != state.current_state_semantic_digest
+        || catalog.source_seed(source)?.proof_digest() != state.color_seed_proof_digest
+    {
+        return Err(integrity(
+            "compact source-state semantic evidence differs from the template catalog",
+        ));
+    }
+    validate_crossed_source_state(
+        anchor.is_initial,
+        &ProcessSourceStateRow {
+            source_slot: anchor.source_slot,
+            state_index: state.state_index,
+            public_helicity: state.public_helicity,
+            chirality: state.chirality,
+            spin_state: state.spin_state,
+            current_state_template_id: state.current_state_template_id,
+            source_template_id: state.source_template_id,
+            momentum_sign: state.momentum_sign,
+            // The helper does not consume the process-owned factor ID; the
+            // compact seed authenticates the exact crossing phase directly.
+            crossing_phase_factor_id: 0,
+        },
+        source,
+        input,
+    )?;
+    let binding = input
+        .evaluator_bindings
+        .get(source.evaluator_binding_id as usize)
+        .ok_or_else(|| integrity("source evaluator binding is absent"))?;
+    if binding.id != source.evaluator_binding_id
+        || EvaluatorContractKind::try_from(binding.contract_kind)? != EvaluatorContractKind::Source
+    {
+        return Err(integrity("source evaluator binding has the wrong role"));
+    }
+    Ok((source, current_state))
+}
+
+fn query_target_matches(closed: &[LCColorComponent], query: &DecodedLcQueryV1) -> bool {
+    let mut closed = closed.to_vec();
+    closed.sort_unstable();
+    closed.as_slice() == query.target_components.as_ref()
+}
+
+fn reflected_query_closure_factor(
+    query: &DecodedLcQueryV1,
+    closed: &[LCColorComponent],
+    colors: &DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+    parent_ids: [u32; 2],
+) -> RusticolResult<Option<ExactComplexRational>> {
+    let mut certified_parent = None;
+    for parent_id in parent_ids {
+        let current = currents
+            .get(parent_id as usize)
+            .ok_or_else(|| integrity("query-local closure reflection parent is absent"))?;
+        let Some(certificate) = current.reflection_certificate.as_ref() else {
+            continue;
+        };
+        if certified_parent.replace((current, certificate)).is_some() {
+            return Err(integrity(
+                "one query-local closure references multiple folded reflection orbits",
+            ));
+        }
+    }
+    let Some((current, certificate)) = certified_parent else {
+        return Ok(None);
+    };
+    let proof = current.reflection.proof().ok_or_else(|| {
+        integrity("certified query-local closure parent has no reflection lineage")
+    })?;
+    if proof.proof_digest() != certificate.canonical_lineage_digest() {
+        return Err(integrity(
+            "query-local closure reflection lineage differs from its certificate",
+        ));
+    }
+    let color = colors
+        .get(current.key.dynamic_lc_color_state_id())
+        .ok_or_else(|| integrity("query-local closure reflection color is absent"))?;
+    if dynamic_color_identity_digest(color)? != certificate.canonical_color_identity() {
+        return Err(integrity(
+            "query-local closure reflection color differs from its certificate",
+        ));
+    }
+    if !certificate.is_reciprocal_two_cycle() {
+        return Err(integrity(
+            "query-local closure reflection certificate is not a reciprocal two-cycle",
+        ));
+    }
+    let [closed_trace] = closed else {
+        return Ok(None);
+    };
+    let [target_trace] = query.target_components.as_ref() else {
+        return Ok(None);
+    };
+    let source_count = query.selected_sources.len();
+    if source_count <= 2
+        || closed_trace.kind() != LCColorComponentKind::Trace
+        || target_trace.kind() != LCColorComponentKind::Trace
+        || closed_trace.source_slots().len() != source_count
+        || target_trace.source_slots().len() != source_count
+    {
+        return Ok(None);
+    }
+    validate_permutation(
+        closed_trace.source_slots(),
+        source_count,
+        "query-local reflected closure word",
+    )?;
+    let permutation = certificate.source_permutation();
+    validate_permutation(
+        permutation,
+        source_count,
+        "query-local closure reflection permutation",
+    )?;
+    if permutation.get(query.closure_anchor_slot as usize).copied()
+        != Some(query.closure_anchor_slot)
+    {
+        return Err(integrity(
+            "query-local closure reflection does not fix its certified anchor",
+        ));
+    }
+    let mapped_word = closed_trace
+        .source_slots()
+        .iter()
+        .map(|source_slot| {
+            permutation
+                .get(*source_slot as usize)
+                .copied()
+                .ok_or_else(|| integrity("closure reflection omits a source slot"))
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let mapped_trace = LCColorComponent::new(LCColorComponentKind::Trace, mapped_word)?;
+    if &mapped_trace == closed_trace {
+        return Err(integrity(
+            "query-local closure reflection maps a trace to a cyclic fixed point",
+        ));
+    }
+    Ok((&mapped_trace == target_trace).then_some(certificate.canonical_phase()))
+}
+
+#[allow(clippy::too_many_arguments)] // Explicitly mirrors the query-local sweep state.
+pub(super) fn insert_selected_sources(
+    grammar: &PreparedOnTheFlyGrammarV1,
+    seed: &OnTheFlyProcessSeedV1,
+    coupling_limits: &[Option<u32>],
+    query: &DecodedLcQueryV1,
+    enable_cyclic_trace_reflection: bool,
+    colors: &mut DynamicLCColorStateInterner,
+    currents: &mut Vec<PendingCurrent>,
+    current_ids: &mut BTreeMap<CurrentCoreKey, u32>,
+) -> RusticolResult<()> {
+    if coupling_limits.len() != seed.explicit_coupling_limits().len() {
+        return Err(integrity(
+            "resolved coupling-limit dimension differs from the compact seed",
+        ));
+    }
+    let zero_orders = vec![0_u32; coupling_limits.len()];
+    for selected in query.selected_sources.iter().copied() {
+        let (_, state) = selected_source_state(seed, selected)?;
+        let contract = grammar
+            .sources
+            .get(&(state.source_template_id, state.current_state_template_id))
+            .ok_or_else(|| integrity("selected source has no prepared source contract"))?;
+        let color = contract.color_seed.instantiate(
+            selected.source_slot,
+            contract.current_state.color_representation,
+        )?;
+        let color_id = colors.intern(color)?;
+        let reflection = if enable_cyclic_trace_reflection {
+            source_reflection(
+                colors,
+                color_id,
+                selected.source_slot,
+                state.color_seed_proof_digest,
+            )?
+        } else {
+            CurrentReflection::Unavailable
+        };
+        let key = CurrentCoreKey::new(
+            seed.template_catalog_digest,
+            RecurrenceNodeKind::Source,
+            state.current_state_template_id,
+            color_id,
+            vec![selected.source_slot],
+            CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                source_slot: selected.source_slot,
+                coefficient: state.momentum_sign,
+            }])?,
+            CurrentHelicityIdentity::topology_replay(
+                state.spin_state,
+                vec![SourceStateAssignment::new(
+                    selected.source_slot,
+                    selected.state_index,
+                )],
+            )?,
+            state.flavour_flow.to_vec(),
+            state.quantum_number_flow_id,
+            zero_orders.clone(),
+            CurrentSourceBinding::FixedTemplate(state.source_template_id),
+            None,
+        )?;
+        let id = checked_u32(currents.len(), "query-local current count")?;
+        if current_ids.insert(key.clone(), id).is_some() {
+            return Err(integrity(
+                "selected source construction produced a duplicate current",
+            ));
+        }
+        currents.push(PendingCurrent {
+            key,
+            source_factor: Some(state.crossing_phase),
+            contributions: BTreeMap::new(),
+            pairing_lineages: vec![PendingPairingLineage::source(seed, selected.source_slot)],
+            stage: 0,
+            reflection,
+            reflection_certificate: None,
+        });
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn include_transition(
+    templates: &ValidatedRecurrenceTemplateInput,
+    prepared: &PreparedTransition,
+    transition_reflections: &TransitionReflectionIndex,
+    enable_cyclic_trace_reflection: bool,
+    concrete_parent_ids: [u32; 2],
+    source_count: usize,
+    seed: &OnTheFlyProcessSeedV1,
+    fermion_ordering: &FermionOrderingContext,
+    coupling_limits: &[Option<u32>],
+    propagators: &BTreeMap<u32, Option<u32>>,
+    colors: &mut DynamicLCColorStateInterner,
+    currents: &mut Vec<PendingCurrent>,
+    current_ids: &mut BTreeMap<CurrentCoreKey, u32>,
+) -> RusticolResult<()> {
+    let parents = [
+        &currents[concrete_parent_ids[0] as usize].key,
+        &currents[concrete_parent_ids[1] as usize].key,
+    ];
+    if !(0..2).all(|index| {
+        prepared.input_states[index] == parents[index].current_state_template_id()
+            && quantum_parent_spin_matches(prepared.input_spins[index], parents[index])
+    }) {
+        return Ok(());
+    }
+    if let Some(contact_orbit) = prepared.contact_orbit.as_ref()
+        && !contact_orbit.accepts_parent_domain(parents)?
+    {
+        return Ok(());
+    }
+    let Some(coupling_orders) = combined_coupling_orders(
+        parents[0].coupling_orders(),
+        parents[1].coupling_orders(),
+        &prepared.local_orders,
+        coupling_limits,
+    )?
+    else {
+        return Ok(());
+    };
+    let support = merge_disjoint_support(
+        parents[0].support_source_slots(),
+        parents[1].support_source_slots(),
+    )?;
+    if support.len() >= source_count {
+        return Ok(());
+    }
+    let helicity = merged_helicity_identity(
+        parents[0].helicity_identity(),
+        parents[1].helicity_identity(),
+        prepared.quantum.result_spin_state,
+    )?;
+    let flavour = prepared.flavour.apply(parents);
+    let momentum = merged_momentum(parents[0].momentum(), parents[1].momentum())?;
+    let parent_colors = [
+        colors
+            .get(parents[0].dynamic_lc_color_state_id())
+            .ok_or_else(|| integrity("left query-local color state disappeared"))?
+            .clone(),
+        colors
+            .get(parents[1].dynamic_lc_color_state_id())
+            .ok_or_else(|| integrity("right query-local color state disappeared"))?
+            .clone(),
+    ];
+    let (evaluator_parent_ids, exchange_factor) = prepared.evaluator_parents(concrete_parent_ids);
+    let fermion_factor = fermion_ordering_factor(
+        &templates.input().current_states,
+        [
+            parents[0].current_state_template_id(),
+            parents[1].current_state_template_id(),
+        ],
+        [
+            parents[0].support_source_slots(),
+            parents[1].support_source_slots(),
+        ],
+        fermion_ordering,
+    )?;
+    let result_state = templates
+        .input()
+        .current_states
+        .get(prepared.row.result_state_template_id as usize)
+        .ok_or_else(|| integrity("pairing-lineage result state is absent"))?;
+    let carries_colored_fermion_line =
+        result_state.statistics == 1 && result_state.color_representation != 1;
+    let pairing_lineages = combine_pairing_lineage_sets(
+        seed,
+        &currents[concrete_parent_ids[0] as usize].pairing_lineages,
+        &currents[concrete_parent_ids[1] as usize].pairing_lineages,
+        carries_colored_fermion_line,
+    )?;
+    if pairing_lineages.is_empty() {
+        return Ok(());
+    }
+    let parent_reflections = if enable_cyclic_trace_reflection {
+        [
+            currents[concrete_parent_ids[0] as usize].reflection.clone(),
+            currents[concrete_parent_ids[1] as usize].reflection.clone(),
+        ]
+    } else {
+        [
+            CurrentReflection::Unavailable,
+            CurrentReflection::Unavailable,
+        ]
+    };
+    let reversal_masks = if enable_cyclic_trace_reflection {
+        current_reversal_masks(&parent_colors, &parent_reflections)
+    } else {
+        vec![0]
+    };
+    let local_reflection_proof = enable_cyclic_trace_reflection
+        .then(|| transition_reflections.proof(prepared.row.id))
+        .flatten();
+    let output_factor = prepared.output_factor()?;
+    for prepared_witness in &prepared.witnesses {
+        if prepared_witness.row.left_shape_string_id != parent_colors[0].output_color_shape_id()
+            || prepared_witness.row.right_shape_string_id
+                != parent_colors[1].output_color_shape_id()
+        {
+            continue;
+        }
+        for reversal_mask in reversal_masks.iter().copied() {
+            let mut variant_colors = parent_colors.clone();
+            let mut reversal_factor = ExactComplexRational::ONE;
+            for index in 0..2 {
+                if reversal_mask & (1 << index) == 0 {
+                    continue;
+                }
+                variant_colors[index] = variant_colors[index].reversed()?;
+                reversal_factor = reversal_factor.checked_mul(
+                    parent_reflections[index]
+                        .phase()
+                        .expect("reversal mask requires a proven parent phase"),
+                )?;
+            }
+            let Some(result_color) = prepared_witness
+                .witness
+                .apply(&variant_colors[0], &variant_colors[1])?
+            else {
+                continue;
+            };
+            let result_reflection = current_reflection_candidate(
+                &result_color,
+                &parent_reflections,
+                local_reflection_proof,
+            )?;
+            #[cfg(feature = "on-the-fly-test-support")]
+            let diagnostic_result_reflection = result_reflection.clone();
+            let color_id = colors.intern(result_color)?;
+            let propagator_template_id = if support.len() + 1 < source_count {
+                propagators
+                    .get(&prepared.row.result_state_template_id)
+                    .copied()
+                    .flatten()
+            } else {
+                None
+            };
+            let key = CurrentCoreKey::new(
+                seed.template_catalog_digest,
+                RecurrenceNodeKind::Current,
+                prepared.row.result_state_template_id,
+                color_id,
+                support.clone(),
+                momentum.clone(),
+                helicity.clone(),
+                flavour.clone(),
+                prepared.quantum.result_quantum_number_flow_id,
+                coupling_orders.clone(),
+                CurrentSourceBinding::None,
+                propagator_template_id,
+            )?;
+            let result_id = if let Some(id) = current_ids.get(&key).copied() {
+                currents[id as usize]
+                    .reflection
+                    .include(result_reflection)?;
+                id
+            } else {
+                let id = checked_u32(currents.len(), "query-local current count")?;
+                let map_key = key.clone();
+                let pending = PendingCurrent {
+                    key,
+                    source_factor: None,
+                    contributions: BTreeMap::new(),
+                    pairing_lineages: try_clone_pairing_lineages(&pairing_lineages)?,
+                    stage: checked_u32(support.len() - 1, "query-local current stage")?,
+                    reflection: result_reflection
+                        .map_or(CurrentReflection::Unavailable, CurrentReflection::Proven),
+                    reflection_certificate: None,
+                };
+                current_ids.insert(map_key, id);
+                currents.push(pending);
+                id
+            };
+            extend_pairing_lineages(
+                &mut currents[result_id as usize].pairing_lineages,
+                &pairing_lineages,
+            )?;
+            let contribution_key = ContributionKey::new(
+                prepared.row.id,
+                evaluator_parent_ids.to_vec(),
+                evaluator_parent_ids
+                    .iter()
+                    .map(|id| currents[*id as usize].key.current_state_template_id())
+                    .collect(),
+                evaluator_parent_ids
+                    .iter()
+                    .map(|id| currents[*id as usize].key.momentum().clone())
+                    .collect(),
+                prepared.row.result_state_template_id,
+                prepared.quantum.id,
+                LCColorWitnessTermId::new(
+                    prepared.row.color_contraction_template_id,
+                    prepared_witness.row.ordinal,
+                ),
+                prepared.quantum_semantic_digest,
+                prepared.row.output_projection_string_id,
+            )?;
+            let pending_key = PendingContributionKey {
+                parent_current_ids: evaluator_parent_ids,
+                key: contribution_key,
+            };
+            let witness_factor = prepared_witness.witness.exact_factor();
+            let factor = multiply_factors(&[
+                prepared.base_factor,
+                output_factor,
+                exchange_factor,
+                witness_factor,
+                fermion_factor,
+                reversal_factor,
+            ])?;
+            let aggregate = currents[result_id as usize]
+                .contributions
+                .entry(pending_key)
+                .or_insert(ExactComplexRational::ZERO);
+            aggregate_factor(aggregate, factor)?;
+            #[cfg(feature = "on-the-fly-test-support")]
+            let aggregate_factor_after = *aggregate;
+            #[cfg(feature = "on-the-fly-test-support")]
+            'transition_diagnostic: {
+                if !crate::recurrence::diagnostic::transition_diagnostic_observation_active() {
+                    break 'transition_diagnostic;
+                }
+                use crate::recurrence::diagnostic::{
+                    ConstructionTransitionDiagnosticRowV1, observe_transition_diagnostic,
+                };
+
+                let digest = |current_id: u32| -> RusticolResult<SemanticDigest> {
+                    let current = currents
+                        .get(current_id as usize)
+                        .ok_or_else(|| integrity("diagnostic current is absent"))?;
+                    let color = colors
+                        .get(current.key.dynamic_lc_color_state_id())
+                        .ok_or_else(|| integrity("diagnostic current color is absent"))?;
+                    super::trace::hash_current_key(&current.key, color)
+                };
+                let result_color = colors
+                    .get(currents[result_id as usize].key.dynamic_lc_color_state_id())
+                    .ok_or_else(|| integrity("diagnostic result color is absent"))?;
+                observe_transition_diagnostic(ConstructionTransitionDiagnosticRowV1 {
+                    materialized_sector_id: None,
+                    output_current_digest: digest(result_id)?,
+                    ordered_parent_digests: [
+                        digest(evaluator_parent_ids[0])?,
+                        digest(evaluator_parent_ids[1])?,
+                    ],
+                    transition_template_id: prepared.row.id,
+                    transition_semantic_digest: prepared.transition_semantic_digest,
+                    evaluator_binding_semantic_digest: prepared.evaluator_binding_digest,
+                    result_state_template_id: prepared.row.result_state_template_id,
+                    quantum_flow_witness_id: prepared.quantum.id,
+                    quantum_semantic_digest: prepared.quantum_semantic_digest,
+                    color_contraction_template_id: prepared.row.color_contraction_template_id,
+                    color_witness_ordinal: prepared_witness.row.ordinal,
+                    color_witness_proof_digest: prepared_witness.witness.proof_digest(),
+                    output_projection_id: prepared.row.output_projection_string_id,
+                    transition_factor: prepared.transition_factor,
+                    contraction_factor: prepared.contraction_factor,
+                    output_factor,
+                    exchange_factor,
+                    witness_factor,
+                    reversal_mask,
+                    reversal_factor,
+                    candidate_factor: factor,
+                    aggregate_factor_after,
+                    parent_reflection_proof_digests: [
+                        parent_reflections[0]
+                            .proof()
+                            .map(|proof| proof.proof_digest()),
+                        parent_reflections[1]
+                            .proof()
+                            .map(|proof| proof.proof_digest()),
+                    ],
+                    parent_reflection_phases: [
+                        parent_reflections[0].phase(),
+                        parent_reflections[1].phase(),
+                    ],
+                    local_reflection_proof_digest: local_reflection_proof
+                        .map(|proof| proof.proof_digest()),
+                    local_reflection_phase: local_reflection_proof.map(|proof| proof.phase()),
+                    result_reflection_proof_digest: diagnostic_result_reflection
+                        .as_ref()
+                        .map(|proof| proof.proof_digest()),
+                    result_reflection_phase: diagnostic_result_reflection
+                        .as_ref()
+                        .map(|proof| proof.phase()),
+                    output_color_orientation: format!("{result_color:?}"),
+                });
+            }
+        }
+    }
+    Ok(())
+}
+
+#[derive(Debug)]
+struct QuerySupportSizeIndex {
+    support_size_by_current: Vec<usize>,
+    composite_parent_eligible_by_current: Vec<bool>,
+    current_ids_by_size: Vec<Vec<usize>>,
+}
+
+impl QuerySupportSizeIndex {
+    fn new(
+        currents: &[PendingCurrent],
+        source_count: usize,
+        closure_anchor_slot: Option<u32>,
+    ) -> RusticolResult<Self> {
+        if closure_anchor_slot.is_some_and(|slot| slot as usize >= source_count) {
+            return Err(invalid(
+                "query closure anchor is outside the forward source domain",
+            ));
+        }
+        let mut index = Self {
+            support_size_by_current: Vec::with_capacity(currents.len()),
+            composite_parent_eligible_by_current: Vec::with_capacity(currents.len()),
+            current_ids_by_size: (0..source_count).map(|_| Vec::new()).collect(),
+        };
+        let mut anchor_source_count = 0usize;
+        for (current_id, current) in currents.iter().enumerate() {
+            let support = current.key.support_source_slots();
+            let contains_anchor =
+                closure_anchor_slot.is_some_and(|anchor| support.binary_search(&anchor).is_ok());
+            if contains_anchor {
+                let anchor = closure_anchor_slot.expect("tested present closure anchor");
+                if current.key.node_kind() != RecurrenceNodeKind::Source || support != [anchor] {
+                    return Err(integrity(
+                        "initial forward domain contains a non-singleton closure-anchor current",
+                    ));
+                }
+                anchor_source_count += 1;
+            }
+            index.append(current_id, support.len(), !contains_anchor)?;
+        }
+        if closure_anchor_slot.is_some() && anchor_source_count != 1 {
+            return Err(integrity(
+                "initial forward domain must contain exactly one singleton closure-anchor source",
+            ));
+        }
+        Ok(index)
+    }
+
+    fn append(
+        &mut self,
+        current_id: usize,
+        support_size: usize,
+        composite_parent_eligible: bool,
+    ) -> RusticolResult<()> {
+        if current_id != self.support_size_by_current.len()
+            || current_id != self.composite_parent_eligible_by_current.len()
+        {
+            return Err(integrity(
+                "query-local support-size index lost current-ID order",
+            ));
+        }
+        let bucket = self
+            .current_ids_by_size
+            .get_mut(support_size)
+            .filter(|_| support_size > 0)
+            .ok_or_else(|| integrity("query-local current has invalid forward support size"))?;
+        self.support_size_by_current.push(support_size);
+        self.composite_parent_eligible_by_current
+            .push(composite_parent_eligible);
+        if composite_parent_eligible {
+            bucket.push(current_id);
+        }
+        Ok(())
+    }
+
+    fn append_stage(
+        &mut self,
+        currents: &[PendingCurrent],
+        stage_current_start: usize,
+        target_size: usize,
+        closure_anchor_slot: Option<u32>,
+    ) -> RusticolResult<()> {
+        if stage_current_start != self.support_size_by_current.len()
+            || stage_current_start != self.composite_parent_eligible_by_current.len()
+            || stage_current_start > currents.len()
+        {
+            return Err(integrity(
+                "query-local support-size index differs from the stage prefix",
+            ));
+        }
+        for (current_id, current) in currents.iter().enumerate().skip(stage_current_start) {
+            let support = current.key.support_source_slots();
+            let support_size = support.len();
+            if support_size != target_size {
+                return Err(integrity(
+                    "query-local sweep produced a current in the wrong support-size stage",
+                ));
+            }
+            if closure_anchor_slot.is_some_and(|anchor| support.binary_search(&anchor).is_ok()) {
+                return Err(integrity(
+                    "query-local sweep produced a composite containing the closure anchor",
+                ));
+            }
+            self.append(current_id, support_size, true)?;
+        }
+        Ok(())
+    }
+
+    fn for_each_parent_pair(
+        &self,
+        target_size: usize,
+        stage_current_end: usize,
+        mut visit: impl FnMut([usize; 2]) -> RusticolResult<()>,
+    ) -> RusticolResult<()> {
+        if stage_current_end != self.support_size_by_current.len()
+            || stage_current_end != self.composite_parent_eligible_by_current.len()
+        {
+            return Err(integrity(
+                "query-local support-size schedule differs from its current prefix",
+            ));
+        }
+        for left_id in 0..stage_current_end {
+            if !self.composite_parent_eligible_by_current[left_id] {
+                continue;
+            }
+            let left_size = self.support_size_by_current[left_id];
+            if left_size >= target_size {
+                continue;
+            }
+            let right_size = target_size - left_size;
+            let right_ids = self
+                .current_ids_by_size
+                .get(right_size)
+                .ok_or_else(|| integrity("query-local right support-size bucket is absent"))?;
+            let first_right = right_ids.partition_point(|right_id| *right_id <= left_id);
+            for right_id in right_ids[first_right..].iter().copied() {
+                visit([left_id, right_id])?;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Fold only a completely certified reciprocal pure-adjoint orbit after the
+/// stage fan-in and contact-owner selection are final.  Any missing, stale, or
+/// contradictory proof retains both orientations.
+fn reconcile_on_the_fly_stage_reflections(
+    stage_start: usize,
+    colors: &mut DynamicLCColorStateInterner,
+    currents: &mut Vec<PendingCurrent>,
+    current_ids: &mut BTreeMap<CurrentCoreKey, u32>,
+    source_count: usize,
+) -> RusticolResult<()> {
+    if stage_start > currents.len() {
+        return Err(invalid(
+            "query-local reflection stage starts beyond current storage",
+        ));
+    }
+    let stage_end = currents.len();
+    let mut visited = vec![false; stage_end - stage_start];
+    let mut prune = vec![false; stage_end - stage_start];
+
+    for current_index in stage_start..stage_end {
+        let local_index = current_index - stage_start;
+        if visited[local_index] {
+            continue;
+        }
+        let key = currents[current_index].key.clone();
+        let color = colors
+            .get(key.dynamic_lc_color_state_id())
+            .ok_or_else(|| integrity("query-local reflection color disappeared"))?
+            .clone();
+        let Some(word) = color.pure_adjoint_word() else {
+            continue;
+        };
+        if word.len() < 2 {
+            continue;
+        }
+        let canonical = pure_adjoint_word_is_canonical(word);
+        let reversed_color_id = colors.intern(color.reversed()?)?;
+        if reversed_color_id == key.dynamic_lc_color_state_id() {
+            currents[current_index].reflection = CurrentReflection::Unavailable;
+            continue;
+        }
+        let reversed_key = current_key_with_dynamic_color(&key, reversed_color_id)?;
+        let Some(reversed_id) = current_ids.get(&reversed_key).copied() else {
+            currents[current_index].reflection = CurrentReflection::Unavailable;
+            continue;
+        };
+        let reversed_index = reversed_id as usize;
+        if !(stage_start..stage_end).contains(&reversed_index) {
+            currents[current_index].reflection = CurrentReflection::Unavailable;
+            continue;
+        }
+        let reversed_local_index = reversed_index - stage_start;
+        visited[local_index] = true;
+        visited[reversed_local_index] = true;
+
+        let reversed_color = colors
+            .get(reversed_color_id)
+            .ok_or_else(|| integrity("query-local reversed reflection color disappeared"))?;
+        let Some(reversed_word) = reversed_color.pure_adjoint_word() else {
+            currents[current_index].reflection = CurrentReflection::Unavailable;
+            currents[reversed_index].reflection = CurrentReflection::Unavailable;
+            continue;
+        };
+        let reciprocal = reciprocal_reflection_proof(
+            &currents[current_index].reflection,
+            &currents[reversed_index].reflection,
+        )?;
+        if !reciprocal || canonical == pure_adjoint_word_is_canonical(reversed_word) {
+            currents[current_index].reflection = CurrentReflection::Unavailable;
+            currents[reversed_index].reflection = CurrentReflection::Unavailable;
+            continue;
+        }
+        let (canonical_index, reflected_index, pruned_local_index) = if canonical {
+            (current_index, reversed_index, reversed_local_index)
+        } else {
+            (reversed_index, current_index, local_index)
+        };
+        let canonical_proof = currents[canonical_index]
+            .reflection
+            .proof()
+            .cloned()
+            .ok_or_else(|| integrity("canonical query-local reflection proof disappeared"))?;
+        let reflected_proof = currents[reflected_index]
+            .reflection
+            .proof()
+            .cloned()
+            .ok_or_else(|| integrity("reflected query-local reflection proof disappeared"))?;
+        for (label, index, proof) in [
+            ("canonical", canonical_index, &canonical_proof),
+            ("reflected", reflected_index, &reflected_proof),
+        ] {
+            let current_color = colors
+                .get(currents[index].key.dynamic_lc_color_state_id())
+                .ok_or_else(|| integrity(format!("{label} query-local color disappeared")))?;
+            if dynamic_color_identity_digest(current_color)? != proof.result_color_identity() {
+                return Err(integrity(format!(
+                    "{label} query-local reflection proof has a stale color identity"
+                )));
+            }
+        }
+        let canonical_color = colors
+            .get(currents[canonical_index].key.dynamic_lc_color_state_id())
+            .ok_or_else(|| integrity("canonical query-local reflection color disappeared"))?;
+        let reflected_color = colors
+            .get(currents[reflected_index].key.dynamic_lc_color_state_id())
+            .ok_or_else(|| integrity("reflected query-local reflection color disappeared"))?;
+        currents[canonical_index].reflection_certificate =
+            Some(PendingReflectionCertificate::reciprocal_pair(
+                checked_u32(canonical_index, "query-local reflection certificate ID")?,
+                checked_u32(
+                    canonical_index,
+                    "canonical query-local reflection current ID",
+                )?,
+                checked_u32(
+                    reflected_index,
+                    "reflected query-local reflection current ID",
+                )?,
+                &canonical_proof,
+                &reflected_proof,
+                canonical_color,
+                reflected_color,
+                source_count,
+            )?);
+        prune[pruned_local_index] = true;
+    }
+
+    for current in &currents[stage_start..] {
+        current_ids.remove(&current.key);
+    }
+    let stage_currents = currents.split_off(stage_start);
+    for (local_index, current) in stage_currents.into_iter().enumerate() {
+        if prune[local_index] {
+            continue;
+        }
+        if current
+            .contributions
+            .keys()
+            .flat_map(|contribution| contribution.parent_current_ids)
+            .any(|parent_id| parent_id as usize >= stage_start)
+        {
+            return Err(integrity(
+                "query-local reflection stage depends on another current in the same stage",
+            ));
+        }
+        let current_id = checked_u32(currents.len(), "query-local reflected current ID")?;
+        if current_ids
+            .insert(current.key.clone(), current_id)
+            .is_some()
+        {
+            return Err(integrity(
+                "query-local reflection reconciliation produced a duplicate current",
+            ));
+        }
+        currents.push(current);
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)] // Explicitly mirrors the query-local sweep state.
+pub(super) fn build_forward_currents(
+    templates: &ValidatedRecurrenceTemplateInput,
+    transitions: &BTreeMap<(u32, u32), Vec<PreparedTransition>>,
+    transition_reflections: &TransitionReflectionIndex,
+    contact_orbits: &PreparedContactOrbitIndex,
+    enable_cyclic_trace_reflection: bool,
+    seed: &OnTheFlyProcessSeedV1,
+    fermion_ordering: &FermionOrderingContext,
+    closure_anchor_slot: u32,
+    coupling_limits: &[Option<u32>],
+    propagators: &BTreeMap<u32, Option<u32>>,
+    colors: &mut DynamicLCColorStateInterner,
+    currents: &mut Vec<PendingCurrent>,
+    current_ids: &mut BTreeMap<CurrentCoreKey, u32>,
+) -> RusticolResult<()> {
+    build_forward_currents_with_anchor_exclusion(
+        templates,
+        transitions,
+        transition_reflections,
+        contact_orbits,
+        enable_cyclic_trace_reflection,
+        seed,
+        fermion_ordering,
+        Some(closure_anchor_slot),
+        coupling_limits,
+        propagators,
+        colors,
+        currents,
+        current_ids,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_forward_currents_with_anchor_exclusion(
+    templates: &ValidatedRecurrenceTemplateInput,
+    transitions: &BTreeMap<(u32, u32), Vec<PreparedTransition>>,
+    transition_reflections: &TransitionReflectionIndex,
+    contact_orbits: &PreparedContactOrbitIndex,
+    enable_cyclic_trace_reflection: bool,
+    seed: &OnTheFlyProcessSeedV1,
+    fermion_ordering: &FermionOrderingContext,
+    closure_anchor_slot: Option<u32>,
+    coupling_limits: &[Option<u32>],
+    propagators: &BTreeMap<u32, Option<u32>>,
+    colors: &mut DynamicLCColorStateInterner,
+    currents: &mut Vec<PendingCurrent>,
+    current_ids: &mut BTreeMap<CurrentCoreKey, u32>,
+) -> RusticolResult<()> {
+    let source_count = seed.source_anchors.len();
+    // The selected closure always combines its singleton anchor source with
+    // the exact complementary support. Supports only grow by disjoint union,
+    // so a composite containing the anchor can never feed that complement.
+    // Keep the source current itself for closure, but exclude it from the
+    // ordered composite-parent schedule before any transition is considered.
+    let mut support_size_index =
+        QuerySupportSizeIndex::new(currents, source_count, closure_anchor_slot)?;
+    for target_size in 2..source_count {
+        let stage_current_start = currents.len();
+        support_size_index.for_each_parent_pair(
+            target_size,
+            stage_current_start,
+            |[left_index, right_index]| {
+                let left = &currents[left_index].key;
+                let right = &currents[right_index].key;
+                debug_assert_eq!(
+                    left.support_source_slots().len() + right.support_source_slots().len(),
+                    target_size,
+                );
+                if !supports_are_disjoint(left.support_source_slots(), right.support_source_slots())
+                {
+                    return Ok(());
+                }
+                let left_state = left.current_state_template_id();
+                let right_state = right.current_state_template_id();
+                let Some(rows) = transitions.get(&canonical_state_pair(left_state, right_state))
+                else {
+                    return Ok(());
+                };
+                let left_id = checked_u32(left_index, "query-local parent ID")?;
+                let right_id = checked_u32(right_index, "query-local parent ID")?;
+                for prepared in rows {
+                    let Some(parent_ids) =
+                        prepared.parent_ids(left_state, right_state, left_id, right_id)
+                    else {
+                        continue;
+                    };
+                    include_transition(
+                        templates,
+                        prepared,
+                        transition_reflections,
+                        enable_cyclic_trace_reflection,
+                        parent_ids,
+                        source_count,
+                        seed,
+                        fermion_ordering,
+                        coupling_limits,
+                        propagators,
+                        colors,
+                        currents,
+                        current_ids,
+                    )?;
+                }
+                Ok(())
+            },
+        )?;
+        if !contact_orbits.is_empty()
+            && let Some(plan) = plan_on_the_fly_contact_orbit_owners(
+                stage_current_start,
+                transitions,
+                contact_orbits,
+                currents,
+            )?
+        {
+            plan.commit(currents);
+        }
+        if enable_cyclic_trace_reflection {
+            reconcile_on_the_fly_stage_reflections(
+                stage_current_start,
+                colors,
+                currents,
+                current_ids,
+                source_count,
+            )?;
+        }
+        support_size_index.append_stage(
+            currents,
+            stage_current_start,
+            target_size,
+            closure_anchor_slot,
+        )?;
+    }
+    Ok(())
+}
+
+fn closure_quantum_matches(
+    quantum: &PreparedClosureQuantum,
+    parents: [&CurrentCoreKey; 2],
+) -> bool {
+    match (quantum.input_states, quantum.input_spins) {
+        (None, None) => true,
+        (Some(states), Some(spins)) => (0..2).all(|index| {
+            states[index] == parents[index].current_state_template_id()
+                && quantum_parent_spin_matches(spins[index], parents[index])
+        }),
+        _ => false,
+    }
+}
+
+#[allow(clippy::too_many_arguments)] // Explicitly mirrors the query-local sweep state.
+pub(super) fn build_selected_closures(
+    templates: &ValidatedRecurrenceTemplateInput,
+    closures: &BTreeMap<(u32, u32), Vec<PreparedClosure>>,
+    seed: &OnTheFlyProcessSeedV1,
+    fermion_ordering: &FermionOrderingContext,
+    query: &DecodedLcQueryV1,
+    enable_cyclic_trace_reflection: bool,
+    colors: &DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+) -> RusticolResult<Option<Vec<PendingClosure>>> {
+    let anchor_support = [query.closure_anchor_slot];
+    let complement_support = (0..query.selected_sources.len() as u32)
+        .filter(|slot| *slot != query.closure_anchor_slot)
+        .collect::<Vec<_>>();
+    let anchor_ids = currents
+        .iter()
+        .enumerate()
+        .filter(|(_, current)| {
+            current.key.node_kind() == RecurrenceNodeKind::Source
+                && current.key.support_source_slots() == anchor_support
+        })
+        .map(|(id, _)| checked_u32(id, "closure anchor current ID"))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    if anchor_ids.len() != 1 {
+        return Err(invalid(
+            "decoded closure anchor does not identify exactly one source",
+        ));
+    }
+    let complement_ids = currents
+        .iter()
+        .enumerate()
+        .filter(|(_, current)| current.key.support_source_slots() == complement_support)
+        .map(|(id, _)| checked_u32(id, "closure complement current ID"))
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let mut retained = BTreeMap::<PendingClosureKey, PendingClosure>::new();
+    let anchor_id = anchor_ids[0];
+    let anchor_state = currents[anchor_id as usize].key.current_state_template_id();
+    for complement_id in complement_ids {
+        let complement_state = currents[complement_id as usize]
+            .key
+            .current_state_template_id();
+        let Some(rows) = closures.get(&canonical_state_pair(anchor_state, complement_state)) else {
+            continue;
+        };
+        for closure in rows {
+            let Some(concrete_parent_ids) =
+                closure.parent_ids(anchor_state, complement_state, anchor_id, complement_id)
+            else {
+                continue;
+            };
+            let parents = [
+                &currents[concrete_parent_ids[0] as usize].key,
+                &currents[concrete_parent_ids[1] as usize].key,
+            ];
+            let pairing_lineages = combine_pairing_lineage_sets(
+                // A physical closure is bosonic and must close the final
+                // unmatched fundamental/antifundamental pair, if any.
+                // Completed pairs remain query-local proof state only.
+                seed,
+                &currents[concrete_parent_ids[0] as usize].pairing_lineages,
+                &currents[concrete_parent_ids[1] as usize].pairing_lineages,
+                false,
+            )?;
+            let mut complete_lineages = Vec::new();
+            complete_lineages
+                .try_reserve_exact(pairing_lineages.len())
+                .map_err(|error| {
+                    invalid(format!(
+                        "complete pairing-lineage allocation failed: {error}"
+                    ))
+                })?;
+            for lineage in pairing_lineages {
+                if complete_pairing_lineage(seed, &lineage)? {
+                    complete_lineages.push(lineage);
+                }
+            }
+            let pairing_lineages = complete_lineages;
+            if pairing_lineages.is_empty() {
+                continue;
+            }
+            let parent_colors = [
+                colors
+                    .get(parents[0].dynamic_lc_color_state_id())
+                    .ok_or_else(|| integrity("closure left color state disappeared"))?,
+                colors
+                    .get(parents[1].dynamic_lc_color_state_id())
+                    .ok_or_else(|| integrity("closure right color state disappeared"))?,
+            ];
+            let (evaluator_parent_ids, exchange_factor) =
+                closure.evaluator_parents(concrete_parent_ids);
+            let fermion_factor = fermion_ordering_factor(
+                &templates.input().current_states,
+                [
+                    parents[0].current_state_template_id(),
+                    parents[1].current_state_template_id(),
+                ],
+                [
+                    parents[0].support_source_slots(),
+                    parents[1].support_source_slots(),
+                ],
+                fermion_ordering,
+            )?;
+            for quantum in closure
+                .quantum_flows
+                .iter()
+                .filter(|quantum| closure_quantum_matches(quantum, parents))
+            {
+                for witness in &closure.witnesses {
+                    if witness.row.left_shape_string_id != parent_colors[0].output_color_shape_id()
+                        || witness.row.right_shape_string_id
+                            != parent_colors[1].output_color_shape_id()
+                    {
+                        continue;
+                    }
+                    let closed = witness
+                        .witness
+                        .closed_components(parent_colors[0], parent_colors[1])?;
+                    let reflection_factor = if query_target_matches(&closed, query) {
+                        ExactComplexRational::ONE
+                    } else if enable_cyclic_trace_reflection {
+                        let Some(factor) = reflected_query_closure_factor(
+                            query,
+                            &closed,
+                            colors,
+                            currents,
+                            concrete_parent_ids,
+                        )?
+                        else {
+                            continue;
+                        };
+                        factor
+                    } else {
+                        continue;
+                    };
+                    let key = PendingClosureKey {
+                        closure_template_id: closure.row.id,
+                        quantum_flow_template_id: quantum.row.map(|row| row.id),
+                        parent_current_ids: evaluator_parent_ids,
+                        color_witness_term_id: LCColorWitnessTermId::new(
+                            closure.row.color_contraction_template_id,
+                            witness.row.ordinal,
+                        ),
+                    };
+                    let factor = multiply_factors(&[
+                        closure.base_factor,
+                        quantum.output_factor()?,
+                        exchange_factor,
+                        witness.witness.exact_factor(),
+                        fermion_factor,
+                        reflection_factor,
+                    ])?;
+                    let coefficients = closure.component_coefficients.clone();
+                    match retained.entry(key.clone()) {
+                        std::collections::btree_map::Entry::Vacant(entry) => {
+                            entry.insert(PendingClosure {
+                                key,
+                                factor,
+                                component_coefficients: coefficients,
+                                pairing_lineages: try_clone_pairing_lineages(&pairing_lineages)?,
+                            });
+                        }
+                        std::collections::btree_map::Entry::Occupied(mut entry) => {
+                            if entry.get().component_coefficients != coefficients {
+                                return Err(integrity(
+                                    "equal closure identities have different component coefficients",
+                                ));
+                            }
+                            aggregate_factor(&mut entry.get_mut().factor, factor)?;
+                            extend_pairing_lineages(
+                                &mut entry.get_mut().pairing_lineages,
+                                &pairing_lineages,
+                            )?;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    retained.retain(|_, closure| !closure.factor.is_zero());
+    for closure in retained.values_mut() {
+        retain_canonical_pairing_lineage(&mut closure.pairing_lineages)?;
+    }
+    if retained.is_empty() {
+        // The process-global immutable grammar proved this closure domain
+        // complete before it entered the runtime cache.
+        return Ok(None);
+    }
+    Ok(Some(retained.into_values().collect()))
+}
+
+pub(super) fn validate_prepared_closure_domain(
+    templates: &ValidatedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+    closures: &BTreeMap<(u32, u32), Vec<PreparedClosure>>,
+) -> RusticolResult<()> {
+    let expected = &templates.input().closures;
+    let observed_count = closures.values().try_fold(0usize, |count, rows| {
+        count
+            .checked_add(rows.len())
+            .ok_or_else(|| invalid("prepared closure-domain row count exceeds usize"))
+    })?;
+    if observed_count != expected.len() {
+        return Err(integrity(format!(
+            "prepared closure domain has {observed_count} rows, expected {}",
+            expected.len()
+        )));
+    }
+
+    let mut observed = vec![false; expected.len()];
+    for (state_pair, rows) in closures {
+        for closure in rows {
+            let expected_row = expected
+                .get(closure.row.id as usize)
+                .filter(|row| row.id == closure.row.id)
+                .ok_or_else(|| integrity("prepared closure domain contains an unknown row"))?;
+            if closure.row != *expected_row {
+                return Err(integrity(
+                    "prepared closure row differs from its authenticated template",
+                ));
+            }
+            let expected_states: [u32; 2] = catalog
+                .u32_sequence(expected_row.input_state_sequence_id, "closure input states")?
+                .try_into()
+                .map_err(|_| integrity("authenticated closure input-state pair is not binary"))?;
+            if closure.input_states != expected_states
+                || *state_pair != canonical_state_pair(expected_states[0], expected_states[1])
+            {
+                return Err(integrity(
+                    "prepared closure parent-state pair differs from its authenticated template",
+                ));
+            }
+            let seen = observed
+                .get_mut(closure.row.id as usize)
+                .ok_or_else(|| integrity("prepared closure row ID exceeds its domain"))?;
+            if std::mem::replace(seen, true) {
+                return Err(integrity(
+                    "prepared closure domain repeats an authenticated row",
+                ));
+            }
+        }
+    }
+    if observed.iter().any(|seen| !seen) {
+        return Err(integrity(
+            "prepared closure domain omits an authenticated row",
+        ));
+    }
+    Ok(())
+}
+
+pub(super) fn live_current_ids(
+    currents: &[PendingCurrent],
+    closures: &[PendingClosure],
+) -> RusticolResult<BTreeSet<u32>> {
+    let mut live = BTreeSet::new();
+    let mut queue = VecDeque::new();
+    for closure in closures {
+        for parent in closure.key.parent_current_ids {
+            if live.insert(parent) {
+                queue.push_back(parent);
+            }
+        }
+    }
+    while let Some(current_id) = queue.pop_front() {
+        let current = currents
+            .get(current_id as usize)
+            .ok_or_else(|| integrity("liveness queue references an absent current"))?;
+        for (contribution, factor) in &current.contributions {
+            if factor.is_zero() {
+                continue;
+            }
+            for parent in contribution.parent_current_ids {
+                if live.insert(parent) {
+                    queue.push_back(parent);
+                }
+            }
+        }
+    }
+    Ok(live)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::recurrence::DynamicLCColorStateId;
+    use crate::recurrence::construct::CurrentReflectionProof;
+    use crate::recurrence::contact_orbit_owner::{
+        ContactOrbitStepProof, ContactOrbitTestBinding, contact_orbit_application_for_test,
+        contact_orbit_test_template, final_contact_orbit_step_for_test,
+        partial_contact_orbit_step_for_test, prepared_contact_orbit_transition_for_test,
+    };
+    use crate::recurrence::{ExactRational, LCColorEndpoint, LCColorPortBinding};
+
+    use super::*;
+
+    #[test]
+    fn fermion_ordering_filter_uses_authenticated_source_color_role() {
+        assert!(
+            on_the_fly_source_requires_exterior_sign(true, OnTheFlyExternalColorRoleV1::Singlet,)
+                .unwrap()
+        );
+        assert!(
+            !on_the_fly_source_requires_exterior_sign(
+                true,
+                OnTheFlyExternalColorRoleV1::Fundamental,
+            )
+            .unwrap()
+        );
+        assert!(
+            !on_the_fly_source_requires_exterior_sign(
+                true,
+                OnTheFlyExternalColorRoleV1::Antifundamental,
+            )
+            .unwrap()
+        );
+        assert!(
+            !on_the_fly_source_requires_exterior_sign(false, OnTheFlyExternalColorRoleV1::Adjoint,)
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn fermion_ordering_filter_rejects_unsupported_or_unauthenticated_roles() {
+        let adjoint =
+            on_the_fly_source_requires_exterior_sign(true, OnTheFlyExternalColorRoleV1::Adjoint)
+                .unwrap_err();
+        assert!(adjoint.to_string().contains("adjoint fermion"));
+        let bosonic_endpoint = on_the_fly_source_requires_exterior_sign(
+            false,
+            OnTheFlyExternalColorRoleV1::Fundamental,
+        )
+        .unwrap_err();
+        assert!(bosonic_endpoint.to_string().contains("bosonic source"));
+    }
+
+    fn contact_digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).expect("test digest must be nonzero")
+    }
+
+    fn reflection_test_states() -> (
+        DynamicLCColorStateInterner,
+        DynamicLCColorStateId,
+        DynamicLCColorStateId,
+    ) {
+        let canonical = DynamicLCColorState::new_port_wired(
+            1,
+            vec![
+                LCColorPortBinding::new(0, LCColorEndpoint::Back),
+                LCColorPortBinding::new(0, LCColorEndpoint::Front),
+            ],
+            vec![
+                LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![1, 3, 2]).unwrap(),
+            ],
+        )
+        .unwrap();
+        let reversed = canonical.reversed().unwrap();
+        let mut colors = DynamicLCColorStateInterner::default();
+        let canonical_id = colors.intern(canonical).unwrap();
+        let reversed_id = colors.intern(reversed).unwrap();
+        (colors, canonical_id, reversed_id)
+    }
+
+    fn proven_reflection(
+        colors: &DynamicLCColorStateInterner,
+        color_id: DynamicLCColorStateId,
+        phase: ExactComplexRational,
+        lineage: u8,
+    ) -> CurrentReflection {
+        let color = colors.get(color_id).unwrap();
+        CurrentReflection::Proven(
+            CurrentReflectionProof::new(
+                phase,
+                [contact_digest(lineage)],
+                dynamic_color_identity_digest(color).unwrap(),
+            )
+            .unwrap(),
+        )
+    }
+
+    fn reflection_current(
+        node_kind: RecurrenceNodeKind,
+        color_id: DynamicLCColorStateId,
+        support: &[u32],
+        reflection: CurrentReflection,
+    ) -> PendingCurrent {
+        PendingCurrent {
+            key: CurrentCoreKey::new(
+                contact_digest(230),
+                node_kind,
+                0,
+                color_id,
+                support.to_vec(),
+                CanonicalMomentumLinearForm::new(
+                    support
+                        .iter()
+                        .copied()
+                        .map(|source_slot| MomentumTerm {
+                            source_slot,
+                            coefficient: 1,
+                        })
+                        .collect(),
+                )
+                .unwrap(),
+                CurrentHelicityIdentity::topology_replay(
+                    0,
+                    support
+                        .iter()
+                        .copied()
+                        .map(|source_slot| SourceStateAssignment::new(source_slot, 0))
+                        .collect(),
+                )
+                .unwrap(),
+                vec![1],
+                0,
+                vec![0],
+                if node_kind == RecurrenceNodeKind::Source {
+                    CurrentSourceBinding::FixedTemplate(0)
+                } else {
+                    CurrentSourceBinding::None
+                },
+                None,
+            )
+            .unwrap(),
+            source_factor: (node_kind == RecurrenceNodeKind::Source)
+                .then_some(ExactComplexRational::ONE),
+            contributions: BTreeMap::new(),
+            pairing_lineages: vec![PendingPairingLineage {
+                completed_pairs: Vec::new(),
+                unmatched_endpoint: None,
+            }],
+            stage: u32::try_from(support.len().saturating_sub(1)).unwrap(),
+            reflection,
+            reflection_certificate: None,
+        }
+    }
+
+    #[test]
+    fn query_local_reflection_fold_is_insertion_invariant_and_fail_closed() {
+        let minus_one = ExactComplexRational::ONE.checked_neg().unwrap();
+        let run = |reverse_insertion: bool, prove_both: bool| {
+            let (mut colors, canonical_id, reversed_id) = reflection_test_states();
+            let mut currents = vec![
+                reflection_current(
+                    RecurrenceNodeKind::Current,
+                    canonical_id,
+                    &[1, 2, 3],
+                    proven_reflection(&colors, canonical_id, minus_one, 201),
+                ),
+                reflection_current(
+                    RecurrenceNodeKind::Current,
+                    reversed_id,
+                    &[1, 2, 3],
+                    if prove_both {
+                        proven_reflection(&colors, reversed_id, minus_one, 202)
+                    } else {
+                        let mut late_unproved =
+                            proven_reflection(&colors, reversed_id, minus_one, 202);
+                        late_unproved.include(None).unwrap();
+                        late_unproved
+                    },
+                ),
+            ];
+            if reverse_insertion {
+                currents.reverse();
+            }
+            let mut current_ids = currents
+                .iter()
+                .enumerate()
+                .map(|(id, current)| (current.key.clone(), id as u32))
+                .collect::<BTreeMap<_, _>>();
+            reconcile_on_the_fly_stage_reflections(
+                0,
+                &mut colors,
+                &mut currents,
+                &mut current_ids,
+                4,
+            )
+            .unwrap();
+            (colors, currents, current_ids)
+        };
+
+        let (_, folded, folded_ids) = run(false, true);
+        let (_, folded_reordered, folded_reordered_ids) = run(true, true);
+        assert_eq!(folded.len(), 1);
+        assert_eq!(folded_ids.len(), 1);
+        assert_eq!(folded[0].key, folded_reordered[0].key);
+        assert_eq!(folded_ids, folded_reordered_ids);
+        for current in [&folded[0], &folded_reordered[0]] {
+            let certificate = current.reflection_certificate.as_ref().unwrap();
+            assert!(certificate.is_reciprocal_two_cycle());
+            assert_eq!(certificate.source_permutation(), [0, 2, 1, 3]);
+            assert_eq!(certificate.canonical_phase(), minus_one);
+        }
+
+        let (_, residual, residual_ids) = run(false, false);
+        assert_eq!(residual.len(), 2);
+        assert_eq!(residual_ids.len(), 2);
+        assert!(
+            residual
+                .iter()
+                .all(|current| current.reflection_certificate.is_none())
+        );
+    }
+
+    #[test]
+    fn reflected_query_closure_uses_only_the_certified_exact_phase() {
+        let canonical_phase =
+            ExactComplexRational::new(ExactRational::new(2, 1).unwrap(), ExactRational::ZERO);
+        let reflected_phase =
+            ExactComplexRational::new(ExactRational::new(1, 2).unwrap(), ExactRational::ZERO);
+        let (mut colors, canonical_id, reversed_id) = reflection_test_states();
+        let mut currents = vec![
+            reflection_current(
+                RecurrenceNodeKind::Source,
+                canonical_id,
+                &[0],
+                CurrentReflection::Unavailable,
+            ),
+            reflection_current(
+                RecurrenceNodeKind::Current,
+                canonical_id,
+                &[1, 2, 3],
+                proven_reflection(&colors, canonical_id, canonical_phase, 203),
+            ),
+            reflection_current(
+                RecurrenceNodeKind::Current,
+                reversed_id,
+                &[1, 2, 3],
+                proven_reflection(&colors, reversed_id, reflected_phase, 204),
+            ),
+        ];
+        let mut current_ids = currents
+            .iter()
+            .enumerate()
+            .map(|(id, current)| (current.key.clone(), id as u32))
+            .collect::<BTreeMap<_, _>>();
+        reconcile_on_the_fly_stage_reflections(1, &mut colors, &mut currents, &mut current_ids, 4)
+            .unwrap();
+        assert_eq!(currents.len(), 2);
+
+        let seed = adjoint_reflection_seed();
+        let query = DecodedLcQueryV1::new(
+            &seed,
+            vec![0, 1, 2, 3],
+            &[0, 0, 0, 0],
+            OnTheFlyLcSelectorV1::single_trace(vec![0, 2, 3, 1]),
+        )
+        .unwrap();
+        let query = OnTheFlyClosureAnchorPolicyV1::certified_cyclic_minimum(0)
+            .canonicalize_query(&seed, query)
+            .unwrap();
+        let closed =
+            vec![LCColorComponent::new(LCColorComponentKind::Trace, vec![0, 1, 3, 2]).unwrap()];
+        assert!(!query_target_matches(&closed, &query));
+        assert_eq!(
+            reflected_query_closure_factor(&query, &closed, &colors, &currents, [0, 1]).unwrap(),
+            Some(canonical_phase),
+        );
+
+        let certificate = currents[1].reflection_certificate.take();
+        assert_eq!(
+            reflected_query_closure_factor(&query, &closed, &colors, &currents, [0, 1]).unwrap(),
+            None,
+        );
+        currents[1].reflection_certificate = certificate;
+        currents[1].reflection = proven_reflection(&colors, canonical_id, canonical_phase, 205);
+        assert!(
+            reflected_query_closure_factor(&query, &closed, &colors, &currents, [0, 1]).is_err()
+        );
+    }
+
+    fn contact_current(
+        node_kind: RecurrenceNodeKind,
+        state: u32,
+        color: u32,
+        support: &[u32],
+    ) -> PendingCurrent {
+        contact_current_with_source_template(
+            node_kind,
+            state,
+            color,
+            support,
+            support.first().copied().unwrap_or_default(),
+        )
+    }
+
+    fn contact_current_with_source_template(
+        node_kind: RecurrenceNodeKind,
+        state: u32,
+        color: u32,
+        support: &[u32],
+        source_template_id: u32,
+    ) -> PendingCurrent {
+        let key = CurrentCoreKey::new(
+            contact_digest(230),
+            node_kind,
+            state,
+            DynamicLCColorStateId::from_interner(color),
+            support.to_vec(),
+            CanonicalMomentumLinearForm::new(
+                support
+                    .iter()
+                    .copied()
+                    .map(|source_slot| MomentumTerm {
+                        source_slot,
+                        coefficient: 1,
+                    })
+                    .collect(),
+            )
+            .unwrap(),
+            CurrentHelicityIdentity::topology_replay(
+                0,
+                support
+                    .iter()
+                    .copied()
+                    .map(|source_slot| SourceStateAssignment::new(source_slot, 0))
+                    .collect(),
+            )
+            .unwrap(),
+            vec![state as i32],
+            0,
+            vec![0],
+            if node_kind == RecurrenceNodeKind::Source {
+                CurrentSourceBinding::FixedTemplate(source_template_id)
+            } else {
+                CurrentSourceBinding::None
+            },
+            None,
+        )
+        .unwrap();
+        PendingCurrent {
+            key,
+            source_factor: (node_kind == RecurrenceNodeKind::Source)
+                .then_some(ExactComplexRational::ONE),
+            contributions: BTreeMap::new(),
+            pairing_lineages: vec![PendingPairingLineage {
+                completed_pairs: Vec::new(),
+                unmatched_endpoint: None,
+            }],
+            stage: u32::try_from(support.len().saturating_sub(1)).unwrap(),
+            reflection: CurrentReflection::Unavailable,
+            reflection_certificate: None,
+        }
+    }
+
+    fn legacy_support_size_pairs(support_sizes: &[usize], target_size: usize) -> Vec<[usize; 2]> {
+        let mut pairs = Vec::new();
+        for left_id in 0..support_sizes.len() {
+            if support_sizes[left_id] >= target_size {
+                continue;
+            }
+            for right_id in (left_id + 1)..support_sizes.len() {
+                if support_sizes[right_id] < target_size
+                    && support_sizes[left_id] + support_sizes[right_id] == target_size
+                {
+                    pairs.push([left_id, right_id]);
+                }
+            }
+        }
+        pairs
+    }
+
+    fn legacy_anchor_filtered_pairs(
+        supports: &[Vec<u32>],
+        target_size: usize,
+        closure_anchor_slot: u32,
+    ) -> Vec<[usize; 2]> {
+        legacy_support_size_pairs(
+            &supports.iter().map(Vec::len).collect::<Vec<_>>(),
+            target_size,
+        )
+        .into_iter()
+        .filter(|[left, right]| {
+            !supports[*left].contains(&closure_anchor_slot)
+                && !supports[*right].contains(&closure_anchor_slot)
+        })
+        .collect()
+    }
+
+    #[test]
+    fn query_support_size_index_preserves_legacy_pair_order() {
+        let mut random_state = 0x6a09_e667_f3bc_c909_u64;
+        for source_count in 3..=12 {
+            for case_index in 0..64 {
+                let current_count = source_count + case_index % (source_count * 3);
+                let mut support_sizes = Vec::with_capacity(current_count);
+                for _ in 0..current_count {
+                    random_state = random_state
+                        .wrapping_mul(6_364_136_223_846_793_005)
+                        .wrapping_add(1_442_695_040_888_963_407);
+                    support_sizes.push(
+                        1 + usize::try_from(random_state % (source_count as u64 - 1)).unwrap(),
+                    );
+                }
+
+                let mut index = QuerySupportSizeIndex {
+                    support_size_by_current: Vec::new(),
+                    composite_parent_eligible_by_current: Vec::new(),
+                    current_ids_by_size: (0..source_count).map(|_| Vec::new()).collect(),
+                };
+                for (current_id, support_size) in support_sizes.iter().copied().enumerate() {
+                    index.append(current_id, support_size, true).unwrap();
+                }
+
+                for target_size in 2..source_count {
+                    let mut indexed_pairs = Vec::new();
+                    index
+                        .for_each_parent_pair(target_size, support_sizes.len(), |pair| {
+                            indexed_pairs.push(pair);
+                            Ok(())
+                        })
+                        .unwrap();
+                    assert_eq!(
+                        indexed_pairs,
+                        legacy_support_size_pairs(&support_sizes, target_size),
+                        "source_count={source_count}, case_index={case_index}, target_size={target_size}"
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn all_flow_queries_use_distinct_anchor_filters_without_reordering_pairs() {
+        // An all-flow family constructs each decoded query independently.
+        // Rebuild the same support domain for every possible query anchor to
+        // prove that no anchor eligibility leaks from one query to the next.
+        for source_count in 2_u32..=8 {
+            let mut supports = (1_u32..(1_u32 << source_count))
+                .filter(|mask| mask.count_ones() < source_count)
+                .map(|mask| {
+                    (0..source_count)
+                        .filter(|slot| mask & (1 << slot) != 0)
+                        .collect::<Vec<_>>()
+                })
+                .collect::<Vec<_>>();
+            supports.sort_by_key(|support| (support.len(), support.clone()));
+
+            for closure_anchor_slot in 0..source_count {
+                let mut index = QuerySupportSizeIndex {
+                    support_size_by_current: Vec::new(),
+                    composite_parent_eligible_by_current: Vec::new(),
+                    current_ids_by_size: (0..source_count as usize).map(|_| Vec::new()).collect(),
+                };
+                for (current_id, support) in supports.iter().enumerate() {
+                    index
+                        .append(
+                            current_id,
+                            support.len(),
+                            !support.contains(&closure_anchor_slot),
+                        )
+                        .unwrap();
+                }
+
+                for target_size in 2..source_count as usize {
+                    let mut filtered_pairs = Vec::new();
+                    index
+                        .for_each_parent_pair(target_size, supports.len(), |pair| {
+                            filtered_pairs.push(pair);
+                            Ok(())
+                        })
+                        .unwrap();
+                    assert_eq!(
+                        filtered_pairs,
+                        legacy_anchor_filtered_pairs(&supports, target_size, closure_anchor_slot,),
+                        "source_count={source_count}, closure_anchor_slot={closure_anchor_slot}, target_size={target_size}",
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn two_source_anchor_is_retained_but_cannot_enter_composite_schedule() {
+        let currents = vec![
+            contact_current(RecurrenceNodeKind::Source, 0, 0, &[0]),
+            contact_current(RecurrenceNodeKind::Source, 0, 0, &[1]),
+        ];
+        let index = QuerySupportSizeIndex::new(&currents, 2, Some(1)).unwrap();
+        assert_eq!(index.support_size_by_current, [1, 1]);
+        assert_eq!(index.composite_parent_eligible_by_current, [true, false]);
+        let mut pairs = Vec::new();
+        index
+            .for_each_parent_pair(2, currents.len(), |pair| {
+                pairs.push(pair);
+                Ok(())
+            })
+            .unwrap();
+        assert!(pairs.is_empty());
+
+        let error = QuerySupportSizeIndex::new(&currents, 2, Some(2)).unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("outside the forward source domain")
+        );
+
+        let missing_anchor = vec![contact_current(RecurrenceNodeKind::Source, 0, 0, &[0])];
+        let error = QuerySupportSizeIndex::new(&missing_anchor, 2, Some(1)).unwrap_err();
+        assert!(error.to_string().contains("exactly one singleton"));
+
+        let malformed_anchor = vec![
+            contact_current(RecurrenceNodeKind::Source, 0, 0, &[0]),
+            contact_current(RecurrenceNodeKind::Current, 0, 0, &[0, 1]),
+        ];
+        let error = QuerySupportSizeIndex::new(&malformed_anchor, 2, Some(1)).unwrap_err();
+        assert!(error.to_string().contains("non-singleton closure-anchor"));
+    }
+
+    #[test]
+    fn query_support_size_index_enforces_stage_prefix() {
+        let mut index = QuerySupportSizeIndex {
+            support_size_by_current: Vec::new(),
+            composite_parent_eligible_by_current: Vec::new(),
+            current_ids_by_size: (0..4).map(|_| Vec::new()).collect(),
+        };
+        index.append(0, 1, true).unwrap();
+        index.append(1, 1, true).unwrap();
+        index.append(2, 1, true).unwrap();
+
+        let error = index
+            .for_each_parent_pair(2, 2, |_| Ok(()))
+            .expect_err("a size bucket extending past the stage prefix must be rejected");
+        assert!(
+            error
+                .to_string()
+                .contains("differs from its current prefix")
+        );
+    }
+
+    fn contact_transition(
+        step: ContactOrbitStepProof,
+        input_state_template_ids: [u32; 2],
+        transition_digest: u8,
+    ) -> PreparedContactOrbitTransition {
+        contact_transition_with_witness(
+            step,
+            input_state_template_ids,
+            transition_digest,
+            LCColorWitnessTermId::new(4, 0),
+        )
+    }
+
+    fn contact_transition_with_witness(
+        step: ContactOrbitStepProof,
+        input_state_template_ids: [u32; 2],
+        transition_digest: u8,
+        color_witness_term_id: LCColorWitnessTermId,
+    ) -> PreparedContactOrbitTransition {
+        let mut application = contact_orbit_application_for_test();
+        application.color_witness_term_id = color_witness_term_id;
+        prepared_contact_orbit_transition_for_test(
+            step,
+            input_state_template_ids,
+            contact_digest(transition_digest),
+            application,
+        )
+    }
+
+    fn add_contact_contribution(
+        currents: &mut [PendingCurrent],
+        destination: u32,
+        transition: u32,
+        parents: [u32; 2],
+    ) {
+        let parent_keys = parents.map(|id| &currents[id as usize].key);
+        let destination_key = &currents[destination as usize].key;
+        let key = ContributionKey::new(
+            transition,
+            parents.to_vec(),
+            parent_keys
+                .iter()
+                .map(|key| key.current_state_template_id())
+                .collect(),
+            parent_keys
+                .iter()
+                .map(|key| key.momentum().clone())
+                .collect(),
+            destination_key.current_state_template_id(),
+            0,
+            LCColorWitnessTermId::new(4, 0),
+            contact_digest(2),
+            8,
+        )
+        .unwrap();
+        assert!(
+            currents[destination as usize]
+                .contributions
+                .insert(
+                    PendingContributionKey {
+                        parent_current_ids: parents,
+                        key,
+                    },
+                    ExactComplexRational::ONE,
+                )
+                .is_none()
+        );
+    }
+
+    fn contact_transition_ids(current: &PendingCurrent) -> Vec<u32> {
+        current
+            .contributions
+            .keys()
+            .map(|pending| pending.key.transition_template_id())
+            .collect()
+    }
+
+    fn pending_contact_counts(currents: &[PendingCurrent]) -> (usize, usize) {
+        (
+            currents.len(),
+            currents
+                .iter()
+                .map(|current| current.contributions.len())
+                .sum(),
+        )
+    }
+
+    fn scalar_contact_seed(source_count: u32) -> OnTheFlyProcessSeedV1 {
+        let state = OnTheFlySourceStateV1::new(
+            0,
+            0,
+            0,
+            0,
+            0,
+            contact_digest(231),
+            contact_digest(232),
+            1,
+            ExactComplexRational::ONE,
+            0,
+            0,
+            vec![1],
+            0,
+            contact_digest(233),
+            OnTheFlySourceWavefunctionFamilyV1::Scalar,
+            OnTheFlySourceOrientationV1::SelfConjugate,
+            None,
+        )
+        .unwrap();
+        let anchors = (0_u32..source_count)
+            .map(|source_slot| {
+                OnTheFlySourceAnchorV1::new(
+                    source_slot,
+                    source_slot,
+                    false,
+                    OnTheFlyExternalColorRoleV1::Singlet,
+                    false,
+                    None,
+                    vec![state.clone()],
+                )
+                .unwrap()
+            })
+            .collect();
+        OnTheFlyProcessSeedV1::new(
+            contact_digest(234),
+            contact_digest(235),
+            contact_digest(230),
+            contact_digest(236),
+            contact_digest(237),
+            contact_digest(238),
+            "raw-amplitude-contact-test",
+            ExactComplexRational::ONE,
+            anchors,
+            (0_u32..source_count).collect(),
+            OnTheFlyCouplingOrderPolicyV1::Explicit,
+            vec![1],
+            vec![Some(0)],
+            Vec::new(),
+        )
+        .unwrap()
+    }
+
+    fn adjoint_reflection_seed() -> OnTheFlyProcessSeedV1 {
+        let state = OnTheFlySourceStateV1::new(
+            0,
+            0,
+            0,
+            0,
+            0,
+            contact_digest(241),
+            contact_digest(242),
+            1,
+            ExactComplexRational::ONE,
+            0,
+            0,
+            vec![1],
+            0,
+            contact_digest(243),
+            OnTheFlySourceWavefunctionFamilyV1::Vector,
+            OnTheFlySourceOrientationV1::SelfConjugate,
+            None,
+        )
+        .unwrap();
+        let anchors = (0_u32..4)
+            .map(|source_slot| {
+                OnTheFlySourceAnchorV1::new(
+                    source_slot,
+                    source_slot,
+                    source_slot < 2,
+                    OnTheFlyExternalColorRoleV1::Adjoint,
+                    false,
+                    None,
+                    vec![state.clone()],
+                )
+                .unwrap()
+            })
+            .collect();
+        OnTheFlyProcessSeedV1::new(
+            contact_digest(244),
+            contact_digest(245),
+            contact_digest(230),
+            contact_digest(246),
+            contact_digest(247),
+            contact_digest(248),
+            "raw-amplitude-reflection-test",
+            ExactComplexRational::ONE,
+            anchors,
+            vec![0, 1, 2, 3],
+            OnTheFlyCouplingOrderPolicyV1::Explicit,
+            vec![1],
+            vec![Some(0)],
+            Vec::new(),
+        )
+        .unwrap()
+    }
+
+    fn production_contact_barrier_currents(
+        reverse_transition_order: bool,
+        include_ordinary_scalar_transition: bool,
+        closure_anchor_slot: Option<u32>,
+    ) -> Vec<PendingCurrent> {
+        let mut template_input = contact_orbit_test_template(ContactOrbitTestBinding::One);
+        let mut intermediate_state = template_input.current_states[0];
+        intermediate_state.id = 1;
+        let mut append_canonical_string = |value: &[u8]| {
+            let previous_string = template_input.string_ranges.last().unwrap();
+            let previous_range = previous_string
+                .as_usize_range(template_input.string_bytes.len(), "test string")
+                .unwrap();
+            assert!(
+                &template_input.string_bytes[previous_range] < value,
+                "the intermediate-state fixture must extend the canonical string catalog"
+            );
+            let id = u32::try_from(template_input.string_ranges.len()).unwrap();
+            template_input
+                .string_ranges
+                .push(crate::recurrence::CheckedTableRange::new(
+                    u64::try_from(template_input.string_bytes.len()).unwrap(),
+                    u64::try_from(value.len()).unwrap(),
+                ));
+            template_input.string_bytes.extend_from_slice(value);
+            id
+        };
+        let intermediate_propagator_template_id =
+            append_canonical_string(b"zz-on-the-fly-intermediate-propagator");
+        let intermediate_state_template_id =
+            append_canonical_string(b"zz-on-the-fly-intermediate-state");
+        intermediate_state.template_string_id = intermediate_state_template_id;
+        let intermediate_digest_id = u32::try_from(template_input.digest_catalog.len()).unwrap();
+        template_input
+            .digest_catalog
+            .push(crate::recurrence::template::DigestCatalogRow {
+                id: intermediate_digest_id,
+                value: [240; 32],
+            });
+        intermediate_state.semantic_digest_id = intermediate_digest_id;
+        template_input.current_states.push(intermediate_state);
+        let intermediate_propagator_digest_id =
+            u32::try_from(template_input.digest_catalog.len()).unwrap();
+        template_input
+            .digest_catalog
+            .push(crate::recurrence::template::DigestCatalogRow {
+                id: intermediate_propagator_digest_id,
+                value: [241; 32],
+            });
+        let mut intermediate_propagator = template_input.propagators[0];
+        intermediate_propagator.id = 1;
+        intermediate_propagator.template_string_id = intermediate_propagator_template_id;
+        intermediate_propagator.state_template_id = 1;
+        intermediate_propagator.applies_propagator = 0;
+        intermediate_propagator.evaluator_binding_id = MISSING_U32;
+        intermediate_propagator.numerator_expression_digest_id = MISSING_U32;
+        intermediate_propagator.denominator_expression_digest_id = MISSING_U32;
+        intermediate_propagator.semantic_digest_id = intermediate_propagator_digest_id;
+        template_input.propagators.push(intermediate_propagator);
+        template_input.catalog_header[0].current_state_count = 2;
+        template_input.catalog_header[0].propagator_count = 2;
+        let templates = template_input.validate().unwrap();
+        let catalog = TemplateCatalog::new(templates.input()).unwrap();
+        let prepared = prepared_transitions(&templates, &catalog).unwrap();
+        let base = prepared.values().next().unwrap()[0].clone();
+        let partial_steps = [
+            partial_contact_orbit_step_for_test(0, 1, 2, 20, [0, 0, 0, 0]),
+            partial_contact_orbit_step_for_test(1, 0, 2, 30, [0, 0, 0, 0]),
+            partial_contact_orbit_step_for_test(0, 2, 1, 21, [0, 0, 0, 0]),
+            partial_contact_orbit_step_for_test(2, 0, 1, 31, [0, 0, 0, 0]),
+            partial_contact_orbit_step_for_test(0, 3, 1, 22, [0, 0, 0, 0]),
+            partial_contact_orbit_step_for_test(3, 0, 1, 32, [0, 0, 0, 0]),
+        ];
+        let final_steps = [
+            final_contact_orbit_step_for_test(&[0], &[1, 2], 3, 60, [0, 0, 0, 0]),
+            final_contact_orbit_step_for_test(&[1, 2], &[0], 3, 70, [0, 0, 0, 0]),
+            final_contact_orbit_step_for_test(&[0], &[1, 3], 2, 61, [0, 0, 0, 0]),
+            final_contact_orbit_step_for_test(&[1, 3], &[0], 2, 71, [0, 0, 0, 0]),
+            final_contact_orbit_step_for_test(&[0], &[2, 3], 1, 62, [0, 0, 0, 0]),
+            final_contact_orbit_step_for_test(&[2, 3], &[0], 1, 72, [0, 0, 0, 0]),
+        ];
+        let transition_order = if reverse_transition_order {
+            (0_usize..partial_steps.len()).rev().collect::<Vec<_>>()
+        } else {
+            (0_usize..partial_steps.len()).collect::<Vec<_>>()
+        };
+        let build_row = |index: usize,
+                         id_offset: u32,
+                         step: ContactOrbitStepProof,
+                         input_states: [u32; 2],
+                         result_state: u32| {
+            let id = id_offset + u32::try_from(index).unwrap();
+            let digest_byte = 40 + u8::try_from(id).unwrap();
+            let mut row = base.clone();
+            row.row.id = id;
+            row.input_states = input_states;
+            row.row.result_state_template_id = result_state;
+            row.quantum.result_state_template_id = result_state;
+            row.local_orders = vec![0].into_boxed_slice();
+            row.transition_semantic_digest = contact_digest(digest_byte);
+            row.contact_orbit = Some(contact_transition_with_witness(
+                step,
+                input_states,
+                digest_byte,
+                LCColorWitnessTermId::new(
+                    row.row.color_contraction_template_id,
+                    row.witnesses[0].row.ordinal,
+                ),
+            ));
+            row
+        };
+        let mut partial_rows = transition_order
+            .iter()
+            .copied()
+            .map(|index| build_row(index, 0, partial_steps[index].clone(), [0, 0], 1))
+            .collect::<Vec<_>>();
+        let final_rows = transition_order
+            .into_iter()
+            .map(|index| {
+                let input_states = if index % 2 == 0 { [0, 1] } else { [1, 0] };
+                build_row(index, 6, final_steps[index].clone(), input_states, 1)
+            })
+            .collect::<Vec<_>>();
+        if include_ordinary_scalar_transition {
+            let mut ordinary = base.clone();
+            ordinary.row.id = 12;
+            ordinary.input_states = [0, 0];
+            ordinary.row.result_state_template_id = 0;
+            ordinary.quantum.result_state_template_id = 0;
+            ordinary.local_orders = vec![0].into_boxed_slice();
+            ordinary.transition_semantic_digest = contact_digest(120);
+            ordinary.contact_orbit = None;
+            partial_rows.push(ordinary);
+        }
+        let transitions = BTreeMap::from([((0, 0), partial_rows), ((0, 1), final_rows)]);
+        let propagators = propagator_by_state(&templates).unwrap();
+        let seed = scalar_contact_seed(4);
+        let mut colors = DynamicLCColorStateInterner::default();
+        let color_id = colors
+            .intern(
+                DynamicLCColorState::new(
+                    base.witnesses[0].row.left_shape_string_id,
+                    None,
+                    Vec::new(),
+                )
+                .unwrap(),
+            )
+            .unwrap();
+        assert_eq!(color_id, DynamicLCColorStateId::from_interner(0));
+        let mut currents = (0_u32..4)
+            .map(|source_slot| {
+                contact_current_with_source_template(
+                    RecurrenceNodeKind::Source,
+                    0,
+                    0,
+                    &[source_slot],
+                    0,
+                )
+            })
+            .collect::<Vec<_>>();
+        let mut current_ids = currents
+            .iter()
+            .enumerate()
+            .map(|(id, current)| (current.key.clone(), u32::try_from(id).unwrap()))
+            .collect::<BTreeMap<_, _>>();
+        let contact_orbits = PreparedContactOrbitIndex::new(&transitions).unwrap();
+        let fermion_ordering = on_the_fly_fermion_ordering_context(&seed).unwrap();
+
+        build_forward_currents_with_anchor_exclusion(
+            &templates,
+            &transitions,
+            &TransitionReflectionIndex::default(),
+            &contact_orbits,
+            false,
+            &seed,
+            &fermion_ordering,
+            closure_anchor_slot,
+            seed.explicit_coupling_limits(),
+            &propagators,
+            &mut colors,
+            &mut currents,
+            &mut current_ids,
+        )
+        .unwrap();
+
+        currents
+    }
+
+    #[allow(clippy::type_complexity)] // Compact assertion fixture returned only inside tests.
+    fn production_contact_barrier_case(
+        reverse_transition_order: bool,
+        include_ordinary_scalar_transition: bool,
+    ) -> (Vec<(Vec<u32>, u32, Vec<u32>)>, (usize, usize), bool) {
+        let currents = production_contact_barrier_currents(
+            reverse_transition_order,
+            include_ordinary_scalar_transition,
+            None,
+        );
+
+        assert!(
+            currents[4..].iter().all(|current| {
+                let expected = if include_ordinary_scalar_transition
+                    && current.stage == 2
+                    && current.key.current_state_template_id() == 1
+                {
+                    6
+                } else if current.stage == 1 {
+                    1
+                } else {
+                    3
+                };
+                current.contributions.len() == expected
+            }),
+            "certified pair/final destinations retain one owner per physical assignment",
+        );
+        assert!(
+            currents[4..].iter().all(|current| {
+                current.contributions.keys().all(|contribution| {
+                    contribution.parent_current_ids.iter().all(|parent_id| {
+                        let parent = &currents[*parent_id as usize];
+                        parent.source_factor.is_some() || !parent.contributions.is_empty()
+                    })
+                })
+            }),
+            "a selected contact transition must not reference an empty parent",
+        );
+
+        let staged = currents[4..]
+            .iter()
+            .map(|current| {
+                (
+                    current.key.support_source_slots().to_vec(),
+                    current.stage,
+                    contact_transition_ids(current),
+                )
+            })
+            .collect();
+        let retained_partial_is_consumed = currents[10..].iter().all(|current| {
+            current.contributions.keys().all(|contribution| {
+                let mut partial_parents = contribution
+                    .parent_current_ids
+                    .iter()
+                    .copied()
+                    .filter(|parent| (4..10).contains(&usize::try_from(*parent).unwrap()));
+                let Some(partial_parent) = partial_parents.next() else {
+                    return false;
+                };
+                partial_parents.next().is_none()
+                    && currents[partial_parent as usize]
+                        .key
+                        .current_state_template_id()
+                        == 1
+                    && contribution
+                        .parent_current_ids
+                        .iter()
+                        .copied()
+                        .any(|parent| {
+                            parent != partial_parent
+                                && currents[parent as usize].key.current_state_template_id() == 0
+                        })
+            })
+        });
+        (
+            staged,
+            pending_contact_counts(&currents),
+            retained_partial_is_consumed,
+        )
+    }
+
+    type OrderedExactForwardSignature = Vec<(
+        Vec<u32>,
+        RecurrenceNodeKind,
+        u32,
+        Vec<(u32, [Vec<u32>; 2], ExactComplexRational)>,
+    )>;
+
+    fn ordered_exact_forward_signature(
+        currents: &[PendingCurrent],
+    ) -> OrderedExactForwardSignature {
+        currents
+            .iter()
+            .map(|current| {
+                (
+                    current.key.support_source_slots().to_vec(),
+                    current.key.node_kind(),
+                    current.stage,
+                    current
+                        .contributions
+                        .iter()
+                        .map(|(pending, factor)| {
+                            (
+                                pending.key.transition_template_id(),
+                                pending.parent_current_ids.map(|parent_id| {
+                                    currents[parent_id as usize]
+                                        .key
+                                        .support_source_slots()
+                                        .to_vec()
+                                }),
+                                *factor,
+                            )
+                        })
+                        .collect(),
+                )
+            })
+            .collect()
+    }
+
+    fn commit_contact_plan(
+        currents: &mut [PendingCurrent],
+        contacts: &BTreeMap<u32, PreparedContactOrbitTransition>,
+        stage_current_start: usize,
+    ) -> RusticolResult<()> {
+        if let Some(plan) = plan_on_the_fly_contact_orbit_owners_with_resolver(
+            stage_current_start,
+            currents,
+            |transition_id| contacts.get(&transition_id),
+        )? {
+            plan.commit(currents);
+        }
+        Ok(())
+    }
+
+    fn contact_0000_case(final_stage: bool, reverse_insertion: bool) -> (Vec<u32>, (usize, usize)) {
+        let (mut currents, steps, parent_ids, destination_id) = if final_stage {
+            (
+                vec![
+                    contact_current(RecurrenceNodeKind::Source, 10, 0, &[10]),
+                    contact_current(RecurrenceNodeKind::Source, 10, 1, &[11]),
+                    contact_current(RecurrenceNodeKind::Source, 10, 2, &[12]),
+                    contact_current(RecurrenceNodeKind::Current, 11, 3, &[11, 12]),
+                    contact_current(RecurrenceNodeKind::Current, 11, 4, &[10, 12]),
+                    contact_current(RecurrenceNodeKind::Current, 11, 5, &[10, 11]),
+                    contact_current(RecurrenceNodeKind::Current, 20, 6, &[10, 11, 12]),
+                ],
+                vec![
+                    final_contact_orbit_step_for_test(&[1, 2], &[3], 0, 60, [0, 0, 0, 0]),
+                    final_contact_orbit_step_for_test(&[3], &[1, 2], 0, 70, [0, 0, 0, 0]),
+                    final_contact_orbit_step_for_test(&[1, 2], &[3], 0, 61, [0, 0, 0, 0]),
+                    final_contact_orbit_step_for_test(&[3], &[1, 2], 0, 71, [0, 0, 0, 0]),
+                    final_contact_orbit_step_for_test(&[1, 2], &[3], 0, 62, [0, 0, 0, 0]),
+                    final_contact_orbit_step_for_test(&[3], &[1, 2], 0, 72, [0, 0, 0, 0]),
+                ],
+                vec![[3, 0], [0, 3], [4, 1], [1, 4], [5, 2], [2, 5]],
+                6_u32,
+            )
+        } else {
+            (
+                vec![
+                    contact_current(RecurrenceNodeKind::Source, 10, 0, &[10]),
+                    contact_current(RecurrenceNodeKind::Source, 10, 1, &[11]),
+                    contact_current(RecurrenceNodeKind::Current, 20, 2, &[10, 11]),
+                ],
+                vec![
+                    partial_contact_orbit_step_for_test(0, 1, 2, 20, [0, 0, 0, 0]),
+                    partial_contact_orbit_step_for_test(1, 0, 2, 30, [0, 0, 0, 0]),
+                    partial_contact_orbit_step_for_test(0, 2, 1, 21, [0, 0, 0, 0]),
+                    partial_contact_orbit_step_for_test(2, 0, 1, 31, [0, 0, 0, 0]),
+                    partial_contact_orbit_step_for_test(0, 3, 1, 22, [0, 0, 0, 0]),
+                    partial_contact_orbit_step_for_test(3, 0, 1, 32, [0, 0, 0, 0]),
+                ],
+                vec![[0, 1], [1, 0], [0, 1], [1, 0], [0, 1], [1, 0]],
+                2_u32,
+            )
+        };
+        let contacts = steps
+            .into_iter()
+            .enumerate()
+            .map(|(transition, step)| {
+                let transition = u32::try_from(transition).unwrap();
+                let parents = parent_ids[transition as usize];
+                (
+                    transition,
+                    contact_transition(
+                        step,
+                        parents.map(|parent| {
+                            currents[parent as usize].key.current_state_template_id()
+                        }),
+                        40 + u8::try_from(transition).unwrap(),
+                    ),
+                )
+            })
+            .collect::<BTreeMap<_, _>>();
+        let order = if reverse_insertion {
+            (0_u32..6).rev().collect::<Vec<_>>()
+        } else {
+            (0_u32..6).collect::<Vec<_>>()
+        };
+        for transition in order {
+            add_contact_contribution(
+                &mut currents,
+                destination_id,
+                transition,
+                parent_ids[transition as usize],
+            );
+        }
+        commit_contact_plan(&mut currents, &contacts, destination_id as usize).unwrap();
+        (
+            contact_transition_ids(&currents[destination_id as usize]),
+            pending_contact_counts(&currents),
+        )
+    }
+
+    fn closure(lineages: Vec<PendingPairingLineage>) -> PendingClosure {
+        PendingClosure {
+            key: PendingClosureKey {
+                closure_template_id: 0,
+                quantum_flow_template_id: None,
+                parent_current_ids: [0, 1],
+                color_witness_term_id: LCColorWitnessTermId::new(0, 0),
+            },
+            factor: ExactComplexRational::ONE,
+            component_coefficients: vec![ExactComplexRational::ONE].into_boxed_slice(),
+            pairing_lineages: lineages,
+        }
+    }
+
+    fn lineage(pair: [u32; 2]) -> PendingPairingLineage {
+        PendingPairingLineage {
+            completed_pairs: vec![pair],
+            unmatched_endpoint: None,
+        }
+    }
+
+    #[test]
+    fn contact_0000_fan_in_keeps_exact_assignment_multiplicity_deterministically() {
+        let partial_forward = contact_0000_case(false, false);
+        let partial_reverse = contact_0000_case(false, true);
+        assert_eq!(partial_forward, (vec![0], (3, 1)));
+        assert_eq!(partial_reverse, partial_forward);
+
+        let final_forward = contact_0000_case(true, false);
+        let final_reverse = contact_0000_case(true, true);
+        assert_eq!(final_reverse, final_forward);
+        assert_eq!(final_forward.0.len(), 3);
+        assert_eq!(final_forward.1, (7, 3));
+    }
+
+    #[test]
+    fn forward_sweep_barrier_prunes_complete_contact_fan_in_before_next_stage() {
+        let forward = production_contact_barrier_case(false, false);
+        let reverse = production_contact_barrier_case(true, false);
+        assert_eq!(reverse, forward);
+        let (staged, counts, retained_partial_is_consumed) = forward;
+        assert_eq!(
+            staged
+                .iter()
+                .map(|(support, stage, _)| (support.clone(), *stage))
+                .collect::<Vec<_>>(),
+            vec![
+                (vec![0, 1], 1),
+                (vec![0, 2], 1),
+                (vec![0, 3], 1),
+                (vec![1, 2], 1),
+                (vec![1, 3], 1),
+                (vec![2, 3], 1),
+                (vec![0, 1, 2], 2),
+                (vec![0, 1, 3], 2),
+                (vec![0, 2, 3], 2),
+                (vec![1, 2, 3], 2),
+            ],
+        );
+        assert!(staged.iter().all(|(_, stage, transition_ids)| {
+            transition_ids.len() == if *stage == 1 { 1 } else { 3 }
+        }));
+        assert_eq!(counts, (14, 18));
+        assert!(retained_partial_is_consumed);
+    }
+
+    #[test]
+    fn anchor_exclusion_preserves_order_exact_factors_and_contact_owners() {
+        let baseline = production_contact_barrier_currents(false, false, None);
+        let baseline_signature = ordered_exact_forward_signature(&baseline);
+
+        for closure_anchor_slot in 0_u32..4 {
+            let pruned =
+                production_contact_barrier_currents(false, false, Some(closure_anchor_slot));
+            assert_eq!(
+                pruned
+                    .iter()
+                    .filter(|current| {
+                        current.key.node_kind() == RecurrenceNodeKind::Source
+                            && current.key.support_source_slots() == [closure_anchor_slot]
+                    })
+                    .count(),
+                1,
+                "the singleton closure anchor must remain materialized",
+            );
+            assert!(pruned.iter().all(|current| {
+                current.key.node_kind() == RecurrenceNodeKind::Source
+                    || !current
+                        .key
+                        .support_source_slots()
+                        .contains(&closure_anchor_slot)
+            }));
+
+            let expected = baseline_signature
+                .iter()
+                .filter(|(support, node_kind, _, _)| {
+                    *node_kind == RecurrenceNodeKind::Source
+                        || !support.contains(&closure_anchor_slot)
+                })
+                .cloned()
+                .collect::<Vec<_>>();
+            assert_eq!(
+                ordered_exact_forward_signature(&pruned),
+                expected,
+                "anchor filtering must preserve surviving current order, exact factors, ordered parent supports, and contact-orbit owners",
+            );
+
+            let anchor_id = pruned
+                .iter()
+                .position(|current| {
+                    current.key.node_kind() == RecurrenceNodeKind::Source
+                        && current.key.support_source_slots() == [closure_anchor_slot]
+                })
+                .unwrap() as u32;
+            let complement = (0_u32..4)
+                .filter(|slot| *slot != closure_anchor_slot)
+                .collect::<Vec<_>>();
+            let complement_id = pruned
+                .iter()
+                .position(|current| current.key.support_source_slots() == complement)
+                .unwrap() as u32;
+            let closure = PendingClosure {
+                key: PendingClosureKey {
+                    closure_template_id: 0,
+                    quantum_flow_template_id: None,
+                    parent_current_ids: [anchor_id, complement_id],
+                    color_witness_term_id: LCColorWitnessTermId::new(0, 0),
+                },
+                factor: ExactComplexRational::ONE,
+                component_coefficients: vec![ExactComplexRational::ONE].into_boxed_slice(),
+                pairing_lineages: vec![PendingPairingLineage {
+                    completed_pairs: Vec::new(),
+                    unmatched_endpoint: None,
+                }],
+            };
+            let live = live_current_ids(&pruned, &[closure]).unwrap();
+            assert!(live.contains(&anchor_id));
+            assert!(live.iter().all(|current_id| {
+                let current = &pruned[*current_id as usize];
+                current.key.node_kind() == RecurrenceNodeKind::Source
+                    || !current
+                        .key
+                        .support_source_slots()
+                        .contains(&closure_anchor_slot)
+            }));
+        }
+    }
+
+    #[test]
+    fn anchor_exclusion_preserves_structural_zero_when_no_complement_can_be_built() {
+        let templates = contact_orbit_test_template(ContactOrbitTestBinding::None)
+            .validate()
+            .unwrap();
+        let propagators = propagator_by_state(&templates).unwrap();
+        let seed = scalar_contact_seed(3);
+        let query = DecodedLcQueryV1::new(
+            &seed,
+            vec![0, 1, 2],
+            &[0, 0, 0],
+            OnTheFlyLcSelectorV1::Singlet,
+        )
+        .unwrap();
+        let transitions = BTreeMap::new();
+        let closures = BTreeMap::new();
+        let contact_orbits = PreparedContactOrbitIndex::new(&transitions).unwrap();
+        let fermion_ordering = on_the_fly_fermion_ordering_context(&seed).unwrap();
+        let build = |closure_anchor_slot| {
+            let mut colors = DynamicLCColorStateInterner::default();
+            let mut currents = (0_u32..3)
+                .map(|slot| {
+                    contact_current_with_source_template(
+                        RecurrenceNodeKind::Source,
+                        0,
+                        0,
+                        &[slot],
+                        0,
+                    )
+                })
+                .collect::<Vec<_>>();
+            let mut current_ids = currents
+                .iter()
+                .enumerate()
+                .map(|(id, current)| (current.key.clone(), id as u32))
+                .collect::<BTreeMap<_, _>>();
+            build_forward_currents_with_anchor_exclusion(
+                &templates,
+                &transitions,
+                &TransitionReflectionIndex::default(),
+                &contact_orbits,
+                false,
+                &seed,
+                &fermion_ordering,
+                closure_anchor_slot,
+                seed.explicit_coupling_limits(),
+                &propagators,
+                &mut colors,
+                &mut currents,
+                &mut current_ids,
+            )
+            .unwrap();
+            assert!(
+                build_selected_closures(
+                    &templates,
+                    &closures,
+                    &seed,
+                    &fermion_ordering,
+                    &query,
+                    false,
+                    &colors,
+                    &currents,
+                )
+                .unwrap()
+                .is_none()
+            );
+            currents
+        };
+        let baseline = build(None);
+        let pruned = build(Some(query.closure_anchor_slot));
+        assert_eq!(
+            ordered_exact_forward_signature(&pruned),
+            ordered_exact_forward_signature(&baseline),
+        );
+    }
+
+    #[test]
+    fn forward_sweep_accepts_contact_partial_in_its_certified_internal_parent_domain() {
+        let forward = production_contact_barrier_case(false, true);
+        let reverse = production_contact_barrier_case(true, true);
+        assert_eq!(reverse, forward);
+        let (staged, _, _) = forward;
+
+        assert!(
+            staged
+                .iter()
+                .filter(|(_, stage, _)| *stage == 1)
+                .any(|(_, _, transition_ids)| {
+                    transition_ids
+                        .iter()
+                        .any(|transition_id| *transition_id < 6)
+                }),
+            "one-plus-one source parents must retain a certified contact partial",
+        );
+        assert!(
+            staged
+                .iter()
+                .filter(|(_, stage, _)| *stage == 1)
+                .any(|(_, _, transition_ids)| transition_ids.as_slice() == [12]),
+            "the ordinary scalar transition must construct a composite scalar parent",
+        );
+        assert!(
+            staged
+                .iter()
+                .filter(|(_, stage, _)| *stage == 2)
+                .flat_map(|(_, _, transition_ids)| transition_ids)
+                .any(|transition_id| *transition_id < 6),
+            "a certified contact partial must accept a matching internal scalar parent",
+        );
+        assert!(
+            staged
+                .iter()
+                .filter(|(_, stage, _)| *stage == 2)
+                .flat_map(|(_, _, transition_ids)| transition_ids)
+                .any(|transition_id| (6..12).contains(transition_id)),
+            "a one-plus-two certified contact final must remain available",
+        );
+    }
+
+    #[test]
+    fn contact_0012_partial_and_final_fan_in_each_keep_one_owner() {
+        let mut partial_currents = vec![
+            contact_current(RecurrenceNodeKind::Source, 10, 0, &[10]),
+            contact_current(RecurrenceNodeKind::Source, 10, 1, &[11]),
+            contact_current(RecurrenceNodeKind::Current, 20, 2, &[10, 11]),
+        ];
+        let partial_contacts = BTreeMap::from([
+            (
+                10,
+                contact_transition(
+                    partial_contact_orbit_step_for_test(0, 1, 2, 50, [0, 0, 1, 2]),
+                    [10, 10],
+                    52,
+                ),
+            ),
+            (
+                11,
+                contact_transition(
+                    partial_contact_orbit_step_for_test(1, 0, 2, 51, [0, 0, 1, 2]),
+                    [10, 10],
+                    53,
+                ),
+            ),
+        ]);
+        add_contact_contribution(&mut partial_currents, 2, 11, [0, 1]);
+        add_contact_contribution(&mut partial_currents, 2, 10, [0, 1]);
+        commit_contact_plan(&mut partial_currents, &partial_contacts, 2).unwrap();
+        assert_eq!(contact_transition_ids(&partial_currents[2]), [10]);
+        assert_eq!(pending_contact_counts(&partial_currents), (3, 1));
+
+        let mut final_currents = vec![
+            contact_current(RecurrenceNodeKind::Current, 20, 0, &[10, 11]),
+            contact_current(RecurrenceNodeKind::Source, 30, 1, &[12]),
+            contact_current(RecurrenceNodeKind::Current, 40, 2, &[10, 11, 12]),
+        ];
+        let final_contacts = BTreeMap::from([
+            (
+                20,
+                contact_transition(
+                    final_contact_orbit_step_for_test(&[0, 1], &[2], 3, 54, [0, 0, 1, 2]),
+                    [20, 30],
+                    56,
+                ),
+            ),
+            (
+                21,
+                contact_transition(
+                    final_contact_orbit_step_for_test(&[2], &[0, 1], 3, 55, [0, 0, 1, 2]),
+                    [30, 20],
+                    57,
+                ),
+            ),
+        ]);
+        add_contact_contribution(&mut final_currents, 2, 20, [0, 1]);
+        add_contact_contribution(&mut final_currents, 2, 21, [1, 0]);
+        commit_contact_plan(&mut final_currents, &final_contacts, 2).unwrap();
+        assert_eq!(contact_transition_ids(&final_currents[2]), [21]);
+        assert_eq!(pending_contact_counts(&final_currents), (3, 1));
+    }
+
+    #[test]
+    fn contact_owner_planning_rolls_back_conflict_decode_and_allocation_errors() {
+        let mut currents = vec![
+            contact_current(RecurrenceNodeKind::Source, 10, 0, &[10]),
+            contact_current(RecurrenceNodeKind::Source, 10, 1, &[11]),
+            contact_current(RecurrenceNodeKind::Current, 20, 2, &[10, 11]),
+        ];
+        let duplicate_step = partial_contact_orbit_step_for_test(0, 1, 2, 60, [0, 0, 0, 0]);
+        let contacts = BTreeMap::from([
+            (30, contact_transition(duplicate_step.clone(), [10, 10], 61)),
+            (31, contact_transition(duplicate_step, [10, 10], 61)),
+        ]);
+        add_contact_contribution(&mut currents, 2, 30, [0, 1]);
+        add_contact_contribution(&mut currents, 2, 31, [0, 1]);
+        let before = currents[2].contributions.clone();
+        assert!(
+            plan_on_the_fly_contact_orbit_owners_with_resolver(2, &currents, |transition_id| {
+                contacts.get(&transition_id)
+            })
+            .unwrap_err()
+            .to_string()
+            .contains("conflicting exact rank")
+        );
+        assert_eq!(currents[2].contributions, before);
+
+        let mut malformed = currents;
+        let (pending, factor) = malformed[2]
+            .contributions
+            .first_key_value()
+            .map(|(pending, factor)| (pending.clone(), *factor))
+            .unwrap();
+        malformed[2].contributions.remove(&pending);
+        malformed[2].contributions.insert(
+            PendingContributionKey {
+                parent_current_ids: [u32::MAX, pending.parent_current_ids[1]],
+                key: pending.key,
+            },
+            factor,
+        );
+        let malformed_before = malformed[2].contributions.clone();
+        assert!(
+            plan_on_the_fly_contact_orbit_owners_with_resolver(2, &malformed, |transition_id| {
+                contacts.get(&transition_id)
+            },)
+            .unwrap_err()
+            .to_string()
+            .contains("left parent is absent")
+        );
+        assert_eq!(malformed[2].contributions, malformed_before);
+
+        let mut candidate_reservation = Vec::<OnTheFlyContactContributionToken>::new();
+        assert!(
+            reserve_on_the_fly_contact_candidates(&mut candidate_reservation, usize::MAX)
+                .unwrap_err()
+                .to_string()
+                .contains("candidate allocation failed")
+        );
+        assert!(candidate_reservation.is_empty());
+        let mut location_reservation = Vec::<u8>::new();
+        assert!(
+            reserve_on_the_fly_contact_locations(&mut location_reservation, usize::MAX)
+                .unwrap_err()
+                .to_string()
+                .contains("transition-index allocation failed")
+        );
+        assert!(location_reservation.is_empty());
+    }
+
+    #[test]
+    fn contact_index_and_uncertified_controls_use_production_lookup_and_fast_path() {
+        let none = contact_orbit_test_template(ContactOrbitTestBinding::None)
+            .validate()
+            .unwrap();
+        let none_catalog = TemplateCatalog::new(none.input()).unwrap();
+        let none_transitions = prepared_transitions(&none, &none_catalog).unwrap();
+        assert!(
+            PreparedContactOrbitIndex::new(&none_transitions)
+                .unwrap()
+                .is_empty()
+        );
+
+        let one = contact_orbit_test_template(ContactOrbitTestBinding::One)
+            .validate()
+            .unwrap();
+        let one_catalog = TemplateCatalog::new(one.input()).unwrap();
+        let mut one_transitions = prepared_transitions(&one, &one_catalog).unwrap();
+        let mut ordinary = one_transitions.values().flatten().next().unwrap().clone();
+        ordinary.row.id = u32::MAX - 1;
+        ordinary.contact_orbit = None;
+        assert!(
+            one_transitions
+                .values()
+                .flatten()
+                .all(|prepared| prepared.row.id != ordinary.row.id)
+        );
+        one_transitions.values_mut().next().unwrap().push(ordinary);
+        let index = PreparedContactOrbitIndex::new(&one_transitions).unwrap();
+        assert!(!index.is_empty());
+        assert_eq!(index.len(), 1);
+        for prepared in one_transitions.values().flatten() {
+            assert_eq!(
+                index.get(&one_transitions, prepared.row.id),
+                prepared.contact_orbit.as_ref(),
+            );
+        }
+        assert!(index.get(&one_transitions, u32::MAX).is_none());
+
+        let mut currents = vec![
+            contact_current(RecurrenceNodeKind::Source, 10, 0, &[10]),
+            contact_current(RecurrenceNodeKind::Source, 11, 1, &[11]),
+            contact_current(RecurrenceNodeKind::Current, 20, 2, &[10, 11]),
+        ];
+        // Distinct uncertified rows represent ordinary V3, vector, fermion,
+        // and QCD controls. No model-level class is inspected by this path.
+        for transition in 70..74 {
+            add_contact_contribution(&mut currents, 2, transition, [0, 1]);
+        }
+        let before = currents[2].contributions.clone();
+        assert!(
+            plan_on_the_fly_contact_orbit_owners(
+                2,
+                &BTreeMap::new(),
+                &PreparedContactOrbitIndex::default(),
+                &currents
+            )
+            .unwrap()
+            .is_none()
+        );
+        assert_eq!(currents[2].contributions, before);
+        assert_eq!(pending_contact_counts(&currents), (3, 4));
+    }
+
+    #[test]
+    fn pairing_lineage_capacity_is_checked_without_an_arbitrary_limit() {
+        assert_eq!(
+            checked_pairing_capacity(1 << 20, 1 << 20, 1).unwrap(),
+            2_097_153
+        );
+        assert!(checked_pairing_capacity(usize::MAX, 1, 0).is_err());
+    }
+
+    #[test]
+    fn large_pairing_lineage_clone_is_fallible_and_exact() {
+        let pair_count = 16_384usize;
+        let mut completed_pairs = Vec::new();
+        completed_pairs.try_reserve_exact(pair_count).unwrap();
+        for index in 0..pair_count {
+            completed_pairs.push([index as u32, (index + pair_count) as u32]);
+        }
+        let lineage = PendingPairingLineage {
+            completed_pairs,
+            unmatched_endpoint: None,
+        };
+        let copied = try_clone_pairing_lineage(&lineage).unwrap();
+        assert_eq!(copied, lineage);
+    }
+
+    #[test]
+    fn projected_pairing_owners_are_exactly_one_per_closure_not_global() {
+        assert!(
+            projected_pairing_lineages(&[closure(vec![lineage([0, 1]), lineage([0, 3])])]).is_err()
+        );
+        let closures = [
+            closure(vec![lineage([0, 1])]),
+            closure(vec![lineage([0, 3])]),
+        ];
+        let owners = projected_pairing_lineages(&closures).unwrap();
+        assert_eq!(owners, [&lineage([0, 1]), &lineage([0, 3])]);
+        assert!(projected_pairing_lineages(&[]).is_err());
+    }
+
+    #[test]
+    fn multi_realized_closure_keeps_one_semantic_owner_without_rescaling() {
+        let mut pending = closure(vec![
+            lineage([4, 7]),
+            lineage([0, 3]),
+            lineage([2, 5]),
+            lineage([0, 3]),
+        ]);
+        pending.factor = ExactComplexRational::ONE.checked_neg().unwrap();
+        let expected_factor = pending.factor;
+
+        retain_canonical_pairing_lineage(&mut pending.pairing_lineages).unwrap();
+
+        assert_eq!(pending.pairing_lineages, vec![lineage([0, 3])]);
+        assert_eq!(pending.factor, expected_factor);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/templates.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/templates.rs
new file mode 100644
index 0000000000..24a5cf4c46
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/templates.rs
@@ -0,0 +1,1050 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+use crate::recurrence::construct::TransitionReflectionIndex;
+use crate::recurrence::fermion_ordering::FermionOrderingContext;
+use crate::recurrence::template::{
+    CurrentOrientation, EvaluatorCallableKind, OutputFactorSource, ParticleStatistics,
+};
+
+/// Immutable grammar prepared once for one loaded on-the-fly runtime.
+/// Query families borrow these exact rows and query-invariant contexts; they
+/// never rebuild transition, closure, contact-orbit, propagator, or fermion
+/// ordering state per selected query.
+#[derive(Debug)]
+pub(crate) struct PreparedOnTheFlyGrammarV1 {
+    pub(super) transitions: BTreeMap<(u32, u32), Vec<PreparedTransition>>,
+    pub(super) transition_reflections: TransitionReflectionIndex,
+    pub(super) contact_orbits: PreparedContactOrbitIndex,
+    pub(super) closures: BTreeMap<(u32, u32), Vec<PreparedClosure>>,
+    pub(super) propagators: BTreeMap<u32, Option<u32>>,
+    pub(super) sources: BTreeMap<(u32, u32), PreparedOnTheFlySourceContractV1>,
+    pub(super) propagator_executors: BTreeMap<u32, PreparedOnTheFlyExecutorContractV1>,
+    pub(super) fermion_ordering: FermionOrderingContext,
+    pub(super) closure_anchor_policy: OnTheFlyClosureAnchorPolicyV1,
+}
+
+impl PreparedOnTheFlyGrammarV1 {
+    pub(crate) fn canonicalize_query(
+        &self,
+        seed: &OnTheFlyProcessSeedV1,
+        query: DecodedLcQueryV1,
+    ) -> RusticolResult<DecodedLcQueryV1> {
+        self.closure_anchor_policy.canonicalize_query(seed, query)
+    }
+
+    pub(crate) fn authenticate_canonical_query(
+        &self,
+        seed: &OnTheFlyProcessSeedV1,
+        query: &DecodedLcQueryV1,
+    ) -> RusticolResult<()> {
+        self.closure_anchor_policy
+            .authenticate_canonical_query(seed, query)
+    }
+
+    pub(super) fn closure_anchor_for_components(
+        &self,
+        seed: &OnTheFlyProcessSeedV1,
+        components: &[LCColorComponent],
+    ) -> Option<u32> {
+        self.closure_anchor_policy
+            .closure_anchor_for_components(seed, components)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) struct PreparedOnTheFlyExecutorContractV1 {
+    pub(super) operation_id: u32,
+    pub(super) operation_semantic_digest: SemanticDigest,
+    pub(super) evaluator_binding_id: u32,
+    pub(super) evaluator_binding_semantic_digest: SemanticDigest,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) struct PreparedOnTheFlySourceContractV1 {
+    pub(super) current_state: CurrentStateRow,
+    pub(super) color_seed: LCColorSourceSeed,
+    pub(super) executor: PreparedOnTheFlyExecutorContractV1,
+}
+
+pub(super) fn prepare_on_the_fly_grammar_v1(
+    templates: &ValidatedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+    seed: &OnTheFlyProcessSeedV1,
+) -> RusticolResult<PreparedOnTheFlyGrammarV1> {
+    let transitions = prepared_transitions(templates, catalog)?;
+    let transition_reflections = TransitionReflectionIndex::new(templates.input(), catalog)?;
+    let contact_orbits = PreparedContactOrbitIndex::new(&transitions)?;
+    let closures = prepared_closures(templates, catalog)?;
+    // Structural-zero queries may trust this immutable domain only because it
+    // is proved complete once, before the grammar enters the runtime cache.
+    validate_prepared_closure_domain(templates, catalog, &closures)?;
+    let propagators = propagator_by_state(templates)?;
+    let fermion_ordering = on_the_fly_fermion_ordering_context(seed)?;
+    let closure_anchor_policy =
+        certified_cyclic_trace_closure_anchor_policy(templates.input(), catalog, seed)?;
+    Ok(PreparedOnTheFlyGrammarV1 {
+        transitions,
+        transition_reflections,
+        contact_orbits,
+        closures,
+        sources: prepared_source_contracts(templates, catalog, seed)?,
+        propagator_executors: prepared_propagator_executors(templates, catalog, &propagators)?,
+        propagators,
+        fermion_ordering,
+        closure_anchor_policy,
+    })
+}
+
+/// Infer the v4 cyclic-anchor capability from the compact process seed and
+/// the already-authenticated template catalog.
+///
+/// This deliberately mirrors the generation-side v4 admission proof.  A
+/// false predicate retains the established selector-endpoint policy; malformed
+/// catalog references remain hard errors rather than silently widening the
+/// optimization domain.
+fn certified_cyclic_trace_closure_anchor_policy(
+    input: &crate::recurrence::template::OwnedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+    seed: &OnTheFlyProcessSeedV1,
+) -> RusticolResult<OnTheFlyClosureAnchorPolicyV1> {
+    let fallback = || Ok(OnTheFlyClosureAnchorPolicyV1::selector_endpoint());
+    if !seed.pairing_classes.is_empty()
+        || seed.source_anchors.iter().any(|anchor| {
+            anchor.is_fermionic || anchor.color_role != OnTheFlyExternalColorRoleV1::Adjoint
+        })
+    {
+        return fallback();
+    }
+    let state_template_ids = seed
+        .source_anchors
+        .iter()
+        .flat_map(|anchor| anchor.states.iter())
+        .map(|state| state.current_state_template_id)
+        .collect::<BTreeSet<_>>();
+    if state_template_ids.len() != 1 {
+        return fallback();
+    }
+    let state_template_id = *state_template_ids
+        .iter()
+        .next()
+        .expect("tested one cyclic-anchor state template");
+    let state = input
+        .current_states
+        .get(state_template_id as usize)
+        .copied()
+        .ok_or_else(|| integrity("cyclic-anchor current-state template is absent"))?;
+    if state.id != state_template_id
+        || CurrentOrientation::try_from(state.orientation)? != CurrentOrientation::SelfConjugate
+        || ParticleStatistics::try_from(state.statistics)? != ParticleStatistics::Boson
+        || state.particle_id != state.anti_particle_id
+        || state.color_representation != 8
+        || catalog.string(
+            state.lc_color_shape_string_id,
+            "cyclic-anchor current-state color shape",
+        )? != "adjoint-segment"
+        || state.auxiliary_kind_string_id != MISSING_U32
+    {
+        return fallback();
+    }
+
+    let mut has_direct_closure = false;
+    for closure in input.closures.iter().copied() {
+        let coupling_order_set = input
+            .coupling_order_ranges
+            .get(closure.coupling_order_set_id as usize)
+            .ok_or_else(|| integrity("cyclic-anchor coupling-order set is absent"))?;
+        if catalog.u32_sequence(
+            closure.input_state_sequence_id,
+            "cyclic-anchor closure input states",
+        )? != [state_template_id, state_template_id]
+            || closure.result_state_template_id != MISSING_U32
+            || !catalog
+                .u32_sequence(
+                    closure.coupling_parameter_sequence_id,
+                    "cyclic-anchor closure coupling parameters",
+                )?
+                .is_empty()
+            || coupling_order_set.range.count != 0
+            || !catalog
+                .u32_sequence(
+                    closure.eligible_quantum_flow_sequence_id,
+                    "cyclic-anchor closure quantum flows",
+                )?
+                .is_empty()
+            || OutputFactorSource::try_from(closure.output_factor_source)?
+                != OutputFactorSource::None
+            || catalog.string(
+                closure.equivalence_class_string_id,
+                "cyclic-anchor closure equivalence class",
+            )? != "direct-contraction"
+        {
+            continue;
+        }
+        let binding = input
+            .evaluator_bindings
+            .get(closure.evaluator_binding_id as usize)
+            .copied()
+            .ok_or_else(|| integrity("cyclic-anchor closure evaluator is absent"))?;
+        if binding.id != closure.evaluator_binding_id
+            || EvaluatorCallableKind::try_from(binding.callable_kind)?
+                != EvaluatorCallableKind::RusticolTemplate
+            || EvaluatorContractKind::try_from(binding.contract_kind)?
+                != EvaluatorContractKind::Closure
+            || catalog.u32_sequence(
+                binding.input_state_sequence_id,
+                "cyclic-anchor evaluator input states",
+            )? != [state_template_id, state_template_id]
+            || binding.output_state_template_id != MISSING_U32
+        {
+            continue;
+        }
+        let color = input
+            .color_contractions
+            .get(closure.color_contraction_template_id as usize)
+            .copied()
+            .ok_or_else(|| integrity("cyclic-anchor color contraction is absent"))?;
+        if color.id == closure.color_contraction_template_id
+            && catalog.i32_sequence(
+                color.input_representation_sequence_id,
+                "cyclic-anchor color input representations",
+            )? == [8, 8]
+            && color.has_output_representation == 0
+        {
+            has_direct_closure = true;
+            break;
+        }
+    }
+    if !has_direct_closure {
+        return fallback();
+    }
+    let minimum = seed
+        .source_anchors
+        .iter()
+        .map(|anchor| anchor.source_slot)
+        .min()
+        .ok_or_else(|| integrity("cyclic-anchor source domain is empty"))?;
+    Ok(OnTheFlyClosureAnchorPolicyV1::certified_cyclic_minimum(
+        minimum,
+    ))
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct PreparedFlavourFlow {
+    operation: PreparedFlavourFlowOperation,
+    result_particle: i32,
+    static_result: Box<[i32]>,
+}
+
+#[derive(Clone, Copy, Debug)]
+enum PreparedFlavourFlowOperation {
+    Constant,
+    AppendLeft,
+    AppendRight,
+    ConcatLeftRight,
+}
+
+impl PreparedFlavourFlow {
+    fn new(quantum: QuantumFlowRow, catalog: &TemplateCatalog<'_>) -> RusticolResult<Self> {
+        let operation = match catalog.string(
+            quantum.flavour_flow_operation_string_id,
+            "quantum-flow flavour operation",
+        )? {
+            "constant-result" => PreparedFlavourFlowOperation::Constant,
+            "append-left-result" => PreparedFlavourFlowOperation::AppendLeft,
+            "append-right-result" => PreparedFlavourFlowOperation::AppendRight,
+            "concat-left-right-result" => PreparedFlavourFlowOperation::ConcatLeftRight,
+            value => {
+                return Err(invalid(format!(
+                    "unsupported quantum-flow flavour operation {value:?}"
+                )));
+            }
+        };
+        let static_result = catalog
+            .flavour_flow(quantum.result_flavour_flow_id, "quantum result flavour")?
+            .to_vec();
+        let result_particle = *static_result
+            .last()
+            .ok_or_else(|| invalid("quantum result flavour ancestry is empty"))?;
+        Ok(Self {
+            operation,
+            result_particle,
+            static_result: static_result.into_boxed_slice(),
+        })
+    }
+
+    pub(super) fn apply(&self, parents: [&CurrentCoreKey; 2]) -> Vec<i32> {
+        self.apply_flows(parents[0].flavour_flow(), parents[1].flavour_flow())
+    }
+
+    pub(super) fn apply_flows(&self, left: &[i32], right: &[i32]) -> Vec<i32> {
+        let append = |parent: &[i32], result_particle| {
+            let mut result = parent.to_vec();
+            if result.last().copied() != Some(result_particle) {
+                result.push(result_particle);
+            }
+            result
+        };
+        match self.operation {
+            PreparedFlavourFlowOperation::Constant => self.static_result.to_vec(),
+            PreparedFlavourFlowOperation::AppendLeft => append(left, self.result_particle),
+            PreparedFlavourFlowOperation::AppendRight => append(right, self.result_particle),
+            PreparedFlavourFlowOperation::ConcatLeftRight => {
+                let mut result = left.to_vec();
+                result.extend_from_slice(right);
+                result.push(self.result_particle);
+                result
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct PreparedWitness {
+    pub(super) row: LCColorTransitionWitnessRow,
+    pub(super) witness: crate::recurrence::LCColorTransitionWitness,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct PreparedTransition {
+    pub(super) row: TransitionRow,
+    pub(super) input_states: [u32; 2],
+    pub(super) quantum: QuantumFlowRow,
+    pub(super) input_spins: [i32; 2],
+    pub(super) local_orders: Box<[u32]>,
+    canonical_input_order: [u32; 2],
+    input_exchange_factor: Option<ExactComplexRational>,
+    pub(super) base_factor: ExactComplexRational,
+    #[cfg(feature = "on-the-fly-test-support")]
+    pub(super) transition_factor: ExactComplexRational,
+    #[cfg(feature = "on-the-fly-test-support")]
+    pub(super) contraction_factor: ExactComplexRational,
+    coupling_authenticated: bool,
+    binding_coupling: ExactComplexRational,
+    output_factor_source: u8,
+    pub(super) flavour: PreparedFlavourFlow,
+    pub(super) quantum_semantic_digest: SemanticDigest,
+    pub(super) transition_semantic_digest: SemanticDigest,
+    pub(super) evaluator_binding_digest: SemanticDigest,
+    pub(super) contact_orbit: Option<PreparedContactOrbitTransition>,
+    pub(super) witnesses: Box<[PreparedWitness]>,
+}
+
+impl PreparedTransition {
+    fn new(
+        row: TransitionRow,
+        templates: &ValidatedRecurrenceTemplateInput,
+        catalog: &TemplateCatalog<'_>,
+    ) -> RusticolResult<Self> {
+        let input = templates.input();
+        let input_states: [u32; 2] = catalog
+            .u32_sequence(row.input_state_sequence_id, "transition input states")?
+            .try_into()
+            .map_err(|_| invalid("on-the-fly transition must be binary"))?;
+        let quantum = *input
+            .quantum_flows
+            .get(row.quantum_flow_template_id as usize)
+            .ok_or_else(|| invalid("transition quantum flow is absent"))?;
+        let input_spins: [i32; 2] = catalog
+            .i32_sequence(quantum.input_spin_sequence_id, "quantum input spins")?
+            .try_into()
+            .map_err(|_| invalid("on-the-fly quantum flow must be binary"))?;
+        let quantum_states =
+            catalog.u32_sequence(quantum.input_state_sequence_id, "quantum input states")?;
+        if quantum_states != input_states {
+            return Err(invalid("transition and quantum-flow input states disagree"));
+        }
+        let canonical_input_order = match catalog.u32_sequence(
+            row.canonical_input_order_sequence_id,
+            "transition canonical input order",
+        )? {
+            [0, 1] => [0, 1],
+            [1, 0] => [1, 0],
+            _ => return Err(invalid("transition canonical input order is not binary")),
+        };
+        let input_exchange_factor = (row.input_exchange_factor_id != MISSING_U32)
+            .then(|| catalog.factor(row.input_exchange_factor_id, "transition input exchange"))
+            .transpose()?;
+        let contraction = input
+            .color_contractions
+            .get(row.color_contraction_template_id as usize)
+            .ok_or_else(|| invalid("transition color contraction is absent"))?;
+        let quantum_coupling =
+            catalog.factor(quantum.exact_coupling_factor_id, "quantum coupling")?;
+        let binding_coupling = catalog.factor(
+            row.binding_coupling_factor_id,
+            "transition binding coupling",
+        )?;
+        let transition_exact_factor = catalog.factor(row.exact_factor_id, "transition exact")?;
+        let contraction_exact_factor = catalog.factor(
+            contraction.exact_coefficient_factor_id,
+            "transition color contraction",
+        )?;
+        let base_factor = multiply_factors(&[transition_exact_factor, contraction_exact_factor])?;
+        let binding = input
+            .evaluator_bindings
+            .get(row.evaluator_binding_id as usize)
+            .ok_or_else(|| invalid("transition evaluator binding is absent"))?;
+        if binding.id != row.evaluator_binding_id
+            || EvaluatorContractKind::try_from(binding.contract_kind)?
+                != EvaluatorContractKind::Vertex
+        {
+            return Err(invalid("transition evaluator binding has the wrong role"));
+        }
+        let local_orders = catalog
+            .coupling_orders(row.coupling_order_set_id)?
+            .into_boxed_slice();
+        let quantum_semantic_digest =
+            catalog.digest(quantum.semantic_digest_id, "quantum semantic")?;
+        let witness_rows = catalog.witness_rows(row.color_contraction_template_id)?;
+        let contact_orbit = prepare_contact_orbit_transition(
+            input,
+            catalog,
+            row,
+            quantum_semantic_digest,
+            &local_orders,
+            binding_coupling,
+            transition_exact_factor,
+            contraction_exact_factor,
+            input_exchange_factor,
+            witness_rows,
+        )?;
+        let witnesses = witness_rows
+            .iter()
+            .copied()
+            .map(|witness_row| {
+                Ok(PreparedWitness {
+                    row: witness_row,
+                    witness: catalog.witness(witness_row)?,
+                })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        Ok(Self {
+            row,
+            input_states,
+            quantum,
+            input_spins,
+            local_orders,
+            canonical_input_order,
+            input_exchange_factor,
+            base_factor,
+            #[cfg(feature = "on-the-fly-test-support")]
+            transition_factor: transition_exact_factor,
+            #[cfg(feature = "on-the-fly-test-support")]
+            contraction_factor: contraction_exact_factor,
+            coupling_authenticated: quantum_coupling == binding_coupling,
+            binding_coupling,
+            output_factor_source: row.output_factor_source,
+            flavour: PreparedFlavourFlow::new(quantum, catalog)?,
+            quantum_semantic_digest,
+            transition_semantic_digest: catalog
+                .digest(row.semantic_digest_id, "transition semantic")?,
+            evaluator_binding_digest: catalog
+                .digest(binding.semantic_digest_id, "transition evaluator binding")?,
+            contact_orbit,
+            witnesses: witnesses.into_boxed_slice(),
+        })
+    }
+
+    pub(super) fn parent_ids(
+        &self,
+        left_state: u32,
+        right_state: u32,
+        left_id: u32,
+        right_id: u32,
+    ) -> Option<[u32; 2]> {
+        if self.input_states == [left_state, right_state] {
+            Some([left_id, right_id])
+        } else if left_state != right_state && self.input_states == [right_state, left_state] {
+            Some([right_id, left_id])
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn evaluator_parents(&self, concrete: [u32; 2]) -> ([u32; 2], ExactComplexRational) {
+        let mut ordered = match self.canonical_input_order {
+            [0, 1] => concrete,
+            [1, 0] => [concrete[1], concrete[0]],
+            _ => unreachable!("validated transition input order"),
+        };
+        let mut factor = ExactComplexRational::ONE;
+        if let Some(exchange) = self.input_exchange_factor
+            && ordered[1] < ordered[0]
+        {
+            ordered.swap(0, 1);
+            factor = exchange;
+        }
+        (ordered, factor)
+    }
+
+    pub(super) fn output_factor(&self) -> RusticolResult<ExactComplexRational> {
+        if !self.coupling_authenticated {
+            return Err(invalid(
+                "transition binding coupling does not match its quantum-flow coupling witness",
+            ));
+        }
+        output_factor_from_binding(
+            self.binding_coupling,
+            self.output_factor_source,
+            "on-the-fly transition",
+        )
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct PreparedClosureQuantum {
+    pub(super) row: Option<QuantumFlowRow>,
+    pub(super) input_states: Option<[u32; 2]>,
+    pub(super) input_spins: Option<[i32; 2]>,
+    coupling_authenticated: bool,
+    binding_coupling: ExactComplexRational,
+    output_factor_source: u8,
+}
+
+impl PreparedClosureQuantum {
+    pub(super) fn output_factor(&self) -> RusticolResult<ExactComplexRational> {
+        if !self.coupling_authenticated {
+            return Err(invalid(
+                "closure binding coupling does not match its quantum-flow coupling witness",
+            ));
+        }
+        output_factor_from_binding(
+            self.binding_coupling,
+            self.output_factor_source,
+            "on-the-fly closure quantum flow",
+        )
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct PreparedClosure {
+    pub(super) row: ClosureRow,
+    pub(super) input_states: [u32; 2],
+    pub(super) local_orders: Box<[u32]>,
+    pub(super) component_coefficients: Box<[ExactComplexRational]>,
+    canonical_input_order: [u32; 2],
+    input_exchange_factor: Option<ExactComplexRational>,
+    pub(super) base_factor: ExactComplexRational,
+    pub(super) closure_semantic_digest: SemanticDigest,
+    pub(super) evaluator_binding_digest: SemanticDigest,
+    pub(super) quantum_flows: Box<[PreparedClosureQuantum]>,
+    pub(super) witnesses: Box<[PreparedWitness]>,
+}
+
+impl PreparedClosure {
+    fn new(
+        row: ClosureRow,
+        templates: &ValidatedRecurrenceTemplateInput,
+        catalog: &TemplateCatalog<'_>,
+    ) -> RusticolResult<Self> {
+        let input = templates.input();
+        let input_states: [u32; 2] = catalog
+            .u32_sequence(row.input_state_sequence_id, "closure input states")?
+            .try_into()
+            .map_err(|_| invalid("on-the-fly closure must be binary"))?;
+        let local_orders = catalog
+            .coupling_orders(row.coupling_order_set_id)?
+            .into_boxed_slice();
+        let component_coefficients = catalog
+            .u32_sequence(
+                row.component_coefficient_sequence_id,
+                "closure component coefficients",
+            )?
+            .iter()
+            .map(|factor_id| catalog.factor(*factor_id, "closure component coefficient"))
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_boxed_slice();
+        let canonical_input_order = match catalog.u32_sequence(
+            row.canonical_input_order_sequence_id,
+            "closure canonical input order",
+        )? {
+            [0, 1] => [0, 1],
+            [1, 0] => [1, 0],
+            _ => return Err(invalid("closure canonical input order is not binary")),
+        };
+        let input_exchange_factor = (row.input_exchange_factor_id != MISSING_U32)
+            .then(|| catalog.factor(row.input_exchange_factor_id, "closure input exchange"))
+            .transpose()?;
+        let contraction = input
+            .color_contractions
+            .get(row.color_contraction_template_id as usize)
+            .ok_or_else(|| invalid("closure color contraction is absent"))?;
+        let binding_coupling =
+            catalog.factor(row.binding_coupling_factor_id, "closure binding coupling")?;
+        let base_factor = multiply_factors(&[
+            catalog.factor(row.exact_factor_id, "closure exact")?,
+            catalog.factor(
+                contraction.exact_coefficient_factor_id,
+                "closure color contraction",
+            )?,
+        ])?;
+        let binding = input
+            .evaluator_bindings
+            .get(row.evaluator_binding_id as usize)
+            .ok_or_else(|| invalid("closure evaluator binding is absent"))?;
+        if binding.id != row.evaluator_binding_id
+            || EvaluatorContractKind::try_from(binding.contract_kind)?
+                != EvaluatorContractKind::Closure
+        {
+            return Err(invalid("closure evaluator binding has the wrong role"));
+        }
+        let eligible = catalog.u32_sequence(
+            row.eligible_quantum_flow_sequence_id,
+            "closure eligible quantum flows",
+        )?;
+        let quantum_flows = if eligible.is_empty() {
+            vec![PreparedClosureQuantum {
+                row: None,
+                input_states: None,
+                input_spins: None,
+                coupling_authenticated: true,
+                binding_coupling,
+                output_factor_source: row.output_factor_source,
+            }]
+        } else {
+            eligible
+                .iter()
+                .copied()
+                .map(|id| {
+                    let quantum = *input
+                        .quantum_flows
+                        .get(id as usize)
+                        .ok_or_else(|| invalid("closure quantum flow is absent"))?;
+                    let states: [u32; 2] = catalog
+                        .u32_sequence(quantum.input_state_sequence_id, "closure quantum states")?
+                        .try_into()
+                        .map_err(|_| invalid("closure quantum flow must be binary"))?;
+                    let spins: [i32; 2] = catalog
+                        .i32_sequence(quantum.input_spin_sequence_id, "closure quantum spins")?
+                        .try_into()
+                        .map_err(|_| invalid("closure quantum flow must be binary"))?;
+                    let quantum_coupling = catalog
+                        .factor(quantum.exact_coupling_factor_id, "closure quantum coupling")?;
+                    Ok(PreparedClosureQuantum {
+                        row: Some(quantum),
+                        input_states: Some(states),
+                        input_spins: Some(spins),
+                        coupling_authenticated: quantum_coupling == binding_coupling,
+                        binding_coupling,
+                        output_factor_source: row.output_factor_source,
+                    })
+                })
+                .collect::<RusticolResult<Vec<_>>>()?
+        };
+        let witnesses = catalog
+            .witness_rows(row.color_contraction_template_id)?
+            .iter()
+            .copied()
+            .map(|witness_row| {
+                Ok(PreparedWitness {
+                    row: witness_row,
+                    witness: catalog.witness(witness_row)?,
+                })
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        Ok(Self {
+            row,
+            input_states,
+            local_orders,
+            component_coefficients,
+            canonical_input_order,
+            input_exchange_factor,
+            base_factor,
+            closure_semantic_digest: catalog.digest(row.semantic_digest_id, "closure semantic")?,
+            evaluator_binding_digest: catalog
+                .digest(binding.semantic_digest_id, "closure evaluator binding")?,
+            quantum_flows: quantum_flows.into_boxed_slice(),
+            witnesses: witnesses.into_boxed_slice(),
+        })
+    }
+
+    pub(super) fn parent_ids(
+        &self,
+        anchor_state: u32,
+        complement_state: u32,
+        anchor_id: u32,
+        complement_id: u32,
+    ) -> Option<[u32; 2]> {
+        if self.input_states == [complement_state, anchor_state] {
+            Some([complement_id, anchor_id])
+        } else if anchor_state != complement_state
+            && self.input_states == [anchor_state, complement_state]
+        {
+            Some([anchor_id, complement_id])
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn evaluator_parents(&self, concrete: [u32; 2]) -> ([u32; 2], ExactComplexRational) {
+        let mut ordered = match self.canonical_input_order {
+            [0, 1] => concrete,
+            [1, 0] => [concrete[1], concrete[0]],
+            _ => unreachable!("validated closure input order"),
+        };
+        let mut factor = ExactComplexRational::ONE;
+        if let Some(exchange) = self.input_exchange_factor
+            && ordered[1] < ordered[0]
+        {
+            ordered.swap(0, 1);
+            factor = exchange;
+        }
+        (ordered, factor)
+    }
+}
+
+fn prepared_source_contracts(
+    templates: &ValidatedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+    seed: &OnTheFlyProcessSeedV1,
+) -> RusticolResult<BTreeMap<(u32, u32), PreparedOnTheFlySourceContractV1>> {
+    let mut result = BTreeMap::new();
+    for anchor in &seed.source_anchors {
+        for state in &anchor.states {
+            let (source, current_state) =
+                validate_source_contract(templates, catalog, anchor, state)?;
+            let binding = templates
+                .input()
+                .evaluator_bindings
+                .get(source.evaluator_binding_id as usize)
+                .ok_or_else(|| integrity("source evaluator binding is absent"))?;
+            let contract = PreparedOnTheFlySourceContractV1 {
+                current_state,
+                color_seed: catalog.source_seed(source)?,
+                executor: PreparedOnTheFlyExecutorContractV1 {
+                    operation_id: source.id,
+                    operation_semantic_digest: catalog
+                        .digest(source.semantic_digest_id, "source semantic")?,
+                    evaluator_binding_id: binding.id,
+                    evaluator_binding_semantic_digest: catalog
+                        .digest(binding.semantic_digest_id, "source evaluator semantic")?,
+                },
+            };
+            let key = (state.source_template_id, state.current_state_template_id);
+            if let Some(previous) = result.insert(key, contract)
+                && previous != contract
+            {
+                return Err(integrity(
+                    "equal compact source identities have different prepared contracts",
+                ));
+            }
+        }
+    }
+    Ok(result)
+}
+
+fn prepared_propagator_executors(
+    templates: &ValidatedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+    propagators: &BTreeMap<u32, Option<u32>>,
+) -> RusticolResult<BTreeMap<u32, PreparedOnTheFlyExecutorContractV1>> {
+    let mut result = BTreeMap::new();
+    for propagator_id in propagators.values().flatten().copied() {
+        let row = templates
+            .input()
+            .propagators
+            .get(propagator_id as usize)
+            .ok_or_else(|| integrity("propagator executor template is absent"))?;
+        let binding = templates
+            .input()
+            .evaluator_bindings
+            .get(row.evaluator_binding_id as usize)
+            .ok_or_else(|| integrity("propagator executor binding is absent"))?;
+        let contract = PreparedOnTheFlyExecutorContractV1 {
+            operation_id: row.id,
+            operation_semantic_digest: catalog
+                .digest(row.semantic_digest_id, "propagator semantic")?,
+            evaluator_binding_id: binding.id,
+            evaluator_binding_semantic_digest: catalog
+                .digest(binding.semantic_digest_id, "propagator evaluator semantic")?,
+        };
+        if let Some(previous) = result.insert(propagator_id, contract)
+            && previous != contract
+        {
+            return Err(integrity(
+                "equal propagator identities have different prepared contracts",
+            ));
+        }
+    }
+    Ok(result)
+}
+
+pub(super) fn canonical_state_pair(left: u32, right: u32) -> (u32, u32) {
+    if left <= right {
+        (left, right)
+    } else {
+        (right, left)
+    }
+}
+
+pub(super) fn propagator_by_state(
+    templates: &ValidatedRecurrenceTemplateInput,
+) -> RusticolResult<BTreeMap<u32, Option<u32>>> {
+    let mut result = BTreeMap::new();
+    for row in &templates.input().propagators {
+        let value = (row.applies_propagator != 0).then_some(row.id);
+        if result.insert(row.state_template_id, value).is_some() {
+            return Err(invalid(format!(
+                "current state {} has multiple propagator contracts",
+                row.state_template_id
+            )));
+        }
+    }
+    Ok(result)
+}
+
+pub(super) fn prepared_transitions(
+    templates: &ValidatedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<BTreeMap<(u32, u32), Vec<PreparedTransition>>> {
+    let mut result = BTreeMap::<(u32, u32), Vec<PreparedTransition>>::new();
+    for row in templates.input().transitions.iter().copied() {
+        let prepared = PreparedTransition::new(row, templates, catalog)?;
+        result
+            .entry(canonical_state_pair(
+                prepared.input_states[0],
+                prepared.input_states[1],
+            ))
+            .or_default()
+            .push(prepared);
+    }
+    Ok(result)
+}
+
+pub(super) fn prepared_closures(
+    templates: &ValidatedRecurrenceTemplateInput,
+    catalog: &TemplateCatalog<'_>,
+) -> RusticolResult<BTreeMap<(u32, u32), Vec<PreparedClosure>>> {
+    let mut result = BTreeMap::<(u32, u32), Vec<PreparedClosure>>::new();
+    for row in templates.input().closures.iter().copied() {
+        let prepared = PreparedClosure::new(row, templates, catalog)?;
+        result
+            .entry(canonical_state_pair(
+                prepared.input_states[0],
+                prepared.input_states[1],
+            ))
+            .or_default()
+            .push(prepared);
+    }
+    Ok(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::contact_orbit_owner::{
+        ContactOrbitTestBinding, contact_orbit_test_template,
+    };
+    use crate::recurrence::fermion_ordering::fermion_ordering_factor;
+    use crate::recurrence::validated_template_fixture;
+
+    fn append_string(
+        input: &mut crate::recurrence::template::OwnedRecurrenceTemplateInput,
+        value: &str,
+    ) -> u32 {
+        let id = u32::try_from(input.string_ranges.len()).unwrap();
+        let start = u64::try_from(input.string_bytes.len()).unwrap();
+        input.string_bytes.extend_from_slice(value.as_bytes());
+        input
+            .string_ranges
+            .push(crate::recurrence::CheckedTableRange::new(
+                start,
+                u64::try_from(value.len()).unwrap(),
+            ));
+        id
+    }
+
+    fn four_adjoint_seed(
+        summary: crate::recurrence::template::RecurrenceTemplateValidationSummary,
+    ) -> OnTheFlyProcessSeedV1 {
+        let anchors = (0..4_u32)
+            .map(|source_slot| {
+                let state = OnTheFlySourceStateV1::new(
+                    0,
+                    1,
+                    1,
+                    0,
+                    0,
+                    SemanticDigest::new([5; 32]).unwrap(),
+                    SemanticDigest::new([4; 32]).unwrap(),
+                    1,
+                    ExactComplexRational::ONE,
+                    50_000,
+                    0,
+                    vec![21],
+                    0,
+                    SemanticDigest::new([17; 32]).unwrap(),
+                    OnTheFlySourceWavefunctionFamilyV1::Vector,
+                    OnTheFlySourceOrientationV1::SelfConjugate,
+                    None,
+                )
+                .unwrap();
+                OnTheFlySourceAnchorV1::new(
+                    source_slot,
+                    source_slot,
+                    source_slot < 2,
+                    OnTheFlyExternalColorRoleV1::Adjoint,
+                    false,
+                    None,
+                    vec![state],
+                )
+                .unwrap()
+            })
+            .collect();
+        OnTheFlyProcessSeedV1::new(
+            SemanticDigest::new([91; 32]).unwrap(),
+            summary.compiled_model_digest,
+            summary.catalog_digest,
+            summary.prepared_kernel_pack_digest,
+            SemanticDigest::new([0x7d; 32]).unwrap(),
+            SemanticDigest::new([92; 32]).unwrap(),
+            "raw-amplitude-test",
+            ExactComplexRational::ONE,
+            anchors,
+            vec![0, 1, 2, 3],
+            OnTheFlyCouplingOrderPolicyV1::Explicit,
+            vec![1],
+            vec![Some(0)],
+            Vec::new(),
+        )
+        .unwrap()
+    }
+
+    fn cyclic_anchor_template_fixture() -> (
+        crate::recurrence::template::OwnedRecurrenceTemplateInput,
+        OnTheFlyProcessSeedV1,
+    ) {
+        let templates = validated_template_fixture();
+        let seed = four_adjoint_seed(templates.summary());
+        let mut input = templates.into_input();
+        let adjoint_shape = append_string(&mut input, "adjoint-segment");
+        let direct_contraction = append_string(&mut input, "direct-contraction");
+        let empty_sequence = input
+            .u32_sequence_ranges
+            .iter()
+            .find(|row| row.range.count == 0)
+            .unwrap()
+            .id;
+
+        input.current_states[0].color_representation = 8;
+        input.current_states[0].lc_color_shape_string_id = adjoint_shape;
+        let closure = &mut input.closures[0];
+        closure.result_state_template_id = MISSING_U32;
+        closure.eligible_quantum_flow_sequence_id = empty_sequence;
+        closure.equivalence_class_string_id = direct_contraction;
+        input.evaluator_bindings[closure.evaluator_binding_id as usize].callable_kind =
+            EvaluatorCallableKind::RusticolTemplate as u8;
+        let color = &mut input.color_contractions[closure.color_contraction_template_id as usize];
+        let representations = input.i32_sequence_ranges
+            [color.input_representation_sequence_id as usize]
+            .range
+            .as_usize_range(input.i32_sequence_values.len(), "test color inputs")
+            .unwrap();
+        input.i32_sequence_values[representations].copy_from_slice(&[8, 8]);
+        (input, seed)
+    }
+
+    #[test]
+    fn on_the_fly_prepared_transition_binds_only_certified_contact_metadata() {
+        let none = contact_orbit_test_template(ContactOrbitTestBinding::None)
+            .validate()
+            .unwrap();
+        let none_catalog = TemplateCatalog::new(none.input()).unwrap();
+        let none_prepared = prepared_transitions(&none, &none_catalog).unwrap();
+        assert!(
+            none_prepared
+                .values()
+                .flatten()
+                .next()
+                .unwrap()
+                .contact_orbit
+                .is_none()
+        );
+
+        let one = contact_orbit_test_template(ContactOrbitTestBinding::One)
+            .validate()
+            .unwrap();
+        let one_catalog = TemplateCatalog::new(one.input()).unwrap();
+        let one_prepared = prepared_transitions(&one, &one_catalog).unwrap();
+        assert!(
+            one_prepared
+                .values()
+                .flatten()
+                .next()
+                .unwrap()
+                .contact_orbit
+                .is_some()
+        );
+    }
+
+    #[test]
+    fn prepared_grammar_caches_exact_query_invariant_contexts() {
+        let templates = validated_template_fixture();
+        let summary = templates.summary();
+        let seed = scalar_adapter_test_seed(
+            summary.compiled_model_digest,
+            summary.catalog_digest,
+            summary.prepared_kernel_pack_digest,
+            SemanticDigest::new([0x7d; 32]).unwrap(),
+        )
+        .unwrap();
+        let catalog = TemplateCatalog::new(templates.input()).unwrap();
+        let grammar = prepare_on_the_fly_grammar_v1(&templates, &catalog, &seed).unwrap();
+
+        assert_eq!(
+            grammar.contact_orbits,
+            PreparedContactOrbitIndex::new(&grammar.transitions).unwrap(),
+        );
+        assert_eq!(
+            grammar.closure_anchor_policy,
+            OnTheFlyClosureAnchorPolicyV1::selector_endpoint(),
+        );
+        let fresh_fermion_ordering = on_the_fly_fermion_ordering_context(&seed).unwrap();
+        assert_eq!(
+            fermion_ordering_factor(
+                &templates.input().current_states,
+                [0, 0],
+                [&[0], &[1]],
+                &grammar.fermion_ordering,
+            )
+            .unwrap(),
+            fermion_ordering_factor(
+                &templates.input().current_states,
+                [0, 0],
+                [&[0], &[1]],
+                &fresh_fermion_ordering,
+            )
+            .unwrap(),
+        );
+    }
+
+    #[test]
+    fn cyclic_anchor_policy_requires_the_exact_v4_template_contract() {
+        let (input, seed) = cyclic_anchor_template_fixture();
+        let catalog = TemplateCatalog::new(&input).unwrap();
+        assert_eq!(
+            certified_cyclic_trace_closure_anchor_policy(&input, &catalog, &seed).unwrap(),
+            OnTheFlyClosureAnchorPolicyV1::certified_cyclic_minimum(0),
+        );
+
+        let mut ineligible = input.clone();
+        let closure = ineligible.closures[0];
+        ineligible.evaluator_bindings[closure.evaluator_binding_id as usize].callable_kind =
+            EvaluatorCallableKind::PreparedKernel as u8;
+        let catalog = TemplateCatalog::new(&ineligible).unwrap();
+        assert_eq!(
+            certified_cyclic_trace_closure_anchor_policy(&ineligible, &catalog, &seed).unwrap(),
+            OnTheFlyClosureAnchorPolicyV1::selector_endpoint(),
+        );
+
+        let mut auxiliary = input;
+        auxiliary.current_states[0].auxiliary_kind_string_id =
+            auxiliary.current_states[0].lc_color_shape_string_id;
+        let catalog = TemplateCatalog::new(&auxiliary).unwrap();
+        assert_eq!(
+            certified_cyclic_trace_closure_anchor_policy(&auxiliary, &catalog, &seed).unwrap(),
+            OnTheFlyClosureAnchorPolicyV1::selector_endpoint(),
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/test_support.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/test_support.rs
new file mode 100644
index 0000000000..f300e7c4c1
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/test_support.rs
@@ -0,0 +1,1469 @@
+// SPDX-License-Identifier: 0BSD
+
+#![allow(dead_code)] // This module is intentionally a non-default test-support surface.
+
+//! Feature-gated development oracle for the compact on-the-fly builder.
+//!
+//! This is the only on-the-fly module allowed to consume the materialized
+//! recurrence builder input.  It maps exactly one authenticated public row
+//! into the compact seed/query API, then compares that query-local trace with
+//! the established builder.  Release/default builds do not compile this file.
+
+use super::source_seed::validate_permutation;
+use super::trace::{contribution_proof_digest, hash_current_key, multiset_digest};
+use super::*;
+use crate::recurrence::construct::TemplateCatalog;
+use crate::recurrence::process::{
+    OwnedFermionPairingInput, OwnedRecurrenceProcessInput, ProcessLCSectorKind,
+    ProcessSourceStateRow,
+};
+use crate::recurrence::template::{CurrentOrientation, CurrentStateRow, ParticleStatistics};
+use crate::recurrence::{
+    AuthenticatedRecurrenceBuilderInput, ConstructionTransitionDiagnosticRowV1, RecurrenceProgram,
+    RecurrenceStrategy,
+};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[doc(hidden)]
+pub struct OnTheFlyTestSupportReportV1 {
+    pub seed_digest: SemanticDigest,
+    pub query_digest: SemanticDigest,
+    pub selector_digest: SemanticDigest,
+    pub trace_digest: SemanticDigest,
+    pub current_count: u32,
+    pub contribution_count: u32,
+    pub closure_count: u32,
+    pub established_current_count: u32,
+    pub established_contribution_count: u32,
+    pub established_closure_count: u32,
+    pub current_multiset_digest: SemanticDigest,
+    pub established_current_multiset_digest: SemanticDigest,
+    pub contribution_multiset_digest: SemanticDigest,
+    pub established_contribution_multiset_digest: SemanticDigest,
+    pub closure_multiset_digest: SemanticDigest,
+    pub closure_parity_multiset_digest: SemanticDigest,
+    pub established_closure_parity_multiset_digest: SemanticDigest,
+    pub negative_contribution_factor_count: u32,
+    pub established_negative_contribution_factor_count: u32,
+    pub source_domain_equal: bool,
+    pub pairing_oracle_equal: bool,
+    pub pairing_fermion_parities: Vec<i32>,
+    pub established_pairing_fermion_parities: Vec<i32>,
+    pub workspace_capacity_independent: bool,
+    pub compact_transition_candidates: Vec<ConstructionTransitionDiagnosticRowV1>,
+    pub established_transition_candidates: Vec<ConstructionTransitionDiagnosticRowV1>,
+}
+
+impl OnTheFlyTestSupportReportV1 {
+    pub fn structural_parity(&self) -> bool {
+        self.current_count == self.established_current_count
+            && self.contribution_count == self.established_contribution_count
+            && self.closure_count == self.established_closure_count
+            && self.current_multiset_digest == self.established_current_multiset_digest
+            && self.contribution_multiset_digest == self.established_contribution_multiset_digest
+            && self.closure_parity_multiset_digest
+                == self.established_closure_parity_multiset_digest
+            && self.source_domain_equal
+            && self.pairing_oracle_equal
+    }
+}
+
+struct OnePublicRowOracle {
+    external_permutation: Vec<u32>,
+    public_helicities: Vec<i32>,
+    selector: OnTheFlyLcSelectorV1,
+}
+
+/// Test-support convenience bundle retaining one generated compact seed.
+/// Production families instead keep one lane-owned seed and build borrowed
+/// [`OnTheFlySelectedQueryTraceV1`] values for each selected query.
+pub(crate) struct OnTheFlySelectedTraceV1 {
+    pub(crate) seed: OnTheFlyProcessSeedV1,
+    pub(crate) query: DecodedLcQueryV1,
+    pub(crate) trace: OnTheFlyStructuralTraceV1,
+    pub(crate) projection: OnTheFlyProjectionProbeV1,
+}
+
+fn process_string<'a>(
+    process: &'a OwnedRecurrenceProcessInput,
+    string_id: u32,
+    label: &str,
+) -> RusticolResult<&'a str> {
+    let range = process
+        .string_ranges
+        .get(string_id as usize)
+        .copied()
+        .ok_or_else(|| integrity(format!("{label} string is absent")))?;
+    let bytes = &process.string_bytes[range.as_usize_range(process.string_bytes.len(), label)?];
+    std::str::from_utf8(bytes)
+        .map_err(|error| integrity(format!("{label} string is not UTF-8: {error}")))
+}
+
+fn process_factor(
+    process: &OwnedRecurrenceProcessInput,
+    factor_id: u32,
+    label: &str,
+) -> RusticolResult<ExactComplexRational> {
+    let row = process
+        .exact_factors
+        .get(factor_id as usize)
+        .ok_or_else(|| integrity(format!("{label} factor is absent")))?;
+    if row.id != factor_id {
+        return Err(integrity(format!(
+            "{label} factor catalog is not canonical"
+        )));
+    }
+    ExactComplexRational::parse_parts(
+        process_string(process, row.real_numerator_string_id, label)?,
+        process_string(process, row.real_denominator_string_id, label)?,
+        process_string(process, row.imag_numerator_string_id, label)?,
+        process_string(process, row.imag_denominator_string_id, label)?,
+    )
+    .map_err(|error| integrity(format!("{label} exact factor is invalid: {error}")))
+}
+
+fn process_sequence<'a>(
+    process: &'a OwnedRecurrenceProcessInput,
+    sequence_id: u32,
+    label: &str,
+) -> RusticolResult<&'a [u32]> {
+    let range = process
+        .u32_sequence_ranges
+        .get(sequence_id as usize)
+        .copied()
+        .ok_or_else(|| integrity(format!("{label} sequence is absent")))?;
+    Ok(&process.u32_sequence_values
+        [range.as_usize_range(process.u32_sequence_values.len(), label)?])
+}
+
+fn process_digest(
+    process: &OwnedRecurrenceProcessInput,
+    digest_id: u32,
+    label: &str,
+) -> RusticolResult<SemanticDigest> {
+    let row = process
+        .digest_catalog
+        .get(digest_id as usize)
+        .copied()
+        .ok_or_else(|| integrity(format!("{label} digest is absent")))?;
+    if row.id != digest_id {
+        return Err(integrity(format!(
+            "{label} digest catalog is not canonical"
+        )));
+    }
+    SemanticDigest::new(row.value)
+        .map_err(|error| integrity(format!("{label} digest is invalid: {error}")))
+}
+
+fn pairing_string<'a>(
+    input: &'a OwnedFermionPairingInput,
+    string_id: u32,
+    label: &str,
+) -> RusticolResult<&'a str> {
+    let range = input
+        .string_ranges
+        .get(string_id as usize)
+        .copied()
+        .ok_or_else(|| integrity(format!("{label} pairing string is absent")))?;
+    let bytes = &input.string_bytes[range.as_usize_range(input.string_bytes.len(), label)?];
+    std::str::from_utf8(bytes)
+        .map_err(|error| integrity(format!("{label} pairing string is not UTF-8: {error}")))
+}
+
+fn authenticated_source_family(
+    catalog: &TemplateCatalog<'_>,
+    source: SourceRow,
+    current_state: CurrentStateRow,
+) -> RusticolResult<OnTheFlySourceWavefunctionFamilyV1> {
+    let family = catalog.string(
+        source.wavefunction_family_string_id,
+        "source wavefunction family",
+    )?;
+    let statistics = ParticleStatistics::try_from(current_state.statistics)?;
+    match (family, statistics, current_state.dimension) {
+        ("scalar", ParticleStatistics::Boson, 1) => Ok(OnTheFlySourceWavefunctionFamilyV1::Scalar),
+        ("fermion", ParticleStatistics::Fermion, 2) => {
+            Ok(OnTheFlySourceWavefunctionFamilyV1::WeylFermion)
+        }
+        ("fermion", ParticleStatistics::Fermion, 4) => {
+            Ok(OnTheFlySourceWavefunctionFamilyV1::DiracFermion)
+        }
+        ("vector", ParticleStatistics::Boson, 4) => Ok(OnTheFlySourceWavefunctionFamilyV1::Vector),
+        ("spin2", ParticleStatistics::Boson, 16) => Ok(OnTheFlySourceWavefunctionFamilyV1::Spin2),
+        ("ghost" | "auxiliary", _, _) => Err(invalid(
+            "on-the-fly source execution does not support ghost or auxiliary external states",
+        )),
+        _ => Err(integrity(
+            "authenticated source family, statistics, and component dimension disagree",
+        )),
+    }
+}
+
+fn authenticated_source_orientation(
+    current_state: CurrentStateRow,
+) -> RusticolResult<OnTheFlySourceOrientationV1> {
+    Ok(
+        match CurrentOrientation::try_from(current_state.orientation)? {
+            CurrentOrientation::Particle => OnTheFlySourceOrientationV1::Particle,
+            CurrentOrientation::Antiparticle => OnTheFlySourceOrientationV1::Antiparticle,
+            CurrentOrientation::SelfConjugate => OnTheFlySourceOrientationV1::SelfConjugate,
+        },
+    )
+}
+
+fn authenticated_prepared_mass_slot(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    catalog: &TemplateCatalog<'_>,
+    source: SourceRow,
+    current_state: CurrentStateRow,
+) -> RusticolResult<Option<u32>> {
+    super::source_builder::resolve_prepared_mass_slot(
+        source,
+        current_state,
+        authenticated.template().input(),
+        catalog,
+        authenticated
+            .process()
+            .input()
+            .parameter_projection
+            .iter()
+            .map(|row| {
+                (
+                    row.parameter_template_id,
+                    row.prepared_parameter_id(),
+                    row.component,
+                )
+            }),
+    )
+}
+
+fn pairing_endpoint_contracts(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+) -> RusticolResult<BTreeMap<u32, (OnTheFlyExternalColorRoleV1, SemanticDigest)>> {
+    let Some(pairing) = authenticated.process().input().fermion_pairing.as_ref() else {
+        return Ok(BTreeMap::new());
+    };
+    let mut result = BTreeMap::new();
+    for endpoint in &pairing.endpoints {
+        let role = match endpoint.color_orientation {
+            0 => OnTheFlyExternalColorRoleV1::Fundamental,
+            1 => OnTheFlyExternalColorRoleV1::Antifundamental,
+            _ => {
+                return Err(integrity(
+                    "pairing endpoint has an invalid color orientation",
+                ));
+            }
+        };
+        let digest = SemanticDigest::new(endpoint.contract_digest)
+            .map_err(|error| integrity(format!("pairing endpoint digest is invalid: {error}")))?;
+        if result
+            .insert(endpoint.source_slot, (role, digest))
+            .is_some()
+        {
+            return Err(integrity("pairing endpoint repeats a source slot"));
+        }
+    }
+    Ok(result)
+}
+
+fn color_role(
+    representation: i32,
+    endpoint: Option<(OnTheFlyExternalColorRoleV1, SemanticDigest)>,
+) -> RusticolResult<(OnTheFlyExternalColorRoleV1, Option<SemanticDigest>)> {
+    match (representation, endpoint) {
+        (1, None) => Ok((OnTheFlyExternalColorRoleV1::Singlet, None)),
+        (8, None) => Ok((OnTheFlyExternalColorRoleV1::Adjoint, None)),
+        (3, Some((OnTheFlyExternalColorRoleV1::Fundamental, digest))) => {
+            Ok((OnTheFlyExternalColorRoleV1::Fundamental, Some(digest)))
+        }
+        (-3, Some((OnTheFlyExternalColorRoleV1::Antifundamental, digest))) => {
+            Ok((OnTheFlyExternalColorRoleV1::Antifundamental, Some(digest)))
+        }
+        _ => Err(integrity(
+            "source color representation disagrees with the pairing endpoint catalog",
+        )),
+    }
+}
+
+fn authenticated_source_anchors(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+) -> RusticolResult<Vec<OnTheFlySourceAnchorV1>> {
+    let process = authenticated.process().input();
+    let selected_source_mode = authenticated.process().summary().selected_source_mode();
+    let selected_states = process
+        .selected_source_coverage
+        .iter()
+        .map(|row| (row.source_slot, row.source_state_index))
+        .collect::<BTreeSet<_>>();
+    let input = authenticated.template().input();
+    let catalog = TemplateCatalog::new(input)?;
+    let endpoint_contracts = pairing_endpoint_contracts(authenticated)?;
+    let mut anchors = Vec::new();
+    anchors
+        .try_reserve_exact(process.external_legs.len())
+        .map_err(|error| invalid(format!("source-anchor allocation failed: {error}")))?;
+    for (source_slot, leg) in process.external_legs.iter().copied().enumerate() {
+        if leg.source_slot as usize != source_slot {
+            return Err(integrity("external source slots are not canonical"));
+        }
+        let range = leg.source_state_range.as_usize_range(
+            process.source_states.len(),
+            "on-the-fly authenticated source states",
+        )?;
+        let mut states = Vec::new();
+        let mut role = None;
+        let mut anchor_fermionic = None;
+        let mut pairing_contract = None;
+        for process_state in process.source_states[range]
+            .iter()
+            .copied()
+            .filter(|state| {
+                !selected_source_mode
+                    || selected_states.contains(&(leg.source_slot, state.state_index))
+            })
+        {
+            let source = *input
+                .sources
+                .get(process_state.source_template_id as usize)
+                .ok_or_else(|| integrity("authenticated source template is absent"))?;
+            let current_state = *input
+                .current_states
+                .get(process_state.current_state_template_id as usize)
+                .ok_or_else(|| integrity("authenticated current-state template is absent"))?;
+            if source.id != process_state.source_template_id
+                || current_state.id != process_state.current_state_template_id
+            {
+                return Err(integrity(
+                    "authenticated process source row differs from its template contract",
+                ));
+            }
+            validate_crossed_source_state(leg.is_initial != 0, &process_state, source, input)?;
+            let family = authenticated_source_family(&catalog, source, current_state)?;
+            let (state_role, state_pairing_contract) = color_role(
+                current_state.color_representation,
+                endpoint_contracts.get(&leg.source_slot).copied(),
+            )?;
+            match role {
+                None => role = Some(state_role),
+                Some(previous) if previous == state_role => {}
+                Some(_) => return Err(integrity("one source anchor mixes color roles")),
+            }
+            match anchor_fermionic {
+                None => anchor_fermionic = Some(family.is_fermionic()),
+                Some(previous) if previous == family.is_fermionic() => {}
+                Some(_) => return Err(integrity("one source anchor mixes statistics")),
+            }
+            match pairing_contract {
+                None => pairing_contract = state_pairing_contract,
+                Some(previous) if Some(previous) == state_pairing_contract => {}
+                Some(_) => return Err(integrity("one source anchor mixes pairing contracts")),
+            }
+            let seed = catalog.source_seed(source)?;
+            states.push(OnTheFlySourceStateV1::new(
+                process_state.state_index,
+                process_state.public_helicity,
+                process_state.public_helicity,
+                source.id,
+                current_state.id,
+                catalog.digest(source.semantic_digest_id, "source semantic")?,
+                catalog.digest(current_state.semantic_digest_id, "current-state semantic")?,
+                process_state.momentum_sign,
+                process_factor(
+                    process,
+                    process_state.crossing_phase_factor_id,
+                    "source crossing phase",
+                )?,
+                process_state.spin_state,
+                process_state.chirality,
+                catalog
+                    .flavour_flow(source.flavour_flow_id, "source flavour flow")?
+                    .to_vec(),
+                source.quantum_number_flow_id,
+                seed.proof_digest(),
+                family,
+                authenticated_source_orientation(current_state)?,
+                authenticated_prepared_mass_slot(authenticated, &catalog, source, current_state)?,
+            )?);
+        }
+        anchors.push(OnTheFlySourceAnchorV1::new(
+            leg.source_slot,
+            leg.public_label,
+            leg.is_initial != 0,
+            role.ok_or_else(|| integrity("authenticated source anchor is empty"))?,
+            anchor_fermionic.ok_or_else(|| integrity("source statistics are absent"))?,
+            pairing_contract,
+            states,
+        )?);
+    }
+    Ok(anchors)
+}
+
+fn pairing_classes(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    contracts: &BTreeMap<u32, (OnTheFlyExternalColorRoleV1, SemanticDigest)>,
+) -> RusticolResult<Vec<OnTheFlyPairingClassV1>> {
+    let Some(input) = authenticated.process().input().fermion_pairing.as_ref() else {
+        return Ok(Vec::new());
+    };
+    input
+        .pairing_classes
+        .iter()
+        .map(|class| {
+            let endpoints = |range: crate::recurrence::CheckedTableRange,
+                             role: OnTheFlyExternalColorRoleV1,
+                             label: &str|
+             -> RusticolResult<Vec<OnTheFlyPairingEndpointV1>> {
+                let values = match role {
+                    OnTheFlyExternalColorRoleV1::Fundamental => &input.class_fundamental_slots,
+                    OnTheFlyExternalColorRoleV1::Antifundamental => {
+                        &input.class_antifundamental_slots
+                    }
+                    _ => unreachable!(),
+                };
+                values[range.as_usize_range(values.len(), label)?]
+                    .iter()
+                    .copied()
+                    .map(|source_slot| {
+                        let (actual_role, digest) = contracts
+                            .get(&source_slot)
+                            .copied()
+                            .ok_or_else(|| integrity("pairing class endpoint is absent"))?;
+                        if actual_role != role {
+                            return Err(integrity("pairing class endpoint role changed"));
+                        }
+                        Ok(OnTheFlyPairingEndpointV1 {
+                            source_slot,
+                            source_contract_digest: digest,
+                        })
+                    })
+                    .collect()
+            };
+            OnTheFlyPairingClassV1::new(
+                pairing_string(input, class.species_string_id, "pairing class species")?,
+                SemanticDigest::new(class.proof_digest).map_err(|error| {
+                    integrity(format!("pairing class proof digest is invalid: {error}"))
+                })?,
+                endpoints(
+                    class.fundamental_slot_range,
+                    OnTheFlyExternalColorRoleV1::Fundamental,
+                    "pairing class fundamental slots",
+                )?,
+                endpoints(
+                    class.antifundamental_slot_range,
+                    OnTheFlyExternalColorRoleV1::Antifundamental,
+                    "pairing class antifundamental slots",
+                )?,
+            )
+        })
+        .collect()
+}
+
+fn compact_seed(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    direct_catalog_digest: SemanticDigest,
+    external_permutation: Vec<u32>,
+) -> RusticolResult<OnTheFlyProcessSeedV1> {
+    if authenticated.process().summary().strategy() != RecurrenceStrategy::TopologyReplay {
+        return Err(invalid(
+            "the on-the-fly test oracle requires topology-replay input",
+        ));
+    }
+    let process = authenticated.process().input();
+    let normalization = *process
+        .normalization
+        .first()
+        .ok_or_else(|| integrity("authenticated process normalization is absent"))?;
+    if process.normalization.len() != 1 {
+        return Err(integrity(
+            "on-the-fly raw-amplitude input requires one normalization row",
+        ));
+    }
+    let normalization_factor =
+        process_factor(process, normalization.factor_id, "process normalization")?;
+    if normalization_factor != ExactComplexRational::ONE {
+        return Err(integrity(
+            "on-the-fly raw-amplitude normalization must be exact one",
+        ));
+    }
+    let contracts = pairing_endpoint_contracts(authenticated)?;
+    let template_catalog = TemplateCatalog::new(authenticated.template().input())?;
+    let mut process_limits = BTreeMap::new();
+    for row in &process.coupling_limits {
+        let name = process_string(process, row.name_string_id, "process coupling limit")?;
+        process_limits.insert(name, row.maximum);
+    }
+    let coupling_limits = template_catalog
+        .coupling_order_names()
+        .iter()
+        .map(|name| {
+            process_limits.get(name).copied().map(Some).ok_or_else(|| {
+                integrity(format!(
+                    "authenticated process has no finalized coupling limit for model order {name:?} required by the prepared template catalog"
+                ))
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    OnTheFlyProcessSeedV1::new(
+        authenticated.process().semantic_identity().process_digest(),
+        authenticated.template().summary().compiled_model_digest,
+        authenticated.template().summary().catalog_digest,
+        authenticated
+            .template()
+            .summary()
+            .prepared_kernel_pack_digest,
+        direct_catalog_digest,
+        process_digest(
+            process,
+            normalization.semantic_digest_id,
+            "process normalization semantic",
+        )?,
+        process_string(
+            process,
+            normalization.convention_string_id,
+            "process normalization convention",
+        )?,
+        normalization_factor,
+        authenticated_source_anchors(authenticated)?,
+        external_permutation,
+        OnTheFlyCouplingOrderPolicyV1::Explicit,
+        vec![1; coupling_limits.len()],
+        coupling_limits,
+        pairing_classes(authenticated, &contracts)?,
+    )
+}
+
+fn open_blocks_for_sector(
+    process: &OwnedRecurrenceProcessInput,
+    sector: crate::recurrence::process::ProcessPhysicalLCSectorRow,
+) -> RusticolResult<Vec<Vec<u32>>> {
+    let range = sector
+        .open_string_range
+        .as_usize_range(process.lc_open_strings.len(), "one-row open strings")?;
+    process.lc_open_strings[range]
+        .iter()
+        .map(|row| {
+            let mut block = vec![row.fundamental_source_slot];
+            block.extend_from_slice(process_sequence(
+                process,
+                row.adjoint_sequence_id,
+                "one-row open-string adjoints",
+            )?);
+            block.push(row.antifundamental_source_slot);
+            Ok(block)
+        })
+        .collect()
+}
+
+fn established_pairing_rule_by_id(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    rule_id: Option<u32>,
+) -> RusticolResult<Option<crate::recurrence::process::FermionPairingRuleRow>> {
+    let Some(catalog) = authenticated.process().fermion_pairing_catalog() else {
+        if rule_id.is_none() {
+            return Ok(None);
+        }
+        return Err(integrity(
+            "established pairing owner has no pairing catalog",
+        ));
+    };
+    let Some(rule_id) = rule_id else {
+        return Err(integrity(
+            "established retained closure has no pairing owner",
+        ));
+    };
+    catalog
+        .rules()
+        .iter()
+        .copied()
+        .find(|rule| rule.rule_id == rule_id)
+        .map(Some)
+        .ok_or_else(|| integrity(format!("established pairing owner {rule_id} is absent")))
+}
+
+fn one_public_row_oracle(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    selected_public_flow_id: u32,
+    public_helicities: &[i32],
+) -> RusticolResult<OnePublicRowOracle> {
+    let process = authenticated.process().input();
+    if public_helicities.len() != process.external_legs.len() {
+        return Err(invalid(
+            "one-row oracle requires one public helicity per external source",
+        ));
+    }
+    let selected_mode = authenticated.process().summary().selected_flow_mode();
+    if selected_mode
+        && !process
+            .selected_public_flow_coverage
+            .iter()
+            .any(|row| row.flow_id == selected_public_flow_id)
+    {
+        return Err(invalid(
+            "requested public flow is absent from the selected generation slice",
+        ));
+    }
+    let flow = process
+        .public_lc_flows
+        .iter()
+        .copied()
+        .find(|row| row.flow_id == selected_public_flow_id)
+        .ok_or_else(|| invalid("requested public flow is absent"))?;
+    let sector = *process
+        .physical_lc_sectors
+        .get(flow.construction_sector_id as usize)
+        .ok_or_else(|| integrity("public row construction sector is absent"))?;
+    if sector.sector_id != flow.construction_sector_id {
+        return Err(integrity(
+            "public row construction-sector catalog is not canonical",
+        ));
+    }
+    let external_permutation = process_sequence(
+        process,
+        flow.source_slot_permutation_sequence_id,
+        "one-row source permutation",
+    )?
+    .to_vec();
+    validate_permutation(
+        &external_permutation,
+        process.external_legs.len(),
+        "one-row external permutation",
+    )?;
+    let selector = match sector.kind()? {
+        ProcessLCSectorKind::Singlet => OnTheFlyLcSelectorV1::Singlet,
+        ProcessLCSectorKind::SingleTrace => OnTheFlyLcSelectorV1::single_trace(
+            process_sequence(process, flow.word_sequence_id, "one-row public trace")?.to_vec(),
+        ),
+        ProcessLCSectorKind::OpenLines => {
+            let construction_blocks = open_blocks_for_sector(process, sector)?;
+            let public_blocks = construction_blocks
+                .iter()
+                .map(|block| {
+                    block
+                        .iter()
+                        .map(|slot| {
+                            external_permutation
+                                .get(*slot as usize)
+                                .copied()
+                                .ok_or_else(|| integrity("one-row block source is out of range"))
+                        })
+                        .collect::<RusticolResult<Vec<_>>>()
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+            OnTheFlyLcSelectorV1::open_lines(public_blocks)
+        }
+    };
+    Ok(OnePublicRowOracle {
+        external_permutation,
+        public_helicities: public_helicities.to_vec(),
+        selector,
+    })
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct SourceDomainRow {
+    source_slot: u32,
+    source_template_id: u32,
+    spin_state_class: i32,
+    family: u8,
+    orientation: u8,
+    source_helicity: i32,
+    chirality: i32,
+    prepared_mass_parameter_slot: Option<u32>,
+}
+
+fn compact_source_domain(seed: &OnTheFlyProcessSeedV1) -> Vec<SourceDomainRow> {
+    let mut rows = seed
+        .source_execution_specs()
+        .map(|row| SourceDomainRow {
+            source_slot: row.source_slot,
+            source_template_id: row.source_template_id,
+            spin_state_class: row.spin_state_class,
+            family: row.family as u8,
+            orientation: row.orientation as u8,
+            source_helicity: row.helicity,
+            chirality: row.chirality,
+            prepared_mass_parameter_slot: row.prepared_mass_parameter_slot,
+        })
+        .collect::<Vec<_>>();
+    rows.sort_unstable();
+    rows
+}
+
+fn established_source_state_for_template(
+    source_slot: u32,
+    states: &[ProcessSourceStateRow],
+    source_template_id: u32,
+) -> RusticolResult<ProcessSourceStateRow> {
+    let mut matches = states
+        .iter()
+        .copied()
+        .filter(|state| state.source_template_id == source_template_id);
+    let state = matches.next().ok_or_else(|| {
+        integrity(format!(
+            "established source slot {source_slot} template {source_template_id} is absent from its authenticated state domain"
+        ))
+    })?;
+    if matches.next().is_some() {
+        return Err(integrity(format!(
+            "established source slot {source_slot} template {source_template_id} is ambiguous in its authenticated state domain"
+        )));
+    }
+    Ok(state)
+}
+
+fn established_source_domain(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    program: &RecurrenceProgram,
+) -> RusticolResult<Vec<SourceDomainRow>> {
+    let input = authenticated.template().input();
+    let catalog = TemplateCatalog::new(input)?;
+    let mut rows = Vec::new();
+    for current in program
+        .currents()
+        .iter()
+        .filter(|current| current.is_source())
+    {
+        let key = current.key();
+        let [source_slot] = key.support_source_slots() else {
+            return Err(integrity(
+                "established source current has non-unary support",
+            ));
+        };
+        let source_template_id = match key.source_binding() {
+            CurrentSourceBinding::FixedTemplate(value) => *value,
+            _ => return Err(integrity("established source has no fixed source template")),
+        };
+        let source = *input
+            .sources
+            .get(source_template_id as usize)
+            .ok_or_else(|| integrity("established source template is absent"))?;
+        let current_state = *input
+            .current_states
+            .get(key.current_state_template_id() as usize)
+            .ok_or_else(|| integrity("established source current state is absent"))?;
+        let process = authenticated.process().input();
+        let source_state_range = process
+            .external_legs
+            .get(*source_slot as usize)
+            .ok_or_else(|| integrity("established source leg is absent"))?
+            .source_state_range
+            .as_usize_range(process.source_states.len(), "established source states")?;
+        let source_helicity = established_source_state_for_template(
+            *source_slot,
+            &process.source_states[source_state_range],
+            source_template_id,
+        )?;
+        if source_helicity.current_state_template_id != key.current_state_template_id() {
+            return Err(integrity(format!(
+                "established source state and current template disagree: source slot {}, source state {}, source template {}, authenticated current template {}, established current template {}",
+                source_slot,
+                source_helicity.state_index,
+                source_template_id,
+                source_helicity.current_state_template_id,
+                key.current_state_template_id(),
+            )));
+        }
+        rows.push(SourceDomainRow {
+            source_slot: *source_slot,
+            source_template_id,
+            spin_state_class: key.spin_state_class(),
+            family: authenticated_source_family(&catalog, source, current_state)? as u8,
+            orientation: authenticated_source_orientation(current_state)? as u8,
+            source_helicity: source_helicity.public_helicity,
+            chirality: current_state.chirality,
+            prepared_mass_parameter_slot: authenticated_prepared_mass_slot(
+                authenticated,
+                &catalog,
+                source,
+                current_state,
+            )?,
+        });
+    }
+    rows.sort_unstable();
+    Ok(rows)
+}
+
+fn established_current_digests(program: &RecurrenceProgram) -> RusticolResult<Vec<SemanticDigest>> {
+    program
+        .currents()
+        .iter()
+        .map(|current| {
+            let color = program
+                .dynamic_color_states()
+                .get(current.key().dynamic_lc_color_state_id().get() as usize)
+                .ok_or_else(|| integrity("established current color state is absent"))?;
+            hash_current_key(current.key(), color)
+        })
+        .collect()
+}
+
+fn established_contribution_digest(
+    program: &RecurrenceProgram,
+    current_digests: &[SemanticDigest],
+) -> RusticolResult<SemanticDigest> {
+    let mut rows = Vec::new();
+    for contribution in program.contributions() {
+        let [parent0, parent1] = contribution.parent_current_ids() else {
+            return Err(integrity(
+                "established selected-query contribution is not binary",
+            ));
+        };
+        let result = *current_digests
+            .get(contribution.result_current_id() as usize)
+            .ok_or_else(|| integrity("established contribution result current is absent"))?;
+        let parents = [
+            *current_digests
+                .get(*parent0 as usize)
+                .ok_or_else(|| integrity("established contribution parent is absent"))?,
+            *current_digests
+                .get(*parent1 as usize)
+                .ok_or_else(|| integrity("established contribution parent is absent"))?,
+        ];
+        rows.push(contribution_proof_digest(
+            result,
+            parents,
+            contribution.key(),
+            contribution.exact_factor(),
+        )?);
+    }
+    multiset_digest(b"pyamplicol-on-the-fly-contribution-multiset-v1\0", rows)
+}
+
+fn closure_parity_row_digest(
+    parent_digests: [SemanticDigest; 2],
+    closure_template_id: u32,
+    factor: ExactComplexRational,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-on-the-fly-closure-parity-row-v1\0");
+    hash_digest(&mut hash, parent_digests[0]);
+    hash_digest(&mut hash, parent_digests[1]);
+    hash.update(closure_template_id.to_le_bytes());
+    hash_exact(&mut hash, factor);
+    final_digest(hash)
+}
+
+fn compact_closure_parity_digest(
+    trace: &OnTheFlyStructuralTraceV1,
+) -> RusticolResult<SemanticDigest> {
+    let mut current_by_component_base = BTreeMap::new();
+    for (index, range) in trace.current_component_ranges.iter().copied().enumerate() {
+        current_by_component_base.insert(range[0], trace.current_semantic_digests[index]);
+    }
+    let mut rows = Vec::new();
+    for operation in trace.operations.iter() {
+        let OnTheFlyTraceOperationV1::Closure { key, row } = operation else {
+            continue;
+        };
+        let closure_template_id = key.operation_id().ok_or_else(|| {
+            integrity("compact closure executor has no closure-template identity")
+        })?;
+        let factor = *trace
+            .exact_factors
+            .get(row.exact_factor_id as usize)
+            .ok_or_else(|| integrity("compact closure factor is absent"))?;
+        rows.push(closure_parity_row_digest(
+            [
+                *current_by_component_base
+                    .get(&row.parent0_component_base)
+                    .ok_or_else(|| integrity("compact closure parent 0 is absent"))?,
+                *current_by_component_base
+                    .get(&row.parent1_component_base_or_sentinel)
+                    .ok_or_else(|| integrity("compact closure parent 1 is absent"))?,
+            ],
+            closure_template_id,
+            factor,
+        )?);
+    }
+    multiset_digest(b"pyamplicol-on-the-fly-closure-parity-multiset-v1\0", rows)
+}
+
+fn established_closure_parity_digest(
+    program: &RecurrenceProgram,
+    current_digests: &[SemanticDigest],
+) -> RusticolResult<SemanticDigest> {
+    let mut rows = Vec::new();
+    for closure in program.closure_terms() {
+        let [parent0, parent1] = closure.parent_current_ids() else {
+            return Err(integrity(
+                "established selected-query closure is not binary",
+            ));
+        };
+        rows.push(closure_parity_row_digest(
+            [
+                *current_digests
+                    .get(*parent0 as usize)
+                    .ok_or_else(|| integrity("established closure parent 0 is absent"))?,
+                *current_digests
+                    .get(*parent1 as usize)
+                    .ok_or_else(|| integrity("established closure parent 1 is absent"))?,
+            ],
+            closure.closure_template_id(),
+            closure.exact_factor(),
+        )?);
+    }
+    multiset_digest(b"pyamplicol-on-the-fly-closure-parity-multiset-v1\0", rows)
+}
+
+fn is_negative_one(value: ExactComplexRational) -> RusticolResult<bool> {
+    Ok(value == ExactComplexRational::ONE.checked_neg()?)
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct PairingOracleRow {
+    endpoint_pairs: Vec<[u32; 2]>,
+    source_slot_permutation: Vec<u32>,
+    source_lineage: Vec<u32>,
+    fermion_parity: i32,
+}
+
+fn pairing_oracle_equal(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    owners: &[ResolvedPairingOwnerV1],
+    rules: &[Option<crate::recurrence::process::FermionPairingRuleRow>],
+) -> RusticolResult<(bool, Vec<i32>, Vec<i32>)> {
+    let mut compact = owners
+        .iter()
+        .map(|owner| PairingOracleRow {
+            endpoint_pairs: owner.endpoint_pairs.clone(),
+            source_slot_permutation: owner.source_slot_permutation.clone(),
+            source_lineage: owner.source_lineage.clone(),
+            fermion_parity: owner.fermion_parity,
+        })
+        .collect::<Vec<_>>();
+    let source_count = authenticated.process().input().external_legs.len();
+    let identity = (0..source_count)
+        .map(|value| checked_u32(value, "identity source slot"))
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let catalog = authenticated.process().fermion_pairing_catalog();
+    let mut established = rules
+        .iter()
+        .copied()
+        .map(|rule| {
+            let Some(rule) = rule else {
+                return Ok(PairingOracleRow {
+                    endpoint_pairs: Vec::new(),
+                    source_slot_permutation: identity.clone(),
+                    source_lineage: vec![MISSING_U32; source_count],
+                    fermion_parity: 1,
+                });
+            };
+            let catalog =
+                catalog.ok_or_else(|| integrity("established pairing rule has no catalog"))?;
+            let mut endpoint_pairs = catalog
+                .endpoint_pairings(rule)?
+                .iter()
+                .map(|pair| {
+                    [
+                        pair.fundamental_source_slot,
+                        pair.antifundamental_source_slot,
+                    ]
+                })
+                .collect::<Vec<_>>();
+            endpoint_pairs.sort_unstable();
+            Ok(PairingOracleRow {
+                endpoint_pairs,
+                source_slot_permutation: catalog.source_slot_permutation(rule)?.to_vec(),
+                source_lineage: catalog.lineage(rule)?.to_vec(),
+                fermion_parity: rule.fermion_parity,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    compact.sort_unstable();
+    established.sort_unstable();
+    let compact_parities = compact.iter().map(|row| row.fermion_parity).collect();
+    let established_parities = established.iter().map(|row| row.fermion_parity).collect();
+    Ok((
+        compact == established,
+        compact_parities,
+        established_parities,
+    ))
+}
+
+pub(crate) fn build_on_the_fly_selected_trace_v1(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    direct: &PreparedDirectExecutorCatalog,
+    selected_public_flow_id: u32,
+    public_helicities: &[i32],
+    enable_projection: bool,
+) -> RusticolResult<OnTheFlySelectedTraceV1> {
+    let oracle = one_public_row_oracle(authenticated, selected_public_flow_id, public_helicities)?;
+    let seed = compact_seed(
+        authenticated,
+        direct.direct_template_catalog_digest(),
+        oracle.external_permutation.clone(),
+    )?;
+    let query = DecodedLcQueryV1::new(
+        &seed,
+        oracle.external_permutation,
+        &oracle.public_helicities,
+        oracle.selector,
+    )?;
+    let selected = build_selected_lc_query_trace_for_probe_v1(
+        authenticated.template(),
+        direct,
+        &seed,
+        query,
+        enable_projection,
+        false,
+    )?;
+    Ok(OnTheFlySelectedTraceV1 {
+        seed,
+        query: selected.query,
+        trace: selected.trace,
+        projection: selected.projection,
+    })
+}
+
+fn reconstruct_seed_in_projection_domain(
+    retained_seed: OnTheFlyProcessSeedV1,
+    artifact_seed: &OnTheFlyProcessSeedV1,
+) -> RusticolResult<OnTheFlyProcessSeedV1> {
+    let OnTheFlyProcessSeedV1 {
+        process_digest,
+        model_digest,
+        template_catalog_digest,
+        prepared_pack_digest,
+        direct_catalog_digest,
+        normalization_semantic_digest,
+        normalization_convention,
+        source_anchors,
+        external_permutation: _,
+        coupling_order_policy: _,
+        coupling_hierarchies: _,
+        coupling_limits: _,
+        pairing_classes,
+        semantic_digest: _,
+    } = retained_seed;
+    let reconstructed = OnTheFlyProcessSeedV1::new(
+        process_digest,
+        model_digest,
+        template_catalog_digest,
+        prepared_pack_digest,
+        direct_catalog_digest,
+        normalization_semantic_digest,
+        normalization_convention,
+        ExactComplexRational::ONE,
+        source_anchors.into_vec(),
+        artifact_seed.external_permutation().to_vec(),
+        artifact_seed.coupling_order_policy(),
+        artifact_seed.coupling_hierarchies().to_vec(),
+        artifact_seed.explicit_coupling_limits().to_vec(),
+        pairing_classes.into_vec(),
+    )?;
+    if reconstructed.semantic_digest() != artifact_seed.semantic_digest() {
+        return Err(integrity(
+            "retained diagnostic semantic constituents do not authenticate in the on-the-fly artifact seed projection domain",
+        ));
+    }
+    Ok(reconstructed)
+}
+
+/// Build one retained recurrence row against an already-authenticated compact
+/// artifact seed. The retained input supplies semantic constituents and the
+/// public selector oracle; projection policy remains owned by the artifact.
+pub(crate) fn build_on_the_fly_selected_trace_against_seed_v1(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    direct: &PreparedDirectExecutorCatalog,
+    artifact_seed: &OnTheFlyProcessSeedV1,
+    selected_public_flow_id: u32,
+    public_helicities: &[i32],
+    enable_projection: bool,
+    enable_cyclic_trace_reflection: bool,
+) -> RusticolResult<OnTheFlySelectedTraceV1> {
+    let oracle = one_public_row_oracle(authenticated, selected_public_flow_id, public_helicities)?;
+    let retained_seed = compact_seed(
+        authenticated,
+        direct.direct_template_catalog_digest(),
+        oracle.external_permutation,
+    )?;
+    let _authenticated = reconstruct_seed_in_projection_domain(retained_seed, artifact_seed)?;
+    let query = DecodedLcQueryV1::new(
+        artifact_seed,
+        artifact_seed.external_permutation().to_vec(),
+        &oracle.public_helicities,
+        oracle.selector,
+    )?;
+    let selected = build_selected_lc_query_trace_for_probe_v1(
+        authenticated.template(),
+        direct,
+        artifact_seed,
+        query,
+        enable_projection,
+        enable_cyclic_trace_reflection,
+    )?;
+    Ok(OnTheFlySelectedTraceV1 {
+        seed: artifact_seed.clone(),
+        query: selected.query,
+        trace: selected.trace,
+        projection: selected.projection,
+    })
+}
+
+fn observed_transition_build<T>(
+    selection: Option<crate::recurrence::diagnostic::ConstructionDiagnosticSelectionV1>,
+    build: impl FnOnce() -> RusticolResult<T>,
+) -> RusticolResult<(
+    T,
+    Vec<ConstructionTransitionDiagnosticRowV1>,
+    Option<BTreeSet<SemanticDigest>>,
+)> {
+    crate::recurrence::diagnostic::begin_transition_diagnostic_observation(selection)?;
+    let built = build();
+    let observed = crate::recurrence::diagnostic::take_transition_diagnostic_observation();
+    match (built, observed) {
+        (Ok(value), Ok((rows, live))) => Ok((value, rows, live)),
+        (Err(error), _) => Err(error),
+        (Ok(_), Err(error)) => Err(error),
+    }
+}
+
+/// Build one compact selected query and compare it with the established
+/// materialized builder. This API exists only under `on-the-fly-test-support`.
+#[doc(hidden)]
+pub fn on_the_fly_test_support_probe_v1(
+    authenticated: &AuthenticatedRecurrenceBuilderInput,
+    direct: &PreparedDirectExecutorCatalog,
+    selected_public_flow_id: u32,
+    public_helicities: &[i32],
+) -> RusticolResult<OnTheFlyTestSupportReportV1> {
+    let (compact_pre_projection, compact_transition_candidates, _) =
+        observed_transition_build(None, || {
+            build_on_the_fly_selected_trace_v1(
+                authenticated,
+                direct,
+                selected_public_flow_id,
+                public_helicities,
+                false,
+            )
+        })?;
+    let compact_live = compact_pre_projection
+        .trace
+        .current_semantic_digests
+        .iter()
+        .copied()
+        .collect::<BTreeSet<_>>();
+    let compact_transition_candidates = compact_transition_candidates
+        .into_iter()
+        .filter(|row| {
+            compact_live.contains(&row.output_current_digest)
+                && row
+                    .ordered_parent_digests
+                    .iter()
+                    .all(|digest| compact_live.contains(digest))
+        })
+        .collect::<Vec<_>>();
+    let selected = build_on_the_fly_selected_trace_v1(
+        authenticated,
+        direct,
+        selected_public_flow_id,
+        public_helicities,
+        true,
+    )?;
+    let OnTheFlySelectedTraceV1 {
+        seed,
+        query,
+        trace,
+        projection: _,
+    } = selected;
+    crate::recurrence::construct::begin_established_pairing_owner_observation();
+    let diagnostic_selection = crate::recurrence::diagnostic::ConstructionDiagnosticSelectionV1 {
+        public_flow_id: selected_public_flow_id,
+        public_helicities: public_helicities.to_vec(),
+    };
+    let (established, established_transition_candidates, established_live) =
+        observed_transition_build(Some(diagnostic_selection), || authenticated.build())?;
+    let established_live = established_live.ok_or_else(|| {
+        integrity("established transition diagnostic did not record its selected live slice")
+    })?;
+    let established_materialized_sector_id = established
+        .replay_targets()
+        .iter()
+        .find(|target| target.target_sector_id() == selected_public_flow_id)
+        .map(crate::recurrence::RecurrenceReplayTarget::materialized_sector_id)
+        .ok_or_else(|| {
+            integrity(format!(
+                "established transition diagnostic public flow {selected_public_flow_id} has no replay target"
+            ))
+        })?;
+    let established_transition_candidates =
+        crate::recurrence::diagnostic::retain_materialized_sector_rows(
+            established_transition_candidates,
+            established_materialized_sector_id,
+            |row| row.materialized_sector_id,
+        )
+        .into_iter()
+        .filter(|row| {
+            established_live.contains(&row.output_current_digest)
+                && row
+                    .ordered_parent_digests
+                    .iter()
+                    .all(|digest| established_live.contains(digest))
+        })
+        .collect::<Vec<_>>();
+    let established_pairing_rules =
+        crate::recurrence::construct::take_established_pairing_owner_observation()?
+            .into_iter()
+            .map(|rule_id| established_pairing_rule_by_id(authenticated, rule_id))
+            .collect::<RusticolResult<Vec<_>>>()?;
+    let established_current_rows = established_current_digests(&established)?;
+    let established_current_multiset_digest = multiset_digest(
+        b"pyamplicol-on-the-fly-current-multiset-v1\0",
+        established_current_rows.clone(),
+    )?;
+    let established_contribution_multiset_digest =
+        established_contribution_digest(&established, &established_current_rows)?;
+    let closure_parity_multiset_digest = compact_closure_parity_digest(&trace)?;
+    let established_closure_parity_multiset_digest =
+        established_closure_parity_digest(&established, &established_current_rows)?;
+    let negative_contribution_factor_count = checked_u32(
+        trace
+            .operations
+            .iter()
+            .filter_map(|operation| match operation {
+                OnTheFlyTraceOperationV1::Contribution { row, .. } => trace
+                    .exact_factors
+                    .get(row.exact_factor_id as usize)
+                    .copied(),
+                _ => None,
+            })
+            .map(is_negative_one)
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_iter()
+            .filter(|negative| *negative)
+            .count(),
+        "compact negative contribution count",
+    )?;
+    let established_negative_contribution_factor_count = checked_u32(
+        established
+            .contributions()
+            .iter()
+            .map(|row| is_negative_one(row.exact_factor()))
+            .collect::<RusticolResult<Vec<_>>>()?
+            .into_iter()
+            .filter(|negative| *negative)
+            .count(),
+        "established negative contribution count",
+    )?;
+    let (pairing_oracle_equal, pairing_fermion_parities, established_pairing_fermion_parities) =
+        pairing_oracle_equal(
+            authenticated,
+            &trace.pairing_owners,
+            &established_pairing_rules,
+        )?;
+    let one = OnTheFlyWorkspaceV1::new(&trace, 1)?;
+    let many = OnTheFlyWorkspaceV1::new(&trace, 17)?;
+    let workspace_capacity_independent = one.point_stride() != many.point_stride();
+    let proof = trace.proof();
+    Ok(OnTheFlyTestSupportReportV1 {
+        seed_digest: seed.semantic_digest(),
+        query_digest: query.semantic_digest(),
+        selector_digest: query.selector_digest,
+        trace_digest: trace.semantic_digest(),
+        current_count: proof.current_count(),
+        contribution_count: proof.contribution_count(),
+        closure_count: proof.closure_count(),
+        established_current_count: checked_u32(
+            established.currents().len(),
+            "established current count",
+        )?,
+        established_contribution_count: checked_u32(
+            established.contributions().len(),
+            "established contribution count",
+        )?,
+        established_closure_count: checked_u32(
+            established.closure_terms().len(),
+            "established closure count",
+        )?,
+        current_multiset_digest: proof.current_multiset_digest(),
+        established_current_multiset_digest,
+        contribution_multiset_digest: proof.contribution_multiset_digest(),
+        established_contribution_multiset_digest,
+        closure_multiset_digest: proof.closure_multiset_digest(),
+        closure_parity_multiset_digest,
+        established_closure_parity_multiset_digest,
+        negative_contribution_factor_count,
+        established_negative_contribution_factor_count,
+        source_domain_equal: compact_source_domain(&seed)
+            == established_source_domain(authenticated, &established)?,
+        pairing_oracle_equal,
+        pairing_fermion_parities,
+        established_pairing_fermion_parities,
+        workspace_capacity_independent,
+        compact_transition_candidates,
+        established_transition_candidates,
+    })
+}
+
+#[cfg(test)]
+mod source_domain_tests {
+    use super::*;
+
+    fn digest(value: u8) -> SemanticDigest {
+        SemanticDigest::new([value; 32]).unwrap()
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn rebuild_test_seed(
+        seed: OnTheFlyProcessSeedV1,
+        external_permutation: Vec<u32>,
+        coupling_order_policy: OnTheFlyCouplingOrderPolicyV1,
+        coupling_hierarchies: Vec<u32>,
+        coupling_limits: Vec<Option<u32>>,
+        normalization_semantic_digest: Option<SemanticDigest>,
+        source_semantic_digest: Option<SemanticDigest>,
+    ) -> OnTheFlyProcessSeedV1 {
+        let OnTheFlyProcessSeedV1 {
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest: original_normalization_semantic_digest,
+            normalization_convention,
+            source_anchors,
+            external_permutation: _,
+            coupling_order_policy: _,
+            coupling_hierarchies: _,
+            coupling_limits: _,
+            pairing_classes,
+            semantic_digest: _,
+        } = seed;
+        let mut source_anchors = source_anchors.into_vec();
+        if let Some(source_semantic_digest) = source_semantic_digest {
+            source_anchors[0].states[0].source_semantic_digest = source_semantic_digest;
+        }
+        OnTheFlyProcessSeedV1::new(
+            process_digest,
+            model_digest,
+            template_catalog_digest,
+            prepared_pack_digest,
+            direct_catalog_digest,
+            normalization_semantic_digest.unwrap_or(original_normalization_semantic_digest),
+            normalization_convention,
+            ExactComplexRational::ONE,
+            source_anchors,
+            external_permutation,
+            coupling_order_policy,
+            coupling_hierarchies,
+            coupling_limits,
+            pairing_classes.into_vec(),
+        )
+        .unwrap()
+    }
+
+    fn projection_domain_fixture(
+        normalization_semantic_digest: Option<SemanticDigest>,
+        source_semantic_digest: Option<SemanticDigest>,
+    ) -> (OnTheFlyProcessSeedV1, OnTheFlyProcessSeedV1) {
+        let base = scalar_adapter_test_seed(digest(1), digest(2), digest(3), digest(4)).unwrap();
+        let artifact_seed = rebuild_test_seed(
+            base.clone(),
+            vec![0, 1],
+            OnTheFlyCouplingOrderPolicyV1::Minimal,
+            vec![1, 2],
+            vec![None, None],
+            None,
+            None,
+        );
+        let retained_seed = rebuild_test_seed(
+            base,
+            vec![1, 0],
+            OnTheFlyCouplingOrderPolicyV1::Explicit,
+            vec![1, 1],
+            vec![Some(4), Some(0)],
+            normalization_semantic_digest,
+            source_semantic_digest,
+        );
+        (artifact_seed, retained_seed)
+    }
+
+    fn source_state(
+        state_index: u32,
+        public_helicity: i32,
+        current_state_template_id: u32,
+        source_template_id: u32,
+    ) -> ProcessSourceStateRow {
+        ProcessSourceStateRow {
+            source_slot: 0,
+            state_index,
+            public_helicity,
+            chirality: public_helicity,
+            spin_state: public_helicity,
+            current_state_template_id,
+            source_template_id,
+            momentum_sign: 1,
+            crossing_phase_factor_id: 0,
+        }
+    }
+
+    #[test]
+    fn established_source_domain_resolves_each_valid_state_by_its_own_template() {
+        let states = [source_state(0, -1, 16, 57), source_state(1, 1, 76, 23)];
+        let negative = established_source_state_for_template(0, &states, 57).unwrap();
+        let positive = established_source_state_for_template(0, &states, 23).unwrap();
+        assert_eq!(
+            (negative.state_index, negative.current_state_template_id),
+            (0, 16)
+        );
+        assert_eq!(
+            (positive.state_index, positive.current_state_template_id),
+            (1, 76)
+        );
+    }
+
+    #[test]
+    fn minimal_process_global_artifact_authenticates_explicit_flow_local_oracle_in_artifact_domain()
+    {
+        let (artifact_seed, retained_seed) = projection_domain_fixture(None, None);
+        assert_ne!(
+            retained_seed.semantic_digest(),
+            artifact_seed.semantic_digest()
+        );
+        let oracle = OnePublicRowOracle {
+            external_permutation: retained_seed.external_permutation().to_vec(),
+            public_helicities: vec![0, 0],
+            selector: OnTheFlyLcSelectorV1::Singlet,
+        };
+        assert!(
+            DecodedLcQueryV1::new(
+                &artifact_seed,
+                oracle.external_permutation.clone(),
+                &oracle.public_helicities,
+                oracle.selector.clone(),
+            )
+            .is_err()
+        );
+        let reconstructed =
+            reconstruct_seed_in_projection_domain(retained_seed, &artifact_seed).unwrap();
+        assert_eq!(
+            reconstructed.semantic_digest(),
+            artifact_seed.semantic_digest()
+        );
+        let query = DecodedLcQueryV1::new(
+            &artifact_seed,
+            artifact_seed.external_permutation().to_vec(),
+            &oracle.public_helicities,
+            oracle.selector,
+        )
+        .unwrap();
+        assert_eq!(query.process_seed_digest(), artifact_seed.semantic_digest());
+    }
+
+    #[test]
+    fn projection_domain_reconstruction_rejects_mutated_semantic_constituents() {
+        for (normalization_semantic_digest, source_semantic_digest) in
+            [(Some(digest(93)), None), (None, Some(digest(94)))]
+        {
+            let (artifact_seed, retained_seed) =
+                projection_domain_fixture(normalization_semantic_digest, source_semantic_digest);
+            let error =
+                reconstruct_seed_in_projection_domain(retained_seed, &artifact_seed).unwrap_err();
+            assert!(
+                error
+                    .to_string()
+                    .contains("semantic constituents do not authenticate")
+            );
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/trace.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/trace.rs
new file mode 100644
index 0000000000..487a1693ca
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/on_the_fly/trace.rs
@@ -0,0 +1,2196 @@
+// SPDX-License-Identifier: 0BSD
+
+#![allow(dead_code)] // Query-local proof inspection is retained for opt-in support builds.
+
+use super::sweep::*;
+use super::*;
+
+#[cfg(feature = "on-the-fly-test-support")]
+pub(crate) const ON_THE_FLY_WORK_CENSUS_BASIS_V1: &str = "fully-resident-query-local-trace-v1";
+
+/// Authenticated model operation addressed by one semantic executor key.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, bincode::Encode, bincode::Decode)]
+#[repr(u8)]
+pub(crate) enum OnTheFlyOperationKindV1 {
+    Source = 0,
+    Transition = 1,
+    Propagator = 2,
+    Closure = 3,
+    IdentityFinalizer = 4,
+}
+
+/// Plan-independent semantic address of one prepared Direct-Arena executor.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, bincode::Encode, bincode::Decode)]
+pub(crate) enum OnTheFlyExecutorKeyV1 {
+    PreparedOperation {
+        direct_catalog_digest: SemanticDigest,
+        role: DirectExecutorRole,
+        operation_kind: OnTheFlyOperationKindV1,
+        operation_id: u32,
+        operation_semantic_digest: SemanticDigest,
+        evaluator_binding_id: u32,
+        evaluator_binding_semantic_digest: SemanticDigest,
+    },
+    /// The prepared direct catalog authenticates this one typed synthetic
+    /// binding as a whole.  It has no recurrence-operation or evaluator row,
+    /// so no sentinel semantic digests are fabricated for it.
+    IdentityFinalizer {
+        direct_catalog_digest: SemanticDigest,
+    },
+}
+
+impl OnTheFlyExecutorKeyV1 {
+    #[allow(clippy::too_many_arguments)]
+    fn new(
+        direct_catalog_digest: SemanticDigest,
+        role: DirectExecutorRole,
+        operation_kind: OnTheFlyOperationKindV1,
+        operation_id: u32,
+        operation_semantic_digest: SemanticDigest,
+        evaluator_binding_id: u32,
+        evaluator_binding_semantic_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        let expected_role = match operation_kind {
+            OnTheFlyOperationKindV1::Source => DirectExecutorRole::Source,
+            OnTheFlyOperationKindV1::Transition => DirectExecutorRole::Contribution,
+            OnTheFlyOperationKindV1::Propagator => DirectExecutorRole::Finalization,
+            OnTheFlyOperationKindV1::Closure => DirectExecutorRole::Closure,
+            OnTheFlyOperationKindV1::IdentityFinalizer => {
+                return Err(invalid(
+                    "identity finalizer must use its typed semantic key",
+                ));
+            }
+        };
+        if role != expected_role {
+            return Err(invalid("semantic executor key has an inconsistent role"));
+        }
+        Ok(Self::PreparedOperation {
+            direct_catalog_digest,
+            role,
+            operation_kind,
+            operation_id,
+            operation_semantic_digest,
+            evaluator_binding_id,
+            evaluator_binding_semantic_digest,
+        })
+    }
+
+    pub(crate) const fn identity_finalizer(direct_catalog_digest: SemanticDigest) -> Self {
+        Self::IdentityFinalizer {
+            direct_catalog_digest,
+        }
+    }
+
+    pub(crate) const fn direct_catalog_digest(self) -> SemanticDigest {
+        match self {
+            Self::PreparedOperation {
+                direct_catalog_digest,
+                ..
+            }
+            | Self::IdentityFinalizer {
+                direct_catalog_digest,
+            } => direct_catalog_digest,
+        }
+    }
+
+    pub(crate) const fn role(self) -> DirectExecutorRole {
+        match self {
+            Self::PreparedOperation { role, .. } => role,
+            Self::IdentityFinalizer { .. } => DirectExecutorRole::Finalization,
+        }
+    }
+
+    pub(crate) const fn operation_kind(self) -> OnTheFlyOperationKindV1 {
+        match self {
+            Self::PreparedOperation { operation_kind, .. } => operation_kind,
+            Self::IdentityFinalizer { .. } => OnTheFlyOperationKindV1::IdentityFinalizer,
+        }
+    }
+
+    pub(crate) const fn operation_id(self) -> Option<u32> {
+        match self {
+            Self::PreparedOperation { operation_id, .. } => Some(operation_id),
+            Self::IdentityFinalizer { .. } => None,
+        }
+    }
+
+    pub(crate) const fn operation_semantic_digest(self) -> Option<SemanticDigest> {
+        match self {
+            Self::PreparedOperation {
+                operation_semantic_digest,
+                ..
+            } => Some(operation_semantic_digest),
+            Self::IdentityFinalizer { .. } => None,
+        }
+    }
+
+    pub(crate) const fn evaluator_binding_id(self) -> Option<u32> {
+        match self {
+            Self::PreparedOperation {
+                evaluator_binding_id,
+                ..
+            } => Some(evaluator_binding_id),
+            Self::IdentityFinalizer { .. } => None,
+        }
+    }
+
+    pub(crate) const fn evaluator_binding_semantic_digest(self) -> Option<SemanticDigest> {
+        match self {
+            Self::PreparedOperation {
+                evaluator_binding_semantic_digest,
+                ..
+            } => Some(evaluator_binding_semantic_digest),
+            Self::IdentityFinalizer { .. } => None,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) enum OnTheFlyTraceOperationV1 {
+    Source {
+        key: OnTheFlyExecutorKeyV1,
+        row: DirectSourceRow,
+    },
+    Contribution {
+        key: OnTheFlyExecutorKeyV1,
+        row: DirectContributionRow,
+    },
+    Finalization {
+        key: OnTheFlyExecutorKeyV1,
+        row: DirectFinalizationRow,
+    },
+    Closure {
+        key: OnTheFlyExecutorKeyV1,
+        row: DirectClosureRow,
+    },
+}
+
+/// Cold semantic contribution row retained only by the development feature.
+///
+/// Direct rows carry trace-local component bases and, after prepared binding,
+/// may use a physical parent permutation.  A query-family union instead needs
+/// the exact construction identity before those physical choices.  Keeping
+/// this row beside the trace lets the prototype remap parent current IDs
+/// without materializing an established recurrence program or DirectPlan.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(super) struct OnTheFlyTraceContributionProofRowV1 {
+    pub(super) result_current_id: u32,
+    pub(super) parent_current_ids: [u32; 2],
+    pub(super) key: ContributionKey,
+    pub(super) exact_factor: ExactComplexRational,
+}
+
+impl OnTheFlyTraceOperationV1 {
+    pub(super) const fn key(&self) -> OnTheFlyExecutorKeyV1 {
+        match self {
+            Self::Source { key, .. }
+            | Self::Contribution { key, .. }
+            | Self::Finalization { key, .. }
+            | Self::Closure { key, .. } => *key,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct OnTheFlyWorkspaceLayoutV1 {
+    pub(super) source_count: u32,
+    pub(super) lorentz_component_count: u16,
+    pub(super) parameter_count: u32,
+    pub(super) current_component_count: u32,
+    pub(super) amplitude_component_count: u32,
+    pub(super) momentum_form_count: u32,
+    pub(super) exact_factor_count: u32,
+}
+
+impl OnTheFlyWorkspaceLayoutV1 {
+    pub(crate) const fn source_count(self) -> u32 {
+        self.source_count
+    }
+
+    pub(crate) const fn current_component_count(self) -> u32 {
+        self.current_component_count
+    }
+
+    pub(crate) const fn amplitude_component_count(self) -> u32 {
+        self.amplitude_component_count
+    }
+
+    #[cfg(feature = "on-the-fly-test-support")]
+    pub(crate) const fn lorentz_component_count(self) -> u16 {
+        self.lorentz_component_count
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct OnTheFlyStructuralProofV1 {
+    current_count: u32,
+    contribution_count: u32,
+    closure_count: u32,
+    constructed_current_count: u32,
+    constructed_contribution_count: u32,
+    current_multiset_digest: SemanticDigest,
+    contribution_multiset_digest: SemanticDigest,
+    closure_multiset_digest: SemanticDigest,
+    owner_digest: SemanticDigest,
+    semantic_digest: SemanticDigest,
+}
+
+/// Warming-independent work represented by one selected-query trace.
+///
+/// The current arena is fully resident for the lifetime of the trace.  These
+/// current counts therefore describe allocated resident work, not a temporal
+/// liveness estimate.  Operation counts describe one execution of the trace;
+/// the probe must not multiply them by warm-up or benchmark repetitions.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg(any(test, feature = "on-the-fly-test-support"))]
+pub(crate) struct OnTheFlyExecutionWorkCensusV1 {
+    pub(crate) logical_current_count: u32,
+    pub(crate) resident_current_count: u32,
+    pub(crate) resident_current_component_count: u32,
+    pub(crate) source_operation_count: u32,
+    pub(crate) contribution_operation_count: u32,
+    pub(crate) finalization_operation_count: u32,
+    pub(crate) closure_operation_count: u32,
+    pub(crate) total_kernel_application_count: u32,
+}
+
+impl OnTheFlyStructuralProofV1 {
+    pub(crate) const fn current_count(self) -> u32 {
+        self.current_count
+    }
+
+    pub(crate) const fn contribution_count(self) -> u32 {
+        self.contribution_count
+    }
+
+    pub(crate) const fn closure_count(self) -> u32 {
+        self.closure_count
+    }
+
+    pub(crate) const fn semantic_digest(self) -> SemanticDigest {
+        self.semantic_digest
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    pub(super) const fn current_multiset_digest(self) -> SemanticDigest {
+        self.current_multiset_digest
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    pub(super) const fn contribution_multiset_digest(self) -> SemanticDigest {
+        self.contribution_multiset_digest
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    pub(super) const fn closure_multiset_digest(self) -> SemanticDigest {
+        self.closure_multiset_digest
+    }
+}
+
+/// Immutable selected-query trace.  Exact current keys remain available for
+/// development parity joins; numeric IDs are deliberately query-local.
+#[derive(Debug)]
+pub(crate) struct OnTheFlyStructuralTraceV1 {
+    pub(super) seed_digest: SemanticDigest,
+    pub(super) query_digest: SemanticDigest,
+    pub(super) current_keys: Box<[CurrentCoreKey]>,
+    pub(super) current_colors: Box<[DynamicLCColorState]>,
+    pub(super) operations: Box<[OnTheFlyTraceOperationV1]>,
+    pub(super) momentum_forms: Box<[CanonicalMomentumLinearForm]>,
+    pub(super) exact_factors: Box<[ExactComplexRational]>,
+    pub(super) pairing_owners: Box<[ResolvedPairingOwnerV1]>,
+    pub(super) layout: OnTheFlyWorkspaceLayoutV1,
+    pub(super) proof: OnTheFlyStructuralProofV1,
+    pub(super) semantic_digest: SemanticDigest,
+    prepared_executor_rows_bound: bool,
+    pub(super) current_component_ranges: Box<[[u32; 2]]>,
+    pub(super) current_semantic_digests: Box<[SemanticDigest]>,
+    pub(super) contribution_proof_rows: Box<[OnTheFlyTraceContributionProofRowV1]>,
+}
+
+impl OnTheFlyStructuralTraceV1 {
+    pub(crate) fn executor_keys(&self) -> impl Iterator<Item = OnTheFlyExecutorKeyV1> + '_ {
+        self.operations.iter().map(OnTheFlyTraceOperationV1::key)
+    }
+
+    /// Bind authenticated prepared-executor parent order into the trace rows
+    /// once, before any executor can cache descriptors for their addresses.
+    /// The semantic trace identity is unchanged: this is a private physical
+    /// executor binding, not a different selected recurrence graph.
+    pub(crate) fn bind_prepared_executor_rows(
+        &mut self,
+        parent_permutations: &BTreeMap<OnTheFlyExecutorKeyV1, [u8; 2]>,
+    ) -> RusticolResult<()> {
+        if self.prepared_executor_rows_bound {
+            return Err(integrity(
+                "prepared executor parent order is already bound into the trace",
+            ));
+        }
+
+        let mut contribution_permutations = Vec::new();
+        for (operation_index, operation) in self.operations.iter().enumerate() {
+            let key = operation.key();
+            let permutation = parent_permutations.get(&key).copied().ok_or_else(|| {
+                integrity("trace operation has no authenticated prepared parent order")
+            })?;
+            match operation {
+                OnTheFlyTraceOperationV1::Contribution { .. } => match permutation {
+                    [0, 1] | [1, 0] => {
+                        contribution_permutations.push((operation_index, permutation));
+                    }
+                    _ => {
+                        return Err(integrity(
+                            "prepared contribution executor has a non-binary parent order",
+                        ));
+                    }
+                },
+                OnTheFlyTraceOperationV1::Source { .. }
+                | OnTheFlyTraceOperationV1::Finalization { .. }
+                | OnTheFlyTraceOperationV1::Closure { .. } => {
+                    if permutation != [0, 1] {
+                        return Err(integrity(
+                            "non-contribution executor unexpectedly permutes parent rows",
+                        ));
+                    }
+                }
+            }
+        }
+
+        // The first pass made every remaining operation infallible. Mutate the
+        // existing boxed rows in place so their stable storage is preserved.
+        for (operation_index, permutation) in contribution_permutations {
+            if permutation == [0, 1] {
+                continue;
+            }
+            let Some(OnTheFlyTraceOperationV1::Contribution { row, .. }) =
+                self.operations.get_mut(operation_index)
+            else {
+                unreachable!("validated contribution operation changed during parent binding");
+            };
+            std::mem::swap(
+                &mut row.parent0_component_base,
+                &mut row.parent1_component_base_or_sentinel,
+            );
+            std::mem::swap(
+                &mut row.parent0_momentum_form_id,
+                &mut row.parent1_momentum_form_id_or_sentinel,
+            );
+        }
+        self.prepared_executor_rows_bound = true;
+        Ok(())
+    }
+
+    pub(crate) const fn prepared_executor_rows_bound(&self) -> bool {
+        self.prepared_executor_rows_bound
+    }
+
+    pub(crate) const fn proof(&self) -> OnTheFlyStructuralProofV1 {
+        self.proof
+    }
+
+    pub(crate) const fn seed_digest(&self) -> SemanticDigest {
+        self.seed_digest
+    }
+
+    pub(crate) fn current_keys(&self) -> &[CurrentCoreKey] {
+        &self.current_keys
+    }
+
+    pub(crate) const fn layout(&self) -> OnTheFlyWorkspaceLayoutV1 {
+        self.layout
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    pub(crate) fn execution_work_census(&self) -> RusticolResult<OnTheFlyExecutionWorkCensusV1> {
+        let mut source_operation_count = 0_u32;
+        let mut contribution_operation_count = 0_u32;
+        let mut finalization_operation_count = 0_u32;
+        let mut closure_operation_count = 0_u32;
+        for operation in &self.operations {
+            let count = match operation.key().role() {
+                DirectExecutorRole::Source => &mut source_operation_count,
+                DirectExecutorRole::Contribution => &mut contribution_operation_count,
+                DirectExecutorRole::Finalization => &mut finalization_operation_count,
+                DirectExecutorRole::Closure => &mut closure_operation_count,
+            };
+            *count = count
+                .checked_add(1)
+                .ok_or_else(|| invalid("execution operation count overflows u32"))?;
+        }
+        let total_kernel_application_count = checked_u32(
+            self.operations.len(),
+            "selected-query kernel application count",
+        )?;
+        let counted = source_operation_count
+            .checked_add(contribution_operation_count)
+            .and_then(|value| value.checked_add(finalization_operation_count))
+            .and_then(|value| value.checked_add(closure_operation_count))
+            .ok_or_else(|| invalid("execution operation total overflows u32"))?;
+        if counted != total_kernel_application_count {
+            return Err(integrity(
+                "execution operation census does not cover the selected-query trace",
+            ));
+        }
+        let logical_current_count = self.proof.current_count();
+        Ok(OnTheFlyExecutionWorkCensusV1 {
+            logical_current_count,
+            resident_current_count: logical_current_count,
+            resident_current_component_count: self.layout.current_component_count(),
+            source_operation_count,
+            contribution_operation_count,
+            finalization_operation_count,
+            closure_operation_count,
+            total_kernel_application_count,
+        })
+    }
+
+    pub(crate) fn momentum_forms(&self) -> &[CanonicalMomentumLinearForm] {
+        &self.momentum_forms
+    }
+
+    pub(crate) fn exact_factors(&self) -> &[ExactComplexRational] {
+        &self.exact_factors
+    }
+
+    pub(crate) const fn semantic_digest(&self) -> SemanticDigest {
+        self.semantic_digest
+    }
+
+    #[cfg(feature = "on-the-fly-test-support")]
+    pub(crate) fn tamper_first_prepared_executor_key_for_probe(&mut self) -> RusticolResult<()> {
+        let replacement = SemanticDigest::new([0xa5; 32])?;
+        for operation in self.operations.iter_mut() {
+            let key = operation.key();
+            let OnTheFlyExecutorKeyV1::PreparedOperation {
+                direct_catalog_digest,
+                role,
+                operation_kind,
+                operation_id,
+                operation_semantic_digest,
+                evaluator_binding_id,
+                evaluator_binding_semantic_digest,
+            } = key
+            else {
+                continue;
+            };
+            let replacement = if replacement != operation_semantic_digest {
+                replacement
+            } else {
+                SemanticDigest::new([0x5a; 32])?
+            };
+            let tampered = OnTheFlyExecutorKeyV1::PreparedOperation {
+                direct_catalog_digest,
+                role,
+                operation_kind,
+                operation_id,
+                operation_semantic_digest: replacement,
+                evaluator_binding_id,
+                evaluator_binding_semantic_digest,
+            };
+            match operation {
+                OnTheFlyTraceOperationV1::Source { key, .. }
+                | OnTheFlyTraceOperationV1::Contribution { key, .. }
+                | OnTheFlyTraceOperationV1::Finalization { key, .. }
+                | OnTheFlyTraceOperationV1::Closure { key, .. } => *key = tampered,
+            }
+            return Ok(());
+        }
+        Err(integrity(
+            "selected trace has no prepared executor key to tamper",
+        ))
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    pub(crate) fn current_component_range(&self, current_id: u32) -> RusticolResult<[u32; 2]> {
+        self.current_component_ranges
+            .get(current_id as usize)
+            .copied()
+            .ok_or_else(|| invalid("observed current ID is outside the trace"))
+    }
+
+    #[cfg(any(test, feature = "on-the-fly-test-support"))]
+    pub(crate) fn current_semantic_digest(
+        &self,
+        current_id: u32,
+    ) -> RusticolResult<SemanticDigest> {
+        self.current_semantic_digests
+            .get(current_id as usize)
+            .copied()
+            .ok_or_else(|| invalid("observed current ID is outside the trace"))
+    }
+}
+
+/// Join one query-local operation key to the exact authenticated recurrence
+/// row and prepared direct-template binding that implements it.  No global
+/// operation map or direct recurrence plan participates in the address.
+pub(crate) fn authenticated_prepared_executor_binding<'a>(
+    templates: &'a ValidatedRecurrenceTemplateInput,
+    direct: &'a PreparedDirectExecutorCatalog,
+) -> RusticolResult<
+    impl Fn(OnTheFlyExecutorKeyV1) -> RusticolResult<PreparedDirectExecutorBinding> + 'a,
+> {
+    let direct_digest = direct.direct_template_catalog_digest();
+    Ok(move |key: OnTheFlyExecutorKeyV1| {
+        if key.direct_catalog_digest() != direct_digest {
+            return Err(integrity(
+                "operation key belongs to a different direct-template catalog",
+            ));
+        }
+        if matches!(key, OnTheFlyExecutorKeyV1::IdentityFinalizer { .. }) {
+            return Ok(PreparedDirectExecutorBinding::identity_finalizer(
+                direct.resolve_identity_finalizer()?,
+            ));
+        }
+        let operation_id = key
+            .operation_id()
+            .ok_or_else(|| integrity("prepared operation key has no operation ID"))?;
+        let (row_id, semantic_digest_id, evaluator_binding_id, expected_role, label) =
+            match key.operation_kind() {
+                OnTheFlyOperationKindV1::Source => {
+                    let row = templates
+                        .input()
+                        .sources
+                        .get(operation_id as usize)
+                        .ok_or_else(|| integrity("source operation row is absent"))?;
+                    (
+                        row.id,
+                        row.semantic_digest_id,
+                        row.evaluator_binding_id,
+                        DirectExecutorRole::Source,
+                        "source",
+                    )
+                }
+                OnTheFlyOperationKindV1::Transition => {
+                    let row = templates
+                        .input()
+                        .transitions
+                        .get(operation_id as usize)
+                        .ok_or_else(|| integrity("transition operation row is absent"))?;
+                    (
+                        row.id,
+                        row.semantic_digest_id,
+                        row.evaluator_binding_id,
+                        DirectExecutorRole::Contribution,
+                        "transition",
+                    )
+                }
+                OnTheFlyOperationKindV1::Propagator => {
+                    let row = templates
+                        .input()
+                        .propagators
+                        .get(operation_id as usize)
+                        .ok_or_else(|| integrity("propagator operation row is absent"))?;
+                    (
+                        row.id,
+                        row.semantic_digest_id,
+                        row.evaluator_binding_id,
+                        DirectExecutorRole::Finalization,
+                        "propagator",
+                    )
+                }
+                OnTheFlyOperationKindV1::Closure => {
+                    let row = templates
+                        .input()
+                        .closures
+                        .get(operation_id as usize)
+                        .ok_or_else(|| integrity("closure operation row is absent"))?;
+                    (
+                        row.id,
+                        row.semantic_digest_id,
+                        row.evaluator_binding_id,
+                        DirectExecutorRole::Closure,
+                        "closure",
+                    )
+                }
+                OnTheFlyOperationKindV1::IdentityFinalizer => {
+                    return Err(integrity(
+                        "identity finalizer is not a prepared-operation key",
+                    ));
+                }
+            };
+        if row_id != operation_id || key.role() != expected_role {
+            return Err(integrity(format!(
+                "{label} operation catalog or executor role is not canonical"
+            )));
+        }
+        let evaluator = templates
+            .input()
+            .evaluator_bindings
+            .get(evaluator_binding_id as usize)
+            .ok_or_else(|| integrity(format!("{label} evaluator binding is absent")))?;
+        if evaluator.id != evaluator_binding_id
+            || key.operation_semantic_digest()
+                != Some(authenticated_digest_row(
+                    templates,
+                    semantic_digest_id,
+                    &format!("{label} semantic"),
+                )?)
+            || key.evaluator_binding_id() != Some(evaluator.id)
+            || key.evaluator_binding_semantic_digest()
+                != Some(authenticated_digest_row(
+                    templates,
+                    evaluator.semantic_digest_id,
+                    &format!("{label} evaluator semantic"),
+                )?)
+        {
+            return Err(integrity(format!(
+                "{label} operation key disagrees with authenticated template semantics"
+            )));
+        }
+        let binding = match expected_role {
+            DirectExecutorRole::Contribution => {
+                let (executor_id, parent_permutation) =
+                    direct.resolve_contribution(evaluator.id)?;
+                PreparedDirectExecutorBinding::evaluator_with_parent_permutation(
+                    expected_role,
+                    evaluator.id,
+                    executor_id,
+                    parent_permutation,
+                )
+            }
+            role => PreparedDirectExecutorBinding::evaluator(
+                role,
+                evaluator.id,
+                direct.resolve_evaluator(role, evaluator.id)?,
+            ),
+        };
+        Ok(binding)
+    })
+}
+
+fn authenticated_digest_row(
+    templates: &ValidatedRecurrenceTemplateInput,
+    digest_id: u32,
+    label: &str,
+) -> RusticolResult<SemanticDigest> {
+    let row = templates
+        .input()
+        .digest_catalog
+        .get(digest_id as usize)
+        .ok_or_else(|| integrity(format!("{label} digest is absent")))?;
+    if row.id != digest_id {
+        return Err(integrity(format!(
+            "{label} digest catalog is not canonical"
+        )));
+    }
+    SemanticDigest::new(row.value)
+        .map_err(|error| integrity(format!("{label} digest is invalid: {error}")))
+}
+
+#[cfg(test)]
+pub(crate) fn scalar_adapter_test_trace(
+    templates: &ValidatedRecurrenceTemplateInput,
+    seed: &OnTheFlyProcessSeedV1,
+) -> RusticolResult<OnTheFlyStructuralTraceV1> {
+    let source = templates
+        .input()
+        .sources
+        .first()
+        .ok_or_else(|| integrity("scalar adapter fixture has no source"))?;
+    let source_evaluator = templates
+        .input()
+        .evaluator_bindings
+        .get(source.evaluator_binding_id as usize)
+        .ok_or_else(|| integrity("scalar adapter source evaluator is absent"))?;
+    let source_key = OnTheFlyExecutorKeyV1::new(
+        seed.direct_catalog_digest(),
+        DirectExecutorRole::Source,
+        OnTheFlyOperationKindV1::Source,
+        source.id,
+        authenticated_digest_row(templates, source.semantic_digest_id, "source semantic")?,
+        source_evaluator.id,
+        authenticated_digest_row(
+            templates,
+            source_evaluator.semantic_digest_id,
+            "source evaluator semantic",
+        )?,
+    )?;
+    let closure = templates
+        .input()
+        .closures
+        .first()
+        .ok_or_else(|| integrity("scalar adapter fixture has no closure"))?;
+    let closure_evaluator = templates
+        .input()
+        .evaluator_bindings
+        .get(closure.evaluator_binding_id as usize)
+        .ok_or_else(|| integrity("scalar adapter closure evaluator is absent"))?;
+    let closure_key = OnTheFlyExecutorKeyV1::new(
+        seed.direct_catalog_digest(),
+        DirectExecutorRole::Closure,
+        OnTheFlyOperationKindV1::Closure,
+        closure.id,
+        authenticated_digest_row(templates, closure.semantic_digest_id, "closure semantic")?,
+        closure_evaluator.id,
+        authenticated_digest_row(
+            templates,
+            closure_evaluator.semantic_digest_id,
+            "closure evaluator semantic",
+        )?,
+    )?;
+    let momentum_forms = (0..2)
+        .map(|source_slot| {
+            CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                source_slot,
+                coefficient: 1,
+            }])
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let test_digest = SemanticDigest::new([93; 32])?;
+    Ok(OnTheFlyStructuralTraceV1 {
+        seed_digest: seed.semantic_digest(),
+        query_digest: SemanticDigest::new([94; 32])?,
+        current_keys: Vec::new().into_boxed_slice(),
+        current_colors: Vec::new().into_boxed_slice(),
+        operations: vec![
+            OnTheFlyTraceOperationV1::Source {
+                key: source_key,
+                row: DirectSourceRow {
+                    source_slot: 0,
+                    destination_component_base: 0,
+                    momentum_form_id: 0,
+                    source_template_or_dispatch_domain: 0,
+                    spin_state_class: 50_000,
+                    exact_factor_id: 0,
+                    selector_domain_id: 0,
+                },
+            },
+            OnTheFlyTraceOperationV1::Source {
+                key: source_key,
+                row: DirectSourceRow {
+                    source_slot: 1,
+                    destination_component_base: 1,
+                    momentum_form_id: 1,
+                    source_template_or_dispatch_domain: 0,
+                    spin_state_class: 50_000,
+                    exact_factor_id: 0,
+                    selector_domain_id: 0,
+                },
+            },
+            OnTheFlyTraceOperationV1::Closure {
+                key: closure_key,
+                row: DirectClosureRow {
+                    parent0_component_base: 0,
+                    parent1_component_base_or_sentinel: 1,
+                    parent0_momentum_form_id: 0,
+                    parent1_momentum_form_id_or_sentinel: 1,
+                    amplitude_destination_id: 0,
+                    exact_factor_id: 0,
+                    component_factor_start: 1,
+                    component_count: 1,
+                    selector_domain_id: 0,
+                    flags: 0,
+                },
+            },
+        ]
+        .into_boxed_slice(),
+        momentum_forms: momentum_forms.into_boxed_slice(),
+        exact_factors: vec![
+            ExactComplexRational::ONE,
+            ExactComplexRational::ONE,
+            ExactComplexRational::new(
+                crate::recurrence::ExactRational::new(2, 1)?,
+                crate::recurrence::ExactRational::ZERO,
+            ),
+        ]
+        .into_boxed_slice(),
+        pairing_owners: vec![ResolvedPairingOwnerV1 {
+            endpoint_pairs: Vec::new(),
+            proof_digest: None,
+            source_slot_permutation: vec![0, 1],
+            source_lineage: vec![0, 1],
+            fermion_parity: 1,
+        }]
+        .into_boxed_slice(),
+        layout: OnTheFlyWorkspaceLayoutV1 {
+            source_count: 2,
+            lorentz_component_count: 4,
+            parameter_count: 0,
+            current_component_count: 2,
+            amplitude_component_count: 1,
+            momentum_form_count: 2,
+            exact_factor_count: 3,
+        },
+        proof: OnTheFlyStructuralProofV1 {
+            current_count: 2,
+            contribution_count: 0,
+            closure_count: 1,
+            constructed_current_count: 2,
+            constructed_contribution_count: 0,
+            current_multiset_digest: test_digest,
+            contribution_multiset_digest: test_digest,
+            closure_multiset_digest: test_digest,
+            owner_digest: test_digest,
+            semantic_digest: test_digest,
+        },
+        semantic_digest: test_digest,
+        prepared_executor_rows_bound: false,
+        current_component_ranges: vec![[0, 1], [1, 1]].into_boxed_slice(),
+        current_semantic_digests: vec![test_digest; 2].into_boxed_slice(),
+        contribution_proof_rows: Box::new([]),
+    })
+}
+
+#[cfg(test)]
+impl OnTheFlyStructuralTraceV1 {
+    pub(crate) fn test_two_contribution_rows()
+    -> (Self, OnTheFlyExecutorKeyV1, OnTheFlyExecutorKeyV1) {
+        let test_digest = SemanticDigest::new([0x5a; 32]).unwrap();
+        let direct_digest = SemanticDigest::new([0x61; 32]).unwrap();
+        let source_key = OnTheFlyExecutorKeyV1::new(
+            direct_digest,
+            DirectExecutorRole::Source,
+            OnTheFlyOperationKindV1::Source,
+            0,
+            SemanticDigest::new([0x62; 32]).unwrap(),
+            0,
+            SemanticDigest::new([0x63; 32]).unwrap(),
+        )
+        .unwrap();
+        let contribution_key = OnTheFlyExecutorKeyV1::new(
+            direct_digest,
+            DirectExecutorRole::Contribution,
+            OnTheFlyOperationKindV1::Transition,
+            1,
+            SemanticDigest::new([0x64; 32]).unwrap(),
+            1,
+            SemanticDigest::new([0x65; 32]).unwrap(),
+        )
+        .unwrap();
+        let momentum_forms = (0..4)
+            .map(|source_slot| {
+                CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                    source_slot,
+                    coefficient: 1,
+                }])
+                .unwrap()
+            })
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+        let trace = Self {
+            seed_digest: SemanticDigest::new([0x51; 32]).unwrap(),
+            query_digest: SemanticDigest::new([0x52; 32]).unwrap(),
+            current_keys: Box::new([]),
+            current_colors: Box::new([]),
+            operations: vec![
+                OnTheFlyTraceOperationV1::Source {
+                    key: source_key,
+                    row: DirectSourceRow {
+                        source_slot: 0,
+                        destination_component_base: 1,
+                        momentum_form_id: 1,
+                        source_template_or_dispatch_domain: 0,
+                        spin_state_class: 50_000,
+                        exact_factor_id: 0,
+                        selector_domain_id: 0,
+                    },
+                },
+                OnTheFlyTraceOperationV1::Source {
+                    key: source_key,
+                    row: DirectSourceRow {
+                        source_slot: 1,
+                        destination_component_base: 3,
+                        momentum_form_id: 3,
+                        source_template_or_dispatch_domain: 0,
+                        spin_state_class: 50_000,
+                        exact_factor_id: 0,
+                        selector_domain_id: 0,
+                    },
+                },
+                OnTheFlyTraceOperationV1::Contribution {
+                    key: contribution_key,
+                    row: DirectContributionRow {
+                        parent0_component_base: 0,
+                        parent1_component_base_or_sentinel: 1,
+                        parent0_momentum_form_id: 0,
+                        parent1_momentum_form_id_or_sentinel: 1,
+                        destination_component_base: 2,
+                        exact_factor_id: 0,
+                        selector_domain_id: 0,
+                        flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+                    },
+                },
+                OnTheFlyTraceOperationV1::Contribution {
+                    key: contribution_key,
+                    row: DirectContributionRow {
+                        parent0_component_base: 0,
+                        parent1_component_base_or_sentinel: 3,
+                        parent0_momentum_form_id: 0,
+                        parent1_momentum_form_id_or_sentinel: 3,
+                        destination_component_base: 4,
+                        exact_factor_id: 0,
+                        selector_domain_id: 0,
+                        flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+                    },
+                },
+            ]
+            .into_boxed_slice(),
+            momentum_forms,
+            exact_factors: vec![ExactComplexRational::ONE].into_boxed_slice(),
+            pairing_owners: Box::new([]),
+            layout: OnTheFlyWorkspaceLayoutV1 {
+                source_count: 4,
+                lorentz_component_count: 4,
+                parameter_count: 0,
+                current_component_count: 5,
+                amplitude_component_count: 1,
+                momentum_form_count: 4,
+                exact_factor_count: 1,
+            },
+            proof: OnTheFlyStructuralProofV1 {
+                current_count: 5,
+                contribution_count: 2,
+                closure_count: 0,
+                constructed_current_count: 5,
+                constructed_contribution_count: 2,
+                current_multiset_digest: test_digest,
+                contribution_multiset_digest: test_digest,
+                closure_multiset_digest: test_digest,
+                owner_digest: test_digest,
+                semantic_digest: test_digest,
+            },
+            semantic_digest: test_digest,
+            prepared_executor_rows_bound: false,
+            current_component_ranges: (0..5)
+                .map(|base| [base, 1])
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            current_semantic_digests: vec![test_digest; 5].into_boxed_slice(),
+            contribution_proof_rows: Box::new([]),
+        };
+        (trace, source_key, contribution_key)
+    }
+
+    pub(crate) fn test_bound_contribution_rows(&self) -> Vec<DirectContributionRow> {
+        self.operations
+            .iter()
+            .filter_map(|operation| match operation {
+                OnTheFlyTraceOperationV1::Contribution { row, .. } => Some(*row),
+                _ => None,
+            })
+            .collect()
+    }
+
+    pub(crate) fn test_query_family_trace(
+        query_digest_byte: u8,
+        contribution_factor: ExactComplexRational,
+    ) -> (Self, OnTheFlyProjectionProbeV1) {
+        let digest = |byte| SemanticDigest::new([byte; 32]).unwrap();
+        let direct_digest = digest(0x71);
+        let color_id = crate::recurrence::DynamicLCColorStateId::from_interner(0);
+        let momentum = |slots: &[u32]| {
+            CanonicalMomentumLinearForm::new(
+                slots
+                    .iter()
+                    .copied()
+                    .map(|source_slot| MomentumTerm {
+                        source_slot,
+                        coefficient: 1,
+                    })
+                    .collect(),
+            )
+            .unwrap()
+        };
+        let helicity = |slots: &[u32]| {
+            CurrentHelicityIdentity::topology_replay(
+                0,
+                slots
+                    .iter()
+                    .copied()
+                    .map(|source_slot| SourceStateAssignment::new(source_slot, 0))
+                    .collect(),
+            )
+            .unwrap()
+        };
+        let current_key = |node_kind, state, support: &[u32], source_binding| {
+            CurrentCoreKey::new(
+                digest(0x72),
+                node_kind,
+                state,
+                color_id,
+                support.to_vec(),
+                momentum(support),
+                helicity(support),
+                vec![state as i32],
+                0,
+                vec![0],
+                source_binding,
+                (node_kind == RecurrenceNodeKind::Current).then_some(0),
+            )
+            .unwrap()
+        };
+        let current_keys = vec![
+            current_key(
+                RecurrenceNodeKind::Source,
+                0,
+                &[0],
+                CurrentSourceBinding::FixedTemplate(0),
+            ),
+            current_key(
+                RecurrenceNodeKind::Source,
+                1,
+                &[1],
+                CurrentSourceBinding::FixedTemplate(1),
+            ),
+            current_key(
+                RecurrenceNodeKind::Current,
+                2,
+                &[0, 1],
+                CurrentSourceBinding::None,
+            ),
+        ];
+        let source_key = |id| {
+            OnTheFlyExecutorKeyV1::new(
+                direct_digest,
+                DirectExecutorRole::Source,
+                OnTheFlyOperationKindV1::Source,
+                id,
+                digest(0x73 + id as u8),
+                id,
+                digest(0x75 + id as u8),
+            )
+            .unwrap()
+        };
+        let contribution_executor = OnTheFlyExecutorKeyV1::new(
+            direct_digest,
+            DirectExecutorRole::Contribution,
+            OnTheFlyOperationKindV1::Transition,
+            2,
+            digest(0x77),
+            2,
+            digest(0x78),
+        )
+        .unwrap();
+        let finalization_executor = OnTheFlyExecutorKeyV1::new(
+            direct_digest,
+            DirectExecutorRole::Finalization,
+            OnTheFlyOperationKindV1::Propagator,
+            0,
+            digest(0x79),
+            3,
+            digest(0x7a),
+        )
+        .unwrap();
+        let closure_executor = OnTheFlyExecutorKeyV1::new(
+            direct_digest,
+            DirectExecutorRole::Closure,
+            OnTheFlyOperationKindV1::Closure,
+            0,
+            digest(0x7b),
+            4,
+            digest(0x7c),
+        )
+        .unwrap();
+        let contribution_key = ContributionKey::new(
+            2,
+            vec![0, 1],
+            vec![0, 1],
+            vec![momentum(&[0]), momentum(&[1])],
+            2,
+            0,
+            LCColorWitnessTermId::new(0, 0),
+            digest(0x7d),
+            0,
+        )
+        .unwrap();
+        let color = DynamicLCColorState::new(0, None, vec![]).unwrap();
+        let test_digest = digest(0x7e);
+        let current_semantic_digests = current_keys
+            .iter()
+            .map(|key| hash_current_key(key, &color).unwrap())
+            .collect::<Vec<_>>();
+        let trace = Self {
+            seed_digest: digest(0x70),
+            query_digest: digest(query_digest_byte),
+            current_keys: current_keys.into_boxed_slice(),
+            current_colors: vec![color; 3].into_boxed_slice(),
+            operations: vec![
+                OnTheFlyTraceOperationV1::Source {
+                    key: source_key(0),
+                    row: DirectSourceRow {
+                        source_slot: 0,
+                        destination_component_base: 0,
+                        momentum_form_id: 0,
+                        source_template_or_dispatch_domain: 0,
+                        spin_state_class: 0,
+                        exact_factor_id: 0,
+                        selector_domain_id: 0,
+                    },
+                },
+                OnTheFlyTraceOperationV1::Source {
+                    key: source_key(1),
+                    row: DirectSourceRow {
+                        source_slot: 1,
+                        destination_component_base: 1,
+                        momentum_form_id: 1,
+                        source_template_or_dispatch_domain: 1,
+                        spin_state_class: 0,
+                        exact_factor_id: 0,
+                        selector_domain_id: 0,
+                    },
+                },
+                OnTheFlyTraceOperationV1::Contribution {
+                    key: contribution_executor,
+                    row: DirectContributionRow {
+                        parent0_component_base: 0,
+                        parent1_component_base_or_sentinel: 1,
+                        parent0_momentum_form_id: 0,
+                        parent1_momentum_form_id_or_sentinel: 1,
+                        destination_component_base: 2,
+                        exact_factor_id: 1,
+                        selector_domain_id: 0,
+                        flags: DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION,
+                    },
+                },
+                OnTheFlyTraceOperationV1::Finalization {
+                    key: finalization_executor,
+                    row: DirectFinalizationRow {
+                        component_base: 2,
+                        component_count: 1,
+                        momentum_form_id: 2,
+                        exact_factor_id: 0,
+                        selector_domain_id: 0,
+                        flags: 0,
+                    },
+                },
+                OnTheFlyTraceOperationV1::Closure {
+                    key: closure_executor,
+                    row: DirectClosureRow {
+                        parent0_component_base: 0,
+                        parent1_component_base_or_sentinel: 2,
+                        parent0_momentum_form_id: 0,
+                        parent1_momentum_form_id_or_sentinel: 2,
+                        amplitude_destination_id: 0,
+                        exact_factor_id: 0,
+                        component_factor_start: 2,
+                        component_count: 1,
+                        selector_domain_id: 0,
+                        flags: 0,
+                    },
+                },
+            ]
+            .into_boxed_slice(),
+            momentum_forms: vec![momentum(&[0]), momentum(&[1]), momentum(&[0, 1])]
+                .into_boxed_slice(),
+            exact_factors: vec![
+                ExactComplexRational::ONE,
+                contribution_factor,
+                ExactComplexRational::ONE,
+            ]
+            .into_boxed_slice(),
+            pairing_owners: vec![ResolvedPairingOwnerV1 {
+                endpoint_pairs: Vec::new(),
+                proof_digest: None,
+                source_slot_permutation: vec![0, 1],
+                source_lineage: vec![0, 1],
+                fermion_parity: 1,
+            }]
+            .into_boxed_slice(),
+            layout: OnTheFlyWorkspaceLayoutV1 {
+                source_count: 2,
+                lorentz_component_count: 4,
+                parameter_count: 0,
+                current_component_count: 3,
+                amplitude_component_count: 1,
+                momentum_form_count: 3,
+                exact_factor_count: 3,
+            },
+            proof: OnTheFlyStructuralProofV1 {
+                current_count: 3,
+                contribution_count: 1,
+                closure_count: 1,
+                constructed_current_count: 3,
+                constructed_contribution_count: 1,
+                current_multiset_digest: test_digest,
+                contribution_multiset_digest: test_digest,
+                closure_multiset_digest: test_digest,
+                owner_digest: test_digest,
+                semantic_digest: test_digest,
+            },
+            semantic_digest: test_digest,
+            prepared_executor_rows_bound: true,
+            current_component_ranges: vec![[0, 1], [1, 1], [2, 1]].into_boxed_slice(),
+            current_semantic_digests: current_semantic_digests.into_boxed_slice(),
+            contribution_proof_rows: vec![OnTheFlyTraceContributionProofRowV1 {
+                result_current_id: 2,
+                parent_current_ids: [0, 1],
+                key: contribution_key,
+                exact_factor: contribution_factor,
+            }]
+            .into_boxed_slice(),
+        };
+        (
+            trace,
+            OnTheFlyProjectionProbeV1 {
+                enabled: true,
+                applied: false,
+                pre: [3, 1, 1],
+                post: [3, 1, 1],
+            },
+        )
+    }
+
+    pub(crate) fn test_remap_dynamic_color_id(&mut self, id: u32) {
+        let color_id = crate::recurrence::DynamicLCColorStateId::from_interner(id);
+        for ((key, color), digest) in self
+            .current_keys
+            .iter_mut()
+            .zip(self.current_colors.iter())
+            .zip(self.current_semantic_digests.iter_mut())
+        {
+            *key = crate::recurrence::construct::current_key_with_dynamic_color(key, color_id)
+                .unwrap();
+            *digest = hash_current_key(key, color).unwrap();
+        }
+    }
+
+    pub(crate) fn test_add_query_family_contribution(
+        &mut self,
+        operation_id: u32,
+        evaluator_binding_id: u32,
+        exact_factor: ExactComplexRational,
+    ) {
+        let digest = |byte| SemanticDigest::new([byte; 32]).unwrap();
+        let existing = self.contribution_proof_rows[0].clone();
+        let executor = OnTheFlyExecutorKeyV1::new(
+            self.executor_keys().next().unwrap().direct_catalog_digest(),
+            DirectExecutorRole::Contribution,
+            OnTheFlyOperationKindV1::Transition,
+            operation_id,
+            digest(0x90_u8.wrapping_add(operation_id as u8)),
+            evaluator_binding_id,
+            digest(0xa0_u8.wrapping_add(evaluator_binding_id as u8)),
+        )
+        .unwrap();
+        let proof_key = ContributionKey::new(
+            operation_id,
+            existing.key.parent_value_class_ids().to_vec(),
+            existing.key.parent_state_template_ids().to_vec(),
+            existing.key.parent_momenta().to_vec(),
+            existing.key.result_state_template_id(),
+            existing.key.quantum_flow_witness_id(),
+            existing.key.color_witness_term_id(),
+            digest(0xb0_u8.wrapping_add(evaluator_binding_id as u8)),
+            existing.key.output_projection_id(),
+        )
+        .unwrap();
+        let mut factors = std::mem::take(&mut self.exact_factors).into_vec();
+        let exact_factor_id = factors.len() as u32;
+        factors.push(exact_factor);
+        self.exact_factors = factors.into_boxed_slice();
+        self.layout.exact_factor_count += 1;
+        let mut operations = std::mem::take(&mut self.operations).into_vec();
+        let insertion = operations
+            .iter()
+            .position(|operation| {
+                matches!(operation, OnTheFlyTraceOperationV1::Finalization { .. })
+            })
+            .unwrap();
+        operations.insert(
+            insertion,
+            OnTheFlyTraceOperationV1::Contribution {
+                key: executor,
+                row: DirectContributionRow {
+                    parent0_component_base: 0,
+                    parent1_component_base_or_sentinel: 1,
+                    parent0_momentum_form_id: 0,
+                    parent1_momentum_form_id_or_sentinel: 1,
+                    destination_component_base: 2,
+                    exact_factor_id,
+                    selector_domain_id: 0,
+                    flags: 0,
+                },
+            },
+        );
+        self.operations = operations.into_boxed_slice();
+        let mut proofs = std::mem::take(&mut self.contribution_proof_rows).into_vec();
+        proofs.push(OnTheFlyTraceContributionProofRowV1 {
+            result_current_id: 2,
+            parent_current_ids: [0, 1],
+            key: proof_key,
+            exact_factor,
+        });
+        self.contribution_proof_rows = proofs.into_boxed_slice();
+        self.proof.contribution_count += 1;
+        self.proof.constructed_contribution_count += 1;
+        let replacement = digest(0xc0_u8.wrapping_add(evaluator_binding_id as u8));
+        self.semantic_digest = replacement;
+        self.proof.semantic_digest = replacement;
+    }
+
+    pub(crate) fn test_set_last_contribution_selector_domain(&mut self, selector_domain_id: u32) {
+        let row = self
+            .operations
+            .iter_mut()
+            .rev()
+            .find_map(|operation| match operation {
+                OnTheFlyTraceOperationV1::Contribution { row, .. } => Some(row),
+                _ => None,
+            })
+            .expect("test trace has no contribution row");
+        row.selector_domain_id = selector_domain_id;
+        let replacement = SemanticDigest::new([0xd1; 32]).unwrap();
+        self.semantic_digest = replacement;
+        self.proof.semantic_digest = replacement;
+    }
+
+    pub(crate) fn test_insert_identity_finalizer(&mut self, direct_catalog_digest: SemanticDigest) {
+        let operation = OnTheFlyTraceOperationV1::Finalization {
+            key: OnTheFlyExecutorKeyV1::identity_finalizer(direct_catalog_digest),
+            row: DirectFinalizationRow {
+                component_base: 0,
+                component_count: 1,
+                momentum_form_id: 0,
+                exact_factor_id: 2,
+                selector_domain_id: 0,
+                flags: 0,
+            },
+        };
+        let mut operations = std::mem::take(&mut self.operations).into_vec();
+        operations.insert(2, operation);
+        self.operations = operations.into_boxed_slice();
+    }
+
+    pub(crate) fn test_tamper_first_operation_semantic_digest(&mut self, digest: SemanticDigest) {
+        if let Some(OnTheFlyTraceOperationV1::Source {
+            key:
+                OnTheFlyExecutorKeyV1::PreparedOperation {
+                    operation_semantic_digest,
+                    ..
+                },
+            ..
+        }) = self.operations.first_mut()
+        {
+            *operation_semantic_digest = digest;
+        }
+    }
+}
+
+pub(crate) fn hash_current_key(
+    key: &CurrentCoreKey,
+    color: &DynamicLCColorState,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-on-the-fly-current-key-v1\0");
+    hash_digest(&mut hash, key.catalog_digest());
+    hash.update([match key.node_kind() {
+        RecurrenceNodeKind::Source => 0,
+        RecurrenceNodeKind::Current => 1,
+    }]);
+    hash.update(key.current_state_template_id().to_le_bytes());
+    hash_len(
+        &mut hash,
+        key.support_source_slots().len(),
+        "current support",
+    )?;
+    for slot in key.support_source_slots() {
+        hash.update(slot.to_le_bytes());
+    }
+    hash_len(&mut hash, key.momentum().terms().len(), "current momentum")?;
+    for term in key.momentum().terms() {
+        hash.update(term.source_slot.to_le_bytes());
+        hash.update(term.coefficient.to_le_bytes());
+    }
+    hash.update(key.spin_state_class().to_le_bytes());
+    hash_len(
+        &mut hash,
+        key.helicity_identity().local_source_states().len(),
+        "current source ancestry",
+    )?;
+    for assignment in key.helicity_identity().local_source_states() {
+        hash.update(assignment.source_slot().to_le_bytes());
+        hash.update(assignment.state_index().to_le_bytes());
+    }
+    hash_len(
+        &mut hash,
+        key.flavour_flow().len(),
+        "current flavour ancestry",
+    )?;
+    for value in key.flavour_flow() {
+        hash.update(value.to_le_bytes());
+    }
+    hash.update(key.quantum_number_flow_id().to_le_bytes());
+    hash_len(
+        &mut hash,
+        key.coupling_orders().len(),
+        "current coupling orders",
+    )?;
+    for value in key.coupling_orders() {
+        hash.update(value.to_le_bytes());
+    }
+    match key.source_binding() {
+        CurrentSourceBinding::None => hash.update([0]),
+        CurrentSourceBinding::FixedTemplate(id) => {
+            hash.update([1]);
+            hash.update(id.to_le_bytes());
+        }
+        CurrentSourceBinding::RuntimeDispatch { .. } => {
+            return Err(integrity(
+                "selected on-the-fly current unexpectedly uses runtime source dispatch",
+            ));
+        }
+    }
+    hash.update(
+        key.propagator_template_id()
+            .unwrap_or(MISSING_U32)
+            .to_le_bytes(),
+    );
+    hash.update(color.output_color_shape_id().to_le_bytes());
+    hash_len(
+        &mut hash,
+        color.components().len(),
+        "current color components",
+    )?;
+    for component in color.components() {
+        hash.update([component.kind() as u8]);
+        hash_len(&mut hash, component.source_slots().len(), "color component")?;
+        for slot in component.source_slots() {
+            hash.update(slot.to_le_bytes());
+        }
+    }
+    hash_len(
+        &mut hash,
+        color.result_port_bindings().len(),
+        "current color ports",
+    )?;
+    for binding in color.result_port_bindings() {
+        hash.update(binding.component_index().to_le_bytes());
+        hash.update([binding.endpoint() as u8]);
+    }
+    final_digest(hash)
+}
+
+pub(super) fn multiset_digest(
+    domain: &[u8],
+    mut rows: Vec<SemanticDigest>,
+) -> RusticolResult<SemanticDigest> {
+    rows.sort_unstable();
+    let mut hash = Sha256::new();
+    hash.update(domain);
+    hash_len(&mut hash, rows.len(), "proof rows")?;
+    for row in rows {
+        hash_digest(&mut hash, row);
+    }
+    final_digest(hash)
+}
+
+pub(super) fn contribution_proof_digest(
+    result_digest: SemanticDigest,
+    parent_digests: [SemanticDigest; 2],
+    key: &ContributionKey,
+    factor: ExactComplexRational,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-on-the-fly-contribution-row-v1\0");
+    hash_digest(&mut hash, result_digest);
+    hash_digest(&mut hash, parent_digests[0]);
+    hash_digest(&mut hash, parent_digests[1]);
+    hash.update(key.transition_template_id().to_le_bytes());
+    hash.update(key.result_state_template_id().to_le_bytes());
+    hash.update(key.quantum_flow_witness_id().to_le_bytes());
+    hash.update(
+        key.color_witness_term_id()
+            .color_contraction_template_id()
+            .to_le_bytes(),
+    );
+    hash.update(key.color_witness_term_id().witness_ordinal().to_le_bytes());
+    hash_digest(&mut hash, key.runtime_coupling_binding_digest());
+    hash.update(key.output_projection_id().to_le_bytes());
+    hash_exact(&mut hash, factor);
+    final_digest(hash)
+}
+
+fn closure_proof_digest(
+    parent_digests: [SemanticDigest; 2],
+    closure: &PendingClosure,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-on-the-fly-closure-row-v1\0");
+    hash_digest(&mut hash, parent_digests[0]);
+    hash_digest(&mut hash, parent_digests[1]);
+    hash.update(closure.key.closure_template_id.to_le_bytes());
+    hash.update(
+        closure
+            .key
+            .quantum_flow_template_id
+            .unwrap_or(MISSING_U32)
+            .to_le_bytes(),
+    );
+    hash.update(
+        closure
+            .key
+            .color_witness_term_id
+            .color_contraction_template_id()
+            .to_le_bytes(),
+    );
+    hash.update(
+        closure
+            .key
+            .color_witness_term_id
+            .witness_ordinal()
+            .to_le_bytes(),
+    );
+    hash_exact(&mut hash, closure.factor);
+    hash_len(
+        &mut hash,
+        closure.component_coefficients.len(),
+        "closure component factors",
+    )?;
+    for coefficient in &closure.component_coefficients {
+        hash_exact(&mut hash, *coefficient);
+    }
+    final_digest(hash)
+}
+
+fn pairing_owner_association_multiset_digest(
+    closure_proof_rows: &[SemanticDigest],
+    pairing_owners: &[ResolvedPairingOwnerV1],
+) -> RusticolResult<SemanticDigest> {
+    if closure_proof_rows.len() != pairing_owners.len() {
+        return Err(integrity(
+            "closure proof and pairing-owner domains have different sizes",
+        ));
+    }
+    let mut rows = Vec::new();
+    rows.try_reserve_exact(pairing_owners.len())
+        .map_err(|error| invalid(format!("pairing-owner proof allocation failed: {error}")))?;
+    for (closure_proof, owner) in closure_proof_rows.iter().zip(pairing_owners) {
+        let mut hash = Sha256::new();
+        hash.update(b"pyamplicol-on-the-fly-closure-pairing-owner-row-v1\0");
+        hash_digest(&mut hash, *closure_proof);
+        match owner.proof_digest {
+            None => hash.update([0]),
+            Some(digest) => {
+                hash.update([1]);
+                hash_digest(&mut hash, digest);
+            }
+        }
+        rows.push(final_digest(hash)?);
+    }
+    multiset_digest(
+        b"pyamplicol-on-the-fly-closure-pairing-owner-multiset-v1\0",
+        rows,
+    )
+}
+
+fn intern_factor(
+    factor: ExactComplexRational,
+    factors: &mut Vec<ExactComplexRational>,
+    ids: &mut BTreeMap<ExactComplexRational, u32>,
+) -> RusticolResult<u32> {
+    if let Some(id) = ids.get(&factor).copied() {
+        return Ok(id);
+    }
+    let id = checked_u32(factors.len(), "exact factor count")?;
+    factors.push(factor);
+    ids.insert(factor, id);
+    Ok(id)
+}
+
+fn intern_momentum(
+    form: &CanonicalMomentumLinearForm,
+    forms: &mut Vec<CanonicalMomentumLinearForm>,
+    ids: &mut BTreeMap<CanonicalMomentumLinearForm, u32>,
+) -> RusticolResult<u32> {
+    if let Some(id) = ids.get(form).copied() {
+        return Ok(id);
+    }
+    let id = checked_u32(forms.len(), "momentum form count")?;
+    forms.push(form.clone());
+    ids.insert(form.clone(), id);
+    Ok(id)
+}
+
+fn operation_key(
+    seed: &OnTheFlyProcessSeedV1,
+    role: DirectExecutorRole,
+    kind: OnTheFlyOperationKindV1,
+    operation_id: u32,
+    operation_semantic_digest: SemanticDigest,
+    evaluator_binding_id: u32,
+    evaluator_binding_semantic_digest: SemanticDigest,
+) -> RusticolResult<OnTheFlyExecutorKeyV1> {
+    OnTheFlyExecutorKeyV1::new(
+        seed.direct_catalog_digest,
+        role,
+        kind,
+        operation_id,
+        operation_semantic_digest,
+        evaluator_binding_id,
+        evaluator_binding_semantic_digest,
+    )
+}
+
+fn source_executor_key(
+    grammar: &PreparedOnTheFlyGrammarV1,
+    seed: &OnTheFlyProcessSeedV1,
+    source_template_id: u32,
+    current_state_template_id: u32,
+) -> RusticolResult<OnTheFlyExecutorKeyV1> {
+    let executor = grammar
+        .sources
+        .get(&(source_template_id, current_state_template_id))
+        .ok_or_else(|| integrity("source executor contract is absent"))?
+        .executor;
+    operation_key(
+        seed,
+        DirectExecutorRole::Source,
+        OnTheFlyOperationKindV1::Source,
+        executor.operation_id,
+        executor.operation_semantic_digest,
+        executor.evaluator_binding_id,
+        executor.evaluator_binding_semantic_digest,
+    )
+}
+
+fn transition_executor_key(
+    seed: &OnTheFlyProcessSeedV1,
+    transition: &PreparedTransition,
+) -> RusticolResult<OnTheFlyExecutorKeyV1> {
+    operation_key(
+        seed,
+        DirectExecutorRole::Contribution,
+        OnTheFlyOperationKindV1::Transition,
+        transition.row.id,
+        transition.transition_semantic_digest,
+        transition.row.evaluator_binding_id,
+        transition.evaluator_binding_digest,
+    )
+}
+
+fn propagator_executor_key(
+    grammar: &PreparedOnTheFlyGrammarV1,
+    seed: &OnTheFlyProcessSeedV1,
+    propagator_template_id: u32,
+) -> RusticolResult<OnTheFlyExecutorKeyV1> {
+    let executor = grammar
+        .propagator_executors
+        .get(&propagator_template_id)
+        .ok_or_else(|| integrity("propagator executor contract is absent"))?;
+    operation_key(
+        seed,
+        DirectExecutorRole::Finalization,
+        OnTheFlyOperationKindV1::Propagator,
+        executor.operation_id,
+        executor.operation_semantic_digest,
+        executor.evaluator_binding_id,
+        executor.evaluator_binding_semantic_digest,
+    )
+}
+
+fn closure_executor_key(
+    seed: &OnTheFlyProcessSeedV1,
+    closure: &PreparedClosure,
+) -> RusticolResult<OnTheFlyExecutorKeyV1> {
+    operation_key(
+        seed,
+        DirectExecutorRole::Closure,
+        OnTheFlyOperationKindV1::Closure,
+        closure.row.id,
+        closure.closure_semantic_digest,
+        closure.row.evaluator_binding_id,
+        closure.evaluator_binding_digest,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn lower_trace(
+    templates: &ValidatedRecurrenceTemplateInput,
+    grammar: &PreparedOnTheFlyGrammarV1,
+    seed: &OnTheFlyProcessSeedV1,
+    query: &DecodedLcQueryV1,
+    colors: &DynamicLCColorStateInterner,
+    currents: &[PendingCurrent],
+    closures: &[PendingClosure],
+    pairing_owners: Vec<ResolvedPairingOwnerV1>,
+    live: &BTreeSet<u32>,
+    constructed_contribution_count: usize,
+) -> RusticolResult<OnTheFlyStructuralTraceV1> {
+    if pairing_owners.len() != closures.len() {
+        return Err(integrity(
+            "selected closures and resolved pairing owners have different sizes",
+        ));
+    }
+    let input = templates.input();
+    let mut old_to_new = BTreeMap::new();
+    let mut current_keys = Vec::with_capacity(live.len());
+    let mut current_colors = Vec::with_capacity(live.len());
+    let mut component_bases = BTreeMap::new();
+    let mut component_counts = BTreeMap::new();
+    let mut current_component_count = 0u32;
+    for old_id in live.iter().copied() {
+        let current = currents
+            .get(old_id as usize)
+            .ok_or_else(|| integrity("live current is absent"))?;
+        let state = input
+            .current_states
+            .get(current.key.current_state_template_id() as usize)
+            .ok_or_else(|| integrity("live current state template is absent"))?;
+        let count = u16::try_from(state.dimension)
+            .map_err(|_| invalid("on-the-fly current component count exceeds u16"))?;
+        let new_id = checked_u32(current_keys.len(), "live current count")?;
+        old_to_new.insert(old_id, new_id);
+        component_bases.insert(old_id, current_component_count);
+        component_counts.insert(old_id, count);
+        current_component_count = current_component_count
+            .checked_add(u32::from(count))
+            .ok_or_else(|| invalid("on-the-fly current arena exceeds u32 components"))?;
+        current_keys.push(current.key.clone());
+        current_colors.push(
+            colors
+                .get(current.key.dynamic_lc_color_state_id())
+                .ok_or_else(|| integrity("live current color state is absent"))?
+                .clone(),
+        );
+    }
+
+    let mut momentum_forms = Vec::new();
+    let mut momentum_ids = BTreeMap::new();
+    for old_id in live.iter().copied() {
+        intern_momentum(
+            currents[old_id as usize].key.momentum(),
+            &mut momentum_forms,
+            &mut momentum_ids,
+        )?;
+    }
+    let mut exact_factors = Vec::new();
+    let mut factor_ids = BTreeMap::new();
+    intern_factor(
+        ExactComplexRational::ONE,
+        &mut exact_factors,
+        &mut factor_ids,
+    )?;
+    let mut operations = Vec::new();
+
+    for old_id in live
+        .iter()
+        .copied()
+        .filter(|old_id| currents[*old_id as usize].key.node_kind() == RecurrenceNodeKind::Source)
+    {
+        let current = &currents[old_id as usize];
+        let source_template_id = match current.key.source_binding() {
+            CurrentSourceBinding::FixedTemplate(id) => *id,
+            _ => return Err(integrity("selected source has no fixed template binding")),
+        };
+        operations.push(OnTheFlyTraceOperationV1::Source {
+            key: source_executor_key(
+                grammar,
+                seed,
+                source_template_id,
+                current.key.current_state_template_id(),
+            )?,
+            row: DirectSourceRow {
+                source_slot: current.key.support_source_slots()[0],
+                destination_component_base: component_bases[&old_id],
+                momentum_form_id: momentum_ids[current.key.momentum()],
+                source_template_or_dispatch_domain: source_template_id,
+                spin_state_class: current.key.spin_state_class(),
+                exact_factor_id: intern_factor(
+                    current
+                        .source_factor
+                        .ok_or_else(|| integrity("source current has no exact factor"))?,
+                    &mut exact_factors,
+                    &mut factor_ids,
+                )?,
+                selector_domain_id: 0,
+            },
+        });
+    }
+
+    let maximum_stage = live
+        .iter()
+        .map(|id| currents[*id as usize].stage)
+        .max()
+        .unwrap_or(0);
+    let mut contribution_proof_rows = Vec::new();
+    let mut family_contribution_rows = Vec::new();
+    let current_digest_by_old = live
+        .iter()
+        .copied()
+        .map(|old_id| {
+            let current = &currents[old_id as usize];
+            Ok((
+                old_id,
+                hash_current_key(
+                    &current.key,
+                    colors
+                        .get(current.key.dynamic_lc_color_state_id())
+                        .ok_or_else(|| integrity("proof current color state is absent"))?,
+                )?,
+            ))
+        })
+        .collect::<RusticolResult<BTreeMap<_, _>>>()?;
+
+    for stage in 1..=maximum_stage {
+        for old_id in live
+            .iter()
+            .copied()
+            .filter(|old_id| currents[*old_id as usize].stage == stage)
+        {
+            let current = &currents[old_id as usize];
+            let mut initialized = false;
+            for (pending, factor) in current.contributions.iter().filter(|(pending, factor)| {
+                !factor.is_zero()
+                    && pending
+                        .parent_current_ids
+                        .iter()
+                        .all(|parent| live.contains(parent))
+            }) {
+                let transition_id = pending.key.transition_template_id();
+                let prepared = grammar
+                    .transitions
+                    .values()
+                    .flatten()
+                    .find(|prepared| prepared.row.id == transition_id)
+                    .ok_or_else(|| integrity("prepared live transition disappeared"))?;
+                let parent_ids = pending.parent_current_ids;
+                operations.push(OnTheFlyTraceOperationV1::Contribution {
+                    key: transition_executor_key(seed, prepared)?,
+                    row: DirectContributionRow {
+                        parent0_component_base: component_bases[&parent_ids[0]],
+                        parent1_component_base_or_sentinel: component_bases[&parent_ids[1]],
+                        parent0_momentum_form_id: momentum_ids
+                            [currents[parent_ids[0] as usize].key.momentum()],
+                        parent1_momentum_form_id_or_sentinel: momentum_ids
+                            [currents[parent_ids[1] as usize].key.momentum()],
+                        destination_component_base: component_bases[&old_id],
+                        exact_factor_id: intern_factor(
+                            *factor,
+                            &mut exact_factors,
+                            &mut factor_ids,
+                        )?,
+                        selector_domain_id: 0,
+                        flags: if initialized {
+                            0
+                        } else {
+                            DIRECT_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION
+                        },
+                    },
+                });
+                initialized = true;
+                contribution_proof_rows.push(contribution_proof_digest(
+                    current_digest_by_old[&old_id],
+                    [
+                        current_digest_by_old[&parent_ids[0]],
+                        current_digest_by_old[&parent_ids[1]],
+                    ],
+                    &pending.key,
+                    *factor,
+                )?);
+                {
+                    let local_parent_ids = [old_to_new[&parent_ids[0]], old_to_new[&parent_ids[1]]];
+                    family_contribution_rows.push(OnTheFlyTraceContributionProofRowV1 {
+                        result_current_id: old_to_new[&old_id],
+                        parent_current_ids: local_parent_ids,
+                        key: ContributionKey::new(
+                            pending.key.transition_template_id(),
+                            local_parent_ids.to_vec(),
+                            pending.key.parent_state_template_ids().to_vec(),
+                            pending.key.parent_momenta().to_vec(),
+                            pending.key.result_state_template_id(),
+                            pending.key.quantum_flow_witness_id(),
+                            pending.key.color_witness_term_id(),
+                            pending.key.runtime_coupling_binding_digest(),
+                            pending.key.output_projection_id(),
+                        )?,
+                        exact_factor: *factor,
+                    });
+                }
+            }
+            if !initialized {
+                return Err(integrity(
+                    "live non-source current has no live contribution",
+                ));
+            }
+            if let Some(propagator_id) = current.key.propagator_template_id() {
+                let component_count = component_counts[&old_id];
+                operations.push(OnTheFlyTraceOperationV1::Finalization {
+                    key: propagator_executor_key(grammar, seed, propagator_id)?,
+                    row: DirectFinalizationRow {
+                        component_base: component_bases[&old_id],
+                        component_count,
+                        momentum_form_id: momentum_ids[current.key.momentum()],
+                        exact_factor_id: factor_ids[&ExactComplexRational::ONE],
+                        selector_domain_id: 0,
+                        flags: 0,
+                    },
+                });
+            }
+        }
+    }
+
+    let mut closure_proof_rows = Vec::new();
+    for closure in closures {
+        let prepared = grammar
+            .closures
+            .values()
+            .flatten()
+            .find(|prepared| prepared.row.id == closure.key.closure_template_id)
+            .ok_or_else(|| integrity("prepared live closure disappeared"))?;
+        let parent_ids = closure.key.parent_current_ids;
+        let parent0_count = component_counts[&parent_ids[0]];
+        let parent1_count = component_counts[&parent_ids[1]];
+        if parent0_count != parent1_count
+            || closure.component_coefficients.len() != usize::from(parent0_count)
+        {
+            return Err(integrity(
+                "closure component coefficients do not match parent dimensions",
+            ));
+        }
+        let component_factor_start = checked_u32(exact_factors.len(), "closure factor start")?;
+        exact_factors.extend_from_slice(&closure.component_coefficients);
+        operations.push(OnTheFlyTraceOperationV1::Closure {
+            key: closure_executor_key(seed, prepared)?,
+            row: DirectClosureRow {
+                parent0_component_base: component_bases[&parent_ids[0]],
+                parent1_component_base_or_sentinel: component_bases[&parent_ids[1]],
+                parent0_momentum_form_id: momentum_ids
+                    [currents[parent_ids[0] as usize].key.momentum()],
+                parent1_momentum_form_id_or_sentinel: momentum_ids
+                    [currents[parent_ids[1] as usize].key.momentum()],
+                amplitude_destination_id: 0,
+                exact_factor_id: intern_factor(
+                    closure.factor,
+                    &mut exact_factors,
+                    &mut factor_ids,
+                )?,
+                component_factor_start,
+                component_count: parent0_count,
+                selector_domain_id: 0,
+                flags: 0,
+            },
+        });
+        closure_proof_rows.push(closure_proof_digest(
+            [
+                current_digest_by_old[&parent_ids[0]],
+                current_digest_by_old[&parent_ids[1]],
+            ],
+            closure,
+        )?);
+    }
+
+    let current_multiset_digest = multiset_digest(
+        b"pyamplicol-on-the-fly-current-multiset-v1\0",
+        current_digest_by_old.values().copied().collect(),
+    )?;
+    let contribution_multiset_digest = multiset_digest(
+        b"pyamplicol-on-the-fly-contribution-multiset-v1\0",
+        contribution_proof_rows,
+    )?;
+    let pairing_owner_multiset_digest =
+        pairing_owner_association_multiset_digest(&closure_proof_rows, &pairing_owners)?;
+    let closure_multiset_digest = multiset_digest(
+        b"pyamplicol-on-the-fly-closure-multiset-v1\0",
+        closure_proof_rows,
+    )?;
+    let mut owner_hash = Sha256::new();
+    owner_hash.update(b"pyamplicol-on-the-fly-owner-v2\0");
+    hash_digest(&mut owner_hash, seed.semantic_digest());
+    hash_digest(&mut owner_hash, query.semantic_digest());
+    owner_hash.update(query.closure_anchor_slot.to_le_bytes());
+    hash_digest(&mut owner_hash, query.selector_digest);
+    hash_digest(&mut owner_hash, pairing_owner_multiset_digest);
+    let owner_digest = final_digest(owner_hash)?;
+    let mut proof_hash = Sha256::new();
+    proof_hash.update(ON_THE_FLY_PROOF_DOMAIN);
+    for digest in [
+        current_multiset_digest,
+        contribution_multiset_digest,
+        closure_multiset_digest,
+        owner_digest,
+    ] {
+        hash_digest(&mut proof_hash, digest);
+    }
+    let live_contribution_count = operations
+        .iter()
+        .filter(|operation| matches!(operation, OnTheFlyTraceOperationV1::Contribution { .. }))
+        .count();
+    for value in [
+        live.len(),
+        live_contribution_count,
+        closures.len(),
+        currents.len(),
+        constructed_contribution_count,
+    ] {
+        proof_hash.update(checked_u32(value, "structural proof count")?.to_le_bytes());
+    }
+    let proof = OnTheFlyStructuralProofV1 {
+        current_count: checked_u32(live.len(), "live current count")?,
+        contribution_count: checked_u32(live_contribution_count, "live contribution count")?,
+        closure_count: checked_u32(closures.len(), "live closure count")?,
+        constructed_current_count: checked_u32(currents.len(), "constructed current count")?,
+        constructed_contribution_count: checked_u32(
+            constructed_contribution_count,
+            "constructed contribution count",
+        )?,
+        current_multiset_digest,
+        contribution_multiset_digest,
+        closure_multiset_digest,
+        owner_digest,
+        semantic_digest: final_digest(proof_hash)?,
+    };
+    let exact_factor_count = checked_u32(exact_factors.len(), "exact factor count")?;
+    let layout = OnTheFlyWorkspaceLayoutV1 {
+        source_count: checked_u32(query.selected_sources.len(), "selected source count")?,
+        lorentz_component_count: 4,
+        parameter_count: checked_u32(templates.input().parameters.len(), "parameter count")?,
+        current_component_count,
+        amplitude_component_count: 1,
+        momentum_form_count: checked_u32(momentum_ids.len(), "momentum form count")?,
+        exact_factor_count,
+    };
+    let mut trace_hash = Sha256::new();
+    trace_hash.update(b"pyamplicol-on-the-fly-structural-trace-v1\0");
+    hash_digest(&mut trace_hash, seed.semantic_digest());
+    hash_digest(&mut trace_hash, query.semantic_digest());
+    hash_digest(&mut trace_hash, proof.semantic_digest());
+    for value in [
+        layout.source_count,
+        u32::from(layout.lorentz_component_count),
+        layout.parameter_count,
+        layout.current_component_count,
+        layout.amplitude_component_count,
+        layout.momentum_form_count,
+        layout.exact_factor_count,
+    ] {
+        trace_hash.update(value.to_le_bytes());
+    }
+    let semantic_digest = final_digest(trace_hash)?;
+    let current_component_ranges = live
+        .iter()
+        .copied()
+        .map(|old_id| {
+            [
+                component_bases[&old_id],
+                u32::from(component_counts[&old_id]),
+            ]
+        })
+        .collect::<Vec<_>>()
+        .into_boxed_slice();
+    let current_semantic_digests = live
+        .iter()
+        .copied()
+        .map(|old_id| current_digest_by_old[&old_id])
+        .collect::<Vec<_>>()
+        .into_boxed_slice();
+    Ok(OnTheFlyStructuralTraceV1 {
+        seed_digest: seed.semantic_digest(),
+        query_digest: query.semantic_digest(),
+        current_keys: current_keys.into_boxed_slice(),
+        current_colors: current_colors.into_boxed_slice(),
+        operations: operations.into_boxed_slice(),
+        momentum_forms: momentum_forms.into_boxed_slice(),
+        exact_factors: exact_factors.into_boxed_slice(),
+        pairing_owners: pairing_owners.into_boxed_slice(),
+        layout,
+        proof,
+        semantic_digest,
+        prepared_executor_rows_bound: false,
+        current_component_ranges,
+        current_semantic_digests,
+        contribution_proof_rows: family_contribution_rows.into_boxed_slice(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    fn pairing_owner(byte: u8) -> ResolvedPairingOwnerV1 {
+        ResolvedPairingOwnerV1 {
+            endpoint_pairs: Vec::new(),
+            proof_digest: Some(digest(byte)),
+            source_slot_permutation: Vec::new(),
+            source_lineage: Vec::new(),
+            fermion_parity: 1,
+        }
+    }
+
+    #[test]
+    fn pairing_owner_proof_binds_closure_associations_order_independently() {
+        let closures = [digest(1), digest(2)];
+        let owners = [pairing_owner(3), pairing_owner(4)];
+        let expected = pairing_owner_association_multiset_digest(&closures, &owners).unwrap();
+        assert_eq!(
+            expected,
+            pairing_owner_association_multiset_digest(
+                &[closures[1], closures[0]],
+                &[pairing_owner(4), pairing_owner(3)],
+            )
+            .unwrap(),
+        );
+        assert_ne!(
+            expected,
+            pairing_owner_association_multiset_digest(
+                &closures,
+                &[pairing_owner(4), pairing_owner(3)],
+            )
+            .unwrap(),
+        );
+        assert_ne!(
+            pairing_owner_association_multiset_digest(&[closures[0]], &[pairing_owner(3)],)
+                .unwrap(),
+            pairing_owner_association_multiset_digest(
+                &[closures[0], closures[0]],
+                &[pairing_owner(3), pairing_owner(3)],
+            )
+            .unwrap(),
+        );
+        assert!(pairing_owner_association_multiset_digest(&closures, &owners[..1]).is_err());
+    }
+
+    #[test]
+    fn logical_batch_capacity_belongs_to_workspace_not_structural_trace() {
+        let trace = OnTheFlyStructuralTraceV1 {
+            seed_digest: digest(1),
+            query_digest: digest(2),
+            current_keys: Box::new([]),
+            current_colors: Box::new([]),
+            operations: Box::new([]),
+            momentum_forms: vec![
+                CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+                    source_slot: 0,
+                    coefficient: 1,
+                }])
+                .unwrap(),
+            ]
+            .into_boxed_slice(),
+            exact_factors: vec![ExactComplexRational::ONE].into_boxed_slice(),
+            pairing_owners: Box::new([]),
+            layout: OnTheFlyWorkspaceLayoutV1 {
+                source_count: 1,
+                lorentz_component_count: 4,
+                parameter_count: 0,
+                current_component_count: 1,
+                amplitude_component_count: 1,
+                momentum_form_count: 1,
+                exact_factor_count: 1,
+            },
+            proof: OnTheFlyStructuralProofV1 {
+                current_count: 0,
+                contribution_count: 0,
+                closure_count: 0,
+                constructed_current_count: 0,
+                constructed_contribution_count: 0,
+                current_multiset_digest: digest(3),
+                contribution_multiset_digest: digest(4),
+                closure_multiset_digest: digest(5),
+                owner_digest: digest(6),
+                semantic_digest: digest(7),
+            },
+            semantic_digest: digest(8),
+            prepared_executor_rows_bound: false,
+            current_component_ranges: Box::new([]),
+            current_semantic_digests: Box::new([]),
+            contribution_proof_rows: Box::new([]),
+        };
+        let small = OnTheFlyWorkspaceV1::new(&trace, 1).unwrap();
+        let large = OnTheFlyWorkspaceV1::new(&trace, 65).unwrap();
+        assert_ne!(small.point_stride(), large.point_stride());
+        assert_eq!(trace.semantic_digest(), digest(8));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/process.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/process.rs
new file mode 100644
index 0000000000..e06aa1bdfe
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/process.rs
@@ -0,0 +1,4339 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Checked process-wide input for the compact recurrence builder.
+//!
+//! The Python producer encodes `pyamplicol-recurrence-builder-input-v2` as
+//! little-endian structure-of-arrays tables.  A boundary decoder can zip those
+//! columns into the fixed-width row types below and then construct
+//! [`OwnedRecurrenceProcessInput`].  This module validates process semantics
+//! and exposes typed template references and semantic identities for a later
+//! composite process-plus-template authentication step.  It deliberately does
+//! not construct recurrence states or an execution schedule.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use serde_json::json;
+use sha2::{Digest, Sha256};
+
+use super::{
+    CheckedTableRange, ExactComplexRational, MultiwordMaskCatalogView,
+    RECURRENCE_BUILDER_INPUT_ABI, RecurrenceStrategy, SemanticDigest, checked_u32_len,
+    validate_concrete_spin_state, validate_packed_ranges, validate_u32_references,
+};
+use crate::{RusticolError, RusticolResult};
+
+pub const RECURRENCE_PROCESS_INPUT_SCHEMA_VERSION: u32 = 1;
+pub const RECURRENCE_FERMION_PAIRING_COLUMNAR_ABI: &str =
+    "pyamplicol-recurrence-fermion-pairing-columnar-v1";
+pub const RECURRENCE_FERMION_PAIRING_SCHEMA_VERSION: u32 = 1;
+pub const RECURRENCE_NO_FERMION_LINE: u32 = u32::MAX;
+
+const RECURRENCE_FERMION_PAIRING_PROOF_ALGORITHM: &str = "canonical-external-fermion-pairing-v1";
+
+const MISSING_ID: u32 = u32::MAX;
+const REQUIRED_DIGEST_ROLE_COUNT: usize = 4;
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+struct FermionPairingCatalogs<'a> {
+    strings: Vec<&'a str>,
+}
+
+impl<'a> FermionPairingInputView<'a> {
+    fn validate_internal(
+        self,
+        expected_process_id: &str,
+    ) -> RusticolResult<FermionPairingValidationSummary> {
+        if self.input_abi != RECURRENCE_FERMION_PAIRING_COLUMNAR_ABI {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported fermion-pairing columnar ABI {:?}; expected {:?}",
+                self.input_abi, RECURRENCE_FERMION_PAIRING_COLUMNAR_ABI
+            )));
+        }
+        if self.header.len() != 1 {
+            return Err(invalid(format!(
+                "fermion-pairing header must contain one row, found {}",
+                self.header.len()
+            )));
+        }
+        if self.rules.is_empty() {
+            return Err(invalid("fermion-pairing catalog has no rules"));
+        }
+
+        let catalogs = self.validate_catalogs()?;
+        let header = self.header[0];
+        if header.schema_version != RECURRENCE_FERMION_PAIRING_SCHEMA_VERSION {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported fermion-pairing schema {}; expected {}",
+                header.schema_version, RECURRENCE_FERMION_PAIRING_SCHEMA_VERSION
+            )));
+        }
+        require_string_value(
+            &catalogs.strings,
+            header.abi_string_id,
+            RECURRENCE_FERMION_PAIRING_COLUMNAR_ABI,
+            "fermion-pairing ABI",
+        )?;
+        require_string_value(
+            &catalogs.strings,
+            header.proof_algorithm_string_id,
+            RECURRENCE_FERMION_PAIRING_PROOF_ALGORITHM,
+            "fermion-pairing proof algorithm",
+        )?;
+        let process_key = required_string(
+            &catalogs.strings,
+            header.process_key_string_id,
+            "fermion-pairing process key",
+        )?;
+        if process_key != expected_process_id {
+            return Err(invalid(format!(
+                "fermion-pairing process key {process_key:?} does not match {expected_process_id:?}"
+            )));
+        }
+        self.validate_counts_and_ranges(header)?;
+        self.validate_endpoints(&catalogs, header)?;
+        self.validate_classes(&catalogs, header)?;
+        self.validate_exact_integers()?;
+        self.validate_rules(&catalogs, header)?;
+
+        let topology_digest = SemanticDigest::new(header.topology_digest).map_err(|error| {
+            invalid(format!(
+                "fermion-pairing topology digest is invalid: {error}"
+            ))
+        })?;
+        let semantic_digest = SemanticDigest::new(header.semantic_digest).map_err(|error| {
+            invalid(format!(
+                "fermion-pairing semantic digest is invalid: {error}"
+            ))
+        })?;
+        Ok(FermionPairingValidationSummary {
+            columnar_digest: self.declared_columnar_digest,
+            topology_digest,
+            semantic_digest,
+            source_count: header.source_count,
+            endpoint_count: header.endpoint_count,
+            pairing_class_count: header.pairing_class_count,
+            rule_count: header.rule_count,
+        })
+    }
+
+    fn validate_catalogs(self) -> RusticolResult<FermionPairingCatalogs<'a>> {
+        validate_packed_ranges(
+            "fermion-pairing strings",
+            self.string_ranges,
+            self.string_bytes.len(),
+        )?;
+        let mut strings = Vec::with_capacity(self.string_ranges.len());
+        let mut previous: Option<&[u8]> = None;
+        for (index, range) in self.string_ranges.iter().copied().enumerate() {
+            let bytes = &self.string_bytes[range.as_usize_range(
+                self.string_bytes.len(),
+                &format!("fermion-pairing string {index}"),
+            )?];
+            if bytes.is_empty() || previous.is_some_and(|value| value >= bytes) {
+                return Err(invalid(format!(
+                    "fermion-pairing string row {index} is empty or not canonical"
+                )));
+            }
+            let value = std::str::from_utf8(bytes).map_err(|error| {
+                invalid(format!(
+                    "fermion-pairing string row {index} is not UTF-8: {error}"
+                ))
+            })?;
+            previous = Some(bytes);
+            strings.push(value);
+        }
+        Ok(FermionPairingCatalogs { strings })
+    }
+
+    fn validate_counts_and_ranges(self, header: FermionPairingHeaderRow) -> RusticolResult<()> {
+        for (label, declared, actual) in [
+            ("endpoints", header.endpoint_count, self.endpoints.len()),
+            (
+                "pairing classes",
+                header.pairing_class_count,
+                self.pairing_classes.len(),
+            ),
+            ("rules", header.rule_count, self.rules.len()),
+            (
+                "exact integers",
+                header.exact_integer_count,
+                self.exact_integers.len(),
+            ),
+            ("strings", header.string_count, self.string_ranges.len()),
+        ] {
+            if declared != checked_u32_len(actual, label)? {
+                return Err(invalid(format!(
+                    "fermion-pairing header {label} count does not match its table"
+                )));
+            }
+        }
+        for (label, declared, actual) in [
+            (
+                "endpoint state IDs",
+                header.endpoint_state_template_count,
+                self.endpoint_state_template_ids.len(),
+            ),
+            (
+                "endpoint anti-state IDs",
+                header.endpoint_anti_state_template_count,
+                self.endpoint_anti_state_template_ids.len(),
+            ),
+            (
+                "endpoint basis IDs",
+                header.endpoint_basis_count,
+                self.endpoint_basis_ids.len(),
+            ),
+            (
+                "endpoint color representations",
+                header.endpoint_color_representation_count,
+                self.endpoint_color_representations.len(),
+            ),
+            (
+                "class fundamental slots",
+                header.class_fundamental_slot_count,
+                self.class_fundamental_slots.len(),
+            ),
+            (
+                "class antifundamental slots",
+                header.class_antifundamental_slot_count,
+                self.class_antifundamental_slots.len(),
+            ),
+            (
+                "class reference pairings",
+                header.class_reference_pairing_count,
+                self.class_reference_pairings.len(),
+            ),
+            (
+                "rule class indices",
+                header.rule_class_pairing_index_count,
+                self.rule_class_pairing_indices.len(),
+            ),
+            (
+                "rule endpoint pairings",
+                header.rule_endpoint_pairing_count,
+                self.rule_endpoint_pairings.len(),
+            ),
+            (
+                "rule source permutations",
+                header.rule_source_permutation_count,
+                self.rule_source_slot_permutations.len(),
+            ),
+            (
+                "rule lineages",
+                header.rule_lineage_count,
+                self.rule_lineages.len(),
+            ),
+            (
+                "exact-integer limbs",
+                header.exact_integer_limb_count,
+                self.exact_integer_limbs.len(),
+            ),
+            (
+                "string bytes",
+                header.string_byte_count,
+                self.string_bytes.len(),
+            ),
+        ] {
+            let actual = u64::try_from(actual)
+                .map_err(|_| invalid(format!("fermion-pairing {label} count exceeds u64")))?;
+            if declared != actual {
+                return Err(invalid(format!(
+                    "fermion-pairing header {label} count does not match its table"
+                )));
+            }
+        }
+        if header.no_fermion_line != RECURRENCE_NO_FERMION_LINE {
+            return Err(invalid("fermion-pairing lineage sentinel is stale"));
+        }
+        validate_pairing_ranges(
+            "endpoint state IDs",
+            self.endpoints.iter().map(|row| row.state_template_range),
+            self.endpoint_state_template_ids.len(),
+        )?;
+        validate_pairing_ranges(
+            "endpoint anti-state IDs",
+            self.endpoints
+                .iter()
+                .map(|row| row.anti_state_template_range),
+            self.endpoint_anti_state_template_ids.len(),
+        )?;
+        validate_pairing_ranges(
+            "endpoint basis IDs",
+            self.endpoints.iter().map(|row| row.basis_range),
+            self.endpoint_basis_ids.len(),
+        )?;
+        validate_pairing_ranges(
+            "endpoint color representations",
+            self.endpoints
+                .iter()
+                .map(|row| row.color_representation_range),
+            self.endpoint_color_representations.len(),
+        )?;
+        validate_pairing_ranges(
+            "class fundamental slots",
+            self.pairing_classes
+                .iter()
+                .map(|row| row.fundamental_slot_range),
+            self.class_fundamental_slots.len(),
+        )?;
+        validate_pairing_ranges(
+            "class antifundamental slots",
+            self.pairing_classes
+                .iter()
+                .map(|row| row.antifundamental_slot_range),
+            self.class_antifundamental_slots.len(),
+        )?;
+        validate_pairing_ranges(
+            "class reference pairings",
+            self.pairing_classes
+                .iter()
+                .map(|row| row.reference_pairing_range),
+            self.class_reference_pairings.len(),
+        )?;
+        validate_pairing_ranges(
+            "rule class indices",
+            self.rules.iter().map(|row| row.class_pairing_index_range),
+            self.rule_class_pairing_indices.len(),
+        )?;
+        validate_pairing_ranges(
+            "rule endpoint pairings",
+            self.rules.iter().map(|row| row.endpoint_pairing_range),
+            self.rule_endpoint_pairings.len(),
+        )?;
+        validate_pairing_ranges(
+            "rule source permutations",
+            self.rules.iter().map(|row| row.source_permutation_range),
+            self.rule_source_slot_permutations.len(),
+        )?;
+        validate_pairing_ranges(
+            "rule lineages",
+            self.rules.iter().map(|row| row.lineage_range),
+            self.rule_lineages.len(),
+        )?;
+        validate_pairing_ranges(
+            "exact-integer limbs",
+            self.exact_integers.iter().map(|row| row.limb_range),
+            self.exact_integer_limbs.len(),
+        )
+    }
+
+    fn validate_endpoints(
+        self,
+        catalogs: &FermionPairingCatalogs<'_>,
+        header: FermionPairingHeaderRow,
+    ) -> RusticolResult<()> {
+        validate_canonical_ids(
+            "fermion-pairing endpoint IDs",
+            self.endpoints.iter().map(|row| row.endpoint_id),
+        )?;
+        let mut previous_slot = None;
+        for (index, endpoint) in self.endpoints.iter().copied().enumerate() {
+            required_reference(
+                endpoint.source_slot,
+                header.source_count as usize,
+                "fermion endpoint source",
+            )?;
+            if previous_slot.is_some_and(|value| value >= endpoint.source_slot) {
+                return Err(invalid(format!(
+                    "fermion endpoints are not in source-slot order at row {index}"
+                )));
+            }
+            previous_slot = Some(endpoint.source_slot);
+            required_reference(
+                endpoint.species_class_id,
+                self.pairing_classes.len(),
+                "fermion endpoint species class",
+            )?;
+            required_string(
+                &catalogs.strings,
+                endpoint.species_string_id,
+                "fermion endpoint species",
+            )?;
+            if !matches!(endpoint.particle_orientation, 0 | 1)
+                || !matches!(endpoint.color_orientation, 0 | 1)
+            {
+                return Err(invalid(format!(
+                    "fermion endpoint {index} has an invalid orientation"
+                )));
+            }
+            SemanticDigest::new(endpoint.contract_digest).map_err(|error| {
+                invalid(format!(
+                    "fermion endpoint {index} digest is invalid: {error}"
+                ))
+            })?;
+            for (ids, range, label) in [
+                (
+                    self.endpoint_state_template_ids,
+                    endpoint.state_template_range,
+                    "endpoint state IDs",
+                ),
+                (
+                    self.endpoint_anti_state_template_ids,
+                    endpoint.anti_state_template_range,
+                    "endpoint anti-state IDs",
+                ),
+                (
+                    self.endpoint_basis_ids,
+                    endpoint.basis_range,
+                    "endpoint basis IDs",
+                ),
+            ] {
+                let ids = pairing_range_slice(ids, range, label)?;
+                if ids.is_empty() {
+                    return Err(invalid(format!(
+                        "fermion endpoint {index} has empty {label}"
+                    )));
+                }
+                validate_strict_u32_values(ids, catalogs.strings.len(), label)?;
+            }
+            let representations = pairing_range_slice(
+                self.endpoint_color_representations,
+                endpoint.color_representation_range,
+                "endpoint color representations",
+            )?;
+            if representations.is_empty() {
+                return Err(invalid(format!(
+                    "fermion endpoint {index} has no color representation"
+                )));
+            }
+            validate_strict_i32_values(representations, "endpoint color representations")?;
+        }
+        Ok(())
+    }
+
+    fn validate_classes(
+        self,
+        catalogs: &FermionPairingCatalogs<'_>,
+        header: FermionPairingHeaderRow,
+    ) -> RusticolResult<()> {
+        validate_canonical_ids(
+            "fermion-pairing class IDs",
+            self.pairing_classes.iter().map(|row| row.class_id),
+        )?;
+        let mut species = BTreeSet::new();
+        for (index, class) in self.pairing_classes.iter().copied().enumerate() {
+            if class.species_class_id != class.class_id {
+                return Err(invalid(format!(
+                    "fermion class {index} species-class ID is not aligned"
+                )));
+            }
+            let species_id = required_string(
+                &catalogs.strings,
+                class.species_string_id,
+                "fermion class species",
+            )?;
+            if !species.insert(species_id) {
+                return Err(invalid(format!(
+                    "fermion class {index} repeats species {species_id:?}"
+                )));
+            }
+            let fundamental = pairing_range_slice(
+                self.class_fundamental_slots,
+                class.fundamental_slot_range,
+                "class fundamental slots",
+            )?;
+            let antifundamental = pairing_range_slice(
+                self.class_antifundamental_slots,
+                class.antifundamental_slot_range,
+                "class antifundamental slots",
+            )?;
+            let references = pairing_range_slice(
+                self.class_reference_pairings,
+                class.reference_pairing_range,
+                "class reference pairings",
+            )?;
+            validate_strict_u32_values(
+                fundamental,
+                header.source_count as usize,
+                "class fundamental slots",
+            )?;
+            validate_strict_u32_values(
+                antifundamental,
+                header.source_count as usize,
+                "class antifundamental slots",
+            )?;
+            if fundamental.is_empty()
+                || fundamental.len() != antifundamental.len()
+                || references.len() != fundamental.len()
+            {
+                return Err(invalid(format!(
+                    "fermion class {index} has unbalanced endpoint ranges"
+                )));
+            }
+            for ((fundamental, antifundamental), reference) in fundamental
+                .iter()
+                .copied()
+                .zip(antifundamental.iter().copied())
+                .zip(references.iter().copied())
+            {
+                if reference.fundamental_source_slot != fundamental
+                    || reference.antifundamental_source_slot != antifundamental
+                {
+                    return Err(invalid(format!(
+                        "fermion class {index} reference pairings are stale"
+                    )));
+                }
+            }
+            let expected_pairing_count = checked_factorial_u64(
+                fundamental.len(),
+                &format!("fermion class {index} pairing count"),
+            )?;
+            if class.pairing_count != expected_pairing_count {
+                return Err(invalid(format!(
+                    "fermion class {index} declares {} pairings, expected {expected_pairing_count}",
+                    class.pairing_count
+                )));
+            }
+            SemanticDigest::new(class.proof_digest).map_err(|error| {
+                invalid(format!(
+                    "fermion class {index} proof digest is invalid: {error}"
+                ))
+            })?;
+        }
+        for endpoint in self.endpoints {
+            let class = self.pairing_classes[endpoint.species_class_id as usize];
+            if endpoint.species_string_id != class.species_string_id {
+                return Err(invalid(
+                    "fermion endpoint species disagrees with its pairing class",
+                ));
+            }
+            let slots = if endpoint.color_orientation == 0 {
+                pairing_range_slice(
+                    self.class_fundamental_slots,
+                    class.fundamental_slot_range,
+                    "class fundamental slots",
+                )?
+            } else {
+                pairing_range_slice(
+                    self.class_antifundamental_slots,
+                    class.antifundamental_slot_range,
+                    "class antifundamental slots",
+                )?
+            };
+            if slots.binary_search(&endpoint.source_slot).is_err() {
+                return Err(invalid(
+                    "fermion endpoint is absent from its pairing class orientation",
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_exact_integers(self) -> RusticolResult<()> {
+        validate_canonical_ids(
+            "fermion exact-integer IDs",
+            self.exact_integers.iter().map(|row| row.integer_id),
+        )?;
+        for (index, row) in self.exact_integers.iter().copied().enumerate() {
+            if !matches!(row.sign, -1..=1) {
+                return Err(invalid(format!(
+                    "exact integer {index} has an invalid sign"
+                )));
+            }
+            let limbs = pairing_range_slice(
+                self.exact_integer_limbs,
+                row.limb_range,
+                "exact-integer limbs",
+            )?;
+            if (row.sign == 0 && !limbs.is_empty())
+                || (row.sign != 0 && (limbs.is_empty() || limbs.last() == Some(&0)))
+            {
+                return Err(invalid(format!(
+                    "exact integer {index} has a noncanonical magnitude"
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_rules(
+        self,
+        catalogs: &FermionPairingCatalogs<'_>,
+        header: FermionPairingHeaderRow,
+    ) -> RusticolResult<()> {
+        let expected_rule_count =
+            self.pairing_classes
+                .iter()
+                .enumerate()
+                .try_fold(1_u64, |count, (index, class)| {
+                    count.checked_mul(class.pairing_count).ok_or_else(|| {
+                        invalid(format!(
+                            "combined fermion-pairing rule count overflows u64 at class {index}"
+                        ))
+                    })
+                })?;
+        let actual_rule_count = u64::try_from(self.rules.len())
+            .map_err(|_| invalid("fermion-pairing rule count exceeds u64"))?;
+        if actual_rule_count != expected_rule_count {
+            return Err(invalid(format!(
+                "fermion-pairing catalog contains {actual_rule_count} rules, expected {expected_rule_count}"
+            )));
+        }
+        validate_canonical_ids(
+            "fermion-pairing rule IDs",
+            self.rules.iter().map(|row| row.rule_id),
+        )?;
+        for (index, rule) in self.rules.iter().copied().enumerate() {
+            let class_indices = pairing_range_slice(
+                self.rule_class_pairing_indices,
+                rule.class_pairing_index_range,
+                "rule class indices",
+            )?;
+            if class_indices.len() != self.pairing_classes.len() {
+                return Err(invalid(format!(
+                    "fermion rule {index} does not reference every class"
+                )));
+            }
+            for (expected_class, encoded) in class_indices.iter().copied().enumerate() {
+                let expected_class = u32::try_from(expected_class)
+                    .map_err(|_| invalid("fermion pairing class index exceeds u32"))?;
+                if encoded.class_id != expected_class
+                    || encoded.pairing_index
+                        >= self.pairing_classes[expected_class as usize].pairing_count
+                {
+                    return Err(invalid(format!(
+                        "fermion rule {index} has an invalid class-local pairing index"
+                    )));
+                }
+            }
+            let pairs = pairing_range_slice(
+                self.rule_endpoint_pairings,
+                rule.endpoint_pairing_range,
+                "rule endpoint pairings",
+            )?;
+            if pairs.windows(2).any(|pair| {
+                (
+                    pair[0].fundamental_source_slot,
+                    pair[0].antifundamental_source_slot,
+                ) >= (
+                    pair[1].fundamental_source_slot,
+                    pair[1].antifundamental_source_slot,
+                )
+            }) {
+                return Err(invalid(format!(
+                    "fermion rule {index} endpoint pairs are not canonical"
+                )));
+            }
+            for pair in pairs {
+                for source_slot in [
+                    pair.fundamental_source_slot,
+                    pair.antifundamental_source_slot,
+                ] {
+                    required_reference(
+                        source_slot,
+                        header.source_count as usize,
+                        "rule endpoint source",
+                    )?;
+                }
+            }
+            let permutation = pairing_range_slice(
+                self.rule_source_slot_permutations,
+                rule.source_permutation_range,
+                "rule source permutation",
+            )?;
+            validate_permutation(
+                permutation,
+                header.source_count as usize,
+                &format!("fermion rule {index} source permutation"),
+            )?;
+            let lineage =
+                pairing_range_slice(self.rule_lineages, rule.lineage_range, "rule lineage")?;
+            if lineage.len() != header.source_count as usize
+                || lineage.iter().any(|line| {
+                    *line != RECURRENCE_NO_FERMION_LINE && (*line as usize) >= pairs.len()
+                })
+            {
+                return Err(invalid(format!("fermion rule {index} lineage is invalid")));
+            }
+            if !matches!(rule.fermion_parity, -1 | 1) || rule.multiplicity != 1 {
+                return Err(invalid(format!(
+                    "fermion rule {index} parity or multiplicity is invalid"
+                )));
+            }
+            require_string_value(
+                &catalogs.strings,
+                rule.proof_algorithm_string_id,
+                RECURRENCE_FERMION_PAIRING_PROOF_ALGORITHM,
+                "fermion rule proof algorithm",
+            )?;
+            SemanticDigest::new(rule.proof_digest).map_err(|error| {
+                invalid(format!(
+                    "fermion rule {index} proof digest is invalid: {error}"
+                ))
+            })?;
+            self.validate_rule_factor(rule, index)?;
+        }
+        Ok(())
+    }
+
+    fn validate_rule_factor(
+        self,
+        rule: FermionPairingRuleRow,
+        rule_index: usize,
+    ) -> RusticolResult<()> {
+        for (id, expected, label) in [
+            (
+                rule.real_numerator_integer_id,
+                rule.fermion_parity,
+                "real numerator",
+            ),
+            (rule.real_denominator_integer_id, 1, "real denominator"),
+            (rule.imag_numerator_integer_id, 0, "imaginary numerator"),
+            (rule.imag_denominator_integer_id, 1, "imaginary denominator"),
+        ] {
+            if !exact_integer_equals(self, id, expected)? {
+                return Err(invalid(format!(
+                    "fermion rule {rule_index} {label} does not match its exact parity factor"
+                )));
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Physical leading-colour sector representation used by process input v1.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub enum ProcessLCSectorKind {
+    Singlet = 0,
+    OpenLines = 1,
+    SingleTrace = 2,
+}
+
+impl TryFrom<u8> for ProcessLCSectorKind {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Singlet),
+            1 => Ok(Self::OpenLines),
+            2 => Ok(Self::SingleTrace),
+            _ => Err(invalid(format!(
+                "unsupported recurrence LC sector kind {value}"
+            ))),
+        }
+    }
+}
+
+/// Closed semantic-template kinds referenced by process input v1.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum ProcessSemanticTemplateKind {
+    Parameter,
+    CurrentState,
+    Source,
+    QuantumFlow,
+    Transition,
+    Propagator,
+    Closure,
+    ColorContraction,
+    SymmetryProof,
+}
+
+impl ProcessSemanticTemplateKind {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Parameter => "parameter",
+            Self::CurrentState => "current-state",
+            Self::Source => "source",
+            Self::QuantumFlow => "quantum-flow",
+            Self::Transition => "transition",
+            Self::Propagator => "propagator",
+            Self::Closure => "closure",
+            Self::ColorContraction => "color-contraction",
+            Self::SymmetryProof => "symmetry-proof",
+        }
+    }
+}
+
+impl TryFrom<&str> for ProcessSemanticTemplateKind {
+    type Error = RusticolError;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+            "parameter" => Ok(Self::Parameter),
+            "current-state" => Ok(Self::CurrentState),
+            "source" => Ok(Self::Source),
+            "quantum-flow" => Ok(Self::QuantumFlow),
+            "transition" => Ok(Self::Transition),
+            "propagator" => Ok(Self::Propagator),
+            "closure" => Ok(Self::Closure),
+            "color-contraction" => Ok(Self::ColorContraction),
+            "symmetry-proof" => Ok(Self::SymmetryProof),
+            _ => Err(invalid(format!(
+                "unsupported process semantic-template kind {value:?}"
+            ))),
+        }
+    }
+}
+
+/// Typed identity of one model-wide semantic template.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ProcessSemanticTemplateId {
+    pub kind: ProcessSemanticTemplateKind,
+    pub template_id: u32,
+}
+
+/// Decoded process-side claim about one model-wide semantic template.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ProcessSemanticTemplateReference {
+    pub typed_id: ProcessSemanticTemplateId,
+    pub semantic_digest: SemanticDigest,
+    pub prepared_kernel_id: Option<u32>,
+}
+
+/// Semantic digest role carried by the process header.
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub enum ProcessDigestRole {
+    Process,
+    ModelCatalog,
+    PreparedCatalog,
+    ColorPlan,
+    Extension(String),
+}
+
+impl ProcessDigestRole {
+    pub fn decode(value: &str) -> RusticolResult<Self> {
+        if value.is_empty() {
+            return Err(invalid("process semantic digest role must not be empty"));
+        }
+        Ok(match value {
+            "process" => Self::Process,
+            "model-catalog" => Self::ModelCatalog,
+            "prepared-catalog" => Self::PreparedCatalog,
+            "color-plan" => Self::ColorPlan,
+            extension => Self::Extension(extension.to_owned()),
+        })
+    }
+
+    pub fn as_str(&self) -> &str {
+        match self {
+            Self::Process => "process",
+            Self::ModelCatalog => "model-catalog",
+            Self::PreparedCatalog => "prepared-catalog",
+            Self::ColorPlan => "color-plan",
+            Self::Extension(value) => value,
+        }
+    }
+}
+
+/// Decoded semantic identity needed by composite catalog authentication.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceProcessSemanticIdentity {
+    input_digest: SemanticDigest,
+    process_digest: SemanticDigest,
+    model_catalog_digest: SemanticDigest,
+    prepared_catalog_digest: SemanticDigest,
+    color_plan_digest: SemanticDigest,
+    extension_digests: BTreeMap<String, SemanticDigest>,
+}
+
+impl RecurrenceProcessSemanticIdentity {
+    pub const fn input_digest(&self) -> SemanticDigest {
+        self.input_digest
+    }
+
+    pub const fn process_digest(&self) -> SemanticDigest {
+        self.process_digest
+    }
+
+    pub const fn model_catalog_digest(&self) -> SemanticDigest {
+        self.model_catalog_digest
+    }
+
+    pub const fn prepared_catalog_digest(&self) -> SemanticDigest {
+        self.prepared_catalog_digest
+    }
+
+    pub const fn color_plan_digest(&self) -> SemanticDigest {
+        self.color_plan_digest
+    }
+
+    pub const fn extension_digests(&self) -> &BTreeMap<String, SemanticDigest> {
+        &self.extension_digests
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessBitsetRangeRow {
+    pub id: u32,
+    pub range: CheckedTableRange,
+    pub bit_count: u64,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessCouplingLimitRow {
+    pub name_string_id: u32,
+    pub minimum: u32,
+    pub maximum: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessDigestCatalogRow {
+    pub id: u32,
+    pub value: [u8; 32],
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessExactFactorRow {
+    pub id: u32,
+    pub real_numerator_string_id: u32,
+    pub real_denominator_string_id: u32,
+    pub imag_numerator_string_id: u32,
+    pub imag_denominator_string_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessExternalLegRow {
+    pub source_slot: u32,
+    pub public_label: u32,
+    pub physical_pdg: i32,
+    pub outgoing_pdg: i32,
+    pub is_initial: u8,
+    pub is_fermionic: u8,
+    pub source_state_range: CheckedTableRange,
+    pub momentum_mask_id: u32,
+    pub support_mask_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessHeaderRow {
+    pub schema_version: u32,
+    pub abi_string_id: u32,
+    pub process_id_string_id: u32,
+    pub layout: u8,
+    pub selected_flow_mode: u8,
+    pub selected_source_mode: u8,
+    pub external_leg_count: u32,
+    pub physical_sector_count: u32,
+    pub public_flow_count: u32,
+    pub replay_partition_count: u32,
+    pub coupling_limit_count: u32,
+    pub parameter_projection_count: u32,
+    pub process_support_mask_id: u32,
+}
+
+impl ProcessHeaderRow {
+    pub fn strategy(self) -> RusticolResult<RecurrenceStrategy> {
+        RecurrenceStrategy::try_from(u32::from(self.layout))
+    }
+
+    pub fn selected_flow_mode(self) -> RusticolResult<bool> {
+        decode_bool(self.selected_flow_mode, "header.selected_flow_mode")
+    }
+
+    pub fn selected_source_mode(self) -> RusticolResult<bool> {
+        decode_bool(self.selected_source_mode, "header.selected_source_mode")
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessHeaderDigestRow {
+    pub role_string_id: u32,
+    pub digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessLCOpenStringRow {
+    pub sector_id: u32,
+    pub ordinal: u32,
+    pub fundamental_source_slot: u32,
+    pub antifundamental_source_slot: u32,
+    pub adjoint_sequence_id: u32,
+    pub singlet_sequence_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessNormalizationRow {
+    pub factor_id: u32,
+    pub convention_string_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessParameterProjectionRow {
+    pub runtime_slot: u32,
+    pub runtime_name_string_id: u32,
+    pub parameter_template_id: u32,
+    pub prepared_parameter_id: u32,
+    pub component: u32,
+}
+
+impl ProcessParameterProjectionRow {
+    pub const fn prepared_parameter_id(self) -> Option<u32> {
+        if self.prepared_parameter_id == MISSING_ID {
+            None
+        } else {
+            Some(self.prepared_parameter_id)
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessPhysicalLCSectorRow {
+    pub sector_id: u32,
+    pub public_id_string_id: u32,
+    pub kind: u8,
+    pub closure_source_slot: u32,
+    pub closure_proof_algorithm_string_id: u32,
+    pub closure_proof_digest_id: u32,
+    pub open_string_range: CheckedTableRange,
+    pub trace_sequence_id: u32,
+    pub singlet_sequence_id: u32,
+    pub word_sequence_id: u32,
+    pub support_mask_id: u32,
+}
+
+impl ProcessPhysicalLCSectorRow {
+    pub fn kind(self) -> RusticolResult<ProcessLCSectorKind> {
+        ProcessLCSectorKind::try_from(self.kind)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessPublicLCFlowRow {
+    pub flow_id: u32,
+    pub public_id_string_id: u32,
+    pub construction_sector_id: u32,
+    pub word_sequence_id: u32,
+    pub source_slot_permutation_sequence_id: u32,
+    pub reduction_weight_factor_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessReplayPartitionRow {
+    pub partition_id: u32,
+    pub representative_sector_id: u32,
+    pub materialized_sector_id: u32,
+    pub target_range: CheckedTableRange,
+    pub proof_algorithm_string_id: u32,
+    pub proof_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessReplayTargetRow {
+    pub partition_id: u32,
+    pub sector_id: u32,
+    pub external_permutation_sequence_id: u32,
+    pub source_slot_permutation_sequence_id: u32,
+    pub amplitude_phase_factor_id: u32,
+    pub fermion_sign: i32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessSelectedPublicFlowRow {
+    pub flow_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessSelectedSourceStateRow {
+    pub source_slot: u32,
+    pub source_state_index: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessSemanticTemplateReferenceRow {
+    pub kind_string_id: u32,
+    pub template_id: u32,
+    pub semantic_digest_id: u32,
+    pub prepared_kernel_id: u32,
+}
+
+impl ProcessSemanticTemplateReferenceRow {
+    pub const fn prepared_kernel_id(self) -> Option<u32> {
+        if self.prepared_kernel_id == MISSING_ID {
+            None
+        } else {
+            Some(self.prepared_kernel_id)
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProcessSourceStateRow {
+    pub source_slot: u32,
+    pub state_index: u32,
+    pub public_helicity: i32,
+    pub chirality: i32,
+    pub spin_state: i32,
+    pub current_state_template_id: u32,
+    pub source_template_id: u32,
+    pub momentum_sign: i32,
+    pub crossing_phase_factor_id: u32,
+}
+
+/// Fixed-width header for one process-owned external-fermion pairing catalog.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct FermionPairingHeaderRow {
+    pub schema_version: u32,
+    pub abi_string_id: u32,
+    pub process_key_string_id: u32,
+    pub proof_algorithm_string_id: u32,
+    pub source_count: u32,
+    pub endpoint_count: u32,
+    pub pairing_class_count: u32,
+    pub rule_count: u32,
+    pub endpoint_state_template_count: u64,
+    pub endpoint_anti_state_template_count: u64,
+    pub endpoint_basis_count: u64,
+    pub endpoint_color_representation_count: u64,
+    pub class_fundamental_slot_count: u64,
+    pub class_antifundamental_slot_count: u64,
+    pub class_reference_pairing_count: u64,
+    pub rule_class_pairing_index_count: u64,
+    pub rule_endpoint_pairing_count: u64,
+    pub rule_source_permutation_count: u64,
+    pub rule_lineage_count: u64,
+    pub exact_integer_count: u32,
+    pub exact_integer_limb_count: u64,
+    pub string_count: u32,
+    pub string_byte_count: u64,
+    pub no_fermion_line: u32,
+    pub topology_digest: [u8; 32],
+    pub semantic_digest: [u8; 32],
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct FermionPairingEndpointRow {
+    pub endpoint_id: u32,
+    pub source_slot: u32,
+    pub public_label: u32,
+    pub species_class_id: u32,
+    pub species_string_id: u32,
+    pub particle_orientation: u8,
+    pub color_orientation: u8,
+    pub state_template_range: CheckedTableRange,
+    pub anti_state_template_range: CheckedTableRange,
+    pub basis_range: CheckedTableRange,
+    pub color_representation_range: CheckedTableRange,
+    pub contract_digest: [u8; 32],
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct FermionPairingClassRow {
+    pub class_id: u32,
+    pub species_class_id: u32,
+    pub species_string_id: u32,
+    pub fundamental_slot_range: CheckedTableRange,
+    pub antifundamental_slot_range: CheckedTableRange,
+    pub reference_pairing_range: CheckedTableRange,
+    pub pairing_count: u64,
+    pub proof_digest: [u8; 32],
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct FermionPairingRuleRow {
+    pub rule_id: u32,
+    pub class_pairing_index_range: CheckedTableRange,
+    pub endpoint_pairing_range: CheckedTableRange,
+    pub source_permutation_range: CheckedTableRange,
+    pub lineage_range: CheckedTableRange,
+    pub fermion_parity: i32,
+    pub real_numerator_integer_id: u32,
+    pub real_denominator_integer_id: u32,
+    pub imag_numerator_integer_id: u32,
+    pub imag_denominator_integer_id: u32,
+    pub multiplicity: u64,
+    pub proof_algorithm_string_id: u32,
+    pub proof_digest: [u8; 32],
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct FermionPairingClassPairingIndexRow {
+    pub class_id: u32,
+    pub pairing_index: u64,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct FermionPairingEndpointPairRow {
+    pub fundamental_source_slot: u32,
+    pub antifundamental_source_slot: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct FermionPairingExactIntegerRow {
+    pub integer_id: u32,
+    pub sign: i32,
+    pub limb_range: CheckedTableRange,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct FermionPairingInputView<'a> {
+    pub input_abi: &'a str,
+    pub declared_columnar_digest: SemanticDigest,
+    pub header: &'a [FermionPairingHeaderRow],
+    pub endpoints: &'a [FermionPairingEndpointRow],
+    pub endpoint_state_template_ids: &'a [u32],
+    pub endpoint_anti_state_template_ids: &'a [u32],
+    pub endpoint_basis_ids: &'a [u32],
+    pub endpoint_color_representations: &'a [i32],
+    pub pairing_classes: &'a [FermionPairingClassRow],
+    pub class_fundamental_slots: &'a [u32],
+    pub class_antifundamental_slots: &'a [u32],
+    pub class_reference_pairings: &'a [FermionPairingEndpointPairRow],
+    pub rules: &'a [FermionPairingRuleRow],
+    pub rule_class_pairing_indices: &'a [FermionPairingClassPairingIndexRow],
+    pub rule_endpoint_pairings: &'a [FermionPairingEndpointPairRow],
+    pub rule_source_slot_permutations: &'a [u32],
+    pub rule_lineages: &'a [u32],
+    pub exact_integers: &'a [FermionPairingExactIntegerRow],
+    pub exact_integer_limbs: &'a [u64],
+    pub string_ranges: &'a [CheckedTableRange],
+    pub string_bytes: &'a [u8],
+}
+
+#[derive(Clone, Debug)]
+pub struct OwnedFermionPairingInput {
+    pub input_abi: String,
+    pub declared_columnar_digest: SemanticDigest,
+    pub header: Vec<FermionPairingHeaderRow>,
+    pub endpoints: Vec<FermionPairingEndpointRow>,
+    pub endpoint_state_template_ids: Vec<u32>,
+    pub endpoint_anti_state_template_ids: Vec<u32>,
+    pub endpoint_basis_ids: Vec<u32>,
+    pub endpoint_color_representations: Vec<i32>,
+    pub pairing_classes: Vec<FermionPairingClassRow>,
+    pub class_fundamental_slots: Vec<u32>,
+    pub class_antifundamental_slots: Vec<u32>,
+    pub class_reference_pairings: Vec<FermionPairingEndpointPairRow>,
+    pub rules: Vec<FermionPairingRuleRow>,
+    pub rule_class_pairing_indices: Vec<FermionPairingClassPairingIndexRow>,
+    pub rule_endpoint_pairings: Vec<FermionPairingEndpointPairRow>,
+    pub rule_source_slot_permutations: Vec<u32>,
+    pub rule_lineages: Vec<u32>,
+    pub exact_integers: Vec<FermionPairingExactIntegerRow>,
+    pub exact_integer_limbs: Vec<u64>,
+    pub string_ranges: Vec<CheckedTableRange>,
+    pub string_bytes: Vec<u8>,
+}
+
+impl OwnedFermionPairingInput {
+    pub fn as_view(&self) -> FermionPairingInputView<'_> {
+        FermionPairingInputView {
+            input_abi: &self.input_abi,
+            declared_columnar_digest: self.declared_columnar_digest,
+            header: &self.header,
+            endpoints: &self.endpoints,
+            endpoint_state_template_ids: &self.endpoint_state_template_ids,
+            endpoint_anti_state_template_ids: &self.endpoint_anti_state_template_ids,
+            endpoint_basis_ids: &self.endpoint_basis_ids,
+            endpoint_color_representations: &self.endpoint_color_representations,
+            pairing_classes: &self.pairing_classes,
+            class_fundamental_slots: &self.class_fundamental_slots,
+            class_antifundamental_slots: &self.class_antifundamental_slots,
+            class_reference_pairings: &self.class_reference_pairings,
+            rules: &self.rules,
+            rule_class_pairing_indices: &self.rule_class_pairing_indices,
+            rule_endpoint_pairings: &self.rule_endpoint_pairings,
+            rule_source_slot_permutations: &self.rule_source_slot_permutations,
+            rule_lineages: &self.rule_lineages,
+            exact_integers: &self.exact_integers,
+            exact_integer_limbs: &self.exact_integer_limbs,
+            string_ranges: &self.string_ranges,
+            string_bytes: &self.string_bytes,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FermionPairingValidationSummary {
+    columnar_digest: SemanticDigest,
+    topology_digest: SemanticDigest,
+    semantic_digest: SemanticDigest,
+    source_count: u32,
+    endpoint_count: u32,
+    pairing_class_count: u32,
+    rule_count: u32,
+}
+
+impl FermionPairingValidationSummary {
+    pub const fn columnar_digest(&self) -> SemanticDigest {
+        self.columnar_digest
+    }
+
+    pub const fn topology_digest(&self) -> SemanticDigest {
+        self.topology_digest
+    }
+
+    pub const fn semantic_digest(&self) -> SemanticDigest {
+        self.semantic_digest
+    }
+
+    pub const fn source_count(&self) -> u32 {
+        self.source_count
+    }
+
+    pub const fn endpoint_count(&self) -> u32 {
+        self.endpoint_count
+    }
+
+    pub const fn pairing_class_count(&self) -> u32 {
+        self.pairing_class_count
+    }
+
+    pub const fn rule_count(&self) -> u32 {
+        self.rule_count
+    }
+}
+
+macro_rules! define_process_inputs {
+    ($( $field:ident : $item:ty ),+ $(,)?) => {
+        #[derive(Clone, Copy, Debug)]
+        pub struct RecurrenceProcessInputView<'a> {
+            pub input_abi: &'a str,
+            pub declared_input_digest: SemanticDigest,
+            pub fermion_pairing: Option<FermionPairingInputView<'a>>,
+            $(pub $field: &'a [$item],)+
+        }
+
+        #[derive(Clone, Debug)]
+        pub struct OwnedRecurrenceProcessInput {
+            pub input_abi: String,
+            pub declared_input_digest: SemanticDigest,
+            pub fermion_pairing: Option<OwnedFermionPairingInput>,
+            $(pub $field: Vec<$item>,)+
+        }
+
+        impl OwnedRecurrenceProcessInput {
+            pub fn as_view(&self) -> RecurrenceProcessInputView<'_> {
+                RecurrenceProcessInputView {
+                    input_abi: &self.input_abi,
+                    declared_input_digest: self.declared_input_digest,
+                    fermion_pairing: self.fermion_pairing.as_ref().map(OwnedFermionPairingInput::as_view),
+                    $($field: &self.$field,)+
+                }
+            }
+
+            pub fn validate(self) -> RusticolResult<ValidatedRecurrenceProcessInput> {
+                let validated = self.as_view().validate()?;
+                Ok(ValidatedRecurrenceProcessInput {
+                    input: self,
+                    summary: validated.summary,
+                    semantic_identity: validated.semantic_identity,
+                    template_references: validated.template_references,
+                    fermion_pairing_summary: validated.fermion_pairing_summary,
+                })
+            }
+        }
+    };
+}
+
+define_process_inputs! {
+    bitset_ranges: ProcessBitsetRangeRow,
+    bitset_words: u64,
+    coupling_limits: ProcessCouplingLimitRow,
+    digest_catalog: ProcessDigestCatalogRow,
+    exact_factors: ProcessExactFactorRow,
+    external_legs: ProcessExternalLegRow,
+    header: ProcessHeaderRow,
+    header_digests: ProcessHeaderDigestRow,
+    lc_open_strings: ProcessLCOpenStringRow,
+    normalization: ProcessNormalizationRow,
+    parameter_projection: ProcessParameterProjectionRow,
+    physical_lc_sectors: ProcessPhysicalLCSectorRow,
+    public_lc_flows: ProcessPublicLCFlowRow,
+    replay_partitions: ProcessReplayPartitionRow,
+    replay_targets: ProcessReplayTargetRow,
+    selected_public_flow_coverage: ProcessSelectedPublicFlowRow,
+    selected_source_coverage: ProcessSelectedSourceStateRow,
+    semantic_template_references: ProcessSemanticTemplateReferenceRow,
+    source_states: ProcessSourceStateRow,
+    string_ranges: CheckedTableRange,
+    string_bytes: u8,
+    u32_sequence_ranges: CheckedTableRange,
+    u32_sequence_values: u32,
+}
+
+/// Counts and process identity produced by process-input validation.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceProcessValidationSummary {
+    process_id: String,
+    strategy: RecurrenceStrategy,
+    selected_flow_mode: bool,
+    selected_source_mode: bool,
+    external_leg_count: u32,
+    source_state_count: u32,
+    physical_sector_count: u32,
+    public_flow_count: u32,
+    replay_partition_count: u32,
+    replay_target_count: u32,
+    template_reference_count: u32,
+}
+
+impl RecurrenceProcessValidationSummary {
+    pub fn process_id(&self) -> &str {
+        &self.process_id
+    }
+
+    pub const fn strategy(&self) -> RecurrenceStrategy {
+        self.strategy
+    }
+
+    pub const fn selected_flow_mode(&self) -> bool {
+        self.selected_flow_mode
+    }
+
+    pub const fn selected_source_mode(&self) -> bool {
+        self.selected_source_mode
+    }
+
+    pub const fn external_leg_count(&self) -> u32 {
+        self.external_leg_count
+    }
+
+    pub const fn source_state_count(&self) -> u32 {
+        self.source_state_count
+    }
+
+    pub const fn physical_sector_count(&self) -> u32 {
+        self.physical_sector_count
+    }
+
+    pub const fn public_flow_count(&self) -> u32 {
+        self.public_flow_count
+    }
+
+    pub const fn replay_partition_count(&self) -> u32 {
+        self.replay_partition_count
+    }
+
+    pub const fn replay_target_count(&self) -> u32 {
+        self.replay_target_count
+    }
+
+    pub const fn template_reference_count(&self) -> u32 {
+        self.template_reference_count
+    }
+}
+
+/// Validated process payload retained for later builder and catalog checks.
+#[derive(Clone, Debug)]
+pub struct ValidatedRecurrenceProcessInput {
+    input: OwnedRecurrenceProcessInput,
+    summary: RecurrenceProcessValidationSummary,
+    semantic_identity: RecurrenceProcessSemanticIdentity,
+    template_references: Vec<ProcessSemanticTemplateReference>,
+    fermion_pairing_summary: Option<FermionPairingValidationSummary>,
+}
+
+/// Zero-copy access to a process-owned pairing catalog after full validation.
+#[derive(Clone, Copy, Debug)]
+pub struct ValidatedFermionPairingCatalog<'a> {
+    input: FermionPairingInputView<'a>,
+    summary: &'a FermionPairingValidationSummary,
+}
+
+impl<'a> ValidatedFermionPairingCatalog<'a> {
+    pub const fn summary(self) -> &'a FermionPairingValidationSummary {
+        self.summary
+    }
+
+    pub const fn endpoints(self) -> &'a [FermionPairingEndpointRow] {
+        self.input.endpoints
+    }
+
+    pub const fn pairing_classes(self) -> &'a [FermionPairingClassRow] {
+        self.input.pairing_classes
+    }
+
+    pub const fn rules(self) -> &'a [FermionPairingRuleRow] {
+        self.input.rules
+    }
+
+    pub fn class_pairing_indices(
+        self,
+        rule: FermionPairingRuleRow,
+    ) -> RusticolResult<&'a [FermionPairingClassPairingIndexRow]> {
+        pairing_range_slice(
+            self.input.rule_class_pairing_indices,
+            rule.class_pairing_index_range,
+            "fermion pairing rule class indices",
+        )
+    }
+
+    pub fn endpoint_pairings(
+        self,
+        rule: FermionPairingRuleRow,
+    ) -> RusticolResult<&'a [FermionPairingEndpointPairRow]> {
+        pairing_range_slice(
+            self.input.rule_endpoint_pairings,
+            rule.endpoint_pairing_range,
+            "fermion pairing rule endpoint pairs",
+        )
+    }
+
+    pub fn source_slot_permutation(self, rule: FermionPairingRuleRow) -> RusticolResult<&'a [u32]> {
+        pairing_range_slice(
+            self.input.rule_source_slot_permutations,
+            rule.source_permutation_range,
+            "fermion pairing rule source permutation",
+        )
+    }
+
+    pub fn lineage(self, rule: FermionPairingRuleRow) -> RusticolResult<&'a [u32]> {
+        pairing_range_slice(
+            self.input.rule_lineages,
+            rule.lineage_range,
+            "fermion pairing rule lineage",
+        )
+    }
+}
+
+impl ValidatedRecurrenceProcessInput {
+    pub const fn input(&self) -> &OwnedRecurrenceProcessInput {
+        &self.input
+    }
+
+    pub const fn summary(&self) -> &RecurrenceProcessValidationSummary {
+        &self.summary
+    }
+
+    pub const fn semantic_identity(&self) -> &RecurrenceProcessSemanticIdentity {
+        &self.semantic_identity
+    }
+
+    pub fn template_references(&self) -> &[ProcessSemanticTemplateReference] {
+        &self.template_references
+    }
+
+    pub fn template_reference(
+        &self,
+        typed_id: ProcessSemanticTemplateId,
+    ) -> Option<&ProcessSemanticTemplateReference> {
+        self.template_references
+            .binary_search_by_key(&typed_id, |reference| reference.typed_id)
+            .ok()
+            .map(|index| &self.template_references[index])
+    }
+
+    pub fn fermion_pairing_catalog(&self) -> Option<ValidatedFermionPairingCatalog<'_>> {
+        Some(ValidatedFermionPairingCatalog {
+            input: self.input.fermion_pairing.as_ref()?.as_view(),
+            summary: self.fermion_pairing_summary.as_ref()?,
+        })
+    }
+
+    pub const fn fermion_pairing_summary(&self) -> Option<&FermionPairingValidationSummary> {
+        self.fermion_pairing_summary.as_ref()
+    }
+
+    pub fn into_input(self) -> OwnedRecurrenceProcessInput {
+        self.input
+    }
+}
+
+struct ValidatedProcessMetadata {
+    summary: RecurrenceProcessValidationSummary,
+    semantic_identity: RecurrenceProcessSemanticIdentity,
+    template_references: Vec<ProcessSemanticTemplateReference>,
+    fermion_pairing_summary: Option<FermionPairingValidationSummary>,
+}
+
+struct ProcessCatalogs<'a> {
+    strings: Vec<&'a str>,
+    digests: Vec<SemanticDigest>,
+    factors: Vec<ExactComplexRational>,
+}
+
+impl<'a> RecurrenceProcessInputView<'a> {
+    fn validate(self) -> RusticolResult<ValidatedProcessMetadata> {
+        if self.input_abi != RECURRENCE_BUILDER_INPUT_ABI {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported recurrence process input ABI {:?}; expected {:?}",
+                self.input_abi, RECURRENCE_BUILDER_INPUT_ABI
+            )));
+        }
+
+        let catalogs = self.validate_catalogs()?;
+        let (strategy, selected_flow_mode, selected_source_mode, process_id) =
+            self.validate_header(&catalogs)?;
+        let semantic_identity = self.validate_semantic_identity(&catalogs)?;
+        let template_references = self.validate_template_references(&catalogs)?;
+
+        self.validate_dense_ids()?;
+        self.validate_common_references(&catalogs)?;
+        self.validate_external_legs(&catalogs, &template_references)?;
+        self.validate_color_sectors(&catalogs)?;
+        self.validate_public_flows(&catalogs)?;
+        self.validate_replay(&catalogs, strategy)?;
+        self.validate_generation_coverage(selected_flow_mode, selected_source_mode)?;
+        self.validate_couplings_and_parameters(&catalogs, &template_references)?;
+        self.validate_normalization(&catalogs)?;
+        let fermion_pairing_summary =
+            self.validate_fermion_pairing(process_id, &semantic_identity)?;
+
+        Ok(ValidatedProcessMetadata {
+            summary: RecurrenceProcessValidationSummary {
+                process_id: process_id.to_owned(),
+                strategy,
+                selected_flow_mode,
+                selected_source_mode,
+                external_leg_count: checked_u32_len(
+                    self.external_legs.len(),
+                    "process external legs",
+                )?,
+                source_state_count: checked_u32_len(
+                    self.source_states.len(),
+                    "process source states",
+                )?,
+                physical_sector_count: checked_u32_len(
+                    self.physical_lc_sectors.len(),
+                    "physical LC sectors",
+                )?,
+                public_flow_count: checked_u32_len(self.public_lc_flows.len(), "public LC flows")?,
+                replay_partition_count: checked_u32_len(
+                    self.replay_partitions.len(),
+                    "replay partitions",
+                )?,
+                replay_target_count: checked_u32_len(self.replay_targets.len(), "replay targets")?,
+                template_reference_count: checked_u32_len(
+                    template_references.len(),
+                    "semantic-template references",
+                )?,
+            },
+            semantic_identity,
+            template_references,
+            fermion_pairing_summary,
+        })
+    }
+
+    fn validate_catalogs(self) -> RusticolResult<ProcessCatalogs<'a>> {
+        validate_packed_ranges(
+            "recurrence process strings",
+            self.string_ranges,
+            self.string_bytes.len(),
+        )?;
+        let mut strings = Vec::with_capacity(self.string_ranges.len());
+        let mut previous: Option<&[u8]> = None;
+        for (index, range) in self.string_ranges.iter().copied().enumerate() {
+            let bytes = &self.string_bytes[range
+                .as_usize_range(self.string_bytes.len(), &format!("process string {index}"))?];
+            if bytes.is_empty() {
+                return Err(invalid(format!(
+                    "recurrence process string catalog row {index} is empty"
+                )));
+            }
+            if let Some(previous) = previous
+                && previous >= bytes
+            {
+                return Err(invalid(format!(
+                    "recurrence process string catalog is not in strict canonical byte order at row {index}"
+                )));
+            }
+            let value = std::str::from_utf8(bytes).map_err(|error| {
+                invalid(format!(
+                    "recurrence process string catalog row {index} is not UTF-8: {error}"
+                ))
+            })?;
+            previous = Some(bytes);
+            strings.push(value);
+        }
+
+        validate_packed_ranges(
+            "recurrence process u32 sequences",
+            self.u32_sequence_ranges,
+            self.u32_sequence_values.len(),
+        )?;
+        let mut previous_sequence: Option<&[u32]> = None;
+        for (index, range) in self.u32_sequence_ranges.iter().copied().enumerate() {
+            let values = &self.u32_sequence_values[range.as_usize_range(
+                self.u32_sequence_values.len(),
+                &format!("process u32 sequence {index}"),
+            )?];
+            if let Some(previous) = previous_sequence
+                && previous >= values
+            {
+                return Err(invalid(format!(
+                    "recurrence process u32-sequence catalog is not in strict canonical order at row {index}"
+                )));
+            }
+            previous_sequence = Some(values);
+        }
+
+        validate_canonical_ids(
+            "process bitset catalog",
+            self.bitset_ranges.iter().map(|row| row.id),
+        )?;
+        let mask_ranges = self
+            .bitset_ranges
+            .iter()
+            .map(|row| row.range)
+            .collect::<Vec<_>>();
+        let populations = self
+            .bitset_ranges
+            .iter()
+            .map(|row| row.bit_count)
+            .collect::<Vec<_>>();
+        MultiwordMaskCatalogView {
+            ranges: &mask_ranges,
+            populations: &populations,
+            words: self.bitset_words,
+        }
+        .validate(true)?;
+
+        validate_canonical_ids(
+            "process digest catalog",
+            self.digest_catalog.iter().map(|row| row.id),
+        )?;
+        let mut digests = Vec::with_capacity(self.digest_catalog.len());
+        let mut previous_digest = None;
+        for (index, row) in self.digest_catalog.iter().enumerate() {
+            let value = SemanticDigest::new(row.value).map_err(|error| {
+                invalid(format!(
+                    "recurrence process digest catalog row {index} is invalid: {error}"
+                ))
+            })?;
+            if let Some(previous) = previous_digest
+                && previous >= value
+            {
+                return Err(invalid(format!(
+                    "recurrence process digest catalog is not in strict canonical order at row {index}"
+                )));
+            }
+            previous_digest = Some(value);
+            digests.push(value);
+        }
+
+        validate_canonical_ids(
+            "process exact-factor catalog",
+            self.exact_factors.iter().map(|row| row.id),
+        )?;
+        let mut factors = Vec::with_capacity(self.exact_factors.len());
+        let mut previous_factor = None;
+        for (index, row) in self.exact_factors.iter().enumerate() {
+            let real_numerator = required_string(
+                &strings,
+                row.real_numerator_string_id,
+                "process exact real numerator",
+            )?;
+            let real_denominator = required_string(
+                &strings,
+                row.real_denominator_string_id,
+                "process exact real denominator",
+            )?;
+            let imag_numerator = required_string(
+                &strings,
+                row.imag_numerator_string_id,
+                "process exact imaginary numerator",
+            )?;
+            let imag_denominator = required_string(
+                &strings,
+                row.imag_denominator_string_id,
+                "process exact imaginary denominator",
+            )?;
+            let factor = ExactComplexRational::parse_parts(
+                real_numerator,
+                real_denominator,
+                imag_numerator,
+                imag_denominator,
+            )
+            .map_err(|error| {
+                invalid(format!(
+                    "recurrence process exact factor {index} is invalid: {error}"
+                ))
+            })?;
+            let canonical = (
+                factor.real().numerator(),
+                factor.real().denominator(),
+                factor.imag().numerator(),
+                factor.imag().denominator(),
+            );
+            if canonical.0.to_string() != real_numerator
+                || canonical.1.to_string() != real_denominator
+                || canonical.2.to_string() != imag_numerator
+                || canonical.3.to_string() != imag_denominator
+            {
+                return Err(invalid(format!(
+                    "recurrence process exact factor {index} is not in canonical reduced decimal form"
+                )));
+            }
+            if let Some(previous) = previous_factor
+                && previous >= canonical
+            {
+                return Err(invalid(format!(
+                    "recurrence process exact-factor catalog is not in strict canonical order at row {index}"
+                )));
+            }
+            previous_factor = Some(canonical);
+            factors.push(factor);
+        }
+
+        Ok(ProcessCatalogs {
+            strings,
+            digests,
+            factors,
+        })
+    }
+
+    fn validate_header<'b>(
+        self,
+        catalogs: &'b ProcessCatalogs<'_>,
+    ) -> RusticolResult<(RecurrenceStrategy, bool, bool, &'b str)> {
+        if self.header.len() != 1 {
+            return Err(invalid(format!(
+                "recurrence process header must contain one row, found {}",
+                self.header.len()
+            )));
+        }
+        let header = self.header[0];
+        if header.schema_version != RECURRENCE_PROCESS_INPUT_SCHEMA_VERSION {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported recurrence process input schema {}; expected {}",
+                header.schema_version, RECURRENCE_PROCESS_INPUT_SCHEMA_VERSION
+            )));
+        }
+        require_string_value(
+            &catalogs.strings,
+            header.abi_string_id,
+            RECURRENCE_BUILDER_INPUT_ABI,
+            "recurrence process ABI",
+        )?;
+        let process_id = required_string(
+            &catalogs.strings,
+            header.process_id_string_id,
+            "recurrence process ID",
+        )?;
+        let strategy = header.strategy()?;
+        let selected_flow_mode = header.selected_flow_mode()?;
+        let selected_source_mode = header.selected_source_mode()?;
+
+        let expected = [
+            (
+                "external legs",
+                header.external_leg_count,
+                self.external_legs.len(),
+            ),
+            (
+                "physical LC sectors",
+                header.physical_sector_count,
+                self.physical_lc_sectors.len(),
+            ),
+            (
+                "public LC flows",
+                header.public_flow_count,
+                self.public_lc_flows.len(),
+            ),
+            (
+                "replay partitions",
+                header.replay_partition_count,
+                self.replay_partitions.len(),
+            ),
+            (
+                "coupling limits",
+                header.coupling_limit_count,
+                self.coupling_limits.len(),
+            ),
+            (
+                "parameter projections",
+                header.parameter_projection_count,
+                self.parameter_projection.len(),
+            ),
+        ];
+        for (label, declared, actual) in expected {
+            let actual = checked_u32_len(actual, label)?;
+            if declared != actual {
+                return Err(invalid(format!(
+                    "recurrence process header declares {declared} {label}, found {actual}"
+                )));
+            }
+        }
+        required_reference(
+            header.process_support_mask_id,
+            self.bitset_ranges.len(),
+            "process support mask",
+        )?;
+        if selected_flow_mode == self.selected_public_flow_coverage.is_empty() {
+            return Err(invalid(
+                "selected-flow header mode disagrees with process coverage rows",
+            ));
+        }
+        if selected_source_mode == self.selected_source_coverage.is_empty() {
+            return Err(invalid(
+                "selected-source header mode disagrees with process coverage rows",
+            ));
+        }
+        Ok((
+            strategy,
+            selected_flow_mode,
+            selected_source_mode,
+            process_id,
+        ))
+    }
+
+    fn validate_semantic_identity(
+        self,
+        catalogs: &ProcessCatalogs<'_>,
+    ) -> RusticolResult<RecurrenceProcessSemanticIdentity> {
+        if self.header_digests.len() < REQUIRED_DIGEST_ROLE_COUNT {
+            return Err(invalid(
+                "recurrence process header has too few semantic digest roles",
+            ));
+        }
+        let mut values = BTreeMap::new();
+        let mut previous_role = None;
+        for (index, row) in self.header_digests.iter().enumerate() {
+            let role_text = required_string(
+                &catalogs.strings,
+                row.role_string_id,
+                "process semantic digest role",
+            )?;
+            if let Some(previous) = previous_role
+                && previous >= role_text
+            {
+                return Err(invalid(format!(
+                    "process semantic digest roles are not in strict canonical order at row {index}"
+                )));
+            }
+            previous_role = Some(role_text);
+            let role = ProcessDigestRole::decode(role_text)?;
+            let digest =
+                required_digest(&catalogs.digests, row.digest_id, "process semantic digest")?;
+            if values.insert(role, digest).is_some() {
+                return Err(invalid(format!(
+                    "process semantic digest role {role_text:?} is repeated"
+                )));
+            }
+        }
+
+        let process_digest = take_required_role(&mut values, ProcessDigestRole::Process)?;
+        let model_catalog_digest =
+            take_required_role(&mut values, ProcessDigestRole::ModelCatalog)?;
+        let prepared_catalog_digest =
+            take_required_role(&mut values, ProcessDigestRole::PreparedCatalog)?;
+        let color_plan_digest = take_required_role(&mut values, ProcessDigestRole::ColorPlan)?;
+        let extension_digests = values
+            .into_iter()
+            .map(|(role, digest)| (role.as_str().to_owned(), digest))
+            .collect();
+        Ok(RecurrenceProcessSemanticIdentity {
+            input_digest: self.declared_input_digest,
+            process_digest,
+            model_catalog_digest,
+            prepared_catalog_digest,
+            color_plan_digest,
+            extension_digests,
+        })
+    }
+
+    fn validate_template_references(
+        self,
+        catalogs: &ProcessCatalogs<'_>,
+    ) -> RusticolResult<Vec<ProcessSemanticTemplateReference>> {
+        let mut references = Vec::with_capacity(self.semantic_template_references.len());
+        let mut seen_ids = BTreeSet::new();
+        let mut seen_digests = BTreeSet::new();
+        let mut previous_raw = None;
+        for (index, row) in self
+            .semantic_template_references
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            let kind_text = required_string(
+                &catalogs.strings,
+                row.kind_string_id,
+                "process semantic-template kind",
+            )?;
+            let raw_key = (kind_text, row.template_id);
+            if let Some(previous) = previous_raw
+                && previous >= raw_key
+            {
+                return Err(invalid(format!(
+                    "process semantic-template references are not in strict canonical order at row {index}"
+                )));
+            }
+            previous_raw = Some(raw_key);
+            let typed_id = ProcessSemanticTemplateId {
+                kind: ProcessSemanticTemplateKind::try_from(kind_text)?,
+                template_id: row.template_id,
+            };
+            if !seen_ids.insert(typed_id) {
+                return Err(invalid(format!(
+                    "process repeats semantic-template reference ({kind_text:?}, {})",
+                    row.template_id
+                )));
+            }
+            let semantic_digest = required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "semantic-template digest",
+            )?;
+            if !seen_digests.insert(semantic_digest) {
+                return Err(invalid(format!(
+                    "process semantic-template reference row {index} reuses semantic digest {semantic_digest}"
+                )));
+            }
+            references.push(ProcessSemanticTemplateReference {
+                typed_id,
+                semantic_digest,
+                prepared_kernel_id: row.prepared_kernel_id(),
+            });
+        }
+        references.sort_unstable_by_key(|reference| reference.typed_id);
+        Ok(references)
+    }
+
+    fn validate_dense_ids(self) -> RusticolResult<()> {
+        validate_canonical_ids(
+            "external source slots",
+            self.external_legs.iter().map(|row| row.source_slot),
+        )?;
+        validate_canonical_ids(
+            "physical LC sector IDs",
+            self.physical_lc_sectors.iter().map(|row| row.sector_id),
+        )?;
+        validate_canonical_ids(
+            "public LC flow IDs",
+            self.public_lc_flows.iter().map(|row| row.flow_id),
+        )?;
+        validate_canonical_ids(
+            "replay partition IDs",
+            self.replay_partitions.iter().map(|row| row.partition_id),
+        )?;
+        validate_canonical_ids(
+            "runtime parameter slots",
+            self.parameter_projection.iter().map(|row| row.runtime_slot),
+        )?;
+        Ok(())
+    }
+
+    fn validate_common_references(self, catalogs: &ProcessCatalogs<'_>) -> RusticolResult<()> {
+        let string_count = catalogs.strings.len();
+        validate_u32_references(
+            &self
+                .coupling_limits
+                .iter()
+                .map(|row| row.name_string_id)
+                .collect::<Vec<_>>(),
+            string_count,
+            "coupling-limit names",
+        )?;
+        validate_u32_references(
+            &self
+                .physical_lc_sectors
+                .iter()
+                .flat_map(|row| {
+                    [
+                        row.public_id_string_id,
+                        row.closure_proof_algorithm_string_id,
+                    ]
+                })
+                .chain(
+                    self.public_lc_flows
+                        .iter()
+                        .map(|row| row.public_id_string_id),
+                )
+                .chain(
+                    self.replay_partitions
+                        .iter()
+                        .map(|row| row.proof_algorithm_string_id),
+                )
+                .chain(
+                    self.normalization
+                        .iter()
+                        .map(|row| row.convention_string_id),
+                )
+                .chain(
+                    self.parameter_projection
+                        .iter()
+                        .map(|row| row.runtime_name_string_id),
+                )
+                .collect::<Vec<_>>(),
+            string_count,
+            "process string references",
+        )?;
+
+        validate_u32_references(
+            &self
+                .physical_lc_sectors
+                .iter()
+                .map(|row| row.closure_proof_digest_id)
+                .collect::<Vec<_>>(),
+            catalogs.digests.len(),
+            "physical LC closure proof digests",
+        )?;
+
+        let sequence_count = self.u32_sequence_ranges.len();
+        validate_u32_references(
+            &self
+                .lc_open_strings
+                .iter()
+                .flat_map(|row| [row.adjoint_sequence_id, row.singlet_sequence_id])
+                .chain(self.physical_lc_sectors.iter().flat_map(|row| {
+                    [
+                        row.trace_sequence_id,
+                        row.singlet_sequence_id,
+                        row.word_sequence_id,
+                    ]
+                }))
+                .chain(self.public_lc_flows.iter().flat_map(|row| {
+                    [
+                        row.word_sequence_id,
+                        row.source_slot_permutation_sequence_id,
+                    ]
+                }))
+                .chain(self.replay_targets.iter().flat_map(|row| {
+                    [
+                        row.external_permutation_sequence_id,
+                        row.source_slot_permutation_sequence_id,
+                    ]
+                }))
+                .collect::<Vec<_>>(),
+            sequence_count,
+            "process u32-sequence references",
+        )?;
+
+        let bitset_count = self.bitset_ranges.len();
+        validate_u32_references(
+            &self
+                .external_legs
+                .iter()
+                .flat_map(|row| [row.momentum_mask_id, row.support_mask_id])
+                .chain(
+                    self.physical_lc_sectors
+                        .iter()
+                        .map(|row| row.support_mask_id),
+                )
+                .collect::<Vec<_>>(),
+            bitset_count,
+            "process bitset references",
+        )?;
+
+        let factor_count = catalogs.factors.len();
+        validate_u32_references(
+            &self
+                .source_states
+                .iter()
+                .map(|row| row.crossing_phase_factor_id)
+                .chain(
+                    self.public_lc_flows
+                        .iter()
+                        .map(|row| row.reduction_weight_factor_id),
+                )
+                .chain(
+                    self.replay_targets
+                        .iter()
+                        .map(|row| row.amplitude_phase_factor_id),
+                )
+                .chain(self.normalization.iter().map(|row| row.factor_id))
+                .collect::<Vec<_>>(),
+            factor_count,
+            "process exact-factor references",
+        )?;
+
+        validate_u32_references(
+            &self
+                .normalization
+                .iter()
+                .map(|row| row.semantic_digest_id)
+                .chain(self.replay_partitions.iter().map(|row| row.proof_digest_id))
+                .collect::<Vec<_>>(),
+            catalogs.digests.len(),
+            "process semantic-digest references",
+        )?;
+        Ok(())
+    }
+
+    fn validate_external_legs(
+        self,
+        catalogs: &ProcessCatalogs<'_>,
+        references: &[ProcessSemanticTemplateReference],
+    ) -> RusticolResult<()> {
+        if self.external_legs.is_empty() {
+            return Err(invalid(
+                "recurrence process input requires at least one external leg",
+            ));
+        }
+        let ranges = self
+            .external_legs
+            .iter()
+            .map(|row| row.source_state_range)
+            .collect::<Vec<_>>();
+        validate_packed_ranges("external source states", &ranges, self.source_states.len())?;
+
+        let mask_ranges = self
+            .bitset_ranges
+            .iter()
+            .map(|row| row.range)
+            .collect::<Vec<_>>();
+        let populations = self
+            .bitset_ranges
+            .iter()
+            .map(|row| row.bit_count)
+            .collect::<Vec<_>>();
+        let masks = MultiwordMaskCatalogView {
+            ranges: &mask_ranges,
+            populations: &populations,
+            words: self.bitset_words,
+        };
+
+        let mut public_labels = BTreeSet::new();
+        for (source_slot, leg) in self.external_legs.iter().copied().enumerate() {
+            decode_bool(leg.is_initial, "external_legs.is_initial")?;
+            decode_bool(leg.is_fermionic, "external_legs.is_fermionic")?;
+            if !public_labels.insert(leg.public_label) {
+                return Err(invalid(format!(
+                    "external leg {source_slot} repeats public label {}",
+                    leg.public_label
+                )));
+            }
+            if leg.source_state_range.count == 0 {
+                return Err(invalid(format!(
+                    "external leg {source_slot} retains no source states"
+                )));
+            }
+            let source_slot_u32 = u32::try_from(source_slot)
+                .map_err(|_| invalid("external source slot exceeds u32"))?;
+            let momentum_population = self.bitset_ranges[leg.momentum_mask_id as usize].bit_count;
+            if momentum_population != 1
+                || !masks.contains(leg.momentum_mask_id, source_slot as u64)?
+            {
+                return Err(invalid(format!(
+                    "external leg {source_slot} momentum mask must contain exactly its source slot"
+                )));
+            }
+
+            let rows = leg.source_state_range.as_usize_range(
+                self.source_states.len(),
+                &format!("external leg {source_slot} source states"),
+            )?;
+            let mut helicities = BTreeSet::new();
+            let mut source_template_ids = BTreeSet::new();
+            for (state_index, row_index) in rows.enumerate() {
+                let state = self.source_states[row_index];
+                if state.source_slot != source_slot_u32 {
+                    return Err(invalid(format!(
+                        "source-state row {row_index} belongs to source slot {}, expected {source_slot_u32}",
+                        state.source_slot
+                    )));
+                }
+                let expected_state_index = u32::try_from(state_index)
+                    .map_err(|_| invalid("source-state index exceeds u32"))?;
+                if state.state_index != expected_state_index {
+                    return Err(invalid(format!(
+                        "source-state row {row_index} has local index {}, expected {expected_state_index}",
+                        state.state_index
+                    )));
+                }
+                if !helicities.insert(state.public_helicity) {
+                    return Err(invalid(format!(
+                        "external leg {source_slot} repeats public helicity {}",
+                        state.public_helicity
+                    )));
+                }
+                if !source_template_ids.insert(state.source_template_id) {
+                    return Err(invalid(format!(
+                        "external leg {source_slot} repeats source template {}",
+                        state.source_template_id
+                    )));
+                }
+                validate_concrete_spin_state(
+                    state.spin_state,
+                    &format!("source-state row {row_index} spin state"),
+                )?;
+                if !matches!(state.momentum_sign, -1 | 1) {
+                    return Err(invalid(format!(
+                        "source-state row {row_index} momentum sign must be -1 or 1"
+                    )));
+                }
+                require_process_template(
+                    references,
+                    ProcessSemanticTemplateId {
+                        kind: ProcessSemanticTemplateKind::CurrentState,
+                        template_id: state.current_state_template_id,
+                    },
+                    &format!("source-state row {row_index} current state"),
+                )?;
+                require_process_template(
+                    references,
+                    ProcessSemanticTemplateId {
+                        kind: ProcessSemanticTemplateKind::Source,
+                        template_id: state.source_template_id,
+                    },
+                    &format!("source-state row {row_index} source template"),
+                )?;
+                required_reference(
+                    state.crossing_phase_factor_id,
+                    catalogs.factors.len(),
+                    "source-state crossing phase",
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_color_sectors(self, catalogs: &ProcessCatalogs<'_>) -> RusticolResult<()> {
+        if self.physical_lc_sectors.is_empty() {
+            return Err(invalid(
+                "recurrence process input requires at least one physical LC sector",
+            ));
+        }
+        let ranges = self
+            .physical_lc_sectors
+            .iter()
+            .map(|row| row.open_string_range)
+            .collect::<Vec<_>>();
+        validate_packed_ranges(
+            "physical LC open strings",
+            &ranges,
+            self.lc_open_strings.len(),
+        )?;
+
+        let mut public_ids = BTreeSet::new();
+        for (sector_index, sector) in self.physical_lc_sectors.iter().copied().enumerate() {
+            let public_id = required_string(
+                &catalogs.strings,
+                sector.public_id_string_id,
+                "physical LC sector public ID",
+            )?;
+            if !public_ids.insert(public_id) {
+                return Err(invalid(format!(
+                    "physical LC sector {sector_index} repeats public identifier {public_id:?}"
+                )));
+            }
+            let kind = sector.kind()?;
+            required_reference(
+                sector.closure_source_slot,
+                self.external_legs.len(),
+                "physical LC closure source slot",
+            )?;
+            let closure_algorithm = required_string(
+                &catalogs.strings,
+                sector.closure_proof_algorithm_string_id,
+                "physical LC closure-anchor proof algorithm",
+            )?;
+            if !matches!(
+                closure_algorithm,
+                "canonical-lc-closure-anchor-v2"
+                    | "canonical-lc-closure-anchor-v3"
+                    | "canonical-lc-closure-anchor-v4"
+            ) {
+                return Err(invalid(format!(
+                    "physical LC sector {sector_index} uses unsupported closure-anchor proof algorithm {closure_algorithm:?}"
+                )));
+            }
+            let closure_proof_digest = required_digest(
+                &catalogs.digests,
+                sector.closure_proof_digest_id,
+                "physical LC closure-anchor proof digest",
+            )?;
+            let trace = self.sequence(
+                sector.trace_sequence_id,
+                &format!("physical LC sector {sector_index} trace"),
+            )?;
+            let singlets = self.sequence(
+                sector.singlet_sequence_id,
+                &format!("physical LC sector {sector_index} singlets"),
+            )?;
+            let word = self.sequence(
+                sector.word_sequence_id,
+                &format!("physical LC sector {sector_index} word"),
+            )?;
+            validate_source_slot_sequence(
+                trace,
+                self.external_legs.len(),
+                &format!("physical LC sector {sector_index} trace"),
+            )?;
+            validate_source_slot_sequence(
+                singlets,
+                self.external_legs.len(),
+                &format!("physical LC sector {sector_index} singlets"),
+            )?;
+            validate_source_slot_sequence(
+                word,
+                self.external_legs.len(),
+                &format!("physical LC sector {sector_index} word"),
+            )?;
+            if let Some(expected_anchor) = word.last().copied() {
+                if closure_algorithm == "canonical-lc-closure-anchor-v2"
+                    && sector.closure_source_slot != expected_anchor
+                {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} v2 closure source slot {} does not match terminal color-word endpoint {expected_anchor}",
+                        sector.closure_source_slot
+                    )));
+                }
+                if closure_algorithm == "canonical-lc-closure-anchor-v3"
+                    && kind != ProcessLCSectorKind::OpenLines
+                    && sector.closure_source_slot != expected_anchor
+                {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} v3 non-open-line closure source slot {} does not match terminal color-word endpoint {expected_anchor}",
+                        sector.closure_source_slot
+                    )));
+                }
+            } else if kind != ProcessLCSectorKind::Singlet {
+                return Err(invalid(format!(
+                    "non-singlet LC sector {sector_index} has no color word for its closure anchor"
+                )));
+            }
+
+            match kind {
+                ProcessLCSectorKind::OpenLines if sector.open_string_range.count == 0 => {
+                    return Err(invalid(format!(
+                        "open-lines LC sector {sector_index} has no open strings"
+                    )));
+                }
+                ProcessLCSectorKind::OpenLines if !trace.is_empty() => {
+                    return Err(invalid(format!(
+                        "open-lines LC sector {sector_index} unexpectedly carries a trace"
+                    )));
+                }
+                ProcessLCSectorKind::SingleTrace if trace.is_empty() => {
+                    return Err(invalid(format!(
+                        "single-trace LC sector {sector_index} has an empty trace"
+                    )));
+                }
+                ProcessLCSectorKind::SingleTrace if sector.open_string_range.count != 0 => {
+                    return Err(invalid(format!(
+                        "single-trace LC sector {sector_index} carries open strings"
+                    )));
+                }
+                ProcessLCSectorKind::Singlet
+                    if sector.open_string_range.count != 0 || !trace.is_empty() =>
+                {
+                    return Err(invalid(format!(
+                        "singlet LC sector {sector_index} carries colored strings"
+                    )));
+                }
+                _ => {}
+            }
+
+            let rows = sector.open_string_range.as_usize_range(
+                self.lc_open_strings.len(),
+                &format!("physical LC sector {sector_index} open strings"),
+            )?;
+            let mut open_blocks = Vec::new();
+            for (ordinal, row_index) in rows.enumerate() {
+                let line = self.lc_open_strings[row_index];
+                let expected_sector = u32::try_from(sector_index)
+                    .map_err(|_| invalid("physical LC sector index exceeds u32"))?;
+                let expected_ordinal = u32::try_from(ordinal)
+                    .map_err(|_| invalid("LC open-string ordinal exceeds u32"))?;
+                if line.sector_id != expected_sector || line.ordinal != expected_ordinal {
+                    return Err(invalid(format!(
+                        "LC open-string row {row_index} has parent/ordinal ({}, {}), expected ({expected_sector}, {expected_ordinal})",
+                        line.sector_id, line.ordinal
+                    )));
+                }
+                required_reference(
+                    line.fundamental_source_slot,
+                    self.external_legs.len(),
+                    "LC fundamental source slot",
+                )?;
+                required_reference(
+                    line.antifundamental_source_slot,
+                    self.external_legs.len(),
+                    "LC antifundamental source slot",
+                )?;
+                let adjoints = self.sequence(
+                    line.adjoint_sequence_id,
+                    &format!("LC open-string row {row_index} adjoints"),
+                )?;
+                let line_singlets = self.sequence(
+                    line.singlet_sequence_id,
+                    &format!("LC open-string row {row_index} singlets"),
+                )?;
+                validate_source_slot_sequence(
+                    adjoints,
+                    self.external_legs.len(),
+                    &format!("LC open-string row {row_index} adjoints"),
+                )?;
+                validate_source_slot_sequence(
+                    line_singlets,
+                    self.external_legs.len(),
+                    &format!("LC open-string row {row_index} singlets"),
+                )?;
+                let mut block = Vec::with_capacity(adjoints.len() + 2);
+                block.push(line.fundamental_source_slot);
+                block.extend_from_slice(adjoints);
+                block.push(line.antifundamental_source_slot);
+                open_blocks.push(block);
+            }
+            if closure_algorithm == "canonical-lc-closure-anchor-v4" {
+                if kind != ProcessLCSectorKind::SingleTrace
+                    || sector.open_string_range.count != 0
+                    || !singlets.is_empty()
+                    || trace != word
+                {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} v4 closure anchoring requires one complete cyclic single-trace source domain"
+                    )));
+                }
+                let mut sorted_word = word.to_vec();
+                sorted_word.sort_unstable();
+                let expected_domain = (0..self.external_legs.len())
+                    .map(|slot| {
+                        u32::try_from(slot).map_err(|_| invalid("external source slot exceeds u32"))
+                    })
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                if sorted_word != expected_domain {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} v4 trace does not cover every external source exactly once"
+                    )));
+                }
+                let expected_anchor = word.iter().copied().min().ok_or_else(|| {
+                    invalid(format!(
+                        "physical LC sector {sector_index} v4 colour word is empty"
+                    ))
+                })?;
+                if sector.closure_source_slot != expected_anchor {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} v4 closure source slot {} is not the minimum cyclic trace source {expected_anchor}",
+                        sector.closure_source_slot
+                    )));
+                }
+                let fermionic_source_slots = self
+                    .external_legs
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, leg)| leg.is_fermionic == 1)
+                    .map(|(slot, _)| {
+                        u32::try_from(slot).map_err(|_| invalid("external source slot exceeds u32"))
+                    })
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                let mut state_template_ids = BTreeSet::new();
+                for (source_slot, leg) in self.external_legs.iter().copied().enumerate() {
+                    let rows = leg.source_state_range.as_usize_range(
+                        self.source_states.len(),
+                        &format!(
+                            "physical LC sector {sector_index} v4 source {source_slot} states"
+                        ),
+                    )?;
+                    if rows.is_empty() {
+                        return Err(invalid(format!(
+                            "physical LC sector {sector_index} v4 source {source_slot} has no current-state contract"
+                        )));
+                    }
+                    state_template_ids.extend(
+                        self.source_states[rows]
+                            .iter()
+                            .map(|state| state.current_state_template_id),
+                    );
+                }
+                if !fermionic_source_slots.is_empty() || state_template_ids.len() != 1 {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} v4 closure anchoring requires one nonfermionic current-state template across every source"
+                    )));
+                }
+            }
+            if closure_algorithm == "canonical-lc-closure-anchor-v3" {
+                if kind != ProcessLCSectorKind::OpenLines {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} uses v3 closure anchoring outside an open-line sector"
+                    )));
+                }
+                let mut physical_blocks = Vec::with_capacity(open_blocks.len());
+                let mut used = vec![false; open_blocks.len()];
+                let mut cursor = 0usize;
+                while cursor < word.len() {
+                    let matches = open_blocks
+                        .iter()
+                        .enumerate()
+                        .filter_map(|(index, block)| {
+                            (!used[index]
+                                && word.get(cursor..cursor.saturating_add(block.len()))
+                                    == Some(block.as_slice()))
+                            .then_some(index)
+                        })
+                        .collect::<Vec<_>>();
+                    if matches.len() != 1 {
+                        return Err(invalid(format!(
+                            "physical LC sector {sector_index} v3 public word has {} open-line block matches at source position {cursor}",
+                            matches.len()
+                        )));
+                    }
+                    let block_index = matches[0];
+                    used[block_index] = true;
+                    cursor = cursor.saturating_add(open_blocks[block_index].len());
+                    physical_blocks.push(open_blocks[block_index].clone());
+                }
+                if cursor != word.len()
+                    || physical_blocks.len() != open_blocks.len()
+                    || used.iter().any(|value| !value)
+                {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} v3 public word is not an exact complete-open-line block traversal"
+                    )));
+                }
+                let distinguished_source_slot = word.iter().copied().min().ok_or_else(|| {
+                    invalid(format!(
+                        "physical LC sector {sector_index} v3 colour word is empty"
+                    ))
+                })?;
+                let distinguished_positions = physical_blocks
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(index, block)| {
+                        block.contains(&distinguished_source_slot).then_some(index)
+                    })
+                    .collect::<Vec<_>>();
+                if distinguished_positions.len() != 1 {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} v3 minimum coloured source slot belongs to {} open-line blocks",
+                        distinguished_positions.len()
+                    )));
+                }
+                let first = distinguished_positions[0];
+                let closure_blocks = physical_blocks[first..]
+                    .iter()
+                    .chain(physical_blocks[..first].iter())
+                    .cloned()
+                    .collect::<Vec<_>>();
+                let closure_traversal = closure_blocks
+                    .iter()
+                    .flat_map(|block| block.iter().copied())
+                    .collect::<Vec<_>>();
+                let expected_anchor = closure_traversal.last().copied().ok_or_else(|| {
+                    invalid(format!(
+                        "physical LC sector {sector_index} v3 closure traversal is empty"
+                    ))
+                })?;
+                if sector.closure_source_slot != expected_anchor {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} v3 closure source slot {} does not match independently reconstructed minimum-coloured-source block rotation endpoint {expected_anchor}",
+                        sector.closure_source_slot
+                    )));
+                }
+                let process_source_label_order = self
+                    .external_legs
+                    .iter()
+                    .map(|leg| leg.public_label)
+                    .collect::<Vec<_>>();
+                let fermionic_source_slots = self
+                    .external_legs
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, leg)| leg.is_fermionic == 1)
+                    .map(|(slot, _)| {
+                        u32::try_from(slot).map_err(|_| invalid("external source slot exceeds u32"))
+                    })
+                    .collect::<RusticolResult<Vec<_>>>()?;
+                let sector_kind = match kind {
+                    ProcessLCSectorKind::OpenLines => "open-lines",
+                    ProcessLCSectorKind::SingleTrace => "single-trace",
+                    ProcessLCSectorKind::Singlet => "singlet",
+                };
+                let payload = json!({
+                    "algorithm": "canonical-lc-closure-anchor-v3",
+                    "closure_block_source_slots": closure_blocks,
+                    "closure_source_slot": sector.closure_source_slot,
+                    "closure_traversal_source_slots": closure_traversal,
+                    "component_order_policy": if open_blocks.len() > 1 {
+                        "independent-open-string-block-permutation"
+                    } else {
+                        "exact-ordered-components"
+                    },
+                    "distinguished_source_block": closure_blocks[0],
+                    "distinguished_source_slot": distinguished_source_slot,
+                    "external_source_count": self.external_legs.len(),
+                    "fermionic_source_slots": fermionic_source_slots,
+                    "open_string_count": open_blocks.len(),
+                    "physical_block_source_slots": physical_blocks,
+                    "policy": "minimum-coloured-source-slot-open-line-block-rotation",
+                    "process_source_label_order": process_source_label_order,
+                    "sector_id": sector.sector_id,
+                    "sector_kind": sector_kind,
+                    "selected_closure_block": closure_blocks.last().ok_or_else(|| {
+                        invalid(format!(
+                            "physical LC sector {sector_index} v3 has no selected closure block"
+                        ))
+                    })?,
+                    "singlet_source_slots": singlets,
+                    "word_source_slots": word,
+                });
+                let canonical = serde_json::to_vec(&payload).map_err(|error| {
+                    invalid(format!(
+                        "physical LC sector {sector_index} v3 closure proof cannot be canonicalized: {error}"
+                    ))
+                })?;
+                let expected_digest: [u8; 32] = Sha256::digest(canonical).into();
+                if closure_proof_digest.as_bytes() != &expected_digest {
+                    return Err(invalid(format!(
+                        "physical LC sector {sector_index} v3 closure proof digest does not match the independently reconstructed minimum-coloured-source block rotation"
+                    )));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_public_flows(self, catalogs: &ProcessCatalogs<'_>) -> RusticolResult<()> {
+        if self.public_lc_flows.is_empty() {
+            return Err(invalid(
+                "recurrence process input requires at least one public LC flow",
+            ));
+        }
+        let mut public_ids = BTreeSet::new();
+        for (flow_index, flow) in self.public_lc_flows.iter().copied().enumerate() {
+            let public_id = required_string(
+                &catalogs.strings,
+                flow.public_id_string_id,
+                "public LC flow identifier",
+            )?;
+            if !public_ids.insert(public_id) {
+                return Err(invalid(format!(
+                    "public LC flow {flow_index} repeats identifier {public_id:?}"
+                )));
+            }
+            let construction_sector = self
+                .physical_lc_sectors
+                .get(required_reference(
+                    flow.construction_sector_id,
+                    self.physical_lc_sectors.len(),
+                    "public-flow construction sector",
+                )?)
+                .copied()
+                .ok_or_else(|| invalid("validated construction sector disappeared"))?;
+            let permutation = self.sequence(
+                flow.source_slot_permutation_sequence_id,
+                &format!("public LC flow {flow_index} source permutation"),
+            )?;
+            validate_permutation(
+                permutation,
+                self.external_legs.len(),
+                &format!("public LC flow {flow_index} source permutation"),
+            )?;
+            self.validate_source_contract_permutation(
+                permutation,
+                &format!("public LC flow {flow_index}"),
+            )?;
+            let construction_word = self.sequence(
+                construction_sector.word_sequence_id,
+                &format!("public LC flow {flow_index} construction word"),
+            )?;
+            let public_word = self.sequence(
+                flow.word_sequence_id,
+                &format!("public LC flow {flow_index} word"),
+            )?;
+            let reflected_trace = construction_sector.kind()? == ProcessLCSectorKind::SingleTrace
+                && construction_word.len() > 2
+                && permutation
+                    .iter()
+                    .copied()
+                    .eq(0..u32::try_from(permutation.len())
+                        .map_err(|_| invalid("public LC flow source count exceeds u32"))?)
+                && public_word.first() == construction_word.first()
+                && public_word[1..]
+                    .iter()
+                    .copied()
+                    .eq(construction_word[1..].iter().rev().copied());
+            if !reflected_trace {
+                validate_mapped_word(
+                    construction_word,
+                    permutation,
+                    public_word,
+                    &format!("public LC flow {flow_index}"),
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_replay(
+        self,
+        _catalogs: &ProcessCatalogs<'_>,
+        strategy: RecurrenceStrategy,
+    ) -> RusticolResult<()> {
+        if !strategy.uses_topology_replay_targets()
+            && (!self.replay_partitions.is_empty() || !self.replay_targets.is_empty())
+        {
+            return Err(invalid(
+                "non-replay recurrence input must not carry topology-replay rows",
+            ));
+        }
+        let ranges = self
+            .replay_partitions
+            .iter()
+            .map(|row| row.target_range)
+            .collect::<Vec<_>>();
+        validate_packed_ranges(
+            "replay partition targets",
+            &ranges,
+            self.replay_targets.len(),
+        )?;
+
+        let mut covered_sectors = BTreeSet::new();
+        for (partition_index, partition) in self.replay_partitions.iter().copied().enumerate() {
+            required_reference(
+                partition.representative_sector_id,
+                self.physical_lc_sectors.len(),
+                "replay representative sector",
+            )?;
+            required_reference(
+                partition.materialized_sector_id,
+                self.physical_lc_sectors.len(),
+                "replay materialized sector",
+            )?;
+            if partition.target_range.count == 0 {
+                return Err(invalid(format!(
+                    "replay partition {partition_index} has no targets"
+                )));
+            }
+            let representative_word_id = self.physical_lc_sectors
+                [partition.representative_sector_id as usize]
+                .word_sequence_id;
+            let representative_word = self.sequence(
+                representative_word_id,
+                &format!("replay partition {partition_index} representative word"),
+            )?;
+            let representative_anchor = self.physical_lc_sectors
+                [partition.representative_sector_id as usize]
+                .closure_source_slot;
+            let rows = partition.target_range.as_usize_range(
+                self.replay_targets.len(),
+                &format!("replay partition {partition_index} targets"),
+            )?;
+            let mut contains_representative = false;
+            for row_index in rows {
+                let target = self.replay_targets[row_index];
+                let expected_partition = u32::try_from(partition_index)
+                    .map_err(|_| invalid("replay partition index exceeds u32"))?;
+                if target.partition_id != expected_partition {
+                    return Err(invalid(format!(
+                        "replay target row {row_index} belongs to partition {}, expected {expected_partition}",
+                        target.partition_id
+                    )));
+                }
+                required_reference(
+                    target.sector_id,
+                    self.physical_lc_sectors.len(),
+                    "replay target sector",
+                )?;
+                if !covered_sectors.insert(target.sector_id) {
+                    return Err(invalid(format!(
+                        "physical LC sector {} belongs to multiple replay partitions",
+                        target.sector_id
+                    )));
+                }
+                contains_representative |= target.sector_id == partition.representative_sector_id;
+                if !matches!(target.fermion_sign, -1 | 1) {
+                    return Err(invalid(format!(
+                        "replay target row {row_index} fermion sign must be -1 or 1"
+                    )));
+                }
+                let external_permutation = self.sequence(
+                    target.external_permutation_sequence_id,
+                    &format!("replay target row {row_index} external permutation"),
+                )?;
+                let source_permutation = self.sequence(
+                    target.source_slot_permutation_sequence_id,
+                    &format!("replay target row {row_index} source permutation"),
+                )?;
+                validate_permutation(
+                    external_permutation,
+                    self.external_legs.len(),
+                    &format!("replay target row {row_index} external permutation"),
+                )?;
+                validate_permutation(
+                    source_permutation,
+                    self.external_legs.len(),
+                    &format!("replay target row {row_index} source permutation"),
+                )?;
+                if external_permutation != source_permutation {
+                    return Err(invalid(format!(
+                        "replay target row {row_index} external and source permutations differ"
+                    )));
+                }
+                self.validate_source_contract_permutation(
+                    source_permutation,
+                    &format!("replay target row {row_index}"),
+                )?;
+                let target_word_id =
+                    self.physical_lc_sectors[target.sector_id as usize].word_sequence_id;
+                let target_word = self.sequence(
+                    target_word_id,
+                    &format!("replay target row {row_index} target word"),
+                )?;
+                validate_mapped_word(
+                    representative_word,
+                    source_permutation,
+                    target_word,
+                    &format!("replay target row {row_index}"),
+                )?;
+                let target_anchor =
+                    self.physical_lc_sectors[target.sector_id as usize].closure_source_slot;
+                let mapped_anchor = *source_permutation
+                    .get(representative_anchor as usize)
+                    .ok_or_else(|| {
+                        invalid("replay representative closure anchor is out of range")
+                    })?;
+                if mapped_anchor != target_anchor {
+                    return Err(invalid(format!(
+                        "replay target row {row_index} maps representative closure anchor {representative_anchor} to {mapped_anchor}, expected {target_anchor}"
+                    )));
+                }
+            }
+            if !contains_representative {
+                return Err(invalid(format!(
+                    "replay partition {partition_index} does not contain its representative sector"
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_source_contract_permutation(
+        self,
+        permutation: &[u32],
+        context: &str,
+    ) -> RusticolResult<()> {
+        for (representative_slot, target_slot) in permutation.iter().copied().enumerate() {
+            let target_slot = required_reference(
+                target_slot,
+                self.external_legs.len(),
+                "replay target source slot",
+            )?;
+            let representative = self.external_legs[representative_slot];
+            let target = self.external_legs[target_slot];
+            if representative.is_initial != target.is_initial {
+                return Err(invalid(format!(
+                    "{context} maps source slot {representative_slot} across the initial/final crossing boundary"
+                )));
+            }
+            let contracts = |leg: ProcessExternalLegRow,
+                             label: &str|
+             -> RusticolResult<BTreeMap<u32, (i32, u32)>> {
+                let rows = leg.source_state_range.as_usize_range(
+                    self.source_states.len(),
+                    &format!("{context} {label} source states"),
+                )?;
+                let mut result = BTreeMap::new();
+                for row_index in rows {
+                    let state = self.source_states[row_index];
+                    if result
+                        .insert(
+                            state.source_template_id,
+                            (state.momentum_sign, state.crossing_phase_factor_id),
+                        )
+                        .is_some()
+                    {
+                        return Err(invalid(format!(
+                            "{context} {label} repeats source template {}",
+                            state.source_template_id
+                        )));
+                    }
+                }
+                Ok(result)
+            };
+            let representative_contracts = contracts(representative, "representative")?;
+            let target_contracts = contracts(target, "target")?;
+            if representative_contracts != target_contracts {
+                return Err(invalid(format!(
+                    "{context} maps source slot {representative_slot} onto slot {target_slot} with a different source crossing contract"
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_generation_coverage(
+        self,
+        selected_flow_mode: bool,
+        selected_source_mode: bool,
+    ) -> RusticolResult<()> {
+        if selected_flow_mode == self.selected_public_flow_coverage.is_empty() {
+            return Err(invalid(
+                "selected-flow mode disagrees with generation coverage rows",
+            ));
+        }
+        if selected_source_mode == self.selected_source_coverage.is_empty() {
+            return Err(invalid(
+                "selected-source mode disagrees with generation coverage rows",
+            ));
+        }
+        let selected_flows = self
+            .selected_public_flow_coverage
+            .iter()
+            .map(|row| row.flow_id)
+            .collect::<Vec<_>>();
+        validate_strict_ids("selected public-flow coverage", &selected_flows)?;
+        validate_u32_references(
+            &selected_flows,
+            self.public_lc_flows.len(),
+            "selected public-flow coverage",
+        )?;
+
+        let mut previous = None;
+        let mut covered_source_slots = BTreeSet::new();
+        for (row_index, row) in self.selected_source_coverage.iter().copied().enumerate() {
+            let key = (row.source_slot, row.source_state_index);
+            if let Some(previous) = previous
+                && previous >= key
+            {
+                return Err(invalid(format!(
+                    "selected source coverage is not in strict canonical order at row {row_index}"
+                )));
+            }
+            previous = Some(key);
+            let leg = self
+                .external_legs
+                .get(required_reference(
+                    row.source_slot,
+                    self.external_legs.len(),
+                    "selected source slot",
+                )?)
+                .ok_or_else(|| invalid("validated selected source slot disappeared"))?;
+            if u64::from(row.source_state_index) >= leg.source_state_range.count {
+                return Err(invalid(format!(
+                    "selected source coverage row {row_index} references absent state {} for source slot {}",
+                    row.source_state_index, row.source_slot
+                )));
+            }
+            covered_source_slots.insert(row.source_slot);
+        }
+        if selected_source_mode && covered_source_slots.len() != self.external_legs.len() {
+            return Err(invalid(
+                "selected source coverage must retain at least one state for every external source slot",
+            ));
+        }
+        Ok(())
+    }
+
+    fn validate_couplings_and_parameters(
+        self,
+        catalogs: &ProcessCatalogs<'_>,
+        references: &[ProcessSemanticTemplateReference],
+    ) -> RusticolResult<()> {
+        let mut previous_name = None;
+        for (row_index, row) in self.coupling_limits.iter().copied().enumerate() {
+            let name =
+                required_string(&catalogs.strings, row.name_string_id, "coupling-limit name")?;
+            if let Some(previous) = previous_name
+                && previous >= name
+            {
+                return Err(invalid(format!(
+                    "coupling limits are not in strict canonical name order at row {row_index}"
+                )));
+            }
+            previous_name = Some(name);
+            if row.minimum > row.maximum {
+                return Err(invalid(format!(
+                    "coupling limit {name:?} minimum {} exceeds maximum {}",
+                    row.minimum, row.maximum
+                )));
+            }
+        }
+
+        let mut runtime_components = BTreeSet::new();
+        for (row_index, row) in self.parameter_projection.iter().copied().enumerate() {
+            let runtime_name = required_string(
+                &catalogs.strings,
+                row.runtime_name_string_id,
+                "runtime parameter name",
+            )?;
+            if !runtime_components.insert((runtime_name, row.component)) {
+                return Err(invalid(format!(
+                    "parameter projection row {row_index} repeats runtime parameter component ({runtime_name:?}, {})",
+                    row.component
+                )));
+            }
+            require_process_template(
+                references,
+                ProcessSemanticTemplateId {
+                    kind: ProcessSemanticTemplateKind::Parameter,
+                    template_id: row.parameter_template_id,
+                },
+                &format!("parameter projection row {row_index}"),
+            )?;
+        }
+        Ok(())
+    }
+
+    fn validate_normalization(self, catalogs: &ProcessCatalogs<'_>) -> RusticolResult<()> {
+        if self.normalization.len() != 1 {
+            return Err(invalid(format!(
+                "recurrence process normalization must contain one row, found {}",
+                self.normalization.len()
+            )));
+        }
+        let row = self.normalization[0];
+        required_reference(
+            row.factor_id,
+            catalogs.factors.len(),
+            "process normalization factor",
+        )?;
+        required_string(
+            &catalogs.strings,
+            row.convention_string_id,
+            "process normalization convention",
+        )?;
+        required_digest(
+            &catalogs.digests,
+            row.semantic_digest_id,
+            "process normalization semantic digest",
+        )?;
+        Ok(())
+    }
+
+    fn validate_fermion_pairing(
+        self,
+        process_id: &str,
+        semantic_identity: &RecurrenceProcessSemanticIdentity,
+    ) -> RusticolResult<Option<FermionPairingValidationSummary>> {
+        let topology_role = semantic_identity
+            .extension_digests()
+            .get("fermion-pairing-topology")
+            .copied();
+        let semantic_role = semantic_identity
+            .extension_digests()
+            .get("fermion-pairing-semantic")
+            .copied();
+        let Some(pairing) = self.fermion_pairing else {
+            if topology_role.is_some() || semantic_role.is_some() {
+                return Err(invalid(
+                    "recurrence process claims fermion-pairing digests without pairing tables",
+                ));
+            }
+            return Ok(None);
+        };
+        let topology_role = topology_role.ok_or_else(|| {
+            invalid("recurrence fermion-pairing tables lack their topology digest role")
+        })?;
+        let semantic_role = semantic_role.ok_or_else(|| {
+            invalid("recurrence fermion-pairing tables lack their semantic digest role")
+        })?;
+        let summary = pairing.validate_internal(process_id)?;
+        if summary.topology_digest != topology_role {
+            return Err(invalid(
+                "fermion-pairing topology digest disagrees with the process semantic identity",
+            ));
+        }
+        if summary.semantic_digest != semantic_role {
+            return Err(invalid(
+                "fermion-pairing semantic digest disagrees with the process semantic identity",
+            ));
+        }
+        if summary.source_count as usize != self.external_legs.len() {
+            return Err(invalid(
+                "fermion-pairing source count does not match recurrence external legs",
+            ));
+        }
+
+        let mut expected_orientations = BTreeMap::<u32, u8>::new();
+        for line in self.lc_open_strings {
+            for (source_slot, orientation) in [
+                (line.fundamental_source_slot, 0_u8),
+                (line.antifundamental_source_slot, 1_u8),
+            ] {
+                if let Some(previous) = expected_orientations.insert(source_slot, orientation)
+                    && previous != orientation
+                {
+                    return Err(invalid(
+                        "LC sectors assign inconsistent orientations to one fermion endpoint",
+                    ));
+                }
+            }
+        }
+        let endpoint_slots = pairing
+            .endpoints
+            .iter()
+            .map(|row| row.source_slot)
+            .collect::<BTreeSet<_>>();
+        if endpoint_slots != expected_orientations.keys().copied().collect() {
+            return Err(invalid(
+                "fermion-pairing endpoints do not cover the LC open-line endpoints",
+            ));
+        }
+        for endpoint in pairing.endpoints {
+            let source = self
+                .external_legs
+                .get(required_reference(
+                    endpoint.source_slot,
+                    self.external_legs.len(),
+                    "fermion-pairing endpoint source",
+                )?)
+                .ok_or_else(|| invalid("validated pairing endpoint source disappeared"))?;
+            if !decode_bool(source.is_fermionic, "external_legs.is_fermionic")? {
+                return Err(invalid(
+                    "fermion-pairing endpoint references a non-fermionic source",
+                ));
+            }
+            if endpoint.public_label != source.public_label {
+                return Err(invalid(
+                    "fermion-pairing endpoint public label disagrees with its source",
+                ));
+            }
+            if Some(&endpoint.color_orientation) != expected_orientations.get(&endpoint.source_slot)
+            {
+                return Err(invalid(
+                    "fermion-pairing endpoint orientation disagrees with LC sectors",
+                ));
+            }
+        }
+        Ok(Some(summary))
+    }
+
+    fn sequence(self, sequence_id: u32, label: &str) -> RusticolResult<&'a [u32]> {
+        let range = self
+            .u32_sequence_ranges
+            .get(required_reference(
+                sequence_id,
+                self.u32_sequence_ranges.len(),
+                label,
+            )?)
+            .copied()
+            .ok_or_else(|| invalid(format!("validated {label} disappeared")))?;
+        let values = &self.u32_sequence_values
+            [range.as_usize_range(self.u32_sequence_values.len(), label)?];
+        Ok(values)
+    }
+}
+
+fn pairing_range_slice<'a, T>(
+    values: &'a [T],
+    range: CheckedTableRange,
+    label: &str,
+) -> RusticolResult<&'a [T]> {
+    Ok(&values[range.as_usize_range(values.len(), label)?])
+}
+
+fn checked_factorial_u64(value: usize, label: &str) -> RusticolResult<u64> {
+    (2..=value).try_fold(1_u64, |product, factor| {
+        let factor =
+            u64::try_from(factor).map_err(|_| invalid(format!("{label} factor exceeds u64")))?;
+        product
+            .checked_mul(factor)
+            .ok_or_else(|| invalid(format!("{label} exceeds u64")))
+    })
+}
+
+fn validate_pairing_ranges(
+    label: &str,
+    ranges: impl Iterator<Item = CheckedTableRange>,
+    value_len: usize,
+) -> RusticolResult<()> {
+    let ranges = ranges.collect::<Vec<_>>();
+    validate_packed_ranges(label, &ranges, value_len)
+}
+
+fn validate_strict_u32_values(values: &[u32], bound: usize, label: &str) -> RusticolResult<()> {
+    let mut previous = None;
+    for (index, value) in values.iter().copied().enumerate() {
+        required_reference(value, bound, label)?;
+        if let Some(previous) = previous
+            && previous >= value
+        {
+            return Err(invalid(format!(
+                "{label} are not in strict canonical order at row {index}"
+            )));
+        }
+        previous = Some(value);
+    }
+    Ok(())
+}
+
+fn validate_strict_i32_values(values: &[i32], label: &str) -> RusticolResult<()> {
+    if values.windows(2).any(|pair| pair[0] >= pair[1]) {
+        return Err(invalid(format!(
+            "{label} are not in strict canonical order"
+        )));
+    }
+    Ok(())
+}
+
+fn exact_integer_equals(
+    input: FermionPairingInputView<'_>,
+    integer_id: u32,
+    expected: i32,
+) -> RusticolResult<bool> {
+    let row = input
+        .exact_integers
+        .get(required_reference(
+            integer_id,
+            input.exact_integers.len(),
+            "fermion-pairing exact integer",
+        )?)
+        .copied()
+        .ok_or_else(|| invalid("validated fermion-pairing exact integer disappeared"))?;
+    let limbs = pairing_range_slice(
+        input.exact_integer_limbs,
+        row.limb_range,
+        "fermion-pairing exact-integer magnitude",
+    )?;
+    Ok(match expected {
+        -1 => row.sign == -1 && limbs == [1],
+        0 => row.sign == 0 && limbs.is_empty(),
+        1 => row.sign == 1 && limbs == [1],
+        _ => false,
+    })
+}
+
+fn decode_bool(value: u8, label: &str) -> RusticolResult<bool> {
+    match value {
+        0 => Ok(false),
+        1 => Ok(true),
+        _ => Err(invalid(format!(
+            "{label} must be zero or one, found {value}"
+        ))),
+    }
+}
+
+fn required_reference(id: u32, target_len: usize, label: &str) -> RusticolResult<usize> {
+    let index =
+        usize::try_from(id).map_err(|_| invalid(format!("{label} id {id} exceeds usize")))?;
+    if index >= target_len {
+        return Err(invalid(format!(
+            "{label} references id {id}, target length is {target_len}"
+        )));
+    }
+    Ok(index)
+}
+
+fn required_string<'a>(strings: &'a [&str], id: u32, label: &str) -> RusticolResult<&'a str> {
+    strings
+        .get(required_reference(id, strings.len(), label)?)
+        .copied()
+        .ok_or_else(|| invalid(format!("validated {label} disappeared")))
+}
+
+fn require_string_value(
+    strings: &[&str],
+    id: u32,
+    expected: &str,
+    label: &str,
+) -> RusticolResult<()> {
+    let actual = required_string(strings, id, label)?;
+    if actual != expected {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported {label} {actual:?}; expected {expected:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn required_digest(
+    digests: &[SemanticDigest],
+    id: u32,
+    label: &str,
+) -> RusticolResult<SemanticDigest> {
+    digests
+        .get(required_reference(id, digests.len(), label)?)
+        .copied()
+        .ok_or_else(|| invalid(format!("validated {label} disappeared")))
+}
+
+fn take_required_role(
+    values: &mut BTreeMap<ProcessDigestRole, SemanticDigest>,
+    role: ProcessDigestRole,
+) -> RusticolResult<SemanticDigest> {
+    values.remove(&role).ok_or_else(|| {
+        invalid(format!(
+            "recurrence process header is missing semantic digest role {:?}",
+            role.as_str()
+        ))
+    })
+}
+
+fn validate_canonical_ids(
+    label: &str,
+    values: impl IntoIterator<Item = u32>,
+) -> RusticolResult<()> {
+    for (index, value) in values.into_iter().enumerate() {
+        let expected =
+            u32::try_from(index).map_err(|_| invalid(format!("{label} row index exceeds u32")))?;
+        if value != expected {
+            return Err(invalid(format!(
+                "{label} row {index} contains id {value}, expected {expected}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_strict_ids(label: &str, values: &[u32]) -> RusticolResult<()> {
+    let mut previous = None;
+    for (index, value) in values.iter().copied().enumerate() {
+        if let Some(previous) = previous
+            && previous >= value
+        {
+            return Err(invalid(format!(
+                "{label} is not in strict ascending order at row {index}"
+            )));
+        }
+        previous = Some(value);
+    }
+    Ok(())
+}
+
+fn validate_source_slot_sequence(
+    values: &[u32],
+    external_leg_count: usize,
+    label: &str,
+) -> RusticolResult<()> {
+    let mut seen = BTreeSet::new();
+    for value in values.iter().copied() {
+        required_reference(value, external_leg_count, label)?;
+        if !seen.insert(value) {
+            return Err(invalid(format!(
+                "{label} repeats external source slot {value}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_permutation(values: &[u32], expected_len: usize, label: &str) -> RusticolResult<()> {
+    if values.len() != expected_len {
+        return Err(invalid(format!(
+            "{label} has {} entries, expected {expected_len}",
+            values.len()
+        )));
+    }
+    let mut seen = vec![false; expected_len];
+    for value in values.iter().copied() {
+        let index = required_reference(value, expected_len, label)?;
+        if seen[index] {
+            return Err(invalid(format!("{label} repeats source slot {value}")));
+        }
+        seen[index] = true;
+    }
+    Ok(())
+}
+
+fn validate_mapped_word(
+    source_word: &[u32],
+    permutation: &[u32],
+    target_word: &[u32],
+    label: &str,
+) -> RusticolResult<()> {
+    if source_word.len() != target_word.len() {
+        return Err(invalid(format!(
+            "{label} maps a word of length {} onto length {}",
+            source_word.len(),
+            target_word.len()
+        )));
+    }
+    for (position, (source_slot, expected_target)) in source_word
+        .iter()
+        .copied()
+        .zip(target_word.iter().copied())
+        .enumerate()
+    {
+        let actual_target = permutation
+            .get(required_reference(
+                source_slot,
+                permutation.len(),
+                &format!("{label} source word"),
+            )?)
+            .copied()
+            .ok_or_else(|| invalid(format!("validated {label} permutation entry disappeared")))?;
+        if actual_target != expected_target {
+            return Err(invalid(format!(
+                "{label} maps word position {position} to {actual_target}, expected {expected_target}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn require_process_template(
+    references: &[ProcessSemanticTemplateReference],
+    typed_id: ProcessSemanticTemplateId,
+    label: &str,
+) -> RusticolResult<()> {
+    if references
+        .binary_search_by_key(&typed_id, |reference| reference.typed_id)
+        .is_err()
+    {
+        return Err(invalid(format!(
+            "{label} references absent semantic template ({:?}, {})",
+            typed_id.kind.as_str(),
+            typed_id.template_id
+        )));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::{BTreeMap, BTreeSet};
+
+    use super::*;
+
+    const TEST_PROCESS_ID: &str = "max-quark-pairs-scaling";
+
+    fn test_digest(seed: u8) -> [u8; 32] {
+        [seed; 32]
+    }
+
+    fn test_range(start: usize, count: usize) -> CheckedTableRange {
+        CheckedTableRange::new(
+            u64::try_from(start).expect("test table start fits u64"),
+            u64::try_from(count).expect("test table count fits u64"),
+        )
+    }
+
+    fn v3_no_rotation_digest() -> [u8; 32] {
+        let payload = json!({
+            "algorithm": "canonical-lc-closure-anchor-v3",
+            "closure_block_source_slots": [[1, 0], [2, 3]],
+            "closure_source_slot": 3,
+            "closure_traversal_source_slots": [1, 0, 2, 3],
+            "component_order_policy": "independent-open-string-block-permutation",
+            "distinguished_source_block": [1, 0],
+            "distinguished_source_slot": 0,
+            "external_source_count": 4,
+            "fermionic_source_slots": [0, 1, 2, 3],
+            "open_string_count": 2,
+            "physical_block_source_slots": [[1, 0], [2, 3]],
+            "policy": "minimum-coloured-source-slot-open-line-block-rotation",
+            "process_source_label_order": [1, 2, 3, 4],
+            "sector_id": 0,
+            "sector_kind": "open-lines",
+            "selected_closure_block": [2, 3],
+            "singlet_source_slots": [],
+            "word_source_slots": [1, 0, 2, 3],
+        });
+        Sha256::digest(serde_json::to_vec(&payload).expect("test v3 payload must canonicalize"))
+            .into()
+    }
+
+    fn validate_v3_color_fixture(
+        word: &[u32],
+        public_labels: [u32; 4],
+        open_strings: &[ProcessLCOpenStringRow],
+        closure_source_slot: u32,
+        closure_digest: [u8; 32],
+    ) -> RusticolResult<()> {
+        let external_legs = public_labels
+            .into_iter()
+            .enumerate()
+            .map(|(source_slot, public_label)| ProcessExternalLegRow {
+                source_slot: u32::try_from(source_slot).expect("test source slot fits u32"),
+                public_label,
+                physical_pdg: 1,
+                outgoing_pdg: 1,
+                is_initial: u8::from(source_slot < 2),
+                is_fermionic: 1,
+                source_state_range: test_range(0, 0),
+                momentum_mask_id: 0,
+                support_mask_id: 0,
+            })
+            .collect::<Vec<_>>();
+        let physical_sectors = [ProcessPhysicalLCSectorRow {
+            sector_id: 0,
+            public_id_string_id: 0,
+            kind: ProcessLCSectorKind::OpenLines as u8,
+            closure_source_slot,
+            closure_proof_algorithm_string_id: 1,
+            closure_proof_digest_id: 0,
+            open_string_range: test_range(0, open_strings.len()),
+            trace_sequence_id: 0,
+            singlet_sequence_id: 0,
+            word_sequence_id: 1,
+            support_mask_id: 0,
+        }];
+        let mut sequence_values = word.to_vec();
+        sequence_values.push(2);
+        let sequence_ranges = [
+            test_range(0, 0),
+            test_range(0, word.len()),
+            test_range(word.len(), 1),
+        ];
+        let strings = vec!["flow:2,1,3,4", "canonical-lc-closure-anchor-v3"];
+        let catalogs = ProcessCatalogs {
+            strings,
+            digests: vec![
+                SemanticDigest::new(closure_digest).expect("test closure digest must be nonzero"),
+            ],
+            factors: Vec::new(),
+        };
+        let input = RecurrenceProcessInputView {
+            input_abi: RECURRENCE_BUILDER_INPUT_ABI,
+            declared_input_digest: SemanticDigest::new(test_digest(31))
+                .expect("test process digest is nonzero"),
+            fermion_pairing: None,
+            bitset_ranges: &[],
+            bitset_words: &[],
+            coupling_limits: &[],
+            digest_catalog: &[],
+            exact_factors: &[],
+            external_legs: &external_legs,
+            header: &[],
+            header_digests: &[],
+            lc_open_strings: open_strings,
+            normalization: &[],
+            parameter_projection: &[],
+            physical_lc_sectors: &physical_sectors,
+            public_lc_flows: &[],
+            replay_partitions: &[],
+            replay_targets: &[],
+            selected_public_flow_coverage: &[],
+            selected_source_coverage: &[],
+            semantic_template_references: &[],
+            source_states: &[],
+            string_ranges: &[],
+            string_bytes: &[],
+            u32_sequence_ranges: &sequence_ranges,
+            u32_sequence_values: &sequence_values,
+        };
+        input.validate_color_sectors(&catalogs)
+    }
+
+    fn validate_v4_color_fixture(
+        word: &[u32],
+        closure_source_slot: u32,
+        state_template_ids: [u32; 4],
+        fermionic_source_slot: Option<usize>,
+    ) -> RusticolResult<()> {
+        let external_legs = (0..4)
+            .map(|source_slot| ProcessExternalLegRow {
+                source_slot,
+                public_label: source_slot + 1,
+                physical_pdg: 21,
+                outgoing_pdg: 21,
+                is_initial: u8::from(source_slot < 2),
+                is_fermionic: u8::from(fermionic_source_slot == Some(source_slot as usize)),
+                source_state_range: test_range(source_slot as usize, 1),
+                momentum_mask_id: 0,
+                support_mask_id: 0,
+            })
+            .collect::<Vec<_>>();
+        let source_states = state_template_ids
+            .into_iter()
+            .enumerate()
+            .map(
+                |(source_slot, current_state_template_id)| ProcessSourceStateRow {
+                    source_slot: source_slot as u32,
+                    state_index: 0,
+                    public_helicity: 1,
+                    chirality: 0,
+                    spin_state: 1,
+                    current_state_template_id,
+                    source_template_id: source_slot as u32,
+                    momentum_sign: 1,
+                    crossing_phase_factor_id: 0,
+                },
+            )
+            .collect::<Vec<_>>();
+        let physical_sectors = [ProcessPhysicalLCSectorRow {
+            sector_id: 0,
+            public_id_string_id: 0,
+            kind: ProcessLCSectorKind::SingleTrace as u8,
+            closure_source_slot,
+            closure_proof_algorithm_string_id: 1,
+            closure_proof_digest_id: 0,
+            open_string_range: test_range(0, 0),
+            trace_sequence_id: 1,
+            singlet_sequence_id: 0,
+            word_sequence_id: 1,
+            support_mask_id: 0,
+        }];
+        let sequence_ranges = [test_range(0, 0), test_range(0, word.len())];
+        let catalogs = ProcessCatalogs {
+            strings: vec!["flow:1,2,3,4", "canonical-lc-closure-anchor-v4"],
+            digests: vec![
+                SemanticDigest::new(test_digest(33)).expect("test closure digest must be nonzero"),
+            ],
+            factors: Vec::new(),
+        };
+        let input = RecurrenceProcessInputView {
+            input_abi: RECURRENCE_BUILDER_INPUT_ABI,
+            declared_input_digest: SemanticDigest::new(test_digest(32))
+                .expect("test process digest is nonzero"),
+            fermion_pairing: None,
+            bitset_ranges: &[],
+            bitset_words: &[],
+            coupling_limits: &[],
+            digest_catalog: &[],
+            exact_factors: &[],
+            external_legs: &external_legs,
+            header: &[],
+            header_digests: &[],
+            lc_open_strings: &[],
+            normalization: &[],
+            parameter_projection: &[],
+            physical_lc_sectors: &physical_sectors,
+            public_lc_flows: &[],
+            replay_partitions: &[],
+            replay_targets: &[],
+            selected_public_flow_coverage: &[],
+            selected_source_coverage: &[],
+            semantic_template_references: &[],
+            source_states: &source_states,
+            string_ranges: &[],
+            string_bytes: &[],
+            u32_sequence_ranges: &sequence_ranges,
+            u32_sequence_values: word,
+        };
+        input.validate_color_sectors(&catalogs)
+    }
+
+    #[test]
+    fn v3_closure_recomputes_no_rotation_mapping_and_rejects_stale_inputs() {
+        let open_strings = [
+            ProcessLCOpenStringRow {
+                sector_id: 0,
+                ordinal: 0,
+                fundamental_source_slot: 1,
+                antifundamental_source_slot: 0,
+                adjoint_sequence_id: 0,
+                singlet_sequence_id: 0,
+            },
+            ProcessLCOpenStringRow {
+                sector_id: 0,
+                ordinal: 1,
+                fundamental_source_slot: 2,
+                antifundamental_source_slot: 3,
+                adjoint_sequence_id: 0,
+                singlet_sequence_id: 0,
+            },
+        ];
+        let digest = v3_no_rotation_digest();
+        validate_v3_color_fixture(&[1, 0, 2, 3], [1, 2, 3, 4], &open_strings, 3, digest)
+            .expect("valid no-rotation v3 fixture must pass");
+
+        for error in [
+            validate_v3_color_fixture(&[2, 3, 1, 0], [1, 2, 3, 4], &open_strings, 3, digest)
+                .expect_err("stale public block order must fail"),
+            validate_v3_color_fixture(&[1, 0, 2, 3], [99, 2, 3, 4], &open_strings, 3, digest)
+                .expect_err("stale public-label/source map must fail"),
+            validate_v3_color_fixture(&[1, 0, 2, 3], [1, 2, 3, 4], &open_strings, 0, digest)
+                .expect_err("stale closure source slot must fail"),
+        ] {
+            assert!(
+                error.to_string().contains("v3 closure"),
+                "unexpected v3 tamper error: {error}"
+            );
+        }
+
+        let mut endpoint_tamper = open_strings;
+        endpoint_tamper[0].fundamental_source_slot = 2;
+        assert!(
+            validate_v3_color_fixture(&[1, 0, 2, 3], [1, 2, 3, 4], &endpoint_tamper, 3, digest,)
+                .expect_err("stale endpoint map must fail")
+                .to_string()
+                .contains("v3 public word")
+        );
+
+        let mut adjoint_tamper = open_strings;
+        adjoint_tamper[0].adjoint_sequence_id = 2;
+        assert!(
+            validate_v3_color_fixture(&[1, 0, 2, 3], [1, 2, 3, 4], &adjoint_tamper, 3, digest,)
+                .expect_err("stale adjoint map must fail")
+                .to_string()
+                .contains("v3 public word")
+        );
+    }
+
+    fn encode_test_strings(
+        values: impl IntoIterator<Item = String>,
+    ) -> (Vec<u8>, Vec<CheckedTableRange>, BTreeMap<String, u32>) {
+        let values = values.into_iter().collect::<BTreeSet<_>>();
+        let mut bytes = Vec::new();
+        let mut ranges = Vec::with_capacity(values.len());
+        let mut ids = BTreeMap::new();
+        for (index, value) in values.into_iter().enumerate() {
+            let start = bytes.len();
+            bytes.extend_from_slice(value.as_bytes());
+            ranges.push(test_range(start, value.len()));
+            ids.insert(
+                value,
+                u32::try_from(index).expect("test string count fits u32"),
+            );
+        }
+        (bytes, ranges, ids)
+    }
+
+    fn unrank_test_permutation(values: &[u32], mut rank: u64) -> Vec<u32> {
+        let mut available = values.to_vec();
+        let mut permutation = Vec::with_capacity(values.len());
+        for remaining in (1..=values.len()).rev() {
+            let block = checked_factorial_u64(remaining - 1, "test permutation block")
+                .expect("test permutation factorial fits u64");
+            let index = usize::try_from(rank / block).expect("test permutation index fits usize");
+            rank %= block;
+            permutation.push(available.remove(index));
+        }
+        assert_eq!(rank, 0);
+        permutation
+    }
+
+    fn test_permutation_parity(values: &[u32]) -> i32 {
+        let inversions = values
+            .iter()
+            .enumerate()
+            .map(|(index, value)| {
+                values[index + 1..]
+                    .iter()
+                    .filter(|other| value > *other)
+                    .count()
+            })
+            .sum::<usize>();
+        if inversions % 2 == 0 { 1 } else { -1 }
+    }
+
+    fn pairing_fixture(pair_counts_by_species: &[usize]) -> OwnedFermionPairingInput {
+        assert!(pair_counts_by_species.iter().all(|count| *count > 0));
+        let species = (0..pair_counts_by_species.len())
+            .map(|index| format!("species-{index:03}"))
+            .collect::<Vec<_>>();
+        let strings = [
+            RECURRENCE_FERMION_PAIRING_COLUMNAR_ABI.to_owned(),
+            RECURRENCE_FERMION_PAIRING_PROOF_ALGORITHM.to_owned(),
+            TEST_PROCESS_ID.to_owned(),
+            "anti-state".to_owned(),
+            "basis".to_owned(),
+            "state".to_owned(),
+        ]
+        .into_iter()
+        .chain(species.iter().cloned());
+        let (string_bytes, string_ranges, string_ids) = encode_test_strings(strings);
+        let string_id = |value: &str| {
+            *string_ids
+                .get(value)
+                .unwrap_or_else(|| panic!("missing test string {value:?}"))
+        };
+
+        let mut endpoints = Vec::new();
+        let mut endpoint_state_template_ids = Vec::new();
+        let mut endpoint_anti_state_template_ids = Vec::new();
+        let mut endpoint_basis_ids = Vec::new();
+        let mut endpoint_color_representations = Vec::new();
+        let mut pairing_classes = Vec::new();
+        let mut class_fundamental_slots = Vec::new();
+        let mut class_antifundamental_slots = Vec::new();
+        let mut class_reference_pairings = Vec::new();
+        let mut class_fundamentals = Vec::new();
+        let mut class_antifundamentals = Vec::new();
+        let mut next_source_slot = 0_u32;
+
+        for (class_id, (&pair_count, species)) in pair_counts_by_species
+            .iter()
+            .zip(species.iter())
+            .enumerate()
+        {
+            let mut fundamental = Vec::with_capacity(pair_count);
+            let mut antifundamental = Vec::with_capacity(pair_count);
+            for _ in 0..pair_count {
+                fundamental.push(next_source_slot);
+                antifundamental.push(next_source_slot + 1);
+                next_source_slot += 2;
+            }
+
+            for (fundamental_slot, antifundamental_slot) in fundamental
+                .iter()
+                .copied()
+                .zip(antifundamental.iter().copied())
+            {
+                for (source_slot, particle_orientation, color_orientation, representation) in [
+                    (fundamental_slot, 0, 0, 3),
+                    (antifundamental_slot, 1, 1, -3),
+                ] {
+                    let state_start = endpoint_state_template_ids.len();
+                    endpoint_state_template_ids.push(string_id("state"));
+                    let anti_state_start = endpoint_anti_state_template_ids.len();
+                    endpoint_anti_state_template_ids.push(string_id("anti-state"));
+                    let basis_start = endpoint_basis_ids.len();
+                    endpoint_basis_ids.push(string_id("basis"));
+                    let representation_start = endpoint_color_representations.len();
+                    endpoint_color_representations.push(representation);
+                    endpoints.push(FermionPairingEndpointRow {
+                        endpoint_id: u32::try_from(endpoints.len())
+                            .expect("test endpoint count fits u32"),
+                        source_slot,
+                        public_label: source_slot + 1,
+                        species_class_id: u32::try_from(class_id)
+                            .expect("test class count fits u32"),
+                        species_string_id: string_id(species),
+                        particle_orientation,
+                        color_orientation,
+                        state_template_range: test_range(state_start, 1),
+                        anti_state_template_range: test_range(anti_state_start, 1),
+                        basis_range: test_range(basis_start, 1),
+                        color_representation_range: test_range(representation_start, 1),
+                        contract_digest: test_digest(4),
+                    });
+                }
+            }
+
+            let fundamental_start = class_fundamental_slots.len();
+            class_fundamental_slots.extend_from_slice(&fundamental);
+            let antifundamental_start = class_antifundamental_slots.len();
+            class_antifundamental_slots.extend_from_slice(&antifundamental);
+            let reference_start = class_reference_pairings.len();
+            class_reference_pairings.extend(
+                fundamental
+                    .iter()
+                    .copied()
+                    .zip(antifundamental.iter().copied())
+                    .map(|(fundamental_source_slot, antifundamental_source_slot)| {
+                        FermionPairingEndpointPairRow {
+                            fundamental_source_slot,
+                            antifundamental_source_slot,
+                        }
+                    }),
+            );
+            pairing_classes.push(FermionPairingClassRow {
+                class_id: u32::try_from(class_id).expect("test class count fits u32"),
+                species_class_id: u32::try_from(class_id).expect("test class count fits u32"),
+                species_string_id: string_id(species),
+                fundamental_slot_range: test_range(fundamental_start, pair_count),
+                antifundamental_slot_range: test_range(antifundamental_start, pair_count),
+                reference_pairing_range: test_range(reference_start, pair_count),
+                pairing_count: checked_factorial_u64(pair_count, "test pairing count")
+                    .expect("test pairing count fits u64"),
+                proof_digest: test_digest(5),
+            });
+            class_fundamentals.push(fundamental);
+            class_antifundamentals.push(antifundamental);
+        }
+
+        let source_count = usize::try_from(next_source_slot).expect("test source count fits usize");
+        let total_rule_count = pairing_classes
+            .iter()
+            .try_fold(1_u64, |count, class| count.checked_mul(class.pairing_count))
+            .expect("test rule count fits u64");
+        let total_rule_count =
+            usize::try_from(total_rule_count).expect("test rule count fits usize");
+        let mut rules = Vec::with_capacity(total_rule_count);
+        let mut rule_class_pairing_indices = Vec::new();
+        let mut rule_endpoint_pairings = Vec::new();
+        let mut rule_source_slot_permutations = Vec::new();
+        let mut rule_lineages = Vec::new();
+
+        for rule_id in 0..total_rule_count {
+            let class_index_start = rule_class_pairing_indices.len();
+            let endpoint_pairing_start = rule_endpoint_pairings.len();
+            let mut mixed_index = u64::try_from(rule_id).expect("test rule ID fits u64");
+            let mut parity = 1;
+            for (class_id, class) in pairing_classes.iter().enumerate() {
+                let local_index = mixed_index % class.pairing_count;
+                mixed_index /= class.pairing_count;
+                rule_class_pairing_indices.push(FermionPairingClassPairingIndexRow {
+                    class_id: u32::try_from(class_id).expect("test class count fits u32"),
+                    pairing_index: local_index,
+                });
+                let permutation =
+                    unrank_test_permutation(&class_antifundamentals[class_id], local_index);
+                parity *= test_permutation_parity(&permutation);
+                rule_endpoint_pairings.extend(
+                    class_fundamentals[class_id]
+                        .iter()
+                        .copied()
+                        .zip(permutation)
+                        .map(|(fundamental_source_slot, antifundamental_source_slot)| {
+                            FermionPairingEndpointPairRow {
+                                fundamental_source_slot,
+                                antifundamental_source_slot,
+                            }
+                        }),
+                );
+            }
+            assert_eq!(mixed_index, 0);
+            let source_permutation_start = rule_source_slot_permutations.len();
+            rule_source_slot_permutations.extend(0..next_source_slot);
+            let lineage_start = rule_lineages.len();
+            rule_lineages.extend(std::iter::repeat_n(
+                RECURRENCE_NO_FERMION_LINE,
+                source_count,
+            ));
+            rules.push(FermionPairingRuleRow {
+                rule_id: u32::try_from(rule_id).expect("test rule count fits u32"),
+                class_pairing_index_range: test_range(class_index_start, pairing_classes.len()),
+                endpoint_pairing_range: test_range(
+                    endpoint_pairing_start,
+                    pair_counts_by_species.iter().sum(),
+                ),
+                source_permutation_range: test_range(source_permutation_start, source_count),
+                lineage_range: test_range(lineage_start, source_count),
+                fermion_parity: parity,
+                real_numerator_integer_id: if parity < 0 { 0 } else { 2 },
+                real_denominator_integer_id: 2,
+                imag_numerator_integer_id: 1,
+                imag_denominator_integer_id: 2,
+                multiplicity: 1,
+                proof_algorithm_string_id: string_id(RECURRENCE_FERMION_PAIRING_PROOF_ALGORITHM),
+                proof_digest: test_digest(6),
+            });
+        }
+
+        let exact_integers = vec![
+            FermionPairingExactIntegerRow {
+                integer_id: 0,
+                sign: -1,
+                limb_range: test_range(0, 1),
+            },
+            FermionPairingExactIntegerRow {
+                integer_id: 1,
+                sign: 0,
+                limb_range: test_range(1, 0),
+            },
+            FermionPairingExactIntegerRow {
+                integer_id: 2,
+                sign: 1,
+                limb_range: test_range(1, 1),
+            },
+        ];
+        let exact_integer_limbs = vec![1, 1];
+        let u32_len = |value: usize| u32::try_from(value).expect("test count fits u32");
+        let u64_len = |value: usize| u64::try_from(value).expect("test count fits u64");
+        let header = FermionPairingHeaderRow {
+            schema_version: RECURRENCE_FERMION_PAIRING_SCHEMA_VERSION,
+            abi_string_id: string_id(RECURRENCE_FERMION_PAIRING_COLUMNAR_ABI),
+            process_key_string_id: string_id(TEST_PROCESS_ID),
+            proof_algorithm_string_id: string_id(RECURRENCE_FERMION_PAIRING_PROOF_ALGORITHM),
+            source_count: u32_len(source_count),
+            endpoint_count: u32_len(endpoints.len()),
+            pairing_class_count: u32_len(pairing_classes.len()),
+            rule_count: u32_len(rules.len()),
+            endpoint_state_template_count: u64_len(endpoint_state_template_ids.len()),
+            endpoint_anti_state_template_count: u64_len(endpoint_anti_state_template_ids.len()),
+            endpoint_basis_count: u64_len(endpoint_basis_ids.len()),
+            endpoint_color_representation_count: u64_len(endpoint_color_representations.len()),
+            class_fundamental_slot_count: u64_len(class_fundamental_slots.len()),
+            class_antifundamental_slot_count: u64_len(class_antifundamental_slots.len()),
+            class_reference_pairing_count: u64_len(class_reference_pairings.len()),
+            rule_class_pairing_index_count: u64_len(rule_class_pairing_indices.len()),
+            rule_endpoint_pairing_count: u64_len(rule_endpoint_pairings.len()),
+            rule_source_permutation_count: u64_len(rule_source_slot_permutations.len()),
+            rule_lineage_count: u64_len(rule_lineages.len()),
+            exact_integer_count: u32_len(exact_integers.len()),
+            exact_integer_limb_count: u64_len(exact_integer_limbs.len()),
+            string_count: u32_len(string_ranges.len()),
+            string_byte_count: u64_len(string_bytes.len()),
+            no_fermion_line: RECURRENCE_NO_FERMION_LINE,
+            topology_digest: test_digest(7),
+            semantic_digest: test_digest(8),
+        };
+        OwnedFermionPairingInput {
+            input_abi: RECURRENCE_FERMION_PAIRING_COLUMNAR_ABI.to_owned(),
+            declared_columnar_digest: SemanticDigest::new(test_digest(9))
+                .expect("test digest is nonzero"),
+            header: vec![header],
+            endpoints,
+            endpoint_state_template_ids,
+            endpoint_anti_state_template_ids,
+            endpoint_basis_ids,
+            endpoint_color_representations,
+            pairing_classes,
+            class_fundamental_slots,
+            class_antifundamental_slots,
+            class_reference_pairings,
+            rules,
+            rule_class_pairing_indices,
+            rule_endpoint_pairings,
+            rule_source_slot_permutations,
+            rule_lineages,
+            exact_integers,
+            exact_integer_limbs,
+            string_ranges,
+            string_bytes,
+        }
+    }
+
+    #[test]
+    fn v4_closure_validates_cyclic_anchor_and_homogeneous_source_contract() {
+        let word = [0, 2, 1, 3];
+        validate_v4_color_fixture(&word, 0, [7; 4], None)
+            .expect("valid cyclic trace anchor must pass");
+
+        for error in [
+            validate_v4_color_fixture(&word, 1, [7; 4], None)
+                .expect_err("noncanonical anchor must fail"),
+            validate_v4_color_fixture(&word, 0, [7, 7, 8, 7], None)
+                .expect_err("heterogeneous current states must fail"),
+            validate_v4_color_fixture(&word, 0, [7; 4], Some(2))
+                .expect_err("fermionic trace source must fail"),
+        ] {
+            assert!(
+                error.to_string().contains("v4"),
+                "unexpected validation error: {error}"
+            );
+        }
+    }
+
+    fn generation_coverage_view<'a>(
+        header: &'a [ProcessHeaderRow],
+        external_legs: &'a [ProcessExternalLegRow],
+        public_lc_flows: &'a [ProcessPublicLCFlowRow],
+        selected_public_flow_coverage: &'a [ProcessSelectedPublicFlowRow],
+        selected_source_coverage: &'a [ProcessSelectedSourceStateRow],
+    ) -> RecurrenceProcessInputView<'a> {
+        RecurrenceProcessInputView {
+            input_abi: RECURRENCE_BUILDER_INPUT_ABI,
+            declared_input_digest: SemanticDigest::new(test_digest(31))
+                .expect("test process digest is nonzero"),
+            fermion_pairing: None,
+            bitset_ranges: &[],
+            bitset_words: &[],
+            coupling_limits: &[],
+            digest_catalog: &[],
+            exact_factors: &[],
+            external_legs,
+            header,
+            header_digests: &[],
+            lc_open_strings: &[],
+            normalization: &[],
+            parameter_projection: &[],
+            physical_lc_sectors: &[],
+            public_lc_flows,
+            replay_partitions: &[],
+            replay_targets: &[],
+            selected_public_flow_coverage,
+            selected_source_coverage,
+            semantic_template_references: &[],
+            source_states: &[],
+            string_ranges: &[],
+            string_bytes: &[],
+            u32_sequence_ranges: &[],
+            u32_sequence_values: &[],
+        }
+    }
+
+    fn generation_coverage_header(
+        strategy: RecurrenceStrategy,
+        selected_flow_mode: bool,
+        selected_source_mode: bool,
+    ) -> ProcessHeaderRow {
+        ProcessHeaderRow {
+            schema_version: RECURRENCE_PROCESS_INPUT_SCHEMA_VERSION,
+            abi_string_id: 0,
+            process_id_string_id: 0,
+            layout: u8::try_from(strategy.as_u32()).expect("strategy fits u8"),
+            selected_flow_mode: u8::from(selected_flow_mode),
+            selected_source_mode: u8::from(selected_source_mode),
+            external_leg_count: 2,
+            physical_sector_count: 0,
+            public_flow_count: 2,
+            replay_partition_count: 0,
+            coupling_limit_count: 0,
+            parameter_projection_count: 0,
+            process_support_mask_id: 0,
+        }
+    }
+
+    fn generation_coverage_external_legs() -> [ProcessExternalLegRow; 2] {
+        [
+            ProcessExternalLegRow {
+                source_slot: 0,
+                public_label: 1,
+                physical_pdg: 1,
+                outgoing_pdg: 1,
+                is_initial: 1,
+                is_fermionic: 1,
+                source_state_range: test_range(0, 2),
+                momentum_mask_id: 0,
+                support_mask_id: 0,
+            },
+            ProcessExternalLegRow {
+                source_slot: 1,
+                public_label: 2,
+                physical_pdg: -1,
+                outgoing_pdg: -1,
+                is_initial: 1,
+                is_fermionic: 1,
+                source_state_range: test_range(2, 2),
+                momentum_mask_id: 0,
+                support_mask_id: 0,
+            },
+        ]
+    }
+
+    fn generation_coverage_public_flows() -> [ProcessPublicLCFlowRow; 2] {
+        [
+            ProcessPublicLCFlowRow {
+                flow_id: 0,
+                public_id_string_id: 0,
+                construction_sector_id: 0,
+                word_sequence_id: 0,
+                source_slot_permutation_sequence_id: 0,
+                reduction_weight_factor_id: 0,
+            },
+            ProcessPublicLCFlowRow {
+                flow_id: 1,
+                public_id_string_id: 0,
+                construction_sector_id: 0,
+                word_sequence_id: 0,
+                source_slot_permutation_sequence_id: 0,
+                reduction_weight_factor_id: 0,
+            },
+        ]
+    }
+
+    #[test]
+    fn all_flow_union_accepts_generation_specialized_coverage() {
+        let header = [generation_coverage_header(
+            RecurrenceStrategy::AllFlowUnion,
+            true,
+            true,
+        )];
+        let external_legs = generation_coverage_external_legs();
+        let public_flows = generation_coverage_public_flows();
+        let selected_flows = [ProcessSelectedPublicFlowRow { flow_id: 1 }];
+        let selected_sources = [
+            ProcessSelectedSourceStateRow {
+                source_slot: 0,
+                source_state_index: 1,
+            },
+            ProcessSelectedSourceStateRow {
+                source_slot: 1,
+                source_state_index: 0,
+            },
+        ];
+        let input = generation_coverage_view(
+            &header,
+            &external_legs,
+            &public_flows,
+            &selected_flows,
+            &selected_sources,
+        );
+
+        input
+            .validate_generation_coverage(true, true)
+            .expect("all-flow-union accepts valid generation specialization");
+    }
+
+    #[test]
+    fn all_flow_union_accepts_omitted_generation_axes() {
+        let header = [generation_coverage_header(
+            RecurrenceStrategy::AllFlowUnion,
+            false,
+            false,
+        )];
+        let external_legs = generation_coverage_external_legs();
+        let public_flows = generation_coverage_public_flows();
+        let input = generation_coverage_view(&header, &external_legs, &public_flows, &[], &[]);
+
+        input
+            .validate_generation_coverage(false, false)
+            .expect("omitted union axes retain complete coverage");
+    }
+
+    #[test]
+    fn selected_source_coverage_rejects_missing_external_slot() {
+        let header = [generation_coverage_header(
+            RecurrenceStrategy::AllFlowUnion,
+            false,
+            true,
+        )];
+        let external_legs = generation_coverage_external_legs();
+        let public_flows = generation_coverage_public_flows();
+        let selected_sources = [ProcessSelectedSourceStateRow {
+            source_slot: 0,
+            source_state_index: 1,
+        }];
+        let input = generation_coverage_view(
+            &header,
+            &external_legs,
+            &public_flows,
+            &[],
+            &selected_sources,
+        );
+
+        let error = input
+            .validate_generation_coverage(false, true)
+            .expect_err("partial source coverage must fail closed");
+        assert!(error.to_string().contains("every external source slot"));
+    }
+
+    #[test]
+    fn selected_union_coverage_rejects_out_of_range_rows() {
+        let header = [generation_coverage_header(
+            RecurrenceStrategy::AllFlowUnion,
+            true,
+            true,
+        )];
+        let external_legs = generation_coverage_external_legs();
+        let public_flows = generation_coverage_public_flows();
+        let selected_flows = [ProcessSelectedPublicFlowRow { flow_id: 2 }];
+        let selected_sources = [
+            ProcessSelectedSourceStateRow {
+                source_slot: 0,
+                source_state_index: 0,
+            },
+            ProcessSelectedSourceStateRow {
+                source_slot: 1,
+                source_state_index: 2,
+            },
+        ];
+        let input = generation_coverage_view(
+            &header,
+            &external_legs,
+            &public_flows,
+            &selected_flows,
+            &selected_sources,
+        );
+
+        assert!(input.validate_generation_coverage(true, true).is_err());
+    }
+
+    #[test]
+    fn semantic_template_kinds_are_closed_and_round_trip() {
+        for kind in [
+            ProcessSemanticTemplateKind::Parameter,
+            ProcessSemanticTemplateKind::CurrentState,
+            ProcessSemanticTemplateKind::Source,
+            ProcessSemanticTemplateKind::QuantumFlow,
+            ProcessSemanticTemplateKind::Transition,
+            ProcessSemanticTemplateKind::Propagator,
+            ProcessSemanticTemplateKind::Closure,
+            ProcessSemanticTemplateKind::ColorContraction,
+            ProcessSemanticTemplateKind::SymmetryProof,
+        ] {
+            assert_eq!(
+                ProcessSemanticTemplateKind::try_from(kind.as_str()),
+                Ok(kind)
+            );
+        }
+        assert!(ProcessSemanticTemplateKind::try_from("model-specific").is_err());
+    }
+
+    #[test]
+    fn process_digest_roles_decode_required_and_extension_roles() {
+        assert_eq!(
+            ProcessDigestRole::decode("process").unwrap(),
+            ProcessDigestRole::Process
+        );
+        assert_eq!(
+            ProcessDigestRole::decode("future-proof").unwrap(),
+            ProcessDigestRole::Extension("future-proof".to_owned())
+        );
+        assert!(ProcessDigestRole::decode("").is_err());
+    }
+
+    #[test]
+    fn permutation_validation_rejects_duplicates_and_missing_entries() {
+        assert!(validate_permutation(&[2, 0, 1], 3, "test permutation").is_ok());
+        assert!(validate_permutation(&[0, 0, 2], 3, "test permutation").is_err());
+        assert!(validate_permutation(&[0, 1], 3, "test permutation").is_err());
+    }
+
+    #[test]
+    fn user_max_quark_pairs_above_eight_has_no_hidden_endpoint_cap() {
+        let input = pairing_fixture(&[1; 9]);
+        let summary = input
+            .as_view()
+            .validate_internal(TEST_PROCESS_ID)
+            .expect("nine independently flavored quark pairs must validate");
+        assert_eq!(summary.endpoint_count, 18);
+        assert_eq!(summary.pairing_class_count, 9);
+        assert_eq!(summary.rule_count, 1);
+    }
+
+    #[test]
+    fn user_max_quark_pairs_allows_more_than_legacy_pairing_and_rule_caps() {
+        let input = pairing_fixture(&[7]);
+        assert_eq!(input.pairing_classes[0].pairing_count, 5_040);
+        let summary = input
+            .as_view()
+            .validate_internal(TEST_PROCESS_ID)
+            .expect("seven same-species quark pairs and all 5,040 rules must validate");
+        assert_eq!(summary.endpoint_count, 14);
+        assert_eq!(summary.pairing_class_count, 1);
+        assert_eq!(summary.rule_count, 5_040);
+    }
+
+    #[test]
+    fn pairing_growth_stops_only_at_checked_integer_representation() {
+        assert_eq!(
+            checked_factorial_u64(20, "test pairing count").unwrap(),
+            2_432_902_008_176_640_000
+        );
+        let error = checked_factorial_u64(21, "test pairing count").unwrap_err();
+        assert!(error.to_string().contains("exceeds u64"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/program.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/program.rs
new file mode 100644
index 0000000000..74a4c9b8f6
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/program.rs
@@ -0,0 +1,3781 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Compact, immutable recurrence schedule produced by the recurrence builder.
+//!
+//! The owned vectors are build-time storage. Evaluation consumes only packed
+//! slices and ranges, so traversing a validated program requires no maps or
+//! heap allocation.
+
+use std::collections::BTreeSet;
+
+use sha2::{Digest, Sha256};
+
+use super::{
+    CheckedTableRange, ContributionKey, CurrentCoreKey, DynamicLCColorState, ExactComplexRational,
+    ExactRational, RecurrenceNodeKind, RecurrenceStrategy, SemanticDigest, SourceStateAssignment,
+};
+use crate::{RusticolError, RusticolResult};
+
+pub const CLOSURE_TARGET_DOMAIN_PROOF_KIND: &str = "complete-recurrence-closure-target-domain-v1";
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+fn checked_table_len(label: &str, length: usize) -> RusticolResult<u64> {
+    u64::try_from(length).map_err(|_| invalid(format!("{label} length {length} exceeds u64")))
+}
+
+fn validate_permutation(label: &str, values: &[u32], expected_len: usize) -> RusticolResult<()> {
+    if values.len() != expected_len {
+        return Err(invalid(format!(
+            "{label} has length {}, expected {expected_len}",
+            values.len()
+        )));
+    }
+    let mut seen = vec![false; expected_len];
+    for (index, value) in values.iter().copied().enumerate() {
+        let value = usize::try_from(value)
+            .map_err(|_| invalid(format!("{label} row {index} exceeds usize")))?;
+        let Some(slot) = seen.get_mut(value) else {
+            return Err(invalid(format!(
+                "{label} row {index} references out-of-range slot {value}"
+            )));
+        };
+        if std::mem::replace(slot, true) {
+            return Err(invalid(format!(
+                "{label} repeats slot {value} at row {index}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn hash_exact_factor(hash: &mut Sha256, factor: ExactComplexRational) {
+    for rational in [factor.real(), factor.imag()] {
+        hash.update(rational.numerator().to_le_bytes());
+        hash.update(rational.denominator().to_le_bytes());
+    }
+}
+
+fn hash_optional_u32(hash: &mut Sha256, value: Option<u32>) {
+    hash.update(value.unwrap_or(u32::MAX).to_le_bytes());
+}
+
+fn hash_optional_digest(hash: &mut Sha256, value: Option<SemanticDigest>) {
+    hash.update(value.map_or([0; 32], |digest| *digest.as_bytes()));
+}
+
+fn semantic_digest_from_fields(
+    domain: &[u8],
+    values: impl IntoIterator<Item = u32>,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(domain);
+    for value in values {
+        hash.update(value.to_le_bytes());
+    }
+    SemanticDigest::new(hash.finalize().into())
+}
+
+/// One unaggregated exact closure obligation.
+///
+/// These rows are cold proof metadata. Runtime closure rows are formed only
+/// after the complete contribution multiset has been validated and grouped.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClosureProofContributionV2 {
+    id: u32,
+    target_sector_id: u32,
+    target_destination_id: Option<u32>,
+    target_helicity_id: Option<u32>,
+    closure_template_id: u32,
+    closure_template_semantic_digest: SemanticDigest,
+    quantum_flow_template_id: Option<u32>,
+    construction_parent_builder_ids: Box<[u32]>,
+    construction_parent_runtime_ids: Box<[Option<u32>]>,
+    construction_parent_semantic_digests: Box<[SemanticDigest]>,
+    construction_parent_color_digests: Box<[SemanticDigest]>,
+    construction_parent_permutation: Box<[u32]>,
+    reconstruction_parent_permutation: Box<[u32]>,
+    evaluator_parent_permutation: Box<[u32]>,
+    color_witness_term_id: u32,
+    color_witness_proof_digest: SemanticDigest,
+    three_line_certificate_id: Option<u32>,
+    pairing_certificate_ids: Box<[u32]>,
+    reflection_certificate_id: Option<u32>,
+    exact_factor: ExactComplexRational,
+    multiplicity: u32,
+}
+
+/// Compact commitment to the complete accepted closure-candidate multiset.
+///
+/// The builder computes this before aggregation. Loading recomputes it from the
+/// persisted proof contributions and rejects omitted, duplicated, or altered
+/// candidates without retaining a second expanded closure table.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ClosureCandidateDomainCertificateV1 {
+    accepted_candidate_count: u64,
+    accepted_candidate_digest: SemanticDigest,
+}
+
+/// Exact proof that complete physical colour sectors have no retained closure.
+///
+/// The construction pass produces this certificate only after enumerating the
+/// complete physical-sector x resolved-helicity closure domain.  Its digest
+/// binds every target row, including rows with an empty candidate list, plus
+/// every original candidate identity and exact aggregate.  The compact sector
+/// list is therefore a consequence of an exhaustive native proof, not an
+/// inference from missing runtime destinations.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClosureTargetDomainCertificateV1 {
+    physical_sector_count: u32,
+    resolved_helicity_count: u32,
+    certified_structural_zero_physical_sector_ids: Box<[u32]>,
+    semantic_digest: SemanticDigest,
+}
+
+impl ClosureTargetDomainCertificateV1 {
+    pub fn new(
+        physical_sector_count: u32,
+        resolved_helicity_count: u32,
+        certified_structural_zero_physical_sector_ids: Vec<u32>,
+        semantic_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        if physical_sector_count == 0 {
+            return Err(invalid(
+                "closure target-domain certificate requires physical sectors",
+            ));
+        }
+        if resolved_helicity_count == 0 {
+            return Err(invalid(
+                "closure target-domain certificate requires resolved helicities",
+            ));
+        }
+        if certified_structural_zero_physical_sector_ids
+            .windows(2)
+            .any(|pair| pair[0] >= pair[1])
+            || certified_structural_zero_physical_sector_ids
+                .iter()
+                .any(|sector_id| *sector_id >= physical_sector_count)
+        {
+            return Err(invalid(
+                "closure target-domain structural-zero sectors are not canonical",
+            ));
+        }
+        Ok(Self {
+            physical_sector_count,
+            resolved_helicity_count,
+            certified_structural_zero_physical_sector_ids:
+                certified_structural_zero_physical_sector_ids.into_boxed_slice(),
+            semantic_digest,
+        })
+    }
+
+    pub const fn physical_sector_count(&self) -> u32 {
+        self.physical_sector_count
+    }
+
+    pub const fn resolved_helicity_count(&self) -> u32 {
+        self.resolved_helicity_count
+    }
+
+    pub fn certified_structural_zero_physical_sector_ids(&self) -> &[u32] {
+        &self.certified_structural_zero_physical_sector_ids
+    }
+
+    pub const fn semantic_digest(&self) -> SemanticDigest {
+        self.semantic_digest
+    }
+}
+
+impl ClosureCandidateDomainCertificateV1 {
+    pub const fn new(
+        accepted_candidate_count: u64,
+        accepted_candidate_digest: SemanticDigest,
+    ) -> Self {
+        Self {
+            accepted_candidate_count,
+            accepted_candidate_digest,
+        }
+    }
+
+    pub(crate) fn from_identity_digests(
+        mut identity_digests: Vec<SemanticDigest>,
+    ) -> RusticolResult<Self> {
+        identity_digests.sort_unstable();
+        let accepted_candidate_count = u64::try_from(identity_digests.len())
+            .map_err(|_| invalid("closure candidate-domain count exceeds u64"))?;
+        let mut hash = Sha256::new();
+        hash.update(b"pyamplicol-recurrence-closure-candidate-domain-v1\0");
+        hash.update(accepted_candidate_count.to_le_bytes());
+        for digest in identity_digests {
+            hash.update(digest.as_bytes());
+        }
+        Ok(Self::new(
+            accepted_candidate_count,
+            SemanticDigest::new(hash.finalize().into())?,
+        ))
+    }
+
+    pub const fn accepted_candidate_count(self) -> u64 {
+        self.accepted_candidate_count
+    }
+
+    pub const fn accepted_candidate_digest(self) -> SemanticDigest {
+        self.accepted_candidate_digest
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn closure_candidate_identity_digest_v1(
+    selector_domain_digest: SemanticDigest,
+    target_sector_id: u32,
+    closure_template_id: u32,
+    closure_template_semantic_digest: SemanticDigest,
+    quantum_flow_template_id: Option<u32>,
+    construction_parent_builder_ids: &[u32],
+    construction_parent_semantic_digests: &[SemanticDigest],
+    construction_parent_color_digests: &[SemanticDigest],
+    construction_parent_permutation: &[u32],
+    reconstruction_parent_permutation: &[u32],
+    evaluator_parent_permutation: &[u32],
+    color_witness_term_id: u32,
+    color_witness_proof_digest: SemanticDigest,
+    three_line_proof_digest: Option<SemanticDigest>,
+    pairing_certificate_ids: &[u32],
+    reflection_proof_digest: Option<SemanticDigest>,
+    exact_factor: ExactComplexRational,
+    multiplicity: u32,
+) -> RusticolResult<SemanticDigest> {
+    let parent_count = construction_parent_builder_ids.len();
+    if construction_parent_semantic_digests.len() != parent_count
+        || construction_parent_color_digests.len() != parent_count
+    {
+        return Err(invalid(
+            "closure candidate parent IDs and semantic/color digests have inconsistent lengths",
+        ));
+    }
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-closure-candidate-v1\0");
+    hash.update(selector_domain_digest.as_bytes());
+    hash.update(target_sector_id.to_le_bytes());
+    hash.update(closure_template_id.to_le_bytes());
+    hash.update(closure_template_semantic_digest.as_bytes());
+    hash_optional_u32(&mut hash, quantum_flow_template_id);
+    for values in [
+        construction_parent_builder_ids,
+        construction_parent_permutation,
+        reconstruction_parent_permutation,
+        evaluator_parent_permutation,
+        pairing_certificate_ids,
+    ] {
+        hash.update(
+            u64::try_from(values.len())
+                .map_err(|_| invalid("closure candidate sequence length exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for value in values {
+            hash.update(value.to_le_bytes());
+        }
+    }
+    for digests in [
+        construction_parent_semantic_digests,
+        construction_parent_color_digests,
+    ] {
+        hash.update(
+            u64::try_from(digests.len())
+                .map_err(|_| invalid("closure candidate digest sequence length exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for digest in digests {
+            hash.update(digest.as_bytes());
+        }
+    }
+    hash.update(color_witness_term_id.to_le_bytes());
+    hash.update(color_witness_proof_digest.as_bytes());
+    hash_optional_digest(&mut hash, three_line_proof_digest);
+    hash_optional_digest(&mut hash, reflection_proof_digest);
+    hash_exact_factor(&mut hash, exact_factor);
+    hash.update(multiplicity.to_le_bytes());
+    SemanticDigest::new(hash.finalize().into())
+}
+
+impl ClosureProofContributionV2 {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        id: u32,
+        target_sector_id: u32,
+        target_destination_id: Option<u32>,
+        target_helicity_id: Option<u32>,
+        closure_template_id: u32,
+        closure_template_semantic_digest: SemanticDigest,
+        quantum_flow_template_id: Option<u32>,
+        construction_parent_builder_ids: Vec<u32>,
+        construction_parent_runtime_ids: Vec<Option<u32>>,
+        construction_parent_semantic_digests: Vec<SemanticDigest>,
+        construction_parent_color_digests: Vec<SemanticDigest>,
+        construction_parent_permutation: Vec<u32>,
+        reconstruction_parent_permutation: Vec<u32>,
+        evaluator_parent_permutation: Vec<u32>,
+        color_witness_term_id: u32,
+        color_witness_proof_digest: SemanticDigest,
+        three_line_certificate_id: Option<u32>,
+        mut pairing_certificate_ids: Vec<u32>,
+        reflection_certificate_id: Option<u32>,
+        exact_factor: ExactComplexRational,
+        multiplicity: u32,
+    ) -> RusticolResult<Self> {
+        let parent_count = construction_parent_builder_ids.len();
+        if parent_count == 0 {
+            return Err(invalid(
+                "closure proof contribution requires at least one parent",
+            ));
+        }
+        u32::try_from(parent_count)
+            .map_err(|_| invalid("closure proof parent count exceeds u32"))?;
+        if construction_parent_runtime_ids.len() != parent_count
+            || construction_parent_semantic_digests.len() != parent_count
+            || construction_parent_color_digests.len() != parent_count
+        {
+            return Err(invalid(
+                "closure proof builder/runtime parent IDs and semantic/color digests have inconsistent lengths",
+            ));
+        }
+        validate_permutation(
+            "closure construction-parent permutation",
+            &construction_parent_permutation,
+            parent_count,
+        )?;
+        validate_permutation(
+            "closure reconstruction-parent permutation",
+            &reconstruction_parent_permutation,
+            parent_count,
+        )?;
+        validate_permutation(
+            "closure evaluator-parent permutation",
+            &evaluator_parent_permutation,
+            parent_count,
+        )?;
+        if exact_factor.is_zero() {
+            return Err(invalid(
+                "closure proof contribution factor must not be zero",
+            ));
+        }
+        if multiplicity == 0 {
+            return Err(invalid(
+                "closure proof contribution multiplicity must be positive",
+            ));
+        }
+        pairing_certificate_ids.sort_unstable();
+        pairing_certificate_ids.dedup();
+        Ok(Self {
+            id,
+            target_sector_id,
+            target_destination_id,
+            target_helicity_id,
+            closure_template_id,
+            closure_template_semantic_digest,
+            quantum_flow_template_id,
+            construction_parent_builder_ids: construction_parent_builder_ids.into_boxed_slice(),
+            construction_parent_runtime_ids: construction_parent_runtime_ids.into_boxed_slice(),
+            construction_parent_semantic_digests: construction_parent_semantic_digests
+                .into_boxed_slice(),
+            construction_parent_color_digests: construction_parent_color_digests.into_boxed_slice(),
+            construction_parent_permutation: construction_parent_permutation.into_boxed_slice(),
+            reconstruction_parent_permutation: reconstruction_parent_permutation.into_boxed_slice(),
+            evaluator_parent_permutation: evaluator_parent_permutation.into_boxed_slice(),
+            color_witness_term_id,
+            color_witness_proof_digest,
+            three_line_certificate_id,
+            pairing_certificate_ids: pairing_certificate_ids.into_boxed_slice(),
+            reflection_certificate_id,
+            exact_factor,
+            multiplicity,
+        })
+    }
+
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    pub const fn target_sector_id(&self) -> u32 {
+        self.target_sector_id
+    }
+
+    pub const fn target_destination_id(&self) -> Option<u32> {
+        self.target_destination_id
+    }
+
+    pub const fn target_helicity_id(&self) -> Option<u32> {
+        self.target_helicity_id
+    }
+
+    pub const fn closure_template_id(&self) -> u32 {
+        self.closure_template_id
+    }
+
+    pub const fn closure_template_semantic_digest(&self) -> SemanticDigest {
+        self.closure_template_semantic_digest
+    }
+
+    pub const fn quantum_flow_template_id(&self) -> Option<u32> {
+        self.quantum_flow_template_id
+    }
+
+    pub fn construction_parent_builder_ids(&self) -> &[u32] {
+        &self.construction_parent_builder_ids
+    }
+
+    pub fn construction_parent_runtime_ids(&self) -> &[Option<u32>] {
+        &self.construction_parent_runtime_ids
+    }
+
+    pub fn construction_parent_semantic_digests(&self) -> &[SemanticDigest] {
+        &self.construction_parent_semantic_digests
+    }
+
+    pub fn construction_parent_color_digests(&self) -> &[SemanticDigest] {
+        &self.construction_parent_color_digests
+    }
+
+    pub fn construction_parent_permutation(&self) -> &[u32] {
+        &self.construction_parent_permutation
+    }
+
+    pub fn reconstruction_parent_permutation(&self) -> &[u32] {
+        &self.reconstruction_parent_permutation
+    }
+
+    pub fn evaluator_parent_permutation(&self) -> &[u32] {
+        &self.evaluator_parent_permutation
+    }
+
+    pub fn evaluator_parent_builder_ids(&self) -> Vec<u32> {
+        self.evaluator_parent_permutation
+            .iter()
+            .map(|slot| self.construction_parent_builder_ids[*slot as usize])
+            .collect()
+    }
+
+    pub fn evaluator_parent_runtime_ids(&self) -> Option<Vec<u32>> {
+        self.evaluator_parent_permutation
+            .iter()
+            .map(|slot| self.construction_parent_runtime_ids[*slot as usize])
+            .collect()
+    }
+
+    pub const fn color_witness_term_id(&self) -> u32 {
+        self.color_witness_term_id
+    }
+
+    pub const fn color_witness_proof_digest(&self) -> SemanticDigest {
+        self.color_witness_proof_digest
+    }
+
+    pub const fn three_line_certificate_id(&self) -> Option<u32> {
+        self.three_line_certificate_id
+    }
+
+    pub fn pairing_certificate_ids(&self) -> &[u32] {
+        &self.pairing_certificate_ids
+    }
+
+    pub const fn reflection_certificate_id(&self) -> Option<u32> {
+        self.reflection_certificate_id
+    }
+
+    pub const fn exact_factor(&self) -> ExactComplexRational {
+        self.exact_factor
+    }
+
+    pub const fn multiplicity(&self) -> u32 {
+        self.multiplicity
+    }
+}
+
+/// One exact group of proof contributions represented by at most one runtime
+/// closure row. Exact cancellation is retained with both runtime IDs absent.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClosureExecutionProofGroupV2 {
+    id: u32,
+    emitted_runtime_closure_term_id: Option<u32>,
+    emitted_direct_closure_row_id: Option<u32>,
+    contribution_range: CheckedTableRange,
+    exact_summed_factor: ExactComplexRational,
+    component_factor_digest: SemanticDigest,
+    candidate_selector_domain_digest: SemanticDigest,
+    selector_domain_digest: SemanticDigest,
+}
+
+impl ClosureExecutionProofGroupV2 {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        id: u32,
+        emitted_runtime_closure_term_id: Option<u32>,
+        emitted_direct_closure_row_id: Option<u32>,
+        contribution_range: CheckedTableRange,
+        exact_summed_factor: ExactComplexRational,
+        component_factor_digest: SemanticDigest,
+        selector_domain_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        Self::new_with_candidate_selector_domain(
+            id,
+            emitted_runtime_closure_term_id,
+            emitted_direct_closure_row_id,
+            contribution_range,
+            exact_summed_factor,
+            component_factor_digest,
+            selector_domain_digest,
+            selector_domain_digest,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn new_with_candidate_selector_domain(
+        id: u32,
+        emitted_runtime_closure_term_id: Option<u32>,
+        emitted_direct_closure_row_id: Option<u32>,
+        contribution_range: CheckedTableRange,
+        exact_summed_factor: ExactComplexRational,
+        component_factor_digest: SemanticDigest,
+        candidate_selector_domain_digest: SemanticDigest,
+        selector_domain_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        contribution_range.end("closure proof-group contribution")?;
+        if exact_summed_factor.is_zero() {
+            if emitted_runtime_closure_term_id.is_some() || emitted_direct_closure_row_id.is_some()
+            {
+                return Err(invalid(
+                    "exact-zero closure proof group must not reference a runtime closure",
+                ));
+            }
+        } else if emitted_runtime_closure_term_id.is_none() {
+            return Err(invalid(
+                "nonzero closure proof group requires a runtime closure term",
+            ));
+        }
+        Ok(Self {
+            id,
+            emitted_runtime_closure_term_id,
+            emitted_direct_closure_row_id,
+            contribution_range,
+            exact_summed_factor,
+            component_factor_digest,
+            candidate_selector_domain_digest,
+            selector_domain_digest,
+        })
+    }
+
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    pub const fn emitted_runtime_closure_term_id(&self) -> Option<u32> {
+        self.emitted_runtime_closure_term_id
+    }
+
+    pub const fn emitted_direct_closure_row_id(&self) -> Option<u32> {
+        self.emitted_direct_closure_row_id
+    }
+
+    pub const fn contribution_range(&self) -> CheckedTableRange {
+        self.contribution_range
+    }
+
+    pub const fn exact_summed_factor(&self) -> ExactComplexRational {
+        self.exact_summed_factor
+    }
+
+    pub const fn component_factor_digest(&self) -> SemanticDigest {
+        self.component_factor_digest
+    }
+
+    pub const fn candidate_selector_domain_digest(&self) -> SemanticDigest {
+        self.candidate_selector_domain_digest
+    }
+
+    pub const fn selector_domain_digest(&self) -> SemanticDigest {
+        self.selector_domain_digest
+    }
+
+    pub fn with_direct_closure_row_id(&self, row_id: Option<u32>) -> RusticolResult<Self> {
+        self.with_direct_closure_binding(
+            row_id,
+            self.component_factor_digest,
+            self.selector_domain_digest,
+        )
+    }
+
+    pub fn with_direct_closure_binding(
+        &self,
+        row_id: Option<u32>,
+        component_factor_digest: SemanticDigest,
+        selector_domain_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        Self::new_with_candidate_selector_domain(
+            self.id,
+            self.emitted_runtime_closure_term_id,
+            row_id,
+            self.contribution_range,
+            self.exact_summed_factor,
+            component_factor_digest,
+            self.candidate_selector_domain_digest,
+            selector_domain_digest,
+        )
+    }
+}
+
+/// Exact reciprocal-orbit certificate used by folded pure-gluon closures.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ReflectionCertificateV1 {
+    id: u32,
+    orbit_identity: SemanticDigest,
+    reciprocal_identity: SemanticDigest,
+    source_permutation: Box<[u32]>,
+    exact_phase: ExactComplexRational,
+    fixed_point: bool,
+    orbit_size: u32,
+    proof_algorithm_id: u32,
+    proof_digest: SemanticDigest,
+}
+
+impl ReflectionCertificateV1 {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        id: u32,
+        orbit_identity: SemanticDigest,
+        reciprocal_identity: SemanticDigest,
+        source_permutation: Vec<u32>,
+        exact_phase: ExactComplexRational,
+        fixed_point: bool,
+        orbit_size: u32,
+        proof_algorithm_id: u32,
+        proof_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        validate_permutation(
+            "reflection source permutation",
+            &source_permutation,
+            source_permutation.len(),
+        )?;
+        if exact_phase.is_zero() {
+            return Err(invalid("reflection phase must not be zero"));
+        }
+        match (
+            fixed_point,
+            orbit_size,
+            orbit_identity == reciprocal_identity,
+        ) {
+            (true, 1, true) | (false, 2, false) => {}
+            _ => {
+                return Err(invalid(
+                    "reflection fixed-point flag, orbit size, and reciprocal identities disagree",
+                ));
+            }
+        }
+        Ok(Self {
+            id,
+            orbit_identity,
+            reciprocal_identity,
+            source_permutation: source_permutation.into_boxed_slice(),
+            exact_phase,
+            fixed_point,
+            orbit_size,
+            proof_algorithm_id,
+            proof_digest,
+        })
+    }
+
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    pub const fn orbit_identity(&self) -> SemanticDigest {
+        self.orbit_identity
+    }
+
+    pub const fn reciprocal_identity(&self) -> SemanticDigest {
+        self.reciprocal_identity
+    }
+
+    pub fn source_permutation(&self) -> &[u32] {
+        &self.source_permutation
+    }
+
+    pub const fn exact_phase(&self) -> ExactComplexRational {
+        self.exact_phase
+    }
+
+    pub const fn fixed_point(&self) -> bool {
+        self.fixed_point
+    }
+
+    pub const fn orbit_size(&self) -> u32 {
+        self.orbit_size
+    }
+
+    pub const fn proof_algorithm_id(&self) -> u32 {
+        self.proof_algorithm_id
+    }
+
+    pub const fn proof_digest(&self) -> SemanticDigest {
+        self.proof_digest
+    }
+}
+
+/// Certified traversal class for a three-open-line closure.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum ThreeLineTraversalKindV1 {
+    Direct = 0,
+    Partner = 1,
+}
+
+impl ThreeLineTraversalKindV1 {
+    pub const fn code(self) -> u32 {
+        self as u32
+    }
+}
+
+impl TryFrom<u32> for ThreeLineTraversalKindV1 {
+    type Error = RusticolError;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Direct),
+            1 => Ok(Self::Partner),
+            _ => Err(invalid(format!(
+                "three-line traversal kind must be direct (0) or partner (1), found {value}"
+            ))),
+        }
+    }
+}
+
+/// Cold exact witness for one direct or partner traversal of three open lines.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ThreeLineTraversalCertificateV1 {
+    id: u32,
+    sector_id: u32,
+    kind: ThreeLineTraversalKindV1,
+    sink_block_ordinal: u32,
+    reference_block_order: Box<[u32]>,
+    witness_block_order: Box<[u32]>,
+    block_permutation: Box<[u32]>,
+    reference_source_order: Box<[u32]>,
+    witness_source_order: Box<[u32]>,
+    source_position_permutation: Box<[u32]>,
+    closure_anchor_source_slot: u32,
+    pairing_rule_id: u32,
+    proof_digest: SemanticDigest,
+}
+
+impl ThreeLineTraversalCertificateV1 {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        id: u32,
+        sector_id: u32,
+        kind: ThreeLineTraversalKindV1,
+        sink_block_ordinal: u32,
+        reference_block_order: Vec<u32>,
+        witness_block_order: Vec<u32>,
+        block_permutation: Vec<u32>,
+        reference_source_order: Vec<u32>,
+        witness_source_order: Vec<u32>,
+        source_position_permutation: Vec<u32>,
+        closure_anchor_source_slot: u32,
+        pairing_rule_id: u32,
+        proof_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        const BLOCK_COUNT: usize = 3;
+        validate_permutation(
+            "three-line reference block order",
+            &reference_block_order,
+            BLOCK_COUNT,
+        )?;
+        validate_permutation(
+            "three-line witness block order",
+            &witness_block_order,
+            BLOCK_COUNT,
+        )?;
+        validate_permutation(
+            "three-line block permutation",
+            &block_permutation,
+            BLOCK_COUNT,
+        )?;
+        if sink_block_ordinal >= BLOCK_COUNT as u32 {
+            return Err(invalid(format!(
+                "three-line sink block ordinal {sink_block_ordinal} is out of range"
+            )));
+        }
+        if reference_block_order[BLOCK_COUNT - 1] != sink_block_ordinal
+            || witness_block_order[BLOCK_COUNT - 1] != sink_block_ordinal
+        {
+            return Err(invalid(
+                "three-line reference and witness traversals must end at the sink block",
+            ));
+        }
+        for (witness_position, reference_position) in block_permutation.iter().copied().enumerate()
+        {
+            if witness_block_order[witness_position]
+                != reference_block_order[reference_position as usize]
+            {
+                return Err(invalid(
+                    "three-line block permutation does not transport reference order to witness order",
+                ));
+            }
+        }
+        let expected_witness_order = match kind {
+            ThreeLineTraversalKindV1::Direct => reference_block_order.clone(),
+            ThreeLineTraversalKindV1::Partner => {
+                let mut partner = reference_block_order.clone();
+                partner.swap(0, 1);
+                partner
+            }
+        };
+        if witness_block_order != expected_witness_order {
+            return Err(invalid(format!(
+                "three-line {:?} traversal has an inconsistent witness block order",
+                kind
+            )));
+        }
+
+        if reference_source_order.is_empty() {
+            return Err(invalid(
+                "three-line traversal requires a nonempty source order",
+            ));
+        }
+        if witness_source_order.len() != reference_source_order.len() {
+            return Err(invalid(
+                "three-line reference and witness source orders have inconsistent lengths",
+            ));
+        }
+        validate_permutation(
+            "three-line source-position permutation",
+            &source_position_permutation,
+            reference_source_order.len(),
+        )?;
+        if reference_source_order
+            .iter()
+            .copied()
+            .collect::<BTreeSet<_>>()
+            .len()
+            != reference_source_order.len()
+            || witness_source_order
+                .iter()
+                .copied()
+                .collect::<BTreeSet<_>>()
+                .len()
+                != witness_source_order.len()
+        {
+            return Err(invalid(
+                "three-line source orders must contain unique source slots",
+            ));
+        }
+        for (witness_position, reference_position) in
+            source_position_permutation.iter().copied().enumerate()
+        {
+            if witness_source_order[witness_position]
+                != reference_source_order[reference_position as usize]
+            {
+                return Err(invalid(
+                    "three-line source-position permutation does not transport reference order to witness order",
+                ));
+            }
+        }
+        if reference_source_order.last() != Some(&closure_anchor_source_slot)
+            || witness_source_order.last() != Some(&closure_anchor_source_slot)
+        {
+            return Err(invalid(
+                "three-line reference and witness source orders must end at the closure anchor",
+            ));
+        }
+        let expected_proof_digest = three_line_traversal_proof_digest_v1(
+            sector_id,
+            kind,
+            sink_block_ordinal,
+            &reference_block_order,
+            &witness_block_order,
+            &block_permutation,
+            &reference_source_order,
+            &witness_source_order,
+            &source_position_permutation,
+            closure_anchor_source_slot,
+            pairing_rule_id,
+        )?;
+        if proof_digest != expected_proof_digest {
+            return Err(invalid("three-line traversal proof digest mismatch"));
+        }
+        Ok(Self {
+            id,
+            sector_id,
+            kind,
+            sink_block_ordinal,
+            reference_block_order: reference_block_order.into_boxed_slice(),
+            witness_block_order: witness_block_order.into_boxed_slice(),
+            block_permutation: block_permutation.into_boxed_slice(),
+            reference_source_order: reference_source_order.into_boxed_slice(),
+            witness_source_order: witness_source_order.into_boxed_slice(),
+            source_position_permutation: source_position_permutation.into_boxed_slice(),
+            closure_anchor_source_slot,
+            pairing_rule_id,
+            proof_digest,
+        })
+    }
+
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    pub const fn sector_id(&self) -> u32 {
+        self.sector_id
+    }
+
+    pub const fn kind(&self) -> ThreeLineTraversalKindV1 {
+        self.kind
+    }
+
+    pub const fn sink_block_ordinal(&self) -> u32 {
+        self.sink_block_ordinal
+    }
+
+    pub fn reference_block_order(&self) -> &[u32] {
+        &self.reference_block_order
+    }
+
+    pub fn witness_block_order(&self) -> &[u32] {
+        &self.witness_block_order
+    }
+
+    pub fn block_permutation(&self) -> &[u32] {
+        &self.block_permutation
+    }
+
+    pub fn reference_source_order(&self) -> &[u32] {
+        &self.reference_source_order
+    }
+
+    pub fn witness_source_order(&self) -> &[u32] {
+        &self.witness_source_order
+    }
+
+    pub fn source_position_permutation(&self) -> &[u32] {
+        &self.source_position_permutation
+    }
+
+    pub const fn closure_anchor_source_slot(&self) -> u32 {
+        self.closure_anchor_source_slot
+    }
+
+    pub const fn pairing_rule_id(&self) -> u32 {
+        self.pairing_rule_id
+    }
+
+    pub const fn proof_digest(&self) -> SemanticDigest {
+        self.proof_digest
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn three_line_traversal_proof_digest_v1(
+    sector_id: u32,
+    kind: ThreeLineTraversalKindV1,
+    sink_block_ordinal: u32,
+    reference_block_order: &[u32],
+    witness_block_order: &[u32],
+    block_permutation: &[u32],
+    reference_source_order: &[u32],
+    witness_source_order: &[u32],
+    source_position_permutation: &[u32],
+    closure_anchor_source_slot: u32,
+    pairing_rule_id: u32,
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-three-line-traversal-v1\0");
+    hash.update(sector_id.to_le_bytes());
+    hash.update([kind as u8]);
+    hash.update(sink_block_ordinal.to_le_bytes());
+    for values in [
+        reference_block_order,
+        witness_block_order,
+        block_permutation,
+        reference_source_order,
+        witness_source_order,
+        source_position_permutation,
+    ] {
+        hash.update(
+            u64::try_from(values.len())
+                .map_err(|_| invalid("three-line certificate sequence length exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for value in values {
+            hash.update(value.to_le_bytes());
+        }
+    }
+    hash.update(closure_anchor_source_slot.to_le_bytes());
+    hash.update(pairing_rule_id.to_le_bytes());
+    SemanticDigest::new(hash.finalize().into())
+}
+
+fn closure_candidate_domain_certificate_from_tables_v1(
+    contributions: &[ClosureProofContributionV2],
+    groups: &[ClosureExecutionProofGroupV2],
+    reflection_certificates: &[ReflectionCertificateV1],
+    three_line_traversal_certificates: &[ThreeLineTraversalCertificateV1],
+) -> RusticolResult<ClosureCandidateDomainCertificateV1> {
+    let mut identity_digests = Vec::with_capacity(contributions.len());
+    for group in groups {
+        let range = group
+            .contribution_range
+            .as_usize_range(contributions.len(), "closure candidate-domain contribution")?;
+        for contribution in &contributions[range] {
+            let three_line_proof_digest = contribution
+                .three_line_certificate_id
+                .map(|certificate_id| {
+                    three_line_traversal_certificates
+                        .get(certificate_id as usize)
+                        .map(ThreeLineTraversalCertificateV1::proof_digest)
+                        .ok_or_else(|| {
+                            invalid(format!(
+                                "closure candidate references absent three-line certificate {certificate_id}"
+                            ))
+                        })
+                })
+                .transpose()?;
+            let reflection_proof_digest = contribution
+                .reflection_certificate_id
+                .map(|certificate_id| {
+                    reflection_certificates
+                        .get(certificate_id as usize)
+                        .map(ReflectionCertificateV1::proof_digest)
+                        .ok_or_else(|| {
+                            invalid(format!(
+                                "closure candidate references absent reflection certificate {certificate_id}"
+                            ))
+                        })
+                })
+                .transpose()?;
+            identity_digests.push(closure_candidate_identity_digest_v1(
+                group.candidate_selector_domain_digest,
+                contribution.target_sector_id,
+                contribution.closure_template_id,
+                contribution.closure_template_semantic_digest,
+                contribution.quantum_flow_template_id,
+                &contribution.construction_parent_builder_ids,
+                &contribution.construction_parent_semantic_digests,
+                &contribution.construction_parent_color_digests,
+                &contribution.construction_parent_permutation,
+                &contribution.reconstruction_parent_permutation,
+                &contribution.evaluator_parent_permutation,
+                contribution.color_witness_term_id,
+                contribution.color_witness_proof_digest,
+                three_line_proof_digest,
+                &contribution.pairing_certificate_ids,
+                reflection_proof_digest,
+                contribution.exact_factor,
+                contribution.multiplicity,
+            )?);
+        }
+    }
+    ClosureCandidateDomainCertificateV1::from_identity_digests(identity_digests)
+}
+
+/// Cold exact closure-completeness metadata shared by program and direct plan.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClosureProofMetadataV2 {
+    contributions: Box<[ClosureProofContributionV2]>,
+    groups: Box<[ClosureExecutionProofGroupV2]>,
+    reflection_certificates: Box<[ReflectionCertificateV1]>,
+    three_line_traversal_certificates: Box<[ThreeLineTraversalCertificateV1]>,
+    candidate_domain_certificate: ClosureCandidateDomainCertificateV1,
+    expected_semantic_completeness_digest: SemanticDigest,
+}
+
+impl ClosureProofMetadataV2 {
+    pub fn new(
+        contributions: Vec<ClosureProofContributionV2>,
+        groups: Vec<ClosureExecutionProofGroupV2>,
+        reflection_certificates: Vec<ReflectionCertificateV1>,
+    ) -> RusticolResult<Self> {
+        Self::new_with_three_line_certificates(
+            contributions,
+            groups,
+            reflection_certificates,
+            Vec::new(),
+        )
+    }
+
+    pub fn new_with_three_line_certificates(
+        contributions: Vec<ClosureProofContributionV2>,
+        groups: Vec<ClosureExecutionProofGroupV2>,
+        reflection_certificates: Vec<ReflectionCertificateV1>,
+        three_line_traversal_certificates: Vec<ThreeLineTraversalCertificateV1>,
+    ) -> RusticolResult<Self> {
+        validate_closure_proof_tables(
+            &contributions,
+            &groups,
+            &reflection_certificates,
+            &three_line_traversal_certificates,
+        )?;
+        let candidate_domain_certificate = closure_candidate_domain_certificate_from_tables_v1(
+            &contributions,
+            &groups,
+            &reflection_certificates,
+            &three_line_traversal_certificates,
+        )?;
+        Self::new_with_three_line_certificates_and_candidate_domain(
+            contributions,
+            groups,
+            reflection_certificates,
+            three_line_traversal_certificates,
+            candidate_domain_certificate,
+        )
+    }
+
+    pub fn new_with_three_line_certificates_and_candidate_domain(
+        contributions: Vec<ClosureProofContributionV2>,
+        groups: Vec<ClosureExecutionProofGroupV2>,
+        reflection_certificates: Vec<ReflectionCertificateV1>,
+        three_line_traversal_certificates: Vec<ThreeLineTraversalCertificateV1>,
+        candidate_domain_certificate: ClosureCandidateDomainCertificateV1,
+    ) -> RusticolResult<Self> {
+        validate_closure_proof_tables(
+            &contributions,
+            &groups,
+            &reflection_certificates,
+            &three_line_traversal_certificates,
+        )?;
+        let actual_candidate_domain_certificate =
+            closure_candidate_domain_certificate_from_tables_v1(
+                &contributions,
+                &groups,
+                &reflection_certificates,
+                &three_line_traversal_certificates,
+            )?;
+        if actual_candidate_domain_certificate != candidate_domain_certificate {
+            return Err(invalid(
+                "closure candidate-domain certificate does not match persisted proof rows",
+            ));
+        }
+        let expected_semantic_completeness_digest =
+            closure_proof_semantic_completeness_digest_with_three_line_v2(
+                &contributions,
+                &groups,
+                &reflection_certificates,
+                &three_line_traversal_certificates,
+            )?;
+        Ok(Self {
+            contributions: contributions.into_boxed_slice(),
+            groups: groups.into_boxed_slice(),
+            reflection_certificates: reflection_certificates.into_boxed_slice(),
+            three_line_traversal_certificates: three_line_traversal_certificates.into_boxed_slice(),
+            candidate_domain_certificate,
+            expected_semantic_completeness_digest,
+        })
+    }
+
+    pub fn new_with_expected_digest(
+        contributions: Vec<ClosureProofContributionV2>,
+        groups: Vec<ClosureExecutionProofGroupV2>,
+        reflection_certificates: Vec<ReflectionCertificateV1>,
+        expected_semantic_completeness_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        let metadata = Self::new(contributions, groups, reflection_certificates)?;
+        metadata.validate_expected_digest(expected_semantic_completeness_digest)
+    }
+
+    pub fn new_with_three_line_certificates_and_expected_digest(
+        contributions: Vec<ClosureProofContributionV2>,
+        groups: Vec<ClosureExecutionProofGroupV2>,
+        reflection_certificates: Vec<ReflectionCertificateV1>,
+        three_line_traversal_certificates: Vec<ThreeLineTraversalCertificateV1>,
+        expected_semantic_completeness_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        let metadata = Self::new_with_three_line_certificates(
+            contributions,
+            groups,
+            reflection_certificates,
+            three_line_traversal_certificates,
+        )?;
+        metadata.validate_expected_digest(expected_semantic_completeness_digest)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn new_with_three_line_certificates_candidate_domain_and_expected_digest(
+        contributions: Vec<ClosureProofContributionV2>,
+        groups: Vec<ClosureExecutionProofGroupV2>,
+        reflection_certificates: Vec<ReflectionCertificateV1>,
+        three_line_traversal_certificates: Vec<ThreeLineTraversalCertificateV1>,
+        candidate_domain_certificate: ClosureCandidateDomainCertificateV1,
+        expected_semantic_completeness_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        let metadata = Self::new_with_three_line_certificates_and_candidate_domain(
+            contributions,
+            groups,
+            reflection_certificates,
+            three_line_traversal_certificates,
+            candidate_domain_certificate,
+        )?;
+        metadata.validate_expected_digest(expected_semantic_completeness_digest)
+    }
+
+    fn validate_expected_digest(
+        self,
+        expected_semantic_completeness_digest: SemanticDigest,
+    ) -> RusticolResult<Self> {
+        if self.expected_semantic_completeness_digest != expected_semantic_completeness_digest {
+            return Err(invalid(
+                "closure proof semantic completeness digest mismatch",
+            ));
+        }
+        Ok(self)
+    }
+
+    pub fn contributions(&self) -> &[ClosureProofContributionV2] {
+        &self.contributions
+    }
+
+    pub fn groups(&self) -> &[ClosureExecutionProofGroupV2] {
+        &self.groups
+    }
+
+    pub fn reflection_certificates(&self) -> &[ReflectionCertificateV1] {
+        &self.reflection_certificates
+    }
+
+    pub fn three_line_traversal_certificates(&self) -> &[ThreeLineTraversalCertificateV1] {
+        &self.three_line_traversal_certificates
+    }
+
+    pub const fn candidate_domain_certificate(&self) -> ClosureCandidateDomainCertificateV1 {
+        self.candidate_domain_certificate
+    }
+
+    pub const fn expected_semantic_completeness_digest(&self) -> SemanticDigest {
+        self.expected_semantic_completeness_digest
+    }
+
+    pub fn group_for_runtime_term(
+        &self,
+        closure_term_id: u32,
+    ) -> Option<&ClosureExecutionProofGroupV2> {
+        self.groups
+            .iter()
+            .find(|group| group.emitted_runtime_closure_term_id == Some(closure_term_id))
+    }
+
+    pub fn with_direct_closure_rows(&self, row_by_runtime_term: &[u32]) -> RusticolResult<Self> {
+        let groups = self
+            .groups
+            .iter()
+            .map(|group| {
+                let row_id = group
+                    .emitted_runtime_closure_term_id
+                    .map(|term_id| {
+                        row_by_runtime_term
+                            .get(term_id as usize)
+                            .copied()
+                            .ok_or_else(|| {
+                                invalid(format!(
+                                    "closure proof group {} references absent runtime term {term_id}",
+                                    group.id
+                                ))
+                            })
+                    })
+                    .transpose()?;
+                group.with_direct_closure_row_id(row_id)
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        Self::new_with_three_line_certificates_and_candidate_domain(
+            self.contributions.to_vec(),
+            groups,
+            self.reflection_certificates.to_vec(),
+            self.three_line_traversal_certificates.to_vec(),
+            self.candidate_domain_certificate,
+        )
+    }
+
+    pub(crate) fn validate_tables(&self) -> RusticolResult<()> {
+        validate_closure_proof_tables(
+            &self.contributions,
+            &self.groups,
+            &self.reflection_certificates,
+            &self.three_line_traversal_certificates,
+        )?;
+        if closure_proof_semantic_completeness_digest_with_three_line_v2(
+            &self.contributions,
+            &self.groups,
+            &self.reflection_certificates,
+            &self.three_line_traversal_certificates,
+        )? != self.expected_semantic_completeness_digest
+        {
+            return Err(invalid(
+                "closure proof semantic completeness digest mismatch",
+            ));
+        }
+        if closure_candidate_domain_certificate_from_tables_v1(
+            &self.contributions,
+            &self.groups,
+            &self.reflection_certificates,
+            &self.three_line_traversal_certificates,
+        )? != self.candidate_domain_certificate
+        {
+            return Err(invalid(
+                "closure candidate-domain certificate does not match persisted proof rows",
+            ));
+        }
+        Ok(())
+    }
+
+    pub(crate) fn discard_rows_for_runtime(&mut self) {
+        self.contributions = Box::default();
+        self.groups = Box::default();
+        self.reflection_certificates = Box::default();
+        self.three_line_traversal_certificates = Box::default();
+    }
+}
+
+pub fn closure_component_factor_digest_v2(
+    factors: &[ExactComplexRational],
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-closure-component-factors-v2\0");
+    hash.update(
+        u64::try_from(factors.len())
+            .map_err(|_| invalid("closure component-factor count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for factor in factors {
+        hash_exact_factor(&mut hash, *factor);
+    }
+    SemanticDigest::new(hash.finalize().into())
+}
+
+pub fn closure_selector_domain_digest_v2(words: &[u64]) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-closure-selector-domain-v2\0");
+    hash.update(
+        u64::try_from(words.len())
+            .map_err(|_| invalid("closure selector-domain word count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for word in words {
+        hash.update(word.to_le_bytes());
+    }
+    SemanticDigest::new(hash.finalize().into())
+}
+
+pub fn closure_proof_semantic_completeness_digest_v2(
+    contributions: &[ClosureProofContributionV2],
+    groups: &[ClosureExecutionProofGroupV2],
+    reflection_certificates: &[ReflectionCertificateV1],
+) -> RusticolResult<SemanticDigest> {
+    closure_proof_semantic_completeness_digest_with_three_line_v2(
+        contributions,
+        groups,
+        reflection_certificates,
+        &[],
+    )
+}
+
+pub fn closure_proof_semantic_completeness_digest_with_three_line_v2(
+    contributions: &[ClosureProofContributionV2],
+    groups: &[ClosureExecutionProofGroupV2],
+    reflection_certificates: &[ReflectionCertificateV1],
+    three_line_traversal_certificates: &[ThreeLineTraversalCertificateV1],
+) -> RusticolResult<SemanticDigest> {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-closure-proof-v2\0");
+    hash.update(
+        u64::try_from(contributions.len())
+            .map_err(|_| invalid("closure proof contribution count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for row in contributions {
+        hash.update(row.id.to_le_bytes());
+        hash.update(row.target_sector_id.to_le_bytes());
+        hash_optional_u32(&mut hash, row.target_destination_id);
+        hash_optional_u32(&mut hash, row.target_helicity_id);
+        hash.update(row.closure_template_id.to_le_bytes());
+        hash.update(row.closure_template_semantic_digest.as_bytes());
+        hash_optional_u32(&mut hash, row.quantum_flow_template_id);
+        for values in [
+            row.construction_parent_builder_ids.as_ref(),
+            row.construction_parent_permutation.as_ref(),
+            row.reconstruction_parent_permutation.as_ref(),
+            row.evaluator_parent_permutation.as_ref(),
+        ] {
+            hash.update(
+                u64::try_from(values.len())
+                    .map_err(|_| invalid("closure proof sequence length exceeds u64"))?
+                    .to_le_bytes(),
+            );
+            for value in values {
+                hash.update(value.to_le_bytes());
+            }
+        }
+        hash.update(
+            u64::try_from(row.construction_parent_runtime_ids.len())
+                .map_err(|_| invalid("closure proof runtime-parent sequence length exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for value in row.construction_parent_runtime_ids.iter().copied() {
+            hash_optional_u32(&mut hash, value);
+        }
+        for digests in [
+            row.construction_parent_semantic_digests.as_ref(),
+            row.construction_parent_color_digests.as_ref(),
+        ] {
+            hash.update(
+                u64::try_from(digests.len())
+                    .map_err(|_| invalid("closure proof digest sequence length exceeds u64"))?
+                    .to_le_bytes(),
+            );
+            for digest in digests {
+                hash.update(digest.as_bytes());
+            }
+        }
+        hash.update(row.color_witness_term_id.to_le_bytes());
+        hash.update(row.color_witness_proof_digest.as_bytes());
+        hash_optional_u32(&mut hash, row.three_line_certificate_id);
+        hash.update(
+            u64::try_from(row.pairing_certificate_ids.len())
+                .map_err(|_| invalid("closure pairing-certificate count exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for certificate_id in row.pairing_certificate_ids.iter().copied() {
+            hash.update(certificate_id.to_le_bytes());
+        }
+        hash_optional_u32(&mut hash, row.reflection_certificate_id);
+        hash_exact_factor(&mut hash, row.exact_factor);
+        hash.update(row.multiplicity.to_le_bytes());
+    }
+    hash.update(
+        u64::try_from(groups.len())
+            .map_err(|_| invalid("closure proof group count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for row in groups {
+        hash.update(row.id.to_le_bytes());
+        hash_optional_u32(&mut hash, row.emitted_runtime_closure_term_id);
+        hash_optional_u32(&mut hash, row.emitted_direct_closure_row_id);
+        hash.update(row.contribution_range.start.to_le_bytes());
+        hash.update(row.contribution_range.count.to_le_bytes());
+        hash_exact_factor(&mut hash, row.exact_summed_factor);
+        hash.update(row.component_factor_digest.as_bytes());
+        hash.update(row.candidate_selector_domain_digest.as_bytes());
+        hash.update(row.selector_domain_digest.as_bytes());
+    }
+    hash.update(
+        u64::try_from(reflection_certificates.len())
+            .map_err(|_| invalid("reflection certificate count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for row in reflection_certificates {
+        hash.update(row.id.to_le_bytes());
+        hash.update(row.orbit_identity.as_bytes());
+        hash.update(row.reciprocal_identity.as_bytes());
+        hash.update(
+            u64::try_from(row.source_permutation.len())
+                .map_err(|_| invalid("reflection permutation length exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for value in row.source_permutation.iter() {
+            hash.update(value.to_le_bytes());
+        }
+        hash_exact_factor(&mut hash, row.exact_phase);
+        hash.update(u8::from(row.fixed_point).to_le_bytes());
+        hash.update(row.orbit_size.to_le_bytes());
+        hash.update(row.proof_algorithm_id.to_le_bytes());
+        hash.update(row.proof_digest.as_bytes());
+    }
+    hash.update(
+        u64::try_from(three_line_traversal_certificates.len())
+            .map_err(|_| invalid("three-line traversal certificate count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for row in three_line_traversal_certificates {
+        hash.update(row.id.to_le_bytes());
+        hash.update(row.sector_id.to_le_bytes());
+        hash.update([row.kind as u8]);
+        hash.update(row.sink_block_ordinal.to_le_bytes());
+        for values in [
+            row.reference_block_order.as_ref(),
+            row.witness_block_order.as_ref(),
+            row.block_permutation.as_ref(),
+            row.reference_source_order.as_ref(),
+            row.witness_source_order.as_ref(),
+            row.source_position_permutation.as_ref(),
+        ] {
+            hash.update(
+                u64::try_from(values.len())
+                    .map_err(|_| invalid("three-line certificate sequence length exceeds u64"))?
+                    .to_le_bytes(),
+            );
+            for value in values {
+                hash.update(value.to_le_bytes());
+            }
+        }
+        hash.update(row.closure_anchor_source_slot.to_le_bytes());
+        hash.update(row.pairing_rule_id.to_le_bytes());
+        hash.update(row.proof_digest.as_bytes());
+    }
+    let candidate_domain_certificate = closure_candidate_domain_certificate_from_tables_v1(
+        contributions,
+        groups,
+        reflection_certificates,
+        three_line_traversal_certificates,
+    )?;
+    hash.update(
+        candidate_domain_certificate
+            .accepted_candidate_count()
+            .to_le_bytes(),
+    );
+    hash.update(
+        candidate_domain_certificate
+            .accepted_candidate_digest()
+            .as_bytes(),
+    );
+    SemanticDigest::new(hash.finalize().into())
+}
+
+fn validate_closure_proof_tables(
+    contributions: &[ClosureProofContributionV2],
+    groups: &[ClosureExecutionProofGroupV2],
+    reflection_certificates: &[ReflectionCertificateV1],
+    three_line_traversal_certificates: &[ThreeLineTraversalCertificateV1],
+) -> RusticolResult<()> {
+    u32::try_from(contributions.len())
+        .map_err(|_| invalid("closure proof contribution count exceeds u32"))?;
+    u32::try_from(groups.len()).map_err(|_| invalid("closure proof group count exceeds u32"))?;
+    u32::try_from(reflection_certificates.len())
+        .map_err(|_| invalid("reflection certificate count exceeds u32"))?;
+    u32::try_from(three_line_traversal_certificates.len())
+        .map_err(|_| invalid("three-line traversal certificate count exceeds u32"))?;
+
+    for (index, certificate) in reflection_certificates.iter().enumerate() {
+        if certificate.id != index as u32 {
+            return Err(invalid(format!(
+                "reflection certificate row {index} has non-dense id {}",
+                certificate.id
+            )));
+        }
+    }
+    for (index, certificate) in three_line_traversal_certificates.iter().enumerate() {
+        if certificate.id != index as u32 {
+            return Err(invalid(format!(
+                "three-line traversal certificate row {index} has non-dense id {}",
+                certificate.id
+            )));
+        }
+    }
+    for (index, contribution) in contributions.iter().enumerate() {
+        if contribution.id != index as u32 {
+            return Err(invalid(format!(
+                "closure proof contribution row {index} has non-dense id {}",
+                contribution.id
+            )));
+        }
+        if let Some(certificate_id) = contribution.reflection_certificate_id
+            && certificate_id as usize >= reflection_certificates.len()
+        {
+            return Err(invalid(format!(
+                "closure proof contribution {index} references absent reflection certificate {certificate_id}"
+            )));
+        }
+        if let Some(certificate_id) = contribution.three_line_certificate_id {
+            let Some(certificate) = three_line_traversal_certificates.get(certificate_id as usize)
+            else {
+                return Err(invalid(format!(
+                    "closure proof contribution {index} references absent three-line traversal certificate {certificate_id}"
+                )));
+            };
+            if certificate.sector_id != contribution.target_sector_id {
+                return Err(invalid(format!(
+                    "closure proof contribution {index} sector {} does not match three-line traversal certificate {certificate_id} sector {}",
+                    contribution.target_sector_id, certificate.sector_id
+                )));
+            }
+        }
+    }
+
+    let mut next_contribution = 0u64;
+    for (index, group) in groups.iter().enumerate() {
+        if group.id != index as u32 {
+            return Err(invalid(format!(
+                "closure proof group row {index} has non-dense id {}",
+                group.id
+            )));
+        }
+        if group.contribution_range.start != next_contribution {
+            return Err(invalid(format!(
+                "closure proof group {index} starts at {}, expected packed offset {next_contribution}",
+                group.contribution_range.start
+            )));
+        }
+        let range = group.contribution_range.as_usize_range(
+            contributions.len(),
+            &format!("closure proof group {index} contribution"),
+        )?;
+        if range.is_empty() {
+            return Err(invalid(format!(
+                "closure proof group {index} has no contributions"
+            )));
+        }
+        let group_contributions = &contributions[range];
+        next_contribution = group
+            .contribution_range
+            .end("closure proof-group contribution")?;
+        let mut exact_sum = ExactComplexRational::ZERO;
+        let mut execution_identity = None;
+        for contribution in group_contributions {
+            let multiplicity = ExactComplexRational::new(
+                ExactRational::new(i128::from(contribution.multiplicity), 1)?,
+                ExactRational::ZERO,
+            );
+            exact_sum =
+                exact_sum.checked_add(contribution.exact_factor.checked_mul(multiplicity)?)?;
+            let proof_identity = (
+                contribution.target_sector_id,
+                contribution.target_helicity_id,
+                contribution.closure_template_id,
+                contribution.quantum_flow_template_id,
+                contribution.evaluator_parent_builder_ids(),
+            );
+            if let Some(expected) = &execution_identity {
+                if expected != &proof_identity {
+                    return Err(invalid(format!(
+                        "closure proof group {index} mixes distinct construction identities"
+                    )));
+                }
+            } else {
+                execution_identity = Some(proof_identity);
+            }
+        }
+        if exact_sum != group.exact_summed_factor {
+            return Err(invalid(format!(
+                "closure proof group {index} exact factor does not equal its contribution sum"
+            )));
+        }
+        match (
+            exact_sum.is_zero(),
+            group.emitted_runtime_closure_term_id,
+            group.emitted_direct_closure_row_id,
+        ) {
+            (true, None, None) | (false, Some(_), None | Some(_)) => {}
+            (true, _, _) => {
+                return Err(invalid(format!(
+                    "exact-zero closure proof group {index} references a runtime closure"
+                )));
+            }
+            (false, None, _) => {
+                return Err(invalid(format!(
+                    "nonzero closure proof group {index} has no runtime closure term"
+                )));
+            }
+        }
+        if !exact_sum.is_zero() {
+            for contribution in group_contributions {
+                if contribution.target_destination_id.is_none()
+                    || contribution.evaluator_parent_runtime_ids().is_none()
+                {
+                    return Err(invalid(format!(
+                        "nonzero closure proof group {index} lacks a complete runtime binding"
+                    )));
+                }
+            }
+        }
+    }
+    if next_contribution != contributions.len() as u64 {
+        return Err(invalid(format!(
+            "closure proof groups consume {next_contribution} of {} contributions",
+            contributions.len()
+        )));
+    }
+    Ok(())
+}
+
+/// One source or propagated current in topological execution order.
+///
+/// For a source, the key's dynamic color-state ID refers to the materialized
+/// result of a compiler-owned source-color seed. This schedule never infers a
+/// seed from particle identity, representation, or source position.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceCurrent {
+    id: u32,
+    key: CurrentCoreKey,
+    source_exact_factor: Option<ExactComplexRational>,
+    contribution_range: CheckedTableRange,
+    finalization_id: Option<u32>,
+}
+
+impl RecurrenceCurrent {
+    pub fn new(
+        id: u32,
+        key: CurrentCoreKey,
+        source_exact_factor: Option<ExactComplexRational>,
+        contribution_range: CheckedTableRange,
+        finalization_id: Option<u32>,
+    ) -> RusticolResult<Self> {
+        contribution_range.end("recurrence current contribution")?;
+        if source_exact_factor.is_some_and(ExactComplexRational::is_zero) {
+            return Err(invalid("recurrence source factor must not be zero"));
+        }
+        Ok(Self {
+            id,
+            key,
+            source_exact_factor,
+            contribution_range,
+            finalization_id,
+        })
+    }
+
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    pub const fn key(&self) -> &CurrentCoreKey {
+        &self.key
+    }
+
+    pub const fn contribution_range(&self) -> CheckedTableRange {
+        self.contribution_range
+    }
+
+    pub const fn source_exact_factor(&self) -> Option<ExactComplexRational> {
+        self.source_exact_factor
+    }
+
+    pub const fn fan_in(&self) -> u64 {
+        self.contribution_range.count
+    }
+
+    pub const fn finalization_id(&self) -> Option<u32> {
+        self.finalization_id
+    }
+
+    pub const fn is_source(&self) -> bool {
+        matches!(self.key.node_kind(), RecurrenceNodeKind::Source)
+    }
+}
+
+/// One exact contribution accumulated into one result current.
+///
+/// The key's color-witness term owns the compiler-certified result-component
+/// role (active, passive, or absent). The program only stores its materialized
+/// result current and does not derive that role from parent ordering.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceContribution {
+    id: u32,
+    result_current_id: u32,
+    parent_current_ids: Box<[u32]>,
+    key: ContributionKey,
+    exact_factor: ExactComplexRational,
+}
+
+impl RecurrenceContribution {
+    pub fn new(
+        id: u32,
+        result_current_id: u32,
+        parent_current_ids: Vec<u32>,
+        key: ContributionKey,
+        exact_factor: ExactComplexRational,
+    ) -> RusticolResult<Self> {
+        if parent_current_ids.is_empty() {
+            return Err(invalid(
+                "recurrence contribution requires at least one parent current",
+            ));
+        }
+        u32::try_from(parent_current_ids.len())
+            .map_err(|_| invalid("recurrence contribution parent count exceeds u32"))?;
+        if exact_factor.is_zero() {
+            return Err(invalid("recurrence contribution factor must not be zero"));
+        }
+        Ok(Self {
+            id,
+            result_current_id,
+            parent_current_ids: parent_current_ids.into_boxed_slice(),
+            key,
+            exact_factor,
+        })
+    }
+
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    pub const fn result_current_id(&self) -> u32 {
+        self.result_current_id
+    }
+
+    pub fn parent_current_ids(&self) -> &[u32] {
+        &self.parent_current_ids
+    }
+
+    pub const fn key(&self) -> &ContributionKey {
+        &self.key
+    }
+
+    pub const fn exact_factor(&self) -> ExactComplexRational {
+        self.exact_factor
+    }
+}
+
+/// Exactly one propagation/finalization operation for one non-source current.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceFinalization {
+    id: u32,
+    current_id: u32,
+    propagator_template_id: Option<u32>,
+    exact_factor: ExactComplexRational,
+}
+
+/// One complete physical helicity retained by a topology-replay schedule.
+///
+/// Currents retain only their local source-state ancestry. This catalog names
+/// the complete ancestry reached by closure terms so amplitudes from distinct
+/// helicities are never added coherently before squaring.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceResolvedHelicity {
+    id: u32,
+    source_states: Box<[SourceStateAssignment]>,
+    public_helicities: Box<[i32]>,
+}
+
+/// One live amplitude destination and its packed closure-term range.
+///
+/// Destinations are sparse: topology replay stores only live combinations of
+/// a materialized representative sector and a resolved helicity, never their
+/// Cartesian product.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct RecurrenceAmplitudeDestination {
+    id: u32,
+    target_sector_id: u32,
+    target_helicity_id: Option<u32>,
+    closure_range: CheckedTableRange,
+}
+
+/// One exact topology-replay route from a materialized recurrence to a public sector.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceReplayTarget {
+    id: u32,
+    materialized_sector_id: u32,
+    target_sector_id: u32,
+    source_slot_permutation: Box<[u32]>,
+    source_momentum_signs: Box<[i32]>,
+    amplitude_factor: ExactComplexRational,
+}
+
+impl RecurrenceReplayTarget {
+    pub fn new(
+        id: u32,
+        materialized_sector_id: u32,
+        target_sector_id: u32,
+        source_slot_permutation: Vec<u32>,
+        source_momentum_signs: Vec<i32>,
+        amplitude_factor: ExactComplexRational,
+    ) -> RusticolResult<Self> {
+        if source_slot_permutation.is_empty() {
+            return Err(invalid(
+                "recurrence replay target requires a source permutation",
+            ));
+        }
+        if source_momentum_signs.len() != source_slot_permutation.len()
+            || source_momentum_signs
+                .iter()
+                .any(|sign| !matches!(sign, -1 | 1))
+        {
+            return Err(invalid(
+                "recurrence replay target requires one signed momentum map per source",
+            ));
+        }
+        if amplitude_factor.is_zero() {
+            return Err(invalid("recurrence replay target factor must not be zero"));
+        }
+        Ok(Self {
+            id,
+            materialized_sector_id,
+            target_sector_id,
+            source_slot_permutation: source_slot_permutation.into_boxed_slice(),
+            source_momentum_signs: source_momentum_signs.into_boxed_slice(),
+            amplitude_factor,
+        })
+    }
+
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    pub const fn materialized_sector_id(&self) -> u32 {
+        self.materialized_sector_id
+    }
+
+    pub const fn target_sector_id(&self) -> u32 {
+        self.target_sector_id
+    }
+
+    pub fn source_slot_permutation(&self) -> &[u32] {
+        &self.source_slot_permutation
+    }
+
+    pub fn source_momentum_signs(&self) -> &[i32] {
+        &self.source_momentum_signs
+    }
+
+    pub const fn amplitude_factor(&self) -> ExactComplexRational {
+        self.amplitude_factor
+    }
+}
+
+impl RecurrenceAmplitudeDestination {
+    pub fn new(
+        id: u32,
+        target_sector_id: u32,
+        target_helicity_id: Option<u32>,
+        closure_range: CheckedTableRange,
+    ) -> RusticolResult<Self> {
+        closure_range.end("recurrence amplitude destination")?;
+        if closure_range.count == 0 {
+            return Err(invalid(
+                "recurrence amplitude destination requires closure terms",
+            ));
+        }
+        Ok(Self {
+            id,
+            target_sector_id,
+            target_helicity_id,
+            closure_range,
+        })
+    }
+
+    pub const fn id(self) -> u32 {
+        self.id
+    }
+
+    pub const fn target_sector_id(self) -> u32 {
+        self.target_sector_id
+    }
+
+    pub const fn target_helicity_id(self) -> Option<u32> {
+        self.target_helicity_id
+    }
+
+    pub const fn closure_range(self) -> CheckedTableRange {
+        self.closure_range
+    }
+}
+
+impl RecurrenceResolvedHelicity {
+    pub fn new(
+        id: u32,
+        source_states: Vec<SourceStateAssignment>,
+        public_helicities: Vec<i32>,
+    ) -> RusticolResult<Self> {
+        if source_states.is_empty() || source_states.len() != public_helicities.len() {
+            return Err(invalid(
+                "resolved helicity requires one public value per source-state assignment",
+            ));
+        }
+        for (source_slot, assignment) in source_states.iter().copied().enumerate() {
+            if assignment.source_slot() as usize != source_slot {
+                return Err(invalid(
+                    "resolved-helicity source states must cover every source slot in order",
+                ));
+            }
+        }
+        Ok(Self {
+            id,
+            source_states: source_states.into_boxed_slice(),
+            public_helicities: public_helicities.into_boxed_slice(),
+        })
+    }
+
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    pub fn source_states(&self) -> &[SourceStateAssignment] {
+        &self.source_states
+    }
+
+    pub fn public_helicities(&self) -> &[i32] {
+        &self.public_helicities
+    }
+}
+
+impl RecurrenceFinalization {
+    pub fn new(
+        id: u32,
+        current_id: u32,
+        propagator_template_id: Option<u32>,
+        exact_factor: ExactComplexRational,
+    ) -> RusticolResult<Self> {
+        if exact_factor.is_zero() {
+            return Err(invalid("recurrence finalization factor must not be zero"));
+        }
+        Ok(Self {
+            id,
+            current_id,
+            propagator_template_id,
+            exact_factor,
+        })
+    }
+
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    pub const fn current_id(&self) -> u32 {
+        self.current_id
+    }
+
+    pub const fn propagator_template_id(&self) -> Option<u32> {
+        self.propagator_template_id
+    }
+
+    pub const fn exact_factor(&self) -> ExactComplexRational {
+        self.exact_factor
+    }
+}
+
+/// One exact signed term contributing to one physical LC target sector.
+///
+/// The closure template owns the result-component kind. `target_sector_id` is
+/// only the reduction destination selected after validating the physical
+/// sector's compiler-owned closure anchor; it is not itself an anchor or an
+/// instruction for reconstructing one.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceClosureTerm {
+    id: u32,
+    target_destination_id: u32,
+    closure_template_id: u32,
+    quantum_flow_template_id: Option<u32>,
+    parent_current_ids: Box<[u32]>,
+    exact_factor: ExactComplexRational,
+}
+
+impl RecurrenceClosureTerm {
+    pub fn new(
+        id: u32,
+        target_destination_id: u32,
+        closure_template_id: u32,
+        quantum_flow_template_id: Option<u32>,
+        parent_current_ids: Vec<u32>,
+        exact_factor: ExactComplexRational,
+    ) -> RusticolResult<Self> {
+        if parent_current_ids.is_empty() {
+            return Err(invalid(
+                "recurrence closure term requires at least one parent current",
+            ));
+        }
+        u32::try_from(parent_current_ids.len())
+            .map_err(|_| invalid("recurrence closure parent count exceeds u32"))?;
+        if exact_factor.is_zero() {
+            return Err(invalid("recurrence closure term factor must not be zero"));
+        }
+        Ok(Self {
+            id,
+            target_destination_id,
+            closure_template_id,
+            quantum_flow_template_id,
+            parent_current_ids: parent_current_ids.into_boxed_slice(),
+            exact_factor,
+        })
+    }
+
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    pub const fn target_destination_id(&self) -> u32 {
+        self.target_destination_id
+    }
+
+    pub const fn closure_template_id(&self) -> u32 {
+        self.closure_template_id
+    }
+
+    /// Prepared quantum-flow witness for a kernel closure.
+    ///
+    /// Direct Rusticol closure templates have no vertex coupling and therefore
+    /// carry `None`.
+    pub const fn quantum_flow_template_id(&self) -> Option<u32> {
+        self.quantum_flow_template_id
+    }
+
+    pub fn parent_current_ids(&self) -> &[u32] {
+        &self.parent_current_ids
+    }
+
+    pub const fn exact_factor(&self) -> ExactComplexRational {
+        self.exact_factor
+    }
+}
+
+/// Validated compact recurrence program ready for serialization or execution.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceProgram {
+    strategy: RecurrenceStrategy,
+    physical_sector_count: u32,
+    retained_helicity_count: u64,
+    dynamic_color_states: Box<[DynamicLCColorState]>,
+    currents: Box<[RecurrenceCurrent]>,
+    contributions: Box<[RecurrenceContribution]>,
+    finalizations: Box<[RecurrenceFinalization]>,
+    replay_targets: Box<[RecurrenceReplayTarget]>,
+    resolved_helicities: Box<[RecurrenceResolvedHelicity]>,
+    amplitude_destinations: Box<[RecurrenceAmplitudeDestination]>,
+    closure_terms: Box<[RecurrenceClosureTerm]>,
+    closure_proofs: ClosureProofMetadataV2,
+    closure_target_domain_certificate: Option<ClosureTargetDomainCertificateV1>,
+    color_projection_certificate_body: Option<Box<[u8]>>,
+}
+
+impl RecurrenceProgram {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        strategy: RecurrenceStrategy,
+        physical_sector_count: u32,
+        retained_helicity_count: u64,
+        dynamic_color_states: Vec<DynamicLCColorState>,
+        currents: Vec<RecurrenceCurrent>,
+        contributions: Vec<RecurrenceContribution>,
+        finalizations: Vec<RecurrenceFinalization>,
+        replay_targets: Vec<RecurrenceReplayTarget>,
+        resolved_helicities: Vec<RecurrenceResolvedHelicity>,
+        amplitude_destinations: Vec<RecurrenceAmplitudeDestination>,
+        closure_terms: Vec<RecurrenceClosureTerm>,
+    ) -> RusticolResult<Self> {
+        let closure_proofs = closure_proofs_from_materialized_terms(
+            &currents,
+            &amplitude_destinations,
+            &closure_terms,
+        )?;
+        Self::new_with_closure_proofs(
+            strategy,
+            physical_sector_count,
+            retained_helicity_count,
+            dynamic_color_states,
+            currents,
+            contributions,
+            finalizations,
+            replay_targets,
+            resolved_helicities,
+            amplitude_destinations,
+            closure_terms,
+            closure_proofs,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn new_with_closure_proofs(
+        strategy: RecurrenceStrategy,
+        physical_sector_count: u32,
+        retained_helicity_count: u64,
+        dynamic_color_states: Vec<DynamicLCColorState>,
+        currents: Vec<RecurrenceCurrent>,
+        contributions: Vec<RecurrenceContribution>,
+        finalizations: Vec<RecurrenceFinalization>,
+        replay_targets: Vec<RecurrenceReplayTarget>,
+        resolved_helicities: Vec<RecurrenceResolvedHelicity>,
+        amplitude_destinations: Vec<RecurrenceAmplitudeDestination>,
+        closure_terms: Vec<RecurrenceClosureTerm>,
+        closure_proofs: ClosureProofMetadataV2,
+    ) -> RusticolResult<Self> {
+        let program = Self {
+            strategy,
+            physical_sector_count,
+            retained_helicity_count,
+            dynamic_color_states: dynamic_color_states.into_boxed_slice(),
+            currents: currents.into_boxed_slice(),
+            contributions: contributions.into_boxed_slice(),
+            finalizations: finalizations.into_boxed_slice(),
+            replay_targets: replay_targets.into_boxed_slice(),
+            resolved_helicities: resolved_helicities.into_boxed_slice(),
+            amplitude_destinations: amplitude_destinations.into_boxed_slice(),
+            closure_terms: closure_terms.into_boxed_slice(),
+            closure_proofs,
+            closure_target_domain_certificate: None,
+            color_projection_certificate_body: None,
+        };
+        program.validate()?;
+        Ok(program)
+    }
+
+    pub const fn strategy(&self) -> RecurrenceStrategy {
+        self.strategy
+    }
+
+    pub const fn physical_sector_count(&self) -> u32 {
+        self.physical_sector_count
+    }
+
+    pub const fn retained_helicity_count(&self) -> u64 {
+        self.retained_helicity_count
+    }
+
+    pub fn dynamic_color_states(&self) -> &[DynamicLCColorState] {
+        &self.dynamic_color_states
+    }
+
+    pub fn currents(&self) -> &[RecurrenceCurrent] {
+        &self.currents
+    }
+
+    pub fn contributions(&self) -> &[RecurrenceContribution] {
+        &self.contributions
+    }
+
+    pub fn finalizations(&self) -> &[RecurrenceFinalization] {
+        &self.finalizations
+    }
+
+    pub fn replay_targets(&self) -> &[RecurrenceReplayTarget] {
+        &self.replay_targets
+    }
+
+    pub fn resolved_helicities(&self) -> &[RecurrenceResolvedHelicity] {
+        &self.resolved_helicities
+    }
+
+    pub fn amplitude_destinations(&self) -> &[RecurrenceAmplitudeDestination] {
+        &self.amplitude_destinations
+    }
+
+    pub fn closure_terms(&self) -> &[RecurrenceClosureTerm] {
+        &self.closure_terms
+    }
+
+    pub const fn closure_proofs(&self) -> &ClosureProofMetadataV2 {
+        &self.closure_proofs
+    }
+
+    pub fn closure_target_domain_certificate(&self) -> Option<&ClosureTargetDomainCertificateV1> {
+        self.closure_target_domain_certificate.as_ref()
+    }
+
+    pub(crate) fn with_closure_target_domain_certificate(
+        mut self,
+        certificate: ClosureTargetDomainCertificateV1,
+    ) -> RusticolResult<Self> {
+        if self.strategy != RecurrenceStrategy::ContractedColorUnion {
+            return Err(invalid(
+                "closure target-domain certificate is restricted to contracted color",
+            ));
+        }
+        if certificate.physical_sector_count() != self.physical_sector_count
+            || certificate.resolved_helicity_count() as usize != self.resolved_helicities.len()
+        {
+            return Err(invalid(
+                "closure target-domain certificate disagrees with its recurrence domain",
+            ));
+        }
+        let active_sector_ids = self
+            .amplitude_destinations
+            .iter()
+            .map(|destination| destination.target_sector_id())
+            .collect::<BTreeSet<_>>();
+        if certificate
+            .certified_structural_zero_physical_sector_ids()
+            .iter()
+            .any(|sector_id| active_sector_ids.contains(sector_id))
+        {
+            return Err(invalid(
+                "closure target-domain certificate marks an active sector as structural zero",
+            ));
+        }
+        self.closure_target_domain_certificate = Some(certificate);
+        Ok(self)
+    }
+
+    pub(crate) fn with_color_projection_certificate_body(
+        mut self,
+        body: Vec<u8>,
+    ) -> RusticolResult<Self> {
+        if body.is_empty() {
+            return Err(invalid("recurrence color-projection certificate is empty"));
+        }
+        if self.strategy != RecurrenceStrategy::TopologyReplay {
+            return Err(invalid(
+                "recurrence color projection is restricted to topology replay",
+            ));
+        }
+        self.color_projection_certificate_body = Some(body.into_boxed_slice());
+        Ok(self)
+    }
+
+    pub fn color_projection_certificate_body(&self) -> Option<&[u8]> {
+        self.color_projection_certificate_body.as_deref()
+    }
+
+    pub fn current_range(&self) -> CheckedTableRange {
+        CheckedTableRange::new(0, self.currents.len() as u64)
+    }
+
+    pub fn contribution_range(&self) -> CheckedTableRange {
+        CheckedTableRange::new(0, self.contributions.len() as u64)
+    }
+
+    pub fn closure_term_range(&self) -> CheckedTableRange {
+        CheckedTableRange::new(0, self.closure_terms.len() as u64)
+    }
+
+    pub fn closure_range_for_destination(&self, destination_id: u32) -> Option<CheckedTableRange> {
+        self.amplitude_destinations
+            .get(destination_id as usize)
+            .map(|destination| destination.closure_range())
+    }
+
+    pub fn validate(&self) -> RusticolResult<()> {
+        let current_count = checked_table_len("recurrence current", self.currents.len())?;
+        let color_state_count = checked_table_len(
+            "recurrence dynamic LC color state",
+            self.dynamic_color_states.len(),
+        )?;
+        let contribution_count =
+            checked_table_len("recurrence contribution", self.contributions.len())?;
+        let finalization_count =
+            checked_table_len("recurrence finalization", self.finalizations.len())?;
+        let replay_target_count =
+            checked_table_len("recurrence replay target", self.replay_targets.len())?;
+        let closure_count = checked_table_len("recurrence closure term", self.closure_terms.len())?;
+        let helicity_count = checked_table_len(
+            "recurrence resolved helicity",
+            self.resolved_helicities.len(),
+        )?;
+        let destination_count = checked_table_len(
+            "recurrence amplitude destination",
+            self.amplitude_destinations.len(),
+        )?;
+
+        if self.physical_sector_count == 0 {
+            return Err(invalid("recurrence requires physical LC sectors"));
+        }
+        if self.retained_helicity_count == 0 {
+            return Err(invalid("recurrence retains no public helicities"));
+        }
+
+        u32::try_from(current_count)
+            .map_err(|_| invalid("recurrence current count exceeds the u32 ID domain"))?;
+        u32::try_from(color_state_count)
+            .map_err(|_| invalid("recurrence dynamic color-state count exceeds u32"))?;
+        u32::try_from(contribution_count)
+            .map_err(|_| invalid("recurrence contribution count exceeds the u32 ID domain"))?;
+        u32::try_from(finalization_count)
+            .map_err(|_| invalid("recurrence finalization count exceeds the u32 ID domain"))?;
+        u32::try_from(replay_target_count)
+            .map_err(|_| invalid("recurrence replay-target count exceeds the u32 ID domain"))?;
+        u32::try_from(closure_count)
+            .map_err(|_| invalid("recurrence closure count exceeds the u32 ID domain"))?;
+        u32::try_from(helicity_count)
+            .map_err(|_| invalid("recurrence resolved-helicity count exceeds u32"))?;
+        u32::try_from(destination_count)
+            .map_err(|_| invalid("recurrence amplitude-destination count exceeds u32"))?;
+
+        let mut next_contribution = 0u64;
+        let mut fan_in_sum = 0u64;
+        let mut non_source_count = 0u64;
+        for (index, current) in self.currents.iter().enumerate() {
+            let expected_id = index as u32;
+            if current.id != expected_id {
+                return Err(invalid(format!(
+                    "recurrence current row {index} has non-dense id {}",
+                    current.id
+                )));
+            }
+            if current.key.helicity_identity().strategy() != self.strategy {
+                return Err(invalid(format!(
+                    "recurrence current {expected_id} uses strategy {} in a {} program",
+                    current.key.helicity_identity().strategy(),
+                    self.strategy
+                )));
+            }
+            if u64::from(current.key.dynamic_lc_color_state_id().get()) >= color_state_count {
+                return Err(invalid(format!(
+                    "recurrence current {expected_id} references unknown dynamic LC color state {}",
+                    current.key.dynamic_lc_color_state_id().get()
+                )));
+            }
+            if current.contribution_range.start != next_contribution {
+                return Err(invalid(format!(
+                    "recurrence current {expected_id} contribution range starts at {}, expected packed offset {next_contribution}",
+                    current.contribution_range.start
+                )));
+            }
+            let range = current.contribution_range.as_usize_range(
+                self.contributions.len(),
+                &format!("recurrence current {expected_id} contribution"),
+            )?;
+            next_contribution = current
+                .contribution_range
+                .end("recurrence current contribution")?;
+            fan_in_sum = fan_in_sum
+                .checked_add(current.fan_in())
+                .ok_or_else(|| invalid("recurrence fan-in sum exceeds u64"))?;
+
+            if current.is_source() {
+                if !range.is_empty() || current.finalization_id.is_some() {
+                    return Err(invalid(format!(
+                        "source current {expected_id} must not have contributions or finalization"
+                    )));
+                }
+                match self.strategy {
+                    RecurrenceStrategy::TopologyReplay
+                    | RecurrenceStrategy::ContractedColorUnion
+                        if current.source_exact_factor.is_none() =>
+                    {
+                        return Err(invalid(format!(
+                            "{} source current {expected_id} requires an exact source factor",
+                            self.strategy
+                        )));
+                    }
+                    RecurrenceStrategy::AllFlowUnion if current.source_exact_factor.is_some() => {
+                        return Err(invalid(format!(
+                            "all-flow-union source current {expected_id} must take its factor from runtime dispatch"
+                        )));
+                    }
+                    _ => {}
+                }
+            } else {
+                if current.source_exact_factor.is_some() {
+                    return Err(invalid(format!(
+                        "non-source current {expected_id} cannot carry a source factor"
+                    )));
+                }
+                non_source_count += 1;
+                if range.is_empty() {
+                    return Err(invalid(format!(
+                        "non-source current {expected_id} requires at least one contribution"
+                    )));
+                }
+                let finalization_id = current.finalization_id.ok_or_else(|| {
+                    invalid(format!(
+                        "non-source current {expected_id} requires exactly one finalization"
+                    ))
+                })?;
+                let finalization = self
+                    .finalizations
+                    .get(finalization_id as usize)
+                    .ok_or_else(|| {
+                        invalid(format!(
+                            "current {expected_id} references unknown finalization {finalization_id}"
+                        ))
+                    })?;
+                if finalization.current_id != expected_id {
+                    return Err(invalid(format!(
+                        "current {expected_id} references finalization {finalization_id} owned by current {}",
+                        finalization.current_id
+                    )));
+                }
+            }
+
+            for contribution in &self.contributions[range] {
+                if contribution.result_current_id != expected_id {
+                    return Err(invalid(format!(
+                        "contribution {} is packed under current {expected_id} but targets current {}",
+                        contribution.id, contribution.result_current_id
+                    )));
+                }
+            }
+        }
+        if next_contribution != contribution_count || fan_in_sum != contribution_count {
+            return Err(invalid(format!(
+                "stored contribution count {contribution_count} does not equal packed fan-in sum {fan_in_sum}"
+            )));
+        }
+
+        for (index, contribution) in self.contributions.iter().enumerate() {
+            let expected_id = index as u32;
+            if contribution.id != expected_id {
+                return Err(invalid(format!(
+                    "recurrence contribution row {index} has non-dense id {}",
+                    contribution.id
+                )));
+            }
+            let result = self
+                .currents
+                .get(contribution.result_current_id as usize)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "contribution {expected_id} references unknown result current {}",
+                        contribution.result_current_id
+                    ))
+                })?;
+            if contribution.parent_current_ids.len()
+                != contribution.key.parent_state_template_ids().len()
+            {
+                return Err(invalid(format!(
+                    "contribution {expected_id} has {} parent current IDs but {} semantic parent states",
+                    contribution.parent_current_ids.len(),
+                    contribution.key.parent_state_template_ids().len()
+                )));
+            }
+            if contribution.key.result_state_template_id() != result.key.current_state_template_id()
+            {
+                return Err(invalid(format!(
+                    "contribution {expected_id} result-state template {} does not match current {} state template {}",
+                    contribution.key.result_state_template_id(),
+                    contribution.result_current_id,
+                    result.key.current_state_template_id()
+                )));
+            }
+            for (parent_ordinal, parent_id) in
+                contribution.parent_current_ids.iter().copied().enumerate()
+            {
+                if parent_id >= contribution.result_current_id {
+                    return Err(invalid(format!(
+                        "contribution {expected_id} parent {parent_ordinal} current {parent_id} does not precede result current {}",
+                        contribution.result_current_id
+                    )));
+                }
+                let parent = &self.currents[parent_id as usize];
+                let expected_state = contribution.key.parent_state_template_ids()[parent_ordinal];
+                if parent.key.current_state_template_id() != expected_state {
+                    return Err(invalid(format!(
+                        "contribution {expected_id} parent {parent_ordinal} current {parent_id} has state template {}, expected {expected_state}",
+                        parent.key.current_state_template_id()
+                    )));
+                }
+            }
+            if contribution.exact_factor.is_zero() {
+                return Err(invalid(format!(
+                    "recurrence contribution {expected_id} has zero exact factor"
+                )));
+            }
+        }
+
+        if finalization_count != non_source_count {
+            return Err(invalid(format!(
+                "recurrence has {finalization_count} finalizations for {non_source_count} non-source currents"
+            )));
+        }
+        for (index, finalization) in self.finalizations.iter().enumerate() {
+            let expected_id = index as u32;
+            if finalization.id != expected_id {
+                return Err(invalid(format!(
+                    "recurrence finalization row {index} has non-dense id {}",
+                    finalization.id
+                )));
+            }
+            let current = self
+                .currents
+                .get(finalization.current_id as usize)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "finalization {expected_id} references unknown current {}",
+                        finalization.current_id
+                    ))
+                })?;
+            if current.is_source() {
+                return Err(invalid(format!(
+                    "finalization {expected_id} references source current {}",
+                    finalization.current_id
+                )));
+            }
+            if current.finalization_id != Some(expected_id) {
+                return Err(invalid(format!(
+                    "finalization {expected_id} is not the unique finalization recorded by current {}",
+                    finalization.current_id
+                )));
+            }
+            if finalization.propagator_template_id != current.key.propagator_template_id() {
+                return Err(invalid(format!(
+                    "finalization {expected_id} propagator template {:?} does not match current {} template {:?}",
+                    finalization.propagator_template_id,
+                    finalization.current_id,
+                    current.key.propagator_template_id()
+                )));
+            }
+            if finalization.exact_factor.is_zero() {
+                return Err(invalid(format!(
+                    "recurrence finalization {expected_id} has zero exact factor"
+                )));
+            }
+        }
+
+        let source_slot_count = self
+            .currents
+            .iter()
+            .flat_map(|current| current.key.support_source_slots().iter().copied())
+            .max()
+            .map_or(0usize, |slot| slot as usize + 1);
+        let mut replayed_sectors = BTreeSet::new();
+        let mut materialized_sectors = BTreeSet::new();
+        for (index, target) in self.replay_targets.iter().enumerate() {
+            let expected_id = index as u32;
+            if target.id != expected_id {
+                return Err(invalid(format!(
+                    "recurrence replay-target row {index} has non-dense id {}",
+                    target.id
+                )));
+            }
+            if target.materialized_sector_id >= self.physical_sector_count
+                || target.target_sector_id >= self.physical_sector_count
+            {
+                return Err(invalid(format!(
+                    "recurrence replay target {expected_id} references an unknown physical sector"
+                )));
+            }
+            if !replayed_sectors.insert(target.target_sector_id) {
+                return Err(invalid(format!(
+                    "physical sector {} has multiple recurrence replay targets",
+                    target.target_sector_id
+                )));
+            }
+            materialized_sectors.insert(target.materialized_sector_id);
+            if target.source_slot_permutation.len() != source_slot_count {
+                return Err(invalid(format!(
+                    "recurrence replay target {expected_id} source permutation has length {}, expected {source_slot_count}",
+                    target.source_slot_permutation.len()
+                )));
+            }
+            if target.source_momentum_signs.len() != source_slot_count
+                || target
+                    .source_momentum_signs
+                    .iter()
+                    .any(|sign| !matches!(sign, -1 | 1))
+            {
+                return Err(invalid(format!(
+                    "recurrence replay target {expected_id} has an invalid momentum-sign mapping"
+                )));
+            }
+            let mut permutation = target.source_slot_permutation.to_vec();
+            permutation.sort_unstable();
+            if permutation
+                .iter()
+                .copied()
+                .enumerate()
+                .any(|(slot, value)| value as usize != slot)
+            {
+                return Err(invalid(format!(
+                    "recurrence replay target {expected_id} source mapping is not a permutation"
+                )));
+            }
+        }
+
+        match self.strategy {
+            RecurrenceStrategy::TopologyReplay if self.replay_targets.is_empty() => {
+                return Err(invalid(
+                    "topology-replay recurrence requires replay targets",
+                ));
+            }
+            RecurrenceStrategy::AllFlowUnion if !self.replay_targets.is_empty() => {
+                return Err(invalid(
+                    "all-flow-union recurrence must not carry topology-replay targets",
+                ));
+            }
+            _ => {}
+        }
+        if self.strategy.uses_topology_replay_targets()
+            && !self.replay_targets.is_empty()
+            && replayed_sectors.len() != self.physical_sector_count as usize
+        {
+            return Err(invalid(format!(
+                "{} recurrence replay covers {} of {} physical sectors",
+                self.strategy,
+                replayed_sectors.len(),
+                self.physical_sector_count
+            )));
+        }
+        let mut destination_sectors = BTreeSet::new();
+        for destination in &self.amplitude_destinations {
+            destination_sectors.insert(destination.target_sector_id);
+            if self.strategy.uses_topology_replay_targets()
+                && !self.replay_targets.is_empty()
+                && !materialized_sectors.contains(&destination.target_sector_id)
+            {
+                return Err(invalid(format!(
+                    "{} amplitude destination {} targets non-materialized sector {}",
+                    self.strategy, destination.id, destination.target_sector_id
+                )));
+            }
+        }
+        for sector in materialized_sectors {
+            if !destination_sectors.contains(&sector) {
+                return Err(invalid(format!(
+                    "recurrence replay materialized sector {sector} has no amplitude destination"
+                )));
+            }
+        }
+
+        match self.strategy {
+            RecurrenceStrategy::TopologyReplay if self.resolved_helicities.is_empty() => {
+                return Err(invalid(
+                    "topology-replay recurrence requires resolved-helicity destinations",
+                ));
+            }
+            RecurrenceStrategy::AllFlowUnion if !self.resolved_helicities.is_empty() => {
+                return Err(invalid(
+                    "all-flow-union recurrence must select source helicity at runtime",
+                ));
+            }
+            RecurrenceStrategy::ContractedColorUnion if self.resolved_helicities.is_empty() => {
+                return Err(invalid(
+                    "contracted-color recurrence requires resolved-helicity destinations",
+                ));
+            }
+            _ => {}
+        }
+        if helicity_count > self.retained_helicity_count {
+            return Err(invalid(format!(
+                "recurrence has {helicity_count} active helicities but retains only {} public assignments",
+                self.retained_helicity_count
+            )));
+        }
+        for (index, helicity) in self.resolved_helicities.iter().enumerate() {
+            if helicity.id != index as u32 {
+                return Err(invalid(format!(
+                    "resolved-helicity row {index} has non-dense id {}",
+                    helicity.id
+                )));
+            }
+            if helicity.source_states.len() != helicity.public_helicities.len() {
+                return Err(invalid(format!(
+                    "resolved helicity {index} has inconsistent source-state and public-helicity dimensions"
+                )));
+            }
+            for (source_slot, assignment) in helicity.source_states.iter().copied().enumerate() {
+                if assignment.source_slot() as usize != source_slot {
+                    return Err(invalid(format!(
+                        "resolved helicity {index} does not cover source slot {source_slot} canonically"
+                    )));
+                }
+            }
+        }
+
+        let mut next_closure = 0u64;
+        for (destination_index, destination) in
+            self.amplitude_destinations.iter().copied().enumerate()
+        {
+            let destination_id = destination_index as u32;
+            if destination.id != destination_id {
+                return Err(invalid(format!(
+                    "amplitude destination row {destination_index} has non-dense id {}",
+                    destination.id
+                )));
+            }
+            if destination.target_sector_id >= self.physical_sector_count {
+                return Err(invalid(format!(
+                    "amplitude destination {destination_id} references unknown physical sector {}",
+                    destination.target_sector_id
+                )));
+            }
+            match (self.strategy, destination.target_helicity_id) {
+                (RecurrenceStrategy::TopologyReplay, Some(helicity_id))
+                    if u64::from(helicity_id) < helicity_count => {}
+                (RecurrenceStrategy::TopologyReplay, Some(helicity_id)) => {
+                    return Err(invalid(format!(
+                        "amplitude destination {destination_id} references unknown resolved helicity {helicity_id}"
+                    )));
+                }
+                (RecurrenceStrategy::TopologyReplay, None) => {
+                    return Err(invalid(format!(
+                        "topology-replay amplitude destination {destination_id} lacks a helicity"
+                    )));
+                }
+                (RecurrenceStrategy::AllFlowUnion, None) => {}
+                (RecurrenceStrategy::AllFlowUnion, Some(_)) => {
+                    return Err(invalid(format!(
+                        "all-flow-union amplitude destination {destination_id} fixes a helicity"
+                    )));
+                }
+                (RecurrenceStrategy::ContractedColorUnion, Some(helicity_id))
+                    if u64::from(helicity_id) < helicity_count => {}
+                (RecurrenceStrategy::ContractedColorUnion, Some(helicity_id)) => {
+                    return Err(invalid(format!(
+                        "contracted-color amplitude destination {destination_id} references unknown resolved helicity {helicity_id}"
+                    )));
+                }
+                (RecurrenceStrategy::ContractedColorUnion, None) => {
+                    return Err(invalid(format!(
+                        "contracted-color amplitude destination {destination_id} lacks a helicity"
+                    )));
+                }
+            }
+            let range = destination.closure_range;
+            if range.start != next_closure {
+                return Err(invalid(format!(
+                    "amplitude destination {destination_id} closure range starts at {}, expected packed offset {next_closure}",
+                    range.start
+                )));
+            }
+            let term_range = range.as_usize_range(
+                self.closure_terms.len(),
+                &format!("amplitude destination {destination_id} closure"),
+            )?;
+            next_closure = range.end("amplitude-destination closure")?;
+            for term in &self.closure_terms[term_range] {
+                if term.target_destination_id != destination_id {
+                    return Err(invalid(format!(
+                        "closure term {} is packed under destination {destination_id} but points to destination {}",
+                        term.id, term.target_destination_id
+                    )));
+                }
+            }
+        }
+        if next_closure != closure_count {
+            return Err(invalid(format!(
+                "packed amplitude-destination ranges cover {next_closure} of {closure_count} terms"
+            )));
+        }
+
+        for (index, term) in self.closure_terms.iter().enumerate() {
+            let expected_id = index as u32;
+            if term.id != expected_id {
+                return Err(invalid(format!(
+                    "recurrence closure row {index} has non-dense id {}",
+                    term.id
+                )));
+            }
+            let destination = self
+                .amplitude_destinations
+                .get(term.target_destination_id as usize)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "closure term {expected_id} references unknown amplitude destination {}",
+                        term.target_destination_id
+                    ))
+                })?;
+            if term.exact_factor.is_zero() {
+                return Err(invalid(format!(
+                    "recurrence closure term {expected_id} has zero exact factor"
+                )));
+            }
+            for parent_id in term.parent_current_ids.iter().copied() {
+                if u64::from(parent_id) >= current_count {
+                    return Err(invalid(format!(
+                        "closure term {expected_id} references unknown parent current {parent_id}"
+                    )));
+                }
+            }
+            if let Some(helicity_id) = destination.target_helicity_id {
+                let expected = self.resolved_helicities[helicity_id as usize].source_states();
+                let actual = closure_parent_source_states(term, &self.currents)?;
+                if actual != expected {
+                    return Err(invalid(format!(
+                        "closure term {expected_id} ancestry does not match amplitude destination {}",
+                        destination.id
+                    )));
+                }
+            }
+        }
+
+        validate_program_closure_proofs(self)?;
+
+        Ok(())
+    }
+}
+
+fn closure_proofs_from_materialized_terms(
+    currents: &[RecurrenceCurrent],
+    amplitude_destinations: &[RecurrenceAmplitudeDestination],
+    closure_terms: &[RecurrenceClosureTerm],
+) -> RusticolResult<ClosureProofMetadataV2> {
+    let mut contributions = Vec::with_capacity(closure_terms.len());
+    let mut groups = Vec::with_capacity(closure_terms.len());
+    for term in closure_terms {
+        let destination = amplitude_destinations
+            .get(term.target_destination_id as usize)
+            .ok_or_else(|| {
+                invalid(format!(
+                    "closure term {} references absent destination {}",
+                    term.id, term.target_destination_id
+                ))
+            })?;
+        let parent_count = term.parent_current_ids.len();
+        let identity_permutation = (0..parent_count)
+            .map(|index| {
+                u32::try_from(index).map_err(|_| invalid("closure proof parent index exceeds u32"))
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let mut parent_semantic_digests = Vec::with_capacity(parent_count);
+        let mut parent_color_digests = Vec::with_capacity(parent_count);
+        for parent_id in term.parent_current_ids.iter().copied() {
+            let parent = currents.get(parent_id as usize).ok_or_else(|| {
+                invalid(format!(
+                    "closure term {} references absent parent {parent_id}",
+                    term.id
+                ))
+            })?;
+            parent_semantic_digests.push(parent.key.catalog_digest());
+            parent_color_digests.push(semantic_digest_from_fields(
+                b"recurrence-closure-parent-color-v2\0",
+                [parent_id, parent.key.dynamic_lc_color_state_id().get()],
+            )?);
+        }
+        let contribution_id = u32::try_from(contributions.len())
+            .map_err(|_| invalid("closure proof contribution count exceeds u32"))?;
+        contributions.push(ClosureProofContributionV2::new(
+            contribution_id,
+            destination.target_sector_id,
+            Some(destination.id),
+            destination.target_helicity_id,
+            term.closure_template_id,
+            semantic_digest_from_fields(
+                b"recurrence-closure-template-v2\0",
+                [term.closure_template_id],
+            )?,
+            term.quantum_flow_template_id,
+            term.parent_current_ids.to_vec(),
+            term.parent_current_ids.iter().copied().map(Some).collect(),
+            parent_semantic_digests,
+            parent_color_digests,
+            identity_permutation.clone(),
+            identity_permutation.clone(),
+            identity_permutation,
+            u32::MAX,
+            semantic_digest_from_fields(
+                b"recurrence-materialized-closure-witness-v2\0",
+                [term.id],
+            )?,
+            None,
+            vec![],
+            None,
+            term.exact_factor,
+            1,
+        )?);
+        groups.push(ClosureExecutionProofGroupV2::new(
+            term.id,
+            Some(term.id),
+            None,
+            CheckedTableRange::new(u64::from(contribution_id), 1),
+            term.exact_factor,
+            semantic_digest_from_fields(
+                b"recurrence-materialized-component-factor-v2\0",
+                [term.closure_template_id],
+            )?,
+            semantic_digest_from_fields(
+                b"recurrence-materialized-selector-domain-v2\0",
+                [destination.id],
+            )?,
+        )?);
+    }
+    ClosureProofMetadataV2::new(contributions, groups, Vec::new())
+}
+
+fn validate_program_closure_proofs(program: &RecurrenceProgram) -> RusticolResult<()> {
+    validate_closure_proof_tables(
+        program.closure_proofs.contributions(),
+        program.closure_proofs.groups(),
+        program.closure_proofs.reflection_certificates(),
+        program.closure_proofs.three_line_traversal_certificates(),
+    )?;
+    if closure_proof_semantic_completeness_digest_with_three_line_v2(
+        program.closure_proofs.contributions(),
+        program.closure_proofs.groups(),
+        program.closure_proofs.reflection_certificates(),
+        program.closure_proofs.three_line_traversal_certificates(),
+    )? != program
+        .closure_proofs
+        .expected_semantic_completeness_digest()
+    {
+        return Err(invalid(
+            "recurrence closure proof semantic completeness digest mismatch",
+        ));
+    }
+
+    for (index, contribution) in program.closure_proofs.contributions().iter().enumerate() {
+        if let Some(destination_id) = contribution.target_destination_id {
+            let destination = program
+                .amplitude_destinations
+                .get(destination_id as usize)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "closure proof contribution {index} references absent destination {destination_id}"
+                    ))
+                })?;
+            if contribution.target_sector_id != destination.target_sector_id
+                || contribution.target_helicity_id != destination.target_helicity_id
+            {
+                return Err(invalid(format!(
+                    "closure proof contribution {index} target does not match destination {}",
+                    destination.id
+                )));
+            }
+        }
+        for parent_id in contribution
+            .construction_parent_runtime_ids
+            .iter()
+            .copied()
+            .flatten()
+        {
+            if parent_id as usize >= program.currents.len() {
+                return Err(invalid(format!(
+                    "closure proof contribution {index} references absent runtime parent current {parent_id}"
+                )));
+            }
+        }
+    }
+
+    let mut term_owner = vec![None; program.closure_terms.len()];
+    for group in program.closure_proofs.groups() {
+        if group.emitted_direct_closure_row_id.is_some() {
+            return Err(invalid(format!(
+                "program closure proof group {} must not contain a lowered direct row ID",
+                group.id
+            )));
+        }
+        let Some(term_id) = group.emitted_runtime_closure_term_id else {
+            continue;
+        };
+        let term = program.closure_terms.get(term_id as usize).ok_or_else(|| {
+            invalid(format!(
+                "closure proof group {} references absent runtime closure term {term_id}",
+                group.id
+            ))
+        })?;
+        if term_owner[term_id as usize].replace(group.id).is_some() {
+            return Err(invalid(format!(
+                "runtime closure term {term_id} is owned by multiple proof groups"
+            )));
+        }
+        if term.exact_factor != group.exact_summed_factor {
+            return Err(invalid(format!(
+                "closure proof group {} factor does not match runtime closure term {term_id}",
+                group.id
+            )));
+        }
+        let range = group.contribution_range.as_usize_range(
+            program.closure_proofs.contributions.len(),
+            &format!("closure proof group {} contribution", group.id),
+        )?;
+        for contribution in &program.closure_proofs.contributions[range] {
+            if contribution.target_destination_id != Some(term.target_destination_id)
+                || contribution.closure_template_id != term.closure_template_id
+                || contribution.quantum_flow_template_id != term.quantum_flow_template_id
+                || contribution.evaluator_parent_runtime_ids().as_deref()
+                    != Some(term.parent_current_ids.as_ref())
+            {
+                return Err(invalid(format!(
+                    "closure proof group {} does not describe runtime closure term {term_id}",
+                    group.id
+                )));
+            }
+        }
+    }
+    if let Some((term_id, _)) = term_owner
+        .iter()
+        .enumerate()
+        .find(|(_, owner)| owner.is_none())
+    {
+        return Err(invalid(format!(
+            "runtime closure term {term_id} has no closure proof group"
+        )));
+    }
+    Ok(())
+}
+
+fn closure_parent_source_states(
+    term: &RecurrenceClosureTerm,
+    currents: &[RecurrenceCurrent],
+) -> RusticolResult<Vec<SourceStateAssignment>> {
+    let mut states = Vec::new();
+    for parent_id in term.parent_current_ids.iter().copied() {
+        let parent = currents
+            .get(parent_id as usize)
+            .ok_or_else(|| invalid("closure parent current is absent"))?;
+        states.extend_from_slice(parent.key.helicity_identity().local_source_states());
+    }
+    states.sort_unstable();
+    if states
+        .windows(2)
+        .any(|pair| pair[0].source_slot() == pair[1].source_slot())
+    {
+        return Err(invalid("closure parent helicity ancestries overlap"));
+    }
+    Ok(states)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::{
+        CanonicalMomentumLinearForm, CurrentHelicityIdentity, CurrentSourceBinding,
+        DynamicLCColorStateId, LCColorWitnessTermId, MomentumTerm, SemanticDigest,
+        SourceStateAssignment,
+    };
+
+    fn digest(byte: u8) -> SemanticDigest {
+        SemanticDigest::new([byte; 32]).unwrap()
+    }
+
+    fn momentum() -> CanonicalMomentumLinearForm {
+        CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+            source_slot: 0,
+            coefficient: 1,
+        }])
+        .unwrap()
+    }
+
+    fn source_key() -> CurrentCoreKey {
+        CurrentCoreKey::new(
+            digest(1),
+            RecurrenceNodeKind::Source,
+            0,
+            DynamicLCColorStateId::from_interner(0),
+            vec![0],
+            momentum(),
+            CurrentHelicityIdentity::topology_replay(-1, vec![SourceStateAssignment::new(0, 0)])
+                .unwrap(),
+            vec![],
+            0,
+            vec![],
+            CurrentSourceBinding::FixedTemplate(0),
+            None,
+        )
+        .unwrap()
+    }
+
+    fn propagated_key() -> CurrentCoreKey {
+        CurrentCoreKey::new(
+            digest(1),
+            RecurrenceNodeKind::Current,
+            1,
+            DynamicLCColorStateId::from_interner(0),
+            vec![0],
+            momentum(),
+            CurrentHelicityIdentity::topology_replay(-1, vec![SourceStateAssignment::new(0, 0)])
+                .unwrap(),
+            vec![],
+            0,
+            vec![],
+            CurrentSourceBinding::None,
+            Some(0),
+        )
+        .unwrap()
+    }
+
+    fn contribution(parent_id: u32) -> RecurrenceContribution {
+        RecurrenceContribution::new(
+            0,
+            1,
+            vec![parent_id],
+            ContributionKey::new(
+                0,
+                vec![0],
+                vec![0],
+                vec![momentum()],
+                1,
+                0,
+                LCColorWitnessTermId::new(0, 0),
+                digest(2),
+                0,
+            )
+            .unwrap(),
+            ExactComplexRational::ONE,
+        )
+        .unwrap()
+    }
+
+    fn resolved_helicity() -> RecurrenceResolvedHelicity {
+        RecurrenceResolvedHelicity::new(0, vec![SourceStateAssignment::new(0, 0)], vec![-1])
+            .unwrap()
+    }
+
+    fn identity_replay_target() -> RecurrenceReplayTarget {
+        RecurrenceReplayTarget::new(0, 0, 0, vec![0], vec![1], ExactComplexRational::ONE).unwrap()
+    }
+
+    fn minus_one() -> ExactComplexRational {
+        ExactComplexRational::new(ExactRational::new(-1, 1).unwrap(), ExactRational::ZERO)
+    }
+
+    fn proof_contribution(
+        id: u32,
+        parent_id: u32,
+        witness_id: u32,
+        witness_digest: SemanticDigest,
+        reflection_certificate_id: Option<u32>,
+        exact_factor: ExactComplexRational,
+    ) -> ClosureProofContributionV2 {
+        proof_contribution_with_runtime_binding(
+            id,
+            parent_id,
+            witness_id,
+            witness_digest,
+            reflection_certificate_id,
+            exact_factor,
+            true,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn proof_contribution_with_runtime_binding(
+        id: u32,
+        parent_id: u32,
+        witness_id: u32,
+        witness_digest: SemanticDigest,
+        reflection_certificate_id: Option<u32>,
+        exact_factor: ExactComplexRational,
+        has_runtime_binding: bool,
+    ) -> ClosureProofContributionV2 {
+        ClosureProofContributionV2::new(
+            id,
+            0,
+            has_runtime_binding.then_some(0),
+            Some(0),
+            0,
+            digest(10),
+            None,
+            vec![parent_id],
+            vec![has_runtime_binding.then_some(parent_id)],
+            vec![digest(11)],
+            vec![digest(12)],
+            vec![0],
+            vec![0],
+            vec![0],
+            witness_id,
+            witness_digest,
+            None,
+            vec![],
+            reflection_certificate_id,
+            exact_factor,
+            1,
+        )
+        .unwrap()
+    }
+
+    fn reflection_certificate(proof_digest: SemanticDigest) -> ReflectionCertificateV1 {
+        ReflectionCertificateV1::new(
+            0,
+            digest(20),
+            digest(21),
+            vec![0],
+            minus_one(),
+            false,
+            2,
+            1,
+            proof_digest,
+        )
+        .unwrap()
+    }
+
+    fn three_line_certificate(
+        id: u32,
+        sector_id: u32,
+        pairing_rule_id: u32,
+    ) -> ThreeLineTraversalCertificateV1 {
+        let reference_block_order = vec![0, 1, 2];
+        let witness_block_order = vec![1, 0, 2];
+        let block_permutation = vec![1, 0, 2];
+        let reference_source_order = vec![10, 11, 12];
+        let witness_source_order = vec![11, 10, 12];
+        let source_position_permutation = vec![1, 0, 2];
+        let proof_digest = three_line_traversal_proof_digest_v1(
+            sector_id,
+            ThreeLineTraversalKindV1::Partner,
+            2,
+            &reference_block_order,
+            &witness_block_order,
+            &block_permutation,
+            &reference_source_order,
+            &witness_source_order,
+            &source_position_permutation,
+            12,
+            pairing_rule_id,
+        )
+        .unwrap();
+        ThreeLineTraversalCertificateV1::new(
+            id,
+            sector_id,
+            ThreeLineTraversalKindV1::Partner,
+            2,
+            reference_block_order,
+            witness_block_order,
+            block_permutation,
+            reference_source_order,
+            witness_source_order,
+            source_position_permutation,
+            12,
+            pairing_rule_id,
+            proof_digest,
+        )
+        .unwrap()
+    }
+
+    fn three_line_proof_contribution(
+        certificate_id: u32,
+        sector_id: u32,
+    ) -> ClosureProofContributionV2 {
+        ClosureProofContributionV2::new(
+            0,
+            sector_id,
+            Some(0),
+            Some(0),
+            0,
+            digest(10),
+            None,
+            vec![1],
+            vec![Some(1)],
+            vec![digest(11)],
+            vec![digest(12)],
+            vec![0],
+            vec![0],
+            vec![0],
+            0,
+            digest(13),
+            Some(certificate_id),
+            vec![],
+            None,
+            ExactComplexRational::ONE,
+            1,
+        )
+        .unwrap()
+    }
+
+    fn valid_program() -> RecurrenceProgram {
+        RecurrenceProgram::new(
+            RecurrenceStrategy::TopologyReplay,
+            1,
+            1,
+            vec![DynamicLCColorState::new(0, None, vec![]).unwrap()],
+            vec![
+                RecurrenceCurrent::new(
+                    0,
+                    source_key(),
+                    Some(ExactComplexRational::ONE),
+                    CheckedTableRange::new(0, 0),
+                    None,
+                )
+                .unwrap(),
+                RecurrenceCurrent::new(
+                    1,
+                    propagated_key(),
+                    None,
+                    CheckedTableRange::new(0, 1),
+                    Some(0),
+                )
+                .unwrap(),
+            ],
+            vec![contribution(0)],
+            vec![RecurrenceFinalization::new(0, 1, Some(0), ExactComplexRational::ONE).unwrap()],
+            vec![identity_replay_target()],
+            vec![resolved_helicity()],
+            vec![
+                RecurrenceAmplitudeDestination::new(0, 0, Some(0), CheckedTableRange::new(0, 1))
+                    .unwrap(),
+            ],
+            vec![
+                RecurrenceClosureTerm::new(0, 0, 0, None, vec![1], ExactComplexRational::ONE)
+                    .unwrap(),
+            ],
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn validates_one_compact_recurrence_program() {
+        let program = valid_program();
+        assert_eq!(program.current_range(), CheckedTableRange::new(0, 2));
+        assert_eq!(program.contribution_range(), CheckedTableRange::new(0, 1));
+        assert_eq!(program.closure_term_range(), CheckedTableRange::new(0, 1));
+        assert_eq!(
+            program.closure_range_for_destination(0),
+            Some(CheckedTableRange::new(0, 1))
+        );
+        assert!(program.validate().is_ok());
+    }
+
+    #[test]
+    fn rejects_a_parent_that_does_not_precede_its_result() {
+        let error = RecurrenceProgram::new(
+            RecurrenceStrategy::TopologyReplay,
+            1,
+            1,
+            vec![DynamicLCColorState::new(0, None, vec![]).unwrap()],
+            vec![
+                RecurrenceCurrent::new(
+                    0,
+                    source_key(),
+                    Some(ExactComplexRational::ONE),
+                    CheckedTableRange::new(0, 0),
+                    None,
+                )
+                .unwrap(),
+                RecurrenceCurrent::new(
+                    1,
+                    propagated_key(),
+                    None,
+                    CheckedTableRange::new(0, 1),
+                    Some(0),
+                )
+                .unwrap(),
+            ],
+            vec![contribution(1)],
+            vec![RecurrenceFinalization::new(0, 1, Some(0), ExactComplexRational::ONE).unwrap()],
+            vec![identity_replay_target()],
+            vec![resolved_helicity()],
+            vec![
+                RecurrenceAmplitudeDestination::new(0, 0, Some(0), CheckedTableRange::new(0, 1))
+                    .unwrap(),
+            ],
+            vec![
+                RecurrenceClosureTerm::new(0, 0, 0, None, vec![1], ExactComplexRational::ONE)
+                    .unwrap(),
+            ],
+        )
+        .unwrap_err();
+        assert!(error.message().contains("does not precede result current"));
+    }
+
+    #[test]
+    fn rejects_a_closure_destination_with_mismatched_source_ancestry() {
+        let error = RecurrenceProgram::new(
+            RecurrenceStrategy::TopologyReplay,
+            1,
+            2,
+            vec![DynamicLCColorState::new(0, None, vec![]).unwrap()],
+            vec![
+                RecurrenceCurrent::new(
+                    0,
+                    source_key(),
+                    Some(ExactComplexRational::ONE),
+                    CheckedTableRange::new(0, 0),
+                    None,
+                )
+                .unwrap(),
+                RecurrenceCurrent::new(
+                    1,
+                    propagated_key(),
+                    None,
+                    CheckedTableRange::new(0, 1),
+                    Some(0),
+                )
+                .unwrap(),
+            ],
+            vec![contribution(0)],
+            vec![RecurrenceFinalization::new(0, 1, Some(0), ExactComplexRational::ONE).unwrap()],
+            vec![identity_replay_target()],
+            vec![
+                RecurrenceResolvedHelicity::new(0, vec![SourceStateAssignment::new(0, 1)], vec![1])
+                    .unwrap(),
+            ],
+            vec![
+                RecurrenceAmplitudeDestination::new(0, 0, Some(0), CheckedTableRange::new(0, 1))
+                    .unwrap(),
+            ],
+            vec![
+                RecurrenceClosureTerm::new(0, 0, 0, None, vec![1], ExactComplexRational::ONE)
+                    .unwrap(),
+            ],
+        )
+        .unwrap_err();
+        assert!(error.message().contains("ancestry does not match"));
+    }
+
+    #[test]
+    fn closure_proof_tables_reject_missing_contributions_and_wrong_group_sums() {
+        let group = ClosureExecutionProofGroupV2::new(
+            0,
+            Some(0),
+            None,
+            CheckedTableRange::new(0, 1),
+            ExactComplexRational::ONE,
+            digest(30),
+            digest(31),
+        )
+        .unwrap();
+        let missing = ClosureProofMetadataV2::new(vec![], vec![group.clone()], vec![]).unwrap_err();
+        assert!(missing.message().contains("exceeds table length"));
+
+        let wrong_sum = ClosureExecutionProofGroupV2::new(
+            0,
+            Some(0),
+            None,
+            CheckedTableRange::new(0, 1),
+            minus_one(),
+            digest(30),
+            digest(31),
+        )
+        .unwrap();
+        let error = ClosureProofMetadataV2::new(
+            vec![proof_contribution(
+                0,
+                1,
+                0,
+                digest(13),
+                None,
+                ExactComplexRational::ONE,
+            )],
+            vec![wrong_sum],
+            vec![],
+        )
+        .unwrap_err();
+        assert!(error.message().contains("does not equal"));
+    }
+
+    #[test]
+    fn closure_proof_tables_reject_a_stale_candidate_domain_certificate() {
+        let contribution = proof_contribution(0, 1, 0, digest(13), None, ExactComplexRational::ONE);
+        let group = ClosureExecutionProofGroupV2::new(
+            0,
+            Some(0),
+            None,
+            CheckedTableRange::new(0, 1),
+            ExactComplexRational::ONE,
+            digest(30),
+            digest(31),
+        )
+        .unwrap();
+        let metadata =
+            ClosureProofMetadataV2::new(vec![contribution.clone()], vec![group.clone()], vec![])
+                .unwrap();
+        let certificate = metadata.candidate_domain_certificate();
+        let stale = ClosureCandidateDomainCertificateV1::new(
+            certificate.accepted_candidate_count() + 1,
+            certificate.accepted_candidate_digest(),
+        );
+        let error = ClosureProofMetadataV2::new_with_three_line_certificates_and_candidate_domain(
+            vec![contribution],
+            vec![group],
+            vec![],
+            vec![],
+            stale,
+        )
+        .unwrap_err();
+        assert!(error.message().contains("candidate-domain certificate"));
+    }
+
+    #[test]
+    fn closure_proof_digest_rejects_parent_witness_proof_and_certificate_mutations() {
+        let group = ClosureExecutionProofGroupV2::new(
+            0,
+            Some(0),
+            None,
+            CheckedTableRange::new(0, 1),
+            ExactComplexRational::ONE,
+            digest(30),
+            digest(31),
+        )
+        .unwrap();
+        let original = ClosureProofMetadataV2::new(
+            vec![proof_contribution(
+                0,
+                1,
+                7,
+                digest(13),
+                Some(0),
+                ExactComplexRational::ONE,
+            )],
+            vec![group.clone()],
+            vec![reflection_certificate(digest(22))],
+        )
+        .unwrap();
+        let expected = original.expected_semantic_completeness_digest();
+
+        for contribution in [
+            proof_contribution(0, 2, 7, digest(13), Some(0), ExactComplexRational::ONE),
+            proof_contribution(0, 1, 8, digest(13), Some(0), ExactComplexRational::ONE),
+            proof_contribution(0, 1, 7, digest(14), Some(0), ExactComplexRational::ONE),
+        ] {
+            let error = ClosureProofMetadataV2::new_with_expected_digest(
+                vec![contribution],
+                vec![group.clone()],
+                vec![reflection_certificate(digest(22))],
+                expected,
+            )
+            .unwrap_err();
+            assert!(error.message().contains("digest mismatch"));
+        }
+
+        let error = ClosureProofMetadataV2::new_with_expected_digest(
+            original.contributions().to_vec(),
+            original.groups().to_vec(),
+            vec![reflection_certificate(digest(23))],
+            expected,
+        )
+        .unwrap_err();
+        assert!(error.message().contains("digest mismatch"));
+    }
+
+    #[test]
+    fn closure_proof_tables_retain_exact_zero_groups_without_runtime_rows() {
+        let metadata = ClosureProofMetadataV2::new(
+            vec![
+                proof_contribution_with_runtime_binding(
+                    0,
+                    91,
+                    0,
+                    digest(13),
+                    None,
+                    ExactComplexRational::ONE,
+                    false,
+                ),
+                proof_contribution_with_runtime_binding(
+                    1,
+                    91,
+                    0,
+                    digest(13),
+                    None,
+                    minus_one(),
+                    false,
+                ),
+            ],
+            vec![
+                ClosureExecutionProofGroupV2::new(
+                    0,
+                    None,
+                    None,
+                    CheckedTableRange::new(0, 2),
+                    ExactComplexRational::ZERO,
+                    digest(30),
+                    digest(31),
+                )
+                .unwrap(),
+            ],
+            vec![],
+        )
+        .unwrap();
+        assert_eq!(metadata.groups().len(), 1);
+        assert!(metadata.groups()[0].exact_summed_factor().is_zero());
+        assert_eq!(metadata.groups()[0].emitted_runtime_closure_term_id(), None);
+        assert_eq!(metadata.groups()[0].emitted_direct_closure_row_id(), None);
+    }
+
+    #[test]
+    fn closure_proof_tables_reject_nonzero_groups_without_runtime_bindings() {
+        let contribution = proof_contribution_with_runtime_binding(
+            0,
+            91,
+            0,
+            digest(13),
+            None,
+            ExactComplexRational::ONE,
+            false,
+        );
+        let group = ClosureExecutionProofGroupV2::new(
+            0,
+            Some(0),
+            None,
+            CheckedTableRange::new(0, 1),
+            ExactComplexRational::ONE,
+            digest(30),
+            digest(31),
+        )
+        .unwrap();
+        let error =
+            ClosureProofMetadataV2::new(vec![contribution], vec![group], vec![]).unwrap_err();
+        assert!(error.message().contains("lacks a complete runtime binding"));
+    }
+
+    #[test]
+    fn three_line_traversal_certificate_authenticates_orders_anchor_and_kind() {
+        let certificate = three_line_certificate(0, 4, 7);
+        assert_eq!(certificate.kind(), ThreeLineTraversalKindV1::Partner);
+        assert_eq!(certificate.sink_block_ordinal(), 2);
+        assert_eq!(certificate.closure_anchor_source_slot(), 12);
+        assert!(ThreeLineTraversalKindV1::try_from(2).is_err());
+
+        let error = ThreeLineTraversalCertificateV1::new(
+            0,
+            4,
+            ThreeLineTraversalKindV1::Partner,
+            2,
+            vec![0, 2],
+            vec![1, 0, 2],
+            vec![1, 0, 2],
+            vec![10, 11, 12],
+            vec![11, 10, 12],
+            vec![1, 0, 2],
+            12,
+            7,
+            digest(60),
+        )
+        .unwrap_err();
+        assert!(error.message().contains("expected 3"));
+
+        let error = ThreeLineTraversalCertificateV1::new(
+            0,
+            4,
+            ThreeLineTraversalKindV1::Partner,
+            2,
+            vec![0, 1, 2],
+            vec![1, 0, 2],
+            vec![1, 0, 2],
+            vec![10, 11, 12],
+            vec![11, 10, 12],
+            vec![0, 1, 2],
+            12,
+            7,
+            digest(60),
+        )
+        .unwrap_err();
+        assert!(error.message().contains("source-position permutation"));
+
+        let original = three_line_certificate(0, 4, 7);
+        let error = ThreeLineTraversalCertificateV1::new(
+            original.id(),
+            original.sector_id(),
+            original.kind(),
+            original.sink_block_ordinal(),
+            original.reference_block_order().to_vec(),
+            original.witness_block_order().to_vec(),
+            original.block_permutation().to_vec(),
+            original.reference_source_order().to_vec(),
+            original.witness_source_order().to_vec(),
+            original.source_position_permutation().to_vec(),
+            original.closure_anchor_source_slot(),
+            original.pairing_rule_id(),
+            digest(61),
+        )
+        .unwrap_err();
+        assert!(error.message().contains("proof digest mismatch"));
+    }
+
+    #[test]
+    fn closure_proofs_authenticate_three_line_catalog_and_references() {
+        let group = ClosureExecutionProofGroupV2::new(
+            0,
+            Some(0),
+            None,
+            CheckedTableRange::new(0, 1),
+            ExactComplexRational::ONE,
+            digest(30),
+            digest(31),
+        )
+        .unwrap();
+        let original = ClosureProofMetadataV2::new_with_three_line_certificates(
+            vec![three_line_proof_contribution(0, 4)],
+            vec![group.clone()],
+            vec![],
+            vec![three_line_certificate(0, 4, 7)],
+        )
+        .unwrap();
+        let expected = original.expected_semantic_completeness_digest();
+
+        let error = ClosureProofMetadataV2::new_with_three_line_certificates(
+            original.contributions().to_vec(),
+            original.groups().to_vec(),
+            vec![],
+            vec![],
+        )
+        .unwrap_err();
+        assert!(error.message().contains("absent three-line"));
+
+        let error = ClosureProofMetadataV2::new_with_three_line_certificates(
+            vec![three_line_proof_contribution(1, 4)],
+            vec![group.clone()],
+            vec![],
+            vec![three_line_certificate(1, 4, 7)],
+        )
+        .unwrap_err();
+        assert!(error.message().contains("non-dense id"));
+
+        let error = ClosureProofMetadataV2::new_with_three_line_certificates(
+            vec![three_line_proof_contribution(0, 5)],
+            vec![group.clone()],
+            vec![],
+            vec![three_line_certificate(0, 4, 7)],
+        )
+        .unwrap_err();
+        assert!(error.message().contains("does not match"));
+
+        let error = ClosureProofMetadataV2::new_with_three_line_certificates_and_expected_digest(
+            original.contributions().to_vec(),
+            original.groups().to_vec(),
+            vec![],
+            vec![three_line_certificate(0, 4, 8)],
+            expected,
+        )
+        .unwrap_err();
+        assert!(error.message().contains("digest mismatch"));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/relation.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/relation.rs
new file mode 100644
index 0000000000..780980fed1
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/relation.rs
@@ -0,0 +1,1124 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Opt-in numerical nomination and exact replay for recurrence-current reuse.
+//!
+//! Numerical projections are deliberately only an index. A current is
+//! reusable only when the complete lowered contribution vector is
+//! proportional over [`ExactComplexRational`]. The resulting certificate is
+//! replayed once more before lowering may emit a scale-copy row.
+
+use std::collections::BTreeMap;
+
+use serde_json::{Value as JsonValue, json};
+use sha2::{Digest, Sha256};
+
+use super::{
+    DIRECT_NONE_U32, DirectExecutorRole, DirectNodeKind, DirectRecurrencePlan,
+    ExactComplexRational, RecurrenceStrategy,
+};
+use crate::{RusticolError, RusticolResult};
+
+const PROJECTION_PRIME: u64 = (1_u64 << 61) - 1;
+const RELATION_CERTIFICATE_ALGORITHM: &str = "recurrence-exact-rational-row-vector-replay-v1";
+pub const NUMERICAL_RELATION_CERTIFICATE_ALGORITHM: &str =
+    "authenticated-independent-recursive-decimal-raw-probes-v2";
+pub const RECURRENCE_NUMERICAL_SOURCE_ABI: &str =
+    "pyamplicol-recurrence-numerical-current-source-v3";
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(format!("recurrence relation discovery: {}", message.into()))
+}
+
+/// User-visible recurrence relation-discovery mode.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum RecurrenceRelationDiscoveryMode {
+    Off,
+    Diagnostic,
+    CertifiedReuse,
+}
+
+impl RecurrenceRelationDiscoveryMode {
+    pub fn parse(value: &str) -> RusticolResult<Self> {
+        match value {
+            "off" => Ok(Self::Off),
+            "diagnostic" => Ok(Self::Diagnostic),
+            "certified-reuse" => Ok(Self::CertifiedReuse),
+            _ => Err(invalid(format!("unsupported mode {value:?}"))),
+        }
+    }
+
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Off => "off",
+            Self::Diagnostic => "diagnostic",
+            Self::CertifiedReuse => "certified-reuse",
+        }
+    }
+
+    pub const fn applies_reuse(self) -> bool {
+        matches!(self, Self::CertifiedReuse)
+    }
+}
+
+/// Authenticated options passed through the recurrence lowering boundary.
+#[derive(Clone, Debug, PartialEq)]
+pub struct RecurrenceRelationDiscoveryOptions {
+    pub mode: RecurrenceRelationDiscoveryMode,
+    pub precision_digits: u32,
+    pub probe_count: u32,
+    pub verification_probe_count: u32,
+    pub relative_tolerance: f64,
+    pub absolute_tolerance: f64,
+    pub seed: u64,
+    pub color_accuracy: String,
+    pub numerical_evidence: Option<RecurrenceNumericalRelationEvidence>,
+}
+
+impl RecurrenceRelationDiscoveryOptions {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        mode: RecurrenceRelationDiscoveryMode,
+        precision_digits: u32,
+        probe_count: u32,
+        verification_probe_count: u32,
+        relative_tolerance: f64,
+        absolute_tolerance: f64,
+        seed: u64,
+        color_accuracy: impl Into<String>,
+    ) -> RusticolResult<Self> {
+        if precision_digits < 80 {
+            return Err(invalid("precision must be at least 80 decimal digits"));
+        }
+        if probe_count < 2 {
+            return Err(invalid("at least two probes are required"));
+        }
+        if verification_probe_count < 2 {
+            return Err(invalid("at least two verification probes are required"));
+        }
+        if !relative_tolerance.is_finite()
+            || relative_tolerance < 0.0
+            || !absolute_tolerance.is_finite()
+            || absolute_tolerance < 0.0
+            || (relative_tolerance == 0.0 && absolute_tolerance == 0.0)
+        {
+            return Err(invalid(
+                "relative and absolute tolerances must be finite and nonnegative, and at least one must be positive",
+            ));
+        }
+        let color_accuracy = color_accuracy.into();
+        if !matches!(color_accuracy.as_str(), "lc" | "nlc" | "full") {
+            return Err(invalid(format!(
+                "unsupported color accuracy {color_accuracy:?}"
+            )));
+        }
+        Ok(Self {
+            mode,
+            precision_digits,
+            probe_count,
+            verification_probe_count,
+            relative_tolerance,
+            absolute_tolerance,
+            seed,
+            color_accuracy,
+            numerical_evidence: None,
+        })
+    }
+
+    pub fn with_numerical_evidence(
+        mut self,
+        evidence: RecurrenceNumericalRelationEvidence,
+    ) -> RusticolResult<Self> {
+        if self.mode == RecurrenceRelationDiscoveryMode::Off {
+            return Err(invalid("off mode cannot carry numerical relation evidence"));
+        }
+        if evidence.requested_mode != self.mode {
+            return Err(invalid(
+                "numerical evidence mode disagrees with lowering options",
+            ));
+        }
+        if evidence.certificate_algorithm != NUMERICAL_RELATION_CERTIFICATE_ALGORITHM {
+            return Err(invalid(
+                "numerical evidence uses an unsupported certificate algorithm",
+            ));
+        }
+        if evidence.precision_digits != self.precision_digits
+            || evidence.probe_count != self.probe_count
+            || evidence.verification_probe_count != self.verification_probe_count
+            || evidence.relative_tolerance.to_bits() != self.relative_tolerance.to_bits()
+            || evidence.absolute_tolerance.to_bits() != self.absolute_tolerance.to_bits()
+            || evidence.seed != self.seed
+        {
+            return Err(invalid(
+                "numerical evidence probe contract disagrees with lowering options",
+            ));
+        }
+        let expected_candidate_count = evidence
+            .mappings
+            .len()
+            .checked_add(evidence.verification_rejected_count)
+            .ok_or_else(|| invalid("numerical evidence candidate count overflows usize"))?;
+        let expected_rejected_count = evidence
+            .tested_hypothesis_count
+            .checked_sub(evidence.mappings.len())
+            .ok_or_else(|| invalid("numerical evidence rejected-hypothesis count underflows"))?;
+        if evidence.numerical_candidate_count != expected_candidate_count
+            || evidence.tested_hypothesis_count < evidence.numerical_candidate_count
+            || evidence.rejected_hypothesis_count != expected_rejected_count
+        {
+            return Err(invalid(
+                "numerical evidence candidate counters are inconsistent",
+            ));
+        }
+        self.numerical_evidence = Some(evidence);
+        Ok(self)
+    }
+
+    pub fn off() -> Self {
+        Self {
+            mode: RecurrenceRelationDiscoveryMode::Off,
+            precision_digits: 96,
+            probe_count: 4,
+            verification_probe_count: 4,
+            relative_tolerance: 1.0e-70,
+            absolute_tolerance: 1.0e-80,
+            seed: 0x5059_414d,
+            color_accuracy: "lc".to_owned(),
+            numerical_evidence: None,
+        }
+    }
+}
+
+/// One Python-authenticated exact ±1/zero scale mapping.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceNumericalCurrentMapping {
+    pub current_id: u32,
+    pub representative_id: Option<u32>,
+    pub execution_representative_id: u32,
+    pub relation_kind: String,
+    pub factor: ExactComplexRational,
+    pub current_dimension: u16,
+    pub certificate_proof_sha256: String,
+    pub candidate_observations_sha256: String,
+    pub verification_observations_sha256: String,
+}
+
+/// Canonical evidence supplied only after an unpublished exact baseline pass.
+#[derive(Clone, Debug, PartialEq)]
+pub struct RecurrenceNumericalRelationEvidence {
+    pub requested_mode: RecurrenceRelationDiscoveryMode,
+    pub schedule_semantic_digest: String,
+    pub baseline_runtime_layout_digest: String,
+    pub source_semantics_sha256: String,
+    pub runtime_parameter_schema_sha256: String,
+    pub candidate_observation_batch_sha256: String,
+    pub verification_observation_batch_sha256: String,
+    pub decision_sha256: String,
+    pub rejection_decision_sha256: String,
+    pub certificate_algorithm: String,
+    pub certificate_set_sha256: String,
+    pub precision_digits: u32,
+    pub probe_count: u32,
+    pub verification_probe_count: u32,
+    pub relative_tolerance: f64,
+    pub absolute_tolerance: f64,
+    pub seed: u64,
+    pub numerical_candidate_count: usize,
+    pub verification_rejected_count: usize,
+    pub rejected_hypothesis_count: usize,
+    pub tested_hypothesis_count: usize,
+    pub mappings: Vec<RecurrenceNumericalCurrentMapping>,
+}
+
+/// Recompute the source contract consumed by the exact Python probe pass.
+///
+/// This deliberately binds the baseline physical layout as well as every
+/// current comparison contract. The numerical evidence is rejected unless
+/// its claimed digest is byte-for-byte identical to this native result.
+pub fn recurrence_numerical_source_semantics_sha256(
+    plan: &DirectRecurrencePlan,
+    process_id: &str,
+) -> RusticolResult<String> {
+    let mut finalization_executors = BTreeMap::<u32, u32>::new();
+    for group in plan
+        .row_groups()
+        .iter()
+        .filter(|group| group.role == DirectExecutorRole::Finalization)
+    {
+        let start = u32::try_from(group.row_start)
+            .map_err(|_| invalid("finalization row-group start exceeds u32"))?;
+        let stop = start
+            .checked_add(group.row_count)
+            .ok_or_else(|| invalid("finalization row-group range overflows u32"))?;
+        for row_id in start..stop {
+            if finalization_executors
+                .insert(row_id, group.direct_executor_id)
+                .is_some()
+            {
+                return Err(invalid(
+                    "baseline finalization row belongs to multiple executor groups",
+                ));
+            }
+        }
+    }
+
+    let currents = plan
+        .currents()
+        .iter()
+        .map(|current| {
+            let (executor_id, momentum_form_id, factor) = if current.finalization_row_or_sentinel
+                == DIRECT_NONE_U32
+            {
+                (
+                    DIRECT_NONE_U32,
+                    DIRECT_NONE_U32,
+                    [
+                        "1".to_owned(),
+                        "1".to_owned(),
+                        "0".to_owned(),
+                        "1".to_owned(),
+                    ],
+                )
+            } else {
+                let row = plan
+                    .finalizations()
+                    .get(current.finalization_row_or_sentinel as usize)
+                    .ok_or_else(|| invalid("baseline current finalization row is absent"))?;
+                let executor_id = *finalization_executors
+                    .get(&current.finalization_row_or_sentinel)
+                    .ok_or_else(|| invalid("baseline current finalization executor is absent"))?;
+                let factor = plan
+                    .exact_factors()
+                    .get(row.exact_factor_id as usize)
+                    .ok_or_else(|| invalid("baseline finalization factor is absent"))?;
+                (
+                    executor_id,
+                    row.momentum_form_id,
+                    [
+                        factor.real().numerator().to_string(),
+                        factor.real().denominator().to_string(),
+                        factor.imag().numerator().to_string(),
+                        factor.imag().denominator().to_string(),
+                    ],
+                )
+            };
+            Ok(json!({
+                "current_id": current.semantic_current_id,
+                "is_source": current.node_kind == DirectNodeKind::Source,
+                "contract": [
+                    current.node_kind as u16,
+                    current.stage,
+                    current.state_template_id,
+                    current.component_count,
+                    current.momentum_form_id,
+                    current.selector_domain_id,
+                    executor_id,
+                    momentum_form_id,
+                    factor,
+                ],
+            }))
+        })
+        .collect::<RusticolResult<Vec<JsonValue>>>()?;
+    let selector_schedule = match plan.strategy() {
+        RecurrenceStrategy::TopologyReplay => json!({
+            "policy": "seeded-replay-target-per-physical-point-v1",
+            "replay_targets": plan
+                .replay_targets()
+                .iter()
+                .enumerate()
+                .map(|(target_index, target)| json!({
+                    "target_index": target_index,
+                    "public_flow_id": target.public_flow_id,
+                    "representative_id": target.representative_id,
+                    "selector_domain_id": target.selector_domain_id,
+                }))
+                .collect::<Vec<_>>(),
+        }),
+        RecurrenceStrategy::AllFlowUnion => json!({
+            "policy": "seeded-helicity-per-selector-domain-and-physical-point-v1",
+            "resolved_helicities": plan
+                .resolved_helicities()
+                .iter()
+                .enumerate()
+                .map(|(helicity_index, helicity)| json!({
+                    "helicity_index": helicity_index,
+                    "helicity_id": helicity.id,
+                    "selector_domain_id": helicity.selector_domain_id,
+                }))
+                .collect::<Vec<_>>(),
+        }),
+        RecurrenceStrategy::ContractedColorUnion => json!({
+            "policy": "fixed-contracted-source-schedule-v1",
+            "fixed_source_schedule": true,
+        }),
+    };
+    let payload = json!({
+        "abi": RECURRENCE_NUMERICAL_SOURCE_ABI,
+        "process_id": process_id,
+        "strategy": plan.strategy().as_str(),
+        "schedule_semantic_digest": plan.semantic_digest().to_string(),
+        "baseline_runtime_layout_digest": plan.runtime_layout_digest().to_string(),
+        "selector_schedule": selector_schedule,
+        "currents": currents,
+    });
+    let bytes = serde_json::to_vec(&payload)
+        .map_err(|error| invalid(format!("could not canonicalize source semantics: {error}")))?;
+    Ok(format!("{:x}", Sha256::digest(bytes)))
+}
+
+pub fn authenticate_recurrence_numerical_relation_provenance(
+    evidence: &RecurrenceNumericalRelationEvidence,
+    baseline_plan: &DirectRecurrencePlan,
+    process_id: &str,
+) -> RusticolResult<()> {
+    if evidence.baseline_runtime_layout_digest != baseline_plan.runtime_layout_digest().to_string()
+    {
+        return Err(RusticolError::integrity(
+            "numerical relation evidence baseline runtime-layout digest does not match the native baseline",
+        ));
+    }
+    let expected_source_semantics =
+        recurrence_numerical_source_semantics_sha256(baseline_plan, process_id)?;
+    if evidence.source_semantics_sha256 != expected_source_semantics {
+        return Err(RusticolError::integrity(
+            "numerical relation evidence source-semantics digest does not match the native baseline",
+        ));
+    }
+    Ok(())
+}
+
+/// Runtime contract which must agree before two current values are comparable.
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(crate) struct RelationCurrentContract {
+    pub stage: u16,
+    pub state_template_id: u32,
+    pub component_count: u16,
+    pub momentum_form_id: u32,
+    pub selector_domain_id: u32,
+    pub finalization_executor_id: u32,
+    pub finalization_momentum_form_id: u32,
+    pub finalization_exact_factor: ExactComplexRational,
+}
+
+/// One exact lowered contribution before parent relation substitution.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct RelationTermInput {
+    pub executor_id: u32,
+    pub parent_current_ids: Box<[u32]>,
+    pub parent_momentum_form_ids: Box<[u32]>,
+    pub exact_factor: ExactComplexRational,
+}
+
+/// Exact schedule input for one current in topological ID order.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct RelationCurrentInput {
+    pub current_id: u32,
+    pub is_source: bool,
+    pub contract: RelationCurrentContract,
+    pub terms: Box<[RelationTermInput]>,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct RelationTermKey {
+    executor_id: u32,
+    parent_class_ids: Box<[u32]>,
+    parent_momentum_form_ids: Box<[u32]>,
+}
+
+type ExactTermVector = BTreeMap<RelationTermKey, ExactComplexRational>;
+
+/// Exact, independently replayable relation between two lowered currents.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceCurrentRelationCertificate {
+    pub current_id: u32,
+    pub representative_id: u32,
+    pub factor: ExactComplexRational,
+    pub current_expression_sha256: String,
+    pub representative_expression_sha256: String,
+    pub proof_sha256: String,
+}
+
+/// Manifest-facing result of one recurrence relation-discovery pass.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecurrenceRelationDiscoveryReport {
+    pub requested_mode: RecurrenceRelationDiscoveryMode,
+    pub state: &'static str,
+    pub strategy: RecurrenceStrategy,
+    pub color_accuracy: String,
+    pub precision_digits: u32,
+    pub probe_count: u32,
+    pub verification_probe_count: u32,
+    pub seed: u64,
+    pub certificate_algorithm: String,
+    pub authenticated_certificate_set_sha256: Option<String>,
+    pub authenticated_runtime_parameter_schema_sha256: Option<String>,
+    pub authenticated_candidate_observation_batch_sha256: Option<String>,
+    pub authenticated_verification_observation_batch_sha256: Option<String>,
+    pub authenticated_decision_sha256: Option<String>,
+    pub rejected_decision_sha256: String,
+    pub tested_hypothesis_count: usize,
+    pub verification_rejected_count: usize,
+    pub rejected_hypothesis_count: usize,
+    pub effective_projection_count: u32,
+    pub numerical_candidate_count: usize,
+    pub uncertified_candidate_count: usize,
+    pub exact_certified_relation_count: usize,
+    pub applied_relation_count: usize,
+    pub current_count_before: usize,
+    pub current_count_after: usize,
+    pub contribution_count_before: usize,
+    pub contribution_count_after: usize,
+    pub interaction_evaluation_count_before: usize,
+    pub interaction_evaluation_count_after: usize,
+    pub scale_copy_row_count: usize,
+    pub certificates: Vec<RecurrenceCurrentRelationCertificate>,
+    pub rejected_candidates: Vec<String>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct RecurrenceRelationDiscoveryOutcome {
+    pub relations: Vec<RecurrenceCurrentRelationCertificate>,
+    pub numerical_candidate_count: usize,
+    pub uncertified_candidate_count: usize,
+    pub rejected_hypothesis_count: usize,
+    pub rejected_candidates: Vec<String>,
+    pub rejected_decision_sha256: String,
+    pub effective_projection_count: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct Fp2 {
+    re: u64,
+    im: u64,
+}
+
+impl Fp2 {
+    const ZERO: Self = Self { re: 0, im: 0 };
+
+    fn add(self, right: Self) -> Self {
+        Self {
+            re: add_mod(self.re, right.re),
+            im: add_mod(self.im, right.im),
+        }
+    }
+
+    fn mul(self, right: Self) -> Self {
+        Self {
+            re: sub_mod(mul_mod(self.re, right.re), mul_mod(self.im, right.im)),
+            im: add_mod(mul_mod(self.re, right.im), mul_mod(self.im, right.re)),
+        }
+    }
+
+    fn inverse(self) -> Option<Self> {
+        let norm = add_mod(mul_mod(self.re, self.re), mul_mod(self.im, self.im));
+        if norm == 0 {
+            return None;
+        }
+        let inverse = pow_mod(norm, PROJECTION_PRIME - 2);
+        Some(Self {
+            re: mul_mod(self.re, inverse),
+            im: sub_mod(0, mul_mod(self.im, inverse)),
+        })
+    }
+}
+
+/// Discover recurrence-current relations in topological order.
+///
+/// The finite-field fingerprint nominates candidates with a collision bound
+/// controlled by `precision_digits` and `probe_count`. It is never accepted
+/// as proof: `exact_relation_factor` checks every exact coefficient, and
+/// `replay_certificate` repeats that check from the stored vectors.
+pub(crate) fn discover_recurrence_current_relations(
+    inputs: &[RelationCurrentInput],
+    options: &RecurrenceRelationDiscoveryOptions,
+) -> RusticolResult<RecurrenceRelationDiscoveryOutcome> {
+    let rejection_root = format!(
+        "{:x}",
+        Sha256::digest(
+            serde_json::to_vec(&json!({
+                "abi": "rusticol-recurrence-rejected-decision-chain-v1",
+                "precision_digits": options.precision_digits,
+                "probe_count": options.probe_count,
+                "seed": options.seed,
+            }))
+            .map_err(|error| invalid(format!("could not encode rejection root: {error}")))?,
+        )
+    );
+    if options.mode == RecurrenceRelationDiscoveryMode::Off {
+        return Ok(RecurrenceRelationDiscoveryOutcome {
+            relations: Vec::new(),
+            numerical_candidate_count: 0,
+            uncertified_candidate_count: 0,
+            rejected_hypothesis_count: 0,
+            rejected_candidates: Vec::new(),
+            rejected_decision_sha256: rejection_root,
+            effective_projection_count: 0,
+        });
+    }
+    for (index, input) in inputs.iter().enumerate() {
+        if input.current_id != index as u32 {
+            return Err(invalid(format!(
+                "current {index} has non-canonical ID {}",
+                input.current_id
+            )));
+        }
+    }
+
+    // Four bits per requested decimal digit is conservative relative to
+    // log2(10). Each independent projection lives in F_(2^61-1)^2.
+    let precision_projection_count = options.precision_digits.saturating_mul(4).div_ceil(61);
+    let effective_projection_count = options.probe_count.max(precision_projection_count).max(2);
+
+    let mut class_by_current = Vec::<u32>::with_capacity(inputs.len());
+    let mut factor_by_current = Vec::<ExactComplexRational>::with_capacity(inputs.len());
+    let mut vector_by_current = Vec::<ExactTermVector>::with_capacity(inputs.len());
+    let mut groups = BTreeMap::<(RelationCurrentContract, Vec<Fp2>), Vec<u32>>::new();
+    let mut relations = Vec::new();
+    let mut numerical_candidate_count = 0usize;
+    let mut uncertified_candidate_count = 0usize;
+    let mut rejected_candidates = Vec::new();
+    let mut rejected_decision_sha256 = rejection_root;
+
+    for input in inputs {
+        if input.is_source {
+            class_by_current.push(input.current_id);
+            factor_by_current.push(ExactComplexRational::ONE);
+            vector_by_current.push(BTreeMap::new());
+            continue;
+        }
+        let vector = exact_term_vector(input, &class_by_current, &factor_by_current)?;
+        let Some(fingerprint) =
+            numerical_fingerprint(&vector, options.seed, effective_projection_count)?
+        else {
+            class_by_current.push(input.current_id);
+            factor_by_current.push(ExactComplexRational::ONE);
+            vector_by_current.push(vector);
+            continue;
+        };
+
+        let key = (input.contract.clone(), fingerprint);
+        let mut relation = None;
+        if let Some(representatives) = groups.get(&key) {
+            for representative_id in representatives {
+                numerical_candidate_count = numerical_candidate_count
+                    .checked_add(1)
+                    .ok_or_else(|| invalid("candidate count overflows usize"))?;
+                let representative = vector_by_current
+                    .get(*representative_id as usize)
+                    .ok_or_else(|| invalid("candidate representative is absent"))?;
+                match exact_relation_factor(&vector, representative)? {
+                    Some(factor) => {
+                        let certificate = build_certificate(
+                            input.current_id,
+                            *representative_id,
+                            factor,
+                            &vector,
+                            representative,
+                        );
+                        if replay_certificate(&certificate, &vector, representative)? {
+                            relation = Some(certificate);
+                            break;
+                        }
+                        uncertified_candidate_count += 1;
+                        let reason = format!(
+                            "current {} and representative {} failed exact certificate replay",
+                            input.current_id, representative_id
+                        );
+                        let mut digest = Sha256::new();
+                        digest.update(rejected_decision_sha256.as_bytes());
+                        digest.update(reason.as_bytes());
+                        rejected_decision_sha256 = format!("{:x}", digest.finalize());
+                        if rejected_candidates.len() < 16 {
+                            rejected_candidates.push(reason);
+                        }
+                    }
+                    None => {
+                        uncertified_candidate_count += 1;
+                        let reason = format!(
+                            "current {} and representative {} collided numerically without an exact relation",
+                            input.current_id, representative_id
+                        );
+                        let mut digest = Sha256::new();
+                        digest.update(rejected_decision_sha256.as_bytes());
+                        digest.update(reason.as_bytes());
+                        rejected_decision_sha256 = format!("{:x}", digest.finalize());
+                        if rejected_candidates.len() < 16 {
+                            rejected_candidates.push(reason);
+                        }
+                    }
+                }
+            }
+        }
+        if let Some(certificate) = relation {
+            let representative_id = certificate.representative_id;
+            class_by_current.push(class_by_current[representative_id as usize]);
+            factor_by_current.push(certificate.factor);
+            relations.push(certificate);
+        } else {
+            class_by_current.push(input.current_id);
+            factor_by_current.push(ExactComplexRational::ONE);
+            groups.entry(key).or_default().push(input.current_id);
+        }
+        vector_by_current.push(vector);
+    }
+
+    Ok(RecurrenceRelationDiscoveryOutcome {
+        relations,
+        numerical_candidate_count,
+        uncertified_candidate_count,
+        rejected_hypothesis_count: uncertified_candidate_count,
+        rejected_candidates,
+        rejected_decision_sha256,
+        effective_projection_count,
+    })
+}
+
+fn exact_term_vector(
+    input: &RelationCurrentInput,
+    class_by_current: &[u32],
+    factor_by_current: &[ExactComplexRational],
+) -> RusticolResult<ExactTermVector> {
+    let mut vector = BTreeMap::<RelationTermKey, ExactComplexRational>::new();
+    for term in input.terms.iter() {
+        if term.parent_current_ids.len() != term.parent_momentum_form_ids.len()
+            || term.parent_current_ids.is_empty()
+            || term.parent_current_ids.len() > 2
+        {
+            return Err(invalid(format!(
+                "current {} has an invalid relation term arity",
+                input.current_id
+            )));
+        }
+        let mut coefficient = term.exact_factor;
+        let mut parent_class_ids = Vec::with_capacity(term.parent_current_ids.len());
+        for parent_id in term.parent_current_ids.iter().copied() {
+            if parent_id >= input.current_id {
+                return Err(invalid(format!(
+                    "current {} relation term references non-topological parent {parent_id}",
+                    input.current_id
+                )));
+            }
+            parent_class_ids.push(
+                *class_by_current
+                    .get(parent_id as usize)
+                    .ok_or_else(|| invalid("relation parent class is absent"))?,
+            );
+            coefficient = coefficient.checked_mul(
+                *factor_by_current
+                    .get(parent_id as usize)
+                    .ok_or_else(|| invalid("relation parent factor is absent"))?,
+            )?;
+        }
+        let key = RelationTermKey {
+            executor_id: term.executor_id,
+            parent_class_ids: parent_class_ids.into_boxed_slice(),
+            parent_momentum_form_ids: term.parent_momentum_form_ids.clone(),
+        };
+        let combined = vector
+            .get(&key)
+            .copied()
+            .unwrap_or(ExactComplexRational::ZERO)
+            .checked_add(coefficient)?;
+        if combined.is_zero() {
+            vector.remove(&key);
+        } else {
+            vector.insert(key, combined);
+        }
+    }
+    Ok(vector)
+}
+
+fn numerical_fingerprint(
+    vector: &ExactTermVector,
+    seed: u64,
+    projection_count: u32,
+) -> RusticolResult<Option<Vec<Fp2>>> {
+    if vector.is_empty() {
+        return Ok(None);
+    }
+    let mut values = Vec::with_capacity(projection_count as usize);
+    for projection in 0..projection_count {
+        let mut value = Fp2::ZERO;
+        for (key, coefficient) in vector {
+            value =
+                value.add(exact_to_fp2(*coefficient)?.mul(term_projection(seed, projection, key)));
+        }
+        values.push(value);
+    }
+    let Some(pivot) = values.iter().copied().find(|value| *value != Fp2::ZERO) else {
+        return Ok(None);
+    };
+    let Some(inverse) = pivot.inverse() else {
+        return Ok(None);
+    };
+    Ok(Some(
+        values.into_iter().map(|value| value.mul(inverse)).collect(),
+    ))
+}
+
+fn term_projection(seed: u64, projection: u32, key: &RelationTermKey) -> Fp2 {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-relation-probe-v1");
+    hash.update(seed.to_le_bytes());
+    hash.update(projection.to_le_bytes());
+    hash.update(key.executor_id.to_le_bytes());
+    hash.update((key.parent_class_ids.len() as u64).to_le_bytes());
+    for value in key.parent_class_ids.iter() {
+        hash.update(value.to_le_bytes());
+    }
+    for value in key.parent_momentum_form_ids.iter() {
+        hash.update(value.to_le_bytes());
+    }
+    let digest = hash.finalize();
+    let re = u64::from_le_bytes(digest[0..8].try_into().expect("SHA slice"));
+    let im = u64::from_le_bytes(digest[8..16].try_into().expect("SHA slice"));
+    Fp2 {
+        re: re % PROJECTION_PRIME,
+        im: im % PROJECTION_PRIME,
+    }
+}
+
+fn exact_to_fp2(value: ExactComplexRational) -> RusticolResult<Fp2> {
+    Ok(Fp2 {
+        re: rational_to_field(value.real())?,
+        im: rational_to_field(value.imag())?,
+    })
+}
+
+fn rational_to_field(value: super::ExactRational) -> RusticolResult<u64> {
+    let numerator = field_residue(value.numerator());
+    let denominator = field_residue(value.denominator());
+    if denominator == 0 {
+        return Err(invalid(
+            "an exact denominator is zero in the numerical projection field",
+        ));
+    }
+    Ok(mul_mod(
+        numerator,
+        pow_mod(denominator, PROJECTION_PRIME - 2),
+    ))
+}
+
+fn field_residue(value: i128) -> u64 {
+    value.rem_euclid(i128::from(PROJECTION_PRIME)) as u64
+}
+
+fn exact_relation_factor(
+    current: &ExactTermVector,
+    representative: &ExactTermVector,
+) -> RusticolResult<Option<ExactComplexRational>> {
+    if current.len() != representative.len() || current.is_empty() {
+        return Ok(None);
+    }
+    let Some((
+        (current_key, current_coefficient),
+        (representative_key, representative_coefficient),
+    )) = current
+        .first_key_value()
+        .zip(representative.first_key_value())
+    else {
+        return Ok(None);
+    };
+    if current_key != representative_key {
+        return Ok(None);
+    }
+    let factor = current_coefficient.checked_div(*representative_coefficient)?;
+    if factor.is_zero() {
+        return Ok(None);
+    }
+    for ((current_key, current_coefficient), (representative_key, representative_coefficient)) in
+        current.iter().zip(representative)
+    {
+        if current_key != representative_key
+            || *current_coefficient != representative_coefficient.checked_mul(factor)?
+        {
+            return Ok(None);
+        }
+    }
+    Ok(Some(factor))
+}
+
+fn build_certificate(
+    current_id: u32,
+    representative_id: u32,
+    factor: ExactComplexRational,
+    current: &ExactTermVector,
+    representative: &ExactTermVector,
+) -> RecurrenceCurrentRelationCertificate {
+    let current_expression_sha256 = expression_digest(current);
+    let representative_expression_sha256 = expression_digest(representative);
+    let proof_sha256 = proof_digest(
+        current_id,
+        representative_id,
+        factor,
+        &current_expression_sha256,
+        &representative_expression_sha256,
+    );
+    RecurrenceCurrentRelationCertificate {
+        current_id,
+        representative_id,
+        factor,
+        current_expression_sha256,
+        representative_expression_sha256,
+        proof_sha256,
+    }
+}
+
+fn replay_certificate(
+    certificate: &RecurrenceCurrentRelationCertificate,
+    current: &ExactTermVector,
+    representative: &ExactTermVector,
+) -> RusticolResult<bool> {
+    Ok(
+        exact_relation_factor(current, representative)? == Some(certificate.factor)
+            && expression_digest(current) == certificate.current_expression_sha256
+            && expression_digest(representative) == certificate.representative_expression_sha256
+            && proof_digest(
+                certificate.current_id,
+                certificate.representative_id,
+                certificate.factor,
+                &certificate.current_expression_sha256,
+                &certificate.representative_expression_sha256,
+            ) == certificate.proof_sha256,
+    )
+}
+
+fn expression_digest(vector: &ExactTermVector) -> String {
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-exact-row-vector-v1");
+    hash.update((vector.len() as u64).to_le_bytes());
+    for (key, coefficient) in vector {
+        hash.update(key.executor_id.to_le_bytes());
+        hash.update((key.parent_class_ids.len() as u64).to_le_bytes());
+        for value in key.parent_class_ids.iter() {
+            hash.update(value.to_le_bytes());
+        }
+        for value in key.parent_momentum_form_ids.iter() {
+            hash.update(value.to_le_bytes());
+        }
+        update_exact_hash(&mut hash, *coefficient);
+    }
+    format!("{:x}", hash.finalize())
+}
+
+fn proof_digest(
+    current_id: u32,
+    representative_id: u32,
+    factor: ExactComplexRational,
+    current_digest: &str,
+    representative_digest: &str,
+) -> String {
+    let mut hash = Sha256::new();
+    hash.update(RELATION_CERTIFICATE_ALGORITHM.as_bytes());
+    hash.update(current_id.to_le_bytes());
+    hash.update(representative_id.to_le_bytes());
+    update_exact_hash(&mut hash, factor);
+    hash.update(current_digest.as_bytes());
+    hash.update(representative_digest.as_bytes());
+    format!("{:x}", hash.finalize())
+}
+
+fn update_exact_hash(hash: &mut Sha256, value: ExactComplexRational) {
+    for part in [
+        value.real().numerator(),
+        value.real().denominator(),
+        value.imag().numerator(),
+        value.imag().denominator(),
+    ] {
+        let text = part.to_string();
+        hash.update((text.len() as u64).to_le_bytes());
+        hash.update(text.as_bytes());
+    }
+}
+
+fn add_mod(left: u64, right: u64) -> u64 {
+    ((u128::from(left) + u128::from(right)) % u128::from(PROJECTION_PRIME)) as u64
+}
+
+fn sub_mod(left: u64, right: u64) -> u64 {
+    ((u128::from(left) + u128::from(PROJECTION_PRIME) - u128::from(right))
+        % u128::from(PROJECTION_PRIME)) as u64
+}
+
+fn mul_mod(left: u64, right: u64) -> u64 {
+    ((u128::from(left) * u128::from(right)) % u128::from(PROJECTION_PRIME)) as u64
+}
+
+fn pow_mod(mut value: u64, mut exponent: u64) -> u64 {
+    let mut result = 1_u64;
+    while exponent != 0 {
+        if exponent & 1 != 0 {
+            result = mul_mod(result, value);
+        }
+        value = mul_mod(value, value);
+        exponent >>= 1;
+    }
+    result
+}
+
+pub fn relation_certificate_algorithm() -> &'static str {
+    RELATION_CERTIFICATE_ALGORITHM
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::recurrence::ExactRational;
+
+    fn factor(value: i128) -> ExactComplexRational {
+        ExactComplexRational::new(
+            ExactRational::new(value, 1).expect("integer factor"),
+            ExactRational::ZERO,
+        )
+    }
+
+    fn contract(stage: u16) -> RelationCurrentContract {
+        RelationCurrentContract {
+            stage,
+            state_template_id: 11,
+            component_count: 2,
+            momentum_form_id: 17,
+            selector_domain_id: 0,
+            finalization_executor_id: 9,
+            finalization_momentum_form_id: 17,
+            finalization_exact_factor: ExactComplexRational::ONE,
+        }
+    }
+
+    fn term(
+        executor_id: u32,
+        parent_current_id: u32,
+        exact_factor: ExactComplexRational,
+    ) -> RelationTermInput {
+        RelationTermInput {
+            executor_id,
+            parent_current_ids: vec![parent_current_id].into_boxed_slice(),
+            parent_momentum_form_ids: vec![3].into_boxed_slice(),
+            exact_factor,
+        }
+    }
+
+    #[test]
+    fn relation_options_reject_a_zero_width_tolerance_contract() {
+        let error = RecurrenceRelationDiscoveryOptions::new(
+            RecurrenceRelationDiscoveryMode::CertifiedReuse,
+            96,
+            4,
+            4,
+            0.0,
+            0.0,
+            0x5059_414d,
+            "lc",
+        )
+        .unwrap_err();
+        assert!(error.to_string().contains("at least one must be positive"));
+    }
+
+    #[test]
+    fn numerical_nomination_requires_exact_row_vector_replay() {
+        let inputs = vec![
+            RelationCurrentInput {
+                current_id: 0,
+                is_source: true,
+                contract: contract(0),
+                terms: Vec::new().into_boxed_slice(),
+            },
+            RelationCurrentInput {
+                current_id: 1,
+                is_source: false,
+                contract: contract(1),
+                terms: vec![term(7, 0, factor(1))].into_boxed_slice(),
+            },
+            RelationCurrentInput {
+                current_id: 2,
+                is_source: false,
+                contract: contract(1),
+                terms: vec![term(7, 0, factor(2))].into_boxed_slice(),
+            },
+            // The same projected algebra under an incompatible runtime
+            // contract must never be nominated for reuse.
+            RelationCurrentInput {
+                current_id: 3,
+                is_source: false,
+                contract: contract(2),
+                terms: vec![term(7, 0, factor(2))].into_boxed_slice(),
+            },
+        ];
+        let options = RecurrenceRelationDiscoveryOptions::new(
+            RecurrenceRelationDiscoveryMode::Diagnostic,
+            96,
+            4,
+            4,
+            1.0e-70,
+            1.0e-80,
+            0x5059_414d,
+            "full",
+        )
+        .unwrap();
+        let outcome = discover_recurrence_current_relations(&inputs, &options).unwrap();
+        assert_eq!(outcome.numerical_candidate_count, 1);
+        assert_eq!(outcome.uncertified_candidate_count, 0);
+        assert_eq!(outcome.relations.len(), 1);
+        let certificate = &outcome.relations[0];
+        assert_eq!(certificate.current_id, 2);
+        assert_eq!(certificate.representative_id, 1);
+        assert_eq!(certificate.factor, factor(2));
+        assert_eq!(certificate.proof_sha256.len(), 64);
+    }
+
+    #[test]
+    fn exact_parent_relations_propagate_to_later_currents() {
+        let inputs = vec![
+            RelationCurrentInput {
+                current_id: 0,
+                is_source: true,
+                contract: contract(0),
+                terms: Vec::new().into_boxed_slice(),
+            },
+            RelationCurrentInput {
+                current_id: 1,
+                is_source: false,
+                contract: contract(1),
+                terms: vec![term(7, 0, factor(1))].into_boxed_slice(),
+            },
+            RelationCurrentInput {
+                current_id: 2,
+                is_source: false,
+                contract: contract(1),
+                terms: vec![term(7, 0, factor(2))].into_boxed_slice(),
+            },
+            RelationCurrentInput {
+                current_id: 3,
+                is_source: false,
+                contract: contract(2),
+                terms: vec![term(8, 2, factor(1))].into_boxed_slice(),
+            },
+            RelationCurrentInput {
+                current_id: 4,
+                is_source: false,
+                contract: contract(2),
+                terms: vec![term(8, 1, factor(2))].into_boxed_slice(),
+            },
+        ];
+        let options = RecurrenceRelationDiscoveryOptions::new(
+            RecurrenceRelationDiscoveryMode::CertifiedReuse,
+            96,
+            4,
+            4,
+            1.0e-70,
+            1.0e-80,
+            7,
+            "nlc",
+        )
+        .unwrap();
+        let outcome = discover_recurrence_current_relations(&inputs, &options).unwrap();
+        assert_eq!(
+            outcome
+                .relations
+                .iter()
+                .map(|relation| (relation.current_id, relation.representative_id))
+                .collect::<Vec<_>>(),
+            vec![(2, 1), (4, 3)]
+        );
+        assert_eq!(outcome.relations[1].factor, ExactComplexRational::ONE);
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/symmetric_group_fft.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/symmetric_group_fft.rs
new file mode 100644
index 0000000000..b72d45446e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/symmetric_group_fft.rs
@@ -0,0 +1,1679 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Fast, unnormalised Fourier transforms on symmetric groups.
+//!
+//! The transform follows the subgroup tower `S_0 < S_1 < ... < S_m`.  Its
+//! output contains one column-major matrix for every Young diagram `lambda`,
+//! packed consecutively, and uses the convention
+//!
+//! `F_lambda = sum_g f(g) rho_lambda(g)`.
+//!
+//! Complex values are represented as `(real, imaginary)` pairs so this module
+//! remains independent of any evaluator backend.  In the batched interface the
+//! lane is the innermost index: `value[group_element * lane_count + lane]`.
+
+use std::collections::BTreeMap;
+
+use crate::{RusticolError, RusticolResult};
+
+/// Largest supported permutation degree.
+///
+/// `10!` still fits in `u32`, which keeps the persistent reorder map compact.
+pub const MAX_SYMMETRIC_GROUP_FFT_DEGREE: usize = 10;
+
+/// Backend-independent complex-f64 storage used by the FFT.
+pub type SymmetricGroupComplex64 = (f64, f64);
+
+type YoungTableau = Box<[(u8, u8)]>;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct YoungGeneratorAction {
+    partner: u32,
+    diagonal: f64,
+    mixing: f64,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct YoungBranch {
+    child_irrep: u32,
+    basis_offset: u32,
+}
+
+#[derive(Debug)]
+struct YoungIrrep {
+    shape: Box<[u8]>,
+    dimension: usize,
+    coefficient_offset: usize,
+    branches: Box<[YoungBranch]>,
+    tableaux: Box<[YoungTableau]>,
+    generators: Box<[YoungGeneratorAction]>,
+}
+
+impl YoungIrrep {
+    fn generator(&self, generator: usize, basis: usize) -> YoungGeneratorAction {
+        self.generators[generator * self.dimension + basis]
+    }
+}
+
+#[derive(Debug)]
+struct SymmetricGroupLevel {
+    degree: usize,
+    order: usize,
+    maximum_dimension: usize,
+    irreps: Box<[YoungIrrep]>,
+}
+
+/// Public description of one packed Fourier block.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct SymmetricGroupFftBlock<'a> {
+    shape: &'a [u8],
+    dimension: usize,
+    coefficient_offset: usize,
+}
+
+impl<'a> SymmetricGroupFftBlock<'a> {
+    /// Row lengths of the Young diagram, in non-increasing order.
+    pub fn shape(self) -> &'a [u8] {
+        self.shape
+    }
+
+    /// Dimension of this irreducible representation.
+    pub fn dimension(self) -> usize {
+        self.dimension
+    }
+
+    /// Zero-based offset of the column-major matrix in the packed transform.
+    pub fn coefficient_offset(self) -> usize {
+        self.coefficient_offset
+    }
+
+    /// Number of scalar complex coefficients in this block.
+    pub fn coefficient_count(self) -> usize {
+        self.dimension * self.dimension
+    }
+}
+
+/// Immutable representation and reorder metadata for one `S_m` transform.
+#[derive(Debug)]
+pub struct SymmetricGroupFftPlan {
+    degree: usize,
+    order: usize,
+    maximum_dimension: usize,
+    factorials: Box<[usize]>,
+    levels: Box<[SymmetricGroupLevel]>,
+    recursive_to_lexicographic: Box<[u32]>,
+    scalar_degree_three: Option<ScalarDegreeThreeTransform>,
+}
+
+/// Load-time compiled scalar Fourier rows for the smallest non-abelian group.
+///
+/// The generic subgroup-tower implementation remains the source of truth: it
+/// is applied once to each basis vector while constructing an `S_3` plan.
+/// Warm scalar calls can then execute the same real representation transform
+/// without repeatedly walking Young-branch metadata and clearing temporary
+/// blocks.  This is still the complete `S_3` Fourier transform, merely a
+/// compact base case of the general recursion.
+#[derive(Debug)]
+struct ScalarDegreeThreeTransform {
+    row_offsets: Box<[u8]>,
+    terms: Box<[(u8, f64)]>,
+}
+
+impl SymmetricGroupFftPlan {
+    /// Build a transform plan for `S_degree`.
+    #[cfg_attr(target_vendor = "apple", unsafe(link_section = "__TEXT,__rcl_load"))]
+    #[cfg_attr(target_vendor = "apple", inline(never))]
+    pub fn new(degree: usize) -> RusticolResult<Self> {
+        if degree > MAX_SYMMETRIC_GROUP_FFT_DEGREE {
+            return Err(invalid(format!(
+                "symmetric-group FFT degree {degree} exceeds supported maximum {MAX_SYMMETRIC_GROUP_FFT_DEGREE}"
+            )));
+        }
+        let factorials = checked_factorials(degree)?;
+        let order = factorials[degree];
+        let levels = build_levels(degree, &factorials)?;
+        let maximum_dimension = levels
+            .iter()
+            .map(|level| level.maximum_dimension)
+            .max()
+            .unwrap_or(1);
+        let recursive_to_lexicographic = build_recursive_to_lexicographic(degree, &factorials)?;
+        let mut plan = Self {
+            degree,
+            order,
+            maximum_dimension,
+            factorials: factorials.into_boxed_slice(),
+            levels: levels.into_boxed_slice(),
+            recursive_to_lexicographic: recursive_to_lexicographic.into_boxed_slice(),
+            scalar_degree_three: None,
+        };
+        if degree == 3 {
+            plan.scalar_degree_three = Some(compile_scalar_degree_three_transform(&plan)?);
+        }
+        Ok(plan)
+    }
+
+    /// Permutation degree `m`.
+    pub fn degree(&self) -> usize {
+        self.degree
+    }
+
+    /// Group order `m!`, equal to the number of scalar Fourier coefficients.
+    pub fn order(&self) -> usize {
+        self.order
+    }
+
+    /// Largest matrix dimension needed by a reusable workspace.
+    pub fn maximum_block_dimension(&self) -> usize {
+        self.maximum_dimension
+    }
+
+    /// Number of Young-irrep blocks in the packed transform.
+    pub fn block_count(&self) -> usize {
+        self.levels[self.degree].irreps.len()
+    }
+
+    /// Describe one Young-irrep block.
+    pub fn block(&self, index: usize) -> Option<SymmetricGroupFftBlock<'_>> {
+        self.levels[self.degree]
+            .irreps
+            .get(index)
+            .map(block_description)
+    }
+
+    /// Iterate over Young-irrep blocks in packed-output order.
+    pub fn blocks(
+        &self,
+    ) -> impl ExactSizeIterator<Item = SymmetricGroupFftBlock<'_>> + DoubleEndedIterator + '_ {
+        self.levels[self.degree]
+            .irreps
+            .iter()
+            .map(block_description)
+    }
+
+    /// Map recursive coset-order indices to lexicographic image-permutation indices.
+    pub fn recursive_to_lexicographic(&self) -> &[u32] {
+        &self.recursive_to_lexicographic
+    }
+
+    /// Return the lexicographic index of the inverse of one indexed permutation.
+    ///
+    /// This is the convention boundary needed when a raw colour kernel is
+    /// stored as `k(g)` but the block contraction requires the transform of
+    /// `g -> k(g^-1)`.  The calculation uses fixed-size stack storage and does
+    /// not allocate, so callers may build and then discard a compact reorder
+    /// vector during setup.
+    pub fn inverse_lexicographic_index(&self, index: usize) -> RusticolResult<usize> {
+        if index >= self.order {
+            return Err(invalid(format!(
+                "symmetric-group permutation index {index} exceeds group order {}",
+                self.order
+            )));
+        }
+        let permutation = lexicographic_unrank(self.degree, index, &self.factorials)?;
+        let mut inverse_code = 0_u64;
+        for (position, value) in permutation[..self.degree].iter().copied().enumerate() {
+            inverse_code |= (position as u64) << (4 * usize::from(value));
+        }
+        lexicographic_rank(inverse_code, self.degree, &self.factorials)
+    }
+
+    /// Allocate mutable scratch for at most `lane_capacity` innermost lanes.
+    pub fn workspace(&self, lane_capacity: usize) -> RusticolResult<SymmetricGroupFftWorkspace> {
+        SymmetricGroupFftWorkspace::new(self, lane_capacity)
+    }
+
+    /// Transform one complex function on `S_m`.
+    pub fn forward(
+        &self,
+        values: &[SymmetricGroupComplex64],
+        coefficients: &mut [SymmetricGroupComplex64],
+        workspace: &mut SymmetricGroupFftWorkspace,
+    ) -> RusticolResult<()> {
+        self.forward_lanes(1, values, coefficients, workspace)
+    }
+
+    /// Transform independent lanes stored contiguously for every group element.
+    pub fn forward_lanes(
+        &self,
+        active_lanes: usize,
+        values: &[SymmetricGroupComplex64],
+        coefficients: &mut [SymmetricGroupComplex64],
+        workspace: &mut SymmetricGroupFftWorkspace,
+    ) -> RusticolResult<()> {
+        if active_lanes == 0 {
+            return Err(invalid("symmetric-group FFT lane count must be positive"));
+        }
+        let value_count = self
+            .order
+            .checked_mul(active_lanes)
+            .ok_or_else(|| invalid("symmetric-group FFT value count overflows usize"))?;
+        if values.len() != value_count || coefficients.len() != value_count {
+            return Err(invalid(format!(
+                "symmetric-group FFT expected {value_count} input and output values, got {} and {}",
+                values.len(),
+                coefficients.len()
+            )));
+        }
+        workspace.validate(self, active_lanes)?;
+
+        if active_lanes == 1
+            && let Some(transform) = self.scalar_degree_three.as_ref()
+        {
+            transform.forward(values, coefficients);
+            return Ok(());
+        }
+
+        for (recursive_index, lexicographic_index) in
+            self.recursive_to_lexicographic.iter().copied().enumerate()
+        {
+            let source = usize::try_from(lexicographic_index)
+                .map_err(|_| internal("symmetric-group reorder index exceeds usize"))?
+                * active_lanes;
+            let target = recursive_index * active_lanes;
+            workspace.buffer[target..target + active_lanes]
+                .copy_from_slice(&values[source..source + active_lanes]);
+        }
+
+        let mut current_is_workspace = true;
+        for current_degree in 2..=self.degree {
+            let level = &self.levels[current_degree];
+            let child_level = &self.levels[current_degree - 1];
+            if active_lanes == 1 {
+                if current_is_workspace {
+                    transform_level_scalar(
+                        level,
+                        child_level,
+                        &workspace.buffer[..value_count],
+                        coefficients,
+                        &mut workspace.block,
+                        self.order,
+                    );
+                } else {
+                    transform_level_scalar(
+                        level,
+                        child_level,
+                        coefficients,
+                        &mut workspace.buffer[..value_count],
+                        &mut workspace.block,
+                        self.order,
+                    );
+                }
+            } else if current_is_workspace {
+                transform_level_batched(
+                    level,
+                    child_level,
+                    &workspace.buffer[..value_count],
+                    coefficients,
+                    &mut workspace.block,
+                    active_lanes,
+                    self.order,
+                );
+            } else {
+                transform_level_batched(
+                    level,
+                    child_level,
+                    coefficients,
+                    &mut workspace.buffer[..value_count],
+                    &mut workspace.block,
+                    active_lanes,
+                    self.order,
+                );
+            }
+            current_is_workspace = !current_is_workspace;
+        }
+        if current_is_workspace {
+            coefficients.copy_from_slice(&workspace.buffer[..value_count]);
+        }
+        Ok(())
+    }
+}
+
+impl ScalarDegreeThreeTransform {
+    #[inline(always)]
+    fn forward(
+        &self,
+        values: &[SymmetricGroupComplex64],
+        coefficients: &mut [SymmetricGroupComplex64],
+    ) {
+        debug_assert_eq!(values.len(), 6);
+        debug_assert_eq!(coefficients.len(), 6);
+        debug_assert_eq!(self.row_offsets.len(), 7);
+        for (output, coefficient) in coefficients.iter_mut().enumerate().take(6) {
+            let start = usize::from(self.row_offsets[output]);
+            let end = usize::from(self.row_offsets[output + 1]);
+            let mut real = 0.0;
+            let mut imaginary = 0.0;
+            for &(source, factor) in &self.terms[start..end] {
+                let value = values[usize::from(source)];
+                real = factor.mul_add(value.0, real);
+                imaginary = factor.mul_add(value.1, imaginary);
+            }
+            *coefficient = (real, imaginary);
+        }
+    }
+}
+
+fn compile_scalar_degree_three_transform(
+    plan: &SymmetricGroupFftPlan,
+) -> RusticolResult<ScalarDegreeThreeTransform> {
+    debug_assert_eq!(plan.degree, 3);
+    debug_assert_eq!(plan.order, 6);
+    debug_assert!(plan.scalar_degree_three.is_none());
+    let mut values = vec![(0.0, 0.0); plan.order];
+    let mut coefficients = vec![(0.0, 0.0); plan.order];
+    let mut workspace = plan.workspace(1)?;
+    let mut columns = vec![vec![0.0; plan.order]; plan.order];
+    for source in 0..plan.order {
+        values[source] = (1.0, 0.0);
+        plan.forward(&values, &mut coefficients, &mut workspace)?;
+        values[source] = (0.0, 0.0);
+        for (output, &(real, imaginary)) in coefficients.iter().enumerate() {
+            if imaginary != 0.0 || !real.is_finite() {
+                return Err(internal(
+                    "compiled scalar S3 Fourier transform is not finite and real",
+                ));
+            }
+            columns[source][output] = real;
+        }
+    }
+
+    let mut row_offsets = Vec::with_capacity(plan.order + 1);
+    let mut terms = Vec::new();
+    row_offsets.push(0_u8);
+    for output in 0..plan.order {
+        for (source, column) in columns.iter().enumerate() {
+            let factor = column[output];
+            if factor != 0.0 {
+                terms.push((source as u8, factor));
+            }
+        }
+        row_offsets.push(
+            u8::try_from(terms.len()).map_err(|_| {
+                internal("compiled scalar S3 Fourier transform term count exceeds u8")
+            })?,
+        );
+    }
+    Ok(ScalarDegreeThreeTransform {
+        row_offsets: row_offsets.into_boxed_slice(),
+        terms: terms.into_boxed_slice(),
+    })
+}
+
+fn block_description(irrep: &YoungIrrep) -> SymmetricGroupFftBlock<'_> {
+    SymmetricGroupFftBlock {
+        shape: &irrep.shape,
+        dimension: irrep.dimension,
+        coefficient_offset: irrep.coefficient_offset,
+    }
+}
+
+/// Mutable scratch that can be reused for transforms with the same shape.
+#[derive(Debug)]
+pub struct SymmetricGroupFftWorkspace {
+    degree: usize,
+    order: usize,
+    lane_capacity: usize,
+    buffer: Vec<SymmetricGroupComplex64>,
+    block: Vec<SymmetricGroupComplex64>,
+}
+
+impl SymmetricGroupFftWorkspace {
+    /// Allocate scratch for at most `lane_capacity` independent functions.
+    pub fn new(plan: &SymmetricGroupFftPlan, lane_capacity: usize) -> RusticolResult<Self> {
+        if lane_capacity == 0 {
+            return Err(invalid("symmetric-group FFT lane count must be positive"));
+        }
+        let buffer_count = plan
+            .order
+            .checked_mul(lane_capacity)
+            .ok_or_else(|| invalid("symmetric-group FFT workspace buffer size overflows usize"))?;
+        let block_count = plan
+            .maximum_dimension
+            .checked_mul(plan.maximum_dimension)
+            .and_then(|value| value.checked_mul(lane_capacity))
+            .ok_or_else(|| invalid("symmetric-group FFT block workspace size overflows usize"))?;
+        Ok(Self {
+            degree: plan.degree,
+            order: plan.order,
+            lane_capacity,
+            buffer: zeroed_complex_values(buffer_count, "FFT permutation buffer")?,
+            block: zeroed_complex_values(block_count, "FFT block workspace")?,
+        })
+    }
+
+    /// Maximum number of independent lanes accepted by this workspace.
+    pub fn lane_capacity(&self) -> usize {
+        self.lane_capacity
+    }
+
+    fn validate(&self, plan: &SymmetricGroupFftPlan, active_lanes: usize) -> RusticolResult<()> {
+        if self.degree != plan.degree || self.order != plan.order {
+            return Err(invalid(
+                "symmetric-group FFT workspace does not match the plan",
+            ));
+        }
+        if active_lanes > self.lane_capacity {
+            return Err(invalid(format!(
+                "symmetric-group FFT requested {active_lanes} active lanes from workspace capacity {}",
+                self.lane_capacity
+            )));
+        }
+        Ok(())
+    }
+}
+
+fn transform_level_batched(
+    level: &SymmetricGroupLevel,
+    child_level: &SymmetricGroupLevel,
+    input: &[SymmetricGroupComplex64],
+    output: &mut [SymmetricGroupComplex64],
+    block: &mut [SymmetricGroupComplex64],
+    lane_count: usize,
+    total_order: usize,
+) {
+    debug_assert_eq!(input.len(), total_order * lane_count);
+    debug_assert_eq!(output.len(), total_order * lane_count);
+    debug_assert_eq!(level.order, level.degree * child_level.order);
+    debug_assert!(block.len() >= level.maximum_dimension.pow(2) * lane_count);
+
+    for group_start in (0..total_order).step_by(level.order) {
+        let group_value_start = group_start * lane_count;
+        let group_value_end = (group_start + level.order) * lane_count;
+        output[group_value_start..group_value_end].fill((0.0, 0.0));
+
+        for coset in 0..level.degree {
+            let child_start = group_start + coset * child_level.order;
+            for irrep in &level.irreps {
+                let dimension = irrep.dimension;
+                let block_value_count = dimension * dimension * lane_count;
+                let block = &mut block[..block_value_count];
+                block.fill((0.0, 0.0));
+
+                for branch in &irrep.branches {
+                    let child = &child_level.irreps[branch.child_irrep as usize];
+                    let basis_offset = branch.basis_offset as usize;
+                    for column in 0..child.dimension {
+                        for row in 0..child.dimension {
+                            let source_coefficient = child_start
+                                + child.coefficient_offset
+                                + column * child.dimension
+                                + row;
+                            let target_coefficient =
+                                (basis_offset + column) * dimension + basis_offset + row;
+                            let source = source_coefficient * lane_count;
+                            let target = target_coefficient * lane_count;
+                            block[target..target + lane_count]
+                                .copy_from_slice(&input[source..source + lane_count]);
+                        }
+                    }
+                }
+
+                // The coset representative is s_i s_(i+1) ... s_(m-1).
+                // Left multiplication therefore applies its rightmost factor first.
+                for generator in (coset..level.degree - 1).rev() {
+                    apply_generator_on_left(irrep, generator, block, lane_count);
+                }
+
+                let output_offset = (group_start + irrep.coefficient_offset) * lane_count;
+                for (target, value) in output[output_offset..output_offset + block_value_count]
+                    .iter_mut()
+                    .zip(block.iter().copied())
+                {
+                    target.0 += value.0;
+                    target.1 += value.1;
+                }
+            }
+        }
+    }
+}
+
+/// Scalar transforms keep each temporary matrix transposed.  A Young
+/// generator then mixes two contiguous rows rather than walking two strided
+/// rows of the public column-major output.  The transpose is folded into the
+/// branch gather and final accumulation, so it needs no additional storage or
+/// pass over the block.
+fn transform_level_scalar(
+    level: &SymmetricGroupLevel,
+    child_level: &SymmetricGroupLevel,
+    input: &[SymmetricGroupComplex64],
+    output: &mut [SymmetricGroupComplex64],
+    block: &mut [SymmetricGroupComplex64],
+    total_order: usize,
+) {
+    debug_assert_eq!(input.len(), total_order);
+    debug_assert_eq!(output.len(), total_order);
+    debug_assert_eq!(level.order, level.degree * child_level.order);
+    debug_assert!(block.len() >= level.maximum_dimension.pow(2));
+
+    for group_start in (0..total_order).step_by(level.order) {
+        output[group_start..group_start + level.order].fill((0.0, 0.0));
+
+        for coset in 0..level.degree {
+            let child_start = group_start + coset * child_level.order;
+            for irrep in &level.irreps {
+                let dimension = irrep.dimension;
+                let block_value_count = dimension * dimension;
+                let block = &mut block[..block_value_count];
+                block.fill((0.0, 0.0));
+
+                for branch in &irrep.branches {
+                    let child = &child_level.irreps[branch.child_irrep as usize];
+                    let basis_offset = branch.basis_offset as usize;
+                    for column in 0..child.dimension {
+                        for row in 0..child.dimension {
+                            let source = child_start
+                                + child.coefficient_offset
+                                + column * child.dimension
+                                + row;
+                            // Fold the column-major -> row-major transpose into
+                            // the sparse branch embedding.
+                            let target = (basis_offset + row) * dimension + basis_offset + column;
+                            block[target] = input[source];
+                        }
+                    }
+                }
+
+                // The coset representative is s_i s_(i+1) ... s_(m-1).
+                // Left multiplication therefore applies its rightmost factor first.
+                for generator in (coset..level.degree - 1).rev() {
+                    apply_generator_on_left_scalar_transposed(irrep, generator, block);
+                }
+
+                let output_offset = group_start + irrep.coefficient_offset;
+                for row in 0..dimension {
+                    for column in 0..dimension {
+                        let target = output_offset + column * dimension + row;
+                        let value = block[row * dimension + column];
+                        output[target].0 += value.0;
+                        output[target].1 += value.1;
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn apply_generator_on_left(
+    irrep: &YoungIrrep,
+    generator: usize,
+    matrix: &mut [SymmetricGroupComplex64],
+    lane_count: usize,
+) {
+    let dimension = irrep.dimension;
+    for first in 0..dimension {
+        let first_action = irrep.generator(generator, first);
+        let other = first_action.partner as usize;
+        if other < first {
+            continue;
+        }
+        if other == first {
+            for column in 0..dimension {
+                let base = (column * dimension + first) * lane_count;
+                for value in &mut matrix[base..base + lane_count] {
+                    value.0 *= first_action.diagonal;
+                    value.1 *= first_action.diagonal;
+                }
+            }
+            continue;
+        }
+        let other_action = irrep.generator(generator, other);
+        for column in 0..dimension {
+            let first_base = (column * dimension + first) * lane_count;
+            let other_base = (column * dimension + other) * lane_count;
+            for lane in 0..lane_count {
+                let first_value = matrix[first_base + lane];
+                let other_value = matrix[other_base + lane];
+                matrix[first_base + lane] = linear_combination(
+                    first_action.diagonal,
+                    first_value,
+                    first_action.mixing,
+                    other_value,
+                );
+                matrix[other_base + lane] = linear_combination(
+                    other_action.mixing,
+                    first_value,
+                    other_action.diagonal,
+                    other_value,
+                );
+            }
+        }
+    }
+}
+
+fn apply_generator_on_left_scalar_transposed(
+    irrep: &YoungIrrep,
+    generator: usize,
+    matrix: &mut [SymmetricGroupComplex64],
+) {
+    let dimension = irrep.dimension;
+    debug_assert_eq!(matrix.len(), dimension * dimension);
+    for first in 0..dimension {
+        let first_action = irrep.generator(generator, first);
+        let other = first_action.partner as usize;
+        if other < first {
+            continue;
+        }
+        if other == first {
+            // A fixed Young-basis vector has axial distance +/-1.  The +1
+            // action is the identity and is common enough to skip outright.
+            if first_action.diagonal == 1.0 {
+                continue;
+            }
+            debug_assert_eq!(first_action.diagonal, -1.0);
+            let row = &mut matrix[first * dimension..(first + 1) * dimension];
+            for value in row {
+                value.0 = -value.0;
+                value.1 = -value.1;
+            }
+            continue;
+        }
+
+        let other_action = irrep.generator(generator, other);
+        let (before_other, from_other) = matrix.split_at_mut(other * dimension);
+        let first_row = &mut before_other[first * dimension..(first + 1) * dimension];
+        let other_row = &mut from_other[..dimension];
+        for (first_value, other_value) in first_row.iter_mut().zip(other_row) {
+            let old_first = *first_value;
+            let old_other = *other_value;
+            *first_value = linear_combination(
+                first_action.diagonal,
+                old_first,
+                first_action.mixing,
+                old_other,
+            );
+            *other_value = linear_combination(
+                other_action.mixing,
+                old_first,
+                other_action.diagonal,
+                old_other,
+            );
+        }
+    }
+}
+
+fn linear_combination(
+    first_factor: f64,
+    first: SymmetricGroupComplex64,
+    second_factor: f64,
+    second: SymmetricGroupComplex64,
+) -> SymmetricGroupComplex64 {
+    (
+        first_factor * first.0 + second_factor * second.0,
+        first_factor * first.1 + second_factor * second.1,
+    )
+}
+
+fn build_levels(degree: usize, factorials: &[usize]) -> RusticolResult<Vec<SymmetricGroupLevel>> {
+    let trivial_tableau: Box<[(u8, u8)]> = Vec::new().into_boxed_slice();
+    let mut levels = vec![SymmetricGroupLevel {
+        degree: 0,
+        order: 1,
+        maximum_dimension: 1,
+        irreps: vec![YoungIrrep {
+            shape: Vec::new().into_boxed_slice(),
+            dimension: 1,
+            coefficient_offset: 0,
+            branches: Vec::new().into_boxed_slice(),
+            tableaux: vec![trivial_tableau].into_boxed_slice(),
+            generators: Vec::new().into_boxed_slice(),
+        }]
+        .into_boxed_slice(),
+    }];
+    for current_degree in 1..=degree {
+        let level = build_level(
+            current_degree,
+            factorials[current_degree],
+            &levels[current_degree - 1],
+        )?;
+        levels.push(level);
+    }
+    Ok(levels)
+}
+
+fn build_level(
+    degree: usize,
+    order: usize,
+    child_level: &SymmetricGroupLevel,
+) -> RusticolResult<SymmetricGroupLevel> {
+    debug_assert_eq!(child_level.degree + 1, degree);
+    let shapes = integer_partitions(degree)?;
+    let mut irreps = Vec::new();
+    irreps
+        .try_reserve_exact(shapes.len())
+        .map_err(|error| internal(format!("Young-irrep allocation failed: {error}")))?;
+    let mut coefficient_offset = 0_usize;
+    let mut maximum_dimension = 1_usize;
+
+    for shape in shapes {
+        let removable_rows = (0..shape.len())
+            .filter(|row| shape[*row] > shape.get(*row + 1).copied().unwrap_or(0))
+            .collect::<Vec<_>>();
+        let mut branches = Vec::new();
+        let mut tableaux = Vec::new();
+        let mut dimension = 0_usize;
+        for row in removable_rows {
+            let mut child_shape = shape.clone();
+            child_shape[row] -= 1;
+            if child_shape.last() == Some(&0) {
+                child_shape.pop();
+            }
+            let child_irrep = child_level
+                .irreps
+                .iter()
+                .position(|candidate| candidate.shape.as_ref() == child_shape)
+                .ok_or_else(|| internal("Young branching child shape is absent"))?;
+            let child = &child_level.irreps[child_irrep];
+            let basis_offset = dimension;
+            dimension = dimension
+                .checked_add(child.dimension)
+                .ok_or_else(|| internal("Young-irrep dimension overflows usize"))?;
+            branches.push(YoungBranch {
+                child_irrep: u32::try_from(child_irrep)
+                    .map_err(|_| internal("Young child-irrep index exceeds u32"))?,
+                basis_offset: u32::try_from(basis_offset)
+                    .map_err(|_| internal("Young branch basis offset exceeds u32"))?,
+            });
+            for child_tableau in &child.tableaux {
+                let mut tableau = child_tableau.to_vec();
+                tableau.push((
+                    u8::try_from(row).map_err(|_| internal("Young tableau row exceeds u8"))?,
+                    shape[row] - 1,
+                ));
+                tableaux.push(tableau.into_boxed_slice());
+            }
+        }
+        if dimension == 0 || tableaux.len() != dimension {
+            return Err(internal("Young branching produced an invalid dimension"));
+        }
+        let generators = build_young_generators(degree, &tableaux)?;
+        let coefficient_count = dimension
+            .checked_mul(dimension)
+            .ok_or_else(|| internal("Young Fourier block size overflows usize"))?;
+        let irrep = YoungIrrep {
+            shape: shape.into_boxed_slice(),
+            dimension,
+            coefficient_offset,
+            branches: branches.into_boxed_slice(),
+            tableaux: tableaux.into_boxed_slice(),
+            generators: generators.into_boxed_slice(),
+        };
+        coefficient_offset = coefficient_offset
+            .checked_add(coefficient_count)
+            .ok_or_else(|| internal("Young coefficient count overflows usize"))?;
+        maximum_dimension = maximum_dimension.max(dimension);
+        irreps.push(irrep);
+    }
+    if coefficient_offset != order {
+        return Err(internal(format!(
+            "Young dimensions square to {coefficient_offset}, expected group order {order}"
+        )));
+    }
+    Ok(SymmetricGroupLevel {
+        degree,
+        order,
+        maximum_dimension,
+        irreps: irreps.into_boxed_slice(),
+    })
+}
+
+fn integer_partitions(degree: usize) -> RusticolResult<Vec<Vec<u8>>> {
+    fn visit(
+        remaining: usize,
+        maximum_part: usize,
+        shape: &mut Vec<u8>,
+        output: &mut Vec<Vec<u8>>,
+    ) -> RusticolResult<()> {
+        if remaining == 0 {
+            output.push(shape.clone());
+            return Ok(());
+        }
+        for part in (1..=remaining.min(maximum_part)).rev() {
+            shape.push(
+                u8::try_from(part)
+                    .map_err(|_| internal("Young partition row length exceeds u8"))?,
+            );
+            visit(remaining - part, part, shape, output)?;
+            shape.pop();
+        }
+        Ok(())
+    }
+
+    let mut output = Vec::new();
+    visit(degree, degree, &mut Vec::new(), &mut output)?;
+    Ok(output)
+}
+
+fn build_young_generators(
+    degree: usize,
+    tableaux: &[Box<[(u8, u8)]>],
+) -> RusticolResult<Vec<YoungGeneratorAction>> {
+    if degree <= 1 {
+        return Ok(Vec::new());
+    }
+    let dimension = tableaux.len();
+    let action_count = (degree - 1)
+        .checked_mul(dimension)
+        .ok_or_else(|| internal("Young generator table size overflows usize"))?;
+    let mut actions = Vec::new();
+    actions
+        .try_reserve_exact(action_count)
+        .map_err(|error| internal(format!("Young generator allocation failed: {error}")))?;
+
+    let tableau_index = tableaux
+        .iter()
+        .enumerate()
+        .map(|(index, tableau)| (tableau.to_vec(), index))
+        .collect::<BTreeMap<_, _>>();
+    for generator in 0..degree - 1 {
+        for (basis, tableau) in tableaux.iter().enumerate() {
+            let first = tableau[generator];
+            let second = tableau[generator + 1];
+            let first_content = i16::from(first.1) - i16::from(first.0);
+            let second_content = i16::from(second.1) - i16::from(second.0);
+            let axial_distance = second_content - first_content;
+            if axial_distance == 0 {
+                return Err(internal("standard Young tableau has zero axial distance"));
+            }
+            let diagonal = 1.0 / f64::from(axial_distance);
+            let partner = if axial_distance.unsigned_abs() == 1 {
+                basis
+            } else {
+                let mut swapped = tableau.to_vec();
+                swapped.swap(generator, generator + 1);
+                *tableau_index
+                    .get(&swapped)
+                    .ok_or_else(|| internal("Young generator partner tableau is absent"))?
+            };
+            actions.push(YoungGeneratorAction {
+                partner: u32::try_from(partner)
+                    .map_err(|_| internal("Young generator partner exceeds u32"))?,
+                diagonal,
+                mixing: (1.0 - diagonal * diagonal).max(0.0).sqrt(),
+            });
+        }
+    }
+    Ok(actions)
+}
+
+fn checked_factorials(degree: usize) -> RusticolResult<Vec<usize>> {
+    let mut factorials = Vec::new();
+    factorials
+        .try_reserve_exact(degree + 1)
+        .map_err(|error| invalid(format!("factorial table allocation failed: {error}")))?;
+    factorials.push(1_usize);
+    for factor in 1..=degree {
+        let value = factorials[factor - 1]
+            .checked_mul(factor)
+            .ok_or_else(|| invalid("symmetric-group order overflows usize"))?;
+        if value > u32::MAX as usize {
+            return Err(invalid(
+                "symmetric-group order exceeds compact reorder-index capacity",
+            ));
+        }
+        factorials.push(value);
+    }
+    Ok(factorials)
+}
+
+fn build_recursive_to_lexicographic(
+    degree: usize,
+    factorials: &[usize],
+) -> RusticolResult<Vec<u32>> {
+    if degree == 0 {
+        return Ok(vec![0]);
+    }
+    let mut child_codes = vec![0_u64];
+    let mut final_map = Vec::new();
+    for current_degree in 1..=degree {
+        let order = factorials[current_degree];
+        let is_final = current_degree == degree;
+        let mut next_codes = Vec::new();
+        if is_final {
+            final_map.try_reserve_exact(order).map_err(|error| {
+                invalid(format!("permutation reorder allocation failed: {error}"))
+            })?;
+        } else {
+            next_codes
+                .try_reserve_exact(order)
+                .map_err(|error| invalid(format!("permutation-code allocation failed: {error}")))?;
+        }
+        for coset in 0..current_degree {
+            for child_code in child_codes.iter().copied() {
+                let code = extend_recursive_permutation(child_code, current_degree, coset);
+                if is_final {
+                    let rank = lexicographic_rank(code, current_degree, factorials)?;
+                    final_map.push(
+                        u32::try_from(rank)
+                            .map_err(|_| internal("lexicographic rank exceeds u32"))?,
+                    );
+                } else {
+                    next_codes.push(code);
+                }
+            }
+        }
+        if !is_final {
+            child_codes = next_codes;
+        }
+    }
+    validate_reorder_map(&final_map, factorials[degree])?;
+    Ok(final_map)
+}
+
+fn extend_recursive_permutation(child: u64, degree: usize, coset: usize) -> u64 {
+    debug_assert!((1..=MAX_SYMMETRIC_GROUP_FFT_DEGREE).contains(&degree));
+    debug_assert!(coset < degree);
+    let mut result = 0_u64;
+    for position in 0..degree - 1 {
+        let child_value = ((child >> (4 * position)) & 0xf) as usize;
+        let value = if child_value < coset {
+            child_value
+        } else {
+            child_value + 1
+        };
+        result |= (value as u64) << (4 * position);
+    }
+    result | (coset as u64) << (4 * (degree - 1))
+}
+
+fn lexicographic_rank(code: u64, degree: usize, factorials: &[usize]) -> RusticolResult<usize> {
+    let mut used = 0_u16;
+    let mut rank = 0_usize;
+    for position in 0..degree {
+        let value = ((code >> (4 * position)) & 0xf) as usize;
+        if value >= degree || used & (1_u16 << value) != 0 {
+            return Err(internal("recursive permutation code is invalid"));
+        }
+        let smaller_mask = (1_u16 << value) - 1;
+        let used_smaller = (used & smaller_mask).count_ones() as usize;
+        let unused_smaller = value - used_smaller;
+        rank = rank
+            .checked_add(unused_smaller * factorials[degree - position - 1])
+            .ok_or_else(|| internal("lexicographic permutation rank overflows usize"))?;
+        used |= 1_u16 << value;
+    }
+    Ok(rank)
+}
+
+fn lexicographic_unrank(
+    degree: usize,
+    mut rank: usize,
+    factorials: &[usize],
+) -> RusticolResult<[u8; MAX_SYMMETRIC_GROUP_FFT_DEGREE]> {
+    if factorials
+        .get(degree)
+        .copied()
+        .is_none_or(|order| rank >= order)
+    {
+        return Err(invalid("lexicographic permutation rank is out of bounds"));
+    }
+    let mut available = [0_u8; MAX_SYMMETRIC_GROUP_FFT_DEGREE];
+    for (index, value) in available[..degree].iter_mut().enumerate() {
+        *value = u8::try_from(index)
+            .map_err(|_| internal("permutation value exceeds compact storage"))?;
+    }
+    let mut available_count = degree;
+    let mut permutation = [0_u8; MAX_SYMMETRIC_GROUP_FFT_DEGREE];
+    for (position, value) in permutation[..degree].iter_mut().enumerate() {
+        let block = factorials[degree - position - 1];
+        let choice = rank / block;
+        rank %= block;
+        if choice >= available_count {
+            return Err(internal("lexicographic unrank selected an invalid digit"));
+        }
+        *value = available[choice];
+        available.copy_within(choice + 1..available_count, choice);
+        available_count -= 1;
+    }
+    Ok(permutation)
+}
+
+fn validate_reorder_map(values: &[u32], order: usize) -> RusticolResult<()> {
+    if values.len() != order {
+        return Err(internal("permutation reorder map has the wrong length"));
+    }
+    let mut seen = Vec::new();
+    seen.try_reserve_exact(order)
+        .map_err(|error| invalid(format!("reorder validation allocation failed: {error}")))?;
+    seen.resize(order, false);
+    for value in values.iter().copied() {
+        let index = usize::try_from(value)
+            .map_err(|_| internal("permutation reorder index exceeds usize"))?;
+        if index >= order || std::mem::replace(&mut seen[index], true) {
+            return Err(internal("permutation reorder map is not bijective"));
+        }
+    }
+    Ok(())
+}
+
+fn zeroed_complex_values(
+    count: usize,
+    label: &str,
+) -> RusticolResult<Vec<SymmetricGroupComplex64>> {
+    let mut values = Vec::new();
+    values
+        .try_reserve_exact(count)
+        .map_err(|error| invalid(format!("{label} allocation failed: {error}")))?;
+    values.resize(count, (0.0, 0.0));
+    Ok(values)
+}
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+fn internal(message: impl Into<String>) -> RusticolError {
+    RusticolError::internal(message)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const TOLERANCE: f64 = 2.0e-11;
+
+    #[test]
+    fn known_young_layouts_and_dimensions() {
+        let plan = SymmetricGroupFftPlan::new(4).unwrap();
+        let blocks = plan
+            .blocks()
+            .map(|block| (block.shape().to_vec(), block.dimension()))
+            .collect::<Vec<_>>();
+        assert_eq!(
+            blocks,
+            vec![
+                (vec![4], 1),
+                (vec![3, 1], 3),
+                (vec![2, 2], 2),
+                (vec![2, 1, 1], 3),
+                (vec![1, 1, 1, 1], 1),
+            ]
+        );
+        assert_eq!(
+            plan.blocks()
+                .map(|block| block.coefficient_count())
+                .sum::<usize>(),
+            24
+        );
+    }
+
+    #[test]
+    fn transform_matches_direct_definition_through_six() {
+        for degree in 0..=6 {
+            let plan = SymmetricGroupFftPlan::new(degree).unwrap();
+            let values = deterministic_values(plan.order(), 0);
+            let mut fast = vec![(0.0, 0.0); plan.order()];
+            let mut workspace = plan.workspace(1).unwrap();
+            plan.forward(&values, &mut fast, &mut workspace).unwrap();
+            let direct = direct_transform(&plan, &values);
+            assert_complex_slices_close(&fast, &direct, TOLERANCE);
+        }
+    }
+
+    #[test]
+    fn inverse_kernel_blocks_match_direct_quadratic_form() {
+        let plan = SymmetricGroupFftPlan::new(4).unwrap();
+        let left = deterministic_values(plan.order(), 2);
+        let right = deterministic_values(plan.order(), 11);
+        // Deliberately not inversion-symmetric: this catches a silently
+        // reversed raw-kernel convention that a diagonal colour kernel cannot.
+        let kernel = deterministic_values(plan.order(), 23);
+        let inverse_kernel = (0..plan.order())
+            .map(|index| kernel[plan.inverse_lexicographic_index(index).unwrap()])
+            .collect::<Vec<_>>();
+
+        let mut workspace = plan.workspace(1).unwrap();
+        let mut left_fourier = vec![(0.0, 0.0); plan.order()];
+        let mut right_fourier = vec![(0.0, 0.0); plan.order()];
+        let mut kernel_fourier = vec![(0.0, 0.0); plan.order()];
+        plan.forward(&left, &mut left_fourier, &mut workspace)
+            .unwrap();
+        plan.forward(&right, &mut right_fourier, &mut workspace)
+            .unwrap();
+        plan.forward(&inverse_kernel, &mut kernel_fourier, &mut workspace)
+            .unwrap();
+
+        let direct = direct_relative_kernel_form(&plan, &left, &right, &kernel);
+        let blocked =
+            fourier_relative_kernel_form(&plan, &left_fourier, &right_fourier, &kernel_fourier);
+        let scale = complex_norm(direct).max(1.0);
+        assert!(
+            complex_norm((blocked.0 - direct.0, blocked.1 - direct.1)) <= 5.0e-11 * scale,
+            "inverse-kernel block form {blocked:?} != direct form {direct:?}"
+        );
+    }
+
+    #[test]
+    fn identity_impulse_transforms_to_irrep_identities() {
+        for degree in 0..=7 {
+            let plan = SymmetricGroupFftPlan::new(degree).unwrap();
+            let mut values = vec![(0.0, 0.0); plan.order()];
+            values[0] = (1.0, 0.0);
+            let mut transformed = vec![(0.0, 0.0); plan.order()];
+            let mut workspace = plan.workspace(1).unwrap();
+            plan.forward(&values, &mut transformed, &mut workspace)
+                .unwrap();
+            for block in plan.blocks() {
+                for column in 0..block.dimension() {
+                    for row in 0..block.dimension() {
+                        let value = transformed
+                            [block.coefficient_offset() + column * block.dimension() + row];
+                        let expected = if row == column { 1.0 } else { 0.0 };
+                        assert!((value.0 - expected).abs() <= TOLERANCE);
+                        assert!(value.1.abs() <= TOLERANCE);
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn young_generators_obey_coxeter_relations() {
+        for degree in 2..=7 {
+            let plan = SymmetricGroupFftPlan::new(degree).unwrap();
+            let level = &plan.levels[degree];
+            for irrep in &level.irreps {
+                let identity = dense_identity(irrep.dimension);
+                let generators = (0..degree - 1)
+                    .map(|generator| dense_generator(irrep, generator))
+                    .collect::<Vec<_>>();
+                for generator in &generators {
+                    assert_real_matrices_close(
+                        &dense_multiply(generator, generator, irrep.dimension),
+                        &identity,
+                        TOLERANCE,
+                    );
+                }
+                for generator in 0..degree - 2 {
+                    let left = dense_multiply(
+                        &dense_multiply(
+                            &generators[generator],
+                            &generators[generator + 1],
+                            irrep.dimension,
+                        ),
+                        &generators[generator],
+                        irrep.dimension,
+                    );
+                    let right = dense_multiply(
+                        &dense_multiply(
+                            &generators[generator + 1],
+                            &generators[generator],
+                            irrep.dimension,
+                        ),
+                        &generators[generator + 1],
+                        irrep.dimension,
+                    );
+                    assert_real_matrices_close(&left, &right, TOLERANCE);
+                }
+                for first in 0..degree - 1 {
+                    for second in first + 2..degree - 1 {
+                        let left = dense_multiply(
+                            &generators[first],
+                            &generators[second],
+                            irrep.dimension,
+                        );
+                        let right = dense_multiply(
+                            &generators[second],
+                            &generators[first],
+                            irrep.dimension,
+                        );
+                        assert_real_matrices_close(&left, &right, TOLERANCE);
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn parseval_identity_holds_through_s_eight() {
+        for degree in 0..=8 {
+            let plan = SymmetricGroupFftPlan::new(degree).unwrap();
+            let values = deterministic_values(plan.order(), degree);
+            let mut transformed = vec![(0.0, 0.0); plan.order()];
+            let mut workspace = plan.workspace(1).unwrap();
+            plan.forward(&values, &mut transformed, &mut workspace)
+                .unwrap();
+            let input_norm = values
+                .iter()
+                .map(|value| value.0 * value.0 + value.1 * value.1)
+                .sum::<f64>();
+            let fourier_norm = plan
+                .blocks()
+                .map(|block| {
+                    let start = block.coefficient_offset();
+                    let end = start + block.coefficient_count();
+                    block.dimension() as f64
+                        * transformed[start..end]
+                            .iter()
+                            .map(|value| value.0 * value.0 + value.1 * value.1)
+                            .sum::<f64>()
+                })
+                .sum::<f64>()
+                / plan.order() as f64;
+            let scale = input_norm.abs().max(1.0);
+            assert!((fourier_norm - input_norm).abs() <= 5.0e-11 * scale);
+        }
+    }
+
+    #[test]
+    fn workspace_reuse_does_not_retain_transform_state() {
+        let plan = SymmetricGroupFftPlan::new(7).unwrap();
+        let first = deterministic_values(plan.order(), 3);
+        let second = deterministic_values(plan.order(), 19);
+        let mut workspace = plan.workspace(1).unwrap();
+        let mut discarded = vec![(0.0, 0.0); plan.order()];
+        let mut reused = vec![(0.0, 0.0); plan.order()];
+        plan.forward(&first, &mut discarded, &mut workspace)
+            .unwrap();
+        plan.forward(&second, &mut reused, &mut workspace).unwrap();
+        let mut fresh = vec![(0.0, 0.0); plan.order()];
+        let mut fresh_workspace = plan.workspace(1).unwrap();
+        plan.forward(&second, &mut fresh, &mut fresh_workspace)
+            .unwrap();
+        assert_complex_slices_close(&reused, &fresh, TOLERANCE);
+    }
+
+    #[test]
+    fn batched_lanes_match_independent_transforms() {
+        let plan = SymmetricGroupFftPlan::new(6).unwrap();
+        let lanes = 3;
+        let lane_values = (0..lanes)
+            .map(|lane| deterministic_values(plan.order(), lane * 7))
+            .collect::<Vec<_>>();
+        let mut values = vec![(0.0, 0.0); plan.order() * lanes];
+        for group_element in 0..plan.order() {
+            for lane in 0..lanes {
+                values[group_element * lanes + lane] = lane_values[lane][group_element];
+            }
+        }
+        let mut batched = vec![(0.0, 0.0); values.len()];
+        let mut workspace = plan.workspace(lanes).unwrap();
+        plan.forward_lanes(lanes, &values, &mut batched, &mut workspace)
+            .unwrap();
+        for lane in 0..lanes {
+            let mut expected = vec![(0.0, 0.0); plan.order()];
+            let mut scalar_workspace = plan.workspace(1).unwrap();
+            plan.forward(&lane_values[lane], &mut expected, &mut scalar_workspace)
+                .unwrap();
+            let actual = (0..plan.order())
+                .map(|coefficient| batched[coefficient * lanes + lane])
+                .collect::<Vec<_>>();
+            assert_complex_slices_close(&actual, &expected, TOLERANCE);
+        }
+    }
+
+    #[test]
+    fn scalar_transposed_path_matches_batched_path_through_s_seven() {
+        for degree in 0..=7 {
+            let plan = SymmetricGroupFftPlan::new(degree).unwrap();
+            let scalar_values = deterministic_values(plan.order(), degree * 13 + 5);
+            let other_values = deterministic_values(plan.order(), degree * 17 + 9);
+            let mut scalar = vec![(0.0, 0.0); plan.order()];
+            let mut scalar_workspace = plan.workspace(1).unwrap();
+            plan.forward(&scalar_values, &mut scalar, &mut scalar_workspace)
+                .unwrap();
+
+            let mut batched_values = vec![(0.0, 0.0); plan.order() * 2];
+            for group in 0..plan.order() {
+                batched_values[group * 2] = scalar_values[group];
+                batched_values[group * 2 + 1] = other_values[group];
+            }
+            let mut batched = vec![(0.0, 0.0); batched_values.len()];
+            let mut batched_workspace = plan.workspace(2).unwrap();
+            plan.forward_lanes(2, &batched_values, &mut batched, &mut batched_workspace)
+                .unwrap();
+            let first_lane = batched
+                .chunks_exact(2)
+                .map(|lanes| lanes[0])
+                .collect::<Vec<_>>();
+            assert_complex_slices_close(&scalar, &first_lane, TOLERANCE);
+        }
+    }
+
+    #[test]
+    fn capacity_workspace_reuses_active_prefix_without_state_leakage() {
+        let plan = SymmetricGroupFftPlan::new(5).unwrap();
+        let lane_capacity = 4;
+        let mut workspace = plan.workspace(lane_capacity).unwrap();
+        let buffer_address = workspace.buffer.as_ptr();
+        let block_address = workspace.block.as_ptr();
+
+        assert_eq!(workspace.lane_capacity(), lane_capacity);
+        for active_lanes in 1..=lane_capacity {
+            let lane_values = (0..active_lanes)
+                .map(|lane| deterministic_values(plan.order(), active_lanes * 11 + lane * 7))
+                .collect::<Vec<_>>();
+            let mut values = vec![(0.0, 0.0); plan.order() * active_lanes];
+            for group_element in 0..plan.order() {
+                for lane in 0..active_lanes {
+                    values[group_element * active_lanes + lane] = lane_values[lane][group_element];
+                }
+            }
+
+            let mut transformed = vec![(f64::NAN, f64::NAN); values.len()];
+            plan.forward_lanes(active_lanes, &values, &mut transformed, &mut workspace)
+                .unwrap();
+
+            for lane in 0..active_lanes {
+                let mut expected = vec![(0.0, 0.0); plan.order()];
+                let mut scalar_workspace = plan.workspace(1).unwrap();
+                plan.forward(&lane_values[lane], &mut expected, &mut scalar_workspace)
+                    .unwrap();
+                let actual = (0..plan.order())
+                    .map(|coefficient| transformed[coefficient * active_lanes + lane])
+                    .collect::<Vec<_>>();
+                assert_complex_slices_close(&actual, &expected, TOLERANCE);
+            }
+
+            assert_eq!(workspace.buffer.as_ptr(), buffer_address);
+            assert_eq!(workspace.block.as_ptr(), block_address);
+            assert_eq!(workspace.lane_capacity(), lane_capacity);
+        }
+
+        let values = vec![(0.0, 0.0); plan.order() * (lane_capacity + 1)];
+        let mut coefficients = values.clone();
+        assert!(
+            plan.forward_lanes(
+                lane_capacity + 1,
+                &values,
+                &mut coefficients,
+                &mut workspace,
+            )
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn reorder_map_is_a_lexicographic_bijection() {
+        for degree in 0..=8 {
+            let plan = SymmetricGroupFftPlan::new(degree).unwrap();
+            let mut values = plan.recursive_to_lexicographic().to_vec();
+            values.sort_unstable();
+            assert_eq!(
+                values,
+                (0..plan.order() as u32).collect::<Vec<_>>(),
+                "degree {degree}"
+            );
+            for index in 0..plan.order() {
+                let inverse = plan.inverse_lexicographic_index(index).unwrap();
+                assert_eq!(
+                    plan.inverse_lexicographic_index(inverse).unwrap(),
+                    index,
+                    "inverse-index involution failed at degree {degree}, index {index}"
+                );
+            }
+            assert!(plan.inverse_lexicographic_index(plan.order()).is_err());
+        }
+    }
+
+    #[test]
+    fn degree_ten_is_supported_and_larger_degrees_are_rejected() {
+        let plan = SymmetricGroupFftPlan::new(10).unwrap();
+        assert_eq!(plan.order(), 3_628_800);
+        assert_eq!(plan.recursive_to_lexicographic().len(), plan.order());
+        assert_eq!(
+            plan.blocks()
+                .map(|block| block.coefficient_count())
+                .sum::<usize>(),
+            plan.order()
+        );
+        assert!(SymmetricGroupFftPlan::new(11).is_err());
+    }
+
+    fn deterministic_values(count: usize, salt: usize) -> Vec<SymmetricGroupComplex64> {
+        (0..count)
+            .map(|index| {
+                let value = (index + salt + 1) as f64;
+                (
+                    ((value * 0.173).sin() + (value * 0.037).cos()) / (value + 1.0).sqrt(),
+                    ((value * 0.113).cos() - (value * 0.071).sin()) / (value + 2.0).sqrt(),
+                )
+            })
+            .collect()
+    }
+
+    fn direct_transform(
+        plan: &SymmetricGroupFftPlan,
+        values: &[SymmetricGroupComplex64],
+    ) -> Vec<SymmetricGroupComplex64> {
+        let mut result = vec![(0.0, 0.0); plan.order()];
+        for (rank, value) in values.iter().copied().enumerate() {
+            let permutation = lexicographic_unrank(plan.degree(), rank);
+            for (block_index, block) in plan.blocks().enumerate() {
+                let representation = representation_matrix(plan, block_index, &permutation);
+                for (offset, coefficient) in representation.into_iter().enumerate() {
+                    result[block.coefficient_offset() + offset].0 += value.0 * coefficient;
+                    result[block.coefficient_offset() + offset].1 += value.1 * coefficient;
+                }
+            }
+        }
+        result
+    }
+
+    fn direct_relative_kernel_form(
+        plan: &SymmetricGroupFftPlan,
+        left: &[SymmetricGroupComplex64],
+        right: &[SymmetricGroupComplex64],
+        kernel: &[SymmetricGroupComplex64],
+    ) -> SymmetricGroupComplex64 {
+        let permutations = (0..plan.order())
+            .map(|index| lexicographic_unrank(plan.degree(), index))
+            .collect::<Vec<_>>();
+        let mut result = (0.0, 0.0);
+        for (left_index, left_value) in left.iter().copied().enumerate() {
+            let mut inverse_left = vec![0_usize; plan.degree()];
+            for (position, value) in permutations[left_index].iter().copied().enumerate() {
+                inverse_left[value] = position;
+            }
+            for (right_index, right_value) in right.iter().copied().enumerate() {
+                let relative = permutations[right_index]
+                    .iter()
+                    .map(|value| inverse_left[*value])
+                    .collect::<Vec<_>>();
+                let relative_index = permutation_rank(&relative);
+                let bilinear = complex_multiply(
+                    complex_multiply((left_value.0, -left_value.1), right_value),
+                    kernel[relative_index],
+                );
+                result.0 += bilinear.0;
+                result.1 += bilinear.1;
+            }
+        }
+        result
+    }
+
+    fn fourier_relative_kernel_form(
+        plan: &SymmetricGroupFftPlan,
+        left: &[SymmetricGroupComplex64],
+        right: &[SymmetricGroupComplex64],
+        kernel: &[SymmetricGroupComplex64],
+    ) -> SymmetricGroupComplex64 {
+        let mut result = (0.0, 0.0);
+        for block in plan.blocks() {
+            let dimension = block.dimension();
+            let offset = block.coefficient_offset();
+            let mut product = vec![(0.0, 0.0); dimension * dimension];
+            for column in 0..dimension {
+                for inner in 0..dimension {
+                    let kernel_value = kernel[offset + column * dimension + inner];
+                    for row in 0..dimension {
+                        let value =
+                            complex_multiply(right[offset + inner * dimension + row], kernel_value);
+                        let target = &mut product[column * dimension + row];
+                        target.0 += value.0;
+                        target.1 += value.1;
+                    }
+                }
+            }
+            let mut trace = (0.0, 0.0);
+            for (index, right_kernel) in product.into_iter().enumerate() {
+                let left_value = left[offset + index];
+                let value = complex_multiply((left_value.0, -left_value.1), right_kernel);
+                trace.0 += value.0;
+                trace.1 += value.1;
+            }
+            let weight = dimension as f64 / plan.order() as f64;
+            result.0 += weight * trace.0;
+            result.1 += weight * trace.1;
+        }
+        result
+    }
+
+    fn permutation_rank(permutation: &[usize]) -> usize {
+        let factorials = checked_factorials(permutation.len()).unwrap();
+        permutation
+            .iter()
+            .enumerate()
+            .map(|(position, value)| {
+                let smaller = permutation[position + 1..]
+                    .iter()
+                    .filter(|other| *other < value)
+                    .count();
+                smaller * factorials[permutation.len() - position - 1]
+            })
+            .sum()
+    }
+
+    fn complex_multiply(
+        left: SymmetricGroupComplex64,
+        right: SymmetricGroupComplex64,
+    ) -> SymmetricGroupComplex64 {
+        (
+            left.0 * right.0 - left.1 * right.1,
+            left.0 * right.1 + left.1 * right.0,
+        )
+    }
+
+    fn complex_norm(value: SymmetricGroupComplex64) -> f64 {
+        value.0.hypot(value.1)
+    }
+
+    fn representation_matrix(
+        plan: &SymmetricGroupFftPlan,
+        block_index: usize,
+        permutation: &[usize],
+    ) -> Vec<f64> {
+        let irrep = &plan.levels[plan.degree()].irreps[block_index];
+        let mut current = (0..plan.degree()).collect::<Vec<_>>();
+        let mut matrix = dense_identity(irrep.dimension);
+        for position in 0..plan.degree() {
+            let mut source = current[position..]
+                .iter()
+                .position(|value| *value == permutation[position])
+                .unwrap()
+                + position;
+            while source > position {
+                let generator = source - 1;
+                current.swap(generator, generator + 1);
+                apply_dense_generator_on_right(irrep, generator, &mut matrix);
+                source -= 1;
+            }
+        }
+        assert_eq!(current, permutation);
+        matrix
+    }
+
+    fn lexicographic_unrank(degree: usize, mut rank: usize) -> Vec<usize> {
+        let factorials = checked_factorials(degree).unwrap();
+        let mut available = (0..degree).collect::<Vec<_>>();
+        let mut permutation = Vec::with_capacity(degree);
+        for position in 0..degree {
+            let block = factorials[degree - position - 1];
+            let choice = rank / block;
+            rank %= block;
+            permutation.push(available.remove(choice));
+        }
+        permutation
+    }
+
+    fn dense_generator(irrep: &YoungIrrep, generator: usize) -> Vec<f64> {
+        let mut matrix = vec![0.0; irrep.dimension * irrep.dimension];
+        for column in 0..irrep.dimension {
+            let action = irrep.generator(generator, column);
+            matrix[column * irrep.dimension + column] = action.diagonal;
+            if action.partner as usize != column {
+                matrix[column * irrep.dimension + action.partner as usize] = action.mixing;
+            }
+        }
+        matrix
+    }
+
+    fn dense_identity(dimension: usize) -> Vec<f64> {
+        let mut matrix = vec![0.0; dimension * dimension];
+        for index in 0..dimension {
+            matrix[index * dimension + index] = 1.0;
+        }
+        matrix
+    }
+
+    fn apply_dense_generator_on_right(irrep: &YoungIrrep, generator: usize, matrix: &mut [f64]) {
+        for first in 0..irrep.dimension {
+            let first_action = irrep.generator(generator, first);
+            let other = first_action.partner as usize;
+            if other < first {
+                continue;
+            }
+            if other == first {
+                for row in 0..irrep.dimension {
+                    matrix[first * irrep.dimension + row] *= first_action.diagonal;
+                }
+                continue;
+            }
+            let other_action = irrep.generator(generator, other);
+            for row in 0..irrep.dimension {
+                let first_index = first * irrep.dimension + row;
+                let other_index = other * irrep.dimension + row;
+                let first_value = matrix[first_index];
+                let other_value = matrix[other_index];
+                matrix[first_index] =
+                    first_action.diagonal * first_value + first_action.mixing * other_value;
+                matrix[other_index] =
+                    other_action.mixing * first_value + other_action.diagonal * other_value;
+            }
+        }
+    }
+
+    fn dense_multiply(first: &[f64], second: &[f64], dimension: usize) -> Vec<f64> {
+        let mut product = vec![0.0; dimension * dimension];
+        for column in 0..dimension {
+            for inner in 0..dimension {
+                let second_value = second[column * dimension + inner];
+                for row in 0..dimension {
+                    product[column * dimension + row] +=
+                        first[inner * dimension + row] * second_value;
+                }
+            }
+        }
+        product
+    }
+
+    fn assert_complex_slices_close(
+        actual: &[SymmetricGroupComplex64],
+        expected: &[SymmetricGroupComplex64],
+        tolerance: f64,
+    ) {
+        assert_eq!(actual.len(), expected.len());
+        let scale = expected
+            .iter()
+            .map(|value| value.0.abs().max(value.1.abs()))
+            .fold(1.0_f64, f64::max);
+        for (index, (actual, expected)) in actual.iter().zip(expected).enumerate() {
+            assert!(
+                (actual.0 - expected.0).abs() <= tolerance * scale
+                    && (actual.1 - expected.1).abs() <= tolerance * scale,
+                "complex mismatch at {index}: {actual:?} != {expected:?}, scale {scale}"
+            );
+        }
+    }
+
+    fn assert_real_matrices_close(actual: &[f64], expected: &[f64], tolerance: f64) {
+        assert_eq!(actual.len(), expected.len());
+        let scale = expected.iter().copied().map(f64::abs).fold(1.0, f64::max);
+        for (index, (actual, expected)) in actual.iter().zip(expected).enumerate() {
+            assert!(
+                (actual - expected).abs() <= tolerance * scale,
+                "matrix mismatch at {index}: {actual} != {expected}"
+            );
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/template.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/template.rs
new file mode 100644
index 0000000000..dedc07713a
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/template.rs
@@ -0,0 +1,4443 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Checked model-wide input for the compact recurrence builder.
+//!
+//! The Python producer projects a semantic recurrence-template catalog into
+//! fixed-width primitive columns.  A Python decoder can zip those columns
+//! directly into the row types below, construct [`OwnedRecurrenceTemplateInput`],
+//! and call [`OwnedRecurrenceTemplateInput::validate`].  Validation resolves no
+//! model-specific assumptions: it checks canonical catalogs, exact factors,
+//! references, evaluator contracts, and propagator coverage before the state
+//! builder is allowed to consume the input.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use super::{
+    CheckedTableRange, ExactComplexRational, LCColorComponentKind, LCColorComponentRole,
+    LCColorSourceSeed, LCColorSourceSeedOperation, RECURRENCE_TEMPLATE_ABI, SemanticDigest,
+    validate_concrete_spin_state, validate_packed_ranges, validate_u32_references,
+};
+use crate::{RusticolError, RusticolResult};
+
+pub const RECURRENCE_TEMPLATE_INPUT_ABI: &str = "pyamplicol-recurrence-template-input-v1";
+pub const RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION: u32 = 2;
+pub const RECURRENCE_TEMPLATE_CANONICALIZATION_ABI: &str = "pyamplicol-canonical-json-v1";
+pub const RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI: &str = "pyamplicol-exact-complex-rational-v1";
+pub const MISSING_U32: u32 = u32::MAX;
+const CONTACT_ORBIT_ALGORITHM: &str = "compiler-certified-contact-orbit";
+const CONTACT_ORBIT_ALGORITHM_VERSION: u32 = 2;
+const CONTACT_ORBIT_EVALUATOR_CLASS: &str = "constant-scalar-literal-singlet-self-conjugate-boson";
+const HEFT_CONTACT_ORBIT_EVALUATOR_CLASS: &str = "scalar-heft-colored-contact-tree";
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum ParameterKind {
+    External = 0,
+    Derived = 1,
+    Constant = 2,
+}
+
+impl TryFrom<u8> for ParameterKind {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::External),
+            1 => Ok(Self::Derived),
+            2 => Ok(Self::Constant),
+            _ => Err(invalid(format!("unsupported parameter kind {value}"))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum ParameterValueType {
+    Real = 0,
+    Complex = 1,
+}
+
+impl TryFrom<u8> for ParameterValueType {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Real),
+            1 => Ok(Self::Complex),
+            _ => Err(invalid(format!("unsupported parameter value type {value}"))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum CurrentOrientation {
+    Particle = 0,
+    Antiparticle = 1,
+    SelfConjugate = 2,
+}
+
+impl TryFrom<u8> for CurrentOrientation {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Particle),
+            1 => Ok(Self::Antiparticle),
+            2 => Ok(Self::SelfConjugate),
+            _ => Err(invalid(format!("unsupported current orientation {value}"))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum ParticleStatistics {
+    Boson = 0,
+    Fermion = 1,
+}
+
+impl TryFrom<u8> for ParticleStatistics {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Boson),
+            1 => Ok(Self::Fermion),
+            _ => Err(invalid(format!("unsupported particle statistics {value}"))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub enum EvaluatorContractKind {
+    Source = 0,
+    Vertex = 1,
+    Propagator = 2,
+    Closure = 3,
+    ModelParameter = 4,
+}
+
+impl TryFrom<u8> for EvaluatorContractKind {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Source),
+            1 => Ok(Self::Vertex),
+            2 => Ok(Self::Propagator),
+            3 => Ok(Self::Closure),
+            4 => Ok(Self::ModelParameter),
+            _ => Err(invalid(format!(
+                "unsupported evaluator contract kind {value}"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum EvaluatorCallableKind {
+    PreparedKernel = 0,
+    RusticolTemplate = 1,
+}
+
+impl TryFrom<u8> for EvaluatorCallableKind {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::PreparedKernel),
+            1 => Ok(Self::RusticolTemplate),
+            _ => Err(invalid(format!(
+                "unsupported evaluator callable kind {value}"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum OutputFactorSource {
+    None = 0,
+    CouplingReal = 1,
+    CouplingImag = 2,
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub enum ContactOrbitStage {
+    Partial = 0,
+    Final = 1,
+}
+
+impl TryFrom<u8> for ContactOrbitStage {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Partial),
+            1 => Ok(Self::Final),
+            _ => Err(invalid(format!("unsupported contact-orbit stage {value}"))),
+        }
+    }
+}
+
+impl TryFrom<u8> for OutputFactorSource {
+    type Error = RusticolError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::None),
+            1 => Ok(Self::CouplingReal),
+            2 => Ok(Self::CouplingImag),
+            _ => Err(invalid(format!("unsupported output-factor source {value}"))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct IndexedRangeRow {
+    pub id: u32,
+    pub range: CheckedTableRange,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct CatalogHeaderRow {
+    pub schema_version: u32,
+    pub abi_string_id: u32,
+    pub canonicalization_abi_string_id: u32,
+    pub exact_scalar_abi_string_id: u32,
+    pub compiled_model_digest_id: u32,
+    pub prepared_kernel_pack_digest_id: u32,
+    pub catalog_digest_id: u32,
+    pub parameter_count: u32,
+    pub current_state_count: u32,
+    pub source_count: u32,
+    pub quantum_flow_count: u32,
+    pub contact_orbit_certificate_count: u32,
+    pub contact_orbit_step_count: u32,
+    pub transition_count: u32,
+    pub propagator_count: u32,
+    pub closure_count: u32,
+    pub color_contraction_count: u32,
+    pub symmetry_proof_count: u32,
+    pub runtime_helicity_contract_count: u32,
+    pub evaluator_binding_count: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct CouplingOrderTermRow {
+    pub set_id: u32,
+    pub name_string_id: u32,
+    pub power: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct DigestCatalogRow {
+    pub id: u32,
+    pub value: [u8; 32],
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ExactFactorRow {
+    pub id: u32,
+    pub real_numerator_string_id: u32,
+    pub real_denominator_string_id: u32,
+    pub imag_numerator_string_id: u32,
+    pub imag_denominator_string_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct QuantumNumberFlowTermRow {
+    pub flow_id: u32,
+    pub name_string_id: u32,
+    pub expression_string_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ParameterRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub name_string_id: u32,
+    pub kind: u8,
+    pub value_type: u8,
+    pub mutable: u8,
+    pub default_factor_id: u32,
+    pub exact_expression_digest_id: u32,
+    pub dependency_sequence_id: u32,
+    pub prepared_parameter_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct CurrentStateRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub particle_id: i32,
+    pub anti_particle_id: i32,
+    pub species_string_id: u32,
+    pub orientation: u8,
+    pub statistics: u8,
+    pub color_representation: i32,
+    pub basis_string_id: u32,
+    pub tensor_ordering_sequence_id: u32,
+    pub dimension: u32,
+    pub chirality: i32,
+    pub lc_color_shape_string_id: u32,
+    pub auxiliary_kind_string_id: u32,
+    pub mass_parameter_id: u32,
+    pub width_parameter_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct SourceRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub state_template_id: u32,
+    pub crossing_string_id: u32,
+    pub wavefunction_family_string_id: u32,
+    pub helicity: i32,
+    pub spin_state: i32,
+    pub flavour_flow_id: u32,
+    pub quantum_number_flow_id: u32,
+    pub lc_color_seed_operation: u8,
+    pub lc_color_seed_shape_string_id: u32,
+    pub lc_color_seed_component_kind: u8,
+    pub lc_color_seed_component_role: u8,
+    pub lc_color_seed_proof_digest_id: u32,
+    pub lc_color_seed_provenance_sequence_id: u32,
+    pub wavefunction_expression_digest_id: u32,
+    pub evaluator_binding_id: u32,
+    pub mass_parameter_id: u32,
+    pub width_parameter_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct RuntimeHelicityContractRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub full_state_template_id: u32,
+    pub variant_range: CheckedTableRange,
+    pub proof_algorithm_string_id: u32,
+    pub proof_digest_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct RuntimeHelicityVariantRow {
+    pub id: u32,
+    pub contract_id: u32,
+    pub source_template_id: u32,
+    pub source_state_template_id: u32,
+    pub embedding_range: CheckedTableRange,
+    pub projection_range: CheckedTableRange,
+    pub proof_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct RuntimeHelicityEmbeddingRow {
+    pub variant_id: u32,
+    pub full_component: u32,
+    pub source_component: u32,
+    pub factor_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct RuntimeHelicityProjectionRow {
+    pub variant_id: u32,
+    pub source_component: u32,
+    pub full_component: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct QuantumFlowRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub input_state_sequence_id: u32,
+    pub input_spin_sequence_id: u32,
+    pub input_flavour_sequence_id: u32,
+    pub input_quantum_sequence_id: u32,
+    pub flavour_flow_operation_string_id: u32,
+    pub quantum_number_flow_operation_string_id: u32,
+    pub coupling_order_set_id: u32,
+    pub result_state_template_id: u32,
+    pub result_spin_state: i32,
+    pub result_flavour_flow_id: u32,
+    pub result_quantum_number_flow_id: u32,
+    pub exact_coupling_factor_id: u32,
+    pub predicate_digest_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ContactOrbitCertificateRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub algorithm_string_id: u32,
+    pub algorithm_version: u32,
+    pub term_id: u32,
+    pub vertex_string_id: u32,
+    pub particle_string_sequence_id: u32,
+    pub evaluator_class_string_id: u32,
+    pub physical_leg_equivalence_sequence_id: u32,
+    pub reconstruction_factor_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ContactOrbitStepRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub certificate_id: u32,
+    pub stage: u8,
+    pub result_leg: u8,
+    pub left_covered_leg_sequence_id: u32,
+    pub right_covered_leg_sequence_id: u32,
+    pub source_particle_leg_sequence_id: u32,
+    pub reconstruction_factor_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct TransitionRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub input_state_sequence_id: u32,
+    pub result_state_template_id: u32,
+    pub quantum_flow_template_id: u32,
+    pub evaluator_binding_id: u32,
+    pub canonical_input_order_sequence_id: u32,
+    pub momentum_convention_sequence_id: u32,
+    pub coupling_parameter_sequence_id: u32,
+    pub coupling_order_set_id: u32,
+    pub color_contraction_template_id: u32,
+    pub binding_coupling_factor_id: u32,
+    pub exact_factor_id: u32,
+    pub output_factor_source: u8,
+    pub equivalence_class_string_id: u32,
+    pub input_exchange_factor_id: u32,
+    pub output_projection_string_id: u32,
+    pub contact_orbit_step_sequence_id: u32,
+    pub contact_orbit_step_semantic_digest_sequence_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct PropagatorRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub state_template_id: u32,
+    pub applies_propagator: u8,
+    pub evaluator_binding_id: u32,
+    pub numerator_expression_digest_id: u32,
+    pub denominator_expression_digest_id: u32,
+    pub mass_parameter_id: u32,
+    pub width_parameter_id: u32,
+    pub gauge_string_id: u32,
+    pub linearity_proof_template_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ClosureRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub input_state_sequence_id: u32,
+    pub result_state_template_id: u32,
+    pub evaluator_binding_id: u32,
+    pub canonical_input_order_sequence_id: u32,
+    pub coupling_parameter_sequence_id: u32,
+    pub coupling_order_set_id: u32,
+    pub eligible_quantum_flow_sequence_id: u32,
+    pub color_contraction_template_id: u32,
+    pub binding_coupling_factor_id: u32,
+    pub exact_factor_id: u32,
+    pub output_factor_source: u8,
+    pub equivalence_class_string_id: u32,
+    pub input_exchange_factor_id: u32,
+    pub projection_string_id: u32,
+    pub component_coefficient_sequence_id: u32,
+    pub chirality_relation_string_id: u32,
+    pub metric_signature_string_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ColorContractionRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub rule_kind_string_id: u32,
+    pub input_representation_sequence_id: u32,
+    pub has_output_representation: u8,
+    pub output_representation: i32,
+    pub ordered_open_string_arity: u32,
+    pub exact_coefficient_factor_id: u32,
+    pub witness_start: u64,
+    pub witness_count: u64,
+    pub nc_term_start: u64,
+    pub nc_term_count: u64,
+    pub expression_digest_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct LCColorTransitionWitnessRow {
+    pub color_contraction_id: u32,
+    pub ordinal: u32,
+    pub left_shape_string_id: u32,
+    pub right_shape_string_id: u32,
+    pub input_permutation: u8,
+    pub reverse_parent_mask: u8,
+    pub component_operation: u8,
+    pub result_component_kind: u8,
+    pub result_component_role: u8,
+    pub result_shape_string_id: u32,
+    pub exact_factor_id: u32,
+    pub proof_digest_id: u32,
+    pub input_port_pairing_sequence_id: u32,
+    pub result_port_binding_sequence_id: u32,
+    pub provenance_sequence_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ColorNcTermRow {
+    pub color_contraction_id: u32,
+    pub exponent: i32,
+    pub factor_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct SymmetryProofRow {
+    pub id: u32,
+    pub template_string_id: u32,
+    pub proof_algorithm_string_id: u32,
+    pub subject_template_sequence_id: u32,
+    pub input_permutation_sequence_id: u32,
+    pub exact_phase_factor_id: u32,
+    pub expression_digest_sequence_id: u32,
+    pub witness_digest_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EvaluatorBindingRow {
+    pub id: u32,
+    pub resolver_key_string_id: u32,
+    pub prepared_kernel_id: u32,
+    pub contract_kind: u8,
+    pub callable_signature_digest_id: u32,
+    pub input_state_sequence_id: u32,
+    pub output_state_template_id: u32,
+    pub input_layout_sequence_id: u32,
+    pub output_layout_sequence_id: u32,
+    pub exact_expression_digest_sequence_id: u32,
+    pub semantic_template_sequence_id: u32,
+    pub callable_kind: u8,
+    pub runtime_template_string_id: u32,
+    pub semantic_digest_id: u32,
+}
+
+macro_rules! define_template_inputs {
+    ($( $field:ident : $item:ty ),+ $(,)?) => {
+        #[derive(Clone, Copy, Debug)]
+        pub struct RecurrenceTemplateInputView<'a> {
+            pub input_abi: &'a str,
+            pub catalog_digest: SemanticDigest,
+            pub compiled_model_digest: SemanticDigest,
+            pub prepared_kernel_pack_digest: SemanticDigest,
+            $(pub $field: &'a [$item],)+
+        }
+
+        #[derive(Clone, Debug)]
+        pub struct OwnedRecurrenceTemplateInput {
+            pub input_abi: String,
+            pub catalog_digest: SemanticDigest,
+            pub compiled_model_digest: SemanticDigest,
+            pub prepared_kernel_pack_digest: SemanticDigest,
+            $(pub $field: Vec<$item>,)+
+        }
+
+        impl OwnedRecurrenceTemplateInput {
+            pub fn as_view(&self) -> RecurrenceTemplateInputView<'_> {
+                RecurrenceTemplateInputView {
+                    input_abi: &self.input_abi,
+                    catalog_digest: self.catalog_digest,
+                    compiled_model_digest: self.compiled_model_digest,
+                    prepared_kernel_pack_digest: self.prepared_kernel_pack_digest,
+                    $($field: &self.$field,)+
+                }
+            }
+
+            pub fn validate(self) -> RusticolResult<ValidatedRecurrenceTemplateInput> {
+                let summary = self.as_view().validate()?;
+                Ok(ValidatedRecurrenceTemplateInput { input: self, summary })
+            }
+        }
+    };
+}
+
+define_template_inputs! {
+    catalog_header: CatalogHeaderRow,
+    coupling_order_ranges: IndexedRangeRow,
+    coupling_order_terms: CouplingOrderTermRow,
+    contact_orbit_certificates: ContactOrbitCertificateRow,
+    contact_orbit_steps: ContactOrbitStepRow,
+    current_states: CurrentStateRow,
+    digest_catalog: DigestCatalogRow,
+    evaluator_bindings: EvaluatorBindingRow,
+    exact_factors: ExactFactorRow,
+    flavour_flow_ranges: IndexedRangeRow,
+    flavour_flow_values: i32,
+    i32_sequence_ranges: IndexedRangeRow,
+    i32_sequence_values: i32,
+    parameters: ParameterRow,
+    propagators: PropagatorRow,
+    quantum_flows: QuantumFlowRow,
+    quantum_number_flow_ranges: IndexedRangeRow,
+    quantum_number_flow_terms: QuantumNumberFlowTermRow,
+    runtime_helicity_contracts: RuntimeHelicityContractRow,
+    runtime_helicity_variants: RuntimeHelicityVariantRow,
+    runtime_helicity_embeddings: RuntimeHelicityEmbeddingRow,
+    runtime_helicity_projections: RuntimeHelicityProjectionRow,
+    sources: SourceRow,
+    string_ranges: CheckedTableRange,
+    string_bytes: u8,
+    symmetry_proofs: SymmetryProofRow,
+    transitions: TransitionRow,
+    closures: ClosureRow,
+    color_contractions: ColorContractionRow,
+    lc_color_transition_witnesses: LCColorTransitionWitnessRow,
+    color_nc_terms: ColorNcTermRow,
+    u32_sequence_ranges: IndexedRangeRow,
+    u32_sequence_values: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct RecurrenceTemplateValidationSummary {
+    pub catalog_digest: SemanticDigest,
+    pub compiled_model_digest: SemanticDigest,
+    pub prepared_kernel_pack_digest: SemanticDigest,
+    pub parameter_count: u32,
+    pub current_state_count: u32,
+    pub source_count: u32,
+    pub quantum_flow_count: u32,
+    pub contact_orbit_certificate_count: u32,
+    pub contact_orbit_step_count: u32,
+    pub transition_count: u32,
+    pub propagator_count: u32,
+    pub closure_count: u32,
+    pub color_contraction_count: u32,
+    pub lc_color_transition_witness_count: u32,
+    pub symmetry_proof_count: u32,
+    pub runtime_helicity_contract_count: u32,
+    pub evaluator_binding_count: u32,
+    pub prepared_kernel_count: u32,
+}
+
+#[derive(Clone, Debug)]
+pub struct ValidatedRecurrenceTemplateInput {
+    input: OwnedRecurrenceTemplateInput,
+    summary: RecurrenceTemplateValidationSummary,
+}
+
+/// Stable semantic section names used by process/template cross-authentication.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum RecurrenceSemanticTemplateKind {
+    Parameter,
+    CurrentState,
+    Source,
+    QuantumFlow,
+    ContactOrbitCertificate,
+    ContactOrbitStep,
+    Transition,
+    Propagator,
+    Closure,
+    ColorContraction,
+    SymmetryProof,
+}
+
+impl RecurrenceSemanticTemplateKind {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Parameter => "parameter",
+            Self::CurrentState => "current-state",
+            Self::Source => "source",
+            Self::QuantumFlow => "quantum-flow",
+            Self::ContactOrbitCertificate => "contact-orbit-certificate",
+            Self::ContactOrbitStep => "contact-orbit-step",
+            Self::Transition => "transition",
+            Self::Propagator => "propagator",
+            Self::Closure => "closure",
+            Self::ColorContraction => "color-contraction",
+            Self::SymmetryProof => "symmetry-proof",
+        }
+    }
+
+    pub fn parse(value: &str) -> RusticolResult<Self> {
+        match value {
+            "parameter" => Ok(Self::Parameter),
+            "current-state" => Ok(Self::CurrentState),
+            "source" => Ok(Self::Source),
+            "quantum-flow" => Ok(Self::QuantumFlow),
+            "contact-orbit-certificate" => Ok(Self::ContactOrbitCertificate),
+            "contact-orbit-step" => Ok(Self::ContactOrbitStep),
+            "transition" => Ok(Self::Transition),
+            "propagator" => Ok(Self::Propagator),
+            "closure" => Ok(Self::Closure),
+            "color-contraction" => Ok(Self::ColorContraction),
+            "symmetry-proof" => Ok(Self::SymmetryProof),
+            _ => Err(invalid(format!(
+                "unsupported recurrence semantic-template kind {value:?}"
+            ))),
+        }
+    }
+}
+
+/// One authenticated model-wide semantic record addressable by process input.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct RecurrenceSemanticTemplateIdentity {
+    pub kind: RecurrenceSemanticTemplateKind,
+    pub template_id: u32,
+    pub semantic_digest: SemanticDigest,
+    pub prepared_kernel_id: Option<u32>,
+}
+
+/// Bounded index used to bind one process input to its prepared model catalog.
+#[derive(Clone, Debug)]
+pub struct RecurrenceTemplateSemanticIndex {
+    pub compiled_model_digest: SemanticDigest,
+    pub catalog_digest: SemanticDigest,
+    records: BTreeMap<(RecurrenceSemanticTemplateKind, u32), RecurrenceSemanticTemplateIdentity>,
+}
+
+impl RecurrenceTemplateSemanticIndex {
+    pub fn record(
+        &self,
+        kind: RecurrenceSemanticTemplateKind,
+        template_id: u32,
+    ) -> Option<RecurrenceSemanticTemplateIdentity> {
+        self.records.get(&(kind, template_id)).copied()
+    }
+
+    pub fn len(&self) -> usize {
+        self.records.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.records.is_empty()
+    }
+}
+
+impl ValidatedRecurrenceTemplateInput {
+    pub const fn summary(&self) -> RecurrenceTemplateValidationSummary {
+        self.summary
+    }
+
+    pub const fn input(&self) -> &OwnedRecurrenceTemplateInput {
+        &self.input
+    }
+
+    pub fn into_input(self) -> OwnedRecurrenceTemplateInput {
+        self.input
+    }
+
+    /// Return the authenticated kind/default contract for every parameter.
+    ///
+    /// Numerical recurrence probes use this model-owned catalog to anchor
+    /// mutable runtime defaults. Derived parameters deliberately retain no
+    /// semantic probe default because their prepared slots are overwritten by
+    /// the authenticated parameter-derivation evaluator.
+    pub fn parameter_kind_and_default_factors(
+        &self,
+    ) -> RusticolResult<Vec<(ParameterKind, Option<ExactComplexRational>)>> {
+        let input = self.input.as_view();
+        let catalogs = input.validate_catalogs()?;
+        input
+            .parameters
+            .iter()
+            .map(|row| {
+                Ok((
+                    ParameterKind::try_from(row.kind)?,
+                    optional_factor(
+                        &catalogs.factors,
+                        row.default_factor_id,
+                        "parameter default",
+                    )?
+                    .copied(),
+                ))
+            })
+            .collect()
+    }
+
+    pub(crate) fn closure_component_coefficient_catalog(
+        &self,
+    ) -> RusticolResult<Vec<Box<[ExactComplexRational]>>> {
+        let input = self.input.as_view();
+        let catalogs = input.validate_catalogs()?;
+        input
+            .closures
+            .iter()
+            .enumerate()
+            .map(|(expected_id, row)| {
+                let expected_id = u32::try_from(expected_id)
+                    .map_err(|_| invalid("closure template count exceeds u32"))?;
+                if row.id != expected_id {
+                    return Err(invalid(format!(
+                        "closure template {expected_id} has noncanonical ID {}",
+                        row.id
+                    )));
+                }
+                u32_sequence(
+                    input,
+                    row.component_coefficient_sequence_id,
+                    "closure component coefficients",
+                )?
+                .iter()
+                .map(|factor_id| {
+                    catalogs
+                        .factors
+                        .get(*factor_id as usize)
+                        .copied()
+                        .ok_or_else(|| invalid("closure component factor ID is out of range"))
+                })
+                .collect::<RusticolResult<Vec<_>>>()
+                .map(Vec::into_boxed_slice)
+            })
+            .collect()
+    }
+
+    pub fn semantic_index(&self) -> RusticolResult<RecurrenceTemplateSemanticIndex> {
+        let input = self.input.as_view();
+        let catalogs = input.validate_catalogs()?;
+
+        let mut prepared_kernel_by_template_string_id = BTreeMap::new();
+        for binding in input.evaluator_bindings {
+            let prepared_kernel_id =
+                (binding.prepared_kernel_id != MISSING_U32).then_some(binding.prepared_kernel_id);
+            for template_string_id in u32_sequence(
+                input,
+                binding.semantic_template_sequence_id,
+                "evaluator semantic templates",
+            )? {
+                if let Some(previous) = prepared_kernel_by_template_string_id
+                    .insert(*template_string_id, prepared_kernel_id)
+                    && previous != prepared_kernel_id
+                {
+                    return Err(invalid(
+                        "one semantic template has inconsistent prepared-kernel ownership",
+                    ));
+                }
+            }
+        }
+
+        let mut records = BTreeMap::new();
+        macro_rules! register {
+            ($kind:expr, $rows:expr) => {
+                for row in $rows {
+                    let semantic_digest = *catalogs
+                        .digests
+                        .get(row.semantic_digest_id as usize)
+                        .ok_or_else(|| invalid("semantic-template digest ID is out of range"))?;
+                    let identity = RecurrenceSemanticTemplateIdentity {
+                        kind: $kind,
+                        template_id: row.id,
+                        semantic_digest,
+                        prepared_kernel_id: prepared_kernel_by_template_string_id
+                            .get(&row.template_string_id)
+                            .copied()
+                            .flatten(),
+                    };
+                    if records.insert(($kind, row.id), identity).is_some() {
+                        return Err(invalid(format!(
+                            "duplicate {} recurrence template ID {}",
+                            $kind.as_str(),
+                            row.id
+                        )));
+                    }
+                }
+            };
+        }
+        register!(RecurrenceSemanticTemplateKind::Parameter, input.parameters);
+        register!(
+            RecurrenceSemanticTemplateKind::CurrentState,
+            input.current_states
+        );
+        register!(RecurrenceSemanticTemplateKind::Source, input.sources);
+        register!(
+            RecurrenceSemanticTemplateKind::QuantumFlow,
+            input.quantum_flows
+        );
+        register!(
+            RecurrenceSemanticTemplateKind::ContactOrbitCertificate,
+            input.contact_orbit_certificates
+        );
+        register!(
+            RecurrenceSemanticTemplateKind::ContactOrbitStep,
+            input.contact_orbit_steps
+        );
+        register!(
+            RecurrenceSemanticTemplateKind::Transition,
+            input.transitions
+        );
+        register!(
+            RecurrenceSemanticTemplateKind::Propagator,
+            input.propagators
+        );
+        register!(RecurrenceSemanticTemplateKind::Closure, input.closures);
+        register!(
+            RecurrenceSemanticTemplateKind::ColorContraction,
+            input.color_contractions
+        );
+        register!(
+            RecurrenceSemanticTemplateKind::SymmetryProof,
+            input.symmetry_proofs
+        );
+
+        Ok(RecurrenceTemplateSemanticIndex {
+            compiled_model_digest: self.summary.compiled_model_digest,
+            catalog_digest: self.summary.catalog_digest,
+            records,
+        })
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum TemplateKind {
+    Parameter,
+    CurrentState,
+    Source,
+    RuntimeHelicity,
+    QuantumFlow,
+    ContactOrbitCertificate,
+    ContactOrbitStep,
+    Transition,
+    Propagator,
+    Closure,
+    ColorContraction,
+    SymmetryProof,
+}
+
+impl TemplateKind {
+    const fn evaluator_contract(self) -> Option<EvaluatorContractKind> {
+        match self {
+            Self::Parameter => Some(EvaluatorContractKind::ModelParameter),
+            Self::Source => Some(EvaluatorContractKind::Source),
+            Self::Transition => Some(EvaluatorContractKind::Vertex),
+            Self::Propagator => Some(EvaluatorContractKind::Propagator),
+            Self::Closure => Some(EvaluatorContractKind::Closure),
+            Self::CurrentState
+            | Self::RuntimeHelicity
+            | Self::QuantumFlow
+            | Self::ContactOrbitCertificate
+            | Self::ContactOrbitStep
+            | Self::ColorContraction
+            | Self::SymmetryProof => None,
+        }
+    }
+}
+
+struct ValidatedCatalogs<'a> {
+    strings: Vec<&'a str>,
+    digests: Vec<SemanticDigest>,
+    factors: Vec<ExactComplexRational>,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct CallableContractKey {
+    contract_kind: EvaluatorContractKind,
+    callable_signature_digest_id: u32,
+    input_layout: Vec<u32>,
+    output_layout: Vec<u32>,
+    exact_expression_digests: Vec<u32>,
+}
+
+impl<'a> RecurrenceTemplateInputView<'a> {
+    pub fn validate(self) -> RusticolResult<RecurrenceTemplateValidationSummary> {
+        if self.input_abi != RECURRENCE_TEMPLATE_INPUT_ABI {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported recurrence template input ABI {:?}; expected {:?}",
+                self.input_abi, RECURRENCE_TEMPLATE_INPUT_ABI
+            )));
+        }
+        let catalogs = self.validate_catalogs()?;
+        self.validate_header(&catalogs)?;
+
+        let mut template_kinds = BTreeMap::new();
+        let mut semantic_digests = BTreeSet::new();
+        self.validate_parameters(&catalogs, &mut template_kinds, &mut semantic_digests)?;
+        self.validate_current_states(&catalogs, &mut template_kinds, &mut semantic_digests)?;
+        self.validate_sources_basic(&catalogs, &mut template_kinds, &mut semantic_digests)?;
+        self.validate_runtime_helicity_contracts(
+            &catalogs,
+            &mut template_kinds,
+            &mut semantic_digests,
+        )?;
+        self.validate_quantum_flows(&catalogs, &mut template_kinds, &mut semantic_digests)?;
+        self.validate_contact_orbit_records(&catalogs, &mut template_kinds, &mut semantic_digests)?;
+        self.validate_color_contractions(&catalogs, &mut template_kinds, &mut semantic_digests)?;
+        self.validate_symmetry_proofs_basic(&catalogs, &mut template_kinds, &mut semantic_digests)?;
+        self.validate_transitions_basic(&catalogs, &mut template_kinds, &mut semantic_digests)?;
+        self.validate_propagators_basic(&catalogs, &mut template_kinds, &mut semantic_digests)?;
+        self.validate_closures_basic(&catalogs, &mut template_kinds, &mut semantic_digests)?;
+        let prepared_kernel_count =
+            self.validate_evaluators(&catalogs, &template_kinds, &mut semantic_digests)?;
+        self.validate_proof_subjects(&template_kinds)?;
+        self.validate_evaluator_state_contracts(&template_kinds)?;
+
+        Ok(RecurrenceTemplateValidationSummary {
+            catalog_digest: self.catalog_digest,
+            compiled_model_digest: self.compiled_model_digest,
+            prepared_kernel_pack_digest: self.prepared_kernel_pack_digest,
+            parameter_count: checked_len(self.parameters.len(), "parameters")?,
+            current_state_count: checked_len(self.current_states.len(), "current states")?,
+            source_count: checked_len(self.sources.len(), "sources")?,
+            quantum_flow_count: checked_len(self.quantum_flows.len(), "quantum flows")?,
+            contact_orbit_certificate_count: checked_len(
+                self.contact_orbit_certificates.len(),
+                "contact-orbit certificates",
+            )?,
+            contact_orbit_step_count: checked_len(
+                self.contact_orbit_steps.len(),
+                "contact-orbit steps",
+            )?,
+            transition_count: checked_len(self.transitions.len(), "transitions")?,
+            propagator_count: checked_len(self.propagators.len(), "propagators")?,
+            closure_count: checked_len(self.closures.len(), "closures")?,
+            color_contraction_count: checked_len(
+                self.color_contractions.len(),
+                "color contractions",
+            )?,
+            lc_color_transition_witness_count: checked_len(
+                self.lc_color_transition_witnesses.len(),
+                "LC color transition witnesses",
+            )?,
+            symmetry_proof_count: checked_len(self.symmetry_proofs.len(), "symmetry proofs")?,
+            runtime_helicity_contract_count: checked_len(
+                self.runtime_helicity_contracts.len(),
+                "runtime-helicity contracts",
+            )?,
+            evaluator_binding_count: checked_len(
+                self.evaluator_bindings.len(),
+                "evaluator bindings",
+            )?,
+            prepared_kernel_count,
+        })
+    }
+
+    fn validate_catalogs(self) -> RusticolResult<ValidatedCatalogs<'a>> {
+        validate_packed_ranges(
+            "string catalog",
+            self.string_ranges,
+            self.string_bytes.len(),
+        )?;
+        let mut strings = Vec::with_capacity(self.string_ranges.len());
+        let mut previous = None;
+        for (index, range) in self.string_ranges.iter().copied().enumerate() {
+            let bytes = &self.string_bytes
+                [range.as_usize_range(self.string_bytes.len(), &format!("string {index}"))?];
+            let value = std::str::from_utf8(bytes)
+                .map_err(|error| invalid(format!("string {index} is not UTF-8: {error}")))?;
+            if value.is_empty() {
+                return Err(invalid(format!("string catalog row {index} is empty")));
+            }
+            if let Some(previous) = previous
+                && previous >= value
+            {
+                return Err(invalid(format!(
+                    "string catalog is not in strict canonical order at row {index}"
+                )));
+            }
+            previous = Some(value);
+            strings.push(value);
+        }
+
+        validate_canonical_ids(
+            "digest catalog",
+            self.digest_catalog.iter().map(|row| row.id),
+        )?;
+        let mut digests = Vec::with_capacity(self.digest_catalog.len());
+        let mut previous = None;
+        for (index, row) in self.digest_catalog.iter().enumerate() {
+            let value = SemanticDigest::new(row.value).map_err(|error| {
+                invalid(format!("digest catalog row {index} is invalid: {error}"))
+            })?;
+            if let Some(previous) = previous
+                && previous >= value
+            {
+                return Err(invalid(format!(
+                    "digest catalog is not in strict canonical order at row {index}"
+                )));
+            }
+            previous = Some(value);
+            digests.push(value);
+        }
+
+        self.validate_sequence_catalogs(&strings)?;
+        let factors = self.validate_exact_factors(&strings)?;
+        Ok(ValidatedCatalogs {
+            strings,
+            digests,
+            factors,
+        })
+    }
+
+    fn validate_sequence_catalogs(self, strings: &[&str]) -> RusticolResult<()> {
+        validate_sequence_catalog(
+            "u32 sequence catalog",
+            self.u32_sequence_ranges,
+            self.u32_sequence_values,
+            false,
+        )?;
+        validate_sequence_catalog(
+            "i32 sequence catalog",
+            self.i32_sequence_ranges,
+            self.i32_sequence_values,
+            false,
+        )?;
+        validate_sequence_catalog(
+            "flavour-flow catalog",
+            self.flavour_flow_ranges,
+            self.flavour_flow_values,
+            true,
+        )?;
+        self.validate_coupling_order_catalog(strings)?;
+        self.validate_quantum_number_flow_catalog(strings)?;
+        Ok(())
+    }
+
+    fn validate_coupling_order_catalog(self, strings: &[&str]) -> RusticolResult<()> {
+        validate_indexed_ranges(
+            "coupling-order catalog",
+            self.coupling_order_ranges,
+            self.coupling_order_terms.len(),
+        )?;
+        let mut previous: Option<Vec<(u32, u32)>> = None;
+        for (set_index, range) in self.coupling_order_ranges.iter().enumerate() {
+            let terms = &self.coupling_order_terms[range
+                .range
+                .as_usize_range(self.coupling_order_terms.len(), "coupling-order set")?];
+            let mut current = Vec::with_capacity(terms.len());
+            let mut previous_name = None;
+            for term in terms {
+                if term.set_id as usize != set_index {
+                    return Err(invalid(format!(
+                        "coupling-order term names set {}, expected {set_index}",
+                        term.set_id
+                    )));
+                }
+                required_string(strings, term.name_string_id, "coupling-order name")?;
+                if let Some(previous_name) = previous_name
+                    && previous_name >= term.name_string_id
+                {
+                    return Err(invalid(format!(
+                        "coupling-order set {set_index} is not strictly name ordered"
+                    )));
+                }
+                previous_name = Some(term.name_string_id);
+                current.push((term.name_string_id, term.power));
+            }
+            if let Some(previous) = previous.as_ref()
+                && previous.as_slice() >= current.as_slice()
+            {
+                return Err(invalid(format!(
+                    "coupling-order catalog is not in strict canonical order at set {set_index}"
+                )));
+            }
+            previous = Some(current);
+        }
+        Ok(())
+    }
+
+    fn validate_quantum_number_flow_catalog(self, strings: &[&str]) -> RusticolResult<()> {
+        validate_indexed_ranges(
+            "quantum-number-flow catalog",
+            self.quantum_number_flow_ranges,
+            self.quantum_number_flow_terms.len(),
+        )?;
+        let mut previous: Option<Vec<(u32, u32)>> = None;
+        for (flow_index, range) in self.quantum_number_flow_ranges.iter().enumerate() {
+            let terms = &self.quantum_number_flow_terms[range
+                .range
+                .as_usize_range(self.quantum_number_flow_terms.len(), "quantum-number flow")?];
+            let mut current = Vec::with_capacity(terms.len());
+            let mut previous_name = None;
+            for term in terms {
+                if term.flow_id as usize != flow_index {
+                    return Err(invalid(format!(
+                        "quantum-number-flow term names flow {}, expected {flow_index}",
+                        term.flow_id
+                    )));
+                }
+                required_string(strings, term.name_string_id, "quantum-number name")?;
+                required_string(
+                    strings,
+                    term.expression_string_id,
+                    "quantum-number expression",
+                )?;
+                if let Some(previous_name) = previous_name
+                    && previous_name >= term.name_string_id
+                {
+                    return Err(invalid(format!(
+                        "quantum-number flow {flow_index} is not strictly name ordered"
+                    )));
+                }
+                previous_name = Some(term.name_string_id);
+                current.push((term.name_string_id, term.expression_string_id));
+            }
+            if let Some(previous) = previous.as_ref()
+                && previous.as_slice() >= current.as_slice()
+            {
+                return Err(invalid(format!(
+                    "quantum-number-flow catalog is not in strict canonical order at flow {flow_index}"
+                )));
+            }
+            previous = Some(current);
+        }
+        Ok(())
+    }
+
+    fn validate_exact_factors(self, strings: &[&str]) -> RusticolResult<Vec<ExactComplexRational>> {
+        validate_canonical_ids(
+            "exact-factor catalog",
+            self.exact_factors.iter().map(|row| row.id),
+        )?;
+        let mut factors = Vec::with_capacity(self.exact_factors.len());
+        let mut previous = None;
+        for (index, row) in self.exact_factors.iter().enumerate() {
+            let real_numerator = required_string(
+                strings,
+                row.real_numerator_string_id,
+                "exact real numerator",
+            )?;
+            let real_denominator = required_string(
+                strings,
+                row.real_denominator_string_id,
+                "exact real denominator",
+            )?;
+            let imag_numerator = required_string(
+                strings,
+                row.imag_numerator_string_id,
+                "exact imaginary numerator",
+            )?;
+            let imag_denominator = required_string(
+                strings,
+                row.imag_denominator_string_id,
+                "exact imaginary denominator",
+            )?;
+            let raw_key = (
+                parse_canonical_i128(real_numerator, false, "exact real numerator")?,
+                parse_canonical_i128(real_denominator, true, "exact real denominator")?,
+                parse_canonical_i128(imag_numerator, false, "exact imaginary numerator")?,
+                parse_canonical_i128(imag_denominator, true, "exact imaginary denominator")?,
+            );
+            let factor = ExactComplexRational::parse_parts(
+                real_numerator,
+                real_denominator,
+                imag_numerator,
+                imag_denominator,
+            )
+            .map_err(|error| invalid(format!("exact factor {index} is invalid: {error}")))?;
+            if factor.real().numerator() != raw_key.0
+                || factor.real().denominator() != raw_key.1
+                || factor.imag().numerator() != raw_key.2
+                || factor.imag().denominator() != raw_key.3
+            {
+                return Err(invalid(format!(
+                    "exact factor {index} is not reduced canonically"
+                )));
+            }
+            if let Some(previous) = previous
+                && previous >= raw_key
+            {
+                return Err(invalid(format!(
+                    "exact-factor catalog is not in strict canonical order at row {index}"
+                )));
+            }
+            previous = Some(raw_key);
+            factors.push(factor);
+        }
+        Ok(factors)
+    }
+
+    fn validate_header(self, catalogs: &ValidatedCatalogs<'_>) -> RusticolResult<()> {
+        if self.catalog_header.len() != 1 {
+            return Err(invalid(format!(
+                "catalog_header must contain one row, found {}",
+                self.catalog_header.len()
+            )));
+        }
+        let header = self.catalog_header[0];
+        if header.schema_version != RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION {
+            return Err(RusticolError::compatibility(format!(
+                "unsupported recurrence template input schema {}; expected {}",
+                header.schema_version, RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION
+            )));
+        }
+        require_string_value(
+            &catalogs.strings,
+            header.abi_string_id,
+            RECURRENCE_TEMPLATE_ABI,
+            "recurrence template ABI",
+        )?;
+        require_string_value(
+            &catalogs.strings,
+            header.canonicalization_abi_string_id,
+            RECURRENCE_TEMPLATE_CANONICALIZATION_ABI,
+            "recurrence canonicalization ABI",
+        )?;
+        require_string_value(
+            &catalogs.strings,
+            header.exact_scalar_abi_string_id,
+            RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI,
+            "recurrence exact-scalar ABI",
+        )?;
+        if required_digest(
+            &catalogs.digests,
+            header.compiled_model_digest_id,
+            "compiled-model digest",
+        )? != self.compiled_model_digest
+        {
+            return Err(invalid(
+                "compiled-model digest does not match the input envelope",
+            ));
+        }
+        if required_digest(
+            &catalogs.digests,
+            header.prepared_kernel_pack_digest_id,
+            "prepared-kernel-pack digest",
+        )? != self.prepared_kernel_pack_digest
+        {
+            return Err(invalid(
+                "prepared-kernel-pack digest does not match the input envelope",
+            ));
+        }
+        if required_digest(
+            &catalogs.digests,
+            header.catalog_digest_id,
+            "catalog digest",
+        )? != self.catalog_digest
+        {
+            return Err(invalid("catalog digest does not match the input envelope"));
+        }
+
+        let expected = [
+            ("parameters", header.parameter_count, self.parameters.len()),
+            (
+                "current states",
+                header.current_state_count,
+                self.current_states.len(),
+            ),
+            ("sources", header.source_count, self.sources.len()),
+            (
+                "quantum flows",
+                header.quantum_flow_count,
+                self.quantum_flows.len(),
+            ),
+            (
+                "contact-orbit certificates",
+                header.contact_orbit_certificate_count,
+                self.contact_orbit_certificates.len(),
+            ),
+            (
+                "contact-orbit steps",
+                header.contact_orbit_step_count,
+                self.contact_orbit_steps.len(),
+            ),
+            (
+                "transitions",
+                header.transition_count,
+                self.transitions.len(),
+            ),
+            (
+                "propagators",
+                header.propagator_count,
+                self.propagators.len(),
+            ),
+            ("closures", header.closure_count, self.closures.len()),
+            (
+                "color contractions",
+                header.color_contraction_count,
+                self.color_contractions.len(),
+            ),
+            (
+                "symmetry proofs",
+                header.symmetry_proof_count,
+                self.symmetry_proofs.len(),
+            ),
+            (
+                "runtime-helicity contracts",
+                header.runtime_helicity_contract_count,
+                self.runtime_helicity_contracts.len(),
+            ),
+            (
+                "evaluator bindings",
+                header.evaluator_binding_count,
+                self.evaluator_bindings.len(),
+            ),
+        ];
+        for (label, declared, actual) in expected {
+            if usize::try_from(declared).ok() != Some(actual) {
+                return Err(invalid(format!(
+                    "catalog header declares {declared} {label}, found {actual}"
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_parameters(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "parameter",
+            self.parameters.iter().map(|row| row.id),
+            self.parameters.iter().map(|row| row.template_string_id),
+        )?;
+        for (index, row) in self.parameters.iter().enumerate() {
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::Parameter,
+                "parameter",
+            )?;
+            register_semantic_digest(semantic_digests, row.semantic_digest_id, "parameter")?;
+            required_string(
+                &catalogs.strings,
+                row.template_string_id,
+                "parameter template",
+            )?;
+            required_string(&catalogs.strings, row.name_string_id, "parameter name")?;
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "parameter semantic digest",
+            )?;
+            let kind = ParameterKind::try_from(row.kind)?;
+            let value_type = ParameterValueType::try_from(row.value_type)?;
+            validate_bool(row.mutable, "parameter mutable")?;
+            let default = optional_factor(
+                &catalogs.factors,
+                row.default_factor_id,
+                "parameter default",
+            )?;
+            optional_digest(
+                &catalogs.digests,
+                row.exact_expression_digest_id,
+                "parameter exact expression",
+            )?;
+            let dependencies =
+                u32_sequence(self, row.dependency_sequence_id, "parameter dependencies")?;
+            validate_strict_u32(dependencies, "parameter dependencies")?;
+            validate_u32_references(
+                dependencies,
+                self.parameters.len(),
+                "parameter dependencies",
+            )?;
+            if dependencies.contains(&(index as u32)) {
+                return Err(invalid(format!(
+                    "parameter {index} depends directly on itself"
+                )));
+            }
+            match kind {
+                ParameterKind::Derived => {
+                    if row.exact_expression_digest_id == MISSING_U32 {
+                        return Err(invalid(format!(
+                            "derived parameter {index} has no exact expression digest"
+                        )));
+                    }
+                }
+                ParameterKind::External | ParameterKind::Constant => {
+                    if default.is_none() {
+                        return Err(invalid(format!(
+                            "external/constant parameter {index} has no exact default"
+                        )));
+                    }
+                }
+            }
+            if value_type == ParameterValueType::Real
+                && default.is_some_and(|value| !value.imag().is_zero())
+            {
+                return Err(invalid(format!(
+                    "real parameter {index} has a complex default"
+                )));
+            }
+        }
+        self.validate_parameter_dependency_graph()?;
+        Ok(())
+    }
+
+    fn validate_parameter_dependency_graph(self) -> RusticolResult<()> {
+        let mut indegree = vec![0usize; self.parameters.len()];
+        let mut dependents = vec![Vec::<usize>::new(); self.parameters.len()];
+        for (index, row) in self.parameters.iter().enumerate() {
+            let dependencies =
+                u32_sequence(self, row.dependency_sequence_id, "parameter dependencies")?;
+            indegree[index] = dependencies.len();
+            for dependency in dependencies {
+                dependents[*dependency as usize].push(index);
+            }
+        }
+        let mut ready = indegree
+            .iter()
+            .enumerate()
+            .filter_map(|(index, count)| (*count == 0).then_some(index))
+            .collect::<Vec<_>>();
+        let mut visited = 0usize;
+        while let Some(index) = ready.pop() {
+            visited += 1;
+            for dependent in &dependents[index] {
+                indegree[*dependent] -= 1;
+                if indegree[*dependent] == 0 {
+                    ready.push(*dependent);
+                }
+            }
+        }
+        if visited != self.parameters.len() {
+            let cyclic = indegree
+                .iter()
+                .enumerate()
+                .filter_map(|(index, count)| (*count > 0).then_some(index.to_string()))
+                .collect::<Vec<_>>()
+                .join(", ");
+            return Err(invalid(format!(
+                "parameter dependency graph contains a cycle involving: {cyclic}"
+            )));
+        }
+        Ok(())
+    }
+
+    fn validate_current_states(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "current state",
+            self.current_states.iter().map(|row| row.id),
+            self.current_states.iter().map(|row| row.template_string_id),
+        )?;
+        for (index, row) in self.current_states.iter().enumerate() {
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::CurrentState,
+                "current state",
+            )?;
+            register_semantic_digest(semantic_digests, row.semantic_digest_id, "current state")?;
+            for (id, label) in [
+                (row.template_string_id, "current-state template"),
+                (row.species_string_id, "current-state species"),
+                (row.basis_string_id, "current-state basis"),
+            ] {
+                required_string(&catalogs.strings, id, label)?;
+            }
+            let color_shape = required_string(
+                &catalogs.strings,
+                row.lc_color_shape_string_id,
+                "current-state LC color shape",
+            )?;
+            validate_lc_color_shape(
+                color_shape,
+                row.color_representation,
+                &format!("current state {index}"),
+            )?;
+            optional_string(
+                &catalogs.strings,
+                row.auxiliary_kind_string_id,
+                "current-state auxiliary kind",
+            )?;
+            CurrentOrientation::try_from(row.orientation)?;
+            ParticleStatistics::try_from(row.statistics)?;
+            if row.dimension == 0 {
+                return Err(invalid(format!("current state {index} has zero dimension")));
+            }
+            let tensor_ordering = u32_sequence(
+                self,
+                row.tensor_ordering_sequence_id,
+                "current tensor ordering",
+            )?;
+            if tensor_ordering.len() != row.dimension as usize {
+                return Err(invalid(format!(
+                    "current state {index} dimension {} does not match tensor ordering length {}",
+                    row.dimension,
+                    tensor_ordering.len()
+                )));
+            }
+            for string_id in tensor_ordering {
+                required_string(&catalogs.strings, *string_id, "current tensor label")?;
+            }
+            optional_reference(
+                row.mass_parameter_id,
+                self.parameters.len(),
+                "current mass parameter",
+            )?;
+            optional_reference(
+                row.width_parameter_id,
+                self.parameters.len(),
+                "current width parameter",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "current-state semantic digest",
+            )?;
+        }
+        Ok(())
+    }
+
+    fn validate_sources_basic(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "source",
+            self.sources.iter().map(|row| row.id),
+            self.sources.iter().map(|row| row.template_string_id),
+        )?;
+        for row in self.sources {
+            validate_concrete_spin_state(row.spin_state, "source template spin state")?;
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::Source,
+                "source",
+            )?;
+            register_semantic_digest(semantic_digests, row.semantic_digest_id, "source")?;
+            required_reference(
+                row.state_template_id,
+                self.current_states.len(),
+                "source state",
+            )?;
+            required_reference(
+                row.evaluator_binding_id,
+                self.evaluator_bindings.len(),
+                "source evaluator",
+            )?;
+            required_reference(
+                row.flavour_flow_id,
+                self.flavour_flow_ranges.len(),
+                "source flavour flow",
+            )?;
+            required_reference(
+                row.quantum_number_flow_id,
+                self.quantum_number_flow_ranges.len(),
+                "source quantum-number flow",
+            )?;
+            let state = self.current_states[row.state_template_id as usize];
+            if row.lc_color_seed_shape_string_id != state.lc_color_shape_string_id {
+                return Err(invalid(
+                    "source LC color seed shape does not match its current state",
+                ));
+            }
+            let seed_shape = required_string(
+                &catalogs.strings,
+                row.lc_color_seed_shape_string_id,
+                "source LC color seed shape",
+            )?;
+            validate_lc_color_shape(
+                seed_shape,
+                state.color_representation,
+                "source LC color seed",
+            )?;
+            let seed_operation = LCColorSourceSeedOperation::try_from(row.lc_color_seed_operation)?;
+            let seed_component_kind = if row.lc_color_seed_component_kind == u8::MAX {
+                None
+            } else {
+                Some(LCColorComponentKind::try_from(
+                    row.lc_color_seed_component_kind,
+                )?)
+            };
+            let seed_component_role =
+                LCColorComponentRole::try_from(row.lc_color_seed_component_role)?;
+            let expected_seed = match seed_shape {
+                "singlet-forest" => (
+                    LCColorSourceSeedOperation::Empty,
+                    None,
+                    LCColorComponentRole::None,
+                ),
+                "fundamental-open-string" | "antifundamental-open-string" => (
+                    LCColorSourceSeedOperation::Singleton,
+                    Some(LCColorComponentKind::OpenString),
+                    LCColorComponentRole::Active,
+                ),
+                "adjoint-segment" => (
+                    LCColorSourceSeedOperation::Singleton,
+                    Some(LCColorComponentKind::AdjointSegment),
+                    LCColorComponentRole::Active,
+                ),
+                _ => unreachable!("validated LC color shape"),
+            };
+            if (seed_operation, seed_component_kind, seed_component_role) != expected_seed {
+                return Err(invalid(
+                    "source LC color seed does not match its certified output shape",
+                ));
+            }
+            let seed_proof = required_digest(
+                &catalogs.digests,
+                row.lc_color_seed_proof_digest_id,
+                "source LC color seed proof",
+            )?;
+            LCColorSourceSeed::new(
+                seed_operation,
+                row.lc_color_seed_shape_string_id,
+                seed_component_kind,
+                seed_component_role,
+                seed_proof,
+            )?;
+            let seed_provenance = u32_sequence(
+                self,
+                row.lc_color_seed_provenance_sequence_id,
+                "source LC color seed provenance",
+            )?;
+            validate_string_pair_sequence(
+                &catalogs.strings,
+                seed_provenance,
+                "source LC color seed provenance",
+            )?;
+            optional_reference(
+                row.mass_parameter_id,
+                self.parameters.len(),
+                "source mass parameter",
+            )?;
+            optional_reference(
+                row.width_parameter_id,
+                self.parameters.len(),
+                "source width parameter",
+            )?;
+            required_string(&catalogs.strings, row.template_string_id, "source template")?;
+            required_string(&catalogs.strings, row.crossing_string_id, "source crossing")?;
+            let family = required_string(
+                &catalogs.strings,
+                row.wavefunction_family_string_id,
+                "source wavefunction family",
+            )?;
+            if !matches!(
+                family,
+                "scalar" | "fermion" | "vector" | "spin2" | "ghost" | "auxiliary"
+            ) {
+                return Err(invalid(format!(
+                    "unsupported source wavefunction family {family:?}"
+                )));
+            }
+            required_digest(
+                &catalogs.digests,
+                row.wavefunction_expression_digest_id,
+                "source wavefunction expression",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "source semantic digest",
+            )?;
+        }
+        Ok(())
+    }
+
+    fn validate_runtime_helicity_contracts(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "runtime-helicity contract",
+            self.runtime_helicity_contracts.iter().map(|row| row.id),
+            self.runtime_helicity_contracts
+                .iter()
+                .map(|row| row.template_string_id),
+        )?;
+        validate_canonical_ids(
+            "runtime-helicity variant",
+            self.runtime_helicity_variants.iter().map(|row| row.id),
+        )?;
+        let contract_ranges = self
+            .runtime_helicity_contracts
+            .iter()
+            .map(|row| row.variant_range)
+            .collect::<Vec<_>>();
+        validate_packed_ranges(
+            "runtime-helicity variants",
+            &contract_ranges,
+            self.runtime_helicity_variants.len(),
+        )?;
+        let embedding_ranges = self
+            .runtime_helicity_variants
+            .iter()
+            .map(|row| row.embedding_range)
+            .collect::<Vec<_>>();
+        validate_packed_ranges(
+            "runtime-helicity embeddings",
+            &embedding_ranges,
+            self.runtime_helicity_embeddings.len(),
+        )?;
+        let projection_ranges = self
+            .runtime_helicity_variants
+            .iter()
+            .map(|row| row.projection_range)
+            .collect::<Vec<_>>();
+        validate_packed_ranges(
+            "runtime-helicity projections",
+            &projection_ranges,
+            self.runtime_helicity_projections.len(),
+        )?;
+
+        let mut owned_sources = BTreeSet::new();
+        for contract in self.runtime_helicity_contracts {
+            register_template(
+                template_kinds,
+                contract.template_string_id,
+                TemplateKind::RuntimeHelicity,
+                "runtime-helicity contract",
+            )?;
+            register_semantic_digest(
+                semantic_digests,
+                contract.semantic_digest_id,
+                "runtime-helicity contract",
+            )?;
+            required_string(
+                &catalogs.strings,
+                contract.template_string_id,
+                "runtime-helicity template",
+            )?;
+            required_string(
+                &catalogs.strings,
+                contract.proof_algorithm_string_id,
+                "runtime-helicity proof algorithm",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                contract.proof_digest_id,
+                "runtime-helicity proof",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                contract.semantic_digest_id,
+                "runtime-helicity semantic digest",
+            )?;
+            let full_state_index = required_reference(
+                contract.full_state_template_id,
+                self.current_states.len(),
+                "runtime-helicity full state",
+            )?;
+            let full_dimension = self.current_states[full_state_index].dimension as usize;
+            let variants = &self.runtime_helicity_variants[contract.variant_range.as_usize_range(
+                self.runtime_helicity_variants.len(),
+                "runtime-helicity variants",
+            )?];
+            if variants.is_empty() {
+                return Err(invalid(format!(
+                    "runtime-helicity contract {} has no variants",
+                    contract.id
+                )));
+            }
+            for variant in variants {
+                if variant.contract_id != contract.id {
+                    return Err(invalid(format!(
+                        "runtime-helicity variant {} names contract {}, expected {}",
+                        variant.id, variant.contract_id, contract.id
+                    )));
+                }
+                let source_index = required_reference(
+                    variant.source_template_id,
+                    self.sources.len(),
+                    "runtime-helicity source",
+                )?;
+                if !owned_sources.insert(variant.source_template_id) {
+                    return Err(invalid(format!(
+                        "source template {} belongs to multiple runtime-helicity variants",
+                        variant.source_template_id
+                    )));
+                }
+                let source_state_index = required_reference(
+                    variant.source_state_template_id,
+                    self.current_states.len(),
+                    "runtime-helicity source state",
+                )?;
+                if self.sources[source_index].state_template_id != variant.source_state_template_id
+                {
+                    return Err(invalid(format!(
+                        "runtime-helicity variant {} source-state contract is inconsistent",
+                        variant.id
+                    )));
+                }
+                required_digest(
+                    &catalogs.digests,
+                    variant.proof_digest_id,
+                    "runtime-helicity variant proof",
+                )?;
+                let source_dimension = self.current_states[source_state_index].dimension as usize;
+                let embeddings =
+                    &self.runtime_helicity_embeddings[variant.embedding_range.as_usize_range(
+                        self.runtime_helicity_embeddings.len(),
+                        "runtime-helicity embedding",
+                    )?];
+                let projections =
+                    &self.runtime_helicity_projections[variant.projection_range.as_usize_range(
+                        self.runtime_helicity_projections.len(),
+                        "runtime-helicity projection",
+                    )?];
+                if embeddings.len() != full_dimension || projections.len() != source_dimension {
+                    return Err(invalid(format!(
+                        "runtime-helicity variant {} dimensions do not match its current states",
+                        variant.id
+                    )));
+                }
+                for (component, embedding) in embeddings.iter().enumerate() {
+                    if embedding.variant_id != variant.id
+                        || embedding.full_component as usize != component
+                    {
+                        return Err(invalid(format!(
+                            "runtime-helicity variant {} has noncanonical embedding rows",
+                            variant.id
+                        )));
+                    }
+                    let factor = required_factor(
+                        &catalogs.factors,
+                        embedding.factor_id,
+                        "runtime-helicity embedding factor",
+                    )?;
+                    if embedding.source_component == MISSING_U32 {
+                        if !factor.is_zero() {
+                            return Err(invalid(
+                                "an absent runtime-helicity source component has nonzero factor",
+                            ));
+                        }
+                    } else if embedding.source_component as usize >= source_dimension
+                        || factor.is_zero()
+                    {
+                        return Err(invalid(
+                            "a runtime-helicity source embedding is out of range or zero",
+                        ));
+                    }
+                }
+                for (component, projection) in projections.iter().enumerate() {
+                    if projection.variant_id != variant.id
+                        || projection.source_component as usize != component
+                        || projection.full_component as usize >= full_dimension
+                    {
+                        return Err(invalid(format!(
+                            "runtime-helicity variant {} has invalid projection rows",
+                            variant.id
+                        )));
+                    }
+                    if embeddings[projection.full_component as usize].source_component
+                        != projection.source_component
+                    {
+                        return Err(invalid(format!(
+                            "runtime-helicity variant {} embedding and projection disagree",
+                            variant.id
+                        )));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_quantum_flows(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "quantum flow",
+            self.quantum_flows.iter().map(|row| row.id),
+            self.quantum_flows.iter().map(|row| row.template_string_id),
+        )?;
+        let mut static_quantum_flows = BTreeMap::<u32, u32>::new();
+        for (index, row) in self.quantum_flows.iter().enumerate() {
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::QuantumFlow,
+                "quantum flow",
+            )?;
+            register_semantic_digest(semantic_digests, row.semantic_digest_id, "quantum flow")?;
+            required_string(
+                &catalogs.strings,
+                row.template_string_id,
+                "quantum-flow template",
+            )?;
+            let states = u32_sequence(
+                self,
+                row.input_state_sequence_id,
+                "quantum-flow input states",
+            )?;
+            if states.len() != 2 {
+                return Err(invalid(format!(
+                    "quantum flow {index} must have binary input arity"
+                )));
+            }
+            validate_u32_references(
+                states,
+                self.current_states.len(),
+                "quantum-flow input states",
+            )?;
+            let spins = i32_sequence(self, row.input_spin_sequence_id, "quantum-flow spins")?;
+            for spin in spins {
+                validate_concrete_spin_state(*spin, "quantum-flow input spin state")?;
+            }
+            validate_concrete_spin_state(row.result_spin_state, "quantum-flow result spin state")?;
+            let flavour_ids = u32_sequence(
+                self,
+                row.input_flavour_sequence_id,
+                "quantum-flow flavour flows",
+            )?;
+            let quantum_ids = u32_sequence(
+                self,
+                row.input_quantum_sequence_id,
+                "quantum-flow quantum-number flows",
+            )?;
+            if states.len() != spins.len()
+                || states.len() != flavour_ids.len()
+                || states.len() != quantum_ids.len()
+            {
+                return Err(invalid(format!(
+                    "quantum flow {index} input contract columns have different arity"
+                )));
+            }
+            validate_u32_references(
+                flavour_ids,
+                self.flavour_flow_ranges.len(),
+                "quantum-flow flavour flows",
+            )?;
+            validate_u32_references(
+                quantum_ids,
+                self.quantum_number_flow_ranges.len(),
+                "quantum-flow quantum-number flows",
+            )?;
+            let operation = required_string(
+                &catalogs.strings,
+                row.flavour_flow_operation_string_id,
+                "quantum-flow flavour operation",
+            )?;
+            if !matches!(
+                operation,
+                "constant-result"
+                    | "append-left-result"
+                    | "append-right-result"
+                    | "concat-left-right-result"
+            ) {
+                return Err(invalid(format!(
+                    "quantum flow {index} has unsupported flavour operation {operation:?}"
+                )));
+            }
+            let quantum_operation = required_string(
+                &catalogs.strings,
+                row.quantum_number_flow_operation_string_id,
+                "quantum-flow quantum-number operation",
+            )?;
+            if quantum_operation != "particle-static-result" {
+                return Err(invalid(format!(
+                    "quantum flow {index} has unsupported quantum-number operation {quantum_operation:?}"
+                )));
+            }
+            required_reference(
+                row.result_state_template_id,
+                self.current_states.len(),
+                "quantum-flow result state",
+            )?;
+            required_reference(
+                row.result_flavour_flow_id,
+                self.flavour_flow_ranges.len(),
+                "quantum-flow result flavour flow",
+            )?;
+            required_reference(
+                row.result_quantum_number_flow_id,
+                self.quantum_number_flow_ranges.len(),
+                "quantum-flow result quantum-number flow",
+            )?;
+            let previous_quantum_flow = static_quantum_flows
+                .entry(row.result_state_template_id)
+                .or_insert(row.result_quantum_number_flow_id);
+            if *previous_quantum_flow != row.result_quantum_number_flow_id {
+                return Err(invalid(format!(
+                    "quantum flow {index} violates particle-static quantum-number flow"
+                )));
+            }
+            validate_flavour_flow_witness(
+                self,
+                index,
+                operation,
+                flavour_ids,
+                row.result_state_template_id,
+                row.result_flavour_flow_id,
+            )?;
+            required_reference(
+                row.coupling_order_set_id,
+                self.coupling_order_ranges.len(),
+                "quantum-flow coupling-order set",
+            )?;
+            required_factor(
+                &catalogs.factors,
+                row.exact_coupling_factor_id,
+                "quantum-flow exact coupling",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                row.predicate_digest_id,
+                "quantum-flow predicate",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "quantum-flow semantic digest",
+            )?;
+        }
+        Ok(())
+    }
+
+    fn validate_contact_orbit_records(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "contact-orbit certificate",
+            self.contact_orbit_certificates.iter().map(|row| row.id),
+            self.contact_orbit_certificates
+                .iter()
+                .map(|row| row.template_string_id),
+        )?;
+        for (index, row) in self.contact_orbit_certificates.iter().enumerate() {
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::ContactOrbitCertificate,
+                "contact-orbit certificate",
+            )?;
+            register_semantic_digest(
+                semantic_digests,
+                row.semantic_digest_id,
+                "contact-orbit certificate",
+            )?;
+            required_string(
+                &catalogs.strings,
+                row.template_string_id,
+                "contact-orbit certificate template",
+            )?;
+            require_string_value(
+                &catalogs.strings,
+                row.algorithm_string_id,
+                CONTACT_ORBIT_ALGORITHM,
+                "contact-orbit certificate algorithm",
+            )?;
+            if row.algorithm_version != CONTACT_ORBIT_ALGORITHM_VERSION {
+                return Err(invalid(format!(
+                    "contact-orbit certificate {index} has unsupported algorithm version {}",
+                    row.algorithm_version
+                )));
+            }
+            required_string(
+                &catalogs.strings,
+                row.vertex_string_id,
+                "contact-orbit certificate vertex",
+            )?;
+            let evaluator_class = required_string(
+                &catalogs.strings,
+                row.evaluator_class_string_id,
+                "contact-orbit evaluator class",
+            )?;
+            if !matches!(
+                evaluator_class,
+                CONTACT_ORBIT_EVALUATOR_CLASS | HEFT_CONTACT_ORBIT_EVALUATOR_CLASS
+            ) {
+                return Err(RusticolError::compatibility(format!(
+                    "unsupported contact-orbit evaluator class {evaluator_class:?}"
+                )));
+            }
+            let particles = u32_sequence(
+                self,
+                row.particle_string_sequence_id,
+                "contact-orbit certificate particles",
+            )?;
+            let equivalence_classes = u32_sequence(
+                self,
+                row.physical_leg_equivalence_sequence_id,
+                "contact-orbit certificate physical-leg equivalence classes",
+            )?;
+            if !matches!(particles.len(), 4 | 5) || equivalence_classes.len() != particles.len() {
+                return Err(invalid(format!(
+                    "contact-orbit certificate {index} must describe four or five physical legs"
+                )));
+            }
+            for particle in particles {
+                required_string(
+                    &catalogs.strings,
+                    *particle,
+                    "contact-orbit certificate particle",
+                )?;
+            }
+            let mut class_by_particle = BTreeMap::<u32, u32>::new();
+            let mut next_class = 0u32;
+            let expected_classes = particles
+                .iter()
+                .map(|particle| {
+                    *class_by_particle.entry(*particle).or_insert_with(|| {
+                        let class = next_class;
+                        next_class += 1;
+                        class
+                    })
+                })
+                .collect::<Vec<_>>();
+            if equivalence_classes != expected_classes.as_slice() {
+                return Err(invalid(format!(
+                    "contact-orbit certificate {index} has noncanonical physical-leg equivalence classes"
+                )));
+            }
+            let reconstruction = required_factor(
+                &catalogs.factors,
+                row.reconstruction_factor_id,
+                "contact-orbit certificate reconstruction factor",
+            )?;
+            if *reconstruction != ExactComplexRational::ONE {
+                return Err(invalid(format!(
+                    "contact-orbit certificate {index} reconstruction factor is not one"
+                )));
+            }
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "contact-orbit certificate semantic digest",
+            )?;
+        }
+
+        validate_record_ids(
+            "contact-orbit step",
+            self.contact_orbit_steps.iter().map(|row| row.id),
+            self.contact_orbit_steps
+                .iter()
+                .map(|row| row.template_string_id),
+        )?;
+        for (index, row) in self.contact_orbit_steps.iter().enumerate() {
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::ContactOrbitStep,
+                "contact-orbit step",
+            )?;
+            register_semantic_digest(
+                semantic_digests,
+                row.semantic_digest_id,
+                "contact-orbit step",
+            )?;
+            required_string(
+                &catalogs.strings,
+                row.template_string_id,
+                "contact-orbit step template",
+            )?;
+            required_reference(
+                row.certificate_id,
+                self.contact_orbit_certificates.len(),
+                "contact-orbit step certificate",
+            )?;
+            let certificate = self
+                .contact_orbit_certificates
+                .get(row.certificate_id as usize)
+                .ok_or_else(|| invalid("contact-orbit step certificate is absent"))?;
+            let arity = u32_sequence(
+                self,
+                certificate.physical_leg_equivalence_sequence_id,
+                "contact-orbit step certificate arity",
+            )?
+            .len();
+            let stage = ContactOrbitStage::try_from(row.stage)?;
+            if usize::from(row.result_leg) >= arity {
+                return Err(invalid(format!(
+                    "contact-orbit step {index} result leg is outside arity"
+                )));
+            }
+            let left = u32_sequence(
+                self,
+                row.left_covered_leg_sequence_id,
+                "contact-orbit left covered legs",
+            )?;
+            let right = u32_sequence(
+                self,
+                row.right_covered_leg_sequence_id,
+                "contact-orbit right covered legs",
+            )?;
+            if left.is_empty()
+                || right.is_empty()
+                || left.iter().chain(right).any(|leg| *leg as usize >= arity)
+            {
+                return Err(invalid(format!(
+                    "contact-orbit step {index} has invalid covered legs"
+                )));
+            }
+            let covered = left.iter().chain(right).copied().collect::<BTreeSet<_>>();
+            if covered.len() != left.len() + right.len() {
+                return Err(invalid(format!(
+                    "contact-orbit step {index} repeats a covered leg"
+                )));
+            }
+            let sources = i32_sequence(
+                self,
+                row.source_particle_leg_sequence_id,
+                "contact-orbit source-particle legs",
+            )?;
+            if sources.len() != 3 || sources.iter().any(|leg| *leg < -1 || *leg >= arity as i32) {
+                return Err(invalid(format!(
+                    "contact-orbit step {index} has invalid source-particle legs"
+                )));
+            }
+            let reconstruction = required_factor(
+                &catalogs.factors,
+                row.reconstruction_factor_id,
+                "contact-orbit step reconstruction factor",
+            )?;
+            if *reconstruction != ExactComplexRational::ONE {
+                return Err(invalid(format!(
+                    "contact-orbit step {index} reconstruction factor is not one"
+                )));
+            }
+            match stage {
+                ContactOrbitStage::Partial => {
+                    if left.len() != 1
+                        || right.len() != 1
+                        || sources != [left[0] as i32, right[0] as i32, -1]
+                        || covered.contains(&(row.result_leg as u32))
+                    {
+                        return Err(invalid(format!(
+                            "contact-orbit partial step {index} has inconsistent lineage"
+                        )));
+                    }
+                }
+                ContactOrbitStage::Final => {
+                    let expected_covered = (0u32..arity as u32)
+                        .filter(|leg| *leg != row.result_leg as u32)
+                        .collect::<BTreeSet<_>>();
+                    let expected_sources = [
+                        if left.len() > 1 { -1 } else { left[0] as i32 },
+                        if right.len() > 1 { -1 } else { right[0] as i32 },
+                        row.result_leg as i32,
+                    ];
+                    if covered != expected_covered
+                        || left.len() > 2
+                        || right.len() > 2
+                        || sources != expected_sources
+                    {
+                        return Err(invalid(format!(
+                            "contact-orbit final step {index} has inconsistent lineage"
+                        )));
+                    }
+                }
+            }
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "contact-orbit step semantic digest",
+            )?;
+        }
+        Ok(())
+    }
+
+    fn validate_color_contractions(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "color contraction",
+            self.color_contractions.iter().map(|row| row.id),
+            self.color_contractions
+                .iter()
+                .map(|row| row.template_string_id),
+        )?;
+        let ranges: Vec<_> = self
+            .color_contractions
+            .iter()
+            .map(|row| CheckedTableRange::new(row.nc_term_start, row.nc_term_count))
+            .collect();
+        validate_packed_ranges("color Nc polynomial", &ranges, self.color_nc_terms.len())?;
+        let witness_ranges: Vec<_> = self
+            .color_contractions
+            .iter()
+            .map(|row| CheckedTableRange::new(row.witness_start, row.witness_count))
+            .collect();
+        validate_packed_ranges(
+            "LC color transition witnesses",
+            &witness_ranges,
+            self.lc_color_transition_witnesses.len(),
+        )?;
+        for (index, row) in self.color_contractions.iter().enumerate() {
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::ColorContraction,
+                "color contraction",
+            )?;
+            register_semantic_digest(
+                semantic_digests,
+                row.semantic_digest_id,
+                "color contraction",
+            )?;
+            required_string(&catalogs.strings, row.template_string_id, "color template")?;
+            required_string(
+                &catalogs.strings,
+                row.rule_kind_string_id,
+                "color rule kind",
+            )?;
+            let input_representations = i32_sequence(
+                self,
+                row.input_representation_sequence_id,
+                "color input representations",
+            )?;
+            validate_color_contract_shape(
+                index,
+                input_representations,
+                row.has_output_representation,
+                row.output_representation,
+                row.ordered_open_string_arity,
+            )?;
+            let witnesses = &self.lc_color_transition_witnesses[witness_ranges[index]
+                .as_usize_range(
+                    self.lc_color_transition_witnesses.len(),
+                    "LC color transition witnesses",
+                )?];
+            if witnesses.is_empty() {
+                return Err(invalid(format!(
+                    "color contraction {index} has no executable LC transition witness"
+                )));
+            }
+            let has_output = row.has_output_representation == 1;
+            for (ordinal, witness) in witnesses.iter().enumerate() {
+                if witness.color_contraction_id as usize != index {
+                    return Err(invalid(format!(
+                        "LC color witness names contraction {}, expected {index}",
+                        witness.color_contraction_id
+                    )));
+                }
+                if witness.ordinal as usize != ordinal {
+                    return Err(invalid(format!(
+                        "LC color witness for contraction {index} has ordinal {}, expected {ordinal}",
+                        witness.ordinal
+                    )));
+                }
+                let left_shape = required_string(
+                    &catalogs.strings,
+                    witness.left_shape_string_id,
+                    "LC color witness left shape",
+                )?;
+                let right_shape = required_string(
+                    &catalogs.strings,
+                    witness.right_shape_string_id,
+                    "LC color witness right shape",
+                )?;
+                validate_lc_color_shape_name(left_shape, "LC color witness left shape")?;
+                validate_lc_color_shape_name(right_shape, "LC color witness right shape")?;
+                if input_representations.len() != 2 {
+                    return Err(invalid(format!(
+                        "LC color witness for contraction {index} requires exactly two input representations"
+                    )));
+                }
+                match witness.input_permutation {
+                    0 | 1 => {}
+                    value => {
+                        return Err(invalid(format!(
+                            "LC color witness input permutation must be 0 or 1, found {value}"
+                        )));
+                    }
+                }
+                for (shape, input) in [left_shape, right_shape].into_iter().zip([0usize, 1usize]) {
+                    validate_lc_color_shape(
+                        shape,
+                        input_representations[input],
+                        "LC color witness input",
+                    )?;
+                }
+                if witness.reverse_parent_mask > 3 {
+                    return Err(invalid(format!(
+                        "LC color witness reverse-parent mask {} exceeds two inputs",
+                        witness.reverse_parent_mask
+                    )));
+                }
+                let is_join = witness.component_operation == 0;
+                let is_close = witness.component_operation == 5;
+                if witness.component_operation > 5 {
+                    return Err(invalid(format!(
+                        "LC color witness operation {} is not supported",
+                        witness.component_operation
+                    )));
+                }
+                let component_kind = if witness.result_component_kind == u8::MAX {
+                    None
+                } else {
+                    Some(LCColorComponentKind::try_from(
+                        witness.result_component_kind,
+                    )?)
+                };
+                let component_role = LCColorComponentRole::try_from(witness.result_component_role)?;
+                if is_join {
+                    if component_kind.is_none() || component_role == LCColorComponentRole::None {
+                        return Err(invalid(
+                            "LC color join witness requires component kind and role",
+                        ));
+                    }
+                    let expected_role = if row.output_representation.abs() == 1 {
+                        LCColorComponentRole::Passive
+                    } else {
+                        LCColorComponentRole::Active
+                    };
+                    if component_role != expected_role {
+                        return Err(invalid(
+                            "LC color join role does not match its output representation",
+                        ));
+                    }
+                } else if is_close {
+                    if component_role != LCColorComponentRole::None {
+                        return Err(invalid("LC color closure result role must be none"));
+                    }
+                    let expected_kind = match input_representations {
+                        [left, right] if left.abs() == 1 && right.abs() == 1 => None,
+                        [left, right]
+                            if (*left == 3 && *right == -3) || (*left == -3 && *right == 3) =>
+                        {
+                            Some(LCColorComponentKind::OpenString)
+                        }
+                        [8, 8] => Some(LCColorComponentKind::Trace),
+                        _ => {
+                            return Err(invalid(
+                                "LC color closure has unsupported input representations",
+                            ));
+                        }
+                    };
+                    if component_kind != expected_kind {
+                        return Err(invalid(
+                            "LC color closure component kind does not match its inputs",
+                        ));
+                    }
+                } else {
+                    if component_kind.is_some() {
+                        return Err(invalid(
+                            "only LC color join/closure witnesses may declare a component kind",
+                        ));
+                    }
+                    let expected_role = if matches!(witness.component_operation, 2 | 3) {
+                        LCColorComponentRole::Active
+                    } else {
+                        LCColorComponentRole::None
+                    };
+                    if component_role != expected_role {
+                        return Err(invalid(
+                            "LC color witness result role does not match its operation",
+                        ));
+                    }
+                }
+                if is_close {
+                    if has_output || witness.result_shape_string_id != MISSING_U32 {
+                        return Err(invalid(
+                            "LC color closure witness must have neither an output representation nor a result shape",
+                        ));
+                    }
+                } else {
+                    if !has_output {
+                        return Err(invalid(
+                            "non-closure LC color witness requires an output representation",
+                        ));
+                    }
+                    let result_shape = required_string(
+                        &catalogs.strings,
+                        witness.result_shape_string_id,
+                        "LC color witness result shape",
+                    )?;
+                    validate_lc_color_shape(
+                        result_shape,
+                        row.output_representation,
+                        "LC color witness result",
+                    )?;
+                }
+                let factor = required_factor(
+                    &catalogs.factors,
+                    witness.exact_factor_id,
+                    "LC color witness factor",
+                )?;
+                if *factor == ExactComplexRational::ZERO {
+                    return Err(invalid("LC color witness factor must be nonzero"));
+                }
+                required_digest(
+                    &catalogs.digests,
+                    witness.proof_digest_id,
+                    "LC color witness proof",
+                )?;
+                let input_port_pairings = u32_sequence(
+                    self,
+                    witness.input_port_pairing_sequence_id,
+                    "LC color witness input-port pairings",
+                )?;
+                if input_port_pairings.len() % 4 != 0 {
+                    return Err(invalid(
+                        "LC color witness input-port pairings are not divisible by four",
+                    ));
+                }
+                let result_port_bindings = u32_sequence(
+                    self,
+                    witness.result_port_binding_sequence_id,
+                    "LC color witness result-port bindings",
+                )?;
+                if result_port_bindings.len() % 2 != 0 {
+                    return Err(invalid(
+                        "LC color witness result-port bindings are not divisible by two",
+                    ));
+                }
+                let mut consumed_ports = BTreeSet::new();
+                for port in input_port_pairings
+                    .chunks_exact(2)
+                    .chain(result_port_bindings.chunks_exact(2))
+                {
+                    let parent = port[0] as usize;
+                    let local = port[1] as usize;
+                    let representation = *input_representations.get(parent).ok_or_else(|| {
+                        invalid("LC color witness port references an absent parent")
+                    })?;
+                    let port_count = match representation {
+                        1 => 0,
+                        3 | -3 => 1,
+                        8 => 2,
+                        _ => {
+                            return Err(invalid(
+                                "LC color witness port uses an unsupported representation",
+                            ));
+                        }
+                    };
+                    if local >= port_count {
+                        return Err(invalid(
+                            "LC color witness port references an absent local port",
+                        ));
+                    }
+                    if !consumed_ports.insert((parent, local)) {
+                        return Err(invalid(
+                            "LC color witness consumes one parent port more than once",
+                        ));
+                    }
+                }
+                let expected_port_count = input_representations
+                    .iter()
+                    .map(|representation| match representation {
+                        1 => Ok(0_usize),
+                        3 | -3 => Ok(1),
+                        8 => Ok(2),
+                        _ => Err(invalid(
+                            "LC color witness uses an unsupported representation",
+                        )),
+                    })
+                    .sum::<RusticolResult<usize>>()?;
+                if consumed_ports.len() != expected_port_count {
+                    return Err(invalid(
+                        "LC color witness does not consume every parent port exactly once",
+                    ));
+                }
+                let provenance = u32_sequence(
+                    self,
+                    witness.provenance_sequence_id,
+                    "LC color witness provenance",
+                )?;
+                validate_string_pair_sequence(
+                    &catalogs.strings,
+                    provenance,
+                    "LC color witness provenance",
+                )?;
+            }
+            required_factor(
+                &catalogs.factors,
+                row.exact_coefficient_factor_id,
+                "color exact coefficient",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                row.expression_digest_id,
+                "color expression",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "color semantic digest",
+            )?;
+            let terms = &self.color_nc_terms
+                [ranges[index].as_usize_range(self.color_nc_terms.len(), "color Nc terms")?];
+            let mut previous_exponent = None;
+            for term in terms {
+                if term.color_contraction_id as usize != index {
+                    return Err(invalid(format!(
+                        "color Nc term names contraction {}, expected {index}",
+                        term.color_contraction_id
+                    )));
+                }
+                if term.exponent < 0 {
+                    return Err(invalid(format!(
+                        "color contraction {index} has a negative Nc exponent"
+                    )));
+                }
+                if let Some(previous_exponent) = previous_exponent
+                    && previous_exponent >= term.exponent
+                {
+                    return Err(invalid(format!(
+                        "color contraction {index} Nc powers are not strictly ordered"
+                    )));
+                }
+                let coefficient =
+                    required_factor(&catalogs.factors, term.factor_id, "color Nc coefficient")?;
+                if *coefficient == ExactComplexRational::ZERO {
+                    return Err(invalid(format!(
+                        "color contraction {index} retains an exact-zero Nc term"
+                    )));
+                }
+                previous_exponent = Some(term.exponent);
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_symmetry_proofs_basic(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "symmetry proof",
+            self.symmetry_proofs.iter().map(|row| row.id),
+            self.symmetry_proofs
+                .iter()
+                .map(|row| row.template_string_id),
+        )?;
+        for (index, row) in self.symmetry_proofs.iter().enumerate() {
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::SymmetryProof,
+                "symmetry proof",
+            )?;
+            register_semantic_digest(semantic_digests, row.semantic_digest_id, "symmetry proof")?;
+            required_string(&catalogs.strings, row.template_string_id, "proof template")?;
+            let algorithm = required_string(
+                &catalogs.strings,
+                row.proof_algorithm_string_id,
+                "proof algorithm",
+            )?;
+            if !is_supported_proof_algorithm(algorithm) {
+                return Err(invalid(format!(
+                    "symmetry proof {index} uses unsupported algorithm {algorithm:?}"
+                )));
+            }
+            let subjects = u32_sequence(self, row.subject_template_sequence_id, "proof subjects")?;
+            if subjects.is_empty() {
+                return Err(invalid(format!("symmetry proof {index} has no subjects")));
+            }
+            for subject in subjects {
+                required_string(&catalogs.strings, *subject, "proof subject template")?;
+            }
+            validate_permutation(
+                u32_sequence(
+                    self,
+                    row.input_permutation_sequence_id,
+                    "proof input permutation",
+                )?,
+                "proof input permutation",
+            )?;
+            let phase = required_factor(
+                &catalogs.factors,
+                row.exact_phase_factor_id,
+                "proof exact phase",
+            )?;
+            if *phase == ExactComplexRational::ZERO {
+                return Err(invalid(format!("symmetry proof {index} has zero phase")));
+            }
+            let expressions = u32_sequence(
+                self,
+                row.expression_digest_sequence_id,
+                "proof expression digests",
+            )?;
+            if expressions.is_empty() {
+                return Err(invalid(format!(
+                    "symmetry proof {index} has no expression digests"
+                )));
+            }
+            validate_u32_references(
+                expressions,
+                catalogs.digests.len(),
+                "proof expression digests",
+            )?;
+            required_digest(&catalogs.digests, row.witness_digest_id, "proof witness")?;
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "proof semantic digest",
+            )?;
+        }
+        Ok(())
+    }
+
+    fn validate_transitions_basic(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "transition",
+            self.transitions.iter().map(|row| row.id),
+            self.transitions.iter().map(|row| row.template_string_id),
+        )?;
+        for (index, row) in self.transitions.iter().enumerate() {
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::Transition,
+                "transition",
+            )?;
+            register_semantic_digest(semantic_digests, row.semantic_digest_id, "transition")?;
+            required_string(
+                &catalogs.strings,
+                row.template_string_id,
+                "transition template",
+            )?;
+            let inputs =
+                u32_sequence(self, row.input_state_sequence_id, "transition input states")?;
+            if inputs.is_empty() {
+                return Err(invalid(format!("transition {index} has no inputs")));
+            }
+            validate_u32_references(inputs, self.current_states.len(), "transition input states")?;
+            required_reference(
+                row.result_state_template_id,
+                self.current_states.len(),
+                "transition result state",
+            )?;
+            required_reference(
+                row.quantum_flow_template_id,
+                self.quantum_flows.len(),
+                "transition quantum flow",
+            )?;
+            required_reference(
+                row.evaluator_binding_id,
+                self.evaluator_bindings.len(),
+                "transition evaluator",
+            )?;
+            let permutation = u32_sequence(
+                self,
+                row.canonical_input_order_sequence_id,
+                "transition canonical input order",
+            )?;
+            validate_permutation_of(
+                permutation,
+                inputs.len(),
+                "transition canonical input order",
+            )?;
+            let momentum = u32_sequence(
+                self,
+                row.momentum_convention_sequence_id,
+                "transition momentum convention",
+            )?;
+            if momentum.len() != inputs.len() {
+                return Err(invalid(format!(
+                    "transition {index} momentum convention does not cover every input"
+                )));
+            }
+            for string_id in momentum {
+                required_string(
+                    &catalogs.strings,
+                    *string_id,
+                    "transition momentum convention",
+                )?;
+            }
+            let parameters = u32_sequence(
+                self,
+                row.coupling_parameter_sequence_id,
+                "transition coupling parameters",
+            )?;
+            validate_strict_u32(parameters, "transition coupling parameters")?;
+            validate_u32_references(
+                parameters,
+                self.parameters.len(),
+                "transition coupling parameters",
+            )?;
+            required_reference(
+                row.coupling_order_set_id,
+                self.coupling_order_ranges.len(),
+                "transition coupling-order set",
+            )?;
+            required_reference(
+                row.color_contraction_template_id,
+                self.color_contractions.len(),
+                "transition color contraction",
+            )?;
+            required_factor(
+                &catalogs.factors,
+                row.binding_coupling_factor_id,
+                "transition binding coupling",
+            )?;
+            required_factor(
+                &catalogs.factors,
+                row.exact_factor_id,
+                "transition exact factor",
+            )?;
+            OutputFactorSource::try_from(row.output_factor_source)?;
+            required_string(
+                &catalogs.strings,
+                row.equivalence_class_string_id,
+                "transition equivalence class",
+            )?;
+            if let Some(factor) = optional_factor(
+                &catalogs.factors,
+                row.input_exchange_factor_id,
+                "transition input-exchange factor",
+            )? && *factor == ExactComplexRational::ZERO
+            {
+                return Err(invalid(format!(
+                    "transition {index} has a zero input-exchange factor"
+                )));
+            }
+            required_string(
+                &catalogs.strings,
+                row.output_projection_string_id,
+                "transition output projection",
+            )?;
+            let contact_orbit_steps = u32_sequence(
+                self,
+                row.contact_orbit_step_sequence_id,
+                "transition contact-orbit steps",
+            )?;
+            let contact_orbit_step_digests = u32_sequence(
+                self,
+                row.contact_orbit_step_semantic_digest_sequence_id,
+                "transition contact-orbit step semantic digests",
+            )?;
+            if contact_orbit_steps.len() != contact_orbit_step_digests.len() {
+                return Err(invalid(format!(
+                    "transition {index} has incomplete contact-orbit step bindings"
+                )));
+            }
+            if contact_orbit_steps
+                .windows(2)
+                .any(|pair| pair[0] >= pair[1])
+            {
+                return Err(invalid(format!(
+                    "transition {index} contact-orbit steps are not canonical"
+                )));
+            }
+            for (&step_id, &step_digest_id) in
+                contact_orbit_steps.iter().zip(contact_orbit_step_digests)
+            {
+                let step_index = required_reference(
+                    step_id,
+                    self.contact_orbit_steps.len(),
+                    "transition contact-orbit step",
+                )?;
+                let expected_digest_id = self.contact_orbit_steps[step_index].semantic_digest_id;
+                if step_digest_id != expected_digest_id {
+                    return Err(invalid(format!(
+                        "transition {index} contact-orbit step digest does not match its record"
+                    )));
+                }
+                required_digest(
+                    &catalogs.digests,
+                    step_digest_id,
+                    "transition contact-orbit step semantic digest",
+                )?;
+            }
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "transition semantic digest",
+            )?;
+
+            let flow = self.quantum_flows[row.quantum_flow_template_id as usize];
+            let flow_inputs = u32_sequence(
+                self,
+                flow.input_state_sequence_id,
+                "quantum-flow input states",
+            )?;
+            if inputs != flow_inputs
+                || row.result_state_template_id != flow.result_state_template_id
+                || row.coupling_order_set_id != flow.coupling_order_set_id
+            {
+                return Err(invalid(format!(
+                    "transition {index} and quantum-flow state/coupling contracts do not match"
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_propagators_basic(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "propagator",
+            self.propagators.iter().map(|row| row.id),
+            self.propagators.iter().map(|row| row.template_string_id),
+        )?;
+        let mut state_owners = vec![None; self.current_states.len()];
+        for (index, row) in self.propagators.iter().enumerate() {
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::Propagator,
+                "propagator",
+            )?;
+            register_semantic_digest(semantic_digests, row.semantic_digest_id, "propagator")?;
+            required_string(
+                &catalogs.strings,
+                row.template_string_id,
+                "propagator template",
+            )?;
+            let state = required_reference(
+                row.state_template_id,
+                self.current_states.len(),
+                "propagator state",
+            )?;
+            if let Some(previous) = state_owners[state].replace(index) {
+                return Err(invalid(format!(
+                    "current state {state} has propagator rows {previous} and {index}"
+                )));
+            }
+            let active = validate_bool(row.applies_propagator, "applies_propagator")?;
+            let evaluator = optional_reference(
+                row.evaluator_binding_id,
+                self.evaluator_bindings.len(),
+                "propagator evaluator",
+            )?;
+            let numerator = optional_digest(
+                &catalogs.digests,
+                row.numerator_expression_digest_id,
+                "propagator numerator",
+            )?;
+            let denominator = optional_digest(
+                &catalogs.digests,
+                row.denominator_expression_digest_id,
+                "propagator denominator",
+            )?;
+            if active {
+                if evaluator.is_none() || numerator.is_none() || denominator.is_none() {
+                    return Err(invalid(format!(
+                        "active propagator {index} requires evaluator, numerator, and denominator"
+                    )));
+                }
+            } else if evaluator.is_some() || numerator.is_some() || denominator.is_some() {
+                return Err(invalid(format!(
+                    "identity propagator {index} carries evaluator or expression metadata"
+                )));
+            }
+            optional_reference(
+                row.mass_parameter_id,
+                self.parameters.len(),
+                "propagator mass parameter",
+            )?;
+            optional_reference(
+                row.width_parameter_id,
+                self.parameters.len(),
+                "propagator width parameter",
+            )?;
+            optional_string(&catalogs.strings, row.gauge_string_id, "propagator gauge")?;
+            optional_reference(
+                row.linearity_proof_template_id,
+                self.symmetry_proofs.len(),
+                "propagator linearity proof",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "propagator semantic digest",
+            )?;
+        }
+        if let Some((state, _)) = state_owners
+            .iter()
+            .enumerate()
+            .find(|(_, owner)| owner.is_none())
+        {
+            return Err(invalid(format!(
+                "current state {state} has no active or identity propagator"
+            )));
+        }
+        Ok(())
+    }
+
+    fn validate_closures_basic(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &mut BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<()> {
+        validate_record_ids(
+            "closure",
+            self.closures.iter().map(|row| row.id),
+            self.closures.iter().map(|row| row.template_string_id),
+        )?;
+        for (index, row) in self.closures.iter().enumerate() {
+            register_template(
+                template_kinds,
+                row.template_string_id,
+                TemplateKind::Closure,
+                "closure",
+            )?;
+            register_semantic_digest(semantic_digests, row.semantic_digest_id, "closure")?;
+            required_string(
+                &catalogs.strings,
+                row.template_string_id,
+                "closure template",
+            )?;
+            let inputs = u32_sequence(self, row.input_state_sequence_id, "closure input states")?;
+            if inputs.is_empty() {
+                return Err(invalid(format!("closure {index} has no inputs")));
+            }
+            validate_u32_references(inputs, self.current_states.len(), "closure input states")?;
+            let result_state = optional_reference(
+                row.result_state_template_id,
+                self.current_states.len(),
+                "closure result state",
+            )?;
+            required_reference(
+                row.evaluator_binding_id,
+                self.evaluator_bindings.len(),
+                "closure evaluator",
+            )?;
+            validate_permutation_of(
+                u32_sequence(
+                    self,
+                    row.canonical_input_order_sequence_id,
+                    "closure canonical input order",
+                )?,
+                inputs.len(),
+                "closure canonical input order",
+            )?;
+            let parameters = u32_sequence(
+                self,
+                row.coupling_parameter_sequence_id,
+                "closure coupling parameters",
+            )?;
+            validate_strict_u32(parameters, "closure coupling parameters")?;
+            validate_u32_references(
+                parameters,
+                self.parameters.len(),
+                "closure coupling parameters",
+            )?;
+            required_reference(
+                row.coupling_order_set_id,
+                self.coupling_order_ranges.len(),
+                "closure coupling-order set",
+            )?;
+            let eligible_flows = u32_sequence(
+                self,
+                row.eligible_quantum_flow_sequence_id,
+                "closure eligible quantum flows",
+            )?;
+            validate_strict_u32(eligible_flows, "closure eligible quantum flows")?;
+            validate_u32_references(
+                eligible_flows,
+                self.quantum_flows.len(),
+                "closure eligible quantum flows",
+            )?;
+            let evaluator = &self.evaluator_bindings[row.evaluator_binding_id as usize];
+            match EvaluatorCallableKind::try_from(evaluator.callable_kind)? {
+                EvaluatorCallableKind::PreparedKernel if eligible_flows.is_empty() => {
+                    return Err(invalid(format!(
+                        "prepared closure {index} has no eligible quantum-flow witness"
+                    )));
+                }
+                EvaluatorCallableKind::RusticolTemplate if !eligible_flows.is_empty() => {
+                    return Err(invalid(format!(
+                        "direct Rusticol closure {index} carries prepared quantum-flow witnesses"
+                    )));
+                }
+                EvaluatorCallableKind::PreparedKernel if result_state.is_none() => {
+                    return Err(invalid(format!(
+                        "prepared closure {index} has no result-state contract"
+                    )));
+                }
+                EvaluatorCallableKind::RusticolTemplate if result_state.is_some() => {
+                    return Err(invalid(format!(
+                        "direct Rusticol closure {index} carries a result-state contract"
+                    )));
+                }
+                _ => {}
+            }
+            for flow_id in eligible_flows {
+                let flow = &self.quantum_flows[*flow_id as usize];
+                let flow_inputs = u32_sequence(
+                    self,
+                    flow.input_state_sequence_id,
+                    "closure quantum-flow input states",
+                )?;
+                if flow_inputs != inputs {
+                    return Err(invalid(format!(
+                        "closure {index} and eligible quantum flow {flow_id} have different input-state contracts"
+                    )));
+                }
+                if Some(flow.result_state_template_id as usize) != result_state {
+                    return Err(invalid(format!(
+                        "closure {index} and eligible quantum flow {flow_id} have different result-state contracts"
+                    )));
+                }
+                if flow.coupling_order_set_id != row.coupling_order_set_id {
+                    return Err(invalid(format!(
+                        "closure {index} and eligible quantum flow {flow_id} have different coupling-order contracts"
+                    )));
+                }
+            }
+            required_reference(
+                row.color_contraction_template_id,
+                self.color_contractions.len(),
+                "closure color contraction",
+            )?;
+            required_factor(
+                &catalogs.factors,
+                row.binding_coupling_factor_id,
+                "closure binding coupling",
+            )?;
+            required_factor(
+                &catalogs.factors,
+                row.exact_factor_id,
+                "closure exact factor",
+            )?;
+            OutputFactorSource::try_from(row.output_factor_source)?;
+            required_string(
+                &catalogs.strings,
+                row.equivalence_class_string_id,
+                "closure equivalence class",
+            )?;
+            if let Some(factor) = optional_factor(
+                &catalogs.factors,
+                row.input_exchange_factor_id,
+                "closure input-exchange factor",
+            )? && *factor == ExactComplexRational::ZERO
+            {
+                return Err(invalid(format!(
+                    "closure {index} has a zero input-exchange factor"
+                )));
+            }
+            required_string(
+                &catalogs.strings,
+                row.projection_string_id,
+                "closure projection",
+            )?;
+            let coefficients = u32_sequence(
+                self,
+                row.component_coefficient_sequence_id,
+                "closure component coefficients",
+            )?;
+            validate_u32_references(
+                coefficients,
+                catalogs.factors.len(),
+                "closure component coefficients",
+            )?;
+            let chirality = required_string(
+                &catalogs.strings,
+                row.chirality_relation_string_id,
+                "closure chirality relation",
+            )?;
+            if !matches!(chirality, "any" | "equal" | "opposite") {
+                return Err(invalid(format!(
+                    "closure {index} has unsupported chirality relation {chirality:?}"
+                )));
+            }
+            optional_string(
+                &catalogs.strings,
+                row.metric_signature_string_id,
+                "closure metric signature",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "closure semantic digest",
+            )?;
+        }
+        Ok(())
+    }
+
+    fn validate_evaluators(
+        self,
+        catalogs: &ValidatedCatalogs<'_>,
+        template_kinds: &BTreeMap<u32, TemplateKind>,
+        semantic_digests: &mut BTreeSet<u32>,
+    ) -> RusticolResult<u32> {
+        validate_record_ids(
+            "evaluator binding",
+            self.evaluator_bindings.iter().map(|row| row.id),
+            self.evaluator_bindings
+                .iter()
+                .map(|row| row.resolver_key_string_id),
+        )?;
+        let mut prepared_contracts = BTreeMap::new();
+        let mut runtime_contracts = BTreeMap::new();
+        let mut semantic_owners = BTreeMap::new();
+        let mut prepared_ids = BTreeSet::new();
+        for (index, row) in self.evaluator_bindings.iter().enumerate() {
+            register_semantic_digest(
+                semantic_digests,
+                row.semantic_digest_id,
+                "evaluator binding",
+            )?;
+            required_string(
+                &catalogs.strings,
+                row.resolver_key_string_id,
+                "evaluator resolver key",
+            )?;
+            let contract_kind = EvaluatorContractKind::try_from(row.contract_kind)?;
+            let callable_kind = EvaluatorCallableKind::try_from(row.callable_kind)?;
+            required_digest(
+                &catalogs.digests,
+                row.callable_signature_digest_id,
+                "evaluator callable signature",
+            )?;
+            required_digest(
+                &catalogs.digests,
+                row.semantic_digest_id,
+                "evaluator semantic digest",
+            )?;
+            let inputs = u32_sequence(self, row.input_state_sequence_id, "evaluator input states")?;
+            validate_u32_references(inputs, self.current_states.len(), "evaluator input states")?;
+            let output = optional_reference(
+                row.output_state_template_id,
+                self.current_states.len(),
+                "evaluator output state",
+            )?;
+            let input_layout =
+                u32_sequence(self, row.input_layout_sequence_id, "evaluator input layout")?;
+            let output_layout = u32_sequence(
+                self,
+                row.output_layout_sequence_id,
+                "evaluator output layout",
+            )?;
+            let exact_expressions = u32_sequence(
+                self,
+                row.exact_expression_digest_sequence_id,
+                "evaluator exact expressions",
+            )?;
+            if input_layout.is_empty() || output_layout.is_empty() || exact_expressions.is_empty() {
+                return Err(invalid(format!(
+                    "evaluator binding {index} has an empty layout or expression contract"
+                )));
+            }
+            validate_u32_references(
+                input_layout,
+                catalogs.strings.len(),
+                "evaluator input layout",
+            )?;
+            validate_u32_references(
+                output_layout,
+                catalogs.strings.len(),
+                "evaluator output layout",
+            )?;
+            validate_u32_references(
+                exact_expressions,
+                catalogs.digests.len(),
+                "evaluator exact expressions",
+            )?;
+            if output_layout.len() != exact_expressions.len() {
+                return Err(invalid(format!(
+                    "evaluator binding {index} output layout and exact expressions do not align"
+                )));
+            }
+            if let Some(output) = output
+                && output_layout.len() != self.current_states[output].dimension as usize
+            {
+                return Err(invalid(format!(
+                    "evaluator binding {index} output layout does not match state dimension"
+                )));
+            }
+            match contract_kind {
+                EvaluatorContractKind::Source
+                | EvaluatorContractKind::Vertex
+                | EvaluatorContractKind::Propagator => {
+                    if output.is_none() {
+                        return Err(invalid(format!(
+                            "evaluator binding {index} requires an output state"
+                        )));
+                    }
+                }
+                EvaluatorContractKind::Closure | EvaluatorContractKind::ModelParameter => {
+                    if output.is_some() {
+                        return Err(invalid(format!(
+                            "evaluator binding {index} cannot produce a current state"
+                        )));
+                    }
+                }
+            }
+            match callable_kind {
+                EvaluatorCallableKind::PreparedKernel => {
+                    if row.prepared_kernel_id == MISSING_U32
+                        || row.runtime_template_string_id != MISSING_U32
+                    {
+                        return Err(invalid(format!(
+                            "prepared-kernel evaluator binding {index} has invalid callable identity"
+                        )));
+                    }
+                    prepared_ids.insert(row.prepared_kernel_id);
+                }
+                EvaluatorCallableKind::RusticolTemplate => {
+                    if row.prepared_kernel_id != MISSING_U32
+                        || row.runtime_template_string_id == MISSING_U32
+                    {
+                        return Err(invalid(format!(
+                            "Rusticol-template evaluator binding {index} has invalid callable identity"
+                        )));
+                    }
+                    required_string(
+                        &catalogs.strings,
+                        row.runtime_template_string_id,
+                        "evaluator runtime template",
+                    )?;
+                    validate_rusticol_runtime_template(catalogs, row, contract_kind, index)?;
+                }
+            }
+
+            let semantic_templates = u32_sequence(
+                self,
+                row.semantic_template_sequence_id,
+                "evaluator semantic templates",
+            )?;
+            if semantic_templates.is_empty() {
+                return Err(invalid(format!(
+                    "evaluator binding {index} has no semantic templates"
+                )));
+            }
+            validate_strict_u32(semantic_templates, "evaluator semantic templates")?;
+            for template in semantic_templates {
+                let template_kind = template_kinds.get(template).ok_or_else(|| {
+                    invalid(format!(
+                        "evaluator binding {index} references unknown semantic template string id {template}"
+                    ))
+                })?;
+                if template_kind.evaluator_contract() != Some(contract_kind) {
+                    return Err(invalid(format!(
+                        "evaluator binding {index} contract kind does not match semantic template {template}"
+                    )));
+                }
+                if let Some(previous) = semantic_owners.insert(*template, index)
+                    && previous != index
+                {
+                    return Err(invalid(format!(
+                        "semantic template {template} belongs to evaluator bindings {previous} and {index}"
+                    )));
+                }
+            }
+
+            let callable_contract = CallableContractKey {
+                contract_kind,
+                callable_signature_digest_id: row.callable_signature_digest_id,
+                input_layout: input_layout.to_vec(),
+                output_layout: output_layout.to_vec(),
+                exact_expression_digests: exact_expressions.to_vec(),
+            };
+            let (owner, previous) = match callable_kind {
+                EvaluatorCallableKind::PreparedKernel => (
+                    "prepared kernel ID",
+                    prepared_contracts.insert(row.prepared_kernel_id, callable_contract.clone()),
+                ),
+                EvaluatorCallableKind::RusticolTemplate => (
+                    "Rusticol runtime template",
+                    runtime_contracts
+                        .insert(row.runtime_template_string_id, callable_contract.clone()),
+                ),
+            };
+            if previous.is_some_and(|previous| previous != callable_contract) {
+                return Err(invalid(format!(
+                    "{owner} has inconsistent evaluator callable contracts"
+                )));
+            }
+        }
+        checked_len(prepared_ids.len(), "prepared kernels")
+    }
+
+    fn validate_proof_subjects(
+        self,
+        template_kinds: &BTreeMap<u32, TemplateKind>,
+    ) -> RusticolResult<()> {
+        for (index, proof) in self.symmetry_proofs.iter().enumerate() {
+            let subjects =
+                u32_sequence(self, proof.subject_template_sequence_id, "proof subjects")?;
+            for subject in subjects {
+                if !template_kinds.contains_key(subject) {
+                    return Err(invalid(format!(
+                        "symmetry proof {index} references unknown template string id {subject}"
+                    )));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_evaluator_state_contracts(
+        self,
+        _template_kinds: &BTreeMap<u32, TemplateKind>,
+    ) -> RusticolResult<()> {
+        for source in self.sources {
+            self.validate_evaluator_contract(
+                source.evaluator_binding_id,
+                EvaluatorContractKind::Source,
+                &[],
+                Some(source.state_template_id),
+                source.template_string_id,
+            )?;
+        }
+        for transition in self.transitions {
+            self.validate_evaluator_contract(
+                transition.evaluator_binding_id,
+                EvaluatorContractKind::Vertex,
+                u32_sequence(
+                    self,
+                    transition.input_state_sequence_id,
+                    "transition states",
+                )?,
+                Some(transition.result_state_template_id),
+                transition.template_string_id,
+            )?;
+        }
+        for propagator in self.propagators {
+            if propagator.evaluator_binding_id != MISSING_U32 {
+                self.validate_evaluator_contract(
+                    propagator.evaluator_binding_id,
+                    EvaluatorContractKind::Propagator,
+                    &[propagator.state_template_id],
+                    Some(propagator.state_template_id),
+                    propagator.template_string_id,
+                )?;
+            }
+        }
+        for closure in self.closures {
+            self.validate_evaluator_contract(
+                closure.evaluator_binding_id,
+                EvaluatorContractKind::Closure,
+                u32_sequence(self, closure.input_state_sequence_id, "closure states")?,
+                None,
+                closure.template_string_id,
+            )?;
+        }
+        Ok(())
+    }
+
+    fn validate_evaluator_contract(
+        self,
+        evaluator_id: u32,
+        expected_kind: EvaluatorContractKind,
+        expected_inputs: &[u32],
+        expected_output: Option<u32>,
+        semantic_template_string_id: u32,
+    ) -> RusticolResult<()> {
+        let evaluator = self
+            .evaluator_bindings
+            .get(evaluator_id as usize)
+            .ok_or_else(|| invalid(format!("unknown evaluator binding {evaluator_id}")))?;
+        if EvaluatorContractKind::try_from(evaluator.contract_kind)? != expected_kind {
+            return Err(invalid(format!(
+                "semantic template string id {semantic_template_string_id} uses the wrong evaluator contract kind"
+            )));
+        }
+        let inputs = u32_sequence(self, evaluator.input_state_sequence_id, "evaluator states")?;
+        if inputs != expected_inputs {
+            return Err(invalid(format!(
+                "semantic template string id {semantic_template_string_id} evaluator input states do not match"
+            )));
+        }
+        if optional_id(evaluator.output_state_template_id) != expected_output {
+            return Err(invalid(format!(
+                "semantic template string id {semantic_template_string_id} evaluator output state does not match"
+            )));
+        }
+        let templates = u32_sequence(
+            self,
+            evaluator.semantic_template_sequence_id,
+            "evaluator semantic templates",
+        )?;
+        if templates
+            .binary_search(&semantic_template_string_id)
+            .is_err()
+        {
+            return Err(invalid(format!(
+                "semantic template string id {semantic_template_string_id} is absent from its evaluator binding"
+            )));
+        }
+        Ok(())
+    }
+}
+
+fn validate_rusticol_runtime_template(
+    catalogs: &ValidatedCatalogs<'_>,
+    row: &EvaluatorBindingRow,
+    contract_kind: EvaluatorContractKind,
+    index: usize,
+) -> RusticolResult<()> {
+    let runtime_template = required_string(
+        &catalogs.strings,
+        row.runtime_template_string_id,
+        "evaluator runtime template",
+    )?;
+    let signature = required_digest(
+        &catalogs.digests,
+        row.callable_signature_digest_id,
+        "evaluator callable signature",
+    )?
+    .to_string();
+    let signature_suffix = &signature[..24];
+    match contract_kind {
+        EvaluatorContractKind::Source => {
+            const PREFIX: &str = "rusticol.source-fill.";
+            let suffix = format!(".v1:{signature_suffix}");
+            let family = runtime_template
+                .strip_prefix(PREFIX)
+                .and_then(|value| value.strip_suffix(&suffix))
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "Rusticol source evaluator binding {index} has an unauthenticated runtime template"
+                    ))
+                })?;
+            if !matches!(
+                family,
+                "scalar" | "fermion" | "vector" | "spin2" | "ghost" | "auxiliary"
+            ) {
+                return Err(invalid(format!(
+                    "Rusticol source evaluator binding {index} has unsupported family {family:?}"
+                )));
+            }
+        }
+        EvaluatorContractKind::Closure => {
+            let expected = format!("rusticol.closure-reduce.v1:{signature_suffix}");
+            if runtime_template != expected {
+                return Err(invalid(format!(
+                    "Rusticol closure evaluator binding {index} has an unauthenticated runtime template"
+                )));
+            }
+        }
+        _ => {
+            return Err(invalid(format!(
+                "Rusticol runtime templates are not registered for evaluator binding {index} contract {contract_kind:?}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_indexed_ranges(
+    label: &str,
+    ranges: &[IndexedRangeRow],
+    value_len: usize,
+) -> RusticolResult<()> {
+    validate_canonical_ids(label, ranges.iter().map(|row| row.id))?;
+    let checked: Vec<_> = ranges.iter().map(|row| row.range).collect();
+    validate_packed_ranges(label, &checked, value_len)
+}
+
+fn validate_sequence_catalog<T: Ord>(
+    label: &str,
+    ranges: &[IndexedRangeRow],
+    values: &[T],
+    require_nonempty: bool,
+) -> RusticolResult<()> {
+    validate_indexed_ranges(label, ranges, values.len())?;
+    let mut previous: Option<&[T]> = None;
+    for (index, row) in ranges.iter().enumerate() {
+        let sequence = &values[row.range.as_usize_range(values.len(), label)?];
+        if require_nonempty && sequence.is_empty() {
+            return Err(invalid(format!("{label} row {index} is empty")));
+        }
+        if let Some(previous) = previous
+            && previous >= sequence
+        {
+            return Err(invalid(format!(
+                "{label} is not in strict canonical order at row {index}"
+            )));
+        }
+        previous = Some(sequence);
+    }
+    Ok(())
+}
+
+fn validate_canonical_ids(label: &str, ids: impl IntoIterator<Item = u32>) -> RusticolResult<()> {
+    for (index, id) in ids.into_iter().enumerate() {
+        if usize::try_from(id).ok() != Some(index) {
+            return Err(invalid(format!(
+                "{label} row {index} has noncanonical id {id}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_record_ids(
+    label: &str,
+    ids: impl IntoIterator<Item = u32>,
+    identity_string_ids: impl IntoIterator<Item = u32>,
+) -> RusticolResult<()> {
+    validate_canonical_ids(label, ids)?;
+    let mut previous = None;
+    for (index, id) in identity_string_ids.into_iter().enumerate() {
+        if let Some(previous) = previous
+            && previous >= id
+        {
+            return Err(invalid(format!(
+                "{label} records are not in strict semantic-identity order at row {index}"
+            )));
+        }
+        previous = Some(id);
+    }
+    Ok(())
+}
+
+fn validate_bool(value: u8, label: &str) -> RusticolResult<bool> {
+    match value {
+        0 => Ok(false),
+        1 => Ok(true),
+        _ => Err(invalid(format!(
+            "{label} must be encoded as 0 or 1, found {value}"
+        ))),
+    }
+}
+
+fn validate_color_contract_shape(
+    row: usize,
+    input_representations: &[i32],
+    has_output_representation: u8,
+    output_representation: i32,
+    ordered_open_string_arity: u32,
+) -> RusticolResult<()> {
+    let has_output = validate_bool(
+        has_output_representation,
+        "color output-representation presence",
+    )?;
+    if !has_output && output_representation != 0 {
+        return Err(invalid(format!(
+            "color contraction {row} has no output representation but carries nonzero payload {output_representation}"
+        )));
+    }
+
+    // Every ordered open string has two endpoints. This slot-count bound is
+    // representation independent and therefore also applies to external
+    // models using an otherwise unknown representation encoding.
+    let endpoint_slots = input_representations
+        .len()
+        .checked_add(usize::from(has_output))
+        .ok_or_else(|| invalid("color endpoint-slot count exceeds usize"))?;
+    let arity = usize::try_from(ordered_open_string_arity)
+        .map_err(|_| invalid("color open-string arity exceeds usize"))?;
+    if arity > endpoint_slots / 2 {
+        return Err(invalid(format!(
+            "color contraction {row} declares {arity} ordered open strings but has only {endpoint_slots} endpoint slots"
+        )));
+    }
+
+    let representations_are_standard = input_representations
+        .iter()
+        .copied()
+        .chain(has_output.then_some(output_representation))
+        .all(|value| matches!(value, -3 | 1 | 3 | 8));
+    if representations_are_standard {
+        let fundamental_endpoints = input_representations
+            .iter()
+            .copied()
+            .chain(has_output.then_some(output_representation))
+            .filter(|value| matches!(value, -3 | 3))
+            .count();
+        if arity > fundamental_endpoints / 2 {
+            return Err(invalid(format!(
+                "color contraction {row} declares {arity} ordered open strings but its standard representations provide only {fundamental_endpoints} fundamental endpoints"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_lc_color_shape_name(value: &str, label: &str) -> RusticolResult<()> {
+    if matches!(
+        value,
+        "singlet-forest"
+            | "fundamental-open-string"
+            | "antifundamental-open-string"
+            | "adjoint-segment"
+    ) {
+        Ok(())
+    } else {
+        Err(invalid(format!(
+            "{label} has unsupported LC color shape {value:?}"
+        )))
+    }
+}
+
+fn validate_lc_color_shape(value: &str, representation: i32, label: &str) -> RusticolResult<()> {
+    validate_lc_color_shape_name(value, label)?;
+    let expected = match representation {
+        1 => "singlet-forest",
+        3 => "fundamental-open-string",
+        -3 => "antifundamental-open-string",
+        8 => "adjoint-segment",
+        other => {
+            return Err(invalid(format!(
+                "{label} uses unsupported LC representation {other}"
+            )));
+        }
+    };
+    if value != expected {
+        return Err(invalid(format!(
+            "{label} maps LC representation {representation} to {value:?}, expected {expected:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn checked_len(length: usize, label: &str) -> RusticolResult<u32> {
+    u32::try_from(length).map_err(|_| invalid(format!("{label} count {length} exceeds u32")))
+}
+
+fn required_reference(value: u32, target_len: usize, label: &str) -> RusticolResult<usize> {
+    let value =
+        usize::try_from(value).map_err(|_| invalid(format!("{label} id {value} exceeds usize")))?;
+    if value >= target_len {
+        return Err(invalid(format!(
+            "{label} id {value} exceeds target length {target_len}"
+        )));
+    }
+    Ok(value)
+}
+
+fn optional_reference(value: u32, target_len: usize, label: &str) -> RusticolResult<Option<usize>> {
+    if value == MISSING_U32 {
+        Ok(None)
+    } else {
+        required_reference(value, target_len, label).map(Some)
+    }
+}
+
+const fn optional_id(value: u32) -> Option<u32> {
+    if value == MISSING_U32 {
+        None
+    } else {
+        Some(value)
+    }
+}
+
+fn required_string<'a>(strings: &[&'a str], id: u32, label: &str) -> RusticolResult<&'a str> {
+    strings
+        .get(required_reference(id, strings.len(), label)?)
+        .copied()
+        .ok_or_else(|| invalid(format!("{label} is absent")))
+}
+
+fn optional_string<'a>(
+    strings: &[&'a str],
+    id: u32,
+    label: &str,
+) -> RusticolResult<Option<&'a str>> {
+    optional_reference(id, strings.len(), label)?
+        .map(|index| {
+            strings
+                .get(index)
+                .copied()
+                .ok_or_else(|| invalid(format!("{label} is absent")))
+        })
+        .transpose()
+}
+
+fn require_string_value(
+    strings: &[&str],
+    id: u32,
+    expected: &str,
+    label: &str,
+) -> RusticolResult<()> {
+    let actual = required_string(strings, id, label)?;
+    if actual != expected {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported {label} {actual:?}; expected {expected:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn required_digest(
+    digests: &[SemanticDigest],
+    id: u32,
+    label: &str,
+) -> RusticolResult<SemanticDigest> {
+    digests
+        .get(required_reference(id, digests.len(), label)?)
+        .copied()
+        .ok_or_else(|| invalid(format!("{label} is absent")))
+}
+
+fn validate_string_pair_sequence(
+    strings: &[&str],
+    values: &[u32],
+    label: &str,
+) -> RusticolResult<()> {
+    if !values.len().is_multiple_of(2) {
+        return Err(invalid(format!("{label} must contain key/value pairs")));
+    }
+    let mut previous_key = None;
+    for pair in values.chunks_exact(2) {
+        let key = required_string(strings, pair[0], &format!("{label} key"))?;
+        required_string(strings, pair[1], &format!("{label} value"))?;
+        if previous_key.is_some_and(|previous| previous >= key) {
+            return Err(invalid(format!("{label} keys must be sorted and unique")));
+        }
+        previous_key = Some(key);
+    }
+    Ok(())
+}
+
+fn optional_digest(
+    digests: &[SemanticDigest],
+    id: u32,
+    label: &str,
+) -> RusticolResult<Option<SemanticDigest>> {
+    optional_reference(id, digests.len(), label)?
+        .map(|index| {
+            digests
+                .get(index)
+                .copied()
+                .ok_or_else(|| invalid(format!("{label} is absent")))
+        })
+        .transpose()
+}
+
+fn required_factor<'a>(
+    factors: &'a [ExactComplexRational],
+    id: u32,
+    label: &str,
+) -> RusticolResult<&'a ExactComplexRational> {
+    factors
+        .get(required_reference(id, factors.len(), label)?)
+        .ok_or_else(|| invalid(format!("{label} is absent")))
+}
+
+fn optional_factor<'a>(
+    factors: &'a [ExactComplexRational],
+    id: u32,
+    label: &str,
+) -> RusticolResult<Option<&'a ExactComplexRational>> {
+    optional_reference(id, factors.len(), label)?
+        .map(|index| {
+            factors
+                .get(index)
+                .ok_or_else(|| invalid(format!("{label} is absent")))
+        })
+        .transpose()
+}
+
+fn sequence<'a, T>(
+    ranges: &[IndexedRangeRow],
+    values: &'a [T],
+    id: u32,
+    label: &str,
+) -> RusticolResult<&'a [T]> {
+    let row = ranges
+        .get(required_reference(id, ranges.len(), label)?)
+        .ok_or_else(|| invalid(format!("{label} range is absent")))?;
+    let range = row.range.as_usize_range(values.len(), label)?;
+    Ok(&values[range])
+}
+
+fn u32_sequence<'a>(
+    input: RecurrenceTemplateInputView<'a>,
+    id: u32,
+    label: &str,
+) -> RusticolResult<&'a [u32]> {
+    sequence(
+        input.u32_sequence_ranges,
+        input.u32_sequence_values,
+        id,
+        label,
+    )
+}
+
+fn i32_sequence<'a>(
+    input: RecurrenceTemplateInputView<'a>,
+    id: u32,
+    label: &str,
+) -> RusticolResult<&'a [i32]> {
+    sequence(
+        input.i32_sequence_ranges,
+        input.i32_sequence_values,
+        id,
+        label,
+    )
+}
+
+fn validate_flavour_flow_witness(
+    input: RecurrenceTemplateInputView<'_>,
+    row: usize,
+    operation: &str,
+    input_flavour_ids: &[u32],
+    result_state_id: u32,
+    result_flavour_id: u32,
+) -> RusticolResult<()> {
+    if input_flavour_ids.len() != 2 {
+        return Err(invalid(format!(
+            "quantum flow {row} must have two flavour-flow inputs"
+        )));
+    }
+    let left = sequence(
+        input.flavour_flow_ranges,
+        input.flavour_flow_values,
+        input_flavour_ids[0],
+        "quantum-flow left flavour flow",
+    )?;
+    let right = sequence(
+        input.flavour_flow_ranges,
+        input.flavour_flow_values,
+        input_flavour_ids[1],
+        "quantum-flow right flavour flow",
+    )?;
+    let result = sequence(
+        input.flavour_flow_ranges,
+        input.flavour_flow_values,
+        result_flavour_id,
+        "quantum-flow result flavour flow",
+    )?;
+    let result_particle = input.current_states[result_state_id as usize].particle_id;
+    let mut expected = Vec::with_capacity(left.len() + right.len() + 1);
+    match operation {
+        "constant-result" => expected.push(result_particle),
+        "append-left-result" => {
+            expected.extend_from_slice(left);
+            if left.last().copied() != Some(result_particle) {
+                expected.push(result_particle);
+            }
+        }
+        "append-right-result" => {
+            expected.extend_from_slice(right);
+            if right.last().copied() != Some(result_particle) {
+                expected.push(result_particle);
+            }
+        }
+        "concat-left-right-result" => {
+            expected.extend_from_slice(left);
+            expected.extend_from_slice(right);
+            expected.push(result_particle);
+        }
+        _ => return Err(invalid("unsupported flavour-flow operation")),
+    }
+    if result != expected {
+        return Err(invalid(format!(
+            "quantum flow {row} flavour operation does not reproduce its stored result witness"
+        )));
+    }
+    Ok(())
+}
+
+fn validate_strict_u32(values: &[u32], label: &str) -> RusticolResult<()> {
+    for (index, pair) in values.windows(2).enumerate() {
+        if pair[0] >= pair[1] {
+            return Err(invalid(format!(
+                "{label} is not strictly ordered at item {}",
+                index + 1
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn validate_permutation(values: &[u32], label: &str) -> RusticolResult<()> {
+    validate_permutation_of(values, values.len(), label)
+}
+
+fn validate_permutation_of(values: &[u32], arity: usize, label: &str) -> RusticolResult<()> {
+    if values.len() != arity {
+        return Err(invalid(format!(
+            "{label} length {} does not match arity {arity}",
+            values.len()
+        )));
+    }
+    let mut seen = vec![false; arity];
+    for value in values {
+        let index = usize::try_from(*value)
+            .map_err(|_| invalid(format!("{label} item {value} exceeds usize")))?;
+        if index >= arity || seen[index] {
+            return Err(invalid(format!(
+                "{label} is not a permutation of 0..{arity}"
+            )));
+        }
+        seen[index] = true;
+    }
+    Ok(())
+}
+
+fn register_template(
+    templates: &mut BTreeMap<u32, TemplateKind>,
+    string_id: u32,
+    kind: TemplateKind,
+    label: &str,
+) -> RusticolResult<()> {
+    if let Some(previous) = templates.insert(string_id, kind) {
+        return Err(invalid(format!(
+            "{label} reuses global template string id {string_id} already owned by {previous:?}"
+        )));
+    }
+    Ok(())
+}
+
+fn register_semantic_digest(
+    digests: &mut BTreeSet<u32>,
+    digest_id: u32,
+    label: &str,
+) -> RusticolResult<()> {
+    if !digests.insert(digest_id) {
+        return Err(invalid(format!(
+            "{label} reuses semantic digest id {digest_id}"
+        )));
+    }
+    Ok(())
+}
+
+fn parse_canonical_i128(value: &str, positive: bool, label: &str) -> RusticolResult<i128> {
+    let parsed = value
+        .parse::<i128>()
+        .map_err(|_| invalid(format!("{label} {value:?} is outside the i128 domain")))?;
+    if parsed.to_string() != value {
+        return Err(invalid(format!(
+            "{label} {value:?} is not a canonical decimal integer"
+        )));
+    }
+    if parsed == i128::MIN {
+        return Err(invalid(format!(
+            "{label} cannot use i128::MIN in the symmetric exact-rational domain"
+        )));
+    }
+    if positive && parsed <= 0 {
+        return Err(invalid(format!("{label} must be positive")));
+    }
+    Ok(parsed)
+}
+
+fn is_supported_proof_algorithm(value: &str) -> bool {
+    matches!(
+        value,
+        "canonical-crossing-bijection-v1"
+            | "canonical-current-word-reversal-v1"
+            | "canonical-kernel-input-exchange-v1"
+            | "canonical-model-contract-label-equivariance-v1"
+            | "canonical-recurrence-replay-witness-v1"
+            | "canonical-recurrence-union-witness-v1"
+            | "canonical-source-transition-dependency-shape-v1"
+            | "canonical-trace-amplitude-reversal-v1"
+            | "exact-expression-identity-v1"
+            | "prepared-kernel-homogeneous-complex-linear-current-v1"
+            | "prepared-kernel-independent-current-block-v1"
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn empty_canonical_input() -> OwnedRecurrenceTemplateInput {
+        let mut strings = vec![
+            RECURRENCE_TEMPLATE_INPUT_ABI,
+            RECURRENCE_TEMPLATE_ABI,
+            RECURRENCE_TEMPLATE_CANONICALIZATION_ABI,
+            RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI,
+        ];
+        strings.sort_unstable();
+        strings.dedup();
+        let string_id =
+            |value: &str| u32::try_from(strings.binary_search(&value).unwrap()).unwrap();
+        let mut string_ranges = Vec::new();
+        let mut string_bytes = Vec::new();
+        for value in &strings {
+            string_ranges.push(CheckedTableRange::new(
+                string_bytes.len() as u64,
+                value.len() as u64,
+            ));
+            string_bytes.extend_from_slice(value.as_bytes());
+        }
+
+        let compiled_model_digest = SemanticDigest::new([1; 32]).unwrap();
+        let prepared_kernel_pack_digest = SemanticDigest::new([2; 32]).unwrap();
+        let catalog_digest = SemanticDigest::new([3; 32]).unwrap();
+        OwnedRecurrenceTemplateInput {
+            input_abi: RECURRENCE_TEMPLATE_INPUT_ABI.to_owned(),
+            catalog_digest,
+            compiled_model_digest,
+            prepared_kernel_pack_digest,
+            catalog_header: vec![CatalogHeaderRow {
+                schema_version: RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION,
+                abi_string_id: string_id(RECURRENCE_TEMPLATE_ABI),
+                canonicalization_abi_string_id: string_id(RECURRENCE_TEMPLATE_CANONICALIZATION_ABI),
+                exact_scalar_abi_string_id: string_id(RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI),
+                compiled_model_digest_id: 0,
+                prepared_kernel_pack_digest_id: 1,
+                catalog_digest_id: 2,
+                parameter_count: 0,
+                current_state_count: 0,
+                source_count: 0,
+                quantum_flow_count: 0,
+                contact_orbit_certificate_count: 0,
+                contact_orbit_step_count: 0,
+                transition_count: 0,
+                propagator_count: 0,
+                closure_count: 0,
+                color_contraction_count: 0,
+                symmetry_proof_count: 0,
+                runtime_helicity_contract_count: 0,
+                evaluator_binding_count: 0,
+            }],
+            coupling_order_ranges: vec![IndexedRangeRow {
+                id: 0,
+                range: CheckedTableRange::new(0, 0),
+            }],
+            coupling_order_terms: vec![],
+            contact_orbit_certificates: vec![],
+            contact_orbit_steps: vec![],
+            current_states: vec![],
+            digest_catalog: vec![
+                DigestCatalogRow {
+                    id: 0,
+                    value: [1; 32],
+                },
+                DigestCatalogRow {
+                    id: 1,
+                    value: [2; 32],
+                },
+                DigestCatalogRow {
+                    id: 2,
+                    value: [3; 32],
+                },
+            ],
+            evaluator_bindings: vec![],
+            exact_factors: vec![],
+            flavour_flow_ranges: vec![],
+            flavour_flow_values: vec![],
+            i32_sequence_ranges: vec![IndexedRangeRow {
+                id: 0,
+                range: CheckedTableRange::new(0, 0),
+            }],
+            i32_sequence_values: vec![],
+            parameters: vec![],
+            propagators: vec![],
+            quantum_flows: vec![],
+            quantum_number_flow_ranges: vec![],
+            quantum_number_flow_terms: vec![],
+            runtime_helicity_contracts: vec![],
+            runtime_helicity_variants: vec![],
+            runtime_helicity_embeddings: vec![],
+            runtime_helicity_projections: vec![],
+            sources: vec![],
+            string_ranges,
+            string_bytes,
+            symmetry_proofs: vec![],
+            transitions: vec![],
+            closures: vec![],
+            color_contractions: vec![],
+            lc_color_transition_witnesses: vec![],
+            color_nc_terms: vec![],
+            u32_sequence_ranges: vec![IndexedRangeRow {
+                id: 0,
+                range: CheckedTableRange::new(0, 0),
+            }],
+            u32_sequence_values: vec![],
+        }
+    }
+
+    #[test]
+    fn output_factor_source_is_closed() {
+        assert_eq!(
+            OutputFactorSource::try_from(0).unwrap(),
+            OutputFactorSource::None
+        );
+        assert!(OutputFactorSource::try_from(3).is_err());
+    }
+
+    #[test]
+    fn canonical_i128_rejects_aliases_and_asymmetric_minimum() {
+        assert_eq!(parse_canonical_i128("-17", false, "value").unwrap(), -17);
+        assert!(parse_canonical_i128("+17", false, "value").is_err());
+        assert!(parse_canonical_i128("017", false, "value").is_err());
+        assert!(parse_canonical_i128(&i128::MIN.to_string(), false, "value").is_err());
+    }
+
+    #[test]
+    fn permutations_are_checked_exactly() {
+        validate_permutation_of(&[2, 0, 1], 3, "test permutation").unwrap();
+        assert!(validate_permutation_of(&[0, 0, 1], 3, "test permutation").is_err());
+        assert!(validate_permutation_of(&[0, 1], 3, "test permutation").is_err());
+    }
+
+    #[test]
+    fn canonical_sequence_order_rejects_duplicates() {
+        let ranges = [
+            IndexedRangeRow {
+                id: 0,
+                range: CheckedTableRange::new(0, 1),
+            },
+            IndexedRangeRow {
+                id: 1,
+                range: CheckedTableRange::new(1, 1),
+            },
+        ];
+        assert!(validate_sequence_catalog("test", &ranges, &[4_u32, 4], false).is_err());
+    }
+
+    #[test]
+    fn absent_color_output_requires_zero_sentinel() {
+        validate_color_contract_shape(0, &[3, -3], 0, 0, 1).unwrap();
+        assert!(validate_color_contract_shape(0, &[3, -3], 0, 8, 1).is_err());
+        assert!(validate_color_contract_shape(0, &[3, -3], 2, 0, 1).is_err());
+    }
+
+    #[test]
+    fn color_open_string_arity_respects_available_endpoints() {
+        validate_color_contract_shape(0, &[3, 8], 1, 3, 1).unwrap();
+        assert!(validate_color_contract_shape(0, &[3, 8], 1, 3, 2).is_err());
+        assert!(validate_color_contract_shape(0, &[8, 8], 1, 8, 1).is_err());
+
+        // Unknown representation encodings retain the generic endpoint-slot
+        // bound without acquiring a model-specific fundamental-role rule.
+        validate_color_contract_shape(0, &[41, -41], 0, 0, 1).unwrap();
+    }
+
+    #[test]
+    fn empty_model_catalog_validates_end_to_end() {
+        let validated = empty_canonical_input().validate().unwrap();
+        assert_eq!(validated.summary().current_state_count, 0);
+        assert_eq!(validated.summary().prepared_kernel_count, 0);
+        let semantic_index = validated.semantic_index().unwrap();
+        assert!(semantic_index.is_empty());
+        assert_eq!(
+            semantic_index.compiled_model_digest,
+            validated.summary().compiled_model_digest
+        );
+        assert_eq!(
+            semantic_index.catalog_digest,
+            validated.summary().catalog_digest
+        );
+    }
+
+    #[test]
+    fn closure_component_coefficient_catalog_decodes_every_template() {
+        let mut input = crate::recurrence::validated_template_fixture().into_input();
+        let unit = input.exact_factors[0];
+        input.exact_factors.push(ExactFactorRow {
+            id: 1,
+            real_numerator_string_id: unit.real_numerator_string_id,
+            real_denominator_string_id: unit.real_denominator_string_id,
+            imag_numerator_string_id: unit.real_numerator_string_id,
+            imag_denominator_string_id: unit.imag_denominator_string_id,
+        });
+        input.closures[1].component_coefficient_sequence_id =
+            input.closures[1].canonical_input_order_sequence_id;
+
+        let catalog = input
+            .validate()
+            .unwrap()
+            .closure_component_coefficient_catalog()
+            .unwrap();
+        let unit_plus_i = ExactComplexRational::parse_parts("1", "1", "1", "1").unwrap();
+        assert_eq!(catalog.len(), 2);
+        assert_eq!(catalog[0].as_ref(), &[ExactComplexRational::ONE]);
+        assert_eq!(
+            catalog[1].as_ref(),
+            &[ExactComplexRational::ONE, unit_plus_i]
+        );
+    }
+
+    #[test]
+    fn closure_component_coefficient_catalog_rejects_corrupt_validated_state() {
+        let mut templates = crate::recurrence::validated_template_fixture();
+        templates.input.closures[0].component_coefficient_sequence_id =
+            templates.input.closures[0].canonical_input_order_sequence_id;
+        let error = templates
+            .closure_component_coefficient_catalog()
+            .unwrap_err()
+            .to_string();
+        assert!(
+            error.contains("closure component factor ID is out of range"),
+            "unexpected validation error: {error}"
+        );
+
+        let mut templates = crate::recurrence::validated_template_fixture();
+        templates.input.closures[0].component_coefficient_sequence_id = MISSING_U32;
+        let error = templates
+            .closure_component_coefficient_catalog()
+            .unwrap_err()
+            .to_string();
+        assert!(
+            error.contains("closure component coefficients id")
+                && error.contains("exceeds target length"),
+            "unexpected validation error: {error}"
+        );
+
+        let mut templates = crate::recurrence::validated_template_fixture();
+        templates.input.closures[1].id = 7;
+        let error = templates
+            .closure_component_coefficient_catalog()
+            .unwrap_err()
+            .to_string();
+        assert!(
+            error.contains("closure template 1 has noncanonical ID 7"),
+            "unexpected validation error: {error}"
+        );
+    }
+
+    #[test]
+    fn indirect_parameter_dependency_cycles_are_rejected() {
+        let mut input = empty_canonical_input();
+        input.catalog_header[0].parameter_count = 2;
+        input.u32_sequence_ranges.extend([
+            IndexedRangeRow {
+                id: 1,
+                range: CheckedTableRange::new(0, 1),
+            },
+            IndexedRangeRow {
+                id: 2,
+                range: CheckedTableRange::new(1, 1),
+            },
+        ]);
+        input.u32_sequence_values.extend([0, 1]);
+        let mut parameter_template_ids = [
+            input.catalog_header[0].abi_string_id,
+            input.catalog_header[0].canonicalization_abi_string_id,
+        ];
+        parameter_template_ids.sort_unstable();
+        input.parameters = vec![
+            ParameterRow {
+                id: 0,
+                template_string_id: parameter_template_ids[0],
+                name_string_id: input.catalog_header[0].canonicalization_abi_string_id,
+                kind: ParameterKind::Derived as u8,
+                value_type: ParameterValueType::Complex as u8,
+                mutable: 0,
+                default_factor_id: MISSING_U32,
+                exact_expression_digest_id: 0,
+                dependency_sequence_id: 2,
+                prepared_parameter_id: MISSING_U32,
+                semantic_digest_id: 0,
+            },
+            ParameterRow {
+                id: 1,
+                template_string_id: parameter_template_ids[1],
+                name_string_id: input.catalog_header[0].exact_scalar_abi_string_id,
+                kind: ParameterKind::Derived as u8,
+                value_type: ParameterValueType::Complex as u8,
+                mutable: 0,
+                default_factor_id: MISSING_U32,
+                exact_expression_digest_id: 1,
+                dependency_sequence_id: 1,
+                prepared_parameter_id: MISSING_U32,
+                semantic_digest_id: 1,
+            },
+        ];
+
+        let error = input.validate().unwrap_err().to_string();
+        assert!(
+            error.contains("parameter dependency graph contains a cycle"),
+            "unexpected validation error: {error}"
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/template_json.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/template_json.rs
new file mode 100644
index 0000000000..f8e49c1fd4
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/template_json.rs
@@ -0,0 +1,2956 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Strict projection of the retained semantic recurrence-template JSON.
+//!
+//! Prepared kernel packs retain the model-wide recurrence template as the
+//! canonical `RecurrenceTemplateCatalog.to_dict()` object.  This module turns
+//! that authenticated semantic object directly into the primitive owned core
+//! columns.  It deliberately has no Python, NumPy, process-builder, or direct
+//! plan dependency.
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::fmt::Write as _;
+
+use serde::{Deserialize, Deserializer};
+use serde_json::Value;
+use sha2::{Digest, Sha256};
+
+use super::template::{
+    CatalogHeaderRow, ClosureRow, ColorContractionRow, ColorNcTermRow, ContactOrbitCertificateRow,
+    ContactOrbitStepRow, CouplingOrderTermRow, CurrentStateRow, DigestCatalogRow,
+    EvaluatorBindingRow, ExactFactorRow, IndexedRangeRow, LCColorTransitionWitnessRow, MISSING_U32,
+    OwnedRecurrenceTemplateInput, ParameterRow, PropagatorRow, QuantumFlowRow,
+    QuantumNumberFlowTermRow, RECURRENCE_TEMPLATE_CANONICALIZATION_ABI,
+    RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI, RECURRENCE_TEMPLATE_INPUT_ABI,
+    RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION, RuntimeHelicityContractRow,
+    RuntimeHelicityEmbeddingRow, RuntimeHelicityProjectionRow, RuntimeHelicityVariantRow,
+    SourceRow, SymmetryProofRow, TransitionRow,
+};
+use super::{CheckedTableRange, ExactComplexRational, RECURRENCE_TEMPLATE_ABI, SemanticDigest};
+use crate::{RusticolError, RusticolResult};
+
+const ROOT_SECTIONS: [(&str, &str, &str); 13] = [
+    ("parameters", "parameter", "template_id"),
+    ("current_states", "current-state", "template_id"),
+    ("sources", "source", "template_id"),
+    ("quantum_flows", "quantum-flow", "template_id"),
+    (
+        "contact_orbit_certificates",
+        "contact-orbit-certificate",
+        "template_id",
+    ),
+    ("contact_orbit_steps", "contact-orbit-step", "template_id"),
+    ("transitions", "transition", "template_id"),
+    ("propagators", "propagator", "template_id"),
+    ("closures", "closure", "template_id"),
+    ("color_contractions", "color-contraction", "template_id"),
+    ("symmetry_proofs", "symmetry-proof", "template_id"),
+    (
+        "runtime_helicity_contracts",
+        "runtime-helicity-contract",
+        "template_id",
+    ),
+    ("evaluator_bindings", "evaluator-binding", "resolver_key"),
+];
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+#[derive(Clone, Debug)]
+struct RequiredOption<T>(Option<T>);
+
+impl<'de, T> Deserialize<'de> for RequiredOption<T>
+where
+    T: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Option::<T>::deserialize(deserializer).map(Self)
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+enum OptionalField<T> {
+    #[default]
+    Absent,
+    Present(T),
+}
+
+impl<'de, T> Deserialize<'de> for OptionalField<T>
+where
+    T: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        T::deserialize(deserializer).map(Self::Present)
+    }
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct SemanticCatalogJson {
+    header: CatalogHeaderJson,
+    parameters: Vec<ParameterJson>,
+    current_states: Vec<CurrentStateJson>,
+    sources: Vec<SourceJson>,
+    quantum_flows: Vec<QuantumFlowJson>,
+    contact_orbit_certificates: Vec<ContactOrbitCertificateJson>,
+    contact_orbit_steps: Vec<ContactOrbitStepJson>,
+    transitions: Vec<TransitionJson>,
+    propagators: Vec<PropagatorJson>,
+    closures: Vec<ClosureJson>,
+    color_contractions: Vec<ColorContractionJson>,
+    symmetry_proofs: Vec<SymmetryProofJson>,
+    runtime_helicity_contracts: Vec<RuntimeHelicityContractJson>,
+    evaluator_bindings: Vec<EvaluatorBindingJson>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct CatalogHeaderJson {
+    abi: String,
+    canonicalization_abi: String,
+    compiled_model_digest: String,
+    exact_scalar_abi: String,
+    prepared_kernel_pack_digest: String,
+    catalog_digest: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ExactFactorJson {
+    real_numerator: String,
+    real_denominator: String,
+    imag_numerator: String,
+    imag_denominator: String,
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct FactorKey {
+    parts: [i128; 4],
+    strings: [String; 4],
+}
+
+impl ExactFactorJson {
+    fn key(&self) -> RusticolResult<FactorKey> {
+        let value = ExactComplexRational::parse_parts(
+            &self.real_numerator,
+            &self.real_denominator,
+            &self.imag_numerator,
+            &self.imag_denominator,
+        )?;
+        let real = value.real().to_string();
+        let imag = value.imag().to_string();
+        let expected_real = format!("{}/{}", self.real_numerator, self.real_denominator);
+        let expected_imag = format!("{}/{}", self.imag_numerator, self.imag_denominator);
+        if real != expected_real || imag != expected_imag {
+            return Err(invalid(
+                "exact complex rational components are not canonical reduced decimals",
+            ));
+        }
+        Ok(FactorKey {
+            parts: [
+                parse_i128(&self.real_numerator, "real numerator")?,
+                parse_i128(&self.real_denominator, "real denominator")?,
+                parse_i128(&self.imag_numerator, "imaginary numerator")?,
+                parse_i128(&self.imag_denominator, "imaginary denominator")?,
+            ],
+            strings: [
+                self.real_numerator.clone(),
+                self.real_denominator.clone(),
+                self.imag_numerator.clone(),
+                self.imag_denominator.clone(),
+            ],
+        })
+    }
+}
+
+fn parse_i128(value: &str, context: &str) -> RusticolResult<i128> {
+    value
+        .parse::<i128>()
+        .map_err(|_| invalid(format!("{context} is outside the exact i128 domain")))
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ParameterJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    name: String,
+    parameter_kind: String,
+    value_type: String,
+    mutable: bool,
+    default_value: RequiredOption<ExactFactorJson>,
+    exact_expression_digest: RequiredOption<String>,
+    dependency_parameter_ids: Vec<String>,
+    prepared_parameter_id: RequiredOption<u32>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct CurrentStateJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    particle_id: i32,
+    anti_particle_id: i32,
+    species_id: String,
+    orientation: String,
+    statistics: String,
+    color_representation: i32,
+    basis: String,
+    tensor_ordering: Vec<String>,
+    dimension: u32,
+    chirality: i32,
+    lc_color_shape_kind: String,
+    auxiliary_kind: RequiredOption<String>,
+    mass_parameter_id: RequiredOption<String>,
+    width_parameter_id: RequiredOption<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct LCColorSourceSeedJson {
+    operation: String,
+    output_shape_kind: String,
+    component_kind: RequiredOption<String>,
+    component_role: String,
+    proof_digest: String,
+    provenance: Vec<[String; 2]>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct SourceJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    state_template_id: String,
+    crossing: String,
+    wavefunction_family: String,
+    helicity: i32,
+    spin_state: i32,
+    flavour_flow: Vec<i32>,
+    quantum_number_flow: Vec<[String; 2]>,
+    lc_color_seed: LCColorSourceSeedJson,
+    wavefunction_expression_digest: String,
+    evaluator_resolver_key: String,
+    mass_parameter_id: RequiredOption<String>,
+    width_parameter_id: RequiredOption<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct QuantumFlowJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    input_state_template_ids: Vec<String>,
+    input_spin_states: Vec<i32>,
+    input_flavour_flows: Vec<Vec<i32>>,
+    input_quantum_number_flows: Vec<Vec<[String; 2]>>,
+    flavour_flow_operation: String,
+    quantum_number_flow_operation: String,
+    coupling_orders: Vec<(String, u32)>,
+    result_state_template_id: String,
+    result_spin_state: i32,
+    result_flavour_flow: Vec<i32>,
+    result_quantum_number_flow: Vec<[String; 2]>,
+    exact_coupling: ExactFactorJson,
+    predicate_digest: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ContactOrbitCertificateJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    algorithm: String,
+    algorithm_version: u32,
+    term_id: u32,
+    vertex: String,
+    particles: Vec<String>,
+    evaluator_class: String,
+    physical_leg_equivalence_classes: Vec<u32>,
+    reconstruction_factor: ExactFactorJson,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ContactOrbitStepJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    certificate_template_id: String,
+    stage: String,
+    result_leg: u8,
+    left_covered_legs: Vec<u32>,
+    right_covered_legs: Vec<u32>,
+    source_particle_legs: [i32; 3],
+    reconstruction_factor: ExactFactorJson,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct TransitionJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    input_state_template_ids: Vec<String>,
+    result_state_template_id: String,
+    quantum_flow_template_id: String,
+    evaluator_resolver_key: String,
+    canonical_input_order: Vec<u32>,
+    momentum_convention: Vec<String>,
+    coupling_parameter_ids: Vec<String>,
+    coupling_orders: Vec<(String, u32)>,
+    color_contraction_template_id: String,
+    binding_coupling: ExactFactorJson,
+    exact_factor: ExactFactorJson,
+    output_factor_source: String,
+    equivalence_class: String,
+    input_exchange_factor: RequiredOption<ExactFactorJson>,
+    output_projection: String,
+    contact_orbit_step_template_ids: Vec<String>,
+    contact_orbit_step_semantic_digests: Vec<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct PropagatorJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    state_template_id: String,
+    applies_propagator: bool,
+    evaluator_resolver_key: RequiredOption<String>,
+    numerator_expression_digest: RequiredOption<String>,
+    denominator_expression_digest: RequiredOption<String>,
+    mass_parameter_id: RequiredOption<String>,
+    width_parameter_id: RequiredOption<String>,
+    gauge: RequiredOption<String>,
+    linearity_proof_template_id: RequiredOption<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ClosureJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    input_state_template_ids: Vec<String>,
+    result_state_template_id: RequiredOption<String>,
+    evaluator_resolver_key: String,
+    canonical_input_order: Vec<u32>,
+    coupling_parameter_ids: Vec<String>,
+    coupling_orders: Vec<(String, u32)>,
+    eligible_quantum_flow_template_ids: Vec<String>,
+    color_contraction_template_id: String,
+    binding_coupling: ExactFactorJson,
+    exact_factor: ExactFactorJson,
+    output_factor_source: String,
+    equivalence_class: String,
+    input_exchange_factor: RequiredOption<ExactFactorJson>,
+    projection: String,
+    component_coefficients: Vec<ExactFactorJson>,
+    chirality_relation: String,
+    metric_signature: RequiredOption<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct LCColorTransitionWitnessJson {
+    component_operation: String,
+    exact_factor: ExactFactorJson,
+    input_permutation: [u8; 2],
+    input_shape_kinds: [String; 2],
+    proof_digest: String,
+    provenance: Vec<[String; 2]>,
+    result_component_kind: RequiredOption<String>,
+    result_component_role: String,
+    result_shape_kind: RequiredOption<String>,
+    reverse_parent_mask: u8,
+    #[serde(default)]
+    input_port_pairings: OptionalField<Vec<[[u32; 2]; 2]>>,
+    #[serde(default)]
+    result_port_bindings: OptionalField<Vec<[u32; 2]>>,
+}
+
+type CanonicalPortSlices<'a> = (&'a [[[u32; 2]; 2]], &'a [[u32; 2]]);
+
+impl LCColorTransitionWitnessJson {
+    fn canonical_ports(&self) -> RusticolResult<CanonicalPortSlices<'_>> {
+        match (&self.input_port_pairings, &self.result_port_bindings) {
+            (OptionalField::Absent, OptionalField::Absent) => Ok((&[], &[])),
+            (OptionalField::Present(pairings), OptionalField::Present(bindings))
+                if !pairings.is_empty() || !bindings.is_empty() =>
+            {
+                Ok((pairings, bindings))
+            }
+            (OptionalField::Present(_), OptionalField::Present(_)) => Err(invalid(
+                "LC color witness must omit empty canonical port fields",
+            )),
+            _ => Err(invalid(
+                "LC color witness port-pairing and result-binding fields must be paired",
+            )),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ColorContractionJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    rule_kind: String,
+    input_representations: Vec<i32>,
+    output_representation: RequiredOption<i32>,
+    ordered_open_string_arity: u32,
+    exact_coefficient: ExactFactorJson,
+    nc_polynomial: Vec<(i32, ExactFactorJson)>,
+    expression_digest: String,
+    transition_witnesses: Vec<LCColorTransitionWitnessJson>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct SymmetryProofJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    proof_algorithm: String,
+    subject_template_ids: Vec<String>,
+    input_permutation: Vec<u32>,
+    exact_phase: ExactFactorJson,
+    expression_digests: Vec<String>,
+    witness_digest: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct RuntimeHelicityVariantJson {
+    source_template_id: String,
+    source_state_template_id: String,
+    embedding_source_components: Vec<Option<u32>>,
+    embedding_factors: Vec<ExactFactorJson>,
+    projection_full_components: Vec<u32>,
+    proof_digest: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct RuntimeHelicityContractJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    template_id: String,
+    full_state_template_id: String,
+    variants: Vec<RuntimeHelicityVariantJson>,
+    proof_algorithm: String,
+    proof_digest: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct EvaluatorBindingJson {
+    #[serde(rename = "record_kind")]
+    _record_kind: String,
+    semantic_digest: String,
+    resolver_key: String,
+    prepared_kernel_id: RequiredOption<u32>,
+    contract_kind: String,
+    callable_signature: String,
+    input_state_template_ids: Vec<String>,
+    output_state_template_id: RequiredOption<String>,
+    input_layout: Vec<String>,
+    output_layout: Vec<String>,
+    exact_expression_digests: Vec<String>,
+    semantic_template_ids: Vec<String>,
+    callable_kind: String,
+    runtime_template: RequiredOption<String>,
+}
+
+#[derive(Clone, Debug)]
+struct Catalog<T: Ord> {
+    values: Vec<T>,
+    ids: BTreeMap<T, u32>,
+}
+
+impl<T: Clone + Ord> Catalog<T> {
+    fn from_set(values: BTreeSet<T>, context: &str) -> RusticolResult<Self> {
+        let values = values.into_iter().collect::<Vec<_>>();
+        let mut ids = BTreeMap::new();
+        for (index, value) in values.iter().cloned().enumerate() {
+            ids.insert(value, checked_u32(index, context)?);
+        }
+        Ok(Self { values, ids })
+    }
+
+    fn id(&self, value: &T, context: &str) -> RusticolResult<u32> {
+        self.ids
+            .get(value)
+            .copied()
+            .ok_or_else(|| invalid(format!("{context} is absent from its canonical catalog")))
+    }
+}
+
+fn checked_u32(value: usize, context: &str) -> RusticolResult<u32> {
+    u32::try_from(value).map_err(|_| invalid(format!("{context} exceeds u32")))
+}
+
+fn checked_u64(value: usize, context: &str) -> RusticolResult<u64> {
+    u64::try_from(value).map_err(|_| invalid(format!("{context} exceeds u64")))
+}
+
+fn optional_id<T: Ord>(
+    value: Option<&T>,
+    ids: &BTreeMap<T, u32>,
+    context: &str,
+) -> RusticolResult<u32> {
+    match value {
+        None => Ok(MISSING_U32),
+        Some(value) => ids
+            .get(value)
+            .copied()
+            .ok_or_else(|| invalid(format!("unknown {context}"))),
+    }
+}
+
+fn mapped_ids(
+    values: &[String],
+    ids: &BTreeMap<String, u32>,
+    context: &str,
+) -> RusticolResult<Vec<u32>> {
+    values
+        .iter()
+        .map(|value| {
+            ids.get(value)
+                .copied()
+                .ok_or_else(|| invalid(format!("unknown {context} {value:?}")))
+        })
+        .collect()
+}
+
+fn enum_id(value: &str, choices: &[(&str, u8)], context: &str) -> RusticolResult<u8> {
+    choices
+        .iter()
+        .find_map(|(name, id)| (*name == value).then_some(*id))
+        .ok_or_else(|| invalid(format!("unsupported {context} {value:?}")))
+}
+
+/// Project one retained `RecurrenceTemplateCatalog.to_dict()` value into the
+/// validated, owned core recurrence-template input.
+///
+/// The caller must pass the semantic catalog object itself, not a surrounding
+/// prepared-pack object.  The function authenticates every record digest and
+/// the catalog digest before deriving any primitive IDs.
+#[cfg(any(feature = "python-generation-bridge", test))]
+pub(crate) fn project_recurrence_template_catalog_json_v1(
+    value: &Value,
+) -> RusticolResult<OwnedRecurrenceTemplateInput> {
+    authenticate_semantic_json(value)?;
+    project_authenticated_recurrence_template_catalog_json_v1(value.clone())
+}
+
+/// Project an owned semantic catalog without retaining its JSON representation.
+pub(crate) fn project_owned_recurrence_template_catalog_json_v1(
+    value: Value,
+) -> RusticolResult<OwnedRecurrenceTemplateInput> {
+    authenticate_semantic_json(&value)?;
+    project_authenticated_recurrence_template_catalog_json_v1(value)
+}
+
+fn project_authenticated_recurrence_template_catalog_json_v1(
+    value: Value,
+) -> RusticolResult<OwnedRecurrenceTemplateInput> {
+    let catalog: SemanticCatalogJson = serde_json::from_value(value).map_err(|error| {
+        invalid(format!(
+            "invalid recurrence-template semantic JSON shape: {error}"
+        ))
+    })?;
+    validate_header(&catalog.header)?;
+    validate_witness_port_shapes(&catalog)?;
+    project_catalog(&catalog)
+}
+
+fn validate_header(header: &CatalogHeaderJson) -> RusticolResult<()> {
+    if header.abi != RECURRENCE_TEMPLATE_ABI {
+        return Err(invalid(format!(
+            "unsupported recurrence-template ABI {:?}",
+            header.abi
+        )));
+    }
+    if header.canonicalization_abi != RECURRENCE_TEMPLATE_CANONICALIZATION_ABI {
+        return Err(invalid(format!(
+            "unsupported recurrence-template canonicalization ABI {:?}",
+            header.canonicalization_abi
+        )));
+    }
+    if header.exact_scalar_abi != RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI {
+        return Err(invalid(format!(
+            "unsupported recurrence-template exact-scalar ABI {:?}",
+            header.exact_scalar_abi
+        )));
+    }
+    parse_digest(&header.compiled_model_digest, "compiled-model digest")?;
+    parse_digest(
+        &header.prepared_kernel_pack_digest,
+        "prepared-kernel-pack digest",
+    )?;
+    parse_digest(&header.catalog_digest, "catalog digest")?;
+    Ok(())
+}
+
+fn validate_witness_port_shapes(catalog: &SemanticCatalogJson) -> RusticolResult<()> {
+    for color in &catalog.color_contractions {
+        for witness in &color.transition_witnesses {
+            witness.canonical_ports()?;
+        }
+    }
+    for contract in &catalog.runtime_helicity_contracts {
+        let mut previous_source: Option<&str> = None;
+        for variant in &contract.variants {
+            if previous_source
+                .is_some_and(|previous| previous >= variant.source_template_id.as_str())
+            {
+                return Err(invalid(
+                    "runtime-helicity variants must be in strict source-template order",
+                ));
+            }
+            previous_source = Some(&variant.source_template_id);
+            if variant.embedding_source_components.len() != variant.embedding_factors.len() {
+                return Err(invalid(
+                    "runtime-helicity embedding components and factors must have equal length",
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn authenticate_semantic_json(value: &Value) -> RusticolResult<()> {
+    let root = value
+        .as_object()
+        .ok_or_else(|| invalid("recurrence-template catalog must be a JSON object"))?;
+    let header = root
+        .get("header")
+        .and_then(Value::as_object)
+        .ok_or_else(|| invalid("recurrence-template catalog header must be an object"))?;
+    let expected_catalog_digest = header
+        .get("catalog_digest")
+        .and_then(Value::as_str)
+        .ok_or_else(|| invalid("recurrence-template catalog digest must be a string"))?;
+    parse_digest(expected_catalog_digest, "catalog digest")?;
+
+    for (section, expected_kind, identity_field) in ROOT_SECTIONS {
+        let records = root
+            .get(section)
+            .and_then(Value::as_array)
+            .ok_or_else(|| invalid(format!("recurrence-template {section} must be an array")))?;
+        let mut previous_identity: Option<&str> = None;
+        for (index, record) in records.iter().enumerate() {
+            let object = record.as_object().ok_or_else(|| {
+                invalid(format!(
+                    "recurrence-template {section} row {index} must be an object"
+                ))
+            })?;
+            let kind = object
+                .get("record_kind")
+                .and_then(Value::as_str)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "recurrence-template {section} row {index} lacks record_kind"
+                    ))
+                })?;
+            if kind != expected_kind {
+                return Err(invalid(format!(
+                    "recurrence-template {section} row {index} has record kind {kind:?}, expected {expected_kind:?}"
+                )));
+            }
+            let identity = object
+                .get(identity_field)
+                .and_then(Value::as_str)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "recurrence-template {section} row {index} lacks string {identity_field}"
+                    ))
+                })?;
+            if identity.is_empty() || previous_identity.is_some_and(|previous| previous >= identity)
+            {
+                return Err(invalid(format!(
+                    "recurrence-template {section} identities are not in strict canonical order at row {index}"
+                )));
+            }
+            previous_identity = Some(identity);
+
+            let expected = object
+                .get("semantic_digest")
+                .and_then(Value::as_str)
+                .ok_or_else(|| {
+                    invalid(format!(
+                        "recurrence-template {section} row {index} lacks semantic_digest"
+                    ))
+                })?;
+            parse_digest(expected, "record semantic digest")?;
+            let mut payload = record.clone();
+            payload
+                .as_object_mut()
+                .expect("record object was checked")
+                .remove("semantic_digest");
+            let actual = canonical_json_digest(&payload)?;
+            if expected != actual {
+                return Err(invalid(format!(
+                    "stale recurrence-template semantic digest in {section} row {index}"
+                )));
+            }
+        }
+    }
+
+    let mut catalog_payload = value.clone();
+    catalog_payload
+        .as_object_mut()
+        .and_then(|root| root.get_mut("header"))
+        .and_then(Value::as_object_mut)
+        .expect("catalog/header objects were checked")
+        .remove("catalog_digest");
+    let actual_catalog_digest = canonical_json_digest(&catalog_payload)?;
+    if expected_catalog_digest != actual_catalog_digest {
+        return Err(invalid("stale recurrence-template catalog digest"));
+    }
+    Ok(())
+}
+
+fn parse_digest(value: &str, context: &str) -> RusticolResult<[u8; 32]> {
+    if value.len() != 64
+        || !value
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+    {
+        return Err(invalid(format!(
+            "{context} must be a lowercase SHA-256 digest"
+        )));
+    }
+    let mut bytes = [0_u8; 32];
+    for (index, output) in bytes.iter_mut().enumerate() {
+        let offset = index * 2;
+        *output = u8::from_str_radix(&value[offset..offset + 2], 16)
+            .map_err(|_| invalid(format!("{context} contains invalid hexadecimal")))?;
+    }
+    if bytes == [0; 32] {
+        return Err(invalid(format!("{context} must not be all zero")));
+    }
+    Ok(bytes)
+}
+
+fn semantic_digest(value: &str, context: &str) -> RusticolResult<SemanticDigest> {
+    SemanticDigest::new(parse_digest(value, context)?)
+}
+
+fn canonical_json_digest(value: &Value) -> RusticolResult<String> {
+    let mut canonical = String::new();
+    write_canonical_json(value, &mut canonical)?;
+    Ok(format!("{:x}", Sha256::digest(canonical.as_bytes())))
+}
+
+fn write_canonical_json(value: &Value, output: &mut String) -> RusticolResult<()> {
+    match value {
+        Value::Null => output.push_str("null"),
+        Value::Bool(value) => output.push_str(if *value { "true" } else { "false" }),
+        Value::Number(value) => output.push_str(&python_json_number(value)),
+        Value::String(value) => write_ascii_json_string(value, output),
+        Value::Array(values) => {
+            output.push('[');
+            for (index, value) in values.iter().enumerate() {
+                if index != 0 {
+                    output.push(',');
+                }
+                write_canonical_json(value, output)?;
+            }
+            output.push(']');
+        }
+        Value::Object(values) => {
+            output.push('{');
+            let mut keys = values.keys().collect::<Vec<_>>();
+            keys.sort_unstable();
+            for (index, key) in keys.iter().enumerate() {
+                if index != 0 {
+                    output.push(',');
+                }
+                write_ascii_json_string(key, output);
+                output.push(':');
+                write_canonical_json(&values[*key], output)?;
+            }
+            output.push('}');
+        }
+    }
+    Ok(())
+}
+
+fn python_json_number(number: &serde_json::Number) -> String {
+    let rendered = number.to_string();
+    let Some((mantissa, exponent)) = rendered.split_once('e') else {
+        return rendered;
+    };
+    let (sign, digits) = if let Some(digits) = exponent.strip_prefix('-') {
+        ('-', digits)
+    } else if let Some(digits) = exponent.strip_prefix('+') {
+        ('+', digits)
+    } else {
+        ('+', exponent)
+    };
+    format!("{mantissa}e{sign}{digits:0>2}")
+}
+
+fn write_ascii_json_string(value: &str, output: &mut String) {
+    output.push('"');
+    for character in value.chars() {
+        match character {
+            '"' => output.push_str("\\\""),
+            '\\' => output.push_str("\\\\"),
+            '\u{0008}' => output.push_str("\\b"),
+            '\u{000c}' => output.push_str("\\f"),
+            '\n' => output.push_str("\\n"),
+            '\r' => output.push_str("\\r"),
+            '\t' => output.push_str("\\t"),
+            '\u{0020}'..='\u{007e}' => output.push(character),
+            character if u32::from(character) <= 0xffff => {
+                let _ = write!(output, "\\u{:04x}", u32::from(character));
+            }
+            character => {
+                let scalar = u32::from(character) - 0x1_0000;
+                let high = 0xd800 + (scalar >> 10);
+                let low = 0xdc00 + (scalar & 0x3ff);
+                let _ = write!(output, "\\u{high:04x}\\u{low:04x}");
+            }
+        }
+    }
+    output.push('"');
+}
+
+#[derive(Debug)]
+struct SectionIds {
+    parameters: BTreeMap<String, u32>,
+    current_states: BTreeMap<String, u32>,
+    sources: BTreeMap<String, u32>,
+    quantum_flows: BTreeMap<String, u32>,
+    contact_orbit_certificates: BTreeMap<String, u32>,
+    contact_orbit_steps: BTreeMap<String, u32>,
+    color_contractions: BTreeMap<String, u32>,
+    symmetry_proofs: BTreeMap<String, u32>,
+    evaluator_bindings: BTreeMap<String, u32>,
+}
+
+fn identity_ids<'a>(
+    values: impl IntoIterator<Item = &'a String>,
+    context: &str,
+) -> RusticolResult<BTreeMap<String, u32>> {
+    let mut result = BTreeMap::new();
+    for (index, value) in values.into_iter().enumerate() {
+        if result
+            .insert(value.clone(), checked_u32(index, context)?)
+            .is_some()
+        {
+            return Err(invalid(format!("duplicate {context} identity {value:?}")));
+        }
+    }
+    Ok(result)
+}
+
+impl SectionIds {
+    fn build(catalog: &SemanticCatalogJson) -> RusticolResult<Self> {
+        Ok(Self {
+            parameters: identity_ids(
+                catalog.parameters.iter().map(|record| &record.template_id),
+                "parameter",
+            )?,
+            current_states: identity_ids(
+                catalog
+                    .current_states
+                    .iter()
+                    .map(|record| &record.template_id),
+                "current-state",
+            )?,
+            sources: identity_ids(
+                catalog.sources.iter().map(|record| &record.template_id),
+                "source",
+            )?,
+            quantum_flows: identity_ids(
+                catalog
+                    .quantum_flows
+                    .iter()
+                    .map(|record| &record.template_id),
+                "quantum-flow",
+            )?,
+            contact_orbit_certificates: identity_ids(
+                catalog
+                    .contact_orbit_certificates
+                    .iter()
+                    .map(|record| &record.template_id),
+                "contact-orbit certificate",
+            )?,
+            contact_orbit_steps: identity_ids(
+                catalog
+                    .contact_orbit_steps
+                    .iter()
+                    .map(|record| &record.template_id),
+                "contact-orbit step",
+            )?,
+            color_contractions: identity_ids(
+                catalog
+                    .color_contractions
+                    .iter()
+                    .map(|record| &record.template_id),
+                "color contraction",
+            )?,
+            symmetry_proofs: identity_ids(
+                catalog
+                    .symmetry_proofs
+                    .iter()
+                    .map(|record| &record.template_id),
+                "symmetry proof",
+            )?,
+            evaluator_bindings: identity_ids(
+                catalog
+                    .evaluator_bindings
+                    .iter()
+                    .map(|record| &record.resolver_key),
+                "evaluator binding",
+            )?,
+        })
+    }
+}
+
+#[derive(Debug)]
+struct PrimitiveCatalogs {
+    strings: Catalog<String>,
+    digests: Catalog<[u8; 32]>,
+    factors: Catalog<FactorKey>,
+    flavour_flows: Catalog<Vec<i32>>,
+    quantum_number_flows: Catalog<Vec<(String, String)>>,
+    coupling_orders: Catalog<Vec<(String, u32)>>,
+    u32_sequences: Catalog<Vec<u32>>,
+    i32_sequences: Catalog<Vec<i32>>,
+}
+
+fn qflow(values: &[[String; 2]]) -> Vec<(String, String)> {
+    values
+        .iter()
+        .map(|pair| (pair[0].clone(), pair[1].clone()))
+        .collect()
+}
+
+fn add_optional_string(values: &mut BTreeSet<String>, value: &RequiredOption<String>) {
+    if let Some(value) = &value.0 {
+        values.insert(value.clone());
+    }
+}
+
+fn add_digest(values: &mut BTreeSet<[u8; 32]>, value: &str, context: &str) -> RusticolResult<()> {
+    values.insert(parse_digest(value, context)?);
+    Ok(())
+}
+
+fn add_optional_digest(
+    values: &mut BTreeSet<[u8; 32]>,
+    value: &RequiredOption<String>,
+    context: &str,
+) -> RusticolResult<()> {
+    if let Some(value) = &value.0 {
+        add_digest(values, value, context)?;
+    }
+    Ok(())
+}
+
+fn add_factor(values: &mut BTreeSet<FactorKey>, value: &ExactFactorJson) -> RusticolResult<()> {
+    values.insert(value.key()?);
+    Ok(())
+}
+
+fn add_optional_factor(
+    values: &mut BTreeSet<FactorKey>,
+    value: &RequiredOption<ExactFactorJson>,
+) -> RusticolResult<()> {
+    if let Some(value) = &value.0 {
+        add_factor(values, value)?;
+    }
+    Ok(())
+}
+
+fn collect_strings(catalog: &SemanticCatalogJson) -> RusticolResult<BTreeSet<String>> {
+    let mut values = BTreeSet::from([
+        RECURRENCE_TEMPLATE_INPUT_ABI.to_owned(),
+        catalog.header.abi.clone(),
+        catalog.header.canonicalization_abi.clone(),
+        catalog.header.exact_scalar_abi.clone(),
+    ]);
+    for record in &catalog.parameters {
+        values.extend([record.template_id.clone(), record.name.clone()]);
+        values.extend(record.dependency_parameter_ids.iter().cloned());
+    }
+    for record in &catalog.current_states {
+        values.extend([
+            record.template_id.clone(),
+            record.species_id.clone(),
+            record.basis.clone(),
+            record.lc_color_shape_kind.clone(),
+        ]);
+        values.extend(record.tensor_ordering.iter().cloned());
+        add_optional_string(&mut values, &record.auxiliary_kind);
+        add_optional_string(&mut values, &record.mass_parameter_id);
+        add_optional_string(&mut values, &record.width_parameter_id);
+    }
+    for record in &catalog.sources {
+        values.extend([
+            record.template_id.clone(),
+            record.crossing.clone(),
+            record.wavefunction_family.clone(),
+            record.evaluator_resolver_key.clone(),
+            record.lc_color_seed.output_shape_kind.clone(),
+        ]);
+        for pair in &record.lc_color_seed.provenance {
+            values.extend(pair.iter().cloned());
+        }
+        for pair in &record.quantum_number_flow {
+            values.extend(pair.iter().cloned());
+        }
+    }
+    for record in &catalog.quantum_flows {
+        values.extend([
+            record.template_id.clone(),
+            record.flavour_flow_operation.clone(),
+            record.quantum_number_flow_operation.clone(),
+        ]);
+        for flow in record
+            .input_quantum_number_flows
+            .iter()
+            .chain(std::iter::once(&record.result_quantum_number_flow))
+        {
+            for pair in flow {
+                values.extend(pair.iter().cloned());
+            }
+        }
+        values.extend(record.coupling_orders.iter().map(|(name, _)| name.clone()));
+    }
+    for record in &catalog.contact_orbit_certificates {
+        values.extend([
+            record.template_id.clone(),
+            record.algorithm.clone(),
+            record.vertex.clone(),
+            record.evaluator_class.clone(),
+        ]);
+        values.extend(record.particles.iter().cloned());
+    }
+    for record in &catalog.contact_orbit_steps {
+        values.extend([
+            record.template_id.clone(),
+            record.certificate_template_id.clone(),
+            record.stage.clone(),
+        ]);
+    }
+    for record in &catalog.transitions {
+        values.extend([
+            record.template_id.clone(),
+            record.evaluator_resolver_key.clone(),
+            record.output_factor_source.clone(),
+            record.equivalence_class.clone(),
+            record.output_projection.clone(),
+        ]);
+        values.extend(record.momentum_convention.iter().cloned());
+        values.extend(record.coupling_orders.iter().map(|(name, _)| name.clone()));
+    }
+    for record in &catalog.propagators {
+        values.insert(record.template_id.clone());
+        add_optional_string(&mut values, &record.evaluator_resolver_key);
+        add_optional_string(&mut values, &record.gauge);
+    }
+    for record in &catalog.closures {
+        values.extend([
+            record.template_id.clone(),
+            record.evaluator_resolver_key.clone(),
+            record.output_factor_source.clone(),
+            record.equivalence_class.clone(),
+            record.projection.clone(),
+            record.chirality_relation.clone(),
+        ]);
+        add_optional_string(&mut values, &record.metric_signature);
+        values.extend(record.coupling_orders.iter().map(|(name, _)| name.clone()));
+    }
+    for record in &catalog.color_contractions {
+        values.extend([record.template_id.clone(), record.rule_kind.clone()]);
+        for witness in &record.transition_witnesses {
+            values.extend(witness.input_shape_kinds.iter().cloned());
+            add_optional_string(&mut values, &witness.result_shape_kind);
+            for pair in &witness.provenance {
+                values.extend(pair.iter().cloned());
+            }
+        }
+    }
+    for record in &catalog.symmetry_proofs {
+        values.extend([record.template_id.clone(), record.proof_algorithm.clone()]);
+        values.extend(record.subject_template_ids.iter().cloned());
+    }
+    for record in &catalog.runtime_helicity_contracts {
+        values.extend([
+            record.template_id.clone(),
+            record.full_state_template_id.clone(),
+            record.proof_algorithm.clone(),
+        ]);
+        for variant in &record.variants {
+            values.extend([
+                variant.source_template_id.clone(),
+                variant.source_state_template_id.clone(),
+            ]);
+        }
+    }
+    for record in &catalog.evaluator_bindings {
+        values.insert(record.resolver_key.clone());
+        values.extend(record.input_layout.iter().cloned());
+        values.extend(record.output_layout.iter().cloned());
+        values.extend(record.semantic_template_ids.iter().cloned());
+        add_optional_string(&mut values, &record.runtime_template);
+    }
+
+    for factor in collect_factors(catalog)? {
+        values.extend(factor.strings);
+    }
+    Ok(values)
+}
+
+fn collect_digests(catalog: &SemanticCatalogJson) -> RusticolResult<BTreeSet<[u8; 32]>> {
+    let mut values = BTreeSet::new();
+    add_digest(
+        &mut values,
+        &catalog.header.catalog_digest,
+        "catalog digest",
+    )?;
+    add_digest(
+        &mut values,
+        &catalog.header.compiled_model_digest,
+        "compiled-model digest",
+    )?;
+    add_digest(
+        &mut values,
+        &catalog.header.prepared_kernel_pack_digest,
+        "prepared-kernel-pack digest",
+    )?;
+    macro_rules! record_digests {
+        ($records:expr) => {
+            for record in $records {
+                add_digest(
+                    &mut values,
+                    &record.semantic_digest,
+                    "record semantic digest",
+                )?;
+            }
+        };
+    }
+    record_digests!(&catalog.parameters);
+    record_digests!(&catalog.current_states);
+    record_digests!(&catalog.sources);
+    record_digests!(&catalog.quantum_flows);
+    record_digests!(&catalog.contact_orbit_certificates);
+    record_digests!(&catalog.contact_orbit_steps);
+    record_digests!(&catalog.transitions);
+    record_digests!(&catalog.propagators);
+    record_digests!(&catalog.closures);
+    record_digests!(&catalog.color_contractions);
+    record_digests!(&catalog.symmetry_proofs);
+    record_digests!(&catalog.runtime_helicity_contracts);
+    record_digests!(&catalog.evaluator_bindings);
+
+    for record in &catalog.parameters {
+        add_optional_digest(
+            &mut values,
+            &record.exact_expression_digest,
+            "parameter expression digest",
+        )?;
+    }
+    for record in &catalog.sources {
+        add_digest(
+            &mut values,
+            &record.wavefunction_expression_digest,
+            "source expression digest",
+        )?;
+        add_digest(
+            &mut values,
+            &record.lc_color_seed.proof_digest,
+            "source color proof digest",
+        )?;
+    }
+    for record in &catalog.quantum_flows {
+        add_digest(
+            &mut values,
+            &record.predicate_digest,
+            "quantum predicate digest",
+        )?;
+    }
+    for record in &catalog.transitions {
+        for digest in &record.contact_orbit_step_semantic_digests {
+            add_digest(&mut values, digest, "contact-orbit step digest")?;
+        }
+    }
+    for record in &catalog.propagators {
+        add_optional_digest(
+            &mut values,
+            &record.numerator_expression_digest,
+            "propagator numerator digest",
+        )?;
+        add_optional_digest(
+            &mut values,
+            &record.denominator_expression_digest,
+            "propagator denominator digest",
+        )?;
+    }
+    for record in &catalog.color_contractions {
+        add_digest(
+            &mut values,
+            &record.expression_digest,
+            "color expression digest",
+        )?;
+        for witness in &record.transition_witnesses {
+            add_digest(
+                &mut values,
+                &witness.proof_digest,
+                "color witness proof digest",
+            )?;
+        }
+    }
+    for record in &catalog.symmetry_proofs {
+        add_digest(
+            &mut values,
+            &record.witness_digest,
+            "symmetry witness digest",
+        )?;
+        for digest in &record.expression_digests {
+            add_digest(&mut values, digest, "symmetry expression digest")?;
+        }
+    }
+    for record in &catalog.runtime_helicity_contracts {
+        add_digest(&mut values, &record.proof_digest, "helicity proof digest")?;
+        for variant in &record.variants {
+            add_digest(
+                &mut values,
+                &variant.proof_digest,
+                "helicity variant proof digest",
+            )?;
+        }
+    }
+    for record in &catalog.evaluator_bindings {
+        add_digest(
+            &mut values,
+            &record.callable_signature,
+            "callable signature digest",
+        )?;
+        for digest in &record.exact_expression_digests {
+            add_digest(&mut values, digest, "evaluator expression digest")?;
+        }
+    }
+    Ok(values)
+}
+
+fn collect_factors(catalog: &SemanticCatalogJson) -> RusticolResult<BTreeSet<FactorKey>> {
+    let mut values = BTreeSet::new();
+    for record in &catalog.parameters {
+        add_optional_factor(&mut values, &record.default_value)?;
+    }
+    for record in &catalog.transitions {
+        add_factor(&mut values, &record.binding_coupling)?;
+        add_factor(&mut values, &record.exact_factor)?;
+        add_optional_factor(&mut values, &record.input_exchange_factor)?;
+    }
+    for record in &catalog.contact_orbit_certificates {
+        add_factor(&mut values, &record.reconstruction_factor)?;
+    }
+    for record in &catalog.contact_orbit_steps {
+        add_factor(&mut values, &record.reconstruction_factor)?;
+    }
+    for record in &catalog.quantum_flows {
+        add_factor(&mut values, &record.exact_coupling)?;
+    }
+    for record in &catalog.closures {
+        add_factor(&mut values, &record.binding_coupling)?;
+        add_factor(&mut values, &record.exact_factor)?;
+        add_optional_factor(&mut values, &record.input_exchange_factor)?;
+        for factor in &record.component_coefficients {
+            add_factor(&mut values, factor)?;
+        }
+    }
+    for record in &catalog.color_contractions {
+        add_factor(&mut values, &record.exact_coefficient)?;
+        for (_, factor) in &record.nc_polynomial {
+            add_factor(&mut values, factor)?;
+        }
+        for witness in &record.transition_witnesses {
+            add_factor(&mut values, &witness.exact_factor)?;
+        }
+    }
+    for record in &catalog.symmetry_proofs {
+        add_factor(&mut values, &record.exact_phase)?;
+    }
+    for record in &catalog.runtime_helicity_contracts {
+        for variant in &record.variants {
+            for factor in &variant.embedding_factors {
+                add_factor(&mut values, factor)?;
+            }
+        }
+    }
+    Ok(values)
+}
+
+impl PrimitiveCatalogs {
+    fn build(catalog: &SemanticCatalogJson, ids: &SectionIds) -> RusticolResult<Self> {
+        let strings = Catalog::from_set(collect_strings(catalog)?, "string catalog")?;
+        let digests = Catalog::from_set(collect_digests(catalog)?, "digest catalog")?;
+        let factors = Catalog::from_set(collect_factors(catalog)?, "factor catalog")?;
+
+        let mut flavour_values = BTreeSet::new();
+        let mut quantum_values = BTreeSet::new();
+        for record in &catalog.sources {
+            flavour_values.insert(record.flavour_flow.clone());
+            quantum_values.insert(qflow(&record.quantum_number_flow));
+        }
+        for record in &catalog.quantum_flows {
+            flavour_values.extend(record.input_flavour_flows.iter().cloned());
+            flavour_values.insert(record.result_flavour_flow.clone());
+            quantum_values.extend(
+                record
+                    .input_quantum_number_flows
+                    .iter()
+                    .map(|flow| qflow(flow)),
+            );
+            quantum_values.insert(qflow(&record.result_quantum_number_flow));
+        }
+        let flavour_flows = Catalog::from_set(flavour_values, "flavour-flow catalog")?;
+        let quantum_number_flows =
+            Catalog::from_set(quantum_values, "quantum-number-flow catalog")?;
+
+        let mut coupling_values = BTreeSet::from([Vec::new()]);
+        coupling_values.extend(
+            catalog
+                .quantum_flows
+                .iter()
+                .map(|record| record.coupling_orders.clone()),
+        );
+        coupling_values.extend(
+            catalog
+                .transitions
+                .iter()
+                .map(|record| record.coupling_orders.clone()),
+        );
+        coupling_values.extend(
+            catalog
+                .closures
+                .iter()
+                .map(|record| record.coupling_orders.clone()),
+        );
+        let coupling_orders = Catalog::from_set(coupling_values, "coupling-order catalog")?;
+
+        let mut u32_values = BTreeSet::from([Vec::new()]);
+        let mut i32_values = BTreeSet::from([Vec::new()]);
+        for record in &catalog.parameters {
+            u32_values.insert(mapped_ids(
+                &record.dependency_parameter_ids,
+                &ids.parameters,
+                "parameter dependency",
+            )?);
+        }
+        for record in &catalog.current_states {
+            u32_values.insert(
+                record
+                    .tensor_ordering
+                    .iter()
+                    .map(|value| string_id(&strings, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+        }
+        for record in &catalog.sources {
+            u32_values.insert(
+                record
+                    .lc_color_seed
+                    .provenance
+                    .iter()
+                    .flat_map(|pair| pair.iter())
+                    .map(|value| string_id(&strings, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+        }
+        for record in &catalog.quantum_flows {
+            u32_values.insert(mapped_ids(
+                &record.input_state_template_ids,
+                &ids.current_states,
+                "quantum-flow input state",
+            )?);
+            u32_values.insert(
+                record
+                    .input_flavour_flows
+                    .iter()
+                    .map(|value| flavour_flows.id(value, "input flavour flow"))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+            u32_values.insert(
+                record
+                    .input_quantum_number_flows
+                    .iter()
+                    .map(|value| {
+                        quantum_number_flows.id(&qflow(value), "input quantum-number flow")
+                    })
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+            i32_values.insert(record.input_spin_states.clone());
+        }
+        for record in &catalog.transitions {
+            u32_values.insert(mapped_ids(
+                &record.input_state_template_ids,
+                &ids.current_states,
+                "transition input state",
+            )?);
+            u32_values.insert(record.canonical_input_order.clone());
+            u32_values.insert(
+                record
+                    .momentum_convention
+                    .iter()
+                    .map(|value| string_id(&strings, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+            u32_values.insert(mapped_ids(
+                &record.coupling_parameter_ids,
+                &ids.parameters,
+                "transition coupling parameter",
+            )?);
+            u32_values.insert(mapped_ids(
+                &record.contact_orbit_step_template_ids,
+                &ids.contact_orbit_steps,
+                "transition contact-orbit step",
+            )?);
+            u32_values.insert(
+                record
+                    .contact_orbit_step_semantic_digests
+                    .iter()
+                    .map(|value| digest_id(&digests, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+        }
+        for record in &catalog.contact_orbit_certificates {
+            u32_values.insert(
+                record
+                    .particles
+                    .iter()
+                    .map(|value| string_id(&strings, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+            u32_values.insert(record.physical_leg_equivalence_classes.to_vec());
+        }
+        for record in &catalog.contact_orbit_steps {
+            u32_values.insert(record.left_covered_legs.clone());
+            u32_values.insert(record.right_covered_legs.clone());
+            i32_values.insert(record.source_particle_legs.to_vec());
+        }
+        for record in &catalog.closures {
+            u32_values.insert(mapped_ids(
+                &record.input_state_template_ids,
+                &ids.current_states,
+                "closure input state",
+            )?);
+            u32_values.insert(record.canonical_input_order.clone());
+            u32_values.insert(mapped_ids(
+                &record.coupling_parameter_ids,
+                &ids.parameters,
+                "closure coupling parameter",
+            )?);
+            u32_values.insert(mapped_ids(
+                &record.eligible_quantum_flow_template_ids,
+                &ids.quantum_flows,
+                "closure quantum flow",
+            )?);
+            u32_values.insert(
+                record
+                    .component_coefficients
+                    .iter()
+                    .map(|value| factor_id(&factors, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+        }
+        for record in &catalog.color_contractions {
+            i32_values.insert(record.input_representations.clone());
+            for witness in &record.transition_witnesses {
+                let (pairings, bindings) = witness.canonical_ports()?;
+                u32_values.insert(
+                    pairings
+                        .iter()
+                        .flat_map(|pairing| pairing.iter())
+                        .flat_map(|port| port.iter().copied())
+                        .collect(),
+                );
+                u32_values.insert(
+                    bindings
+                        .iter()
+                        .flat_map(|port| port.iter().copied())
+                        .collect(),
+                );
+                u32_values.insert(
+                    witness
+                        .provenance
+                        .iter()
+                        .flat_map(|pair| pair.iter())
+                        .map(|value| string_id(&strings, value))
+                        .collect::<RusticolResult<Vec<_>>>()?,
+                );
+            }
+        }
+        for record in &catalog.symmetry_proofs {
+            u32_values.insert(
+                record
+                    .subject_template_ids
+                    .iter()
+                    .map(|value| string_id(&strings, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+            u32_values.insert(record.input_permutation.clone());
+            u32_values.insert(
+                record
+                    .expression_digests
+                    .iter()
+                    .map(|value| digest_id(&digests, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+        }
+        for record in &catalog.evaluator_bindings {
+            u32_values.insert(mapped_ids(
+                &record.input_state_template_ids,
+                &ids.current_states,
+                "evaluator input state",
+            )?);
+            u32_values.insert(
+                record
+                    .input_layout
+                    .iter()
+                    .map(|value| string_id(&strings, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+            u32_values.insert(
+                record
+                    .output_layout
+                    .iter()
+                    .map(|value| string_id(&strings, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+            u32_values.insert(
+                record
+                    .exact_expression_digests
+                    .iter()
+                    .map(|value| digest_id(&digests, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+            u32_values.insert(
+                record
+                    .semantic_template_ids
+                    .iter()
+                    .map(|value| string_id(&strings, value))
+                    .collect::<RusticolResult<Vec<_>>>()?,
+            );
+        }
+
+        Ok(Self {
+            strings,
+            digests,
+            factors,
+            flavour_flows,
+            quantum_number_flows,
+            coupling_orders,
+            u32_sequences: Catalog::from_set(u32_values, "u32 sequence catalog")?,
+            i32_sequences: Catalog::from_set(i32_values, "i32 sequence catalog")?,
+        })
+    }
+}
+
+fn string_id(catalog: &Catalog<String>, value: &str) -> RusticolResult<u32> {
+    catalog.ids.get(value).copied().ok_or_else(|| {
+        invalid(format!(
+            "string {value:?} is absent from the canonical catalog"
+        ))
+    })
+}
+
+fn digest_id(catalog: &Catalog<[u8; 32]>, value: &str) -> RusticolResult<u32> {
+    catalog.id(&parse_digest(value, "digest catalog lookup")?, "digest")
+}
+
+fn factor_id(catalog: &Catalog<FactorKey>, value: &ExactFactorJson) -> RusticolResult<u32> {
+    catalog.id(&value.key()?, "exact factor")
+}
+
+fn optional_factor_id(
+    catalog: &Catalog<FactorKey>,
+    value: &RequiredOption<ExactFactorJson>,
+) -> RusticolResult<u32> {
+    match &value.0 {
+        Some(value) => factor_id(catalog, value),
+        None => Ok(MISSING_U32),
+    }
+}
+
+fn optional_digest_id(
+    catalog: &Catalog<[u8; 32]>,
+    value: &RequiredOption<String>,
+) -> RusticolResult<u32> {
+    match &value.0 {
+        Some(value) => digest_id(catalog, value),
+        None => Ok(MISSING_U32),
+    }
+}
+
+fn pack_sequences<T: Clone + Ord>(
+    catalog: &Catalog<Vec<T>>,
+    context: &str,
+) -> RusticolResult<(Vec<IndexedRangeRow>, Vec<T>)> {
+    let mut ranges = Vec::with_capacity(catalog.values.len());
+    let mut flat = Vec::new();
+    for (index, values) in catalog.values.iter().enumerate() {
+        ranges.push(IndexedRangeRow {
+            id: checked_u32(index, context)?,
+            range: CheckedTableRange::new(
+                checked_u64(flat.len(), context)?,
+                checked_u64(values.len(), context)?,
+            ),
+        });
+        flat.extend(values.iter().cloned());
+    }
+    Ok((ranges, flat))
+}
+
+fn project_catalog(catalog: &SemanticCatalogJson) -> RusticolResult<OwnedRecurrenceTemplateInput> {
+    let ids = SectionIds::build(catalog)?;
+    let primitive = PrimitiveCatalogs::build(catalog, &ids)?;
+
+    let mut string_ranges = Vec::with_capacity(primitive.strings.values.len());
+    let mut string_bytes = Vec::new();
+    for value in &primitive.strings.values {
+        let bytes = value.as_bytes();
+        string_ranges.push(CheckedTableRange::new(
+            checked_u64(string_bytes.len(), "string byte offset")?,
+            checked_u64(bytes.len(), "string byte length")?,
+        ));
+        string_bytes.extend_from_slice(bytes);
+    }
+
+    let digest_catalog = primitive
+        .digests
+        .values
+        .iter()
+        .copied()
+        .enumerate()
+        .map(|(index, value)| {
+            Ok(DigestCatalogRow {
+                id: checked_u32(index, "digest catalog row")?,
+                value,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+    let exact_factors = primitive
+        .factors
+        .values
+        .iter()
+        .enumerate()
+        .map(|(index, factor)| {
+            Ok(ExactFactorRow {
+                id: checked_u32(index, "exact-factor row")?,
+                real_numerator_string_id: string_id(&primitive.strings, &factor.strings[0])?,
+                real_denominator_string_id: string_id(&primitive.strings, &factor.strings[1])?,
+                imag_numerator_string_id: string_id(&primitive.strings, &factor.strings[2])?,
+                imag_denominator_string_id: string_id(&primitive.strings, &factor.strings[3])?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let (flavour_flow_ranges, flavour_flow_values) =
+        pack_sequences(&primitive.flavour_flows, "flavour-flow")?;
+    let (i32_sequence_ranges, i32_sequence_values) =
+        pack_sequences(&primitive.i32_sequences, "i32 sequence")?;
+    let (u32_sequence_ranges, u32_sequence_values) =
+        pack_sequences(&primitive.u32_sequences, "u32 sequence")?;
+    let (coupling_order_ranges, _) = pack_sequences(&primitive.coupling_orders, "coupling-order")?;
+    let coupling_order_terms = primitive
+        .coupling_orders
+        .values
+        .iter()
+        .enumerate()
+        .flat_map(|(set_index, values)| {
+            values
+                .iter()
+                .map(move |(name, power)| (set_index, name, power))
+        })
+        .map(|(set_index, name, power)| {
+            Ok(CouplingOrderTermRow {
+                set_id: checked_u32(set_index, "coupling-order set")?,
+                name_string_id: string_id(&primitive.strings, name)?,
+                power: *power,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let (quantum_number_flow_ranges, _) =
+        pack_sequences(&primitive.quantum_number_flows, "quantum-number flow")?;
+    let quantum_number_flow_terms = primitive
+        .quantum_number_flows
+        .values
+        .iter()
+        .enumerate()
+        .flat_map(|(flow_index, values)| {
+            values
+                .iter()
+                .map(move |(name, expression)| (flow_index, name, expression))
+        })
+        .map(|(flow_index, name, expression)| {
+            Ok(QuantumNumberFlowTermRow {
+                flow_id: checked_u32(flow_index, "quantum-number flow")?,
+                name_string_id: string_id(&primitive.strings, name)?,
+                expression_string_id: string_id(&primitive.strings, expression)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let catalog_header = vec![CatalogHeaderRow {
+        schema_version: RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION,
+        abi_string_id: string_id(&primitive.strings, &catalog.header.abi)?,
+        canonicalization_abi_string_id: string_id(
+            &primitive.strings,
+            &catalog.header.canonicalization_abi,
+        )?,
+        exact_scalar_abi_string_id: string_id(
+            &primitive.strings,
+            &catalog.header.exact_scalar_abi,
+        )?,
+        compiled_model_digest_id: digest_id(
+            &primitive.digests,
+            &catalog.header.compiled_model_digest,
+        )?,
+        prepared_kernel_pack_digest_id: digest_id(
+            &primitive.digests,
+            &catalog.header.prepared_kernel_pack_digest,
+        )?,
+        catalog_digest_id: digest_id(&primitive.digests, &catalog.header.catalog_digest)?,
+        parameter_count: checked_u32(catalog.parameters.len(), "parameter count")?,
+        current_state_count: checked_u32(catalog.current_states.len(), "current-state count")?,
+        source_count: checked_u32(catalog.sources.len(), "source count")?,
+        quantum_flow_count: checked_u32(catalog.quantum_flows.len(), "quantum-flow count")?,
+        contact_orbit_certificate_count: checked_u32(
+            catalog.contact_orbit_certificates.len(),
+            "contact-orbit certificate count",
+        )?,
+        contact_orbit_step_count: checked_u32(
+            catalog.contact_orbit_steps.len(),
+            "contact-orbit step count",
+        )?,
+        transition_count: checked_u32(catalog.transitions.len(), "transition count")?,
+        propagator_count: checked_u32(catalog.propagators.len(), "propagator count")?,
+        closure_count: checked_u32(catalog.closures.len(), "closure count")?,
+        color_contraction_count: checked_u32(
+            catalog.color_contractions.len(),
+            "color-contraction count",
+        )?,
+        symmetry_proof_count: checked_u32(catalog.symmetry_proofs.len(), "symmetry-proof count")?,
+        runtime_helicity_contract_count: checked_u32(
+            catalog.runtime_helicity_contracts.len(),
+            "runtime-helicity contract count",
+        )?,
+        evaluator_binding_count: checked_u32(
+            catalog.evaluator_bindings.len(),
+            "evaluator-binding count",
+        )?,
+    }];
+
+    let parameters = catalog
+        .parameters
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            Ok(ParameterRow {
+                id: checked_u32(index, "parameter row")?,
+                template_string_id: string_id(&primitive.strings, &record.template_id)?,
+                name_string_id: string_id(&primitive.strings, &record.name)?,
+                kind: enum_id(
+                    &record.parameter_kind,
+                    &[("external", 0), ("derived", 1), ("constant", 2)],
+                    "parameter kind",
+                )?,
+                value_type: enum_id(
+                    &record.value_type,
+                    &[("real", 0), ("complex", 1)],
+                    "parameter value type",
+                )?,
+                mutable: u8::from(record.mutable),
+                default_factor_id: optional_factor_id(&primitive.factors, &record.default_value)?,
+                exact_expression_digest_id: optional_digest_id(
+                    &primitive.digests,
+                    &record.exact_expression_digest,
+                )?,
+                dependency_sequence_id: primitive.u32_sequences.id(
+                    &mapped_ids(
+                        &record.dependency_parameter_ids,
+                        &ids.parameters,
+                        "parameter dependency",
+                    )?,
+                    "parameter dependency sequence",
+                )?,
+                prepared_parameter_id: record.prepared_parameter_id.0.unwrap_or(MISSING_U32),
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let current_states = catalog
+        .current_states
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            let tensor_ordering = record
+                .tensor_ordering
+                .iter()
+                .map(|value| string_id(&primitive.strings, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(CurrentStateRow {
+                id: checked_u32(index, "current-state row")?,
+                template_string_id: string_id(&primitive.strings, &record.template_id)?,
+                particle_id: record.particle_id,
+                anti_particle_id: record.anti_particle_id,
+                species_string_id: string_id(&primitive.strings, &record.species_id)?,
+                orientation: enum_id(
+                    &record.orientation,
+                    &[("particle", 0), ("antiparticle", 1), ("self-conjugate", 2)],
+                    "current orientation",
+                )?,
+                statistics: enum_id(
+                    &record.statistics,
+                    &[("boson", 0), ("fermion", 1)],
+                    "particle statistics",
+                )?,
+                color_representation: record.color_representation,
+                basis_string_id: string_id(&primitive.strings, &record.basis)?,
+                tensor_ordering_sequence_id: primitive
+                    .u32_sequences
+                    .id(&tensor_ordering, "tensor-ordering sequence")?,
+                dimension: record.dimension,
+                chirality: record.chirality,
+                lc_color_shape_string_id: string_id(
+                    &primitive.strings,
+                    &record.lc_color_shape_kind,
+                )?,
+                auxiliary_kind_string_id: optional_string_id(
+                    &primitive.strings,
+                    &record.auxiliary_kind,
+                )?,
+                mass_parameter_id: optional_id(
+                    record.mass_parameter_id.0.as_ref(),
+                    &ids.parameters,
+                    "current mass parameter",
+                )?,
+                width_parameter_id: optional_id(
+                    record.width_parameter_id.0.as_ref(),
+                    &ids.parameters,
+                    "current width parameter",
+                )?,
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let sources = catalog
+        .sources
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            let provenance = record
+                .lc_color_seed
+                .provenance
+                .iter()
+                .flat_map(|pair| pair.iter())
+                .map(|value| string_id(&primitive.strings, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(SourceRow {
+                id: checked_u32(index, "source row")?,
+                template_string_id: string_id(&primitive.strings, &record.template_id)?,
+                state_template_id: required_id(
+                    &ids.current_states,
+                    &record.state_template_id,
+                    "source state",
+                )?,
+                crossing_string_id: string_id(&primitive.strings, &record.crossing)?,
+                wavefunction_family_string_id: string_id(
+                    &primitive.strings,
+                    &record.wavefunction_family,
+                )?,
+                helicity: record.helicity,
+                spin_state: record.spin_state,
+                flavour_flow_id: primitive
+                    .flavour_flows
+                    .id(&record.flavour_flow, "source flavour flow")?,
+                quantum_number_flow_id: primitive.quantum_number_flows.id(
+                    &qflow(&record.quantum_number_flow),
+                    "source quantum-number flow",
+                )?,
+                lc_color_seed_operation: enum_id(
+                    &record.lc_color_seed.operation,
+                    &[("empty", 0), ("singleton", 1)],
+                    "LC source-seed operation",
+                )?,
+                lc_color_seed_shape_string_id: string_id(
+                    &primitive.strings,
+                    &record.lc_color_seed.output_shape_kind,
+                )?,
+                lc_color_seed_component_kind: optional_enum_id(
+                    &record.lc_color_seed.component_kind,
+                    &[("open-string", 0), ("adjoint-segment", 1), ("trace", 2)],
+                    "LC source-seed component kind",
+                    255,
+                )?,
+                lc_color_seed_component_role: enum_id(
+                    &record.lc_color_seed.component_role,
+                    &[("active", 0), ("passive", 1), ("none", 2)],
+                    "LC source-seed component role",
+                )?,
+                lc_color_seed_proof_digest_id: digest_id(
+                    &primitive.digests,
+                    &record.lc_color_seed.proof_digest,
+                )?,
+                lc_color_seed_provenance_sequence_id: primitive
+                    .u32_sequences
+                    .id(&provenance, "LC source provenance sequence")?,
+                wavefunction_expression_digest_id: digest_id(
+                    &primitive.digests,
+                    &record.wavefunction_expression_digest,
+                )?,
+                evaluator_binding_id: required_id(
+                    &ids.evaluator_bindings,
+                    &record.evaluator_resolver_key,
+                    "source evaluator",
+                )?,
+                mass_parameter_id: optional_id(
+                    record.mass_parameter_id.0.as_ref(),
+                    &ids.parameters,
+                    "source mass parameter",
+                )?,
+                width_parameter_id: optional_id(
+                    record.width_parameter_id.0.as_ref(),
+                    &ids.parameters,
+                    "source width parameter",
+                )?,
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let quantum_flows = catalog
+        .quantum_flows
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            let input_flavours = record
+                .input_flavour_flows
+                .iter()
+                .map(|value| primitive.flavour_flows.id(value, "input flavour flow"))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let input_quantum = record
+                .input_quantum_number_flows
+                .iter()
+                .map(|value| {
+                    primitive
+                        .quantum_number_flows
+                        .id(&qflow(value), "input quantum-number flow")
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(QuantumFlowRow {
+                id: checked_u32(index, "quantum-flow row")?,
+                template_string_id: string_id(&primitive.strings, &record.template_id)?,
+                input_state_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    mapped_ids(
+                        &record.input_state_template_ids,
+                        &ids.current_states,
+                        "quantum-flow input state",
+                    )?,
+                    "quantum-flow input-state sequence",
+                )?,
+                input_spin_sequence_id: sequence_id(
+                    &primitive.i32_sequences,
+                    record.input_spin_states.clone(),
+                    "quantum-flow spin sequence",
+                )?,
+                input_flavour_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    input_flavours,
+                    "quantum-flow flavour sequence",
+                )?,
+                input_quantum_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    input_quantum,
+                    "quantum-flow quantum-number sequence",
+                )?,
+                flavour_flow_operation_string_id: string_id(
+                    &primitive.strings,
+                    &record.flavour_flow_operation,
+                )?,
+                quantum_number_flow_operation_string_id: string_id(
+                    &primitive.strings,
+                    &record.quantum_number_flow_operation,
+                )?,
+                coupling_order_set_id: primitive
+                    .coupling_orders
+                    .id(&record.coupling_orders, "quantum-flow coupling orders")?,
+                result_state_template_id: required_id(
+                    &ids.current_states,
+                    &record.result_state_template_id,
+                    "quantum-flow result state",
+                )?,
+                result_spin_state: record.result_spin_state,
+                result_flavour_flow_id: primitive
+                    .flavour_flows
+                    .id(&record.result_flavour_flow, "result flavour flow")?,
+                result_quantum_number_flow_id: primitive.quantum_number_flows.id(
+                    &qflow(&record.result_quantum_number_flow),
+                    "result quantum-number flow",
+                )?,
+                exact_coupling_factor_id: factor_id(&primitive.factors, &record.exact_coupling)?,
+                predicate_digest_id: digest_id(&primitive.digests, &record.predicate_digest)?,
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let contact_orbit_certificates = catalog
+        .contact_orbit_certificates
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            let particles = record
+                .particles
+                .iter()
+                .map(|value| string_id(&primitive.strings, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(ContactOrbitCertificateRow {
+                id: checked_u32(index, "contact-orbit certificate row")?,
+                template_string_id: string_id(&primitive.strings, &record.template_id)?,
+                algorithm_string_id: string_id(&primitive.strings, &record.algorithm)?,
+                algorithm_version: record.algorithm_version,
+                term_id: record.term_id,
+                vertex_string_id: string_id(&primitive.strings, &record.vertex)?,
+                particle_string_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    particles,
+                    "contact-orbit particle sequence",
+                )?,
+                evaluator_class_string_id: string_id(&primitive.strings, &record.evaluator_class)?,
+                physical_leg_equivalence_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    record.physical_leg_equivalence_classes.to_vec(),
+                    "contact-orbit equivalence sequence",
+                )?,
+                reconstruction_factor_id: factor_id(
+                    &primitive.factors,
+                    &record.reconstruction_factor,
+                )?,
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let contact_orbit_steps = catalog
+        .contact_orbit_steps
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            Ok(ContactOrbitStepRow {
+                id: checked_u32(index, "contact-orbit step row")?,
+                template_string_id: string_id(&primitive.strings, &record.template_id)?,
+                certificate_id: required_id(
+                    &ids.contact_orbit_certificates,
+                    &record.certificate_template_id,
+                    "contact-orbit certificate",
+                )?,
+                stage: enum_id(
+                    &record.stage,
+                    &[("partial", 0), ("final", 1)],
+                    "contact-orbit stage",
+                )?,
+                result_leg: record.result_leg,
+                left_covered_leg_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    record.left_covered_legs.clone(),
+                    "contact-orbit left legs",
+                )?,
+                right_covered_leg_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    record.right_covered_legs.clone(),
+                    "contact-orbit right legs",
+                )?,
+                source_particle_leg_sequence_id: sequence_id(
+                    &primitive.i32_sequences,
+                    record.source_particle_legs.to_vec(),
+                    "contact-orbit source legs",
+                )?,
+                reconstruction_factor_id: factor_id(
+                    &primitive.factors,
+                    &record.reconstruction_factor,
+                )?,
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let transitions = catalog
+        .transitions
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            let momentum = record
+                .momentum_convention
+                .iter()
+                .map(|value| string_id(&primitive.strings, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let step_digests = record
+                .contact_orbit_step_semantic_digests
+                .iter()
+                .map(|value| digest_id(&primitive.digests, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(TransitionRow {
+                id: checked_u32(index, "transition row")?,
+                template_string_id: string_id(&primitive.strings, &record.template_id)?,
+                input_state_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    mapped_ids(
+                        &record.input_state_template_ids,
+                        &ids.current_states,
+                        "transition input state",
+                    )?,
+                    "transition input-state sequence",
+                )?,
+                result_state_template_id: required_id(
+                    &ids.current_states,
+                    &record.result_state_template_id,
+                    "transition result state",
+                )?,
+                quantum_flow_template_id: required_id(
+                    &ids.quantum_flows,
+                    &record.quantum_flow_template_id,
+                    "transition quantum flow",
+                )?,
+                evaluator_binding_id: required_id(
+                    &ids.evaluator_bindings,
+                    &record.evaluator_resolver_key,
+                    "transition evaluator",
+                )?,
+                canonical_input_order_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    record.canonical_input_order.clone(),
+                    "transition canonical input order",
+                )?,
+                momentum_convention_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    momentum,
+                    "transition momentum convention",
+                )?,
+                coupling_parameter_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    mapped_ids(
+                        &record.coupling_parameter_ids,
+                        &ids.parameters,
+                        "transition coupling parameter",
+                    )?,
+                    "transition coupling parameters",
+                )?,
+                coupling_order_set_id: primitive
+                    .coupling_orders
+                    .id(&record.coupling_orders, "transition coupling orders")?,
+                color_contraction_template_id: required_id(
+                    &ids.color_contractions,
+                    &record.color_contraction_template_id,
+                    "transition color contraction",
+                )?,
+                binding_coupling_factor_id: factor_id(
+                    &primitive.factors,
+                    &record.binding_coupling,
+                )?,
+                exact_factor_id: factor_id(&primitive.factors, &record.exact_factor)?,
+                output_factor_source: enum_id(
+                    &record.output_factor_source,
+                    &[("none", 0), ("coupling-real", 1), ("coupling-imag", 2)],
+                    "transition output-factor source",
+                )?,
+                equivalence_class_string_id: string_id(
+                    &primitive.strings,
+                    &record.equivalence_class,
+                )?,
+                input_exchange_factor_id: optional_factor_id(
+                    &primitive.factors,
+                    &record.input_exchange_factor,
+                )?,
+                output_projection_string_id: string_id(
+                    &primitive.strings,
+                    &record.output_projection,
+                )?,
+                contact_orbit_step_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    mapped_ids(
+                        &record.contact_orbit_step_template_ids,
+                        &ids.contact_orbit_steps,
+                        "transition contact-orbit step",
+                    )?,
+                    "transition contact-orbit steps",
+                )?,
+                contact_orbit_step_semantic_digest_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    step_digests,
+                    "transition contact-orbit digests",
+                )?,
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let propagators = catalog
+        .propagators
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            Ok(PropagatorRow {
+                id: checked_u32(index, "propagator row")?,
+                template_string_id: string_id(&primitive.strings, &record.template_id)?,
+                state_template_id: required_id(
+                    &ids.current_states,
+                    &record.state_template_id,
+                    "propagator state",
+                )?,
+                applies_propagator: u8::from(record.applies_propagator),
+                evaluator_binding_id: optional_id(
+                    record.evaluator_resolver_key.0.as_ref(),
+                    &ids.evaluator_bindings,
+                    "propagator evaluator",
+                )?,
+                numerator_expression_digest_id: optional_digest_id(
+                    &primitive.digests,
+                    &record.numerator_expression_digest,
+                )?,
+                denominator_expression_digest_id: optional_digest_id(
+                    &primitive.digests,
+                    &record.denominator_expression_digest,
+                )?,
+                mass_parameter_id: optional_id(
+                    record.mass_parameter_id.0.as_ref(),
+                    &ids.parameters,
+                    "propagator mass parameter",
+                )?,
+                width_parameter_id: optional_id(
+                    record.width_parameter_id.0.as_ref(),
+                    &ids.parameters,
+                    "propagator width parameter",
+                )?,
+                gauge_string_id: optional_string_id(&primitive.strings, &record.gauge)?,
+                linearity_proof_template_id: optional_id(
+                    record.linearity_proof_template_id.0.as_ref(),
+                    &ids.symmetry_proofs,
+                    "propagator linearity proof",
+                )?,
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let closures = catalog
+        .closures
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            let coefficients = record
+                .component_coefficients
+                .iter()
+                .map(|value| factor_id(&primitive.factors, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(ClosureRow {
+                id: checked_u32(index, "closure row")?,
+                template_string_id: string_id(&primitive.strings, &record.template_id)?,
+                input_state_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    mapped_ids(
+                        &record.input_state_template_ids,
+                        &ids.current_states,
+                        "closure input state",
+                    )?,
+                    "closure input states",
+                )?,
+                result_state_template_id: optional_id(
+                    record.result_state_template_id.0.as_ref(),
+                    &ids.current_states,
+                    "closure result state",
+                )?,
+                evaluator_binding_id: required_id(
+                    &ids.evaluator_bindings,
+                    &record.evaluator_resolver_key,
+                    "closure evaluator",
+                )?,
+                canonical_input_order_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    record.canonical_input_order.clone(),
+                    "closure canonical input order",
+                )?,
+                coupling_parameter_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    mapped_ids(
+                        &record.coupling_parameter_ids,
+                        &ids.parameters,
+                        "closure coupling parameter",
+                    )?,
+                    "closure coupling parameters",
+                )?,
+                coupling_order_set_id: primitive
+                    .coupling_orders
+                    .id(&record.coupling_orders, "closure coupling orders")?,
+                eligible_quantum_flow_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    mapped_ids(
+                        &record.eligible_quantum_flow_template_ids,
+                        &ids.quantum_flows,
+                        "closure quantum flow",
+                    )?,
+                    "closure eligible quantum flows",
+                )?,
+                color_contraction_template_id: required_id(
+                    &ids.color_contractions,
+                    &record.color_contraction_template_id,
+                    "closure color contraction",
+                )?,
+                binding_coupling_factor_id: factor_id(
+                    &primitive.factors,
+                    &record.binding_coupling,
+                )?,
+                exact_factor_id: factor_id(&primitive.factors, &record.exact_factor)?,
+                output_factor_source: enum_id(
+                    &record.output_factor_source,
+                    &[("none", 0), ("coupling-real", 1), ("coupling-imag", 2)],
+                    "closure output-factor source",
+                )?,
+                equivalence_class_string_id: string_id(
+                    &primitive.strings,
+                    &record.equivalence_class,
+                )?,
+                input_exchange_factor_id: optional_factor_id(
+                    &primitive.factors,
+                    &record.input_exchange_factor,
+                )?,
+                projection_string_id: string_id(&primitive.strings, &record.projection)?,
+                component_coefficient_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    coefficients,
+                    "closure component coefficients",
+                )?,
+                chirality_relation_string_id: string_id(
+                    &primitive.strings,
+                    &record.chirality_relation,
+                )?,
+                metric_signature_string_id: optional_string_id(
+                    &primitive.strings,
+                    &record.metric_signature,
+                )?,
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let mut color_contractions = Vec::with_capacity(catalog.color_contractions.len());
+    let mut lc_color_transition_witnesses = Vec::new();
+    let mut color_nc_terms = Vec::new();
+    for (color_index, record) in catalog.color_contractions.iter().enumerate() {
+        let color_id = checked_u32(color_index, "color-contraction row")?;
+        let witness_start =
+            checked_u64(lc_color_transition_witnesses.len(), "color witness offset")?;
+        let nc_term_start = checked_u64(color_nc_terms.len(), "color Nc offset")?;
+        for (ordinal, witness) in record.transition_witnesses.iter().enumerate() {
+            let (pairings, bindings) = witness.canonical_ports()?;
+            let flattened_pairings = pairings
+                .iter()
+                .flat_map(|pairing| pairing.iter())
+                .flat_map(|port| port.iter().copied())
+                .collect::<Vec<_>>();
+            let flattened_bindings = bindings
+                .iter()
+                .flat_map(|port| port.iter().copied())
+                .collect::<Vec<_>>();
+            let provenance = witness
+                .provenance
+                .iter()
+                .flat_map(|pair| pair.iter())
+                .map(|value| string_id(&primitive.strings, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let input_permutation = match witness.input_permutation {
+                [0, 1] => 0,
+                [1, 0] => 1,
+                value => {
+                    return Err(invalid(format!(
+                        "unsupported LC witness input permutation {value:?}"
+                    )));
+                }
+            };
+            lc_color_transition_witnesses.push(LCColorTransitionWitnessRow {
+                color_contraction_id: color_id,
+                ordinal: checked_u32(ordinal, "color witness ordinal")?,
+                left_shape_string_id: string_id(&primitive.strings, &witness.input_shape_kinds[0])?,
+                right_shape_string_id: string_id(
+                    &primitive.strings,
+                    &witness.input_shape_kinds[1],
+                )?,
+                input_permutation,
+                reverse_parent_mask: witness.reverse_parent_mask,
+                component_operation: enum_id(
+                    &witness.component_operation,
+                    &[
+                        ("concatenate-join", 0),
+                        ("concatenate-keep", 1),
+                        ("inherit-left", 2),
+                        ("inherit-right", 3),
+                        ("empty", 4),
+                        ("close", 5),
+                    ],
+                    "LC witness component operation",
+                )?,
+                result_component_kind: optional_enum_id(
+                    &witness.result_component_kind,
+                    &[("open-string", 0), ("adjoint-segment", 1), ("trace", 2)],
+                    "LC witness component kind",
+                    255,
+                )?,
+                result_component_role: enum_id(
+                    &witness.result_component_role,
+                    &[("active", 0), ("passive", 1), ("none", 2)],
+                    "LC witness component role",
+                )?,
+                result_shape_string_id: optional_string_id(
+                    &primitive.strings,
+                    &witness.result_shape_kind,
+                )?,
+                exact_factor_id: factor_id(&primitive.factors, &witness.exact_factor)?,
+                proof_digest_id: digest_id(&primitive.digests, &witness.proof_digest)?,
+                input_port_pairing_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    flattened_pairings,
+                    "LC witness port pairings",
+                )?,
+                result_port_binding_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    flattened_bindings,
+                    "LC witness result bindings",
+                )?,
+                provenance_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    provenance,
+                    "LC witness provenance",
+                )?,
+            });
+        }
+        for (exponent, factor) in &record.nc_polynomial {
+            color_nc_terms.push(ColorNcTermRow {
+                color_contraction_id: color_id,
+                exponent: *exponent,
+                factor_id: factor_id(&primitive.factors, factor)?,
+            });
+        }
+        color_contractions.push(ColorContractionRow {
+            id: color_id,
+            template_string_id: string_id(&primitive.strings, &record.template_id)?,
+            rule_kind_string_id: string_id(&primitive.strings, &record.rule_kind)?,
+            input_representation_sequence_id: sequence_id(
+                &primitive.i32_sequences,
+                record.input_representations.clone(),
+                "color input representations",
+            )?,
+            has_output_representation: u8::from(record.output_representation.0.is_some()),
+            output_representation: record.output_representation.0.unwrap_or(0),
+            ordered_open_string_arity: record.ordered_open_string_arity,
+            exact_coefficient_factor_id: factor_id(&primitive.factors, &record.exact_coefficient)?,
+            witness_start,
+            witness_count: checked_u64(record.transition_witnesses.len(), "color witness count")?,
+            nc_term_start,
+            nc_term_count: checked_u64(record.nc_polynomial.len(), "color Nc count")?,
+            expression_digest_id: digest_id(&primitive.digests, &record.expression_digest)?,
+            semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+        });
+    }
+
+    let symmetry_proofs = catalog
+        .symmetry_proofs
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            let subjects = record
+                .subject_template_ids
+                .iter()
+                .map(|value| string_id(&primitive.strings, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let expressions = record
+                .expression_digests
+                .iter()
+                .map(|value| digest_id(&primitive.digests, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(SymmetryProofRow {
+                id: checked_u32(index, "symmetry-proof row")?,
+                template_string_id: string_id(&primitive.strings, &record.template_id)?,
+                proof_algorithm_string_id: string_id(&primitive.strings, &record.proof_algorithm)?,
+                subject_template_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    subjects,
+                    "symmetry-proof subjects",
+                )?,
+                input_permutation_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    record.input_permutation.clone(),
+                    "symmetry-proof input permutation",
+                )?,
+                exact_phase_factor_id: factor_id(&primitive.factors, &record.exact_phase)?,
+                expression_digest_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    expressions,
+                    "symmetry-proof expressions",
+                )?,
+                witness_digest_id: digest_id(&primitive.digests, &record.witness_digest)?,
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let mut runtime_helicity_contracts = Vec::new();
+    let mut runtime_helicity_variants = Vec::new();
+    let mut runtime_helicity_embeddings = Vec::new();
+    let mut runtime_helicity_projections = Vec::new();
+    for (contract_index, record) in catalog.runtime_helicity_contracts.iter().enumerate() {
+        let contract_id = checked_u32(contract_index, "runtime-helicity contract")?;
+        let variant_start = checked_u64(
+            runtime_helicity_variants.len(),
+            "runtime-helicity variant offset",
+        )?;
+        for variant in &record.variants {
+            let variant_id =
+                checked_u32(runtime_helicity_variants.len(), "runtime-helicity variant")?;
+            let embedding_start = checked_u64(
+                runtime_helicity_embeddings.len(),
+                "runtime-helicity embedding offset",
+            )?;
+            for (full_component, (source_component, factor)) in variant
+                .embedding_source_components
+                .iter()
+                .zip(&variant.embedding_factors)
+                .enumerate()
+            {
+                runtime_helicity_embeddings.push(RuntimeHelicityEmbeddingRow {
+                    variant_id,
+                    full_component: checked_u32(full_component, "full helicity component")?,
+                    source_component: source_component.unwrap_or(MISSING_U32),
+                    factor_id: factor_id(&primitive.factors, factor)?,
+                });
+            }
+            let projection_start = checked_u64(
+                runtime_helicity_projections.len(),
+                "runtime-helicity projection offset",
+            )?;
+            for (source_component, full_component) in variant
+                .projection_full_components
+                .iter()
+                .copied()
+                .enumerate()
+            {
+                runtime_helicity_projections.push(RuntimeHelicityProjectionRow {
+                    variant_id,
+                    source_component: checked_u32(source_component, "source helicity component")?,
+                    full_component,
+                });
+            }
+            runtime_helicity_variants.push(RuntimeHelicityVariantRow {
+                id: variant_id,
+                contract_id,
+                source_template_id: required_id(
+                    &ids.sources,
+                    &variant.source_template_id,
+                    "runtime-helicity source",
+                )?,
+                source_state_template_id: required_id(
+                    &ids.current_states,
+                    &variant.source_state_template_id,
+                    "runtime-helicity source state",
+                )?,
+                embedding_range: CheckedTableRange::new(
+                    embedding_start,
+                    checked_u64(
+                        variant.embedding_source_components.len(),
+                        "runtime-helicity embedding count",
+                    )?,
+                ),
+                projection_range: CheckedTableRange::new(
+                    projection_start,
+                    checked_u64(
+                        variant.projection_full_components.len(),
+                        "runtime-helicity projection count",
+                    )?,
+                ),
+                proof_digest_id: digest_id(&primitive.digests, &variant.proof_digest)?,
+            });
+        }
+        runtime_helicity_contracts.push(RuntimeHelicityContractRow {
+            id: contract_id,
+            template_string_id: string_id(&primitive.strings, &record.template_id)?,
+            full_state_template_id: required_id(
+                &ids.current_states,
+                &record.full_state_template_id,
+                "runtime-helicity full state",
+            )?,
+            variant_range: CheckedTableRange::new(
+                variant_start,
+                checked_u64(record.variants.len(), "runtime-helicity variant count")?,
+            ),
+            proof_algorithm_string_id: string_id(&primitive.strings, &record.proof_algorithm)?,
+            proof_digest_id: digest_id(&primitive.digests, &record.proof_digest)?,
+            semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+        });
+    }
+
+    let evaluator_bindings = catalog
+        .evaluator_bindings
+        .iter()
+        .enumerate()
+        .map(|(index, record)| {
+            let input_layout = record
+                .input_layout
+                .iter()
+                .map(|value| string_id(&primitive.strings, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let output_layout = record
+                .output_layout
+                .iter()
+                .map(|value| string_id(&primitive.strings, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let expressions = record
+                .exact_expression_digests
+                .iter()
+                .map(|value| digest_id(&primitive.digests, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            let semantic_templates = record
+                .semantic_template_ids
+                .iter()
+                .map(|value| string_id(&primitive.strings, value))
+                .collect::<RusticolResult<Vec<_>>>()?;
+            Ok(EvaluatorBindingRow {
+                id: checked_u32(index, "evaluator-binding row")?,
+                resolver_key_string_id: string_id(&primitive.strings, &record.resolver_key)?,
+                prepared_kernel_id: record.prepared_kernel_id.0.unwrap_or(MISSING_U32),
+                contract_kind: enum_id(
+                    &record.contract_kind,
+                    &[
+                        ("source", 0),
+                        ("vertex", 1),
+                        ("propagator", 2),
+                        ("closure", 3),
+                        ("model-parameter", 4),
+                    ],
+                    "evaluator contract kind",
+                )?,
+                callable_signature_digest_id: digest_id(
+                    &primitive.digests,
+                    &record.callable_signature,
+                )?,
+                input_state_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    mapped_ids(
+                        &record.input_state_template_ids,
+                        &ids.current_states,
+                        "evaluator input state",
+                    )?,
+                    "evaluator input states",
+                )?,
+                output_state_template_id: optional_id(
+                    record.output_state_template_id.0.as_ref(),
+                    &ids.current_states,
+                    "evaluator output state",
+                )?,
+                input_layout_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    input_layout,
+                    "evaluator input layout",
+                )?,
+                output_layout_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    output_layout,
+                    "evaluator output layout",
+                )?,
+                exact_expression_digest_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    expressions,
+                    "evaluator expressions",
+                )?,
+                semantic_template_sequence_id: sequence_id(
+                    &primitive.u32_sequences,
+                    semantic_templates,
+                    "evaluator semantic templates",
+                )?,
+                callable_kind: enum_id(
+                    &record.callable_kind,
+                    &[("prepared-kernel", 0), ("rusticol-template", 1)],
+                    "evaluator callable kind",
+                )?,
+                runtime_template_string_id: optional_string_id(
+                    &primitive.strings,
+                    &record.runtime_template,
+                )?,
+                semantic_digest_id: digest_id(&primitive.digests, &record.semantic_digest)?,
+            })
+        })
+        .collect::<RusticolResult<Vec<_>>>()?;
+
+    let input = OwnedRecurrenceTemplateInput {
+        input_abi: RECURRENCE_TEMPLATE_INPUT_ABI.to_owned(),
+        catalog_digest: semantic_digest(&catalog.header.catalog_digest, "catalog digest")?,
+        compiled_model_digest: semantic_digest(
+            &catalog.header.compiled_model_digest,
+            "compiled-model digest",
+        )?,
+        prepared_kernel_pack_digest: semantic_digest(
+            &catalog.header.prepared_kernel_pack_digest,
+            "prepared-kernel-pack digest",
+        )?,
+        catalog_header,
+        coupling_order_ranges,
+        coupling_order_terms,
+        contact_orbit_certificates,
+        contact_orbit_steps,
+        current_states,
+        digest_catalog,
+        evaluator_bindings,
+        exact_factors,
+        flavour_flow_ranges,
+        flavour_flow_values,
+        i32_sequence_ranges,
+        i32_sequence_values,
+        parameters,
+        propagators,
+        quantum_flows,
+        quantum_number_flow_ranges,
+        quantum_number_flow_terms,
+        runtime_helicity_contracts,
+        runtime_helicity_variants,
+        runtime_helicity_embeddings,
+        runtime_helicity_projections,
+        sources,
+        string_ranges,
+        string_bytes,
+        symmetry_proofs,
+        transitions,
+        closures,
+        color_contractions,
+        lc_color_transition_witnesses,
+        color_nc_terms,
+        u32_sequence_ranges,
+        u32_sequence_values,
+    };
+    input.as_view().validate()?;
+    Ok(input)
+}
+
+fn required_id(ids: &BTreeMap<String, u32>, value: &str, context: &str) -> RusticolResult<u32> {
+    ids.get(value)
+        .copied()
+        .ok_or_else(|| invalid(format!("unknown {context} {value:?}")))
+}
+
+fn optional_string_id(
+    catalog: &Catalog<String>,
+    value: &RequiredOption<String>,
+) -> RusticolResult<u32> {
+    match &value.0 {
+        Some(value) => string_id(catalog, value),
+        None => Ok(MISSING_U32),
+    }
+}
+
+fn optional_enum_id(
+    value: &RequiredOption<String>,
+    choices: &[(&str, u8)],
+    context: &str,
+    missing: u8,
+) -> RusticolResult<u8> {
+    match &value.0 {
+        Some(value) => enum_id(value, choices, context),
+        None => Ok(missing),
+    }
+}
+
+fn sequence_id<T: Clone + Ord>(
+    catalog: &Catalog<Vec<T>>,
+    values: Vec<T>,
+    context: &str,
+) -> RusticolResult<u32> {
+    catalog.id(&values, context)
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{Value, json};
+
+    use super::{
+        ROOT_SECTIONS, canonical_json_digest, project_owned_recurrence_template_catalog_json_v1,
+        project_recurrence_template_catalog_json_v1, write_canonical_json,
+    };
+
+    const COMPILED_DIGEST: &str =
+        "1111111111111111111111111111111111111111111111111111111111111111";
+    const PACK_DIGEST: &str = "2222222222222222222222222222222222222222222222222222222222222222";
+    const EMPTY_CATALOG_DIGEST: &str =
+        "93c542973b80e35e8300b4c25182cb0900040f9893dc6671b4af628062b9fbec";
+
+    fn empty_catalog() -> Value {
+        json!({
+            "header": {
+                "abi": "pyamplicol-recurrence-template-v1",
+                "canonicalization_abi": "pyamplicol-canonical-json-v1",
+                "compiled_model_digest": COMPILED_DIGEST,
+                "exact_scalar_abi": "pyamplicol-exact-complex-rational-v1",
+                "prepared_kernel_pack_digest": PACK_DIGEST,
+                "catalog_digest": EMPTY_CATALOG_DIGEST,
+            },
+            "parameters": [],
+            "current_states": [],
+            "sources": [],
+            "quantum_flows": [],
+            "contact_orbit_certificates": [],
+            "contact_orbit_steps": [],
+            "transitions": [],
+            "propagators": [],
+            "closures": [],
+            "color_contractions": [],
+            "symmetry_proofs": [],
+            "runtime_helicity_contracts": [],
+            "evaluator_bindings": [],
+        })
+    }
+
+    fn refresh_catalog_digest(value: &mut Value) {
+        let mut payload = value.clone();
+        payload["header"]
+            .as_object_mut()
+            .expect("test header")
+            .remove("catalog_digest");
+        let digest = canonical_json_digest(&payload).expect("canonical test digest");
+        value["header"]["catalog_digest"] = Value::String(digest);
+    }
+
+    #[test]
+    fn project_empty_catalog_matches_known_python_contract() {
+        let input = project_recurrence_template_catalog_json_v1(&empty_catalog())
+            .expect("known Python empty catalog must project");
+        assert_eq!(input.input_abi, "pyamplicol-recurrence-template-input-v1");
+        assert_eq!(input.catalog_header.len(), 1);
+        assert_eq!(input.catalog_header[0].parameter_count, 0);
+        assert_eq!(input.catalog_header[0].evaluator_binding_count, 0);
+        assert_eq!(input.string_ranges.len(), 4);
+        assert_eq!(input.digest_catalog.len(), 3);
+        assert_eq!(input.coupling_order_ranges.len(), 1);
+        assert_eq!(input.u32_sequence_ranges.len(), 1);
+        assert_eq!(input.i32_sequence_ranges.len(), 1);
+        assert!(input.exact_factors.is_empty());
+        input
+            .clone()
+            .validate()
+            .expect("projected empty catalog must satisfy core validation");
+    }
+
+    #[test]
+    fn owned_projection_preserves_the_authenticated_contract() {
+        let catalog = empty_catalog();
+        let retained = project_recurrence_template_catalog_json_v1(&catalog)
+            .expect("retained catalog must project")
+            .validate()
+            .expect("retained projection must validate");
+        let owned = project_owned_recurrence_template_catalog_json_v1(catalog)
+            .expect("owned catalog must project")
+            .validate()
+            .expect("owned projection must validate");
+        assert_eq!(owned.summary(), retained.summary());
+
+        let mut stale = empty_catalog();
+        stale["header"]["catalog_digest"] = Value::String(COMPILED_DIGEST.to_owned());
+        let error = project_owned_recurrence_template_catalog_json_v1(stale)
+            .expect_err("owned stale catalog must fail closed");
+        assert!(
+            error
+                .to_string()
+                .contains("stale recurrence-template catalog digest"),
+            "unexpected validation error: {error}"
+        );
+    }
+
+    #[test]
+    fn root_inventory_is_exact_and_all_thirteen_sections_are_required() {
+        assert_eq!(ROOT_SECTIONS.len(), 13);
+
+        let mut unknown = empty_catalog();
+        unknown["opaque"] = json!([]);
+        refresh_catalog_digest(&mut unknown);
+        let error = project_recurrence_template_catalog_json_v1(&unknown)
+            .expect_err("unknown root field must fail closed");
+        assert!(
+            error.to_string().contains("unknown field `opaque`"),
+            "unexpected validation error: {error}"
+        );
+
+        for (section, _, _) in ROOT_SECTIONS {
+            let mut missing = empty_catalog();
+            missing
+                .as_object_mut()
+                .expect("test catalog")
+                .remove(section);
+            let error = project_recurrence_template_catalog_json_v1(&missing)
+                .expect_err("missing semantic section must fail closed");
+            assert!(
+                error.to_string().contains(section),
+                "missing {section} produced unexpected validation error: {error}"
+            );
+        }
+    }
+
+    #[test]
+    fn stale_catalog_digest_fails_before_projection() {
+        let mut catalog = empty_catalog();
+        catalog["header"]["catalog_digest"] = Value::String(COMPILED_DIGEST.to_owned());
+        let error = project_recurrence_template_catalog_json_v1(&catalog)
+            .expect_err("stale catalog digest must fail closed");
+        assert!(
+            error
+                .to_string()
+                .contains("stale recurrence-template catalog digest"),
+            "unexpected validation error: {error}"
+        );
+    }
+
+    #[test]
+    fn canonical_json_matches_python_ascii_contract() {
+        let value = json!({"z": "é\n", "a": [true, null, "λ", -2]});
+        let mut output = String::new();
+        write_canonical_json(&value, &mut output).expect("canonical writer");
+        assert_eq!(
+            output,
+            "{\"a\":[true,null,\"\\u03bb\",-2],\"z\":\"\\u00e9\\n\"}"
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/recurrence/tests.rs b/pyamplicol/rust/crates/rusticol-core/src/recurrence/tests.rs
new file mode 100644
index 0000000000..7e3b1511fe
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/recurrence/tests.rs
@@ -0,0 +1,707 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::cmp::Ordering;
+
+use super::*;
+
+fn digest(byte: u8) -> SemanticDigest {
+    SemanticDigest::new([byte; 32]).expect("test digest must be nonzero")
+}
+
+fn momentum(slot: u32) -> CanonicalMomentumLinearForm {
+    CanonicalMomentumLinearForm::new(vec![MomentumTerm {
+        source_slot: slot,
+        coefficient: 1,
+    }])
+    .expect("test momentum is canonical")
+}
+
+#[test]
+fn abi_constants_are_frozen() {
+    assert_eq!(RECURRENCE_TEMPLATE_ABI, "pyamplicol-recurrence-template-v1");
+    assert_eq!(
+        RECURRENCE_BUILDER_INPUT_ABI,
+        "pyamplicol-recurrence-builder-input-v2"
+    );
+    assert_eq!(
+        RECURRENCE_BUILDER_RESULT_ABI,
+        "pyamplicol-recurrence-builder-result-v2"
+    );
+    assert_eq!(RECURRENCE_PLAN_ABI, "pyamplicol-recurrence-plan-v2");
+    assert_eq!(
+        RECURRENCE_RUNTIME_LAYOUT_ABI,
+        "pyamplicol-recurrence-runtime-layout-v2"
+    );
+    assert_eq!(
+        RECURRENCE_RUNTIME_KIND,
+        "pyamplicol-runtime-recurrence-execution"
+    );
+    assert_eq!(
+        RECURRENCE_RUNTIME_CAPABILITY,
+        "rusticol.recurrence-direct-arena.complex-f64.v1"
+    );
+    assert_eq!(
+        RECURRENCE_LC_COLOR_CAPABILITY,
+        "rusticol.recurrence-color.lc.v1"
+    );
+}
+
+#[test]
+fn dynamic_union_spin_sentinel_is_rejected_as_concrete_input() {
+    for context in [
+        "process source spin",
+        "template source spin",
+        "quantum input spin",
+        "quantum result spin",
+    ] {
+        assert!(validate_concrete_spin_state(-1, context).is_ok());
+        let error = validate_concrete_spin_state(DYNAMIC_UNION_SOURCE_SPIN_STATE_CLASS, context)
+            .unwrap_err()
+            .to_string();
+        assert!(error.contains("reserved dynamic-union source-spin sentinel"));
+    }
+}
+
+#[test]
+fn exact_rationals_parse_reduce_and_canonicalize_zero() {
+    let value = ExactRational::parse_parts("-42", "56").unwrap();
+    assert_eq!(value.numerator(), -3);
+    assert_eq!(value.denominator(), 4);
+    assert_eq!(value.to_string(), "-3/4");
+    assert_eq!(
+        "000/009".parse::<ExactRational>().unwrap(),
+        ExactRational::ZERO
+    );
+    assert!(ExactRational::parse_parts("1", "0").is_err());
+    assert!(ExactRational::parse_parts("1", "-2").is_err());
+    assert!("1/2/3".parse::<ExactRational>().is_err());
+}
+
+#[test]
+fn exact_aggregation_distinguishes_binary64_collision() {
+    let one = ExactRational::ONE;
+    let epsilon = ExactRational::new(1, 1_i128 << 54).unwrap();
+    let sum = one.checked_add(epsilon).unwrap();
+    assert_ne!(sum, one);
+    assert_eq!(sum.checked_sub(one).unwrap(), epsilon);
+    assert_eq!(1.0_f64 + 2.0_f64.powi(-54), 1.0_f64);
+}
+
+#[test]
+fn exact_ordering_avoids_cross_multiplication_overflow() {
+    let maximum = i128::MAX;
+    let left = ExactRational::new(maximum - 1, maximum).unwrap();
+    let right = ExactRational::new(maximum - 2, maximum - 1).unwrap();
+    assert_eq!(left.cmp(&right), Ordering::Greater);
+}
+
+#[test]
+fn exact_arithmetic_fails_closed_on_overflow() {
+    let large = ExactRational::new(i128::MAX, 1).unwrap();
+    assert!(large.checked_add(ExactRational::ONE).is_err());
+    assert!(
+        large
+            .checked_mul(ExactRational::new(2, 1).unwrap())
+            .is_err()
+    );
+    assert!(ExactRational::ONE.checked_div(ExactRational::ZERO).is_err());
+}
+
+#[test]
+fn binary64_conversion_is_exact_or_rejected() {
+    assert_eq!(
+        ExactRational::from_f64_exact(0.1).unwrap(),
+        ExactRational::new(3_602_879_701_896_397, 36_028_797_018_963_968).unwrap()
+    );
+    assert_eq!(
+        ExactRational::from_f64_exact(-0.0).unwrap(),
+        ExactRational::ZERO
+    );
+    assert!(ExactRational::from_f64_exact(f64::INFINITY).is_err());
+    assert!(ExactRational::from_f64_exact(f64::from_bits(1)).is_err());
+}
+
+#[test]
+fn exact_complex_arithmetic_is_canonical() {
+    let left = ExactComplexRational::parse_parts("1", "2", "1", "3").unwrap();
+    let right = ExactComplexRational::parse_parts("2", "5", "-1", "7").unwrap();
+    let product = left.checked_mul(right).unwrap();
+    assert_eq!(product.real(), ExactRational::new(26, 105).unwrap());
+    assert_eq!(product.imag(), ExactRational::new(13, 210).unwrap());
+    assert_eq!(product.checked_div(right).unwrap(), left);
+}
+
+#[test]
+fn checked_ranges_reject_overflow_gaps_and_bounds() {
+    assert!(CheckedTableRange::new(u64::MAX, 1).end("test").is_err());
+    assert!(validate_ranges_within("test", &[CheckedTableRange::new(2, 2)], 3).is_err());
+    assert!(
+        validate_packed_ranges(
+            "test",
+            &[CheckedTableRange::new(0, 1), CheckedTableRange::new(2, 1)],
+            3
+        )
+        .is_err()
+    );
+    validate_packed_ranges(
+        "test",
+        &[CheckedTableRange::new(0, 1), CheckedTableRange::new(1, 2)],
+        3,
+    )
+    .unwrap();
+}
+
+#[test]
+fn table_validators_reject_mismatched_columns_and_references() {
+    assert!(validate_equal_column_lengths("table", &[("a", 2), ("b", 1)]).is_err());
+    assert!(validate_u32_references(&[0, 2], 2, "reference").is_err());
+    validate_equal_column_lengths("table", &[("a", 2), ("b", 2)]).unwrap();
+    validate_u32_references(&[0, 1], 2, "reference").unwrap();
+}
+
+#[test]
+fn multiword_masks_retain_high_bits_and_validate_canonical_form() {
+    let ranges = [CheckedTableRange::new(0, 0), CheckedTableRange::new(0, 2)];
+    let populations = [0, 2];
+    let words = [1, 1_u64 << 63];
+    let catalog = MultiwordMaskCatalogView {
+        ranges: &ranges,
+        populations: &populations,
+        words: &words,
+    };
+    catalog.validate(true).unwrap();
+    assert!(catalog.contains(1, 0).unwrap());
+    assert!(catalog.contains(1, 127).unwrap());
+    assert!(!catalog.contains(1, 126).unwrap());
+
+    let invalid_words = [1, 0];
+    let invalid = MultiwordMaskCatalogView {
+        ranges: &[CheckedTableRange::new(0, 2)],
+        populations: &[1],
+        words: &invalid_words,
+    };
+    assert!(invalid.validate(false).is_err());
+}
+
+fn header_for(
+    strategy: RecurrenceStrategy,
+    sections: &[CanonicalInputSection<'_>],
+) -> RecurrenceBuilderInputHeader {
+    let placeholder = digest(9);
+    let mut header = RecurrenceBuilderInputHeader::canonical(
+        strategy,
+        sections.len() as u32,
+        digest(1),
+        digest(2),
+        digest(3),
+        placeholder,
+    );
+    header.input_digest = canonical_input_digest(&header, sections).unwrap();
+    header
+}
+
+#[test]
+fn input_header_digest_is_deterministic_and_authenticated() {
+    let sections = [
+        CanonicalInputSection {
+            name: "catalogs/states",
+            row_width: 2,
+            row_count: 2,
+            bytes: &[1, 2, 3, 4],
+        },
+        CanonicalInputSection {
+            name: "process/legs",
+            row_width: 1,
+            row_count: 2,
+            bytes: &[5, 6],
+        },
+    ];
+    let header = header_for(RecurrenceStrategy::TopologyReplay, &sections);
+    validate_header_and_sections(&header, &sections).unwrap();
+    assert_eq!(
+        canonical_input_digest(&header, &sections).unwrap(),
+        header.input_digest
+    );
+
+    let modified = [
+        sections[0],
+        CanonicalInputSection {
+            bytes: &[5, 7],
+            ..sections[1]
+        },
+    ];
+    assert!(validate_header_and_sections(&header, &modified).is_err());
+}
+
+#[test]
+fn input_header_rejects_noncanonical_sections_and_abi_drift() {
+    let sections = [
+        CanonicalInputSection {
+            name: "z",
+            row_width: 1,
+            row_count: 1,
+            bytes: &[0],
+        },
+        CanonicalInputSection {
+            name: "a",
+            row_width: 1,
+            row_count: 1,
+            bytes: &[0],
+        },
+    ];
+    let mut header = RecurrenceBuilderInputHeader::canonical(
+        RecurrenceStrategy::AllFlowUnion,
+        2,
+        digest(1),
+        digest(2),
+        digest(3),
+        digest(4),
+    );
+    assert!(validate_header_and_sections(&header, &sections).is_err());
+    let canonical_section = [CanonicalInputSection {
+        name: "a",
+        row_width: 1,
+        row_count: 1,
+        bytes: &[0],
+    }];
+    let wrong_count_header = RecurrenceBuilderInputHeader::canonical(
+        RecurrenceStrategy::AllFlowUnion,
+        2,
+        digest(1),
+        digest(2),
+        digest(3),
+        digest(4),
+    );
+    assert!(canonical_input_digest(&wrong_count_header, &canonical_section).is_err());
+    header.builder_input_abi = "future-abi".to_owned();
+    assert!(header.validate_identity().is_err());
+}
+
+#[test]
+fn strategy_and_digest_validation_fail_closed() {
+    assert_eq!(
+        RecurrenceStrategy::try_from(0).unwrap(),
+        RecurrenceStrategy::TopologyReplay
+    );
+    assert_eq!(
+        RecurrenceStrategy::try_from(1).unwrap(),
+        RecurrenceStrategy::AllFlowUnion
+    );
+    assert_eq!(
+        RecurrenceStrategy::try_from(2).unwrap(),
+        RecurrenceStrategy::ContractedColorUnion
+    );
+    assert!(RecurrenceStrategy::try_from(3).is_err());
+    assert!(SemanticDigest::new([0; 32]).is_err());
+}
+
+#[test]
+fn current_core_key_preserves_every_model_visible_axis() {
+    let ancestry = vec![
+        SourceStateAssignment::new(0, 1),
+        SourceStateAssignment::new(2, 0),
+    ];
+    let key = CurrentCoreKey::new(
+        digest(1),
+        RecurrenceNodeKind::Current,
+        7,
+        DynamicLCColorStateId::from_interner(13),
+        vec![0, 2],
+        CanonicalMomentumLinearForm::new(vec![
+            MomentumTerm {
+                source_slot: 0,
+                coefficient: 1,
+            },
+            MomentumTerm {
+                source_slot: 2,
+                coefficient: -1,
+            },
+        ])
+        .unwrap(),
+        CurrentHelicityIdentity::topology_replay(-1, ancestry.clone()).unwrap(),
+        vec![2, -2],
+        3,
+        vec![1, 2],
+        CurrentSourceBinding::None,
+        Some(9),
+    )
+    .unwrap();
+    let changed = CurrentCoreKey::new(
+        digest(1),
+        RecurrenceNodeKind::Current,
+        7,
+        DynamicLCColorStateId::from_interner(13),
+        vec![0, 2],
+        key.momentum().clone(),
+        CurrentHelicityIdentity::topology_replay(1, ancestry.clone()).unwrap(),
+        key.flavour_flow().to_vec(),
+        key.quantum_number_flow_id(),
+        key.coupling_orders().to_vec(),
+        CurrentSourceBinding::None,
+        Some(9),
+    )
+    .unwrap();
+    assert_ne!(key, changed);
+    assert!(
+        CurrentCoreKey::new(
+            digest(1),
+            RecurrenceNodeKind::Current,
+            7,
+            DynamicLCColorStateId::from_interner(13),
+            vec![2, 0],
+            momentum(0),
+            CurrentHelicityIdentity::topology_replay(0, ancestry).unwrap(),
+            vec![],
+            0,
+            vec![],
+            CurrentSourceBinding::None,
+            None,
+        )
+        .is_err()
+    );
+}
+
+#[test]
+fn current_core_key_enforces_layout_specific_helicity_identity() {
+    let source_momentum = momentum(0);
+    let replay_source = CurrentCoreKey::new(
+        digest(1),
+        RecurrenceNodeKind::Source,
+        7,
+        DynamicLCColorStateId::from_interner(13),
+        vec![0],
+        source_momentum.clone(),
+        CurrentHelicityIdentity::topology_replay(-1, vec![SourceStateAssignment::new(0, 2)])
+            .unwrap(),
+        vec![1],
+        3,
+        vec![],
+        CurrentSourceBinding::FixedTemplate(11),
+        None,
+    )
+    .unwrap();
+    assert_eq!(replay_source.spin_state_class(), -1);
+    assert_eq!(
+        replay_source.helicity_identity().local_source_states()[0].state_index(),
+        2
+    );
+
+    let union_source = CurrentCoreKey::new(
+        digest(1),
+        RecurrenceNodeKind::Source,
+        7,
+        DynamicLCColorStateId::from_interner(13),
+        vec![0],
+        source_momentum.clone(),
+        CurrentHelicityIdentity::all_flow_union(0),
+        vec![1],
+        3,
+        vec![],
+        CurrentSourceBinding::runtime_dispatch(5, vec![11]).unwrap(),
+        None,
+    )
+    .unwrap();
+    assert_eq!(
+        union_source.source_binding(),
+        &CurrentSourceBinding::runtime_dispatch(5, vec![11]).unwrap()
+    );
+    assert!(
+        union_source
+            .helicity_identity()
+            .local_source_states()
+            .is_empty()
+    );
+
+    assert!(
+        CurrentCoreKey::new(
+            digest(1),
+            RecurrenceNodeKind::Current,
+            7,
+            DynamicLCColorStateId::from_interner(13),
+            vec![0, 2],
+            source_momentum.clone(),
+            CurrentHelicityIdentity::topology_replay(0, vec![SourceStateAssignment::new(0, 1)],)
+                .unwrap(),
+            vec![],
+            3,
+            vec![],
+            CurrentSourceBinding::None,
+            None,
+        )
+        .is_err()
+    );
+    assert!(
+        CurrentCoreKey::new(
+            digest(1),
+            RecurrenceNodeKind::Source,
+            7,
+            DynamicLCColorStateId::from_interner(13),
+            vec![0],
+            source_momentum,
+            CurrentHelicityIdentity::all_flow_union(0),
+            vec![],
+            3,
+            vec![],
+            CurrentSourceBinding::FixedTemplate(11),
+            None,
+        )
+        .is_err()
+    );
+}
+
+#[test]
+fn dynamic_lc_color_states_preserve_order_and_only_fold_trace_rotations() {
+    let trace = LCColorComponent::new(LCColorComponentKind::Trace, vec![4, 7, 2]).unwrap();
+    assert_eq!(trace.source_slots(), &[2, 4, 7]);
+    let reversed = LCColorComponent::new(LCColorComponentKind::Trace, vec![2, 7, 4]).unwrap();
+    assert_ne!(trace, reversed);
+
+    let open = LCColorComponent::new(LCColorComponentKind::OpenString, vec![7, 2]).unwrap();
+    assert_eq!(open.source_slots(), &[7, 2]);
+    assert!(LCColorComponent::new(LCColorComponentKind::OpenString, vec![2, 2]).is_err());
+    assert!(DynamicLCColorState::new(1, None, vec![trace, open]).is_err());
+}
+
+#[test]
+fn dynamic_lc_color_state_ids_are_issued_only_by_the_interner() {
+    let state = DynamicLCColorState::new(
+        1,
+        Some(0),
+        vec![LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![0]).unwrap()],
+    )
+    .unwrap();
+    let mut interner = DynamicLCColorStateInterner::default();
+    let first = interner.intern(state.clone()).unwrap();
+    let second = interner.intern(state).unwrap();
+    assert_eq!(first, second);
+    assert_eq!(first.get(), 0);
+    assert_eq!(interner.len(), 1);
+    assert_eq!(interner.get(first).unwrap().output_color_shape_id(), 1);
+}
+
+#[test]
+fn compiler_certified_lc_color_witnesses_apply_exact_ordered_operations() {
+    let left = DynamicLCColorState::new(
+        1,
+        Some(0),
+        vec![LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![0]).unwrap()],
+    )
+    .unwrap();
+    let right = DynamicLCColorState::new(
+        1,
+        Some(0),
+        vec![LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![1, 2]).unwrap()],
+    )
+    .unwrap();
+    let witness = LCColorTransitionWitness::new(
+        [1, 0],
+        0b10,
+        LCColorComponentOperation::ConcatenateJoin,
+        Some(LCColorComponentKind::AdjointSegment),
+        LCColorComponentRole::Active,
+        Some(2),
+        LCColorPortWiring::new(
+            [1, 0],
+            vec![],
+            vec![
+                LCColorParentPort::new(1, 0).unwrap(),
+                LCColorParentPort::new(0, 0).unwrap(),
+            ],
+        )
+        .unwrap(),
+        ExactComplexRational::new(ExactRational::ONE, ExactRational::ZERO),
+        digest(9),
+    )
+    .unwrap();
+    let result = witness.apply(&left, &right).unwrap().unwrap();
+    assert_eq!(result.output_color_shape_id(), 2);
+    assert_eq!(result.components().len(), 2);
+    assert_eq!(result.components()[0].source_slots(), &[2, 1]);
+    assert_eq!(result.components()[1].source_slots(), &[0]);
+    assert_eq!(witness.proof_digest(), digest(9));
+
+    assert!(
+        LCColorTransitionWitness::new(
+            [0, 0],
+            0,
+            LCColorComponentOperation::ConcatenateKeep,
+            None,
+            LCColorComponentRole::None,
+            Some(2),
+            LCColorPortWiring::new([0, 1], vec![], vec![]).unwrap(),
+            ExactComplexRational::new(ExactRational::ONE, ExactRational::ZERO),
+            digest(9),
+        )
+        .is_err()
+    );
+}
+
+#[test]
+fn lc_color_join_uses_declared_active_components_in_multi_line_forests() {
+    let left = DynamicLCColorState::new(
+        1,
+        Some(1),
+        vec![
+            LCColorComponent::new(LCColorComponentKind::OpenString, vec![7, 8]).unwrap(),
+            LCColorComponent::new(LCColorComponentKind::OpenString, vec![0, 1]).unwrap(),
+        ],
+    )
+    .unwrap();
+    let right = DynamicLCColorState::new_port_wired(
+        1,
+        vec![
+            LCColorPortBinding::new(0, LCColorEndpoint::Back),
+            LCColorPortBinding::new(0, LCColorEndpoint::Front),
+        ],
+        vec![
+            LCColorComponent::new(LCColorComponentKind::AdjointSegment, vec![2]).unwrap(),
+            LCColorComponent::new(LCColorComponentKind::OpenString, vec![5, 6]).unwrap(),
+        ],
+    )
+    .unwrap();
+    let witness = LCColorTransitionWitness::new(
+        [0, 1],
+        0,
+        LCColorComponentOperation::ConcatenateJoin,
+        Some(LCColorComponentKind::OpenString),
+        LCColorComponentRole::Active,
+        Some(2),
+        LCColorPortWiring::new(
+            [0, 1],
+            vec![[
+                LCColorParentPort::new(0, 0).unwrap(),
+                LCColorParentPort::new(1, 1).unwrap(),
+            ]],
+            vec![LCColorParentPort::new(1, 0).unwrap()],
+        )
+        .unwrap(),
+        ExactComplexRational::new(ExactRational::ONE, ExactRational::ZERO),
+        digest(11),
+    )
+    .unwrap();
+    let result = witness.apply(&left, &right).unwrap().unwrap();
+    assert_eq!(result.active_component_index(), Some(1));
+    assert_eq!(result.components()[0].source_slots(), &[7, 8]);
+    assert_eq!(result.components()[1].source_slots(), &[0, 1, 2]);
+    assert_eq!(result.components()[2].source_slots(), &[5, 6]);
+}
+
+#[test]
+fn port_wiring_preserves_crossed_two_line_connectivity() {
+    let fundamental = |slot| {
+        DynamicLCColorState::new_port_wired(
+            1,
+            vec![LCColorPortBinding::new(0, LCColorEndpoint::Back)],
+            vec![LCColorComponent::new(LCColorComponentKind::OpenString, vec![slot]).unwrap()],
+        )
+        .unwrap()
+    };
+    let antifundamental = |slot| {
+        DynamicLCColorState::new_port_wired(
+            2,
+            vec![LCColorPortBinding::new(0, LCColorEndpoint::Front)],
+            vec![LCColorComponent::new(LCColorComponentKind::OpenString, vec![slot]).unwrap()],
+        )
+        .unwrap()
+    };
+
+    // u(2) + ubar(3) -> g*: the two gluon result ports retain the two
+    // independent quark-line endpoints rather than collapsing to one port.
+    let gluon_wiring = LCColorPortWiring::new(
+        [0, 1],
+        vec![],
+        vec![
+            LCColorParentPort::new(0, 0).unwrap(),
+            LCColorParentPort::new(1, 0).unwrap(),
+        ],
+    )
+    .unwrap();
+    let gluon = gluon_wiring
+        .apply(&fundamental(2), &antifundamental(3), 3)
+        .unwrap();
+    assert_eq!(gluon.result_port_bindings().len(), 2);
+    assert_eq!(gluon.result_port_lineage_source_slots().unwrap(), [2, 3]);
+
+    // d(1) consumes the ubar-side gluon port; the u-side port becomes the
+    // result current port. This creates passive [1,3] plus active [2].
+    let quark_wiring = LCColorPortWiring::new(
+        [0, 1],
+        vec![[
+            LCColorParentPort::new(0, 0).unwrap(),
+            LCColorParentPort::new(1, 1).unwrap(),
+        ]],
+        vec![LCColorParentPort::new(1, 0).unwrap()],
+    )
+    .unwrap();
+    let complement = quark_wiring.apply(&fundamental(1), &gluon, 1).unwrap();
+    assert_eq!(
+        complement
+            .components()
+            .iter()
+            .map(LCColorComponent::source_slots)
+            .collect::<Vec<_>>(),
+        vec![&[1, 3][..], &[2][..]],
+    );
+    assert_eq!(complement.result_port_lineage_source_slots().unwrap(), [2]);
+
+    // The remaining result port closes against dbar(0), yielding exactly the
+    // crossed physical forest [1,3] + [2,0].
+    let closure_wiring = LCColorPortWiring::new(
+        [0, 1],
+        vec![[
+            LCColorParentPort::new(0, 0).unwrap(),
+            LCColorParentPort::new(1, 0).unwrap(),
+        ]],
+        vec![],
+    )
+    .unwrap();
+    let closed = closure_wiring
+        .apply(&complement, &antifundamental(0), 0)
+        .unwrap();
+    assert!(closed.result_port_bindings().is_empty());
+    assert!(
+        closed
+            .result_port_lineage_source_slots()
+            .unwrap()
+            .is_empty()
+    );
+    assert_eq!(
+        closed
+            .components()
+            .iter()
+            .map(LCColorComponent::source_slots)
+            .collect::<Vec<_>>(),
+        vec![&[1, 3][..], &[2, 0][..]],
+    );
+}
+
+#[test]
+fn contribution_key_validates_aligned_parent_contracts() {
+    let key = ContributionKey::new(
+        1,
+        vec![2, 3],
+        vec![4, 5],
+        vec![momentum(0), momentum(1)],
+        6,
+        7,
+        LCColorWitnessTermId::new(8, 0),
+        digest(9),
+        10,
+    )
+    .unwrap();
+    assert_eq!(key.parent_value_class_ids(), &[2, 3]);
+    assert!(
+        ContributionKey::new(
+            1,
+            vec![2, 3],
+            vec![4],
+            vec![momentum(0), momentum(1)],
+            6,
+            7,
+            LCColorWitnessTermId::new(8, 0),
+            digest(9),
+            10,
+        )
+        .is_err()
+    );
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/src/wavefunctions.rs b/pyamplicol/rust/crates/rusticol-core/src/wavefunctions.rs
new file mode 100644
index 0000000000..3db5fed3ac
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/src/wavefunctions.rs
@@ -0,0 +1,963 @@
+// SPDX-License-Identifier: 0BSD
+
+use super::*;
+
+pub(super) fn c64(re: f64, im: f64) -> Complex<f64> {
+    Complex::new(re, im)
+}
+
+pub(super) fn negate(momentum: [f64; 4]) -> [f64; 4] {
+    [-momentum[0], -momentum[1], -momentum[2], -momentum[3]]
+}
+
+pub(super) fn fortran_sign(value: f64, sign_source: f64) -> f64 {
+    value.abs().copysign(sign_source)
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn complex_zero<T>() -> Complex<T>
+where
+    T: Real + Clone,
+{
+    Complex::new(T::new_zero(), T::new_zero())
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn c_generic<T>(re: T, im: T) -> Complex<T> {
+    Complex::new(re, im)
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn negate_generic<T>(momentum: &[T; 4]) -> [T; 4]
+where
+    T: Real + Clone,
+{
+    [
+        -momentum[0].clone(),
+        -momentum[1].clone(),
+        -momentum[2].clone(),
+        -momentum[3].clone(),
+    ]
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn is_zero<T: RealLike>(value: &T) -> bool {
+    value.to_f64() == 0.0
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn t_min<T>(left: &T, right: &T) -> T
+where
+    T: RealLike + PartialOrd + Clone,
+{
+    if left <= right {
+        left.clone()
+    } else {
+        right.clone()
+    }
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn t_max<T>(left: &T, right: &T) -> T
+where
+    T: RealLike + PartialOrd + Clone,
+{
+    if left >= right {
+        left.clone()
+    } else {
+        right.clone()
+    }
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn fortran_sign_generic<T>(value: &T, sign_source: &T) -> T
+where
+    T: Real + RealLike + Clone,
+{
+    let magnitude = value.norm();
+    if sign_source.to_f64().is_sign_negative() {
+        -magnitude
+    } else {
+        magnitude
+    }
+}
+
+pub(super) fn ext_quark_dirac(momentum: [f64; 4], helicity: i32) -> [Complex<f64>; 4] {
+    let [energy, px, py, pz] = momentum;
+    if energy > 0.0 {
+        let sqp0p3 = if px == 0.0 && py == 0.0 && pz < 0.0 {
+            0.0
+        } else {
+            (energy + pz).max(0.0).sqrt()
+        };
+        let chi1 = c64(sqp0p3, 0.0);
+        let chi2 = if sqp0p3 == 0.0 {
+            c64(-(helicity as f64) * (2.0 * energy).sqrt(), 0.0)
+        } else {
+            c64(helicity as f64 * px / sqp0p3, -py / sqp0p3)
+        };
+        if helicity == 1 {
+            return [chi1, chi2, c64(0.0, 0.0), c64(0.0, 0.0)];
+        }
+        return [c64(0.0, 0.0), c64(0.0, 0.0), chi2, chi1];
+    }
+    let sqp0p3 = if px == 0.0 && py == 0.0 && pz > 0.0 {
+        0.0
+    } else {
+        -(-(energy + pz)).max(0.0).sqrt()
+    };
+    let chi1 = c64(sqp0p3, 0.0);
+    let chi2 = if sqp0p3 == 0.0 {
+        c64(-(helicity as f64) * (2.0 * energy.abs()).sqrt(), 0.0)
+    } else {
+        c64(-(helicity as f64) * (-px) / sqp0p3, py / sqp0p3)
+    };
+    if -helicity == 1 {
+        [chi1, chi2, c64(0.0, 0.0), c64(0.0, 0.0)]
+    } else {
+        [c64(0.0, 0.0), c64(0.0, 0.0), chi2, chi1]
+    }
+}
+
+pub(super) fn ext_antiquark_dirac(momentum: [f64; 4], helicity: i32) -> [Complex<f64>; 4] {
+    let [energy, px, py, pz] = momentum;
+    if energy > 0.0 {
+        let sqp0p3 = if px == 0.0 && py == 0.0 && pz < 0.0 {
+            0.0
+        } else {
+            -(energy + pz).max(0.0).sqrt()
+        };
+        let chi1 = c64(sqp0p3, 0.0);
+        let chi2 = if sqp0p3 == 0.0 {
+            c64(-(helicity as f64) * (2.0 * energy).sqrt(), 0.0)
+        } else {
+            c64(-(helicity as f64) * px / sqp0p3, py / sqp0p3)
+        };
+        if -helicity == 1 {
+            return [c64(0.0, 0.0), c64(0.0, 0.0), chi1, chi2];
+        }
+        return [chi2, chi1, c64(0.0, 0.0), c64(0.0, 0.0)];
+    }
+    let sqp0p3 = if px == 0.0 && py == 0.0 && pz > 0.0 {
+        0.0
+    } else {
+        (-(energy + pz)).max(0.0).sqrt()
+    };
+    let chi1 = c64(sqp0p3, 0.0);
+    let chi2 = if sqp0p3 == 0.0 {
+        c64(-(helicity as f64) * (2.0 * energy.abs()).sqrt(), 0.0)
+    } else {
+        c64(helicity as f64 * (-px) / sqp0p3, -py / sqp0p3)
+    };
+    if helicity == 1 {
+        [c64(0.0, 0.0), c64(0.0, 0.0), chi1, chi2]
+    } else {
+        [chi2, chi1, c64(0.0, 0.0), c64(0.0, 0.0)]
+    }
+}
+
+pub(super) fn ext_quark_dirac_massive(
+    momentum: [f64; 4],
+    helicity: i32,
+    mass: f64,
+) -> [Complex<f64>; 4] {
+    if mass.abs() < 1.0e-8 {
+        return ext_quark_dirac(momentum, helicity);
+    }
+    let [energy, px, py, pz] = momentum;
+    let nsf = if energy > 0.0 { 1 } else { -1 };
+    let nh = nsf * helicity;
+    let pp = (px * px + py * py + pz * pz).sqrt().abs();
+    let omega1 = (energy.abs() + pp).sqrt();
+    let omega2 = mass / omega1;
+    let omega = [omega1, omega2];
+    let sf1 = (1 + nsf + (1 - nsf) * nh) as f64 * 0.5;
+    let sf2 = (1 + nsf - (1 - nsf) * nh) as f64 * 0.5;
+    let ip = ((3 + nh) / 2 - 1) as usize;
+    let im = ((3 - nh) / 2 - 1) as usize;
+    let sfomeg = [sf1 * omega[ip], sf2 * omega[im]];
+    let (signed_px, signed_py, signed_pz) = if energy > 0.0 {
+        (px, py, pz)
+    } else {
+        (-px, -py, -pz)
+    };
+    let pp3 = (pp + signed_pz).max(0.0);
+    let chi1 = if pp == 0.0 {
+        c64(1.0, 0.0)
+    } else {
+        c64((pp3 * 0.5 / pp).sqrt(), 0.0)
+    };
+    let chi2 = if pp3 == 0.0 || pp == 0.0 {
+        c64(-(nh as f64), 0.0)
+    } else {
+        let denom = (2.0 * pp * pp3).sqrt();
+        c64((nh as f64) * signed_px / denom, -signed_py / denom)
+    };
+    let chi = [chi1, chi2];
+    [
+        chi[im] * sfomeg[1],
+        chi[ip] * sfomeg[1],
+        chi[im] * sfomeg[0],
+        chi[ip] * sfomeg[0],
+    ]
+}
+
+pub(super) fn ext_antiquark_dirac_massive(
+    momentum: [f64; 4],
+    helicity: i32,
+    mass: f64,
+) -> [Complex<f64>; 4] {
+    if mass.abs() < 1.0e-8 {
+        return ext_antiquark_dirac(momentum, helicity);
+    }
+    let [energy, px, py, pz] = momentum;
+    let nsf = if energy > 0.0 { -1 } else { 1 };
+    let nh = nsf * helicity;
+    let pp = (px * px + py * py + pz * pz).sqrt().abs();
+    let omega1 = (energy.abs() + pp).sqrt();
+    let omega2 = mass / omega1;
+    let omega = [omega1, omega2];
+    let sf1 = (1 + nsf + (1 - nsf) * nh) as f64 * 0.5;
+    let sf2 = (1 + nsf - (1 - nsf) * nh) as f64 * 0.5;
+    let ip = ((3 + nh) / 2 - 1) as usize;
+    let im = ((3 - nh) / 2 - 1) as usize;
+    let sfomeg = [sf1 * omega[ip], sf2 * omega[im]];
+    let (signed_px, signed_py, signed_pz) = if energy > 0.0 {
+        (px, py, pz)
+    } else {
+        (-px, -py, -pz)
+    };
+    let pp3 = (pp + signed_pz).max(0.0);
+    let chi1 = if pp == 0.0 {
+        c64(1.0, 0.0)
+    } else {
+        c64((pp3 * 0.5 / pp).sqrt(), 0.0)
+    };
+    let chi2 = if pp3 == 0.0 || pp == 0.0 {
+        c64(-(nh as f64), 0.0)
+    } else {
+        let denom = (2.0 * pp * pp3).sqrt();
+        c64((nh as f64) * signed_px / denom, signed_py / denom)
+    };
+    let chi = [chi1, chi2];
+    [
+        chi[im] * sfomeg[0],
+        chi[ip] * sfomeg[0],
+        chi[im] * sfomeg[1],
+        chi[ip] * sfomeg[1],
+    ]
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn ext_quark_dirac_generic<T>(momentum: &[T; 4], helicity: i32) -> [Complex<T>; 4]
+where
+    T: Real + RealLike + From<f64> + PartialOrd + Clone,
+{
+    let energy = momentum[0].clone();
+    let px = momentum[1].clone();
+    let py = momentum[2].clone();
+    let pz = momentum[3].clone();
+    if energy.to_f64() > 0.0 {
+        let sqp0p3 = if is_zero(&px) && is_zero(&py) && pz.to_f64() < 0.0 {
+            T::new_zero()
+        } else {
+            t_max(&(energy.clone() + pz.clone()), &T::new_zero()).sqrt()
+        };
+        let chi1 = c_generic(sqp0p3.clone(), T::new_zero());
+        let chi2 = if is_zero(&sqp0p3) {
+            c_generic(
+                -energy.from_i64(helicity as i64) * (energy.from_i64(2) * energy.clone()).sqrt(),
+                T::new_zero(),
+            )
+        } else {
+            c_generic(
+                energy.from_i64(helicity as i64) * px.clone() / sqp0p3.clone(),
+                -py.clone() / sqp0p3.clone(),
+            )
+        };
+        if helicity == 1 {
+            return [chi1, chi2, complex_zero(), complex_zero()];
+        }
+        return [complex_zero(), complex_zero(), chi2, chi1];
+    }
+    let sqp0p3 = if is_zero(&px) && is_zero(&py) && pz.to_f64() > 0.0 {
+        T::new_zero()
+    } else {
+        -t_max(&(-(energy.clone() + pz.clone())), &T::new_zero()).sqrt()
+    };
+    let chi1 = c_generic(sqp0p3.clone(), T::new_zero());
+    let chi2 = if is_zero(&sqp0p3) {
+        c_generic(
+            -energy.from_i64(helicity as i64) * (energy.from_i64(2) * energy.norm()).sqrt(),
+            T::new_zero(),
+        )
+    } else {
+        c_generic(
+            -energy.from_i64(helicity as i64) * (-px.clone()) / sqp0p3.clone(),
+            py.clone() / sqp0p3.clone(),
+        )
+    };
+    if -helicity == 1 {
+        [chi1, chi2, complex_zero(), complex_zero()]
+    } else {
+        [complex_zero(), complex_zero(), chi2, chi1]
+    }
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn ext_antiquark_dirac_generic<T>(momentum: &[T; 4], helicity: i32) -> [Complex<T>; 4]
+where
+    T: Real + RealLike + From<f64> + PartialOrd + Clone,
+{
+    let energy = momentum[0].clone();
+    let px = momentum[1].clone();
+    let py = momentum[2].clone();
+    let pz = momentum[3].clone();
+    if energy.to_f64() > 0.0 {
+        let sqp0p3 = if is_zero(&px) && is_zero(&py) && pz.to_f64() < 0.0 {
+            T::new_zero()
+        } else {
+            -t_max(&(energy.clone() + pz.clone()), &T::new_zero()).sqrt()
+        };
+        let chi1 = c_generic(sqp0p3.clone(), T::new_zero());
+        let chi2 = if is_zero(&sqp0p3) {
+            c_generic(
+                -energy.from_i64(helicity as i64) * (energy.from_i64(2) * energy.clone()).sqrt(),
+                T::new_zero(),
+            )
+        } else {
+            c_generic(
+                -energy.from_i64(helicity as i64) * px.clone() / sqp0p3.clone(),
+                py.clone() / sqp0p3.clone(),
+            )
+        };
+        if -helicity == 1 {
+            return [complex_zero(), complex_zero(), chi1, chi2];
+        }
+        return [chi2, chi1, complex_zero(), complex_zero()];
+    }
+    let sqp0p3 = if is_zero(&px) && is_zero(&py) && pz.to_f64() > 0.0 {
+        T::new_zero()
+    } else {
+        t_max(&(-(energy.clone() + pz.clone())), &T::new_zero()).sqrt()
+    };
+    let chi1 = c_generic(sqp0p3.clone(), T::new_zero());
+    let chi2 = if is_zero(&sqp0p3) {
+        c_generic(
+            -energy.from_i64(helicity as i64) * (energy.from_i64(2) * energy.norm()).sqrt(),
+            T::new_zero(),
+        )
+    } else {
+        c_generic(
+            energy.from_i64(helicity as i64) * (-px.clone()) / sqp0p3.clone(),
+            -py.clone() / sqp0p3.clone(),
+        )
+    };
+    if helicity == 1 {
+        [complex_zero(), complex_zero(), chi1, chi2]
+    } else {
+        [chi2, chi1, complex_zero(), complex_zero()]
+    }
+}
+
+pub(super) fn ext_massive_vector(
+    momentum: [f64; 4],
+    helicity: i32,
+    mass: f64,
+) -> [Complex<f64>; 4] {
+    let [energy, px, py, pz] = momentum;
+    if energy < 0.0 {
+        return ext_massive_vector(negate(momentum), -helicity, mass);
+    }
+    let sqh = 0.5f64.sqrt();
+    let hel = helicity as f64;
+    let nsvahl = helicity.abs() as f64;
+    let pt2 = px * px + py * py;
+    let pp = energy.min((pt2 + pz * pz).sqrt());
+    let pt = pp.min(pt2.sqrt());
+    let hel0 = 1.0 - hel.abs();
+    if pp == 0.0 {
+        return [
+            c64(0.0, 0.0),
+            c64(-hel * sqh, 0.0),
+            c64(0.0, nsvahl * sqh),
+            c64(hel0, 0.0),
+        ];
+    }
+    let emp = energy / (mass * pp);
+    let wf0 = c64(hel0 * pp / mass, 0.0);
+    let wf3 = c64(hel0 * pz * emp + hel * pt / pp * sqh, 0.0);
+    let (wf1, wf2) = if pt != 0.0 {
+        let pzpt = pz / (pp * pt) * sqh * hel;
+        (
+            c64(hel0 * px * emp - px * pzpt, -nsvahl * py / pt * sqh),
+            c64(hel0 * py * emp - py * pzpt, nsvahl * px / pt * sqh),
+        )
+    } else {
+        (
+            c64(-hel * sqh, 0.0),
+            c64(0.0, nsvahl * fortran_sign(sqh, pz)),
+        )
+    };
+    [wf0, wf1, wf2, wf3]
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn ext_massive_vector_generic<T>(
+    momentum: &[T; 4],
+    helicity: i32,
+    mass: T,
+) -> [Complex<T>; 4]
+where
+    T: Real + RealLike + From<f64> + PartialOrd + Clone,
+{
+    let energy = momentum[0].clone();
+    if energy.to_f64() < 0.0 {
+        return ext_massive_vector_generic(&negate_generic(momentum), -helicity, mass);
+    }
+    let px = momentum[1].clone();
+    let py = momentum[2].clone();
+    let pz = momentum[3].clone();
+    let sqh = (energy.one() / energy.from_i64(2)).sqrt();
+    let hel = energy.from_i64(helicity as i64);
+    let nsvahl = energy.from_i64(helicity.abs() as i64);
+    let pt2 = px.clone() * px.clone() + py.clone() * py.clone();
+    let pp = t_min(&energy, &(pt2.clone() + pz.clone() * pz.clone()).sqrt());
+    let pt = t_min(&pp, &pt2.sqrt());
+    let hel0 = if helicity == 0 {
+        energy.one()
+    } else {
+        T::new_zero()
+    };
+    if is_zero(&pp) {
+        return [
+            complex_zero(),
+            c_generic(-hel.clone() * sqh.clone(), T::new_zero()),
+            c_generic(T::new_zero(), nsvahl.clone() * sqh.clone()),
+            c_generic(hel0, T::new_zero()),
+        ];
+    }
+    let emp = energy.clone() / (mass.clone() * pp.clone());
+    let wf0 = c_generic(hel0.clone() * pp.clone() / mass, T::new_zero());
+    let wf3 = c_generic(
+        hel0.clone() * pz.clone() * emp.clone()
+            + hel.clone() * pt.clone() / pp.clone() * sqh.clone(),
+        T::new_zero(),
+    );
+    let (wf1, wf2) = if !is_zero(&pt) {
+        let pzpt = pz.clone() / (pp.clone() * pt.clone()) * sqh.clone() * hel.clone();
+        (
+            c_generic(
+                hel0.clone() * px.clone() * emp.clone() - px.clone() * pzpt.clone(),
+                -nsvahl.clone() * py.clone() / pt.clone() * sqh.clone(),
+            ),
+            c_generic(
+                hel0 * py.clone() * emp - py.clone() * pzpt,
+                nsvahl * px.clone() / pt * sqh,
+            ),
+        )
+    } else {
+        (
+            c_generic(-hel * sqh.clone(), T::new_zero()),
+            c_generic(T::new_zero(), nsvahl * fortran_sign_generic(&sqh, &pz)),
+        )
+    };
+    [wf0, wf1, wf2, wf3]
+}
+
+pub(super) fn spin2_outer(
+    left: &[Complex<f64>; 4],
+    right: &[Complex<f64>; 4],
+) -> [Complex<f64>; 16] {
+    std::array::from_fn(|index| left[index / 4] * right[index % 4])
+}
+
+pub(super) fn ext_spin2(
+    momentum: [f64; 4],
+    helicity: i32,
+    mass: f64,
+) -> RusticolResult<[Complex<f64>; 16]> {
+    if mass == 0.0 {
+        if ![-2, 2].contains(&helicity) {
+            return Err(RusticolError::invalid_argument(
+                "massless spin-2 sources only support helicities -2 and 2",
+            ));
+        }
+        let vector = ext_gluon(momentum, helicity / 2);
+        return Ok(spin2_outer(&vector, &vector));
+    }
+    if ![-2, -1, 0, 1, 2].contains(&helicity) {
+        return Err(RusticolError::invalid_argument(format!(
+            "unsupported massive spin-2 helicity {helicity}"
+        )));
+    }
+    let plus = ext_massive_vector(momentum, 1, mass);
+    let minus = ext_massive_vector(momentum, -1, mass);
+    let longitudinal = ext_massive_vector(momentum, 0, mass);
+    let plus_plus = spin2_outer(&plus, &plus);
+    let minus_minus = spin2_outer(&minus, &minus);
+    if helicity == 2 {
+        return Ok(plus_plus);
+    }
+    if helicity == -2 {
+        return Ok(minus_minus);
+    }
+    let inverse_sqrt_two = 1.0 / 2.0f64.sqrt();
+    if helicity == 1 {
+        let first = spin2_outer(&plus, &longitudinal);
+        let second = spin2_outer(&longitudinal, &plus);
+        return Ok(std::array::from_fn(|index| {
+            (first[index] + second[index]) * inverse_sqrt_two
+        }));
+    }
+    if helicity == -1 {
+        let first = spin2_outer(&minus, &longitudinal);
+        let second = spin2_outer(&longitudinal, &minus);
+        return Ok(std::array::from_fn(|index| {
+            (first[index] + second[index]) * inverse_sqrt_two
+        }));
+    }
+    let plus_minus = spin2_outer(&plus, &minus);
+    let minus_plus = spin2_outer(&minus, &plus);
+    let zero_zero = spin2_outer(&longitudinal, &longitudinal);
+    let inverse_sqrt_six = 1.0 / 6.0f64.sqrt();
+    Ok(std::array::from_fn(|index| {
+        (plus_minus[index] + minus_plus[index] + c64(2.0, 0.0) * zero_zero[index])
+            * inverse_sqrt_six
+    }))
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn spin2_outer_generic<T>(
+    left: &[Complex<T>; 4],
+    right: &[Complex<T>; 4],
+) -> [Complex<T>; 16]
+where
+    T: Real + RealLike + From<f64> + Clone,
+{
+    std::array::from_fn(|index| left[index / 4].clone() * right[index % 4].clone())
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn ext_spin2_generic<T>(
+    momentum: &[T; 4],
+    helicity: i32,
+    mass: T,
+) -> RusticolResult<[Complex<T>; 16]>
+where
+    T: Real + RealLike + From<f64> + PartialOrd + Clone,
+{
+    if is_zero(&mass) {
+        if ![-2, 2].contains(&helicity) {
+            return Err(RusticolError::invalid_argument(
+                "massless spin-2 sources only support helicities -2 and 2",
+            ));
+        }
+        let vector = ext_gluon_generic(momentum, helicity / 2);
+        return Ok(spin2_outer_generic(&vector, &vector));
+    }
+    if ![-2, -1, 0, 1, 2].contains(&helicity) {
+        return Err(RusticolError::invalid_argument(format!(
+            "unsupported massive spin-2 helicity {helicity}"
+        )));
+    }
+    let plus = ext_massive_vector_generic(momentum, 1, mass.clone());
+    let minus = ext_massive_vector_generic(momentum, -1, mass.clone());
+    let longitudinal = ext_massive_vector_generic(momentum, 0, mass.clone());
+    if helicity == 2 {
+        return Ok(spin2_outer_generic(&plus, &plus));
+    }
+    if helicity == -2 {
+        return Ok(spin2_outer_generic(&minus, &minus));
+    }
+    let inverse_sqrt_two = mass.one() / mass.from_i64(2).sqrt();
+    let weight_two = c_generic(inverse_sqrt_two, T::new_zero());
+    if helicity == 1 {
+        let first = spin2_outer_generic(&plus, &longitudinal);
+        let second = spin2_outer_generic(&longitudinal, &plus);
+        return Ok(std::array::from_fn(|index| {
+            (first[index].clone() + second[index].clone()) * weight_two.clone()
+        }));
+    }
+    if helicity == -1 {
+        let first = spin2_outer_generic(&minus, &longitudinal);
+        let second = spin2_outer_generic(&longitudinal, &minus);
+        return Ok(std::array::from_fn(|index| {
+            (first[index].clone() + second[index].clone()) * weight_two.clone()
+        }));
+    }
+    let plus_minus = spin2_outer_generic(&plus, &minus);
+    let minus_plus = spin2_outer_generic(&minus, &plus);
+    let zero_zero = spin2_outer_generic(&longitudinal, &longitudinal);
+    let two = c_generic(mass.from_i64(2), T::new_zero());
+    let inverse_sqrt_six = c_generic(mass.one() / mass.from_i64(6).sqrt(), T::new_zero());
+    Ok(std::array::from_fn(|index| {
+        (plus_minus[index].clone()
+            + minus_plus[index].clone()
+            + two.clone() * zero_zero[index].clone())
+            * inverse_sqrt_six.clone()
+    }))
+}
+
+pub(super) fn ext_gluon(momentum: [f64; 4], helicity: i32) -> [Complex<f64>; 4] {
+    let [energy, px, py, pz] = momentum;
+    let sqh = 0.5f64.sqrt();
+    if energy > 0.0 {
+        let hel = helicity as f64;
+        let pp = energy;
+        let pt = (px * px + py * py).sqrt();
+        let wf3 = c64(hel * pt / pp * sqh, 0.0);
+        let (wf1, wf2) = if pt != 0.0 {
+            let pzpt = pz / (pp * pt) * sqh * hel;
+            (
+                c64(-px * pzpt, -py / pt * sqh),
+                c64(-py * pzpt, px / pt * sqh),
+            )
+        } else {
+            (c64(-hel * sqh, 0.0), c64(0.0, fortran_sign(sqh, pz)))
+        };
+        return [c64(0.0, 0.0), wf1, wf2, wf3];
+    }
+    let hel = -helicity as f64;
+    let pp = -energy;
+    let pt = (px * px + py * py).sqrt();
+    let wf3 = c64(hel * pt / pp * sqh, 0.0);
+    let (wf1, wf2) = if pt != 0.0 {
+        let pzpt = -pz / (pp * pt) * sqh * hel;
+        (
+            c64(px * pzpt, py / pt * sqh),
+            c64(py * pzpt, -px / pt * sqh),
+        )
+    } else {
+        (c64(-hel * sqh, 0.0), c64(0.0, -fortran_sign(sqh, pz)))
+    };
+    [c64(0.0, 0.0), wf1, wf2, wf3]
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn ext_gluon_generic<T>(momentum: &[T; 4], helicity: i32) -> [Complex<T>; 4]
+where
+    T: Real + RealLike + From<f64> + Clone,
+{
+    let energy = momentum[0].clone();
+    let px = momentum[1].clone();
+    let py = momentum[2].clone();
+    let pz = momentum[3].clone();
+    let sqh = (energy.one() / energy.from_i64(2)).sqrt();
+    if energy.to_f64() > 0.0 {
+        let hel = energy.from_i64(helicity as i64);
+        let pp = energy;
+        let pt = (px.clone() * px.clone() + py.clone() * py.clone()).sqrt();
+        let wf3 = c_generic(
+            hel.clone() * pt.clone() / pp.clone() * sqh.clone(),
+            T::new_zero(),
+        );
+        let (wf1, wf2) = if !is_zero(&pt) {
+            let pzpt = pz.clone() / (pp.clone() * pt.clone()) * sqh.clone() * hel.clone();
+            (
+                c_generic(
+                    -px.clone() * pzpt.clone(),
+                    -py.clone() / pt.clone() * sqh.clone(),
+                ),
+                c_generic(-py.clone() * pzpt, px.clone() / pt * sqh),
+            )
+        } else {
+            (
+                c_generic(-hel * sqh.clone(), T::new_zero()),
+                c_generic(T::new_zero(), fortran_sign_generic(&sqh, &pz)),
+            )
+        };
+        return [complex_zero(), wf1, wf2, wf3];
+    }
+    let hel = energy.from_i64(-(helicity as i64));
+    let pp = -energy;
+    let pt = (px.clone() * px.clone() + py.clone() * py.clone()).sqrt();
+    let wf3 = c_generic(
+        hel.clone() * pt.clone() / pp.clone() * sqh.clone(),
+        T::new_zero(),
+    );
+    let (wf1, wf2) = if !is_zero(&pt) {
+        let pzpt = -pz.clone() / (pp.clone() * pt.clone()) * sqh.clone() * hel.clone();
+        (
+            c_generic(
+                px.clone() * pzpt.clone(),
+                py.clone() / pt.clone() * sqh.clone(),
+            ),
+            c_generic(py.clone() * pzpt, -px.clone() / pt * sqh),
+        )
+    } else {
+        (
+            c_generic(-hel * sqh.clone(), T::new_zero()),
+            c_generic(T::new_zero(), -fortran_sign_generic(&sqh, &pz)),
+        )
+    };
+    [complex_zero(), wf1, wf2, wf3]
+}
+
+pub(super) fn ext_quark_weyl_array(
+    momentum: [f64; 4],
+    helicity: i32,
+    chirality: i32,
+) -> [Complex<f64>; 2] {
+    let [energy, px, py, pz] = momentum;
+    if energy > 0.0 {
+        let sqp0p3 = if px == 0.0 && py == 0.0 && pz < 0.0 {
+            0.0
+        } else {
+            (energy + pz).max(0.0).sqrt()
+        };
+        let chi1 = c64(sqp0p3, 0.0);
+        let chi2 = if sqp0p3 == 0.0 {
+            c64(-(helicity as f64) * (2.0 * energy).sqrt(), 0.0)
+        } else {
+            c64(helicity as f64 * px / sqp0p3, -py / sqp0p3)
+        };
+        if helicity == 1 && chirality == 1 {
+            return [chi1, chi2];
+        }
+        if helicity == -1 && chirality == -1 {
+            return [chi2, chi1];
+        }
+        return [c64(0.0, 0.0), c64(0.0, 0.0)];
+    }
+    let sqp0p3 = if px == 0.0 && py == 0.0 && pz > 0.0 {
+        0.0
+    } else {
+        -(-(energy + pz)).max(0.0).sqrt()
+    };
+    let chi1 = c64(sqp0p3, 0.0);
+    let chi2 = if sqp0p3 == 0.0 {
+        c64(-(helicity as f64) * (2.0 * energy.abs()).sqrt(), 0.0)
+    } else {
+        c64(-(helicity as f64) * (-px) / sqp0p3, py / sqp0p3)
+    };
+    if helicity == -1 && chirality == 1 {
+        [chi1, chi2]
+    } else if helicity == 1 && chirality == -1 {
+        [chi2, chi1]
+    } else {
+        [c64(0.0, 0.0), c64(0.0, 0.0)]
+    }
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn ext_quark_weyl_generic<T>(
+    momentum: &[T; 4],
+    helicity: i32,
+    chirality: i32,
+) -> Vec<Complex<T>>
+where
+    T: Real + RealLike + From<f64> + PartialOrd + Clone,
+{
+    let energy = momentum[0].clone();
+    let px = momentum[1].clone();
+    let py = momentum[2].clone();
+    let pz = momentum[3].clone();
+    if energy.to_f64() > 0.0 {
+        let sqp0p3 = if is_zero(&px) && is_zero(&py) && pz.to_f64() < 0.0 {
+            T::new_zero()
+        } else {
+            t_max(&(energy.clone() + pz.clone()), &T::new_zero()).sqrt()
+        };
+        let chi1 = c_generic(sqp0p3.clone(), T::new_zero());
+        let chi2 = if is_zero(&sqp0p3) {
+            c_generic(
+                -energy.from_i64(helicity as i64) * (energy.from_i64(2) * energy.clone()).sqrt(),
+                T::new_zero(),
+            )
+        } else {
+            c_generic(
+                energy.from_i64(helicity as i64) * px.clone() / sqp0p3.clone(),
+                -py.clone() / sqp0p3.clone(),
+            )
+        };
+        if helicity == 1 && chirality == 1 {
+            return vec![chi1, chi2];
+        }
+        if helicity == -1 && chirality == -1 {
+            return vec![chi2, chi1];
+        }
+        return vec![complex_zero(), complex_zero()];
+    }
+    let sqp0p3 = if is_zero(&px) && is_zero(&py) && pz.to_f64() > 0.0 {
+        T::new_zero()
+    } else {
+        -t_max(&(-(energy.clone() + pz.clone())), &T::new_zero()).sqrt()
+    };
+    let chi1 = c_generic(sqp0p3.clone(), T::new_zero());
+    let chi2 = if is_zero(&sqp0p3) {
+        c_generic(
+            -energy.from_i64(helicity as i64) * (energy.from_i64(2) * energy.norm()).sqrt(),
+            T::new_zero(),
+        )
+    } else {
+        c_generic(
+            -energy.from_i64(helicity as i64) * (-px.clone()) / sqp0p3.clone(),
+            py.clone() / sqp0p3.clone(),
+        )
+    };
+    if helicity == -1 && chirality == 1 {
+        vec![chi1, chi2]
+    } else if helicity == 1 && chirality == -1 {
+        vec![chi2, chi1]
+    } else {
+        vec![complex_zero(), complex_zero()]
+    }
+}
+
+pub(super) fn ext_antiquark_weyl_array(
+    momentum: [f64; 4],
+    helicity: i32,
+    chirality: i32,
+) -> [Complex<f64>; 2] {
+    let [energy, px, py, pz] = momentum;
+    if energy > 0.0 {
+        let sqp0p3 = if px == 0.0 && py == 0.0 && pz < 0.0 {
+            0.0
+        } else {
+            -(energy + pz).max(0.0).sqrt()
+        };
+        let chi1 = c64(sqp0p3, 0.0);
+        let chi2 = if sqp0p3 == 0.0 {
+            c64(-(helicity as f64) * (2.0 * energy).sqrt(), 0.0)
+        } else {
+            c64(-(helicity as f64) * px / sqp0p3, py / sqp0p3)
+        };
+        if helicity == 1 && chirality == 1 {
+            return [chi2, chi1];
+        }
+        if helicity == -1 && chirality == -1 {
+            return [chi1, chi2];
+        }
+        return [c64(0.0, 0.0), c64(0.0, 0.0)];
+    }
+    let sqp0p3 = if px == 0.0 && py == 0.0 && pz > 0.0 {
+        0.0
+    } else {
+        (-(energy + pz)).max(0.0).sqrt()
+    };
+    let chi1 = c64(sqp0p3, 0.0);
+    let chi2 = if sqp0p3 == 0.0 {
+        c64(-(helicity as f64) * (2.0 * energy.abs()).sqrt(), 0.0)
+    } else {
+        c64(helicity as f64 * (-px) / sqp0p3, -py / sqp0p3)
+    };
+    if helicity == -1 && chirality == 1 {
+        [chi2, chi1]
+    } else if helicity == 1 && chirality == -1 {
+        [chi1, chi2]
+    } else {
+        [c64(0.0, 0.0), c64(0.0, 0.0)]
+    }
+}
+
+#[cfg(feature = "symbolica-runtime")]
+pub(super) fn ext_antiquark_weyl_generic<T>(
+    momentum: &[T; 4],
+    helicity: i32,
+    chirality: i32,
+) -> Vec<Complex<T>>
+where
+    T: Real + RealLike + From<f64> + PartialOrd + Clone,
+{
+    let energy = momentum[0].clone();
+    let px = momentum[1].clone();
+    let py = momentum[2].clone();
+    let pz = momentum[3].clone();
+    if energy.to_f64() > 0.0 {
+        let sqp0p3 = if is_zero(&px) && is_zero(&py) && pz.to_f64() < 0.0 {
+            T::new_zero()
+        } else {
+            -t_max(&(energy.clone() + pz.clone()), &T::new_zero()).sqrt()
+        };
+        let chi1 = c_generic(sqp0p3.clone(), T::new_zero());
+        let chi2 = if is_zero(&sqp0p3) {
+            c_generic(
+                -energy.from_i64(helicity as i64) * (energy.from_i64(2) * energy.clone()).sqrt(),
+                T::new_zero(),
+            )
+        } else {
+            c_generic(
+                -energy.from_i64(helicity as i64) * px.clone() / sqp0p3.clone(),
+                py.clone() / sqp0p3.clone(),
+            )
+        };
+        if helicity == 1 && chirality == 1 {
+            return vec![chi2, chi1];
+        }
+        if helicity == -1 && chirality == -1 {
+            return vec![chi1, chi2];
+        }
+        return vec![complex_zero(), complex_zero()];
+    }
+    let sqp0p3 = if is_zero(&px) && is_zero(&py) && pz.to_f64() > 0.0 {
+        T::new_zero()
+    } else {
+        t_max(&(-(energy.clone() + pz.clone())), &T::new_zero()).sqrt()
+    };
+    let chi1 = c_generic(sqp0p3.clone(), T::new_zero());
+    let chi2 = if is_zero(&sqp0p3) {
+        c_generic(
+            -energy.from_i64(helicity as i64) * (energy.from_i64(2) * energy.norm()).sqrt(),
+            T::new_zero(),
+        )
+    } else {
+        c_generic(
+            energy.from_i64(helicity as i64) * (-px.clone()) / sqp0p3.clone(),
+            -py.clone() / sqp0p3.clone(),
+        )
+    };
+    if helicity == -1 && chirality == 1 {
+        vec![chi2, chi1]
+    } else if helicity == 1 && chirality == -1 {
+        vec![chi1, chi2]
+    } else {
+        vec![complex_zero(), complex_zero()]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Complex, ext_massive_vector, negate};
+
+    fn assert_complex_close(left: Complex<f64>, right: Complex<f64>) {
+        assert!((left.re - right.re).abs() < 1.0e-13);
+        assert!((left.im - right.im).abs() < 1.0e-13);
+    }
+
+    #[test]
+    fn massive_vector_negative_energy_obeys_crossing_convention() {
+        let momentum = [13.0, 4.0, 8.0, 8.0];
+        for helicity in [-1, 0, 1] {
+            let outgoing = ext_massive_vector(momentum, helicity, 5.0);
+            let incoming = ext_massive_vector(negate(momentum), -helicity, 5.0);
+            for (left, right) in incoming.into_iter().zip(outgoing) {
+                assert_complex_close(left, right);
+            }
+        }
+    }
+
+    #[test]
+    fn massive_vector_is_transverse_for_both_energy_signs() {
+        let momentum = [13.0, 4.0, 8.0, 8.0];
+        for helicity in [-1, 0, 1] {
+            for (candidate, source_helicity) in
+                [(momentum, helicity), (negate(momentum), -helicity)]
+            {
+                let wave = ext_massive_vector(candidate, source_helicity, 5.0);
+                let contraction_re = candidate[0] * wave[0].re
+                    - candidate[1] * wave[1].re
+                    - candidate[2] * wave[2].re
+                    - candidate[3] * wave[3].re;
+                let contraction_im = candidate[0] * wave[0].im
+                    - candidate[1] * wave[1].im
+                    - candidate[2] * wave[2].im
+                    - candidate[3] * wave[3].im;
+                assert!(
+                    contraction_re.hypot(contraction_im) < 1.0e-12,
+                    "({contraction_re}, {contraction_im})"
+                );
+            }
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/tests/direct_arena_workspace_allocations.rs b/pyamplicol/rust/crates/rusticol-core/tests/direct_arena_workspace_allocations.rs
new file mode 100644
index 0000000000..8a8eef79d6
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/tests/direct_arena_workspace_allocations.rs
@@ -0,0 +1,277 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::alloc::{GlobalAlloc, Layout, System};
+use std::cell::Cell;
+use std::hint::black_box;
+
+use rusticol_core::direct_arena::{
+    DirectArenaTrafficCounters, DirectArenaView, DirectArenaWorkspace, DirectPlaneShape,
+    DirectPointTile,
+};
+
+thread_local! {
+    static TRACK_ALLOCATIONS: Cell<bool> = const { Cell::new(false) };
+    static ALLOCATION_COUNT: Cell<usize> = const { Cell::new(0) };
+    static ALLOCATED_BYTES: Cell<usize> = const { Cell::new(0) };
+}
+
+struct CountingAllocator;
+
+#[global_allocator]
+static GLOBAL_ALLOCATOR: CountingAllocator = CountingAllocator;
+
+unsafe impl GlobalAlloc for CountingAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        count_allocation(layout.size());
+        unsafe { System.alloc(layout) }
+    }
+
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        count_allocation(layout.size());
+        unsafe { System.alloc_zeroed(layout) }
+    }
+
+    unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        count_allocation(new_size);
+        unsafe { System.realloc(pointer, layout, new_size) }
+    }
+
+    unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+        unsafe { System.dealloc(pointer, layout) }
+    }
+}
+
+fn count_allocation(bytes: usize) {
+    if TRACK_ALLOCATIONS.try_with(Cell::get).unwrap_or(false) {
+        let _ = ALLOCATION_COUNT.try_with(|count| count.set(count.get() + 1));
+        let _ = ALLOCATED_BYTES.try_with(|total| total.set(total.get().saturating_add(bytes)));
+    }
+}
+
+fn count_allocations<T>(operation: impl FnOnce() -> T) -> (T, usize, usize) {
+    ALLOCATION_COUNT.with(|count| count.set(0));
+    ALLOCATED_BYTES.with(|total| total.set(0));
+    TRACK_ALLOCATIONS.with(|tracking| tracking.set(true));
+    let result = operation();
+    TRACK_ALLOCATIONS.with(|tracking| tracking.set(false));
+    (
+        result,
+        ALLOCATION_COUNT.with(Cell::get),
+        ALLOCATED_BYTES.with(Cell::get),
+    )
+}
+
+fn write_split(
+    values_re: *mut f64,
+    values_im: *mut f64,
+    shape: DirectPlaneShape,
+    component: u32,
+    point: u32,
+    value_re: f64,
+    value_im: f64,
+) {
+    let index = shape
+        .checked_scalar_index(component, point, "test split plane")
+        .unwrap();
+    unsafe {
+        values_re.add(index).write(value_re);
+        values_im.add(index).write(value_im);
+    }
+}
+
+fn read_split(
+    values_re: *const f64,
+    values_im: *const f64,
+    shape: DirectPlaneShape,
+    component: u32,
+    point: u32,
+) -> (f64, f64) {
+    let index = shape
+        .checked_scalar_index(component, point, "test split plane")
+        .unwrap();
+    unsafe { (values_re.add(index).read(), values_im.add(index).read()) }
+}
+
+fn write_current(view: DirectArenaView, component: u32, point: u32, re: f64, im: f64) {
+    write_split(
+        view.current_re,
+        view.current_im,
+        view.current_shape().unwrap(),
+        component,
+        point,
+        re,
+        im,
+    );
+}
+
+fn read_current(view: DirectArenaView, component: u32, point: u32) -> (f64, f64) {
+    read_split(
+        view.current_re,
+        view.current_im,
+        view.current_shape().unwrap(),
+        component,
+        point,
+    )
+}
+
+fn write_amplitude(view: DirectArenaView, component: u32, point: u32, re: f64, im: f64) {
+    write_split(
+        view.amplitude_re,
+        view.amplitude_im,
+        view.amplitude_shape().unwrap(),
+        component,
+        point,
+        re,
+        im,
+    );
+}
+
+fn read_amplitude(view: DirectArenaView, component: u32, point: u32) -> (f64, f64) {
+    read_split(
+        view.amplitude_re,
+        view.amplitude_im,
+        view.amplitude_shape().unwrap(),
+        component,
+        point,
+    )
+}
+
+#[test]
+fn every_physical_plane_base_is_cache_aligned_for_awkward_capacities() {
+    for (tile_capacity, expected_stride) in [(1, 8), (7, 8), (127, 128), (129, 136)] {
+        let mut workspace = DirectArenaWorkspace::new(3, 2, tile_capacity).unwrap();
+        assert_eq!(workspace.tile_capacity(), tile_capacity);
+        assert_eq!(workspace.point_stride(), expected_stride);
+        workspace.begin_tile(tile_capacity).unwrap();
+        let view = workspace.view().unwrap();
+        for component in 0..3_usize {
+            let offset = component * expected_stride as usize;
+            assert_eq!(unsafe { view.current_re.add(offset) } as usize % 64, 0);
+            assert_eq!(unsafe { view.current_im.add(offset) } as usize % 64, 0);
+        }
+        for component in 0..2_usize {
+            let offset = component * expected_stride as usize;
+            assert_eq!(unsafe { view.amplitude_re.add(offset) } as usize % 64, 0);
+            assert_eq!(unsafe { view.amplitude_im.add(offset) } as usize % 64, 0);
+        }
+    }
+}
+
+#[test]
+fn begin_tile_preserves_storage_and_selective_clear_skips_inactive_tails() {
+    let mut workspace = DirectArenaWorkspace::new(3, 2, 129).unwrap();
+    workspace.begin_tile(129).unwrap();
+    let initial = workspace.view().unwrap();
+    assert_eq!(initial.point_stride, 136);
+    for component in 0..3 {
+        for point in 0..initial.point_stride {
+            let value = 10_000.0 + f64::from(component * 1000 + point);
+            write_current(initial, component, point, value, -value);
+        }
+    }
+    for component in 0..2 {
+        for point in 0..initial.point_stride {
+            let value = 20_000.0 + f64::from(component * 1000 + point);
+            write_amplitude(initial, component, point, value, -value);
+        }
+    }
+
+    workspace.begin_tile(127).unwrap();
+    workspace.clear_current_active(1, 1).unwrap();
+    workspace.clear_amplitude_active(0, 1).unwrap();
+    let view = workspace.view().unwrap();
+    assert_eq!(view.current_re, initial.current_re);
+    assert_eq!(view.amplitude_re, initial.amplitude_re);
+    assert_eq!(view.point_stride, initial.point_stride);
+    assert_eq!(read_current(view, 1, 126), (0.0, 0.0));
+    assert_eq!(read_current(view, 1, 127), (11_127.0, -11_127.0));
+    assert_eq!(read_current(view, 0, 0), (10_000.0, -10_000.0));
+    assert_eq!(read_amplitude(view, 0, 126), (0.0, 0.0));
+    assert_eq!(read_amplitude(view, 0, 127), (20_127.0, -20_127.0));
+    assert_eq!(read_amplitude(view, 1, 0), (21_000.0, -21_000.0));
+}
+
+#[test]
+fn adapter_uses_global_tile_offsets_but_local_workspace_indices() {
+    const POINT_COUNT: u32 = 1025;
+    const SENTINEL: f64 = -9_876_543.25;
+    let input_a = (0..POINT_COUNT)
+        .map(|point| f64::from(point) + 0.25)
+        .collect::<Vec<_>>();
+    let input_b = (0..POINT_COUNT)
+        .map(|point| f64::from(point) * -0.5 - 3.0)
+        .collect::<Vec<_>>();
+    let mut output = vec![SENTINEL; POINT_COUNT as usize + 2];
+    let mut workspace = DirectArenaWorkspace::new(2, 1, 129).unwrap();
+    let tiles = workspace.point_tiles(POINT_COUNT, 128).unwrap();
+    let mut final_tile = None;
+
+    for tile in tiles {
+        workspace.begin_tile(tile.point_count).unwrap();
+        let view = workspace.view().unwrap();
+        for local in 0..tile.point_count {
+            let global = tile.point_start + local;
+            write_current(view, 0, local, input_a[global as usize], 0.0);
+            write_current(view, 1, local, input_b[global as usize], 0.0);
+        }
+        for local in 0..tile.point_count {
+            let left = read_current(view, 0, local).0;
+            let right = read_current(view, 1, local).0;
+            write_amplitude(view, 0, local, left + 2.0 * right, 0.0);
+            output[(tile.point_start + local) as usize + 1] = read_amplitude(view, 0, local).0;
+        }
+        final_tile = Some(tile);
+    }
+    assert_eq!(
+        final_tile,
+        Some(DirectPointTile {
+            point_start: 1024,
+            point_count: 1,
+        })
+    );
+    assert_eq!(output[0], SENTINEL);
+    assert_eq!(output[POINT_COUNT as usize + 1], SENTINEL);
+    for point in 0..POINT_COUNT as usize {
+        assert_eq!(output[point + 1], input_a[point] + 2.0 * input_b[point]);
+    }
+}
+
+#[test]
+fn warmed_begin_view_selective_clear_and_tile_reuse_allocate_zero_bytes() {
+    let mut workspace = DirectArenaWorkspace::new(97, 13, 129).unwrap();
+    workspace.begin_tile(129).unwrap();
+    workspace.clear_current_active(0, 97).unwrap();
+    workspace.clear_amplitude_active(0, 13).unwrap();
+    black_box(workspace.view().unwrap());
+    let allocation_counters = workspace.allocation_counters();
+    let traffic_counters = DirectArenaTrafficCounters::default();
+
+    let (tail, allocation_count, allocated_bytes) = count_allocations(|| {
+        let mut tail = DirectPointTile {
+            point_start: 0,
+            point_count: 0,
+        };
+        for points in [127, 129, 128, 1].into_iter().cycle().take(64) {
+            workspace.begin_tile(points).unwrap();
+            workspace.clear_current_active(3, 71).unwrap();
+            workspace.clear_amplitude_active(2, 7).unwrap();
+            black_box(workspace.view().unwrap());
+            for tile in workspace.point_tiles(1025, points).unwrap() {
+                tail = black_box(tile);
+            }
+        }
+        tail
+    });
+
+    assert_eq!(
+        tail,
+        DirectPointTile {
+            point_start: 1024,
+            point_count: 1,
+        }
+    );
+    assert_eq!(allocation_count, 0, "warmed workspace path allocated");
+    assert_eq!(allocated_bytes, 0, "warmed workspace path allocated bytes");
+    assert_eq!(workspace.allocation_counters(), allocation_counters);
+    assert_eq!(traffic_counters, DirectArenaTrafficCounters::default());
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/tests/eager_runtime.rs b/pyamplicol/rust/crates/rusticol-core/tests/eager_runtime.rs
new file mode 100644
index 0000000000..5662358a4b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/tests/eager_runtime.rs
@@ -0,0 +1,1364 @@
+// SPDX-License-Identifier: 0BSD
+
+use rusticol_core::{
+    EagerAttachmentRow, EagerClosureRow, EagerComplex64, EagerCouplingRow, EagerDirectClosureSpec,
+    EagerExecutionPlan, EagerExecutionRuntime, EagerFinalizationRow, EagerInvocationRow,
+    EagerKernelBackend, EagerKernelCall, EagerKernelInput, EagerKernelRole, EagerKernelSpec,
+    EagerPlanDefinition, EagerPlanDimensions, EagerPlanPayloads, EagerReductionEntry,
+    EagerReductionGroup, EagerRuntimeOptions, EagerSelectorDomainIdRow, EagerSelectorDomainRow,
+    EagerSelectorGroupRow, EagerSelectorPayloads, EagerSelectorStagePayload, EagerStagePayload,
+    MISSING_U32, RusticolError, RusticolErrorKind, RusticolResult,
+};
+use std::alloc::{GlobalAlloc, Layout, System};
+use std::cell::Cell;
+
+thread_local! {
+    static TRACK_ALLOCATIONS: Cell<bool> = const { Cell::new(false) };
+    static ALLOCATION_COUNT: Cell<usize> = const { Cell::new(0) };
+}
+
+struct CountingAllocator;
+
+#[global_allocator]
+static GLOBAL_ALLOCATOR: CountingAllocator = CountingAllocator;
+
+unsafe impl GlobalAlloc for CountingAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        count_allocation();
+        unsafe { System.alloc(layout) }
+    }
+
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        count_allocation();
+        unsafe { System.alloc_zeroed(layout) }
+    }
+
+    unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        count_allocation();
+        unsafe { System.realloc(pointer, layout, new_size) }
+    }
+
+    unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+        unsafe { System.dealloc(pointer, layout) }
+    }
+}
+
+fn count_allocation() {
+    let tracking = TRACK_ALLOCATIONS.try_with(Cell::get).unwrap_or(false);
+    if tracking {
+        let _ = ALLOCATION_COUNT.try_with(|count| count.set(count.get() + 1));
+    }
+}
+
+fn count_allocations<T>(function: impl FnOnce() -> T) -> (T, usize) {
+    ALLOCATION_COUNT.with(|count| count.set(0));
+    TRACK_ALLOCATIONS.with(|tracking| tracking.set(true));
+    let result = function();
+    TRACK_ALLOCATIONS.with(|tracking| tracking.set(false));
+    let count = ALLOCATION_COUNT.with(Cell::get);
+    (result, count)
+}
+
+#[derive(Default)]
+struct MockBackend {
+    calls: [usize; 3],
+    max_lanes: [usize; 3],
+}
+
+impl EagerKernelBackend for MockBackend {
+    fn evaluate_batch(&mut self, call: EagerKernelCall<'_>) -> RusticolResult<()> {
+        let kernel = usize::try_from(call.kernel_id)
+            .map_err(|_| RusticolError::evaluation("mock kernel id does not fit usize"))?;
+        if kernel >= self.calls.len() {
+            return Err(RusticolError::evaluation("unknown mock eager kernel"));
+        }
+        self.calls[kernel] += 1;
+        self.max_lanes[kernel] = self.max_lanes[kernel].max(call.lane_count);
+        match call.kernel_id {
+            0 => {
+                assert_eq!(call.input_component_count, 7);
+                assert_eq!(call.output_component_count, 1);
+                for lane in 0..call.lane_count {
+                    let row = lane * call.input_component_count;
+                    let right = call.inputs[row];
+                    let left = call.inputs[row + 1];
+                    let left_momentum = call.inputs[row + 2];
+                    let right_momentum = call.inputs[row + 3];
+                    let coupling_real = call.inputs[row + 4];
+                    let coupling_imag = call.inputs[row + 5];
+                    let parameter = call.inputs[row + 6];
+                    call.outputs[lane] = (left + right + left_momentum + right_momentum)
+                        * coupling_real
+                        + coupling_imag
+                        + parameter;
+                }
+            }
+            1 => {
+                assert_eq!(call.input_component_count, 3);
+                assert_eq!(call.output_component_count, 1);
+                for lane in 0..call.lane_count {
+                    let row = lane * call.input_component_count;
+                    let momentum = call.inputs[row];
+                    let current = call.inputs[row + 1];
+                    let parameter = call.inputs[row + 2];
+                    call.outputs[lane] = current * momentum + parameter;
+                }
+            }
+            2 => {
+                assert_eq!(call.input_component_count, 5);
+                assert_eq!(call.output_component_count, 1);
+                for lane in 0..call.lane_count {
+                    let row = lane * call.input_component_count;
+                    let coupling_imag = call.inputs[row];
+                    let right = call.inputs[row + 1];
+                    let coupling_real = call.inputs[row + 2];
+                    let left = call.inputs[row + 3];
+                    let parameter = call.inputs[row + 4];
+                    call.outputs[lane] = left * right * coupling_real + coupling_imag + parameter;
+                }
+            }
+            _ => unreachable!(),
+        }
+        Ok(())
+    }
+}
+
+fn c64(real: f64) -> EagerComplex64 {
+    EagerComplex64::new(real, 0.0)
+}
+
+fn definition() -> EagerPlanDefinition {
+    EagerPlanDefinition {
+        dimensions: EagerPlanDimensions {
+            value_slot_component_counts: vec![1, 1, 1, 1, 1, 1],
+            momentum_slot_component_counts: vec![1],
+            current_component_counts: vec![1, 1],
+            parameter_count: 1,
+            amplitude_count: 2,
+        },
+        kernels: vec![
+            EagerKernelSpec {
+                kernel_id: 0,
+                role: EagerKernelRole::Vertex,
+                inputs: vec![
+                    EagerKernelInput::SecondCurrentComponent(0),
+                    EagerKernelInput::FirstCurrentComponent(0),
+                    EagerKernelInput::FirstMomentumComponent(0),
+                    EagerKernelInput::SecondMomentumComponent(0),
+                    EagerKernelInput::CouplingReal,
+                    EagerKernelInput::CouplingImag,
+                    EagerKernelInput::ModelParameter(0),
+                ],
+                output_component_count: 1,
+                homogeneous_linear_first_current: false,
+                independent_block_size: 1,
+            },
+            EagerKernelSpec {
+                kernel_id: 1,
+                role: EagerKernelRole::Finalization,
+                inputs: vec![
+                    EagerKernelInput::FirstMomentumComponent(0),
+                    EagerKernelInput::FirstCurrentComponent(0),
+                    EagerKernelInput::ModelParameter(0),
+                ],
+                output_component_count: 1,
+                homogeneous_linear_first_current: false,
+                independent_block_size: 1,
+            },
+            EagerKernelSpec {
+                kernel_id: 2,
+                role: EagerKernelRole::Closure,
+                inputs: vec![
+                    EagerKernelInput::CouplingImag,
+                    EagerKernelInput::SecondCurrentComponent(0),
+                    EagerKernelInput::CouplingReal,
+                    EagerKernelInput::FirstCurrentComponent(0),
+                    EagerKernelInput::ModelParameter(0),
+                ],
+                output_component_count: 1,
+                homogeneous_linear_first_current: false,
+                independent_block_size: 1,
+            },
+        ],
+        direct_closures: vec![EagerDirectClosureSpec {
+            closure_index: 1,
+            coefficients: vec![c64(3.0)],
+        }],
+        reduction_groups: vec![
+            EagerReductionGroup {
+                coherent_group_id: 10,
+                amplitude_indices: vec![0],
+            },
+            EagerReductionGroup {
+                coherent_group_id: 20,
+                amplitude_indices: vec![1],
+            },
+        ],
+        reduction_entries: vec![
+            EagerReductionEntry {
+                left_group_index: 0,
+                right_group_index: 0,
+                coefficient: c64(1.0),
+            },
+            EagerReductionEntry {
+                left_group_index: 1,
+                right_group_index: 1,
+                coefficient: c64(0.5),
+            },
+        ],
+    }
+}
+
+fn invocation_rows() -> Vec<EagerInvocationRow> {
+    vec![
+        EagerInvocationRow {
+            kernel_id: 0,
+            left_value_slot_id: 0,
+            right_value_slot_id: 1,
+            left_momentum_slot_id: 0,
+            right_momentum_slot_id: 0,
+            coupling_slot_id: 0,
+            output_factor_source: rusticol_core::EAGER_OUTPUT_FACTOR_NONE,
+            attachment_start: 0,
+            attachment_count: 1,
+        },
+        EagerInvocationRow {
+            kernel_id: 0,
+            left_value_slot_id: 1,
+            right_value_slot_id: 0,
+            left_momentum_slot_id: 0,
+            right_momentum_slot_id: 0,
+            coupling_slot_id: 0,
+            output_factor_source: rusticol_core::EAGER_OUTPUT_FACTOR_NONE,
+            attachment_start: 1,
+            attachment_count: 1,
+        },
+    ]
+}
+
+fn attachment_rows() -> Vec<EagerAttachmentRow> {
+    vec![
+        EagerAttachmentRow {
+            result_current_id: 0,
+            factor_real: 1.0,
+            factor_imag: 0.0,
+        },
+        EagerAttachmentRow {
+            result_current_id: 1,
+            factor_real: -1.0,
+            factor_imag: 0.0,
+        },
+    ]
+}
+
+fn finalization_rows() -> Vec<EagerFinalizationRow> {
+    vec![
+        EagerFinalizationRow {
+            kernel_id: 1,
+            current_id: 0,
+            unpropagated_value_slot_id: 2,
+            propagated_value_slot_id: 3,
+            momentum_slot_id: 0,
+        },
+        EagerFinalizationRow {
+            kernel_id: 1,
+            current_id: 1,
+            unpropagated_value_slot_id: 4,
+            propagated_value_slot_id: 5,
+            momentum_slot_id: 0,
+        },
+    ]
+}
+
+fn closure_rows() -> Vec<EagerClosureRow> {
+    vec![
+        EagerClosureRow {
+            kernel_id: 2,
+            left_value_slot_id: 3,
+            right_value_slot_id: 0,
+            amplitude_index: 0,
+            coupling_slot_id: 0,
+            output_factor_source: rusticol_core::EAGER_OUTPUT_FACTOR_NONE,
+            factor_real: 1.0,
+            factor_imag: 0.0,
+        },
+        EagerClosureRow {
+            kernel_id: MISSING_U32,
+            left_value_slot_id: 4,
+            right_value_slot_id: 1,
+            amplitude_index: 1,
+            coupling_slot_id: MISSING_U32,
+            output_factor_source: rusticol_core::EAGER_OUTPUT_FACTOR_NONE,
+            factor_real: 2.0,
+            factor_imag: 0.0,
+        },
+    ]
+}
+
+fn build_plan_with(
+    definition: EagerPlanDefinition,
+    invocations: &[EagerInvocationRow],
+    attachments: &[EagerAttachmentRow],
+    finalizations: &[EagerFinalizationRow],
+    closures: &[EagerClosureRow],
+) -> RusticolResult<EagerExecutionPlan> {
+    let coupling_bytes = EagerCouplingRow::encode_table(&[EagerCouplingRow {
+        real_parameter_id: 0,
+        imag_parameter_id: MISSING_U32,
+        constant_real: 99.0,
+        constant_imag: 0.5,
+    }])?;
+    let invocation_bytes = EagerInvocationRow::encode_table(invocations)?;
+    let attachment_bytes = EagerAttachmentRow::encode_table(attachments)?;
+    let finalization_bytes = EagerFinalizationRow::encode_table(finalizations)?;
+    let closure_bytes = EagerClosureRow::encode_table(closures)?;
+    let stage = EagerStagePayload {
+        stage_index: 1,
+        invocations: &invocation_bytes,
+        attachments: &attachment_bytes,
+        finalizations: &finalization_bytes,
+    };
+    EagerExecutionPlan::from_payloads(
+        definition,
+        EagerPlanPayloads {
+            couplings: &coupling_bytes,
+            stages: &[stage],
+            closures: &closure_bytes,
+            selector_domains: None,
+        },
+    )
+}
+
+fn build_runtime(options: EagerRuntimeOptions) -> EagerExecutionRuntime {
+    let plan = build_plan_with(
+        definition(),
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap();
+    EagerExecutionRuntime::new(plan, options).unwrap()
+}
+
+#[derive(Default)]
+struct BlockBackend {
+    calls_by_block_size: [usize; 5],
+}
+
+impl EagerKernelBackend for BlockBackend {
+    fn evaluate_batch(&mut self, call: EagerKernelCall<'_>) -> RusticolResult<()> {
+        let block_size = call.independent_block_size as usize;
+        self.calls_by_block_size[block_size] += 1;
+        assert_eq!(call.input_component_count, 2 * block_size);
+        assert_eq!(call.output_component_count, block_size);
+        for row in 0..call.lane_count {
+            for lane in 0..block_size {
+                let input = row * call.input_component_count + lane * 2;
+                let output = row * call.output_component_count + lane;
+                call.outputs[output] = call.inputs[input] + call.inputs[input + 1];
+            }
+        }
+        Ok(())
+    }
+}
+
+fn build_block_runtime(point_count: usize) -> EagerExecutionRuntime {
+    const INVOCATION_COUNT: usize = 5;
+    let definition = EagerPlanDefinition {
+        dimensions: EagerPlanDimensions {
+            value_slot_component_counts: vec![1; 2 + INVOCATION_COUNT],
+            momentum_slot_component_counts: vec![1],
+            current_component_counts: vec![1; INVOCATION_COUNT],
+            parameter_count: 0,
+            amplitude_count: INVOCATION_COUNT as u32,
+        },
+        kernels: vec![EagerKernelSpec {
+            kernel_id: 0,
+            role: EagerKernelRole::Vertex,
+            inputs: vec![
+                EagerKernelInput::FirstCurrentComponent(0),
+                EagerKernelInput::SecondCurrentComponent(0),
+            ],
+            output_component_count: 1,
+            homogeneous_linear_first_current: false,
+            independent_block_size: 4,
+        }],
+        direct_closures: (0..INVOCATION_COUNT)
+            .map(|index| EagerDirectClosureSpec {
+                closure_index: index as u32,
+                coefficients: vec![c64(1.0)],
+            })
+            .collect(),
+        reduction_groups: (0..INVOCATION_COUNT)
+            .map(|index| EagerReductionGroup {
+                coherent_group_id: index as u32,
+                amplitude_indices: vec![index as u32],
+            })
+            .collect(),
+        reduction_entries: (0..INVOCATION_COUNT)
+            .map(|index| EagerReductionEntry {
+                left_group_index: index as u32,
+                right_group_index: index as u32,
+                coefficient: c64(1.0),
+            })
+            .collect(),
+    };
+    let invocations = (0..INVOCATION_COUNT)
+        .map(|index| EagerInvocationRow {
+            kernel_id: 0,
+            left_value_slot_id: 0,
+            right_value_slot_id: 1,
+            left_momentum_slot_id: 0,
+            right_momentum_slot_id: 0,
+            coupling_slot_id: 0,
+            output_factor_source: rusticol_core::EAGER_OUTPUT_FACTOR_NONE,
+            attachment_start: index as u64,
+            attachment_count: 1,
+        })
+        .collect::<Vec<_>>();
+    let attachments = (0..INVOCATION_COUNT)
+        .map(|index| EagerAttachmentRow {
+            result_current_id: index as u32,
+            factor_real: index as f64 + 1.0,
+            factor_imag: 0.0,
+        })
+        .collect::<Vec<_>>();
+    let finalizations = (0..INVOCATION_COUNT)
+        .map(|index| EagerFinalizationRow {
+            kernel_id: MISSING_U32,
+            current_id: index as u32,
+            unpropagated_value_slot_id: (2 + index) as u32,
+            propagated_value_slot_id: MISSING_U32,
+            momentum_slot_id: 0,
+        })
+        .collect::<Vec<_>>();
+    let closures = (0..INVOCATION_COUNT)
+        .map(|index| EagerClosureRow {
+            kernel_id: MISSING_U32,
+            left_value_slot_id: (2 + index) as u32,
+            right_value_slot_id: 0,
+            amplitude_index: index as u32,
+            coupling_slot_id: MISSING_U32,
+            output_factor_source: rusticol_core::EAGER_OUTPUT_FACTOR_NONE,
+            factor_real: 1.0,
+            factor_imag: 0.0,
+        })
+        .collect::<Vec<_>>();
+    let coupling_bytes = EagerCouplingRow::encode_table(&[EagerCouplingRow {
+        real_parameter_id: MISSING_U32,
+        imag_parameter_id: MISSING_U32,
+        constant_real: 1.0,
+        constant_imag: 0.0,
+    }])
+    .unwrap();
+    let invocation_bytes = EagerInvocationRow::encode_table(&invocations).unwrap();
+    let attachment_bytes = EagerAttachmentRow::encode_table(&attachments).unwrap();
+    let finalization_bytes = EagerFinalizationRow::encode_table(&finalizations).unwrap();
+    let closure_bytes = EagerClosureRow::encode_table(&closures).unwrap();
+    let stage = EagerStagePayload {
+        stage_index: 1,
+        invocations: &invocation_bytes,
+        attachments: &attachment_bytes,
+        finalizations: &finalization_bytes,
+    };
+    let plan = EagerExecutionPlan::from_payloads(
+        definition,
+        EagerPlanPayloads {
+            couplings: &coupling_bytes,
+            stages: &[stage],
+            closures: &closure_bytes,
+            selector_domains: None,
+        },
+    )
+    .unwrap();
+    EagerExecutionRuntime::new(
+        plan,
+        EagerRuntimeOptions {
+            point_tile_size: point_count,
+            workspace_bytes: 64 * 1024,
+        },
+    )
+    .unwrap()
+}
+
+fn selector_domain_id_bytes(values: &[u32]) -> Vec<u8> {
+    EagerSelectorDomainIdRow::encode_table(
+        &values
+            .iter()
+            .map(|domain_id| EagerSelectorDomainIdRow {
+                domain_id: *domain_id,
+            })
+            .collect::<Vec<_>>(),
+    )
+    .unwrap()
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_selector_plan_with(
+    finalizations: &[EagerFinalizationRow],
+    domain_rows: &[EagerSelectorDomainRow],
+    group_rows: &[EagerSelectorGroupRow],
+    invocation_domain_ids: &[u32],
+    attachment_domain_ids: &[u32],
+    unpropagated_domain_ids: &[u32],
+    propagated_domain_ids: &[u32],
+    closure_domain_ids: &[u32],
+) -> RusticolResult<EagerExecutionPlan> {
+    let coupling_bytes = EagerCouplingRow::encode_table(&[EagerCouplingRow {
+        real_parameter_id: 0,
+        imag_parameter_id: MISSING_U32,
+        constant_real: 99.0,
+        constant_imag: 0.5,
+    }])?;
+    let invocation_bytes = EagerInvocationRow::encode_table(&invocation_rows())?;
+    let attachment_bytes = EagerAttachmentRow::encode_table(&attachment_rows())?;
+    let finalization_bytes = EagerFinalizationRow::encode_table(finalizations)?;
+    let closure_bytes = EagerClosureRow::encode_table(&closure_rows())?;
+    let stage = EagerStagePayload {
+        stage_index: 1,
+        invocations: &invocation_bytes,
+        attachments: &attachment_bytes,
+        finalizations: &finalization_bytes,
+    };
+    let domains = EagerSelectorDomainRow::encode_table(domain_rows)?;
+    let groups = EagerSelectorGroupRow::encode_table(group_rows)?;
+    let invocation_domains = selector_domain_id_bytes(invocation_domain_ids);
+    let attachment_domains = selector_domain_id_bytes(attachment_domain_ids);
+    let unpropagated_domains = selector_domain_id_bytes(unpropagated_domain_ids);
+    let propagated_domains = selector_domain_id_bytes(propagated_domain_ids);
+    let closure_domains = selector_domain_id_bytes(closure_domain_ids);
+    let selector_stage = EagerSelectorStagePayload {
+        stage_index: 1,
+        invocation_domains: &invocation_domains,
+        attachment_domains: &attachment_domains,
+        unpropagated_finalization_domains: &unpropagated_domains,
+        propagated_finalization_domains: &propagated_domains,
+    };
+    let selector = EagerSelectorPayloads {
+        domains: &domains,
+        domain_group_ids: &groups,
+        stages: &[selector_stage],
+        closure_domains: &closure_domains,
+    };
+    EagerExecutionPlan::from_payloads(
+        definition(),
+        EagerPlanPayloads {
+            couplings: &coupling_bytes,
+            stages: &[stage],
+            closures: &closure_bytes,
+            selector_domains: Some(selector),
+        },
+    )
+}
+
+fn build_selector_runtime(options: EagerRuntimeOptions) -> EagerExecutionRuntime {
+    let domains = [
+        EagerSelectorDomainRow {
+            member_start: 0,
+            member_count: 0,
+        },
+        EagerSelectorDomainRow {
+            member_start: 0,
+            member_count: 1,
+        },
+        EagerSelectorDomainRow {
+            member_start: 1,
+            member_count: 1,
+        },
+    ];
+    let groups = [
+        EagerSelectorGroupRow {
+            coherent_group_id: 10,
+        },
+        EagerSelectorGroupRow {
+            coherent_group_id: 20,
+        },
+    ];
+    let plan = build_selector_plan_with(
+        &finalization_rows(),
+        &domains,
+        &groups,
+        &[1, 2],
+        &[1, 2],
+        &[0, 2],
+        &[1, 0],
+        &[1, 2],
+    )
+    .unwrap();
+    EagerExecutionRuntime::new(plan, options).unwrap()
+}
+
+fn inputs(point_count: usize) -> (Vec<EagerComplex64>, Vec<f64>) {
+    let mut values = vec![c64(0.0); 6 * point_count];
+    let mut momenta = vec![0.0; point_count];
+    for point in 0..point_count {
+        values[point] = c64(point as f64 + 1.0);
+        values[point_count + point] = c64(10.0 + point as f64);
+        momenta[point] = 0.5 + point as f64 * 0.25;
+    }
+    (values, momenta)
+}
+
+fn expected(point: usize, momenta: &[f64]) -> (EagerComplex64, EagerComplex64, f64) {
+    let left = point as f64 + 1.0;
+    let right = 10.0 + point as f64;
+    let momentum = momenta[point];
+    let current = (left + right + 2.0 * momentum) * 2.0 + 0.5 + 2.0;
+    let propagated = current * momentum + 2.0;
+    let amplitude_0 = propagated * left * 2.0 + 0.5 + 2.0;
+    let amplitude_1 = -6.0 * current * right;
+    let reduced = amplitude_0 * amplitude_0 + 0.5 * amplitude_1 * amplitude_1;
+    (c64(amplitude_0), c64(amplitude_1), reduced)
+}
+
+#[test]
+fn executes_packetized_stages_finalization_closures_and_reduction() {
+    let point_count = 5;
+    let mut runtime = build_runtime(EagerRuntimeOptions {
+        point_tile_size: 2,
+        workspace_bytes: 4096,
+    });
+    let (values, momenta) = inputs(point_count);
+    let mut amplitudes = vec![c64(0.0); 2 * point_count];
+    let mut reduced = vec![0.0; point_count];
+    let mut backend = MockBackend::default();
+
+    runtime
+        .evaluate_into(
+            &mut backend,
+            point_count,
+            &values,
+            &momenta,
+            &[c64(2.0)],
+            &mut amplitudes,
+            &mut reduced,
+        )
+        .unwrap();
+
+    for point in 0..point_count {
+        let (amplitude_0, amplitude_1, expected_reduced) = expected(point, &momenta);
+        assert_eq!(amplitudes[point], amplitude_0);
+        assert_eq!(amplitudes[point_count + point], amplitude_1);
+        assert_eq!(reduced[point], expected_reduced);
+    }
+    assert_eq!(backend.calls, [3, 3, 3]);
+    assert_eq!(backend.max_lanes, [4, 4, 2]);
+    assert_eq!(runtime.effective_point_tile_size(), 2);
+    assert_eq!(runtime.plan().invocation_count(), 2);
+    assert_eq!(runtime.plan().attachment_count(), 2);
+    assert_eq!(runtime.plan().closure_count(), 2);
+    assert_eq!(runtime.plan().reduction_group_count(), 2);
+    assert_eq!(runtime.plan().reduction_entry_count(), 2);
+    assert_eq!(runtime.plan().stage_indices().collect::<Vec<_>>(), [1]);
+}
+
+#[test]
+fn independent_block_variant_preserves_scalar_tail_and_allocates_nothing() {
+    const POINT_COUNT: usize = 3;
+    const INVOCATION_COUNT: usize = 5;
+    let mut runtime = build_block_runtime(POINT_COUNT);
+    let mut values = vec![c64(0.0); (2 + INVOCATION_COUNT) * POINT_COUNT];
+    for point in 0..POINT_COUNT {
+        values[point] = c64(point as f64 + 1.0);
+        values[POINT_COUNT + point] = c64(10.0 + point as f64);
+    }
+    let momenta = vec![0.0; POINT_COUNT];
+    let mut amplitudes = vec![c64(0.0); INVOCATION_COUNT * POINT_COUNT];
+    let mut reduced = vec![0.0; POINT_COUNT];
+    let mut backend = BlockBackend::default();
+
+    runtime
+        .evaluate_into(
+            &mut backend,
+            POINT_COUNT,
+            &values,
+            &momenta,
+            &[],
+            &mut amplitudes,
+            &mut reduced,
+        )
+        .unwrap();
+    assert_eq!(backend.calls_by_block_size[4], 1);
+    assert_eq!(backend.calls_by_block_size[1], 1);
+    for point in 0..POINT_COUNT {
+        let left = point as f64 + 1.0;
+        let right = 10.0 + point as f64;
+        let mut expected_reduced = 0.0;
+        for invocation in 0..INVOCATION_COUNT {
+            let expected = (left + right) * (invocation as f64 + 1.0) * left;
+            assert_eq!(amplitudes[invocation * POINT_COUNT + point], c64(expected));
+            expected_reduced += expected * expected;
+        }
+        assert_eq!(reduced[point], expected_reduced);
+    }
+
+    let (_, allocation_count) = count_allocations(|| {
+        runtime.evaluate_into(
+            &mut backend,
+            POINT_COUNT,
+            &values,
+            &momenta,
+            &[],
+            &mut amplitudes,
+            &mut reduced,
+        )
+    });
+    assert_eq!(allocation_count, 0);
+}
+
+#[test]
+fn reduces_coherent_amplitudes_through_compact_groups() {
+    let point_count = 3;
+    let mut definition = definition();
+    definition.reduction_groups = vec![EagerReductionGroup {
+        coherent_group_id: 10,
+        amplitude_indices: vec![0, 1],
+    }];
+    definition.reduction_entries = vec![EagerReductionEntry {
+        left_group_index: 0,
+        right_group_index: 0,
+        coefficient: c64(0.25),
+    }];
+    let plan = build_plan_with(
+        definition,
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap();
+    let mut runtime = EagerExecutionRuntime::new(
+        plan,
+        EagerRuntimeOptions {
+            point_tile_size: 2,
+            workspace_bytes: 4096,
+        },
+    )
+    .unwrap();
+    let (values, momenta) = inputs(point_count);
+    let mut amplitudes = vec![c64(0.0); 2 * point_count];
+    let mut reduced = vec![0.0; point_count];
+    runtime
+        .evaluate_into(
+            &mut MockBackend::default(),
+            point_count,
+            &values,
+            &momenta,
+            &[c64(2.0)],
+            &mut amplitudes,
+            &mut reduced,
+        )
+        .unwrap();
+
+    for (point, actual) in reduced.iter().copied().enumerate() {
+        let (left, right, _) = expected(point, &momenta);
+        assert_eq!(actual, 0.25 * (left + right).norm_sqr());
+    }
+}
+
+#[test]
+fn workspace_budget_reduces_tile_and_splits_packets() {
+    let runtime = build_runtime(EagerRuntimeOptions {
+        point_tile_size: 8,
+        workspace_bytes: 400,
+    });
+    assert_eq!(runtime.effective_point_tile_size(), 1);
+    assert_eq!(runtime.packet_count(), 4);
+    assert!(runtime.workspace_bytes() <= 400);
+
+    let plan = build_plan_with(
+        definition(),
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap();
+    let runtime = EagerExecutionRuntime::new(
+        plan,
+        EagerRuntimeOptions {
+            point_tile_size: 8,
+            workspace_bytes: 250,
+        },
+    )
+    .unwrap();
+    assert_eq!(runtime.effective_point_tile_size(), 1);
+    assert!(runtime.workspace_bytes() > 250);
+}
+
+#[test]
+fn warmed_evaluation_performs_no_allocations() {
+    let point_count = 4;
+    let mut runtime = build_runtime(EagerRuntimeOptions {
+        point_tile_size: point_count,
+        workspace_bytes: 4096,
+    });
+    let (values, momenta) = inputs(point_count);
+    let parameters = [c64(2.0)];
+    let mut amplitudes = vec![c64(0.0); 2 * point_count];
+    let mut reduced = vec![0.0; point_count];
+    let mut backend = MockBackend::default();
+    runtime
+        .evaluate_into(
+            &mut backend,
+            point_count,
+            &values,
+            &momenta,
+            &parameters,
+            &mut amplitudes,
+            &mut reduced,
+        )
+        .unwrap();
+
+    let (result, allocation_count) = count_allocations(|| {
+        runtime.evaluate_into(
+            &mut backend,
+            point_count,
+            &values,
+            &momenta,
+            &parameters,
+            &mut amplitudes,
+            &mut reduced,
+        )
+    });
+    result.unwrap();
+    assert_eq!(allocation_count, 0);
+}
+
+#[test]
+fn selector_domains_skip_unrelated_kernels_and_structural_zeros() {
+    let point_count = 5;
+    let mut runtime = build_selector_runtime(EagerRuntimeOptions {
+        point_tile_size: 2,
+        workspace_bytes: 4096,
+    });
+    assert_eq!(runtime.selector_group_ids(), Some(vec![10, 20]));
+    let (values, momenta) = inputs(point_count);
+    let parameters = [c64(2.0)];
+    let mut amplitudes = vec![c64(99.0); 2 * point_count];
+
+    let mut first_backend = MockBackend::default();
+    runtime
+        .evaluate_selected_amplitudes_into(
+            &mut first_backend,
+            &[10],
+            point_count,
+            &values,
+            &momenta,
+            &parameters,
+            &mut amplitudes,
+        )
+        .unwrap();
+    for point in 0..point_count {
+        let (left, _right, _) = expected(point, &momenta);
+        assert_eq!(amplitudes[point], left);
+        assert_eq!(amplitudes[point_count + point], c64(0.0));
+    }
+    assert_eq!(first_backend.calls, [3, 3, 3]);
+
+    let mut second_backend = MockBackend::default();
+    runtime
+        .evaluate_selected_amplitudes_into(
+            &mut second_backend,
+            &[20],
+            point_count,
+            &values,
+            &momenta,
+            &parameters,
+            &mut amplitudes,
+        )
+        .unwrap();
+    for point in 0..point_count {
+        let (_left, right, _) = expected(point, &momenta);
+        assert_eq!(amplitudes[point], c64(0.0));
+        assert_eq!(amplitudes[point_count + point], right);
+    }
+    assert_eq!(second_backend.calls, [3, 0, 0]);
+
+    let mut zero_backend = MockBackend::default();
+    runtime
+        .evaluate_selected_amplitudes_into(
+            &mut zero_backend,
+            &[],
+            point_count,
+            &values,
+            &momenta,
+            &parameters,
+            &mut amplitudes,
+        )
+        .unwrap();
+    assert!(amplitudes.iter().all(|value| *value == c64(0.0)));
+    assert_eq!(zero_backend.calls, [0, 0, 0]);
+}
+
+#[test]
+fn unknown_selected_coherent_groups_are_invalid_arguments() {
+    let mut runtime = build_selector_runtime(EagerRuntimeOptions {
+        point_tile_size: 2,
+        workspace_bytes: 4096,
+    });
+    let (values, momenta) = inputs(1);
+    let mut amplitudes = vec![c64(0.0); 2];
+    let error = runtime
+        .evaluate_selected_amplitudes_into(
+            &mut MockBackend::default(),
+            &[99],
+            1,
+            &values,
+            &momenta,
+            &[c64(2.0)],
+            &mut amplitudes,
+        )
+        .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+    assert!(error.to_string().contains("unknown coherent group 99"));
+}
+
+#[test]
+fn warmed_selected_evaluation_performs_no_allocations() {
+    let point_count = 4;
+    let mut runtime = build_selector_runtime(EagerRuntimeOptions {
+        point_tile_size: point_count,
+        workspace_bytes: 4096,
+    });
+    let (values, momenta) = inputs(point_count);
+    let parameters = [c64(2.0)];
+    let mut amplitudes = vec![c64(0.0); 2 * point_count];
+    let mut backend = MockBackend::default();
+    runtime
+        .evaluate_selected_amplitudes_into(
+            &mut backend,
+            &[10],
+            point_count,
+            &values,
+            &momenta,
+            &parameters,
+            &mut amplitudes,
+        )
+        .unwrap();
+
+    let (result, allocation_count) = count_allocations(|| {
+        runtime.evaluate_selected_amplitudes_into(
+            &mut backend,
+            &[10],
+            point_count,
+            &values,
+            &momenta,
+            &parameters,
+            &mut amplitudes,
+        )
+    });
+    result.unwrap();
+    assert_eq!(allocation_count, 0);
+}
+
+fn selector_domain_fixture() -> ([EagerSelectorDomainRow; 3], [EagerSelectorGroupRow; 2]) {
+    (
+        [
+            EagerSelectorDomainRow {
+                member_start: 0,
+                member_count: 0,
+            },
+            EagerSelectorDomainRow {
+                member_start: 0,
+                member_count: 1,
+            },
+            EagerSelectorDomainRow {
+                member_start: 1,
+                member_count: 1,
+            },
+        ],
+        [
+            EagerSelectorGroupRow {
+                coherent_group_id: 10,
+            },
+            EagerSelectorGroupRow {
+                coherent_group_id: 20,
+            },
+        ],
+    )
+}
+
+#[test]
+fn unknown_selector_domain_ids_are_artifact_errors() {
+    let (domains, groups) = selector_domain_fixture();
+    let error = build_selector_plan_with(
+        &finalization_rows(),
+        &domains,
+        &groups,
+        &[3, 2],
+        &[1, 2],
+        &[0, 2],
+        &[1, 0],
+        &[1, 2],
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("unknown domain 3"));
+}
+
+#[test]
+fn invocation_selector_domains_must_equal_attachment_unions() {
+    let (domains, groups) = selector_domain_fixture();
+    let error = build_selector_plan_with(
+        &finalization_rows(),
+        &domains,
+        &groups,
+        &[2, 2],
+        &[1, 2],
+        &[0, 2],
+        &[1, 0],
+        &[1, 2],
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("attachment union"));
+}
+
+#[test]
+fn selector_domain_members_must_be_sorted_and_unique() {
+    let domains = [
+        EagerSelectorDomainRow {
+            member_start: 0,
+            member_count: 0,
+        },
+        EagerSelectorDomainRow {
+            member_start: 0,
+            member_count: 2,
+        },
+    ];
+    let groups = [
+        EagerSelectorGroupRow {
+            coherent_group_id: 20,
+        },
+        EagerSelectorGroupRow {
+            coherent_group_id: 10,
+        },
+    ];
+    let error = build_selector_plan_with(
+        &finalization_rows(),
+        &domains,
+        &groups,
+        &[1, 1],
+        &[1, 1],
+        &[0, 1],
+        &[1, 0],
+        &[1, 1],
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("sorted and unique"));
+}
+
+#[test]
+fn absent_finalization_outputs_require_empty_selector_domains() {
+    let (domains, groups) = selector_domain_fixture();
+    let mut finalizations = finalization_rows();
+    finalizations[0].unpropagated_value_slot_id = MISSING_U32;
+    let error = build_selector_plan_with(
+        &finalizations,
+        &domains,
+        &groups,
+        &[1, 2],
+        &[1, 2],
+        &[1, 2],
+        &[1, 0],
+        &[1, 2],
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("nonempty selector domain"));
+}
+
+#[test]
+fn closure_selector_domains_must_match_amplitude_owners() {
+    let (domains, groups) = selector_domain_fixture();
+    let error = build_selector_plan_with(
+        &finalization_rows(),
+        &domains,
+        &groups,
+        &[1, 2],
+        &[1, 2],
+        &[0, 2],
+        &[1, 0],
+        &[2, 1],
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("eager closure 0"));
+    assert!(error.to_string().contains("proven dependency closure"));
+}
+
+#[test]
+fn attachment_domains_must_match_downstream_finalization_dependencies() {
+    let (domains, groups) = selector_domain_fixture();
+    let error = build_selector_plan_with(
+        &finalization_rows(),
+        &domains,
+        &groups,
+        &[2, 2],
+        &[2, 2],
+        &[0, 2],
+        &[1, 0],
+        &[1, 2],
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("attachment 0"));
+    assert!(error.to_string().contains("proven dependency closure"));
+}
+
+#[test]
+fn finalization_domains_must_follow_downstream_value_consumers() {
+    let (domains, groups) = selector_domain_fixture();
+    let error = build_selector_plan_with(
+        &finalization_rows(),
+        &domains,
+        &groups,
+        &[1, 2],
+        &[1, 2],
+        &[0, 2],
+        &[0, 0],
+        &[1, 2],
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("propagated finalization 0"));
+    assert!(error.to_string().contains("proven dependency closure"));
+}
+
+#[test]
+fn selector_domains_reject_unknown_coherent_groups() {
+    let (domains, mut groups) = selector_domain_fixture();
+    groups[0].coherent_group_id = 99;
+    let error = build_selector_plan_with(
+        &finalization_rows(),
+        &domains,
+        &groups,
+        &[1, 2],
+        &[1, 2],
+        &[0, 2],
+        &[1, 0],
+        &[1, 2],
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("unknown coherent group 99"));
+}
+
+#[test]
+fn malformed_attachment_ranges_are_artifact_errors() {
+    let mut invocations = invocation_rows();
+    invocations[0].attachment_start = u64::MAX;
+    let error = build_plan_with(
+        definition(),
+        &invocations,
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("attachment"));
+}
+
+#[test]
+fn unknown_attachment_targets_are_artifact_errors() {
+    let mut attachments = attachment_rows();
+    attachments[1].result_current_id = 99;
+    let error = build_plan_with(
+        definition(),
+        &invocation_rows(),
+        &attachments,
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("unknown slot"));
+}
+
+#[test]
+fn duplicate_finalization_is_an_artifact_error() {
+    let mut finalizations = finalization_rows();
+    finalizations[1].current_id = 0;
+    let error = build_plan_with(
+        definition(),
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalizations,
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("more than once"));
+}
+
+#[test]
+fn finalization_of_an_unwritten_current_is_an_artifact_error() {
+    let mut attachments = attachment_rows();
+    attachments[1].result_current_id = 0;
+    let error = build_plan_with(
+        definition(),
+        &invocation_rows(),
+        &attachments,
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("finalizes unwritten current 1"));
+}
+
+#[test]
+fn kernel_roles_and_finalization_outputs_are_validated() {
+    let mut wrong_role = definition();
+    wrong_role.kernels[0].role = EagerKernelRole::Closure;
+    let error = build_plan_with(
+        wrong_role,
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("expected Vertex"));
+
+    let mut aliased = finalization_rows();
+    aliased[0].propagated_value_slot_id = aliased[0].unpropagated_value_slot_id;
+    let error = build_plan_with(
+        definition(),
+        &invocation_rows(),
+        &attachment_rows(),
+        &aliased,
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("aliases"));
+}
+
+#[test]
+fn direct_closure_requires_exact_coefficients() {
+    let mut missing = definition();
+    missing.direct_closures.clear();
+    let error = build_plan_with(
+        missing,
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("lacks contraction coefficients"));
+
+    let mut wrong_width = definition();
+    wrong_width.direct_closures[0].coefficients.push(c64(1.0));
+    let error = build_plan_with(
+        wrong_width,
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("component widths"));
+}
+
+#[test]
+fn kernel_input_components_are_validated_against_invocation_slots() {
+    let mut definition = definition();
+    definition.kernels[0].inputs[0] = EagerKernelInput::SecondCurrentComponent(1);
+    let error = build_plan_with(
+        definition,
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("SecondCurrentComponent(1)"));
+    assert!(error.to_string().contains("outside 0..1"));
+}
+
+#[test]
+fn kernel_input_roles_reject_unavailable_sources() {
+    let mut definition = definition();
+    definition.kernels[1]
+        .inputs
+        .push(EagerKernelInput::CouplingReal);
+    let error = build_plan_with(
+        definition,
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("Finalization"));
+    assert!(error.to_string().contains("CouplingReal"));
+}
+
+#[test]
+fn kernel_input_descriptors_are_unique_and_parameter_bounded() {
+    let mut duplicate = definition();
+    duplicate.kernels[2]
+        .inputs
+        .push(EagerKernelInput::CouplingImag);
+    let error = build_plan_with(
+        duplicate,
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("repeats input descriptor"));
+
+    let mut out_of_bounds = definition();
+    out_of_bounds.kernels[0]
+        .inputs
+        .push(EagerKernelInput::ModelParameter(1));
+    let error = build_plan_with(
+        out_of_bounds,
+        &invocation_rows(),
+        &attachment_rows(),
+        &finalization_rows(),
+        &closure_rows(),
+    )
+    .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::Artifact);
+    assert!(error.to_string().contains("model parameter"));
+    assert!(error.to_string().contains("outside 0..1"));
+}
+
+#[test]
+fn invalid_execution_buffers_return_errors_without_panicking() {
+    let mut runtime = build_runtime(EagerRuntimeOptions {
+        point_tile_size: 2,
+        workspace_bytes: 4096,
+    });
+    let mut backend = MockBackend::default();
+    let mut amplitudes = vec![c64(0.0); 2];
+    let mut reduced = vec![0.0];
+    let error = runtime
+        .evaluate_into(
+            &mut backend,
+            1,
+            &[],
+            &[1.0],
+            &[c64(2.0)],
+            &mut amplitudes,
+            &mut reduced,
+        )
+        .unwrap_err();
+    assert_eq!(error.kind(), RusticolErrorKind::InvalidArgument);
+    assert!(error.to_string().contains("initial value buffer"));
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/tests/fixtures/on_the_fly_query_parity_v1.json b/pyamplicol/rust/crates/rusticol-core/tests/fixtures/on_the_fly_query_parity_v1.json
new file mode 100644
index 0000000000..42f131c7a8
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/tests/fixtures/on_the_fly_query_parity_v1.json
@@ -0,0 +1,304 @@
+{
+  "schema": "pyamplicol-on-the-fly-query-parity-fixture-v1",
+  "provenance": {
+    "architecture_base_commit": "f986acf61e6807b74453b5ad7e7793b73082ee30",
+    "selected_generic_dag_oracle_commit": "2312b1137c7e2f3d6bdf9064a902592c16bac58c",
+    "ownership_oracle_commit": "cf8de3820152be262bafc6f93e5af9a6f423b271",
+    "scaling_oracle_commit": "dc171ac357c2817465f20baf3ff0efa91086b53a",
+    "numerical_authority": "retained authenticated recurrence runtime plus selected-GenericDAG p32 interpreter",
+    "digest_contract": "sha256 of the sorted canonical-JSON selected-GenericDAG semantic row multiset"
+  },
+  "massless_2_to_3_point": {
+    "sha256": "3be3d02aa9d9932332e461a7dfd874cd97e0305f7a148119dc5a5acc760aa84b",
+    "momenta": [
+      [500.0, 0.0, 0.0, 500.0],
+      [500.0, 0.0, 0.0, -500.0],
+      [333.3333333333333, 333.3333333333333, 0.0, 0.0],
+      [333.3333333333333, -166.66666666666666, 288.67513459481285, 0.0],
+      [333.3333333333333, -166.66666666666666, -288.67513459481285, 0.0]
+    ]
+  },
+  "selected_queries": [
+    {
+      "name": "scalar_contact",
+      "process": "h h > h h",
+      "coupling_limits": {"QCD": 0, "QED": 2},
+      "flow_rank": "0",
+      "flow_id": "flow:singlet",
+      "helicity_rank": "0",
+      "helicity_id": "h:+0,+0,+0,+0",
+      "current_count": 11,
+      "contribution_count": 12,
+      "closure_count": 1,
+      "contribution_multiset_sha256": "871b91602e6883c887a89a979578d41ee05f9d7ff06c643eb57084bffbc84213",
+      "closure_multiset_sha256": "b440504ec358c7c49df1c0b782dc716d0d4af40d7a7394beaeb850f5634c81a4"
+    },
+    {
+      "name": "pure_gluon_n5",
+      "process": "g g > g g g",
+      "coupling_limits": {"QCD": 3, "QED": 0},
+      "flow_rank": "0",
+      "flow_id": "flow:1,2,3,4,5",
+      "helicity_rank": "0",
+      "helicity_id": "h:-1,-1,-1,-1,-1",
+      "current_count": 16,
+      "contribution_count": 25,
+      "closure_count": 1,
+      "contribution_multiset_sha256": "34926d54a299c6610de4c76384b6f8c4b7cbc8f076063d5a484f5a6822168102",
+      "closure_multiset_sha256": "345db39a6f134b4870c5207573630e299d61208ecd2ac9c9aef766a2044b06a3",
+      "selected_generic_dag_p32": "0.00004178069796309911254363311176",
+      "retained_recurrence_p32": "0.000041780697963098513001361030334541",
+      "retained_recurrence_f64_bits": "0x3f05e7b5d9d0f228",
+      "maximum_relative_residual": "2e-13"
+    },
+    {
+      "name": "one_open_line_n5",
+      "process": "u u~ > g g g",
+      "coupling_limits": {"QCD": 3, "QED": 0},
+      "flow_rank": "0",
+      "flow_id": "flow:2,3,4,5,1",
+      "helicity_rank": "9",
+      "helicity_id": "h:-1,+1,-1,-1,+1",
+      "current_count": 13,
+      "contribution_count": 14,
+      "closure_count": 1,
+      "contribution_multiset_sha256": "55fda24e1598a7125fdbda55b1e826f41ddcc0d991c25f844bc18159fcdbf5f5",
+      "closure_multiset_sha256": "2d29f0645b17d6bd55bfb2d0e44bbb503b2190f3bfb02e93f45fb2e1aa8e4024",
+      "selected_generic_dag_p32": "0.000001222663314878072887698934878",
+      "retained_recurrence_p32": "0.0000012226633148780577574738566420466",
+      "retained_recurrence_f64_bits": "0x3eb4834c88148d10",
+      "maximum_relative_residual": "2e-13"
+    },
+    {
+      "name": "three_distinct_open_lines_n6",
+      "process": "d d~ > u u~ s s~",
+      "coupling_limits": {"QCD": 4, "QED": 0},
+      "flow_rank": "0",
+      "flow_id": "flow:2,1,3,4,5,6",
+      "helicity_rank": "21",
+      "helicity_id": "h:-1,+1,-1,+1,-1,+1",
+      "current_count": 18,
+      "contribution_count": 16,
+      "closure_count": 2,
+      "contribution_multiset_sha256": "effc6a982369541b23bd804b3f293b914b26e3fa6e7396675452249a43f6162b",
+      "closure_multiset_sha256": "415aab2f7875fab2760cd1b959696c708dd69ea864a88de1f660dcedee2957e0",
+      "owner_multiset_sha256": "1b8a2d2fbdbd3b10303f0d7684c85db815fd91bc47c1dfa8ffb8ef18169234a5"
+    },
+    {
+      "name": "three_identical_open_lines_n6",
+      "process": "d d~ > u u~ u u~",
+      "coupling_limits": {"QCD": 4, "QED": 0},
+      "flow_rank": "0",
+      "flow_id": "flow:2,1,3,4,5,6",
+      "helicity_rank": "19",
+      "helicity_id": "h:-1,+1,-1,-1,+1,+1",
+      "current_count": 15,
+      "contribution_count": 11,
+      "closure_count": 2,
+      "contribution_multiset_sha256": "ea86aa72b8d08672672cfccecb8ddcb7fa7057338a344378a91eec47837c7cab",
+      "closure_multiset_sha256": "02bb77b2b2fd5884ab9e5db033e02c5bc8a38b7d30964094cad4993bb839b13a",
+      "owner_multiset_sha256": "e6cc180248ad8a3f39196a726aba76018b1ffb3dc01bb18e55b9d9eefcad58ab"
+    },
+    {
+      "name": "three_identical_open_lines_exchange_n6",
+      "process": "d d~ > u u~ u u~",
+      "coupling_limits": {
+        "QCD": 4,
+        "QED": 0
+      },
+      "flow_rank": "2",
+      "flow_id": "flow:2,4,3,1,5,6",
+      "helicity_rank": "19",
+      "helicity_id": "h:-1,+1,-1,-1,+1,+1",
+      "current_count": 13,
+      "contribution_count": 10,
+      "closure_count": 1,
+      "contribution_multiset_sha256": "30082ef8c2d305d1ddc2370b28ff041e2d7cf22b2ab7419d41f667f3b4762c63",
+      "closure_multiset_sha256": "3be9bd544b4aa157bc08c597bb2f9fbcd43e0e3c649d75921bcdc01b38071ebe",
+      "owner_multiset_sha256": "6ccdfc73ac4efdf43f0c6d7556b6fe7e882be02567bc328b3f1d0d30865f0fb5",
+      "negative_evaluation_factor_count": 1,
+      "negative_evaluation_factor_multiset_sha256": "427fbcf7b8fc983357aa0106fef6f01f98493ba24354f4dde20403d6df928739"
+    }
+  ],
+  "reduction_contracts": [
+    {
+      "process": "h h > h h",
+      "color_factor": 1,
+      "average_factor": 4,
+      "identical_factor": 2,
+      "qcd_coupling_power": 0,
+      "electroweak_coupling_power": 4,
+      "global_coupling_factor": "0.0012942082163584319"
+    },
+    {
+      "process": "g g > g g g",
+      "color_factor": 243,
+      "average_factor": 256,
+      "identical_factor": 6,
+      "qcd_coupling_power": 3,
+      "electroweak_coupling_power": 0,
+      "global_coupling_factor": "3.260435506341527"
+    },
+    {
+      "process": "u u~ > g g g",
+      "color_factor": 81,
+      "average_factor": 36,
+      "identical_factor": 6,
+      "qcd_coupling_power": 3,
+      "electroweak_coupling_power": 0,
+      "global_coupling_factor": "3.260435506341527"
+    },
+    {
+      "process": "d d~ > u u~ s s~",
+      "color_factor": 27,
+      "average_factor": 36,
+      "identical_factor": 1,
+      "qcd_coupling_power": 4,
+      "electroweak_coupling_power": 0,
+      "global_coupling_factor": "4.834677230554605"
+    },
+    {
+      "process": "d d~ > u u~ u u~",
+      "color_factor": 27,
+      "average_factor": 36,
+      "identical_factor": 4,
+      "qcd_coupling_power": 4,
+      "electroweak_coupling_power": 0,
+      "global_coupling_factor": "4.834677230554605"
+    }
+  ],
+  "small_domain_exhaustive_oracles": [
+    {
+      "process": "g g > g g",
+      "query_count": 96,
+      "structural_zero_count": 0,
+      "maximum_current_count": 9,
+      "maximum_contribution_count": 8,
+      "maximum_closure_count": 1,
+      "aggregate_sha256": "6281e91a1ddf5913bd4e8658d56b6cbb8bbb668dab4d5d727786bbab53034376"
+    },
+    {
+      "process": "u u~ > g g",
+      "query_count": 32,
+      "structural_zero_count": 16,
+      "maximum_current_count": 7,
+      "maximum_contribution_count": 4,
+      "maximum_closure_count": 1,
+      "aggregate_sha256": "c2f1c25205461cb52409e51e42ef31597bbc354ef432955245b7ed4386d297b1"
+    },
+    {
+      "process": "d d~ > u u~ s s~",
+      "query_count": 384,
+      "structural_zero_count": 336,
+      "maximum_current_count": 18,
+      "maximum_contribution_count": 16,
+      "maximum_closure_count": 2,
+      "aggregate_sha256": "93ff051e1380d329572f459e48b3d13ac691d32da0532fcb8c65651d57c978a9"
+    },
+    {
+      "process": "d d~ > u u~ u u~",
+      "query_count": 384,
+      "structural_zero_count": 312,
+      "maximum_current_count": 20,
+      "maximum_contribution_count": 22,
+      "maximum_closure_count": 2,
+      "aggregate_sha256": "80ae8c05d44d0922f03b43e74c9fa065fe1380b4160ef40619365fd16cd0a258"
+    }
+  ],
+  "structural_scale_queries": [
+    {
+      "name": "pure_gluon_n7_first",
+      "process": "g g > g g g g g",
+      "flow_cardinality": "720",
+      "helicity_cardinality": "128",
+      "flow_rank": "0",
+      "helicity_rank": "0",
+      "current_count": 36,
+      "contribution_count": 105,
+      "closure_count": 1,
+      "peak_query_rows": 141,
+      "contribution_multiset_sha256": "db65f1f25b63d9748295aaa4f756a49ea46c60aad64fcba18cb306193637185b",
+      "closure_multiset_sha256": "f4ef144f5450601956c0fcc51afce5f698918bb6746251d12e830834eb7eda11"
+    },
+    {
+      "name": "pure_gluon_n8_first",
+      "process": "g g > g g g g g g",
+      "flow_cardinality": "5040",
+      "helicity_cardinality": "256",
+      "flow_rank": "0",
+      "helicity_rank": "0",
+      "current_count": 49,
+      "contribution_count": 176,
+      "closure_count": 1,
+      "peak_query_rows": 225,
+      "contribution_multiset_sha256": "79c27773475fa4543c10df44e3371f7abbd2a27f340196e4275a403fc13aba4a",
+      "closure_multiset_sha256": "e68bb34e7da958e3e45e9194c6691eef4a36d399a11d77da8c303411f5f54c85"
+    },
+    {
+      "name": "pure_gluon_n10_first",
+      "process": "g g > g g g g g g g g",
+      "flow_cardinality": "362880",
+      "helicity_cardinality": "1024",
+      "flow_rank": "0",
+      "helicity_rank": "0",
+      "current_count": 81,
+      "contribution_count": 400,
+      "closure_count": 1,
+      "peak_query_rows": 481,
+      "contribution_multiset_sha256": "d5fb390f78bb4050a03383b0198273ff56f10810d513cb28aa20153d4ff0d356",
+      "closure_multiset_sha256": "8a26d3b1e89796fe640a064d4d62aa6653149ed121b0ef380001dc6526197f18"
+    },
+    {
+      "name": "one_open_line_n7_first_nonzero",
+      "process": "u u~ > g g g g g",
+      "flow_cardinality": "120",
+      "helicity_cardinality": "128",
+      "flow_rank": "0",
+      "helicity_rank": "33",
+      "current_count": 31,
+      "contribution_count": 71,
+      "closure_count": 1,
+      "peak_query_rows": 102,
+      "contribution_multiset_sha256": "49644bb28ced5658e80a2a5262d8ce404d4b0fd3ccac4aaf8fef2c870b4036f6",
+      "closure_multiset_sha256": "4665272ed07d193d107400aaf17812f7c6ed861017468360b5d5d12b49c23d7a"
+    },
+    {
+      "name": "one_open_line_n8_first_nonzero",
+      "process": "u u~ > g g g g g g",
+      "flow_cardinality": "720",
+      "helicity_cardinality": "256",
+      "flow_rank": "0",
+      "helicity_rank": "65",
+      "current_count": 43,
+      "contribution_count": 126,
+      "closure_count": 1,
+      "peak_query_rows": 169,
+      "contribution_multiset_sha256": "b51c1dc874e9fea6feaffdfe941c0aef9b982e53dc337726776201481986b8c0",
+      "closure_multiset_sha256": "8b996826605c4f10387d838e0256bb03455f13fa65d0fc97966bdd0dbb5b5dc3"
+    },
+    {
+      "name": "one_open_line_n10_first_nonzero",
+      "process": "u u~ > g g g g g g g g",
+      "flow_cardinality": "40320",
+      "helicity_cardinality": "1024",
+      "flow_rank": "0",
+      "helicity_rank": "257",
+      "current_count": 73,
+      "contribution_count": 309,
+      "closure_count": 1,
+      "peak_query_rows": 382,
+      "contribution_multiset_sha256": "adf783e0ddfabbbd3e59befd84a938c5f79dff7aff8d68fb615338909d525202",
+      "closure_multiset_sha256": "ff80c07b33dd9675d2c6d5606e52a23db367403cc04da387e8fcf3ea6ffc47ad"
+    }
+  ],
+  "forbidden_global_boundaries": [
+    "build_color_plan",
+    "Generator._prepare_process_construction",
+    "project_recurrence_process_v1",
+    "build_recurrence_builder_input_v1",
+    "build_recurrence_physics",
+    "build_replay_targets",
+    "finish_program",
+    "DirectRecurrencePlan"
+  ]
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_full_v2.json b/pyamplicol/rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_full_v2.json
new file mode 100644
index 0000000000..17cb075afc
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_full_v2.json
@@ -0,0 +1 @@
+{"builder_input_abi":"pyamplicol-recurrence-builder-input-v2","color_accuracy":"full","direct_backend_abi":"rusticol.recurrence-direct-backend.v1","direct_template_abi":"pyamplicol-recurrence-direct-template-v1","direct_template_catalog_digest":"1b402620f9d8c1fadc6be4bc43d650483d46455b2ec14e6579c00296fab99809","external_pdg_order":[1,-1,23,23,23],"kernel_pack":{"manifest_path":"model/eager-kernel-pack.json","payload_root":"model/eager-kernels"},"key":"d_dbar_to_z_z_z","kind":"pyamplicol-runtime-recurrence-execution","plan":{"builder_input_abi":"pyamplicol-recurrence-builder-input-v2","builder_input_sha256":"65048ae46f9172f870675aa1eb87675724ab18430889af33b7074c14af888c10","direct_backend_abi":"rusticol.recurrence-direct-backend.v1","direct_template_abi":"pyamplicol-recurrence-direct-template-v1","direct_template_catalog_digest":"1b402620f9d8c1fadc6be4bc43d650483d46455b2ec14e6579c00296fab99809","inspection_summary":{"construction":{"candidate_parent_pair_count":2706,"color_target_prune_count":0,"peak_contribution_count":450,"peak_current_count":193,"peak_dynamic_color_state_count":3,"peak_to_final_contribution_ratio":1.0,"peak_to_final_current_ratio":1.0},"direct_arena":{"arena_component_reuse_count":62,"cache_footprint_policy":"persisted-arena-v1","current_arena_components":369,"momentum_form_count":16,"packed_input_bytes":0,"packed_output_bytes":0,"row_group_count":23,"scatter_bytes":0,"selector_domain_count":1,"semantic_component_count":431},"direct_executor_count":633,"direct_template_abi":"pyamplicol-recurrence-direct-template-v1","execution_mode":"recurrence","generation_timings_seconds":{"catalog_authentication":0.043677792,"direct_lowering":0.073076834,"native_total":0.163294333,"python_extraction":0.00234625,"semantic_construction":0.005414292,"serialization":0.018141},"lc_flow_layout":"contracted-color-union","parameter_count":10,"prepared_kernel_count":49,"process_id":"d_dbar_to_z_z_z","recurrence_plan_abi":"pyamplicol-recurrence-plan-v2","runtime_container_member":{"container_size_bytes":70408,"path":"schedule/recurrence-direct-schedule-v2.bin","sha256":"f44237c7a9cb769845e09e57e7e328378a406405ff10119accbbc69f689e03bd","size_bytes":70120},"runtime_layout_abi":"pyamplicol-recurrence-runtime-layout-v2","runtime_layout_digest":"3e1c95714566f6b8f3b5075985e63421acef8aadcbd0e1201b988cd744eba442","schedule":{"amplitude_destination_count":54,"closure_term_count":54,"contribution_count":450,"current_count":193,"exact_factor_count":6,"finalization_count":126,"replay_target_count":1,"resolved_helicity_count":54,"retained_helicity_count":108,"source_row_count":13},"schedule_digest":"2474ae81e1e9b2027db747967d1322398b02a79e230a366376b5b5a552c366d7","sector_count":1,"selector_work_certificate":{"binding":"runtime_layout_digest","persisted_union":{"closure_count":54,"contribution_count":450,"current_count":193,"finalization_count":126,"row_count":643,"semantic_component_count":431,"source_row_count":13},"representatives":[],"schema_version":1},"semantic_digest":"65048ae46f9172f870675aa1eb87675724ab18430889af33b7074c14af888c10"},"kind":"pyamplicol-runtime-recurrence-execution","prepared_kernel_pack_digest":"ddaa7c31f2361bda246b1310c8dca2e800a7237afd270249f86d5b549b557868","process_binding":{"abi":"pyamplicol-recurrence-process-binding-v2","path":"recurrence-binding.bin","process_id":"d_dbar_to_z_z_z","process_semantic_digest":"65048ae46f9172f870675aa1eb87675724ab18430889af33b7074c14af888c10","process_support_words":[1],"remap":{"bijection_digest":"7077a7b59abb4f7bdb3b99d5618068255325c57dde6c3489e82086c795234688","direct_executors":{"changes":[],"count":633},"parameter_slots":{"changes":[],"count":10},"physical_sector_ids":[0],"public_flow_ids":[0],"source_helicity_signs":[1,1,1,1,1],"source_momentum_signs":[1,1,1,1,1],"source_slots":[0,1,2,3,4],"source_state_indices":[0,1,0,1,0,1,2,0,1,2,0,1,2],"source_state_offsets":[0,2,4,7,10,13],"source_templates":{"changes":[],"count":62},"state_templates":{"changes":[],"count":82}},"schedule_digest":"2474ae81e1e9b2027db747967d1322398b02a79e230a366376b5b5a552c366d7","sha256":"9c25bcb1d2f12f12d0a4b877fa568dd16da47386f9bf5e630e9d4fee4e49448a","size_bytes":327},"recurrence_plan_abi":"pyamplicol-recurrence-plan-v2","required_runtime_capabilities":["rusticol.recurrence-color.contracted.v1","rusticol.recurrence-direct-arena.complex-f64.v1"],"runtime_layout_abi":"pyamplicol-recurrence-runtime-layout-v2","runtime_schedule":{"index_sha256":"ae108ebefad0a37d8886f336068b23a0d1999082ba94500e9f6d5f26c95e0889","kind":"pyamplicol-recurrence-runtime-container","member_count":1,"path":"recurrence/schedules/2474ae81e1e9b2027db747967d1322398b02a79e230a366376b5b5a552c366d7/recurrence-runtime.pacbin","plan_member_path":"schedule/recurrence-direct-schedule-v2.bin","schema_version":1,"sha256":"90fc08f26e9f3a936fa4b8bd51f72c393844b726e99d0377c97940cacc04a8c1","size_bytes":70408,"storage_abi":"pacbin-v1","unpacked_size_bytes":70120}},"prepared_kernel_pack_digest":"ddaa7c31f2361bda246b1310c8dca2e800a7237afd270249f86d5b549b557868","process":"d d~ > z z z","recurrence_plan_abi":"pyamplicol-recurrence-plan-v2","recurrence_summary":{"builder_input_abi":"pyamplicol-recurrence-builder-input-v2","closure_term_count":54,"contribution_count":450,"current_count":193,"lc_flow_layout":"contracted-color-union","template_input_abi":"pyamplicol-recurrence-template-input-v1"},"required_runtime_capabilities":["rusticol.recurrence-color.contracted.v1","rusticol.recurrence-direct-arena.complex-f64.v1"],"runtime_layout_abi":"pyamplicol-recurrence-runtime-layout-v2","runtime_metadata":{"color_contraction":{"abi":"pyamplicol-recurrence-color-contraction-v3","active_sector_count":1,"color_accuracy":"full","component_count":54,"destination_count":54,"entry_count":1,"factorization":null,"group_count":54,"includes_color_factor":true,"logical_entry_count":54,"materialized_destination_count":54,"path":"recurrence-color.bin","sector_count":1,"semantic_digest":"2ba9e3b1eef24758b866592eddf98589809b0bcf9ac641e94be49e6695b0dc1c","sha256":"2ba9e3b1eef24758b866592eddf98589809b0bcf9ac641e94be49e6695b0dc1c","size_bytes":1088,"storage":"repeated"},"external_legs":[{"is_initial":true,"outgoing_pdg":-1,"physical_pdg":1,"public_label":1,"source_slot":0},{"is_initial":true,"outgoing_pdg":1,"physical_pdg":-1,"public_label":2,"source_slot":1},{"is_initial":false,"outgoing_pdg":23,"physical_pdg":23,"public_label":3,"source_slot":2},{"is_initial":false,"outgoing_pdg":23,"physical_pdg":23,"public_label":4,"source_slot":3},{"is_initial":false,"outgoing_pdg":23,"physical_pdg":23,"public_label":5,"source_slot":4}],"normalization":{"average_factor":36,"color_accuracy":"full","color_factor":3,"coupling_policy":"stage evaluators include local vertex couplings","couplings_in_stage_evaluators":true,"electroweak_coupling_power":3,"global_coupling_factor":0.006823435874517697,"identical_factor":6,"qcd_coupling_power":0},"parameter_projection":[{"component":0,"parameter_template_id":0,"prepared_parameter_id":null,"runtime_name":"normalization.alpha_ew","runtime_slot":0},{"component":0,"parameter_template_id":7,"prepared_parameter_id":null,"runtime_name":"normalization.alpha_s_me_check","runtime_slot":1},{"component":0,"parameter_template_id":2,"prepared_parameter_id":0,"runtime_name":"particle.23.mass","runtime_slot":2},{"component":0,"parameter_template_id":1,"prepared_parameter_id":1,"runtime_name":"particle.23.width","runtime_slot":3},{"component":0,"parameter_template_id":9,"prepared_parameter_id":2,"runtime_name":"particle.24.mass","runtime_slot":4},{"component":0,"parameter_template_id":3,"prepared_parameter_id":3,"runtime_name":"particle.24.width","runtime_slot":5},{"component":0,"parameter_template_id":5,"prepared_parameter_id":4,"runtime_name":"particle.25.mass","runtime_slot":6},{"component":0,"parameter_template_id":6,"prepared_parameter_id":5,"runtime_name":"particle.25.width","runtime_slot":7},{"component":0,"parameter_template_id":8,"prepared_parameter_id":6,"runtime_name":"particle.6.mass","runtime_slot":8},{"component":0,"parameter_template_id":4,"prepared_parameter_id":7,"runtime_name":"particle.6.width","runtime_slot":9}],"particle_masses":[{"mass":0.0,"outgoing_pdg":-1},{"mass":0.0,"outgoing_pdg":1},{"mass":91.188,"outgoing_pdg":23}],"prepared_parameter_defaults":[[91.188,0.0],[2.441404,0.0],[80.41900244575616,0.0],[2.0476,0.0],[125.0,0.0],[0.006382339,0.0],[173.0,0.0],[1.4915,0.0],[0.0,0.0],[0.0,0.0]],"public_color_flows":[],"runtime_parameters":[{"complex_component":null,"default":0.0075467711139788835,"kind":"external","name":"normalization.alpha_ew","parameter_index":0,"runtime_name":null},{"complex_component":null,"default":0.118,"kind":"external","name":"normalization.alpha_s_me_check","parameter_index":1,"runtime_name":null},{"complex_component":null,"default":91.188,"kind":"external","name":"particle.23.mass","parameter_index":2,"runtime_name":null},{"complex_component":null,"default":2.441404,"kind":"external","name":"particle.23.width","parameter_index":3,"runtime_name":null},{"complex_component":null,"default":80.41900244575616,"kind":"external","name":"particle.24.mass","parameter_index":4,"runtime_name":null},{"complex_component":null,"default":2.0476,"kind":"external","name":"particle.24.width","parameter_index":5,"runtime_name":null},{"complex_component":null,"default":125.0,"kind":"external","name":"particle.25.mass","parameter_index":6,"runtime_name":null},{"complex_component":null,"default":0.006382339,"kind":"external","name":"particle.25.width","parameter_index":7,"runtime_name":null},{"complex_component":null,"default":173.0,"kind":"external","name":"particle.6.mass","parameter_index":8,"runtime_name":null},{"complex_component":null,"default":1.4915,"kind":"external","name":"particle.6.width","parameter_index":9,"runtime_name":null}],"source_templates":[{"chirality":0,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":57,"dimension":4,"helicity":-1,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":"particle.23.mass","states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":"particle.23.width"},"source_template_id":18,"spin_state":-1},{"chirality":1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":16,"dimension":2,"helicity":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":23,"spin_state":1},{"chirality":0,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":57,"dimension":4,"helicity":0,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":"particle.23.mass","states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":"particle.23.width"},"source_template_id":30,"spin_state":0},{"chirality":0,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":57,"dimension":4,"helicity":1,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":"particle.23.mass","states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":"particle.23.width"},"source_template_id":34,"spin_state":1},{"chirality":-1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":21,"dimension":2,"helicity":-1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":37,"spin_state":-1},{"chirality":1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":39,"dimension":2,"helicity":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":40,"spin_state":1},{"chirality":-1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":76,"dimension":2,"helicity":-1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":57,"spin_state":-1}]},"runtime_options":{"point_tile_size":1024,"workspace_mib":256},"schema_version":3}
diff --git a/pyamplicol/rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_lc.json b/pyamplicol/rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_lc.json
new file mode 100644
index 0000000000..09c0ea3b64
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_lc.json
@@ -0,0 +1 @@
+{"builder_input_abi":"pyamplicol-recurrence-builder-input-v2","color_accuracy":"lc","direct_backend_abi":"rusticol.recurrence-direct-backend.v1","direct_template_abi":"pyamplicol-recurrence-direct-template-v1","direct_template_catalog_digest":"c831e44d43cd88251e9a65233812063838cbcf749963e41abbe4e3cf667b5d16","external_pdg_order":[1,-1,23,23,23],"kernel_pack":{"manifest_path":"model/eager-kernel-pack.json","payload_root":"model/eager-kernels"},"key":"d_dbar_to_z_z_z","kind":"pyamplicol-runtime-recurrence-execution","plan":{"builder_input_abi":"pyamplicol-recurrence-builder-input-v2","builder_input_sha256":"9e5d6022436c86ce17f847d56a755b32854d2fe1234ceb8ee7868a9a90888d97","direct_backend_abi":"rusticol.recurrence-direct-backend.v1","direct_template_abi":"pyamplicol-recurrence-direct-template-v1","direct_template_catalog_digest":"c831e44d43cd88251e9a65233812063838cbcf749963e41abbe4e3cf667b5d16","inspection_summary":{"construction":{"candidate_parent_pair_count":2706,"color_target_prune_count":0,"peak_contribution_count":450,"peak_current_count":193,"peak_dynamic_color_state_count":3,"peak_to_final_contribution_ratio":1.0,"peak_to_final_current_ratio":1.0},"direct_arena":{"arena_component_reuse_count":62,"cache_footprint_policy":"selector-active-max-v1","current_arena_components":369,"momentum_form_count":16,"packed_input_bytes":0,"packed_output_bytes":0,"row_group_count":23,"scatter_bytes":0,"selector_domain_count":2,"semantic_component_count":431},"direct_executor_count":633,"direct_template_abi":"pyamplicol-recurrence-direct-template-v1","execution_mode":"recurrence","generation_timings_seconds":{"catalog_authentication":0.041804625,"direct_lowering":0.068728875,"native_total":0.153668125,"python_extraction":0.002089,"semantic_construction":0.005300625,"serialization":0.0152825},"lc_flow_layout":"topology-replay","parameter_count":10,"prepared_kernel_count":49,"process_id":"d_dbar_to_z_z_z","recurrence_plan_abi":"pyamplicol-recurrence-plan-v2","runtime_container_member":{"container_size_bytes":70408,"path":"schedule/recurrence-direct-schedule-v2.bin","sha256":"3451a0492abe65f5b8918fe816973891331b58f0f358191175c5dba2c8ad9629","size_bytes":70144},"runtime_layout_abi":"pyamplicol-recurrence-runtime-layout-v2","runtime_layout_digest":"f5ca63bfc81cc8d92b88f4df156798662bc562fb889a1005130cb180eaa4facc","schedule":{"amplitude_destination_count":54,"closure_term_count":54,"contribution_count":450,"current_count":193,"exact_factor_count":6,"finalization_count":126,"replay_target_count":1,"resolved_helicity_count":54,"retained_helicity_count":108,"source_row_count":13},"schedule_digest":"16aa32bc1d8c78321240b6fa2227fb2a8ee0832936d05aa6cdddfd0a067a6450","sector_count":1,"selector_work_certificate":{"binding":"runtime_layout_digest","persisted_union":{"closure_count":54,"contribution_count":450,"current_count":193,"finalization_count":126,"row_count":643,"semantic_component_count":431,"source_row_count":13},"representatives":[{"amplitude_destination_count":54,"closure_count":54,"contribution_count":450,"current_count":193,"finalization_count":126,"public_flow_count":1,"representative_sector_id":0,"row_count":643,"semantic_component_count":431,"source_row_count":13}],"schema_version":1},"semantic_digest":"9e5d6022436c86ce17f847d56a755b32854d2fe1234ceb8ee7868a9a90888d97"},"kind":"pyamplicol-runtime-recurrence-execution","prepared_kernel_pack_digest":"00f6903f11582717e1ddfab8a9a7d91de76acab0a7d47224a0c7ae362877b258","process_binding":{"abi":"pyamplicol-recurrence-process-binding-v2","path":"recurrence-binding.bin","process_id":"d_dbar_to_z_z_z","process_semantic_digest":"9e5d6022436c86ce17f847d56a755b32854d2fe1234ceb8ee7868a9a90888d97","process_support_words":[1],"remap":{"bijection_digest":"7077a7b59abb4f7bdb3b99d5618068255325c57dde6c3489e82086c795234688","direct_executors":{"changes":[],"count":633},"parameter_slots":{"changes":[],"count":10},"physical_sector_ids":[0],"public_flow_ids":[0],"source_helicity_signs":[1,1,1,1,1],"source_momentum_signs":[1,1,1,1,1],"source_slots":[0,1,2,3,4],"source_state_indices":[0,1,0,1,0,1,2,0,1,2,0,1,2],"source_state_offsets":[0,2,4,7,10,13],"source_templates":{"changes":[],"count":62},"state_templates":{"changes":[],"count":82}},"schedule_digest":"16aa32bc1d8c78321240b6fa2227fb2a8ee0832936d05aa6cdddfd0a067a6450","sha256":"d1e6e0877bee8f1310f641879ae65fd723db2cc399227aeb2f2d4a2c7cbfbde6","size_bytes":327},"recurrence_plan_abi":"pyamplicol-recurrence-plan-v2","required_runtime_capabilities":["rusticol.recurrence-color.lc.v1","rusticol.recurrence-direct-arena.complex-f64.v1"],"runtime_layout_abi":"pyamplicol-recurrence-runtime-layout-v2","runtime_schedule":{"index_sha256":"32f2fd79bf7abb2eba9779e53bac170de4bc57eda09f3bdcf7e16a3028b12ecb","kind":"pyamplicol-recurrence-runtime-container","member_count":1,"path":"recurrence/schedules/16aa32bc1d8c78321240b6fa2227fb2a8ee0832936d05aa6cdddfd0a067a6450/recurrence-runtime.pacbin","plan_member_path":"schedule/recurrence-direct-schedule-v2.bin","schema_version":1,"sha256":"55e2d17c9a91efd76b636835c93f750a2b7f33d803a244a5f27b30c7df7b1bf7","size_bytes":70408,"storage_abi":"pacbin-v1","unpacked_size_bytes":70144}},"prepared_kernel_pack_digest":"00f6903f11582717e1ddfab8a9a7d91de76acab0a7d47224a0c7ae362877b258","process":"d d~ > z z z","recurrence_plan_abi":"pyamplicol-recurrence-plan-v2","recurrence_summary":{"builder_input_abi":"pyamplicol-recurrence-builder-input-v2","closure_term_count":54,"contribution_count":450,"current_count":193,"lc_flow_layout":"topology-replay","template_input_abi":"pyamplicol-recurrence-template-input-v1"},"required_runtime_capabilities":["rusticol.recurrence-color.lc.v1","rusticol.recurrence-direct-arena.complex-f64.v1"],"runtime_layout_abi":"pyamplicol-recurrence-runtime-layout-v2","runtime_metadata":{"color_contraction":null,"external_legs":[{"is_initial":true,"outgoing_pdg":-1,"physical_pdg":1,"public_label":1,"source_slot":0},{"is_initial":true,"outgoing_pdg":1,"physical_pdg":-1,"public_label":2,"source_slot":1},{"is_initial":false,"outgoing_pdg":23,"physical_pdg":23,"public_label":3,"source_slot":2},{"is_initial":false,"outgoing_pdg":23,"physical_pdg":23,"public_label":4,"source_slot":3},{"is_initial":false,"outgoing_pdg":23,"physical_pdg":23,"public_label":5,"source_slot":4}],"normalization":{"average_factor":36,"color_accuracy":"lc","color_factor":3,"coupling_policy":"stage evaluators include local vertex couplings","couplings_in_stage_evaluators":true,"electroweak_coupling_power":3,"global_coupling_factor":0.006823435874517697,"identical_factor":6,"qcd_coupling_power":0},"parameter_projection":[{"component":0,"parameter_template_id":0,"prepared_parameter_id":null,"runtime_name":"normalization.alpha_ew","runtime_slot":0},{"component":0,"parameter_template_id":7,"prepared_parameter_id":null,"runtime_name":"normalization.alpha_s_me_check","runtime_slot":1},{"component":0,"parameter_template_id":2,"prepared_parameter_id":0,"runtime_name":"particle.23.mass","runtime_slot":2},{"component":0,"parameter_template_id":1,"prepared_parameter_id":1,"runtime_name":"particle.23.width","runtime_slot":3},{"component":0,"parameter_template_id":9,"prepared_parameter_id":2,"runtime_name":"particle.24.mass","runtime_slot":4},{"component":0,"parameter_template_id":3,"prepared_parameter_id":3,"runtime_name":"particle.24.width","runtime_slot":5},{"component":0,"parameter_template_id":5,"prepared_parameter_id":4,"runtime_name":"particle.25.mass","runtime_slot":6},{"component":0,"parameter_template_id":6,"prepared_parameter_id":5,"runtime_name":"particle.25.width","runtime_slot":7},{"component":0,"parameter_template_id":8,"prepared_parameter_id":6,"runtime_name":"particle.6.mass","runtime_slot":8},{"component":0,"parameter_template_id":4,"prepared_parameter_id":7,"runtime_name":"particle.6.width","runtime_slot":9}],"particle_masses":[{"mass":0.0,"outgoing_pdg":-1},{"mass":0.0,"outgoing_pdg":1},{"mass":91.188,"outgoing_pdg":23}],"prepared_parameter_defaults":[[91.188,0.0],[2.441404,0.0],[80.41900244575616,0.0],[2.0476,0.0],[125.0,0.0],[0.006382339,0.0],[173.0,0.0],[1.4915,0.0],[0.0,0.0],[0.0,0.0]],"public_color_flows":[{"construction_sector_id":0,"public_id":"flow:2,1","target_sector_id":0}],"runtime_parameters":[{"complex_component":null,"default":0.0075467711139788835,"kind":"external","name":"normalization.alpha_ew","parameter_index":0,"runtime_name":null},{"complex_component":null,"default":0.118,"kind":"external","name":"normalization.alpha_s_me_check","parameter_index":1,"runtime_name":null},{"complex_component":null,"default":91.188,"kind":"external","name":"particle.23.mass","parameter_index":2,"runtime_name":null},{"complex_component":null,"default":2.441404,"kind":"external","name":"particle.23.width","parameter_index":3,"runtime_name":null},{"complex_component":null,"default":80.41900244575616,"kind":"external","name":"particle.24.mass","parameter_index":4,"runtime_name":null},{"complex_component":null,"default":2.0476,"kind":"external","name":"particle.24.width","parameter_index":5,"runtime_name":null},{"complex_component":null,"default":125.0,"kind":"external","name":"particle.25.mass","parameter_index":6,"runtime_name":null},{"complex_component":null,"default":0.006382339,"kind":"external","name":"particle.25.width","parameter_index":7,"runtime_name":null},{"complex_component":null,"default":173.0,"kind":"external","name":"particle.6.mass","parameter_index":8,"runtime_name":null},{"complex_component":null,"default":1.4915,"kind":"external","name":"particle.6.width","parameter_index":9,"runtime_name":null}],"source_templates":[{"chirality":0,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":57,"dimension":4,"helicity":-1,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":"particle.23.mass","states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":"particle.23.width"},"source_template_id":18,"spin_state":-1},{"chirality":1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":16,"dimension":2,"helicity":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":23,"spin_state":1},{"chirality":0,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":57,"dimension":4,"helicity":0,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":"particle.23.mass","states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":"particle.23.width"},"source_template_id":30,"spin_state":0},{"chirality":0,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":57,"dimension":4,"helicity":1,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":"particle.23.mass","states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":"particle.23.width"},"source_template_id":34,"spin_state":1},{"chirality":-1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":21,"dimension":2,"helicity":-1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":37,"spin_state":-1},{"chirality":1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":39,"dimension":2,"helicity":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":40,"spin_state":1},{"chirality":-1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":76,"dimension":2,"helicity":-1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":57,"spin_state":-1}]},"runtime_options":{"point_tile_size":1024,"workspace_mib":256},"schema_version":3}
diff --git a/pyamplicol/rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_nlc.json b/pyamplicol/rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_nlc.json
new file mode 100644
index 0000000000..85f912cb98
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_nlc.json
@@ -0,0 +1 @@
+{"builder_input_abi":"pyamplicol-recurrence-builder-input-v2","color_accuracy":"nlc","direct_backend_abi":"rusticol.recurrence-direct-backend.v1","direct_template_abi":"pyamplicol-recurrence-direct-template-v1","direct_template_catalog_digest":"c831e44d43cd88251e9a65233812063838cbcf749963e41abbe4e3cf667b5d16","external_pdg_order":[1,-1,23,23,23],"kernel_pack":{"manifest_path":"model/eager-kernel-pack.json","payload_root":"model/eager-kernels"},"key":"d_dbar_to_z_z_z","kind":"pyamplicol-runtime-recurrence-execution","plan":{"builder_input_abi":"pyamplicol-recurrence-builder-input-v2","builder_input_sha256":"6277cdfb8b170b27c6a6b28779fa607911610db924bf8a8b03d0b51060bb3633","direct_backend_abi":"rusticol.recurrence-direct-backend.v1","direct_template_abi":"pyamplicol-recurrence-direct-template-v1","direct_template_catalog_digest":"c831e44d43cd88251e9a65233812063838cbcf749963e41abbe4e3cf667b5d16","inspection_summary":{"construction":{"candidate_parent_pair_count":2706,"color_target_prune_count":0,"peak_contribution_count":450,"peak_current_count":193,"peak_dynamic_color_state_count":3,"peak_to_final_contribution_ratio":1.0,"peak_to_final_current_ratio":1.0},"direct_arena":{"arena_component_reuse_count":62,"cache_footprint_policy":"persisted-arena-v1","current_arena_components":369,"momentum_form_count":16,"packed_input_bytes":0,"packed_output_bytes":0,"row_group_count":23,"scatter_bytes":0,"selector_domain_count":1,"semantic_component_count":431},"direct_executor_count":633,"direct_template_abi":"pyamplicol-recurrence-direct-template-v1","execution_mode":"recurrence","generation_timings_seconds":{"catalog_authentication":0.075438833,"direct_lowering":0.074224625,"native_total":0.191393333,"python_extraction":0.012225667,"semantic_construction":0.005605333,"serialization":0.011755792},"lc_flow_layout":"contracted-color-union","parameter_count":10,"prepared_kernel_count":49,"process_id":"d_dbar_to_z_z_z","recurrence_plan_abi":"pyamplicol-recurrence-plan-v2","runtime_container_member":{"container_size_bytes":70408,"path":"schedule/recurrence-direct-schedule-v2.bin","sha256":"358acb674cefc1570146eb361bcaf42516c3045f91575327fa8e1b344fd3b6b0","size_bytes":70120},"runtime_layout_abi":"pyamplicol-recurrence-runtime-layout-v2","runtime_layout_digest":"a2fc04dc7b94e806af1fa14bdd26e0b61db13ef3d3e349e81b2c64faa5344abb","schedule":{"amplitude_destination_count":54,"closure_term_count":54,"contribution_count":450,"current_count":193,"exact_factor_count":6,"finalization_count":126,"replay_target_count":1,"resolved_helicity_count":54,"retained_helicity_count":108,"source_row_count":13},"schedule_digest":"32acf60fc25819dee96f7c64c5857baa63a18b9e1dd52ebe4ff674696bc158c7","sector_count":1,"selector_work_certificate":{"binding":"runtime_layout_digest","persisted_union":{"closure_count":54,"contribution_count":450,"current_count":193,"finalization_count":126,"row_count":643,"semantic_component_count":431,"source_row_count":13},"representatives":[],"schema_version":1},"semantic_digest":"6277cdfb8b170b27c6a6b28779fa607911610db924bf8a8b03d0b51060bb3633"},"kind":"pyamplicol-runtime-recurrence-execution","prepared_kernel_pack_digest":"00f6903f11582717e1ddfab8a9a7d91de76acab0a7d47224a0c7ae362877b258","process_binding":{"abi":"pyamplicol-recurrence-process-binding-v2","path":"recurrence-binding.bin","process_id":"d_dbar_to_z_z_z","process_semantic_digest":"6277cdfb8b170b27c6a6b28779fa607911610db924bf8a8b03d0b51060bb3633","process_support_words":[1],"remap":{"bijection_digest":"7077a7b59abb4f7bdb3b99d5618068255325c57dde6c3489e82086c795234688","direct_executors":{"changes":[],"count":633},"parameter_slots":{"changes":[],"count":10},"physical_sector_ids":[0],"public_flow_ids":[0],"source_helicity_signs":[1,1,1,1,1],"source_momentum_signs":[1,1,1,1,1],"source_slots":[0,1,2,3,4],"source_state_indices":[0,1,0,1,0,1,2,0,1,2,0,1,2],"source_state_offsets":[0,2,4,7,10,13],"source_templates":{"changes":[],"count":62},"state_templates":{"changes":[],"count":82}},"schedule_digest":"32acf60fc25819dee96f7c64c5857baa63a18b9e1dd52ebe4ff674696bc158c7","sha256":"bf1e043fd2cf9ec7565d4eb9a271c92fc07a94c8c9cba445484ac7778d81d276","size_bytes":327},"recurrence_plan_abi":"pyamplicol-recurrence-plan-v2","required_runtime_capabilities":["rusticol.recurrence-color.contracted.v1","rusticol.recurrence-direct-arena.complex-f64.v1"],"runtime_layout_abi":"pyamplicol-recurrence-runtime-layout-v2","runtime_schedule":{"index_sha256":"dab93f5cebe469bdb92fa6d218c045d1aca114e1f4bf08430f0aa52f1b0b2084","kind":"pyamplicol-recurrence-runtime-container","member_count":1,"path":"recurrence/schedules/32acf60fc25819dee96f7c64c5857baa63a18b9e1dd52ebe4ff674696bc158c7/recurrence-runtime.pacbin","plan_member_path":"schedule/recurrence-direct-schedule-v2.bin","schema_version":1,"sha256":"a19e79e209ad12c355639f6abed502b87cab311c0151627437b1cbe1ecf5d58c","size_bytes":70408,"storage_abi":"pacbin-v1","unpacked_size_bytes":70120}},"prepared_kernel_pack_digest":"00f6903f11582717e1ddfab8a9a7d91de76acab0a7d47224a0c7ae362877b258","process":"d d~ > z z z","recurrence_plan_abi":"pyamplicol-recurrence-plan-v2","recurrence_summary":{"builder_input_abi":"pyamplicol-recurrence-builder-input-v2","closure_term_count":54,"contribution_count":450,"current_count":193,"lc_flow_layout":"contracted-color-union","template_input_abi":"pyamplicol-recurrence-template-input-v1"},"required_runtime_capabilities":["rusticol.recurrence-color.contracted.v1","rusticol.recurrence-direct-arena.complex-f64.v1"],"runtime_layout_abi":"pyamplicol-recurrence-runtime-layout-v2","runtime_metadata":{"color_contraction":{"abi":"pyamplicol-recurrence-color-contraction-v3","active_sector_count":1,"color_accuracy":"nlc","component_count":54,"destination_count":54,"entry_count":1,"factorization":null,"group_count":54,"includes_color_factor":true,"logical_entry_count":54,"materialized_destination_count":54,"path":"recurrence-color.bin","sector_count":1,"semantic_digest":"fdf22dd8291d038eec5c0a115c6b18bfaca6bf77eb80eeb301425960a98ed027","sha256":"fdf22dd8291d038eec5c0a115c6b18bfaca6bf77eb80eeb301425960a98ed027","size_bytes":1088,"storage":"repeated"},"external_legs":[{"is_initial":true,"outgoing_pdg":-1,"physical_pdg":1,"public_label":1,"source_slot":0},{"is_initial":true,"outgoing_pdg":1,"physical_pdg":-1,"public_label":2,"source_slot":1},{"is_initial":false,"outgoing_pdg":23,"physical_pdg":23,"public_label":3,"source_slot":2},{"is_initial":false,"outgoing_pdg":23,"physical_pdg":23,"public_label":4,"source_slot":3},{"is_initial":false,"outgoing_pdg":23,"physical_pdg":23,"public_label":5,"source_slot":4}],"normalization":{"average_factor":36,"color_accuracy":"nlc","color_factor":3,"coupling_policy":"stage evaluators include local vertex couplings","couplings_in_stage_evaluators":true,"electroweak_coupling_power":3,"global_coupling_factor":0.006823435874517697,"identical_factor":6,"qcd_coupling_power":0},"parameter_projection":[{"component":0,"parameter_template_id":0,"prepared_parameter_id":null,"runtime_name":"normalization.alpha_ew","runtime_slot":0},{"component":0,"parameter_template_id":7,"prepared_parameter_id":null,"runtime_name":"normalization.alpha_s_me_check","runtime_slot":1},{"component":0,"parameter_template_id":2,"prepared_parameter_id":0,"runtime_name":"particle.23.mass","runtime_slot":2},{"component":0,"parameter_template_id":1,"prepared_parameter_id":1,"runtime_name":"particle.23.width","runtime_slot":3},{"component":0,"parameter_template_id":9,"prepared_parameter_id":2,"runtime_name":"particle.24.mass","runtime_slot":4},{"component":0,"parameter_template_id":3,"prepared_parameter_id":3,"runtime_name":"particle.24.width","runtime_slot":5},{"component":0,"parameter_template_id":5,"prepared_parameter_id":4,"runtime_name":"particle.25.mass","runtime_slot":6},{"component":0,"parameter_template_id":6,"prepared_parameter_id":5,"runtime_name":"particle.25.width","runtime_slot":7},{"component":0,"parameter_template_id":8,"prepared_parameter_id":6,"runtime_name":"particle.6.mass","runtime_slot":8},{"component":0,"parameter_template_id":4,"prepared_parameter_id":7,"runtime_name":"particle.6.width","runtime_slot":9}],"particle_masses":[{"mass":0.0,"outgoing_pdg":-1},{"mass":0.0,"outgoing_pdg":1},{"mass":91.188,"outgoing_pdg":23}],"prepared_parameter_defaults":[[91.188,0.0],[2.441404,0.0],[80.41900244575616,0.0],[2.0476,0.0],[125.0,0.0],[0.006382339,0.0],[173.0,0.0],[1.4915,0.0],[0.0,0.0],[0.0,0.0]],"public_color_flows":[],"runtime_parameters":[{"complex_component":null,"default":0.0075467711139788835,"kind":"external","name":"normalization.alpha_ew","parameter_index":0,"runtime_name":null},{"complex_component":null,"default":0.118,"kind":"external","name":"normalization.alpha_s_me_check","parameter_index":1,"runtime_name":null},{"complex_component":null,"default":91.188,"kind":"external","name":"particle.23.mass","parameter_index":2,"runtime_name":null},{"complex_component":null,"default":2.441404,"kind":"external","name":"particle.23.width","parameter_index":3,"runtime_name":null},{"complex_component":null,"default":80.41900244575616,"kind":"external","name":"particle.24.mass","parameter_index":4,"runtime_name":null},{"complex_component":null,"default":2.0476,"kind":"external","name":"particle.24.width","parameter_index":5,"runtime_name":null},{"complex_component":null,"default":125.0,"kind":"external","name":"particle.25.mass","parameter_index":6,"runtime_name":null},{"complex_component":null,"default":0.006382339,"kind":"external","name":"particle.25.width","parameter_index":7,"runtime_name":null},{"complex_component":null,"default":173.0,"kind":"external","name":"particle.6.mass","parameter_index":8,"runtime_name":null},{"complex_component":null,"default":1.4915,"kind":"external","name":"particle.6.width","parameter_index":9,"runtime_name":null}],"source_templates":[{"chirality":0,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":57,"dimension":4,"helicity":-1,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":"particle.23.mass","states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":"particle.23.width"},"source_template_id":18,"spin_state":-1},{"chirality":1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":16,"dimension":2,"helicity":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":23,"spin_state":1},{"chirality":0,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":57,"dimension":4,"helicity":0,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":"particle.23.mass","states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":"particle.23.width"},"source_template_id":30,"spin_state":0},{"chirality":0,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":57,"dimension":4,"helicity":1,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":"particle.23.mass","states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":"particle.23.width"},"source_template_id":34,"spin_state":1},{"chirality":-1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":21,"dimension":2,"helicity":-1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":37,"spin_state":-1},{"chirality":1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":39,"dimension":2,"helicity":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":40,"spin_state":1},{"chirality":-1,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"current_state_template_id":76,"dimension":2,"helicity":-1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_template_id":57,"spin_state":-1}]},"runtime_options":{"point_tile_size":1024,"workspace_mib":256},"schema_version":3}
diff --git a/pyamplicol/rust/crates/rusticol-core/tests/generated_artifact_odd_tails.rs b/pyamplicol/rust/crates/rusticol-core/tests/generated_artifact_odd_tails.rs
new file mode 100644
index 0000000000..fbfbcfa4bb
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/tests/generated_artifact_odd_tails.rs
@@ -0,0 +1,860 @@
+// SPDX-License-Identifier: 0BSD
+
+#![cfg(all(feature = "f64-symjit", any(target_os = "linux", target_os = "macos")))]
+
+use rusticol_core::{NativeResolvedEvaluation, NativeRuntime, NativeRuntimeProfile, RusticolError};
+use std::alloc::{GlobalAlloc, Layout, System};
+use std::cell::Cell;
+use std::fs;
+use std::path::PathBuf;
+
+const ODD_TAIL_POINT_COUNTS: [usize; 4] = [127, 129, 1023, 1025];
+const PROFILE_REPETITIONS: usize = 2;
+const EXPECTED_PROCESS: &str = "d d~ > z g g g g g g";
+const EXPECTED_EXTERNAL_PDGS: [i32; 9] = [1, -1, 23, 21, 21, 21, 21, 21, 21];
+const INPUT_PREFIX_CANARY_BITS: u64 = 0x3fd1_2345_6789_abcd;
+const INPUT_SUFFIX_CANARY_BITS: u64 = 0xbfc9_8765_4321_0fed;
+const OUTPUT_PREFIX_CANARY_BITS: u64 = 0x4023_4567_89ab_cdef;
+const OUTPUT_SUFFIX_CANARY_BITS: u64 = 0xc013_579b_dfb7_5311;
+
+thread_local! {
+    static TRACK_ALLOCATIONS: Cell<bool> = const { Cell::new(false) };
+    static ALLOCATION_COUNT: Cell<usize> = const { Cell::new(0) };
+    static ALLOCATED_BYTES: Cell<usize> = const { Cell::new(0) };
+}
+
+struct CountingAllocator;
+
+#[global_allocator]
+static GLOBAL_ALLOCATOR: CountingAllocator = CountingAllocator;
+
+unsafe impl GlobalAlloc for CountingAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        count_allocation(layout.size());
+        unsafe { System.alloc(layout) }
+    }
+
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        count_allocation(layout.size());
+        unsafe { System.alloc_zeroed(layout) }
+    }
+
+    unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        count_allocation(new_size);
+        unsafe { System.realloc(pointer, layout, new_size) }
+    }
+
+    unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+        unsafe { System.dealloc(pointer, layout) }
+    }
+}
+
+fn count_allocation(bytes: usize) {
+    if TRACK_ALLOCATIONS.try_with(Cell::get).unwrap_or(false) {
+        let _ = ALLOCATION_COUNT.try_with(|count| count.set(count.get() + 1));
+        let _ = ALLOCATED_BYTES.try_with(|total| total.set(total.get().saturating_add(bytes)));
+    }
+}
+
+fn count_allocations<T>(function: impl FnOnce() -> T) -> (T, usize, usize) {
+    ALLOCATION_COUNT.with(|count| count.set(0));
+    ALLOCATED_BYTES.with(|total| total.set(0));
+    TRACK_ALLOCATIONS.with(|tracking| tracking.set(true));
+    let result = function();
+    TRACK_ALLOCATIONS.with(|tracking| tracking.set(false));
+    let count = ALLOCATION_COUNT.with(Cell::get);
+    let bytes = ALLOCATED_BYTES.with(Cell::get);
+    (result, count, bytes)
+}
+
+#[derive(Clone, Copy)]
+enum ProfileLane {
+    Compiled,
+    Eager,
+    RecurrenceTopology,
+    RecurrenceUnion,
+}
+
+fn guarded_values(values: &[f64], prefix_bits: u64, suffix_bits: u64) -> Vec<f64> {
+    let mut guarded = Vec::with_capacity(values.len() + 2);
+    guarded.push(f64::from_bits(prefix_bits));
+    guarded.extend_from_slice(values);
+    guarded.push(f64::from_bits(suffix_bits));
+    guarded
+}
+
+fn assert_guard_canaries(
+    guarded: &[f64],
+    logical_len: usize,
+    prefix_bits: u64,
+    suffix_bits: u64,
+    context: &str,
+) {
+    assert_eq!(
+        guarded.len(),
+        logical_len + 2,
+        "{context}: malformed guarded buffer"
+    );
+    assert_eq!(
+        guarded[0].to_bits(),
+        prefix_bits,
+        "{context}: prefix canary changed"
+    );
+    assert_eq!(
+        guarded[logical_len + 1].to_bits(),
+        suffix_bits,
+        "{context}: suffix canary changed"
+    );
+}
+
+fn fixture_path(environment_name: &str) -> Option<PathBuf> {
+    let Some(path) = std::env::var_os(environment_name) else {
+        eprintln!("skipping genuine odd-tail gate: {environment_name} is not set");
+        return None;
+    };
+    let path = PathBuf::from(path);
+    assert!(
+        path.is_dir(),
+        "{environment_name} does not name an artifact directory: {}",
+        path.display()
+    );
+    Some(path)
+}
+
+fn validation_momenta(runtime: &NativeRuntime) -> Vec<f64> {
+    let metadata = runtime.metadata();
+    let path = runtime
+        .root()
+        .join("processes")
+        .join(&metadata.representative_process_key)
+        .join("validation-momenta.json");
+    let payload: serde_json::Value =
+        serde_json::from_slice(&fs::read(&path).unwrap_or_else(|error| {
+            panic!(
+                "could not read genuine odd-tail validation momenta {}: {error}",
+                path.display()
+            )
+        }))
+        .unwrap_or_else(|error| {
+            panic!(
+                "could not parse genuine odd-tail validation momenta {}: {error}",
+                path.display()
+            )
+        });
+    let point = payload["points"][0]
+        .as_array()
+        .expect("genuine odd-tail fixture must contain one validation point");
+    assert_eq!(
+        point.len(),
+        metadata.external_count,
+        "genuine odd-tail validation point has the wrong external multiplicity"
+    );
+    point
+        .iter()
+        .flat_map(|leg| {
+            leg["momentum"]
+                .as_array()
+                .expect("validation leg must contain four momentum components")
+                .iter()
+                .map(|component| {
+                    component
+                        .as_str()
+                        .map(str::parse::<f64>)
+                        .transpose()
+                        .expect("validation momentum string must be binary64")
+                        .or_else(|| component.as_f64())
+                        .expect("validation momentum component must be numeric")
+                })
+        })
+        .collect()
+}
+
+fn assert_close(actual: f64, expected: f64, context: &str) {
+    let tolerance = 1.0e-15 + 1.0e-12 * expected.abs();
+    assert!(
+        (actual - expected).abs() <= tolerance,
+        "{context}: {actual:.17e} != {expected:.17e} (tolerance {tolerance:.3e})"
+    );
+}
+
+fn alternating_helicity_references(
+    runtime: &mut NativeRuntime,
+    point: &[f64],
+    resolved: &NativeResolvedEvaluation,
+) -> [(u32, f64); 2] {
+    let helicities = runtime
+        .helicities()
+        .expect("load genuine odd-tail helicity metadata");
+    let color_count = resolved.color_ids.len();
+    assert!(
+        color_count > 0,
+        "genuine odd-tail resolved reference has no color components"
+    );
+    assert_eq!(
+        resolved.values.len(),
+        resolved.helicity_ids.len() * color_count,
+        "genuine odd-tail one-point resolved shape"
+    );
+
+    let mut candidates = Vec::new();
+    for (resolved_index, helicity_id) in resolved.helicity_ids.iter().enumerate() {
+        let Some(helicity) = helicities.iter().find(|item| &item.id == helicity_id) else {
+            panic!("resolved helicity {helicity_id:?} is absent from runtime metadata");
+        };
+        if helicity.structural_zero {
+            continue;
+        }
+        let start = resolved_index * color_count;
+        let expected = resolved.values[start..start + color_count]
+            .iter()
+            .copied()
+            .sum::<f64>();
+        if !expected.is_finite() || expected == 0.0 {
+            continue;
+        }
+        candidates.push((
+            u32::try_from(helicity.index)
+                .expect("genuine odd-tail helicity index does not fit u32"),
+            expected,
+            helicity.id.clone(),
+        ));
+    }
+
+    let mut selected_pair = None;
+    'pairs: for (left_index, left) in candidates.iter().enumerate() {
+        for right in candidates.iter().skip(left_index + 1) {
+            let scale = left.1.abs().max(right.1.abs());
+            let separation = (left.1 - right.1).abs();
+            if separation > 64.0 * (1.0e-15 + 1.0e-12 * scale) {
+                selected_pair = Some([left.clone(), right.clone()]);
+                break 'pairs;
+            }
+        }
+    }
+    let selected_pair = selected_pair.unwrap_or_else(|| {
+        panic!(concat!(
+            "genuine odd-tail fixture has no two finite nonzero, numerically ",
+            "distinguishable helicity references"
+        ))
+    });
+
+    let mut verified = Vec::with_capacity(2);
+    for (index, expected, helicity_id) in selected_pair {
+        let selector = [helicity_id.clone()];
+        let selected = runtime
+            .evaluate_f64_with_selectors(point, 1, Some(&selector), None, None, None)
+            .unwrap_or_else(|error| {
+                panic!(
+                    "evaluate genuine odd-tail scalar helicity reference {:?}: {error}",
+                    helicity_id
+                )
+            })[0];
+        assert_close(
+            selected,
+            expected,
+            &format!(
+                "genuine odd-tail selected/resolved helicity parity {:?}",
+                helicity_id
+            ),
+        );
+        verified.push((index, selected));
+    }
+    verified
+        .try_into()
+        .expect("genuine odd-tail helicity reference pair")
+}
+
+fn assert_recurrence_layout(runtime: &NativeRuntime, expected_layout: &str) {
+    let metadata = runtime.metadata();
+    let path = runtime
+        .root()
+        .join("processes")
+        .join(&metadata.representative_process_key)
+        .join("execution.json");
+    let execution: serde_json::Value =
+        serde_json::from_slice(&fs::read(&path).unwrap_or_else(|error| {
+            panic!(
+                "could not read genuine odd-tail execution manifest {}: {error}",
+                path.display()
+            )
+        }))
+        .unwrap_or_else(|error| {
+            panic!(
+                "could not parse genuine odd-tail execution manifest {}: {error}",
+                path.display()
+            )
+        });
+    assert_eq!(
+        execution["recurrence_summary"]["lc_flow_layout"].as_str(),
+        Some(expected_layout),
+        "genuine odd-tail recurrence fixture has the wrong LC layout"
+    );
+}
+
+fn assert_jit_optimization_level(runtime: &NativeRuntime, expected_level: u32) {
+    let path = runtime.root().join("config").join("effective.toml");
+    let contents = fs::read_to_string(&path).unwrap_or_else(|error| {
+        panic!(
+            "could not read genuine odd-tail effective configuration {}: {error}",
+            path.display()
+        )
+    });
+    let mut section = "";
+    let mut observed_backend = None;
+    let mut observed_level = None;
+    for line in contents.lines().map(str::trim) {
+        if line.starts_with('[') {
+            section = line;
+            continue;
+        }
+        let Some((name, value)) = line.split_once('=') else {
+            continue;
+        };
+        match (section, name.trim()) {
+            ("[evaluator]", "backend") => {
+                observed_backend = Some(value.trim().trim_matches('"').to_string());
+            }
+            ("[evaluator.jit]", "optimization_level") => {
+                observed_level = Some(
+                    value
+                        .trim()
+                        .parse::<u32>()
+                        .expect("JIT optimization level must be an unsigned integer"),
+                );
+            }
+            _ => {}
+        }
+    }
+    assert_eq!(
+        observed_backend.as_deref(),
+        Some("jit"),
+        "genuine odd-tail fixture does not use the JIT evaluator backend"
+    );
+    assert_eq!(
+        observed_level,
+        Some(expected_level),
+        "genuine odd-tail fixture has the wrong JIT optimization level"
+    );
+}
+
+fn assert_zero_legacy_boundary_counters(profile: &NativeRuntimeProfile, context: &str) {
+    // These are the legacy stage/amplitude and selector boundary adapters.
+    // Eager DirectTable gather/fanout and P-kernel scratch traffic are internal
+    // arena traffic and deliberately have separate attribution.
+    for (label, observed) in [
+        (
+            "stage input copies",
+            profile.stage_input_copy_component_count,
+        ),
+        (
+            "stage leaf input copies",
+            profile.stage_leaf_input_copy_component_count,
+        ),
+        (
+            "stage evaluator output gathers",
+            profile.stage_evaluator_output_gather_component_count,
+        ),
+        (
+            "stage output assignments",
+            profile.stage_output_assign_component_count,
+        ),
+        (
+            "amplitude input copies",
+            profile.amplitude_input_copy_component_count,
+        ),
+        (
+            "amplitude leaf input copies",
+            profile.amplitude_leaf_input_copy_component_count,
+        ),
+        (
+            "amplitude evaluator output gathers",
+            profile.amplitude_evaluator_output_gather_component_count,
+        ),
+        (
+            "amplitude output remaps",
+            profile.amplitude_output_remap_component_count,
+        ),
+        (
+            "selector gather points",
+            profile.selector_gather_point_count,
+        ),
+        ("selector gather bytes", profile.selector_gather_bytes),
+        (
+            "selector scatter values",
+            profile.selector_scatter_value_count,
+        ),
+    ] {
+        assert_eq!(observed, 0, "{context}: {label}");
+    }
+}
+
+fn assert_zero_exposed_boundary_traffic(
+    profile: &NativeRuntimeProfile,
+    lane: ProfileLane,
+    measured_input_components: u64,
+    context: &str,
+) {
+    assert_eq!(
+        profile.native_input_component_count, measured_input_components,
+        "{context}: profiled input component count"
+    );
+    assert_eq!(
+        profile.native_input_pack_bytes, 0,
+        "{context}: native input packing traffic"
+    );
+    assert_eq!(
+        profile.native_input_crossing_bytes, 0,
+        "{context}: native input crossing traffic"
+    );
+    assert_eq!(
+        profile.native_input_container_allocation_count, 0,
+        "{context}: native input container allocations"
+    );
+    assert_eq!(
+        profile.native_output_allocation_count, 0,
+        "{context}: native output allocations"
+    );
+    assert_eq!(
+        profile.observed_scratch_reallocation_count, 0,
+        "{context}: warmed scratch reallocations"
+    );
+    assert_zero_legacy_boundary_counters(profile, context);
+
+    match lane {
+        ProfileLane::Compiled => {
+            assert!(
+                profile.compiled_direct_arena_engine_count > 0,
+                "{context}: compiled profile did not authenticate an Arena engine"
+            );
+            assert!(
+                profile.compiled_direct_arena_call_count > 0,
+                "{context}: compiled profile observed no Arena calls"
+            );
+            assert_eq!(
+                profile.compiled_direct_arena_boundary_input_bytes, 0,
+                "{context}: compiled arena input boundary traffic"
+            );
+            assert_eq!(
+                profile.compiled_direct_arena_boundary_current_output_bytes, 0,
+                "{context}: compiled arena current-output boundary traffic"
+            );
+            assert_eq!(
+                profile.compiled_direct_arena_boundary_amplitude_output_bytes, 0,
+                "{context}: compiled arena amplitude-output boundary traffic"
+            );
+        }
+        ProfileLane::Eager => {
+            assert_eq!(
+                profile.compiled_direct_arena_engine_count, 0,
+                "{context}: eager profile reported a compiled Arena engine"
+            );
+        }
+        ProfileLane::RecurrenceTopology | ProfileLane::RecurrenceUnion => {
+            panic!("{context}: recurrence must not request the eager/compiled Arena profile")
+        }
+    }
+}
+
+fn assert_lane_activity_profile(runtime: &mut NativeRuntime, point: &[f64], lane: ProfileLane) {
+    if matches!(lane, ProfileLane::Compiled) {
+        return;
+    }
+    let point_count = *ODD_TAIL_POINT_COUNTS
+        .last()
+        .expect("genuine odd-tail point-count inventory");
+    let momenta = point.repeat(point_count);
+    let profiled = runtime
+        .evaluate_f64_profile_repeated(&momenta, point_count, 1, None, None)
+        .expect("profile genuine odd-tail lane activity");
+    let profile = &profiled.profile;
+    assert_eq!(
+        profile.observed_scratch_reallocation_count, 0,
+        "genuine odd-tail lane activity profile reallocated warmed scratch"
+    );
+    assert_zero_legacy_boundary_counters(profile, "genuine odd-tail lane activity");
+
+    match lane {
+        ProfileLane::Compiled => unreachable!("compiled lane returned above"),
+        ProfileLane::Eager => {
+            assert!(
+                profile.evaluator_backend_call_count > 0,
+                "genuine eager odd-tail profile observed no JIT backend calls"
+            );
+        }
+        ProfileLane::RecurrenceTopology => {
+            assert!(
+                profile.recurrence_schedule_execution_count > 0,
+                "genuine topology odd-tail profile observed no recurrence schedule"
+            );
+            assert!(
+                profile.recurrence_replay_schedule_execution_count > 0,
+                "genuine topology odd-tail profile observed no replay schedule"
+            );
+            assert_eq!(
+                profile.recurrence_union_schedule_execution_count, 0,
+                "genuine topology odd-tail profile unexpectedly used a union schedule"
+            );
+            assert!(
+                profile.recurrence_replay_output_value_count > 0,
+                "genuine topology odd-tail profile observed no replay outputs"
+            );
+            assert!(
+                profile.recurrence_source_call_count > 0
+                    && profile.recurrence_contribution_call_count > 0,
+                "genuine topology odd-tail profile did not execute source and contribution kernels"
+            );
+        }
+        ProfileLane::RecurrenceUnion => {
+            assert!(
+                profile.recurrence_schedule_execution_count > 0,
+                "genuine union odd-tail profile observed no recurrence schedule"
+            );
+            assert!(
+                profile.recurrence_union_schedule_execution_count > 0,
+                "genuine union odd-tail profile observed no union schedule"
+            );
+            assert_eq!(
+                profile.recurrence_replay_schedule_execution_count, 0,
+                "genuine union odd-tail profile unexpectedly used a replay schedule"
+            );
+            assert!(
+                profile.recurrence_union_source_row_count > 0,
+                "genuine union odd-tail profile observed no union source rows"
+            );
+            assert!(
+                profile.recurrence_contribution_call_count > 0,
+                "genuine union odd-tail profile did not execute contribution kernels"
+            );
+        }
+    }
+}
+
+fn prove_genuine_odd_tails(
+    artifact: PathBuf,
+    expected_execution_mode: &str,
+    expected_jit_optimization_level: u32,
+    recurrence_layout: Option<&str>,
+    profile_lane: ProfileLane,
+) {
+    let mut runtime =
+        NativeRuntime::load(&artifact, None, None).expect("load genuine odd-tail artifact");
+    let metadata = runtime.metadata();
+    assert_eq!(
+        metadata.execution_mode, expected_execution_mode,
+        "genuine odd-tail fixture has the wrong execution mode"
+    );
+    assert_eq!(
+        metadata.process, EXPECTED_PROCESS,
+        "genuine odd-tail fixture has the wrong process"
+    );
+    assert_eq!(
+        metadata.external_pdg_order, EXPECTED_EXTERNAL_PDGS,
+        "genuine odd-tail fixture has the wrong external PDG ordering"
+    );
+    assert!(
+        metadata.current_count > 0 && metadata.interaction_count > 0,
+        "genuine odd-tail fixture does not contain a generated current DAG"
+    );
+    match profile_lane {
+        ProfileLane::Compiled => assert_eq!(
+            metadata.prepared_backend, None,
+            "genuine compiled odd-tail fixture unexpectedly reports a prepared backend"
+        ),
+        ProfileLane::Eager | ProfileLane::RecurrenceTopology | ProfileLane::RecurrenceUnion => {
+            assert_eq!(
+                metadata.prepared_backend.as_deref(),
+                Some("jit"),
+                "genuine prepared odd-tail fixture does not use the JIT backend"
+            )
+        }
+    }
+    assert_jit_optimization_level(&runtime, expected_jit_optimization_level);
+    if let Some(expected_layout) = recurrence_layout {
+        assert_recurrence_layout(&runtime, expected_layout);
+    }
+
+    let point = validation_momenta(&runtime);
+    let owned_total = runtime
+        .evaluate_f64(&point, 1)
+        .expect("evaluate genuine odd-tail scalar reference")[0];
+    let resolved = runtime
+        .evaluate_resolved_f64(&point, 1, None, None)
+        .expect("resolve genuine odd-tail scalar reference");
+    let resolved_total = resolved.totals()[0];
+    assert_close(
+        owned_total,
+        resolved_total,
+        "genuine odd-tail scalar total/resolved parity",
+    );
+    assert!(
+        owned_total.is_finite(),
+        "genuine odd-tail scalar reference is non-finite"
+    );
+    let alternating_helicities = alternating_helicity_references(&mut runtime, &point, &resolved);
+
+    for point_count in ODD_TAIL_POINT_COUNTS {
+        let context = format!("{expected_execution_mode} point_count={point_count}");
+        let logical_momenta = point.repeat(point_count);
+        let guarded_momenta = guarded_values(
+            &logical_momenta,
+            INPUT_PREFIX_CANARY_BITS,
+            INPUT_SUFFIX_CANARY_BITS,
+        );
+        let momenta = &guarded_momenta[1..logical_momenta.len() + 1];
+        let logical_output = vec![f64::NAN; point_count];
+        let mut guarded_output = guarded_values(
+            &logical_output,
+            OUTPUT_PREFIX_CANARY_BITS,
+            OUTPUT_SUFFIX_CANARY_BITS,
+        );
+
+        for warmup_name in ["first", "descriptor"] {
+            guarded_output[1..point_count + 1].fill(f64::NAN);
+            runtime
+                .evaluate_f64_into(
+                    momenta,
+                    point_count,
+                    &mut guarded_output[1..point_count + 1],
+                )
+                .unwrap_or_else(|error| panic!("{context}: {warmup_name} warmup failed: {error}"));
+            assert_guard_canaries(
+                &guarded_momenta,
+                logical_momenta.len(),
+                INPUT_PREFIX_CANARY_BITS,
+                INPUT_SUFFIX_CANARY_BITS,
+                &format!("{context} {warmup_name} input"),
+            );
+            assert_guard_canaries(
+                &guarded_output,
+                point_count,
+                OUTPUT_PREFIX_CANARY_BITS,
+                OUTPUT_SUFFIX_CANARY_BITS,
+                &format!("{context} {warmup_name} output"),
+            );
+            for (point_index, observed) in guarded_output[1..point_count + 1]
+                .iter()
+                .copied()
+                .enumerate()
+            {
+                assert_close(
+                    observed,
+                    resolved_total,
+                    &format!("{context} {warmup_name} numerical parity point={point_index}"),
+                );
+            }
+        }
+
+        guarded_output[1..point_count + 1].fill(f64::NAN);
+        let (result, allocation_count, allocated_bytes) = count_allocations(|| {
+            runtime.evaluate_f64_into(
+                momenta,
+                point_count,
+                &mut guarded_output[1..point_count + 1],
+            )
+        });
+        result.unwrap_or_else(|error: RusticolError| {
+            panic!("{context}: counted caller-output evaluation failed: {error}")
+        });
+        assert_eq!(
+            (allocation_count, allocated_bytes),
+            (0, 0),
+            "{context}: warmed caller-output evaluation allocated"
+        );
+        assert_guard_canaries(
+            &guarded_momenta,
+            logical_momenta.len(),
+            INPUT_PREFIX_CANARY_BITS,
+            INPUT_SUFFIX_CANARY_BITS,
+            &format!("{context} counted input"),
+        );
+        assert_guard_canaries(
+            &guarded_output,
+            point_count,
+            OUTPUT_PREFIX_CANARY_BITS,
+            OUTPUT_SUFFIX_CANARY_BITS,
+            &format!("{context} counted output"),
+        );
+        for (point_index, observed) in guarded_output[1..point_count + 1]
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            assert_close(
+                observed,
+                resolved_total,
+                &format!("{context} counted numerical parity point={point_index}"),
+            );
+        }
+
+        let helicity_by_point = (0..point_count)
+            .map(|point_index| alternating_helicities[point_index % 2].0)
+            .collect::<Vec<_>>();
+        for warmup_name in ["first selector", "descriptor selector"] {
+            guarded_output[1..point_count + 1].fill(f64::NAN);
+            runtime
+                .evaluate_f64_into_with_selectors(
+                    momenta,
+                    point_count,
+                    None,
+                    None,
+                    Some(&helicity_by_point),
+                    None,
+                    &mut guarded_output[1..point_count + 1],
+                )
+                .unwrap_or_else(|error| panic!("{context}: {warmup_name} warmup failed: {error}"));
+            assert_guard_canaries(
+                &guarded_momenta,
+                logical_momenta.len(),
+                INPUT_PREFIX_CANARY_BITS,
+                INPUT_SUFFIX_CANARY_BITS,
+                &format!("{context} {warmup_name} input"),
+            );
+            assert_guard_canaries(
+                &guarded_output,
+                point_count,
+                OUTPUT_PREFIX_CANARY_BITS,
+                OUTPUT_SUFFIX_CANARY_BITS,
+                &format!("{context} {warmup_name} output"),
+            );
+            for (point_index, observed) in guarded_output[1..point_count + 1]
+                .iter()
+                .copied()
+                .enumerate()
+            {
+                assert_close(
+                    observed,
+                    alternating_helicities[point_index % 2].1,
+                    &format!("{context} {warmup_name} numerical parity point={point_index}"),
+                );
+            }
+        }
+
+        guarded_output[1..point_count + 1].fill(f64::NAN);
+        let (selector_result, selector_allocations, selector_bytes) = count_allocations(|| {
+            runtime.evaluate_f64_into_with_selectors(
+                momenta,
+                point_count,
+                None,
+                None,
+                Some(&helicity_by_point),
+                None,
+                &mut guarded_output[1..point_count + 1],
+            )
+        });
+        selector_result.unwrap_or_else(|error: RusticolError| {
+            panic!("{context}: counted selector evaluation failed: {error}")
+        });
+        assert_eq!(
+            (selector_allocations, selector_bytes),
+            (0, 0),
+            "{context}: warmed caller-output selector evaluation allocated"
+        );
+        assert_guard_canaries(
+            &guarded_momenta,
+            logical_momenta.len(),
+            INPUT_PREFIX_CANARY_BITS,
+            INPUT_SUFFIX_CANARY_BITS,
+            &format!("{context} counted selector input"),
+        );
+        assert_guard_canaries(
+            &guarded_output,
+            point_count,
+            OUTPUT_PREFIX_CANARY_BITS,
+            OUTPUT_SUFFIX_CANARY_BITS,
+            &format!("{context} counted selector output"),
+        );
+        for (point_index, observed) in guarded_output[1..point_count + 1]
+            .iter()
+            .copied()
+            .enumerate()
+        {
+            assert_close(
+                observed,
+                alternating_helicities[point_index % 2].1,
+                &format!("{context} counted selector parity point={point_index}"),
+            );
+        }
+
+        if matches!(profile_lane, ProfileLane::Compiled | ProfileLane::Eager) {
+            let profiled = runtime
+                .evaluate_f64_arena_profile_repeated(
+                    momenta,
+                    point_count,
+                    PROFILE_REPETITIONS,
+                    None,
+                    None,
+                )
+                .unwrap_or_else(|error| panic!("{context}: warmed profile failed: {error}"));
+            assert_eq!(
+                profiled.values.len(),
+                point_count,
+                "{context}: profiled output length"
+            );
+            for (point_index, observed) in profiled.values.iter().copied().enumerate() {
+                assert_close(
+                    observed,
+                    resolved_total,
+                    &format!("{context} profiled numerical parity point={point_index}"),
+                );
+            }
+            let measured_input_components = u64::try_from(
+                momenta
+                    .len()
+                    .checked_mul(PROFILE_REPETITIONS)
+                    .expect("profiled input component count overflowed"),
+            )
+            .expect("profiled input component count does not fit u64");
+            assert_zero_exposed_boundary_traffic(
+                &profiled.profile,
+                profile_lane,
+                measured_input_components,
+                &context,
+            );
+        }
+    }
+    assert_lane_activity_profile(&mut runtime, &point, profile_lane);
+}
+
+#[test]
+fn genuine_compiled_o3_odd_tails_preserve_numerics_allocations_and_boundary_traffic() {
+    let Some(artifact) = fixture_path("RUSTICOL_COMPILED_DIRECT_ARTIFACT") else {
+        return;
+    };
+    prove_genuine_odd_tails(artifact, "compiled", 3, None, ProfileLane::Compiled);
+}
+
+#[test]
+fn genuine_eager_o2_odd_tails_preserve_numerics_allocations_and_boundary_traffic() {
+    let Some(artifact) = fixture_path("RUSTICOL_EAGER_ARTIFACT") else {
+        return;
+    };
+    prove_genuine_odd_tails(artifact, "eager", 2, None, ProfileLane::Eager);
+}
+
+#[test]
+fn genuine_topology_recurrence_o2_odd_tails_preserve_numerics_and_allocations() {
+    let Some(artifact) = fixture_path("RUSTICOL_RECURRENCE_TOPOLOGY_ALLOCATION_ARTIFACT") else {
+        return;
+    };
+    prove_genuine_odd_tails(
+        artifact,
+        "recurrence",
+        2,
+        Some("topology-replay"),
+        ProfileLane::RecurrenceTopology,
+    );
+}
+
+#[test]
+fn genuine_all_flow_union_recurrence_o2_odd_tails_preserve_numerics_and_allocations() {
+    let Some(artifact) = fixture_path("RUSTICOL_RECURRENCE_UNION_ALLOCATION_ARTIFACT") else {
+        return;
+    };
+    prove_genuine_odd_tails(
+        artifact,
+        "recurrence",
+        2,
+        Some("all-flow-union"),
+        ProfileLane::RecurrenceUnion,
+    );
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/tests/recurrence_direct_arena_allocations.rs b/pyamplicol/rust/crates/rusticol-core/tests/recurrence_direct_arena_allocations.rs
new file mode 100644
index 0000000000..dfa995d94b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/tests/recurrence_direct_arena_allocations.rs
@@ -0,0 +1,972 @@
+// SPDX-License-Identifier: 0BSD
+
+use rusticol_core::recurrence::direct_backend::{
+    DIRECT_STATUS_OK, DirectArenaView, DirectExecutorCatalog, DirectExecutorHandle,
+    DirectFactorView, DirectMomentumView, DirectParameterView, DirectUnionSourceDispatchHandle,
+};
+use rusticol_core::recurrence::direct_runtime::DirectRecurrenceExecutionRuntime;
+use rusticol_core::recurrence::{
+    CheckedTableRange, ClosureExecutionProofGroupV2, ClosureProofContributionV2,
+    ClosureProofMetadataV2, DIRECT_NONE_U32, DirectAmplitudeDestinationDescriptor,
+    DirectClosureRow, DirectContributionRow, DirectCurrentDescriptor, DirectDestinationOperation,
+    DirectExecutorRole, DirectFinalizationRow, DirectMomentumFormDescriptor, DirectMomentumTerm,
+    DirectNodeKind, DirectRecurrencePlan, DirectRecurrencePlanParts, DirectReplayTargetDescriptor,
+    DirectResolvedHelicityDescriptor, DirectResolvedSourceSelection, DirectRowGroupDescriptor,
+    DirectSelectorDomainDescriptor, DirectSourceDispatchVariantDescriptor,
+    DirectSourceEmbeddingRow, DirectSourceProjectionRow, DirectSourceRow,
+    DirectSourceStateAssignment, ExactComplexRational, RecurrenceStrategy, SemanticDigest,
+    closure_component_factor_digest_v2, closure_selector_domain_digest_v2,
+};
+use rusticol_core::{NativeRuntime, RusticolError};
+use std::alloc::{GlobalAlloc, Layout, System};
+use std::cell::Cell;
+use std::ffi::c_void;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+thread_local! {
+    static TRACK_ALLOCATIONS: Cell<bool> = const { Cell::new(false) };
+    static ALLOCATION_COUNT: Cell<usize> = const { Cell::new(0) };
+    static ALLOCATED_BYTES: Cell<usize> = const { Cell::new(0) };
+}
+
+struct CountingAllocator;
+
+#[global_allocator]
+static GLOBAL_ALLOCATOR: CountingAllocator = CountingAllocator;
+
+unsafe impl GlobalAlloc for CountingAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        count_allocation(layout.size());
+        unsafe { System.alloc(layout) }
+    }
+
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        count_allocation(layout.size());
+        unsafe { System.alloc_zeroed(layout) }
+    }
+
+    unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        count_allocation(new_size);
+        unsafe { System.realloc(pointer, layout, new_size) }
+    }
+
+    unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+        unsafe { System.dealloc(pointer, layout) }
+    }
+}
+
+fn count_allocation(bytes: usize) {
+    let tracking = TRACK_ALLOCATIONS.try_with(Cell::get).unwrap_or(false);
+    if tracking {
+        let _ = ALLOCATION_COUNT.try_with(|count| count.set(count.get() + 1));
+        let _ = ALLOCATED_BYTES.try_with(|total| total.set(total.get().saturating_add(bytes)));
+    }
+}
+
+fn count_allocations<T>(function: impl FnOnce() -> T) -> (T, usize, usize) {
+    ALLOCATION_COUNT.with(|count| count.set(0));
+    ALLOCATED_BYTES.with(|total| total.set(0));
+    TRACK_ALLOCATIONS.with(|tracking| tracking.set(true));
+    let result = function();
+    TRACK_ALLOCATIONS.with(|tracking| tracking.set(false));
+    let count = ALLOCATION_COUNT.with(Cell::get);
+    let bytes = ALLOCATED_BYTES.with(Cell::get);
+    (result, count, bytes)
+}
+
+const STATUS_BOUNDS: i32 = 2;
+const POINT_COUNT: u32 = 4;
+const EXPECTED_RE: [f64; 4] = [3.0, 6.0, 9.0, 12.0];
+const EXPECTED_IM: [f64; 4] = [1.0, 2.0, 3.0, 4.0];
+const REAL_ARTIFACT_REPETITIONS: usize = 8;
+const TOPOLOGY_ARTIFACT_ENV: &str = "RUSTICOL_RECURRENCE_TOPOLOGY_ALLOCATION_ARTIFACT";
+const UNION_ARTIFACT_ENV: &str = "RUSTICOL_RECURRENCE_UNION_ALLOCATION_ARTIFACT";
+const CONTRACTED_ARTIFACT_ENV: &str = "RUSTICOL_RECURRENCE_CONTRACTED_ALLOCATION_ARTIFACT";
+
+unsafe extern "C" fn fill_sources(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    _factors: DirectFactorView,
+    rows: *const DirectSourceRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        for point in 0..point_count as usize {
+            let source = row.momentum_form_id as usize
+                * momenta.lorentz_component_count as usize
+                * momenta.point_stride as usize
+                + point;
+            let destination =
+                row.destination_component_base as usize * arena.point_stride as usize + point;
+            if source >= momenta.scalar_len as usize
+                || destination >= arena.current_scalar_len as usize
+            {
+                return STATUS_BOUNDS;
+            }
+            unsafe {
+                *arena.current_re.add(destination) = *momenta.values.add(source);
+                *arena.current_im.add(destination) = 0.0;
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+unsafe extern "C" fn fill_union_sources(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectSourceRow,
+    row_count: u32,
+    variants: *const DirectSourceDispatchVariantDescriptor,
+    variant_count: u32,
+    embeddings: *const DirectSourceEmbeddingRow,
+    embedding_count: u32,
+    selections: *const DirectResolvedSourceSelection,
+    selection_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    let variants = unsafe { std::slice::from_raw_parts(variants, variant_count as usize) };
+    let embeddings = unsafe { std::slice::from_raw_parts(embeddings, embedding_count as usize) };
+    let selections = unsafe { std::slice::from_raw_parts(selections, selection_count as usize) };
+    for selection in selections {
+        let Some(variant) = variants.get(selection.dispatch_variant_id as usize) else {
+            return STATUS_BOUNDS;
+        };
+        let Some(row) = rows.get(variant.source_row_id as usize) else {
+            return STATUS_BOUNDS;
+        };
+        if row.source_slot != selection.source_slot
+            || variant.crossing_exact_factor_id >= factors.value_count
+        {
+            return STATUS_BOUNDS;
+        }
+        let embedding_start = variant.embedding_start as usize;
+        let Some(variant_embeddings) =
+            embeddings.get(embedding_start..embedding_start + variant.embedding_count as usize)
+        else {
+            return STATUS_BOUNDS;
+        };
+        let crossing = unsafe {
+            *factors
+                .values_re
+                .add(variant.crossing_exact_factor_id as usize)
+        };
+        for embedding in variant_embeddings {
+            if embedding.source_component_or_sentinel == DIRECT_NONE_U32
+                || embedding.exact_factor_id >= factors.value_count
+            {
+                return STATUS_BOUNDS;
+            }
+            let embedding_factor =
+                unsafe { *factors.values_re.add(embedding.exact_factor_id as usize) };
+            for point in 0..point_count as usize {
+                let source = row.momentum_form_id as usize
+                    * momenta.lorentz_component_count as usize
+                    * momenta.point_stride as usize
+                    + point;
+                let destination = (row.destination_component_base as usize
+                    + embedding.full_component as usize)
+                    * arena.point_stride as usize
+                    + point;
+                if source >= momenta.scalar_len as usize
+                    || destination >= arena.current_scalar_len as usize
+                {
+                    return STATUS_BOUNDS;
+                }
+                unsafe {
+                    *arena.current_re.add(destination) =
+                        *momenta.values.add(source) * crossing * embedding_factor;
+                    *arena.current_im.add(destination) = 0.0;
+                }
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+unsafe extern "C" fn accumulate_contributions(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectContributionRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        if row.exact_factor_id >= factors.value_count || parameters.value_count == 0 {
+            return STATUS_BOUNDS;
+        }
+        let factor_re = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        let factor_im = unsafe { *factors.values_im.add(row.exact_factor_id as usize) };
+        let parameter_re = unsafe { *parameters.values_re };
+        let parameter_im = unsafe { *parameters.values_im };
+        let scale_re = factor_re * parameter_re - factor_im * parameter_im;
+        let scale_im = factor_re * parameter_im + factor_im * parameter_re;
+        for point in 0..point_count as usize {
+            let source = row.parent0_component_base as usize * arena.point_stride as usize + point;
+            let destination =
+                row.destination_component_base as usize * arena.point_stride as usize + point;
+            if source >= arena.current_scalar_len as usize
+                || destination >= arena.current_scalar_len as usize
+            {
+                return STATUS_BOUNDS;
+            }
+            let source_re = unsafe { *arena.current_re.add(source) };
+            let source_im = unsafe { *arena.current_im.add(source) };
+            unsafe {
+                *arena.current_re.add(destination) += source_re * scale_re - source_im * scale_im;
+                *arena.current_im.add(destination) += source_re * scale_im + source_im * scale_re;
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+unsafe extern "C" fn finalize_currents(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectFinalizationRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        if row.exact_factor_id >= factors.value_count {
+            return STATUS_BOUNDS;
+        }
+        let factor = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        for component in 0..usize::from(row.component_count) {
+            for point in 0..point_count as usize {
+                let destination =
+                    (row.component_base as usize + component) * arena.point_stride as usize + point;
+                if destination >= arena.current_scalar_len as usize {
+                    return STATUS_BOUNDS;
+                }
+                unsafe {
+                    *arena.current_re.add(destination) *= factor;
+                    *arena.current_im.add(destination) *= factor;
+                }
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+unsafe extern "C" fn accumulate_closures(
+    _context: *const c_void,
+    arena: DirectArenaView,
+    _momenta: DirectMomentumView,
+    _parameters: DirectParameterView,
+    factors: DirectFactorView,
+    rows: *const DirectClosureRow,
+    row_count: u32,
+    point_count: u32,
+) -> i32 {
+    let rows = unsafe { std::slice::from_raw_parts(rows, row_count as usize) };
+    for row in rows {
+        if row.exact_factor_id >= factors.value_count {
+            return STATUS_BOUNDS;
+        }
+        let factor = unsafe { *factors.values_re.add(row.exact_factor_id as usize) };
+        for point in 0..point_count as usize {
+            let source = row.parent0_component_base as usize * arena.point_stride as usize + point;
+            let destination =
+                row.amplitude_destination_id as usize * arena.point_stride as usize + point;
+            if source >= arena.current_scalar_len as usize
+                || destination >= arena.amplitude_scalar_len as usize
+            {
+                return STATUS_BOUNDS;
+            }
+            unsafe {
+                *arena.amplitude_re.add(destination) += *arena.current_re.add(source) * factor;
+                *arena.amplitude_im.add(destination) += *arena.current_im.add(source) * factor;
+            }
+        }
+    }
+    DIRECT_STATUS_OK
+}
+
+fn direct_runtime(strategy: RecurrenceStrategy) -> DirectRecurrenceExecutionRuntime {
+    let is_union = strategy == RecurrenceStrategy::AllFlowUnion;
+    let catalog_digest = SemanticDigest::new([0x33; 32]).unwrap();
+    let plan = DirectRecurrencePlan::new(DirectRecurrencePlanParts {
+        strategy,
+        semantic_digest: SemanticDigest::new([0x11; 32]).unwrap(),
+        prepared_pack_digest: SemanticDigest::new([0x22; 32]).unwrap(),
+        direct_template_catalog_digest: catalog_digest,
+        point_tile_size: POINT_COUNT,
+        workspace_mib: 1,
+        current_arena_components: 2,
+        physical_sector_count: 1,
+        retained_helicity_count: 1,
+        amplitude_destination_count: 1,
+        parameter_value_count: 1,
+        external_source_count: 1,
+        state_template_count: 2,
+        source_template_count: 1,
+        source_template_or_dispatch_count: 1,
+        runtime_helicity_contract_count: u32::from(is_union),
+        runtime_helicity_variant_count: u32::from(is_union),
+        direct_executor_count: 4,
+        currents: vec![
+            DirectCurrentDescriptor {
+                semantic_current_id: 0,
+                node_kind: DirectNodeKind::Source,
+                state_template_id: 0,
+                component_base: 0,
+                component_count: 1,
+                momentum_form_id: 0,
+                stage: 0,
+                selector_domain_id: 0,
+                first_use: 0,
+                last_use: 1,
+                source_row_or_sentinel: 0,
+                finalization_row_or_sentinel: DIRECT_NONE_U32,
+            },
+            DirectCurrentDescriptor {
+                semantic_current_id: 1,
+                node_kind: DirectNodeKind::Current,
+                state_template_id: 1,
+                component_base: 1,
+                component_count: 1,
+                momentum_form_id: 0,
+                stage: 1,
+                selector_domain_id: 0,
+                first_use: 1,
+                last_use: 2,
+                source_row_or_sentinel: DIRECT_NONE_U32,
+                finalization_row_or_sentinel: 0,
+            },
+        ],
+        sources: vec![DirectSourceRow {
+            source_slot: 0,
+            destination_component_base: 0,
+            momentum_form_id: 0,
+            source_template_or_dispatch_domain: 0,
+            spin_state_class: -1,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+        }],
+        contributions: vec![DirectContributionRow {
+            parent0_component_base: 0,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            destination_component_base: 1,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        }],
+        finalizations: vec![DirectFinalizationRow {
+            component_base: 1,
+            component_count: 1,
+            momentum_form_id: 0,
+            exact_factor_id: 0,
+            selector_domain_id: 0,
+            flags: 0,
+        }],
+        closures: vec![DirectClosureRow {
+            parent0_component_base: 1,
+            parent1_component_base_or_sentinel: DIRECT_NONE_U32,
+            parent0_momentum_form_id: 0,
+            parent1_momentum_form_id_or_sentinel: DIRECT_NONE_U32,
+            amplitude_destination_id: 0,
+            exact_factor_id: 0,
+            component_factor_start: 0,
+            component_count: 1,
+            selector_domain_id: 0,
+            flags: 0,
+        }],
+        row_groups: vec![
+            DirectRowGroupDescriptor {
+                stage: 0,
+                role: DirectExecutorRole::Source,
+                destination_operation: DirectDestinationOperation::Initialize,
+                direct_executor_id: if is_union { DIRECT_NONE_U32 } else { 0 },
+                row_start: 0,
+                row_count: 1,
+            },
+            DirectRowGroupDescriptor {
+                stage: 1,
+                role: DirectExecutorRole::Contribution,
+                destination_operation: DirectDestinationOperation::Add,
+                direct_executor_id: 1,
+                row_start: 0,
+                row_count: 1,
+            },
+            DirectRowGroupDescriptor {
+                stage: 1,
+                role: DirectExecutorRole::Finalization,
+                destination_operation: DirectDestinationOperation::FinalizeInPlace,
+                direct_executor_id: 2,
+                row_start: 0,
+                row_count: 1,
+            },
+            DirectRowGroupDescriptor {
+                stage: 2,
+                role: DirectExecutorRole::Closure,
+                destination_operation: DirectDestinationOperation::ClosureAdd,
+                direct_executor_id: 3,
+                row_start: 0,
+                row_count: 1,
+            },
+        ],
+        momentum_forms: vec![DirectMomentumFormDescriptor {
+            term_start: 0,
+            term_count: 1,
+        }],
+        momentum_terms: vec![DirectMomentumTerm {
+            source_slot: 0,
+            coefficient: 1,
+        }],
+        selector_domains: vec![DirectSelectorDomainDescriptor {
+            word_start: 0,
+            word_count: 1,
+        }],
+        selector_words: vec![1],
+        replay_targets: if is_union {
+            vec![]
+        } else {
+            vec![DirectReplayTargetDescriptor {
+                public_flow_id: 0,
+                representative_id: 0,
+                source_permutation_start: 0,
+                source_permutation_count: 1,
+                helicity_map_start: 0,
+                helicity_map_count: 1,
+                phase_exact_factor_id: 0,
+                multiplicity: 1,
+                selector_domain_id: 0,
+            }]
+        },
+        source_permutations: if is_union { vec![] } else { vec![0] },
+        replay_momentum_signs: if is_union { vec![] } else { vec![1] },
+        replay_helicity_map: if is_union { vec![] } else { vec![0] },
+        amplitude_destinations: vec![DirectAmplitudeDestinationDescriptor {
+            closure_row_start: 0,
+            id: 0,
+            target_sector_id: 0,
+            target_helicity_id_or_sentinel: if is_union { DIRECT_NONE_U32 } else { 0 },
+            closure_row_count: 1,
+            selector_domain_id: 0,
+        }],
+        resolved_helicities: vec![DirectResolvedHelicityDescriptor {
+            source_state_start: 0,
+            source_selection_start: 0,
+            public_helicity_start: 0,
+            id: 0,
+            source_state_count: 1,
+            source_selection_count: u32::from(is_union),
+            public_helicity_count: 1,
+            selector_domain_id: 0,
+        }],
+        source_state_assignments: vec![DirectSourceStateAssignment {
+            source_slot: 0,
+            state_index: 0,
+        }],
+        source_dispatch_variants: if is_union {
+            vec![DirectSourceDispatchVariantDescriptor {
+                embedding_start: 0,
+                projection_start: 0,
+                source_row_id: 0,
+                dispatch_domain_id: 0,
+                runtime_variant_id: 0,
+                source_state_index: 0,
+                source_template_id: 0,
+                source_state_template_id: 0,
+                crossed_state_template_id: 0,
+                crossed_spin_state_class: -1,
+                direct_executor_id: 0,
+                crossing_exact_factor_id: 0,
+                embedding_count: 1,
+                projection_count: 1,
+            }]
+        } else {
+            vec![]
+        },
+        source_embeddings: if is_union {
+            vec![DirectSourceEmbeddingRow {
+                full_component: 0,
+                source_component_or_sentinel: 0,
+                exact_factor_id: 0,
+            }]
+        } else {
+            vec![]
+        },
+        source_projections: if is_union {
+            vec![DirectSourceProjectionRow {
+                source_component: 0,
+                full_component: 0,
+            }]
+        } else {
+            vec![]
+        },
+        resolved_source_selections: if is_union {
+            vec![DirectResolvedSourceSelection {
+                source_slot: 0,
+                dispatch_variant_id: 0,
+            }]
+        } else {
+            vec![]
+        },
+        public_helicities: vec![-1],
+        exact_factors: vec![ExactComplexRational::ONE],
+        closure_proofs: ClosureProofMetadataV2::new(
+            vec![
+                ClosureProofContributionV2::new(
+                    0,
+                    0,
+                    Some(0),
+                    (!is_union).then_some(0),
+                    0,
+                    SemanticDigest::new([0x41; 32]).unwrap(),
+                    None,
+                    vec![1],
+                    vec![Some(1)],
+                    vec![SemanticDigest::new([0x42; 32]).unwrap()],
+                    vec![SemanticDigest::new([0x43; 32]).unwrap()],
+                    vec![0],
+                    vec![0],
+                    vec![0],
+                    0,
+                    SemanticDigest::new([0x44; 32]).unwrap(),
+                    None,
+                    vec![],
+                    None,
+                    ExactComplexRational::ONE,
+                    1,
+                )
+                .unwrap(),
+            ],
+            vec![
+                ClosureExecutionProofGroupV2::new(
+                    0,
+                    Some(0),
+                    Some(0),
+                    CheckedTableRange::new(0, 1),
+                    ExactComplexRational::ONE,
+                    closure_component_factor_digest_v2(&[ExactComplexRational::ONE]).unwrap(),
+                    closure_selector_domain_digest_v2(&[1]).unwrap(),
+                )
+                .unwrap(),
+            ],
+            vec![],
+        )
+        .unwrap(),
+    })
+    .unwrap();
+
+    let executors = DirectExecutorCatalog::new(
+        &plan,
+        catalog_digest,
+        vec![
+            DirectExecutorHandle::Source {
+                call: fill_sources,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Contribution {
+                call: accumulate_contributions,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Finalization {
+                call: finalize_currents,
+                context: std::ptr::null(),
+            },
+            DirectExecutorHandle::Closure {
+                call: accumulate_closures,
+                context: std::ptr::null(),
+            },
+        ],
+    )
+    .unwrap();
+    let mut runtime = if is_union {
+        DirectRecurrenceExecutionRuntime::new_with_union_source_dispatch(
+            plan,
+            executors,
+            4,
+            DirectUnionSourceDispatchHandle {
+                call: fill_union_sources,
+                context: std::ptr::null(),
+            },
+        )
+        .unwrap()
+    } else {
+        DirectRecurrenceExecutionRuntime::new(plan, executors, 4).unwrap()
+    };
+    runtime.set_parameters(&[3.0], &[1.0]).unwrap();
+    runtime
+}
+
+fn topology_replay_runtime() -> DirectRecurrenceExecutionRuntime {
+    direct_runtime(RecurrenceStrategy::TopologyReplay)
+}
+
+fn all_flow_union_runtime() -> DirectRecurrenceExecutionRuntime {
+    direct_runtime(RecurrenceStrategy::AllFlowUnion)
+}
+
+fn external_momenta() -> [f64; 16] {
+    [
+        1.0, 10.0, 100.0, 1000.0, 2.0, 20.0, 200.0, 2000.0, 3.0, 30.0, 300.0, 3000.0, 4.0, 40.0,
+        400.0, 4000.0,
+    ]
+}
+
+#[test]
+fn warmed_topology_replay_tiles_allocate_zero_heap_bytes_and_remain_correct() {
+    let mut runtime = topology_replay_runtime();
+    let selector = runtime.prepare_replay_selector(0).unwrap();
+    let momenta = external_momenta();
+
+    let warm_output = runtime
+        .execute_replay_tile_from_external(&selector, POINT_COUNT, &momenta)
+        .unwrap();
+    assert_eq!(warm_output.destination_re(0).unwrap(), EXPECTED_RE);
+    assert_eq!(warm_output.destination_im(0).unwrap(), EXPECTED_IM);
+    let persistent_allocations = runtime.allocation_counters();
+    runtime.reset_counters();
+
+    let (result, allocation_count, allocated_bytes) = count_allocations(|| {
+        let mut observed_re = [0.0; POINT_COUNT as usize];
+        let mut observed_im = [0.0; POINT_COUNT as usize];
+        for _ in 0..32 {
+            let output = runtime.execute_replay_tile_from_external_unprofiled(
+                &selector,
+                POINT_COUNT,
+                &momenta,
+            )?;
+            observed_re.copy_from_slice(output.destination_re(0).ok_or_else(|| {
+                RusticolError::internal("missing direct recurrence real destination")
+            })?);
+            observed_im.copy_from_slice(output.destination_im(0).ok_or_else(|| {
+                RusticolError::internal("missing direct recurrence imaginary destination")
+            })?);
+        }
+        Ok::<_, RusticolError>((observed_re, observed_im))
+    });
+
+    let (observed_re, observed_im) = result.unwrap();
+    assert_eq!(observed_re, EXPECTED_RE);
+    assert_eq!(observed_im, EXPECTED_IM);
+    assert_eq!(allocation_count, 0, "warmed recurrence loop allocated");
+    assert_eq!(allocated_bytes, 0, "warmed recurrence loop allocated bytes");
+    assert_eq!(runtime.counters(), Default::default());
+    assert_eq!(runtime.role_timings(), Default::default());
+    assert_eq!(runtime.activity_counters(), Default::default());
+    assert_eq!(runtime.phase_timings(), Default::default());
+    assert_eq!(runtime.traffic_counters(), Default::default());
+    assert_eq!(runtime.allocation_counters(), persistent_allocations);
+}
+
+#[test]
+fn warmed_all_flow_union_tiles_allocate_zero_heap_bytes_and_remain_correct() {
+    let mut runtime = all_flow_union_runtime();
+    let selector = runtime.prepare_union_helicity_selector(0).unwrap();
+    let momenta = external_momenta();
+
+    let warm_output = runtime
+        .execute_union_tile_from_external(&selector, POINT_COUNT, &momenta)
+        .unwrap();
+    assert_eq!(warm_output.destination_re(0).unwrap(), EXPECTED_RE);
+    assert_eq!(warm_output.destination_im(0).unwrap(), EXPECTED_IM);
+    let persistent_allocations = runtime.allocation_counters();
+    runtime.reset_counters();
+
+    let (result, allocation_count, allocated_bytes) = count_allocations(|| {
+        let mut observed_re = [0.0; POINT_COUNT as usize];
+        let mut observed_im = [0.0; POINT_COUNT as usize];
+        for _ in 0..32 {
+            let output = runtime.execute_union_tile_from_external_unprofiled(
+                &selector,
+                POINT_COUNT,
+                &momenta,
+            )?;
+            observed_re.copy_from_slice(output.destination_re(0).ok_or_else(|| {
+                RusticolError::internal("missing direct recurrence real destination")
+            })?);
+            observed_im.copy_from_slice(output.destination_im(0).ok_or_else(|| {
+                RusticolError::internal("missing direct recurrence imaginary destination")
+            })?);
+        }
+        Ok::<_, RusticolError>((observed_re, observed_im))
+    });
+
+    let (observed_re, observed_im) = result.unwrap();
+    assert_eq!(observed_re, EXPECTED_RE);
+    assert_eq!(observed_im, EXPECTED_IM);
+    assert_eq!(
+        allocation_count, 0,
+        "warmed union recurrence loop allocated"
+    );
+    assert_eq!(
+        allocated_bytes, 0,
+        "warmed union recurrence loop allocated bytes"
+    );
+    assert_eq!(runtime.counters(), Default::default());
+    assert_eq!(runtime.role_timings(), Default::default());
+    assert_eq!(runtime.activity_counters(), Default::default());
+    assert_eq!(runtime.phase_timings(), Default::default());
+    assert_eq!(runtime.traffic_counters(), Default::default());
+    assert_eq!(runtime.allocation_counters(), persistent_allocations);
+}
+
+fn genuine_artifact_path(environment_name: &str) -> Option<PathBuf> {
+    let Some(path) = std::env::var_os(environment_name) else {
+        eprintln!("skipping genuine recurrence allocation proof: {environment_name} is not set");
+        return None;
+    };
+    let path = PathBuf::from(path);
+    assert!(
+        path.is_dir(),
+        "{environment_name} does not name an artifact directory: {}",
+        path.display()
+    );
+    Some(path)
+}
+
+fn validation_momenta(runtime: &NativeRuntime) -> Vec<f64> {
+    let metadata = runtime.metadata();
+    let path = runtime
+        .root()
+        .join("processes")
+        .join(&metadata.representative_process_key)
+        .join("validation-momenta.json");
+    let payload: serde_json::Value =
+        serde_json::from_slice(&fs::read(&path).unwrap_or_else(|error| {
+            panic!(
+                "could not read recurrence validation momenta {}: {error}",
+                path.display()
+            )
+        }))
+        .unwrap_or_else(|error| {
+            panic!(
+                "could not parse recurrence validation momenta {}: {error}",
+                path.display()
+            )
+        });
+    let point = payload["points"][0]
+        .as_array()
+        .expect("recurrence validation payload must contain one point");
+    assert_eq!(
+        point.len(),
+        metadata.external_count,
+        "recurrence validation point has the wrong external multiplicity"
+    );
+    point
+        .iter()
+        .flat_map(|leg| {
+            leg["momentum"]
+                .as_array()
+                .expect("validation leg must contain four momentum components")
+                .iter()
+                .map(|component| {
+                    component
+                        .as_str()
+                        .map(str::parse::<f64>)
+                        .transpose()
+                        .expect("validation momentum string must be binary64")
+                        .or_else(|| component.as_f64())
+                        .expect("validation momentum component must be numeric")
+                })
+        })
+        .collect()
+}
+
+fn assert_recurrence_layout(artifact: &Path, process_id: &str, expected_layout: &str) {
+    let path = artifact
+        .join("processes")
+        .join(process_id)
+        .join("execution.json");
+    let execution: serde_json::Value =
+        serde_json::from_slice(&fs::read(&path).unwrap_or_else(|error| {
+            panic!(
+                "could not read recurrence execution manifest {}: {error}",
+                path.display()
+            )
+        }))
+        .unwrap_or_else(|error| {
+            panic!(
+                "could not parse recurrence execution manifest {}: {error}",
+                path.display()
+            )
+        });
+    assert_eq!(
+        execution["recurrence_summary"]["lc_flow_layout"].as_str(),
+        Some(expected_layout),
+        "genuine allocation fixture has the wrong LC layout"
+    );
+    assert_eq!(
+        execution["required_runtime_capabilities"]
+            .as_array()
+            .expect("recurrence capabilities must be an array")
+            .iter()
+            .filter_map(serde_json::Value::as_str)
+            .filter(|capability| {
+                *capability == "rusticol.recurrence-direct-arena.complex-f64.v1"
+            })
+            .count(),
+        1,
+        "genuine allocation fixture must require Direct-Arena"
+    );
+}
+
+fn prove_genuine_artifact_warmed_loop_allocates_nothing(artifact: PathBuf, expected_layout: &str) {
+    let mut runtime =
+        NativeRuntime::load(&artifact, None, None).expect("load genuine recurrence artifact");
+    let metadata = runtime.metadata();
+    assert_eq!(metadata.execution_mode, "recurrence");
+    assert_recurrence_layout(
+        &artifact,
+        &metadata.representative_process_key,
+        expected_layout,
+    );
+
+    // Loading prepares every replay-flow or union-helicity selector. Momentum
+    // parsing, output ownership, and SymJIT descriptor creation also stay
+    // outside the counted region.
+    let one_point_momenta = validation_momenta(&runtime);
+    for point_count in [1, 3] {
+        let momenta = one_point_momenta.repeat(point_count);
+        let mut output = vec![f64::NAN; point_count];
+        runtime
+            .evaluate_f64_into(&momenta, point_count, &mut output)
+            .expect("warm genuine recurrence evaluation");
+        runtime
+            .evaluate_f64_into(&momenta, point_count, &mut output)
+            .expect("warm genuine recurrence descriptor caches");
+        let expected = output.clone();
+        assert!(
+            expected.iter().all(|value| value.is_finite()),
+            "genuine recurrence warmup returned a non-finite total"
+        );
+
+        let (result, allocation_count, allocated_bytes) = count_allocations(|| {
+            for _ in 0..REAL_ARTIFACT_REPETITIONS {
+                runtime.evaluate_f64_into(&momenta, point_count, &mut output)?;
+                std::hint::black_box(output.as_slice());
+            }
+            Ok::<(), RusticolError>(())
+        });
+        result.expect("repeat genuine warmed recurrence evaluation");
+
+        assert_eq!(output, expected, "genuine recurrence output changed");
+        assert_eq!(
+            allocation_count, 0,
+            "genuine warmed recurrence loop allocated at {point_count} points"
+        );
+        assert_eq!(
+            allocated_bytes, 0,
+            "genuine warmed recurrence loop allocated bytes at {point_count} points"
+        );
+    }
+}
+
+fn prove_genuine_contracted_selector_plan_allocates_nothing(artifact: PathBuf) {
+    let mut runtime =
+        NativeRuntime::load(&artifact, None, None).expect("load genuine recurrence artifact");
+    let metadata = runtime.metadata();
+    assert_eq!(metadata.execution_mode, "recurrence");
+    assert_recurrence_layout(
+        &artifact,
+        &metadata.representative_process_key,
+        "contracted-color-union",
+    );
+    let helicity_ids = runtime
+        .helicity_ids()
+        .expect("load recurrence helicity IDs");
+    assert_eq!(
+        helicity_ids.len(),
+        1,
+        "contracted allocation artifact must retain exactly one helicity"
+    );
+    let helicity_id = helicity_ids[0].clone();
+    let selected_helicities = [helicity_id];
+    let selector_plan = runtime
+        .prepare_recurrence_selector_plan(Some(&selected_helicities), None)
+        .expect("prepare recurrence selector plan");
+    let momenta = validation_momenta(&runtime);
+    let mut output = [f64::NAN; 1];
+    runtime
+        .evaluate_f64_into_with_recurrence_selector_plan(&selector_plan, &momenta, 1, &mut output)
+        .expect("warm genuine selected recurrence evaluation");
+    let expected = output;
+    let mut total = [f64::NAN; 1];
+    runtime
+        .evaluate_f64_into(&momenta, 1, &mut total)
+        .expect("evaluate genuine recurrence through the no-selector total fast path");
+    assert_eq!(
+        total, expected,
+        "no-selector total must equal the sole retained-helicity selector"
+    );
+
+    let (result, allocation_count, allocated_bytes) = count_allocations(|| {
+        for _ in 0..REAL_ARTIFACT_REPETITIONS {
+            runtime.evaluate_f64_into_with_recurrence_selector_plan(
+                &selector_plan,
+                &momenta,
+                1,
+                &mut output,
+            )?;
+            std::hint::black_box(output.as_slice());
+        }
+        Ok::<(), RusticolError>(())
+    });
+    result.expect("repeat genuine selected recurrence evaluation");
+
+    assert_eq!(output, expected, "selected recurrence output changed");
+    assert_eq!(
+        allocation_count, 0,
+        "prepared recurrence selector loop allocated"
+    );
+    assert_eq!(
+        allocated_bytes, 0,
+        "prepared recurrence selector loop allocated bytes"
+    );
+}
+
+#[test]
+fn genuine_topology_replay_artifact_warmed_loop_allocates_zero_heap_bytes() {
+    let Some(artifact) = genuine_artifact_path(TOPOLOGY_ARTIFACT_ENV) else {
+        return;
+    };
+    prove_genuine_artifact_warmed_loop_allocates_nothing(artifact, "topology-replay");
+}
+
+#[test]
+fn genuine_all_flow_union_artifact_warmed_loop_allocates_zero_heap_bytes() {
+    let Some(artifact) = genuine_artifact_path(UNION_ARTIFACT_ENV) else {
+        return;
+    };
+    prove_genuine_artifact_warmed_loop_allocates_nothing(artifact, "all-flow-union");
+}
+
+#[test]
+fn genuine_contracted_color_artifact_warmed_loop_allocates_zero_heap_bytes() {
+    let Some(artifact) = genuine_artifact_path(CONTRACTED_ARTIFACT_ENV) else {
+        return;
+    };
+    prove_genuine_artifact_warmed_loop_allocates_nothing(artifact, "contracted-color-union");
+}
+
+#[test]
+fn genuine_contracted_color_prepared_selector_allocates_zero_heap_bytes() {
+    let Some(artifact) = genuine_artifact_path(CONTRACTED_ARTIFACT_ENV) else {
+        return;
+    };
+    prove_genuine_contracted_selector_plan_allocates_nothing(artifact);
+}
diff --git a/pyamplicol/rust/crates/rusticol-core/tests/recurrence_selected_helicity.rs b/pyamplicol/rust/crates/rusticol-core/tests/recurrence_selected_helicity.rs
new file mode 100644
index 0000000000..4ab09847f3
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-core/tests/recurrence_selected_helicity.rs
@@ -0,0 +1,330 @@
+// SPDX-License-Identifier: 0BSD
+
+#![cfg(all(feature = "f64-symjit", any(target_os = "linux", target_os = "macos")))]
+
+//! Reuse the genuine topology-replay fixture accepted by the allocation
+//! tests. No generation is performed here; the ordinary all-helicity route
+//! supplies the independent resolved-component reference.
+
+use rusticol_core::NativeRuntime;
+use std::fs;
+use std::path::PathBuf;
+
+fn assert_close(actual: &[f64], expected: &[f64]) {
+    assert_eq!(actual.len(), expected.len());
+    for (actual, expected) in actual.iter().zip(expected) {
+        let scale = actual.abs().max(expected.abs()).max(1.0e-200);
+        assert!(
+            (actual - expected).abs() <= 5.0e-12 * scale,
+            "selected recurrence differs: {actual:.17e} versus {expected:.17e}"
+        );
+    }
+}
+
+fn momenta(runtime: &NativeRuntime) -> Vec<f64> {
+    let path = runtime
+        .root()
+        .join("processes")
+        .join(&runtime.metadata().representative_process_key)
+        .join("validation-momenta.json");
+    let payload: serde_json::Value = serde_json::from_slice(&fs::read(path).unwrap()).unwrap();
+    let point = payload["points"][0].as_array().unwrap();
+    let one_point = point
+        .iter()
+        .flat_map(|leg| {
+            leg["momentum"].as_array().unwrap().iter().map(|value| {
+                value
+                    .as_str()
+                    .map(|value| value.parse::<f64>().unwrap())
+                    .or_else(|| value.as_f64())
+                    .unwrap()
+            })
+        })
+        .collect::<Vec<_>>();
+    let mut batch = Vec::new();
+    // Include a partial SIMD tile and distinct, on-shell, rotated points.
+    for angle in [0.0_f64, 0.21, 0.43, 0.76, 1.07] {
+        for leg in one_point.chunks_exact(4) {
+            batch.extend([
+                leg[0],
+                angle.cos() * leg[1] + angle.sin() * leg[3],
+                leg[2],
+                -angle.sin() * leg[1] + angle.cos() * leg[3],
+            ]);
+        }
+    }
+    batch
+}
+
+#[test]
+fn genuine_selected_recurrence_matches_unrestricted_resolved_components() {
+    let Some(path) = std::env::var_os("RUSTICOL_RECURRENCE_TOPOLOGY_ALLOCATION_ARTIFACT") else {
+        return;
+    };
+    let path = PathBuf::from(path);
+    assert!(path.is_dir(), "missing fixture {}", path.display());
+    let mut runtime = NativeRuntime::load(&path, None, None).unwrap();
+    assert_eq!(runtime.metadata().execution_mode, "recurrence");
+    let helicities = runtime.process_physics().unwrap().helicities.clone();
+    let color_ids = runtime.color_ids().unwrap();
+    assert!(
+        helicities.len() > 2,
+        "fixture must retain generic helicities"
+    );
+    assert!(
+        color_ids.len() > 1,
+        "fixture must exercise flow relabelling"
+    );
+    let points = momenta(&runtime);
+    let point_count = 5;
+    let mut chosen = helicities
+        .iter()
+        .enumerate()
+        .filter(|(_, helicity)| helicity.computed && !helicity.structural_zero)
+        .take(2)
+        .map(|(index, _)| index)
+        .collect::<Vec<_>>();
+    if let Some(index) = helicities
+        .iter()
+        .position(|helicity| !helicity.computed && !helicity.structural_zero)
+    {
+        chosen.push(index);
+    }
+    if let Some(index) = helicities
+        .iter()
+        .position(|helicity| helicity.structural_zero)
+    {
+        chosen.push(index);
+    }
+    assert!(chosen.len() >= 2);
+
+    for color_index in [0, color_ids.len() - 1] {
+        let colors = [color_ids[color_index].clone()];
+        let baseline = runtime
+            .evaluate_resolved_f64(&points, point_count, None, Some(&colors))
+            .unwrap();
+        let total = runtime
+            .evaluate_f64_profile_with_selectors(
+                &points,
+                point_count,
+                None,
+                Some(&colors),
+                None,
+                None,
+            )
+            .unwrap();
+        let complete_helicities = helicities
+            .iter()
+            .map(|helicity| helicity.id.clone())
+            .collect::<Vec<_>>();
+        let explicit_sum = runtime
+            .evaluate_f64_profile_with_selectors(
+                &points,
+                point_count,
+                Some(&complete_helicities),
+                Some(&colors),
+                None,
+                None,
+            )
+            .unwrap();
+        assert_close(&explicit_sum.values, &total.values);
+        assert_eq!(
+            explicit_sum.profile.recurrence_closure_row_count,
+            total.profile.recurrence_closure_row_count,
+        );
+        for &index in &chosen {
+            let selected = [helicities[index].id.clone()];
+            let expected = (0..point_count)
+                .map(|point| baseline.values[point * helicities.len() + index])
+                .collect::<Vec<_>>();
+            let actual = runtime
+                .evaluate_f64_with_selectors(
+                    &points,
+                    point_count,
+                    Some(&selected),
+                    Some(&colors),
+                    None,
+                    None,
+                )
+                .unwrap();
+            assert_close(&actual, &expected);
+            let profiled = runtime
+                .evaluate_f64_profile_with_selectors(
+                    &points,
+                    point_count,
+                    Some(&selected),
+                    Some(&colors),
+                    None,
+                    None,
+                )
+                .unwrap();
+            assert_close(&profiled.values, &expected);
+            if expected.iter().any(|value| *value != 0.0) {
+                assert!(
+                    profiled.profile.recurrence_closure_row_count
+                        < total.profile.recurrence_closure_row_count,
+                    "selected evaluator still executes all helicity closures"
+                );
+            }
+            let resolved = runtime
+                .evaluate_resolved_f64(&points, point_count, Some(&selected), Some(&colors))
+                .unwrap();
+            assert_close(&resolved.values, &expected);
+
+            // Restore the unrestricted route, then select the same cached
+            // route again. Reused arenas must not leak stale amplitudes.
+            let sum_again = runtime
+                .evaluate_f64_with_selectors(&points, point_count, None, Some(&colors), None, None)
+                .unwrap();
+            assert_close(&sum_again, &total.values);
+            let selected_again = runtime
+                .evaluate_f64_with_selectors(
+                    &points,
+                    point_count,
+                    Some(&selected),
+                    Some(&colors),
+                    None,
+                    None,
+                )
+                .unwrap();
+            assert_close(&selected_again, &expected);
+        }
+        let mut indices = chosen.clone();
+        indices.sort_unstable();
+        indices.dedup();
+        let selected = indices
+            .iter()
+            .map(|index| helicities[*index].id.clone())
+            .collect::<Vec<_>>();
+        let expected = (0..point_count)
+            .map(|point| {
+                indices
+                    .iter()
+                    .map(|index| baseline.values[point * helicities.len() + index])
+                    .sum()
+            })
+            .collect::<Vec<_>>();
+        let subset = runtime
+            .evaluate_f64_with_selectors(
+                &points,
+                point_count,
+                Some(&selected),
+                Some(&colors),
+                None,
+                None,
+            )
+            .unwrap();
+        assert_close(&subset, &expected);
+
+        let by_point = (0..point_count)
+            .map(|point| chosen[point % chosen.len()] as u32)
+            .collect::<Vec<_>>();
+        let expected = by_point
+            .iter()
+            .enumerate()
+            .map(|(point, index)| baseline.values[point * helicities.len() + *index as usize])
+            .collect::<Vec<_>>();
+        let point_selected = runtime
+            .evaluate_f64_with_selectors(
+                &points,
+                point_count,
+                None,
+                Some(&colors),
+                Some(&by_point),
+                None,
+            )
+            .unwrap();
+        assert_close(&point_selected, &expected);
+        assert!(
+            runtime
+                .evaluate_f64_with_selectors(
+                    &points,
+                    point_count,
+                    Some(&[]),
+                    Some(&colors),
+                    None,
+                    None
+                )
+                .is_err()
+        );
+        assert!(
+            runtime
+                .evaluate_f64_with_selectors(
+                    &points,
+                    point_count,
+                    Some(&["missing-helicity".to_string()]),
+                    Some(&colors),
+                    None,
+                    None,
+                )
+                .is_err()
+        );
+    }
+}
+
+#[cfg(feature = "symbolica-runtime")]
+#[test]
+fn selected_compiled_replay_preserves_double_double_and_arb_components() {
+    let Some(path) = std::env::var_os("RUSTICOL_COMPILED_SELECTED_HELICITY_ARTIFACT") else {
+        return;
+    };
+    let mut runtime = NativeRuntime::load(&PathBuf::from(path), None, None).unwrap();
+    assert_eq!(runtime.metadata().execution_mode, "compiled");
+    let helicities = runtime.process_physics().unwrap().helicities.clone();
+    let colors = runtime.color_ids().unwrap();
+    assert!(helicities.len() > 2 && colors.len() > 1);
+    let colors = [colors[colors.len() - 1].clone()];
+    let mut chosen = helicities
+        .iter()
+        .enumerate()
+        .filter(|(_, helicity)| helicity.computed && !helicity.structural_zero)
+        .take(2)
+        .map(|(index, _)| index)
+        .collect::<Vec<_>>();
+    if let Some(index) = helicities
+        .iter()
+        .position(|helicity| !helicity.computed && !helicity.structural_zero)
+    {
+        chosen.push(index);
+    }
+    let points = momenta(&runtime)
+        .into_iter()
+        .map(|value| format!("{value:.17e}"))
+        .collect::<Vec<_>>();
+    for digits in [32, 64] {
+        let baseline = runtime
+            .evaluate_resolved_with_precision(&points, 5, digits, None, Some(&colors))
+            .unwrap();
+        for &index in &chosen {
+            let selected = [helicities[index].id.clone()];
+            let expected = (0..5)
+                .map(|point| {
+                    baseline.values[point * helicities.len() + index]
+                        .parse()
+                        .unwrap()
+                })
+                .collect::<Vec<f64>>();
+            let actual = runtime
+                .evaluate_resolved_with_precision(
+                    &points,
+                    5,
+                    digits,
+                    Some(&selected),
+                    Some(&colors),
+                )
+                .unwrap();
+            assert_close(
+                &actual
+                    .values
+                    .iter()
+                    .map(|value| value.parse().unwrap())
+                    .collect::<Vec<_>>(),
+                &expected,
+            );
+            let sum_again = runtime
+                .evaluate_resolved_with_precision(&points, 5, digits, None, Some(&colors))
+                .unwrap();
+            assert_eq!(sum_again.values, baseline.values);
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-python/Cargo.toml b/pyamplicol/rust/crates/rusticol-python/Cargo.toml
new file mode 100644
index 0000000000..866058789b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/Cargo.toml
@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: 0BSD
+
+[package]
+name = "rusticol-python"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+build = "build.rs"
+
+[lib]
+name = "_rusticol"
+crate-type = ["cdylib", "rlib"]
+
+[features]
+default = []
+extension-module = ["pyo3/extension-module"]
+numpy = ["dep:numpy"]
+on-the-fly-test-support = ["rusticol-core/on-the-fly-test-support"]
+
+[dependencies]
+flate2.workspace = true
+numpy = { workspace = true, optional = true }
+num-bigint.workspace = true
+num-rational.workspace = true
+num-traits.workspace = true
+pyo3.workspace = true
+rusticol-core = { path = "../rusticol-core", default-features = false, features = ["f64-compiled", "f64-symjit", "python-generation-bridge"] }
+serde_json.workspace = true
+sha2.workspace = true
+
+[build-dependencies]
+pyo3-build-config = "0.29"
diff --git a/pyamplicol/rust/crates/rusticol-python/build.rs b/pyamplicol/rust/crates/rusticol-python/build.rs
new file mode 100644
index 0000000000..057c9fb516
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/build.rs
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: 0BSD
+
+use std::env;
+use std::fs;
+use std::io;
+use std::path::{Path, PathBuf};
+
+fn copy_tree(source: &Path, destination: &Path) -> io::Result<()> {
+    fs::create_dir_all(destination)?;
+    for entry in fs::read_dir(source)? {
+        let entry = entry?;
+        let file_type = entry.file_type()?;
+        let target = destination.join(entry.file_name());
+        if file_type.is_symlink() {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "SDK staging may not contain symlinks",
+            ));
+        }
+        if file_type.is_dir() {
+            copy_tree(&entry.path(), &target)?;
+        } else if file_type.is_file() {
+            fs::copy(entry.path(), target)?;
+        } else {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "SDK staging must contain regular files only",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn main() {
+    pyo3_build_config::add_extension_module_link_args();
+    println!("cargo:rerun-if-env-changed=PYAMPLICOL_SDK_STAGING");
+    println!("cargo:rerun-if-env-changed=PYAMPLICOL_NATIVE_BUILD_INPUTS_SHA256");
+    let output = PathBuf::from(env::var_os("OUT_DIR").expect("OUT_DIR"));
+    let sdk_output = output.join("_sdk");
+    match fs::remove_dir_all(&sdk_output) {
+        Ok(()) => {}
+        Err(error) if error.kind() == io::ErrorKind::NotFound => {}
+        Err(error) => panic!("remove previous Rusticol SDK from OUT_DIR: {error}"),
+    }
+    let Some(staging) = env::var_os("PYAMPLICOL_SDK_STAGING") else {
+        return;
+    };
+    let source = PathBuf::from(staging);
+    copy_tree(&source, &sdk_output).expect("copy validated Rusticol SDK into OUT_DIR");
+}
diff --git a/pyamplicol/rust/crates/rusticol-python/src/eager_lowering.rs b/pyamplicol/rust/crates/rusticol-python/src/eager_lowering.rs
new file mode 100644
index 0000000000..b568cf2f7c
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/src/eager_lowering.rs
@@ -0,0 +1,1110 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Private Python boundary for compact eager plan-v3 lowering.
+
+use numpy::{PyReadonlyArrayDyn, PyUntypedArrayMethods};
+use pyo3::exceptions::{PyTypeError, PyValueError};
+use pyo3::prelude::*;
+use pyo3::types::{PyAny, PyDict, PyList};
+use rusticol_core::eager_layout::{
+    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY, EAGER_LOWERING_INPUT_ABI, EAGER_PLAN_ABI,
+    EAGER_RUNTIME_CAPABILITY, EAGER_RUNTIME_CONTAINER_KIND, EAGER_RUNTIME_CONTAINER_SCHEMA,
+    EAGER_RUNTIME_LAYOUT_ABI,
+};
+use rusticol_core::{
+    EAGER_LOWERING_V1_TABLE_NAMES, EagerBitsetColumns, EagerCoherentGroupColumns,
+    EagerColorContractionEntryColumns, EagerColorContractionMetadata, EagerColorSelectorColumns,
+    EagerContractionCoefficientColumns, EagerCouplingColumns, EagerCurrentColumns,
+    EagerExactFactorColumns, EagerHelicitySelectorColumns, EagerI32SequenceColumns,
+    EagerInteractionColumns, EagerInteractionGroupColumns, EagerLoweringInputV1,
+    EagerLoweringInputV1View, EagerModelParameterColumns, EagerMomentumMaskColumns,
+    EagerPrimitiveColumnView, EagerReductionMemberColumns, EagerRetainedColumnView,
+    EagerRetainedTableView, EagerRootColumns, EagerSourceColumns, EagerU32SequenceColumns,
+    RusticolError, RusticolResult, lower_eager_plan_v3, write_eager_plan_v3_pacbin,
+};
+use sha2::{Digest, Sha256};
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::PathBuf;
+
+use crate::python_error;
+
+const INPUT_SCHEMA_SHA256: &str =
+    "59d5a3193ca25af6224c296297425782c394a34e352be622f47045e90d2bce29";
+const RESULT_KIND: &str = "pyamplicol-eager-runtime-lowering-result";
+const RESULT_SCHEMA_VERSION: u32 = 1;
+const STORAGE_ABI: &str = "pacbin-v1";
+const SELECTOR_WORK_ABI: &str = "pyamplicol-eager-selector-work-v1";
+
+struct NativeLoweringResult {
+    process_key: String,
+    model_name: String,
+    member_count: u64,
+    unpacked_size_bytes: u64,
+    index_sha256: String,
+    current_count: usize,
+    value_count: usize,
+    momentum_count: usize,
+    source_count: usize,
+    parameter_count: usize,
+    stage_count: usize,
+    coupling_count: usize,
+    invocation_count: usize,
+    attachment_count: usize,
+    finalization_count: usize,
+    closure_count: usize,
+    selector_domain_count: usize,
+    reduction_group_count: usize,
+    reduction_entry_count: usize,
+    retained_table_count: usize,
+    current_component_count: u64,
+    value_component_count: u64,
+    momentum_component_count: u64,
+    selected_flow_selector_count: u64,
+    selected_flow_current_count: u64,
+    selected_flow_evaluation_count: u64,
+    selected_flow_attachment_count: u64,
+    all_flow_selector_count: u64,
+    all_flow_current_count: u64,
+    all_flow_evaluation_count: u64,
+    all_flow_attachment_count: u64,
+    contracted_current_count: u64,
+    contracted_evaluation_count: u64,
+    contracted_attachment_count: u64,
+}
+
+enum BorrowedValues<'py> {
+    U8(PyReadonlyArrayDyn<'py, u8>),
+    U32(PyReadonlyArrayDyn<'py, u32>),
+    U64(PyReadonlyArrayDyn<'py, u64>),
+    I32(PyReadonlyArrayDyn<'py, i32>),
+    F64(PyReadonlyArrayDyn<'py, f64>),
+}
+
+impl BorrowedValues<'_> {
+    fn raw_bytes(&self) -> PyResult<&[u8]> {
+        fn bytes<T>(values: &[T]) -> &[u8] {
+            // All accepted dtypes are explicit little-endian primitives.
+            unsafe {
+                std::slice::from_raw_parts(
+                    values.as_ptr().cast::<u8>(),
+                    std::mem::size_of_val(values),
+                )
+            }
+        }
+        match self {
+            Self::U8(values) => values.as_slice().map_err(not_contiguous),
+            Self::U32(values) => values.as_slice().map(bytes).map_err(not_contiguous),
+            Self::U64(values) => values.as_slice().map(bytes).map_err(not_contiguous),
+            Self::I32(values) => values.as_slice().map(bytes).map_err(not_contiguous),
+            Self::F64(values) => values.as_slice().map(bytes).map_err(not_contiguous),
+        }
+    }
+
+    fn primitive_view(&self) -> RusticolResult<EagerPrimitiveColumnView<'_>> {
+        match self {
+            Self::U8(values) => Ok(EagerPrimitiveColumnView::U8(
+                values.as_slice().map_err(core_not_contiguous)?,
+            )),
+            Self::U32(values) => Ok(EagerPrimitiveColumnView::U32(
+                values.as_slice().map_err(core_not_contiguous)?,
+            )),
+            Self::U64(values) => Ok(EagerPrimitiveColumnView::U64(
+                values.as_slice().map_err(core_not_contiguous)?,
+            )),
+            Self::I32(values) => Ok(EagerPrimitiveColumnView::I32(
+                values.as_slice().map_err(core_not_contiguous)?,
+            )),
+            Self::F64(values) => Ok(EagerPrimitiveColumnView::F64(
+                values.as_slice().map_err(core_not_contiguous)?,
+            )),
+        }
+    }
+
+    fn as_u8(&self, context: &str) -> RusticolResult<&[u8]> {
+        match self.primitive_view()? {
+            EagerPrimitiveColumnView::U8(values) => Ok(values),
+            _ => Err(wrong_type(context, "u8")),
+        }
+    }
+
+    fn as_u32(&self, context: &str) -> RusticolResult<&[u32]> {
+        match self.primitive_view()? {
+            EagerPrimitiveColumnView::U32(values) => Ok(values),
+            _ => Err(wrong_type(context, "u32")),
+        }
+    }
+
+    fn as_u64(&self, context: &str) -> RusticolResult<&[u64]> {
+        match self.primitive_view()? {
+            EagerPrimitiveColumnView::U64(values) => Ok(values),
+            _ => Err(wrong_type(context, "u64")),
+        }
+    }
+
+    fn as_i32(&self, context: &str) -> RusticolResult<&[i32]> {
+        match self.primitive_view()? {
+            EagerPrimitiveColumnView::I32(values) => Ok(values),
+            _ => Err(wrong_type(context, "i32")),
+        }
+    }
+
+    fn as_f64(&self, context: &str) -> RusticolResult<&[f64]> {
+        match self.primitive_view()? {
+            EagerPrimitiveColumnView::F64(values) => Ok(values),
+            _ => Err(wrong_type(context, "f64")),
+        }
+    }
+}
+
+struct BorrowedColumn<'py> {
+    name: String,
+    shape: Vec<usize>,
+    values: BorrowedValues<'py>,
+}
+
+struct BorrowedTable<'py> {
+    name: String,
+    row_count: u64,
+    columns: Vec<BorrowedColumn<'py>>,
+    column_by_name: BTreeMap<String, usize>,
+}
+
+impl BorrowedTable<'_> {
+    fn column(&self, name: &str) -> RusticolResult<&BorrowedValues<'_>> {
+        let index = self.column_by_name.get(name).ok_or_else(|| {
+            RusticolError::invalid_argument(format!(
+                "eager lowering table {:?} has no column {name:?}",
+                self.name
+            ))
+        })?;
+        Ok(&self.columns[*index].values)
+    }
+}
+
+struct BorrowedInput<'py> {
+    abi: String,
+    process_key: String,
+    model_name: String,
+    string_catalog: Vec<String>,
+    canonical_ir_catalog: Vec<String>,
+    semantic_limitations: Vec<String>,
+    tables: Vec<BorrowedTable<'py>>,
+    table_by_name: BTreeMap<String, usize>,
+    digest: String,
+}
+
+impl BorrowedInput<'_> {
+    fn table(&self, name: &str) -> RusticolResult<&BorrowedTable<'_>> {
+        let index = self.table_by_name.get(name).ok_or_else(|| {
+            RusticolError::invalid_argument(format!("eager lowering input has no table {name:?}"))
+        })?;
+        Ok(&self.tables[*index])
+    }
+
+    fn column(&self, table: &str, column: &str) -> RusticolResult<&BorrowedValues<'_>> {
+        self.table(table)?.column(column)
+    }
+
+    fn into_core_input(&self) -> RusticolResult<EagerLoweringInputV1> {
+        let strings = self
+            .string_catalog
+            .iter()
+            .map(String::as_str)
+            .collect::<Vec<_>>();
+        let canonical_ir = self
+            .canonical_ir_catalog
+            .iter()
+            .map(String::as_str)
+            .collect::<Vec<_>>();
+        let limitations = self
+            .semantic_limitations
+            .iter()
+            .map(String::as_str)
+            .collect::<Vec<_>>();
+        let retained_columns =
+            self.tables
+                .iter()
+                .map(|table| {
+                    table
+                        .columns
+                        .iter()
+                        .filter(|column| !is_consumed_column(&table.name, &column.name))
+                        .map(|column| {
+                            let elements_per_row = column.shape.iter().skip(1).try_fold(
+                                1_u32,
+                                |product, dimension| {
+                                    let dimension = u32::try_from(*dimension).map_err(|_| {
+                                        RusticolError::invalid_argument(format!(
+                                            "{}.{} trailing shape exceeds u32",
+                                            table.name, column.name
+                                        ))
+                                    })?;
+                                    product.checked_mul(dimension).ok_or_else(|| {
+                                        RusticolError::invalid_argument(format!(
+                                            "{}.{} elements per row exceed u32",
+                                            table.name, column.name
+                                        ))
+                                    })
+                                },
+                            )?;
+                            Ok(EagerRetainedColumnView {
+                                name: &column.name,
+                                elements_per_row,
+                                values: column.values.primitive_view()?,
+                            })
+                        })
+                        .collect::<RusticolResult<Vec<_>>>()
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+        let retained_tables = self
+            .tables
+            .iter()
+            .zip(&retained_columns)
+            .map(|(table, columns)| EagerRetainedTableView {
+                name: &table.name,
+                row_count: table.row_count,
+                columns,
+            })
+            .collect::<Vec<_>>();
+        let u8c = |table, column| {
+            self.column(table, column)?
+                .as_u8(&format!("{table}.{column}"))
+        };
+        let u8x2 = |table, column| -> RusticolResult<&[[u8; 2]]> {
+            let values = u8c(table, column)?;
+            if values.len() % 2 != 0 {
+                return Err(RusticolError::invalid_argument(format!(
+                    "{table}.{column} has an invalid flattened shape"
+                )));
+            }
+            Ok(unsafe {
+                std::slice::from_raw_parts(values.as_ptr().cast::<[u8; 2]>(), values.len() / 2)
+            })
+        };
+        let u32c = |table, column| {
+            self.column(table, column)?
+                .as_u32(&format!("{table}.{column}"))
+        };
+        let u64c = |table, column| {
+            self.column(table, column)?
+                .as_u64(&format!("{table}.{column}"))
+        };
+        let i32c = |table, column| {
+            self.column(table, column)?
+                .as_i32(&format!("{table}.{column}"))
+        };
+        let f64c = |table, column| {
+            self.column(table, column)?
+                .as_f64(&format!("{table}.{column}"))
+        };
+        let contraction = self.table("color_contraction_metadata")?;
+        if contraction.row_count != 1 {
+            return Err(RusticolError::invalid_argument(
+                "color_contraction_metadata must contain exactly one row",
+            ));
+        }
+        EagerLoweringInputV1::try_from_view(EagerLoweringInputV1View {
+            abi: &self.abi,
+            process_key: &self.process_key,
+            model_name: &self.model_name,
+            string_catalog: &strings,
+            canonical_ir_catalog: &canonical_ir,
+            semantic_limitations: &limitations,
+            retained_tables: &retained_tables,
+            unsupported_tables: &[],
+            currents: EagerCurrentColumns {
+                id: u32c("currents", "id")?,
+                dimension: u32c("currents", "dimension")?,
+                is_source: u8c("currents", "is_source")?,
+                momentum_mask_bitset_id: u32c("currents", "momentum_mask_bitset_id")?,
+                propagator_ir_id: u32c("currents", "propagator_ir_id")?,
+                propagator_kernel_id: u32c("currents", "propagator_kernel_id")?,
+            },
+            sources: EagerSourceColumns {
+                source_id: u32c("sources", "source_id")?,
+                current_id: u32c("sources", "current_id")?,
+                external_label: u32c("sources", "external_label")?,
+                input_momentum_slot: u32c("sources", "input_momentum_slot")?,
+                source_ir_id: u32c("sources", "source_ir_id")?,
+                crossing_ir_id: u32c("sources", "crossing_ir_id")?,
+                crossing_factor_id: u32c("sources", "crossing_factor_id")?,
+                declared_state_index: u32c("sources", "declared_state_index")?,
+            },
+            interactions: EagerInteractionColumns {
+                id: u32c("interactions", "id")?,
+                stage_subset_size: u32c("interactions", "stage_subset_size")?,
+                left_current_id: u32c("interactions", "left_current_id")?,
+                right_current_id: u32c("interactions", "right_current_id")?,
+                result_current_id: u32c("interactions", "result_current_id")?,
+                coupling_id: u32c("interactions", "coupling_id")?,
+                coupling_factor_id: u32c("interactions", "coupling_factor_id")?,
+                color_factor_id: u32c("interactions", "color_factor_id")?,
+                evaluation_factor_id: u32c("interactions", "evaluation_factor_id")?,
+                evaluation_group_id: u32c("interactions", "evaluation_group_id")?,
+                full_tensor_network_ready: u8c("interactions", "full_tensor_network_ready")?,
+                kernel_id: u32c("interactions", "kernel_id")?,
+                canonical_input_order: u8x2("interactions", "canonical_input_order")?,
+                kernel_normalization_factor_id: u32c(
+                    "interactions",
+                    "kernel_normalization_factor_id",
+                )?,
+                output_factor_source: u8c("interactions", "output_factor_source")?,
+            },
+            roots: EagerRootColumns {
+                id: u32c("roots", "id")?,
+                left_current_id: u32c("roots", "left_current_id")?,
+                right_current_id: u32c("roots", "right_current_id")?,
+                color_factor_id: u32c("roots", "color_factor_id")?,
+                contraction_ir_id: u32c("roots", "contraction_ir_id")?,
+                coupling_id: u32c("roots", "coupling_id")?,
+                coupling_factor_id: u32c("roots", "coupling_factor_id")?,
+                helicity_weight_factor_id: u32c("roots", "helicity_weight_factor_id")?,
+                coherent_group_id: u32c("roots", "coherent_group_id")?,
+                kernel_id: u32c("roots", "kernel_id")?,
+                canonical_input_order: u8x2("roots", "canonical_input_order")?,
+                kernel_normalization_factor_id: u32c("roots", "kernel_normalization_factor_id")?,
+                output_factor_source: u8c("roots", "output_factor_source")?,
+            },
+            interaction_groups: EagerInteractionGroupColumns {
+                representative_interaction_id: u32c(
+                    "interaction_groups",
+                    "representative_interaction_id",
+                )?,
+                member_start: u64c("interaction_groups", "member_start")?,
+                member_count: u64c("interaction_groups", "member_count")?,
+                member_interaction_id: u32c("interaction_group_members", "interaction_id")?,
+            },
+            momentum_masks: EagerMomentumMaskColumns {
+                slot_id: u32c("momentum_masks", "slot_id")?,
+                bitset_id: u32c("momentum_masks", "bitset_id")?,
+            },
+            bitsets: EagerBitsetColumns {
+                start: u64c("bitset_ranges", "start")?,
+                count: u64c("bitset_ranges", "count")?,
+                bit_count: u64c("bitset_ranges", "bit_count")?,
+                words: u64c("bitset_words", "value")?,
+            },
+            u32_sequences: EagerU32SequenceColumns {
+                start: u64c("u32_sequence_ranges", "start")?,
+                count: u64c("u32_sequence_ranges", "count")?,
+                values: u32c("u32_sequence_values", "value")?,
+            },
+            i32_sequences: EagerI32SequenceColumns {
+                start: u64c("i32_sequence_ranges", "start")?,
+                count: u64c("i32_sequence_ranges", "count")?,
+                values: i32c("i32_sequence_values", "value")?,
+            },
+            exact_factors: EagerExactFactorColumns {
+                real: f64c("exact_factors", "real")?,
+                imaginary: f64c("exact_factors", "imaginary")?,
+                canonical_string_id: u32c("exact_factors", "canonical_string_id")?,
+                exact_source: u8c("exact_factors", "exact_source")?,
+                exact_ir_id: u32c("exact_factors", "exact_ir_id")?,
+                source_ir_id: u32c("exact_factors", "source_ir_id")?,
+            },
+            couplings: EagerCouplingColumns {
+                constant_factor_id: u32c("couplings", "constant_factor_id")?,
+                parameter_name_ids_sequence_id: u32c(
+                    "couplings",
+                    "parameter_name_ids_sequence_id",
+                )?,
+            },
+            model_parameters: EagerModelParameterColumns {
+                name_string_id: u32c("model_parameters", "name_string_id")?,
+                kind_string_id: u32c("model_parameters", "kind_string_id")?,
+                default_value: f64c("model_parameters", "default_value")?,
+                default_factor_id: u32c("model_parameters", "default_factor_id")?,
+                runtime_name_string_id: u32c("model_parameters", "runtime_name_string_id")?,
+                complex_component: i32c("model_parameters", "complex_component")?,
+                derived: u8c("model_parameters", "derived")?,
+            },
+            contraction_coefficients: EagerContractionCoefficientColumns {
+                contraction_ir_id: u32c("contraction_coefficients", "contraction_ir_id")?,
+                component_index: u32c("contraction_coefficients", "component_index")?,
+                factor_id: u32c("contraction_coefficients", "factor_id")?,
+            },
+            coherent_groups: EagerCoherentGroupColumns {
+                id: u32c("coherent_groups", "id")?,
+                helicity_weight_factor_id: u32c("coherent_groups", "helicity_weight_factor_id")?,
+                all_sector_weight_factor_id: u32c(
+                    "coherent_groups",
+                    "all_sector_weight_factor_id",
+                )?,
+            },
+            helicity_selectors: EagerHelicitySelectorColumns {
+                values_sequence_id: u32c("helicity_selectors", "values_sequence_id")?,
+                representative_sequence_id: u32c(
+                    "helicity_selectors",
+                    "representative_sequence_id",
+                )?,
+                coefficient_factor_id: u32c("helicity_selectors", "coefficient_factor_id")?,
+                computed: u8c("helicity_selectors", "computed")?,
+                structural_zero: u8c("helicity_selectors", "structural_zero")?,
+            },
+            color_selectors: EagerColorSelectorColumns {
+                word_sequence_id: u32c("color_selectors", "word_sequence_id")?,
+                representative_word_sequence_id: u32c(
+                    "color_selectors",
+                    "representative_word_sequence_id",
+                )?,
+                coefficient_factor_id: u32c("color_selectors", "coefficient_factor_id")?,
+                computed: u8c("color_selectors", "computed")?,
+            },
+            reduction_members: EagerReductionMemberColumns {
+                coherent_group_id: u32c("reduction_members", "coherent_group_id")?,
+                helicity_selector_id: u32c("reduction_members", "helicity_selector_id")?,
+                color_selector_id: u32c("reduction_members", "color_selector_id")?,
+            },
+            color_contraction: EagerColorContractionMetadata {
+                present: u8c("color_contraction_metadata", "present")?[0],
+                supported: u8c("color_contraction_metadata", "supported")?[0],
+                group_count: u64c("color_contraction_metadata", "group_count")?[0],
+                includes_color_factor: u8c("color_contraction_metadata", "includes_color_factor")?
+                    [0],
+            },
+            color_contraction_entries: EagerColorContractionEntryColumns {
+                left_group_id: u32c("color_contraction_entries", "left_group_id")?,
+                right_group_id: u32c("color_contraction_entries", "right_group_id")?,
+                weight_factor_id: u32c("color_contraction_entries", "weight_factor_id")?,
+                symmetry_factor_id: u32c("color_contraction_entries", "symmetry_factor_id")?,
+            },
+        })
+    }
+}
+
+#[pyfunction]
+pub(crate) fn _lower_eager_runtime_v1(
+    py: Python<'_>,
+    lowering_input: &Bound<'_, PyAny>,
+    destination: PathBuf,
+) -> PyResult<Py<PyAny>> {
+    let borrowed = parse_input(lowering_input)?;
+    let owned = borrowed.into_core_input().map_err(python_error)?;
+    let input_digest = borrowed.digest.clone();
+    let native = py
+        .detach(move || {
+            let plan = lower_eager_plan_v3(owned)?;
+            let selector_work = plan.selector_work_summary()?;
+            let result = NativeLoweringResult {
+                process_key: plan.process_key().to_owned(),
+                model_name: plan.model_name().to_owned(),
+                current_count: plan.currents().len(),
+                value_count: plan.values().len(),
+                momentum_count: plan.momenta().len(),
+                source_count: plan.sources().len(),
+                parameter_count: plan.parameters().len(),
+                stage_count: plan.stages().len(),
+                coupling_count: plan.couplings().len(),
+                invocation_count: plan.invocations().len(),
+                attachment_count: plan.attachments().len(),
+                finalization_count: plan.finalizations().len(),
+                closure_count: plan.closures().len(),
+                selector_domain_count: plan.selector_domains().len(),
+                reduction_group_count: plan.reduction_groups().len(),
+                reduction_entry_count: plan.reduction_entries().len(),
+                retained_table_count: plan.retained_tables().len(),
+                current_component_count: plan.current_component_count(),
+                value_component_count: plan.value_component_count(),
+                momentum_component_count: plan.momentum_component_count(),
+                selected_flow_selector_count: selector_work.selected_flow_selector_count,
+                selected_flow_current_count: selector_work.selected_flow_worst.current_count,
+                selected_flow_evaluation_count: selector_work.selected_flow_worst.evaluation_count,
+                selected_flow_attachment_count: selector_work.selected_flow_worst.attachment_count,
+                all_flow_selector_count: selector_work.all_flow_selector_count,
+                all_flow_current_count: selector_work.all_flow_worst.current_count,
+                all_flow_evaluation_count: selector_work.all_flow_worst.evaluation_count,
+                all_flow_attachment_count: selector_work.all_flow_worst.attachment_count,
+                contracted_current_count: selector_work.contracted.current_count,
+                contracted_evaluation_count: selector_work.contracted.evaluation_count,
+                contracted_attachment_count: selector_work.contracted.attachment_count,
+                member_count: 0,
+                unpacked_size_bytes: 0,
+                index_sha256: String::new(),
+            };
+            let metadata = write_eager_plan_v3_pacbin(&plan, &destination)?;
+            Ok::<_, RusticolError>(NativeLoweringResult {
+                member_count: metadata.member_count,
+                unpacked_size_bytes: metadata.unpacked_bytes,
+                index_sha256: hex_digest(metadata.index_sha256),
+                ..result
+            })
+        })
+        .map_err(python_error)?;
+    result_mapping(py, &input_digest, native)
+}
+
+fn result_mapping(
+    py: Python<'_>,
+    input_digest: &str,
+    native: NativeLoweringResult,
+) -> PyResult<Py<PyAny>> {
+    let result = PyDict::new(py);
+    result.set_item("kind", RESULT_KIND)?;
+    result.set_item("schema_version", RESULT_SCHEMA_VERSION)?;
+    result.set_item("lowering_input_abi", EAGER_LOWERING_INPUT_ABI)?;
+    result.set_item("lowering_input_sha256", input_digest)?;
+    result.set_item("eager_plan_abi", EAGER_PLAN_ABI)?;
+    result.set_item("runtime_layout_abi", EAGER_RUNTIME_LAYOUT_ABI)?;
+    result.set_item(
+        "required_runtime_capabilities",
+        PyList::new(
+            py,
+            [
+                EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+                EAGER_RUNTIME_CAPABILITY,
+            ],
+        )?,
+    )?;
+    let container = PyDict::new(py);
+    container.set_item("kind", EAGER_RUNTIME_CONTAINER_KIND)?;
+    container.set_item("schema_version", EAGER_RUNTIME_CONTAINER_SCHEMA)?;
+    container.set_item("storage_abi", STORAGE_ABI)?;
+    container.set_item("member_count", native.member_count)?;
+    container.set_item("unpacked_size_bytes", native.unpacked_size_bytes)?;
+    container.set_item("index_sha256", native.index_sha256)?;
+    result.set_item("runtime_container", container)?;
+
+    let inspection = PyDict::new(py);
+    inspection.set_item("execution_mode", "eager")?;
+    inspection.set_item("eager_plan_abi", EAGER_PLAN_ABI)?;
+    inspection.set_item("runtime_layout_abi", EAGER_RUNTIME_LAYOUT_ABI)?;
+    inspection.set_item("process_id", native.process_key)?;
+    inspection.set_item("model_name", native.model_name)?;
+    inspection.set_item("current_count", native.current_count)?;
+    inspection.set_item("value_count", native.value_count)?;
+    inspection.set_item("momentum_count", native.momentum_count)?;
+    inspection.set_item("source_count", native.source_count)?;
+    inspection.set_item("parameter_count", native.parameter_count)?;
+    inspection.set_item("stage_count", native.stage_count)?;
+    inspection.set_item("coupling_count", native.coupling_count)?;
+    inspection.set_item("invocation_count", native.invocation_count)?;
+    inspection.set_item("attachment_count", native.attachment_count)?;
+    inspection.set_item("finalization_count", native.finalization_count)?;
+    inspection.set_item("closure_count", native.closure_count)?;
+    inspection.set_item("selector_domain_count", native.selector_domain_count)?;
+    inspection.set_item("reduction_group_count", native.reduction_group_count)?;
+    inspection.set_item("reduction_entry_count", native.reduction_entry_count)?;
+    inspection.set_item("retained_table_count", native.retained_table_count)?;
+    inspection.set_item("current_component_count", native.current_component_count)?;
+    inspection.set_item("value_component_count", native.value_component_count)?;
+    inspection.set_item("momentum_component_count", native.momentum_component_count)?;
+    let selector_work = PyDict::new(py);
+    selector_work.set_item("abi", SELECTOR_WORK_ABI)?;
+    selector_work.set_item(
+        "selected_flow_selector_count",
+        native.selected_flow_selector_count,
+    )?;
+    selector_work.set_item(
+        "selected_flow_current_count",
+        native.selected_flow_current_count,
+    )?;
+    selector_work.set_item(
+        "selected_flow_evaluation_count",
+        native.selected_flow_evaluation_count,
+    )?;
+    selector_work.set_item(
+        "selected_flow_attachment_count",
+        native.selected_flow_attachment_count,
+    )?;
+    selector_work.set_item("all_flow_selector_count", native.all_flow_selector_count)?;
+    selector_work.set_item("all_flow_current_count", native.all_flow_current_count)?;
+    selector_work.set_item(
+        "all_flow_evaluation_count",
+        native.all_flow_evaluation_count,
+    )?;
+    selector_work.set_item(
+        "all_flow_attachment_count",
+        native.all_flow_attachment_count,
+    )?;
+    selector_work.set_item("contracted_current_count", native.contracted_current_count)?;
+    selector_work.set_item(
+        "contracted_evaluation_count",
+        native.contracted_evaluation_count,
+    )?;
+    selector_work.set_item(
+        "contracted_attachment_count",
+        native.contracted_attachment_count,
+    )?;
+    inspection.set_item("selector_work", selector_work)?;
+    result.set_item("inspection_summary", inspection)?;
+    Ok(result.into_any().unbind())
+}
+
+fn parse_input<'py>(input: &Bound<'py, PyAny>) -> PyResult<BorrowedInput<'py>> {
+    if cfg!(not(target_endian = "little")) {
+        return Err(PyValueError::new_err(
+            "eager lowering input v1 requires a little-endian target",
+        ));
+    }
+    let abi = required_string(input, "abi")?;
+    if abi != EAGER_LOWERING_INPUT_ABI {
+        return Err(PyValueError::new_err(format!(
+            "unsupported eager lowering input ABI {abi:?}"
+        )));
+    }
+    let process_key = nonempty_string(input, "process_key")?;
+    let model_name = nonempty_string(input, "model_name")?;
+    let string_catalog = unique_strings(input, "string_catalog", false)?;
+    let canonical_ir_catalog = unique_strings(input, "canonical_ir_catalog", false)?;
+    let semantic_limitations = unique_strings(input, "semantic_limitations", true)?;
+
+    let mut content_digest = Sha256::new();
+    for value in [&abi, &process_key, &model_name] {
+        hash_text(&mut content_digest, value);
+    }
+    for catalog in [&string_catalog, &canonical_ir_catalog] {
+        hash_u64(&mut content_digest, catalog.len())?;
+        for value in catalog {
+            hash_text(&mut content_digest, value);
+        }
+    }
+
+    let tables_object = input.getattr("tables")?;
+    let table_objects = tables_object
+        .try_iter()
+        .map_err(|_| PyTypeError::new_err("eager lowering tables must be iterable"))?
+        .collect::<PyResult<Vec<_>>>()?;
+    hash_u64(&mut content_digest, table_objects.len())?;
+    let mut schema_digest = Sha256::new();
+    hash_u64(&mut schema_digest, table_objects.len())?;
+    let mut tables = Vec::with_capacity(table_objects.len());
+    let mut table_by_name = BTreeMap::new();
+    let mut previous_table_name: Option<String> = None;
+    for table_object in table_objects {
+        let table_name = nonempty_string(&table_object, "name")?;
+        if previous_table_name
+            .as_deref()
+            .is_some_and(|name| name >= table_name.as_str())
+        {
+            return Err(PyValueError::new_err(
+                "eager lowering table names must be unique and sorted",
+            ));
+        }
+        previous_table_name = Some(table_name.clone());
+        let row_count = table_object.getattr("row_count")?.extract::<u64>()?;
+        hash_text(&mut content_digest, &table_name);
+        content_digest.update(row_count.to_le_bytes());
+        hash_text(&mut schema_digest, &table_name);
+
+        let columns_object = table_object.getattr("columns")?;
+        let column_objects = columns_object
+            .try_iter()
+            .map_err(|_| PyTypeError::new_err("eager lowering columns must be iterable"))?
+            .collect::<PyResult<Vec<_>>>()?;
+        hash_u32(&mut content_digest, column_objects.len())?;
+        hash_u32(&mut schema_digest, column_objects.len())?;
+        let mut columns = Vec::with_capacity(column_objects.len());
+        let mut column_by_name = BTreeMap::new();
+        for column_object in column_objects {
+            let column_name = nonempty_string(&column_object, "name")?;
+            if column_by_name.contains_key(&column_name) {
+                return Err(PyValueError::new_err(format!(
+                    "table {table_name:?} contains duplicate column {column_name:?}"
+                )));
+            }
+            let values_object = column_object.getattr("values")?;
+            let dtype = values_object
+                .getattr("dtype")?
+                .getattr("str")?
+                .extract::<String>()?;
+            let writeable = values_object
+                .getattr("flags")?
+                .getattr("writeable")?
+                .extract::<bool>()?;
+            if writeable {
+                return Err(PyValueError::new_err(format!(
+                    "{table_name}.{column_name} must be read-only"
+                )));
+            }
+            let values = extract_values(&values_object, &dtype, &table_name, &column_name)?;
+            let shape = shape(&values);
+            if shape.is_empty() || u64::try_from(shape[0]).ok() != Some(row_count) {
+                return Err(PyValueError::new_err(format!(
+                    "{table_name}.{column_name} shape does not match row_count"
+                )));
+            }
+            hash_text(&mut content_digest, &column_name);
+            hash_text(&mut content_digest, &dtype);
+            hash_u8(&mut content_digest, shape.len())?;
+            for dimension in &shape {
+                hash_u64(&mut content_digest, *dimension)?;
+            }
+            content_digest.update(values.raw_bytes()?);
+            hash_text(&mut schema_digest, &column_name);
+            hash_text(&mut schema_digest, &dtype);
+            hash_u8(&mut schema_digest, shape.len())?;
+            for dimension in shape.iter().skip(1) {
+                hash_u64(&mut schema_digest, *dimension)?;
+            }
+            column_by_name.insert(column_name.clone(), columns.len());
+            columns.push(BorrowedColumn {
+                name: column_name,
+                shape,
+                values,
+            });
+        }
+        table_by_name.insert(table_name.clone(), tables.len());
+        tables.push(BorrowedTable {
+            name: table_name,
+            row_count,
+            columns,
+            column_by_name,
+        });
+    }
+    let names = tables
+        .iter()
+        .map(|table| table.name.as_str())
+        .collect::<Vec<_>>();
+    if names != EAGER_LOWERING_V1_TABLE_NAMES {
+        return Err(PyValueError::new_err(
+            "eager lowering table inventory does not match input ABI v1",
+        ));
+    }
+    let schema_digest = hex_digest(schema_digest.finalize());
+    if schema_digest != INPUT_SCHEMA_SHA256 {
+        return Err(PyValueError::new_err(format!(
+            "eager lowering table/column schema does not match input ABI v1: {schema_digest}"
+        )));
+    }
+    for limitation in &semantic_limitations {
+        hash_text(&mut content_digest, limitation);
+    }
+    let digest = hex_digest(content_digest.finalize());
+    let declared_digest = required_string(input, "digest")?;
+    if declared_digest != digest {
+        return Err(PyValueError::new_err(
+            "eager lowering input digest does not match its primitive columns",
+        ));
+    }
+    Ok(BorrowedInput {
+        abi,
+        process_key,
+        model_name,
+        string_catalog,
+        canonical_ir_catalog,
+        semantic_limitations,
+        tables,
+        table_by_name,
+        digest,
+    })
+}
+
+fn extract_values<'py>(
+    value: &Bound<'py, PyAny>,
+    dtype: &str,
+    table: &str,
+    column: &str,
+) -> PyResult<BorrowedValues<'py>> {
+    let context = format!("{table}.{column}");
+    macro_rules! extract {
+        ($ty:ty, $variant:ident) => {{
+            let array = value
+                .extract::<PyReadonlyArrayDyn<'py, $ty>>()
+                .map_err(|_| {
+                    PyTypeError::new_err(format!(
+                        "{context} is not a NumPy array with dtype {dtype}"
+                    ))
+                })?;
+            if !array.is_c_contiguous() {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must be C-contiguous"
+                )));
+            }
+            BorrowedValues::$variant(array)
+        }};
+    }
+    match dtype {
+        "|u1" => Ok(extract!(u8, U8)),
+        "<u4" => Ok(extract!(u32, U32)),
+        "<u8" => Ok(extract!(u64, U64)),
+        "<i4" => Ok(extract!(i32, I32)),
+        "<f8" => Ok(extract!(f64, F64)),
+        _ => Err(PyValueError::new_err(format!(
+            "{context} has unsupported dtype {dtype:?}"
+        ))),
+    }
+}
+
+fn shape(values: &BorrowedValues<'_>) -> Vec<usize> {
+    match values {
+        BorrowedValues::U8(array) => array.shape().to_vec(),
+        BorrowedValues::U32(array) => array.shape().to_vec(),
+        BorrowedValues::U64(array) => array.shape().to_vec(),
+        BorrowedValues::I32(array) => array.shape().to_vec(),
+        BorrowedValues::F64(array) => array.shape().to_vec(),
+    }
+}
+
+fn required_string(value: &Bound<'_, PyAny>, attribute: &str) -> PyResult<String> {
+    value
+        .getattr(attribute)?
+        .extract::<String>()
+        .map_err(|_| PyTypeError::new_err(format!("eager lowering {attribute} must be a string")))
+}
+
+fn nonempty_string(value: &Bound<'_, PyAny>, attribute: &str) -> PyResult<String> {
+    let result = required_string(value, attribute)?;
+    if result.is_empty() {
+        return Err(PyValueError::new_err(format!(
+            "eager lowering {attribute} must not be empty"
+        )));
+    }
+    Ok(result)
+}
+
+fn unique_strings(
+    value: &Bound<'_, PyAny>,
+    attribute: &str,
+    require_nonempty: bool,
+) -> PyResult<Vec<String>> {
+    let object = value.getattr(attribute)?;
+    let result = object
+        .try_iter()
+        .map_err(|_| PyTypeError::new_err(format!("{attribute} must be iterable")))?
+        .map(|item| item?.extract::<String>())
+        .collect::<PyResult<Vec<_>>>()?;
+    if require_nonempty && result.is_empty() {
+        return Err(PyValueError::new_err(format!(
+            "{attribute} must not be empty"
+        )));
+    }
+    if result.iter().any(String::is_empty) {
+        return Err(PyValueError::new_err(format!(
+            "{attribute} entries must not be empty"
+        )));
+    }
+    let unique = result.iter().collect::<BTreeSet<_>>();
+    if unique.len() != result.len() {
+        return Err(PyValueError::new_err(format!(
+            "{attribute} contains duplicate strings"
+        )));
+    }
+    Ok(result)
+}
+
+fn is_consumed_column(table: &str, column: &str) -> bool {
+    matches!(
+        (table, column),
+        (
+            "currents",
+            "id" | "dimension"
+                | "is_source"
+                | "momentum_mask_bitset_id"
+                | "propagator_ir_id"
+                | "propagator_kernel_id"
+        ) | (
+            "sources",
+            "source_id"
+                | "current_id"
+                | "external_label"
+                | "input_momentum_slot"
+                | "source_ir_id"
+                | "crossing_ir_id"
+                | "crossing_factor_id"
+                | "declared_state_index"
+        ) | (
+            "interactions",
+            "id" | "stage_subset_size"
+                | "left_current_id"
+                | "right_current_id"
+                | "result_current_id"
+                | "coupling_id"
+                | "coupling_factor_id"
+                | "color_factor_id"
+                | "evaluation_factor_id"
+                | "evaluation_group_id"
+                | "full_tensor_network_ready"
+                | "kernel_id"
+                | "canonical_input_order"
+                | "kernel_normalization_factor_id"
+                | "output_factor_source"
+        ) | (
+            "roots",
+            "id" | "left_current_id"
+                | "right_current_id"
+                | "color_factor_id"
+                | "contraction_ir_id"
+                | "coupling_id"
+                | "coupling_factor_id"
+                | "helicity_weight_factor_id"
+                | "coherent_group_id"
+                | "kernel_id"
+                | "canonical_input_order"
+                | "kernel_normalization_factor_id"
+                | "output_factor_source"
+        ) | (
+            "interaction_groups",
+            "representative_interaction_id" | "member_start" | "member_count"
+        ) | ("interaction_group_members", "interaction_id")
+            | ("momentum_masks", "slot_id" | "bitset_id")
+            | ("bitset_ranges", "start" | "count" | "bit_count")
+            | ("bitset_words", "value")
+            | ("u32_sequence_ranges", "start" | "count")
+            | ("u32_sequence_values", "value")
+            | ("i32_sequence_ranges", "start" | "count")
+            | ("i32_sequence_values", "value")
+            | (
+                "exact_factors",
+                "real"
+                    | "imaginary"
+                    | "canonical_string_id"
+                    | "exact_source"
+                    | "exact_ir_id"
+                    | "source_ir_id"
+            )
+            | (
+                "couplings",
+                "constant_factor_id" | "parameter_name_ids_sequence_id"
+            )
+            | (
+                "model_parameters",
+                "name_string_id"
+                    | "kind_string_id"
+                    | "default_value"
+                    | "default_factor_id"
+                    | "runtime_name_string_id"
+                    | "complex_component"
+                    | "derived"
+            )
+            | (
+                "contraction_coefficients",
+                "contraction_ir_id" | "component_index" | "factor_id"
+            )
+            | (
+                "coherent_groups",
+                "id" | "helicity_weight_factor_id" | "all_sector_weight_factor_id"
+            )
+            | (
+                "helicity_selectors",
+                "values_sequence_id"
+                    | "representative_sequence_id"
+                    | "coefficient_factor_id"
+                    | "computed"
+                    | "structural_zero"
+            )
+            | (
+                "color_selectors",
+                "word_sequence_id"
+                    | "representative_word_sequence_id"
+                    | "coefficient_factor_id"
+                    | "computed"
+            )
+            | (
+                "reduction_members",
+                "coherent_group_id" | "helicity_selector_id" | "color_selector_id"
+            )
+            | (
+                "color_contraction_metadata",
+                "present" | "supported" | "group_count" | "includes_color_factor"
+            )
+            | (
+                "color_contraction_entries",
+                "left_group_id" | "right_group_id" | "weight_factor_id" | "symmetry_factor_id"
+            )
+    )
+}
+
+fn hash_text(digest: &mut Sha256, value: &str) {
+    digest.update((value.len() as u64).to_le_bytes());
+    digest.update(value.as_bytes());
+}
+
+fn hash_u8(digest: &mut Sha256, value: usize) -> PyResult<()> {
+    digest
+        .update([u8::try_from(value)
+            .map_err(|_| PyValueError::new_err("eager lowering rank exceeds u8"))?]);
+    Ok(())
+}
+
+fn hash_u32(digest: &mut Sha256, value: usize) -> PyResult<()> {
+    digest.update(
+        u32::try_from(value)
+            .map_err(|_| PyValueError::new_err("eager lowering count exceeds u32"))?
+            .to_le_bytes(),
+    );
+    Ok(())
+}
+
+fn hash_u64(digest: &mut Sha256, value: usize) -> PyResult<()> {
+    digest.update(
+        u64::try_from(value)
+            .map_err(|_| PyValueError::new_err("eager lowering count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    Ok(())
+}
+
+fn hex_digest(value: impl AsRef<[u8]>) -> String {
+    value
+        .as_ref()
+        .iter()
+        .map(|byte| format!("{byte:02x}"))
+        .collect()
+}
+
+fn not_contiguous(error: impl std::fmt::Display) -> PyErr {
+    PyValueError::new_err(format!("NumPy column is not contiguous: {error}"))
+}
+
+fn core_not_contiguous(error: impl std::fmt::Display) -> RusticolError {
+    RusticolError::invalid_argument(format!("NumPy column is not contiguous: {error}"))
+}
+
+fn wrong_type(context: &str, dtype: &str) -> RusticolError {
+    RusticolError::invalid_argument(format!("{context} is not a {dtype} column"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_v1_table_is_classified_for_retention() {
+        assert_eq!(EAGER_LOWERING_V1_TABLE_NAMES.len(), 64);
+        assert!(
+            EAGER_LOWERING_V1_TABLE_NAMES
+                .windows(2)
+                .all(|pair| pair[0] < pair[1])
+        );
+        for table in [
+            "color_replay_contraction_component_groups",
+            "color_replay_contraction_entries",
+            "color_replay_contraction_metadata",
+            "color_replay_mappings",
+            "color_replay_metadata",
+            "color_replay_permutations",
+            "color_replay_physical_groups",
+            "color_replay_routes",
+        ] {
+            assert!(EAGER_LOWERING_V1_TABLE_NAMES.contains(&table));
+        }
+    }
+
+    #[test]
+    fn consumed_columns_are_narrow_and_explicit() {
+        assert!(is_consumed_column("currents", "id"));
+        assert!(is_consumed_column("interactions", "canonical_input_order"));
+        assert!(!is_consumed_column("currents", "particle_id"));
+        assert!(!is_consumed_column("metadata", "process_ir_id"));
+        assert!(!is_consumed_column(
+            "helicity_source_mappings",
+            "source_contract_digest_string_id"
+        ));
+        assert!(!is_consumed_column(
+            "helicity_materialized_schedules",
+            "active_current_sequence_id"
+        ));
+        assert!(!is_consumed_column(
+            "lc_replay_partitions",
+            "proof_digest_string_id"
+        ));
+        assert!(!is_consumed_column(
+            "color_replay_metadata",
+            "physical_group_count"
+        ));
+        assert!(!is_consumed_column(
+            "color_replay_routes",
+            "source_group_id"
+        ));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-python/src/lib.rs b/pyamplicol/rust/crates/rusticol-python/src/lib.rs
new file mode 100644
index 0000000000..46ee8ec18a
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/src/lib.rs
@@ -0,0 +1,2511 @@
+// SPDX-License-Identifier: 0BSD
+
+#[cfg(feature = "numpy")]
+mod eager_lowering;
+#[cfg(feature = "numpy")]
+mod recurrence;
+#[cfg(feature = "numpy")]
+mod recurrence_numerical_evidence;
+#[cfg(feature = "numpy")]
+mod recurrence_template;
+
+#[cfg(feature = "numpy")]
+use numpy::{PyReadonlyArray3, PyUntypedArrayMethods};
+use pyo3::IntoPyObjectExt;
+use pyo3::create_exception;
+use pyo3::exceptions::{PyException, PyTypeError, PyValueError};
+use pyo3::prelude::*;
+use pyo3::types::{PyAny, PyBool, PyBytes, PyDict, PyInt, PyList, PyTuple};
+use rusticol_core::__private::{
+    build_recurrence_bootstrap_image_v1, compile_symbolica_program_to_plane_application_bytes,
+};
+use rusticol_core::{
+    ColorAccuracy, ColorComponent as CoreColorComponent, ModelParameter as CoreModelParameter,
+    NativeOnTheFlyWarmUpEvent, NativeOnTheFlyWarmUpEventKind, NativeOnTheFlyWarmUpObserver,
+    NativeOnTheFlyWarmUpStage, NativeResolvedEvaluation, NativeRuntime, NativeRuntimeProfile,
+    ParameterKind, ParticleRole, ProcessPhysics as CoreProcessPhysics, ReductionKind,
+    RusticolError as CoreError, RusticolErrorKind,
+    eager_direct_descriptor_for_source_application_bytes, preflight_prepared_kernel_pack,
+    runtime_target_info,
+};
+use serde_json::Value;
+use std::collections::BTreeMap;
+use std::marker::PhantomData;
+use std::path::PathBuf;
+use std::ptr::NonNull;
+use std::sync::{Arc, Mutex};
+use std::thread::{self, ThreadId};
+
+create_exception!(_rusticol, RusticolError, PyException);
+create_exception!(_rusticol, ArtifactError, RusticolError);
+create_exception!(_rusticol, CompatibilityError, RusticolError);
+create_exception!(_rusticol, EvaluationError, RusticolError);
+create_exception!(_rusticol, SelectorError, EvaluationError);
+create_exception!(_rusticol, ModelParameterError, EvaluationError);
+
+#[pyclass(module = "pyamplicol._rusticol", frozen, get_all, skip_from_py_object)]
+#[derive(Clone)]
+struct TargetInfo {
+    triple: String,
+    cpu_features: Vec<String>,
+}
+
+fn python_error(error: CoreError) -> PyErr {
+    let message = error.to_string();
+    match error.kind() {
+        RusticolErrorKind::InvalidArgument => PyValueError::new_err(message),
+        RusticolErrorKind::Artifact
+        | RusticolErrorKind::Security
+        | RusticolErrorKind::Integrity
+        | RusticolErrorKind::Serialization => ArtifactError::new_err(message),
+        RusticolErrorKind::Compatibility
+        | RusticolErrorKind::UnsupportedPrecision
+        | RusticolErrorKind::UnsupportedRuntimeCapability => CompatibilityError::new_err(message),
+        RusticolErrorKind::Selector => SelectorError::new_err(message),
+        RusticolErrorKind::ModelParameter => ModelParameterError::new_err(message),
+        RusticolErrorKind::Evaluation | RusticolErrorKind::Internal => {
+            EvaluationError::new_err(message)
+        }
+        _ => EvaluationError::new_err(message),
+    }
+}
+
+fn require_raw_f64_precision(precision: u32) -> Result<(), CoreError> {
+    if precision == 16 {
+        return Ok(());
+    }
+    Err(CoreError::compatibility(format!(
+        "raw pyamplicol._rusticol supports only precision=16 for Symbolica-free direct SymJIT evaluation; precision={precision} must be routed through the public Python Symbolica executor"
+    )))
+}
+
+fn report_on_the_fly_warm_up_progress(
+    callback: &Py<PyAny>,
+    callback_error: &Mutex<Option<PyErr>>,
+    event: &NativeOnTheFlyWarmUpEvent,
+) -> Result<bool, CoreError> {
+    let payload = serde_json::to_string(event).map_err(|error| {
+        CoreError::serialization(format!(
+            "could not serialize on-the-fly warm-up progress event: {error}"
+        ))
+    })?;
+    let terminal_notification = event.kind == NativeOnTheFlyWarmUpEventKind::End
+        && event.stage == NativeOnTheFlyWarmUpStage::FirstEvaluation;
+    Python::attach(|py| {
+        let decision = callback.bind(py).call1((payload,));
+        let decision = match decision {
+            Ok(decision) => decision,
+            Err(error) if terminal_notification => {
+                error.write_unraisable(py, Some(callback.bind(py)));
+                return Ok(true);
+            }
+            Err(error) => {
+                let message = error.to_string();
+                let mut slot = callback_error.lock().map_err(|_| {
+                    CoreError::internal("on-the-fly warm-up callback error lock was poisoned")
+                })?;
+                *slot = Some(error);
+                return Err(CoreError::evaluation(format!(
+                    "on-the-fly warm-up progress callback failed: {message}"
+                )));
+            }
+        };
+        if decision.is_none() {
+            return Ok(true);
+        }
+        if !decision.is_instance_of::<PyBool>() {
+            let error = PyTypeError::new_err(
+                "on-the-fly warm-up progress callback must return bool or None",
+            );
+            if terminal_notification {
+                error.write_unraisable(py, Some(callback.bind(py)));
+                return Ok(true);
+            }
+            let mut slot = callback_error.lock().map_err(|_| {
+                CoreError::internal("on-the-fly warm-up callback error lock was poisoned")
+            })?;
+            *slot = Some(error);
+            return Err(CoreError::invalid_argument(
+                "on-the-fly warm-up progress callback must return bool or None",
+            ));
+        }
+        decision.extract::<bool>().map_err(|error| {
+            CoreError::invalid_argument(format!(
+                "could not read on-the-fly warm-up progress decision: {error}"
+            ))
+        })
+    })
+}
+
+#[pyclass(module = "pyamplicol._rusticol", frozen, get_all, skip_from_py_object)]
+#[derive(Clone)]
+struct ExternalParticle {
+    index: usize,
+    label: usize,
+    name: String,
+    pdg_id: i32,
+    state: String,
+    momentum_slot: usize,
+}
+
+#[pyclass(module = "pyamplicol._rusticol", frozen, get_all, skip_from_py_object)]
+#[derive(Clone)]
+struct HelicityConfiguration {
+    id: String,
+    index: usize,
+    values: Vec<i32>,
+    computed: bool,
+    structural_zero: bool,
+    representative_id: String,
+    coefficient: f64,
+}
+
+#[pyclass(module = "pyamplicol._rusticol", frozen, get_all, skip_from_py_object)]
+#[derive(Clone)]
+struct ColorFlow {
+    id: String,
+    index: usize,
+    word: Vec<usize>,
+    computed: bool,
+    representative_id: String,
+    coefficient: f64,
+}
+
+#[pyclass(module = "pyamplicol._rusticol", frozen, get_all, skip_from_py_object)]
+#[derive(Clone)]
+struct ContractedColorComponent {
+    id: String,
+    index: usize,
+    description: String,
+}
+
+#[pyclass(module = "pyamplicol._rusticol", frozen, get_all, skip_from_py_object)]
+#[derive(Clone)]
+struct ModelParameter {
+    name: String,
+    kind: String,
+    default_real: f64,
+    default_imaginary: f64,
+    mutable: bool,
+}
+
+#[pyclass(module = "pyamplicol._rusticol", frozen, get_all, skip_from_py_object)]
+#[derive(Clone)]
+struct ReductionGroup {
+    id: String,
+    representative_helicity_id: String,
+    representative_color_id: String,
+    physical_helicity_ids: Vec<String>,
+    physical_color_ids: Vec<String>,
+}
+
+#[pyclass(module = "pyamplicol._rusticol", frozen, get_all, skip_from_py_object)]
+#[derive(Clone)]
+struct PhysicsReduction {
+    kind: String,
+    groups: Vec<ReductionGroup>,
+}
+
+impl From<&CoreModelParameter> for ModelParameter {
+    fn from(parameter: &CoreModelParameter) -> Self {
+        Self {
+            name: parameter.name.clone(),
+            kind: parameter_kind_name(parameter.kind).to_string(),
+            default_real: parameter.default_real,
+            default_imaginary: parameter.default_imaginary,
+            mutable: parameter.mutable,
+        }
+    }
+}
+
+#[pyclass(module = "pyamplicol._rusticol", frozen, skip_from_py_object)]
+#[derive(Clone)]
+struct ProcessPhysics {
+    process_id: String,
+    process: String,
+    color_accuracy: String,
+    helicity_coverage: String,
+    color_coverage: String,
+    color_kind: String,
+    structural_zero_helicity_count: usize,
+    external_particles: Vec<ExternalParticle>,
+    helicities: Vec<HelicityConfiguration>,
+    color_flows: Vec<ColorFlow>,
+    contracted_color_components: Vec<ContractedColorComponent>,
+    reduction: PhysicsReduction,
+    model_parameters: Vec<ModelParameter>,
+    selector_capabilities: Vec<String>,
+}
+
+impl ProcessPhysics {
+    fn from_core(physics: &CoreProcessPhysics) -> Self {
+        let external_particles = physics
+            .external_particles
+            .iter()
+            .map(|particle| ExternalParticle {
+                index: particle.index,
+                label: particle.label,
+                name: particle.particle.clone(),
+                pdg_id: particle.pdg,
+                state: match particle.role {
+                    ParticleRole::Initial => "incoming",
+                    ParticleRole::Final => "outgoing",
+                }
+                .to_string(),
+                momentum_slot: particle.momentum_slot,
+            })
+            .collect();
+        let helicities = physics
+            .helicities
+            .iter()
+            .map(|helicity| HelicityConfiguration {
+                id: helicity.id.clone(),
+                index: helicity.index,
+                values: helicity.values.clone(),
+                computed: helicity.computed,
+                structural_zero: helicity.structural_zero,
+                representative_id: helicity.representative_id.clone(),
+                coefficient: helicity.coefficient,
+            })
+            .collect();
+        let color_flows = physics
+            .color_components
+            .iter()
+            .filter_map(|component| match component {
+                CoreColorComponent::LcFlow(flow) => Some(ColorFlow {
+                    id: flow.id.clone(),
+                    index: flow.index,
+                    word: flow.word.clone(),
+                    computed: flow.computed,
+                    representative_id: flow.representative_id.clone(),
+                    coefficient: flow.coefficient,
+                }),
+                CoreColorComponent::ContractedColor(_) => None,
+            })
+            .collect();
+        let contracted_color_components = physics
+            .color_components
+            .iter()
+            .filter_map(|component| match component {
+                CoreColorComponent::ContractedColor(color) => Some(ContractedColorComponent {
+                    id: color.id.clone(),
+                    index: color.index,
+                    description: color.description.clone(),
+                }),
+                CoreColorComponent::LcFlow(_) => None,
+            })
+            .collect();
+        let mut selector_capabilities = Vec::new();
+        if physics.selectors.helicity {
+            selector_capabilities.push("helicity".to_string());
+        }
+        if physics.selectors.color_flow {
+            selector_capabilities.push("color_flow".to_string());
+        }
+        if physics.selectors.contracted_color {
+            selector_capabilities.push("contracted_color".to_string());
+        }
+        let reduction = PhysicsReduction {
+            kind: reduction_kind_name(physics.reduction.kind).to_string(),
+            groups: physics
+                .reduction
+                .groups
+                .iter()
+                .map(|group| ReductionGroup {
+                    id: group.id.clone(),
+                    representative_helicity_id: group.representative_helicity_id.clone(),
+                    representative_color_id: group.representative_color_id.clone(),
+                    physical_helicity_ids: group.physical_helicity_ids.clone(),
+                    physical_color_ids: group.physical_color_ids.clone(),
+                })
+                .collect(),
+        };
+        Self {
+            process_id: physics.process_id.clone(),
+            process: physics.process.clone(),
+            color_accuracy: color_accuracy_name(physics.color_accuracy).to_string(),
+            helicity_coverage: physics.coverage.helicities.clone(),
+            color_coverage: physics.coverage.color.clone(),
+            color_kind: physics.coverage.color_kind.clone(),
+            structural_zero_helicity_count: physics.coverage.structural_zero_helicity_count,
+            external_particles,
+            helicities,
+            color_flows,
+            contracted_color_components,
+            reduction,
+            model_parameters: physics.model_parameters.iter().map(Into::into).collect(),
+            selector_capabilities,
+        }
+    }
+}
+
+#[pymethods]
+impl ProcessPhysics {
+    #[getter]
+    fn process_id(&self) -> &str {
+        &self.process_id
+    }
+
+    #[getter]
+    fn process(&self) -> &str {
+        &self.process
+    }
+
+    #[getter]
+    fn color_accuracy(&self) -> &str {
+        &self.color_accuracy
+    }
+
+    #[getter]
+    fn helicity_coverage(&self) -> &str {
+        &self.helicity_coverage
+    }
+
+    #[getter]
+    fn color_coverage(&self) -> &str {
+        &self.color_coverage
+    }
+
+    #[getter]
+    fn color_kind(&self) -> &str {
+        &self.color_kind
+    }
+
+    #[getter]
+    fn structural_zero_helicity_count(&self) -> usize {
+        self.structural_zero_helicity_count
+    }
+
+    #[getter]
+    fn external_particles(&self) -> Vec<ExternalParticle> {
+        self.external_particles.clone()
+    }
+
+    #[getter]
+    fn helicities(&self) -> Vec<HelicityConfiguration> {
+        self.helicities.clone()
+    }
+
+    #[getter]
+    fn color_flows(&self) -> Vec<ColorFlow> {
+        self.color_flows.clone()
+    }
+
+    #[getter]
+    fn contracted_color_components(&self) -> Vec<ContractedColorComponent> {
+        self.contracted_color_components.clone()
+    }
+
+    #[getter]
+    fn reduction(&self) -> PhysicsReduction {
+        self.reduction.clone()
+    }
+
+    #[getter]
+    fn model_parameters(&self) -> Vec<ModelParameter> {
+        self.model_parameters.clone()
+    }
+
+    #[getter]
+    fn selector_capabilities(&self) -> Vec<String> {
+        self.selector_capabilities.clone()
+    }
+}
+
+#[pyclass(module = "pyamplicol._rusticol", unsendable)]
+struct ResolvedEvaluation {
+    values: Py<PyAny>,
+    totals: Py<PyAny>,
+    shape: (usize, usize, usize),
+    helicity_ids: Vec<String>,
+    color_ids: Vec<String>,
+    color_accuracy: String,
+    precision: u32,
+}
+
+#[pymethods]
+impl ResolvedEvaluation {
+    #[getter]
+    fn values(&self, py: Python<'_>) -> Py<PyAny> {
+        self.values.clone_ref(py)
+    }
+
+    #[getter]
+    fn shape(&self) -> (usize, usize, usize) {
+        self.shape
+    }
+
+    #[getter]
+    fn helicity_ids(&self) -> Vec<String> {
+        self.helicity_ids.clone()
+    }
+
+    #[getter]
+    fn color_ids(&self) -> Vec<String> {
+        self.color_ids.clone()
+    }
+
+    #[getter]
+    fn color_flow_ids(&self) -> Vec<String> {
+        if self.color_accuracy == "lc" {
+            self.color_ids.clone()
+        } else {
+            Vec::new()
+        }
+    }
+
+    #[getter]
+    fn color_accuracy(&self) -> &str {
+        &self.color_accuracy
+    }
+
+    #[getter]
+    fn precision(&self) -> u32 {
+        self.precision
+    }
+
+    fn total(&self, py: Python<'_>) -> Py<PyAny> {
+        self.totals.clone_ref(py)
+    }
+}
+
+#[pyclass(module = "pyamplicol._rusticol", unsendable)]
+struct Runtime {
+    runtime: NativeRuntime,
+}
+
+/// An exclusive `NativeRuntime` borrow which stable PyO3 can carry through
+/// [`Python::detach`].
+///
+/// Stable PyO3 conservatively uses `Send` as its `Ungil` bound even though
+/// `detach` invokes its closure synchronously on the calling thread. The
+/// native runtime is deliberately `!Send`, so this adapter retains its Rust
+/// borrow for the whole detached call and permits access only on the thread
+/// which created it.
+struct SameThreadNativeRuntimeBorrow<'a> {
+    runtime: NonNull<NativeRuntime>,
+    origin: ThreadId,
+    _exclusive: PhantomData<&'a mut NativeRuntime>,
+}
+
+fn require_origin_thread(origin: ThreadId) -> Result<(), CoreError> {
+    if thread::current().id() == origin {
+        return Ok(());
+    }
+    Err(CoreError::internal(
+        "detached NativeRuntime operation moved away from its owning thread",
+    ))
+}
+
+impl<'a> SameThreadNativeRuntimeBorrow<'a> {
+    fn new(runtime: &'a mut NativeRuntime) -> Self {
+        Self {
+            runtime: NonNull::from(runtime),
+            origin: thread::current().id(),
+            _exclusive: PhantomData,
+        }
+    }
+
+    fn run<R>(mut self, operation: impl FnOnce(&mut NativeRuntime) -> R) -> Result<R, CoreError> {
+        require_origin_thread(self.origin)?;
+        // SAFETY: `new` receives an exclusive borrow whose lifetime is retained
+        // by `_exclusive`. This consuming method can create only one mutable
+        // reborrow, and the thread check above prevents dereferencing the
+        // deliberately thread-affine runtime from any other thread.
+        Ok(operation(unsafe { self.runtime.as_mut() }))
+    }
+}
+
+// SAFETY: transferring the adapter cannot transfer, move, drop, or access the
+// borrowed runtime. `run` is its only accessor and checks the creating thread
+// before dereferencing; dropping the adapter never touches the pointee. The
+// lifetime marker continues to enforce exclusive access on the creating stack.
+unsafe impl Send for SameThreadNativeRuntimeBorrow<'_> {}
+
+// These signatures intentionally mirror the keyword-rich public Python ABI.
+#[allow(clippy::too_many_arguments)]
+#[pymethods]
+impl Runtime {
+    #[new]
+    #[pyo3(signature=(artifact, *, process=None, model_parameters=None, mute_warnings=false))]
+    fn new(
+        artifact: &Bound<'_, PyAny>,
+        process: Option<&str>,
+        model_parameters: Option<&Bound<'_, PyAny>>,
+        mute_warnings: bool,
+    ) -> PyResult<Self> {
+        let path = path_from_python(artifact)?;
+        let mut runtime = NativeRuntime::load(path, process, None).map_err(python_error)?;
+        if let Some(mapping) = model_parameters {
+            let values = parse_model_parameters(mapping)?;
+            runtime
+                .set_model_parameters(&values)
+                .map_err(python_error)?;
+        }
+        if mute_warnings {
+            runtime.mute_warnings();
+        }
+        Ok(Self { runtime })
+    }
+
+    #[staticmethod]
+    #[pyo3(signature=(artifact, *, process=None, model_parameters=None, mute_warnings=false))]
+    fn load(
+        artifact: &Bound<'_, PyAny>,
+        process: Option<&str>,
+        model_parameters: Option<&Bound<'_, PyAny>>,
+        mute_warnings: bool,
+    ) -> PyResult<Self> {
+        Self::new(artifact, process, model_parameters, mute_warnings)
+    }
+
+    #[getter]
+    fn process(&self) -> String {
+        self.runtime.metadata().process
+    }
+
+    #[getter]
+    fn artifact_id(&self) -> &str {
+        self.runtime.artifact_id()
+    }
+
+    #[getter]
+    fn process_id(&self) -> String {
+        self.runtime.metadata().process_key
+    }
+
+    #[getter]
+    fn color_accuracy(&self) -> String {
+        self.runtime.metadata().color_accuracy
+    }
+
+    #[getter]
+    fn physics(&self) -> PyResult<ProcessPhysics> {
+        Ok(ProcessPhysics::from_core(
+            self.runtime.process_physics().map_err(python_error)?,
+        ))
+    }
+
+    fn metadata_json(&self) -> PyResult<String> {
+        self.runtime.metadata_json().map_err(python_error)
+    }
+
+    fn save(&mut self, py: Python<'_>, path: &Bound<'_, PyAny>) -> PyResult<()> {
+        let path = path_from_python(path)?;
+        let runtime = SameThreadNativeRuntimeBorrow::new(&mut self.runtime);
+        py.detach(move || runtime.run(|runtime| runtime.save(path)))
+            .and_then(|result| result)
+            .map_err(python_error)
+    }
+
+    fn load_cache(&mut self, py: Python<'_>, path: &Bound<'_, PyAny>) -> PyResult<()> {
+        let path = path_from_python(path)?;
+        let runtime = SameThreadNativeRuntimeBorrow::new(&mut self.runtime);
+        py.detach(move || runtime.run(|runtime| runtime.load_cache(path)))
+            .and_then(|result| result)
+            .map_err(python_error)
+    }
+
+    #[pyo3(signature=(color_flow_ids=None))]
+    fn _on_the_fly_benchmark_context_json(
+        &self,
+        color_flow_ids: Option<Vec<String>>,
+    ) -> PyResult<Option<String>> {
+        self.runtime
+            .on_the_fly_benchmark_context_json(color_flow_ids.as_deref())
+            .map_err(python_error)
+    }
+
+    #[pyo3(signature=(helicity_ids=None, color_flow_ids=None))]
+    fn _on_the_fly_selector_ordinals_json(
+        &self,
+        helicity_ids: Option<Vec<String>>,
+        color_flow_ids: Option<Vec<String>>,
+    ) -> PyResult<Option<String>> {
+        self.runtime
+            .on_the_fly_selector_ordinals_json(helicity_ids.as_deref(), color_flow_ids.as_deref())
+            .map_err(python_error)
+    }
+
+    /// Private read-only production introspection of retained compact OTF state.
+    fn _on_the_fly_runtime_state_census_json(&self) -> PyResult<Option<String>> {
+        self.runtime
+            .on_the_fly_runtime_state_census_json()
+            .map_err(python_error)
+    }
+
+    #[pyo3(signature=(momenta, helicity_ids=None, color_flow_ids=None, progress_callback=None, *, n_cores=None))]
+    fn _on_the_fly_warm_up_f64_json(
+        &mut self,
+        py: Python<'_>,
+        momenta: &Bound<'_, PyAny>,
+        helicity_ids: Option<Vec<String>>,
+        color_flow_ids: Option<Vec<String>>,
+        progress_callback: Option<Py<PyAny>>,
+        n_cores: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<String> {
+        let n_cores = n_cores
+            .map(|value| {
+                if value.is_instance_of::<PyBool>() || !value.is_instance_of::<PyInt>() {
+                    return Err(PyTypeError::new_err(
+                        "n_cores must be a positive integer or None",
+                    ));
+                }
+                match value.extract::<usize>() {
+                    Ok(count) if count > 0 => Ok(count),
+                    _ => Err(PyValueError::new_err(
+                        "n_cores must be a positive integer fitting the platform's usize",
+                    )),
+                }
+            })
+            .transpose()?;
+        let momenta = parse_f64_momenta(momenta, self.runtime.external_count())?;
+        if momenta.point_count() != 1 {
+            return Err(PyValueError::new_err(format!(
+                "on-the-fly warm_up requires exactly one phase-space point, received {}",
+                momenta.point_count()
+            )));
+        }
+        let momenta = momenta.as_slice().to_vec();
+        if let Some(callback) = progress_callback.as_ref()
+            && !callback.bind(py).is_callable()
+        {
+            return Err(PyTypeError::new_err(
+                "on-the-fly warm_up progress_callback must be callable or None",
+            ));
+        }
+        let callback_error = Arc::new(Mutex::new(None));
+        let detached_callback_error = Arc::clone(&callback_error);
+        let detached_runtime = SameThreadNativeRuntimeBorrow::new(&mut self.runtime);
+        let result = py
+            .detach(move || {
+                detached_runtime.run(|runtime| {
+                    if let Some(callback) = progress_callback.as_ref() {
+                        let mut observer = |event: &NativeOnTheFlyWarmUpEvent| {
+                            report_on_the_fly_warm_up_progress(
+                                callback,
+                                detached_callback_error.as_ref(),
+                                event,
+                            )
+                        };
+                        let observer: &mut NativeOnTheFlyWarmUpObserver<'_> = &mut observer;
+                        runtime.warm_up_on_the_fly_f64_with_selectors(
+                            &momenta,
+                            helicity_ids.as_deref(),
+                            color_flow_ids.as_deref(),
+                            n_cores,
+                            Some(observer),
+                        )
+                    } else {
+                        runtime.warm_up_on_the_fly_f64_with_selectors(
+                            &momenta,
+                            helicity_ids.as_deref(),
+                            color_flow_ids.as_deref(),
+                            n_cores,
+                            None,
+                        )
+                    }
+                })
+            })
+            .and_then(|result| result);
+        if let Some(error) = callback_error
+            .lock()
+            .map_err(|_| {
+                PyException::new_err("on-the-fly warm-up callback error lock was poisoned")
+            })?
+            .take()
+        {
+            return Err(error);
+        }
+        let result = result.map_err(python_error)?;
+        serde_json::to_string(&result).map_err(|error| {
+            python_error(CoreError::serialization(format!(
+                "could not serialize on-the-fly warm-up result: {error}"
+            )))
+        })
+    }
+
+    fn physics_json(&self) -> PyResult<String> {
+        self.runtime.physics_json().map_err(python_error)
+    }
+
+    fn _exact_runtime_state_json(&self) -> PyResult<String> {
+        self.runtime
+            .exact_runtime_state_json()
+            .map_err(python_error)
+    }
+
+    #[pyo3(signature=(momenta, *, helicities=None, color_flows=None, helicity_by_point=None, color_flow_by_point=None, precision=16))]
+    fn evaluate(
+        &mut self,
+        py: Python<'_>,
+        momenta: &Bound<'_, PyAny>,
+        helicities: Option<Vec<String>>,
+        color_flows: Option<Vec<String>>,
+        helicity_by_point: Option<Vec<u32>>,
+        color_flow_by_point: Option<Vec<u32>>,
+        precision: u32,
+    ) -> PyResult<Py<PyAny>> {
+        require_raw_f64_precision(precision).map_err(python_error)?;
+        let momenta = parse_f64_momenta(momenta, self.runtime.external_count())?;
+        let point_count = momenta.point_count();
+        let mut values = vec![0.0; point_count];
+        self.runtime
+            .evaluate_f64_into_with_selectors(
+                momenta.as_slice(),
+                point_count,
+                helicities.as_deref(),
+                color_flows.as_deref(),
+                helicity_by_point.as_deref(),
+                color_flow_by_point.as_deref(),
+                &mut values,
+            )
+            .map_err(python_error)?;
+        let result = PyList::new(py, values)?.into_any().unbind();
+        self.emit_warnings(py)?;
+        Ok(result)
+    }
+
+    #[pyo3(signature=(momenta, repetitions, *, helicities=None, color_flows=None, helicity_by_point=None, color_flow_by_point=None, precision=16))]
+    fn _benchmark_f64_wall_time(
+        &mut self,
+        momenta: &Bound<'_, PyAny>,
+        repetitions: usize,
+        helicities: Option<Vec<String>>,
+        color_flows: Option<Vec<String>>,
+        helicity_by_point: Option<Vec<u32>>,
+        color_flow_by_point: Option<Vec<u32>>,
+        precision: u32,
+    ) -> PyResult<f64> {
+        require_raw_f64_precision(precision).map_err(python_error)?;
+        let momenta = parse_f64_momenta(momenta, self.runtime.external_count())?;
+        let point_count = momenta.point_count();
+        self.runtime
+            .benchmark_f64_wall_time_with_selectors(
+                momenta.as_slice(),
+                point_count,
+                repetitions,
+                helicities.as_deref(),
+                color_flows.as_deref(),
+                helicity_by_point.as_deref(),
+                color_flow_by_point.as_deref(),
+            )
+            .map_err(python_error)
+    }
+
+    #[pyo3(signature=(momenta, repetitions, *, helicities=None, color_flows=None, precision=16, include_values=false))]
+    fn _profile_arena_repeated(
+        &mut self,
+        py: Python<'_>,
+        momenta: &Bound<'_, PyAny>,
+        repetitions: usize,
+        helicities: Option<Vec<String>>,
+        color_flows: Option<Vec<String>>,
+        precision: u32,
+        include_values: bool,
+    ) -> PyResult<Py<PyAny>> {
+        require_raw_f64_precision(precision).map_err(python_error)?;
+        let momenta = parse_f64_momenta(momenta, self.runtime.external_count())?;
+        let point_count = momenta.point_count();
+        let profiled = self
+            .runtime
+            .evaluate_f64_arena_profile_repeated(
+                momenta.as_slice(),
+                point_count,
+                repetitions,
+                helicities.as_deref(),
+                color_flows.as_deref(),
+            )
+            .map_err(python_error)?;
+        let measured_points = point_count
+            .checked_mul(repetitions)
+            .ok_or_else(|| PyValueError::new_err("arena profile point count overflowed"))?;
+        let result = runtime_profile_to_python(py, &profiled.profile, measured_points)?;
+        result.set_item("execution_mode", self.runtime.metadata().execution_mode)?;
+        result.set_item(
+            "profile_boundary",
+            "warmed-direct-arena-borrowed-input-preallocated-output-v1",
+        )?;
+        result.set_item("borrowed_flat_input", true)?;
+        result.set_item("preallocated_output", true)?;
+        result.set_item("phase_timing_scope", "coarse-arena-boundary-only-v1")?;
+        result.set_item("evaluator_timing_available", false)?;
+        if include_values {
+            result.set_item("values", PyList::new(py, profiled.values)?)?;
+        }
+        self.emit_warnings(py)?;
+        Ok(result.into_any().unbind())
+    }
+
+    #[pyo3(signature=(momenta, *, helicities=None, color_flows=None, helicity_by_point=None, color_flow_by_point=None, precision=16, include_values=false))]
+    fn profile(
+        &mut self,
+        py: Python<'_>,
+        momenta: &Bound<'_, PyAny>,
+        helicities: Option<Vec<String>>,
+        color_flows: Option<Vec<String>>,
+        helicity_by_point: Option<Vec<u32>>,
+        color_flow_by_point: Option<Vec<u32>>,
+        precision: u32,
+        include_values: bool,
+    ) -> PyResult<Py<PyAny>> {
+        require_raw_f64_precision(precision).map_err(python_error)?;
+        let momenta = parse_f64_momenta(momenta, self.runtime.external_count())?;
+        let point_count = momenta.point_count();
+        let profiled = self
+            .runtime
+            .evaluate_f64_profile_with_selectors(
+                momenta.as_slice(),
+                point_count,
+                helicities.as_deref(),
+                color_flows.as_deref(),
+                helicity_by_point.as_deref(),
+                color_flow_by_point.as_deref(),
+            )
+            .map_err(python_error)?;
+        let result = runtime_profile_to_python(py, &profiled.profile, point_count)?;
+        result.set_item("execution_mode", self.runtime.metadata().execution_mode)?;
+        if include_values {
+            result.set_item("values", PyList::new(py, profiled.values)?)?;
+        }
+        self.emit_warnings(py)?;
+        Ok(result.into_any().unbind())
+    }
+
+    #[pyo3(signature=(momenta, repetitions, *, helicities=None, color_flows=None, helicity_by_point=None, color_flow_by_point=None, precision=16, include_values=false))]
+    fn profile_repeated(
+        &mut self,
+        py: Python<'_>,
+        momenta: &Bound<'_, PyAny>,
+        repetitions: usize,
+        helicities: Option<Vec<String>>,
+        color_flows: Option<Vec<String>>,
+        helicity_by_point: Option<Vec<u32>>,
+        color_flow_by_point: Option<Vec<u32>>,
+        precision: u32,
+        include_values: bool,
+    ) -> PyResult<Py<PyAny>> {
+        require_raw_f64_precision(precision).map_err(python_error)?;
+        let momenta = parse_f64_momenta(momenta, self.runtime.external_count())?;
+        let point_count = momenta.point_count();
+        let profiled = self
+            .runtime
+            .evaluate_f64_profile_repeated_with_selectors(
+                momenta.as_slice(),
+                point_count,
+                repetitions,
+                helicities.as_deref(),
+                color_flows.as_deref(),
+                helicity_by_point.as_deref(),
+                color_flow_by_point.as_deref(),
+            )
+            .map_err(python_error)?;
+        let measured_points = point_count
+            .checked_mul(repetitions)
+            .ok_or_else(|| PyValueError::new_err("profile point count overflowed"))?;
+        let result = runtime_profile_to_python(py, &profiled.profile, measured_points)?;
+        result.set_item("execution_mode", self.runtime.metadata().execution_mode)?;
+        if include_values {
+            result.set_item("values", PyList::new(py, profiled.values)?)?;
+        }
+        self.emit_warnings(py)?;
+        Ok(result.into_any().unbind())
+    }
+
+    #[pyo3(signature=(momenta, *, helicities=None, color_flows=None, helicity_by_point=None, color_flow_by_point=None, precision=16, include_values=false))]
+    fn evaluate_profile(
+        &mut self,
+        py: Python<'_>,
+        momenta: &Bound<'_, PyAny>,
+        helicities: Option<Vec<String>>,
+        color_flows: Option<Vec<String>>,
+        helicity_by_point: Option<Vec<u32>>,
+        color_flow_by_point: Option<Vec<u32>>,
+        precision: u32,
+        include_values: bool,
+    ) -> PyResult<Py<PyAny>> {
+        self.profile(
+            py,
+            momenta,
+            helicities,
+            color_flows,
+            helicity_by_point,
+            color_flow_by_point,
+            precision,
+            include_values,
+        )
+    }
+
+    #[pyo3(signature=(momenta, *, helicities=None, color_flows=None, precision=16))]
+    fn evaluate_resolved(
+        &mut self,
+        py: Python<'_>,
+        momenta: &Bound<'_, PyAny>,
+        helicities: Option<Vec<String>>,
+        color_flows: Option<Vec<String>>,
+        precision: u32,
+    ) -> PyResult<ResolvedEvaluation> {
+        require_raw_f64_precision(precision).map_err(python_error)?;
+        let accuracy = self.runtime.metadata().color_accuracy;
+        let momenta = parse_f64_momenta(momenta, self.runtime.external_count())?;
+        let point_count = momenta.point_count();
+        let resolved = self
+            .runtime
+            .evaluate_resolved_f64(
+                momenta.as_slice(),
+                point_count,
+                helicities.as_deref(),
+                color_flows.as_deref(),
+            )
+            .map_err(python_error)?;
+        let result = resolved_f64_to_python(py, resolved, accuracy, precision)?;
+        self.emit_warnings(py)?;
+        Ok(result)
+    }
+
+    fn evaluate_with_prec(
+        &mut self,
+        py: Python<'_>,
+        momenta: &Bound<'_, PyAny>,
+        decimal_digit_precision: u32,
+    ) -> PyResult<Py<PyAny>> {
+        self.evaluate(py, momenta, None, None, None, None, decimal_digit_precision)
+    }
+
+    #[pyo3(signature=(momenta, decimal_digit_precision, helicities=None, color_flows=None))]
+    fn evaluate_resolved_with_prec(
+        &mut self,
+        py: Python<'_>,
+        momenta: &Bound<'_, PyAny>,
+        decimal_digit_precision: u32,
+        helicities: Option<Vec<String>>,
+        color_flows: Option<Vec<String>>,
+    ) -> PyResult<ResolvedEvaluation> {
+        self.evaluate_resolved(
+            py,
+            momenta,
+            helicities,
+            color_flows,
+            decimal_digit_precision,
+        )
+    }
+
+    fn set_model_parameters(&mut self, mapping: &Bound<'_, PyAny>) -> PyResult<()> {
+        let values = parse_model_parameters(mapping)?;
+        self.runtime
+            .set_model_parameters(&values)
+            .map_err(python_error)
+    }
+
+    fn clear(&mut self) -> PyResult<()> {
+        self.runtime.clear().map_err(python_error)
+    }
+
+    fn set_model_parameter(&mut self, name: &str, value: &Bound<'_, PyAny>) -> PyResult<()> {
+        let value = parse_complex_value(value, name)?;
+        self.runtime
+            .set_model_parameter(name, value.0, value.1)
+            .map_err(python_error)
+    }
+
+    fn mute_warnings(&mut self) {
+        self.runtime.mute_warnings();
+    }
+
+    fn unmute_warnings(&mut self) {
+        self.runtime.unmute_warnings();
+    }
+
+    fn take_warnings(&mut self) -> Vec<String> {
+        self.runtime.take_warnings()
+    }
+}
+
+impl Runtime {
+    fn emit_warnings(&mut self, py: Python<'_>) -> PyResult<()> {
+        let pending = self.runtime.take_warnings();
+        if pending.is_empty() {
+            return Ok(());
+        }
+        let warnings = py.import("warnings")?;
+        for message in pending {
+            warnings.call_method1("warn", (message,))?;
+        }
+        Ok(())
+    }
+}
+
+fn color_accuracy_name(value: ColorAccuracy) -> &'static str {
+    value.as_str()
+}
+
+fn reduction_kind_name(value: ReductionKind) -> &'static str {
+    match value {
+        ReductionKind::LcDiagonal => "lc-diagonal",
+        ReductionKind::ContractedColor => "contracted-color",
+    }
+}
+
+fn parameter_kind_name(value: ParameterKind) -> &'static str {
+    match value {
+        ParameterKind::Normalization => "normalization",
+        ParameterKind::Mass => "mass",
+        ParameterKind::Width => "width",
+        ParameterKind::Coupling => "coupling",
+        ParameterKind::External => "external",
+        ParameterKind::Derived => "derived",
+    }
+}
+
+fn path_from_python(value: &Bound<'_, PyAny>) -> PyResult<PathBuf> {
+    value.extract::<PathBuf>().map_err(|error| {
+        PyTypeError::new_err(format!(
+            "artifact must be a string or path-like object: {error}"
+        ))
+    })
+}
+
+fn parse_model_parameters(mapping: &Bound<'_, PyAny>) -> PyResult<BTreeMap<String, (f64, f64)>> {
+    let items = mapping.call_method0("items").map_err(|_| {
+        PyTypeError::new_err("model_parameters must be a mapping from names to numbers")
+    })?;
+    let mut result = BTreeMap::new();
+    for item in items.try_iter()? {
+        let item = item?;
+        let name = item.get_item(0)?.extract::<String>()?;
+        if name.is_empty() {
+            return Err(PyValueError::new_err(
+                "model parameter names must not be empty",
+            ));
+        }
+        let value = item.get_item(1)?;
+        if result
+            .insert(name.clone(), parse_complex_value(&value, &name)?)
+            .is_some()
+        {
+            return Err(PyValueError::new_err(format!(
+                "duplicate model parameter {name:?}"
+            )));
+        }
+    }
+    Ok(result)
+}
+
+fn parse_complex_value(value: &Bound<'_, PyAny>, name: &str) -> PyResult<(f64, f64)> {
+    if value.is_instance_of::<PyBool>() {
+        return Err(PyTypeError::new_err(format!(
+            "model parameter {name:?} must be numeric, not bool"
+        )));
+    }
+    if let Ok(real) = value.extract::<f64>() {
+        return Ok((real, 0.0));
+    }
+    if value.is_instance_of::<PyList>() || value.is_instance_of::<PyTuple>() {
+        if value.len()? != 2 {
+            return Err(PyValueError::new_err(format!(
+                "model parameter {name:?} array must contain [real, imaginary]"
+            )));
+        }
+        let component = |index: usize, label: &str| -> PyResult<f64> {
+            let item = value.get_item(index)?;
+            if item.is_instance_of::<PyBool>() {
+                return Err(PyTypeError::new_err(format!(
+                    "model parameter {name:?} {label} component must be numeric, not bool"
+                )));
+            }
+            item.extract::<f64>().map_err(|_| {
+                PyTypeError::new_err(format!(
+                    "model parameter {name:?} {label} component must be numeric"
+                ))
+            })
+        };
+        return Ok((component(0, "real")?, component(1, "imaginary")?));
+    }
+    let real = value.getattr("real")?.extract::<f64>().map_err(|_| {
+        PyTypeError::new_err(format!(
+            "model parameter {name:?} must be a number or [real, imaginary]"
+        ))
+    })?;
+    let imaginary = value.getattr("imag")?.extract::<f64>().map_err(|_| {
+        PyTypeError::new_err(format!(
+            "model parameter {name:?} must be a number or [real, imaginary]"
+        ))
+    })?;
+    Ok((real, imaginary))
+}
+
+enum ParsedF64Momenta<'py> {
+    #[cfg(feature = "numpy")]
+    Borrowed {
+        array: PyReadonlyArray3<'py, f64>,
+        point_count: usize,
+    },
+    Owned {
+        values: Vec<f64>,
+        point_count: usize,
+        _python: PhantomData<&'py ()>,
+    },
+}
+
+impl ParsedF64Momenta<'_> {
+    fn as_slice(&self) -> &[f64] {
+        match self {
+            #[cfg(feature = "numpy")]
+            Self::Borrowed { array, .. } => array
+                .as_slice()
+                .expect("contiguous NumPy momenta were validated while parsing"),
+            Self::Owned { values, .. } => values,
+        }
+    }
+
+    fn point_count(&self) -> usize {
+        match self {
+            #[cfg(feature = "numpy")]
+            Self::Borrowed { point_count, .. } => *point_count,
+            Self::Owned { point_count, .. } => *point_count,
+        }
+    }
+}
+
+fn parse_f64_momenta<'py>(
+    momenta: &Bound<'py, PyAny>,
+    expected_legs: usize,
+) -> PyResult<ParsedF64Momenta<'py>> {
+    #[cfg(feature = "numpy")]
+    if let Ok(array) = momenta.extract::<PyReadonlyArray3<'py, f64>>() {
+        let shape = array.shape();
+        let point_count = shape[0];
+        if shape[1] != expected_legs || shape[2] != 4 {
+            return Err(PyValueError::new_err(format!(
+                "momenta array has shape ({}, {}, {}), expected (points, {expected_legs}, 4)",
+                point_count, shape[1], shape[2]
+            )));
+        }
+        if point_count == 0 {
+            return Err(PyValueError::new_err(
+                "momenta must contain at least one point",
+            ));
+        }
+        if array.as_slice().is_ok() {
+            return Ok(ParsedF64Momenta::Borrowed { point_count, array });
+        }
+    }
+
+    let mut values = Vec::new();
+    let mut point_count = 0;
+    for (point_index, point) in momenta.try_iter()?.enumerate() {
+        let point = point?;
+        let mut leg_count = 0;
+        for (leg_index, leg) in point.try_iter()?.enumerate() {
+            let leg = leg?;
+            let components = leg
+                .try_iter()?
+                .map(|component| component?.extract::<f64>())
+                .collect::<PyResult<Vec<_>>>()?;
+            if components.len() != 4 {
+                return Err(PyValueError::new_err(format!(
+                    "momenta point {point_index} leg {leg_index} has {} components, expected 4",
+                    components.len()
+                )));
+            }
+            values.extend(components);
+            leg_count += 1;
+        }
+        if leg_count != expected_legs {
+            return Err(PyValueError::new_err(format!(
+                "momenta point {point_index} has {leg_count} external legs, expected {expected_legs}"
+            )));
+        }
+        point_count += 1;
+    }
+    if point_count == 0 {
+        return Err(PyValueError::new_err(
+            "momenta must contain at least one point",
+        ));
+    }
+    Ok(ParsedF64Momenta::Owned {
+        values,
+        point_count,
+        _python: PhantomData,
+    })
+}
+
+fn resolved_f64_to_python(
+    py: Python<'_>,
+    resolved: NativeResolvedEvaluation,
+    color_accuracy: String,
+    precision: u32,
+) -> PyResult<ResolvedEvaluation> {
+    let shape = resolved.shape();
+    let values = nested_f64_values(py, &resolved.values, shape.1, shape.2)?;
+    let totals = PyList::new(py, resolved.totals())?.into_any().unbind();
+    Ok(ResolvedEvaluation {
+        values,
+        totals,
+        shape,
+        helicity_ids: resolved.helicity_ids,
+        color_ids: resolved.color_ids,
+        color_accuracy,
+        precision,
+    })
+}
+
+fn nested_f64_values(
+    py: Python<'_>,
+    values: &[f64],
+    helicity_count: usize,
+    color_count: usize,
+) -> PyResult<Py<PyAny>> {
+    let point_width = helicity_count
+        .checked_mul(color_count)
+        .ok_or_else(|| EvaluationError::new_err("resolved shape overflow"))?;
+    if point_width == 0 || !values.len().is_multiple_of(point_width) {
+        return Err(EvaluationError::new_err(
+            "resolved value buffer does not match its shape",
+        ));
+    }
+    let mut points = Vec::with_capacity(values.len() / point_width);
+    for point in values.chunks(point_width) {
+        let mut helicities = Vec::with_capacity(helicity_count);
+        for colors in point.chunks(color_count) {
+            helicities.push(PyList::new(py, colors.iter().copied())?.into_any().unbind());
+        }
+        points.push(PyList::new(py, helicities)?.into_any().unbind());
+    }
+    Ok(PyList::new(py, points)?.into_any().unbind())
+}
+
+fn runtime_profile_to_python<'py>(
+    py: Python<'py>,
+    profile: &NativeRuntimeProfile,
+    point_count: usize,
+) -> PyResult<Bound<'py, PyDict>> {
+    let payload = PyDict::new(py);
+    payload.set_item("points", point_count)?;
+    payload.set_item("wall_time_s", profile.total_s)?;
+    payload.set_item("native_input_pack_time_s", profile.native_input_pack_s)?;
+    payload.set_item(
+        "native_input_crossing_time_s",
+        profile.native_input_crossing_s,
+    )?;
+    payload.set_item("orchestration_time_s", profile.orchestration_s)?;
+    payload.set_item("state_prepare_time_s", profile.state_prepare_s)?;
+    payload.set_item("state_clear_time_s", profile.state_clear_s)?;
+    payload.set_item("source_fill_time_s", profile.source_fill_s)?;
+    payload.set_item(
+        "momentum_input_setup_time_s",
+        profile.momentum_input_setup_s,
+    )?;
+    payload.set_item("momentum_setup_time_s", profile.momentum_setup_s)?;
+    payload.set_item(
+        "model_parameter_setup_time_s",
+        profile.model_parameter_setup_s,
+    )?;
+    payload.set_item("stage_input_pack_time_s", profile.stage_input_pack_s)?;
+    payload.set_item(
+        "stage_leaf_input_pack_time_s",
+        profile.stage_leaf_input_pack_s,
+    )?;
+    payload.set_item(
+        "stage_evaluator_call_time_s",
+        profile.stage_evaluator_call_s,
+    )?;
+    payload.set_item("stage_evaluator_time_s", profile.stage_evaluator_s)?;
+    payload.set_item("stage_backend_call_time_s", profile.stage_backend_call_s)?;
+    payload.set_item(
+        "stage_evaluator_output_gather_time_s",
+        profile.stage_evaluator_output_gather_s,
+    )?;
+    payload.set_item("output_assign_time_s", profile.output_assign_s)?;
+    payload.set_item(
+        "amplitude_input_pack_time_s",
+        profile.amplitude_input_pack_s,
+    )?;
+    payload.set_item(
+        "amplitude_evaluator_call_time_s",
+        profile.amplitude_evaluator_call_s,
+    )?;
+    payload.set_item(
+        "amplitude_leaf_input_pack_time_s",
+        profile.amplitude_leaf_input_pack_s,
+    )?;
+    payload.set_item(
+        "amplitude_backend_call_time_s",
+        profile.amplitude_backend_call_s,
+    )?;
+    payload.set_item(
+        "amplitude_evaluator_output_gather_time_s",
+        profile.amplitude_evaluator_output_gather_s,
+    )?;
+    payload.set_item(
+        "amplitude_output_remap_time_s",
+        profile.amplitude_output_remap_s,
+    )?;
+    payload.set_item("amplitude_evaluator_time_s", profile.amplitude_evaluator_s)?;
+    payload.set_item("reduction_time_s", profile.reduction_s)?;
+    payload.set_item(
+        "resolved_reduction_materialization_inclusive_time_s",
+        profile.resolved_reduction_materialization_s,
+    )?;
+    payload.set_item(
+        "total_materialization_time_s",
+        profile.total_materialization_s,
+    )?;
+    payload.set_item("final_output_copy_time_s", profile.final_output_copy_s)?;
+    payload.set_item(
+        "stage_input_pack_by_stage_time_s",
+        profile.stage_input_pack_by_stage_s.clone(),
+    )?;
+    payload.set_item(
+        "stage_evaluator_call_by_stage_time_s",
+        profile.stage_evaluator_call_by_stage_s.clone(),
+    )?;
+    payload.set_item(
+        "stage_leaf_input_pack_by_stage_time_s",
+        profile.stage_leaf_input_pack_by_stage_s.clone(),
+    )?;
+    payload.set_item(
+        "stage_backend_call_by_stage_time_s",
+        profile.stage_backend_call_by_stage_s.clone(),
+    )?;
+    payload.set_item(
+        "stage_evaluator_output_gather_by_stage_time_s",
+        profile.stage_evaluator_output_gather_by_stage_s.clone(),
+    )?;
+    payload.set_item(
+        "stage_output_assign_by_stage_time_s",
+        profile.stage_output_assign_by_stage_s.clone(),
+    )?;
+    payload.set_item("eager_initialize_time_s", profile.eager_initialize_s)?;
+    payload.set_item("eager_gather_time_s", profile.eager_gather_s)?;
+    payload.set_item("eager_kernel_call_time_s", profile.eager_kernel_call_s)?;
+    payload.set_item(
+        "eager_invocation_scatter_time_s",
+        profile.eager_invocation_scatter_s,
+    )?;
+    payload.set_item("eager_finalization_time_s", profile.eager_finalization_s)?;
+    payload.set_item(
+        "eager_scatter_finalization_time_s",
+        profile.eager_scatter_finalization_s,
+    )?;
+    payload.set_item("eager_closure_time_s", profile.eager_closure_s)?;
+    payload.set_item("eager_reduction_time_s", profile.eager_reduction_s)?;
+    payload.set_item("eager_copy_out_time_s", profile.eager_copy_out_s)?;
+    payload.set_item(
+        "recurrence_momentum_fill_time_s",
+        profile.recurrence_momentum_fill_s,
+    )?;
+    payload.set_item(
+        "recurrence_union_source_fill_time_s",
+        profile.recurrence_union_source_fill_s,
+    )?;
+    payload.set_item("recurrence_schedule_time_s", profile.recurrence_schedule_s)?;
+    payload.set_item(
+        "recurrence_source_kernel_time_s",
+        profile.recurrence_source_kernel_s,
+    )?;
+    payload.set_item(
+        "recurrence_contribution_kernel_time_s",
+        profile.recurrence_contribution_kernel_s,
+    )?;
+    payload.set_item(
+        "recurrence_finalization_time_s",
+        profile.recurrence_finalization_s,
+    )?;
+    payload.set_item("recurrence_closure_time_s", profile.recurrence_closure_s)?;
+    payload.set_item(
+        "recurrence_replay_output_mapping_time_s",
+        profile.recurrence_replay_output_mapping_s,
+    )?;
+    payload.set_item(
+        "recurrence_momentum_scalar_value_count",
+        profile.recurrence_momentum_scalar_value_count,
+    )?;
+    payload.set_item(
+        "recurrence_schedule_execution_count",
+        profile.recurrence_schedule_execution_count,
+    )?;
+    payload.set_item(
+        "recurrence_replay_schedule_execution_count",
+        profile.recurrence_replay_schedule_execution_count,
+    )?;
+    payload.set_item(
+        "recurrence_union_schedule_execution_count",
+        profile.recurrence_union_schedule_execution_count,
+    )?;
+    payload.set_item(
+        "recurrence_union_source_row_count",
+        profile.recurrence_union_source_row_count,
+    )?;
+    payload.set_item(
+        "recurrence_replay_output_value_count",
+        profile.recurrence_replay_output_value_count,
+    )?;
+    payload.set_item(
+        "recurrence_source_call_count",
+        profile.recurrence_source_call_count,
+    )?;
+    payload.set_item(
+        "recurrence_source_row_count",
+        profile.recurrence_source_row_count,
+    )?;
+    payload.set_item(
+        "recurrence_contribution_call_count",
+        profile.recurrence_contribution_call_count,
+    )?;
+    payload.set_item(
+        "recurrence_contribution_row_count",
+        profile.recurrence_contribution_row_count,
+    )?;
+    payload.set_item(
+        "recurrence_finalization_call_count",
+        profile.recurrence_finalization_call_count,
+    )?;
+    payload.set_item(
+        "recurrence_finalization_row_count",
+        profile.recurrence_finalization_row_count,
+    )?;
+    payload.set_item(
+        "recurrence_closure_call_count",
+        profile.recurrence_closure_call_count,
+    )?;
+    payload.set_item(
+        "recurrence_closure_row_count",
+        profile.recurrence_closure_row_count,
+    )?;
+    payload.set_item("selector_planner_time_s", profile.selector_planner_s)?;
+    payload.set_item("selector_gather_time_s", profile.selector_gather_s)?;
+    payload.set_item("selector_scatter_time_s", profile.selector_scatter_s)?;
+    payload.set_item("selector_plan_kind", &profile.selector_plan_kind)?;
+    payload.set_item("selector_group_sizes", profile.selector_group_sizes.clone())?;
+    payload.set_item(
+        "selector_reordered_point_count",
+        profile.selector_reordered_point_count,
+    )?;
+    payload.set_item("selector_simd_lane_width", profile.selector_simd_lane_width)?;
+    payload.set_item("selector_simd_occupancy", profile.selector_simd_occupancy)?;
+    payload.set_item(
+        "native_input_component_count",
+        profile.native_input_component_count,
+    )?;
+    payload.set_item("native_input_pack_bytes", profile.native_input_pack_bytes)?;
+    payload.set_item(
+        "native_input_crossing_bytes",
+        profile.native_input_crossing_bytes,
+    )?;
+    payload.set_item(
+        "native_input_container_allocation_count",
+        profile.native_input_container_allocation_count,
+    )?;
+    payload.set_item("state_component_count", profile.state_component_count)?;
+    payload.set_item(
+        "state_clear_component_count",
+        profile.state_clear_component_count,
+    )?;
+    payload.set_item("source_component_count", profile.source_component_count)?;
+    payload.set_item("momentum_component_count", profile.momentum_component_count)?;
+    payload.set_item(
+        "model_parameter_component_count",
+        profile.model_parameter_component_count,
+    )?;
+    payload.set_item(
+        "stage_input_copy_component_count",
+        profile.stage_input_copy_component_count,
+    )?;
+    payload.set_item(
+        "stage_leaf_input_copy_component_count",
+        profile.stage_leaf_input_copy_component_count,
+    )?;
+    payload.set_item(
+        "stage_evaluator_output_gather_component_count",
+        profile.stage_evaluator_output_gather_component_count,
+    )?;
+    payload.set_item(
+        "stage_output_assign_component_count",
+        profile.stage_output_assign_component_count,
+    )?;
+    payload.set_item(
+        "amplitude_input_copy_component_count",
+        profile.amplitude_input_copy_component_count,
+    )?;
+    payload.set_item(
+        "amplitude_leaf_input_copy_component_count",
+        profile.amplitude_leaf_input_copy_component_count,
+    )?;
+    payload.set_item(
+        "amplitude_evaluator_output_gather_component_count",
+        profile.amplitude_evaluator_output_gather_component_count,
+    )?;
+    payload.set_item(
+        "amplitude_output_remap_component_count",
+        profile.amplitude_output_remap_component_count,
+    )?;
+    payload.set_item(
+        "evaluator_backend_call_count",
+        profile.evaluator_backend_call_count,
+    )?;
+    payload.set_item(
+        "compiled_direct_arena_engine_count",
+        profile.compiled_direct_arena_engine_count,
+    )?;
+    payload.set_item(
+        "compiled_direct_arena_call_count",
+        profile.compiled_direct_arena_call_count,
+    )?;
+    payload.set_item(
+        "compiled_direct_arena_minimum_effective_tile_capacity",
+        profile.compiled_direct_arena_minimum_effective_tile_capacity,
+    )?;
+    payload.set_item(
+        "compiled_direct_arena_maximum_physical_scalar_values_per_point",
+        profile.compiled_direct_arena_maximum_physical_scalar_values_per_point,
+    )?;
+    payload.set_item(
+        "compiled_direct_arena_maximum_hot_scalar_values_per_point",
+        profile.compiled_direct_arena_maximum_hot_scalar_values_per_point,
+    )?;
+    payload.set_item(
+        "compiled_direct_arena_maximum_source_scalar_values_per_point",
+        profile.compiled_direct_arena_maximum_source_scalar_values_per_point,
+    )?;
+    payload.set_item(
+        "compiled_direct_arena_maximum_reduction_scalar_values_per_point",
+        profile.compiled_direct_arena_maximum_reduction_scalar_values_per_point,
+    )?;
+    payload.set_item(
+        "compiled_direct_arena_boundary_input_bytes",
+        profile.compiled_direct_arena_boundary_input_bytes,
+    )?;
+    payload.set_item(
+        "compiled_direct_arena_boundary_current_output_bytes",
+        profile.compiled_direct_arena_boundary_current_output_bytes,
+    )?;
+    payload.set_item(
+        "compiled_direct_arena_boundary_amplitude_output_bytes",
+        profile.compiled_direct_arena_boundary_amplitude_output_bytes,
+    )?;
+    payload.set_item(
+        "reduction_input_component_count",
+        profile.reduction_input_component_count,
+    )?;
+    payload.set_item(
+        "selector_gather_point_count",
+        profile.selector_gather_point_count,
+    )?;
+    payload.set_item("selector_gather_bytes", profile.selector_gather_bytes)?;
+    payload.set_item(
+        "selector_scatter_value_count",
+        profile.selector_scatter_value_count,
+    )?;
+    payload.set_item(
+        "resolved_materialized_component_count",
+        profile.resolved_materialized_component_count,
+    )?;
+    payload.set_item(
+        "total_materialized_value_count",
+        profile.total_materialized_value_count,
+    )?;
+    payload.set_item(
+        "final_output_copy_value_count",
+        profile.final_output_copy_value_count,
+    )?;
+    payload.set_item(
+        "observed_scratch_reallocation_count",
+        profile.observed_scratch_reallocation_count,
+    )?;
+    payload.set_item(
+        "native_output_allocation_count",
+        profile.native_output_allocation_count,
+    )?;
+    Ok(payload)
+}
+
+#[pyfunction]
+fn abi_version() -> u32 {
+    NativeRuntime::ABI_VERSION
+}
+
+#[pyfunction]
+fn package_version() -> &'static str {
+    option_env!("PYAMPLICOL_PACKAGE_VERSION").unwrap_or(env!("CARGO_PKG_VERSION"))
+}
+
+#[pyfunction]
+fn native_build_inputs_sha256() -> &'static str {
+    option_env!("PYAMPLICOL_NATIVE_BUILD_INPUTS_SHA256").unwrap_or("")
+}
+
+#[pyfunction]
+fn target_info() -> TargetInfo {
+    let target = runtime_target_info();
+    TargetInfo {
+        triple: target.triple,
+        cpu_features: target.cpu_features,
+    }
+}
+
+#[pyfunction]
+fn _preflight_eager_kernel_pack(manifest_path: PathBuf, payload_root: PathBuf) -> PyResult<usize> {
+    preflight_prepared_kernel_pack(&manifest_path, &payload_root).map_err(python_error)
+}
+
+#[pyfunction]
+fn _eager_direct_descriptor_v1(
+    py: Python<'_>,
+    source_application: &[u8],
+    input_complex_count: u32,
+    output_complex_count: u32,
+) -> PyResult<Py<PyBytes>> {
+    let descriptor = eager_direct_descriptor_for_source_application_bytes(
+        source_application,
+        input_complex_count,
+        output_complex_count,
+        std::path::Path::new("<prepared eager application>"),
+    )
+    .map_err(python_error)?;
+    Ok(PyBytes::new(py, &descriptor).unbind())
+}
+
+#[pyfunction]
+fn _compile_symjit_plane_application_v2(
+    py: Python<'_>,
+    program_repr: &str,
+    input_complex_count: usize,
+    output_complex_count: usize,
+    optimization_level: u8,
+    compress: bool,
+) -> PyResult<Py<PyBytes>> {
+    let application = compile_symbolica_program_to_plane_application_bytes(
+        program_repr,
+        input_complex_count,
+        output_complex_count,
+        optimization_level,
+        compress,
+    )
+    .map_err(python_error)?;
+    Ok(PyBytes::new(py, &application).unbind())
+}
+
+#[pyfunction]
+fn _build_recurrence_bootstrap_v1(
+    py: Python<'_>,
+    context_json: &[u8],
+    execution_json: &[u8],
+    physics_json: &[u8],
+) -> PyResult<Py<PyBytes>> {
+    let image = build_recurrence_bootstrap_image_v1(context_json, execution_json, physics_json)
+        .map_err(python_error)?;
+    Ok(PyBytes::new(py, &image).unbind())
+}
+
+#[pyfunction]
+fn _load_eager_reduction_groups_v1(
+    py: Python<'_>,
+    artifact_root: PathBuf,
+    process_id: String,
+) -> PyResult<Py<PyAny>> {
+    let result_process_id = process_id.clone();
+    let reduction_groups = py
+        .detach(move || NativeRuntime::load_eager_reduction_groups(artifact_root, &process_id))
+        .map_err(python_error)?;
+    let result = PyDict::new(py);
+    result.set_item("abi", "pyamplicol-eager-reduction-groups-v1")?;
+    result.set_item("runtime_layout_abi", "pyamplicol-eager-runtime-layout-v1")?;
+    result.set_item("process_id", result_process_id)?;
+    result.set_item(
+        "reduction_groups",
+        json_value_to_python(py, &reduction_groups)?,
+    )?;
+    Ok(result.into_any().unbind())
+}
+
+#[pyfunction]
+fn _load_eager_exact_sections_v1(
+    py: Python<'_>,
+    artifact_root: PathBuf,
+    process_id: String,
+) -> PyResult<Py<PyAny>> {
+    let sections = py
+        .detach(move || NativeRuntime::load_eager_exact_sections(artifact_root, &process_id))
+        .map_err(python_error)?;
+    eager_exact_sections_to_python(py, sections)
+}
+
+#[pyfunction]
+fn _load_recurrence_exact_sections_v1(
+    py: Python<'_>,
+    artifact_root: PathBuf,
+    process_id: String,
+) -> PyResult<Py<PyAny>> {
+    let sections = py
+        .detach(move || NativeRuntime::load_recurrence_exact_sections(artifact_root, &process_id))
+        .map_err(python_error)?;
+    recurrence_exact_sections_to_python(py, sections)
+}
+
+fn eager_exact_sections_to_python(
+    py: Python<'_>,
+    sections: rusticol_core::NativeEagerExactSections,
+) -> PyResult<Py<PyAny>> {
+    let result = PyDict::new(py);
+    result.set_item("abi", "pyamplicol-eager-exact-sections-v1")?;
+    result.set_item("runtime_layout_abi", "pyamplicol-eager-runtime-layout-v1")?;
+    result.set_item("process_id", sections.process_id)?;
+    result.set_item(
+        "exact_schema",
+        json_value_to_python(py, &sections.exact_schema)?,
+    )?;
+    result.set_item(
+        "reduction_groups",
+        json_value_to_python(py, &sections.reduction_groups)?,
+    )?;
+    result.set_item("selector_group_ids", sections.selector_group_ids)?;
+    result.set_item("selector_domains", sections.selector_domains)?;
+    result.set_item(
+        "couplings",
+        sections
+            .couplings
+            .into_iter()
+            .map(|row| {
+                (
+                    row.real_parameter_id,
+                    row.imaginary_parameter_id,
+                    row.constant_real,
+                    row.constant_imaginary,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "stages",
+        sections
+            .stages
+            .into_iter()
+            .map(|row| {
+                (
+                    row.stage_index,
+                    row.invocation_start,
+                    row.invocation_count,
+                    row.attachment_start,
+                    row.attachment_count,
+                    row.finalization_start,
+                    row.finalization_count,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "invocations",
+        sections
+            .invocations
+            .into_iter()
+            .map(|row| {
+                (
+                    row.kernel_id,
+                    row.left_value_slot_id,
+                    row.right_value_slot_id,
+                    row.left_momentum_slot_id,
+                    row.right_momentum_slot_id,
+                    row.coupling_slot_id,
+                    row.output_factor_source,
+                    row.attachment_start,
+                    row.attachment_count,
+                    row.selector_domain_id,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "attachments",
+        sections
+            .attachments
+            .into_iter()
+            .map(|row| {
+                (
+                    row.result_current_id,
+                    row.factor_numerators
+                        .into_iter()
+                        .map(|[real, imaginary]| (real, imaginary))
+                        .collect::<Vec<_>>(),
+                    row.factor_denominator
+                        .map(|[real, imaginary]| (real, imaginary)),
+                    row.selector_domain_id,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "finalizations",
+        sections
+            .finalizations
+            .into_iter()
+            .map(|row| {
+                (
+                    row.kernel_id,
+                    row.current_id,
+                    row.unpropagated_value_slot_id,
+                    row.propagated_value_slot_id,
+                    row.momentum_slot_id,
+                    row.unpropagated_selector_domain_id,
+                    row.propagated_selector_domain_id,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "closures",
+        sections
+            .closures
+            .into_iter()
+            .map(|row| {
+                (
+                    row.kernel_id,
+                    row.left_value_slot_id,
+                    row.right_value_slot_id,
+                    row.amplitude_index,
+                    row.coupling_slot_id,
+                    row.output_factor_source,
+                    row.factor_numerators
+                        .into_iter()
+                        .map(|[real, imaginary]| (real, imaginary))
+                        .collect::<Vec<_>>(),
+                    row.factor_denominator
+                        .map(|[real, imaginary]| (real, imaginary)),
+                    row.direct_coefficients.map(|values| {
+                        values
+                            .into_iter()
+                            .map(|[real, imaginary]| (real, imaginary))
+                            .collect::<Vec<_>>()
+                    }),
+                    row.coherent_group_id,
+                    row.selector_domain_id,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    Ok(result.into_any().unbind())
+}
+
+fn recurrence_exact_sections_to_python(
+    py: Python<'_>,
+    sections: rusticol_core::NativeRecurrenceExactSections,
+) -> PyResult<Py<PyAny>> {
+    let result = PyDict::new(py);
+    result.set_item("abi", "pyamplicol-recurrence-exact-sections-v1")?;
+    result.set_item(
+        "runtime_layout_abi",
+        "pyamplicol-recurrence-runtime-layout-v2",
+    )?;
+    result.set_item("process_id", sections.process_id)?;
+    result.set_item("strategy", sections.strategy)?;
+    result.set_item("semantic_digest", sections.semantic_digest)?;
+    result.set_item("runtime_layout_digest", sections.runtime_layout_digest)?;
+    result.set_item(
+        "counts",
+        (
+            sections.current_arena_components,
+            sections.amplitude_destination_count,
+            sections.parameter_value_count,
+            sections.external_source_count,
+        ),
+    )?;
+    result.set_item(
+        "currents",
+        sections
+            .currents
+            .into_iter()
+            .map(|row| {
+                (
+                    row.semantic_current_id,
+                    row.node_kind as u16,
+                    row.state_template_id,
+                    row.component_base,
+                    row.component_count,
+                    row.momentum_form_id,
+                    row.stage,
+                    row.selector_domain_id,
+                    row.first_use,
+                    row.last_use,
+                    row.source_row_or_sentinel,
+                    row.finalization_row_or_sentinel,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "sources",
+        sections
+            .sources
+            .into_iter()
+            .map(|row| {
+                (
+                    row.source_slot,
+                    row.destination_component_base,
+                    row.momentum_form_id,
+                    row.source_template_or_dispatch_domain,
+                    row.spin_state_class,
+                    row.exact_factor_id,
+                    row.selector_domain_id,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "contributions",
+        sections
+            .contributions
+            .into_iter()
+            .map(|row| {
+                (
+                    row.parent0_component_base,
+                    row.parent1_component_base_or_sentinel,
+                    row.parent0_momentum_form_id,
+                    row.parent1_momentum_form_id_or_sentinel,
+                    row.destination_component_base,
+                    row.exact_factor_id,
+                    row.selector_domain_id,
+                    row.flags,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "finalizations",
+        sections
+            .finalizations
+            .into_iter()
+            .map(|row| {
+                (
+                    row.component_base,
+                    row.component_count,
+                    row.momentum_form_id,
+                    row.exact_factor_id,
+                    row.selector_domain_id,
+                    row.flags,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "closures",
+        sections
+            .closures
+            .into_iter()
+            .map(|row| {
+                (
+                    row.parent0_component_base,
+                    row.parent1_component_base_or_sentinel,
+                    row.parent0_momentum_form_id,
+                    row.parent1_momentum_form_id_or_sentinel,
+                    row.amplitude_destination_id,
+                    row.exact_factor_id,
+                    row.component_factor_start,
+                    row.component_count,
+                    row.selector_domain_id,
+                    row.flags,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "row_groups",
+        sections
+            .row_groups
+            .into_iter()
+            .map(|row| {
+                (
+                    row.stage,
+                    row.role as u16,
+                    row.destination_operation as u16,
+                    row.direct_executor_id,
+                    row.row_start,
+                    row.row_count,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "momentum_forms",
+        sections
+            .momentum_forms
+            .into_iter()
+            .map(|row| (row.term_start, row.term_count))
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "momentum_terms",
+        sections
+            .momentum_terms
+            .into_iter()
+            .map(|row| (row.source_slot, row.coefficient))
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "replay_targets",
+        sections
+            .replay_targets
+            .into_iter()
+            .map(|row| {
+                (
+                    row.public_flow_id,
+                    row.representative_id,
+                    row.source_permutation_start,
+                    row.source_permutation_count,
+                    row.helicity_map_start,
+                    row.helicity_map_count,
+                    row.phase_exact_factor_id,
+                    row.multiplicity,
+                    row.selector_domain_id,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item("source_permutations", sections.source_permutations)?;
+    result.set_item("replay_momentum_signs", sections.replay_momentum_signs)?;
+    result.set_item("replay_helicity_map", sections.replay_helicity_map)?;
+    result.set_item(
+        "source_state_assignments",
+        sections
+            .source_state_assignments
+            .into_iter()
+            .map(|row| (row.source_slot, row.state_index))
+            .collect::<Vec<_>>(),
+    )?;
+    let source_dispatch_variants = sections
+        .source_dispatch_variants
+        .into_iter()
+        .map(|row| {
+            Ok(vec![
+                i64::try_from(row.embedding_start).map_err(|_| {
+                    PyValueError::new_err("recurrence source embedding offset exceeds i64")
+                })?,
+                i64::try_from(row.projection_start).map_err(|_| {
+                    PyValueError::new_err("recurrence source projection offset exceeds i64")
+                })?,
+                i64::from(row.source_row_id),
+                i64::from(row.dispatch_domain_id),
+                i64::from(row.runtime_variant_id),
+                i64::from(row.source_state_index),
+                i64::from(row.source_template_id),
+                i64::from(row.source_state_template_id),
+                i64::from(row.crossed_state_template_id),
+                i64::from(row.crossed_spin_state_class),
+                i64::from(row.direct_executor_id),
+                i64::from(row.crossing_exact_factor_id),
+                i64::from(row.embedding_count),
+                i64::from(row.projection_count),
+            ])
+        })
+        .collect::<PyResult<Vec<_>>>()?;
+    result.set_item("source_dispatch_variants", source_dispatch_variants)?;
+    result.set_item(
+        "source_embeddings",
+        sections
+            .source_embeddings
+            .into_iter()
+            .map(|row| {
+                (
+                    row.full_component,
+                    row.source_component_or_sentinel,
+                    row.exact_factor_id,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "source_projections",
+        sections
+            .source_projections
+            .into_iter()
+            .map(|row| (row.source_component, row.full_component))
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "resolved_source_selections",
+        sections
+            .resolved_source_selections
+            .into_iter()
+            .map(|row| (row.source_slot, row.dispatch_variant_id))
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "amplitude_destinations",
+        sections
+            .amplitude_destinations
+            .into_iter()
+            .map(|row| {
+                (
+                    row.closure_row_start,
+                    row.id,
+                    row.target_sector_id,
+                    row.target_helicity_id_or_sentinel,
+                    row.closure_row_count,
+                    row.selector_domain_id,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item(
+        "resolved_helicities",
+        sections
+            .resolved_helicities
+            .into_iter()
+            .map(|row| {
+                (
+                    row.source_state_start,
+                    row.source_selection_start,
+                    row.public_helicity_start,
+                    row.id,
+                    row.source_state_count,
+                    row.source_selection_count,
+                    row.public_helicity_count,
+                    row.selector_domain_id,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item("public_helicities", sections.public_helicities)?;
+    result.set_item(
+        "exact_factors",
+        sections
+            .exact_factors
+            .into_iter()
+            .map(|factor| {
+                (
+                    factor.real_numerator,
+                    factor.real_denominator,
+                    factor.imaginary_numerator,
+                    factor.imaginary_denominator,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item("public_flow_ids", sections.public_flow_ids)?;
+    result.set_item(
+        "executors",
+        sections
+            .executors
+            .into_iter()
+            .map(|executor| {
+                (
+                    executor.direct_executor_id,
+                    executor.role,
+                    executor.destination_operation,
+                    executor.parent_component_counts,
+                    executor.destination_component_count,
+                    executor.momentum_operand_count,
+                    executor.prepared_kernel_id,
+                    executor.runtime_template,
+                )
+            })
+            .collect::<Vec<_>>(),
+    )?;
+    Ok(result.into_any().unbind())
+}
+
+fn json_value_to_python(py: Python<'_>, value: &Value) -> PyResult<Py<PyAny>> {
+    match value {
+        Value::Null => Ok(py.None()),
+        Value::Bool(value) => value.into_py_any(py),
+        Value::Number(value) => {
+            if let Some(value) = value.as_i64() {
+                value.into_py_any(py)
+            } else if let Some(value) = value.as_u64() {
+                value.into_py_any(py)
+            } else if let Some(value) = value.as_f64() {
+                value.into_py_any(py)
+            } else {
+                Err(ArtifactError::new_err(
+                    "compact eager exact schema contains an invalid number",
+                ))
+            }
+        }
+        Value::String(value) => value.as_str().into_py_any(py),
+        Value::Array(values) => {
+            let values = values
+                .iter()
+                .map(|value| json_value_to_python(py, value))
+                .collect::<PyResult<Vec<_>>>()?;
+            Ok(PyList::new(py, values)?.into_any().unbind())
+        }
+        Value::Object(values) => {
+            let result = PyDict::new(py);
+            for (key, value) in values {
+                result.set_item(key, json_value_to_python(py, value)?)?;
+            }
+            Ok(result.into_any().unbind())
+        }
+    }
+}
+
+#[pymodule]
+fn _rusticol(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add("RusticolError", module.py().get_type::<RusticolError>())?;
+    module.add("ArtifactError", module.py().get_type::<ArtifactError>())?;
+    module.add(
+        "CompatibilityError",
+        module.py().get_type::<CompatibilityError>(),
+    )?;
+    module.add("EvaluationError", module.py().get_type::<EvaluationError>())?;
+    module.add("SelectorError", module.py().get_type::<SelectorError>())?;
+    module.add(
+        "ModelParameterError",
+        module.py().get_type::<ModelParameterError>(),
+    )?;
+    module.add_class::<Runtime>()?;
+    module.add_class::<ProcessPhysics>()?;
+    module.add_class::<ExternalParticle>()?;
+    module.add_class::<HelicityConfiguration>()?;
+    module.add_class::<ColorFlow>()?;
+    module.add_class::<ContractedColorComponent>()?;
+    module.add_class::<ReductionGroup>()?;
+    module.add_class::<PhysicsReduction>()?;
+    module.add_class::<ModelParameter>()?;
+    module.add_class::<ResolvedEvaluation>()?;
+    module.add_class::<TargetInfo>()?;
+    module.add_function(wrap_pyfunction!(abi_version, module)?)?;
+    module.add_function(wrap_pyfunction!(package_version, module)?)?;
+    module.add_function(wrap_pyfunction!(native_build_inputs_sha256, module)?)?;
+    module.add_function(wrap_pyfunction!(target_info, module)?)?;
+    module.add_function(wrap_pyfunction!(_preflight_eager_kernel_pack, module)?)?;
+    module.add_function(wrap_pyfunction!(
+        _compile_symjit_plane_application_v2,
+        module
+    )?)?;
+    module.add_function(wrap_pyfunction!(_build_recurrence_bootstrap_v1, module)?)?;
+    module.add_function(wrap_pyfunction!(_eager_direct_descriptor_v1, module)?)?;
+    module.add_function(wrap_pyfunction!(_load_eager_reduction_groups_v1, module)?)?;
+    module.add_function(wrap_pyfunction!(_load_eager_exact_sections_v1, module)?)?;
+    module.add_function(wrap_pyfunction!(
+        _load_recurrence_exact_sections_v1,
+        module
+    )?)?;
+    #[cfg(feature = "numpy")]
+    module.add_function(wrap_pyfunction!(
+        eager_lowering::_lower_eager_runtime_v1,
+        module
+    )?)?;
+    #[cfg(feature = "numpy")]
+    module.add_function(wrap_pyfunction!(
+        recurrence::_lower_recurrence_direct_v2,
+        module
+    )?)?;
+    #[cfg(all(feature = "numpy", feature = "on-the-fly-test-support"))]
+    module.add_function(wrap_pyfunction!(
+        recurrence::_on_the_fly_test_support_probe_v1,
+        module
+    )?)?;
+    #[cfg(all(feature = "numpy", feature = "on-the-fly-test-support"))]
+    module.add_function(wrap_pyfunction!(
+        recurrence::_on_the_fly_query_family_census_v1,
+        module
+    )?)?;
+    #[cfg(all(feature = "numpy", feature = "on-the-fly-test-support"))]
+    module.add_function(wrap_pyfunction!(
+        recurrence::_on_the_fly_artifact_probe_v1,
+        module
+    )?)?;
+    #[cfg(all(feature = "numpy", feature = "on-the-fly-test-support"))]
+    module.add_function(wrap_pyfunction!(
+        recurrence::_on_the_fly_execution_diagnostic_v1,
+        module
+    )?)?;
+    #[cfg(feature = "numpy")]
+    module.add_function(wrap_pyfunction!(
+        recurrence_template::_validate_recurrence_template_input_v1,
+        module
+    )?)?;
+    #[cfg(feature = "numpy")]
+    module.add_function(wrap_pyfunction!(
+        recurrence::_build_on_the_fly_process_seeds_v1,
+        module
+    )?)?;
+    #[cfg(feature = "numpy")]
+    module.add_function(wrap_pyfunction!(
+        recurrence::_build_on_the_fly_process_seed_v1,
+        module
+    )?)?;
+    #[cfg(feature = "numpy")]
+    module.add_function(wrap_pyfunction!(
+        recurrence::_inspect_on_the_fly_process_seed_v1,
+        module
+    )?)?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rusticol_core::{
+        ContractedColor as CoreContractedColor, Coverage, ExternalParticle as CoreExternalParticle,
+        Helicity, LcColorFlow, Reduction, ReductionGroup as CoreReductionGroup, ReductionKind,
+        SelectorCapabilities,
+    };
+
+    #[cfg(not(feature = "on-the-fly-test-support"))]
+    #[test]
+    fn default_build_exposes_loaded_on_the_fly_state_census_binding() {
+        let binding: fn(&Runtime) -> PyResult<Option<String>> =
+            Runtime::_on_the_fly_runtime_state_census_json;
+        let _ = binding;
+    }
+
+    #[test]
+    fn raw_runtime_accepts_only_f64_precision() {
+        assert!(require_raw_f64_precision(16).is_ok());
+        let error = require_raw_f64_precision(32).unwrap_err();
+        assert_eq!(error.kind(), RusticolErrorKind::Compatibility);
+        assert!(error.to_string().contains("only precision=16"));
+        assert!(
+            error
+                .to_string()
+                .contains("public Python Symbolica executor")
+        );
+    }
+
+    #[test]
+    fn detached_runtime_guard_allows_only_its_origin_thread() {
+        let origin = thread::current().id();
+        assert!(require_origin_thread(origin).is_ok());
+
+        let error = thread::spawn(move || require_origin_thread(origin).unwrap_err())
+            .join()
+            .expect("thread guard check must not panic");
+        assert_eq!(error.kind(), RusticolErrorKind::Internal);
+        assert!(error.to_string().contains("owning thread"));
+    }
+
+    #[test]
+    fn process_physics_maps_the_canonical_python_metadata_fields() {
+        let mut physics = CoreProcessPhysics {
+            schema_version: 1,
+            kind: "pyamplicol-resolved-physics".to_string(),
+            process_id: "p0".to_string(),
+            process: "d d~ > z".to_string(),
+            color_accuracy: ColorAccuracy::Lc,
+            coverage: Coverage {
+                helicities: "complete".to_string(),
+                color: "complete".to_string(),
+                color_kind: "physical-lc-flows".to_string(),
+                structural_zero_helicity_count: 0,
+            },
+            external_particles: vec![
+                core_particle(0, "d", 1, ParticleRole::Initial),
+                core_particle(1, "d~", -1, ParticleRole::Initial),
+                core_particle(2, "z", 23, ParticleRole::Final),
+            ],
+            helicities: vec![Helicity {
+                id: "h0".to_string(),
+                index: 0,
+                values: vec![-1, 1, 0],
+                computed: true,
+                structural_zero: false,
+                representative_id: "h0".to_string(),
+                coefficient: 2.0,
+            }],
+            color_components: vec![CoreColorComponent::LcFlow(LcColorFlow {
+                id: "c0".to_string(),
+                index: 0,
+                word: vec![1, 2],
+                computed: true,
+                representative_id: "c0".to_string(),
+                coefficient: 3.0,
+            })],
+            reduction: Reduction {
+                kind: ReductionKind::LcDiagonal,
+                groups: vec![CoreReductionGroup {
+                    id: "group:0".to_string(),
+                    representative_helicity_id: "h0".to_string(),
+                    representative_color_id: "c0".to_string(),
+                    physical_helicity_ids: vec!["h0".to_string()],
+                    physical_color_ids: vec!["c0".to_string()],
+                }],
+            },
+            model_parameters: vec![CoreModelParameter {
+                name: "alpha_s".to_string(),
+                kind: ParameterKind::Coupling,
+                default_real: 0.118,
+                default_imaginary: 0.0,
+                mutable: true,
+            }],
+            selectors: SelectorCapabilities {
+                helicity: true,
+                color_flow: true,
+                contracted_color: false,
+            },
+            extensions: BTreeMap::new(),
+        };
+
+        physics.validate().unwrap();
+        let mapped = ProcessPhysics::from_core(&physics);
+
+        assert_eq!(mapped.process_id, "p0");
+        assert_eq!(mapped.process, "d d~ > z");
+        assert_eq!(mapped.color_accuracy, "lc");
+        assert_eq!(mapped.helicity_coverage, "complete");
+        assert_eq!(mapped.color_coverage, "complete");
+        assert_eq!(mapped.color_kind, "physical-lc-flows");
+        assert_eq!(mapped.structural_zero_helicity_count, 0);
+        assert_eq!(mapped.external_particles[0].name, "d");
+        assert_eq!(mapped.external_particles[0].pdg_id, 1);
+        assert_eq!(mapped.external_particles[0].state, "incoming");
+        assert_eq!(mapped.external_particles[2].state, "outgoing");
+        assert_eq!(mapped.helicities[0].representative_id, "h0");
+        assert_eq!(mapped.helicities[0].coefficient, 2.0);
+        assert_eq!(mapped.color_flows[0].word, vec![1, 2]);
+        assert_eq!(mapped.color_flows[0].coefficient, 3.0);
+        assert!(mapped.contracted_color_components.is_empty());
+        assert_eq!(mapped.reduction.kind, "lc-diagonal");
+        assert_eq!(mapped.reduction.groups[0].id, "group:0");
+        assert_eq!(mapped.reduction.groups[0].physical_helicity_ids, vec!["h0"]);
+        assert_eq!(mapped.model_parameters[0].kind, "coupling");
+        assert_eq!(mapped.model_parameters[0].default_real, 0.118);
+        assert!(mapped.model_parameters[0].mutable);
+        assert_eq!(mapped.selector_capabilities, vec!["helicity", "color_flow"]);
+
+        physics.color_accuracy = ColorAccuracy::Full;
+        physics.coverage.color = "contracted".to_string();
+        physics.coverage.color_kind = "contracted-color".to_string();
+        physics.color_components = vec![CoreColorComponent::ContractedColor(CoreContractedColor {
+            id: "contracted".to_string(),
+            index: 0,
+            description: "fully contracted color".to_string(),
+        })];
+        physics.reduction.kind = ReductionKind::ContractedColor;
+        physics.reduction.groups[0].representative_color_id = "contracted".to_string();
+        physics.reduction.groups[0].physical_color_ids = vec!["contracted".to_string()];
+        physics.selectors.color_flow = false;
+        physics.validate().unwrap();
+
+        let mapped = ProcessPhysics::from_core(&physics);
+        assert!(mapped.color_flows.is_empty());
+        assert_eq!(mapped.contracted_color_components[0].id, "contracted");
+        assert_eq!(mapped.selector_capabilities, vec!["helicity"]);
+    }
+
+    #[test]
+    fn target_info_is_canonical_and_matches_the_core() {
+        let mapped = target_info();
+        let core = runtime_target_info();
+        assert_eq!(mapped.triple, core.triple);
+        assert_eq!(mapped.cpu_features, core.cpu_features);
+        assert!(mapped.cpu_features.windows(2).all(|pair| pair[0] < pair[1]));
+    }
+
+    fn core_particle(
+        index: usize,
+        name: &str,
+        pdg: i32,
+        role: ParticleRole,
+    ) -> CoreExternalParticle {
+        CoreExternalParticle {
+            index,
+            label: index + 1,
+            particle: name.to_string(),
+            pdg,
+            role,
+            momentum_slot: index,
+            momentum_components: ["E", "px", "py", "pz"].map(str::to_string),
+        }
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-python/src/recurrence.rs b/pyamplicol/rust/crates/rusticol-python/src/recurrence.rs
new file mode 100644
index 0000000000..bafa3e8045
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/src/recurrence.rs
@@ -0,0 +1,5866 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Private Python boundary for Direct-Arena recurrence lowering.
+//!
+//! Python supplies authenticated fixed-width builder and prepared-template
+//! columns. Rust constructs the compact recurrence, lowers its direct arena
+//! plan, and publishes the plan-v2 PACBIN without exposing an intermediate
+//! packet schedule.
+
+use numpy::{PyReadonlyArrayDyn, PyUntypedArrayMethods};
+use pyo3::exceptions::{PyTypeError, PyValueError};
+use pyo3::prelude::*;
+use pyo3::types::{PyAny, PyBytes, PyDict, PyList};
+use rusticol_core::recurrence::process;
+use rusticol_core::recurrence::template;
+use rusticol_core::recurrence::{
+    AuthenticatedRecurrenceBuilderInput, CLOSURE_TARGET_DOMAIN_PROOF_KIND, CheckedTableRange,
+    DIRECT_NONE_U32, DirectExecutorRole, DirectRecurrencePlan, DirectRecurrenceRuntimeOptions,
+    DirectSelectorWorkSummary, PreparedDirectExecutorBinding, PreparedDirectExecutorCatalog,
+    RECURRENCE_BUILDER_INPUT_ABI, RECURRENCE_CONTRACTED_COLOR_CAPABILITY,
+    RECURRENCE_DIRECT_PLAN_ABI, RECURRENCE_DIRECT_RUNTIME_CAPABILITY,
+    RECURRENCE_DIRECT_RUNTIME_LAYOUT_ABI, RECURRENCE_DIRECT_SCHEDULE_MEMBER,
+    RECURRENCE_DIRECT_TEMPLATE_ABI, RECURRENCE_LC_COLOR_CAPABILITY, RecurrenceBuildProgress,
+    RecurrenceGenerationTelemetry, RecurrenceRelationDiscoveryMode,
+    RecurrenceRelationDiscoveryOptions, RecurrenceRelationDiscoveryReport, RecurrenceStrategy,
+    SemanticDigest, authenticate_recurrence_numerical_relation_provenance, checked_usize,
+    lower_recurrence_direct_plan_v2, lower_recurrence_direct_plan_v2_with_helicity_dispatch,
+    lower_recurrence_direct_plan_v2_with_relation_discovery,
+    write_recurrence_direct_plan_pacbin_with_projection_certificate,
+    write_recurrence_helicity_dispatch_v1_atomic,
+};
+#[cfg(feature = "on-the-fly-test-support")]
+use rusticol_core::recurrence::{
+    ConstructionTransitionDiagnosticRowV1, ExactComplexRational, OnTheFlyQueryFamilyCensusV1,
+    OnTheFlyTestSupportReportV1, on_the_fly_query_family_census_v1,
+    on_the_fly_test_support_probe_v1,
+};
+#[cfg(feature = "on-the-fly-test-support")]
+use rusticol_core::{
+    NativeOnTheFlyArtifactProbeV1, NativeOnTheFlyExecutionDiagnosticV1, NativeRuntime,
+};
+use rusticol_core::{
+    NativeRecurrenceExactExecutor, NativeRecurrenceExactFactor, NativeRecurrenceExactSections,
+    RusticolError, RusticolResult,
+};
+use serde_json::{Map as JsonMap, Value as JsonValue};
+use sha2::{Digest, Sha256};
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::PathBuf;
+use std::time::Instant;
+
+use crate::python_error;
+use crate::recurrence_numerical_evidence::{
+    authenticated_runtime_parameter_contract, parse_numerical_relation_evidence,
+};
+
+const RUNTIME_CONTAINER_KIND: &str = "pyamplicol-recurrence-runtime-container";
+const RUNTIME_CONTAINER_SCHEMA_VERSION: u32 = 1;
+const STORAGE_ABI: &str = "pacbin-v1";
+const DIRECT_BUILDER_INPUT_ABI: &str = "pyamplicol-recurrence-builder-input-v2";
+const DIRECT_LOWERING_RESULT_KIND: &str = "pyamplicol-recurrence-direct-lowering-result";
+const DIRECT_LOWERING_RESULT_SCHEMA_VERSION: u32 = 4;
+const RECURRENCE_HELICITY_DISPATCH_ABI: &str = "pyamplicol-recurrence-helicity-dispatch-v1";
+const DIRECT_CANONICALIZATION_ABI: &str = "pyamplicol-canonical-json-v1";
+const DIRECT_BACKEND_ABI: &str = "rusticol.recurrence-direct-backend.v1";
+const DIRECT_PAYLOAD_BINDING_ABI: &str = "pyamplicol-recurrence-plane-binding-v2";
+const DIRECT_IDENTITY_FINALIZER: &str = "rusticol.identity-finalize-in-place.v1";
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum PrimitiveKind {
+    U8,
+    U32,
+    U64,
+    I32,
+}
+
+impl PrimitiveKind {
+    const fn dtype(self) -> &'static str {
+        match self {
+            Self::U8 => "|u1",
+            Self::U32 => "<u4",
+            Self::U64 => "<u8",
+            Self::I32 => "<i4",
+        }
+    }
+
+    fn from_dtype(value: &str) -> Option<Self> {
+        match value {
+            "|u1" => Some(Self::U8),
+            "<u4" => Some(Self::U32),
+            "<u8" => Some(Self::U64),
+            "<i4" => Some(Self::I32),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+struct ColumnSpec {
+    name: &'static str,
+    kind: PrimitiveKind,
+    tail_shape: &'static [usize],
+}
+
+#[derive(Clone, Copy)]
+struct TableSpec {
+    name: &'static str,
+    columns: &'static [ColumnSpec],
+}
+
+const fn column(name: &'static str, kind: PrimitiveKind) -> ColumnSpec {
+    ColumnSpec {
+        name,
+        kind,
+        tail_shape: &[],
+    }
+}
+
+const fn shaped_column(
+    name: &'static str,
+    kind: PrimitiveKind,
+    tail_shape: &'static [usize],
+) -> ColumnSpec {
+    ColumnSpec {
+        name,
+        kind,
+        tail_shape,
+    }
+}
+
+const TABLE_SPECS: &[TableSpec] = &[
+    TableSpec {
+        name: "bitset_ranges",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("start", PrimitiveKind::U64),
+            column("count", PrimitiveKind::U64),
+            column("bit_count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "bitset_words",
+        columns: &[column("value", PrimitiveKind::U64)],
+    },
+    TableSpec {
+        name: "coupling_limits",
+        columns: &[
+            column("name_string_id", PrimitiveKind::U32),
+            column("minimum", PrimitiveKind::U32),
+            column("maximum", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "digest_catalog",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            shaped_column("value", PrimitiveKind::U8, &[32]),
+        ],
+    },
+    TableSpec {
+        name: "exact_factors",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("real_numerator_string_id", PrimitiveKind::U32),
+            column("real_denominator_string_id", PrimitiveKind::U32),
+            column("imag_numerator_string_id", PrimitiveKind::U32),
+            column("imag_denominator_string_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "external_legs",
+        columns: &[
+            column("source_slot", PrimitiveKind::U32),
+            column("public_label", PrimitiveKind::U32),
+            column("physical_pdg", PrimitiveKind::I32),
+            column("outgoing_pdg", PrimitiveKind::I32),
+            column("is_initial", PrimitiveKind::U8),
+            column("is_fermionic", PrimitiveKind::U8),
+            column("source_state_start", PrimitiveKind::U64),
+            column("source_state_count", PrimitiveKind::U64),
+            column("momentum_mask_id", PrimitiveKind::U32),
+            column("support_mask_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "header",
+        columns: &[
+            column("schema_version", PrimitiveKind::U32),
+            column("abi_string_id", PrimitiveKind::U32),
+            column("process_id_string_id", PrimitiveKind::U32),
+            column("layout", PrimitiveKind::U8),
+            column("selected_flow_mode", PrimitiveKind::U8),
+            column("selected_source_mode", PrimitiveKind::U8),
+            column("external_leg_count", PrimitiveKind::U32),
+            column("physical_sector_count", PrimitiveKind::U32),
+            column("public_flow_count", PrimitiveKind::U32),
+            column("replay_partition_count", PrimitiveKind::U32),
+            column("coupling_limit_count", PrimitiveKind::U32),
+            column("parameter_projection_count", PrimitiveKind::U32),
+            column("process_support_mask_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "header_digests",
+        columns: &[
+            column("role_string_id", PrimitiveKind::U32),
+            column("digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "lc_open_strings",
+        columns: &[
+            column("sector_id", PrimitiveKind::U32),
+            column("ordinal", PrimitiveKind::U32),
+            column("fundamental_source_slot", PrimitiveKind::U32),
+            column("antifundamental_source_slot", PrimitiveKind::U32),
+            column("adjoint_sequence_id", PrimitiveKind::U32),
+            column("singlet_sequence_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "normalization",
+        columns: &[
+            column("factor_id", PrimitiveKind::U32),
+            column("convention_string_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "parameter_projection",
+        columns: &[
+            column("runtime_slot", PrimitiveKind::U32),
+            column("runtime_name_string_id", PrimitiveKind::U32),
+            column("parameter_template_id", PrimitiveKind::U32),
+            column("prepared_parameter_id", PrimitiveKind::U32),
+            column("component", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "physical_lc_sectors",
+        columns: &[
+            column("sector_id", PrimitiveKind::U32),
+            column("public_id_string_id", PrimitiveKind::U32),
+            column("kind", PrimitiveKind::U8),
+            column("closure_source_slot", PrimitiveKind::U32),
+            column("closure_proof_algorithm_string_id", PrimitiveKind::U32),
+            column("closure_proof_digest_id", PrimitiveKind::U32),
+            column("open_string_start", PrimitiveKind::U64),
+            column("open_string_count", PrimitiveKind::U64),
+            column("trace_sequence_id", PrimitiveKind::U32),
+            column("singlet_sequence_id", PrimitiveKind::U32),
+            column("word_sequence_id", PrimitiveKind::U32),
+            column("support_mask_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "public_lc_flows",
+        columns: &[
+            column("flow_id", PrimitiveKind::U32),
+            column("public_id_string_id", PrimitiveKind::U32),
+            column("construction_sector_id", PrimitiveKind::U32),
+            column("word_sequence_id", PrimitiveKind::U32),
+            column("source_slot_permutation_sequence_id", PrimitiveKind::U32),
+            column("reduction_weight_factor_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "replay_partitions",
+        columns: &[
+            column("partition_id", PrimitiveKind::U32),
+            column("representative_sector_id", PrimitiveKind::U32),
+            column("materialized_sector_id", PrimitiveKind::U32),
+            column("target_start", PrimitiveKind::U64),
+            column("target_count", PrimitiveKind::U64),
+            column("proof_algorithm_string_id", PrimitiveKind::U32),
+            column("proof_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "replay_targets",
+        columns: &[
+            column("partition_id", PrimitiveKind::U32),
+            column("sector_id", PrimitiveKind::U32),
+            column("external_permutation_sequence_id", PrimitiveKind::U32),
+            column("source_slot_permutation_sequence_id", PrimitiveKind::U32),
+            column("amplitude_phase_factor_id", PrimitiveKind::U32),
+            column("fermion_sign", PrimitiveKind::I32),
+        ],
+    },
+    TableSpec {
+        name: "selected_public_flow_coverage",
+        columns: &[column("flow_id", PrimitiveKind::U32)],
+    },
+    TableSpec {
+        name: "selected_source_coverage",
+        columns: &[
+            column("source_slot", PrimitiveKind::U32),
+            column("source_state_index", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "semantic_template_references",
+        columns: &[
+            column("kind_string_id", PrimitiveKind::U32),
+            column("template_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+            column("prepared_kernel_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "source_states",
+        columns: &[
+            column("source_slot", PrimitiveKind::U32),
+            column("state_index", PrimitiveKind::U32),
+            column("public_helicity", PrimitiveKind::I32),
+            column("chirality", PrimitiveKind::I32),
+            column("spin_state", PrimitiveKind::I32),
+            column("current_state_template_id", PrimitiveKind::U32),
+            column("source_template_id", PrimitiveKind::U32),
+            column("momentum_sign", PrimitiveKind::I32),
+            column("crossing_phase_factor_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "string_bytes",
+        columns: &[column("value", PrimitiveKind::U8)],
+    },
+    TableSpec {
+        name: "string_ranges",
+        columns: &[
+            column("start", PrimitiveKind::U64),
+            column("count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "u32_sequence_ranges",
+        columns: &[
+            column("start", PrimitiveKind::U64),
+            column("count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "u32_sequence_values",
+        columns: &[column("value", PrimitiveKind::U32)],
+    },
+];
+
+const FERMION_PAIRING_TABLE_SPECS: &[TableSpec] = &[
+    TableSpec {
+        name: "header",
+        columns: &[
+            column("schema_version", PrimitiveKind::U32),
+            column("abi_string_id", PrimitiveKind::U32),
+            column("process_key_string_id", PrimitiveKind::U32),
+            column("proof_algorithm_string_id", PrimitiveKind::U32),
+            column("source_count", PrimitiveKind::U32),
+            column("endpoint_count", PrimitiveKind::U32),
+            column("pairing_class_count", PrimitiveKind::U32),
+            column("rule_count", PrimitiveKind::U32),
+            column("endpoint_state_template_count", PrimitiveKind::U64),
+            column("endpoint_anti_state_template_count", PrimitiveKind::U64),
+            column("endpoint_basis_count", PrimitiveKind::U64),
+            column("endpoint_color_representation_count", PrimitiveKind::U64),
+            column("class_fundamental_slot_count", PrimitiveKind::U64),
+            column("class_antifundamental_slot_count", PrimitiveKind::U64),
+            column("class_reference_pairing_count", PrimitiveKind::U64),
+            column("rule_class_pairing_index_count", PrimitiveKind::U64),
+            column("rule_endpoint_pairing_count", PrimitiveKind::U64),
+            column("rule_source_permutation_count", PrimitiveKind::U64),
+            column("rule_lineage_count", PrimitiveKind::U64),
+            column("exact_integer_count", PrimitiveKind::U32),
+            column("exact_integer_limb_count", PrimitiveKind::U64),
+            column("string_count", PrimitiveKind::U32),
+            column("string_byte_count", PrimitiveKind::U64),
+            column("no_fermion_line", PrimitiveKind::U32),
+            shaped_column("topology_digest", PrimitiveKind::U8, &[32]),
+            shaped_column("semantic_digest", PrimitiveKind::U8, &[32]),
+        ],
+    },
+    TableSpec {
+        name: "endpoints",
+        columns: &[
+            column("endpoint_id", PrimitiveKind::U32),
+            column("source_slot", PrimitiveKind::U32),
+            column("public_label", PrimitiveKind::U32),
+            column("species_class_id", PrimitiveKind::U32),
+            column("species_string_id", PrimitiveKind::U32),
+            column("particle_orientation", PrimitiveKind::U8),
+            column("color_orientation", PrimitiveKind::U8),
+            column("state_template_start", PrimitiveKind::U64),
+            column("state_template_count", PrimitiveKind::U64),
+            column("anti_state_template_start", PrimitiveKind::U64),
+            column("anti_state_template_count", PrimitiveKind::U64),
+            column("basis_start", PrimitiveKind::U64),
+            column("basis_count", PrimitiveKind::U64),
+            column("color_representation_start", PrimitiveKind::U64),
+            column("color_representation_count", PrimitiveKind::U64),
+            shaped_column("contract_digest", PrimitiveKind::U8, &[32]),
+        ],
+    },
+    TableSpec {
+        name: "endpoint_state_template_ids",
+        columns: &[column("string_id", PrimitiveKind::U32)],
+    },
+    TableSpec {
+        name: "endpoint_anti_state_template_ids",
+        columns: &[column("string_id", PrimitiveKind::U32)],
+    },
+    TableSpec {
+        name: "endpoint_basis_ids",
+        columns: &[column("string_id", PrimitiveKind::U32)],
+    },
+    TableSpec {
+        name: "endpoint_color_representations",
+        columns: &[column("value", PrimitiveKind::I32)],
+    },
+    TableSpec {
+        name: "pairing_classes",
+        columns: &[
+            column("class_id", PrimitiveKind::U32),
+            column("species_class_id", PrimitiveKind::U32),
+            column("species_string_id", PrimitiveKind::U32),
+            column("fundamental_slot_start", PrimitiveKind::U64),
+            column("fundamental_slot_count", PrimitiveKind::U64),
+            column("antifundamental_slot_start", PrimitiveKind::U64),
+            column("antifundamental_slot_count", PrimitiveKind::U64),
+            column("reference_pairing_start", PrimitiveKind::U64),
+            column("reference_pairing_count", PrimitiveKind::U64),
+            column("pairing_count", PrimitiveKind::U64),
+            shaped_column("proof_digest", PrimitiveKind::U8, &[32]),
+        ],
+    },
+    TableSpec {
+        name: "class_fundamental_slots",
+        columns: &[column("source_slot", PrimitiveKind::U32)],
+    },
+    TableSpec {
+        name: "class_antifundamental_slots",
+        columns: &[column("source_slot", PrimitiveKind::U32)],
+    },
+    TableSpec {
+        name: "class_reference_pairings",
+        columns: &[
+            column("fundamental_source_slot", PrimitiveKind::U32),
+            column("antifundamental_source_slot", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "rules",
+        columns: &[
+            column("rule_id", PrimitiveKind::U32),
+            column("class_pairing_index_start", PrimitiveKind::U64),
+            column("class_pairing_index_count", PrimitiveKind::U64),
+            column("endpoint_pairing_start", PrimitiveKind::U64),
+            column("endpoint_pairing_count", PrimitiveKind::U64),
+            column("source_permutation_start", PrimitiveKind::U64),
+            column("source_permutation_count", PrimitiveKind::U64),
+            column("lineage_start", PrimitiveKind::U64),
+            column("lineage_count", PrimitiveKind::U64),
+            column("fermion_parity", PrimitiveKind::I32),
+            column("real_numerator_integer_id", PrimitiveKind::U32),
+            column("real_denominator_integer_id", PrimitiveKind::U32),
+            column("imag_numerator_integer_id", PrimitiveKind::U32),
+            column("imag_denominator_integer_id", PrimitiveKind::U32),
+            column("multiplicity", PrimitiveKind::U64),
+            column("proof_algorithm_string_id", PrimitiveKind::U32),
+            shaped_column("proof_digest", PrimitiveKind::U8, &[32]),
+        ],
+    },
+    TableSpec {
+        name: "rule_class_pairing_indices",
+        columns: &[
+            column("class_id", PrimitiveKind::U32),
+            column("pairing_index", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "rule_endpoint_pairings",
+        columns: &[
+            column("fundamental_source_slot", PrimitiveKind::U32),
+            column("antifundamental_source_slot", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "rule_source_slot_permutations",
+        columns: &[column("source_slot", PrimitiveKind::U32)],
+    },
+    TableSpec {
+        name: "rule_lineages",
+        columns: &[column("line_id", PrimitiveKind::U32)],
+    },
+    TableSpec {
+        name: "exact_integers",
+        columns: &[
+            column("integer_id", PrimitiveKind::U32),
+            column("sign", PrimitiveKind::I32),
+            column("limb_start", PrimitiveKind::U64),
+            column("limb_count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "exact_integer_limbs",
+        columns: &[column("value", PrimitiveKind::U64)],
+    },
+    TableSpec {
+        name: "string_ranges",
+        columns: &[
+            column("string_id", PrimitiveKind::U32),
+            column("start", PrimitiveKind::U64),
+            column("count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "string_bytes",
+        columns: &[column("value", PrimitiveKind::U8)],
+    },
+];
+
+#[derive(Clone)]
+enum OwnedValues {
+    U8(Vec<u8>),
+    U32(Vec<u32>),
+    U64(Vec<u64>),
+    I32(Vec<i32>),
+}
+
+impl OwnedValues {
+    fn raw_bytes(&self) -> &[u8] {
+        fn bytes<T>(values: &[T]) -> &[u8] {
+            // Accepted multi-byte arrays are explicitly little-endian and this
+            // module rejects big-endian hosts before extraction.
+            unsafe {
+                std::slice::from_raw_parts(
+                    values.as_ptr().cast::<u8>(),
+                    std::mem::size_of_val(values),
+                )
+            }
+        }
+        match self {
+            Self::U8(values) => values,
+            Self::U32(values) => bytes(values),
+            Self::U64(values) => bytes(values),
+            Self::I32(values) => bytes(values),
+        }
+    }
+
+    fn as_u8(&self, context: &str) -> RusticolResult<&[u8]> {
+        match self {
+            Self::U8(values) => Ok(values),
+            _ => Err(wrong_type(context, "u8")),
+        }
+    }
+
+    fn as_u32(&self, context: &str) -> RusticolResult<&[u32]> {
+        match self {
+            Self::U32(values) => Ok(values),
+            _ => Err(wrong_type(context, "u32")),
+        }
+    }
+
+    fn as_u64(&self, context: &str) -> RusticolResult<&[u64]> {
+        match self {
+            Self::U64(values) => Ok(values),
+            _ => Err(wrong_type(context, "u64")),
+        }
+    }
+
+    fn as_i32(&self, context: &str) -> RusticolResult<&[i32]> {
+        match self {
+            Self::I32(values) => Ok(values),
+            _ => Err(wrong_type(context, "i32")),
+        }
+    }
+}
+
+#[derive(Clone)]
+struct OwnedColumn {
+    name: String,
+    dtype: &'static str,
+    shape: Vec<u64>,
+    values: OwnedValues,
+}
+
+#[derive(Clone)]
+struct OwnedTable {
+    name: String,
+    row_count: u64,
+    columns: Vec<OwnedColumn>,
+    column_by_name: BTreeMap<String, usize>,
+}
+
+impl OwnedTable {
+    fn row_count(&self) -> RusticolResult<usize> {
+        checked_usize(self.row_count, &format!("{} row count", self.name))
+    }
+
+    fn column(&self, name: &str) -> RusticolResult<&OwnedColumn> {
+        let index = self.column_by_name.get(name).ok_or_else(|| {
+            invalid(format!(
+                "recurrence builder table {:?} has no column {name:?}",
+                self.name
+            ))
+        })?;
+        Ok(&self.columns[*index])
+    }
+
+    fn u8(&self, column: &str) -> RusticolResult<&[u8]> {
+        self.column(column)?
+            .values
+            .as_u8(&format!("{}.{column}", self.name))
+    }
+
+    fn u32(&self, column: &str) -> RusticolResult<&[u32]> {
+        self.column(column)?
+            .values
+            .as_u32(&format!("{}.{column}", self.name))
+    }
+
+    fn u64(&self, column: &str) -> RusticolResult<&[u64]> {
+        self.column(column)?
+            .values
+            .as_u64(&format!("{}.{column}", self.name))
+    }
+
+    fn i32(&self, column: &str) -> RusticolResult<&[i32]> {
+        self.column(column)?
+            .values
+            .as_i32(&format!("{}.{column}", self.name))
+    }
+}
+
+#[derive(Clone)]
+struct OwnedInput {
+    abi: String,
+    declared_digest: String,
+    tables: Vec<OwnedTable>,
+    table_by_name: BTreeMap<String, usize>,
+    declared_fermion_pairing_digest: Option<String>,
+    fermion_pairing_tables: Vec<OwnedTable>,
+    fermion_pairing_table_by_name: BTreeMap<String, usize>,
+}
+
+impl OwnedInput {
+    fn table(&self, name: &str) -> RusticolResult<&OwnedTable> {
+        let index = self
+            .table_by_name
+            .get(name)
+            .ok_or_else(|| invalid(format!("recurrence builder input has no table {name:?}")))?;
+        Ok(&self.tables[*index])
+    }
+
+    fn column(&self, table: &str, column: &str) -> RusticolResult<&OwnedColumn> {
+        self.table(table)?.column(column)
+    }
+
+    fn u8(&self, table: &str, column: &str) -> RusticolResult<&[u8]> {
+        self.column(table, column)?
+            .values
+            .as_u8(&format!("{table}.{column}"))
+    }
+
+    fn u32(&self, table: &str, column: &str) -> RusticolResult<&[u32]> {
+        self.column(table, column)?
+            .values
+            .as_u32(&format!("{table}.{column}"))
+    }
+
+    fn u64(&self, table: &str, column: &str) -> RusticolResult<&[u64]> {
+        self.column(table, column)?
+            .values
+            .as_u64(&format!("{table}.{column}"))
+    }
+
+    fn i32(&self, table: &str, column: &str) -> RusticolResult<&[i32]> {
+        self.column(table, column)?
+            .values
+            .as_i32(&format!("{table}.{column}"))
+    }
+
+    fn fermion_pairing_table(&self, name: &str) -> RusticolResult<&OwnedTable> {
+        let index = self
+            .fermion_pairing_table_by_name
+            .get(name)
+            .ok_or_else(|| invalid(format!("recurrence fermion pairing has no table {name:?}")))?;
+        Ok(&self.fermion_pairing_tables[*index])
+    }
+
+    fn pairing_u8(&self, table: &str, column: &str) -> RusticolResult<&[u8]> {
+        self.fermion_pairing_table(table)?.u8(column)
+    }
+
+    fn pairing_u32(&self, table: &str, column: &str) -> RusticolResult<&[u32]> {
+        self.fermion_pairing_table(table)?.u32(column)
+    }
+
+    fn pairing_u64(&self, table: &str, column: &str) -> RusticolResult<&[u64]> {
+        self.fermion_pairing_table(table)?.u64(column)
+    }
+
+    fn pairing_i32(&self, table: &str, column: &str) -> RusticolResult<&[i32]> {
+        self.fermion_pairing_table(table)?.i32(column)
+    }
+}
+
+const TEMPLATE_TABLE_INVENTORY: &[(&str, usize)] = &[
+    ("catalog_header", 20),
+    ("closures", 20),
+    ("color_contractions", 14),
+    ("color_nc_terms", 3),
+    ("contact_orbit_certificates", 11),
+    ("contact_orbit_steps", 10),
+    ("coupling_order_ranges", 3),
+    ("coupling_order_terms", 3),
+    ("current_states", 17),
+    ("digest_catalog", 2),
+    ("evaluator_bindings", 14),
+    ("exact_factors", 5),
+    ("flavour_flow_ranges", 3),
+    ("flavour_flow_values", 1),
+    ("i32_sequence_ranges", 3),
+    ("i32_sequence_values", 1),
+    ("lc_color_transition_witnesses", 15),
+    ("parameters", 11),
+    ("propagators", 12),
+    ("quantum_flows", 16),
+    ("quantum_number_flow_ranges", 3),
+    ("quantum_number_flow_terms", 3),
+    ("runtime_helicity_contracts", 8),
+    ("runtime_helicity_embeddings", 4),
+    ("runtime_helicity_projections", 3),
+    ("runtime_helicity_variants", 9),
+    ("sources", 20),
+    ("string_bytes", 1),
+    ("string_ranges", 2),
+    ("symmetry_proofs", 9),
+    ("transitions", 20),
+    ("u32_sequence_ranges", 3),
+    ("u32_sequence_values", 1),
+];
+
+struct PreparedTemplateInput {
+    input: OwnedInput,
+    canonical_digest_property: String,
+    catalog_digest: SemanticDigest,
+    compiled_model_digest: SemanticDigest,
+    prepared_kernel_pack_digest: SemanticDigest,
+}
+
+struct AuthenticatedBuilderInputs {
+    builder_input_digest: String,
+    template_input_digest: String,
+    authenticated: AuthenticatedRecurrenceBuilderInput,
+}
+
+fn authenticate_builder_inputs(
+    input: OwnedInput,
+    prepared_template: PreparedTemplateInput,
+    expected_pack_digest: SemanticDigest,
+) -> RusticolResult<AuthenticatedBuilderInputs> {
+    validate_inventory(&input)?;
+    let builder_input_digest = canonical_digest(&input)?;
+    if builder_input_digest != input.declared_digest {
+        return Err(invalid(format!(
+            "recurrence builder input digest mismatch: declared {}, found {builder_input_digest}",
+            input.declared_digest
+        )));
+    }
+    let template_input_digest = prepared_template.canonical_digest()?;
+    if prepared_template.prepared_kernel_pack_digest != expected_pack_digest {
+        return Err(RusticolError::integrity(
+            "recurrence prepared-kernel pack digest does not match the authenticated template",
+        ));
+    }
+    let process = decode_process_input(&input)?.validate()?;
+    let template = prepared_template.into_core()?.validate()?;
+    let authenticated = AuthenticatedRecurrenceBuilderInput::new(process, template)?;
+    Ok(AuthenticatedBuilderInputs {
+        builder_input_digest,
+        template_input_digest,
+        authenticated,
+    })
+}
+
+impl PreparedTemplateInput {
+    fn canonical_digest(&self) -> RusticolResult<String> {
+        let mut digest = Sha256::new();
+        hash_text(&mut digest, &self.input.abi)?;
+        digest.update(self.catalog_digest.as_bytes());
+        digest.update(self.compiled_model_digest.as_bytes());
+        digest.update(self.prepared_kernel_pack_digest.as_bytes());
+        hash_tables(&mut digest, &self.input.tables)?;
+        Ok(hex_digest(digest.finalize()))
+    }
+
+    fn into_core(self) -> RusticolResult<template::OwnedRecurrenceTemplateInput> {
+        let actual_digest = self.canonical_digest()?;
+        if actual_digest != self.input.declared_digest
+            || actual_digest != self.canonical_digest_property
+        {
+            return Err(invalid(format!(
+                "recurrence template input digest mismatch: declared {}, found {actual_digest}",
+                self.input.declared_digest
+            )));
+        }
+        decode_template_input(
+            &self.input,
+            self.catalog_digest,
+            self.compiled_model_digest,
+            self.prepared_kernel_pack_digest,
+        )
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct DirectLoweringTimings {
+    python_extraction_seconds: f64,
+    catalog_authentication_seconds: f64,
+    semantic_construction_seconds: f64,
+    direct_lowering_seconds: f64,
+    serialization_seconds: f64,
+    native_total_seconds: f64,
+}
+
+#[derive(Debug)]
+struct NativeDirectLoweringResult {
+    builder_input_digest: String,
+    template_input_digest: String,
+    prepared_kernel_pack_digest: String,
+    direct_template_catalog_digest: String,
+    process_id: String,
+    strategy: RecurrenceStrategy,
+    semantic_digest: String,
+    runtime_layout_digest: String,
+    member_count: u64,
+    unpacked_size_bytes: u64,
+    index_sha256: String,
+    container_size: u64,
+    plan_payload_size: u64,
+    plan_sha256: String,
+    projection_certificate_payload_size: Option<u64>,
+    projection_certificate_sha256: Option<String>,
+    current_count: usize,
+    source_row_count: usize,
+    contribution_count: usize,
+    finalization_count: usize,
+    closure_count: usize,
+    row_group_count: usize,
+    momentum_form_count: usize,
+    selector_domain_count: usize,
+    replay_target_count: usize,
+    amplitude_destination_count: usize,
+    resolved_helicity_count: usize,
+    retained_helicity_count: u64,
+    exact_factor_count: usize,
+    semantic_component_count: u64,
+    current_arena_components: u32,
+    parameter_value_count: u32,
+    physical_sector_count: u32,
+    direct_executor_count: u32,
+    prepared_kernel_count: usize,
+    resolved_helicities: Vec<Vec<i32>>,
+    amplitude_destinations: Vec<(u32, Option<u32>)>,
+    closure_target_domain_certificate: Option<NativeClosureTargetDomainCertificate>,
+    selector_work: Vec<(DirectSelectorWorkSummary, u64)>,
+    relation_discovery: Option<RecurrenceRelationDiscoveryReport>,
+    exact_sections: NativeRecurrenceExactSections,
+    construction: RecurrenceConstructionMetrics,
+    generation_profile: RecurrenceGenerationTelemetry,
+    timings: DirectLoweringTimings,
+    helicity_dispatch: Option<NativeHelicityDispatchMetadata>,
+}
+
+#[derive(Debug)]
+struct NativeClosureTargetDomainCertificate {
+    physical_sector_count: u32,
+    resolved_helicity_count: u32,
+    certified_structural_zero_physical_sector_ids: Vec<u32>,
+    semantic_digest: String,
+}
+
+#[derive(Debug)]
+struct NativeHelicityDispatchMetadata {
+    size_bytes: u64,
+    sha256: String,
+    base_runtime_layout_digest: String,
+    resolved_helicity_count: usize,
+}
+
+#[derive(Clone, Debug, Default)]
+struct RecurrenceConstructionMetrics {
+    peak_current_count: usize,
+    peak_contribution_count: usize,
+    peak_dynamic_color_state_count: usize,
+    color_target_prune_count: usize,
+    candidate_parent_pair_count_by_stage: BTreeMap<usize, usize>,
+}
+
+impl RecurrenceConstructionMetrics {
+    fn include(&mut self, progress: &RecurrenceBuildProgress) {
+        self.peak_current_count = self.peak_current_count.max(progress.current_count);
+        self.peak_contribution_count = self
+            .peak_contribution_count
+            .max(progress.contribution_count);
+        self.peak_dynamic_color_state_count = self
+            .peak_dynamic_color_state_count
+            .max(progress.dynamic_color_state_count);
+        self.color_target_prune_count = self
+            .color_target_prune_count
+            .max(progress.color_target_prune_count);
+        if let Some(stage_index) = progress.stage_index {
+            self.candidate_parent_pair_count_by_stage
+                .entry(stage_index)
+                .and_modify(|count| {
+                    *count = (*count).max(progress.candidate_parent_pair_count);
+                })
+                .or_insert(progress.candidate_parent_pair_count);
+        }
+    }
+
+    fn candidate_parent_pair_count(&self) -> usize {
+        self.candidate_parent_pair_count_by_stage
+            .values()
+            .copied()
+            .sum()
+    }
+}
+
+struct AuthenticatedDirectTemplateCatalog {
+    catalog: PreparedDirectExecutorCatalog,
+    catalog_digest: SemanticDigest,
+    prepared_kernel_pack_digest: SemanticDigest,
+    prepared_kernel_count: usize,
+    exact_executors: Vec<NativeRecurrenceExactExecutor>,
+}
+
+#[pyfunction(signature = (
+    builder_input,
+    prepared_template_input,
+    direct_template_catalog_json,
+    prepared_kernel_pack_digest,
+    schedule_semantic_digest,
+    destination,
+    *,
+    point_tile_size,
+    workspace_mib,
+    relation_discovery_mode,
+    relation_discovery_precision_digits,
+    relation_discovery_probe_count,
+    relation_discovery_verification_probe_count,
+    relation_discovery_relative_tolerance,
+    relation_discovery_absolute_tolerance,
+    relation_discovery_seed,
+    color_accuracy,
+    relation_discovery_evidence_json=None,
+    helicity_dispatch_destination=None,
+    progress_callback=None
+))]
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn _lower_recurrence_direct_v2(
+    py: Python<'_>,
+    builder_input: &Bound<'_, PyAny>,
+    prepared_template_input: &Bound<'_, PyAny>,
+    direct_template_catalog_json: &Bound<'_, PyBytes>,
+    prepared_kernel_pack_digest: String,
+    schedule_semantic_digest: String,
+    destination: PathBuf,
+    point_tile_size: u32,
+    workspace_mib: u32,
+    relation_discovery_mode: String,
+    relation_discovery_precision_digits: u32,
+    relation_discovery_probe_count: u32,
+    relation_discovery_verification_probe_count: u32,
+    relation_discovery_relative_tolerance: f64,
+    relation_discovery_absolute_tolerance: f64,
+    relation_discovery_seed: u64,
+    color_accuracy: String,
+    relation_discovery_evidence_json: Option<&Bound<'_, PyBytes>>,
+    helicity_dispatch_destination: Option<PathBuf>,
+    progress_callback: Option<Py<PyAny>>,
+) -> PyResult<Py<PyAny>> {
+    let extraction_started = Instant::now();
+    let owned = parse_input(builder_input)?;
+    let prepared_template = parse_prepared_template_input(prepared_template_input)?;
+    let direct_template_catalog_json = direct_template_catalog_json.as_bytes().to_vec();
+    validate_sha256_text(&prepared_kernel_pack_digest, "prepared kernel pack digest")?;
+    validate_sha256_text(&schedule_semantic_digest, "recurrence schedule digest")?;
+    let relation_discovery = RecurrenceRelationDiscoveryOptions::new(
+        RecurrenceRelationDiscoveryMode::parse(&relation_discovery_mode).map_err(python_error)?,
+        relation_discovery_precision_digits,
+        relation_discovery_probe_count,
+        relation_discovery_verification_probe_count,
+        relation_discovery_relative_tolerance,
+        relation_discovery_absolute_tolerance,
+        relation_discovery_seed,
+        color_accuracy,
+    )
+    .map_err(python_error)?;
+    let relation_discovery_evidence_json =
+        relation_discovery_evidence_json.map(|raw| raw.as_bytes().to_vec());
+    let python_extraction_seconds = extraction_started.elapsed().as_secs_f64();
+
+    let native = py
+        .detach(move || {
+            let mut report =
+                |progress| report_recurrence_build_progress(progress_callback.as_ref(), progress);
+            lower_recurrence_direct(
+                owned,
+                prepared_template,
+                &direct_template_catalog_json,
+                &prepared_kernel_pack_digest,
+                &schedule_semantic_digest,
+                &destination,
+                point_tile_size,
+                workspace_mib,
+                relation_discovery,
+                relation_discovery_evidence_json,
+                helicity_dispatch_destination.as_deref(),
+                python_extraction_seconds,
+                &mut report,
+            )
+        })
+        .map_err(python_error)?;
+    direct_lowering_mapping(py, native)
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[pyfunction(signature = (
+    builder_input,
+    prepared_template_input,
+    direct_template_catalog_json,
+    prepared_kernel_pack_digest,
+    selected_public_flow_id,
+    public_helicities
+))]
+pub(crate) fn _on_the_fly_test_support_probe_v1(
+    py: Python<'_>,
+    builder_input: &Bound<'_, PyAny>,
+    prepared_template_input: &Bound<'_, PyAny>,
+    direct_template_catalog_json: &Bound<'_, PyBytes>,
+    prepared_kernel_pack_digest: String,
+    selected_public_flow_id: u32,
+    public_helicities: Vec<i32>,
+) -> PyResult<Py<PyAny>> {
+    let input = parse_input(builder_input)?;
+    let prepared_template = parse_prepared_template_input(prepared_template_input)?;
+    let direct_template_catalog_json = direct_template_catalog_json.as_bytes().to_vec();
+    validate_sha256_text(&prepared_kernel_pack_digest, "prepared kernel pack digest")?;
+    let native = py
+        .detach(move || {
+            let expected_pack_digest = semantic_digest_from_hex(
+                &prepared_kernel_pack_digest,
+                "prepared kernel pack digest",
+            )?;
+            let authenticated =
+                authenticate_builder_inputs(input, prepared_template, expected_pack_digest)?
+                    .authenticated;
+            let direct_catalog = parse_direct_template_catalog(
+                &direct_template_catalog_json,
+                expected_pack_digest,
+                authenticated.template().summary().catalog_digest,
+                authenticated.template().summary().compiled_model_digest,
+            )?;
+            on_the_fly_test_support_probe_v1(
+                &authenticated,
+                &direct_catalog.catalog,
+                selected_public_flow_id,
+                &public_helicities,
+            )
+        })
+        .map_err(python_error)?;
+    on_the_fly_test_support_mapping(py, native)
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[pyfunction(signature = (
+    builder_input,
+    prepared_template_input,
+    direct_template_catalog_json,
+    prepared_kernel_pack_digest,
+    selected_public_flow_ids,
+    public_helicities,
+    *,
+    enable_color_projection=true
+))]
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn _on_the_fly_query_family_census_v1(
+    py: Python<'_>,
+    builder_input: &Bound<'_, PyAny>,
+    prepared_template_input: &Bound<'_, PyAny>,
+    direct_template_catalog_json: &Bound<'_, PyBytes>,
+    prepared_kernel_pack_digest: String,
+    selected_public_flow_ids: Vec<u32>,
+    public_helicities: Vec<Vec<i32>>,
+    enable_color_projection: bool,
+) -> PyResult<Py<PyAny>> {
+    if selected_public_flow_ids.len() != public_helicities.len() {
+        return Err(PyValueError::new_err(
+            "on-the-fly query-family flow and helicity columns have different lengths",
+        ));
+    }
+    let input = parse_input(builder_input)?;
+    let prepared_template = parse_prepared_template_input(prepared_template_input)?;
+    let direct_template_catalog_json = direct_template_catalog_json.as_bytes().to_vec();
+    validate_sha256_text(&prepared_kernel_pack_digest, "prepared kernel pack digest")?;
+    let queries = selected_public_flow_ids
+        .into_iter()
+        .zip(public_helicities)
+        .collect::<Vec<_>>();
+    let native = py
+        .detach(move || {
+            let expected_pack_digest = semantic_digest_from_hex(
+                &prepared_kernel_pack_digest,
+                "prepared kernel pack digest",
+            )?;
+            let authenticated =
+                authenticate_builder_inputs(input, prepared_template, expected_pack_digest)?
+                    .authenticated;
+            let direct_catalog = parse_direct_template_catalog(
+                &direct_template_catalog_json,
+                expected_pack_digest,
+                authenticated.template().summary().catalog_digest,
+                authenticated.template().summary().compiled_model_digest,
+            )?;
+            on_the_fly_query_family_census_v1(
+                &authenticated,
+                &direct_catalog.catalog,
+                &queries,
+                enable_color_projection,
+            )
+        })
+        .map_err(python_error)?;
+    on_the_fly_query_family_census_mapping(py, native)
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[pyfunction(signature = (
+    artifact_path,
+    process_id,
+    builder_input,
+    prepared_template_input,
+    direct_template_catalog_json,
+    prepared_kernel_pack_digest,
+    selected_public_flow_id,
+    public_helicities,
+    point_major_external_momenta,
+    point_count,
+    *,
+    parameter_overrides=None,
+    tamper_executor_key=false,
+    benchmark=false,
+    benchmark_warmup_repetitions=0,
+    benchmark_repetitions=0,
+    collect_current_diagnostics=true,
+    enable_color_projection=true,
+    query_family=None
+))]
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn _on_the_fly_artifact_probe_v1(
+    py: Python<'_>,
+    artifact_path: PathBuf,
+    process_id: String,
+    builder_input: &Bound<'_, PyAny>,
+    prepared_template_input: &Bound<'_, PyAny>,
+    direct_template_catalog_json: &Bound<'_, PyBytes>,
+    prepared_kernel_pack_digest: String,
+    selected_public_flow_id: u32,
+    public_helicities: Vec<i32>,
+    point_major_external_momenta: Vec<f64>,
+    point_count: u32,
+    parameter_overrides: Option<BTreeMap<String, Vec<f64>>>,
+    tamper_executor_key: bool,
+    benchmark: bool,
+    benchmark_warmup_repetitions: u32,
+    benchmark_repetitions: u32,
+    collect_current_diagnostics: bool,
+    enable_color_projection: bool,
+    query_family: Option<Vec<(u32, Vec<i32>)>>,
+) -> PyResult<Py<PyAny>> {
+    let input = parse_input(builder_input)?;
+    let prepared_template = parse_prepared_template_input(prepared_template_input)?;
+    let direct_template_catalog_json = direct_template_catalog_json.as_bytes().to_vec();
+    validate_sha256_text(&prepared_kernel_pack_digest, "prepared kernel pack digest")?;
+    let parameter_overrides = parameter_overrides
+        .unwrap_or_default()
+        .into_iter()
+        .map(|(name, value)| {
+            let value: [f64; 2] = value.try_into().map_err(|value: Vec<f64>| {
+                PyValueError::new_err(format!(
+                    "on-the-fly parameter override {name:?} has {} components, expected 2",
+                    value.len()
+                ))
+            })?;
+            Ok((name, value))
+        })
+        .collect::<PyResult<BTreeMap<_, _>>>()?;
+    let native = py
+        .detach(move || {
+            let expected_pack_digest = semantic_digest_from_hex(
+                &prepared_kernel_pack_digest,
+                "prepared kernel pack digest",
+            )?;
+            let authenticated =
+                authenticate_builder_inputs(input, prepared_template, expected_pack_digest)?
+                    .authenticated;
+            let direct_catalog = parse_direct_template_catalog(
+                &direct_template_catalog_json,
+                expected_pack_digest,
+                authenticated.template().summary().catalog_digest,
+                authenticated.template().summary().compiled_model_digest,
+            )?;
+            NativeRuntime::on_the_fly_artifact_probe_v1(
+                artifact_path,
+                &process_id,
+                &authenticated,
+                &direct_catalog.catalog,
+                selected_public_flow_id,
+                &public_helicities,
+                &point_major_external_momenta,
+                point_count,
+                &parameter_overrides,
+                tamper_executor_key,
+                benchmark,
+                benchmark_warmup_repetitions,
+                benchmark_repetitions,
+                collect_current_diagnostics,
+                enable_color_projection,
+                query_family.as_deref(),
+            )
+        })
+        .map_err(python_error)?;
+    on_the_fly_artifact_probe_mapping(py, native)
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+#[pyfunction(signature = (
+    on_the_fly_artifact_path,
+    on_the_fly_process_id,
+    recurrence_artifact_path,
+    recurrence_process_id,
+    builder_input,
+    prepared_template_input,
+    direct_template_catalog_json,
+    prepared_kernel_pack_digest,
+    selected_public_flow_id,
+    public_helicities,
+    point_major_external_momenta,
+    *,
+    parameter_overrides=None
+))]
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn _on_the_fly_execution_diagnostic_v1(
+    py: Python<'_>,
+    on_the_fly_artifact_path: PathBuf,
+    on_the_fly_process_id: String,
+    recurrence_artifact_path: PathBuf,
+    recurrence_process_id: String,
+    builder_input: &Bound<'_, PyAny>,
+    prepared_template_input: &Bound<'_, PyAny>,
+    direct_template_catalog_json: &Bound<'_, PyBytes>,
+    prepared_kernel_pack_digest: String,
+    selected_public_flow_id: u32,
+    public_helicities: Vec<i32>,
+    point_major_external_momenta: Vec<f64>,
+    parameter_overrides: Option<BTreeMap<String, Vec<f64>>>,
+) -> PyResult<Py<PyAny>> {
+    let input = parse_input(builder_input)?;
+    let prepared_template = parse_prepared_template_input(prepared_template_input)?;
+    let direct_template_catalog_json = direct_template_catalog_json.as_bytes().to_vec();
+    validate_sha256_text(&prepared_kernel_pack_digest, "prepared kernel pack digest")?;
+    let parameter_overrides = parameter_overrides
+        .unwrap_or_default()
+        .into_iter()
+        .map(|(name, value)| {
+            let value: [f64; 2] = value.try_into().map_err(|value: Vec<f64>| {
+                PyValueError::new_err(format!(
+                    "execution diagnostic parameter override {name:?} has {} components, expected 2",
+                    value.len()
+                ))
+            })?;
+            Ok((name, value))
+        })
+        .collect::<PyResult<BTreeMap<_, _>>>()?;
+    let native = py
+        .detach(move || {
+            let expected_pack_digest = semantic_digest_from_hex(
+                &prepared_kernel_pack_digest,
+                "prepared kernel pack digest",
+            )?;
+            let authenticated =
+                authenticate_builder_inputs(input, prepared_template, expected_pack_digest)?
+                    .authenticated;
+            let direct_catalog = parse_direct_template_catalog(
+                &direct_template_catalog_json,
+                expected_pack_digest,
+                authenticated.template().summary().catalog_digest,
+                authenticated.template().summary().compiled_model_digest,
+            )?;
+            NativeRuntime::on_the_fly_execution_diagnostic_v1(
+                on_the_fly_artifact_path,
+                &on_the_fly_process_id,
+                recurrence_artifact_path,
+                &recurrence_process_id,
+                &authenticated,
+                &direct_catalog.catalog,
+                selected_public_flow_id,
+                &public_helicities,
+                &point_major_external_momenta,
+                &parameter_overrides,
+            )
+        })
+        .map_err(python_error)?;
+    on_the_fly_execution_diagnostic_mapping(py, native)
+}
+
+fn build_on_the_fly_process_seeds_v1(
+    ordered_source_projection_jsons: Vec<Vec<u8>>,
+    recurrence_template_catalog_json: Vec<u8>,
+    direct_template_catalog_json: Vec<u8>,
+    prepared_kernel_pack_digest: String,
+) -> RusticolResult<Vec<Vec<u8>>> {
+    let expected_pack_digest =
+        semantic_digest_from_hex(&prepared_kernel_pack_digest, "prepared kernel pack digest")?;
+    let template_value: JsonValue = serde_json::from_slice(&recurrence_template_catalog_json)
+        .map_err(|error| {
+            invalid(format!(
+                "recurrence-template catalog is not valid JSON: {error}"
+            ))
+        })?;
+    let templates =
+        rusticol_core::__private::project_recurrence_template_catalog_json_v1(&template_value)?
+            .validate()?;
+    let summary = templates.summary();
+    if summary.prepared_kernel_pack_digest != expected_pack_digest {
+        return Err(RusticolError::integrity(
+            "recurrence-template catalog prepared-kernel pack differs from the requested pack",
+        ));
+    }
+    let direct = parse_direct_template_catalog(
+        &direct_template_catalog_json,
+        expected_pack_digest,
+        summary.catalog_digest,
+        summary.compiled_model_digest,
+    )?;
+    rusticol_core::__private::build_on_the_fly_process_seed_bytes_batch_v1(
+        &ordered_source_projection_jsons,
+        &templates,
+        &direct.catalog,
+        expected_pack_digest,
+    )
+}
+
+fn owned_on_the_fly_source_projection_jsons(values: &Bound<'_, PyAny>) -> PyResult<Vec<Vec<u8>>> {
+    let iterator = values.try_iter().map_err(|_| {
+        PyTypeError::new_err("ordered on-the-fly source projections must be iterable")
+    })?;
+    let mut result = Vec::new();
+    for (index, item) in iterator.enumerate() {
+        let item = item?;
+        let value = item.cast::<PyBytes>().map_err(|_| {
+            PyTypeError::new_err(format!(
+                "on-the-fly source projection at index {index} must be bytes"
+            ))
+        })?;
+        result.push(value.as_bytes().to_vec());
+    }
+    Ok(result)
+}
+
+/// Private ordered cold-path bridge used by the on-the-fly artifact writer.
+///
+/// The four byte/string inputs are the complete boundary: in particular this
+/// function accepts no recurrence builder input, physical color plan, DAG, or
+/// direct-plan payload.
+#[pyfunction]
+pub(crate) fn _build_on_the_fly_process_seeds_v1(
+    py: Python<'_>,
+    ordered_source_projection_jsons: &Bound<'_, PyAny>,
+    recurrence_template_catalog_json: &Bound<'_, PyBytes>,
+    direct_template_catalog_json: &Bound<'_, PyBytes>,
+    prepared_kernel_pack_digest: &str,
+) -> PyResult<Py<PyList>> {
+    let ordered_source_projection_jsons =
+        owned_on_the_fly_source_projection_jsons(ordered_source_projection_jsons)?;
+    let recurrence_template_catalog_json = recurrence_template_catalog_json.as_bytes().to_vec();
+    let direct_template_catalog_json = direct_template_catalog_json.as_bytes().to_vec();
+    let prepared_kernel_pack_digest = prepared_kernel_pack_digest.to_owned();
+    let encoded = py
+        .detach(move || {
+            build_on_the_fly_process_seeds_v1(
+                ordered_source_projection_jsons,
+                recurrence_template_catalog_json,
+                direct_template_catalog_json,
+                prepared_kernel_pack_digest,
+            )
+        })
+        .map_err(python_error)?;
+    let result = PyList::empty(py);
+    for payload in encoded {
+        result.append(PyBytes::new(py, &payload))?;
+    }
+    Ok(result.unbind())
+}
+
+/// Private singleton wrapper retained for callers of the original bridge.
+#[pyfunction]
+pub(crate) fn _build_on_the_fly_process_seed_v1(
+    py: Python<'_>,
+    source_projection_json: &Bound<'_, PyBytes>,
+    recurrence_template_catalog_json: &Bound<'_, PyBytes>,
+    direct_template_catalog_json: &Bound<'_, PyBytes>,
+    prepared_kernel_pack_digest: &str,
+) -> PyResult<Py<PyBytes>> {
+    let source_projection_json = source_projection_json.as_bytes().to_vec();
+    let recurrence_template_catalog_json = recurrence_template_catalog_json.as_bytes().to_vec();
+    let direct_template_catalog_json = direct_template_catalog_json.as_bytes().to_vec();
+    let prepared_kernel_pack_digest = prepared_kernel_pack_digest.to_owned();
+    let mut encoded = py
+        .detach(move || {
+            build_on_the_fly_process_seeds_v1(
+                vec![source_projection_json],
+                recurrence_template_catalog_json,
+                direct_template_catalog_json,
+                prepared_kernel_pack_digest,
+            )
+        })
+        .map_err(python_error)?;
+    let payload = encoded.pop().ok_or_else(|| {
+        PyValueError::new_err("singleton on-the-fly process-seed batch returned no payload")
+    })?;
+    Ok(PyBytes::new(py, &payload).unbind())
+}
+
+/// Private authoritative decoder used to bind a compact seed to the JSON
+/// execution manifest and publication audit.
+#[pyfunction]
+pub(crate) fn _inspect_on_the_fly_process_seed_v1(
+    py: Python<'_>,
+    payload: &Bound<'_, PyBytes>,
+) -> PyResult<String> {
+    let payload = payload.as_bytes().to_vec();
+    py.detach(move || {
+        rusticol_core::__private::inspect_on_the_fly_process_seed_identity_json_v1(&payload)
+    })
+    .map_err(python_error)
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn on_the_fly_artifact_probe_mapping(
+    py: Python<'_>,
+    native: NativeOnTheFlyArtifactProbeV1,
+) -> PyResult<Py<PyAny>> {
+    let result = PyDict::new(py);
+    result.set_item("artifact_id", native.artifact_id)?;
+    result.set_item("process_id", native.process_id)?;
+    result.set_item("seed_digest", native.seed_digest)?;
+    result.set_item("query_digest", native.query_digest)?;
+    result.set_item("trace_digest", native.trace_digest)?;
+    result.set_item("point_count", native.point_count)?;
+    result.set_item("raw_amplitudes", native.raw_amplitudes)?;
+    result.set_item("normalized_values", native.normalized_values)?;
+    result.set_item("normalization_factor", native.normalization_factor)?;
+    if let Some(family) = native.query_family {
+        let family_result = PyDict::new(py);
+        let queries = PyList::empty(py);
+        for query in family.queries {
+            let row = PyDict::new(py);
+            row.set_item("selected_public_flow_id", query.selected_public_flow_id)?;
+            row.set_item("public_helicities", query.public_helicities)?;
+            row.set_item("query_digest", query.query_digest)?;
+            row.set_item("raw_amplitudes", query.raw_amplitudes)?;
+            row.set_item("normalized_values", query.normalized_values)?;
+            queries.append(row)?;
+        }
+        family_result.set_item("queries", queries)?;
+        family_result.set_item(
+            "census",
+            on_the_fly_query_family_census_mapping(py, family.census)?,
+        )?;
+        family_result.set_item("execution_cache_hit", family.execution_cache_hit)?;
+        family_result.set_item("execution_source_calls", family.execution_source_calls)?;
+        family_result.set_item("execution_source_rows", family.execution_source_rows)?;
+        family_result.set_item(
+            "execution_contribution_calls",
+            family.execution_contribution_calls,
+        )?;
+        family_result.set_item(
+            "execution_contribution_rows",
+            family.execution_contribution_rows,
+        )?;
+        family_result.set_item(
+            "execution_finalization_calls",
+            family.execution_finalization_calls,
+        )?;
+        family_result.set_item(
+            "execution_finalization_rows",
+            family.execution_finalization_rows,
+        )?;
+        family_result.set_item("execution_closure_calls", family.execution_closure_calls)?;
+        family_result.set_item("execution_closure_rows", family.execution_closure_rows)?;
+        family_result.set_item("cold_prepare_seconds", family.cold_prepare_seconds)?;
+        family_result.set_item(
+            "benchmark_warmup_repetitions",
+            family.benchmark_warmup_repetitions,
+        )?;
+        family_result.set_item("benchmark_repetitions", family.benchmark_repetitions)?;
+        family_result.set_item(
+            "private_warmed_elapsed_seconds",
+            family.benchmark_elapsed_seconds,
+        )?;
+        family_result.set_item(
+            "private_warmed_seconds_per_point",
+            family.benchmark_seconds_per_point,
+        )?;
+        family_result.set_item("private_timing_excludes_source_crossing", true)?;
+        result.set_item("query_family", family_result)?;
+    } else {
+        result.set_item("query_family", py.None())?;
+    }
+    result.set_item("projection_enabled", native.projection_enabled)?;
+    result.set_item("projection_applied", native.projection_applied)?;
+    for (prefix, counts) in [
+        ("pre", native.projection_counts[0]),
+        ("post", native.projection_counts[1]),
+    ] {
+        for (name, value) in ["current", "contribution", "closure"]
+            .into_iter()
+            .zip(counts)
+        {
+            result.set_item(format!("{prefix}_projection_{name}_count"), value)?;
+        }
+    }
+    result.set_item("work_census_basis", native.work_census_basis)?;
+    result.set_item("logical_current_count", native.logical_current_count)?;
+    result.set_item("resident_current_count", native.resident_current_count)?;
+    result.set_item(
+        "resident_current_component_count",
+        native.resident_current_component_count,
+    )?;
+    result.set_item("source_operation_count", native.source_operation_count)?;
+    result.set_item(
+        "contribution_operation_count",
+        native.contribution_operation_count,
+    )?;
+    result.set_item(
+        "finalization_operation_count",
+        native.finalization_operation_count,
+    )?;
+    result.set_item("closure_operation_count", native.closure_operation_count)?;
+    result.set_item(
+        "total_kernel_application_count",
+        native.total_kernel_application_count,
+    )?;
+    result.set_item(
+        "semantic_executor_binding_count",
+        native.semantic_executor_binding_count,
+    )?;
+    result.set_item(
+        "distinct_prepared_executor_count",
+        native.distinct_prepared_executor_count,
+    )?;
+    result.set_item("trace_build_count", native.trace_build_count)?;
+    result.set_item("trace_cache_hit_count", native.trace_cache_hit_count)?;
+    result.set_item("momentum_fill_count", native.momentum_fill_count)?;
+    result.set_item(
+        "benchmark_warmup_repetitions",
+        native.benchmark_warmup_repetitions,
+    )?;
+    result.set_item("benchmark_repetitions", native.benchmark_repetitions)?;
+    result.set_item(
+        "benchmark_elapsed_seconds",
+        native.benchmark_elapsed_seconds,
+    )?;
+    result.set_item(
+        "benchmark_seconds_per_point",
+        native.benchmark_seconds_per_point,
+    )?;
+    result.set_item(
+        "direct_plan_load_attempts",
+        native.direct_plan_load_attempts,
+    )?;
+    result.set_item(
+        "direct_plan_decode_attempts",
+        native.direct_plan_decode_attempts,
+    )?;
+    result.set_item(
+        "direct_plan_materialization_attempts",
+        native.direct_plan_materialization_attempts,
+    )?;
+    result.set_item(
+        "established_builder_attempts",
+        native.established_builder_attempts,
+    )?;
+    let currents = PyList::empty(py);
+    for current in native.currents {
+        let row = PyDict::new(py);
+        row.set_item("semantic_digest", current.semantic_digest)?;
+        row.set_item("component_count", current.component_count)?;
+        row.set_item("values", current.values)?;
+        currents.append(row)?;
+    }
+    result.set_item("currents", currents)?;
+    Ok(result.into_any().unbind())
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn on_the_fly_execution_diagnostic_mapping(
+    py: Python<'_>,
+    native: NativeOnTheFlyExecutionDiagnosticV1,
+) -> PyResult<Py<PyAny>> {
+    let result = PyDict::new(py);
+    result.set_item("schema_version", 1)?;
+    result.set_item("on_the_fly_artifact_id", native.on_the_fly_artifact_id)?;
+    result.set_item("on_the_fly_process_id", native.on_the_fly_process_id)?;
+    result.set_item("recurrence_artifact_id", native.recurrence_artifact_id)?;
+    result.set_item("recurrence_process_id", native.recurrence_process_id)?;
+    result.set_item("seed_digest", native.seed_digest)?;
+    result.set_item("query_digest", native.query_digest)?;
+    result.set_item("trace_digest", native.trace_digest)?;
+    result.set_item(
+        "direct_plan_semantic_digest",
+        native.direct_plan_semantic_digest,
+    )?;
+    result.set_item(
+        "direct_runtime_layout_digest",
+        native.direct_runtime_layout_digest,
+    )?;
+    result.set_item("public_flow_id", native.public_flow_id)?;
+    result.set_item("representative_flow_id", native.representative_flow_id)?;
+    result.set_item("public_helicities", native.public_helicities)?;
+    result.set_item(
+        "public_direct_helicity_id",
+        native.public_direct_helicity_id,
+    )?;
+    result.set_item(
+        "representative_direct_helicity_id",
+        native.representative_direct_helicity_id,
+    )?;
+    result.set_item("replay_phase", native.replay_phase.to_vec())?;
+    result.set_item("replay_multiplicity", native.replay_multiplicity)?;
+    result.set_item("replay_scale", native.replay_scale.to_vec())?;
+    result.set_item(
+        "on_the_fly_public_amplitude",
+        native.on_the_fly_public_amplitude.to_vec(),
+    )?;
+    result.set_item(
+        "recurrence_representative_amplitude",
+        native.recurrence_representative_amplitude.to_vec(),
+    )?;
+    result.set_item(
+        "recurrence_public_amplitude",
+        native.recurrence_public_amplitude.to_vec(),
+    )?;
+    result.set_item(
+        "amplitude_absolute_delta",
+        native.amplitude_absolute_delta.to_vec(),
+    )?;
+    result.set_item("raw_bit_difference_count", native.raw_bit_difference_count)?;
+    result.set_item("compared_current_count", native.compared_current_count)?;
+    result.set_item(
+        "excluded_direct_current_count",
+        native.excluded_direct_current_count,
+    )?;
+
+    let first_raw_bit_difference = native.first_raw_bit_difference;
+    let components = PyList::empty(py);
+    for component in native.current_components {
+        let row = PyDict::new(py);
+        row.set_item("dependency_depth", component.dependency_depth)?;
+        row.set_item("semantic_digest", component.semantic_digest)?;
+        row.set_item("component", component.component)?;
+        row.set_item("on_the_fly", component.on_the_fly.to_vec())?;
+        row.set_item("recurrence", component.recurrence.to_vec())?;
+        row.set_item("on_the_fly_bits", component.on_the_fly_bits.to_vec())?;
+        row.set_item("recurrence_bits", component.recurrence_bits.to_vec())?;
+        row.set_item("absolute_delta", component.absolute_delta.to_vec())?;
+        components.append(row)?;
+    }
+    result.set_item("current_components", &components)?;
+    if let Some(index) = first_raw_bit_difference {
+        result.set_item("first_raw_bit_difference_index", index)?;
+        result.set_item("first_raw_bit_difference", components.get_item(index)?)?;
+    } else {
+        result.set_item("first_raw_bit_difference_index", py.None())?;
+        result.set_item("first_raw_bit_difference", py.None())?;
+    }
+    Ok(result.into_any().unbind())
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn on_the_fly_query_family_census_mapping(
+    py: Python<'_>,
+    native: OnTheFlyQueryFamilyCensusV1,
+) -> PyResult<Py<PyAny>> {
+    let result = PyDict::new(py);
+    result.set_item("query_count", native.query_count)?;
+    result.set_item(
+        "source_frame_partition_count",
+        native.source_frame_partition_count,
+    )?;
+    result.set_item(
+        "projection_applied_query_count",
+        native.projection_applied_query_count,
+    )?;
+    result.set_item(
+        "projection_pre_current_count",
+        native.projection_pre_current_count,
+    )?;
+    result.set_item(
+        "projection_pre_contribution_count",
+        native.projection_pre_contribution_count,
+    )?;
+    result.set_item(
+        "projection_pre_closure_count",
+        native.projection_pre_closure_count,
+    )?;
+    result.set_item(
+        "projection_post_current_count",
+        native.projection_post_current_count,
+    )?;
+    result.set_item(
+        "projection_post_contribution_count",
+        native.projection_post_contribution_count,
+    )?;
+    result.set_item(
+        "projection_post_closure_count",
+        native.projection_post_closure_count,
+    )?;
+    result.set_item(
+        "dynamic_current_occurrence_count",
+        native.dynamic_current_occurrence_count,
+    )?;
+    result.set_item(
+        "dynamic_current_component_occurrence_count",
+        native.dynamic_current_component_occurrence_count,
+    )?;
+    result.set_item("dynamic_source_rows", native.dynamic_source_rows)?;
+    result.set_item(
+        "dynamic_contribution_rows",
+        native.dynamic_contribution_rows,
+    )?;
+    result.set_item(
+        "dynamic_finalization_rows",
+        native.dynamic_finalization_rows,
+    )?;
+    result.set_item("dynamic_closure_rows", native.dynamic_closure_rows)?;
+    result.set_item("dynamic_source_calls", native.dynamic_source_calls)?;
+    result.set_item(
+        "dynamic_contribution_calls",
+        native.dynamic_contribution_calls,
+    )?;
+    result.set_item(
+        "dynamic_finalization_calls",
+        native.dynamic_finalization_calls,
+    )?;
+    result.set_item("dynamic_closure_calls", native.dynamic_closure_calls)?;
+    result.set_item(
+        "union_unique_current_count",
+        native.union_unique_current_count,
+    )?;
+    result.set_item(
+        "union_unique_current_component_count",
+        native.union_unique_current_component_count,
+    )?;
+    result.set_item("union_source_rows", native.union_source_rows)?;
+    result.set_item("union_contribution_rows", native.union_contribution_rows)?;
+    result.set_item("union_finalization_rows", native.union_finalization_rows)?;
+    result.set_item("union_closure_rows", native.union_closure_rows)?;
+    result.set_item(
+        "union_amplitude_destination_count",
+        native.union_amplitude_destination_count,
+    )?;
+    result.set_item(
+        "union_source_executor_call_groups",
+        native.union_source_executor_call_groups,
+    )?;
+    result.set_item(
+        "union_contribution_executor_call_groups",
+        native.union_contribution_executor_call_groups,
+    )?;
+    result.set_item(
+        "union_finalization_executor_call_groups",
+        native.union_finalization_executor_call_groups,
+    )?;
+    result.set_item(
+        "union_closure_executor_call_groups",
+        native.union_closure_executor_call_groups,
+    )?;
+    Ok(result.into_any().unbind())
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn on_the_fly_exact_factor_mapping(
+    py: Python<'_>,
+    factor: ExactComplexRational,
+) -> PyResult<Py<PyAny>> {
+    let result = PyDict::new(py);
+    for (name, value) in [("real", factor.real()), ("imag", factor.imag())] {
+        let part = PyDict::new(py);
+        part.set_item("numerator", value.numerator().to_string())?;
+        part.set_item("denominator", value.denominator().to_string())?;
+        result.set_item(name, part)?;
+    }
+    Ok(result.into_any().unbind())
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn on_the_fly_optional_exact_factor_mapping(
+    py: Python<'_>,
+    factor: Option<ExactComplexRational>,
+) -> PyResult<Py<PyAny>> {
+    match factor {
+        Some(factor) => on_the_fly_exact_factor_mapping(py, factor),
+        None => Ok(py.None()),
+    }
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn on_the_fly_transition_candidate_mapping(
+    py: Python<'_>,
+    row: ConstructionTransitionDiagnosticRowV1,
+) -> PyResult<Py<PyAny>> {
+    let result = PyDict::new(py);
+    result.set_item("materialized_sector_id", row.materialized_sector_id)?;
+    result.set_item(
+        "output_current_digest",
+        row.output_current_digest.to_string(),
+    )?;
+    result.set_item(
+        "ordered_parent_digests",
+        row.ordered_parent_digests
+            .into_iter()
+            .map(|digest| digest.to_string())
+            .collect::<Vec<_>>(),
+    )?;
+    result.set_item("transition_template_id", row.transition_template_id)?;
+    result.set_item(
+        "transition_semantic_digest",
+        row.transition_semantic_digest.to_string(),
+    )?;
+    result.set_item(
+        "evaluator_binding_semantic_digest",
+        row.evaluator_binding_semantic_digest.to_string(),
+    )?;
+    result.set_item("result_state_template_id", row.result_state_template_id)?;
+    result.set_item("quantum_flow_witness_id", row.quantum_flow_witness_id)?;
+    result.set_item(
+        "quantum_semantic_digest",
+        row.quantum_semantic_digest.to_string(),
+    )?;
+    result.set_item(
+        "color_contraction_template_id",
+        row.color_contraction_template_id,
+    )?;
+    result.set_item("color_witness_ordinal", row.color_witness_ordinal)?;
+    result.set_item(
+        "color_witness_proof_digest",
+        row.color_witness_proof_digest.to_string(),
+    )?;
+    result.set_item("output_projection_id", row.output_projection_id)?;
+    let factors = PyDict::new(py);
+    for (name, factor) in [
+        ("transition", row.transition_factor),
+        ("contraction", row.contraction_factor),
+        ("output", row.output_factor),
+        ("exchange", row.exchange_factor),
+        ("witness", row.witness_factor),
+        ("reversal", row.reversal_factor),
+        ("candidate_product", row.candidate_factor),
+        ("aggregate_after", row.aggregate_factor_after),
+    ] {
+        factors.set_item(name, on_the_fly_exact_factor_mapping(py, factor)?)?;
+    }
+    result.set_item("factor_components", factors)?;
+    result.set_item("reversal_mask", row.reversal_mask)?;
+    let reflections = PyDict::new(py);
+    reflections.set_item(
+        "parent_proof_digests",
+        row.parent_reflection_proof_digests
+            .into_iter()
+            .map(|digest| digest.map(|value| value.to_string()))
+            .collect::<Vec<_>>(),
+    )?;
+    let parent_phases = PyList::empty(py);
+    for phase in row.parent_reflection_phases {
+        parent_phases.append(on_the_fly_optional_exact_factor_mapping(py, phase)?)?;
+    }
+    reflections.set_item("parent_phases", parent_phases)?;
+    reflections.set_item(
+        "local_proof_digest",
+        row.local_reflection_proof_digest
+            .map(|digest| digest.to_string()),
+    )?;
+    reflections.set_item(
+        "local_phase",
+        on_the_fly_optional_exact_factor_mapping(py, row.local_reflection_phase)?,
+    )?;
+    reflections.set_item(
+        "result_proof_digest",
+        row.result_reflection_proof_digest
+            .map(|digest| digest.to_string()),
+    )?;
+    reflections.set_item(
+        "result_phase",
+        on_the_fly_optional_exact_factor_mapping(py, row.result_reflection_phase)?,
+    )?;
+    result.set_item("reflection", reflections)?;
+    result.set_item("output_color_orientation", row.output_color_orientation)?;
+    result.set_item("post_row_complex_value", py.None())?;
+    Ok(result.into_any().unbind())
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn on_the_fly_transition_candidates_mapping(
+    py: Python<'_>,
+    mut rows: Vec<ConstructionTransitionDiagnosticRowV1>,
+) -> PyResult<Py<PyList>> {
+    rows.sort_by_cached_key(|row| format!("{row:?}"));
+    let result = PyList::empty(py);
+    for row in rows {
+        result.append(on_the_fly_transition_candidate_mapping(py, row)?)?;
+    }
+    Ok(result.unbind())
+}
+
+#[cfg(feature = "on-the-fly-test-support")]
+fn on_the_fly_test_support_mapping(
+    py: Python<'_>,
+    native: OnTheFlyTestSupportReportV1,
+) -> PyResult<Py<PyAny>> {
+    let result = PyDict::new(py);
+    let structural_parity = native.structural_parity();
+    result.set_item("seed_digest", native.seed_digest.to_string())?;
+    result.set_item("query_digest", native.query_digest.to_string())?;
+    result.set_item("selector_digest", native.selector_digest.to_string())?;
+    result.set_item("trace_digest", native.trace_digest.to_string())?;
+    result.set_item("current_count", native.current_count)?;
+    result.set_item("contribution_count", native.contribution_count)?;
+    result.set_item("closure_count", native.closure_count)?;
+    result.set_item(
+        "established_current_count",
+        native.established_current_count,
+    )?;
+    result.set_item(
+        "established_contribution_count",
+        native.established_contribution_count,
+    )?;
+    result.set_item(
+        "established_closure_count",
+        native.established_closure_count,
+    )?;
+    result.set_item(
+        "current_multiset_digest",
+        native.current_multiset_digest.to_string(),
+    )?;
+    result.set_item(
+        "established_current_multiset_digest",
+        native.established_current_multiset_digest.to_string(),
+    )?;
+    result.set_item(
+        "contribution_multiset_digest",
+        native.contribution_multiset_digest.to_string(),
+    )?;
+    result.set_item(
+        "established_contribution_multiset_digest",
+        native.established_contribution_multiset_digest.to_string(),
+    )?;
+    result.set_item(
+        "closure_multiset_digest",
+        native.closure_multiset_digest.to_string(),
+    )?;
+    result.set_item(
+        "closure_parity_multiset_digest",
+        native.closure_parity_multiset_digest.to_string(),
+    )?;
+    result.set_item(
+        "established_closure_parity_multiset_digest",
+        native
+            .established_closure_parity_multiset_digest
+            .to_string(),
+    )?;
+    result.set_item(
+        "negative_contribution_factor_count",
+        native.negative_contribution_factor_count,
+    )?;
+    result.set_item(
+        "established_negative_contribution_factor_count",
+        native.established_negative_contribution_factor_count,
+    )?;
+    result.set_item("source_domain_equal", native.source_domain_equal)?;
+    result.set_item("pairing_oracle_equal", native.pairing_oracle_equal)?;
+    result.set_item("pairing_fermion_parities", native.pairing_fermion_parities)?;
+    result.set_item(
+        "established_pairing_fermion_parities",
+        native.established_pairing_fermion_parities,
+    )?;
+    result.set_item(
+        "workspace_capacity_independent",
+        native.workspace_capacity_independent,
+    )?;
+    result.set_item("structural_parity", structural_parity)?;
+    result.set_item(
+        "compact_transition_candidates",
+        on_the_fly_transition_candidates_mapping(py, native.compact_transition_candidates)?,
+    )?;
+    result.set_item(
+        "established_transition_candidates",
+        on_the_fly_transition_candidates_mapping(py, native.established_transition_candidates)?,
+    )?;
+    Ok(result.into_any().unbind())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn lower_recurrence_direct(
+    input: OwnedInput,
+    prepared_template: PreparedTemplateInput,
+    direct_template_catalog_json: &[u8],
+    prepared_kernel_pack_digest: &str,
+    schedule_semantic_digest: &str,
+    destination: &std::path::Path,
+    point_tile_size: u32,
+    workspace_mib: u32,
+    mut relation_discovery: RecurrenceRelationDiscoveryOptions,
+    relation_discovery_evidence_json: Option<Vec<u8>>,
+    helicity_dispatch_destination: Option<&std::path::Path>,
+    python_extraction_seconds: f64,
+    progress: &mut dyn FnMut(RecurrenceBuildProgress) -> RusticolResult<()>,
+) -> RusticolResult<NativeDirectLoweringResult> {
+    let native_started = Instant::now();
+    if std::fs::symlink_metadata(destination).is_ok() {
+        return Err(invalid(format!(
+            "recurrence direct-plan destination already exists: {}",
+            destination.display()
+        )));
+    }
+    if let Some(dispatch_destination) = helicity_dispatch_destination {
+        if std::fs::symlink_metadata(dispatch_destination).is_ok() {
+            return Err(invalid(format!(
+                "recurrence helicity-dispatch destination already exists: {}",
+                dispatch_destination.display()
+            )));
+        }
+        if relation_discovery.mode != RecurrenceRelationDiscoveryMode::Off
+            || relation_discovery_evidence_json.is_some()
+        {
+            return Err(invalid(
+                "recurrence helicity-dispatch lowering requires relation discovery off",
+            ));
+        }
+    }
+
+    let expected_pack_digest =
+        semantic_digest_from_hex(prepared_kernel_pack_digest, "prepared kernel pack digest")?;
+    let authenticated_inputs =
+        authenticate_builder_inputs(input, prepared_template, expected_pack_digest)?;
+    let builder_input_digest = authenticated_inputs.builder_input_digest;
+    let template_input_digest = authenticated_inputs.template_input_digest;
+    let authenticated = authenticated_inputs.authenticated;
+
+    let catalog_started = Instant::now();
+    let direct_catalog = parse_direct_template_catalog(
+        direct_template_catalog_json,
+        expected_pack_digest,
+        authenticated.template().summary().catalog_digest,
+        authenticated.template().summary().compiled_model_digest,
+    )?;
+    let catalog_authentication_seconds = catalog_started.elapsed().as_secs_f64();
+
+    let process_id = authenticated.process().summary().process_id().to_owned();
+    let strategy = authenticated.process().summary().strategy();
+    let semantic_digest =
+        semantic_digest_from_hex(schedule_semantic_digest, "recurrence schedule digest")?;
+    if let Some(raw_evidence) = relation_discovery_evidence_json {
+        let parameter_contract = authenticated_runtime_parameter_contract(
+            authenticated.process(),
+            authenticated.template(),
+        )?;
+        relation_discovery = relation_discovery.with_numerical_evidence(
+            parse_numerical_relation_evidence(&raw_evidence, &parameter_contract)?,
+        )?;
+    }
+
+    let semantic_started = Instant::now();
+    let mut construction = RecurrenceConstructionMetrics::default();
+    let mut tracked_progress = |snapshot: RecurrenceBuildProgress| {
+        construction.include(&snapshot);
+        progress(snapshot)
+    };
+    let (program, generation_profile) =
+        authenticated.build_with_progress_and_telemetry(&mut tracked_progress)?;
+    let closure_target_domain_certificate =
+        program
+            .closure_target_domain_certificate()
+            .map(|certificate| NativeClosureTargetDomainCertificate {
+                physical_sector_count: certificate.physical_sector_count(),
+                resolved_helicity_count: certificate.resolved_helicity_count(),
+                certified_structural_zero_physical_sector_ids: certificate
+                    .certified_structural_zero_physical_sector_ids()
+                    .to_vec(),
+                semantic_digest: certificate.semantic_digest().to_string(),
+            });
+    let projection_certificate = program
+        .color_projection_certificate_body()
+        .map(|body| body.to_vec());
+    let semantic_construction_seconds = semantic_started.elapsed().as_secs_f64();
+
+    let direct_lowering_started = Instant::now();
+    let runtime_options = DirectRecurrenceRuntimeOptions::new(point_tile_size, workspace_mib)?;
+    if let Some(evidence) = relation_discovery.numerical_evidence.as_ref() {
+        let baseline_plan = lower_recurrence_direct_plan_v2(
+            &program,
+            authenticated.template(),
+            &direct_catalog.catalog,
+            semantic_digest,
+            expected_pack_digest,
+            direct_catalog.catalog_digest,
+            runtime_options,
+        )?;
+        authenticate_recurrence_numerical_relation_provenance(
+            evidence,
+            &baseline_plan,
+            &process_id,
+        )?;
+    }
+    let (plan, relation_discovery_report, helicity_dispatch) =
+        if helicity_dispatch_destination.is_some() {
+            let (plan, dispatch) = lower_recurrence_direct_plan_v2_with_helicity_dispatch(
+                &program,
+                authenticated.template(),
+                &direct_catalog.catalog,
+                semantic_digest,
+                expected_pack_digest,
+                direct_catalog.catalog_digest,
+                runtime_options,
+            )?;
+            (plan, None, Some(dispatch))
+        } else {
+            let (plan, report) = lower_recurrence_direct_plan_v2_with_relation_discovery(
+                &program,
+                authenticated.template(),
+                &direct_catalog.catalog,
+                semantic_digest,
+                expected_pack_digest,
+                direct_catalog.catalog_digest,
+                runtime_options,
+                &relation_discovery,
+            )?;
+            (plan, report, None)
+        };
+    let direct_lowering_seconds = direct_lowering_started.elapsed().as_secs_f64();
+
+    let resolved_helicities = resolved_helicities_from_direct_plan(&plan)?;
+    let amplitude_destinations = plan
+        .amplitude_destinations()
+        .iter()
+        .map(|destination| {
+            (
+                destination.target_sector_id,
+                (destination.target_helicity_id_or_sentinel != DIRECT_NONE_U32)
+                    .then_some(destination.target_helicity_id_or_sentinel),
+            )
+        })
+        .collect();
+    let semantic_component_count = plan.currents().iter().try_fold(0_u64, |total, current| {
+        total
+            .checked_add(u64::from(current.component_count))
+            .ok_or_else(|| invalid("recurrence semantic component count exceeds u64"))
+    })?;
+    let selector_work =
+        if strategy.uses_topology_replay_targets() && !plan.replay_targets().is_empty() {
+            let mut public_flow_counts = BTreeMap::<u32, u64>::new();
+            for target in plan.replay_targets() {
+                let count = public_flow_counts
+                    .entry(target.representative_id)
+                    .or_default();
+                *count = count
+                    .checked_add(1)
+                    .ok_or_else(|| invalid("recurrence public-flow count exceeds u64"))?;
+            }
+            public_flow_counts
+                .into_iter()
+                .map(|(representative_sector_id, public_flow_count)| {
+                    Ok((
+                        plan.selector_work_summary(representative_sector_id)?,
+                        public_flow_count,
+                    ))
+                })
+                .collect::<RusticolResult<Vec<_>>>()?
+        } else {
+            vec![]
+        };
+    let exact_sections = exact_sections_from_direct_plan(
+        &plan,
+        process_id.clone(),
+        direct_catalog.exact_executors.clone(),
+    );
+
+    let serialization_started = Instant::now();
+    let metadata = write_recurrence_direct_plan_pacbin_with_projection_certificate(
+        destination,
+        &plan,
+        projection_certificate.as_deref(),
+    )?;
+    let helicity_dispatch = match (helicity_dispatch_destination, helicity_dispatch.as_ref()) {
+        (Some(dispatch_destination), Some(dispatch)) => {
+            let dispatch_metadata = match write_recurrence_helicity_dispatch_v1_atomic(
+                dispatch_destination,
+                dispatch,
+            ) {
+                Ok(metadata) => metadata,
+                Err(error) => {
+                    let _ = std::fs::remove_file(destination);
+                    return Err(error);
+                }
+            };
+            Some(NativeHelicityDispatchMetadata {
+                size_bytes: dispatch_metadata.size_bytes,
+                sha256: hex_digest(dispatch_metadata.sha256),
+                base_runtime_layout_digest: dispatch.runtime_layout_digest().to_string(),
+                resolved_helicity_count: dispatch.resolved_helicity_count() as usize,
+            })
+        }
+        (None, None) => None,
+        _ => {
+            let _ = std::fs::remove_file(destination);
+            return Err(invalid(
+                "recurrence helicity-dispatch destination and lowering result disagree",
+            ));
+        }
+    };
+    let serialization_seconds = serialization_started.elapsed().as_secs_f64();
+    let native_total_seconds = native_started.elapsed().as_secs_f64();
+
+    Ok(NativeDirectLoweringResult {
+        builder_input_digest,
+        template_input_digest,
+        prepared_kernel_pack_digest: direct_catalog.prepared_kernel_pack_digest.to_string(),
+        direct_template_catalog_digest: direct_catalog.catalog_digest.to_string(),
+        process_id,
+        strategy,
+        semantic_digest: plan.semantic_digest().to_string(),
+        runtime_layout_digest: plan.runtime_layout_digest().to_string(),
+        member_count: metadata.member_count,
+        unpacked_size_bytes: metadata.unpacked_size_bytes,
+        index_sha256: hex_digest(metadata.index_sha256),
+        container_size: metadata.container_size,
+        plan_payload_size: metadata.plan_payload_size,
+        plan_sha256: hex_digest(metadata.plan_sha256),
+        projection_certificate_payload_size: metadata.projection_certificate_payload_size,
+        projection_certificate_sha256: metadata.projection_certificate_sha256.map(hex_digest),
+        current_count: plan.currents().len(),
+        source_row_count: plan.sources().len(),
+        contribution_count: plan.contributions().len(),
+        finalization_count: plan.finalizations().len(),
+        closure_count: plan.closures().len(),
+        row_group_count: plan.row_groups().len(),
+        momentum_form_count: plan.momentum_forms().len(),
+        selector_domain_count: plan.selector_domains().len(),
+        replay_target_count: plan.replay_targets().len(),
+        amplitude_destination_count: plan.amplitude_destinations().len(),
+        resolved_helicity_count: plan.resolved_helicities().len(),
+        retained_helicity_count: plan.retained_helicity_count(),
+        exact_factor_count: plan.exact_factors().len(),
+        semantic_component_count,
+        current_arena_components: plan.current_arena_components(),
+        parameter_value_count: plan.parameter_value_count(),
+        physical_sector_count: plan.physical_sector_count(),
+        direct_executor_count: plan.direct_executor_count(),
+        prepared_kernel_count: direct_catalog.prepared_kernel_count,
+        resolved_helicities,
+        amplitude_destinations,
+        closure_target_domain_certificate,
+        selector_work,
+        relation_discovery: relation_discovery_report,
+        exact_sections,
+        construction,
+        generation_profile,
+        timings: DirectLoweringTimings {
+            python_extraction_seconds,
+            catalog_authentication_seconds,
+            semantic_construction_seconds,
+            direct_lowering_seconds,
+            serialization_seconds,
+            native_total_seconds,
+        },
+        helicity_dispatch,
+    })
+}
+
+fn resolved_helicities_from_direct_plan(
+    plan: &DirectRecurrencePlan,
+) -> RusticolResult<Vec<Vec<i32>>> {
+    let public = plan.public_helicities();
+    plan.resolved_helicities()
+        .iter()
+        .enumerate()
+        .map(|(index, row)| {
+            if row.id != index as u32 {
+                return Err(invalid(format!(
+                    "direct resolved helicity {index} has non-canonical ID {}",
+                    row.id
+                )));
+            }
+            let start = usize::try_from(row.public_helicity_start)
+                .map_err(|_| invalid("direct resolved-helicity offset exceeds usize"))?;
+            let count = usize::try_from(row.public_helicity_count)
+                .map_err(|_| invalid("direct resolved-helicity count exceeds usize"))?;
+            let end = start
+                .checked_add(count)
+                .ok_or_else(|| invalid("direct resolved-helicity range exceeds usize"))?;
+            public
+                .get(start..end)
+                .map(<[i32]>::to_vec)
+                .ok_or_else(|| invalid("direct resolved-helicity range is out of bounds"))
+        })
+        .collect()
+}
+
+pub(super) fn canonical_json_sha256(value: &JsonValue, context: &str) -> RusticolResult<String> {
+    Ok(hex_digest(Sha256::digest(canonical_json_bytes(
+        value, context,
+    )?)))
+}
+
+fn parse_direct_template_catalog(
+    bytes: &[u8],
+    expected_pack_digest: SemanticDigest,
+    expected_template_catalog_digest: SemanticDigest,
+    expected_compiled_model_digest: SemanticDigest,
+) -> RusticolResult<AuthenticatedDirectTemplateCatalog> {
+    if bytes.is_empty() {
+        return Err(invalid("direct-template catalog JSON must not be empty"));
+    }
+    let value: JsonValue = serde_json::from_slice(bytes).map_err(|error| {
+        invalid(format!(
+            "direct-template catalog is not valid JSON: {error}"
+        ))
+    })?;
+    let canonical = canonical_json_bytes(&value, "direct-template catalog")?;
+    if canonical != bytes {
+        return Err(invalid(
+            "direct-template catalog JSON is not canonical ASCII JSON",
+        ));
+    }
+    let object = json_object(&value, "direct-template catalog")?;
+    require_json_fields(
+        object,
+        &[
+            "abi",
+            "backend",
+            "backend_abi",
+            "canonicalization_abi",
+            "catalog_digest",
+            "compiled_model_digest",
+            "optimization_level",
+            "optimization_settings_digest",
+            "portable",
+            "prepared_kernel_contract_digest",
+            "prepared_kernel_pack_digest",
+            "prepared_kernel_payload_digest",
+            "recurrence_template_catalog_digest",
+            "target_triple",
+            "templates",
+        ],
+        "direct-template catalog",
+    )?;
+    require_json_string_value(
+        object,
+        "abi",
+        RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "direct-template catalog",
+    )?;
+    require_json_string_value(
+        object,
+        "backend_abi",
+        DIRECT_BACKEND_ABI,
+        "direct-template catalog",
+    )?;
+    require_json_string_value(
+        object,
+        "canonicalization_abi",
+        DIRECT_CANONICALIZATION_ABI,
+        "direct-template catalog",
+    )?;
+
+    let catalog_digest = json_sha256(object, "catalog_digest", "direct-template catalog digest")?;
+    let actual_catalog_digest = digest_json_without_field(
+        &value,
+        "catalog_digest",
+        "direct-template catalog semantic payload",
+    )?;
+    if catalog_digest != actual_catalog_digest {
+        return Err(RusticolError::integrity(
+            "direct-template catalog digest does not match its canonical payload",
+        ));
+    }
+    let prepared_kernel_pack_digest = json_sha256(
+        object,
+        "prepared_kernel_pack_digest",
+        "direct-template prepared-kernel pack digest",
+    )?;
+    if prepared_kernel_pack_digest != expected_pack_digest {
+        return Err(RusticolError::integrity(
+            "direct-template catalog prepared-kernel pack digest does not match the requested pack",
+        ));
+    }
+    let recurrence_template_catalog_digest = json_sha256(
+        object,
+        "recurrence_template_catalog_digest",
+        "direct-template semantic catalog digest",
+    )?;
+    if recurrence_template_catalog_digest != expected_template_catalog_digest {
+        return Err(RusticolError::integrity(
+            "direct-template catalog does not match the authenticated recurrence template",
+        ));
+    }
+    let compiled_model_digest = json_sha256(
+        object,
+        "compiled_model_digest",
+        "direct-template compiled-model digest",
+    )?;
+    if compiled_model_digest != expected_compiled_model_digest {
+        return Err(RusticolError::integrity(
+            "direct-template catalog does not match the authenticated compiled model",
+        ));
+    }
+    for (field, context) in [
+        (
+            "prepared_kernel_contract_digest",
+            "direct-template prepared-kernel contract digest",
+        ),
+        (
+            "prepared_kernel_payload_digest",
+            "direct-template prepared-kernel payload digest",
+        ),
+        (
+            "optimization_settings_digest",
+            "direct-template optimization-settings digest",
+        ),
+    ] {
+        json_sha256(object, field, context)?;
+    }
+
+    let backend = json_string(object, "backend", "direct-template backend")?;
+    if !matches!(backend, "jit" | "cpp" | "asm") {
+        return Err(invalid(format!(
+            "direct-template catalog has unsupported backend {backend:?}"
+        )));
+    }
+    let target_triple =
+        json_nonempty_string(object, "target_triple", "direct-template target triple")?;
+    let portable = json_bool(object, "portable", "direct-template portable flag")?;
+    let optimization_level = json_u32(
+        object,
+        "optimization_level",
+        "direct-template optimization level",
+    )?;
+    match backend {
+        "jit" if !portable || optimization_level != 2 => {
+            return Err(invalid(
+                "prepared direct JIT catalogs must use portable SymJIT O2",
+            ));
+        }
+        "cpp" | "asm" if portable => {
+            return Err(invalid(
+                "prepared direct C++/ASM catalogs must be target-native",
+            ));
+        }
+        _ => {}
+    }
+
+    let templates = json_array(object, "templates", "direct-template templates")?;
+    if templates.is_empty() {
+        return Err(invalid(
+            "direct-template executor catalog must not be empty",
+        ));
+    }
+    let mut bindings = Vec::with_capacity(templates.len());
+    let mut exact_executors = Vec::with_capacity(templates.len());
+    let mut prepared_kernel_ids = BTreeSet::new();
+    let mut identity_finalizer_seen = false;
+    for (expected_executor_id, template_value) in templates.iter().enumerate() {
+        let context = format!("direct template {expected_executor_id}");
+        let template = json_object(template_value, &context)?;
+        require_json_fields(
+            template,
+            &[
+                "abi",
+                "alignment_bytes",
+                "backend",
+                "coupling_slot_count",
+                "destination_aliasing",
+                "destination_component_count",
+                "destination_operation",
+                "direct_executor_id",
+                "evaluator_binding_id",
+                "evaluator_resolver_key",
+                "exact_expression_digest",
+                "momentum_operand_count",
+                "optimization_level",
+                "parameter_slot_count",
+                "parent_arity",
+                "parent_component_counts",
+                "payload_binding",
+                "portable",
+                "role",
+                "semantic_digest",
+                "semantic_template_ids",
+                "simd_axis",
+                "target_triple",
+                "template_id",
+            ],
+            &context,
+        )?;
+        require_json_string_value(template, "abi", RECURRENCE_DIRECT_TEMPLATE_ABI, &context)?;
+        let actual_template_digest =
+            digest_json_without_field(template_value, "semantic_digest", &context)?;
+        let template_digest = json_sha256(
+            template,
+            "semantic_digest",
+            &format!("{context} semantic digest"),
+        )?;
+        if template_digest != actual_template_digest {
+            return Err(RusticolError::integrity(format!(
+                "{context} semantic digest does not match its canonical payload"
+            )));
+        }
+
+        let direct_executor_id = json_u32(
+            template,
+            "direct_executor_id",
+            &format!("{context} executor ID"),
+        )?;
+        let expected_executor_id = u32::try_from(expected_executor_id)
+            .map_err(|_| invalid("direct-template executor count exceeds u32"))?;
+        if direct_executor_id != expected_executor_id {
+            return Err(invalid(format!(
+                "{context} has executor ID {direct_executor_id}, expected dense ID {expected_executor_id}"
+            )));
+        }
+        let evaluator_binding_id = json_u32(
+            template,
+            "evaluator_binding_id",
+            &format!("{context} evaluator-binding ID"),
+        )?;
+        let role_text = json_string(template, "role", &format!("{context} role"))?;
+        let role = direct_executor_role(role_text, &context)?;
+        let expected_operation = match role {
+            DirectExecutorRole::Source => "initialize",
+            DirectExecutorRole::Contribution => "add",
+            DirectExecutorRole::Finalization => "finalize-in-place",
+            DirectExecutorRole::Closure => "closure-add",
+        };
+        require_json_string_value(
+            template,
+            "destination_operation",
+            expected_operation,
+            &context,
+        )?;
+        require_json_string_value(template, "backend", backend, &context)?;
+        require_json_string_value(template, "target_triple", target_triple, &context)?;
+        if json_bool(template, "portable", &format!("{context} portable flag"))? != portable
+            || json_u32(
+                template,
+                "optimization_level",
+                &format!("{context} optimization level"),
+            )? != optimization_level
+        {
+            return Err(invalid(format!(
+                "{context} backend policy does not match its catalog"
+            )));
+        }
+        require_json_string_value(template, "simd_axis", "points-contiguous", &context)?;
+        let destination_aliasing = json_bool(
+            template,
+            "destination_aliasing",
+            &format!("{context} destination aliasing"),
+        )?;
+        if destination_aliasing != (role == DirectExecutorRole::Finalization) {
+            return Err(invalid(format!(
+                "{context} has an invalid destination-aliasing contract"
+            )));
+        }
+        json_nonempty_string(template, "template_id", &format!("{context} template ID"))?;
+        json_nonempty_string(
+            template,
+            "evaluator_resolver_key",
+            &format!("{context} evaluator resolver key"),
+        )?;
+        json_sha256(
+            template,
+            "exact_expression_digest",
+            &format!("{context} exact-expression digest"),
+        )?;
+        validate_direct_template_shapes(template, &context)?;
+        let parent_component_counts = json_array(
+            template,
+            "parent_component_counts",
+            &format!("{context} parent component counts"),
+        )?
+        .iter()
+        .enumerate()
+        .map(|(index, value)| json_value_u32(value, &format!("{context} parent component {index}")))
+        .collect::<RusticolResult<Vec<_>>>()?;
+        let destination_component_count = json_u32(
+            template,
+            "destination_component_count",
+            &format!("{context} destination component count"),
+        )?;
+        let momentum_operand_count = json_u32(
+            template,
+            "momentum_operand_count",
+            &format!("{context} momentum operand count"),
+        )?;
+
+        let payload = json_object(
+            json_field(template, "payload_binding", &context)?,
+            &format!("{context} payload binding"),
+        )?;
+        require_json_fields_with_optional(
+            payload,
+            &[
+                "abi",
+                "destination_operation",
+                "direct_application_abi",
+                "exact_factor_scalar_slots",
+                "input_plane_count",
+                "input_plane_projections",
+                "intrinsic_contract_digest",
+                "kind",
+                "output_alias_inputs",
+                "contribution_parent_permutation",
+                "parameter_bindings",
+                "payload_digest",
+                "payload_paths",
+                "prepared_kernel_id",
+                "prepared_template_semantic_digest",
+                "role",
+                "runtime_template",
+                "scalar_input_count",
+                "scalar_projections",
+                "source_application_abi",
+                "source_application_path",
+                "source_application_sha256",
+                "state_plane_indices",
+            ],
+            &["native_entry_point"],
+            &format!("{context} payload binding"),
+        )?;
+        require_json_string_value(
+            payload,
+            "abi",
+            DIRECT_PAYLOAD_BINDING_ABI,
+            &format!("{context} payload binding"),
+        )?;
+        json_sha256(
+            payload,
+            "payload_digest",
+            &format!("{context} payload digest"),
+        )?;
+        let payload_kind = json_string(payload, "kind", &format!("{context} payload kind"))?;
+        if !matches!(
+            payload_kind,
+            "rusticol-intrinsic" | "prepared-direct-call" | "pending-direct-call-abi"
+        ) {
+            return Err(invalid(format!(
+                "{context} has unsupported payload kind {payload_kind:?}"
+            )));
+        }
+        if payload_kind == "pending-direct-call-abi" {
+            return Err(RusticolError::compatibility(format!(
+                "{context} has no executable Direct-Arena payload; rebuild the prepared model"
+            )));
+        }
+        let parent_permutation_values = json_array(
+            payload,
+            "contribution_parent_permutation",
+            &format!("{context} parent permutation"),
+        )?;
+        if parent_permutation_values.len() != 2 {
+            return Err(invalid(format!(
+                "{context} parent permutation must contain two entries"
+            )));
+        }
+        let mut parent_permutation = [0_u8; 2];
+        for (index, value) in parent_permutation_values.iter().enumerate() {
+            parent_permutation[index] = u8::try_from(json_value_u32(
+                value,
+                &format!("{context} parent permutation entry {index}"),
+            )?)
+            .map_err(|_| invalid(format!("{context} parent permutation exceeds u8")))?;
+        }
+        if !matches!(parent_permutation, [0, 1] | [1, 0])
+            || (parent_permutation != [0, 1]
+                && !(payload_kind == "rusticol-intrinsic"
+                    && role == DirectExecutorRole::Contribution))
+        {
+            return Err(invalid(format!(
+                "{context} has an invalid parent permutation"
+            )));
+        }
+        let runtime_template = json_optional_string(
+            payload,
+            "runtime_template",
+            &format!("{context} runtime template"),
+        )?;
+        let prepared_kernel_id = json_optional_u32(
+            payload,
+            "prepared_kernel_id",
+            &format!("{context} prepared-kernel ID"),
+        )?;
+        exact_executors.push(NativeRecurrenceExactExecutor {
+            direct_executor_id,
+            role: role_text.to_owned(),
+            destination_operation: expected_operation.to_owned(),
+            parent_component_counts,
+            destination_component_count,
+            momentum_operand_count,
+            prepared_kernel_id,
+            runtime_template: runtime_template.map(str::to_owned),
+        });
+        let native_entry_point = match payload.get("native_entry_point") {
+            None | Some(JsonValue::Null) => None,
+            Some(JsonValue::String(value)) if !value.is_empty() => Some(value.as_str()),
+            Some(_) => {
+                return Err(invalid(format!(
+                    "{context} native entry point must be a nonempty string or null"
+                )));
+            }
+        };
+        match (payload_kind, backend) {
+            ("prepared-direct-call", "cpp" | "asm") => {
+                let kernel_id = prepared_kernel_id.ok_or_else(|| {
+                    invalid(format!(
+                        "{context} native prepared call has no prepared-kernel ID"
+                    ))
+                })?;
+                let expected =
+                    format!("pyamplicol_recurrence_direct_{role_text}_k{kernel_id:08x}_v1");
+                if native_entry_point != Some(expected.as_str()) {
+                    return Err(invalid(format!(
+                        "{context} native prepared call has a noncanonical entry point"
+                    )));
+                }
+            }
+            _ if native_entry_point.is_some() => {
+                return Err(invalid(format!(
+                    "{context} non-native payload carries a native entry point"
+                )));
+            }
+            _ => {}
+        }
+        let intrinsic_contract_digest = json_optional_string(
+            payload,
+            "intrinsic_contract_digest",
+            &format!("{context} intrinsic contract digest"),
+        )?;
+        if let Some(digest) = intrinsic_contract_digest {
+            semantic_digest_from_hex(digest, &format!("{context} intrinsic contract digest"))?;
+        }
+        if payload_kind == "rusticol-intrinsic"
+            && role == DirectExecutorRole::Contribution
+            && intrinsic_contract_digest.is_none()
+        {
+            return Err(invalid(format!(
+                "{context} contribution intrinsic has no certified contract digest"
+            )));
+        }
+        if payload_kind != "rusticol-intrinsic" && intrinsic_contract_digest.is_some() {
+            return Err(invalid(format!(
+                "{context} non-intrinsic payload carries an intrinsic contract digest"
+            )));
+        }
+        validate_string_array(
+            json_array(
+                payload,
+                "payload_paths",
+                &format!("{context} payload paths"),
+            )?,
+            &format!("{context} payload paths"),
+        )?;
+
+        let identity_finalizer =
+            runtime_template.is_some_and(|name| name == DIRECT_IDENTITY_FINALIZER);
+        if identity_finalizer {
+            if identity_finalizer_seen {
+                return Err(invalid(
+                    "direct-template catalog contains more than one generic identity finalizer",
+                ));
+            }
+            if role != DirectExecutorRole::Finalization
+                || payload_kind != "rusticol-intrinsic"
+                || prepared_kernel_id.is_some()
+            {
+                return Err(invalid(format!(
+                    "{context} has an invalid identity-finalizer contract"
+                )));
+            }
+            identity_finalizer_seen = true;
+            bindings.push(PreparedDirectExecutorBinding::identity_finalizer(
+                direct_executor_id,
+            ));
+        } else {
+            if let Some(kernel_id) = prepared_kernel_id {
+                prepared_kernel_ids.insert(kernel_id);
+            }
+            bindings.push(
+                PreparedDirectExecutorBinding::evaluator_with_parent_permutation(
+                    role,
+                    evaluator_binding_id,
+                    direct_executor_id,
+                    parent_permutation,
+                ),
+            );
+        }
+    }
+
+    let catalog = PreparedDirectExecutorCatalog::new(catalog_digest, bindings)?;
+    Ok(AuthenticatedDirectTemplateCatalog {
+        catalog,
+        catalog_digest,
+        prepared_kernel_pack_digest,
+        prepared_kernel_count: prepared_kernel_ids.len(),
+        exact_executors,
+    })
+}
+
+fn exact_sections_from_direct_plan(
+    plan: &DirectRecurrencePlan,
+    process_id: String,
+    executors: Vec<NativeRecurrenceExactExecutor>,
+) -> NativeRecurrenceExactSections {
+    let public_flow_ids = match plan.strategy() {
+        RecurrenceStrategy::TopologyReplay => plan
+            .replay_targets()
+            .iter()
+            .map(|target| target.public_flow_id)
+            .collect(),
+        RecurrenceStrategy::AllFlowUnion => plan
+            .amplitude_destinations()
+            .iter()
+            .map(|destination| destination.target_sector_id)
+            .collect(),
+        RecurrenceStrategy::ContractedColorUnion => Vec::new(),
+    };
+    let exact_factors = plan
+        .exact_factors()
+        .iter()
+        .map(|factor| NativeRecurrenceExactFactor {
+            real_numerator: factor.real().numerator().to_string(),
+            real_denominator: factor.real().denominator().to_string(),
+            imaginary_numerator: factor.imag().numerator().to_string(),
+            imaginary_denominator: factor.imag().denominator().to_string(),
+        })
+        .collect();
+    NativeRecurrenceExactSections {
+        process_id,
+        strategy: plan.strategy().as_str().to_owned(),
+        semantic_digest: plan.semantic_digest().to_string(),
+        runtime_layout_digest: plan.runtime_layout_digest().to_string(),
+        current_arena_components: plan.current_arena_components(),
+        amplitude_destination_count: plan.amplitude_destination_count(),
+        parameter_value_count: plan.parameter_value_count(),
+        external_source_count: plan.external_source_count(),
+        currents: plan.currents().to_vec(),
+        sources: plan.sources().to_vec(),
+        contributions: plan.contributions().to_vec(),
+        finalizations: plan.finalizations().to_vec(),
+        closures: plan.closures().to_vec(),
+        row_groups: plan.row_groups().to_vec(),
+        momentum_forms: plan.momentum_forms().to_vec(),
+        momentum_terms: plan.momentum_terms().to_vec(),
+        replay_targets: plan.replay_targets().to_vec(),
+        source_permutations: plan.source_permutations().to_vec(),
+        replay_momentum_signs: plan.replay_momentum_signs().to_vec(),
+        replay_helicity_map: plan.replay_helicity_map().to_vec(),
+        amplitude_destinations: plan.amplitude_destinations().to_vec(),
+        resolved_helicities: plan.resolved_helicities().to_vec(),
+        public_helicities: plan.public_helicities().to_vec(),
+        source_state_assignments: plan.source_state_assignments().to_vec(),
+        source_dispatch_variants: plan.source_dispatch_variants().to_vec(),
+        source_embeddings: plan.source_embeddings().to_vec(),
+        source_projections: plan.source_projections().to_vec(),
+        resolved_source_selections: plan.resolved_source_selections().to_vec(),
+        exact_factors,
+        public_flow_ids,
+        executors,
+    }
+}
+
+fn validate_direct_template_shapes(
+    template: &JsonMap<String, JsonValue>,
+    context: &str,
+) -> RusticolResult<()> {
+    let parent_arity = json_u32(template, "parent_arity", &format!("{context} parent arity"))?;
+    let parent_counts = json_array(
+        template,
+        "parent_component_counts",
+        &format!("{context} parent component counts"),
+    )?;
+    if parent_counts.len() != parent_arity as usize {
+        return Err(invalid(format!(
+            "{context} parent component counts do not match parent arity"
+        )));
+    }
+    for (index, value) in parent_counts.iter().enumerate() {
+        let count = json_value_u32(value, &format!("{context} parent component {index}"))?;
+        if count == 0 {
+            return Err(invalid(format!(
+                "{context} parent component {index} is empty"
+            )));
+        }
+    }
+    for field in [
+        "coupling_slot_count",
+        "momentum_operand_count",
+        "parameter_slot_count",
+    ] {
+        json_u32(template, field, &format!("{context} {field}"))?;
+    }
+    if json_u32(
+        template,
+        "destination_component_count",
+        &format!("{context} destination component count"),
+    )? == 0
+    {
+        return Err(invalid(format!(
+            "{context} destination component count must be positive"
+        )));
+    }
+    let alignment = json_u32(template, "alignment_bytes", &format!("{context} alignment"))?;
+    if alignment == 0 || !alignment.is_power_of_two() {
+        return Err(invalid(format!(
+            "{context} alignment must be a positive power of two"
+        )));
+    }
+    validate_string_array(
+        json_array(
+            template,
+            "semantic_template_ids",
+            &format!("{context} semantic template IDs"),
+        )?,
+        &format!("{context} semantic template IDs"),
+    )
+}
+
+fn direct_executor_role(value: &str, context: &str) -> RusticolResult<DirectExecutorRole> {
+    match value {
+        "source" => Ok(DirectExecutorRole::Source),
+        "contribution" => Ok(DirectExecutorRole::Contribution),
+        "finalization" => Ok(DirectExecutorRole::Finalization),
+        "closure" => Ok(DirectExecutorRole::Closure),
+        _ => Err(invalid(format!(
+            "{context} has unsupported direct role {value:?}"
+        ))),
+    }
+}
+
+pub(super) fn canonical_json_bytes(value: &JsonValue, context: &str) -> RusticolResult<Vec<u8>> {
+    serde_json::to_vec(value)
+        .map_err(|error| invalid(format!("could not canonicalize {context}: {error}")))
+}
+
+fn digest_json_without_field(
+    value: &JsonValue,
+    field: &str,
+    context: &str,
+) -> RusticolResult<SemanticDigest> {
+    let mut semantic = value.clone();
+    let object = semantic
+        .as_object_mut()
+        .ok_or_else(|| invalid(format!("{context} must be a JSON object")))?;
+    if object.remove(field).is_none() {
+        return Err(invalid(format!("{context} has no {field:?} field")));
+    }
+    let digest: [u8; 32] = Sha256::digest(canonical_json_bytes(&semantic, context)?).into();
+    SemanticDigest::new(digest)
+}
+
+pub(super) fn json_object<'a>(
+    value: &'a JsonValue,
+    context: &str,
+) -> RusticolResult<&'a JsonMap<String, JsonValue>> {
+    value
+        .as_object()
+        .ok_or_else(|| invalid(format!("{context} must be a JSON object")))
+}
+
+pub(super) fn require_json_fields(
+    object: &JsonMap<String, JsonValue>,
+    expected: &[&str],
+    context: &str,
+) -> RusticolResult<()> {
+    require_json_fields_with_optional(object, expected, &[], context)
+}
+
+fn require_json_fields_with_optional(
+    object: &JsonMap<String, JsonValue>,
+    expected: &[&str],
+    optional: &[&str],
+    context: &str,
+) -> RusticolResult<()> {
+    let expected = expected.iter().copied().collect::<BTreeSet<_>>();
+    let optional = optional.iter().copied().collect::<BTreeSet<_>>();
+    let allowed = expected.union(&optional).copied().collect::<BTreeSet<_>>();
+    let actual = object.keys().map(String::as_str).collect::<BTreeSet<_>>();
+    if expected.is_subset(&actual) && actual.is_subset(&allowed) {
+        return Ok(());
+    }
+    let missing = expected.difference(&actual).copied().collect::<Vec<_>>();
+    let unexpected = actual.difference(&allowed).copied().collect::<Vec<_>>();
+    Err(invalid(format!(
+        "{context} fields do not match direct-template-v1; missing={missing:?}, unexpected={unexpected:?}"
+    )))
+}
+
+pub(super) fn json_field<'a>(
+    object: &'a JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<&'a JsonValue> {
+    object
+        .get(field)
+        .ok_or_else(|| invalid(format!("{context} has no {field:?} field")))
+}
+
+pub(super) fn json_string<'a>(
+    object: &'a JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<&'a str> {
+    json_field(object, field, context)?
+        .as_str()
+        .ok_or_else(|| invalid(format!("{context} must be a string")))
+}
+
+pub(super) fn json_nonempty_string<'a>(
+    object: &'a JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<&'a str> {
+    let value = json_string(object, field, context)?;
+    if value.is_empty() {
+        return Err(invalid(format!("{context} must not be empty")));
+    }
+    Ok(value)
+}
+
+pub(super) fn require_json_string_value(
+    object: &JsonMap<String, JsonValue>,
+    field: &str,
+    expected: &str,
+    context: &str,
+) -> RusticolResult<()> {
+    let actual = json_string(object, field, context)?;
+    if actual != expected {
+        return Err(invalid(format!(
+            "{context} {field:?} is {actual:?}, expected {expected:?}"
+        )));
+    }
+    Ok(())
+}
+
+pub(super) fn json_bool(
+    object: &JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<bool> {
+    json_field(object, field, context)?
+        .as_bool()
+        .ok_or_else(|| invalid(format!("{context} must be a boolean")))
+}
+
+pub(super) fn json_u32(
+    object: &JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<u32> {
+    json_value_u32(json_field(object, field, context)?, context)
+}
+
+fn json_value_u32(value: &JsonValue, context: &str) -> RusticolResult<u32> {
+    value
+        .as_u64()
+        .and_then(|value| u32::try_from(value).ok())
+        .ok_or_else(|| invalid(format!("{context} must be a nonnegative u32")))
+}
+
+pub(super) fn json_optional_u32(
+    object: &JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<Option<u32>> {
+    let value = json_field(object, field, context)?;
+    if value.is_null() {
+        return Ok(None);
+    }
+    json_value_u32(value, context).map(Some)
+}
+
+fn json_optional_string<'a>(
+    object: &'a JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<Option<&'a str>> {
+    let value = json_field(object, field, context)?;
+    if value.is_null() {
+        return Ok(None);
+    }
+    value
+        .as_str()
+        .filter(|value| !value.is_empty())
+        .map(Some)
+        .ok_or_else(|| invalid(format!("{context} must be null or a nonempty string")))
+}
+
+pub(super) fn json_array<'a>(
+    object: &'a JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<&'a [JsonValue]> {
+    json_field(object, field, context)?
+        .as_array()
+        .map(Vec::as_slice)
+        .ok_or_else(|| invalid(format!("{context} must be a JSON array")))
+}
+
+fn validate_string_array(values: &[JsonValue], context: &str) -> RusticolResult<()> {
+    if values
+        .iter()
+        .all(|value| value.as_str().is_some_and(|value| !value.is_empty()))
+    {
+        return Ok(());
+    }
+    Err(invalid(format!(
+        "{context} must contain only nonempty strings"
+    )))
+}
+
+fn json_sha256(
+    object: &JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<SemanticDigest> {
+    semantic_digest_from_hex(json_string(object, field, context)?, context)
+}
+
+fn report_recurrence_build_progress(
+    callback: Option<&Py<PyAny>>,
+    progress: RecurrenceBuildProgress,
+) -> RusticolResult<()> {
+    let Some(callback) = callback else {
+        return Ok(());
+    };
+    Python::attach(|py| -> PyResult<()> {
+        let payload = PyDict::new(py);
+        payload.set_item("step", progress.phase)?;
+        payload.set_item("phase_index", progress.phase_index)?;
+        payload.set_item("phase_total", progress.phase_total)?;
+        payload.set_item("stage_total", progress.stage_total)?;
+        payload.set_item(
+            "candidate_parent_pair_count",
+            progress.candidate_parent_pair_count,
+        )?;
+        payload.set_item("current_count", progress.current_count)?;
+        payload.set_item("contribution_count", progress.contribution_count)?;
+        payload.set_item(
+            "dynamic_color_state_count",
+            progress.dynamic_color_state_count,
+        )?;
+        payload.set_item(
+            "color_target_prune_count",
+            progress.color_target_prune_count,
+        )?;
+        if let Some(stage_index) = progress.stage_index {
+            payload.set_item("stage_index", stage_index)?;
+        }
+        if let Some(subset_size) = progress.subset_size {
+            payload.set_item("subset_size", subset_size)?;
+        }
+        if let Some(total) = progress.candidate_parent_pair_total {
+            payload.set_item("candidate_parent_pair_total", total)?;
+        }
+        callback.bind(py).call1((payload,))?;
+        Ok(())
+    })
+    .map_err(|error| invalid(format!("recurrence progress callback failed: {error}")))
+}
+
+fn recurrence_generation_profile_mapping<'py>(
+    py: Python<'py>,
+    native: &NativeDirectLoweringResult,
+) -> PyResult<Bound<'py, PyDict>> {
+    let profile = PyDict::new(py);
+    profile.set_item("schema_version", 1)?;
+    profile.set_item("scope", "generation-only")?;
+
+    let telemetry = &native.generation_profile;
+    let timings = PyDict::new(py);
+    for (name, nanoseconds) in [
+        (
+            "transition-catalog",
+            telemetry.transition_catalog_nanoseconds,
+        ),
+        (
+            "structural-feasibility",
+            telemetry.structural_feasibility_nanoseconds,
+        ),
+        (
+            "color-target-index",
+            telemetry.color_target_index_nanoseconds,
+        ),
+        ("structural-demand", telemetry.structural_demand_nanoseconds),
+        ("support-indexing", telemetry.support_indexing_nanoseconds),
+        (
+            "candidate-processing",
+            telemetry.candidate_processing_nanoseconds,
+        ),
+        (
+            "closure-processing",
+            telemetry.closure_processing_nanoseconds,
+        ),
+        (
+            "canonical-emission",
+            telemetry.canonical_emission_nanoseconds,
+        ),
+    ] {
+        timings.set_item(name, nanoseconds as f64 / 1_000_000_000.0)?;
+    }
+    for (name, seconds) in [
+        (
+            "python-extraction",
+            native.timings.python_extraction_seconds,
+        ),
+        (
+            "catalog-authentication",
+            native.timings.catalog_authentication_seconds,
+        ),
+        (
+            "semantic-construction-total",
+            native.timings.semantic_construction_seconds,
+        ),
+        ("direct-lowering", native.timings.direct_lowering_seconds),
+        ("serialization", native.timings.serialization_seconds),
+        ("native-total", native.timings.native_total_seconds),
+    ] {
+        timings.set_item(name, seconds)?;
+    }
+    profile.set_item("timings_seconds", timings)?;
+
+    let counters = PyDict::new(py);
+    for (name, value) in [
+        ("support_bucket_count", telemetry.support_bucket_count),
+        (
+            "support_bucket_probe_count",
+            telemetry.support_bucket_probe_count,
+        ),
+        (
+            "support_bucket_cache_hit_count",
+            telemetry.support_bucket_cache_hit_count,
+        ),
+        (
+            "support_bucket_cache_miss_count",
+            telemetry.support_bucket_cache_miss_count,
+        ),
+        (
+            "candidate_parent_pair_theoretical_count",
+            telemetry.candidate_parent_pair_theoretical_count,
+        ),
+        (
+            "candidate_parent_pair_visited_count",
+            telemetry.candidate_parent_pair_visited_count,
+        ),
+        (
+            "structural_feasible_support_count",
+            telemetry.structural_feasible_support_count,
+        ),
+        (
+            "structural_decomposition_count",
+            telemetry.structural_decomposition_count,
+        ),
+        (
+            "structural_forward_transition_probe_count",
+            telemetry.structural_forward_transition_probe_count,
+        ),
+        (
+            "structural_demand_support_count",
+            telemetry.structural_demand_support_count,
+        ),
+        (
+            "structural_demand_state_count",
+            telemetry.structural_demand_state_count,
+        ),
+        ("structural_reject_count", telemetry.structural_reject_count),
+        (
+            "transition_index_hit_count",
+            telemetry.transition_index_hit_count,
+        ),
+        (
+            "transition_index_miss_count",
+            telemetry.transition_index_miss_count,
+        ),
+        (
+            "transition_candidate_count",
+            telemetry.transition_candidate_count,
+        ),
+        ("quantum_match_count", telemetry.quantum_match_count),
+        ("coupling_match_count", telemetry.coupling_match_count),
+        ("transition_accept_count", telemetry.transition_accept_count),
+        ("color_shape_match_count", telemetry.color_shape_match_count),
+        ("color_result_count", telemetry.color_result_count),
+        (
+            "color_target_accept_count",
+            telemetry.color_target_accept_count,
+        ),
+        (
+            "color_target_reject_count",
+            telemetry.color_target_reject_count,
+        ),
+        (
+            "color_acceptance_cache_hit_count",
+            telemetry.color_acceptance_cache_hit_count,
+        ),
+        (
+            "color_acceptance_cache_miss_count",
+            telemetry.color_acceptance_cache_miss_count,
+        ),
+        (
+            "color_fragment_bucket_count",
+            telemetry.color_fragment_bucket_count,
+        ),
+        (
+            "color_fragment_hash_lookup_count",
+            telemetry.color_fragment_hash_lookup_count,
+        ),
+        (
+            "color_posting_incidence_count",
+            telemetry.color_posting_incidence_count,
+        ),
+        (
+            "color_sparse_posting_bucket_count",
+            telemetry.color_sparse_posting_bucket_count,
+        ),
+        (
+            "color_dense_posting_bucket_count",
+            telemetry.color_dense_posting_bucket_count,
+        ),
+        (
+            "color_sparse_posting_bytes",
+            telemetry.color_sparse_posting_bytes,
+        ),
+        (
+            "color_dense_posting_bytes",
+            telemetry.color_dense_posting_bytes,
+        ),
+        (
+            "accepted_parent_key_clone_count",
+            telemetry.accepted_parent_key_clone_count,
+        ),
+        (
+            "current_key_lookup_count",
+            telemetry.current_key_lookup_count,
+        ),
+        ("current_key_hit_count", telemetry.current_key_hit_count),
+        ("current_insert_count", telemetry.current_insert_count),
+        ("current_key_clone_count", telemetry.current_key_clone_count),
+        (
+            "indexed_hash_lookup_count",
+            telemetry.indexed_hash_lookup_count,
+        ),
+        (
+            "contribution_attempt_count",
+            telemetry.contribution_attempt_count,
+        ),
+        (
+            "contribution_insert_count",
+            telemetry.contribution_insert_count,
+        ),
+        (
+            "contribution_merge_count",
+            telemetry.contribution_merge_count,
+        ),
+        (
+            "closure_candidate_theoretical_count",
+            telemetry.closure_candidate_theoretical_count,
+        ),
+        ("closure_candidate_count", telemetry.closure_candidate_count),
+        (
+            "closure_support_lookup_count",
+            telemetry.closure_support_lookup_count,
+        ),
+        (
+            "closure_state_match_count",
+            telemetry.closure_state_match_count,
+        ),
+        (
+            "closure_color_attempt_count",
+            telemetry.closure_color_attempt_count,
+        ),
+        ("closure_group_count", telemetry.closure_group_count),
+        (
+            "closure_proof_contribution_count",
+            telemetry.closure_proof_contribution_count,
+        ),
+        (
+            "constructed_current_count",
+            telemetry.constructed_current_count,
+        ),
+        (
+            "constructed_contribution_count",
+            telemetry.constructed_contribution_count,
+        ),
+        (
+            "constructed_interaction_count",
+            telemetry.constructed_interaction_count,
+        ),
+        (
+            "constructed_dynamic_color_state_count",
+            telemetry.constructed_dynamic_color_state_count,
+        ),
+        ("emitted_current_count", telemetry.emitted_current_count),
+        (
+            "emitted_contribution_count",
+            telemetry.emitted_contribution_count,
+        ),
+        (
+            "emitted_interaction_count",
+            telemetry.emitted_interaction_count,
+        ),
+        (
+            "emitted_finalization_count",
+            telemetry.emitted_finalization_count,
+        ),
+        ("emitted_closure_count", telemetry.emitted_closure_count),
+    ] {
+        counters.set_item(name, value)?;
+    }
+    profile.set_item("operation_counters", counters)?;
+
+    let serialized_bytes = PyDict::new(py);
+    serialized_bytes.set_item("plan_payload", native.plan_payload_size)?;
+    serialized_bytes.set_item("container", native.container_size)?;
+    serialized_bytes.set_item("unpacked_container", native.unpacked_size_bytes)?;
+    profile.set_item("serialized_bytes", serialized_bytes)?;
+    Ok(profile)
+}
+
+fn direct_lowering_mapping(
+    py: Python<'_>,
+    native: NativeDirectLoweringResult,
+) -> PyResult<Py<PyAny>> {
+    let generation_profile = recurrence_generation_profile_mapping(py, &native)?;
+    let result = PyDict::new(py);
+    result.set_item("kind", DIRECT_LOWERING_RESULT_KIND)?;
+    result.set_item("schema_version", DIRECT_LOWERING_RESULT_SCHEMA_VERSION)?;
+    result.set_item("builder_input_abi", DIRECT_BUILDER_INPUT_ABI)?;
+    result.set_item("builder_input_sha256", native.builder_input_digest)?;
+    result.set_item(
+        "template_input_abi",
+        template::RECURRENCE_TEMPLATE_INPUT_ABI,
+    )?;
+    result.set_item("template_input_sha256", native.template_input_digest)?;
+    result.set_item(
+        "prepared_kernel_pack_digest",
+        native.prepared_kernel_pack_digest,
+    )?;
+    result.set_item("direct_template_abi", RECURRENCE_DIRECT_TEMPLATE_ABI)?;
+    result.set_item(
+        "direct_template_catalog_digest",
+        native.direct_template_catalog_digest,
+    )?;
+    result.set_item("recurrence_plan_abi", RECURRENCE_DIRECT_PLAN_ABI)?;
+    result.set_item("runtime_layout_abi", RECURRENCE_DIRECT_RUNTIME_LAYOUT_ABI)?;
+    result.set_item(
+        "required_runtime_capabilities",
+        PyList::new(
+            py,
+            [
+                match native.strategy {
+                    RecurrenceStrategy::ContractedColorUnion => {
+                        RECURRENCE_CONTRACTED_COLOR_CAPABILITY
+                    }
+                    RecurrenceStrategy::TopologyReplay | RecurrenceStrategy::AllFlowUnion => {
+                        RECURRENCE_LC_COLOR_CAPABILITY
+                    }
+                },
+                RECURRENCE_DIRECT_RUNTIME_CAPABILITY,
+            ],
+        )?,
+    )?;
+
+    let container = PyDict::new(py);
+    container.set_item("kind", RUNTIME_CONTAINER_KIND)?;
+    container.set_item("schema_version", RUNTIME_CONTAINER_SCHEMA_VERSION)?;
+    container.set_item("storage_abi", STORAGE_ABI)?;
+    container.set_item("member_count", native.member_count)?;
+    container.set_item("unpacked_size_bytes", native.unpacked_size_bytes)?;
+    container.set_item("index_sha256", native.index_sha256)?;
+    result.set_item("runtime_container", container)?;
+
+    let inspection = PyDict::new(py);
+    inspection.set_item("execution_mode", "recurrence")?;
+    inspection.set_item("recurrence_plan_abi", RECURRENCE_DIRECT_PLAN_ABI)?;
+    inspection.set_item("runtime_layout_abi", RECURRENCE_DIRECT_RUNTIME_LAYOUT_ABI)?;
+    inspection.set_item("direct_template_abi", RECURRENCE_DIRECT_TEMPLATE_ABI)?;
+    inspection.set_item("process_id", native.process_id)?;
+    inspection.set_item("lc_flow_layout", native.strategy.as_str())?;
+    inspection.set_item("prepared_kernel_count", native.prepared_kernel_count)?;
+    inspection.set_item("parameter_count", native.parameter_value_count)?;
+    inspection.set_item("sector_count", native.physical_sector_count)?;
+    inspection.set_item("direct_executor_count", native.direct_executor_count)?;
+    inspection.set_item("semantic_digest", native.semantic_digest)?;
+    inspection.set_item("runtime_layout_digest", native.runtime_layout_digest)?;
+
+    let schedule = PyDict::new(py);
+    schedule.set_item("current_count", native.current_count)?;
+    schedule.set_item("source_row_count", native.source_row_count)?;
+    schedule.set_item("contribution_count", native.contribution_count)?;
+    schedule.set_item("finalization_count", native.finalization_count)?;
+    schedule.set_item("closure_term_count", native.closure_count)?;
+    schedule.set_item(
+        "amplitude_destination_count",
+        native.amplitude_destination_count,
+    )?;
+    schedule.set_item("replay_target_count", native.replay_target_count)?;
+    schedule.set_item("resolved_helicity_count", native.resolved_helicity_count)?;
+    schedule.set_item("retained_helicity_count", native.retained_helicity_count)?;
+    schedule.set_item("exact_factor_count", native.exact_factor_count)?;
+    inspection.set_item("schedule", schedule)?;
+
+    let selector_work = PyDict::new(py);
+    selector_work.set_item("schema_version", 1)?;
+    selector_work.set_item("binding", "runtime_layout_digest")?;
+    let persisted = PyDict::new(py);
+    persisted.set_item("current_count", native.current_count)?;
+    persisted.set_item("semantic_component_count", native.semantic_component_count)?;
+    persisted.set_item("source_row_count", native.source_row_count)?;
+    persisted.set_item("contribution_count", native.contribution_count)?;
+    persisted.set_item("finalization_count", native.finalization_count)?;
+    persisted.set_item("closure_count", native.closure_count)?;
+    persisted.set_item(
+        "row_count",
+        native.source_row_count
+            + native.contribution_count
+            + native.finalization_count
+            + native.closure_count,
+    )?;
+    selector_work.set_item("persisted_union", persisted)?;
+    let representatives = PyList::empty(py);
+    for (summary, public_flow_count) in native.selector_work {
+        let entry = PyDict::new(py);
+        entry.set_item("representative_sector_id", summary.physical_sector_id)?;
+        entry.set_item("public_flow_count", public_flow_count)?;
+        entry.set_item("current_count", summary.current_count)?;
+        entry.set_item("semantic_component_count", summary.semantic_component_count)?;
+        entry.set_item("source_row_count", summary.source_row_count)?;
+        entry.set_item("contribution_count", summary.contribution_count)?;
+        entry.set_item("finalization_count", summary.finalization_count)?;
+        entry.set_item("closure_count", summary.closure_count)?;
+        entry.set_item(
+            "amplitude_destination_count",
+            summary.amplitude_destination_count,
+        )?;
+        entry.set_item("row_count", summary.row_count())?;
+        representatives.append(entry)?;
+    }
+    selector_work.set_item("representatives", representatives)?;
+    inspection.set_item("selector_work_certificate", selector_work)?;
+
+    let construction = PyDict::new(py);
+    construction.set_item("peak_current_count", native.construction.peak_current_count)?;
+    construction.set_item(
+        "peak_contribution_count",
+        native.construction.peak_contribution_count,
+    )?;
+    construction.set_item(
+        "peak_contribution_count_semantics",
+        "resident-pending-contributions-v1",
+    )?;
+    construction.set_item(
+        "peak_dynamic_color_state_count",
+        native.construction.peak_dynamic_color_state_count,
+    )?;
+    construction.set_item(
+        "color_target_prune_count",
+        native.construction.color_target_prune_count,
+    )?;
+    construction.set_item(
+        "candidate_parent_pair_count",
+        native.construction.candidate_parent_pair_count(),
+    )?;
+    construction.set_item(
+        "peak_to_final_current_ratio",
+        native.construction.peak_current_count as f64 / native.current_count.max(1) as f64,
+    )?;
+    construction.set_item(
+        "peak_to_final_contribution_ratio",
+        native.construction.peak_contribution_count as f64
+            / native.contribution_count.max(1) as f64,
+    )?;
+    inspection.set_item("construction", construction)?;
+
+    let direct_arena = PyDict::new(py);
+    direct_arena.set_item("semantic_component_count", native.semantic_component_count)?;
+    direct_arena.set_item("current_arena_components", native.current_arena_components)?;
+    direct_arena.set_item(
+        "arena_component_reuse_count",
+        native
+            .semantic_component_count
+            .saturating_sub(u64::from(native.current_arena_components)),
+    )?;
+    direct_arena.set_item("momentum_form_count", native.momentum_form_count)?;
+    direct_arena.set_item("selector_domain_count", native.selector_domain_count)?;
+    direct_arena.set_item(
+        "cache_footprint_policy",
+        if native.strategy == RecurrenceStrategy::TopologyReplay {
+            "selector-active-max-v1"
+        } else {
+            "persisted-arena-v1"
+        },
+    )?;
+    direct_arena.set_item("row_group_count", native.row_group_count)?;
+    direct_arena.set_item("packed_input_bytes", 0)?;
+    direct_arena.set_item("packed_output_bytes", 0)?;
+    direct_arena.set_item("scatter_bytes", 0)?;
+    inspection.set_item("direct_arena", direct_arena)?;
+    if let Some(report) = native.relation_discovery.as_ref() {
+        inspection.set_item(
+            "relation_discovery",
+            relation_discovery_mapping(py, report)?,
+        )?;
+    }
+
+    let member = PyDict::new(py);
+    member.set_item("path", RECURRENCE_DIRECT_SCHEDULE_MEMBER)?;
+    member.set_item("size_bytes", native.plan_payload_size)?;
+    member.set_item("sha256", native.plan_sha256)?;
+    member.set_item("container_size_bytes", native.container_size)?;
+    inspection.set_item("runtime_container_member", member)?;
+    if let (Some(size_bytes), Some(sha256)) = (
+        native.projection_certificate_payload_size,
+        native.projection_certificate_sha256,
+    ) {
+        let certificate = PyDict::new(py);
+        certificate.set_item(
+            "path",
+            rusticol_core::recurrence::RECURRENCE_COLOR_PROJECTION_CERTIFICATE_MEMBER,
+        )?;
+        certificate.set_item("schema_version", 1)?;
+        certificate.set_item("proof_kind", "exact-rectangular-sum-projection")?;
+        certificate.set_item("publishable", true)?;
+        certificate.set_item("size_bytes", size_bytes)?;
+        certificate.set_item("sha256", sha256)?;
+        inspection.set_item("color_projection_certificate", certificate)?;
+    }
+    if let Some(certificate) = native.closure_target_domain_certificate.as_ref() {
+        let provenance = PyDict::new(py);
+        provenance.set_item("proof_kind", CLOSURE_TARGET_DOMAIN_PROOF_KIND)?;
+        provenance.set_item("semantic_digest", &certificate.semantic_digest)?;
+        provenance.set_item("sector_count", certificate.physical_sector_count)?;
+        provenance.set_item(
+            "resolved_helicity_count",
+            certificate.resolved_helicity_count,
+        )?;
+        provenance.set_item(
+            "certified_structural_zero_sector_count",
+            certificate
+                .certified_structural_zero_physical_sector_ids
+                .len(),
+        )?;
+        inspection.set_item("structural_zero_physical_sector_certificate", provenance)?;
+    }
+
+    let timings = PyDict::new(py);
+    timings.set_item(
+        "python_extraction",
+        native.timings.python_extraction_seconds,
+    )?;
+    timings.set_item(
+        "catalog_authentication",
+        native.timings.catalog_authentication_seconds,
+    )?;
+    timings.set_item(
+        "semantic_construction",
+        native.timings.semantic_construction_seconds,
+    )?;
+    timings.set_item("direct_lowering", native.timings.direct_lowering_seconds)?;
+    timings.set_item("serialization", native.timings.serialization_seconds)?;
+    timings.set_item("native_total", native.timings.native_total_seconds)?;
+    inspection.set_item("generation_timings_seconds", timings)?;
+
+    result.set_item("inspection_summary", inspection)?;
+    result.set_item("resolved_helicities", native.resolved_helicities)?;
+    result.set_item("amplitude_destinations", native.amplitude_destinations)?;
+    if let Some(certificate) = native.closure_target_domain_certificate.as_ref() {
+        let metadata = PyDict::new(py);
+        metadata.set_item("proof_kind", CLOSURE_TARGET_DOMAIN_PROOF_KIND)?;
+        metadata.set_item(
+            "sector_ids",
+            &certificate.certified_structural_zero_physical_sector_ids,
+        )?;
+        metadata.set_item("semantic_digest", &certificate.semantic_digest)?;
+        metadata.set_item("sector_count", certificate.physical_sector_count)?;
+        metadata.set_item(
+            "resolved_helicity_count",
+            certificate.resolved_helicity_count,
+        )?;
+        result.set_item("structural_zero_physical_sector_certificate", metadata)?;
+    } else {
+        result.set_item("structural_zero_physical_sector_certificate", py.None())?;
+    }
+    if let Some(dispatch) = native.helicity_dispatch.as_ref() {
+        let metadata = PyDict::new(py);
+        metadata.set_item("abi", RECURRENCE_HELICITY_DISPATCH_ABI)?;
+        metadata.set_item("size_bytes", dispatch.size_bytes)?;
+        metadata.set_item("sha256", &dispatch.sha256)?;
+        metadata.set_item(
+            "base_runtime_layout_digest",
+            &dispatch.base_runtime_layout_digest,
+        )?;
+        metadata.set_item("resolved_helicity_count", dispatch.resolved_helicity_count)?;
+        result.set_item("helicity_dispatch", metadata)?;
+    } else {
+        result.set_item("helicity_dispatch", py.None())?;
+    }
+    result.set_item(
+        "exact_sections",
+        crate::recurrence_exact_sections_to_python(py, native.exact_sections)?,
+    )?;
+    result.set_item("generation_profile", generation_profile)?;
+    Ok(result.into_any().unbind())
+}
+
+fn relation_discovery_mapping<'py>(
+    py: Python<'py>,
+    report: &RecurrenceRelationDiscoveryReport,
+) -> PyResult<Bound<'py, PyDict>> {
+    let payload = PyDict::new(py);
+    payload.set_item("schema_version", 1)?;
+    payload.set_item("requested_mode", report.requested_mode.as_str())?;
+    payload.set_item("state", report.state)?;
+
+    let scope = PyDict::new(py);
+    scope.set_item("execution_mode", "recurrence")?;
+    scope.set_item("color_accuracy", &report.color_accuracy)?;
+    scope.set_item("representation", "recurrence-direct-plan-v2")?;
+    scope.set_item("lc_flow_layout", report.strategy.as_str())?;
+    payload.set_item("scope", scope)?;
+
+    let probe = PyDict::new(py);
+    probe.set_item("status", "completed")?;
+    probe.set_item("precision_digits", report.precision_digits)?;
+    probe.set_item("probe_count", report.probe_count)?;
+    probe.set_item("verification_probe_count", report.verification_probe_count)?;
+    probe.set_item(
+        "effective_projection_count",
+        report.effective_projection_count,
+    )?;
+    probe.set_item("seed", report.seed)?;
+    probe.set_item("deterministic", true)?;
+    probe.set_item(
+        "candidate_only",
+        report.certificate_algorithm
+            != rusticol_core::recurrence::NUMERICAL_RELATION_CERTIFICATE_ALGORITHM,
+    )?;
+    probe.set_item("tested_hypothesis_count", report.tested_hypothesis_count)?;
+    probe.set_item(
+        "verification_rejected_count",
+        report.verification_rejected_count,
+    )?;
+    probe.set_item(
+        "runtime_parameter_schema_sha256",
+        report
+            .authenticated_runtime_parameter_schema_sha256
+            .as_deref(),
+    )?;
+    probe.set_item(
+        "candidate_observation_batch_sha256",
+        report
+            .authenticated_candidate_observation_batch_sha256
+            .as_deref(),
+    )?;
+    probe.set_item(
+        "verification_observation_batch_sha256",
+        report
+            .authenticated_verification_observation_batch_sha256
+            .as_deref(),
+    )?;
+    probe.set_item(
+        "decision_sha256",
+        report.authenticated_decision_sha256.as_deref(),
+    )?;
+    probe.set_item(
+        "rejection_decision_sha256",
+        &report.rejected_decision_sha256,
+    )?;
+    payload.set_item("probe", probe)?;
+
+    let replay = PyDict::new(py);
+    replay.set_item("algorithm", &report.certificate_algorithm)?;
+    replay.set_item(
+        "status",
+        if report.certificates.is_empty() {
+            "no-certified-relations"
+        } else {
+            "verified"
+        },
+    )?;
+    replay.set_item(
+        "certificate_set_sha256",
+        relation_certificate_set_sha256(report),
+    )?;
+    payload.set_item("certificate_replay", replay)?;
+    payload.set_item(
+        "numerical_candidate_count",
+        report.numerical_candidate_count,
+    )?;
+    payload.set_item(
+        "uncertified_candidate_count",
+        report.uncertified_candidate_count,
+    )?;
+    payload.set_item(
+        "rejected_hypothesis_count",
+        report.rejected_hypothesis_count,
+    )?;
+    payload.set_item(
+        "exact_certified_relation_count",
+        report.exact_certified_relation_count,
+    )?;
+    payload.set_item("applied_relation_count", report.applied_relation_count)?;
+    payload.set_item(
+        "interaction_evaluation_count_before",
+        report.interaction_evaluation_count_before,
+    )?;
+    payload.set_item(
+        "interaction_evaluation_count_after",
+        report.interaction_evaluation_count_after,
+    )?;
+    payload.set_item(
+        "interaction_evaluation_savings",
+        report
+            .interaction_evaluation_count_before
+            .saturating_sub(report.interaction_evaluation_count_after),
+    )?;
+    payload.set_item("current_count_before", report.current_count_before)?;
+    payload.set_item("current_count_after", report.current_count_after)?;
+    payload.set_item(
+        "contribution_count_before",
+        report.contribution_count_before,
+    )?;
+    payload.set_item("contribution_count_after", report.contribution_count_after)?;
+    payload.set_item("scale_copy_row_count", report.scale_copy_row_count)?;
+
+    let certificates = PyList::empty(py);
+    // Recurrence schedules can contain many exact aliases. Keep generation
+    // metadata bounded while the aggregate digest authenticates the complete
+    // replayed certificate set and the plan binds every applied scale row.
+    const CERTIFICATE_SAMPLE_LIMIT: usize = 16;
+    for certificate in report.certificates.iter().take(CERTIFICATE_SAMPLE_LIMIT) {
+        let entry = PyDict::new(py);
+        entry.set_item("algorithm", &report.certificate_algorithm)?;
+        entry.set_item("current_id", certificate.current_id)?;
+        entry.set_item("representative_id", certificate.representative_id)?;
+        let factor = PyDict::new(py);
+        factor.set_item(
+            "real_numerator",
+            certificate.factor.real().numerator().to_string(),
+        )?;
+        factor.set_item(
+            "real_denominator",
+            certificate.factor.real().denominator().to_string(),
+        )?;
+        factor.set_item(
+            "imag_numerator",
+            certificate.factor.imag().numerator().to_string(),
+        )?;
+        factor.set_item(
+            "imag_denominator",
+            certificate.factor.imag().denominator().to_string(),
+        )?;
+        entry.set_item("factor_exact_rational", factor)?;
+        entry.set_item(
+            "current_term_vector_sha256",
+            &certificate.current_expression_sha256,
+        )?;
+        entry.set_item(
+            "representative_term_vector_sha256",
+            &certificate.representative_expression_sha256,
+        )?;
+        entry.set_item("proof_sha256", &certificate.proof_sha256)?;
+        certificates.append(entry)?;
+    }
+    payload.set_item("certificates", certificates)?;
+    payload.set_item("certificate_count", report.certificates.len())?;
+    payload.set_item(
+        "certificates_truncated",
+        report.certificates.len() > CERTIFICATE_SAMPLE_LIMIT,
+    )?;
+
+    let rejected = PyList::empty(py);
+    for reason in &report.rejected_candidates {
+        let entry = PyDict::new(py);
+        entry.set_item("reason", reason)?;
+        rejected.append(entry)?;
+    }
+    payload.set_item("rejected_candidates", rejected)?;
+    let rejected_diagnostics = PyDict::new(py);
+    rejected_diagnostics.set_item(
+        "total_rejected_hypothesis_count",
+        report.rejected_hypothesis_count,
+    )?;
+    rejected_diagnostics.set_item("retained_count", report.rejected_candidates.len())?;
+    rejected_diagnostics.set_item(
+        "truncated",
+        report.rejected_hypothesis_count > report.rejected_candidates.len(),
+    )?;
+    let authenticated_raw_decisions = report.authenticated_decision_sha256.is_some();
+    if authenticated_raw_decisions && !report.rejected_candidates.is_empty() {
+        return Err(PyValueError::new_err(
+            "authenticated raw relation diagnostics must use zero retained rows",
+        ));
+    }
+    rejected_diagnostics.set_item(
+        "truncation_policy",
+        if authenticated_raw_decisions {
+            "none-authenticated-full-rejection-digest-v1"
+        } else {
+            "first-16-in-canonical-discovery-order-v1"
+        },
+    )?;
+    let retained_rows = report
+        .rejected_candidates
+        .iter()
+        .map(|reason| serde_json::json!({"reason": reason}))
+        .collect::<Vec<_>>();
+    let retained_payload = serde_json::json!({
+        "abi": "pyamplicol-rejected-relation-diagnostics-v1",
+        "rows": retained_rows,
+    });
+    let retained_bytes =
+        canonical_json_bytes(&retained_payload, "native recurrence rejected diagnostics")
+            .map_err(|error| PyValueError::new_err(error.to_string()))?;
+    rejected_diagnostics.set_item(
+        "retained_sha256",
+        hex_digest(Sha256::digest(retained_bytes)),
+    )?;
+    rejected_diagnostics.set_item(
+        "full_census_sha256",
+        hex_digest(Sha256::digest(
+            canonical_json_bytes(
+                &serde_json::json!({
+                    "abi": "pyamplicol-relation-discovery-full-census-v1",
+                    "tested_hypothesis_count": report.tested_hypothesis_count,
+                    "numerical_candidate_count": report.numerical_candidate_count,
+                    "verification_rejected_count": report.verification_rejected_count,
+                    "uncertified_candidate_count":
+                        report.uncertified_candidate_count,
+                    "certified_relation_count": report.exact_certified_relation_count,
+                    "rejected_hypothesis_count":
+                        report.rejected_hypothesis_count,
+                    "applied_relation_count": report.applied_relation_count,
+                    "runtime_parameter_schema_sha256":
+                        report.authenticated_runtime_parameter_schema_sha256,
+                    "candidate_observation_batch_sha256":
+                        report.authenticated_candidate_observation_batch_sha256,
+                    "verification_observation_batch_sha256":
+                        report.authenticated_verification_observation_batch_sha256,
+                    "decision_sha256": report.authenticated_decision_sha256,
+                    "rejection_decision_sha256":
+                        report.rejected_decision_sha256,
+                }),
+                "native recurrence relation census",
+            )
+            .map_err(|error| PyValueError::new_err(error.to_string()))?,
+        )),
+    )?;
+    rejected_diagnostics.set_item("full_rejection_sha256", &report.rejected_decision_sha256)?;
+    payload.set_item("rejected_candidate_diagnostics", rejected_diagnostics)?;
+    payload.set_item(
+        "follow_up_boundary",
+        "Direct-plan-v2 retains dense semantic current descriptors and exact closure bindings; exact certified reuse removes interaction rows and emits one scale-copy row per relation. Direct-Arena lifetime allocation continues to own physical component recycling.",
+    )?;
+    Ok(payload)
+}
+
+fn relation_certificate_set_sha256(report: &RecurrenceRelationDiscoveryReport) -> String {
+    if let Some(digest) = report.authenticated_certificate_set_sha256.as_ref() {
+        return digest.clone();
+    }
+    let mut hash = Sha256::new();
+    hash.update(b"pyamplicol-recurrence-relation-certificate-set-v1");
+    hash.update((report.certificates.len() as u64).to_le_bytes());
+    for certificate in &report.certificates {
+        hash.update(certificate.current_id.to_le_bytes());
+        hash.update(certificate.representative_id.to_le_bytes());
+        for value in [
+            certificate.factor.real().numerator(),
+            certificate.factor.real().denominator(),
+            certificate.factor.imag().numerator(),
+            certificate.factor.imag().denominator(),
+        ] {
+            let text = value.to_string();
+            hash.update((text.len() as u64).to_le_bytes());
+            hash.update(text.as_bytes());
+        }
+        hash.update(certificate.current_expression_sha256.as_bytes());
+        hash.update(certificate.representative_expression_sha256.as_bytes());
+        hash.update(certificate.proof_sha256.as_bytes());
+    }
+    format!("{:x}", hash.finalize())
+}
+
+fn parse_input(input: &Bound<'_, PyAny>) -> PyResult<OwnedInput> {
+    if cfg!(not(target_endian = "little")) {
+        return Err(PyValueError::new_err(
+            "recurrence builder input v2 requires a little-endian target",
+        ));
+    }
+    let abi = required_string(input, "abi")?;
+    if abi != RECURRENCE_BUILDER_INPUT_ABI {
+        return Err(PyValueError::new_err(format!(
+            "unsupported recurrence builder input ABI {abi:?}"
+        )));
+    }
+    let declared_digest = required_string(input, "digest")?;
+    validate_sha256_text(&declared_digest, "recurrence builder input digest")?;
+
+    let table_objects = iterable_attribute(input, "tables", "recurrence builder tables")?;
+    if table_objects.len() != TABLE_SPECS.len() {
+        return Err(PyValueError::new_err(format!(
+            "recurrence builder table inventory has {} tables, expected {}",
+            table_objects.len(),
+            TABLE_SPECS.len()
+        )));
+    }
+
+    let mut tables = Vec::with_capacity(TABLE_SPECS.len());
+    let mut table_by_name = BTreeMap::new();
+    for (table_object, spec) in table_objects.into_iter().zip(TABLE_SPECS) {
+        let table_name = required_nonempty_string(&table_object, "name", "table name")?;
+        if table_name != spec.name {
+            return Err(PyValueError::new_err(format!(
+                "recurrence builder table inventory mismatch: found {table_name:?}, expected {:?}",
+                spec.name
+            )));
+        }
+        let row_count = table_object
+            .getattr("row_count")?
+            .extract::<u64>()
+            .map_err(|_| {
+                PyTypeError::new_err(format!(
+                    "recurrence builder table {table_name:?} row_count must be u64"
+                ))
+            })?;
+        let column_objects = iterable_attribute(
+            &table_object,
+            "columns",
+            &format!("recurrence builder table {table_name:?} columns"),
+        )?;
+        if column_objects.len() != spec.columns.len() {
+            return Err(PyValueError::new_err(format!(
+                "recurrence builder table {table_name:?} has {} columns, expected {}",
+                column_objects.len(),
+                spec.columns.len()
+            )));
+        }
+
+        let mut columns = Vec::with_capacity(spec.columns.len());
+        let mut column_by_name = BTreeMap::new();
+        for (column_object, column_spec) in column_objects.into_iter().zip(spec.columns) {
+            let column_name = required_nonempty_string(&column_object, "name", "column name")?;
+            if column_name != column_spec.name {
+                return Err(PyValueError::new_err(format!(
+                    "recurrence builder table {table_name:?} column mismatch: found {column_name:?}, expected {:?}",
+                    column_spec.name
+                )));
+            }
+            let context = format!("{table_name}.{column_name}");
+            let values_object = column_object.getattr("values")?;
+            let dtype = values_object
+                .getattr("dtype")?
+                .getattr("str")?
+                .extract::<String>()?;
+            if dtype != column_spec.kind.dtype() {
+                return Err(PyValueError::new_err(format!(
+                    "{context} has dtype {dtype:?}, expected {:?}",
+                    column_spec.kind.dtype()
+                )));
+            }
+            let flags = values_object.getattr("flags")?;
+            if flags.getattr("writeable")?.extract::<bool>()? {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must be read-only"
+                )));
+            }
+            if !flags.getattr("owndata")?.extract::<bool>()? {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must own its storage"
+                )));
+            }
+            let (values, shape) = extract_owned_values(&values_object, column_spec.kind, &context)?;
+            if shape.first().copied() != Some(row_count) {
+                return Err(PyValueError::new_err(format!(
+                    "{context} first dimension does not match row_count {row_count}"
+                )));
+            }
+            let actual_tail = shape
+                .iter()
+                .skip(1)
+                .map(|value| usize::try_from(*value))
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|_| PyValueError::new_err(format!("{context} shape exceeds usize")))?;
+            if actual_tail != column_spec.tail_shape {
+                return Err(PyValueError::new_err(format!(
+                    "{context} has tail shape {actual_tail:?}, expected {:?}",
+                    column_spec.tail_shape
+                )));
+            }
+            column_by_name.insert(column_name.clone(), columns.len());
+            columns.push(OwnedColumn {
+                name: column_name,
+                dtype: column_spec.kind.dtype(),
+                shape,
+                values,
+            });
+        }
+        table_by_name.insert(table_name.clone(), tables.len());
+        tables.push(OwnedTable {
+            name: table_name,
+            row_count,
+            columns,
+            column_by_name,
+        });
+    }
+
+    let pairing_table_objects = if input.hasattr("fermion_pairing_tables")? {
+        iterable_attribute(
+            input,
+            "fermion_pairing_tables",
+            "recurrence fermion-pairing tables",
+        )?
+    } else {
+        Vec::new()
+    };
+    if !pairing_table_objects.is_empty()
+        && pairing_table_objects.len() != FERMION_PAIRING_TABLE_SPECS.len()
+    {
+        return Err(PyValueError::new_err(format!(
+            "recurrence fermion-pairing table inventory has {} tables, expected {}",
+            pairing_table_objects.len(),
+            FERMION_PAIRING_TABLE_SPECS.len()
+        )));
+    }
+    let mut fermion_pairing_tables = Vec::with_capacity(pairing_table_objects.len());
+    let mut fermion_pairing_table_by_name = BTreeMap::new();
+    for (table_object, spec) in pairing_table_objects
+        .into_iter()
+        .zip(FERMION_PAIRING_TABLE_SPECS)
+    {
+        let table_name = required_nonempty_string(&table_object, "name", "table name")?;
+        if table_name != spec.name {
+            return Err(PyValueError::new_err(format!(
+                "recurrence fermion-pairing table inventory mismatch: found {table_name:?}, expected {:?}",
+                spec.name
+            )));
+        }
+        let row_count = table_object
+            .getattr("row_count")?
+            .extract::<u64>()
+            .map_err(|_| {
+                PyTypeError::new_err(format!(
+                    "recurrence fermion-pairing table {table_name:?} row_count must be u64"
+                ))
+            })?;
+        let column_objects = iterable_attribute(
+            &table_object,
+            "columns",
+            &format!("recurrence fermion-pairing table {table_name:?} columns"),
+        )?;
+        if column_objects.len() != spec.columns.len() {
+            return Err(PyValueError::new_err(format!(
+                "recurrence fermion-pairing table {table_name:?} has {} columns, expected {}",
+                column_objects.len(),
+                spec.columns.len()
+            )));
+        }
+
+        let mut columns = Vec::with_capacity(spec.columns.len());
+        let mut column_by_name = BTreeMap::new();
+        for (column_object, column_spec) in column_objects.into_iter().zip(spec.columns) {
+            let column_name = required_nonempty_string(&column_object, "name", "column name")?;
+            if column_name != column_spec.name {
+                return Err(PyValueError::new_err(format!(
+                    "recurrence fermion-pairing table {table_name:?} column mismatch: found {column_name:?}, expected {:?}",
+                    column_spec.name
+                )));
+            }
+            let context = format!("fermion_pairing.{table_name}.{column_name}");
+            let values_object = column_object.getattr("values")?;
+            let dtype = values_object
+                .getattr("dtype")?
+                .getattr("str")?
+                .extract::<String>()?;
+            if dtype != column_spec.kind.dtype() {
+                return Err(PyValueError::new_err(format!(
+                    "{context} has dtype {dtype:?}, expected {:?}",
+                    column_spec.kind.dtype()
+                )));
+            }
+            let flags = values_object.getattr("flags")?;
+            if flags.getattr("writeable")?.extract::<bool>()? {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must be read-only"
+                )));
+            }
+            if !flags.getattr("owndata")?.extract::<bool>()? {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must own its storage"
+                )));
+            }
+            let (values, shape) = extract_owned_values(&values_object, column_spec.kind, &context)?;
+            if shape.first().copied() != Some(row_count) {
+                return Err(PyValueError::new_err(format!(
+                    "{context} first dimension does not match row_count {row_count}"
+                )));
+            }
+            let actual_tail = shape
+                .iter()
+                .skip(1)
+                .map(|value| usize::try_from(*value))
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|_| PyValueError::new_err(format!("{context} shape exceeds usize")))?;
+            if actual_tail != column_spec.tail_shape {
+                return Err(PyValueError::new_err(format!(
+                    "{context} has tail shape {actual_tail:?}, expected {:?}",
+                    column_spec.tail_shape
+                )));
+            }
+            column_by_name.insert(column_name.clone(), columns.len());
+            columns.push(OwnedColumn {
+                name: column_name,
+                dtype: column_spec.kind.dtype(),
+                shape,
+                values,
+            });
+        }
+        fermion_pairing_table_by_name.insert(table_name.clone(), fermion_pairing_tables.len());
+        fermion_pairing_tables.push(OwnedTable {
+            name: table_name,
+            row_count,
+            columns,
+            column_by_name,
+        });
+    }
+    let declared_fermion_pairing_digest = if fermion_pairing_tables.is_empty() {
+        None
+    } else {
+        if !input.hasattr("fermion_pairing_digest")? {
+            return Err(PyValueError::new_err(
+                "recurrence fermion-pairing tables require a canonical digest",
+            ));
+        }
+        let value = input.getattr("fermion_pairing_digest")?;
+        if value.is_none() {
+            return Err(PyValueError::new_err(
+                "recurrence fermion-pairing tables require a canonical digest",
+            ));
+        }
+        let digest = value.extract::<String>().map_err(|_| {
+            PyTypeError::new_err("recurrence fermion-pairing digest must be a string")
+        })?;
+        validate_sha256_text(&digest, "recurrence fermion-pairing digest")?;
+        Some(digest)
+    };
+
+    Ok(OwnedInput {
+        abi,
+        declared_digest,
+        tables,
+        table_by_name,
+        declared_fermion_pairing_digest,
+        fermion_pairing_tables,
+        fermion_pairing_table_by_name,
+    })
+}
+
+fn parse_prepared_template_input(input: &Bound<'_, PyAny>) -> PyResult<PreparedTemplateInput> {
+    if cfg!(not(target_endian = "little")) {
+        return Err(PyValueError::new_err(
+            "recurrence template input v1 requires a little-endian target",
+        ));
+    }
+    let abi = required_string(input, "abi")?;
+    if abi != template::RECURRENCE_TEMPLATE_INPUT_ABI {
+        return Err(PyValueError::new_err(format!(
+            "unsupported recurrence template input ABI {abi:?}"
+        )));
+    }
+    let declared_digest = required_string(input, "digest")?;
+    validate_sha256_text(&declared_digest, "recurrence template input digest")?;
+    let canonical_digest_property = required_string(input, "canonical_digest")?;
+    validate_sha256_text(
+        &canonical_digest_property,
+        "recurrence template canonical digest",
+    )?;
+    let catalog_digest = semantic_digest_python_attribute(input, "catalog_digest")?;
+    let compiled_model_digest = semantic_digest_python_attribute(input, "compiled_model_digest")?;
+    let prepared_kernel_pack_digest =
+        semantic_digest_python_attribute(input, "prepared_kernel_pack_digest")?;
+
+    let table_objects = iterable_attribute(input, "tables", "recurrence template tables")?;
+    if table_objects.len() != TEMPLATE_TABLE_INVENTORY.len() {
+        return Err(PyValueError::new_err(format!(
+            "recurrence template table inventory has {} tables, expected {}",
+            table_objects.len(),
+            TEMPLATE_TABLE_INVENTORY.len()
+        )));
+    }
+
+    let mut tables = Vec::with_capacity(TEMPLATE_TABLE_INVENTORY.len());
+    let mut table_by_name = BTreeMap::new();
+    for (table_object, (expected_name, expected_column_count)) in
+        table_objects.into_iter().zip(TEMPLATE_TABLE_INVENTORY)
+    {
+        let table_name = required_nonempty_string(&table_object, "name", "table name")?;
+        if table_name != *expected_name {
+            return Err(PyValueError::new_err(format!(
+                "recurrence template table inventory mismatch: found {table_name:?}, expected {expected_name:?}"
+            )));
+        }
+        let row_count = table_object
+            .getattr("row_count")?
+            .extract::<u64>()
+            .map_err(|_| {
+                PyTypeError::new_err(format!(
+                    "recurrence template table {table_name:?} row_count must be u64"
+                ))
+            })?;
+        let column_objects = iterable_attribute(
+            &table_object,
+            "columns",
+            &format!("recurrence template table {table_name:?} columns"),
+        )?;
+        if column_objects.len() != *expected_column_count {
+            return Err(PyValueError::new_err(format!(
+                "recurrence template table {table_name:?} has {} columns, expected {expected_column_count}",
+                column_objects.len()
+            )));
+        }
+
+        let mut columns = Vec::with_capacity(*expected_column_count);
+        let mut column_by_name = BTreeMap::new();
+        for column_object in column_objects {
+            let column_name = required_nonempty_string(&column_object, "name", "column name")?;
+            if column_by_name.contains_key(&column_name) {
+                return Err(PyValueError::new_err(format!(
+                    "recurrence template table {table_name:?} repeats column {column_name:?}"
+                )));
+            }
+            let context = format!("{table_name}.{column_name}");
+            let values_object = column_object.getattr("values")?;
+            let dtype = values_object
+                .getattr("dtype")?
+                .getattr("str")?
+                .extract::<String>()?;
+            let kind = PrimitiveKind::from_dtype(&dtype).ok_or_else(|| {
+                PyValueError::new_err(format!(
+                    "{context} has unsupported recurrence-template dtype {dtype:?}"
+                ))
+            })?;
+            let flags = values_object.getattr("flags")?;
+            if flags.getattr("writeable")?.extract::<bool>()? {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must be read-only"
+                )));
+            }
+            if !flags.getattr("owndata")?.extract::<bool>()? {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must own its storage"
+                )));
+            }
+            let (values, shape) = extract_owned_values(&values_object, kind, &context)?;
+            if shape.first().copied() != Some(row_count) {
+                return Err(PyValueError::new_err(format!(
+                    "{context} first dimension does not match row_count {row_count}"
+                )));
+            }
+            column_by_name.insert(column_name.clone(), columns.len());
+            columns.push(OwnedColumn {
+                name: column_name,
+                dtype: kind.dtype(),
+                shape,
+                values,
+            });
+        }
+        table_by_name.insert(table_name.clone(), tables.len());
+        tables.push(OwnedTable {
+            name: table_name,
+            row_count,
+            columns,
+            column_by_name,
+        });
+    }
+
+    Ok(PreparedTemplateInput {
+        input: OwnedInput {
+            abi,
+            declared_digest,
+            tables,
+            table_by_name,
+            declared_fermion_pairing_digest: None,
+            fermion_pairing_tables: Vec::new(),
+            fermion_pairing_table_by_name: BTreeMap::new(),
+        },
+        canonical_digest_property,
+        catalog_digest,
+        compiled_model_digest,
+        prepared_kernel_pack_digest,
+    })
+}
+
+fn extract_owned_values(
+    value: &Bound<'_, PyAny>,
+    kind: PrimitiveKind,
+    context: &str,
+) -> PyResult<(OwnedValues, Vec<u64>)> {
+    macro_rules! extract {
+        ($ty:ty, $variant:ident) => {{
+            let array = value
+                .extract::<PyReadonlyArrayDyn<'_, $ty>>()
+                .map_err(|_| {
+                    PyTypeError::new_err(format!(
+                        "{context} is not a NumPy array with dtype {:?}",
+                        kind.dtype()
+                    ))
+                })?;
+            if !array.is_c_contiguous() {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must be C-contiguous"
+                )));
+            }
+            let shape = array
+                .shape()
+                .iter()
+                .map(|value| {
+                    u64::try_from(*value)
+                        .map_err(|_| PyValueError::new_err(format!("{context} shape exceeds u64")))
+                })
+                .collect::<PyResult<Vec<_>>>()?;
+            let values = array
+                .as_slice()
+                .map_err(|error| {
+                    PyValueError::new_err(format!("{context} must be contiguous: {error}"))
+                })?
+                .to_vec();
+            (OwnedValues::$variant(values), shape)
+        }};
+    }
+    Ok(match kind {
+        PrimitiveKind::U8 => extract!(u8, U8),
+        PrimitiveKind::U32 => extract!(u32, U32),
+        PrimitiveKind::U64 => extract!(u64, U64),
+        PrimitiveKind::I32 => extract!(i32, I32),
+    })
+}
+
+fn decode_process_input(
+    input: &OwnedInput,
+) -> RusticolResult<process::OwnedRecurrenceProcessInput> {
+    let fermion_pairing = decode_fermion_pairing_input(input)?;
+    let bitset_ranges = decode_process_rows(input, "bitset_ranges", |row| {
+        Ok(process::ProcessBitsetRangeRow {
+            id: input.u32("bitset_ranges", "id")?[row],
+            range: CheckedTableRange {
+                start: input.u64("bitset_ranges", "start")?[row],
+                count: input.u64("bitset_ranges", "count")?[row],
+            },
+            bit_count: input.u64("bitset_ranges", "bit_count")?[row],
+        })
+    })?;
+    let coupling_limits = decode_process_rows(input, "coupling_limits", |row| {
+        Ok(process::ProcessCouplingLimitRow {
+            name_string_id: input.u32("coupling_limits", "name_string_id")?[row],
+            minimum: input.u32("coupling_limits", "minimum")?[row],
+            maximum: input.u32("coupling_limits", "maximum")?[row],
+        })
+    })?;
+    let digest_values = input.u8("digest_catalog", "value")?;
+    let digest_catalog = decode_process_rows(input, "digest_catalog", |row| {
+        let start = row
+            .checked_mul(32)
+            .ok_or_else(|| invalid("process digest catalog offset exceeds usize"))?;
+        let value = digest_values
+            .get(start..start + 32)
+            .ok_or_else(|| invalid("process digest catalog row is truncated"))?
+            .try_into()
+            .map_err(|_| invalid("process digest catalog row must contain 32 bytes"))?;
+        Ok(process::ProcessDigestCatalogRow {
+            id: input.u32("digest_catalog", "id")?[row],
+            value,
+        })
+    })?;
+    let exact_factors = decode_process_rows(input, "exact_factors", |row| {
+        Ok(process::ProcessExactFactorRow {
+            id: input.u32("exact_factors", "id")?[row],
+            real_numerator_string_id: input.u32("exact_factors", "real_numerator_string_id")?[row],
+            real_denominator_string_id: input.u32("exact_factors", "real_denominator_string_id")?
+                [row],
+            imag_numerator_string_id: input.u32("exact_factors", "imag_numerator_string_id")?[row],
+            imag_denominator_string_id: input.u32("exact_factors", "imag_denominator_string_id")?
+                [row],
+        })
+    })?;
+    let external_legs = decode_process_rows(input, "external_legs", |row| {
+        Ok(process::ProcessExternalLegRow {
+            source_slot: input.u32("external_legs", "source_slot")?[row],
+            public_label: input.u32("external_legs", "public_label")?[row],
+            physical_pdg: input.i32("external_legs", "physical_pdg")?[row],
+            outgoing_pdg: input.i32("external_legs", "outgoing_pdg")?[row],
+            is_initial: input.u8("external_legs", "is_initial")?[row],
+            is_fermionic: input.u8("external_legs", "is_fermionic")?[row],
+            source_state_range: CheckedTableRange {
+                start: input.u64("external_legs", "source_state_start")?[row],
+                count: input.u64("external_legs", "source_state_count")?[row],
+            },
+            momentum_mask_id: input.u32("external_legs", "momentum_mask_id")?[row],
+            support_mask_id: input.u32("external_legs", "support_mask_id")?[row],
+        })
+    })?;
+    let header = decode_process_rows(input, "header", |row| {
+        Ok(process::ProcessHeaderRow {
+            schema_version: input.u32("header", "schema_version")?[row],
+            abi_string_id: input.u32("header", "abi_string_id")?[row],
+            process_id_string_id: input.u32("header", "process_id_string_id")?[row],
+            layout: input.u8("header", "layout")?[row],
+            selected_flow_mode: input.u8("header", "selected_flow_mode")?[row],
+            selected_source_mode: input.u8("header", "selected_source_mode")?[row],
+            external_leg_count: input.u32("header", "external_leg_count")?[row],
+            physical_sector_count: input.u32("header", "physical_sector_count")?[row],
+            public_flow_count: input.u32("header", "public_flow_count")?[row],
+            replay_partition_count: input.u32("header", "replay_partition_count")?[row],
+            coupling_limit_count: input.u32("header", "coupling_limit_count")?[row],
+            parameter_projection_count: input.u32("header", "parameter_projection_count")?[row],
+            process_support_mask_id: input.u32("header", "process_support_mask_id")?[row],
+        })
+    })?;
+    let header_digests = decode_process_rows(input, "header_digests", |row| {
+        Ok(process::ProcessHeaderDigestRow {
+            role_string_id: input.u32("header_digests", "role_string_id")?[row],
+            digest_id: input.u32("header_digests", "digest_id")?[row],
+        })
+    })?;
+    let lc_open_strings = decode_process_rows(input, "lc_open_strings", |row| {
+        Ok(process::ProcessLCOpenStringRow {
+            sector_id: input.u32("lc_open_strings", "sector_id")?[row],
+            ordinal: input.u32("lc_open_strings", "ordinal")?[row],
+            fundamental_source_slot: input.u32("lc_open_strings", "fundamental_source_slot")?[row],
+            antifundamental_source_slot: input
+                .u32("lc_open_strings", "antifundamental_source_slot")?[row],
+            adjoint_sequence_id: input.u32("lc_open_strings", "adjoint_sequence_id")?[row],
+            singlet_sequence_id: input.u32("lc_open_strings", "singlet_sequence_id")?[row],
+        })
+    })?;
+    let normalization = decode_process_rows(input, "normalization", |row| {
+        Ok(process::ProcessNormalizationRow {
+            factor_id: input.u32("normalization", "factor_id")?[row],
+            convention_string_id: input.u32("normalization", "convention_string_id")?[row],
+            semantic_digest_id: input.u32("normalization", "semantic_digest_id")?[row],
+        })
+    })?;
+    let parameter_projection = decode_process_rows(input, "parameter_projection", |row| {
+        Ok(process::ProcessParameterProjectionRow {
+            runtime_slot: input.u32("parameter_projection", "runtime_slot")?[row],
+            runtime_name_string_id: input.u32("parameter_projection", "runtime_name_string_id")?
+                [row],
+            parameter_template_id: input.u32("parameter_projection", "parameter_template_id")?[row],
+            prepared_parameter_id: input.u32("parameter_projection", "prepared_parameter_id")?[row],
+            component: input.u32("parameter_projection", "component")?[row],
+        })
+    })?;
+    let physical_lc_sectors = decode_process_rows(input, "physical_lc_sectors", |row| {
+        Ok(process::ProcessPhysicalLCSectorRow {
+            sector_id: input.u32("physical_lc_sectors", "sector_id")?[row],
+            public_id_string_id: input.u32("physical_lc_sectors", "public_id_string_id")?[row],
+            kind: input.u8("physical_lc_sectors", "kind")?[row],
+            closure_source_slot: input.u32("physical_lc_sectors", "closure_source_slot")?[row],
+            closure_proof_algorithm_string_id: input
+                .u32("physical_lc_sectors", "closure_proof_algorithm_string_id")?[row],
+            closure_proof_digest_id: input.u32("physical_lc_sectors", "closure_proof_digest_id")?
+                [row],
+            open_string_range: CheckedTableRange {
+                start: input.u64("physical_lc_sectors", "open_string_start")?[row],
+                count: input.u64("physical_lc_sectors", "open_string_count")?[row],
+            },
+            trace_sequence_id: input.u32("physical_lc_sectors", "trace_sequence_id")?[row],
+            singlet_sequence_id: input.u32("physical_lc_sectors", "singlet_sequence_id")?[row],
+            word_sequence_id: input.u32("physical_lc_sectors", "word_sequence_id")?[row],
+            support_mask_id: input.u32("physical_lc_sectors", "support_mask_id")?[row],
+        })
+    })?;
+    let public_lc_flows = decode_process_rows(input, "public_lc_flows", |row| {
+        Ok(process::ProcessPublicLCFlowRow {
+            flow_id: input.u32("public_lc_flows", "flow_id")?[row],
+            public_id_string_id: input.u32("public_lc_flows", "public_id_string_id")?[row],
+            construction_sector_id: input.u32("public_lc_flows", "construction_sector_id")?[row],
+            word_sequence_id: input.u32("public_lc_flows", "word_sequence_id")?[row],
+            source_slot_permutation_sequence_id: input
+                .u32("public_lc_flows", "source_slot_permutation_sequence_id")?[row],
+            reduction_weight_factor_id: input
+                .u32("public_lc_flows", "reduction_weight_factor_id")?[row],
+        })
+    })?;
+    let replay_partitions = decode_process_rows(input, "replay_partitions", |row| {
+        Ok(process::ProcessReplayPartitionRow {
+            partition_id: input.u32("replay_partitions", "partition_id")?[row],
+            representative_sector_id: input.u32("replay_partitions", "representative_sector_id")?
+                [row],
+            materialized_sector_id: input.u32("replay_partitions", "materialized_sector_id")?[row],
+            target_range: CheckedTableRange {
+                start: input.u64("replay_partitions", "target_start")?[row],
+                count: input.u64("replay_partitions", "target_count")?[row],
+            },
+            proof_algorithm_string_id: input
+                .u32("replay_partitions", "proof_algorithm_string_id")?[row],
+            proof_digest_id: input.u32("replay_partitions", "proof_digest_id")?[row],
+        })
+    })?;
+    let replay_targets = decode_process_rows(input, "replay_targets", |row| {
+        Ok(process::ProcessReplayTargetRow {
+            partition_id: input.u32("replay_targets", "partition_id")?[row],
+            sector_id: input.u32("replay_targets", "sector_id")?[row],
+            external_permutation_sequence_id: input
+                .u32("replay_targets", "external_permutation_sequence_id")?[row],
+            source_slot_permutation_sequence_id: input
+                .u32("replay_targets", "source_slot_permutation_sequence_id")?[row],
+            amplitude_phase_factor_id: input.u32("replay_targets", "amplitude_phase_factor_id")?
+                [row],
+            fermion_sign: input.i32("replay_targets", "fermion_sign")?[row],
+        })
+    })?;
+    let selected_public_flow_coverage =
+        decode_process_rows(input, "selected_public_flow_coverage", |row| {
+            Ok(process::ProcessSelectedPublicFlowRow {
+                flow_id: input.u32("selected_public_flow_coverage", "flow_id")?[row],
+            })
+        })?;
+    let selected_source_coverage = decode_process_rows(input, "selected_source_coverage", |row| {
+        Ok(process::ProcessSelectedSourceStateRow {
+            source_slot: input.u32("selected_source_coverage", "source_slot")?[row],
+            source_state_index: input.u32("selected_source_coverage", "source_state_index")?[row],
+        })
+    })?;
+    let semantic_template_references =
+        decode_process_rows(input, "semantic_template_references", |row| {
+            Ok(process::ProcessSemanticTemplateReferenceRow {
+                kind_string_id: input.u32("semantic_template_references", "kind_string_id")?[row],
+                template_id: input.u32("semantic_template_references", "template_id")?[row],
+                semantic_digest_id: input
+                    .u32("semantic_template_references", "semantic_digest_id")?[row],
+                prepared_kernel_id: input
+                    .u32("semantic_template_references", "prepared_kernel_id")?[row],
+            })
+        })?;
+    let source_states = decode_process_rows(input, "source_states", |row| {
+        Ok(process::ProcessSourceStateRow {
+            source_slot: input.u32("source_states", "source_slot")?[row],
+            state_index: input.u32("source_states", "state_index")?[row],
+            public_helicity: input.i32("source_states", "public_helicity")?[row],
+            chirality: input.i32("source_states", "chirality")?[row],
+            spin_state: input.i32("source_states", "spin_state")?[row],
+            current_state_template_id: input.u32("source_states", "current_state_template_id")?
+                [row],
+            source_template_id: input.u32("source_states", "source_template_id")?[row],
+            momentum_sign: input.i32("source_states", "momentum_sign")?[row],
+            crossing_phase_factor_id: input.u32("source_states", "crossing_phase_factor_id")?[row],
+        })
+    })?;
+
+    Ok(process::OwnedRecurrenceProcessInput {
+        input_abi: input.abi.clone(),
+        declared_input_digest: semantic_digest_from_hex(
+            &input.declared_digest,
+            "recurrence process input digest",
+        )?,
+        fermion_pairing,
+        bitset_ranges,
+        bitset_words: input.u64("bitset_words", "value")?.to_vec(),
+        coupling_limits,
+        digest_catalog,
+        exact_factors,
+        external_legs,
+        header,
+        header_digests,
+        lc_open_strings,
+        normalization,
+        parameter_projection,
+        physical_lc_sectors,
+        public_lc_flows,
+        replay_partitions,
+        replay_targets,
+        selected_public_flow_coverage,
+        selected_source_coverage,
+        semantic_template_references,
+        source_states,
+        string_ranges: plain_ranges(input, "string_ranges")?,
+        string_bytes: input.u8("string_bytes", "value")?.to_vec(),
+        u32_sequence_ranges: plain_ranges(input, "u32_sequence_ranges")?,
+        u32_sequence_values: input.u32("u32_sequence_values", "value")?.to_vec(),
+    })
+}
+
+fn decode_fermion_pairing_input(
+    input: &OwnedInput,
+) -> RusticolResult<Option<process::OwnedFermionPairingInput>> {
+    let Some(declared_digest) = input.declared_fermion_pairing_digest.as_deref() else {
+        if !input.fermion_pairing_tables.is_empty() {
+            return Err(invalid(
+                "recurrence fermion-pairing tables have no declared digest",
+            ));
+        }
+        return Ok(None);
+    };
+    if input.fermion_pairing_tables.is_empty() {
+        return Err(invalid(
+            "recurrence fermion-pairing digest has no fixed-width tables",
+        ));
+    }
+
+    let header = decode_pairing_rows(input, "header", |row| {
+        Ok(process::FermionPairingHeaderRow {
+            schema_version: input.pairing_u32("header", "schema_version")?[row],
+            abi_string_id: input.pairing_u32("header", "abi_string_id")?[row],
+            process_key_string_id: input.pairing_u32("header", "process_key_string_id")?[row],
+            proof_algorithm_string_id: input.pairing_u32("header", "proof_algorithm_string_id")?
+                [row],
+            source_count: input.pairing_u32("header", "source_count")?[row],
+            endpoint_count: input.pairing_u32("header", "endpoint_count")?[row],
+            pairing_class_count: input.pairing_u32("header", "pairing_class_count")?[row],
+            rule_count: input.pairing_u32("header", "rule_count")?[row],
+            endpoint_state_template_count: input
+                .pairing_u64("header", "endpoint_state_template_count")?[row],
+            endpoint_anti_state_template_count: input
+                .pairing_u64("header", "endpoint_anti_state_template_count")?[row],
+            endpoint_basis_count: input.pairing_u64("header", "endpoint_basis_count")?[row],
+            endpoint_color_representation_count: input
+                .pairing_u64("header", "endpoint_color_representation_count")?[row],
+            class_fundamental_slot_count: input
+                .pairing_u64("header", "class_fundamental_slot_count")?[row],
+            class_antifundamental_slot_count: input
+                .pairing_u64("header", "class_antifundamental_slot_count")?[row],
+            class_reference_pairing_count: input
+                .pairing_u64("header", "class_reference_pairing_count")?[row],
+            rule_class_pairing_index_count: input
+                .pairing_u64("header", "rule_class_pairing_index_count")?[row],
+            rule_endpoint_pairing_count: input
+                .pairing_u64("header", "rule_endpoint_pairing_count")?[row],
+            rule_source_permutation_count: input
+                .pairing_u64("header", "rule_source_permutation_count")?[row],
+            rule_lineage_count: input.pairing_u64("header", "rule_lineage_count")?[row],
+            exact_integer_count: input.pairing_u32("header", "exact_integer_count")?[row],
+            exact_integer_limb_count: input.pairing_u64("header", "exact_integer_limb_count")?[row],
+            string_count: input.pairing_u32("header", "string_count")?[row],
+            string_byte_count: input.pairing_u64("header", "string_byte_count")?[row],
+            no_fermion_line: input.pairing_u32("header", "no_fermion_line")?[row],
+            topology_digest: pairing_digest_row(input, "header", "topology_digest", row)?,
+            semantic_digest: pairing_digest_row(input, "header", "semantic_digest", row)?,
+        })
+    })?;
+    let endpoints = decode_pairing_rows(input, "endpoints", |row| {
+        Ok(process::FermionPairingEndpointRow {
+            endpoint_id: input.pairing_u32("endpoints", "endpoint_id")?[row],
+            source_slot: input.pairing_u32("endpoints", "source_slot")?[row],
+            public_label: input.pairing_u32("endpoints", "public_label")?[row],
+            species_class_id: input.pairing_u32("endpoints", "species_class_id")?[row],
+            species_string_id: input.pairing_u32("endpoints", "species_string_id")?[row],
+            particle_orientation: input.pairing_u8("endpoints", "particle_orientation")?[row],
+            color_orientation: input.pairing_u8("endpoints", "color_orientation")?[row],
+            state_template_range: pairing_range(input, "endpoints", "state_template", row)?,
+            anti_state_template_range: pairing_range(
+                input,
+                "endpoints",
+                "anti_state_template",
+                row,
+            )?,
+            basis_range: pairing_range(input, "endpoints", "basis", row)?,
+            color_representation_range: pairing_range(
+                input,
+                "endpoints",
+                "color_representation",
+                row,
+            )?,
+            contract_digest: pairing_digest_row(input, "endpoints", "contract_digest", row)?,
+        })
+    })?;
+    let pairing_classes = decode_pairing_rows(input, "pairing_classes", |row| {
+        Ok(process::FermionPairingClassRow {
+            class_id: input.pairing_u32("pairing_classes", "class_id")?[row],
+            species_class_id: input.pairing_u32("pairing_classes", "species_class_id")?[row],
+            species_string_id: input.pairing_u32("pairing_classes", "species_string_id")?[row],
+            fundamental_slot_range: pairing_range(
+                input,
+                "pairing_classes",
+                "fundamental_slot",
+                row,
+            )?,
+            antifundamental_slot_range: pairing_range(
+                input,
+                "pairing_classes",
+                "antifundamental_slot",
+                row,
+            )?,
+            reference_pairing_range: pairing_range(
+                input,
+                "pairing_classes",
+                "reference_pairing",
+                row,
+            )?,
+            pairing_count: input.pairing_u64("pairing_classes", "pairing_count")?[row],
+            proof_digest: pairing_digest_row(input, "pairing_classes", "proof_digest", row)?,
+        })
+    })?;
+    let rules = decode_pairing_rows(input, "rules", |row| {
+        Ok(process::FermionPairingRuleRow {
+            rule_id: input.pairing_u32("rules", "rule_id")?[row],
+            class_pairing_index_range: pairing_range(input, "rules", "class_pairing_index", row)?,
+            endpoint_pairing_range: pairing_range(input, "rules", "endpoint_pairing", row)?,
+            source_permutation_range: pairing_range(input, "rules", "source_permutation", row)?,
+            lineage_range: pairing_range(input, "rules", "lineage", row)?,
+            fermion_parity: input.pairing_i32("rules", "fermion_parity")?[row],
+            real_numerator_integer_id: input.pairing_u32("rules", "real_numerator_integer_id")?
+                [row],
+            real_denominator_integer_id: input
+                .pairing_u32("rules", "real_denominator_integer_id")?[row],
+            imag_numerator_integer_id: input.pairing_u32("rules", "imag_numerator_integer_id")?
+                [row],
+            imag_denominator_integer_id: input
+                .pairing_u32("rules", "imag_denominator_integer_id")?[row],
+            multiplicity: input.pairing_u64("rules", "multiplicity")?[row],
+            proof_algorithm_string_id: input.pairing_u32("rules", "proof_algorithm_string_id")?
+                [row],
+            proof_digest: pairing_digest_row(input, "rules", "proof_digest", row)?,
+        })
+    })?;
+    let rule_class_pairing_indices =
+        decode_pairing_rows(input, "rule_class_pairing_indices", |row| {
+            Ok(process::FermionPairingClassPairingIndexRow {
+                class_id: input.pairing_u32("rule_class_pairing_indices", "class_id")?[row],
+                pairing_index: input.pairing_u64("rule_class_pairing_indices", "pairing_index")?
+                    [row],
+            })
+        })?;
+    let decode_pairs = |table_name: &str| {
+        decode_pairing_rows(input, table_name, |row| {
+            Ok(process::FermionPairingEndpointPairRow {
+                fundamental_source_slot: input
+                    .pairing_u32(table_name, "fundamental_source_slot")?[row],
+                antifundamental_source_slot: input
+                    .pairing_u32(table_name, "antifundamental_source_slot")?[row],
+            })
+        })
+    };
+    let exact_integers = decode_pairing_rows(input, "exact_integers", |row| {
+        Ok(process::FermionPairingExactIntegerRow {
+            integer_id: input.pairing_u32("exact_integers", "integer_id")?[row],
+            sign: input.pairing_i32("exact_integers", "sign")?[row],
+            limb_range: pairing_range(input, "exact_integers", "limb", row)?,
+        })
+    })?;
+
+    Ok(Some(process::OwnedFermionPairingInput {
+        input_abi: process::RECURRENCE_FERMION_PAIRING_COLUMNAR_ABI.to_owned(),
+        declared_columnar_digest: semantic_digest_from_hex(
+            declared_digest,
+            "recurrence fermion-pairing digest",
+        )?,
+        header,
+        endpoints,
+        endpoint_state_template_ids: input
+            .pairing_u32("endpoint_state_template_ids", "string_id")?
+            .to_vec(),
+        endpoint_anti_state_template_ids: input
+            .pairing_u32("endpoint_anti_state_template_ids", "string_id")?
+            .to_vec(),
+        endpoint_basis_ids: input
+            .pairing_u32("endpoint_basis_ids", "string_id")?
+            .to_vec(),
+        endpoint_color_representations: input
+            .pairing_i32("endpoint_color_representations", "value")?
+            .to_vec(),
+        pairing_classes,
+        class_fundamental_slots: input
+            .pairing_u32("class_fundamental_slots", "source_slot")?
+            .to_vec(),
+        class_antifundamental_slots: input
+            .pairing_u32("class_antifundamental_slots", "source_slot")?
+            .to_vec(),
+        class_reference_pairings: decode_pairs("class_reference_pairings")?,
+        rules,
+        rule_class_pairing_indices,
+        rule_endpoint_pairings: decode_pairs("rule_endpoint_pairings")?,
+        rule_source_slot_permutations: input
+            .pairing_u32("rule_source_slot_permutations", "source_slot")?
+            .to_vec(),
+        rule_lineages: input.pairing_u32("rule_lineages", "line_id")?.to_vec(),
+        exact_integers,
+        exact_integer_limbs: input.pairing_u64("exact_integer_limbs", "value")?.to_vec(),
+        string_ranges: pairing_plain_ranges(input, "string_ranges")?,
+        string_bytes: input.pairing_u8("string_bytes", "value")?.to_vec(),
+    }))
+}
+
+fn decode_pairing_rows<T>(
+    input: &OwnedInput,
+    table_name: &str,
+    mut decode: impl FnMut(usize) -> RusticolResult<T>,
+) -> RusticolResult<Vec<T>> {
+    let row_count = checked_usize(
+        input.fermion_pairing_table(table_name)?.row_count,
+        &format!("fermion-pairing {table_name} row count"),
+    )?;
+    (0..row_count).map(&mut decode).collect()
+}
+
+fn pairing_range(
+    input: &OwnedInput,
+    table_name: &str,
+    prefix: &str,
+    row: usize,
+) -> RusticolResult<CheckedTableRange> {
+    Ok(CheckedTableRange {
+        start: input.pairing_u64(table_name, &format!("{prefix}_start"))?[row],
+        count: input.pairing_u64(table_name, &format!("{prefix}_count"))?[row],
+    })
+}
+
+fn pairing_plain_ranges(
+    input: &OwnedInput,
+    table_name: &str,
+) -> RusticolResult<Vec<CheckedTableRange>> {
+    decode_pairing_rows(input, table_name, |row| {
+        Ok(CheckedTableRange {
+            start: input.pairing_u64(table_name, "start")?[row],
+            count: input.pairing_u64(table_name, "count")?[row],
+        })
+    })
+}
+
+fn pairing_digest_row(
+    input: &OwnedInput,
+    table_name: &str,
+    column_name: &str,
+    row: usize,
+) -> RusticolResult<[u8; 32]> {
+    let values = input.pairing_u8(table_name, column_name)?;
+    let start = row
+        .checked_mul(32)
+        .ok_or_else(|| invalid("fermion-pairing digest offset exceeds usize"))?;
+    values
+        .get(start..start + 32)
+        .ok_or_else(|| invalid("fermion-pairing digest row is truncated"))?
+        .try_into()
+        .map_err(|_| invalid("fermion-pairing digest row must contain 32 bytes"))
+}
+
+fn decode_process_rows<T>(
+    input: &OwnedInput,
+    table_name: &str,
+    mut decode: impl FnMut(usize) -> RusticolResult<T>,
+) -> RusticolResult<Vec<T>> {
+    let row_count = checked_usize(
+        input.table(table_name)?.row_count,
+        &format!("{table_name} row count"),
+    )?;
+    (0..row_count).map(&mut decode).collect()
+}
+
+fn plain_ranges(input: &OwnedInput, table_name: &str) -> RusticolResult<Vec<CheckedTableRange>> {
+    decode_process_rows(input, table_name, |row| {
+        Ok(CheckedTableRange {
+            start: input.u64(table_name, "start")?[row],
+            count: input.u64(table_name, "count")?[row],
+        })
+    })
+}
+
+fn decode_template_input(
+    input: &OwnedInput,
+    catalog_digest: SemanticDigest,
+    compiled_model_digest: SemanticDigest,
+    prepared_kernel_pack_digest: SemanticDigest,
+) -> RusticolResult<template::OwnedRecurrenceTemplateInput> {
+    use template::{
+        CatalogHeaderRow, ClosureRow, ColorContractionRow, ColorNcTermRow,
+        ContactOrbitCertificateRow, ContactOrbitStepRow, CouplingOrderTermRow, CurrentStateRow,
+        EvaluatorBindingRow, ExactFactorRow, LCColorTransitionWitnessRow,
+        OwnedRecurrenceTemplateInput, ParameterRow, PropagatorRow, QuantumFlowRow,
+        QuantumNumberFlowTermRow, RuntimeHelicityContractRow, RuntimeHelicityEmbeddingRow,
+        RuntimeHelicityProjectionRow, RuntimeHelicityVariantRow, SourceRow, SymmetryProofRow,
+        TransitionRow,
+    };
+    let catalog_header = decode_template_rows(input.table("catalog_header")?, |table, row| {
+        Ok(CatalogHeaderRow {
+            schema_version: table.u32("schema_version")?[row],
+            abi_string_id: table.u32("abi_string_id")?[row],
+            canonicalization_abi_string_id: table.u32("canonicalization_abi_string_id")?[row],
+            exact_scalar_abi_string_id: table.u32("exact_scalar_abi_string_id")?[row],
+            compiled_model_digest_id: table.u32("compiled_model_digest_id")?[row],
+            prepared_kernel_pack_digest_id: table.u32("prepared_kernel_pack_digest_id")?[row],
+            catalog_digest_id: table.u32("catalog_digest_id")?[row],
+            parameter_count: table.u32("parameter_count")?[row],
+            current_state_count: table.u32("current_state_count")?[row],
+            source_count: table.u32("source_count")?[row],
+            quantum_flow_count: table.u32("quantum_flow_count")?[row],
+            contact_orbit_certificate_count: table.u32("contact_orbit_certificate_count")?[row],
+            contact_orbit_step_count: table.u32("contact_orbit_step_count")?[row],
+            transition_count: table.u32("transition_count")?[row],
+            propagator_count: table.u32("propagator_count")?[row],
+            closure_count: table.u32("closure_count")?[row],
+            color_contraction_count: table.u32("color_contraction_count")?[row],
+            symmetry_proof_count: table.u32("symmetry_proof_count")?[row],
+            runtime_helicity_contract_count: table.u32("runtime_helicity_contract_count")?[row],
+            evaluator_binding_count: table.u32("evaluator_binding_count")?[row],
+        })
+    })?;
+    let coupling_order_ranges = template_indexed_ranges(input.table("coupling_order_ranges")?)?;
+    let coupling_order_terms =
+        decode_template_rows(input.table("coupling_order_terms")?, |table, row| {
+            Ok(CouplingOrderTermRow {
+                set_id: table.u32("set_id")?[row],
+                name_string_id: table.u32("name_string_id")?[row],
+                power: table.u32("power")?[row],
+            })
+        })?;
+    let contact_orbit_certificates =
+        decode_template_rows(input.table("contact_orbit_certificates")?, |table, row| {
+            Ok(ContactOrbitCertificateRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                algorithm_string_id: table.u32("algorithm_string_id")?[row],
+                algorithm_version: table.u32("algorithm_version")?[row],
+                term_id: table.u32("term_id")?[row],
+                vertex_string_id: table.u32("vertex_string_id")?[row],
+                particle_string_sequence_id: table.u32("particle_string_sequence_id")?[row],
+                evaluator_class_string_id: table.u32("evaluator_class_string_id")?[row],
+                physical_leg_equivalence_sequence_id: table
+                    .u32("physical_leg_equivalence_sequence_id")?[row],
+                reconstruction_factor_id: table.u32("reconstruction_factor_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+    let contact_orbit_steps =
+        decode_template_rows(input.table("contact_orbit_steps")?, |table, row| {
+            Ok(ContactOrbitStepRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                certificate_id: table.u32("certificate_id")?[row],
+                stage: table.u8("stage")?[row],
+                result_leg: table.u8("result_leg")?[row],
+                left_covered_leg_sequence_id: table.u32("left_covered_leg_sequence_id")?[row],
+                right_covered_leg_sequence_id: table.u32("right_covered_leg_sequence_id")?[row],
+                source_particle_leg_sequence_id: table.u32("source_particle_leg_sequence_id")?[row],
+                reconstruction_factor_id: table.u32("reconstruction_factor_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+    let current_states = decode_template_rows(input.table("current_states")?, |table, row| {
+        Ok(CurrentStateRow {
+            id: table.u32("id")?[row],
+            template_string_id: table.u32("template_string_id")?[row],
+            particle_id: table.i32("particle_id")?[row],
+            anti_particle_id: table.i32("anti_particle_id")?[row],
+            species_string_id: table.u32("species_string_id")?[row],
+            orientation: table.u8("orientation")?[row],
+            statistics: table.u8("statistics")?[row],
+            color_representation: table.i32("color_representation")?[row],
+            basis_string_id: table.u32("basis_string_id")?[row],
+            tensor_ordering_sequence_id: table.u32("tensor_ordering_sequence_id")?[row],
+            dimension: table.u32("dimension")?[row],
+            chirality: table.i32("chirality")?[row],
+            lc_color_shape_string_id: table.u32("lc_color_shape_string_id")?[row],
+            auxiliary_kind_string_id: table.u32("auxiliary_kind_string_id")?[row],
+            mass_parameter_id: table.u32("mass_parameter_id")?[row],
+            width_parameter_id: table.u32("width_parameter_id")?[row],
+            semantic_digest_id: table.u32("semantic_digest_id")?[row],
+        })
+    })?;
+    let digest_catalog = decode_template_digest_catalog(input.table("digest_catalog")?)?;
+    let evaluator_bindings =
+        decode_template_rows(input.table("evaluator_bindings")?, |table, row| {
+            Ok(EvaluatorBindingRow {
+                id: table.u32("id")?[row],
+                resolver_key_string_id: table.u32("resolver_key_string_id")?[row],
+                prepared_kernel_id: table.u32("prepared_kernel_id")?[row],
+                contract_kind: table.u8("contract_kind")?[row],
+                callable_signature_digest_id: table.u32("callable_signature_digest_id")?[row],
+                input_state_sequence_id: table.u32("input_state_sequence_id")?[row],
+                output_state_template_id: table.u32("output_state_template_id")?[row],
+                input_layout_sequence_id: table.u32("input_layout_sequence_id")?[row],
+                output_layout_sequence_id: table.u32("output_layout_sequence_id")?[row],
+                exact_expression_digest_sequence_id: table
+                    .u32("exact_expression_digest_sequence_id")?[row],
+                semantic_template_sequence_id: table.u32("semantic_template_sequence_id")?[row],
+                callable_kind: table.u8("callable_kind")?[row],
+                runtime_template_string_id: table.u32("runtime_template_string_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+    let exact_factors = decode_template_rows(input.table("exact_factors")?, |table, row| {
+        Ok(ExactFactorRow {
+            id: table.u32("id")?[row],
+            real_numerator_string_id: table.u32("real_numerator_string_id")?[row],
+            real_denominator_string_id: table.u32("real_denominator_string_id")?[row],
+            imag_numerator_string_id: table.u32("imag_numerator_string_id")?[row],
+            imag_denominator_string_id: table.u32("imag_denominator_string_id")?[row],
+        })
+    })?;
+    let flavour_flow_ranges = template_indexed_ranges(input.table("flavour_flow_ranges")?)?;
+    let flavour_flow_values = input.table("flavour_flow_values")?.i32("value")?.to_vec();
+    let i32_sequence_ranges = template_indexed_ranges(input.table("i32_sequence_ranges")?)?;
+    let i32_sequence_values = input.table("i32_sequence_values")?.i32("value")?.to_vec();
+    let parameters = decode_template_rows(input.table("parameters")?, |table, row| {
+        Ok(ParameterRow {
+            id: table.u32("id")?[row],
+            template_string_id: table.u32("template_string_id")?[row],
+            name_string_id: table.u32("name_string_id")?[row],
+            kind: table.u8("kind")?[row],
+            value_type: table.u8("value_type")?[row],
+            mutable: table.u8("mutable")?[row],
+            default_factor_id: table.u32("default_factor_id")?[row],
+            exact_expression_digest_id: table.u32("exact_expression_digest_id")?[row],
+            dependency_sequence_id: table.u32("dependency_sequence_id")?[row],
+            prepared_parameter_id: table.u32("prepared_parameter_id")?[row],
+            semantic_digest_id: table.u32("semantic_digest_id")?[row],
+        })
+    })?;
+    let propagators = decode_template_rows(input.table("propagators")?, |table, row| {
+        Ok(PropagatorRow {
+            id: table.u32("id")?[row],
+            template_string_id: table.u32("template_string_id")?[row],
+            state_template_id: table.u32("state_template_id")?[row],
+            applies_propagator: table.u8("applies_propagator")?[row],
+            evaluator_binding_id: table.u32("evaluator_binding_id")?[row],
+            numerator_expression_digest_id: table.u32("numerator_expression_digest_id")?[row],
+            denominator_expression_digest_id: table.u32("denominator_expression_digest_id")?[row],
+            mass_parameter_id: table.u32("mass_parameter_id")?[row],
+            width_parameter_id: table.u32("width_parameter_id")?[row],
+            gauge_string_id: table.u32("gauge_string_id")?[row],
+            linearity_proof_template_id: table.u32("linearity_proof_template_id")?[row],
+            semantic_digest_id: table.u32("semantic_digest_id")?[row],
+        })
+    })?;
+    let quantum_flows = decode_template_rows(input.table("quantum_flows")?, |table, row| {
+        Ok(QuantumFlowRow {
+            id: table.u32("id")?[row],
+            template_string_id: table.u32("template_string_id")?[row],
+            input_state_sequence_id: table.u32("input_state_sequence_id")?[row],
+            input_spin_sequence_id: table.u32("input_spin_sequence_id")?[row],
+            input_flavour_sequence_id: table.u32("input_flavour_sequence_id")?[row],
+            input_quantum_sequence_id: table.u32("input_quantum_sequence_id")?[row],
+            flavour_flow_operation_string_id: table.u32("flavour_flow_operation_string_id")?[row],
+            quantum_number_flow_operation_string_id: table
+                .u32("quantum_number_flow_operation_string_id")?[row],
+            coupling_order_set_id: table.u32("coupling_order_set_id")?[row],
+            result_state_template_id: table.u32("result_state_template_id")?[row],
+            result_spin_state: table.i32("result_spin_state")?[row],
+            result_flavour_flow_id: table.u32("result_flavour_flow_id")?[row],
+            result_quantum_number_flow_id: table.u32("result_quantum_number_flow_id")?[row],
+            exact_coupling_factor_id: table.u32("exact_coupling_factor_id")?[row],
+            predicate_digest_id: table.u32("predicate_digest_id")?[row],
+            semantic_digest_id: table.u32("semantic_digest_id")?[row],
+        })
+    })?;
+    let quantum_number_flow_ranges =
+        template_indexed_ranges(input.table("quantum_number_flow_ranges")?)?;
+    let quantum_number_flow_terms =
+        decode_template_rows(input.table("quantum_number_flow_terms")?, |table, row| {
+            Ok(QuantumNumberFlowTermRow {
+                flow_id: table.u32("flow_id")?[row],
+                name_string_id: table.u32("name_string_id")?[row],
+                expression_string_id: table.u32("expression_string_id")?[row],
+            })
+        })?;
+    let runtime_helicity_contracts =
+        decode_template_rows(input.table("runtime_helicity_contracts")?, |table, row| {
+            Ok(RuntimeHelicityContractRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                full_state_template_id: table.u32("full_state_template_id")?[row],
+                variant_range: CheckedTableRange::new(
+                    table.u32("variant_offset")?[row].into(),
+                    table.u32("variant_count")?[row].into(),
+                ),
+                proof_algorithm_string_id: table.u32("proof_algorithm_string_id")?[row],
+                proof_digest_id: table.u32("proof_digest_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+    let runtime_helicity_embeddings =
+        decode_template_rows(input.table("runtime_helicity_embeddings")?, |table, row| {
+            Ok(RuntimeHelicityEmbeddingRow {
+                variant_id: table.u32("variant_id")?[row],
+                full_component: table.u32("full_component")?[row],
+                source_component: table.u32("source_component")?[row],
+                factor_id: table.u32("factor_id")?[row],
+            })
+        })?;
+    let runtime_helicity_projections = decode_template_rows(
+        input.table("runtime_helicity_projections")?,
+        |table, row| {
+            Ok(RuntimeHelicityProjectionRow {
+                variant_id: table.u32("variant_id")?[row],
+                source_component: table.u32("source_component")?[row],
+                full_component: table.u32("full_component")?[row],
+            })
+        },
+    )?;
+    let runtime_helicity_variants =
+        decode_template_rows(input.table("runtime_helicity_variants")?, |table, row| {
+            Ok(RuntimeHelicityVariantRow {
+                id: table.u32("id")?[row],
+                contract_id: table.u32("contract_id")?[row],
+                source_template_id: table.u32("source_template_id")?[row],
+                source_state_template_id: table.u32("source_state_template_id")?[row],
+                embedding_range: CheckedTableRange::new(
+                    table.u32("embedding_offset")?[row].into(),
+                    table.u32("embedding_count")?[row].into(),
+                ),
+                projection_range: CheckedTableRange::new(
+                    table.u32("projection_offset")?[row].into(),
+                    table.u32("projection_count")?[row].into(),
+                ),
+                proof_digest_id: table.u32("proof_digest_id")?[row],
+            })
+        })?;
+    let sources = decode_template_rows(input.table("sources")?, |table, row| {
+        Ok(SourceRow {
+            id: table.u32("id")?[row],
+            template_string_id: table.u32("template_string_id")?[row],
+            state_template_id: table.u32("state_template_id")?[row],
+            crossing_string_id: table.u32("crossing_string_id")?[row],
+            wavefunction_family_string_id: table.u32("wavefunction_family_string_id")?[row],
+            helicity: table.i32("helicity")?[row],
+            spin_state: table.i32("spin_state")?[row],
+            flavour_flow_id: table.u32("flavour_flow_id")?[row],
+            quantum_number_flow_id: table.u32("quantum_number_flow_id")?[row],
+            lc_color_seed_operation: table.u8("lc_color_seed_operation")?[row],
+            lc_color_seed_shape_string_id: table.u32("lc_color_seed_shape_string_id")?[row],
+            lc_color_seed_component_kind: table.u8("lc_color_seed_component_kind")?[row],
+            lc_color_seed_component_role: table.u8("lc_color_seed_component_role")?[row],
+            lc_color_seed_proof_digest_id: table.u32("lc_color_seed_proof_digest_id")?[row],
+            lc_color_seed_provenance_sequence_id: table
+                .u32("lc_color_seed_provenance_sequence_id")?[row],
+            wavefunction_expression_digest_id: table.u32("wavefunction_expression_digest_id")?[row],
+            evaluator_binding_id: table.u32("evaluator_binding_id")?[row],
+            mass_parameter_id: table.u32("mass_parameter_id")?[row],
+            width_parameter_id: table.u32("width_parameter_id")?[row],
+            semantic_digest_id: table.u32("semantic_digest_id")?[row],
+        })
+    })?;
+    let string_ranges = template_plain_ranges(input.table("string_ranges")?)?;
+    let string_bytes = input.table("string_bytes")?.u8("value")?.to_vec();
+    let symmetry_proofs = decode_template_rows(input.table("symmetry_proofs")?, |table, row| {
+        Ok(SymmetryProofRow {
+            id: table.u32("id")?[row],
+            template_string_id: table.u32("template_string_id")?[row],
+            proof_algorithm_string_id: table.u32("proof_algorithm_string_id")?[row],
+            subject_template_sequence_id: table.u32("subject_template_sequence_id")?[row],
+            input_permutation_sequence_id: table.u32("input_permutation_sequence_id")?[row],
+            exact_phase_factor_id: table.u32("exact_phase_factor_id")?[row],
+            expression_digest_sequence_id: table.u32("expression_digest_sequence_id")?[row],
+            witness_digest_id: table.u32("witness_digest_id")?[row],
+            semantic_digest_id: table.u32("semantic_digest_id")?[row],
+        })
+    })?;
+    let transitions = decode_template_rows(input.table("transitions")?, |table, row| {
+        Ok(TransitionRow {
+            id: table.u32("id")?[row],
+            template_string_id: table.u32("template_string_id")?[row],
+            input_state_sequence_id: table.u32("input_state_sequence_id")?[row],
+            result_state_template_id: table.u32("result_state_template_id")?[row],
+            quantum_flow_template_id: table.u32("quantum_flow_template_id")?[row],
+            evaluator_binding_id: table.u32("evaluator_binding_id")?[row],
+            canonical_input_order_sequence_id: table.u32("canonical_input_order_sequence_id")?[row],
+            momentum_convention_sequence_id: table.u32("momentum_convention_sequence_id")?[row],
+            coupling_parameter_sequence_id: table.u32("coupling_parameter_sequence_id")?[row],
+            coupling_order_set_id: table.u32("coupling_order_set_id")?[row],
+            color_contraction_template_id: table.u32("color_contraction_template_id")?[row],
+            binding_coupling_factor_id: table.u32("binding_coupling_factor_id")?[row],
+            exact_factor_id: table.u32("exact_factor_id")?[row],
+            output_factor_source: table.u8("output_factor_source")?[row],
+            equivalence_class_string_id: table.u32("equivalence_class_string_id")?[row],
+            input_exchange_factor_id: table.u32("input_exchange_factor_id")?[row],
+            output_projection_string_id: table.u32("output_projection_string_id")?[row],
+            contact_orbit_step_sequence_id: table.u32("contact_orbit_step_sequence_id")?[row],
+            contact_orbit_step_semantic_digest_sequence_id: table
+                .u32("contact_orbit_step_semantic_digest_sequence_id")?[row],
+            semantic_digest_id: table.u32("semantic_digest_id")?[row],
+        })
+    })?;
+    let closures = decode_template_rows(input.table("closures")?, |table, row| {
+        Ok(ClosureRow {
+            id: table.u32("id")?[row],
+            template_string_id: table.u32("template_string_id")?[row],
+            input_state_sequence_id: table.u32("input_state_sequence_id")?[row],
+            result_state_template_id: table.u32("result_state_template_id")?[row],
+            evaluator_binding_id: table.u32("evaluator_binding_id")?[row],
+            canonical_input_order_sequence_id: table.u32("canonical_input_order_sequence_id")?[row],
+            coupling_parameter_sequence_id: table.u32("coupling_parameter_sequence_id")?[row],
+            coupling_order_set_id: table.u32("coupling_order_set_id")?[row],
+            eligible_quantum_flow_sequence_id: table.u32("eligible_quantum_flow_sequence_id")?[row],
+            color_contraction_template_id: table.u32("color_contraction_template_id")?[row],
+            binding_coupling_factor_id: table.u32("binding_coupling_factor_id")?[row],
+            exact_factor_id: table.u32("exact_factor_id")?[row],
+            output_factor_source: table.u8("output_factor_source")?[row],
+            equivalence_class_string_id: table.u32("equivalence_class_string_id")?[row],
+            input_exchange_factor_id: table.u32("input_exchange_factor_id")?[row],
+            projection_string_id: table.u32("projection_string_id")?[row],
+            component_coefficient_sequence_id: table.u32("component_coefficient_sequence_id")?[row],
+            chirality_relation_string_id: table.u32("chirality_relation_string_id")?[row],
+            metric_signature_string_id: table.u32("metric_signature_string_id")?[row],
+            semantic_digest_id: table.u32("semantic_digest_id")?[row],
+        })
+    })?;
+    let color_contractions =
+        decode_template_rows(input.table("color_contractions")?, |table, row| {
+            Ok(ColorContractionRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                rule_kind_string_id: table.u32("rule_kind_string_id")?[row],
+                input_representation_sequence_id: table.u32("input_representation_sequence_id")?
+                    [row],
+                has_output_representation: table.u8("has_output_representation")?[row],
+                output_representation: table.i32("output_representation")?[row],
+                ordered_open_string_arity: table.u32("ordered_open_string_arity")?[row],
+                exact_coefficient_factor_id: table.u32("exact_coefficient_factor_id")?[row],
+                witness_start: table.u64("witness_start")?[row],
+                witness_count: table.u64("witness_count")?[row],
+                nc_term_start: table.u64("nc_term_start")?[row],
+                nc_term_count: table.u64("nc_term_count")?[row],
+                expression_digest_id: table.u32("expression_digest_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+    let lc_color_transition_witnesses = decode_template_rows(
+        input.table("lc_color_transition_witnesses")?,
+        |table, row| {
+            Ok(LCColorTransitionWitnessRow {
+                color_contraction_id: table.u32("color_contraction_id")?[row],
+                ordinal: table.u32("ordinal")?[row],
+                left_shape_string_id: table.u32("left_shape_string_id")?[row],
+                right_shape_string_id: table.u32("right_shape_string_id")?[row],
+                input_permutation: table.u8("input_permutation")?[row],
+                reverse_parent_mask: table.u8("reverse_parent_mask")?[row],
+                component_operation: table.u8("component_operation")?[row],
+                result_component_kind: table.u8("result_component_kind")?[row],
+                result_component_role: table.u8("result_component_role")?[row],
+                result_shape_string_id: table.u32("result_shape_string_id")?[row],
+                exact_factor_id: table.u32("exact_factor_id")?[row],
+                proof_digest_id: table.u32("proof_digest_id")?[row],
+                input_port_pairing_sequence_id: table.u32("input_port_pairing_sequence_id")?[row],
+                result_port_binding_sequence_id: table.u32("result_port_binding_sequence_id")?[row],
+                provenance_sequence_id: table.u32("provenance_sequence_id")?[row],
+            })
+        },
+    )?;
+    let color_nc_terms = decode_template_rows(input.table("color_nc_terms")?, |table, row| {
+        Ok(ColorNcTermRow {
+            color_contraction_id: table.u32("color_contraction_id")?[row],
+            exponent: table.i32("exponent")?[row],
+            factor_id: table.u32("factor_id")?[row],
+        })
+    })?;
+    let u32_sequence_ranges = template_indexed_ranges(input.table("u32_sequence_ranges")?)?;
+    let u32_sequence_values = input.table("u32_sequence_values")?.u32("value")?.to_vec();
+
+    Ok(OwnedRecurrenceTemplateInput {
+        input_abi: input.abi.clone(),
+        catalog_digest: catalog_digest,
+        compiled_model_digest: compiled_model_digest,
+        prepared_kernel_pack_digest: prepared_kernel_pack_digest,
+        catalog_header,
+        coupling_order_ranges,
+        coupling_order_terms,
+        contact_orbit_certificates,
+        contact_orbit_steps,
+        current_states,
+        digest_catalog,
+        evaluator_bindings,
+        exact_factors,
+        flavour_flow_ranges,
+        flavour_flow_values,
+        i32_sequence_ranges,
+        i32_sequence_values,
+        parameters,
+        propagators,
+        quantum_flows,
+        quantum_number_flow_ranges,
+        quantum_number_flow_terms,
+        runtime_helicity_contracts,
+        runtime_helicity_variants,
+        runtime_helicity_embeddings,
+        runtime_helicity_projections,
+        sources,
+        string_ranges,
+        string_bytes,
+        symmetry_proofs,
+        transitions,
+        closures,
+        color_contractions,
+        lc_color_transition_witnesses,
+        color_nc_terms,
+        u32_sequence_ranges,
+        u32_sequence_values,
+    })
+}
+
+fn decode_template_rows<T>(
+    table: &OwnedTable,
+    mut decode: impl FnMut(&OwnedTable, usize) -> RusticolResult<T>,
+) -> RusticolResult<Vec<T>> {
+    let row_count = table.row_count()?;
+    (0..row_count).map(|row| decode(table, row)).collect()
+}
+
+fn template_indexed_ranges(table: &OwnedTable) -> RusticolResult<Vec<template::IndexedRangeRow>> {
+    decode_template_rows(table, |table, row| {
+        Ok(template::IndexedRangeRow {
+            id: table.u32("id")?[row],
+            range: CheckedTableRange::new(table.u64("start")?[row], table.u64("count")?[row]),
+        })
+    })
+}
+
+fn template_plain_ranges(table: &OwnedTable) -> RusticolResult<Vec<CheckedTableRange>> {
+    decode_template_rows(table, |table, row| {
+        Ok(CheckedTableRange::new(
+            table.u64("start")?[row],
+            table.u64("count")?[row],
+        ))
+    })
+}
+
+fn decode_template_digest_catalog(
+    table: &OwnedTable,
+) -> RusticolResult<Vec<template::DigestCatalogRow>> {
+    let ids = table.u32("id")?;
+    let values = table.u8("value")?;
+    let row_count = table.row_count()?;
+    let expected = row_count
+        .checked_mul(32)
+        .ok_or_else(|| invalid("digest catalog byte count exceeds usize"))?;
+    if values.len() != expected {
+        return Err(invalid(format!(
+            "digest_catalog.value has {} bytes, expected {expected}",
+            values.len()
+        )));
+    }
+    (0..row_count)
+        .map(|row| {
+            let start = row * 32;
+            let mut value = [0_u8; 32];
+            value.copy_from_slice(&values[start..start + 32]);
+            Ok(template::DigestCatalogRow {
+                id: ids[row],
+                value,
+            })
+        })
+        .collect()
+}
+
+fn validate_inventory(input: &OwnedInput) -> RusticolResult<()> {
+    if input.abi != RECURRENCE_BUILDER_INPUT_ABI {
+        return Err(RusticolError::compatibility(format!(
+            "unsupported recurrence builder input ABI {:?}; expected {:?}",
+            input.abi, RECURRENCE_BUILDER_INPUT_ABI
+        )));
+    }
+    if input.tables.len() != TABLE_SPECS.len() {
+        return Err(invalid(
+            "recurrence builder table inventory changed after extraction",
+        ));
+    }
+    for (table, spec) in input.tables.iter().zip(TABLE_SPECS) {
+        if table.name != spec.name || table.columns.len() != spec.columns.len() {
+            return Err(invalid(format!(
+                "recurrence builder table {:?} schema changed after extraction",
+                table.name
+            )));
+        }
+        for (column, column_spec) in table.columns.iter().zip(spec.columns) {
+            if column.name != column_spec.name || column.dtype != column_spec.kind.dtype() {
+                return Err(invalid(format!(
+                    "recurrence builder column {}.{} schema changed after extraction",
+                    table.name, column.name
+                )));
+            }
+            if column.shape.first().copied() != Some(table.row_count) {
+                return Err(invalid(format!(
+                    "recurrence builder column {}.{} row count changed after extraction",
+                    table.name, column.name
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn canonical_digest(input: &OwnedInput) -> RusticolResult<String> {
+    let mut digest = Sha256::new();
+    hash_text(&mut digest, &input.abi)?;
+    hash_tables(&mut digest, &input.tables)?;
+    Ok(hex_digest(digest.finalize()))
+}
+
+fn hash_tables(digest: &mut Sha256, tables: &[OwnedTable]) -> RusticolResult<()> {
+    digest.update(
+        u64::try_from(tables.len())
+            .map_err(|_| invalid("recurrence table count exceeds u64"))?
+            .to_le_bytes(),
+    );
+    for table in tables {
+        hash_text(digest, &table.name)?;
+        digest.update(table.row_count.to_le_bytes());
+        digest.update(
+            u32::try_from(table.columns.len())
+                .map_err(|_| invalid("recurrence table column count exceeds u32"))?
+                .to_le_bytes(),
+        );
+        for column in &table.columns {
+            hash_text(digest, &column.name)?;
+            hash_text(digest, column.dtype)?;
+            digest.update(
+                u8::try_from(column.shape.len())
+                    .map_err(|_| invalid("recurrence column rank exceeds u8"))?
+                    .to_le_bytes(),
+            );
+            for dimension in &column.shape {
+                digest.update(dimension.to_le_bytes());
+            }
+            digest.update(column.values.raw_bytes());
+        }
+    }
+    Ok(())
+}
+
+fn iterable_attribute<'py>(
+    value: &Bound<'py, PyAny>,
+    attribute: &str,
+    context: &str,
+) -> PyResult<Vec<Bound<'py, PyAny>>> {
+    value
+        .getattr(attribute)?
+        .try_iter()
+        .map_err(|_| PyTypeError::new_err(format!("{context} must be iterable")))?
+        .collect()
+}
+
+fn required_string(value: &Bound<'_, PyAny>, attribute: &str) -> PyResult<String> {
+    value.getattr(attribute)?.extract::<String>().map_err(|_| {
+        PyTypeError::new_err(format!(
+            "recurrence builder input {attribute} must be a string"
+        ))
+    })
+}
+
+fn required_nonempty_string(
+    value: &Bound<'_, PyAny>,
+    attribute: &str,
+    context: &str,
+) -> PyResult<String> {
+    let result = required_string(value, attribute)?;
+    if result.is_empty() {
+        return Err(PyValueError::new_err(format!(
+            "recurrence builder {context} must not be empty"
+        )));
+    }
+    Ok(result)
+}
+
+fn validate_sha256_text(value: &str, context: &str) -> PyResult<()> {
+    if value.len() != 64
+        || !value
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f'))
+    {
+        return Err(PyValueError::new_err(format!(
+            "{context} must be a lowercase SHA-256 digest"
+        )));
+    }
+    Ok(())
+}
+
+fn semantic_digest_python_attribute(
+    value: &Bound<'_, PyAny>,
+    attribute: &str,
+) -> PyResult<SemanticDigest> {
+    let digest = required_string(value, attribute)?;
+    semantic_digest_from_hex(&digest, attribute).map_err(python_error)
+}
+
+pub(super) fn semantic_digest_from_hex(
+    value: &str,
+    context: &str,
+) -> RusticolResult<SemanticDigest> {
+    if value.len() != 64
+        || !value
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f'))
+    {
+        return Err(invalid(format!(
+            "{context} must be a lowercase SHA-256 digest"
+        )));
+    }
+    let mut result = [0_u8; 32];
+    for (index, byte) in result.iter_mut().enumerate() {
+        let offset = index * 2;
+        *byte = u8::from_str_radix(&value[offset..offset + 2], 16)
+            .map_err(|_| invalid(format!("{context} is not hexadecimal")))?;
+    }
+    SemanticDigest::new(result)
+}
+
+fn hash_text(digest: &mut Sha256, value: &str) -> RusticolResult<()> {
+    digest.update(
+        u64::try_from(value.len())
+            .map_err(|_| invalid("recurrence digest text length exceeds u64"))?
+            .to_le_bytes(),
+    );
+    digest.update(value.as_bytes());
+    Ok(())
+}
+
+pub(super) fn hex_digest(value: impl AsRef<[u8]>) -> String {
+    let mut result = String::with_capacity(value.as_ref().len() * 2);
+    for byte in value.as_ref() {
+        use std::fmt::Write;
+        write!(&mut result, "{byte:02x}").expect("writing to String cannot fail");
+    }
+    result
+}
+
+pub(super) fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+fn wrong_type(context: &str, expected: &str) -> RusticolError {
+    invalid(format!("{context} is not a {expected} recurrence column"))
+}
+
+#[cfg(test)]
+mod direct_binding_tests {
+    use super::*;
+    use serde_json::json;
+
+    fn construction_progress(
+        stage_index: usize,
+        candidate_parent_pair_count: usize,
+    ) -> RecurrenceBuildProgress {
+        RecurrenceBuildProgress {
+            phase: "recurrence stage",
+            phase_index: stage_index + 2,
+            phase_total: 33,
+            stage_index: Some(stage_index),
+            stage_total: 30,
+            subset_size: Some(stage_index % 5 + 2),
+            candidate_parent_pair_count,
+            candidate_parent_pair_total: Some(candidate_parent_pair_count),
+            current_count: 0,
+            contribution_count: 0,
+            dynamic_color_state_count: 0,
+            color_target_prune_count: 0,
+        }
+    }
+
+    fn digest(seed: u8) -> String {
+        format!("{seed:02x}").repeat(32)
+    }
+
+    fn refresh_digest(value: &mut JsonValue, field: &str, context: &str) {
+        value.as_object_mut().unwrap().remove(field);
+        let digest: [u8; 32] = Sha256::digest(canonical_json_bytes(value, context).unwrap()).into();
+        value
+            .as_object_mut()
+            .unwrap()
+            .insert(field.to_owned(), json!(hex_digest(digest)));
+    }
+
+    fn canonical_direct_catalog() -> (Vec<u8>, SemanticDigest, SemanticDigest, SemanticDigest) {
+        let prepared_pack = semantic_digest_from_hex(&digest(1), "test pack").unwrap();
+        let semantic_catalog =
+            semantic_digest_from_hex(&digest(2), "test semantic catalog").unwrap();
+        let compiled_model = semantic_digest_from_hex(&digest(3), "test compiled model").unwrap();
+        let mut template = json!({
+            "abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+            "alignment_bytes": 64,
+            "backend": "jit",
+            "coupling_slot_count": 0,
+            "destination_aliasing": false,
+            "destination_component_count": 4,
+            "destination_operation": "initialize",
+            "direct_executor_id": 0,
+            "evaluator_binding_id": 7,
+            "evaluator_resolver_key": "source:7",
+            "exact_expression_digest": digest(4),
+            "momentum_operand_count": 1,
+            "optimization_level": 2,
+            "parameter_slot_count": 0,
+            "parent_arity": 0,
+            "parent_component_counts": [],
+            "payload_binding": {
+                "abi": DIRECT_PAYLOAD_BINDING_ABI,
+                "destination_operation": "initialize",
+                "direct_application_abi": null,
+                "exact_factor_scalar_slots": [],
+                "input_plane_count": 0,
+                "input_plane_projections": [],
+                "intrinsic_contract_digest": null,
+                "kind": "rusticol-intrinsic",
+                "native_entry_point": null,
+                "output_alias_inputs": [],
+                "contribution_parent_permutation": [0, 1],
+                "parameter_bindings": [],
+                "payload_digest": digest(5),
+                "payload_paths": [],
+                "prepared_kernel_id": null,
+                "prepared_template_semantic_digest": null,
+                "role": "source",
+                "runtime_template": "rusticol.source-fill.v1",
+                "scalar_input_count": 0,
+                "scalar_projections": [],
+                "source_application_abi": null,
+                "source_application_path": null,
+                "source_application_sha256": null,
+                "state_plane_indices": []
+            },
+            "portable": true,
+            "role": "source",
+            "semantic_template_ids": ["source:test"],
+            "simd_axis": "points-contiguous",
+            "target_triple": "symjit-storage-v3-portable",
+            "template_id": "direct:source:test"
+        });
+        let template_digest: [u8; 32] =
+            Sha256::digest(canonical_json_bytes(&template, "test template").unwrap()).into();
+        template.as_object_mut().unwrap().insert(
+            "semantic_digest".to_owned(),
+            json!(hex_digest(template_digest)),
+        );
+
+        let mut catalog = json!({
+            "abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+            "backend": "jit",
+            "backend_abi": DIRECT_BACKEND_ABI,
+            "canonicalization_abi": DIRECT_CANONICALIZATION_ABI,
+            "compiled_model_digest": compiled_model.to_string(),
+            "optimization_level": 2,
+            "optimization_settings_digest": digest(6),
+            "portable": true,
+            "prepared_kernel_contract_digest": digest(7),
+            "prepared_kernel_pack_digest": prepared_pack.to_string(),
+            "prepared_kernel_payload_digest": digest(8),
+            "recurrence_template_catalog_digest": semantic_catalog.to_string(),
+            "target_triple": "symjit-storage-v3-portable",
+            "templates": [template]
+        });
+        let catalog_digest: [u8; 32] =
+            Sha256::digest(canonical_json_bytes(&catalog, "test catalog").unwrap()).into();
+        catalog.as_object_mut().unwrap().insert(
+            "catalog_digest".to_owned(),
+            json!(hex_digest(catalog_digest)),
+        );
+        (
+            canonical_json_bytes(&catalog, "test catalog").unwrap(),
+            prepared_pack,
+            semantic_catalog,
+            compiled_model,
+        )
+    }
+
+    #[test]
+    fn canonical_catalog_authenticates_dense_role_binding() {
+        let (bytes, pack, semantic, model) = canonical_direct_catalog();
+        let parsed = parse_direct_template_catalog(&bytes, pack, semantic, model).unwrap();
+
+        assert_eq!(parsed.catalog.direct_executor_count(), 1);
+        assert_eq!(
+            parsed
+                .catalog
+                .resolve_evaluator(DirectExecutorRole::Source, 7)
+                .unwrap(),
+            0
+        );
+        assert_eq!(parsed.prepared_kernel_count, 0);
+    }
+
+    #[test]
+    fn construction_metrics_sum_lane_unique_stage_counts() {
+        let mut metrics = RecurrenceConstructionMetrics::default();
+        for lane_index in 0..6 {
+            for stage_index_within_lane in 0..5 {
+                let stage_index = lane_index * 5 + stage_index_within_lane;
+                let final_count = (lane_index + 1) * (stage_index_within_lane + 2);
+                metrics.include(&construction_progress(stage_index, final_count / 2));
+                metrics.include(&construction_progress(stage_index, final_count));
+            }
+        }
+
+        let expected = (0..6)
+            .flat_map(|lane_index| {
+                (0..5).map(move |stage_index_within_lane| {
+                    (lane_index + 1) * (stage_index_within_lane + 2)
+                })
+            })
+            .sum::<usize>();
+        assert_eq!(metrics.candidate_parent_pair_count_by_stage.len(), 30);
+        assert_eq!(metrics.candidate_parent_pair_count(), expected);
+    }
+
+    #[test]
+    fn noncanonical_catalog_bytes_are_rejected() {
+        let (mut bytes, pack, semantic, model) = canonical_direct_catalog();
+        bytes.push(b'\n');
+
+        let error = match parse_direct_template_catalog(&bytes, pack, semantic, model) {
+            Ok(_) => panic!("noncanonical direct catalog was accepted"),
+            Err(error) => error,
+        };
+        assert!(error.to_string().contains("not canonical"));
+    }
+
+    #[test]
+    fn catalog_digest_authenticates_executor_mapping() {
+        let (bytes, pack, semantic, model) = canonical_direct_catalog();
+        let mut value: JsonValue = serde_json::from_slice(&bytes).unwrap();
+        value["templates"][0]["evaluator_binding_id"] = json!(8);
+        let tampered = canonical_json_bytes(&value, "tampered catalog").unwrap();
+
+        let error = match parse_direct_template_catalog(&tampered, pack, semantic, model) {
+            Ok(_) => panic!("tampered direct catalog was accepted"),
+            Err(error) => error,
+        };
+        assert!(error.to_string().contains("catalog digest"));
+    }
+
+    #[test]
+    fn pending_direct_payload_is_rejected_before_lowering() {
+        let (bytes, pack, semantic, model) = canonical_direct_catalog();
+        let mut value: JsonValue = serde_json::from_slice(&bytes).unwrap();
+        let template = &mut value["templates"][0];
+        template["payload_binding"]["kind"] = json!("pending-direct-call-abi");
+        template["payload_binding"]["runtime_template"] = JsonValue::Null;
+        template["payload_binding"]["prepared_kernel_id"] = json!(7);
+        refresh_digest(template, "semantic_digest", "pending direct template");
+        refresh_digest(&mut value, "catalog_digest", "pending direct catalog");
+        let pending = canonical_json_bytes(&value, "pending direct catalog").unwrap();
+
+        let error = match parse_direct_template_catalog(&pending, pack, semantic, model) {
+            Ok(_) => panic!("pending direct payload was accepted"),
+            Err(error) => error,
+        };
+        assert!(
+            error
+                .to_string()
+                .contains("no executable Direct-Arena payload")
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-python/src/recurrence_numerical_evidence.rs b/pyamplicol/rust/crates/rusticol-python/src/recurrence_numerical_evidence.rs
new file mode 100644
index 0000000000..20ec80243b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/src/recurrence_numerical_evidence.rs
@@ -0,0 +1,4783 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Fail-closed authentication of recurrence numerical-current evidence.
+//!
+//! Python supplies complete raw candidate and independent-verification captures.
+//! This module independently reconstructs their schema, probe contexts, exact
+//! rational residuals, decision census, certificates, and current mappings
+//! before the native Direct-Arena lowering is allowed to apply any reuse.
+
+use flate2::read::ZlibDecoder;
+use num_bigint::BigInt;
+use num_rational::BigRational;
+use num_traits::{One, Signed, ToPrimitive, Zero};
+use rusticol_core::recurrence::process::ValidatedRecurrenceProcessInput;
+use rusticol_core::recurrence::template::{ParameterKind, ValidatedRecurrenceTemplateInput};
+use rusticol_core::recurrence::{
+    RecurrenceNumericalCurrentMapping, RecurrenceNumericalRelationEvidence,
+    RecurrenceRelationDiscoveryMode,
+};
+use rusticol_core::{RusticolError, RusticolResult};
+use serde_json::{Map as JsonMap, Value as JsonValue, value::RawValue as JsonRawValue};
+use sha2::{Digest, Sha256};
+use std::collections::{BTreeMap, BTreeSet};
+use std::io::{self, Read, Write};
+use std::ops::Range;
+use std::str::FromStr;
+use std::time::Instant;
+
+use crate::recurrence::{
+    canonical_json_bytes, canonical_json_sha256, hex_digest, invalid, json_array, json_bool,
+    json_field, json_nonempty_string, json_object, json_string, json_u32, require_json_fields,
+    require_json_string_value, semantic_digest_from_hex,
+};
+
+type ExactProbeComplex = (BigRational, BigRational);
+
+const COMPRESSED_EVIDENCE_MAGIC: &[u8; 8] = b"PACNCEZ1";
+const COMPRESSED_EVIDENCE_HEADER_BYTES: usize = 8 + 8 + 32;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct RawByteRange {
+    start: usize,
+    end: usize,
+}
+
+impl RawByteRange {
+    fn from_usize(start: usize, end: usize, limit: usize, context: &str) -> RusticolResult<Self> {
+        if start > end || end > limit {
+            return Err(invalid(format!("{context} is outside the raw evidence")));
+        }
+        Ok(Self { start, end })
+    }
+
+    fn as_usize(self, limit: usize, context: &str) -> RusticolResult<Range<usize>> {
+        let range = self.start..self.end;
+        if range.start > range.end || range.end > limit {
+            return Err(invalid(format!("{context} is outside the raw evidence")));
+        }
+        Ok(range)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct RawObservationRow {
+    row: RawByteRange,
+    values: RawByteRange,
+}
+
+struct LocatedObservationArrays {
+    metadata_bytes: Vec<u8>,
+    candidate: RawByteRange,
+    verification: RawByteRange,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct LocatedObservationRanges {
+    candidate: RawByteRange,
+    verification: RawByteRange,
+}
+
+fn borrowed_raw_value_range(
+    bytes: &[u8],
+    value: &JsonRawValue,
+    context: &str,
+) -> RusticolResult<RawByteRange> {
+    let raw = value.get().as_bytes();
+    let bytes_start = bytes.as_ptr() as usize;
+    let raw_start = raw.as_ptr() as usize;
+    let start = raw_start
+        .checked_sub(bytes_start)
+        .ok_or_else(|| invalid(format!("{context} does not borrow the raw evidence")))?;
+    let end = start
+        .checked_add(raw.len())
+        .ok_or_else(|| invalid(format!("{context} byte range overflows usize")))?;
+    RawByteRange::from_usize(start, end, bytes.len(), context)
+}
+
+fn locate_raw_observation_ranges(bytes: &[u8]) -> RusticolResult<LocatedObservationRanges> {
+    let root = serde_json::from_slice::<BTreeMap<String, &JsonRawValue>>(bytes)
+        .map_err(|error| invalid(format!("numerical relation evidence is not JSON: {error}")))?;
+    let locate = |field: &str| -> RusticolResult<RawByteRange> {
+        let capture = root
+            .get(field)
+            .ok_or_else(|| invalid(format!("numerical relation evidence has no {field}")))?;
+        let capture_fields = serde_json::from_str::<BTreeMap<String, &JsonRawValue>>(capture.get())
+            .map_err(|error| {
+                invalid(format!(
+                    "{field} raw numerical capture is not JSON: {error}"
+                ))
+            })?;
+        let observations = capture_fields
+            .get("observations")
+            .ok_or_else(|| invalid(format!("{field} raw numerical capture has no observations")))?;
+        borrowed_raw_value_range(bytes, observations, &format!("{field} observations"))
+    };
+    let candidate = locate("candidate_capture")?;
+    let verification = locate("verification_capture")?;
+    let candidate_range = candidate.as_usize(bytes.len(), "candidate observation-array range")?;
+    let verification_range =
+        verification.as_usize(bytes.len(), "verification observation-array range")?;
+    if candidate_range.end > verification_range.start {
+        return Err(invalid(
+            "raw numerical observation arrays overlap or are not canonical",
+        ));
+    }
+    Ok(LocatedObservationRanges {
+        candidate,
+        verification,
+    })
+}
+
+fn raw_observation_metadata_byte_count(
+    bytes: &[u8],
+    ranges: LocatedObservationRanges,
+) -> RusticolResult<usize> {
+    let candidate_range = ranges
+        .candidate
+        .as_usize(bytes.len(), "candidate observation-array range")?;
+    let verification_range = ranges
+        .verification
+        .as_usize(bytes.len(), "verification observation-array range")?;
+    let removed = candidate_range
+        .len()
+        .checked_add(verification_range.len())
+        .ok_or_else(|| invalid("raw observation-array byte count overflows usize"))?;
+    bytes
+        .len()
+        .checked_sub(removed)
+        .and_then(|size| size.checked_add(4))
+        .ok_or_else(|| invalid("raw numerical metadata size overflows usize"))
+}
+
+fn materialize_raw_observation_metadata(
+    bytes: &[u8],
+    ranges: LocatedObservationRanges,
+) -> RusticolResult<Vec<u8>> {
+    let candidate_range = ranges
+        .candidate
+        .as_usize(bytes.len(), "candidate observation-array range")?;
+    let verification_range = ranges
+        .verification
+        .as_usize(bytes.len(), "verification observation-array range")?;
+    let capacity = raw_observation_metadata_byte_count(bytes, ranges)?;
+    let mut metadata_bytes = Vec::with_capacity(capacity);
+    metadata_bytes.extend_from_slice(&bytes[..candidate_range.start]);
+    metadata_bytes.extend_from_slice(b"[]");
+    metadata_bytes.extend_from_slice(&bytes[candidate_range.end..verification_range.start]);
+    metadata_bytes.extend_from_slice(b"[]");
+    metadata_bytes.extend_from_slice(&bytes[verification_range.end..]);
+    if metadata_bytes.len() != capacity {
+        return Err(invalid(
+            "raw numerical metadata materialization length drifted",
+        ));
+    }
+    Ok(metadata_bytes)
+}
+
+#[cfg(test)]
+fn locate_raw_observation_arrays(bytes: &[u8]) -> RusticolResult<LocatedObservationArrays> {
+    let ranges = locate_raw_observation_ranges(bytes)?;
+    let metadata_bytes = materialize_raw_observation_metadata(bytes, ranges)?;
+    Ok(LocatedObservationArrays {
+        metadata_bytes,
+        candidate: ranges.candidate,
+        verification: ranges.verification,
+    })
+}
+
+struct CanonicalObservationCursor<'a> {
+    bytes: &'a [u8],
+    position: usize,
+    absolute_start: usize,
+}
+
+impl<'a> CanonicalObservationCursor<'a> {
+    fn expect(&mut self, expected: &[u8], context: &str) -> RusticolResult<()> {
+        let end = self
+            .position
+            .checked_add(expected.len())
+            .ok_or_else(|| invalid(format!("{context} offset overflows usize")))?;
+        if self.bytes.get(self.position..end) != Some(expected) {
+            return Err(invalid(format!("{context} is malformed or not canonical")));
+        }
+        self.position = end;
+        Ok(())
+    }
+
+    fn absolute_position(&self, context: &str) -> RusticolResult<usize> {
+        self.absolute_start
+            .checked_add(self.position)
+            .ok_or_else(|| invalid(format!("{context} offset overflows usize")))
+    }
+
+    fn decimal_string(&mut self, context: &str) -> RusticolResult<&'a str> {
+        self.expect(b"\"", context)?;
+        let remaining = self
+            .bytes
+            .get(self.position..)
+            .ok_or_else(|| invalid(format!("{context} is truncated")))?;
+        let width = remaining
+            .iter()
+            .position(|byte| *byte == b'"')
+            .ok_or_else(|| invalid(format!("{context} is unterminated")))?;
+        let end = self
+            .position
+            .checked_add(width)
+            .ok_or_else(|| invalid(format!("{context} width overflows usize")))?;
+        let text = std::str::from_utf8(
+            self.bytes
+                .get(self.position..end)
+                .ok_or_else(|| invalid(format!("{context} is truncated")))?,
+        )
+        .map_err(|_| invalid(format!("{context} is not ASCII")))?;
+        validate_canonical_decimal_text(text, context)?;
+        self.position = end;
+        self.expect(b"\"", context)?;
+        Ok(text)
+    }
+}
+
+fn scan_raw_observation_array(
+    bytes: &[u8],
+    array: RawByteRange,
+    source: &RawSourceSemantics,
+    point_count: usize,
+    label: &str,
+) -> RusticolResult<Vec<RawObservationRow>> {
+    let array_range = array.as_usize(bytes.len(), &format!("{label} observation array"))?;
+    let raw_array = bytes
+        .get(array_range.clone())
+        .ok_or_else(|| invalid(format!("{label} observation array is absent")))?;
+    let mut cursor = CanonicalObservationCursor {
+        bytes: raw_array,
+        position: 0,
+        absolute_start: array_range.start,
+    };
+    cursor.expect(b"[", &format!("{label} observation array"))?;
+    let mut rows = Vec::with_capacity(source.currents.len());
+    for (index, current) in source.currents.iter().enumerate() {
+        if index != 0 {
+            cursor.expect(b",", &format!("{label} observation row {index}"))?;
+        }
+        let row_start = cursor.absolute_position(&format!("{label} observation row {index}"))?;
+        cursor.expect(
+            b"{\"current_id\":",
+            &format!("{label} observation row {index}"),
+        )?;
+        cursor.expect(
+            current.current_id.to_string().as_bytes(),
+            &format!("{label} observation row {index} current ID"),
+        )?;
+        cursor.expect(
+            b",\"dimension\":",
+            &format!("{label} observation row {index}"),
+        )?;
+        cursor.expect(
+            current.dimension.to_string().as_bytes(),
+            &format!("{label} observation row {index} dimension"),
+        )?;
+        cursor.expect(b",\"values\":", &format!("{label} observation row {index}"))?;
+        let values_start =
+            cursor.absolute_position(&format!("{label} observation row {index} values"))?;
+        cursor.expect(b"[", &format!("{label} observation row {index} values"))?;
+        let expected_width = point_count
+            .checked_mul(usize::from(current.dimension))
+            .ok_or_else(|| {
+                invalid(format!(
+                    "{label} observation row {index} width overflows usize"
+                ))
+            })?;
+        for component in 0..expected_width {
+            let context = format!("{label} observation row {index} component {component}");
+            if component != 0 {
+                cursor.expect(b",", &context)?;
+            }
+            cursor.expect(b"[", &context)?;
+            cursor.decimal_string(&format!("{context} real part"))?;
+            cursor.expect(b",", &context)?;
+            cursor.decimal_string(&format!("{context} imaginary part"))?;
+            cursor.expect(b"]", &context)?;
+        }
+        cursor.expect(b"]", &format!("{label} observation row {index} values"))?;
+        let values_end =
+            cursor.absolute_position(&format!("{label} observation row {index} values"))?;
+        cursor.expect(b"}", &format!("{label} observation row {index}"))?;
+        let row_end = cursor.absolute_position(&format!("{label} observation row {index}"))?;
+        rows.push(RawObservationRow {
+            row: RawByteRange::from_usize(
+                row_start,
+                row_end,
+                bytes.len(),
+                &format!("{label} observation row {index}"),
+            )?,
+            values: RawByteRange::from_usize(
+                values_start,
+                values_end,
+                bytes.len(),
+                &format!("{label} observation row {index} values"),
+            )?,
+        });
+    }
+    cursor.expect(b"]", &format!("{label} observation array"))?;
+    if cursor.position != cursor.bytes.len() {
+        return Err(invalid(format!(
+            "{label} observation array has trailing or extra rows"
+        )));
+    }
+    Ok(rows)
+}
+
+struct CanonicalJsonMatcher<'a> {
+    expected: &'a [u8],
+    offset: usize,
+    matches: bool,
+}
+
+impl Write for CanonicalJsonMatcher<'_> {
+    fn write(&mut self, buffer: &[u8]) -> io::Result<usize> {
+        let end = self.offset.saturating_add(buffer.len());
+        if end > self.expected.len() || self.expected[self.offset..end] != *buffer {
+            self.matches = false;
+        }
+        self.offset = end;
+        Ok(buffer.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+fn validate_canonical_json_bytes(
+    value: &JsonValue,
+    expected: &[u8],
+    context: &str,
+) -> RusticolResult<()> {
+    let mut matcher = CanonicalJsonMatcher {
+        expected,
+        offset: 0,
+        matches: true,
+    };
+    serde_json::to_writer(&mut matcher, value)
+        .map_err(|error| invalid(format!("could not canonicalize {context}: {error}")))?;
+    if !matcher.matches || matcher.offset != expected.len() {
+        return Err(invalid(format!("{context} is not canonical ASCII JSON")));
+    }
+    Ok(())
+}
+
+fn validate_raw_json_lexical_structure(bytes: &[u8]) -> RusticolResult<()> {
+    let mut in_string = false;
+    let mut escaped = false;
+    let mut depth = 0_usize;
+    for &byte in bytes {
+        if !byte.is_ascii() {
+            return Err(invalid(
+                "numerical relation evidence must be canonical ASCII JSON",
+            ));
+        }
+        if in_string {
+            if escaped {
+                escaped = false;
+            } else if byte == b'\\' {
+                escaped = true;
+            } else if byte == b'"' {
+                in_string = false;
+            }
+            continue;
+        }
+        match byte {
+            b'"' => {
+                in_string = true;
+            }
+            b'{' | b'[' => {
+                depth += 1;
+            }
+            b'}' | b']' => {
+                depth = depth.saturating_sub(1);
+            }
+            _ => {}
+        }
+    }
+    if in_string || depth != 0 {
+        return Err(invalid(
+            "numerical relation evidence JSON lexical structure is incomplete",
+        ));
+    }
+    Ok(())
+}
+
+fn decode_compressed_evidence(bytes: &[u8]) -> RusticolResult<Vec<u8>> {
+    if bytes.len() < COMPRESSED_EVIDENCE_HEADER_BYTES {
+        return Err(invalid(
+            "compressed numerical relation evidence header is truncated",
+        ));
+    }
+    if bytes.get(..COMPRESSED_EVIDENCE_MAGIC.len()) != Some(COMPRESSED_EVIDENCE_MAGIC) {
+        return Err(invalid(
+            "compressed numerical relation evidence has invalid magic",
+        ));
+    }
+    let declared_bytes = u64::from_be_bytes(
+        bytes[8..16]
+            .try_into()
+            .map_err(|_| invalid("compressed numerical evidence length header is malformed"))?,
+    );
+    let declared_bytes = usize::try_from(declared_bytes)
+        .map_err(|_| invalid("compressed numerical evidence length exceeds usize"))?;
+    if declared_bytes == 0 {
+        return Err(invalid(
+            "compressed numerical relation evidence declares an empty payload",
+        ));
+    }
+
+    let expected_digest = bytes
+        .get(16..COMPRESSED_EVIDENCE_HEADER_BYTES)
+        .ok_or_else(|| invalid("compressed numerical evidence digest header is malformed"))?;
+    let compressed = bytes
+        .get(COMPRESSED_EVIDENCE_HEADER_BYTES..)
+        .ok_or_else(|| invalid("compressed numerical evidence payload is truncated"))?;
+    if compressed.is_empty() {
+        return Err(invalid(
+            "compressed numerical relation evidence payload is empty",
+        ));
+    }
+
+    let mut decoded = Vec::new();
+    decoded
+        .try_reserve_exact(declared_bytes)
+        .map_err(|_| invalid("could not reserve decompressed numerical evidence"))?;
+    let mut decoder = ZlibDecoder::new(compressed);
+    {
+        let maximum_read = u64::try_from(declared_bytes)
+            .ok()
+            .and_then(|count| count.checked_add(1))
+            .ok_or_else(|| invalid("compressed numerical decompression limit overflows u64"))?;
+        let mut limited = decoder.by_ref().take(maximum_read);
+        limited.read_to_end(&mut decoded).map_err(|error| {
+            invalid(format!(
+                "compressed numerical relation evidence could not be decompressed: {error}"
+            ))
+        })?;
+    }
+    if decoded.len() != declared_bytes {
+        return Err(invalid(format!(
+            "compressed numerical relation evidence decompressed length disagrees with its declaration (declared={declared_bytes}, actual={})",
+            decoded.len()
+        )));
+    }
+    if usize::try_from(decoder.total_in()).ok() != Some(compressed.len()) {
+        return Err(invalid(
+            "compressed numerical relation evidence has trailing or unconsumed transport bytes",
+        ));
+    }
+    if Sha256::digest(&decoded).as_slice() != expected_digest {
+        return Err(RusticolError::integrity(
+            "compressed numerical relation evidence digest mismatch",
+        ));
+    }
+    Ok(decoded)
+}
+
+#[derive(Clone, Debug)]
+struct RawNumericalCapture<'a> {
+    raw_bytes: &'a [u8],
+    observation_rows: Vec<RawObservationRow>,
+    point_count: usize,
+    point_sha256s: Vec<String>,
+    kinematic_sha256s: Vec<String>,
+    parameter_context_sha256s: Vec<String>,
+    parameter_contexts: Vec<Vec<BigRational>>,
+    dimensions: Vec<u16>,
+    observation_batch_sha256: String,
+    capture_contract_sha256: String,
+}
+
+#[derive(Clone, Debug)]
+struct RawSourceCurrent {
+    current_id: u32,
+    is_source: bool,
+    contract_key: Vec<u8>,
+    dimension: u16,
+    selector_domain_id: u32,
+}
+
+#[derive(Clone, Debug)]
+struct RawSourceSemantics {
+    value: JsonValue,
+    process_id: String,
+    physical_pdgs: Vec<i32>,
+    strategy: String,
+    selector_schedule: JsonValue,
+    currents: Vec<RawSourceCurrent>,
+}
+
+#[derive(Clone, Debug)]
+struct DerivedNumericalRelation {
+    mapping: RecurrenceNumericalCurrentMapping,
+    certificate: JsonValue,
+    mapping_json: JsonValue,
+}
+
+#[derive(Clone, Debug)]
+struct RawNumericalCandidateIndex {
+    #[cfg(test)]
+    observation_index: usize,
+    scalar_component: usize,
+    entries: Vec<(BigRational, u32)>,
+    selected_values: Vec<(u32, ExactProbeComplex)>,
+}
+
+impl RawNumericalCandidateIndex {
+    fn selected_value(&self, current_id: u32, context: &str) -> RusticolResult<&ExactProbeComplex> {
+        let index = self
+            .selected_values
+            .binary_search_by_key(&current_id, |(candidate_id, _value)| *candidate_id)
+            .map_err(|_| invalid(format!("{context} selected observation is absent")))?;
+        Ok(&self.selected_values[index].1)
+    }
+}
+
+#[derive(Clone, Debug)]
+struct RawNumericalDerivation {
+    relations: Vec<DerivedNumericalRelation>,
+    numerical_candidate_count: usize,
+    verification_rejected_count: usize,
+    rejected_hypothesis_count: usize,
+    tested_hypothesis_count: usize,
+    theoretical_pair_hypothesis_count: usize,
+    screened_pair_hypothesis_count: usize,
+    zero_hypothesis_count: usize,
+    candidate_index_contract_count: usize,
+    exhaustive_fallback_contract_count: usize,
+    decision_sha256: String,
+    rejection_decision_sha256: String,
+}
+
+/// Internal, generation-only measurements for numerical-evidence replay.
+///
+/// This record never enters a Python result, recurrence artifact, runtime
+/// payload, semantic digest, or public ABI.
+#[doc(hidden)]
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub(super) struct RecurrenceEvidenceAuthenticationTelemetry {
+    pub transport_decode_nanoseconds: u64,
+    pub capture_authentication_nanoseconds: u64,
+    pub candidate_index_nanoseconds: u64,
+    pub hypothesis_replay_nanoseconds: u64,
+    pub derivation_finalization_nanoseconds: u64,
+    pub evidence_finalization_nanoseconds: u64,
+    pub total_nanoseconds: u64,
+    pub candidate_index_observation_row_scan_count: usize,
+    pub retained_selected_observation_count: usize,
+    pub selected_observation_reuse_count: usize,
+    pub zero_residual_streamed_value_count: usize,
+    pub materialized_observation_vector_count: usize,
+    pub rational_string_materialization_count: usize,
+    pub rational_string_use_count: usize,
+    pub rational_string_reuse_count: usize,
+}
+
+impl RecurrenceEvidenceAuthenticationTelemetry {
+    fn checked_add(target: &mut usize, value: usize, description: &str) -> RusticolResult<()> {
+        *target = target
+            .checked_add(value)
+            .ok_or_else(|| invalid(format!("{description} exceeds usize")))?;
+        Ok(())
+    }
+
+    fn record_rational_string_uses(&mut self, count: usize) -> RusticolResult<()> {
+        Self::checked_add(
+            &mut self.rational_string_use_count,
+            count,
+            "evidence-authentication rational-string use count",
+        )
+    }
+
+    fn finish_rational_string_census(&mut self) -> RusticolResult<()> {
+        self.rational_string_reuse_count = self
+            .rational_string_use_count
+            .checked_sub(self.rational_string_materialization_count)
+            .ok_or_else(|| {
+                invalid(
+                    "evidence-authentication rational-string use count is below materialization count",
+                )
+            })?;
+        Ok(())
+    }
+}
+
+fn elapsed_nanoseconds(started: Instant) -> u64 {
+    u64::try_from(started.elapsed().as_nanos()).unwrap_or(u64::MAX)
+}
+
+#[derive(Clone, Debug)]
+struct AuthenticatedRuntimeParameterSlot {
+    default: BigRational,
+    probe_policy: &'static str,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct AuthenticatedRuntimeParameterContract {
+    schema: JsonValue,
+    schema_sha256: String,
+    slots: Vec<AuthenticatedRuntimeParameterSlot>,
+    process_id: String,
+    physical_pdgs: Vec<i32>,
+}
+
+#[derive(Clone, Debug)]
+struct RelationResiduals {
+    maximum_ratio: BigRational,
+    strings: RelationResidualStrings,
+}
+
+#[derive(Clone, Debug)]
+struct RelationResidualStrings {
+    maximum_absolute: String,
+    maximum_relative: String,
+    maximum_ratio: String,
+}
+
+pub(super) fn authenticated_runtime_parameter_contract(
+    process: &ValidatedRecurrenceProcessInput,
+    template: &ValidatedRecurrenceTemplateInput,
+) -> RusticolResult<AuthenticatedRuntimeParameterContract> {
+    const ABI: &str = "pyamplicol-recurrence-runtime-parameter-schema-v2";
+    const MATERIAL_POLICY: &str = "native-template-default-perturbed-v1";
+    const DERIVED_POLICY: &str = "derived-overwritten-fixed-zero-v1";
+    let input = process.input();
+    let parameter_contracts = template.parameter_kind_and_default_factors()?;
+    let mut parameters = Vec::with_capacity(input.parameter_projection.len());
+    let mut slots = Vec::with_capacity(input.parameter_projection.len());
+    for (index, row) in input.parameter_projection.iter().enumerate() {
+        if row.runtime_slot as usize != index {
+            return Err(invalid(
+                "authenticated runtime parameter projection is not dense",
+            ));
+        }
+        let range = input
+            .string_ranges
+            .get(row.runtime_name_string_id as usize)
+            .copied()
+            .ok_or_else(|| invalid("runtime-parameter name string range is absent"))?
+            .as_usize_range(
+                input.string_bytes.len(),
+                "runtime-parameter name string range",
+            )?;
+        let runtime_name = std::str::from_utf8(&input.string_bytes[range])
+            .map_err(|_| invalid("runtime-parameter name is not UTF-8"))?;
+        let (kind, default_factor) = parameter_contracts
+            .get(row.parameter_template_id as usize)
+            .copied()
+            .ok_or_else(|| invalid("runtime-parameter projection references an absent template"))?;
+        let (default, default_binary64, probe_policy) = if kind == ParameterKind::Derived {
+            (BigRational::zero(), 0.0_f64, DERIVED_POLICY)
+        } else {
+            let factor = default_factor.ok_or_else(|| {
+                invalid("material runtime parameter has no authenticated template default")
+            })?;
+            let exact = match row.component {
+                0 => factor.real(),
+                1 => factor.imag(),
+                _ => {
+                    return Err(invalid(
+                        "runtime-parameter component is not real or imaginary",
+                    ));
+                }
+            };
+            let rational = BigRational::new(
+                BigInt::from(exact.numerator()),
+                BigInt::from(exact.denominator()),
+            );
+            let binary64 = rational.to_f64().ok_or_else(|| {
+                invalid("authenticated runtime-parameter default is outside binary64")
+            })?;
+            if !binary64.is_finite() {
+                return Err(invalid(
+                    "authenticated runtime-parameter default is not finite binary64",
+                ));
+            }
+            (
+                exact_binary64_rational(binary64)?,
+                binary64,
+                MATERIAL_POLICY,
+            )
+        };
+        parameters.push(serde_json::json!({
+            "runtime_slot": row.runtime_slot,
+            "runtime_name": runtime_name,
+            "parameter_template_id": row.parameter_template_id,
+            "prepared_parameter_id": row.prepared_parameter_id(),
+            "component": row.component,
+            "default_binary64": python_f64_hex_signed(default_binary64),
+            "probe_policy": probe_policy,
+        }));
+        slots.push(AuthenticatedRuntimeParameterSlot {
+            default,
+            probe_policy,
+        });
+    }
+    let schema = serde_json::json!({
+        "abi": ABI,
+        "parameters": parameters,
+    });
+    let schema_sha256 =
+        canonical_json_sha256(&schema, "native recurrence runtime-parameter schema")?;
+    Ok(AuthenticatedRuntimeParameterContract {
+        schema,
+        schema_sha256,
+        slots,
+        process_id: process.summary().process_id().to_owned(),
+        physical_pdgs: input
+            .external_legs
+            .iter()
+            .map(|leg| leg.physical_pdg)
+            .collect(),
+    })
+}
+
+pub(super) fn parse_numerical_relation_evidence(
+    bytes: &[u8],
+    runtime_parameters: &AuthenticatedRuntimeParameterContract,
+) -> RusticolResult<RecurrenceNumericalRelationEvidence> {
+    parse_numerical_relation_evidence_with_telemetry(bytes, runtime_parameters)
+        .map(|(evidence, _telemetry)| evidence)
+}
+
+#[doc(hidden)]
+pub(super) fn parse_numerical_relation_evidence_with_telemetry(
+    bytes: &[u8],
+    runtime_parameters: &AuthenticatedRuntimeParameterContract,
+) -> RusticolResult<(
+    RecurrenceNumericalRelationEvidence,
+    RecurrenceEvidenceAuthenticationTelemetry,
+)> {
+    let total_started = Instant::now();
+    let mut telemetry = RecurrenceEvidenceAuthenticationTelemetry::default();
+    if bytes.is_empty() {
+        return Err(invalid("numerical relation evidence must not be empty"));
+    }
+    let evidence = if bytes.starts_with(COMPRESSED_EVIDENCE_MAGIC) {
+        let decode_started = Instant::now();
+        let decoded = decode_compressed_evidence(bytes)?;
+        telemetry.transport_decode_nanoseconds = elapsed_nanoseconds(decode_started);
+        parse_numerical_relation_evidence_v3(&decoded, runtime_parameters, &mut telemetry)?
+    } else {
+        parse_numerical_relation_evidence_v3(bytes, runtime_parameters, &mut telemetry)?
+    };
+    telemetry.total_nanoseconds = elapsed_nanoseconds(total_started);
+    Ok((evidence, telemetry))
+}
+
+fn parse_numerical_relation_evidence_v3(
+    bytes: &[u8],
+    runtime_parameters: &AuthenticatedRuntimeParameterContract,
+    telemetry: &mut RecurrenceEvidenceAuthenticationTelemetry,
+) -> RusticolResult<RecurrenceNumericalRelationEvidence> {
+    const ABI: &str = "pyamplicol-recurrence-numerical-current-evidence-v3";
+    const RELATION_SET_ABI: &str = "pyamplicol-authenticated-numerical-current-relation-set-v2";
+    validate_raw_json_lexical_structure(bytes)?;
+    let observation_ranges = locate_raw_observation_ranges(bytes)?;
+    let metadata_bytes = materialize_raw_observation_metadata(bytes, observation_ranges)?;
+    let located_observations = LocatedObservationArrays {
+        metadata_bytes,
+        candidate: observation_ranges.candidate,
+        verification: observation_ranges.verification,
+    };
+    let value: JsonValue = serde_json::from_slice(&located_observations.metadata_bytes)
+        .map_err(|error| invalid(format!("numerical relation evidence is not JSON: {error}")))?;
+    validate_canonical_json_bytes(
+        &value,
+        &located_observations.metadata_bytes,
+        "numerical relation evidence metadata",
+    )?;
+    let object = json_object(&value, "numerical relation evidence")?;
+    require_json_fields(
+        object,
+        &[
+            "abi",
+            "requested_mode",
+            "schedule_semantic_digest",
+            "baseline_runtime_layout_digest",
+            "source_semantics",
+            "source_semantics_sha256",
+            "runtime_parameter_schema",
+            "runtime_parameter_schema_sha256",
+            "candidate_capture",
+            "verification_capture",
+            "certificate_algorithm",
+            "certificate_set_sha256",
+            "precision_digits",
+            "probe_count",
+            "verification_probe_count",
+            "relative_tolerance_binary64",
+            "absolute_tolerance_binary64",
+            "seed",
+            "candidate_index",
+            "numerical_candidate_count",
+            "verification_rejected_count",
+            "rejected_hypothesis_count",
+            "tested_hypothesis_count",
+            "decision_sha256",
+            "rejection_decision_sha256",
+            "certificates",
+            "mappings",
+        ],
+        "numerical relation evidence",
+    )?;
+    require_json_string_value(object, "abi", ABI, "numerical relation evidence")?;
+    let requested_mode = RecurrenceRelationDiscoveryMode::parse(json_string(
+        object,
+        "requested_mode",
+        "numerical relation evidence mode",
+    )?)?;
+    if requested_mode == RecurrenceRelationDiscoveryMode::Off {
+        return Err(invalid("off mode cannot carry numerical relation evidence"));
+    }
+    let schedule_semantic_digest = evidence_sha256(
+        object,
+        "schedule_semantic_digest",
+        "numerical relation schedule digest",
+    )?;
+    let baseline_runtime_layout_digest = evidence_sha256(
+        object,
+        "baseline_runtime_layout_digest",
+        "numerical relation baseline layout digest",
+    )?;
+    let source_semantics_sha256 = evidence_sha256(
+        object,
+        "source_semantics_sha256",
+        "numerical relation source semantics",
+    )?;
+    let source = parse_raw_source_semantics(
+        json_field(object, "source_semantics", "numerical relation evidence")?,
+        &source_semantics_sha256,
+        &schedule_semantic_digest,
+        &baseline_runtime_layout_digest,
+        runtime_parameters,
+    )?;
+    let runtime_parameter_schema_sha256 = evidence_sha256(
+        object,
+        "runtime_parameter_schema_sha256",
+        "recurrence runtime parameter schema",
+    )?;
+    let runtime_parameter_count = validate_raw_runtime_parameter_schema(
+        json_field(
+            object,
+            "runtime_parameter_schema",
+            "numerical relation evidence",
+        )?,
+        &runtime_parameter_schema_sha256,
+        runtime_parameters,
+    )?;
+    let certificate_algorithm = json_nonempty_string(
+        object,
+        "certificate_algorithm",
+        "numerical relation certificate algorithm",
+    )?
+    .to_owned();
+    if certificate_algorithm != rusticol_core::recurrence::NUMERICAL_RELATION_CERTIFICATE_ALGORITHM
+    {
+        return Err(invalid(
+            "numerical relation evidence uses an unsupported certificate algorithm",
+        ));
+    }
+    let precision_digits = json_u32(object, "precision_digits", "numerical relation precision")?;
+    let probe_count = json_u32(
+        object,
+        "probe_count",
+        "numerical relation candidate probe count",
+    )?;
+    let verification_probe_count = json_u32(
+        object,
+        "verification_probe_count",
+        "numerical relation verification probe count",
+    )?;
+    raw_evidence_geometry_counts(
+        &source,
+        probe_count,
+        verification_probe_count,
+        runtime_parameter_count,
+    )?;
+    let relative_tolerance_hex = json_string(
+        object,
+        "relative_tolerance_binary64",
+        "numerical relation relative tolerance encoding",
+    )?;
+    let absolute_tolerance_hex = json_string(
+        object,
+        "absolute_tolerance_binary64",
+        "numerical relation absolute tolerance encoding",
+    )?;
+    let (relative_tolerance, relative_exact) = parse_nonnegative_python_f64_hex(
+        relative_tolerance_hex,
+        "numerical relation relative tolerance encoding",
+    )?;
+    let (absolute_tolerance, absolute_exact) = parse_nonnegative_python_f64_hex(
+        absolute_tolerance_hex,
+        "numerical relation absolute tolerance encoding",
+    )?;
+    if relative_tolerance == 0.0 && absolute_tolerance == 0.0 {
+        return Err(RusticolError::integrity(
+            "numerical relation tolerances cannot both be zero",
+        ));
+    }
+    if json_string(
+        object,
+        "relative_tolerance_binary64",
+        "numerical relation relative tolerance encoding",
+    )? != python_f64_hex(relative_tolerance)
+        || json_string(
+            object,
+            "absolute_tolerance_binary64",
+            "numerical relation absolute tolerance encoding",
+        )? != python_f64_hex(absolute_tolerance)
+    {
+        return Err(RusticolError::integrity(
+            "numerical relation tolerance encoding disagrees with its binary64 value",
+        ));
+    }
+    let seed = json_u64(object, "seed", "numerical relation seed")?;
+    let capture_authentication_started = Instant::now();
+    let candidate = parse_raw_numerical_capture(
+        bytes,
+        located_observations.candidate,
+        json_field(object, "candidate_capture", "numerical relation evidence")?,
+        "candidate",
+        "candidate-current-probes-v1",
+        precision_digits,
+        probe_count,
+        &source,
+        &source_semantics_sha256,
+        &runtime_parameter_schema_sha256,
+        runtime_parameter_count,
+        seed,
+    )?;
+    let verification = parse_raw_numerical_capture(
+        bytes,
+        located_observations.verification,
+        json_field(
+            object,
+            "verification_capture",
+            "numerical relation evidence",
+        )?,
+        "verification",
+        "independent-verification-current-probes-v1",
+        precision_digits,
+        verification_probe_count,
+        &source,
+        &source_semantics_sha256,
+        &runtime_parameter_schema_sha256,
+        runtime_parameter_count,
+        seed,
+    )?;
+    validate_independent_raw_captures(&candidate, &verification, runtime_parameters, seed)?;
+    telemetry.capture_authentication_nanoseconds =
+        elapsed_nanoseconds(capture_authentication_started);
+
+    let derivation = derive_raw_numerical_relations(
+        &source,
+        &candidate,
+        &verification,
+        precision_digits,
+        seed,
+        &relative_exact,
+        &absolute_exact,
+        json_string(
+            object,
+            "relative_tolerance_binary64",
+            "numerical relation relative tolerance encoding",
+        )?,
+        json_string(
+            object,
+            "absolute_tolerance_binary64",
+            "numerical relation absolute tolerance encoding",
+        )?,
+        &runtime_parameter_schema_sha256,
+        &certificate_algorithm,
+        telemetry,
+    )?;
+    let evidence_finalization_started = Instant::now();
+    let supplied_decision_sha256 = evidence_sha256(
+        object,
+        "decision_sha256",
+        "numerical relation decision chain",
+    )?;
+    if supplied_decision_sha256 != derivation.decision_sha256 {
+        return Err(RusticolError::integrity(format!(
+            "numerical relation decision digest was not derived from every raw hypothesis: \
+             supplied {supplied_decision_sha256}, derived {}",
+            derivation.decision_sha256
+        )));
+    }
+    let supplied_rejection_sha256 = evidence_sha256(
+        object,
+        "rejection_decision_sha256",
+        "numerical relation rejection decision chain",
+    )?;
+    if supplied_rejection_sha256 != derivation.rejection_decision_sha256 {
+        return Err(RusticolError::integrity(
+            "numerical relation rejection digest was not derived from every rejected raw hypothesis",
+        ));
+    }
+    for (field, expected) in [
+        (
+            "numerical_candidate_count",
+            derivation.numerical_candidate_count,
+        ),
+        (
+            "verification_rejected_count",
+            derivation.verification_rejected_count,
+        ),
+        (
+            "tested_hypothesis_count",
+            derivation.tested_hypothesis_count,
+        ),
+        (
+            "rejected_hypothesis_count",
+            derivation.rejected_hypothesis_count,
+        ),
+    ] {
+        if evidence_usize(object, field, "numerical relation evidence counter")? != expected {
+            return Err(RusticolError::integrity(format!(
+                "numerical relation evidence {field} was not derived from raw observations"
+            )));
+        }
+    }
+    validate_candidate_index_claim(
+        json_field(object, "candidate_index", "numerical relation evidence")?,
+        &derivation,
+    )?;
+    let supplied_certificates =
+        json_array(object, "certificates", "numerical relation certificates")?;
+    let supplied_mappings = json_array(object, "mappings", "numerical relation mappings")?;
+    let derived_certificates = derivation
+        .relations
+        .iter()
+        .map(|relation| relation.certificate.clone())
+        .collect::<Vec<_>>();
+    let derived_mappings = derivation
+        .relations
+        .iter()
+        .map(|relation| relation.mapping_json.clone())
+        .collect::<Vec<_>>();
+    if supplied_certificates != derived_certificates || supplied_mappings != derived_mappings {
+        return Err(RusticolError::integrity(
+            "numerical relation certificates or mappings were not derived from raw observations",
+        ));
+    }
+    let relation_set = serde_json::json!({
+        "abi": RELATION_SET_ABI,
+        "certificates": derived_certificates,
+        "mappings": derived_mappings,
+    });
+    let actual_certificate_set_sha256 =
+        canonical_json_sha256(&relation_set, "numerical relation certificate set")?;
+    let certificate_set_sha256 = evidence_sha256(
+        object,
+        "certificate_set_sha256",
+        "numerical relation certificate set",
+    )?;
+    if certificate_set_sha256 != actual_certificate_set_sha256 {
+        return Err(RusticolError::integrity(
+            "numerical relation certificate-set digest does not match native raw-evidence replay",
+        ));
+    }
+    let evidence = RecurrenceNumericalRelationEvidence {
+        requested_mode,
+        schedule_semantic_digest,
+        baseline_runtime_layout_digest,
+        source_semantics_sha256,
+        runtime_parameter_schema_sha256,
+        candidate_observation_batch_sha256: candidate.observation_batch_sha256,
+        verification_observation_batch_sha256: verification.observation_batch_sha256,
+        decision_sha256: derivation.decision_sha256,
+        rejection_decision_sha256: derivation.rejection_decision_sha256,
+        certificate_algorithm,
+        certificate_set_sha256,
+        precision_digits,
+        probe_count,
+        verification_probe_count,
+        relative_tolerance,
+        absolute_tolerance,
+        seed,
+        numerical_candidate_count: derivation.numerical_candidate_count,
+        verification_rejected_count: derivation.verification_rejected_count,
+        rejected_hypothesis_count: derivation.rejected_hypothesis_count,
+        tested_hypothesis_count: derivation.tested_hypothesis_count,
+        mappings: derivation
+            .relations
+            .into_iter()
+            .map(|relation| relation.mapping)
+            .collect(),
+    };
+    telemetry.evidence_finalization_nanoseconds =
+        elapsed_nanoseconds(evidence_finalization_started);
+    Ok(evidence)
+}
+
+fn parse_raw_source_semantics(
+    value: &JsonValue,
+    claimed_sha256: &str,
+    schedule_semantic_digest: &str,
+    baseline_runtime_layout_digest: &str,
+    authenticated_process: &AuthenticatedRuntimeParameterContract,
+) -> RusticolResult<RawSourceSemantics> {
+    const ABI: &str = "pyamplicol-recurrence-numerical-current-source-v3";
+    let object = json_object(value, "recurrence numerical source semantics")?;
+    require_json_fields(
+        object,
+        &[
+            "abi",
+            "process_id",
+            "strategy",
+            "schedule_semantic_digest",
+            "baseline_runtime_layout_digest",
+            "selector_schedule",
+            "currents",
+        ],
+        "recurrence numerical source semantics",
+    )?;
+    require_json_string_value(object, "abi", ABI, "recurrence numerical source semantics")?;
+    if canonical_json_sha256(value, "recurrence numerical source semantics")? != claimed_sha256 {
+        return Err(RusticolError::integrity(
+            "recurrence numerical source-semantics digest does not match its raw payload",
+        ));
+    }
+    require_json_string_value(
+        object,
+        "schedule_semantic_digest",
+        schedule_semantic_digest,
+        "recurrence numerical source semantics",
+    )?;
+    require_json_string_value(
+        object,
+        "baseline_runtime_layout_digest",
+        baseline_runtime_layout_digest,
+        "recurrence numerical source semantics",
+    )?;
+    require_json_string_value(
+        object,
+        "process_id",
+        &authenticated_process.process_id,
+        "recurrence numerical source semantics",
+    )?;
+    if authenticated_process.physical_pdgs.is_empty() {
+        return Err(invalid(
+            "authenticated recurrence process has no physical external particles",
+        ));
+    }
+    let strategy =
+        json_nonempty_string(object, "strategy", "recurrence numerical source semantics")?
+            .to_owned();
+    if !matches!(
+        strategy.as_str(),
+        "topology-replay" | "all-flow-union" | "contracted-color-union"
+    ) {
+        return Err(invalid("raw recurrence source has an unsupported strategy"));
+    }
+    let current_values = json_array(object, "currents", "recurrence numerical source currents")?;
+    let mut currents = Vec::with_capacity(current_values.len());
+    for (index, current_value) in current_values.iter().enumerate() {
+        let context = format!("recurrence numerical source current {index}");
+        let current = json_object(current_value, &context)?;
+        require_json_fields(current, &["current_id", "is_source", "contract"], &context)?;
+        let current_id = json_u32(current, "current_id", &context)?;
+        if current_id as usize != index {
+            return Err(invalid(format!(
+                "{context} has non-canonical current ID {current_id}"
+            )));
+        }
+        let is_source = json_field(current, "is_source", &context)?
+            .as_bool()
+            .ok_or_else(|| invalid(format!("{context} source flag is not boolean")))?;
+        let contract = json_field(current, "contract", &context)?.clone();
+        let contract_values = contract
+            .as_array()
+            .ok_or_else(|| invalid(format!("{context} contract is not an array")))?;
+        if contract_values.len() != 9 {
+            return Err(invalid(format!("{context} contract width is not nine")));
+        }
+        let dimension_u64 = contract_values[3]
+            .as_u64()
+            .ok_or_else(|| invalid(format!("{context} dimension is not unsigned")))?;
+        let dimension = u16::try_from(dimension_u64)
+            .map_err(|_| invalid(format!("{context} dimension exceeds u16")))?;
+        if dimension == 0 {
+            return Err(invalid(format!("{context} dimension is zero")));
+        }
+        let selector_domain_id = contract_values[5]
+            .as_u64()
+            .and_then(|value| u32::try_from(value).ok())
+            .ok_or_else(|| invalid(format!("{context} selector domain is not u32")))?;
+        currents.push(RawSourceCurrent {
+            current_id,
+            is_source,
+            contract_key: canonical_json_bytes(&contract, &context)?,
+            dimension,
+            selector_domain_id,
+        });
+    }
+    Ok(RawSourceSemantics {
+        value: value.clone(),
+        process_id: authenticated_process.process_id.clone(),
+        physical_pdgs: authenticated_process.physical_pdgs.clone(),
+        strategy,
+        selector_schedule: json_field(
+            object,
+            "selector_schedule",
+            "recurrence numerical source semantics",
+        )?
+        .clone(),
+        currents,
+    })
+}
+
+fn validate_candidate_index_claim(
+    value: &JsonValue,
+    derivation: &RawNumericalDerivation,
+) -> RusticolResult<()> {
+    const ALGORITHM: &str = "complete-contract-anchor-tolerance-window-v1";
+    let object = json_object(value, "raw numerical candidate index")?;
+    require_json_fields(
+        object,
+        &[
+            "algorithm",
+            "completeness",
+            "contract_count",
+            "exhaustive_fallback_contract_count",
+            "theoretical_pair_hypothesis_count",
+            "screened_pair_hypothesis_count",
+            "zero_hypothesis_count",
+            "nearest_rejected_scope",
+        ],
+        "raw numerical candidate index",
+    )?;
+    require_json_string_value(
+        object,
+        "algorithm",
+        ALGORITHM,
+        "raw numerical candidate index",
+    )?;
+    require_json_string_value(
+        object,
+        "completeness",
+        "complete-within-configured-tolerance",
+        "raw numerical candidate index",
+    )?;
+    require_json_string_value(
+        object,
+        "nearest_rejected_scope",
+        "zero-and-tolerance-window-screened-hypotheses",
+        "raw numerical candidate index",
+    )?;
+    for (field, expected) in [
+        ("contract_count", derivation.candidate_index_contract_count),
+        (
+            "exhaustive_fallback_contract_count",
+            derivation.exhaustive_fallback_contract_count,
+        ),
+        (
+            "theoretical_pair_hypothesis_count",
+            derivation.theoretical_pair_hypothesis_count,
+        ),
+        (
+            "screened_pair_hypothesis_count",
+            derivation.screened_pair_hypothesis_count,
+        ),
+        ("zero_hypothesis_count", derivation.zero_hypothesis_count),
+    ] {
+        if evidence_usize(object, field, "raw numerical candidate index")? != expected {
+            return Err(RusticolError::integrity(format!(
+                "raw numerical candidate index {field} was not independently derived"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn raw_evidence_geometry_counts(
+    source: &RawSourceSemantics,
+    probe_count: u32,
+    verification_probe_count: u32,
+    runtime_parameter_count: usize,
+) -> RusticolResult<(usize, usize, usize, usize)> {
+    let current_count = source.currents.len();
+    let row_count = source
+        .currents
+        .len()
+        .checked_mul(2)
+        .and_then(|count| count.checked_add(runtime_parameter_count))
+        .ok_or_else(|| invalid("raw numerical row count overflows usize"))?;
+    let component_count = source.currents.iter().try_fold(0_usize, |total, current| {
+        total
+            .checked_add(usize::from(current.dimension))
+            .ok_or_else(|| invalid("raw numerical component count overflows usize"))
+    })?;
+    let point_count = usize::try_from(probe_count)
+        .ok()
+        .and_then(|candidate| {
+            usize::try_from(verification_probe_count)
+                .ok()
+                .and_then(|verification| candidate.checked_add(verification))
+        })
+        .ok_or_else(|| invalid("raw numerical probe count overflows usize"))?;
+    let observation_scalar_count = component_count
+        .checked_mul(point_count)
+        .and_then(|count| count.checked_mul(2))
+        .ok_or_else(|| invalid("raw numerical scalar count overflows usize"))?;
+    let parameter_scalar_count = runtime_parameter_count
+        .checked_mul(point_count)
+        .ok_or_else(|| invalid("raw parameter scalar count overflows usize"))?;
+    let scalar_count = observation_scalar_count
+        .checked_add(parameter_scalar_count)
+        .ok_or_else(|| invalid("raw total scalar count overflows usize"))?;
+    Ok((current_count, component_count, scalar_count, row_count))
+}
+
+fn validate_raw_runtime_parameter_schema(
+    value: &JsonValue,
+    claimed_sha256: &str,
+    expected: &AuthenticatedRuntimeParameterContract,
+) -> RusticolResult<usize> {
+    if value != &expected.schema || claimed_sha256 != expected.schema_sha256 {
+        return Err(RusticolError::integrity(
+            "recurrence runtime parameter schema/defaults do not match the authenticated native template input",
+        ));
+    }
+    Ok(expected.slots.len())
+}
+
+fn canonical_json_sha256_with_raw_arrays(
+    value: &JsonValue,
+    raw_arrays: &[(&str, &[u8])],
+    context: &str,
+) -> RusticolResult<String> {
+    let canonical = canonical_json_bytes(value, context)?;
+    let mut replacements = Vec::with_capacity(raw_arrays.len());
+    let mut names = BTreeSet::new();
+    for (placeholder, raw_array) in raw_arrays {
+        if !names.insert(*placeholder) {
+            return Err(invalid(format!(
+                "{context} raw-array placeholder is duplicated"
+            )));
+        }
+        let encoded_placeholder = canonical_json_bytes(
+            &serde_json::json!([placeholder]),
+            &format!("{context} raw-array placeholder"),
+        )?;
+        let mut matches = canonical
+            .windows(encoded_placeholder.len())
+            .enumerate()
+            .filter_map(|(index, window)| (window == encoded_placeholder).then_some(index));
+        let start = matches
+            .next()
+            .ok_or_else(|| invalid(format!("{context} has no raw-array placeholder")))?;
+        if matches.next().is_some() {
+            return Err(invalid(format!(
+                "{context} raw-array placeholder is ambiguous"
+            )));
+        }
+        let end = start
+            .checked_add(encoded_placeholder.len())
+            .ok_or_else(|| invalid(format!("{context} placeholder range overflows usize")))?;
+        replacements.push((start, end, *raw_array));
+    }
+    replacements.sort_by_key(|replacement| replacement.0);
+    let mut digest = Sha256::new();
+    let mut cursor = 0;
+    for (start, end, raw_array) in replacements {
+        if start < cursor {
+            return Err(invalid(format!("{context} raw-array placeholders overlap")));
+        }
+        digest.update(&canonical[cursor..start]);
+        digest.update(raw_array);
+        cursor = end;
+    }
+    digest.update(&canonical[cursor..]);
+    Ok(hex_digest(digest.finalize()))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn observation_batch_sha256_from_raw(
+    raw_bytes: &[u8],
+    observation_array: RawByteRange,
+    source_semantics_sha256: &str,
+    runtime_parameter_schema_sha256: &str,
+    point_sha256s: &[String],
+    selector_context_sha256s: &[String],
+    parameter_context_sha256s: &[String],
+    batch_abi: &str,
+    context: &str,
+) -> RusticolResult<String> {
+    const PLACEHOLDER: &str = "__pyamplicol_authenticated_raw_array_placeholder__";
+    let range = observation_array.as_usize(raw_bytes.len(), context)?;
+    let raw_array = raw_bytes
+        .get(range)
+        .ok_or_else(|| invalid(format!("{context} raw observation array is absent")))?;
+    canonical_json_sha256_with_raw_arrays(
+        &serde_json::json!({
+            "abi": batch_abi,
+            "source_semantics_sha256": source_semantics_sha256,
+            "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+            "point_sha256s": point_sha256s,
+            "selector_context_sha256s": selector_context_sha256s,
+            "parameter_context_sha256s": parameter_context_sha256s,
+            "currents": [PLACEHOLDER],
+        }),
+        &[(PLACEHOLDER, raw_array)],
+        context,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn parse_raw_numerical_capture<'a>(
+    raw_bytes: &'a [u8],
+    observation_array: RawByteRange,
+    value: &JsonValue,
+    label: &str,
+    domain: &str,
+    precision_digits: u32,
+    expected_point_count: u32,
+    source: &RawSourceSemantics,
+    source_semantics_sha256: &str,
+    runtime_parameter_schema_sha256: &str,
+    runtime_parameter_count: usize,
+    seed: u64,
+) -> RusticolResult<RawNumericalCapture<'a>> {
+    const ABI: &str = "pyamplicol-recurrence-current-observation-capture-v2";
+    const BATCH_ABI: &str = "pyamplicol-recurrence-current-observation-batch-v2";
+    const PARAMETER_CONTEXT_ABI: &str = "pyamplicol-recurrence-parameter-context-v1";
+    let context = format!("{label} raw numerical capture");
+    let object = json_object(value, &context)?;
+    require_json_fields(
+        object,
+        &[
+            "abi",
+            "precision_digits",
+            "point_count",
+            "point_sha256s",
+            "kinematic_sha256s",
+            "parameter_contexts",
+            "parameter_context_sha256s",
+            "context_sha256s",
+            "points",
+            "current_count",
+            "runtime_parameter_schema_sha256",
+            "source_semantics_sha256",
+            "observation_batch_sha256",
+            "capture_contract_sha256",
+            "context_policy",
+            "complete_current_components",
+            "point_major",
+            "current_dimensions_sha256",
+            "evaluator",
+            "kinematic_binary64",
+            "selector_contexts",
+            "current_dimensions",
+            "observations",
+        ],
+        &context,
+    )?;
+    require_json_string_value(object, "abi", ABI, &context)?;
+    if json_u32(object, "precision_digits", &context)? != precision_digits
+        || json_u32(object, "point_count", &context)? != expected_point_count
+        || expected_point_count < 2
+    {
+        return Err(invalid(format!("{context} probe geometry is inconsistent")));
+    }
+    require_json_string_value(
+        object,
+        "runtime_parameter_schema_sha256",
+        runtime_parameter_schema_sha256,
+        &context,
+    )?;
+    require_json_string_value(
+        object,
+        "source_semantics_sha256",
+        source_semantics_sha256,
+        &context,
+    )?;
+    require_json_string_value(
+        object,
+        "evaluator",
+        "recurrence-direct-plan-decimal-symbolica-exact",
+        &context,
+    )?;
+    if !json_bool(object, "complete_current_components", &context)?
+        || !json_bool(object, "point_major", &context)?
+    {
+        return Err(invalid(format!(
+            "{context} does not contain complete point-major current components"
+        )));
+    }
+    let expected_policy = match source.strategy.as_str() {
+        "topology-replay" => "seeded-replay-target-per-physical-point-v1",
+        "all-flow-union" => "seeded-helicity-per-selector-domain-and-physical-point-v1",
+        "contracted-color-union" => "fixed-contracted-source-schedule-v1",
+        _ => return Err(invalid("raw recurrence source strategy is unsupported")),
+    };
+    require_json_string_value(object, "context_policy", expected_policy, &context)?;
+
+    let point_values = json_array(object, "points", &context)?;
+    let point_sha256s = parse_sha256_array(object, "point_sha256s", &context)?;
+    let kinematic_values = json_array(object, "kinematic_binary64", &context)?;
+    let kinematic_sha256s = parse_sha256_array(object, "kinematic_sha256s", &context)?;
+    let selector_contexts = json_array(object, "selector_contexts", &context)?;
+    let selector_context_sha256s = parse_sha256_array(object, "context_sha256s", &context)?;
+    let parameter_values = json_array(object, "parameter_contexts", &context)?;
+    let parameter_context_sha256s =
+        parse_sha256_array(object, "parameter_context_sha256s", &context)?;
+    let point_count = expected_point_count as usize;
+    if [
+        point_values.len(),
+        point_sha256s.len(),
+        kinematic_values.len(),
+        kinematic_sha256s.len(),
+        selector_contexts.len(),
+        selector_context_sha256s.len(),
+        parameter_values.len(),
+        parameter_context_sha256s.len(),
+    ]
+    .into_iter()
+    .any(|count| count != point_count)
+    {
+        return Err(invalid(format!(
+            "{context} does not cover every ordered probe slot"
+        )));
+    }
+    if point_sha256s.iter().collect::<BTreeSet<_>>().len() != point_count
+        || kinematic_sha256s.iter().collect::<BTreeSet<_>>().len() != point_count
+    {
+        return Err(invalid(format!(
+            "{context} physical probes are not distinct"
+        )));
+    }
+
+    let mut parameter_contexts = Vec::with_capacity(point_count);
+    for point_index in 0..point_count {
+        let point_context = format!("{context} point {point_index}");
+        let actual_point_sha256 = canonical_json_sha256(
+            &point_values[point_index],
+            &format!("{point_context} record"),
+        )?;
+        if point_sha256s[point_index] != actual_point_sha256 {
+            return Err(RusticolError::integrity(format!(
+                "{point_context} digest does not match its raw point"
+            )));
+        }
+        validate_raw_kinematic(
+            &point_values[point_index],
+            &kinematic_values[point_index],
+            source,
+            domain_seed(seed, domain, point_index),
+            &point_context,
+        )?;
+        let actual_kinematic_sha256 = canonical_json_sha256(
+            &kinematic_values[point_index],
+            &format!("{point_context} binary64 kinematics"),
+        )?;
+        if kinematic_sha256s[point_index] != actual_kinematic_sha256 {
+            return Err(RusticolError::integrity(format!(
+                "{point_context} kinematic digest does not match its raw binary64 values"
+            )));
+        }
+        let expected_selector = expected_selector_context(source, seed, domain, point_index)?;
+        if selector_contexts[point_index] != expected_selector
+            || selector_context_sha256s[point_index]
+                != canonical_json_sha256(&expected_selector, &format!("{point_context} selector"))?
+        {
+            return Err(RusticolError::integrity(format!(
+                "{point_context} selector context is stale or non-deterministic"
+            )));
+        }
+        let raw_parameters = parameter_values[point_index]
+            .as_array()
+            .ok_or_else(|| invalid(format!("{point_context} parameters are not an array")))?;
+        if raw_parameters.len() != runtime_parameter_count {
+            return Err(invalid(format!(
+                "{point_context} parameters do not cover every runtime slot"
+            )));
+        }
+        let parsed_parameters = raw_parameters
+            .iter()
+            .enumerate()
+            .map(|(slot, value)| {
+                let text = value.as_str().ok_or_else(|| {
+                    invalid(format!("{point_context} parameter {slot} is not a string"))
+                })?;
+                parse_canonical_decimal(text, &format!("{point_context} parameter {slot}"))
+            })
+            .collect::<RusticolResult<Vec<_>>>()?;
+        let parameter_payload = serde_json::json!({
+            "abi": PARAMETER_CONTEXT_ABI,
+            "domain": domain,
+            "point_index": point_index,
+            "point_sha256": point_sha256s[point_index],
+            "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+            "values": raw_parameters,
+        });
+        if parameter_context_sha256s[point_index]
+            != canonical_json_sha256(
+                &parameter_payload,
+                &format!("{point_context} parameter context"),
+            )?
+        {
+            return Err(RusticolError::integrity(format!(
+                "{point_context} parameter-context digest does not match its raw values"
+            )));
+        }
+        parameter_contexts.push(parsed_parameters);
+    }
+
+    let dimension_values = json_array(object, "current_dimensions", &context)?;
+    if dimension_values.len() != source.currents.len()
+        || json_u32(object, "current_count", &context)? as usize != source.currents.len()
+    {
+        return Err(invalid(format!(
+            "{context} current census does not match source semantics"
+        )));
+    }
+    let observation_rows =
+        scan_raw_observation_array(raw_bytes, observation_array, source, point_count, label)?;
+    let mut dimensions = Vec::with_capacity(source.currents.len());
+    for (index, source_current) in source.currents.iter().enumerate() {
+        let row_context = format!("{context} current {index}");
+        let dimension_row = json_object(&dimension_values[index], &row_context)?;
+        require_json_fields(dimension_row, &["current_id", "dimension"], &row_context)?;
+        let current_id = json_u32(dimension_row, "current_id", &row_context)?;
+        let dimension = json_u32(dimension_row, "dimension", &row_context)?;
+        if current_id != source_current.current_id
+            || dimension != u32::from(source_current.dimension)
+        {
+            return Err(invalid(format!(
+                "{row_context} dimension or ID disagrees with source semantics"
+            )));
+        }
+        dimensions.push(source_current.dimension);
+    }
+    let dimensions_object = dimensions
+        .iter()
+        .enumerate()
+        .map(|(current_id, dimension)| {
+            (
+                current_id.to_string(),
+                JsonValue::from(u64::from(*dimension)),
+            )
+        })
+        .collect::<JsonMap<_, _>>();
+    if evidence_sha256(object, "current_dimensions_sha256", &context)?
+        != canonical_json_sha256(
+            &JsonValue::Object(dimensions_object),
+            &format!("{context} dimensions"),
+        )?
+    {
+        return Err(RusticolError::integrity(format!(
+            "{context} dimension digest does not match the raw census"
+        )));
+    }
+    let observation_batch_sha256 = evidence_sha256(object, "observation_batch_sha256", &context)?;
+    if observation_batch_sha256
+        != observation_batch_sha256_from_raw(
+            raw_bytes,
+            observation_array,
+            source_semantics_sha256,
+            runtime_parameter_schema_sha256,
+            &point_sha256s,
+            &selector_context_sha256s,
+            &parameter_context_sha256s,
+            BATCH_ABI,
+            &format!("{context} observation batch"),
+        )?
+    {
+        return Err(RusticolError::integrity(format!(
+            "{context} observation-batch digest does not match raw observations"
+        )));
+    }
+    let capture_contract_sha256 = evidence_sha256(object, "capture_contract_sha256", &context)?;
+    let capture_payload = serde_json::json!({
+        "abi": ABI,
+        "precision_digits": precision_digits,
+        "source_semantics_sha256": source_semantics_sha256,
+        "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+        "point_sha256s": point_sha256s,
+        "kinematic_sha256s": kinematic_sha256s,
+        "selector_context_sha256s": selector_context_sha256s,
+        "parameter_context_sha256s": parameter_context_sha256s,
+        "current_dimensions": dimension_values,
+        "observation_batch_sha256": observation_batch_sha256,
+        "context_policy": expected_policy,
+    });
+    if capture_contract_sha256
+        != canonical_json_sha256(&capture_payload, &format!("{context} contract"))?
+    {
+        return Err(RusticolError::integrity(format!(
+            "{context} contract digest does not match raw capture"
+        )));
+    }
+    Ok(RawNumericalCapture {
+        raw_bytes,
+        observation_rows,
+        point_count,
+        point_sha256s,
+        kinematic_sha256s,
+        parameter_context_sha256s,
+        parameter_contexts,
+        dimensions,
+        observation_batch_sha256,
+        capture_contract_sha256,
+    })
+}
+
+fn parse_sha256_array(
+    object: &JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<Vec<String>> {
+    json_array(object, field, context)?
+        .iter()
+        .enumerate()
+        .map(|(index, value)| {
+            let text = value
+                .as_str()
+                .ok_or_else(|| invalid(format!("{context} {field}[{index}] is not a string")))?;
+            semantic_digest_from_hex(text, &format!("{context} {field}[{index}]"))?;
+            Ok(text.to_owned())
+        })
+        .collect()
+}
+
+fn validate_raw_kinematic(
+    point: &JsonValue,
+    kinematic: &JsonValue,
+    source: &RawSourceSemantics,
+    expected_seed: u64,
+    context: &str,
+) -> RusticolResult<()> {
+    let point_object = json_object(point, &format!("{context} point record"))?;
+    require_json_fields(
+        point_object,
+        &[
+            "schema_version",
+            "kind",
+            "process_id",
+            "process",
+            "seed",
+            "available",
+            "error",
+            "points",
+        ],
+        &format!("{context} point record"),
+    )?;
+    if json_u32(point_object, "schema_version", context)? != 1
+        || json_string(point_object, "kind", context)? != "pyamplicol-rusticol-validation-momenta"
+        || !json_bool(point_object, "available", context)?
+        || !json_field(point_object, "error", context)?.is_null()
+    {
+        return Err(invalid(format!(
+            "{context} validation point is unavailable"
+        )));
+    }
+    require_json_string_value(point_object, "process_id", &source.process_id, context)?;
+    json_nonempty_string(point_object, "process", context)?;
+    if json_u64(point_object, "seed", context)? != expected_seed {
+        return Err(RusticolError::integrity(format!(
+            "{context} validation-point seed is stale"
+        )));
+    }
+    let point_sets = json_array(point_object, "points", context)?;
+    if point_sets.len() != 1 {
+        return Err(invalid(format!(
+            "{context} validation point must contain one momentum set"
+        )));
+    }
+    let particles = point_sets[0]
+        .as_array()
+        .ok_or_else(|| invalid(format!("{context} particle set is not an array")))?;
+    let kinematic_rows = kinematic
+        .as_array()
+        .ok_or_else(|| invalid(format!("{context} kinematics are not an array")))?;
+    if particles.len() != kinematic_rows.len()
+        || particles.len() != source.physical_pdgs.len()
+        || particles.is_empty()
+    {
+        return Err(invalid(format!(
+            "{context} point, process, and binary64 kinematic widths disagree"
+        )));
+    }
+    for (particle_index, ((particle, raw_row), expected_pdg)) in particles
+        .iter()
+        .zip(kinematic_rows)
+        .zip(&source.physical_pdgs)
+        .enumerate()
+    {
+        let particle_context = format!("{context} particle {particle_index}");
+        let particle = json_object(particle, &particle_context)?;
+        require_json_fields(particle, &["pdg", "momentum"], &particle_context)?;
+        let actual_pdg = particle
+            .get("pdg")
+            .and_then(JsonValue::as_i64)
+            .and_then(|value| i32::try_from(value).ok())
+            .ok_or_else(|| invalid(format!("{particle_context} PDG is not an i32")))?;
+        if actual_pdg != *expected_pdg {
+            return Err(RusticolError::integrity(format!(
+                "{particle_context} PDG does not match the authenticated recurrence process"
+            )));
+        }
+        let momentum = json_array(particle, "momentum", &particle_context)?;
+        let binary = raw_row
+            .as_array()
+            .filter(|row| row.len() == 4)
+            .ok_or_else(|| {
+                invalid(format!(
+                    "{particle_context} binary64 momentum is not four-wide"
+                ))
+            })?;
+        if momentum.len() != 4 {
+            return Err(invalid(format!(
+                "{particle_context} decimal momentum is not four-wide"
+            )));
+        }
+        for component in 0..4 {
+            let decimal = momentum[component].as_str().ok_or_else(|| {
+                invalid(format!(
+                    "{particle_context} momentum component {component} is not a string"
+                ))
+            })?;
+            parse_canonical_decimal(
+                decimal,
+                &format!("{particle_context} momentum component {component}"),
+            )?;
+            let binary_value = decimal.parse::<f64>().map_err(|_| {
+                invalid(format!(
+                    "{particle_context} momentum component {component} is not binary64"
+                ))
+            })?;
+            if !binary_value.is_finite()
+                || binary[component].as_str() != Some(python_f64_hex_signed(binary_value).as_str())
+            {
+                return Err(RusticolError::integrity(format!(
+                    "{particle_context} decimal and binary64 momentum disagree at component {component}"
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn all_flow_selector_domain_helicities(
+    source: &RawSourceSemantics,
+) -> RusticolResult<BTreeMap<u32, Vec<(usize, u32)>>> {
+    let schedule = json_object(
+        &source.selector_schedule,
+        "recurrence numerical selector schedule",
+    )?;
+    require_json_fields(
+        schedule,
+        &["policy", "resolved_helicities"],
+        "recurrence union selector schedule",
+    )?;
+    require_json_string_value(
+        schedule,
+        "policy",
+        "seeded-helicity-per-selector-domain-and-physical-point-v1",
+        "recurrence union selector schedule",
+    )?;
+    let helicities = json_array(
+        schedule,
+        "resolved_helicities",
+        "recurrence union selector schedule",
+    )?;
+    let mut by_domain = BTreeMap::<u32, Vec<(usize, u32)>>::new();
+    for (index, value) in helicities.iter().enumerate() {
+        let helicity = json_object(value, "recurrence resolved helicity")?;
+        require_json_fields(
+            helicity,
+            &["helicity_index", "helicity_id", "selector_domain_id"],
+            "recurrence resolved helicity",
+        )?;
+        if json_u32(helicity, "helicity_index", "recurrence resolved helicity")? as usize != index {
+            return Err(invalid(
+                "recurrence resolved-helicity index is not canonical",
+            ));
+        }
+        by_domain
+            .entry(json_u32(
+                helicity,
+                "selector_domain_id",
+                "recurrence resolved helicity",
+            )?)
+            .or_default()
+            .push((
+                index,
+                json_u32(helicity, "helicity_id", "recurrence resolved helicity")?,
+            ));
+    }
+    if by_domain.is_empty() {
+        return Err(invalid("recurrence union selector schedule is empty"));
+    }
+    Ok(by_domain)
+}
+
+fn expected_selector_context(
+    source: &RawSourceSemantics,
+    seed: u64,
+    domain: &str,
+    point_index: usize,
+) -> RusticolResult<JsonValue> {
+    let selector_seed = domain_seed(seed, domain, point_index);
+    match source.strategy.as_str() {
+        "topology-replay" => {
+            let schedule = json_object(
+                &source.selector_schedule,
+                "recurrence numerical selector schedule",
+            )?;
+            require_json_fields(
+                schedule,
+                &["policy", "replay_targets"],
+                "recurrence topology selector schedule",
+            )?;
+            require_json_string_value(
+                schedule,
+                "policy",
+                "seeded-replay-target-per-physical-point-v1",
+                "recurrence topology selector schedule",
+            )?;
+            let targets = json_array(
+                schedule,
+                "replay_targets",
+                "recurrence topology selector schedule",
+            )?;
+            if targets.is_empty() {
+                return Err(invalid("recurrence topology selector schedule is empty"));
+            }
+            let target_index = selector_seed as usize % targets.len();
+            let target = json_object(&targets[target_index], "recurrence replay target")?;
+            require_json_fields(
+                target,
+                &[
+                    "target_index",
+                    "public_flow_id",
+                    "representative_id",
+                    "selector_domain_id",
+                ],
+                "recurrence replay target",
+            )?;
+            if json_u32(target, "target_index", "recurrence replay target")? as usize
+                != target_index
+            {
+                return Err(invalid("recurrence replay target index is not canonical"));
+            }
+            Ok(serde_json::json!({
+                "strategy": source.strategy,
+                "target_index": target_index,
+                "public_flow_id": json_u32(target, "public_flow_id", "recurrence replay target")?,
+                "representative_id": json_u32(target, "representative_id", "recurrence replay target")?,
+                "selector_domain_id": json_u32(target, "selector_domain_id", "recurrence replay target")?,
+            }))
+        }
+        "all-flow-union" => {
+            let selected = all_flow_selector_domain_helicities(source)?
+                .into_iter()
+                .map(|(selector_domain_id, rows)| {
+                    let (helicity_index, helicity_id) = rows[selector_seed as usize % rows.len()];
+                    serde_json::json!({
+                        "selector_domain_id": selector_domain_id,
+                        "helicity_index": helicity_index,
+                        "helicity_id": helicity_id,
+                    })
+                })
+                .collect::<Vec<_>>();
+            Ok(serde_json::json!({
+                "strategy": source.strategy,
+                "selector_domain_helicities": selected,
+            }))
+        }
+        "contracted-color-union" => {
+            let schedule = json_object(
+                &source.selector_schedule,
+                "recurrence numerical selector schedule",
+            )?;
+            require_json_fields(
+                schedule,
+                &["policy", "fixed_source_schedule"],
+                "recurrence contracted selector schedule",
+            )?;
+            require_json_string_value(
+                schedule,
+                "policy",
+                "fixed-contracted-source-schedule-v1",
+                "recurrence contracted selector schedule",
+            )?;
+            if !json_bool(
+                schedule,
+                "fixed_source_schedule",
+                "recurrence contracted selector schedule",
+            )? {
+                return Err(invalid(
+                    "recurrence contracted source schedule is not fixed",
+                ));
+            }
+            Ok(serde_json::json!({
+                "strategy": source.strategy,
+                "fixed_source_schedule": true,
+            }))
+        }
+        _ => Err(invalid("recurrence selector strategy is unsupported")),
+    }
+}
+
+fn validate_independent_raw_captures(
+    candidate: &RawNumericalCapture<'_>,
+    verification: &RawNumericalCapture<'_>,
+    runtime_parameters: &AuthenticatedRuntimeParameterContract,
+    seed: u64,
+) -> RusticolResult<()> {
+    if candidate.dimensions != verification.dimensions
+        || candidate.observation_rows.len() != verification.observation_rows.len()
+        || !sets_are_disjoint(&candidate.point_sha256s, &verification.point_sha256s)
+        || !sets_are_disjoint(
+            &candidate.kinematic_sha256s,
+            &verification.kinematic_sha256s,
+        )
+        || !sets_are_disjoint(
+            &candidate.parameter_context_sha256s,
+            &verification.parameter_context_sha256s,
+        )
+    {
+        return Err(RusticolError::integrity(
+            "candidate and verification raw captures are not independent",
+        ));
+    }
+    let expected_candidate = deterministic_parameter_contexts(
+        &runtime_parameters.slots,
+        candidate.parameter_contexts.len(),
+        seed,
+        "candidate-current-parameter-probes-v1",
+        true,
+    )?;
+    let expected_verification = deterministic_parameter_contexts(
+        &runtime_parameters.slots,
+        verification.parameter_contexts.len(),
+        seed,
+        "independent-verification-current-parameter-probes-v1",
+        false,
+    )?;
+    if candidate.parameter_contexts != expected_candidate
+        || verification.parameter_contexts != expected_verification
+    {
+        return Err(RusticolError::integrity(
+            "raw recurrence parameter contexts are stale or non-deterministic",
+        ));
+    }
+    Ok(())
+}
+
+fn sets_are_disjoint(left: &[String], right: &[String]) -> bool {
+    let left = left.iter().collect::<BTreeSet<_>>();
+    right.iter().all(|value| !left.contains(value))
+}
+
+fn deterministic_parameter_contexts(
+    slots: &[AuthenticatedRuntimeParameterSlot],
+    count: usize,
+    seed: u64,
+    domain: &str,
+    include_defaults: bool,
+) -> RusticolResult<Vec<Vec<BigRational>>> {
+    (0..count)
+        .map(|probe_index| {
+            if include_defaults && probe_index == 0 {
+                return Ok(slots.iter().map(|slot| slot.default.clone()).collect());
+            }
+            slots
+                .iter()
+                .enumerate()
+                .map(|(parameter_index, slot)| {
+                    if slot.probe_policy == "derived-overwritten-fixed-zero-v1" {
+                        return Ok(slot.default.clone());
+                    }
+                    let digest = Sha256::digest(
+                        format!("{seed}:{domain}:{probe_index}:{parameter_index}").as_bytes(),
+                    );
+                    let unsigned = u64::from_be_bytes(
+                        digest[..8]
+                            .try_into()
+                            .map_err(|_| invalid("parameter digest width is not eight"))?,
+                    );
+                    let signed = i128::from(unsigned) - (1_i128 << 63);
+                    let signed = if signed == 0 { 1 } else { signed };
+                    let scale = slot.default.abs().max(BigRational::one());
+                    Ok(&slot.default
+                        + scale * BigRational::new(BigInt::from(signed), BigInt::one() << 67_usize))
+                })
+                .collect()
+        })
+        .collect()
+}
+
+fn domain_seed(seed: u64, domain: &str, index: usize) -> u64 {
+    let digest = Sha256::digest(format!("{seed}:{domain}:{index}").as_bytes());
+    u64::from_be_bytes(
+        digest[..8]
+            .try_into()
+            .expect("SHA-256 prefix is eight bytes"),
+    )
+}
+
+fn validate_canonical_decimal_text<'a>(
+    value: &'a str,
+    context: &str,
+) -> RusticolResult<(&'a str, &'a str, bool)> {
+    if value.is_empty() || value.starts_with('+') || value == "-0" || value.contains(['e', 'E']) {
+        return Err(invalid(format!(
+            "{context} is not a canonical finite decimal"
+        )));
+    }
+    let (negative, unsigned) = value
+        .strip_prefix('-')
+        .map_or((false, value), |rest| (true, rest));
+    let (integer, fraction) = unsigned
+        .split_once('.')
+        .map_or((unsigned, None), |(integer, fraction)| {
+            (integer, Some(fraction))
+        });
+    if integer.is_empty()
+        || !integer.bytes().all(|byte| byte.is_ascii_digit())
+        || integer.len() > 1 && integer.starts_with('0')
+        || fraction.is_some_and(|fraction| {
+            fraction.is_empty()
+                || !fraction.bytes().all(|byte| byte.is_ascii_digit())
+                || fraction.ends_with('0')
+        })
+    {
+        return Err(invalid(format!(
+            "{context} is not a canonical finite decimal"
+        )));
+    }
+    let fraction = fraction.unwrap_or("");
+    if negative && integer == "0" && fraction.bytes().all(|byte| byte == b'0') {
+        return Err(invalid(format!("{context} is negative zero")));
+    }
+    Ok((integer, fraction, negative))
+}
+
+fn parse_canonical_decimal(value: &str, context: &str) -> RusticolResult<BigRational> {
+    let (integer, fraction, negative) = validate_canonical_decimal_text(value, context)?;
+    let digits = format!("{integer}{fraction}");
+    let mut numerator = BigInt::from_str(&digits)
+        .map_err(|_| invalid(format!("{context} decimal numerator is invalid")))?;
+    if negative {
+        numerator = -numerator;
+    }
+    let denominator = BigInt::from(10_u8).pow(
+        u32::try_from(fraction.len())
+            .map_err(|_| invalid(format!("{context} decimal scale exceeds u32")))?,
+    );
+    Ok(BigRational::new(numerator, denominator))
+}
+
+fn exact_binary64_rational(value: f64) -> RusticolResult<BigRational> {
+    if !value.is_finite() {
+        return Err(invalid("binary64 value is not finite"));
+    }
+    if value == 0.0 {
+        return Ok(BigRational::zero());
+    }
+    let bits = value.to_bits();
+    let negative = bits >> 63 != 0;
+    let exponent_bits = ((bits >> 52) & 0x7ff) as i32;
+    let fraction = bits & ((1_u64 << 52) - 1);
+    let (significand, exponent) = if exponent_bits == 0 {
+        (fraction, -1074)
+    } else {
+        ((1_u64 << 52) | fraction, exponent_bits - 1023 - 52)
+    };
+    let mut numerator = BigInt::from(significand);
+    let mut denominator = BigInt::one();
+    if exponent >= 0 {
+        numerator <<= exponent as usize;
+    } else {
+        denominator <<= (-exponent) as usize;
+    }
+    if negative {
+        numerator = -numerator;
+    }
+    Ok(BigRational::new(numerator, denominator))
+}
+
+fn parse_nonnegative_python_f64_hex(
+    text: &str,
+    context: &str,
+) -> RusticolResult<(f64, BigRational)> {
+    if text.starts_with('-') || text.len() > 24 {
+        return Err(invalid(format!(
+            "{context} is not a canonical nonnegative finite binary64 encoding"
+        )));
+    }
+    let (mantissa, exponent_text) = text.split_once('p').ok_or_else(|| {
+        invalid(format!(
+            "{context} is not a canonical nonnegative finite binary64 encoding"
+        ))
+    })?;
+    let (leading, fraction_text) = mantissa
+        .strip_prefix("0x")
+        .and_then(|value| value.split_once('.'))
+        .ok_or_else(|| {
+            invalid(format!(
+                "{context} is not a canonical nonnegative finite binary64 encoding"
+            ))
+        })?;
+    if fraction_text.is_empty()
+        || fraction_text.len() > 13
+        || !fraction_text.bytes().all(|byte| byte.is_ascii_hexdigit())
+        || !matches!(leading, "0" | "1")
+    {
+        return Err(invalid(format!(
+            "{context} is not a canonical nonnegative finite binary64 encoding"
+        )));
+    }
+    let exponent = i32::from_str(exponent_text).map_err(|_| {
+        invalid(format!(
+            "{context} is not a canonical nonnegative finite binary64 encoding"
+        ))
+    })?;
+    let parsed_fraction = u64::from_str_radix(fraction_text, 16).map_err(|_| {
+        invalid(format!(
+            "{context} is not a canonical nonnegative finite binary64 encoding"
+        ))
+    })?;
+    let padding = 4 * (13 - fraction_text.len());
+    let fraction = parsed_fraction
+        .checked_shl(
+            u32::try_from(padding)
+                .map_err(|_| invalid(format!("{context} fraction padding is invalid")))?,
+        )
+        .ok_or_else(|| invalid(format!("{context} fraction is too wide")))?;
+    let bits = match leading {
+        "1" if (-1022..=1023).contains(&exponent) => {
+            let exponent_bits = u64::try_from(exponent + 1023)
+                .map_err(|_| invalid(format!("{context} exponent is invalid")))?;
+            (exponent_bits << 52) | fraction
+        }
+        "0" if exponent == -1022 && fraction != 0 => fraction,
+        "0" if exponent == 0 && fraction == 0 => 0,
+        _ => {
+            return Err(invalid(format!(
+                "{context} is not a canonical nonnegative finite binary64 encoding"
+            )));
+        }
+    };
+    let value = f64::from_bits(bits);
+    if !value.is_finite() || python_f64_hex(value) != text {
+        return Err(invalid(format!(
+            "{context} is not a canonical nonnegative finite binary64 encoding"
+        )));
+    }
+    let exact = exact_binary64_rational(value)?;
+    Ok((value, exact))
+}
+
+fn python_f64_hex_signed(value: f64) -> String {
+    let sign = if value.is_sign_negative() { "-" } else { "" };
+    format!("{sign}{}", python_f64_hex(value.abs()))
+}
+
+fn raw_observation_row<'a>(
+    capture: &'a RawNumericalCapture<'_>,
+    current_id: u32,
+    context: &str,
+) -> RusticolResult<&'a RawObservationRow> {
+    capture
+        .observation_rows
+        .get(current_id as usize)
+        .ok_or_else(|| invalid(format!("{context} row is absent")))
+}
+
+fn visit_raw_observation_text<'a, F>(
+    capture: &RawNumericalCapture<'a>,
+    current_id: u32,
+    context: &str,
+    mut visit: F,
+) -> RusticolResult<()>
+where
+    F: FnMut(usize, &'a str, &'a str) -> RusticolResult<()>,
+{
+    let row = raw_observation_row(capture, current_id, context)?;
+    let values_range = row.values.as_usize(capture.raw_bytes.len(), context)?;
+    let values = capture
+        .raw_bytes
+        .get(values_range.clone())
+        .ok_or_else(|| invalid(format!("{context} values are absent")))?;
+    let dimension = capture
+        .dimensions
+        .get(current_id as usize)
+        .copied()
+        .ok_or_else(|| invalid(format!("{context} dimension is absent")))?;
+    let expected_width = capture
+        .point_count
+        .checked_mul(usize::from(dimension))
+        .ok_or_else(|| invalid(format!("{context} width overflows usize")))?;
+    let mut cursor = CanonicalObservationCursor {
+        bytes: values,
+        position: 0,
+        absolute_start: values_range.start,
+    };
+    cursor.expect(b"[", context)?;
+    for index in 0..expected_width {
+        if index != 0 {
+            cursor.expect(b",", context)?;
+        }
+        cursor.expect(b"[", context)?;
+        let real = cursor.decimal_string(&format!("{context} component {index} real part"))?;
+        cursor.expect(b",", context)?;
+        let imaginary =
+            cursor.decimal_string(&format!("{context} component {index} imaginary part"))?;
+        cursor.expect(b"]", context)?;
+        visit(index, real, imaginary)?;
+    }
+    cursor.expect(b"]", context)?;
+    if cursor.position != cursor.bytes.len() {
+        return Err(invalid(format!(
+            "{context} has trailing or extra observation values"
+        )));
+    }
+    Ok(())
+}
+
+fn parse_raw_observation_values(
+    capture: &RawNumericalCapture<'_>,
+    current_id: u32,
+    context: &str,
+) -> RusticolResult<Vec<ExactProbeComplex>> {
+    let dimension = capture
+        .dimensions
+        .get(current_id as usize)
+        .copied()
+        .ok_or_else(|| invalid(format!("{context} dimension is absent")))?;
+    let width = capture
+        .point_count
+        .checked_mul(usize::from(dimension))
+        .ok_or_else(|| invalid(format!("{context} width overflows usize")))?;
+    let mut values = Vec::with_capacity(width);
+    visit_raw_observation_text(capture, current_id, context, |index, real, imaginary| {
+        values.push((
+            parse_canonical_decimal(real, &format!("{context} component {index} real part"))?,
+            parse_canonical_decimal(
+                imaginary,
+                &format!("{context} component {index} imaginary part"),
+            )?,
+        ));
+        Ok(())
+    })?;
+    Ok(values)
+}
+
+#[cfg(test)]
+fn raw_observation_value(
+    capture: &RawNumericalCapture<'_>,
+    current_id: u32,
+    observation_index: usize,
+    context: &str,
+) -> RusticolResult<ExactProbeComplex> {
+    let mut selected = None;
+    visit_raw_observation_text(capture, current_id, context, |index, real, imaginary| {
+        if index == observation_index {
+            selected = Some((
+                parse_canonical_decimal(real, &format!("{context} selected real part"))?,
+                parse_canonical_decimal(imaginary, &format!("{context} selected imaginary part"))?,
+            ));
+        }
+        Ok(())
+    })?;
+    selected.ok_or_else(|| invalid(format!("{context} selected observation is absent")))
+}
+
+fn raw_observation_values_bytes<'a>(
+    capture: &RawNumericalCapture<'a>,
+    current_id: u32,
+    context: &str,
+) -> RusticolResult<&'a [u8]> {
+    let row = raw_observation_row(capture, current_id, context)?;
+    let range = row.values.as_usize(capture.raw_bytes.len(), context)?;
+    capture
+        .raw_bytes
+        .get(range)
+        .ok_or_else(|| invalid(format!("{context} values are absent")))
+}
+
+fn exact_probe_scalar(value: &ExactProbeComplex, scalar_component: usize) -> &BigRational {
+    if scalar_component == 0 {
+        &value.0
+    } else {
+        &value.1
+    }
+}
+
+fn build_raw_numerical_candidate_indexes(
+    source: &RawSourceSemantics,
+    candidate: &RawNumericalCapture<'_>,
+    telemetry: &mut RecurrenceEvidenceAuthenticationTelemetry,
+) -> RusticolResult<BTreeMap<Vec<u8>, RawNumericalCandidateIndex>> {
+    let mut members_by_contract = BTreeMap::<Vec<u8>, Vec<u32>>::new();
+    for current in &source.currents {
+        members_by_contract
+            .entry(current.contract_key.clone())
+            .or_default()
+            .push(current.current_id);
+    }
+    members_by_contract
+        .into_iter()
+        .map(|(contract, members)| {
+            let first_id = members
+                .first()
+                .copied()
+                .ok_or_else(|| invalid("raw numerical candidate index has no members"))?;
+            let dimension = candidate
+                .dimensions
+                .get(first_id as usize)
+                .copied()
+                .ok_or_else(|| invalid("raw numerical candidate index dimension is absent"))?;
+            let width = candidate
+                .point_count
+                .checked_mul(usize::from(dimension))
+                .ok_or_else(|| invalid("raw numerical candidate index width overflows usize"))?;
+            let scalar_width = width
+                .checked_mul(2)
+                .ok_or_else(|| invalid("raw numerical candidate scalar width overflows usize"))?;
+            let mut scalar_columns = (0..scalar_width)
+                .map(|_| Vec::<&str>::with_capacity(members.len()))
+                .collect::<Vec<_>>();
+            for current_id in &members {
+                if candidate.dimensions.get(*current_id as usize) != Some(&dimension) {
+                    return Err(invalid(
+                        "raw numerical candidate index has inconsistent widths",
+                    ));
+                }
+                visit_raw_observation_text(
+                    candidate,
+                    *current_id,
+                    "raw numerical candidate index",
+                    |index, real, imaginary| {
+                        scalar_columns[index * 2].push(real);
+                        scalar_columns[index * 2 + 1].push(imaginary);
+                        Ok(())
+                    },
+                )?;
+                RecurrenceEvidenceAuthenticationTelemetry::checked_add(
+                    &mut telemetry.candidate_index_observation_row_scan_count,
+                    1,
+                    "evidence-authentication candidate-index row-scan count",
+                )?;
+            }
+            let mut best_choice = (0_usize, 0_usize);
+            let mut best_score = (0_usize, 0_usize);
+            let mut sorted_column = Vec::<&str>::with_capacity(members.len());
+            for observation_index in 0..width {
+                for scalar_component in 0..2 {
+                    let column = &scalar_columns[observation_index * 2 + scalar_component];
+                    sorted_column.clear();
+                    sorted_column.extend_from_slice(column);
+                    sorted_column.sort_unstable();
+                    let unique = usize::from(!sorted_column.is_empty())
+                        + sorted_column
+                            .windows(2)
+                            .filter(|pair| pair[0] != pair[1])
+                            .count();
+                    let nonzero = sorted_column.iter().filter(|value| **value != "0").count();
+                    let score = (unique, nonzero);
+                    if score > best_score
+                        || score == best_score
+                            && (observation_index, scalar_component) < best_choice
+                    {
+                        best_score = score;
+                        best_choice = (observation_index, scalar_component);
+                    }
+                }
+            }
+            let selected_column_start = best_choice
+                .0
+                .checked_mul(2)
+                .ok_or_else(|| invalid("raw numerical selected column overflows usize"))?;
+            let real_column = &scalar_columns[selected_column_start];
+            let imaginary_column = &scalar_columns[selected_column_start + 1];
+            if real_column.len() != members.len() || imaginary_column.len() != members.len() {
+                return Err(invalid(
+                    "raw numerical selected observation column is incomplete",
+                ));
+            }
+            let selected_values = members
+                .iter()
+                .zip(real_column.iter().zip(imaginary_column.iter()))
+                .map(|(current_id, (real, imaginary))| {
+                    Ok((
+                        *current_id,
+                        (
+                            parse_canonical_decimal(
+                                real,
+                                "raw numerical candidate index selected real part",
+                            )?,
+                            parse_canonical_decimal(
+                                imaginary,
+                                "raw numerical candidate index selected imaginary part",
+                            )?,
+                        ),
+                    ))
+                })
+                .collect::<RusticolResult<Vec<_>>>()?;
+            RecurrenceEvidenceAuthenticationTelemetry::checked_add(
+                &mut telemetry.retained_selected_observation_count,
+                selected_values.len(),
+                "evidence-authentication retained selected-observation count",
+            )?;
+            let mut entries = selected_values
+                .iter()
+                .map(|(current_id, value)| {
+                    (
+                        exact_probe_scalar(value, best_choice.1).clone(),
+                        *current_id,
+                    )
+                })
+                .collect::<Vec<_>>();
+            RecurrenceEvidenceAuthenticationTelemetry::checked_add(
+                &mut telemetry.selected_observation_reuse_count,
+                selected_values.len(),
+                "evidence-authentication selected-observation reuse count",
+            )?;
+            entries.sort();
+            Ok((
+                contract,
+                RawNumericalCandidateIndex {
+                    #[cfg(test)]
+                    observation_index: best_choice.0,
+                    scalar_component: best_choice.1,
+                    entries,
+                    selected_values,
+                },
+            ))
+        })
+        .collect()
+}
+
+fn raw_numerical_tolerance_window_ids(
+    index: &RawNumericalCandidateIndex,
+    selected: &ExactProbeComplex,
+    current_id: u32,
+    relation_kind: &str,
+    relative_tolerance: &BigRational,
+    absolute_tolerance: &BigRational,
+) -> RusticolResult<BTreeSet<u32>> {
+    if !matches!(relation_kind, "equal" | "opposite") {
+        return Err(invalid(
+            "raw numerical candidate index relation is unsupported",
+        ));
+    }
+    if relative_tolerance >= &BigRational::one() {
+        return Ok(index
+            .entries
+            .iter()
+            .filter_map(|(_value, representative_id)| {
+                (*representative_id < current_id).then_some(*representative_id)
+            })
+            .collect());
+    }
+    let selected_scalar = exact_probe_scalar(selected, index.scalar_component);
+    let target = if relation_kind == "equal" {
+        selected_scalar.clone()
+    } else {
+        -selected_scalar
+    };
+    // For complex-pair infinity norms X (current), Y (representative), and D
+    // (residual), passing gives D <= a+r*max(X,Y) and reverse triangle gives
+    // Y <= X+D.  Hence r<1 implies D <= (a+rX)/(1-r); the indexed scalar
+    // residual is <= D, so this window cannot discard a passing relation.
+    let current_scale = selected.0.abs().max(selected.1.abs());
+    let radius = (absolute_tolerance + relative_tolerance * current_scale)
+        / (BigRational::one() - relative_tolerance);
+    let lower_value = &target - &radius;
+    let upper_value = target + radius;
+    let lower = index
+        .entries
+        .partition_point(|(value, _current_id)| value < &lower_value);
+    let upper = index
+        .entries
+        .partition_point(|(value, _current_id)| value <= &upper_value);
+    Ok(index.entries[lower..upper]
+        .iter()
+        .filter_map(|(_value, representative_id)| {
+            (*representative_id < current_id).then_some(*representative_id)
+        })
+        .collect())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn derive_raw_numerical_relations(
+    source: &RawSourceSemantics,
+    candidate: &RawNumericalCapture<'_>,
+    verification: &RawNumericalCapture<'_>,
+    precision_digits: u32,
+    seed: u64,
+    relative_tolerance: &BigRational,
+    absolute_tolerance: &BigRational,
+    relative_tolerance_hex: &str,
+    absolute_tolerance_hex: &str,
+    runtime_parameter_schema_sha256: &str,
+    certificate_algorithm: &str,
+    telemetry: &mut RecurrenceEvidenceAuthenticationTelemetry,
+) -> RusticolResult<RawNumericalDerivation> {
+    const DECISION_CHAIN_ABI: &str = "pyamplicol-recurrence-numerical-decision-chain-v1";
+    const REJECTION_CHAIN_ABI: &str = "pyamplicol-recurrence-rejected-numerical-decision-chain-v1";
+    let candidate_index_started = Instant::now();
+    let candidate_indexes = build_raw_numerical_candidate_indexes(source, candidate, telemetry)?;
+    telemetry.candidate_index_nanoseconds = elapsed_nanoseconds(candidate_index_started);
+    let mut prior_by_contract = BTreeMap::<Vec<u8>, Vec<u32>>::new();
+    let mut derived = Vec::new();
+    let mut numerical_candidate_count = 0_usize;
+    let mut verification_rejected_count = 0_usize;
+    let mut tested_hypothesis_count = 0_usize;
+    let mut theoretical_pair_hypothesis_count = 0_usize;
+    let mut screened_pair_hypothesis_count = 0_usize;
+    let mut zero_hypothesis_count = 0_usize;
+    let suppressed_selector_domains = if source.strategy == "all-flow-union" {
+        all_flow_selector_domain_helicities(source)?
+            .into_iter()
+            .filter_map(|(domain_id, helicities)| (helicities.len() > 1).then_some(domain_id))
+            .collect::<BTreeSet<_>>()
+    } else {
+        BTreeSet::new()
+    };
+    let source_semantics_sha256 =
+        canonical_json_sha256(&source.value, "raw numerical source semantics")?;
+    let mut decision_chain = canonical_json_sha256(
+        &serde_json::json!({
+            "abi": DECISION_CHAIN_ABI,
+            "source_semantics_sha256": source_semantics_sha256,
+            "candidate_capture_sha256": candidate.capture_contract_sha256,
+            "verification_capture_sha256": verification.capture_contract_sha256,
+        }),
+        "raw numerical decision-chain root",
+    )?;
+    let mut rejection_chain = canonical_json_sha256(
+        &serde_json::json!({
+            "abi": REJECTION_CHAIN_ABI,
+            "source_semantics_sha256": source_semantics_sha256,
+            "candidate_capture_sha256": candidate.capture_contract_sha256,
+            "verification_capture_sha256": verification.capture_contract_sha256,
+        }),
+        "raw numerical rejection-chain root",
+    )?;
+    let hypothesis_replay_started = Instant::now();
+    for current in &source.currents {
+        let prior = prior_by_contract
+            .entry(current.contract_key.clone())
+            .or_default();
+        if current.is_source {
+            prior.push(current.current_id);
+            continue;
+        }
+        if suppressed_selector_domains.contains(&current.selector_domain_id) {
+            continue;
+        }
+        let candidate_index = candidate_indexes
+            .get(&current.contract_key)
+            .ok_or_else(|| invalid("raw numerical candidate index contract is absent"))?;
+        let selected = candidate_index
+            .selected_value(current.current_id, "raw numerical candidate index current")?;
+        RecurrenceEvidenceAuthenticationTelemetry::checked_add(
+            &mut telemetry.selected_observation_reuse_count,
+            1,
+            "evidence-authentication selected-observation reuse count",
+        )?;
+        let equal_representatives = raw_numerical_tolerance_window_ids(
+            candidate_index,
+            selected,
+            current.current_id,
+            "equal",
+            relative_tolerance,
+            absolute_tolerance,
+        )?;
+        let opposite_representatives = raw_numerical_tolerance_window_ids(
+            candidate_index,
+            selected,
+            current.current_id,
+            "opposite",
+            relative_tolerance,
+            absolute_tolerance,
+        )?;
+        theoretical_pair_hypothesis_count = theoretical_pair_hypothesis_count
+            .checked_add(
+                prior
+                    .len()
+                    .checked_mul(2)
+                    .ok_or_else(|| invalid("theoretical pair count overflows usize"))?,
+            )
+            .ok_or_else(|| invalid("theoretical pair count overflows usize"))?;
+        screened_pair_hypothesis_count = screened_pair_hypothesis_count
+            .checked_add(equal_representatives.len())
+            .and_then(|count| count.checked_add(opposite_representatives.len()))
+            .ok_or_else(|| invalid("screened pair count overflows usize"))?;
+        zero_hypothesis_count = zero_hypothesis_count
+            .checked_add(1)
+            .ok_or_else(|| invalid("zero hypothesis count overflows usize"))?;
+        screened_pair_hypothesis_count
+            .checked_add(zero_hypothesis_count)
+            .ok_or_else(|| invalid("total screened hypothesis count overflows usize"))?;
+        let mut hypotheses = vec![("zero", None)];
+        for representative_id in equal_representatives
+            .union(&opposite_representatives)
+            .copied()
+        {
+            if equal_representatives.contains(&representative_id) {
+                hypotheses.push(("equal", Some(representative_id)));
+            }
+            if opposite_representatives.contains(&representative_id) {
+                hypotheses.push(("opposite", Some(representative_id)));
+            }
+        }
+        for (relation_kind, representative_id) in hypotheses {
+            tested_hypothesis_count = tested_hypothesis_count
+                .checked_add(1)
+                .ok_or_else(|| invalid("numerical hypothesis count overflows usize"))?;
+            let candidate_residuals = relation_residuals(
+                relation_kind,
+                current.current_id,
+                representative_id,
+                candidate,
+                relative_tolerance,
+                absolute_tolerance,
+                telemetry,
+            )?;
+            if candidate_residuals.maximum_ratio > BigRational::one() {
+                decision_chain = advance_decision_chain(
+                    &decision_chain,
+                    current.current_id,
+                    representative_id,
+                    relation_kind,
+                    &candidate_residuals,
+                    None,
+                    false,
+                    telemetry,
+                )?;
+                rejection_chain = advance_rejection_chain(
+                    &rejection_chain,
+                    current.current_id,
+                    representative_id,
+                    relation_kind,
+                    &candidate_residuals,
+                    "candidate-observations-not-equal",
+                    telemetry,
+                )?;
+                continue;
+            }
+            numerical_candidate_count = numerical_candidate_count
+                .checked_add(1)
+                .ok_or_else(|| invalid("numerical candidate count overflows usize"))?;
+            let verification_residuals = relation_residuals(
+                relation_kind,
+                current.current_id,
+                representative_id,
+                verification,
+                relative_tolerance,
+                absolute_tolerance,
+                telemetry,
+            )?;
+            if verification_residuals.maximum_ratio > BigRational::one() {
+                verification_rejected_count = verification_rejected_count
+                    .checked_add(1)
+                    .ok_or_else(|| invalid("verification rejection count overflows usize"))?;
+                decision_chain = advance_decision_chain(
+                    &decision_chain,
+                    current.current_id,
+                    representative_id,
+                    relation_kind,
+                    &candidate_residuals,
+                    Some(&verification_residuals),
+                    false,
+                    telemetry,
+                )?;
+                rejection_chain = advance_rejection_chain(
+                    &rejection_chain,
+                    current.current_id,
+                    representative_id,
+                    relation_kind,
+                    &verification_residuals,
+                    "independent-verification-rejected-candidate",
+                    telemetry,
+                )?;
+                continue;
+            }
+            let execution_representative_id = if relation_kind == "zero" {
+                prior.first().copied().unwrap_or(current.current_id)
+            } else {
+                representative_id
+                    .ok_or_else(|| invalid("non-zero numerical relation has no representative"))?
+            };
+            derived.push(build_derived_numerical_relation(
+                source,
+                current,
+                representative_id,
+                execution_representative_id,
+                relation_kind,
+                candidate,
+                verification,
+                &candidate_residuals,
+                &verification_residuals,
+                precision_digits,
+                seed,
+                relative_tolerance_hex,
+                absolute_tolerance_hex,
+                runtime_parameter_schema_sha256,
+                certificate_algorithm,
+                telemetry,
+            )?);
+            decision_chain = advance_decision_chain(
+                &decision_chain,
+                current.current_id,
+                representative_id,
+                relation_kind,
+                &candidate_residuals,
+                Some(&verification_residuals),
+                true,
+                telemetry,
+            )?;
+            break;
+        }
+        prior.push(current.current_id);
+    }
+    telemetry.hypothesis_replay_nanoseconds = elapsed_nanoseconds(hypothesis_replay_started);
+    let derivation_finalization_started = Instant::now();
+    let rejected_hypothesis_count = tested_hypothesis_count
+        .checked_sub(derived.len())
+        .ok_or_else(|| invalid("raw numerical rejected-hypothesis count underflows"))?;
+    let decision_sha256 = canonical_json_sha256(
+        &serde_json::json!({
+            "abi": DECISION_CHAIN_ABI,
+            "chain_tail_sha256": decision_chain,
+            "tested_hypothesis_count": tested_hypothesis_count,
+            "theoretical_pair_hypothesis_count": theoretical_pair_hypothesis_count,
+            "screened_pair_hypothesis_count": screened_pair_hypothesis_count,
+            "zero_hypothesis_count": zero_hypothesis_count,
+            "numerical_candidate_count": numerical_candidate_count,
+            "verification_rejected_count": verification_rejected_count,
+            "rejected_hypothesis_count": rejected_hypothesis_count,
+            "certified_relation_count": derived.len(),
+        }),
+        "raw numerical decision-chain census",
+    )?;
+    let rejection_decision_sha256 = rejection_chain;
+    telemetry.finish_rational_string_census()?;
+    telemetry.derivation_finalization_nanoseconds =
+        elapsed_nanoseconds(derivation_finalization_started);
+    Ok(RawNumericalDerivation {
+        relations: derived,
+        numerical_candidate_count,
+        verification_rejected_count,
+        rejected_hypothesis_count,
+        tested_hypothesis_count,
+        theoretical_pair_hypothesis_count,
+        screened_pair_hypothesis_count,
+        zero_hypothesis_count,
+        candidate_index_contract_count: candidate_indexes.len(),
+        exhaustive_fallback_contract_count: if relative_tolerance >= &BigRational::one() {
+            candidate_indexes.len()
+        } else {
+            0
+        },
+        decision_sha256,
+        rejection_decision_sha256,
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn advance_decision_chain(
+    previous: &str,
+    current_id: u32,
+    representative_id: Option<u32>,
+    relation_kind: &str,
+    candidate: &RelationResiduals,
+    verification: Option<&RelationResiduals>,
+    selected: bool,
+    telemetry: &mut RecurrenceEvidenceAuthenticationTelemetry,
+) -> RusticolResult<String> {
+    telemetry.record_rational_string_uses(if verification.is_some() { 6 } else { 3 })?;
+    let row = serde_json::json!({
+        "current_id": current_id,
+        "representative_id": representative_id,
+        "relation_kind": relation_kind,
+        "candidate_maximum_absolute_residual": candidate.strings.maximum_absolute.as_str(),
+        "candidate_maximum_relative_residual": candidate.strings.maximum_relative.as_str(),
+        "candidate_maximum_tolerance_ratio": candidate.strings.maximum_ratio.as_str(),
+        "candidate_accepted": candidate.maximum_ratio <= BigRational::one(),
+        "verification_maximum_absolute_residual": verification.map(|value| value.strings.maximum_absolute.as_str()),
+        "verification_maximum_relative_residual": verification.map(|value| value.strings.maximum_relative.as_str()),
+        "verification_maximum_tolerance_ratio": verification.map(|value| value.strings.maximum_ratio.as_str()),
+        "verification_accepted": verification.map(|value| value.maximum_ratio <= BigRational::one()),
+        "selected": selected,
+    });
+    let previous = semantic_digest_from_hex(previous, "raw numerical decision-chain tail")?;
+    let mut digest = Sha256::new();
+    digest.update(previous.as_bytes());
+    digest.update(canonical_json_bytes(&row, "raw numerical decision row")?);
+    Ok(hex_digest(digest.finalize()))
+}
+
+fn advance_rejection_chain(
+    previous: &str,
+    current_id: u32,
+    representative_id: Option<u32>,
+    relation_kind: &str,
+    residuals: &RelationResiduals,
+    reason: &str,
+    telemetry: &mut RecurrenceEvidenceAuthenticationTelemetry,
+) -> RusticolResult<String> {
+    telemetry.record_rational_string_uses(3)?;
+    let row = serde_json::json!({
+        "current_id": current_id,
+        "representative_id": representative_id,
+        "relation_kind": relation_kind,
+        "reason": reason,
+        "maximum_absolute_residual": residuals.strings.maximum_absolute.as_str(),
+        "maximum_relative_residual": residuals.strings.maximum_relative.as_str(),
+        "maximum_tolerance_ratio": residuals.strings.maximum_ratio.as_str(),
+    });
+    let previous = semantic_digest_from_hex(previous, "raw numerical rejection-chain predecessor")?;
+    let mut digest = Sha256::new();
+    digest.update(previous.as_bytes());
+    digest.update(canonical_json_bytes(
+        &row,
+        "raw numerical rejected hypothesis",
+    )?);
+    Ok(hex_digest(digest.finalize()))
+}
+
+fn relation_residuals(
+    relation_kind: &str,
+    current_id: u32,
+    representative_id: Option<u32>,
+    capture: &RawNumericalCapture<'_>,
+    relative_tolerance: &BigRational,
+    absolute_tolerance: &BigRational,
+    telemetry: &mut RecurrenceEvidenceAuthenticationTelemetry,
+) -> RusticolResult<RelationResiduals> {
+    let mut maximum_absolute = BigRational::zero();
+    let mut maximum_relative = BigRational::zero();
+    let mut maximum_ratio = BigRational::zero();
+    if relation_kind == "zero" {
+        if representative_id.is_some() {
+            return Err(invalid("raw numerical zero relation has a representative"));
+        }
+        visit_raw_observation_text(
+            capture,
+            current_id,
+            "raw numerical current observations",
+            |index, real, imaginary| {
+                let current_value = (
+                    parse_canonical_decimal(
+                        real,
+                        &format!("raw numerical current observations component {index} real part"),
+                    )?,
+                    parse_canonical_decimal(
+                        imaginary,
+                        &format!(
+                            "raw numerical current observations component {index} imaginary part"
+                        ),
+                    )?,
+                );
+                accumulate_relation_residual(
+                    relation_kind,
+                    &current_value,
+                    None,
+                    relative_tolerance,
+                    absolute_tolerance,
+                    &mut maximum_absolute,
+                    &mut maximum_relative,
+                    &mut maximum_ratio,
+                )
+            },
+        )?;
+        let streamed_value_count = capture
+            .dimensions
+            .get(current_id as usize)
+            .copied()
+            .and_then(|dimension| capture.point_count.checked_mul(usize::from(dimension)))
+            .ok_or_else(|| invalid("raw numerical zero-residual width overflows usize"))?;
+        RecurrenceEvidenceAuthenticationTelemetry::checked_add(
+            &mut telemetry.zero_residual_streamed_value_count,
+            streamed_value_count,
+            "evidence-authentication zero-residual streamed-value count",
+        )?;
+    } else {
+        let current = parse_raw_observation_values(
+            capture,
+            current_id,
+            "raw numerical current observations",
+        )?;
+        let representative_id = representative_id
+            .ok_or_else(|| invalid("raw numerical non-zero relation has no representative"))?;
+        let representative = parse_raw_observation_values(
+            capture,
+            representative_id,
+            "raw numerical representative observations",
+        )?;
+        RecurrenceEvidenceAuthenticationTelemetry::checked_add(
+            &mut telemetry.materialized_observation_vector_count,
+            2,
+            "evidence-authentication materialized observation-vector count",
+        )?;
+        if representative.len() != current.len() {
+            return Err(invalid("raw numerical relation width is invalid"));
+        }
+        for (current_value, representative_value) in current.iter().zip(&representative) {
+            accumulate_relation_residual(
+                relation_kind,
+                current_value,
+                Some(representative_value),
+                relative_tolerance,
+                absolute_tolerance,
+                &mut maximum_absolute,
+                &mut maximum_relative,
+                &mut maximum_ratio,
+            )?;
+        }
+    }
+    let strings = RelationResidualStrings {
+        maximum_absolute: rational_string(&maximum_absolute),
+        maximum_relative: rational_string(&maximum_relative),
+        maximum_ratio: rational_string(&maximum_ratio),
+    };
+    RecurrenceEvidenceAuthenticationTelemetry::checked_add(
+        &mut telemetry.rational_string_materialization_count,
+        3,
+        "evidence-authentication rational-string materialization count",
+    )?;
+    Ok(RelationResiduals {
+        maximum_ratio,
+        strings,
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn accumulate_relation_residual(
+    relation_kind: &str,
+    current_value: &ExactProbeComplex,
+    representative_value: Option<&ExactProbeComplex>,
+    relative_tolerance: &BigRational,
+    absolute_tolerance: &BigRational,
+    maximum_absolute: &mut BigRational,
+    maximum_relative: &mut BigRational,
+    maximum_ratio: &mut BigRational,
+) -> RusticolResult<()> {
+    let current_scale = current_value.0.abs().max(current_value.1.abs());
+    let (difference, scale) = match relation_kind {
+        "zero" => {
+            if representative_value.is_some() {
+                return Err(invalid("raw numerical zero relation has a representative"));
+            }
+            (current_scale.clone(), current_scale)
+        }
+        "equal" | "opposite" => {
+            let representative_value = representative_value
+                .ok_or_else(|| invalid("raw numerical non-zero relation has no representative"))?;
+            let (right_real, right_imaginary) = if relation_kind == "equal" {
+                (
+                    representative_value.0.clone(),
+                    representative_value.1.clone(),
+                )
+            } else {
+                (
+                    -representative_value.0.clone(),
+                    -representative_value.1.clone(),
+                )
+            };
+            (
+                (&current_value.0 - right_real)
+                    .abs()
+                    .max((&current_value.1 - right_imaginary).abs()),
+                current_scale
+                    .max(representative_value.0.abs())
+                    .max(representative_value.1.abs()),
+            )
+        }
+        _ => return Err(invalid("raw numerical relation kind is unsupported")),
+    };
+    let allowed = absolute_tolerance + relative_tolerance * &scale;
+    let (relative, ratio) = if difference.is_zero() {
+        (BigRational::zero(), BigRational::zero())
+    } else {
+        if allowed <= BigRational::zero() {
+            return Err(invalid("raw numerical tolerance is not positive"));
+        }
+        (
+            &difference / scale.max(absolute_tolerance.clone()),
+            &difference / allowed,
+        )
+    };
+    *maximum_absolute = std::mem::take(maximum_absolute).max(difference);
+    *maximum_relative = std::mem::take(maximum_relative).max(relative);
+    *maximum_ratio = std::mem::take(maximum_ratio).max(ratio);
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_derived_numerical_relation(
+    source: &RawSourceSemantics,
+    current: &RawSourceCurrent,
+    representative_id: Option<u32>,
+    execution_representative_id: u32,
+    relation_kind: &str,
+    candidate: &RawNumericalCapture<'_>,
+    verification: &RawNumericalCapture<'_>,
+    candidate_residuals: &RelationResiduals,
+    verification_residuals: &RelationResiduals,
+    precision_digits: u32,
+    seed: u64,
+    relative_tolerance_hex: &str,
+    absolute_tolerance_hex: &str,
+    runtime_parameter_schema_sha256: &str,
+    certificate_algorithm: &str,
+    telemetry: &mut RecurrenceEvidenceAuthenticationTelemetry,
+) -> RusticolResult<DerivedNumericalRelation> {
+    let factor = match relation_kind {
+        "equal" => rusticol_core::recurrence::ExactComplexRational::ONE,
+        "opposite" => rusticol_core::recurrence::ExactComplexRational::ONE.checked_neg()?,
+        "zero" => rusticol_core::recurrence::ExactComplexRational::ZERO,
+        _ => return Err(invalid("raw numerical relation kind is unsupported")),
+    };
+    let factor_integer = match relation_kind {
+        "equal" => serde_json::json!([1, 0]),
+        "opposite" => serde_json::json!([-1, 0]),
+        "zero" => serde_json::json!([0, 0]),
+        _ => unreachable!(),
+    };
+    let candidate_observations_sha256 = relation_observation_sha256(
+        current.current_id,
+        representative_id,
+        relation_kind,
+        candidate,
+    )?;
+    let verification_observations_sha256 = relation_observation_sha256(
+        current.current_id,
+        representative_id,
+        relation_kind,
+        verification,
+    )?;
+    let probe_contract = serde_json::json!({
+        "algorithm": certificate_algorithm,
+        "source_semantics_sha256": canonical_json_sha256(
+            &source.value,
+            "raw numerical source semantics",
+        )?,
+        "current_id": current.current_id,
+        "representative_id": representative_id,
+        "execution_representative_id": execution_representative_id,
+        "relation_kind": relation_kind,
+        "precision_digits": precision_digits,
+        "seed": seed,
+        "candidate_domain": "candidate-current-probes-v1",
+        "verification_domain": "independent-verification-current-probes-v1",
+        "relative_tolerance_binary64": relative_tolerance_hex,
+        "absolute_tolerance_binary64": absolute_tolerance_hex,
+        "candidate_probe_count": candidate.point_sha256s.len(),
+        "verification_probe_count": verification.point_sha256s.len(),
+        "current_dimension": current.dimension,
+        "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+        "candidate_capture_sha256": candidate.capture_contract_sha256,
+        "verification_capture_sha256": verification.capture_contract_sha256,
+        "candidate_observations_sha256": candidate_observations_sha256,
+        "verification_observations_sha256": verification_observations_sha256,
+    });
+    let probe_contract_sha256 =
+        canonical_json_sha256(&probe_contract, "raw numerical probe contract")?;
+    telemetry.record_rational_string_uses(12)?;
+    let proof = serde_json::json!({
+        "algorithm": certificate_algorithm,
+        "source_semantics_sha256": probe_contract["source_semantics_sha256"],
+        "current_id": current.current_id,
+        "representative_id": representative_id,
+        "execution_representative_id": execution_representative_id,
+        "relation_kind": relation_kind,
+        "precision_digits": precision_digits,
+        "seed": seed,
+        "candidate_domain": "candidate-current-probes-v1",
+        "verification_domain": "independent-verification-current-probes-v1",
+        "relative_tolerance_binary64": relative_tolerance_hex,
+        "absolute_tolerance_binary64": absolute_tolerance_hex,
+        "candidate_probe_count": candidate.point_sha256s.len(),
+        "verification_probe_count": verification.point_sha256s.len(),
+        "current_dimension": current.dimension,
+        "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+        "candidate_capture_sha256": candidate.capture_contract_sha256,
+        "verification_capture_sha256": verification.capture_contract_sha256,
+        "candidate_observations_sha256": candidate_observations_sha256,
+        "verification_observations_sha256": verification_observations_sha256,
+        "proof_kind": "authenticated-numerical",
+        "factor_integer": factor_integer,
+        "candidate_maximum_absolute_residual": candidate_residuals.strings.maximum_absolute.as_str(),
+        "candidate_maximum_relative_residual": candidate_residuals.strings.maximum_relative.as_str(),
+        "candidate_maximum_tolerance_ratio": candidate_residuals.strings.maximum_ratio.as_str(),
+        "verification_maximum_absolute_residual": verification_residuals.strings.maximum_absolute.as_str(),
+        "verification_maximum_relative_residual": verification_residuals.strings.maximum_relative.as_str(),
+        "verification_maximum_tolerance_ratio": verification_residuals.strings.maximum_ratio.as_str(),
+        "probe_contract_sha256": probe_contract_sha256,
+    });
+    let proof_sha256 = canonical_json_sha256(&proof, "raw numerical relation proof")?;
+    let certificate = serde_json::json!({
+        "algorithm": certificate_algorithm,
+        "proof_kind": "authenticated-numerical",
+        "relation_kind": relation_kind,
+        "current_id": current.current_id,
+        "representative_id": representative_id,
+        "execution_representative_id": execution_representative_id,
+        "factor_integer": factor_integer,
+        "source_semantics_sha256": probe_contract["source_semantics_sha256"],
+        "precision_digits": precision_digits,
+        "seed": seed,
+        "relative_tolerance_binary64": relative_tolerance_hex,
+        "absolute_tolerance_binary64": absolute_tolerance_hex,
+        "candidate_probe_count": candidate.point_sha256s.len(),
+        "verification_probe_count": verification.point_sha256s.len(),
+        "current_dimension": current.dimension,
+        "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+        "candidate_capture_sha256": candidate.capture_contract_sha256,
+        "verification_capture_sha256": verification.capture_contract_sha256,
+        "candidate_maximum_absolute_residual": candidate_residuals.strings.maximum_absolute.as_str(),
+        "candidate_maximum_relative_residual": candidate_residuals.strings.maximum_relative.as_str(),
+        "candidate_maximum_tolerance_ratio": candidate_residuals.strings.maximum_ratio.as_str(),
+        "verification_maximum_absolute_residual": verification_residuals.strings.maximum_absolute.as_str(),
+        "verification_maximum_relative_residual": verification_residuals.strings.maximum_relative.as_str(),
+        "verification_maximum_tolerance_ratio": verification_residuals.strings.maximum_ratio.as_str(),
+        "candidate_observations_sha256": candidate_observations_sha256,
+        "verification_observations_sha256": verification_observations_sha256,
+        "probe_contract_sha256": probe_contract_sha256,
+        "proof_sha256": proof_sha256,
+    });
+    let mapping_json = serde_json::json!({
+        "current_id": current.current_id,
+        "representative_id": representative_id,
+        "execution_representative_id": execution_representative_id,
+        "relation_kind": relation_kind,
+        "factor_integer": factor_integer,
+        "current_dimension": current.dimension,
+        "certificate_proof_sha256": proof_sha256,
+        "candidate_observations_sha256": candidate_observations_sha256,
+        "verification_observations_sha256": verification_observations_sha256,
+    });
+    Ok(DerivedNumericalRelation {
+        mapping: RecurrenceNumericalCurrentMapping {
+            current_id: current.current_id,
+            representative_id,
+            execution_representative_id,
+            relation_kind: relation_kind.to_owned(),
+            factor,
+            current_dimension: current.dimension,
+            certificate_proof_sha256: proof_sha256,
+            candidate_observations_sha256,
+            verification_observations_sha256,
+        },
+        certificate,
+        mapping_json,
+    })
+}
+
+fn relation_observation_sha256(
+    current_id: u32,
+    representative_id: Option<u32>,
+    relation_kind: &str,
+    capture: &RawNumericalCapture<'_>,
+) -> RusticolResult<String> {
+    const CURRENT_PLACEHOLDER: &str = "__pyamplicol_authenticated_current_values_placeholder__";
+    const REPRESENTATIVE_PLACEHOLDER: &str =
+        "__pyamplicol_authenticated_representative_values_placeholder__";
+    let current_values =
+        raw_observation_values_bytes(capture, current_id, "raw relation current observations")?;
+    let current_dimension = capture
+        .dimensions
+        .get(current_id as usize)
+        .copied()
+        .ok_or_else(|| invalid("raw relation current dimension is absent"))?;
+    let (representative_values, representative_raw) =
+        if let Some(representative_id) = representative_id {
+            (
+                serde_json::json!([REPRESENTATIVE_PLACEHOLDER]),
+                Some(raw_observation_values_bytes(
+                    capture,
+                    representative_id,
+                    "raw relation representative observations",
+                )?),
+            )
+        } else {
+            (JsonValue::Null, None)
+        };
+    let payload = serde_json::json!({
+        "abi": "pyamplicol-recurrence-relation-observation-v2",
+        "capture_contract_sha256": capture.capture_contract_sha256,
+        "current_id": current_id,
+        "representative_id": representative_id,
+        "relation_kind": relation_kind,
+        "current_dimension": current_dimension,
+        "current_values": [CURRENT_PLACEHOLDER],
+        "representative_values": representative_values,
+    });
+    let mut replacements = vec![(CURRENT_PLACEHOLDER, current_values)];
+    if let Some(representative_raw) = representative_raw {
+        replacements.push((REPRESENTATIVE_PLACEHOLDER, representative_raw));
+    }
+    canonical_json_sha256_with_raw_arrays(
+        &payload,
+        &replacements,
+        "raw numerical relation observations",
+    )
+}
+
+fn rational_string(value: &BigRational) -> String {
+    if value.denom().is_one() {
+        value.numer().to_string()
+    } else {
+        format!("{}/{}", value.numer(), value.denom())
+    }
+}
+
+fn evidence_sha256(
+    object: &JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<String> {
+    let value = json_string(object, field, context)?;
+    semantic_digest_from_hex(value, context)?;
+    Ok(value.to_owned())
+}
+
+fn evidence_usize(
+    object: &JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<usize> {
+    json_field(object, field, context)?
+        .as_u64()
+        .and_then(|value| usize::try_from(value).ok())
+        .ok_or_else(|| invalid(format!("{context} must be a nonnegative usize")))
+}
+
+fn json_u64(
+    object: &JsonMap<String, JsonValue>,
+    field: &str,
+    context: &str,
+) -> RusticolResult<u64> {
+    json_field(object, field, context)?
+        .as_u64()
+        .ok_or_else(|| invalid(format!("{context} must be a nonnegative u64")))
+}
+
+fn python_f64_hex(value: f64) -> String {
+    let bits = value.to_bits();
+    if bits & 0x7fff_ffff_ffff_ffff == 0 {
+        return "0x0.0p+0".to_owned();
+    }
+    let exponent_bits = ((bits >> 52) & 0x7ff) as i32;
+    let fraction = bits & ((1_u64 << 52) - 1);
+    let (leading, exponent) = if exponent_bits == 0 {
+        (0, -1022)
+    } else {
+        (1, exponent_bits - 1023)
+    };
+    format!("0x{leading}.{fraction:013x}p{exponent:+}")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use flate2::{Compression, write::ZlibEncoder};
+    use rusticol_core::recurrence::RecurrenceRelationDiscoveryOptions;
+    use serde_json::json;
+
+    fn digest(seed: u8) -> String {
+        format!("{seed:02x}").repeat(32)
+    }
+
+    fn empty_runtime_parameter_contract() -> AuthenticatedRuntimeParameterContract {
+        let schema = json!({
+            "abi": "pyamplicol-recurrence-runtime-parameter-schema-v2",
+            "parameters": [],
+        });
+        AuthenticatedRuntimeParameterContract {
+            schema_sha256: canonical_json_sha256(&schema, "empty runtime parameter schema")
+                .unwrap(),
+            schema,
+            slots: Vec::new(),
+            process_id: "raw-v3-test".to_owned(),
+            physical_pdgs: vec![1],
+        }
+    }
+
+    fn parse_fixture(bytes: &[u8]) -> RusticolResult<RecurrenceNumericalRelationEvidence> {
+        parse_numerical_relation_evidence(bytes, &empty_runtime_parameter_contract())
+    }
+
+    fn scanner_source(metadata_bytes: &[u8]) -> (JsonValue, RawSourceSemantics) {
+        let metadata: JsonValue = serde_json::from_slice(metadata_bytes).unwrap();
+        let object = metadata.as_object().unwrap();
+        let source_semantics_sha256 = object["source_semantics_sha256"].as_str().unwrap();
+        let source = parse_raw_source_semantics(
+            &object["source_semantics"],
+            source_semantics_sha256,
+            object["schedule_semantic_digest"].as_str().unwrap(),
+            object["baseline_runtime_layout_digest"].as_str().unwrap(),
+            &empty_runtime_parameter_contract(),
+        )
+        .unwrap();
+        (metadata, source)
+    }
+
+    fn capture_from_observation_array<'a>(
+        encoded: &'a [u8],
+        source: &RawSourceSemantics,
+        point_count: usize,
+    ) -> RawNumericalCapture<'a> {
+        let observation_array =
+            RawByteRange::from_usize(0, encoded.len(), encoded.len(), "test observation array")
+                .unwrap();
+        let observation_rows =
+            scan_raw_observation_array(encoded, observation_array, source, point_count, "test")
+                .unwrap();
+        RawNumericalCapture {
+            raw_bytes: encoded,
+            observation_rows,
+            point_count,
+            point_sha256s: Vec::new(),
+            kinematic_sha256s: Vec::new(),
+            parameter_context_sha256s: Vec::new(),
+            parameter_contexts: Vec::new(),
+            dimensions: source
+                .currents
+                .iter()
+                .map(|current| current.dimension)
+                .collect(),
+            observation_batch_sha256: digest(80),
+            capture_contract_sha256: digest(81),
+        }
+    }
+
+    fn refresh_numerical_certificate_set_digest(value: &mut JsonValue) {
+        let object = value.as_object().unwrap();
+        let relation_set = json!({
+            "abi": "pyamplicol-authenticated-numerical-current-relation-set-v2",
+            "certificates": object["certificates"].clone(),
+            "mappings": object["mappings"].clone(),
+        });
+        let digest =
+            canonical_json_sha256(&relation_set, "test numerical relation certificate set")
+                .unwrap();
+        value
+            .as_object_mut()
+            .unwrap()
+            .insert("certificate_set_sha256".to_owned(), json!(digest));
+    }
+
+    fn raw_capture_fixture(
+        domain: &str,
+        point_base: u32,
+        source_semantics_sha256: &str,
+        runtime_parameter_schema_sha256: &str,
+        seed: u64,
+    ) -> JsonValue {
+        let points = (0..4_u32)
+            .map(|index| {
+                let value = point_base + index;
+                json!({
+                    "schema_version": 1,
+                    "kind": "pyamplicol-rusticol-validation-momenta",
+                    "process_id": "raw-v3-test",
+                    "process": "1 -> 1",
+                    "seed": domain_seed(seed, domain, index as usize),
+                    "available": true,
+                    "error": null,
+                    "points": [[{
+                        "pdg": 1,
+                        "momentum": [value.to_string(), "0", "0", "0"],
+                    }]],
+                })
+            })
+            .collect::<Vec<_>>();
+        let point_sha256s = points
+            .iter()
+            .map(|point| canonical_json_sha256(point, "fixture point").unwrap())
+            .collect::<Vec<_>>();
+        let kinematic_binary64 = (0..4_u32)
+            .map(|index| {
+                json!([[
+                    python_f64_hex(f64::from(point_base + index)),
+                    "0x0.0p+0",
+                    "0x0.0p+0",
+                    "0x0.0p+0",
+                ]])
+            })
+            .collect::<Vec<_>>();
+        let kinematic_sha256s = kinematic_binary64
+            .iter()
+            .map(|row| canonical_json_sha256(row, "fixture kinematics").unwrap())
+            .collect::<Vec<_>>();
+        let selector_contexts = (0..4)
+            .map(|_| {
+                json!({
+                    "strategy": "contracted-color-union",
+                    "fixed_source_schedule": true,
+                })
+            })
+            .collect::<Vec<_>>();
+        let selector_context_sha256s = selector_contexts
+            .iter()
+            .map(|row| canonical_json_sha256(row, "fixture selector").unwrap())
+            .collect::<Vec<_>>();
+        let parameter_contexts = vec![json!([]); 4];
+        let parameter_context_sha256s = (0..4)
+            .map(|point_index| {
+                canonical_json_sha256(
+                    &json!({
+                        "abi": "pyamplicol-recurrence-parameter-context-v1",
+                        "domain": domain,
+                        "point_index": point_index,
+                        "point_sha256": point_sha256s[point_index],
+                        "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+                        "values": [],
+                    }),
+                    "fixture parameter context",
+                )
+                .unwrap()
+            })
+            .collect::<Vec<_>>();
+        let observation_scalars = [
+            [1_i64, 1, 1, 1],
+            [2, 3, 4, 5],
+            [2, 3, 4, 5],
+            [-2, -3, -4, -5],
+            [0, 0, 0, 0],
+            [7, 8, 9, 11],
+        ];
+        let observations = observation_scalars
+            .iter()
+            .enumerate()
+            .map(|(current_id, values)| {
+                json!({
+                    "current_id": current_id,
+                    "dimension": 1,
+                    "values": values
+                        .iter()
+                        .map(|value| json!([value.to_string(), "0"]))
+                        .collect::<Vec<_>>(),
+                })
+            })
+            .collect::<Vec<_>>();
+        let dimensions = (0..observation_scalars.len())
+            .map(|current_id| json!({"current_id": current_id, "dimension": 1}))
+            .collect::<Vec<_>>();
+        let observation_batch_sha256 = canonical_json_sha256(
+            &json!({
+                "abi": "pyamplicol-recurrence-current-observation-batch-v2",
+                "source_semantics_sha256": source_semantics_sha256,
+                "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+                "point_sha256s": point_sha256s,
+                "selector_context_sha256s": selector_context_sha256s,
+                "parameter_context_sha256s": parameter_context_sha256s,
+                "currents": observations,
+            }),
+            "fixture observation batch",
+        )
+        .unwrap();
+        let capture_contract_sha256 = canonical_json_sha256(
+            &json!({
+                "abi": "pyamplicol-recurrence-current-observation-capture-v2",
+                "precision_digits": 96,
+                "source_semantics_sha256": source_semantics_sha256,
+                "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+                "point_sha256s": point_sha256s,
+                "kinematic_sha256s": kinematic_sha256s,
+                "selector_context_sha256s": selector_context_sha256s,
+                "parameter_context_sha256s": parameter_context_sha256s,
+                "current_dimensions": dimensions,
+                "observation_batch_sha256": observation_batch_sha256,
+                "context_policy": "fixed-contracted-source-schedule-v1",
+            }),
+            "fixture capture contract",
+        )
+        .unwrap();
+        let dimensions_object = (0..observation_scalars.len())
+            .map(|current_id| (current_id.to_string(), json!(1)))
+            .collect::<JsonMap<_, _>>();
+        let value = json!({
+            "abi": "pyamplicol-recurrence-current-observation-capture-v2",
+            "precision_digits": 96,
+            "point_count": 4,
+            "point_sha256s": point_sha256s,
+            "kinematic_sha256s": kinematic_sha256s,
+            "parameter_contexts": parameter_contexts,
+            "parameter_context_sha256s": parameter_context_sha256s,
+            "context_sha256s": selector_context_sha256s,
+            "points": points,
+            "current_count": observation_scalars.len(),
+            "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+            "source_semantics_sha256": source_semantics_sha256,
+            "observation_batch_sha256": observation_batch_sha256,
+            "capture_contract_sha256": capture_contract_sha256,
+            "context_policy": "fixed-contracted-source-schedule-v1",
+            "complete_current_components": true,
+            "point_major": true,
+            "current_dimensions_sha256": canonical_json_sha256(
+                &JsonValue::Object(dimensions_object),
+                "fixture dimensions",
+            ).unwrap(),
+            "evaluator": "recurrence-direct-plan-decimal-symbolica-exact",
+            "kinematic_binary64": kinematic_binary64,
+            "selector_contexts": selector_contexts,
+            "current_dimensions": dimensions,
+            "observations": observations,
+        });
+        value
+    }
+
+    fn canonical_numerical_relation_evidence() -> JsonValue {
+        canonical_numerical_relation_evidence_with_tolerances(1.0e-70, 1.0e-80)
+    }
+
+    fn canonical_numerical_relation_evidence_with_tolerances(
+        relative_tolerance: f64,
+        absolute_tolerance: f64,
+    ) -> JsonValue {
+        let seed = 0x5059_414d_u64;
+        let source_semantics = json!({
+            "abi": "pyamplicol-recurrence-numerical-current-source-v3",
+            "process_id": "raw-v3-test",
+            "strategy": "contracted-color-union",
+            "schedule_semantic_digest": digest(40),
+            "baseline_runtime_layout_digest": digest(41),
+            "selector_schedule": {
+                "policy": "fixed-contracted-source-schedule-v1",
+                "fixed_source_schedule": true,
+            },
+            "currents": (0..6_u32).map(|current_id| json!({
+                "current_id": current_id,
+                "is_source": current_id == 0,
+                "contract": [
+                    if current_id == 0 { 0 } else { 1 },
+                    1, 7, 1, 0, 0, u32::MAX, u32::MAX, ["1", "1", "0", "1"],
+                ],
+            })).collect::<Vec<_>>(),
+        });
+        let source_semantics_sha256 =
+            canonical_json_sha256(&source_semantics, "fixture source semantics").unwrap();
+        let source = parse_raw_source_semantics(
+            &source_semantics,
+            &source_semantics_sha256,
+            &digest(40),
+            &digest(41),
+            &empty_runtime_parameter_contract(),
+        )
+        .unwrap();
+        let runtime_parameter_schema = json!({
+            "abi": "pyamplicol-recurrence-runtime-parameter-schema-v2",
+            "parameters": [],
+        });
+        let runtime_parameter_schema_sha256 = canonical_json_sha256(
+            &runtime_parameter_schema,
+            "fixture runtime parameter schema",
+        )
+        .unwrap();
+        let candidate_value = raw_capture_fixture(
+            "candidate-current-probes-v1",
+            1,
+            &source_semantics_sha256,
+            &runtime_parameter_schema_sha256,
+            seed,
+        );
+        let verification_value = raw_capture_fixture(
+            "independent-verification-current-probes-v1",
+            101,
+            &source_semantics_sha256,
+            &runtime_parameter_schema_sha256,
+            seed,
+        );
+        let fixture_wire = canonical_json_bytes(
+            &json!({
+                "candidate_capture": candidate_value.clone(),
+                "verification_capture": verification_value.clone(),
+            }),
+            "raw capture fixture wire",
+        )
+        .unwrap();
+        let located = locate_raw_observation_arrays(&fixture_wire).unwrap();
+        let metadata: JsonValue = serde_json::from_slice(&located.metadata_bytes).unwrap();
+        let candidate = parse_raw_numerical_capture(
+            &fixture_wire,
+            located.candidate,
+            &metadata["candidate_capture"],
+            "candidate",
+            "candidate-current-probes-v1",
+            96,
+            4,
+            &source,
+            &source_semantics_sha256,
+            &runtime_parameter_schema_sha256,
+            0,
+            seed,
+        )
+        .unwrap();
+        let verification = parse_raw_numerical_capture(
+            &fixture_wire,
+            located.verification,
+            &metadata["verification_capture"],
+            "verification",
+            "independent-verification-current-probes-v1",
+            96,
+            4,
+            &source,
+            &source_semantics_sha256,
+            &runtime_parameter_schema_sha256,
+            0,
+            seed,
+        )
+        .unwrap();
+        validate_independent_raw_captures(
+            &candidate,
+            &verification,
+            &empty_runtime_parameter_contract(),
+            seed,
+        )
+        .unwrap();
+        let mut derivation_telemetry = RecurrenceEvidenceAuthenticationTelemetry::default();
+        let derivation = derive_raw_numerical_relations(
+            &source,
+            &candidate,
+            &verification,
+            96,
+            seed,
+            &exact_binary64_rational(relative_tolerance).unwrap(),
+            &exact_binary64_rational(absolute_tolerance).unwrap(),
+            &python_f64_hex(relative_tolerance),
+            &python_f64_hex(absolute_tolerance),
+            &runtime_parameter_schema_sha256,
+            rusticol_core::recurrence::NUMERICAL_RELATION_CERTIFICATE_ALGORITHM,
+            &mut derivation_telemetry,
+        )
+        .unwrap();
+        assert_eq!(
+            derivation
+                .relations
+                .iter()
+                .map(|relation| relation.mapping.relation_kind.as_str())
+                .collect::<Vec<_>>(),
+            ["equal", "opposite", "zero"],
+        );
+        let certificates = derivation
+            .relations
+            .iter()
+            .map(|relation| relation.certificate.clone())
+            .collect::<Vec<_>>();
+        let mappings = derivation
+            .relations
+            .iter()
+            .map(|relation| relation.mapping_json.clone())
+            .collect::<Vec<_>>();
+        let mut evidence = json!({
+            "abi": "pyamplicol-recurrence-numerical-current-evidence-v3",
+            "requested_mode": "certified-reuse",
+            "schedule_semantic_digest": digest(40),
+            "baseline_runtime_layout_digest": digest(41),
+            "source_semantics": source_semantics,
+            "source_semantics_sha256": source_semantics_sha256,
+            "runtime_parameter_schema": runtime_parameter_schema,
+            "runtime_parameter_schema_sha256": runtime_parameter_schema_sha256,
+            "candidate_capture": candidate_value,
+            "verification_capture": verification_value,
+            "certificate_algorithm":
+                rusticol_core::recurrence::NUMERICAL_RELATION_CERTIFICATE_ALGORITHM,
+            "certificate_set_sha256": digest(0),
+            "precision_digits": 96,
+            "probe_count": 4,
+            "verification_probe_count": 4,
+            "relative_tolerance_binary64": python_f64_hex(relative_tolerance),
+            "absolute_tolerance_binary64": python_f64_hex(absolute_tolerance),
+            "seed": seed,
+            "candidate_index": {
+                "algorithm": "complete-contract-anchor-tolerance-window-v1",
+                "completeness": "complete-within-configured-tolerance",
+                "contract_count": derivation.candidate_index_contract_count,
+                "exhaustive_fallback_contract_count":
+                    derivation.exhaustive_fallback_contract_count,
+                "theoretical_pair_hypothesis_count":
+                    derivation.theoretical_pair_hypothesis_count,
+                "screened_pair_hypothesis_count":
+                    derivation.screened_pair_hypothesis_count,
+                "zero_hypothesis_count": derivation.zero_hypothesis_count,
+                "nearest_rejected_scope":
+                    "zero-and-tolerance-window-screened-hypotheses",
+            },
+            "numerical_candidate_count": derivation.numerical_candidate_count,
+            "verification_rejected_count": derivation.verification_rejected_count,
+            "rejected_hypothesis_count": derivation.rejected_hypothesis_count,
+            "tested_hypothesis_count": derivation.tested_hypothesis_count,
+            "decision_sha256": derivation.decision_sha256,
+            "rejection_decision_sha256":
+                derivation.rejection_decision_sha256,
+            "certificates": certificates,
+            "mappings": mappings,
+        });
+        refresh_numerical_certificate_set_digest(&mut evidence);
+        evidence
+    }
+
+    #[test]
+    fn numerical_relation_evidence_recomputes_every_digest_layer() {
+        let evidence = canonical_numerical_relation_evidence();
+        let encoded = canonical_json_bytes(&evidence, "test numerical evidence").unwrap();
+        assert_eq!(encoded.len(), 16_778);
+        assert_eq!(
+            hex_digest(Sha256::digest(&encoded)),
+            "aceda1cf45eddf400159f8ce7f60c3bc0de399273fd7a035b5343544d7b19c96",
+        );
+        assert_eq!(
+            evidence["decision_sha256"],
+            "e1899c8791f374e406550435e7ff3e3c57044be2a9161b3f39a023df283cc403",
+        );
+        assert_eq!(
+            evidence["rejection_decision_sha256"],
+            "ff294e07e4c84a5c6645c71ad1b9c55aff8dc5f7bfa302b3f20c367ffcfa01be",
+        );
+        assert_eq!(
+            evidence["certificate_set_sha256"],
+            "5c500444d772f455df8650acaa1d38ca75638452b84c8e9bc0a5037756a04c97",
+        );
+        let parsed = parse_fixture(&encoded).unwrap();
+        assert_eq!(parsed.mappings.len(), 3);
+        assert_eq!(
+            parsed.rejected_hypothesis_count,
+            parsed.tested_hypothesis_count - parsed.mappings.len(),
+        );
+        assert!(parsed.rejected_hypothesis_count > parsed.verification_rejected_count);
+
+        let mut stale_set = evidence.clone();
+        stale_set["certificates"][0]["current_dimension"] = json!(3);
+        let stale_bytes =
+            canonical_json_bytes(&stale_set, "stale numerical certificate set").unwrap();
+        assert!(
+            parse_fixture(&stale_bytes)
+                .unwrap_err()
+                .to_string()
+                .contains("not derived from raw observations")
+        );
+
+        let mut stale_proof = evidence.clone();
+        stale_proof["certificates"][0]["candidate_maximum_absolute_residual"] = json!("1e-90");
+        refresh_numerical_certificate_set_digest(&mut stale_proof);
+        let stale_bytes = canonical_json_bytes(&stale_proof, "stale numerical proof").unwrap();
+        assert!(
+            parse_fixture(&stale_bytes)
+                .unwrap_err()
+                .to_string()
+                .contains("not derived from raw observations")
+        );
+
+        let mut stale_mapping = evidence.clone();
+        stale_mapping["mappings"][0]["current_dimension"] = json!(3);
+        refresh_numerical_certificate_set_digest(&mut stale_mapping);
+        let stale_bytes = canonical_json_bytes(&stale_mapping, "stale numerical mapping").unwrap();
+        assert!(
+            parse_fixture(&stale_bytes)
+                .unwrap_err()
+                .to_string()
+                .contains("not derived from raw observations")
+        );
+
+        let mut stale_tolerance = evidence;
+        stale_tolerance["relative_tolerance_binary64"] = json!("0x1.0p+0");
+        let stale_bytes =
+            canonical_json_bytes(&stale_tolerance, "stale numerical tolerance").unwrap();
+        assert!(
+            parse_fixture(&stale_bytes)
+                .unwrap_err()
+                .to_string()
+                .contains("canonical nonnegative finite binary64")
+        );
+
+        let mut stale_index = canonical_numerical_relation_evidence();
+        stale_index["candidate_index"]["screened_pair_hypothesis_count"] = json!(99);
+        let stale_bytes =
+            canonical_json_bytes(&stale_index, "stale numerical candidate index").unwrap();
+        assert!(
+            parse_fixture(&stale_bytes)
+                .unwrap_err()
+                .to_string()
+                .contains("was not independently derived")
+        );
+    }
+
+    #[test]
+    fn profiled_evidence_authentication_is_semantically_identical() {
+        let evidence = canonical_numerical_relation_evidence();
+        let encoded = canonical_json_bytes(&evidence, "profiled numerical evidence").unwrap();
+        let expected = parse_fixture(&encoded).unwrap();
+        let (profiled, telemetry) = parse_numerical_relation_evidence_with_telemetry(
+            &encoded,
+            &empty_runtime_parameter_contract(),
+        )
+        .unwrap();
+
+        assert_eq!(profiled, expected);
+        assert_eq!(telemetry.transport_decode_nanoseconds, 0);
+        assert!(telemetry.total_nanoseconds >= telemetry.candidate_index_nanoseconds);
+        assert!(telemetry.total_nanoseconds >= telemetry.hypothesis_replay_nanoseconds);
+        assert!(telemetry.total_nanoseconds >= telemetry.evidence_finalization_nanoseconds);
+        assert_eq!(
+            (
+                telemetry.candidate_index_observation_row_scan_count,
+                telemetry.retained_selected_observation_count,
+                telemetry.selected_observation_reuse_count,
+                telemetry.zero_residual_streamed_value_count,
+                telemetry.materialized_observation_vector_count,
+                telemetry.rational_string_materialization_count,
+                telemetry.rational_string_use_count,
+                telemetry.rational_string_reuse_count,
+            ),
+            (6, 6, 11, 24, 8, 30, 78, 48),
+        );
+
+        let compressed = compressed_envelope(&encoded);
+        let (compressed_profiled, compressed_telemetry) =
+            parse_numerical_relation_evidence_with_telemetry(
+                &compressed,
+                &empty_runtime_parameter_contract(),
+            )
+            .unwrap();
+        assert_eq!(compressed_profiled, expected);
+        assert!(
+            compressed_telemetry.total_nanoseconds
+                >= compressed_telemetry.transport_decode_nanoseconds
+        );
+        assert_eq!(
+            compressed_telemetry.rational_string_reuse_count,
+            telemetry.rational_string_reuse_count,
+        );
+    }
+
+    #[test]
+    fn candidate_index_retains_the_exact_selected_observations() {
+        let source = RawSourceSemantics {
+            value: json!({}),
+            process_id: "selected-observation-test".to_owned(),
+            physical_pdgs: vec![1],
+            strategy: "contracted-color-union".to_owned(),
+            selector_schedule: json!({}),
+            currents: (0..3)
+                .map(|current_id| RawSourceCurrent {
+                    current_id,
+                    is_source: false,
+                    contract_key: vec![7],
+                    dimension: 1,
+                    selector_domain_id: 0,
+                })
+                .collect(),
+        };
+        let bytes = canonical_json_bytes(
+            &json!([
+                {"current_id": 0, "dimension": 1, "values": [["1", "10"], ["4", "0"]]},
+                {"current_id": 1, "dimension": 1, "values": [["2", "10"], ["4", "0"]]},
+                {"current_id": 2, "dimension": 1, "values": [["3", "10"], ["4", "0"]]},
+            ]),
+            "selected observation fixture",
+        )
+        .unwrap();
+        let capture = capture_from_observation_array(&bytes, &source, 2);
+        let mut telemetry = RecurrenceEvidenceAuthenticationTelemetry::default();
+        let indexes =
+            build_raw_numerical_candidate_indexes(&source, &capture, &mut telemetry).unwrap();
+        let index = indexes.get(&vec![7]).unwrap();
+
+        assert_eq!((index.observation_index, index.scalar_component), (0, 0));
+        for current_id in 0..3 {
+            assert_eq!(
+                index
+                    .selected_value(current_id, "retained selected observation")
+                    .unwrap(),
+                &raw_observation_value(
+                    &capture,
+                    current_id,
+                    index.observation_index,
+                    "retained selected observation",
+                )
+                .unwrap(),
+            );
+        }
+        assert_eq!(telemetry.candidate_index_observation_row_scan_count, 3);
+        assert_eq!(telemetry.retained_selected_observation_count, 3);
+        assert_eq!(telemetry.selected_observation_reuse_count, 3);
+        assert!(
+            index
+                .selected_value(u32::MAX, "retained selected observation")
+                .unwrap_err()
+                .to_string()
+                .contains("selected observation is absent")
+        );
+    }
+
+    #[test]
+    fn multi_helicity_all_flow_domains_contribute_no_raw_hypotheses() {
+        let source_value = json!({"synthetic": "multi-helicity-all-flow"});
+        let source = RawSourceSemantics {
+            value: source_value.clone(),
+            process_id: "unsafe-selector-domain-test".to_owned(),
+            physical_pdgs: vec![1],
+            strategy: "all-flow-union".to_owned(),
+            selector_schedule: json!({
+                "policy": "seeded-helicity-per-selector-domain-and-physical-point-v1",
+                "resolved_helicities": [
+                    {"helicity_index": 0, "helicity_id": 0, "selector_domain_id": 0},
+                    {"helicity_index": 1, "helicity_id": 2, "selector_domain_id": 0},
+                ],
+            }),
+            currents: (0..3)
+                .map(|current_id| RawSourceCurrent {
+                    current_id,
+                    is_source: current_id == 0,
+                    contract_key: vec![7],
+                    dimension: 1,
+                    selector_domain_id: 0,
+                })
+                .collect(),
+        };
+        let bytes = canonical_json_bytes(
+            &json!([
+                {"current_id": 0, "dimension": 1, "values": [["1", "0"], ["1", "0"]]},
+                {"current_id": 1, "dimension": 1, "values": [["1", "0"], ["1", "0"]]},
+                {"current_id": 2, "dimension": 1, "values": [["1", "0"], ["1", "0"]]},
+            ]),
+            "unsafe selector-domain observations",
+        )
+        .unwrap();
+        let candidate = capture_from_observation_array(&bytes, &source, 2);
+        let verification = capture_from_observation_array(&bytes, &source, 2);
+        let runtime_parameter_schema_sha256 = digest(82);
+        let mut telemetry = RecurrenceEvidenceAuthenticationTelemetry::default();
+        let derivation = derive_raw_numerical_relations(
+            &source,
+            &candidate,
+            &verification,
+            96,
+            67,
+            &exact_binary64_rational(1.0e-70).unwrap(),
+            &exact_binary64_rational(1.0e-80).unwrap(),
+            &python_f64_hex(1.0e-70),
+            &python_f64_hex(1.0e-80),
+            &runtime_parameter_schema_sha256,
+            rusticol_core::recurrence::NUMERICAL_RELATION_CERTIFICATE_ALGORITHM,
+            &mut telemetry,
+        )
+        .unwrap();
+
+        assert!(derivation.relations.is_empty());
+        assert_eq!(derivation.tested_hypothesis_count, 0);
+        assert_eq!(derivation.theoretical_pair_hypothesis_count, 0);
+        assert_eq!(derivation.screened_pair_hypothesis_count, 0);
+        assert_eq!(derivation.zero_hypothesis_count, 0);
+        let chain_root = canonical_json_sha256(
+            &json!({
+                "abi": "pyamplicol-recurrence-numerical-decision-chain-v1",
+                "source_semantics_sha256": canonical_json_sha256(
+                    &source_value,
+                    "unsafe selector-domain source",
+                ).unwrap(),
+                "candidate_capture_sha256": candidate.capture_contract_sha256,
+                "verification_capture_sha256": verification.capture_contract_sha256,
+            }),
+            "unsafe selector-domain decision root",
+        )
+        .unwrap();
+        let expected = canonical_json_sha256(
+            &json!({
+                "abi": "pyamplicol-recurrence-numerical-decision-chain-v1",
+                "chain_tail_sha256": chain_root,
+                "tested_hypothesis_count": 0,
+                "theoretical_pair_hypothesis_count": 0,
+                "screened_pair_hypothesis_count": 0,
+                "zero_hypothesis_count": 0,
+                "numerical_candidate_count": 0,
+                "verification_rejected_count": 0,
+                "rejected_hypothesis_count": 0,
+                "certified_relation_count": 0,
+            }),
+            "unsafe selector-domain decision census",
+        )
+        .unwrap();
+        assert_eq!(derivation.decision_sha256, expected);
+    }
+
+    #[test]
+    fn zero_residuals_stream_without_materialized_comparison_vectors() {
+        let source = RawSourceSemantics {
+            value: json!({}),
+            process_id: "zero-residual-test".to_owned(),
+            physical_pdgs: vec![1],
+            strategy: "contracted-color-union".to_owned(),
+            selector_schedule: json!({}),
+            currents: vec![RawSourceCurrent {
+                current_id: 0,
+                is_source: false,
+                contract_key: vec![1],
+                dimension: 1,
+                selector_domain_id: 0,
+            }],
+        };
+        let bytes = canonical_json_bytes(
+            &json!([
+                {"current_id": 0, "dimension": 1, "values": [["3", "4"], ["0", "0"]]},
+            ]),
+            "zero residual fixture",
+        )
+        .unwrap();
+        let capture = capture_from_observation_array(&bytes, &source, 2);
+        let mut telemetry = RecurrenceEvidenceAuthenticationTelemetry::default();
+        let residuals = relation_residuals(
+            "zero",
+            0,
+            None,
+            &capture,
+            &BigRational::zero(),
+            &BigRational::one(),
+            &mut telemetry,
+        )
+        .unwrap();
+
+        assert_eq!(residuals.maximum_ratio, BigRational::from_integer(4.into()));
+        assert_eq!(residuals.strings.maximum_absolute, "4");
+        assert_eq!(residuals.strings.maximum_relative, "1");
+        assert_eq!(residuals.strings.maximum_ratio, "4");
+        assert_eq!(telemetry.zero_residual_streamed_value_count, 2);
+        assert_eq!(telemetry.materialized_observation_vector_count, 0);
+        assert_eq!(telemetry.rational_string_materialization_count, 3);
+    }
+
+    #[test]
+    #[ignore = "manual recurrence evidence-authentication microbenchmark"]
+    fn benchmark_canonical_evidence_authentication() {
+        let evidence = canonical_numerical_relation_evidence();
+        let encoded = canonical_json_bytes(&evidence, "benchmark numerical evidence").unwrap();
+        let started = std::time::Instant::now();
+        for _ in 0..50 {
+            let parsed = parse_fixture(&encoded).unwrap();
+            assert_eq!(parsed.mappings.len(), 3);
+        }
+        eprintln!(
+            "evidence-authentication-benchmark iterations=50 elapsed_ns={}",
+            started.elapsed().as_nanos()
+        );
+    }
+
+    #[test]
+    fn raw_probe_identity_is_bound_to_the_authenticated_process_and_seed_domain() {
+        fn mutate_first_candidate_point(
+            mut evidence: JsonValue,
+            field: &str,
+            value: JsonValue,
+        ) -> Vec<u8> {
+            evidence["candidate_capture"]["points"][0][field] = value;
+            let digest = canonical_json_sha256(
+                &evidence["candidate_capture"]["points"][0],
+                "tampered candidate point",
+            )
+            .unwrap();
+            evidence["candidate_capture"]["point_sha256s"][0] = json!(digest);
+            canonical_json_bytes(&evidence, "tampered probe identity").unwrap()
+        }
+
+        let wrong_id = mutate_first_candidate_point(
+            canonical_numerical_relation_evidence(),
+            "process_id",
+            json!("unrelated-process"),
+        );
+        assert!(
+            parse_fixture(&wrong_id)
+                .unwrap_err()
+                .to_string()
+                .contains("process_id")
+        );
+
+        let wrong_pdg = mutate_first_candidate_point(
+            canonical_numerical_relation_evidence(),
+            "points",
+            json!([[{
+                "pdg": -1,
+                "momentum": ["1", "0", "0", "0"],
+            }]]),
+        );
+        assert!(
+            parse_fixture(&wrong_pdg)
+                .unwrap_err()
+                .to_string()
+                .contains("authenticated recurrence process")
+        );
+
+        let wrong_seed =
+            mutate_first_candidate_point(canonical_numerical_relation_evidence(), "seed", json!(0));
+        assert!(
+            parse_fixture(&wrong_seed)
+                .unwrap_err()
+                .to_string()
+                .contains("validation-point seed is stale")
+        );
+    }
+
+    #[test]
+    fn numerical_relation_evidence_accepts_canonical_binary64_tolerance_boundaries() {
+        for (relative, absolute) in [
+            (1.0e-8, 1.0e-9),
+            (f64::from_bits(1), 0.0),
+            (f64::MIN_POSITIVE, f64::from_bits(1)),
+            (0.25, 0.0),
+        ] {
+            let evidence =
+                canonical_numerical_relation_evidence_with_tolerances(relative, absolute);
+            let encoded = canonical_json_bytes(&evidence, "boundary tolerance evidence").unwrap();
+            let parsed = parse_fixture(&encoded).unwrap();
+            assert_eq!(parsed.relative_tolerance.to_bits(), relative.to_bits());
+            assert_eq!(parsed.absolute_tolerance.to_bits(), absolute.to_bits());
+        }
+        let (maximum, exact) =
+            parse_nonnegative_python_f64_hex(&python_f64_hex(f64::MAX), "maximum").unwrap();
+        assert_eq!(maximum, f64::MAX);
+        assert_eq!(exact, exact_binary64_rational(f64::MAX).unwrap());
+    }
+
+    #[test]
+    fn numerical_relation_evidence_rejects_nonfinite_negative_zero_and_noncanonical_tolerances() {
+        for invalid_tolerance in [
+            "nan",
+            "inf",
+            "-0x0.0p+0",
+            "0x1.0p-3",
+            "0X1.0000000000000P-3",
+        ] {
+            let mut evidence = canonical_numerical_relation_evidence();
+            evidence["relative_tolerance_binary64"] = json!(invalid_tolerance);
+            let encoded = canonical_json_bytes(&evidence, "invalid tolerance evidence").unwrap();
+            assert!(
+                parse_fixture(&encoded)
+                    .unwrap_err()
+                    .to_string()
+                    .contains("canonical nonnegative finite binary64")
+            );
+        }
+        let mut zero = canonical_numerical_relation_evidence();
+        zero["relative_tolerance_binary64"] = json!("0x0.0p+0");
+        zero["absolute_tolerance_binary64"] = json!("0x0.0p+0");
+        let encoded = canonical_json_bytes(&zero, "zero tolerance evidence").unwrap();
+        assert!(
+            parse_fixture(&encoded)
+                .unwrap_err()
+                .to_string()
+                .contains("cannot both be zero")
+        );
+    }
+
+    #[test]
+    fn observation_locator_builds_canonical_metadata_and_authenticated_offsets() {
+        let evidence = canonical_numerical_relation_evidence();
+        let encoded = canonical_json_bytes(&evidence, "observation locator fixture").unwrap();
+        let located = locate_raw_observation_arrays(&encoded).unwrap();
+        let (metadata, source) = scanner_source(&located.metadata_bytes);
+        validate_canonical_json_bytes(
+            &metadata,
+            &located.metadata_bytes,
+            "observation locator metadata",
+        )
+        .unwrap();
+        assert_eq!(metadata["candidate_capture"]["observations"], json!([]));
+        assert_eq!(metadata["verification_capture"]["observations"], json!([]));
+        let candidate =
+            scan_raw_observation_array(&encoded, located.candidate, &source, 4, "candidate")
+                .unwrap();
+        let verification =
+            scan_raw_observation_array(&encoded, located.verification, &source, 4, "verification")
+                .unwrap();
+        assert_eq!(candidate.len(), source.currents.len());
+        assert_eq!(verification.len(), source.currents.len());
+        assert!(candidate.iter().all(|row| row.row.start < row.row.end));
+        assert!(
+            candidate
+                .iter()
+                .all(|row| row.row.start <= row.values.start && row.values.end <= row.row.end)
+        );
+    }
+
+    #[test]
+    fn observation_scanner_rejects_truncated_reordered_extra_and_wrong_width_rows() {
+        let evidence = canonical_numerical_relation_evidence();
+        let encoded = canonical_json_bytes(&evidence, "observation scanner fixture").unwrap();
+        let located = locate_raw_observation_arrays(&encoded).unwrap();
+        let (_metadata, source) = scanner_source(&located.metadata_bytes);
+        let candidate_range = located
+            .candidate
+            .as_usize(encoded.len(), "candidate fixture")
+            .unwrap();
+        let candidate = &encoded[candidate_range];
+
+        let truncated = &candidate[..candidate.len() - 1];
+        let truncated_range =
+            RawByteRange::from_usize(0, truncated.len(), truncated.len(), "truncated").unwrap();
+        assert!(
+            scan_raw_observation_array(truncated, truncated_range, &source, 4, "truncated",)
+                .unwrap_err()
+                .to_string()
+                .contains("malformed or not canonical")
+        );
+
+        let text = std::str::from_utf8(candidate).unwrap();
+        let reordered = text.replacen(
+            "{\"current_id\":0,\"dimension\":1,",
+            "{\"dimension\":1,\"current_id\":0,",
+            1,
+        );
+        assert_ne!(reordered, text);
+        let reordered_range =
+            RawByteRange::from_usize(0, reordered.len(), reordered.len(), "reordered").unwrap();
+        assert!(
+            scan_raw_observation_array(
+                reordered.as_bytes(),
+                reordered_range,
+                &source,
+                4,
+                "reordered",
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("malformed or not canonical")
+        );
+
+        let mut extra = candidate[..candidate.len() - 1].to_vec();
+        extra.extend_from_slice(b",{}]");
+        let extra_range = RawByteRange::from_usize(0, extra.len(), extra.len(), "extra").unwrap();
+        assert!(
+            scan_raw_observation_array(&extra, extra_range, &source, 4, "extra")
+                .unwrap_err()
+                .to_string()
+                .contains("malformed or not canonical")
+        );
+
+        let mut wrong_width = evidence["candidate_capture"]["observations"].clone();
+        wrong_width[0]["values"].as_array_mut().unwrap().pop();
+        let wrong_width =
+            canonical_json_bytes(&wrong_width, "wrong-width observation fixture").unwrap();
+        let wrong_width_range =
+            RawByteRange::from_usize(0, wrong_width.len(), wrong_width.len(), "wrong width")
+                .unwrap();
+        assert!(
+            scan_raw_observation_array(&wrong_width, wrong_width_range, &source, 4, "wrong width",)
+                .unwrap_err()
+                .to_string()
+                .contains("malformed or not canonical")
+        );
+
+        let mut wide_scalar = evidence["candidate_capture"]["observations"].clone();
+        wide_scalar[0]["values"][0][0] = json!("1".repeat(16_385));
+        let wide_scalar =
+            canonical_json_bytes(&wide_scalar, "wide-scalar observation fixture").unwrap();
+        let wide_scalar_range =
+            RawByteRange::from_usize(0, wide_scalar.len(), wide_scalar.len(), "wide scalar")
+                .unwrap();
+        scan_raw_observation_array(&wide_scalar, wide_scalar_range, &source, 4, "wide scalar")
+            .unwrap();
+
+        if usize::BITS > 32 {
+            let offset = u32::MAX as usize + 1;
+            assert_eq!(
+                RawByteRange::from_usize(offset, offset, offset, "large offset")
+                    .unwrap()
+                    .as_usize(offset, "large offset")
+                    .unwrap(),
+                offset..offset,
+            );
+        }
+    }
+
+    #[test]
+    fn raw_candidate_index_is_complete_at_equal_and_opposite_boundaries() {
+        fn rational(numerator: i128, denominator: i128) -> BigRational {
+            BigRational::new(BigInt::from(numerator), BigInt::from(denominator))
+        }
+        let mut entries = vec![
+            (rational(100, 9), 0),
+            (rational(-100, 9), 1),
+            (BigRational::from_integer(BigInt::from(1_000)), 2),
+            (BigRational::from_integer(BigInt::from(10)), 4),
+        ];
+        entries.sort();
+        let index = RawNumericalCandidateIndex {
+            observation_index: 0,
+            scalar_component: 0,
+            entries,
+            selected_values: Vec::new(),
+        };
+        let current = (
+            BigRational::from_integer(BigInt::from(10)),
+            BigRational::zero(),
+        );
+        let relative = rational(1, 10);
+        let absolute = BigRational::zero();
+        let boundary_residual = rational(10, 9);
+        assert_eq!((&current.0 - rational(100, 9)).abs(), boundary_residual,);
+        assert_eq!(&relative * rational(100, 9).abs(), boundary_residual,);
+        assert_eq!(
+            raw_numerical_tolerance_window_ids(&index, &current, 4, "equal", &relative, &absolute,)
+                .unwrap(),
+            BTreeSet::from([0]),
+        );
+        assert_eq!(
+            raw_numerical_tolerance_window_ids(
+                &index, &current, 4, "opposite", &relative, &absolute,
+            )
+            .unwrap(),
+            BTreeSet::from([1]),
+        );
+    }
+
+    #[test]
+    fn numerical_relation_options_reject_stale_probe_and_counter_contracts() {
+        let evidence = canonical_numerical_relation_evidence();
+        let encoded = canonical_json_bytes(&evidence, "test numerical evidence").unwrap();
+        let parsed = parse_fixture(&encoded).unwrap();
+        let options = RecurrenceRelationDiscoveryOptions::new(
+            RecurrenceRelationDiscoveryMode::CertifiedReuse,
+            96,
+            4,
+            4,
+            1.0e-70,
+            1.0e-80,
+            0x5059_414d,
+            "lc",
+        )
+        .unwrap();
+        options
+            .clone()
+            .with_numerical_evidence(parsed.clone())
+            .unwrap();
+
+        let mut stale_probe = parsed.clone();
+        stale_probe.probe_count = 5;
+        assert!(
+            options
+                .clone()
+                .with_numerical_evidence(stale_probe)
+                .unwrap_err()
+                .to_string()
+                .contains("probe contract")
+        );
+
+        let mut stale_counters = parsed;
+        stale_counters.verification_rejected_count = 1;
+        assert!(
+            options
+                .with_numerical_evidence(stale_counters)
+                .unwrap_err()
+                .to_string()
+                .contains("candidate counters")
+        );
+    }
+
+    #[test]
+    fn raw_numerical_replay_rejects_context_nonfinite_and_decision_tampering() {
+        let evidence = canonical_numerical_relation_evidence();
+
+        let mut selector_tamper = evidence.clone();
+        selector_tamper["candidate_capture"]["selector_contexts"][0]["fixed_source_schedule"] =
+            json!(false);
+        let error =
+            parse_fixture(&canonical_json_bytes(&selector_tamper, "selector tamper").unwrap())
+                .unwrap_err()
+                .to_string();
+        assert!(error.contains("selector context"));
+
+        let mut nonfinite = evidence.clone();
+        nonfinite["candidate_capture"]["observations"][1]["values"][0][0] = json!("NaN");
+        let error =
+            parse_fixture(&canonical_json_bytes(&nonfinite, "nonfinite raw observation").unwrap())
+                .unwrap_err()
+                .to_string();
+        assert!(error.contains("canonical finite decimal"));
+
+        let mut stale_decision = evidence;
+        stale_decision["decision_sha256"] = json!(digest(99));
+        let error =
+            parse_fixture(&canonical_json_bytes(&stale_decision, "stale decision digest").unwrap())
+                .unwrap_err()
+                .to_string();
+        assert!(error.contains("decision digest"));
+
+        let mut stale_rejection = canonical_numerical_relation_evidence();
+        stale_rejection["rejection_decision_sha256"] = json!(digest(98));
+        let error = parse_fixture(
+            &canonical_json_bytes(&stale_rejection, "stale rejection digest").unwrap(),
+        )
+        .unwrap_err()
+        .to_string();
+        assert!(error.contains("rejection digest"));
+    }
+
+    #[test]
+    fn raw_numerical_tolerance_boundary_and_parameter_domains_are_exact() {
+        let defaults = vec![AuthenticatedRuntimeParameterSlot {
+            default: BigRational::new(BigInt::from(3), BigInt::from(2)),
+            probe_policy: "native-template-default-perturbed-v1",
+        }];
+        let candidate = deterministic_parameter_contexts(
+            &defaults,
+            4,
+            17,
+            "candidate-current-parameter-probes-v1",
+            true,
+        )
+        .unwrap();
+        let verification = deterministic_parameter_contexts(
+            &defaults,
+            4,
+            17,
+            "independent-verification-current-parameter-probes-v1",
+            false,
+        )
+        .unwrap();
+        assert_eq!(candidate[0], vec![defaults[0].default.clone()]);
+        assert!(
+            candidate
+                .iter()
+                .all(|row| !verification.iter().any(|other| row == other))
+        );
+
+        let source = RawSourceSemantics {
+            value: json!({}),
+            process_id: "residual-test".to_owned(),
+            physical_pdgs: vec![1],
+            strategy: "contracted-color-union".to_owned(),
+            selector_schedule: json!({}),
+            currents: (0..2)
+                .map(|current_id| RawSourceCurrent {
+                    current_id,
+                    is_source: false,
+                    contract_key: vec![1],
+                    dimension: 1,
+                    selector_domain_id: 0,
+                })
+                .collect(),
+        };
+        let boundary_bytes = canonical_json_bytes(
+            &json!([
+                {"current_id": 0, "dimension": 1, "values": [["1", "0"]]},
+                {"current_id": 1, "dimension": 1, "values": [["2", "0"]]},
+            ]),
+            "boundary observation capture",
+        )
+        .unwrap();
+        let boundary_capture = capture_from_observation_array(&boundary_bytes, &source, 1);
+        let mut telemetry = RecurrenceEvidenceAuthenticationTelemetry::default();
+        let boundary = relation_residuals(
+            "equal",
+            1,
+            Some(0),
+            &boundary_capture,
+            &BigRational::zero(),
+            &BigRational::one(),
+            &mut telemetry,
+        )
+        .unwrap();
+        assert_eq!(boundary.maximum_ratio, BigRational::one());
+        let outside_bytes = canonical_json_bytes(
+            &json!([
+                {"current_id": 0, "dimension": 1, "values": [["1", "0"]]},
+                {"current_id": 1, "dimension": 1, "values": [["2.000001", "0"]]},
+            ]),
+            "outside observation capture",
+        )
+        .unwrap();
+        let outside_capture = capture_from_observation_array(&outside_bytes, &source, 1);
+        let outside = relation_residuals(
+            "equal",
+            1,
+            Some(0),
+            &outside_capture,
+            &BigRational::zero(),
+            &BigRational::one(),
+            &mut telemetry,
+        )
+        .unwrap();
+        assert!(outside.maximum_ratio > BigRational::one());
+    }
+
+    #[test]
+    fn authenticated_parameter_defaults_reject_shifted_neighborhoods() {
+        fn contract(default: i64) -> AuthenticatedRuntimeParameterContract {
+            let default = BigRational::from_integer(BigInt::from(default));
+            let schema = json!({
+                "abi": "pyamplicol-recurrence-runtime-parameter-schema-v2",
+                "parameters": [{
+                    "runtime_slot": 0,
+                    "runtime_name": "mass",
+                    "parameter_template_id": 0,
+                    "prepared_parameter_id": 0,
+                    "component": 0,
+                    "default_binary64": python_f64_hex_signed(default.to_f64().unwrap()),
+                    "probe_policy": "native-template-default-perturbed-v1",
+                }],
+            });
+            AuthenticatedRuntimeParameterContract {
+                schema_sha256: canonical_json_sha256(&schema, "test runtime parameter schema")
+                    .unwrap(),
+                schema,
+                slots: vec![AuthenticatedRuntimeParameterSlot {
+                    default,
+                    probe_policy: "native-template-default-perturbed-v1",
+                }],
+                process_id: "parameter-test".to_owned(),
+                physical_pdgs: vec![1],
+            }
+        }
+
+        let authenticated = contract(3);
+        let shifted = contract(5);
+        assert!(
+            validate_raw_runtime_parameter_schema(
+                &shifted.schema,
+                &shifted.schema_sha256,
+                &authenticated,
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("authenticated native template input")
+        );
+    }
+
+    #[test]
+    fn native_parameter_default_hex_preserves_negative_binary64_signs() {
+        assert_eq!(python_f64_hex_signed(-1.5), "-0x1.8000000000000p+0");
+        assert_eq!(
+            python_f64_hex_signed(f64::from_bits(0x8000_0000_0000_0001)),
+            "-0x0.0000000000001p-1022"
+        );
+        assert_eq!(python_f64_hex_signed(0.0), "0x0.0p+0");
+    }
+
+    #[test]
+    fn derived_parameter_probe_slots_are_fixed_and_tampering_fails() {
+        let contract = AuthenticatedRuntimeParameterContract {
+            schema: json!({}),
+            schema_sha256: digest(90),
+            slots: vec![AuthenticatedRuntimeParameterSlot {
+                default: BigRational::zero(),
+                probe_policy: "derived-overwritten-fixed-zero-v1",
+            }],
+            process_id: "parameter-test".to_owned(),
+            physical_pdgs: vec![1],
+        };
+        let candidate_contexts = deterministic_parameter_contexts(
+            &contract.slots,
+            4,
+            17,
+            "candidate-current-parameter-probes-v1",
+            true,
+        )
+        .unwrap();
+        let verification_contexts = deterministic_parameter_contexts(
+            &contract.slots,
+            4,
+            17,
+            "independent-verification-current-parameter-probes-v1",
+            false,
+        )
+        .unwrap();
+        assert!(
+            candidate_contexts
+                .iter()
+                .chain(&verification_contexts)
+                .all(|row| row == &[BigRational::zero()])
+        );
+        let capture = |parameter_contexts, base: u8| RawNumericalCapture {
+            raw_bytes: b"[]",
+            observation_rows: Vec::new(),
+            point_count: 4,
+            point_sha256s: (0..4).map(|index| digest(base + index)).collect(),
+            kinematic_sha256s: (0..4).map(|index| digest(base + 10 + index)).collect(),
+            parameter_context_sha256s: (0..4).map(|index| digest(base + 20 + index)).collect(),
+            parameter_contexts,
+            dimensions: Vec::new(),
+            observation_batch_sha256: digest(base + 30),
+            capture_contract_sha256: digest(base + 31),
+        };
+        let mut candidate = capture(candidate_contexts, 1);
+        let verification = capture(verification_contexts, 101);
+        validate_independent_raw_captures(&candidate, &verification, &contract, 17).unwrap();
+        candidate.parameter_contexts[1][0] = BigRational::one();
+        assert!(
+            validate_independent_raw_captures(&candidate, &verification, &contract, 17)
+                .unwrap_err()
+                .to_string()
+                .contains("stale or non-deterministic")
+        );
+    }
+
+    #[test]
+    fn parameter_rows_are_included_in_raw_geometry() {
+        let source = RawSourceSemantics {
+            value: json!({}),
+            process_id: "memory-preflight-test".to_owned(),
+            physical_pdgs: vec![1],
+            strategy: "contracted-color-union".to_owned(),
+            selector_schedule: json!({}),
+            currents: Vec::new(),
+        };
+        assert_eq!(
+            raw_evidence_geometry_counts(&source, 2, 2, 400_000).unwrap(),
+            (0, 0, 1_600_000, 400_000)
+        );
+    }
+
+    fn compressed_envelope(raw: &[u8]) -> Vec<u8> {
+        let mut encoder = ZlibEncoder::new(Vec::new(), Compression::fast());
+        encoder.write_all(raw).unwrap();
+        let compressed = encoder.finish().unwrap();
+        let mut envelope = Vec::with_capacity(COMPRESSED_EVIDENCE_HEADER_BYTES + compressed.len());
+        envelope.extend_from_slice(COMPRESSED_EVIDENCE_MAGIC);
+        envelope.extend_from_slice(&(raw.len() as u64).to_be_bytes());
+        envelope.extend_from_slice(&Sha256::digest(raw));
+        envelope.extend_from_slice(&compressed);
+        envelope
+    }
+
+    #[test]
+    fn compressed_transport_checks_declared_length_and_digest_before_json_parsing() {
+        let raw = br#"{"candidate_capture":{"observations":[]},"verification_capture":{"observations":[]}}"#;
+        let encoded = compressed_envelope(raw);
+        assert_eq!(decode_compressed_evidence(&encoded).unwrap(), raw);
+
+        let mut digest_tamper = encoded.clone();
+        digest_tamper[16] ^= 1;
+        assert!(
+            decode_compressed_evidence(&digest_tamper)
+                .unwrap_err()
+                .to_string()
+                .contains("digest mismatch")
+        );
+
+        let mut length_tamper = encoded.clone();
+        length_tamper[8..16].copy_from_slice(&((raw.len() - 1) as u64).to_be_bytes());
+        assert!(
+            decode_compressed_evidence(&length_tamper)
+                .unwrap_err()
+                .to_string()
+                .contains("decompressed length")
+        );
+
+        let mut trailing = encoded;
+        trailing.push(0);
+        assert!(
+            decode_compressed_evidence(&trailing)
+                .unwrap_err()
+                .to_string()
+                .contains("trailing or unconsumed")
+        );
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-python/src/recurrence_template.rs b/pyamplicol/rust/crates/rusticol-python/src/recurrence_template.rs
new file mode 100644
index 0000000000..f8cf07841f
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/src/recurrence_template.rs
@@ -0,0 +1,1693 @@
+// SPDX-License-Identifier: 0BSD
+
+//! Private Python boundary for model-wide recurrence-template input v1.
+//!
+//! The Python producer owns and freezes canonical NumPy columns. This module
+//! checks that envelope before copying it into the strongly typed core input.
+//! Prepared-kernel IDs can additionally be checked against an inventory from
+//! an already authenticated prepared pack. Central registration must provide
+//! that inventory before the validated template input is used for lowering.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use numpy::{PyReadonlyArrayDyn, PyUntypedArrayMethods};
+use pyo3::exceptions::{PyTypeError, PyValueError};
+use pyo3::prelude::*;
+use pyo3::types::{PyAny, PyDict};
+use rusticol_core::recurrence::template::{
+    CatalogHeaderRow, ClosureRow, ColorContractionRow, ColorNcTermRow, ContactOrbitCertificateRow,
+    ContactOrbitStepRow, CouplingOrderTermRow, CurrentStateRow, DigestCatalogRow,
+    EvaluatorBindingRow, ExactFactorRow, IndexedRangeRow, LCColorTransitionWitnessRow, MISSING_U32,
+    OwnedRecurrenceTemplateInput, ParameterRow, PropagatorRow, QuantumFlowRow,
+    QuantumNumberFlowTermRow, RECURRENCE_TEMPLATE_INPUT_ABI,
+    RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION, RuntimeHelicityContractRow,
+    RuntimeHelicityEmbeddingRow, RuntimeHelicityProjectionRow, RuntimeHelicityVariantRow,
+    SourceRow, SymmetryProofRow, TransitionRow,
+};
+use rusticol_core::recurrence::{CheckedTableRange, SemanticDigest, checked_usize};
+use rusticol_core::{RusticolError, RusticolResult};
+use sha2::{Digest, Sha256};
+
+use crate::python_error;
+
+const RESULT_KIND: &str = "pyamplicol-recurrence-template-validation-result";
+const RESULT_SCHEMA_VERSION: u32 = 1;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum PrimitiveKind {
+    U8,
+    U32,
+    U64,
+    I32,
+}
+
+impl PrimitiveKind {
+    const fn dtype(self) -> &'static str {
+        match self {
+            Self::U8 => "|u1",
+            Self::U32 => "<u4",
+            Self::U64 => "<u8",
+            Self::I32 => "<i4",
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+struct ColumnSpec {
+    name: &'static str,
+    kind: PrimitiveKind,
+    tail_shape: &'static [usize],
+}
+
+#[derive(Clone, Copy)]
+struct TableSpec {
+    name: &'static str,
+    columns: &'static [ColumnSpec],
+}
+
+const fn column(name: &'static str, kind: PrimitiveKind) -> ColumnSpec {
+    ColumnSpec {
+        name,
+        kind,
+        tail_shape: &[],
+    }
+}
+
+const fn shaped_column(
+    name: &'static str,
+    kind: PrimitiveKind,
+    tail_shape: &'static [usize],
+) -> ColumnSpec {
+    ColumnSpec {
+        name,
+        kind,
+        tail_shape,
+    }
+}
+
+const TABLE_SPECS: &[TableSpec] = &[
+    TableSpec {
+        name: "catalog_header",
+        columns: &[
+            column("schema_version", PrimitiveKind::U32),
+            column("abi_string_id", PrimitiveKind::U32),
+            column("canonicalization_abi_string_id", PrimitiveKind::U32),
+            column("exact_scalar_abi_string_id", PrimitiveKind::U32),
+            column("compiled_model_digest_id", PrimitiveKind::U32),
+            column("prepared_kernel_pack_digest_id", PrimitiveKind::U32),
+            column("catalog_digest_id", PrimitiveKind::U32),
+            column("parameter_count", PrimitiveKind::U32),
+            column("current_state_count", PrimitiveKind::U32),
+            column("source_count", PrimitiveKind::U32),
+            column("quantum_flow_count", PrimitiveKind::U32),
+            column("contact_orbit_certificate_count", PrimitiveKind::U32),
+            column("contact_orbit_step_count", PrimitiveKind::U32),
+            column("transition_count", PrimitiveKind::U32),
+            column("propagator_count", PrimitiveKind::U32),
+            column("closure_count", PrimitiveKind::U32),
+            column("color_contraction_count", PrimitiveKind::U32),
+            column("symmetry_proof_count", PrimitiveKind::U32),
+            column("runtime_helicity_contract_count", PrimitiveKind::U32),
+            column("evaluator_binding_count", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "closures",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("input_state_sequence_id", PrimitiveKind::U32),
+            column("result_state_template_id", PrimitiveKind::U32),
+            column("evaluator_binding_id", PrimitiveKind::U32),
+            column("canonical_input_order_sequence_id", PrimitiveKind::U32),
+            column("coupling_parameter_sequence_id", PrimitiveKind::U32),
+            column("coupling_order_set_id", PrimitiveKind::U32),
+            column("eligible_quantum_flow_sequence_id", PrimitiveKind::U32),
+            column("color_contraction_template_id", PrimitiveKind::U32),
+            column("binding_coupling_factor_id", PrimitiveKind::U32),
+            column("exact_factor_id", PrimitiveKind::U32),
+            column("output_factor_source", PrimitiveKind::U8),
+            column("equivalence_class_string_id", PrimitiveKind::U32),
+            column("input_exchange_factor_id", PrimitiveKind::U32),
+            column("projection_string_id", PrimitiveKind::U32),
+            column("component_coefficient_sequence_id", PrimitiveKind::U32),
+            column("chirality_relation_string_id", PrimitiveKind::U32),
+            column("metric_signature_string_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "color_contractions",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("rule_kind_string_id", PrimitiveKind::U32),
+            column("input_representation_sequence_id", PrimitiveKind::U32),
+            column("has_output_representation", PrimitiveKind::U8),
+            column("output_representation", PrimitiveKind::I32),
+            column("ordered_open_string_arity", PrimitiveKind::U32),
+            column("exact_coefficient_factor_id", PrimitiveKind::U32),
+            column("witness_start", PrimitiveKind::U64),
+            column("witness_count", PrimitiveKind::U64),
+            column("nc_term_start", PrimitiveKind::U64),
+            column("nc_term_count", PrimitiveKind::U64),
+            column("expression_digest_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "color_nc_terms",
+        columns: &[
+            column("color_contraction_id", PrimitiveKind::U32),
+            column("exponent", PrimitiveKind::I32),
+            column("factor_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "contact_orbit_certificates",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("algorithm_string_id", PrimitiveKind::U32),
+            column("algorithm_version", PrimitiveKind::U32),
+            column("term_id", PrimitiveKind::U32),
+            column("vertex_string_id", PrimitiveKind::U32),
+            column("particle_string_sequence_id", PrimitiveKind::U32),
+            column("evaluator_class_string_id", PrimitiveKind::U32),
+            column("physical_leg_equivalence_sequence_id", PrimitiveKind::U32),
+            column("reconstruction_factor_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "contact_orbit_steps",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("certificate_id", PrimitiveKind::U32),
+            column("stage", PrimitiveKind::U8),
+            column("result_leg", PrimitiveKind::U8),
+            column("left_covered_leg_sequence_id", PrimitiveKind::U32),
+            column("right_covered_leg_sequence_id", PrimitiveKind::U32),
+            column("source_particle_leg_sequence_id", PrimitiveKind::U32),
+            column("reconstruction_factor_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "coupling_order_ranges",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("start", PrimitiveKind::U64),
+            column("count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "coupling_order_terms",
+        columns: &[
+            column("set_id", PrimitiveKind::U32),
+            column("name_string_id", PrimitiveKind::U32),
+            column("power", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "current_states",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("particle_id", PrimitiveKind::I32),
+            column("anti_particle_id", PrimitiveKind::I32),
+            column("species_string_id", PrimitiveKind::U32),
+            column("orientation", PrimitiveKind::U8),
+            column("statistics", PrimitiveKind::U8),
+            column("color_representation", PrimitiveKind::I32),
+            column("basis_string_id", PrimitiveKind::U32),
+            column("tensor_ordering_sequence_id", PrimitiveKind::U32),
+            column("dimension", PrimitiveKind::U32),
+            column("chirality", PrimitiveKind::I32),
+            column("lc_color_shape_string_id", PrimitiveKind::U32),
+            column("auxiliary_kind_string_id", PrimitiveKind::U32),
+            column("mass_parameter_id", PrimitiveKind::U32),
+            column("width_parameter_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "digest_catalog",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            shaped_column("value", PrimitiveKind::U8, &[32]),
+        ],
+    },
+    TableSpec {
+        name: "evaluator_bindings",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("resolver_key_string_id", PrimitiveKind::U32),
+            column("prepared_kernel_id", PrimitiveKind::U32),
+            column("contract_kind", PrimitiveKind::U8),
+            column("callable_signature_digest_id", PrimitiveKind::U32),
+            column("input_state_sequence_id", PrimitiveKind::U32),
+            column("output_state_template_id", PrimitiveKind::U32),
+            column("input_layout_sequence_id", PrimitiveKind::U32),
+            column("output_layout_sequence_id", PrimitiveKind::U32),
+            column("exact_expression_digest_sequence_id", PrimitiveKind::U32),
+            column("semantic_template_sequence_id", PrimitiveKind::U32),
+            column("callable_kind", PrimitiveKind::U8),
+            column("runtime_template_string_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "exact_factors",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("real_numerator_string_id", PrimitiveKind::U32),
+            column("real_denominator_string_id", PrimitiveKind::U32),
+            column("imag_numerator_string_id", PrimitiveKind::U32),
+            column("imag_denominator_string_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "flavour_flow_ranges",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("start", PrimitiveKind::U64),
+            column("count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "flavour_flow_values",
+        columns: &[column("value", PrimitiveKind::I32)],
+    },
+    TableSpec {
+        name: "i32_sequence_ranges",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("start", PrimitiveKind::U64),
+            column("count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "i32_sequence_values",
+        columns: &[column("value", PrimitiveKind::I32)],
+    },
+    TableSpec {
+        name: "lc_color_transition_witnesses",
+        columns: &[
+            column("color_contraction_id", PrimitiveKind::U32),
+            column("ordinal", PrimitiveKind::U32),
+            column("left_shape_string_id", PrimitiveKind::U32),
+            column("right_shape_string_id", PrimitiveKind::U32),
+            column("input_permutation", PrimitiveKind::U8),
+            column("reverse_parent_mask", PrimitiveKind::U8),
+            column("component_operation", PrimitiveKind::U8),
+            column("result_component_kind", PrimitiveKind::U8),
+            column("result_component_role", PrimitiveKind::U8),
+            column("result_shape_string_id", PrimitiveKind::U32),
+            column("exact_factor_id", PrimitiveKind::U32),
+            column("proof_digest_id", PrimitiveKind::U32),
+            column("input_port_pairing_sequence_id", PrimitiveKind::U32),
+            column("result_port_binding_sequence_id", PrimitiveKind::U32),
+            column("provenance_sequence_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "parameters",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("name_string_id", PrimitiveKind::U32),
+            column("kind", PrimitiveKind::U8),
+            column("value_type", PrimitiveKind::U8),
+            column("mutable", PrimitiveKind::U8),
+            column("default_factor_id", PrimitiveKind::U32),
+            column("exact_expression_digest_id", PrimitiveKind::U32),
+            column("dependency_sequence_id", PrimitiveKind::U32),
+            column("prepared_parameter_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "propagators",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("state_template_id", PrimitiveKind::U32),
+            column("applies_propagator", PrimitiveKind::U8),
+            column("evaluator_binding_id", PrimitiveKind::U32),
+            column("numerator_expression_digest_id", PrimitiveKind::U32),
+            column("denominator_expression_digest_id", PrimitiveKind::U32),
+            column("mass_parameter_id", PrimitiveKind::U32),
+            column("width_parameter_id", PrimitiveKind::U32),
+            column("gauge_string_id", PrimitiveKind::U32),
+            column("linearity_proof_template_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "quantum_flows",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("input_state_sequence_id", PrimitiveKind::U32),
+            column("input_spin_sequence_id", PrimitiveKind::U32),
+            column("input_flavour_sequence_id", PrimitiveKind::U32),
+            column("input_quantum_sequence_id", PrimitiveKind::U32),
+            column("flavour_flow_operation_string_id", PrimitiveKind::U32),
+            column(
+                "quantum_number_flow_operation_string_id",
+                PrimitiveKind::U32,
+            ),
+            column("coupling_order_set_id", PrimitiveKind::U32),
+            column("result_state_template_id", PrimitiveKind::U32),
+            column("result_spin_state", PrimitiveKind::I32),
+            column("result_flavour_flow_id", PrimitiveKind::U32),
+            column("result_quantum_number_flow_id", PrimitiveKind::U32),
+            column("exact_coupling_factor_id", PrimitiveKind::U32),
+            column("predicate_digest_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "quantum_number_flow_ranges",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("start", PrimitiveKind::U64),
+            column("count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "quantum_number_flow_terms",
+        columns: &[
+            column("flow_id", PrimitiveKind::U32),
+            column("name_string_id", PrimitiveKind::U32),
+            column("expression_string_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "runtime_helicity_contracts",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("full_state_template_id", PrimitiveKind::U32),
+            column("variant_offset", PrimitiveKind::U32),
+            column("variant_count", PrimitiveKind::U32),
+            column("proof_algorithm_string_id", PrimitiveKind::U32),
+            column("proof_digest_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "runtime_helicity_embeddings",
+        columns: &[
+            column("variant_id", PrimitiveKind::U32),
+            column("full_component", PrimitiveKind::U32),
+            column("source_component", PrimitiveKind::U32),
+            column("factor_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "runtime_helicity_projections",
+        columns: &[
+            column("variant_id", PrimitiveKind::U32),
+            column("source_component", PrimitiveKind::U32),
+            column("full_component", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "runtime_helicity_variants",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("contract_id", PrimitiveKind::U32),
+            column("source_template_id", PrimitiveKind::U32),
+            column("source_state_template_id", PrimitiveKind::U32),
+            column("embedding_offset", PrimitiveKind::U32),
+            column("embedding_count", PrimitiveKind::U32),
+            column("projection_offset", PrimitiveKind::U32),
+            column("projection_count", PrimitiveKind::U32),
+            column("proof_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "sources",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("state_template_id", PrimitiveKind::U32),
+            column("crossing_string_id", PrimitiveKind::U32),
+            column("wavefunction_family_string_id", PrimitiveKind::U32),
+            column("helicity", PrimitiveKind::I32),
+            column("spin_state", PrimitiveKind::I32),
+            column("flavour_flow_id", PrimitiveKind::U32),
+            column("quantum_number_flow_id", PrimitiveKind::U32),
+            column("lc_color_seed_operation", PrimitiveKind::U8),
+            column("lc_color_seed_shape_string_id", PrimitiveKind::U32),
+            column("lc_color_seed_component_kind", PrimitiveKind::U8),
+            column("lc_color_seed_component_role", PrimitiveKind::U8),
+            column("lc_color_seed_proof_digest_id", PrimitiveKind::U32),
+            column("lc_color_seed_provenance_sequence_id", PrimitiveKind::U32),
+            column("wavefunction_expression_digest_id", PrimitiveKind::U32),
+            column("evaluator_binding_id", PrimitiveKind::U32),
+            column("mass_parameter_id", PrimitiveKind::U32),
+            column("width_parameter_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "string_bytes",
+        columns: &[column("value", PrimitiveKind::U8)],
+    },
+    TableSpec {
+        name: "string_ranges",
+        columns: &[
+            column("start", PrimitiveKind::U64),
+            column("count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "symmetry_proofs",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("proof_algorithm_string_id", PrimitiveKind::U32),
+            column("subject_template_sequence_id", PrimitiveKind::U32),
+            column("input_permutation_sequence_id", PrimitiveKind::U32),
+            column("exact_phase_factor_id", PrimitiveKind::U32),
+            column("expression_digest_sequence_id", PrimitiveKind::U32),
+            column("witness_digest_id", PrimitiveKind::U32),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "transitions",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("template_string_id", PrimitiveKind::U32),
+            column("input_state_sequence_id", PrimitiveKind::U32),
+            column("result_state_template_id", PrimitiveKind::U32),
+            column("quantum_flow_template_id", PrimitiveKind::U32),
+            column("evaluator_binding_id", PrimitiveKind::U32),
+            column("canonical_input_order_sequence_id", PrimitiveKind::U32),
+            column("momentum_convention_sequence_id", PrimitiveKind::U32),
+            column("coupling_parameter_sequence_id", PrimitiveKind::U32),
+            column("coupling_order_set_id", PrimitiveKind::U32),
+            column("color_contraction_template_id", PrimitiveKind::U32),
+            column("binding_coupling_factor_id", PrimitiveKind::U32),
+            column("exact_factor_id", PrimitiveKind::U32),
+            column("output_factor_source", PrimitiveKind::U8),
+            column("equivalence_class_string_id", PrimitiveKind::U32),
+            column("input_exchange_factor_id", PrimitiveKind::U32),
+            column("output_projection_string_id", PrimitiveKind::U32),
+            column("contact_orbit_step_sequence_id", PrimitiveKind::U32),
+            column(
+                "contact_orbit_step_semantic_digest_sequence_id",
+                PrimitiveKind::U32,
+            ),
+            column("semantic_digest_id", PrimitiveKind::U32),
+        ],
+    },
+    TableSpec {
+        name: "u32_sequence_ranges",
+        columns: &[
+            column("id", PrimitiveKind::U32),
+            column("start", PrimitiveKind::U64),
+            column("count", PrimitiveKind::U64),
+        ],
+    },
+    TableSpec {
+        name: "u32_sequence_values",
+        columns: &[column("value", PrimitiveKind::U32)],
+    },
+];
+
+#[derive(Clone)]
+enum OwnedValues {
+    U8(Vec<u8>),
+    U32(Vec<u32>),
+    U64(Vec<u64>),
+    I32(Vec<i32>),
+}
+
+impl OwnedValues {
+    fn raw_bytes(&self) -> &[u8] {
+        fn bytes<T>(values: &[T]) -> &[u8] {
+            // Multi-byte inputs are explicitly little-endian and big-endian
+            // hosts are rejected before NumPy extraction.
+            unsafe {
+                std::slice::from_raw_parts(
+                    values.as_ptr().cast::<u8>(),
+                    std::mem::size_of_val(values),
+                )
+            }
+        }
+        match self {
+            Self::U8(values) => values,
+            Self::U32(values) => bytes(values),
+            Self::U64(values) => bytes(values),
+            Self::I32(values) => bytes(values),
+        }
+    }
+
+    fn as_u8(&self, context: &str) -> RusticolResult<&[u8]> {
+        match self {
+            Self::U8(values) => Ok(values),
+            _ => Err(wrong_type(context, "u8")),
+        }
+    }
+
+    fn as_u32(&self, context: &str) -> RusticolResult<&[u32]> {
+        match self {
+            Self::U32(values) => Ok(values),
+            _ => Err(wrong_type(context, "u32")),
+        }
+    }
+
+    fn as_u64(&self, context: &str) -> RusticolResult<&[u64]> {
+        match self {
+            Self::U64(values) => Ok(values),
+            _ => Err(wrong_type(context, "u64")),
+        }
+    }
+
+    fn as_i32(&self, context: &str) -> RusticolResult<&[i32]> {
+        match self {
+            Self::I32(values) => Ok(values),
+            _ => Err(wrong_type(context, "i32")),
+        }
+    }
+}
+
+#[derive(Clone)]
+struct OwnedColumn {
+    name: String,
+    dtype: &'static str,
+    shape: Vec<u64>,
+    values: OwnedValues,
+}
+
+#[derive(Clone)]
+struct OwnedTable {
+    name: String,
+    row_count: u64,
+    columns: Vec<OwnedColumn>,
+    column_by_name: BTreeMap<String, usize>,
+}
+
+impl OwnedTable {
+    fn row_count(&self) -> RusticolResult<usize> {
+        checked_usize(self.row_count, &format!("{} row count", self.name))
+    }
+
+    fn column(&self, name: &str) -> RusticolResult<&OwnedColumn> {
+        let index = self.column_by_name.get(name).ok_or_else(|| {
+            invalid(format!(
+                "recurrence template table {:?} has no column {name:?}",
+                self.name
+            ))
+        })?;
+        Ok(&self.columns[*index])
+    }
+
+    fn u8(&self, column: &str) -> RusticolResult<&[u8]> {
+        self.column(column)?
+            .values
+            .as_u8(&format!("{}.{column}", self.name))
+    }
+
+    fn u32(&self, column: &str) -> RusticolResult<&[u32]> {
+        self.column(column)?
+            .values
+            .as_u32(&format!("{}.{column}", self.name))
+    }
+
+    fn u64(&self, column: &str) -> RusticolResult<&[u64]> {
+        self.column(column)?
+            .values
+            .as_u64(&format!("{}.{column}", self.name))
+    }
+
+    fn i32(&self, column: &str) -> RusticolResult<&[i32]> {
+        self.column(column)?
+            .values
+            .as_i32(&format!("{}.{column}", self.name))
+    }
+}
+
+struct DecodedInput {
+    abi: String,
+    declared_digest: String,
+    canonical_digest_property: String,
+    catalog_digest: SemanticDigest,
+    compiled_model_digest: SemanticDigest,
+    prepared_kernel_pack_digest: SemanticDigest,
+    tables: Vec<OwnedTable>,
+    table_by_name: BTreeMap<String, usize>,
+}
+
+impl DecodedInput {
+    fn table(&self, name: &str) -> RusticolResult<&OwnedTable> {
+        let index = self
+            .table_by_name
+            .get(name)
+            .ok_or_else(|| invalid(format!("recurrence template input has no table {name:?}")))?;
+        Ok(&self.tables[*index])
+    }
+
+    fn canonical_digest(&self) -> RusticolResult<String> {
+        let mut digest = Sha256::new();
+        hash_text(&mut digest, &self.abi)?;
+        digest.update(self.catalog_digest.as_bytes());
+        digest.update(self.compiled_model_digest.as_bytes());
+        digest.update(self.prepared_kernel_pack_digest.as_bytes());
+        digest.update(
+            u64::try_from(self.tables.len())
+                .map_err(|_| invalid("recurrence template table count exceeds u64"))?
+                .to_le_bytes(),
+        );
+        for table in &self.tables {
+            hash_text(&mut digest, &table.name)?;
+            digest.update(table.row_count.to_le_bytes());
+            digest.update(
+                u32::try_from(table.columns.len())
+                    .map_err(|_| invalid("recurrence template column count exceeds u32"))?
+                    .to_le_bytes(),
+            );
+            for column in &table.columns {
+                hash_text(&mut digest, &column.name)?;
+                hash_text(&mut digest, column.dtype)?;
+                digest.update(
+                    u8::try_from(column.shape.len())
+                        .map_err(|_| invalid("recurrence template column rank exceeds u8"))?
+                        .to_le_bytes(),
+                );
+                for dimension in &column.shape {
+                    digest.update(dimension.to_le_bytes());
+                }
+                digest.update(column.values.raw_bytes());
+            }
+        }
+        Ok(hex_digest(digest.finalize()))
+    }
+
+    fn into_core(self) -> RusticolResult<OwnedRecurrenceTemplateInput> {
+        let catalog_header = decode_rows(self.table("catalog_header")?, |table, row| {
+            Ok(CatalogHeaderRow {
+                schema_version: table.u32("schema_version")?[row],
+                abi_string_id: table.u32("abi_string_id")?[row],
+                canonicalization_abi_string_id: table.u32("canonicalization_abi_string_id")?[row],
+                exact_scalar_abi_string_id: table.u32("exact_scalar_abi_string_id")?[row],
+                compiled_model_digest_id: table.u32("compiled_model_digest_id")?[row],
+                prepared_kernel_pack_digest_id: table.u32("prepared_kernel_pack_digest_id")?[row],
+                catalog_digest_id: table.u32("catalog_digest_id")?[row],
+                parameter_count: table.u32("parameter_count")?[row],
+                current_state_count: table.u32("current_state_count")?[row],
+                source_count: table.u32("source_count")?[row],
+                quantum_flow_count: table.u32("quantum_flow_count")?[row],
+                contact_orbit_certificate_count: table.u32("contact_orbit_certificate_count")?[row],
+                contact_orbit_step_count: table.u32("contact_orbit_step_count")?[row],
+                transition_count: table.u32("transition_count")?[row],
+                propagator_count: table.u32("propagator_count")?[row],
+                closure_count: table.u32("closure_count")?[row],
+                color_contraction_count: table.u32("color_contraction_count")?[row],
+                symmetry_proof_count: table.u32("symmetry_proof_count")?[row],
+                runtime_helicity_contract_count: table.u32("runtime_helicity_contract_count")?[row],
+                evaluator_binding_count: table.u32("evaluator_binding_count")?[row],
+            })
+        })?;
+        let coupling_order_ranges = indexed_ranges(self.table("coupling_order_ranges")?)?;
+        let coupling_order_terms =
+            decode_rows(self.table("coupling_order_terms")?, |table, row| {
+                Ok(CouplingOrderTermRow {
+                    set_id: table.u32("set_id")?[row],
+                    name_string_id: table.u32("name_string_id")?[row],
+                    power: table.u32("power")?[row],
+                })
+            })?;
+        let contact_orbit_certificates =
+            decode_rows(self.table("contact_orbit_certificates")?, |table, row| {
+                Ok(ContactOrbitCertificateRow {
+                    id: table.u32("id")?[row],
+                    template_string_id: table.u32("template_string_id")?[row],
+                    algorithm_string_id: table.u32("algorithm_string_id")?[row],
+                    algorithm_version: table.u32("algorithm_version")?[row],
+                    term_id: table.u32("term_id")?[row],
+                    vertex_string_id: table.u32("vertex_string_id")?[row],
+                    particle_string_sequence_id: table.u32("particle_string_sequence_id")?[row],
+                    evaluator_class_string_id: table.u32("evaluator_class_string_id")?[row],
+                    physical_leg_equivalence_sequence_id: table
+                        .u32("physical_leg_equivalence_sequence_id")?[row],
+                    reconstruction_factor_id: table.u32("reconstruction_factor_id")?[row],
+                    semantic_digest_id: table.u32("semantic_digest_id")?[row],
+                })
+            })?;
+        let contact_orbit_steps = decode_rows(self.table("contact_orbit_steps")?, |table, row| {
+            Ok(ContactOrbitStepRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                certificate_id: table.u32("certificate_id")?[row],
+                stage: table.u8("stage")?[row],
+                result_leg: table.u8("result_leg")?[row],
+                left_covered_leg_sequence_id: table.u32("left_covered_leg_sequence_id")?[row],
+                right_covered_leg_sequence_id: table.u32("right_covered_leg_sequence_id")?[row],
+                source_particle_leg_sequence_id: table.u32("source_particle_leg_sequence_id")?[row],
+                reconstruction_factor_id: table.u32("reconstruction_factor_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let current_states = decode_rows(self.table("current_states")?, |table, row| {
+            Ok(CurrentStateRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                particle_id: table.i32("particle_id")?[row],
+                anti_particle_id: table.i32("anti_particle_id")?[row],
+                species_string_id: table.u32("species_string_id")?[row],
+                orientation: table.u8("orientation")?[row],
+                statistics: table.u8("statistics")?[row],
+                color_representation: table.i32("color_representation")?[row],
+                basis_string_id: table.u32("basis_string_id")?[row],
+                tensor_ordering_sequence_id: table.u32("tensor_ordering_sequence_id")?[row],
+                dimension: table.u32("dimension")?[row],
+                chirality: table.i32("chirality")?[row],
+                lc_color_shape_string_id: table.u32("lc_color_shape_string_id")?[row],
+                auxiliary_kind_string_id: table.u32("auxiliary_kind_string_id")?[row],
+                mass_parameter_id: table.u32("mass_parameter_id")?[row],
+                width_parameter_id: table.u32("width_parameter_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let digest_catalog = decode_digest_catalog(self.table("digest_catalog")?)?;
+        let evaluator_bindings = decode_rows(self.table("evaluator_bindings")?, |table, row| {
+            Ok(EvaluatorBindingRow {
+                id: table.u32("id")?[row],
+                resolver_key_string_id: table.u32("resolver_key_string_id")?[row],
+                prepared_kernel_id: table.u32("prepared_kernel_id")?[row],
+                contract_kind: table.u8("contract_kind")?[row],
+                callable_signature_digest_id: table.u32("callable_signature_digest_id")?[row],
+                input_state_sequence_id: table.u32("input_state_sequence_id")?[row],
+                output_state_template_id: table.u32("output_state_template_id")?[row],
+                input_layout_sequence_id: table.u32("input_layout_sequence_id")?[row],
+                output_layout_sequence_id: table.u32("output_layout_sequence_id")?[row],
+                exact_expression_digest_sequence_id: table
+                    .u32("exact_expression_digest_sequence_id")?[row],
+                semantic_template_sequence_id: table.u32("semantic_template_sequence_id")?[row],
+                callable_kind: table.u8("callable_kind")?[row],
+                runtime_template_string_id: table.u32("runtime_template_string_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let exact_factors = decode_rows(self.table("exact_factors")?, |table, row| {
+            Ok(ExactFactorRow {
+                id: table.u32("id")?[row],
+                real_numerator_string_id: table.u32("real_numerator_string_id")?[row],
+                real_denominator_string_id: table.u32("real_denominator_string_id")?[row],
+                imag_numerator_string_id: table.u32("imag_numerator_string_id")?[row],
+                imag_denominator_string_id: table.u32("imag_denominator_string_id")?[row],
+            })
+        })?;
+        let flavour_flow_ranges = indexed_ranges(self.table("flavour_flow_ranges")?)?;
+        let flavour_flow_values = self.table("flavour_flow_values")?.i32("value")?.to_vec();
+        let i32_sequence_ranges = indexed_ranges(self.table("i32_sequence_ranges")?)?;
+        let i32_sequence_values = self.table("i32_sequence_values")?.i32("value")?.to_vec();
+        let parameters = decode_rows(self.table("parameters")?, |table, row| {
+            Ok(ParameterRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                name_string_id: table.u32("name_string_id")?[row],
+                kind: table.u8("kind")?[row],
+                value_type: table.u8("value_type")?[row],
+                mutable: table.u8("mutable")?[row],
+                default_factor_id: table.u32("default_factor_id")?[row],
+                exact_expression_digest_id: table.u32("exact_expression_digest_id")?[row],
+                dependency_sequence_id: table.u32("dependency_sequence_id")?[row],
+                prepared_parameter_id: table.u32("prepared_parameter_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let propagators = decode_rows(self.table("propagators")?, |table, row| {
+            Ok(PropagatorRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                state_template_id: table.u32("state_template_id")?[row],
+                applies_propagator: table.u8("applies_propagator")?[row],
+                evaluator_binding_id: table.u32("evaluator_binding_id")?[row],
+                numerator_expression_digest_id: table.u32("numerator_expression_digest_id")?[row],
+                denominator_expression_digest_id: table.u32("denominator_expression_digest_id")?
+                    [row],
+                mass_parameter_id: table.u32("mass_parameter_id")?[row],
+                width_parameter_id: table.u32("width_parameter_id")?[row],
+                gauge_string_id: table.u32("gauge_string_id")?[row],
+                linearity_proof_template_id: table.u32("linearity_proof_template_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let quantum_flows = decode_rows(self.table("quantum_flows")?, |table, row| {
+            Ok(QuantumFlowRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                input_state_sequence_id: table.u32("input_state_sequence_id")?[row],
+                input_spin_sequence_id: table.u32("input_spin_sequence_id")?[row],
+                input_flavour_sequence_id: table.u32("input_flavour_sequence_id")?[row],
+                input_quantum_sequence_id: table.u32("input_quantum_sequence_id")?[row],
+                flavour_flow_operation_string_id: table.u32("flavour_flow_operation_string_id")?
+                    [row],
+                quantum_number_flow_operation_string_id: table
+                    .u32("quantum_number_flow_operation_string_id")?[row],
+                coupling_order_set_id: table.u32("coupling_order_set_id")?[row],
+                result_state_template_id: table.u32("result_state_template_id")?[row],
+                result_spin_state: table.i32("result_spin_state")?[row],
+                result_flavour_flow_id: table.u32("result_flavour_flow_id")?[row],
+                result_quantum_number_flow_id: table.u32("result_quantum_number_flow_id")?[row],
+                exact_coupling_factor_id: table.u32("exact_coupling_factor_id")?[row],
+                predicate_digest_id: table.u32("predicate_digest_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let quantum_number_flow_ranges = indexed_ranges(self.table("quantum_number_flow_ranges")?)?;
+        let quantum_number_flow_terms =
+            decode_rows(self.table("quantum_number_flow_terms")?, |table, row| {
+                Ok(QuantumNumberFlowTermRow {
+                    flow_id: table.u32("flow_id")?[row],
+                    name_string_id: table.u32("name_string_id")?[row],
+                    expression_string_id: table.u32("expression_string_id")?[row],
+                })
+            })?;
+        let runtime_helicity_contracts =
+            decode_rows(self.table("runtime_helicity_contracts")?, |table, row| {
+                Ok(RuntimeHelicityContractRow {
+                    id: table.u32("id")?[row],
+                    template_string_id: table.u32("template_string_id")?[row],
+                    full_state_template_id: table.u32("full_state_template_id")?[row],
+                    variant_range: CheckedTableRange::new(
+                        table.u32("variant_offset")?[row].into(),
+                        table.u32("variant_count")?[row].into(),
+                    ),
+                    proof_algorithm_string_id: table.u32("proof_algorithm_string_id")?[row],
+                    proof_digest_id: table.u32("proof_digest_id")?[row],
+                    semantic_digest_id: table.u32("semantic_digest_id")?[row],
+                })
+            })?;
+        let runtime_helicity_embeddings =
+            decode_rows(self.table("runtime_helicity_embeddings")?, |table, row| {
+                Ok(RuntimeHelicityEmbeddingRow {
+                    variant_id: table.u32("variant_id")?[row],
+                    full_component: table.u32("full_component")?[row],
+                    source_component: table.u32("source_component")?[row],
+                    factor_id: table.u32("factor_id")?[row],
+                })
+            })?;
+        let runtime_helicity_projections =
+            decode_rows(self.table("runtime_helicity_projections")?, |table, row| {
+                Ok(RuntimeHelicityProjectionRow {
+                    variant_id: table.u32("variant_id")?[row],
+                    source_component: table.u32("source_component")?[row],
+                    full_component: table.u32("full_component")?[row],
+                })
+            })?;
+        let runtime_helicity_variants =
+            decode_rows(self.table("runtime_helicity_variants")?, |table, row| {
+                Ok(RuntimeHelicityVariantRow {
+                    id: table.u32("id")?[row],
+                    contract_id: table.u32("contract_id")?[row],
+                    source_template_id: table.u32("source_template_id")?[row],
+                    source_state_template_id: table.u32("source_state_template_id")?[row],
+                    embedding_range: CheckedTableRange::new(
+                        table.u32("embedding_offset")?[row].into(),
+                        table.u32("embedding_count")?[row].into(),
+                    ),
+                    projection_range: CheckedTableRange::new(
+                        table.u32("projection_offset")?[row].into(),
+                        table.u32("projection_count")?[row].into(),
+                    ),
+                    proof_digest_id: table.u32("proof_digest_id")?[row],
+                })
+            })?;
+        let sources = decode_rows(self.table("sources")?, |table, row| {
+            Ok(SourceRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                state_template_id: table.u32("state_template_id")?[row],
+                crossing_string_id: table.u32("crossing_string_id")?[row],
+                wavefunction_family_string_id: table.u32("wavefunction_family_string_id")?[row],
+                helicity: table.i32("helicity")?[row],
+                spin_state: table.i32("spin_state")?[row],
+                flavour_flow_id: table.u32("flavour_flow_id")?[row],
+                quantum_number_flow_id: table.u32("quantum_number_flow_id")?[row],
+                lc_color_seed_operation: table.u8("lc_color_seed_operation")?[row],
+                lc_color_seed_shape_string_id: table.u32("lc_color_seed_shape_string_id")?[row],
+                lc_color_seed_component_kind: table.u8("lc_color_seed_component_kind")?[row],
+                lc_color_seed_component_role: table.u8("lc_color_seed_component_role")?[row],
+                lc_color_seed_proof_digest_id: table.u32("lc_color_seed_proof_digest_id")?[row],
+                lc_color_seed_provenance_sequence_id: table
+                    .u32("lc_color_seed_provenance_sequence_id")?[row],
+                wavefunction_expression_digest_id: table
+                    .u32("wavefunction_expression_digest_id")?[row],
+                evaluator_binding_id: table.u32("evaluator_binding_id")?[row],
+                mass_parameter_id: table.u32("mass_parameter_id")?[row],
+                width_parameter_id: table.u32("width_parameter_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let string_ranges = plain_ranges(self.table("string_ranges")?)?;
+        let string_bytes = self.table("string_bytes")?.u8("value")?.to_vec();
+        let symmetry_proofs = decode_rows(self.table("symmetry_proofs")?, |table, row| {
+            Ok(SymmetryProofRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                proof_algorithm_string_id: table.u32("proof_algorithm_string_id")?[row],
+                subject_template_sequence_id: table.u32("subject_template_sequence_id")?[row],
+                input_permutation_sequence_id: table.u32("input_permutation_sequence_id")?[row],
+                exact_phase_factor_id: table.u32("exact_phase_factor_id")?[row],
+                expression_digest_sequence_id: table.u32("expression_digest_sequence_id")?[row],
+                witness_digest_id: table.u32("witness_digest_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let transitions = decode_rows(self.table("transitions")?, |table, row| {
+            Ok(TransitionRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                input_state_sequence_id: table.u32("input_state_sequence_id")?[row],
+                result_state_template_id: table.u32("result_state_template_id")?[row],
+                quantum_flow_template_id: table.u32("quantum_flow_template_id")?[row],
+                evaluator_binding_id: table.u32("evaluator_binding_id")?[row],
+                canonical_input_order_sequence_id: table
+                    .u32("canonical_input_order_sequence_id")?[row],
+                momentum_convention_sequence_id: table.u32("momentum_convention_sequence_id")?[row],
+                coupling_parameter_sequence_id: table.u32("coupling_parameter_sequence_id")?[row],
+                coupling_order_set_id: table.u32("coupling_order_set_id")?[row],
+                color_contraction_template_id: table.u32("color_contraction_template_id")?[row],
+                binding_coupling_factor_id: table.u32("binding_coupling_factor_id")?[row],
+                exact_factor_id: table.u32("exact_factor_id")?[row],
+                output_factor_source: table.u8("output_factor_source")?[row],
+                equivalence_class_string_id: table.u32("equivalence_class_string_id")?[row],
+                input_exchange_factor_id: table.u32("input_exchange_factor_id")?[row],
+                output_projection_string_id: table.u32("output_projection_string_id")?[row],
+                contact_orbit_step_sequence_id: table.u32("contact_orbit_step_sequence_id")?[row],
+                contact_orbit_step_semantic_digest_sequence_id: table
+                    .u32("contact_orbit_step_semantic_digest_sequence_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let closures = decode_rows(self.table("closures")?, |table, row| {
+            Ok(ClosureRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                input_state_sequence_id: table.u32("input_state_sequence_id")?[row],
+                result_state_template_id: table.u32("result_state_template_id")?[row],
+                evaluator_binding_id: table.u32("evaluator_binding_id")?[row],
+                canonical_input_order_sequence_id: table
+                    .u32("canonical_input_order_sequence_id")?[row],
+                coupling_parameter_sequence_id: table.u32("coupling_parameter_sequence_id")?[row],
+                coupling_order_set_id: table.u32("coupling_order_set_id")?[row],
+                eligible_quantum_flow_sequence_id: table
+                    .u32("eligible_quantum_flow_sequence_id")?[row],
+                color_contraction_template_id: table.u32("color_contraction_template_id")?[row],
+                binding_coupling_factor_id: table.u32("binding_coupling_factor_id")?[row],
+                exact_factor_id: table.u32("exact_factor_id")?[row],
+                output_factor_source: table.u8("output_factor_source")?[row],
+                equivalence_class_string_id: table.u32("equivalence_class_string_id")?[row],
+                input_exchange_factor_id: table.u32("input_exchange_factor_id")?[row],
+                projection_string_id: table.u32("projection_string_id")?[row],
+                component_coefficient_sequence_id: table
+                    .u32("component_coefficient_sequence_id")?[row],
+                chirality_relation_string_id: table.u32("chirality_relation_string_id")?[row],
+                metric_signature_string_id: table.u32("metric_signature_string_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let color_contractions = decode_rows(self.table("color_contractions")?, |table, row| {
+            Ok(ColorContractionRow {
+                id: table.u32("id")?[row],
+                template_string_id: table.u32("template_string_id")?[row],
+                rule_kind_string_id: table.u32("rule_kind_string_id")?[row],
+                input_representation_sequence_id: table.u32("input_representation_sequence_id")?
+                    [row],
+                has_output_representation: table.u8("has_output_representation")?[row],
+                output_representation: table.i32("output_representation")?[row],
+                ordered_open_string_arity: table.u32("ordered_open_string_arity")?[row],
+                exact_coefficient_factor_id: table.u32("exact_coefficient_factor_id")?[row],
+                witness_start: table.u64("witness_start")?[row],
+                witness_count: table.u64("witness_count")?[row],
+                nc_term_start: table.u64("nc_term_start")?[row],
+                nc_term_count: table.u64("nc_term_count")?[row],
+                expression_digest_id: table.u32("expression_digest_id")?[row],
+                semantic_digest_id: table.u32("semantic_digest_id")?[row],
+            })
+        })?;
+        let lc_color_transition_witnesses = decode_rows(
+            self.table("lc_color_transition_witnesses")?,
+            |table, row| {
+                Ok(LCColorTransitionWitnessRow {
+                    color_contraction_id: table.u32("color_contraction_id")?[row],
+                    ordinal: table.u32("ordinal")?[row],
+                    left_shape_string_id: table.u32("left_shape_string_id")?[row],
+                    right_shape_string_id: table.u32("right_shape_string_id")?[row],
+                    input_permutation: table.u8("input_permutation")?[row],
+                    reverse_parent_mask: table.u8("reverse_parent_mask")?[row],
+                    component_operation: table.u8("component_operation")?[row],
+                    result_component_kind: table.u8("result_component_kind")?[row],
+                    result_component_role: table.u8("result_component_role")?[row],
+                    result_shape_string_id: table.u32("result_shape_string_id")?[row],
+                    exact_factor_id: table.u32("exact_factor_id")?[row],
+                    proof_digest_id: table.u32("proof_digest_id")?[row],
+                    input_port_pairing_sequence_id: table.u32("input_port_pairing_sequence_id")?
+                        [row],
+                    result_port_binding_sequence_id: table
+                        .u32("result_port_binding_sequence_id")?[row],
+                    provenance_sequence_id: table.u32("provenance_sequence_id")?[row],
+                })
+            },
+        )?;
+        let color_nc_terms = decode_rows(self.table("color_nc_terms")?, |table, row| {
+            Ok(ColorNcTermRow {
+                color_contraction_id: table.u32("color_contraction_id")?[row],
+                exponent: table.i32("exponent")?[row],
+                factor_id: table.u32("factor_id")?[row],
+            })
+        })?;
+        let u32_sequence_ranges = indexed_ranges(self.table("u32_sequence_ranges")?)?;
+        let u32_sequence_values = self.table("u32_sequence_values")?.u32("value")?.to_vec();
+
+        Ok(OwnedRecurrenceTemplateInput {
+            input_abi: self.abi,
+            catalog_digest: self.catalog_digest,
+            compiled_model_digest: self.compiled_model_digest,
+            prepared_kernel_pack_digest: self.prepared_kernel_pack_digest,
+            catalog_header,
+            coupling_order_ranges,
+            coupling_order_terms,
+            contact_orbit_certificates,
+            contact_orbit_steps,
+            current_states,
+            digest_catalog,
+            evaluator_bindings,
+            exact_factors,
+            flavour_flow_ranges,
+            flavour_flow_values,
+            i32_sequence_ranges,
+            i32_sequence_values,
+            parameters,
+            propagators,
+            quantum_flows,
+            quantum_number_flow_ranges,
+            quantum_number_flow_terms,
+            runtime_helicity_contracts,
+            runtime_helicity_variants,
+            runtime_helicity_embeddings,
+            runtime_helicity_projections,
+            sources,
+            string_ranges,
+            string_bytes,
+            symmetry_proofs,
+            transitions,
+            closures,
+            color_contractions,
+            lc_color_transition_witnesses,
+            color_nc_terms,
+            u32_sequence_ranges,
+            u32_sequence_values,
+        })
+    }
+}
+
+struct InventoryValidation {
+    referenced_count: usize,
+    authenticated_count: Option<usize>,
+    verified: bool,
+}
+
+struct NativeValidationResult {
+    input_digest: String,
+    catalog_digest: SemanticDigest,
+    compiled_model_digest: SemanticDigest,
+    prepared_kernel_pack_digest: SemanticDigest,
+    parameter_count: u32,
+    current_state_count: u32,
+    source_count: u32,
+    quantum_flow_count: u32,
+    contact_orbit_certificate_count: u32,
+    contact_orbit_step_count: u32,
+    transition_count: u32,
+    propagator_count: u32,
+    closure_count: u32,
+    color_contraction_count: u32,
+    lc_color_transition_witness_count: u32,
+    symmetry_proof_count: u32,
+    runtime_helicity_contract_count: u32,
+    evaluator_binding_count: u32,
+    prepared_kernel_count: u32,
+    inventory: InventoryValidation,
+}
+
+#[pyfunction(signature = (template_input, authenticated_prepared_kernel_ids=None))]
+pub(crate) fn _validate_recurrence_template_input_v1(
+    py: Python<'_>,
+    template_input: &Bound<'_, PyAny>,
+    authenticated_prepared_kernel_ids: Option<Vec<u32>>,
+) -> PyResult<Py<PyAny>> {
+    let decoded = parse_input(template_input)?;
+    let native = py
+        .detach(move || validate_input(decoded, authenticated_prepared_kernel_ids))
+        .map_err(python_error)?;
+    result_mapping(py, native)
+}
+
+fn parse_input(input: &Bound<'_, PyAny>) -> PyResult<DecodedInput> {
+    if cfg!(not(target_endian = "little")) {
+        return Err(PyValueError::new_err(
+            "recurrence template input v1 requires a little-endian target",
+        ));
+    }
+    let abi = required_string(input, "abi")?;
+    if abi != RECURRENCE_TEMPLATE_INPUT_ABI {
+        return Err(PyValueError::new_err(format!(
+            "unsupported recurrence template input ABI {abi:?}"
+        )));
+    }
+    let declared_digest = required_sha256(input, "digest", "template input digest")?;
+    let canonical_digest_property =
+        required_sha256(input, "canonical_digest", "template input canonical digest")?;
+    if declared_digest != canonical_digest_property {
+        return Err(PyValueError::new_err(
+            "recurrence template input digest and canonical_digest disagree",
+        ));
+    }
+    let catalog_digest = semantic_digest_attribute(input, "catalog_digest")?;
+    let compiled_model_digest = semantic_digest_attribute(input, "compiled_model_digest")?;
+    let prepared_kernel_pack_digest =
+        semantic_digest_attribute(input, "prepared_kernel_pack_digest")?;
+
+    let table_objects = iterable_attribute(input, "tables", "recurrence template tables")?;
+    if table_objects.len() != TABLE_SPECS.len() {
+        return Err(PyValueError::new_err(format!(
+            "recurrence template table inventory has {} tables, expected {}",
+            table_objects.len(),
+            TABLE_SPECS.len()
+        )));
+    }
+
+    let mut tables = Vec::with_capacity(TABLE_SPECS.len());
+    let mut table_by_name = BTreeMap::new();
+    for (table_object, spec) in table_objects.into_iter().zip(TABLE_SPECS) {
+        let table_name = required_nonempty_string(&table_object, "name", "table name")?;
+        if table_name != spec.name {
+            return Err(PyValueError::new_err(format!(
+                "recurrence template table inventory mismatch: found {table_name:?}, expected {:?}",
+                spec.name
+            )));
+        }
+        let row_count = table_object
+            .getattr("row_count")?
+            .extract::<u64>()
+            .map_err(|_| {
+                PyTypeError::new_err(format!(
+                    "recurrence template table {table_name:?} row_count must be u64"
+                ))
+            })?;
+        let column_objects = iterable_attribute(
+            &table_object,
+            "columns",
+            &format!("recurrence template table {table_name:?} columns"),
+        )?;
+        if column_objects.len() != spec.columns.len() {
+            return Err(PyValueError::new_err(format!(
+                "recurrence template table {table_name:?} has {} columns, expected {}",
+                column_objects.len(),
+                spec.columns.len()
+            )));
+        }
+
+        let mut columns = Vec::with_capacity(spec.columns.len());
+        let mut column_by_name = BTreeMap::new();
+        for (column_object, column_spec) in column_objects.into_iter().zip(spec.columns) {
+            let column_name = required_nonempty_string(&column_object, "name", "column name")?;
+            if column_name != column_spec.name {
+                return Err(PyValueError::new_err(format!(
+                    "recurrence template table {table_name:?} column mismatch: found {column_name:?}, expected {:?}",
+                    column_spec.name
+                )));
+            }
+            let context = format!("{table_name}.{column_name}");
+            let values_object = column_object.getattr("values")?;
+            let dtype = values_object
+                .getattr("dtype")?
+                .getattr("str")?
+                .extract::<String>()?;
+            if dtype != column_spec.kind.dtype() {
+                return Err(PyValueError::new_err(format!(
+                    "{context} has dtype {dtype:?}, expected {:?}",
+                    column_spec.kind.dtype()
+                )));
+            }
+            let flags = values_object.getattr("flags")?;
+            if flags.getattr("writeable")?.extract::<bool>()? {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must be read-only"
+                )));
+            }
+            if !flags.getattr("owndata")?.extract::<bool>()? {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must own its storage"
+                )));
+            }
+            let (values, shape) = extract_owned_values(&values_object, column_spec.kind, &context)?;
+            if shape.first().copied() != Some(row_count) {
+                return Err(PyValueError::new_err(format!(
+                    "{context} first dimension does not match row_count {row_count}"
+                )));
+            }
+            let actual_tail = shape
+                .iter()
+                .skip(1)
+                .map(|value| usize::try_from(*value))
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|_| PyValueError::new_err(format!("{context} shape exceeds usize")))?;
+            if actual_tail != column_spec.tail_shape {
+                return Err(PyValueError::new_err(format!(
+                    "{context} has tail shape {actual_tail:?}, expected {:?}",
+                    column_spec.tail_shape
+                )));
+            }
+            column_by_name.insert(column_name.clone(), columns.len());
+            columns.push(OwnedColumn {
+                name: column_name,
+                dtype: column_spec.kind.dtype(),
+                shape,
+                values,
+            });
+        }
+        table_by_name.insert(table_name.clone(), tables.len());
+        tables.push(OwnedTable {
+            name: table_name,
+            row_count,
+            columns,
+            column_by_name,
+        });
+    }
+
+    Ok(DecodedInput {
+        abi,
+        declared_digest,
+        canonical_digest_property,
+        catalog_digest,
+        compiled_model_digest,
+        prepared_kernel_pack_digest,
+        tables,
+        table_by_name,
+    })
+}
+
+fn extract_owned_values(
+    value: &Bound<'_, PyAny>,
+    kind: PrimitiveKind,
+    context: &str,
+) -> PyResult<(OwnedValues, Vec<u64>)> {
+    macro_rules! extract {
+        ($ty:ty, $variant:ident) => {{
+            let array = value
+                .extract::<PyReadonlyArrayDyn<'_, $ty>>()
+                .map_err(|_| {
+                    PyTypeError::new_err(format!(
+                        "{context} is not a NumPy array with dtype {:?}",
+                        kind.dtype()
+                    ))
+                })?;
+            if !array.is_c_contiguous() {
+                return Err(PyValueError::new_err(format!(
+                    "{context} must be C-contiguous"
+                )));
+            }
+            let shape = array
+                .shape()
+                .iter()
+                .map(|value| {
+                    u64::try_from(*value)
+                        .map_err(|_| PyValueError::new_err(format!("{context} shape exceeds u64")))
+                })
+                .collect::<PyResult<Vec<_>>>()?;
+            let values = array
+                .as_slice()
+                .map_err(|error| {
+                    PyValueError::new_err(format!("{context} must be contiguous: {error}"))
+                })?
+                .to_vec();
+            (OwnedValues::$variant(values), shape)
+        }};
+    }
+    Ok(match kind {
+        PrimitiveKind::U8 => extract!(u8, U8),
+        PrimitiveKind::U32 => extract!(u32, U32),
+        PrimitiveKind::U64 => extract!(u64, U64),
+        PrimitiveKind::I32 => extract!(i32, I32),
+    })
+}
+
+fn validate_input(
+    decoded: DecodedInput,
+    authenticated_prepared_kernel_ids: Option<Vec<u32>>,
+) -> RusticolResult<NativeValidationResult> {
+    let actual_digest = decoded.canonical_digest()?;
+    if actual_digest != decoded.declared_digest
+        || actual_digest != decoded.canonical_digest_property
+    {
+        return Err(invalid(format!(
+            "recurrence template input digest mismatch: declared {}, found {actual_digest}",
+            decoded.declared_digest
+        )));
+    }
+    let core = decoded.into_core()?;
+    let inventory =
+        validate_prepared_kernel_inventory(&core, authenticated_prepared_kernel_ids.as_deref())?;
+    let validated = core.validate()?;
+    let summary = validated.summary();
+    if summary.prepared_kernel_count as usize != inventory.referenced_count {
+        return Err(invalid(format!(
+            "core prepared-kernel count {} disagrees with decoded inventory count {}",
+            summary.prepared_kernel_count, inventory.referenced_count
+        )));
+    }
+    Ok(NativeValidationResult {
+        input_digest: actual_digest,
+        catalog_digest: summary.catalog_digest,
+        compiled_model_digest: summary.compiled_model_digest,
+        prepared_kernel_pack_digest: summary.prepared_kernel_pack_digest,
+        parameter_count: summary.parameter_count,
+        current_state_count: summary.current_state_count,
+        source_count: summary.source_count,
+        quantum_flow_count: summary.quantum_flow_count,
+        contact_orbit_certificate_count: summary.contact_orbit_certificate_count,
+        contact_orbit_step_count: summary.contact_orbit_step_count,
+        transition_count: summary.transition_count,
+        propagator_count: summary.propagator_count,
+        closure_count: summary.closure_count,
+        color_contraction_count: summary.color_contraction_count,
+        lc_color_transition_witness_count: summary.lc_color_transition_witness_count,
+        symmetry_proof_count: summary.symmetry_proof_count,
+        runtime_helicity_contract_count: summary.runtime_helicity_contract_count,
+        evaluator_binding_count: summary.evaluator_binding_count,
+        prepared_kernel_count: summary.prepared_kernel_count,
+        inventory,
+    })
+}
+
+fn validate_prepared_kernel_inventory(
+    input: &OwnedRecurrenceTemplateInput,
+    authenticated_ids: Option<&[u32]>,
+) -> RusticolResult<InventoryValidation> {
+    let referenced = input
+        .evaluator_bindings
+        .iter()
+        .filter_map(|binding| {
+            (binding.prepared_kernel_id != MISSING_U32).then_some(binding.prepared_kernel_id)
+        })
+        .collect::<BTreeSet<_>>();
+    let Some(authenticated_ids) = authenticated_ids else {
+        return Ok(InventoryValidation {
+            referenced_count: referenced.len(),
+            authenticated_count: None,
+            verified: false,
+        });
+    };
+    let authenticated = authenticated_ids.iter().copied().collect::<BTreeSet<_>>();
+    if authenticated.len() != authenticated_ids.len() {
+        return Err(invalid(
+            "authenticated prepared-kernel ID inventory contains duplicates",
+        ));
+    }
+    if authenticated.contains(&MISSING_U32) {
+        return Err(invalid(
+            "authenticated prepared-kernel ID inventory contains the missing-ID sentinel",
+        ));
+    }
+    let missing = referenced
+        .difference(&authenticated)
+        .copied()
+        .take(16)
+        .collect::<Vec<_>>();
+    if !missing.is_empty() {
+        return Err(invalid(format!(
+            "recurrence template references prepared-kernel IDs absent from the authenticated pack inventory: {missing:?}"
+        )));
+    }
+    Ok(InventoryValidation {
+        referenced_count: referenced.len(),
+        authenticated_count: Some(authenticated.len()),
+        verified: true,
+    })
+}
+
+fn result_mapping(py: Python<'_>, native: NativeValidationResult) -> PyResult<Py<PyAny>> {
+    let result = PyDict::new(py);
+    result.set_item("kind", RESULT_KIND)?;
+    result.set_item("schema_version", RESULT_SCHEMA_VERSION)?;
+    result.set_item("validation_status", "validated")?;
+    result.set_item("template_input_abi", RECURRENCE_TEMPLATE_INPUT_ABI)?;
+    result.set_item(
+        "template_input_schema_version",
+        RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION,
+    )?;
+    result.set_item("template_input_sha256", native.input_digest)?;
+    result.set_item("catalog_digest", native.catalog_digest.to_string())?;
+    result.set_item(
+        "compiled_model_digest",
+        native.compiled_model_digest.to_string(),
+    )?;
+    result.set_item(
+        "prepared_kernel_pack_digest",
+        native.prepared_kernel_pack_digest.to_string(),
+    )?;
+    result.set_item(
+        "prepared_kernel_inventory_verified",
+        native.inventory.verified,
+    )?;
+    result.set_item(
+        "prepared_kernel_inventory_count",
+        native.inventory.authenticated_count,
+    )?;
+    if !native.inventory.verified {
+        result.set_item(
+            "prepared_kernel_inventory_requirement",
+            "central registration must compare referenced IDs with the authenticated prepared pack",
+        )?;
+    }
+
+    let counts = PyDict::new(py);
+    counts.set_item("parameters", native.parameter_count)?;
+    counts.set_item("current_states", native.current_state_count)?;
+    counts.set_item("sources", native.source_count)?;
+    counts.set_item("quantum_flows", native.quantum_flow_count)?;
+    counts.set_item(
+        "contact_orbit_certificates",
+        native.contact_orbit_certificate_count,
+    )?;
+    counts.set_item("contact_orbit_steps", native.contact_orbit_step_count)?;
+    counts.set_item("transitions", native.transition_count)?;
+    counts.set_item("propagators", native.propagator_count)?;
+    counts.set_item("closures", native.closure_count)?;
+    counts.set_item("color_contractions", native.color_contraction_count)?;
+    counts.set_item(
+        "lc_color_transition_witnesses",
+        native.lc_color_transition_witness_count,
+    )?;
+    counts.set_item("symmetry_proofs", native.symmetry_proof_count)?;
+    counts.set_item(
+        "runtime_helicity_contracts",
+        native.runtime_helicity_contract_count,
+    )?;
+    counts.set_item("evaluator_bindings", native.evaluator_binding_count)?;
+    counts.set_item("prepared_kernels", native.prepared_kernel_count)?;
+    counts.set_item(
+        "referenced_prepared_kernels",
+        native.inventory.referenced_count,
+    )?;
+    result.set_item("counts", counts)?;
+    Ok(result.into_any().unbind())
+}
+
+fn decode_rows<T>(
+    table: &OwnedTable,
+    mut decode: impl FnMut(&OwnedTable, usize) -> RusticolResult<T>,
+) -> RusticolResult<Vec<T>> {
+    let row_count = table.row_count()?;
+    (0..row_count).map(|row| decode(table, row)).collect()
+}
+
+fn indexed_ranges(table: &OwnedTable) -> RusticolResult<Vec<IndexedRangeRow>> {
+    decode_rows(table, |table, row| {
+        Ok(IndexedRangeRow {
+            id: table.u32("id")?[row],
+            range: CheckedTableRange::new(table.u64("start")?[row], table.u64("count")?[row]),
+        })
+    })
+}
+
+fn plain_ranges(table: &OwnedTable) -> RusticolResult<Vec<CheckedTableRange>> {
+    decode_rows(table, |table, row| {
+        Ok(CheckedTableRange::new(
+            table.u64("start")?[row],
+            table.u64("count")?[row],
+        ))
+    })
+}
+
+fn decode_digest_catalog(table: &OwnedTable) -> RusticolResult<Vec<DigestCatalogRow>> {
+    let ids = table.u32("id")?;
+    let values = table.u8("value")?;
+    let row_count = table.row_count()?;
+    let expected = row_count
+        .checked_mul(32)
+        .ok_or_else(|| invalid("digest catalog byte count exceeds usize"))?;
+    if values.len() != expected {
+        return Err(invalid(format!(
+            "digest_catalog.value has {} bytes, expected {expected}",
+            values.len()
+        )));
+    }
+    (0..row_count)
+        .map(|row| {
+            let start = row * 32;
+            let mut value = [0_u8; 32];
+            value.copy_from_slice(&values[start..start + 32]);
+            Ok(DigestCatalogRow {
+                id: ids[row],
+                value,
+            })
+        })
+        .collect()
+}
+
+fn semantic_digest_attribute(
+    input: &Bound<'_, PyAny>,
+    attribute: &str,
+) -> PyResult<SemanticDigest> {
+    let value = required_sha256(input, attribute, attribute)?;
+    let bytes = decode_sha256(&value, attribute)?;
+    SemanticDigest::new(bytes).map_err(python_error)
+}
+
+fn iterable_attribute<'py>(
+    value: &Bound<'py, PyAny>,
+    attribute: &str,
+    context: &str,
+) -> PyResult<Vec<Bound<'py, PyAny>>> {
+    value
+        .getattr(attribute)?
+        .try_iter()
+        .map_err(|_| PyTypeError::new_err(format!("{context} must be iterable")))?
+        .collect()
+}
+
+fn required_string(value: &Bound<'_, PyAny>, attribute: &str) -> PyResult<String> {
+    value.getattr(attribute)?.extract::<String>().map_err(|_| {
+        PyTypeError::new_err(format!(
+            "recurrence template input {attribute} must be a string"
+        ))
+    })
+}
+
+fn required_nonempty_string(
+    value: &Bound<'_, PyAny>,
+    attribute: &str,
+    context: &str,
+) -> PyResult<String> {
+    let result = required_string(value, attribute)?;
+    if result.is_empty() {
+        return Err(PyValueError::new_err(format!(
+            "recurrence template {context} must not be empty"
+        )));
+    }
+    Ok(result)
+}
+
+fn required_sha256(value: &Bound<'_, PyAny>, attribute: &str, context: &str) -> PyResult<String> {
+    let result = required_string(value, attribute)?;
+    validate_sha256_text(&result, context)?;
+    Ok(result)
+}
+
+fn validate_sha256_text(value: &str, context: &str) -> PyResult<()> {
+    if value.len() != 64
+        || !value
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f'))
+    {
+        return Err(PyValueError::new_err(format!(
+            "{context} must be a lowercase SHA-256 digest"
+        )));
+    }
+    Ok(())
+}
+
+fn decode_sha256(value: &str, context: &str) -> PyResult<[u8; 32]> {
+    validate_sha256_text(value, context)?;
+    let mut result = [0_u8; 32];
+    for (index, byte) in result.iter_mut().enumerate() {
+        let offset = index * 2;
+        *byte = u8::from_str_radix(&value[offset..offset + 2], 16)
+            .map_err(|_| PyValueError::new_err(format!("{context} is not hexadecimal")))?;
+    }
+    Ok(result)
+}
+
+fn hash_text(digest: &mut Sha256, value: &str) -> RusticolResult<()> {
+    digest.update(
+        u64::try_from(value.len())
+            .map_err(|_| invalid("recurrence template digest text length exceeds u64"))?
+            .to_le_bytes(),
+    );
+    digest.update(value.as_bytes());
+    Ok(())
+}
+
+fn hex_digest(value: impl AsRef<[u8]>) -> String {
+    let mut result = String::with_capacity(value.as_ref().len() * 2);
+    for byte in value.as_ref() {
+        use std::fmt::Write;
+        write!(&mut result, "{byte:02x}").expect("writing to String cannot fail");
+    }
+    result
+}
+
+fn invalid(message: impl Into<String>) -> RusticolError {
+    RusticolError::invalid_argument(message)
+}
+
+fn wrong_type(context: &str, expected: &str) -> RusticolError {
+    invalid(format!(
+        "{context} is not a {expected} recurrence template column"
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn table_inventory_is_canonical() {
+        assert!(
+            TABLE_SPECS
+                .windows(2)
+                .all(|pair| pair[0].name < pair[1].name)
+        );
+        for table in TABLE_SPECS {
+            assert!(
+                table
+                    .columns
+                    .iter()
+                    .map(|column| column.name)
+                    .collect::<BTreeSet<_>>()
+                    .len()
+                    == table.columns.len()
+            );
+        }
+    }
+
+    #[test]
+    fn sha256_decoder_is_strict() {
+        let value = "01".repeat(32);
+        assert_eq!(decode_sha256(&value, "test").unwrap(), [1; 32]);
+        assert!(decode_sha256(&"A1".repeat(32), "test").is_err());
+        assert!(decode_sha256("00", "test").is_err());
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-python/stubs/pyamplicol/__init__.pyi b/pyamplicol/rust/crates/rusticol-python/stubs/pyamplicol/__init__.pyi
new file mode 100644
index 0000000000..8a98ab015e
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/stubs/pyamplicol/__init__.pyi
@@ -0,0 +1 @@
+# SPDX-License-Identifier: 0BSD
diff --git a/pyamplicol/rust/crates/rusticol-python/stubs/pyamplicol/_rusticol.pyi b/pyamplicol/rust/crates/rusticol-python/stubs/pyamplicol/_rusticol.pyi
new file mode 100644
index 0000000000..20a9c9d343
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/stubs/pyamplicol/_rusticol.pyi
@@ -0,0 +1,312 @@
+# SPDX-License-Identifier: 0BSD
+
+from collections.abc import Callable, Mapping, Sequence
+from os import PathLike
+from typing import Literal, TypeAlias
+
+ScalarInput: TypeAlias = float | int
+Momenta: TypeAlias = Sequence[Sequence[Sequence[ScalarInput]]]
+ModelParameterValue: TypeAlias = complex | float | int
+ResolvedScalar: TypeAlias = float
+RuntimeProfile: TypeAlias = Mapping[str, object]
+
+class TargetInfo:
+    """Native target triple and CPU features supported by this runtime."""
+
+    @property
+    def triple(self) -> str: ...
+    @property
+    def cpu_features(self) -> list[str]: ...
+
+class RusticolError(Exception): ...
+class ArtifactError(RusticolError): ...
+class CompatibilityError(RusticolError): ...
+class EvaluationError(RusticolError): ...
+class SelectorError(EvaluationError): ...
+class ModelParameterError(EvaluationError): ...
+
+class ExternalParticle:
+    """One external particle in the public process momentum order."""
+
+    @property
+    def index(self) -> int: ...
+    @property
+    def label(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def pdg_id(self) -> int: ...
+    @property
+    def state(self) -> Literal["incoming", "outgoing"]: ...
+    @property
+    def momentum_slot(self) -> int: ...
+
+class HelicityConfiguration:
+    """A physical helicity vector and its computed representative metadata."""
+
+    @property
+    def id(self) -> str: ...
+    @property
+    def index(self) -> int: ...
+    @property
+    def values(self) -> list[int]: ...
+    @property
+    def computed(self) -> bool: ...
+    @property
+    def structural_zero(self) -> bool: ...
+    @property
+    def representative_id(self) -> str: ...
+    @property
+    def coefficient(self) -> float: ...
+
+class ColorFlow:
+    """A stable physical LC flow selector and ordered colored word."""
+
+    @property
+    def id(self) -> str: ...
+    @property
+    def index(self) -> int: ...
+    @property
+    def word(self) -> list[int]: ...
+    @property
+    def computed(self) -> bool: ...
+    @property
+    def representative_id(self) -> str: ...
+    @property
+    def coefficient(self) -> float: ...
+
+class ContractedColorComponent:
+    """The singleton contracted-color axis used by NLC and full color."""
+
+    @property
+    def id(self) -> str: ...
+    @property
+    def index(self) -> int: ...
+    @property
+    def description(self) -> str: ...
+
+class ModelParameter:
+    """A runtime model parameter and its default complex value."""
+
+    @property
+    def name(self) -> str: ...
+    @property
+    def kind(self) -> str: ...
+    @property
+    def default_real(self) -> float: ...
+    @property
+    def default_imaginary(self) -> float: ...
+    @property
+    def mutable(self) -> bool: ...
+
+class ReductionGroup:
+    @property
+    def id(self) -> str: ...
+    @property
+    def representative_helicity_id(self) -> str: ...
+    @property
+    def representative_color_id(self) -> str: ...
+    @property
+    def physical_helicity_ids(self) -> list[str]: ...
+    @property
+    def physical_color_ids(self) -> list[str]: ...
+
+class PhysicsReduction:
+    @property
+    def kind(self) -> Literal["lc-diagonal", "contracted-color"]: ...
+    @property
+    def groups(self) -> list[ReductionGroup]: ...
+
+class ProcessPhysics:
+    """Physical axes, selector capabilities, and reductions for one process."""
+
+    @property
+    def process_id(self) -> str: ...
+    @property
+    def process(self) -> str: ...
+    @property
+    def color_accuracy(self) -> Literal["lc", "nlc", "full"]: ...
+    @property
+    def helicity_coverage(self) -> str: ...
+    @property
+    def color_coverage(self) -> str: ...
+    @property
+    def color_kind(self) -> str: ...
+    @property
+    def structural_zero_helicity_count(self) -> int: ...
+    @property
+    def external_particles(self) -> list[ExternalParticle]: ...
+    @property
+    def helicities(self) -> list[HelicityConfiguration]: ...
+    @property
+    def color_flows(self) -> list[ColorFlow]: ...
+    @property
+    def contracted_color_components(self) -> list[ContractedColorComponent]: ...
+    @property
+    def reduction(self) -> PhysicsReduction: ...
+    @property
+    def model_parameters(self) -> list[ModelParameter]: ...
+    @property
+    def selector_capabilities(self) -> list[str]: ...
+
+class ResolvedEvaluation:
+    """Values shaped ``(point, helicity, color)``.
+
+    ``total()`` sums the non-point axes. LC uses physical color flows; NLC and
+    full color use one contracted color component.
+    """
+
+    @property
+    def values(self) -> list[list[list[ResolvedScalar]]]: ...
+    @property
+    def shape(self) -> tuple[int, int, int]: ...
+    @property
+    def helicity_ids(self) -> list[str]: ...
+    @property
+    def color_ids(self) -> list[str]: ...
+    @property
+    def color_flow_ids(self) -> list[str]: ...
+    @property
+    def color_accuracy(self) -> Literal["lc", "nlc", "full"]: ...
+    @property
+    def precision(self) -> int: ...
+    def total(self) -> list[ResolvedScalar]: ...
+
+class Runtime:
+    """Native f64 runtime for one process in a generated artifact."""
+
+    def __init__(
+        self,
+        artifact: str | PathLike[str],
+        *,
+        process: str | None = None,
+        model_parameters: Mapping[str, ModelParameterValue] | None = None,
+        mute_warnings: bool = False,
+    ) -> None: ...
+    @staticmethod
+    def load(
+        artifact: str | PathLike[str],
+        *,
+        process: str | None = None,
+        model_parameters: Mapping[str, ModelParameterValue] | None = None,
+        mute_warnings: bool = False,
+    ) -> Runtime:
+        """Load by stable process ID, alias ID, or exact process expression."""
+        ...
+    @property
+    def process(self) -> str: ...
+    @property
+    def artifact_id(self) -> str: ...
+    @property
+    def process_id(self) -> str: ...
+    @property
+    def color_accuracy(self) -> Literal["lc", "nlc", "full"]: ...
+    @property
+    def physics(self) -> ProcessPhysics: ...
+    def metadata_json(self) -> str: ...
+    def physics_json(self) -> str: ...
+    def save(self, path: str | PathLike[str]) -> None:
+        """Save the retained on-the-fly recursion, without model parameters."""
+        ...
+    def load_cache(self, path: str | PathLike[str]) -> None:
+        """Restore a saved recursion into the same loaded on-the-fly process."""
+        ...
+    def _on_the_fly_warm_up_f64_json(
+        self,
+        momenta: Momenta,
+        helicity_ids: Sequence[str] | None = None,
+        color_flow_ids: Sequence[str] | None = None,
+        progress_callback: Callable[[str], bool | None] | None = None,
+        *,
+        n_cores: int | None = None,
+    ) -> str: ...
+    def evaluate(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        helicity_by_point: Sequence[int] | None = None,
+        color_flow_by_point: Sequence[int] | None = None,
+        precision: Literal[16] = 16,
+    ) -> list[float]:
+        """Return one fully summed matrix element for every input point."""
+        ...
+    def _benchmark_f64_wall_time(
+        self,
+        momenta: Momenta,
+        repetitions: int,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        helicity_by_point: Sequence[int] | None = None,
+        color_flow_by_point: Sequence[int] | None = None,
+        precision: Literal[16] = 16,
+    ) -> float: ...
+    def profile(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        helicity_by_point: Sequence[int] | None = None,
+        color_flow_by_point: Sequence[int] | None = None,
+        precision: Literal[16] = 16,
+        include_values: bool = False,
+    ) -> RuntimeProfile: ...
+    def profile_repeated(
+        self,
+        momenta: Momenta,
+        repetitions: int,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        helicity_by_point: Sequence[int] | None = None,
+        color_flow_by_point: Sequence[int] | None = None,
+        precision: Literal[16] = 16,
+        include_values: bool = False,
+    ) -> RuntimeProfile: ...
+    def evaluate_profile(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        helicity_by_point: Sequence[int] | None = None,
+        color_flow_by_point: Sequence[int] | None = None,
+        precision: Literal[16] = 16,
+        include_values: bool = False,
+    ) -> RuntimeProfile: ...
+    def evaluate_resolved(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        precision: Literal[16] = 16,
+    ) -> ResolvedEvaluation:
+        """Return individual physical helicity and color components."""
+        ...
+    def evaluate_with_prec(
+        self, momenta: Momenta, decimal_digit_precision: Literal[16]
+    ) -> list[float]: ...
+    def evaluate_resolved_with_prec(
+        self,
+        momenta: Momenta,
+        decimal_digit_precision: Literal[16],
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+    ) -> ResolvedEvaluation: ...
+    def set_model_parameters(self, mapping: Mapping[str, ModelParameterValue]) -> None:
+        """Validate and atomically apply a parameter-update batch."""
+        ...
+    def clear(self) -> None: ...
+    def set_model_parameter(self, name: str, value: ModelParameterValue) -> None: ...
+    def mute_warnings(self) -> None: ...
+    def unmute_warnings(self) -> None: ...
+    def take_warnings(self) -> list[str]: ...
+
+def abi_version() -> int: ...
+def package_version() -> str: ...
+def native_build_inputs_sha256() -> str: ...
+def target_info() -> TargetInfo: ...
diff --git a/pyamplicol/rust/crates/rusticol-python/tests/pyrightconfig.json b/pyamplicol/rust/crates/rusticol-python/tests/pyrightconfig.json
new file mode 100644
index 0000000000..88f6c84f0b
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/tests/pyrightconfig.json
@@ -0,0 +1,7 @@
+{
+  "include": ["typing_consumer.py"],
+  "extraPaths": ["../stubs"],
+  "pythonVersion": "3.11",
+  "typeCheckingMode": "strict",
+  "reportMissingModuleSource": "none"
+}
diff --git a/pyamplicol/rust/crates/rusticol-python/tests/stub_contract.rs b/pyamplicol/rust/crates/rusticol-python/tests/stub_contract.rs
new file mode 100644
index 0000000000..8f7b8bcaf8
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/tests/stub_contract.rs
@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: 0BSD
+
+const BINDING: &str = include_str!("../src/lib.rs");
+const STUB: &str = include_str!("../stubs/pyamplicol/_rusticol.pyi");
+const CONSUMER: &str = include_str!("typing_consumer.py");
+
+#[test]
+fn stub_covers_the_exported_binding_surface() {
+    for name in [
+        "Runtime",
+        "ProcessPhysics",
+        "ExternalParticle",
+        "HelicityConfiguration",
+        "ColorFlow",
+        "ContractedColorComponent",
+        "ModelParameter",
+        "ResolvedEvaluation",
+        "RusticolError",
+        "ArtifactError",
+        "CompatibilityError",
+        "EvaluationError",
+        "SelectorError",
+        "ModelParameterError",
+    ] {
+        assert!(BINDING.contains(name), "binding is missing {name}");
+        assert!(
+            STUB.contains(&format!("class {name}")),
+            "stub is missing {name}"
+        );
+    }
+    for function in ["abi_version", "package_version"] {
+        assert!(BINDING.contains(&format!("fn {function}")));
+        assert!(STUB.contains(&format!("def {function}")));
+    }
+}
+
+#[test]
+fn f64_precision_and_typed_metadata_are_exercised_by_a_consumer() {
+    assert!(BINDING.contains("fn artifact_id(&self) -> &str"));
+    assert!(STUB.contains("def artifact_id(self) -> str"));
+    assert!(CONSUMER.contains("assert_type(runtime.artifact_id, str)"));
+    assert!(BINDING.contains("color_flows=None, precision=16"));
+    assert!(STUB.contains("precision: Literal[16] = 16"));
+    assert!(BINDING.contains("only precision=16"));
+    assert!(CONSUMER.contains("evaluate(momenta, precision=16)"));
+    assert!(CONSUMER.contains("evaluate_resolved(momenta, precision=16)"));
+    assert!(!CONSUMER.contains("Decimal"));
+    for field in [
+        "external_particles",
+        "helicities",
+        "color_flows",
+        "contracted_color_components",
+        "model_parameters",
+    ] {
+        assert!(STUB.contains(&format!("def {field}")));
+        assert!(CONSUMER.contains(field));
+    }
+}
diff --git a/pyamplicol/rust/crates/rusticol-python/tests/typing_consumer.py b/pyamplicol/rust/crates/rusticol-python/tests/typing_consumer.py
new file mode 100644
index 0000000000..244fe75b71
--- /dev/null
+++ b/pyamplicol/rust/crates/rusticol-python/tests/typing_consumer.py
@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: 0BSD
+
+from collections.abc import Mapping
+from typing import assert_type
+
+from pyamplicol._rusticol import (
+    ColorFlow,
+    ContractedColorComponent,
+    ExternalParticle,
+    HelicityConfiguration,
+    ModelParameter,
+    ProcessPhysics,
+    ResolvedEvaluation,
+    Runtime,
+)
+
+
+def consume_runtime(runtime: Runtime) -> None:
+    momenta = [[[10.0, 0.0, 0.0, 10.0]] * 3]
+
+    assert_type(runtime.artifact_id, str)
+    assert_type(runtime.evaluate(momenta), list[float])
+    assert_type(runtime.evaluate(momenta, precision=16), list[float])
+    assert_type(runtime.profile(momenta, precision=16), Mapping[str, object])
+    assert_type(runtime.evaluate_profile(momenta, precision=16), Mapping[str, object])
+    assert_type(runtime.evaluate_resolved(momenta, precision=16), ResolvedEvaluation)
+
+    physics = assert_type(runtime.physics, ProcessPhysics)
+    assert_type(physics.external_particles, list[ExternalParticle])
+    assert_type(physics.helicities, list[HelicityConfiguration])
+    assert_type(physics.color_flows, list[ColorFlow])
+    assert_type(physics.contracted_color_components, list[ContractedColorComponent])
+    assert_type(physics.model_parameters, list[ModelParameter])
+
+    resolved = runtime.evaluate_resolved(
+        momenta,
+        helicities=["h0"],
+        color_flows=["c0"],
+        precision=16,
+    )
+    assert_type(resolved.values, list[list[list[float]]])
+    assert_type(resolved.total(), list[float])
diff --git a/pyamplicol/schemas/README.md b/pyamplicol/schemas/README.md
new file mode 100644
index 0000000000..ccf70aa16e
--- /dev/null
+++ b/pyamplicol/schemas/README.md
@@ -0,0 +1,47 @@
+# Shared Schemas
+
+These JSON Schemas are the normative wire contracts shared by the Python
+generator, Rusticol, the native SDK, and installed-package self-tests.
+
+- `artifact-manifest-v3.schema.json` describes the only top-level process
+  artifact accepted by pyAmpliCol 0.1.
+- `runtime-physics-v1.schema.json` describes either resolved public helicity
+  and color axes or compact on-the-fly public particle/parameter metadata;
+  resolved artifacts also carry reductions and selectors.
+- `reference-physics-v2.schema.json` is the repository/sdist-only contract for
+  exact decimal physics baselines, complete resolved axes, structural zeros,
+  model-derived external spin/color/mass metadata, topology, canonical
+  reduction-group mappings, normalization, payload hashes, and capture
+  provenance.
+- `reference-oracle-evidence-v2.schema.json` records independent analytic or
+  pinned-Fortran evidence. Evidence can certify resolved cells, per-helicity
+  aggregates, or totals according to the oracle's actual semantics; it must
+  not promote diagnostic contraction partitions into physical color flows.
+  This is a developer validation format, not a runtime artifact format.
+- `reference-fixture-bundle-v1.schema.json` is the final commit marker for a
+  captured fixture and its evidence documents. It names and hashes every JSON
+  member; readers reject data files until this manifest is present and valid.
+
+Evaluator plans remain private payloads. The top-level manifest nevertheless
+records their canonical required runtime capabilities so a loader can reject
+an unsupported backend before opening evaluator bytes. Direct SymJIT f64
+applications, optional Symbolica evaluator state, compiled libraries, and
+their checksums, producer ABI, and target compatibility are covered by the
+manifest; their internal representation is not part of the public API.
+
+Loaders must perform checks that JSON Schema cannot express before opening a
+payload:
+
+1. Resolve every payload beneath the artifact root without following a
+   symlink outside it.
+2. Reject absolute paths, `..` traversal, duplicate normalized paths,
+   missing or unexpected executable payloads, and non-regular files.
+3. Verify every byte size and SHA-256 digest before deserializing or loading
+   executable state.
+4. Check package, process-artifact, runtime-physics, compiled-model,
+   evaluator runtime capabilities, relevant evaluator serialization ABI,
+   C-ABI, target-triple, and CPU-feature compatibility.
+
+Unknown top-level fields are rejected. Deliberate extension data belongs in
+the explicit `extensions` objects and must not affect physics or executable
+loading.
diff --git a/pyamplicol/schemas/artifact-manifest-v3.schema.json b/pyamplicol/schemas/artifact-manifest-v3.schema.json
new file mode 100644
index 0000000000..dee9c7c2b1
--- /dev/null
+++ b/pyamplicol/schemas/artifact-manifest-v3.schema.json
@@ -0,0 +1,574 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://pyamplicol.org/schemas/artifact-manifest-v3.schema.json",
+  "title": "pyAmpliCol process artifact manifest v3",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_version",
+    "kind",
+    "artifact_id",
+    "created_utc",
+    "producer",
+    "model",
+    "configuration",
+    "processes",
+    "runtime",
+    "payloads",
+    "dependencies"
+  ],
+  "properties": {
+    "schema_version": {
+      "const": 3
+    },
+    "kind": {
+      "enum": [
+        "pyamplicol-process",
+        "pyamplicol-process-set"
+      ]
+    },
+    "artifact_id": {
+      "$ref": "#/$defs/sha256"
+    },
+    "created_utc": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "producer": {
+      "$ref": "#/$defs/producer"
+    },
+    "model": {
+      "$ref": "#/$defs/model"
+    },
+    "configuration": {
+      "$ref": "#/$defs/configuration"
+    },
+    "processes": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/process"
+      }
+    },
+    "default_process_id": {
+      "oneOf": [
+        {
+          "$ref": "#/$defs/public_id"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null
+    },
+    "runtime": {
+      "$ref": "#/$defs/runtime"
+    },
+    "payloads": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/payload"
+      }
+    },
+    "dependencies": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/dependency"
+      }
+    },
+    "extensions": {
+      "type": "object",
+      "default": {}
+    }
+  },
+  "$defs": {
+    "sha256": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "git_revision": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{40}$"
+    },
+    "public_id": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 255,
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:+,~-]*$"
+    },
+    "runtime_capability": {
+      "enum": [
+        "symjit.application.complex-f64.v1",
+        "symbolica.legacy-jit-container.complex-f64.v1",
+        "symbolica.compiled-cpp.complex-f64.v1",
+        "symbolica.compiled-asm.complex-f64.v1"
+      ]
+    },
+    "relative_path": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*\\\\).+$"
+    },
+    "version_set": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "python_api",
+        "toml",
+        "compiled_model",
+        "process_artifact",
+        "runtime_physics",
+        "symbolica_serialization",
+        "c_abi"
+      ],
+      "properties": {
+        "python_api": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "toml": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "compiled_model": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "process_artifact": {
+          "const": 3
+        },
+        "runtime_physics": {
+          "const": 1
+        },
+        "symbolica_serialization": {
+          "type": "string",
+          "minLength": 1
+        },
+        "c_abi": {
+          "type": "integer",
+          "minimum": 1
+        }
+      }
+    },
+    "target": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "triple",
+        "cpu_features"
+      ],
+      "properties": {
+        "triple": {
+          "type": "string",
+          "minLength": 1
+        },
+        "cpu_features": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      }
+    },
+    "producer": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "distribution",
+        "version",
+        "versions",
+        "target"
+      ],
+      "properties": {
+        "distribution": {
+          "const": "pyamplicol"
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1
+        },
+        "versions": {
+          "$ref": "#/$defs/version_set"
+        },
+        "target": {
+          "$ref": "#/$defs/target"
+        },
+        "git_revision": {
+          "oneOf": [
+            {
+              "$ref": "#/$defs/git_revision"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "native_build_inputs_sha256": {
+          "oneOf": [
+            {
+              "$ref": "#/$defs/sha256"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      }
+    },
+    "model": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "name",
+        "source_kind",
+        "content_sha256",
+        "compiled_schema_version"
+      ],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "source_kind": {
+          "enum": [
+            "built-in-sm",
+            "built-in-sm-heft",
+            "ufo",
+            "ufo-json",
+            "compiled-model"
+          ]
+        },
+        "content_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "compiled_schema_version": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "restriction": {
+          "oneOf": [
+            {
+              "type": "string",
+              "minLength": 1
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null
+        }
+      }
+    },
+    "configuration": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "toml_schema_version",
+        "requested_path",
+        "effective_path",
+        "adjustments"
+      ],
+      "properties": {
+        "toml_schema_version": {
+          "const": 1
+        },
+        "requested_path": {
+          "$ref": "#/$defs/relative_path"
+        },
+        "effective_path": {
+          "$ref": "#/$defs/relative_path"
+        },
+        "adjustments": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "path",
+              "reason"
+            ],
+            "properties": {
+              "path": {
+                "type": "string",
+                "minLength": 1
+              },
+              "reason": {
+                "type": "string",
+                "minLength": 1
+              }
+            }
+          }
+        }
+      }
+    },
+    "process": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "expression",
+        "color_accuracy",
+        "external_pdgs",
+        "physics_path",
+        "required_runtime_capabilities",
+        "aliases"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "expression": {
+          "type": "string",
+          "minLength": 1
+        },
+        "color_accuracy": {
+          "enum": [
+            "lc",
+            "nlc",
+            "full"
+          ]
+        },
+        "external_pdgs": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "type": "integer"
+          }
+        },
+        "physics_path": {
+          "$ref": "#/$defs/relative_path"
+        },
+        "required_runtime_capabilities": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/runtime_capability"
+          }
+        },
+        "aliases": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "id",
+              "expression",
+              "external_pdgs",
+              "external_permutation"
+            ],
+            "properties": {
+              "id": {
+                "$ref": "#/$defs/public_id"
+              },
+              "expression": {
+                "type": "string",
+                "minLength": 1
+              },
+              "external_pdgs": {
+                "type": "array",
+                "minItems": 3,
+                "items": {
+                  "type": "integer"
+                }
+              },
+              "external_permutation": {
+                "type": "array",
+                "minItems": 3,
+                "uniqueItems": true,
+                "prefixItems": [
+                  {
+                    "const": 0
+                  },
+                  {
+                    "const": 1
+                  }
+                ],
+                "items": {
+                  "type": "integer",
+                  "minimum": 0
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "runtime": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "engine",
+        "engine_version",
+        "evaluator_manifest_path",
+        "api_bundle_path",
+        "required_runtime_capabilities"
+      ],
+      "properties": {
+        "engine": {
+          "const": "rusticol"
+        },
+        "engine_version": {
+          "type": "string",
+          "minLength": 1
+        },
+        "evaluator_manifest_path": {
+          "$ref": "#/$defs/relative_path"
+        },
+        "api_bundle_path": {
+          "oneOf": [
+            {
+              "$ref": "#/$defs/relative_path"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "required_runtime_capabilities": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/runtime_capability"
+          }
+        }
+      }
+    },
+    "payload": {
+      "type": "object",
+      "additionalProperties": false,
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "executable": {
+                "const": true
+              }
+            },
+            "required": [
+              "executable"
+            ]
+          },
+          "then": {
+            "properties": {
+              "role": {
+                "enum": [
+                  "evaluator-state",
+                  "api-source",
+                  "api-build-file"
+                ]
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "role": {
+                "const": "evaluator-state"
+              }
+            },
+            "required": [
+              "role"
+            ]
+          },
+          "then": {
+            "required": [
+              "target"
+            ]
+          }
+        }
+      ],
+      "required": [
+        "path",
+        "role",
+        "media_type",
+        "size_bytes",
+        "sha256",
+        "executable"
+      ],
+      "properties": {
+        "path": {
+          "$ref": "#/$defs/relative_path"
+        },
+        "role": {
+          "enum": [
+            "configuration-requested",
+            "configuration-effective",
+            "compiled-model",
+            "runtime-physics",
+            "evaluator-manifest",
+            "evaluator-state",
+            "model-parameters",
+            "validation-momenta",
+            "api-source",
+            "api-build-file",
+            "sdk-metadata",
+            "process-groups"
+          ]
+        },
+        "media_type": {
+          "type": "string",
+          "minLength": 1
+        },
+        "size_bytes": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "executable": {
+          "type": "boolean"
+        },
+        "target": {
+          "$ref": "#/$defs/target"
+        },
+        "process_id": {
+          "$ref": "#/$defs/public_id"
+        }
+      }
+    },
+    "dependency": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "name",
+        "version",
+        "source",
+        "license"
+      ],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1
+        },
+        "source": {
+          "type": "string",
+          "minLength": 1
+        },
+        "license": {
+          "type": "string",
+          "minLength": 1
+        },
+        "content_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "revision": {
+          "type": "string",
+          "minLength": 1
+        },
+        "patch_sha256": {
+          "$ref": "#/$defs/sha256"
+        }
+      }
+    }
+  }
+}
diff --git a/pyamplicol/schemas/reference-fixture-bundle-v1.schema.json b/pyamplicol/schemas/reference-fixture-bundle-v1.schema.json
new file mode 100644
index 0000000000..03b5667888
--- /dev/null
+++ b/pyamplicol/schemas/reference-fixture-bundle-v1.schema.json
@@ -0,0 +1,48 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://pyamplicol.org/schemas/reference-fixture-bundle-v1.schema.json",
+  "title": "pyAmpliCol reference fixture bundle manifest v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_version",
+    "kind",
+    "files",
+    "bundle_sha256"
+  ],
+  "properties": {
+    "schema_version": {
+      "const": 1
+    },
+    "kind": {
+      "const": "pyamplicol-reference-fixture-bundle"
+    },
+    "files": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "path",
+          "sha256"
+        ],
+        "properties": {
+          "path": {
+            "type": "string",
+            "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]*\\.json$"
+          },
+          "sha256": {
+            "type": "string",
+            "pattern": "^[a-f0-9]{64}$"
+          }
+        }
+      }
+    },
+    "bundle_sha256": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    }
+  }
+}
diff --git a/pyamplicol/schemas/reference-oracle-evidence-v2.schema.json b/pyamplicol/schemas/reference-oracle-evidence-v2.schema.json
new file mode 100644
index 0000000000..42f485c580
--- /dev/null
+++ b/pyamplicol/schemas/reference-oracle-evidence-v2.schema.json
@@ -0,0 +1,436 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://pyamplicol.org/schemas/reference-oracle-evidence-v2.schema.json",
+  "title": "pyAmpliCol independent oracle evidence v2",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "evidence_schema_version",
+    "kind",
+    "evidence_set_id",
+    "captured_at",
+    "oracle",
+    "dependency_ids",
+    "records"
+  ],
+  "properties": {
+    "evidence_schema_version": {
+      "const": 2
+    },
+    "kind": {
+      "const": "pyamplicol-reference-oracle-evidence"
+    },
+    "evidence_set_id": {
+      "$ref": "#/$defs/public_id"
+    },
+    "captured_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "oracle": {
+      "$ref": "#/$defs/oracle"
+    },
+    "dependency_ids": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/$defs/public_id"
+      }
+    },
+    "records": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/record"
+      }
+    }
+  },
+  "$defs": {
+    "public_id": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 255,
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:+,~-]*$"
+    },
+    "sha256": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "decimal": {
+      "type": "string",
+      "pattern": "^(?:0|-?(?:(?:[1-9][0-9]*)(?:\\.[0-9]*[1-9])?|0\\.[0-9]*[1-9]))$"
+    },
+    "nonnegative_decimal": {
+      "type": "string",
+      "pattern": "^(?:0|[1-9][0-9]*)(?:\\.[0-9]*[1-9])?$"
+    },
+    "oracle": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "name",
+        "implementation",
+        "revision",
+        "content_sha256",
+        "independence_statement",
+        "validation_profile",
+        "tolerance_ceiling"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "implementation": {
+          "type": "string",
+          "minLength": 1
+        },
+        "revision": {
+          "type": "string",
+          "minLength": 1
+        },
+        "content_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "independence_statement": {
+          "type": "string",
+          "minLength": 1
+        },
+        "validation_profile": {
+          "enum": [
+            "exact",
+            "binary64",
+            "high-precision"
+          ]
+        },
+        "tolerance_ceiling": {
+          "$ref": "#/$defs/tolerances"
+        }
+      }
+    },
+    "process_identity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "expression",
+        "ordered_external_pdgs",
+        "ordered_external_leg_ids",
+        "source_to_row_permutation",
+        "row_id",
+        "color_order_count",
+        "ordered_color_legs"
+      ],
+      "properties": {
+        "expression": {
+          "type": "string",
+          "minLength": 1
+        },
+        "ordered_external_pdgs": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "type": "integer"
+          }
+        },
+        "ordered_external_leg_ids": {
+          "type": "array",
+          "minItems": 3,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        },
+        "source_to_row_permutation": {
+          "type": "array",
+          "minItems": 3,
+          "uniqueItems": true,
+          "items": {
+            "type": "integer",
+            "minimum": 0
+          }
+        },
+        "row_id": {
+          "oneOf": [
+            {
+              "type": "string",
+              "minLength": 1
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "color_order_count": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "ordered_color_legs": {
+          "type": "array",
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        }
+      }
+    },
+    "tolerances": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "relative",
+        "absolute"
+      ],
+      "properties": {
+        "relative": {
+          "$ref": "#/$defs/nonnegative_decimal"
+        },
+        "absolute": {
+          "$ref": "#/$defs/nonnegative_decimal"
+        }
+      }
+    },
+    "decimal_vector": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/decimal"
+      }
+    },
+    "decimal_matrix": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/decimal_vector"
+      }
+    },
+    "record": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "case_id",
+        "point_id",
+        "independent_of_pyamplicol",
+        "arithmetic_precision_bits",
+        "round_trip_decimal_digits",
+        "certified_decimal_digits",
+        "arithmetic",
+        "coverage",
+        "helicity_ids",
+        "color_ids",
+        "observed_total",
+        "observed_helicity_totals",
+        "observed_values",
+        "process_identity",
+        "input_sha256",
+        "physics_case_sha256",
+        "oracle_output_sha256",
+        "evidence_record_sha256",
+        "command",
+        "tolerances"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "case_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "point_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "independent_of_pyamplicol": {
+          "const": true
+        },
+        "arithmetic_precision_bits": {
+          "type": "integer",
+          "minimum": 2
+        },
+        "round_trip_decimal_digits": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "certified_decimal_digits": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "arithmetic": {
+          "enum": [
+            "binary64",
+            "decimal",
+            "rational",
+            "analytic"
+          ]
+        },
+        "coverage": {
+          "enum": [
+            "total",
+            "helicity-aggregate",
+            "resolved"
+          ]
+        },
+        "helicity_ids": {
+          "type": "array",
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        },
+        "color_ids": {
+          "type": "array",
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        },
+        "observed_total": {
+          "$ref": "#/$defs/decimal"
+        },
+        "observed_helicity_totals": {
+          "oneOf": [
+            {
+              "$ref": "#/$defs/decimal_vector"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "observed_values": {
+          "oneOf": [
+            {
+              "$ref": "#/$defs/decimal_matrix"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "process_identity": {
+          "$ref": "#/$defs/process_identity"
+        },
+        "input_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "physics_case_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "oracle_output_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "evidence_record_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "command": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "tolerances": {
+          "$ref": "#/$defs/tolerances"
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "arithmetic": {
+                "const": "binary64"
+              }
+            },
+            "required": [
+              "arithmetic"
+            ]
+          },
+          "then": {
+            "properties": {
+              "arithmetic_precision_bits": {
+                "const": 53
+              },
+              "round_trip_decimal_digits": {
+                "const": 17
+              },
+              "certified_decimal_digits": {
+                "maximum": 15
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "coverage": {
+                "const": "total"
+              }
+            },
+            "required": [
+              "coverage"
+            ]
+          },
+          "then": {
+            "properties": {
+              "observed_helicity_totals": {
+                "type": "null"
+              },
+              "observed_values": {
+                "type": "null"
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "coverage": {
+                "const": "helicity-aggregate"
+              }
+            },
+            "required": [
+              "coverage"
+            ]
+          },
+          "then": {
+            "properties": {
+              "observed_helicity_totals": {
+                "$ref": "#/$defs/decimal_vector"
+              },
+              "observed_values": {
+                "type": "null"
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "coverage": {
+                "const": "resolved"
+              }
+            },
+            "required": [
+              "coverage"
+            ]
+          },
+          "then": {
+            "properties": {
+              "observed_helicity_totals": {
+                "type": "null"
+              },
+              "observed_values": {
+                "$ref": "#/$defs/decimal_matrix"
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+}
diff --git a/pyamplicol/schemas/reference-physics-v2.schema.json b/pyamplicol/schemas/reference-physics-v2.schema.json
new file mode 100644
index 0000000000..b875160166
--- /dev/null
+++ b/pyamplicol/schemas/reference-physics-v2.schema.json
@@ -0,0 +1,1131 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://pyamplicol.org/schemas/reference-physics-v2.schema.json",
+  "title": "pyAmpliCol test reference physics fixture v2",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "fixture_schema_version",
+    "kind",
+    "fixture_id",
+    "provenance",
+    "dependencies",
+    "models",
+    "processes",
+    "points",
+    "cases",
+    "evidence_sets"
+  ],
+  "properties": {
+    "fixture_schema_version": {
+      "const": 2
+    },
+    "kind": {
+      "const": "pyamplicol-reference-physics"
+    },
+    "fixture_id": {
+      "$ref": "#/$defs/public_id"
+    },
+    "provenance": {
+      "$ref": "#/$defs/fixture_provenance"
+    },
+    "dependencies": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/dependency"
+      }
+    },
+    "models": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/model"
+      }
+    },
+    "processes": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/process"
+      }
+    },
+    "points": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/point"
+      }
+    },
+    "cases": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/case"
+      }
+    },
+    "evidence_sets": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/$defs/public_id"
+      }
+    }
+  },
+  "$defs": {
+    "public_id": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 255,
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:+,~-]*$"
+    },
+    "sha256": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "git_revision": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{40}$"
+    },
+    "decimal": {
+      "type": "string",
+      "pattern": "^(?:0|-?(?:(?:[1-9][0-9]*)(?:\\.[0-9]*[1-9])?|0\\.[0-9]*[1-9]))$"
+    },
+    "nonnegative_decimal": {
+      "type": "string",
+      "pattern": "^(?:0|[1-9][0-9]*)(?:\\.[0-9]*[1-9])?$"
+    },
+    "positive_decimal": {
+      "type": "string",
+      "pattern": "^(?:(?:[1-9][0-9]*)(?:\\.[0-9]*[1-9])?|0\\.[0-9]*[1-9])$"
+    },
+    "complex_decimal": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "real",
+        "imag"
+      ],
+      "properties": {
+        "real": {
+          "$ref": "#/$defs/decimal"
+        },
+        "imag": {
+          "$ref": "#/$defs/decimal"
+        }
+      }
+    },
+    "fixture_provenance": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "source_repository",
+        "source_revision",
+        "source_tree_sha256",
+        "captured_at",
+        "capture_command",
+        "working_tree_clean",
+        "memory_watchdog_gb"
+      ],
+      "properties": {
+        "source_repository": {
+          "type": "string",
+          "format": "uri"
+        },
+        "source_revision": {
+          "$ref": "#/$defs/git_revision"
+        },
+        "source_tree_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "captured_at": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "capture_command": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "working_tree_clean": {
+          "type": "boolean"
+        },
+        "memory_watchdog_gb": {
+          "type": "integer",
+          "minimum": 1
+        }
+      }
+    },
+    "dependency": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "name",
+        "version",
+        "revision",
+        "content_sha256",
+        "serialization_abi",
+        "license"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1
+        },
+        "revision": {
+          "oneOf": [
+            {
+              "type": "string",
+              "minLength": 1
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "content_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "patch_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "serialization_abi": {
+          "oneOf": [
+            {
+              "type": "string",
+              "minLength": 1
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "license": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "model": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "name",
+        "source_kind",
+        "content_sha256",
+        "compiled_model_sha256",
+        "compiled_schema_version",
+        "restriction",
+        "dependency_ids",
+        "parameter_defaults"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "source_kind": {
+          "enum": [
+            "built-in-sm",
+            "built-in-sm-heft",
+            "ufo",
+            "ufo-json",
+            "compiled-model"
+          ]
+        },
+        "content_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "compiled_model_sha256": {
+          "$ref": "#/$defs/sha256",
+          "description": "Canonical hash of the compiled model contract excluding conversion and phase timing diagnostics."
+        },
+        "compiled_schema_version": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "restriction": {
+          "oneOf": [
+            {
+              "type": "string",
+              "minLength": 1
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "dependency_ids": {
+          "type": "array",
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        },
+        "parameter_defaults": {
+          "type": "object",
+          "propertyNames": {
+            "type": "string",
+            "minLength": 1
+          },
+          "additionalProperties": {
+            "$ref": "#/$defs/complex_decimal"
+          }
+        }
+      }
+    },
+    "process": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "expression",
+        "external_pdgs",
+        "external_labels",
+        "external_leg_ids",
+        "external_spins",
+        "external_colors",
+        "external_masses",
+        "external_helicity_domains",
+        "initial_state_count",
+        "alias_of",
+        "final_state_permutation"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "expression": {
+          "type": "string",
+          "minLength": 1
+        },
+        "external_pdgs": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "type": "integer"
+          }
+        },
+        "external_labels": {
+          "type": "array",
+          "minItems": 3,
+          "uniqueItems": true,
+          "items": {
+            "type": "integer",
+            "minimum": 1
+          }
+        },
+        "external_leg_ids": {
+          "type": "array",
+          "minItems": 3,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        },
+        "external_spins": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "type": "integer",
+            "minimum": 1
+          }
+        },
+        "external_colors": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "enum": [
+              -3,
+              1,
+              3,
+              8
+            ]
+          }
+        },
+        "external_masses": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "$ref": "#/$defs/nonnegative_decimal"
+          }
+        },
+        "external_helicity_domains": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true,
+            "items": {
+              "type": "integer"
+            }
+          }
+        },
+        "initial_state_count": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "alias_of": {
+          "oneOf": [
+            {
+              "$ref": "#/$defs/public_id"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "final_state_permutation": {
+          "oneOf": [
+            {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": {
+                "type": "integer",
+                "minimum": 0
+              }
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "alias_of": {
+                "type": "null"
+              }
+            },
+            "required": [
+              "alias_of"
+            ]
+          },
+          "then": {
+            "properties": {
+              "final_state_permutation": {
+                "type": "null"
+              }
+            }
+          },
+          "else": {
+            "properties": {
+              "final_state_permutation": {
+                "type": "array",
+                "minItems": 1
+              }
+            }
+          }
+        }
+      ]
+    },
+    "point_algorithm": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "name",
+        "version",
+        "rng",
+        "seed"
+      ],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1
+        },
+        "rng": {
+          "oneOf": [
+            {
+              "type": "string",
+              "minLength": 1
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "seed": {
+          "oneOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      }
+    },
+    "point": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "process_id",
+        "class",
+        "algorithm",
+        "sqrt_s",
+        "momenta",
+        "masses",
+        "arithmetic_precision_bits",
+        "round_trip_decimal_digits",
+        "certified_decimal_digits",
+        "stress_metric"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "process_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "class": {
+          "enum": [
+            "canonical",
+            "generic",
+            "stress"
+          ]
+        },
+        "algorithm": {
+          "$ref": "#/$defs/point_algorithm"
+        },
+        "sqrt_s": {
+          "$ref": "#/$defs/decimal"
+        },
+        "momenta": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "type": "array",
+            "minItems": 4,
+            "maxItems": 4,
+            "items": {
+              "$ref": "#/$defs/decimal"
+            }
+          }
+        },
+        "masses": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "$ref": "#/$defs/nonnegative_decimal"
+          }
+        },
+        "arithmetic_precision_bits": {
+          "type": "integer",
+          "minimum": 2
+        },
+        "round_trip_decimal_digits": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "certified_decimal_digits": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "stress_metric": {
+          "oneOf": [
+            {
+              "$ref": "#/$defs/stress_metric"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "class": {
+                "const": "stress"
+              }
+            },
+            "required": [
+              "class"
+            ]
+          },
+          "then": {
+            "properties": {
+              "stress_metric": {
+                "$ref": "#/$defs/stress_metric"
+              }
+            }
+          },
+          "else": {
+            "properties": {
+              "stress_metric": {
+                "type": "null"
+              }
+            }
+          }
+        }
+      ]
+    },
+    "stress_metric": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "kind",
+        "value"
+      ],
+      "properties": {
+        "kind": {
+          "enum": [
+            "minimum-final-energy-fraction",
+            "minimum-final-transverse-momentum-squared-fraction",
+            "relative-excess-energy"
+          ]
+        },
+        "value": {
+          "$ref": "#/$defs/positive_decimal"
+        }
+      }
+    },
+    "coverage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "helicities",
+        "color",
+        "color_kind",
+        "helicity_count",
+        "color_component_count",
+        "structural_zero_helicity_count"
+      ],
+      "properties": {
+        "helicities": {
+          "enum": [
+            "complete",
+            "selected"
+          ]
+        },
+        "color": {
+          "enum": [
+            "complete",
+            "selected",
+            "contracted"
+          ]
+        },
+        "color_kind": {
+          "enum": [
+            "physical-lc-flows",
+            "contracted-color"
+          ]
+        },
+        "helicity_count": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "color_component_count": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "structural_zero_helicity_count": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "selectors": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "helicity",
+        "color_flow",
+        "omitted_helicity",
+        "omitted_color"
+      ],
+      "properties": {
+        "helicity": {
+          "type": "boolean"
+        },
+        "color_flow": {
+          "type": "boolean"
+        },
+        "omitted_helicity": {
+          "const": "all-components"
+        },
+        "omitted_color": {
+          "enum": [
+            "all-components",
+            "contracted-component"
+          ]
+        }
+      }
+    },
+    "normalization": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "average_factor",
+        "color_factor",
+        "identical_factor",
+        "global_coupling_factor",
+        "quark_line_partner_factor",
+        "couplings_in_stage_evaluators"
+      ],
+      "properties": {
+        "average_factor": {
+          "$ref": "#/$defs/decimal"
+        },
+        "color_factor": {
+          "$ref": "#/$defs/decimal"
+        },
+        "identical_factor": {
+          "$ref": "#/$defs/decimal"
+        },
+        "global_coupling_factor": {
+          "$ref": "#/$defs/decimal"
+        },
+        "quark_line_partner_factor": {
+          "$ref": "#/$defs/decimal"
+        },
+        "couplings_in_stage_evaluators": {
+          "type": "boolean"
+        }
+      }
+    },
+    "topology": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "currents",
+        "interactions",
+        "roots",
+        "reduction_groups"
+      ],
+      "properties": {
+        "currents": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "interactions": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "roots": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "reduction_groups": {
+          "type": "integer",
+          "minimum": 1
+        }
+      }
+    },
+    "helicity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "index",
+        "values",
+        "computed",
+        "structural_zero",
+        "representative_id",
+        "coefficient"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "index": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "values": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "type": "integer"
+          }
+        },
+        "computed": {
+          "type": "boolean"
+        },
+        "structural_zero": {
+          "type": "boolean"
+        },
+        "representative_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "coefficient": {
+          "$ref": "#/$defs/decimal"
+        }
+      }
+    },
+    "lc_color_flow": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "kind",
+        "id",
+        "index",
+        "word",
+        "computed",
+        "representative_id",
+        "coefficient"
+      ],
+      "properties": {
+        "kind": {
+          "const": "lc-flow"
+        },
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "index": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "word": {
+          "type": "array",
+          "items": {
+            "type": "integer",
+            "minimum": 1
+          }
+        },
+        "computed": {
+          "type": "boolean"
+        },
+        "representative_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "coefficient": {
+          "$ref": "#/$defs/decimal"
+        }
+      }
+    },
+    "contracted_color": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "kind",
+        "id",
+        "index",
+        "description"
+      ],
+      "properties": {
+        "kind": {
+          "const": "contracted-color"
+        },
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "index": {
+          "const": 0
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "axes": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "helicities",
+        "colors"
+      ],
+      "properties": {
+        "helicities": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "$ref": "#/$defs/helicity"
+          }
+        },
+        "colors": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "oneOf": [
+              {
+                "$ref": "#/$defs/lc_color_flow"
+              },
+              {
+                "$ref": "#/$defs/contracted_color"
+              }
+            ]
+          }
+        }
+      }
+    },
+    "reduction_group": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "representative_helicity_id",
+        "representative_color_id",
+        "physical_helicity_ids",
+        "physical_color_ids"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "representative_helicity_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "representative_color_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "physical_helicity_ids": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        },
+        "physical_color_ids": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        }
+      }
+    },
+    "reduction": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "kind",
+        "cell_semantics",
+        "groups",
+        "plan_sha256"
+      ],
+      "properties": {
+        "kind": {
+          "enum": [
+            "lc-diagonal",
+            "contracted-color"
+          ]
+        },
+        "cell_semantics": {
+          "enum": [
+            "sum-all-contributing-groups",
+            "fully-contracted-color"
+          ]
+        },
+        "groups": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "$ref": "#/$defs/reduction_group"
+          }
+        },
+        "plan_sha256": {
+          "$ref": "#/$defs/sha256"
+        }
+      }
+    },
+    "observation": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "point_id",
+        "arithmetic_precision_bits",
+        "round_trip_decimal_digits",
+        "certified_decimal_digits",
+        "values",
+        "total",
+        "evidence_refs"
+      ],
+      "properties": {
+        "point_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "arithmetic_precision_bits": {
+          "type": "integer",
+          "minimum": 2
+        },
+        "round_trip_decimal_digits": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "certified_decimal_digits": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "values": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "$ref": "#/$defs/decimal"
+            }
+          }
+        },
+        "total": {
+          "$ref": "#/$defs/decimal"
+        },
+        "evidence_refs": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        }
+      }
+    },
+    "case": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "case_kind",
+        "model_id",
+        "process_id",
+        "color_accuracy",
+        "point_policy",
+        "point_ids",
+        "coverage",
+        "selectors",
+        "normalization",
+        "topology",
+        "artifact_physics_sha256",
+        "artifact_execution_sha256",
+        "physics_case_sha256",
+        "axes",
+        "reduction",
+        "observations"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "case_kind": {
+          "enum": [
+            "substantive",
+            "diagnostic"
+          ]
+        },
+        "model_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "process_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "color_accuracy": {
+          "enum": [
+            "lc",
+            "nlc",
+            "full"
+          ]
+        },
+        "point_policy": {
+          "enum": [
+            "standard",
+            "degenerate-2to1"
+          ]
+        },
+        "point_ids": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        },
+        "coverage": {
+          "$ref": "#/$defs/coverage"
+        },
+        "selectors": {
+          "$ref": "#/$defs/selectors"
+        },
+        "normalization": {
+          "$ref": "#/$defs/normalization"
+        },
+        "topology": {
+          "$ref": "#/$defs/topology"
+        },
+        "artifact_physics_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "artifact_execution_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "physics_case_sha256": {
+          "$ref": "#/$defs/sha256"
+        },
+        "axes": {
+          "$ref": "#/$defs/axes"
+        },
+        "reduction": {
+          "$ref": "#/$defs/reduction"
+        },
+        "observations": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "$ref": "#/$defs/observation"
+          }
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "case_kind": {
+                "const": "substantive"
+              }
+            },
+            "required": [
+              "case_kind"
+            ]
+          },
+          "then": {
+            "properties": {
+              "coverage": {
+                "properties": {
+                  "helicities": {
+                    "const": "complete"
+                  },
+                  "color": {
+                    "enum": [
+                      "complete",
+                      "contracted"
+                    ]
+                  }
+                }
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+}
diff --git a/pyamplicol/schemas/runtime-physics-v1.schema.json b/pyamplicol/schemas/runtime-physics-v1.schema.json
new file mode 100644
index 0000000000..b79912f1ff
--- /dev/null
+++ b/pyamplicol/schemas/runtime-physics-v1.schema.json
@@ -0,0 +1,456 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://pyamplicol.org/schemas/runtime-physics-v1.schema.json",
+  "title": "pyAmpliCol runtime physics metadata v1",
+  "oneOf": [
+    {
+      "$ref": "#/$defs/resolved_physics"
+    },
+    {
+      "$ref": "#/$defs/on_the_fly_public_metadata"
+    }
+  ],
+  "$defs": {
+    "resolved_physics": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "schema_version",
+        "kind",
+        "process_id",
+        "process",
+        "color_accuracy",
+        "coverage",
+        "external_particles",
+        "helicities",
+        "color_components",
+        "reduction",
+        "model_parameters",
+        "selectors"
+      ],
+      "properties": {
+        "schema_version": {
+          "const": 1
+        },
+        "kind": {
+          "const": "pyamplicol-resolved-physics"
+        },
+        "process_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "process": {
+          "type": "string",
+          "minLength": 1
+        },
+        "color_accuracy": {
+          "enum": [
+            "lc",
+            "nlc",
+            "full"
+          ]
+        },
+        "coverage": {
+          "$ref": "#/$defs/coverage"
+        },
+        "external_particles": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "$ref": "#/$defs/external_particle"
+          }
+        },
+        "helicities": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "$ref": "#/$defs/helicity"
+          }
+        },
+        "color_components": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "oneOf": [
+              {
+                "$ref": "#/$defs/color_flow"
+              },
+              {
+                "$ref": "#/$defs/contracted_color"
+              }
+            ]
+          }
+        },
+        "reduction": {
+          "$ref": "#/$defs/reduction"
+        },
+        "model_parameters": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/model_parameter"
+          }
+        },
+        "selectors": {
+          "$ref": "#/$defs/selectors"
+        },
+        "extensions": {
+          "type": "object",
+          "default": {}
+        }
+      }
+    },
+    "on_the_fly_public_metadata": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "schema_version",
+        "kind",
+        "process_id",
+        "process",
+        "color_accuracy",
+        "external_particles",
+        "model_parameters"
+      ],
+      "properties": {
+        "schema_version": {
+          "const": 1
+        },
+        "kind": {
+          "const": "pyamplicol-on-the-fly-public-metadata"
+        },
+        "process_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "process": {
+          "type": "string",
+          "minLength": 1
+        },
+        "color_accuracy": {
+          "const": "lc"
+        },
+        "external_particles": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "$ref": "#/$defs/external_particle"
+          }
+        },
+        "model_parameters": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/model_parameter"
+          }
+        }
+      }
+    },
+    "public_id": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 255,
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:+,~-]*$"
+    },
+    "coverage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "helicities",
+        "color",
+        "color_kind",
+        "structural_zero_helicity_count"
+      ],
+      "properties": {
+        "helicities": {
+          "enum": [
+            "complete",
+            "selected"
+          ]
+        },
+        "color": {
+          "enum": [
+            "complete",
+            "selected",
+            "contracted"
+          ]
+        },
+        "color_kind": {
+          "enum": [
+            "physical-lc-flows",
+            "contracted-color"
+          ]
+        },
+        "structural_zero_helicity_count": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "external_particle": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "index",
+        "label",
+        "particle",
+        "pdg",
+        "role",
+        "momentum_slot",
+        "momentum_components"
+      ],
+      "properties": {
+        "index": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "label": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "particle": {
+          "type": "string",
+          "minLength": 1
+        },
+        "pdg": {
+          "type": "integer"
+        },
+        "role": {
+          "enum": [
+            "initial",
+            "final"
+          ]
+        },
+        "momentum_slot": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "momentum_components": {
+          "const": [
+            "E",
+            "px",
+            "py",
+            "pz"
+          ]
+        }
+      }
+    },
+    "helicity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "index",
+        "values",
+        "computed",
+        "structural_zero",
+        "representative_id",
+        "coefficient"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "index": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "values": {
+          "type": "array",
+          "minItems": 3,
+          "items": {
+            "type": "integer"
+          }
+        },
+        "computed": {
+          "type": "boolean"
+        },
+        "structural_zero": {
+          "type": "boolean"
+        },
+        "representative_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "coefficient": {
+          "type": "number"
+        }
+      }
+    },
+    "color_flow": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "kind",
+        "id",
+        "index",
+        "word",
+        "computed",
+        "representative_id",
+        "coefficient"
+      ],
+      "properties": {
+        "kind": {
+          "const": "lc-flow"
+        },
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "index": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "word": {
+          "type": "array",
+          "items": {
+            "type": "integer",
+            "minimum": 1
+          }
+        },
+        "computed": {
+          "type": "boolean"
+        },
+        "representative_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "coefficient": {
+          "type": "number"
+        }
+      }
+    },
+    "contracted_color": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "kind",
+        "id",
+        "index",
+        "description"
+      ],
+      "properties": {
+        "kind": {
+          "const": "contracted-color"
+        },
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "index": {
+          "const": 0
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "reduction": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "kind",
+        "groups"
+      ],
+      "properties": {
+        "kind": {
+          "enum": [
+            "lc-diagonal",
+            "contracted-color"
+          ]
+        },
+        "groups": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/reduction_group"
+          }
+        }
+      }
+    },
+    "reduction_group": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "representative_helicity_id",
+        "representative_color_id",
+        "physical_helicity_ids",
+        "physical_color_ids"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "representative_helicity_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "representative_color_id": {
+          "$ref": "#/$defs/public_id"
+        },
+        "physical_helicity_ids": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        },
+        "physical_color_ids": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "$ref": "#/$defs/public_id"
+          }
+        }
+      }
+    },
+    "model_parameter": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "name",
+        "kind",
+        "default_real",
+        "default_imaginary",
+        "mutable"
+      ],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "kind": {
+          "enum": [
+            "normalization",
+            "mass",
+            "width",
+            "coupling",
+            "external",
+            "derived"
+          ]
+        },
+        "default_real": {
+          "type": "number"
+        },
+        "default_imaginary": {
+          "type": "number"
+        },
+        "mutable": {
+          "type": "boolean"
+        }
+      }
+    },
+    "selectors": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "helicity",
+        "color_flow",
+        "contracted_color"
+      ],
+      "properties": {
+        "helicity": {
+          "type": "boolean"
+        },
+        "color_flow": {
+          "type": "boolean"
+        },
+        "contracted_color": {
+          "const": false
+        }
+      }
+    }
+  }
+}
diff --git a/pyamplicol/source_hash.py b/pyamplicol/source_hash.py
new file mode 100644
index 0000000000..9c43423d94
--- /dev/null
+++ b/pyamplicol/source_hash.py
@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: 0BSD
+"""Hash of the pyAmpliCol sources that end up in an installed package.
+
+The build stores it as ``pyamplicol._source_hash.SOURCE_HASH``, so MadGraph7
+can warn when the installed package no longer matches the source tree (as for
+madspace). Generated files (native libraries, staged SDK, prepared-model packs
+from the release archive, build provenance) are left out.
+"""
+
+import hashlib
+from pathlib import Path, PurePosixPath
+
+_ROOT = Path(__file__).resolve().parent
+
+_SOURCE_DIRS = ("src", "rust")
+_SOURCE_FILES = ("Cargo.toml", "Cargo.lock", "pyproject.toml", "rust-toolchain.toml")
+
+_IGNORED_DIR_NAMES = {"__pycache__", "target"}
+_IGNORED_FILE_NAMES = {".DS_Store", "_build_info.json", "_source_hash.py"}
+_IGNORED_SUFFIXES = {".pyc", ".pyo", ".so", ".dylib", ".pyd", ".pyamplicol-model"}
+_IGNORED_TREES = tuple(
+    PurePosixPath(path)
+    for path in (
+        "src/pyamplicol/_sdk/lib",
+        "src/pyamplicol/_sdk/include",
+        "src/pyamplicol/_sdk/fortran",
+        "src/pyamplicol/_sdk/sboms",
+        "src/pyamplicol/_sdk/link.json",
+        "src/pyamplicol/_sdk/metadata.json",
+        "src/pyamplicol/_examples",
+    )
+)
+
+
+def _ignored(relative: PurePosixPath) -> bool:
+    if _IGNORED_DIR_NAMES & set(relative.parts):
+        return True
+    if relative.name in _IGNORED_FILE_NAMES or relative.suffix in _IGNORED_SUFFIXES:
+        return True
+    if (
+        relative.name.endswith(".metadata.json")
+        and relative.parent.name == "prepared_models"
+    ):
+        return True
+    # Self-test fixtures other than the tracked portable one are generated.
+    parts = relative.parts
+    selftest = parts[:4] == ("src", "pyamplicol", "assets", "selftest")
+    if selftest and len(parts) > 5 and parts[4] != "portable-64le":
+        return True
+    return any(relative == tree or tree in relative.parents for tree in _IGNORED_TREES)
+
+
+def _iter_source_files(root: Path):
+    for dir_name in _SOURCE_DIRS:
+        for path in (root / dir_name).rglob("*"):
+            relative = PurePosixPath(path.relative_to(root).as_posix())
+            if path.is_file() and not _ignored(relative):
+                yield path
+    for file_name in _SOURCE_FILES:
+        yield root / file_name
+
+
+def compute_source_hash(root: Path = _ROOT) -> str:
+    root = Path(root).resolve()
+    paths = sorted(
+        _iter_source_files(root), key=lambda p: p.relative_to(root).as_posix()
+    )
+    digest = hashlib.sha256()
+    for path in paths:
+        digest.update(path.relative_to(root).as_posix().encode("utf-8"))
+        digest.update(b"\0")
+        with open(path, "rb") as f:
+            digest.update(hashlib.file_digest(f, "sha256").digest())
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+if __name__ == "__main__":
+    print(compute_source_hash())
diff --git a/pyamplicol/src/pyamplicol/__init__.py b/pyamplicol/src/pyamplicol/__init__.py
new file mode 100644
index 0000000000..535575e367
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/__init__.py
@@ -0,0 +1,275 @@
+# SPDX-License-Identifier: 0BSD
+"""Public Python interface for pyAmpliCol.
+
+The package's Symbolica library key is tried before any symbolic work.
+Personal licenses and restricted mode remain available if registration fails.
+Model tooling is loaded only when generation or runtime services are first used.
+"""
+
+from __future__ import annotations
+
+import os as _os
+from contextlib import suppress as _suppress
+from importlib import import_module
+from typing import TYPE_CHECKING, Any
+
+from ._internal.versions import package_version
+
+if TYPE_CHECKING:
+    from types import ModuleType as _ModuleType
+
+# Registration precedes symbolic work, including in spawned Python workers.
+# Keep startup quiet before CLI output/banner policy can be resolved, without
+# changing the caller's banner or personal-license environment.
+_previous_banner = _os.environ.get("SYMBOLICA_HIDE_BANNER")
+_os.environ["SYMBOLICA_HIDE_BANNER"] = "1"
+_symbolica: _ModuleType | None
+try:
+    try:
+        import symbolica as _symbolica
+    except ModuleNotFoundError as _error:
+        if _error.name != "symbolica":
+            raise
+        # Keep configuration/source-only tooling usable without native deps.
+        _symbolica = None
+
+    _set_library_key = getattr(_symbolica, "set_library_key", None)
+    if callable(_set_library_key):
+        # Symbolica's public is_licensed() remains the authority: a personal
+        # key can still license this process, otherwise use restricted mode.
+        with _suppress(ValueError, PermissionError):
+            _set_library_key(
+                "SU-419-pyamplicol-2028.01.01-"
+                "KJBO3RLZJ3H5FKU5CL756QLKZCURABBCKRGHZRK5OVIUQXZBCLJTOUQPHXYVTANIX"
+                "SCKI6YTZDWGH2NWHQIBCPDUO5GVW2STVMP3MCQ"
+            )
+finally:
+    if _previous_banner is None:
+        _os.environ.pop("SYMBOLICA_HIDE_BANNER", None)
+    else:
+        _os.environ["SYMBOLICA_HIDE_BANNER"] = _previous_banner
+del _os, _suppress, _previous_banner, _symbolica, _set_library_key
+
+if TYPE_CHECKING:
+    from .api import (
+        ArtifactError,
+        BenchmarkComponentTiming,
+        BenchmarkProfileCounters,
+        BenchmarkResult,
+        BenchmarkRunner,
+        BenchmarkStageTiming,
+        BenchmarkStatistics,
+        BenchmarkTimingBreakdown,
+        ColorComponent,
+        ColorFlow,
+        CompatibilityError,
+        CompiledModel,
+        CompiledModelCapabilities,
+        CompiledModelInfo,
+        CompiledModelSource,
+        ConfigurationError,
+        ContractedColorComponent,
+        DependencyError,
+        EvaluationError,
+        ExternalParticle,
+        GenerationError,
+        GenerationPlan,
+        GenerationResult,
+        Generator,
+        HelicityConfiguration,
+        ModelCompilationIssue,
+        ModelCompilationPhase,
+        ModelError,
+        ModelParameter,
+        ModelSource,
+        PhysicsReduction,
+        ProcessAlias,
+        ProcessPhysics,
+        ProcessRequest,
+        ProcessSet,
+        PyAmpliColError,
+        ReductionGroup,
+        ResolvedEvaluation,
+        Runtime,
+        WarmUpResult,
+        benchmark,
+        generate,
+        group_processes,
+        load,
+    )
+    from .config import (
+        BenchmarkConfig,
+        ColorConfig,
+        ColorFFTBasis,
+        EvaluationConfig,
+        GenerationConfig,
+        RunConfig,
+    )
+    from .correlators import (
+        ColorCorrelator,
+        CorrelatedRequest,
+        CorrelatedValue,
+        CorrelatorConfig,
+        EmitGluon,
+        SplitGluon,
+    )
+
+__version__ = package_version()
+
+__all__ = [
+    "ArtifactError",
+    "BenchmarkComponentTiming",
+    "BenchmarkConfig",
+    "BenchmarkProfileCounters",
+    "BenchmarkResult",
+    "BenchmarkRunner",
+    "BenchmarkStageTiming",
+    "BenchmarkStatistics",
+    "BenchmarkTimingBreakdown",
+    "ColorComponent",
+    "ColorConfig",
+    "ColorCorrelator",
+    "ColorFFTBasis",
+    "ColorFlow",
+    "CompatibilityError",
+    "CompiledModel",
+    "CompiledModelCapabilities",
+    "CompiledModelInfo",
+    "CompiledModelSource",
+    "ConfigurationError",
+    "ContractedColorComponent",
+    "CorrelatedRequest",
+    "CorrelatedValue",
+    "CorrelatorConfig",
+    "DependencyError",
+    "EmitGluon",
+    "EvaluationConfig",
+    "EvaluationError",
+    "ExternalParticle",
+    "GenerationConfig",
+    "GenerationError",
+    "GenerationPlan",
+    "GenerationResult",
+    "Generator",
+    "HelicityConfiguration",
+    "ModelCompilationIssue",
+    "ModelCompilationPhase",
+    "ModelError",
+    "ModelParameter",
+    "ModelSource",
+    "PhysicsReduction",
+    "ProcessAlias",
+    "ProcessPhysics",
+    "ProcessRequest",
+    "ProcessSet",
+    "PyAmpliColError",
+    "ReductionGroup",
+    "ResolvedEvaluation",
+    "RunConfig",
+    "Runtime",
+    "SplitGluon",
+    "WarmUpResult",
+    "__version__",
+    "benchmark",
+    "generate",
+    "group_processes",
+    "load",
+]
+
+_ERROR_EXPORTS = (
+    "ArtifactError",
+    "CompatibilityError",
+    "ConfigurationError",
+    "DependencyError",
+    "EvaluationError",
+    "GenerationError",
+    "ModelError",
+    "PyAmpliColError",
+)
+_REQUEST_EXPORTS = (
+    "ModelSource",
+    "ProcessAlias",
+    "ProcessRequest",
+    "ProcessSet",
+)
+_MODEL_EXPORTS = (
+    "CompiledModel",
+    "CompiledModelCapabilities",
+    "CompiledModelInfo",
+    "CompiledModelSource",
+    "ModelCompilationIssue",
+    "ModelCompilationPhase",
+)
+_RESULT_EXPORTS = (
+    "BenchmarkComponentTiming",
+    "BenchmarkProfileCounters",
+    "BenchmarkResult",
+    "BenchmarkStageTiming",
+    "BenchmarkStatistics",
+    "BenchmarkTimingBreakdown",
+    "ColorComponent",
+    "ColorFlow",
+    "ContractedColorComponent",
+    "ExternalParticle",
+    "GenerationPlan",
+    "GenerationResult",
+    "HelicityConfiguration",
+    "ModelParameter",
+    "PhysicsReduction",
+    "ProcessPhysics",
+    "ReductionGroup",
+    "ResolvedEvaluation",
+    "WarmUpResult",
+)
+_SERVICE_EXPORTS = (
+    "BenchmarkRunner",
+    "Generator",
+    "Runtime",
+    "benchmark",
+    "generate",
+    "load",
+)
+_CONFIG_EXPORTS = (
+    "BenchmarkConfig",
+    "ColorConfig",
+    "ColorFFTBasis",
+    "EvaluationConfig",
+    "GenerationConfig",
+    "RunConfig",
+)
+_PUBLIC_EXPORTS = {
+    **{
+        name: (".correlators", name)
+        for name in (
+            "ColorCorrelator",
+            "CorrelatedRequest",
+            "CorrelatedValue",
+            "CorrelatorConfig",
+            "EmitGluon",
+            "SplitGluon",
+        )
+    },
+    **{name: (".api.errors", name) for name in _ERROR_EXPORTS},
+    **{name: (".api.models", name) for name in _MODEL_EXPORTS},
+    **{name: (".api.requests", name) for name in _REQUEST_EXPORTS},
+    **{name: (".api.results", name) for name in _RESULT_EXPORTS},
+    **{name: (".api.services", name) for name in _SERVICE_EXPORTS},
+    **{name: (".config", name) for name in _CONFIG_EXPORTS},
+    "group_processes": (".api.process_groups", "group_processes"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    """Load a public object only when that object is requested."""
+
+    export = _PUBLIC_EXPORTS.get(name)
+    if export is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    module_name, attribute = export
+    value = getattr(import_module(module_name, __name__), attribute)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()).union(__all__))
diff --git a/pyamplicol/src/pyamplicol/__main__.py b/pyamplicol/src/pyamplicol/__main__.py
new file mode 100644
index 0000000000..db791b7c48
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/__main__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from .cli import main
+
+raise SystemExit(main())
diff --git a/pyamplicol/src/pyamplicol/_internal/physics/__init__.py b/pyamplicol/src/pyamplicol/_internal/physics/__init__.py
new file mode 100644
index 0000000000..c4c49a35c1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_internal/physics/__init__.py
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: 0BSD
+"""Neutral physics contracts shared across generation and evaluation."""
+
+from .types import (
+    ExternalMomentum,
+    FourMomentum,
+    HelicityContribution,
+    MatrixElementEvaluation,
+    NativeEvaluationError,
+)
+
+__all__ = [
+    "ExternalMomentum",
+    "FourMomentum",
+    "HelicityContribution",
+    "MatrixElementEvaluation",
+    "NativeEvaluationError",
+]
diff --git a/pyamplicol/src/pyamplicol/_internal/physics/parameters.py b/pyamplicol/src/pyamplicol/_internal/physics/parameters.py
new file mode 100644
index 0000000000..c617d70fa1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_internal/physics/parameters.py
@@ -0,0 +1,323 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import base64
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any
+
+from .symbols import symbols
+
+ParameterHead = tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class ParameterRange:
+    head: ParameterHead
+    start: int
+    stop: int
+    role: str = "scalar"
+    tensor_name: str | None = None
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "head": list(self.head),
+            "range": [self.start, self.stop],
+            "role": self.role,
+            "tensor_name": self.tensor_name,
+        }
+
+    @classmethod
+    def from_json_dict(cls, data: dict[str, object]) -> ParameterRange:
+        head = data.get("head")
+        span = data.get("range")
+        if not isinstance(head, list) or not all(
+            isinstance(item, str) for item in head
+        ):
+            raise ValueError("parameter range is missing a string head")
+        if not isinstance(span, list) or len(span) != 2:
+            raise ValueError("parameter range is missing a two-entry range")
+        role = data.get("role", "scalar")
+        tensor_name = data.get("tensor_name")
+        return cls(
+            head=tuple(head),
+            start=int(span[0]),
+            stop=int(span[1]),
+            role=role if isinstance(role, str) else "scalar",
+            tensor_name=tensor_name if isinstance(tensor_name, str) else None,
+        )
+
+
+class ParamBuilder:
+    """Ordered runtime input builder for pyamplicol Symbolica evaluators."""
+
+    def __init__(self) -> None:
+        self.positions: dict[ParameterHead, tuple[int, int]] = {}
+        self.order: list[ParameterHead] = []
+        self.ranges: dict[ParameterHead, ParameterRange] = {}
+        self.values: list[complex] = []
+        self._symbols: list[Any] = []
+        self.real_valued_inputs: list[int] = []
+        self.purely_imaginary_valued_inputs: list[int] = []
+        self.forced_complex_valued_inputs: list[int] = []
+
+    def add_parameter_list(
+        self,
+        head: ParameterHead,
+        length: int,
+        *,
+        role: str = "scalar",
+        tensor_name: str | None = None,
+        real_valued: bool = False,
+    ) -> tuple[Any, ...]:
+        if head in self.positions:
+            raise ValueError(f"parameter head already registered: {head}")
+        if length <= 0:
+            raise ValueError("parameter length must be positive")
+        start = len(self.values)
+        stop = start + length
+        self.positions[head] = (start, stop)
+        self.order.append(head)
+        self.ranges[head] = ParameterRange(
+            head=head,
+            start=start,
+            stop=stop,
+            role=role,
+            tensor_name=tensor_name,
+        )
+        self.values.extend(0j for _ in range(length))
+        if real_valued:
+            self.real_valued_inputs.extend(range(start, stop))
+        parameter_symbols = tuple(
+            symbols.parameter_component(head, index) for index in range(length)
+        )
+        self._symbols.extend(parameter_symbols)
+        return parameter_symbols
+
+    def register_rank1_tensor(
+        self,
+        library: Any,
+        *,
+        tensor_name: str,
+        representation: Any,
+        head: ParameterHead,
+        length: int,
+        role: str,
+        real_valued: bool = False,
+    ) -> tuple[Any, ...]:
+        from symbolica.community.tensor import Tensor, TensorName
+
+        parameter_symbols = self.add_parameter_list(
+            head,
+            length,
+            role=role,
+            tensor_name=tensor_name,
+            real_valued=real_valued,
+        )
+        library.register(
+            Tensor.dense(
+                TensorName(tensor_name)(representation),
+                parameter_symbols,
+            )
+        )
+        return parameter_symbols
+
+    def set_parameter_values(
+        self,
+        head: ParameterHead,
+        values: Sequence[complex | float],
+        *,
+        check_phase_flags: bool = True,
+    ) -> None:
+        if head not in self.positions:
+            raise ValueError(f"unknown parameter head: {head}")
+        start, stop = self.positions[head]
+        if stop - start != len(values):
+            raise ValueError(
+                f"parameter {head} expects {stop - start} values, got {len(values)}"
+            )
+        complex_values = [complex(value) for value in values]
+        if check_phase_flags:
+            self._check_values_against_phase_flags(start, complex_values)
+        self.values[start:stop] = complex_values
+
+    def parameter_symbols(self) -> list[Any]:
+        return list(self._symbols)
+
+    def get_values(self, *, complexified: bool = False) -> list[complex] | list[float]:
+        if not complexified:
+            return list(self.values)
+        flat: list[float] = []
+        for value in self.values:
+            flat.extend([float(value.real), float(value.imag)])
+        return flat
+
+    def get_complex_values(self) -> list[complex]:
+        return list(self.values)
+
+    def get_real_values(self) -> list[float]:
+        """Return evaluator inputs for Symbolica real-valued evaluators."""
+
+        real_values: list[float] = []
+        for index, value in enumerate(self.values):
+            if value.imag != 0.0:
+                raise ValueError(
+                    f"parameter index {index} has imaginary part {value.imag}; "
+                    "complex inputs must be represented with an explicit real/imag "
+                    "parameter packing"
+                )
+            real_values.append(float(value.real))
+        return real_values
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "parameters": [self.ranges[head].to_json_dict() for head in self.order],
+            "values": [[value.real, value.imag] for value in self.values],
+            "real_valued_inputs": list(self.real_valued_inputs),
+            "purely_imaginary_valued_inputs": list(self.purely_imaginary_valued_inputs),
+            "forced_complex_valued_inputs": list(self.forced_complex_valued_inputs),
+        }
+
+    @classmethod
+    def from_json_dict(cls, data: dict[str, object]) -> ParamBuilder:
+        builder = cls()
+        parameters = data.get("parameters")
+        values = data.get("values")
+        if not isinstance(parameters, list):
+            raise ValueError("param builder payload is missing parameters")
+        if not isinstance(values, list):
+            raise ValueError("param builder payload is missing values")
+        for item in parameters:
+            if not isinstance(item, dict):
+                raise ValueError("malformed parameter entry")
+            parameter_range = ParameterRange.from_json_dict(item)
+            length = parameter_range.stop - parameter_range.start
+            symbols_for_range = builder.add_parameter_list(
+                parameter_range.head,
+                length,
+                role=parameter_range.role,
+                tensor_name=parameter_range.tensor_name,
+            )
+            if len(symbols_for_range) != length:
+                raise ValueError("internal parameter reconstruction mismatch")
+        decoded_values = []
+        for item in values:
+            if not isinstance(item, list) or len(item) != 2:
+                raise ValueError("malformed parameter value entry")
+            decoded_values.append(complex(float(item[0]), float(item[1])))
+        if len(decoded_values) != len(builder.values):
+            raise ValueError("parameter value count does not match ranges")
+        builder.values = decoded_values
+        builder.real_valued_inputs = _int_list(data.get("real_valued_inputs", []))
+        builder.purely_imaginary_valued_inputs = _int_list(
+            data.get("purely_imaginary_valued_inputs", [])
+        )
+        builder.forced_complex_valued_inputs = _int_list(
+            data.get("forced_complex_valued_inputs", [])
+        )
+        return builder
+
+    def _check_values_against_phase_flags(
+        self,
+        start: int,
+        values: Sequence[complex],
+    ) -> None:
+        for offset, value in enumerate(values):
+            index = start + offset
+            if index in self.real_valued_inputs and value.imag != 0.0:
+                raise ValueError(f"parameter index {index} is marked real")
+            if index in self.purely_imaginary_valued_inputs and value.real != 0.0:
+                raise ValueError(f"parameter index {index} is marked imaginary")
+
+
+@dataclass
+class SymbolicaEvaluatorBundle:
+    name: str
+    evaluator: Any
+    param_builder: ParamBuilder
+    output_length: int = 1
+    complex_inputs: bool = False
+    metadata: dict[str, object] | None = None
+
+    def evaluate(self) -> tuple[complex, ...]:
+        if self.complex_inputs:
+            result = self.evaluator.evaluate_complex(
+                [self.param_builder.get_complex_values()]
+            )
+        else:
+            result = self.evaluator.evaluate([self.param_builder.get_real_values()])
+        row = result[0]
+        return tuple(complex(value) for value in row[: self.output_length])
+
+    def to_artifact_payload(self) -> dict[str, object]:
+        return {
+            "kind": "pyamplicol-symbolica-evaluator-bundle",
+            "name": self.name,
+            "output_length": self.output_length,
+            "complex_inputs": self.complex_inputs,
+            "param_builder": self.param_builder.to_json_dict(),
+            "evaluator_state_b64": base64.b64encode(self.evaluator.save()).decode(
+                "ascii"
+            ),
+            "metadata": self.metadata or {},
+        }
+
+    @classmethod
+    def from_artifact_payload(
+        cls,
+        payload: dict[str, object],
+    ) -> SymbolicaEvaluatorBundle:
+        from symbolica import Evaluator
+
+        encoded = payload.get("evaluator_state_b64")
+        param_builder_payload = payload.get("param_builder")
+        name = payload.get("name")
+        output_length = payload.get("output_length", 1)
+        complex_inputs = payload.get("complex_inputs", False)
+        metadata = payload.get("metadata")
+        if not isinstance(encoded, str):
+            raise ValueError("bundle payload is missing evaluator_state_b64")
+        if not isinstance(param_builder_payload, dict):
+            raise ValueError("bundle payload is missing param_builder")
+        if not isinstance(name, str):
+            raise ValueError("bundle payload is missing name")
+        param_builder = ParamBuilder.from_json_dict(param_builder_payload)
+        evaluator = Evaluator.load(base64.b64decode(encoded))
+        if param_builder.real_valued_inputs:
+            evaluator.set_real_params(param_builder.real_valued_inputs)
+        return cls(
+            name=name,
+            evaluator=evaluator,
+            param_builder=param_builder,
+            output_length=_int_value(output_length, "output_length"),
+            complex_inputs=_bool_value(complex_inputs, "complex_inputs"),
+            metadata=metadata if isinstance(metadata, dict) else {},
+        )
+
+
+def _int_list(value: object) -> list[int]:
+    if not isinstance(value, list):
+        return []
+    return [int(item) for item in value]
+
+
+def _int_value(value: object, name: str) -> int:
+    if isinstance(value, bool):
+        raise ValueError(f"{name} must be an integer")
+    if isinstance(value, int | str | bytes | bytearray):
+        return int(value)
+    raise ValueError(f"{name} must be an integer")
+
+
+def _bool_value(value: object, name: str) -> bool:
+    if isinstance(value, bool):
+        return value
+    raise ValueError(f"{name} must be a boolean")
+
+
+__all__ = [
+    "ParamBuilder",
+    "ParameterHead",
+    "ParameterRange",
+    "SymbolicaEvaluatorBundle",
+]
diff --git a/pyamplicol/src/pyamplicol/_internal/physics/symbols.py b/pyamplicol/src/pyamplicol/_internal/physics/symbols.py
new file mode 100644
index 0000000000..80e4069f36
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_internal/physics/symbols.py
@@ -0,0 +1,261 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from functools import cached_property
+from hashlib import sha256
+from threading import Lock
+from typing import Any
+
+_UFO_CANONICAL_NAMESPACE = "UFO::{}::"
+# Symbolica's process-wide symbol table cannot handle concurrent S(...) calls.
+_SYMBOL_CONSTRUCTION_LOCK = Lock()
+_SYMBOL_CACHE: dict[tuple[str, bool], Any] = {}
+
+
+def _construct_symbol(qualified_name: str, *, is_real: bool) -> Any:
+    from symbolica import S
+
+    return S(qualified_name, is_real=True) if is_real else S(qualified_name)
+
+
+def _symbol(qualified_name: str, *, is_real: bool = False) -> Any:
+    with _SYMBOL_CONSTRUCTION_LOCK:
+        key = (qualified_name, is_real)
+        cached = _SYMBOL_CACHE.get(key)
+        if cached is not None:
+            return cached
+        value = _construct_symbol(qualified_name, is_real=is_real)
+        _SYMBOL_CACHE[key] = value
+        return value
+
+
+def _safe_namespace_part(value: object) -> str:
+    text = str(value).strip()
+    if re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", text):
+        return text
+    readable = re.sub(r"[^A-Za-z0-9_]+", "_", text).strip("_") or "unnamed"
+    if readable[0].isdigit():
+        readable = f"n_{readable}"
+    digest = sha256(text.encode("utf-8")).hexdigest()[:12]
+    return f"{readable}_{digest}"
+
+
+def _safe_symbol_path(value: object) -> str:
+    return "::".join(
+        _safe_namespace_part(part) for part in str(value).split("::") if part
+    )
+
+
+@dataclass(frozen=True)
+class ModelSymbolRegistry:
+    """Symbolica names owned by one externally supplied model."""
+
+    model_name: str
+
+    @cached_property
+    def namespace(self) -> str:
+        return f"model_{_safe_namespace_part(self.model_name)}"
+
+    def qualified_name(self, name: str) -> str:
+        return f"{self.namespace}::{_safe_symbol_path(name)}"
+
+    def symbol(self, name: str) -> Any:
+        return _symbol(self.qualified_name(name))
+
+    def expression(self, source: str) -> Any:
+        """Parse a UFO expression after moving every UFO head into this model."""
+
+        from symbolica import E
+
+        namespaced = str(source).replace(
+            _UFO_CANONICAL_NAMESPACE,
+            f"{self.namespace}::",
+        )
+        namespaced = namespaced.replace("UFO::", f"{self.namespace}::")
+        return E(namespaced)
+
+    def expression_string(self, source: str) -> str:
+        return self.expression(source).to_canonical_string()
+
+    def kernel_tensor_name(self, kind: int, side: str) -> str:
+        return self.qualified_name(f"compiler::kernel_{int(kind)}_{side}")
+
+    def kernel_component(self, kind: int, side: str, index: int) -> Any:
+        return self.symbol(f"compiler::kernel_{int(kind)}_{side}_{int(index)}")
+
+    def kernel_momentum(self, kind: int, side: str, index: int) -> Any:
+        return self.symbol(
+            f"compiler::kernel_{int(kind)}_{side}_momentum_{int(index)}"
+        )
+
+    def contact_leg_tensor_name(self, kind: int, leg: int) -> str:
+        return self.qualified_name(
+            f"compiler::contact_{int(kind)}_leg_{int(leg)}"
+        )
+
+    def ufo_momentum_tensor_name(self, leg: int) -> str:
+        return self.qualified_name(f"compiler::ufo_momentum_{int(leg)}")
+
+
+@dataclass(frozen=True)
+class SymbolRegistry:
+    """Central registry for reusable Symbolica heads used by pyamplicol."""
+
+    namespace: str = "pyamplicol"
+
+    def qualified_name(self, name: str) -> str:
+        return f"{self.namespace}::{name}"
+
+    def display_name(self, name: str) -> str:
+        return self.qualified_name(name)
+
+    def symbol(self, name: str) -> Any:
+        return _symbol(self.qualified_name(name))
+
+    def real_symbol(self, name: str) -> Any:
+        return _symbol(self.qualified_name(name), is_real=True)
+
+    def parameter(self, name: str) -> Any:
+        return self.symbol(f"param::{name}")
+
+    def parameter_component(
+        self,
+        head: tuple[str, ...],
+        index: int,
+    ) -> Any:
+        safe_head = "::".join(_safe_symbol_path(part) for part in head)
+        return self.parameter(f"{safe_head}::c{int(index)}")
+
+    def model(self, model_name: str) -> ModelSymbolRegistry:
+        return ModelSymbolRegistry(str(model_name))
+
+    def model_owned_name(self, model_name: str, name: str) -> str:
+        model_tag = _safe_namespace_part(model_name)
+        return self.qualified_name(f"model::{model_tag}::{name}")
+
+    def model_owned(self, model_name: str, name: str) -> Any:
+        return self.symbol(f"model::{_safe_namespace_part(model_name)}::{name}")
+
+    def derived_coupling(self, model_name: str, term_id: int) -> Any:
+        return self.model_owned(model_name, f"derived_coupling_{int(term_id)}")
+
+    def runtime_model_parameter(self, model_name: str, name: str) -> Any:
+        """Return the canonical head for one external-model runtime input."""
+
+        match = re.fullmatch(r"derived_coupling_([0-9]+)", str(name))
+        if match is not None:
+            return self.derived_coupling(model_name, int(match.group(1)))
+        return self.model(model_name).symbol(str(name))
+
+    def kernel_component(self, kind: int, side: str, index: int) -> Any:
+        return self.symbol(f"kernel_{int(kind)}_{side}_{int(index)}")
+
+    def kernel_momentum(self, kind: int, side: str, index: int) -> Any:
+        return self.symbol(f"kernel_{int(kind)}_{side}_momentum_{int(index)}")
+
+    def kernel_tensor_name(self, kind: int, side: str) -> str:
+        return self.qualified_name(f"kernel_{int(kind)}_{side}")
+
+    def kernel_function_argument(
+        self,
+        model_name: str,
+        key: str,
+        role: str,
+        index: int,
+    ) -> Any:
+        return self.model_owned(
+            model_name,
+            f"kernel_function::{key}::{role}::c{int(index)}",
+        )
+
+    def kernel_function_component(
+        self,
+        model_name: str,
+        key: str,
+        index: int,
+    ) -> Any:
+        return self.model_owned(
+            model_name,
+            f"kernel_function::{key}::component::c{int(index)}",
+        )
+
+    def weyl_probe(
+        self,
+        model_name: str,
+        kind: int,
+        side: str,
+        role: str,
+        index: int,
+    ) -> Any:
+        return self.model_owned(
+            model_name,
+            f"weyl_probe::kind_{int(kind)}::{side}::{role}::c{int(index)}",
+        )
+
+    def runtime_domain(
+        self,
+        model_name: str,
+        parameter_name: str,
+        domain: str,
+    ) -> Any:
+        name = f"runtime_domain::{domain}::{_safe_symbol_path(parameter_name)}"
+        if domain == "complex":
+            return self.model_owned(model_name, name)
+        real_symbol = self.real_symbol(
+            f"model::{_safe_namespace_part(model_name)}::{name}"
+        )
+        return 1j * real_symbol if domain == "imaginary" else real_symbol
+
+    def custom_propagator_component(
+        self,
+        model_name: str,
+        role: str,
+        index: int,
+    ) -> Any:
+        return self.model_owned(
+            model_name,
+            f"custom_propagator::{role}::c{int(index)}",
+        )
+
+    def custom_propagator_tensor_name(self, model_name: str) -> str:
+        return self.model_owned_name(model_name, "custom_propagator::input")
+
+    def ufo_momentum_tensor_name(self, leg: int) -> str:
+        return self.qualified_name(f"ufo_momentum_{int(leg)}")
+
+    def contact_leg_tensor_name(self, kind: int, leg: int) -> str:
+        return self.qualified_name(f"contact_{int(kind)}_leg_{int(leg)}")
+
+    def canonical_tensor_index(
+        self,
+        family: str,
+        representation: str,
+        index: int,
+    ) -> Any:
+        """Return a reserved dummy-index candidate for tensor canonization."""
+
+        return self.symbol(
+            "canonical_tensor_index::"
+            f"{_safe_symbol_path(family)}::"
+            f"{_safe_symbol_path(representation)}::i{int(index)}"
+        )
+
+    @cached_property
+    def color_projection_probe_name(self) -> str:
+        return self.qualified_name("color_projection_probe")
+
+    def inline_function_wildcard(
+        self,
+        definition_index: int,
+        argument_index: int,
+    ) -> Any:
+        return self.symbol(
+            f"inline_function_{int(definition_index)}_argument_{int(argument_index)}_"
+        )
+
+symbols = SymbolRegistry()
+
+
+__all__ = ["ModelSymbolRegistry", "SymbolRegistry", "symbols"]
diff --git a/pyamplicol/src/pyamplicol/_internal/physics/types.py b/pyamplicol/src/pyamplicol/_internal/physics/types.py
new file mode 100644
index 0000000000..43dc97d642
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_internal/physics/types.py
@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+FourMomentum = tuple[float, float, float, float]
+WaveFunction = tuple[complex, complex, complex, complex]
+WeylWaveFunction = tuple[complex, complex]
+TensorWaveFunction = tuple[complex, complex, complex, complex, complex, complex]
+
+
+@dataclass(frozen=True)
+class ExternalMomentum:
+    pdg: int
+    momentum: FourMomentum
+
+
+@dataclass(frozen=True)
+class HelicityContribution:
+    helicities: tuple[int, ...]
+    amplitude: complex
+    squared: float
+
+
+@dataclass(frozen=True)
+class MatrixElementEvaluation:
+    process: str
+    particles: tuple[ExternalMomentum, ...]
+    matrix_element: float
+    raw_helicity_sum: float
+    color_factor: int
+    average_factor: int
+    coupling_factor: float
+    helicity_contributions: tuple[HelicityContribution, ...]
+    identical_factor: int = 1
+
+
+class NativeEvaluationError(ValueError):
+    pass
+
+
+__all__ = [
+    "ExternalMomentum",
+    "FourMomentum",
+    "HelicityContribution",
+    "MatrixElementEvaluation",
+    "NativeEvaluationError",
+    "TensorWaveFunction",
+    "WaveFunction",
+    "WeylWaveFunction",
+]
diff --git a/pyamplicol/src/pyamplicol/_internal/sm_heft.py b/pyamplicol/src/pyamplicol/_internal/sm_heft.py
new file mode 100644
index 0000000000..47fb203707
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_internal/sm_heft.py
@@ -0,0 +1,373 @@
+# SPDX-License-Identifier: 0BSD
+"""Packaged scalar-HEFT extension of the Standard Model source.
+
+The extension is deliberately stored as a small set of canonical model records
+on top of the already packaged SM JSON model.  It adds the scalar Hgg, Hggg,
+and Hgggg interactions from the FeynRules Higgs Effective Theory model without
+duplicating the Standard Model payload or retaining a runtime dependency on an
+external UFO checkout.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import contextmanager
+from copy import deepcopy
+from dataclasses import replace
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyamplicol.models.loading import CompiledModel
+
+CANONICAL_SM_HEFT_SOURCE = "built-in-sm-heft"
+SM_HEFT_ALIASES = frozenset(
+    {
+        CANONICAL_SM_HEFT_SOURCE,
+        "builtin_sm_heft",
+        "sm-heft",
+        "sm_heft",
+    }
+)
+
+_HEFT_ORDER = {
+    "name": "HIG",
+    "expansion_order": 1,
+    "hierarchy": 1,
+}
+
+_HEFT_PARAMETER = {
+    "name": "GH",
+    "nature": "internal",
+    "parameter_type": "real",
+    "value": None,
+    "expression": (
+        "(1+1/168*UFO::{}::MH^4*UFO::{}::MT^(-4)"
+        "+13/16800*UFO::{}::MH^6*UFO::{}::MT^(-6)"
+        "+7/120*UFO::{}::MH^2*UFO::{}::MT^(-2))"
+        "*-1/12*UFO::{}::G^2*UFO::{}::vev^(-1)*𝜋^(-2)"
+    ),
+    "lhablock": None,
+    "lhacode": None,
+}
+
+_HEFT_COUPLINGS = (
+    {
+        "name": "GC_HEFT_HGG",
+        "expression": "-1𝑖*UFO::{}::GH",  # noqa: RUF001
+        "orders": [["HIG", 1]],
+        "value": None,
+    },
+    {
+        "name": "GC_HEFT_HGGG",
+        "expression": "-1*UFO::{}::G*UFO::{}::GH",
+        "orders": [["HIG", 1], ["QCD", 1]],
+        "value": None,
+    },
+    {
+        "name": "GC_HEFT_HGGGG",
+        "expression": "1𝑖*UFO::{}::GH*UFO::{}::G^2",  # noqa: RUF001
+        "orders": [["HIG", 1], ["QCD", 2]],
+        "value": None,
+    },
+)
+
+_HEFT_LORENTZ_STRUCTURES = (
+    {
+        "name": "HEFT_VVS",
+        "spins": [3, 3, 1],
+        "structure": (
+            "-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+            "*UFO::{}::P(UFO::{}::dummy(1),UFO::{}::idx(1,1))"
+            "*UFO::{}::P(UFO::{}::dummy(1),UFO::{}::idx(1,2))"
+            "+UFO::{}::P(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+            "*UFO::{}::P(UFO::{}::idx(1,2),UFO::{}::idx(1,1))"
+        ),
+    },
+    {
+        "name": "HEFT_VVVS",
+        "spins": [3, 3, 3, 1],
+        "structure": (
+            "-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+            "*UFO::{}::P(UFO::{}::idx(1,3),UFO::{}::idx(1,2))"
+            "+-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,3))"
+            "*UFO::{}::P(UFO::{}::idx(1,2),UFO::{}::idx(1,1))"
+            "+-1*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,3))"
+            "*UFO::{}::P(UFO::{}::idx(1,1),UFO::{}::idx(1,3))"
+            "+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+            "*UFO::{}::P(UFO::{}::idx(1,3),UFO::{}::idx(1,1))"
+            "+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,3))"
+            "*UFO::{}::P(UFO::{}::idx(1,2),UFO::{}::idx(1,3))"
+            "+UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,3))"
+            "*UFO::{}::P(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+        ),
+    },
+    {
+        "name": "HEFT_VVVVS1",
+        "spins": [3, 3, 3, 3, 1],
+        "structure": (
+            "-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,3))"
+            "*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,4))"
+            "+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,4))"
+            "*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,3))"
+        ),
+    },
+    {
+        "name": "HEFT_VVVVS2",
+        "spins": [3, 3, 3, 3, 1],
+        "structure": (
+            "-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+            "*UFO::{}::Metric(UFO::{}::idx(1,3),UFO::{}::idx(1,4))"
+            "+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,4))"
+            "*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,3))"
+        ),
+    },
+    {
+        "name": "HEFT_VVVVS3",
+        "spins": [3, 3, 3, 3, 1],
+        "structure": (
+            "-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+            "*UFO::{}::Metric(UFO::{}::idx(1,3),UFO::{}::idx(1,4))"
+            "+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,3))"
+            "*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,4))"
+        ),
+    },
+)
+
+_HEFT_VERTICES = (
+    {
+        "name": "V_HEFT_HGG",
+        "particles": ["g", "g", "H"],
+        "color_structures": ["UFO::{}::Identity(1,2)"],
+        "lorentz_structures": ["HEFT_VVS"],
+        "couplings": [["GC_HEFT_HGG"]],
+    },
+    {
+        "name": "V_HEFT_HGGG",
+        "particles": ["g", "g", "g", "H"],
+        "color_structures": ["UFO::{}::f(1,2,3)"],
+        "lorentz_structures": ["HEFT_VVVS"],
+        "couplings": [["GC_HEFT_HGGG"]],
+    },
+    {
+        "name": "V_HEFT_HGGGG",
+        "particles": ["g", "g", "g", "g", "H"],
+        "color_structures": [
+            "UFO::{}::f(-1,1,2)*UFO::{}::f(3,4,-1)",
+            "UFO::{}::f(-1,1,3)*UFO::{}::f(2,4,-1)",
+            "UFO::{}::f(-1,1,4)*UFO::{}::f(2,3,-1)",
+        ],
+        "lorentz_structures": [
+            "HEFT_VVVVS1",
+            "HEFT_VVVVS2",
+            "HEFT_VVVVS3",
+        ],
+        "couplings": [
+            ["GC_HEFT_HGGGG", None, None],
+            [None, "GC_HEFT_HGGGG", None],
+            [None, None, "GC_HEFT_HGGGG"],
+        ],
+    },
+)
+
+
+def is_sm_heft_alias(value: object) -> bool:
+    return str(value).lower() in SM_HEFT_ALIASES
+
+
+def packaged_sm_source_path() -> Path:
+    """Return the installed package's canonical SM JSON source."""
+
+    path = (
+        Path(__file__).resolve().parents[1]
+        / "assets"
+        / "models"
+        / "json"
+        / "sm"
+        / "sm.json"
+    )
+    if not path.is_file():
+        raise RuntimeError(f"packaged Standard Model source is missing: {path}")
+    return path
+
+
+def extend_sm_model_payload(model: Mapping[str, object]) -> dict[str, object]:
+    """Return an independent SM payload with the scalar HEFT records appended."""
+
+    payload = deepcopy(dict(model))
+    _require_base_particles(payload)
+    additions: tuple[tuple[str, Sequence[Mapping[str, object]]], ...] = (
+        ("orders", (_HEFT_ORDER,)),
+        ("parameters", (_HEFT_PARAMETER,)),
+        ("couplings", _HEFT_COUPLINGS),
+        ("lorentz_structures", _HEFT_LORENTZ_STRUCTURES),
+        ("vertex_rules", _HEFT_VERTICES),
+    )
+    for field, records in additions:
+        raw_values = payload.get(field)
+        if not isinstance(raw_values, list) or not all(
+            isinstance(record, dict) for record in raw_values
+        ):
+            raise ValueError(f"packaged Standard Model {field} records are invalid")
+        existing_names = {str(record.get("name")) for record in raw_values}
+        added_names = {str(record["name"]) for record in records}
+        conflicts = sorted(existing_names.intersection(added_names))
+        if conflicts:
+            raise ValueError(
+                f"packaged Standard Model already defines HEFT {field}: {conflicts!r}"
+            )
+        raw_values.extend(deepcopy(list(records)))
+    payload["name"] = CANONICAL_SM_HEFT_SOURCE
+    return payload
+
+
+def source_digest() -> str:
+    """Identify only the packaged SM inputs and canonical HEFT physics records."""
+
+    digest = hashlib.sha256()
+    base = packaged_sm_source_path()
+    restriction = base.with_name("restrict_default.json")
+    for path in (base, restriction):
+        if not path.is_file():
+            raise RuntimeError(f"packaged Standard Model input is missing: {path}")
+        digest.update(path.name.encode("utf-8") + b"\0")
+        digest.update(path.read_bytes())
+        digest.update(b"\0")
+    digest.update(
+        json.dumps(
+            {
+                "order": _HEFT_ORDER,
+                "parameter": _HEFT_PARAMETER,
+                "couplings": _HEFT_COUPLINGS,
+                "lorentz_structures": _HEFT_LORENTZ_STRUCTURES,
+                "vertices": _HEFT_VERTICES,
+            },
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    )
+    return digest.hexdigest()
+
+
+@contextmanager
+def _materialized_source() -> Iterator[tuple[Path, Path]]:
+    """Materialize the canonical overlay for the existing JSON compiler."""
+
+    base = packaged_sm_source_path()
+    packaged_restriction = base.with_name("restrict_default.json")
+    with TemporaryDirectory(prefix="pyamplicol-sm-heft-") as temporary:
+        source = Path(temporary) / "sm-heft.json"
+        restriction = source.with_name("restrict_default.json")
+        source.write_text(
+            json.dumps(
+                extend_sm_model_payload(json.loads(base.read_text(encoding="utf-8"))),
+                ensure_ascii=False,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        restriction.write_bytes(packaged_restriction.read_bytes())
+        yield source, restriction
+
+
+def _with_packaged_identity(compiled: CompiledModel) -> CompiledModel:
+    return replace(
+        compiled,
+        source={
+            "kind": "built-in-sm-heft",
+            "source_name": None,
+            "digest": source_digest(),
+            "options": {
+                "restriction": {"kind": "name", "value": "default"},
+                "simplify": True,
+            },
+        },
+        _serialized_path=None,
+    )
+
+
+def compile_sm_heft_source(
+    *,
+    cache_dir: Path | None = None,
+    use_cache: bool = True,
+    require_supported: bool = True,
+) -> CompiledModel:
+    """Compile the packaged overlay through the canonical JSON model path."""
+
+    from pyamplicol.models.loading import compile_model_source
+
+    with _materialized_source() as (source, restriction):
+        compiled = compile_model_source(
+            source,
+            restriction=str(restriction),
+            simplify=True,
+            cache_dir=cache_dir,
+            use_cache=use_cache,
+            require_supported=require_supported,
+        )
+    return _with_packaged_identity(compiled)
+
+
+def load_cached_sm_heft_source(
+    *,
+    cache_dir: Path | None = None,
+    require_supported: bool = True,
+) -> CompiledModel | None:
+    """Load the packaged overlay only when its canonical cache already exists."""
+
+    from pyamplicol.models.loading import load_cached_model_source
+
+    with _materialized_source() as (source, restriction):
+        compiled = load_cached_model_source(
+            source,
+            restriction=str(restriction),
+            simplify=True,
+            cache_dir=cache_dir,
+            require_supported=require_supported,
+        )
+    return None if compiled is None else _with_packaged_identity(compiled)
+
+
+def _require_base_particles(payload: Mapping[str, object]) -> None:
+    raw_particles = payload.get("particles")
+    if not isinstance(raw_particles, list):
+        raise ValueError("packaged Standard Model particle records are invalid")
+    particles = {
+        str(record.get("name")): record
+        for record in raw_particles
+        if isinstance(record, dict)
+    }
+    expected = {"g": (21, 3, 8), "H": (25, 1, 1)}
+    for name, identity in expected.items():
+        record = particles.get(name)
+        observed = (
+            None
+            if record is None
+            else (
+                record.get("pdg_code"),
+                record.get("spin"),
+                record.get("color"),
+            )
+        )
+        if observed != identity:
+            raise ValueError(
+                f"packaged Standard Model particle {name!r} changed: {observed!r}"
+            )
+
+
+__all__ = [
+    "CANONICAL_SM_HEFT_SOURCE",
+    "SM_HEFT_ALIASES",
+    "compile_sm_heft_source",
+    "extend_sm_model_payload",
+    "is_sm_heft_alias",
+    "load_cached_sm_heft_source",
+    "packaged_sm_source_path",
+    "source_digest",
+]
diff --git a/pyamplicol/src/pyamplicol/_internal/versions.py b/pyamplicol/src/pyamplicol/_internal/versions.py
new file mode 100644
index 0000000000..78fa1ce649
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_internal/versions.py
@@ -0,0 +1,1088 @@
+# SPDX-License-Identifier: 0BSD
+"""Independent public, serialization, and evaluator runtime contracts."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import json
+import re
+import tomllib
+from collections.abc import Mapping
+from importlib import metadata
+from pathlib import Path
+from typing import Any
+
+PYTHON_API_VERSION = 1
+TOML_SCHEMA_VERSION = 1
+COMPILED_MODEL_SCHEMA_VERSION = 9
+PROCESS_ARTIFACT_SCHEMA_VERSION = 3
+RUNTIME_PHYSICS_SCHEMA_VERSION = 1
+C_ABI_VERSION = 1
+
+# These are project-owned wire-format identifiers. Dependency source revisions
+# live in the release and contributor locks, outside serialized artifacts.
+SYMBOLICA_SERIALIZATION_ABI = "symbolica-bincode2-v1"
+SYMJIT_APPLICATION_ABI = "symjit-application-storage-v3"
+SYMJIT_PLANE_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+NATIVE_COMPILED_DIRECT_APPLICATION_ABI = (
+    "pyamplicol-native-compiled-direct-application-v1"
+)
+NATIVE_EAGER_DIRECT_TABLE_APPLICATION_ABI = "pyamplicol-eager-native-direct-table-v1"
+COMPILED_PLANE_DIRECT_APPLICATION_ABI = "pyamplicol-compiled-plane-kernel-v2"
+EAGER_DIRECT_TABLE_DESCRIPTOR_ABI = "pyamplicol-eager-plane-table-descriptor-v1"
+EAGER_DIRECT_TABLE_BINDING_ABI = "pyamplicol-eager-plane-table-binding-v2"
+RECURRENCE_DIRECT_BINDING_ABI = "pyamplicol-recurrence-plane-binding-v2"
+
+SYMJIT_F64_RUNTIME_CAPABILITY = "symjit.application.complex-f64.v1"
+SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY = (
+    "symbolica.legacy-jit-container.complex-f64.v1"
+)
+SYMBOLICA_CPP_RUNTIME_CAPABILITY = "symbolica.compiled-cpp.complex-f64.v1"
+SYMBOLICA_ASM_RUNTIME_CAPABILITY = "symbolica.compiled-asm.complex-f64.v1"
+EAGER_DAG_F64_RUNTIME_CAPABILITY = "rusticol.eager-dag.complex-f64.v1"
+EAGER_RUNTIME_LAYOUT_F64_CAPABILITY = "rusticol.eager-runtime-layout.complex-f64.v1"
+EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY = "eager-direct-arena-v1"
+EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY = "rusticol.eager-dag.lc-topology-replay.v1"
+RECURRENCE_BUILDER_INPUT_ABI = "pyamplicol-recurrence-builder-input-v2"
+RECURRENCE_PLAN_ABI = "pyamplicol-recurrence-plan-v2"
+RECURRENCE_RUNTIME_LAYOUT_ABI = "pyamplicol-recurrence-runtime-layout-v2"
+RECURRENCE_DIRECT_TEMPLATE_ABI = "pyamplicol-recurrence-direct-template-v1"
+RECURRENCE_DIRECT_BACKEND_ABI = "rusticol.recurrence-direct-backend.v1"
+RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY = (
+    "rusticol.recurrence-direct-arena.complex-f64.v1"
+)
+RECURRENCE_COLOR_RUNTIME_CAPABILITY = "rusticol.recurrence-color.lc.v1"
+RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY = (
+    "rusticol.recurrence-color.contracted.v1"
+)
+RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY = (
+    "rusticol.recurrence-helicity-selector-companion.v2"
+)
+ON_THE_FLY_RUNTIME_CAPABILITY = "rusticol.on-the-fly.complex-f64.v1"
+ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY = "rusticol.on-the-fly.lc-color.v1"
+ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY = (
+    "rusticol.on-the-fly.contracted-color.v1"
+)
+SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY = (
+    "rusticol.color-contraction.symmetric-group-fft.v1"
+)
+COMPILED_RUNTIME_SELECTORS_CAPABILITY = "rusticol.compiled.runtime-selectors.v1"
+COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY = "compiled-plane-arena-v1"
+COMPILED_HELICITY_DUAL_LANE_CAPABILITY = "rusticol.compiled.helicity-dual-lane.v1"
+COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY = (
+    "rusticol.compiled.helicity-selector-union.v1"
+)
+COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY = (
+    "rusticol.compiled.helicity-primary-recurrence.v1"
+)
+COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY = "rusticol.compiled.color-topology-lanes.v1"
+COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY = (
+    "rusticol.compiled.color-contraction-walsh.v1"
+)
+COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY = (
+    "rusticol.compiled.color-contraction-walsh-c2k.v1"
+)
+EVALUATOR_RUNTIME_CAPABILITIES = frozenset(
+    {
+        COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY,
+        COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY,
+        COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY,
+        COMPILED_HELICITY_DUAL_LANE_CAPABILITY,
+        COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY,
+        COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY,
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+        COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+        EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        EAGER_RUNTIME_LAYOUT_F64_CAPABILITY,
+        RECURRENCE_COLOR_RUNTIME_CAPABILITY,
+        RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+        RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+        RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+        ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+        SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+        ON_THE_FLY_RUNTIME_CAPABILITY,
+        SYMJIT_F64_RUNTIME_CAPABILITY,
+        SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+        SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+        SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    }
+)
+KNOWN_EVALUATOR_RUNTIME_CAPABILITIES = EVALUATOR_RUNTIME_CAPABILITIES | frozenset(
+    {
+        # Historical eager plan-v2 artifacts remain parseable for inspection
+        # and actionable migration errors, but are not executable capabilities.
+        EAGER_DAG_F64_RUNTIME_CAPABILITY,
+        EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY,
+    }
+)
+
+_SOURCE_PACKAGE_ROOT = Path(__file__).resolve().parents[1]
+_SOURCE_ROOT = Path(__file__).resolve().parents[3]
+_PACKAGE_BUILD_INFO_PATH = _SOURCE_PACKAGE_ROOT / "_build_info.json"
+_SOURCE_RUNTIME_ROOT = _SOURCE_ROOT / ".artifacts" / "source-runtime"
+_SOURCE_BUILD_INFO_PATH = _SOURCE_RUNTIME_ROOT / "_build_info.json"
+_SOURCE_RUNTIME_STAGING_PATH = _SOURCE_RUNTIME_ROOT / ".staging"
+
+_NATIVE_BUILD_IDENTITY_DOMAIN = b"pyamplicol-native-build-inputs-v2\0"
+_NATIVE_BUILD_INPUT_FILES = (
+    Path("Cargo.lock"),
+    Path("Cargo.toml"),
+    Path("pyproject.toml"),
+    Path("rust-toolchain.toml"),
+    Path("dependencies/candidate-Cargo.lock"),
+    Path("dependencies/candidate-cargo-config.toml"),
+    Path("dependencies/install-state.json"),
+)
+_NATIVE_BUILD_INPUT_TREES = (Path("rust"),)
+# Keep this projection identical to build_backend/native_build_identity.py
+# without importing build-only modules. Release sdists omit candidate inputs.
+_RELEASE_OMITTED_NATIVE_BUILD_INPUTS = frozenset(
+    {
+        Path("dependencies/candidate-Cargo.lock"),
+        Path("dependencies/candidate-cargo-config.toml"),
+        Path("dependencies/install-state.json"),
+    }
+)
+_NATIVE_MATURIN_CONFIG_KEYS = frozenset(
+    {
+        "all-features",
+        "bindings",
+        "config",
+        "features",
+        "include-debuginfo",
+        "manifest-path",
+        "module-name",
+        "no-default-features",
+        "profile",
+        "rustc-args",
+        "strip",
+        "target",
+        "targets",
+        "unstable-flags",
+        "zig",
+    }
+)
+_NON_OUTPUT_MATURIN_CONFIG_KEYS = frozenset(
+    {
+        "editable-profile",
+        "frozen",
+        "locked",
+        "pgo-command",
+        "target-dir",
+        "use-base-python",
+    }
+)
+_PACKAGING_MATURIN_CONFIG_KEYS = frozenset(
+    {
+        "auditwheel",
+        "compatibility",
+        "data",
+        "exclude",
+        "generate-ci",
+        "generate-stubs",
+        "include",
+        "include-import-lib",
+        "manylinux",
+        "python-packages",
+        "python-source",
+        "sbom",
+        "sdist-generator",
+        "skip-auditwheel",
+        "compression-enable-large-file-support",
+        "compression-level",
+        "compression-method",
+        "sbom-include",
+    }
+)
+_NATIVE_BUILD_IGNORED_TREE_PARTS = frozenset({".artifacts", "__pycache__", "target"})
+_NON_NATIVE_RUST_PATHS = frozenset(
+    {
+        Path("rust/crates/rusticol-capi/tests/eager_artifact.rs"),
+        Path("rust/crates/rusticol-capi/tests/runtime_selectors.rs"),
+        Path("rust/crates/rusticol-core/src/artifact_tests.rs"),
+        Path("rust/crates/rusticol-core/src/eager_layout_tests.rs"),
+        Path("rust/crates/rusticol-core/src/eager_lowering_v3_tests.rs"),
+        Path("rust/crates/rusticol-core/src/eager_plan_v3_pacbin_tests.rs"),
+        Path("rust/crates/rusticol-core/src/eager_runtime/plan_v3_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/contraction_metadata_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/eager_integration_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/eager_v3_manifest_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/quantum_number_flow_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/recurrence_integration_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine/source_metadata_tests.rs"),
+        Path("rust/crates/rusticol-core/src/engine_tests.rs"),
+        Path("rust/crates/rusticol-core/src/metadata_tests.rs"),
+        Path("rust/crates/rusticol-core/src/pacbin_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_backend_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_codec_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_lowering_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_pacbin_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_plan_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/direct_runtime_tests.rs"),
+        Path("rust/crates/rusticol-core/src/recurrence/tests.rs"),
+        Path("rust/crates/rusticol-core/tests/direct_arena_workspace_allocations.rs"),
+        Path("rust/crates/rusticol-core/tests/eager_runtime.rs"),
+        Path(
+            "rust/crates/rusticol-core/tests/fixtures/on_the_fly_query_parity_v1.json"
+        ),
+        Path(
+            "rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_full_v2.json"
+        ),
+        Path(
+            "rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_lc.json"
+        ),
+        Path(
+            "rust/crates/rusticol-core/tests/fixtures/recurrence_execution_hzz_nlc.json"
+        ),
+        Path("rust/crates/rusticol-core/tests/generated_artifact_odd_tails.rs"),
+        Path("rust/crates/rusticol-core/tests/recurrence_direct_arena_allocations.rs"),
+        Path("rust/crates/rusticol-python/stubs/pyamplicol/__init__.pyi"),
+        Path("rust/crates/rusticol-python/stubs/pyamplicol/_rusticol.pyi"),
+        Path("rust/crates/rusticol-python/tests/pyrightconfig.json"),
+        Path("rust/crates/rusticol-python/tests/stub_contract.rs"),
+        Path("rust/crates/rusticol-python/tests/typing_consumer.py"),
+    }
+)
+_NATIVE_BUILD_CONTRACT_KEYS = frozenset(
+    {"macos", "rust-path-remapping", "schema-version", "sdk"}
+)
+_RUST_PATH_REMAP_KEYS = frozenset(
+    {"build", "candidate-checkouts", "checkout", "source", "sysroot"}
+)
+_MACOS_NATIVE_BUILD_KEYS = frozenset({"cc", "cxx", "deployment-target"})
+_SDK_NATIVE_BUILD_KEYS = frozenset({"package", "profile", "rustc-codegen-arguments"})
+_CANDIDATE_CARGO_CONFIG = Path("dependencies/candidate-cargo-config.toml")
+_CANDIDATE_INSTALL_STATE = Path("dependencies/install-state.json")
+_CANDIDATE_PATCH_TARGETS = {
+    "graphica": "dependencies/checkouts/symbolica/lib/graphica",
+    "numerica": "dependencies/checkouts/symbolica/lib/numerica",
+    "symbolica": "dependencies/checkouts/symbolica",
+    "symjit": "dependencies/checkouts/symjit",
+}
+_NATIVE_CANDIDATE_SOURCE_NAMES = frozenset({"symbolica", "symjit"})
+_NATIVE_EXTENSION_SUFFIXES = (".dylib", ".pyd", ".so")
+
+
+def _canonical_json_bytes(payload: Any) -> bytes:
+    try:
+        return (
+            json.dumps(
+                payload,
+                sort_keys=True,
+                separators=(",", ":"),
+                allow_nan=False,
+            )
+            + "\n"
+        ).encode("utf-8")
+    except (TypeError, ValueError) as error:
+        raise RuntimeError(
+            f"candidate native build identity is not canonical JSON: {error}"
+        ) from error
+
+
+def _native_build_contract(payload: Mapping[str, Any]) -> dict[str, Any]:
+    tool = payload.get("tool")
+    pyamplicol = tool.get("pyamplicol") if isinstance(tool, Mapping) else None
+    contract = (
+        pyamplicol.get("native-build") if isinstance(pyamplicol, Mapping) else None
+    )
+    if not isinstance(contract, Mapping) or set(contract) != set(
+        _NATIVE_BUILD_CONTRACT_KEYS
+    ):
+        raise RuntimeError(
+            "native pyproject contract must contain exactly schema-version, "
+            "rust-path-remapping, macos, and sdk"
+        )
+    schema_version = contract.get("schema-version")
+    if (
+        not isinstance(schema_version, int)
+        or isinstance(schema_version, bool)
+        or schema_version != 1
+    ):
+        raise RuntimeError("native pyproject contract must use schema-version 1")
+    remapping = contract.get("rust-path-remapping")
+    if not isinstance(remapping, Mapping) or set(remapping) != set(
+        _RUST_PATH_REMAP_KEYS
+    ):
+        raise RuntimeError("native Rust path-remapping contract is incomplete")
+    canonical_remapping: dict[str, str] = {}
+    for key in sorted(_RUST_PATH_REMAP_KEYS):
+        value = remapping[key]
+        if not isinstance(value, str) or not value.startswith("/"):
+            raise RuntimeError(
+                f"native Rust path-remapping destination {key} must be absolute"
+            )
+        canonical_remapping[key] = value
+    if len(set(canonical_remapping.values())) != len(canonical_remapping):
+        raise RuntimeError("native Rust path-remapping destinations must be unique")
+    macos = contract.get("macos")
+    if not isinstance(macos, Mapping) or set(macos) != set(_MACOS_NATIVE_BUILD_KEYS):
+        raise RuntimeError("native macOS build contract is incomplete")
+    canonical_macos: dict[str, str] = {}
+    for key in sorted(_MACOS_NATIVE_BUILD_KEYS):
+        value = macos[key]
+        if not isinstance(value, str) or not value:
+            raise RuntimeError(f"native macOS build setting {key} is invalid")
+        canonical_macos[key] = value
+    if not canonical_macos["cc"].startswith("/") or not canonical_macos[
+        "cxx"
+    ].startswith("/"):
+        raise RuntimeError("native macOS compilers must be absolute paths")
+    sdk = contract.get("sdk")
+    if not isinstance(sdk, Mapping) or set(sdk) != set(_SDK_NATIVE_BUILD_KEYS):
+        raise RuntimeError("native SDK build contract is incomplete")
+    package = sdk.get("package")
+    profile = sdk.get("profile")
+    codegen = sdk.get("rustc-codegen-arguments")
+    if not isinstance(package, str) or not package:
+        raise RuntimeError("native SDK package must be a non-empty string")
+    if not isinstance(profile, str) or not profile:
+        raise RuntimeError("native SDK profile must be a non-empty string")
+    if (
+        not isinstance(codegen, list)
+        or not codegen
+        or any(not isinstance(value, str) or not value for value in codegen)
+    ):
+        raise RuntimeError("native SDK rustc codegen arguments must be strings")
+    return {
+        "macos": canonical_macos,
+        "rust-path-remapping": canonical_remapping,
+        "schema-version": 1,
+        "sdk": {
+            "package": package,
+            "profile": profile,
+            "rustc-codegen-arguments": list(codegen),
+        },
+    }
+
+
+def _native_pyproject_bytes(data: bytes) -> bytes:
+    try:
+        payload = tomllib.loads(data.decode("utf-8"))
+    except (UnicodeDecodeError, tomllib.TOMLDecodeError) as error:
+        raise RuntimeError(
+            f"invalid native pyproject configuration: {error}"
+        ) from error
+    build_system = payload.get("build-system")
+    requirements = (
+        build_system.get("requires") if isinstance(build_system, Mapping) else None
+    )
+    if not isinstance(requirements, list) or any(
+        not isinstance(requirement, str) for requirement in requirements
+    ):
+        raise RuntimeError("native pyproject build-system requires must be a list")
+    maturin_pins: list[str] = []
+    for requirement in requirements:
+        match = re.fullmatch(
+            r"\s*maturin\s*==\s*([0-9][A-Za-z0-9._+-]*)\s*",
+            requirement,
+            flags=re.IGNORECASE,
+        )
+        if match is not None:
+            maturin_pins.append(f"maturin=={match.group(1)}")
+        elif re.match(r"\s*maturin(?:\W|$)", requirement, flags=re.IGNORECASE):
+            raise RuntimeError(
+                "native Maturin build requirement must be exactly pinned"
+            )
+    if len(maturin_pins) != 1:
+        raise RuntimeError(
+            "native pyproject must contain exactly one pinned Maturin requirement"
+        )
+    tool = payload.get("tool")
+    maturin = tool.get("maturin") if isinstance(tool, Mapping) else None
+    if not isinstance(maturin, Mapping):
+        raise RuntimeError("native pyproject Maturin configuration must be a table")
+    classified = (
+        _NATIVE_MATURIN_CONFIG_KEYS
+        | _NON_OUTPUT_MATURIN_CONFIG_KEYS
+        | _PACKAGING_MATURIN_CONFIG_KEYS
+    )
+    unknown = set(maturin) - classified
+    if unknown:
+        rendered = ", ".join(sorted(str(key) for key in unknown))
+        raise RuntimeError(f"unclassified Maturin configuration: {rendered}")
+    return _canonical_json_bytes(
+        {
+            "build-system": {"requires": maturin_pins},
+            "tool": {
+                "maturin": {
+                    key: maturin[key]
+                    for key in sorted(_NATIVE_MATURIN_CONFIG_KEYS & set(maturin))
+                },
+                "pyamplicol": {"native-build": _native_build_contract(payload)},
+            },
+        }
+    )
+
+
+def _canonical_checkout_path(raw: str) -> str:
+    normalized = raw.replace("\\", "/").rstrip("/")
+    if normalized in {"TMP_FIXED_SYMJIT", "./TMP_FIXED_SYMJIT"} or normalized.endswith(
+        "/TMP_FIXED_SYMJIT"
+    ):
+        return "TMP_FIXED_SYMJIT"
+    marker = "/dependencies/checkouts/"
+    if marker in normalized:
+        suffix = normalized.rsplit(marker, maxsplit=1)[1]
+        if suffix:
+            return f"dependencies/checkouts/{suffix}"
+    prefix = "dependencies/checkouts/"
+    if normalized.startswith(prefix) and len(normalized) > len(prefix):
+        return normalized
+    raise RuntimeError(
+        "candidate Cargo patch paths must resolve below dependencies/checkouts"
+    )
+
+
+def _candidate_cargo_config_bytes(data: bytes) -> bytes:
+    """Return the exact path-independent candidate Cargo patch contract."""
+
+    try:
+        payload = tomllib.loads(data.decode("utf-8"))
+        patch = payload["patch"]
+        crates_io = patch["crates-io"]
+    except (
+        KeyError,
+        TypeError,
+        UnicodeDecodeError,
+        tomllib.TOMLDecodeError,
+    ) as error:
+        raise RuntimeError(f"invalid candidate Cargo config: {error}") from error
+    if (
+        not isinstance(payload, dict)
+        or set(payload) != {"patch"}
+        or not isinstance(patch, dict)
+        or set(patch) != {"crates-io"}
+        or not isinstance(crates_io, dict)
+        or not set(_CANDIDATE_PATCH_TARGETS).issubset(crates_io)
+    ):
+        raise RuntimeError(
+            "candidate Cargo config must contain the locked native crates.io "
+            "patch table"
+        )
+    canonical: dict[str, Any] = {"patch": {"crates-io": {}}}
+    canonical_patches = canonical["patch"]["crates-io"]
+    for name, expected in _CANDIDATE_PATCH_TARGETS.items():
+        entry = crates_io[name]
+        if (
+            not isinstance(entry, Mapping)
+            or set(entry) != {"path"}
+            or not isinstance(entry["path"], str)
+        ):
+            raise RuntimeError(
+                f"candidate Cargo patch {name} must contain exactly one path"
+            )
+        observed = _canonical_checkout_path(entry["path"])
+        if observed != expected and not (
+            name == "symjit" and observed == "TMP_FIXED_SYMJIT"
+        ):
+            raise RuntimeError(
+                f"candidate Cargo patch {name} must resolve to {expected}"
+            )
+        canonical_patches[name] = {"path": observed}
+    return _canonical_json_bytes(canonical)
+
+
+def _required_string(
+    payload: Mapping[str, Any],
+    key: str,
+    *,
+    description: str,
+) -> str:
+    value = payload.get(key)
+    if not isinstance(value, str) or not value:
+        raise RuntimeError(f"{description} {key} must be a non-empty string")
+    return value
+
+
+def _required_hex(
+    payload: Mapping[str, Any],
+    key: str,
+    *,
+    length: int,
+    description: str,
+) -> str:
+    value = _required_string(payload, key, description=description)
+    if len(value) != length or any(
+        character not in "0123456789abcdef" for character in value
+    ):
+        raise RuntimeError(
+            f"{description} {key} must be a lowercase {length}-digit hex value"
+        )
+    return value
+
+
+def _canonical_candidate_sources(raw_sources: Any) -> dict[str, dict[str, str]]:
+    if not isinstance(raw_sources, Mapping):
+        raise RuntimeError("candidate installer state sources must be an object")
+    source_names = set(raw_sources)
+    if any(not isinstance(name, str) or not name for name in source_names):
+        raise RuntimeError("candidate installer source names must be non-empty strings")
+    if not _NATIVE_CANDIDATE_SOURCE_NAMES.issubset(source_names):
+        raise RuntimeError(
+            "candidate installer state has an incomplete native source map"
+        )
+    sources: dict[str, dict[str, str]] = {}
+    for name in sorted(_NATIVE_CANDIDATE_SOURCE_NAMES):
+        raw_source = raw_sources[name]
+        description = f"candidate installer source {name}"
+        if not isinstance(raw_source, Mapping):
+            raise RuntimeError(f"{description} must be an object")
+        allowed_fields = {"url", "revision", "branch"}
+        required_fields = {"url", "revision"}
+        if not required_fields.issubset(raw_source) or not set(raw_source).issubset(
+            allowed_fields
+        ):
+            raise RuntimeError(
+                f"{description} must contain url/revision and optional branch only"
+            )
+        source = {
+            "url": _required_string(raw_source, "url", description=description),
+            "revision": _required_hex(
+                raw_source,
+                "revision",
+                length=40,
+                description=description,
+            ),
+        }
+        if "branch" in raw_source:
+            source["branch"] = _required_string(
+                raw_source,
+                "branch",
+                description=description,
+            )
+        sources[name] = source
+    return sources
+
+
+def _candidate_install_state_bytes(
+    root: Path,
+    data: bytes,
+    *,
+    cargo_config_data: bytes,
+) -> bytes:
+    """Validate and canonicalize the minimal immutable-source install state."""
+
+    del root, cargo_config_data
+
+    try:
+        payload = json.loads(data)
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise RuntimeError(f"invalid candidate installer state: {error}") from error
+    schema_version = (
+        payload.get("schema_version") if isinstance(payload, dict) else None
+    )
+    if not isinstance(payload, dict) or set(payload) != {
+        "publishable",
+        "schema_version",
+        "sources",
+    }:
+        raise RuntimeError(
+            "candidate installer state must contain only schema_version, "
+            "publishable, and sources"
+        )
+    if (
+        not isinstance(schema_version, int)
+        or isinstance(schema_version, bool)
+        or schema_version != 1
+        or payload["publishable"] is not False
+    ):
+        raise RuntimeError(
+            "candidate installer state must be a non-publishable schema-1 object"
+        )
+    sources = _canonical_candidate_sources(payload["sources"])
+    return _canonical_json_bytes(
+        {
+            "publishable": False,
+            "schema_version": 1,
+            "sources": sources,
+        }
+    )
+
+
+def _release_cargo_lock_bytes(root: Path, data: bytes) -> bytes:
+    """Return the ordinary immutable-Git Cargo lock without projection."""
+
+    del root
+    return data
+
+
+def _is_native_build_tree_input(root: Path, tree: Path, path: Path) -> bool:
+    if not path.is_file():
+        return False
+    tree_relative = path.relative_to(tree)
+    root_relative = path.relative_to(root)
+    return (
+        not _NATIVE_BUILD_IGNORED_TREE_PARTS.intersection(tree_relative.parts)
+        and root_relative not in _NON_NATIVE_RUST_PATHS
+    )
+
+
+def _native_build_inputs_digest(
+    root: Path,
+    *,
+    normalize_release_cargo_lock: bool = False,
+) -> str:
+    """Hash the small set of checkout inputs that determines the native build."""
+
+    candidate_config = root / _CANDIDATE_CARGO_CONFIG
+    candidate_state = root / _CANDIDATE_INSTALL_STATE
+    canonical_candidate_inputs: dict[Path, bytes] = {}
+    if not normalize_release_cargo_lock:
+        if candidate_config.is_file() != candidate_state.is_file():
+            raise RuntimeError(
+                "candidate native build identity requires both "
+                "candidate-cargo-config.toml and install-state.json"
+            )
+        if candidate_config.is_file():
+            cargo_config_data = candidate_config.read_bytes()
+            canonical_candidate_inputs[candidate_config] = (
+                _candidate_cargo_config_bytes(cargo_config_data)
+            )
+            canonical_candidate_inputs[candidate_state] = (
+                _candidate_install_state_bytes(
+                    root,
+                    candidate_state.read_bytes(),
+                    cargo_config_data=cargo_config_data,
+                )
+            )
+
+    paths = [
+        root / relative
+        for relative in _NATIVE_BUILD_INPUT_FILES
+        if not (
+            normalize_release_cargo_lock
+            and relative in _RELEASE_OMITTED_NATIVE_BUILD_INPUTS
+        )
+        and not (canonical_candidate_inputs and relative == Path("Cargo.lock"))
+    ]
+    # Local upstream fixes have no new Git revision. Include their compiler
+    # inputs in the existing cache key, but not their tests or documentation.
+    manifest = root / "Cargo.toml"
+    if manifest.is_file():
+        cargo = tomllib.loads(manifest.read_text(encoding="utf-8"))
+        local_symjit = cargo.get("patch", {}).get("crates-io", {}).get("symjit", {})
+        local_path = local_symjit.get("path")
+        if isinstance(local_path, str):
+            local_root = (root / local_path).resolve()
+            if local_root == (root / "TMP_FIXED_SYMJIT").resolve():
+                paths.extend(local_root / name for name in ("Cargo.toml", "build.rs"))
+                paths.extend(
+                    path for path in (local_root / "src").rglob("*") if path.is_file()
+                )
+    for relative in _NATIVE_BUILD_INPUT_TREES:
+        tree = root / relative
+        if not tree.is_dir():
+            continue
+        paths.extend(
+            path
+            for path in tree.rglob("*")
+            if _is_native_build_tree_input(root, tree, path)
+            and not (
+                normalize_release_cargo_lock
+                and path.relative_to(root) in _RELEASE_OMITTED_NATIVE_BUILD_INPUTS
+            )
+        )
+    digest = hashlib.sha256(_NATIVE_BUILD_IDENTITY_DOMAIN)
+    for path in sorted(set(paths)):
+        if not path.is_file():
+            continue
+        relative = path.relative_to(root).as_posix().encode("utf-8")
+        data = canonical_candidate_inputs.get(path, path.read_bytes())
+        if path == root / "pyproject.toml":
+            data = _native_pyproject_bytes(data)
+        if normalize_release_cargo_lock and path == root / "Cargo.lock":
+            data = _release_cargo_lock_bytes(root, data)
+        digest.update(len(relative).to_bytes(8, "little"))
+        digest.update(relative)
+        digest.update(len(data).to_bytes(8, "little"))
+        digest.update(data)
+    return digest.hexdigest()
+
+
+def _native_extensions(package_root: Path) -> tuple[Path, ...]:
+    return tuple(
+        sorted(
+            (
+                path
+                for path in package_root.glob("_rusticol.*")
+                if path.is_file() and path.name.endswith(_NATIVE_EXTENSION_SUFFIXES)
+            ),
+            key=lambda path: path.name,
+        )
+    )
+
+
+def _read_build_info(path: Path, description: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, TypeError, ValueError) as error:
+        raise RuntimeError(
+            f"{description} is unreadable; rerun `just dev-install`"
+        ) from error
+    if not isinstance(payload, dict):
+        raise RuntimeError(f"{description} is invalid; rerun `just dev-install`")
+    return payload
+
+
+def _is_source_checkout(package_root: Path, source_root: Path) -> bool:
+    return (
+        package_root == source_root / "src" / "pyamplicol"
+        and (source_root / "pyproject.toml").is_file()
+    )
+
+
+def _verify_source_runtime(
+    payload: dict[str, Any],
+    *,
+    package_root: Path | None = None,
+    source_root: Path | None = None,
+) -> None:
+    contract = payload.get("source_runtime")
+    if not isinstance(contract, dict):
+        raise RuntimeError(
+            "source runtime provenance is missing; rerun `just dev-install`"
+        )
+    extension_name = contract.get("extension_name")
+    extension_sha256 = contract.get("extension_sha256")
+    mode = contract.get("mode")
+    native_digest = contract.get("native_build_inputs_sha256")
+    if not all(
+        isinstance(value, str) and value
+        for value in (extension_name, extension_sha256, native_digest)
+    ) or mode not in {"candidate", "release"}:
+        raise RuntimeError(
+            "source runtime provenance is incomplete; rerun `just dev-install`"
+        )
+    valid_build_mode = (
+        mode == "candidate" and payload.get("publishable") is False
+    ) or (
+        mode == "release"
+        and (
+            payload.get("publishable") is True
+            or (
+                payload.get("publishable") is False
+                and payload.get("release_prepared_model_bootstrap") is True
+            )
+        )
+    )
+    if not valid_build_mode:
+        raise RuntimeError(
+            "source runtime provenance has an inconsistent build mode; "
+            "rerun `just dev-install`"
+        )
+    if (
+        len(extension_sha256) != 64
+        or any(character not in "0123456789abcdef" for character in extension_sha256)
+        or len(native_digest) != 64
+        or any(character not in "0123456789abcdef" for character in native_digest)
+        or payload.get("native_build_inputs_sha256") != native_digest
+    ):
+        raise RuntimeError(
+            "source runtime provenance is incomplete; rerun `just dev-install`"
+        )
+    package_root = package_root or _SOURCE_PACKAGE_ROOT
+    extensions = _native_extensions(package_root)
+    if len(extensions) != 1 or extensions[0].name != extension_name:
+        raise RuntimeError(
+            "source runtime extension inventory is ambiguous or stale; "
+            "rerun `just dev-install`"
+        )
+    if hashlib.sha256(extensions[0].read_bytes()).hexdigest() != extension_sha256:
+        raise RuntimeError(
+            "source runtime extension is stale or was replaced; "
+            "rerun `just dev-install`"
+        )
+    source_root = source_root or _SOURCE_ROOT
+    if (
+        _native_build_inputs_digest(
+            source_root,
+            normalize_release_cargo_lock=mode == "release",
+        )
+        != native_digest
+    ):
+        raise RuntimeError(
+            "native build inputs changed after the source runtime was staged; "
+            "rerun `just dev-install`"
+        )
+
+
+def _verify_candidate_install(payload: dict[str, Any]) -> None:
+    raw_root = payload.get("source_checkout")
+    native_digest = payload.get("native_build_inputs_sha256")
+    if (
+        not isinstance(raw_root, str)
+        or not raw_root
+        or not isinstance(native_digest, str)
+        or len(native_digest) != 64
+    ):
+        raise RuntimeError(
+            "candidate wheel provenance is incomplete; rerun `just dev-install`"
+        )
+    source_root = Path(raw_root)
+    if not source_root.is_absolute() or not (source_root / "pyproject.toml").is_file():
+        raise RuntimeError(
+            "candidate wheel source checkout is unavailable; rerun `just dev-install`"
+        )
+    release_prepared_model_bootstrap = (
+        payload.get("release_prepared_model_bootstrap") is True
+    )
+    if (
+        _native_build_inputs_digest(
+            source_root,
+            normalize_release_cargo_lock=release_prepared_model_bootstrap,
+        )
+        != native_digest
+    ):
+        install_kind = (
+            "release prepared-model bootstrap"
+            if release_prepared_model_bootstrap
+            else "candidate wheel"
+        )
+        raise RuntimeError(
+            f"installed {install_kind} is stale for this checkout; "
+            "rerun `just dev-install`"
+        )
+
+
+def _active_build_info() -> dict[str, Any] | None:
+    if (
+        _is_source_checkout(_SOURCE_PACKAGE_ROOT, _SOURCE_ROOT)
+        and _SOURCE_BUILD_INFO_PATH.exists()
+    ):
+        return _read_build_info(
+            _SOURCE_BUILD_INFO_PATH,
+            "source runtime provenance",
+        )
+    if _PACKAGE_BUILD_INFO_PATH.exists():
+        return _read_build_info(_PACKAGE_BUILD_INFO_PATH, "wheel build provenance")
+    return None
+
+
+def _native_build_inputs_from_build_info(build_info: Mapping[str, Any]) -> str:
+    native_digest = build_info.get("native_build_inputs_sha256")
+    if native_digest is None and build_info.get("publishable") is True:
+        try:
+            native = importlib.import_module("pyamplicol._rusticol")
+        except ImportError as error:
+            raise RuntimeError(
+                "active native build-input identity is unavailable; reinstall "
+                "pyAmpliCol"
+            ) from error
+        operation = getattr(native, "native_build_inputs_sha256", None)
+        native_digest = operation() if callable(operation) else None
+    if (
+        not isinstance(native_digest, str)
+        or len(native_digest) != 64
+        or any(character not in "0123456789abcdef" for character in native_digest)
+    ):
+        raise RuntimeError(
+            "active native build-input identity is incomplete; reinstall pyAmpliCol"
+        )
+    return native_digest
+
+
+def active_native_build_inputs_sha256() -> str:
+    """Return the authenticated native build-input digest, if installed."""
+
+    build_info = _active_build_info()
+    if build_info is None:
+        raise RuntimeError(
+            "active native build provenance is unavailable; reinstall pyAmpliCol"
+        )
+    return _native_build_inputs_from_build_info(build_info)
+
+
+def active_native_source_identity() -> tuple[str, str]:
+    """Return the authenticated source revision and native-input digest."""
+
+    build_info = _active_build_info()
+    if build_info is None:
+        raise RuntimeError(
+            "active native build provenance is unavailable; reinstall pyAmpliCol"
+        )
+    source_revision = build_info.get("source_revision")
+    if (
+        not isinstance(source_revision, str)
+        or len(source_revision) != 40
+        or any(character not in "0123456789abcdef" for character in source_revision)
+    ):
+        raise RuntimeError(
+            "active native source identity is incomplete; reinstall pyAmpliCol"
+        )
+    return source_revision, _native_build_inputs_from_build_info(build_info)
+
+
+def active_source_revision() -> str | None:
+    """Return the revision bound to the active wheel/source runtime, if any."""
+
+    build_info = _active_build_info()
+    if build_info is None:
+        return None
+    revision = build_info.get("source_revision")
+    if (
+        not isinstance(revision, str)
+        or len(revision) != 40
+        or any(character not in "0123456789abcdef" for character in revision)
+    ):
+        return None
+    return revision
+
+
+def active_source_checkout() -> Path | None:
+    """Return the checkout backing a non-publishable local build, if available."""
+
+    build_info = _active_build_info()
+    if build_info is None or build_info.get("publishable") is not False:
+        return None
+    raw_root = build_info.get("source_checkout")
+    if not isinstance(raw_root, str) or not raw_root:
+        return None
+    root = Path(raw_root)
+    return root if root.is_absolute() else None
+
+
+def verify_native_module(module: Any, *, expected_version: str | None = None) -> None:
+    """Reject a stale native extension in contributor builds.
+
+    Published wheels retain the normal package-manager import path; the extra
+    build-ID check is limited to non-publishable candidate wheels and staged
+    source runtimes.
+    """
+
+    # Unit tests and external adapters may provide a duck-typed stand-in. Real
+    # extension modules always expose an on-disk module path.
+    if not getattr(module, "__file__", None):
+        return
+    operation = getattr(module, "package_version", None)
+    if not callable(operation):
+        raise RuntimeError(
+            "native runtime has no package-version contract; reinstall pyAmpliCol"
+        )
+    observed = operation()
+    expected = expected_version or package_version()
+    if not isinstance(observed, str) or observed.replace("-dev.", ".dev") != expected:
+        raise RuntimeError(
+            "native runtime version does not match the Python package "
+            f"({observed!r} != {expected!r}); rerun `just dev-install`"
+        )
+    build_info = _active_build_info()
+    if build_info is None:
+        return
+    source_runtime = build_info.get("source_runtime")
+    if build_info.get("publishable") is not False and not isinstance(
+        source_runtime, dict
+    ):
+        return
+    native_digest = build_info.get("native_build_inputs_sha256")
+    native_operation = getattr(module, "native_build_inputs_sha256", None)
+    if not isinstance(native_digest, str) or not callable(native_operation):
+        raise RuntimeError(
+            "native runtime build-ID contract is incomplete; rerun `just dev-install`"
+        )
+    if native_operation() != native_digest:
+        raise RuntimeError(
+            "native runtime was built from different source inputs; "
+            "rerun `just dev-install`"
+        )
+
+
+def package_version(default: str = "0.2.1") -> str:
+    """Return the wheel/source-runtime version without importing heavy modules."""
+
+    if _is_source_checkout(_SOURCE_PACKAGE_ROOT, _SOURCE_ROOT):
+        source_runtime_present = (
+            _SOURCE_BUILD_INFO_PATH.exists()
+            or _SOURCE_RUNTIME_STAGING_PATH.exists()
+            or bool(_native_extensions(_SOURCE_PACKAGE_ROOT))
+        )
+        if source_runtime_present:
+            if _SOURCE_RUNTIME_STAGING_PATH.exists():
+                raise RuntimeError(
+                    "source runtime staging is incomplete; rerun `just dev-install`"
+                )
+            payload = _read_build_info(
+                _SOURCE_BUILD_INFO_PATH,
+                "source runtime provenance",
+            )
+            _verify_source_runtime(payload)
+            value = payload.get("version")
+            if not isinstance(value, str) or not value:
+                raise RuntimeError(
+                    "source runtime version provenance is invalid; "
+                    "rerun `just dev-install`"
+                )
+            return value
+
+    if _PACKAGE_BUILD_INFO_PATH.exists():
+        payload = _read_build_info(
+            _PACKAGE_BUILD_INFO_PATH,
+            "wheel build provenance",
+        )
+        value = payload.get("version")
+        if not isinstance(value, str) or not value:
+            raise RuntimeError(
+                "wheel build version provenance is invalid; reinstall pyAmpliCol"
+            )
+        if payload.get("publishable") is False:
+            _verify_candidate_install(payload)
+        return value
+    try:
+        return metadata.version("pyamplicol")
+    except metadata.PackageNotFoundError:
+        return default
+
+
+__all__ = [
+    "COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY",
+    "COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY",
+    "COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY",
+    "COMPILED_HELICITY_DUAL_LANE_CAPABILITY",
+    "COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY",
+    "COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY",
+    "COMPILED_MODEL_SCHEMA_VERSION",
+    "COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY",
+    "COMPILED_PLANE_DIRECT_APPLICATION_ABI",
+    "COMPILED_RUNTIME_SELECTORS_CAPABILITY",
+    "C_ABI_VERSION",
+    "EAGER_DAG_F64_RUNTIME_CAPABILITY",
+    "EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY",
+    "EAGER_DIRECT_TABLE_BINDING_ABI",
+    "EAGER_DIRECT_TABLE_DESCRIPTOR_ABI",
+    "EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY",
+    "EAGER_RUNTIME_LAYOUT_F64_CAPABILITY",
+    "EVALUATOR_RUNTIME_CAPABILITIES",
+    "KNOWN_EVALUATOR_RUNTIME_CAPABILITIES",
+    "ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY",
+    "ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY",
+    "ON_THE_FLY_RUNTIME_CAPABILITY",
+    "PROCESS_ARTIFACT_SCHEMA_VERSION",
+    "PYTHON_API_VERSION",
+    "RECURRENCE_BUILDER_INPUT_ABI",
+    "RECURRENCE_COLOR_RUNTIME_CAPABILITY",
+    "RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY",
+    "RECURRENCE_DIRECT_BACKEND_ABI",
+    "RECURRENCE_DIRECT_BINDING_ABI",
+    "RECURRENCE_DIRECT_TEMPLATE_ABI",
+    "RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY",
+    "RECURRENCE_PLAN_ABI",
+    "RECURRENCE_RUNTIME_LAYOUT_ABI",
+    "RUNTIME_PHYSICS_SCHEMA_VERSION",
+    "SYMBOLICA_ASM_RUNTIME_CAPABILITY",
+    "SYMBOLICA_CPP_RUNTIME_CAPABILITY",
+    "SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY",
+    "SYMBOLICA_SERIALIZATION_ABI",
+    "SYMJIT_APPLICATION_ABI",
+    "SYMJIT_F64_RUNTIME_CAPABILITY",
+    "SYMJIT_PLANE_APPLICATION_ABI",
+    "SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY",
+    "TOML_SCHEMA_VERSION",
+    "active_native_build_inputs_sha256",
+    "active_native_source_identity",
+    "active_source_checkout",
+    "active_source_revision",
+    "package_version",
+    "verify_native_module",
+]
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/README.md b/pyamplicol/src/pyamplicol/_profiling_campaign/README.md
new file mode 100644
index 0000000000..63557f2937
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/README.md
@@ -0,0 +1,190 @@
+<!-- SPDX-License-Identifier: 0BSD -->
+# pyAmpliCol profiling campaign template
+
+This packaged directory is the authoritative reset template for a
+self-contained profiling campaign. Create it in a destination whose name
+identifies its measurement environment:
+
+```console
+pyamplicol profiling-campaign copy ./my-profiling-campaign \
+  --local-madgraph /path/to/MG5_aMC
+cd ./my-profiling-campaign
+```
+
+The copy contains the report's LaTeX sources, reset raw JSON measurements, and
+generated table TeX. Its visible `campaign_artifacts/` directory contains all
+evaluator attempts, prepared artifacts, worker logs, locks, leases, and other
+runtime state. Moving or renaming the whole campaign therefore moves its state;
+no repository-level or legacy `.artifacts` directory is consulted.
+
+Use the executable manual controller described in `TABLE_FILLING.md`. Its
+`--help` output is the authoritative selector, resource-limit, reuse, and
+keyboard-control reference:
+
+```console
+./steer_performance_campaign.py --help
+```
+
+An installed pyAmpliCol wheel can create the portable reset copy without a
+source checkout:
+
+```console
+pyamplicol profiling-campaign copy ./pyamplicol-profiling-campaign --force
+./pyamplicol-profiling-campaign/steer_performance_campaign.py --help
+./pyamplicol-profiling-campaign/steer_performance_campaign.py run \
+  --workers 1 --table matrix --process-id 1 --multiplicity 1 \
+  --color-approximation lc --generation-mode non-union-flow \
+  --generation-engine recurrence --model built_in \
+  --no-dependencies-added --no-dashboard
+```
+
+The final command is a real, deliberately small installation smoke test. It
+measures only `d d~ > Z`; broader multiplicities belong on a dedicated
+profiling host.
+
+`--force` overwrites the managed template files and resets only this copy's
+`campaign_artifacts/`, `pyAmpliCol.pdf`, `campaign_summary_ids/`, and known
+measurement-lineage/LaTeX build byproducts. It keeps unrelated files and a
+previously recorded `.pyamplicol-original-amplicol` default unless a new
+`--local-amplicol PATH` is supplied. It likewise preserves the recorded
+`.pyamplicol-madgraph` default unless `--local-madgraph PATH` is supplied.
+Stop an active campaign before resetting its destination.
+
+Release wheels do not include the optional `ratatui` and `ratatui_py`
+dashboard bindings. Installed campaign runs therefore continue headlessly as
+if `--no-dashboard` were supplied. `dashboard-snapshot` is available when
+those bindings are present, including in a contributor checkout prepared with
+`just dev-install`; otherwise it exits with the corresponding instruction.
+
+By default, a run adds the available numerical-authority closure for every
+selected cell at the active source revision. MadGraph standalone is the
+authoritative full-colour boundary for the four UFO-SM comparison views;
+recurrence is the independent authority for compiled/eager comparisons on the
+other surfaces. Original AmpliCol is retained only as a legacy performance and
+numerical diagnostic and never certifies or rejects a candidate. Independent
+processes remain parallel, while a terminal required authority releases its
+candidate to run unverified. Use
+`--no-dependencies-added` to suppress optional authority expansion; hard
+construction and selector/provider dependencies are always retained. A
+selection that directly or automatically includes `amplicol` requires a clean,
+complete checkout exposing the color-probe sources and Make targets from PR
+#12. Supply it with `run --original-amplicol PATH`, or add
+`--local-amplicol PATH` to the copy command to record that checkout as this
+campaign's default; the run option overrides the saved default. A source
+checkout can prepare the default path with
+`just dev-install --with-legacy-amplicol`. The `amplicol_with_patches` branch
+works now; a compatible upstream revision will work unchanged after the PR is
+merged.
+
+The full-colour MadGraph views require an installation with executable
+`bin/mg5_aMC` and its standard `models/sm` UFO model. Supply it once with
+`profiling-campaign copy --local-madgraph PATH`, or override the saved value
+with `run --madgraph PATH`. Each authority cell streams `generate`, `output
+standalone`, and `launch -f` through a MadGraph command card, counts the
+standalone compilation in generation time, then compiles a small campaign-owned
+Fortran driver to evaluate and benchmark the generated matrix element. The
+same deterministic point is evaluated by pyAmpliCol at precision 200 for
+recurrence, compiled, and eager, and at the supported precision 16 for OTF; all
+four candidates must agree within relative tolerance `1e-10`.
+
+For on-the-fly LC cells in the n<=4 matrix, the matching recurrence cell is the
+single numerical correctness authority. No compiled artifact is generated or
+loaded for that gate. Original AmpliCol remains the legacy performance
+baseline used by the OTF-versus-AmpliCol tables. OTF NLC and full colour use a
+selector-free contracted workload and require the authenticated contracted-
+colour runtime capability; the UFO-SM full-colour cells compare directly with
+MadGraph. This contract is report-cache schema v5.
+
+With `run --fail-fast`, dispatch proceeds in multiplicity waves (`n=1`, then
+`n=2`, and so on) and stops at the first required mismatch. A failed legacy
+AmpliCol comparison is deliberately non-terminal: the existing table keeps all
+other entries unchanged and renders only the AmpliCol generation time in red.
+
+Rebuild every table and the PDF from one stable current-result snapshot with:
+
+```console
+./steer_performance_campaign.py refresh-pdf
+```
+
+The refresh shows a coloured progress bar while it reads and confirms the
+campaign's current records. List the stable top-level PDF section IDs, or omit
+selected sections from one generated PDF, with:
+
+```console
+./steer_performance_campaign.py refresh-pdf --list-sections
+./steer_performance_campaign.py refresh-pdf \
+  --remove-sections worked-zgg shared-current-dag
+```
+
+Section removal changes only that staged PDF build. It does not remove
+measurements, result JSON, generated table TeX, or source material; the next
+plain `refresh-pdf` restores the complete report. `--quiet` suppresses both the
+scan progress display and live LaTeX output.
+
+Review the deterministic dashboard fixture, or capture the newest running
+campaign's read-only informational lease, with:
+
+```console
+./steer_performance_campaign.py dashboard-snapshot
+./steer_performance_campaign.py dashboard-snapshot --live
+```
+
+The live form reads only compact lease JSON in the ignored coordination
+directory. Use `--instance ID_OR_PREFIX` to choose among concurrent runs; see
+`dashboard-snapshot --help` for staleness and styled-cell capture controls.
+
+Every completed or orderly interrupted `run` atomically replaces
+`campaign_summary_ids/` with one text file per non-success status. Each file
+contains exact canonical cell IDs and can be fed straight back to `run` or
+`inspect`:
+
+```console
+./steer_performance_campaign.py run \
+  --cell-id-file campaign_summary_ids/error.txt \
+                 campaign_summary_ids/validation_failed.txt \
+  --force-refresh
+```
+
+`campaign_summary_ids/unverified.txt` is directly replayable without
+`--force-refresh`: those timing diagnostics are not successful currents, and
+they are rerun and validated automatically once the required recurrence or
+MadGraph authority is available.
+
+For state-based retries, keep the ordinary table/process/engine selectors and
+add `--rerun-failed`, `--rerun-capped`, or both. The flags filter only that
+direct selection: failed means its latest terminal non-success is not an
+authenticated policy cap, while capped means an authenticated policy cap. The
+combined flags take the union; successful, static, and never-attempted cells
+are excluded. Unverified results remain automatically retryable and can be
+selected as failed. Normal dependency closure and reuse of successful currents
+still apply, and `--continue-across-revisions` controls whether historical
+terminal state participates. The retry flags conflict with `--force-refresh`.
+A retry filter with no matches exits successfully without replacing the
+existing campaign summary.
+
+The default lifecycle is compact. Each completed attempt retains its sealed
+result and current pointer, provenance, commands, progress/timeline evidence,
+bounded log tails, and reusable outputs needed by currents or dependencies.
+Disposable copied AmpliCol, MadGraph, and build workspaces are removed after
+publication; cross-revision reuse relies on the sealed results, not those
+workspaces. Pass `run --retain-workspaces` only when full debug workspaces are
+needed. `--cleanup-artifacts` remains a compatibility spelling for the default
+compact policy.
+
+Two storage guards apply independently of process-tree memory supervision:
+`--attempt-output-limit` defaults to 67,108,864 bytes (64 MiB) per watched
+output/log file, and `--minimum-free-disk` defaults to 5,368,709,120 bytes
+(5 GiB) on the campaign artifact volume. Both options accept byte counts.
+
+Create independent campaigns with separate `profiling-campaign copy` commands.
+Every result artifact, worker lease, lock, and reproduction file remains below
+that copy's `campaign_artifacts/`, even when two destinations share a basename.
+A copy made from an installed wheel uses that wheel's recorded source revision
+and installed runtime. Never commit `campaign_artifacts/`, evaluator artifacts,
+candidate wheels, prepared models, attempts, logs, locks, coordination state,
+page images, or LaTeX auxiliary files.
+
+When the launcher runs from a source checkout, it checks the checkout index
+and worktree before measuring. It reads ordinary Git metadata directly and,
+if HEAD is packed, uses one read-only `git rev-parse` query for the committed
+tree. Installed-wheel campaigns do not need a Git checkout.
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/TABLE_FILLING.md b/pyamplicol/src/pyamplicol/_profiling_campaign/TABLE_FILLING.md
new file mode 100644
index 0000000000..e165188269
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/TABLE_FILLING.md
@@ -0,0 +1,224 @@
+<!-- SPDX-License-Identifier: 0BSD -->
+# Profiling campaign table filling
+
+First create and enter a reset campaign. The executable controller in that
+copy is the authoritative campaign interface:
+
+```console
+pyamplicol profiling-campaign copy ./my-profiling-campaign \
+  --local-madgraph /path/to/MG5_aMC
+cd ./my-profiling-campaign
+./steer_performance_campaign.py --help
+```
+
+For an installed release wheel, first copy the reset campaign into a new or
+empty destination and invoke the controller there:
+
+```console
+pyamplicol profiling-campaign copy ./pyamplicol-profiling-campaign --force
+./pyamplicol-profiling-campaign/steer_performance_campaign.py \
+  run --workers 1 --table matrix --process-id 1 --multiplicity 1 \
+  --color-approximation lc --generation-mode non-union-flow \
+  --generation-engine recurrence --model built_in \
+  --no-dependencies-added --no-dashboard
+```
+
+This real smoke campaign selects only the final-state-multiplicity-one
+`d d~ > Z` recurrence cell and is suitable for checking an installation.
+
+Release wheels omit the optional `ratatui` and `ratatui_py` dashboard
+bindings. Installed runs automatically continue headlessly as though
+`--no-dashboard` had been supplied. `dashboard-snapshot` remains available
+when those bindings are present, notably in a contributor checkout prepared
+with `just dev-install`; without them it exits with an actionable instruction.
+
+By default, selected cells gain their available active-source numerical
+authority closure. MadGraph standalone is authoritative for the full-colour
+UFO-SM views, and recurrence is authoritative for the remaining compiled/eager
+cross-mode comparisons. Original AmpliCol is an optional legacy diagnostic and
+performance denominator only. Added cells are dependency-only work;
+independent processes remain parallel, and a terminal required authority
+releases its candidate to run unverified. Pass `--no-dependencies-added` to
+suppress optional
+authority expansion while retaining every hard construction and
+selector/provider dependency. A selection that directly or automatically
+includes `amplicol` requires a clean, complete checkout exposing the PR #12
+probe sources and Make targets. Supply it with
+`run --original-amplicol PATH`, or pass `--local-amplicol PATH` to the initial
+`profiling-campaign copy` command to save it as the campaign default; the run
+option overrides the saved default. A source checkout can prepare the default
+path with `just dev-install --with-legacy-amplicol`. The
+`amplicol_with_patches` branch works now, and a compatible upstream revision
+will work unchanged after the PR is merged.
+
+The MadGraph full-colour cells require an installation containing executable
+`bin/mg5_aMC` and the standard `models/sm` UFO model. Record it with the copy
+command's `--local-madgraph PATH`, or supply/override it for one invocation via
+`run --madgraph PATH`. The campaign times the streamed `generate`, `output
+standalone`, `launch -f` sequence, including standalone compilation, and uses a
+custom Fortran driver for the reference value and repeated-evaluation timing.
+pyAmpliCol evaluates the shared comparison point at precision 200 for
+recurrence, compiled, and eager, and at the supported precision 16 for OTF;
+the strict relative tolerance is `1e-10` for every candidate.
+
+Use `run --fail-fast` for multiplicity-wave validation: all selected `n=1`
+work completes before `n=2` is released, and the campaign stops at the first
+required mismatch. A disagreement with legacy AmpliCol is non-terminal; only
+its generation-time token is rendered red, while the rest of the existing
+table remains unchanged. OTF NLC and full colour are genuine contracted
+workloads with no flow selector and require their accuracy-specific runtime
+capability; OTF LC retains the selected-flow and all-flow workloads.
+
+Inside a contributor checkout it re-executes with the repository `.venv`; an
+installed copy uses the wheel's Python runtime. Both modes reuse compatible
+same-source currents by default, supervise each process tree, and store campaign
+state plus compact retained evidence in this campaign's visible
+`campaign_artifacts/` directory. Full workspaces and other heavy debugging
+payloads are retained only with `--retain-workspaces`. That state moves with the
+entire campaign and never falls back to an old repository-level `.artifacts`
+directory. Use separate copied directories for independent campaigns, even when
+their basenames happen to match.
+
+Preview selections before launching workers:
+
+```console
+./steer_performance_campaign.py run \
+  --dry-run --table z_table --multiplicity 3 4 \
+  --model built_in sm_ufo
+```
+
+The preview lists direct cells and dependency work separately and prints a
+wrapped public-CLI recipe for every selected runnable cell, even for broad
+selections. Each recipe uses the repository `.venv/bin/pyamplicol` and states
+whether it is exact, a template, or a diagnostic protocol exception. UFO
+recurrence/eager recipes include their public `model compile` prerequisite.
+
+The same small installation campaign, when run from inside its directory, is:
+
+```console
+./steer_performance_campaign.py run \
+  --workers 1 --table matrix --process-id 1 --multiplicity 1 \
+  --color-approximation lc --generation-mode non-union-flow \
+  --generation-engine recurrence --model built_in \
+  --no-dependencies-added --no-dashboard
+```
+
+Broader selections may raise `--workers` and `--cores-per-worker` on a dedicated
+profiling host. Original AmpliCol builds use the independent
+`--amplicol-build-jobs` setting, which remains 1 by default because the
+maintained legacy generator target is not parallel-safe. Defaults are one
+worker, one pyAmpliCol core, one AmpliCol build job, a one-hour
+generation/preparation limit, and a decimal 30 GB process-tree RAM limit.
+`--ram-limit` applies to each worker tree. Add `--campaign-ram-limit` to place
+an aggregate ceiling across all workers; it is conservatively divided by the
+requested worker count and combined with the per-worker limit. Thus
+`--workers 10 --ram-limit 30000000000 --campaign-ram-limit 30000000000`
+limits each tree to 3 GB rather than permitting ten independent 30 GB claims.
+Press `Ctrl-C` or `Esc` to stop dispatch, terminate supervised process trees,
+preserve completed currents, and restore the terminal.
+
+After normal completion or an orderly interrupt, the controller prints the
+absolute path of `campaign_summary_ids/`. It replaces that directory with one
+sorted text file per non-success status, for example `error.txt`,
+`blocked_dependency.txt`, `validation_failed.txt`, or `worker_timeout.txt`.
+Replay any union of those exact IDs while retaining the normal dependency
+closure and other selector intersections:
+
+```console
+./steer_performance_campaign.py run \
+  --cell-id-file campaign_summary_ids/error.txt \
+                 campaign_summary_ids/validation_failed.txt \
+  --force-refresh
+```
+
+`--cell-id-file` is also accepted by `inspect`. Blank lines and full-line `#`
+comments are ignored. For a structured retry within the ordinary direct
+selection, add `--rerun-failed`, `--rerun-capped`, or both:
+
+```console
+./steer_performance_campaign.py run \
+  --table z_table --generation-engine recurrence compiled \
+  --rerun-failed --rerun-capped
+```
+
+`--rerun-failed` keeps cells whose latest terminal outcome is unsuccessful but
+is not an authenticated policy cap; `--rerun-capped` keeps authenticated policy
+caps, and combining them takes the union. Successful, static, and unseen cells
+are not direct retry targets. Unverified results are automatically retryable
+and may be selected as failed. Dependency closure is still planned normally,
+including reuse of successful prerequisite currents. Historical outcomes are
+recognized only with `--continue-across-revisions`. These retry flags cannot be
+combined with `--force-refresh`; use that option only for an unconditional
+refresh. If no selected cell matches the requested retry state, the command is
+a successful no-op and preserves the existing campaign summary.
+
+Replaying `blocked_dependency.txt` automatically includes required
+prerequisites.
+`unverified.txt` needs no `--force-refresh`: an unverified timing diagnostic is
+not a successful current and is automatically rerun against a later available
+recurrence or MadGraph authority.
+
+The default lifecycle is compact. Each completed attempt retains its sealed
+result and current pointer, provenance, commands, progress/timeline evidence,
+bounded log tails, and reusable outputs needed by currents or dependencies.
+Disposable copied AmpliCol, MadGraph, and build workspaces are removed after
+publication; cross-revision reuse relies on the sealed results, not those
+workspaces. Use `--retain-workspaces` only when full debug workspaces are
+needed. `--cleanup-artifacts` remains a compatibility spelling for the default
+compact policy.
+
+Storage safety is separate from the process-tree RAM cap.
+`--attempt-output-limit` defaults to 67,108,864 bytes (64 MiB) per watched
+output/log file, while `--minimum-free-disk` reserves 5,368,709,120 bytes
+(5 GiB) on the campaign artifact volume. Both options accept byte counts.
+
+Running `pyamplicol profiling-campaign copy DEST --force` again resets only
+`DEST/campaign_artifacts`, the managed PDF, the campaign summary-ID directory,
+known lineage/LaTeX build byproducts, and the packaged template files. It
+preserves unrelated files and the recorded original-AmpliCol and MadGraph
+paths unless new `--local-amplicol` or `--local-madgraph` values are supplied.
+Stop active campaign processes before resetting their destination.
+
+Capture a running dashboard from another terminal without attaching to or
+changing the campaign:
+
+```console
+./steer_performance_campaign.py \
+  dashboard-snapshot --live --width 160 --height 48
+```
+
+This reads only the compact non-stale coordination lease. The newest active
+invocation is the default; pass `--instance ID_OR_PREFIX` to choose one
+concurrent run. Omit `--live` for the deterministic synthetic layout fixture.
+
+Inspect coverage and AmpliCol-relative statistics:
+
+```console
+./steer_performance_campaign.py inspect \
+  --color-approximation lc --generation-engine recurrence compiled
+```
+
+Rebuild all current JSON/TeX tables and atomically replace the PDF:
+
+```console
+./steer_performance_campaign.py refresh-pdf
+```
+
+Interactive refreshes show a coloured progress bar while the controller reads
+and confirms the complete current-record snapshot. To discover stable
+top-level section IDs or build a shorter PDF without changing campaign data:
+
+```console
+./steer_performance_campaign.py refresh-pdf --list-sections
+./steer_performance_campaign.py refresh-pdf \
+  --remove-sections worked-zgg shared-current-dag
+```
+
+The omission applies only to that PDF build. Measurements, JSON caches, table
+TeX, and the canonical source remain present; a later plain refresh restores
+the full report. Use `--quiet` to suppress the scan progress display and live
+LaTeX output.
+
+Human output is coloured by default. Use `--no-color` or `NO_COLOR`; JSON is
+always uncoloured. Consult each subcommand’s `--help` for all selectors,
+aliases, resource controls, profiling parameters, reuse rules, and examples.
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/build_pdf.py b/pyamplicol/src/pyamplicol/_profiling_campaign/build_pdf.py
new file mode 100644
index 0000000000..47b616fc1c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/build_pdf.py
@@ -0,0 +1,112 @@
+# SPDX-License-Identifier: 0BSD
+"""Compile and verify an exported pyAmpliCol report using only its TeX folder."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+from collections.abc import Sequence
+from pathlib import Path
+from shutil import which
+
+
+class StandaloneBuildError(RuntimeError):
+    """The standalone publication could not be compiled or verified."""
+
+
+_UNRESOLVED_PATTERNS = (
+    re.compile(r"LaTeX Warning: Citation .* undefined"),
+    re.compile(r"LaTeX Warning: Reference .* undefined"),
+    re.compile(r"LaTeX Warning: There were undefined references"),
+    re.compile(r"Package rerunfilecheck Warning:"),
+)
+
+
+def validate_latex_log(log: str) -> None:
+    """Reject layout overflow and unresolved cross-reference diagnostics."""
+
+    if "Overfull \\hbox" in log or "Overfull \\vbox" in log:
+        raise StandaloneBuildError("LaTeX output contains an overfull box")
+    for pattern in _UNRESOLVED_PATTERNS:
+        if pattern.search(log):
+            raise StandaloneBuildError(
+                f"LaTeX output is unresolved: {pattern.pattern}"
+            )
+
+
+def compile_report(
+    report_dir: Path,
+    *,
+    engine: str = "pdflatex",
+    passes: int = 3,
+) -> Path:
+    """Compile ``pyAmpliCol.tex`` and reject unresolved or overflowing output."""
+
+    root = report_dir.expanduser().resolve(strict=True)
+    source = root / "pyAmpliCol.tex"
+    if not source.is_file():
+        raise StandaloneBuildError(f"missing report source: {source}")
+    if passes < 2:
+        raise StandaloneBuildError("at least two LaTeX passes are required")
+    executable = which(engine)
+    if executable is None:
+        raise StandaloneBuildError(f"LaTeX engine is not available: {engine}")
+
+    command = (
+        executable,
+        "-interaction=nonstopmode",
+        "-halt-on-error",
+        "-file-line-error",
+        source.name,
+    )
+    for _ in range(passes):
+        completed = subprocess.run(
+            command,
+            cwd=root,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if completed.returncode != 0:
+            detail = (completed.stdout + completed.stderr)[-4000:]
+            raise StandaloneBuildError(
+                f"LaTeX compilation failed with exit {completed.returncode}:\n"
+                f"{detail}"
+            )
+
+    log_path = root / "pyAmpliCol.log"
+    try:
+        log = log_path.read_text(encoding="utf-8", errors="replace")
+    except OSError as error:
+        raise StandaloneBuildError(f"cannot read LaTeX log: {error}") from error
+    validate_latex_log(log)
+
+    output = root / "pyAmpliCol.pdf"
+    if not output.is_file() or output.stat().st_size == 0:
+        raise StandaloneBuildError(f"LaTeX did not produce {output}")
+    return output
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Compile and verify this standalone pyAmpliCol report",
+    )
+    parser.add_argument("--engine", default="pdflatex")
+    parser.add_argument("--passes", type=int, default=3)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = _parser().parse_args(argv)
+    output = compile_report(
+        Path(__file__).resolve().parent,
+        engine=arguments.engine,
+        passes=arguments.passes,
+    )
+    print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/pyAmpliCol.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/pyAmpliCol.tex
new file mode 100644
index 0000000000..885d2d8362
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/pyAmpliCol.tex
@@ -0,0 +1,537 @@
+% SPDX-License-Identifier: 0BSD
+\documentclass[10pt,letterpaper]{article}
+
+\usepackage[T1]{fontenc}
+\usepackage[utf8]{inputenc}
+\usepackage[letterpaper,margin=0.75in,headheight=21pt]{geometry}
+\usepackage{amsmath,amssymb}
+\usepackage{array}
+\usepackage{booktabs}
+\usepackage{eso-pic}
+\usepackage{fancyhdr}
+\usepackage{hyperref}
+\usepackage{listings}
+\usepackage{longtable}
+\usepackage{pdflscape}
+\usepackage{siunitx}
+\usepackage[table]{xcolor}
+
+\DeclareMathSizes{5}{5}{5}{5}
+\DeclareMathSizes{6.8}{6.8}{5}{5}
+
+\definecolor{ReportInk}{HTML}{17212B}
+\definecolor{ReportBlue}{HTML}{145A86}
+\definecolor{ReportGreen}{HTML}{287A58}
+\definecolor{ReportOrange}{HTML}{B76E00}
+\definecolor{ReportRed}{HTML}{B33A3A}
+\definecolor{ReportRule}{HTML}{CBD3DA}
+\definecolor{ReportMuted}{HTML}{66717C}
+\definecolor{refblue}{HTML}{DCEBFF}
+\definecolor{bestgreen}{HTML}{DFF5E4}
+\definecolor{speedgreen}{HTML}{1A7F37}
+\definecolor{speedorange}{HTML}{BF8700}
+\definecolor{speedred}{HTML}{CF222E}
+
+\hypersetup{
+  colorlinks=true,
+  linkcolor=ReportBlue,
+  urlcolor=ReportBlue,
+  pdftitle={pyAmpliCol 1.0.1 Methodology and Performance Report},
+  pdfauthor={Rikkert Frederix, Valentin Hirschi, and Timea Vitos}
+}
+\sisetup{detect-all,scientific-notation=true,round-mode=figures,round-precision=3}
+\setlength{\parindent}{0pt}
+\setlength{\parskip}{0.55em}
+\setcounter{secnumdepth}{2}
+\setcounter{tocdepth}{1}
+
+\pagestyle{fancy}
+\fancyhf{}
+\fancyhead[L]{\textcolor{ReportInk}{pyAmpliCol 1.0.1}}
+\fancyhead[R]{\textcolor{ReportMuted}{Methodology and performance}}
+\fancyfoot[C]{\thepage}
+\renewcommand{\headrulewidth}{0.4pt}
+\renewcommand{\headrule}{\hbox to\headwidth{\color{ReportRule}\leaders\hrule height \headrulewidth\hfill}}
+
+\newif\ifReportLandscapePage
+\ReportLandscapePagefalse
+\AddToShipoutPictureFG{%
+  \ifReportLandscapePage
+    \AtPageLowerLeft{%
+      \put(\LenToUnit{\dimexpr\paperwidth-0.35in\relax},
+           \LenToUnit{0.5\paperheight}){%
+        \rotatebox{90}{\makebox[0pt][c]{%
+          \textcolor{ReportMuted}{\thepage}}}}}%
+  \fi
+}
+
+\newcolumntype{L}[1]{>{\raggedright\arraybackslash}p{#1}}
+\newcolumntype{R}[1]{>{\raggedleft\arraybackslash}p{#1}}
+\newcommand{\PAC}{\texttt{pyAmpliCol}}
+\newcommand{\AC}{\texttt{AmpliCol}}
+\newcommand{\ReportNA}{\textcolor{ReportMuted}{\textsc{n/a}}}
+\newcommand{\ReportStatus}[1]{\textcolor{ReportMuted}{\textsc{#1}}}
+\newcommand{\ReportMetricCell}[2]{\shortstack{\textcolor{ReportGreen}{G #1}\\\textcolor{ReportBlue}{R #2}}}
+\newcommand{\ReportTableNote}[1]{\par\smallskip\noindent\footnotesize\textcolor{ReportMuted}{#1}\par}
+\newcommand{\ReportMatrixLegend}{\ReportTableNote{The table heading names the baseline and candidate. LC reports the selected-flow, summed-helicity workload and the all-flow, selected-helicity workload separately. NLC and full colour report one contracted workload. Parenthesized values are candidate-to-baseline ratios; an execution attribution is shown only when both measurements expose it.}}
+\newcommand{\ReportLadderLegend}{\ReportTableNote{Each LC workload reports process-generation time in seconds and native wall time in microseconds per phase-space point, together with a separately measured execution attribution when exposed. Compiled rows use the labelled JIT, ASM, or C++ backend; eager and recurrence rows use portable JIT O2 prepared models. Parenthesized wall-time and selected-flow generation values compare each pyAmpliCol row with the corresponding AmpliCol workload. For compiled and eager rows, wall time is the authenticated warmed total-evaluator boundary; not exposed refers only to a narrower execution attribution. All-flow generation is shown absolutely without a ratio because its setup boundary differs from the reference.}}
+\newcommand{\ReportLandscapeFooter}{}
+\newcommand{\ReportProfileName}{unpopulated}
+\newcommand{\ReportPlatformSummary}{specified by the architecture profile}
+\newcommand{\ReportToolchainSummary}{specified by the architecture profile}
+\newcommand{\ReportEditionStatement}{This source is the unpopulated
+  documentation template. Architecture-specific copies contain their recorded
+  environment and measured results.}
+\InputIfFileExists{report_environment.tex}{}{}
+
+\lstset{
+  basicstyle=\ttfamily\small,
+  columns=fullflexible,
+  frame=single,
+  rulecolor=\color{ReportRule},
+  breaklines=true,
+  showstringspaces=false,
+  xleftmargin=0.5em,
+  xrightmargin=0.5em
+}
+
+\title{\vspace{-1.4cm}\textbf{pyAmpliCol 1.0.1}\\[0.35em]
+  \Large Methodology and Performance Report}
+\author{Rikkert Frederix \and Valentin Hirschi \and Timea Vitos}
+\date{Release 1.0.1\\[0.25em]\small Measurement profile:
+  \texttt{\ReportProfileName}}
+
+\begin{document}
+\maketitle
+
+\begin{abstract}
+This report presents the physics coverage, numerical validation, and
+performance of \PAC{} 1.0.1. We compare compiled, eager, recurrence, and
+on-the-fly evaluation across the report's stated built-in Standard Model and
+UFO or serialized-JSON scopes, together with scalar-contact and scalar-gravity
+benchmarks. Every reported
+timing is associated with a documented software revision, hardware profile,
+numerical configuration, and validation reference appropriate to the
+corresponding data set.
+\end{abstract}
+
+\begingroup
+\small
+\setlength{\parskip}{0pt}
+\tableofcontents
+\endgroup
+\clearpage
+
+% pyamplicol-report-section-begin: scope
+\section{Scope}
+
+\PAC{} generates and evaluates tree-level scattering amplitudes. Compiled mode
+specializes a shared-current directed acyclic graph (DAG) to a process. Eager
+mode evaluates the same graph with reusable model kernels. Recurrence mode
+constructs a compact current schedule directly. On-the-fly mode stores a
+compact source-oriented process seed and constructs selector-family schedules
+lazily; this report covers its built-in-SM leading-colour and selector-free
+contracted NLC/full lanes through four final-state particles. Within their
+declared scopes, the modes implement the
+same physics normalization, colour treatment, helicity sums, and resolved
+observables. The original \AC{} program and its use in event generation are
+described in Ref.~\cite{FrederixVitos2026}.
+
+The report has three purposes:
+\begin{enumerate}
+  \item define the observables and conditions required for a reproducible
+        benchmark;
+  \item preserve a stable matrix of representative process families and colour
+        approximations; and
+  \item present performance only after numerical agreement has been verified.
+\end{enumerate}
+
+In each architecture-specific report, an \ReportNA{} entry denotes a
+process/multiplicity combination outside the declared scope or an observable
+that does not apply. Every applicable cell across the complete declared
+multiplicity range must instead contain a validated measurement or an
+documented resource-limit status. A measurement that does not pass
+numerical validation is labelled explicitly and never replaced by a timing
+value. No value is copied, interpolated, or estimated from a neighbouring
+cell.
+% pyamplicol-report-section-end: scope
+
+% pyamplicol-report-section-begin: recursion
+\section{Current Recursion and Model Lowering}
+
+\subsection{Shared-current DAG}
+
+For an external subset $I$, particle state $t$, and local spin or flow label
+$\chi$, an off-shell current has the schematic recursion
+\begin{equation}
+  J^{\alpha}_{t,\chi}(I)
+  = P^{\alpha}{}_{\beta}(t,p_I)
+    \sum_{I=A\mathbin{\dot\cup}B}
+    V^{\beta}{}_{\gamma\delta}(t_A,t_B\!\to t)
+    J^{\gamma}_{t_A,\chi_A}(A)
+    J^{\delta}_{t_B,\chi_B}(B),
+  \qquad p_I=\sum_{i\in I}p_i .
+  \label{eq:recursion}
+\end{equation}
+Current identity includes the particle, external labels, helicity ancestry,
+chirality or spin state, flavour and charge flow, colour state, momentum mask,
+and any auxiliary-current kind. Contributions with the same complete identity
+share one node. A topological sweep therefore evaluates each retained current
+once per phase-space point and reuses it in all dependent amplitudes.
+This is a Berends--Giele-type construction~\cite{BerendsGiele1988}.
+
+The Universal Feynman Output format (UFO; originally Universal FeynRules
+Output) describes particles, parameters, interactions, Lorentz tensors,
+colour tensors, and propagators in a model-independent
+form~\cite{UFO2012,UFO2023}. \PAC{} normalizes a trusted UFO Python module, or
+its own serialized JSON representation of that model, to the same canonical
+representation used by process generation. The UFO module is executable
+Python; the corresponding serialized JSON form is data-only.
+
+Optimizations of imported models are based on exact colour, Lorentz,
+propagator, and coupling identities rather than particle names or numerical
+codes. For Standard-Model validation processes, the built-in and imported
+routes must produce equivalent current, interaction, amplitude, and colour
+content. Algebraic reuse is allowed only when the relevant identity has been
+established exactly.
+
+\subsection{Contact terms and spin two}
+
+A supported vertex with valence above three is lowered to a deterministic tree
+of non-propagating auxiliary currents. The construction inserts the original
+coupling once and introduces no pole. Direct contraction of the original
+contact tensor is the validation reference for the scalar-contact ladder.
+
+The scalar-gravity ladder exercises rank-two external states and
+momentum-dependent interactions. For a massless graviton, the helicity-two
+polarization tensor is represented as
+\begin{equation}
+  \epsilon^{\mu\nu}_{\pm 2}
+  = \epsilon^{\mu}_{\pm}\epsilon^{\nu}_{\pm} .
+\end{equation}
+Validation checks symmetry, transversality, tracelessness, normalization, and
+agreement between ordinary and higher-precision evaluation.
+% pyamplicol-report-section-end: recursion
+
+% pyamplicol-report-section-begin: colour-runtime
+\section{Colour and Runtime Semantics}
+
+The process matrices use three colour contracts:
+\begin{center}
+\begin{tabular}{@{}L{0.45in}L{5.85in}@{}}
+\textbf{LC} & Leading-colour ordered amplitudes with physical colour-flow selectors~\cite{Maltoni2002}. \\
+\textbf{NLC} & Every colour-metric entry whose leading power is at most two below the leading power of the complete basis. \\
+\textbf{Full} & The complete supported sparse colour metric for the generated amplitude basis. \\
+\end{tabular}
+\end{center}
+
+For NLC, ``retained'' applies to a colour-matrix \emph{entry}, not to a
+truncated numerical coefficient.  Write the exact overlap of two colour-flow
+tensors as
+\begin{equation}
+  C_{ab}(N_c)=\sum_p c^{(ab)}_p N_c^p,
+  \qquad
+  p_{ab}=\max\{p:c^{(ab)}_p\ne0\},
+  \label{eq:nlc-entry-gate}
+\end{equation}
+and let \(P\) be the leading power of the complete colour basis.  The sparse
+NLC metric is
+\begin{equation}
+  C^{\mathrm{NLC}}_{ab}=
+  \begin{cases}
+    C_{ab}(3), & p_{ab}\ge P-2,\\
+    0,         & p_{ab}<P-2.
+  \end{cases}
+  \label{eq:nlc-exact-coefficient}
+\end{equation}
+Thus every qualifying entry keeps all of its finite-\(N_c\) terms.  For three
+open fundamental lines and one adjoint, \(P=4\).  Representative retained
+off-diagonal overlaps are
+
+\begin{center}
+\begin{tabular}{@{}L{1.45in}L{1.20in}L{1.35in}L{1.35in}@{}}
+\toprule
+\textbf{exact overlap} & \textbf{highest power} &
+  \textbf{NLC at \(N_c=3\)} & \textbf{full at \(N_c=3\)} \\
+\midrule
+\(-N_c^3+N_c\) & \(3\) & \(-24\) & \(-24\) \\
+\(N_c^2-1\) & \(2\) & \(8\) & \(8\) \\
+\bottomrule
+\end{tabular}
+\end{center}
+
+The powers and coefficients are retained exactly.  When only the
+upper-triangular part of the colour metric is stored, off-diagonal interference
+terms receive the usual factor of two; this factor is not part of the colour
+coefficient in Eq.~\eqref{eq:nlc-exact-coefficient}.
+
+The summed observable returns one matrix element per point.  Leading-colour
+resolved values have axes \texttt{(point, helicity, flow)}; NLC and full-colour
+values have one contracted colour component per helicity. Summing all
+non-point axes must reproduce the directly evaluated total. Selectors refer to
+physical helicities and flows.
+
+All \PAC{} binary64 interfaces use the same native numerical core.
+Cross-interface agreement therefore checks data conventions, while a
+separately generated value is required for an independent physics comparison.
+
+The JIT backend stores a portable SymJIT application for binary64 evaluation;
+the receiving host creates code appropriate for its processor. ASM and C++
+payloads are target-specific. Evaluation above binary64 precision uses the
+retained symbolic evaluator state.
+% pyamplicol-report-section-end: colour-runtime
+
+% pyamplicol-report-section-begin: methodology
+\section{Benchmark Methodology}
+
+\subsection{Configuration contract}
+
+Each measurement begins from an immutable resolved configuration. Unless a
+table states otherwise, measurements use a batch size of 128, two warmup runs,
+at least five timed samples, a five-second sampling target, and one CPU core.
+Compiled process matrices use JIT O3; eager and recurrence matrices use
+portable JIT O2 prepared models, and on-the-fly matrices use their prepared
+JIT O2 model kernels. Explicitly labelled rows in the dedicated \(Z\) ladder
+use JIT O1, JIT O3, ASM O3, or C++ O3. Backend-specific optimization settings
+are retained with the measurement record.
+
+Generation time begins with the resolved model input required by an execution
+mode and ends with a validated, loadable process representation. Compiled mode
+includes process-specific evaluator construction and backend compilation.
+Eager and recurrence modes include construction and serialization of their
+respective numerical schedules. Preparation of a reusable built-in or UFO/JSON
+model bundle occurs before this timer and is therefore excluded from the
+process-generation values in the tables. On-the-fly generation serializes one
+compact process-seed artifact and, for contracted colour accuracies, its
+authenticated colour-contraction payload; the separately reported first cold
+evaluation is not part of that generation timer.
+
+Runtime measurements use the summed matrix element. The reported native wall
+time starts after caller-language array conversion and includes source
+construction, numerical evaluation, selector handling, and final reduction.
+Caller-language packing is excluded. When a backend exposes a separately
+measured execution attribution, the tables show it alongside wall time;
+otherwise the field is marked \textsc{not exposed} and is never inferred or
+replaced by zero. Comparisons use the same process, colour accuracy,
+parameters, phase-space point, precision, selectors, and normalization.
+
+\subsection{Benchmark platform}
+
+\ReportEditionStatement{} The recorded hardware, operating system, and processor
+summary is \ReportPlatformSummary. The measurement profile is
+\texttt{\ReportProfileName}; its recorded software environment is
+\ReportToolchainSummary. Measurements from different processor architectures
+are reported separately and are never combined in a summary ratio. Unless a
+table states otherwise, generation and evaluation use one CPU core and a
+five-second sampling target.
+
+\subsection{Numerical validation}
+
+For each Standard-Model process, compared execution modes and references use
+the same deterministic phase-space point and numerical parameters. Cross-mode
+comparisons use relative tolerance $10^{-12}$ and absolute tolerance
+$10^{-15}$. In the four full-colour UFO-SM views, MadGraph standalone is the
+authoritative physics reference: recurrence, compiled, and eager evaluate the
+shared point at precision 200, while on-the-fly uses its supported precision-16
+lane; every candidate must agree within relative tolerance $10^{-10}$. Scalar-model ladders
+instead compare binary64 evaluation with higher precision and, where
+applicable, direct contact-tensor contraction. Every result must reproduce its
+resolved sum and preserve expected structural zeros.
+
+Original \AC{} comparisons remain in the historical LC, NLC, and full-colour
+tables at relative tolerance $10^{-8}$, but they are diagnostic rather than
+authoritative. A discrepancy does not invalidate the \PAC{} result: the table
+colours only the \AC{} generation-time token red and otherwise preserves its
+timings and ratios. MadGraph-discovered fixes are implemented in shared,
+model-generic generation paths so that recurrence, compiled, eager, and
+on-the-fly inherit the same correction. On-the-fly NLC and full colour are
+genuine selector-free contracted evaluations backed by an authenticated
+expanded colour-contraction payload.
+
+For each on-the-fly LC cell, both measured workloads must agree component by
+component with a separately generated recurrence result. The complete
+resolved-component check is performed before and after
+\texttt{Runtime.clear()}, and the resolved components must reproduce the total
+on both passes.
+
+Timing and numerical validation are separate requirements: a timing is
+reported only when the corresponding matrix element passes all required
+validation checks, and numerical agreement alone does not substitute for a
+measured generation or runtime value. Legacy \AC{} disagreement is explicitly
+not a required check.
+% pyamplicol-report-section-end: methodology
+
+% pyamplicol-report-section-begin: process-matrices
+\clearpage
+\begin{landscape}
+\ReportLandscapePagetrue
+\pagestyle{empty}
+\input{section_three_mode_performance_tables.tex}
+\end{landscape}
+\ReportLandscapePagefalse
+% pyamplicol-report-section-end: process-matrices
+% pyamplicol-report-section-begin: z-ladders
+\clearpage
+\pagestyle{empty}
+\begin{landscape}
+\ReportLandscapePagetrue
+\section{Z-plus-Jets Evaluator Ladders}
+
+The dedicated $d\bar d\to Z+(n-1)g$ ladders compare the independent reference
+with compiled JIT O1, compiled JIT O3, ASM O3, C++ O3, eager-DAG JIT O2,
+recurrence JIT O2, and on-the-fly JIT O2 evaluator configurations. They retain
+final-state multiplicities $n=1,\ldots,9$ for both the built-in model and
+the UFO-SM result set. Each row states its evaluator backend
+and optimization level explicitly; all other workload settings follow the
+benchmark contract above.
+
+The eager, recurrence, and on-the-fly rows start from the corresponding
+portable JIT O2 prepared model. Each layout retains complete flow and helicity
+coverage; the selected-flow workload sums helicities, while the all-flow
+workload selects one helicity at runtime. The on-the-fly row uses one compact
+query-local process seed for both workloads and builds the requested
+query-family union during its first evaluation. Its generation entry therefore
+shows \texttt{[G] G+W}, with the process-seed generation time muted and the cold
+first-evaluation cost included in the primary value. Prepared-model creation is
+excluded from process-generation time. Every displayed \(Z\)-ladder timing
+ratio uses the matching original \AC{} workload as its denominator, while every
+non-recurrence \PAC{} result is compared directly with the matching recurrence
+result at the stricter cross-mode tolerance. Built-in and UFO-SM recurrence
+results are likewise compared directly.
+
+Runtime comparisons between these backends also include their vectorization
+strategy. The JIT rows can use SIMD across phase-space points, whereas the
+generated ASM and C++ rows are scalar. Their ratios therefore include both
+code-generation quality and vectorization; they are not comparisons of
+otherwise identical kernels.
+
+\subsection*{Worked \(d\bar d\to Zg\) example}
+
+For \(n=2\), the explicit process is
+\[
+  d(p_1)\,\bar d(p_2)\to Z(p_3)\,g(p_4).
+\]
+The report labels source particles in process order. The selected leading-colour
+reference order for the selected-flow timing is therefore \((2,4,1,3)\): the
+colour line enters through \(\bar d\), traverses the gluon, and exits through
+\(d\), while the colour-singlet \(Z\) remains in the public ordering only to
+keep source labels unambiguous. The corresponding coloured word is
+\((2,4,1)\).
+
+\PAC{} builds a shared-current representation for the selected process. Source
+nodes carry particle, momentum, helicity, flavour, and colour-flow labels;
+composite nodes are identified by their complete quantum state. The
+selected-flow workload uses the traversal \((2,4,1)\) and sums helicities; the
+all-flow workload sums every LC flow for one selected helicity. Both layouts
+retain complete physical coverage and are validated against the same reference
+point before timing.
+
+\clearpage
+\input{result_z_builtin_sm_table.tex}
+\clearpage
+\input{result_z_external_sm_table.tex}
+\ReportLadderLegend
+\ReportLandscapeFooter
+\end{landscape}
+\ReportLandscapePagefalse
+% pyamplicol-report-section-end: z-ladders
+\clearpage
+\pagestyle{fancy}
+
+% pyamplicol-report-section-begin: scalar-ladders
+\section{Colour-Singlet Model Ladders}
+
+Both colour-singlet ladders use compiled JIT O3 evaluation and the full-colour
+contract. The scalar-contact ladder retains $n=2,\ldots,8$ final scalars and
+tests high-valence contact decomposition, identical-particle normalization,
+and source parity without Standard-Model-specific kernels. The scalar-gravity
+ladder retains $n=2,\ldots,4$ final gravitons and exercises spin-two
+wavefunctions, tensor propagators, and momentum-dependent vertices. Because
+every external particle in these models is a colour singlet, LC, NLC, and full
+colour reduce to the same unit colour contraction.
+
+For these ladders, the relative-difference row is
+\(\bigl||\mathcal M|^2_{\mathrm{f64}}-|\mathcal M|^2_{\mathrm{hp}}\bigr|
+/\max(|\mathcal M|^2_{\mathrm{hp}},10^{-300})\), where the high-precision value
+uses the same phase-space point. It is a numerical stability check, not a
+performance ratio.
+
+\input{result_scalar_contact_table.tex}
+\input{result_scalar_gravity_table.tex}
+% pyamplicol-report-section-end: scalar-ladders
+
+% pyamplicol-report-section-begin: interpretation
+\section{Interpretation}
+
+Performance comparisons are meaningful only for a baseline measured with the
+same observables, parameters, selectors, and hardware profile. The result
+tables therefore present validated, architecture-local comparisons; they do
+not combine measurements from different machines. An \ReportNA{} entry denotes
+only a structurally inapplicable cell or observable; every applicable cell
+contains a validated measurement or documented resource-limit status.
+Numerical agreement, timing uncertainty, and software revision remain part of
+the published result set even when a compact table shows only the central
+timing.
+% pyamplicol-report-section-end: interpretation
+
+% pyamplicol-report-section-begin: worked-zgg
+\clearpage
+\input{section_zgg_example.tex}
+% pyamplicol-report-section-end: worked-zgg
+% pyamplicol-report-section-begin: shared-current-dag
+\clearpage
+\input{section_zgg_dag.tex}
+% pyamplicol-report-section-end: shared-current-dag
+% pyamplicol-report-section-begin: lc-layouts
+\clearpage
+\input{section_lc_flow_layouts.tex}
+% pyamplicol-report-section-end: lc-layouts
+% pyamplicol-report-section-begin: execution-modes
+\clearpage
+\input{section_eager_execution.tex}
+% pyamplicol-report-section-end: execution-modes
+% pyamplicol-report-section-begin: ufo-support
+\input{section_ufo_support.tex}
+% pyamplicol-report-section-end: ufo-support
+
+\clearpage
+\begin{thebibliography}{9}
+
+\bibitem{BerendsGiele1988}
+F.~A. Berends and W.~T. Giele,
+\emph{Recursive Calculations for Processes with \(n\) Gluons},
+Nucl.\ Phys.\ B \textbf{306} (1988) 759--808,
+doi:10.1016/0550-3213(88)90442-7.
+
+\bibitem{Maltoni2002}
+F.~Maltoni, K.~Paul, T.~Stelzer, and S.~Willenbrock,
+\emph{Color-flow decomposition of QCD amplitudes},
+Phys.\ Rev.\ D \textbf{67} (2003) 014026,
+doi:10.1103/PhysRevD.67.014026,
+arXiv:hep-ph/0209271.
+
+\bibitem{UFO2012}
+C.~Degrande, C.~Duhr, B.~Fuks, D.~Grellscheid, O.~Mattelaer, and T.~Reiter,
+\emph{UFO---The Universal FeynRules Output},
+Comput.\ Phys.\ Commun.\ \textbf{183} (2012) 1201--1214,
+doi:10.1016/j.cpc.2012.01.022,
+arXiv:1108.2040.
+
+\bibitem{UFO2023}
+L.~Darm\'e et al.,
+\emph{UFO 2.0---The Universal Feynman Output format},
+Eur.\ Phys.\ J.\ C \textbf{83} (2023) 631,
+doi:10.1140/epjc/s10052-023-11780-9,
+arXiv:2304.09883.
+
+\bibitem{FrederixVitos2026}
+R.~Frederix and T.~Vitos,
+\emph{Event generation with exponential scaling in multiplicity using
+AmpliCol},
+JHEP \textbf{04} (2026) 192,
+doi:10.1007/JHEP04(2026)192,
+arXiv:2601.19483.
+
+\end{thebibliography}
+
+\end{document}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/report-workspace.json b/pyamplicol/src/pyamplicol/_profiling_campaign/report-workspace.json
new file mode 100644
index 0000000000..6561ffb1d1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/report-workspace.json
@@ -0,0 +1,71 @@
+{
+  "artifact_root": "campaign_artifacts",
+  "campaign_policy": {
+    "allow_terminal_censors": false,
+    "cell_cores": null,
+    "generation_limit_exemptions": "none",
+    "generation_limit_seconds": null,
+    "memory_limit_bytes": null,
+    "name": "strict-complete-v1",
+    "require_symbolica_parallel": false,
+    "schema": "pyamplicol-report-campaign-policy-v1",
+    "target_runtime_seconds": 5.0,
+    "workers": null
+  },
+  "coordination_root": "campaign_artifacts/coordination",
+  "document": "pyAmpliCol.tex",
+  "environment_json": "report_environment.json",
+  "environment_tex": "report_environment.tex",
+  "excluded_content": [
+    "campaign_artifacts evaluator attempts and prepared models",
+    "worker logs",
+    "locks and coordination state",
+    "LaTeX auxiliary files"
+  ],
+  "initialized_environment": {
+    "candidate_fingerprint": "pending",
+    "machine": "pending measurement-host authentication",
+    "native_build_inputs_sha256": "pending",
+    "native_cpu_features": "pending exact-source runtime authentication",
+    "native_extension_sha256": "pending",
+    "native_target": "pending exact-source runtime authentication",
+    "numpy": "pending exact-source runtime authentication",
+    "platform": "pending measurement-host authentication",
+    "processor": "pending measurement-host authentication",
+    "profile": "macbook_M3_manual",
+    "pyamplicol": "pending exact-source runtime authentication",
+    "python": "pending measurement-host authentication",
+    "python_implementation": "pending measurement-host authentication",
+    "python_package_tree_sha256": "pending",
+    "schema": "pyamplicol-performance-report-environment-v1",
+    "source_revision": "pending",
+    "status": "pending_exact_runtime"
+  },
+  "initialized_from": "src/pyamplicol/_profiling_campaign",
+  "initialized_source_identity": {
+    "clean": false,
+    "dirty_paths": [],
+    "revision": "unknown",
+    "schema": "pyamplicol-report-source-v1",
+    "tree": "unknown"
+  },
+  "measurement_environment_contract": "refresh generated environment JSON/TeX after the exact-source clean build and before population",
+  "measurement_state": "reset",
+  "profile": "macbook_M3_manual",
+  "raw_results": "results",
+  "report_source_revision": "unknown",
+  "report_source_tree": "unknown",
+  "schema": "pyamplicol-performance-report-workspace-v4",
+  "tracked_content": [
+    "*.tex",
+    "report_environment.json",
+    "measurement_lineage.json",
+    "results/*.json",
+    "README.md",
+    "TABLE_FILLING.md",
+    "report-workspace.json",
+    "build_pdf.py",
+    "result_tables.py",
+    "pyAmpliCol.pdf (when compiled and reviewed)"
+  ]
+}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/report_environment.json b/pyamplicol/src/pyamplicol/_profiling_campaign/report_environment.json
new file mode 100644
index 0000000000..7bcdbd4b0d
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/report_environment.json
@@ -0,0 +1 @@
+{"candidate_fingerprint":"pending","machine":"pending measurement-host authentication","native_build_inputs_sha256":"pending","native_cpu_features":"pending exact-source runtime authentication","native_extension_sha256":"pending","native_target":"pending exact-source runtime authentication","numpy":"pending exact-source runtime authentication","platform":"pending measurement-host authentication","processor":"pending measurement-host authentication","profile":"macbook_M3_manual","pyamplicol":"pending exact-source runtime authentication","python":"pending measurement-host authentication","python_implementation":"pending measurement-host authentication","python_package_tree_sha256":"pending","schema":"pyamplicol-performance-report-environment-v1","source_revision":"pending","status":"pending_exact_runtime"}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/report_environment.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/report_environment.tex
new file mode 100644
index 0000000000..af067d45e6
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/report_environment.tex
@@ -0,0 +1,6 @@
+% SPDX-License-Identifier: 0BSD
+% Generated architecture-profile metadata; do not edit by hand.
+\renewcommand{\ReportProfileName}{macbook\_M3\_manual}
+\renewcommand{\ReportPlatformSummary}{pending measurement-host authentication}
+\renewcommand{\ReportToolchainSummary}{pending an authenticated post-checkpoint build}
+\renewcommand{\ReportEditionStatement}{This document is an architecture-specific edition.}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_best_builtin_sm_full_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_best_builtin_sm_full_table.tex
new file mode 100644
index 0000000000..1d53129036
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_best_builtin_sm_full_table.tex
@@ -0,0 +1,212 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\providecommand{\bestmodecode}[1]{\textcolor{ReportMuted}{\texttt{(#1)}}}
+\providecommand{\bestmodecodeprefix}[1]{\bestmodecode{#1}\hspace{0.025in}}
+\providecommand{\bestmodeabsolutechoice}[2]{#1\hspace{0.025in}\bestmodecode{#2}}
+\providecommand{\bestmodemix}[1]{\textcolor{ReportBlue}{\texttt{[#1]}}}
+\clearpage
+\subsection{Built-in SM best measured mode versus AmpliCol: full-colour}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM best measured mode versus AmpliCol full-colour (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.00}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize The candidate is selected independently in each cell and workload by the smallest validated wall time. The upper row is generation in seconds and the lower row is runtime in \(\mu\mathrm{s}/\mathrm{pt}\). In LC cells, each pair is non-union-flow \texttt{|} union-flow. Generation multipliers are coloured directly. Each runtime workload uses \texttt{([xS]xW)}. The muted supplementary xS first compares compatible exposed execution attributions; otherwise it uses authenticated evaluator totals. Because original AmpliCol exposes no evaluator-total clock, a candidate total then uses the AmpliCol direct execution clock, or its wall clock when direct execution is absent, as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; execution/execution remains the compatible supplementary attribution. The coloured xW is always the candidate/AmpliCol wall-time multiplier used for selection and as the primary figure of merit. If no compatible supplementary clock exists, only \texttt{(xW)} is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original-AmpliCol rows beyond its three-open-quark-line scope are catalog static N/A entries; their candidates are shown absolutely and excluded from ratio summaries. Unavailable baselines keep their status; candidates remain absolute. Unverified compiled, eager, or on-the-fly diagnostics are never eligible for best-mode selection or summaries and remain visibly marked unverified. OTF \texttt{([xG]x(G+W))} follows the enclosing contracted cold-start contract. Only exact stored same-point links enter ratios. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation is non-union only; LC runtime retains separate non-union and union wall-only lines. Muted generation-row codes (r)|(c)|(e)|(o) identify recurrence JIT O2, compiled JIT O3, eager-DAG JIT O2, and on-the-fly JIT O2 wall-time winners; runtime rows omit them. Summary mode counts use r|c|e|o in the same order.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM best measured mode versus AmpliCol full-colour (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.00}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize The candidate is selected independently in each cell and workload by the smallest validated wall time. The upper row is generation in seconds and the lower row is runtime in \(\mu\mathrm{s}/\mathrm{pt}\). In LC cells, each pair is non-union-flow \texttt{|} union-flow. Generation multipliers are coloured directly. Each runtime workload uses \texttt{([xS]xW)}. The muted supplementary xS first compares compatible exposed execution attributions; otherwise it uses authenticated evaluator totals. Because original AmpliCol exposes no evaluator-total clock, a candidate total then uses the AmpliCol direct execution clock, or its wall clock when direct execution is absent, as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; execution/execution remains the compatible supplementary attribution. The coloured xW is always the candidate/AmpliCol wall-time multiplier used for selection and as the primary figure of merit. If no compatible supplementary clock exists, only \texttt{(xW)} is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original-AmpliCol rows beyond its three-open-quark-line scope are catalog static N/A entries; their candidates are shown absolutely and excluded from ratio summaries. Unavailable baselines keep their status; candidates remain absolute. Unverified compiled, eager, or on-the-fly diagnostics are never eligible for best-mode selection or summaries and remain visibly marked unverified. OTF \texttt{([xG]x(G+W))} follows the enclosing contracted cold-start contract. Only exact stored same-point links enter ratios. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation is non-union only; LC runtime retains separate non-union and union wall-only lines. Muted generation-row codes (r)|(c)|(e)|(o) identify recurrence JIT O2, compiled JIT O3, eager-DAG JIT O2, and on-the-fly JIT O2 wall-time winners; runtime rows omit them. Summary mode counts use r|c|e|o in the same order.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_best_builtin_sm_lc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_best_builtin_sm_lc_table.tex
new file mode 100644
index 0000000000..da9fedbcb0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_best_builtin_sm_lc_table.tex
@@ -0,0 +1,296 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\providecommand{\bestmodecode}[1]{\textcolor{ReportMuted}{\texttt{(#1)}}}
+\providecommand{\bestmodecodeprefix}[1]{\bestmodecode{#1}\hspace{0.025in}}
+\providecommand{\bestmodeabsolutechoice}[2]{#1\hspace{0.025in}\bestmodecode{#2}}
+\providecommand{\bestmodemix}[1]{\textcolor{ReportBlue}{\texttt{[#1]}}}
+\clearpage
+\subsection{Built-in SM best measured mode versus AmpliCol: LC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM best measured mode versus AmpliCol LC (block 1 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.00}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} & \multicolumn{8}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize The candidate is selected independently in each cell and workload by the smallest validated wall time. The upper row is generation in seconds and the lower row is runtime in \(\mu\mathrm{s}/\mathrm{pt}\). In LC cells, each pair is non-union-flow \texttt{|} union-flow. Generation multipliers are coloured directly. Each runtime workload uses \texttt{([xS]xW)}. The muted supplementary xS first compares compatible exposed execution attributions; otherwise it uses authenticated evaluator totals. Because original AmpliCol exposes no evaluator-total clock, a candidate total then uses the AmpliCol direct execution clock, or its wall clock when direct execution is absent, as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; execution/execution remains the compatible supplementary attribution. The coloured xW is always the candidate/AmpliCol wall-time multiplier used for selection and as the primary figure of merit. If no compatible supplementary clock exists, only \texttt{(xW)} is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original-AmpliCol rows beyond its three-open-quark-line scope are catalog static N/A entries; their candidates are shown absolutely and excluded from ratio summaries. Unavailable baselines keep their status; candidates remain absolute. Unverified compiled, eager, or on-the-fly diagnostics are never eligible for best-mode selection or summaries and remain visibly marked unverified. For the LC all-flow workload, AmpliCol direct-evaluation setup and pyAmpliCol process generation have different boundaries, so the candidate generation value is shown absolutely; no misleading multiplier is formed. OTF \texttt{([xG]x(G+W)) | [G]G+W} follows the enclosing cold-start contract. Only exact stored same-point links enter ratios. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation is non-union only; LC runtime retains separate non-union and union wall-only lines. Muted generation-row codes (r)|(c)|(e)|(o) identify recurrence JIT O2, compiled JIT O3, eager-DAG JIT O2, and on-the-fly JIT O2 wall-time winners; runtime rows omit them. Summary mode counts use r|c|e|o in the same order.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM best measured mode versus AmpliCol LC (block 2 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.00}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=4}} & \multicolumn{8}{c}{\textbf{n=5}} & \multicolumn{8}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{8}{c}{\textbf{n=5}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize The candidate is selected independently in each cell and workload by the smallest validated wall time. The upper row is generation in seconds and the lower row is runtime in \(\mu\mathrm{s}/\mathrm{pt}\). In LC cells, each pair is non-union-flow \texttt{|} union-flow. Generation multipliers are coloured directly. Each runtime workload uses \texttt{([xS]xW)}. The muted supplementary xS first compares compatible exposed execution attributions; otherwise it uses authenticated evaluator totals. Because original AmpliCol exposes no evaluator-total clock, a candidate total then uses the AmpliCol direct execution clock, or its wall clock when direct execution is absent, as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; execution/execution remains the compatible supplementary attribution. The coloured xW is always the candidate/AmpliCol wall-time multiplier used for selection and as the primary figure of merit. If no compatible supplementary clock exists, only \texttt{(xW)} is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original-AmpliCol rows beyond its three-open-quark-line scope are catalog static N/A entries; their candidates are shown absolutely and excluded from ratio summaries. Unavailable baselines keep their status; candidates remain absolute. Unverified compiled, eager, or on-the-fly diagnostics are never eligible for best-mode selection or summaries and remain visibly marked unverified. For the LC all-flow workload, AmpliCol direct-evaluation setup and pyAmpliCol process generation have different boundaries, so the candidate generation value is shown absolutely; no misleading multiplier is formed. OTF \texttt{([xG]x(G+W)) | [G]G+W} follows the enclosing cold-start contract. Only exact stored same-point links enter ratios. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation is non-union only; LC runtime retains separate non-union and union wall-only lines. Muted generation-row codes (r)|(c)|(e)|(o) identify recurrence JIT O2, compiled JIT O3, eager-DAG JIT O2, and on-the-fly JIT O2 wall-time winners; runtime rows omit them. Summary mode counts use r|c|e|o in the same order.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM best measured mode versus AmpliCol LC (block 3 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.00}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=7}} & \multicolumn{8}{c}{\textbf{n=8}} & \multicolumn{8}{c}{\textbf{n=9}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=7}} & \multicolumn{8}{c}{\textbf{n=8}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=9}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize The candidate is selected independently in each cell and workload by the smallest validated wall time. The upper row is generation in seconds and the lower row is runtime in \(\mu\mathrm{s}/\mathrm{pt}\). In LC cells, each pair is non-union-flow \texttt{|} union-flow. Generation multipliers are coloured directly. Each runtime workload uses \texttt{([xS]xW)}. The muted supplementary xS first compares compatible exposed execution attributions; otherwise it uses authenticated evaluator totals. Because original AmpliCol exposes no evaluator-total clock, a candidate total then uses the AmpliCol direct execution clock, or its wall clock when direct execution is absent, as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; execution/execution remains the compatible supplementary attribution. The coloured xW is always the candidate/AmpliCol wall-time multiplier used for selection and as the primary figure of merit. If no compatible supplementary clock exists, only \texttt{(xW)} is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original-AmpliCol rows beyond its three-open-quark-line scope are catalog static N/A entries; their candidates are shown absolutely and excluded from ratio summaries. Unavailable baselines keep their status; candidates remain absolute. Unverified compiled, eager, or on-the-fly diagnostics are never eligible for best-mode selection or summaries and remain visibly marked unverified. For the LC all-flow workload, AmpliCol direct-evaluation setup and pyAmpliCol process generation have different boundaries, so the candidate generation value is shown absolutely; no misleading multiplier is formed. OTF \texttt{([xG]x(G+W)) | [G]G+W} follows the enclosing cold-start contract. Only exact stored same-point links enter ratios. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation is non-union only; LC runtime retains separate non-union and union wall-only lines. Muted generation-row codes (r)|(c)|(e)|(o) identify recurrence JIT O2, compiled JIT O3, eager-DAG JIT O2, and on-the-fly JIT O2 wall-time winners; runtime rows omit them. Summary mode counts use r|c|e|o in the same order.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_best_builtin_sm_nlc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_best_builtin_sm_nlc_table.tex
new file mode 100644
index 0000000000..083155fcda
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_best_builtin_sm_nlc_table.tex
@@ -0,0 +1,212 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\providecommand{\bestmodecode}[1]{\textcolor{ReportMuted}{\texttt{(#1)}}}
+\providecommand{\bestmodecodeprefix}[1]{\bestmodecode{#1}\hspace{0.025in}}
+\providecommand{\bestmodeabsolutechoice}[2]{#1\hspace{0.025in}\bestmodecode{#2}}
+\providecommand{\bestmodemix}[1]{\textcolor{ReportBlue}{\texttt{[#1]}}}
+\clearpage
+\subsection{Built-in SM best measured mode versus AmpliCol: NLC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM best measured mode versus AmpliCol NLC (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.00}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize The candidate is selected independently in each cell and workload by the smallest validated wall time. The upper row is generation in seconds and the lower row is runtime in \(\mu\mathrm{s}/\mathrm{pt}\). In LC cells, each pair is non-union-flow \texttt{|} union-flow. Generation multipliers are coloured directly. Each runtime workload uses \texttt{([xS]xW)}. The muted supplementary xS first compares compatible exposed execution attributions; otherwise it uses authenticated evaluator totals. Because original AmpliCol exposes no evaluator-total clock, a candidate total then uses the AmpliCol direct execution clock, or its wall clock when direct execution is absent, as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; execution/execution remains the compatible supplementary attribution. The coloured xW is always the candidate/AmpliCol wall-time multiplier used for selection and as the primary figure of merit. If no compatible supplementary clock exists, only \texttt{(xW)} is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original-AmpliCol rows beyond its three-open-quark-line scope are catalog static N/A entries; their candidates are shown absolutely and excluded from ratio summaries. Unavailable baselines keep their status; candidates remain absolute. Unverified compiled, eager, or on-the-fly diagnostics are never eligible for best-mode selection or summaries and remain visibly marked unverified. OTF \texttt{([xG]x(G+W))} follows the enclosing contracted cold-start contract. Only exact stored same-point links enter ratios. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation is non-union only; LC runtime retains separate non-union and union wall-only lines. Muted generation-row codes (r)|(c)|(e)|(o) identify recurrence JIT O2, compiled JIT O3, eager-DAG JIT O2, and on-the-fly JIT O2 wall-time winners; runtime rows omit them. Summary mode counts use r|c|e|o in the same order.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM best measured mode versus AmpliCol NLC (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.00}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize The candidate is selected independently in each cell and workload by the smallest validated wall time. The upper row is generation in seconds and the lower row is runtime in \(\mu\mathrm{s}/\mathrm{pt}\). In LC cells, each pair is non-union-flow \texttt{|} union-flow. Generation multipliers are coloured directly. Each runtime workload uses \texttt{([xS]xW)}. The muted supplementary xS first compares compatible exposed execution attributions; otherwise it uses authenticated evaluator totals. Because original AmpliCol exposes no evaluator-total clock, a candidate total then uses the AmpliCol direct execution clock, or its wall clock when direct execution is absent, as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; execution/execution remains the compatible supplementary attribution. The coloured xW is always the candidate/AmpliCol wall-time multiplier used for selection and as the primary figure of merit. If no compatible supplementary clock exists, only \texttt{(xW)} is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original-AmpliCol rows beyond its three-open-quark-line scope are catalog static N/A entries; their candidates are shown absolutely and excluded from ratio summaries. Unavailable baselines keep their status; candidates remain absolute. Unverified compiled, eager, or on-the-fly diagnostics are never eligible for best-mode selection or summaries and remain visibly marked unverified. OTF \texttt{([xG]x(G+W))} follows the enclosing contracted cold-start contract. Only exact stored same-point links enter ratios. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation is non-union only; LC runtime retains separate non-union and union wall-only lines. Muted generation-row codes (r)|(c)|(e)|(o) identify recurrence JIT O2, compiled JIT O3, eager-DAG JIT O2, and on-the-fly JIT O2 wall-time winners; runtime rows omit them. Summary mode counts use r|c|e|o in the same order.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_builtin_sm_full_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_builtin_sm_full_table.tex
new file mode 100644
index 0000000000..d16f732d53
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_builtin_sm_full_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM compiled JIT O3 versus recurrence JIT O2 full-colour}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM compiled JIT O3 versus recurrence JIT O2 full-colour (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: compiled JIT O3. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM compiled JIT O3 versus recurrence JIT O2 full-colour (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: compiled JIT O3. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_builtin_sm_lc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_builtin_sm_lc_table.tex
new file mode 100644
index 0000000000..732e4545c7
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_builtin_sm_lc_table.tex
@@ -0,0 +1,292 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM compiled JIT O3 versus recurrence JIT O2 LC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM compiled JIT O3 versus recurrence JIT O2 LC (block 1 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} & \multicolumn{8}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: compiled JIT O3. Each cell shows the topology-replay/all-flow-union baseline generation times and wall times, followed by layout-matched candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM compiled JIT O3 versus recurrence JIT O2 LC (block 2 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=4}} & \multicolumn{8}{c}{\textbf{n=5}} & \multicolumn{8}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{8}{c}{\textbf{n=5}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: compiled JIT O3. Each cell shows the topology-replay/all-flow-union baseline generation times and wall times, followed by layout-matched candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM compiled JIT O3 versus recurrence JIT O2 LC (block 3 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=7}} & \multicolumn{8}{c}{\textbf{n=8}} & \multicolumn{8}{c}{\textbf{n=9}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=7}} & \multicolumn{8}{c}{\textbf{n=8}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=9}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: compiled JIT O3. Each cell shows the topology-replay/all-flow-union baseline generation times and wall times, followed by layout-matched candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_builtin_sm_nlc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_builtin_sm_nlc_table.tex
new file mode 100644
index 0000000000..c08b9b2b41
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_builtin_sm_nlc_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM compiled JIT O3 versus recurrence JIT O2 NLC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM compiled JIT O3 versus recurrence JIT O2 NLC (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: compiled JIT O3. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM compiled JIT O3 versus recurrence JIT O2 NLC (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: compiled JIT O3. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_ufo_sm_full_vs_madgraph_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_ufo_sm_full_vs_madgraph_table.tex
new file mode 100644
index 0000000000..fd504db4b3
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_compiled_ufo_sm_full_vs_madgraph_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{UFO-SM compiled JIT O3 versus MadGraph full-colour}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM compiled JIT O3 versus MadGraph full-colour (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: MadGraph standalone; candidate: compiled JIT O3. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. MadGraph standalone is the authoritative full-colour numerical reference; its generation and repeated-evaluation measurements are shared by all four UFO-SM comparison views. Recurrence, compiled, and eager candidates use p200 at the comparison point; the on-the-fly candidate uses its supported p16 lane. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM compiled JIT O3 versus MadGraph full-colour (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: MadGraph standalone; candidate: compiled JIT O3. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. MadGraph standalone is the authoritative full-colour numerical reference; its generation and repeated-evaluation measurements are shared by all four UFO-SM comparison views. Recurrence, compiled, and eager candidates use p200 at the comparison point; the on-the-fly candidate uses its supported p16 lane. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_builtin_sm_full_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_builtin_sm_full_table.tex
new file mode 100644
index 0000000000..a8494ee036
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_builtin_sm_full_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM eager-DAG JIT O2 versus recurrence JIT O2 full-colour}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM eager-DAG JIT O2 versus recurrence JIT O2 full-colour (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: eager-DAG JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM eager-DAG JIT O2 versus recurrence JIT O2 full-colour (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: eager-DAG JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_builtin_sm_lc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_builtin_sm_lc_table.tex
new file mode 100644
index 0000000000..2002ea40d2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_builtin_sm_lc_table.tex
@@ -0,0 +1,292 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM eager-DAG JIT O2 versus recurrence JIT O2 LC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM eager-DAG JIT O2 versus recurrence JIT O2 LC (block 1 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} & \multicolumn{8}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: eager-DAG JIT O2. Each cell shows the topology-replay/all-flow-union baseline generation times and wall times, followed by layout-matched candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM eager-DAG JIT O2 versus recurrence JIT O2 LC (block 2 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=4}} & \multicolumn{8}{c}{\textbf{n=5}} & \multicolumn{8}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{8}{c}{\textbf{n=5}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: eager-DAG JIT O2. Each cell shows the topology-replay/all-flow-union baseline generation times and wall times, followed by layout-matched candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM eager-DAG JIT O2 versus recurrence JIT O2 LC (block 3 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=7}} & \multicolumn{8}{c}{\textbf{n=8}} & \multicolumn{8}{c}{\textbf{n=9}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=7}} & \multicolumn{8}{c}{\textbf{n=8}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=9}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: eager-DAG JIT O2. Each cell shows the topology-replay/all-flow-union baseline generation times and wall times, followed by layout-matched candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_builtin_sm_nlc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_builtin_sm_nlc_table.tex
new file mode 100644
index 0000000000..1e0fd55100
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_builtin_sm_nlc_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM eager-DAG JIT O2 versus recurrence JIT O2 NLC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM eager-DAG JIT O2 versus recurrence JIT O2 NLC (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: eager-DAG JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM eager-DAG JIT O2 versus recurrence JIT O2 NLC (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: recurrence JIT O2; candidate: eager-DAG JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_ufo_sm_full_vs_madgraph_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_ufo_sm_full_vs_madgraph_table.tex
new file mode 100644
index 0000000000..3fcb7c1aca
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_eager_ufo_sm_full_vs_madgraph_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{UFO-SM eager-DAG JIT O2 versus MadGraph full-colour}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM eager-DAG JIT O2 versus MadGraph full-colour (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: MadGraph standalone; candidate: eager-DAG JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. MadGraph standalone is the authoritative full-colour numerical reference; its generation and repeated-evaluation measurements are shared by all four UFO-SM comparison views. Recurrence, compiled, and eager candidates use p200 at the comparison point; the on-the-fly candidate uses its supported p16 lane. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM eager-DAG JIT O2 versus MadGraph full-colour (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: MadGraph standalone; candidate: eager-DAG JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. MadGraph standalone is the authoritative full-colour numerical reference; its generation and repeated-evaluation measurements are shared by all four UFO-SM comparison views. Recurrence, compiled, and eager candidates use p200 at the comparison point; the on-the-fly candidate uses its supported p16 lane. Unverified compiled or eager diagnostics show absolute generation and runtime values with a yellow unverified marker, but never enter ratios or summaries. In their runtime token the muted bracketed value is evaluator-total and the following value is outer wall time. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_builtin_sm_full_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_builtin_sm_full_table.tex
new file mode 100644
index 0000000000..d7752ffdf6
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_builtin_sm_full_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM on-the-fly JIT O2 versus AmpliCol full-colour}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM on-the-fly JIT O2 versus AmpliCol full-colour (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: on-the-fly JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM on-the-fly JIT O2 versus AmpliCol full-colour (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: on-the-fly JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_builtin_sm_lc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_builtin_sm_lc_table.tex
new file mode 100644
index 0000000000..5c2aa0a1bd
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_builtin_sm_lc_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM on-the-fly JIT O2 versus AmpliCol LC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM on-the-fly JIT O2 versus AmpliCol LC (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.00}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: on-the-fly JIT O2. Each cell shows non-union-flow and union-flow quantities. For non-union flow, generation is ([xG] x(G+W)): the muted inner multiplier is artifact generation G alone and the normally coloured outer multiplier adds exactly the first cold on-the-fly evaluation W, both relative to AmpliCol selected-flow generation. For union flow, generation is the absolute [G] G+W pair, with G muted and G+W in normal black. W excludes artifact loading and conventional benchmark warm-ups. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM on-the-fly JIT O2 versus AmpliCol LC (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.00}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=3}} & \multicolumn{8}{c}{\textbf{n=4}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=3}} & \multicolumn{8}{c}{\textbf{n=4}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: on-the-fly JIT O2. Each cell shows non-union-flow and union-flow quantities. For non-union flow, generation is ([xG] x(G+W)): the muted inner multiplier is artifact generation G alone and the normally coloured outer multiplier adds exactly the first cold on-the-fly evaluation W, both relative to AmpliCol selected-flow generation. For union flow, generation is the absolute [G] G+W pair, with G muted and G+W in normal black. W excludes artifact loading and conventional benchmark warm-ups. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_builtin_sm_nlc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_builtin_sm_nlc_table.tex
new file mode 100644
index 0000000000..8daf768bf4
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_builtin_sm_nlc_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM on-the-fly JIT O2 versus AmpliCol NLC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM on-the-fly JIT O2 versus AmpliCol NLC (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: on-the-fly JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM on-the-fly JIT O2 versus AmpliCol NLC (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: on-the-fly JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_ufo_sm_full_vs_madgraph_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_ufo_sm_full_vs_madgraph_table.tex
new file mode 100644
index 0000000000..ba6f691dd1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_on_the_fly_ufo_sm_full_vs_madgraph_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{UFO-SM on-the-fly JIT O2 versus MadGraph full-colour}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM on-the-fly JIT O2 versus MadGraph full-colour (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: MadGraph standalone; candidate: on-the-fly JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. MadGraph standalone is the authoritative full-colour numerical reference; its generation and repeated-evaluation measurements are shared by all four UFO-SM comparison views. Recurrence, compiled, and eager candidates use p200 at the comparison point; the on-the-fly candidate uses its supported p16 lane. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM on-the-fly JIT O2 versus MadGraph full-colour (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: MadGraph standalone; candidate: on-the-fly JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. MadGraph standalone is the authoritative full-colour numerical reference; its generation and repeated-evaluation measurements are shared by all four UFO-SM comparison views. Recurrence, compiled, and eager candidates use p200 at the comparison point; the on-the-fly candidate uses its supported p16 lane. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_builtin_sm_full_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_builtin_sm_full_table.tex
new file mode 100644
index 0000000000..14e6163be3
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_builtin_sm_full_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM recurrence versus AmpliCol full-colour}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM recurrence versus AmpliCol full-colour (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM recurrence versus AmpliCol full-colour (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_builtin_sm_lc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_builtin_sm_lc_table.tex
new file mode 100644
index 0000000000..5be1fb8d19
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_builtin_sm_lc_table.tex
@@ -0,0 +1,292 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM recurrence versus AmpliCol LC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM recurrence versus AmpliCol LC (block 1 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} & \multicolumn{8}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the selected-flow library-generation and all-flow direct-setup baseline quantities. The selected-flow entry carries a generation ratio; the all-flow entry carries the absolute pyAmpliCol process-generation time. Its setup boundary differs from the reference, so no generation ratio is formed. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM recurrence versus AmpliCol LC (block 2 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=4}} & \multicolumn{8}{c}{\textbf{n=5}} & \multicolumn{8}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{8}{c}{\textbf{n=5}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the selected-flow library-generation and all-flow direct-setup baseline quantities. The selected-flow entry carries a generation ratio; the all-flow entry carries the absolute pyAmpliCol process-generation time. Its setup boundary differs from the reference, so no generation ratio is formed. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM recurrence versus AmpliCol LC (block 3 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=7}} & \multicolumn{8}{c}{\textbf{n=8}} & \multicolumn{8}{c}{\textbf{n=9}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=7}} & \multicolumn{8}{c}{\textbf{n=8}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=9}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the selected-flow library-generation and all-flow direct-setup baseline quantities. The selected-flow entry carries a generation ratio; the all-flow entry carries the absolute pyAmpliCol process-generation time. Its setup boundary differs from the reference, so no generation ratio is formed. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_builtin_sm_nlc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_builtin_sm_nlc_table.tex
new file mode 100644
index 0000000000..edd2ff8e12
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_builtin_sm_nlc_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{Built-in SM recurrence versus AmpliCol NLC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM recurrence versus AmpliCol NLC (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM recurrence versus AmpliCol NLC (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_full_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_full_table.tex
new file mode 100644
index 0000000000..2a5ddbcb6a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_full_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{UFO-SM recurrence versus AmpliCol full-colour}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM recurrence versus AmpliCol full-colour (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM recurrence versus AmpliCol full-colour (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_full_vs_madgraph_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_full_vs_madgraph_table.tex
new file mode 100644
index 0000000000..af6e00faf9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_full_vs_madgraph_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{UFO-SM recurrence JIT O2 versus MadGraph full-colour}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM recurrence JIT O2 versus MadGraph full-colour (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: MadGraph standalone; candidate: recurrence JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. MadGraph standalone is the authoritative full-colour numerical reference; its generation and repeated-evaluation measurements are shared by all four UFO-SM comparison views. Recurrence, compiled, and eager candidates use p200 at the comparison point; the on-the-fly candidate uses its supported p16 lane. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM recurrence JIT O2 versus MadGraph full-colour (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: MadGraph standalone; candidate: recurrence JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. MadGraph standalone is the authoritative full-colour numerical reference; its generation and repeated-evaluation measurements are shared by all four UFO-SM comparison views. Recurrence, compiled, and eager candidates use p200 at the comparison point; the on-the-fly candidate uses its supported p16 lane. Ratios and summaries require exact stored linkage to the current denominator. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_lc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_lc_table.tex
new file mode 100644
index 0000000000..13ea78895d
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_lc_table.tex
@@ -0,0 +1,292 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{UFO-SM recurrence versus AmpliCol LC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM recurrence versus AmpliCol LC (block 1 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} & \multicolumn{8}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{8}{c}{\textbf{n=2}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the selected-flow library-generation and all-flow direct-setup baseline quantities. The selected-flow entry carries a generation ratio; the all-flow entry carries the absolute pyAmpliCol process-generation time. Its setup boundary differs from the reference, so no generation ratio is formed. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM recurrence versus AmpliCol LC (block 2 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=4}} & \multicolumn{8}{c}{\textbf{n=5}} & \multicolumn{8}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{8}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{8}{c}{} & \multicolumn{8}{c}{} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{8}{c}{\textbf{n=5}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the selected-flow library-generation and all-flow direct-setup baseline quantities. The selected-flow entry carries a generation ratio; the all-flow entry carries the absolute pyAmpliCol process-generation time. Its setup boundary differs from the reference, so no generation ratio is formed. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM recurrence versus AmpliCol LC (block 3 of 3)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}l>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l>{\matrixentryfontlc}c>{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{8}{c}{\textbf{n=7}} & \multicolumn{8}{c}{\textbf{n=8}} & \multicolumn{8}{c}{\textbf{n=9}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstaticna{ReportMuted} & \matrixpunct{|} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixpunct{|} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=7}} & \multicolumn{8}{c}{\textbf{n=8}} & \multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=9}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{8}{c}{\matrixna{ReportMuted}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\matrixsummaryworkloads{\textbf{summary: run single-flow, hel. sum}}{\textbf{summary: run all-flows, single hel.}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} & \multicolumn{8}{c}{\cellcolor{refblue}\matrixsummaryworkloads{\matrixna{ReportMuted}}{\matrixna{ReportMuted}}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the selected-flow library-generation and all-flow direct-setup baseline quantities. The selected-flow entry carries a generation ratio; the all-flow entry carries the absolute pyAmpliCol process-generation time. Its setup boundary differs from the reference, so no generation ratio is formed. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums and is the framed bold entry. LC generation uses selected flow only, while LC runtime shows separate selected-flow and all-flow wall-only lines. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_nlc_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_nlc_table.tex
new file mode 100644
index 0000000000..59add0555e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_matrix_recurrence_ufo_sm_nlc_table.tex
@@ -0,0 +1,208 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\providecommand{\matrixpair}[2]{\begin{tabular}[t]{@{}r@{\hspace{0.025in}\matrixpunct{|}\hspace{0.025in}}r@{}}#1&#2\end{tabular}}
+\providecommand{\bestmoderatio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\bestmodecompactratio}[3]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}\textcolor{#2}{\texttt{x#3}}\matrixpunct{)}}
+\providecommand{\bestmodewallratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodecompactprefix}[1]{\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeopenprefix}{\matrixpunct{(}\hspace{0.04in}}
+\providecommand{\bestmodeprimaryratio}[2]{\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\bestmodeabsoluteprefix}[1]{#1\hspace{0.04in}}
+\providecommand{\bestmodecompactabsolute}[2]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}\textcolor{black}{\texttt{#2}}}
+\providecommand{\bestmodecompactabsoluteprefix}[1]{\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}
+\providecommand{\bestmodeabsoluteprimary}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\bestmodeunverifiedclockprefix}[2]{\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}\hspace{0.04in}#2\hspace{0.04in}}
+\clearpage
+\subsection{UFO-SM recurrence versus AmpliCol NLC}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM recurrence versus AmpliCol NLC (block 1 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\textbf{n=3}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=1}} & \multicolumn{3}{c}{\textbf{n=2}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=3}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM recurrence versus AmpliCol NLC (block 2 of 2)}
+\begingroup
+\centering
+\footnotesize
+\setlength{\tabcolsep}{2.1pt}
+\renewcommand{\arraystretch}{1.04}
+\matrixfitwidth{%
+\begin{tabular}{@{}rL{1.45in}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l>{\matrixentryfont}l>{\matrixentryfont}r@{}>{\matrixentryfont}l@{}}
+\toprule
+\textbf{ID} & \textbf{base process} & \textbf{metric} & \multicolumn{3}{c}{\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\textbf{n=6}} \\
+\specialrule{0.85pt}{0pt}{0pt}
+\rowcolor{refblue}
+\texttt{1} & $d\bar d\to Z+(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{2} & $u\bar d\to W^++(n-1)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{3} & $d\bar d\to e^+e^-+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{4} & $u\bar d\to e^+\nu_e+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{5} & $d\bar d\to ZZ+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{6} & $gg\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{7} & $d\bar d\to t\bar t+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{8} & $gg\to gg+(n-2)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{9} & $d\bar d\to ZZZ+(n-3)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{10} & $d\bar d\to e^+e^-ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{11} & $d\bar d\to t\bar t ZH+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\texttt{12} & $d\bar d\to e^+e^-e^+e^-+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{\matrixstatus{ReportMuted}{not run}} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \multicolumn{3}{c}{} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{13} & $d\bar d\to u\bar u\,s\bar s+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\texttt{14} & $d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \multicolumn{3}{c}{\matrixnotapplicable{ReportMuted}} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \multicolumn{3}{c}{} & \multicolumn{3}{c}{} & \matrixstaticna{ReportMuted} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\rowcolor{refblue}
+\texttt{15} & $d\bar d\to u\bar u\,u\bar u+(n-4)g$ & \textcolor{ReportMuted}{\scriptsize gen. [s]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+ &  & \textcolor{ReportMuted}{\scriptsize run [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} &  & \matrixstatus{ReportMuted}{N/A} \\
+\addlinespace[0.05em]
+\specialrule{1.05pt}{0.22em}{0.18em}
+\multicolumn{3}{@{}l}{} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=4}} & \multicolumn{3}{c}{\textbf{n=5}} & \multicolumn{3}{c}{\cellcolor{refblue}\textbf{n=6}} \\
+\multicolumn{3}{@{}l}{\textbf{summary: generation}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\[0.08em]
+\multicolumn{3}{@{}l}{\textbf{summary: wall}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} & \multicolumn{3}{c}{\matrixna{ReportMuted}} & \multicolumn{3}{c}{\cellcolor{refblue}\matrixna{ReportMuted}} \\
+\bottomrule
+\end{tabular}
+}
+\endgroup
+\ReportTableNote{{\scriptsize Baseline: original AmpliCol; candidate: recurrence JIT O2. Each cell shows the baseline generation and wall time, followed by candidate/baseline generation and wall-time ratios. Runtime comparisons use ([xS]xW). The muted supplementary xS first compares compatible exposed execution attributions; otherwise it compares authenticated evaluator totals. Only when original AmpliCol has no evaluator-total clock may a candidate evaluator total use the legacy direct execution clock (or its wall clock when direct execution is absent) as denominator. An evaluator total is never divided by a recurrence core. This evaluator-total fallback is diagnostic only; the execution/execution ratio remains the compatible supplementary attribution. The coloured xW is always the candidate/baseline wall multiplier and remains the primary figure of merit. When no compatible supplementary clock exists, only (xW) is shown. No clock is fabricated from another. Every displayed number uses exactly three significant digits. Original AmpliCol is static N/A beyond three open quark lines; unavailable, terminal, or unlinked baselines keep their status while successful candidate timings remain absolute and leave summaries. Summary rows contain multipliers only in min, max, median, average, and weighted-average order; the weighted average is the ratio of timing sums, is the framed bold entry, and runtime statistics use wall time only. Not applicable marks a multiplicity for which the process family does not exist. Not run marks an otherwise defined process that was intentionally excluded from the declared measurement scope. Fixed-engine tables intentionally omit mode letters because the selected engine is named in the table heading.}}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_scalar_contact_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_scalar_contact_table.tex
new file mode 100644
index 0000000000..f50d770db7
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_scalar_contact_table.tex
@@ -0,0 +1,51 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\subsection{Scalar-contact ladder}
+\begingroup
+\scriptsize
+\setlength{\tabcolsep}{2.2pt}
+\renewcommand{\arraystretch}{1.10}
+\begin{center}
+\begin{tabular}{@{}L{1.00in}L{0.72in}L{0.72in}L{0.72in}L{0.72in}L{0.72in}L{0.72in}L{0.72in}@{}}
+\toprule
+\multicolumn{8}{c}{\texttt{scalar\_0 scalar\_0 > n*scalar\_0}} \\
+\textbf{metric} & \textbf{\texttt{n=2}} & \textbf{\texttt{n=3}} & \textbf{\texttt{n=4}} & \textbf{\texttt{n=5}} & \textbf{\texttt{n=6}} & \textbf{\texttt{n=7}} & \textbf{\texttt{n=8}} \\
+\midrule
+\rowcolor{refblue}
+generation [s] & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+wall [\(\mu\mathrm{s}/\mathrm{pt}\)] & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+{\fontsize{6.4pt}{7.4pt}\selectfont\mbox{evaluator total [\(\mu\mathrm{s}/\mathrm{pt}\)]}} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+matrix element & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportOrange!8}
+relative diff. vs hp & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\bottomrule
+\end{tabular}
+\end{center}
+\endgroup
+\ReportTableNote{Wall time is the common runtime observable. Evaluator total is the independently measured accumulated warmed evaluator clock from its dedicated authenticated record; it is never copied from or derived from wall time. Unverified diagnostics retain absolute generation, wall, and evaluator clocks with a yellow marker; they are not successes. \textsc{not exposed} denotes a successful wall measurement, and older entries without dedicated evaluator-total evidence remain valid; it does not denote a missing result.}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_scalar_gravity_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_scalar_gravity_table.tex
new file mode 100644
index 0000000000..a47239c5af
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_scalar_gravity_table.tex
@@ -0,0 +1,51 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\subsection{Scalar-gravity ladder}
+\begingroup
+\scriptsize
+\setlength{\tabcolsep}{3.2pt}
+\renewcommand{\arraystretch}{1.10}
+\begin{center}
+\begin{tabular}{@{}L{1.08in}L{0.82in}L{0.82in}L{0.82in}@{}}
+\toprule
+\multicolumn{4}{c}{\texttt{scalar\_0 scalar\_0 > n*graviton}} \\
+\textbf{metric} & \textbf{\texttt{n=2}} & \textbf{\texttt{n=3}} & \textbf{\texttt{n=4}} \\
+\midrule
+\rowcolor{refblue}
+generation [s] & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+wall [\(\mu\mathrm{s}/\mathrm{pt}\)] & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{refblue}
+{\fontsize{6.4pt}{7.4pt}\selectfont\mbox{evaluator total [\(\mu\mathrm{s}/\mathrm{pt}\)]}} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+matrix element & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportOrange!8}
+relative diff. vs hp & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\bottomrule
+\end{tabular}
+\end{center}
+\endgroup
+\ReportTableNote{Wall time is the common runtime observable. Evaluator total is the independently measured accumulated warmed evaluator clock from its dedicated authenticated record; it is never copied from or derived from wall time. Unverified diagnostics retain absolute generation, wall, and evaluator clocks with a yellow marker; they are not successes. \textsc{not exposed} denotes a successful wall measurement, and older entries without dedicated evaluator-total evidence remain valid; it does not denote a missing result.}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_tables.py b/pyamplicol/src/pyamplicol/_profiling_campaign/result_tables.py
new file mode 100644
index 0000000000..b8e6c811a0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_tables.py
@@ -0,0 +1,711 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Compatibility entry point for the performance-report service."""
+
+from __future__ import annotations
+
+import importlib.machinery
+import json
+import os
+import subprocess
+import sys
+import sysconfig
+import tempfile
+import uuid
+from pathlib import Path
+
+_EXACT_REEXEC_MARKER = "PYAMPLICOL_EXACT_PYTHON_REEXEC"
+_EXACT_IMPORT_PATHS = "PYAMPLICOL_EXACT_IMPORT_PATHS"
+_PUBLICATION_ONLY_COMMANDS = {
+    "init-profile",
+    "export-profile",
+    "validate",
+    "audit",
+    "audit-source-bridge",
+    "reset",
+    "render",
+    "recover",
+    "publish-snapshot",
+    "validate-snapshot",
+    "snapshot-cell-boundary",
+    "accept-cell-boundary",
+}
+_GLOBAL_OPTIONS_WITH_VALUE = {
+    "--repo-root",
+    "--report-profile",
+    "--docs-dir",
+    "--artifact-root",
+    "--coordination-root",
+    "--class-c-ancestor-runtime-root",
+    "--measurement-source-root",
+    "--expected-measurement-source-revision",
+    "--expected-measurement-source-tree",
+    "--expected-policy-wrapper-revision",
+    "--expected-policy-wrapper-tree",
+    "--expected-policy-entrypoint-sha256",
+    "--expected-legacy-adapter-sha256",
+    "--study-contract-sha256",
+}
+
+
+def _repository_root(entrypoint: Path) -> Path:
+    for candidate in entrypoint.parents:
+        if (
+            (candidate / "tools/performance_report").is_dir()
+            and (candidate / "src/pyamplicol").is_dir()
+        ):
+            return candidate
+    raise RuntimeError(
+        "result_tables.py must run from a pyAmpliCol source checkout"
+    )
+
+
+def _embedded_profile(entrypoint: Path, repo_root: Path) -> str | None:
+    profile_parent = repo_root / "docs/performance_reports"
+    try:
+        relative = entrypoint.parent.relative_to(profile_parent)
+    except ValueError:
+        return None
+    return relative.parts[0] if len(relative.parts) == 1 else None
+
+
+def _has_option(arguments: list[str], option: str) -> bool:
+    return any(
+        argument == option or argument.startswith(f"{option}=")
+        for argument in arguments
+    )
+
+
+def _subcommand(arguments: list[str]) -> str | None:
+    offset = 0
+    while offset < len(arguments):
+        argument = arguments[offset]
+        if argument in _GLOBAL_OPTIONS_WITH_VALUE:
+            offset += 2
+            continue
+        if any(
+            argument.startswith(f"{option}=")
+            for option in _GLOBAL_OPTIONS_WITH_VALUE
+        ):
+            offset += 1
+            continue
+        if argument.startswith("-"):
+            offset += 1
+            continue
+        return argument
+    return None
+
+
+def _option_path(arguments: list[str], option: str) -> Path | None:
+    """Read one early bootstrap path option without importing the CLI."""
+
+    values: list[str] = []
+    offset = 0
+    while offset < len(arguments):
+        argument = arguments[offset]
+        if argument == option:
+            if offset + 1 >= len(arguments):
+                raise RuntimeError(f"{option} requires one absolute path")
+            values.append(arguments[offset + 1])
+            offset += 2
+            continue
+        prefix = f"{option}="
+        if argument.startswith(prefix):
+            values.append(argument[len(prefix) :])
+        offset += 1
+    if not values:
+        return None
+    if len(values) != 1:
+        raise RuntimeError(f"{option} must be specified exactly once")
+    path = Path(values[0])
+    if not path.is_absolute():
+        raise RuntimeError(f"{option} must be an absolute path")
+    try:
+        root = path.resolve(strict=True)
+    except OSError as error:
+        raise RuntimeError(f"{option} is unavailable") from error
+    if not (root / "src/pyamplicol").is_dir():
+        raise RuntimeError(f"{option} has no pyamplicol source package")
+    return root
+
+
+def _option_value(arguments: list[str], option: str) -> str | None:
+    """Read one exact early-bootstrap value without importing the CLI."""
+
+    values: list[str] = []
+    offset = 0
+    while offset < len(arguments):
+        argument = arguments[offset]
+        if argument == option:
+            if offset + 1 >= len(arguments):
+                raise RuntimeError(f"{option} requires one value")
+            values.append(arguments[offset + 1])
+            offset += 2
+            continue
+        prefix = f"{option}="
+        if argument.startswith(prefix):
+            values.append(argument[len(prefix) :])
+        offset += 1
+    if not values:
+        return None
+    if len(values) != 1 or not values[0]:
+        raise RuntimeError(f"{option} must be specified exactly once")
+    return values[0]
+
+
+def _git_value(root: Path, expression: str) -> str:
+    completed = subprocess.run(
+        ("git", "-C", str(root), "rev-parse", expression),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    value = completed.stdout.strip()
+    if (
+        completed.returncode != 0
+        or len(value) != 40
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise RuntimeError(
+            f"cannot authenticate worker checkout identity {expression!r}"
+        )
+    return value
+
+
+def _require_git_identity(
+    root: Path,
+    *,
+    revision: str,
+    tree: str,
+    require_clean: bool,
+    require_tracked_clean: bool = False,
+    untracked_source_paths: tuple[str, ...] = (),
+) -> None:
+    if (
+        _git_value(root, "HEAD^{commit}") != revision
+        or _git_value(root, "HEAD^{tree}") != tree
+    ):
+        raise RuntimeError("worker checkout Git identity differs")
+    if require_clean:
+        completed = subprocess.run(
+            (
+                "git",
+                "-C",
+                str(root),
+                "status",
+                "--porcelain=v1",
+                "--untracked-files=all",
+            ),
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if completed.returncode != 0 or completed.stdout:
+            raise RuntimeError("policy-wrapper checkout is not clean")
+    if require_tracked_clean:
+        completed = subprocess.run(
+            (
+                "git",
+                "-C",
+                str(root),
+                "diff",
+                "--quiet",
+                "--no-ext-diff",
+                "HEAD",
+                "--",
+            ),
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if completed.returncode == 1:
+            raise RuntimeError(
+                "measured-source checkout has tracked changes"
+            )
+        if completed.returncode != 0:
+            raise RuntimeError(
+                "cannot inspect measured-source tracked cleanliness"
+            )
+    if untracked_source_paths:
+        completed = subprocess.run(
+            (
+                "git",
+                "-C",
+                str(root),
+                "ls-files",
+                "--others",
+                "--exclude-standard",
+                "-z",
+                "--",
+                *untracked_source_paths,
+            ),
+            check=False,
+            capture_output=True,
+        )
+        if completed.returncode != 0:
+            raise RuntimeError(
+                "cannot inspect measured-source untracked files"
+            )
+        if completed.stdout:
+            raise RuntimeError(
+                "measured-source checkout has untracked files in "
+                "imported source roots"
+            )
+
+
+def _sha256_file(path: Path) -> str:
+    import hashlib
+
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _measured_venv_site_paths(measured_root: Path) -> tuple[Path, ...]:
+    """Recover the measured checkout's venv even under ``-I -S``."""
+
+    expected_venv = measured_root / ".venv"
+    if expected_venv.is_symlink() or not expected_venv.is_dir():
+        raise RuntimeError(
+            "split worker requires a regular measured .venv directory"
+        )
+    venv_root = expected_venv.resolve(strict=True)
+    executable = Path(os.path.abspath(sys.executable))
+    if executable.parent.parent.resolve(strict=True) != venv_root:
+        raise RuntimeError(
+            "split worker interpreter is not the measured .venv interpreter"
+        )
+    configuration = expected_venv / "pyvenv.cfg"
+    if configuration.is_symlink() or not configuration.is_file():
+        raise RuntimeError("measured .venv has no regular pyvenv.cfg")
+    fields: dict[str, str] = {}
+    for line in configuration.read_text(
+        encoding="utf-8",
+        errors="strict",
+    ).splitlines():
+        key, separator, value = line.partition("=")
+        if separator:
+            fields[key.strip().lower()] = value.strip()
+    if fields.get("include-system-site-packages", "").lower() != "false":
+        raise RuntimeError(
+            "measured .venv must exclude system site-packages"
+        )
+
+    variables = dict(sysconfig.get_config_vars())
+    variables.update(
+        {
+            "base": str(venv_root),
+            "platbase": str(venv_root),
+            "installed_base": str(venv_root),
+            "installed_platbase": str(venv_root),
+        }
+    )
+    paths: list[Path] = []
+    for name in ("purelib", "platlib"):
+        value = sysconfig.get_path(name, vars=variables)
+        if not isinstance(value, str):
+            raise RuntimeError(f"measured .venv has no {name} path")
+        candidate = Path(value)
+        try:
+            resolved = candidate.resolve(strict=True)
+            resolved.relative_to(venv_root)
+        except (OSError, ValueError) as error:
+            raise RuntimeError(
+                f"measured .venv {name} path is unavailable"
+            ) from error
+        if resolved not in paths:
+            paths.append(resolved)
+    if not paths:
+        raise RuntimeError("measured .venv has no site-packages path")
+    return tuple(paths)
+
+
+def _native_extensions(package_dir: Path) -> tuple[Path, ...]:
+    try:
+        candidates = tuple(
+            sorted(
+                (
+                    path
+                    for path in package_dir.iterdir()
+                    if path.name.startswith("_rusticol")
+                    and path.name.endswith(
+                        tuple(importlib.machinery.EXTENSION_SUFFIXES)
+                    )
+                ),
+                key=lambda path: path.name,
+            )
+        )
+    except OSError:
+        return ()
+    if any(path.is_symlink() or not path.is_file() for path in candidates):
+        raise RuntimeError(
+            "measured native extension must be a regular file"
+        )
+    return candidates
+
+
+def _measured_split_runtime(
+    measured_root: Path,
+) -> tuple[tuple[Path, ...], Path]:
+    """Return exact venv import roots and one canonical measured native root."""
+
+    site_paths = _measured_venv_site_paths(measured_root)
+    source_package = (measured_root / "src/pyamplicol").resolve(strict=True)
+    package_dirs = (
+        source_package,
+        *(
+            site_path / "pyamplicol"
+            for site_path in site_paths
+            if (site_path / "pyamplicol").is_dir()
+        ),
+    )
+    candidates: list[tuple[Path, Path, str]] = []
+    for package_dir in package_dirs:
+        extensions = _native_extensions(package_dir)
+        if len(extensions) > 1:
+            raise RuntimeError(
+                "measured package has multiple native extension candidates"
+            )
+        if extensions:
+            extension = extensions[0]
+            candidates.append(
+                (package_dir, extension, _sha256_file(extension))
+            )
+    if not candidates:
+        raise RuntimeError(
+            "split worker found no native extension in measured source/venv"
+        )
+    if len({digest for _package, _path, digest in candidates}) != 1:
+        raise RuntimeError(
+            "measured source and venv native extensions differ"
+        )
+    canonical_package = next(
+        (
+            package
+            for package, _path, _digest in candidates
+            if package == source_package
+        ),
+        candidates[0][0],
+    )
+    return site_paths, canonical_package
+
+
+ENTRYPOINT = Path(__file__).resolve()
+REPOSITORY_ROOT = _repository_root(ENTRYPOINT)
+EMBEDDED_PROFILE = _embedded_profile(ENTRYPOINT, REPOSITORY_ROOT)
+ARGUMENTS = list(sys.argv[1:])
+if (
+    EMBEDDED_PROFILE is not None
+    and not _has_option(ARGUMENTS, "--report-profile")
+    and not _has_option(ARGUMENTS, "--docs-dir")
+):
+    ARGUMENTS[:0] = ("--report-profile", EMBEDDED_PROFILE)
+COMMAND = _subcommand(ARGUMENTS)
+CLASS_C_ANCESTOR_RUNTIME_ROOT = _option_path(
+    ARGUMENTS,
+    "--class-c-ancestor-runtime-root",
+)
+MEASUREMENT_SOURCE_ROOT = _option_path(
+    ARGUMENTS,
+    "--measurement-source-root",
+)
+_SPLIT_WORKER_OPTIONS = {
+    "measured_revision": _option_value(
+        ARGUMENTS,
+        "--expected-measurement-source-revision",
+    ),
+    "measured_tree": _option_value(
+        ARGUMENTS,
+        "--expected-measurement-source-tree",
+    ),
+    "wrapper_revision": _option_value(
+        ARGUMENTS,
+        "--expected-policy-wrapper-revision",
+    ),
+    "wrapper_tree": _option_value(
+        ARGUMENTS,
+        "--expected-policy-wrapper-tree",
+    ),
+    "entrypoint_sha256": _option_value(
+        ARGUMENTS,
+        "--expected-policy-entrypoint-sha256",
+    ),
+    "legacy_adapter_sha256": _option_value(
+        ARGUMENTS,
+        "--expected-legacy-adapter-sha256",
+    ),
+    "study_contract_sha256": _option_value(
+        ARGUMENTS,
+        "--study-contract-sha256",
+    ),
+}
+_SPLIT_WORKER_SPECIFIED = (
+    MEASUREMENT_SOURCE_ROOT is not None
+    or any(value is not None for value in _SPLIT_WORKER_OPTIONS.values())
+)
+if _SPLIT_WORKER_SPECIFIED:
+    if MEASUREMENT_SOURCE_ROOT is None or any(
+        value is None for value in _SPLIT_WORKER_OPTIONS.values()
+    ):
+        raise RuntimeError(
+            "split worker wrapper/source options must be specified together"
+        )
+    if COMMAND not in {"_prepare", "_worker"}:
+        raise RuntimeError(
+            "split worker wrapper/source options are restricted to workers"
+        )
+    requested_repo_root = _option_path(ARGUMENTS, "--repo-root")
+    if requested_repo_root != MEASUREMENT_SOURCE_ROOT:
+        raise RuntimeError(
+            "worker --repo-root must equal --measurement-source-root"
+        )
+    measured_revision = str(_SPLIT_WORKER_OPTIONS["measured_revision"])
+    measured_tree = str(_SPLIT_WORKER_OPTIONS["measured_tree"])
+    wrapper_revision = str(_SPLIT_WORKER_OPTIONS["wrapper_revision"])
+    wrapper_tree = str(_SPLIT_WORKER_OPTIONS["wrapper_tree"])
+    _require_git_identity(
+        MEASUREMENT_SOURCE_ROOT,
+        revision=measured_revision,
+        tree=measured_tree,
+        require_clean=False,
+        require_tracked_clean=True,
+        # ``src`` is the measured checkout's only Python import root.
+        untracked_source_paths=("src",),
+    )
+    _require_git_identity(
+        REPOSITORY_ROOT,
+        revision=wrapper_revision,
+        tree=wrapper_tree,
+        require_clean=True,
+    )
+    if _sha256_file(ENTRYPOINT) != _SPLIT_WORKER_OPTIONS[
+        "entrypoint_sha256"
+    ]:
+        raise RuntimeError("policy-wrapper entrypoint digest differs")
+    if _sha256_file(
+        REPOSITORY_ROOT / "tools/performance_report/legacy.py"
+    ) != _SPLIT_WORKER_OPTIONS["legacy_adapter_sha256"]:
+        raise RuntimeError("policy-wrapper legacy adapter digest differs")
+if (
+    CLASS_C_ANCESTOR_RUNTIME_ROOT is not None
+    and COMMAND != "prepare-class-c-bridge"
+):
+    raise RuntimeError(
+        "--class-c-ancestor-runtime-root is restricted to "
+        "prepare-class-c-bridge"
+    )
+RUNTIME_REQUIRED = COMMAND not in _PUBLICATION_ONLY_COMMANDS
+
+
+def _native_package_dir(search_path: object = sys.path) -> Path | None:
+    if not isinstance(search_path, (list, tuple)):
+        raise RuntimeError("Python import path is invalid")
+    for entry in search_path:
+        if not isinstance(entry, str):
+            continue
+        package_dir = Path(entry) / "pyamplicol"
+        try:
+            native = any(
+                path.is_file()
+                and path.name.startswith("_rusticol")
+                and path.name.endswith(tuple(importlib.machinery.EXTENSION_SUFFIXES))
+                for path in package_dir.iterdir()
+            )
+        except OSError:
+            continue
+        if native:
+            return package_dir
+    return None
+
+
+def _bootstrap_exact_python(arguments: list[str]) -> None:
+    """Re-exec before importing any repository or candidate module."""
+
+    if os.environ.get(_EXACT_REEXEC_MARKER) == "1":
+        if (
+            sys.flags.isolated != 1
+            or sys.flags.no_site != 1
+            or sys.flags.ignore_environment != 1
+            or sys.flags.dont_write_bytecode != 1
+            or not sys.dont_write_bytecode
+        ):
+            raise RuntimeError("exact Python re-exec flags are incomplete")
+        raw_paths = json.loads(os.environ[_EXACT_IMPORT_PATHS])
+        if not isinstance(raw_paths, list) or not all(
+            isinstance(path, str) and Path(path).is_absolute() for path in raw_paths
+        ):
+            raise RuntimeError("exact Python import paths are invalid")
+        if MEASUREMENT_SOURCE_ROOT is not None:
+            measured_paths, _native_package = _measured_split_runtime(
+                MEASUREMENT_SOURCE_ROOT
+            )
+            if raw_paths != [str(path) for path in measured_paths]:
+                raise RuntimeError(
+                    "exact Python import paths differ from measured .venv"
+                )
+        cache_prefix = os.environ.get("PYTHONPYCACHEPREFIX")
+        if (
+            not isinstance(cache_prefix, str)
+            or not Path(cache_prefix).is_absolute()
+            or Path(cache_prefix).exists()
+        ):
+            raise RuntimeError("exact Python cache prefix is not absent")
+        for import_path in reversed(raw_paths):
+            if import_path not in sys.path:
+                sys.path.insert(0, import_path)
+        # ``-I`` ignores PYTHON* variables. Install the authenticated absent
+        # namespace explicitly before any repository or candidate import.
+        sys.pycache_prefix = cache_prefix
+        return
+
+    prefix = Path(tempfile.gettempdir()) / (
+        f".pyamplicol-no-bytecode-{os.getpid()}-{uuid.uuid4().hex}"
+    )
+    if prefix.exists():
+        raise RuntimeError(
+            f"isolated Python cache prefix unexpectedly exists: {prefix}"
+        )
+    if MEASUREMENT_SOURCE_ROOT is not None:
+        measured_paths, _native_package = _measured_split_runtime(
+            MEASUREMENT_SOURCE_ROOT
+        )
+        import_paths = [str(path) for path in measured_paths]
+    elif COMMAND in {"_prepare", "_worker"}:
+        # The scheduler deliberately starts workers with ``-I -S``.  On
+        # Python 3.12, suppressing ``site`` also prevents pyvenv.cfg from
+        # changing ``sys.prefix``, so generic sysconfig discovery below would
+        # resolve the base interpreter's site-packages instead of this
+        # checkout's venv.  Workers always use the repository venv; recover
+        # and authenticate its paths explicitly just as split workers do.
+        import_paths = [
+            str(path) for path in _measured_venv_site_paths(REPOSITORY_ROOT)
+        ]
+    else:
+        import_paths = []
+        native_package = _native_package_dir()
+        if native_package is not None:
+            import_paths.append(
+                str(native_package.parent.resolve(strict=True))
+            )
+        for scheme_name in ("purelib", "platlib"):
+            scheme_path = sysconfig.get_path(scheme_name)
+            if not isinstance(scheme_path, str):
+                continue
+            try:
+                resolved = str(Path(scheme_path).resolve(strict=True))
+            except OSError:
+                continue
+            if resolved not in import_paths:
+                import_paths.append(resolved)
+    environment = os.environ.copy()
+    environment["PYTHONDONTWRITEBYTECODE"] = "1"
+    environment["PYTHONPYCACHEPREFIX"] = str(prefix)
+    environment[_EXACT_REEXEC_MARKER] = "1"
+    environment[_EXACT_IMPORT_PATHS] = json.dumps(import_paths)
+    os.execve(
+        sys.executable,
+        (
+            sys.executable,
+            "-I",
+            "-S",
+            "-B",
+            str(ENTRYPOINT.resolve(strict=True)),
+            *arguments,
+        ),
+        environment,
+    )
+    raise RuntimeError("exact Python re-exec returned unexpectedly")
+
+
+if __name__ == "__main__":
+    _bootstrap_exact_python(ARGUMENTS)
+
+_PACKAGE_SOURCE_ROOT = (
+    CLASS_C_ANCESTOR_RUNTIME_ROOT
+    if CLASS_C_ANCESTOR_RUNTIME_ROOT is not None
+    else (
+        REPOSITORY_ROOT
+        if MEASUREMENT_SOURCE_ROOT is None
+        else MEASUREMENT_SOURCE_ROOT
+    )
+)
+_IMPORT_ROOTS = (
+    REPOSITORY_ROOT,
+    _PACKAGE_SOURCE_ROOT / "src",
+)
+for source_root in reversed(_IMPORT_ROOTS):
+    if str(source_root) not in sys.path:
+        sys.path.insert(0, str(source_root))
+NATIVE_PACKAGE_DIR = (
+    _native_package_dir()
+    if MEASUREMENT_SOURCE_ROOT is None
+    else _measured_split_runtime(MEASUREMENT_SOURCE_ROOT)[1]
+)
+
+if __name__ == "__main__":
+    from tools.performance_report.runtime_evidence import (
+        RuntimeEvidenceError,
+        source_only_bytecode_policy,
+    )
+
+    try:
+        source_only_bytecode_policy()
+    except RuntimeEvidenceError as error:
+        raise RuntimeError(
+            "could not establish source-only Python bytecode isolation"
+        ) from error
+
+if __name__ == "__main__" and RUNTIME_REQUIRED:
+    from tools.performance_report.runtime_evidence import (
+        native_extension_in_package,
+        preimport_python_runtime_identity,
+    )
+
+    if NATIVE_PACKAGE_DIR is not None:
+        _EXACT_SOURCE_PACKAGE = _PACKAGE_SOURCE_ROOT / "src" / "pyamplicol"
+        _EXACT_PACKAGE_ROOTS = (
+            (_EXACT_SOURCE_PACKAGE,)
+            if NATIVE_PACKAGE_DIR == _EXACT_SOURCE_PACKAGE
+            else (_EXACT_SOURCE_PACKAGE, NATIVE_PACKAGE_DIR)
+        )
+        _EXACT_NATIVE_EXTENSION = native_extension_in_package(NATIVE_PACKAGE_DIR)
+        preimport_python_runtime_identity(
+            _EXACT_PACKAGE_ROOTS,
+            native_extension=_EXACT_NATIVE_EXTENSION,
+        )
+
+    import pyamplicol
+
+    if (
+        NATIVE_PACKAGE_DIR is not None
+        and str(NATIVE_PACKAGE_DIR) not in pyamplicol.__path__
+    ):
+        # Match normal Python import precedence exactly. Additional native-bearing
+        # installations remain ineligible rather than expanding this namespace.
+        pyamplicol.__path__.append(str(NATIVE_PACKAGE_DIR))
+    if MEASUREMENT_SOURCE_ROOT is not None:
+        expected_package_roots = {
+            path.resolve(strict=True)
+            for path in _EXACT_PACKAGE_ROOTS
+        }
+        observed_package_roots = {
+            Path(path).resolve(strict=True)
+            for path in pyamplicol.__path__
+        }
+        if (
+            observed_package_roots
+            - expected_package_roots
+            or _EXACT_SOURCE_PACKAGE.resolve(strict=True)
+            not in observed_package_roots
+        ):
+            raise RuntimeError(
+                "pyamplicol namespace escaped measured source/venv roots"
+            )
+
+from tools.performance_report.cli import main  # noqa: E402, I001
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(ARGUMENTS))
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_validation_summary.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_validation_summary.tex
new file mode 100644
index 0000000000..445174f8f5
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_validation_summary.tex
@@ -0,0 +1,44 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/validation_summary.py; do not edit.
+\begin{samepage}
+\subsection*{Numerical validation summary}
+Only measurements whose numerical checks pass are counted below. The scope comprises every applicable report cell across the complete declared multiplicity range.
+\begin{center}
+\small
+\begin{tabular}{@{}l r r r l@{}}
+\toprule
+\textbf{final-state multiplicity} & \textbf{declared} & \textbf{static N/A} & \textbf{verified} & \textbf{measurable coverage} \\
+\midrule
+1 & 84 & 0 & 0 & \textcolor{ReportOrange}{incomplete (0 censored, 84 open)} \\
+2 & 254 & 0 & 0 & \textcolor{ReportOrange}{incomplete (0 censored, 254 open)} \\
+3 & 282 & 0 & 0 & \textcolor{ReportOrange}{incomplete (0 censored, 282 open)} \\
+4 & 422 & 0 & 0 & \textcolor{ReportOrange}{incomplete (0 censored, 422 open)} \\
+5 & 393 & 0 & 0 & \textcolor{ReportOrange}{incomplete (0 censored, 393 open)} \\
+6 & 227 & 4 & 0 & \textcolor{ReportOrange}{incomplete (0 censored, 223 open)} \\
+7 & 179 & 10 & 0 & \textcolor{ReportOrange}{incomplete (0 censored, 169 open)} \\
+8 & 179 & 10 & 0 & \textcolor{ReportOrange}{incomplete (0 censored, 169 open)} \\
+9 & 178 & 10 & 0 & \textcolor{ReportOrange}{incomplete (0 censored, 168 open)} \\
+\midrule
+\textbf{total} & 2198 & 34 & 0 & \textcolor{ReportOrange}{incomplete (0 censored, 2164 open)} \\
+\bottomrule
+\end{tabular}
+\end{center}
+\end{samepage}
+\ReportTableNote{Full-catalog display accounting through \(n=9\): 2198 declared cells, comprising 2164 measurable cells and 34 catalog-authenticated static N/A rows; 659 matrix process/multiplicity positions marked either \textsc{not applicable} or \textsc{not run}; and 36 reference execution fields marked \textsc{not exposed}. The latter two categories are intentional table structure, not unfilled measurements.}
+\begin{center}
+\small
+\begin{tabular}{@{}l r r@{}}
+\toprule
+\textbf{validation evidence} & \textbf{records} & \textbf{max. relative difference} \\
+\midrule
+MadGraph standalone tree-level reference records & 0 & \textcolor{ReportMuted}{reference} \\
+\PAC{} versus MadGraph binary64 (p200; OTF p16) & 0 & \textcolor{ReportMuted}{---} \\
+original-\AC{} legacy diagnostic records & 0 & \textcolor{ReportMuted}{diagnostic} \\
+\PAC{} versus original-\AC{} legacy diagnostic & 0 pass, 0 mismatch & \textcolor{ReportMuted}{---} \\
+compiled/eager/OTF versus recurrence & 0 & \textcolor{ReportMuted}{---} \\
+optimized result versus resolved sum & 0 & \textcolor{ReportMuted}{---} \\
+binary64 result versus p32 & 0 & \textcolor{ReportMuted}{---} \\
+\bottomrule
+\end{tabular}
+\end{center}
+\ReportTableNote{Profile: \texttt{\ReportProfileName}. Measured source: \textcolor{ReportOrange}{source identity is incomplete or mixed}. The authoritative \PAC{} versus MadGraph binary64 full-colour comparison uses p200 for recurrence, compiled, and eager candidates and the supported p16 lane for OTF; all use a relative tolerance of \(10^{-10}\). Original-\AC{} comparisons are retained non-authoritative legacy diagnostics at \(10^{-8}\); a legacy mismatch does not invalidate a candidate; cross-mode (including OTF/recurrence), resolved-sum, and p32 comparisons use \(10^{-12}\).}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_z_builtin_sm_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_z_builtin_sm_table.tex
new file mode 100644
index 0000000000..37c64a6a68
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_z_builtin_sm_table.tex
@@ -0,0 +1,205 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\clearpage
+\subsection{Built-in SM dedicated \(d\bar d\to Z+\) gluon performance}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM \(d\bar d\to Z+\) gluon ladder (block 1 of 3)}
+\begingroup
+\centering
+\scriptsize
+\setlength{\tabcolsep}{1.4pt}
+\renewcommand{\arraystretch}{1.05}
+\begin{tabular}{@{}r L{1.50in} R{1.26in} R{1.26in} R{1.26in} @{\hspace{0.08in}}R{1.26in} R{1.26in} R{1.26in}@{}}
+\toprule
+\textbf{n} & \textbf{setup} & \multicolumn{3}{c}{\textbf{selected flow, helicity sum}} & \multicolumn{3}{c}{\textbf{all flows, single helicity}} \\
+& & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} \\
+\midrule
+\rowcolor{refblue}
+1 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+1 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+1 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+1 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+1 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+1 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+1 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+1 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+2 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+2 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+2 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+2 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+2 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+2 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+2 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+2 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+3 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+3 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+3 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+3 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+3 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+3 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+3 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+3 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\bottomrule
+\end{tabular}
+\endgroup
+\ReportTableNote{Original AmpliCol is the denominator only when successful and exactly linked by stored same-point evidence, directly or through current recurrence. Otherwise its status remains visible and successful pyAmpliCol values are absolute. Unverified diagnostics retain absolute clocks with a yellow marker, but never enter ratios or summaries. Compiled, eager, and recurrence rows report separate topology-replay and all-flow-union generation and runtime measurements. On-the-fly uses one compact query-local process seed for both physical workloads. Its generation entry is the absolute \texttt{[G] G+W} pair: muted G is process-seed generation and G+W adds the first cold on-the-fly evaluation. Parenthesized values are candidate/reference ratios. All-flow generation shows the absolute pyAmpliCol value without a ratio because its setup boundary differs from the reference. The wall time is the common runtime observable. Not exposed means that a successful wall measurement has no dedicated authenticated evaluator-total timing. Authenticated accumulated warmed evaluator totals appear in the eval column with enough precision to remain distinct from wall time. Its parenthesized multiplier uses the original-AmpliCol wall measurement as denominator because the legacy reference has no separate evaluator-total clock. Recurrence rows retain the independently measured narrower recurrence core in detailed evidence; it is not relabeled as evaluator total. Neither evaluator total nor recurrence core is derived from wall time or from the other. Older entries without authenticated total evidence remain marked not exposed; it is not a missing measurement. user cap: native C++/ASM generation is not attempted above n=6 (native-backend-generation-cap-n6-v1).}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM \(d\bar d\to Z+\) gluon ladder (block 2 of 3)}
+\begingroup
+\centering
+\scriptsize
+\setlength{\tabcolsep}{1.4pt}
+\renewcommand{\arraystretch}{1.05}
+\begin{tabular}{@{}r L{1.50in} R{1.26in} R{1.26in} R{1.26in} @{\hspace{0.08in}}R{1.26in} R{1.26in} R{1.26in}@{}}
+\toprule
+\textbf{n} & \textbf{setup} & \multicolumn{3}{c}{\textbf{selected flow, helicity sum}} & \multicolumn{3}{c}{\textbf{all flows, single helicity}} \\
+& & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} \\
+\midrule
+\rowcolor{refblue}
+4 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+4 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+4 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+4 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+4 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+4 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+4 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+4 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+5 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+5 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+5 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+5 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+5 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+5 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+5 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+5 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+6 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+6 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+6 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+6 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+6 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+6 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+6 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+6 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\bottomrule
+\end{tabular}
+\endgroup
+\ReportTableNote{Original AmpliCol is the denominator only when successful and exactly linked by stored same-point evidence, directly or through current recurrence. Otherwise its status remains visible and successful pyAmpliCol values are absolute. Unverified diagnostics retain absolute clocks with a yellow marker, but never enter ratios or summaries. Compiled, eager, and recurrence rows report separate topology-replay and all-flow-union generation and runtime measurements. On-the-fly uses one compact query-local process seed for both physical workloads. Its generation entry is the absolute \texttt{[G] G+W} pair: muted G is process-seed generation and G+W adds the first cold on-the-fly evaluation. Parenthesized values are candidate/reference ratios. All-flow generation shows the absolute pyAmpliCol value without a ratio because its setup boundary differs from the reference. The wall time is the common runtime observable. Not exposed means that a successful wall measurement has no dedicated authenticated evaluator-total timing. Authenticated accumulated warmed evaluator totals appear in the eval column with enough precision to remain distinct from wall time. Its parenthesized multiplier uses the original-AmpliCol wall measurement as denominator because the legacy reference has no separate evaluator-total clock. Recurrence rows retain the independently measured narrower recurrence core in detailed evidence; it is not relabeled as evaluator total. Neither evaluator total nor recurrence core is derived from wall time or from the other. Older entries without authenticated total evidence remain marked not exposed; it is not a missing measurement. user cap: native C++/ASM generation is not attempted above n=6 (native-backend-generation-cap-n6-v1).}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{Built-in SM \(d\bar d\to Z+\) gluon ladder (block 3 of 3)}
+\begingroup
+\centering
+\scriptsize
+\setlength{\tabcolsep}{1.4pt}
+\renewcommand{\arraystretch}{1.05}
+\begin{tabular}{@{}r L{1.50in} R{1.26in} R{1.26in} R{1.26in} @{\hspace{0.08in}}R{1.26in} R{1.26in} R{1.26in}@{}}
+\toprule
+\textbf{n} & \textbf{setup} & \multicolumn{3}{c}{\textbf{selected flow, helicity sum}} & \multicolumn{3}{c}{\textbf{all flows, single helicity}} \\
+& & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} \\
+\midrule
+\rowcolor{refblue}
+7 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+7 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+7 & compiled ASM O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+7 & compiled C++ O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+\rowcolor{ReportGreen!12}
+7 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+7 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+7 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+7 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+8 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+8 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+8 & compiled ASM O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+8 & compiled C++ O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+\rowcolor{ReportGreen!12}
+8 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+8 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+8 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+8 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+9 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+9 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+9 & compiled ASM O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+9 & compiled C++ O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+\rowcolor{ReportGreen!12}
+9 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+9 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+9 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+9 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\bottomrule
+\end{tabular}
+\endgroup
+\ReportTableNote{Original AmpliCol is the denominator only when successful and exactly linked by stored same-point evidence, directly or through current recurrence. Otherwise its status remains visible and successful pyAmpliCol values are absolute. Unverified diagnostics retain absolute clocks with a yellow marker, but never enter ratios or summaries. Compiled, eager, and recurrence rows report separate topology-replay and all-flow-union generation and runtime measurements. On-the-fly uses one compact query-local process seed for both physical workloads. Its generation entry is the absolute \texttt{[G] G+W} pair: muted G is process-seed generation and G+W adds the first cold on-the-fly evaluation. Parenthesized values are candidate/reference ratios. All-flow generation shows the absolute pyAmpliCol value without a ratio because its setup boundary differs from the reference. The wall time is the common runtime observable. Not exposed means that a successful wall measurement has no dedicated authenticated evaluator-total timing. Authenticated accumulated warmed evaluator totals appear in the eval column with enough precision to remain distinct from wall time. Its parenthesized multiplier uses the original-AmpliCol wall measurement as denominator because the legacy reference has no separate evaluator-total clock. Recurrence rows retain the independently measured narrower recurrence core in detailed evidence; it is not relabeled as evaluator total. Neither evaluator total nor recurrence core is derived from wall time or from the other. Older entries without authenticated total evidence remain marked not exposed; it is not a missing measurement. user cap: native C++/ASM generation is not attempted above n=6 (native-backend-generation-cap-n6-v1).}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/result_z_external_sm_table.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/result_z_external_sm_table.tex
new file mode 100644
index 0000000000..949cde29e6
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/result_z_external_sm_table.tex
@@ -0,0 +1,205 @@
+% SPDX-License-Identifier: 0BSD
+% Generated by tools/performance_report/render.py; do not edit.
+\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}
+\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}
+\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}
+\providecommand{\matrixfitwidth}[1]{\begingroup\sbox0{#1}\ifdim\wd0>\linewidth\resizebox{\linewidth}{!}{\usebox0}\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}
+\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}
+\providecommand{\matrixratio}[2]{\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}
+\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}
+\providecommand{\matrixnotapplicable}[1]{\textcolor{#1}{\textsc{not applicable}}}
+\providecommand{\matrixnotexposed}[1]{\textcolor{#1}{\textsc{not exposed}}}
+\providecommand{\matrixstaticna}[1]{\textcolor{#1}{\textsc{static N/A}}}
+\providecommand{\matrixtotalevaluator}[1]{\textcolor{ReportBlue}{\texttt{T }}#1}
+\providecommand{\matrixrecurrencecore}[1]{\textcolor{ReportOrange}{\texttt{C }}#1}
+\providecommand{\matrixzrecurrenceclocks}[2]{\shortstack[r]{#1\\#2}}
+\providecommand{\matrixwallclock}[2]{\textcolor{#1}{\texttt{W #2}}}
+\providecommand{\matrixwallabsolute}[1]{\textcolor{ReportBlue}{\texttt{W }}#1}
+\providecommand{\matrixruntimepair}[2]{\shortstack[l]{#1\\#2}}
+\providecommand{\matrixruntimetriple}[3]{\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}
+\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}
+\providecommand{\matrixnaratio}[1]{\matrixpunct{(}\matrixna{#1}\matrixpunct{)}}
+\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}
+\providecommand{\matrixncabsolute}[1]{#1}
+\providecommand{\matrixsummaryratio}[2]{\textcolor{#1}{\texttt{x#2}}}
+\providecommand{\matrixsummaryratiohighlight}[2]{\begingroup\setlength{\fboxsep}{0.9pt}\setlength{\fboxrule}{0.35pt}\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}\endgroup}
+\providecommand{\matrixsummarystats}[5]{\begingroup\matrixsummaryfont\begin{tabular}[t]{@{}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}\makebox[3.6em][l]{#1}&\makebox[4.6em][l]{#2}&\makebox[3.6em][l]{#3}&\makebox[3.6em][l]{#4}&\makebox[4.2em][l]{#5}\end{tabular}\endgroup}
+\providecommand{\matrixsummaryworkloads}[2]{\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}
+\clearpage
+\subsection{UFO-SM dedicated \(d\bar d\to Z+\) gluon performance}
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM \(d\bar d\to Z+\) gluon ladder (block 1 of 3)}
+\begingroup
+\centering
+\scriptsize
+\setlength{\tabcolsep}{1.4pt}
+\renewcommand{\arraystretch}{1.05}
+\begin{tabular}{@{}r L{1.50in} R{1.26in} R{1.26in} R{1.26in} @{\hspace{0.08in}}R{1.26in} R{1.26in} R{1.26in}@{}}
+\toprule
+\textbf{n} & \textbf{setup} & \multicolumn{3}{c}{\textbf{selected flow, helicity sum}} & \multicolumn{3}{c}{\textbf{all flows, single helicity}} \\
+& & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} \\
+\midrule
+\rowcolor{refblue}
+1 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+1 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+1 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+1 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+1 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+1 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+1 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+1 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+2 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+2 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+2 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+2 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+2 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+2 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+2 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+2 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+3 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+3 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+3 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+3 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+3 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+3 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+3 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+3 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\bottomrule
+\end{tabular}
+\endgroup
+\ReportTableNote{Original AmpliCol is the denominator only when successful and exactly linked by stored same-point evidence, directly or through current recurrence. Otherwise its status remains visible and successful pyAmpliCol values are absolute. Unverified diagnostics retain absolute clocks with a yellow marker, but never enter ratios or summaries. Compiled, eager, and recurrence rows report separate topology-replay and all-flow-union generation and runtime measurements. On-the-fly uses one compact query-local process seed for both physical workloads. Its generation entry is the absolute \texttt{[G] G+W} pair: muted G is process-seed generation and G+W adds the first cold on-the-fly evaluation. Parenthesized values are candidate/reference ratios. All-flow generation shows the absolute pyAmpliCol value without a ratio because its setup boundary differs from the reference. The wall time is the common runtime observable. Not exposed means that a successful wall measurement has no dedicated authenticated evaluator-total timing. Authenticated accumulated warmed evaluator totals appear in the eval column with enough precision to remain distinct from wall time. Its parenthesized multiplier uses the original-AmpliCol wall measurement as denominator because the legacy reference has no separate evaluator-total clock. Recurrence rows retain the independently measured narrower recurrence core in detailed evidence; it is not relabeled as evaluator total. Neither evaluator total nor recurrence core is derived from wall time or from the other. Older entries without authenticated total evidence remain marked not exposed; it is not a missing measurement. user cap: native C++/ASM generation is not attempted above n=6 (native-backend-generation-cap-n6-v1).}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM \(d\bar d\to Z+\) gluon ladder (block 2 of 3)}
+\begingroup
+\centering
+\scriptsize
+\setlength{\tabcolsep}{1.4pt}
+\renewcommand{\arraystretch}{1.05}
+\begin{tabular}{@{}r L{1.50in} R{1.26in} R{1.26in} R{1.26in} @{\hspace{0.08in}}R{1.26in} R{1.26in} R{1.26in}@{}}
+\toprule
+\textbf{n} & \textbf{setup} & \multicolumn{3}{c}{\textbf{selected flow, helicity sum}} & \multicolumn{3}{c}{\textbf{all flows, single helicity}} \\
+& & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} \\
+\midrule
+\rowcolor{refblue}
+4 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+4 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+4 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+4 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+4 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+4 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+4 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+4 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+5 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+5 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+5 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+5 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+5 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+5 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+5 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+5 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+6 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+6 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+6 & compiled ASM O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+6 & compiled C++ O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+6 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+6 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+6 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+6 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\bottomrule
+\end{tabular}
+\endgroup
+\ReportTableNote{Original AmpliCol is the denominator only when successful and exactly linked by stored same-point evidence, directly or through current recurrence. Otherwise its status remains visible and successful pyAmpliCol values are absolute. Unverified diagnostics retain absolute clocks with a yellow marker, but never enter ratios or summaries. Compiled, eager, and recurrence rows report separate topology-replay and all-flow-union generation and runtime measurements. On-the-fly uses one compact query-local process seed for both physical workloads. Its generation entry is the absolute \texttt{[G] G+W} pair: muted G is process-seed generation and G+W adds the first cold on-the-fly evaluation. Parenthesized values are candidate/reference ratios. All-flow generation shows the absolute pyAmpliCol value without a ratio because its setup boundary differs from the reference. The wall time is the common runtime observable. Not exposed means that a successful wall measurement has no dedicated authenticated evaluator-total timing. Authenticated accumulated warmed evaluator totals appear in the eval column with enough precision to remain distinct from wall time. Its parenthesized multiplier uses the original-AmpliCol wall measurement as denominator because the legacy reference has no separate evaluator-total clock. Recurrence rows retain the independently measured narrower recurrence core in detailed evidence; it is not relabeled as evaluator total. Neither evaluator total nor recurrence core is derived from wall time or from the other. Older entries without authenticated total evidence remain marked not exposed; it is not a missing measurement. user cap: native C++/ASM generation is not attempted above n=6 (native-backend-generation-cap-n6-v1).}
+\end{minipage}
+\clearpage
+\noindent\begin{minipage}{\linewidth}
+\subsubsection*{UFO-SM \(d\bar d\to Z+\) gluon ladder (block 3 of 3)}
+\begingroup
+\centering
+\scriptsize
+\setlength{\tabcolsep}{1.4pt}
+\renewcommand{\arraystretch}{1.05}
+\begin{tabular}{@{}r L{1.50in} R{1.26in} R{1.26in} R{1.26in} @{\hspace{0.08in}}R{1.26in} R{1.26in} R{1.26in}@{}}
+\toprule
+\textbf{n} & \textbf{setup} & \multicolumn{3}{c}{\textbf{selected flow, helicity sum}} & \multicolumn{3}{c}{\textbf{all flows, single helicity}} \\
+& & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{gen [s]} & \textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & \textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} \\
+\midrule
+\rowcolor{refblue}
+7 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+7 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+7 & compiled ASM O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+7 & compiled C++ O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+\rowcolor{ReportGreen!12}
+7 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+7 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+7 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+7 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+8 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+8 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+8 & compiled ASM O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+8 & compiled C++ O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+\rowcolor{ReportGreen!12}
+8 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+8 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+8 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+8 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\midrule[0.45pt]
+\rowcolor{refblue}
+9 & \AC{} reference & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixnotexposed{ReportMuted} \\
+9 & compiled JIT O1 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+9 & compiled ASM O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+9 & compiled C++ O3 & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} & \matrixstaticna{ReportMuted} \\
+\rowcolor{ReportGreen!12}
+9 & compiled JIT O3 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+9 & eager-DAG JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+9 & recurrence JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\rowcolor{ReportGreen!12}
+9 & on-the-fly JIT O2 & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} & \matrixstatus{ReportMuted}{N/A} \\
+\bottomrule
+\end{tabular}
+\endgroup
+\ReportTableNote{Original AmpliCol is the denominator only when successful and exactly linked by stored same-point evidence, directly or through current recurrence. Otherwise its status remains visible and successful pyAmpliCol values are absolute. Unverified diagnostics retain absolute clocks with a yellow marker, but never enter ratios or summaries. Compiled, eager, and recurrence rows report separate topology-replay and all-flow-union generation and runtime measurements. On-the-fly uses one compact query-local process seed for both physical workloads. Its generation entry is the absolute \texttt{[G] G+W} pair: muted G is process-seed generation and G+W adds the first cold on-the-fly evaluation. Parenthesized values are candidate/reference ratios. All-flow generation shows the absolute pyAmpliCol value without a ratio because its setup boundary differs from the reference. The wall time is the common runtime observable. Not exposed means that a successful wall measurement has no dedicated authenticated evaluator-total timing. Authenticated accumulated warmed evaluator totals appear in the eval column with enough precision to remain distinct from wall time. Its parenthesized multiplier uses the original-AmpliCol wall measurement as denominator because the legacy reference has no separate evaluator-total clock. Recurrence rows retain the independently measured narrower recurrence core in detailed evidence; it is not relabeled as evaluator total. Neither evaluator total nor recurrence core is derived from wall time or from the other. Older entries without authenticated total evidence remain marked not exposed; it is not a missing measurement. user cap: native C++/ASM generation is not attempted above n=6 (native-backend-generation-cap-n6-v1).}
+\end{minipage}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_builtin_sm_full.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_builtin_sm_full.json
new file mode 100644
index 0000000000..6ef9d5f8d1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_builtin_sm_full.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_compiled_builtin_sm_full","entries":[{"cell_id":"matrix-compiled-builtin-sm-full-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-full-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_builtin_sm_lc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_builtin_sm_lc.json
new file mode 100644
index 0000000000..e2aa032bfc
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_builtin_sm_lc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_compiled_builtin_sm_lc","entries":[{"cell_id":"matrix-compiled-builtin-sm-lc-n1-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n1-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n1-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n1-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n2-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n3-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n4-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n5-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- e+ e- g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- e+ e- g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- z h g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- z h g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ z h g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ z h g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z z g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z z g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"g g > g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"g g > g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"g g > t t~ g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"g g > t t~ g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"u d~ > e+ ve g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"u d~ > e+ ve g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"u d~ > w+ g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n6-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"u d~ > w+ g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ u u~ g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ u u~ g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- e+ e- g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- e+ e- g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ c c~ g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ c c~ g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- z h g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- z h g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ z h g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ z h g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z z g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z z g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"g g > g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"g g > g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"g g > t t~ g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"g g > t t~ g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"u d~ > e+ ve g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"u d~ > e+ ve g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"u d~ > w+ g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n7-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"u d~ > w+ g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ u u~ g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ u u~ g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ g g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ g g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- e+ e- g g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- e+ e- g g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ c c~ g g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ c c~ g g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- z h g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- z h g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ z h g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ z h g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z z g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z z g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"g g > g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"g g > g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"g g > t t~ g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"g g > t t~ g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"u d~ > e+ ve g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"u d~ > e+ ve g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"u d~ > w+ g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n8-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"u d~ > w+ g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ u u~ g g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ u u~ g g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ g g g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ g g g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- e+ e- g g g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- e+ e- g g g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ c c~ g g g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ c c~ g g g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- g g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- g g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- z h g g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- z h g g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ g g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ g g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ z h g g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ z h g g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z g g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z g g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z z g g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z z g g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"g g > g g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"g g > g g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"g g > t t~ g g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"g g > t t~ g g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"u d~ > e+ ve g g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"u d~ > e+ ve g g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"u d~ > w+ g g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-compiled-builtin-sm-lc-n9-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"u d~ > w+ g g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_builtin_sm_nlc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_builtin_sm_nlc.json
new file mode 100644
index 0000000000..a7d6505199
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_builtin_sm_nlc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_compiled_builtin_sm_nlc","entries":[{"cell_id":"matrix-compiled-builtin-sm-nlc-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-builtin-sm-nlc-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"nlc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_ufo_sm_full.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_ufo_sm_full.json
new file mode 100644
index 0000000000..28ac310734
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_compiled_ufo_sm_full.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_compiled_ufo_sm_full","entries":[{"cell_id":"matrix-compiled-ufo-sm-full-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-compiled-ufo-sm-full-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_builtin_sm_full.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_builtin_sm_full.json
new file mode 100644
index 0000000000..c0482dc1b3
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_builtin_sm_full.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_eager_builtin_sm_full","entries":[{"cell_id":"matrix-eager-builtin-sm-full-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-full-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_builtin_sm_lc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_builtin_sm_lc.json
new file mode 100644
index 0000000000..300584c62f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_builtin_sm_lc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_eager_builtin_sm_lc","entries":[{"cell_id":"matrix-eager-builtin-sm-lc-n1-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n1-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n1-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n1-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n2-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n3-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n4-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n5-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- e+ e- g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- e+ e- g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- z h g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- z h g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ z h g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ z h g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z z g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z z g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"g g > g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"g g > g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"g g > t t~ g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"g g > t t~ g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"u d~ > e+ ve g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"u d~ > e+ ve g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"u d~ > w+ g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n6-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"u d~ > w+ g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ u u~ g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ u u~ g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- e+ e- g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- e+ e- g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ c c~ g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ c c~ g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- z h g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- z h g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ z h g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ z h g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z z g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z z g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"g g > g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"g g > g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"g g > t t~ g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"g g > t t~ g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"u d~ > e+ ve g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"u d~ > e+ ve g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"u d~ > w+ g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n7-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"u d~ > w+ g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ u u~ g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ u u~ g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ g g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ g g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- e+ e- g g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- e+ e- g g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ c c~ g g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ c c~ g g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- z h g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- z h g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ z h g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ z h g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z z g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z z g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"g g > g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"g g > g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"g g > t t~ g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"g g > t t~ g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"u d~ > e+ ve g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"u d~ > e+ ve g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"u d~ > w+ g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n8-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"u d~ > w+ g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ u u~ g g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ u u~ g g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ g g g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ g g g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- e+ e- g g g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- e+ e- g g g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ c c~ g g g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ c c~ g g g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- g g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- g g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- z h g g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- z h g g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ g g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ g g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ z h g g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ z h g g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z g g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z g g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z z g g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z z g g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"g g > g g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"g g > g g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"g g > t t~ g g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"g g > t t~ g g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"u d~ > e+ ve g g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"u d~ > e+ ve g g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"u d~ > w+ g g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-eager-builtin-sm-lc-n9-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"u d~ > w+ g g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_builtin_sm_nlc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_builtin_sm_nlc.json
new file mode 100644
index 0000000000..6669da05d5
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_builtin_sm_nlc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_eager_builtin_sm_nlc","entries":[{"cell_id":"matrix-eager-builtin-sm-nlc-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-builtin-sm-nlc-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"nlc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_ufo_sm_full.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_ufo_sm_full.json
new file mode 100644
index 0000000000..9398809b07
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_eager_ufo_sm_full.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_eager_ufo_sm_full","entries":[{"cell_id":"matrix-eager-ufo-sm-full-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-eager-ufo-sm-full-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_builtin_sm_full.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_builtin_sm_full.json
new file mode 100644
index 0000000000..eff1e7a3b2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_builtin_sm_full.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_on_the_fly_builtin_sm_full","entries":[{"cell_id":"matrix-on-the-fly-builtin-sm-full-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-full-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_builtin_sm_lc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_builtin_sm_lc.json
new file mode 100644
index 0000000000..10352c3c4d
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_builtin_sm_lc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_on_the_fly_builtin_sm_lc","entries":[{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n1-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n1-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n1-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n1-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n2-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n3-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-on-the-fly-builtin-sm-lc-n4-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_builtin_sm_nlc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_builtin_sm_nlc.json
new file mode 100644
index 0000000000..c1d6d121b2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_builtin_sm_nlc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_on_the_fly_builtin_sm_nlc","entries":[{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-builtin-sm-nlc-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"nlc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_ufo_sm_full.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_ufo_sm_full.json
new file mode 100644
index 0000000000..48e2c99a45
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_on_the_fly_ufo_sm_full.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_on_the_fly_ufo_sm_full","entries":[{"cell_id":"matrix-on-the-fly-ufo-sm-full-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-on-the-fly-ufo-sm-full-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_builtin_sm_full.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_builtin_sm_full.json
new file mode 100644
index 0000000000..bc5aceec31
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_builtin_sm_full.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_recurrence_builtin_sm_full","entries":[{"cell_id":"matrix-recurrence-builtin-sm-full-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-full-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_builtin_sm_lc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_builtin_sm_lc.json
new file mode 100644
index 0000000000..7fc6491610
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_builtin_sm_lc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_recurrence_builtin_sm_lc","entries":[{"cell_id":"matrix-recurrence-builtin-sm-lc-n1-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n1-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n1-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n1-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n2-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n3-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n4-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n5-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- e+ e- g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- e+ e- g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- z h g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > e+ e- z h g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ z h g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > t t~ z h g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z z g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z z z g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"g g > g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"g g > g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"g g > t t~ g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"g g > t t~ g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"u d~ > e+ ve g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"u d~ > e+ ve g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"u d~ > w+ g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n6-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"u d~ > w+ g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ u u~ g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ u u~ g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- e+ e- g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- e+ e- g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ c c~ g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > u u~ s s~ c c~ g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- z h g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > e+ e- z h g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ z h g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > t t~ z h g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z z g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z z z g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"g g > g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"g g > g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"g g > t t~ g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"g g > t t~ g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"u d~ > e+ ve g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"u d~ > e+ ve g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"u d~ > w+ g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n7-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"u d~ > w+ g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ u u~ g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ u u~ g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ g g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ g g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- e+ e- g g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- e+ e- g g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ c c~ g g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > u u~ s s~ c c~ g g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- z h g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > e+ e- z h g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ z h g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > t t~ z h g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z z g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z z z g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"g g > g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"g g > g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"g g > t t~ g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"g g > t t~ g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"u d~ > e+ ve g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"u d~ > e+ ve g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"u d~ > w+ g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n8-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"u d~ > w+ g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ u u~ g g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ u u~ g g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ g g g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ g g g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- e+ e- g g g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- e+ e- g g g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ c c~ g g g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > u u~ s s~ c c~ g g g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- g g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- g g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- z h g g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > e+ e- z h g g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ g g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ g g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ z h g g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > t t~ z h g g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z g g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z g g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z z g g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z z z g g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"g g > g g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"g g > g g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"g g > t t~ g g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"g g > t t~ g g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"u d~ > e+ ve g g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"u d~ > e+ ve g g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"u d~ > w+ g g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-builtin-sm-lc-n9-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"u d~ > w+ g g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_builtin_sm_nlc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_builtin_sm_nlc.json
new file mode 100644
index 0000000000..c89f92b4d3
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_builtin_sm_nlc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_recurrence_builtin_sm_nlc","entries":[{"cell_id":"matrix-recurrence-builtin-sm-nlc-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-builtin-sm-nlc-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_ufo_sm_full.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_ufo_sm_full.json
new file mode 100644
index 0000000000..2c9182fb76
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_ufo_sm_full.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_recurrence_ufo_sm_full","entries":[{"cell_id":"matrix-recurrence-ufo-sm-full-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-full-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_ufo_sm_lc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_ufo_sm_lc.json
new file mode 100644
index 0000000000..de72771e12
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_ufo_sm_lc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_recurrence_ufo_sm_lc","entries":[{"cell_id":"matrix-recurrence-ufo-sm-lc-n1-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n1-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n1-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n1-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n2-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n3-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n4-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n5-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > e+ e- e+ e- g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > e+ e- e+ e- g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > e+ e- g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > e+ e- g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > e+ e- z h g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > e+ e- z h g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > t t~ g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > t t~ g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > t t~ z h g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > t t~ z h g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z z g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z z g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z z z g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z z z g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"g g > g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"g g > g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"g g > t t~ g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"g g > t t~ g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"u d~ > e+ ve g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"u d~ > e+ ve g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"u d~ > w+ g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n6-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"u d~ > w+ g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > u u~ u u~ g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > u u~ u u~ g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > u u~ s s~ g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > u u~ s s~ g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > e+ e- e+ e- g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > e+ e- e+ e- g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > u u~ s s~ c c~ g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > u u~ s s~ c c~ g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > e+ e- g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > e+ e- g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > e+ e- z h g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > e+ e- z h g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > t t~ g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > t t~ g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > t t~ z h g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > t t~ z h g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z z g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z z g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z z z g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z z z g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"g g > g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"g g > g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"g g > t t~ g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"g g > t t~ g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"u d~ > e+ ve g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"u d~ > e+ ve g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"u d~ > w+ g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n7-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"u d~ > w+ g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > u u~ u u~ g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > u u~ u u~ g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > u u~ s s~ g g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > u u~ s s~ g g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > e+ e- e+ e- g g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > e+ e- e+ e- g g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > u u~ s s~ c c~ g g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > u u~ s s~ c c~ g g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > e+ e- g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > e+ e- g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > e+ e- z h g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > e+ e- z h g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > t t~ g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > t t~ g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > t t~ z h g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > t t~ z h g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z z g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z z g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z z z g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z z z g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"g g > g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"g g > g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"g g > t t~ g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"g g > t t~ g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"u d~ > e+ ve g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"u d~ > e+ ve g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"u d~ > w+ g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n8-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"u d~ > w+ g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > u u~ u u~ g g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > u u~ u u~ g g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > u u~ s s~ g g g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > u u~ s s~ g g g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > e+ e- e+ e- g g g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > e+ e- e+ e- g g g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > u u~ s s~ c c~ g g g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > u u~ s s~ c c~ g g g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > e+ e- g g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > e+ e- g g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > e+ e- z h g g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > e+ e- z h g g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > t t~ g g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > t t~ g g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > t t~ z h g g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > t t~ z h g g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z z g g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z z g g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z z z g g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z z z g g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"g g > g g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"g g > g g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"g g > t t~ g g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"g g > t t~ g g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"u d~ > e+ ve g g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"u d~ > e+ ve g g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"u d~ > w+ g g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"matrix-recurrence-ufo-sm-lc-n9-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"u d~ > w+ g g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_ufo_sm_nlc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_ufo_sm_nlc.json
new file mode 100644
index 0000000000..b7faa8ce38
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/matrix_recurrence_ufo_sm_nlc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"matrix_recurrence_ufo_sm_nlc","entries":[{"cell_id":"matrix-recurrence-ufo-sm-nlc-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"matrix-recurrence-ufo-sm-nlc-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"nlc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_amplicol_full.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_amplicol_full.json
new file mode 100644
index 0000000000..bec9e43703
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_amplicol_full.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"reference_amplicol_full","entries":[{"cell_id":"reference-amplicol-full-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-full-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_amplicol_lc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_amplicol_lc.json
new file mode 100644
index 0000000000..e281c6abd1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_amplicol_lc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"reference_amplicol_lc","entries":[{"cell_id":"reference-amplicol-lc-n1-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n1-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n1-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n1-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n2-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n2-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n2-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n2-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n2-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n2-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n2-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n2-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n2-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n2-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n2-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n2-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n2-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n2-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n2-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n2-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n3-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n3-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n3-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n3-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n3-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n3-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n3-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n3-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n3-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n3-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n3-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n3-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n3-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n3-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n3-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n3-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n3-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n3-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n4-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n4-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n5-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n5-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > e+ e- e+ e- g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > e+ e- e+ e- g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > e+ e- g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > e+ e- g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > e+ e- z h g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > e+ e- z h g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > t t~ g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > t t~ g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > t t~ z h g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > t t~ z h g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > z z g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > z z g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > z z z g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > z z z g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"g g > g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"g g > g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"g g > t t~ g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"g g > t t~ g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"u d~ > e+ ve g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"u d~ > e+ ve g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n6-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"u d~ > w+ g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n6-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"u d~ > w+ g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > u u~ u u~ g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > u u~ u u~ g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > u u~ s s~ g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > u u~ s s~ g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > e+ e- e+ e- g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > e+ e- e+ e- g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > u u~ s s~ c c~ g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > u u~ s s~ c c~ g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > e+ e- g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > e+ e- g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > e+ e- z h g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > e+ e- z h g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > t t~ g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > t t~ g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > t t~ z h g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > t t~ z h g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > z z g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > z z g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > z z z g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"d d~ > z z z g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"g g > g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"g g > g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"g g > t t~ g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"g g > t t~ g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"u d~ > e+ ve g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"u d~ > e+ ve g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n7-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"u d~ > w+ g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n7-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":7,"process":"u d~ > w+ g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > u u~ u u~ g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > u u~ u u~ g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > u u~ s s~ g g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > u u~ s s~ g g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > e+ e- e+ e- g g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > e+ e- e+ e- g g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > u u~ s s~ c c~ g g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > u u~ s s~ c c~ g g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > e+ e- g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > e+ e- g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > e+ e- z h g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > e+ e- z h g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > t t~ g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > t t~ g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > t t~ z h g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > t t~ z h g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > z z g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > z z g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > z z z g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"d d~ > z z z g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"g g > g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"g g > g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"g g > t t~ g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"g g > t t~ g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"u d~ > e+ ve g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"u d~ > e+ ve g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n8-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"u d~ > w+ g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n8-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":8,"process":"u d~ > w+ g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-3q-identical-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > u u~ u u~ g g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-3q-identical-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > u u~ u u~ g g g g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-3q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > u u~ s s~ g g g g g","process_key":"dd_3q_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-3q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > u u~ s s~ g g g g g","process_key":"dd_3q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-4l-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > e+ e- e+ e- g g g g g","process_key":"dd_4l_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-4l-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > e+ e- e+ e- g g g g g","process_key":"dd_4l_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-4q-lines-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > u u~ s s~ c c~ g g g","process_key":"dd_4q_lines","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-4q-lines-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > u u~ s s~ c c~ g g g","process_key":"dd_4q_lines","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-epem-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > e+ e- g g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-epem-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > e+ e- g g g g g g g","process_key":"dd_epem_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-epemzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > e+ e- z h g g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-epemzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > e+ e- z h g g g g g","process_key":"dd_epemzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > t t~ g g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > t t~ g g g g g g g","process_key":"dd_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-ttzh-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > t t~ z h g g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-ttzh-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > t t~ z h g g g g g","process_key":"dd_ttzh_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-z-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-z-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-zz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > z z g g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-zz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > z z g g g g g g g","process_key":"dd_zz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-zzz-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > z z z g g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-dd-zzz-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"d d~ > z z z g g g g g g","process_key":"dd_zzz_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-gg-gluons-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"g g > g g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-gg-gluons-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"g g > g g g g g g g g g","process_key":"gg_gluons","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-gg-tt-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"g g > t t~ g g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-gg-tt-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"g g > t t~ g g g g g g g","process_key":"gg_tt_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-ud-epve-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"u d~ > e+ ve g g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-ud-epve-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"u d~ > e+ ve g g g g g g g","process_key":"ud_epve_jets","variant":null,"workload":"selected-flow"},{"cell_id":"reference-amplicol-lc-n9-ud-w-jets-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"u d~ > w+ g g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"all-flow"},{"cell_id":"reference-amplicol-lc-n9-ud-w-jets-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":9,"process":"u d~ > w+ g g g g g g g g","process_key":"ud_w_jets","variant":null,"workload":"selected-flow"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"lc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_amplicol_nlc.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_amplicol_nlc.json
new file mode 100644
index 0000000000..82c28e8fcf
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_amplicol_nlc.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"reference_amplicol_nlc","entries":[{"cell_id":"reference-amplicol-nlc-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-amplicol-nlc-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"nlc","backend":"fortran","execution_mode":"amplicol","jit_optimization_level":null,"model":null}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_madgraph_full.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_madgraph_full.json
new file mode 100644
index 0000000000..b5b1a59584
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/reference_madgraph_full.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"reference_madgraph_full","entries":[{"cell_id":"reference-madgraph-full-n1-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n1-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":1,"process":"u d~ > w+","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n2-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"d d~ > e+ e-","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n2-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"d d~ > t t~","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n2-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n2-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z z","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n2-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"g g > g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n2-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"g g > t t~","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n2-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"u d~ > e+ ve","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n2-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"u d~ > w+ g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n3-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"d d~ > e+ e- g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n3-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"d d~ > t t~ g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n3-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n3-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n3-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z z z","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n3-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"g g > g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n3-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"g g > t t~ g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n3-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"u d~ > e+ ve g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n3-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"u d~ > w+ g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ u u~","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > u u~ s s~","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- e+ e-","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > e+ e- z h","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > t t~ z h","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z z z g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"g g > g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"g g > t t~ g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"u d~ > e+ ve g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n4-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"u d~ > w+ g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ u u~ g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > u u~ s s~ g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-dd-4l-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- e+ e- g","process_key":"dd_4l_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-dd-epem-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- g g g","process_key":"dd_epem_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-dd-epemzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > e+ e- z h g","process_key":"dd_epemzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-dd-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ g g g","process_key":"dd_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-dd-ttzh-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > t t~ z h g","process_key":"dd_ttzh_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-dd-z-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-dd-zz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z g g g","process_key":"dd_zz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-dd-zzz-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z z z g g","process_key":"dd_zzz_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-gg-gluons-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"g g > g g g g g","process_key":"gg_gluons","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-gg-tt-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"g g > t t~ g g g","process_key":"gg_tt_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-ud-epve-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"u d~ > e+ ve g g g","process_key":"ud_epve_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n5-ud-w-jets-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"u d~ > w+ g g g g","process_key":"ud_w_jets","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n6-dd-3q-identical-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ u u~ g g","process_key":"dd_3q_identical_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n6-dd-3q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ g g","process_key":"dd_3q_lines","variant":null,"workload":"contracted"},{"cell_id":"reference-madgraph-full-n6-dd-4q-lines-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"},"n_final":6,"process":"d d~ > u u~ s s~ c c~","process_key":"dd_4q_lines","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"fortran","execution_mode":"madgraph","jit_optimization_level":null,"model":"ufo_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/report-cache.schema.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/report-cache.schema.json
new file mode 100644
index 0000000000..8d0b133880
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/report-cache.schema.json
@@ -0,0 +1 @@
+{"$id":"https://pyamplicol.dev/schema/report-cache-v5.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"$schema":{"const":"./report-cache.schema.json"},"dataset_id":{"minLength":1,"type":"string"},"entries":{"items":{"additionalProperties":false,"properties":{"cell_id":{"minLength":1,"type":"string"},"measurement":{"additionalProperties":false,"allOf":[{"if":{"properties":{"status":{"const":"ok"}},"required":["status"]},"then":{"properties":{"validation":{"properties":{"direct_agreements":{"items":{"oneOf":[{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-direct-agreement-v1"},"absolute_difference":{"minimum":0,"type":"number"},"absolute_tolerance":{"minimum":0,"type":"number"},"baseline":{"type":"number"},"baseline_cell_id":{"minLength":1,"type":"string"},"candidate":{"type":"number"},"candidate_cell_id":{"minLength":1,"type":"string"},"edge_kind":{"enum":["builtin-ufo-recurrence","z-recurrence-cross-mode","lc-cross-layout-component","lc-legacy-pyamplicol-component","madgraph-full-colour"]},"relative_difference":{"minimum":0,"type":"number"},"relative_tolerance":{"minimum":0,"type":"number"},"status":{"enum":["not_available","ok","failed","timeout","memory_limit","skip","validation_failed","unverified","error","unsupported"]},"value_kind":{"enum":["matrix_element","lc_common_component"]}},"required":["abi","edge_kind","value_kind","baseline_cell_id","candidate_cell_id","status","candidate","baseline","absolute_difference","relative_difference","relative_tolerance","absolute_tolerance"],"type":"object"},{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-direct-agreement-v2"},"absolute_difference":{"minimum":0,"type":"number"},"baseline":{"type":"number"},"baseline_cell_id":{"minLength":1,"type":"string"},"baseline_scale":{"minimum":0,"type":"number"},"baseline_scale_source":{"minLength":1,"type":"string"},"candidate":{"type":"number"},"candidate_cell_id":{"minLength":1,"type":"string"},"candidate_scale":{"minimum":0,"type":"number"},"candidate_scale_source":{"minLength":1,"type":"string"},"comparison_binding":{"minProperties":1,"type":"object"},"comparison_scale":{"minimum":0,"type":"number"},"conditioned_residual":{"minimum":0,"type":"number"},"edge_kind":{"enum":["builtin-ufo-recurrence","z-recurrence-cross-mode","lc-cross-layout-component","lc-legacy-pyamplicol-component","madgraph-full-colour"]},"error_bound":{"minimum":0,"type":"number"},"relative_difference":{"minimum":0,"type":"number"},"relative_tolerance":{"minimum":0,"type":"number"},"status":{"enum":["not_available","ok","failed","timeout","memory_limit","skip","validation_failed","unverified","error","unsupported"]},"value_kind":{"enum":["matrix_element","lc_common_component"]}},"required":["abi","edge_kind","value_kind","baseline_cell_id","candidate_cell_id","status","candidate","baseline","candidate_scale","baseline_scale","candidate_scale_source","baseline_scale_source","comparison_scale","absolute_difference","relative_difference","conditioned_residual","error_bound","relative_tolerance","comparison_binding"],"type":"object"}]},"type":"array"},"independent_authority":{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-independent-authority-v1"},"expected_cell_ids":{"items":{"minLength":1,"type":"string"},"type":"array","uniqueItems":true},"reason":{"minLength":1,"type":"string"},"same_artifact_diagnostics_are_authority":{"const":false},"selected_cell_id":{"type":["string","null"]},"status":{"enum":["unavailable","verified","mismatch","incompatible"]}},"required":["abi","expected_cell_ids","selected_cell_id","status","reason","same_artifact_diagnostics_are_authority"],"type":"object"},"lc_common_component":{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-lc-common-component-v1"},"cell_id":{"minLength":1,"type":"string"},"color_flow_ids":{"items":{"minLength":1,"type":"string"},"minItems":1,"type":"array","uniqueItems":true},"helicity_ids":{"items":{"minLength":1,"type":"string"},"minItems":1,"type":"array","uniqueItems":true},"point_digest":{"pattern":"^[0-9a-f]{64}$","type":"string"},"value":{"type":"number"}},"required":["abi","cell_id","value","point_digest","helicity_ids","color_flow_ids"],"type":"object"},"madgraph_comparison":{"type":"object"},"on_the_fly_recurrence_authority":{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-on-the-fly-recurrence-authority-validation-v1"},"after_clear":{"additionalProperties":false,"properties":{"candidate_resolved_ordering_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_sum":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"candidate_resolved_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"comparison":{"additionalProperties":false,"properties":{"authority_cell_id":{"minLength":1,"type":"string"},"resolved_components":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"component_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","component_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"total":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"}},"required":["authority_cell_id","total","resolved_components"],"type":"object"}},"required":["candidate_total_source_sha256","candidate_resolved_total_source_sha256","candidate_resolved_ordering_sha256","candidate_resolved_source_sha256","candidate_resolved_sum","comparison"],"type":"object"},"authority":{"additionalProperties":false,"properties":{"artifact_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"cell_id":{"minLength":1,"type":"string"},"resolved_ordering_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"resolved_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"resolved_sum":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"resolved_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["cell_id","artifact_id","total_source_sha256","resolved_total_source_sha256","resolved_ordering_sha256","resolved_source_sha256","resolved_sum"],"type":"object"},"before_clear":{"additionalProperties":false,"properties":{"candidate_resolved_ordering_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_sum":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"candidate_resolved_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"comparison":{"additionalProperties":false,"properties":{"authority_cell_id":{"minLength":1,"type":"string"},"resolved_components":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"component_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","component_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"total":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"}},"required":["authority_cell_id","total","resolved_components"],"type":"object"}},"required":["candidate_total_source_sha256","candidate_resolved_total_source_sha256","candidate_resolved_ordering_sha256","candidate_resolved_source_sha256","candidate_resolved_sum","comparison"],"type":"object"},"candidate_artifact_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_cell_id":{"minLength":1,"type":"string"},"lifecycle":{"additionalProperties":false,"properties":{"authority_artifact_loaded_only":{"const":true},"candidate_loaded_before_validation":{"const":true},"clear_call_count":{"const":2},"final_clear_before_profile":{"const":true},"validated_after_clear":{"const":true},"validated_before_clear":{"const":true}},"required":["authority_artifact_loaded_only","candidate_loaded_before_validation","validated_before_clear","validated_after_clear","clear_call_count","final_clear_before_profile"],"type":"object"},"point_count":{"minimum":1,"type":"integer"},"point_digest":{"pattern":"^[0-9a-f]{64}$","type":"string"},"precision_digits":{"const":16},"relative_tolerance":{"const":1e-12},"resolved_check_count":{"minimum":1,"type":"integer"},"resolved_component_count":{"minimum":1,"type":"integer"},"selector_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"status":{"const":"ok"},"workload":{"enum":["selected-flow","all-flow"]}},"required":["abi","status","candidate_cell_id","candidate_artifact_id","workload","precision_digits","relative_tolerance","point_digest","selector_sha256","point_count","resolved_component_count","resolved_check_count","authority","before_clear","after_clear","lifecycle"],"type":"object"},"status":{"enum":["not_available","ok","failed","timeout","memory_limit","skip","validation_failed","unverified","error","unsupported"]}},"required":["direct_agreements"],"type":"object"}}}},{"if":{"properties":{"status":{"const":"unverified"}},"required":["status"]},"then":{"properties":{"failure":{"type":"object"},"validation":{"properties":{"direct_agreements":{"items":{"oneOf":[{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-direct-agreement-v1"},"absolute_difference":{"minimum":0,"type":"number"},"absolute_tolerance":{"minimum":0,"type":"number"},"baseline":{"type":"number"},"baseline_cell_id":{"minLength":1,"type":"string"},"candidate":{"type":"number"},"candidate_cell_id":{"minLength":1,"type":"string"},"edge_kind":{"enum":["builtin-ufo-recurrence","z-recurrence-cross-mode","lc-cross-layout-component","lc-legacy-pyamplicol-component","madgraph-full-colour"]},"relative_difference":{"minimum":0,"type":"number"},"relative_tolerance":{"minimum":0,"type":"number"},"status":{"enum":["not_available","ok","failed","timeout","memory_limit","skip","validation_failed","unverified","error","unsupported"]},"value_kind":{"enum":["matrix_element","lc_common_component"]}},"required":["abi","edge_kind","value_kind","baseline_cell_id","candidate_cell_id","status","candidate","baseline","absolute_difference","relative_difference","relative_tolerance","absolute_tolerance"],"type":"object"},{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-direct-agreement-v2"},"absolute_difference":{"minimum":0,"type":"number"},"baseline":{"type":"number"},"baseline_cell_id":{"minLength":1,"type":"string"},"baseline_scale":{"minimum":0,"type":"number"},"baseline_scale_source":{"minLength":1,"type":"string"},"candidate":{"type":"number"},"candidate_cell_id":{"minLength":1,"type":"string"},"candidate_scale":{"minimum":0,"type":"number"},"candidate_scale_source":{"minLength":1,"type":"string"},"comparison_binding":{"minProperties":1,"type":"object"},"comparison_scale":{"minimum":0,"type":"number"},"conditioned_residual":{"minimum":0,"type":"number"},"edge_kind":{"enum":["builtin-ufo-recurrence","z-recurrence-cross-mode","lc-cross-layout-component","lc-legacy-pyamplicol-component","madgraph-full-colour"]},"error_bound":{"minimum":0,"type":"number"},"relative_difference":{"minimum":0,"type":"number"},"relative_tolerance":{"minimum":0,"type":"number"},"status":{"enum":["not_available","ok","failed","timeout","memory_limit","skip","validation_failed","unverified","error","unsupported"]},"value_kind":{"enum":["matrix_element","lc_common_component"]}},"required":["abi","edge_kind","value_kind","baseline_cell_id","candidate_cell_id","status","candidate","baseline","candidate_scale","baseline_scale","candidate_scale_source","baseline_scale_source","comparison_scale","absolute_difference","relative_difference","conditioned_residual","error_bound","relative_tolerance","comparison_binding"],"type":"object"}]},"type":"array"},"independent_authority":{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-independent-authority-v1"},"expected_cell_ids":{"items":{"minLength":1,"type":"string"},"type":"array","uniqueItems":true},"reason":{"minLength":1,"type":"string"},"same_artifact_diagnostics_are_authority":{"const":false},"selected_cell_id":{"type":["string","null"]},"status":{"enum":["unavailable","verified","mismatch","incompatible"]}},"required":["abi","expected_cell_ids","selected_cell_id","status","reason","same_artifact_diagnostics_are_authority"],"type":"object"},"lc_common_component":{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-lc-common-component-v1"},"cell_id":{"minLength":1,"type":"string"},"color_flow_ids":{"items":{"minLength":1,"type":"string"},"minItems":1,"type":"array","uniqueItems":true},"helicity_ids":{"items":{"minLength":1,"type":"string"},"minItems":1,"type":"array","uniqueItems":true},"point_digest":{"pattern":"^[0-9a-f]{64}$","type":"string"},"value":{"type":"number"}},"required":["abi","cell_id","value","point_digest","helicity_ids","color_flow_ids"],"type":"object"},"madgraph_comparison":{"type":"object"},"on_the_fly_recurrence_authority":{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-on-the-fly-recurrence-authority-validation-v1"},"after_clear":{"additionalProperties":false,"properties":{"candidate_resolved_ordering_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_sum":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"candidate_resolved_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"comparison":{"additionalProperties":false,"properties":{"authority_cell_id":{"minLength":1,"type":"string"},"resolved_components":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"component_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","component_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"total":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"}},"required":["authority_cell_id","total","resolved_components"],"type":"object"}},"required":["candidate_total_source_sha256","candidate_resolved_total_source_sha256","candidate_resolved_ordering_sha256","candidate_resolved_source_sha256","candidate_resolved_sum","comparison"],"type":"object"},"authority":{"additionalProperties":false,"properties":{"artifact_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"cell_id":{"minLength":1,"type":"string"},"resolved_ordering_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"resolved_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"resolved_sum":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"resolved_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["cell_id","artifact_id","total_source_sha256","resolved_total_source_sha256","resolved_ordering_sha256","resolved_source_sha256","resolved_sum"],"type":"object"},"before_clear":{"additionalProperties":false,"properties":{"candidate_resolved_ordering_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_sum":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"candidate_resolved_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"comparison":{"additionalProperties":false,"properties":{"authority_cell_id":{"minLength":1,"type":"string"},"resolved_components":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"component_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","component_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"total":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"}},"required":["authority_cell_id","total","resolved_components"],"type":"object"}},"required":["candidate_total_source_sha256","candidate_resolved_total_source_sha256","candidate_resolved_ordering_sha256","candidate_resolved_source_sha256","candidate_resolved_sum","comparison"],"type":"object"},"candidate_artifact_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_cell_id":{"minLength":1,"type":"string"},"lifecycle":{"additionalProperties":false,"properties":{"authority_artifact_loaded_only":{"const":true},"candidate_loaded_before_validation":{"const":true},"clear_call_count":{"const":2},"final_clear_before_profile":{"const":true},"validated_after_clear":{"const":true},"validated_before_clear":{"const":true}},"required":["authority_artifact_loaded_only","candidate_loaded_before_validation","validated_before_clear","validated_after_clear","clear_call_count","final_clear_before_profile"],"type":"object"},"point_count":{"minimum":1,"type":"integer"},"point_digest":{"pattern":"^[0-9a-f]{64}$","type":"string"},"precision_digits":{"const":16},"relative_tolerance":{"const":1e-12},"resolved_check_count":{"minimum":1,"type":"integer"},"resolved_component_count":{"minimum":1,"type":"integer"},"selector_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"status":{"const":"ok"},"workload":{"enum":["selected-flow","all-flow"]}},"required":["abi","status","candidate_cell_id","candidate_artifact_id","workload","precision_digits","relative_tolerance","point_digest","selector_sha256","point_count","resolved_component_count","resolved_check_count","authority","before_clear","after_clear","lifecycle"],"type":"object"},"status":{"enum":["not_available","ok","failed","timeout","memory_limit","skip","validation_failed","unverified","error","unsupported"]}},"required":["status","direct_agreements","independent_authority","resolved_sum","high_precision_resolved_sum","high_precision","precision_diagnostic"],"type":"object"}}}}],"properties":{"artifact":{"type":["object","null"]},"execution_seconds_per_point":{"minimum":0,"type":["number","null"]},"failure":{"type":["object","null"]},"generation_seconds":{"minimum":0,"type":["number","null"]},"matrix_element":{"type":["number","string","null"]},"provenance":{"oneOf":[{"type":"null"},{"properties":{"generation_timer_excludes_model_preparation":{"const":true},"runtime_load_included_in_cold_warmup":{"const":false},"runtime_profile":{"dependentRequired":{"cold_warmup_acceptance_eligible":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_batch_size":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_elapsed_seconds":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_point_count":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_ratio_eligible":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_run_count":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_runtime_cold_before_first_evaluation":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_runtime_freshness":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_runtime_retained_after_first_evaluation":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_runtime_retained_before_first_evaluation":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_runtime_state_after":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_runtime_state_before":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_runtime_state_evidence":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_timer_source":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"],"cold_warmup_timing_scope":["cold_warmup_acceptance_eligible","cold_warmup_batch_size","cold_warmup_elapsed_seconds","cold_warmup_point_count","cold_warmup_ratio_eligible","cold_warmup_run_count","cold_warmup_runtime_cold_before_first_evaluation","cold_warmup_runtime_freshness","cold_warmup_runtime_retained_after_first_evaluation","cold_warmup_runtime_retained_before_first_evaluation","cold_warmup_runtime_state_after","cold_warmup_runtime_state_before","cold_warmup_runtime_state_evidence","cold_warmup_timer_source","cold_warmup_timing_scope","first_warmup_run_outer_wall_seconds","warmup_batch_size","warmup_configured_run_count","warmup_elapsed_seconds","warmup_point_count","warmup_run_outer_wall_seconds","warmup_timer_source","warmup_timing_scope"]},"properties":{"cold_warmup_acceptance_eligible":{"const":false},"cold_warmup_batch_size":{"minimum":1,"type":"integer"},"cold_warmup_elapsed_seconds":{"exclusiveMinimum":0,"type":"number"},"cold_warmup_point_count":{"minimum":1,"type":"integer"},"cold_warmup_ratio_eligible":{"const":false},"cold_warmup_run_count":{"const":1},"cold_warmup_runtime_cold_before_first_evaluation":{"type":"boolean"},"cold_warmup_runtime_freshness":{"enum":["authenticated-already-retained","authenticated-cold"]},"cold_warmup_runtime_retained_after_first_evaluation":{"const":true},"cold_warmup_runtime_retained_before_first_evaluation":{"type":"boolean"},"cold_warmup_runtime_state_after":{"additionalProperties":false,"properties":{"active_family_union_census":{"oneOf":[{"type":"null"},{"additionalProperties":false,"properties":{"basis":{"const":"shared-query-family-union-v1"},"query_count":{"minimum":0,"type":"integer"},"scope":{"const":"active-family-union"},"union_amplitude_destination_count":{"minimum":0,"type":"integer"},"union_closure_executor_call_groups":{"minimum":0,"type":"integer"},"union_closure_rows":{"minimum":0,"type":"integer"},"union_contribution_executor_call_groups":{"minimum":0,"type":"integer"},"union_contribution_rows":{"minimum":0,"type":"integer"},"union_finalization_executor_call_groups":{"minimum":0,"type":"integer"},"union_finalization_rows":{"minimum":0,"type":"integer"},"union_source_executor_call_groups":{"minimum":0,"type":"integer"},"union_source_rows":{"minimum":0,"type":"integer"},"union_unique_current_component_count":{"minimum":0,"type":"integer"},"union_unique_current_count":{"minimum":0,"type":"integer"}},"required":["basis","query_count","scope","union_amplitude_destination_count","union_closure_executor_call_groups","union_closure_rows","union_contribution_executor_call_groups","union_contribution_rows","union_finalization_executor_call_groups","union_finalization_rows","union_source_executor_call_groups","union_source_rows","union_unique_current_component_count","union_unique_current_count"],"type":"object"}]},"family_cache_limit":{"const":1},"family_cache_policy":{"const":"last-family-only"},"kind":{"const":"rusticol-on-the-fly-runtime-state-census-v1"},"pending_family_count":{"minimum":0,"type":"integer"},"process_id":{"minLength":1,"type":"string"},"process_preparation_count":{"minimum":0,"type":"integer"},"retained_amplitude_destination_count":{"minimum":0,"type":"integer"},"retained_embedded_lookup_key_count":{"minimum":0,"type":"integer"},"retained_executor_handle_count":{"minimum":0,"type":"integer"},"retained_family_count":{"maximum":1,"minimum":0,"type":"integer"},"retained_query_local_trace_count":{"minimum":0,"type":"integer"},"retained_request_count":{"minimum":0,"type":"integer"},"retained_selection_count":{"minimum":0,"type":"integer"},"semantic_executor_binding_count":{"minimum":0,"type":"integer"}},"required":["active_family_union_census","family_cache_limit","family_cache_policy","kind","pending_family_count","process_id","process_preparation_count","retained_amplitude_destination_count","retained_embedded_lookup_key_count","retained_executor_handle_count","retained_family_count","retained_query_local_trace_count","retained_request_count","retained_selection_count","semantic_executor_binding_count"],"type":"object"},"cold_warmup_runtime_state_before":{"additionalProperties":false,"properties":{"active_family_union_census":{"oneOf":[{"type":"null"},{"additionalProperties":false,"properties":{"basis":{"const":"shared-query-family-union-v1"},"query_count":{"minimum":0,"type":"integer"},"scope":{"const":"active-family-union"},"union_amplitude_destination_count":{"minimum":0,"type":"integer"},"union_closure_executor_call_groups":{"minimum":0,"type":"integer"},"union_closure_rows":{"minimum":0,"type":"integer"},"union_contribution_executor_call_groups":{"minimum":0,"type":"integer"},"union_contribution_rows":{"minimum":0,"type":"integer"},"union_finalization_executor_call_groups":{"minimum":0,"type":"integer"},"union_finalization_rows":{"minimum":0,"type":"integer"},"union_source_executor_call_groups":{"minimum":0,"type":"integer"},"union_source_rows":{"minimum":0,"type":"integer"},"union_unique_current_component_count":{"minimum":0,"type":"integer"},"union_unique_current_count":{"minimum":0,"type":"integer"}},"required":["basis","query_count","scope","union_amplitude_destination_count","union_closure_executor_call_groups","union_closure_rows","union_contribution_executor_call_groups","union_contribution_rows","union_finalization_executor_call_groups","union_finalization_rows","union_source_executor_call_groups","union_source_rows","union_unique_current_component_count","union_unique_current_count"],"type":"object"}]},"family_cache_limit":{"const":1},"family_cache_policy":{"const":"last-family-only"},"kind":{"const":"rusticol-on-the-fly-runtime-state-census-v1"},"pending_family_count":{"minimum":0,"type":"integer"},"process_id":{"minLength":1,"type":"string"},"process_preparation_count":{"minimum":0,"type":"integer"},"retained_amplitude_destination_count":{"minimum":0,"type":"integer"},"retained_embedded_lookup_key_count":{"minimum":0,"type":"integer"},"retained_executor_handle_count":{"minimum":0,"type":"integer"},"retained_family_count":{"maximum":1,"minimum":0,"type":"integer"},"retained_query_local_trace_count":{"minimum":0,"type":"integer"},"retained_request_count":{"minimum":0,"type":"integer"},"retained_selection_count":{"minimum":0,"type":"integer"},"semantic_executor_binding_count":{"minimum":0,"type":"integer"}},"required":["active_family_union_census","family_cache_limit","family_cache_policy","kind","pending_family_count","process_id","process_preparation_count","retained_amplitude_destination_count","retained_embedded_lookup_key_count","retained_executor_handle_count","retained_family_count","retained_query_local_trace_count","retained_request_count","retained_selection_count","semantic_executor_binding_count"],"type":"object"},"cold_warmup_runtime_state_evidence":{"const":"authenticated-native-otf-census-v1"},"cold_warmup_timer_source":{"const":"python_outer_time.perf_counter"},"cold_warmup_timing_scope":{"const":"one initial requested-selector Runtime evaluation on the full benchmark batch; artifact generation and Runtime/artifact load are excluded"},"first_warmup_run_outer_wall_seconds":{"minimum":0,"type":["number","null"]},"warmup_batch_size":{"minimum":1,"type":"integer"},"warmup_configured_run_count":{"minimum":0,"type":"integer"},"warmup_elapsed_seconds":{"minimum":0,"type":"number"},"warmup_point_count":{"minimum":0,"type":"integer"},"warmup_run_outer_wall_seconds":{"items":{"minimum":0,"type":"number"},"type":"array"},"warmup_timer_source":{"const":"python_outer_time.perf_counter"},"warmup_timing_scope":{"const":"configured benchmark warm-up iteration outer wall; includes the headline evaluation and optional native-profile warm-up; artifact generation and Runtime/artifact load are excluded"}},"type":"object"}},"type":"object"}]},"relative_standard_error":{"minimum":0,"type":["number","null"]},"resources":{"type":["object","null"]},"sample_count":{"minimum":1,"type":["integer","null"]},"selector_contract":{"type":["object","null"]},"standard_error_seconds_per_point":{"minimum":0,"type":["number","null"]},"status":{"enum":["not_available","ok","failed","timeout","memory_limit","skip","validation_failed","unverified","error","unsupported"]},"validation":{"oneOf":[{"type":"null"},{"properties":{"direct_agreements":{"items":{"oneOf":[{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-direct-agreement-v1"},"absolute_difference":{"minimum":0,"type":"number"},"absolute_tolerance":{"minimum":0,"type":"number"},"baseline":{"type":"number"},"baseline_cell_id":{"minLength":1,"type":"string"},"candidate":{"type":"number"},"candidate_cell_id":{"minLength":1,"type":"string"},"edge_kind":{"enum":["builtin-ufo-recurrence","z-recurrence-cross-mode","lc-cross-layout-component","lc-legacy-pyamplicol-component","madgraph-full-colour"]},"relative_difference":{"minimum":0,"type":"number"},"relative_tolerance":{"minimum":0,"type":"number"},"status":{"enum":["not_available","ok","failed","timeout","memory_limit","skip","validation_failed","unverified","error","unsupported"]},"value_kind":{"enum":["matrix_element","lc_common_component"]}},"required":["abi","edge_kind","value_kind","baseline_cell_id","candidate_cell_id","status","candidate","baseline","absolute_difference","relative_difference","relative_tolerance","absolute_tolerance"],"type":"object"},{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-direct-agreement-v2"},"absolute_difference":{"minimum":0,"type":"number"},"baseline":{"type":"number"},"baseline_cell_id":{"minLength":1,"type":"string"},"baseline_scale":{"minimum":0,"type":"number"},"baseline_scale_source":{"minLength":1,"type":"string"},"candidate":{"type":"number"},"candidate_cell_id":{"minLength":1,"type":"string"},"candidate_scale":{"minimum":0,"type":"number"},"candidate_scale_source":{"minLength":1,"type":"string"},"comparison_binding":{"minProperties":1,"type":"object"},"comparison_scale":{"minimum":0,"type":"number"},"conditioned_residual":{"minimum":0,"type":"number"},"edge_kind":{"enum":["builtin-ufo-recurrence","z-recurrence-cross-mode","lc-cross-layout-component","lc-legacy-pyamplicol-component","madgraph-full-colour"]},"error_bound":{"minimum":0,"type":"number"},"relative_difference":{"minimum":0,"type":"number"},"relative_tolerance":{"minimum":0,"type":"number"},"status":{"enum":["not_available","ok","failed","timeout","memory_limit","skip","validation_failed","unverified","error","unsupported"]},"value_kind":{"enum":["matrix_element","lc_common_component"]}},"required":["abi","edge_kind","value_kind","baseline_cell_id","candidate_cell_id","status","candidate","baseline","candidate_scale","baseline_scale","candidate_scale_source","baseline_scale_source","comparison_scale","absolute_difference","relative_difference","conditioned_residual","error_bound","relative_tolerance","comparison_binding"],"type":"object"}]},"type":"array"},"independent_authority":{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-independent-authority-v1"},"expected_cell_ids":{"items":{"minLength":1,"type":"string"},"type":"array","uniqueItems":true},"reason":{"minLength":1,"type":"string"},"same_artifact_diagnostics_are_authority":{"const":false},"selected_cell_id":{"type":["string","null"]},"status":{"enum":["unavailable","verified","mismatch","incompatible"]}},"required":["abi","expected_cell_ids","selected_cell_id","status","reason","same_artifact_diagnostics_are_authority"],"type":"object"},"lc_common_component":{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-lc-common-component-v1"},"cell_id":{"minLength":1,"type":"string"},"color_flow_ids":{"items":{"minLength":1,"type":"string"},"minItems":1,"type":"array","uniqueItems":true},"helicity_ids":{"items":{"minLength":1,"type":"string"},"minItems":1,"type":"array","uniqueItems":true},"point_digest":{"pattern":"^[0-9a-f]{64}$","type":"string"},"value":{"type":"number"}},"required":["abi","cell_id","value","point_digest","helicity_ids","color_flow_ids"],"type":"object"},"madgraph_comparison":{"type":"object"},"on_the_fly_recurrence_authority":{"additionalProperties":false,"properties":{"abi":{"const":"pyamplicol-report-on-the-fly-recurrence-authority-validation-v1"},"after_clear":{"additionalProperties":false,"properties":{"candidate_resolved_ordering_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_sum":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"candidate_resolved_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"comparison":{"additionalProperties":false,"properties":{"authority_cell_id":{"minLength":1,"type":"string"},"resolved_components":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"component_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","component_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"total":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"}},"required":["authority_cell_id","total","resolved_components"],"type":"object"}},"required":["candidate_total_source_sha256","candidate_resolved_total_source_sha256","candidate_resolved_ordering_sha256","candidate_resolved_source_sha256","candidate_resolved_sum","comparison"],"type":"object"},"authority":{"additionalProperties":false,"properties":{"artifact_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"cell_id":{"minLength":1,"type":"string"},"resolved_ordering_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"resolved_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"resolved_sum":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"resolved_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["cell_id","artifact_id","total_source_sha256","resolved_total_source_sha256","resolved_ordering_sha256","resolved_source_sha256","resolved_sum"],"type":"object"},"before_clear":{"additionalProperties":false,"properties":{"candidate_resolved_ordering_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_resolved_sum":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"candidate_resolved_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_total_source_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"comparison":{"additionalProperties":false,"properties":{"authority_cell_id":{"minLength":1,"type":"string"},"resolved_components":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"component_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","component_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"},"total":{"additionalProperties":false,"properties":{"check_count":{"minimum":1,"type":"integer"},"maximum_absolute_delta":{"minimum":0,"type":"number"},"maximum_conditioned_residual":{"minimum":0,"type":"number"}},"required":["check_count","maximum_conditioned_residual","maximum_absolute_delta"],"type":"object"}},"required":["authority_cell_id","total","resolved_components"],"type":"object"}},"required":["candidate_total_source_sha256","candidate_resolved_total_source_sha256","candidate_resolved_ordering_sha256","candidate_resolved_source_sha256","candidate_resolved_sum","comparison"],"type":"object"},"candidate_artifact_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"candidate_cell_id":{"minLength":1,"type":"string"},"lifecycle":{"additionalProperties":false,"properties":{"authority_artifact_loaded_only":{"const":true},"candidate_loaded_before_validation":{"const":true},"clear_call_count":{"const":2},"final_clear_before_profile":{"const":true},"validated_after_clear":{"const":true},"validated_before_clear":{"const":true}},"required":["authority_artifact_loaded_only","candidate_loaded_before_validation","validated_before_clear","validated_after_clear","clear_call_count","final_clear_before_profile"],"type":"object"},"point_count":{"minimum":1,"type":"integer"},"point_digest":{"pattern":"^[0-9a-f]{64}$","type":"string"},"precision_digits":{"const":16},"relative_tolerance":{"const":1e-12},"resolved_check_count":{"minimum":1,"type":"integer"},"resolved_component_count":{"minimum":1,"type":"integer"},"selector_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"status":{"const":"ok"},"workload":{"enum":["selected-flow","all-flow"]}},"required":["abi","status","candidate_cell_id","candidate_artifact_id","workload","precision_digits","relative_tolerance","point_digest","selector_sha256","point_count","resolved_component_count","resolved_check_count","authority","before_clear","after_clear","lifecycle"],"type":"object"},"status":{"enum":["not_available","ok","failed","timeout","memory_limit","skip","validation_failed","unverified","error","unsupported"]}},"type":"object"}]},"wall_seconds_per_point":{"minimum":0,"type":["number","null"]}},"required":["status","generation_seconds","wall_seconds_per_point","execution_seconds_per_point","matrix_element","sample_count","standard_error_seconds_per_point","relative_standard_error","artifact","selector_contract","validation","resources","provenance","failure"],"type":"object"},"measurement_spec":{"type":"object"},"n_final":{"minimum":1,"type":"integer"},"process":{"minLength":1,"type":"string"},"process_key":{"type":["string","null"]},"variant":{"type":["string","null"]},"workload":{"enum":["selected-flow","all-flow","contracted"]}},"required":["cell_id","process_key","process","n_final","variant","workload","measurement_spec","measurement"],"type":"object"},"type":"array"},"kind":{"const":"performance_measurements"},"measurement_specs":{"items":{"type":"object"},"type":"array"},"report_version":{"const":"0.3.0"},"schema_version":{"const":5}},"required":["$schema","schema_version","report_version","kind","dataset_id","measurement_specs","entries"],"title":"pyAmpliCol performance cache","type":"object"}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/scalar_contact.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/scalar_contact.json
new file mode 100644
index 0000000000..4fccc05d98
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/scalar_contact.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"scalar_contact","entries":[{"cell_id":"scalar-contact-n2-scalar-contact-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_contact"},"n_final":2,"process":"scalar_0 scalar_0 > scalar_0 scalar_0","process_key":"scalar_contact","variant":null,"workload":"contracted"},{"cell_id":"scalar-contact-n3-scalar-contact-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_contact"},"n_final":3,"process":"scalar_0 scalar_0 > scalar_0 scalar_0 scalar_0","process_key":"scalar_contact","variant":null,"workload":"contracted"},{"cell_id":"scalar-contact-n4-scalar-contact-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_contact"},"n_final":4,"process":"scalar_0 scalar_0 > scalar_0 scalar_0 scalar_0 scalar_0","process_key":"scalar_contact","variant":null,"workload":"contracted"},{"cell_id":"scalar-contact-n5-scalar-contact-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_contact"},"n_final":5,"process":"scalar_0 scalar_0 > scalar_0 scalar_0 scalar_0 scalar_0 scalar_0","process_key":"scalar_contact","variant":null,"workload":"contracted"},{"cell_id":"scalar-contact-n6-scalar-contact-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_contact"},"n_final":6,"process":"scalar_0 scalar_0 > scalar_0 scalar_0 scalar_0 scalar_0 scalar_0 scalar_0","process_key":"scalar_contact","variant":null,"workload":"contracted"},{"cell_id":"scalar-contact-n7-scalar-contact-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_contact"},"n_final":7,"process":"scalar_0 scalar_0 > scalar_0 scalar_0 scalar_0 scalar_0 scalar_0 scalar_0 scalar_0","process_key":"scalar_contact","variant":null,"workload":"contracted"},{"cell_id":"scalar-contact-n8-scalar-contact-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_contact"},"n_final":8,"process":"scalar_0 scalar_0 > scalar_0 scalar_0 scalar_0 scalar_0 scalar_0 scalar_0 scalar_0 scalar_0","process_key":"scalar_contact","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_contact"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/scalar_gravity.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/scalar_gravity.json
new file mode 100644
index 0000000000..f4ea7c5afd
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/scalar_gravity.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"scalar_gravity","entries":[{"cell_id":"scalar-gravity-n2-scalar-gravity-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_gravity"},"n_final":2,"process":"scalar_0 scalar_0 > graviton graviton","process_key":"scalar_gravity","variant":null,"workload":"contracted"},{"cell_id":"scalar-gravity-n3-scalar-gravity-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_gravity"},"n_final":3,"process":"scalar_0 scalar_0 > graviton graviton graviton","process_key":"scalar_gravity","variant":null,"workload":"contracted"},{"cell_id":"scalar-gravity-n4-scalar-gravity-contracted","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_gravity"},"n_final":4,"process":"scalar_0 scalar_0 > graviton graviton graviton graviton","process_key":"scalar_gravity","variant":null,"workload":"contracted"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"full","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"scalar_gravity"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/z_builtin_sm.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/z_builtin_sm.json
new file mode 100644
index 0000000000..12340896f4
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/z_builtin_sm.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"z_builtin_sm","entries":[{"cell_id":"z-builtin-sm-n1-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n1-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n2-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n3-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n4-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n5-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n6-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n7-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n8-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-builtin-sm-n9-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"builtin_sm"},{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"builtin_sm"},{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"builtin_sm"},{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"builtin_sm"},{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"builtin_sm"},{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"builtin_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/results/z_external_sm.json b/pyamplicol/src/pyamplicol/_profiling_campaign/results/z_external_sm.json
new file mode 100644
index 0000000000..d55bbd3db6
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/results/z_external_sm.json
@@ -0,0 +1 @@
+{"$schema":"./report-cache.schema.json","dataset_id":"z_external_sm","entries":[{"cell_id":"z-external-sm-n1-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n1-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":1,"process":"d d~ > z","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n2-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":2,"process":"d d~ > z g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n3-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":3,"process":"d d~ > z g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n4-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":4,"process":"d d~ > z g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n5-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":5,"process":"d d~ > z g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n6-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":6,"process":"d d~ > z g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n7-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":7,"process":"d d~ > z g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n8-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":8,"process":"d d~ > z g g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-asm-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-asm-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"asm_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-cpp-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-cpp-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"cpp_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-eager-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-eager-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"eager_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-jit-o1-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"all-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-jit-o1-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"jit_o1","workload":"selected-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-jit-o3-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"all-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-jit-o3-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"jit_o3","workload":"selected-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-on-the-fly-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-on-the-fly-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"on_the_fly_jit_o2","workload":"selected-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-recurrence-jit-o2-all-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"all-flow"},{"cell_id":"z-external-sm-n9-dd-z-jets-recurrence-jit-o2-selected-flow","measurement":{"artifact":null,"execution_seconds_per_point":null,"failure":null,"generation_seconds":null,"matrix_element":null,"provenance":null,"relative_standard_error":null,"resources":null,"sample_count":null,"selector_contract":null,"standard_error_seconds_per_point":null,"status":"not_available","validation":null,"wall_seconds_per_point":null},"measurement_spec":{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"},"n_final":9,"process":"d d~ > z g g g g g g g g","process_key":"dd_z_jets","variant":"recurrence_jit_o2","workload":"selected-flow"}],"kind":"performance_measurements","measurement_specs":[{"accuracy":"lc","backend":"asm","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},{"accuracy":"lc","backend":"cpp","execution_mode":"compiled","jit_optimization_level":null,"model":"ufo_sm"},{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":1,"model":"ufo_sm"},{"accuracy":"lc","backend":"jit","execution_mode":"compiled","jit_optimization_level":3,"model":"ufo_sm"},{"accuracy":"lc","backend":"jit","execution_mode":"eager","jit_optimization_level":2,"model":"ufo_sm"},{"accuracy":"lc","backend":"jit","execution_mode":"on-the-fly","jit_optimization_level":2,"model":"ufo_sm"},{"accuracy":"lc","backend":"jit","execution_mode":"recurrence","jit_optimization_level":2,"model":"ufo_sm"}],"report_version":"0.3.0","schema_version":5}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/section_eager_execution.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/section_eager_execution.tex
new file mode 100644
index 0000000000..cb9ca80b1e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/section_eager_execution.tex
@@ -0,0 +1,97 @@
+% SPDX-License-Identifier: 0BSD
+\section{Compiled, Eager, and Recurrence Execution}
+\label{sec:eager-execution}
+
+The three execution modes differ in how they turn the same current recursion
+into numerical work. Compiled mode specializes groups of current relations to
+one process. Eager mode applies reusable model kernels according to a
+process-specific schedule. Recurrence mode constructs a compact schedule of
+currents, contributions, and closures directly. These choices change the
+balance between process-generation cost and runtime work, but not the
+observable being evaluated.
+
+Recurrence JIT O2 is the default execution mode.
+
+\begin{center}
+\small
+\begin{tabular}{@{}L{0.72in}L{1.85in}L{2.00in}L{1.40in}@{}}
+\toprule
+\textbf{mode} & \textbf{process preparation} & \textbf{evaluation} &
+  \textbf{characteristic balance} \\
+\midrule
+Compiled
+  & Builds process-specific stage evaluators
+  & Evaluates a small number of process-wide, multi-output stages
+  & More preparation; greater fusion across a process \\
+Eager
+  & Maps the process graph to reusable prepared-model kernels
+  & Applies those kernels according to the process dependencies
+  & Reuses model work across processes \\
+Recurrence
+  & Builds a compact schedule directly from the current recursion
+  & Evaluates scheduled currents, contributions, and closures
+  & Avoids construction of a generic process DAG \\
+\bottomrule
+\end{tabular}
+\end{center}
+
+\subsection{Common physics contract}
+
+All three modes retain the same external states, perturbative orders,
+helicities, colour components, coherent amplitude groups, symmetry factors,
+and initial-state averages. In a contracted colour basis their common
+observable has the schematic form
+\begin{equation}
+  \mathcal M_p
+  =\mathcal N\sum_h\sum_{a,b}
+    A_{ha}(p)^{*}\,C_{ab}\,A_{hb}(p),
+  \label{eq:three-mode-common-observable}
+\end{equation}
+with the corresponding resolved form retained when helicity or leading-colour
+flow components are requested. Each mode must reproduce both the directly
+evaluated total and the sum of those resolved components.
+
+Current contributions are accumulated coherently before a propagator or other
+current transformation is applied. Final closures then form the amplitude
+components entering Eq.~\eqref{eq:three-mode-common-observable}. This ordering
+is common to the three modes and prevents execution strategy from changing the
+normalization.
+
+\subsection{Prepared-model boundary}
+
+A prepared model contains reusable numerical information derived from the
+model's particles, parameters, propagators, and interaction tensors. Eager and
+recurrence JIT O2 measurements reuse this model-level preparation and add only
+the process-dependent schedule. Compiled JIT O3 measurements instead include
+construction and compilation of their process-specific evaluators.
+
+Prepared-model creation occurs outside the process-generation timer. The
+reported eager and recurrence generation times therefore describe adding a
+process to an already prepared model, not importing and compiling the model
+itself.
+
+\subsection{Batches, selectors, and portability}
+
+Evaluation is batched over phase-space points, allowing the JIT backend to use
+the point dimension for vectorization. Partitioning a large input batch changes
+neither the process representation nor the numerical result.
+
+Helicity and colour-flow selectors refer to physical resolved components. A
+complete leading-colour calculation retains every declared helicity and flow,
+so selecting one flow with summed helicities or one helicity with all flows
+does not alter the underlying physics coverage. The selected-flow and all-flow
+layouts used for these workloads retain that same physical coverage.
+
+Portable JIT state is compiled for the receiving processor when loaded.
+Target-native ASM and C++ payloads remain architecture-specific, and the exact
+symbolic representation is retained where higher-precision evaluation is
+supported.
+
+\subsection{Interpretation}
+
+Compiled mode may benefit most when process-wide fusion outweighs its
+additional preparation cost. Eager mode can reduce repeated preparation when
+many processes share a model, while recurrence provides a compact direct
+representation of the current construction. The tables compare these
+trade-offs under identical physics, selector, precision, and validation
+conditions; no mode is assumed to be universally fastest.
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/section_lc_flow_layouts.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/section_lc_flow_layouts.tex
new file mode 100644
index 0000000000..9a5e688c83
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/section_lc_flow_layouts.tex
@@ -0,0 +1,148 @@
+% SPDX-License-Identifier: 0BSD
+\section{Reusable Leading-Colour Execution Layouts}
+\label{sec:lc-flow-layouts}
+
+Leading-colour coverage and its numerical layout are separate concepts.  Let
+\(\mathcal H\) be the retained helicities and \(\mathcal F\) the retained
+physical colour flows.  Complete leading-colour coverage represents
+\begin{equation}
+  \mathcal C_{\mathrm{LC}}=\mathcal H\times\mathcal F
+  \label{eq:lc-complete-coverage}
+\end{equation}
+and can expose every resolved amplitude \(\mathcal A_{hf}\).  For selected
+subsets \(S_H\subseteq\mathcal H\) and \(S_F\subseteq\mathcal F\), the
+observable is
+\begin{equation}
+  \mathcal W(S_H,S_F)
+  =\mathcal N\sum_{h\in S_H}\sum_{f\in S_F}w_{hf}
+   \left|\sum_{r\in G(h,f)}\mathcal A^{(r)}_{hf}\right|^2 .
+  \label{eq:lc-runtime-selection}
+\end{equation}
+Here \(G(h,f)\) is a coherent contribution group, \(w_{hf}\) contains exact
+symmetry and leading-colour weights, and \(\mathcal N\) is the process
+normalization.  The layout changes how this sum is scheduled, not its
+components or normalization.
+
+\subsection{Two complete-coverage layouts}
+
+The report measures two layouts because selected-flow and all-flow workloads
+offer different opportunities for sharing:
+
+\begin{center}
+\small
+\begin{tabular}{@{}L{1.32in}L{2.40in}L{2.40in}@{}}
+\toprule
+\textbf{property} & \textbf{topology replay} &
+  \textbf{all-flow union} \\
+\midrule
+Measured workload & one selected flow, summed helicities &
+  all flows, one selected helicity \\
+Retained physics & every flow and helicity &
+  every flow and helicity \\
+Main reuse & equivalent flow topologies related by exact permutations and
+  factors & currents and closures shared directly across all flows \\
+Availability & compiled, eager, recurrence, and on-the-fly to
+  \(n_{\mathrm{final}}=4\) &
+  compiled, eager, and recurrence \\
+\bottomrule
+\end{tabular}
+\end{center}
+
+On-the-fly execution does not materialize a separate all-flow-union artifact.
+Within its LC scope, one compact process-seed artifact serves both measured
+workloads: one selected flow with helicities summed, and all physical flows
+with one helicity selected. Thus the all-flow observable remains the same, but
+its on-the-fly execution is reconstructed lazily from the shared compact
+artifact rather than from \(D_{\mathrm{union}}\).
+
+In topology replay, exact relations partition physical flows into equivalence
+classes. If \(\rho(f)\) represents the class containing \(f\), the calculation
+records a permutation \(\pi_f\), an exact factor \(s_f\), and the corresponding
+weight:
+\begin{equation}
+  \mathcal A_{h f}(p)
+  =s_f\,\mathcal A_{\pi_f(h),\rho(f)}\!\left(\pi_f(p)\right).
+  \label{eq:lc-topology-replay}
+\end{equation}
+This avoids constructing an independent current graph for every physical
+ordering and is suited to selected-flow, helicity-summed evaluation.
+
+The all-flow union instead merges the dependency graphs of all resolved
+components:
+\begin{equation}
+  D_{\mathrm{union}}
+  =\left(\bigcup_{h\in\mathcal H,\,f\in\mathcal F}D_{hf}\right)
+   \big/\!\sim ,
+  \label{eq:lc-all-flow-union}
+\end{equation}
+where \(\sim\) identifies currents, kernel values, and closures that are
+algebraically equal up to retained exact factors.  For a selected helicity,
+one graph traversal then reuses intermediate currents across all flows.
+
+Compiled mode specializes the chosen layout to process-wide stage evaluators.
+Eager mode applies prepared-model kernels to the same dependency structure,
+recurrence mode constructs a compact current schedule directly, and on-the-fly
+mode reconstructs query-local traces from its compact process seed. These
+execution choices do not change \(\mathcal H\), \(\mathcal F\), or
+Eq.~\eqref{eq:lc-runtime-selection}.
+
+\subsection{Runtime selection}
+
+Flow and helicity selections refer to physical components.  A selection may be
+applied to a complete batch or specified independently for each point; omitting
+an axis sums all retained entries on that axis.  Rows with equal selections can
+be grouped into contiguous numerical batches.  This grouping changes neither
+the generated coverage nor the resolved result.
+
+\subsection{Generation and reference boundaries}
+
+The two layouts build different graphs and numerical schedules, so their
+process-generation times are distinct observables:
+\begin{equation}
+  T_{\mathrm{gen}}^{\mathrm{replay}}
+  \quad\hbox{and}\quad
+  T_{\mathrm{gen}}^{\mathrm{union}}.
+  \label{eq:lc-two-generation-times}
+\end{equation}
+Cross-mode comparisons use the same layout on both sides.  Preparation of
+reusable model-level kernels occurs before the process-generation timer and is
+not included in these table values.
+
+The on-the-fly exception has one process-generation quantity \(G\), because
+the selected-flow and all-flow workloads share one compact artifact. Its first
+full-batch evaluation \(W\) constructs the initially requested selector-family
+state. Artifact loading and the conventional benchmark warmup calls are timed
+separately and are excluded from \(W\). Calling \texttt{Runtime.clear()} drops
+the lazy on-the-fly state without replacing the process artifact.
+
+The original-\AC{} reference uses two different routes. For the selected-flow
+workload, its generation value measures creation of the process library. For
+the all-flow workload, the reported setup value measures preparation of direct
+all-flow evaluation. The corresponding runtime measurements implement the
+same physical workloads as \PAC{}, but the all-flow setup quantities do not
+define a like-for-like process-generation speedup. The table therefore reports
+both quantities absolutely and marks their generation comparison as not
+comparable.
+
+Before timing an on-the-fly cell, the complete resolved components for both
+workloads are compared with a separately generated recurrence authority. The
+same componentwise comparison is repeated after
+\texttt{Runtime.clear()} to check the cold reconstruction path.
+
+\subsection{NLC and full colour}
+
+The alternative layouts apply only at leading colour.  NLC and full-colour
+evaluation construct an amplitude basis and contract it with the appropriate
+colour metric:
+\begin{equation}
+  \mathcal W_{\mathrm{contracted}}
+  =\mathcal N\sum_h\sum_{a,b}
+   \mathcal A_{ha}^{*}\,C_{ab}\,\mathcal A_{hb}.
+  \label{eq:contracted-colour-layout}
+\end{equation}
+These treatments do not expose the physical leading-colour flow axis, so there
+is no topology-replay or all-flow-union distinction. On-the-fly NLC and
+full-colour entries are selector-free contracted evaluations: their cold stage
+builds the requested helicity family and evaluates the authenticated sparse-NLC
+or complete-colour contraction payload. They expose helicity selection but no
+leading-colour flow selector.
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/section_three_mode_performance_tables.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/section_three_mode_performance_tables.tex
new file mode 100644
index 0000000000..0d5369dd35
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/section_three_mode_performance_tables.tex
@@ -0,0 +1,230 @@
+% SPDX-License-Identifier: 0BSD
+\section{Standard-Model Process Matrices}
+\label{sec:three-mode-performance-tables}
+
+The process matrices use recurrence as the primary \PAC{} execution mode.
+Built-in-SM and UFO-SM recurrence JIT O2 retain comparisons with legacy
+original-\AC{} results.  Separate built-in-SM matrices compare compiled JIT O3
+and eager JIT O2 with recurrence JIT O2 for the same process, colour treatment,
+and observable. A built-in-SM on-the-fly JIT O2 matrix compares directly with
+original-\AC{} for LC at \(n_{\mathrm{final}}\leq4\). Four additional
+full-colour UFO-SM views compare recurrence, compiled, eager, and on-the-fly
+with one shared authoritative MadGraph standalone reference.
+
+The canonical matrix spans electroweak vector production, charged-current and
+leptonic channels, heavy-quark production, pure gluons, multi-boson final
+states, Higgs-associated final states, and three- and four-quark-line cases.
+Here \(n\) is the number of final-state particles.  LC coverage retains every
+declared family through \(n=9\), except that on-the-fly LC coverage currently
+ends at \(n_{\mathrm{final}}=4\). NLC and full-colour grids display
+\(n=1,\ldots,6\), including genuine on-the-fly contracted cells. A multiplicity
+for which a process family does not yet exist
+is marked \textsc{not applicable}; an otherwise defined process intentionally
+excluded from the declared measurement scope is marked \textsc{not run}.
+These are table structure, not unfilled measurements.  A complete edition
+accounts for every scheduled cell across the full declared range.
+Resource-limited cells carry a documented status; every successful cell is
+numerical and validated.  An in-scope result that does not pass required
+numerical validation is identified by a status and does not carry a timing
+ratio. Original-\AC{} disagreement is the deliberate exception: it is a legacy
+diagnostic, not a required validation failure.
+Best-mode cells select the fastest successful candidate, including on-the-fly
+where it is in scope and marking that winner with \texttt{(o)}. If none
+succeeds, the recurrence attempt is shown with \texttt{(r)} and its terminal
+status.
+
+The UFO-SM recurrence matrices use the same process definitions, colour
+contracts, numerical parameters, selectors, and validation points as the
+built-in-SM recurrence matrices. Their source is the packaged Standard Model
+loaded through the serialized-JSON interface. This comparison verifies that the
+imported and built-in model routes implement the same requested physics.
+Outside the four MadGraph-reference full-colour views, compiled, eager, and
+on-the-fly process matrices remain built-in-only, isolating differences between
+execution modes from differences in model loading.
+
+\input{result_validation_summary.tex}
+
+\subsection*{Workloads and denominators}
+
+For a reported timing quantity \(T\), each multiplier is
+\begin{equation}
+  r_{\mathrm{candidate/baseline}}
+  = \frac{T_{\mathrm{candidate}}}{T_{\mathrm{baseline}}}.
+  \label{eq:three-mode-matrix-time-ratio}
+\end{equation}
+Green, orange, and red denote respectively \(r<1\), \(1\leq r<2\), and
+\(r\geq2\).  Green therefore means that the candidate is faster than the
+baseline named in the table heading.  The recurrence matrices use original
+\AC{} as the baseline, as does the detailed on-the-fly LC matrix. The compiled
+and eager matrices use built-in-SM recurrence JIT O2 as the baseline.
+
+Every LC comparison contains two complete-coverage layouts:
+\begin{itemize}
+  \item topology replay, measured with one physical colour flow selected and
+        all retained helicities summed; and
+  \item the all-flow union, measured with one physical helicity selected and
+        all retained colour flows summed.
+\end{itemize}
+Neither selection is fixed during generation. Each LC cell reports the two
+baseline generation quantities and wall times, followed by candidate
+generation entries and runtime ratios. The muted supplementary ratio first
+compares separately measured execution attributions when both sides expose
+compatible boundaries; otherwise it compares authenticated evaluator totals.
+Only against original \AC{}, which has no evaluator-total clock, may a candidate
+evaluator total use the legacy direct execution clock (or wall when direct
+execution is absent) as denominator. An evaluator total is never divided by a
+recurrence core. This evaluator-total fallback is diagnostic only;
+execution/execution remains the compatible supplementary attribution. If no
+compatible supplementary clock exists, only the wall ratio is shown. Compiled
+and eager generation are compared with recurrence using the same layout.
+
+On-the-fly is the scoped LC exception to the two-artifact layout. One compact
+process-seed artifact serves both the selected-flow, helicity-summed
+workload and the all-flow, single-helicity workload. Its process-generation
+time is \(G\). For selected flow, \texttt{([xG] x(G+W))} shows the muted
+generation-only multiplier and the normally coloured multiplier after adding
+the first full-batch evaluation \(W\), both relative to the matching \AC{}
+library-generation time. For all flow, \texttt{[G] G+W} shows the two absolute
+times, with \(G\) muted and \(G+W\) in normal black. In this generation-only
+notation, \(W\) excludes artifact loading and the conventional benchmark
+warmup calls.
+
+The two original-\AC{} reference workloads have different setup boundaries.
+For the selected-flow workload, the reported generation quantity is creation
+of the process library. For the all-flow workload, it is preparation of direct
+all-flow evaluation. Runtime ratios compare the same physical observable. The
+all-flow setup quantities are not like-for-like, so the table shows the
+candidate process-generation time as an absolute value and forms no ratio.
+For on-the-fly this is the absolute \texttt{[G] G+W} pair above.
+
+NLC and full colour use one helicity-summed, colour-contracted calculation per
+mode. Their cells report the absolute baseline generation and wall time,
+followed by the candidate generation and runtime ratios. No per-flow scalar or
+flow selector is defined for these contracted colour accuracies. On-the-fly
+uses the same public contracted result shape and authenticates its expanded
+colour-contraction payload.
+
+The wall quantity is the repeated native evaluation time after caller-language
+input conversion and is the primary runtime observable. Independent accumulated
+evaluator-total and narrower recurrence-core clocks remain in the detailed
+measurement evidence; neither is copied from wall time or from the other. The
+compact runtime notation \texttt{([xS]xW)} shows a compatible supplementary
+clock multiplier \texttt{xS} in muted brackets and the primary wall multiplier
+\texttt{xW} in its performance colour. The hierarchy above determines whether
+\texttt{xS} is execution attribution or a diagnostic evaluator-total fallback.
+If no supplementary ratio is eligible, the cell shows only \texttt{(xW)}.
+
+Preparation of reusable model-level kernels is excluded from
+process-generation time. Compiled generation still includes process-specific
+evaluator construction and backend compilation. On-the-fly \(W\) starts only
+after the compact artifact has been loaded and stops after its first complete
+batch evaluation; later benchmark warmups are separate.
+
+A timing is shown only after the candidate passes its required internal and
+cross-mode checks. Compiled and eager results agree with recurrence at the
+strict cross-mode tolerance, and built-in and UFO-SM recurrence results are
+compared directly. Each result must reproduce its resolved sum. The four new
+full-colour UFO-SM views instead use the shared MadGraph standalone value as
+the authoritative physics boundary: \PAC{} is evaluated at precision 200 at
+the same point and must agree within relative tolerance \(10^{-10}\). For LC,
+the common flow--helicity component is compared directly between topology
+replay and all-flow union. On-the-fly adds a recurrence-authority gate: for
+both workloads, its complete resolved-component array must agree with the
+separately generated recurrence result before timing. After
+\texttt{Runtime.clear()}, the full component comparison and the resolved-sum
+identity are repeated before the cell is accepted.
+
+Original \AC{} remains visible as a performance baseline and numerical
+diagnostic, but is not authoritative. A mismatch with it does not suppress the
+candidate timing, ratio, or summary contribution; only the corresponding
+\AC{} generation-time token is coloured red. This rule applies equally to LC,
+NLC, and full-colour legacy comparisons.
+
+\subsection*{Cell and summary layout}
+
+\begin{center}
+\small
+\begin{tabular}{@{}L{0.95in}L{2.45in}L{5.75in}@{}}
+\toprule
+\textbf{contract} & \textbf{baseline entry} & \textbf{candidate entries} \\
+\midrule
+LC, upper
+  & topology replay \texttt{|} all-flow generation quantities in seconds
+  & layout-matched ratios, except that the all-flow candidate against original
+    \AC{} is shown absolutely without a ratio; on-the-fly uses selected
+    \texttt{([xG] x(G+W))} \texttt{|} all-flow \texttt{[G] G+W} \\
+LC, lower
+  & selected-flow \texttt{|} all-flow wall times in
+    \(\mu\mathrm{s}/\mathrm{pt}\)
+  & compact \texttt{([xS]xW)} comparisons, or \texttt{(xW)} when only wall is
+    comparable \\
+NLC and full-colour, upper
+  & contracted generation time in seconds
+  & candidate generation ratio \\
+NLC and full-colour, lower
+  & contracted wall time in \(\mu\mathrm{s}/\mathrm{pt}\)
+  & compact \texttt{([xS]xW)} comparison, or \texttt{(xW)} when only wall is
+    comparable \\
+\bottomrule
+\end{tabular}
+\end{center}
+
+Summary rows contain multipliers only, ordered as minimum, maximum, median,
+arithmetic mean, and weighted mean.  The arithmetic mean averages the
+individual candidate/baseline multipliers; the weighted mean is the ratio of
+sums
+\(\sum_i T_{\mathrm{candidate},i}/\sum_i T_{\mathrm{baseline},i}\).
+Generation summaries use topology replay for LC and the contracted workload
+for NLC and full colour; the non-comparable LC all-flow generation quantity is
+omitted. In the best-mode overview, an on-the-fly winner contributes its
+displayed primary \(G+W\) quantity, not the muted generation-only \(G\)
+diagnostic. Fixed-engine on-the-fly summaries retain their generation-only
+comparison. Runtime summaries use wall time only, with
+separate aligned LC topology-replay and all-flow lines. Structurally inapplicable,
+resource-limited, unsupported, and validation-failed cells do not contribute.
+
+The first three matrices provide a built-in-SM overview against original
+\AC{}.  For each process, multiplicity, colour treatment, and LC workload,
+they select the validated pyAmpliCol mode with the smallest wall time.
+Selection is independent in every cell: the overview records the measured
+winner rather than prescribing one mode for all processes.  Its upper row
+reports generation and its lower row reports runtime.  LC pairs use
+non-union-flow \texttt{|} union-flow ordering.  Since original-\AC{} all-flow
+setup and \PAC{} process generation have different boundaries, the latter is
+shown absolutely rather than as a misleading ratio. When on-the-fly is the
+winner, the same \texttt{([xG] x(G+W))} and \texttt{[G] G+W} generation
+notation applies beside its \texttt{(o)} marker.
+
+\input{result_matrix_best_builtin_sm_lc_table.tex}
+\input{result_matrix_best_builtin_sm_nlc_table.tex}
+\input{result_matrix_best_builtin_sm_full_table.tex}
+
+The detailed tables are grouped by execution mode, model source, and colour
+treatment.
+
+\input{result_matrix_recurrence_builtin_sm_lc_table.tex}
+\input{result_matrix_recurrence_builtin_sm_nlc_table.tex}
+\input{result_matrix_recurrence_builtin_sm_full_table.tex}
+\input{result_matrix_recurrence_ufo_sm_lc_table.tex}
+\input{result_matrix_recurrence_ufo_sm_nlc_table.tex}
+\input{result_matrix_recurrence_ufo_sm_full_table.tex}
+\input{result_matrix_compiled_builtin_sm_lc_table.tex}
+\input{result_matrix_compiled_builtin_sm_nlc_table.tex}
+\input{result_matrix_compiled_builtin_sm_full_table.tex}
+\input{result_matrix_eager_builtin_sm_lc_table.tex}
+\input{result_matrix_eager_builtin_sm_nlc_table.tex}
+\input{result_matrix_eager_builtin_sm_full_table.tex}
+\input{result_matrix_on_the_fly_builtin_sm_lc_table.tex}
+\input{result_matrix_on_the_fly_builtin_sm_nlc_table.tex}
+\input{result_matrix_on_the_fly_builtin_sm_full_table.tex}
+
+The following four views reuse the candidate measurements above and one shared
+MadGraph full-colour reference cache; they do not create duplicate campaign
+measurements. The recurrence, compiled, and eager comparisons use p200
+candidate values, while the genuine on-the-fly contracted comparison uses its
+supported p16 lane.
+
+\input{result_matrix_recurrence_ufo_sm_full_vs_madgraph_table.tex}
+\input{result_matrix_compiled_ufo_sm_full_vs_madgraph_table.tex}
+\input{result_matrix_eager_ufo_sm_full_vs_madgraph_table.tex}
+\input{result_matrix_on_the_fly_ufo_sm_full_vs_madgraph_table.tex}
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/section_ufo_support.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/section_ufo_support.tex
new file mode 100644
index 0000000000..3f01e3d9d2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/section_ufo_support.tex
@@ -0,0 +1,163 @@
+% SPDX-License-Identifier: 0BSD
+\section{Supported UFO and Serialized-JSON Models}
+\label{sec:ufo-support}
+
+\PAC{} accepts a documented subset of the Universal FeynRules Output (UFO)
+format and an equivalent serialized-JSON representation. Both sources are
+normalized before process generation and then use the same current recursion,
+colour treatment, and numerical interfaces as the built-in models. Unsupported
+structures are rejected explicitly rather than interpreted approximately.
+
+\subsection{Sources and normalization}
+
+The two input routes are
+\begin{equation}
+  \{\text{trusted UFO module},\text{ serialized JSON}\}
+  \longrightarrow
+  \text{normalized model}
+  \longrightarrow
+  \text{numerical kernels}.
+  \label{eq:ufo-loading-route}
+\end{equation}
+A UFO module is executable Python and must therefore come from a trusted
+source. The serialized JSON form is data-only and is preferable for portable
+exchange and archival. After loading, both forms describe the same particles,
+parameters, propagators, interactions, coupling orders, Lorentz tensors, and
+colour tensors.
+
+Model symbols remain in a model-local namespace, so equally named parameters
+from different models are not identified accidentally. Normalization also
+makes component orderings and particle conjugation explicit. A model is
+accepted for ordinary process generation only when the normalized model
+satisfies the support boundary below; an unrepresentable requested interaction
+is rejected explicitly.
+
+\subsection{Interactions and exact verification}
+
+A UFO vertex is a sum over colour and Lorentz structures,
+\begin{equation}
+  \mathcal V(1,\ldots,n)
+  =\sum_{a,b}g_{ab}\,
+    C_a(c_1,\ldots,c_n)\,
+    L_b(s_1,p_1;\ldots;s_n,p_n).
+  \label{eq:ufo-vertex-matrix}
+\end{equation}
+Each term retains its coupling-order assignment. The supported Lorentz basis
+includes scalars, momenta, metrics, Dirac identity and gamma matrices,
+\(\gamma_5\), chiral projectors, slashed momenta, and sigma tensors. The
+supported SU(3) representations are the singlet, fundamental,
+antifundamental, and adjoint.
+
+Colour projection and symmetry reuse are based on exact normalized
+expressions. Numerical agreement at a sample point is not used to establish an
+algebraic identity. When an identity needed only for reuse cannot be proved,
+the corresponding contributions are evaluated separately. When an identity
+is required to represent an interaction at all, failure to establish it causes
+the model or process to be rejected.
+
+Leading-colour singlet subtraction, for example, follows from the fundamental
+Fierz identity
+\begin{equation}
+  (T^a)_i{}^{\bar\jmath}(T^a)_k{}^{\bar l}
+  =T_R\left(
+    \delta_i{}^{\bar l}\delta_k{}^{\bar\jmath}
+    -\frac{1}{N_c}
+     \delta_i{}^{\bar\jmath}\delta_k{}^{\bar l}
+  \right).
+  \label{eq:fierz}
+\end{equation}
+It is used only when the colour representation, Lorentz interaction, and
+vector propagator satisfy the corresponding exact conditions. The same
+principle applies to vectorlike parity, Yang--Mills relations, and current
+reflection.
+
+\subsection{Contact interactions and propagators}
+
+Supported contact interactions are rewritten with non-propagating auxiliary
+currents only when the original tensor can be reconstructed exactly. The
+physical coupling appears once, and the rewriting introduces no artificial
+pole. Colour-singlet scalar contacts provide the validation ladder for this
+construction. Higher-valence singlet interactions are accepted when their
+normalized tensor admits the same exact reconstruction.
+
+A coloured four-vector gauge contact is accepted only for the two-\(f\)
+structure
+\begin{equation}
+  C^{a_1a_2a_3a_4}
+  =c\,f^{a_i a_j b}f^{b a_k a_r},
+  \label{eq:two-f-color}
+\end{equation}
+up to exact permutations, with one shared adjoint index and a matching Lorentz
+factorization. Other coloured contact tensors require a separately supported
+intermediate colour channel.
+
+Standard scalar, Dirac, vector, and spin-two propagators use the mass, width,
+gauge, and component ordering declared by the normalized model. A custom UFO
+propagator is accepted only when its numerator and denominator can be lowered
+exactly; optimizations that assume a standard propagator are then disabled.
+Massless spin two is validated by the scalar-gravity model. Massive spin-two
+support remains experimental because it has not yet been tested across a
+comparably broad set of models.
+
+\subsection{Support boundary}
+
+In the table, \emph{conditional} means that the stated exact algebraic
+condition must be established for the particular model expression. It does not
+imply acceptance of every algebraically equivalent UFO spelling.
+
+\begingroup
+\small
+\setlength{\LTpre}{0.3em}
+\setlength{\LTpost}{0.3em}
+\begin{longtable}{@{}L{0.83in}L{1.47in}L{0.93in}L{3.15in}@{}}
+\toprule
+\textbf{area} & \textbf{class} & \textbf{status} & \textbf{boundary} \\
+\midrule
+\endfirsthead
+\toprule
+\textbf{area} & \textbf{class} & \textbf{status} & \textbf{boundary} \\
+\midrule
+\endhead
+source & UFO directory / JSON & supported & UFO Python must be trusted; JSON
+  is data-only and both use the same normalized model \\
+spin & scalar, Dirac, vector & supported & standard wavefunctions,
+  propagators, component orderings, and closures \\
+spin & massless spin two & supported & tensor path validated by the
+  scalar-gravity model \\
+spin & massive spin two & experimental & Fierz--Pauli path is available, but
+  broad model validation is incomplete \\
+spin & UFO ghosts & partial & propagating ghosts require an exactly
+  representable custom propagator and are not broadly qualified \\
+spin & Majorana/FNV, spin \(3/2\) & unsupported & no
+  fermion-number-violating-flow or Rarita--Schwinger current prescription \\
+colour & \(1,3,\bar3,8\) of SU(3) & supported & LC, NLC, and full-colour
+  treatments described in this report \\
+colour & \(6,\bar6\), extra groups & unsupported & no sextet or
+  multiple-group flow and contraction representation \\
+arity 3 & \(1,\delta,T,f\) colour & supported & exact colour projection and
+  representable Lorentz components \\
+arity 3 & \(d^{abc}\), \(\epsilon\), \(K_6\), \(T_6\) & unsupported & no
+  supported colour-flow and contraction prescription \\
+arity 4 & colour singlet & conditional & exact tensor reconstruction by
+  non-propagating auxiliary currents \\
+arity 4 & two-\(f\) gauge colour & conditional & one shared adjoint index,
+  trivalent topology, and exact Lorentz reconstruction \\
+arity 4 & other coloured tensors & unsupported & no supported auxiliary colour
+  channel \\
+arity \(>4\) & colour-singlet contact & conditional & exact no-pole
+  reconstruction with the original coupling inserted once \\
+arity \(>4\) & coloured contact & unsupported & no general
+  irreducible-channel factorization \\
+Lorentz & normalized tensor basis & supported & every tensor function must
+  normalize with explicit component axes \\
+Lorentz & form factors / unknown functions & unsupported & no portable
+  numerical prescription \\
+propagator & standard \(0,\frac12,1,2\) & supported & model mass and width,
+  with explicit component ordering and closure \\
+propagator & custom UFO tensor & conditional & exact component lowering;
+  standard-propagator optimizations are disabled \\
+symmetry & vectorlike/Yang--Mills/reflection & conditional & exact normalized
+  identities over the complete interaction sector used by the process \\
+\bottomrule
+\end{longtable}
+\endgroup
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/section_zgg_dag.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/section_zgg_dag.tex
new file mode 100644
index 0000000000..2a78286be4
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/section_zgg_dag.tex
@@ -0,0 +1,83 @@
+% SPDX-License-Identifier: 0BSD
+\section{\texorpdfstring{Shared-Current DAG and Numerical Execution}{Shared-Current DAG and Numerical Execution}}
+\label{sec:zgg-dag}
+
+The current recursion becomes a directed acyclic graph (DAG) when physically
+identical intermediate currents are shared. This section summarizes the
+identity and ordering needed for that reuse and relates them to the three
+execution modes.
+
+\subsection{Current identity and reuse}
+
+Two contributions share a current only when every physics-relevant label
+agrees. Schematically,
+\begin{equation}
+ \Omega(J)=
+ \bigl(t,I,H,s,F,Q,C,O,a,\pi_I\bigr),
+ \label{eq:zgg-current-key}
+\end{equation}
+where the entries identify the particle species, external subset, helicity and
+spin ancestry, flavour and additive charges, colour state, perturbative order,
+auxiliary-current type, and colour-sensitive ordering. The subset determines
+the current momentum \(q_I=\sum_{i\in I}q_i\), while the ordered labels prevent
+distinct colour traversals from being merged.
+
+Exact identity permits one stored current to serve every amplitude contribution
+that needs it. A second kind of reuse applies when different currents require
+the same numerical kernel value up to a known exact factor. Neither form of
+reuse merges distinct physical helicity or colour-flow components.
+
+\subsection{Topological ordering}
+
+The graph is evaluated in increasing external-subset size. Every input is
+therefore available before the current that consumes it. For the representative
+\(d\bar d\to Zgg\) process, the ordering is schematically
+\begin{equation}
+ \boxed{\text{sources}}
+ \longrightarrow
+ \boxed{|I|=2}
+ \longrightarrow
+ \boxed{|I|=3}
+ \longrightarrow
+ \boxed{|I|=4}
+ \longrightarrow
+ \boxed{\text{amplitude closures}} .
+ \label{eq:zgg-stage-chain}
+\end{equation}
+At each stage, all admissible partitions contributing to the same current are
+summed coherently before propagation. The final closures join the largest
+retained currents to the remaining external states. This ordering makes the
+dependency structure explicit without assigning physical meaning to a
+particular storage layout.
+
+\subsection{Numerical realization}
+
+Compiled mode combines many relations in a stage into process-specific
+multi-output evaluators. Eager mode follows the same process graph using
+reusable prepared-model kernels. Recurrence mode represents the current and
+closure sequence directly. All three preserve the same coherent sums, colour
+contraction, helicity treatment, symmetry weights, and normalization.
+
+For resolved leading-colour evaluation, the public result has the form
+\begin{equation}
+  R_{p,h,f}=\left|\mathcal M_{h,f}(p)\right|^2,
+  \qquad
+  \operatorname{shape}(R)=
+  (N_{\rm point},N_{\rm helicity},N_{\rm flow}) .
+  \label{eq:zgg-resolved-shape}
+\end{equation}
+Structural zeros remain explicit, and summing the non-point axes must reproduce
+the directly evaluated total within the stated numerical tolerance.
+
+\subsection{Timing boundary}
+
+The primary runtime quantity is the complete native wall time after
+caller-language array conversion. It includes source and momentum preparation,
+the mode-specific numerical evaluation, selectors, closures, and final
+reduction. Packing performed by the caller is outside this boundary.
+
+Some backends additionally expose a narrower execution attribution. Because
+its precise boundary is mode-specific, it is reported only as a supplementary
+quantity and only when measured directly. The complete wall time remains the
+common observable used for comparisons; an unavailable attribution is marked
+explicitly rather than inferred.
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/section_zgg_example.tex b/pyamplicol/src/pyamplicol/_profiling_campaign/section_zgg_example.tex
new file mode 100644
index 0000000000..86f7892480
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/section_zgg_example.tex
@@ -0,0 +1,143 @@
+% SPDX-License-Identifier: 0BSD
+\section{\texorpdfstring{Worked \(d\bar d\to Zgg\) Example}{Worked d dbar -> Z g g Example}}
+\label{sec:zgg-example}
+
+This example illustrates how a familiar tree-level process is represented by
+reusable off-shell currents.  It also fixes the momentum, helicity, and colour
+conventions used in the performance tables.
+
+\subsection{External legs and conventions}
+
+The physical process is
+\begin{equation}
+  d(p_1)\,\bar d(p_2) \longrightarrow Z(p_3)\,g(p_4)\,g(p_5),
+  \qquad p_1+p_2=p_3+p_4+p_5 .
+  \label{eq:zgg-physical-process}
+\end{equation}
+The current recursion uses the all-outgoing convention
+\begin{equation}
+  q_1=-p_1,\quad q_2=-p_2,\quad q_i=p_i\ (i=3,4,5),
+  \qquad \sum_{i=1}^{5}q_i=0 .
+  \label{eq:zgg-all-outgoing}
+\end{equation}
+External momenta are supplied in the physical convention of
+Eq.~\eqref{eq:zgg-physical-process} and crossed to the all-outgoing convention
+before the recursion is evaluated.
+
+\begin{center}
+\small
+\begin{tabular}{@{}cL{0.90in}L{1.05in}L{1.00in}cL{1.35in}@{}}
+\toprule
+\textbf{label} & \textbf{physical leg} & \textbf{outgoing state} &
+\textbf{momentum} & \textbf{states} & \textbf{colour role} \\
+\midrule
+$1$ & incoming $d$ & outgoing $\bar d$ & $q_1=-p_1$ & $2$ &
+  $\overline{\mathbf 3}$, line end \\
+$2$ & incoming $\bar d$ & outgoing $d$ & $q_2=-p_2$ & $2$ &
+  $\mathbf 3$, line start \\
+$3$ & outgoing $Z$ & outgoing $Z$ & $q_3=p_3$ & $3$ & singlet \\
+$4$ & outgoing $g$ & outgoing $g$ & $q_4=p_4$ & $2$ & adjoint insertion \\
+$5$ & outgoing $g$ & outgoing $g$ & $q_5=p_5$ & $2$ & adjoint insertion \\
+\bottomrule
+\end{tabular}
+\end{center}
+
+There are \(2\times2\times3\times2\times2=48\) physical helicity
+configurations.  Twenty-four vanish identically because the massless quark line
+permits only chirality-compatible initial-state helicities; they remain
+explicit zero entries in resolved results.
+
+At leading colour the \(Z\) is absent from the colour word.  Complete coverage
+contains the two orderings
+\begin{equation}
+  c_0=(2,4,5,1),\qquad c_1=(2,5,4,1).
+  \label{eq:zgg-physical-flows}
+\end{equation}
+Both are retained during generation, so either flow can be selected at
+evaluation time.
+
+\subsection{Reusable current recursion}
+
+For a nonempty source subset \(I\), define its momentum by
+\begin{equation}
+  q_I=\sum_{i\in I}q_i .
+  \label{eq:zgg-subset-mask}
+\end{equation}
+A one-leg current is the appropriate external spinor, polarization vector, or
+scalar wavefunction.  Composite currents obey the binary recursion
+\begin{equation}
+  J_{t,\Omega}^{a}(I)
+  =P_t{}^{a}{}_{b}(q_I)
+   \sum_{\substack{I=A\mathbin{\dot\cup}B\\
+                   A,B\ne\varnothing}}
+   \sum_{v\,:\,t_A t_B\to t}
+   \kappa_v\,
+   V_v{}^{b}{}_{cd}(q_A,q_B)
+   J_{t_A,\Omega_A}^{c}(A)
+   J_{t_B,\Omega_B}^{d}(B).
+  \label{eq:zgg-current-recursion}
+\end{equation}
+Here \(t\) is the particle state, \(P_t\) is its propagator, \(V_v\) is an
+allowed interaction, and \(\Omega\) collects the quantum numbers required to
+identify the current.  Only combinations consistent with the model,
+perturbative order, and colour ordering enter the sum.
+
+Representative terms along the quark line are
+\begin{align}
+ J_d(2,5) &={P}_d\,V_{dgd}\bigl[J_d(2),J_g(5)\bigr],
+ \label{eq:zgg-j25}\\
+ J_g(4,5) &={P}_g\,V_{ggg}\bigl[J_g(4),J_g(5)\bigr],
+ \label{eq:zgg-j45}\\
+ J_d(2,4,5) &={P}_d\Bigl(
+     V_{dgd}\bigl[J_d(2,5),J_g(4)\bigr]
+    +V_{dgd}\bigl[J_d(2,4),J_g(5)\bigr]
+    +V_{dgd}\bigl[J_d(2),J_g(4,5)\bigr]
+  \Bigr),
+ \label{eq:zgg-j245}\\
+ J_d(2,3,4,5) &={P}_d\!\sum_{A\dot\cup B=\{2,3,4,5\}}
+   V\bigl[J(A),J(B)\bigr].
+ \label{eq:zgg-j2345}
+\end{align}
+Equation~\eqref{eq:zgg-j2345} includes every admissible placement of the
+\(Z\) emission and both gluon insertions.  Ordered currents such as
+\(J_d(2,5,4)\) and \(J_d(2,4,5)\) remain distinct even though their momentum
+subset is the same.
+
+The final closure joins the endpoint current to source label \(1\):
+\begin{equation}
+  {\cal A}_{h,c}^{(r)}
+  =C^{(r)}_{\dot a a}\,
+   J_{\bar d}^{\dot a}(1)\,
+   J_d^a(2,3,4,5),
+  \qquad
+  {\cal A}_{h,c}=\sum_{r\in G(h,c)}{\cal A}_{h,c}^{(r)} .
+  \label{eq:zgg-amplitude-root}
+\end{equation}
+The set \(G(h,c)\) contains contributions that must be summed coherently.
+Identical subcurrents are evaluated once and reused wherever their complete
+quantum-number and ordering labels agree.  This sharing is the essential
+difference between the current DAG and an independent evaluation of every
+Feynman diagram.
+
+\subsection{Resolved observable and normalization}
+
+The two leading-colour execution layouts evaluate the same complete set of
+helicity and flow components.  One is optimized for a selected flow with summed helicities;
+the other shares work across all flows for a selected helicity.  Their resolved
+components and their summed matrix element are numerically identical.
+
+For the built-in Standard Model, the normalization used in this example is
+\begin{equation}
+  |{\cal M}|^2
+  ={\cal N}\sum_{h,c}w_{h,c}\,
+     \left|\sum_{r\in G(h,c)}{\cal A}_{h,c}^{(r)}\right|^2,
+  \qquad
+  {\cal N}=\frac{27\,(4\pi\alpha_s)^2(8\pi\alpha_{\rm EW})}
+                  {36\times2}.
+  \label{eq:zgg-normalization}
+\end{equation}
+The denominator averages over the incoming colour and spin states, while the
+factor \(2=2!\) accounts for the identical final-state gluons.  Coupling
+powers, colour weights, coherent groups, and symmetry factors are retained
+separately so that changing numerical model parameters does not alter the
+process definition.
diff --git a/pyamplicol/src/pyamplicol/_profiling_campaign/steer_performance_campaign.py b/pyamplicol/src/pyamplicol/_profiling_campaign/steer_performance_campaign.py
new file mode 100755
index 0000000000..071a694a63
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_profiling_campaign/steer_performance_campaign.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Steer a copied pyAmpliCol profiling campaign."""
+
+from __future__ import annotations
+
+import os
+import sys
+from importlib import import_module
+from pathlib import Path
+
+
+def _entrypoint_from_invocation(raw_entrypoint: str) -> Path:
+    """Preserve a trustworthy lexical campaign path for relative launchers."""
+
+    entrypoint = Path(raw_entrypoint)
+    if entrypoint.is_absolute():
+        return Path(os.path.abspath(os.fspath(entrypoint)))
+
+    logical_text = os.environ.get("PWD")
+    logical_cwd = Path(logical_text) if logical_text else None
+    try:
+        physical_cwd = Path.cwd()
+        same_directory = (
+            logical_cwd is not None
+            and logical_cwd.is_absolute()
+            and logical_cwd.samefile(physical_cwd)
+        )
+    except OSError:
+        same_directory = False
+    if not same_directory:
+        raise RuntimeError(
+            "campaign launcher cannot identify its working directory: "
+            "the shell PWD is missing or no longer names the physical directory. "
+            "Run `cd ..` and re-enter the intended campaign directory, then retry "
+            "(or invoke its absolute path from another working directory)."
+        )
+    return Path(os.path.abspath(os.fspath(logical_cwd / entrypoint)))
+
+
+def _repository_root(entrypoint: Path) -> Path:
+    for candidate in entrypoint.parents:
+        if (candidate / "tools/performance_report").is_dir() and (
+            candidate / "src/pyamplicol"
+        ).is_dir():
+            return candidate
+    raise RuntimeError("campaign entrypoint is not inside a pyAmpliCol checkout")
+
+
+def _embedded_profile(entrypoint: Path, repo_root: Path) -> str:
+    """Derive the campaign identity from its directory under report profiles."""
+
+    profile_parent = repo_root / "docs/performance_reports"
+    try:
+        relative = entrypoint.parent.relative_to(profile_parent)
+    except ValueError as error:
+        raise RuntimeError(
+            "campaign entrypoint must be directly inside "
+            "docs/performance_reports/<campaign>"
+        ) from error
+    if len(relative.parts) != 1:
+        raise RuntimeError(
+            "campaign entrypoint must be directly inside "
+            "docs/performance_reports/<campaign>"
+        )
+    return relative.parts[0]
+
+
+def _reexecute_with_repository_python(repo_root: Path, entrypoint: Path) -> None:
+    expected = repo_root / ".venv/bin/python"
+    if not expected.is_file():
+        raise RuntimeError(
+            f"repository Python is unavailable at {expected}; run `just dev-install`"
+        )
+    try:
+        current_environment = Path(sys.prefix).resolve(strict=True)
+        expected_environment = (repo_root / ".venv").resolve(strict=True)
+    except OSError as error:
+        raise RuntimeError(f"cannot resolve repository Python: {error}") from error
+    if current_environment == expected_environment:
+        return
+    environment = dict(os.environ)
+    # macOS framework Python leaves this launcher hint behind when a shebang
+    # process execs a virtual-environment interpreter.  Keeping it can make
+    # the new interpreter ignore the repository venv's site-packages.
+    environment.pop("__PYVENV_LAUNCHER__", None)
+    environment.pop("PYTHONHOME", None)
+    os.execve(
+        os.fspath(expected),
+        (os.fspath(expected), os.fspath(entrypoint), *sys.argv[1:]),
+        environment,
+    )
+
+
+def main() -> int:
+    # Keep the lexical path until the controller has rejected symlinked
+    # campaign directories and ancestors.  Resolving here would erase the
+    # exact path that must be validated before campaign state is opened.
+    try:
+        entrypoint = _entrypoint_from_invocation(sys.argv[0])
+    except RuntimeError as error:
+        sys.stderr.write(f"error: {error}\n")
+        return 2
+    profile = entrypoint.parent.name
+    try:
+        repo_root = _repository_root(entrypoint)
+        source_profile = _embedded_profile(entrypoint, repo_root)
+    except RuntimeError:
+        installed = import_module(
+            "pyamplicol._performance_report.manual_campaign"
+        )
+        return installed.main(
+            sys.argv[1:],
+            repo_root=entrypoint.parent,
+            profile=profile,
+            docs_dir=entrypoint.parent,
+            installed=True,
+            launcher_path_checked=True,
+        )
+
+    _reexecute_with_repository_python(repo_root, entrypoint)
+    sys.path.insert(0, os.fspath(repo_root))
+    sys.path.insert(0, os.fspath(repo_root / "src"))
+    from tools.performance_report.manual_campaign import main as campaign_main
+
+    return campaign_main(
+        sys.argv[1:],
+        repo_root=repo_root,
+        profile=source_profile,
+        docs_dir=entrypoint.parent,
+        launcher_path_checked=True,
+    )
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except KeyboardInterrupt:
+        sys.stderr.write("Interrupted; workers were asked to stop cleanly.\n")
+        raise SystemExit(130) from None
diff --git a/pyamplicol/src/pyamplicol/_sdk/__init__.py b/pyamplicol/src/pyamplicol/_sdk/__init__.py
new file mode 100644
index 0000000000..d5ab7c89cc
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_sdk/__init__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: 0BSD
+"""Installed C, C++, and Fortran Rusticol SDK resources."""
+
+from .config import SdkInfo, load_sdk_info
+
+__all__ = ["SdkInfo", "load_sdk_info"]
diff --git a/pyamplicol/src/pyamplicol/_sdk/config.py b/pyamplicol/src/pyamplicol/_sdk/config.py
new file mode 100644
index 0000000000..9e1b3450a0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_sdk/config.py
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: 0BSD
+"""Compatibility import for the standalone, metadata-only SDK query utility."""
+
+from rusticol_config import SdkInfo, SdkUnavailableError, load_sdk_info, main
+
+__all__ = ["SdkInfo", "SdkUnavailableError", "load_sdk_info", "main"]
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/src/pyamplicol/_sdk/rust/rusticol.rs b/pyamplicol/src/pyamplicol/_sdk/rust/rusticol.rs
new file mode 100644
index 0000000000..0ae7ee6e49
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/_sdk/rust/rusticol.rs
@@ -0,0 +1,1836 @@
+// SPDX-License-Identifier: 0BSD
+// Dependency-free safe Rust 2021 bindings for Rusticol C ABI v1.
+
+use std::any::Any;
+use std::error;
+use std::ffi::{c_char, c_int, c_void, CStr, CString};
+use std::fmt;
+use std::marker::PhantomData;
+use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
+use std::path::Path;
+use std::ptr::{self, NonNull};
+use std::rc::Rc;
+
+/// C ABI version implemented by this source wrapper.
+pub const ABI_VERSION: u32 = 1;
+
+/// Dependency-free complex value; no C complex memory layout is assumed.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Complex64 {
+    pub re: f64,
+    pub im: f64,
+}
+
+impl Complex64 {
+    pub const fn new(re: f64, im: f64) -> Self {
+        Self { re, im }
+    }
+}
+
+/// A literal vector on a one-based public leg. One entry broadcasts over points.
+#[derive(Clone, Debug)]
+pub struct SpinCorrelationVector {
+    pub leg: usize,
+    pub components: Vec<[Complex64; 4]>,
+}
+
+#[derive(Clone, Debug)]
+pub struct CorrelatedRequest {
+    pub color_correlation: String,
+    /// None inherits the setter; Some(vec![]) selects physical helicities.
+    pub spin_vectors: Option<Vec<SpinCorrelationVector>>,
+}
+
+impl CorrelatedRequest {
+    pub fn new(color_correlation: impl Into<String>) -> Self {
+        Self {
+            color_correlation: color_correlation.into(),
+            spin_vectors: None,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct CorrelatedEvaluation {
+    pub values: Vec<Complex64>,
+    pub request_count: usize,
+    pub point_count: usize,
+}
+
+impl CorrelatedEvaluation {
+    /// Access request-major output by its zero-based request and point indices.
+    pub fn get(&self, request: usize, point: usize) -> Option<Complex64> {
+        if request >= self.request_count || point >= self.point_count {
+            None
+        } else {
+            self.values
+                .get(request.checked_mul(self.point_count)?.checked_add(point)?)
+                .copied()
+        }
+    }
+}
+
+/// The category of a Rusticol SDK error.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ErrorKind {
+    InvalidArgument,
+    BufferTooSmall,
+    Runtime,
+    Panic,
+    AbiMismatch,
+    InvalidInput,
+    InvalidUtf8,
+    InvalidResponse,
+    SizeOverflow,
+    UnknownStatus(c_int),
+}
+
+/// A typed error returned by the safe Rusticol wrapper.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+    kind: ErrorKind,
+    message: String,
+}
+
+impl Error {
+    fn new(kind: ErrorKind, message: impl Into<String>) -> Self {
+        Self {
+            kind,
+            message: message.into(),
+        }
+    }
+
+    fn from_status(status: c_int) -> Self {
+        let kind = match status {
+            ffi::STATUS_INVALID_ARGUMENT => ErrorKind::InvalidArgument,
+            ffi::STATUS_BUFFER_TOO_SMALL => ErrorKind::BufferTooSmall,
+            ffi::STATUS_RUNTIME_ERROR => ErrorKind::Runtime,
+            ffi::STATUS_PANIC => ErrorKind::Panic,
+            other => ErrorKind::UnknownStatus(other),
+        };
+        Self::new(kind, last_error_message(status))
+    }
+
+    pub fn kind(&self) -> ErrorKind {
+        self.kind
+    }
+
+    pub fn message(&self) -> &str {
+        &self.message
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(&self.message)
+    }
+}
+
+impl error::Error for Error {}
+
+/// Result type used by the safe Rusticol wrapper.
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ExternalParticle {
+    pub index: usize,
+    pub pdg: i32,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct HelicityConfiguration {
+    pub id: String,
+    pub helicities: Vec<i32>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ColorComponent {
+    pub id: String,
+    pub kind: String,
+    pub word: Vec<usize>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ModelParameter {
+    pub name: String,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum WarmUpEventKind {
+    Start,
+    Update,
+    End,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum WarmUpStage {
+    ProcessPreparation,
+    QueryFamily,
+    FamilyFinalization,
+    FirstEvaluation,
+}
+
+/// One throttled progress snapshot from an explicit OTF warm-up.
+#[derive(Clone, Debug, PartialEq)]
+pub struct WarmUpProgress {
+    pub schema_version: u32,
+    pub kind: WarmUpEventKind,
+    pub stage: WarmUpStage,
+    pub completed: u64,
+    pub total: u64,
+    pub elapsed_seconds: f64,
+    pub current_rss_bytes: Option<u64>,
+    pub peak_rss_bytes: Option<u64>,
+    pub workers: u64,
+}
+
+impl WarmUpProgress {
+    fn from_ffi(event: &ffi::WarmUpProgressEvent) -> Result<Self> {
+        if event.schema_version != 1 {
+            return Err(Error::new(
+                ErrorKind::InvalidResponse,
+                format!(
+                    "Rusticol returned unsupported warm-up progress schema {}",
+                    event.schema_version
+                ),
+            ));
+        }
+        let kind = match event.kind {
+            ffi::WARM_UP_EVENT_START => WarmUpEventKind::Start,
+            ffi::WARM_UP_EVENT_UPDATE => WarmUpEventKind::Update,
+            ffi::WARM_UP_EVENT_END => WarmUpEventKind::End,
+            value => {
+                return Err(Error::new(
+                    ErrorKind::InvalidResponse,
+                    format!("Rusticol returned unknown warm-up event kind {value}"),
+                ));
+            }
+        };
+        let stage = match event.stage {
+            ffi::WARM_UP_STAGE_PROCESS_PREPARATION => WarmUpStage::ProcessPreparation,
+            ffi::WARM_UP_STAGE_QUERY_FAMILY => WarmUpStage::QueryFamily,
+            ffi::WARM_UP_STAGE_FAMILY_FINALIZATION => WarmUpStage::FamilyFinalization,
+            ffi::WARM_UP_STAGE_FIRST_EVALUATION => WarmUpStage::FirstEvaluation,
+            value => {
+                return Err(Error::new(
+                    ErrorKind::InvalidResponse,
+                    format!("Rusticol returned unknown warm-up stage {value}"),
+                ));
+            }
+        };
+        Ok(Self {
+            schema_version: event.schema_version,
+            kind,
+            stage,
+            completed: event.completed,
+            total: event.total,
+            elapsed_seconds: event.elapsed_seconds,
+            current_rss_bytes: (event.current_rss_available != 0)
+                .then_some(event.current_rss_bytes),
+            peak_rss_bytes: (event.peak_rss_available != 0).then_some(event.peak_rss_bytes),
+            workers: event.workers,
+        })
+    }
+}
+
+/// Summary of exactly one binary64 point used to warm an OTF selection.
+#[derive(Clone, Debug, PartialEq)]
+pub struct WarmUpResult {
+    pub schema_version: u32,
+    pub elapsed_seconds: f64,
+    pub query_count: u64,
+    pub warmed_query_count: u64,
+    pub current_rss_bytes: Option<u64>,
+    pub peak_rss_bytes: Option<u64>,
+    pub already_warm: bool,
+    pub first_evaluation_completed: bool,
+}
+
+impl WarmUpResult {
+    fn from_ffi(result: ffi::WarmUpResult) -> Result<Self> {
+        if result.schema_version != 1 {
+            return Err(Error::new(
+                ErrorKind::InvalidResponse,
+                format!(
+                    "Rusticol returned unsupported warm-up result schema {}",
+                    result.schema_version
+                ),
+            ));
+        }
+        if result.first_evaluation_completed == 0 {
+            return Err(Error::new(
+                ErrorKind::InvalidResponse,
+                "Rusticol reported a successful warm-up without its first evaluation",
+            ));
+        }
+        Ok(Self {
+            schema_version: result.schema_version,
+            elapsed_seconds: result.elapsed_seconds,
+            query_count: result.query_count,
+            warmed_query_count: result.warmed_query_count,
+            current_rss_bytes: (result.current_rss_available != 0)
+                .then_some(result.current_rss_bytes),
+            peak_rss_bytes: (result.peak_rss_available != 0).then_some(result.peak_rss_bytes),
+            already_warm: result.already_warm != 0,
+            first_evaluation_completed: true,
+        })
+    }
+}
+
+struct WarmUpCallbackState<'a> {
+    callback: &'a mut dyn FnMut(&WarmUpProgress) -> bool,
+    conversion_error: Option<Error>,
+    panic_payload: Option<Box<dyn Any + Send>>,
+}
+
+unsafe extern "C" fn warm_up_progress_trampoline(
+    event: *const ffi::WarmUpProgressEvent,
+    user_data: *mut c_void,
+) -> c_int {
+    if event.is_null() || user_data.is_null() {
+        return 0;
+    }
+    // SAFETY: `Runtime::warm_up_f64` passes this stack-owned state and the C
+    // ABI invokes the callback synchronously on the coordinating thread only.
+    let state = unsafe { &mut *user_data.cast::<WarmUpCallbackState<'_>>() };
+    // SAFETY: The C ABI promises a borrowed event for this callback invocation.
+    let event = match WarmUpProgress::from_ffi(unsafe { &*event }) {
+        Ok(event) => event,
+        Err(error) => {
+            state.conversion_error = Some(error);
+            return 0;
+        }
+    };
+    let terminal =
+        event.kind == WarmUpEventKind::End && event.stage == WarmUpStage::FirstEvaluation;
+    match catch_unwind(AssertUnwindSafe(|| (state.callback)(&event))) {
+        Ok(keep_going) => c_int::from(keep_going),
+        Err(_) if terminal => 1,
+        Err(payload) => {
+            state.panic_payload = Some(payload);
+            0
+        }
+    }
+}
+
+/// Typed physics metadata used to interpret resolved output axes.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PhysicsMetadata {
+    pub process: String,
+    pub process_key: String,
+    pub color_accuracy: String,
+    pub external_particles: Vec<ExternalParticle>,
+    pub helicities: Vec<HelicityConfiguration>,
+    pub colors: Vec<ColorComponent>,
+}
+
+/// Physical component selectors for resolved evaluation.
+///
+/// An empty axis selects every component on that axis. Selected output remains
+/// in the artifact's canonical metadata order.
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct Selectors {
+    helicity_ids: Vec<String>,
+    color_ids: Vec<String>,
+}
+
+impl Selectors {
+    pub fn all() -> Self {
+        Self::default()
+    }
+
+    pub fn with_helicities<I, S>(mut self, ids: I) -> Self
+    where
+        I: IntoIterator<Item = S>,
+        S: Into<String>,
+    {
+        self.helicity_ids = ids.into_iter().map(Into::into).collect();
+        self
+    }
+
+    pub fn with_colors<I, S>(mut self, ids: I) -> Self
+    where
+        I: IntoIterator<Item = S>,
+        S: Into<String>,
+    {
+        self.color_ids = ids.into_iter().map(Into::into).collect();
+        self
+    }
+
+    pub fn helicity_ids(&self) -> &[String] {
+        &self.helicity_ids
+    }
+
+    pub fn color_ids(&self) -> &[String] {
+        &self.color_ids
+    }
+}
+
+/// One atomic model-parameter update in a batch.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParameterUpdate {
+    pub name: String,
+    pub real: f64,
+    pub imaginary: f64,
+}
+
+impl ParameterUpdate {
+    pub fn new(name: impl Into<String>, real: f64, imaginary: f64) -> Self {
+        Self {
+            name: name.into(),
+            real,
+            imaginary,
+        }
+    }
+}
+
+/// Owned resolved f64 matrix elements with typed physical axes.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ResolvedEvaluation {
+    values: Vec<f64>,
+    point_count: usize,
+    helicities: Vec<HelicityConfiguration>,
+    colors: Vec<ColorComponent>,
+}
+
+impl ResolvedEvaluation {
+    pub fn values(&self) -> &[f64] {
+        &self.values
+    }
+
+    pub fn point_count(&self) -> usize {
+        self.point_count
+    }
+
+    pub fn helicities(&self) -> &[HelicityConfiguration] {
+        &self.helicities
+    }
+
+    pub fn colors(&self) -> &[ColorComponent] {
+        &self.colors
+    }
+
+    pub fn shape(&self) -> (usize, usize, usize) {
+        (self.point_count, self.helicities.len(), self.colors.len())
+    }
+
+    pub fn get(&self, point: usize, helicity: usize, color: usize) -> Option<f64> {
+        if point >= self.point_count
+            || helicity >= self.helicities.len()
+            || color >= self.colors.len()
+        {
+            return None;
+        }
+        let offset = (point * self.helicities.len() + helicity) * self.colors.len() + color;
+        self.values.get(offset).copied()
+    }
+
+    /// Explicitly sum every resolved component for each phase-space point.
+    pub fn totals(&self) -> Vec<f64> {
+        let stride = self.helicities.len() * self.colors.len();
+        self.values
+            .chunks_exact(stride)
+            .map(|point| point.iter().sum())
+            .collect()
+    }
+}
+
+/// Owning Rusticol runtime handle.
+///
+/// Methods requiring mutable runtime state take `&mut self`. The marker keeps
+/// a handle on its creating thread because C ABI v1 does not promise that an
+/// individual handle may be transferred between threads.
+pub struct Runtime {
+    handle: NonNull<ffi::RuntimeHandle>,
+    _thread_bound: PhantomData<Rc<()>>,
+}
+
+impl Runtime {
+    /// Load an artifact, optionally selecting a process and applying a JSON
+    /// model-parameter card before the runtime becomes visible to the caller.
+    pub fn load(
+        artifact: impl AsRef<Path>,
+        process_key: Option<&str>,
+        model_parameters_path: Option<&Path>,
+    ) -> Result<Self> {
+        ensure_abi_version()?;
+        let artifact = path_cstring(artifact.as_ref(), "artifact path")?;
+        let process_key = optional_cstring(process_key, "process selector")?;
+        let model_parameters = model_parameters_path
+            .map(|path| path_cstring(path, "model-parameter path"))
+            .transpose()?;
+        let mut handle = ptr::null_mut();
+        // SAFETY: CStrings remain live for the call and output points to writable storage.
+        check(unsafe {
+            ffi::runtime_load(
+                artifact.as_ptr(),
+                optional_pointer(&process_key),
+                optional_pointer(&model_parameters),
+                &mut handle,
+            )
+        })?;
+        let handle = NonNull::new(handle).ok_or_else(|| {
+            Error::new(
+                ErrorKind::InvalidResponse,
+                "Rusticol returned a null runtime handle after a successful load",
+            )
+        })?;
+        Ok(Self {
+            handle,
+            _thread_bound: PhantomData,
+        })
+    }
+
+    /// Save the completed, retained OTF recursion cache without warming new selections.
+    /// The cache file complements, rather than replaces, the generated process output.
+    pub fn save(&self, path: impl AsRef<Path>) -> Result<()> {
+        let path = path_cstring(path.as_ref(), "cache path")?;
+        // SAFETY: The owning handle and NUL-terminated path remain live for the call.
+        check(unsafe { ffi::runtime_save(self.handle.as_ptr(), path.as_ptr()) })
+    }
+
+    /// Restore a saved OTF cache into this already-loaded matching process.
+    pub fn load_cache(&mut self, path: impl AsRef<Path>) -> Result<()> {
+        let path = path_cstring(path.as_ref(), "cache path")?;
+        // SAFETY: The uniquely borrowed handle and path remain live for the call.
+        check(unsafe { ffi::runtime_load_cache(self.handle.as_ptr(), path.as_ptr()) })
+    }
+
+    pub fn process(&self) -> Result<String> {
+        self.get_string(ffi::runtime_process)
+    }
+
+    pub fn process_key(&self) -> Result<String> {
+        self.get_string(ffi::runtime_process_key)
+    }
+
+    pub fn representative_process_key(&self) -> Result<String> {
+        self.get_string(ffi::runtime_representative_process_key)
+    }
+
+    pub fn color_accuracy(&self) -> Result<String> {
+        self.get_string(ffi::runtime_color_accuracy)
+    }
+
+    pub fn metadata_json(&self) -> Result<String> {
+        self.get_string(ffi::runtime_metadata_json)
+    }
+
+    pub fn execution_mode(&self) -> Result<String> {
+        self.get_string(ffi::runtime_execution_mode)
+    }
+
+    pub fn physics_json(&self) -> Result<String> {
+        self.get_string(ffi::runtime_physics_json)
+    }
+
+    pub fn external_particles(&self) -> Result<Vec<ExternalParticle>> {
+        let mut count = 0;
+        // SAFETY: The RAII handle is live and count is writable.
+        check(unsafe { ffi::runtime_external_count(self.handle.as_ptr(), &mut count) })?;
+        let mut particles = Vec::with_capacity(count);
+        for index in 0..count {
+            let mut pdg = 0;
+            // SAFETY: The RAII handle is live and pdg is writable.
+            check(unsafe { ffi::runtime_external_pdg(self.handle.as_ptr(), index, &mut pdg) })?;
+            particles.push(ExternalParticle { index, pdg });
+        }
+        Ok(particles)
+    }
+
+    /// Representative-index to public/requested-index external-leg permutation.
+    pub fn external_permutation(&self) -> Result<Vec<usize>> {
+        read_usize_vector(|output, capacity, required| {
+            // SAFETY: The helper owns a correctly sized output buffer for the live handle.
+            unsafe {
+                ffi::runtime_external_permutation(self.handle.as_ptr(), output, capacity, required)
+            }
+        })
+    }
+
+    /// Load one public-order JSON kinematic point as flattened f64 components.
+    pub fn load_kinematics_json(&self, path: impl AsRef<Path>) -> Result<Vec<f64>> {
+        let path = path_cstring(path.as_ref(), "kinematics path")?;
+        read_f64_vector(|output, capacity, required| {
+            // SAFETY: The path and output storage remain live for the call.
+            unsafe {
+                ffi::runtime_load_kinematics_json(
+                    self.handle.as_ptr(),
+                    path.as_ptr(),
+                    output,
+                    capacity,
+                    required,
+                )
+            }
+        })
+    }
+
+    pub fn helicities(&self) -> Result<Vec<HelicityConfiguration>> {
+        let mut count = 0;
+        // SAFETY: The RAII handle is live and count is writable.
+        check(unsafe { ffi::runtime_helicity_count(self.handle.as_ptr(), &mut count) })?;
+        let mut result = Vec::with_capacity(count);
+        for index in 0..count {
+            let id = self.get_indexed_string(ffi::runtime_helicity_id, index)?;
+            let helicities = read_i32_vector(|output, capacity, required| {
+                // SAFETY: The helper owns a correctly sized output buffer for the live handle.
+                unsafe {
+                    ffi::runtime_helicity_vector(
+                        self.handle.as_ptr(),
+                        index,
+                        output,
+                        capacity,
+                        required,
+                    )
+                }
+            })?;
+            result.push(HelicityConfiguration { id, helicities });
+        }
+        Ok(result)
+    }
+
+    pub fn colors(&self) -> Result<Vec<ColorComponent>> {
+        let mut count = 0;
+        // SAFETY: The RAII handle is live and count is writable.
+        check(unsafe { ffi::runtime_color_count(self.handle.as_ptr(), &mut count) })?;
+        let mut result = Vec::with_capacity(count);
+        for index in 0..count {
+            let id = self.get_indexed_string(ffi::runtime_color_id, index)?;
+            let kind = self.get_indexed_string(ffi::runtime_color_kind, index)?;
+            let word = read_usize_vector(|output, capacity, required| {
+                // SAFETY: The helper owns a correctly sized output buffer for the live handle.
+                unsafe {
+                    ffi::runtime_color_word(self.handle.as_ptr(), index, output, capacity, required)
+                }
+            })?;
+            result.push(ColorComponent { id, kind, word });
+        }
+        Ok(result)
+    }
+
+    pub fn model_parameters(&self) -> Result<Vec<ModelParameter>> {
+        let mut count = 0;
+        // SAFETY: The RAII handle is live and count is writable.
+        check(unsafe { ffi::runtime_model_parameter_count(self.handle.as_ptr(), &mut count) })?;
+        (0..count)
+            .map(|index| {
+                self.get_indexed_string(ffi::runtime_model_parameter_name, index)
+                    .map(|name| ModelParameter { name })
+            })
+            .collect()
+    }
+
+    pub fn physics(&self) -> Result<PhysicsMetadata> {
+        Ok(PhysicsMetadata {
+            process: self.process()?,
+            process_key: self.process_key()?,
+            color_accuracy: self.color_accuracy()?,
+            external_particles: self.external_particles()?,
+            helicities: self.helicities()?,
+            colors: self.colors()?,
+        })
+    }
+
+    /// Evaluate compatibility totals for one or more flattened momentum points.
+    pub fn evaluate_f64(&mut self, momenta: &[f64], point_count: usize) -> Result<Vec<f64>> {
+        self.validate_momenta(momenta, point_count)?;
+        let mut values = vec![0.0; point_count];
+        // SAFETY: Input and output slices are disjoint, sized, and live for the call.
+        check(unsafe {
+            ffi::runtime_evaluate_f64(
+                self.handle.as_ptr(),
+                momenta.as_ptr(),
+                momenta.len(),
+                point_count,
+                values.as_mut_ptr(),
+                values.len(),
+            )
+        })?;
+        Ok(values)
+    }
+
+    pub fn color_correlation_catalogue_json(&mut self) -> Result<String> {
+        read_string(|buffer, capacity, required| {
+            // SAFETY: read_string owns the output buffer; this handle is exclusive.
+            unsafe {
+                ffi::rusticol_runtime_color_correlation_catalogue_json(
+                    self.handle.as_ptr(),
+                    buffer,
+                    capacity,
+                    required,
+                )
+            }
+        })
+    }
+
+    pub fn color_correlation_ids(&mut self) -> Result<Vec<String>> {
+        let mut count = 0;
+        // SAFETY: The output and exclusively borrowed handle are live.
+        check(unsafe {
+            ffi::rusticol_runtime_color_correlation_count(self.handle.as_ptr(), &mut count)
+        })?;
+        (0..count)
+            .map(|index| {
+                read_string(|buffer, capacity, required| {
+                    // SAFETY: read_string owns the output buffer.
+                    unsafe {
+                        ffi::rusticol_runtime_color_correlation_id(
+                            self.handle.as_ptr(),
+                            index,
+                            buffer,
+                            capacity,
+                            required,
+                        )
+                    }
+                })
+            })
+            .collect()
+    }
+
+    /// Replace defaults atomically; an empty slice clears them. Ordinary calls are unaffected.
+    pub fn set_spin_correlation_vectors(
+        &mut self,
+        vectors: &[SpinCorrelationVector],
+    ) -> Result<()> {
+        let storage = SpinCorrelationStorage::new(vectors);
+        // SAFETY: storage owns every component and descriptor until the call returns.
+        check(unsafe {
+            ffi::rusticol_runtime_set_spin_correlation_vectors_f64(
+                self.handle.as_ptr(),
+                storage.vectors.as_ptr(),
+                storage.vectors.len(),
+            )
+        })
+    }
+
+    pub fn evaluate_correlated_many_f64(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        requests: &[CorrelatedRequest],
+        helicity_ids: &[String],
+    ) -> Result<CorrelatedEvaluation> {
+        self.validate_momenta(momenta, point_count)?;
+        if requests.is_empty() {
+            return Err(Error::new(
+                ErrorKind::InvalidInput,
+                "a correlated batch requires requests",
+            ));
+        }
+        let output_count = requests
+            .len()
+            .checked_mul(point_count)
+            .and_then(|n| n.checked_mul(2))
+            .ok_or_else(|| {
+                Error::new(
+                    ErrorKind::SizeOverflow,
+                    "correlated output dimensions overflow",
+                )
+            })?;
+        let ids = requests
+            .iter()
+            .map(|request| checked_cstring(&request.color_correlation, "colour correlation ID"))
+            .collect::<Result<Vec<_>>>()?;
+        let storage = requests
+            .iter()
+            .map(|request| {
+                SpinCorrelationStorage::new(request.spin_vectors.as_deref().unwrap_or(&[]))
+            })
+            .collect::<Vec<_>>();
+        let raw_requests = requests
+            .iter()
+            .zip(&ids)
+            .zip(&storage)
+            .map(|((request, id), vectors)| ffi::CorrelatedRequest {
+                color_correlation: id.as_ptr(),
+                spin_vectors: vectors.vectors.as_ptr(),
+                spin_vector_count: vectors.vectors.len(),
+                use_default_spin_vectors: u32::from(request.spin_vectors.is_none()),
+            })
+            .collect::<Vec<_>>();
+        let helicities = cstring_list(helicity_ids, "helicity ID")?;
+        let helicity_pointers = cstring_pointers(&helicities);
+        let mut raw = vec![0.0; output_count];
+        // SAFETY: Owned buffers retain all nested pointers; output is disjoint and correctly sized.
+        check(unsafe {
+            ffi::rusticol_runtime_evaluate_correlated_many_f64(
+                self.handle.as_ptr(),
+                momenta.as_ptr(),
+                momenta.len(),
+                point_count,
+                raw_requests.as_ptr(),
+                raw_requests.len(),
+                helicity_pointers.as_ptr(),
+                helicity_pointers.len(),
+                raw.as_mut_ptr(),
+                raw.len(),
+            )
+        })?;
+        Ok(CorrelatedEvaluation {
+            values: raw
+                .chunks_exact(2)
+                .map(|value| Complex64::new(value[0], value[1]))
+                .collect(),
+            request_count: requests.len(),
+            point_count,
+        })
+    }
+
+    pub fn evaluate_correlated_f64(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        request: &CorrelatedRequest,
+        helicity_ids: &[String],
+    ) -> Result<Vec<Complex64>> {
+        self.evaluate_correlated_many_f64(
+            momenta,
+            point_count,
+            std::slice::from_ref(request),
+            helicity_ids,
+        )
+        .map(|result| result.values)
+    }
+
+    /// Construct and retain one selected OTF family, then evaluate exactly one
+    /// binary64 point. The optional callback receives throttled progress and
+    /// may return `false` to cancel at the next cold-path boundary.
+    /// `n_cores=None` uses the process-output construction default; `Some(n)`
+    /// requires `n > 0` and overrides construction workers for this call only.
+    /// Evaluation defaults and structural cache identity are unchanged.
+    pub fn warm_up(
+        &mut self,
+        point: &[f64],
+        selectors: &Selectors,
+        n_cores: Option<usize>,
+        progress: Option<&mut dyn FnMut(&WarmUpProgress) -> bool>,
+    ) -> Result<WarmUpResult> {
+        self.warm_up_f64(point, selectors, n_cores, progress)
+    }
+
+    /// Binary64-explicit alias for [`Runtime::warm_up`].
+    ///
+    /// Callback panics are contained at the C boundary and resumed after the
+    /// native call returns. The terminal post-commit notification is
+    /// non-cancellable, so its callback result or panic is ignored.
+    pub fn warm_up_f64(
+        &mut self,
+        point: &[f64],
+        selectors: &Selectors,
+        n_cores: Option<usize>,
+        progress: Option<&mut dyn FnMut(&WarmUpProgress) -> bool>,
+    ) -> Result<WarmUpResult> {
+        if n_cores == Some(0) {
+            return Err(Error::new(
+                ErrorKind::InvalidArgument,
+                "warm-up n_cores must be positive",
+            ));
+        }
+        let n_cores = n_cores.unwrap_or(0);
+        self.validate_momenta(point, 1)?;
+        let helicity_strings = cstring_list(&selectors.helicity_ids, "helicity selector")?;
+        let color_strings = cstring_list(&selectors.color_ids, "color selector")?;
+        let helicity_pointers = cstring_pointers(&helicity_strings);
+        let color_pointers = cstring_pointers(&color_strings);
+        let (helicity_pointer, helicity_count) = selector_parts(&helicity_pointers);
+        let (color_pointer, color_count) = selector_parts(&color_pointers);
+        let mut result = ffi::WarmUpResult::default();
+
+        let status = if let Some(callback) = progress {
+            let mut state = WarmUpCallbackState {
+                callback,
+                conversion_error: None,
+                panic_payload: None,
+            };
+            // SAFETY: Every input and selector allocation remains live. The
+            // callback state is stack-owned for this synchronous call.
+            let status = unsafe {
+                ffi::runtime_warm_up_f64_with_cores(
+                    self.handle.as_ptr(),
+                    point.as_ptr(),
+                    point.len(),
+                    helicity_pointer,
+                    helicity_count,
+                    color_pointer,
+                    color_count,
+                    n_cores,
+                    Some(warm_up_progress_trampoline),
+                    (&mut state as *mut WarmUpCallbackState<'_>).cast(),
+                    &mut result,
+                )
+            };
+            if let Some(payload) = state.panic_payload {
+                resume_unwind(payload);
+            }
+            if let Some(error) = state.conversion_error {
+                return Err(error);
+            }
+            status
+        } else {
+            // SAFETY: Every input and selector allocation remains live; both
+            // callback pointers are null together.
+            unsafe {
+                ffi::runtime_warm_up_f64_with_cores(
+                    self.handle.as_ptr(),
+                    point.as_ptr(),
+                    point.len(),
+                    helicity_pointer,
+                    helicity_count,
+                    color_pointer,
+                    color_count,
+                    n_cores,
+                    None,
+                    ptr::null_mut(),
+                    &mut result,
+                )
+            }
+        };
+        check(status)?;
+        WarmUpResult::from_ffi(result)
+    }
+
+    /// Evaluate one selected total per point.
+    ///
+    /// Global string selectors retain subset/sum semantics. Per-point selector
+    /// arrays contain zero-based physical-axis indices and must contain exactly
+    /// one entry per momentum point. The global and per-point forms are mutually
+    /// exclusive on the same axis.
+    pub fn evaluate_selected_f64(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        selectors: &Selectors,
+        helicity_by_point: Option<&[u32]>,
+        color_flow_by_point: Option<&[u32]>,
+    ) -> Result<Vec<f64>> {
+        self.validate_momenta(momenta, point_count)?;
+        if !selectors.helicity_ids.is_empty() && helicity_by_point.is_some() {
+            return Err(Error::new(
+                ErrorKind::InvalidArgument,
+                "global helicity selectors and helicity_by_point are mutually exclusive",
+            ));
+        }
+        if !selectors.color_ids.is_empty() && color_flow_by_point.is_some() {
+            return Err(Error::new(
+                ErrorKind::InvalidArgument,
+                "global color selectors and color_flow_by_point are mutually exclusive",
+            ));
+        }
+        for (name, values) in [
+            ("helicity_by_point", helicity_by_point),
+            ("color_flow_by_point", color_flow_by_point),
+        ] {
+            if let Some(values) = values {
+                if values.len() != point_count {
+                    return Err(Error::new(
+                        ErrorKind::InvalidArgument,
+                        format!(
+                            "{name} contains {} entries, expected {point_count}",
+                            values.len()
+                        ),
+                    ));
+                }
+            }
+        }
+
+        let helicity_strings = cstring_list(&selectors.helicity_ids, "helicity selector")?;
+        let color_strings = cstring_list(&selectors.color_ids, "color selector")?;
+        let helicity_pointers = cstring_pointers(&helicity_strings);
+        let color_pointers = cstring_pointers(&color_strings);
+        let (helicity_pointer, helicity_count) = selector_parts(&helicity_pointers);
+        let (color_pointer, color_count) = selector_parts(&color_pointers);
+        let (helicity_by_point_pointer, helicity_by_point_count) =
+            u32_selector_parts(helicity_by_point);
+        let (color_flow_by_point_pointer, color_flow_by_point_count) =
+            u32_selector_parts(color_flow_by_point);
+        let mut values = vec![0.0; point_count];
+        // SAFETY: All selector and momentum buffers remain live and the output
+        // has exactly one writable entry per point.
+        check(unsafe {
+            ffi::runtime_evaluate_selected_f64(
+                self.handle.as_ptr(),
+                momenta.as_ptr(),
+                momenta.len(),
+                point_count,
+                helicity_pointer,
+                helicity_count,
+                color_pointer,
+                color_count,
+                helicity_by_point_pointer,
+                helicity_by_point_count,
+                color_flow_by_point_pointer,
+                color_flow_by_point_count,
+                values.as_mut_ptr(),
+                values.len(),
+            )
+        })?;
+        Ok(values)
+    }
+
+    /// Evaluate resolved f64 components for one or more momentum points.
+    pub fn evaluate_resolved_f64(
+        &mut self,
+        momenta: &[f64],
+        point_count: usize,
+        selectors: &Selectors,
+    ) -> Result<ResolvedEvaluation> {
+        self.validate_momenta(momenta, point_count)?;
+        let helicity_strings = cstring_list(&selectors.helicity_ids, "helicity selector")?;
+        let color_strings = cstring_list(&selectors.color_ids, "color selector")?;
+        let helicity_pointers = cstring_pointers(&helicity_strings);
+        let color_pointers = cstring_pointers(&color_strings);
+        let (helicity_pointer, helicity_count) = selector_parts(&helicity_pointers);
+        let (color_pointer, color_count) = selector_parts(&color_pointers);
+
+        let mut resolved_helicity_count = 0;
+        let mut resolved_color_count = 0;
+        // SAFETY: Selector CStrings and output dimensions remain live for the call.
+        check(unsafe {
+            ffi::runtime_resolved_shape(
+                self.handle.as_ptr(),
+                helicity_pointer,
+                helicity_count,
+                color_pointer,
+                color_count,
+                &mut resolved_helicity_count,
+                &mut resolved_color_count,
+            )
+        })?;
+        if resolved_helicity_count == 0 || resolved_color_count == 0 {
+            return Err(Error::new(
+                ErrorKind::InvalidResponse,
+                "Rusticol returned an empty resolved axis",
+            ));
+        }
+        let value_count = point_count
+            .checked_mul(resolved_helicity_count)
+            .and_then(|count| count.checked_mul(resolved_color_count))
+            .ok_or_else(|| Error::new(ErrorKind::SizeOverflow, "resolved output shape overflow"))?;
+        let mut values = vec![0.0; value_count];
+        let mut returned_helicity_count = resolved_helicity_count;
+        let mut returned_color_count = resolved_color_count;
+        // SAFETY: Every pointer refers to a live, disjoint, correctly sized allocation.
+        check(unsafe {
+            ffi::runtime_evaluate_resolved_f64(
+                self.handle.as_ptr(),
+                momenta.as_ptr(),
+                momenta.len(),
+                point_count,
+                helicity_pointer,
+                helicity_count,
+                color_pointer,
+                color_count,
+                values.as_mut_ptr(),
+                values.len(),
+                &mut returned_helicity_count,
+                &mut returned_color_count,
+            )
+        })?;
+        if returned_helicity_count != resolved_helicity_count
+            || returned_color_count != resolved_color_count
+        {
+            return Err(Error::new(
+                ErrorKind::InvalidResponse,
+                "Rusticol changed the resolved shape during evaluation",
+            ));
+        }
+
+        let metadata = self.physics()?;
+        let helicities = select_helicities(metadata.helicities, &selectors.helicity_ids);
+        let colors = select_colors(metadata.colors, &selectors.color_ids);
+        if helicities.len() != resolved_helicity_count || colors.len() != resolved_color_count {
+            return Err(Error::new(
+                ErrorKind::InvalidResponse,
+                "Rusticol resolved output does not match its physics metadata",
+            ));
+        }
+        Ok(ResolvedEvaluation {
+            values,
+            point_count,
+            helicities,
+            colors,
+        })
+    }
+
+    pub fn set_model_parameter(&mut self, name: &str, real: f64, imaginary: f64) -> Result<()> {
+        let name = checked_cstring(name, "model-parameter name")?;
+        // SAFETY: The name CString and owning handle remain live for the call.
+        check(unsafe {
+            ffi::runtime_set_model_parameter(self.handle.as_ptr(), name.as_ptr(), real, imaginary)
+        })
+    }
+
+    /// Apply a batch as one atomic update. A failing entry leaves all runtime
+    /// model parameters unchanged.
+    pub fn set_model_parameters(&mut self, updates: &[ParameterUpdate]) -> Result<()> {
+        if updates.is_empty() {
+            return Ok(());
+        }
+        let names = updates
+            .iter()
+            .map(|update| checked_cstring(&update.name, "model-parameter name"))
+            .collect::<Result<Vec<_>>>()?;
+        let name_pointers = cstring_pointers(&names);
+        let real = updates.iter().map(|update| update.real).collect::<Vec<_>>();
+        let imaginary = updates
+            .iter()
+            .map(|update| update.imaginary)
+            .collect::<Vec<_>>();
+        // SAFETY: All arrays have identical nonzero lengths and remain live for the call.
+        check(unsafe {
+            ffi::runtime_set_model_parameters(
+                self.handle.as_ptr(),
+                name_pointers.as_ptr(),
+                real.as_ptr(),
+                imaginary.as_ptr(),
+                updates.len(),
+            )
+        })
+    }
+
+    pub fn set_model_parameters_json(&mut self, path: impl AsRef<Path>) -> Result<()> {
+        let path = path_cstring(path.as_ref(), "model-parameter path")?;
+        // SAFETY: The path CString and owning handle remain live for the call.
+        check(unsafe {
+            ffi::runtime_set_model_parameters_json(self.handle.as_ptr(), path.as_ptr())
+        })
+    }
+
+    pub fn set_warnings_muted(&mut self, muted: bool) -> Result<()> {
+        // SAFETY: The owning handle remains live and exclusively borrowed.
+        check(unsafe { ffi::runtime_mute_warnings(self.handle.as_ptr(), c_int::from(muted)) })
+    }
+
+    pub fn mute_warnings(&mut self) -> Result<()> {
+        self.set_warnings_muted(true)
+    }
+
+    pub fn unmute_warnings(&mut self) -> Result<()> {
+        self.set_warnings_muted(false)
+    }
+
+    /// Return pending warnings as a JSON array and consume them after copying.
+    pub fn take_warnings_json(&mut self) -> Result<String> {
+        read_string(|buffer, capacity, required| {
+            // SAFETY: The helper owns the output buffer and the handle is exclusively borrowed.
+            unsafe {
+                ffi::runtime_take_warnings_json(self.handle.as_ptr(), buffer, capacity, required)
+            }
+        })
+    }
+
+    fn validate_momenta(&self, momenta: &[f64], point_count: usize) -> Result<()> {
+        if point_count == 0 {
+            return Err(Error::new(
+                ErrorKind::InvalidInput,
+                "point_count must be positive",
+            ));
+        }
+        let external_count = self.external_particles()?.len();
+        let expected = point_count
+            .checked_mul(external_count)
+            .and_then(|count| count.checked_mul(4))
+            .ok_or_else(|| Error::new(ErrorKind::SizeOverflow, "momentum shape overflow"))?;
+        if momenta.len() != expected {
+            return Err(Error::new(
+                ErrorKind::InvalidInput,
+                format!(
+                    "momenta contain {} values, expected {expected} for {point_count} point(s)",
+                    momenta.len()
+                ),
+            ));
+        }
+        if momenta.iter().any(|value| !value.is_finite()) {
+            return Err(Error::new(
+                ErrorKind::InvalidInput,
+                "momenta must contain only finite f64 values",
+            ));
+        }
+        Ok(())
+    }
+
+    fn get_string(&self, getter: ffi::StringGetter) -> Result<String> {
+        read_string(|buffer, capacity, required| {
+            // SAFETY: The helper owns the output buffer and the RAII handle is live.
+            unsafe { getter(self.handle.as_ptr(), buffer, capacity, required) }
+        })
+    }
+
+    fn get_indexed_string(&self, getter: ffi::IndexedStringGetter, index: usize) -> Result<String> {
+        read_string(|buffer, capacity, required| {
+            // SAFETY: The helper owns the output buffer and the RAII handle is live.
+            unsafe { getter(self.handle.as_ptr(), index, buffer, capacity, required) }
+        })
+    }
+}
+
+impl Drop for Runtime {
+    fn drop(&mut self) {
+        // SAFETY: Runtime uniquely owns this live handle and frees it exactly once.
+        let _ = unsafe { ffi::runtime_free(self.handle.as_ptr()) };
+    }
+}
+
+pub fn abi_version() -> u32 {
+    // SAFETY: This function has no pointer arguments or mutable state contract.
+    unsafe { ffi::abi_version() }
+}
+
+pub fn ensure_abi_version() -> Result<()> {
+    let observed = abi_version();
+    if observed == ABI_VERSION {
+        Ok(())
+    } else {
+        Err(Error::new(
+            ErrorKind::AbiMismatch,
+            format!(
+                "Rusticol ABI version {observed} does not match required version {ABI_VERSION}"
+            ),
+        ))
+    }
+}
+
+pub fn supported_runtime_capabilities_json() -> Result<String> {
+    read_string(|buffer, capacity, required| {
+        // SAFETY: The helper owns the correctly sized output buffer.
+        unsafe { ffi::supported_runtime_capabilities_json(buffer, capacity, required) }
+    })
+}
+
+fn check(status: c_int) -> Result<()> {
+    if status == ffi::STATUS_OK {
+        Ok(())
+    } else {
+        Err(Error::from_status(status))
+    }
+}
+
+fn last_error_message(original_status: c_int) -> String {
+    let mut required = 0;
+    // SAFETY: A null zero-capacity buffer is the documented size query.
+    let query_status = unsafe { ffi::last_error_message(ptr::null_mut(), 0, &mut required) };
+    if query_status != ffi::STATUS_OK || required == 0 {
+        return format!("Rusticol C ABI call failed with status {original_status}");
+    }
+    let mut buffer = vec![0_u8; required];
+    // SAFETY: The vector provides required writable bytes and remains live for the call.
+    let copy_status =
+        unsafe { ffi::last_error_message(buffer.as_mut_ptr().cast(), buffer.len(), &mut required) };
+    if copy_status != ffi::STATUS_OK {
+        return format!("Rusticol C ABI call failed with status {original_status}");
+    }
+    CStr::from_bytes_until_nul(&buffer)
+        .ok()
+        .and_then(|value| value.to_str().ok())
+        .map(str::to_owned)
+        .unwrap_or_else(|| format!("Rusticol C ABI call failed with status {original_status}"))
+}
+
+fn read_string(mut getter: impl FnMut(*mut c_char, usize, *mut usize) -> c_int) -> Result<String> {
+    let mut required = 0;
+    check(getter(ptr::null_mut(), 0, &mut required))?;
+    if required == 0 {
+        return Err(Error::new(
+            ErrorKind::InvalidResponse,
+            "Rusticol returned a zero-length string buffer",
+        ));
+    }
+    let mut buffer = vec![0_u8; required];
+    let mut copied_required = required;
+    check(getter(
+        buffer.as_mut_ptr().cast(),
+        buffer.len(),
+        &mut copied_required,
+    ))?;
+    if copied_required == 0 || copied_required > buffer.len() {
+        return Err(Error::new(
+            ErrorKind::InvalidResponse,
+            "Rusticol returned an inconsistent string size",
+        ));
+    }
+    let value = CStr::from_bytes_until_nul(&buffer).map_err(|_| {
+        Error::new(
+            ErrorKind::InvalidResponse,
+            "Rusticol returned a string without a trailing NUL",
+        )
+    })?;
+    value.to_str().map(str::to_owned).map_err(|_| {
+        Error::new(
+            ErrorKind::InvalidUtf8,
+            "Rusticol returned a string that is not valid UTF-8",
+        )
+    })
+}
+
+fn read_i32_vector(
+    mut getter: impl FnMut(*mut i32, usize, *mut usize) -> c_int,
+) -> Result<Vec<i32>> {
+    let mut required = 0;
+    check(getter(ptr::null_mut(), 0, &mut required))?;
+    if required == 0 {
+        return Ok(Vec::new());
+    }
+    let mut values = vec![0_i32; required];
+    let mut copied_required = required;
+    check(getter(
+        values.as_mut_ptr(),
+        values.len(),
+        &mut copied_required,
+    ))?;
+    if copied_required != values.len() {
+        return Err(Error::new(
+            ErrorKind::InvalidResponse,
+            "Rusticol returned an inconsistent i32 vector size",
+        ));
+    }
+    Ok(values)
+}
+
+fn read_usize_vector(
+    mut getter: impl FnMut(*mut usize, usize, *mut usize) -> c_int,
+) -> Result<Vec<usize>> {
+    let mut required = 0;
+    check(getter(ptr::null_mut(), 0, &mut required))?;
+    if required == 0 {
+        return Ok(Vec::new());
+    }
+    let mut values = vec![0_usize; required];
+    let mut copied_required = required;
+    check(getter(
+        values.as_mut_ptr(),
+        values.len(),
+        &mut copied_required,
+    ))?;
+    if copied_required != values.len() {
+        return Err(Error::new(
+            ErrorKind::InvalidResponse,
+            "Rusticol returned an inconsistent usize vector size",
+        ));
+    }
+    Ok(values)
+}
+
+fn read_f64_vector(
+    mut getter: impl FnMut(*mut f64, usize, *mut usize) -> c_int,
+) -> Result<Vec<f64>> {
+    let mut required = 0;
+    check(getter(ptr::null_mut(), 0, &mut required))?;
+    if required == 0 {
+        return Ok(Vec::new());
+    }
+    let mut values = vec![0.0_f64; required];
+    let mut copied_required = required;
+    check(getter(
+        values.as_mut_ptr(),
+        values.len(),
+        &mut copied_required,
+    ))?;
+    if copied_required != values.len() {
+        return Err(Error::new(
+            ErrorKind::InvalidResponse,
+            "Rusticol returned an inconsistent f64 vector size",
+        ));
+    }
+    Ok(values)
+}
+
+fn checked_cstring(value: &str, description: &str) -> Result<CString> {
+    CString::new(value).map_err(|_| {
+        Error::new(
+            ErrorKind::InvalidInput,
+            format!("{description} contains a NUL byte"),
+        )
+    })
+}
+
+fn path_cstring(path: &Path, description: &str) -> Result<CString> {
+    let value = path.to_str().ok_or_else(|| {
+        Error::new(
+            ErrorKind::InvalidUtf8,
+            format!("{description} is not valid UTF-8: {}", path.display()),
+        )
+    })?;
+    checked_cstring(value, description)
+}
+
+fn optional_cstring(value: Option<&str>, description: &str) -> Result<Option<CString>> {
+    value
+        .map(|item| checked_cstring(item, description))
+        .transpose()
+}
+
+fn optional_pointer(value: &Option<CString>) -> *const c_char {
+    value.as_ref().map_or(ptr::null(), |item| item.as_ptr())
+}
+
+fn cstring_list(values: &[String], description: &str) -> Result<Vec<CString>> {
+    values
+        .iter()
+        .map(|value| checked_cstring(value, description))
+        .collect()
+}
+
+fn cstring_pointers(values: &[CString]) -> Vec<*const c_char> {
+    values.iter().map(|value| value.as_ptr()).collect()
+}
+
+fn selector_parts(values: &[*const c_char]) -> (*const *const c_char, usize) {
+    if values.is_empty() {
+        (ptr::null(), 0)
+    } else {
+        (values.as_ptr(), values.len())
+    }
+}
+
+fn u32_selector_parts(values: Option<&[u32]>) -> (*const u32, usize) {
+    match values {
+        Some(values) if !values.is_empty() => (values.as_ptr(), values.len()),
+        _ => (ptr::null(), 0),
+    }
+}
+
+fn select_helicities(
+    available: Vec<HelicityConfiguration>,
+    selected: &[String],
+) -> Vec<HelicityConfiguration> {
+    if selected.is_empty() {
+        available
+    } else {
+        available
+            .into_iter()
+            .filter(|item| selected.iter().any(|id| id == &item.id))
+            .collect()
+    }
+}
+
+fn select_colors(available: Vec<ColorComponent>, selected: &[String]) -> Vec<ColorComponent> {
+    if selected.is_empty() {
+        available
+    } else {
+        available
+            .into_iter()
+            .filter(|item| selected.iter().any(|id| id == &item.id))
+            .collect()
+    }
+}
+
+struct SpinCorrelationStorage {
+    // Buffers own the memory referenced by vectors even after moving this struct.
+    _components: Vec<Vec<f64>>,
+    vectors: Vec<ffi::SpinCorrelationVector>,
+}
+
+impl SpinCorrelationStorage {
+    fn new(input: &[SpinCorrelationVector]) -> Self {
+        let components = input
+            .iter()
+            .map(|vector| {
+                vector
+                    .components
+                    .iter()
+                    .flatten()
+                    .flat_map(|value| [value.re, value.im])
+                    .collect::<Vec<_>>()
+            })
+            .collect::<Vec<_>>();
+        let vectors = input
+            .iter()
+            .zip(&components)
+            .map(|(vector, flat)| ffi::SpinCorrelationVector {
+                leg: vector.leg,
+                point_count: vector.components.len(),
+                components: flat.as_ptr(),
+                component_count: flat.len(),
+            })
+            .collect();
+        Self {
+            _components: components,
+            vectors,
+        }
+    }
+}
+
+mod ffi {
+    use super::{c_char, c_int, c_void};
+
+    pub(super) const STATUS_OK: c_int = 0;
+    pub(super) const STATUS_INVALID_ARGUMENT: c_int = 1;
+    pub(super) const STATUS_BUFFER_TOO_SMALL: c_int = 2;
+    pub(super) const STATUS_RUNTIME_ERROR: c_int = 3;
+    pub(super) const STATUS_PANIC: c_int = 4;
+
+    pub(super) const WARM_UP_EVENT_START: u32 = 0;
+    pub(super) const WARM_UP_EVENT_UPDATE: u32 = 1;
+    pub(super) const WARM_UP_EVENT_END: u32 = 2;
+    pub(super) const WARM_UP_STAGE_PROCESS_PREPARATION: u32 = 0;
+    pub(super) const WARM_UP_STAGE_QUERY_FAMILY: u32 = 1;
+    pub(super) const WARM_UP_STAGE_FAMILY_FINALIZATION: u32 = 2;
+    pub(super) const WARM_UP_STAGE_FIRST_EVALUATION: u32 = 3;
+
+    #[repr(C)]
+    pub(super) struct RuntimeHandle {
+        _private: [u8; 0],
+    }
+
+    #[repr(C)]
+    pub(super) struct SpinCorrelationVector {
+        pub(super) leg: usize,
+        pub(super) point_count: usize,
+        pub(super) components: *const f64,
+        pub(super) component_count: usize,
+    }
+
+    #[repr(C)]
+    pub(super) struct CorrelatedRequest {
+        pub(super) color_correlation: *const c_char,
+        pub(super) spin_vectors: *const SpinCorrelationVector,
+        pub(super) spin_vector_count: usize,
+        pub(super) use_default_spin_vectors: u32,
+    }
+
+    #[repr(C)]
+    pub(super) struct WarmUpProgressEvent {
+        pub(super) schema_version: u32,
+        pub(super) kind: u32,
+        pub(super) stage: u32,
+        pub(super) reserved: u32,
+        pub(super) completed: u64,
+        pub(super) total: u64,
+        pub(super) elapsed_seconds: f64,
+        pub(super) current_rss_bytes: u64,
+        pub(super) peak_rss_bytes: u64,
+        pub(super) workers: u64,
+        pub(super) current_rss_available: u32,
+        pub(super) peak_rss_available: u32,
+    }
+
+    #[repr(C)]
+    #[derive(Default)]
+    pub(super) struct WarmUpResult {
+        pub(super) schema_version: u32,
+        pub(super) reserved: u32,
+        pub(super) elapsed_seconds: f64,
+        pub(super) query_count: u64,
+        pub(super) warmed_query_count: u64,
+        pub(super) current_rss_bytes: u64,
+        pub(super) peak_rss_bytes: u64,
+        pub(super) current_rss_available: u32,
+        pub(super) peak_rss_available: u32,
+        pub(super) already_warm: u32,
+        pub(super) first_evaluation_completed: u32,
+    }
+
+    pub(super) type WarmUpProgressCallback =
+        Option<unsafe extern "C" fn(*const WarmUpProgressEvent, *mut c_void) -> c_int>;
+
+    pub(super) type StringGetter =
+        unsafe extern "C" fn(*const RuntimeHandle, *mut c_char, usize, *mut usize) -> c_int;
+    pub(super) type IndexedStringGetter =
+        unsafe extern "C" fn(*const RuntimeHandle, usize, *mut c_char, usize, *mut usize) -> c_int;
+
+    unsafe extern "C" {
+        pub(super) fn rusticol_runtime_color_correlation_count(
+            handle: *mut RuntimeHandle,
+            output: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_color_correlation_id(
+            handle: *mut RuntimeHandle,
+            index: usize,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_color_correlation_catalogue_json(
+            handle: *mut RuntimeHandle,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_set_spin_correlation_vectors_f64(
+            handle: *mut RuntimeHandle,
+            vectors: *const SpinCorrelationVector,
+            count: usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_evaluate_correlated_many_f64(
+            handle: *mut RuntimeHandle,
+            momenta: *const f64,
+            momentum_count: usize,
+            point_count: usize,
+            requests: *const CorrelatedRequest,
+            request_count: usize,
+            helicity_ids: *const *const c_char,
+            helicity_count: usize,
+            output: *mut f64,
+            output_capacity: usize,
+        ) -> c_int;
+        pub(super) fn rusticol_abi_version() -> u32;
+        pub(super) fn rusticol_supported_runtime_capabilities_json(
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_last_error_message(
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_load(
+            process_dir: *const c_char,
+            process_key: *const c_char,
+            model_parameters_path: *const c_char,
+            output: *mut *mut RuntimeHandle,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_free(handle: *mut RuntimeHandle) -> c_int;
+        pub(super) fn rusticol_runtime_save(
+            handle: *const RuntimeHandle,
+            path: *const c_char,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_load_cache(
+            handle: *mut RuntimeHandle,
+            path: *const c_char,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_metadata_json(
+            handle: *const RuntimeHandle,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_execution_mode(
+            handle: *const RuntimeHandle,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_physics_json(
+            handle: *const RuntimeHandle,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_process(
+            handle: *const RuntimeHandle,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_process_key(
+            handle: *const RuntimeHandle,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_representative_process_key(
+            handle: *const RuntimeHandle,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_color_accuracy(
+            handle: *const RuntimeHandle,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_external_count(
+            handle: *const RuntimeHandle,
+            output: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_external_pdg(
+            handle: *const RuntimeHandle,
+            index: usize,
+            output: *mut i32,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_external_permutation(
+            handle: *const RuntimeHandle,
+            output: *mut usize,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_load_kinematics_json(
+            handle: *const RuntimeHandle,
+            path: *const c_char,
+            output: *mut f64,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_helicity_count(
+            handle: *const RuntimeHandle,
+            output: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_helicity_id(
+            handle: *const RuntimeHandle,
+            index: usize,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_helicity_vector(
+            handle: *const RuntimeHandle,
+            index: usize,
+            output: *mut i32,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_color_count(
+            handle: *const RuntimeHandle,
+            output: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_color_id(
+            handle: *const RuntimeHandle,
+            index: usize,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_color_kind(
+            handle: *const RuntimeHandle,
+            index: usize,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_color_word(
+            handle: *const RuntimeHandle,
+            index: usize,
+            output: *mut usize,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_model_parameter_count(
+            handle: *const RuntimeHandle,
+            output: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_model_parameter_name(
+            handle: *const RuntimeHandle,
+            index: usize,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_resolved_shape(
+            handle: *const RuntimeHandle,
+            helicity_ids: *const *const c_char,
+            helicity_count: usize,
+            color_ids: *const *const c_char,
+            color_count: usize,
+            output_helicity_count: *mut usize,
+            output_color_count: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_warm_up_f64_with_cores(
+            handle: *mut RuntimeHandle,
+            momenta: *const f64,
+            momentum_count: usize,
+            helicity_ids: *const *const c_char,
+            helicity_count: usize,
+            color_ids: *const *const c_char,
+            color_count: usize,
+            n_cores: usize,
+            progress_callback: WarmUpProgressCallback,
+            progress_user_data: *mut c_void,
+            output: *mut WarmUpResult,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_evaluate_f64(
+            handle: *mut RuntimeHandle,
+            momenta: *const f64,
+            momentum_count: usize,
+            point_count: usize,
+            output: *mut f64,
+            output_capacity: usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_evaluate_selected_f64(
+            handle: *mut RuntimeHandle,
+            momenta: *const f64,
+            momentum_count: usize,
+            point_count: usize,
+            helicity_ids: *const *const c_char,
+            helicity_count: usize,
+            color_ids: *const *const c_char,
+            color_count: usize,
+            helicity_by_point: *const u32,
+            helicity_by_point_count: usize,
+            color_flow_by_point: *const u32,
+            color_flow_by_point_count: usize,
+            output: *mut f64,
+            output_capacity: usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_evaluate_resolved_f64(
+            handle: *mut RuntimeHandle,
+            momenta: *const f64,
+            momentum_count: usize,
+            point_count: usize,
+            helicity_ids: *const *const c_char,
+            helicity_count: usize,
+            color_ids: *const *const c_char,
+            color_count: usize,
+            output: *mut f64,
+            output_capacity: usize,
+            output_helicity_count: *mut usize,
+            output_color_count: *mut usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_set_model_parameters(
+            handle: *mut RuntimeHandle,
+            names: *const *const c_char,
+            real: *const f64,
+            imaginary: *const f64,
+            count: usize,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_set_model_parameter(
+            handle: *mut RuntimeHandle,
+            name: *const c_char,
+            real: f64,
+            imaginary: f64,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_set_model_parameters_json(
+            handle: *mut RuntimeHandle,
+            path: *const c_char,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_mute_warnings(
+            handle: *mut RuntimeHandle,
+            muted: c_int,
+        ) -> c_int;
+        pub(super) fn rusticol_runtime_take_warnings_json(
+            handle: *mut RuntimeHandle,
+            buffer: *mut c_char,
+            capacity: usize,
+            required: *mut usize,
+        ) -> c_int;
+    }
+
+    pub(super) use rusticol_abi_version as abi_version;
+    pub(super) use rusticol_last_error_message as last_error_message;
+    pub(super) use rusticol_runtime_color_accuracy as runtime_color_accuracy;
+    pub(super) use rusticol_runtime_color_count as runtime_color_count;
+    pub(super) use rusticol_runtime_color_id as runtime_color_id;
+    pub(super) use rusticol_runtime_color_kind as runtime_color_kind;
+    pub(super) use rusticol_runtime_color_word as runtime_color_word;
+    pub(super) use rusticol_runtime_evaluate_f64 as runtime_evaluate_f64;
+    pub(super) use rusticol_runtime_evaluate_resolved_f64 as runtime_evaluate_resolved_f64;
+    pub(super) use rusticol_runtime_evaluate_selected_f64 as runtime_evaluate_selected_f64;
+    pub(super) use rusticol_runtime_execution_mode as runtime_execution_mode;
+    pub(super) use rusticol_runtime_external_count as runtime_external_count;
+    pub(super) use rusticol_runtime_external_pdg as runtime_external_pdg;
+    pub(super) use rusticol_runtime_external_permutation as runtime_external_permutation;
+    pub(super) use rusticol_runtime_free as runtime_free;
+    pub(super) use rusticol_runtime_helicity_count as runtime_helicity_count;
+    pub(super) use rusticol_runtime_helicity_id as runtime_helicity_id;
+    pub(super) use rusticol_runtime_helicity_vector as runtime_helicity_vector;
+    pub(super) use rusticol_runtime_load as runtime_load;
+    pub(super) use rusticol_runtime_load_cache as runtime_load_cache;
+    pub(super) use rusticol_runtime_load_kinematics_json as runtime_load_kinematics_json;
+    pub(super) use rusticol_runtime_metadata_json as runtime_metadata_json;
+    pub(super) use rusticol_runtime_model_parameter_count as runtime_model_parameter_count;
+    pub(super) use rusticol_runtime_model_parameter_name as runtime_model_parameter_name;
+    pub(super) use rusticol_runtime_mute_warnings as runtime_mute_warnings;
+    pub(super) use rusticol_runtime_physics_json as runtime_physics_json;
+    pub(super) use rusticol_runtime_process as runtime_process;
+    pub(super) use rusticol_runtime_process_key as runtime_process_key;
+    pub(super) use rusticol_runtime_representative_process_key as runtime_representative_process_key;
+    pub(super) use rusticol_runtime_resolved_shape as runtime_resolved_shape;
+    pub(super) use rusticol_runtime_save as runtime_save;
+    pub(super) use rusticol_runtime_set_model_parameter as runtime_set_model_parameter;
+    pub(super) use rusticol_runtime_set_model_parameters as runtime_set_model_parameters;
+    pub(super) use rusticol_runtime_set_model_parameters_json as runtime_set_model_parameters_json;
+    pub(super) use rusticol_runtime_take_warnings_json as runtime_take_warnings_json;
+    pub(super) use rusticol_runtime_warm_up_f64_with_cores as runtime_warm_up_f64_with_cores;
+    pub(super) use rusticol_supported_runtime_capabilities_json as supported_runtime_capabilities_json;
+}
diff --git a/pyamplicol/src/pyamplicol/api/__init__.py b/pyamplicol/src/pyamplicol/api/__init__.py
new file mode 100644
index 0000000000..898b51ff5d
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/api/__init__.py
@@ -0,0 +1,222 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .errors import (
+        ArtifactError,
+        CompatibilityError,
+        ConfigurationError,
+        DependencyError,
+        EvaluationError,
+        GenerationError,
+        ModelError,
+        PyAmpliColError,
+    )
+    from .models import (
+        CompiledModel,
+        CompiledModelCapabilities,
+        CompiledModelInfo,
+        CompiledModelSource,
+        ModelCompilationIssue,
+        ModelCompilationPhase,
+    )
+    from .process_groups import group_processes
+    from .protocols import (
+        BenchmarkBackend,
+        BenchmarkFactory,
+        GeneratorBackend,
+        GeneratorFactory,
+        ModelParameters,
+        Momenta,
+        RuntimeBackend,
+        RuntimeLoader,
+    )
+    from .requests import (
+        ModelSource,
+        ModelSourceKind,
+        ProcessAlias,
+        ProcessRequest,
+        ProcessSet,
+    )
+    from .results import (
+        BenchmarkComponentTiming,
+        BenchmarkProfileCounters,
+        BenchmarkResult,
+        BenchmarkStageTiming,
+        BenchmarkStatistics,
+        BenchmarkTimingBreakdown,
+        ColorComponent,
+        ColorFlow,
+        ContractedColorComponent,
+        ExternalParticle,
+        GenerationPlan,
+        GenerationResult,
+        HelicityConfiguration,
+        ModelParameter,
+        PhysicsReduction,
+        ProcessPhysics,
+        ReductionGroup,
+        ResolvedEvaluation,
+        WarmUpResult,
+    )
+    from .services import (
+        BenchmarkRunner,
+        Generator,
+        Runtime,
+        benchmark,
+        generate,
+        install_backend_factories,
+        load,
+    )
+
+__all__ = [
+    "ArtifactError",
+    "BenchmarkBackend",
+    "BenchmarkComponentTiming",
+    "BenchmarkFactory",
+    "BenchmarkProfileCounters",
+    "BenchmarkResult",
+    "BenchmarkRunner",
+    "BenchmarkStageTiming",
+    "BenchmarkStatistics",
+    "BenchmarkTimingBreakdown",
+    "ColorComponent",
+    "ColorFlow",
+    "CompatibilityError",
+    "CompiledModel",
+    "CompiledModelCapabilities",
+    "CompiledModelInfo",
+    "CompiledModelSource",
+    "ConfigurationError",
+    "ContractedColorComponent",
+    "DependencyError",
+    "EvaluationError",
+    "ExternalParticle",
+    "GenerationError",
+    "GenerationPlan",
+    "GenerationResult",
+    "Generator",
+    "GeneratorBackend",
+    "GeneratorFactory",
+    "HelicityConfiguration",
+    "ModelCompilationIssue",
+    "ModelCompilationPhase",
+    "ModelError",
+    "ModelParameter",
+    "ModelParameters",
+    "ModelSource",
+    "ModelSourceKind",
+    "Momenta",
+    "PhysicsReduction",
+    "ProcessAlias",
+    "ProcessPhysics",
+    "ProcessRequest",
+    "ProcessSet",
+    "PyAmpliColError",
+    "ReductionGroup",
+    "ResolvedEvaluation",
+    "Runtime",
+    "RuntimeBackend",
+    "RuntimeLoader",
+    "WarmUpResult",
+    "benchmark",
+    "generate",
+    "group_processes",
+    "install_backend_factories",
+    "load",
+]
+
+_ERROR_EXPORTS = (
+    "ArtifactError",
+    "CompatibilityError",
+    "ConfigurationError",
+    "DependencyError",
+    "EvaluationError",
+    "GenerationError",
+    "ModelError",
+    "PyAmpliColError",
+)
+_PROTOCOL_EXPORTS = (
+    "BenchmarkBackend",
+    "BenchmarkFactory",
+    "GeneratorBackend",
+    "GeneratorFactory",
+    "ModelParameters",
+    "Momenta",
+    "RuntimeBackend",
+    "RuntimeLoader",
+)
+_REQUEST_EXPORTS = (
+    "ModelSource",
+    "ModelSourceKind",
+    "ProcessAlias",
+    "ProcessRequest",
+    "ProcessSet",
+)
+_MODEL_EXPORTS = (
+    "CompiledModel",
+    "CompiledModelCapabilities",
+    "CompiledModelInfo",
+    "CompiledModelSource",
+    "ModelCompilationIssue",
+    "ModelCompilationPhase",
+)
+_RESULT_EXPORTS = (
+    "BenchmarkComponentTiming",
+    "BenchmarkProfileCounters",
+    "BenchmarkResult",
+    "BenchmarkStageTiming",
+    "BenchmarkStatistics",
+    "BenchmarkTimingBreakdown",
+    "ColorComponent",
+    "ColorFlow",
+    "ContractedColorComponent",
+    "ExternalParticle",
+    "GenerationPlan",
+    "GenerationResult",
+    "HelicityConfiguration",
+    "ModelParameter",
+    "PhysicsReduction",
+    "ProcessPhysics",
+    "ReductionGroup",
+    "ResolvedEvaluation",
+    "WarmUpResult",
+)
+_SERVICE_EXPORTS = (
+    "BenchmarkRunner",
+    "Generator",
+    "Runtime",
+    "benchmark",
+    "generate",
+    "install_backend_factories",
+    "load",
+)
+_PUBLIC_EXPORTS = {
+    **{name: (".errors", name) for name in _ERROR_EXPORTS},
+    **{name: (".protocols", name) for name in _PROTOCOL_EXPORTS},
+    **{name: (".models", name) for name in _MODEL_EXPORTS},
+    **{name: (".requests", name) for name in _REQUEST_EXPORTS},
+    **{name: (".results", name) for name in _RESULT_EXPORTS},
+    **{name: (".services", name) for name in _SERVICE_EXPORTS},
+    "group_processes": (".process_groups", "group_processes"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    """Load a public object only when that object is requested."""
+
+    export = _PUBLIC_EXPORTS.get(name)
+    if export is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    module_name, attribute = export
+    package = __name__ if module_name.startswith(".") else None
+    value = getattr(import_module(module_name, package), attribute)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()).union(__all__))
diff --git a/pyamplicol/src/pyamplicol/api/errors.py b/pyamplicol/src/pyamplicol/api/errors.py
new file mode 100644
index 0000000000..fe120bc965
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/api/errors.py
@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pyamplicol.config.errors import ConfigurationError, PyAmpliColError
+
+
+class ModelError(PyAmpliColError):
+    """A model source or compiled model is invalid."""
+
+
+class GenerationError(PyAmpliColError):
+    """Planning or artifact generation failed."""
+
+
+class ArtifactError(PyAmpliColError):
+    """An artifact is malformed, incomplete, or unavailable."""
+
+
+class CompatibilityError(ArtifactError):
+    """An artifact is incompatible with the active target or ABI."""
+
+
+class EvaluationError(PyAmpliColError):
+    """Runtime loading, selection, or evaluation failed."""
+
+
+class DependencyError(PyAmpliColError):
+    """A required optional or native dependency is unavailable."""
+
+
+__all__ = [
+    "ArtifactError",
+    "CompatibilityError",
+    "ConfigurationError",
+    "DependencyError",
+    "EvaluationError",
+    "GenerationError",
+    "ModelError",
+    "PyAmpliColError",
+]
diff --git a/pyamplicol/src/pyamplicol/api/models.py b/pyamplicol/src/pyamplicol/api/models.py
new file mode 100644
index 0000000000..e1b4ceeef1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/api/models.py
@@ -0,0 +1,698 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+import os
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal, Protocol, TypeAlias, cast
+
+from .results import ModelParameter
+
+CompiledModelSourceKind: TypeAlias = Literal[
+    "built-in-sm",
+    "built-in-sm-heft",
+    "ufo",
+    "json",
+    "compiled",
+]
+ModelCompilationSeverity: TypeAlias = Literal["warning", "error"]
+SupportedColorAccuracy: TypeAlias = Literal["lc", "nlc", "full"]
+
+
+class _CompiledModelPayloadView(Protocol):
+    name: str
+    schema_version: int
+    model_compiler_version: int
+    source: Mapping[str, object]
+    capabilities: Mapping[str, object]
+    parameter_defaults: Mapping[str, object]
+    issues: Iterable[object]
+    phase_timings: Mapping[str, object]
+    conversion_seconds: float
+    prepared_backend: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledModelSource:
+    """Stable provenance for the source consumed by the model compiler."""
+
+    kind: CompiledModelSourceKind
+    name: str | None = None
+    digest: str | None = None
+    restriction: str | None = None
+    restriction_digest: str | None = None
+    simplify: bool = True
+
+    def __post_init__(self) -> None:
+        if self.kind not in (
+            "built-in-sm",
+            "built-in-sm-heft",
+            "ufo",
+            "json",
+            "compiled",
+        ):
+            raise ValueError(f"unsupported compiled model source kind {self.kind!r}")
+        for field_name in ("name", "digest", "restriction", "restriction_digest"):
+            value = getattr(self, field_name)
+            if value is not None and (not isinstance(value, str) or not value.strip()):
+                raise ValueError(
+                    f"compiled model source {field_name} must be non-empty or null"
+                )
+        if self.restriction is not None and self.restriction_digest is not None:
+            raise ValueError(
+                "compiled model source cannot have both a restriction name and digest"
+            )
+        if not isinstance(self.simplify, bool):
+            raise TypeError("compiled model source simplify must be a boolean")
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledModelCapabilities:
+    """User-relevant capabilities of a compiled physics model."""
+
+    particle_count: int = 0
+    parameter_count: int = 0
+    vertex_count: int = 0
+    propagator_count: int = 0
+    form_factor_count: int = 0
+    maximum_valence: int = 0
+    spins: tuple[int, ...] = ()
+    color_representations: tuple[int, ...] = ()
+    supported_color_accuracies: tuple[SupportedColorAccuracy, ...] = ()
+    has_custom_propagators: bool = False
+
+    def __post_init__(self) -> None:
+        for field_name in (
+            "particle_count",
+            "parameter_count",
+            "vertex_count",
+            "propagator_count",
+            "form_factor_count",
+            "maximum_valence",
+        ):
+            _validate_non_negative_integer(getattr(self, field_name), field_name)
+
+        spins = tuple(self.spins)
+        colors = tuple(self.color_representations)
+        accuracies = tuple(self.supported_color_accuracies)
+        _validate_integer_tuple(spins, "spins")
+        _validate_integer_tuple(colors, "color_representations")
+        if len(set(spins)) != len(spins):
+            raise ValueError("compiled model spins must be unique")
+        if len(set(colors)) != len(colors):
+            raise ValueError("compiled model color representations must be unique")
+        if any(accuracy not in ("lc", "nlc", "full") for accuracy in accuracies):
+            raise ValueError("compiled model has an unsupported color accuracy")
+        if len(set(accuracies)) != len(accuracies):
+            raise ValueError("compiled model color accuracies must be unique")
+        if not isinstance(self.has_custom_propagators, bool):
+            raise TypeError("has_custom_propagators must be a boolean")
+
+        object.__setattr__(self, "spins", spins)
+        object.__setattr__(self, "color_representations", colors)
+        object.__setattr__(self, "supported_color_accuracies", accuracies)
+
+    @property
+    def max_vertex_valence(self) -> int:
+        """Compatibility spelling for serialized model capability records."""
+
+        return self.maximum_valence
+
+    @property
+    def color_accuracy_modes(self) -> tuple[SupportedColorAccuracy, ...]:
+        """Compatibility spelling for serialized model capability records."""
+
+        return self.supported_color_accuracies
+
+
+@dataclass(frozen=True, slots=True)
+class ModelCompilationIssue:
+    """A stable diagnostic emitted while compiling a model."""
+
+    severity: ModelCompilationSeverity
+    code: str
+    message: str
+    context: str = ""
+
+    def __post_init__(self) -> None:
+        if self.severity not in ("warning", "error"):
+            raise ValueError(f"unsupported model issue severity {self.severity!r}")
+        if not isinstance(self.code, str) or not self.code.strip():
+            raise ValueError("model compilation issue code must not be empty")
+        if not isinstance(self.message, str) or not self.message.strip():
+            raise ValueError("model compilation issue message must not be empty")
+        if not isinstance(self.context, str):
+            raise TypeError("model compilation issue context must be text")
+
+
+@dataclass(frozen=True, slots=True)
+class ModelCompilationPhase:
+    """Wall-clock duration of one model-compilation phase."""
+
+    name: str
+    seconds: float
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.name, str) or not self.name.strip():
+            raise ValueError("model compilation phase name must not be empty")
+        object.__setattr__(
+            self,
+            "seconds",
+            _non_negative_finite(self.seconds, "model compilation phase seconds"),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledModelInfo:
+    """Deeply immutable public metadata for one compiled model."""
+
+    name: str
+    schema_version: int
+    model_compiler_version: int
+    source: CompiledModelSource
+    capabilities: CompiledModelCapabilities
+    parameters: tuple[ModelParameter, ...]
+    issues: tuple[ModelCompilationIssue, ...]
+    compilation_phases: tuple[ModelCompilationPhase, ...]
+    conversion_seconds: float
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.name, str) or not self.name.strip():
+            raise ValueError("compiled model name must not be empty")
+        _validate_non_negative_integer(self.schema_version, "schema_version")
+        _validate_non_negative_integer(
+            self.model_compiler_version,
+            "model_compiler_version",
+        )
+        if not isinstance(self.source, CompiledModelSource):
+            raise TypeError("compiled model source must be CompiledModelSource")
+        if not isinstance(self.capabilities, CompiledModelCapabilities):
+            raise TypeError(
+                "compiled model capabilities must be CompiledModelCapabilities"
+            )
+
+        parameters = tuple(self.parameters)
+        issues = tuple(self.issues)
+        phases = tuple(self.compilation_phases)
+        _validate_tuple_members(parameters, ModelParameter, "parameters")
+        _validate_tuple_members(issues, ModelCompilationIssue, "issues")
+        _validate_tuple_members(phases, ModelCompilationPhase, "compilation_phases")
+        if len({parameter.name for parameter in parameters}) != len(parameters):
+            raise ValueError("compiled model parameter names must be unique")
+        if len({phase.name for phase in phases}) != len(phases):
+            raise ValueError("model compilation phase names must be unique")
+        object.__setattr__(
+            self,
+            "conversion_seconds",
+            _non_negative_finite(
+                self.conversion_seconds,
+                "compiled model conversion_seconds",
+            ),
+        )
+
+        object.__setattr__(self, "parameters", parameters)
+        object.__setattr__(self, "issues", issues)
+        object.__setattr__(self, "compilation_phases", phases)
+
+    @property
+    def supported(self) -> bool:
+        return not any(issue.severity == "error" for issue in self.issues)
+
+    @property
+    def phases(self) -> tuple[ModelCompilationPhase, ...]:
+        """Short alias for :attr:`compilation_phases`."""
+
+        return self.compilation_phases
+
+
+class CompiledModel:
+    """Opaque compiled-model handle accepted by :class:`~pyamplicol.Generator`.
+
+    Construct handles with :meth:`pyamplicol.ModelSource.compile`. The compiler's
+    mutable payload and expression IR intentionally remain private; stable model
+    metadata is available through :attr:`info` and the typed convenience
+    properties below.
+    """
+
+    __slots__ = ("_info", "_payload")
+
+    _info: CompiledModelInfo
+    _payload: object
+
+    def __init__(self) -> None:
+        raise TypeError("construct compiled models with ModelSource.compile()")
+
+    def __setattr__(self, _name: str, _value: object) -> None:
+        raise AttributeError("CompiledModel handles are immutable")
+
+    def __delattr__(self, _name: str) -> None:
+        raise AttributeError("CompiledModel handles are immutable")
+
+    @property
+    def info(self) -> CompiledModelInfo:
+        """Stable, deeply immutable model metadata."""
+
+        return self._info
+
+    @property
+    def name(self) -> str:
+        return self._info.name
+
+    @property
+    def schema_version(self) -> int:
+        return self._info.schema_version
+
+    @property
+    def model_compiler_version(self) -> int:
+        return self._info.model_compiler_version
+
+    @property
+    def source(self) -> CompiledModelSource:
+        return self._info.source
+
+    @property
+    def capabilities(self) -> CompiledModelCapabilities:
+        return self._info.capabilities
+
+    @property
+    def parameters(self) -> tuple[ModelParameter, ...]:
+        return self._info.parameters
+
+    @property
+    def issues(self) -> tuple[ModelCompilationIssue, ...]:
+        return self._info.issues
+
+    @property
+    def compilation_phases(self) -> tuple[ModelCompilationPhase, ...]:
+        return self._info.compilation_phases
+
+    @property
+    def conversion_seconds(self) -> float:
+        return self._info.conversion_seconds
+
+    @property
+    def supported(self) -> bool:
+        return self._info.supported
+
+    @property
+    def is_prepared(self) -> bool:
+        """Whether this handle owns a validated prepared-mode kernel pack.
+
+        The pack is shared by eager, recurrence, and on-the-fly execution.
+        """
+
+        return self.prepared_backend is not None
+
+    @property
+    def prepared_backend(self) -> Literal["jit", "asm", "cpp"] | None:
+        """Backend embedded in the prepared model, if any."""
+
+        backend = getattr(self._payload, "prepared_backend", None)
+        if backend is None:
+            return None
+        if backend not in ("jit", "asm", "cpp"):
+            raise RuntimeError(f"invalid prepared-model backend {backend!r}")
+        return cast(Literal["jit", "asm", "cpp"], backend)
+
+    def write(self, path: os.PathLike[str] | str) -> Path:
+        """Serialize the compiled model and return its absolute output path."""
+
+        writer = getattr(self._payload, "write", None)
+        if not callable(writer):
+            raise RuntimeError("compiled model payload cannot be serialized")
+        target = Path(os.fspath(path)).expanduser().resolve(strict=False)
+        return Path(os.fspath(writer(target))).resolve(strict=False)
+
+    def write_parameter_card(self, path: os.PathLike[str] | str) -> Path:
+        """Write mutable external-parameter defaults as a JSON model card."""
+
+        writer = getattr(self._payload, "write_parameter_card", None)
+        if not callable(writer):
+            raise RuntimeError("compiled model payload cannot write parameter cards")
+        target = Path(os.fspath(path)).expanduser().resolve(strict=False)
+        return Path(os.fspath(writer(target))).resolve(strict=False)
+
+    def __repr__(self) -> str:
+        return (
+            f"CompiledModel(name={self.name!r}, supported={self.supported!r}, "
+            f"schema_version={self.schema_version})"
+        )
+
+
+def _compiled_model_from_payload(payload: object) -> CompiledModel:
+    """Create an opaque public handle from the private compiler payload."""
+
+    view = cast(_CompiledModelPayloadView, payload)
+    try:
+        info = _compiled_model_info(
+            name=str(view.name),
+            schema_version=int(view.schema_version),
+            model_compiler_version=int(view.model_compiler_version),
+            source=view.source,
+            capabilities=view.capabilities,
+            parameter_defaults=view.parameter_defaults,
+            issues=view.issues,
+            phase_timings=view.phase_timings,
+            conversion_seconds=float(view.conversion_seconds),
+        )
+    except (AttributeError, TypeError, ValueError) as exc:
+        raise TypeError("invalid private compiled-model payload") from exc
+    model = object.__new__(CompiledModel)
+    object.__setattr__(model, "_payload", payload)
+    object.__setattr__(model, "_info", info)
+    return model
+
+
+def _compiled_model_payload(model: CompiledModel) -> object:
+    """Return the private payload at an internal generation boundary."""
+
+    if not isinstance(model, CompiledModel):
+        raise TypeError("expected a CompiledModel handle")
+    return model._payload
+
+
+def _compiled_model_info(
+    *,
+    name: str,
+    schema_version: int,
+    model_compiler_version: int,
+    source: Mapping[str, object],
+    capabilities: Mapping[str, object],
+    parameter_defaults: Mapping[str, object],
+    issues: Iterable[object],
+    phase_timings: Mapping[str, object],
+    conversion_seconds: float,
+) -> CompiledModelInfo:
+    """Convert compiler-owned records without importing the compiler module."""
+
+    return CompiledModelInfo(
+        name=name,
+        schema_version=schema_version,
+        model_compiler_version=model_compiler_version,
+        source=_compiled_model_source(source),
+        capabilities=_compiled_model_capabilities(capabilities),
+        parameters=_compiled_model_parameters(parameter_defaults),
+        issues=tuple(_model_compilation_issue(issue) for issue in issues),
+        compilation_phases=_model_compilation_phases(phase_timings),
+        conversion_seconds=conversion_seconds,
+    )
+
+
+def _compiled_model_source(source: Mapping[str, object]) -> CompiledModelSource:
+    raw_kind = source.get("kind")
+    if not isinstance(raw_kind, str) or raw_kind not in (
+        "built-in-sm",
+        "built-in-sm-heft",
+        "ufo",
+        "json",
+        "compiled",
+    ):
+        raise ValueError(f"unsupported compiled model source kind {raw_kind!r}")
+
+    raw_name = source.get("source_name", source.get("name"))
+    name = _optional_non_empty_string(raw_name, "compiled model source name")
+    digest = _optional_non_empty_string(
+        source.get("digest"),
+        "compiled model source digest",
+    )
+
+    options = _optional_mapping(source.get("options"), "compiled model source options")
+    simplify = _boolean(
+        source.get("simplify", options.get("simplify", True)),
+        "compiled model source simplify",
+    )
+    restriction: str | None = None
+    restriction_digest: str | None = None
+    raw_restriction = source.get("restriction", options.get("restriction"))
+    if isinstance(raw_restriction, str):
+        restriction = _optional_non_empty_string(
+            raw_restriction,
+            "compiled model source restriction",
+        )
+    elif isinstance(raw_restriction, Mapping):
+        restriction_kind = raw_restriction.get("kind")
+        if restriction_kind == "name":
+            restriction = _optional_non_empty_string(
+                raw_restriction.get("value"),
+                "compiled model source restriction",
+            )
+        elif restriction_kind == "file":
+            restriction_digest = _optional_non_empty_string(
+                raw_restriction.get("sha256"),
+                "compiled model restriction digest",
+            )
+
+    return CompiledModelSource(
+        kind=cast(CompiledModelSourceKind, raw_kind),
+        name=name,
+        digest=digest,
+        restriction=restriction,
+        restriction_digest=restriction_digest,
+        simplify=simplify,
+    )
+
+
+def _compiled_model_capabilities(
+    capabilities: Mapping[str, object],
+) -> CompiledModelCapabilities:
+    return CompiledModelCapabilities(
+        particle_count=_mapping_non_negative_integer(
+            capabilities,
+            "particle_count",
+        ),
+        parameter_count=_mapping_non_negative_integer(
+            capabilities,
+            "parameter_count",
+        ),
+        vertex_count=_mapping_non_negative_integer(capabilities, "vertex_count"),
+        propagator_count=_mapping_non_negative_integer(
+            capabilities,
+            "propagator_count",
+            fallback="compiled_propagator_count",
+        ),
+        form_factor_count=_mapping_non_negative_integer(
+            capabilities,
+            "form_factor_count",
+        ),
+        maximum_valence=_mapping_non_negative_integer(
+            capabilities,
+            "maximum_valence",
+            fallback="max_vertex_valence",
+        ),
+        spins=_integer_values(capabilities.get("spins", ()), "spins"),
+        color_representations=_integer_values(
+            capabilities.get("color_representations", ()),
+            "color_representations",
+        ),
+        supported_color_accuracies=_color_accuracies(
+            capabilities.get(
+                "supported_color_accuracies",
+                capabilities.get("color_accuracy_modes", ()),
+            )
+        ),
+        has_custom_propagators=_boolean(
+            capabilities.get("has_custom_propagators", False),
+            "has_custom_propagators",
+        ),
+    )
+
+
+def _compiled_model_parameters(
+    parameter_defaults: Mapping[str, object],
+) -> tuple[ModelParameter, ...]:
+    parameters = []
+    for raw_name, value in parameter_defaults.items():
+        name = str(raw_name)
+        real, imaginary = _complex_pair(value, f"model parameter {name!r}")
+        parameters.append(
+            ModelParameter(
+                name=name,
+                kind="external",
+                default_real=real,
+                default_imaginary=imaginary,
+                mutable=True,
+            )
+        )
+    return tuple(sorted(parameters, key=lambda parameter: parameter.name))
+
+
+def _model_compilation_issue(issue: object) -> ModelCompilationIssue:
+    if isinstance(issue, ModelCompilationIssue):
+        return issue
+    raw_severity = _record_value(issue, "severity")
+    if not isinstance(raw_severity, str) or raw_severity not in ("warning", "error"):
+        raise ValueError(f"unsupported model issue severity {raw_severity!r}")
+    code = _record_text(issue, "code")
+    message = _record_text(issue, "message")
+    raw_context = _record_value(issue, "context", default="")
+    context = "" if raw_context is None else raw_context
+    if not isinstance(context, str):
+        raise TypeError("model compilation issue context must be text")
+    return ModelCompilationIssue(
+        severity=cast(ModelCompilationSeverity, raw_severity),
+        code=code,
+        message=message,
+        context=context,
+    )
+
+
+def _model_compilation_phases(
+    phase_timings: Mapping[str, object],
+) -> tuple[ModelCompilationPhase, ...]:
+    return tuple(
+        ModelCompilationPhase(
+            name=str(name),
+            seconds=_finite_float(value, f"model compilation phase {name!r}"),
+        )
+        for name, value in phase_timings.items()
+    )
+
+
+_MISSING = object()
+
+
+def _record_value(
+    record: object,
+    field_name: str,
+    *,
+    default: object = _MISSING,
+) -> object:
+    if isinstance(record, Mapping):
+        if field_name in record:
+            return record[field_name]
+    elif hasattr(record, field_name):
+        return getattr(record, field_name)
+    if default is not _MISSING:
+        return default
+    raise TypeError(f"model compilation issue has no {field_name!r} field")
+
+
+def _record_text(record: object, field_name: str) -> str:
+    value = _record_value(record, field_name)
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"model compilation issue {field_name} must not be empty")
+    return value
+
+
+def _optional_mapping(value: object, context: str) -> Mapping[str, object]:
+    if value is None:
+        return {}
+    if not isinstance(value, Mapping):
+        raise TypeError(f"{context} must be a mapping")
+    return value
+
+
+def _optional_non_empty_string(value: object, context: str) -> str | None:
+    if value is None:
+        return None
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"{context} must be non-empty or null")
+    return value
+
+
+def _mapping_non_negative_integer(
+    mapping: Mapping[str, object],
+    field_name: str,
+    *,
+    fallback: str | None = None,
+) -> int:
+    value = mapping.get(field_name, _MISSING)
+    if value is _MISSING and fallback is not None:
+        value = mapping.get(fallback, _MISSING)
+    if value is _MISSING:
+        value = 0
+    _validate_non_negative_integer(value, field_name)
+    return cast(int, value)
+
+
+def _validate_non_negative_integer(value: object, context: str) -> None:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise ValueError(f"{context} must be a non-negative integer")
+
+
+def _validate_integer_tuple(values: tuple[object, ...], context: str) -> None:
+    if not all(
+        isinstance(value, int) and not isinstance(value, bool) for value in values
+    ):
+        raise ValueError(f"{context} must contain integers")
+
+
+def _integer_values(value: object, context: str) -> tuple[int, ...]:
+    values = _sequence(value, context)
+    _validate_integer_tuple(values, context)
+    return cast(tuple[int, ...], values)
+
+
+def _color_accuracies(value: object) -> tuple[SupportedColorAccuracy, ...]:
+    values = _sequence(value, "supported color accuracies")
+    if not all(
+        isinstance(accuracy, str) and accuracy in ("lc", "nlc", "full")
+        for accuracy in values
+    ):
+        raise ValueError("compiled model has an unsupported color accuracy")
+    return cast(tuple[SupportedColorAccuracy, ...], values)
+
+
+def _sequence(value: object, context: str) -> tuple[object, ...]:
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise TypeError(f"{context} must be a sequence")
+    return tuple(value)
+
+
+def _complex_pair(value: object, context: str) -> tuple[float, float]:
+    if isinstance(value, complex):
+        return float(value.real), float(value.imag)
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        if len(value) != 2:
+            raise ValueError(f"{context} must contain a real and imaginary value")
+        return (
+            _finite_float(value[0], f"{context} real component"),
+            _finite_float(value[1], f"{context} imaginary component"),
+        )
+    return _finite_float(value, context), 0.0
+
+
+def _boolean(value: object, context: str) -> bool:
+    if not isinstance(value, bool):
+        raise TypeError(f"{context} must be a boolean")
+    return value
+
+
+def _finite_float(value: object, context: str) -> float:
+    if isinstance(value, (bool, str, bytes, bytearray)):
+        raise TypeError(f"{context} must be a finite number")
+    try:
+        result = float(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError, OverflowError) as exc:
+        raise TypeError(f"{context} must be a finite number") from exc
+    if not math.isfinite(result):
+        raise ValueError(f"{context} must be finite")
+    return result
+
+
+def _non_negative_finite(value: object, context: str) -> float:
+    result = _finite_float(value, context)
+    if result < 0.0:
+        raise ValueError(f"{context} must be non-negative")
+    return result
+
+
+def _validate_tuple_members(
+    values: tuple[object, ...],
+    member_type: type[object],
+    context: str,
+) -> None:
+    if not all(isinstance(value, member_type) for value in values):
+        raise TypeError(f"compiled model {context} contain invalid records")
+
+
+__all__ = [
+    "CompiledModel",
+    "CompiledModelCapabilities",
+    "CompiledModelInfo",
+    "CompiledModelSource",
+    "ModelCompilationIssue",
+    "ModelCompilationPhase",
+]
diff --git a/pyamplicol/src/pyamplicol/api/process_groups.py b/pyamplicol/src/pyamplicol/api/process_groups.py
new file mode 100644
index 0000000000..573d61188b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/api/process_groups.py
@@ -0,0 +1,53 @@
+# SPDX-License-Identifier: 0BSD
+"""Process-group analysis of a generated artifact."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from pyamplicol.generation.process_grouping import GroupingAnalysis
+from pyamplicol.generation.process_grouping_numerical import (
+    update_artifact_process_groups,
+)
+
+
+def group_processes(
+    artifact: os.PathLike[str] | str,
+    *,
+    analysis: str = "numerical",
+    only_unit_multiplier: bool = False,
+    consider_charge_conjugation: bool = True,
+) -> dict[str, object]:
+    """Group the artifact's subprocesses with equal matrix elements.
+
+    The stored representatives are compared numerically and every new
+    relation (a rational factor and a leg permutation, optionally with charge
+    conjugation) is merged into ``process-groups.json``, which is rewritten in
+    place. UMAMI files and the artifact ID are left unchanged. ``"none"`` only
+    writes the trivial map when the artifact has none. Returns a summary.
+    """
+
+    if analysis not in tuple(GroupingAnalysis):
+        raise ValueError(
+            "analysis must be one of "
+            + ", ".join(repr(str(value)) for value in GroupingAnalysis)
+        )
+    for name, value in (
+        ("only_unit_multiplier", only_unit_multiplier),
+        ("consider_charge_conjugation", consider_charge_conjugation),
+    ):
+        if not isinstance(value, bool):
+            raise TypeError(f"{name} must be a boolean")
+    path = Path(os.fspath(artifact)).expanduser()
+    if not path.is_dir():
+        raise FileNotFoundError(f"artifact does not exist: {path}")
+    return update_artifact_process_groups(
+        path,
+        analysis=GroupingAnalysis(analysis),
+        only_unit_multiplier=only_unit_multiplier,
+        consider_charge_conjugation=consider_charge_conjugation,
+    )
+
+
+__all__ = ["group_processes"]
diff --git a/pyamplicol/src/pyamplicol/api/protocols.py b/pyamplicol/src/pyamplicol/api/protocols.py
new file mode 100644
index 0000000000..7685c2575c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/api/protocols.py
@@ -0,0 +1,144 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping, Sequence
+from decimal import Decimal
+from typing import Protocol, runtime_checkable
+
+import pyamplicol as _pyamplicol
+from pyamplicol.config import (
+    BenchmarkConfig,
+    ConfigResolution,
+    GenerationConfig,
+    RunConfig,
+)
+from pyamplicol.reporting import ProgressSink
+
+from .requests import ModelSource, ProcessSet
+from .results import (
+    BenchmarkResult,
+    GenerationPlan,
+    GenerationResult,
+    ProcessPhysics,
+    ResolvedEvaluation,
+)
+
+ScalarInput = float | int | str | Decimal
+ScalarValue = complex | Decimal
+Momenta = Sequence[Sequence[Sequence[ScalarInput]]]
+ModelParameters = Mapping[
+    str,
+    complex | float | int | list[float | int] | tuple[float | int, float | int],
+]
+
+
+@runtime_checkable
+class GeneratorBackend(Protocol):
+    def plan(
+        self,
+        processes: ProcessSet,
+        *,
+        model: ModelSource | _pyamplicol.CompiledModel | None = None,
+    ) -> GenerationPlan: ...
+
+    def generate(
+        self,
+        processes: ProcessSet,
+        output: os.PathLike[str] | str,
+        *,
+        model: ModelSource | _pyamplicol.CompiledModel | None = None,
+        mode: str = "error",
+    ) -> GenerationResult: ...
+
+
+@runtime_checkable
+class RuntimeBackend(Protocol):
+    """Minimum structural runtime contract.
+
+    Authenticated ``artifact_id`` and ``execution_mode`` are facade capabilities
+    rather than protocol requirements so existing injected third-party backends
+    remain structurally compatible. Built-in backends expose both, and
+    :class:`pyamplicol.Runtime` fails closed when either identity is requested
+    but unavailable.
+    """
+
+    @property
+    def physics(self) -> ProcessPhysics: ...
+
+    def evaluate(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        precision: int = 16,
+    ) -> Sequence[ScalarValue]: ...
+
+    def evaluate_resolved(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        precision: int = 16,
+    ) -> ResolvedEvaluation: ...
+
+    def set_model_parameters(self, mapping: ModelParameters) -> None: ...
+
+    def clear(self) -> None: ...
+
+    def mute_warnings(self) -> None: ...
+
+    def unmute_warnings(self) -> None: ...
+
+
+@runtime_checkable
+class BenchmarkBackend(Protocol):
+    def run(
+        self,
+        target: RuntimeBackend | os.PathLike[str] | str,
+        *,
+        points: Momenta | None = None,
+    ) -> BenchmarkResult: ...
+
+
+class GeneratorFactory(Protocol):
+    def __call__(
+        self,
+        config: GenerationConfig | RunConfig | ConfigResolution | None,
+        progress: ProgressSink | None,
+    ) -> GeneratorBackend: ...
+
+
+class RuntimeLoader(Protocol):
+    def __call__(
+        self,
+        artifact: os.PathLike[str] | str,
+        *,
+        process: str | None,
+        model_parameters: ModelParameters | None,
+        mute_warnings: bool,
+    ) -> RuntimeBackend: ...
+
+
+class BenchmarkFactory(Protocol):
+    def __call__(
+        self,
+        config: BenchmarkConfig | RunConfig | None,
+        progress: ProgressSink | None,
+    ) -> BenchmarkBackend: ...
+
+
+__all__ = [
+    "BenchmarkBackend",
+    "BenchmarkFactory",
+    "GeneratorBackend",
+    "GeneratorFactory",
+    "ModelParameters",
+    "Momenta",
+    "RuntimeBackend",
+    "RuntimeLoader",
+    "ScalarInput",
+    "ScalarValue",
+]
diff --git a/pyamplicol/src/pyamplicol/api/requests.py b/pyamplicol/src/pyamplicol/api/requests.py
new file mode 100644
index 0000000000..87ea91f1ac
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/api/requests.py
@@ -0,0 +1,495 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal, TypeAlias
+
+import pyamplicol as _pyamplicol
+from pyamplicol.config import EvaluatorConfig
+
+from .errors import ModelError
+
+if TYPE_CHECKING:
+    from pyamplicol.models.loading import CompiledModel
+
+ModelSourceKind: TypeAlias = Literal[
+    "built-in-sm",
+    "built-in-sm-heft",
+    "ufo",
+    "json",
+    "compiled",
+    "prepared",
+]
+_PROCESS_NAME = re.compile(r"^[A-Za-z][A-Za-z0-9_.-]*$")
+
+
+@dataclass(frozen=True, slots=True)
+class ModelSource:
+    """A built-in, packaged HEFT, UFO, JSON, or precompiled model input.
+
+    Use :meth:`from_config` for a resolved run card or :meth:`from_path` for an
+    external model. Calling :meth:`compile` produces the canonical serialized
+    model consumed by process generation.
+    """
+
+    kind: ModelSourceKind
+    path: Path | None = None
+    restriction: Path | str | None = None
+    simplify: bool = True
+
+    def __post_init__(self) -> None:
+        if self.kind not in (
+            "built-in-sm",
+            "built-in-sm-heft",
+            "ufo",
+            "json",
+            "compiled",
+            "prepared",
+        ):
+            raise ModelError(f"unsupported model source kind {self.kind!r}")
+        if not isinstance(self.simplify, bool):
+            raise ModelError("model simplify must be a boolean")
+        if self.path is not None:
+            try:
+                resolved_path = (
+                    Path(os.fspath(self.path)).expanduser().resolve(strict=False)
+                )
+            except TypeError as exc:
+                raise ModelError("model path must be path-like or null") from exc
+            object.__setattr__(self, "path", resolved_path)
+        if self.restriction is not None:
+            if isinstance(self.restriction, str):
+                if not self.restriction or any(
+                    character.isspace() for character in self.restriction
+                ):
+                    raise ModelError(
+                        "model restriction names must be non-empty and contain no "
+                        "whitespace"
+                    )
+            else:
+                try:
+                    resolved_restriction = (
+                        Path(os.fspath(self.restriction))
+                        .expanduser()
+                        .resolve(strict=False)
+                    )
+                except TypeError as exc:
+                    raise ModelError(
+                        "model restriction must be a name, path-like, or null"
+                    ) from exc
+                object.__setattr__(self, "restriction", resolved_restriction)
+        if self.kind in {"built-in-sm", "built-in-sm-heft"}:
+            if self.path is not None:
+                raise ModelError("built-in models have no public source path")
+        elif self.kind in ("ufo", "json") and (
+            self.path is None or not self.path.is_absolute()
+        ):
+            raise ModelError("external model paths must be absolute")
+        elif self.path is not None and not self.path.is_absolute():
+            raise ModelError("compiled model paths must be absolute")
+        if isinstance(self.restriction, Path) and not self.restriction.is_absolute():
+            raise ModelError("model restriction paths must be absolute")
+
+    @classmethod
+    def built_in_sm(cls) -> ModelSource:
+        return cls(kind="built-in-sm")
+
+    @classmethod
+    def built_in_sm_heft(cls) -> ModelSource:
+        """Select the packaged Standard Model with scalar HEFT interactions."""
+
+        return cls(kind="built-in-sm-heft")
+
+    @classmethod
+    def from_config(cls, config: object) -> ModelSource:
+        """Create a source from the typed ``[model]`` run-card section.
+
+        Restriction selectors such as ``default``, ``none``, or a loader-defined
+        name remain names. Explicit restriction files are resolved relative to
+        the selected UFO/JSON model by :meth:`from_path`.
+        """
+
+        from pyamplicol.config import ModelConfig
+
+        if not isinstance(config, ModelConfig):
+            raise TypeError("model source config must be a ModelConfig")
+        if config.source == "built-in-sm":
+            if config.restriction not in (None, "default"):
+                raise ModelError(
+                    "model restrictions can only be applied to external models"
+                )
+            if not config.simplify:
+                raise ModelError(
+                    "simplification cannot be disabled for the built-in Standard Model"
+                )
+            return cls.built_in_sm()
+        from pyamplicol._internal.sm_heft import is_sm_heft_alias
+
+        if is_sm_heft_alias(config.source):
+            if config.restriction not in (None, "default"):
+                raise ModelError(
+                    "model restrictions cannot be applied to built-in-sm-heft"
+                )
+            if not config.simplify:
+                raise ModelError(
+                    "simplification cannot be disabled for built-in-sm-heft"
+                )
+            return cls.built_in_sm_heft()
+        return cls.from_path(
+            config.source,
+            restriction=config.restriction,
+            simplify=config.simplify,
+        )
+
+    @classmethod
+    def from_path(
+        cls,
+        path: os.PathLike[str] | str,
+        restriction: os.PathLike[str] | str | None = None,
+        simplify: bool = True,
+    ) -> ModelSource:
+        """Resolve an external source kind without importing Symbolica."""
+
+        source = Path(os.fspath(path)).expanduser().resolve(strict=False)
+        if not source.exists():
+            raise ModelError(f"model source does not exist: {source}")
+        if source.is_dir():
+            kind: ModelSourceKind = "ufo"
+        elif source.is_file() and source.name.lower().endswith(".pyamplicol-model"):
+            kind = "prepared"
+        elif source.is_file() and source.suffix.lower() == ".json":
+            lowered_name = source.name.lower()
+            kind = (
+                "compiled"
+                if lowered_name.endswith(
+                    (".pyamplicol-model.json", ".compiled-model.json")
+                )
+                else "json"
+            )
+        elif source.is_file():
+            kind = "compiled"
+        else:
+            raise ModelError(f"model source is not a file or directory: {source}")
+
+        restriction_value: Path | str | None = None
+        if restriction is not None:
+            raw_restriction = os.fspath(restriction)
+            if not isinstance(raw_restriction, str):
+                raise ModelError(
+                    "model restriction must resolve to a text path or name"
+                )
+            restriction_path = Path(raw_restriction).expanduser()
+            if not restriction_path.is_absolute():
+                base = source if source.is_dir() else source.parent
+                restriction_path = base / restriction_path
+            restriction_path = restriction_path.resolve(strict=False)
+            if restriction_path.is_file():
+                restriction_value = restriction_path
+            elif not isinstance(restriction, str) or _restriction_looks_like_path(
+                raw_restriction
+            ):
+                raise ModelError(
+                    f"model restriction file does not exist: {restriction_path}"
+                )
+            else:
+                restriction_value = raw_restriction
+        return cls(
+            kind=kind,
+            path=source,
+            restriction=restriction_value,
+            simplify=simplify,
+        )
+
+    def compile(
+        self,
+        *,
+        cache_dir: os.PathLike[str] | str | None = None,
+        use_cache: bool = True,
+        require_supported: bool = True,
+        prepared_output: os.PathLike[str] | str | None = None,
+        evaluator: EvaluatorConfig | None = None,
+    ) -> _pyamplicol.CompiledModel:
+        """Compile or load this source and return its compiled-model handle.
+
+        By default this only creates the canonical, portable model IR in memory.
+        Supplying both ``prepared_output`` and ``evaluator`` additionally writes
+        one self-contained ``.pyamplicol-model`` bundle containing exactly the
+        requested evaluator backend pack. The returned handle is loaded from that
+        bundle and can be passed directly to eager, recurrence, or on-the-fly
+        generation.
+        """
+
+        if (prepared_output is None) != (evaluator is None):
+            raise ModelError(
+                "prepared model compilation requires both prepared_output and "
+                "an EvaluatorConfig"
+            )
+        if evaluator is not None and not isinstance(evaluator, EvaluatorConfig):
+            raise ModelError("evaluator must be an EvaluatorConfig or null")
+
+        resolved_cache: Path | None = None
+        if cache_dir is not None:
+            try:
+                resolved_cache = (
+                    Path(os.fspath(cache_dir)).expanduser().resolve(strict=False)
+                )
+            except TypeError as exc:
+                raise ModelError(
+                    "model cache directory must be path-like or null"
+                ) from exc
+        resolved_prepared_output: Path | None = None
+        if prepared_output is not None:
+            try:
+                resolved_prepared_output = (
+                    Path(os.fspath(prepared_output)).expanduser().resolve(strict=False)
+                )
+            except TypeError as exc:
+                raise ModelError(
+                    "prepared model output must be path-like or null"
+                ) from exc
+            if not resolved_prepared_output.name.lower().endswith(".pyamplicol-model"):
+                raise ModelError(
+                    "prepared model output must end with '.pyamplicol-model'"
+                )
+        try:
+            payload = _compile_model_source_payload(
+                self,
+                cache_dir=resolved_cache,
+                use_cache=use_cache,
+                require_supported=require_supported,
+            )
+            if resolved_prepared_output is not None:
+                assert evaluator is not None
+                from pyamplicol.models.prepared_compile import prepare_model_bundle
+
+                prepared = prepare_model_bundle(
+                    payload,
+                    resolved_prepared_output,
+                    evaluator=evaluator,
+                )
+                from pyamplicol.models.loading import load_compiled_model
+
+                payload = load_compiled_model(prepared.output)
+            from .models import _compiled_model_from_payload
+
+            return _compiled_model_from_payload(payload)
+        except (OSError, RuntimeError, TypeError, ValueError) as exc:
+            raise ModelError(str(exc)) from exc
+
+
+def _compile_model_source_payload(
+    source: ModelSource,
+    *,
+    cache_dir: Path | None,
+    use_cache: bool,
+    require_supported: bool,
+) -> CompiledModel:
+    """Compile one normalized source through the shared private boundary."""
+
+    if source.kind == "built-in-sm-heft":
+        from pyamplicol._internal.sm_heft import compile_sm_heft_source
+
+        return compile_sm_heft_source(
+            cache_dir=cache_dir,
+            use_cache=use_cache,
+            require_supported=require_supported,
+        )
+    if source.kind == "built-in-sm":
+        source_input: str | Path = source.kind
+    elif source.path is not None:
+        source_input = source.path
+    else:
+        raise ModelError("an in-memory compiled model source cannot be reloaded")
+    from pyamplicol.models.loading import compile_model_source
+
+    return compile_model_source(
+        source_input,
+        restriction=(
+            "default" if source.restriction is None else os.fspath(source.restriction)
+        ),
+        simplify=source.simplify,
+        cache_dir=cache_dir,
+        use_cache=use_cache,
+        require_supported=require_supported,
+    )
+
+
+def _restriction_looks_like_path(value: str) -> bool:
+    path = Path(value)
+    return (
+        path.is_absolute()
+        or path.parent != Path(".")
+        or path.name.startswith("restrict_")
+        or path.suffix.lower() in {".dat", ".json"}
+    )
+
+
+def _validate_delimiters(expression: str) -> None:
+    pairs = {")": "(", "]": "[", "}": "{"}
+    stack: list[str] = []
+    for character in expression:
+        if character in "([{":
+            stack.append(character)
+        elif character in pairs and (not stack or stack.pop() != pairs[character]):
+            raise ValueError("process expression has unbalanced delimiters")
+    if stack:
+        raise ValueError("process expression has unbalanced delimiters")
+
+
+def _default_process_name(expression: str) -> str:
+    readable = expression.replace("~", "bar")
+    readable = readable.replace(">", "_to_")
+    readable = re.sub(r"[^A-Za-z0-9]+", "_", readable).strip("_").lower()
+    if not readable or not readable[0].isalpha():
+        readable = f"process_{readable}" if readable else "process"
+    if len(readable) <= 72:
+        return readable
+    digest = hashlib.sha256(expression.encode("utf-8")).hexdigest()[:10]
+    return f"{readable[:61]}_{digest}"
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessRequest:
+    """One concrete or multiparticle process expression and its artifact name."""
+
+    expression: str
+    name: str
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.expression, str) or not self.expression:
+            raise ValueError("process expression must be a non-empty string")
+        if not isinstance(self.name, str) or not _PROCESS_NAME.fullmatch(self.name):
+            raise ValueError(
+                "process name must start with a letter and contain only "
+                "letters, digits, '.', '_', or '-'"
+            )
+
+    @classmethod
+    def parse(cls, expression: str, *, name: str | None = None) -> ProcessRequest:
+        """Normalize an expression and derive a stable readable name if omitted."""
+
+        if not isinstance(expression, str):
+            raise TypeError("process expression must be a string")
+        if "\n" in expression or "\r" in expression:
+            raise ValueError("one ProcessRequest may contain only one line")
+        normalized = " ".join(expression.split())
+        if not normalized:
+            raise ValueError("process expression must not be empty")
+        _validate_delimiters(normalized)
+        if ">" not in normalized:
+            raise ValueError("process expression must contain '>'")
+        for segment in normalized.split(","):
+            if ">" not in segment:
+                continue
+            if segment.count(">") != 1:
+                raise ValueError("each process clause must contain exactly one arrow")
+            sides = segment.split(">")
+            if any(not side.strip() for side in sides):
+                raise ValueError("each process arrow must have particles on both sides")
+        selected_name = _default_process_name(normalized) if name is None else name
+        return cls(expression=normalized, name=selected_name)
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessAlias:
+    """A public process alias backed by a generated concrete process.
+
+    ``particle_permutation`` maps each stored representative external index to
+    its public alias index. Incoming and outgoing legs may each be reordered,
+    but a leg may not cross the process arrow. Runtime selectors and metadata
+    are remapped to the alias automatically.
+    """
+
+    name: str
+    process_name: str
+    particle_permutation: tuple[int, ...] = ()
+
+    def __post_init__(self) -> None:
+        if not _PROCESS_NAME.fullmatch(self.name):
+            raise ValueError(f"invalid process alias name {self.name!r}")
+        if not _PROCESS_NAME.fullmatch(self.process_name):
+            raise ValueError(f"invalid aliased process name {self.process_name!r}")
+        permutation = tuple(self.particle_permutation)
+        if any(
+            isinstance(item, bool) or not isinstance(item, int) or item < 0
+            for item in permutation
+        ):
+            raise ValueError("particle_permutation must contain non-negative integers")
+        if permutation and sorted(permutation) != list(range(len(permutation))):
+            raise ValueError("particle_permutation must be a complete permutation")
+        object.__setattr__(self, "particle_permutation", permutation)
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessSet:
+    """A named collection of generation requests and optional crossing aliases."""
+
+    requests: tuple[ProcessRequest, ...]
+    aliases: tuple[ProcessAlias, ...] = ()
+
+    def __post_init__(self) -> None:
+        requests = tuple(self.requests)
+        aliases = tuple(self.aliases)
+        if not requests:
+            raise ValueError("a ProcessSet must contain at least one request")
+        if not all(isinstance(request, ProcessRequest) for request in requests):
+            raise TypeError("ProcessSet.requests must contain ProcessRequest objects")
+        if not all(isinstance(alias, ProcessAlias) for alias in aliases):
+            raise TypeError("ProcessSet.aliases must contain ProcessAlias objects")
+        request_names = tuple(request.name for request in requests)
+        if len(set(request_names)) != len(request_names):
+            raise ValueError("ProcessSet request names must be unique")
+        alias_names = tuple(alias.name for alias in aliases)
+        if len(set(alias_names)) != len(alias_names):
+            raise ValueError("ProcessSet alias names must be unique")
+        if set(alias_names).intersection(request_names):
+            raise ValueError("process alias names may not shadow request names")
+        unknown_targets = {
+            alias.process_name
+            for alias in aliases
+            if alias.process_name not in request_names
+        }
+        if unknown_targets:
+            raise ValueError(
+                "process aliases refer to unknown requests: "
+                + ", ".join(sorted(unknown_targets))
+            )
+        object.__setattr__(self, "requests", requests)
+        object.__setattr__(self, "aliases", aliases)
+
+    @classmethod
+    def from_expressions(
+        cls,
+        expressions: Iterable[str],
+        *,
+        names: Sequence[str] = (),
+        aliases: Iterable[ProcessAlias] = (),
+    ) -> ProcessSet:
+        """Build a process set from expressions using optional aligned names."""
+
+        expression_tuple = tuple(expressions)
+        name_tuple = tuple(names)
+        if name_tuple and len(name_tuple) != len(expression_tuple):
+            raise ValueError("process names must be empty or aligned with expressions")
+        requests = tuple(
+            ProcessRequest.parse(
+                expression,
+                name=name_tuple[index] if name_tuple else None,
+            )
+            for index, expression in enumerate(expression_tuple)
+        )
+        return cls(requests=requests, aliases=tuple(aliases))
+
+
+__all__ = [
+    "ModelSource",
+    "ModelSourceKind",
+    "ProcessAlias",
+    "ProcessRequest",
+    "ProcessSet",
+]
diff --git a/pyamplicol/src/pyamplicol/api/results.py b/pyamplicol/src/pyamplicol/api/results.py
new file mode 100644
index 0000000000..f540298d32
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/api/results.py
@@ -0,0 +1,1006 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+import os
+from collections.abc import Mapping
+from dataclasses import dataclass
+from decimal import Decimal
+from pathlib import Path
+from types import MappingProxyType
+from typing import Literal, TypeAlias, cast
+
+from pyamplicol.config import (
+    BenchmarkConfig,
+    ConfigClamp,
+    GenerationConfig,
+    RunConfig,
+)
+
+from .requests import ProcessRequest, ProcessSet
+
+
+def _freeze(value: object) -> object:
+    if isinstance(value, Mapping):
+        return MappingProxyType(
+            {str(key): _freeze(entry) for key, entry in value.items()}
+        )
+    if isinstance(value, (list, tuple)):
+        return tuple(_freeze(entry) for entry in value)
+    return value
+
+
+def _freeze_mapping(value: Mapping[str, object]) -> Mapping[str, object]:
+    frozen = _freeze(value)
+    assert isinstance(frozen, Mapping)
+    return frozen
+
+
+def _exact_decimal_sum(values: tuple[Decimal, ...]) -> Decimal:
+    if not values:
+        return Decimal(0)
+    if not all(value.is_finite() for value in values):
+        return sum(values, start=Decimal(0))
+
+    def finite_exponent(value: Decimal) -> int:
+        exponent = value.as_tuple().exponent
+        if not isinstance(exponent, int):
+            raise ValueError("finite Decimal has a non-integral exponent")
+        return exponent
+
+    common_exponent = min(finite_exponent(value) for value in values)
+    total = 0
+    for value in values:
+        sign, digits, _ = value.as_tuple()
+        exponent = finite_exponent(value)
+        coefficient = int("".join(str(digit) for digit in digits) or "0")
+        if sign:
+            coefficient = -coefficient
+        total += coefficient * 10 ** (exponent - common_exponent)
+    if total == 0:
+        return Decimal(0)
+    digits = tuple(int(character) for character in str(abs(total)))
+    return Decimal((int(total < 0), digits, common_exponent))
+
+
+@dataclass(frozen=True, slots=True)
+class ExternalParticle:
+    index: int
+    label: int
+    name: str
+    pdg_id: int
+    state: Literal["incoming", "outgoing"]
+    momentum_slot: int
+
+    def __post_init__(self) -> None:
+        for name in ("index", "label", "momentum_slot"):
+            value = getattr(self, name)
+            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                raise ValueError(f"external particle {name} must be non-negative")
+        if not self.name:
+            raise ValueError("external particle name must not be empty")
+        if isinstance(self.pdg_id, bool) or not isinstance(self.pdg_id, int):
+            raise ValueError("external particle pdg_id must be an integer")
+        if self.state not in ("incoming", "outgoing"):
+            raise ValueError("external particle state must be 'incoming' or 'outgoing'")
+
+
+@dataclass(frozen=True, slots=True)
+class HelicityConfiguration:
+    id: str
+    index: int
+    values: tuple[int, ...]
+    computed: bool
+    structural_zero: bool
+    representative_id: str
+    coefficient: float
+
+    def __post_init__(self) -> None:
+        if not self.id or not self.representative_id:
+            raise ValueError("helicity IDs must not be empty")
+        if isinstance(self.index, bool) or self.index < 0:
+            raise ValueError("helicity index must be non-negative")
+        values = tuple(self.values)
+        if not all(
+            isinstance(value, int) and not isinstance(value, bool) for value in values
+        ):
+            raise ValueError("helicity values must be integers")
+        if not math.isfinite(self.coefficient):
+            raise ValueError("helicity coefficient must be finite")
+        object.__setattr__(self, "values", values)
+
+
+@dataclass(frozen=True, slots=True)
+class ColorFlow:
+    id: str
+    index: int
+    word: tuple[int, ...]
+    computed: bool
+    representative_id: str
+    coefficient: float
+
+    def __post_init__(self) -> None:
+        if not self.id or not self.representative_id:
+            raise ValueError("color-flow IDs must not be empty")
+        if isinstance(self.index, bool) or self.index < 0:
+            raise ValueError("color-flow index must be non-negative")
+        word = tuple(self.word)
+        if not all(
+            isinstance(value, int) and not isinstance(value, bool) and value >= 0
+            for value in word
+        ):
+            raise ValueError("color-flow words must contain non-negative integers")
+        if not math.isfinite(self.coefficient):
+            raise ValueError("color-flow coefficient must be finite")
+        object.__setattr__(self, "word", word)
+
+
+@dataclass(frozen=True, slots=True)
+class ContractedColorComponent:
+    id: str
+    index: int
+    description: str
+
+    def __post_init__(self) -> None:
+        if not self.id or not self.description:
+            raise ValueError("contracted-color metadata must not be empty")
+        if isinstance(self.index, bool) or self.index < 0:
+            raise ValueError("contracted-color index must be non-negative")
+
+
+@dataclass(frozen=True, slots=True)
+class ModelParameter:
+    name: str
+    kind: str
+    default_real: float
+    default_imaginary: float
+    mutable: bool
+
+    def __post_init__(self) -> None:
+        if not self.name or not self.kind:
+            raise ValueError("model parameter name and kind must not be empty")
+        if not math.isfinite(self.default_real) or not math.isfinite(
+            self.default_imaginary
+        ):
+            raise ValueError("model parameter defaults must be finite")
+
+
+ColorComponent: TypeAlias = ColorFlow | ContractedColorComponent
+
+
+@dataclass(frozen=True, slots=True)
+class ReductionGroup:
+    id: str
+    representative_helicity_id: str
+    representative_color_id: str
+    physical_helicity_ids: tuple[str, ...]
+    physical_color_ids: tuple[str, ...]
+
+    def __post_init__(self) -> None:
+        if not self.id or not self.representative_helicity_id:
+            raise ValueError("reduction group and representative IDs must not be empty")
+        if not self.representative_color_id:
+            raise ValueError("reduction color representative ID must not be empty")
+        helicities = tuple(self.physical_helicity_ids)
+        colors = tuple(self.physical_color_ids)
+        if not helicities or not colors:
+            raise ValueError("reduction groups require physical helicity and color IDs")
+        if len(set(helicities)) != len(helicities) or len(set(colors)) != len(colors):
+            raise ValueError("reduction group member IDs must be unique")
+        if self.representative_helicity_id not in helicities:
+            raise ValueError("helicity representative must be a physical group member")
+        if self.representative_color_id not in colors:
+            raise ValueError("color representative must be a physical group member")
+        object.__setattr__(self, "physical_helicity_ids", helicities)
+        object.__setattr__(self, "physical_color_ids", colors)
+
+
+@dataclass(frozen=True, slots=True)
+class PhysicsReduction:
+    kind: Literal["lc-diagonal", "contracted-color"]
+    groups: tuple[ReductionGroup, ...]
+
+    def __post_init__(self) -> None:
+        if self.kind not in ("lc-diagonal", "contracted-color"):
+            raise ValueError("unsupported physics reduction kind")
+        groups = tuple(self.groups)
+        if not all(isinstance(group, ReductionGroup) for group in groups):
+            raise TypeError("physics reduction contains invalid groups")
+        if len({group.id for group in groups}) != len(groups):
+            raise ValueError("physics reduction group IDs must be unique")
+        object.__setattr__(self, "groups", groups)
+
+
+@dataclass(frozen=True, slots=True)
+class GenerationPlan:
+    """Dry-run result with concrete requests, coverage, and effective settings."""
+
+    concrete_processes: tuple[ProcessRequest, ...]
+    estimated_coverage: Mapping[str, object]
+    requested_settings: RunConfig | GenerationConfig
+    effective_settings: RunConfig | GenerationConfig
+    adjustments: tuple[ConfigClamp, ...] = ()
+    unsupported_features: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        concrete_processes = tuple(self.concrete_processes)
+        if not all(
+            isinstance(process, ProcessRequest) for process in concrete_processes
+        ):
+            raise TypeError("concrete_processes must contain ProcessRequest objects")
+        for name in ("requested_settings", "effective_settings"):
+            if not isinstance(getattr(self, name), (RunConfig, GenerationConfig)):
+                raise TypeError(f"{name} must be RunConfig or GenerationConfig")
+        adjustments = tuple(self.adjustments)
+        if not all(isinstance(adjustment, ConfigClamp) for adjustment in adjustments):
+            raise TypeError("adjustments must contain ConfigClamp objects")
+        unsupported_features = tuple(self.unsupported_features)
+        if not all(
+            isinstance(feature, str) and feature for feature in unsupported_features
+        ):
+            raise ValueError("unsupported_features must contain non-empty strings")
+        object.__setattr__(self, "concrete_processes", concrete_processes)
+        object.__setattr__(
+            self, "estimated_coverage", _freeze_mapping(self.estimated_coverage)
+        )
+        object.__setattr__(self, "adjustments", adjustments)
+        object.__setattr__(self, "unsupported_features", unsupported_features)
+
+
+@dataclass(frozen=True, slots=True)
+class GenerationResult:
+    """Location and process inventory of a successfully written artifact."""
+
+    output: Path
+    processes: ProcessSet
+    mode: Literal["error", "append", "replace"]
+    schema_version: int = 3
+    files: tuple[Path, ...] = ()
+
+    def __post_init__(self) -> None:
+        try:
+            output = Path(os.fspath(self.output)).expanduser().resolve(strict=False)
+            files = tuple(
+                Path(os.fspath(path)).expanduser().resolve(strict=False)
+                for path in self.files
+            )
+        except TypeError as exc:
+            raise ValueError("generation result paths must be path-like") from exc
+        object.__setattr__(self, "output", output)
+        if self.mode not in ("error", "append", "replace"):
+            raise ValueError(f"invalid generation mode {self.mode!r}")
+        if self.schema_version != 3:
+            raise ValueError("generated artifacts must use schema version 3")
+        object.__setattr__(self, "files", files)
+
+
+@dataclass(frozen=True, slots=True)
+class WarmUpResult:
+    """Metrics from warming one on-the-fly selector family at one f64 point."""
+
+    elapsed_seconds: float
+    query_count: int
+    warmed_query_count: int
+    current_rss_bytes: int | None
+    peak_rss_bytes: int | None
+    already_warm: bool
+
+    def __post_init__(self) -> None:
+        if (
+            isinstance(self.elapsed_seconds, bool)
+            or not isinstance(self.elapsed_seconds, (int, float))
+            or not math.isfinite(float(self.elapsed_seconds))
+            or self.elapsed_seconds < 0.0
+        ):
+            raise ValueError("warm-up elapsed_seconds must be finite and non-negative")
+        object.__setattr__(self, "elapsed_seconds", float(self.elapsed_seconds))
+        for name in ("query_count", "warmed_query_count"):
+            value = getattr(self, name)
+            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                raise ValueError(f"warm-up {name} must be a non-negative integer")
+        if self.warmed_query_count > self.query_count:
+            raise ValueError("warm-up warmed_query_count may not exceed query_count")
+        for name in ("current_rss_bytes", "peak_rss_bytes"):
+            value = getattr(self, name)
+            if value is not None and (
+                isinstance(value, bool) or not isinstance(value, int) or value < 0
+            ):
+                raise ValueError(
+                    f"warm-up {name} must be a non-negative integer or null"
+                )
+        if (
+            self.current_rss_bytes is not None
+            and self.peak_rss_bytes is not None
+            and self.current_rss_bytes > self.peak_rss_bytes
+        ):
+            raise ValueError("warm-up current RSS may not exceed peak RSS")
+        if not isinstance(self.already_warm, bool):
+            raise TypeError("warm-up already_warm must be a boolean")
+        if self.already_warm and self.warmed_query_count != 0:
+            raise ValueError("an already-warm selector family cannot warm new queries")
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessPhysics:
+    """Physical axes, reduction metadata, and selectors for one process.
+
+    LC processes expose physical color flows; NLC/full processes expose one
+    contracted color component. ``selector_capabilities`` states which axes may
+    be restricted without changing the generated artifact.
+    """
+
+    process_id: str
+    process: str
+    color_accuracy: Literal["lc", "nlc", "full"]
+    helicity_coverage: str
+    color_coverage: str
+    color_kind: str
+    structural_zero_helicity_count: int
+    external_particles: tuple[ExternalParticle, ...]
+    helicities: tuple[HelicityConfiguration, ...]
+    color_flows: tuple[ColorFlow, ...]
+    contracted_color_components: tuple[ContractedColorComponent, ...]
+    reduction: PhysicsReduction
+    model_parameters: tuple[ModelParameter, ...]
+    selector_capabilities: tuple[str, ...]
+
+    def __post_init__(self) -> None:
+        if not self.process_id or not self.process:
+            raise ValueError("process ID and expression must not be empty")
+        if self.color_accuracy not in ("lc", "nlc", "full"):
+            raise ValueError("color accuracy must be 'lc', 'nlc', or 'full'")
+        for name in ("helicity_coverage", "color_coverage", "color_kind"):
+            if not getattr(self, name):
+                raise ValueError(f"{name} must not be empty")
+        if (
+            isinstance(self.structural_zero_helicity_count, bool)
+            or self.structural_zero_helicity_count < 0
+        ):
+            raise ValueError("structural-zero helicity count must be non-negative")
+        particles = tuple(self.external_particles)
+        helicities = tuple(self.helicities)
+        color_flows = tuple(self.color_flows)
+        contracted = tuple(self.contracted_color_components)
+        reduction = self.reduction
+        parameters = tuple(self.model_parameters)
+        selector_capabilities = tuple(self.selector_capabilities)
+        expected = (
+            ("external_particles", particles, ExternalParticle),
+            ("helicities", helicities, HelicityConfiguration),
+            ("color_flows", color_flows, ColorFlow),
+            ("contracted_color_components", contracted, ContractedColorComponent),
+            ("model_parameters", parameters, ModelParameter),
+        )
+        for name, values, expected_type in expected:
+            if not all(isinstance(value, expected_type) for value in values):
+                raise TypeError(f"{name} contains invalid metadata")
+        if not helicities:
+            raise ValueError("physics metadata requires physical helicities")
+        particle_indices = tuple(particle.index for particle in particles)
+        if len(set(particle_indices)) != len(particles):
+            raise ValueError("external particle indices must be unique")
+        for name, identifiers in (
+            ("helicities", tuple(value.id for value in helicities)),
+            ("color_flows", tuple(value.id for value in color_flows)),
+            (
+                "contracted_color_components",
+                tuple(value.id for value in contracted),
+            ),
+        ):
+            if len(set(identifiers)) != len(identifiers):
+                raise ValueError(f"{name} IDs must be unique")
+        parameter_names = tuple(parameter.name for parameter in parameters)
+        if len(set(parameter_names)) != len(parameter_names):
+            raise ValueError("model parameter names must be unique")
+        if self.color_accuracy == "lc" and not color_flows:
+            raise ValueError("LC physics metadata requires physical color flows")
+        if self.color_accuracy != "lc" and len(contracted) != 1:
+            raise ValueError("NLC/full physics metadata requires one color component")
+        if not isinstance(reduction, PhysicsReduction):
+            raise TypeError("reduction must be PhysicsReduction metadata")
+        expected_reduction = (
+            "lc-diagonal" if self.color_accuracy == "lc" else "contracted-color"
+        )
+        if reduction.kind != expected_reduction:
+            raise ValueError("reduction kind does not match color accuracy")
+        physical_helicity_ids = {value.id for value in helicities}
+        physical_color_ids = {value.id for value in color_flows} | {
+            value.id for value in contracted
+        }
+        for group in reduction.groups:
+            if not set(group.physical_helicity_ids) <= physical_helicity_ids:
+                raise ValueError("reduction references unknown physical helicities")
+            if not set(group.physical_color_ids) <= physical_color_ids:
+                raise ValueError("reduction references unknown physical colors")
+        if not all(isinstance(value, str) and value for value in selector_capabilities):
+            raise ValueError("selector_capabilities must contain non-empty strings")
+        if len(set(selector_capabilities)) != len(selector_capabilities):
+            raise ValueError("selector_capabilities must be unique")
+        object.__setattr__(self, "external_particles", particles)
+        object.__setattr__(self, "helicities", helicities)
+        object.__setattr__(self, "color_flows", color_flows)
+        object.__setattr__(self, "contracted_color_components", contracted)
+        object.__setattr__(self, "model_parameters", parameters)
+        object.__setattr__(self, "selector_capabilities", selector_capabilities)
+
+    @property
+    def helicity_ids(self) -> tuple[str, ...]:
+        return tuple(item.id for item in self.helicities)
+
+    @property
+    def color_flow_ids(self) -> tuple[str, ...]:
+        return tuple(item.id for item in self.color_flows)
+
+    @property
+    def color_ids(self) -> tuple[str, ...]:
+        components: tuple[ColorComponent, ...] = (
+            self.color_flows
+            if self.color_accuracy == "lc"
+            else self.contracted_color_components
+        )
+        return tuple(item.id for item in components)
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedEvaluation:
+    """Physical values shaped ``(point, helicity, color)``.
+
+    :meth:`total` explicitly sums the helicity and color axes for each point and
+    reproduces the compatibility summed evaluation.
+    """
+
+    values: tuple[tuple[tuple[complex | Decimal, ...], ...], ...]
+    helicity_ids: tuple[str, ...]
+    color_ids: tuple[str, ...]
+    color_accuracy: Literal["lc", "nlc", "full"] = "lc"
+
+    def __post_init__(self) -> None:
+        values = tuple(
+            tuple(
+                tuple(
+                    entry if isinstance(entry, Decimal) else complex(entry)
+                    for entry in colors
+                )
+                for colors in helicities
+            )
+            for helicities in self.values
+        )
+        helicity_ids = tuple(self.helicity_ids)
+        color_ids = tuple(self.color_ids)
+        expected_colors = len(color_ids)
+        if self.color_accuracy != "lc" and expected_colors != 1:
+            raise ValueError("NLC/full resolved output has one contracted color axis")
+        for point in values:
+            if len(point) != len(helicity_ids):
+                raise ValueError(
+                    "resolved values do not match the physical helicity dimension"
+                )
+            if any(len(colors) != expected_colors for colors in point):
+                raise ValueError(
+                    "resolved values do not match the contracted color dimension"
+                )
+        if self.color_accuracy not in ("lc", "nlc", "full"):
+            raise ValueError("color_accuracy must be 'lc', 'nlc', or 'full'")
+        object.__setattr__(self, "values", values)
+        object.__setattr__(self, "helicity_ids", helicity_ids)
+        object.__setattr__(self, "color_ids", color_ids)
+
+    @property
+    def color_flow_ids(self) -> tuple[str, ...]:
+        return self.color_ids if self.color_accuracy == "lc" else ()
+
+    @property
+    def accuracy(self) -> Literal["lc", "nlc", "full"]:
+        """Compatibility alias for :attr:`color_accuracy`."""
+
+        return self.color_accuracy
+
+    @property
+    def shape(self) -> tuple[int, int, int]:
+        return (len(self.values), len(self.helicity_ids), len(self.color_ids))
+
+    def total(self) -> tuple[complex | Decimal, ...]:
+        """Sum all non-point axes while preserving decimal precision."""
+
+        totals: list[complex | Decimal] = []
+        for point in self.values:
+            entries = tuple(entry for helicity in point for entry in helicity)
+            if entries and isinstance(entries[0], Decimal):
+                if not all(isinstance(entry, Decimal) for entry in entries):
+                    raise TypeError("resolved values must not mix Decimal and complex")
+                totals.append(
+                    _exact_decimal_sum(tuple(cast(Decimal, entry) for entry in entries))
+                )
+            else:
+                totals.append(sum((complex(entry) for entry in entries), start=0j))
+        return tuple(totals)
+
+
+@dataclass(frozen=True, slots=True)
+class BenchmarkStatistics:
+    """Distribution summary for repeated benchmark measurements."""
+
+    standard_deviation: float
+    standard_error: float
+    relative_standard_error: float
+
+    def __post_init__(self) -> None:
+        for name in (
+            "standard_deviation",
+            "standard_error",
+            "relative_standard_error",
+        ):
+            value = getattr(self, name)
+            if not math.isfinite(value) or value < 0:
+                raise ValueError(f"benchmark {name} must be finite and non-negative")
+
+
+@dataclass(frozen=True, slots=True)
+class BenchmarkComponentTiming:
+    """Mean per-point time and uncertainty for one runtime-profile component."""
+
+    mean_seconds_per_point: float
+    uncertainty: BenchmarkStatistics
+    sample_count: int
+
+    def __post_init__(self) -> None:
+        if (
+            not math.isfinite(self.mean_seconds_per_point)
+            or self.mean_seconds_per_point < 0
+        ):
+            raise ValueError(
+                "benchmark component timing must be finite and non-negative"
+            )
+        if not isinstance(self.uncertainty, BenchmarkStatistics):
+            raise TypeError(
+                "benchmark component uncertainty must be BenchmarkStatistics"
+            )
+        if (
+            isinstance(self.sample_count, bool)
+            or not isinstance(self.sample_count, int)
+            or self.sample_count < 1
+        ):
+            raise ValueError("benchmark component sample_count must be positive")
+
+
+@dataclass(frozen=True, slots=True)
+class BenchmarkStageTiming:
+    """Per-point timings for one native evaluator stage.
+
+    The leaf/backend/output-gather fields are internal attribution, not
+    additional top-level phases. A full-stage leaf gather is owned by the
+    evaluator-call envelope; a composed selected-chunk leaf gather is owned by
+    the input-pack envelope.
+    """
+
+    stage_index: int
+    input_pack_time: BenchmarkComponentTiming | None = None
+    evaluator_call_time: BenchmarkComponentTiming | None = None
+    output_assign_time: BenchmarkComponentTiming | None = None
+    leaf_input_pack_time: BenchmarkComponentTiming | None = None
+    backend_call_time: BenchmarkComponentTiming | None = None
+    evaluator_output_gather_time: BenchmarkComponentTiming | None = None
+
+    def __post_init__(self) -> None:
+        if (
+            isinstance(self.stage_index, bool)
+            or not isinstance(self.stage_index, int)
+            or self.stage_index < 1
+        ):
+            raise ValueError("benchmark stage_index must be positive")
+        timings = (
+            self.input_pack_time,
+            self.evaluator_call_time,
+            self.output_assign_time,
+            self.leaf_input_pack_time,
+            self.backend_call_time,
+            self.evaluator_output_gather_time,
+        )
+        if not any(timing is not None for timing in timings):
+            raise ValueError("benchmark stage timing must contain at least one value")
+        if any(
+            timing is not None and not isinstance(timing, BenchmarkComponentTiming)
+            for timing in timings
+        ):
+            raise TypeError("benchmark stage timings must be BenchmarkComponentTiming")
+
+
+@dataclass(frozen=True, slots=True)
+class BenchmarkProfileCounters:
+    """Mean native profile work counts with an explicit normalization basis.
+
+    Movement and materialization fields are means per profiled phase-space
+    point. Backend-call, allocation, and compiled Direct-Arena fields are means
+    per profiled runtime call. The native repeated profiler reports integer
+    totals; normalizing before aggregating samples keeps these values comparable
+    across batch sizes and repetition counts.
+    """
+
+    sample_count: int
+    normalization: Literal["mean_per_profiled_point_or_runtime_call_v1"] = (
+        "mean_per_profiled_point_or_runtime_call_v1"
+    )
+    native_input_components_per_point: float | None = None
+    native_input_pack_bytes_per_point: float | None = None
+    native_input_crossing_bytes_per_point: float | None = None
+    state_components_per_point: float | None = None
+    state_clear_components_per_point: float | None = None
+    source_components_per_point: float | None = None
+    momentum_components_per_point: float | None = None
+    model_parameter_components_per_point: float | None = None
+    stage_input_copy_components_per_point: float | None = None
+    stage_leaf_input_copy_components_per_point: float | None = None
+    stage_evaluator_output_gather_components_per_point: float | None = None
+    stage_output_assign_components_per_point: float | None = None
+    amplitude_input_copy_components_per_point: float | None = None
+    amplitude_leaf_input_copy_components_per_point: float | None = None
+    amplitude_evaluator_output_gather_components_per_point: float | None = None
+    amplitude_output_remap_components_per_point: float | None = None
+    reduction_input_components_per_point: float | None = None
+    selector_gather_points_per_point: float | None = None
+    selector_gather_bytes_per_point: float | None = None
+    selector_scatter_values_per_point: float | None = None
+    resolved_materialized_components_per_point: float | None = None
+    total_materialized_values_per_point: float | None = None
+    final_output_copy_values_per_point: float | None = None
+    native_input_container_allocations_per_call: float | None = None
+    evaluator_backend_calls_per_call: float | None = None
+    compiled_direct_arena_engines_per_call: float | None = None
+    compiled_direct_arena_calls_per_call: float | None = None
+    compiled_direct_arena_boundary_input_bytes_per_call: float | None = None
+    compiled_direct_arena_boundary_current_output_bytes_per_call: float | None = None
+    compiled_direct_arena_boundary_amplitude_output_bytes_per_call: float | None = None
+    recurrence_momentum_scalar_values_per_point: float | None = None
+    recurrence_schedule_executions_per_call: float | None = None
+    recurrence_replay_schedule_executions_per_call: float | None = None
+    recurrence_union_schedule_executions_per_call: float | None = None
+    recurrence_union_source_rows_per_call: float | None = None
+    recurrence_replay_output_values_per_point: float | None = None
+    recurrence_source_calls_per_call: float | None = None
+    recurrence_source_rows_per_call: float | None = None
+    recurrence_contribution_calls_per_call: float | None = None
+    recurrence_contribution_rows_per_call: float | None = None
+    recurrence_finalization_calls_per_call: float | None = None
+    recurrence_finalization_rows_per_call: float | None = None
+    recurrence_closure_calls_per_call: float | None = None
+    recurrence_closure_rows_per_call: float | None = None
+    observed_scratch_reallocations_per_call: float | None = None
+    native_output_allocations_per_call: float | None = None
+
+    def __post_init__(self) -> None:
+        if (
+            isinstance(self.sample_count, bool)
+            or not isinstance(self.sample_count, int)
+            or self.sample_count < 1
+        ):
+            raise ValueError("benchmark profile counter sample_count must be positive")
+        if self.normalization != "mean_per_profiled_point_or_runtime_call_v1":
+            raise ValueError("benchmark profile counter normalization is invalid")
+        for name in (
+            "native_input_components_per_point",
+            "native_input_pack_bytes_per_point",
+            "native_input_crossing_bytes_per_point",
+            "state_components_per_point",
+            "state_clear_components_per_point",
+            "source_components_per_point",
+            "momentum_components_per_point",
+            "model_parameter_components_per_point",
+            "stage_input_copy_components_per_point",
+            "stage_leaf_input_copy_components_per_point",
+            "stage_evaluator_output_gather_components_per_point",
+            "stage_output_assign_components_per_point",
+            "amplitude_input_copy_components_per_point",
+            "amplitude_leaf_input_copy_components_per_point",
+            "amplitude_evaluator_output_gather_components_per_point",
+            "amplitude_output_remap_components_per_point",
+            "reduction_input_components_per_point",
+            "selector_gather_points_per_point",
+            "selector_gather_bytes_per_point",
+            "selector_scatter_values_per_point",
+            "resolved_materialized_components_per_point",
+            "total_materialized_values_per_point",
+            "final_output_copy_values_per_point",
+            "native_input_container_allocations_per_call",
+            "evaluator_backend_calls_per_call",
+            "compiled_direct_arena_engines_per_call",
+            "compiled_direct_arena_calls_per_call",
+            "compiled_direct_arena_boundary_input_bytes_per_call",
+            "compiled_direct_arena_boundary_current_output_bytes_per_call",
+            "compiled_direct_arena_boundary_amplitude_output_bytes_per_call",
+            "recurrence_momentum_scalar_values_per_point",
+            "recurrence_schedule_executions_per_call",
+            "recurrence_replay_schedule_executions_per_call",
+            "recurrence_union_schedule_executions_per_call",
+            "recurrence_union_source_rows_per_call",
+            "recurrence_replay_output_values_per_point",
+            "recurrence_source_calls_per_call",
+            "recurrence_source_rows_per_call",
+            "recurrence_contribution_calls_per_call",
+            "recurrence_contribution_rows_per_call",
+            "recurrence_finalization_calls_per_call",
+            "recurrence_finalization_rows_per_call",
+            "recurrence_closure_calls_per_call",
+            "recurrence_closure_rows_per_call",
+            "observed_scratch_reallocations_per_call",
+            "native_output_allocations_per_call",
+        ):
+            value = getattr(self, name)
+            if value is not None and (
+                not isinstance(value, (float, int))
+                or isinstance(value, bool)
+                or not math.isfinite(float(value))
+                or value < 0
+            ):
+                raise ValueError(
+                    f"benchmark profile counter {name} must be finite and non-negative"
+                )
+
+
+@dataclass(frozen=True, slots=True)
+class BenchmarkTimingBreakdown:
+    """Typed aggregate of bounded native Rusticol profile samples.
+
+    Internal leaf/backend/output-gather/remap fields explain their enclosing
+    work but are not additive top-level phases. Leaf gathering is owned by the
+    evaluator envelope for full stages and by the input-pack envelope for
+    composed selected-chunk paths. The recurrence schedule is an inclusive
+    top-level phase; its source-kernel, contribution-kernel, finalization, and
+    closure fields are sub-attribution and must not be added to it.
+    """
+
+    sample_count: int
+    execution_mode: Literal["compiled", "eager", "recurrence", "on-the-fly"] = (
+        "compiled"
+    )
+    wall_time: BenchmarkComponentTiming | None = None
+    source_fill_time: BenchmarkComponentTiming | None = None
+    momentum_setup_time: BenchmarkComponentTiming | None = None
+    stage_input_pack_time: BenchmarkComponentTiming | None = None
+    stage_evaluator_call_time: BenchmarkComponentTiming | None = None
+    output_assign_time: BenchmarkComponentTiming | None = None
+    amplitude_input_pack_time: BenchmarkComponentTiming | None = None
+    amplitude_evaluator_call_time: BenchmarkComponentTiming | None = None
+    reduction_time: BenchmarkComponentTiming | None = None
+    other_core_time: BenchmarkComponentTiming | None = None
+    eager_execution_time: BenchmarkComponentTiming | None = None
+    eager_initialize_time: BenchmarkComponentTiming | None = None
+    eager_gather_time: BenchmarkComponentTiming | None = None
+    eager_kernel_call_time: BenchmarkComponentTiming | None = None
+    eager_invocation_scatter_time: BenchmarkComponentTiming | None = None
+    eager_finalization_time: BenchmarkComponentTiming | None = None
+    eager_scatter_finalization_time: BenchmarkComponentTiming | None = None
+    eager_closure_time: BenchmarkComponentTiming | None = None
+    eager_copy_out_time: BenchmarkComponentTiming | None = None
+    stages: tuple[BenchmarkStageTiming, ...] = ()
+    native_input_pack_time: BenchmarkComponentTiming | None = None
+    native_input_crossing_time: BenchmarkComponentTiming | None = None
+    orchestration_time: BenchmarkComponentTiming | None = None
+    state_prepare_time: BenchmarkComponentTiming | None = None
+    state_clear_time: BenchmarkComponentTiming | None = None
+    momentum_input_setup_time: BenchmarkComponentTiming | None = None
+    model_parameter_setup_time: BenchmarkComponentTiming | None = None
+    total_materialization_time: BenchmarkComponentTiming | None = None
+    final_output_copy_time: BenchmarkComponentTiming | None = None
+    selector_planner_time: BenchmarkComponentTiming | None = None
+    selector_gather_time: BenchmarkComponentTiming | None = None
+    selector_scatter_time: BenchmarkComponentTiming | None = None
+    recurrence_momentum_fill_time: BenchmarkComponentTiming | None = None
+    recurrence_union_source_fill_time: BenchmarkComponentTiming | None = None
+    recurrence_schedule_time: BenchmarkComponentTiming | None = None
+    recurrence_source_kernel_time: BenchmarkComponentTiming | None = None
+    recurrence_contribution_kernel_time: BenchmarkComponentTiming | None = None
+    recurrence_finalization_time: BenchmarkComponentTiming | None = None
+    recurrence_closure_time: BenchmarkComponentTiming | None = None
+    recurrence_replay_output_mapping_time: BenchmarkComponentTiming | None = None
+    counters: BenchmarkProfileCounters | None = None
+    stage_leaf_input_pack_time: BenchmarkComponentTiming | None = None
+    stage_backend_call_time: BenchmarkComponentTiming | None = None
+    stage_evaluator_output_gather_time: BenchmarkComponentTiming | None = None
+    amplitude_leaf_input_pack_time: BenchmarkComponentTiming | None = None
+    amplitude_backend_call_time: BenchmarkComponentTiming | None = None
+    amplitude_evaluator_output_gather_time: BenchmarkComponentTiming | None = None
+    amplitude_output_remap_time: BenchmarkComponentTiming | None = None
+
+    def __post_init__(self) -> None:
+        if (
+            isinstance(self.sample_count, bool)
+            or not isinstance(self.sample_count, int)
+            or self.sample_count < 1
+        ):
+            raise ValueError("benchmark timing breakdown sample_count must be positive")
+        if self.execution_mode not in {
+            "compiled",
+            "eager",
+            "recurrence",
+            "on-the-fly",
+        }:
+            raise ValueError(
+                "benchmark timing breakdown execution_mode must be compiled, eager, "
+                "recurrence, or on-the-fly"
+            )
+        for name in (
+            "wall_time",
+            "native_input_pack_time",
+            "native_input_crossing_time",
+            "orchestration_time",
+            "state_prepare_time",
+            "state_clear_time",
+            "source_fill_time",
+            "momentum_input_setup_time",
+            "momentum_setup_time",
+            "model_parameter_setup_time",
+            "stage_input_pack_time",
+            "stage_evaluator_call_time",
+            "stage_leaf_input_pack_time",
+            "stage_backend_call_time",
+            "stage_evaluator_output_gather_time",
+            "output_assign_time",
+            "amplitude_input_pack_time",
+            "amplitude_evaluator_call_time",
+            "amplitude_leaf_input_pack_time",
+            "amplitude_backend_call_time",
+            "amplitude_evaluator_output_gather_time",
+            "amplitude_output_remap_time",
+            "reduction_time",
+            "total_materialization_time",
+            "final_output_copy_time",
+            "selector_planner_time",
+            "selector_gather_time",
+            "selector_scatter_time",
+            "other_core_time",
+            "eager_execution_time",
+            "eager_initialize_time",
+            "eager_gather_time",
+            "eager_kernel_call_time",
+            "eager_invocation_scatter_time",
+            "eager_finalization_time",
+            "eager_scatter_finalization_time",
+            "eager_closure_time",
+            "eager_copy_out_time",
+            "recurrence_momentum_fill_time",
+            "recurrence_union_source_fill_time",
+            "recurrence_schedule_time",
+            "recurrence_source_kernel_time",
+            "recurrence_contribution_kernel_time",
+            "recurrence_finalization_time",
+            "recurrence_closure_time",
+            "recurrence_replay_output_mapping_time",
+        ):
+            value = getattr(self, name)
+            if value is not None and not isinstance(value, BenchmarkComponentTiming):
+                raise TypeError(
+                    f"benchmark timing breakdown {name} must be "
+                    "BenchmarkComponentTiming or null"
+                )
+        stages = tuple(self.stages)
+        if not all(isinstance(stage, BenchmarkStageTiming) for stage in stages):
+            raise TypeError("benchmark timing breakdown stages are invalid")
+        indices = tuple(stage.stage_index for stage in stages)
+        if len(indices) != len(set(indices)):
+            raise ValueError("benchmark timing breakdown stage indices must be unique")
+        if self.counters is not None and not isinstance(
+            self.counters, BenchmarkProfileCounters
+        ):
+            raise TypeError(
+                "benchmark timing breakdown counters must be "
+                "BenchmarkProfileCounters or null"
+            )
+        object.__setattr__(self, "stages", stages)
+
+
+@dataclass(frozen=True, slots=True)
+class BenchmarkResult:
+    """Per-point timings and uncertainty across independent measured blocks.
+
+    ``sample_count`` is the number of timed blocks. Each block averages
+    ``repetitions_per_sample`` runtime calls of ``effective_config.batch_size``
+    points. For native f64 evaluation, ``wall_time_per_point`` is measured by
+    Rusticol around repeated core evaluations of an already packed momentum
+    buffer; caller-language conversion and adapter overhead are excluded.
+    For compiled/eager execution, ``evaluator_time_per_point`` is the relevant
+    evaluator envelope measured by the bounded native profiler. For recurrence
+    and on-the-fly execution, it is the inclusive recurrence schedule measured
+    by the paired profiled pass. ``evaluator_total_time_per_point`` is the
+    accumulated warmed headline evaluator duration divided by its authenticated
+    measured-point count; it is distinct from both wall-sample statistics and
+    execution attribution.
+    ``interrupted`` marks a valid partial result computed only from timing blocks
+    that finished before sampling was interrupted.
+    """
+
+    requested_config: BenchmarkConfig
+    effective_config: BenchmarkConfig
+    sample_count: int
+    wall_time_per_point: float
+    evaluator_time_per_point: float | None
+    uncertainty: BenchmarkStatistics
+    environment: Mapping[str, object]
+    repetitions_per_sample: int = 1
+    evaluator_uncertainty: BenchmarkStatistics | None = None
+    process_id: str | None = None
+    process_expression: str | None = None
+    timing_breakdown: BenchmarkTimingBreakdown | None = None
+    interrupted: bool = False
+    evaluator_total_time_per_point: float | None = None
+
+    def __post_init__(self) -> None:
+        if (
+            isinstance(self.sample_count, bool)
+            or not isinstance(self.sample_count, int)
+            or self.sample_count < 1
+        ):
+            raise ValueError("benchmark sample_count must be positive")
+        if not isinstance(self.interrupted, bool):
+            raise TypeError("benchmark interrupted flag must be a boolean")
+        if not math.isfinite(self.wall_time_per_point) or self.wall_time_per_point < 0:
+            raise ValueError("benchmark wall_time_per_point must be non-negative")
+        if self.evaluator_time_per_point is not None and (
+            not math.isfinite(self.evaluator_time_per_point)
+            or self.evaluator_time_per_point < 0
+        ):
+            raise ValueError("benchmark evaluator_time_per_point must be non-negative")
+        if self.evaluator_total_time_per_point is not None and (
+            not math.isfinite(self.evaluator_total_time_per_point)
+            or self.evaluator_total_time_per_point <= 0
+        ):
+            raise ValueError(
+                "benchmark evaluator_total_time_per_point must be positive"
+            )
+        if (
+            isinstance(self.repetitions_per_sample, bool)
+            or not isinstance(self.repetitions_per_sample, int)
+            or self.repetitions_per_sample < 1
+        ):
+            raise ValueError("benchmark repetitions_per_sample must be positive")
+        if self.evaluator_uncertainty is not None and not isinstance(
+            self.evaluator_uncertainty, BenchmarkStatistics
+        ):
+            raise TypeError(
+                "benchmark evaluator_uncertainty must be BenchmarkStatistics or null"
+            )
+        for name in ("process_id", "process_expression"):
+            value = getattr(self, name)
+            if value is not None and (not isinstance(value, str) or not value):
+                raise ValueError(f"benchmark {name} must be a non-empty string or null")
+        if self.timing_breakdown is not None and not isinstance(
+            self.timing_breakdown, BenchmarkTimingBreakdown
+        ):
+            raise TypeError(
+                "benchmark timing_breakdown must be BenchmarkTimingBreakdown or null"
+            )
+        object.__setattr__(self, "environment", _freeze_mapping(self.environment))
+
+    @property
+    def evaluation_count(self) -> int:
+        """Return the number of timed runtime evaluations."""
+
+        return self.sample_count * self.repetitions_per_sample
+
+    @property
+    def evaluated_point_count(self) -> int:
+        """Return the number of phase-space point evaluations timed."""
+
+        return self.evaluation_count * self.effective_config.batch_size
+
+
+__all__ = [
+    "BenchmarkComponentTiming",
+    "BenchmarkProfileCounters",
+    "BenchmarkResult",
+    "BenchmarkStageTiming",
+    "BenchmarkStatistics",
+    "BenchmarkTimingBreakdown",
+    "ColorComponent",
+    "ColorFlow",
+    "ContractedColorComponent",
+    "ExternalParticle",
+    "GenerationPlan",
+    "GenerationResult",
+    "HelicityConfiguration",
+    "ModelParameter",
+    "PhysicsReduction",
+    "ProcessPhysics",
+    "ReductionGroup",
+    "ResolvedEvaluation",
+    "WarmUpResult",
+]
diff --git a/pyamplicol/src/pyamplicol/api/services.py b/pyamplicol/src/pyamplicol/api/services.py
new file mode 100644
index 0000000000..87df2a81c9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/api/services.py
@@ -0,0 +1,1016 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib
+import inspect
+import os
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from decimal import Decimal
+from fractions import Fraction
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal, cast
+
+import pyamplicol as _pyamplicol
+from pyamplicol.config import (
+    Action,
+    BenchmarkConfig,
+    ConfigResolution,
+    GenerationConfig,
+    RunConfig,
+)
+from pyamplicol.reporting import ProgressSink
+
+from .errors import (
+    ArtifactError,
+    CompatibilityError,
+    DependencyError,
+    EvaluationError,
+    GenerationError,
+)
+from .protocols import (
+    BenchmarkBackend,
+    BenchmarkFactory,
+    GeneratorBackend,
+    GeneratorFactory,
+    ModelParameters,
+    Momenta,
+    RuntimeBackend,
+    RuntimeLoader,
+)
+from .requests import ModelSource, ProcessRequest, ProcessSet
+from .results import (
+    BenchmarkResult,
+    ColorFlow,
+    GenerationPlan,
+    GenerationResult,
+    HelicityConfiguration,
+    ProcessPhysics,
+    ResolvedEvaluation,
+    WarmUpResult,
+)
+
+_generator_factory: GeneratorFactory | None = None
+_runtime_loader: RuntimeLoader | None = None
+_benchmark_factory: BenchmarkFactory | None = None
+
+if TYPE_CHECKING:
+    from pyamplicol.runtime.correlations import CorrelatorCatalogue, CorrelatorEvaluator
+
+
+def install_backend_factories(
+    *,
+    generator: GeneratorFactory | None = None,
+    runtime: RuntimeLoader | None = None,
+    benchmark: BenchmarkFactory | None = None,
+) -> None:
+    """Install backend adapters without importing domain dependencies eagerly."""
+
+    global _generator_factory, _runtime_loader, _benchmark_factory
+    if generator is not None:
+        _generator_factory = generator
+    if runtime is not None:
+        _runtime_loader = runtime
+    if benchmark is not None:
+        _benchmark_factory = benchmark
+
+
+def _discover(attribute: str, modules: Sequence[str]) -> Any:
+    failures: list[str] = []
+    for module_name in modules:
+        try:
+            module = importlib.import_module(module_name)
+        except ImportError as exc:
+            failures.append(f"{module_name}: {exc}")
+            continue
+        factory = getattr(module, attribute, None)
+        if factory is not None:
+            return factory
+        failures.append(f"{module_name}: missing {attribute}")
+    detail = "; ".join(failures)
+    raise DependencyError(
+        f"no pyAmpliCol backend provides {attribute}; backend discovery tried {detail}"
+    )
+
+
+def _get_generator_factory() -> GeneratorFactory:
+    if _generator_factory is not None:
+        return _generator_factory
+    return cast(
+        GeneratorFactory,
+        _discover(
+            "create_generator_backend",
+            ("pyamplicol.generation", "pyamplicol.generation.service"),
+        ),
+    )
+
+
+def _generation_resource_resolution(
+    config: GenerationConfig | RunConfig | ConfigResolution | None,
+) -> ConfigResolution:
+    from pyamplicol import licensing
+
+    if isinstance(config, ConfigResolution):
+        effective = config.effective
+    else:
+        effective = (
+            RunConfig(action=Action.GENERATE)
+            if config is None
+            else RunConfig(action=Action.GENERATE, generation=config)
+            if isinstance(config, GenerationConfig)
+            else config
+        )
+    state = licensing.detect_symbolica_license(
+        suggest=effective.symbolica.suggest_license,
+        json_mode=str(effective.output.format) == "json",
+    )
+    return licensing.resolve_symbolica_resource_config(
+        config,
+        state,
+    )
+
+
+def _get_runtime_loader() -> RuntimeLoader:
+    if _runtime_loader is not None:
+        return _runtime_loader
+    return cast(
+        RuntimeLoader,
+        _discover(
+            "load_runtime_backend",
+            ("pyamplicol.artifact", "pyamplicol.runtime"),
+        ),
+    )
+
+
+def _get_benchmark_factory() -> BenchmarkFactory:
+    if _benchmark_factory is not None:
+        return _benchmark_factory
+    return cast(
+        BenchmarkFactory,
+        _discover(
+            "create_benchmark_backend",
+            ("pyamplicol.benchmarking", "pyamplicol.benchmark"),
+        ),
+    )
+
+
+def _process_set(
+    processes: ProcessSet | ProcessRequest | str | Iterable[ProcessRequest | str],
+) -> ProcessSet:
+    if isinstance(processes, ProcessSet):
+        return processes
+    if isinstance(processes, ProcessRequest):
+        return ProcessSet((processes,))
+    if isinstance(processes, str):
+        return ProcessSet((ProcessRequest.parse(processes),))
+    requests = tuple(
+        entry if isinstance(entry, ProcessRequest) else ProcessRequest.parse(entry)
+        for entry in processes
+    )
+    return ProcessSet(requests)
+
+
+def _validate_progress(progress: ProgressSink | None) -> None:
+    if progress is not None and not isinstance(progress, ProgressSink):
+        raise TypeError("progress must implement ProgressSink.emit(event)")
+
+
+def _validate_precision(precision: int) -> int:
+    if isinstance(precision, bool) or not isinstance(precision, int):
+        raise TypeError("precision must be a positive integer number of decimal digits")
+    if precision < 1:
+        raise ValueError(
+            "precision must be a positive integer number of decimal digits"
+        )
+    return precision
+
+
+def _selector_ids(
+    values: Sequence[str | HelicityConfiguration | ColorFlow] | None,
+    *,
+    expected_type: type[HelicityConfiguration] | type[ColorFlow],
+    name: str,
+) -> tuple[str, ...] | None:
+    if values is None:
+        return None
+    identifiers: list[str] = []
+    for value in values:
+        if isinstance(value, str) and value:
+            identifiers.append(value)
+        elif isinstance(value, expected_type):
+            identifiers.append(value.id)
+        else:
+            raise TypeError(f"{name} selectors must be IDs or {expected_type.__name__}")
+    if len(set(identifiers)) != len(identifiers):
+        raise ValueError(f"{name} selectors must be unique")
+    return tuple(identifiers) or None
+
+
+def _point_selector_ids(
+    values: Sequence[str | HelicityConfiguration | ColorFlow] | None,
+    *,
+    expected_type: type[HelicityConfiguration] | type[ColorFlow],
+    name: str,
+) -> tuple[str, ...] | None:
+    if values is None:
+        return None
+    identifiers: list[str] = []
+    for value in values:
+        if isinstance(value, str) and value:
+            identifiers.append(value)
+        elif isinstance(value, expected_type):
+            identifiers.append(value.id)
+        else:
+            raise TypeError(f"{name} selectors must be IDs or {expected_type.__name__}")
+    return tuple(identifiers) or None
+
+
+def _accepts_keyword_arguments(operation: object, *names: str) -> bool:
+    if not callable(operation):
+        return False
+    try:
+        parameters = inspect.signature(operation).parameters.values()
+    except (TypeError, ValueError):
+        return False
+    declared = {parameter.name for parameter in parameters}
+    accepts_arbitrary = any(
+        parameter.kind is inspect.Parameter.VAR_KEYWORD for parameter in parameters
+    )
+    return accepts_arbitrary or all(name in declared for name in names)
+
+
+class Generator:
+    """Plan and generate process artifacts with typed configuration.
+
+    A :class:`~pyamplicol.config.ConfigResolution` preserves both requested and
+    effective settings, including license/resource clamps, in the output.
+    """
+
+    def __init__(
+        self,
+        config: GenerationConfig | RunConfig | ConfigResolution | None = None,
+        progress: ProgressSink | None = None,
+    ) -> None:
+        if config is not None and not isinstance(
+            config, (GenerationConfig, RunConfig, ConfigResolution)
+        ):
+            raise TypeError(
+                "Generator config must be GenerationConfig, RunConfig, "
+                "ConfigResolution, or null"
+            )
+        _validate_progress(progress)
+        self._config = config
+        self._progress = progress
+        self._backend: GeneratorBackend | None = None
+
+    def _implementation(self) -> GeneratorBackend:
+        if self._backend is None:
+            self._backend = _get_generator_factory()(self._config, self._progress)
+        return self._backend
+
+    def _resolve_generation_resources(self) -> None:
+        resource_config = _generation_resource_resolution(self._config)
+        if resource_config != self._config:
+            self._config = resource_config
+            self._backend = None
+
+    def plan(
+        self,
+        processes: ProcessSet | ProcessRequest | str | Iterable[ProcessRequest | str],
+        *,
+        model: ModelSource | _pyamplicol.CompiledModel | None = None,
+    ) -> GenerationPlan:
+        """Resolve concrete processes and coverage without writing an artifact."""
+
+        process_set = _process_set(processes)
+        self._resolve_generation_resources()
+        result = self._implementation().plan(process_set, model=model)
+        if not isinstance(result, GenerationPlan):
+            raise GenerationError(
+                "generator backend returned an invalid GenerationPlan"
+            )
+        return result
+
+    def generate(
+        self,
+        processes: ProcessSet | ProcessRequest | str | Iterable[ProcessRequest | str],
+        output: os.PathLike[str] | str,
+        *,
+        model: ModelSource | _pyamplicol.CompiledModel | None = None,
+        mode: Literal["error", "append", "replace"] = "error",
+        correlators: _pyamplicol.CorrelatorConfig | None = None,
+    ) -> GenerationResult:
+        """Generate an artifact in ``error``, ``append``, or ``replace`` mode."""
+
+        if mode not in ("error", "append", "replace"):
+            raise ValueError("generation mode must be 'error', 'append', or 'replace'")
+        process_set = _process_set(processes)
+        destination = Path(os.fspath(output)).expanduser().resolve(strict=False)
+        if destination.exists() and not destination.is_dir():
+            raise GenerationError(
+                f"artifact destination is not a directory: {destination}"
+            )
+        if mode == "error" and destination.exists():
+            raise FileExistsError(f"artifact already exists: {destination}")
+        if mode == "append" and not destination.is_dir():
+            raise FileNotFoundError(f"cannot append to missing artifact: {destination}")
+        self._resolve_generation_resources()
+        if correlators is not None:
+            from pyamplicol.generation.correlated import generate_correlated
+
+            return generate_correlated(
+                process_set,
+                destination,
+                model=model,
+                mode=mode,
+                config=self._config,
+                progress=self._progress,
+                declarations=correlators,
+            )
+        result = self._implementation().generate(
+            process_set, destination, model=model, mode=mode
+        )
+        if not isinstance(result, GenerationResult):
+            raise GenerationError(
+                "generator backend returned an invalid GenerationResult"
+            )
+        return result
+
+
+class Runtime:
+    """Typed Python facade for one process in a generated Rusticol artifact."""
+
+    def __init__(self, backend: RuntimeBackend) -> None:
+        if not isinstance(backend, RuntimeBackend):
+            raise TypeError("Runtime backend does not implement RuntimeBackend")
+        self._backend = backend
+
+    @classmethod
+    def load(
+        cls,
+        artifact: os.PathLike[str] | str,
+        *,
+        process: str | None = None,
+        model_parameters: ModelParameters | None = None,
+        mute_warnings: bool = False,
+    ) -> Runtime:
+        """Load one process by stable ID, alias ID, or exact expression.
+
+        ``model_parameters`` is applied atomically before the runtime is
+        returned. Omit ``process`` only for a single-process artifact or to use
+        the artifact's declared default.
+        """
+
+        path = Path(os.fspath(artifact)).expanduser().resolve(strict=False)
+        parameters = dict(model_parameters) if model_parameters is not None else None
+        backend = _get_runtime_loader()(
+            path,
+            process=process,
+            model_parameters=parameters,
+            mute_warnings=mute_warnings,
+        )
+        return backend if isinstance(backend, cls) else cls(backend)
+
+    @property
+    def physics(self) -> ProcessPhysics:
+        """Return the complete public process metadata.
+
+        On-the-fly runtimes materialize their compact helicity and color-flow
+        axes on first access and retain that compatibility view for the life of
+        the runtime. Use :meth:`inspect` for compact high-multiplicity runtime
+        metadata and cache-state observation.
+        """
+
+        result = self._backend.physics
+        if not isinstance(result, ProcessPhysics):
+            raise EvaluationError("runtime backend returned invalid process physics")
+        return result
+
+    @property
+    def artifact_id(self) -> str:
+        """Identity of the artifact manifest authenticated by the native loader."""
+
+        try:
+            value = getattr(self._backend, "artifact_id", None)
+        except ArtifactError as error:
+            raise EvaluationError(
+                "runtime backend does not expose an authenticated artifact identity"
+            ) from error
+        if (
+            not isinstance(value, str)
+            or len(value) != 64
+            or value != value.lower()
+            or any(character not in "0123456789abcdef" for character in value)
+        ):
+            raise EvaluationError(
+                "runtime backend does not expose an authenticated artifact identity"
+            )
+        return value
+
+    @property
+    def execution_mode(
+        self,
+    ) -> Literal["compiled", "eager", "recurrence", "on-the-fly"]:
+        """Native execution lane authenticated while loading the artifact."""
+
+        value = getattr(self._backend, "execution_mode", None)
+        if value not in {"compiled", "eager", "recurrence", "on-the-fly"}:
+            raise EvaluationError(
+                "runtime backend does not expose a valid execution mode"
+            )
+        return cast(Literal["compiled", "eager", "recurrence", "on-the-fly"], value)
+
+    def inspect(self) -> Mapping[str, object]:
+        """Return compact authenticated runtime metadata and live cache state.
+
+        This optional facade capability does not form part of the minimum
+        :class:`RuntimeBackend` protocol. The built-in backend implements it
+        without opening dense process physics.
+        """
+
+        operation = getattr(self._backend, "inspect", None)
+        if not callable(operation):
+            raise CompatibilityError(
+                "runtime backend does not expose compact runtime inspection"
+            )
+        result = operation()
+        if not isinstance(result, Mapping):
+            raise EvaluationError("runtime backend returned invalid runtime inspection")
+        return dict(result)
+
+    def save(self, path: os.PathLike[str] | str) -> None:
+        """Save the retained on-the-fly recursion after completed evaluations.
+
+        This saves structural warm-up work, not momenta, evaluated matrix
+        elements, or model-parameter values. Load the same process normally,
+        then use :meth:`load_cache` to restore it. Only the currently retained
+        selector family is saved; other selectors keep their usual cold path.
+        """
+
+        operation = getattr(self._backend, "save", None)
+        if not callable(operation):
+            raise CompatibilityError(
+                "runtime backend does not support saving on-the-fly caches"
+            )
+        operation(Path(os.fspath(path)).expanduser().resolve(strict=False))
+
+    def load_cache(self, path: os.PathLike[str] | str) -> None:
+        """Restore a saved on-the-fly recursion into the same loaded process.
+
+        The current model parameters remain unchanged. A failed restore leaves
+        the existing cache intact. Restoring does not specialize the process:
+        new momenta, batch sizes and selector families remain supported.
+        """
+
+        operation = getattr(self._backend, "load_cache", None)
+        if not callable(operation):
+            raise CompatibilityError(
+                "runtime backend does not support restoring on-the-fly caches"
+            )
+        operation(Path(os.fspath(path)).expanduser().resolve(strict=False))
+
+    def evaluate(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str | HelicityConfiguration] | None = None,
+        color_flows: Sequence[str | ColorFlow] | None = None,
+        helicity_by_point: Sequence[str | HelicityConfiguration] | None = None,
+        color_flow_by_point: Sequence[str | ColorFlow] | None = None,
+        precision: int = 16,
+    ) -> tuple[complex | Decimal, ...]:
+        """Return one fully summed matrix element for every input point.
+
+        Selectors accept stable string IDs or the typed objects exposed by
+        :attr:`physics`. Precision 16 uses the native f64 path; larger values
+        use the retained high-precision evaluator state when available.
+        """
+
+        helicity_ids = _selector_ids(
+            helicities,
+            expected_type=HelicityConfiguration,
+            name="helicity",
+        )
+        color_ids = _selector_ids(
+            color_flows,
+            expected_type=ColorFlow,
+            name="color-flow",
+        )
+        point_helicity_ids = _point_selector_ids(
+            helicity_by_point,
+            expected_type=HelicityConfiguration,
+            name="per-point helicity",
+        )
+        point_color_ids = _point_selector_ids(
+            color_flow_by_point,
+            expected_type=ColorFlow,
+            name="per-point color-flow",
+        )
+        if helicity_ids is not None and point_helicity_ids is not None:
+            raise ValueError("helicities and helicity_by_point are mutually exclusive")
+        if color_ids is not None and point_color_ids is not None:
+            raise ValueError(
+                "color_flows and color_flow_by_point are mutually exclusive"
+            )
+        precision = _validate_precision(precision)
+        if point_helicity_ids is None and point_color_ids is None:
+            values = self._backend.evaluate(
+                momenta,
+                helicities=helicity_ids,
+                color_flows=color_ids,
+                precision=precision,
+            )
+        else:
+            operation = self._backend.evaluate
+            if not _accepts_keyword_arguments(
+                operation,
+                "helicity_by_point",
+                "color_flow_by_point",
+            ):
+                raise EvaluationError(
+                    "runtime backend does not support per-point helicity/color-flow "
+                    "selectors; use batch-global selectors or install a "
+                    "selector-capable backend"
+                )
+            values = cast(Any, operation)(
+                momenta,
+                helicities=helicity_ids,
+                color_flows=color_ids,
+                helicity_by_point=point_helicity_ids,
+                color_flow_by_point=point_color_ids,
+                precision=precision,
+            )
+        return tuple(
+            value if isinstance(value, Decimal) else complex(value) for value in values
+        )
+
+    def warm_up(
+        self,
+        momenta: Momenta,
+        *,
+        precision: int = 16,
+        helicities: Sequence[str | HelicityConfiguration] | None = None,
+        color_flows: Sequence[str | ColorFlow] | None = None,
+        progress: ProgressSink | None = None,
+        n_cores: int | None = None,
+    ) -> WarmUpResult:
+        """Warm one on-the-fly selector family using exactly one f64 point.
+
+        This is an explicit structural warm-up, not a throughput evaluation:
+        batches and high-precision execution are intentionally rejected. LC
+        accepts the same helicity and color-flow selectors as :meth:`evaluate`;
+        contracted NLC/full execution accepts only helicity selectors.
+        ``n_cores`` overrides the process's query-construction worker count for
+        this call only; omitted, it uses the generation-time setting. Changing
+        the count neither discards a warm family nor changes evaluation threads.
+        """
+
+        if n_cores is not None:
+            if isinstance(n_cores, bool) or not isinstance(n_cores, int):
+                raise TypeError("n_cores must be a positive integer or None")
+            if n_cores < 1:
+                raise ValueError("n_cores must be a positive integer or None")
+        try:
+            point_count = len(momenta)
+        except TypeError as exc:
+            raise TypeError("warm_up momenta must be a sized sequence") from exc
+        if point_count != 1:
+            raise ValueError(
+                "warm_up requires exactly one phase-space point; "
+                f"received {point_count}"
+            )
+        precision = _validate_precision(precision)
+        if precision != 16:
+            raise CompatibilityError(
+                "on-the-fly warm_up supports only precision=16 (native f64); "
+                f"received precision={precision}"
+            )
+        _validate_progress(progress)
+        if self.execution_mode != "on-the-fly":
+            raise CompatibilityError(
+                "warm_up is available only for on-the-fly runtimes"
+            )
+        operation = getattr(self._backend, "warm_up", None)
+        if not callable(operation):
+            raise CompatibilityError(
+                "installed on-the-fly runtime does not expose explicit warm-up; "
+                "reinstall pyAmpliCol from the current source revision"
+            )
+        result = operation(
+            momenta,
+            helicities=_selector_ids(
+                helicities,
+                expected_type=HelicityConfiguration,
+                name="helicity",
+            ),
+            color_flows=_selector_ids(
+                color_flows,
+                expected_type=ColorFlow,
+                name="color-flow",
+            ),
+            precision=precision,
+            progress=progress,
+            n_cores=n_cores,
+        )
+        if not isinstance(result, WarmUpResult):
+            raise EvaluationError("runtime backend returned an invalid WarmUpResult")
+        return result
+
+    def evaluate_with_prec(
+        self,
+        momenta: Momenta,
+        precision: int,
+        *,
+        helicities: Sequence[str | HelicityConfiguration] | None = None,
+        color_flows: Sequence[str | ColorFlow] | None = None,
+    ) -> tuple[complex | Decimal, ...]:
+        return self.evaluate(
+            momenta,
+            helicities=helicities,
+            color_flows=color_flows,
+            precision=precision,
+        )
+
+    def evaluate_resolved(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str | HelicityConfiguration] | None = None,
+        color_flows: Sequence[str | ColorFlow] | None = None,
+        precision: int = 16,
+    ) -> ResolvedEvaluation:
+        """Return physical values resolved by helicity and color component.
+
+        LC output has shape ``(point, helicity, color_flow)``. NLC/full output
+        has shape ``(point, helicity, 1)`` because color is already contracted.
+        Summing the non-point axes reproduces :meth:`evaluate`.
+        """
+
+        precision = _validate_precision(precision)
+        result = self._backend.evaluate_resolved(
+            momenta,
+            helicities=_selector_ids(
+                helicities,
+                expected_type=HelicityConfiguration,
+                name="helicity",
+            ),
+            color_flows=_selector_ids(
+                color_flows,
+                expected_type=ColorFlow,
+                name="color-flow",
+            ),
+            precision=precision,
+        )
+        if not isinstance(result, ResolvedEvaluation):
+            raise EvaluationError(
+                "runtime backend returned an invalid ResolvedEvaluation"
+            )
+        return result
+
+    def evaluate_resolved_with_prec(
+        self,
+        momenta: Momenta,
+        precision: int,
+        *,
+        helicities: Sequence[str | HelicityConfiguration] | None = None,
+        color_flows: Sequence[str | ColorFlow] | None = None,
+    ) -> ResolvedEvaluation:
+        return self.evaluate_resolved(
+            momenta,
+            helicities=helicities,
+            color_flows=color_flows,
+            precision=precision,
+        )
+
+    def _diagnostic_project_onshell(
+        self,
+        momenta: Momenta,
+        *,
+        precision: int,
+    ) -> tuple[object, Mapping[str, object]]:
+        """Forward the private report-only kinematic projection capability."""
+
+        precision = _validate_precision(precision)
+        operation = getattr(self._backend, "_diagnostic_project_onshell", None)
+        if not callable(operation):
+            raise EvaluationError(
+                "runtime backend does not support diagnostic on-shell projection"
+            )
+        result = operation(momenta, precision=precision)
+        if (
+            not isinstance(result, tuple)
+            or len(result) != 2
+            or not isinstance(result[1], Mapping)
+        ):
+            raise EvaluationError(
+                "runtime backend returned an invalid diagnostic on-shell projection"
+            )
+        return result[0], dict(result[1])
+
+    def set_model_parameters(self, mapping: ModelParameters) -> None:
+        """Validate and atomically apply a batch of runtime model parameters."""
+
+        self._backend.set_model_parameters(dict(mapping))
+
+    def _correlator_catalogue(self) -> CorrelatorCatalogue:
+        catalogue: CorrelatorCatalogue | None = getattr(
+            self, "_correlated_catalogue", None
+        )
+        if catalogue is None:
+            from pyamplicol.runtime.correlations import load_correlator_catalogue
+
+            catalogue = load_correlator_catalogue(self._backend)
+            self._correlated_catalogue = catalogue
+        return catalogue
+
+    def available_color_correlations(self) -> tuple[_pyamplicol.ColorCorrelator, ...]:
+        """List this process's resolved operators, including ``"born"``.
+
+        Reads the declared catalogue without loading an amplitude executor.
+        Each returned record contains its runtime ID and ordered bra/ket steps.
+        """
+        return self._correlator_catalogue().declarations.color_requests
+
+    def _correlator_evaluator(self) -> CorrelatorEvaluator:
+        evaluator: CorrelatorEvaluator | None = getattr(
+            self, "_correlated_evaluator", None
+        )
+        if evaluator is None:
+            from pyamplicol.runtime.correlations import CorrelatorEvaluator
+
+            evaluator = CorrelatorEvaluator(
+                self._backend, catalogue=self._correlator_catalogue()
+            )
+            self._correlated_evaluator = evaluator
+        return evaluator
+
+    def set_spin_correlation_vectors(
+        self, vectors: Mapping[int, object] | None
+    ) -> None:
+        """Replace declared spin-1 sources by literal complex four-vectors.
+
+        Keys are public one-based leg labels. A value is either ``(E,x,y,z)``
+        or one such vector per phase-space point. The set of keys must match a
+        spin class declared at generation. ``None`` or ``{}`` restores ordinary
+        helicity states. Vectors are neither normalized nor projected.
+        Real components accept Decimal; a ``(real, imaginary)`` Decimal pair
+        represents a complex component without a binary64 conversion.
+        This affects the correlated evaluation methods, not :meth:`evaluate`.
+        """
+        self._correlator_evaluator().set_spin_correlation_vectors(vectors)
+
+    def evaluate_correlated(
+        self,
+        momenta: Momenta,
+        *,
+        color_correlation: str = "born",
+        helicities: Sequence[str | HelicityConfiguration] | None = None,
+        precision: int = 16,
+        arithmetic: str = "arbitrary",
+    ) -> tuple[_pyamplicol.CorrelatedValue, ...]:
+        """Evaluate a generation-time colour ID with the current spin vectors.
+
+        Returns one complex decimal value per point. ``"born"`` selects the
+        Born metric at the declared colour accuracy. All ordinary normalization
+        factors remain in place; a replaced spin leg is counted once in the
+        helicity sum.
+
+        ``arithmetic="double-double"`` selects genuine DoubleFloat arithmetic
+        (at most 31 output digits); the default uses arbitrary precision.
+        Decimal spin inputs (including complex-component pairs) retain their
+        digits until conversion into the requested arithmetic.
+        """
+        return self._correlator_evaluator().evaluate(
+            momenta,
+            color_correlation=color_correlation,
+            helicities=_selector_ids(
+                helicities, expected_type=HelicityConfiguration, name="helicity"
+            ),
+            precision=_validate_precision(precision),
+            arithmetic=arithmetic,
+        )
+
+    def evaluate_correlated_many(
+        self,
+        momenta: Momenta,
+        requests: Mapping[str, _pyamplicol.CorrelatedRequest],
+        *,
+        helicities: Sequence[str | HelicityConfiguration] | None = None,
+        precision: int = 16,
+        arithmetic: str = "arbitrary",
+    ) -> dict[str, tuple[_pyamplicol.CorrelatedValue, ...]]:
+        """Evaluate labelled colour/spin combinations over a point batch.
+
+        Equal spin assignments share amplitudes across colour IDs. Different
+        assignments may reuse stages with identical exact inputs. Numerical
+        reuse is local to this call; requests never change the spin setter.
+        ``None`` vectors inherit its initial state and ``{}`` selects physical
+        helicities. Each result tuple follows the input point order.
+        Arithmetic and Decimal spin inputs follow :meth:`evaluate_correlated`.
+        """
+        return self._correlator_evaluator().evaluate_many(
+            momenta,
+            requests,
+            helicities=_selector_ids(
+                helicities, expected_type=HelicityConfiguration, name="helicity"
+            ),
+            precision=_validate_precision(precision),
+            arithmetic=arithmetic,
+        )
+
+    def clear(self) -> None:
+        """Drop warmed execution state while keeping this artifact loaded.
+
+        An already materialized :attr:`physics` compatibility view remains
+        cached until the runtime itself is released.
+        """
+
+        self._backend.clear()
+        correlated = getattr(self, "_correlated_evaluator", None)
+        if correlated is not None:
+            correlated.clear()
+
+    @property
+    def representative_process_key(self) -> str:
+        """Stable artifact process implementing the selected public ordering."""
+
+        value = getattr(self._backend, "representative_process_key", None)
+        return value if isinstance(value, str) and value else self.physics.process_id
+
+    @property
+    def external_permutation(self) -> tuple[int, ...]:
+        """Representative-index to public-index external-leg permutation."""
+
+        value = getattr(self._backend, "external_permutation", None)
+        count_value = getattr(self._backend, "external_count", None)
+        count: int | None
+        if count_value is None:
+            count = None
+        elif (
+            isinstance(count_value, bool)
+            or not isinstance(count_value, int)
+            or count_value < 1
+        ):
+            raise CompatibilityError("runtime external process count is invalid")
+        else:
+            count = count_value
+        if value is None:
+            if count is None:
+                # Preserve the original minimum RuntimeBackend contract. The
+                # built-in backend always supplies authenticated compact
+                # metadata, while older injected backends may expose only
+                # ProcessPhysics.
+                return tuple(range(len(self.physics.external_particles)))
+            return tuple(range(count))
+        try:
+            permutation = tuple(value)
+        except TypeError as exc:
+            raise CompatibilityError(
+                "runtime external permutation must be an iterable of integers"
+            ) from exc
+        if any(
+            isinstance(index, bool) or not isinstance(index, int)
+            for index in permutation
+        ):
+            raise CompatibilityError(
+                "runtime external permutation must contain integers"
+            )
+        expected_count = (
+            len(self.physics.external_particles) if count is None else count
+        )
+        if len(permutation) != expected_count or sorted(permutation) != list(
+            range(expected_count)
+        ):
+            raise CompatibilityError("runtime external permutation is invalid")
+        return permutation
+
+    @property
+    def process_group_factor(self) -> Fraction:
+        """Exact factor relating the selected process to its representative.
+
+        A process selected through the artifact's process-group map evaluates
+        ``factor * ME_representative`` at the permuted momenta; every other
+        selection reports one.
+        """
+
+        value = getattr(self._backend, "process_group_factor", None)
+        if value is None:
+            return Fraction(1)
+        if not isinstance(value, Fraction) or value <= 0:
+            raise CompatibilityError("runtime process-group factor is invalid")
+        return value
+
+    @property
+    def charge_conjugated(self) -> bool:
+        """Whether the selection is the charge conjugate of its representative.
+
+        Its LC color-flow words are then the reversed representative words.
+        """
+
+        return getattr(self._backend, "charge_conjugated", False) is True
+
+    def set_model_parameter(self, name: str, value: complex | float | int) -> None:
+        self.set_model_parameters({name: value})
+
+    def mute_warnings(self) -> None:
+        self._backend.mute_warnings()
+
+    def unmute_warnings(self) -> None:
+        self._backend.unmute_warnings()
+
+
+class BenchmarkRunner:
+    """Profile summed process evaluation with a typed benchmark configuration."""
+
+    def __init__(
+        self,
+        config: BenchmarkConfig | RunConfig | None = None,
+        progress: ProgressSink | None = None,
+        *,
+        _chunk_guard: Callable[[float | None, str], None] | None = None,
+    ) -> None:
+        if config is not None and not isinstance(config, (BenchmarkConfig, RunConfig)):
+            raise TypeError(
+                "BenchmarkRunner config must be BenchmarkConfig, RunConfig, or null"
+            )
+        _validate_progress(progress)
+        if _chunk_guard is not None and not callable(_chunk_guard):
+            raise TypeError("BenchmarkRunner chunk guard must be callable")
+        self._config = config
+        self._progress = progress
+        self._chunk_guard = _chunk_guard
+        self._backend: BenchmarkBackend | None = None
+
+    def _implementation(self) -> BenchmarkBackend:
+        if self._backend is None:
+            self._backend = _get_benchmark_factory()(self._config, self._progress)
+            if self._chunk_guard is not None:
+                setter = getattr(self._backend, "set_chunk_guard", None)
+                if not callable(setter):
+                    raise EvaluationError(
+                        "benchmark backend does not support a profiling chunk guard"
+                    )
+                setter(self._chunk_guard)
+        return self._backend
+
+    def run(
+        self,
+        target: Runtime | os.PathLike[str] | str,
+        *,
+        points: Momenta | None = None,
+    ) -> BenchmarkResult:
+        """Profile an artifact path or an already loaded :class:`Runtime`."""
+
+        backend_target: RuntimeBackend | os.PathLike[str] | str
+        if isinstance(target, Runtime):
+            backend_target = target._backend
+        else:
+            backend_target = Path(os.fspath(target)).expanduser().resolve(strict=False)
+        result = self._implementation().run(backend_target, points=points)
+        if not isinstance(result, BenchmarkResult):
+            raise EvaluationError(
+                "benchmark backend returned an invalid BenchmarkResult"
+            )
+        return result
+
+
+def generate(
+    processes: ProcessSet | ProcessRequest | str | Iterable[ProcessRequest | str],
+    output: os.PathLike[str] | str,
+    *,
+    model: ModelSource | _pyamplicol.CompiledModel | None = None,
+    mode: Literal["error", "append", "replace"] = "error",
+    config: GenerationConfig | RunConfig | ConfigResolution | None = None,
+    progress: ProgressSink | None = None,
+    correlators: _pyamplicol.CorrelatorConfig | None = None,
+) -> GenerationResult:
+    """Generate a process artifact using a one-shot convenience function."""
+
+    return Generator(config=config, progress=progress).generate(
+        processes, output, model=model, mode=mode, correlators=correlators
+    )
+
+
+load = Runtime.load
+
+
+def benchmark(
+    target: Runtime | os.PathLike[str] | str,
+    *,
+    points: Momenta | None = None,
+    config: BenchmarkConfig | RunConfig | None = None,
+    progress: ProgressSink | None = None,
+) -> BenchmarkResult:
+    """Profile a generated artifact using a one-shot convenience function."""
+
+    return BenchmarkRunner(config=config, progress=progress).run(target, points=points)
+
+
+__all__ = [
+    "BenchmarkRunner",
+    "Generator",
+    "Runtime",
+    "benchmark",
+    "generate",
+    "install_backend_factories",
+    "load",
+]
diff --git a/pyamplicol/src/pyamplicol/artifacts/__init__.py b/pyamplicol/src/pyamplicol/artifacts/__init__.py
new file mode 100644
index 0000000000..ccb104888a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/__init__.py
@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: 0BSD
+"""Schema-v3 process artifact services."""
+
+from .api_bundle import emit_api_bundle
+from .inspection import (
+    ArtifactAliasInspection,
+    ArtifactDependencyInspection,
+    ArtifactInspection,
+    ArtifactProcessInspection,
+    inspect_artifact,
+)
+from .manifest import (
+    MANIFEST_NAME,
+    ArtifactManifest,
+    PayloadRecord,
+    compute_artifact_id,
+    load_manifest,
+    validate_payloads,
+)
+from .security import confined_path, normalize_relative_path, sha256_file
+from .transaction import ArtifactTransaction, ArtifactWriteMode
+from .writer import ArtifactBuilder
+
+__all__ = [
+    "MANIFEST_NAME",
+    "ArtifactAliasInspection",
+    "ArtifactBuilder",
+    "ArtifactDependencyInspection",
+    "ArtifactInspection",
+    "ArtifactManifest",
+    "ArtifactProcessInspection",
+    "ArtifactTransaction",
+    "ArtifactWriteMode",
+    "PayloadRecord",
+    "compute_artifact_id",
+    "confined_path",
+    "emit_api_bundle",
+    "inspect_artifact",
+    "load_manifest",
+    "normalize_relative_path",
+    "sha256_file",
+    "validate_payloads",
+]
diff --git a/pyamplicol/src/pyamplicol/artifacts/api_bundle.py b/pyamplicol/src/pyamplicol/artifacts/api_bundle.py
new file mode 100644
index 0000000000..f70b997b95
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/api_bundle.py
@@ -0,0 +1,171 @@
+# SPDX-License-Identifier: 0BSD
+"""Emit the wheel-independent API examples bundled with process artifacts."""
+
+from __future__ import annotations
+
+import importlib.resources
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from decimal import Decimal
+
+from .manifest import PayloadRecord
+from .writer import ArtifactBuilder
+
+Scalar = float | int | str | Decimal
+ValidationPoint = Sequence[Sequence[Scalar]]
+
+_TEMPLATES: tuple[tuple[str, str, str, bool], ...] = (
+    (
+        "python/check_standalone.py",
+        "text/x-python",
+        "api-source",
+        True,
+    ),
+    (
+        "c/check_standalone.c",
+        "text/x-csrc",
+        "api-source",
+        False,
+    ),
+    ("c/Makefile", "text/x-makefile", "api-build-file", False),
+    (
+        "cpp/check_standalone.cpp",
+        "text/x-c++src",
+        "api-source",
+        False,
+    ),
+    ("cpp/Makefile", "text/x-makefile", "api-build-file", False),
+    (
+        "fortran/check_standalone.f90",
+        "text/x-fortran",
+        "api-source",
+        False,
+    ),
+    ("fortran/Makefile", "text/x-makefile", "api-build-file", False),
+    (
+        "rust/check_standalone.rs",
+        "text/x-rust",
+        "api-source",
+        False,
+    ),
+    ("rust/Makefile", "text/x-makefile", "api-build-file", False),
+    ("umami/Makefile", "text/x-makefile", "api-build-file", False),
+    ("umami/umami.h", "text/x-chdr", "api-source", False),
+    ("umami/umami_provider.h", "text/x-chdr", "api-source", False),
+    ("umami/umami.c", "text/x-csrc", "api-source", False),
+    ("umami/umami_driver.c", "text/x-csrc", "api-source", False),
+    ("umami/umami.exports", "text/plain", "api-build-file", False),
+    ("umami/umami.exports.macos", "text/plain", "api-build-file", False),
+    ("umami/UMAMI_LICENSE", "text/plain", "sdk-metadata", False),
+    ("umami/README.md", "text/markdown", "sdk-metadata", False),
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ApiBundlePayload:
+    path: str
+    content: bytes
+    role: str
+    media_type: str
+    executable: bool = False
+
+
+def _template_bytes(relative: str) -> bytes:
+    root = importlib.resources.files("pyamplicol.assets.api_templates")
+    resource = root.joinpath(*relative.split("/"))
+    if not resource.is_file():
+        raise RuntimeError(f"packaged API template is missing: {relative}")
+    return resource.read_bytes()
+
+
+def _scalar_text(value: Scalar) -> str:
+    if isinstance(value, bool):
+        raise TypeError("validation momenta must not contain booleans")
+    if isinstance(value, Decimal):
+        if not value.is_finite():
+            raise ValueError("validation momenta must be finite")
+        return str(value)
+    if isinstance(value, str):
+        parsed = Decimal(value)
+        if not parsed.is_finite():
+            raise ValueError("validation momenta must be finite")
+        return value
+    numeric = float(value)
+    if not math.isfinite(numeric):
+        raise ValueError("validation momenta must be finite")
+    return format(numeric, ".17g")
+
+
+def format_validation_points(
+    points: Mapping[str, ValidationPoint],
+) -> bytes:
+    """Serialize deterministic f64-compatible points in a language-neutral format."""
+
+    lines = ["RUSTICOL_VALIDATION_POINTS_V1"]
+    for process_id in sorted(points):
+        if not process_id or any(character.isspace() for character in process_id):
+            raise ValueError("validation-point process IDs must be non-empty tokens")
+        momenta = tuple(tuple(momentum) for momentum in points[process_id])
+        if not momenta:
+            raise ValueError(f"validation point for {process_id!r} is empty")
+        if any(len(momentum) != 4 for momentum in momenta):
+            raise ValueError(
+                f"validation point for {process_id!r} must use four-vectors"
+            )
+        components = [
+            _scalar_text(component) for momentum in momenta for component in momentum
+        ]
+        lines.append("\t".join((process_id, str(len(momenta)), *components)))
+    return ("\n".join(lines) + "\n").encode("ascii")
+
+
+def api_bundle_payloads(
+    validation_points: Mapping[str, ValidationPoint] | None = None,
+) -> tuple[ApiBundlePayload, ...]:
+    payloads = [
+        ApiBundlePayload(
+            path=f"API/{relative}",
+            content=_template_bytes(relative),
+            role=role,
+            media_type=media_type,
+            executable=executable,
+        )
+        for relative, media_type, role, executable in _TEMPLATES
+    ]
+    payloads.append(
+        ApiBundlePayload(
+            path="API/validation_points.dat",
+            content=format_validation_points(validation_points or {}),
+            role="validation-momenta",
+            media_type="text/tab-separated-values",
+        )
+    )
+    return tuple(payloads)
+
+
+def emit_api_bundle(
+    builder: ArtifactBuilder,
+    validation_points: Mapping[str, ValidationPoint] | None = None,
+) -> tuple[PayloadRecord, ...]:
+    """Write exactly one root API bundle through an active artifact builder."""
+
+    return tuple(
+        builder.add_bytes(
+            payload.path,
+            payload.content,
+            role=payload.role,
+            media_type=payload.media_type,
+            executable=payload.executable,
+        )
+        for payload in api_bundle_payloads(validation_points)
+    )
+
+
+__all__ = [
+    "ApiBundlePayload",
+    "ValidationPoint",
+    "api_bundle_payloads",
+    "emit_api_bundle",
+    "format_validation_points",
+]
diff --git a/pyamplicol/src/pyamplicol/artifacts/inspection.py b/pyamplicol/src/pyamplicol/artifacts/inspection.py
new file mode 100644
index 0000000000..242348fb64
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/inspection.py
@@ -0,0 +1,3252 @@
+# SPDX-License-Identifier: 0BSD
+"""Read-only summaries of generated process artifacts."""
+
+from __future__ import annotations
+
+import json
+import math
+import struct
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, cast
+
+from pyamplicol._internal.versions import (
+    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_RUNTIME_CAPABILITY,
+    RECURRENCE_BUILDER_INPUT_ABI,
+    RECURRENCE_COLOR_RUNTIME_CAPABILITY,
+    RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+    RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    RECURRENCE_DIRECT_BACKEND_ABI,
+    RECURRENCE_DIRECT_TEMPLATE_ABI,
+    RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+    RECURRENCE_PLAN_ABI,
+    RECURRENCE_RUNTIME_LAYOUT_ABI,
+    SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+)
+from pyamplicol.api.errors import ArtifactError
+from pyamplicol.generation.process_grouping import GroupMember, ProcessGroupMap
+
+from .manifest import MANIFEST_NAME, ArtifactManifest, load_manifest
+from .process_groups import initial_process_groups, read_process_groups
+from .security import confined_path, normalize_relative_path
+
+_EAGER_RUNTIME_KIND = "pyamplicol-runtime-eager-execution"
+_RECURRENCE_RUNTIME_KIND = "pyamplicol-runtime-recurrence-execution"
+_ON_THE_FLY_RUNTIME_KIND = "pyamplicol-runtime-on-the-fly-execution"
+_ON_THE_FLY_PUBLIC_METADATA_KIND = "pyamplicol-on-the-fly-public-metadata"
+_RETIRED_RECURRENCE_RUNTIME_CAPABILITY = "rusticol.recurrence-runtime.complex-f64.v1"
+_RECURRENCE_DIRECT_SCHEDULE_MEMBER_PATH = "schedule/recurrence-direct-schedule-v2.bin"
+_RECURRENCE_COLOR_CONTRACTION_CODEC_ABI = "pyamplicol-recurrence-color-contraction-v3"
+_EAGER_PLAN_V3_ABI = "pyamplicol-eager-plan-v3"
+_EAGER_RUNTIME_CAPABILITIES = frozenset(
+    {
+        EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        "rusticol.eager-dag.complex-f64.v1",
+        "rusticol.eager-runtime-layout.complex-f64.v1",
+    }
+)
+_MISSING_U32 = (1 << 32) - 1
+_EAGER_INVOCATION = struct.Struct("<IIIIIIIQQ")
+_EAGER_FINALIZATION = struct.Struct("<IIIII")
+_EAGER_CLOSURE = struct.Struct("<IIIIIIdd")
+_EAGER_SELECTOR_DOMAINS_ABI = "pyamplicol-eager-selector-domains-v1"
+_EAGER_SELECTOR_DOMAIN = struct.Struct("<QQ")
+_EAGER_SELECTOR_GROUP = struct.Struct("<I")
+_EAGER_SELECTOR_DOMAIN_ID = struct.Struct("<I")
+_COMPILED_PROFILE_PHASES = (
+    "source-fill",
+    "momentum-setup",
+    "stage-input-pack",
+    "stage-evaluator-call",
+    "output-assign",
+    "amplitude-input-pack",
+    "amplitude-evaluator-call",
+    "reduction",
+)
+_EAGER_PROFILE_PHASES = (
+    "source-fill",
+    "momentum-setup",
+    "eager-execution-aggregate",
+)
+_RECURRENCE_PROFILE_PHASES = (
+    "selector-plan",
+    "source-fill",
+    "momentum-form-fill",
+    "recurrence-direct-contribution",
+    "recurrence-direct-finalization",
+    "recurrence-direct-closure",
+    "reduction",
+)
+# The compact lane feeds the same direct-profile counters from its dynamically
+# prepared query family; only the plan materialization boundary differs.
+_ON_THE_FLY_PROFILE_PHASES = _RECURRENCE_PROFILE_PHASES
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactAliasInspection:
+    id: str
+    expression: str
+    representative_id: str
+    external_pdgs: tuple[int, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactProcessInspection:
+    id: str
+    expression: str
+    color_accuracy: str
+    external_pdgs: tuple[int, ...]
+    default: bool
+    physical_helicities: int
+    computed_helicities: int
+    physical_color_components: int
+    computed_color_components: int
+    helicity_coverage: str
+    color_coverage: str
+    aliases: tuple[ArtifactAliasInspection, ...]
+    selector_provenance: str | None = None
+    helicity_runtime_contract: str | None = None
+    color_flow_runtime_contract: str | None = None
+    generation_specialized_axes: tuple[str, ...] = ()
+    selected_source_helicities: tuple[tuple[int, int], ...] = ()
+    selected_color_sector_ids: tuple[int, ...] = ()
+    helicity_recurrence_status: str | None = None
+    helicity_optimized_class_count: int | None = None
+    helicity_optimized_current_count: int | None = None
+    helicity_residual_current_count: int | None = None
+    helicity_optimized_amplitude_class_count: int | None = None
+    helicity_residual_amplitude_count: int | None = None
+    helicity_materialized_current_count: int | None = None
+    helicity_materialized_amplitude_count: int | None = None
+    lc_physical_sector_count: int | None = None
+    lc_materialized_sector_count: int | None = None
+    lc_replayed_sector_count: int | None = None
+    lc_residual_sector_count: int | None = None
+    lc_flow_layout: str | None = None
+    lc_union_sector_count: int | None = None
+    execution_mode: str = "compiled"
+    prepared_backend: str | None = None
+    prepared_kernel_count: int | None = None
+    referenced_kernel_count: int | None = None
+    invocation_count: int | None = None
+    attachment_count: int | None = None
+    evaluation_alias_count: int | None = None
+    maximum_fanout: int | None = None
+    finalization_count: int | None = None
+    closure_count: int | None = None
+    selector_closure_available: bool = False
+    selector_domain_count: int | None = None
+    selector_domain_membership_count: int | None = None
+    requested_point_tile_size: int | None = None
+    effective_point_tile_size: int | None = None
+    requested_query_construction_threads: int | None = None
+    # Historical field name: this is a soft batching target, not an upper limit.
+    workspace_limit_bytes: int | None = None
+    workspace_bytes: int | None = None
+    arena_semantic_component_count: int | None = None
+    arena_component_count: int | None = None
+    arena_component_reuse_count: int | None = None
+    momentum_form_count: int | None = None
+    direct_source_row_count: int | None = None
+    direct_contribution_row_count: int | None = None
+    direct_finalization_row_count: int | None = None
+    direct_closure_row_count: int | None = None
+    direct_row_group_count: int | None = None
+    recurrence_color_accuracy: str | None = None
+    recurrence_color_storage: str | None = None
+    recurrence_color_sector_count: int | None = None
+    recurrence_color_active_sector_count: int | None = None
+    recurrence_color_component_count: int | None = None
+    recurrence_color_group_count: int | None = None
+    recurrence_color_destination_count: int | None = None
+    recurrence_color_entry_count: int | None = None
+    recurrence_color_logical_entry_count: int | None = None
+    recurrence_color_factorization_kind: str | None = None
+    recurrence_color_factorization_rank: int | None = None
+    recurrence_color_factorization_coset_count: int | None = None
+    recurrence_color_contraction_method: str | None = None
+    recurrence_color_fft_degree: int | None = None
+    recurrence_color_fft_channel_count: int | None = None
+    recurrence_color_fft_covered_local_group_count: int | None = None
+    recurrence_color_direct_residual_group_count: int | None = None
+    recurrence_color_direct_residual_entry_count: int | None = None
+    recurrence_color_raw_kernel_bytes: int | None = None
+    recurrence_color_transformed_kernel_bytes: int | None = None
+    recurrence_color_fft_capability: str | None = None
+    packed_input_bytes: int | None = None
+    packed_output_bytes: int | None = None
+    scatter_bytes: int | None = None
+    native_profile_phases: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactDependencyInspection:
+    name: str
+    version: str
+    license: str
+    source: str
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactProcessGroupMemberInspection:
+    """One subprocess of a process group and its relation to the representative.
+
+    ``ME(p) = factor * ME_representative(q)`` with ``q[r] = p[permutation[r]]``;
+    ``factor`` is the reduced fraction text, such as ``"1"`` or ``"16/9"``.
+    """
+
+    id: str
+    process: str
+    pdgs: tuple[int, ...]
+    initial_count: int
+    factor: str
+    permutation: tuple[int, ...]
+    conjugated: bool
+    basis: str
+    generated: bool
+    warning: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactProcessGroupInspection:
+    """A generated representative and its members, the representative first."""
+
+    representative_id: str
+    representative: str
+    members: tuple[ArtifactProcessGroupMemberInspection, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactProcessGroupsInspection:
+    """The artifact's process-group map, in artifact process order.
+
+    ``stored`` is false for an artifact without ``process-groups.json``, whose
+    processes are then each their own group.
+    """
+
+    stored: bool
+    groups: tuple[ArtifactProcessGroupInspection, ...]
+    analyses: tuple[Mapping[str, object], ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactProcessGroupSelection:
+    """The process-group relation of one selected process.
+
+    ``role`` is ``representative``, ``routed member`` (not generated, evaluated
+    through the representative) or ``generated member`` (related numerically,
+    evaluated by its own runtime process). ``permutation`` relates the
+    representative's legs to the selected leg order, as in a group member.
+    """
+
+    process_id: str
+    role: str
+    representative_id: str
+    representative: str
+    factor: str
+    permutation: tuple[int, ...]
+    conjugated: bool
+    basis: str
+    warning: str | None
+    group_size: int
+    routed_count: int
+    conjugated_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactInspection:
+    kind: str
+    path: Path
+    artifact_kind: str
+    artifact_id: str
+    created_utc: str
+    producer_version: str
+    target: str
+    cpu_features: tuple[str, ...]
+    model_name: str
+    model_source: str
+    model_restriction: str | None
+    default_process_id: str | None
+    runtime_engine: str
+    runtime_version: str
+    runtime_capabilities: tuple[str, ...]
+    payload_count: int
+    payload_size_bytes: int
+    integrity: str
+    processes: tuple[ArtifactProcessInspection, ...]
+    dependencies: tuple[ArtifactDependencyInspection, ...]
+    physical_file_count: int | None = None
+    evaluator_container_path: str | None = None
+    evaluator_container_abi: str | None = None
+    evaluator_container_member_count: int | None = None
+    evaluator_container_unpacked_size_bytes: int | None = None
+    process_groups: ArtifactProcessGroupsInspection | None = None
+
+
+def _mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise ArtifactError(f"{context} must be an object")
+    return value
+
+
+def _sequence(value: object, context: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} must be an array")
+    return value
+
+
+def _computed(value: object, context: str) -> bool:
+    record = _mapping(value, context)
+    if record.get("kind") == "contracted-color":
+        return True
+    computed = record.get("computed")
+    if not isinstance(computed, bool):
+        raise ArtifactError(f"{context}.computed must be a boolean")
+    return computed
+
+
+def _integer(value: object, context: str, *, minimum: int = 0) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < minimum:
+        raise ArtifactError(f"{context} must be an integer >= {minimum}")
+    return value
+
+
+def _string(value: object, context: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise ArtifactError(f"{context} must be a non-empty string")
+    return value
+
+
+def _json_mapping(path: Path, context: str) -> Mapping[str, object]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise ArtifactError(f"cannot read {context}: {exc}") from exc
+    except json.JSONDecodeError as exc:
+        raise ArtifactError(f"invalid {context}: {exc}") from exc
+    return _mapping(value, context)
+
+
+def _artifact_path(
+    manifest: ArtifactManifest,
+    relative: str | Path,
+    context: str,
+) -> Path:
+    try:
+        normalized = normalize_relative_path(Path(relative).as_posix())
+    except ArtifactError:
+        raise
+    except (TypeError, ValueError) as exc:
+        raise ArtifactError(f"{context} is not a valid artifact path") from exc
+    return confined_path(manifest.root, normalized)
+
+
+def _execution_paths(manifest: ArtifactManifest) -> Mapping[str, Path]:
+    evaluator_relative = _string(
+        manifest.runtime.get("evaluator_manifest_path"),
+        "runtime.evaluator_manifest_path",
+    )
+    evaluator_path = _artifact_path(
+        manifest,
+        evaluator_relative,
+        "runtime.evaluator_manifest_path",
+    )
+    evaluator_set = _json_mapping(evaluator_path, "runtime evaluator manifest")
+    records = _sequence(
+        evaluator_set.get("processes"),
+        "runtime evaluator manifest.processes",
+    )
+    base = Path(evaluator_relative).parent
+    result: dict[str, Path] = {}
+    for index, raw in enumerate(records):
+        record = _mapping(raw, f"runtime evaluator manifest.processes[{index}]")
+        process_id = _string(
+            record.get("process_id"),
+            f"runtime evaluator manifest.processes[{index}].process_id",
+        )
+        manifest_path = _string(
+            record.get("manifest_path"),
+            f"runtime evaluator manifest.processes[{index}].manifest_path",
+        )
+        if process_id in result:
+            raise ArtifactError(
+                f"runtime evaluator manifest repeats process {process_id!r}"
+            )
+        result[process_id] = _artifact_path(
+            manifest,
+            base / manifest_path,
+            f"runtime evaluator manifest for {process_id!r}",
+        )
+    expected = {str(process["id"]) for process in manifest.processes}
+    if set(result) != expected:
+        raise ArtifactError(
+            "runtime evaluator manifest process IDs do not match artifact processes"
+        )
+    return result
+
+
+@dataclass(frozen=True, slots=True)
+class _ExecutionInspection:
+    execution_mode: str
+    physical_helicity_count: int | None = None
+    physical_color_flow_count: int | None = None
+    prepared_backend: str | None = None
+    prepared_kernel_count: int | None = None
+    referenced_kernel_count: int | None = None
+    invocation_count: int | None = None
+    attachment_count: int | None = None
+    evaluation_alias_count: int | None = None
+    maximum_fanout: int | None = None
+    finalization_count: int | None = None
+    closure_count: int | None = None
+    selector_closure_available: bool = False
+    selector_domain_count: int | None = None
+    selector_domain_membership_count: int | None = None
+    requested_point_tile_size: int | None = None
+    effective_point_tile_size: int | None = None
+    requested_query_construction_threads: int | None = None
+    # Historical field name: this is a soft batching target, not an upper limit.
+    workspace_limit_bytes: int | None = None
+    workspace_bytes: int | None = None
+    arena_semantic_component_count: int | None = None
+    arena_component_count: int | None = None
+    arena_component_reuse_count: int | None = None
+    momentum_form_count: int | None = None
+    direct_source_row_count: int | None = None
+    direct_contribution_row_count: int | None = None
+    direct_finalization_row_count: int | None = None
+    direct_closure_row_count: int | None = None
+    direct_row_group_count: int | None = None
+    recurrence_color_accuracy: str | None = None
+    recurrence_color_storage: str | None = None
+    recurrence_color_sector_count: int | None = None
+    recurrence_color_active_sector_count: int | None = None
+    recurrence_color_component_count: int | None = None
+    recurrence_color_group_count: int | None = None
+    recurrence_color_destination_count: int | None = None
+    recurrence_color_entry_count: int | None = None
+    recurrence_color_logical_entry_count: int | None = None
+    recurrence_color_factorization_kind: str | None = None
+    recurrence_color_factorization_rank: int | None = None
+    recurrence_color_factorization_coset_count: int | None = None
+    recurrence_color_contraction_method: str | None = None
+    recurrence_color_fft_degree: int | None = None
+    recurrence_color_fft_channel_count: int | None = None
+    recurrence_color_fft_covered_local_group_count: int | None = None
+    recurrence_color_direct_residual_group_count: int | None = None
+    recurrence_color_direct_residual_entry_count: int | None = None
+    recurrence_color_raw_kernel_bytes: int | None = None
+    recurrence_color_transformed_kernel_bytes: int | None = None
+    recurrence_color_fft_capability: str | None = None
+    packed_input_bytes: int | None = None
+    packed_output_bytes: int | None = None
+    scatter_bytes: int | None = None
+    native_profile_phases: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class _PhysicsInspection:
+    physical_helicities: int
+    computed_helicities: int
+    physical_color_components: int
+    computed_color_components: int
+    helicity_coverage: str
+    color_coverage: str
+    selector_provenance: str | None = None
+    helicity_runtime_contract: str | None = None
+    color_flow_runtime_contract: str | None = None
+    generation_specialized_axes: tuple[str, ...] = ()
+    selected_source_helicities: tuple[tuple[int, int], ...] = ()
+    selected_color_sector_ids: tuple[int, ...] = ()
+    helicity_recurrence_status: str | None = None
+    helicity_optimized_class_count: int | None = None
+    helicity_optimized_current_count: int | None = None
+    helicity_residual_current_count: int | None = None
+    helicity_optimized_amplitude_class_count: int | None = None
+    helicity_residual_amplitude_count: int | None = None
+    helicity_materialized_current_count: int | None = None
+    helicity_materialized_amplitude_count: int | None = None
+    lc_physical_sector_count: int | None = None
+    lc_materialized_sector_count: int | None = None
+    lc_replayed_sector_count: int | None = None
+    lc_residual_sector_count: int | None = None
+
+
+def _table_record(
+    value: object,
+    context: str,
+) -> tuple[str, int, int]:
+    record = _mapping(value, context)
+    return (
+        _string(record.get("path"), f"{context}.path"),
+        _integer(record.get("count"), f"{context}.count"),
+        _integer(record.get("row_size"), f"{context}.row_size", minimum=1),
+    )
+
+
+def _table_rows(
+    manifest: ArtifactManifest,
+    execution_root: Path,
+    table: object,
+    layout: struct.Struct,
+    context: str,
+) -> tuple[tuple[int | float, ...], ...]:
+    relative, count, row_size = _table_record(table, context)
+    if row_size != layout.size:
+        raise ArtifactError(f"{context}.row_size is {row_size}, expected {layout.size}")
+    path = _artifact_path(
+        manifest,
+        execution_root.relative_to(manifest.root) / relative,
+        f"{context}.path",
+    )
+    try:
+        payload = path.read_bytes()
+    except OSError as exc:
+        raise ArtifactError(f"cannot read {context} payload: {exc}") from exc
+    expected_size = count * row_size
+    if len(payload) != expected_size:
+        raise ArtifactError(
+            f"{context} declares {count} rows but has {len(payload)} bytes"
+        )
+    return cast(
+        tuple[tuple[int | float, ...], ...],
+        tuple(tuple(row) for row in layout.iter_unpack(payload)),
+    )
+
+
+def _optional_positive_integer(
+    value: object,
+    context: str,
+) -> int | None:
+    if value is None:
+        return None
+    return _integer(value, context, minimum=1)
+
+
+def _profile_phases(execution: Mapping[str, object]) -> tuple[str, ...]:
+    raw = execution.get("native_profile_phases")
+    if raw is None:
+        return _EAGER_PROFILE_PHASES
+    phases = tuple(
+        _string(value, f"execution.native_profile_phases[{index}]")
+        for index, value in enumerate(_sequence(raw, "execution.native_profile_phases"))
+    )
+    if len(phases) != len(set(phases)):
+        raise ArtifactError("execution.native_profile_phases contains duplicates")
+    return phases
+
+
+def _selector_domain_ids(
+    manifest: ArtifactManifest,
+    execution_root: Path,
+    table: object,
+    *,
+    expected_count: int,
+    domain_count: int,
+    context: str,
+) -> tuple[int, ...]:
+    rows = _table_rows(
+        manifest,
+        execution_root,
+        table,
+        _EAGER_SELECTOR_DOMAIN_ID,
+        context,
+    )
+    if len(rows) != expected_count:
+        raise ArtifactError(
+            f"{context} has {len(rows)} rows, expected {expected_count}"
+        )
+    result = tuple(int(row[0]) for row in rows)
+    invalid = next((value for value in result if value >= domain_count), None)
+    if invalid is not None:
+        raise ArtifactError(f"{context} references unknown domain {invalid}")
+    return result
+
+
+def _selector_domain_inspection(
+    manifest: ArtifactManifest,
+    execution: Mapping[str, object],
+    execution_root: Path,
+    selector_closures: object,
+    *,
+    stages: Sequence[
+        tuple[
+            Mapping[str, object],
+            tuple[tuple[int | float, ...], ...],
+            int,
+            tuple[tuple[int | float, ...], ...],
+        ]
+    ],
+    closures: tuple[tuple[int | float, ...], ...],
+) -> tuple[int, int]:
+    selector = _mapping(
+        selector_closures,
+        "eager execution.plan.selector_closures",
+    )
+    abi = _string(
+        selector.get("abi"),
+        "eager execution.plan.selector_closures.abi",
+    )
+    if abi != _EAGER_SELECTOR_DOMAINS_ABI:
+        raise ArtifactError(f"unsupported eager selector-domain ABI {abi!r}")
+
+    domain_rows = _table_rows(
+        manifest,
+        execution_root,
+        selector.get("domains"),
+        _EAGER_SELECTOR_DOMAIN,
+        "eager execution.plan.selector_closures.domains",
+    )
+    group_rows = _table_rows(
+        manifest,
+        execution_root,
+        selector.get("domain_group_ids"),
+        _EAGER_SELECTOR_GROUP,
+        "eager execution.plan.selector_closures.domain_group_ids",
+    )
+    memberships: list[frozenset[int]] = []
+    cursor = 0
+    for domain_id, row in enumerate(domain_rows):
+        start, count = int(row[0]), int(row[1])
+        if start != cursor:
+            raise ArtifactError(
+                f"eager selector domain {domain_id} starts at {start}, "
+                f"expected {cursor}"
+            )
+        stop = start + count
+        if stop > len(group_rows):
+            raise ArtifactError(
+                f"eager selector domain {domain_id} exceeds its membership table"
+            )
+        members = tuple(int(member[0]) for member in group_rows[start:stop])
+        if members != tuple(sorted(set(members))):
+            raise ArtifactError(
+                f"eager selector domain {domain_id} members are not unique and sorted"
+            )
+        memberships.append(frozenset(members))
+        cursor = stop
+    if cursor != len(group_rows):
+        raise ArtifactError(
+            "eager selector domains do not cover their membership table"
+        )
+    if len(memberships) != len(set(memberships)):
+        raise ArtifactError("eager selector domains contain duplicate memberships")
+
+    runtime_schema = _mapping(
+        execution.get("runtime_schema"), "eager execution.runtime_schema"
+    )
+    amplitude_stage = _mapping(
+        runtime_schema.get("amplitude_stage"),
+        "eager execution.runtime_schema.amplitude_stage",
+    )
+    roots = _sequence(
+        amplitude_stage.get("roots"),
+        "eager execution.runtime_schema.amplitude_stage.roots",
+    )
+    groups_by_output: dict[int, int] = {}
+    for index, raw_root in enumerate(roots):
+        root = _mapping(
+            raw_root,
+            f"eager execution.runtime_schema.amplitude_stage.roots[{index}]",
+        )
+        output_index = _integer(
+            root.get("output_index"),
+            f"eager execution.runtime_schema.amplitude_stage.roots[{index}]"
+            ".output_index",
+        )
+        group_id = _integer(
+            root.get("coherent_group_id"),
+            f"eager execution.runtime_schema.amplitude_stage.roots[{index}]"
+            ".coherent_group_id",
+        )
+        if output_index in groups_by_output:
+            raise ArtifactError(
+                f"eager amplitude roots repeat output index {output_index}"
+            )
+        groups_by_output[output_index] = group_id
+
+    declared_groups = set(groups_by_output.values())
+    unknown_groups = (
+        set().union(*memberships) - declared_groups if memberships else set()
+    )
+    if unknown_groups:
+        rendered = ", ".join(str(value) for value in sorted(unknown_groups))
+        raise ArtifactError(
+            f"eager selector domains reference undeclared coherent groups: {rendered}"
+        )
+
+    selector_stages = _sequence(
+        selector.get("stages"),
+        "eager execution.plan.selector_closures.stages",
+    )
+    if len(selector_stages) != len(stages):
+        raise ArtifactError("eager selector domains do not cover every stage")
+    domain_count = len(memberships)
+    for index, (raw_selector_stage, execution_stage) in enumerate(
+        zip(selector_stages, stages, strict=True)
+    ):
+        selector_stage = _mapping(
+            raw_selector_stage,
+            f"eager execution.plan.selector_closures.stages[{index}]",
+        )
+        stage, invocations, attachment_count, finalizations = execution_stage
+        stage_index = _integer(
+            stage.get("stage_index"),
+            f"eager execution.plan.stages[{index}].stage_index",
+        )
+        selector_stage_index = _integer(
+            selector_stage.get("stage_index"),
+            f"eager execution.plan.selector_closures.stages[{index}].stage_index",
+        )
+        if selector_stage_index != stage_index:
+            raise ArtifactError("eager selector-domain stage index mismatch")
+        invocation_domains = _selector_domain_ids(
+            manifest,
+            execution_root,
+            selector_stage.get("invocation_domains"),
+            expected_count=len(invocations),
+            domain_count=domain_count,
+            context=(
+                f"eager execution.plan.selector_closures.stages[{index}]"
+                ".invocation_domains"
+            ),
+        )
+        attachment_domains = _selector_domain_ids(
+            manifest,
+            execution_root,
+            selector_stage.get("attachment_domains"),
+            expected_count=attachment_count,
+            domain_count=domain_count,
+            context=(
+                f"eager execution.plan.selector_closures.stages[{index}]"
+                ".attachment_domains"
+            ),
+        )
+        unpropagated_domains = _selector_domain_ids(
+            manifest,
+            execution_root,
+            selector_stage.get("unpropagated_finalization_domains"),
+            expected_count=len(finalizations),
+            domain_count=domain_count,
+            context=(
+                f"eager execution.plan.selector_closures.stages[{index}]"
+                ".unpropagated_finalization_domains"
+            ),
+        )
+        propagated_domains = _selector_domain_ids(
+            manifest,
+            execution_root,
+            selector_stage.get("propagated_finalization_domains"),
+            expected_count=len(finalizations),
+            domain_count=domain_count,
+            context=(
+                f"eager execution.plan.selector_closures.stages[{index}]"
+                ".propagated_finalization_domains"
+            ),
+        )
+
+        for invocation, domain_id in zip(invocations, invocation_domains, strict=True):
+            start, count = int(invocation[7]), int(invocation[8])
+            stop = start + count
+            if stop > len(attachment_domains):
+                raise ArtifactError(
+                    "eager invocation selector range exceeds attachment domains"
+                )
+            expected_domain = frozenset(
+                group_id
+                for attachment_domain_id in attachment_domains[start:stop]
+                for group_id in memberships[attachment_domain_id]
+            )
+            if memberships[domain_id] != expected_domain:
+                raise ArtifactError(
+                    "eager invocation selector domain does not equal its "
+                    "attachment-domain union"
+                )
+        for finalization, unpropagated, propagated in zip(
+            finalizations,
+            unpropagated_domains,
+            propagated_domains,
+            strict=True,
+        ):
+            if int(finalization[2]) == _MISSING_U32 and memberships[unpropagated]:
+                raise ArtifactError(
+                    "missing eager unpropagated output has a nonempty selector domain"
+                )
+            if int(finalization[3]) == _MISSING_U32 and memberships[propagated]:
+                raise ArtifactError(
+                    "missing eager propagated output has a nonempty selector domain"
+                )
+
+    closure_domains = _selector_domain_ids(
+        manifest,
+        execution_root,
+        selector.get("closure_domains"),
+        expected_count=len(closures),
+        domain_count=domain_count,
+        context="eager execution.plan.selector_closures.closure_domains",
+    )
+    for closure, domain_id in zip(closures, closure_domains, strict=True):
+        output_index = int(closure[3])
+        try:
+            expected = frozenset((groups_by_output[output_index],))
+        except KeyError as exc:
+            raise ArtifactError(
+                f"eager closure references unknown amplitude output {output_index}"
+            ) from exc
+        if memberships[domain_id] != expected:
+            raise ArtifactError(
+                "eager closure selector domain does not match its coherent group"
+            )
+
+    return domain_count, len(group_rows)
+
+
+def _eager_execution_inspection(
+    manifest: ArtifactManifest,
+    execution: Mapping[str, object],
+    execution_path: Path,
+) -> _ExecutionInspection:
+    if execution.get("eager_plan_abi") == _EAGER_PLAN_V3_ABI:
+        return _eager_v3_execution_inspection(manifest, execution)
+    runtime_options = _mapping(
+        execution.get("runtime_options"), "eager execution.runtime_options"
+    )
+    requested_tile = _integer(
+        runtime_options.get("point_tile_size"),
+        "eager execution.runtime_options.point_tile_size",
+        minimum=1,
+    )
+    workspace_mib = _integer(
+        runtime_options.get("workspace_mib"),
+        "eager execution.runtime_options.workspace_mib",
+        minimum=1,
+    )
+    effective_tile = _optional_positive_integer(
+        runtime_options.get("effective_point_tile_size"),
+        "eager execution.runtime_options.effective_point_tile_size",
+    )
+    workspace_bytes = _optional_positive_integer(
+        runtime_options.get("workspace_bytes"),
+        "eager execution.runtime_options.workspace_bytes",
+    )
+    plan = _mapping(execution.get("plan"), "eager execution.plan")
+    stages = _sequence(plan.get("stages"), "eager execution.plan.stages")
+    execution_root = execution_path.parent
+
+    invocation_count = 0
+    attachment_count = 0
+    finalization_count = 0
+    maximum_fanout = 0
+    referenced_kernel_ids: set[int] = set()
+    inspected_stages: list[
+        tuple[
+            Mapping[str, object],
+            tuple[tuple[int | float, ...], ...],
+            int,
+            tuple[tuple[int | float, ...], ...],
+        ]
+    ] = []
+    for index, raw_stage in enumerate(stages):
+        stage = _mapping(raw_stage, f"eager execution.plan.stages[{index}]")
+        invocations = _table_rows(
+            manifest,
+            execution_root,
+            stage.get("invocations"),
+            _EAGER_INVOCATION,
+            f"eager execution.plan.stages[{index}].invocations",
+        )
+        _attachment_path, stage_attachments, _attachment_size = _table_record(
+            stage.get("attachments"),
+            f"eager execution.plan.stages[{index}].attachments",
+        )
+        finalizations = _table_rows(
+            manifest,
+            execution_root,
+            stage.get("finalizations"),
+            _EAGER_FINALIZATION,
+            f"eager execution.plan.stages[{index}].finalizations",
+        )
+        inspected_stages.append((stage, invocations, stage_attachments, finalizations))
+        invocation_count += len(invocations)
+        attachment_count += stage_attachments
+        finalization_count += len(finalizations)
+        for row in invocations:
+            referenced_kernel_ids.add(int(row[0]))
+            maximum_fanout = max(maximum_fanout, int(row[-1]))
+        referenced_kernel_ids.update(
+            int(row[0]) for row in finalizations if int(row[0]) != _MISSING_U32
+        )
+
+    closures = _table_rows(
+        manifest,
+        execution_root,
+        plan.get("closures"),
+        _EAGER_CLOSURE,
+        "eager execution.plan.closures",
+    )
+    referenced_kernel_ids.update(
+        int(row[0]) for row in closures if int(row[0]) != _MISSING_U32
+    )
+    if attachment_count < invocation_count:
+        raise ArtifactError(
+            "eager execution has fewer attachments than canonical invocations"
+        )
+
+    kernel_pack = _mapping(execution.get("kernel_pack"), "eager execution.kernel_pack")
+    pack_path = _artifact_path(
+        manifest,
+        _string(
+            kernel_pack.get("manifest_path"),
+            "eager execution.kernel_pack.manifest_path",
+        ),
+        "eager execution.kernel_pack.manifest_path",
+    )
+    pack = _json_mapping(pack_path, "prepared eager kernel pack")
+    kernels = _sequence(pack.get("kernels"), "prepared eager kernel pack.kernels")
+    kernel_ids = {
+        _integer(
+            _mapping(raw, f"prepared eager kernel pack.kernels[{index}]").get(
+                "kernel_id"
+            ),
+            f"prepared eager kernel pack.kernels[{index}].kernel_id",
+        )
+        for index, raw in enumerate(kernels)
+    }
+    if not referenced_kernel_ids <= kernel_ids:
+        missing = ", ".join(
+            str(value) for value in sorted(referenced_kernel_ids - kernel_ids)
+        )
+        raise ArtifactError(
+            "eager execution references kernels absent from its prepared pack: "
+            f"{missing}"
+        )
+
+    selector_closures = plan.get("selector_closures")
+    selector_closure_available = False
+    selector_domain_count = None
+    selector_domain_membership_count = None
+    if selector_closures is not None:
+        (
+            selector_domain_count,
+            selector_domain_membership_count,
+        ) = _selector_domain_inspection(
+            manifest,
+            execution,
+            execution_root,
+            selector_closures,
+            stages=tuple(inspected_stages),
+            closures=closures,
+        )
+        selector_closure_available = True
+
+    return _ExecutionInspection(
+        execution_mode="eager",
+        prepared_backend=_string(
+            pack.get("backend"), "prepared eager kernel pack.backend"
+        ),
+        prepared_kernel_count=len(kernels),
+        referenced_kernel_count=len(referenced_kernel_ids),
+        invocation_count=invocation_count,
+        attachment_count=attachment_count,
+        evaluation_alias_count=attachment_count - invocation_count,
+        maximum_fanout=maximum_fanout,
+        finalization_count=finalization_count,
+        closure_count=len(closures),
+        selector_closure_available=selector_closure_available,
+        selector_domain_count=selector_domain_count,
+        selector_domain_membership_count=selector_domain_membership_count,
+        requested_point_tile_size=requested_tile,
+        effective_point_tile_size=effective_tile,
+        workspace_limit_bytes=workspace_mib * 1024 * 1024,
+        workspace_bytes=workspace_bytes,
+        native_profile_phases=_profile_phases(execution),
+    )
+
+
+def _eager_v3_execution_inspection(
+    manifest: ArtifactManifest,
+    execution: Mapping[str, object],
+) -> _ExecutionInspection:
+    runtime_options = _mapping(
+        execution.get("runtime_options"), "eager execution.runtime_options"
+    )
+    requested_tile = _integer(
+        runtime_options.get("point_tile_size"),
+        "eager execution.runtime_options.point_tile_size",
+        minimum=1,
+    )
+    workspace_mib = _integer(
+        runtime_options.get("workspace_mib"),
+        "eager execution.runtime_options.workspace_mib",
+        minimum=1,
+    )
+    plan = _mapping(execution.get("plan"), "eager execution.plan")
+    summary = _mapping(
+        plan.get("inspection_summary"),
+        "eager execution.plan.inspection_summary",
+    )
+    pack_reference = _mapping(
+        execution.get("kernel_pack"), "eager execution.kernel_pack"
+    )
+    pack_path = _artifact_path(
+        manifest,
+        _string(
+            pack_reference.get("manifest_path"),
+            "eager execution.kernel_pack.manifest_path",
+        ),
+        "eager execution.kernel_pack.manifest_path",
+    )
+    pack = _json_mapping(pack_path, "prepared eager kernel pack")
+    kernels = _sequence(pack.get("kernels"), "prepared eager kernel pack.kernels")
+    invocation_count = _integer(
+        summary.get("invocation_count"),
+        "eager inspection invocation_count",
+    )
+    attachment_count = _integer(
+        summary.get("attachment_count"),
+        "eager inspection attachment_count",
+    )
+    if attachment_count < invocation_count:
+        raise ArtifactError(
+            "eager execution has fewer attachments than canonical invocations"
+        )
+    selector_domain_count = _integer(
+        summary.get("selector_domain_count"),
+        "eager inspection selector_domain_count",
+    )
+    return _ExecutionInspection(
+        execution_mode="eager",
+        prepared_backend=_string(
+            pack.get("backend"), "prepared eager kernel pack.backend"
+        ),
+        prepared_kernel_count=len(kernels),
+        invocation_count=invocation_count,
+        attachment_count=attachment_count,
+        evaluation_alias_count=attachment_count - invocation_count,
+        finalization_count=_integer(
+            summary.get("finalization_count"),
+            "eager inspection finalization_count",
+        ),
+        closure_count=_integer(
+            summary.get("closure_count"), "eager inspection closure_count"
+        ),
+        selector_closure_available=selector_domain_count > 0,
+        selector_domain_count=selector_domain_count,
+        requested_point_tile_size=requested_tile,
+        workspace_limit_bytes=workspace_mib * 1024 * 1024,
+        native_profile_phases=_profile_phases(execution),
+    )
+
+
+def _recurrence_execution_inspection(
+    manifest: ArtifactManifest,
+    execution: Mapping[str, object],
+) -> _ExecutionInspection:
+    declared_capabilities = frozenset(
+        str(value)
+        for value in _sequence(
+            execution.get("required_runtime_capabilities"),
+            "recurrence execution.required_runtime_capabilities",
+        )
+    )
+    _require_contract(
+        execution,
+        "builder_input_abi",
+        RECURRENCE_BUILDER_INPUT_ABI,
+        "recurrence execution",
+    )
+    _require_contract(
+        execution,
+        "recurrence_plan_abi",
+        RECURRENCE_PLAN_ABI,
+        "recurrence execution",
+    )
+    _require_contract(
+        execution,
+        "runtime_layout_abi",
+        RECURRENCE_RUNTIME_LAYOUT_ABI,
+        "recurrence execution",
+    )
+    _require_contract(
+        execution,
+        "direct_template_abi",
+        RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "recurrence execution",
+    )
+    _require_contract(
+        execution,
+        "direct_backend_abi",
+        RECURRENCE_DIRECT_BACKEND_ABI,
+        "recurrence execution",
+    )
+    runtime_options = _mapping(
+        execution.get("runtime_options"),
+        "recurrence execution.runtime_options",
+    )
+    requested_tile = _integer(
+        runtime_options.get("point_tile_size"),
+        "recurrence execution.runtime_options.point_tile_size",
+        minimum=1,
+    )
+    workspace_mib = _integer(
+        runtime_options.get("workspace_mib"),
+        "recurrence execution.runtime_options.workspace_mib",
+        minimum=1,
+    )
+    plan = _mapping(execution.get("plan"), "recurrence execution.plan")
+    _require_contract(
+        plan,
+        "builder_input_abi",
+        RECURRENCE_BUILDER_INPUT_ABI,
+        "recurrence execution.plan",
+    )
+    _require_contract(
+        plan,
+        "recurrence_plan_abi",
+        RECURRENCE_PLAN_ABI,
+        "recurrence execution.plan",
+    )
+    _require_contract(
+        plan,
+        "runtime_layout_abi",
+        RECURRENCE_RUNTIME_LAYOUT_ABI,
+        "recurrence execution.plan",
+    )
+    _require_contract(
+        plan,
+        "direct_template_abi",
+        RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "recurrence execution.plan",
+    )
+    _require_contract(
+        plan,
+        "direct_backend_abi",
+        RECURRENCE_DIRECT_BACKEND_ABI,
+        "recurrence execution.plan",
+    )
+    runtime_schedule = _mapping(
+        plan.get("runtime_schedule"),
+        "recurrence execution.plan.runtime_schedule",
+    )
+    _require_contract(
+        runtime_schedule,
+        "plan_member_path",
+        _RECURRENCE_DIRECT_SCHEDULE_MEMBER_PATH,
+        "recurrence execution.plan.runtime_schedule",
+    )
+    binding = _mapping(
+        plan.get("process_binding"),
+        "recurrence execution.plan.process_binding",
+    )
+    _require_contract(
+        binding,
+        "abi",
+        "pyamplicol-recurrence-process-binding-v4",
+        "recurrence execution.plan.process_binding",
+    )
+    primary_process_digest = _string(
+        binding.get("process_digest"),
+        "recurrence execution.plan.process_binding.process_digest",
+    )
+    if len(primary_process_digest) != 64 or any(
+        character not in "0123456789abcdef" for character in primary_process_digest
+    ):
+        raise ArtifactError(
+            "recurrence primary process binding has an invalid process digest"
+        )
+    companion_process_digest = execution.get("process_digest")
+    if (
+        companion_process_digest is not None
+        and companion_process_digest != primary_process_digest
+    ):
+        raise ArtifactError(
+            "recurrence companion process digest disagrees with its primary binding"
+        )
+    summary = _mapping(
+        plan.get("inspection_summary"),
+        "recurrence execution.plan.inspection_summary",
+    )
+    if (
+        _string(
+            summary.get("execution_mode"),
+            "recurrence inspection execution_mode",
+        )
+        != "recurrence"
+    ):
+        raise ArtifactError(
+            "recurrence inspection summary has the wrong execution mode"
+        )
+    schedule = _mapping(
+        summary.get("schedule"),
+        "recurrence inspection schedule",
+    )
+    direct_arena_raw = summary.get("direct_arena")
+    direct_arena = (
+        {}
+        if direct_arena_raw is None
+        else _mapping(direct_arena_raw, "recurrence inspection direct_arena")
+    )
+    pack_reference = _mapping(
+        execution.get("kernel_pack"),
+        "recurrence execution.kernel_pack",
+    )
+    pack_path = _artifact_path(
+        manifest,
+        _string(
+            pack_reference.get("manifest_path"),
+            "recurrence execution.kernel_pack.manifest_path",
+        ),
+        "recurrence execution.kernel_pack.manifest_path",
+    )
+    pack = _json_mapping(pack_path, "prepared recurrence kernel pack")
+    kernels = _sequence(
+        pack.get("kernels"),
+        "prepared recurrence kernel pack.kernels",
+    )
+    prepared_kernel_count = _integer(
+        summary.get("prepared_kernel_count"),
+        "recurrence inspection prepared_kernel_count",
+    )
+    kernel_ids = {
+        _integer(
+            _mapping(
+                value,
+                f"prepared recurrence kernel pack.kernels[{index}]",
+            ).get("kernel_id"),
+            f"prepared recurrence kernel pack.kernels[{index}].kernel_id",
+        )
+        for index, value in enumerate(kernels)
+    }
+    direct_catalog = _mapping(
+        pack.get("recurrence_direct_template"),
+        "prepared recurrence kernel pack.recurrence_direct_template",
+    )
+    direct_templates = _sequence(
+        direct_catalog.get("templates"),
+        "prepared recurrence direct templates",
+    )
+    referenced_kernel_ids: set[int] = set()
+    for index, value in enumerate(direct_templates):
+        template = _mapping(
+            value,
+            f"prepared recurrence direct templates[{index}]",
+        )
+        binding = _mapping(
+            template.get("payload_binding"),
+            f"prepared recurrence direct templates[{index}].payload_binding",
+        )
+        kernel_id = binding.get("prepared_kernel_id")
+        if kernel_id is None:
+            continue
+        parsed_kernel_id = _integer(
+            kernel_id,
+            f"prepared recurrence direct templates[{index}].prepared_kernel_id",
+        )
+        if parsed_kernel_id not in kernel_ids:
+            raise ArtifactError(
+                "recurrence direct template references an absent prepared kernel"
+            )
+        referenced_kernel_ids.add(parsed_kernel_id)
+    complete_companion_catalog = (
+        RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY
+        in declared_capabilities
+    )
+    if (
+        not complete_companion_catalog
+        and prepared_kernel_count != len(referenced_kernel_ids)
+    ) or (
+        complete_companion_catalog
+        and not 0 < prepared_kernel_count <= len(referenced_kernel_ids)
+    ):
+        raise ArtifactError(
+            "recurrence inspection prepared-kernel count does not match its "
+            "direct template catalog"
+        )
+    semantic_components = _optional_counter(
+        direct_arena,
+        "semantic_component_count",
+        "recurrence inspection direct_arena.semantic_component_count",
+    )
+    arena_components = _optional_counter(
+        direct_arena,
+        "current_arena_components",
+        "recurrence inspection direct_arena.current_arena_components",
+    )
+    arena_reuse = _optional_counter(
+        direct_arena,
+        "arena_component_reuse_count",
+        "recurrence inspection direct_arena.arena_component_reuse_count",
+    )
+    if (
+        semantic_components is not None
+        and arena_components is not None
+        and arena_reuse is not None
+        and semantic_components - arena_components != arena_reuse
+    ):
+        raise ArtifactError(
+            "recurrence direct-arena component reuse count is inconsistent"
+        )
+    packed_input_bytes = _optional_counter(
+        direct_arena,
+        "packed_input_bytes",
+        "recurrence inspection direct_arena.packed_input_bytes",
+    )
+    packed_output_bytes = _optional_counter(
+        direct_arena,
+        "packed_output_bytes",
+        "recurrence inspection direct_arena.packed_output_bytes",
+    )
+    scatter_bytes = _optional_counter(
+        direct_arena,
+        "scatter_bytes",
+        "recurrence inspection direct_arena.scatter_bytes",
+    )
+    for label, value in (
+        ("packed-input bytes", packed_input_bytes),
+        ("packed-output bytes", packed_output_bytes),
+        ("scatter bytes", scatter_bytes),
+    ):
+        if value not in {None, 0}:
+            raise ArtifactError(f"recurrence direct-arena {label} must be zero")
+    source_rows = _optional_counter(
+        schedule,
+        "source_row_count",
+        "recurrence inspection source row count",
+    )
+    contribution_rows = _optional_counter(
+        schedule,
+        "contribution_count",
+        "recurrence inspection contribution count",
+    )
+    finalization_rows = _optional_counter(
+        schedule,
+        "finalization_count",
+        "recurrence inspection finalization count",
+    )
+    closure_rows = _optional_counter(
+        schedule,
+        "closure_term_count",
+        "recurrence inspection closure row count",
+    )
+    runtime_metadata = _mapping(
+        execution.get("runtime_metadata"),
+        "recurrence execution.runtime_metadata",
+    )
+    color_reference_raw = runtime_metadata.get("color_contraction")
+    color_accuracy = None
+    color_storage = None
+    color_sector_count = None
+    color_active_sector_count = None
+    color_component_count = None
+    color_group_count = None
+    color_destination_count = None
+    color_entry_count = None
+    color_logical_entry_count = None
+    color_factorization_kind = None
+    color_factorization_rank = None
+    color_factorization_coset_count = None
+    color_fft_provenance = None
+    if color_reference_raw is not None:
+        color_reference = _mapping(
+            color_reference_raw,
+            "recurrence execution.runtime_metadata.color_contraction",
+        )
+        _require_contract(
+            color_reference,
+            "abi",
+            _RECURRENCE_COLOR_CONTRACTION_CODEC_ABI,
+            "recurrence execution.runtime_metadata.color_contraction",
+        )
+        color_accuracy = _string(
+            color_reference.get("color_accuracy"),
+            "recurrence color-contraction accuracy",
+        )
+        if color_accuracy not in {"nlc", "full"}:
+            raise ArtifactError(
+                "recurrence color-contraction accuracy must be nlc or full"
+            )
+        color_storage = _string(
+            color_reference.get("storage"),
+            "recurrence color-contraction storage",
+        )
+        if color_storage not in {"expanded", "repeated", "convolution-kernels"}:
+            raise ArtifactError(
+                "recurrence color-contraction storage must be expanded, repeated, "
+                "or convolution-kernels"
+            )
+        color_sector_count = _integer(
+            color_reference.get("sector_count"),
+            "recurrence color-contraction sector count",
+            minimum=1,
+        )
+        color_active_sector_count = _integer(
+            color_reference.get("active_sector_count"),
+            "recurrence color-contraction active sector count",
+            minimum=1,
+        )
+        color_component_count = _integer(
+            color_reference.get("component_count"),
+            "recurrence color-contraction component count",
+            minimum=1,
+        )
+        color_group_count = _integer(
+            color_reference.get("group_count"),
+            "recurrence color-contraction group count",
+            minimum=1,
+        )
+        color_destination_count = _integer(
+            color_reference.get("destination_count"),
+            "recurrence color-contraction destination count",
+            minimum=1,
+        )
+        color_entry_count = _integer(
+            color_reference.get("entry_count"),
+            "recurrence color-contraction entry count",
+            minimum=1,
+        )
+        color_logical_entry_count = _integer(
+            color_reference.get("logical_entry_count"),
+            "recurrence color-contraction logical entry count",
+            minimum=1,
+        )
+        if color_active_sector_count > color_sector_count:
+            raise ArtifactError(
+                "recurrence active color sectors exceed the physical sector count"
+            )
+        if color_destination_count < color_group_count:
+            raise ArtifactError(
+                "recurrence color destinations do not cover contraction groups"
+            )
+        if color_group_count > color_active_sector_count * color_component_count:
+            raise ArtifactError(
+                "recurrence color groups exceed the active sector-helicity domain"
+            )
+        factorization_raw = color_reference.get("factorization")
+        if factorization_raw is not None:
+            factorization = _mapping(
+                factorization_raw,
+                "recurrence color-contraction factorization",
+            )
+            color_factorization_kind = _string(
+                factorization.get("kind"),
+                "recurrence color-contraction factorization kind",
+            )
+            color_factorization_rank = _integer(
+                factorization.get("rank"),
+                "recurrence color-contraction factorization rank",
+                minimum=2,
+            )
+            color_factorization_coset_count = _integer(
+                factorization.get("coset_count"),
+                "recurrence color-contraction factorization coset count",
+                minimum=1,
+            )
+            valid_factorization = (
+                (
+                    color_storage == "repeated"
+                    and color_factorization_kind == "klein-four-walsh"
+                    and color_factorization_rank == 2
+                )
+                or (
+                    color_storage == "repeated"
+                    and color_factorization_kind == "elementary-abelian-walsh"
+                    and 3 <= color_factorization_rank <= 31
+                )
+                or (
+                    color_storage == "convolution-kernels"
+                    and color_factorization_kind == "symmetric-group-fourier"
+                    and 2 <= color_factorization_rank <= 10
+                )
+            )
+            if not valid_factorization:
+                raise ArtifactError(
+                    "recurrence color factorization kind, rank, and storage disagree"
+                )
+        symmetric_group_fft = color_factorization_kind == "symmetric-group-fourier"
+        if (color_storage == "convolution-kernels") != symmetric_group_fft:
+            raise ArtifactError(
+                "recurrence convolution-kernel storage requires symmetric-group "
+                "Fourier factorization"
+            )
+        if (
+            SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY in declared_capabilities
+        ) != symmetric_group_fft:
+            raise ArtifactError(
+                "recurrence symmetric-group Fourier metadata and runtime capability "
+                "disagree"
+            )
+        color_fft_provenance = _symmetric_group_fft_provenance(
+            color_reference,
+            factorization_kind=color_factorization_kind,
+            degree=color_factorization_rank,
+            channel_count=color_factorization_coset_count,
+            group_count=color_group_count,
+            component_count=color_component_count,
+            entry_count=color_entry_count,
+            logical_entry_count=color_logical_entry_count,
+            context="recurrence color-contraction",
+        )
+    elif SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY in declared_capabilities:
+        raise ArtifactError(
+            "recurrence symmetric-group Fourier capability has no color payload"
+        )
+    return _ExecutionInspection(
+        execution_mode="recurrence",
+        prepared_backend=_string(
+            pack.get("backend"),
+            "prepared recurrence kernel pack.backend",
+        ),
+        prepared_kernel_count=prepared_kernel_count,
+        invocation_count=contribution_rows,
+        attachment_count=0,
+        finalization_count=finalization_rows,
+        closure_count=closure_rows,
+        requested_point_tile_size=requested_tile,
+        effective_point_tile_size=requested_tile,
+        workspace_limit_bytes=workspace_mib * 1024 * 1024,
+        arena_semantic_component_count=semantic_components,
+        arena_component_count=arena_components,
+        arena_component_reuse_count=arena_reuse,
+        momentum_form_count=_optional_counter(
+            direct_arena,
+            "momentum_form_count",
+            "recurrence inspection direct_arena.momentum_form_count",
+        ),
+        direct_source_row_count=source_rows,
+        direct_contribution_row_count=contribution_rows,
+        direct_finalization_row_count=finalization_rows,
+        direct_closure_row_count=closure_rows,
+        direct_row_group_count=_optional_counter(
+            direct_arena,
+            "row_group_count",
+            "recurrence inspection direct_arena.row_group_count",
+        ),
+        recurrence_color_accuracy=color_accuracy,
+        recurrence_color_storage=color_storage,
+        recurrence_color_sector_count=color_sector_count,
+        recurrence_color_active_sector_count=color_active_sector_count,
+        recurrence_color_component_count=color_component_count,
+        recurrence_color_group_count=color_group_count,
+        recurrence_color_destination_count=color_destination_count,
+        recurrence_color_entry_count=color_entry_count,
+        recurrence_color_logical_entry_count=color_logical_entry_count,
+        recurrence_color_factorization_kind=color_factorization_kind,
+        recurrence_color_factorization_rank=color_factorization_rank,
+        recurrence_color_factorization_coset_count=(color_factorization_coset_count),
+        recurrence_color_contraction_method=(
+            None
+            if color_fft_provenance is None
+            else cast(str, color_fft_provenance["method"])
+        ),
+        recurrence_color_fft_degree=(
+            None
+            if color_fft_provenance is None
+            else cast(int, color_fft_provenance["degree"])
+        ),
+        recurrence_color_fft_channel_count=(
+            None
+            if color_fft_provenance is None
+            else cast(int, color_fft_provenance["channel_count"])
+        ),
+        recurrence_color_fft_covered_local_group_count=(
+            None
+            if color_fft_provenance is None
+            else cast(int, color_fft_provenance["covered_local_group_count"])
+        ),
+        recurrence_color_direct_residual_group_count=(
+            None
+            if color_fft_provenance is None
+            else cast(int, color_fft_provenance["residual_group_count"])
+        ),
+        recurrence_color_direct_residual_entry_count=(
+            None
+            if color_fft_provenance is None
+            else cast(int, color_fft_provenance["residual_entry_count"])
+        ),
+        recurrence_color_raw_kernel_bytes=(
+            None
+            if color_fft_provenance is None
+            else cast(int, color_fft_provenance["raw_kernel_bytes"])
+        ),
+        recurrence_color_transformed_kernel_bytes=(
+            None
+            if color_fft_provenance is None
+            else cast(int, color_fft_provenance["transformed_kernel_bytes"])
+        ),
+        recurrence_color_fft_capability=(
+            None
+            if color_fft_provenance is None
+            else cast(str, color_fft_provenance["capability"])
+        ),
+        packed_input_bytes=0,
+        packed_output_bytes=0,
+        scatter_bytes=0,
+        native_profile_phases=_RECURRENCE_PROFILE_PHASES,
+    )
+
+
+def _symmetric_group_fft_provenance(
+    reference: Mapping[str, object],
+    *,
+    factorization_kind: str | None,
+    degree: int | None,
+    channel_count: int | None,
+    group_count: int,
+    component_count: int,
+    entry_count: int,
+    logical_entry_count: int,
+    context: str,
+) -> dict[str, int | str] | None:
+    raw = reference.get("fft_provenance")
+    if factorization_kind != "symmetric-group-fourier":
+        if raw is not None or "fft_provenance" in reference:
+            raise ArtifactError(f"{context} non-FFT summary carries FFT provenance")
+        return None
+    if degree is None or channel_count is None:
+        raise ArtifactError(f"{context} symmetric-group factorization is incomplete")
+    provenance = _mapping(raw, f"{context} FFT provenance")
+    expected_fields = {
+        "method",
+        "degree",
+        "channel_count",
+        "covered_local_group_count",
+        "residual_group_count",
+        "residual_entry_count",
+        "raw_kernel_bytes",
+        "transformed_kernel_bytes",
+        "capability",
+    }
+    if set(provenance) != expected_fields:
+        raise ArtifactError(f"{context} FFT provenance has unsupported fields")
+    if group_count % component_count:
+        raise ArtifactError(f"{context} FFT component map is not rectangular")
+    local_group_count = group_count // component_count
+    group_order = math.factorial(degree)
+    covered_local_group_count = channel_count * group_order
+    if covered_local_group_count > local_group_count:
+        raise ArtifactError(f"{context} FFT channels exceed the local group domain")
+    residual_group_count = local_group_count - covered_local_group_count
+    residual_entry_count = (
+        local_group_count * (local_group_count + 1) // 2
+        - covered_local_group_count * (covered_local_group_count + 1) // 2
+    )
+    kernel_entry_count = channel_count * (channel_count + 1) // 2 * group_order
+    raw_kernel_bytes = kernel_entry_count * 16
+    transformed_kernel_bytes = kernel_entry_count * 8
+    values: dict[str, int | str] = {
+        "method": _string(provenance.get("method"), f"{context} FFT method"),
+        "degree": _integer(provenance.get("degree"), f"{context} FFT degree"),
+        "channel_count": _integer(
+            provenance.get("channel_count"), f"{context} FFT channel count"
+        ),
+        "covered_local_group_count": _integer(
+            provenance.get("covered_local_group_count"),
+            f"{context} FFT-covered local group count",
+        ),
+        "residual_group_count": _integer(
+            provenance.get("residual_group_count"),
+            f"{context} direct residual group count",
+        ),
+        "residual_entry_count": _integer(
+            provenance.get("residual_entry_count"),
+            f"{context} direct residual entry count",
+        ),
+        "raw_kernel_bytes": _integer(
+            provenance.get("raw_kernel_bytes"), f"{context} raw kernel bytes"
+        ),
+        "transformed_kernel_bytes": _integer(
+            provenance.get("transformed_kernel_bytes"),
+            f"{context} transformed kernel bytes",
+        ),
+        "capability": _string(
+            provenance.get("capability"), f"{context} FFT capability"
+        ),
+    }
+    expected: dict[str, int | str] = {
+        "method": "symmetric-group-fourier",
+        "degree": degree,
+        "channel_count": channel_count,
+        "covered_local_group_count": covered_local_group_count,
+        "residual_group_count": residual_group_count,
+        "residual_entry_count": residual_entry_count,
+        "raw_kernel_bytes": raw_kernel_bytes,
+        "transformed_kernel_bytes": transformed_kernel_bytes,
+        "capability": SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+    }
+    if (
+        values != expected
+        or entry_count != kernel_entry_count + residual_entry_count
+        or logical_entry_count != entry_count * component_count
+    ):
+        raise ArtifactError(f"{context} symmetric-group FFT provenance is inconsistent")
+    return values
+
+
+def _on_the_fly_color_reference(
+    runtime_metadata: Mapping[str, object],
+    *,
+    color_accuracy: str,
+    contracted: bool,
+) -> dict[str, Any] | None:
+    raw = runtime_metadata.get("color_contraction")
+    if not contracted:
+        if raw is not None or "color_contraction" in runtime_metadata:
+            raise ArtifactError(
+                "LC on-the-fly execution unexpectedly carries color contraction"
+            )
+        return None
+    reference = _mapping(
+        raw,
+        "on-the-fly execution.runtime_metadata.color_contraction",
+    )
+    expected_fields = {
+        "abi",
+        "color_accuracy",
+        "storage",
+        "includes_color_factor",
+        "group_count",
+        "sector_count",
+        "active_sector_count",
+        "component_count",
+        "destination_count",
+        "entry_count",
+        "logical_entry_count",
+        "semantic_digest",
+        "factorization",
+        "path",
+        "size_bytes",
+        "sha256",
+    }
+    if reference.get("factorization") is not None:
+        expected_fields.add("fft_provenance")
+    if set(reference) != expected_fields:
+        raise ArtifactError(
+            "on-the-fly color-contraction reference has unsupported fields"
+        )
+    _require_contract(
+        reference,
+        "abi",
+        _RECURRENCE_COLOR_CONTRACTION_CODEC_ABI,
+        "on-the-fly execution.runtime_metadata.color_contraction",
+    )
+    accuracy = _string(
+        reference.get("color_accuracy"),
+        "on-the-fly color-contraction accuracy",
+    )
+    storage = _string(
+        reference.get("storage"),
+        "on-the-fly color-contraction storage",
+    )
+    sector_count = _integer(
+        reference.get("sector_count"),
+        "on-the-fly color-contraction sector count",
+        minimum=1,
+    )
+    active_sector_count = _integer(
+        reference.get("active_sector_count"),
+        "on-the-fly color-contraction active sector count",
+        minimum=1,
+    )
+    component_count = _integer(
+        reference.get("component_count"),
+        "on-the-fly color-contraction component count",
+        minimum=1,
+    )
+    group_count = _integer(
+        reference.get("group_count"),
+        "on-the-fly color-contraction group count",
+        minimum=1,
+    )
+    destination_count = _integer(
+        reference.get("destination_count"),
+        "on-the-fly color-contraction destination count",
+        minimum=1,
+    )
+    entry_count = _integer(
+        reference.get("entry_count"),
+        "on-the-fly color-contraction entry count",
+        minimum=1,
+    )
+    logical_entry_count = _integer(
+        reference.get("logical_entry_count"),
+        "on-the-fly color-contraction logical entry count",
+        minimum=1,
+    )
+    semantic_digest = _string(
+        reference.get("semantic_digest"),
+        "on-the-fly color-contraction semantic digest",
+    )
+    payload_sha256 = _string(
+        reference.get("sha256"),
+        "on-the-fly color-contraction SHA-256",
+    )
+    factorization_raw = reference.get("factorization")
+    symmetric_group_fft = False
+    factorization_rank = None
+    factorization_coset_count = None
+    if factorization_raw is not None:
+        factorization = _mapping(
+            factorization_raw,
+            "on-the-fly color-contraction factorization",
+        )
+        if set(factorization) != {"kind", "rank", "coset_count"}:
+            raise ArtifactError(
+                "on-the-fly color-contraction factorization has unsupported fields"
+            )
+        factorization_kind = _string(
+            factorization.get("kind"),
+            "on-the-fly color-contraction factorization kind",
+        )
+        factorization_rank = _integer(
+            factorization.get("rank"),
+            "on-the-fly color-contraction factorization degree",
+            minimum=2,
+        )
+        factorization_coset_count = _integer(
+            factorization.get("coset_count"),
+            "on-the-fly color-contraction channel count",
+            minimum=1,
+        )
+        symmetric_group_fft = (
+            factorization_kind == "symmetric-group-fourier" and factorization_rank <= 10
+        )
+        if not symmetric_group_fft:
+            raise ArtifactError(
+                "on-the-fly color factorization must be symmetric-group Fourier"
+            )
+    if (
+        accuracy != color_accuracy
+        or accuracy not in {"nlc", "full"}
+        or storage != ("convolution-kernels" if symmetric_group_fft else "expanded")
+        or reference.get("includes_color_factor") is not True
+        or component_count != 1
+        or active_sector_count != group_count
+        or destination_count != group_count
+        or group_count > sector_count
+        or logical_entry_count != entry_count
+        or reference.get("path") != "on-the-fly-color.bin"
+        or semantic_digest != payload_sha256
+        or len(payload_sha256) != 64
+        or any(character not in "0123456789abcdef" for character in payload_sha256)
+    ):
+        raise ArtifactError("on-the-fly color-contraction reference is noncanonical")
+    fft_provenance = _symmetric_group_fft_provenance(
+        reference,
+        factorization_kind=("symmetric-group-fourier" if symmetric_group_fft else None),
+        degree=factorization_rank,
+        channel_count=factorization_coset_count,
+        group_count=group_count,
+        component_count=component_count,
+        entry_count=entry_count,
+        logical_entry_count=logical_entry_count,
+        context="on-the-fly color-contraction",
+    )
+    _integer(
+        reference.get("size_bytes"),
+        "on-the-fly color-contraction payload size",
+        minimum=1,
+    )
+    return {
+        "color_accuracy": accuracy,
+        "storage": storage,
+        "sector_count": sector_count,
+        "active_sector_count": active_sector_count,
+        "component_count": component_count,
+        "group_count": group_count,
+        "destination_count": destination_count,
+        "entry_count": entry_count,
+        "logical_entry_count": logical_entry_count,
+        "factorization_kind": (
+            "symmetric-group-fourier" if symmetric_group_fft else None
+        ),
+        "factorization_rank": factorization_rank,
+        "factorization_coset_count": factorization_coset_count,
+        "contraction_method": (
+            None if fft_provenance is None else fft_provenance["method"]
+        ),
+        "fft_degree": (None if fft_provenance is None else fft_provenance["degree"]),
+        "fft_channel_count": (
+            None if fft_provenance is None else fft_provenance["channel_count"]
+        ),
+        "fft_covered_local_group_count": (
+            None
+            if fft_provenance is None
+            else fft_provenance["covered_local_group_count"]
+        ),
+        "direct_residual_group_count": (
+            None if fft_provenance is None else fft_provenance["residual_group_count"]
+        ),
+        "direct_residual_entry_count": (
+            None if fft_provenance is None else fft_provenance["residual_entry_count"]
+        ),
+        "raw_kernel_bytes": (
+            None if fft_provenance is None else fft_provenance["raw_kernel_bytes"]
+        ),
+        "transformed_kernel_bytes": (
+            None
+            if fft_provenance is None
+            else fft_provenance["transformed_kernel_bytes"]
+        ),
+        "fft_capability": (
+            None if fft_provenance is None else fft_provenance["capability"]
+        ),
+    }
+
+
+def _execution_inspection(
+    manifest: ArtifactManifest,
+    execution_path: Path,
+    required_runtime_capabilities: Sequence[object] | None = None,
+    *,
+    process: Mapping[str, object] | None = None,
+) -> _ExecutionInspection:
+    capabilities = (
+        required_runtime_capabilities
+        if required_runtime_capabilities is not None
+        else _sequence(
+            manifest.runtime.get("required_runtime_capabilities"),
+            "runtime.required_runtime_capabilities",
+        )
+    )
+    capability_values = frozenset(str(value) for value in capabilities)
+    on_the_fly_color_capabilities = {
+        ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+        ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+    }
+    if (
+        ON_THE_FLY_RUNTIME_CAPABILITY in capability_values
+        or not on_the_fly_color_capabilities.isdisjoint(capability_values)
+    ):
+        selected_color_capabilities = capability_values.intersection(
+            on_the_fly_color_capabilities
+        )
+        if len(selected_color_capabilities) != 1:
+            raise ArtifactError(
+                "on-the-fly execution must declare exactly one color capability"
+            )
+        selected_color_capability = next(iter(selected_color_capabilities))
+        on_the_fly_capabilities = {
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+            selected_color_capability,
+        }
+        symmetric_group_fft_capability = (
+            SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY in capability_values
+        )
+        if symmetric_group_fft_capability:
+            on_the_fly_capabilities.add(SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY)
+        if capability_values != on_the_fly_capabilities or len(capabilities) != len(
+            on_the_fly_capabilities
+        ):
+            raise ArtifactError(
+                "on-the-fly execution must declare exactly its required runtime "
+                "capabilities"
+            )
+        contracted_color = (
+            selected_color_capability == ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY
+        )
+        expected_color_accuracies = {"nlc", "full"} if contracted_color else {"lc"}
+        execution = _json_mapping(execution_path, "process execution manifest")
+        expected_root_fields = {
+            "schema_version",
+            "kind",
+            "required_runtime_capabilities",
+            "process",
+            "key",
+            "color_accuracy",
+            "external_pdg_order",
+            "kernel_pack",
+            "runtime_options",
+            "selector_policy",
+            "runtime_metadata",
+            "runtime_container",
+        }
+        if process is None or set(execution) != expected_root_fields:
+            raise ArtifactError(
+                "on-the-fly process execution manifest has unsupported root fields"
+            )
+        kind = _string(execution.get("kind"), "process execution manifest.kind")
+        declared_capabilities = _sequence(
+            execution.get("required_runtime_capabilities"),
+            "on-the-fly process execution manifest.required_runtime_capabilities",
+        )
+        declared_capability_values = frozenset(
+            str(value) for value in declared_capabilities
+        )
+        external_pdgs = tuple(
+            _sequence(
+                execution.get("external_pdg_order"),
+                "on-the-fly process execution manifest.external_pdg_order",
+            )
+        )
+        expected_pdgs = tuple(
+            _sequence(
+                process.get("external_pdgs"),
+                f"process {process.get('id')} external_pdgs",
+            )
+        )
+        if (
+            any(
+                isinstance(value, bool) or not isinstance(value, int)
+                for value in (*external_pdgs, *expected_pdgs)
+            )
+            or execution.get("schema_version") != 3
+            or kind != _ON_THE_FLY_RUNTIME_KIND
+            or len(declared_capabilities) != len(on_the_fly_capabilities)
+            or declared_capability_values != on_the_fly_capabilities
+            or execution.get("process") != process.get("expression")
+            or execution.get("key") != process.get("id")
+            or execution.get("color_accuracy") not in expected_color_accuracies
+            or process.get("color_accuracy") != execution.get("color_accuracy")
+            or external_pdgs != expected_pdgs
+        ):
+            raise ArtifactError(
+                "on-the-fly process execution manifest disagrees with its outer process"
+            )
+        kernel_pack = _mapping(
+            execution.get("kernel_pack"),
+            "on-the-fly execution.kernel_pack",
+        )
+        if kernel_pack != {
+            "manifest_path": "model/eager-kernel-pack.json",
+            "payload_root": "model/eager-kernels",
+        }:
+            raise ArtifactError("on-the-fly prepared-kernel paths are not canonical")
+        runtime_container = _mapping(
+            execution.get("runtime_container"),
+            "on-the-fly execution.runtime_container",
+        )
+        if runtime_container != {
+            "kind": "pyamplicol-on-the-fly-runtime-container",
+            "schema_version": 1,
+            "storage_abi": "pacbin-v1",
+            "path": "on-the-fly-runtime.pacbin",
+            "seed_member_path": "on-the-fly/process-seed-v1.bin",
+        }:
+            raise ArtifactError("on-the-fly runtime-container contract is noncanonical")
+        runtime_metadata = _mapping(
+            execution.get("runtime_metadata"),
+            "on-the-fly execution.runtime_metadata",
+        )
+        color_reference = _on_the_fly_color_reference(
+            runtime_metadata,
+            color_accuracy=str(execution.get("color_accuracy")),
+            contracted=contracted_color,
+        )
+        reference_uses_symmetric_group_fft = (
+            color_reference is not None
+            and color_reference["factorization_kind"] == "symmetric-group-fourier"
+        )
+        if reference_uses_symmetric_group_fft != symmetric_group_fft_capability:
+            raise ArtifactError(
+                "on-the-fly symmetric-group Fourier metadata and runtime "
+                "capability disagree"
+            )
+        selector_policy = _mapping(
+            execution.get("selector_policy"),
+            "on-the-fly execution.selector_policy",
+        )
+        if set(selector_policy) - {"color_basis"} != {
+            "color_coverage",
+            "reference_color_word",
+            "trace_reflections_folded",
+            "selector_census",
+        }:
+            raise ArtifactError(
+                "on-the-fly execution.selector_policy has unsupported fields"
+            )
+        color_basis = selector_policy.get("color_basis", "trace")
+        if color_basis not in ("trace", "adjoint"):
+            raise ArtifactError(
+                "on-the-fly execution.selector_policy.color_basis "
+                "must be trace or adjoint"
+            )
+        if color_basis == "adjoint" and not contracted_color:
+            raise ArtifactError("adjoint on-the-fly color requires contracted NLC/full")
+        expected_color_coverage = "contracted" if contracted_color else "complete"
+        if selector_policy.get("color_coverage") != expected_color_coverage:
+            raise ArtifactError(
+                "on-the-fly execution.selector_policy.color_coverage disagrees "
+                "with its color capability"
+            )
+        trace_reflections_folded = selector_policy.get("trace_reflections_folded")
+        if not isinstance(trace_reflections_folded, bool):
+            raise ArtifactError(
+                "on-the-fly execution.selector_policy.trace_reflections_folded "
+                "must be a boolean"
+            )
+        if contracted_color and trace_reflections_folded:
+            raise ArtifactError(
+                "contracted on-the-fly color cannot fold trace reflections"
+            )
+        reference = selector_policy.get("reference_color_word")
+        if reference is not None:
+            word = tuple(
+                _integer(
+                    value,
+                    "on-the-fly execution.selector_policy.reference_color_word"
+                    f"[{index}]",
+                    minimum=1,
+                )
+                for index, value in enumerate(
+                    _sequence(
+                        reference,
+                        "on-the-fly execution.selector_policy.reference_color_word",
+                    )
+                )
+            )
+            if not word or len(set(word)) != len(word):
+                raise ArtifactError(
+                    "on-the-fly execution selector reference must contain unique "
+                    "positive labels"
+                )
+        census = _mapping(
+            selector_policy.get("selector_census"),
+            "on-the-fly execution.selector_policy.selector_census",
+        )
+        if set(census) != {
+            "physical_helicity_count",
+            "physical_color_flow_count",
+        }:
+            raise ArtifactError(
+                "on-the-fly execution selector census has unsupported fields"
+            )
+        helicity_count = _integer(
+            census.get("physical_helicity_count"),
+            "on-the-fly execution selector census physical_helicity_count",
+            minimum=1,
+        )
+        color_flow_count = _integer(
+            census.get("physical_color_flow_count"),
+            "on-the-fly execution selector census physical_color_flow_count",
+            minimum=1,
+        )
+        if helicity_count > (1 << 64) - 1 or color_flow_count > (1 << 64) - 1:
+            raise ArtifactError(
+                "on-the-fly execution selector census exceeds the u64 domain"
+            )
+        if contracted_color and color_flow_count != 1:
+            raise ArtifactError(
+                "contracted on-the-fly execution must expose one physical color result"
+            )
+        runtime_options = _mapping(
+            execution.get("runtime_options"),
+            "on-the-fly execution.runtime_options",
+        )
+        if set(runtime_options) != {
+            "point_tile_size",
+            "query_construction_threads",
+        }:
+            raise ArtifactError("on-the-fly execution.runtime_options is invalid")
+        point_tile_size = _integer(
+            runtime_options.get("point_tile_size"),
+            "on-the-fly execution.runtime_options.point_tile_size",
+            minimum=1,
+        )
+        query_construction_threads = _integer(
+            runtime_options.get("query_construction_threads"),
+            "on-the-fly execution.runtime_options.query_construction_threads",
+            minimum=1,
+        )
+        return _ExecutionInspection(
+            execution_mode="on-the-fly",
+            physical_helicity_count=helicity_count,
+            physical_color_flow_count=color_flow_count,
+            requested_point_tile_size=point_tile_size,
+            requested_query_construction_threads=query_construction_threads,
+            recurrence_color_accuracy=(
+                None if color_reference is None else color_reference["color_accuracy"]
+            ),
+            recurrence_color_storage=(
+                None if color_reference is None else color_reference["storage"]
+            ),
+            recurrence_color_sector_count=(
+                None if color_reference is None else color_reference["sector_count"]
+            ),
+            recurrence_color_active_sector_count=(
+                None
+                if color_reference is None
+                else color_reference["active_sector_count"]
+            ),
+            recurrence_color_component_count=(
+                None if color_reference is None else color_reference["component_count"]
+            ),
+            recurrence_color_group_count=(
+                None if color_reference is None else color_reference["group_count"]
+            ),
+            recurrence_color_destination_count=(
+                None
+                if color_reference is None
+                else color_reference["destination_count"]
+            ),
+            recurrence_color_entry_count=(
+                None if color_reference is None else color_reference["entry_count"]
+            ),
+            recurrence_color_logical_entry_count=(
+                None
+                if color_reference is None
+                else color_reference["logical_entry_count"]
+            ),
+            recurrence_color_factorization_kind=(
+                None
+                if color_reference is None
+                else color_reference["factorization_kind"]
+            ),
+            recurrence_color_factorization_rank=(
+                None
+                if color_reference is None
+                else color_reference["factorization_rank"]
+            ),
+            recurrence_color_factorization_coset_count=(
+                None
+                if color_reference is None
+                else color_reference["factorization_coset_count"]
+            ),
+            recurrence_color_contraction_method=(
+                None
+                if color_reference is None
+                else color_reference["contraction_method"]
+            ),
+            recurrence_color_fft_degree=(
+                None if color_reference is None else color_reference["fft_degree"]
+            ),
+            recurrence_color_fft_channel_count=(
+                None
+                if color_reference is None
+                else color_reference["fft_channel_count"]
+            ),
+            recurrence_color_fft_covered_local_group_count=(
+                None
+                if color_reference is None
+                else color_reference["fft_covered_local_group_count"]
+            ),
+            recurrence_color_direct_residual_group_count=(
+                None
+                if color_reference is None
+                else color_reference["direct_residual_group_count"]
+            ),
+            recurrence_color_direct_residual_entry_count=(
+                None
+                if color_reference is None
+                else color_reference["direct_residual_entry_count"]
+            ),
+            recurrence_color_raw_kernel_bytes=(
+                None if color_reference is None else color_reference["raw_kernel_bytes"]
+            ),
+            recurrence_color_transformed_kernel_bytes=(
+                None
+                if color_reference is None
+                else color_reference["transformed_kernel_bytes"]
+            ),
+            recurrence_color_fft_capability=(
+                None if color_reference is None else color_reference["fft_capability"]
+            ),
+            native_profile_phases=_ON_THE_FLY_PROFILE_PHASES,
+        )
+    if RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY in capability_values:
+        color_capabilities = capability_values.intersection(
+            {
+                RECURRENCE_COLOR_RUNTIME_CAPABILITY,
+                RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            }
+        )
+        if len(color_capabilities) != 1:
+            raise ArtifactError(
+                "recurrence direct-arena execution must declare exactly one "
+                "recurrence color capability"
+            )
+        required = {
+            *color_capabilities,
+            RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        }
+        if not required.issubset(capability_values):
+            missing = ", ".join(sorted(required - capability_values))
+            raise ArtifactError(
+                "recurrence direct-arena execution is missing required "
+                f"capabilities: {missing}"
+            )
+        execution = _json_mapping(execution_path, "process execution manifest")
+        kind = _string(execution.get("kind"), "process execution manifest.kind")
+        if kind != _RECURRENCE_RUNTIME_KIND:
+            raise ArtifactError(
+                "recurrence capability is paired with an unsupported process "
+                f"execution kind {kind!r}"
+            )
+        return _recurrence_execution_inspection(manifest, execution)
+    if _EAGER_RUNTIME_CAPABILITIES.isdisjoint(capability_values):
+        # Compiled execution manifests can be several GiB at high multiplicity.
+        # Their capability contract already identifies the execution lane, and
+        # the manifest hash validation above has verified the payload bytes.
+        return _ExecutionInspection(
+            execution_mode="compiled",
+            native_profile_phases=_COMPILED_PROFILE_PHASES,
+        )
+    execution = _json_mapping(execution_path, "process execution manifest")
+    kind = _string(execution.get("kind"), "process execution manifest.kind")
+    if kind == _EAGER_RUNTIME_KIND:
+        return _eager_execution_inspection(manifest, execution, execution_path)
+    raise ArtifactError(f"unsupported process execution kind {kind!r}")
+
+
+def _optional_nonnegative_integer(
+    value: object,
+    context: str,
+) -> int | None:
+    if value is None:
+        return None
+    return _integer(value, context, minimum=0)
+
+
+def _optional_counter(
+    record: Mapping[str, object],
+    name: str,
+    context: str,
+) -> int | None:
+    if name not in record:
+        return None
+    return _integer(record[name], context, minimum=0)
+
+
+def _require_contract(
+    record: Mapping[str, object],
+    name: str,
+    expected: str,
+    context: str,
+) -> None:
+    actual = record.get(name)
+    if actual != expected:
+        raise ArtifactError(
+            f"{context}.{name} must be {expected!r}; regenerate the recurrence "
+            "artifact with the current pyAmpliCol"
+        )
+
+
+def _source_helicity_selection(
+    value: object,
+    context: str,
+) -> tuple[tuple[int, int], ...]:
+    selection = _mapping(value, context)
+    result: list[tuple[int, int]] = []
+    for raw_label, raw_helicity in selection.items():
+        try:
+            label = int(raw_label)
+        except (TypeError, ValueError) as exc:
+            raise ArtifactError(f"{context} has a non-integer source label") from exc
+        if str(label) != str(raw_label) or label < 1:
+            raise ArtifactError(f"{context} has an invalid source label {raw_label!r}")
+        if isinstance(raw_helicity, bool) or not isinstance(raw_helicity, int):
+            raise ArtifactError(f"{context}[{raw_label!r}] must be an integer")
+        result.append((label, raw_helicity))
+    result.sort()
+    if len({label for label, _helicity in result}) != len(result):
+        raise ArtifactError(f"{context} repeats a source label")
+    return tuple(result)
+
+
+def _color_sector_selection(
+    value: object,
+    context: str,
+) -> tuple[int, ...]:
+    result = tuple(
+        _integer(item, f"{context}[{index}]")
+        for index, item in enumerate(_sequence(value, context))
+    )
+    if result != tuple(sorted(set(result))):
+        raise ArtifactError(f"{context} must contain unique sorted sector IDs")
+    return result
+
+
+def _physics_inspection(
+    manifest: ArtifactManifest,
+    process: Mapping[str, object],
+    execution: _ExecutionInspection,
+) -> _PhysicsInspection:
+    relative = str(process["physics_path"])
+    path = manifest.root / relative
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise ArtifactError(
+            f"cannot read runtime physics metadata {relative}: {exc}"
+        ) from exc
+    except json.JSONDecodeError as exc:
+        raise ArtifactError(
+            f"invalid runtime physics metadata {relative}: {exc}"
+        ) from exc
+
+    physics = _mapping(payload, f"runtime physics metadata {relative}")
+    if execution.execution_mode == "on-the-fly":
+        if set(physics) != {
+            "schema_version",
+            "kind",
+            "process_id",
+            "process",
+            "color_accuracy",
+            "external_particles",
+            "model_parameters",
+        }:
+            raise ArtifactError(
+                f"{relative} compact on-the-fly metadata has unsupported fields"
+            )
+        if (
+            physics.get("schema_version") != 1
+            or physics.get("kind") != _ON_THE_FLY_PUBLIC_METADATA_KIND
+            or physics.get("process_id") != process.get("id")
+            or physics.get("process") != process.get("expression")
+            or physics.get("color_accuracy") not in {"lc", "nlc", "full"}
+            or process.get("color_accuracy") != physics.get("color_accuracy")
+        ):
+            raise ArtifactError(
+                f"{relative} compact on-the-fly metadata disagrees with its process"
+            )
+        external_pdgs = _sequence(
+            process.get("external_pdgs"),
+            f"process {process.get('id')} external_pdgs",
+        )
+        externals = _sequence(
+            physics.get("external_particles"),
+            f"{relative}.external_particles",
+        )
+        if len(externals) != len(external_pdgs):
+            raise ArtifactError(
+                f"{relative}.external_particles disagrees with the process arity"
+            )
+        for index, (raw_external, pdg) in enumerate(
+            zip(externals, external_pdgs, strict=True)
+        ):
+            external = _mapping(
+                raw_external,
+                f"{relative}.external_particles[{index}]",
+            )
+            if (
+                set(external)
+                != {
+                    "index",
+                    "label",
+                    "particle",
+                    "pdg",
+                    "role",
+                    "momentum_slot",
+                    "momentum_components",
+                }
+                or external.get("index") != index
+                or external.get("label") != index + 1
+                or isinstance(external.get("pdg"), bool)
+                or not isinstance(external.get("pdg"), int)
+                or external.get("pdg") != pdg
+                or external.get("momentum_slot") != index
+                or external.get("role") != ("initial" if index < 2 else "final")
+                or external.get("momentum_components") != ["E", "px", "py", "pz"]
+            ):
+                raise ArtifactError(
+                    f"{relative}.external_particles[{index}] is noncanonical"
+                )
+            _string(
+                external.get("particle"),
+                f"{relative}.external_particles[{index}].particle",
+            )
+        parameter_names: set[str] = set()
+        for index, raw_parameter in enumerate(
+            _sequence(physics.get("model_parameters"), f"{relative}.model_parameters")
+        ):
+            parameter = _mapping(
+                raw_parameter,
+                f"{relative}.model_parameters[{index}]",
+            )
+            if set(parameter) != {
+                "name",
+                "kind",
+                "default_real",
+                "default_imaginary",
+                "mutable",
+            }:
+                raise ArtifactError(
+                    f"{relative}.model_parameters[{index}] has unsupported fields"
+                )
+            name = _string(
+                parameter.get("name"),
+                f"{relative}.model_parameters[{index}].name",
+            )
+            kind = parameter.get("kind")
+            mutable = parameter.get("mutable")
+            defaults = (
+                parameter.get("default_real"),
+                parameter.get("default_imaginary"),
+            )
+            if (
+                name in parameter_names
+                or kind
+                not in {
+                    "normalization",
+                    "mass",
+                    "width",
+                    "coupling",
+                    "external",
+                    "derived",
+                }
+                or not isinstance(mutable, bool)
+                or (kind == "derived" and mutable)
+                or any(
+                    isinstance(value, bool)
+                    or not isinstance(value, int | float)
+                    or not math.isfinite(value)
+                    for value in defaults
+                )
+            ):
+                raise ArtifactError(
+                    f"{relative}.model_parameters[{index}] is noncanonical"
+                )
+            parameter_names.add(name)
+        helicity_count = execution.physical_helicity_count
+        color_flow_count = execution.physical_color_flow_count
+        if helicity_count is None or color_flow_count is None:  # pragma: no cover
+            raise ArtifactError("on-the-fly execution has no selector census")
+        contracted_color = process.get("color_accuracy") in {"nlc", "full"}
+        return _PhysicsInspection(
+            physical_helicities=helicity_count,
+            computed_helicities=helicity_count,
+            physical_color_components=color_flow_count,
+            computed_color_components=color_flow_count,
+            helicity_coverage="complete",
+            color_coverage="contracted" if contracted_color else "complete",
+            selector_provenance="on-the-fly-compact-seed",
+            helicity_runtime_contract="complete-reusable",
+            color_flow_runtime_contract=(
+                None if contracted_color else "complete-reusable"
+            ),
+            lc_physical_sector_count=(None if contracted_color else color_flow_count),
+        )
+    helicities = _sequence(physics.get("helicities"), f"{relative}.helicities")
+    colors = _sequence(physics.get("color_components"), f"{relative}.color_components")
+    coverage = _mapping(physics.get("coverage"), f"{relative}.coverage")
+
+    computed_helicities = sum(
+        _computed(item, f"{relative}.helicities[{index}]")
+        for index, item in enumerate(helicities)
+    )
+    computed_colors = sum(
+        _computed(item, f"{relative}.color_components[{index}]")
+        for index, item in enumerate(colors)
+    )
+    selector_fields: dict[str, object] = {}
+    extensions_raw = physics.get("extensions")
+    extensions = (
+        {}
+        if extensions_raw is None
+        else _mapping(extensions_raw, f"{relative}.extensions")
+    )
+    selectors_raw = extensions.get("runtime_selectors")
+    if selectors_raw is not None:
+        selectors = _mapping(selectors_raw, f"{relative}.extensions.runtime_selectors")
+        if selectors.get("kind") != "pyamplicol-runtime-selectors":
+            raise ArtifactError(
+                f"{relative}.extensions.runtime_selectors.kind is unsupported"
+            )
+        if selectors.get("contract_version") != 1:
+            raise ArtifactError(
+                f"{relative}.extensions.runtime_selectors.contract_version must be 1"
+            )
+        selector_fields["selector_provenance"] = _string(
+            selectors.get("provenance"),
+            f"{relative}.extensions.runtime_selectors.provenance",
+        )
+        axes = _mapping(
+            selectors.get("axes"),
+            f"{relative}.extensions.runtime_selectors.axes",
+        )
+        helicity_axis = _mapping(
+            axes.get("helicity"),
+            f"{relative}.extensions.runtime_selectors.axes.helicity",
+        )
+        color_axis = _mapping(
+            axes.get("color_flow"),
+            f"{relative}.extensions.runtime_selectors.axes.color_flow",
+        )
+        helicity_generation_coverage = _string(
+            helicity_axis.get("generation_coverage"),
+            f"{relative}.extensions.runtime_selectors.axes.helicity."
+            "generation_coverage",
+        )
+        color_generation_coverage = _string(
+            color_axis.get("generation_coverage"),
+            f"{relative}.extensions.runtime_selectors.axes.color_flow."
+            "generation_coverage",
+        )
+        helicity_selection = _source_helicity_selection(
+            helicity_axis.get("generation_selection"),
+            f"{relative}.extensions.runtime_selectors.axes.helicity."
+            "generation_selection",
+        )
+        color_selection = _color_sector_selection(
+            color_axis.get("generation_selection"),
+            f"{relative}.extensions.runtime_selectors.axes.color_flow."
+            "generation_selection",
+        )
+        selector_fields["selected_source_helicities"] = helicity_selection
+        selector_fields["selected_color_sector_ids"] = color_selection
+        selector_fields["helicity_runtime_contract"] = _string(
+            helicity_axis.get("runtime_contract"),
+            f"{relative}.extensions.runtime_selectors.axes.helicity.runtime_contract",
+        )
+        selector_fields["color_flow_runtime_contract"] = _string(
+            color_axis.get("runtime_contract"),
+            f"{relative}.extensions.runtime_selectors.axes.color_flow.runtime_contract",
+        )
+        selector_fields["generation_specialized_axes"] = tuple(
+            _string(
+                value,
+                f"{relative}.extensions.runtime_selectors."
+                f"generation_specialized_axes[{index}]",
+            )
+            for index, value in enumerate(
+                _sequence(
+                    selectors.get("generation_specialized_axes"),
+                    f"{relative}.extensions.runtime_selectors."
+                    "generation_specialized_axes",
+                )
+            )
+        )
+        helicity_contract = cast(str, selector_fields["helicity_runtime_contract"])
+        color_contract = cast(str, selector_fields["color_flow_runtime_contract"])
+        specialized_axes = cast(
+            tuple[str, ...], selector_fields["generation_specialized_axes"]
+        )
+        expected_specialized_axes = (
+            *(("helicity",) if helicity_contract == "generation-specialized" else ()),
+            *(("color_flow",) if color_contract == "generation-specialized" else ()),
+        )
+        if helicity_contract not in {
+            "complete-reusable",
+            "generation-specialized",
+        }:
+            raise ArtifactError("unsupported helicity runtime-selector contract")
+        if color_contract not in {
+            "complete-reusable",
+            "generation-specialized",
+            "contracted-color",
+        }:
+            raise ArtifactError("unsupported color-flow runtime-selector contract")
+        if helicity_generation_coverage != str(coverage.get("helicities")):
+            raise ArtifactError(
+                "helicity selector generation coverage disagrees with physics coverage"
+            )
+        if color_generation_coverage != str(coverage.get("color")):
+            raise ArtifactError(
+                "color-flow selector generation coverage disagrees with "
+                "physics coverage"
+            )
+        if specialized_axes != expected_specialized_axes:
+            raise ArtifactError(
+                "runtime-selector specialized axes disagree with axis contracts"
+            )
+        if (helicity_contract == "complete-reusable") != (
+            helicity_generation_coverage == "complete" and not helicity_selection
+        ):
+            raise ArtifactError(
+                "helicity runtime contract disagrees with generation selection"
+            )
+        if color_contract == "complete-reusable" and (
+            color_generation_coverage != "complete" or color_selection
+        ):
+            raise ArtifactError(
+                "color-flow reusable contract carries a generation specialization"
+            )
+        if color_contract == "generation-specialized" and (
+            color_generation_coverage != "selected" or not color_selection
+        ):
+            raise ArtifactError(
+                "color-flow specialized contract lacks an exact sector selection"
+            )
+        if color_contract == "contracted-color" and (
+            color_generation_coverage != "contracted" or color_selection
+        ):
+            raise ArtifactError(
+                "contracted-color runtime contract carries LC selection metadata"
+            )
+        legacy_helicity_selection = _source_helicity_selection(
+            extensions.get("selected_source_helicities", {}),
+            f"{relative}.extensions.selected_source_helicities",
+        )
+        if legacy_helicity_selection != helicity_selection:
+            raise ArtifactError(
+                "runtime-selector helicity selection disagrees with physics provenance"
+            )
+        recurrence_raw = selectors.get("helicity_recurrence")
+        if recurrence_raw is not None:
+            recurrence = _mapping(
+                recurrence_raw,
+                f"{relative}.extensions.runtime_selectors.helicity_recurrence",
+            )
+            selector_fields["helicity_recurrence_status"] = _string(
+                recurrence.get("status"),
+                f"{relative}.extensions.runtime_selectors.helicity_recurrence.status",
+            )
+            proof_counts = _mapping(
+                recurrence.get("proof_counts"),
+                f"{relative}.extensions.runtime_selectors."
+                "helicity_recurrence.proof_counts",
+            )
+            count_fields = {
+                "helicity_optimized_class_count": ("optimized_recurrence_class_count"),
+                "helicity_optimized_current_count": "optimized_current_count",
+                "helicity_residual_current_count": "residual_current_count",
+                "helicity_optimized_amplitude_class_count": (
+                    "optimized_amplitude_class_count"
+                ),
+                "helicity_residual_amplitude_count": "residual_amplitude_count",
+            }
+            for field, key in count_fields.items():
+                selector_fields[field] = _optional_nonnegative_integer(
+                    proof_counts.get(key),
+                    f"{relative}.extensions.runtime_selectors."
+                    f"helicity_recurrence.proof_counts.{key}",
+                )
+            selector_fields["helicity_materialized_current_count"] = (
+                _optional_nonnegative_integer(
+                    recurrence.get("materialized_current_count"),
+                    f"{relative}.extensions.runtime_selectors."
+                    "helicity_recurrence.materialized_current_count",
+                )
+            )
+            selector_fields["helicity_materialized_amplitude_count"] = (
+                _optional_nonnegative_integer(
+                    recurrence.get("materialized_amplitude_count"),
+                    f"{relative}.extensions.runtime_selectors."
+                    "helicity_recurrence.materialized_amplitude_count",
+                )
+            )
+
+    replay_raw = extensions.get("lc_topology_replay")
+    if replay_raw is not None:
+        replay = _mapping(replay_raw, f"{relative}.extensions.lc_topology_replay")
+        selector_fields.update(
+            {
+                "lc_physical_sector_count": len(
+                    _sequence(
+                        replay.get("physical_sector_ids"),
+                        f"{relative}.extensions.lc_topology_replay.physical_sector_ids",
+                    )
+                ),
+                "lc_materialized_sector_count": len(
+                    _sequence(
+                        replay.get("materialized_sector_ids"),
+                        f"{relative}.extensions.lc_topology_replay."
+                        "materialized_sector_ids",
+                    )
+                ),
+                "lc_replayed_sector_count": _integer(
+                    replay.get("replayed_sector_count"),
+                    f"{relative}.extensions.lc_topology_replay.replayed_sector_count",
+                    minimum=0,
+                ),
+                "lc_residual_sector_count": len(
+                    _sequence(
+                        replay.get("residual_sector_ids"),
+                        f"{relative}.extensions.lc_topology_replay.residual_sector_ids",
+                    )
+                ),
+            }
+        )
+
+    return _PhysicsInspection(
+        physical_helicities=len(helicities),
+        computed_helicities=computed_helicities,
+        physical_color_components=len(colors),
+        computed_color_components=computed_colors,
+        helicity_coverage=str(coverage.get("helicities", "unknown")),
+        color_coverage=str(coverage.get("color", "unknown")),
+        **selector_fields,
+    )
+
+
+def _process_inspection(
+    manifest: ArtifactManifest,
+    process: Mapping[str, object],
+    execution: _ExecutionInspection,
+) -> ArtifactProcessInspection:
+    process_id = str(process["id"])
+    lc_flow_layout: str | None = None
+    if str(process["color_accuracy"]) == "lc":
+        if execution.execution_mode == "on-the-fly":
+            lc_flow_layout = "compact/query-local"
+        else:
+            lc_flow_layout = "topology-replay"
+            generation = manifest.extensions.get("generation")
+            if isinstance(generation, Mapping):
+                concrete = generation.get("concrete_processes")
+                if isinstance(concrete, Sequence) and not isinstance(
+                    concrete, (str, bytes)
+                ):
+                    for record in concrete:
+                        if (
+                            not isinstance(record, Mapping)
+                            or record.get("id") != process_id
+                        ):
+                            continue
+                        filters = record.get("filters")
+                        if not isinstance(filters, Mapping):
+                            continue
+                        candidate = filters.get("lc_flow_layout")
+                        if candidate is not None:
+                            lc_flow_layout = str(candidate)
+                    if lc_flow_layout not in {"topology-replay", "all-flow-union"}:
+                        raise ArtifactError(
+                            f"process {process_id}.filters.lc_flow_layout is "
+                            "unsupported"
+                        )
+    aliases: list[ArtifactAliasInspection] = []
+    for index, raw_alias in enumerate(
+        _sequence(process.get("aliases"), f"process {process_id}.aliases")
+    ):
+        alias = _mapping(raw_alias, f"process {process_id}.aliases[{index}]")
+        aliases.append(
+            ArtifactAliasInspection(
+                id=str(alias["id"]),
+                expression=str(alias["expression"]),
+                representative_id=process_id,
+                external_pdgs=tuple(
+                    cast(int, value)
+                    for value in _sequence(
+                        alias.get("external_pdgs"),
+                        f"process {process_id}.aliases[{index}].external_pdgs",
+                    )
+                ),
+            )
+        )
+    physics = _physics_inspection(manifest, process, execution)
+    union_sector_count = (
+        physics.physical_color_components
+        if lc_flow_layout == "all-flow-union"
+        else None
+    )
+    return ArtifactProcessInspection(
+        id=process_id,
+        expression=str(process["expression"]),
+        color_accuracy=str(process["color_accuracy"]),
+        external_pdgs=tuple(
+            cast(int, value)
+            for value in _sequence(
+                process.get("external_pdgs"), f"process {process_id}.external_pdgs"
+            )
+        ),
+        default=process_id == manifest.default_process_id,
+        physical_helicities=physics.physical_helicities,
+        computed_helicities=physics.computed_helicities,
+        physical_color_components=physics.physical_color_components,
+        computed_color_components=physics.computed_color_components,
+        helicity_coverage=physics.helicity_coverage,
+        color_coverage=physics.color_coverage,
+        aliases=tuple(aliases),
+        selector_provenance=physics.selector_provenance,
+        helicity_runtime_contract=physics.helicity_runtime_contract,
+        color_flow_runtime_contract=physics.color_flow_runtime_contract,
+        generation_specialized_axes=physics.generation_specialized_axes,
+        selected_source_helicities=physics.selected_source_helicities,
+        selected_color_sector_ids=physics.selected_color_sector_ids,
+        helicity_recurrence_status=physics.helicity_recurrence_status,
+        helicity_optimized_class_count=physics.helicity_optimized_class_count,
+        helicity_optimized_current_count=physics.helicity_optimized_current_count,
+        helicity_residual_current_count=physics.helicity_residual_current_count,
+        helicity_optimized_amplitude_class_count=(
+            physics.helicity_optimized_amplitude_class_count
+        ),
+        helicity_residual_amplitude_count=(physics.helicity_residual_amplitude_count),
+        helicity_materialized_current_count=(
+            physics.helicity_materialized_current_count
+        ),
+        helicity_materialized_amplitude_count=(
+            physics.helicity_materialized_amplitude_count
+        ),
+        lc_physical_sector_count=physics.lc_physical_sector_count,
+        lc_materialized_sector_count=physics.lc_materialized_sector_count,
+        lc_replayed_sector_count=physics.lc_replayed_sector_count,
+        lc_residual_sector_count=physics.lc_residual_sector_count,
+        lc_flow_layout=lc_flow_layout,
+        lc_union_sector_count=union_sector_count,
+        execution_mode=execution.execution_mode,
+        prepared_backend=execution.prepared_backend,
+        prepared_kernel_count=execution.prepared_kernel_count,
+        referenced_kernel_count=execution.referenced_kernel_count,
+        invocation_count=execution.invocation_count,
+        attachment_count=execution.attachment_count,
+        evaluation_alias_count=execution.evaluation_alias_count,
+        maximum_fanout=execution.maximum_fanout,
+        finalization_count=execution.finalization_count,
+        closure_count=execution.closure_count,
+        selector_closure_available=execution.selector_closure_available,
+        selector_domain_count=execution.selector_domain_count,
+        selector_domain_membership_count=execution.selector_domain_membership_count,
+        requested_point_tile_size=execution.requested_point_tile_size,
+        effective_point_tile_size=execution.effective_point_tile_size,
+        requested_query_construction_threads=(
+            execution.requested_query_construction_threads
+        ),
+        workspace_limit_bytes=execution.workspace_limit_bytes,
+        workspace_bytes=execution.workspace_bytes,
+        arena_semantic_component_count=execution.arena_semantic_component_count,
+        arena_component_count=execution.arena_component_count,
+        arena_component_reuse_count=execution.arena_component_reuse_count,
+        momentum_form_count=execution.momentum_form_count,
+        direct_source_row_count=execution.direct_source_row_count,
+        direct_contribution_row_count=execution.direct_contribution_row_count,
+        direct_finalization_row_count=execution.direct_finalization_row_count,
+        direct_closure_row_count=execution.direct_closure_row_count,
+        direct_row_group_count=execution.direct_row_group_count,
+        recurrence_color_accuracy=execution.recurrence_color_accuracy,
+        recurrence_color_storage=execution.recurrence_color_storage,
+        recurrence_color_sector_count=execution.recurrence_color_sector_count,
+        recurrence_color_active_sector_count=(
+            execution.recurrence_color_active_sector_count
+        ),
+        recurrence_color_component_count=execution.recurrence_color_component_count,
+        recurrence_color_group_count=execution.recurrence_color_group_count,
+        recurrence_color_destination_count=(
+            execution.recurrence_color_destination_count
+        ),
+        recurrence_color_entry_count=execution.recurrence_color_entry_count,
+        recurrence_color_logical_entry_count=(
+            execution.recurrence_color_logical_entry_count
+        ),
+        recurrence_color_factorization_kind=(
+            execution.recurrence_color_factorization_kind
+        ),
+        recurrence_color_factorization_rank=(
+            execution.recurrence_color_factorization_rank
+        ),
+        recurrence_color_factorization_coset_count=(
+            execution.recurrence_color_factorization_coset_count
+        ),
+        recurrence_color_contraction_method=(
+            execution.recurrence_color_contraction_method
+        ),
+        recurrence_color_fft_degree=execution.recurrence_color_fft_degree,
+        recurrence_color_fft_channel_count=(
+            execution.recurrence_color_fft_channel_count
+        ),
+        recurrence_color_fft_covered_local_group_count=(
+            execution.recurrence_color_fft_covered_local_group_count
+        ),
+        recurrence_color_direct_residual_group_count=(
+            execution.recurrence_color_direct_residual_group_count
+        ),
+        recurrence_color_direct_residual_entry_count=(
+            execution.recurrence_color_direct_residual_entry_count
+        ),
+        recurrence_color_raw_kernel_bytes=(execution.recurrence_color_raw_kernel_bytes),
+        recurrence_color_transformed_kernel_bytes=(
+            execution.recurrence_color_transformed_kernel_bytes
+        ),
+        recurrence_color_fft_capability=(execution.recurrence_color_fft_capability),
+        packed_input_bytes=execution.packed_input_bytes,
+        packed_output_bytes=execution.packed_output_bytes,
+        scatter_bytes=execution.scatter_bytes,
+        native_profile_phases=execution.native_profile_phases,
+    )
+
+
+def _group_member_inspection(
+    member: GroupMember,
+) -> ArtifactProcessGroupMemberInspection:
+    return ArtifactProcessGroupMemberInspection(
+        id=member.process_id,
+        process=member.expression,
+        pdgs=member.pdgs,
+        initial_count=member.initial_count,
+        factor=str(member.factor),
+        permutation=member.permutation,
+        conjugated=member.conjugated,
+        basis=str(member.basis),
+        generated=member.generated,
+        warning=member.warning,
+    )
+
+
+def _groups_inspection(
+    group_map: ProcessGroupMap,
+    *,
+    stored: bool,
+    process_ids: Sequence[str] = (),
+) -> ArtifactProcessGroupsInspection:
+    """Return ``group_map`` with its groups in ``process_ids`` order."""
+
+    order = {process_id: index for index, process_id in enumerate(process_ids)}
+    groups = sorted(
+        group_map.groups.values(),
+        key=lambda group: (
+            order.get(group.representative.process_id, len(order)),
+            group.representative.process_id,
+        ),
+    )
+    return ArtifactProcessGroupsInspection(
+        stored=stored,
+        groups=tuple(
+            ArtifactProcessGroupInspection(
+                representative_id=group.representative.process_id,
+                representative=group.representative.expression,
+                members=tuple(
+                    _group_member_inspection(member) for member in group.members
+                ),
+            )
+            for group in groups
+        ),
+        analyses=tuple(dict(analysis) for analysis in group_map.analyses),
+    )
+
+
+def _process_groups_inspection(
+    manifest: ArtifactManifest,
+) -> ArtifactProcessGroupsInspection:
+    """Read the stored process-group map; without one, each process is a group."""
+
+    group_map = read_process_groups(manifest.root)
+    stored = group_map is not None
+    if group_map is None:
+        group_map = initial_process_groups(
+            (
+                str(process["id"]),
+                str(process["expression"]),
+                cast(Sequence[int], process["external_pdgs"]),
+            )
+            for process in manifest.processes
+        )
+    return _groups_inspection(
+        group_map,
+        stored=stored,
+        process_ids=[str(process["id"]) for process in manifest.processes],
+    )
+
+
+def stored_process_groups(
+    artifact: str | Path,
+) -> ArtifactProcessGroupsInspection | None:
+    """Return the artifact's stored process-group map, or ``None`` without one.
+
+    Unlike :func:`inspect_artifact`, this reads only ``artifact.json`` and
+    ``process-groups.json`` and verifies no payload.
+    """
+
+    group_map = read_process_groups(artifact)
+    return None if group_map is None else _groups_inspection(group_map, stored=True)
+
+
+def process_group_selection(
+    artifact: str | Path,
+    process_id: str,
+    *,
+    permutation: Sequence[int] | None = None,
+) -> ArtifactProcessGroupSelection | None:
+    """Return how ``process_id`` relates to its stored process group.
+
+    Returns ``None`` when the artifact stores no map or the process is alone in
+    its group. ``permutation`` is the runtime's external permutation of the
+    requested leg order: from the representative's legs for a routed member,
+    whose runtime already composes the stored relation, and from the
+    process's own legs otherwise. The returned permutation relates the
+    representative to the requested leg order.
+    """
+
+    group_map = read_process_groups(artifact)
+    group = None if group_map is None else group_map.group_of(process_id)
+    if group is None or len(group.members) == 1:
+        return None
+    member = next(item for item in group.members if item.process_id == process_id)
+    representative = group.representative
+    relation_permutation = member.permutation
+    if permutation is not None:
+        requested = tuple(int(index) for index in permutation)
+        relation_permutation = (
+            tuple(requested[index] for index in member.permutation)
+            if member.generated
+            else requested
+        )
+    if member.process_id == representative.process_id:
+        role = "representative"
+    elif member.generated:
+        role = "generated member"
+    else:
+        role = "routed member"
+    return ArtifactProcessGroupSelection(
+        process_id=member.process_id,
+        role=role,
+        representative_id=representative.process_id,
+        representative=representative.expression,
+        factor=str(member.factor),
+        permutation=relation_permutation,
+        conjugated=member.conjugated,
+        basis=str(member.basis),
+        warning=member.warning,
+        group_size=len(group.members),
+        routed_count=sum(not item.generated for item in group.members),
+        conjugated_count=sum(item.conjugated for item in group.members),
+    )
+
+
+def _reject_retired_recurrence_metadata(artifact: str | Path) -> None:
+    """Reject pre-release recurrence artifacts before payload verification."""
+
+    root = Path(artifact).expanduser().resolve(strict=True)
+    manifest_path = root / MANIFEST_NAME
+    try:
+        raw = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        # The strict manifest loader below owns ordinary format diagnostics.
+        return
+    if not isinstance(raw, Mapping):
+        return
+    capabilities: set[str] = set()
+    runtime = raw.get("runtime")
+    if isinstance(runtime, Mapping):
+        declared = runtime.get("required_runtime_capabilities")
+        if isinstance(declared, Sequence) and not isinstance(declared, (str, bytes)):
+            capabilities.update(str(value) for value in declared)
+    processes = raw.get("processes")
+    if isinstance(processes, Sequence) and not isinstance(processes, (str, bytes)):
+        for process in processes:
+            if not isinstance(process, Mapping):
+                continue
+            declared = process.get("required_runtime_capabilities")
+            if isinstance(declared, Sequence) and not isinstance(
+                declared, (str, bytes)
+            ):
+                capabilities.update(str(value) for value in declared)
+    if _RETIRED_RECURRENCE_RUNTIME_CAPABILITY in capabilities:
+        raise ArtifactError(
+            "this pre-release recurrence artifact uses the retired packet ABI; "
+            "regenerate it with the current pyAmpliCol direct-arena recurrence mode"
+        )
+
+
+def inspect_artifact(artifact: str | Path) -> ArtifactInspection:
+    """Validate and summarize one generated artifact without loading evaluators."""
+
+    _reject_retired_recurrence_metadata(artifact)
+    manifest = load_manifest(artifact)
+    target = _mapping(manifest.producer["target"], "producer.target")
+    model = manifest.model
+    runtime = manifest.runtime
+    execution_paths = _execution_paths(manifest)
+    processes = tuple(
+        _process_inspection(
+            manifest,
+            process,
+            _execution_inspection(
+                manifest,
+                execution_paths[str(process["id"])],
+                _sequence(
+                    process.get("required_runtime_capabilities"),
+                    f"process {process['id']} required runtime capabilities",
+                ),
+                process=process,
+            ),
+        )
+        for process in manifest.processes
+    )
+    dependencies = tuple(
+        ArtifactDependencyInspection(
+            name=str(dependency["name"]),
+            version=str(dependency["version"]),
+            license=str(dependency["license"]),
+            source=str(dependency["source"]),
+        )
+        for dependency in manifest.dependencies
+    )
+    restriction = model.get("restriction")
+    container_path: str | None = None
+    container_abi: str | None = None
+    container_member_count: int | None = None
+    container_unpacked_size: int | None = None
+    container_raw = manifest.extensions.get("evaluator_payload_container")
+    if container_raw is not None:
+        container = _mapping(
+            container_raw,
+            "extensions.evaluator_payload_container",
+        )
+        if (
+            container.get("kind") != "pyamplicol-evaluator-payload-container"
+            or container.get("schema_version") != 1
+            or container.get("storage_abi") != "pacbin-v1"
+        ):
+            raise ArtifactError("unsupported evaluator payload container contract")
+        container_path = _string(
+            container.get("path"),
+            "extensions.evaluator_payload_container.path",
+        )
+        container_abi = _string(
+            container.get("storage_abi"),
+            "extensions.evaluator_payload_container.storage_abi",
+        )
+        container_member_count = _integer(
+            container.get("member_count"),
+            "extensions.evaluator_payload_container.member_count",
+            minimum=0,
+        )
+        container_unpacked_size = _integer(
+            container.get("unpacked_size_bytes"),
+            "extensions.evaluator_payload_container.unpacked_size_bytes",
+            minimum=0,
+        )
+        matching = tuple(
+            payload for payload in manifest.payloads if payload.path == container_path
+        )
+        if len(matching) != 1 or matching[0].role != "evaluator-state":
+            raise ArtifactError(
+                "evaluator payload container is not one declared "
+                "evaluator-state payload"
+            )
+    return ArtifactInspection(
+        kind="pyamplicol-artifact-inspection",
+        path=manifest.root,
+        artifact_kind=manifest.kind,
+        artifact_id=manifest.artifact_id,
+        created_utc=manifest.created_utc,
+        producer_version=str(manifest.producer["version"]),
+        target=str(target["triple"]),
+        cpu_features=tuple(
+            str(value)
+            for value in _sequence(
+                target.get("cpu_features"), "producer.target.cpu_features"
+            )
+        ),
+        model_name=str(model["name"]),
+        model_source=str(model["source_kind"]),
+        model_restriction=None if restriction is None else str(restriction),
+        default_process_id=manifest.default_process_id,
+        runtime_engine=str(runtime["engine"]),
+        runtime_version=str(runtime["engine_version"]),
+        runtime_capabilities=tuple(
+            str(value)
+            for value in _sequence(
+                runtime.get("required_runtime_capabilities"),
+                "runtime.required_runtime_capabilities",
+            )
+        ),
+        payload_count=len(manifest.payloads),
+        payload_size_bytes=sum(payload.size_bytes for payload in manifest.payloads),
+        integrity="verified",
+        processes=processes,
+        dependencies=dependencies,
+        physical_file_count=len(manifest.payloads) + 1,
+        evaluator_container_path=container_path,
+        evaluator_container_abi=container_abi,
+        evaluator_container_member_count=container_member_count,
+        evaluator_container_unpacked_size_bytes=container_unpacked_size,
+        process_groups=_process_groups_inspection(manifest),
+    )
+
+
+__all__ = [
+    "ArtifactAliasInspection",
+    "ArtifactDependencyInspection",
+    "ArtifactInspection",
+    "ArtifactProcessGroupInspection",
+    "ArtifactProcessGroupMemberInspection",
+    "ArtifactProcessGroupSelection",
+    "ArtifactProcessGroupsInspection",
+    "ArtifactProcessInspection",
+    "inspect_artifact",
+    "process_group_selection",
+    "stored_process_groups",
+]
diff --git a/pyamplicol/src/pyamplicol/artifacts/manifest.py b/pyamplicol/src/pyamplicol/artifacts/manifest.py
new file mode 100644
index 0000000000..6b430c636a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/manifest.py
@@ -0,0 +1,1011 @@
+# SPDX-License-Identifier: 0BSD
+"""Typed schema-v3 manifest loading and payload validation."""
+
+from __future__ import annotations
+
+import importlib
+import json
+import re
+import struct
+import sys
+from collections.abc import Mapping, Sequence, Set
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from types import MappingProxyType
+from typing import Any, Literal, cast
+
+from pyamplicol._internal.versions import (
+    KNOWN_EVALUATOR_RUNTIME_CAPABILITIES,
+    SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+    SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+    verify_native_module,
+)
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+
+from .security import (
+    confined_path,
+    executable_bit,
+    normalize_relative_path,
+    sha256_file,
+)
+
+MANIFEST_NAME = "artifact.json"
+SCHEMA_VERSION = 3
+ARTIFACT_IDENTITY_EXTENSION = "artifact_identity"
+ARTIFACT_IDENTITY_KIND = "pyamplicol-runtime-payload-identity"
+ARTIFACT_IDENTITY_SCHEMA_VERSION = 1
+PORTABLE_64LE_TARGET = "portable-64le"
+_SHA256 = re.compile(r"^[a-f0-9]{64}$")
+_GIT_REVISION = re.compile(r"^[a-f0-9]{40}$")
+_PUBLIC_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:+,~-]{0,254}$")
+_CPU_FEATURE_ID = re.compile(r"^[a-z0-9][a-z0-9.-]*$")
+_SUPPORTED_ARTIFACT_TARGETS = frozenset(
+    {
+        "aarch64-apple-darwin",
+        "x86_64-apple-darwin",
+        "x86_64-unknown-linux-gnu",
+    }
+)
+_TARGET_SPECIFIC_EVALUATOR_RUNTIME_CAPABILITIES = frozenset(
+    {
+        SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+        SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+        SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+    }
+)
+_EXECUTABLE_ROLES = {"api-source", "api-build-file", "evaluator-state"}
+_PAYLOAD_ROLES = {
+    "configuration-requested",
+    "configuration-effective",
+    "compiled-model",
+    "runtime-physics",
+    "evaluator-manifest",
+    "evaluator-state",
+    "model-parameters",
+    "validation-momenta",
+    "structural-source-proof",
+    "api-source",
+    "api-build-file",
+    "sdk-metadata",
+    "process-groups",
+}
+_RUNTIME_IDENTITY_PAYLOAD_ROLES = frozenset(
+    {
+        "compiled-model",
+        "evaluator-manifest",
+        "evaluator-state",
+        "model-parameters",
+        "runtime-physics",
+    }
+)
+
+
+def artifact_identity_extension() -> dict[str, object]:
+    """Return the sole supported artifact-ID interpretation contract."""
+
+    return {
+        "kind": ARTIFACT_IDENTITY_KIND,
+        "schema_version": ARTIFACT_IDENTITY_SCHEMA_VERSION,
+    }
+
+
+def _validate_artifact_identity_extension(
+    extensions: Mapping[str, object],
+) -> None:
+    raw = extensions.get(ARTIFACT_IDENTITY_EXTENSION)
+    if raw is None:
+        raise CompatibilityError(
+            "artifact predates the required runtime-payload identity contract; "
+            "regenerate it with the current pyAmpliCol"
+        )
+    policy = _mapping(raw, f"extensions.{ARTIFACT_IDENTITY_EXTENSION}")
+    _keys(
+        policy,
+        f"extensions.{ARTIFACT_IDENTITY_EXTENSION}",
+        required={"kind", "schema_version"},
+    )
+    if (
+        policy.get("kind") != ARTIFACT_IDENTITY_KIND
+        or policy.get("schema_version") != ARTIFACT_IDENTITY_SCHEMA_VERSION
+    ):
+        raise CompatibilityError(
+            "artifact uses an unsupported artifact identity contract; "
+            "regenerate it with the current pyAmpliCol"
+        )
+
+
+def _keys(
+    value: Mapping[str, object],
+    context: str,
+    *,
+    required: Set[str],
+    optional: Set[str] = frozenset(),
+) -> None:
+    missing = required - value.keys()
+    unknown = value.keys() - required - optional
+    if missing:
+        raise ArtifactError(
+            f"{context} is missing fields: {', '.join(sorted(missing))}"
+        )
+    if unknown:
+        raise ArtifactError(
+            f"{context} has unknown fields: {', '.join(sorted(unknown))}"
+        )
+
+
+def _mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise ArtifactError(f"{context} must be an object")
+    if not all(isinstance(key, str) for key in value):
+        raise ArtifactError(f"{context} keys must be strings")
+    return value
+
+
+def _sequence(value: object, context: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} must be an array")
+    return value
+
+
+def _string(value: object, context: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise ArtifactError(f"{context} must be a non-empty string")
+    return value
+
+
+def _public_id(value: object, context: str) -> str:
+    identifier = _string(value, context)
+    if _PUBLIC_ID.fullmatch(identifier) is None:
+        raise ArtifactError(f"{context} is not a valid public identifier")
+    return identifier
+
+
+def _string_array(value: object, context: str) -> tuple[str, ...]:
+    items = tuple(_sequence(value, context))
+    result = tuple(
+        _string(item, f"{context}[{index}]") for index, item in enumerate(items)
+    )
+    if len(set(result)) != len(result):
+        raise ArtifactError(f"{context} must not contain duplicates")
+    return result
+
+
+def _runtime_capabilities(value: object, context: str) -> tuple[str, ...]:
+    result = _string_array(value, context)
+    if not result:
+        raise ArtifactError(f"{context} must contain at least one capability")
+    if result != tuple(sorted(result)):
+        raise ArtifactError(f"{context} must be sorted")
+    unknown = set(result) - KNOWN_EVALUATOR_RUNTIME_CAPABILITIES
+    if unknown:
+        raise ArtifactError(
+            f"{context} contains unsupported capabilities: "
+            + ", ".join(sorted(unknown))
+        )
+    return result
+
+
+def _sha256(value: object, context: str) -> str:
+    digest = _string(value, context)
+    if _SHA256.fullmatch(digest) is None:
+        raise ArtifactError(f"{context} must be a lowercase SHA-256 digest")
+    return digest
+
+
+def _integer(value: object, context: str, *, minimum: int = 0) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < minimum:
+        raise ArtifactError(f"{context} must be an integer >= {minimum}")
+    return value
+
+
+def _target(value: object, context: str) -> Mapping[str, object]:
+    raw = _mapping(value, context)
+    _keys(raw, context, required={"triple", "cpu_features"})
+    cpu_features = _string_array(raw.get("cpu_features"), f"{context}.cpu_features")
+    if cpu_features != tuple(sorted(cpu_features)):
+        raise ArtifactError(f"{context}.cpu_features must be sorted")
+    invalid = tuple(
+        feature
+        for feature in cpu_features
+        if _CPU_FEATURE_ID.fullmatch(feature) is None
+    )
+    if invalid:
+        raise ArtifactError(
+            f"{context}.cpu_features contains non-canonical IDs: "
+            + ", ".join(repr(feature) for feature in invalid)
+        )
+    return MappingProxyType(
+        {
+            "triple": _string(raw.get("triple"), f"{context}.triple"),
+            "cpu_features": cpu_features,
+        }
+    )
+
+
+def _producer(value: object) -> Mapping[str, object]:
+    raw = _mapping(value, "producer")
+    _keys(
+        raw,
+        "producer",
+        required={"distribution", "version", "versions", "target"},
+        optional={"git_revision", "native_build_inputs_sha256"},
+    )
+    if raw.get("distribution") != "pyamplicol":
+        raise ArtifactError("producer.distribution must be 'pyamplicol'")
+    versions = _mapping(raw.get("versions"), "producer.versions")
+    version_fields = {
+        "python_api",
+        "toml",
+        "compiled_model",
+        "process_artifact",
+        "runtime_physics",
+        "symbolica_serialization",
+        "c_abi",
+    }
+    _keys(versions, "producer.versions", required=version_fields)
+    normalized_versions: dict[str, object] = {
+        name: _integer(versions.get(name), f"producer.versions.{name}", minimum=1)
+        for name in version_fields - {"symbolica_serialization"}
+    }
+    if normalized_versions["process_artifact"] != 3:
+        raise ArtifactError("producer.versions.process_artifact must be 3")
+    if normalized_versions["runtime_physics"] != 1:
+        raise ArtifactError("producer.versions.runtime_physics must be 1")
+    normalized_versions["symbolica_serialization"] = _string(
+        versions.get("symbolica_serialization"),
+        "producer.versions.symbolica_serialization",
+    )
+    result: dict[str, object] = {
+        "distribution": "pyamplicol",
+        "version": _string(raw.get("version"), "producer.version"),
+        "versions": MappingProxyType(normalized_versions),
+        "target": _target(raw.get("target"), "producer.target"),
+    }
+    revision = raw.get("git_revision")
+    if revision is not None:
+        revision_value = _string(revision, "producer.git_revision")
+        if _GIT_REVISION.fullmatch(revision_value) is None:
+            raise ArtifactError("producer.git_revision must be a Git SHA-1")
+        result["git_revision"] = revision_value
+    native_inputs = raw.get("native_build_inputs_sha256")
+    if native_inputs is not None:
+        native_inputs_value = _string(
+            native_inputs,
+            "producer.native_build_inputs_sha256",
+        )
+        if _SHA256.fullmatch(native_inputs_value) is None:
+            raise ArtifactError("producer.native_build_inputs_sha256 must be a SHA-256")
+        result["native_build_inputs_sha256"] = native_inputs_value
+    return MappingProxyType(result)
+
+
+def _model(value: object) -> Mapping[str, object]:
+    raw = _mapping(value, "model")
+    _keys(
+        raw,
+        "model",
+        required={"name", "source_kind", "content_sha256", "compiled_schema_version"},
+        optional={"restriction"},
+    )
+    source_kind = raw.get("source_kind")
+    if source_kind not in {
+        "built-in-sm",
+        "built-in-sm-heft",
+        "ufo",
+        "ufo-json",
+        "compiled-model",
+    }:
+        raise ArtifactError(f"unsupported model.source_kind {source_kind!r}")
+    result: dict[str, object] = {
+        "name": _string(raw.get("name"), "model.name"),
+        "source_kind": source_kind,
+        "content_sha256": _sha256(raw.get("content_sha256"), "model.content_sha256"),
+        "compiled_schema_version": _integer(
+            raw.get("compiled_schema_version"),
+            "model.compiled_schema_version",
+            minimum=1,
+        ),
+    }
+    if "restriction" in raw:
+        restriction = raw.get("restriction")
+        result["restriction"] = (
+            None if restriction is None else _string(restriction, "model.restriction")
+        )
+    return MappingProxyType(result)
+
+
+def _configuration(value: object) -> Mapping[str, object]:
+    raw = _mapping(value, "configuration")
+    _keys(
+        raw,
+        "configuration",
+        required={
+            "toml_schema_version",
+            "requested_path",
+            "effective_path",
+            "adjustments",
+        },
+    )
+    if raw.get("toml_schema_version") != 1:
+        raise ArtifactError("configuration.toml_schema_version must be 1")
+    adjustments: list[Mapping[str, object]] = []
+    for index, item in enumerate(
+        _sequence(raw.get("adjustments"), "configuration.adjustments")
+    ):
+        adjustment = _mapping(item, f"configuration.adjustments[{index}]")
+        _keys(
+            adjustment,
+            f"configuration.adjustments[{index}]",
+            required={"path", "reason"},
+        )
+        adjustments.append(
+            MappingProxyType(
+                {
+                    "path": _string(
+                        adjustment.get("path"),
+                        f"configuration.adjustments[{index}].path",
+                    ),
+                    "reason": _string(
+                        adjustment.get("reason"),
+                        f"configuration.adjustments[{index}].reason",
+                    ),
+                }
+            )
+        )
+    return MappingProxyType(
+        {
+            "toml_schema_version": 1,
+            "requested_path": normalize_relative_path(
+                _string(raw.get("requested_path"), "configuration.requested_path")
+            ),
+            "effective_path": normalize_relative_path(
+                _string(raw.get("effective_path"), "configuration.effective_path")
+            ),
+            "adjustments": tuple(adjustments),
+        }
+    )
+
+
+def _process(value: object, index: int) -> Mapping[str, object]:
+    context = f"processes[{index}]"
+    raw = _mapping(value, context)
+    _keys(
+        raw,
+        context,
+        required={
+            "id",
+            "expression",
+            "color_accuracy",
+            "external_pdgs",
+            "physics_path",
+            "required_runtime_capabilities",
+            "aliases",
+        },
+    )
+    accuracy = raw.get("color_accuracy")
+    if accuracy not in {"lc", "nlc", "full"}:
+        raise ArtifactError(f"{context}.color_accuracy is invalid")
+    pdgs = tuple(_sequence(raw.get("external_pdgs"), f"{context}.external_pdgs"))
+    if len(pdgs) < 3 or not all(
+        isinstance(value, int) and not isinstance(value, bool) for value in pdgs
+    ):
+        raise ArtifactError(
+            f"{context}.external_pdgs must contain at least three integers"
+        )
+    process_initial_count = _process_initial_count(
+        _string(raw.get("expression"), f"{context}.expression"),
+        context,
+        len(pdgs),
+    )
+    aliases: list[Mapping[str, object]] = []
+    for alias_index, item in enumerate(
+        _sequence(raw.get("aliases"), f"{context}.aliases")
+    ):
+        alias_context = f"{context}.aliases[{alias_index}]"
+        alias = _mapping(item, alias_context)
+        _keys(
+            alias,
+            alias_context,
+            required={"id", "expression", "external_pdgs", "external_permutation"},
+        )
+        permutation = tuple(
+            _sequence(
+                alias.get("external_permutation"),
+                f"{alias_context}.external_permutation",
+            )
+        )
+        if not all(
+            isinstance(value, int) and not isinstance(value, bool) and value >= 0
+            for value in permutation
+        ):
+            raise ArtifactError(f"{alias_context}.external_permutation is invalid")
+        if len(permutation) != len(pdgs) or sorted(permutation) != list(
+            range(len(pdgs))
+        ):
+            raise ArtifactError(
+                f"{alias_context}.external_permutation must be a complete "
+                f"permutation of {len(pdgs)} external particles"
+            )
+        alias_initial_count = _process_initial_count(
+            _string(alias.get("expression"), f"{alias_context}.expression"),
+            alias_context,
+            len(pdgs),
+        )
+        if alias_initial_count != process_initial_count or any(
+            (representative_index < process_initial_count)
+            != (public_index < process_initial_count)
+            for representative_index, public_index in enumerate(permutation)
+        ):
+            raise ArtifactError(
+                f"{alias_context}.external_permutation may only permute "
+                "particles within the incoming and outgoing sides"
+            )
+        alias_pdgs = tuple(
+            _sequence(alias.get("external_pdgs"), f"{alias_context}.external_pdgs")
+        )
+        if len(alias_pdgs) != len(pdgs) or not all(
+            isinstance(value, int) and not isinstance(value, bool)
+            for value in alias_pdgs
+        ):
+            raise ArtifactError(
+                f"{alias_context}.external_pdgs must contain {len(pdgs)} integers"
+            )
+        expected_pdgs: list[int | None] = [None] * len(pdgs)
+        for representative_index, alias_index in enumerate(permutation):
+            expected_pdgs[alias_index] = int(pdgs[representative_index])
+        if tuple(expected_pdgs) != alias_pdgs:
+            raise ArtifactError(
+                f"{alias_context}.external_pdgs does not match external_permutation"
+            )
+        aliases.append(
+            MappingProxyType(
+                {
+                    "id": _public_id(alias.get("id"), f"{alias_context}.id"),
+                    "expression": _string(
+                        alias.get("expression"), f"{alias_context}.expression"
+                    ),
+                    "external_pdgs": alias_pdgs,
+                    "external_permutation": permutation,
+                }
+            )
+        )
+    return MappingProxyType(
+        {
+            "id": _public_id(raw.get("id"), f"{context}.id"),
+            "expression": _string(raw.get("expression"), f"{context}.expression"),
+            "color_accuracy": accuracy,
+            "external_pdgs": pdgs,
+            "physics_path": normalize_relative_path(
+                _string(raw.get("physics_path"), f"{context}.physics_path")
+            ),
+            "required_runtime_capabilities": _runtime_capabilities(
+                raw.get("required_runtime_capabilities"),
+                f"{context}.required_runtime_capabilities",
+            ),
+            "aliases": tuple(aliases),
+        }
+    )
+
+
+def _process_initial_count(expression: str, context: str, particle_count: int) -> int:
+    sides = expression.split(">")
+    if len(sides) != 2:
+        raise ArtifactError(
+            f"{context}.expression must contain exactly one '>' separator"
+        )
+    initial_count = len(sides[0].split())
+    final_count = len(sides[1].split())
+    if (
+        initial_count < 1
+        or final_count < 1
+        or initial_count + final_count != particle_count
+    ):
+        raise ArtifactError(
+            f"{context}.expression particle count does not match external_pdgs"
+        )
+    return initial_count
+
+
+def _runtime(value: object) -> Mapping[str, object]:
+    raw = _mapping(value, "runtime")
+    _keys(
+        raw,
+        "runtime",
+        required={
+            "engine",
+            "engine_version",
+            "evaluator_manifest_path",
+            "api_bundle_path",
+            "required_runtime_capabilities",
+        },
+    )
+    if raw.get("engine") != "rusticol":
+        raise ArtifactError("runtime.engine must be 'rusticol'")
+    api_path = raw.get("api_bundle_path")
+    return MappingProxyType(
+        {
+            "engine": "rusticol",
+            "engine_version": _string(
+                raw.get("engine_version"), "runtime.engine_version"
+            ),
+            "evaluator_manifest_path": normalize_relative_path(
+                _string(
+                    raw.get("evaluator_manifest_path"),
+                    "runtime.evaluator_manifest_path",
+                )
+            ),
+            "api_bundle_path": None
+            if api_path is None
+            else normalize_relative_path(_string(api_path, "runtime.api_bundle_path")),
+            "required_runtime_capabilities": _runtime_capabilities(
+                raw.get("required_runtime_capabilities"),
+                "runtime.required_runtime_capabilities",
+            ),
+        }
+    )
+
+
+def _dependency(value: object, index: int) -> Mapping[str, object]:
+    context = f"dependencies[{index}]"
+    raw = _mapping(value, context)
+    _keys(
+        raw,
+        context,
+        required={"name", "version", "source", "license"},
+        optional={"content_sha256", "revision", "patch_sha256"},
+    )
+    result: dict[str, object] = {
+        name: _string(raw.get(name), f"{context}.{name}")
+        for name in ("name", "version", "source", "license")
+    }
+    for name in ("content_sha256", "patch_sha256"):
+        if name in raw:
+            result[name] = _sha256(raw.get(name), f"{context}.{name}")
+    if "revision" in raw:
+        result["revision"] = _string(raw.get("revision"), f"{context}.revision")
+    return MappingProxyType(result)
+
+
+@dataclass(frozen=True, slots=True)
+class PayloadRecord:
+    path: str
+    role: str
+    media_type: str
+    size_bytes: int
+    sha256: str
+    executable: bool
+    target: Mapping[str, object] | None = None
+    process_id: str | None = None
+
+    @classmethod
+    def from_mapping(cls, value: object, index: int) -> PayloadRecord:
+        raw = _mapping(value, f"payloads[{index}]")
+        _keys(
+            raw,
+            f"payloads[{index}]",
+            required={
+                "path",
+                "role",
+                "media_type",
+                "size_bytes",
+                "sha256",
+                "executable",
+            },
+            optional={"target", "process_id"},
+        )
+        executable = raw.get("executable")
+        if not isinstance(executable, bool):
+            raise ArtifactError(f"payloads[{index}].executable must be a boolean")
+        target = raw.get("target")
+        process_id = raw.get("process_id")
+        role = _string(raw.get("role"), f"payloads[{index}].role")
+        if role not in _PAYLOAD_ROLES:
+            raise ArtifactError(f"payloads[{index}].role is unsupported: {role!r}")
+        return cls(
+            path=normalize_relative_path(
+                _string(raw.get("path"), f"payloads[{index}].path")
+            ),
+            role=role,
+            media_type=_string(raw.get("media_type"), f"payloads[{index}].media_type"),
+            size_bytes=_integer(raw.get("size_bytes"), f"payloads[{index}].size_bytes"),
+            sha256=_sha256(raw.get("sha256"), f"payloads[{index}].sha256"),
+            executable=executable,
+            target=(
+                _target(target, f"payloads[{index}].target")
+                if target is not None
+                else None
+            ),
+            process_id=(
+                _public_id(process_id, f"payloads[{index}].process_id")
+                if process_id is not None
+                else None
+            ),
+        )
+
+    def as_dict(self) -> dict[str, object]:
+        result: dict[str, object] = {
+            "path": self.path,
+            "role": self.role,
+            "media_type": self.media_type,
+            "size_bytes": self.size_bytes,
+            "sha256": self.sha256,
+            "executable": self.executable,
+        }
+        if self.target is not None:
+            result["target"] = dict(self.target)
+        if self.process_id is not None:
+            result["process_id"] = self.process_id
+        return result
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactManifest:
+    root: Path
+    kind: Literal["pyamplicol-process", "pyamplicol-process-set"]
+    artifact_id: str
+    created_utc: str
+    producer: Mapping[str, object]
+    model: Mapping[str, object]
+    configuration: Mapping[str, object]
+    processes: tuple[Mapping[str, object], ...]
+    default_process_id: str | None
+    runtime: Mapping[str, object]
+    payloads: tuple[PayloadRecord, ...]
+    dependencies: tuple[Mapping[str, object], ...]
+    extensions: Mapping[str, object]
+
+    @classmethod
+    def from_mapping(cls, root: Path, value: object) -> ArtifactManifest:
+        raw = _mapping(value, "artifact manifest")
+        schema = raw.get("schema_version")
+        if schema in (1, 2):
+            raise CompatibilityError(
+                f"process-artifact schema v{schema} is unsupported; regenerate "
+                "the process with pyAmpliCol 0.1.0 or newer"
+            )
+        if schema != SCHEMA_VERSION:
+            raise CompatibilityError(
+                f"unsupported process-artifact schema {schema!r}; expected v3"
+            )
+        if "extensions" not in raw:
+            raise CompatibilityError(
+                "artifact predates the required runtime-payload identity contract; "
+                "regenerate it with the current pyAmpliCol"
+            )
+        _keys(
+            raw,
+            "artifact manifest",
+            required={
+                "schema_version",
+                "kind",
+                "artifact_id",
+                "created_utc",
+                "producer",
+                "model",
+                "configuration",
+                "processes",
+                "runtime",
+                "payloads",
+                "dependencies",
+                "extensions",
+            },
+            optional={"default_process_id"},
+        )
+        kind = raw.get("kind")
+        if kind not in ("pyamplicol-process", "pyamplicol-process-set"):
+            raise ArtifactError(f"unsupported artifact kind {kind!r}")
+        process_values = _sequence(raw.get("processes"), "processes")
+        if not process_values:
+            raise ArtifactError("processes must contain at least one process")
+        payload_values = _sequence(raw.get("payloads"), "payloads")
+        if not payload_values:
+            raise ArtifactError("payloads must contain at least one payload")
+        dependency_values = _sequence(raw.get("dependencies"), "dependencies")
+        default_process = raw.get("default_process_id")
+        extensions = _mapping(raw.get("extensions"), "extensions")
+        _validate_artifact_identity_extension(extensions)
+        created_utc = _string(raw.get("created_utc"), "created_utc")
+        try:
+            datetime.fromisoformat(created_utc.replace("Z", "+00:00"))
+        except ValueError as exc:
+            raise ArtifactError("created_utc must be an ISO-8601 date-time") from exc
+        processes = tuple(
+            _process(item, index) for index, item in enumerate(process_values)
+        )
+        process_ids = tuple(str(item["id"]) for item in processes)
+        if len(set(process_ids)) != len(process_ids):
+            raise ArtifactError("process IDs must be unique")
+        default_process_id = (
+            _public_id(default_process, "default_process_id")
+            if default_process is not None
+            else None
+        )
+        if default_process_id is not None and default_process_id not in process_ids:
+            raise ArtifactError("default_process_id does not identify a process")
+        runtime = _runtime(raw.get("runtime"))
+        process_capabilities = {
+            str(capability)
+            for process in processes
+            for capability in _sequence(
+                process["required_runtime_capabilities"],
+                "process.required_runtime_capabilities",
+            )
+        }
+        runtime_capabilities = set(
+            _sequence(
+                runtime["required_runtime_capabilities"],
+                "runtime.required_runtime_capabilities",
+            )
+        )
+        if runtime_capabilities != process_capabilities:
+            raise ArtifactError(
+                "runtime.required_runtime_capabilities must equal the union of "
+                "process capability declarations"
+            )
+        return cls(
+            root=root.resolve(strict=True),
+            kind=kind,
+            artifact_id=_sha256(raw.get("artifact_id"), "artifact_id"),
+            created_utc=created_utc,
+            producer=_producer(raw.get("producer")),
+            model=_model(raw.get("model")),
+            configuration=_configuration(raw.get("configuration")),
+            processes=processes,
+            default_process_id=default_process_id,
+            runtime=runtime,
+            payloads=tuple(
+                PayloadRecord.from_mapping(item, index)
+                for index, item in enumerate(payload_values)
+            ),
+            dependencies=tuple(
+                _dependency(item, index) for index, item in enumerate(dependency_values)
+            ),
+            extensions=MappingProxyType(dict(extensions)),
+        )
+
+    def as_dict(self) -> dict[str, object]:
+        result: dict[str, object] = {
+            "schema_version": SCHEMA_VERSION,
+            "kind": self.kind,
+            "artifact_id": self.artifact_id,
+            "created_utc": self.created_utc,
+            "producer": _plain(self.producer),
+            "model": _plain(self.model),
+            "configuration": _plain(self.configuration),
+            "processes": _plain(self.processes),
+            "runtime": _plain(self.runtime),
+            "payloads": [payload.as_dict() for payload in self.payloads],
+            "dependencies": _plain(self.dependencies),
+            "extensions": _plain(self.extensions),
+        }
+        if self.default_process_id is not None:
+            result["default_process_id"] = self.default_process_id
+        return result
+
+
+def _plain(value: object) -> Any:
+    if isinstance(value, Mapping):
+        return {str(key): _plain(item) for key, item in value.items()}
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        return [_plain(item) for item in value]
+    return value
+
+
+def canonical_manifest_bytes(value: Mapping[str, object]) -> bytes:
+    return (
+        json.dumps(
+            _plain(value),
+            sort_keys=True,
+            separators=(",", ":"),
+            allow_nan=False,
+        )
+        + "\n"
+    ).encode("utf-8")
+
+
+def _artifact_identity_content(value: Mapping[str, object]) -> dict[str, object]:
+    payloads = _sequence(value.get("payloads"), "payloads")
+    runtime_records: list[dict[str, object]] = []
+    for index, item in enumerate(payloads):
+        record = _mapping(item, f"payloads[{index}]")
+        role = _string(record.get("role"), f"payloads[{index}].role")
+        if role in _RUNTIME_IDENTITY_PAYLOAD_ROLES:
+            runtime_records.append(cast(dict[str, object], _plain(record)))
+    runtime_records.sort(key=lambda record: str(record.get("path", "")))
+    return {
+        "kind": "pyamplicol-runtime-payload-identity",
+        "schema_version": 1,
+        "payloads": runtime_records,
+    }
+
+
+def compute_artifact_id(value: Mapping[str, object]) -> str:
+    import hashlib
+
+    content = _artifact_identity_content(value)
+    return hashlib.sha256(canonical_manifest_bytes(content)).hexdigest()
+
+
+def _validate_target_compatibility(
+    manifest: ArtifactManifest,
+    *,
+    expected_target: str | None = None,
+) -> None:
+    producer_target = _target(manifest.producer.get("target"), "producer.target")
+    target_triple = _string(producer_target.get("triple"), "producer.target.triple")
+    is_portable_64le = target_triple == PORTABLE_64LE_TARGET
+    if (
+        expected_target is not None
+        and not is_portable_64le
+        and target_triple != expected_target
+    ):
+        raise CompatibilityError(
+            f"artifact target {target_triple!r} is incompatible with "
+            f"runtime target {expected_target!r}"
+        )
+    seen: set[str] = set()
+    for record in manifest.payloads:
+        if record.path in seen:
+            raise ArtifactError(f"duplicate artifact payload path: {record.path}")
+        seen.add(record.path)
+        if record.role == "evaluator-state" and record.target is None:
+            raise ArtifactError(
+                f"evaluator-state payload has no target metadata: {record.path}"
+            )
+        if record.target is not None and dict(record.target) != dict(producer_target):
+            raise CompatibilityError(
+                f"payload {record.path} target metadata differs from producer target"
+            )
+
+    required_features = cast(tuple[str, ...], producer_target["cpu_features"])
+    if is_portable_64le:
+        if required_features:
+            raise CompatibilityError(
+                f"{PORTABLE_64LE_TARGET} artifacts may not require CPU features"
+            )
+        runtime_capabilities = set(
+            cast(tuple[str, ...], manifest.runtime["required_runtime_capabilities"])
+        )
+        target_specific_capabilities = sorted(
+            runtime_capabilities & _TARGET_SPECIFIC_EVALUATOR_RUNTIME_CAPABILITIES
+        )
+        if target_specific_capabilities:
+            raise CompatibilityError(
+                f"{PORTABLE_64LE_TARGET} artifact declares target-specific "
+                "evaluator capabilities: "
+                + ", ".join(target_specific_capabilities)
+            )
+        if (
+            expected_target is not None
+            and expected_target not in _SUPPORTED_ARTIFACT_TARGETS
+        ):
+            raise CompatibilityError(
+                f"artifact target {PORTABLE_64LE_TARGET!r} is incompatible with "
+                f"runtime target {expected_target!r}"
+            )
+        if sys.byteorder != "little" or struct.calcsize("P") * 8 != 64:
+            raise CompatibilityError(
+                f"{PORTABLE_64LE_TARGET} artifacts require a 64-bit "
+                "little-endian runtime"
+            )
+        return
+    if required_features:
+        runtime_triple, runtime_features = _runtime_target_metadata()
+        if target_triple != runtime_triple:
+            raise CompatibilityError(
+                f"artifact target {target_triple!r} is incompatible with "
+                f"runtime target {runtime_triple!r}"
+            )
+        unavailable = sorted(set(required_features) - set(runtime_features))
+        if unavailable:
+            raise CompatibilityError(
+                "artifact requires unavailable CPU features: " + ", ".join(unavailable)
+            )
+
+
+def validate_payloads(
+    manifest: ArtifactManifest,
+    *,
+    expected_target: str | None = None,
+) -> None:
+    if compute_artifact_id(manifest.as_dict()) != manifest.artifact_id:
+        raise ArtifactError("artifact manifest identity digest mismatch")
+    _validate_target_compatibility(manifest, expected_target=expected_target)
+    seen = {record.path for record in manifest.payloads}
+    for record in manifest.payloads:
+        path = confined_path(manifest.root, record.path)
+        if path.stat().st_size != record.size_bytes:
+            raise ArtifactError(f"artifact payload size mismatch: {record.path}")
+        if sha256_file(path) != record.sha256:
+            raise ArtifactError(f"artifact payload digest mismatch: {record.path}")
+        actual_executable = executable_bit(path)
+        if actual_executable != record.executable:
+            raise ArtifactError(
+                f"artifact payload executable-bit mismatch: {record.path}"
+            )
+        if record.executable and record.role not in _EXECUTABLE_ROLES:
+            raise ArtifactError(
+                f"artifact payload role {record.role!r} may not be executable"
+            )
+
+    expected_files = seen | {MANIFEST_NAME}
+    for path in manifest.root.rglob("*"):
+        relative = path.relative_to(manifest.root).as_posix()
+        if path.is_symlink():
+            raise ArtifactError(
+                f"artifact tree contains an undeclared symlink: {relative}"
+            )
+        if not path.is_file() or relative in expected_files:
+            continue
+        if executable_bit(path):
+            raise ArtifactError(
+                f"artifact tree contains an undeclared executable: {relative}"
+            )
+
+
+def _runtime_target_metadata() -> tuple[str, tuple[str, ...]]:
+    try:
+        rusticol = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(rusticol)
+        info = rusticol.target_info()
+        triple = str(info.triple)
+        features = tuple(str(feature) for feature in info.cpu_features)
+    except (AttributeError, ImportError, OSError, RuntimeError) as error:
+        raise CompatibilityError(
+            "artifact CPU-feature requirements cannot be checked because the "
+            "Rusticol native runtime is unavailable"
+        ) from error
+    if not triple:
+        raise CompatibilityError("Rusticol returned an empty runtime target triple")
+    if triple not in _SUPPORTED_ARTIFACT_TARGETS:
+        raise CompatibilityError(
+            f"Rusticol process artifacts are not supported on target {triple!r}"
+        )
+    if features != tuple(sorted(set(features))) or any(
+        _CPU_FEATURE_ID.fullmatch(feature) is None for feature in features
+    ):
+        raise CompatibilityError(
+            "Rusticol returned invalid runtime CPU-feature metadata"
+        )
+    return triple, features
+
+
+def load_manifest(
+    artifact: str | Path,
+    *,
+    expected_target: str | None = None,
+    verify_payloads: bool = False,
+) -> ArtifactManifest:
+    root = Path(artifact).expanduser().resolve(strict=True)
+    if not root.is_dir():
+        raise ArtifactError(f"artifact root is not a directory: {root}")
+    manifest_path = confined_path(root, MANIFEST_NAME)
+    try:
+        raw = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ArtifactError(f"invalid artifact manifest JSON: {exc}") from exc
+    manifest = ArtifactManifest.from_mapping(root, raw)
+    if verify_payloads:
+        validate_payloads(manifest, expected_target=expected_target)
+    else:
+        _validate_target_compatibility(manifest, expected_target=expected_target)
+    return manifest
+
+
+__all__ = [
+    "ARTIFACT_IDENTITY_EXTENSION",
+    "ARTIFACT_IDENTITY_KIND",
+    "ARTIFACT_IDENTITY_SCHEMA_VERSION",
+    "MANIFEST_NAME",
+    "PORTABLE_64LE_TARGET",
+    "SCHEMA_VERSION",
+    "ArtifactManifest",
+    "PayloadRecord",
+    "artifact_identity_extension",
+    "canonical_manifest_bytes",
+    "compute_artifact_id",
+    "load_manifest",
+    "validate_payloads",
+]
diff --git a/pyamplicol/src/pyamplicol/artifacts/process_groups.py b/pyamplicol/src/pyamplicol/artifacts/process_groups.py
new file mode 100644
index 0000000000..7524c968a4
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/process_groups.py
@@ -0,0 +1,197 @@
+# SPDX-License-Identifier: 0BSD
+"""Read and update the process-group map stored in an artifact.
+
+``process-groups.json`` is a declared payload whose role is not part of the
+runtime-payload identity: rewriting it updates its payload record in
+``artifact.json`` but never ``artifact_id``.
+"""
+
+from __future__ import annotations
+
+import fcntl
+import hashlib
+import json
+import os
+import tempfile
+from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
+from contextlib import contextmanager, suppress
+from pathlib import Path
+
+from pyamplicol.api.errors import ArtifactError
+from pyamplicol.generation.process_grouping import (
+    PROCESS_GROUPS_PATH,
+    PROCESS_GROUPS_ROLE,
+    GroupingProcess,
+    GroupMember,
+    ProcessGroupMap,
+)
+
+from .manifest import (
+    MANIFEST_NAME,
+    PayloadRecord,
+    canonical_manifest_bytes,
+    load_manifest,
+)
+from .security import confined_path, fsync_directory
+
+PROCESS_GROUPS_MEDIA_TYPE = "application/json"
+
+
+def grouping_process(
+    process_id: str,
+    expression: str,
+    external_pdgs: Sequence[int],
+) -> GroupingProcess:
+    """Return the grouping view of one generated artifact process."""
+
+    initial, _separator, _final = expression.partition(">")
+    return GroupingProcess(
+        process_id=process_id,
+        expression=expression,
+        pdgs=tuple(int(pdg) for pdg in external_pdgs),
+        initial_count=len(initial.split()),
+    )
+
+
+def initial_process_groups(
+    processes: Iterable[tuple[str, str, Sequence[int]]],
+    members: Mapping[str, Sequence[GroupMember]] | None = None,
+) -> ProcessGroupMap:
+    """Group each generated ``(id, expression, pdgs)`` with its known members.
+
+    ``members`` holds, per representative ID, the relations recorded before
+    generation (flavour-blind members); every other process maps to itself.
+    """
+
+    result = ProcessGroupMap()
+    for process_id, expression, external_pdgs in processes:
+        representative = GroupMember.identity(
+            grouping_process(process_id, expression, external_pdgs)
+        )
+        result.add_group([representative, *(members or {}).get(process_id, ())])
+    return result
+
+
+def process_groups_payload(group_map: ProcessGroupMap) -> bytes:
+    return group_map.to_json().encode("utf-8")
+
+
+def validate_process_groups(
+    group_map: ProcessGroupMap,
+    process_ids: Collection[str],
+) -> None:
+    """Require exactly the artifact's processes to be generated members.
+
+    Members that were not generated are evaluated through their representative,
+    so, as the runtime requires, their factor must be positive.
+    """
+
+    generated = [
+        member.process_id for member in group_map.members() if member.generated
+    ]
+    if len(generated) != len(set(generated)) or set(generated) != set(process_ids):
+        missing = sorted(set(process_ids) - set(generated))
+        unknown = sorted(set(generated) - set(process_ids))
+        raise ArtifactError(
+            "process-group map does not list each artifact process exactly once "
+            f"as a generated member (missing: {missing}, not in artifact: {unknown})"
+        )
+    for member in group_map.members():
+        if not member.generated and member.factor <= 0:
+            raise ArtifactError(
+                f"process-group member {member.process_id!r} is not generated, so "
+                f"its factor {member.factor} must be positive"
+            )
+
+
+@contextmanager
+def _artifact_lock(root: Path) -> Iterator[None]:
+    # The lock file of ArtifactTransaction, which serializes generation.
+    with root.with_name(f".{root.name}.lock").open("a+b") as stream:
+        fcntl.flock(stream.fileno(), fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            fcntl.flock(stream.fileno(), fcntl.LOCK_UN)
+
+
+def _replace_file(path: Path, content: bytes) -> None:
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{path.name}.", suffix=".tmp", dir=path.parent
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            stream.write(content)
+            stream.flush()
+            os.fsync(stream.fileno())
+        temporary.chmod(0o644)
+        os.replace(temporary, path)
+    finally:
+        with suppress(FileNotFoundError):
+            temporary.unlink()
+
+
+def read_process_groups(artifact: str | Path) -> ProcessGroupMap | None:
+    """Return the stored process-group map, or ``None`` when none is declared."""
+
+    manifest = load_manifest(artifact)
+    record = next(
+        (item for item in manifest.payloads if item.role == PROCESS_GROUPS_ROLE),
+        None,
+    )
+    if record is None:
+        return None
+    path = confined_path(manifest.root, record.path)
+    try:
+        return ProcessGroupMap.from_json(path.read_text(encoding="utf-8"))
+    except (KeyError, TypeError, ValueError) as exc:
+        raise ArtifactError(f"invalid process-group map {record.path}: {exc}") from exc
+
+
+def write_process_groups(artifact: str | Path, group_map: ProcessGroupMap) -> None:
+    """Replace ``process-groups.json`` and its payload record in place.
+
+    The update runs under the artifact's generation lock. The payload file is
+    replaced first and the manifest second, each atomically, so an interrupted
+    update leaves a digest mismatch that the next update repairs.
+    ``artifact_id`` does not change because the role is not an identity role.
+    """
+
+    root = Path(artifact).expanduser().resolve(strict=True)
+    content = process_groups_payload(group_map)
+    with _artifact_lock(root):
+        manifest = load_manifest(root)
+        validate_process_groups(
+            group_map, [str(process["id"]) for process in manifest.processes]
+        )
+        manifest_path = confined_path(root, MANIFEST_NAME)
+        raw = json.loads(manifest_path.read_text(encoding="utf-8"))
+        payload_path = confined_path(root, PROCESS_GROUPS_PATH, must_exist=False)
+        _replace_file(payload_path, content)
+        record = PayloadRecord(
+            path=PROCESS_GROUPS_PATH,
+            role=PROCESS_GROUPS_ROLE,
+            media_type=PROCESS_GROUPS_MEDIA_TYPE,
+            size_bytes=len(content),
+            sha256=hashlib.sha256(content).hexdigest(),
+            executable=False,
+        )
+        payloads = [
+            item for item in raw["payloads"] if item.get("path") != PROCESS_GROUPS_PATH
+        ]
+        payloads.append(record.as_dict())
+        raw["payloads"] = sorted(payloads, key=lambda item: str(item["path"]))
+        _replace_file(manifest_path, canonical_manifest_bytes(raw))
+        fsync_directory(root)
+
+
+__all__ = [
+    "PROCESS_GROUPS_MEDIA_TYPE",
+    "grouping_process",
+    "initial_process_groups",
+    "process_groups_payload",
+    "read_process_groups",
+    "validate_process_groups",
+    "write_process_groups",
+]
diff --git a/pyamplicol/src/pyamplicol/artifacts/security.py b/pyamplicol/src/pyamplicol/artifacts/security.py
new file mode 100644
index 0000000000..b2d8a3763d
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/security.py
@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: 0BSD
+"""Filesystem and digest checks for schema-v3 process artifacts."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import stat
+from pathlib import Path, PurePosixPath
+
+from pyamplicol.api.errors import ArtifactError
+
+
+def normalize_relative_path(value: str) -> str:
+    """Return a normalized artifact path or reject unsafe input."""
+
+    if not isinstance(value, str) or not value:
+        raise ArtifactError("artifact payload paths must be non-empty strings")
+    if "\\" in value or "\x00" in value:
+        raise ArtifactError(f"artifact payload path is not portable: {value!r}")
+    path = PurePosixPath(value)
+    if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts):
+        raise ArtifactError(f"artifact payload path is not confined: {value!r}")
+    normalized = path.as_posix()
+    if normalized != value:
+        raise ArtifactError(
+            f"artifact payload path is not normalized: {value!r} != {normalized!r}"
+        )
+    return normalized
+
+
+def confined_path(root: Path, relative: str, *, must_exist: bool = True) -> Path:
+    """Resolve a payload while rejecting symlinks and root escapes."""
+
+    normalized = normalize_relative_path(relative)
+    root = root.resolve(strict=True)
+    candidate = root.joinpath(*PurePosixPath(normalized).parts)
+    current = root
+    for part in PurePosixPath(normalized).parts:
+        current = current / part
+        try:
+            metadata = current.lstat()
+        except FileNotFoundError:
+            if must_exist:
+                raise ArtifactError(
+                    f"artifact payload is missing: {normalized}"
+                ) from None
+            break
+        if stat.S_ISLNK(metadata.st_mode):
+            raise ArtifactError(
+                f"artifact payload may not traverse a symlink: {normalized}"
+            )
+    if must_exist and not candidate.is_file():
+        raise ArtifactError(f"artifact payload is not a regular file: {normalized}")
+    try:
+        resolved = candidate.resolve(strict=must_exist)
+        resolved.relative_to(root)
+    except (OSError, ValueError) as exc:
+        raise ArtifactError(f"artifact payload escapes its root: {normalized}") from exc
+    return candidate
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while block := stream.read(1024 * 1024):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def executable_bit(path: Path) -> bool:
+    return bool(path.stat().st_mode & (stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH))
+
+
+def fsync_file(path: Path) -> None:
+    with path.open("rb") as stream:
+        os.fsync(stream.fileno())
+
+
+def fsync_directory(path: Path) -> None:
+    descriptor = os.open(path, os.O_RDONLY)
+    try:
+        os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+__all__ = [
+    "confined_path",
+    "executable_bit",
+    "fsync_directory",
+    "fsync_file",
+    "normalize_relative_path",
+    "sha256_file",
+]
diff --git a/pyamplicol/src/pyamplicol/artifacts/transaction.py b/pyamplicol/src/pyamplicol/artifacts/transaction.py
new file mode 100644
index 0000000000..51d3d6d487
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/transaction.py
@@ -0,0 +1,205 @@
+# SPDX-License-Identifier: 0BSD
+"""Locked transactional directory updates for generated artifacts."""
+
+from __future__ import annotations
+
+import ctypes
+import errno
+import fcntl
+import os
+import shutil
+import sys
+import uuid
+from pathlib import Path
+from types import TracebackType
+from typing import BinaryIO, Literal
+
+from pyamplicol.api.errors import ArtifactError
+
+from .security import fsync_directory
+
+ArtifactWriteMode = Literal["error", "append", "replace"]
+
+_AT_FDCWD = -100
+_RENAME_EXCHANGE = 0x2
+_LINUX_X86_64_RENAMEAT2 = 316
+
+
+def _raise_exchange_error(source: Path, destination: Path) -> None:
+    error_number = ctypes.get_errno() or errno.EIO
+    raise OSError(
+        error_number,
+        (f"atomic artifact directory exchange failed: {os.strerror(error_number)}"),
+        f"{source} <-> {destination}",
+    )
+
+
+def _exchange_directories(source: Path, destination: Path) -> None:
+    """Atomically exchange two existing directories on release platforms."""
+
+    source_bytes = os.fsencode(source)
+    destination_bytes = os.fsencode(destination)
+    libc = ctypes.CDLL(None, use_errno=True)
+    ctypes.set_errno(0)
+
+    if sys.platform == "darwin":
+        try:
+            renameatx_np = libc.renameatx_np
+        except AttributeError as error:
+            raise OSError(
+                errno.ENOTSUP,
+                "this macOS runtime does not provide atomic directory exchange",
+            ) from error
+        renameatx_np.argtypes = (
+            ctypes.c_int,
+            ctypes.c_char_p,
+            ctypes.c_int,
+            ctypes.c_char_p,
+            ctypes.c_uint,
+        )
+        renameatx_np.restype = ctypes.c_int
+        result = renameatx_np(
+            _AT_FDCWD,
+            source_bytes,
+            _AT_FDCWD,
+            destination_bytes,
+            _RENAME_EXCHANGE,
+        )
+    elif sys.platform.startswith("linux"):
+        try:
+            renameat2 = libc.renameat2
+        except AttributeError:
+            if os.uname().machine != "x86_64":
+                raise OSError(
+                    errno.ENOTSUP,
+                    "atomic directory exchange is unsupported on this Linux target",
+                ) from None
+            syscall = libc.syscall
+            syscall.restype = ctypes.c_long
+            result = syscall(
+                _LINUX_X86_64_RENAMEAT2,
+                _AT_FDCWD,
+                source_bytes,
+                _AT_FDCWD,
+                destination_bytes,
+                _RENAME_EXCHANGE,
+            )
+        else:
+            renameat2.argtypes = (
+                ctypes.c_int,
+                ctypes.c_char_p,
+                ctypes.c_int,
+                ctypes.c_char_p,
+                ctypes.c_uint,
+            )
+            renameat2.restype = ctypes.c_int
+            result = renameat2(
+                _AT_FDCWD,
+                source_bytes,
+                _AT_FDCWD,
+                destination_bytes,
+                _RENAME_EXCHANGE,
+            )
+    else:
+        raise OSError(
+            errno.ENOTSUP,
+            "atomic artifact replacement is supported only on macOS and Linux",
+        )
+
+    if result != 0:
+        _raise_exchange_error(source, destination)
+
+
+class ArtifactTransaction:
+    """Prepare a sibling directory and publish it only after successful work."""
+
+    def __init__(
+        self,
+        destination: str | Path,
+        *,
+        mode: ArtifactWriteMode = "error",
+    ) -> None:
+        if mode not in ("error", "append", "replace"):
+            raise ValueError("artifact mode must be 'error', 'append', or 'replace'")
+        self.destination = Path(destination).expanduser().resolve(strict=False)
+        self.mode = mode
+        self.staging = self.destination.with_name(
+            f".{self.destination.name}.staging-{uuid.uuid4().hex}"
+        )
+        self._lock_path = self.destination.with_name(f".{self.destination.name}.lock")
+        self._lock_stream: BinaryIO | None = None
+        self._entered = False
+        self._committed = False
+
+    def __enter__(self) -> Path:
+        if self._entered:
+            raise RuntimeError("artifact transaction cannot be entered twice")
+        self.destination.parent.mkdir(parents=True, exist_ok=True)
+        lock_stream = self._lock_path.open("a+b")
+        fcntl.flock(lock_stream.fileno(), fcntl.LOCK_EX)
+        self._lock_stream = lock_stream
+        self._entered = True
+        try:
+            if self.destination.exists() and not self.destination.is_dir():
+                raise ArtifactError(
+                    f"artifact destination is not a directory: {self.destination}"
+                )
+            if self.mode == "error" and self.destination.exists():
+                raise FileExistsError(f"artifact already exists: {self.destination}")
+            if self.mode == "append":
+                if not self.destination.is_dir():
+                    raise FileNotFoundError(
+                        f"cannot append to missing artifact: {self.destination}"
+                    )
+                shutil.copytree(self.destination, self.staging)
+            else:
+                self.staging.mkdir()
+            return self.staging
+        except BaseException:
+            self._release()
+            raise
+
+    def commit(self) -> None:
+        if not self._entered:
+            raise RuntimeError("artifact transaction has not been entered")
+        if self._committed:
+            raise RuntimeError("artifact transaction is already committed")
+        if not self.staging.is_dir():
+            raise ArtifactError("artifact staging directory disappeared before commit")
+        fsync_directory(self.staging)
+        try:
+            if self.destination.exists():
+                _exchange_directories(self.staging, self.destination)
+            else:
+                os.replace(self.staging, self.destination)
+            fsync_directory(self.destination.parent)
+            self._committed = True
+        except BaseException:
+            # Atomic exchange leaves both directory names untouched on failure.
+            raise
+
+    def _release(self) -> None:
+        if self.staging.exists():
+            shutil.rmtree(self.staging)
+        if self._lock_stream is not None:
+            stream = self._lock_stream
+            fcntl.flock(stream.fileno(), fcntl.LOCK_UN)
+            stream.close()
+            self._lock_stream = None
+
+    def __exit__(
+        self,
+        exception_type: type[BaseException] | None,
+        exception: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> Literal[False]:
+        del exception, traceback
+        try:
+            if exception_type is None and not self._committed:
+                self.commit()
+        finally:
+            self._release()
+        return False
+
+
+__all__ = ["ArtifactTransaction", "ArtifactWriteMode"]
diff --git a/pyamplicol/src/pyamplicol/artifacts/umami.py b/pyamplicol/src/pyamplicol/artifacts/umami.py
new file mode 100644
index 0000000000..a687412204
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/umami.py
@@ -0,0 +1,939 @@
+# SPDX-License-Identifier: 0BSD
+"""Export UMAMI lookup tables without changing numerical artifact contents.
+
+Identical final particles permit relabelling of physical colour contributions.
+Other equivalences require generation certificates or exact structural keys;
+equal masses or parameter defaults are not a proof. The exception is the
+explicit ``--flavor-blind`` assumption: its ungenerated group members are
+exported through their representative's runtime and recorded in
+``grouping.assumptions``. Integration multiplicities live in the JSON, not in
+the C provider.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Mapping, Sequence
+from contextlib import suppress
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from .api_bundle import ApiBundlePayload
+
+if TYPE_CHECKING:
+    from ..generation.process_grouping import GroupMember
+
+FLAVOR_BLIND_ASSUMPTION = (
+    "flavor-blind matrix elements: ungenerated process-group members are "
+    "evaluated through their relabelled representative (assumed, not proven)"
+)
+
+
+@dataclass(frozen=True)
+class UmamiProcessInput:
+    process_id: str
+    expression: str
+    color_accuracy: str
+    external_pdgs: tuple[int, ...]
+    physics: Mapping[str, Any]
+    aliases: tuple[Mapping[str, Any], ...] = ()
+    color_sectors: tuple[Mapping[str, Any], ...] = ()
+    # Keys certify equality of the normalized, available-helicity-summed
+    # squared contribution, in this process's external momentum order.
+    structural_keys: Mapping[str, str] | None = None
+    # Used when re-exporting an appended compact OTF process: its previous SDK
+    # contains authoritative physical LHE tags, while physics.json stays compact.
+    color_flows: Mapping[str, Sequence[Sequence[int]]] | None = None
+    # Ungenerated group members evaluated through this process's runtime:
+    # ME_member(p) = factor * ME_this(q) with q[r] = p[permutation[r]].
+    group_members: tuple[GroupMember, ...] = ()
+
+
+def _records(value: Any) -> list[Mapping[str, Any]]:
+    return [record for record in value or () if isinstance(record, Mapping)]
+
+
+def _finite(value: Any, context: str) -> float:
+    result = float(value)
+    if not math.isfinite(result):
+        raise ValueError(f"UMAMI {context} must be finite")
+    return result
+
+
+def _pair(value: Any) -> tuple[float, float]:
+    if isinstance(value, Sequence) and not isinstance(value, str):
+        return _finite(value[0], "parameter"), _finite(value[1], "parameter")
+    return _finite(value, "parameter"), 0.0
+
+
+def _model_tables(model: Mapping[str, Any]) -> tuple[dict, dict, dict]:
+    ir = model.get("ir", model.get("model", model))
+    particles = {int(p["pdg_code"]): p for p in _records(ir.get("particles"))}
+    parameters = {str(p["name"]): p for p in _records(ir.get("parameters"))}
+    defaults = {
+        str(k): _pair(v) for k, v in model.get("parameter_defaults", {}).items()
+    }
+    for name, parameter in parameters.items():
+        if name not in defaults and parameter.get("value") is not None:
+            defaults[name] = _pair(parameter["value"])
+        if name not in defaults:
+            with suppress(TypeError, ValueError):
+                defaults[name] = _pair(parameter.get("resolved_expression"))
+    return particles, parameters, defaults
+
+
+def _mass(
+    particle: Mapping, parameters: Mapping, defaults: Mapping
+) -> tuple[str, float]:
+    name = str(particle["mass"])
+    if name in defaults:
+        real, imaginary = defaults[name]
+    else:
+        try:
+            real, imaginary = float(name), 0.0
+        except ValueError as exc:
+            # UFO's reserved ZERO is a literal, not an independent parameter.
+            if name.upper() != "ZERO":
+                raise ValueError(f"UMAMI cannot resolve default mass {name!r}") from exc
+            real, imaginary = 0.0, 0.0
+    if imaginary or real < 0.0 or not math.isfinite(real):
+        raise ValueError(f"UMAMI external mass {name!r} must be nonnegative and real")
+    declaration = parameters.get(name, {})
+    semantic = (
+        name
+        if declaration.get("nature") == "external"
+        else str(declaration.get("resolved_expression", name))
+    )
+    if not declaration and real == 0.0:
+        semantic = "0"
+    return semantic, real
+
+
+def _alpha_s_name(model: Mapping, physics: Mapping, parameters: Mapping) -> str | None:
+    public = {p["name"]: p for p in _records(physics.get("model_parameters"))}
+    explicit = model.get("extensions", {}).get("alpha_s_parameter")
+    candidates = (
+        [str(explicit)]
+        if explicit
+        else [
+            name
+            for name, p in parameters.items()
+            if str(p.get("lhablock", "")).upper() == "SMINPUTS"
+            and list(p.get("lhacode", ())) == [3]
+            and p.get("nature") == "external"
+        ]
+    )
+    candidates = [name for name in candidates if public.get(name, {}).get("mutable")]
+    return candidates[0] if len(candidates) == 1 else None
+
+
+def _slha_reference(declaration: Mapping) -> dict[str, Any]:
+    """The parameter card entry of an external UFO parameter, if it has one."""
+    if declaration.get("nature") != "external" or not declaration.get("lhablock"):
+        return {}
+    return {
+        "lhablock": str(declaration["lhablock"]).upper(),
+        "lhacode": [int(code) for code in declaration.get("lhacode", ())],
+    }
+
+
+def _flow_id(word: Sequence[int]) -> str:
+    return "flow:" + (",".join(str(label) for label in word) if word else "singlet")
+
+
+def _word(sector: Mapping) -> tuple[int, ...]:
+    return tuple(
+        sector.get("word_labels") or next(iter(sector.get("color_words", ())), ())
+    )
+
+
+def _permutation(values: Sequence[int], count: int) -> tuple[int, ...]:
+    result = tuple(int(i) for i in values)
+    if sorted(result) != list(range(count)):
+        raise ValueError("UMAMI external permutation is not a complete bijection")
+    return result
+
+
+def _member_permutation(
+    member: GroupMember, count: int, incoming: int
+) -> tuple[int, ...]:
+    """The ``representative leg -> member leg`` map; incoming swaps are allowed."""
+    permutation = _permutation(member.permutation, count)
+    if len(member.pdgs) != count or any(
+        (leg < incoming) != (target < incoming)
+        for leg, target in enumerate(permutation)
+    ):
+        raise ValueError(
+            f"UMAMI group member {member.process_id!r} must keep initial legs initial"
+        )
+    return permutation
+
+
+def _color_flow(
+    word: Sequence[int],
+    external: Sequence[Mapping],
+    particles: Mapping,
+    sector: Mapping | None = None,
+) -> list[list[int]]:
+    """Assign LHE tags from all-outgoing fundamental chains/adjoint cycles."""
+    labels = {int(p["label"]): i for i, p in enumerate(external)}
+    roles = {}
+    for label, slot in labels.items():
+        p = external[slot]
+        representation = int(particles[int(p["pdg"])]["color"])
+        if p["role"] == "initial" and abs(representation) == 3:
+            representation = -representation
+        roles[label] = representation
+    colored = [int(label) for label in word if roles[int(label)] != 1]
+    if set(colored) != {label for label, rep in roles.items() if rep != 1}:
+        raise ValueError("UMAMI LC word must contain every coloured external leg once")
+    if len(colored) != len(set(colored)):
+        raise ValueError("UMAMI LC word repeats an external leg")
+    if any(rep not in (1, 3, -3, 8) for rep in roles.values()):
+        raise ValueError(
+            "UMAMI LHE tags require singlet, fundamental or adjoint colour"
+        )
+    result = [[0, 0] for _ in external]
+    edge = 501
+    if sector is not None and sector.get("kind") == "open-lines":
+        lines = _records(sector.get("open_color_lines"))
+        chains = [
+            [
+                int(line["fundamental_label"]),
+                *(int(label) for label in line.get("adjoint_labels", ())),
+                int(line["antifundamental_label"]),
+            ]
+            for line in lines
+        ]
+        flattened = [label for chain in chains for label in chain]
+        if sorted(flattened) != sorted(colored):
+            raise ValueError("UMAMI colour-sector lines do not cover the LC word")
+        for chain in chains:
+            if (
+                roles[chain[0]] != 3
+                or roles[chain[-1]] != -3
+                or any(roles[label] != 8 for label in chain[1:-1])
+            ):
+                raise ValueError(
+                    "UMAMI colour-sector endpoints disagree with the model"
+                )
+            result[labels[chain[0]]][0] = edge
+            for label in chain[1:-1]:
+                result[labels[label]] = [edge + 1, edge]
+                edge += 1
+            result[labels[chain[-1]]][1] = edge
+            edge += 1
+    elif colored and all(roles[label] == 8 for label in colored):
+        for index, label in enumerate(colored):
+            result[labels[label]] = [edge + index, edge + (index - 1) % len(colored)]
+    else:
+        current = None
+        for label in colored:
+            role = roles[label]
+            if role == 3:
+                if current is not None:
+                    raise ValueError(
+                        "UMAMI LC word has an unterminated fundamental chain"
+                    )
+                current = edge
+                result[labels[label]][0] = current
+            elif role == 8 and current is not None:
+                result[labels[label]] = [current + 1, current]
+                current += 1
+            elif role == -3 and current is not None:
+                result[labels[label]][1] = current
+                edge = current + 1
+                current = None
+            else:
+                raise ValueError(
+                    "UMAMI LC word does not describe complete fundamental chains"
+                )
+        if current is not None:
+            raise ValueError("UMAMI LC word has an unterminated fundamental chain")
+    for index, p in enumerate(external):
+        if p["role"] == "initial":
+            result[index].reverse()
+    return result
+
+
+def _safe_replay(process: UmamiProcessInput) -> dict[str, tuple[str, tuple[int, ...]]]:
+    """Convert certified label maps; weights may fold reflection, not one flow."""
+    physics = process.physics
+    external = _records(physics["external_particles"])
+    count = len(external)
+    labels = {int(p["label"]): i for i, p in enumerate(external)}
+    identity = tuple(range(count))
+    colors = {str(c["id"]): c for c in _records(physics.get("color_components"))}
+    result = {key: (key, identity) for key in colors}
+    certificate = physics.get("extensions", {}).get("lc_topology_replay")
+    if not certificate:
+        # These public nontrivial mappings are certified trace reflections.
+        for key, color in colors.items():
+            representative = str(color.get("representative_id", key))
+            if representative in colors and float(color.get("coefficient", 1.0)) == 1.0:
+                result[key] = (representative, identity)
+        return result
+    sectors = {int(s["id"]): s for s in process.color_sectors}
+    sector_flow_ids = {_flow_id(_word(s)) for s in sectors.values()}
+    helicities = {tuple(h["values"]) for h in _records(physics.get("helicities"))}
+    for partition in _records(certificate.get("partitions")):
+        if (partition.get("proof") or {}).get("status") != "proven":
+            continue
+        representative = sectors.get(int(partition["representative_sector_id"]))
+        if representative is None:
+            continue
+        rep_id = _flow_id(_word(representative))
+        for sector_id, pairs in zip(
+            partition["active_sector_ids"], partition["label_permutations"], strict=True
+        ):
+            sector = sectors.get(int(sector_id))
+            if sector is None:
+                continue
+            mapping = dict(pairs)
+            try:
+                perm = _permutation(
+                    [labels[int(mapping[int(p["label"])])] for p in external], count
+                )
+            except (KeyError, ValueError):
+                continue
+            # No beam/PDF symmetry is assumed. Restricted helicity coverage
+            # must also be invariant under the proposed external relabelling.
+            if any(
+                perm[i] != i for i, p in enumerate(external) if p["role"] == "initial"
+            ):
+                continue
+            if {tuple(h[i] for i in perm) for h in helicities} != helicities:
+                continue
+            word = _word(sector)
+            target_ids = [_flow_id(word)]
+            if sector.get("kind") == "single-trace" and len(word) > 2:
+                reflected = _flow_id((word[0], *reversed(word[1:])))
+                # Only an additional public flow absent from the sector plan
+                # is a folded reflection. An explicit reversed sector has its
+                # own proof/permutation and must not be overwritten here.
+                if reflected not in sector_flow_ids:
+                    target_ids.append(reflected)
+            for target in target_ids:
+                if target in colors and rep_id in colors:
+                    result[target] = (rep_id, perm)
+    return result
+
+
+def _channel_pattern(order, incoming, masses):
+    """The cyclic colour order from the first incoming leg, with the final-state
+    legs known only by their mass: orders with equal patterns share one
+    phase-space map up to relabelling final-state legs of equal mass."""
+    start = order.index(0)
+    rotated = order[start:] + order[:start]
+    pattern = tuple(
+        ("initial", slot) if slot < incoming else ("final", masses[slot])
+        for slot in rotated
+    )
+    return pattern, rotated
+
+
+def _relabelled(values, relabel):
+    result = [None] * len(values)
+    for slot, value in enumerate(values):
+        result[relabel[slot]] = value
+    return result
+
+
+def _relabelled_runtime(runtime, relabel):
+    return {
+        **runtime,
+        "permutation": [relabel[slot] for slot in runtime["permutation"]],
+    }
+
+
+def _intern(table: list, value: Any) -> int:
+    try:
+        return table.index(value)
+    except ValueError:
+        table.append(value)
+        return len(table) - 1
+
+
+def _identical_orbit(order, flow, pdgs, incoming, helicities, word_size):
+    """An oriented physical colour tensor modulo identical outgoing labels.
+
+    Equal keys induce the explicit bijection between the two complete orders.
+    It fixes incoming slots, preserves particle identity, directed colour edges
+    and the available helicity domain. Exchanging identical fermions changes
+    the overall amplitude sign, not this squared physical contribution. This
+    argument is independent of runtime topology/reflection reuse certificates.
+    """
+
+    def key(candidate):
+        tags = {}
+        directed_edges = []
+        for slot in candidate:
+            for tag in flow[slot] if flow is not None else ():
+                directed_edges.append(tags.setdefault(tag, len(tags) + 1) if tag else 0)
+        return (
+            tuple(
+                ("incoming", slot) if slot < incoming else ("final", pdgs[slot])
+                for slot in candidate
+            ),
+            tuple(directed_edges),
+            tuple(
+                sorted(
+                    tuple(h["values"][slot] for slot in candidate) for h in helicities
+                )
+            ),
+        )
+
+    starts = [0]
+    if flow is not None and word_size:
+        # Undo incoming crossing to identify oriented open-line starts from
+        # the actual colour tensor. A closed trace has no such endpoints.
+        pairs = [
+            tuple(reversed(flow[s])) if s < incoming else tuple(flow[s])
+            for s in order[:word_size]
+        ]
+        if all(any(pair) for pair in pairs):
+            starts = [i for i, (left, right) in enumerate(pairs) if left and not right]
+            if not starts:
+                starts = list(range(word_size)) if all(all(p) for p in pairs) else [0]
+    # Re-anchoring a trace, or cyclically rotating complete open-line blocks,
+    # changes no colour tensor. Never reverse it or arbitrarily sort blocks.
+    candidates = [order[i:word_size] + order[:i] + order[word_size:] for i in starts]
+    return min((key(candidate), candidate) for candidate in candidates)
+
+
+def _add_terms(entry, terms):
+    for term in terms:
+        existing = next(
+            (
+                value
+                for value in entry["matrix_elements"]
+                if value["pdg_ids"] == term["pdg_ids"]
+            ),
+            None,
+        )
+        if existing is None:
+            entry["matrix_elements"].append(dict(term))
+        else:
+            existing["factor"] += term["factor"]
+
+
+def _merge_flavour_orbits(data):
+    """Merge different flavours with a common proven computation.
+
+    Do not use runtime reflection reuse to further collapse same-flavour colour
+    orders: their integration partition was already constructed physically.
+    A merged flavour is evaluated by the kept selector, so the complete runtime
+    evaluation (permutation, factor and colour tags included) must agree.
+    """
+    candidates = {}
+    incoming = data["provider"]["incoming_count"]
+    for channel in data["channels"]:
+        kept = []
+        for entry in channel["processes"]:
+            runtime = entry["runtime"]
+            pdgs = {term["pdg_ids"] for term in entry["matrix_elements"]}
+            key = (
+                runtime["process_index"],
+                runtime["color_id"],
+                runtime["color_index"],
+                tuple(runtime["permutation"]),
+                runtime["factor"],
+                tuple(data["pdg_ids"][next(iter(pdgs))][:incoming]),
+            )
+            previous = next(
+                (
+                    other
+                    for other in candidates.get(key, ())
+                    if pdgs.isdisjoint(t["pdg_ids"] for t in other["matrix_elements"])
+                ),
+                None,
+            )
+            if previous is None:
+                candidates.setdefault(key, []).append(entry)
+                kept.append(entry)
+            else:
+                _add_terms(previous, entry["matrix_elements"])
+                previous["members"].extend(entry["members"])
+        channel["processes"] = kept
+    data["channels"] = [c for c in data["channels"] if c["processes"]]
+    for index, channel in enumerate(data["channels"]):
+        for entry in channel["processes"]:
+            entry["multichannels"] = [index]
+
+
+def _export_helicities(data, runtime_helicities):
+    """Map runtime helicities to exported ones, given in the input leg order."""
+    entries = [e for c in data["channels"] for e in c["processes"]]
+    for runtime in [e["runtime"] for e in entries] + [
+        m["runtime"] for e in entries for m in e["members"]
+    ]:
+        permutation = runtime["permutation"]
+        exported = []
+        for values in runtime_helicities[runtime["process_index"]]:
+            ordered = [0] * len(values)
+            for runtime_leg, input_leg in enumerate(permutation):
+                ordered[input_leg] = values[runtime_leg]
+            exported.append(_intern(data["helicities"], ordered))
+        runtime["helicity_export"] = exported
+
+
+def build_umami_metadata(
+    *,
+    processes: Sequence[UmamiProcessInput],
+    compiled_model: Mapping[str, Any],
+    artifact_id: str | None = None,
+) -> tuple[dict[str, Any], ...]:
+    """Return separate, directly consumable metadata documents per provider.
+
+    Each provider exports sources ``(process, member)``: a generated process
+    (``member`` is None) or one of its ungenerated group members, evaluated
+    through the process's runtime without a runtime row of its own.
+    """
+    particles, parameters, defaults = _model_tables(compiled_model)
+    groups: list[tuple[tuple, list[tuple], list[tuple[str, float]]]] = []
+
+    def physical(source, incoming: int) -> tuple:
+        process, member = source
+        pdgs = process.external_pdgs if member is None else tuple(member.pdgs)
+        return pdgs[:incoming], tuple(sorted(pdgs[incoming:]))
+
+    def place(signature, source, masses, preferred=None):
+        # Alternative selections of the same external process are not additive.
+        key = physical(source, signature[1])
+        compatible = next(
+            (
+                g
+                for g in ([preferred] if preferred else []) + groups
+                if g[0] == signature
+                and all(physical(other, signature[1]) != key for other in g[1])
+            ),
+            None,
+        )
+        if compatible is None:
+            compatible = (signature, [], masses)
+            groups.append(compatible)
+        compatible[1].append(source)
+        return compatible
+
+    for process in processes:
+        external = _records(process.physics.get("external_particles"))
+        if not external or len(external) != len(process.external_pdgs):
+            raise ValueError(
+                f"UMAMI process {process.process_id!r} lacks resolved external metadata"
+            )
+        if tuple(int(p["pdg"]) for p in external) != process.external_pdgs:
+            raise ValueError("UMAMI external PDGs disagree with resolved physics")
+        incoming = sum(p["role"] == "initial" for p in external)
+        if [p["role"] for p in external] != ["initial"] * incoming + ["final"] * (
+            len(external) - incoming
+        ):
+            raise ValueError("UMAMI requires initial legs before final legs")
+        # The public catalog has already evaluated internal/derived parameters
+        # for the artifact's defaults. Reuse those values instead of adding a
+        # second symbolic evaluator here (the parameter card can omit them).
+        process_defaults = {
+            **defaults,
+            **{
+                str(p["name"]): (
+                    _finite(p["default_real"], "parameter"),
+                    _finite(p.get("default_imaginary", 0.0), "parameter"),
+                )
+                for p in _records(process.physics.get("model_parameters"))
+            },
+        }
+        masses = [
+            _mass(particles[pdg], parameters, process_defaults)
+            for pdg in process.external_pdgs
+        ]
+        # The available helicity set, not its enumeration order.
+        helicity_domain = tuple(
+            sorted(
+                tuple(h["values"]) for h in _records(process.physics.get("helicities"))
+            )
+        )
+        signature = (
+            len(external),
+            incoming,
+            process.color_accuracy,
+            tuple(masses),
+            helicity_domain,
+        )
+        home = place(signature, (process, None), masses)
+        for member in process.group_members:
+            # A member's legs carry its own masses; a member whose relabelling
+            # moves unequal masses needs a provider of its own.
+            relation = _member_permutation(member, len(external), incoming)
+            member_masses = [
+                _mass(particles[int(pdg)], parameters, process_defaults)
+                for pdg in member.pdgs
+            ]
+            domain = tuple(
+                sorted(tuple(_relabelled(v, relation)) for v in helicity_domain)
+            )
+            place(
+                (*signature[:3], tuple(member_masses), domain),
+                (process, member),
+                member_masses,
+                home,
+            )
+    documents = []
+    for index, (_, sources, masses) in enumerate(groups):
+        provider_id = f"p{index}"
+        documents.append(
+            _build_provider(
+                provider_id,
+                sources,
+                masses,
+                compiled_model,
+                particles,
+                parameters,
+                len(groups) == 1,
+            )
+        )
+        documents[-1]["provider"]["artifact_id"] = artifact_id
+    return tuple(documents)
+
+
+def _build_provider(
+    provider_id, sources, masses, model, particles, parameters, single
+):
+    first_external = _records(sources[0][0].physics["external_particles"])
+    count = len(first_external)
+    incoming = sum(p["role"] == "initial" for p in first_external)
+    identity = list(range(count))
+    assumptions = [
+        "identical-final-particle permutation-invariant observables and cuts",
+        "final-state flavour-blind observables and cuts",
+    ]
+    if any(member is not None for _, member in sources):
+        assumptions.append(FLAVOR_BLIND_ASSUMPTION)
+    data: dict[str, Any] = {
+        "kind": "pyamplicol-umami-metadata",
+        "schema_version": 1,
+        "provider": {
+            "id": provider_id,
+            "library": "libumami.so" if single else f"libumami_{provider_id}.so",
+            "particle_count": count,
+            "incoming_count": incoming,
+            "masses": [m[1] for m in masses],
+            "mass_parameters": [m[0] for m in masses],
+            "color_accuracy": sources[0][0].color_accuracy,
+        },
+        "grouping": {"assumptions": assumptions},
+        "channels": [],
+        "pdg_ids": [],
+        "color_orders": [],
+        "color_flows": [],
+        "helicities": [],
+        "runtime_processes": [],
+        "aliases": [],
+        "xml_header": (
+            '<generator name="pyAmpliCol">UMAMI artifact provider</generator>'
+        ),
+    }
+    structural_representatives: dict[str, dict] = {}
+    orbit_entries: dict[tuple, tuple[dict, list[int]]] = {}
+    channel_lookup = {}
+    channel_patterns: dict[tuple, list[int]] = {}
+    physical_count = 0
+    runtime_helicities: list[list[list[int]]] = []
+    runtime_indices: dict[str, int] = {}
+    for process, group_member in sources:
+        physics = process.physics
+        external = _records(physics["external_particles"])
+        labels = {int(p["label"]): i for i, p in enumerate(external)}
+        helicities = _records(physics.get("helicities"))
+        if process.process_id not in runtime_indices:
+            runtime_indices[process.process_id] = len(data["runtime_processes"])
+            data["runtime_processes"].append(
+                {
+                    "id": process.process_id,
+                    "expression": process.expression,
+                    "pdgs": list(process.external_pdgs),
+                    "color_accuracy": process.color_accuracy,
+                    "alpha_s_parameter": _alpha_s_name(model, physics, parameters),
+                    "parameters": [
+                        {
+                            **p,
+                            **_slha_reference(parameters.get(p["name"], {})),
+                            "is_complex": (
+                                parameters.get(p["name"], {}).get("parameter_type")
+                                == "complex"
+                                or p.get("kind") == "coupling"
+                                or p.get("default_imaginary", 0.0) != 0.0
+                            ),
+                        }
+                        for p in _records(physics.get("model_parameters"))
+                    ],
+                    "helicity_ids": [h["id"] for h in helicities],
+                    "coverage": dict(physics.get("coverage", {})),
+                }
+            )
+            data["aliases"].extend(
+                {"process_id": process.process_id, **dict(a)} for a in process.aliases
+            )
+            runtime_helicities.append([list(h["values"]) for h in helicities])
+        process_index = runtime_indices[process.process_id]
+        source_id, pdgs = process.process_id, process.external_pdgs
+        relation = None
+        if group_member is not None:
+            # Representative leg r is the member's leg relation[r]: helicity
+            # values and colour tags move with it, momenta through the runtime.
+            relation = _member_permutation(group_member, count, incoming)
+            source_id, pdgs = group_member.process_id, tuple(group_member.pdgs)
+            helicities = [
+                {**h, "values": _relabelled(h["values"], relation)} for h in helicities
+            ]
+        # Helicity values in the input leg order, interned per contribution
+        # once its final-state legs are relabelled to the channel.
+        helicity_groups: dict[str, list[list[int]]] = {}
+        helicity_mappings = []
+        for h in helicities:
+            key = str(h.get("representative_id", h["id"]))
+            helicity_groups.setdefault(key, []).append(list(h["values"]))
+            helicity_mappings.append(
+                {
+                    "helicity": list(h["values"]),
+                    "representative_id": h.get("representative_id", h["id"]),
+                    "coefficient": h.get("coefficient", 1.0),
+                    "structural_zero": h.get("structural_zero", False),
+                }
+            )
+        replay = _safe_replay(process)
+        sectors_by_word = {_word(sector): sector for sector in process.color_sectors}
+        colors = sorted(
+            _records(physics.get("color_components")),
+            key=lambda color: tuple(color.get("word", ())),
+        )
+        for color in colors:
+            physical_count += 1
+            color_id = str(color["id"])
+            contracted = process.color_accuracy != "lc"
+            word = tuple(int(v) for v in color.get("word", ()))
+            order = [labels[label] for label in word]
+            order += [i for i in identity if i not in order]
+            order = list(_permutation(order, count))
+            flow = (
+                None
+                if contracted
+                else [list(pair) for pair in process.color_flows[color_id]]
+                if process.color_flows is not None
+                else _color_flow(word, external, particles, sectors_by_word.get(word))
+            )
+            physical_color = None if contracted else color_id
+            if relation is not None:
+                # Charge conjugation reverses the word and swaps the colour
+                # and anticolour tags of every leg.
+                word_slots = [relation[slot] for slot in order[: len(word)]]
+                if group_member.conjugated:
+                    word_slots.reverse()
+                order = word_slots + [i for i in identity if i not in word_slots]
+                if flow is not None:
+                    if group_member.conjugated:
+                        flow = [pair[::-1] for pair in flow]
+                    flow = _relabelled(flow, relation)
+                    physical_color = _flow_id(
+                        [int(external[slot]["label"]) for slot in word_slots]
+                    )
+            color_index = None if flow is None else _intern(data["color_flows"], flow)
+            rep_color, perm = replay.get(color_id, (color_id, tuple(identity)))
+            runtime = {
+                "process_index": process_index,
+                "process_id": process.process_id,
+                "color_id": None if contracted else rep_color,
+                "color_index": 0 if color_index is None else color_index,
+                "permutation": list(perm),
+                "factor": 1.0,
+            }
+            semantic_key = (process.structural_keys or {}).get(color_id)
+            if semantic_key:
+                if semantic_key in structural_representatives:
+                    runtime = dict(structural_representatives[semantic_key])
+                else:
+                    # The proof key already includes normalization and colour
+                    # contraction; exact cross-flavour equality needs no cuts.
+                    structural_representatives[semantic_key] = dict(runtime)
+            if relation is not None:
+                runtime = {
+                    **runtime,
+                    "permutation": [relation[slot] for slot in runtime["permutation"]],
+                    "factor": runtime["factor"] * float(group_member.factor),
+                }
+            member = {
+                "process_id": source_id,
+                "pdgs": list(pdgs),
+                "color_id": physical_color,
+                "color_flows": color_index,
+                "runtime": dict(runtime),
+                "factor": 1.0,
+            }
+            orbit_key, aligned_order = _identical_orbit(
+                order,
+                flow,
+                pdgs,
+                incoming,
+                helicities,
+                len(word),
+            )
+            orbit = (source_id, orbit_key)
+            if orbit in orbit_entries:
+                entry, representative_order, representative_runtime, relabel = (
+                    orbit_entries[orbit]
+                )
+                # Evaluate each physical member through the exported entry,
+                # independently of any additional internal runtime reuse.
+                slots = dict(zip(representative_order, aligned_order, strict=True))
+                member["runtime"] = {
+                    **representative_runtime,
+                    "permutation": [
+                        slots[i] for i in representative_runtime["permutation"]
+                    ],
+                }
+                pdg_index = _intern(
+                    data["pdg_ids"], _relabelled(list(pdgs), relabel)
+                )
+                _add_terms(entry, [{"pdg_ids": pdg_index, "factor": 1.0}])
+                entry["members"].append(member)
+                continue
+            # The exported contribution relabels its final-state legs onto the
+            # first colour order of its channel; members keep physical labels.
+            pattern, rotated = _channel_pattern(
+                order, incoming, data["provider"]["masses"]
+            )
+            relabel = list(identity)
+            representative = channel_patterns.setdefault(pattern, rotated)
+            for slot, target in zip(rotated, representative, strict=True):
+                relabel[slot] = target
+            channel_order = [relabel[slot] for slot in order]
+            entry_color_index = (
+                None if flow is None else _intern(data["color_flows"], _relabelled(flow, relabel))
+            )
+            entry_runtime = _relabelled_runtime(runtime, relabel)
+            if entry_color_index is not None:
+                entry_runtime["color_index"] = entry_color_index
+            pdg_index = _intern(
+                data["pdg_ids"], _relabelled(list(pdgs), relabel)
+            )
+            entry = {
+                "matrix_elements": [{"pdg_ids": pdg_index, "factor": 1.0}],
+                "color_order": _intern(data["color_orders"], channel_order),
+                "color_flows": entry_color_index,
+                "helicities": [
+                    [_intern(data["helicities"], _relabelled(v, relabel)) for v in group]
+                    for group in helicity_groups.values()
+                ],
+                "helicity_mappings": [
+                    {
+                        **mapping,
+                        "helicity": _intern(
+                            data["helicities"], _relabelled(mapping["helicity"], relabel)
+                        ),
+                    }
+                    for mapping in helicity_mappings
+                ],
+                "runtime": entry_runtime,
+                "members": [member],
+                "multichannels": [],
+            }
+            # A single complete map per channel pattern. Maps are shared only if
+            # their fixed external masses agree (already a provider invariant).
+            if pattern not in channel_lookup:
+                channel_lookup[pattern] = len(data["channels"])
+                data["channels"].append(
+                    {"phasespace_order": channel_order, "processes": []}
+                )
+            channel_index = channel_lookup[pattern]
+            entry["multichannels"] = [channel_index]
+            data["channels"][channel_index]["processes"].append(entry)
+            orbit_entries[orbit] = (entry, aligned_order, runtime, relabel)
+    _merge_flavour_orbits(data)
+    _export_helicities(data, runtime_helicities)
+    alpha_names = {p["alpha_s_parameter"] for p in data["runtime_processes"]}
+    data["provider"]["alpha_s_parameter"] = (
+        next(iter(alpha_names)) if len(alpha_names) == 1 else None
+    )
+    data["provider"]["supports_alpha_s"] = all(name is not None for name in alpha_names)
+    data["provider"]["helicity_count"] = max(
+        (len(p["helicity_ids"]) for p in data["runtime_processes"]), default=0
+    )
+    data["provider"]["color_count"] = max(1, len(data["color_flows"]))
+    data["grouping"]["physical_contributions"] = physical_count
+    data["grouping"]["exported_contributions"] = sum(
+        len(c["processes"]) for c in data["channels"]
+    )
+    return data
+
+
+def _json_payload(path: str, value: Any) -> ApiBundlePayload:
+    return ApiBundlePayload(
+        path,
+        (json.dumps(value, indent=2, sort_keys=True, allow_nan=False) + "\n").encode(),
+        "sdk-metadata",
+        "application/json",
+    )
+
+
+def umami_bundle_payloads(
+    *,
+    processes: Sequence[UmamiProcessInput],
+    compiled_model: Mapping[str, Any],
+    artifact_id: str | None = None,
+) -> tuple[ApiBundlePayload, ...]:
+    """Create JSON, provider headers and Make variables from one representation."""
+    from .umami_c import provider_header
+
+    documents = build_umami_metadata(
+        processes=processes,
+        compiled_model=compiled_model,
+        artifact_id=artifact_id,
+    )
+    payloads = []
+    entries = []
+    for data in documents:
+        provider = data["provider"]
+        identifier = provider["id"]
+        relative = (
+            "metadata.json"
+            if len(documents) == 1
+            else f"providers/{identifier}/metadata.json"
+        )
+        payloads.append(_json_payload(f"API/umami/{relative}", data))
+        entries.append(
+            {"id": identifier, "metadata": relative, "library": provider["library"]}
+        )
+        payloads.append(
+            ApiBundlePayload(
+                f"API/umami/provider_{identifier}.h",
+                provider_header(data).encode(),
+                "api-source",
+                "text/x-chdr",
+            )
+        )
+    if len(documents) != 1:
+        payloads.append(
+            _json_payload(
+                "API/umami/metadata.json",
+                {
+                    "kind": "pyamplicol-umami-provider-index",
+                    "schema_version": 1,
+                    "providers": entries,
+                },
+            )
+        )
+    make = "UMAMI_PROVIDERS := " + " ".join(p["id"] for p in entries) + "\n"
+    make += f"UMAMI_SINGLE_PROVIDER := {int(len(documents) == 1)}\n"
+    payloads.append(
+        ApiBundlePayload(
+            "API/umami/providers.mk", make.encode(), "api-build-file", "text/x-makefile"
+        )
+    )
+    return tuple(payloads)
+
+
+__all__ = [
+    "FLAVOR_BLIND_ASSUMPTION",
+    "UmamiProcessInput",
+    "build_umami_metadata",
+    "umami_bundle_payloads",
+]
diff --git a/pyamplicol/src/pyamplicol/artifacts/umami_c.py b/pyamplicol/src/pyamplicol/artifacts/umami_c.py
new file mode 100644
index 0000000000..fc9f94efc6
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/umami_c.py
@@ -0,0 +1,173 @@
+# SPDX-License-Identifier: 0BSD
+"""Small C data emitter shared by generated UMAMI providers."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import Any
+
+
+def _string(value: object) -> str:
+    return "NULL" if value is None else json.dumps(str(value), ensure_ascii=True)
+
+
+def _number(value: object) -> str:
+    return format(float(value), ".17g")
+
+
+def _boolean(value: object) -> str:
+    return "true" if value else "false"
+
+
+def provider_header(data: Mapping[str, Any]) -> str:
+    """Render the private ABI defined by ``umami_provider.h``."""
+    provider = data["provider"]
+    lines = [
+        "/* SPDX-License-Identifier: 0BSD */",
+        "/* Generated from the same records as metadata.json. */",
+        '#include "umami_provider.h"',
+        f"#define UMAMI_HAS_ALPHA_S {int(provider['supports_alpha_s'])}",
+        f"#define UMAMI_HAS_COLOR_FLOW {int(provider['color_accuracy'] == 'lc')}",
+        f"#define UMAMI_ARTIFACT_ID {_string(provider.get('artifact_id'))}",
+        "static const double umami_masses[] = {"
+        + ", ".join(_number(v) for v in provider["masses"])
+        + "};",
+    ]
+    process_rows = []
+    for index, process in enumerate(data["runtime_processes"]):
+        prefix = f"umami_p{index}"
+        lines.append(
+            f"static const int {prefix}_pdgs[] = {{"
+            + ", ".join(str(v) for v in process["pdgs"])
+            + "};"
+        )
+        helicities = process["helicity_ids"]
+        parameters = process["parameters"]
+        if helicities:
+            lines.append(
+                f"static const char *const {prefix}_helicities[] = {{"
+                + ", ".join(_string(v) for v in helicities)
+                + "};"
+            )
+        if parameters:
+            lines.append(f"static const UmamiParameter {prefix}_parameters[] = {{")
+            for p in parameters:
+                lines.append(
+                    "    {"
+                    + ", ".join(
+                        (
+                            _string(p["name"]),
+                            _number(p["default_real"]),
+                            _number(p.get("default_imaginary", 0.0)),
+                            _boolean(p["mutable"]),
+                            _boolean(
+                                p.get(
+                                    "is_complex", p.get("default_imaginary", 0.0) != 0.0
+                                )
+                            ),
+                        )
+                    )
+                    + "},"
+                )
+            lines.append("};")
+        process_rows.append(
+            "    {"
+            + ", ".join(
+                (
+                    _string(process["id"]),
+                    f"{prefix}_pdgs",
+                    _string(process["alpha_s_parameter"]),
+                    _string(process["color_accuracy"]),
+                    str(len(helicities)),
+                    f"{prefix}_helicities" if helicities else "NULL",
+                    str(len(parameters)),
+                    f"{prefix}_parameters" if parameters else "NULL",
+                )
+            )
+            + "},"
+        )
+    lines.extend(
+        ["static const UmamiProcess umami_processes[] = {", *process_rows, "};"]
+    )
+    channel_rows = []
+    for channel_index, channel in enumerate(data["channels"]):
+        flavour_rows = []
+        for flavour_index, flavour in enumerate(channel["processes"]):
+            prefix = f"umami_c{channel_index}_f{flavour_index}"
+            runtime = flavour["runtime"]
+            lines.append(
+                f"static const size_t {prefix}_permutation[] = {{"
+                + ", ".join(str(v) for v in runtime["permutation"])
+                + "};"
+            )
+            exported = runtime["helicity_export"]
+            to_runtime = [-1] * len(data["helicities"])
+            for runtime_index, export_index in enumerate(exported):
+                to_runtime[export_index] = runtime_index
+            lines.append(
+                f"static const int {prefix}_helicity_runtime[] = {{"
+                + ", ".join(str(v) for v in to_runtime or [-1])
+                + "};"
+            )
+            lines.append(
+                f"static const size_t {prefix}_helicity_export[] = {{"
+                + ", ".join(str(v) for v in exported or [0])
+                + "};"
+            )
+            lines.append(
+                f"static const UmamiContribution {prefix}_contributions[] = {{"
+            )
+            lines.append(
+                "    {"
+                + ", ".join(
+                    (
+                        str(runtime["process_index"]),
+                        _string(runtime["color_id"]),
+                        str(runtime["color_index"]),
+                        f"{prefix}_permutation",
+                        _number(runtime["factor"]),
+                        f"{prefix}_helicity_runtime",
+                        f"{prefix}_helicity_export",
+                    )
+                )
+                + "},"
+            )
+            lines.append("};")
+            flavour_rows.append(f"    {{1, {prefix}_contributions}},")
+        lines.extend(
+            [
+                f"static const UmamiFlavour umami_c{channel_index}_flavours[] = {{",
+                *flavour_rows,
+                "};",
+            ]
+        )
+        channel_rows.append(
+            f"    {{{len(flavour_rows)}, umami_c{channel_index}_flavours}},"
+        )
+    lines.extend(
+        ["static const UmamiChannel umami_channels[] = {", *channel_rows, "};"]
+    )
+    lines.extend(
+        [
+            "static const UmamiProvider umami_provider = {",
+            "    "
+            + ", ".join(
+                (
+                    _string(provider["id"]),
+                    str(provider["particle_count"]),
+                    str(provider["incoming_count"]),
+                    str(provider["helicity_count"]),
+                    str(provider["color_count"]),
+                    str(len(data["helicities"])),
+                )
+            )
+            + ",",
+            f"    umami_masses, {len(process_rows)}, umami_processes,",
+            f"    {len(channel_rows)}, umami_channels, "
+            + _boolean(provider["supports_alpha_s"]),
+            "};",
+            "",
+        ]
+    )
+    return "\n".join(lines)
diff --git a/pyamplicol/src/pyamplicol/artifacts/umami_otf.py b/pyamplicol/src/pyamplicol/artifacts/umami_otf.py
new file mode 100644
index 0000000000..3282601e3a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/umami_otf.py
@@ -0,0 +1,191 @@
+# SPDX-License-Identifier: 0BSD
+"""Explicit SDK selector tables from a compact on-the-fly source seed.
+
+This does not construct recurrence schedules or discover amplitude relations.
+The expanded tables are SDK payloads only; the runtime seed remains compact.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import replace
+from itertools import product
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ..generation.on_the_fly_seed import OnTheFlyProcessSeedProjectionV1
+    from ..processes.ir import CanonicalProcessIR
+    from .umami import UmamiProcessInput
+
+
+def build_umami_on_the_fly_physics(
+    public_metadata: Mapping[str, Any],
+    process: CanonicalProcessIR,
+    seed: OnTheFlyProcessSeedProjectionV1,
+) -> tuple[dict[str, Any], tuple[Mapping[str, Any], ...]]:
+    """Enumerate available axes, conservatively without additional proofs."""
+    from ..color import build_color_plan
+
+    sources = {source.public_label: source for source in seed.external_sources}
+    # Match the native selector's seed-domain order exactly. Its mixed-radix
+    # enumeration, like product(), varies the last public leg fastest.
+    domains = [
+        tuple(state.public_helicity for state in sources[leg.label].source_states)
+        for leg in process.legs
+    ]
+    helicities = []
+    for index, values in enumerate(product(*domains)):
+        identifier = "h:" + ",".join(f"{value:+d}" for value in values)
+        helicities.append(
+            {
+                "id": identifier,
+                "index": index,
+                "values": list(values),
+                "computed": True,
+                "representative_id": identifier,
+                "coefficient": 1.0,
+                "structural_zero": False,
+            }
+        )
+    sectors: tuple[Mapping[str, Any], ...] = ()
+    if process.color_accuracy == "lc":
+        plan = build_color_plan(process, color_accuracy="lc")
+        sectors = tuple(sector.to_json_dict() for sector in plan.sectors)
+        colors = []
+        for index, sector in enumerate(plan.sectors):
+            word = tuple(sector.word_labels or sector.color_words[0])
+            identifier = "flow:" + (
+                ",".join(str(label) for label in word) if word else "singlet"
+            )
+            colors.append(
+                {
+                    "kind": "lc-flow",
+                    "id": identifier,
+                    "index": index,
+                    "word": list(word),
+                    "computed": True,
+                    "representative_id": identifier,
+                    "coefficient": 1.0,
+                }
+            )
+    else:
+        colors = [{"kind": "contracted-color", "id": "color:contracted", "index": 0}]
+    return (
+        {
+            **public_metadata,
+            "kind": "pyamplicol-resolved-physics",
+            "helicities": helicities,
+            "color_components": colors,
+            "coverage": {
+                "helicities": "complete",
+                "color": "complete" if process.color_accuracy == "lc" else "contracted",
+            },
+            "extensions": {},
+        },
+        sectors,
+    )
+
+
+def restore_umami_on_the_fly_input(
+    process: UmamiProcessInput, documents: Sequence[Mapping[str, Any]]
+) -> UmamiProcessInput:
+    """Recover an old compact process's explicit SDK axes during append.
+
+    The SDK retains every physical selector and its colour tags in its member
+    records, even when integration orbits have been compressed. Recover those
+    records, not just the exported representatives or their multiplicities.
+    Another provider may also load this runtime for flavour-blind members only.
+    """
+    matches = [
+        (document, runtime)
+        for document in documents
+        for runtime in document["runtime_processes"]
+        if runtime["id"] == process.process_id
+        and any(
+            member["process_id"] == process.process_id
+            for channel in document["channels"]
+            for entry in channel["processes"]
+            for member in entry["members"]
+        )
+    ]
+    if len(matches) != 1:
+        raise ValueError("UMAMI append requires the previous OTF process metadata")
+    document, runtime = matches[0]
+    if (
+        tuple(runtime["pdgs"]) != process.external_pdgs
+        or runtime["color_accuracy"] != process.color_accuracy
+    ):
+        raise ValueError("previous UMAMI OTF process identity disagrees with append")
+    helicity_values = {
+        "h:" + ",".join(f"{value:+d}" for value in values): list(values)
+        for values in document["helicities"]
+    }
+    helicities = [
+        {
+            "id": identifier,
+            "index": index,
+            "values": helicity_values[identifier],
+            "computed": True,
+            "representative_id": identifier,
+            "coefficient": 1.0,
+            "structural_zero": False,
+        }
+        for index, identifier in enumerate(runtime["helicity_ids"])
+    ]
+    colors = []
+    flows = {}
+    for channel in document["channels"]:
+        for entry in channel["processes"]:
+            for member in entry["members"]:
+                if member["process_id"] != process.process_id:
+                    continue
+                identifier = member["color_id"]
+                if process.color_accuracy != "lc":
+                    colors.append(
+                        {
+                            "kind": "contracted-color",
+                            "id": "color:contracted",
+                            "index": 0,
+                        }
+                    )
+                    continue
+                if not isinstance(identifier, str) or not identifier.startswith(
+                    "flow:"
+                ):
+                    raise ValueError("previous UMAMI OTF colour selector is invalid")
+                suffix = identifier.removeprefix("flow:")
+                word = (
+                    [] if suffix == "singlet" else [int(v) for v in suffix.split(",")]
+                )
+                tags = document["color_flows"][member["color_flows"]]
+                if len(tags) != len(process.external_pdgs) or any(
+                    len(pair) != 2 or any(not isinstance(v, int) or v < 0 for v in pair)
+                    for pair in tags
+                ):
+                    raise ValueError("previous UMAMI OTF colour tags are invalid")
+                flows[identifier] = tags
+                colors.append(
+                    {
+                        "kind": "lc-flow",
+                        "id": identifier,
+                        "index": len(colors),
+                        "word": word,
+                        "computed": True,
+                        "representative_id": identifier,
+                        "coefficient": 1.0,
+                    }
+                )
+    if not helicities or not colors or len({c["id"] for c in colors}) != len(colors):
+        raise ValueError("previous UMAMI OTF selectors are empty or repeated")
+    return replace(
+        process,
+        physics={
+            **process.physics,
+            "kind": "pyamplicol-resolved-physics",
+            "helicities": helicities,
+            "color_components": colors,
+            "coverage": dict(runtime["coverage"]),
+            "extensions": {},
+        },
+        color_flows=flows,
+    )
diff --git a/pyamplicol/src/pyamplicol/artifacts/umami_reweight.py b/pyamplicol/src/pyamplicol/artifacts/umami_reweight.py
new file mode 100644
index 0000000000..9855832618
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/umami_reweight.py
@@ -0,0 +1,235 @@
+# SPDX-License-Identifier: 0BSD
+"""UMAMI providers of colour-accuracy ratios between two artifacts.
+
+The ratio is the target matrix element (e.g. full colour) over the leading-colour
+reference summed over all colour flows, both at the helicity of the event. It
+reweights events of a leading-colour UMAMI provider generated from the same
+processes, with the channel, flavour and helicity indices of that provider.
+"""
+
+from __future__ import annotations
+
+import importlib.resources
+import json
+import os
+import re
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from .umami_c import _boolean, _string
+
+_TEMPLATES = {
+    "umami_reweight.c": "umami_reweight.c",
+    "reweight_provider.h": "reweight_provider.h",
+    "umami.h": "umami.h",
+    "umami.exports": "umami.exports",
+    "umami.exports.macos": "umami.exports.macos",
+    "UMAMI_LICENSE": "UMAMI_LICENSE",
+    "Makefile.reweight": "Makefile",
+}
+
+
+_IDENTIFIER = re.compile(r"[A-Za-z0-9_]+")
+
+
+def _identifier(value: object) -> str:
+    # Provider ids end up in file names and in the makefile.
+    if not isinstance(value, str) or not _IDENTIFIER.fullmatch(value):
+        raise ValueError(f"invalid UMAMI provider id {value!r}")
+    return value
+
+
+def _integer(value: object) -> int:
+    # Metadata values are written into generated C sources.
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ValueError(f"expected an integer in the UMAMI metadata, got {value!r}")
+    return value
+
+
+def load_umami_metadata(artifact: Path) -> list[dict[str, Any]]:
+    """The metadata documents of all UMAMI providers of an artifact."""
+    root = (Path(artifact) / "API" / "umami").resolve()
+    index = json.loads((root / "metadata.json").read_text(encoding="utf-8"))
+    if index.get("kind") != "pyamplicol-umami-provider-index":
+        return [index]
+    documents = []
+    for entry in index["providers"]:
+        path = (root / entry["metadata"]).resolve()
+        if not path.is_relative_to(root):
+            raise ValueError(f"UMAMI metadata path {entry['metadata']!r} leaves {root}")
+        documents.append(json.loads(path.read_text(encoding="utf-8")))
+    return documents
+
+
+def _process_row(process: Mapping[str, Any], prefix: str, lines: list[str]) -> str:
+    lines.append(
+        f"static const int {prefix}_pdgs[] = {{"
+        + ", ".join(str(_integer(v)) for v in process["pdgs"])
+        + "};"
+    )
+    return (
+        "    {"
+        + ", ".join(
+            (
+                _string(process["id"]),
+                f"{prefix}_pdgs",
+                _string(process["alpha_s_parameter"]),
+                str(len(process["helicity_ids"])),
+            )
+        )
+        + "},"
+    )
+
+
+def _int_array(name: str, ctype: str, values: Sequence[int]) -> str:
+    return (
+        f"static const {ctype} {name}[] = {{"
+        + ", ".join(str(_integer(v)) for v in values or [-1])
+        + "};"
+    )
+
+
+def reweight_header(
+    reference: Mapping[str, Any],
+    targets: Sequence[Mapping[str, Any]],
+    reference_path: str,
+    target_path: str,
+) -> str:
+    """Render the tables of one reweight provider, see ``reweight_provider.h``."""
+    target_processes: list[Mapping[str, Any]] = []
+    target_ids: list[str | None] = []
+    target_lookup = {}
+    for document in targets:
+        for process in document["runtime_processes"]:
+            target_lookup.setdefault(
+                tuple(process["pdgs"]), (process, document["provider"]["artifact_id"])
+            )
+    reference_processes = reference["runtime_processes"]
+    lines = [
+        "/* SPDX-License-Identifier: 0BSD */",
+        "/* Generated from the UMAMI metadata of the two artifacts. */",
+        '#include "reweight_provider.h"',
+    ]
+    rows = [
+        _process_row(process, f"reweight_r{i}", lines)
+        for i, process in enumerate(reference_processes)
+    ]
+    lines.extend(["static const ReweightProcess reweight_references[] = {", *rows, "};"])
+
+    exported_count = len(reference["helicities"])
+    channel_rows = []
+    for c, channel in enumerate(reference["channels"]):
+        flavour_rows = []
+        for f, entry in enumerate(channel["processes"]):
+            runtime = entry["runtime"]
+            if "helicity_export" not in runtime:
+                raise ValueError("the reference UMAMI metadata has no helicity export")
+            process_index = _integer(runtime["process_index"])
+            process = reference_processes[process_index]
+            match = target_lookup.get(tuple(process["pdgs"]))
+            if match is None:
+                raise ValueError(
+                    f"no process of the target artifact matches {process['id']!r}"
+                )
+            target, target_id = match
+            if target not in target_processes:
+                target_processes.append(target)
+                target_ids.append(target_id)
+            target_index = target_processes.index(target)
+            reference_helicity = [-1] * exported_count
+            target_helicity = [-1] * exported_count
+            for runtime_index, exported in enumerate(runtime["helicity_export"]):
+                reference_helicity[exported] = runtime_index
+                identifier = process["helicity_ids"][runtime_index]
+                if identifier in target["helicity_ids"]:
+                    target_helicity[exported] = target["helicity_ids"].index(identifier)
+            prefix = f"reweight_c{c}_f{f}"
+            lines.append(
+                _int_array(f"{prefix}_permutation", "size_t", runtime["permutation"])
+            )
+            lines.append(_int_array(f"{prefix}_reference", "int", reference_helicity))
+            lines.append(_int_array(f"{prefix}_target", "int", target_helicity))
+            flavour_rows.append(
+                f"    {{{process_index}, {target_index}, "
+                f"{prefix}_permutation, {prefix}_reference, {prefix}_target}},"
+            )
+        lines.extend(
+            [
+                f"static const ReweightFlavour reweight_c{c}_flavours[] = {{",
+                *flavour_rows,
+                "};",
+            ]
+        )
+        channel_rows.append(f"    {{{len(flavour_rows)}, reweight_c{c}_flavours}},")
+    if len(set(target_ids)) > 1:
+        raise ValueError("the target processes come from different artifacts")
+    rows = [
+        _process_row(process, f"reweight_t{i}", lines)
+        for i, process in enumerate(target_processes)
+    ]
+    lines.extend(["static const ReweightProcess reweight_targets[] = {", *rows, "};"])
+    lines.extend(
+        ["static const ReweightChannel reweight_channels[] = {", *channel_rows, "};"]
+    )
+    supports_alpha_s = all(
+        p["alpha_s_parameter"] is not None
+        for p in [*reference_processes, *target_processes]
+    )
+    lines.extend(
+        [
+            f"#define UMAMI_HAS_ALPHA_S {int(supports_alpha_s)}",
+            "static const ReweightProvider reweight_provider = {",
+            f"    {_string(reference['provider']['id'])}, "
+            f"{_integer(reference['provider']['particle_count'])}, {exported_count},",
+            f"    {_string(reference_path)}, {_string(target_path)},",
+            f"    {_string(reference['provider'].get('artifact_id'))}, "
+            f"{_string(target_ids[0] if target_ids else None)},",
+            f"    {len(reference_processes)}, reweight_references,",
+            f"    {len(target_processes)}, reweight_targets,",
+            f"    {len(channel_rows)}, reweight_channels, {_boolean(supports_alpha_s)}",
+            "};",
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def write_reweight_provider(
+    reference_artifact: str | os.PathLike[str],
+    target_artifact: str | os.PathLike[str],
+    output: str | os.PathLike[str],
+) -> list[str]:
+    """Write the sources of the reweight providers to ``output``.
+
+    One provider is written per UMAMI provider of the leading-colour reference
+    artifact; ``make -C output`` builds ``build/libreweight_<id>.so``. The
+    libraries are initialized with the absolute path of ``output``, the artifacts
+    are found relative to it. Returns the provider ids.
+    """
+    output = Path(output)
+    output.mkdir(parents=True, exist_ok=True)
+    references = load_umami_metadata(Path(reference_artifact))
+    targets = load_umami_metadata(Path(target_artifact))
+    if any(d["provider"]["color_accuracy"] != "lc" for d in references):
+        raise ValueError("the reference artifact must have leading-colour accuracy")
+    reference_path = os.path.relpath(Path(reference_artifact).resolve(), output.resolve())
+    target_path = os.path.relpath(Path(target_artifact).resolve(), output.resolve())
+    templates = importlib.resources.files("pyamplicol.assets.api_templates") / "umami"
+    for source, destination in _TEMPLATES.items():
+        (output / destination).write_bytes((templates / source).read_bytes())
+    ids = []
+    for reference in references:
+        identifier = _identifier(reference["provider"]["id"])
+        (output / f"reweight_{identifier}.h").write_text(
+            reweight_header(reference, targets, reference_path, target_path),
+            encoding="utf-8",
+        )
+        ids.append(identifier)
+    (output / "providers.mk").write_text(
+        "UMAMI_PROVIDERS := " + " ".join(ids) + "\n", encoding="utf-8"
+    )
+    return ids
+
+
+__all__ = ["load_umami_metadata", "reweight_header", "write_reweight_provider"]
diff --git a/pyamplicol/src/pyamplicol/artifacts/writer.py b/pyamplicol/src/pyamplicol/artifacts/writer.py
new file mode 100644
index 0000000000..e7dc464711
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/artifacts/writer.py
@@ -0,0 +1,387 @@
+# SPDX-License-Identifier: 0BSD
+"""High-level schema-v3 artifact builder."""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+import tempfile
+from collections.abc import Mapping, Sequence
+from contextlib import suppress
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import BinaryIO, Literal
+
+from .manifest import (
+    ARTIFACT_IDENTITY_EXTENSION,
+    MANIFEST_NAME,
+    PayloadRecord,
+    artifact_identity_extension,
+    canonical_manifest_bytes,
+    compute_artifact_id,
+    load_manifest,
+)
+from .security import (
+    confined_path,
+    executable_bit,
+    fsync_file,
+    normalize_relative_path,
+    sha256_file,
+)
+from .transaction import ArtifactTransaction, ArtifactWriteMode
+
+
+class ArtifactBuilder:
+    """Build one artifact in a private staging directory."""
+
+    def __init__(
+        self,
+        destination: str | Path,
+        *,
+        mode: ArtifactWriteMode = "error",
+        expected_artifact_id: str | None = None,
+    ) -> None:
+        if expected_artifact_id is not None and mode != "append":
+            raise ValueError("expected_artifact_id is valid only for append mode")
+        self._transaction = ArtifactTransaction(destination, mode=mode)
+        self._expected_artifact_id = expected_artifact_id
+        self.root: Path | None = None
+        self._payloads: dict[str, PayloadRecord] = {}
+
+    def __enter__(self) -> ArtifactBuilder:
+        self.root = self._transaction.__enter__()
+        try:
+            if self._transaction.mode == "append":
+                existing = self.root / MANIFEST_NAME
+                if existing.is_file():
+                    manifest = load_manifest(self.root)
+                    if (
+                        self._expected_artifact_id is not None
+                        and manifest.artifact_id != self._expected_artifact_id
+                    ):
+                        raise ValueError(
+                            "append artifact changed before the transaction lock was "
+                            "acquired; retry the append"
+                        )
+                    self._payloads.update(
+                        (record.path, record) for record in manifest.payloads
+                    )
+                    existing.unlink()
+            return self
+        except BaseException as error:
+            self._transaction.__exit__(type(error), error, error.__traceback__)
+            self.root = None
+            raise
+
+    def _root(self) -> Path:
+        if self.root is None:
+            raise RuntimeError("artifact builder is not active")
+        return self.root
+
+    def staged_path(self, relative: str, *, create_parent: bool = False) -> Path:
+        """Return a confined path in the private staging directory.
+
+        This is intended for producers that already provide their own atomic,
+        streaming writer.  Call :meth:`register_staged_file` after the file is
+        complete and independently validated.
+        """
+
+        path_value = normalize_relative_path(relative)
+        if path_value == MANIFEST_NAME:
+            raise ValueError(f"{MANIFEST_NAME} is reserved for the artifact manifest")
+        path = confined_path(self._root(), path_value, must_exist=False)
+        if create_parent:
+            path.parent.mkdir(parents=True, exist_ok=True)
+        return path
+
+    def register_staged_file(
+        self,
+        relative: str,
+        *,
+        role: str,
+        media_type: str,
+        executable: bool | None = None,
+        target: Mapping[str, object] | None = None,
+        process_id: str | None = None,
+    ) -> PayloadRecord:
+        """Register a complete regular file already present in staging."""
+
+        path_value = normalize_relative_path(relative)
+        path = self.staged_path(path_value)
+        if path.is_symlink() or not path.is_file():
+            raise ValueError(f"staged artifact payload must be a regular file: {path}")
+        if executable is not None:
+            path.chmod(0o755 if executable else 0o644)
+        fsync_file(path)
+        record = PayloadRecord(
+            path=path_value,
+            role=role,
+            media_type=media_type,
+            size_bytes=path.stat().st_size,
+            sha256=sha256_file(path),
+            executable=executable_bit(path),
+            target=dict(target) if target is not None else None,
+            process_id=process_id,
+        )
+        self._payloads[path_value] = record
+        return record
+
+    def add_bytes(
+        self,
+        relative: str,
+        content: bytes,
+        *,
+        role: str,
+        media_type: str,
+        executable: bool = False,
+        target: Mapping[str, object] | None = None,
+        process_id: str | None = None,
+    ) -> PayloadRecord:
+        return self.add_stream(
+            relative,
+            io.BytesIO(content),
+            role=role,
+            media_type=media_type,
+            executable=executable,
+            target=target,
+            process_id=process_id,
+        )
+
+    def add_stream(
+        self,
+        relative: str,
+        source: BinaryIO,
+        *,
+        role: str,
+        media_type: str,
+        executable: bool = False,
+        target: Mapping[str, object] | None = None,
+        process_id: str | None = None,
+        chunk_size: int = 1024 * 1024,
+    ) -> PayloadRecord:
+        """Copy a binary stream into staging with bounded memory."""
+
+        if (
+            not isinstance(chunk_size, int)
+            or isinstance(chunk_size, bool)
+            or chunk_size <= 0
+        ):
+            raise ValueError("artifact stream chunk size must be a positive integer")
+        read = getattr(source, "read", None)
+        if not callable(read):
+            raise TypeError("artifact stream source must provide read()")
+        path_value = normalize_relative_path(relative)
+        path = self.staged_path(path_value, create_parent=True)
+        descriptor, temporary_name = tempfile.mkstemp(
+            prefix=f".{path.name}.", suffix=".tmp", dir=path.parent
+        )
+        temporary = Path(temporary_name)
+        descriptor_open = True
+        try:
+            with os.fdopen(descriptor, "wb") as stream:
+                descriptor_open = False
+                while True:
+                    chunk = source.read(chunk_size)
+                    if not isinstance(chunk, bytes | bytearray | memoryview):
+                        raise TypeError("artifact stream source must return bytes")
+                    if not chunk:
+                        break
+                    if len(chunk) > chunk_size:
+                        raise ValueError(
+                            "artifact stream source returned more bytes than requested"
+                        )
+                    view = memoryview(chunk)
+                    written = 0
+                    while written < len(view):
+                        count = stream.write(view[written:])
+                        if not isinstance(count, int) or count <= 0:
+                            raise OSError("short write while staging artifact payload")
+                        written += count
+                stream.flush()
+                os.fsync(stream.fileno())
+            temporary.chmod(0o755 if executable else 0o644)
+            os.replace(temporary, path)
+        finally:
+            if descriptor_open:
+                os.close(descriptor)
+            with suppress(FileNotFoundError):
+                temporary.unlink()
+        return self.register_staged_file(
+            path_value,
+            role=role,
+            media_type=media_type,
+            executable=executable,
+            target=target,
+            process_id=process_id,
+        )
+
+    def add_json(
+        self,
+        relative: str,
+        value: object,
+        *,
+        role: str,
+        process_id: str | None = None,
+        compact: bool = False,
+    ) -> PayloadRecord:
+        content = (
+            json.dumps(
+                value,
+                indent=None if compact else 2,
+                separators=(",", ":") if compact else None,
+                sort_keys=True,
+                allow_nan=False,
+            )
+            + "\n"
+        ).encode("utf-8")
+        return self.add_bytes(
+            relative,
+            content,
+            role=role,
+            media_type="application/json",
+            process_id=process_id,
+        )
+
+    def add_file(
+        self,
+        relative: str,
+        source: str | Path,
+        *,
+        role: str,
+        media_type: str,
+        executable: bool | None = None,
+        target: Mapping[str, object] | None = None,
+        process_id: str | None = None,
+    ) -> PayloadRecord:
+        requested_source = Path(source).expanduser()
+        if requested_source.is_symlink():
+            raise ValueError(
+                f"artifact source must be a regular file: {requested_source}"
+            )
+        source_path = requested_source.resolve(strict=True)
+        if not source_path.is_file():
+            raise ValueError(f"artifact source must be a regular file: {source_path}")
+        with source_path.open("rb") as stream:
+            return self.add_stream(
+                relative,
+                stream,
+                role=role,
+                media_type=media_type,
+                executable=(
+                    executable_bit(source_path) if executable is None else executable
+                ),
+                target=target,
+                process_id=process_id,
+            )
+
+    def discard_payloads(self, relative: str, *, recursive: bool = False) -> None:
+        """Remove an owned payload or payload subtree from the staging snapshot."""
+
+        path_value = normalize_relative_path(relative)
+        if path_value == MANIFEST_NAME:
+            raise ValueError(f"{MANIFEST_NAME} is reserved for the artifact manifest")
+        prefix = path_value.rstrip("/") + "/"
+        owned = tuple(
+            path
+            for path in self._payloads
+            if path == path_value or (recursive and path.startswith(prefix))
+        )
+        for owned_path in owned:
+            path = confined_path(self._root(), owned_path, must_exist=False)
+            if path.is_symlink() or path.is_dir():
+                raise ValueError(
+                    f"artifact payload must be a regular file: {owned_path}"
+                )
+            if path.exists():
+                path.unlink()
+            self._payloads.pop(owned_path, None)
+        if recursive:
+            root = confined_path(self._root(), path_value, must_exist=False)
+            if root.is_symlink():
+                raise ValueError(
+                    f"artifact payload path must not be a symlink: {path_value}"
+                )
+            if root.is_dir():
+                directories = sorted(
+                    (path for path in root.rglob("*") if path.is_dir()),
+                    key=lambda path: len(path.parts),
+                    reverse=True,
+                )
+                for directory in (*directories, root):
+                    with suppress(OSError):
+                        directory.rmdir()
+
+    def payload_records(self) -> tuple[PayloadRecord, ...]:
+        """Return the immutable, path-ordered staged payload inventory.
+
+        Derived runtime caches use this snapshot to bind their compact native
+        representation to the ordinary artifact payload declarations.  The
+        cache is added only after the snapshot is encoded, so it cannot create
+        a self-hash cycle; normal finalization still includes the cache record
+        in the authoritative runtime artifact identity.
+        """
+
+        self._root()
+        return tuple(sorted(self._payloads.values(), key=lambda item: item.path))
+
+    def finalize(
+        self,
+        *,
+        kind: Literal["pyamplicol-process", "pyamplicol-process-set"],
+        producer: Mapping[str, object],
+        model: Mapping[str, object],
+        configuration: Mapping[str, object],
+        processes: Sequence[Mapping[str, object]],
+        runtime: Mapping[str, object],
+        dependencies: Sequence[Mapping[str, object]] = (),
+        default_process_id: str | None = None,
+        extensions: Mapping[str, object] | None = None,
+    ) -> Path:
+        if not self._payloads:
+            raise ValueError("an artifact must contain at least one payload")
+        manifest_extensions = dict(extensions or {})
+        supplied_identity = manifest_extensions.get(ARTIFACT_IDENTITY_EXTENSION)
+        expected_identity = artifact_identity_extension()
+        if supplied_identity is not None and supplied_identity != expected_identity:
+            raise ValueError(
+                "extensions.artifact_identity is compiler-owned and must use the "
+                "current runtime-payload identity contract"
+            )
+        manifest_extensions[ARTIFACT_IDENTITY_EXTENSION] = expected_identity
+        manifest: dict[str, object] = {
+            "schema_version": 3,
+            "kind": kind,
+            "artifact_id": "0" * 64,
+            "created_utc": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            "producer": dict(producer),
+            "model": dict(model),
+            "configuration": dict(configuration),
+            "processes": [dict(process) for process in processes],
+            "runtime": dict(runtime),
+            "payloads": [
+                record.as_dict()
+                for record in sorted(
+                    self._payloads.values(),
+                    key=lambda item: item.path,
+                )
+            ],
+            "dependencies": [dict(dependency) for dependency in dependencies],
+            "extensions": manifest_extensions,
+        }
+        if default_process_id is not None:
+            manifest["default_process_id"] = default_process_id
+        manifest["artifact_id"] = compute_artifact_id(manifest)
+        path = self._root() / MANIFEST_NAME
+        path.write_bytes(canonical_manifest_bytes(manifest))
+        path.chmod(0o644)
+        fsync_file(path)
+        return path
+
+    def __exit__(self, *exception: object) -> bool:
+        if exception[0] is None and not (self._root() / MANIFEST_NAME).is_file():
+            raise RuntimeError("artifact builder exited without finalize()")
+        return self._transaction.__exit__(*exception)  # type: ignore[arg-type]
+
+
+__all__ = ["ArtifactBuilder"]
diff --git a/pyamplicol/src/pyamplicol/assets/__init__.py b/pyamplicol/src/pyamplicol/assets/__init__.py
new file mode 100644
index 0000000000..be31ea44b9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: 0BSD
+"""Wheel-owned models and generated-output templates."""
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/__init__.py b/pyamplicol/src/pyamplicol/assets/api_templates/__init__.py
new file mode 100644
index 0000000000..4267ca4dfb
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: 0BSD
+"""Source templates copied into generated process artifacts."""
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/c/Makefile b/pyamplicol/src/pyamplicol/assets/api_templates/c/Makefile
new file mode 100644
index 0000000000..4c0d18953f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/c/Makefile
@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: 0BSD
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell \
+	if command -v "$(RUSTICOL_CONFIG)" >/dev/null 2>&1; then \
+		command -v "$(RUSTICOL_CONFIG)"; \
+	elif [ "$(RUSTICOL_CONFIG)" = rusticol-config ]; then \
+		directory="$(CURDIR)"; \
+		while [ "$$directory" != / ]; do \
+			candidate="$$directory/.venv/bin/rusticol-config"; \
+			if [ -x "$$candidate" ]; then printf '%s\n' "$$candidate"; break; fi; \
+			directory=$$(dirname "$$directory"); \
+		done; \
+	fi)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+CC ?= cc
+ARTIFACT_DIR := $(abspath ../..)
+BUILD_DIR ?= $(abspath ../../..)/.pyamplicol-api-build/$(notdir $(ARTIFACT_DIR))/c
+TARGET := $(BUILD_DIR)/check_standalone
+CPPFLAGS += $(shell "$(RUSTICOL_CONFIG_PATH)" --cflags)
+CFLAGS ?= -O2
+CFLAGS += -std=c11 -Wall -Wextra -pedantic
+LDLIBS += $(shell "$(RUSTICOL_CONFIG_PATH)" --libs)
+
+.PHONY: all check_standalone clean run
+
+all: $(TARGET)
+
+check_standalone: $(TARGET)
+
+$(BUILD_DIR):
+	mkdir -p "$@"
+
+$(TARGET): check_standalone.c | $(BUILD_DIR)
+	$(CC) $(CPPFLAGS) $(CFLAGS) "$<" -o "$@" $(LDLIBS)
+
+run: $(TARGET)
+	cd "$(ARTIFACT_DIR)" && "$(TARGET)" $(ARGS)
+
+clean:
+	$(RM) "$(TARGET)"
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/c/check_standalone.c b/pyamplicol/src/pyamplicol/assets/api_templates/c/check_standalone.c
new file mode 100644
index 0000000000..defccd3210
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/c/check_standalone.c
@@ -0,0 +1,885 @@
+/* SPDX-License-Identifier: 0BSD */
+
+#include <rusticol.h>
+
+#include <errno.h>
+#include <inttypes.h>
+#include <math.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAX_OVERRIDES 128
+
+typedef struct {
+    const char *process;
+    const char *model_parameters;
+    const char *kinematics;
+    const char *parameter_names[MAX_OVERRIDES];
+    double parameter_real[MAX_OVERRIDES];
+    double parameter_imaginary[MAX_OVERRIDES];
+    size_t parameter_count;
+    int precision;
+    bool json;
+} Options;
+
+typedef struct {
+    char *id;
+    int32_t *values;
+    size_t value_count;
+} HelicityMetadata;
+
+typedef struct {
+    char *id;
+    char *kind;
+    size_t *word;
+    size_t word_count;
+} ColorMetadata;
+
+typedef int (*RuntimeStringGetter)(
+    const RusticolRuntimeHandle *, char *, size_t, size_t *
+);
+typedef int (*IndexedStringGetter)(
+    const RusticolRuntimeHandle *, size_t, char *, size_t, size_t *
+);
+
+static void fail(const char *message) {
+    fprintf(stderr, "check_standalone: %s\n", message);
+    exit(EXIT_FAILURE);
+}
+
+static void fail_errno(const char *operation) {
+    fprintf(stderr, "check_standalone: %s: %s\n", operation, strerror(errno));
+    exit(EXIT_FAILURE);
+}
+
+static void *allocate(size_t count, size_t size) {
+    void *output;
+    if (count != 0 && size > SIZE_MAX / count) {
+        fail("allocation size overflow");
+    }
+    output = calloc(count == 0 ? 1 : count, size == 0 ? 1 : size);
+    if (output == NULL) {
+        fail("out of memory");
+    }
+    return output;
+}
+
+static void *resize(void *pointer, size_t size) {
+    void *output = realloc(pointer, size == 0 ? 1 : size);
+    if (output == NULL) {
+        free(pointer);
+        fail("out of memory");
+    }
+    return output;
+}
+
+static void check_rusticol(int status, const char *operation) {
+    size_t required = 0;
+    char *message = NULL;
+    if (status == RUSTICOL_STATUS_OK) {
+        return;
+    }
+    if (rusticol_last_error_message(NULL, 0, &required) == RUSTICOL_STATUS_OK &&
+        required > 0) {
+        message = allocate(required, sizeof(*message));
+        if (rusticol_last_error_message(message, required, &required) !=
+            RUSTICOL_STATUS_OK) {
+            free(message);
+            message = NULL;
+        }
+    }
+    fprintf(
+        stderr,
+        "check_standalone: %s failed (status %d)%s%s\n",
+        operation,
+        status,
+        message == NULL ? "" : ": ",
+        message == NULL ? "" : message
+    );
+    free(message);
+    exit(EXIT_FAILURE);
+}
+
+static double parse_double(const char *text, const char *description) {
+    char *end = NULL;
+    double value;
+    errno = 0;
+    value = strtod(text, &end);
+    if (text == end || end == NULL || *end != '\0' || errno == ERANGE ||
+        !isfinite(value)) {
+        fprintf(stderr, "check_standalone: invalid %s: %s\n", description, text);
+        exit(EXIT_FAILURE);
+    }
+    return value;
+}
+
+static size_t parse_size(const char *text, const char *description) {
+    char *end = NULL;
+    unsigned long long value;
+    errno = 0;
+    value = strtoull(text, &end, 10);
+    if (text == end || end == NULL || *end != '\0' || errno == ERANGE ||
+        value > SIZE_MAX) {
+        fprintf(stderr, "check_standalone: invalid %s: %s\n", description, text);
+        exit(EXIT_FAILURE);
+    }
+    return (size_t)value;
+}
+
+static Options parse_options(int argc, char **argv) {
+    Options options = {0};
+    int index;
+    options.precision = 16;
+    for (index = 1; index < argc; ++index) {
+        const char *argument = argv[index];
+        if (strcmp(argument, "--") == 0) {
+            continue;
+        }
+        if (strcmp(argument, "--process") == 0) {
+            if (++index >= argc) {
+                fail("missing value after --process");
+            }
+            options.process = argv[index];
+        } else if (strcmp(argument, "--model-parameters") == 0) {
+            if (++index >= argc) {
+                fail("missing value after --model-parameters");
+            }
+            options.model_parameters = argv[index];
+        } else if (strcmp(argument, "--kinematics") == 0) {
+            if (++index >= argc) {
+                fail("missing value after --kinematics");
+            }
+            options.kinematics = argv[index];
+        } else if (strcmp(argument, "--set-parameter") == 0) {
+            size_t slot = options.parameter_count;
+            if (index + 3 >= argc) {
+                fail("--set-parameter requires NAME REAL IMAG");
+            }
+            if (slot >= MAX_OVERRIDES) {
+                fail("too many --set-parameter options");
+            }
+            options.parameter_names[slot] = argv[++index];
+            options.parameter_real[slot] =
+                parse_double(argv[++index], "real model-parameter component");
+            options.parameter_imaginary[slot] =
+                parse_double(argv[++index], "imaginary model-parameter component");
+            options.parameter_count += 1;
+        } else if (strcmp(argument, "--precision") == 0) {
+            size_t precision;
+            if (++index >= argc) {
+                fail("missing value after --precision");
+            }
+            precision = parse_size(argv[index], "--precision value");
+            if (precision > INT32_MAX) {
+                fail("invalid --precision value");
+            }
+            options.precision = (int)precision;
+        } else if (strcmp(argument, "--json") == 0) {
+            options.json = true;
+        } else if (strcmp(argument, "--help") == 0 || strcmp(argument, "-h") == 0) {
+            puts(
+                "usage: check_standalone [--process ID|EXPRESSION] "
+                "[--model-parameters PATH] "
+                "[--kinematics PATH] "
+                "[--set-parameter NAME REAL IMAG] "
+                "[--precision 16] [--json]"
+            );
+            exit(EXIT_SUCCESS);
+        } else {
+            fprintf(stderr, "check_standalone: unknown option: %s\n", argument);
+            exit(EXIT_FAILURE);
+        }
+    }
+    if (options.precision != 16) {
+        fail("the C Rusticol API supports only double precision (--precision 16)");
+    }
+    return options;
+}
+
+static char *runtime_string(
+    const RusticolRuntimeHandle *runtime,
+    RuntimeStringGetter getter,
+    const char *operation
+) {
+    size_t required = 0;
+    char *output;
+    check_rusticol(getter(runtime, NULL, 0, &required), operation);
+    if (required == 0) {
+        fail("Rusticol returned an invalid string size");
+    }
+    output = allocate(required, sizeof(*output));
+    check_rusticol(getter(runtime, output, required, &required), operation);
+    return output;
+}
+
+static char *indexed_string(
+    const RusticolRuntimeHandle *runtime,
+    size_t index,
+    IndexedStringGetter getter,
+    const char *operation
+) {
+    size_t required = 0;
+    char *output;
+    check_rusticol(getter(runtime, index, NULL, 0, &required), operation);
+    if (required == 0) {
+        fail("Rusticol returned an invalid indexed string size");
+    }
+    output = allocate(required, sizeof(*output));
+    check_rusticol(getter(runtime, index, output, required, &required), operation);
+    return output;
+}
+
+static char *read_line(FILE *stream) {
+    size_t capacity = 256;
+    size_t length = 0;
+    char *line = allocate(capacity, sizeof(*line));
+    int character;
+    while ((character = fgetc(stream)) != EOF && character != '\n') {
+        if (length + 1 >= capacity) {
+            if (capacity > SIZE_MAX / 2) {
+                free(line);
+                fail("validation-point row is too large");
+            }
+            capacity *= 2;
+            line = resize(line, capacity);
+        }
+        line[length++] = (char)character;
+    }
+    if (ferror(stream)) {
+        free(line);
+        fail_errno("read API/validation_points.dat");
+    }
+    if (character == EOF && length == 0) {
+        free(line);
+        return NULL;
+    }
+    if (length > 0 && line[length - 1] == '\r') {
+        length -= 1;
+    }
+    line[length] = '\0';
+    return line;
+}
+
+static char *take_field(char **cursor) {
+    char *field;
+    char *separator;
+    if (*cursor == NULL) {
+        return NULL;
+    }
+    field = *cursor;
+    separator = strchr(field, '\t');
+    if (separator == NULL) {
+        *cursor = NULL;
+    } else {
+        *separator = '\0';
+        *cursor = separator + 1;
+    }
+    return field;
+}
+
+static double *load_validation_point(
+    const char *path,
+    const char *process_key,
+    size_t external_count
+) {
+    FILE *input = fopen(path, "r");
+    char *line;
+    if (input == NULL) {
+        if (errno == ENOENT) {
+            return NULL;
+        }
+        fail_errno("open API/validation_points.dat");
+    }
+    line = read_line(input);
+    if (line == NULL || strcmp(line, "RUSTICOL_VALIDATION_POINTS_V1") != 0) {
+        free(line);
+        fclose(input);
+        fail("unsupported validation_points.dat format");
+    }
+    free(line);
+
+    while ((line = read_line(input)) != NULL) {
+        char *cursor = line;
+        char *row_process;
+        char *row_count_text;
+        size_t row_count;
+        size_t momentum_count;
+        size_t index;
+        double *momenta;
+        if (line[0] == '\0' || line[0] == '#') {
+            free(line);
+            continue;
+        }
+        row_process = take_field(&cursor);
+        row_count_text = take_field(&cursor);
+        if (row_process == NULL || row_count_text == NULL) {
+            free(line);
+            fclose(input);
+            fail("invalid validation point row");
+        }
+        if (strcmp(row_process, process_key) != 0) {
+            free(line);
+            continue;
+        }
+        row_count = parse_size(row_count_text, "validation external-particle count");
+        if (row_count != external_count || external_count > SIZE_MAX / 4) {
+            free(line);
+            fclose(input);
+            fail("validation point has an incompatible external-particle count");
+        }
+        momentum_count = 4 * external_count;
+        momenta = allocate(momentum_count, sizeof(*momenta));
+        for (index = 0; index < momentum_count; ++index) {
+            char *component = take_field(&cursor);
+            if (component == NULL) {
+                free(momenta);
+                free(line);
+                fclose(input);
+                fail("validation point has too few momentum components");
+            }
+            momenta[index] =
+                parse_double(component, "validation-point momentum component");
+        }
+        if (cursor != NULL) {
+            free(momenta);
+            free(line);
+            fclose(input);
+            fail("validation point has too many momentum components");
+        }
+        free(line);
+        if (fclose(input) != 0) {
+            free(momenta);
+            fail_errno("close API/validation_points.dat");
+        }
+        return momenta;
+    }
+    if (fclose(input) != 0) {
+        fail_errno("close API/validation_points.dat");
+    }
+    return NULL;
+}
+
+static size_t *load_external_permutation(
+    const RusticolRuntimeHandle *runtime,
+    size_t expected_count
+) {
+    size_t required = 0;
+    size_t *permutation;
+    check_rusticol(
+        rusticol_runtime_external_permutation(runtime, NULL, 0, &required),
+        "query external permutation size"
+    );
+    if (required != expected_count) {
+        fail("external permutation has an incompatible size");
+    }
+    permutation = allocate(required, sizeof(*permutation));
+    check_rusticol(
+        rusticol_runtime_external_permutation(
+            runtime, permutation, required, &required
+        ),
+        "query external permutation"
+    );
+    return permutation;
+}
+
+static double *reorder_validation_point(
+    double *representative,
+    const size_t *permutation,
+    size_t external_count
+) {
+    double *public_point = allocate(4 * external_count, sizeof(*public_point));
+    bool *seen = allocate(external_count, sizeof(*seen));
+    size_t representative_index;
+    for (representative_index = 0; representative_index < external_count;
+         ++representative_index) {
+        size_t public_index = permutation[representative_index];
+        if (public_index >= external_count || seen[public_index]) {
+            free(seen);
+            free(public_point);
+            free(representative);
+            fail("runtime returned an invalid external permutation");
+        }
+        seen[public_index] = true;
+        memcpy(
+            &public_point[4 * public_index],
+            &representative[4 * representative_index],
+            4 * sizeof(*public_point)
+        );
+    }
+    free(seen);
+    free(representative);
+    return public_point;
+}
+
+static double *load_kinematics_json(
+    const RusticolRuntimeHandle *runtime,
+    const char *path,
+    size_t expected_count
+) {
+    size_t required = 0;
+    double *momenta;
+    check_rusticol(
+        rusticol_runtime_load_kinematics_json(
+            runtime, path, NULL, 0, &required
+        ),
+        "query kinematics JSON size"
+    );
+    if (required != 4 * expected_count) {
+        fail("kinematics JSON has an incompatible external-particle count");
+    }
+    momenta = allocate(required, sizeof(*momenta));
+    check_rusticol(
+        rusticol_runtime_load_kinematics_json(
+            runtime, path, momenta, required, &required
+        ),
+        "load kinematics JSON"
+    );
+    return momenta;
+}
+
+static int32_t *load_external_particles(
+    const RusticolRuntimeHandle *runtime,
+    size_t *count
+) {
+    int32_t *particles;
+    size_t index;
+    check_rusticol(
+        rusticol_runtime_external_count(runtime, count),
+        "query external-particle count"
+    );
+    particles = allocate(*count, sizeof(*particles));
+    for (index = 0; index < *count; ++index) {
+        check_rusticol(
+            rusticol_runtime_external_pdg(runtime, index, &particles[index]),
+            "query external-particle PDG"
+        );
+    }
+    return particles;
+}
+
+static HelicityMetadata *load_helicities(
+    const RusticolRuntimeHandle *runtime,
+    size_t *count
+) {
+    HelicityMetadata *items;
+    size_t index;
+    check_rusticol(
+        rusticol_runtime_helicity_count(runtime, count),
+        "query helicity count"
+    );
+    items = allocate(*count, sizeof(*items));
+    for (index = 0; index < *count; ++index) {
+        items[index].id = indexed_string(
+            runtime,
+            index,
+            rusticol_runtime_helicity_id,
+            "query helicity ID"
+        );
+        check_rusticol(
+            rusticol_runtime_helicity_vector(
+                runtime, index, NULL, 0, &items[index].value_count
+            ),
+            "query helicity-vector size"
+        );
+        items[index].values =
+            allocate(items[index].value_count, sizeof(*items[index].values));
+        if (items[index].value_count > 0) {
+            check_rusticol(
+                rusticol_runtime_helicity_vector(
+                    runtime,
+                    index,
+                    items[index].values,
+                    items[index].value_count,
+                    &items[index].value_count
+                ),
+                "query helicity vector"
+            );
+        }
+    }
+    return items;
+}
+
+static ColorMetadata *load_colors(
+    const RusticolRuntimeHandle *runtime,
+    size_t *count
+) {
+    ColorMetadata *items;
+    size_t index;
+    check_rusticol(rusticol_runtime_color_count(runtime, count), "query color count");
+    items = allocate(*count, sizeof(*items));
+    for (index = 0; index < *count; ++index) {
+        items[index].id = indexed_string(
+            runtime, index, rusticol_runtime_color_id, "query color ID"
+        );
+        items[index].kind = indexed_string(
+            runtime, index, rusticol_runtime_color_kind, "query color kind"
+        );
+        check_rusticol(
+            rusticol_runtime_color_word(
+                runtime, index, NULL, 0, &items[index].word_count
+            ),
+            "query color-word size"
+        );
+        items[index].word =
+            allocate(items[index].word_count, sizeof(*items[index].word));
+        if (items[index].word_count > 0) {
+            check_rusticol(
+                rusticol_runtime_color_word(
+                    runtime,
+                    index,
+                    items[index].word,
+                    items[index].word_count,
+                    &items[index].word_count
+                ),
+                "query color word"
+            );
+        }
+    }
+    return items;
+}
+
+static void write_json_string(const char *value) {
+    const unsigned char *cursor = (const unsigned char *)value;
+    putchar('"');
+    while (*cursor != '\0') {
+        unsigned char character = *cursor++;
+        switch (character) {
+        case '"': fputs("\\\"", stdout); break;
+        case '\\': fputs("\\\\", stdout); break;
+        case '\b': fputs("\\b", stdout); break;
+        case '\f': fputs("\\f", stdout); break;
+        case '\n': fputs("\\n", stdout); break;
+        case '\r': fputs("\\r", stdout); break;
+        case '\t': fputs("\\t", stdout); break;
+        default:
+            if (character < 0x20) {
+                printf("\\u%04x", (unsigned int)character);
+            } else {
+                putchar((int)character);
+            }
+        }
+    }
+    putchar('"');
+}
+
+static void write_common_json(
+    const char *process,
+    const char *process_key,
+    const char *color_accuracy,
+    const int32_t *particles,
+    size_t particle_count,
+    const HelicityMetadata *helicities,
+    size_t helicity_count,
+    const ColorMetadata *colors,
+    size_t color_count
+) {
+    size_t index;
+    fputs("\"process\":", stdout);
+    write_json_string(process);
+    fputs(",\"process_key\":", stdout);
+    write_json_string(process_key);
+    fputs(",\"color_accuracy\":", stdout);
+    write_json_string(color_accuracy);
+    fputs(",\"external_particles\":[", stdout);
+    for (index = 0; index < particle_count; ++index) {
+        if (index != 0) {
+            putchar(',');
+        }
+        printf("{\"index\":%zu,\"pdg\":%" PRId32 "}", index, particles[index]);
+    }
+    fputs("],\"helicities\":[", stdout);
+    for (index = 0; index < helicity_count; ++index) {
+        size_t component;
+        if (index != 0) {
+            putchar(',');
+        }
+        fputs("{\"id\":", stdout);
+        write_json_string(helicities[index].id);
+        fputs(",\"helicities\":[", stdout);
+        for (component = 0; component < helicities[index].value_count; ++component) {
+            if (component != 0) {
+                putchar(',');
+            }
+            printf("%" PRId32, helicities[index].values[component]);
+        }
+        fputs("]}", stdout);
+    }
+    fputs("],\"colors\":[", stdout);
+    for (index = 0; index < color_count; ++index) {
+        size_t component;
+        if (index != 0) {
+            putchar(',');
+        }
+        fputs("{\"id\":", stdout);
+        write_json_string(colors[index].id);
+        fputs(",\"kind\":", stdout);
+        write_json_string(colors[index].kind);
+        fputs(",\"word\":[", stdout);
+        for (component = 0; component < colors[index].word_count; ++component) {
+            if (component != 0) {
+                putchar(',');
+            }
+            printf("%zu", colors[index].word[component]);
+        }
+        fputs("]}", stdout);
+    }
+    putchar(']');
+}
+
+static void free_helicities(HelicityMetadata *items, size_t count) {
+    size_t index;
+    for (index = 0; index < count; ++index) {
+        free(items[index].id);
+        free(items[index].values);
+    }
+    free(items);
+}
+
+static void free_colors(ColorMetadata *items, size_t count) {
+    size_t index;
+    for (index = 0; index < count; ++index) {
+        free(items[index].id);
+        free(items[index].kind);
+        free(items[index].word);
+    }
+    free(items);
+}
+
+int main(int argc, char **argv) {
+    Options options = parse_options(argc, argv);
+    RusticolRuntimeHandle *runtime = NULL;
+    FILE *manifest;
+    char *process;
+    char *process_key;
+    char *representative_process_key;
+    char *color_accuracy;
+    int32_t *particles;
+    HelicityMetadata *helicities;
+    ColorMetadata *colors;
+    size_t particle_count = 0;
+    size_t helicity_count = 0;
+    size_t color_count = 0;
+    double *momenta;
+    size_t *external_permutation = NULL;
+    double total = NAN;
+    double *resolved = NULL;
+    size_t resolved_helicity_count = 0;
+    size_t resolved_color_count = 0;
+    size_t resolved_count;
+    double explicit_total = 0.0;
+    size_t index;
+
+    manifest = fopen("artifact.json", "r");
+    if (manifest == NULL) {
+        fail("run check_standalone from a generated artifact directory");
+    }
+    if (fclose(manifest) != 0) {
+        fail_errno("close artifact.json");
+    }
+
+    check_rusticol(
+        rusticol_runtime_load(
+            ".", options.process, options.model_parameters, &runtime
+        ),
+        "load artifact"
+    );
+    if (options.parameter_count > 0) {
+        check_rusticol(
+            rusticol_runtime_set_model_parameters(
+                runtime,
+                options.parameter_names,
+                options.parameter_real,
+                options.parameter_imaginary,
+                options.parameter_count
+            ),
+            "set model parameters"
+        );
+    }
+
+    process = runtime_string(runtime, rusticol_runtime_process, "query process");
+    process_key =
+        runtime_string(runtime, rusticol_runtime_process_key, "query process key");
+    representative_process_key = runtime_string(
+        runtime,
+        rusticol_runtime_representative_process_key,
+        "query representative process key"
+    );
+    color_accuracy = runtime_string(
+        runtime, rusticol_runtime_color_accuracy, "query color accuracy"
+    );
+    particles = load_external_particles(runtime, &particle_count);
+    helicities = load_helicities(runtime, &helicity_count);
+    colors = load_colors(runtime, &color_count);
+    if (options.kinematics != NULL) {
+        momenta = load_kinematics_json(runtime, options.kinematics, particle_count);
+    } else {
+        external_permutation = load_external_permutation(runtime, particle_count);
+        momenta = load_validation_point(
+            "API/validation_points.dat", representative_process_key, particle_count
+        );
+        if (momenta != NULL) {
+            momenta = reorder_validation_point(
+                momenta, external_permutation, particle_count
+            );
+        }
+    }
+
+    if (momenta == NULL) {
+        if (options.json) {
+            fputs("{\"language\":\"c\",\"available\":false,", stdout);
+            write_common_json(
+                process,
+                process_key,
+                color_accuracy,
+                particles,
+                particle_count,
+                helicities,
+                helicity_count,
+                colors,
+                color_count
+            );
+            fputs(
+                ",\"diagnostic\":\"no bundled validation point is available\"}\n",
+                stdout
+            );
+        } else {
+            printf("process: %s\n", process);
+            puts("no bundled validation point is available; metadata load succeeded");
+        }
+    } else {
+        check_rusticol(
+            rusticol_runtime_evaluate_f64(
+                runtime, momenta, 4 * particle_count, 1, &total, 1
+            ),
+            "evaluate compatibility total"
+        );
+        check_rusticol(
+            rusticol_runtime_resolved_shape(
+                runtime,
+                NULL,
+                0,
+                NULL,
+                0,
+                &resolved_helicity_count,
+                &resolved_color_count
+            ),
+            "query resolved shape"
+        );
+        if (resolved_helicity_count != helicity_count ||
+            resolved_color_count != color_count) {
+            fail("resolved shape does not match runtime metadata");
+        }
+        if (resolved_helicity_count != 0 &&
+            resolved_color_count > SIZE_MAX / resolved_helicity_count) {
+            fail("resolved output size overflow");
+        }
+        resolved_count = resolved_helicity_count * resolved_color_count;
+        resolved = allocate(resolved_count, sizeof(*resolved));
+        check_rusticol(
+            rusticol_runtime_evaluate_resolved_f64(
+                runtime,
+                momenta,
+                4 * particle_count,
+                1,
+                NULL,
+                0,
+                NULL,
+                0,
+                resolved,
+                resolved_count,
+                &resolved_helicity_count,
+                &resolved_color_count
+            ),
+            "evaluate resolved components"
+        );
+        if (!isfinite(total)) {
+            fail("matrix-element total is not finite");
+        }
+        for (index = 0; index < resolved_count; ++index) {
+            if (!isfinite(resolved[index])) {
+                fail("resolved matrix-element output is not finite");
+            }
+            explicit_total += resolved[index];
+        }
+
+        if (options.json) {
+            fputs(
+                "{\"language\":\"c\",\"available\":true,\"precision\":16,",
+                stdout
+            );
+            write_common_json(
+                process,
+                process_key,
+                color_accuracy,
+                particles,
+                particle_count,
+                helicities,
+                helicity_count,
+                colors,
+                color_count
+            );
+            printf(
+                ",\"shape\":[1,%zu,%zu],\"values\":[",
+                resolved_helicity_count,
+                resolved_color_count
+            );
+            for (index = 0; index < resolved_count; ++index) {
+                if (index != 0) {
+                    putchar(',');
+                }
+                printf("%.17g", resolved[index]);
+            }
+            printf(
+                "],\"resolved_sum\":[%.17g],\"compatibility_total\":[%.17g]}\n",
+                explicit_total,
+                total
+            );
+        } else {
+            size_t helicity_index;
+            size_t color_index;
+            printf("process: %s [%s]\n", process, process_key);
+            printf(
+                "resolved shape: (1, %zu, %zu)\n",
+                resolved_helicity_count,
+                resolved_color_count
+            );
+            for (helicity_index = 0;
+                 helicity_index < resolved_helicity_count;
+                 ++helicity_index) {
+                for (color_index = 0; color_index < resolved_color_count; ++color_index) {
+                    size_t offset =
+                        helicity_index * resolved_color_count + color_index;
+                    printf(
+                        "  %s  %s  %.17g\n",
+                        helicities[helicity_index].id,
+                        colors[color_index].id,
+                        resolved[offset]
+                    );
+                }
+            }
+            printf("explicit resolved sum: %.17g\n", explicit_total);
+            printf("compatibility total:   %.17g\n", total);
+        }
+        if (!isfinite(explicit_total) ||
+            fabs(explicit_total - total) > 1.0e-12 * fmax(fabs(total), 1.0)) {
+            fail("resolved components do not reproduce the compatibility total");
+        }
+    }
+
+    check_rusticol(rusticol_runtime_free(runtime), "free runtime");
+    free(momenta);
+    free(resolved);
+    free(process);
+    free(process_key);
+    free(representative_process_key);
+    free(external_permutation);
+    free(color_accuracy);
+    free(particles);
+    free_helicities(helicities, helicity_count);
+    free_colors(colors, color_count);
+    return EXIT_SUCCESS;
+}
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/cpp/Makefile b/pyamplicol/src/pyamplicol/assets/api_templates/cpp/Makefile
new file mode 100644
index 0000000000..3edf40f252
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/cpp/Makefile
@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: 0BSD
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell \
+	if command -v "$(RUSTICOL_CONFIG)" >/dev/null 2>&1; then \
+		command -v "$(RUSTICOL_CONFIG)"; \
+	elif [ "$(RUSTICOL_CONFIG)" = rusticol-config ]; then \
+		directory="$(CURDIR)"; \
+		while [ "$$directory" != / ]; do \
+			candidate="$$directory/.venv/bin/rusticol-config"; \
+			if [ -x "$$candidate" ]; then printf '%s\n' "$$candidate"; break; fi; \
+			directory=$$(dirname "$$directory"); \
+		done; \
+	fi)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+CXX ?= c++
+ARTIFACT_DIR := $(abspath ../..)
+BUILD_DIR ?= $(abspath ../../..)/.pyamplicol-api-build/$(notdir $(ARTIFACT_DIR))/cpp
+TARGET := $(BUILD_DIR)/check_standalone
+CPPFLAGS += $(shell "$(RUSTICOL_CONFIG_PATH)" --cflags)
+CXXFLAGS ?= -O2
+CXXFLAGS += -std=c++17 -Wall -Wextra -pedantic
+LDLIBS += $(shell "$(RUSTICOL_CONFIG_PATH)" --libs)
+
+.PHONY: all check_standalone clean run
+
+all: $(TARGET)
+
+check_standalone: $(TARGET)
+
+$(BUILD_DIR):
+	mkdir -p "$@"
+
+$(TARGET): check_standalone.cpp | $(BUILD_DIR)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) "$<" -o "$@" $(LDLIBS)
+
+run: $(TARGET)
+	cd "$(ARTIFACT_DIR)" && "$(TARGET)" $(ARGS)
+
+clean:
+	$(RM) "$(TARGET)"
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/cpp/check_standalone.cpp b/pyamplicol/src/pyamplicol/assets/api_templates/cpp/check_standalone.cpp
new file mode 100644
index 0000000000..8938ae2a3b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/cpp/check_standalone.cpp
@@ -0,0 +1,293 @@
+// SPDX-License-Identifier: 0BSD
+
+#include <rusticol.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace fs = std::filesystem;
+
+struct Options {
+    std::string process;
+    std::string model_parameters;
+    std::string kinematics;
+    std::vector<std::string> parameter_names;
+    std::vector<double> parameter_real;
+    std::vector<double> parameter_imaginary;
+    int precision = 16;
+    bool json = false;
+};
+
+std::string json_string(const std::string &value) {
+    std::ostringstream output;
+    output << '"';
+    for (const unsigned char character : value) {
+        switch (character) {
+        case '"': output << "\\\""; break;
+        case '\\': output << "\\\\"; break;
+        case '\n': output << "\\n"; break;
+        case '\r': output << "\\r"; break;
+        case '\t': output << "\\t"; break;
+        default:
+            if (character < 0x20) {
+                output << "\\u" << std::hex << std::setw(4) << std::setfill('0')
+                       << static_cast<int>(character) << std::dec << std::setfill(' ');
+            } else {
+                output << character;
+            }
+        }
+    }
+    output << '"';
+    return output.str();
+}
+
+Options parse_options(int argc, char **argv) {
+    Options options;
+    for (int index = 1; index < argc; ++index) {
+        const std::string argument = argv[index];
+        auto require = [&](int count) {
+            if (index + count >= argc) {
+                throw std::invalid_argument("missing value after " + argument);
+            }
+        };
+        if (argument == "--process") {
+            require(1);
+            options.process = argv[++index];
+        } else if (argument == "--model-parameters") {
+            require(1);
+            options.model_parameters = argv[++index];
+        } else if (argument == "--kinematics") {
+            require(1);
+            options.kinematics = argv[++index];
+        } else if (argument == "--set-parameter") {
+            require(3);
+            options.parameter_names.emplace_back(argv[++index]);
+            options.parameter_real.push_back(std::stod(argv[++index]));
+            options.parameter_imaginary.push_back(std::stod(argv[++index]));
+        } else if (argument == "--precision") {
+            require(1);
+            options.precision = std::stoi(argv[++index]);
+        } else if (argument == "--json") {
+            options.json = true;
+        } else if (argument == "--help" || argument == "-h") {
+            std::cout << "usage: check_standalone [--process ID|EXPRESSION] "
+                         "[--model-parameters PATH] "
+                         "[--kinematics PATH] "
+                         "[--set-parameter NAME REAL IMAG] "
+                         "[--precision 16] [--json]\n";
+            std::exit(0);
+        } else {
+            throw std::invalid_argument("unknown option: " + argument);
+        }
+    }
+    if (options.precision != 16) {
+        throw std::invalid_argument(
+            "the C++ Rusticol API supports only double precision (--precision 16)");
+    }
+    return options;
+}
+
+std::vector<std::string> split_tabs(const std::string &line) {
+    std::vector<std::string> fields;
+    std::size_t start = 0;
+    while (true) {
+        const auto separator = line.find('\t', start);
+        fields.push_back(line.substr(start, separator - start));
+        if (separator == std::string::npos) break;
+        start = separator + 1;
+    }
+    return fields;
+}
+
+std::vector<double> load_validation_point(
+    const fs::path &path, const std::string &process_id, std::size_t external_count) {
+    std::ifstream input(path);
+    if (!input) return {};
+    std::string line;
+    std::getline(input, line);
+    if (line != "RUSTICOL_VALIDATION_POINTS_V1") {
+        throw std::runtime_error("unsupported validation_points.dat format");
+    }
+    while (std::getline(input, line)) {
+        if (line.empty() || line[0] == '#') continue;
+        const auto fields = split_tabs(line);
+        if (fields.size() < 2 || fields[0] != process_id) continue;
+        const auto row_count = static_cast<std::size_t>(std::stoull(fields[1]));
+        if (row_count != external_count || fields.size() != 2 + 4 * external_count) {
+            throw std::runtime_error(
+                "validation point has an incompatible external-particle count");
+        }
+        std::vector<double> values;
+        values.reserve(4 * external_count);
+        for (std::size_t index = 2; index < fields.size(); ++index) {
+            values.push_back(std::stod(fields[index]));
+        }
+        return values;
+    }
+    return {};
+}
+
+std::vector<double> reorder_validation_point(
+    const std::vector<double> &representative,
+    const std::vector<std::size_t> &permutation) {
+    if (representative.empty()) return {};
+    if (representative.size() != 4 * permutation.size()) {
+        throw std::runtime_error("validation point does not match external permutation");
+    }
+    std::vector<double> public_point(representative.size());
+    std::vector<bool> seen(permutation.size(), false);
+    for (std::size_t representative_index = 0;
+         representative_index < permutation.size(); ++representative_index) {
+        const auto public_index = permutation[representative_index];
+        if (public_index >= permutation.size() || seen[public_index]) {
+            throw std::runtime_error("runtime returned an invalid external permutation");
+        }
+        seen[public_index] = true;
+        std::copy_n(
+            representative.begin() + 4 * representative_index,
+            4,
+            public_point.begin() + 4 * public_index);
+    }
+    return public_point;
+}
+
+template <typename Integer>
+void write_integer_array(std::ostream &output, const std::vector<Integer> &values) {
+    output << '[';
+    for (std::size_t index = 0; index < values.size(); ++index) {
+        if (index) output << ',';
+        output << values[index];
+    }
+    output << ']';
+}
+
+void write_common_json(
+    std::ostream &output,
+    const rusticol::Runtime &runtime,
+    const std::vector<rusticol::ExternalParticle> &particles,
+    const std::vector<rusticol::HelicityConfiguration> &helicities,
+    const std::vector<rusticol::ColorComponent> &colors) {
+    output << "\"process\":" << json_string(runtime.process())
+           << ",\"process_key\":" << json_string(runtime.process_key())
+           << ",\"color_accuracy\":" << json_string(runtime.color_accuracy());
+    output << ",\"external_particles\":[";
+    for (std::size_t index = 0; index < particles.size(); ++index) {
+        if (index) output << ',';
+        output << "{\"index\":" << particles[index].index
+               << ",\"pdg\":" << particles[index].pdg << '}';
+    }
+    output << "],\"helicities\":[";
+    for (std::size_t index = 0; index < helicities.size(); ++index) {
+        if (index) output << ',';
+        output << "{\"id\":" << json_string(helicities[index].id)
+               << ",\"helicities\":";
+        write_integer_array(output, helicities[index].helicities);
+        output << '}';
+    }
+    output << "],\"colors\":[";
+    for (std::size_t index = 0; index < colors.size(); ++index) {
+        if (index) output << ',';
+        output << "{\"id\":" << json_string(colors[index].id)
+               << ",\"kind\":" << json_string(colors[index].kind)
+               << ",\"word\":";
+        write_integer_array(output, colors[index].word);
+        output << '}';
+    }
+    output << ']';
+}
+
+int main(int argc, char **argv) {
+    try {
+        const auto options = parse_options(argc, argv);
+        const fs::path executable = fs::weakly_canonical(fs::absolute(argv[0]));
+        fs::path root = fs::current_path();
+        if (!fs::is_regular_file(root / "artifact.json")) {
+            root = executable.parent_path().parent_path().parent_path();
+        }
+        rusticol::Runtime runtime(root.string(), options.process, options.model_parameters);
+        if (!options.parameter_names.empty()) {
+            runtime.set_model_parameters(
+                options.parameter_names,
+                options.parameter_real,
+                options.parameter_imaginary);
+        }
+        const auto particles = runtime.external_particles();
+        const auto helicities = runtime.helicities();
+        const auto colors = runtime.colors();
+        const auto momenta = options.kinematics.empty()
+            ? reorder_validation_point(
+                  load_validation_point(
+                      root / "API" / "validation_points.dat",
+                      runtime.representative_process_key(),
+                      particles.size()),
+                  runtime.external_permutation())
+            : runtime.load_kinematics_json(options.kinematics);
+        if (momenta.empty()) {
+            if (options.json) {
+                std::cout << "{\"language\":\"cpp\",\"available\":false,";
+                write_common_json(std::cout, runtime, particles, helicities, colors);
+                std::cout << ",\"diagnostic\":"
+                             "\"no bundled validation point is available\"}\n";
+            } else {
+                std::cout << "process: " << runtime.process() << "\n"
+                          << "no bundled validation point is available; "
+                             "metadata load succeeded\n";
+            }
+            return 0;
+        }
+        const auto total = runtime.evaluate(momenta, 1);
+        const auto resolved = runtime.evaluate_resolved(momenta, 1);
+        const auto explicit_total = resolved.total();
+
+        if (options.json) {
+            std::cout << std::setprecision(17)
+                      << "{\"language\":\"cpp\",\"available\":true,"
+                         "\"precision\":16,";
+            write_common_json(std::cout, runtime, particles, helicities, colors);
+            std::cout << ",\"shape\":[1," << resolved.helicities.size() << ','
+                      << resolved.colors.size() << "],\"values\":[";
+            for (std::size_t index = 0; index < resolved.values.size(); ++index) {
+                if (index) std::cout << ',';
+                std::cout << resolved.values[index];
+            }
+            std::cout << "],\"resolved_sum\":[" << explicit_total[0]
+                      << "],\"compatibility_total\":[" << total[0] << "]}\n";
+        } else {
+            std::cout << std::setprecision(17)
+                      << "process: " << runtime.process() << " ["
+                      << runtime.process_key() << "]\n"
+                      << "resolved shape: (1, " << resolved.helicities.size() << ", "
+                      << resolved.colors.size() << ")\n";
+            for (std::size_t helicity = 0;
+                 helicity < resolved.helicities.size();
+                 ++helicity) {
+                for (std::size_t color = 0; color < resolved.colors.size(); ++color) {
+                    std::cout << "  " << resolved.helicities[helicity].id << "  "
+                              << resolved.colors[color].id << "  "
+                              << resolved(0, helicity, color) << '\n';
+                }
+            }
+            std::cout << "explicit resolved sum: " << explicit_total[0] << '\n'
+                      << "compatibility total:   " << total[0] << '\n';
+        }
+        const double scale = std::max(std::abs(total[0]), 1.0);
+        if (std::abs(explicit_total[0] - total[0]) > 1.0e-12 * scale) {
+            throw std::runtime_error(
+                "resolved components do not reproduce the compatibility total");
+        }
+        return 0;
+    } catch (const std::exception &error) {
+        std::cerr << "check_standalone: " << error.what() << '\n';
+        return 1;
+    }
+}
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/fortran/Makefile b/pyamplicol/src/pyamplicol/assets/api_templates/fortran/Makefile
new file mode 100644
index 0000000000..e626df0d15
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/fortran/Makefile
@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: 0BSD
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell \
+	if command -v "$(RUSTICOL_CONFIG)" >/dev/null 2>&1; then \
+		command -v "$(RUSTICOL_CONFIG)"; \
+	elif [ "$(RUSTICOL_CONFIG)" = rusticol-config ]; then \
+		directory="$(CURDIR)"; \
+		while [ "$$directory" != / ]; do \
+			candidate="$$directory/.venv/bin/rusticol-config"; \
+			if [ -x "$$candidate" ]; then printf '%s\n' "$$candidate"; break; fi; \
+			directory=$$(dirname "$$directory"); \
+		done; \
+	fi)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+ifeq ($(origin FC), default)
+FC := gfortran
+endif
+FC ?= gfortran
+ARTIFACT_DIR := $(abspath ../..)
+BUILD_DIR ?= $(abspath ../../..)/.pyamplicol-api-build/$(notdir $(ARTIFACT_DIR))/fortran
+TARGET := $(BUILD_DIR)/check_standalone
+RUSTICOL_FORTRAN := $(shell "$(RUSTICOL_CONFIG_PATH)" --fortran-source)
+FFLAGS ?= -O2
+FFLAGS += -std=f2008 -ffree-line-length-none -Wall -Wextra
+LDLIBS += $(shell "$(RUSTICOL_CONFIG_PATH)" --libs)
+
+.PHONY: all check_standalone clean run
+
+all: $(TARGET)
+
+check_standalone: $(TARGET)
+
+$(BUILD_DIR):
+	mkdir -p "$@"
+
+$(TARGET): check_standalone.f90 | $(BUILD_DIR)
+	test -f "$(RUSTICOL_FORTRAN)"
+	$(FC) $(FFLAGS) -J"$(BUILD_DIR)" "$(RUSTICOL_FORTRAN)" "$<" -o "$@" $(LDLIBS)
+
+run: $(TARGET)
+	cd "$(ARTIFACT_DIR)" && "$(TARGET)" $(ARGS)
+
+clean:
+	$(RM) "$(TARGET)" "$(BUILD_DIR)/rusticol.mod"
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/fortran/check_standalone.f90 b/pyamplicol/src/pyamplicol/assets/api_templates/fortran/check_standalone.f90
new file mode 100644
index 0000000000..d52a39379a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/fortran/check_standalone.f90
@@ -0,0 +1,374 @@
+! SPDX-License-Identifier: 0BSD
+
+program check_standalone
+  use, intrinsic :: iso_c_binding
+  use, intrinsic :: iso_fortran_env, only: error_unit
+  use rusticol
+  implicit none
+
+  integer, parameter :: MAX_OVERRIDES = 128
+  type(rusticol_runtime) :: runtime
+  type(rusticol_external_particle), allocatable :: particles(:)
+  type(rusticol_helicity_configuration), allocatable :: helicities(:)
+  type(rusticol_color_component), allocatable :: colors(:)
+  character(len=4096) :: process_dir, process_key, representative_process_key
+  character(len=4096) :: model_parameters, kinematics
+  character(len=4096) :: executable
+  character(len=256) :: override_names_buffer(MAX_OVERRIDES)
+  character(len=256), allocatable :: override_names(:)
+  real(c_double) :: override_real_buffer(MAX_OVERRIDES)
+  real(c_double) :: override_imaginary_buffer(MAX_OVERRIDES)
+  real(c_double), allocatable :: override_real(:), override_imaginary(:)
+  real(c_double), allocatable, target :: momenta(:), totals(:), resolved(:, :, :)
+  integer(c_size_t), allocatable :: external_permutation(:)
+  logical :: json_output, point_available
+  integer :: precision, override_count
+  integer(c_int) :: status
+  integer :: color_index, helicity_index
+  real(c_double) :: explicit_total, scale
+
+  call parse_options(process_key, model_parameters, kinematics, precision, json_output, &
+      override_names_buffer, override_real_buffer, override_imaginary_buffer, &
+      override_count)
+  if (precision /= 16) call fail( &
+      "the Fortran Rusticol API supports only double precision (--precision 16)")
+  call resolve_process_dir(executable, process_dir)
+
+  if (len_trim(process_key) > 0 .and. len_trim(model_parameters) > 0) then
+    call runtime%load(trim(process_dir), trim(process_key), &
+        trim(model_parameters), status)
+  else if (len_trim(process_key) > 0) then
+    call runtime%load(trim(process_dir), trim(process_key), ierr=status)
+  else if (len_trim(model_parameters) > 0) then
+    call runtime%load(trim(process_dir), model_parameters=trim(model_parameters), &
+        ierr=status)
+  else
+    call runtime%load(trim(process_dir), ierr=status)
+  end if
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+
+  if (override_count > 0) then
+    allocate(override_names(override_count), override_real(override_count), &
+        override_imaginary(override_count))
+    override_names = override_names_buffer(1:override_count)
+    override_real = override_real_buffer(1:override_count)
+    override_imaginary = override_imaginary_buffer(1:override_count)
+    call runtime%set_model_parameters( &
+        override_names, override_real, override_imaginary, ierr=status)
+    if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  end if
+
+  particles = runtime%external_particles(ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  helicities = runtime%helicities(ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  colors = runtime%colors(ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  process_key = runtime%process_key(ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  if (len_trim(kinematics) > 0) then
+    call runtime%load_kinematics_json(trim(kinematics), momenta, ierr=status)
+    if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+    point_available = .true.
+  else
+    representative_process_key = runtime%representative_process_key(ierr=status)
+    if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+    external_permutation = runtime%external_permutation(ierr=status)
+    if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+    call load_validation_point( &
+        trim(process_dir) // "/API/validation_points.dat", &
+        trim(representative_process_key), size(particles), momenta, point_available)
+    if (point_available) call reorder_validation_point(momenta, external_permutation)
+  end if
+
+  if (.not. point_available) then
+    if (json_output) then
+      call emit_json_prefix(runtime, particles, helicities, colors, .false.)
+      write(*, '(A)') &
+          ',"diagnostic":"no bundled validation point is available"}'
+    else
+      write(*, '(A)') "process: " // runtime%process()
+      write(*, '(A)') &
+          "no bundled validation point is available; metadata load succeeded"
+    end if
+    stop 0
+  end if
+
+  call runtime%evaluate(momenta, 1_c_size_t, totals, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  call runtime%evaluate_resolved(momenta, 1_c_size_t, resolved, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  explicit_total = sum(resolved(:, :, 1))
+
+  if (json_output) then
+    call emit_json_prefix(runtime, particles, helicities, colors, .true.)
+    write(*, '(A,I0,A,I0,A)', advance='no') &
+        ',"shape":[1,', size(resolved, 2), ',', size(resolved, 1), &
+        '],"values":['
+    do helicity_index = 1, size(resolved, 2)
+      do color_index = 1, size(resolved, 1)
+        if (helicity_index > 1 .or. color_index > 1) &
+            write(*, '(A)', advance='no') ','
+        write(*, '(G0.17)', advance='no') &
+            resolved(color_index, helicity_index, 1)
+      end do
+    end do
+    write(*, '(A,G0.17,A,G0.17,A)') '],"resolved_sum":[', &
+        explicit_total, '],"compatibility_total":[', totals(1), ']}'
+  else
+    write(*, '(A)') "process: " // runtime%process() // &
+        " [" // trim(process_key) // "]"
+    write(*, '(A,I0,A,I0,A)') "resolved shape: (1, ", &
+        size(resolved, 2), ", ", size(resolved, 1), ")"
+    do helicity_index = 1, size(helicities)
+      do color_index = 1, size(colors)
+        write(*, '(2X,A,2X,A,2X,G0.17)') &
+            trim(helicities(helicity_index)%id), &
+            trim(colors(color_index)%id), &
+            resolved(color_index, helicity_index, 1)
+      end do
+    end do
+    write(*, '(A,G0.17)') "explicit resolved sum: ", explicit_total
+    write(*, '(A,G0.17)') "compatibility total:   ", totals(1)
+  end if
+  scale = max(abs(totals(1)), 1.0_c_double)
+  if (abs(explicit_total - totals(1)) > 1.0e-12_c_double * scale) then
+    call fail("resolved components do not reproduce the compatibility total")
+  end if
+
+contains
+
+  subroutine fail(message)
+    character(len=*), intent(in) :: message
+    write(error_unit, '(A)') "check_standalone: " // trim(message)
+    stop 1
+  end subroutine fail
+
+  subroutine parse_options(selected_process, model_card, kinematics_path, selected_precision, &
+      json, names, real_values, imaginary_values, count)
+    character(len=*), intent(out) :: selected_process, model_card, kinematics_path
+    integer, intent(out) :: selected_precision, count
+    logical, intent(out) :: json
+    character(len=*), intent(out) :: names(:)
+    real(c_double), intent(out) :: real_values(:), imaginary_values(:)
+    character(len=4096) :: argument, value
+    integer :: argc, index, parse_status
+
+    selected_process = ""
+    model_card = ""
+    kinematics_path = ""
+    selected_precision = 16
+    count = 0
+    json = .false.
+    argc = command_argument_count()
+    index = 1
+    do while (index <= argc)
+      call get_command_argument(index, argument)
+      select case (trim(argument))
+      case ("--process")
+        if (index + 1 > argc) call fail("missing value after --process")
+        index = index + 1
+        call get_command_argument(index, selected_process)
+      case ("--model-parameters")
+        if (index + 1 > argc) call fail( &
+            "missing value after --model-parameters")
+        index = index + 1
+        call get_command_argument(index, model_card)
+      case ("--kinematics")
+        if (index + 1 > argc) call fail("missing value after --kinematics")
+        index = index + 1
+        call get_command_argument(index, kinematics_path)
+      case ("--set-parameter")
+        if (index + 3 > argc) call fail( &
+            "--set-parameter requires NAME REAL IMAG")
+        if (count >= size(names)) call fail( &
+            "too many --set-parameter options")
+        count = count + 1
+        index = index + 1
+        call get_command_argument(index, names(count))
+        index = index + 1
+        call get_command_argument(index, value)
+        read(value, *, iostat=parse_status) real_values(count)
+        if (parse_status /= 0) call fail( &
+            "invalid real model-parameter component")
+        index = index + 1
+        call get_command_argument(index, value)
+        read(value, *, iostat=parse_status) imaginary_values(count)
+        if (parse_status /= 0) call fail( &
+            "invalid imaginary model-parameter component")
+      case ("--precision")
+        if (index + 1 > argc) call fail("missing value after --precision")
+        index = index + 1
+        call get_command_argument(index, value)
+        read(value, *, iostat=parse_status) selected_precision
+        if (parse_status /= 0) call fail("invalid --precision value")
+      case ("--json")
+        json = .true.
+      case ("--help", "-h")
+        write(*, '(A)') "usage: check_standalone [--process ID|EXPRESSION] " // &
+            "[--model-parameters PATH] [--kinematics PATH] " // &
+            "[--set-parameter NAME REAL IMAG] " // &
+            "[--precision 16] [--json]"
+        stop 0
+      case default
+        call fail("unknown option: " // trim(argument))
+      end select
+      index = index + 1
+    end do
+  end subroutine parse_options
+
+  subroutine resolve_process_dir(program_path, root)
+    character(len=*), intent(out) :: program_path, root
+    integer :: slash
+    logical :: artifact_in_working_directory
+    call get_command_argument(0, program_path)
+    inquire(file="artifact.json", exist=artifact_in_working_directory)
+    if (artifact_in_working_directory) then
+      root = "."
+      return
+    end if
+    slash = scan(trim(program_path), "/", back=.true.)
+    if (slash == 0) then
+      root = "../.."
+    else
+      root = program_path(:slash - 1) // "/../.."
+    end if
+  end subroutine resolve_process_dir
+
+  subroutine load_validation_point(path, key, external_count, values, available)
+    character(len=*), intent(in) :: path, key
+    integer, intent(in) :: external_count
+    real(c_double), allocatable, target, intent(out) :: values(:)
+    logical, intent(out) :: available
+    character(len=65536) :: line
+    character(len=4096) :: row_key
+    integer :: unit, io_status, row_count
+
+    available = .false.
+    allocate(values(4 * external_count))
+    open(newunit=unit, file=path, status="old", action="read", &
+        iostat=io_status)
+    if (io_status /= 0) return
+    read(unit, '(A)', iostat=io_status) line
+    if (io_status /= 0 .or. &
+        trim(line) /= "RUSTICOL_VALIDATION_POINTS_V1") then
+      close(unit)
+      call fail("unsupported validation_points.dat format")
+    end if
+    do
+      read(unit, '(A)', iostat=io_status) line
+      if (io_status /= 0) exit
+      if (len_trim(line) == 0 .or. line(1:1) == "#") cycle
+      read(line, *, iostat=io_status) row_key, row_count
+      if (io_status /= 0 .or. trim(row_key) /= trim(key)) cycle
+      if (row_count /= external_count) then
+        close(unit)
+        call fail( &
+            "validation point has an incompatible external-particle count")
+      end if
+      read(line, *, iostat=io_status) row_key, row_count, values
+      if (io_status /= 0) then
+        close(unit)
+        call fail("invalid validation point row")
+      end if
+      available = .true.
+      exit
+    end do
+    close(unit)
+  end subroutine load_validation_point
+
+  subroutine reorder_validation_point(values, permutation)
+    real(c_double), allocatable, intent(inout) :: values(:)
+    integer(c_size_t), intent(in) :: permutation(:)
+    real(c_double), allocatable :: reordered(:)
+    logical, allocatable :: seen(:)
+    integer :: representative_index, public_index
+
+    if (size(values) /= 4 * size(permutation)) call fail( &
+        "validation point does not match external permutation")
+    allocate(reordered(size(values)), seen(size(permutation)))
+    seen = .false.
+    do representative_index = 1, size(permutation)
+      public_index = int(permutation(representative_index)) + 1
+      if (public_index < 1 .or. public_index > size(permutation) .or. &
+          seen(public_index)) call fail( &
+          "runtime returned an invalid external permutation")
+      seen(public_index) = .true.
+      reordered(4 * public_index - 3:4 * public_index) = &
+          values(4 * representative_index - 3:4 * representative_index)
+    end do
+    call move_alloc(reordered, values)
+  end subroutine reorder_validation_point
+
+  function json_escape(value) result(escaped)
+    character(len=*), intent(in) :: value
+    character(len=:), allocatable :: escaped
+    integer :: index
+    escaped = ""
+    do index = 1, len_trim(value)
+      select case (value(index:index))
+      case ('"')
+        escaped = escaped // '\"'
+      case ('\')
+        escaped = escaped // '\\'
+      case default
+        escaped = escaped // value(index:index)
+      end select
+    end do
+  end function json_escape
+
+  subroutine emit_json_prefix(active_runtime, external, helicity_items, &
+      color_items, available)
+    type(rusticol_runtime), intent(inout) :: active_runtime
+    type(rusticol_external_particle), intent(in) :: external(:)
+    type(rusticol_helicity_configuration), intent(in) :: helicity_items(:)
+    type(rusticol_color_component), intent(in) :: color_items(:)
+    logical, intent(in) :: available
+    integer :: item, component
+
+    write(*, '(A)', advance='no') '{"language":"fortran","available":'
+    if (available) then
+      write(*, '(A)', advance='no') 'true,"precision":16'
+    else
+      write(*, '(A)', advance='no') 'false'
+    end if
+    write(*, '(A)', advance='no') ',"process":"' // &
+        json_escape(active_runtime%process()) // '","process_key":"' // &
+        json_escape(active_runtime%process_key()) // &
+        '","color_accuracy":"' // &
+        json_escape(active_runtime%color_accuracy()) // &
+        '","external_particles":['
+    do item = 1, size(external)
+      if (item > 1) write(*, '(A)', advance='no') ','
+      write(*, '(A,I0,A,I0,A)', advance='no') &
+          '{"index":', external(item)%index, ',"pdg":', &
+          external(item)%pdg, '}'
+    end do
+    write(*, '(A)', advance='no') '],"helicities":['
+    do item = 1, size(helicity_items)
+      if (item > 1) write(*, '(A)', advance='no') ','
+      write(*, '(A)', advance='no') '{"id":"' // &
+          json_escape(helicity_items(item)%id) // '","helicities":['
+      do component = 1, size(helicity_items(item)%helicities)
+        if (component > 1) write(*, '(A)', advance='no') ','
+        write(*, '(I0)', advance='no') &
+            helicity_items(item)%helicities(component)
+      end do
+      write(*, '(A)', advance='no') ']}'
+    end do
+    write(*, '(A)', advance='no') '],"colors":['
+    do item = 1, size(color_items)
+      if (item > 1) write(*, '(A)', advance='no') ','
+      write(*, '(A)', advance='no') '{"id":"' // &
+          json_escape(color_items(item)%id) // '","kind":"' // &
+          json_escape(color_items(item)%kind) // '","word":['
+      do component = 1, size(color_items(item)%word)
+        if (component > 1) write(*, '(A)', advance='no') ','
+        write(*, '(I0)', advance='no') color_items(item)%word(component)
+      end do
+      write(*, '(A)', advance='no') ']}'
+    end do
+    write(*, '(A)', advance='no') ']'
+  end subroutine emit_json_prefix
+
+end program check_standalone
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/python/check_standalone.py b/pyamplicol/src/pyamplicol/assets/api_templates/python/check_standalone.py
new file mode 100644
index 0000000000..3e22ac3d56
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/python/check_standalone.py
@@ -0,0 +1,401 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Evaluate a generated process through pyAmpliCol's installed Python API."""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import json
+import math
+import os
+import statistics
+import sys
+import time
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+
+
+def _load_pyamplicol() -> Any:
+    try:
+        return importlib.import_module("pyamplicol")
+    except ModuleNotFoundError as error:
+        if error.name != "pyamplicol":
+            raise
+        previous = os.environ.get("_PYAMPLICOL_API_BOOTSTRAP")
+        if previous is not None:
+            raise SystemExit(
+                "pyamplicol remained unavailable after retrying with " + previous
+            ) from error
+        script = Path(__file__).resolve()
+        layouts = (
+            (Path("bin/python"), Path("bin/rusticol-config")),
+            (Path("Scripts/python.exe"), Path("Scripts/rusticol-config.exe")),
+        )
+        for parent in script.parents:
+            for python_relative, config_relative in layouts:
+                python = parent / ".venv" / python_relative
+                config = parent / ".venv" / config_relative
+                if (
+                    not python.is_file()
+                    or not os.access(python, os.X_OK)
+                    or not config.is_file()
+                    or not os.access(config, os.X_OK)
+                ):
+                    continue
+                environment = os.environ.copy()
+                environment["_PYAMPLICOL_API_BOOTSTRAP"] = str(python)
+                os.execve(
+                    python,
+                    (str(python), str(script), *sys.argv[1:]),
+                    environment,
+                )
+        raise SystemExit(
+            "pyamplicol is not importable; activate its environment or place this "
+            "artifact below a checkout containing .venv from `just dev-install`"
+        ) from error
+
+
+pyamplicol = _load_pyamplicol()
+
+
+def _validation_point(path: Path, process_id: str, precision: int):
+    if not path.is_file():
+        return None
+    lines = path.read_text(encoding="ascii").splitlines()
+    if not lines or lines[0] != "RUSTICOL_VALIDATION_POINTS_V1":
+        raise SystemExit("unsupported validation_points.dat format")
+    for line in lines[1:]:
+        if not line or line.startswith("#"):
+            continue
+        fields = line.split("\t")
+        if len(fields) < 2 or fields[0] != process_id:
+            continue
+        external_count = int(fields[1])
+        components = fields[2:]
+        if len(components) != external_count * 4:
+            raise SystemExit(f"invalid validation row for {process_id!r}")
+        convert = float if precision == 16 else Decimal
+        return [
+            [convert(value) for value in components[index : index + 4]]
+            for index in range(0, len(components), 4)
+        ]
+    return None
+
+
+def _reorder_point(
+    point: list[list[Any]], permutation: tuple[int, ...]
+) -> list[list[Any]]:
+    if len(point) != len(permutation) or sorted(permutation) != list(range(len(point))):
+        raise SystemExit("runtime returned an invalid external permutation")
+    reordered: list[list[Any] | None] = [None] * len(point)
+    for representative_index, public_index in enumerate(permutation):
+        reordered[public_index] = point[representative_index]
+    if any(vector is None for vector in reordered):
+        raise SystemExit("runtime returned an incomplete external permutation")
+    return [vector for vector in reordered if vector is not None]
+
+
+def _kinematics(path: str, precision: int, external_count: int) -> list[list[Any]]:
+    source = Path(path).expanduser().resolve(strict=True)
+
+    def invalid_constant(value: str) -> None:
+        raise ValueError(f"non-finite JSON constant {value!r}")
+
+    try:
+        payload = json.loads(
+            source.read_text(encoding="utf-8"),
+            parse_float=Decimal if precision != 16 else float,
+            parse_int=Decimal if precision != 16 else int,
+            parse_constant=invalid_constant,
+        )
+    except (json.JSONDecodeError, OSError, ValueError) as error:
+        raise SystemExit(f"could not read kinematics JSON {source}: {error}") from error
+    if (
+        isinstance(payload, list)
+        and len(payload) == 1
+        and isinstance(payload[0], list)
+        and payload[0]
+        and isinstance(payload[0][0], list)
+    ):
+        payload = payload[0]
+    if not isinstance(payload, list) or len(payload) != external_count:
+        raise SystemExit(
+            f"kinematics JSON must contain one [{external_count}][4] point"
+        )
+    convert = float if precision == 16 else Decimal
+    point: list[list[Any]] = []
+    for leg_index, raw_leg in enumerate(payload):
+        if not isinstance(raw_leg, list) or len(raw_leg) != 4:
+            raise SystemExit(
+                f"kinematics leg {leg_index} must contain [E, px, py, pz]"
+            )
+        leg: list[Any] = []
+        for component_index, raw in enumerate(raw_leg):
+            if isinstance(raw, bool) or not isinstance(raw, (int, float, Decimal, str)):
+                raise SystemExit(
+                    f"kinematics leg {leg_index} component {component_index} "
+                    "must be a number or decimal string"
+                )
+            try:
+                value = convert(raw)
+            except (TypeError, ValueError) as error:
+                raise SystemExit(
+                    f"kinematics leg {leg_index} component {component_index} "
+                    "is not a decimal value"
+                ) from error
+            finite = (
+                math.isfinite(value)
+                if isinstance(value, float)
+                else value.is_finite()
+            )
+            if not finite:
+                raise SystemExit("kinematics components must be finite")
+            leg.append(value)
+        point.append(leg)
+    return point
+
+
+def _repeat_point(point: list[list[Any]], count: int) -> list[list[list[Any]]]:
+    return [point for _ in range(count)]
+
+
+def _flatten(values: Any) -> list[Any]:
+    if hasattr(values, "reshape"):
+        return values.reshape(-1).tolist()
+    output: list[Any] = []
+
+    def visit(value: Any) -> None:
+        if isinstance(value, (list, tuple)):
+            for entry in value:
+                visit(entry)
+        else:
+            output.append(value)
+
+    visit(values)
+    return output
+
+
+def _real(value: Any) -> Any:
+    if isinstance(value, Decimal):
+        return value
+    converted = complex(value)
+    if abs(converted.imag) > 1.0e-14 * max(1.0, abs(converted.real)):
+        raise SystemExit("matrix-element output unexpectedly has an imaginary part")
+    return converted.real
+
+
+def _json_scalar(value: Any, precision: int) -> float | str:
+    real = _real(value)
+    return float(real) if precision == 16 else str(real)
+
+
+def _parameter_component(value: Any) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise SystemExit("model-parameter components must be JSON numbers")
+    component = float(value)
+    if not math.isfinite(component):
+        raise SystemExit("model-parameter components must be finite")
+    return component
+
+
+def _parameter_value(value: Any) -> complex | float:
+    if isinstance(value, list):
+        if len(value) != 2:
+            raise SystemExit("model-parameter arrays must contain [real, imaginary]")
+        return complex(
+            _parameter_component(value[0]),
+            _parameter_component(value[1]),
+        )
+    return _parameter_component(value)
+
+
+def _model_parameters(path: str | None) -> dict[str, complex | float] | None:
+    if path is None:
+        return None
+    source = Path(path).expanduser().resolve(strict=True)
+    payload = json.loads(source.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise SystemExit("model-parameter JSON must be an object")
+    return {str(name): _parameter_value(value) for name, value in payload.items()}
+
+
+def _physics_payload(physics: pyamplicol.ProcessPhysics) -> dict[str, Any]:
+    colors = [
+        {"id": item.id, "kind": "lc-flow", "word": list(item.word)}
+        for item in physics.color_flows
+    ]
+    colors.extend(
+        {"id": item.id, "kind": "contracted-color", "word": []}
+        for item in physics.contracted_color_components
+    )
+    return {
+        "process": physics.process,
+        "process_key": physics.process_id,
+        "color_accuracy": physics.color_accuracy,
+        "external_particles": [
+            {"index": item.index, "pdg": item.pdg_id}
+            for item in physics.external_particles
+        ],
+        "helicities": [
+            {"id": item.id, "helicities": list(item.values)}
+            for item in physics.helicities
+        ],
+        "colors": colors,
+    }
+
+
+def _profile(
+    runtime: pyamplicol.Runtime,
+    point: list[list[Any]],
+    precision: int,
+    target_runtime: float,
+    batch_size: int,
+) -> dict[str, float | int]:
+    samples: list[float] = []
+    elapsed = 0.0
+    while len(samples) < 8 or elapsed < target_runtime:
+        batch = _repeat_point(point, batch_size)
+        started = time.perf_counter()
+        runtime.evaluate(batch, precision=precision)
+        wall = time.perf_counter() - started
+        elapsed += wall
+        samples.append(wall / batch_size)
+    return {
+        "samples": len(samples) * batch_size,
+        "wall_us_per_point": statistics.mean(samples) * 1.0e6,
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Resolved pyAmpliCol Python API example"
+    )
+    parser.add_argument(
+        "--process",
+        help="stable process/alias ID or exact concrete process expression",
+    )
+    parser.add_argument("--model-parameters")
+    parser.add_argument(
+        "--kinematics",
+        help="JSON point in the external-particle order supplied by --process",
+    )
+    parser.add_argument(
+        "--set-parameter",
+        nargs=3,
+        action="append",
+        default=[],
+        metavar=("NAME", "REAL", "IMAG"),
+    )
+    parser.add_argument("--precision", type=int, default=16)
+    parser.add_argument("--profile", action="store_true")
+    parser.add_argument("--target-runtime", type=float, default=10.0)
+    parser.add_argument("--batch-size", type=int, default=128)
+    parser.add_argument("--json", action="store_true")
+    return parser
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    root = Path(__file__).resolve().parents[2]
+    runtime = pyamplicol.Runtime.load(
+        root,
+        process=args.process,
+        model_parameters=_model_parameters(args.model_parameters),
+    )
+    if args.set_parameter:
+        runtime.set_model_parameters(
+            {
+                name: complex(float(real), float(imaginary))
+                for name, real, imaginary in args.set_parameter
+            }
+        )
+    physics = runtime.physics
+    metadata = _physics_payload(physics)
+    if args.kinematics is None:
+        point = _validation_point(
+            root / "API" / "validation_points.dat",
+            runtime.representative_process_key,
+            args.precision,
+        )
+        if point is not None:
+            point = _reorder_point(point, runtime.external_permutation)
+    else:
+        point = _kinematics(
+            args.kinematics,
+            args.precision,
+            len(physics.external_particles),
+        )
+    if point is None:
+        payload = {
+            "language": "python",
+            "available": False,
+            "diagnostic": "no bundled validation point is available",
+            **metadata,
+        }
+        if args.json:
+            print(json.dumps(payload, separators=(",", ":"), sort_keys=True))
+        else:
+            print(f"process: {physics.process}")
+            print("no bundled validation point is available; metadata load succeeded")
+        return 0
+
+    batch = _repeat_point(point, 1)
+    resolved = runtime.evaluate_resolved(batch, precision=args.precision)
+    total = runtime.evaluate(batch, precision=args.precision)
+    values = _flatten(resolved.values)
+    explicit_total = _flatten(resolved.total())
+    compatibility_total = _flatten(total)
+    payload: dict[str, Any] = {
+        "language": "python",
+        "available": True,
+        "precision": args.precision,
+        **metadata,
+        "shape": list(resolved.shape),
+        "values": [_json_scalar(value, args.precision) for value in values],
+        "resolved_sum": [
+            _json_scalar(value, args.precision) for value in explicit_total
+        ],
+        "compatibility_total": [
+            _json_scalar(value, args.precision) for value in compatibility_total
+        ],
+    }
+    if args.profile:
+        payload["profile"] = _profile(
+            runtime,
+            point,
+            args.precision,
+            max(args.target_runtime, 0.0),
+            max(args.batch_size, 1),
+        )
+    if args.json:
+        print(json.dumps(payload, separators=(",", ":"), sort_keys=True))
+        return 0
+
+    print(f"process: {physics.process} [{physics.process_id}]")
+    print(f"resolved shape: {resolved.shape}")
+    color_items = metadata["colors"]
+    color_count = len(color_items)
+    for helicity_index, helicity in enumerate(metadata["helicities"]):
+        for color_index, color in enumerate(color_items):
+            offset = helicity_index * color_count + color_index
+            print(f"  {helicity['id']}  {color['id']}  {values[offset]}")
+    print(f"explicit resolved sum: {explicit_total[0]}")
+    print(f"compatibility total:   {compatibility_total[0]}")
+    if not math.isclose(
+        float(_real(explicit_total[0])),
+        float(_real(compatibility_total[0])),
+        rel_tol=1.0e-12,
+        abs_tol=1.0e-15,
+    ):
+        raise SystemExit("resolved components do not reproduce the compatibility total")
+    if args.profile:
+        profile = payload["profile"]
+        assert isinstance(profile, dict)
+        print(f"timing: {profile['wall_us_per_point']:.6g} us/point")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/rust/Makefile b/pyamplicol/src/pyamplicol/assets/api_templates/rust/Makefile
new file mode 100644
index 0000000000..3f8824f58a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/rust/Makefile
@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: 0BSD
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell \
+	if command -v "$(RUSTICOL_CONFIG)" >/dev/null 2>&1; then \
+		command -v "$(RUSTICOL_CONFIG)"; \
+	elif [ "$(RUSTICOL_CONFIG)" = rusticol-config ]; then \
+		directory="$(CURDIR)"; \
+		while [ "$$directory" != / ]; do \
+			candidate="$$directory/.venv/bin/rusticol-config"; \
+			if [ -x "$$candidate" ]; then printf '%s\n' "$$candidate"; break; fi; \
+			directory=$$(dirname "$$directory"); \
+		done; \
+	fi)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+RUSTC ?= rustc
+RUST_SCRIPT ?= rust-script
+ARTIFACT_DIR := $(abspath ../..)
+BUILD_DIR ?= $(abspath ../../..)/.pyamplicol-api-build/$(notdir $(ARTIFACT_DIR))/rust
+TARGET := $(BUILD_DIR)/check_standalone
+RUSTFLAGS ?= -C opt-level=2
+RUSTICOL_RUST_SOURCE := $(shell "$(RUSTICOL_CONFIG_PATH)" --rust-source)
+RUSTICOL_RUSTFLAGS := $(shell "$(RUSTICOL_CONFIG_PATH)" --rustflags)
+
+.PHONY: all check_standalone clean run run-script
+
+all: $(TARGET)
+
+check_standalone: $(TARGET)
+
+$(BUILD_DIR):
+	mkdir -p "$@"
+
+$(TARGET): check_standalone.rs | $(BUILD_DIR)
+	RUSTICOL_RUST_SOURCE="$(RUSTICOL_RUST_SOURCE)" \
+		$(RUSTC) --edition=2021 $(RUSTFLAGS) "$<" -o "$@" $(RUSTICOL_RUSTFLAGS)
+
+run: $(TARGET)
+	cd "$(ARTIFACT_DIR)" && "$(TARGET)" $(ARGS)
+
+run-script:
+	cd "$(ARTIFACT_DIR)" && \
+		RUSTICOL_RUST_SOURCE="$(RUSTICOL_RUST_SOURCE)" \
+		CARGO_ENCODED_RUSTFLAGS="$$("$(RUSTICOL_CONFIG_PATH)" --cargo-rustflags)" \
+		$(RUST_SCRIPT) "API/rust/check_standalone.rs" -- $(ARGS)
+
+clean:
+	$(RM) "$(TARGET)"
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/rust/check_standalone.rs b/pyamplicol/src/pyamplicol/assets/api_templates/rust/check_standalone.rs
new file mode 100644
index 0000000000..5c91f5c862
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/rust/check_standalone.rs
@@ -0,0 +1,454 @@
+#!/usr/bin/env rust-script
+// SPDX-License-Identifier: 0BSD
+//! ```cargo
+//! [package]
+//! edition = "2021"
+//! ```
+
+use std::env;
+use std::fmt::Write as _;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+#[allow(dead_code)]
+mod rusticol {
+    include!(env!("RUSTICOL_RUST_SOURCE"));
+}
+
+use rusticol::{ParameterUpdate, PhysicsMetadata, ResolvedEvaluation, Runtime, Selectors};
+
+#[derive(Default)]
+struct Options {
+    process: Option<String>,
+    model_parameters: Option<String>,
+    kinematics: Option<String>,
+    overrides: Vec<ParameterUpdate>,
+    precision: u32,
+    json: bool,
+    help: bool,
+}
+
+fn sdk<T>(result: rusticol::Result<T>) -> Result<T, String> {
+    result.map_err(|error| error.to_string())
+}
+
+fn usage() -> &'static str {
+    "usage: check_standalone [--process ID|EXPRESSION] [--model-parameters PATH] \
+[--kinematics PATH] [--set-parameter NAME REAL IMAG] [--precision 16] [--json]"
+}
+
+fn parse_options() -> Result<Options, String> {
+    let arguments = env::args().skip(1).collect::<Vec<_>>();
+    let mut options = Options {
+        precision: 16,
+        ..Options::default()
+    };
+    let mut index = 0;
+    while index < arguments.len() {
+        let argument = &arguments[index];
+        match argument.as_str() {
+            "--" => {
+                index += 1;
+            }
+            "--process" => {
+                options.process = Some(required_argument(&arguments, index, 1)?.to_owned());
+                index += 2;
+            }
+            "--model-parameters" => {
+                options.model_parameters =
+                    Some(required_argument(&arguments, index, 1)?.to_owned());
+                index += 2;
+            }
+            "--kinematics" => {
+                options.kinematics =
+                    Some(required_argument(&arguments, index, 1)?.to_owned());
+                index += 2;
+            }
+            "--set-parameter" => {
+                let name = required_argument(&arguments, index, 1)?.to_owned();
+                let real = parse_f64(
+                    required_argument(&arguments, index, 2)?,
+                    "real model-parameter component",
+                )?;
+                let imaginary = parse_f64(
+                    required_argument(&arguments, index, 3)?,
+                    "imaginary model-parameter component",
+                )?;
+                options
+                    .overrides
+                    .push(ParameterUpdate::new(name, real, imaginary));
+                index += 4;
+            }
+            "--precision" => {
+                options.precision = required_argument(&arguments, index, 1)?
+                    .parse()
+                    .map_err(|_| "invalid --precision value".to_owned())?;
+                index += 2;
+            }
+            "--json" => {
+                options.json = true;
+                index += 1;
+            }
+            "--help" | "-h" => {
+                options.help = true;
+                index += 1;
+            }
+            _ => return Err(format!("unknown option: {argument}")),
+        }
+    }
+    if options.precision != 16 {
+        return Err(
+            "the Rust Rusticol API supports only double precision (--precision 16)".to_owned(),
+        );
+    }
+    Ok(options)
+}
+
+fn required_argument<'a>(
+    arguments: &'a [String],
+    option_index: usize,
+    offset: usize,
+) -> Result<&'a str, String> {
+    arguments
+        .get(option_index + offset)
+        .map(String::as_str)
+        .ok_or_else(|| format!("missing value after {}", arguments[option_index]))
+}
+
+fn parse_f64(value: &str, description: &str) -> Result<f64, String> {
+    let parsed = value
+        .parse::<f64>()
+        .map_err(|_| format!("invalid {description}"))?;
+    if parsed.is_finite() {
+        Ok(parsed)
+    } else {
+        Err(format!("invalid {description}"))
+    }
+}
+
+fn artifact_root() -> Result<PathBuf, String> {
+    let current =
+        env::current_dir().map_err(|error| format!("cannot read current directory: {error}"))?;
+    if current.join("artifact.json").is_file() {
+        return Ok(current);
+    }
+
+    let executable = env::current_exe()
+        .map_err(|error| format!("cannot locate check_standalone executable: {error}"))?;
+    for ancestor in executable.ancestors().skip(1) {
+        if ancestor.join("artifact.json").is_file() {
+            return Ok(ancestor.to_path_buf());
+        }
+    }
+
+    let language_dir = executable.parent();
+    let build_artifact = language_dir.and_then(Path::parent);
+    let build_root = build_artifact.and_then(Path::parent);
+    if build_root.and_then(Path::file_name) == Some(".pyamplicol-api-build".as_ref()) {
+        if let (Some(parent), Some(name)) = (
+            build_root.and_then(Path::parent),
+            build_artifact.and_then(Path::file_name),
+        ) {
+            let candidate = parent.join(name);
+            if candidate.join("artifact.json").is_file() {
+                return Ok(candidate);
+            }
+        }
+    }
+
+    Err("run check_standalone from a generated artifact directory".to_owned())
+}
+
+fn load_validation_point(
+    path: &Path,
+    process_key: &str,
+    external_count: usize,
+) -> Result<Option<Vec<f64>>, String> {
+    let contents = match fs::read_to_string(path) {
+        Ok(contents) => contents,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+        Err(error) => return Err(format!("cannot read {}: {error}", path.display())),
+    };
+    let mut lines = contents.lines();
+    if lines.next() != Some("RUSTICOL_VALIDATION_POINTS_V1") {
+        return Err("unsupported validation_points.dat format".to_owned());
+    }
+    for line in lines {
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        let fields = line.split('\t').collect::<Vec<_>>();
+        if fields.len() < 2 || fields[0] != process_key {
+            continue;
+        }
+        let row_count = fields[1]
+            .parse::<usize>()
+            .map_err(|_| "invalid validation point row".to_owned())?;
+        if row_count != external_count || fields.len() != 2 + 4 * external_count {
+            return Err("validation point has an incompatible external-particle count".to_owned());
+        }
+        let momenta = fields[2..]
+            .iter()
+            .map(|value| parse_f64(value, "validation-point component"))
+            .collect::<Result<Vec<_>, _>>()?;
+        return Ok(Some(momenta));
+    }
+    Ok(None)
+}
+
+fn reorder_validation_point(
+    representative: Vec<f64>,
+    permutation: &[usize],
+) -> Result<Vec<f64>, String> {
+    if representative.len() != 4 * permutation.len() {
+        return Err("validation point does not match external permutation".to_owned());
+    }
+    let mut public_point = vec![0.0; representative.len()];
+    let mut seen = vec![false; permutation.len()];
+    for (representative_index, &public_index) in permutation.iter().enumerate() {
+        if public_index >= permutation.len() || seen[public_index] {
+            return Err("runtime returned an invalid external permutation".to_owned());
+        }
+        seen[public_index] = true;
+        public_point[4 * public_index..4 * public_index + 4].copy_from_slice(
+            &representative[4 * representative_index..4 * representative_index + 4],
+        );
+    }
+    Ok(public_point)
+}
+
+fn json_string(value: &str) -> String {
+    let mut output = String::with_capacity(value.len() + 2);
+    output.push('"');
+    for character in value.chars() {
+        match character {
+            '"' => output.push_str("\\\""),
+            '\\' => output.push_str("\\\\"),
+            '\u{08}' => output.push_str("\\b"),
+            '\u{0c}' => output.push_str("\\f"),
+            '\n' => output.push_str("\\n"),
+            '\r' => output.push_str("\\r"),
+            '\t' => output.push_str("\\t"),
+            character if character <= '\u{1f}' => {
+                write!(&mut output, "\\u{:04x}", character as u32)
+                    .expect("writing to a String cannot fail");
+            }
+            character => output.push(character),
+        }
+    }
+    output.push('"');
+    output
+}
+
+fn write_i32_array(output: &mut String, values: &[i32]) {
+    output.push('[');
+    for (index, value) in values.iter().enumerate() {
+        if index != 0 {
+            output.push(',');
+        }
+        write!(output, "{value}").expect("writing to a String cannot fail");
+    }
+    output.push(']');
+}
+
+fn write_usize_array(output: &mut String, values: &[usize]) {
+    output.push('[');
+    for (index, value) in values.iter().enumerate() {
+        if index != 0 {
+            output.push(',');
+        }
+        write!(output, "{value}").expect("writing to a String cannot fail");
+    }
+    output.push(']');
+}
+
+fn write_f64_array(output: &mut String, values: &[f64]) -> Result<(), String> {
+    output.push('[');
+    for (index, value) in values.iter().enumerate() {
+        if !value.is_finite() {
+            return Err("matrix-element output is not finite".to_owned());
+        }
+        if index != 0 {
+            output.push(',');
+        }
+        write!(output, "{value}").expect("writing to a String cannot fail");
+    }
+    output.push(']');
+    Ok(())
+}
+
+fn write_common_json(output: &mut String, metadata: &PhysicsMetadata) {
+    write!(
+        output,
+        "\"process\":{},\"process_key\":{},\"color_accuracy\":{}",
+        json_string(&metadata.process),
+        json_string(&metadata.process_key),
+        json_string(&metadata.color_accuracy),
+    )
+    .expect("writing to a String cannot fail");
+
+    output.push_str(",\"external_particles\":[");
+    for (index, particle) in metadata.external_particles.iter().enumerate() {
+        if index != 0 {
+            output.push(',');
+        }
+        write!(
+            output,
+            "{{\"index\":{},\"pdg\":{}}}",
+            particle.index, particle.pdg
+        )
+        .expect("writing to a String cannot fail");
+    }
+
+    output.push_str("],\"helicities\":[");
+    for (index, helicity) in metadata.helicities.iter().enumerate() {
+        if index != 0 {
+            output.push(',');
+        }
+        write!(
+            output,
+            "{{\"id\":{},\"helicities\":",
+            json_string(&helicity.id)
+        )
+        .expect("writing to a String cannot fail");
+        write_i32_array(output, &helicity.helicities);
+        output.push('}');
+    }
+
+    output.push_str("],\"colors\":[");
+    for (index, color) in metadata.colors.iter().enumerate() {
+        if index != 0 {
+            output.push(',');
+        }
+        write!(
+            output,
+            "{{\"id\":{},\"kind\":{},\"word\":",
+            json_string(&color.id),
+            json_string(&color.kind),
+        )
+        .expect("writing to a String cannot fail");
+        write_usize_array(output, &color.word);
+        output.push('}');
+    }
+    output.push(']');
+}
+
+fn available_json(
+    metadata: &PhysicsMetadata,
+    resolved: &ResolvedEvaluation,
+    explicit_total: f64,
+    total: f64,
+) -> Result<String, String> {
+    let (_, helicity_count, color_count) = resolved.shape();
+    let mut output = "{\"language\":\"rust\",\"available\":true,\"precision\":16,".to_owned();
+    write_common_json(&mut output, metadata);
+    write!(
+        &mut output,
+        ",\"shape\":[1,{helicity_count},{color_count}],\"values\":"
+    )
+    .expect("writing to a String cannot fail");
+    write_f64_array(&mut output, resolved.values())?;
+    output.push_str(",\"resolved_sum\":");
+    write_f64_array(&mut output, &[explicit_total])?;
+    output.push_str(",\"compatibility_total\":");
+    write_f64_array(&mut output, &[total])?;
+    output.push_str("}\n");
+    Ok(output)
+}
+
+fn unavailable_json(metadata: &PhysicsMetadata) -> String {
+    let mut output = "{\"language\":\"rust\",\"available\":false,".to_owned();
+    write_common_json(&mut output, metadata);
+    output.push_str(",\"diagnostic\":\"no bundled validation point is available\"}\n");
+    output
+}
+
+fn run() -> Result<(), String> {
+    let options = parse_options()?;
+    if options.help {
+        println!("{}", usage());
+        return Ok(());
+    }
+    let root = artifact_root()?;
+    let model_parameters = options.model_parameters.as_deref().map(Path::new);
+    let mut runtime = sdk(Runtime::load(
+        &root,
+        options.process.as_deref(),
+        model_parameters,
+    ))?;
+    sdk(runtime.set_model_parameters(&options.overrides))?;
+    let metadata = sdk(runtime.physics())?;
+    let point = if let Some(path) = options.kinematics.as_deref() {
+        Some(sdk(runtime.load_kinematics_json(path))?)
+    } else {
+        load_validation_point(
+            &root.join("API/validation_points.dat"),
+            &sdk(runtime.representative_process_key())?,
+            metadata.external_particles.len(),
+        )?
+        .map(|point| {
+            let permutation = sdk(runtime.external_permutation())?;
+            reorder_validation_point(point, &permutation)
+        })
+        .transpose()?
+    };
+    let Some(momenta) = point else {
+        if options.json {
+            print!("{}", unavailable_json(&metadata));
+        } else {
+            println!("process: {}", metadata.process);
+            println!("no bundled validation point is available; metadata load succeeded");
+        }
+        return Ok(());
+    };
+
+    let totals = sdk(runtime.evaluate_f64(&momenta, 1))?;
+    let total = *totals
+        .first()
+        .ok_or_else(|| "Rusticol returned no compatibility total".to_owned())?;
+    let resolved = sdk(runtime.evaluate_resolved_f64(&momenta, 1, &Selectors::all()))?;
+    let (_, helicity_count, color_count) = resolved.shape();
+    if helicity_count != metadata.helicities.len() || color_count != metadata.colors.len() {
+        return Err("resolved shape does not match runtime metadata".to_owned());
+    }
+    let resolved_totals = resolved.totals();
+    let explicit_total = *resolved_totals
+        .first()
+        .ok_or_else(|| "Rusticol returned no resolved total".to_owned())?;
+    if !explicit_total.is_finite() || !total.is_finite() {
+        return Err("matrix-element output is not finite".to_owned());
+    }
+    let scale = total.abs().max(1.0);
+    if (explicit_total - total).abs() > 1.0e-12 * scale {
+        return Err("resolved components do not reproduce the compatibility total".to_owned());
+    }
+
+    if options.json {
+        print!(
+            "{}",
+            available_json(&metadata, &resolved, explicit_total, total)?
+        );
+        return Ok(());
+    }
+
+    println!("process: {} [{}]", metadata.process, metadata.process_key);
+    println!("resolved shape: (1, {helicity_count}, {color_count})");
+    for (helicity_index, helicity) in resolved.helicities().iter().enumerate() {
+        for (color_index, color) in resolved.colors().iter().enumerate() {
+            let value = resolved
+                .get(0, helicity_index, color_index)
+                .ok_or_else(|| "resolved result index is out of range".to_owned())?;
+            println!("  {}  {}  {}", helicity.id, color.id, value);
+        }
+    }
+    println!("explicit resolved sum: {explicit_total}");
+    println!("compatibility total:   {total}");
+    Ok(())
+}
+
+fn main() {
+    if let Err(error) = run() {
+        eprintln!("check_standalone: {error}");
+        std::process::exit(1);
+    }
+}
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/Makefile b/pyamplicol/src/pyamplicol/assets/api_templates/umami/Makefile
new file mode 100644
index 0000000000..6e37a40031
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/Makefile
@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: 0BSD
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell \
+	if command -v "$(RUSTICOL_CONFIG)" >/dev/null 2>&1; then \
+		command -v "$(RUSTICOL_CONFIG)"; \
+	elif [ "$(RUSTICOL_CONFIG)" = rusticol-config ]; then \
+		directory="$(CURDIR)"; \
+		while [ "$$directory" != / ]; do \
+			candidate="$$directory/.venv/bin/rusticol-config"; \
+			if [ -x "$$candidate" ]; then printf '%s\n' "$$candidate"; break; fi; \
+			directory=$$(dirname "$$directory"); \
+		done; \
+	fi)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+include providers.mk
+CC ?= cc
+# Make's abspath/notdir functions split on spaces; the shell preserves a path.
+ARTIFACT_DIR := $(shell cd ../.. && pwd -P)
+BUILD_DIR ?= $(shell dirname "$(ARTIFACT_DIR)")/.pyamplicol-api-build/$(shell basename "$(ARTIFACT_DIR)")/umami
+empty :=
+space := $(empty) $(empty)
+make_path = $(subst $(space),\$(space),$(1))
+BUILD_TARGET := $(call make_path,$(BUILD_DIR))
+CFLAGS ?= -O2
+CFLAGS += -std=c11 -Wall -Wextra -pedantic
+SDK_LIBRARY := $(shell "$(RUSTICOL_CONFIG_PATH)" --library)
+ifeq ($(strip $(SDK_LIBRARY)),)
+$(error rusticol-config could not resolve the native library)
+endif
+SDK_CFLAGS := $(shell "$(RUSTICOL_CONFIG_PATH)" --cflags)
+SDK_LIBS := $(shell "$(RUSTICOL_CONFIG_PATH)" --libs)
+SDK_LIBRARY_TARGET := $(call make_path,$(SDK_LIBRARY))
+HOST_SYSTEM := $(shell uname -s)
+ifeq ($(HOST_SYSTEM),Darwin)
+SHARED_FLAGS = -dynamiclib -Wl,-install_name,@rpath/$(shell basename "$@") -Wl,-exported_symbols_list,umami.exports.macos
+DRIVER_FLAGS = -Wl,-rpath,@loader_path
+else ifeq ($(HOST_SYSTEM),Linux)
+SHARED_FLAGS = -shared -Wl,-z,defs -Wl,-soname,$(shell basename "$@") -Wl,--version-script=umami.exports
+DRIVER_FLAGS = -Wl,-rpath,'$$ORIGIN'
+else
+$(error UMAMI shared-library examples support Linux and macOS)
+endif
+ifeq ($(UMAMI_SINGLE_PROVIDER),1)
+LIBRARY_NAMES := libumami.so
+DRIVER_NAMES := umami_driver
+RUN_DRIVER := $(BUILD_DIR)/umami_driver
+else
+LIBRARY_NAMES := $(addprefix libumami_,$(addsuffix .so,$(UMAMI_PROVIDERS)))
+DRIVER_NAMES := $(addprefix umami_driver_,$(UMAMI_PROVIDERS))
+PROVIDER ?= $(firstword $(UMAMI_PROVIDERS))
+RUN_DRIVER := $(BUILD_DIR)/umami_driver_$(PROVIDER)
+endif
+LIBRARIES := $(addprefix $(BUILD_TARGET)/,$(LIBRARY_NAMES))
+DRIVERS := $(addprefix $(BUILD_TARGET)/,$(DRIVER_NAMES))
+
+.PHONY: all shared run clean
+all: $(LIBRARIES) $(DRIVERS)
+shared: $(LIBRARIES)
+
+$(BUILD_TARGET):
+	mkdir -p "$@"
+
+# Explicit generated rules also work with spaces in directories on older Make
+# versions, whose pattern-rule handling does not preserve escaped spaces.
+define provider_rules
+$(BUILD_TARGET)/libumami$(2).so: umami.c provider_$(1).h umami_provider.h umami.h umami.exports umami.exports.macos $(SDK_LIBRARY_TARGET) | $(BUILD_TARGET)
+	$$(CC) $$(CPPFLAGS) $$(SDK_CFLAGS) $$(CFLAGS) -fPIC -DUMAMI_PROVIDER_HEADER='"provider_$(1).h"' $$(SHARED_FLAGS) "$$<" -o "$$@" $$(LDFLAGS) $$(SDK_LIBS)
+
+$(BUILD_TARGET)/umami_driver$(2): umami_driver.c $(BUILD_TARGET)/libumami$(2).so provider_$(1).h umami_provider.h umami.h | $(BUILD_TARGET)
+	$$(CC) $$(CPPFLAGS) $$(CFLAGS) -DUMAMI_PROVIDER_HEADER='"provider_$(1).h"' "$$<" "$(BUILD_DIR)/libumami$(2).so" -o "$$@" $$(LDFLAGS) $$(DRIVER_FLAGS)
+endef
+ifeq ($(UMAMI_SINGLE_PROVIDER),1)
+$(eval $(call provider_rules,p0,))
+else
+$(foreach provider,$(UMAMI_PROVIDERS),$(eval $(call provider_rules,$(provider),_$(provider))))
+endif
+
+run: $(call make_path,$(RUN_DRIVER))
+	"$(RUN_DRIVER)" "$(ARTIFACT_DIR)" $(ARGS)
+
+clean:
+	$(RM) $(foreach name,$(LIBRARY_NAMES) $(DRIVER_NAMES),"$(BUILD_DIR)/$(name)")
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/Makefile.reweight b/pyamplicol/src/pyamplicol/assets/api_templates/umami/Makefile.reweight
new file mode 100644
index 0000000000..225709e043
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/Makefile.reweight
@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: 0BSD
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell command -v "$(RUSTICOL_CONFIG)" 2>/dev/null)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+include providers.mk
+CC ?= cc
+BUILD_DIR ?= build
+CFLAGS ?= -O2
+CFLAGS += -std=c11 -Wall -Wextra -pedantic
+SDK_LIBRARY := $(shell "$(RUSTICOL_CONFIG_PATH)" --library)
+SDK_CFLAGS := $(shell "$(RUSTICOL_CONFIG_PATH)" --cflags)
+SDK_LIBS := $(shell "$(RUSTICOL_CONFIG_PATH)" --libs)
+HOST_SYSTEM := $(shell uname -s)
+ifeq ($(HOST_SYSTEM),Darwin)
+SHARED_FLAGS = -dynamiclib -Wl,-install_name,@rpath/$(notdir $@) -Wl,-exported_symbols_list,umami.exports.macos
+else ifeq ($(HOST_SYSTEM),Linux)
+SHARED_FLAGS = -shared -Wl,-z,defs -Wl,-soname,$(notdir $@) -Wl,--version-script=umami.exports
+else
+$(error UMAMI shared libraries support Linux and macOS)
+endif
+LIBRARIES := $(addprefix $(BUILD_DIR)/libreweight_,$(addsuffix .so,$(UMAMI_PROVIDERS)))
+
+.PHONY: all shared clean
+all shared: $(LIBRARIES)
+
+$(BUILD_DIR):
+	mkdir -p "$@"
+
+$(BUILD_DIR)/libreweight_%.so: umami_reweight.c reweight_%.h reweight_provider.h umami.h $(SDK_LIBRARY) | $(BUILD_DIR)
+	$(CC) $(CPPFLAGS) $(SDK_CFLAGS) $(CFLAGS) -fPIC -DUMAMI_REWEIGHT_HEADER='"reweight_$*.h"' $(SHARED_FLAGS) "$<" -o "$@" $(LDFLAGS) $(SDK_LIBS)
+
+clean:
+	$(RM) $(LIBRARIES)
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/README.md b/pyamplicol/src/pyamplicol/assets/api_templates/umami/README.md
new file mode 100644
index 0000000000..49c2f74bb4
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/README.md
@@ -0,0 +1,76 @@
+# UMAMI provider
+
+Build with the pyAmpliCol environment active:
+
+```sh
+make
+make run
+```
+
+`rusticol-config --cflags` and `--libs` locate the installed native SDK. Set
+`RUSTICOL_CONFIG=/absolute/path/to/rusticol-config` if needed. Build products go
+to the sibling `.pyamplicol-api-build/<artifact>/umami` directory, not into the
+artifact payload; override `BUILD_DIR` to choose another location.
+
+A single provider produces `libumami.so` and `umami_driver`. Multiple providers
+produce `libumami_p0.so`, `umami_driver_p0`, etc.; select `PROVIDER=p0` with
+`make run`. `metadata.json` identifies the available providers and their
+compatible external states. The driver takes `ABSOLUTE_ARTIFACT [CHANNEL [FLAVOUR]]`
+and evaluates a saved validation point.
+
+The shared library statically includes Rusticol. The driver links only that
+shared library, with a relative loader search path; keep the driver and library
+together when moving them. Runtime does not require Python. Retain all artifact
+files and their native evaluator dependencies. The matching SDK is needed only
+when compiling the provider.
+
+Unlike the standard parameter-card convention, `umami_initialize` requires the
+absolute artifact directory in `param_card_path`. Saved defaults initialize each
+independent handle; `umami_set_parameter` updates mutable model parameters through
+Rusticol. Optional per-event alpha_s is temporary and restored before returning.
+The interface reports unsupported alpha_s when the model has no explicit mapping.
+`UMAMI_META_MASSES` describes the saved default masses, not later handle-local
+parameter changes.
+
+Momenta use `input[event + stride*(particle + particle_count*component)]`, with
+components `(E,px,py,pz)`. Channel and flavour indices are zero-based. The returned
+matrix element includes the native incoming averaging and identical-particle
+normalization. It sums the artifact's available helicities. A random helicity
+input produces only an informational label; it does not sample the matrix element.
+Explicit helicity selection, random colour selection, diagrams and GPU streams
+are not supported by this adapter. LC rows select physical additive colour flows;
+NLC/full-colour rows use the complete contracted colour result, without a flow.
+These contracted providers do not support colour-count metadata or colour-index
+output; the corresponding capability query reports this explicitly.
+Integration multiplicities in metadata are not silently included in the returned
+matrix element. Consult metadata for restricted coverage and grouping assumptions.
+
+UMAMI automatically groups proven equivalent contributions; there is no grouping
+setting. Compact integration requires permutation-invariant, flavour-blind cuts
+and observables, recorded in `grouping.assumptions` alongside contribution
+counters. Identical-particle integration orbits are derived from final-state PDGs,
+oriented physical colour topology and permutations that preserve available
+helicity coverage. They do not add a reflection quotient or
+exchange incoming beams. With complete LC coverage, `g g > g g g` has four
+representatives for 24 physical colour contributions, each with integration
+multiplicity six. Full colour remains one contracted contribution with no extra
+factorial multiplier; native identical-particle normalization is already included.
+
+Proven equivalent contributions with different physical final-state flavours
+are also grouped. Equivalence uses model expressions and generated computation,
+not equal default parameters or Standard Model-specific particle rules.
+Unproved relations remain separate. The one exception is generation with
+`--flavor-blind`: its ungenerated flavour-class members are evaluated through
+their representative's runtime, and each provider exporting them records that
+assumption in `grouping.assumptions`.
+
+Integration multiplicities require cuts invariant under the recorded particle
+permutations; they are not factors for pointwise sums. Metadata retains physical
+members and their momentum mappings. Arbitrary labelled-leg or species-sensitive
+cuts require expanding those members and applying each cut to its physical
+contribution. Grouping never assumes equal PDFs; physical incoming PDGs remain
+oriented and retain their own PDF weights.
+
+The public header is copied from MadGraph7's UMAMI interface. Its copyright and
+license terms are retained in `UMAMI_LICENSE`; distribute that notice alongside
+compiled providers. The pyAmpliCol adapter and driver are distributed under 0BSD.
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/UMAMI_LICENSE b/pyamplicol/src/pyamplicol/assets/api_templates/umami/UMAMI_LICENSE
new file mode 100644
index 0000000000..55c561ffc2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/UMAMI_LICENSE
@@ -0,0 +1,41 @@
+The MadGraph7 software comes with the following Open Source License, 
+adapted from the University of Illinois/NCSA license.
+
+Copyright (c) 2009, 2013, the MadTeam.  All rights reserved.
+
+Developed by the "MadTeam", i.e. 
+
+Johan ALWALL
+Rikkert FREDERIX
+Stefano FRIXIONE
+Michel HERQUET
+Valentin HIRSCHI
+Fabio MALTONI
+Olivier MATTELAER
+Tim STELZER
+Paolo TORRIELLI
+Marco ZARO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal with the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimers.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimers in the
+     documentation and/or other materials provided with the distribution.
+  3. Neither the name "MadTeam", the names of the authors, their institution, 
+     nor the names of its contributors may be used to endorse or promote 
+     products derived from this Software without specific prior written 
+     permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+WITH THE SOFTWARE.
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/reweight_provider.h b/pyamplicol/src/pyamplicol/assets/api_templates/umami/reweight_provider.h
new file mode 100644
index 0000000000..b9a34d4926
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/reweight_provider.h
@@ -0,0 +1,41 @@
+/* SPDX-License-Identifier: 0BSD */
+#ifndef PYAMPLICOL_UMAMI_REWEIGHT_PROVIDER_H
+#define PYAMPLICOL_UMAMI_REWEIGHT_PROVIDER_H
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct {
+    const char *key;
+    const int *pdgs;
+    const char *alpha_s_name;
+    size_t helicity_count;
+} ReweightProcess;
+
+typedef struct {
+    size_t reference_process, target_process;
+    /* runtime[j] = input[permutation[j]], including both incoming legs. */
+    const size_t *permutation;
+    /* Exported helicity index -> runtime index of each process, -1 if absent. */
+    const int *reference_helicity, *target_helicity;
+} ReweightFlavour;
+
+typedef struct {
+    size_t flavour_count;
+    const ReweightFlavour *flavours;
+} ReweightChannel;
+
+typedef struct {
+    const char *id;
+    size_t particle_count, exported_helicity_count;
+    /* Artifact directories relative to the directory passed to umami_initialize. */
+    const char *reference_artifact, *target_artifact;
+    const char *reference_artifact_id, *target_artifact_id;
+    size_t reference_process_count;
+    const ReweightProcess *reference_processes;
+    size_t target_process_count;
+    const ReweightProcess *target_processes;
+    size_t channel_count;
+    const ReweightChannel *channels;
+    bool supports_alpha_s;
+} ReweightProvider;
+#endif
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.c b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.c
new file mode 100644
index 0000000000..be6f8e7d27
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.c
@@ -0,0 +1,437 @@
+/* SPDX-License-Identifier: 0BSD */
+#include "umami.h"
+#include "umami_provider.h"
+#include <rusticol.h>
+#include <limits.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#ifndef UMAMI_PROVIDER_HEADER
+#define UMAMI_PROVIDER_HEADER "provider_p0.h"
+#endif
+#include UMAMI_PROVIDER_HEADER
+
+typedef struct {
+    char *name;
+    double real, imaginary;
+} Override;
+
+typedef struct {
+    char *artifact;
+    RusticolRuntimeHandle **runtimes;
+    double *momenta;
+    double *helicity_values;
+    /* Parameters set so far, applied to the processes loaded later. */
+    Override *overrides;
+    size_t override_count;
+} Instance;
+
+static bool const supported_inputs[UMAMI_INPUT_KEY_COUNT] = {
+    [UMAMI_IN_MOMENTA] = true,
+    [UMAMI_IN_ALPHA_S] = UMAMI_HAS_ALPHA_S,
+    [UMAMI_IN_FLAVOR_INDEX] = true,
+    [UMAMI_IN_RANDOM_HELICITY] = true,
+    [UMAMI_IN_HELICITY_INDEX] = true,
+    [UMAMI_IN_CHANNEL_INDEX] = true,
+};
+static bool const required_inputs[UMAMI_INPUT_KEY_COUNT] = {
+    [UMAMI_IN_MOMENTA] = true,
+};
+static bool const supported_outputs[UMAMI_OUTPUT_KEY_COUNT] = {
+    [UMAMI_OUT_MATRIX_ELEMENT] = true,
+    [UMAMI_OUT_COLOR_INDEX] = UMAMI_HAS_COLOR_FLOW,
+    [UMAMI_OUT_HELICITY_INDEX] = true,
+};
+
+static UmamiStatus native_error(int status) {
+    if (status == RUSTICOL_STATUS_OK) return UMAMI_SUCCESS;
+    char message[1024];
+    size_t required = 0;
+    if (rusticol_last_error_message(message, sizeof(message), &required) ==
+        RUSTICOL_STATUS_OK) fprintf(stderr, "umami: %s\n", message);
+    return UMAMI_ERROR;
+}
+
+static UmamiParameter const *parameter(size_t process, char const *name) {
+    UmamiProcess const *entry = &umami_provider.processes[process];
+    for (size_t i = 0; i < entry->parameter_count; ++i)
+        if (strcmp(entry->parameters[i].name, name) == 0) return &entry->parameters[i];
+    return NULL;
+}
+
+static UmamiStatus load_process(Instance *instance, size_t process) {
+    if (instance->runtimes[process] != NULL) return UMAMI_SUCCESS;
+    UmamiProcess const *entry = &umami_provider.processes[process];
+    RusticolRuntimeHandle *runtime = NULL;
+    int status = rusticol_runtime_load(instance->artifact, entry->key, NULL, &runtime);
+    if (status != RUSTICOL_STATUS_OK) return native_error(status);
+    size_t count = 0, required = 0;
+    char accuracy[16];
+    status = rusticol_runtime_external_count(runtime, &count);
+    bool compatible = status == RUSTICOL_STATUS_OK && count == umami_provider.particle_count;
+    char const *expected_identity = UMAMI_ARTIFACT_ID;
+    if (compatible && expected_identity != NULL) {
+        size_t capacity = strlen(expected_identity) + 1;
+        char *identity = malloc(capacity);
+        if (identity == NULL) compatible = false;
+        else {
+            status = rusticol_runtime_artifact_id(runtime, identity, capacity, &required);
+            compatible = status == RUSTICOL_STATUS_OK && strcmp(identity, expected_identity) == 0;
+            free(identity);
+        }
+    }
+    for (size_t j = 0; compatible && j < count; ++j) {
+        int32_t pdg = 0;
+        status = rusticol_runtime_external_pdg(runtime, j, &pdg);
+        compatible = status == RUSTICOL_STATUS_OK && pdg == entry->pdgs[j];
+    }
+    if (compatible) {
+        status = rusticol_runtime_color_accuracy(runtime, accuracy, sizeof(accuracy), &required);
+        compatible = status == RUSTICOL_STATUS_OK && strcmp(accuracy, entry->color_accuracy) == 0;
+    }
+    if (compatible) {
+        status = rusticol_runtime_helicity_count(runtime, &count);
+        compatible = status == RUSTICOL_STATUS_OK && count == entry->helicity_count;
+    }
+    for (size_t j = 0; compatible && j < entry->helicity_count; ++j) {
+        size_t capacity = strlen(entry->helicity_ids[j]) + 1;
+        char *identifier = malloc(capacity);
+        if (identifier == NULL) { compatible = false; break; }
+        status = rusticol_runtime_helicity_id(runtime, j, identifier, capacity, &required);
+        compatible = status == RUSTICOL_STATUS_OK && strcmp(identifier, entry->helicity_ids[j]) == 0;
+        free(identifier);
+    }
+    if (!compatible) {
+        (void)rusticol_runtime_free(runtime);
+        fprintf(stderr, "umami: artifact is incompatible with provider %s, process %s\n",
+                umami_provider.id, entry->key);
+        return UMAMI_ERROR;
+    }
+    for (size_t i = 0; i < instance->override_count; ++i) {
+        Override const *override = &instance->overrides[i];
+        UmamiParameter const *known = parameter(process, override->name);
+        if (known == NULL) continue;
+        status = rusticol_runtime_set_model_parameter(runtime, override->name,
+            override->real, known->is_complex ? override->imaginary : 0.0);
+        if (status != RUSTICOL_STATUS_OK) {
+            (void)rusticol_runtime_free(runtime);
+            return native_error(status);
+        }
+    }
+    instance->runtimes[process] = runtime;
+    return UMAMI_SUCCESS;
+}
+
+static UmamiStatus record_override(Instance *instance, char const *name,
+                                   double real, double imaginary) {
+    for (size_t i = 0; i < instance->override_count; ++i)
+        if (strcmp(instance->overrides[i].name, name) == 0) {
+            instance->overrides[i].real = real;
+            instance->overrides[i].imaginary = imaginary;
+            return UMAMI_SUCCESS;
+        }
+    Override *overrides = realloc(instance->overrides,
+                                  (instance->override_count + 1) * sizeof(*overrides));
+    if (overrides == NULL) return UMAMI_ERROR;
+    instance->overrides = overrides;
+    char *copy = malloc(strlen(name) + 1);
+    if (copy == NULL) return UMAMI_ERROR;
+    strcpy(copy, name);
+    overrides[instance->override_count++] = (Override){copy, real, imaginary};
+    return UMAMI_SUCCESS;
+}
+
+UmamiStatus umami_get_meta(UmamiMetaKey key, void *result) {
+    if (result == NULL) return UMAMI_ERROR;
+    switch (key) {
+    case UMAMI_META_DEVICE: *(UmamiDevice *)result = UMAMI_DEVICE_CPU; break;
+    case UMAMI_META_PARTICLE_COUNT: *(int *)result = (int)umami_provider.particle_count; break;
+    case UMAMI_META_HELICITY_COUNT: *(int *)result = (int)umami_provider.helicity_count; break;
+    case UMAMI_META_COLOR_COUNT:
+        if (!UMAMI_HAS_COLOR_FLOW) return UMAMI_ERROR_UNSUPPORTED_META;
+        *(int *)result = (int)umami_provider.color_count; break;
+    case UMAMI_META_MASSES:
+        memcpy(result, umami_provider.masses, umami_provider.particle_count * sizeof(double));
+        break;
+    default: return UMAMI_ERROR_UNSUPPORTED_META;
+    }
+    return UMAMI_SUCCESS;
+}
+
+UmamiStatus umami_supported_inputs(bool const **supported, int *count) {
+    if (supported == NULL || count == NULL) return UMAMI_ERROR;
+    *supported = supported_inputs; *count = UMAMI_INPUT_KEY_COUNT;
+    return UMAMI_SUCCESS;
+}
+UmamiStatus umami_required_inputs(bool const **required, int *count) {
+    if (required == NULL || count == NULL) return UMAMI_ERROR;
+    *required = required_inputs; *count = UMAMI_INPUT_KEY_COUNT;
+    return UMAMI_SUCCESS;
+}
+UmamiStatus umami_supported_outputs(bool const **supported, int *count) {
+    if (supported == NULL || count == NULL) return UMAMI_ERROR;
+    *supported = supported_outputs; *count = UMAMI_OUTPUT_KEY_COUNT;
+    return UMAMI_SUCCESS;
+}
+
+UmamiStatus umami_initialize(UmamiHandle *handle, char const *param_card_path) {
+    if (handle == NULL) return UMAMI_ERROR;
+    *handle = NULL;
+    struct stat info;
+    if (param_card_path == NULL || param_card_path[0] != '/' ||
+        stat(param_card_path, &info) != 0 || !S_ISDIR(info.st_mode) ||
+        umami_provider.process_count == 0 || umami_provider.particle_count > INT_MAX ||
+        umami_provider.particle_count > SIZE_MAX / (4 * sizeof(double))) return UMAMI_ERROR;
+    Instance *instance = calloc(1, sizeof(*instance));
+    if (instance == NULL) return UMAMI_ERROR;
+    size_t length = strlen(param_card_path) + 1;
+    instance->artifact = malloc(length);
+    instance->runtimes = calloc(umami_provider.process_count, sizeof(*instance->runtimes));
+    instance->momenta = calloc(4 * umami_provider.particle_count, sizeof(double));
+    instance->helicity_values = calloc(umami_provider.helicity_count + 1, sizeof(double));
+    if (instance->artifact == NULL || instance->runtimes == NULL || instance->momenta == NULL ||
+        instance->helicity_values == NULL) {
+        umami_free(instance); return UMAMI_ERROR;
+    }
+    memcpy(instance->artifact, param_card_path, length);
+    /* Validate the artifact now; other processes are loaded lazily on first use. */
+    UmamiStatus status = load_process(instance, 0);
+    if (status != UMAMI_SUCCESS) { umami_free(instance); return status; }
+    *handle = instance;
+    return UMAMI_SUCCESS;
+}
+
+UmamiStatus umami_get_parameter(UmamiHandle handle, char const *name,
+                              double *real, double *imaginary) {
+    if (handle == NULL || name == NULL || real == NULL) return UMAMI_ERROR;
+    Instance *instance = handle;
+    for (size_t i = 0; i < umami_provider.process_count; ++i) {
+        UmamiParameter const *entry = parameter(i, name);
+        if (entry == NULL) continue;
+        if (entry->is_complex && imaginary == NULL) return UMAMI_ERROR;
+        UmamiStatus status = load_process(instance, i);
+        if (status != UMAMI_SUCCESS) return status;
+        double re, im;
+        status = native_error(rusticol_runtime_get_model_parameter(instance->runtimes[i], name, &re, &im));
+        if (status != UMAMI_SUCCESS) return status;
+        *real = re;
+        if (imaginary != NULL) *imaginary = im;
+        return UMAMI_SUCCESS;
+    }
+    return UMAMI_ERROR;
+}
+
+UmamiStatus umami_set_parameter(UmamiHandle handle, char const *name,
+                              double real, double imaginary) {
+    if (handle == NULL || name == NULL || !isfinite(real)) return UMAMI_ERROR;
+    Instance *instance = handle;
+    size_t count = umami_provider.process_count;
+    double *previous = calloc(count * 2, sizeof(double));
+    bool *changed = calloc(count, sizeof(bool));
+    if (previous == NULL || changed == NULL) { free(previous); free(changed); return UMAMI_ERROR; }
+    UmamiStatus status = UMAMI_ERROR;
+    bool found = false;
+    for (size_t i = 0; i < count; ++i) {
+        UmamiParameter const *entry = parameter(i, name);
+        if (entry == NULL) continue;
+        /* Load the first process using it, so that the value is validated now. */
+        if (!found && load_process(instance, i) != UMAMI_SUCCESS) goto rollback;
+        found = true;
+        if (!entry->mutable || (entry->is_complex && !isfinite(imaginary))) goto rollback;
+        if (instance->runtimes[i] == NULL) continue;
+        status = native_error(rusticol_runtime_get_model_parameter(
+            instance->runtimes[i], name, &previous[2*i], &previous[2*i+1]));
+        if (status != UMAMI_SUCCESS) goto rollback;
+        status = native_error(rusticol_runtime_set_model_parameter(
+            instance->runtimes[i], name, real, entry->is_complex ? imaginary : 0.0));
+        if (status != UMAMI_SUCCESS) goto rollback;
+        changed[i] = true;
+    }
+    if (found && record_override(instance, name, real, imaginary) != UMAMI_SUCCESS)
+        goto rollback;
+    free(previous); free(changed);
+    return found ? UMAMI_SUCCESS : UMAMI_ERROR;
+rollback:
+    for (size_t i = 0; i < count; ++i)
+        if (changed[i]) (void)rusticol_runtime_set_model_parameter(
+            instance->runtimes[i], name, previous[2*i], previous[2*i+1]);
+    free(previous); free(changed);
+    return UMAMI_ERROR;
+}
+
+/* Total of one contribution, at a fixed runtime helicity if helicity is not NULL. With
+ * values, the values of all runtime helicities are written there and summed. */
+static UmamiStatus evaluate_contribution(Instance *instance, UmamiContribution const *entry,
+                                        double const *momenta, size_t event, size_t stride,
+                                        double const *alpha_s, uint32_t const *helicity,
+                                        double *values, double *result) {
+    size_t process = entry->process_index;
+    UmamiProcess const *description = &umami_provider.processes[process];
+    UmamiStatus status = load_process(instance, process);
+    if (status != UMAMI_SUCCESS) return status;
+    RusticolRuntimeHandle *runtime = instance->runtimes[process];
+    size_t n = umami_provider.particle_count;
+    for (size_t j = 0; j < n; ++j)
+        for (size_t k = 0; k < 4; ++k) {
+            double value = momenta[event + stride * (n*k + entry->permutation[j])];
+            if (!isfinite(value)) return UMAMI_ERROR;
+            instance->momenta[4*j+k] = value;
+        }
+    double previous_real = 0.0, previous_imaginary = 0.0;
+    bool changed = false;
+    if (alpha_s != NULL) {
+        if (description->alpha_s_name == NULL) return UMAMI_ERROR_UNSUPPORTED_INPUT;
+        if (!isfinite(*alpha_s) || *alpha_s < 0.0) return UMAMI_ERROR;
+        status = native_error(rusticol_runtime_get_model_parameter(
+            runtime, description->alpha_s_name, &previous_real, &previous_imaginary));
+        if (status != UMAMI_SUCCESS) return status;
+        changed = previous_real != *alpha_s || previous_imaginary != 0.0;
+        if (changed) {
+            status = native_error(rusticol_runtime_set_model_parameter(
+                runtime, description->alpha_s_name, *alpha_s, 0.0));
+            if (status != UMAMI_SUCCESS) return status;
+        }
+    }
+    int native_status;
+    if (values != NULL) {
+        size_t helicity_count = 0, color_count = 0;
+        native_status = rusticol_runtime_evaluate_resolved_f64(
+            runtime, instance->momenta, 4*n, 1, NULL, 0,
+            entry->color_id == NULL ? NULL : &entry->color_id,
+            entry->color_id == NULL ? 0 : 1,
+            values, description->helicity_count, &helicity_count, &color_count);
+        if (native_status == RUSTICOL_STATUS_OK &&
+            (helicity_count != description->helicity_count || color_count != 1)) {
+            fprintf(stderr, "umami: unexpected resolved shape of process %s\n", description->key);
+            native_status = RUSTICOL_STATUS_RUNTIME_ERROR;
+        }
+        *result = 0.0;
+        for (size_t h = 0; native_status == RUSTICOL_STATUS_OK && h < helicity_count; ++h)
+            *result += values[h];
+    } else {
+        native_status = rusticol_runtime_evaluate_selected_f64(
+            runtime, instance->momenta, 4*n, 1,
+            NULL, 0,
+            entry->color_id == NULL ? NULL : &entry->color_id,
+            entry->color_id == NULL ? 0 : 1,
+            helicity, helicity == NULL ? 0 : 1, NULL, 0, result, 1);
+    }
+    status = native_error(native_status);
+    if (changed) {
+        UmamiStatus restored = native_error(rusticol_runtime_set_model_parameter(
+            runtime, description->alpha_s_name, previous_real, previous_imaginary));
+        if (restored != UMAMI_SUCCESS) return restored;
+    }
+    return status;
+}
+
+UmamiStatus umami_matrix_element(UmamiHandle handle, size_t count, size_t stride, size_t offset,
+    size_t input_count, UmamiInputKey const *input_keys, void const *const *inputs,
+    size_t output_count, UmamiOutputKey const *output_keys, void *const *outputs) {
+    if (handle == NULL || offset > stride || count > stride-offset ||
+        (input_count && (input_keys == NULL || inputs == NULL)) ||
+        (output_count && (output_keys == NULL || outputs == NULL)) ||
+        (stride && umami_provider.particle_count > SIZE_MAX / stride / 4)) return UMAMI_ERROR;
+    void const *in[UMAMI_INPUT_KEY_COUNT] = {0};
+    void *out[UMAMI_OUTPUT_KEY_COUNT] = {0};
+    for (size_t i = 0; i < input_count; ++i) {
+        int key = input_keys[i];
+        if (key < 0 || key >= UMAMI_INPUT_KEY_COUNT || !supported_inputs[key])
+            return UMAMI_ERROR_UNSUPPORTED_INPUT;
+        if (inputs[i] == NULL || in[key] != NULL) return UMAMI_ERROR;
+        in[key] = inputs[i];
+    }
+    for (size_t i = 0; i < output_count; ++i) {
+        int key = output_keys[i];
+        if (key < 0 || key >= UMAMI_OUTPUT_KEY_COUNT || !supported_outputs[key])
+            return UMAMI_ERROR_UNSUPPORTED_OUTPUT;
+        if (outputs[i] == NULL || out[key] != NULL) return UMAMI_ERROR;
+        out[key] = outputs[i];
+    }
+    if (count == 0) return UMAMI_SUCCESS;
+    if (in[UMAMI_IN_MOMENTA] == NULL) return UMAMI_ERROR_MISSING_INPUT;
+    Instance *instance = handle;
+    for (size_t event = offset; event < offset+count; ++event) {
+        size_t channel = in[UMAMI_IN_CHANNEL_INDEX] ?
+            ((unsigned int const *)in[UMAMI_IN_CHANNEL_INDEX])[event] : 0;
+        int flavour = in[UMAMI_IN_FLAVOR_INDEX] ?
+            ((int const *)in[UMAMI_IN_FLAVOR_INDEX])[event] : 0;
+        if (channel >= umami_provider.channel_count || flavour < 0 ||
+            (size_t)flavour >= umami_provider.channels[channel].flavour_count) return UMAMI_ERROR;
+        UmamiFlavour const *selection = &umami_provider.channels[channel].flavours[flavour];
+        if (selection->contribution_count == 0) return UMAMI_ERROR;
+        double random = in[UMAMI_IN_RANDOM_HELICITY] ?
+            ((double const *)in[UMAMI_IN_RANDOM_HELICITY])[event] : 0.5;
+        if (!isfinite(random) || random < 0.0 || random >= 1.0) return UMAMI_ERROR;
+        double const *alpha_s =
+            in[UMAMI_IN_ALPHA_S] ? &((double const *)in[UMAMI_IN_ALPHA_S])[event] : NULL;
+        UmamiContribution const *first = &selection->contributions[0];
+        int label = 0;
+        double total = 0.0;
+        if (in[UMAMI_IN_HELICITY_INDEX]) {
+            /* a fixed exported helicity, absent ones do not contribute */
+            label = ((int const *)in[UMAMI_IN_HELICITY_INDEX])[event];
+            if (label < 0 || (size_t)label >= umami_provider.exported_helicity_count)
+                return UMAMI_ERROR;
+            for (size_t j = 0; j < selection->contribution_count; ++j) {
+                UmamiContribution const *entry = &selection->contributions[j];
+                if (entry->helicity_runtime[label] < 0) continue;
+                uint32_t helicity = (uint32_t)entry->helicity_runtime[label];
+                double value = 0.0;
+                UmamiStatus status = evaluate_contribution(instance, entry,
+                    in[UMAMI_IN_MOMENTA], event, stride, alpha_s, &helicity, NULL, &value);
+                if (status != UMAMI_SUCCESS) return status;
+                total += entry->factor * value;
+            }
+        } else if (out[UMAMI_OUT_HELICITY_INDEX] && selection->contribution_count == 1) {
+            /* sample the helicity in proportion to its contribution */
+            double *values = instance->helicity_values;
+            UmamiStatus status = evaluate_contribution(instance, first,
+                in[UMAMI_IN_MOMENTA], event, stride, alpha_s, NULL, values, &total);
+            if (status != UMAMI_SUCCESS) return status;
+            size_t count = umami_provider.processes[first->process_index].helicity_count;
+            double target = random * total, cumulative = 0.0;
+            size_t chosen = 0;
+            for (size_t h = 0; h < count; ++h) {
+                if (values[h] <= 0.0) continue;
+                chosen = h;
+                cumulative += values[h];
+                if (cumulative > target) break;
+            }
+            label = (int)first->helicity_export[chosen];
+            total *= first->factor;
+        } else {
+            if (out[UMAMI_OUT_HELICITY_INDEX]) return UMAMI_ERROR_UNSUPPORTED_OUTPUT;
+            for (size_t j = 0; j < selection->contribution_count; ++j) {
+                double value = 0.0;
+                UmamiStatus status = evaluate_contribution(instance, &selection->contributions[j],
+                    in[UMAMI_IN_MOMENTA], event, stride, alpha_s, NULL, NULL, &value);
+                if (status != UMAMI_SUCCESS) return status;
+                total += selection->contributions[j].factor * value;
+            }
+        }
+        if (!isfinite(total)) return UMAMI_ERROR;
+        if (out[UMAMI_OUT_MATRIX_ELEMENT]) ((double *)out[UMAMI_OUT_MATRIX_ELEMENT])[event] = total;
+        if (out[UMAMI_OUT_HELICITY_INDEX]) ((int *)out[UMAMI_OUT_HELICITY_INDEX])[event] = label;
+        if (out[UMAMI_OUT_COLOR_INDEX]) ((int *)out[UMAMI_OUT_COLOR_INDEX])[event] =
+            (int)first->color_index;
+    }
+    return UMAMI_SUCCESS;
+}
+
+UmamiStatus umami_free(UmamiHandle handle) {
+    if (handle == NULL) return UMAMI_SUCCESS;
+    Instance *instance = handle;
+    if (instance->runtimes != NULL)
+        for (size_t i = 0; i < umami_provider.process_count; ++i)
+            if (instance->runtimes[i] != NULL) (void)rusticol_runtime_free(instance->runtimes[i]);
+    for (size_t i = 0; i < instance->override_count; ++i) free(instance->overrides[i].name);
+    free(instance->overrides);
+    free(instance->runtimes); free(instance->momenta); free(instance->helicity_values);
+    free(instance->artifact); free(instance);
+    return UMAMI_SUCCESS;
+}
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.exports b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.exports
new file mode 100644
index 0000000000..5fb36d6d48
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.exports
@@ -0,0 +1,13 @@
+UMAMI_1.0 {
+    global:
+        umami_get_meta;
+        umami_supported_inputs;
+        umami_required_inputs;
+        umami_supported_outputs;
+        umami_initialize;
+        umami_set_parameter;
+        umami_get_parameter;
+        umami_matrix_element;
+        umami_free;
+    local: *;
+};
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.exports.macos b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.exports.macos
new file mode 100644
index 0000000000..8fbe7e93fb
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.exports.macos
@@ -0,0 +1,9 @@
+_umami_get_meta
+_umami_supported_inputs
+_umami_required_inputs
+_umami_supported_outputs
+_umami_initialize
+_umami_set_parameter
+_umami_get_parameter
+_umami_matrix_element
+_umami_free
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.h b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.h
new file mode 100644
index 0000000000..4eb2dba380
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami.h
@@ -0,0 +1,324 @@
+/*
+ *                                   _
+ *                                  (_)
+ *   _   _ _ __ ___   __ _ _ __ ___  _
+ *  | | | | '_ ` _ \ / _` | '_ ` _ \| |
+ *  | |_| | | | | | | (_| | | | | | | |
+ *   \__,_|_| |_| |_|\__,_|_| |_| |_|_|
+ *
+ *  Unified  MAtrix  eleMent  Interface
+ *
+ *
+ */
+
+#ifndef UMAMI_HEADER
+#define UMAMI_HEADER 1
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Major version number of the UMAMI interface. If the major version is the same
+ * between caller and implementation, binary compatibility is ensured.
+ */
+#define UMAMI_MAJOR_VERSION 1
+/**
+ * Minor version number of the UMAMI interface. Between minor versions, new keys for
+ * errors, devices, metadata, inputs and outputs can be added.
+ */
+#define UMAMI_MINOR_VERSION 2
+
+typedef enum {
+    /** operation was executed successfully */
+    UMAMI_SUCCESS,
+    /** an unspecified error */
+    UMAMI_ERROR,
+    /** operation not implemented */
+    UMAMI_ERROR_NOT_IMPLEMENTED,
+    /** the provided input key is not supported by this matrix element implementation */
+    UMAMI_ERROR_UNSUPPORTED_INPUT,
+    /** the provided output key is not supported by this matrix element implementation
+     */
+    UMAMI_ERROR_UNSUPPORTED_OUTPUT,
+    /** the meta_key was not yet initialized */
+    UMAMI_ERROR_UNINITIALIZED_META,
+    /** the provided metadata key is not supported by this matrix element implementation
+     */
+    UMAMI_ERROR_UNSUPPORTED_META,
+    /** a mandatory matrix element input was not provided */
+    UMAMI_ERROR_MISSING_INPUT,
+} UmamiStatus;
+
+typedef enum {
+    UMAMI_DEVICE_CPU,
+    UMAMI_DEVICE_CUDA,
+    UMAMI_DEVICE_HIP,
+} UmamiDevice;
+
+typedef enum {
+    /** `UmamiDevice` specifying the type of device */
+    UMAMI_META_DEVICE,
+    /** `int` specifying the number of external particles */
+    UMAMI_META_PARTICLE_COUNT,
+    /** `int` specifying the number of Feynman diagrams */
+    UMAMI_META_DIAGRAM_COUNT,
+    /** `int` specifying the number of helicities */
+    UMAMI_META_HELICITY_COUNT,
+    /** `int` specifying the number of colors */
+    UMAMI_META_COLOR_COUNT,
+    /** `double` array of length particle count: the external-leg masses (GeV) */
+    UMAMI_META_MASSES,
+} UmamiMetaKey;
+
+typedef enum {
+    /** momenta of the external legs, type: `double`, shape: `(particle count, 4)` */
+    UMAMI_IN_MOMENTA,
+    /** value for the strong coupling, type: `double`, shape: `()` */
+    UMAMI_IN_ALPHA_S,
+    /** flavor index, type: `int`, shape: `()` */
+    UMAMI_IN_FLAVOR_INDEX,
+    /** random number for color selection, type: `double`, shape: `()` */
+    UMAMI_IN_RANDOM_COLOR,
+    /** random number for helicity selection, type: `double`, shape: `()` */
+    UMAMI_IN_RANDOM_HELICITY,
+    /** random number for diagram selection, type: `double`, shape: `()` */
+    UMAMI_IN_RANDOM_DIAGRAM,
+    /** externally selected helicity index, type: `int`, shape: `()` */
+    UMAMI_IN_HELICITY_INDEX,
+    /** externally selected diagram index, type: `unsigned int`, shape: `()` */
+    UMAMI_IN_DIAGRAM_INDEX,
+    /** externally selected channel index, type: `unsigned int`, shape: `()` */
+    UMAMI_IN_CHANNEL_INDEX,
+    /** number of external legs, type: `int`, shape: `()` */
+    UMAMI_IN_PARTICLE_COUNT,
+    /** PDG ids of the external legs, type: `int`, shape: `(particle count)` */
+    UMAMI_IN_PDG_IDS,
+    /** momentum fraction of an incoming parton, type: `double`, shape: `()` */
+    UMAMI_IN_MOMENTUM_FRACTION,
+    /** energy scale, e.g. the factorization scale, type: `double`, shape: `()` */
+    UMAMI_IN_SCALE,
+    /** PDG id of a single parton, type: `int`, shape: `()` */
+    UMAMI_IN_PDG_ID,
+    /** index of the beam (0 or 1), type: `int`, shape: `()` */
+    UMAMI_IN_BEAM_INDEX,
+} UmamiInputKey;
+
+/** Number of values in `UmamiInputKey` */
+#define UMAMI_INPUT_KEY_COUNT (UMAMI_IN_BEAM_INDEX + 1)
+
+typedef enum {
+    /** value of the matrix element, type: `double`, shape: `()` */
+    UMAMI_OUT_MATRIX_ELEMENT,
+    /** squared amplitudes of the diagrams, type: `double`, shape: `(diagram count)` */
+    UMAMI_OUT_DIAGRAM_AMP2,
+    /** selected color index, type: `int`, shape: `()` */
+    UMAMI_OUT_COLOR_INDEX,
+    /** selected helicity index, type: `int`, shape: `()` */
+    UMAMI_OUT_HELICITY_INDEX,
+    /** selected diagram index, type: `int`, shape: `()` */
+    UMAMI_OUT_DIAGRAM_INDEX,
+    /** CUDA or HIP stream for asynchronous execution. Listed as an output as it is a
+     * mutable pointer */
+    UMAMI_OUT_GPU_STREAM,
+    /** value of a custom cut, 0 rejects the event, type: `double`, shape: `()` */
+    UMAMI_OUT_CUT,
+    /** value of a custom energy scale, type: `double`, shape: `()` */
+    UMAMI_OUT_SCALE,
+    /** value x f(x, Q) of a custom parton density, type: `double`, shape: `()` */
+    UMAMI_OUT_PDF,
+    /** value of a custom event bias, type: `double`, shape: `()` */
+    UMAMI_OUT_BIAS,
+    /** ratio of the matrix element to a reference matrix element defined by the
+     * caller, type: `double`, shape: `()` */
+    UMAMI_OUT_MATRIX_ELEMENT_RATIO,
+} UmamiOutputKey;
+
+/** Number of values in `UmamiOutputKey` */
+#define UMAMI_OUTPUT_KEY_COUNT (UMAMI_OUT_MATRIX_ELEMENT_RATIO + 1)
+
+/** Implementation-defined pointer to a matrix element instance */
+typedef void* UmamiHandle;
+
+/**
+ * Retrieve metadata about the implemented matrix element
+ *
+ * @param meta_key
+ *     key specifying the type of metadata to be retrieved
+ * @param result
+ *     pointer to store the result. It's type depends on the metadata key
+ * @return
+ *     UMAMI_SUCCESS on success, error code otherwise
+ */
+UmamiStatus umami_get_meta(UmamiMetaKey meta_key, void* result);
+
+/**
+ * Reports which input keys can be passed to this matrix element implementation, to
+ * be written by whoever implements the UMAMI interface. Implementing this function
+ * is optional; a caller that fails to resolve it should treat it as unavailable.
+ *
+ * @param supported
+ *     pointer set on return to an implementation-owned array of booleans, where
+ *     element `i` indicates whether the input key with numeric value `i`
+ *     (see `UmamiInputKey`) is accepted by this implementation.
+ * @param count
+ *     pointer set on return to the number of elements in `*supported`, reflecting
+ *     the number of `UmamiInputKey` values known to this implementation. A caller
+ *     built against a newer header should treat any key index beyond `*count` as
+ *     not supported.
+ * @return
+ *     UMAMI_SUCCESS on success, error code otherwise
+ */
+UmamiStatus umami_supported_inputs(bool const** supported, int* count);
+
+/**
+ * Reports which input keys must be passed to this matrix element implementation for
+ * `umami_matrix_element` to succeed, to be written by whoever implements the UMAMI
+ * interface. This is a subset of the keys reported by `umami_supported_inputs`.
+ * Implementing this function is optional; a caller that fails to resolve it should
+ * treat it as unavailable.
+ *
+ * @param required
+ *     pointer set on return to an implementation-owned array of booleans, where
+ *     element `i` indicates whether the input key with numeric value `i`
+ *     (see `UmamiInputKey`) is mandatory for this implementation.
+ * @param count
+ *     pointer set on return to the number of elements in `*required`. A caller
+ *     built against a newer header should treat any key index beyond `*count` as
+ *     not required.
+ * @return
+ *     UMAMI_SUCCESS on success, error code otherwise
+ */
+UmamiStatus umami_required_inputs(bool const** required, int* count);
+
+/**
+ * Reports which output keys can be requested from this matrix element
+ * implementation, to be written by whoever implements the UMAMI interface.
+ * Implementing this function is optional; a caller that fails to resolve it should
+ * treat it as unavailable.
+ *
+ * @param supported
+ *     pointer set on return to an implementation-owned array of booleans, where
+ *     element `i` indicates whether the output key with numeric value `i`
+ *     (see `UmamiOutputKey`) can be produced by this implementation.
+ * @param count
+ *     pointer set on return to the number of elements in `*supported`. A caller
+ *     built against a newer header should treat any key index beyond `*count` as
+ *     not supported.
+ * @return
+ *     UMAMI_SUCCESS on success, error code otherwise
+ */
+UmamiStatus umami_supported_outputs(bool const** supported, int* count);
+
+/**
+ * Creates an instance of the matrix element. Each instance is independent, so thread
+ * safety can be achieved by creating a separate one for every thread.
+ *
+ * @param handle
+ *     pointer to an instance of the subprocess. Has to be cleaned up by
+ *     the caller with `free_subprocess`.
+ * @param param_card_path
+ *     path to the parameter file
+ * @return
+ *     UMAMI_SUCCESS on success, error code otherwise
+ */
+UmamiStatus umami_initialize(UmamiHandle* handle, char const* param_card_path);
+
+/**
+ * Sets the value of a model parameter
+ *
+ * @param handle
+ *     handle of a matrix element instance
+ * @param name
+ *     name of the parameter
+ * @param parameter_real
+ *     real part of the parameter value
+ * @param parameter_imag
+ *     imaginary part of the parameter value. Ignored for real valued parameters.
+ * @return
+ *     UMAMI_SUCCESS on success, error code otherwise
+ */
+UmamiStatus umami_set_parameter(
+    UmamiHandle handle, char const* name, double parameter_real, double parameter_imag
+);
+
+/**
+ * Retrieves the value of a model parameter
+ *
+ * @param handle
+ *     handle of a matrix element instance
+ * @param name
+ *     name of the parameter
+ * @param parameter_real
+ *     pointer to double to return real part of the parameter value
+ * @param parameter_imag
+ *     pointer to double to return imaginary part of the parameter value. Ignored
+ *     for real-valued parameters (i.e. you may pass a null pointer)
+ * @return
+ *     UMAMI_SUCCESS on success, error code otherwise
+ */
+UmamiStatus umami_get_parameter(
+    UmamiHandle handle, char const* name, double* parameter_real, double* parameter_imag
+);
+
+/**
+ * Evaluates the matrix element as a function of the given inputs, filling the
+ * requested outputs. Unless otherwise specified, all inputs and outputs have a
+ * column-major memory layout and have a batch dimension that is contiguous in memory.
+ *
+ * @param handle
+ *     handle of a matrix element instance
+ * @param count
+ *     number of events to evaluate the matrix element for
+ * @param stride
+ *     stride of the batch dimension of the input and output arrays to simplify
+ *     parallel execution on CPUs, see memory layout
+ * @param offset
+ *     offset of the event index
+ * @param input_count
+ *     number of inputs to the matrix element
+ * @param input_keys
+ *     pointer to an array of input keys, length `input_count`
+ * @param inputs
+ *     pointer to an array of void pointers to the inputs. The type of the inputs
+ *     depends on the input key
+ * @param output_count
+ *     number of outputs to the matrix element
+ * @param output_keys
+ *     pointer to an array of output keys, length `output_count`
+ * @param outputs
+ *     pointer to an array of void pointers to the outputs. The type of the outputs
+ *     depends on the output key. The caller is responsible for allocating memory for
+ *     the outputs.
+ * @return
+ *     UMAMI_SUCCESS on success, error code otherwise
+ */
+UmamiStatus umami_matrix_element(
+    UmamiHandle handle,
+    size_t count,
+    size_t stride,
+    size_t offset,
+    size_t input_count,
+    UmamiInputKey const* input_keys,
+    void const* const* inputs,
+    size_t output_count,
+    UmamiOutputKey const* output_keys,
+    void* const* outputs
+);
+
+/**
+ * Frees matrix element instance
+ *
+ * @param handle
+ *     handle of a matrix element instance
+ */
+UmamiStatus umami_free(UmamiHandle handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UMAMI_HEADER
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami_driver.c b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami_driver.c
new file mode 100644
index 0000000000..9a37dc217f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami_driver.c
@@ -0,0 +1,93 @@
+/* SPDX-License-Identifier: 0BSD */
+/* A normal linked executable: no dlopen, Python, or direct Rusticol linkage. */
+#include "umami.h"
+#include "umami_provider.h"
+#include <errno.h>
+#include <limits.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef UMAMI_PROVIDER_HEADER
+#define UMAMI_PROVIDER_HEADER "provider_p0.h"
+#endif
+#include UMAMI_PROVIDER_HEADER
+
+static void check(UmamiStatus status, char const *operation) {
+    if (status != UMAMI_SUCCESS) {
+        fprintf(stderr, "umami_driver: %s failed (status %d)\n", operation, status);
+        exit(EXIT_FAILURE);
+    }
+}
+
+static unsigned int index_argument(char const *text) {
+    char *end = NULL;
+    errno = 0;
+    unsigned long value = strtoul(text, &end, 10);
+    if (errno || text == end || *end || text[0] == '-' || value > INT_MAX) {
+        fprintf(stderr, "invalid channel/flavour index: %s\n", text);
+        exit(EXIT_FAILURE);
+    }
+    return (unsigned int)value;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2 || argc > 4) {
+        fprintf(stderr, "usage: %s ABSOLUTE_ARTIFACT [CHANNEL [FLAVOUR]]\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+    unsigned int channel = argc > 2 ? index_argument(argv[2]) : 0;
+    int flavour = argc > 3 ? (int)index_argument(argv[3]) : 0;
+    if (channel >= umami_provider.channel_count ||
+        (size_t)flavour >= umami_provider.channels[channel].flavour_count) {
+        fputs("channel/flavour out of range\n", stderr); return EXIT_FAILURE;
+    }
+    UmamiContribution const *entry = &umami_provider.channels[channel].flavours[flavour].contributions[0];
+    char const *process = umami_provider.processes[entry->process_index].key;
+    int n = 0;
+    check(umami_get_meta(UMAMI_META_PARTICLE_COUNT, &n), "particle count");
+    double *point = calloc((size_t)n * 4, sizeof(double));
+    double *momenta = calloc((size_t)n * 4, sizeof(double));
+    size_t path_length = strlen(argv[1]) + sizeof("/API/validation_points.dat");
+    char *path = malloc(path_length);
+    if (point == NULL || momenta == NULL || path == NULL) return EXIT_FAILURE;
+    snprintf(path, path_length, "%s/API/validation_points.dat", argv[1]);
+    FILE *file = fopen(path, "r");
+    if (file == NULL) { perror(path); return EXIT_FAILURE; }
+    char name[256];
+    if (fscanf(file, "%255s", name) != 1 || strcmp(name, "RUSTICOL_VALIDATION_POINTS_V1")) {
+        fputs("invalid validation-point file\n", stderr); return EXIT_FAILURE;
+    }
+    bool found = false;
+    size_t particles;
+    while (fscanf(file, "%255s %zu", name, &particles) == 2) {
+        bool selected = strcmp(name, process) == 0 && particles == (size_t)n;
+        for (size_t j = 0; j < particles * 4; ++j) {
+            double value;
+            if (fscanf(file, "%lf", &value) != 1) return EXIT_FAILURE;
+            if (selected) point[j] = value;
+        }
+        if (selected) { found = true; break; }
+    }
+    fclose(file); free(path);
+    if (!found) { fprintf(stderr, "no saved point for %s\n", process); return EXIT_FAILURE; }
+    for (size_t j = 0; j < (size_t)n; ++j)
+        for (size_t k = 0; k < 4; ++k)
+            momenta[(size_t)n*k + entry->permutation[j]] = point[4*j+k];
+    UmamiHandle handle = NULL;
+    check(umami_initialize(&handle, argv[1]), "initialize");
+    double value = NAN, random = 0.5;
+    int helicity = -1;
+    UmamiInputKey input_keys[] = {UMAMI_IN_MOMENTA, UMAMI_IN_CHANNEL_INDEX,
+                                  UMAMI_IN_FLAVOR_INDEX, UMAMI_IN_RANDOM_HELICITY};
+    void const *inputs[] = {momenta, &channel, &flavour, &random};
+    UmamiOutputKey output_keys[] = {UMAMI_OUT_MATRIX_ELEMENT, UMAMI_OUT_HELICITY_INDEX};
+    void *outputs[] = {&value, &helicity};
+    check(umami_matrix_element(handle, 1, 1, 0, 4, input_keys, inputs, 2, output_keys, outputs), "evaluate");
+    check(umami_free(handle), "free");
+    free(point); free(momenta);
+    if (!isfinite(value)) return EXIT_FAILURE;
+    printf("{\"provider\":\"%s\",\"channel\":%u,\"flavour\":%d,\"matrix_element\":%.17g,\"helicity_label\":%d}\n",
+           umami_provider.id, channel, flavour, value, helicity);
+    return EXIT_SUCCESS;
+}
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami_provider.h b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami_provider.h
new file mode 100644
index 0000000000..bbffa09da4
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami_provider.h
@@ -0,0 +1,59 @@
+/* SPDX-License-Identifier: 0BSD */
+#ifndef PYAMPLICOL_UMAMI_PROVIDER_H
+#define PYAMPLICOL_UMAMI_PROVIDER_H
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct {
+    const char *name;
+    double real, imaginary;
+    bool mutable, is_complex;
+} UmamiParameter;
+
+typedef struct {
+    const char *key;
+    const int *pdgs;
+    const char *alpha_s_name;
+    const char *color_accuracy;
+    size_t helicity_count;
+    const char *const *helicity_ids;
+    size_t parameter_count;
+    const UmamiParameter *parameters;
+} UmamiProcess;
+
+typedef struct {
+    size_t process_index;
+    const char *color_id;
+    size_t color_index;
+    /* runtime[j] = input[permutation[j]], including both incoming legs. */
+    const size_t *permutation;
+    double factor;
+    /* Exported helicity index (input leg order) -> runtime index, -1 if absent. */
+    const int *helicity_runtime;
+    /* Runtime helicity index -> exported helicity index. */
+    const size_t *helicity_export;
+} UmamiContribution;
+
+typedef struct {
+    size_t contribution_count;
+    const UmamiContribution *contributions;
+} UmamiFlavour;
+
+typedef struct {
+    size_t flavour_count;
+    const UmamiFlavour *flavours;
+} UmamiChannel;
+
+typedef struct {
+    const char *id;
+    size_t particle_count, incoming_count, helicity_count, color_count;
+    /* Number of exported helicities, the metadata "helicities" table. */
+    size_t exported_helicity_count;
+    const double *masses;
+    size_t process_count;
+    const UmamiProcess *processes;
+    size_t channel_count;
+    const UmamiChannel *channels;
+    bool supports_alpha_s;
+} UmamiProvider;
+#endif
diff --git a/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami_reweight.c b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami_reweight.c
new file mode 100644
index 0000000000..7719348f8d
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/api_templates/umami/umami_reweight.c
@@ -0,0 +1,367 @@
+/* SPDX-License-Identifier: 0BSD */
+/* UMAMI provider of the ratio of a target-accuracy matrix element (e.g. full colour)
+ * to the leading-colour one summed over all colour flows, at a fixed helicity. */
+#include "umami.h"
+#include "reweight_provider.h"
+#include <rusticol.h>
+#include <limits.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#ifndef UMAMI_REWEIGHT_HEADER
+#define UMAMI_REWEIGHT_HEADER "reweight_p0.h"
+#endif
+#include UMAMI_REWEIGHT_HEADER
+
+typedef struct {
+    char *name;
+    double real, imaginary;
+} Override;
+
+typedef struct {
+    char *base;
+    RusticolRuntimeHandle **reference, **target;
+    double *momenta;
+    /* Parameters set so far, applied to the processes loaded later. */
+    Override *overrides;
+    size_t override_count;
+} Instance;
+
+static bool const supported_inputs[UMAMI_INPUT_KEY_COUNT] = {
+    [UMAMI_IN_MOMENTA] = true,
+    [UMAMI_IN_ALPHA_S] = UMAMI_HAS_ALPHA_S,
+    [UMAMI_IN_FLAVOR_INDEX] = true,
+    [UMAMI_IN_HELICITY_INDEX] = true,
+    [UMAMI_IN_CHANNEL_INDEX] = true,
+};
+static bool const required_inputs[UMAMI_INPUT_KEY_COUNT] = {
+    [UMAMI_IN_MOMENTA] = true,
+    [UMAMI_IN_HELICITY_INDEX] = true,
+};
+static bool const supported_outputs[UMAMI_OUTPUT_KEY_COUNT] = {
+    [UMAMI_OUT_MATRIX_ELEMENT_RATIO] = true,
+};
+
+static UmamiStatus native_error(int status) {
+    if (status == RUSTICOL_STATUS_OK) return UMAMI_SUCCESS;
+    char message[1024];
+    size_t required = 0;
+    if (rusticol_last_error_message(message, sizeof(message), &required) ==
+        RUSTICOL_STATUS_OK) fprintf(stderr, "umami: %s\n", message);
+    return UMAMI_ERROR;
+}
+
+static UmamiStatus load(char const *base, char const *relative, char const *identity,
+                        ReweightProcess const *process, RusticolRuntimeHandle **result) {
+    size_t length = strlen(base) + strlen(relative) + 2;
+    char *path = malloc(length);
+    if (path == NULL) return UMAMI_ERROR;
+    snprintf(path, length, "%s/%s", base, relative);
+    RusticolRuntimeHandle *runtime = NULL;
+    int status = rusticol_runtime_load(path, process->key, NULL, &runtime);
+    free(path);
+    if (status != RUSTICOL_STATUS_OK) return native_error(status);
+    size_t count = 0, required = 0;
+    status = rusticol_runtime_external_count(runtime, &count);
+    bool compatible = status == RUSTICOL_STATUS_OK && count == reweight_provider.particle_count;
+    for (size_t j = 0; compatible && j < count; ++j) {
+        int32_t pdg = 0;
+        status = rusticol_runtime_external_pdg(runtime, j, &pdg);
+        compatible = status == RUSTICOL_STATUS_OK && pdg == process->pdgs[j];
+    }
+    if (compatible) {
+        status = rusticol_runtime_helicity_count(runtime, &count);
+        compatible = status == RUSTICOL_STATUS_OK && count == process->helicity_count;
+    }
+    if (compatible && identity != NULL) {
+        char *loaded = malloc(strlen(identity) + 1);
+        compatible = loaded != NULL && rusticol_runtime_artifact_id(
+            runtime, loaded, strlen(identity) + 1, &required) == RUSTICOL_STATUS_OK &&
+            strcmp(loaded, identity) == 0;
+        free(loaded);
+    }
+    if (!compatible) {
+        (void)rusticol_runtime_free(runtime);
+        fprintf(stderr, "umami: artifact %s is incompatible with reweight provider %s\n",
+                relative, reweight_provider.id);
+        return UMAMI_ERROR;
+    }
+    *result = runtime;
+    return UMAMI_SUCCESS;
+}
+
+/* Loads a reference (side 0) or target process on first use, with the parameters set. */
+static UmamiStatus ensure_loaded(Instance *instance, int side, size_t index) {
+    RusticolRuntimeHandle **slot =
+        side == 0 ? &instance->reference[index] : &instance->target[index];
+    if (*slot != NULL) return UMAMI_SUCCESS;
+    RusticolRuntimeHandle *runtime = NULL;
+    UmamiStatus status = side == 0
+        ? load(instance->base, reweight_provider.reference_artifact,
+               reweight_provider.reference_artifact_id,
+               &reweight_provider.reference_processes[index], &runtime)
+        : load(instance->base, reweight_provider.target_artifact,
+               reweight_provider.target_artifact_id,
+               &reweight_provider.target_processes[index], &runtime);
+    if (status != UMAMI_SUCCESS) return status;
+    for (size_t i = 0; i < instance->override_count; ++i) {
+        Override const *override = &instance->overrides[i];
+        double re = 0.0, im = 0.0;
+        if (rusticol_runtime_get_model_parameter(runtime, override->name, &re, &im) !=
+            RUSTICOL_STATUS_OK) continue;
+        status = native_error(rusticol_runtime_set_model_parameter(
+            runtime, override->name, override->real, override->imaginary));
+        if (status != UMAMI_SUCCESS) { (void)rusticol_runtime_free(runtime); return status; }
+    }
+    *slot = runtime;
+    return UMAMI_SUCCESS;
+}
+
+static UmamiStatus record_override(Instance *instance, char const *name,
+                                   double real, double imaginary) {
+    for (size_t i = 0; i < instance->override_count; ++i)
+        if (strcmp(instance->overrides[i].name, name) == 0) {
+            instance->overrides[i].real = real;
+            instance->overrides[i].imaginary = imaginary;
+            return UMAMI_SUCCESS;
+        }
+    Override *overrides = realloc(instance->overrides,
+                                  (instance->override_count + 1) * sizeof(*overrides));
+    if (overrides == NULL) return UMAMI_ERROR;
+    instance->overrides = overrides;
+    char *copy = malloc(strlen(name) + 1);
+    if (copy == NULL) return UMAMI_ERROR;
+    strcpy(copy, name);
+    overrides[instance->override_count++] = (Override){copy, real, imaginary};
+    return UMAMI_SUCCESS;
+}
+
+UmamiStatus umami_get_meta(UmamiMetaKey key, void *result) {
+    if (result == NULL) return UMAMI_ERROR;
+    switch (key) {
+    case UMAMI_META_DEVICE: *(UmamiDevice *)result = UMAMI_DEVICE_CPU; break;
+    case UMAMI_META_PARTICLE_COUNT: *(int *)result = (int)reweight_provider.particle_count; break;
+    case UMAMI_META_HELICITY_COUNT:
+        *(int *)result = (int)reweight_provider.exported_helicity_count; break;
+    default: return UMAMI_ERROR_UNSUPPORTED_META;
+    }
+    return UMAMI_SUCCESS;
+}
+
+UmamiStatus umami_supported_inputs(bool const **supported, int *count) {
+    if (supported == NULL || count == NULL) return UMAMI_ERROR;
+    *supported = supported_inputs; *count = UMAMI_INPUT_KEY_COUNT;
+    return UMAMI_SUCCESS;
+}
+UmamiStatus umami_required_inputs(bool const **required, int *count) {
+    if (required == NULL || count == NULL) return UMAMI_ERROR;
+    *required = required_inputs; *count = UMAMI_INPUT_KEY_COUNT;
+    return UMAMI_SUCCESS;
+}
+UmamiStatus umami_supported_outputs(bool const **supported, int *count) {
+    if (supported == NULL || count == NULL) return UMAMI_ERROR;
+    *supported = supported_outputs; *count = UMAMI_OUTPUT_KEY_COUNT;
+    return UMAMI_SUCCESS;
+}
+
+UmamiStatus umami_initialize(UmamiHandle *handle, char const *param_card_path) {
+    if (handle == NULL) return UMAMI_ERROR;
+    *handle = NULL;
+    struct stat info;
+    if (param_card_path == NULL || param_card_path[0] != '/' ||
+        stat(param_card_path, &info) != 0 || !S_ISDIR(info.st_mode) ||
+        reweight_provider.particle_count > INT_MAX) return UMAMI_ERROR;
+    Instance *instance = calloc(1, sizeof(*instance));
+    if (instance == NULL) return UMAMI_ERROR;
+    instance->reference = calloc(reweight_provider.reference_process_count + 1,
+                                 sizeof(*instance->reference));
+    instance->target = calloc(reweight_provider.target_process_count + 1,
+                              sizeof(*instance->target));
+    instance->momenta = calloc(4 * reweight_provider.particle_count, sizeof(double));
+    instance->base = malloc(strlen(param_card_path) + 1);
+    if (instance->reference == NULL || instance->target == NULL || instance->momenta == NULL ||
+        instance->base == NULL || reweight_provider.reference_process_count == 0 ||
+        reweight_provider.target_process_count == 0) {
+        umami_free(instance); return UMAMI_ERROR;
+    }
+    strcpy(instance->base, param_card_path);
+    /* Validate both artifacts now; other processes are loaded lazily on first use. */
+    for (int side = 0; side < 2; ++side) {
+        UmamiStatus status = ensure_loaded(instance, side, 0);
+        if (status != UMAMI_SUCCESS) { umami_free(instance); return status; }
+    }
+    *handle = instance;
+    return UMAMI_SUCCESS;
+}
+
+/* Runs body for every loaded runtime, reference ones first. */
+#define FOR_EACH_RUNTIME(instance, runtime, body) \
+    for (size_t side = 0; side < 2; ++side) { \
+        size_t count = side == 0 ? reweight_provider.reference_process_count \
+                                 : reweight_provider.target_process_count; \
+        for (size_t i = 0; i < count; ++i) { \
+            RusticolRuntimeHandle *runtime = \
+                side == 0 ? (instance)->reference[i] : (instance)->target[i]; \
+            if (runtime == NULL) continue; \
+            body \
+        } \
+    }
+
+UmamiStatus umami_get_parameter(UmamiHandle handle, char const *name,
+                              double *real, double *imaginary) {
+    if (handle == NULL || name == NULL || real == NULL) return UMAMI_ERROR;
+    Instance *instance = handle;
+    double re = 0.0, im = 0.0;
+    FOR_EACH_RUNTIME(instance, runtime, {
+        if (rusticol_runtime_get_model_parameter(runtime, name, &re, &im) ==
+            RUSTICOL_STATUS_OK) {
+            *real = re;
+            if (imaginary != NULL) *imaginary = im;
+            return UMAMI_SUCCESS;
+        }
+    })
+    return UMAMI_ERROR;
+}
+
+UmamiStatus umami_set_parameter(UmamiHandle handle, char const *name,
+                              double real, double imaginary) {
+    if (handle == NULL || name == NULL || !isfinite(real)) return UMAMI_ERROR;
+    Instance *instance = handle;
+    bool found = false;
+    double re = 0.0, im = 0.0;
+    FOR_EACH_RUNTIME(instance, runtime, {
+        if (rusticol_runtime_get_model_parameter(runtime, name, &re, &im) !=
+            RUSTICOL_STATUS_OK) continue;
+        found = true;
+        if (native_error(rusticol_runtime_set_model_parameter(runtime, name, real, imaginary)) !=
+            UMAMI_SUCCESS) return UMAMI_ERROR;
+    })
+    if (!found) return UMAMI_ERROR;
+    return record_override(instance, name, real, imaginary);
+}
+
+/* Value of one process at a fixed runtime helicity, with an optional alpha_s. */
+static UmamiStatus evaluate(Instance *instance, RusticolRuntimeHandle *runtime,
+                            ReweightProcess const *process, uint32_t helicity,
+                            double const *alpha_s, double *result) {
+    size_t n = reweight_provider.particle_count;
+    double previous_real = 0.0, previous_imaginary = 0.0;
+    bool changed = false;
+    UmamiStatus status;
+    if (alpha_s != NULL) {
+        if (process->alpha_s_name == NULL) return UMAMI_ERROR_UNSUPPORTED_INPUT;
+        status = native_error(rusticol_runtime_get_model_parameter(
+            runtime, process->alpha_s_name, &previous_real, &previous_imaginary));
+        if (status != UMAMI_SUCCESS) return status;
+        changed = previous_real != *alpha_s || previous_imaginary != 0.0;
+        if (changed) {
+            status = native_error(rusticol_runtime_set_model_parameter(
+                runtime, process->alpha_s_name, *alpha_s, 0.0));
+            if (status != UMAMI_SUCCESS) return status;
+        }
+    }
+    status = native_error(rusticol_runtime_evaluate_selected_f64(
+        runtime, instance->momenta, 4*n, 1, NULL, 0, NULL, 0,
+        &helicity, 1, NULL, 0, result, 1));
+    if (changed) {
+        UmamiStatus restored = native_error(rusticol_runtime_set_model_parameter(
+            runtime, process->alpha_s_name, previous_real, previous_imaginary));
+        if (restored != UMAMI_SUCCESS) return restored;
+    }
+    return status;
+}
+
+UmamiStatus umami_matrix_element(UmamiHandle handle, size_t count, size_t stride, size_t offset,
+    size_t input_count, UmamiInputKey const *input_keys, void const *const *inputs,
+    size_t output_count, UmamiOutputKey const *output_keys, void *const *outputs) {
+    if (handle == NULL || offset > stride || count > stride-offset ||
+        (input_count && (input_keys == NULL || inputs == NULL)) ||
+        (output_count && (output_keys == NULL || outputs == NULL)) ||
+        (stride && reweight_provider.particle_count > SIZE_MAX / stride / 4)) return UMAMI_ERROR;
+    void const *in[UMAMI_INPUT_KEY_COUNT] = {0};
+    void *out[UMAMI_OUTPUT_KEY_COUNT] = {0};
+    for (size_t i = 0; i < input_count; ++i) {
+        int key = input_keys[i];
+        if (key < 0 || key >= UMAMI_INPUT_KEY_COUNT || !supported_inputs[key])
+            return UMAMI_ERROR_UNSUPPORTED_INPUT;
+        if (inputs[i] == NULL || in[key] != NULL) return UMAMI_ERROR;
+        in[key] = inputs[i];
+    }
+    for (size_t i = 0; i < output_count; ++i) {
+        int key = output_keys[i];
+        if (key < 0 || key >= UMAMI_OUTPUT_KEY_COUNT || !supported_outputs[key])
+            return UMAMI_ERROR_UNSUPPORTED_OUTPUT;
+        if (outputs[i] == NULL || out[key] != NULL) return UMAMI_ERROR;
+        out[key] = outputs[i];
+    }
+    if (count == 0) return UMAMI_SUCCESS;
+    if (in[UMAMI_IN_MOMENTA] == NULL || in[UMAMI_IN_HELICITY_INDEX] == NULL)
+        return UMAMI_ERROR_MISSING_INPUT;
+    Instance *instance = handle;
+    double const *momenta = in[UMAMI_IN_MOMENTA];
+    size_t n = reweight_provider.particle_count;
+    for (size_t event = offset; event < offset+count; ++event) {
+        size_t channel = in[UMAMI_IN_CHANNEL_INDEX] ?
+            ((unsigned int const *)in[UMAMI_IN_CHANNEL_INDEX])[event] : 0;
+        int flavour = in[UMAMI_IN_FLAVOR_INDEX] ?
+            ((int const *)in[UMAMI_IN_FLAVOR_INDEX])[event] : 0;
+        int helicity = ((int const *)in[UMAMI_IN_HELICITY_INDEX])[event];
+        if (channel >= reweight_provider.channel_count || flavour < 0 ||
+            (size_t)flavour >= reweight_provider.channels[channel].flavour_count ||
+            helicity < 0 || (size_t)helicity >= reweight_provider.exported_helicity_count)
+            return UMAMI_ERROR;
+        ReweightFlavour const *entry = &reweight_provider.channels[channel].flavours[flavour];
+        for (size_t j = 0; j < n; ++j)
+            for (size_t k = 0; k < 4; ++k) {
+                double value = momenta[event + stride * (n*k + entry->permutation[j])];
+                if (!isfinite(value)) return UMAMI_ERROR;
+                instance->momenta[4*j+k] = value;
+            }
+        double const *alpha_s =
+            in[UMAMI_IN_ALPHA_S] ? &((double const *)in[UMAMI_IN_ALPHA_S])[event] : NULL;
+        int reference_helicity = entry->reference_helicity[helicity];
+        int target_helicity = entry->target_helicity[helicity];
+        double reference = 0.0, target = 0.0;
+        if ((reference_helicity >= 0 &&
+             ensure_loaded(instance, 0, entry->reference_process) != UMAMI_SUCCESS) ||
+            (target_helicity >= 0 &&
+             ensure_loaded(instance, 1, entry->target_process) != UMAMI_SUCCESS))
+            return UMAMI_ERROR;
+        if (reference_helicity >= 0) {
+            UmamiStatus status = evaluate(instance, instance->reference[entry->reference_process],
+                &reweight_provider.reference_processes[entry->reference_process],
+                (uint32_t)reference_helicity, alpha_s, &reference);
+            if (status != UMAMI_SUCCESS) return status;
+        }
+        if (target_helicity >= 0) {
+            UmamiStatus status = evaluate(instance, instance->target[entry->target_process],
+                &reweight_provider.target_processes[entry->target_process],
+                (uint32_t)target_helicity, alpha_s, &target);
+            if (status != UMAMI_SUCCESS) return status;
+        }
+        double ratio = reference != 0.0 ? target / reference : 0.0;
+        if (!isfinite(ratio)) return UMAMI_ERROR;
+        if (out[UMAMI_OUT_MATRIX_ELEMENT_RATIO])
+            ((double *)out[UMAMI_OUT_MATRIX_ELEMENT_RATIO])[event] = ratio;
+    }
+    return UMAMI_SUCCESS;
+}
+
+UmamiStatus umami_free(UmamiHandle handle) {
+    if (handle == NULL) return UMAMI_SUCCESS;
+    Instance *instance = handle;
+    if (instance->reference != NULL)
+        for (size_t i = 0; i < reweight_provider.reference_process_count; ++i)
+            if (instance->reference[i] != NULL) (void)rusticol_runtime_free(instance->reference[i]);
+    if (instance->target != NULL)
+        for (size_t i = 0; i < reweight_provider.target_process_count; ++i)
+            if (instance->target[i] != NULL) (void)rusticol_runtime_free(instance->target[i]);
+    for (size_t i = 0; i < instance->override_count; ++i) free(instance->overrides[i].name);
+    free(instance->overrides); free(instance->base);
+    free(instance->reference); free(instance->target); free(instance->momenta); free(instance);
+    return UMAMI_SUCCESS;
+}
diff --git a/pyamplicol/src/pyamplicol/assets/models/MANIFEST.sha256 b/pyamplicol/src/pyamplicol/assets/models/MANIFEST.sha256
new file mode 100644
index 0000000000..7842e0453c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/MANIFEST.sha256
@@ -0,0 +1,67 @@
+72b500a47f53fba22d7563263b27eb51906d035b6fd96f9130b327e70542ab88  PROVENANCE.toml
+78e536276cfa98a854ea9b418a6de9437da1e21ea258fcc57ba2b20a6a691900  json/scalar_gravity/restrict_default.json
+3bfc81548466ffc464fa72a3469a9c0c8930970bf048c64c43aee13c8e83bd72  json/scalar_gravity/scalar_gravity.json
+ffe7759b8efcc86e6d12d3797c2e63a91c18c07de1bace6a51ee02144ecbf218  json/scalars/restrict_default.json
+ca27b8cc228cd03db57556fc1c40298865a75269bf2744bee8c59c013eb28df7  json/scalars/scalars.json
+0a268a9fc959036e166367155ab2eeca5c52f76927a89245f8964b9b33b2a8b5  json/scalars/scalars_2p_3p.json
+014e93a779812d9af1d3886143cebc8fd911e92f5f970aee4dfffe01429651f5  json/sm/restrict_c_mass.json
+be8bdca54507167d8ae4b33d0b0b77808052cd841d6fabd26a3d99926d915b99  json/sm/restrict_ckm.json
+8fdd48a3624620c1a15bab602f43a41519038cf69d8fef6aeaaaf13a3f1846c1  json/sm/restrict_default.json
+3d9fe3095907cef03f889bd95b9630a2f836d70244f1b450cfd5d2764913531b  json/sm/restrict_lepton_masses.json
+82d2fbc06f9d0b7daaed56673912d920ca459f435e9083deed2f4b716c2f4a30  json/sm/restrict_no_b_mass.json
+f925921df1b66f010cd6f8cd348b5f4728ba37678e0733d8618cef3f2b4e610e  json/sm/restrict_no_masses.json
+a26603f4f3572309dc7ce2f23295d5a8aec61d2f3c42a017341245e459648478  json/sm/restrict_no_tau_mass.json
+fdc03507f82a3d98571b97ba0ab34f712dc0eb02b101f8308b96c6ab8490c08c  json/sm/restrict_no_widths.json
+b8b4376c82f9486266283a383a0347ec42498296180d92249e2e7a772e1a7e1a  json/sm/restrict_zeromass_ckm.json
+c1222e3b70b71804e5212e994a3b76e2f098f7fc3ba1693c9f9c65578d7e3e00  json/sm/sm.json
+e1ee0059f3fc534c462e98c358249acbce0a711171fcbfe41720a9a1f24b2933  json/sm/sm_wrapped_indices.json
+baf7043f1586a6b70546d04019b11c3fc17f181f278d5d33a70b7217b5e0db71  ufo/scalar_gravity/__init__.py
+63738137e1355e064968615a500ecd195395af6f8dea4fd4efee541b47dc7f27  ufo/scalar_gravity/coupling_orders.py
+afd07d76eaefaf4828a243eb63c88196f11da1fcbea59f873c1e3832fbc276fb  ufo/scalar_gravity/couplings.py
+7ab870cbfebbca3858ab8d6780d138b4b2531f6e2be84ff2cf4e6362b6c601bd  ufo/scalar_gravity/function_library.py
+28e38a5a20aee6e02605fc2dc2d2e850b05edc1ade5f343fc2ef780ba9666e42  ufo/scalar_gravity/lorentz.py
+5db44f44bdc8df1ada2c76bd02d5f9241298d0187b963c0d2ee39b88e3910cb3  ufo/scalar_gravity/object_library.py
+ed708e1744af39117e364be9f8c2f9c7fa844781701a3fb419cff95a8b427dd7  ufo/scalar_gravity/param_card.dat
+01b0477e0b0e352f968a6d1bfd1e9724c505adc6dd5c1d39dd08e9da97cd9f00  ufo/scalar_gravity/parameters.py
+90b4efa5fd4c8eb443c43a3a8d7109add2fae94807670098195d6024acd91bd5  ufo/scalar_gravity/particles.py
+ed708e1744af39117e364be9f8c2f9c7fa844781701a3fb419cff95a8b427dd7  ufo/scalar_gravity/restrict_default.dat
+0005fc634dd25e095ad70ee49b1789736e6ed31a428794866fea279585a7fbd0  ufo/scalar_gravity/restrict_full.dat
+d45878face2f212eaed32932e36ffcaf33e643db347c44d074657292805b47a0  ufo/scalar_gravity/run_write_param_card.py
+4c7d261c81d15242c09cd12403fe8d32a5d41fefc4136e726d5e934d9358e9be  ufo/scalar_gravity/vertices.py
+3008b3269d0689370523a4a6dbcdd4100bb7d78599e2f3df79127ead6fe7fc75  ufo/scalar_gravity/write_param_card.py
+baf7043f1586a6b70546d04019b11c3fc17f181f278d5d33a70b7217b5e0db71  ufo/scalars/__init__.py
+2e691ad2042a4a7edde293fe69ba96f54ec08221061db0ed1dc30f588011504e  ufo/scalars/coupling_orders.py
+325cfc644fe3b86cffd8de916c3f285016d70fe673d50f3c5ca1c7dcdfaa4183  ufo/scalars/couplings.py
+7ab870cbfebbca3858ab8d6780d138b4b2531f6e2be84ff2cf4e6362b6c601bd  ufo/scalars/function_library.py
+3daaf714d13328419366cc5c9b6a490d6cd9cff8ace604bf2ec0915061e5b736  ufo/scalars/lorentz.py
+5db44f44bdc8df1ada2c76bd02d5f9241298d0187b963c0d2ee39b88e3910cb3  ufo/scalars/object_library.py
+7b11a9b1d84126d31f58d5c4752ea0fe0921074bfcb338ecd6ef4d2ad7da89a7  ufo/scalars/parameters.py
+1e346940ecf9746445db47219256cc4739444b111f3a2a96967bbb890b57e310  ufo/scalars/particles.py
+020178e9df8fe242fd4d34077db4caff694959a7c6d7a5c829527f8de4e1c80f  ufo/scalars/restrict_default.dat
+0005fc634dd25e095ad70ee49b1789736e6ed31a428794866fea279585a7fbd0  ufo/scalars/restrict_full.dat
+d45878face2f212eaed32932e36ffcaf33e643db347c44d074657292805b47a0  ufo/scalars/run_write_param_card.py
+1341725ef6b4bf5eb7ff5fa09d633c1cb52e89b695c627ae42c2ca5664525d4f  ufo/scalars/vertices.py
+3008b3269d0689370523a4a6dbcdd4100bb7d78599e2f3df79127ead6fe7fc75  ufo/scalars/write_param_card.py
+dcefb2fa6a4b1653d87944a11dfaedf1b5a2c0a5b27d2370685c2e21d157a568  ufo/sm/__init__.py
+de21ae72ae23f8409d077599f0e4fabbab5287373e3930bc34a19adacd60781e  ufo/sm/build_restrict.py
+cb45f17e973165af72af7f5fabe368306919b00d8421745c79807b5fda1bdace  ufo/sm/coupling_orders.py
+a5d30cec4efec54b637b5a2ce8017b54fa78f16c546afe33e7410a0279bf979c  ufo/sm/couplings.py
+12b9bc8544b01e248087f197c2dc9137d274f980178bc72f67d130fb149007a2  ufo/sm/decays.py
+a8821ed8a739e43b705ff7c7aa7d93ff545071b0fe020f5c0c8b0799c30ef2ae  ufo/sm/function_library.py
+1f13e8b63e2ecf428e2875e14bc6901ce49952e1cf2b18ea9934c8d4264e3559  ufo/sm/lorentz.py
+6391978031caea837ecea426f2f0cfdac748457a00bac99e02c025c42e883cb5  ufo/sm/object_library.py
+e8599a97d31004d7af8c589a5e734c9141b48d9becdbbde86a37e41635390e38  ufo/sm/parameters.py
+9b542b5d49598ade4d9d6897d569e8feeaa05993e74aef67fb5dfafd5efa9916  ufo/sm/particles.py
+817a7843a1435c1c7b1f0231ababc346e58f81d8038b9c0b2c75eae32960da9e  ufo/sm/restrict_c_mass.dat
+75fd361e4ce78100b7dd107cd42b1015d9303da44bec8971e401c2d20d7876cb  ufo/sm/restrict_ckm.dat
+988939a63e2d35ca991bac864b8f10f6ee19fd13063cb68e91af962767974889  ufo/sm/restrict_default.dat
+f1e023d45808db115385e5707640a3a3e126217840067a14200e995181eba151  ufo/sm/restrict_full.dat
+eb44e12f6f4ee591e76277322359e31f4a577a9200acd6c5c8dc6629a039e8c8  ufo/sm/restrict_lepton_masses.dat
+32dc93b5584b7bdbf24e87ce12d55398cc2d865e0240ccf6e853c2ade1f90e9e  ufo/sm/restrict_no_b_mass.dat
+539664a3651839946cc995257bd9e108054c789f5352ecc0e562260798e66bf0  ufo/sm/restrict_no_masses.dat
+52433bb4161af5a0f17c91964fdd695b155c0c9821eda37142f04a1b1c2e57f8  ufo/sm/restrict_no_tau_mass.dat
+0ab8569ed8e747b0c0c0ee2c2c93db1e368489237baf8430c53eef605a1634e8  ufo/sm/restrict_no_widths.dat
+2388cf490afcfb5530f49ae3a85fec235be236e33c4bb5e1515f3d4827b963c6  ufo/sm/restrict_zeromass_ckm.dat
+d45878face2f212eaed32932e36ffcaf33e643db347c44d074657292805b47a0  ufo/sm/run_write_param_card.py
+6f3353b483e6a3f7c6b9f5e79d3a818af8e933ec63f96c18ed271760f6492c68  ufo/sm/vertices.py
+9a289a0f17edaaa0609ccd7d83db3b2d4b389e51f07a0f0c47ffce77afb18c03  ufo/sm/write_param_card.py
diff --git a/pyamplicol/src/pyamplicol/assets/models/PROVENANCE.toml b/pyamplicol/src/pyamplicol/assets/models/PROVENANCE.toml
new file mode 100644
index 0000000000..5ec6b003c0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/PROVENANCE.toml
@@ -0,0 +1,1140 @@
+# SPDX-License-Identifier: 0BSD
+schema_version = 1
+manifest = "MANIFEST.sha256"
+canonical_root = "pyamplicol/assets/models"
+release_status = "eligible"
+selection_policy = "Git blobs under the baseline package asset tree only; the duplicate top-level tree and working-tree generated files are excluded"
+baseline_tracked_file_count = 67
+baseline_payload_file_count = 66
+[[licenses]]
+id = "0BSD"
+path = "LICENSE"
+applies_to = "pyAmpliCol-owned built-in and scalar model material"
+
+[[licenses]]
+id = "GammaLoop-model-assets"
+path = "licenses/GammaLoop-model-assets.txt"
+applies_to = "UFO and derived JSON model assets distributed with GammaLoop"
+
+[[licenses]]
+id = "MadGraph5-aMCatNLO"
+path = "licenses/MadGraph5_aMCatNLO.txt"
+applies_to = "ufo/sm/build_restrict.py"
+
+[[licenses]]
+id = "MIT"
+path = "licenses/ufo-model-loader.txt"
+applies_to = "serialization tool; generated JSON retains source-model terms"
+
+[[models]]
+id = "built-in-sm"
+format = "python"
+canonical_package_path = "pyamplicol/models/builtin/__init__.py"
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/model.py"
+source_sha256 = "7b3bac9e53193260bf9c2829ef972f87d23246e93dc57f208bda4821195b7ad3"
+companion_source_path = "pyAmpliCol/src/pyamplicol/symbols.py"
+companion_source_sha256 = "265178a9b8960c8176decbc92000b47c778e9c993851cc76f067d4cb8e0c6d62"
+license_ids = [ "0BSD",]
+release_eligible = true
+asset_manifest_member = false
+note = "Code-backed model owned by the models/generation worker; no duplicate serialization is invented here"
+
+[[models]]
+id = "sm"
+formats = [ "ufo", "json",]
+authors = [ "N. Christensen", "C. Duhr",]
+canonical_ufo_path = "pyamplicol/assets/models/ufo/sm"
+canonical_json_path = "pyamplicol/assets/models/json/sm/sm.json"
+license_ids = [ "GammaLoop-model-assets",]
+release_eligible = true
+
+[[models]]
+id = "scalars"
+formats = [ "ufo", "json",]
+authors = [ "Valentin Hirschi",]
+generator = "FeynRules 1.7.69"
+canonical_ufo_path = "pyamplicol/assets/models/ufo/scalars"
+canonical_json_path = "pyamplicol/assets/models/json/scalars/scalars.json"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+release_eligible = true
+
+[[models]]
+id = "scalar_gravity"
+formats = [ "ufo", "json",]
+authors = [ "Valentin Hirschi",]
+generator = "FeynRules 1.7.69"
+canonical_ufo_path = "pyamplicol/assets/models/ufo/scalar_gravity"
+canonical_json_path = "pyamplicol/assets/models/json/scalar_gravity/scalar_gravity.json"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+release_eligible = true
+
+[[transformations]]
+id = "verbatim-git-blob-v1"
+description = "Copy the selected baseline Git blob byte-for-byte"
+
+[[transformations]]
+id = "scalar-static-defaults-v1"
+description = "Replace UFO_SCALARS_MODEL_* environment reads with the historical defaults N_SCALARS=3 and N_POINT_INTERACTIONS=3..10"
+authorized_by = "docs/development/PHYSICS_EXTRACTION_CONTRACT.md#model-determinism"
+
+[[transformations]]
+id = "scalar-gravity-static-defaults-v1"
+description = "Replace UFO_GRAVITY_MODEL_N_SCALARS with N_SCALARS=3 and remove the unused interaction-option branch containing undefined N_POINT_INTERACTIONS"
+authorized_by = "docs/development/PHYSICS_EXTRACTION_CONTRACT.md#model-determinism"
+
+[[transformations]]
+id = "loader-ufo-full-v1"
+description = "Load sanitized UFO with restriction='full', simplify=True, no index wrapping; serialize model with ufo-model-loader 0.1.8 JSONLook.VERBOSE"
+authorized_by = "docs/development/MODEL_ASSET_PROVENANCE.md#before-extraction"
+
+[[transformations]]
+id = "loader-ufo-full-wrapped-v1"
+description = "Load sanitized UFO with restriction='full', simplify=True, wrap Lorentz indices; serialize with ufo-model-loader 0.1.8 JSONLook.VERBOSE"
+authorized_by = "docs/development/MODEL_ASSET_PROVENANCE.md#before-extraction"
+
+[[transformations]]
+id = "loader-json-canonical-v1"
+description = "Load the tracked frozen JSON variant without a restriction and reserialize with ufo-model-loader 0.1.8 JSONLook.VERBOSE"
+authorized_by = "docs/development/MODEL_ASSET_PROVENANCE.md#before-extraction"
+
+[[transformations]]
+id = "sm-standard-ufo-spinor-order-v1"
+description = "Swap the fermion-pair leg labels in the spinor slots of the SM Lorentz structures to the standard UFO order of MadGraph and FeynRules, e.g. FFV1 = Gamma(3,2,1); the JSON models apply it to their loader-ufo-full-v1 and loader-ufo-full-wrapped-v1 serializations"
+authorized_by = "docs/development/model-assets/TRANSFORMATIONS.md#standard-ufo-spinor-order"
+
+[[transformations]]
+id = "loader-restriction-card-v1"
+description = "Parse every external parameter from the matching sanitized UFO restriction card and serialize the complete card, including explicit zeros, with ufo-model-loader 0.1.8 JSONLook.VERBOSE"
+authorized_by = "docs/development/MODEL_ASSET_PROVENANCE.md#before-extraction"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/scalar_gravity/restrict_default.json"
+package_sha256 = "78e536276cfa98a854ea9b418a6de9437da1e21ea258fcc57ba2b20a6a691900"
+package_size = 357
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/scalar_gravity/restrict_default.json"
+source_blob_oid = "f3e10838fadee3867cafa98712e40121b4c652b8"
+source_git_mode = "100644"
+source_sha256 = "78e536276cfa98a854ea9b418a6de9437da1e21ea258fcc57ba2b20a6a691900"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/scalar_gravity/restrict_default.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/scalar_gravity/restrict_default.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/scalar_gravity/scalar_gravity.json"
+package_sha256 = "3bfc81548466ffc464fa72a3469a9c0c8930970bf048c64c43aee13c8e83bd72"
+package_size = 224817
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/scalar_gravity/scalar_gravity.json"
+source_blob_oid = "9dba5b8cf3e65a38166a2f852f0aaa7ea987b08b"
+source_git_mode = "100644"
+source_sha256 = "e303fd1c39eb39e7deca5b36099202074a9048da3dbf2a73baf1f43a31648173"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "loader-ufo-full-v1"
+upstream_distribution_path = "assets/models/json/scalar_gravity/scalar_gravity.json"
+upstream_exact_blob_match = true
+generated_from = "ufo/scalar_gravity"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/scalars/restrict_default.json"
+package_sha256 = "ffe7759b8efcc86e6d12d3797c2e63a91c18c07de1bace6a51ee02144ecbf218"
+package_size = 322
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/scalars/restrict_default.json"
+source_blob_oid = "510bf5ae4c24bdf3bd092c46b5cf30d1a3ea012b"
+source_git_mode = "100644"
+source_sha256 = "31e30e8bdbdaf4753e361269fcd0294f7d7c82956c0afe66052dd527aa4b864a"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/scalars/restrict_default.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/scalars/restrict_default.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/scalars/scalars.json"
+package_sha256 = "ca27b8cc228cd03db57556fc1c40298865a75269bf2744bee8c59c013eb28df7"
+package_size = 127756
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/scalars/scalars.json"
+source_blob_oid = "47b891712d2298fe3f617a554b4a88cb4a8f0f8b"
+source_git_mode = "100644"
+source_sha256 = "6085cb3b1307bfdf7f3bb709ac1df9354b0cef8b1a3f6316f673fa069c9d9c85"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "loader-ufo-full-v1"
+upstream_distribution_path = "assets/models/json/scalars/scalars.json"
+upstream_exact_blob_match = true
+generated_from = "ufo/scalars"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/scalars/scalars_2p_3p.json"
+package_sha256 = "0a268a9fc959036e166367155ab2eeca5c52f76927a89245f8964b9b33b2a8b5"
+package_size = 10990
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/scalars/scalars_2p_3p.json"
+source_blob_oid = "f456fa7fb19c5c2964ac431c1d43ab6393814a0b"
+source_git_mode = "100644"
+source_sha256 = "ba4a928f4bf28975ca861c85106559a6d2747326572751eec3448bf67a5f763a"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "loader-json-canonical-v1"
+upstream_distribution_path = "assets/models/json/scalars/scalars_2p_3p.json"
+upstream_exact_blob_match = true
+generated_from = "json/scalars/scalars_2p_3p.json"
+frozen_options = "N_SCALARS=3; N_POINT_INTERACTIONS=[2,3]"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/restrict_c_mass.json"
+package_sha256 = "014e93a779812d9af1d3886143cebc8fd911e92f5f970aee4dfffe01429651f5"
+package_size = 908
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/restrict_c_mass.json"
+source_blob_oid = "6f2691574431b0efb59b4df5449bf8b035118f50"
+source_git_mode = "100644"
+source_sha256 = "6b191f6d0c45a6e91ea867079b1095e37fc4882df1c1380e70312890959dc7a6"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/sm/restrict_c_mass.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm/restrict_c_mass.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/restrict_ckm.json"
+package_sha256 = "be8bdca54507167d8ae4b33d0b0b77808052cd841d6fabd26a3d99926d915b99"
+package_size = 915
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/restrict_ckm.json"
+source_blob_oid = "80a237d40629c2181b63311d79f104f2f865121d"
+source_git_mode = "100644"
+source_sha256 = "57f3ffbd0a0784d433bb9b01211299f29dde1ddd0182ee0b1e4a87dc3f2b5c73"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/sm/restrict_ckm.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm/restrict_ckm.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/restrict_default.json"
+package_sha256 = "8fdd48a3624620c1a15bab602f43a41519038cf69d8fef6aeaaaf13a3f1846c1"
+package_size = 906
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/restrict_default.json"
+source_blob_oid = "3ad2ec48354f2eaa98873074ebab97c39b02c297"
+source_git_mode = "100644"
+source_sha256 = "9d357d17c254595dbf612b66d6b531c982eefb71432835360bbfd8b21dcf454b"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/sm/restrict_default.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm/restrict_default.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/restrict_lepton_masses.json"
+package_sha256 = "3d9fe3095907cef03f889bd95b9630a2f836d70244f1b450cfd5d2764913531b"
+package_size = 929
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/restrict_lepton_masses.json"
+source_blob_oid = "b9a1d2fc10724269fee9b45235351039396594fe"
+source_git_mode = "100644"
+source_sha256 = "a22a9de56e536cd7c4e4bd4707f5f95d3255fb0dffd49d9567ec9a659576bb76"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/sm/restrict_lepton_masses.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm/restrict_lepton_masses.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/restrict_no_b_mass.json"
+package_sha256 = "82d2fbc06f9d0b7daaed56673912d920ca459f435e9083deed2f4b716c2f4a30"
+package_size = 906
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/restrict_no_b_mass.json"
+source_blob_oid = "d9b4518f19c497b9b414fc5380286a1f3f1fe9dc"
+source_git_mode = "100644"
+source_sha256 = "2ca10cc1e02b34f226db983da9a787659257003e6d84001204389e8aef03dfa5"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/sm/restrict_no_b_mass.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm/restrict_no_b_mass.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/restrict_no_masses.json"
+package_sha256 = "f925921df1b66f010cd6f8cd348b5f4728ba37678e0733d8618cef3f2b4e610e"
+package_size = 902
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/restrict_no_masses.json"
+source_blob_oid = "4532ce8adb6385909b113dd706e9382dbba9b3c3"
+source_git_mode = "100644"
+source_sha256 = "9bc6bba7b940da83484e5f43346ba202333669aaca578dfa110ed3fbc17514b8"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/sm/restrict_no_masses.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm/restrict_no_masses.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/restrict_no_tau_mass.json"
+package_sha256 = "a26603f4f3572309dc7ce2f23295d5a8aec61d2f3c42a017341245e459648478"
+package_size = 902
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/restrict_no_tau_mass.json"
+source_blob_oid = "f6a10ad19ea5b9e812b654ef98bfeb0c6ea01667"
+source_git_mode = "100644"
+source_sha256 = "7560d6890d7cd26532f28865fb8f4092ffcbf49c54fa7a16e921e6b08c3f43e3"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/sm/restrict_no_tau_mass.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm/restrict_no_tau_mass.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/restrict_no_widths.json"
+package_sha256 = "fdc03507f82a3d98571b97ba0ab34f712dc0eb02b101f8308b96c6ab8490c08c"
+package_size = 885
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/restrict_no_widths.json"
+source_blob_oid = "267fd018128278533f8b809ab4c58453ebb7b016"
+source_git_mode = "100644"
+source_sha256 = "9002d18be203c34418a3966f7cedc5d20844c317c55906efca32f51a38f1f183"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/sm/restrict_no_widths.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm/restrict_no_widths.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/restrict_zeromass_ckm.json"
+package_sha256 = "b8b4376c82f9486266283a383a0347ec42498296180d92249e2e7a772e1a7e1a"
+package_size = 911
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/restrict_zeromass_ckm.json"
+source_blob_oid = "5a4dd6a33974cd47a32aa3a82625e6f0f38f803c"
+source_git_mode = "100644"
+source_sha256 = "2173adc123ef202816d56e20772747f8a513ce9294635e099fdbe4832329944d"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "loader-restriction-card-v1"
+upstream_distribution_path = "assets/models/json/sm/restrict_zeromass_ckm.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm/restrict_zeromass_ckm.dat"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/sm.json"
+package_sha256 = "c1222e3b70b71804e5212e994a3b76e2f098f7fc3ba1693c9f9c65578d7e3e00"
+package_size = 120661
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/sm.json"
+source_blob_oid = "41927df948a4c22e3295363be3b4c39b3fedc6c3"
+source_git_mode = "100644"
+source_sha256 = "684f75c88c7faf6832e9e8122970ec5fe98b9cd30bc989b7f8e1818c327fe165"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "sm-standard-ufo-spinor-order-v1"
+upstream_distribution_path = "assets/models/json/sm/sm.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/json/sm/sm_wrapped_indices.json"
+package_sha256 = "e1ee0059f3fc534c462e98c358249acbce0a711171fcbfe41720a9a1f24b2933"
+package_size = 124855
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/json/sm/sm_wrapped_indices.json"
+source_blob_oid = "bd86527135715c8bdc9f21aef6f511543a5b7fe2"
+source_git_mode = "100644"
+source_sha256 = "b4221a0985ad5c6987c325a75012a3231995c604e44ad543d0b1ead22eb19404"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "sm-standard-ufo-spinor-order-v1"
+upstream_distribution_path = "assets/models/json/sm/sm_wrapped_indices.json"
+upstream_exact_blob_match = false
+generated_from = "ufo/sm"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/__init__.py"
+package_sha256 = "baf7043f1586a6b70546d04019b11c3fc17f181f278d5d33a70b7217b5e0db71"
+package_size = 652
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/__init__.py"
+source_blob_oid = "9a3ad6aac9acfbe3f8e4b4423d5565bffd909fe1"
+source_git_mode = "100644"
+source_sha256 = "baf7043f1586a6b70546d04019b11c3fc17f181f278d5d33a70b7217b5e0db71"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/__init__.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/coupling_orders.py"
+package_sha256 = "63738137e1355e064968615a500ecd195395af6f8dea4fd4efee541b47dc7f27"
+package_size = 524
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/coupling_orders.py"
+source_blob_oid = "f6a1ec99fbba8b0dcf9abc3192831839f3df1fe5"
+source_git_mode = "100644"
+source_sha256 = "63738137e1355e064968615a500ecd195395af6f8dea4fd4efee541b47dc7f27"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/coupling_orders.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/couplings.py"
+package_sha256 = "afd07d76eaefaf4828a243eb63c88196f11da1fcbea59f873c1e3832fbc276fb"
+package_size = 1865
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/couplings.py"
+source_blob_oid = "643747e8f3ca22ce8189ffa5d3875028bc9d0424"
+source_git_mode = "100644"
+source_sha256 = "afd07d76eaefaf4828a243eb63c88196f11da1fcbea59f873c1e3832fbc276fb"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/couplings.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/function_library.py"
+package_sha256 = "7ab870cbfebbca3858ab8d6780d138b4b2531f6e2be84ff2cf4e6362b6c601bd"
+package_size = 1332
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/function_library.py"
+source_blob_oid = "b2843b6ca0834c14389aef93203a7eaeb8022b7c"
+source_git_mode = "100644"
+source_sha256 = "7ab870cbfebbca3858ab8d6780d138b4b2531f6e2be84ff2cf4e6362b6c601bd"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/function_library.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/lorentz.py"
+package_sha256 = "28e38a5a20aee6e02605fc2dc2d2e850b05edc1ade5f343fc2ef780ba9666e42"
+package_size = 134243
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/lorentz.py"
+source_blob_oid = "768a0b9363a70b28c980c4d2447d4c665b3a07ef"
+source_git_mode = "100644"
+source_sha256 = "28e38a5a20aee6e02605fc2dc2d2e850b05edc1ade5f343fc2ef780ba9666e42"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/lorentz.py"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/object_library.py"
+package_sha256 = "5db44f44bdc8df1ada2c76bd02d5f9241298d0187b963c0d2ee39b88e3910cb3"
+package_size = 7079
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/object_library.py"
+source_blob_oid = "85c41db185c460a8ad17d4220365056f04039658"
+source_git_mode = "100644"
+source_sha256 = "5db44f44bdc8df1ada2c76bd02d5f9241298d0187b963c0d2ee39b88e3910cb3"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/object_library.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/param_card.dat"
+package_sha256 = "ed708e1744af39117e364be9f8c2f9c7fa844781701a3fb419cff95a8b427dd7"
+package_size = 1960
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/param_card.dat"
+source_blob_oid = "84e32fdbbbe9c57cb64d47a00794ec13660ee70e"
+source_git_mode = "100644"
+source_sha256 = "ed708e1744af39117e364be9f8c2f9c7fa844781701a3fb419cff95a8b427dd7"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/param_card.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/parameters.py"
+package_sha256 = "01b0477e0b0e352f968a6d1bfd1e9724c505adc6dd5c1d39dd08e9da97cd9f00"
+package_size = 3645
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/parameters.py"
+source_blob_oid = "1fbe07ca4c5f8d8ea72b541930d6293ee6870959"
+source_git_mode = "100644"
+source_sha256 = "68de6a8ab6ecb1f358a13954be99597bb30665d1e195b7395f8faf405bd8657e"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "scalar-gravity-static-defaults-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/parameters.py"
+upstream_exact_blob_match = true
+generated_from = "ufo/scalar_gravity/parameters.py"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/particles.py"
+package_sha256 = "90b4efa5fd4c8eb443c43a3a8d7109add2fae94807670098195d6024acd91bd5"
+package_size = 1681
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/particles.py"
+source_blob_oid = "bea3ca350ebb8cc66c5179ffb491c82f68d7a026"
+source_git_mode = "100644"
+source_sha256 = "90b4efa5fd4c8eb443c43a3a8d7109add2fae94807670098195d6024acd91bd5"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/particles.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/restrict_default.dat"
+package_sha256 = "ed708e1744af39117e364be9f8c2f9c7fa844781701a3fb419cff95a8b427dd7"
+package_size = 1960
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/restrict_default.dat"
+source_blob_oid = "84e32fdbbbe9c57cb64d47a00794ec13660ee70e"
+source_git_mode = "100644"
+source_sha256 = "ed708e1744af39117e364be9f8c2f9c7fa844781701a3fb419cff95a8b427dd7"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/restrict_default.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/restrict_full.dat"
+package_sha256 = "0005fc634dd25e095ad70ee49b1789736e6ed31a428794866fea279585a7fbd0"
+package_size = 1579
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/restrict_full.dat"
+source_blob_oid = "b206643b681de5bf10fd96112a3a925d5a0e7234"
+source_git_mode = "100644"
+source_sha256 = "0005fc634dd25e095ad70ee49b1789736e6ed31a428794866fea279585a7fbd0"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/restrict_full.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/run_write_param_card.py"
+package_sha256 = "d45878face2f212eaed32932e36ffcaf33e643db347c44d074657292805b47a0"
+package_size = 543
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/run_write_param_card.py"
+source_blob_oid = "d87ecc25b963bd42e7f886e06bc475c8f5333e5b"
+source_git_mode = "100755"
+source_sha256 = "d45878face2f212eaed32932e36ffcaf33e643db347c44d074657292805b47a0"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/run_write_param_card.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/vertices.py"
+package_sha256 = "4c7d261c81d15242c09cd12403fe8d32a5d41fefc4136e726d5e934d9358e9be"
+package_size = 1893
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/vertices.py"
+source_blob_oid = "ca314996c75d9f0750e452a7232ac9a4555b0345"
+source_git_mode = "100644"
+source_sha256 = "4c7d261c81d15242c09cd12403fe8d32a5d41fefc4136e726d5e934d9358e9be"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/vertices.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalar_gravity/write_param_card.py"
+package_sha256 = "3008b3269d0689370523a4a6dbcdd4100bb7d78599e2f3df79127ead6fe7fc75"
+package_size = 6556
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalar_gravity/write_param_card.py"
+source_blob_oid = "bcf80e99553c7631dc4a1ea92d4a28a87ecde78f"
+source_git_mode = "100644"
+source_sha256 = "3008b3269d0689370523a4a6dbcdd4100bb7d78599e2f3df79127ead6fe7fc75"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalar_gravity/write_param_card.py"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/__init__.py"
+package_sha256 = "baf7043f1586a6b70546d04019b11c3fc17f181f278d5d33a70b7217b5e0db71"
+package_size = 652
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/__init__.py"
+source_blob_oid = "9a3ad6aac9acfbe3f8e4b4423d5565bffd909fe1"
+source_git_mode = "100644"
+source_sha256 = "baf7043f1586a6b70546d04019b11c3fc17f181f278d5d33a70b7217b5e0db71"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/__init__.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/coupling_orders.py"
+package_sha256 = "2e691ad2042a4a7edde293fe69ba96f54ec08221061db0ed1dc30f588011504e"
+package_size = 416
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/coupling_orders.py"
+source_blob_oid = "cb073b19efe1954a432c2c375f73c363f6e6b53d"
+source_git_mode = "100644"
+source_sha256 = "2e691ad2042a4a7edde293fe69ba96f54ec08221061db0ed1dc30f588011504e"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/coupling_orders.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/couplings.py"
+package_sha256 = "325cfc644fe3b86cffd8de916c3f285016d70fe673d50f3c5ca1c7dcdfaa4183"
+package_size = 257
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/couplings.py"
+source_blob_oid = "9a3f7c38b09a3d9440e478fefe3b4c6457340bad"
+source_git_mode = "100644"
+source_sha256 = "325cfc644fe3b86cffd8de916c3f285016d70fe673d50f3c5ca1c7dcdfaa4183"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/couplings.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/function_library.py"
+package_sha256 = "7ab870cbfebbca3858ab8d6780d138b4b2531f6e2be84ff2cf4e6362b6c601bd"
+package_size = 1332
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/function_library.py"
+source_blob_oid = "b2843b6ca0834c14389aef93203a7eaeb8022b7c"
+source_git_mode = "100644"
+source_sha256 = "7ab870cbfebbca3858ab8d6780d138b4b2531f6e2be84ff2cf4e6362b6c601bd"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/function_library.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/lorentz.py"
+package_sha256 = "3daaf714d13328419366cc5c9b6a490d6cd9cff8ace604bf2ec0915061e5b736"
+package_size = 726
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/lorentz.py"
+source_blob_oid = "85a4a01cac7a4677d484ea5efbfa75c5fe3d661c"
+source_git_mode = "100644"
+source_sha256 = "3daaf714d13328419366cc5c9b6a490d6cd9cff8ace604bf2ec0915061e5b736"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/lorentz.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/object_library.py"
+package_sha256 = "5db44f44bdc8df1ada2c76bd02d5f9241298d0187b963c0d2ee39b88e3910cb3"
+package_size = 7079
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/object_library.py"
+source_blob_oid = "85c41db185c460a8ad17d4220365056f04039658"
+source_git_mode = "100644"
+source_sha256 = "5db44f44bdc8df1ada2c76bd02d5f9241298d0187b963c0d2ee39b88e3910cb3"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/object_library.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/parameters.py"
+package_sha256 = "7b11a9b1d84126d31f58d5c4752ea0fe0921074bfcb338ecd6ef4d2ad7da89a7"
+package_size = 3452
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/parameters.py"
+source_blob_oid = "884e4025f897608d8f2773300c8cb1fc71306904"
+source_git_mode = "100644"
+source_sha256 = "7620698c89ec9a87eb11177f682627e9a334222d42b378c18e111b866f7c3ad0"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "scalar-static-defaults-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/parameters.py"
+upstream_exact_blob_match = true
+generated_from = "ufo/scalars/parameters.py"
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/particles.py"
+package_sha256 = "1e346940ecf9746445db47219256cc4739444b111f3a2a96967bbb890b57e310"
+package_size = 1221
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/particles.py"
+source_blob_oid = "20399e78bea20b015fdfd4703a896775f8916cb1"
+source_git_mode = "100644"
+source_sha256 = "1e346940ecf9746445db47219256cc4739444b111f3a2a96967bbb890b57e310"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/particles.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/restrict_default.dat"
+package_sha256 = "020178e9df8fe242fd4d34077db4caff694959a7c6d7a5c829527f8de4e1c80f"
+package_size = 1748
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/restrict_default.dat"
+source_blob_oid = "8d45909b657a69ab4a7e8f4f799aeb1cc2163959"
+source_git_mode = "100644"
+source_sha256 = "020178e9df8fe242fd4d34077db4caff694959a7c6d7a5c829527f8de4e1c80f"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/restrict_default.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/restrict_full.dat"
+package_sha256 = "0005fc634dd25e095ad70ee49b1789736e6ed31a428794866fea279585a7fbd0"
+package_size = 1579
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/restrict_full.dat"
+source_blob_oid = "b206643b681de5bf10fd96112a3a925d5a0e7234"
+source_git_mode = "100644"
+source_sha256 = "0005fc634dd25e095ad70ee49b1789736e6ed31a428794866fea279585a7fbd0"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/restrict_full.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/run_write_param_card.py"
+package_sha256 = "d45878face2f212eaed32932e36ffcaf33e643db347c44d074657292805b47a0"
+package_size = 543
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/run_write_param_card.py"
+source_blob_oid = "d87ecc25b963bd42e7f886e06bc475c8f5333e5b"
+source_git_mode = "100755"
+source_sha256 = "d45878face2f212eaed32932e36ffcaf33e643db347c44d074657292805b47a0"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/run_write_param_card.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/vertices.py"
+package_sha256 = "1341725ef6b4bf5eb7ff5fa09d633c1cb52e89b695c627ae42c2ca5664525d4f"
+package_size = 1103
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/vertices.py"
+source_blob_oid = "b58af0f4ce08f1be499c51dba34fba062a5e4191"
+source_git_mode = "100644"
+source_sha256 = "1341725ef6b4bf5eb7ff5fa09d633c1cb52e89b695c627ae42c2ca5664525d4f"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/vertices.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/scalars/write_param_card.py"
+package_sha256 = "3008b3269d0689370523a4a6dbcdd4100bb7d78599e2f3df79127ead6fe7fc75"
+package_size = 6556
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/scalars/write_param_card.py"
+source_blob_oid = "bcf80e99553c7631dc4a1ea92d4a28a87ecde78f"
+source_git_mode = "100644"
+source_sha256 = "3008b3269d0689370523a4a6dbcdd4100bb7d78599e2f3df79127ead6fe7fc75"
+license_ids = [ "0BSD", "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/scalars/write_param_card.py"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/__init__.py"
+package_sha256 = "dcefb2fa6a4b1653d87944a11dfaedf1b5a2c0a5b27d2370685c2e21d157a568"
+package_size = 886
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/__init__.py"
+source_blob_oid = "a4b9447bcac8c96261eaed4a3e4c8bdcaaae0e9a"
+source_git_mode = "100644"
+source_sha256 = "dcefb2fa6a4b1653d87944a11dfaedf1b5a2c0a5b27d2370685c2e21d157a568"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/__init__.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/build_restrict.py"
+package_sha256 = "de21ae72ae23f8409d077599f0e4fabbab5287373e3930bc34a19adacd60781e"
+package_size = 2886
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/build_restrict.py"
+source_blob_oid = "838268f2087759d8315a27d3160c9f003c4849d3"
+source_git_mode = "100644"
+source_sha256 = "de21ae72ae23f8409d077599f0e4fabbab5287373e3930bc34a19adacd60781e"
+license_ids = [ "GammaLoop-model-assets", "MadGraph5-aMCatNLO",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/build_restrict.py"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/coupling_orders.py"
+package_sha256 = "cb45f17e973165af72af7f5fabe368306919b00d8421745c79807b5fda1bdace"
+package_size = 485
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/coupling_orders.py"
+source_blob_oid = "3a0bd46b64bf60b7348433c3fa8b161fc2bcd4bf"
+source_git_mode = "100644"
+source_sha256 = "cb45f17e973165af72af7f5fabe368306919b00d8421745c79807b5fda1bdace"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/coupling_orders.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/couplings.py"
+package_sha256 = "a5d30cec4efec54b637b5a2ce8017b54fa78f16c546afe33e7410a0279bf979c"
+package_size = 14157
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/couplings.py"
+source_blob_oid = "5e3e67ffd2ef718620644c76aaa687d6cd18a924"
+source_git_mode = "100644"
+source_sha256 = "a5d30cec4efec54b637b5a2ce8017b54fa78f16c546afe33e7410a0279bf979c"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/couplings.py"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/decays.py"
+package_sha256 = "12b9bc8544b01e248087f197c2dc9137d274f980178bc72f67d130fb149007a2"
+package_size = 13625
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/decays.py"
+source_blob_oid = "23af667e4c1d5df7ea393bf098daa9982112b588"
+source_git_mode = "100644"
+source_sha256 = "12b9bc8544b01e248087f197c2dc9137d274f980178bc72f67d130fb149007a2"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/decays.py"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/function_library.py"
+package_sha256 = "a8821ed8a739e43b705ff7c7aa7d93ff545071b0fe020f5c0c8b0799c30ef2ae"
+package_size = 1339
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/function_library.py"
+source_blob_oid = "33a8975a586a597cfb86f20d7ccb102d804b1787"
+source_git_mode = "100644"
+source_sha256 = "a8821ed8a739e43b705ff7c7aa7d93ff545071b0fe020f5c0c8b0799c30ef2ae"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/function_library.py"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/lorentz.py"
+package_sha256 = "1f13e8b63e2ecf428e2875e14bc6901ce49952e1cf2b18ea9934c8d4264e3559"
+package_size = 2656
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/lorentz.py"
+source_blob_oid = "f413c46228114e00282f2d5ba99ffeb8eecd3d7e"
+source_git_mode = "100644"
+source_sha256 = "cd578c286b038dd3daae396ebd1515cf36d8089b63a1d20247d2b797054b162b"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "sm-standard-ufo-spinor-order-v1"
+upstream_distribution_path = "assets/models/ufo/sm/lorentz.py"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/object_library.py"
+package_sha256 = "6391978031caea837ecea426f2f0cfdac748457a00bac99e02c025c42e883cb5"
+package_size = 6959
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/object_library.py"
+source_blob_oid = "d63a4532dd732b2cb471c57b2217113d8c9ccfc9"
+source_git_mode = "100644"
+source_sha256 = "6391978031caea837ecea426f2f0cfdac748457a00bac99e02c025c42e883cb5"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/object_library.py"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/parameters.py"
+package_sha256 = "e8599a97d31004d7af8c589a5e734c9141b48d9becdbbde86a37e41635390e38"
+package_size = 14852
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/parameters.py"
+source_blob_oid = "8cf61680938dd9cf68f615ee47d85a281b9b9215"
+source_git_mode = "100644"
+source_sha256 = "e8599a97d31004d7af8c589a5e734c9141b48d9becdbbde86a37e41635390e38"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/parameters.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/particles.py"
+package_sha256 = "9b542b5d49598ade4d9d6897d569e8feeaa05993e74aef67fb5dfafd5efa9916"
+package_size = 10248
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/particles.py"
+source_blob_oid = "161bd4d13e0e49d8c3ddac24ca4de488c4bcd329"
+source_git_mode = "100644"
+source_sha256 = "9b542b5d49598ade4d9d6897d569e8feeaa05993e74aef67fb5dfafd5efa9916"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/particles.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/restrict_c_mass.dat"
+package_sha256 = "817a7843a1435c1c7b1f0231ababc346e58f81d8038b9c0b2c75eae32960da9e"
+package_size = 1412
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/restrict_c_mass.dat"
+source_blob_oid = "153d8c6509d5ecedfde606ef3a2bcf434b1960df"
+source_git_mode = "100644"
+source_sha256 = "817a7843a1435c1c7b1f0231ababc346e58f81d8038b9c0b2c75eae32960da9e"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/restrict_c_mass.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/restrict_ckm.dat"
+package_sha256 = "75fd361e4ce78100b7dd107cd42b1015d9303da44bec8971e401c2d20d7876cb"
+package_size = 1412
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/restrict_ckm.dat"
+source_blob_oid = "3b0e9f9db10eff5ceedb5ee13e2912014d42a367"
+source_git_mode = "100644"
+source_sha256 = "75fd361e4ce78100b7dd107cd42b1015d9303da44bec8971e401c2d20d7876cb"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/restrict_ckm.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/restrict_default.dat"
+package_sha256 = "988939a63e2d35ca991bac864b8f10f6ee19fd13063cb68e91af962767974889"
+package_size = 1439
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/restrict_default.dat"
+source_blob_oid = "2ae557d5ad70599a258322b6fb1d8c15bc4966e2"
+source_git_mode = "100644"
+source_sha256 = "988939a63e2d35ca991bac864b8f10f6ee19fd13063cb68e91af962767974889"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/restrict_default.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/restrict_full.dat"
+package_sha256 = "f1e023d45808db115385e5707640a3a3e126217840067a14200e995181eba151"
+package_size = 4670
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/restrict_full.dat"
+source_blob_oid = "38ec0ccc5299c453c792bb0851fd55467521bc54"
+source_git_mode = "100644"
+source_sha256 = "f1e023d45808db115385e5707640a3a3e126217840067a14200e995181eba151"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/restrict_full.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/restrict_lepton_masses.dat"
+package_sha256 = "eb44e12f6f4ee591e76277322359e31f4a577a9200acd6c5c8dc6629a039e8c8"
+package_size = 1439
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/restrict_lepton_masses.dat"
+source_blob_oid = "b8d90f3e35ac00e2700b06be399f43a9aeb0a904"
+source_git_mode = "100644"
+source_sha256 = "eb44e12f6f4ee591e76277322359e31f4a577a9200acd6c5c8dc6629a039e8c8"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/restrict_lepton_masses.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/restrict_no_b_mass.dat"
+package_sha256 = "32dc93b5584b7bdbf24e87ce12d55398cc2d865e0240ccf6e853c2ade1f90e9e"
+package_size = 1412
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/restrict_no_b_mass.dat"
+source_blob_oid = "f42e3375d13af52b900c0819b13db974a68bbedc"
+source_git_mode = "100644"
+source_sha256 = "32dc93b5584b7bdbf24e87ce12d55398cc2d865e0240ccf6e853c2ade1f90e9e"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/restrict_no_b_mass.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/restrict_no_masses.dat"
+package_sha256 = "539664a3651839946cc995257bd9e108054c789f5352ecc0e562260798e66bf0"
+package_size = 1412
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/restrict_no_masses.dat"
+source_blob_oid = "31a72cedc730903d603b00e0b998a76b9165edd2"
+source_git_mode = "100644"
+source_sha256 = "539664a3651839946cc995257bd9e108054c789f5352ecc0e562260798e66bf0"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/restrict_no_masses.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/restrict_no_tau_mass.dat"
+package_sha256 = "52433bb4161af5a0f17c91964fdd695b155c0c9821eda37142f04a1b1c2e57f8"
+package_size = 1412
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/restrict_no_tau_mass.dat"
+source_blob_oid = "6497e444d297fbeeafd34f0d50986e04c42884a8"
+source_git_mode = "100644"
+source_sha256 = "52433bb4161af5a0f17c91964fdd695b155c0c9821eda37142f04a1b1c2e57f8"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/restrict_no_tau_mass.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/restrict_no_widths.dat"
+package_sha256 = "0ab8569ed8e747b0c0c0ee2c2c93db1e368489237baf8430c53eef605a1634e8"
+package_size = 1410
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/restrict_no_widths.dat"
+source_blob_oid = "55e78884b93d2fcd1a6125d12937ea40974d594a"
+source_git_mode = "100644"
+source_sha256 = "0ab8569ed8e747b0c0c0ee2c2c93db1e368489237baf8430c53eef605a1634e8"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/restrict_no_widths.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/restrict_zeromass_ckm.dat"
+package_sha256 = "2388cf490afcfb5530f49ae3a85fec235be236e33c4bb5e1515f3d4827b963c6"
+package_size = 1412
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/restrict_zeromass_ckm.dat"
+source_blob_oid = "c82164bac69678563fad925c7e9fedc8d497c545"
+source_git_mode = "100644"
+source_sha256 = "2388cf490afcfb5530f49ae3a85fec235be236e33c4bb5e1515f3d4827b963c6"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/restrict_zeromass_ckm.dat"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/run_write_param_card.py"
+package_sha256 = "d45878face2f212eaed32932e36ffcaf33e643db347c44d074657292805b47a0"
+package_size = 543
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/run_write_param_card.py"
+source_blob_oid = "d87ecc25b963bd42e7f886e06bc475c8f5333e5b"
+source_git_mode = "100755"
+source_sha256 = "d45878face2f212eaed32932e36ffcaf33e643db347c44d074657292805b47a0"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/run_write_param_card.py"
+upstream_exact_blob_match = true
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/vertices.py"
+package_sha256 = "6f3353b483e6a3f7c6b9f5e79d3a818af8e933ec63f96c18ed271760f6492c68"
+package_size = 32556
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/vertices.py"
+source_blob_oid = "d8c6ceb815df1d152dc651585848bbd273300bed"
+source_git_mode = "100644"
+source_sha256 = "6f3353b483e6a3f7c6b9f5e79d3a818af8e933ec63f96c18ed271760f6492c68"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/vertices.py"
+upstream_exact_blob_match = false
+
+[[files]]
+canonical_package_path = "pyamplicol/assets/models/ufo/sm/write_param_card.py"
+package_sha256 = "9a289a0f17edaaa0609ccd7d83db3b2d4b389e51f07a0f0c47ffce77afb18c03"
+package_size = 6619
+source_repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+source_revision = "643bc6f99d7b2249af0a85204768df243e612411"
+source_path = "pyAmpliCol/src/pyamplicol/assets/models/ufo/sm/write_param_card.py"
+source_blob_oid = "3abf4cff0cb9dca8baba042a0b7c373b4e8b8b64"
+source_git_mode = "100644"
+source_sha256 = "9a289a0f17edaaa0609ccd7d83db3b2d4b389e51f07a0f0c47ffce77afb18c03"
+license_ids = [ "GammaLoop-model-assets",]
+transformation_id = "verbatim-git-blob-v1"
+upstream_distribution_path = "assets/models/ufo/sm/write_param_card.py"
+upstream_exact_blob_match = false
+
+[source]
+repository = "git@github.com:rikkert-frederix/AmpliCol.git"
+revision = "643bc6f99d7b2249af0a85204768df243e612411"
+root = "pyAmpliCol/src/pyamplicol/assets/models"
+
+[generator]
+distribution = "ufo-model-loader"
+version = "0.1.8"
+repository = "https://github.com/alphal00p/ufo_model_loader.git"
+revision = "70ddee6b416f8c8b340e0d087646d77095c5d24b"
+license_id = "MIT"
+serialization = "JSONLook.VERBOSE"
+
+[upstream_distribution]
+repository = "https://github.com/alphal00p/gammaloop.git"
+revision = "db79edc84f6a1580decbcc4ede7ea0b1c79d9a08"
+root = "assets/models"
+baseline_exact_blob_matches = 28
+baseline_nonmatching_blobs = 38
+interpretation = "Exactness is asserted per file below; all primary source identities remain the AmpliCol baseline Git objects"
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/scalar_gravity/restrict_default.json b/pyamplicol/src/pyamplicol/assets/models/json/scalar_gravity/restrict_default.json
new file mode 100644
index 0000000000..f3e10838fa
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/scalar_gravity/restrict_default.json
@@ -0,0 +1,38 @@
+{
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "dim": [
+    4.0,
+    0.0
+  ],
+  "kappa": [
+    1.0,
+    0.0
+  ],
+  "mass_scalar_1": [
+    1.0,
+    0.0
+  ],
+  "mass_scalar_2": [
+    2.0,
+    0.0
+  ],
+  "width_scalar_1": [
+    0.0,
+    0.0
+  ],
+  "width_scalar_2": [
+    0.0,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/scalar_gravity/scalar_gravity.json b/pyamplicol/src/pyamplicol/assets/models/json/scalar_gravity/scalar_gravity.json
new file mode 100644
index 0000000000..2df4210543
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/scalar_gravity/scalar_gravity.json
@@ -0,0 +1,867 @@
+{
+  "couplings": [
+    {
+      "expression": "UFO::{}::ZERO",
+      "name": "SSTmpart0",
+      "orders": [
+        [
+          "GRAV",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ZERO",
+      "name": "SSTTTmpart0",
+      "orders": [
+        [
+          "GRAV",
+          3
+        ]
+      ],
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ZERO",
+      "name": "SSTTmpart0",
+      "orders": [
+        [
+          "GRAV",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::kappa*UFO::{}::mass_scalar_1^2",
+      "name": "SSTmpart1",
+      "orders": [
+        [
+          "GRAV",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.5
+      ]
+    },
+    {
+      "expression": "1𝑖/32*UFO::{}::kappa^3*UFO::{}::mass_scalar_1^2",
+      "name": "SSTTTmpart1",
+      "orders": [
+        [
+          "GRAV",
+          3
+        ]
+      ],
+      "value": [
+        0.0,
+        0.03125
+      ]
+    },
+    {
+      "expression": "1𝑖/8*UFO::{}::kappa^2*UFO::{}::mass_scalar_1^2",
+      "name": "SSTTmpart1",
+      "orders": [
+        [
+          "GRAV",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.125
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::kappa*UFO::{}::mass_scalar_2^2",
+      "name": "SSTmpart2",
+      "orders": [
+        [
+          "GRAV",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        2.0
+      ]
+    },
+    {
+      "expression": "1𝑖/32*UFO::{}::kappa^3*UFO::{}::mass_scalar_2^2",
+      "name": "SSTTTmpart2",
+      "orders": [
+        [
+          "GRAV",
+          3
+        ]
+      ],
+      "value": [
+        0.0,
+        0.125
+      ]
+    },
+    {
+      "expression": "1𝑖/8*UFO::{}::kappa^2*UFO::{}::mass_scalar_2^2",
+      "name": "SSTTmpart2",
+      "orders": [
+        [
+          "GRAV",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.5
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::kappa",
+      "name": "SST",
+      "orders": [
+        [
+          "GRAV",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.5
+      ]
+    },
+    {
+      "expression": "1𝑖/8*UFO::{}::kappa^2",
+      "name": "SSTT",
+      "orders": [
+        [
+          "GRAV",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.125
+      ]
+    },
+    {
+      "expression": "1𝑖/32*UFO::{}::kappa^3",
+      "name": "SSTTT",
+      "orders": [
+        [
+          "GRAV",
+          3
+        ]
+      ],
+      "value": [
+        0.0,
+        0.03125
+      ]
+    },
+    {
+      "expression": "1𝑖/8*UFO::{}::kappa",
+      "name": "TTT",
+      "orders": [
+        [
+          "GRAV",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.125
+      ]
+    },
+    {
+      "expression": "1𝑖/32*UFO::{}::kappa^2",
+      "name": "TTTT",
+      "orders": [
+        [
+          "GRAV",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.03125
+      ]
+    }
+  ],
+  "form_factors": [],
+  "functions": [
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "complexconjugate"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "re"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "im"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "sec"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "asec"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "csc"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "acsc"
+    }
+  ],
+  "lorentz_structures": [
+    {
+      "name": "SSTmpart",
+      "spins": [
+        1,
+        1,
+        5
+      ],
+      "structure": "-1*UFO::{}::Metric(1003,2003)"
+    },
+    {
+      "name": "SST",
+      "spins": [
+        1,
+        1,
+        5
+      ],
+      "structure": "-1*UFO::{}::Metric(1003,2003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+UFO::{}::P(1003,1)*UFO::{}::P(2003,2)+UFO::{}::P(1003,2)*UFO::{}::P(2003,1)"
+    },
+    {
+      "name": "SSTTmpart",
+      "spins": [
+        1,
+        1,
+        5,
+        5
+      ],
+      "structure": "-2*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)+2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)+2*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)"
+    },
+    {
+      "name": "SSTT",
+      "spins": [
+        1,
+        1,
+        5,
+        5
+      ],
+      "structure": "(-1*UFO::{}::P(1003,1)*UFO::{}::P(2004,2)+-1*UFO::{}::P(1003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2))*UFO::{}::Metric(2003,1004)+(-1*UFO::{}::P(2003,1)*UFO::{}::P(2004,2)+-1*UFO::{}::P(2003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2))*UFO::{}::Metric(1003,1004)+-1*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(1004,2)+-1*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(1004,1)+-1*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2003,2)+-1*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(2003,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(2003,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2003,1)"
+    },
+    {
+      "name": "SSTTTmpart",
+      "spins": [
+        1,
+        1,
+        5,
+        5,
+        5
+      ],
+      "structure": "-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::Metric(2005,1005)+-1*UFO::{}::Metric(1003,1005)*UFO::{}::Metric(2003,2005)*UFO::{}::Metric(2004,1004)+-1*UFO::{}::Metric(1004,1005)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,2005)+-1*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1005)*UFO::{}::Metric(2005,1004)+-1*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::Metric(2005,1005)+-1*UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2004,1004)*UFO::{}::Metric(2005,1003)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2004,2005)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2005)*UFO::{}::Metric(2004,1005)+UFO::{}::Metric(1003,1005)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,2005)+UFO::{}::Metric(1003,1005)*UFO::{}::Metric(2003,2004)*UFO::{}::Metric(2005,1004)+UFO::{}::Metric(1004,1005)*UFO::{}::Metric(2003,2004)*UFO::{}::Metric(2005,1003)+UFO::{}::Metric(1004,1005)*UFO::{}::Metric(2003,2005)*UFO::{}::Metric(2004,1003)+UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1005)*UFO::{}::Metric(2005,1003)+UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2004,1003)*UFO::{}::Metric(2005,1004)"
+    },
+    {
+      "name": "SSTTT",
+      "spins": [
+        1,
+        1,
+        5,
+        5,
+        5
+      ],
+      "structure": "((UFO::{}::Metric(2004,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+UFO::{}::P(1004,1)*UFO::{}::P(2004,2)+UFO::{}::P(1004,2)*UFO::{}::P(2004,1))*-1*UFO::{}::Metric(2003,2005)+(UFO::{}::P(1004,1)*UFO::{}::P(2003,2)+UFO::{}::P(1004,2)*UFO::{}::P(2003,1))*UFO::{}::Metric(2004,2005)+UFO::{}::Metric(2003,1004)*UFO::{}::P(2004,1)*UFO::{}::P(2005,2)+UFO::{}::Metric(2003,1004)*UFO::{}::P(2004,2)*UFO::{}::P(2005,1)+UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,1)*UFO::{}::P(2005,2)+UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2005,1)+UFO::{}::Metric(2005,1004)*UFO::{}::P(2003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(2005,1004)*UFO::{}::P(2003,2)*UFO::{}::P(2004,1))*UFO::{}::Metric(1003,1005)+((UFO::{}::P(1003,1)*UFO::{}::P(2003,2)+UFO::{}::P(1003,2)*UFO::{}::P(2003,1))*-1*UFO::{}::Metric(2004,2005)+-1*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,2005)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(2005,2)+UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(2005,1)+UFO::{}::Metric(2003,2005)*UFO::{}::P(1003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(2003,2005)*UFO::{}::P(1003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(2004,1003)*UFO::{}::P(2003,1)*UFO::{}::P(2005,2)+UFO::{}::Metric(2004,1003)*UFO::{}::P(2003,2)*UFO::{}::P(2005,1)+UFO::{}::Metric(2005,1003)*UFO::{}::P(2003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(2005,1003)*UFO::{}::P(2003,2)*UFO::{}::P(2004,1))*UFO::{}::Metric(1004,1005)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::Metric(2005,1005)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1005,1)*UFO::{}::P(2005,2)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1005,2)*UFO::{}::P(2005,1)+-1*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1005)*UFO::{}::Metric(2005,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::Metric(2005,1005)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1005,1)*UFO::{}::P(2005,2)+-1*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1005,2)*UFO::{}::P(2005,1)+-1*UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2004,1004)*UFO::{}::Metric(2005,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2005,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2004,2)+-1*UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2005,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2004,1)+-1*UFO::{}::Metric(2004,1005)*UFO::{}::Metric(2005,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2003,2)+-1*UFO::{}::Metric(2004,1005)*UFO::{}::Metric(2005,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1005)*UFO::{}::P(2004,1)*UFO::{}::P(2005,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1005)*UFO::{}::P(2004,2)*UFO::{}::P(2005,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2005)*UFO::{}::P(1005,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2005)*UFO::{}::P(1005,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2004,1005)*UFO::{}::P(2003,1)*UFO::{}::P(2005,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2004,1005)*UFO::{}::P(2003,2)*UFO::{}::P(2005,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2004,2005)*UFO::{}::P(1005,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2004,2005)*UFO::{}::P(1005,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::Metric(2005,1005)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1005)*UFO::{}::P(1003,1)*UFO::{}::P(2005,2)+UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1005)*UFO::{}::P(1003,2)*UFO::{}::P(2005,1)+UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,2005)*UFO::{}::P(1003,1)*UFO::{}::P(1005,2)+UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,2005)*UFO::{}::P(1003,2)*UFO::{}::P(1005,1)+UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2005,1003)*UFO::{}::P(1005,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2005,1003)*UFO::{}::P(1005,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2005,2)+UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2005,1)+UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2004,2005)*UFO::{}::P(1003,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2004,2005)*UFO::{}::P(1003,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2005,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(2003,1005)*UFO::{}::Metric(2005,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(2003,2004)*UFO::{}::Metric(2005,1003)*UFO::{}::P(1004,1)*UFO::{}::P(1005,2)+UFO::{}::Metric(2003,2004)*UFO::{}::Metric(2005,1003)*UFO::{}::P(1004,2)*UFO::{}::P(1005,1)+UFO::{}::Metric(2003,2004)*UFO::{}::Metric(2005,1004)*UFO::{}::P(1003,1)*UFO::{}::P(1005,2)+UFO::{}::Metric(2003,2004)*UFO::{}::Metric(2005,1004)*UFO::{}::P(1003,2)*UFO::{}::P(1005,1)+UFO::{}::Metric(2003,2005)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(1005,2)+UFO::{}::Metric(2003,2005)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(1005,1)+UFO::{}::Metric(2003,2005)*UFO::{}::Metric(2004,1005)*UFO::{}::P(1003,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(2003,2005)*UFO::{}::Metric(2004,1005)*UFO::{}::P(1003,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(2004,1003)*UFO::{}::Metric(2005,1004)*UFO::{}::P(1005,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(2004,1003)*UFO::{}::Metric(2005,1004)*UFO::{}::P(1005,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(2004,1005)*UFO::{}::Metric(2005,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(2004,1005)*UFO::{}::Metric(2005,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2003,1)"
+    },
+    {
+      "name": "TTT",
+      "spins": [
+        5,
+        5,
+        5
+      ],
+      "structure": "((UFO::{}::P(1001,2)*UFO::{}::P(2003,1)+UFO::{}::P(1001,3)*UFO::{}::P(2003,2))*UFO::{}::Metric(2001,1002)+(UFO::{}::P(2001,2)*UFO::{}::P(2003,1)+UFO::{}::P(2001,3)*UFO::{}::P(2003,2))*UFO::{}::Metric(1001,1002)+-2*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(2001,2003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,3)+UFO::{}::Metric(2001,2003)*UFO::{}::P(1001,3)*UFO::{}::P(1002,1)+UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2001,2))*-1*UFO::{}::Metric(2002,1003)+((UFO::{}::P(1003,1)*UFO::{}::P(2001,2)+UFO::{}::P(1003,2)*UFO::{}::P(2001,3))*UFO::{}::Metric(2003,1002)+(UFO::{}::P(2001,2)*UFO::{}::P(2003,1)+UFO::{}::P(2001,3)*UFO::{}::P(2003,2))*UFO::{}::Metric(1002,1003)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,2003)*UFO::{}::P(1002,1)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2003)*UFO::{}::P(1002,3)*UFO::{}::P(1003,1))*-1*UFO::{}::Metric(2002,1001)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::P(2002,1)*UFO::{}::P(2003,2)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::P(2002,3)*UFO::{}::P(2003,1)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::P(1003,1)*UFO::{}::P(2002,3)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::P(1003,2)*UFO::{}::P(2002,1)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,1)*UFO::{}::P(2001,2)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,2)*UFO::{}::P(2001,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::P(2002,1)*UFO::{}::P(2003,2)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::P(2002,3)*UFO::{}::P(2003,1)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::P(1002,1)*UFO::{}::P(2003,2)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::P(1002,3)*UFO::{}::P(2003,1)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,1)*UFO::{}::P(2001,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,3)*UFO::{}::P(2001,2)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2002,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2002,1)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::P(1001,2)*UFO::{}::P(2003,1)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::P(1001,3)*UFO::{}::P(2003,2)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::P(1001,2)*UFO::{}::P(2002,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::P(1001,3)*UFO::{}::P(2002,1)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,2)*UFO::{}::P(2002,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2002,1)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(1003,1)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(1003,2)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2002,3)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2002,1)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,3)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(1002,1)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2002,3)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2002,1)+-1*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1003,2)+-1*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,1)+-1*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1003,1)+-1*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,2)+2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::P(1003,1)*UFO::{}::P(2003,2)+2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::P(1003,2)*UFO::{}::P(2003,1)+2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::P(1002,1)*UFO::{}::P(2002,3)+2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::P(1002,3)*UFO::{}::P(2002,1)+2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(2001,3)+2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(2001,2)+2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2002,3)+2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2002,1)"
+    },
+    {
+      "name": "TTTT",
+      "spins": [
+        5,
+        5,
+        5,
+        5
+      ],
+      "structure": "-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+-1*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+-1*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+-1*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,4)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,4)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,4)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,4)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,3)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,4)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,3)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,3)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,4)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,4)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,4)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,4)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,1)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,1)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,2)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,1)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,1)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,3)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,3)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,4)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,4)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,1)*UFO::{}::P(1003,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,1)*UFO::{}::P(1003,4)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,3)*UFO::{}::P(1003,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,3)*UFO::{}::P(1003,4)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,4)*UFO::{}::P(1003,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,4)*UFO::{}::P(1003,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2001,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1004,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1004,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2002,1)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2002,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,1)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,1)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1003,2)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1003,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2002,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2002,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1003,1)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1003,4)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,2)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,4)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1003,1)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1003,2)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1002)*UFO::{}::P(2003,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1002)*UFO::{}::P(2003,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,4)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,4)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,3)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,4)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1002,1)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1002,4)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1002,1)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1002,3)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,1)*UFO::{}::P(1003,4)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,4)*UFO::{}::P(1003,1)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,1)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,3)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2004,1)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2004,2)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2004,3)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2003,4)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2003,1)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2003,2)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1003,2)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1003,4)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,1)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,4)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1003,1)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1003,2)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2002,3)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2002,4)+-2*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2002,1)+-2*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(1002,4)+-2*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,4)*UFO::{}::P(1002,3)+-2*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,3)+-2*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,4)+-2*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(1002,1)+-2*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(1002,4)+-2*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1002,1)+-2*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1002,3)+-2*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(1003,4)+-2*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,4)*UFO::{}::P(1003,2)+-2*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1003,1)+-2*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1003,4)+-2*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,2)+-2*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,4)+-2*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1003,1)+-2*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1003,2)+-2*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,3)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1004,1)+-2*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1004,2)+-2*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1004,3)+-2*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2001,2)+-2*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2001,3)+-2*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2001,4)+-2*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2001,2)+-4*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,4)*UFO::{}::P(2004,3)+-4*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2002,1)+-4*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2004,3)+-4*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(1004,3)+-4*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2003,4)+-4*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2002,1)+-4*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,4)*UFO::{}::P(2004,2)+-4*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2003,1)+-4*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2004,2)+-4*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1004,2)+-4*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2002,4)+-4*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2003,1)+-4*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,3)*UFO::{}::P(2003,2)+-4*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,4)*UFO::{}::P(2004,1)+-4*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2003,2)+-4*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,3)*UFO::{}::P(1003,2)+-4*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2002,3)+-4*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2004,1)+-4*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,1)+-4*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2003,2)+-4*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(1004,1)+-4*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2001,4)+-4*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,1)+-4*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2004,2)+-4*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,1)+-4*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2001,3)+-4*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,4)*UFO::{}::P(2004,3)+-4*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,1)+-4*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,1)+-4*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,2)+-4*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2004,3)+-4*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(1004,3)+-4*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2003,4)+-4*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2002,1)+-4*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2004,2)+-4*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2003,1)+-4*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1004,2)+-4*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2002,4)+-4*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2004,1)+-4*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2003,2)+-4*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,2)+-4*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2002,3)+-4*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,1)+-4*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,1)+-4*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1004,1)+-4*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2001,2)+-4*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2001,4)+-4*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2001,3)+6*UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+6*UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+6*UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+6*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+6*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+6*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+6*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(-1,1)*UFO::{}::P(-1,2)+6*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(-1,1)*UFO::{}::P(-1,4)+6*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(-1,1)*UFO::{}::P(-1,3)+6*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(-1,3)*UFO::{}::P(-1,4)+6*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(-1,2)*UFO::{}::P(-1,4)+6*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(-1,2)*UFO::{}::P(-1,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(2003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(2003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(2003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(2003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1004,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2002,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,1)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(2003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(2003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(2003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(2003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2002,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1003,1)*UFO::{}::P(1004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1003,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1003,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1003,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,2)*UFO::{}::P(1004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2001,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1003,4)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::P(2002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(2001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::P(2003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::P(2003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::P(2003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::P(2003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1004,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2002,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,1)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::P(2003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::P(2003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2002,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2002,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,1)*UFO::{}::P(1004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,3)*UFO::{}::P(1004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::P(2003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::P(2002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(2001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(2001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::P(2003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::P(2003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::P(2003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::P(2003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2002,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::P(2003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::P(2003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2002,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2002,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(1003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,1)*UFO::{}::P(1003,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2001,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2001,2)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1001,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::P(2003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::P(2003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2001,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(2001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,2)*UFO::{}::P(2001,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1004,3)*UFO::{}::P(2001,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2001,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(2001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::P(2003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::P(2003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(2003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1003,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(1003,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(1003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::P(2001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,2)*UFO::{}::P(2001,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1003,4)*UFO::{}::P(2001,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2001,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2001,2)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(2001,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2002,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1002,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,3)*UFO::{}::P(1002,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,2003)*UFO::{}::P(1001,4)*UFO::{}::P(1002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2001,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2001,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2001,2)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(2001,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(1003,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(2001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,2)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,4)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,1)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,2)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,4)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,4)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1002,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,4)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,3)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,4)*UFO::{}::P(1002,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,1)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1004,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,1)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1002,4)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2004,3)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2004,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2004,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,3)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,3)*UFO::{}::P(1002,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,2004)*UFO::{}::P(1001,4)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2003,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(2003,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,3)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(1002,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2003)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2002,2004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(2002,3)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(2002,4)+UFO::{}::Metric(2001,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(2002,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,1)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,2002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,1)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,3)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1001,3)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,4)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,3)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,2003)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1002,3)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,2)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1003,4)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,1)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1002,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,1)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1002,4)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,1)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1003,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,3)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,4)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1004,3)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1004,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1004,2)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,2)*UFO::{}::P(1002,3)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,3)*UFO::{}::P(1002,4)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::P(1001,4)*UFO::{}::P(1002,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,1)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::P(1002,4)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,2)*UFO::{}::P(1003,4)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,3)*UFO::{}::P(1003,2)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::P(1001,4)*UFO::{}::P(1003,1)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,2)*UFO::{}::P(1002,4)+UFO::{}::Metric(2001,2004)*UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::P(1001,4)*UFO::{}::P(1002,1)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,2)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1003,2)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,2)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1001)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1003,4)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1004,3)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1002)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,2)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1002)*UFO::{}::P(1004,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1004)*UFO::{}::P(1002,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,3)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1003)*UFO::{}::Metric(2003,1004)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,3)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1001)*UFO::{}::Metric(2004,1003)*UFO::{}::P(1002,4)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,2)*UFO::{}::P(2001,3)+UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1002)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1003,4)*UFO::{}::P(2001,2)+UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,1)*UFO::{}::P(2001,4)+UFO::{}::Metric(2002,1004)*UFO::{}::Metric(2003,1003)*UFO::{}::Metric(2004,1001)*UFO::{}::P(1002,4)*UFO::{}::P(2001,2)"
+    }
+  ],
+  "name": "scalar_gravity",
+  "orders": [
+    {
+      "expansion_order": 99,
+      "hierarchy": 1,
+      "name": "QCD"
+    },
+    {
+      "expansion_order": 99,
+      "hierarchy": 2,
+      "name": "QED"
+    },
+    {
+      "expansion_order": 99,
+      "hierarchy": 0,
+      "name": "GRAV"
+    }
+  ],
+  "parameters": [
+    {
+      "expression": null,
+      "lhablock": "GRAVITY",
+      "lhacode": [
+        1337
+      ],
+      "name": "kappa",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "GRAVITY",
+      "lhacode": [
+        1338
+      ],
+      "name": "dim",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        4.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        2002
+      ],
+      "name": "mass_scalar_1",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        3002
+      ],
+      "name": "width_scalar_1",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        2003
+      ],
+      "name": "mass_scalar_2",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        2.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        3003
+      ],
+      "name": "width_scalar_2",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        1
+      ],
+      "name": "aEWM1",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        132.50698,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        2
+      ],
+      "name": "Gf",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.16639e-05,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        3
+      ],
+      "name": "aS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.118,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ZERO",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::aEWM1^(-1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "aEW",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.00754677225305414,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::aS^(1/2)*𝜋^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "G",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        1.2177157847767195,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::aEW^(1/2)*𝜋^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ee",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.3079537904849374,
+        0.0
+      ]
+    }
+  ],
+  "particles": [
+    {
+      "antiname": "scalar_0",
+      "antitexname": "\\phi_0",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "scalar_0",
+      "pdg_code": 2000,
+      "propagating": true,
+      "propagator": "scalar_0_propFeynman",
+      "spin": 1,
+      "texname": "\\phi_0",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "scalar_1",
+      "antitexname": "\\phi_1",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "mass_scalar_1",
+      "name": "scalar_1",
+      "pdg_code": 2001,
+      "propagating": true,
+      "propagator": "scalar_1_propFeynman",
+      "spin": 1,
+      "texname": "\\phi_1",
+      "width": "width_scalar_1",
+      "y_charge": 0
+    },
+    {
+      "antiname": "scalar_2",
+      "antitexname": "\\phi_2",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "mass_scalar_2",
+      "name": "scalar_2",
+      "pdg_code": 2002,
+      "propagating": true,
+      "propagator": "scalar_2_propFeynman",
+      "spin": 1,
+      "texname": "\\phi_2",
+      "width": "width_scalar_2",
+      "y_charge": 0
+    },
+    {
+      "antiname": "graviton",
+      "antitexname": "\\tilde{g}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "graviton",
+      "pdg_code": 1337,
+      "propagating": true,
+      "propagator": "graviton_propFeynman",
+      "spin": 5,
+      "texname": "\\tilde{g}",
+      "width": "ZERO",
+      "y_charge": 0
+    }
+  ],
+  "propagators": [
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "scalar_0_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "scalar_0"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::mass_scalar_1^2",
+      "name": "scalar_1_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "scalar_1"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::mass_scalar_2^2",
+      "name": "scalar_2_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "scalar_2"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "graviton_propFeynman",
+      "numerator": "((-2+UFO::{}::dim)^(-1)*-2*UFO::{}::Metric(1001,2001)*UFO::{}::Metric(1002,2002)+UFO::{}::Metric(1001,1002)*UFO::{}::Metric(2001,2002)+UFO::{}::Metric(1001,2002)*UFO::{}::Metric(2001,1002))*1𝑖/2",
+      "particle": "graviton"
+    }
+  ],
+  "restriction": null,
+  "vertex_rules": [
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SSTmpart0",
+          "SST"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSTmpart",
+        "SST"
+      ],
+      "name": "V_S0S0Gr",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "graviton"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SSTTmpart0",
+          "SSTT"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSTTmpart",
+        "SSTT"
+      ],
+      "name": "V_S0S0GrGr",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "graviton",
+        "graviton"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SSTTTmpart0",
+          "SSTTT"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSTTTmpart",
+        "SSTTT"
+      ],
+      "name": "V_S0S0GrGrGr",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "graviton",
+        "graviton",
+        "graviton"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SSTmpart1",
+          "SST"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSTmpart",
+        "SST"
+      ],
+      "name": "V_S1S1Gr",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "graviton"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SSTTmpart1",
+          "SSTT"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSTTmpart",
+        "SSTT"
+      ],
+      "name": "V_S1S1GrGr",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "graviton",
+        "graviton"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SSTTTmpart1",
+          "SSTTT"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSTTTmpart",
+        "SSTTT"
+      ],
+      "name": "V_S1S1GrGrGr",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "graviton",
+        "graviton",
+        "graviton"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SSTmpart2",
+          "SST"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSTmpart",
+        "SST"
+      ],
+      "name": "V_S2S2Gr",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "graviton"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SSTTmpart2",
+          "SSTT"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSTTmpart",
+        "SSTT"
+      ],
+      "name": "V_S2S2GrGr",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "graviton",
+        "graviton"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SSTTTmpart2",
+          "SSTTT"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSTTTmpart",
+        "SSTTT"
+      ],
+      "name": "V_S2S2GrGrGr",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "graviton",
+        "graviton",
+        "graviton"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "TTT"
+        ]
+      ],
+      "lorentz_structures": [
+        "TTT"
+      ],
+      "name": "V_GrGrGr",
+      "particles": [
+        "graviton",
+        "graviton",
+        "graviton"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "TTTT"
+        ]
+      ],
+      "lorentz_structures": [
+        "TTTT"
+      ],
+      "name": "V_GrGrGrGr",
+      "particles": [
+        "graviton",
+        "graviton",
+        "graviton",
+        "graviton"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/scalars/restrict_default.json b/pyamplicol/src/pyamplicol/assets/models/json/scalars/restrict_default.json
new file mode 100644
index 0000000000..29f8a712ac
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/scalars/restrict_default.json
@@ -0,0 +1,34 @@
+{
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "lam": [
+    1.0,
+    0.0
+  ],
+  "mass_scalar_1": [
+    1.0,
+    0.0
+  ],
+  "mass_scalar_2": [
+    2.0,
+    0.0
+  ],
+  "width_scalar_1": [
+    0.0,
+    0.0
+  ],
+  "width_scalar_2": [
+    0.0,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/scalars/scalars.json b/pyamplicol/src/pyamplicol/assets/models/json/scalars/scalars.json
new file mode 100644
index 0000000000..ea57faa89b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/scalars/scalars.json
@@ -0,0 +1,6972 @@
+{
+  "couplings": [
+    {
+      "expression": "1𝑖*UFO::{}::lam",
+      "name": "SCALAR_COUPLING",
+      "orders": [
+        [
+          "QCD",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        1.0
+      ]
+    }
+  ],
+  "form_factors": [],
+  "functions": [
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "complexconjugate"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "re"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "im"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "sec"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "asec"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "csc"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "acsc"
+    }
+  ],
+  "lorentz_structures": [
+    {
+      "name": "SCALAR_3_LORENTZ_STRUCTURE",
+      "spins": [
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "SCALAR_4_LORENTZ_STRUCTURE",
+      "spins": [
+        1,
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "SCALAR_5_LORENTZ_STRUCTURE",
+      "spins": [
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "SCALAR_6_LORENTZ_STRUCTURE",
+      "spins": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "SCALAR_7_LORENTZ_STRUCTURE",
+      "spins": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "SCALAR_8_LORENTZ_STRUCTURE",
+      "spins": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "SCALAR_9_LORENTZ_STRUCTURE",
+      "spins": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "SCALAR_10_LORENTZ_STRUCTURE",
+      "spins": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    }
+  ],
+  "name": "scalars",
+  "orders": [
+    {
+      "expansion_order": 99,
+      "hierarchy": 1,
+      "name": "QCD"
+    },
+    {
+      "expansion_order": 99,
+      "hierarchy": 2,
+      "name": "QED"
+    }
+  ],
+  "parameters": [
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        1337
+      ],
+      "name": "lam",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        2002
+      ],
+      "name": "mass_scalar_1",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        3002
+      ],
+      "name": "width_scalar_1",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        2003
+      ],
+      "name": "mass_scalar_2",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        2.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        3003
+      ],
+      "name": "width_scalar_2",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        1
+      ],
+      "name": "aEWM1",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        132.50698,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        2
+      ],
+      "name": "Gf",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.16639e-05,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        3
+      ],
+      "name": "aS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.118,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ZERO",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::aEWM1^(-1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "aEW",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.00754677225305414,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::aS^(1/2)*𝜋^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "G",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        1.2177157847767195,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::aEW^(1/2)*𝜋^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ee",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.3079537904849374,
+        0.0
+      ]
+    }
+  ],
+  "particles": [
+    {
+      "antiname": "scalar_0",
+      "antitexname": "\\phi_0",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "scalar_0",
+      "pdg_code": 1000,
+      "propagating": true,
+      "propagator": "scalar_0_propFeynman",
+      "spin": 1,
+      "texname": "\\phi_0",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "scalar_1",
+      "antitexname": "\\phi_1",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "mass_scalar_1",
+      "name": "scalar_1",
+      "pdg_code": 1001,
+      "propagating": true,
+      "propagator": "scalar_1_propFeynman",
+      "spin": 1,
+      "texname": "\\phi_1",
+      "width": "width_scalar_1",
+      "y_charge": 0
+    },
+    {
+      "antiname": "scalar_2",
+      "antitexname": "\\phi_2",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "mass_scalar_2",
+      "name": "scalar_2",
+      "pdg_code": 1002,
+      "propagating": true,
+      "propagator": "scalar_2_propFeynman",
+      "spin": 1,
+      "texname": "\\phi_2",
+      "width": "width_scalar_2",
+      "y_charge": 0
+    }
+  ],
+  "propagators": [
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "scalar_0_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "scalar_0"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::mass_scalar_1^2",
+      "name": "scalar_1_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "scalar_1"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::mass_scalar_2^2",
+      "name": "scalar_2_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "scalar_2"
+    }
+  ],
+  "restriction": null,
+  "vertex_rules": [
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_000",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_001",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_002",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_011",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_012",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_022",
+      "particles": [
+        "scalar_0",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_111",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_112",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_122",
+      "particles": [
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_222",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_0000",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_0001",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_0002",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_0011",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_0012",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_0022",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_0111",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_0112",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_0122",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_0222",
+      "particles": [
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_1111",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_1112",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_1122",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_1222",
+      "particles": [
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_4_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_4_SCALAR_2222",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_00000",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_00001",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_00002",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_00011",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_00012",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_00022",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_00111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_00112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_00122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_00222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_01111",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_01112",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_01122",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_01222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_02222",
+      "particles": [
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_11111",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_11112",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_11122",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_11222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_12222",
+      "particles": [
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_5_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_5_SCALAR_22222",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_000000",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_000001",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_000002",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_000011",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_000012",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_000022",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_000111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_000112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_000122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_000222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_001111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_001112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_001122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_001222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_002222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_011111",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_011112",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_011122",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_011222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_012222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_022222",
+      "particles": [
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_111111",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_111112",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_111122",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_111222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_112222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_122222",
+      "particles": [
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_6_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_6_SCALAR_222222",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0000000",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0000001",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0000002",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0000011",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0000012",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0000022",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0000111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0000112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0000122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0000222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0001111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0001112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0001122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0001222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0002222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0011111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0011112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0011122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0011222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0012222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0022222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0111111",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0111112",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0111122",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0111222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0112222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0122222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_0222222",
+      "particles": [
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_1111111",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_1111112",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_1111122",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_1111222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_1112222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_1122222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_1222222",
+      "particles": [
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_7_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_7_SCALAR_2222222",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00000000",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00000001",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00000002",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00000011",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00000012",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00000022",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00000111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00000112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00000122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00000222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00001111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00001112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00001122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00001222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00002222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00011111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00011112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00011122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00011222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00012222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00022222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00111111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00111112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00111122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00111222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00112222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00122222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_00222222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_01111111",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_01111112",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_01111122",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_01111222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_01112222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_01122222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_01222222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_02222222",
+      "particles": [
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_11111111",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_11111112",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_11111122",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_11111222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_11112222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_11122222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_11222222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_12222222",
+      "particles": [
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_8_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_8_SCALAR_22222222",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000000000",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000000001",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000000002",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000000011",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000000012",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000000022",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000000111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000000112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000000122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000000222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000001111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000001112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000001122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000001222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000002222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000011111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000011112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000011122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000011222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000012222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000022222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000111111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000111112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000111122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000111222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000112222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000122222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_000222222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_001111111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_001111112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_001111122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_001111222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_001112222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_001122222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_001222222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_002222222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_011111111",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_011111112",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_011111122",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_011111222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_011112222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_011122222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_011222222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_012222222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_022222222",
+      "particles": [
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_111111111",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_111111112",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_111111122",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_111111222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_111112222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_111122222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_111222222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_112222222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_122222222",
+      "particles": [
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_9_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_9_SCALAR_222222222",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000000000",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000000001",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000000002",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000000011",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000000012",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000000022",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000000111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000000112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000000122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000000222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000001111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000001112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000001122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000001222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000002222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000011111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000011112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000011122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000011222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000012222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000022222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000111111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000111112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000111122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000111222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000112222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000122222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0000222222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0001111111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0001111112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0001111122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0001111222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0001112222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0001122222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0001222222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0002222222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0011111111",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0011111112",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0011111122",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0011111222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0011112222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0011122222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0011222222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0012222222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0022222222",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0111111111",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0111111112",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0111111122",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0111111222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0111112222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0111122222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0111222222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0112222222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0122222222",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_0222222222",
+      "particles": [
+        "scalar_0",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_1111111111",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_1111111112",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_1111111122",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_1111111222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_1111112222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_1111122222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_1111222222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_1112222222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_1122222222",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_1222222222",
+      "particles": [
+        "scalar_1",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_10_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_10_SCALAR_2222222222",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/scalars/scalars_2p_3p.json b/pyamplicol/src/pyamplicol/assets/models/json/scalars/scalars_2p_3p.json
new file mode 100644
index 0000000000..c21b4f8ffd
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/scalars/scalars_2p_3p.json
@@ -0,0 +1,591 @@
+{
+  "couplings": [
+    {
+      "expression": "1𝑖*UFO::{}::lam",
+      "name": "SCALAR_COUPLING",
+      "orders": [
+        [
+          "QCD",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        1.0
+      ]
+    }
+  ],
+  "form_factors": [],
+  "functions": [],
+  "lorentz_structures": [
+    {
+      "name": "SCALAR_2_LORENTZ_STRUCTURE",
+      "spins": [
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "SCALAR_3_LORENTZ_STRUCTURE",
+      "spins": [
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    }
+  ],
+  "name": "scalars",
+  "orders": [
+    {
+      "expansion_order": 99,
+      "hierarchy": 1,
+      "name": "QCD"
+    },
+    {
+      "expansion_order": 99,
+      "hierarchy": 2,
+      "name": "QED"
+    }
+  ],
+  "parameters": [
+    {
+      "expression": null,
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ZERO",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        1337
+      ],
+      "name": "lam",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        2002
+      ],
+      "name": "mass_scalar_1",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ZERO",
+      "lhablock": "SCALARS",
+      "lhacode": [
+        3002
+      ],
+      "name": "width_scalar_1",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SCALARS",
+      "lhacode": [
+        2003
+      ],
+      "name": "mass_scalar_2",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        2.0,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ZERO",
+      "lhablock": "SCALARS",
+      "lhacode": [
+        3003
+      ],
+      "name": "width_scalar_2",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        1
+      ],
+      "name": "aEWM1",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        132.507,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        2
+      ],
+      "name": "Gf",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.16639e-05,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        3
+      ],
+      "name": "aS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.118,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::aEWM1^(-1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "aEW",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.0075467711139788835,
+        -0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::aS^(1/2)*𝜋^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "G",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        1.2177157847767195,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::aEW^(1/2)*𝜋^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ee",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.3079537672443688,
+        0.0
+      ]
+    }
+  ],
+  "particles": [
+    {
+      "antiname": "scalar_0",
+      "antitexname": "\\phi_0",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "scalar_0",
+      "pdg_code": 1000,
+      "propagating": true,
+      "propagator": "scalar_0_propFeynman",
+      "spin": 1,
+      "texname": "\\phi_0",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "scalar_1",
+      "antitexname": "\\phi_1",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "mass_scalar_1",
+      "name": "scalar_1",
+      "pdg_code": 1001,
+      "propagating": true,
+      "propagator": "scalar_1_propFeynman",
+      "spin": 1,
+      "texname": "\\phi_1",
+      "width": "width_scalar_1",
+      "y_charge": 0
+    },
+    {
+      "antiname": "scalar_2",
+      "antitexname": "\\phi_2",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "mass_scalar_2",
+      "name": "scalar_2",
+      "pdg_code": 1002,
+      "propagating": true,
+      "propagator": "scalar_2_propFeynman",
+      "spin": 1,
+      "texname": "\\phi_2",
+      "width": "width_scalar_2",
+      "y_charge": 0
+    }
+  ],
+  "propagators": [
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "scalar_0_propFeynman",
+      "numerator": "1",
+      "particle": "scalar_0"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::mass_scalar_1^2",
+      "name": "scalar_1_propFeynman",
+      "numerator": "1",
+      "particle": "scalar_1"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::mass_scalar_2^2",
+      "name": "scalar_2_propFeynman",
+      "numerator": "1",
+      "particle": "scalar_2"
+    }
+  ],
+  "restriction": "default",
+  "vertex_rules": [
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_2_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_2_SCALAR_00",
+      "particles": [
+        "scalar_0",
+        "scalar_0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_2_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_2_SCALAR_01",
+      "particles": [
+        "scalar_0",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_2_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_2_SCALAR_02",
+      "particles": [
+        "scalar_0",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_2_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_2_SCALAR_11",
+      "particles": [
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_2_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_2_SCALAR_12",
+      "particles": [
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_2_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_2_SCALAR_22",
+      "particles": [
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_000",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_001",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_002",
+      "particles": [
+        "scalar_0",
+        "scalar_0",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_011",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_012",
+      "particles": [
+        "scalar_0",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_022",
+      "particles": [
+        "scalar_0",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_111",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_1"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_112",
+      "particles": [
+        "scalar_1",
+        "scalar_1",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_122",
+      "particles": [
+        "scalar_1",
+        "scalar_2",
+        "scalar_2"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "SCALAR_COUPLING"
+        ]
+      ],
+      "lorentz_structures": [
+        "SCALAR_3_LORENTZ_STRUCTURE"
+      ],
+      "name": "V_3_SCALAR_222",
+      "particles": [
+        "scalar_2",
+        "scalar_2",
+        "scalar_2"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_c_mass.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_c_mass.json
new file mode 100644
index 0000000000..1caa7684d2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_c_mass.json
@@ -0,0 +1,106 @@
+{
+  "AWS": [
+    0.0,
+    0.0
+  ],
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "MB": [
+    4.7,
+    0.0
+  ],
+  "MC": [
+    1.55,
+    0.0
+  ],
+  "MH": [
+    125.0,
+    0.0
+  ],
+  "MM": [
+    0.0,
+    0.0
+  ],
+  "MT": [
+    173.0,
+    0.0
+  ],
+  "MTA": [
+    1.777,
+    0.0
+  ],
+  "MZ": [
+    91.188,
+    0.0
+  ],
+  "Me": [
+    0.0,
+    0.0
+  ],
+  "WH": [
+    0.00638233934,
+    0.0
+  ],
+  "WT": [
+    1.4915,
+    0.0
+  ],
+  "WTau": [
+    0.0,
+    0.0
+  ],
+  "WW": [
+    2.0476,
+    0.0
+  ],
+  "WZ": [
+    2.441404,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "etaWS": [
+    0.0,
+    0.0
+  ],
+  "lamWS": [
+    0.0,
+    0.0
+  ],
+  "rhoWS": [
+    0.0,
+    0.0
+  ],
+  "ymb": [
+    4.7,
+    0.0
+  ],
+  "ymc": [
+    1.55,
+    0.0
+  ],
+  "yme": [
+    0.0,
+    0.0
+  ],
+  "ymm": [
+    0.0,
+    0.0
+  ],
+  "ymt": [
+    173.0,
+    0.0
+  ],
+  "ymtau": [
+    1.777,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_ckm.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_ckm.json
new file mode 100644
index 0000000000..0747393d26
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_ckm.json
@@ -0,0 +1,106 @@
+{
+  "AWS": [
+    0.808,
+    0.0
+  ],
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "MB": [
+    4.7,
+    0.0
+  ],
+  "MC": [
+    0.0,
+    0.0
+  ],
+  "MH": [
+    125.0,
+    0.0
+  ],
+  "MM": [
+    0.0,
+    0.0
+  ],
+  "MT": [
+    173.0,
+    0.0
+  ],
+  "MTA": [
+    1.777,
+    0.0
+  ],
+  "MZ": [
+    91.188,
+    0.0
+  ],
+  "Me": [
+    0.0,
+    0.0
+  ],
+  "WH": [
+    0.00638233934,
+    0.0
+  ],
+  "WT": [
+    1.4915,
+    0.0
+  ],
+  "WTau": [
+    0.0,
+    0.0
+  ],
+  "WW": [
+    2.0476,
+    0.0
+  ],
+  "WZ": [
+    2.441404,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "etaWS": [
+    0.341,
+    0.0
+  ],
+  "lamWS": [
+    0.2253,
+    0.0
+  ],
+  "rhoWS": [
+    0.132,
+    0.0
+  ],
+  "ymb": [
+    4.7,
+    0.0
+  ],
+  "ymc": [
+    0.0,
+    0.0
+  ],
+  "yme": [
+    0.0,
+    0.0
+  ],
+  "ymm": [
+    0.0,
+    0.0
+  ],
+  "ymt": [
+    173.0,
+    0.0
+  ],
+  "ymtau": [
+    1.777,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_default.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_default.json
new file mode 100644
index 0000000000..91cdfff0c8
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_default.json
@@ -0,0 +1,106 @@
+{
+  "AWS": [
+    0.0,
+    0.0
+  ],
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "MB": [
+    4.7,
+    0.0
+  ],
+  "MC": [
+    0.0,
+    0.0
+  ],
+  "MH": [
+    125.0,
+    0.0
+  ],
+  "MM": [
+    0.0,
+    0.0
+  ],
+  "MT": [
+    173.0,
+    0.0
+  ],
+  "MTA": [
+    1.777,
+    0.0
+  ],
+  "MZ": [
+    91.188,
+    0.0
+  ],
+  "Me": [
+    0.0,
+    0.0
+  ],
+  "WH": [
+    0.00638233934,
+    0.0
+  ],
+  "WT": [
+    1.4915,
+    0.0
+  ],
+  "WTau": [
+    0.0,
+    0.0
+  ],
+  "WW": [
+    2.0476,
+    0.0
+  ],
+  "WZ": [
+    2.441404,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "etaWS": [
+    0.0,
+    0.0
+  ],
+  "lamWS": [
+    0.0,
+    0.0
+  ],
+  "rhoWS": [
+    0.0,
+    0.0
+  ],
+  "ymb": [
+    4.7,
+    0.0
+  ],
+  "ymc": [
+    0.0,
+    0.0
+  ],
+  "yme": [
+    0.0,
+    0.0
+  ],
+  "ymm": [
+    0.0,
+    0.0
+  ],
+  "ymt": [
+    173.0,
+    0.0
+  ],
+  "ymtau": [
+    1.777,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_lepton_masses.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_lepton_masses.json
new file mode 100644
index 0000000000..fc24994d66
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_lepton_masses.json
@@ -0,0 +1,106 @@
+{
+  "AWS": [
+    0.0,
+    0.0
+  ],
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "MB": [
+    4.7,
+    0.0
+  ],
+  "MC": [
+    0.0,
+    0.0
+  ],
+  "MH": [
+    125.0,
+    0.0
+  ],
+  "MM": [
+    0.10566,
+    0.0
+  ],
+  "MT": [
+    173.0,
+    0.0
+  ],
+  "MTA": [
+    1.777,
+    0.0
+  ],
+  "MZ": [
+    91.188,
+    0.0
+  ],
+  "Me": [
+    0.000511,
+    0.0
+  ],
+  "WH": [
+    0.00638233934,
+    0.0
+  ],
+  "WT": [
+    1.4915,
+    0.0
+  ],
+  "WTau": [
+    2.27e-12,
+    0.0
+  ],
+  "WW": [
+    2.0476,
+    0.0
+  ],
+  "WZ": [
+    2.441404,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "etaWS": [
+    0.0,
+    0.0
+  ],
+  "lamWS": [
+    0.0,
+    0.0
+  ],
+  "rhoWS": [
+    0.0,
+    0.0
+  ],
+  "ymb": [
+    4.7,
+    0.0
+  ],
+  "ymc": [
+    0.0,
+    0.0
+  ],
+  "yme": [
+    0.000511,
+    0.0
+  ],
+  "ymm": [
+    0.10566,
+    0.0
+  ],
+  "ymt": [
+    173.0,
+    0.0
+  ],
+  "ymtau": [
+    1.777,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_b_mass.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_b_mass.json
new file mode 100644
index 0000000000..cea4f7f1e0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_b_mass.json
@@ -0,0 +1,106 @@
+{
+  "AWS": [
+    0.0,
+    0.0
+  ],
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "MB": [
+    0.0,
+    0.0
+  ],
+  "MC": [
+    0.0,
+    0.0
+  ],
+  "MH": [
+    125.0,
+    0.0
+  ],
+  "MM": [
+    0.0,
+    0.0
+  ],
+  "MT": [
+    173.0,
+    0.0
+  ],
+  "MTA": [
+    1.777,
+    0.0
+  ],
+  "MZ": [
+    91.188,
+    0.0
+  ],
+  "Me": [
+    0.0,
+    0.0
+  ],
+  "WH": [
+    0.00638233934,
+    0.0
+  ],
+  "WT": [
+    1.4915,
+    0.0
+  ],
+  "WTau": [
+    0.0,
+    0.0
+  ],
+  "WW": [
+    2.0476,
+    0.0
+  ],
+  "WZ": [
+    2.441404,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "etaWS": [
+    0.0,
+    0.0
+  ],
+  "lamWS": [
+    0.0,
+    0.0
+  ],
+  "rhoWS": [
+    0.0,
+    0.0
+  ],
+  "ymb": [
+    0.0,
+    0.0
+  ],
+  "ymc": [
+    0.0,
+    0.0
+  ],
+  "yme": [
+    0.0,
+    0.0
+  ],
+  "ymm": [
+    0.0,
+    0.0
+  ],
+  "ymt": [
+    173.0,
+    0.0
+  ],
+  "ymtau": [
+    1.777,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_masses.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_masses.json
new file mode 100644
index 0000000000..2d575cfc72
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_masses.json
@@ -0,0 +1,106 @@
+{
+  "AWS": [
+    0.0,
+    0.0
+  ],
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "MB": [
+    0.0,
+    0.0
+  ],
+  "MC": [
+    0.0,
+    0.0
+  ],
+  "MH": [
+    125.0,
+    0.0
+  ],
+  "MM": [
+    0.0,
+    0.0
+  ],
+  "MT": [
+    173.0,
+    0.0
+  ],
+  "MTA": [
+    0.0,
+    0.0
+  ],
+  "MZ": [
+    91.188,
+    0.0
+  ],
+  "Me": [
+    0.0,
+    0.0
+  ],
+  "WH": [
+    0.00638233934,
+    0.0
+  ],
+  "WT": [
+    1.4915,
+    0.0
+  ],
+  "WTau": [
+    0.0,
+    0.0
+  ],
+  "WW": [
+    2.0476,
+    0.0
+  ],
+  "WZ": [
+    2.441404,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "etaWS": [
+    0.0,
+    0.0
+  ],
+  "lamWS": [
+    0.0,
+    0.0
+  ],
+  "rhoWS": [
+    0.0,
+    0.0
+  ],
+  "ymb": [
+    0.0,
+    0.0
+  ],
+  "ymc": [
+    0.0,
+    0.0
+  ],
+  "yme": [
+    0.0,
+    0.0
+  ],
+  "ymm": [
+    0.0,
+    0.0
+  ],
+  "ymt": [
+    173.0,
+    0.0
+  ],
+  "ymtau": [
+    0.0,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_tau_mass.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_tau_mass.json
new file mode 100644
index 0000000000..c503b11fa7
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_tau_mass.json
@@ -0,0 +1,106 @@
+{
+  "AWS": [
+    0.0,
+    0.0
+  ],
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "MB": [
+    4.7,
+    0.0
+  ],
+  "MC": [
+    0.0,
+    0.0
+  ],
+  "MH": [
+    125.0,
+    0.0
+  ],
+  "MM": [
+    0.0,
+    0.0
+  ],
+  "MT": [
+    173.0,
+    0.0
+  ],
+  "MTA": [
+    0.0,
+    0.0
+  ],
+  "MZ": [
+    91.188,
+    0.0
+  ],
+  "Me": [
+    0.0,
+    0.0
+  ],
+  "WH": [
+    0.00638233934,
+    0.0
+  ],
+  "WT": [
+    1.4915,
+    0.0
+  ],
+  "WTau": [
+    0.0,
+    0.0
+  ],
+  "WW": [
+    2.0476,
+    0.0
+  ],
+  "WZ": [
+    2.441404,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "etaWS": [
+    0.0,
+    0.0
+  ],
+  "lamWS": [
+    0.0,
+    0.0
+  ],
+  "rhoWS": [
+    0.0,
+    0.0
+  ],
+  "ymb": [
+    4.7,
+    0.0
+  ],
+  "ymc": [
+    0.0,
+    0.0
+  ],
+  "yme": [
+    0.0,
+    0.0
+  ],
+  "ymm": [
+    0.0,
+    0.0
+  ],
+  "ymt": [
+    173.0,
+    0.0
+  ],
+  "ymtau": [
+    0.0,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_widths.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_widths.json
new file mode 100644
index 0000000000..50ddc241c1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_no_widths.json
@@ -0,0 +1,106 @@
+{
+  "AWS": [
+    0.0,
+    0.0
+  ],
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "MB": [
+    4.7,
+    0.0
+  ],
+  "MC": [
+    0.0,
+    0.0
+  ],
+  "MH": [
+    120.0,
+    0.0
+  ],
+  "MM": [
+    0.0,
+    0.0
+  ],
+  "MT": [
+    173.0,
+    0.0
+  ],
+  "MTA": [
+    1.777,
+    0.0
+  ],
+  "MZ": [
+    91.188,
+    0.0
+  ],
+  "Me": [
+    0.0,
+    0.0
+  ],
+  "WH": [
+    0.0,
+    0.0
+  ],
+  "WT": [
+    0.0,
+    0.0
+  ],
+  "WTau": [
+    0.0,
+    0.0
+  ],
+  "WW": [
+    0.0,
+    0.0
+  ],
+  "WZ": [
+    0.0,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "etaWS": [
+    0.0,
+    0.0
+  ],
+  "lamWS": [
+    0.0,
+    0.0
+  ],
+  "rhoWS": [
+    0.0,
+    0.0
+  ],
+  "ymb": [
+    4.2,
+    0.0
+  ],
+  "ymc": [
+    0.0,
+    0.0
+  ],
+  "yme": [
+    0.0,
+    0.0
+  ],
+  "ymm": [
+    0.0,
+    0.0
+  ],
+  "ymt": [
+    164.5,
+    0.0
+  ],
+  "ymtau": [
+    1.777,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_zeromass_ckm.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_zeromass_ckm.json
new file mode 100644
index 0000000000..cbe68c5f43
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/restrict_zeromass_ckm.json
@@ -0,0 +1,106 @@
+{
+  "AWS": [
+    0.808,
+    0.0
+  ],
+  "Gf": [
+    1.16639e-05,
+    0.0
+  ],
+  "MB": [
+    0.0,
+    0.0
+  ],
+  "MC": [
+    0.0,
+    0.0
+  ],
+  "MH": [
+    125.0,
+    0.0
+  ],
+  "MM": [
+    0.0,
+    0.0
+  ],
+  "MT": [
+    173.0,
+    0.0
+  ],
+  "MTA": [
+    0.0,
+    0.0
+  ],
+  "MZ": [
+    91.188,
+    0.0
+  ],
+  "Me": [
+    0.0,
+    0.0
+  ],
+  "WH": [
+    0.00638233934,
+    0.0
+  ],
+  "WT": [
+    1.4915,
+    0.0
+  ],
+  "WTau": [
+    0.0,
+    0.0
+  ],
+  "WW": [
+    2.0476,
+    0.0
+  ],
+  "WZ": [
+    2.441404,
+    0.0
+  ],
+  "aEWM1": [
+    132.507,
+    0.0
+  ],
+  "aS": [
+    0.118,
+    0.0
+  ],
+  "etaWS": [
+    0.341,
+    0.0
+  ],
+  "lamWS": [
+    0.2253,
+    0.0
+  ],
+  "rhoWS": [
+    0.132,
+    0.0
+  ],
+  "ymb": [
+    0.0,
+    0.0
+  ],
+  "ymc": [
+    0.0,
+    0.0
+  ],
+  "yme": [
+    0.0,
+    0.0
+  ],
+  "ymm": [
+    0.0,
+    0.0
+  ],
+  "ymt": [
+    173.0,
+    0.0
+  ],
+  "ymtau": [
+    0.0,
+    0.0
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/sm.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/sm.json
new file mode 100644
index 0000000000..618095a67d
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/sm.json
@@ -0,0 +1,6721 @@
+{
+  "couplings": [
+    {
+      "expression": "-1𝑖/3*UFO::{}::ee",
+      "name": "GC_1",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.10265126349497912
+      ]
+    },
+    {
+      "expression": "2𝑖/3*UFO::{}::ee",
+      "name": "GC_2",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.20530252698995824
+      ]
+    },
+    {
+      "expression": "-1𝑖*UFO::{}::ee",
+      "name": "GC_3",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.3079537904849374
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::ee",
+      "name": "GC_4",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.3079537904849374
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::ee^2",
+      "name": "GC_5",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.0948355370740407
+      ]
+    },
+    {
+      "expression": "2𝑖*UFO::{}::ee^2",
+      "name": "GC_6",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.1896710741480814
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::cw^(-1)*UFO::{}::ee^2",
+      "name": "GC_7",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        -0.053767535985328165,
+        0.0
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::cw^(-1)*UFO::{}::ee^2",
+      "name": "GC_8",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.053767535985328165
+      ]
+    },
+    {
+      "expression": "1/2*UFO::{}::cw^(-1)*UFO::{}::ee^2",
+      "name": "GC_9",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.053767535985328165,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::G",
+      "name": "GC_10",
+      "orders": [
+        [
+          "QCD",
+          1
+        ]
+      ],
+      "value": [
+        -1.2177157847767195,
+        0.0
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::G",
+      "name": "GC_11",
+      "orders": [
+        [
+          "QCD",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        1.2177157847767195
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::G^2",
+      "name": "GC_12",
+      "orders": [
+        [
+          "QCD",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        1.4828317324943818
+      ]
+    },
+    {
+      "expression": "UFO::{}::I1x31",
+      "name": "GC_13",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        2.9424734175077786e-05,
+        7.601389661895094e-05
+      ]
+    },
+    {
+      "expression": "UFO::{}::I1x32",
+      "name": "GC_14",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0009894125736418036,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I1x33",
+      "name": "GC_15",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.024123686777011728,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x12",
+      "name": "GC_16",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0016434606240936052,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x13",
+      "name": "GC_17",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.007578355147768138,
+        -0.0029772109509089116
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x22",
+      "name": "GC_18",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.007109407543268448,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x23",
+      "name": "GC_19",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0387519924676373,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x32",
+      "name": "GC_20",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.00029917951631549774,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x33",
+      "name": "GC_21",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.9448443987662926,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x21",
+      "name": "GC_22",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.0016434606240936052,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x22",
+      "name": "GC_23",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.007109407543268448,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x23",
+      "name": "GC_24",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.00029917951631549774,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x31",
+      "name": "GC_25",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.007578355147768138,
+        -0.0029772109509089116
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x32",
+      "name": "GC_26",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.0387519924676373,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x33",
+      "name": "GC_27",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.9448443987662926,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I4x13",
+      "name": "GC_28",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -2.9424734175077786e-05,
+        7.601389661895094e-05
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I4x23",
+      "name": "GC_29",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.0009894125736418036,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I4x33",
+      "name": "GC_30",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.024123686777011728,
+        0.0
+      ]
+    },
+    {
+      "expression": "-2𝑖*UFO::{}::lam",
+      "name": "GC_31",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.25773821203380554
+      ]
+    },
+    {
+      "expression": "-4𝑖*UFO::{}::lam",
+      "name": "GC_32",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.5154764240676111
+      ]
+    },
+    {
+      "expression": "-6𝑖*UFO::{}::lam",
+      "name": "GC_33",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.7732146361014166
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::ee^2*UFO::{}::sw^(-2)",
+      "name": "GC_34",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.2133566177614792
+      ]
+    },
+    {
+      "expression": "-1𝑖*UFO::{}::ee^2*UFO::{}::sw^(-2)",
+      "name": "GC_35",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.4267132355229584
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::cw^2*UFO::{}::ee^2*UFO::{}::sw^(-2)",
+      "name": "GC_36",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.3318776984489177
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_37",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.326616455312251,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1𝑖/2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_38",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.326616455312251
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_39",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.326616455312251
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_40",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.46190542079681124
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM1x1*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_41",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.4501822404312442
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM1x2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_42",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.10406729130552157
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM1x3*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_43",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.001455467036557634,
+        0.0005634065947965036
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM2x1*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_44",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.10406729130552157
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM2x2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_45",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.4501822404312442
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM2x3*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_46",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.01894465947075628
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM3x1*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_47",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.001455467036557634,
+        0.003704825183964887
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM3x2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_48",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.01894465947075628
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM3x3*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_49",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.46190542079681124
+      ]
+    },
+    {
+      "expression": "-1𝑖/2*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_50",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.2880441365697789
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_51",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.2880441365697789
+      ]
+    },
+    {
+      "expression": "-1𝑖*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_52",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.5760882731395578
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_53",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.5760882731395578
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::ee^2*UFO::{}::sw^(-1)",
+      "name": "GC_54",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        -0.10058277544816184,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1𝑖/2*UFO::{}::ee^2*UFO::{}::sw^(-1)",
+      "name": "GC_55",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.10058277544816184
+      ]
+    },
+    {
+      "expression": "1/2*UFO::{}::ee^2*UFO::{}::sw^(-1)",
+      "name": "GC_56",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.10058277544816184,
+        0.0
+      ]
+    },
+    {
+      "expression": "-2𝑖*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-1)",
+      "name": "GC_57",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.35481713473449755
+      ]
+    },
+    {
+      "expression": "-1𝑖/6*UFO::{}::cw^(-1)*UFO::{}::ee*UFO::{}::sw",
+      "name": "GC_58",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.027436633555365665
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::cw^(-1)*UFO::{}::ee*UFO::{}::sw",
+      "name": "GC_59",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.082309900666097
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)+-1/2*UFO::{}::cw^(-1)*UFO::{}::ee*UFO::{}::sw",
+      "name": "GC_60",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.3703540372358759,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1𝑖/2*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)+1𝑖/2*UFO::{}::cw^(-1)*UFO::{}::ee*UFO::{}::sw",
+      "name": "GC_61",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.2057342359036819
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)+1𝑖/2*UFO::{}::cw^(-1)*UFO::{}::ee*UFO::{}::sw",
+      "name": "GC_62",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.3703540372358759
+      ]
+    },
+    {
+      "expression": "-1𝑖*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::sw+1𝑖*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-1)",
+      "name": "GC_63",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.12671327555812228
+      ]
+    },
+    {
+      "expression": "-1𝑖*UFO::{}::ee^2+1𝑖/2*UFO::{}::cw^(-2)*UFO::{}::ee^2*UFO::{}::sw^2+1𝑖/2*UFO::{}::cw^2*UFO::{}::ee^2*UFO::{}::sw^(-2)",
+      "name": "GC_64",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.08465315164574365
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::ee^2+1𝑖/2*UFO::{}::cw^(-2)*UFO::{}::ee^2*UFO::{}::sw^2+1𝑖/2*UFO::{}::cw^2*UFO::{}::ee^2*UFO::{}::sw^(-2)",
+      "name": "GC_65",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.27432422579382504
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev",
+      "name": "GC_66",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -13.23855980624142,
+        0.0
+      ]
+    },
+    {
+      "expression": "1/2*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev",
+      "name": "GC_67",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        13.23855980624142,
+        0.0
+      ]
+    },
+    {
+      "expression": "-2𝑖*UFO::{}::lam*UFO::{}::vev",
+      "name": "GC_68",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -63.459905160882585
+      ]
+    },
+    {
+      "expression": "-6𝑖*UFO::{}::lam*UFO::{}::vev",
+      "name": "GC_69",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -190.37971548264773
+      ]
+    },
+    {
+      "expression": "-1/4*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_70",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -26.266168725525,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1𝑖/4*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_71",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -26.266168725525
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_72",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        52.53233745105
+      ]
+    },
+    {
+      "expression": "1/4*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_73",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        26.266168725525,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::ee^2*UFO::{}::sw^(-1)*UFO::{}::vev",
+      "name": "GC_74",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -24.76533588244763,
+        0.0
+      ]
+    },
+    {
+      "expression": "1/2*UFO::{}::ee^2*UFO::{}::sw^(-1)*UFO::{}::vev",
+      "name": "GC_75",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        24.76533588244763,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/4*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev+-1/4*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev",
+      "name": "GC_76",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -29.78350132701354,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/4*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev+1/4*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev",
+      "name": "GC_77",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -16.54494152077212,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/4*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev+1/4*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_78",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        16.54494152077212,
+        0.0
+      ]
+    },
+    {
+      "expression": "1/4*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev+1/4*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev",
+      "name": "GC_79",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        29.78350132701354,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1𝑖/2*UFO::{}::ee^2*UFO::{}::vev+-1𝑖/4*UFO::{}::cw^(-2)*UFO::{}::ee^2*UFO::{}::sw^2*UFO::{}::vev+-1𝑖/4*UFO::{}::cw^2*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_80",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -33.77184394746505
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::ee^2*UFO::{}::vev+1𝑖/2*UFO::{}::cw^(-2)*UFO::{}::ee^2*UFO::{}::sw^2*UFO::{}::vev+1𝑖/2*UFO::{}::cw^2*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_81",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        67.5436878949301
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1*UFO::{}::yb",
+      "name": "GC_82",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.01705802250724524,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::yb",
+      "name": "GC_83",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.01705802250724524
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::yc",
+      "name": "GC_84",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.005158021091476537
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*UFO::{}::yc",
+      "name": "GC_85",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.005158021091476537,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::ye",
+      "name": "GC_86",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -2.93504855786976e-06,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ye",
+      "name": "GC_87",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        2.93504855786976e-06,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1*UFO::{}::ye",
+      "name": "GC_88",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -2.0753927383815043e-06,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::ye",
+      "name": "GC_89",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -2.0753927383815043e-06
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::ym",
+      "name": "GC_90",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.0006068830344902521,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ym",
+      "name": "GC_91",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0006068830344902521,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1*UFO::{}::ym",
+      "name": "GC_92",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.0004291311090751267,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::ym",
+      "name": "GC_93",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.0004291311090751267
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::yt",
+      "name": "GC_94",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.6681058815337719
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*UFO::{}::yt",
+      "name": "GC_95",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.6681058815337719,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::ytau",
+      "name": "GC_96",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.010206617000654722,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ytau",
+      "name": "GC_97",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.010206617000654722,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1*UFO::{}::ytau",
+      "name": "GC_98",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.007217168094136855,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::ytau",
+      "name": "GC_99",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.007217168094136855
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM1x1)",
+      "name": "GC_100",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.4501822404312442
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM1x2)",
+      "name": "GC_101",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.10406729130552157
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM1x3)",
+      "name": "GC_102",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.001455467036557634,
+        0.0005634065947965036
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM2x1)",
+      "name": "GC_103",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.10406729130552157
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM2x2)",
+      "name": "GC_104",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.4501822404312442
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM2x3)",
+      "name": "GC_105",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.01894465947075628
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM3x1)",
+      "name": "GC_106",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.001455467036557634,
+        0.003704825183964887
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM3x2)",
+      "name": "GC_107",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.01894465947075628
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM3x3)",
+      "name": "GC_108",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.46190542079681124
+      ]
+    }
+  ],
+  "form_factors": [],
+  "functions": [
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "complexconjugate"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "re"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "im"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "sec"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "asec"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "csc"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "acsc"
+    }
+  ],
+  "lorentz_structures": [
+    {
+      "name": "UUS1",
+      "spins": [
+        -1,
+        -1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "UUV1",
+      "spins": [
+        -1,
+        -1,
+        3
+      ],
+      "structure": "-1*UFO::{}::P(3,2)"
+    },
+    {
+      "name": "SSS1",
+      "spins": [
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "FFS1",
+      "spins": [
+        2,
+        2,
+        1
+      ],
+      "structure": "UFO::{}::ProjM(2,1)"
+    },
+    {
+      "name": "FFS2",
+      "spins": [
+        2,
+        2,
+        1
+      ],
+      "structure": "-1*UFO::{}::ProjP(2,1)+UFO::{}::ProjM(2,1)"
+    },
+    {
+      "name": "FFS3",
+      "spins": [
+        2,
+        2,
+        1
+      ],
+      "structure": "UFO::{}::ProjP(2,1)"
+    },
+    {
+      "name": "FFS4",
+      "spins": [
+        2,
+        2,
+        1
+      ],
+      "structure": "UFO::{}::ProjM(2,1)+UFO::{}::ProjP(2,1)"
+    },
+    {
+      "name": "FFV1",
+      "spins": [
+        2,
+        2,
+        3
+      ],
+      "structure": "UFO::{}::Gamma(3,2,1)"
+    },
+    {
+      "name": "FFV2",
+      "spins": [
+        2,
+        2,
+        3
+      ],
+      "structure": "UFO::{}::Gamma(3,2,-1)*UFO::{}::ProjM(-1,1)"
+    },
+    {
+      "name": "FFV3",
+      "spins": [
+        2,
+        2,
+        3
+      ],
+      "structure": "-2*UFO::{}::Gamma(3,2,-1)*UFO::{}::ProjP(-1,1)+UFO::{}::Gamma(3,2,-1)*UFO::{}::ProjM(-1,1)"
+    },
+    {
+      "name": "FFV4",
+      "spins": [
+        2,
+        2,
+        3
+      ],
+      "structure": "2*UFO::{}::Gamma(3,2,-1)*UFO::{}::ProjP(-1,1)+UFO::{}::Gamma(3,2,-1)*UFO::{}::ProjM(-1,1)"
+    },
+    {
+      "name": "FFV5",
+      "spins": [
+        2,
+        2,
+        3
+      ],
+      "structure": "4*UFO::{}::Gamma(3,2,-1)*UFO::{}::ProjP(-1,1)+UFO::{}::Gamma(3,2,-1)*UFO::{}::ProjM(-1,1)"
+    },
+    {
+      "name": "VSS1",
+      "spins": [
+        3,
+        1,
+        1
+      ],
+      "structure": "-1*UFO::{}::P(1,3)+UFO::{}::P(1,2)"
+    },
+    {
+      "name": "VVS1",
+      "spins": [
+        3,
+        3,
+        1
+      ],
+      "structure": "UFO::{}::Metric(1,2)"
+    },
+    {
+      "name": "VVV1",
+      "spins": [
+        3,
+        3,
+        3
+      ],
+      "structure": "-1*UFO::{}::Metric(1,2)*UFO::{}::P(3,2)+-1*UFO::{}::Metric(1,3)*UFO::{}::P(2,1)+-1*UFO::{}::Metric(2,3)*UFO::{}::P(1,3)+UFO::{}::Metric(1,2)*UFO::{}::P(3,1)+UFO::{}::Metric(1,3)*UFO::{}::P(2,3)+UFO::{}::Metric(2,3)*UFO::{}::P(1,2)"
+    },
+    {
+      "name": "SSSS1",
+      "spins": [
+        1,
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "VVSS1",
+      "spins": [
+        3,
+        3,
+        1,
+        1
+      ],
+      "structure": "UFO::{}::Metric(1,2)"
+    },
+    {
+      "name": "VVVV1",
+      "spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "structure": "-1*UFO::{}::Metric(1,3)*UFO::{}::Metric(2,4)+UFO::{}::Metric(1,4)*UFO::{}::Metric(2,3)"
+    },
+    {
+      "name": "VVVV2",
+      "spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "structure": "-2*UFO::{}::Metric(1,2)*UFO::{}::Metric(3,4)+UFO::{}::Metric(1,3)*UFO::{}::Metric(2,4)+UFO::{}::Metric(1,4)*UFO::{}::Metric(2,3)"
+    },
+    {
+      "name": "VVVV3",
+      "spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "structure": "-1*UFO::{}::Metric(1,2)*UFO::{}::Metric(3,4)+UFO::{}::Metric(1,4)*UFO::{}::Metric(2,3)"
+    },
+    {
+      "name": "VVVV4",
+      "spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "structure": "-1*UFO::{}::Metric(1,2)*UFO::{}::Metric(3,4)+UFO::{}::Metric(1,3)*UFO::{}::Metric(2,4)"
+    },
+    {
+      "name": "VVVV5",
+      "spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "structure": "-1/2*UFO::{}::Metric(1,2)*UFO::{}::Metric(3,4)+-1/2*UFO::{}::Metric(1,3)*UFO::{}::Metric(2,4)+UFO::{}::Metric(1,4)*UFO::{}::Metric(2,3)"
+    }
+  ],
+  "name": "sm",
+  "orders": [
+    {
+      "expansion_order": 99,
+      "hierarchy": 1,
+      "name": "QCD"
+    },
+    {
+      "expansion_order": 99,
+      "hierarchy": 2,
+      "name": "QED"
+    }
+  ],
+  "parameters": [
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        1
+      ],
+      "name": "aEWM1",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        132.50698,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        2
+      ],
+      "name": "Gf",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.16639e-05,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        3
+      ],
+      "name": "aS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.118,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "Wolfenstein",
+      "lhacode": [
+        1
+      ],
+      "name": "lamWS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.2253,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "Wolfenstein",
+      "lhacode": [
+        2
+      ],
+      "name": "AWS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.808,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "Wolfenstein",
+      "lhacode": [
+        3
+      ],
+      "name": "rhoWS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.132,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "Wolfenstein",
+      "lhacode": [
+        4
+      ],
+      "name": "etaWS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.341,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        4
+      ],
+      "name": "ymc",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.27,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        5
+      ],
+      "name": "ymb",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        4.2,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        6
+      ],
+      "name": "ymt",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        164.5,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        11
+      ],
+      "name": "yme",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.000511,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        13
+      ],
+      "name": "ymm",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.10566,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        15
+      ],
+      "name": "ymtau",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.777,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        23
+      ],
+      "name": "MZ",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        91.188,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        4
+      ],
+      "name": "MC",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.27,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        6
+      ],
+      "name": "MT",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        173.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        5
+      ],
+      "name": "MB",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        4.7,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        25
+      ],
+      "name": "MH",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        125.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        11
+      ],
+      "name": "Me",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.000511,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        13
+      ],
+      "name": "MM",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.10566,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        15
+      ],
+      "name": "MTA",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.777,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "DECAY",
+      "lhacode": [
+        23
+      ],
+      "name": "WZ",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        2.44140351,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "DECAY",
+      "lhacode": [
+        24
+      ],
+      "name": "WW",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        2.04759951,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "DECAY",
+      "lhacode": [
+        6
+      ],
+      "name": "WT",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.50833649,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "DECAY",
+      "lhacode": [
+        25
+      ],
+      "name": "WH",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.00638233934,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "DECAY",
+      "lhacode": [
+        15
+      ],
+      "name": "WTau",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        2.27e-12,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ZERO",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM3x3",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::lamWS^2+1",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM1x1",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.974619955,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::lamWS",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM1x2",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.2253,
+        0.0
+      ]
+    },
+    {
+      "expression": "(-1𝑖*UFO::{}::etaWS+UFO::{}::rhoWS)*UFO::{}::AWS*UFO::{}::lamWS^3",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM1x3",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.0012197444962317122,
+        -0.0031510066152652563
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::lamWS",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM2x1",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.2253,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::lamWS^2+1",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM2x2",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.974619955,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::AWS*UFO::{}::lamWS^2",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM2x3",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.04101415272,
+        0.0
+      ]
+    },
+    {
+      "expression": "(-1*UFO::{}::rhoWS+-1𝑖*UFO::{}::etaWS+1)*UFO::{}::AWS*UFO::{}::lamWS^3",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM3x1",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.008020744111584288,
+        -0.0031510066152652563
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::AWS*UFO::{}::lamWS^2",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM3x2",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.04101415272,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::aEWM1^(-1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "aEW",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.00754677225305414,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::aS^(1/2)*𝜋^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "G",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        1.2177157847767195,
+        0.0
+      ]
+    },
+    {
+      "expression": "(((1/2)^(1/2)*-1*UFO::{}::Gf^(-1)*UFO::{}::MZ^2*UFO::{}::aEW*𝜋+1/4*UFO::{}::MZ^4)^(1/2)+1/2*UFO::{}::MZ^2)^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "MW",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        80.4190000176632,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::aEW^(1/2)*𝜋^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ee",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.3079537904849374,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::MW^2*UFO::{}::MZ^(-2)+1",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "sw2",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.22224653275123984,
+        0.0
+      ]
+    },
+    {
+      "expression": "(-1*UFO::{}::sw2+1)^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "cw",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.8819033208060622,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::sw2^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "sw",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.47143030529574553,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::cw^(-1)*UFO::{}::ee",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "g1",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.3491922336832418,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ee*UFO::{}::sw^(-1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "gw",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.653232910624502,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::MW*UFO::{}::ee^(-1)*UFO::{}::sw",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "vev",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        246.21845810181625,
+        0.0
+      ]
+    },
+    {
+      "expression": "1/2*UFO::{}::MH^2*UFO::{}::vev^(-2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "lam",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.12886910601690277,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::ymb",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "yb",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.024123686777011728,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::ymc",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "yc",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.007294543382572593,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::yme",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ye",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        2.93504855786976e-06,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::ymm",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ym",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.0006068830344902521,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::ymt",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "yt",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.9448443987662926,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::ymtau",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ytau",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.010206617000654722,
+        0.0
+      ]
+    },
+    {
+      "expression": "(UFO::{}::lam*UFO::{}::vev^2)^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "muH",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        88.38834764831844,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yb*conj(UFO::{}::CKM1x3)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I1x31",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        2.9424734175077786e-05,
+        7.601389661895094e-05
+      ]
+    },
+    {
+      "expression": "UFO::{}::yb*conj(UFO::{}::CKM2x3)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I1x32",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.0009894125736418036,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yb*conj(UFO::{}::CKM3x3)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I1x33",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.024123686777011728,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yc*conj(UFO::{}::CKM2x1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x12",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.0016434606240936052,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yt*conj(UFO::{}::CKM3x1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x13",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.007578355147768138,
+        0.0029772109509089116
+      ]
+    },
+    {
+      "expression": "UFO::{}::yc*conj(UFO::{}::CKM2x2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x22",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.007109407543268448,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yt*conj(UFO::{}::CKM3x2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x23",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.0387519924676373,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yc*conj(UFO::{}::CKM2x3)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x32",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.00029917951631549774,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yt*conj(UFO::{}::CKM3x3)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x33",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.9448443987662926,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM2x1*UFO::{}::yc",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x21",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.0016434606240936052,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM2x2*UFO::{}::yc",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x22",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.007109407543268448,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM2x3*UFO::{}::yc",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x23",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.00029917951631549774,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM3x1*UFO::{}::yt",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x31",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.007578355147768138,
+        -0.0029772109509089116
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM3x2*UFO::{}::yt",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x32",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.0387519924676373,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM3x3*UFO::{}::yt",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x33",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.9448443987662926,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM1x3*UFO::{}::yb",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I4x13",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        2.9424734175077786e-05,
+        -7.601389661895094e-05
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM2x3*UFO::{}::yb",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I4x23",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.0009894125736418036,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM3x3*UFO::{}::yb",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I4x33",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.024123686777011728,
+        0.0
+      ]
+    }
+  ],
+  "particles": [
+    {
+      "antiname": "a",
+      "antitexname": "{\\gamma}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "a",
+      "pdg_code": 22,
+      "propagating": true,
+      "propagator": "a_propFeynman",
+      "spin": 3,
+      "texname": "{\\gamma}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "Z",
+      "antitexname": "{Z}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MZ",
+      "name": "Z",
+      "pdg_code": 23,
+      "propagating": true,
+      "propagator": "Z_propFeynman",
+      "spin": 3,
+      "texname": "{Z}",
+      "width": "WZ",
+      "y_charge": 0
+    },
+    {
+      "antiname": "W-",
+      "antitexname": "{W^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "W+",
+      "pdg_code": 24,
+      "propagating": true,
+      "propagator": "W+_propFeynman",
+      "spin": 3,
+      "texname": "{W^+}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "W+",
+      "antitexname": "{W^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "W-",
+      "pdg_code": -24,
+      "propagating": true,
+      "propagator": "W-_propFeynman",
+      "spin": 3,
+      "texname": "{W^-}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "g",
+      "antitexname": "{g}",
+      "charge": 0.0,
+      "color": 8,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "g",
+      "pdg_code": 21,
+      "propagating": true,
+      "propagator": "g_propFeynman",
+      "spin": 3,
+      "texname": "{g}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghA~",
+      "antitexname": "\\overline{\\tilde{\\gamma}}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "ghA",
+      "pdg_code": 9000001,
+      "propagating": true,
+      "propagator": "ghA_propFeynman",
+      "spin": -1,
+      "texname": "\\tilde{\\gamma}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghA",
+      "antitexname": "\\tilde{\\gamma}",
+      "charge": -0.0,
+      "color": 1,
+      "ghost_number": -1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "ghA~",
+      "pdg_code": -9000001,
+      "propagating": true,
+      "propagator": "ghA~_propFeynman",
+      "spin": -1,
+      "texname": "\\overline{\\tilde{\\gamma}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghZ~",
+      "antitexname": "\\bar{\\tilde{Z}}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MZ",
+      "name": "ghZ",
+      "pdg_code": 9000002,
+      "propagating": true,
+      "propagator": "ghZ_propFeynman",
+      "spin": -1,
+      "texname": "\\tilde{Z}",
+      "width": "WZ",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghZ",
+      "antitexname": "\\tilde{Z}",
+      "charge": -0.0,
+      "color": 1,
+      "ghost_number": -1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MZ",
+      "name": "ghZ~",
+      "pdg_code": -9000002,
+      "propagating": true,
+      "propagator": "ghZ~_propFeynman",
+      "spin": -1,
+      "texname": "\\bar{\\tilde{Z}}",
+      "width": "WZ",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghWp~",
+      "antitexname": "{\\bar{\\tilde{W}}^+}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "ghWp",
+      "pdg_code": 9000003,
+      "propagating": true,
+      "propagator": "ghWp_propFeynman",
+      "spin": -1,
+      "texname": "{\\tilde{W}^+}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghWp",
+      "antitexname": "{\\tilde{W}^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": -1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "ghWp~",
+      "pdg_code": -9000003,
+      "propagating": true,
+      "propagator": "ghWp~_propFeynman",
+      "spin": -1,
+      "texname": "{\\bar{\\tilde{W}}^+}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghWm~",
+      "antitexname": "{\\bar{\\tilde{W}}^-}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "ghWm",
+      "pdg_code": 9000004,
+      "propagating": true,
+      "propagator": "ghWm_propFeynman",
+      "spin": -1,
+      "texname": "{\\tilde{W}^-}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghWm",
+      "antitexname": "{\\tilde{W}^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": -1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "ghWm~",
+      "pdg_code": -9000004,
+      "propagating": true,
+      "propagator": "ghWm~_propFeynman",
+      "spin": -1,
+      "texname": "{\\bar{\\tilde{W}}^-}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghG~",
+      "antitexname": "{\\bar{\\tilde{g}}}",
+      "charge": 0.0,
+      "color": 8,
+      "ghost_number": 1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "ghG",
+      "pdg_code": 9000005,
+      "propagating": true,
+      "propagator": "ghG_propFeynman",
+      "spin": -1,
+      "texname": "{\\tilde{g}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghG",
+      "antitexname": "{\\tilde{g}}",
+      "charge": -0.0,
+      "color": 8,
+      "ghost_number": -1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "ghG~",
+      "pdg_code": -9000005,
+      "propagating": true,
+      "propagator": "ghG~_propFeynman",
+      "spin": -1,
+      "texname": "{\\bar{\\tilde{g}}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ve~",
+      "antitexname": "{\\overline{\\nu}_e}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "ZERO",
+      "name": "ve",
+      "pdg_code": 12,
+      "propagating": true,
+      "propagator": "ve_propFeynman",
+      "spin": 2,
+      "texname": "{\\nu_e}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ve",
+      "antitexname": "{\\nu_e}",
+      "charge": -0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "ZERO",
+      "name": "ve~",
+      "pdg_code": -12,
+      "propagating": true,
+      "propagator": "ve~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{\\nu}_e}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "vm~",
+      "antitexname": "{\\overline{\\nu}_\\mu}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "ZERO",
+      "name": "vm",
+      "pdg_code": 14,
+      "propagating": true,
+      "propagator": "vm_propFeynman",
+      "spin": 2,
+      "texname": "{\\nu_\\mu}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "vm",
+      "antitexname": "{\\nu_\\mu}",
+      "charge": -0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "ZERO",
+      "name": "vm~",
+      "pdg_code": -14,
+      "propagating": true,
+      "propagator": "vm~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{\\nu}_\\mu}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "vt~",
+      "antitexname": "{\\overline{\\nu}_\\tau}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "ZERO",
+      "name": "vt",
+      "pdg_code": 16,
+      "propagating": true,
+      "propagator": "vt_propFeynman",
+      "spin": 2,
+      "texname": "{\\nu_\\tau}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "vt",
+      "antitexname": "{\\nu_\\tau}",
+      "charge": -0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "ZERO",
+      "name": "vt~",
+      "pdg_code": -16,
+      "propagating": true,
+      "propagator": "vt~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{\\nu}_\\tau}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "u~",
+      "antitexname": "{\\overline{u}}",
+      "charge": 0.6666666666666666,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "u",
+      "pdg_code": 2,
+      "propagating": true,
+      "propagator": "u_propFeynman",
+      "spin": 2,
+      "texname": "{u}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "u",
+      "antitexname": "{u}",
+      "charge": -0.6666666666666666,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "u~",
+      "pdg_code": -2,
+      "propagating": true,
+      "propagator": "u~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{u}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "c~",
+      "antitexname": "{\\overline{c}}",
+      "charge": 0.6666666666666666,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MC",
+      "name": "c",
+      "pdg_code": 4,
+      "propagating": true,
+      "propagator": "c_propFeynman",
+      "spin": 2,
+      "texname": "{c}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "c",
+      "antitexname": "{c}",
+      "charge": -0.6666666666666666,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MC",
+      "name": "c~",
+      "pdg_code": -4,
+      "propagating": true,
+      "propagator": "c~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{c}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "t~",
+      "antitexname": "{\\overline{t}}",
+      "charge": 0.6666666666666666,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MT",
+      "name": "t",
+      "pdg_code": 6,
+      "propagating": true,
+      "propagator": "t_propFeynman",
+      "spin": 2,
+      "texname": "{t}",
+      "width": "WT",
+      "y_charge": 0
+    },
+    {
+      "antiname": "t",
+      "antitexname": "{t}",
+      "charge": -0.6666666666666666,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MT",
+      "name": "t~",
+      "pdg_code": -6,
+      "propagating": true,
+      "propagator": "t~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{t}}",
+      "width": "WT",
+      "y_charge": 0
+    },
+    {
+      "antiname": "d~",
+      "antitexname": "{\\overline{d}}",
+      "charge": -0.3333333333333333,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "d",
+      "pdg_code": 1,
+      "propagating": true,
+      "propagator": "d_propFeynman",
+      "spin": 2,
+      "texname": "{d}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "d",
+      "antitexname": "{d}",
+      "charge": 0.3333333333333333,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "d~",
+      "pdg_code": -1,
+      "propagating": true,
+      "propagator": "d~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{d}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "s~",
+      "antitexname": "{\\overline{s}}",
+      "charge": -0.3333333333333333,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "s",
+      "pdg_code": 3,
+      "propagating": true,
+      "propagator": "s_propFeynman",
+      "spin": 2,
+      "texname": "{s}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "s",
+      "antitexname": "{s}",
+      "charge": 0.3333333333333333,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "s~",
+      "pdg_code": -3,
+      "propagating": true,
+      "propagator": "s~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{s}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "b~",
+      "antitexname": "{\\overline{b}}",
+      "charge": -0.3333333333333333,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MB",
+      "name": "b",
+      "pdg_code": 5,
+      "propagating": true,
+      "propagator": "b_propFeynman",
+      "spin": 2,
+      "texname": "{b}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "b",
+      "antitexname": "{b}",
+      "charge": 0.3333333333333333,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MB",
+      "name": "b~",
+      "pdg_code": -5,
+      "propagating": true,
+      "propagator": "b~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{b}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "H",
+      "antitexname": "{H}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MH",
+      "name": "H",
+      "pdg_code": 25,
+      "propagating": true,
+      "propagator": "H_propFeynman",
+      "spin": 1,
+      "texname": "{H}",
+      "width": "WH",
+      "y_charge": 0
+    },
+    {
+      "antiname": "G0",
+      "antitexname": "{G_0}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": true,
+      "lepton_number": 0,
+      "mass": "MZ",
+      "name": "G0",
+      "pdg_code": 250,
+      "propagating": true,
+      "propagator": "G0_propFeynman",
+      "spin": 1,
+      "texname": "{G_0}",
+      "width": "WZ",
+      "y_charge": 0
+    },
+    {
+      "antiname": "G-",
+      "antitexname": "{G^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": true,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "G+",
+      "pdg_code": 251,
+      "propagating": true,
+      "propagator": "G+_propFeynman",
+      "spin": 1,
+      "texname": "{G^+}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "G+",
+      "antitexname": "{G^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": true,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "G-",
+      "pdg_code": -251,
+      "propagating": true,
+      "propagator": "G-_propFeynman",
+      "spin": 1,
+      "texname": "{G^-}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "e+",
+      "antitexname": "{e^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "Me",
+      "name": "e-",
+      "pdg_code": 11,
+      "propagating": true,
+      "propagator": "e-_propFeynman",
+      "spin": 2,
+      "texname": "{e^-}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "e-",
+      "antitexname": "{e^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "Me",
+      "name": "e+",
+      "pdg_code": -11,
+      "propagating": true,
+      "propagator": "e+_propFeynman",
+      "spin": 2,
+      "texname": "{e^+}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "mu+",
+      "antitexname": "{\\mu^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "MM",
+      "name": "mu-",
+      "pdg_code": 13,
+      "propagating": true,
+      "propagator": "mu-_propFeynman",
+      "spin": 2,
+      "texname": "{\\mu^-}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "mu-",
+      "antitexname": "{\\mu^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "MM",
+      "name": "mu+",
+      "pdg_code": -13,
+      "propagating": true,
+      "propagator": "mu+_propFeynman",
+      "spin": 2,
+      "texname": "{\\mu^+}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ta+",
+      "antitexname": "{\\tau^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "MTA",
+      "name": "ta-",
+      "pdg_code": 15,
+      "propagating": true,
+      "propagator": "ta-_propFeynman",
+      "spin": 2,
+      "texname": "{\\tau^-}",
+      "width": "WTau",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ta-",
+      "antitexname": "{\\tau^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "MTA",
+      "name": "ta+",
+      "pdg_code": -15,
+      "propagating": true,
+      "propagator": "ta+_propFeynman",
+      "spin": 2,
+      "texname": "{\\tau^+}",
+      "width": "WTau",
+      "y_charge": 0
+    }
+  ],
+  "propagators": [
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "a_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::Metric(1,2)",
+      "particle": "a"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MZ^2",
+      "name": "Z_propFeynman",
+      "numerator": "(-1*UFO::{}::Metric(1,2)+UFO::{}::MZ^(-2)*UFO::{}::P(1)*UFO::{}::P(2))*1𝑖",
+      "particle": "Z"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MW^2",
+      "name": "W+_propFeynman",
+      "numerator": "(-1*UFO::{}::Metric(1,2)+UFO::{}::MW^(-2)*UFO::{}::P(1)*UFO::{}::P(2))*1𝑖",
+      "particle": "W+"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MW^2",
+      "name": "W-_propFeynman",
+      "numerator": "(-1*UFO::{}::Metric(1,2)+UFO::{}::MW^(-2)*UFO::{}::P(1)*UFO::{}::P(2))*1𝑖",
+      "particle": "W-"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "g_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::Metric(1,2)",
+      "particle": "g"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "ghA_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghA"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "ghA~_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghA~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MZ^2",
+      "name": "ghZ_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghZ"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MZ^2",
+      "name": "ghZ~_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghZ~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MW^2",
+      "name": "ghWp_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghWp"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MW^2",
+      "name": "ghWp~_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghWp~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MW^2",
+      "name": "ghWm_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghWm"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MW^2",
+      "name": "ghWm~_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghWm~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "ghG_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghG"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "ghG~_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghG~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "ve_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(2,1)",
+      "particle": "ve"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "ve~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(1,2)",
+      "particle": "ve~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "vm_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(2,1)",
+      "particle": "vm"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "vm~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(1,2)",
+      "particle": "vm~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "vt_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(2,1)",
+      "particle": "vt"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "vt~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(1,2)",
+      "particle": "vt~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "u_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(2,1)",
+      "particle": "u"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "u~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(1,2)",
+      "particle": "u~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MC^2",
+      "name": "c_propFeynman",
+      "numerator": "(UFO::{}::Identity(2,1)*UFO::{}::MC+UFO::{}::PSlash(2,1))*1𝑖",
+      "particle": "c"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MC^2",
+      "name": "c~_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(1,2)+UFO::{}::Identity(1,2)*UFO::{}::MC)*1𝑖",
+      "particle": "c~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MT^2",
+      "name": "t_propFeynman",
+      "numerator": "(UFO::{}::Identity(2,1)*UFO::{}::MT+UFO::{}::PSlash(2,1))*1𝑖",
+      "particle": "t"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MT^2",
+      "name": "t~_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(1,2)+UFO::{}::Identity(1,2)*UFO::{}::MT)*1𝑖",
+      "particle": "t~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "d_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(2,1)",
+      "particle": "d"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "d~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(1,2)",
+      "particle": "d~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "s_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(2,1)",
+      "particle": "s"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2",
+      "name": "s~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(1,2)",
+      "particle": "s~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MB^2",
+      "name": "b_propFeynman",
+      "numerator": "(UFO::{}::Identity(2,1)*UFO::{}::MB+UFO::{}::PSlash(2,1))*1𝑖",
+      "particle": "b"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MB^2",
+      "name": "b~_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(1,2)+UFO::{}::Identity(1,2)*UFO::{}::MB)*1𝑖",
+      "particle": "b~"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MH^2",
+      "name": "H_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "H"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MZ^2",
+      "name": "G0_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "G0"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MW^2",
+      "name": "G+_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "G+"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MW^2",
+      "name": "G-_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "G-"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::Me^2",
+      "name": "e-_propFeynman",
+      "numerator": "(UFO::{}::Identity(2,1)*UFO::{}::Me+UFO::{}::PSlash(2,1))*1𝑖",
+      "particle": "e-"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::Me^2",
+      "name": "e+_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(1,2)+UFO::{}::Identity(1,2)*UFO::{}::Me)*1𝑖",
+      "particle": "e+"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MM^2",
+      "name": "mu-_propFeynman",
+      "numerator": "(UFO::{}::Identity(2,1)*UFO::{}::MM+UFO::{}::PSlash(2,1))*1𝑖",
+      "particle": "mu-"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MM^2",
+      "name": "mu+_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(1,2)+UFO::{}::Identity(1,2)*UFO::{}::MM)*1𝑖",
+      "particle": "mu+"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MTA^2",
+      "name": "ta-_propFeynman",
+      "numerator": "(UFO::{}::Identity(2,1)*UFO::{}::MTA+UFO::{}::PSlash(2,1))*1𝑖",
+      "particle": "ta-"
+    },
+    {
+      "denominator": "(UFO::{}::P(1))^2+-1*UFO::{}::MTA^2",
+      "name": "ta+_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(1,2)+UFO::{}::Identity(1,2)*UFO::{}::MTA)*1𝑖",
+      "particle": "ta+"
+    }
+  ],
+  "restriction": null,
+  "vertex_rules": [
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_33"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_1",
+      "particles": [
+        "G0",
+        "G0",
+        "G0",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_31"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_2",
+      "particles": [
+        "G0",
+        "G0",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_32"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_3",
+      "particles": [
+        "G-",
+        "G-",
+        "G+",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_31"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_4",
+      "particles": [
+        "G0",
+        "G0",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_31"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_5",
+      "particles": [
+        "G-",
+        "G+",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_33"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_6",
+      "particles": [
+        "H",
+        "H",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_68"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSS1"
+      ],
+      "name": "V_7",
+      "particles": [
+        "G0",
+        "G0",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_68"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSS1"
+      ],
+      "name": "V_8",
+      "particles": [
+        "G-",
+        "G+",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_69"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSS1"
+      ],
+      "name": "V_9",
+      "particles": [
+        "H",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_6"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_10",
+      "particles": [
+        "a",
+        "a",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_11",
+      "particles": [
+        "a",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_12",
+      "particles": [
+        "ghA",
+        "ghWm~",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_4"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_13",
+      "particles": [
+        "ghA",
+        "ghWp~",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_75"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_14",
+      "particles": [
+        "ghWm",
+        "ghA~",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_15",
+      "particles": [
+        "ghWm",
+        "ghA~",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_70"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_16",
+      "particles": [
+        "ghWm",
+        "ghWm~",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_71"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_17",
+      "particles": [
+        "ghWm",
+        "ghWm~",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_4"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_18",
+      "particles": [
+        "ghWm",
+        "ghWm~",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_53"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_19",
+      "particles": [
+        "ghWm",
+        "ghWm~",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_78"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_20",
+      "particles": [
+        "ghWm",
+        "ghZ~",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_52"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_21",
+      "particles": [
+        "ghWm",
+        "ghZ~",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_74"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_22",
+      "particles": [
+        "ghWp",
+        "ghA~",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_4"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_23",
+      "particles": [
+        "ghWp",
+        "ghA~",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_73"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_24",
+      "particles": [
+        "ghWp",
+        "ghWp~",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_71"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_25",
+      "particles": [
+        "ghWp",
+        "ghWp~",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_26",
+      "particles": [
+        "ghWp",
+        "ghWp~",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_52"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_27",
+      "particles": [
+        "ghWp",
+        "ghWp~",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_77"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_28",
+      "particles": [
+        "ghWp",
+        "ghZ~",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_53"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_29",
+      "particles": [
+        "ghWp",
+        "ghZ~",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_79"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_30",
+      "particles": [
+        "ghZ",
+        "ghWm~",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_52"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_31",
+      "particles": [
+        "ghZ",
+        "ghWm~",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_76"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_32",
+      "particles": [
+        "ghZ",
+        "ghWp~",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_53"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_33",
+      "particles": [
+        "ghZ",
+        "ghWp~",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_80"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_34",
+      "particles": [
+        "ghZ",
+        "ghZ~",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::f(3,1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_10"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_35",
+      "particles": [
+        "ghG",
+        "ghG~",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::f(1,2,3)"
+      ],
+      "couplings": [
+        [
+          "GC_10"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVV1"
+      ],
+      "name": "V_36",
+      "particles": [
+        "g",
+        "g",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::f(-1,1,2)*UFO::{}::f(3,4,-1)",
+        "UFO::{}::f(-1,1,3)*UFO::{}::f(2,4,-1)",
+        "UFO::{}::f(-1,1,4)*UFO::{}::f(2,3,-1)"
+      ],
+      "couplings": [
+        [
+          "GC_12",
+          null,
+          null
+        ],
+        [
+          null,
+          "GC_12",
+          null
+        ],
+        [
+          null,
+          null,
+          "GC_12"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVVV1",
+        "VVVV3",
+        "VVVV4"
+      ],
+      "name": "V_37",
+      "particles": [
+        "g",
+        "g",
+        "g",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_55"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_38",
+      "particles": [
+        "a",
+        "W-",
+        "G0",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_54"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_39",
+      "particles": [
+        "a",
+        "W-",
+        "G+",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_74"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_40",
+      "particles": [
+        "a",
+        "W-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_39"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_41",
+      "particles": [
+        "W-",
+        "G0",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_37"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_42",
+      "particles": [
+        "W-",
+        "G+",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_4"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVV1"
+      ],
+      "name": "V_43",
+      "particles": [
+        "a",
+        "W-",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_55"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_44",
+      "particles": [
+        "a",
+        "W+",
+        "G0",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_56"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_45",
+      "particles": [
+        "a",
+        "W+",
+        "G-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_75"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_46",
+      "particles": [
+        "a",
+        "W+",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_38"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_47",
+      "particles": [
+        "W+",
+        "G0",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_37"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_48",
+      "particles": [
+        "W+",
+        "G-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_34"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_49",
+      "particles": [
+        "W-",
+        "W+",
+        "G0",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_34"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_50",
+      "particles": [
+        "W-",
+        "W+",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_34"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_51",
+      "particles": [
+        "W-",
+        "W+",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_72"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_52",
+      "particles": [
+        "W-",
+        "W+",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_5"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVVV2"
+      ],
+      "name": "V_53",
+      "particles": [
+        "a",
+        "a",
+        "W-",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_53"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVV1"
+      ],
+      "name": "V_54",
+      "particles": [
+        "W-",
+        "W+",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_35"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVVV2"
+      ],
+      "name": "V_55",
+      "particles": [
+        "W-",
+        "W-",
+        "W+",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_63"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_56",
+      "particles": [
+        "a",
+        "Z",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_60"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_57",
+      "particles": [
+        "Z",
+        "G0",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_61"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_58",
+      "particles": [
+        "Z",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_8"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_59",
+      "particles": [
+        "W-",
+        "Z",
+        "G0",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_9"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_60",
+      "particles": [
+        "W-",
+        "Z",
+        "G+",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_67"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_61",
+      "particles": [
+        "W-",
+        "Z",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_8"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_62",
+      "particles": [
+        "W+",
+        "Z",
+        "G0",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_7"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_63",
+      "particles": [
+        "W+",
+        "Z",
+        "G-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_66"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_64",
+      "particles": [
+        "W+",
+        "Z",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_57"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVVV5"
+      ],
+      "name": "V_65",
+      "particles": [
+        "a",
+        "W-",
+        "W+",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_65"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_66",
+      "particles": [
+        "Z",
+        "Z",
+        "G0",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_64"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_67",
+      "particles": [
+        "Z",
+        "Z",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_65"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_68",
+      "particles": [
+        "Z",
+        "Z",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_81"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_69",
+      "particles": [
+        "Z",
+        "Z",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_36"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVVV2"
+      ],
+      "name": "V_70",
+      "particles": [
+        "W-",
+        "W+",
+        "Z",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_1"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_71",
+      "particles": [
+        "d~",
+        "d",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_1"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_72",
+      "particles": [
+        "s~",
+        "s",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_1"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_73",
+      "particles": [
+        "b~",
+        "b",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_74",
+      "particles": [
+        "d~",
+        "d",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_75",
+      "particles": [
+        "s~",
+        "s",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_76",
+      "particles": [
+        "b~",
+        "b",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_82"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_77",
+      "particles": [
+        "b~",
+        "b",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_83"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_78",
+      "particles": [
+        "b~",
+        "b",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV3"
+      ],
+      "name": "V_79",
+      "particles": [
+        "d~",
+        "d",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV3"
+      ],
+      "name": "V_80",
+      "particles": [
+        "s~",
+        "s",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV3"
+      ],
+      "name": "V_81",
+      "particles": [
+        "b~",
+        "b",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_16"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_82",
+      "particles": [
+        "c~",
+        "d",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_17"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_83",
+      "particles": [
+        "t~",
+        "d",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_18"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_84",
+      "particles": [
+        "c~",
+        "s",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_19"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_85",
+      "particles": [
+        "t~",
+        "s",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_13"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_86",
+      "particles": [
+        "u~",
+        "b",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_14",
+          "GC_20"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1",
+        "FFS3"
+      ],
+      "name": "V_87",
+      "particles": [
+        "c~",
+        "b",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_15",
+          "GC_21"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1",
+        "FFS3"
+      ],
+      "name": "V_88",
+      "particles": [
+        "t~",
+        "b",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_100"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_89",
+      "particles": [
+        "u~",
+        "d",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_103"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_90",
+      "particles": [
+        "c~",
+        "d",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_106"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_91",
+      "particles": [
+        "t~",
+        "d",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_101"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_92",
+      "particles": [
+        "u~",
+        "s",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_104"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_93",
+      "particles": [
+        "c~",
+        "s",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_107"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_94",
+      "particles": [
+        "t~",
+        "s",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_102"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_95",
+      "particles": [
+        "u~",
+        "b",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_105"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_96",
+      "particles": [
+        "c~",
+        "b",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_108"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_97",
+      "particles": [
+        "t~",
+        "b",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_98",
+      "particles": [
+        "e+",
+        "e-",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_99",
+      "particles": [
+        "mu+",
+        "mu-",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_100",
+      "particles": [
+        "ta+",
+        "ta-",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_88"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_101",
+      "particles": [
+        "e+",
+        "e-",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_92"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_102",
+      "particles": [
+        "mu+",
+        "mu-",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_98"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_103",
+      "particles": [
+        "ta+",
+        "ta-",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_89"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_104",
+      "particles": [
+        "e+",
+        "e-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_93"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_105",
+      "particles": [
+        "mu+",
+        "mu-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_99"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_106",
+      "particles": [
+        "ta+",
+        "ta-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_59"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV4"
+      ],
+      "name": "V_107",
+      "particles": [
+        "e+",
+        "e-",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_59"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV4"
+      ],
+      "name": "V_108",
+      "particles": [
+        "mu+",
+        "mu-",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_59"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV4"
+      ],
+      "name": "V_109",
+      "particles": [
+        "ta+",
+        "ta-",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_87"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_110",
+      "particles": [
+        "ve~",
+        "e-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_91"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_111",
+      "particles": [
+        "vm~",
+        "mu-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_97"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_112",
+      "particles": [
+        "vt~",
+        "ta-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_113",
+      "particles": [
+        "ve~",
+        "e-",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_114",
+      "particles": [
+        "vm~",
+        "mu-",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_115",
+      "particles": [
+        "vt~",
+        "ta-",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_28"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_116",
+      "particles": [
+        "b~",
+        "u",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_22"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_117",
+      "particles": [
+        "d~",
+        "c",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_23"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_118",
+      "particles": [
+        "s~",
+        "c",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_24",
+          "GC_29"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1",
+        "FFS3"
+      ],
+      "name": "V_119",
+      "particles": [
+        "b~",
+        "c",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_25"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_120",
+      "particles": [
+        "d~",
+        "t",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_26"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_121",
+      "particles": [
+        "s~",
+        "t",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_27",
+          "GC_30"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1",
+        "FFS3"
+      ],
+      "name": "V_122",
+      "particles": [
+        "b~",
+        "t",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_41"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_123",
+      "particles": [
+        "d~",
+        "u",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_42"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_124",
+      "particles": [
+        "s~",
+        "u",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_43"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_125",
+      "particles": [
+        "b~",
+        "u",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_44"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_126",
+      "particles": [
+        "d~",
+        "c",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_45"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_127",
+      "particles": [
+        "s~",
+        "c",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_46"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_128",
+      "particles": [
+        "b~",
+        "c",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_47"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_129",
+      "particles": [
+        "d~",
+        "t",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_48"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_130",
+      "particles": [
+        "s~",
+        "t",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_49"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_131",
+      "particles": [
+        "b~",
+        "t",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_2"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_132",
+      "particles": [
+        "u~",
+        "u",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_2"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_133",
+      "particles": [
+        "c~",
+        "c",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_2"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_134",
+      "particles": [
+        "t~",
+        "t",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_135",
+      "particles": [
+        "u~",
+        "u",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_136",
+      "particles": [
+        "c~",
+        "c",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_137",
+      "particles": [
+        "t~",
+        "t",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_85"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_138",
+      "particles": [
+        "c~",
+        "c",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_95"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_139",
+      "particles": [
+        "t~",
+        "t",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_84"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_140",
+      "particles": [
+        "c~",
+        "c",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_94"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_141",
+      "particles": [
+        "t~",
+        "t",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_51",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV5"
+      ],
+      "name": "V_142",
+      "particles": [
+        "u~",
+        "u",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_51",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV5"
+      ],
+      "name": "V_143",
+      "particles": [
+        "c~",
+        "c",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_51",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV5"
+      ],
+      "name": "V_144",
+      "particles": [
+        "t~",
+        "t",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_86"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_145",
+      "particles": [
+        "e+",
+        "ve",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_90"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_146",
+      "particles": [
+        "mu+",
+        "vm",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_96"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_147",
+      "particles": [
+        "ta+",
+        "vt",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_148",
+      "particles": [
+        "e+",
+        "ve",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_149",
+      "particles": [
+        "mu+",
+        "vm",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_150",
+      "particles": [
+        "ta+",
+        "vt",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_62"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_151",
+      "particles": [
+        "ve~",
+        "ve",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_62"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_152",
+      "particles": [
+        "vm~",
+        "vm",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_62"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_153",
+      "particles": [
+        "vt~",
+        "vt",
+        "Z"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/json/sm/sm_wrapped_indices.json b/pyamplicol/src/pyamplicol/assets/models/json/sm/sm_wrapped_indices.json
new file mode 100644
index 0000000000..2996cf8183
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/json/sm/sm_wrapped_indices.json
@@ -0,0 +1,6721 @@
+{
+  "couplings": [
+    {
+      "expression": "-1𝑖/3*UFO::{}::ee",
+      "name": "GC_1",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.10265126349497912
+      ]
+    },
+    {
+      "expression": "2𝑖/3*UFO::{}::ee",
+      "name": "GC_2",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.20530252698995824
+      ]
+    },
+    {
+      "expression": "-1𝑖*UFO::{}::ee",
+      "name": "GC_3",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.3079537904849374
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::ee",
+      "name": "GC_4",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.3079537904849374
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::ee^2",
+      "name": "GC_5",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.0948355370740407
+      ]
+    },
+    {
+      "expression": "2𝑖*UFO::{}::ee^2",
+      "name": "GC_6",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.1896710741480814
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::cw^(-1)*UFO::{}::ee^2",
+      "name": "GC_7",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        -0.053767535985328165,
+        0.0
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::cw^(-1)*UFO::{}::ee^2",
+      "name": "GC_8",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.053767535985328165
+      ]
+    },
+    {
+      "expression": "1/2*UFO::{}::cw^(-1)*UFO::{}::ee^2",
+      "name": "GC_9",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.053767535985328165,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::G",
+      "name": "GC_10",
+      "orders": [
+        [
+          "QCD",
+          1
+        ]
+      ],
+      "value": [
+        -1.2177157847767195,
+        0.0
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::G",
+      "name": "GC_11",
+      "orders": [
+        [
+          "QCD",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        1.2177157847767195
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::G^2",
+      "name": "GC_12",
+      "orders": [
+        [
+          "QCD",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        1.4828317324943818
+      ]
+    },
+    {
+      "expression": "UFO::{}::I1x31",
+      "name": "GC_13",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        2.9424734175077786e-05,
+        7.601389661895094e-05
+      ]
+    },
+    {
+      "expression": "UFO::{}::I1x32",
+      "name": "GC_14",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0009894125736418036,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I1x33",
+      "name": "GC_15",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.024123686777011728,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x12",
+      "name": "GC_16",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0016434606240936052,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x13",
+      "name": "GC_17",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.007578355147768138,
+        -0.0029772109509089116
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x22",
+      "name": "GC_18",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.007109407543268448,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x23",
+      "name": "GC_19",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0387519924676373,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x32",
+      "name": "GC_20",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.00029917951631549774,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I2x33",
+      "name": "GC_21",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.9448443987662926,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x21",
+      "name": "GC_22",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.0016434606240936052,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x22",
+      "name": "GC_23",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.007109407543268448,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x23",
+      "name": "GC_24",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.00029917951631549774,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x31",
+      "name": "GC_25",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.007578355147768138,
+        -0.0029772109509089116
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x32",
+      "name": "GC_26",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.0387519924676373,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::I3x33",
+      "name": "GC_27",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.9448443987662926,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I4x13",
+      "name": "GC_28",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -2.9424734175077786e-05,
+        7.601389661895094e-05
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I4x23",
+      "name": "GC_29",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.0009894125736418036,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::I4x33",
+      "name": "GC_30",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.024123686777011728,
+        0.0
+      ]
+    },
+    {
+      "expression": "-2𝑖*UFO::{}::lam",
+      "name": "GC_31",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.25773821203380554
+      ]
+    },
+    {
+      "expression": "-4𝑖*UFO::{}::lam",
+      "name": "GC_32",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.5154764240676111
+      ]
+    },
+    {
+      "expression": "-6𝑖*UFO::{}::lam",
+      "name": "GC_33",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.7732146361014166
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::ee^2*UFO::{}::sw^(-2)",
+      "name": "GC_34",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.2133566177614792
+      ]
+    },
+    {
+      "expression": "-1𝑖*UFO::{}::ee^2*UFO::{}::sw^(-2)",
+      "name": "GC_35",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.4267132355229584
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::cw^2*UFO::{}::ee^2*UFO::{}::sw^(-2)",
+      "name": "GC_36",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.3318776984489177
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_37",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.326616455312251,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1𝑖/2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_38",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.326616455312251
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_39",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.326616455312251
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_40",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.46190542079681124
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM1x1*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_41",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.4501822404312442
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM1x2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_42",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.10406729130552157
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM1x3*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_43",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.001455467036557634,
+        0.0005634065947965036
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM2x1*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_44",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.10406729130552157
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM2x2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_45",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.4501822404312442
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM2x3*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_46",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.01894465947075628
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM3x1*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_47",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.001455467036557634,
+        0.003704825183964887
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM3x2*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_48",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.01894465947075628
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::CKM3x3*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_49",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.46190542079681124
+      ]
+    },
+    {
+      "expression": "-1𝑖/2*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_50",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.2880441365697789
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_51",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.2880441365697789
+      ]
+    },
+    {
+      "expression": "-1𝑖*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_52",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.5760882731395578
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)",
+      "name": "GC_53",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.5760882731395578
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::ee^2*UFO::{}::sw^(-1)",
+      "name": "GC_54",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        -0.10058277544816184,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1𝑖/2*UFO::{}::ee^2*UFO::{}::sw^(-1)",
+      "name": "GC_55",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.10058277544816184
+      ]
+    },
+    {
+      "expression": "1/2*UFO::{}::ee^2*UFO::{}::sw^(-1)",
+      "name": "GC_56",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.10058277544816184,
+        0.0
+      ]
+    },
+    {
+      "expression": "-2𝑖*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-1)",
+      "name": "GC_57",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.35481713473449755
+      ]
+    },
+    {
+      "expression": "-1𝑖/6*UFO::{}::cw^(-1)*UFO::{}::ee*UFO::{}::sw",
+      "name": "GC_58",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.027436633555365665
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::cw^(-1)*UFO::{}::ee*UFO::{}::sw",
+      "name": "GC_59",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.082309900666097
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)+-1/2*UFO::{}::cw^(-1)*UFO::{}::ee*UFO::{}::sw",
+      "name": "GC_60",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.3703540372358759,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1𝑖/2*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)+1𝑖/2*UFO::{}::cw^(-1)*UFO::{}::ee*UFO::{}::sw",
+      "name": "GC_61",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.2057342359036819
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::cw*UFO::{}::ee*UFO::{}::sw^(-1)+1𝑖/2*UFO::{}::cw^(-1)*UFO::{}::ee*UFO::{}::sw",
+      "name": "GC_62",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.3703540372358759
+      ]
+    },
+    {
+      "expression": "-1𝑖*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::sw+1𝑖*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-1)",
+      "name": "GC_63",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.12671327555812228
+      ]
+    },
+    {
+      "expression": "-1𝑖*UFO::{}::ee^2+1𝑖/2*UFO::{}::cw^(-2)*UFO::{}::ee^2*UFO::{}::sw^2+1𝑖/2*UFO::{}::cw^2*UFO::{}::ee^2*UFO::{}::sw^(-2)",
+      "name": "GC_64",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.08465315164574365
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::ee^2+1𝑖/2*UFO::{}::cw^(-2)*UFO::{}::ee^2*UFO::{}::sw^2+1𝑖/2*UFO::{}::cw^2*UFO::{}::ee^2*UFO::{}::sw^(-2)",
+      "name": "GC_65",
+      "orders": [
+        [
+          "QED",
+          2
+        ]
+      ],
+      "value": [
+        0.0,
+        0.27432422579382504
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev",
+      "name": "GC_66",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -13.23855980624142,
+        0.0
+      ]
+    },
+    {
+      "expression": "1/2*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev",
+      "name": "GC_67",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        13.23855980624142,
+        0.0
+      ]
+    },
+    {
+      "expression": "-2𝑖*UFO::{}::lam*UFO::{}::vev",
+      "name": "GC_68",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -63.459905160882585
+      ]
+    },
+    {
+      "expression": "-6𝑖*UFO::{}::lam*UFO::{}::vev",
+      "name": "GC_69",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -190.37971548264773
+      ]
+    },
+    {
+      "expression": "-1/4*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_70",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -26.266168725525,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1𝑖/4*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_71",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -26.266168725525
+      ]
+    },
+    {
+      "expression": "1𝑖/2*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_72",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        52.53233745105
+      ]
+    },
+    {
+      "expression": "1/4*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_73",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        26.266168725525,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::ee^2*UFO::{}::sw^(-1)*UFO::{}::vev",
+      "name": "GC_74",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -24.76533588244763,
+        0.0
+      ]
+    },
+    {
+      "expression": "1/2*UFO::{}::ee^2*UFO::{}::sw^(-1)*UFO::{}::vev",
+      "name": "GC_75",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        24.76533588244763,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/4*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev+-1/4*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev",
+      "name": "GC_76",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -29.78350132701354,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/4*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev+1/4*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev",
+      "name": "GC_77",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -16.54494152077212,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/4*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev+1/4*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_78",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        16.54494152077212,
+        0.0
+      ]
+    },
+    {
+      "expression": "1/4*UFO::{}::cw*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev+1/4*UFO::{}::cw^(-1)*UFO::{}::ee^2*UFO::{}::vev",
+      "name": "GC_79",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        29.78350132701354,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1𝑖/2*UFO::{}::ee^2*UFO::{}::vev+-1𝑖/4*UFO::{}::cw^(-2)*UFO::{}::ee^2*UFO::{}::sw^2*UFO::{}::vev+-1𝑖/4*UFO::{}::cw^2*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_80",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -33.77184394746505
+      ]
+    },
+    {
+      "expression": "1𝑖*UFO::{}::ee^2*UFO::{}::vev+1𝑖/2*UFO::{}::cw^(-2)*UFO::{}::ee^2*UFO::{}::sw^2*UFO::{}::vev+1𝑖/2*UFO::{}::cw^2*UFO::{}::ee^2*UFO::{}::sw^(-2)*UFO::{}::vev",
+      "name": "GC_81",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        67.5436878949301
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1*UFO::{}::yb",
+      "name": "GC_82",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.01705802250724524,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::yb",
+      "name": "GC_83",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.01705802250724524
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::yc",
+      "name": "GC_84",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.005158021091476537
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*UFO::{}::yc",
+      "name": "GC_85",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.005158021091476537,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::ye",
+      "name": "GC_86",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -2.93504855786976e-06,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ye",
+      "name": "GC_87",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        2.93504855786976e-06,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1*UFO::{}::ye",
+      "name": "GC_88",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -2.0753927383815043e-06,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::ye",
+      "name": "GC_89",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -2.0753927383815043e-06
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::ym",
+      "name": "GC_90",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.0006068830344902521,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ym",
+      "name": "GC_91",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0006068830344902521,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1*UFO::{}::ym",
+      "name": "GC_92",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.0004291311090751267,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::ym",
+      "name": "GC_93",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.0004291311090751267
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::yt",
+      "name": "GC_94",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.6681058815337719
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*UFO::{}::yt",
+      "name": "GC_95",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.6681058815337719,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::ytau",
+      "name": "GC_96",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.010206617000654722,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ytau",
+      "name": "GC_97",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.010206617000654722,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1*UFO::{}::ytau",
+      "name": "GC_98",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.007217168094136855,
+        0.0
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*-1𝑖*UFO::{}::ytau",
+      "name": "GC_99",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.007217168094136855
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM1x1)",
+      "name": "GC_100",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.4501822404312442
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM1x2)",
+      "name": "GC_101",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.10406729130552157
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM1x3)",
+      "name": "GC_102",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.001455467036557634,
+        0.0005634065947965036
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM2x1)",
+      "name": "GC_103",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.10406729130552157
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM2x2)",
+      "name": "GC_104",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.4501822404312442
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM2x3)",
+      "name": "GC_105",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.01894465947075628
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM3x1)",
+      "name": "GC_106",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        -0.001455467036557634,
+        0.003704825183964887
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM3x2)",
+      "name": "GC_107",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        -0.01894465947075628
+      ]
+    },
+    {
+      "expression": "(1/2)^(1/2)*1𝑖*UFO::{}::ee*UFO::{}::sw^(-1)*conj(UFO::{}::CKM3x3)",
+      "name": "GC_108",
+      "orders": [
+        [
+          "QED",
+          1
+        ]
+      ],
+      "value": [
+        0.0,
+        0.46190542079681124
+      ]
+    }
+  ],
+  "form_factors": [],
+  "functions": [
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "complexconjugate"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "re"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "im"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "sec"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "asec"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "csc"
+    },
+    {
+      "arguments": [
+        "z"
+      ],
+      "expression": null,
+      "name": "acsc"
+    }
+  ],
+  "lorentz_structures": [
+    {
+      "name": "UUS1",
+      "spins": [
+        -1,
+        -1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "UUV1",
+      "spins": [
+        -1,
+        -1,
+        3
+      ],
+      "structure": "-1*UFO::{}::P(UFO::{}::idx(1,3),UFO::{}::idx(1,2))"
+    },
+    {
+      "name": "SSS1",
+      "spins": [
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "FFS1",
+      "spins": [
+        2,
+        2,
+        1
+      ],
+      "structure": "UFO::{}::ProjM(UFO::{}::idx(1,2),UFO::{}::idx(1,1))"
+    },
+    {
+      "name": "FFS2",
+      "spins": [
+        2,
+        2,
+        1
+      ],
+      "structure": "-1*UFO::{}::ProjP(UFO::{}::idx(1,2),UFO::{}::idx(1,1))+UFO::{}::ProjM(UFO::{}::idx(1,2),UFO::{}::idx(1,1))"
+    },
+    {
+      "name": "FFS3",
+      "spins": [
+        2,
+        2,
+        1
+      ],
+      "structure": "UFO::{}::ProjP(UFO::{}::idx(1,2),UFO::{}::idx(1,1))"
+    },
+    {
+      "name": "FFS4",
+      "spins": [
+        2,
+        2,
+        1
+      ],
+      "structure": "UFO::{}::ProjM(UFO::{}::idx(1,2),UFO::{}::idx(1,1))+UFO::{}::ProjP(UFO::{}::idx(1,2),UFO::{}::idx(1,1))"
+    },
+    {
+      "name": "FFV1",
+      "spins": [
+        2,
+        2,
+        3
+      ],
+      "structure": "UFO::{}::Gamma(UFO::{}::idx(1,3),UFO::{}::idx(1,2),UFO::{}::idx(1,1))"
+    },
+    {
+      "name": "FFV2",
+      "spins": [
+        2,
+        2,
+        3
+      ],
+      "structure": "UFO::{}::Gamma(UFO::{}::idx(1,3),UFO::{}::idx(1,2),UFO::{}::dummy(1))*UFO::{}::ProjM(UFO::{}::dummy(1),UFO::{}::idx(1,1))"
+    },
+    {
+      "name": "FFV3",
+      "spins": [
+        2,
+        2,
+        3
+      ],
+      "structure": "-2*UFO::{}::Gamma(UFO::{}::idx(1,3),UFO::{}::idx(1,2),UFO::{}::dummy(1))*UFO::{}::ProjP(UFO::{}::dummy(1),UFO::{}::idx(1,1))+UFO::{}::Gamma(UFO::{}::idx(1,3),UFO::{}::idx(1,2),UFO::{}::dummy(1))*UFO::{}::ProjM(UFO::{}::dummy(1),UFO::{}::idx(1,1))"
+    },
+    {
+      "name": "FFV4",
+      "spins": [
+        2,
+        2,
+        3
+      ],
+      "structure": "2*UFO::{}::Gamma(UFO::{}::idx(1,3),UFO::{}::idx(1,2),UFO::{}::dummy(1))*UFO::{}::ProjP(UFO::{}::dummy(1),UFO::{}::idx(1,1))+UFO::{}::Gamma(UFO::{}::idx(1,3),UFO::{}::idx(1,2),UFO::{}::dummy(1))*UFO::{}::ProjM(UFO::{}::dummy(1),UFO::{}::idx(1,1))"
+    },
+    {
+      "name": "FFV5",
+      "spins": [
+        2,
+        2,
+        3
+      ],
+      "structure": "4*UFO::{}::Gamma(UFO::{}::idx(1,3),UFO::{}::idx(1,2),UFO::{}::dummy(1))*UFO::{}::ProjP(UFO::{}::dummy(1),UFO::{}::idx(1,1))+UFO::{}::Gamma(UFO::{}::idx(1,3),UFO::{}::idx(1,2),UFO::{}::dummy(1))*UFO::{}::ProjM(UFO::{}::dummy(1),UFO::{}::idx(1,1))"
+    },
+    {
+      "name": "VSS1",
+      "spins": [
+        3,
+        1,
+        1
+      ],
+      "structure": "-1*UFO::{}::P(UFO::{}::idx(1,1),UFO::{}::idx(1,3))+UFO::{}::P(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+    },
+    {
+      "name": "VVS1",
+      "spins": [
+        3,
+        3,
+        1
+      ],
+      "structure": "UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+    },
+    {
+      "name": "VVV1",
+      "spins": [
+        3,
+        3,
+        3
+      ],
+      "structure": "-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::P(UFO::{}::idx(1,3),UFO::{}::idx(1,2))+-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,3))*UFO::{}::P(UFO::{}::idx(1,2),UFO::{}::idx(1,1))+-1*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,3))*UFO::{}::P(UFO::{}::idx(1,1),UFO::{}::idx(1,3))+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::P(UFO::{}::idx(1,3),UFO::{}::idx(1,1))+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,3))*UFO::{}::P(UFO::{}::idx(1,2),UFO::{}::idx(1,3))+UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,3))*UFO::{}::P(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+    },
+    {
+      "name": "SSSS1",
+      "spins": [
+        1,
+        1,
+        1,
+        1
+      ],
+      "structure": "1"
+    },
+    {
+      "name": "VVSS1",
+      "spins": [
+        3,
+        3,
+        1,
+        1
+      ],
+      "structure": "UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))"
+    },
+    {
+      "name": "VVVV1",
+      "spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "structure": "-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,3))*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,4))+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,4))*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,3))"
+    },
+    {
+      "name": "VVVV2",
+      "spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "structure": "-2*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::Metric(UFO::{}::idx(1,3),UFO::{}::idx(1,4))+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,3))*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,4))+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,4))*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,3))"
+    },
+    {
+      "name": "VVVV3",
+      "spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "structure": "-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::Metric(UFO::{}::idx(1,3),UFO::{}::idx(1,4))+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,4))*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,3))"
+    },
+    {
+      "name": "VVVV4",
+      "spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "structure": "-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::Metric(UFO::{}::idx(1,3),UFO::{}::idx(1,4))+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,3))*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,4))"
+    },
+    {
+      "name": "VVVV5",
+      "spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "structure": "-1/2*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::Metric(UFO::{}::idx(1,3),UFO::{}::idx(1,4))+-1/2*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,3))*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,4))+UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,4))*UFO::{}::Metric(UFO::{}::idx(1,2),UFO::{}::idx(1,3))"
+    }
+  ],
+  "name": "sm",
+  "orders": [
+    {
+      "expansion_order": 99,
+      "hierarchy": 1,
+      "name": "QCD"
+    },
+    {
+      "expansion_order": 99,
+      "hierarchy": 2,
+      "name": "QED"
+    }
+  ],
+  "parameters": [
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        1
+      ],
+      "name": "aEWM1",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        132.50698,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        2
+      ],
+      "name": "Gf",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.16639e-05,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "SMINPUTS",
+      "lhacode": [
+        3
+      ],
+      "name": "aS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.118,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "Wolfenstein",
+      "lhacode": [
+        1
+      ],
+      "name": "lamWS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.2253,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "Wolfenstein",
+      "lhacode": [
+        2
+      ],
+      "name": "AWS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.808,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "Wolfenstein",
+      "lhacode": [
+        3
+      ],
+      "name": "rhoWS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.132,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "Wolfenstein",
+      "lhacode": [
+        4
+      ],
+      "name": "etaWS",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.341,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        4
+      ],
+      "name": "ymc",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.27,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        5
+      ],
+      "name": "ymb",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        4.2,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        6
+      ],
+      "name": "ymt",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        164.5,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        11
+      ],
+      "name": "yme",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.000511,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        13
+      ],
+      "name": "ymm",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.10566,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "YUKAWA",
+      "lhacode": [
+        15
+      ],
+      "name": "ymtau",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.777,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        23
+      ],
+      "name": "MZ",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        91.188,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        4
+      ],
+      "name": "MC",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.27,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        6
+      ],
+      "name": "MT",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        173.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        5
+      ],
+      "name": "MB",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        4.7,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        25
+      ],
+      "name": "MH",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        125.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        11
+      ],
+      "name": "Me",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.000511,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        13
+      ],
+      "name": "MM",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.10566,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "MASS",
+      "lhacode": [
+        15
+      ],
+      "name": "MTA",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.777,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "DECAY",
+      "lhacode": [
+        23
+      ],
+      "name": "WZ",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        2.44140351,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "DECAY",
+      "lhacode": [
+        24
+      ],
+      "name": "WW",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        2.04759951,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "DECAY",
+      "lhacode": [
+        6
+      ],
+      "name": "WT",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        1.50833649,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "DECAY",
+      "lhacode": [
+        25
+      ],
+      "name": "WH",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        0.00638233934,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": "DECAY",
+      "lhacode": [
+        15
+      ],
+      "name": "WTau",
+      "nature": "external",
+      "parameter_type": "real",
+      "value": [
+        2.27e-12,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ZERO",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "expression": null,
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM3x3",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::lamWS^2+1",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM1x1",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.974619955,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::lamWS",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM1x2",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.2253,
+        0.0
+      ]
+    },
+    {
+      "expression": "(-1𝑖*UFO::{}::etaWS+UFO::{}::rhoWS)*UFO::{}::AWS*UFO::{}::lamWS^3",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM1x3",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.0012197444962317122,
+        -0.0031510066152652563
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::lamWS",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM2x1",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.2253,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1/2*UFO::{}::lamWS^2+1",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM2x2",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.974619955,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::AWS*UFO::{}::lamWS^2",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM2x3",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.04101415272,
+        0.0
+      ]
+    },
+    {
+      "expression": "(-1*UFO::{}::rhoWS+-1𝑖*UFO::{}::etaWS+1)*UFO::{}::AWS*UFO::{}::lamWS^3",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM3x1",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.008020744111584288,
+        -0.0031510066152652563
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::AWS*UFO::{}::lamWS^2",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "CKM3x2",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.04101415272,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::aEWM1^(-1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "aEW",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.00754677225305414,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::aS^(1/2)*𝜋^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "G",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        1.2177157847767195,
+        0.0
+      ]
+    },
+    {
+      "expression": "(((1/2)^(1/2)*-1*UFO::{}::Gf^(-1)*UFO::{}::MZ^2*UFO::{}::aEW*𝜋+1/4*UFO::{}::MZ^4)^(1/2)+1/2*UFO::{}::MZ^2)^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "MW",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        80.4190000176632,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::aEW^(1/2)*𝜋^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ee",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.3079537904849374,
+        0.0
+      ]
+    },
+    {
+      "expression": "-1*UFO::{}::MW^2*UFO::{}::MZ^(-2)+1",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "sw2",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.22224653275123984,
+        0.0
+      ]
+    },
+    {
+      "expression": "(-1*UFO::{}::sw2+1)^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "cw",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.8819033208060622,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::sw2^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "sw",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.47143030529574553,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::cw^(-1)*UFO::{}::ee",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "g1",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.3491922336832418,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::ee*UFO::{}::sw^(-1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "gw",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.653232910624502,
+        0.0
+      ]
+    },
+    {
+      "expression": "2*UFO::{}::MW*UFO::{}::ee^(-1)*UFO::{}::sw",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "vev",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        246.21845810181625,
+        0.0
+      ]
+    },
+    {
+      "expression": "1/2*UFO::{}::MH^2*UFO::{}::vev^(-2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "lam",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.12886910601690277,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::ymb",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "yb",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.024123686777011728,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::ymc",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "yc",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.007294543382572593,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::yme",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ye",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        2.93504855786976e-06,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::ymm",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ym",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.0006068830344902521,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::ymt",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "yt",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.9448443987662926,
+        0.0
+      ]
+    },
+    {
+      "expression": "2^(1/2)*UFO::{}::vev^(-1)*UFO::{}::ymtau",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "ytau",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        0.010206617000654722,
+        0.0
+      ]
+    },
+    {
+      "expression": "(UFO::{}::lam*UFO::{}::vev^2)^(1/2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "muH",
+      "nature": "internal",
+      "parameter_type": "real",
+      "value": [
+        88.38834764831844,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yb*conj(UFO::{}::CKM1x3)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I1x31",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        2.9424734175077786e-05,
+        7.601389661895094e-05
+      ]
+    },
+    {
+      "expression": "UFO::{}::yb*conj(UFO::{}::CKM2x3)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I1x32",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.0009894125736418036,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yb*conj(UFO::{}::CKM3x3)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I1x33",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.024123686777011728,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yc*conj(UFO::{}::CKM2x1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x12",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.0016434606240936052,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yt*conj(UFO::{}::CKM3x1)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x13",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.007578355147768138,
+        0.0029772109509089116
+      ]
+    },
+    {
+      "expression": "UFO::{}::yc*conj(UFO::{}::CKM2x2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x22",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.007109407543268448,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yt*conj(UFO::{}::CKM3x2)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x23",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.0387519924676373,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yc*conj(UFO::{}::CKM2x3)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x32",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.00029917951631549774,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::yt*conj(UFO::{}::CKM3x3)",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I2x33",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.9448443987662926,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM2x1*UFO::{}::yc",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x21",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.0016434606240936052,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM2x2*UFO::{}::yc",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x22",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.007109407543268448,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM2x3*UFO::{}::yc",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x23",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.00029917951631549774,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM3x1*UFO::{}::yt",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x31",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.007578355147768138,
+        -0.0029772109509089116
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM3x2*UFO::{}::yt",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x32",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        -0.0387519924676373,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM3x3*UFO::{}::yt",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I3x33",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.9448443987662926,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM1x3*UFO::{}::yb",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I4x13",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        2.9424734175077786e-05,
+        -7.601389661895094e-05
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM2x3*UFO::{}::yb",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I4x23",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.0009894125736418036,
+        0.0
+      ]
+    },
+    {
+      "expression": "UFO::{}::CKM3x3*UFO::{}::yb",
+      "lhablock": null,
+      "lhacode": null,
+      "name": "I4x33",
+      "nature": "internal",
+      "parameter_type": "complex",
+      "value": [
+        0.024123686777011728,
+        0.0
+      ]
+    }
+  ],
+  "particles": [
+    {
+      "antiname": "a",
+      "antitexname": "{\\gamma}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "a",
+      "pdg_code": 22,
+      "propagating": true,
+      "propagator": "a_propFeynman",
+      "spin": 3,
+      "texname": "{\\gamma}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "Z",
+      "antitexname": "{Z}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MZ",
+      "name": "Z",
+      "pdg_code": 23,
+      "propagating": true,
+      "propagator": "Z_propFeynman",
+      "spin": 3,
+      "texname": "{Z}",
+      "width": "WZ",
+      "y_charge": 0
+    },
+    {
+      "antiname": "W-",
+      "antitexname": "{W^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "W+",
+      "pdg_code": 24,
+      "propagating": true,
+      "propagator": "W+_propFeynman",
+      "spin": 3,
+      "texname": "{W^+}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "W+",
+      "antitexname": "{W^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "W-",
+      "pdg_code": -24,
+      "propagating": true,
+      "propagator": "W-_propFeynman",
+      "spin": 3,
+      "texname": "{W^-}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "g",
+      "antitexname": "{g}",
+      "charge": 0.0,
+      "color": 8,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "g",
+      "pdg_code": 21,
+      "propagating": true,
+      "propagator": "g_propFeynman",
+      "spin": 3,
+      "texname": "{g}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghA~",
+      "antitexname": "\\overline{\\tilde{\\gamma}}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "ghA",
+      "pdg_code": 9000001,
+      "propagating": true,
+      "propagator": "ghA_propFeynman",
+      "spin": -1,
+      "texname": "\\tilde{\\gamma}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghA",
+      "antitexname": "\\tilde{\\gamma}",
+      "charge": -0.0,
+      "color": 1,
+      "ghost_number": -1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "ghA~",
+      "pdg_code": -9000001,
+      "propagating": true,
+      "propagator": "ghA~_propFeynman",
+      "spin": -1,
+      "texname": "\\overline{\\tilde{\\gamma}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghZ~",
+      "antitexname": "\\bar{\\tilde{Z}}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MZ",
+      "name": "ghZ",
+      "pdg_code": 9000002,
+      "propagating": true,
+      "propagator": "ghZ_propFeynman",
+      "spin": -1,
+      "texname": "\\tilde{Z}",
+      "width": "WZ",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghZ",
+      "antitexname": "\\tilde{Z}",
+      "charge": -0.0,
+      "color": 1,
+      "ghost_number": -1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MZ",
+      "name": "ghZ~",
+      "pdg_code": -9000002,
+      "propagating": true,
+      "propagator": "ghZ~_propFeynman",
+      "spin": -1,
+      "texname": "\\bar{\\tilde{Z}}",
+      "width": "WZ",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghWp~",
+      "antitexname": "{\\bar{\\tilde{W}}^+}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "ghWp",
+      "pdg_code": 9000003,
+      "propagating": true,
+      "propagator": "ghWp_propFeynman",
+      "spin": -1,
+      "texname": "{\\tilde{W}^+}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghWp",
+      "antitexname": "{\\tilde{W}^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": -1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "ghWp~",
+      "pdg_code": -9000003,
+      "propagating": true,
+      "propagator": "ghWp~_propFeynman",
+      "spin": -1,
+      "texname": "{\\bar{\\tilde{W}}^+}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghWm~",
+      "antitexname": "{\\bar{\\tilde{W}}^-}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "ghWm",
+      "pdg_code": 9000004,
+      "propagating": true,
+      "propagator": "ghWm_propFeynman",
+      "spin": -1,
+      "texname": "{\\tilde{W}^-}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghWm",
+      "antitexname": "{\\tilde{W}^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": -1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "ghWm~",
+      "pdg_code": -9000004,
+      "propagating": true,
+      "propagator": "ghWm~_propFeynman",
+      "spin": -1,
+      "texname": "{\\bar{\\tilde{W}}^-}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghG~",
+      "antitexname": "{\\bar{\\tilde{g}}}",
+      "charge": 0.0,
+      "color": 8,
+      "ghost_number": 1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "ghG",
+      "pdg_code": 9000005,
+      "propagating": true,
+      "propagator": "ghG_propFeynman",
+      "spin": -1,
+      "texname": "{\\tilde{g}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ghG",
+      "antitexname": "{\\tilde{g}}",
+      "charge": -0.0,
+      "color": 8,
+      "ghost_number": -1,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "ghG~",
+      "pdg_code": -9000005,
+      "propagating": true,
+      "propagator": "ghG~_propFeynman",
+      "spin": -1,
+      "texname": "{\\bar{\\tilde{g}}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ve~",
+      "antitexname": "{\\overline{\\nu}_e}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "ZERO",
+      "name": "ve",
+      "pdg_code": 12,
+      "propagating": true,
+      "propagator": "ve_propFeynman",
+      "spin": 2,
+      "texname": "{\\nu_e}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ve",
+      "antitexname": "{\\nu_e}",
+      "charge": -0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "ZERO",
+      "name": "ve~",
+      "pdg_code": -12,
+      "propagating": true,
+      "propagator": "ve~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{\\nu}_e}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "vm~",
+      "antitexname": "{\\overline{\\nu}_\\mu}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "ZERO",
+      "name": "vm",
+      "pdg_code": 14,
+      "propagating": true,
+      "propagator": "vm_propFeynman",
+      "spin": 2,
+      "texname": "{\\nu_\\mu}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "vm",
+      "antitexname": "{\\nu_\\mu}",
+      "charge": -0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "ZERO",
+      "name": "vm~",
+      "pdg_code": -14,
+      "propagating": true,
+      "propagator": "vm~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{\\nu}_\\mu}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "vt~",
+      "antitexname": "{\\overline{\\nu}_\\tau}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "ZERO",
+      "name": "vt",
+      "pdg_code": 16,
+      "propagating": true,
+      "propagator": "vt_propFeynman",
+      "spin": 2,
+      "texname": "{\\nu_\\tau}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "vt",
+      "antitexname": "{\\nu_\\tau}",
+      "charge": -0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "ZERO",
+      "name": "vt~",
+      "pdg_code": -16,
+      "propagating": true,
+      "propagator": "vt~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{\\nu}_\\tau}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "u~",
+      "antitexname": "{\\overline{u}}",
+      "charge": 0.6666666666666666,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "u",
+      "pdg_code": 2,
+      "propagating": true,
+      "propagator": "u_propFeynman",
+      "spin": 2,
+      "texname": "{u}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "u",
+      "antitexname": "{u}",
+      "charge": -0.6666666666666666,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "u~",
+      "pdg_code": -2,
+      "propagating": true,
+      "propagator": "u~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{u}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "c~",
+      "antitexname": "{\\overline{c}}",
+      "charge": 0.6666666666666666,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MC",
+      "name": "c",
+      "pdg_code": 4,
+      "propagating": true,
+      "propagator": "c_propFeynman",
+      "spin": 2,
+      "texname": "{c}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "c",
+      "antitexname": "{c}",
+      "charge": -0.6666666666666666,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MC",
+      "name": "c~",
+      "pdg_code": -4,
+      "propagating": true,
+      "propagator": "c~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{c}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "t~",
+      "antitexname": "{\\overline{t}}",
+      "charge": 0.6666666666666666,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MT",
+      "name": "t",
+      "pdg_code": 6,
+      "propagating": true,
+      "propagator": "t_propFeynman",
+      "spin": 2,
+      "texname": "{t}",
+      "width": "WT",
+      "y_charge": 0
+    },
+    {
+      "antiname": "t",
+      "antitexname": "{t}",
+      "charge": -0.6666666666666666,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MT",
+      "name": "t~",
+      "pdg_code": -6,
+      "propagating": true,
+      "propagator": "t~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{t}}",
+      "width": "WT",
+      "y_charge": 0
+    },
+    {
+      "antiname": "d~",
+      "antitexname": "{\\overline{d}}",
+      "charge": -0.3333333333333333,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "d",
+      "pdg_code": 1,
+      "propagating": true,
+      "propagator": "d_propFeynman",
+      "spin": 2,
+      "texname": "{d}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "d",
+      "antitexname": "{d}",
+      "charge": 0.3333333333333333,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "d~",
+      "pdg_code": -1,
+      "propagating": true,
+      "propagator": "d~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{d}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "s~",
+      "antitexname": "{\\overline{s}}",
+      "charge": -0.3333333333333333,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "s",
+      "pdg_code": 3,
+      "propagating": true,
+      "propagator": "s_propFeynman",
+      "spin": 2,
+      "texname": "{s}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "s",
+      "antitexname": "{s}",
+      "charge": 0.3333333333333333,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "ZERO",
+      "name": "s~",
+      "pdg_code": -3,
+      "propagating": true,
+      "propagator": "s~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{s}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "b~",
+      "antitexname": "{\\overline{b}}",
+      "charge": -0.3333333333333333,
+      "color": 3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MB",
+      "name": "b",
+      "pdg_code": 5,
+      "propagating": true,
+      "propagator": "b_propFeynman",
+      "spin": 2,
+      "texname": "{b}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "b",
+      "antitexname": "{b}",
+      "charge": 0.3333333333333333,
+      "color": -3,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MB",
+      "name": "b~",
+      "pdg_code": -5,
+      "propagating": true,
+      "propagator": "b~_propFeynman",
+      "spin": 2,
+      "texname": "{\\overline{b}}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "H",
+      "antitexname": "{H}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 0,
+      "mass": "MH",
+      "name": "H",
+      "pdg_code": 25,
+      "propagating": true,
+      "propagator": "H_propFeynman",
+      "spin": 1,
+      "texname": "{H}",
+      "width": "WH",
+      "y_charge": 0
+    },
+    {
+      "antiname": "G0",
+      "antitexname": "{G_0}",
+      "charge": 0.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": true,
+      "lepton_number": 0,
+      "mass": "MZ",
+      "name": "G0",
+      "pdg_code": 250,
+      "propagating": true,
+      "propagator": "G0_propFeynman",
+      "spin": 1,
+      "texname": "{G_0}",
+      "width": "WZ",
+      "y_charge": 0
+    },
+    {
+      "antiname": "G-",
+      "antitexname": "{G^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": true,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "G+",
+      "pdg_code": 251,
+      "propagating": true,
+      "propagator": "G+_propFeynman",
+      "spin": 1,
+      "texname": "{G^+}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "G+",
+      "antitexname": "{G^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": true,
+      "lepton_number": 0,
+      "mass": "MW",
+      "name": "G-",
+      "pdg_code": -251,
+      "propagating": true,
+      "propagator": "G-_propFeynman",
+      "spin": 1,
+      "texname": "{G^-}",
+      "width": "WW",
+      "y_charge": 0
+    },
+    {
+      "antiname": "e+",
+      "antitexname": "{e^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "Me",
+      "name": "e-",
+      "pdg_code": 11,
+      "propagating": true,
+      "propagator": "e-_propFeynman",
+      "spin": 2,
+      "texname": "{e^-}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "e-",
+      "antitexname": "{e^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "Me",
+      "name": "e+",
+      "pdg_code": -11,
+      "propagating": true,
+      "propagator": "e+_propFeynman",
+      "spin": 2,
+      "texname": "{e^+}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "mu+",
+      "antitexname": "{\\mu^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "MM",
+      "name": "mu-",
+      "pdg_code": 13,
+      "propagating": true,
+      "propagator": "mu-_propFeynman",
+      "spin": 2,
+      "texname": "{\\mu^-}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "mu-",
+      "antitexname": "{\\mu^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "MM",
+      "name": "mu+",
+      "pdg_code": -13,
+      "propagating": true,
+      "propagator": "mu+_propFeynman",
+      "spin": 2,
+      "texname": "{\\mu^+}",
+      "width": "ZERO",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ta+",
+      "antitexname": "{\\tau^+}",
+      "charge": -1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": 1,
+      "mass": "MTA",
+      "name": "ta-",
+      "pdg_code": 15,
+      "propagating": true,
+      "propagator": "ta-_propFeynman",
+      "spin": 2,
+      "texname": "{\\tau^-}",
+      "width": "WTau",
+      "y_charge": 0
+    },
+    {
+      "antiname": "ta-",
+      "antitexname": "{\\tau^-}",
+      "charge": 1.0,
+      "color": 1,
+      "ghost_number": 0,
+      "goldstoneboson": false,
+      "lepton_number": -1,
+      "mass": "MTA",
+      "name": "ta+",
+      "pdg_code": -15,
+      "propagating": true,
+      "propagator": "ta+_propFeynman",
+      "spin": 2,
+      "texname": "{\\tau^+}",
+      "width": "WTau",
+      "y_charge": 0
+    }
+  ],
+  "propagators": [
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "a_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))",
+      "particle": "a"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MZ^2",
+      "name": "Z_propFeynman",
+      "numerator": "(-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))+UFO::{}::MZ^(-2)*UFO::{}::P(UFO::{}::idx(1,1))*UFO::{}::P(UFO::{}::idx(1,2)))*1𝑖",
+      "particle": "Z"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MW^2",
+      "name": "W+_propFeynman",
+      "numerator": "(-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))+UFO::{}::MW^(-2)*UFO::{}::P(UFO::{}::idx(1,1))*UFO::{}::P(UFO::{}::idx(1,2)))*1𝑖",
+      "particle": "W+"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MW^2",
+      "name": "W-_propFeynman",
+      "numerator": "(-1*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))+UFO::{}::MW^(-2)*UFO::{}::P(UFO::{}::idx(1,1))*UFO::{}::P(UFO::{}::idx(1,2)))*1𝑖",
+      "particle": "W-"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "g_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::Metric(UFO::{}::idx(1,1),UFO::{}::idx(1,2))",
+      "particle": "g"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "ghA_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghA"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "ghA~_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghA~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MZ^2",
+      "name": "ghZ_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghZ"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MZ^2",
+      "name": "ghZ~_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghZ~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MW^2",
+      "name": "ghWp_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghWp"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MW^2",
+      "name": "ghWp~_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghWp~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MW^2",
+      "name": "ghWm_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghWm"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MW^2",
+      "name": "ghWm~_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghWm~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "ghG_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghG"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "ghG~_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "ghG~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "ve_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1))",
+      "particle": "ve"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "ve~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))",
+      "particle": "ve~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "vm_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1))",
+      "particle": "vm"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "vm~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))",
+      "particle": "vm~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "vt_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1))",
+      "particle": "vt"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "vt~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))",
+      "particle": "vt~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "u_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1))",
+      "particle": "u"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "u~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))",
+      "particle": "u~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MC^2",
+      "name": "c_propFeynman",
+      "numerator": "(UFO::{}::Identity(UFO::{}::idx(1,2),UFO::{}::idx(1,1))*UFO::{}::MC+UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1)))*1𝑖",
+      "particle": "c"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MC^2",
+      "name": "c~_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))+UFO::{}::Identity(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::MC)*1𝑖",
+      "particle": "c~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MT^2",
+      "name": "t_propFeynman",
+      "numerator": "(UFO::{}::Identity(UFO::{}::idx(1,2),UFO::{}::idx(1,1))*UFO::{}::MT+UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1)))*1𝑖",
+      "particle": "t"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MT^2",
+      "name": "t~_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))+UFO::{}::Identity(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::MT)*1𝑖",
+      "particle": "t~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "d_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1))",
+      "particle": "d"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "d~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))",
+      "particle": "d~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "s_propFeynman",
+      "numerator": "1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1))",
+      "particle": "s"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2",
+      "name": "s~_propFeynman",
+      "numerator": "-1𝑖*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))",
+      "particle": "s~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MB^2",
+      "name": "b_propFeynman",
+      "numerator": "(UFO::{}::Identity(UFO::{}::idx(1,2),UFO::{}::idx(1,1))*UFO::{}::MB+UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1)))*1𝑖",
+      "particle": "b"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MB^2",
+      "name": "b~_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))+UFO::{}::Identity(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::MB)*1𝑖",
+      "particle": "b~"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MH^2",
+      "name": "H_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "H"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MZ^2",
+      "name": "G0_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "G0"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MW^2",
+      "name": "G+_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "G+"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MW^2",
+      "name": "G-_propFeynman",
+      "numerator": "1𝑖",
+      "particle": "G-"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::Me^2",
+      "name": "e-_propFeynman",
+      "numerator": "(UFO::{}::Identity(UFO::{}::idx(1,2),UFO::{}::idx(1,1))*UFO::{}::Me+UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1)))*1𝑖",
+      "particle": "e-"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::Me^2",
+      "name": "e+_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))+UFO::{}::Identity(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::Me)*1𝑖",
+      "particle": "e+"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MM^2",
+      "name": "mu-_propFeynman",
+      "numerator": "(UFO::{}::Identity(UFO::{}::idx(1,2),UFO::{}::idx(1,1))*UFO::{}::MM+UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1)))*1𝑖",
+      "particle": "mu-"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MM^2",
+      "name": "mu+_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))+UFO::{}::Identity(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::MM)*1𝑖",
+      "particle": "mu+"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MTA^2",
+      "name": "ta-_propFeynman",
+      "numerator": "(UFO::{}::Identity(UFO::{}::idx(1,2),UFO::{}::idx(1,1))*UFO::{}::MTA+UFO::{}::PSlash(UFO::{}::idx(1,2),UFO::{}::idx(1,1)))*1𝑖",
+      "particle": "ta-"
+    },
+    {
+      "denominator": "(UFO::{}::P(UFO::{}::idx(1,1)))^2+-1*UFO::{}::MTA^2",
+      "name": "ta+_propFeynman",
+      "numerator": "(-1*UFO::{}::PSlash(UFO::{}::idx(1,1),UFO::{}::idx(1,2))+UFO::{}::Identity(UFO::{}::idx(1,1),UFO::{}::idx(1,2))*UFO::{}::MTA)*1𝑖",
+      "particle": "ta+"
+    }
+  ],
+  "restriction": null,
+  "vertex_rules": [
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_33"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_1",
+      "particles": [
+        "G0",
+        "G0",
+        "G0",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_31"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_2",
+      "particles": [
+        "G0",
+        "G0",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_32"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_3",
+      "particles": [
+        "G-",
+        "G-",
+        "G+",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_31"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_4",
+      "particles": [
+        "G0",
+        "G0",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_31"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_5",
+      "particles": [
+        "G-",
+        "G+",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_33"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSSS1"
+      ],
+      "name": "V_6",
+      "particles": [
+        "H",
+        "H",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_68"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSS1"
+      ],
+      "name": "V_7",
+      "particles": [
+        "G0",
+        "G0",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_68"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSS1"
+      ],
+      "name": "V_8",
+      "particles": [
+        "G-",
+        "G+",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_69"
+        ]
+      ],
+      "lorentz_structures": [
+        "SSS1"
+      ],
+      "name": "V_9",
+      "particles": [
+        "H",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_6"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_10",
+      "particles": [
+        "a",
+        "a",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_11",
+      "particles": [
+        "a",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_12",
+      "particles": [
+        "ghA",
+        "ghWm~",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_4"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_13",
+      "particles": [
+        "ghA",
+        "ghWp~",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_75"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_14",
+      "particles": [
+        "ghWm",
+        "ghA~",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_15",
+      "particles": [
+        "ghWm",
+        "ghA~",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_70"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_16",
+      "particles": [
+        "ghWm",
+        "ghWm~",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_71"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_17",
+      "particles": [
+        "ghWm",
+        "ghWm~",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_4"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_18",
+      "particles": [
+        "ghWm",
+        "ghWm~",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_53"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_19",
+      "particles": [
+        "ghWm",
+        "ghWm~",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_78"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_20",
+      "particles": [
+        "ghWm",
+        "ghZ~",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_52"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_21",
+      "particles": [
+        "ghWm",
+        "ghZ~",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_74"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_22",
+      "particles": [
+        "ghWp",
+        "ghA~",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_4"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_23",
+      "particles": [
+        "ghWp",
+        "ghA~",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_73"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_24",
+      "particles": [
+        "ghWp",
+        "ghWp~",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_71"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_25",
+      "particles": [
+        "ghWp",
+        "ghWp~",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_26",
+      "particles": [
+        "ghWp",
+        "ghWp~",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_52"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_27",
+      "particles": [
+        "ghWp",
+        "ghWp~",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_77"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_28",
+      "particles": [
+        "ghWp",
+        "ghZ~",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_53"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_29",
+      "particles": [
+        "ghWp",
+        "ghZ~",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_79"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_30",
+      "particles": [
+        "ghZ",
+        "ghWm~",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_52"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_31",
+      "particles": [
+        "ghZ",
+        "ghWm~",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_76"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_32",
+      "particles": [
+        "ghZ",
+        "ghWp~",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_53"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_33",
+      "particles": [
+        "ghZ",
+        "ghWp~",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_80"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUS1"
+      ],
+      "name": "V_34",
+      "particles": [
+        "ghZ",
+        "ghZ~",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::f(3,1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_10"
+        ]
+      ],
+      "lorentz_structures": [
+        "UUV1"
+      ],
+      "name": "V_35",
+      "particles": [
+        "ghG",
+        "ghG~",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::f(1,2,3)"
+      ],
+      "couplings": [
+        [
+          "GC_10"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVV1"
+      ],
+      "name": "V_36",
+      "particles": [
+        "g",
+        "g",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::f(-1,1,2)*UFO::{}::f(3,4,-1)",
+        "UFO::{}::f(-1,1,3)*UFO::{}::f(2,4,-1)",
+        "UFO::{}::f(-1,1,4)*UFO::{}::f(2,3,-1)"
+      ],
+      "couplings": [
+        [
+          "GC_12",
+          null,
+          null
+        ],
+        [
+          null,
+          "GC_12",
+          null
+        ],
+        [
+          null,
+          null,
+          "GC_12"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVVV1",
+        "VVVV3",
+        "VVVV4"
+      ],
+      "name": "V_37",
+      "particles": [
+        "g",
+        "g",
+        "g",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_55"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_38",
+      "particles": [
+        "a",
+        "W-",
+        "G0",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_54"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_39",
+      "particles": [
+        "a",
+        "W-",
+        "G+",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_74"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_40",
+      "particles": [
+        "a",
+        "W-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_39"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_41",
+      "particles": [
+        "W-",
+        "G0",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_37"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_42",
+      "particles": [
+        "W-",
+        "G+",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_4"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVV1"
+      ],
+      "name": "V_43",
+      "particles": [
+        "a",
+        "W-",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_55"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_44",
+      "particles": [
+        "a",
+        "W+",
+        "G0",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_56"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_45",
+      "particles": [
+        "a",
+        "W+",
+        "G-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_75"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_46",
+      "particles": [
+        "a",
+        "W+",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_38"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_47",
+      "particles": [
+        "W+",
+        "G0",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_37"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_48",
+      "particles": [
+        "W+",
+        "G-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_34"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_49",
+      "particles": [
+        "W-",
+        "W+",
+        "G0",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_34"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_50",
+      "particles": [
+        "W-",
+        "W+",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_34"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_51",
+      "particles": [
+        "W-",
+        "W+",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_72"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_52",
+      "particles": [
+        "W-",
+        "W+",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_5"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVVV2"
+      ],
+      "name": "V_53",
+      "particles": [
+        "a",
+        "a",
+        "W-",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_53"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVV1"
+      ],
+      "name": "V_54",
+      "particles": [
+        "W-",
+        "W+",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_35"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVVV2"
+      ],
+      "name": "V_55",
+      "particles": [
+        "W-",
+        "W-",
+        "W+",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_63"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_56",
+      "particles": [
+        "a",
+        "Z",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_60"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_57",
+      "particles": [
+        "Z",
+        "G0",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_61"
+        ]
+      ],
+      "lorentz_structures": [
+        "VSS1"
+      ],
+      "name": "V_58",
+      "particles": [
+        "Z",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_8"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_59",
+      "particles": [
+        "W-",
+        "Z",
+        "G0",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_9"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_60",
+      "particles": [
+        "W-",
+        "Z",
+        "G+",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_67"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_61",
+      "particles": [
+        "W-",
+        "Z",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_8"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_62",
+      "particles": [
+        "W+",
+        "Z",
+        "G0",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_7"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_63",
+      "particles": [
+        "W+",
+        "Z",
+        "G-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_66"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_64",
+      "particles": [
+        "W+",
+        "Z",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_57"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVVV5"
+      ],
+      "name": "V_65",
+      "particles": [
+        "a",
+        "W-",
+        "W+",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_65"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_66",
+      "particles": [
+        "Z",
+        "Z",
+        "G0",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_64"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_67",
+      "particles": [
+        "Z",
+        "Z",
+        "G-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_65"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVSS1"
+      ],
+      "name": "V_68",
+      "particles": [
+        "Z",
+        "Z",
+        "H",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_81"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVS1"
+      ],
+      "name": "V_69",
+      "particles": [
+        "Z",
+        "Z",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_36"
+        ]
+      ],
+      "lorentz_structures": [
+        "VVVV2"
+      ],
+      "name": "V_70",
+      "particles": [
+        "W-",
+        "W+",
+        "Z",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_1"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_71",
+      "particles": [
+        "d~",
+        "d",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_1"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_72",
+      "particles": [
+        "s~",
+        "s",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_1"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_73",
+      "particles": [
+        "b~",
+        "b",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_74",
+      "particles": [
+        "d~",
+        "d",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_75",
+      "particles": [
+        "s~",
+        "s",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_76",
+      "particles": [
+        "b~",
+        "b",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_82"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_77",
+      "particles": [
+        "b~",
+        "b",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_83"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_78",
+      "particles": [
+        "b~",
+        "b",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV3"
+      ],
+      "name": "V_79",
+      "particles": [
+        "d~",
+        "d",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV3"
+      ],
+      "name": "V_80",
+      "particles": [
+        "s~",
+        "s",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV3"
+      ],
+      "name": "V_81",
+      "particles": [
+        "b~",
+        "b",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_16"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_82",
+      "particles": [
+        "c~",
+        "d",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_17"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_83",
+      "particles": [
+        "t~",
+        "d",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_18"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_84",
+      "particles": [
+        "c~",
+        "s",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_19"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_85",
+      "particles": [
+        "t~",
+        "s",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_13"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_86",
+      "particles": [
+        "u~",
+        "b",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_14",
+          "GC_20"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1",
+        "FFS3"
+      ],
+      "name": "V_87",
+      "particles": [
+        "c~",
+        "b",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_15",
+          "GC_21"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1",
+        "FFS3"
+      ],
+      "name": "V_88",
+      "particles": [
+        "t~",
+        "b",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_100"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_89",
+      "particles": [
+        "u~",
+        "d",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_103"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_90",
+      "particles": [
+        "c~",
+        "d",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_106"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_91",
+      "particles": [
+        "t~",
+        "d",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_101"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_92",
+      "particles": [
+        "u~",
+        "s",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_104"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_93",
+      "particles": [
+        "c~",
+        "s",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_107"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_94",
+      "particles": [
+        "t~",
+        "s",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_102"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_95",
+      "particles": [
+        "u~",
+        "b",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_105"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_96",
+      "particles": [
+        "c~",
+        "b",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_108"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_97",
+      "particles": [
+        "t~",
+        "b",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_98",
+      "particles": [
+        "e+",
+        "e-",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_99",
+      "particles": [
+        "mu+",
+        "mu-",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_3"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_100",
+      "particles": [
+        "ta+",
+        "ta-",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_88"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_101",
+      "particles": [
+        "e+",
+        "e-",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_92"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_102",
+      "particles": [
+        "mu+",
+        "mu-",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_98"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_103",
+      "particles": [
+        "ta+",
+        "ta-",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_89"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_104",
+      "particles": [
+        "e+",
+        "e-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_93"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_105",
+      "particles": [
+        "mu+",
+        "mu-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_99"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_106",
+      "particles": [
+        "ta+",
+        "ta-",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_59"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV4"
+      ],
+      "name": "V_107",
+      "particles": [
+        "e+",
+        "e-",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_59"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV4"
+      ],
+      "name": "V_108",
+      "particles": [
+        "mu+",
+        "mu-",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_50",
+          "GC_59"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV4"
+      ],
+      "name": "V_109",
+      "particles": [
+        "ta+",
+        "ta-",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_87"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_110",
+      "particles": [
+        "ve~",
+        "e-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_91"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_111",
+      "particles": [
+        "vm~",
+        "mu-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_97"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_112",
+      "particles": [
+        "vt~",
+        "ta-",
+        "G+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_113",
+      "particles": [
+        "ve~",
+        "e-",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_114",
+      "particles": [
+        "vm~",
+        "mu-",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_115",
+      "particles": [
+        "vt~",
+        "ta-",
+        "W+"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_28"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_116",
+      "particles": [
+        "b~",
+        "u",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_22"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_117",
+      "particles": [
+        "d~",
+        "c",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_23"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_118",
+      "particles": [
+        "s~",
+        "c",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_24",
+          "GC_29"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1",
+        "FFS3"
+      ],
+      "name": "V_119",
+      "particles": [
+        "b~",
+        "c",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_25"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_120",
+      "particles": [
+        "d~",
+        "t",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_26"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1"
+      ],
+      "name": "V_121",
+      "particles": [
+        "s~",
+        "t",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_27",
+          "GC_30"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS1",
+        "FFS3"
+      ],
+      "name": "V_122",
+      "particles": [
+        "b~",
+        "t",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_41"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_123",
+      "particles": [
+        "d~",
+        "u",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_42"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_124",
+      "particles": [
+        "s~",
+        "u",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_43"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_125",
+      "particles": [
+        "b~",
+        "u",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_44"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_126",
+      "particles": [
+        "d~",
+        "c",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_45"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_127",
+      "particles": [
+        "s~",
+        "c",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_46"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_128",
+      "particles": [
+        "b~",
+        "c",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_47"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_129",
+      "particles": [
+        "d~",
+        "t",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_48"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_130",
+      "particles": [
+        "s~",
+        "t",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_49"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_131",
+      "particles": [
+        "b~",
+        "t",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_2"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_132",
+      "particles": [
+        "u~",
+        "u",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_2"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_133",
+      "particles": [
+        "c~",
+        "c",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_2"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_134",
+      "particles": [
+        "t~",
+        "t",
+        "a"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_135",
+      "particles": [
+        "u~",
+        "u",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_136",
+      "particles": [
+        "c~",
+        "c",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::T(3,2,1)"
+      ],
+      "couplings": [
+        [
+          "GC_11"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV1"
+      ],
+      "name": "V_137",
+      "particles": [
+        "t~",
+        "t",
+        "g"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_85"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_138",
+      "particles": [
+        "c~",
+        "c",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_95"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS2"
+      ],
+      "name": "V_139",
+      "particles": [
+        "t~",
+        "t",
+        "G0"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_84"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_140",
+      "particles": [
+        "c~",
+        "c",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_94"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS4"
+      ],
+      "name": "V_141",
+      "particles": [
+        "t~",
+        "t",
+        "H"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_51",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV5"
+      ],
+      "name": "V_142",
+      "particles": [
+        "u~",
+        "u",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_51",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV5"
+      ],
+      "name": "V_143",
+      "particles": [
+        "c~",
+        "c",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "UFO::{}::Identity(1,2)"
+      ],
+      "couplings": [
+        [
+          "GC_51",
+          "GC_58"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2",
+        "FFV5"
+      ],
+      "name": "V_144",
+      "particles": [
+        "t~",
+        "t",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_86"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_145",
+      "particles": [
+        "e+",
+        "ve",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_90"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_146",
+      "particles": [
+        "mu+",
+        "vm",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_96"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFS3"
+      ],
+      "name": "V_147",
+      "particles": [
+        "ta+",
+        "vt",
+        "G-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_148",
+      "particles": [
+        "e+",
+        "ve",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_149",
+      "particles": [
+        "mu+",
+        "vm",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_40"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_150",
+      "particles": [
+        "ta+",
+        "vt",
+        "W-"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_62"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_151",
+      "particles": [
+        "ve~",
+        "ve",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_62"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_152",
+      "particles": [
+        "vm~",
+        "vm",
+        "Z"
+      ]
+    },
+    {
+      "color_structures": [
+        "1"
+      ],
+      "couplings": [
+        [
+          "GC_62"
+        ]
+      ],
+      "lorentz_structures": [
+        "FFV2"
+      ],
+      "name": "V_153",
+      "particles": [
+        "vt~",
+        "vt",
+        "Z"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/__init__.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/__init__.py
new file mode 100644
index 0000000000..9a3ad6aac9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/__init__.py
@@ -0,0 +1,25 @@
+# type: ignore
+from __future__ import absolute_import
+from . import particles
+from . import couplings
+from . import lorentz
+from . import parameters
+from . import vertices
+from . import coupling_orders
+from . import function_library
+from . import object_library
+
+gauge = [0]
+
+all_particles = particles.all_particles
+all_vertices = vertices.all_vertices
+all_couplings = couplings.all_couplings
+all_lorentz = lorentz.all_lorentz
+all_parameters = parameters.all_parameters
+all_orders = coupling_orders.all_orders
+all_functions = function_library.all_functions
+
+
+__author__ = "Valentin Hirschi"
+__version__ = "1.0"
+__email__ = "valentin.hirschi@gmail.com"
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/coupling_orders.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/coupling_orders.py
new file mode 100644
index 0000000000..f6a1ec99fb
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/coupling_orders.py
@@ -0,0 +1,16 @@
+# type: ignore
+from __future__ import absolute_import
+from .object_library import all_orders, CouplingOrder
+
+# Keep the coupling order names QCD and QED as they are hard-coded standards in some generators
+QCD = CouplingOrder(name='QCD',
+                    expansion_order=99,
+                    hierarchy=1)
+
+QED = CouplingOrder(name='QED',
+                    expansion_order=99,
+                    hierarchy=2)
+
+GRAV = CouplingOrder(name='GRAV',
+                    expansion_order=99,
+                    hierarchy=0)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/couplings.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/couplings.py
new file mode 100644
index 0000000000..643747e8f3
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/couplings.py
@@ -0,0 +1,40 @@
+# type: ignore
+from __future__ import absolute_import
+from .object_library import all_couplings, Coupling
+from . import parameters as Param
+
+for i_scalar in list(range(Param.N_SCALARS)):
+    globals()['SSTmpart%d' % i_scalar] = Coupling(name='SSTmpart%d' % i_scalar,
+                                                  value='%s**2*kappa*complex(0,1)/2' % Param.scalar_mass_parameters[
+                                                      i_scalar].name if i_scalar > 0 else "ZERO",
+                                                  order={'GRAV': 1})
+
+    globals()['SSTTTmpart%d' % i_scalar] = Coupling(name='SSTTTmpart%d' % i_scalar,
+                                                    value='%s**2*kappa**3*complex(0,1)/32' % Param.scalar_mass_parameters[
+                                                        i_scalar].name if i_scalar > 0 else "ZERO",
+                                                    order={'GRAV': 3})
+
+    globals()['SSTTmpart%d' % i_scalar] = Coupling(name='SSTTmpart%d' % i_scalar,
+                                                   value='%s**2*kappa**2*complex(0,1)/8' % Param.scalar_mass_parameters[
+                                                       i_scalar].name if i_scalar > 0 else "ZERO",
+                                                   order={'GRAV': 2})
+
+SST = Coupling(name='SST',
+               value='kappa*complex(0,1)/2',
+               order={'GRAV': 1})
+
+SSTT = Coupling(name='SSTT',
+                value='kappa**2*complex(0,1)/8',
+                order={'GRAV': 2})
+
+SSTTT = Coupling(name='SSTTT',
+                 value='kappa**3*complex(0,1)/32',
+                 order={'GRAV': 3})
+
+TTT = Coupling(name='TTT',
+               value='kappa*complex(0,1)/8',
+               order={'GRAV': 1})
+
+TTTT = Coupling(name='TTTT',
+                value='kappa**2*complex(0,1)/32',
+                order={'GRAV': 2})
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/function_library.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/function_library.py
new file mode 100644
index 0000000000..b2843b6ca0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/function_library.py
@@ -0,0 +1,52 @@
+# type: ignore
+# This file is part of the UFO.
+#
+# This file contains definitions for functions that
+# are extensions of the cmath library, and correspond
+# either to functions that are in cmath, but inconvenient
+# to access from there (e.g. z.conjugate()),
+# or functions that are simply not defined.
+#
+#
+from __future__ import absolute_import
+__date__ = "22 July 2010"
+__author__ = "claude.duhr@durham.ac.uk"
+
+from cmath import cos, sin, acos, asin
+from .object_library import all_functions, Function
+
+#
+# shortcuts for functions from cmath
+#
+
+complexconjugate = Function(name='complexconjugate',
+                            arguments=('z',),
+                            expression='z.conjugate()')
+
+
+re = Function(name='re',
+              arguments=('z',),
+              expression='z.real')
+
+im = Function(name='im',
+              arguments=('z',),
+              expression='z.imag')
+
+
+# New functions (trigonometric)
+
+sec = Function(name='sec',
+               arguments=('z',),
+               expression='1./cos(z)')
+
+asec = Function(name='asec',
+                arguments=('z',),
+                expression='acos(1./z)')
+
+csc = Function(name='csc',
+               arguments=('z',),
+               expression='1./sin(z)')
+
+acsc = Function(name='acsc',
+                arguments=('z',),
+                expression='asin(1./z)')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/lorentz.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/lorentz.py
new file mode 100644
index 0000000000..768a0b9363
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/lorentz.py
@@ -0,0 +1,56 @@
+# type: ignore
+from __future__ import absolute_import
+from .object_library import all_lorentz, Lorentz
+
+from .function_library import complexconjugate, re, im, csc, sec, acsc, asec
+from . import parameters as Param
+
+try:
+    import form_factors as ForFac
+except ImportError:
+    pass
+
+SSTmpart = Lorentz(
+    name='SSTmpart',
+    spins=[1, 1, 5],
+    structure='-Metric(1003,2003)')
+
+SST = Lorentz(
+    name='SST',
+    spins=[1, 1, 5],
+    structure='-P(-1,1)*P(-1,2)*Metric(1003,2003) + P(1003,1)*P(2003,2) + P(2003,1)*P(1003,2)')
+
+SSTTmpart = Lorentz(
+    name='SSTTmpart',
+    spins=[1, 1, 5, 5],
+    structure='2*Metric(1003,1004)*Metric(2003,2004) + 2*Metric(2003,1004)*Metric(2004,1003) - 2*Metric(2003,1003)*Metric(2004,1004)')
+
+SSTT = Lorentz(
+    name='SSTT',
+    spins=[1, 1, 5, 5],
+    structure='(-(Metric(2003,1003)*Metric(2004,1004)*P(-1,1)*P(-1,2)) - Metric(2003,2004)*P(1003,2)*P(1004,1) - Metric(2003,2004)*P(1003,1)*P(1004,2) + Metric(2004,1004)*P(1003,2)*P(2003,1) - Metric(2004,1003)*P(1004,2)*P(2003,1) + Metric(2004,1004)*P(1003,1)*P(2003,2) - Metric(2004,1003)*P(1004,1)*P(2003,2) + Metric(2003,1003)*P(1004,2)*P(2004,1) + Metric(2003,1003)*P(1004,1)*P(2004,2) + Metric(2003,1004)*(Metric(2004,1003)*P(-1,1)*P(-1,2) - P(1003,2)*P(2004,1) - P(1003,1)*P(2004,2)) + Metric(1003,1004)*(Metric(2003,2004)*P(-1,1)*P(-1,2) - P(2003,2)*P(2004,1) - P(2003,1)*P(2004,2)))')
+
+SSTTTmpart = Lorentz(
+    name='SSTTTmpart',
+    spins=[1, 1, 5, 5, 5],
+    structure='Metric(1004,1005)*Metric(2003,2005)*Metric(2004,1003) - Metric(1003,1005)*Metric(2003,2005)*Metric(2004,1004) + Metric(1003,1004)*Metric(2003,2005)*Metric(2004,1005) - Metric(1004,1005)*Metric(2003,1003)*Metric(2004,2005) + Metric(1003,1005)*Metric(2003,1004)*Metric(2004,2005) + Metric(1003,1004)*Metric(2003,1005)*Metric(2004,2005) + Metric(1004,1005)*Metric(2003,2004)*Metric(2005,1003) - Metric(2003,1005)*Metric(2004,1004)*Metric(2005,1003) + Metric(2003,1004)*Metric(2004,1005)*Metric(2005,1003) + Metric(1003,1005)*Metric(2003,2004)*Metric(2005,1004) + Metric(2003,1005)*Metric(2004,1003)*Metric(2005,1004) - Metric(2003,1003)*Metric(2004,1005)*Metric(2005,1004) - Metric(1003,1004)*Metric(2003,2004)*Metric(2005,1005) - Metric(2003,1004)*Metric(2004,1003)*Metric(2005,1005)')
+
+SSTTT = Lorentz(
+    name='SSTTT',
+    spins=[1, 1, 5, 5, 5],
+    structure=('-(Metric(2003,1005)*Metric(2004,1004)*Metric(2005,1003)*P(-1,1)*P(-1,2)) - Metric(2003,1003)*Metric(2004,1005)*Metric(2005,1004)*P(-1,1)*P(-1,2) - Metric(1003,1004)*Metric(2003,2004)*Metric(2005,1005)*P(-1,1)*P(-1,2) - Metric(2003,1004)*Metric(2004,1003)*Metric(2005,1005)*P(-1,1)*P(-1,2) + Metric(2003,1003)*Metric(2004,1004)*Metric(2005,1005)*P(-1,1)*P(-1,2) + Metric(2003,2005)*Metric(2004,1005)*P(1003,2)*P(1004,1) + Metric(2003,1005)*Metric(2004,2005)*P(1003,2)*P(1004,1) + Metric(2003,2005)*Metric(2004,1005)*P(1003,1)*P(1004,2) + Metric(2003,1005)*Metric(2004,2005)*P(1003,1)*P(1004,2) + Metric(2003,1004)*Metric(2004,2005)*P(1003,2)*P(1005,1) + Metric(2003,2004)*Metric(2005,1004)*P(1003,2)*P(1005,1) + Metric(2003,2005)*Metric(2004,1003)*P(1004,2)*P(1005,1) + Metric(2003,2004)*Metric(2005,1003)*P(1004,2)*P(1005,1) + Metric(2003,1004)*Metric(2004,2005)*P(1003,1)*P(1005,2) + Metric(2003,2004)*Metric(2005,1004)*P(1003,1)*P(1005,2) + Metric(2003,2005)*Metric(2004,1003)*P(1004,1)*P(1005,2) + Metric(2003,2004)*Metric(2005,1003)*P(1004,1)*P(1005,2) - Metric(2004,1005)*Metric(2005,1004)*P(1003,2)*P(2003,1) + Metric(2004,1005)*Metric(2005,1003)*P(1004,2)*P(2003,1) + Metric(1003,1004)*Metric(2004,2005)*P(1005,2)*P(2003,1) + Metric(2004,1003)*Metric(2005,1004)*P(1005,2)*P(2003,1) - Metric(2004,1005)*Metric(2005,1004)*P(1003,1)*P(2003,2) + Metric(2004,1005)*Metric(2005,1003)*P(1004,1)*P(2003,2) + Metric(1003,1004)*Metric(2004,2005)*P(1005,1)*P(2003,2) + Metric(2004,1003)*Metric(2005,1004)*P(1005,1)*P(2003,2) + Metric(2003,1005)*Metric(2005,1004)*P(1003,2)*P(2004,1) - Metric(2003,1005)*Metric(2005,1003)*P(1004,2)*P(2004,1) + Metric(1003,1004)*Metric(2003,2005)*P(1005,2)*P(2004,1) + Metric(2003,1004)*Metric(2005,1003)*P(1005,2)*P(2004,1) + Metric(2003,1005)*Metric(2005,1004)*P(1003,1)*P(2004,2) - Metric(2003,1005)*Metric(2005,1003)*P(1004,1)*P(2004,2) + Metric(1003,1004)*Metric(2003,2005)*P(1005,1)*P(2004,2) + Metric(2003,1004)*Metric(2005,1003)*P(1005,1)*P(2004,2) + Metric(2003,1004)*Metric(2004,1005)*P(1003,2)*P(2005,1) + Metric(2003,1005)*Metric(2004,1003)*P(1004,2)*P(2005,1) - Metric(1003,1004)*Metric(2003,2004)*P(1005,2)*P(2005,1) - Metric(2003,1004)*Metric(2004,1003)*P(1005,2)*P(2005,1) + Metric(1003,1004)*Metric(2004,1005)*P(2003,2)*P(2005,1) + Metric(1003,1004)*Metric(2003,1005)*P(2004,2)*P(2005,1) + Metric(2003,1004)*Metric(2004,1005)*P(1003,1)*P(2005,2) + Metric(2003,1005)*Metric(2004,1003)*P(1004,1)*P(2005,2) - Metric(1003,1004)*Metric(2003,2004)*P(1005,1)*P(2005,2) - Metric(2003,1004)*Metric(2004,1003)*P(1005,1)*P(2005,2) + Metric(1003,1004)*Metric(2004,1005)*P(2003,1)*P(2005,2) + Metric(1003,1004)*Metric(2003,1005)*P(2004,1)*P(2005,2) + Metric(1004,1005)*(-(Metric(2003,1003)*Metric(2004,2005)*P(-1,1)*P(-1,2)) - Metric(2004,2005)*(P(1003,2)*P(2003,1) + P(1003,1)*P(2003,2)) + Metric(2003,2005)*P(1003,2)*P(2004,1) + Metric(2005,1003)*P(2003,2)*P(2004,1) + Metric(2003,2005)*P(1003,1)*P(2004,2) + Metric(2005,1003)*P(2003,1)*P(2004,2) + Metric(2003,2004)*P(1003,2)*P(2005,1) + Metric(2004,1003)*P(2003,2)*P(2005,1) + Metric(2003,2004)*P(1003,1)*P(2005,2) + Metric(2004,1003)*P(2003,1)*P(2005,2)) + Metric(1003,1005)*(Metric(2004,2005)*(P(1004,2)*P(2003,1) + P(1004,1)*P(2003,2)) + Metric(2005,1004)*P(2003,2)*P(2004,1) + Metric(2005,1004)*P(2003,1)*P(2004,2) - Metric(2003,2005)*(Metric(2004,1004)*P(-1,1)*P(-1,2) + P(1004,2)*P(2004,1) + P(1004,1)*P(2004,2)) + Metric(2003,2004)*P(1004,2)*P(2005,1) + Metric(2003,1004)*P(2004,2)*P(2005,1) + Metric(2003,2004)*P(1004,1)*P(2005,2) + Metric(2003,1004)*P(2004,1)*P(2005,2))'
+    ))
+
+TTT = Lorentz(
+    name='TTT',
+    spins=[5, 5, 5],
+    structure=(
+        '-(Metric(2001,1003)*Metric(2002,2003)*P(1001,3)*P(1002,1)) - Metric(2001,1003)*Metric(2002,2003)*P(1001,2)*P(1002,3) - Metric(2001,1002)*Metric(2002,2003)*P(1001,2)*P(1003,1) - Metric(2001,2002)*Metric(2003,1002)*P(1001,2)*P(1003,1) - Metric(2001,2002)*Metric(2003,1001)*P(1002,3)*P(1003,1) - Metric(2001,1002)*Metric(2002,2003)*P(1001,3)*P(1003,2) - Metric(2001,2002)*Metric(2003,1002)*P(1001,3)*P(1003,2) - Metric(2001,2002)*Metric(2003,1001)*P(1002,1)*P(1003,2) + 2*Metric(1002,1003)*Metric(2002,2003)*P(1001,3)*P(2001,2) - Metric(1001,1003)*Metric(2002,2003)*P(1002,3)*P(2001,2) - Metric(1001,1002)*Metric(2002,2003)*P(1003,1)*P(2001,2) + 2*Metric(1002,1003)*Metric(2002,2003)*P(1001,2)*P(2001,3) - Metric(1001,1003)*Metric(2002,2003)*P(1002,1)*P(2001,3) - Metric(1001,1002)*Metric(2002,2003)*P(1003,2)*P(2001,3) - Metric(1002,1003)*Metric(2001,2003)*P(1001,3)*P(2002,1) - Metric(2001,1003)*Metric(2003,1002)*P(1001,3)*P(2002,1) + 2*Metric(1001,1003)*Metric(2001,2003)*P(1002,3)*P(2002,1) + 2*Metric(2001,1003)*Metric(2003,1001)*P(1002,3)*P(2002,1) - Metric(1001,1002)*Metric(2001,2003)*P(1003,2)*P(2002,1) - Metric(2001,1002)*Metric(2003,1001)*P(1003,2)*P(2002,1) - Metric(1002,1003)*Metric(2003,1001)*P(2001,3)*P(2002,1) - Metric(1001,1003)*Metric(2003,1002)*P(2001,3)*P(2002,1) - Metric(1002,1003)*Metric(2001,2003)*P(1001,2)*P(2002,3) - Metric(2001,1003)*Metric(2003,1002)*P(1001,2)*P(2002,3) + 2*Metric(1001,1003)*Metric(2001,2003)*P(1002,1)*P(2002,3) + 2*Metric(2001,1003)*Metric(2003,1001)*P(1002,1)*P(2002,3) - Metric(1001,1002)*Metric(2001,2003)*P(1003,1)*P(2002,3) - Metric(2001,1002)*Metric(2003,1001)*P(1003,1)*P(2002,3) - Metric(1002,1003)*Metric(2003,1001)*P(2001,2)*P(2002,3) - Metric(1001,1003)*Metric(2003,1002)*P(2001,2)*P(2002,3) - Metric(1002,1003)*Metric(2001,2002)*P(1001,2)*P(2003,1) - Metric(1001,1003)*Metric(2001,2002)*P(1002,3)*P(2003,1) + 2*Metric(1001,1002)*Metric(2001,2002)*P(1003,2)*P(2003,1) - Metric(1001,1003)*Metric(2001,1002)*P(2002,3)*P(2003,1) - Metric(1001,1002)*Metric(2001,1003)*P(2002,3)*P(2003,1) - Metric(1002,1003)*Metric(2001,2002)*P(1001,3)*P(2003,2) - Metric(1001,1003)*Metric(2001,2002)*P(1002,1)*P(2003,2) + 2*Metric(1001,1002)*Metric(2001,2002)*P(1003,1)*P(2003,2) - Metric(1001,1003)*Metric(2001,1002)*P(2002,1)*P(2003,2) - Metric(1001,1002)*Metric(2001,1003)*P(2002,1)*P(2003,2) - Metric(2002,1003)*(Metric(2001,2003)*P(1001,3)*P(1002,1) + Metric(2001,2003)*P(1001,2)*P(1002,3) - 2*Metric(2003,1002)*P(1001,3)*P(2001,2) + Metric(2003,1001)*P(1002,3)*P(2001,2) - 2*Metric(2003,1002)*P(1001,2)*P(2001,3) + Metric(2003,1001)*P(1002,1)*P(2001,3) + Metric(2001,1002)*(P(1001,2)*P(2003,1) + P(1001,3)*P(2003,2)) + Metric(1001,1002)*(P(2001,2)*P(2003,1) + P(2001,3)*P(2003,2))) - Metric(2002,1001)*(Metric(2001,2003)*P(1002,3)*P(1003,1) + Metric(2001,2003)*P(1002,1)*P(1003,2) + Metric(2003,1002)*(P(1003,1)*P(2001,2) + P(1003,2)*P(2001,3)) + Metric(2001,1003)*P(1002,3)*P(2003,1) - 2*Metric(2001,1002)*P(1003,2)*P(2003,1) + Metric(2001,1003)*P(1002,1)*P(2003,2) - 2*Metric(2001,1002)*P(1003,1)*P(2003,2) + Metric(1002,1003)*(P(2001,2)*P(2003,1) + P(2001,3)*P(2003,2)))'
+    ))
+
+TTTT = Lorentz(
+    name='TTTT',
+    spins=[5, 5, 5, 5],
+    structure=('-(Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2004)*Metric(2002,2003)*P(-1,1)*P(-1,2)) - Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2003)*Metric(2002,2004)*P(-1,1)*P(-1,2) - Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1001)*P(-1,1)*P(-1,2) - Metric(1003,1004)*Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1002)*P(-1,1)*P(-1,2) - Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1004)*P(-1,1)*P(-1,2) - Metric(1001,1002)*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1004)*P(-1,1)*P(-1,2) - Metric(1001,1003)*Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(-1,1)*P(-1,2) - Metric(1001,1002)*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(-1,1)*P(-1,2) - Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2002)*Metric(2003,2004)*P(-1,1)*P(-1,2) - Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2002)*Metric(2003,2004)*P(-1,1)*P(-1,2) - Metric(1002,1004)*Metric(2001,1003)*Metric(2002,1001)*Metric(2003,2004)*P(-1,1)*P(-1,2) - Metric(1002,1003)*Metric(2001,1004)*Metric(2002,1001)*Metric(2003,2004)*P(-1,1)*P(-1,2) + 6*Metric(1003,1004)*Metric(2001,1001)*Metric(2002,1002)*Metric(2003,2004)*P(-1,1)*P(-1,2) - Metric(1001,1004)*Metric(2001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(-1,1)*P(-1,2) - Metric(1001,1002)*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(-1,1)*P(-1,2) - Metric(1001,1003)*Metric(2001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(-1,1)*P(-1,2) - Metric(1001,1002)*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(-1,1)*P(-1,2) - Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1001)*P(-1,1)*P(-1,2) - Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1001)*P(-1,1)*P(-1,2) - Metric(1002,1003)*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1001)*P(-1,1)*P(-1,2) - Metric(2001,1002)*Metric(2002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(-1,1)*P(-1,2) - Metric(1003,1004)*Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1002)*P(-1,1)*P(-1,2) - Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1002)*P(-1,1)*P(-1,2) - Metric(1001,1003)*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1002)*P(-1,1)*P(-1,2) - Metric(2001,1003)*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1002)*P(-1,1)*P(-1,2) - Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1003)*P(-1,1)*P(-1,2) - Metric(1001,1002)*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1003)*P(-1,1)*P(-1,2) - Metric(1001,1004)*Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(-1,1)*P(-1,2) - Metric(1001,1002)*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(-1,1)*P(-1,2) - Metric(1002,1004)*Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1003)*P(-1,1)*P(-1,2) - Metric(2001,1002)*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(-1,1)*P(-1,2) - Metric(1001,1004)*Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1003)*P(-1,1)*P(-1,2) - Metric(2001,1004)*Metric(2002,1001)*Metric(2003,1002)*Metric(2004,1003)*P(-1,1)*P(-1,2) + 6*Metric(2001,1001)*Metric(2002,1002)*Metric(2003,1004)*Metric(2004,1003)*P(-1,1)*P(-1,2) - Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2004)*Metric(2002,2003)*P(-1,1)*P(-1,3) - Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2003)*Metric(2002,2004)*P(-1,1)*P(-1,3) - Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2003)*Metric(2002,2004)*P(-1,1)*P(-1,3) - Metric(1002,1004)*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1001)*P(-1,1)*P(-1,3) - Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1001)*P(-1,1)*P(-1,3) - Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1001)*P(-1,1)*P(-1,3) - Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1001)*P(-1,1)*P(-1,3) - Metric(1001,1003)*Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1002)*P(-1,1)*P(-1,3) - Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(-1,1)*P(-1,3) - Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(-1,1)*P(-1,3) + 6*Metric(1002,1004)*Metric(2001,1001)*Metric(2002,2004)*Metric(2003,1003)*P(-1,1)*P(-1,3) - Metric(1001,1003)*Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(-1,1)*P(-1,3) - Metric(1001,1002)*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(-1,1)*P(-1,3) - Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2002)*Metric(2003,2004)*P(-1,1)*P(-1,3) - Metric(1002,1004)*Metric(2001,1003)*Metric(2002,1001)*Metric(2003,2004)*P(-1,1)*P(-1,3) - Metric(1001,1003)*Metric(2001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(-1,1)*P(-1,3) - Metric(1001,1002)*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(-1,1)*P(-1,3) - Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1001)*P(-1,1)*P(-1,3) - Metric(1002,1003)*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1001)*P(-1,1)*P(-1,3) - Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1001)*P(-1,1)*P(-1,3) - Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1002)*Metric(2004,1001)*P(-1,1)*P(-1,3) - Metric(1003,1004)*Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1002)*P(-1,1)*P(-1,3) - Metric(1001,1004)*Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1002)*P(-1,1)*P(-1,3) - Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(-1,1)*P(-1,3) - Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(-1,1)*P(-1,3) - Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1002)*P(-1,1)*P(-1,3) - Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1001)*Metric(2004,1002)*P(-1,1)*P(-1,3) + 6*Metric(2001,1001)*Metric(2002,1004)*Metric(2003,1003)*Metric(2004,1002)*P(-1,1)*P(-1,3) - Metric(1001,1003)*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1002)*P(-1,1)*P(-1,3) - Metric(2001,1003)*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1002)*P(-1,1)*P(-1,3) - Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1003)*P(-1,1)*P(-1,3) - Metric(1001,1002)*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1003)*P(-1,1)*P(-1,3) - Metric(1002,1004)*Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1003)*P(-1,1)*P(-1,3) - Metric(2001,1002)*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(-1,1)*P(-1,3) - Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2004)*Metric(2002,2003)*P(-1,2)*P(-1,3) - Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2004)*Metric(2002,2003)*P(-1,2)*P(-1,3) - Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2003)*Metric(2002,2004)*P(-1,2)*P(-1,3) - Metric(1002,1004)*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1001)*P(-1,2)*P(-1,3) - Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1001)*P(-1,2)*P(-1,3) - Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1001)*P(-1,2)*P(-1,3) - Metric(1003,1004)*Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1002)*P(-1,2)*P(-1,3) - Metric(1001,1003)*Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1002)*P(-1,2)*P(-1,3) - Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(-1,2)*P(-1,3) - Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(-1,2)*P(-1,3) + 6*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,1002)*Metric(2003,1003)*P(-1,2)*P(-1,3) - Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1004)*P(-1,2)*P(-1,3) - Metric(1001,1002)*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1004)*P(-1,2)*P(-1,3) - Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2002)*Metric(2003,2004)*P(-1,2)*P(-1,3) - Metric(1002,1003)*Metric(2001,1004)*Metric(2002,1001)*Metric(2003,2004)*P(-1,2)*P(-1,3) - Metric(1001,1004)*Metric(2001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(-1,2)*P(-1,3) - Metric(1001,1002)*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(-1,2)*P(-1,3) - Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1001)*P(-1,2)*P(-1,3) - Metric(1002,1003)*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1001)*P(-1,2)*P(-1,3) - Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1001)*P(-1,2)*P(-1,3) - Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1001)*P(-1,2)*P(-1,3) - Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1001)*P(-1,2)*P(-1,3) - Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1002)*Metric(2004,1001)*P(-1,2)*P(-1,3) + 6*Metric(2001,1004)*Metric(2002,1002)*Metric(2003,1003)*Metric(2004,1001)*P(-1,2)*P(-1,3) - Metric(1002,1003)*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1001)*P(-1,2)*P(-1,3) - Metric(2001,1002)*Metric(2002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(-1,2)*P(-1,3) - Metric(1001,1004)*Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1002)*P(-1,2)*P(-1,3) - Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(-1,2)*P(-1,3) - Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(-1,2)*P(-1,3) - Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1001)*Metric(2004,1002)*P(-1,2)*P(-1,3) - Metric(1001,1004)*Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(-1,2)*P(-1,3) - Metric(1001,1002)*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(-1,2)*P(-1,3) - Metric(1001,1004)*Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1003)*P(-1,2)*P(-1,3) - Metric(2001,1004)*Metric(2002,1001)*Metric(2003,1002)*Metric(2004,1003)*P(-1,2)*P(-1,3) - Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2004)*Metric(2002,2003)*P(-1,1)*P(-1,4) - Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2004)*Metric(2002,2003)*P(-1,1)*P(-1,4) - Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2003)*Metric(2002,2004)*P(-1,1)*P(-1,4) - Metric(1002,1004)*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1001)*P(-1,1)*P(-1,4) - Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1001)*P(-1,1)*P(-1,4) - Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1001)*P(-1,1)*P(-1,4) - Metric(1003,1004)*Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1002)*P(-1,1)*P(-1,4) - Metric(1001,1003)*Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1002)*P(-1,1)*P(-1,4) - Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(-1,1)*P(-1,4) - Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(-1,1)*P(-1,4) - Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1004)*P(-1,1)*P(-1,4) - Metric(1001,1002)*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1004)*P(-1,1)*P(-1,4) - Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2002)*Metric(2003,2004)*P(-1,1)*P(-1,4) - Metric(1002,1003)*Metric(2001,1004)*Metric(2002,1001)*Metric(2003,2004)*P(-1,1)*P(-1,4) - Metric(1001,1004)*Metric(2001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(-1,1)*P(-1,4) - Metric(1001,1002)*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(-1,1)*P(-1,4) - Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1001)*P(-1,1)*P(-1,4) - Metric(1002,1003)*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1001)*P(-1,1)*P(-1,4) - Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1001)*P(-1,1)*P(-1,4) - Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1001)*P(-1,1)*P(-1,4) - Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1001)*P(-1,1)*P(-1,4) - Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1002)*Metric(2004,1001)*P(-1,1)*P(-1,4) - Metric(1002,1003)*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1001)*P(-1,1)*P(-1,4) - Metric(2001,1002)*Metric(2002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(-1,1)*P(-1,4) - Metric(1001,1004)*Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1002)*P(-1,1)*P(-1,4) - Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(-1,1)*P(-1,4) - Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(-1,1)*P(-1,4) - Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1001)*Metric(2004,1002)*P(-1,1)*P(-1,4) - Metric(1001,1004)*Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(-1,1)*P(-1,4) - Metric(1001,1002)*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(-1,1)*P(-1,4) - Metric(1001,1004)*Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1003)*P(-1,1)*P(-1,4) - Metric(2001,1004)*Metric(2002,1001)*Metric(2003,1002)*Metric(2004,1003)*P(-1,1)*P(-1,4) + 6*Metric(1002,1003)*Metric(2001,1001)*Metric(2002,2003)*Metric(2004,1004)*P(-1,1)*P(-1,4) + 6*Metric(2001,1001)*Metric(2002,1003)*Metric(2003,1002)*Metric(2004,1004)*P(-1,1)*P(-1,4) - Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2004)*Metric(2002,2003)*P(-1,2)*P(-1,4) - Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2003)*Metric(2002,2004)*P(-1,2)*P(-1,4) - Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2003)*Metric(2002,2004)*P(-1,2)*P(-1,4) - Metric(1002,1004)*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1001)*P(-1,2)*P(-1,4) - Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1001)*P(-1,2)*P(-1,4) - Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1001)*P(-1,2)*P(-1,4) - Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1001)*P(-1,2)*P(-1,4) - Metric(1001,1003)*Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1002)*P(-1,2)*P(-1,4) - Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(-1,2)*P(-1,4) - Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(-1,2)*P(-1,4) - Metric(1001,1003)*Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(-1,2)*P(-1,4) - Metric(1001,1002)*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(-1,2)*P(-1,4) - Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2002)*Metric(2003,2004)*P(-1,2)*P(-1,4) - Metric(1002,1004)*Metric(2001,1003)*Metric(2002,1001)*Metric(2003,2004)*P(-1,2)*P(-1,4) - Metric(1001,1003)*Metric(2001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(-1,2)*P(-1,4) - Metric(1001,1002)*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(-1,2)*P(-1,4) - Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1001)*P(-1,2)*P(-1,4) - Metric(1002,1003)*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1001)*P(-1,2)*P(-1,4) - Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1001)*P(-1,2)*P(-1,4) - Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1002)*Metric(2004,1001)*P(-1,2)*P(-1,4) - Metric(1003,1004)*Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1002)*P(-1,2)*P(-1,4) - Metric(1001,1004)*Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1002)*P(-1,2)*P(-1,4) - Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(-1,2)*P(-1,4) - Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(-1,2)*P(-1,4) - Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1002)*P(-1,2)*P(-1,4) - Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1001)*Metric(2004,1002)*P(-1,2)*P(-1,4) - Metric(1001,1003)*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1002)*P(-1,2)*P(-1,4) - Metric(2001,1003)*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1002)*P(-1,2)*P(-1,4) - Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1003)*P(-1,2)*P(-1,4) - Metric(1001,1002)*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1003)*P(-1,2)*P(-1,4) - Metric(1002,1004)*Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1003)*P(-1,2)*P(-1,4) - Metric(2001,1002)*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(-1,2)*P(-1,4) + 6*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,1002)*Metric(2004,1004)*P(-1,2)*P(-1,4) + 6*Metric(2001,1003)*Metric(2002,1002)*Metric(2003,1001)*Metric(2004,1004)*P(-1,2)*P(-1,4) - Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2004)*Metric(2002,2003)*P(-1,3)*P(-1,4) - Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2003)*Metric(2002,2004)*P(-1,3)*P(-1,4) - Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1001)*P(-1,3)*P(-1,4) - Metric(1003,1004)*Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1002)*P(-1,3)*P(-1,4) - Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1004)*P(-1,3)*P(-1,4) - Metric(1001,1002)*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1004)*P(-1,3)*P(-1,4) - Metric(1001,1003)*Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(-1,3)*P(-1,4) - Metric(1001,1002)*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(-1,3)*P(-1,4) - Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2002)*Metric(2003,2004)*P(-1,3)*P(-1,4) - Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2002)*Metric(2003,2004)*P(-1,3)*P(-1,4) - Metric(1002,1004)*Metric(2001,1003)*Metric(2002,1001)*Metric(2003,2004)*P(-1,3)*P(-1,4) - Metric(1002,1003)*Metric(2001,1004)*Metric(2002,1001)*Metric(2003,2004)*P(-1,3)*P(-1,4) - Metric(1001,1004)*Metric(2001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(-1,3)*P(-1,4) - Metric(1001,1002)*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(-1,3)*P(-1,4) - Metric(1001,1003)*Metric(2001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(-1,3)*P(-1,4) - Metric(1001,1002)*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(-1,3)*P(-1,4) - Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1001)*P(-1,3)*P(-1,4) - Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1001)*P(-1,3)*P(-1,4) - Metric(1002,1003)*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1001)*P(-1,3)*P(-1,4) - Metric(2001,1002)*Metric(2002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(-1,3)*P(-1,4) - Metric(1003,1004)*Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1002)*P(-1,3)*P(-1,4) - Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1002)*P(-1,3)*P(-1,4) - Metric(1001,1003)*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1002)*P(-1,3)*P(-1,4) - Metric(2001,1003)*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1002)*P(-1,3)*P(-1,4) - Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1003)*P(-1,3)*P(-1,4) - Metric(1001,1002)*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1003)*P(-1,3)*P(-1,4) - Metric(1001,1004)*Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(-1,3)*P(-1,4) - Metric(1001,1002)*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(-1,3)*P(-1,4) - Metric(1002,1004)*Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1003)*P(-1,3)*P(-1,4) - Metric(2001,1002)*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(-1,3)*P(-1,4) - Metric(1001,1004)*Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1003)*P(-1,3)*P(-1,4) - Metric(2001,1004)*Metric(2002,1001)*Metric(2003,1002)*Metric(2004,1003)*P(-1,3)*P(-1,4) + 6*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,1003)*Metric(2004,1004)*P(-1,3)*P(-1,4) + 6*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,1003)*Metric(2004,1004)*P(-1,3)*P(-1,4) + Metric(1003,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1001,2)*P(1002,1) + Metric(1003,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,2)*P(1002,1) + Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1004)*P(1001,2)*P(1002,1) + Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(1001,2)*P(1002,1) - 4*Metric(1003,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,2)*P(1002,1) + Metric(2001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(1001,2)*P(1002,1) + Metric(2001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(1001,2)*P(1002,1) + Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1003)*P(1001,2)*P(1002,1) + Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(1001,2)*P(1002,1) - 4*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,2)*P(1002,1) + Metric(1003,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,3)*P(1002,1) + Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(1001,3)*P(1002,1) - 2*Metric(1003,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,3)*P(1002,1) + Metric(2001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(1001,3)*P(1002,1) + Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1003)*P(1001,3)*P(1002,1) - 2*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,3)*P(1002,1) + Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1004)*P(1001,3)*P(1002,1) + Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1004)*P(1001,3)*P(1002,1) + Metric(1003,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1001,4)*P(1002,1) + Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1003)*P(1001,4)*P(1002,1) + Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1003)*P(1001,4)*P(1002,1) + Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1004)*P(1001,4)*P(1002,1) - 2*Metric(1003,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,4)*P(1002,1) + Metric(2001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(1001,4)*P(1002,1) + Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(1001,4)*P(1002,1) - 2*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,4)*P(1002,1) + Metric(1003,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1001,2)*P(1002,3) + Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1004)*P(1001,2)*P(1002,3) - 2*Metric(1003,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,2)*P(1002,3) + Metric(2001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(1001,2)*P(1002,3) + Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(1001,2)*P(1002,3) - 2*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,2)*P(1002,3) + Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1004)*P(1001,2)*P(1002,3) + Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1004)*P(1001,2)*P(1002,3) + Metric(1003,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,4)*P(1002,3) + Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(1001,4)*P(1002,3) - 2*Metric(1003,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,4)*P(1002,3) + Metric(2001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(1001,4)*P(1002,3) + Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1003)*P(1001,4)*P(1002,3) - 2*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,4)*P(1002,3) - 2*Metric(2001,2002)*Metric(2003,1003)*Metric(2004,1004)*P(1001,4)*P(1002,3) + Metric(1003,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,2)*P(1002,4) + Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1003)*P(1001,2)*P(1002,4) + Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1003)*P(1001,2)*P(1002,4) + Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(1001,2)*P(1002,4) - 2*Metric(1003,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,2)*P(1002,4) + Metric(2001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(1001,2)*P(1002,4) + Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1003)*P(1001,2)*P(1002,4) - 2*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,2)*P(1002,4) + Metric(1003,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1001,3)*P(1002,4) + Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1004)*P(1001,3)*P(1002,4) - 2*Metric(1003,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,3)*P(1002,4) + Metric(2001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(1001,3)*P(1002,4) + Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(1001,3)*P(1002,4) - 2*Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,3)*P(1002,4) - 2*Metric(2001,2002)*Metric(2003,1003)*Metric(2004,1004)*P(1001,3)*P(1002,4) - 2*Metric(1002,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,2)*P(1003,1) + Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(1001,2)*P(1003,1) + Metric(1002,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,2)*P(1003,1) + Metric(2001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(1001,2)*P(1003,1) - 2*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,2)*P(1003,1) + Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1002)*P(1001,2)*P(1003,1) + Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1004)*P(1001,2)*P(1003,1) + Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1004)*P(1001,2)*P(1003,1) + Metric(1002,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1001,3)*P(1003,1) - 4*Metric(1002,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,3)*P(1003,1) + Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1002)*P(1001,3)*P(1003,1) + Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(1001,3)*P(1003,1) + Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(1001,3)*P(1003,1) + Metric(1002,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,3)*P(1003,1) + Metric(2001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(1001,3)*P(1003,1) - 4*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,3)*P(1003,1) + Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(1001,3)*P(1003,1) + Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1002)*P(1001,3)*P(1003,1) + Metric(1002,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1001,4)*P(1003,1) - 2*Metric(1002,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,4)*P(1003,1) + Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1002)*P(1001,4)*P(1003,1) + Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(1001,4)*P(1003,1) + Metric(2001,2004)*Metric(2002,1002)*Metric(2003,1004)*P(1001,4)*P(1003,1) + Metric(2001,1004)*Metric(2002,1002)*Metric(2003,2004)*P(1001,4)*P(1003,1) - 2*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,4)*P(1003,1) + Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(1001,4)*P(1003,1) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1002,3)*P(1003,1) + Metric(1001,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1002,3)*P(1003,1) + Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1001)*P(1002,3)*P(1003,1) + Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1002,3)*P(1003,1) + Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1001)*P(1002,3)*P(1003,1) - 2*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,3)*P(1003,1) + Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1004)*P(1002,3)*P(1003,1) + Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1004)*P(1002,3)*P(1003,1) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1002,4)*P(1003,1) + Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1004)*P(1002,4)*P(1003,1) + Metric(1001,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1002,4)*P(1003,1) + Metric(2001,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,4)*P(1003,1) - 2*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,4)*P(1003,1) + Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1001)*P(1002,4)*P(1003,1) - 2*Metric(2001,1001)*Metric(2002,2003)*Metric(2004,1004)*P(1002,4)*P(1003,1) + Metric(1002,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1001,3)*P(1003,2) - 2*Metric(1002,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,3)*P(1003,2) + Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1002)*P(1001,3)*P(1003,2) + Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(1001,3)*P(1003,2) - 2*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,3)*P(1003,2) + Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(1001,3)*P(1003,2) + Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1004)*P(1001,3)*P(1003,2) + Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1004)*P(1001,3)*P(1003,2) - 2*Metric(1002,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,4)*P(1003,2) + Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(1001,4)*P(1003,2) + Metric(1002,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,4)*P(1003,2) + Metric(2001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(1001,4)*P(1003,2) - 2*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,4)*P(1003,2) + Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1002)*P(1001,4)*P(1003,2) - 2*Metric(2001,2003)*Metric(2002,1002)*Metric(2004,1004)*P(1001,4)*P(1003,2) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1002,1)*P(1003,2) + Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1004)*P(1002,1)*P(1003,2) + Metric(1001,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1002,1)*P(1003,2) + Metric(2001,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,1)*P(1003,2) - 2*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,1)*P(1003,2) + Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1001)*P(1002,1)*P(1003,2) + Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1004)*P(1002,1)*P(1003,2) + Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1004)*P(1002,1)*P(1003,2) - 4*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1002,3)*P(1003,2) + Metric(1001,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1002,3)*P(1003,2) + Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1001)*P(1002,3)*P(1003,2) + Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1002,3)*P(1003,2) + Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1004)*P(1002,3)*P(1003,2) + Metric(1001,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1002,3)*P(1003,2) + Metric(2001,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,3)*P(1003,2) + Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1001)*P(1002,3)*P(1003,2) - 4*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,3)*P(1003,2) + Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1001)*P(1002,3)*P(1003,2) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1002,4)*P(1003,2) + Metric(1001,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1002,4)*P(1003,2) + Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1001)*P(1002,4)*P(1003,2) + Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1002,4)*P(1003,2) + Metric(2001,1001)*Metric(2002,2004)*Metric(2003,1004)*P(1002,4)*P(1003,2) + Metric(2001,1001)*Metric(2002,1004)*Metric(2003,2004)*P(1002,4)*P(1003,2) + Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1001)*P(1002,4)*P(1003,2) - 2*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,4)*P(1003,2) + Metric(1002,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1001,2)*P(1003,4) - 2*Metric(1002,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,2)*P(1003,4) + Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1002)*P(1001,2)*P(1003,4) + Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(1001,2)*P(1003,4) - 2*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,2)*P(1003,4) + Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(1001,2)*P(1003,4) - 2*Metric(2001,2003)*Metric(2002,1002)*Metric(2004,1004)*P(1001,2)*P(1003,4) - 2*Metric(1002,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1001,3)*P(1003,4) + Metric(2001,2004)*Metric(2002,1002)*Metric(2003,1004)*P(1001,3)*P(1003,4) + Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(1001,3)*P(1003,4) + Metric(1002,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1001,3)*P(1003,4) + Metric(2001,1004)*Metric(2002,1002)*Metric(2003,2004)*P(1001,3)*P(1003,4) + Metric(2001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(1001,3)*P(1003,4) - 2*Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,3)*P(1003,4) + Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1002)*P(1001,3)*P(1003,4) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1002,1)*P(1003,4) + Metric(1001,1004)*Metric(2001,2003)*Metric(2002,2004)*P(1002,1)*P(1003,4) + Metric(2001,2004)*Metric(2002,1004)*Metric(2003,1001)*P(1002,1)*P(1003,4) + Metric(2001,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1002,1)*P(1003,4) + Metric(2001,2003)*Metric(2002,1004)*Metric(2004,1001)*P(1002,1)*P(1003,4) - 2*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,1)*P(1003,4) - 2*Metric(2001,1001)*Metric(2002,2003)*Metric(2004,1004)*P(1002,1)*P(1003,4) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,2003)*P(1002,3)*P(1003,4) + Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1004)*P(1002,3)*P(1003,4) + Metric(2001,1001)*Metric(2002,2004)*Metric(2003,1004)*P(1002,3)*P(1003,4) + Metric(1001,1004)*Metric(2001,2002)*Metric(2003,2004)*P(1002,3)*P(1003,4) + Metric(2001,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,3)*P(1003,4) + Metric(2001,1001)*Metric(2002,1004)*Metric(2003,2004)*P(1002,3)*P(1003,4) - 2*Metric(2001,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,3)*P(1003,4) + Metric(2001,2002)*Metric(2003,1004)*Metric(2004,1001)*P(1002,3)*P(1003,4) - 2*Metric(1002,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1001,2)*P(1004,1) - 2*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,2)*P(1004,1) + Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1003)*P(1001,2)*P(1004,1) + Metric(1002,1003)*Metric(2001,2002)*Metric(2003,2004)*P(1001,2)*P(1004,1) + Metric(2001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(1001,2)*P(1004,1) + Metric(2001,2002)*Metric(2003,1003)*Metric(2004,1002)*P(1001,2)*P(1004,1) + Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(1001,2)*P(1004,1) + Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1003)*P(1001,2)*P(1004,1) - 2*Metric(1002,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1001,3)*P(1004,1) + Metric(1002,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1001,3)*P(1004,1) - 2*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,3)*P(1004,1) + Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(1001,3)*P(1004,1) + Metric(2001,1003)*Metric(2002,1002)*Metric(2003,2004)*P(1001,3)*P(1004,1) + Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1002)*P(1001,3)*P(1004,1) + Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(1001,3)*P(1004,1) + Metric(2001,2003)*Metric(2002,1002)*Metric(2004,1003)*P(1001,3)*P(1004,1) - 4*Metric(1002,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1001,4)*P(1004,1) + Metric(1002,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1001,4)*P(1004,1) - 4*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,4)*P(1004,1) + Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(1001,4)*P(1004,1) + Metric(1002,1003)*Metric(2001,2002)*Metric(2003,2004)*P(1001,4)*P(1004,1) + Metric(2001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(1001,4)*P(1004,1) + Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1002)*P(1001,4)*P(1004,1) + Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(1001,4)*P(1004,1) + Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(1001,4)*P(1004,1) + Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1003)*P(1001,4)*P(1004,1) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1002,3)*P(1004,1) - 2*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1002,3)*P(1004,1) - 2*Metric(2001,1001)*Metric(2002,2004)*Metric(2003,1003)*P(1002,3)*P(1004,1) + Metric(1001,1003)*Metric(2001,2002)*Metric(2003,2004)*P(1002,3)*P(1004,1) + Metric(2001,1003)*Metric(2002,1001)*Metric(2003,2004)*P(1002,3)*P(1004,1) + Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1003)*P(1002,3)*P(1004,1) + Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1003)*P(1002,3)*P(1004,1) + Metric(1001,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1002,4)*P(1004,1) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1002,4)*P(1004,1) + Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1001)*P(1002,4)*P(1004,1) - 2*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1002,4)*P(1004,1) + Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1003)*P(1002,4)*P(1004,1) + Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1001)*P(1002,4)*P(1004,1) + Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1002,4)*P(1004,1) + Metric(2001,2002)*Metric(2003,1003)*Metric(2004,1001)*P(1002,4)*P(1004,1) + Metric(1001,1002)*Metric(2001,2003)*Metric(2002,2004)*P(1003,2)*P(1004,1) + Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1001)*P(1003,2)*P(1004,1) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,2004)*P(1003,2)*P(1004,1) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,2004)*P(1003,2)*P(1004,1) - 2*Metric(2001,1001)*Metric(2002,1002)*Metric(2003,2004)*P(1003,2)*P(1004,1) + Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1002)*P(1003,2)*P(1004,1) + Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1002)*P(1003,2)*P(1004,1) + Metric(1001,1002)*Metric(2001,2004)*Metric(2002,2003)*P(1003,4)*P(1004,1) + Metric(2001,2004)*Metric(2002,1002)*Metric(2003,1001)*P(1003,4)*P(1004,1) + Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1002)*P(1003,4)*P(1004,1) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,2004)*P(1003,4)*P(1004,1) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,2004)*P(1003,4)*P(1004,1) + Metric(2001,2003)*Metric(2002,1002)*Metric(2004,1001)*P(1003,4)*P(1004,1) + Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1001)*P(1003,4)*P(1004,1) + Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1001)*P(1003,4)*P(1004,1) - 2*Metric(1002,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1001,3)*P(1004,2) - 2*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,3)*P(1004,2) - 2*Metric(2001,2004)*Metric(2002,1002)*Metric(2003,1003)*P(1001,3)*P(1004,2) + Metric(1002,1003)*Metric(2001,2002)*Metric(2003,2004)*P(1001,3)*P(1004,2) + Metric(2001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(1001,3)*P(1004,2) + Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(1001,3)*P(1004,2) + Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1003)*P(1001,3)*P(1004,2) - 2*Metric(1002,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1001,4)*P(1004,2) + Metric(1002,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1001,4)*P(1004,2) - 2*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,4)*P(1004,2) + Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(1001,4)*P(1004,2) + Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1003)*P(1001,4)*P(1004,2) + Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1002)*P(1001,4)*P(1004,2) + Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(1001,4)*P(1004,2) + Metric(2001,2002)*Metric(2003,1003)*Metric(2004,1002)*P(1001,4)*P(1004,2) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1002,1)*P(1004,2) - 2*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1002,1)*P(1004,2) + Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1003)*P(1002,1)*P(1004,2) + Metric(1001,1003)*Metric(2001,2002)*Metric(2003,2004)*P(1002,1)*P(1004,2) + Metric(2001,1003)*Metric(2002,1001)*Metric(2003,2004)*P(1002,1)*P(1004,2) + Metric(2001,2002)*Metric(2003,1003)*Metric(2004,1001)*P(1002,1)*P(1004,2) + Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1003)*P(1002,1)*P(1004,2) + Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1003)*P(1002,1)*P(1004,2) + Metric(1001,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1002,3)*P(1004,2) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1002,3)*P(1004,2) + Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1001)*P(1002,3)*P(1004,2) - 2*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1002,3)*P(1004,2) + Metric(2001,1001)*Metric(2002,1003)*Metric(2003,2004)*P(1002,3)*P(1004,2) + Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1001)*P(1002,3)*P(1004,2) + Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1002,3)*P(1004,2) + Metric(2001,1001)*Metric(2002,2003)*Metric(2004,1003)*P(1002,3)*P(1004,2) + Metric(1001,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1002,4)*P(1004,2) - 4*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1002,4)*P(1004,2) + Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1001)*P(1002,4)*P(1004,2) - 4*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1002,4)*P(1004,2) + Metric(1001,1003)*Metric(2001,2002)*Metric(2003,2004)*P(1002,4)*P(1004,2) + Metric(2001,1003)*Metric(2002,1001)*Metric(2003,2004)*P(1002,4)*P(1004,2) + Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1001)*P(1002,4)*P(1004,2) + Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1002,4)*P(1004,2) + Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1003)*P(1002,4)*P(1004,2) + Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1003)*P(1002,4)*P(1004,2) + Metric(1001,1002)*Metric(2001,2004)*Metric(2002,2003)*P(1003,1)*P(1004,2) + Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1002)*P(1003,1)*P(1004,2) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,2004)*P(1003,1)*P(1004,2) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,2004)*P(1003,1)*P(1004,2) - 2*Metric(2001,1001)*Metric(2002,1002)*Metric(2003,2004)*P(1003,1)*P(1004,2) + Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1001)*P(1003,1)*P(1004,2) + Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1001)*P(1003,1)*P(1004,2) + Metric(1001,1002)*Metric(2001,2003)*Metric(2002,2004)*P(1003,4)*P(1004,2) + Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1001)*P(1003,4)*P(1004,2) + Metric(2001,1001)*Metric(2002,2004)*Metric(2003,1002)*P(1003,4)*P(1004,2) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,2004)*P(1003,4)*P(1004,2) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,2004)*P(1003,4)*P(1004,2) + Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1002)*P(1003,4)*P(1004,2) + Metric(2001,1001)*Metric(2002,2003)*Metric(2004,1002)*P(1003,4)*P(1004,2) + Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1002)*P(1003,4)*P(1004,2) - 2*Metric(1002,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1001,2)*P(1004,3) + Metric(1002,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1001,2)*P(1004,3) - 2*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,2)*P(1004,3) + Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(1001,2)*P(1004,3) - 2*Metric(2001,2004)*Metric(2002,1002)*Metric(2003,1003)*P(1001,2)*P(1004,3) + Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1002)*P(1001,2)*P(1004,3) + Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(1001,2)*P(1004,3) - 2*Metric(1002,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1001,4)*P(1004,3) - 2*Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,4)*P(1004,3) + Metric(1002,1003)*Metric(2001,2002)*Metric(2003,2004)*P(1001,4)*P(1004,3) + Metric(2001,1003)*Metric(2002,1002)*Metric(2003,2004)*P(1001,4)*P(1004,3) + Metric(2001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(1001,4)*P(1004,3) + Metric(2001,2003)*Metric(2002,1002)*Metric(2004,1003)*P(1001,4)*P(1004,3) + Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(1001,4)*P(1004,3) + Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1003)*P(1001,4)*P(1004,3) + Metric(1001,1003)*Metric(2001,2004)*Metric(2002,2003)*P(1002,1)*P(1004,3) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1002,1)*P(1004,3) + Metric(2001,2004)*Metric(2002,1003)*Metric(2003,1001)*P(1002,1)*P(1004,3) - 2*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1002,1)*P(1004,3) - 2*Metric(2001,1001)*Metric(2002,2004)*Metric(2003,1003)*P(1002,1)*P(1004,3) + Metric(2001,2003)*Metric(2002,1003)*Metric(2004,1001)*P(1002,1)*P(1004,3) + Metric(2001,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1002,1)*P(1004,3) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,2004)*P(1002,4)*P(1004,3) - 2*Metric(2001,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1002,4)*P(1004,3) + Metric(1001,1003)*Metric(2001,2002)*Metric(2003,2004)*P(1002,4)*P(1004,3) + Metric(2001,1003)*Metric(2002,1001)*Metric(2003,2004)*P(1002,4)*P(1004,3) + Metric(2001,1001)*Metric(2002,1003)*Metric(2003,2004)*P(1002,4)*P(1004,3) + Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1003)*P(1002,4)*P(1004,3) + Metric(2001,1001)*Metric(2002,2003)*Metric(2004,1003)*P(1002,4)*P(1004,3) + Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1003)*P(1002,4)*P(1004,3) + Metric(1001,1002)*Metric(2001,2003)*Metric(2002,2004)*P(1003,1)*P(1004,3) + Metric(2001,2004)*Metric(2002,1002)*Metric(2003,1001)*P(1003,1)*P(1004,3) + Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1001)*P(1003,1)*P(1004,3) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,2004)*P(1003,1)*P(1004,3) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,2004)*P(1003,1)*P(1004,3) + Metric(2001,2003)*Metric(2002,1002)*Metric(2004,1001)*P(1003,1)*P(1004,3) + Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1002)*P(1003,1)*P(1004,3) + Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1002)*P(1003,1)*P(1004,3) + Metric(1001,1002)*Metric(2001,2004)*Metric(2002,2003)*P(1003,2)*P(1004,3) + Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1002)*P(1003,2)*P(1004,3) + Metric(2001,1001)*Metric(2002,2004)*Metric(2003,1002)*P(1003,2)*P(1004,3) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,2004)*P(1003,2)*P(1004,3) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,2004)*P(1003,2)*P(1004,3) + Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1001)*P(1003,2)*P(1004,3) + Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1001)*P(1003,2)*P(1004,3) + Metric(2001,1001)*Metric(2002,2003)*Metric(2004,1002)*P(1003,2)*P(1004,3) + Metric(1001,1002)*Metric(2001,2004)*Metric(2002,2003)*P(1003,4)*P(1004,3) + Metric(1001,1002)*Metric(2001,2003)*Metric(2002,2004)*P(1003,4)*P(1004,3) + Metric(2001,1002)*Metric(2002,2004)*Metric(2003,1001)*P(1003,4)*P(1004,3) + Metric(2001,2004)*Metric(2002,1001)*Metric(2003,1002)*P(1003,4)*P(1004,3) - 4*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,2004)*P(1003,4)*P(1004,3) - 4*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,2004)*P(1003,4)*P(1004,3) + Metric(2001,1002)*Metric(2002,2003)*Metric(2004,1001)*P(1003,4)*P(1004,3) + Metric(2001,2002)*Metric(2003,1002)*Metric(2004,1001)*P(1003,4)*P(1004,3) + Metric(2001,2003)*Metric(2002,1001)*Metric(2004,1002)*P(1003,4)*P(1004,3) + Metric(2001,2002)*Metric(2003,1001)*Metric(2004,1002)*P(1003,4)*P(1004,3) - 2*Metric(1002,1003)*Metric(2002,2003)*Metric(2004,1004)*P(1001,3)*P(2001,2) - 2*Metric(2002,1003)*Metric(2003,1002)*Metric(2004,1004)*P(1001,3)*P(2001,2) - 2*Metric(1002,1004)*Metric(2002,2004)*Metric(2003,1003)*P(1001,4)*P(2001,2) - 2*Metric(2002,1004)*Metric(2003,1003)*Metric(2004,1002)*P(1001,4)*P(2001,2) + Metric(1003,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1002,1)*P(2001,2) + Metric(1001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(1002,1)*P(2001,2) - 4*Metric(1003,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,1)*P(2001,2) + Metric(1001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(1002,1)*P(2001,2) + Metric(1001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(1002,1)*P(2001,2) + Metric(1003,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,1)*P(2001,2) + Metric(2002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(1002,1)*P(2001,2) + Metric(1001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(1002,1)*P(2001,2) + Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(1002,1)*P(2001,2) - 4*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1003)*P(1002,1)*P(2001,2) - 2*Metric(1003,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,3)*P(2001,2) + Metric(1001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(1002,3)*P(2001,2) + Metric(1003,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,3)*P(2001,2) + Metric(2002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(1002,3)*P(2001,2) + Metric(1001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(1002,3)*P(2001,2) - 2*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1003)*P(1002,3)*P(2001,2) + Metric(1001,1003)*Metric(2002,2003)*Metric(2004,1004)*P(1002,3)*P(2001,2) + Metric(2002,1003)*Metric(2003,1001)*Metric(2004,1004)*P(1002,3)*P(2001,2) + Metric(1003,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1002,4)*P(2001,2) + Metric(1001,1004)*Metric(2002,2004)*Metric(2003,1003)*P(1002,4)*P(2001,2) + Metric(1001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(1002,4)*P(2001,2) - 2*Metric(1003,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,4)*P(2001,2) + Metric(1001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(1002,4)*P(2001,2) + Metric(2002,1004)*Metric(2003,1003)*Metric(2004,1001)*P(1002,4)*P(2001,2) + Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(1002,4)*P(2001,2) - 2*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1003)*P(1002,4)*P(2001,2) - 2*Metric(1002,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1003,1)*P(2001,2) + Metric(1001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(1003,1)*P(2001,2) + Metric(1002,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1003,1)*P(2001,2) + Metric(1001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(1003,1)*P(2001,2) - 2*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,1)*P(2001,2) + Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1002)*P(1003,1)*P(2001,2) + Metric(1001,1002)*Metric(2002,2003)*Metric(2004,1004)*P(1003,1)*P(2001,2) + Metric(2002,1001)*Metric(2003,1002)*Metric(2004,1004)*P(1003,1)*P(2001,2) - 2*Metric(1002,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1003,4)*P(2001,2) + Metric(1001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(1003,4)*P(2001,2) + Metric(1002,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1003,4)*P(2001,2) + Metric(2002,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,4)*P(2001,2) + Metric(1001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(1003,4)*P(2001,2) - 2*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,4)*P(2001,2) - 2*Metric(2002,1002)*Metric(2003,1001)*Metric(2004,1004)*P(1003,4)*P(2001,2) + Metric(1001,1002)*Metric(2002,2004)*Metric(2003,1003)*P(1004,1)*P(2001,2) + Metric(1002,1003)*Metric(2002,1001)*Metric(2003,2004)*P(1004,1)*P(2001,2) + Metric(1001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(1004,1)*P(2001,2) - 2*Metric(1002,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1004,1)*P(2001,2) - 2*Metric(2002,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,1)*P(2001,2) + Metric(2002,1001)*Metric(2003,1003)*Metric(2004,1002)*P(1004,1)*P(2001,2) + Metric(1001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(1004,1)*P(2001,2) + Metric(2002,1001)*Metric(2003,1002)*Metric(2004,1003)*P(1004,1)*P(2001,2) + Metric(1002,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1004,3)*P(2001,2) + Metric(1001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(1004,3)*P(2001,2) - 2*Metric(1002,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1004,3)*P(2001,2) - 2*Metric(2002,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,3)*P(2001,2) - 2*Metric(2002,1002)*Metric(2003,1003)*Metric(2004,1001)*P(1004,3)*P(2001,2) + Metric(1001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(1004,3)*P(2001,2) + Metric(2002,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,3)*P(2001,2) - 2*Metric(1002,1003)*Metric(2002,2003)*Metric(2004,1004)*P(1001,2)*P(2001,3) - 2*Metric(2002,1003)*Metric(2003,1002)*Metric(2004,1004)*P(1001,2)*P(2001,3) - 2*Metric(1003,1004)*Metric(2002,1002)*Metric(2003,2004)*P(1001,4)*P(2001,3) - 2*Metric(2002,1002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,4)*P(2001,3) + Metric(1003,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1002,1)*P(2001,3) + Metric(1001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(1002,1)*P(2001,3) - 2*Metric(1003,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,1)*P(2001,3) + Metric(1001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(1002,1)*P(2001,3) + Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(1002,1)*P(2001,3) - 2*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1003)*P(1002,1)*P(2001,3) + Metric(1001,1003)*Metric(2002,2003)*Metric(2004,1004)*P(1002,1)*P(2001,3) + Metric(2002,1003)*Metric(2003,1001)*Metric(2004,1004)*P(1002,1)*P(2001,3) - 2*Metric(1003,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,4)*P(2001,3) + Metric(1001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(1002,4)*P(2001,3) + Metric(1003,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,4)*P(2001,3) + Metric(2002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(1002,4)*P(2001,3) + Metric(1001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(1002,4)*P(2001,3) - 2*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1003)*P(1002,4)*P(2001,3) - 2*Metric(2002,1001)*Metric(2003,1003)*Metric(2004,1004)*P(1002,4)*P(2001,3) - 4*Metric(1002,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1003,1)*P(2001,3) + Metric(1001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(1003,1)*P(2001,3) + Metric(1001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(1003,1)*P(2001,3) + Metric(1002,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1003,1)*P(2001,3) + Metric(1001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(1003,1)*P(2001,3) + Metric(1002,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1003,1)*P(2001,3) + Metric(2002,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,1)*P(2001,3) + Metric(1001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(1003,1)*P(2001,3) - 4*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,1)*P(2001,3) + Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1002)*P(1003,1)*P(2001,3) - 2*Metric(1002,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1003,2)*P(2001,3) + Metric(1001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(1003,2)*P(2001,3) + Metric(1002,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1003,2)*P(2001,3) + Metric(2002,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,2)*P(2001,3) + Metric(1001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(1003,2)*P(2001,3) - 2*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,2)*P(2001,3) + Metric(1001,1002)*Metric(2002,2003)*Metric(2004,1004)*P(1003,2)*P(2001,3) + Metric(2002,1001)*Metric(2003,1002)*Metric(2004,1004)*P(1003,2)*P(2001,3) - 2*Metric(1002,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1003,4)*P(2001,3) + Metric(1001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(1003,4)*P(2001,3) + Metric(1002,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1003,4)*P(2001,3) + Metric(1001,1004)*Metric(2002,1002)*Metric(2003,2004)*P(1003,4)*P(2001,3) + Metric(1001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(1003,4)*P(2001,3) + Metric(2002,1002)*Metric(2003,1004)*Metric(2004,1001)*P(1003,4)*P(2001,3) - 2*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,4)*P(2001,3) + Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1002)*P(1003,4)*P(2001,3) + Metric(1002,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1004,1)*P(2001,3) + Metric(1001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(1004,1)*P(2001,3) + Metric(1001,1003)*Metric(2002,1002)*Metric(2003,2004)*P(1004,1)*P(2001,3) - 2*Metric(1002,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1004,1)*P(2001,3) - 2*Metric(2002,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,1)*P(2001,3) + Metric(1001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(1004,1)*P(2001,3) + Metric(2002,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,1)*P(2001,3) + Metric(2002,1002)*Metric(2003,1001)*Metric(2004,1003)*P(1004,1)*P(2001,3) + Metric(1002,1003)*Metric(2002,1001)*Metric(2003,2004)*P(1004,2)*P(2001,3) + Metric(1001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(1004,2)*P(2001,3) - 2*Metric(1002,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1004,2)*P(2001,3) - 2*Metric(2002,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,2)*P(2001,3) - 2*Metric(2002,1002)*Metric(2003,1003)*Metric(2004,1001)*P(1004,2)*P(2001,3) + Metric(1001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(1004,2)*P(2001,3) + Metric(2002,1001)*Metric(2003,1002)*Metric(2004,1003)*P(1004,2)*P(2001,3) - 2*Metric(1002,1004)*Metric(2002,2004)*Metric(2003,1003)*P(1001,2)*P(2001,4) - 2*Metric(2002,1004)*Metric(2003,1003)*Metric(2004,1002)*P(1001,2)*P(2001,4) - 2*Metric(1003,1004)*Metric(2002,1002)*Metric(2003,2004)*P(1001,3)*P(2001,4) - 2*Metric(2002,1002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,3)*P(2001,4) + Metric(1001,1004)*Metric(2002,2004)*Metric(2003,1003)*P(1002,1)*P(2001,4) - 2*Metric(1003,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,1)*P(2001,4) + Metric(1001,1004)*Metric(2002,1003)*Metric(2003,2004)*P(1002,1)*P(2001,4) + Metric(1003,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1002,1)*P(2001,4) + Metric(2002,1004)*Metric(2003,1003)*Metric(2004,1001)*P(1002,1)*P(2001,4) + Metric(2002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(1002,1)*P(2001,4) + Metric(1001,1004)*Metric(2002,2003)*Metric(2004,1003)*P(1002,1)*P(2001,4) - 2*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1003)*P(1002,1)*P(2001,4) + Metric(1003,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1002,3)*P(2001,4) + Metric(1001,1003)*Metric(2002,2004)*Metric(2003,1004)*P(1002,3)*P(2001,4) - 2*Metric(1003,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1002,3)*P(2001,4) + Metric(1001,1003)*Metric(2002,1004)*Metric(2003,2004)*P(1002,3)*P(2001,4) + Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(1002,3)*P(2001,4) - 2*Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1003)*P(1002,3)*P(2001,4) - 2*Metric(2002,1001)*Metric(2003,1003)*Metric(2004,1004)*P(1002,3)*P(2001,4) - 2*Metric(1002,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1003,1)*P(2001,4) + Metric(1001,1004)*Metric(2002,2004)*Metric(2003,1002)*P(1003,1)*P(2001,4) + Metric(1001,1004)*Metric(2002,1002)*Metric(2003,2004)*P(1003,1)*P(2001,4) + Metric(1002,1004)*Metric(2002,2003)*Metric(2004,1001)*P(1003,1)*P(2001,4) + Metric(2002,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,1)*P(2001,4) + Metric(2002,1002)*Metric(2003,1004)*Metric(2004,1001)*P(1003,1)*P(2001,4) + Metric(1001,1004)*Metric(2002,2003)*Metric(2004,1002)*P(1003,1)*P(2001,4) - 2*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,1)*P(2001,4) - 2*Metric(1002,1004)*Metric(2002,2004)*Metric(2003,1001)*P(1003,2)*P(2001,4) + Metric(1001,1002)*Metric(2002,2004)*Metric(2003,1004)*P(1003,2)*P(2001,4) + Metric(1002,1004)*Metric(2002,1001)*Metric(2003,2004)*P(1003,2)*P(2001,4) + Metric(1001,1002)*Metric(2002,1004)*Metric(2003,2004)*P(1003,2)*P(2001,4) - 2*Metric(2002,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,2)*P(2001,4) + Metric(2002,1001)*Metric(2003,1004)*Metric(2004,1002)*P(1003,2)*P(2001,4) - 2*Metric(2002,1002)*Metric(2003,1001)*Metric(2004,1004)*P(1003,2)*P(2001,4) + Metric(1002,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1004,1)*P(2001,4) + Metric(1001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(1004,1)*P(2001,4) + Metric(1002,1003)*Metric(2002,1001)*Metric(2003,2004)*P(1004,1)*P(2001,4) + Metric(1001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(1004,1)*P(2001,4) - 4*Metric(1002,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1004,1)*P(2001,4) - 4*Metric(2002,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,1)*P(2001,4) + Metric(1001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(1004,1)*P(2001,4) + Metric(2002,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,1)*P(2001,4) + Metric(1001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(1004,1)*P(2001,4) + Metric(2002,1001)*Metric(2003,1002)*Metric(2004,1003)*P(1004,1)*P(2001,4) + Metric(1002,1003)*Metric(2002,2004)*Metric(2003,1001)*P(1004,2)*P(2001,4) + Metric(1001,1003)*Metric(2002,2004)*Metric(2003,1002)*P(1004,2)*P(2001,4) + Metric(1001,1002)*Metric(2002,2004)*Metric(2003,1003)*P(1004,2)*P(2001,4) - 2*Metric(1002,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1004,2)*P(2001,4) - 2*Metric(2002,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,2)*P(2001,4) + Metric(1001,1003)*Metric(2002,2003)*Metric(2004,1002)*P(1004,2)*P(2001,4) + Metric(2002,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,2)*P(2001,4) + Metric(2002,1001)*Metric(2003,1003)*Metric(2004,1002)*P(1004,2)*P(2001,4) + Metric(1002,1003)*Metric(2002,1001)*Metric(2003,2004)*P(1004,3)*P(2001,4) + Metric(1001,1003)*Metric(2002,1002)*Metric(2003,2004)*P(1004,3)*P(2001,4) + Metric(1001,1002)*Metric(2002,1003)*Metric(2003,2004)*P(1004,3)*P(2001,4) - 2*Metric(1002,1003)*Metric(2002,2003)*Metric(2004,1001)*P(1004,3)*P(2001,4) - 2*Metric(2002,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,3)*P(2001,4) + Metric(1001,1002)*Metric(2002,2003)*Metric(2004,1003)*P(1004,3)*P(2001,4) + Metric(2002,1002)*Metric(2003,1001)*Metric(2004,1003)*P(1004,3)*P(2001,4) + Metric(2002,1001)*Metric(2003,1002)*Metric(2004,1003)*P(1004,3)*P(2001,4) + Metric(1003,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1001,2)*P(2002,1) + Metric(1002,1003)*Metric(2001,2004)*Metric(2003,1004)*P(1001,2)*P(2002,1) - 4*Metric(1003,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1001,2)*P(2002,1) + Metric(1002,1004)*Metric(2001,1003)*Metric(2003,2004)*P(1001,2)*P(2002,1) + Metric(1002,1003)*Metric(2001,1004)*Metric(2003,2004)*P(1001,2)*P(2002,1) + Metric(1003,1004)*Metric(2001,2003)*Metric(2004,1002)*P(1001,2)*P(2002,1) + Metric(2001,1003)*Metric(2003,1004)*Metric(2004,1002)*P(1001,2)*P(2002,1) + Metric(1002,1004)*Metric(2001,2003)*Metric(2004,1003)*P(1001,2)*P(2002,1) + Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1003)*P(1001,2)*P(2002,1) - 4*Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,2)*P(2002,1) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1001,3)*P(2002,1) + Metric(1002,1004)*Metric(2001,1003)*Metric(2003,2004)*P(1001,3)*P(2002,1) + Metric(1003,1004)*Metric(2001,2003)*Metric(2004,1002)*P(1001,3)*P(2002,1) + Metric(2001,1003)*Metric(2003,1004)*Metric(2004,1002)*P(1001,3)*P(2002,1) + Metric(1002,1004)*Metric(2001,2003)*Metric(2004,1003)*P(1001,3)*P(2002,1) - 2*Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,3)*P(2002,1) + Metric(1002,1003)*Metric(2001,2003)*Metric(2004,1004)*P(1001,3)*P(2002,1) + Metric(2001,1003)*Metric(2003,1002)*Metric(2004,1004)*P(1001,3)*P(2002,1) + Metric(1003,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1001,4)*P(2002,1) + Metric(1002,1004)*Metric(2001,2004)*Metric(2003,1003)*P(1001,4)*P(2002,1) + Metric(1002,1003)*Metric(2001,2004)*Metric(2003,1004)*P(1001,4)*P(2002,1) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1001,4)*P(2002,1) + Metric(1002,1003)*Metric(2001,1004)*Metric(2003,2004)*P(1001,4)*P(2002,1) + Metric(2001,1004)*Metric(2003,1003)*Metric(2004,1002)*P(1001,4)*P(2002,1) + Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1003)*P(1001,4)*P(2002,1) - 2*Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,4)*P(2002,1) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2004,1004)*P(1002,3)*P(2002,1) - 2*Metric(2001,1003)*Metric(2003,1001)*Metric(2004,1004)*P(1002,3)*P(2002,1) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2003,1003)*P(1002,4)*P(2002,1) - 2*Metric(2001,1004)*Metric(2003,1003)*Metric(2004,1001)*P(1002,4)*P(2002,1) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1003,2)*P(2002,1) + Metric(1001,1002)*Metric(2001,2004)*Metric(2003,1004)*P(1003,2)*P(2002,1) + Metric(1001,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1003,2)*P(2002,1) + Metric(1001,1002)*Metric(2001,1004)*Metric(2003,2004)*P(1003,2)*P(2002,1) - 2*Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,2)*P(2002,1) + Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1001)*P(1003,2)*P(2002,1) + Metric(1001,1002)*Metric(2001,2003)*Metric(2004,1004)*P(1003,2)*P(2002,1) + Metric(2001,1002)*Metric(2003,1001)*Metric(2004,1004)*P(1003,2)*P(2002,1) + Metric(1002,1004)*Metric(2001,2004)*Metric(2003,1001)*P(1003,4)*P(2002,1) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1003,4)*P(2002,1) + Metric(1002,1004)*Metric(2001,2003)*Metric(2004,1001)*P(1003,4)*P(2002,1) - 2*Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,4)*P(2002,1) + Metric(1001,1004)*Metric(2001,2003)*Metric(2004,1002)*P(1003,4)*P(2002,1) + Metric(2001,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,4)*P(2002,1) - 2*Metric(2001,1001)*Metric(2003,1002)*Metric(2004,1004)*P(1003,4)*P(2002,1) + Metric(1001,1002)*Metric(2001,2004)*Metric(2003,1003)*P(1004,2)*P(2002,1) + Metric(1001,1003)*Metric(2001,1002)*Metric(2003,2004)*P(1004,2)*P(2002,1) + Metric(1001,1002)*Metric(2001,1003)*Metric(2003,2004)*P(1004,2)*P(2002,1) + Metric(2001,1002)*Metric(2003,1003)*Metric(2004,1001)*P(1004,2)*P(2002,1) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2004,1002)*P(1004,2)*P(2002,1) - 2*Metric(2001,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,2)*P(2002,1) + Metric(1001,1002)*Metric(2001,2003)*Metric(2004,1003)*P(1004,2)*P(2002,1) + Metric(2001,1002)*Metric(2003,1001)*Metric(2004,1003)*P(1004,2)*P(2002,1) + Metric(1002,1003)*Metric(2001,2004)*Metric(2003,1001)*P(1004,3)*P(2002,1) + Metric(1001,1003)*Metric(2001,2004)*Metric(2003,1002)*P(1004,3)*P(2002,1) + Metric(1002,1003)*Metric(2001,2003)*Metric(2004,1001)*P(1004,3)*P(2002,1) + Metric(2001,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,3)*P(2002,1) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2004,1002)*P(1004,3)*P(2002,1) - 2*Metric(2001,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,3)*P(2002,1) - 2*Metric(2001,1001)*Metric(2003,1003)*Metric(2004,1002)*P(1004,3)*P(2002,1) + Metric(1001,1004)*Metric(1002,1003)*Metric(2003,2004)*P(2001,2)*P(2002,1) + Metric(1001,1003)*Metric(1002,1004)*Metric(2003,2004)*P(2001,2)*P(2002,1) - 4*Metric(1001,1002)*Metric(1003,1004)*Metric(2003,2004)*P(2001,2)*P(2002,1) + Metric(1003,1004)*Metric(2003,1002)*Metric(2004,1001)*P(2001,2)*P(2002,1) + Metric(1002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(2001,2)*P(2002,1) + Metric(1003,1004)*Metric(2003,1001)*Metric(2004,1002)*P(2001,2)*P(2002,1) + Metric(1001,1003)*Metric(2003,1004)*Metric(2004,1002)*P(2001,2)*P(2002,1) + Metric(1002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(2001,2)*P(2002,1) + Metric(1001,1004)*Metric(2003,1002)*Metric(2004,1003)*P(2001,2)*P(2002,1) - 4*Metric(1001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(2001,2)*P(2002,1) + Metric(1001,1003)*Metric(1002,1004)*Metric(2003,2004)*P(2001,3)*P(2002,1) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2003,2004)*P(2001,3)*P(2002,1) + Metric(1003,1004)*Metric(2003,1001)*Metric(2004,1002)*P(2001,3)*P(2002,1) + Metric(1001,1003)*Metric(2003,1004)*Metric(2004,1002)*P(2001,3)*P(2002,1) + Metric(1002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(2001,3)*P(2002,1) - 2*Metric(1001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(2001,3)*P(2002,1) + Metric(1002,1003)*Metric(2003,1001)*Metric(2004,1004)*P(2001,3)*P(2002,1) + Metric(1001,1003)*Metric(2003,1002)*Metric(2004,1004)*P(2001,3)*P(2002,1) + Metric(1001,1004)*Metric(1002,1003)*Metric(2003,2004)*P(2001,4)*P(2002,1) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2003,2004)*P(2001,4)*P(2002,1) + Metric(1003,1004)*Metric(2003,1002)*Metric(2004,1001)*P(2001,4)*P(2002,1) + Metric(1002,1004)*Metric(2003,1003)*Metric(2004,1001)*P(2001,4)*P(2002,1) + Metric(1002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(2001,4)*P(2002,1) + Metric(1001,1004)*Metric(2003,1003)*Metric(2004,1002)*P(2001,4)*P(2002,1) + Metric(1001,1004)*Metric(2003,1002)*Metric(2004,1003)*P(2001,4)*P(2002,1) - 2*Metric(1001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(2001,4)*P(2002,1) + Metric(1003,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1001,2)*P(2002,3) + Metric(1002,1003)*Metric(2001,2004)*Metric(2003,1004)*P(1001,2)*P(2002,3) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1001,2)*P(2002,3) + Metric(1002,1003)*Metric(2001,1004)*Metric(2003,2004)*P(1001,2)*P(2002,3) + Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1003)*P(1001,2)*P(2002,3) - 2*Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,2)*P(2002,3) + Metric(1002,1003)*Metric(2001,2003)*Metric(2004,1004)*P(1001,2)*P(2002,3) + Metric(2001,1003)*Metric(2003,1002)*Metric(2004,1004)*P(1001,2)*P(2002,3) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1001,4)*P(2002,3) + Metric(1002,1004)*Metric(2001,1003)*Metric(2003,2004)*P(1001,4)*P(2002,3) + Metric(1003,1004)*Metric(2001,2003)*Metric(2004,1002)*P(1001,4)*P(2002,3) + Metric(2001,1003)*Metric(2003,1004)*Metric(2004,1002)*P(1001,4)*P(2002,3) + Metric(1002,1004)*Metric(2001,2003)*Metric(2004,1003)*P(1001,4)*P(2002,3) - 2*Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,4)*P(2002,3) - 2*Metric(2001,1002)*Metric(2003,1003)*Metric(2004,1004)*P(1001,4)*P(2002,3) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2004,1004)*P(1002,1)*P(2002,3) - 2*Metric(2001,1003)*Metric(2003,1001)*Metric(2004,1004)*P(1002,1)*P(2002,3) - 2*Metric(1003,1004)*Metric(2001,1001)*Metric(2003,2004)*P(1002,4)*P(2002,3) - 2*Metric(2001,1001)*Metric(2003,1004)*Metric(2004,1003)*P(1002,4)*P(2002,3) + Metric(1002,1004)*Metric(2001,2004)*Metric(2003,1001)*P(1003,1)*P(2002,3) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1003,1)*P(2002,3) + Metric(1002,1004)*Metric(2001,2003)*Metric(2004,1001)*P(1003,1)*P(2002,3) - 2*Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,1)*P(2002,3) + Metric(1001,1004)*Metric(2001,2003)*Metric(2004,1002)*P(1003,1)*P(2002,3) + Metric(2001,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,1)*P(2002,3) + Metric(1001,1002)*Metric(2001,2003)*Metric(2004,1004)*P(1003,1)*P(2002,3) + Metric(2001,1002)*Metric(2003,1001)*Metric(2004,1004)*P(1003,1)*P(2002,3) + Metric(1002,1004)*Metric(2001,2004)*Metric(2003,1001)*P(1003,2)*P(2002,3) - 4*Metric(1001,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1003,2)*P(2002,3) + Metric(1001,1002)*Metric(2001,2004)*Metric(2003,1004)*P(1003,2)*P(2002,3) + Metric(1001,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1003,2)*P(2002,3) + Metric(1001,1002)*Metric(2001,1004)*Metric(2003,2004)*P(1003,2)*P(2002,3) + Metric(1002,1004)*Metric(2001,2003)*Metric(2004,1001)*P(1003,2)*P(2002,3) - 4*Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,2)*P(2002,3) + Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1001)*P(1003,2)*P(2002,3) + Metric(1001,1004)*Metric(2001,2003)*Metric(2004,1002)*P(1003,2)*P(2002,3) + Metric(2001,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,2)*P(2002,3) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1003,4)*P(2002,3) + Metric(1001,1002)*Metric(2001,2004)*Metric(2003,1004)*P(1003,4)*P(2002,3) + Metric(1002,1004)*Metric(2001,1001)*Metric(2003,2004)*P(1003,4)*P(2002,3) + Metric(1001,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1003,4)*P(2002,3) + Metric(1001,1002)*Metric(2001,1004)*Metric(2003,2004)*P(1003,4)*P(2002,3) - 2*Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,4)*P(2002,3) + Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1001)*P(1003,4)*P(2002,3) + Metric(2001,1001)*Metric(2003,1004)*Metric(2004,1002)*P(1003,4)*P(2002,3) + Metric(1001,1003)*Metric(2001,1002)*Metric(2003,2004)*P(1004,1)*P(2002,3) + Metric(1001,1002)*Metric(2001,1003)*Metric(2003,2004)*P(1004,1)*P(2002,3) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2004,1002)*P(1004,1)*P(2002,3) - 2*Metric(2001,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,1)*P(2002,3) - 2*Metric(2001,1001)*Metric(2003,1003)*Metric(2004,1002)*P(1004,1)*P(2002,3) + Metric(1001,1002)*Metric(2001,2003)*Metric(2004,1003)*P(1004,1)*P(2002,3) + Metric(2001,1002)*Metric(2003,1001)*Metric(2004,1003)*P(1004,1)*P(2002,3) + Metric(1002,1003)*Metric(2001,2004)*Metric(2003,1001)*P(1004,2)*P(2002,3) + Metric(1001,1003)*Metric(2001,2004)*Metric(2003,1002)*P(1004,2)*P(2002,3) + Metric(1002,1003)*Metric(2001,1001)*Metric(2003,2004)*P(1004,2)*P(2002,3) + Metric(1002,1003)*Metric(2001,2003)*Metric(2004,1001)*P(1004,2)*P(2002,3) + Metric(2001,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,2)*P(2002,3) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2004,1002)*P(1004,2)*P(2002,3) - 2*Metric(2001,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,2)*P(2002,3) + Metric(2001,1001)*Metric(2003,1002)*Metric(2004,1003)*P(1004,2)*P(2002,3) + Metric(1001,1004)*Metric(1002,1003)*Metric(2003,2004)*P(2001,2)*P(2002,3) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2003,2004)*P(2001,2)*P(2002,3) + Metric(1003,1004)*Metric(2003,1002)*Metric(2004,1001)*P(2001,2)*P(2002,3) + Metric(1002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(2001,2)*P(2002,3) + Metric(1001,1004)*Metric(2003,1002)*Metric(2004,1003)*P(2001,2)*P(2002,3) - 2*Metric(1001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(2001,2)*P(2002,3) + Metric(1002,1003)*Metric(2003,1001)*Metric(2004,1004)*P(2001,2)*P(2002,3) + Metric(1001,1003)*Metric(2003,1002)*Metric(2004,1004)*P(2001,2)*P(2002,3) + Metric(1001,1003)*Metric(1002,1004)*Metric(2003,2004)*P(2001,4)*P(2002,3) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2003,2004)*P(2001,4)*P(2002,3) + Metric(1003,1004)*Metric(2003,1001)*Metric(2004,1002)*P(2001,4)*P(2002,3) + Metric(1001,1003)*Metric(2003,1004)*Metric(2004,1002)*P(2001,4)*P(2002,3) + Metric(1002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(2001,4)*P(2002,3) - 2*Metric(1001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(2001,4)*P(2002,3) - 2*Metric(1001,1002)*Metric(2003,1003)*Metric(2004,1004)*P(2001,4)*P(2002,3) + Metric(1002,1004)*Metric(2001,2004)*Metric(2003,1003)*P(1001,2)*P(2002,4) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1001,2)*P(2002,4) + Metric(1002,1004)*Metric(2001,1003)*Metric(2003,2004)*P(1001,2)*P(2002,4) + Metric(1003,1004)*Metric(2001,2003)*Metric(2004,1002)*P(1001,2)*P(2002,4) + Metric(2001,1004)*Metric(2003,1003)*Metric(2004,1002)*P(1001,2)*P(2002,4) + Metric(2001,1003)*Metric(2003,1004)*Metric(2004,1002)*P(1001,2)*P(2002,4) + Metric(1002,1004)*Metric(2001,2003)*Metric(2004,1003)*P(1001,2)*P(2002,4) - 2*Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,2)*P(2002,4) + Metric(1003,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1001,3)*P(2002,4) + Metric(1002,1003)*Metric(2001,2004)*Metric(2003,1004)*P(1001,3)*P(2002,4) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1001,3)*P(2002,4) + Metric(1002,1003)*Metric(2001,1004)*Metric(2003,2004)*P(1001,3)*P(2002,4) + Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1003)*P(1001,3)*P(2002,4) - 2*Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(1001,3)*P(2002,4) - 2*Metric(2001,1002)*Metric(2003,1003)*Metric(2004,1004)*P(1001,3)*P(2002,4) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2003,1003)*P(1002,1)*P(2002,4) - 2*Metric(2001,1004)*Metric(2003,1003)*Metric(2004,1001)*P(1002,1)*P(2002,4) - 2*Metric(1003,1004)*Metric(2001,1001)*Metric(2003,2004)*P(1002,3)*P(2002,4) - 2*Metric(2001,1001)*Metric(2003,1004)*Metric(2004,1003)*P(1002,3)*P(2002,4) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1003,1)*P(2002,4) + Metric(1001,1002)*Metric(2001,2004)*Metric(2003,1004)*P(1003,1)*P(2002,4) + Metric(1001,1004)*Metric(2001,1002)*Metric(2003,2004)*P(1003,1)*P(2002,4) + Metric(1001,1002)*Metric(2001,1004)*Metric(2003,2004)*P(1003,1)*P(2002,4) - 2*Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,1)*P(2002,4) + Metric(2001,1002)*Metric(2003,1004)*Metric(2004,1001)*P(1003,1)*P(2002,4) - 2*Metric(2001,1001)*Metric(2003,1002)*Metric(2004,1004)*P(1003,1)*P(2002,4) + Metric(1002,1004)*Metric(2001,2004)*Metric(2003,1001)*P(1003,2)*P(2002,4) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2003,1002)*P(1003,2)*P(2002,4) + Metric(1002,1004)*Metric(2001,1001)*Metric(2003,2004)*P(1003,2)*P(2002,4) + Metric(1002,1004)*Metric(2001,2003)*Metric(2004,1001)*P(1003,2)*P(2002,4) - 2*Metric(2001,1004)*Metric(2003,1002)*Metric(2004,1001)*P(1003,2)*P(2002,4) + Metric(1001,1004)*Metric(2001,2003)*Metric(2004,1002)*P(1003,2)*P(2002,4) + Metric(2001,1004)*Metric(2003,1001)*Metric(2004,1002)*P(1003,2)*P(2002,4) + Metric(2001,1001)*Metric(2003,1004)*Metric(2004,1002)*P(1003,2)*P(2002,4) + Metric(1002,1003)*Metric(2001,2004)*Metric(2003,1001)*P(1004,1)*P(2002,4) + Metric(1001,1003)*Metric(2001,2004)*Metric(2003,1002)*P(1004,1)*P(2002,4) + Metric(1001,1002)*Metric(2001,2004)*Metric(2003,1003)*P(1004,1)*P(2002,4) + Metric(1002,1003)*Metric(2001,2003)*Metric(2004,1001)*P(1004,1)*P(2002,4) + Metric(2001,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,1)*P(2002,4) + Metric(2001,1002)*Metric(2003,1003)*Metric(2004,1001)*P(1004,1)*P(2002,4) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2004,1002)*P(1004,1)*P(2002,4) - 2*Metric(2001,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,1)*P(2002,4) + Metric(1002,1003)*Metric(2001,2004)*Metric(2003,1001)*P(1004,2)*P(2002,4) + Metric(1001,1003)*Metric(2001,2004)*Metric(2003,1002)*P(1004,2)*P(2002,4) + Metric(1001,1003)*Metric(2001,1002)*Metric(2003,2004)*P(1004,2)*P(2002,4) + Metric(1001,1002)*Metric(2001,1003)*Metric(2003,2004)*P(1004,2)*P(2002,4) + Metric(1002,1003)*Metric(2001,2003)*Metric(2004,1001)*P(1004,2)*P(2002,4) + Metric(2001,1003)*Metric(2003,1002)*Metric(2004,1001)*P(1004,2)*P(2002,4) - 4*Metric(1001,1003)*Metric(2001,2003)*Metric(2004,1002)*P(1004,2)*P(2002,4) - 4*Metric(2001,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,2)*P(2002,4) + Metric(1001,1002)*Metric(2001,2003)*Metric(2004,1003)*P(1004,2)*P(2002,4) + Metric(2001,1002)*Metric(2003,1001)*Metric(2004,1003)*P(1004,2)*P(2002,4) + Metric(1002,1003)*Metric(2001,1001)*Metric(2003,2004)*P(1004,3)*P(2002,4) + Metric(1001,1003)*Metric(2001,1002)*Metric(2003,2004)*P(1004,3)*P(2002,4) + Metric(1001,1002)*Metric(2001,1003)*Metric(2003,2004)*P(1004,3)*P(2002,4) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2004,1002)*P(1004,3)*P(2002,4) - 2*Metric(2001,1003)*Metric(2003,1001)*Metric(2004,1002)*P(1004,3)*P(2002,4) + Metric(1001,1002)*Metric(2001,2003)*Metric(2004,1003)*P(1004,3)*P(2002,4) + Metric(2001,1002)*Metric(2003,1001)*Metric(2004,1003)*P(1004,3)*P(2002,4) + Metric(2001,1001)*Metric(2003,1002)*Metric(2004,1003)*P(1004,3)*P(2002,4) + Metric(1001,1003)*Metric(1002,1004)*Metric(2003,2004)*P(2001,2)*P(2002,4) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2003,2004)*P(2001,2)*P(2002,4) + Metric(1002,1004)*Metric(2003,1003)*Metric(2004,1001)*P(2001,2)*P(2002,4) + Metric(1003,1004)*Metric(2003,1001)*Metric(2004,1002)*P(2001,2)*P(2002,4) + Metric(1001,1004)*Metric(2003,1003)*Metric(2004,1002)*P(2001,2)*P(2002,4) + Metric(1001,1003)*Metric(2003,1004)*Metric(2004,1002)*P(2001,2)*P(2002,4) + Metric(1002,1004)*Metric(2003,1001)*Metric(2004,1003)*P(2001,2)*P(2002,4) - 2*Metric(1001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(2001,2)*P(2002,4) + Metric(1001,1004)*Metric(1002,1003)*Metric(2003,2004)*P(2001,3)*P(2002,4) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2003,2004)*P(2001,3)*P(2002,4) + Metric(1003,1004)*Metric(2003,1002)*Metric(2004,1001)*P(2001,3)*P(2002,4) + Metric(1002,1003)*Metric(2003,1004)*Metric(2004,1001)*P(2001,3)*P(2002,4) + Metric(1001,1004)*Metric(2003,1002)*Metric(2004,1003)*P(2001,3)*P(2002,4) - 2*Metric(1001,1002)*Metric(2003,1004)*Metric(2004,1003)*P(2001,3)*P(2002,4) - 2*Metric(1001,1002)*Metric(2003,1003)*Metric(2004,1004)*P(2001,3)*P(2002,4) + Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2004)*P(1001,2)*P(2003,1) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1001,2)*P(2003,1) + Metric(1003,1004)*Metric(2001,2002)*Metric(2004,1002)*P(1001,2)*P(2003,1) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,2)*P(2003,1) + Metric(1002,1004)*Metric(2001,2002)*Metric(2004,1003)*P(1001,2)*P(2003,1) + Metric(2001,1002)*Metric(2002,1004)*Metric(2004,1003)*P(1001,2)*P(2003,1) + Metric(1002,1003)*Metric(2001,2002)*Metric(2004,1004)*P(1001,2)*P(2003,1) + Metric(2001,1002)*Metric(2002,1003)*Metric(2004,1004)*P(1001,2)*P(2003,1) + Metric(1002,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1001,3)*P(2003,1) + Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1004)*P(1001,3)*P(2003,1) + Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2004)*P(1001,3)*P(2003,1) - 4*Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1001,3)*P(2003,1) + Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2004)*P(1001,3)*P(2003,1) + Metric(1003,1004)*Metric(2001,2002)*Metric(2004,1002)*P(1001,3)*P(2003,1) + Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1002)*P(1001,3)*P(2003,1) - 4*Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,3)*P(2003,1) + Metric(1002,1004)*Metric(2001,2002)*Metric(2004,1003)*P(1001,3)*P(2003,1) + Metric(2001,1002)*Metric(2002,1004)*Metric(2004,1003)*P(1001,3)*P(2003,1) + Metric(1003,1004)*Metric(2001,2004)*Metric(2002,1002)*P(1001,4)*P(2003,1) + Metric(1002,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1001,4)*P(2003,1) + Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1004)*P(1001,4)*P(2003,1) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1001,4)*P(2003,1) + Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2004)*P(1001,4)*P(2003,1) + Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1002)*P(1001,4)*P(2003,1) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,4)*P(2003,1) + Metric(2001,1004)*Metric(2002,1002)*Metric(2004,1003)*P(1001,4)*P(2003,1) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1002,3)*P(2003,1) + Metric(1001,1003)*Metric(2001,2004)*Metric(2002,1004)*P(1002,3)*P(2003,1) + Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1002,3)*P(2003,1) + Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2004)*P(1002,3)*P(2003,1) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1001)*P(1002,3)*P(2003,1) + Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1001)*P(1002,3)*P(2003,1) + Metric(1001,1003)*Metric(2001,2002)*Metric(2004,1004)*P(1002,3)*P(2003,1) + Metric(2001,1003)*Metric(2002,1001)*Metric(2004,1004)*P(1002,3)*P(2003,1) + Metric(1003,1004)*Metric(2001,2004)*Metric(2002,1001)*P(1002,4)*P(2003,1) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1002,4)*P(2003,1) + Metric(1003,1004)*Metric(2001,2002)*Metric(2004,1001)*P(1002,4)*P(2003,1) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1001)*P(1002,4)*P(2003,1) + Metric(1001,1004)*Metric(2001,2002)*Metric(2004,1003)*P(1002,4)*P(2003,1) + Metric(2001,1004)*Metric(2002,1001)*Metric(2004,1003)*P(1002,4)*P(2003,1) - 2*Metric(2001,1001)*Metric(2002,1003)*Metric(2004,1004)*P(1002,4)*P(2003,1) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2004,1004)*P(1003,2)*P(2003,1) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2004,1004)*P(1003,2)*P(2003,1) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,1002)*P(1003,4)*P(2003,1) - 2*Metric(2001,1004)*Metric(2002,1002)*Metric(2004,1001)*P(1003,4)*P(2003,1) + Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1001)*P(1004,2)*P(2003,1) + Metric(1001,1002)*Metric(2001,2004)*Metric(2002,1003)*P(1004,2)*P(2003,1) + Metric(1002,1003)*Metric(2001,2002)*Metric(2004,1001)*P(1004,2)*P(2003,1) + Metric(2001,1002)*Metric(2002,1003)*Metric(2004,1001)*P(1004,2)*P(2003,1) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2004,1003)*P(1004,2)*P(2003,1) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2004,1003)*P(1004,2)*P(2003,1) - 2*Metric(2001,1001)*Metric(2002,1002)*Metric(2004,1003)*P(1004,2)*P(2003,1) + Metric(1001,1003)*Metric(2001,2004)*Metric(2002,1002)*P(1004,3)*P(2003,1) + Metric(1001,1003)*Metric(2001,1002)*Metric(2002,2004)*P(1004,3)*P(2003,1) + Metric(1001,1002)*Metric(2001,1003)*Metric(2002,2004)*P(1004,3)*P(2003,1) + Metric(2001,1003)*Metric(2002,1002)*Metric(2004,1001)*P(1004,3)*P(2003,1) + Metric(1001,1003)*Metric(2001,2002)*Metric(2004,1002)*P(1004,3)*P(2003,1) + Metric(2001,1003)*Metric(2002,1001)*Metric(2004,1002)*P(1004,3)*P(2003,1) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2004,1003)*P(1004,3)*P(2003,1) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2004,1003)*P(1004,3)*P(2003,1) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2004)*P(2001,2)*P(2003,1) + Metric(1001,1002)*Metric(1003,1004)*Metric(2002,2004)*P(2001,2)*P(2003,1) + Metric(1003,1004)*Metric(2002,1001)*Metric(2004,1002)*P(2001,2)*P(2003,1) - 2*Metric(1001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(2001,2)*P(2003,1) + Metric(1002,1004)*Metric(2002,1001)*Metric(2004,1003)*P(2001,2)*P(2003,1) + Metric(1001,1002)*Metric(2002,1004)*Metric(2004,1003)*P(2001,2)*P(2003,1) + Metric(1002,1003)*Metric(2002,1001)*Metric(2004,1004)*P(2001,2)*P(2003,1) + Metric(1001,1002)*Metric(2002,1003)*Metric(2004,1004)*P(2001,2)*P(2003,1) + Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2004)*P(2001,3)*P(2003,1) - 4*Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2004)*P(2001,3)*P(2003,1) + Metric(1001,1002)*Metric(1003,1004)*Metric(2002,2004)*P(2001,3)*P(2003,1) + Metric(1002,1004)*Metric(2002,1003)*Metric(2004,1001)*P(2001,3)*P(2003,1) + Metric(1002,1003)*Metric(2002,1004)*Metric(2004,1001)*P(2001,3)*P(2003,1) + Metric(1003,1004)*Metric(2002,1001)*Metric(2004,1002)*P(2001,3)*P(2003,1) + Metric(1001,1004)*Metric(2002,1003)*Metric(2004,1002)*P(2001,3)*P(2003,1) - 4*Metric(1001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(2001,3)*P(2003,1) + Metric(1002,1004)*Metric(2002,1001)*Metric(2004,1003)*P(2001,3)*P(2003,1) + Metric(1001,1002)*Metric(2002,1004)*Metric(2004,1003)*P(2001,3)*P(2003,1) + Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2004)*P(2001,4)*P(2003,1) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2004)*P(2001,4)*P(2003,1) + Metric(1003,1004)*Metric(2002,1002)*Metric(2004,1001)*P(2001,4)*P(2003,1) + Metric(1002,1004)*Metric(2002,1003)*Metric(2004,1001)*P(2001,4)*P(2003,1) + Metric(1002,1003)*Metric(2002,1004)*Metric(2004,1001)*P(2001,4)*P(2003,1) + Metric(1001,1004)*Metric(2002,1003)*Metric(2004,1002)*P(2001,4)*P(2003,1) - 2*Metric(1001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(2001,4)*P(2003,1) + Metric(1001,1004)*Metric(2002,1002)*Metric(2004,1003)*P(2001,4)*P(2003,1) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2004)*P(2002,3)*P(2003,1) + Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2004)*P(2002,3)*P(2003,1) + Metric(1002,1004)*Metric(2001,1003)*Metric(2004,1001)*P(2002,3)*P(2003,1) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2004,1001)*P(2002,3)*P(2003,1) + Metric(1001,1004)*Metric(2001,1003)*Metric(2004,1002)*P(2002,3)*P(2003,1) + Metric(1001,1003)*Metric(2001,1004)*Metric(2004,1002)*P(2002,3)*P(2003,1) + Metric(1001,1003)*Metric(2001,1002)*Metric(2004,1004)*P(2002,3)*P(2003,1) + Metric(1001,1002)*Metric(2001,1003)*Metric(2004,1004)*P(2002,3)*P(2003,1) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2004)*P(2002,4)*P(2003,1) + Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2004)*P(2002,4)*P(2003,1) + Metric(1003,1004)*Metric(2001,1002)*Metric(2004,1001)*P(2002,4)*P(2003,1) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2004,1001)*P(2002,4)*P(2003,1) + Metric(1001,1004)*Metric(2001,1002)*Metric(2004,1003)*P(2002,4)*P(2003,1) + Metric(1001,1002)*Metric(2001,1004)*Metric(2004,1003)*P(2002,4)*P(2003,1) - 2*Metric(1002,1003)*Metric(2001,1001)*Metric(2004,1004)*P(2002,4)*P(2003,1) + Metric(1002,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1001,3)*P(2003,2) + Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1004)*P(1001,3)*P(2003,2) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1001,3)*P(2003,2) + Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2004)*P(1001,3)*P(2003,2) + Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1002)*P(1001,3)*P(2003,2) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,3)*P(2003,2) + Metric(1002,1003)*Metric(2001,2002)*Metric(2004,1004)*P(1001,3)*P(2003,2) + Metric(2001,1002)*Metric(2002,1003)*Metric(2004,1004)*P(1001,3)*P(2003,2) + Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2004)*P(1001,4)*P(2003,2) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1001,4)*P(2003,2) + Metric(1003,1004)*Metric(2001,2002)*Metric(2004,1002)*P(1001,4)*P(2003,2) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,4)*P(2003,2) + Metric(1002,1004)*Metric(2001,2002)*Metric(2004,1003)*P(1001,4)*P(2003,2) + Metric(2001,1002)*Metric(2002,1004)*Metric(2004,1003)*P(1001,4)*P(2003,2) - 2*Metric(2001,1003)*Metric(2002,1002)*Metric(2004,1004)*P(1001,4)*P(2003,2) + Metric(1003,1004)*Metric(2001,2004)*Metric(2002,1001)*P(1002,1)*P(2003,2) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1002,1)*P(2003,2) + Metric(1003,1004)*Metric(2001,2002)*Metric(2004,1001)*P(1002,1)*P(2003,2) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1001)*P(1002,1)*P(2003,2) + Metric(1001,1004)*Metric(2001,2002)*Metric(2004,1003)*P(1002,1)*P(2003,2) + Metric(2001,1004)*Metric(2002,1001)*Metric(2004,1003)*P(1002,1)*P(2003,2) + Metric(1001,1003)*Metric(2001,2002)*Metric(2004,1004)*P(1002,1)*P(2003,2) + Metric(2001,1003)*Metric(2002,1001)*Metric(2004,1004)*P(1002,1)*P(2003,2) + Metric(1003,1004)*Metric(2001,2004)*Metric(2002,1001)*P(1002,3)*P(2003,2) - 4*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1002,3)*P(2003,2) + Metric(1001,1003)*Metric(2001,2004)*Metric(2002,1004)*P(1002,3)*P(2003,2) + Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1002,3)*P(2003,2) + Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2004)*P(1002,3)*P(2003,2) + Metric(1003,1004)*Metric(2001,2002)*Metric(2004,1001)*P(1002,3)*P(2003,2) - 4*Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1001)*P(1002,3)*P(2003,2) + Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1001)*P(1002,3)*P(2003,2) + Metric(1001,1004)*Metric(2001,2002)*Metric(2004,1003)*P(1002,3)*P(2003,2) + Metric(2001,1004)*Metric(2002,1001)*Metric(2004,1003)*P(1002,3)*P(2003,2) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1002,4)*P(2003,2) + Metric(1001,1003)*Metric(2001,2004)*Metric(2002,1004)*P(1002,4)*P(2003,2) + Metric(1003,1004)*Metric(2001,1001)*Metric(2002,2004)*P(1002,4)*P(2003,2) + Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1002,4)*P(2003,2) + Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2004)*P(1002,4)*P(2003,2) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1001)*P(1002,4)*P(2003,2) + Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1001)*P(1002,4)*P(2003,2) + Metric(2001,1001)*Metric(2002,1004)*Metric(2004,1003)*P(1002,4)*P(2003,2) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2004,1004)*P(1003,1)*P(2003,2) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2004,1004)*P(1003,1)*P(2003,2) - 2*Metric(1002,1004)*Metric(2001,1001)*Metric(2002,2004)*P(1003,4)*P(2003,2) - 2*Metric(2001,1001)*Metric(2002,1004)*Metric(2004,1002)*P(1003,4)*P(2003,2) + Metric(1001,1003)*Metric(2001,1002)*Metric(2002,2004)*P(1004,1)*P(2003,2) + Metric(1001,1002)*Metric(2001,1003)*Metric(2002,2004)*P(1004,1)*P(2003,2) + Metric(1001,1003)*Metric(2001,2002)*Metric(2004,1002)*P(1004,1)*P(2003,2) + Metric(2001,1003)*Metric(2002,1001)*Metric(2004,1002)*P(1004,1)*P(2003,2) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2004,1003)*P(1004,1)*P(2003,2) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2004,1003)*P(1004,1)*P(2003,2) - 2*Metric(2001,1001)*Metric(2002,1002)*Metric(2004,1003)*P(1004,1)*P(2003,2) + Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1001)*P(1004,3)*P(2003,2) + Metric(1001,1002)*Metric(2001,2004)*Metric(2002,1003)*P(1004,3)*P(2003,2) + Metric(1002,1003)*Metric(2001,1001)*Metric(2002,2004)*P(1004,3)*P(2003,2) + Metric(1002,1003)*Metric(2001,2002)*Metric(2004,1001)*P(1004,3)*P(2003,2) + Metric(2001,1002)*Metric(2002,1003)*Metric(2004,1001)*P(1004,3)*P(2003,2) + Metric(2001,1001)*Metric(2002,1003)*Metric(2004,1002)*P(1004,3)*P(2003,2) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2004,1003)*P(1004,3)*P(2003,2) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2004,1003)*P(1004,3)*P(2003,2) + Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2004)*P(2001,3)*P(2003,2) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2004)*P(2001,3)*P(2003,2) + Metric(1002,1004)*Metric(2002,1003)*Metric(2004,1001)*P(2001,3)*P(2003,2) + Metric(1002,1003)*Metric(2002,1004)*Metric(2004,1001)*P(2001,3)*P(2003,2) + Metric(1001,1004)*Metric(2002,1003)*Metric(2004,1002)*P(2001,3)*P(2003,2) - 2*Metric(1001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(2001,3)*P(2003,2) + Metric(1002,1003)*Metric(2002,1001)*Metric(2004,1004)*P(2001,3)*P(2003,2) + Metric(1001,1002)*Metric(2002,1003)*Metric(2004,1004)*P(2001,3)*P(2003,2) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2004)*P(2001,4)*P(2003,2) + Metric(1001,1002)*Metric(1003,1004)*Metric(2002,2004)*P(2001,4)*P(2003,2) + Metric(1003,1004)*Metric(2002,1001)*Metric(2004,1002)*P(2001,4)*P(2003,2) - 2*Metric(1001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(2001,4)*P(2003,2) + Metric(1002,1004)*Metric(2002,1001)*Metric(2004,1003)*P(2001,4)*P(2003,2) + Metric(1001,1002)*Metric(2002,1004)*Metric(2004,1003)*P(2001,4)*P(2003,2) - 2*Metric(1001,1003)*Metric(2002,1002)*Metric(2004,1004)*P(2001,4)*P(2003,2) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2004)*P(2002,1)*P(2003,2) + Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2004)*P(2002,1)*P(2003,2) + Metric(1003,1004)*Metric(2001,1002)*Metric(2004,1001)*P(2002,1)*P(2003,2) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2004,1001)*P(2002,1)*P(2003,2) + Metric(1001,1004)*Metric(2001,1002)*Metric(2004,1003)*P(2002,1)*P(2003,2) + Metric(1001,1002)*Metric(2001,1004)*Metric(2004,1003)*P(2002,1)*P(2003,2) + Metric(1001,1003)*Metric(2001,1002)*Metric(2004,1004)*P(2002,1)*P(2003,2) + Metric(1001,1002)*Metric(2001,1003)*Metric(2004,1004)*P(2002,1)*P(2003,2) - 4*Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2004)*P(2002,3)*P(2003,2) + Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2004)*P(2002,3)*P(2003,2) + Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2004)*P(2002,3)*P(2003,2) + Metric(1003,1004)*Metric(2001,1002)*Metric(2004,1001)*P(2002,3)*P(2003,2) + Metric(1002,1004)*Metric(2001,1003)*Metric(2004,1001)*P(2002,3)*P(2003,2) - 4*Metric(1002,1003)*Metric(2001,1004)*Metric(2004,1001)*P(2002,3)*P(2003,2) + Metric(1001,1004)*Metric(2001,1003)*Metric(2004,1002)*P(2002,3)*P(2003,2) + Metric(1001,1003)*Metric(2001,1004)*Metric(2004,1002)*P(2002,3)*P(2003,2) + Metric(1001,1004)*Metric(2001,1002)*Metric(2004,1003)*P(2002,3)*P(2003,2) + Metric(1001,1002)*Metric(2001,1004)*Metric(2004,1003)*P(2002,3)*P(2003,2) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2004)*P(2002,4)*P(2003,2) + Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2004)*P(2002,4)*P(2003,2) + Metric(1002,1004)*Metric(2001,1003)*Metric(2004,1001)*P(2002,4)*P(2003,2) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2004,1001)*P(2002,4)*P(2003,2) + Metric(1003,1004)*Metric(2001,1001)*Metric(2004,1002)*P(2002,4)*P(2003,2) + Metric(1001,1004)*Metric(2001,1003)*Metric(2004,1002)*P(2002,4)*P(2003,2) + Metric(1001,1003)*Metric(2001,1004)*Metric(2004,1002)*P(2002,4)*P(2003,2) + Metric(1002,1004)*Metric(2001,1001)*Metric(2004,1003)*P(2002,4)*P(2003,2) + Metric(1002,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1001,2)*P(2003,4) + Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1004)*P(1001,2)*P(2003,4) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1001,2)*P(2003,4) + Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2004)*P(1001,2)*P(2003,4) + Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1002)*P(1001,2)*P(2003,4) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,2)*P(2003,4) - 2*Metric(2001,1003)*Metric(2002,1002)*Metric(2004,1004)*P(1001,2)*P(2003,4) + Metric(1003,1004)*Metric(2001,2004)*Metric(2002,1002)*P(1001,3)*P(2003,4) + Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2004)*P(1001,3)*P(2003,4) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1001,3)*P(2003,4) + Metric(1003,1004)*Metric(2001,2002)*Metric(2004,1002)*P(1001,3)*P(2003,4) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(1001,3)*P(2003,4) + Metric(1002,1004)*Metric(2001,2002)*Metric(2004,1003)*P(1001,3)*P(2003,4) + Metric(2001,1004)*Metric(2002,1002)*Metric(2004,1003)*P(1001,3)*P(2003,4) + Metric(2001,1002)*Metric(2002,1004)*Metric(2004,1003)*P(1001,3)*P(2003,4) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1002,1)*P(2003,4) + Metric(1001,1003)*Metric(2001,2004)*Metric(2002,1004)*P(1002,1)*P(2003,4) + Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2004)*P(1002,1)*P(2003,4) + Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2004)*P(1002,1)*P(2003,4) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1001)*P(1002,1)*P(2003,4) + Metric(2001,1003)*Metric(2002,1004)*Metric(2004,1001)*P(1002,1)*P(2003,4) - 2*Metric(2001,1001)*Metric(2002,1003)*Metric(2004,1004)*P(1002,1)*P(2003,4) + Metric(1003,1004)*Metric(2001,2004)*Metric(2002,1001)*P(1002,3)*P(2003,4) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,1003)*P(1002,3)*P(2003,4) + Metric(1003,1004)*Metric(2001,1001)*Metric(2002,2004)*P(1002,3)*P(2003,4) + Metric(1003,1004)*Metric(2001,2002)*Metric(2004,1001)*P(1002,3)*P(2003,4) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2004,1001)*P(1002,3)*P(2003,4) + Metric(1001,1004)*Metric(2001,2002)*Metric(2004,1003)*P(1002,3)*P(2003,4) + Metric(2001,1004)*Metric(2002,1001)*Metric(2004,1003)*P(1002,3)*P(2003,4) + Metric(2001,1001)*Metric(2002,1004)*Metric(2004,1003)*P(1002,3)*P(2003,4) - 2*Metric(1001,1004)*Metric(2001,2004)*Metric(2002,1002)*P(1003,1)*P(2003,4) - 2*Metric(2001,1004)*Metric(2002,1002)*Metric(2004,1001)*P(1003,1)*P(2003,4) - 2*Metric(1002,1004)*Metric(2001,1001)*Metric(2002,2004)*P(1003,2)*P(2003,4) - 2*Metric(2001,1001)*Metric(2002,1004)*Metric(2004,1002)*P(1003,2)*P(2003,4) + Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1001)*P(1004,1)*P(2003,4) + Metric(1001,1003)*Metric(2001,2004)*Metric(2002,1002)*P(1004,1)*P(2003,4) + Metric(1001,1002)*Metric(2001,2004)*Metric(2002,1003)*P(1004,1)*P(2003,4) + Metric(1002,1003)*Metric(2001,2002)*Metric(2004,1001)*P(1004,1)*P(2003,4) + Metric(2001,1003)*Metric(2002,1002)*Metric(2004,1001)*P(1004,1)*P(2003,4) + Metric(2001,1002)*Metric(2002,1003)*Metric(2004,1001)*P(1004,1)*P(2003,4) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2004,1003)*P(1004,1)*P(2003,4) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2004,1003)*P(1004,1)*P(2003,4) + Metric(1002,1003)*Metric(2001,1001)*Metric(2002,2004)*P(1004,2)*P(2003,4) + Metric(1001,1003)*Metric(2001,1002)*Metric(2002,2004)*P(1004,2)*P(2003,4) + Metric(1001,1002)*Metric(2001,1003)*Metric(2002,2004)*P(1004,2)*P(2003,4) + Metric(1001,1003)*Metric(2001,2002)*Metric(2004,1002)*P(1004,2)*P(2003,4) + Metric(2001,1003)*Metric(2002,1001)*Metric(2004,1002)*P(1004,2)*P(2003,4) + Metric(2001,1001)*Metric(2002,1003)*Metric(2004,1002)*P(1004,2)*P(2003,4) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2004,1003)*P(1004,2)*P(2003,4) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2004,1003)*P(1004,2)*P(2003,4) + Metric(1002,1003)*Metric(2001,2004)*Metric(2002,1001)*P(1004,3)*P(2003,4) + Metric(1001,1002)*Metric(2001,2004)*Metric(2002,1003)*P(1004,3)*P(2003,4) + Metric(1001,1003)*Metric(2001,1002)*Metric(2002,2004)*P(1004,3)*P(2003,4) + Metric(1001,1002)*Metric(2001,1003)*Metric(2002,2004)*P(1004,3)*P(2003,4) + Metric(1002,1003)*Metric(2001,2002)*Metric(2004,1001)*P(1004,3)*P(2003,4) + Metric(2001,1002)*Metric(2002,1003)*Metric(2004,1001)*P(1004,3)*P(2003,4) + Metric(1001,1003)*Metric(2001,2002)*Metric(2004,1002)*P(1004,3)*P(2003,4) + Metric(2001,1003)*Metric(2002,1001)*Metric(2004,1002)*P(1004,3)*P(2003,4) - 4*Metric(1001,1002)*Metric(2001,2002)*Metric(2004,1003)*P(1004,3)*P(2003,4) - 4*Metric(2001,1002)*Metric(2002,1001)*Metric(2004,1003)*P(1004,3)*P(2003,4) + Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2004)*P(2001,2)*P(2003,4) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2004)*P(2001,2)*P(2003,4) + Metric(1002,1004)*Metric(2002,1003)*Metric(2004,1001)*P(2001,2)*P(2003,4) + Metric(1002,1003)*Metric(2002,1004)*Metric(2004,1001)*P(2001,2)*P(2003,4) + Metric(1001,1004)*Metric(2002,1003)*Metric(2004,1002)*P(2001,2)*P(2003,4) - 2*Metric(1001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(2001,2)*P(2003,4) - 2*Metric(1001,1003)*Metric(2002,1002)*Metric(2004,1004)*P(2001,2)*P(2003,4) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2004)*P(2001,3)*P(2003,4) + Metric(1001,1002)*Metric(1003,1004)*Metric(2002,2004)*P(2001,3)*P(2003,4) + Metric(1003,1004)*Metric(2002,1002)*Metric(2004,1001)*P(2001,3)*P(2003,4) + Metric(1003,1004)*Metric(2002,1001)*Metric(2004,1002)*P(2001,3)*P(2003,4) - 2*Metric(1001,1003)*Metric(2002,1004)*Metric(2004,1002)*P(2001,3)*P(2003,4) + Metric(1002,1004)*Metric(2002,1001)*Metric(2004,1003)*P(2001,3)*P(2003,4) + Metric(1001,1004)*Metric(2002,1002)*Metric(2004,1003)*P(2001,3)*P(2003,4) + Metric(1001,1002)*Metric(2002,1004)*Metric(2004,1003)*P(2001,3)*P(2003,4) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2004)*P(2002,1)*P(2003,4) + Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2004)*P(2002,1)*P(2003,4) + Metric(1002,1004)*Metric(2001,1003)*Metric(2004,1001)*P(2002,1)*P(2003,4) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2004,1001)*P(2002,1)*P(2003,4) + Metric(1001,1004)*Metric(2001,1003)*Metric(2004,1002)*P(2002,1)*P(2003,4) + Metric(1001,1003)*Metric(2001,1004)*Metric(2004,1002)*P(2002,1)*P(2003,4) - 2*Metric(1002,1003)*Metric(2001,1001)*Metric(2004,1004)*P(2002,1)*P(2003,4) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2004)*P(2002,3)*P(2003,4) + Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2004)*P(2002,3)*P(2003,4) + Metric(1003,1004)*Metric(2001,1002)*Metric(2004,1001)*P(2002,3)*P(2003,4) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2004,1001)*P(2002,3)*P(2003,4) + Metric(1003,1004)*Metric(2001,1001)*Metric(2004,1002)*P(2002,3)*P(2003,4) + Metric(1002,1004)*Metric(2001,1001)*Metric(2004,1003)*P(2002,3)*P(2003,4) + Metric(1001,1004)*Metric(2001,1002)*Metric(2004,1003)*P(2002,3)*P(2003,4) + Metric(1001,1002)*Metric(2001,1004)*Metric(2004,1003)*P(2002,3)*P(2003,4) + Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2003)*P(1001,2)*P(2004,1) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1001,2)*P(2004,1) + Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1002)*P(1001,2)*P(2004,1) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,2)*P(2004,1) + Metric(1002,1004)*Metric(2001,2002)*Metric(2003,1003)*P(1001,2)*P(2004,1) + Metric(2001,1002)*Metric(2002,1004)*Metric(2003,1003)*P(1001,2)*P(2004,1) + Metric(1002,1003)*Metric(2001,2002)*Metric(2003,1004)*P(1001,2)*P(2004,1) + Metric(2001,1002)*Metric(2002,1003)*Metric(2003,1004)*P(1001,2)*P(2004,1) + Metric(1003,1004)*Metric(2001,2003)*Metric(2002,1002)*P(1001,3)*P(2004,1) + Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1003)*P(1001,3)*P(2004,1) + Metric(1002,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1001,3)*P(2004,1) + Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2003)*P(1001,3)*P(2004,1) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1001,3)*P(2004,1) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,3)*P(2004,1) + Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1002)*P(1001,3)*P(2004,1) + Metric(2001,1003)*Metric(2002,1002)*Metric(2003,1004)*P(1001,3)*P(2004,1) + Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1003)*P(1001,4)*P(2004,1) + Metric(1002,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1001,4)*P(2004,1) + Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2003)*P(1001,4)*P(2004,1) + Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2003)*P(1001,4)*P(2004,1) - 4*Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1001,4)*P(2004,1) + Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1002)*P(1001,4)*P(2004,1) - 4*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,4)*P(2004,1) + Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1002)*P(1001,4)*P(2004,1) + Metric(1002,1003)*Metric(2001,2002)*Metric(2003,1004)*P(1001,4)*P(2004,1) + Metric(2001,1002)*Metric(2002,1003)*Metric(2003,1004)*P(1001,4)*P(2004,1) + Metric(1003,1004)*Metric(2001,2003)*Metric(2002,1001)*P(1002,3)*P(2004,1) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1002,3)*P(2004,1) + Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1001)*P(1002,3)*P(2004,1) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1001)*P(1002,3)*P(2004,1) - 2*Metric(2001,1001)*Metric(2002,1004)*Metric(2003,1003)*P(1002,3)*P(2004,1) + Metric(1001,1003)*Metric(2001,2002)*Metric(2003,1004)*P(1002,3)*P(2004,1) + Metric(2001,1003)*Metric(2002,1001)*Metric(2003,1004)*P(1002,3)*P(2004,1) + Metric(1001,1004)*Metric(2001,2003)*Metric(2002,1003)*P(1002,4)*P(2004,1) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1002,4)*P(2004,1) + Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2003)*P(1002,4)*P(2004,1) + Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1002,4)*P(2004,1) + Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1001)*P(1002,4)*P(2004,1) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1001)*P(1002,4)*P(2004,1) + Metric(1001,1004)*Metric(2001,2002)*Metric(2003,1003)*P(1002,4)*P(2004,1) + Metric(2001,1004)*Metric(2002,1001)*Metric(2003,1003)*P(1002,4)*P(2004,1) + Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1001)*P(1003,2)*P(2004,1) + Metric(1001,1002)*Metric(2001,2003)*Metric(2002,1004)*P(1003,2)*P(2004,1) + Metric(1002,1004)*Metric(2001,2002)*Metric(2003,1001)*P(1003,2)*P(2004,1) + Metric(2001,1002)*Metric(2002,1004)*Metric(2003,1001)*P(1003,2)*P(2004,1) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,1004)*P(1003,2)*P(2004,1) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,1004)*P(1003,2)*P(2004,1) - 2*Metric(2001,1001)*Metric(2002,1002)*Metric(2003,1004)*P(1003,2)*P(2004,1) + Metric(1001,1004)*Metric(2001,2003)*Metric(2002,1002)*P(1003,4)*P(2004,1) + Metric(1001,1004)*Metric(2001,1002)*Metric(2002,2003)*P(1003,4)*P(2004,1) + Metric(1001,1002)*Metric(2001,1004)*Metric(2002,2003)*P(1003,4)*P(2004,1) + Metric(2001,1004)*Metric(2002,1002)*Metric(2003,1001)*P(1003,4)*P(2004,1) + Metric(1001,1004)*Metric(2001,2002)*Metric(2003,1002)*P(1003,4)*P(2004,1) + Metric(2001,1004)*Metric(2002,1001)*Metric(2003,1002)*P(1003,4)*P(2004,1) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,1004)*P(1003,4)*P(2004,1) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,1004)*P(1003,4)*P(2004,1) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,1003)*P(1004,2)*P(2004,1) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,1003)*P(1004,2)*P(2004,1) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,1002)*P(1004,3)*P(2004,1) - 2*Metric(2001,1003)*Metric(2002,1002)*Metric(2003,1001)*P(1004,3)*P(2004,1) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2003)*P(2001,2)*P(2004,1) + Metric(1001,1002)*Metric(1003,1004)*Metric(2002,2003)*P(2001,2)*P(2004,1) + Metric(1003,1004)*Metric(2002,1001)*Metric(2003,1002)*P(2001,2)*P(2004,1) - 2*Metric(1001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(2001,2)*P(2004,1) + Metric(1002,1004)*Metric(2002,1001)*Metric(2003,1003)*P(2001,2)*P(2004,1) + Metric(1001,1002)*Metric(2002,1004)*Metric(2003,1003)*P(2001,2)*P(2004,1) + Metric(1002,1003)*Metric(2002,1001)*Metric(2003,1004)*P(2001,2)*P(2004,1) + Metric(1001,1002)*Metric(2002,1003)*Metric(2003,1004)*P(2001,2)*P(2004,1) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2003)*P(2001,3)*P(2004,1) + Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2003)*P(2001,3)*P(2004,1) + Metric(1003,1004)*Metric(2002,1002)*Metric(2003,1001)*P(2001,3)*P(2004,1) + Metric(1002,1004)*Metric(2002,1003)*Metric(2003,1001)*P(2001,3)*P(2004,1) + Metric(1002,1003)*Metric(2002,1004)*Metric(2003,1001)*P(2001,3)*P(2004,1) - 2*Metric(1001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(2001,3)*P(2004,1) + Metric(1001,1003)*Metric(2002,1004)*Metric(2003,1002)*P(2001,3)*P(2004,1) + Metric(1001,1003)*Metric(2002,1002)*Metric(2003,1004)*P(2001,3)*P(2004,1) - 4*Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2003)*P(2001,4)*P(2004,1) + Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2003)*P(2001,4)*P(2004,1) + Metric(1001,1002)*Metric(1003,1004)*Metric(2002,2003)*P(2001,4)*P(2004,1) + Metric(1002,1004)*Metric(2002,1003)*Metric(2003,1001)*P(2001,4)*P(2004,1) + Metric(1002,1003)*Metric(2002,1004)*Metric(2003,1001)*P(2001,4)*P(2004,1) + Metric(1003,1004)*Metric(2002,1001)*Metric(2003,1002)*P(2001,4)*P(2004,1) - 4*Metric(1001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(2001,4)*P(2004,1) + Metric(1001,1003)*Metric(2002,1004)*Metric(2003,1002)*P(2001,4)*P(2004,1) + Metric(1002,1003)*Metric(2002,1001)*Metric(2003,1004)*P(2001,4)*P(2004,1) + Metric(1001,1002)*Metric(2002,1003)*Metric(2003,1004)*P(2001,4)*P(2004,1) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2003)*P(2002,3)*P(2004,1) + Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2003)*P(2002,3)*P(2004,1) + Metric(1003,1004)*Metric(2001,1002)*Metric(2003,1001)*P(2002,3)*P(2004,1) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2003,1001)*P(2002,3)*P(2004,1) - 2*Metric(1002,1004)*Metric(2001,1001)*Metric(2003,1003)*P(2002,3)*P(2004,1) + Metric(1001,1003)*Metric(2001,1002)*Metric(2003,1004)*P(2002,3)*P(2004,1) + Metric(1001,1002)*Metric(2001,1003)*Metric(2003,1004)*P(2002,3)*P(2004,1) + Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2003)*P(2002,4)*P(2004,1) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2003)*P(2002,4)*P(2004,1) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2003,1001)*P(2002,4)*P(2004,1) + Metric(1002,1003)*Metric(2001,1004)*Metric(2003,1001)*P(2002,4)*P(2004,1) + Metric(1001,1004)*Metric(2001,1003)*Metric(2003,1002)*P(2002,4)*P(2004,1) + Metric(1001,1003)*Metric(2001,1004)*Metric(2003,1002)*P(2002,4)*P(2004,1) + Metric(1001,1004)*Metric(2001,1002)*Metric(2003,1003)*P(2002,4)*P(2004,1) + Metric(1001,1002)*Metric(2001,1004)*Metric(2003,1003)*P(2002,4)*P(2004,1) + Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2002)*P(2003,2)*P(2004,1) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2002)*P(2003,2)*P(2004,1) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2002,1001)*P(2003,2)*P(2004,1) + Metric(1002,1004)*Metric(2001,1003)*Metric(2002,1001)*P(2003,2)*P(2004,1) - 2*Metric(1003,1004)*Metric(2001,1001)*Metric(2002,1002)*P(2003,2)*P(2004,1) + Metric(1001,1003)*Metric(2001,1002)*Metric(2002,1004)*P(2003,2)*P(2004,1) + Metric(1001,1002)*Metric(2001,1003)*Metric(2002,1004)*P(2003,2)*P(2004,1) + Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2002)*P(2003,4)*P(2004,1) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2002)*P(2003,4)*P(2004,1) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2002,1001)*P(2003,4)*P(2004,1) + Metric(1002,1003)*Metric(2001,1004)*Metric(2002,1001)*P(2003,4)*P(2004,1) + Metric(1001,1004)*Metric(2001,1003)*Metric(2002,1002)*P(2003,4)*P(2004,1) + Metric(1001,1003)*Metric(2001,1004)*Metric(2002,1002)*P(2003,4)*P(2004,1) + Metric(1001,1004)*Metric(2001,1002)*Metric(2002,1003)*P(2003,4)*P(2004,1) + Metric(1001,1002)*Metric(2001,1004)*Metric(2002,1003)*P(2003,4)*P(2004,1) + Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2003)*P(1001,3)*P(2004,2) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1001,3)*P(2004,2) + Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1002)*P(1001,3)*P(2004,2) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,3)*P(2004,2) - 2*Metric(2001,1004)*Metric(2002,1002)*Metric(2003,1003)*P(1001,3)*P(2004,2) + Metric(1002,1003)*Metric(2001,2002)*Metric(2003,1004)*P(1001,3)*P(2004,2) + Metric(2001,1002)*Metric(2002,1003)*Metric(2003,1004)*P(1001,3)*P(2004,2) + Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1003)*P(1001,4)*P(2004,2) + Metric(1002,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1001,4)*P(2004,2) + Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2003)*P(1001,4)*P(2004,2) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1001,4)*P(2004,2) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,4)*P(2004,2) + Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1002)*P(1001,4)*P(2004,2) + Metric(1002,1004)*Metric(2001,2002)*Metric(2003,1003)*P(1001,4)*P(2004,2) + Metric(2001,1002)*Metric(2002,1004)*Metric(2003,1003)*P(1001,4)*P(2004,2) + Metric(1003,1004)*Metric(2001,2003)*Metric(2002,1001)*P(1002,1)*P(2004,2) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1002,1)*P(2004,2) + Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1001)*P(1002,1)*P(2004,2) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1001)*P(1002,1)*P(2004,2) + Metric(1001,1004)*Metric(2001,2002)*Metric(2003,1003)*P(1002,1)*P(2004,2) + Metric(2001,1004)*Metric(2002,1001)*Metric(2003,1003)*P(1002,1)*P(2004,2) + Metric(1001,1003)*Metric(2001,2002)*Metric(2003,1004)*P(1002,1)*P(2004,2) + Metric(2001,1003)*Metric(2002,1001)*Metric(2003,1004)*P(1002,1)*P(2004,2) + Metric(1001,1004)*Metric(2001,2003)*Metric(2002,1003)*P(1002,3)*P(2004,2) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1002,3)*P(2004,2) + Metric(1003,1004)*Metric(2001,1001)*Metric(2002,2003)*P(1002,3)*P(2004,2) + Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2003)*P(1002,3)*P(2004,2) + Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1002,3)*P(2004,2) + Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1001)*P(1002,3)*P(2004,2) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1001)*P(1002,3)*P(2004,2) + Metric(2001,1001)*Metric(2002,1003)*Metric(2003,1004)*P(1002,3)*P(2004,2) + Metric(1003,1004)*Metric(2001,2003)*Metric(2002,1001)*P(1002,4)*P(2004,2) + Metric(1001,1004)*Metric(2001,2003)*Metric(2002,1003)*P(1002,4)*P(2004,2) - 4*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1002,4)*P(2004,2) + Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2003)*P(1002,4)*P(2004,2) + Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1002,4)*P(2004,2) + Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1001)*P(1002,4)*P(2004,2) + Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1001)*P(1002,4)*P(2004,2) - 4*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1001)*P(1002,4)*P(2004,2) + Metric(1001,1003)*Metric(2001,2002)*Metric(2003,1004)*P(1002,4)*P(2004,2) + Metric(2001,1003)*Metric(2002,1001)*Metric(2003,1004)*P(1002,4)*P(2004,2) + Metric(1001,1004)*Metric(2001,1002)*Metric(2002,2003)*P(1003,1)*P(2004,2) + Metric(1001,1002)*Metric(2001,1004)*Metric(2002,2003)*P(1003,1)*P(2004,2) + Metric(1001,1004)*Metric(2001,2002)*Metric(2003,1002)*P(1003,1)*P(2004,2) + Metric(2001,1004)*Metric(2002,1001)*Metric(2003,1002)*P(1003,1)*P(2004,2) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,1004)*P(1003,1)*P(2004,2) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,1004)*P(1003,1)*P(2004,2) - 2*Metric(2001,1001)*Metric(2002,1002)*Metric(2003,1004)*P(1003,1)*P(2004,2) + Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1001)*P(1003,4)*P(2004,2) + Metric(1001,1002)*Metric(2001,2003)*Metric(2002,1004)*P(1003,4)*P(2004,2) + Metric(1002,1004)*Metric(2001,1001)*Metric(2002,2003)*P(1003,4)*P(2004,2) + Metric(1002,1004)*Metric(2001,2002)*Metric(2003,1001)*P(1003,4)*P(2004,2) + Metric(2001,1002)*Metric(2002,1004)*Metric(2003,1001)*P(1003,4)*P(2004,2) + Metric(2001,1001)*Metric(2002,1004)*Metric(2003,1002)*P(1003,4)*P(2004,2) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,1004)*P(1003,4)*P(2004,2) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,1004)*P(1003,4)*P(2004,2) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,1003)*P(1004,1)*P(2004,2) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,1003)*P(1004,1)*P(2004,2) - 2*Metric(1002,1003)*Metric(2001,1001)*Metric(2002,2003)*P(1004,3)*P(2004,2) - 2*Metric(2001,1001)*Metric(2002,1003)*Metric(2003,1002)*P(1004,3)*P(2004,2) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2003)*P(2001,3)*P(2004,2) + Metric(1001,1002)*Metric(1003,1004)*Metric(2002,2003)*P(2001,3)*P(2004,2) + Metric(1003,1004)*Metric(2002,1001)*Metric(2003,1002)*P(2001,3)*P(2004,2) - 2*Metric(1001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(2001,3)*P(2004,2) - 2*Metric(1001,1004)*Metric(2002,1002)*Metric(2003,1003)*P(2001,3)*P(2004,2) + Metric(1002,1003)*Metric(2002,1001)*Metric(2003,1004)*P(2001,3)*P(2004,2) + Metric(1001,1002)*Metric(2002,1003)*Metric(2003,1004)*P(2001,3)*P(2004,2) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2003)*P(2001,4)*P(2004,2) + Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2003)*P(2001,4)*P(2004,2) + Metric(1002,1004)*Metric(2002,1003)*Metric(2003,1001)*P(2001,4)*P(2004,2) + Metric(1002,1003)*Metric(2002,1004)*Metric(2003,1001)*P(2001,4)*P(2004,2) - 2*Metric(1001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(2001,4)*P(2004,2) + Metric(1001,1003)*Metric(2002,1004)*Metric(2003,1002)*P(2001,4)*P(2004,2) + Metric(1002,1004)*Metric(2002,1001)*Metric(2003,1003)*P(2001,4)*P(2004,2) + Metric(1001,1002)*Metric(2002,1004)*Metric(2003,1003)*P(2001,4)*P(2004,2) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2003)*P(2002,1)*P(2004,2) + Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2003)*P(2002,1)*P(2004,2) + Metric(1003,1004)*Metric(2001,1002)*Metric(2003,1001)*P(2002,1)*P(2004,2) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2003,1001)*P(2002,1)*P(2004,2) + Metric(1001,1004)*Metric(2001,1002)*Metric(2003,1003)*P(2002,1)*P(2004,2) + Metric(1001,1002)*Metric(2001,1004)*Metric(2003,1003)*P(2002,1)*P(2004,2) + Metric(1001,1003)*Metric(2001,1002)*Metric(2003,1004)*P(2002,1)*P(2004,2) + Metric(1001,1002)*Metric(2001,1003)*Metric(2003,1004)*P(2002,1)*P(2004,2) + Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2003)*P(2002,3)*P(2004,2) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2003)*P(2002,3)*P(2004,2) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2003,1001)*P(2002,3)*P(2004,2) + Metric(1002,1003)*Metric(2001,1004)*Metric(2003,1001)*P(2002,3)*P(2004,2) + Metric(1003,1004)*Metric(2001,1001)*Metric(2003,1002)*P(2002,3)*P(2004,2) + Metric(1001,1004)*Metric(2001,1003)*Metric(2003,1002)*P(2002,3)*P(2004,2) + Metric(1001,1003)*Metric(2001,1004)*Metric(2003,1002)*P(2002,3)*P(2004,2) + Metric(1002,1003)*Metric(2001,1001)*Metric(2003,1004)*P(2002,3)*P(2004,2) + Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2003)*P(2002,4)*P(2004,2) - 4*Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2003)*P(2002,4)*P(2004,2) + Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2003)*P(2002,4)*P(2004,2) + Metric(1003,1004)*Metric(2001,1002)*Metric(2003,1001)*P(2002,4)*P(2004,2) - 4*Metric(1002,1004)*Metric(2001,1003)*Metric(2003,1001)*P(2002,4)*P(2004,2) + Metric(1002,1003)*Metric(2001,1004)*Metric(2003,1001)*P(2002,4)*P(2004,2) + Metric(1001,1004)*Metric(2001,1003)*Metric(2003,1002)*P(2002,4)*P(2004,2) + Metric(1001,1003)*Metric(2001,1004)*Metric(2003,1002)*P(2002,4)*P(2004,2) + Metric(1001,1003)*Metric(2001,1002)*Metric(2003,1004)*P(2002,4)*P(2004,2) + Metric(1001,1002)*Metric(2001,1003)*Metric(2003,1004)*P(2002,4)*P(2004,2) + Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2002)*P(2003,1)*P(2004,2) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2002)*P(2003,1)*P(2004,2) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2002,1001)*P(2003,1)*P(2004,2) + Metric(1002,1003)*Metric(2001,1004)*Metric(2002,1001)*P(2003,1)*P(2004,2) - 2*Metric(1003,1004)*Metric(2001,1001)*Metric(2002,1002)*P(2003,1)*P(2004,2) + Metric(1001,1004)*Metric(2001,1002)*Metric(2002,1003)*P(2003,1)*P(2004,2) + Metric(1001,1002)*Metric(2001,1004)*Metric(2002,1003)*P(2003,1)*P(2004,2) + Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2002)*P(2003,4)*P(2004,2) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2002)*P(2003,4)*P(2004,2) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2002,1001)*P(2003,4)*P(2004,2) + Metric(1002,1004)*Metric(2001,1003)*Metric(2002,1001)*P(2003,4)*P(2004,2) + Metric(1002,1004)*Metric(2001,1001)*Metric(2002,1003)*P(2003,4)*P(2004,2) + Metric(1002,1003)*Metric(2001,1001)*Metric(2002,1004)*P(2003,4)*P(2004,2) + Metric(1001,1003)*Metric(2001,1002)*Metric(2002,1004)*P(2003,4)*P(2004,2) + Metric(1001,1002)*Metric(2001,1003)*Metric(2002,1004)*P(2003,4)*P(2004,2) + Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1003)*P(1001,2)*P(2004,3) + Metric(1002,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1001,2)*P(2004,3) + Metric(1002,1004)*Metric(2001,1003)*Metric(2002,2003)*P(1001,2)*P(2004,3) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1001,2)*P(2004,3) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,2)*P(2004,3) + Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1002)*P(1001,2)*P(2004,3) - 2*Metric(2001,1004)*Metric(2002,1002)*Metric(2003,1003)*P(1001,2)*P(2004,3) + Metric(1003,1004)*Metric(2001,2003)*Metric(2002,1002)*P(1001,4)*P(2004,3) + Metric(1003,1004)*Metric(2001,1002)*Metric(2002,2003)*P(1001,4)*P(2004,3) - 2*Metric(1002,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1001,4)*P(2004,3) + Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1002)*P(1001,4)*P(2004,3) - 2*Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(1001,4)*P(2004,3) + Metric(1002,1003)*Metric(2001,2002)*Metric(2003,1004)*P(1001,4)*P(2004,3) + Metric(2001,1003)*Metric(2002,1002)*Metric(2003,1004)*P(1001,4)*P(2004,3) + Metric(2001,1002)*Metric(2002,1003)*Metric(2003,1004)*P(1001,4)*P(2004,3) + Metric(1001,1004)*Metric(2001,2003)*Metric(2002,1003)*P(1002,1)*P(2004,3) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1002,1)*P(2004,3) + Metric(1001,1004)*Metric(2001,1003)*Metric(2002,2003)*P(1002,1)*P(2004,3) + Metric(1001,1003)*Metric(2001,1004)*Metric(2002,2003)*P(1002,1)*P(2004,3) + Metric(2001,1004)*Metric(2002,1003)*Metric(2003,1001)*P(1002,1)*P(2004,3) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1001)*P(1002,1)*P(2004,3) - 2*Metric(2001,1001)*Metric(2002,1004)*Metric(2003,1003)*P(1002,1)*P(2004,3) + Metric(1003,1004)*Metric(2001,2003)*Metric(2002,1001)*P(1002,4)*P(2004,3) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,1004)*P(1002,4)*P(2004,3) + Metric(1003,1004)*Metric(2001,1001)*Metric(2002,2003)*P(1002,4)*P(2004,3) + Metric(1003,1004)*Metric(2001,2002)*Metric(2003,1001)*P(1002,4)*P(2004,3) - 2*Metric(2001,1003)*Metric(2002,1004)*Metric(2003,1001)*P(1002,4)*P(2004,3) + Metric(1001,1003)*Metric(2001,2002)*Metric(2003,1004)*P(1002,4)*P(2004,3) + Metric(2001,1003)*Metric(2002,1001)*Metric(2003,1004)*P(1002,4)*P(2004,3) + Metric(2001,1001)*Metric(2002,1003)*Metric(2003,1004)*P(1002,4)*P(2004,3) + Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1001)*P(1003,1)*P(2004,3) + Metric(1001,1004)*Metric(2001,2003)*Metric(2002,1002)*P(1003,1)*P(2004,3) + Metric(1001,1002)*Metric(2001,2003)*Metric(2002,1004)*P(1003,1)*P(2004,3) + Metric(1002,1004)*Metric(2001,2002)*Metric(2003,1001)*P(1003,1)*P(2004,3) + Metric(2001,1004)*Metric(2002,1002)*Metric(2003,1001)*P(1003,1)*P(2004,3) + Metric(2001,1002)*Metric(2002,1004)*Metric(2003,1001)*P(1003,1)*P(2004,3) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,1004)*P(1003,1)*P(2004,3) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,1004)*P(1003,1)*P(2004,3) + Metric(1002,1004)*Metric(2001,1001)*Metric(2002,2003)*P(1003,2)*P(2004,3) + Metric(1001,1004)*Metric(2001,1002)*Metric(2002,2003)*P(1003,2)*P(2004,3) + Metric(1001,1002)*Metric(2001,1004)*Metric(2002,2003)*P(1003,2)*P(2004,3) + Metric(1001,1004)*Metric(2001,2002)*Metric(2003,1002)*P(1003,2)*P(2004,3) + Metric(2001,1004)*Metric(2002,1001)*Metric(2003,1002)*P(1003,2)*P(2004,3) + Metric(2001,1001)*Metric(2002,1004)*Metric(2003,1002)*P(1003,2)*P(2004,3) - 2*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,1004)*P(1003,2)*P(2004,3) - 2*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,1004)*P(1003,2)*P(2004,3) + Metric(1002,1004)*Metric(2001,2003)*Metric(2002,1001)*P(1003,4)*P(2004,3) + Metric(1001,1002)*Metric(2001,2003)*Metric(2002,1004)*P(1003,4)*P(2004,3) + Metric(1001,1004)*Metric(2001,1002)*Metric(2002,2003)*P(1003,4)*P(2004,3) + Metric(1001,1002)*Metric(2001,1004)*Metric(2002,2003)*P(1003,4)*P(2004,3) + Metric(1002,1004)*Metric(2001,2002)*Metric(2003,1001)*P(1003,4)*P(2004,3) + Metric(2001,1002)*Metric(2002,1004)*Metric(2003,1001)*P(1003,4)*P(2004,3) + Metric(1001,1004)*Metric(2001,2002)*Metric(2003,1002)*P(1003,4)*P(2004,3) + Metric(2001,1004)*Metric(2002,1001)*Metric(2003,1002)*P(1003,4)*P(2004,3) - 4*Metric(1001,1002)*Metric(2001,2002)*Metric(2003,1004)*P(1003,4)*P(2004,3) - 4*Metric(2001,1002)*Metric(2002,1001)*Metric(2003,1004)*P(1003,4)*P(2004,3) - 2*Metric(1001,1003)*Metric(2001,2003)*Metric(2002,1002)*P(1004,1)*P(2004,3) - 2*Metric(2001,1003)*Metric(2002,1002)*Metric(2003,1001)*P(1004,1)*P(2004,3) - 2*Metric(1002,1003)*Metric(2001,1001)*Metric(2002,2003)*P(1004,2)*P(2004,3) - 2*Metric(2001,1001)*Metric(2002,1003)*Metric(2003,1002)*P(1004,2)*P(2004,3) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2003)*P(2001,2)*P(2004,3) + Metric(1001,1003)*Metric(1002,1004)*Metric(2002,2003)*P(2001,2)*P(2004,3) + Metric(1002,1004)*Metric(2002,1003)*Metric(2003,1001)*P(2001,2)*P(2004,3) + Metric(1002,1003)*Metric(2002,1004)*Metric(2003,1001)*P(2001,2)*P(2004,3) - 2*Metric(1001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(2001,2)*P(2004,3) + Metric(1001,1003)*Metric(2002,1004)*Metric(2003,1002)*P(2001,2)*P(2004,3) - 2*Metric(1001,1004)*Metric(2002,1002)*Metric(2003,1003)*P(2001,2)*P(2004,3) - 2*Metric(1001,1004)*Metric(1002,1003)*Metric(2002,2003)*P(2001,4)*P(2004,3) + Metric(1001,1002)*Metric(1003,1004)*Metric(2002,2003)*P(2001,4)*P(2004,3) + Metric(1003,1004)*Metric(2002,1002)*Metric(2003,1001)*P(2001,4)*P(2004,3) + Metric(1003,1004)*Metric(2002,1001)*Metric(2003,1002)*P(2001,4)*P(2004,3) - 2*Metric(1001,1004)*Metric(2002,1003)*Metric(2003,1002)*P(2001,4)*P(2004,3) + Metric(1002,1003)*Metric(2002,1001)*Metric(2003,1004)*P(2001,4)*P(2004,3) + Metric(1001,1003)*Metric(2002,1002)*Metric(2003,1004)*P(2001,4)*P(2004,3) + Metric(1001,1002)*Metric(2002,1003)*Metric(2003,1004)*P(2001,4)*P(2004,3) + Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2003)*P(2002,1)*P(2004,3) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2003)*P(2002,1)*P(2004,3) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2003,1001)*P(2002,1)*P(2004,3) + Metric(1002,1003)*Metric(2001,1004)*Metric(2003,1001)*P(2002,1)*P(2004,3) + Metric(1001,1004)*Metric(2001,1003)*Metric(2003,1002)*P(2002,1)*P(2004,3) + Metric(1001,1003)*Metric(2001,1004)*Metric(2003,1002)*P(2002,1)*P(2004,3) - 2*Metric(1002,1004)*Metric(2001,1001)*Metric(2003,1003)*P(2002,1)*P(2004,3) - 2*Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2003)*P(2002,4)*P(2004,3) + Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2003)*P(2002,4)*P(2004,3) + Metric(1003,1004)*Metric(2001,1002)*Metric(2003,1001)*P(2002,4)*P(2004,3) - 2*Metric(1002,1004)*Metric(2001,1003)*Metric(2003,1001)*P(2002,4)*P(2004,3) + Metric(1003,1004)*Metric(2001,1001)*Metric(2003,1002)*P(2002,4)*P(2004,3) + Metric(1002,1003)*Metric(2001,1001)*Metric(2003,1004)*P(2002,4)*P(2004,3) + Metric(1001,1003)*Metric(2001,1002)*Metric(2003,1004)*P(2002,4)*P(2004,3) + Metric(1001,1002)*Metric(2001,1003)*Metric(2003,1004)*P(2002,4)*P(2004,3) + Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2002)*P(2003,1)*P(2004,3) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2002)*P(2003,1)*P(2004,3) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2002,1001)*P(2003,1)*P(2004,3) + Metric(1002,1004)*Metric(2001,1003)*Metric(2002,1001)*P(2003,1)*P(2004,3) + Metric(1001,1004)*Metric(2001,1003)*Metric(2002,1002)*P(2003,1)*P(2004,3) + Metric(1001,1003)*Metric(2001,1004)*Metric(2002,1002)*P(2003,1)*P(2004,3) + Metric(1001,1003)*Metric(2001,1002)*Metric(2002,1004)*P(2003,1)*P(2004,3) + Metric(1001,1002)*Metric(2001,1003)*Metric(2002,1004)*P(2003,1)*P(2004,3) + Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2002)*P(2003,2)*P(2004,3) - 2*Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2002)*P(2003,2)*P(2004,3) - 2*Metric(1003,1004)*Metric(2001,1002)*Metric(2002,1001)*P(2003,2)*P(2004,3) + Metric(1002,1003)*Metric(2001,1004)*Metric(2002,1001)*P(2003,2)*P(2004,3) + Metric(1002,1004)*Metric(2001,1001)*Metric(2002,1003)*P(2003,2)*P(2004,3) + Metric(1001,1004)*Metric(2001,1002)*Metric(2002,1003)*P(2003,2)*P(2004,3) + Metric(1001,1002)*Metric(2001,1004)*Metric(2002,1003)*P(2003,2)*P(2004,3) + Metric(1002,1003)*Metric(2001,1001)*Metric(2002,1004)*P(2003,2)*P(2004,3) + Metric(1001,1004)*Metric(1002,1003)*Metric(2001,2002)*P(2003,4)*P(2004,3) + Metric(1001,1003)*Metric(1002,1004)*Metric(2001,2002)*P(2003,4)*P(2004,3) - 4*Metric(1001,1002)*Metric(1003,1004)*Metric(2001,2002)*P(2003,4)*P(2004,3) - 4*Metric(1003,1004)*Metric(2001,1002)*Metric(2002,1001)*P(2003,4)*P(2004,3) + Metric(1002,1004)*Metric(2001,1003)*Metric(2002,1001)*P(2003,4)*P(2004,3) + Metric(1002,1003)*Metric(2001,1004)*Metric(2002,1001)*P(2003,4)*P(2004,3) + Metric(1001,1004)*Metric(2001,1002)*Metric(2002,1003)*P(2003,4)*P(2004,3) + Metric(1001,1002)*Metric(2001,1004)*Metric(2002,1003)*P(2003,4)*P(2004,3) + Metric(1001,1003)*Metric(2001,1002)*Metric(2002,1004)*P(2003,4)*P(2004,3) + Metric(1001,1002)*Metric(2001,1003)*Metric(2002,1004)*P(2003,4)*P(2004,3)')
+
+    )
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/object_library.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/object_library.py
new file mode 100644
index 0000000000..85c41db185
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/object_library.py
@@ -0,0 +1,280 @@
+# type: ignore
+##
+##
+# Feynrules Header
+##
+##
+##
+##
+##
+
+from __future__ import absolute_import
+import cmath
+
+
+class UFOBaseClass(object):
+    """The class from which all FeynRules classes are derived."""
+
+    require_args = []
+
+    def __init__(self, *args, **options):
+        assert (len(self.require_args) == len(args))
+
+        for i, name in enumerate(self.require_args):
+            setattr(self, name, args[i])
+
+        for (option, value) in options.items():
+            setattr(self, option, value)
+
+    def get(self, name):
+        return getattr(self, name)
+
+    def set(self, name, value):
+        setattr(self, name, value)
+
+    def get_all(self):
+        """Return a dictionary containing all the information of the object"""
+        return self.__dict__
+
+    def __str__(self):
+        return self.name
+
+    def nice_string(self):
+        """ return string with the full information """
+        return '\n'.join(['%s \t: %s' % (name, value) for name, value in self.__dict__.items()])
+
+    def __repr__(self):
+        replacements = [
+            ('+', '__plus__'),
+            ('-', '__minus__'),
+            ('@', '__at__'),
+            ('!', '__exclam__'),
+            ('?', '__quest__'),
+            ('*', '__star__'),
+            ('~', '__tilde__')
+        ]
+        text = self.name
+        for orig, sub in replacements:
+            text = text.replace(orig, sub)
+        return text
+
+
+all_particles = []
+
+
+class Particle(UFOBaseClass):
+    """A standard Particle"""
+
+    require_args = ['pdg_code', 'name', 'antiname', 'spin',
+                    'color', 'mass', 'width', 'texname', 'antitexname', 'charge']
+
+    require_args_all = ['pdg_code', 'name', 'antiname', 'spin', 'color', 'mass', 'width',
+                        'texname', 'antitexname', 'charge', 'line', 'propagating', 'goldstoneboson']
+
+    def __init__(self, pdg_code, name, antiname, spin, color, mass, width, texname,
+                 antitexname, charge, line=None, propagating=True, goldstoneboson=False, **options):
+
+        args = (pdg_code, name, antiname, spin, color, mass, width, texname,
+                antitexname, float(charge))
+
+        UFOBaseClass.__init__(self, *args,  **options)
+
+        global all_particles
+        all_particles.append(self)
+
+        self.propagating = propagating
+        self.goldstoneboson = goldstoneboson
+
+        self.selfconjugate = (name == antiname)
+        if 1:  # not line:
+            self.line = self.find_line_type()
+        else:
+            self.line = line
+
+    def find_line_type(self):
+        """ find how we draw a line if not defined
+        valid output: dashed/straight/wavy/curly/double/swavy/scurly
+        """
+
+        spin = self.spin
+        color = self.color
+
+        # use default
+        if spin == 1:
+            return 'dashed'
+        elif spin == 2:
+            if not self.selfconjugate:
+                return 'straight'
+            elif color == 1:
+                return 'swavy'
+            else:
+                return 'scurly'
+        elif spin == 3:
+            if color == 1:
+                return 'wavy'
+
+            else:
+                return 'curly'
+        elif spin == 5:
+            return 'double'
+        elif spin == -1:
+            return 'dotted'
+        else:
+            return 'dashed'  # not supported yet
+
+    def anti(self):
+        if self.selfconjugate:
+            raise Exception('%s has no anti particle.' % self.name)
+        outdic = {}
+        for k, v in self.__dict__.items():
+            if k not in self.require_args_all:
+                outdic[k] = -v
+        if self.color in [1, 8]:
+            newcolor = self.color
+        else:
+            newcolor = -self.color
+
+        return Particle(-self.pdg_code, self.antiname, self.name, self.spin, newcolor, self.mass, self.width,
+                        self.antitexname, self.texname, -self.charge, self.line, self.propagating, self.goldstoneboson, **outdic)
+
+
+all_parameters = []
+
+
+class Parameter(UFOBaseClass):
+
+    require_args = ['name', 'nature', 'type', 'value', 'texname']
+
+    def __init__(self, name, nature, type, value, texname, lhablock=None, lhacode=None):
+
+        args = (name, nature, type, value, texname)
+
+        UFOBaseClass.__init__(self, *args)
+
+        args = (name, nature, type, value, texname)
+
+        global all_parameters
+        all_parameters.append(self)
+
+        if (lhablock is None or lhacode is None) and nature == 'external':
+            raise Exception(
+                'Need LHA information for external parameter "%s".' % name)
+        self.lhablock = lhablock
+        self.lhacode = lhacode
+
+
+all_vertices = []
+
+
+class Vertex(UFOBaseClass):
+
+    require_args = ['name', 'particles', 'color', 'lorentz', 'couplings']
+
+    def __init__(self, name, particles, color, lorentz, couplings, **opt):
+
+        args = (name, particles, color, lorentz, couplings)
+
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        args = (particles, color, lorentz, couplings)
+
+        global all_vertices
+        all_vertices.append(self)
+
+
+all_couplings = []
+
+
+class Coupling(UFOBaseClass):
+
+    require_args = ['name', 'value', 'order']
+
+    def __init__(self, name, value, order, **opt):
+
+        args = (name, value, order)
+        UFOBaseClass.__init__(self, *args, **opt)
+        global all_couplings
+        all_couplings.append(self)
+
+
+all_lorentz = []
+
+
+class Lorentz(UFOBaseClass):
+
+    require_args = ['name', 'spins', 'structure']
+
+    def __init__(self, name, spins, structure='external', **opt):
+        args = (name, spins, structure)
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        global all_lorentz
+        all_lorentz.append(self)
+
+
+all_functions = []
+
+
+class Function(object):
+
+    def __init__(self, name, arguments, expression):
+
+        global all_functions
+        all_functions.append(self)
+
+        self.name = name
+        self.arguments = arguments
+        self.expr = expression
+
+    def __call__(self, *opt):
+
+        for i, arg in enumerate(self.arguments):
+            exec('%s = %s' % (arg, opt[i]))
+
+        return eval(self.expr)
+
+
+all_orders = []
+
+
+class CouplingOrder(object):
+
+    def __init__(self, name, expansion_order, hierarchy, perturbative_expansion=0):
+
+        global all_orders
+        all_orders.append(self)
+
+        self.name = name
+        self.expansion_order = expansion_order
+        self.hierarchy = hierarchy
+
+
+all_decays = []
+
+
+class Decay(UFOBaseClass):
+    require_args = ['particle', 'partial_widths']
+
+    def __init__(self, particle, partial_widths, **opt):
+        args = (particle, partial_widths)
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        global all_decays
+        all_decays.append(self)
+
+        # Add the information directly to the particle
+        particle.partial_widths = partial_widths
+
+
+all_form_factors = []
+
+
+class FormFactor(UFOBaseClass):
+    require_args = ['name', 'type', 'value']
+
+    def __init__(self, name, type, value, **opt):
+        args = (name, type, value)
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        global all_form_factors
+        all_form_factors.append(self)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/param_card.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/param_card.dat
new file mode 100644
index 0000000000..84e32fdbbb
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/param_card.dat
@@ -0,0 +1,51 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR GRAVITY
+###################################
+Block GRAVITY
+  1337 1.000000e+00 # kappa
+  1338 4.000000e+00 # dim
+
+###################################
+## INFORMATION FOR SCALARS
+###################################
+Block SCALARS
+  2002 1.000000e+00 # mass_scalar_1
+  2003 2.000000e+00 # mass_scalar_2
+  3002 0.000000e+00 # width_scalar_1
+  3003 0.000000e+00 # width_scalar_2
+#===========================================================
+# QUANTUM NUMBERS OF NEW STATE(S) (NON SM PDG CODE)
+#===========================================================
+
+Block QNUMBERS 2000  # scalar_0
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 2001  # scalar_1
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 2002  # scalar_2
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 1337  # graviton
+        1 0  # 3 times electric charge
+        2 11  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/parameters.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/parameters.py
new file mode 100644
index 0000000000..fc7068f097
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/parameters.py
@@ -0,0 +1,100 @@
+# type: ignore
+from __future__ import absolute_import
+from .object_library import all_parameters, Parameter
+
+from .function_library import complexconjugate, re, im, csc, sec, acsc, asec
+
+# Standalone assets are immutable; model shape must not depend on host state.
+N_SCALARS = 3
+
+# This is a default parameter object representing 0.
+ZERO = Parameter(name='ZERO',
+                 nature='internal',
+                 type='real',
+                 value='0.0',
+                 texname='0')
+
+# Introduce the scalar coupling lambda
+kappa = Parameter(name='kappa',
+                  nature='external',
+                  type='real',
+                  value=1.0,
+                  texname='\\kappa',
+                  lhablock='GRAVITY',
+                  lhacode=[1337])
+
+dim = Parameter(name='dim',
+                nature='external',
+                type='real',
+                value=4.0,
+                texname='\\text{dim}',
+                lhablock='GRAVITY',
+                lhacode=[1338])
+
+# Assign masses and widths to the scalars
+scalar_mass_parameters = []
+scalar_width_parameters = []
+for i_scalar in range(N_SCALARS):
+    # Set the first scalar with id 0 to always be massless
+    if i_scalar == 0:
+        scalar_mass_parameters.append(ZERO)
+        scalar_width_parameters.append(ZERO)
+        continue
+    # remember that the constructor automatically adds the objects to all_parameters
+    scalar_mass_parameters.append(Parameter(name='mass_scalar_%s' % i_scalar,
+                                            nature='external',
+                                            type='real',
+                                            value=1.0*i_scalar,
+                                            texname='m_%d' % i_scalar,
+                                            lhablock='SCALARS',
+                                            lhacode=[2001+i_scalar]))
+    scalar_width_parameters.append(Parameter(name='width_scalar_%s' % i_scalar,
+                                             nature='external',
+                                             type='real',
+                                             value=0.0,
+                                             texname='w_%d' % i_scalar,
+                                             lhablock='SCALARS',
+                                             lhacode=[3001+i_scalar]))
+
+# User-defined parameters. Keep key SM parameters as their use may be hardcoded in some generators
+aEWM1 = Parameter(name='aEWM1',
+                  nature='external',
+                  type='real',
+                  value=132.50698,
+                  texname='\\text{aEWM1}',
+                  lhablock='SMINPUTS',
+                  lhacode=[1])
+
+Gf = Parameter(name='Gf',
+               nature='external',
+               type='real',
+               value=0.0000116639,
+               texname='G_f',
+               lhablock='SMINPUTS',
+               lhacode=[2])
+
+aS = Parameter(name='aS',
+               nature='external',
+               type='real',
+               value=0.118,
+               texname='\\alpha _s',
+               lhablock='SMINPUTS',
+               lhacode=[3])
+
+aEW = Parameter(name='aEW',
+                nature='internal',
+                type='real',
+                value='1/aEWM1',
+                texname='\\alpha _{\\text{EW}}')
+
+G = Parameter(name='G',
+              nature='internal',
+              type='real',
+              value='2*cmath.sqrt(aS)*cmath.sqrt(cmath.pi)',
+              texname='G')
+
+ee = Parameter(name='ee',
+               nature='internal',
+               type='real',
+               value='2*cmath.sqrt(aEW)*cmath.sqrt(cmath.pi)',
+               texname='e')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/particles.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/particles.py
new file mode 100644
index 0000000000..bea3ca350e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/particles.py
@@ -0,0 +1,40 @@
+# type: ignore
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:25
+
+
+from __future__ import division
+from __future__ import absolute_import
+from .object_library import all_particles, Particle  # pylint: disable=unused-import
+from . import parameters as Param
+
+scalar_particles = []
+for i_scalar in range(Param.N_SCALARS):
+    scalar_particles.append(Particle(pdg_code=2000+i_scalar,
+                                     name='scalar_%d' % i_scalar,
+                                     antiname='scalar_%d' % i_scalar,
+                                     spin=1,
+                                     color=1,
+                                     mass=Param.scalar_mass_parameters[i_scalar],
+                                     width=Param.scalar_width_parameters[i_scalar],
+                                     texname='\\phi_%d' % i_scalar,
+                                     antitexname='\\phi_%d' % i_scalar,
+                                     charge=0,
+                                     GhostNumber=0,
+                                     LeptonNumber=0,
+                                     Y=0))
+
+graviton = Particle(pdg_code=1337,
+                    name='graviton',
+                    antiname='graviton',
+                    spin=5,
+                    color=1,
+                    mass=Param.ZERO,
+                    width=Param.ZERO,
+                    texname='\\tilde{g}',
+                    antitexname='\\tilde{g}',
+                    charge=0,
+                    GhostNumber=0,
+                    LeptonNumber=0,
+                    Y=0)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/restrict_default.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/restrict_default.dat
new file mode 100644
index 0000000000..84e32fdbbb
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/restrict_default.dat
@@ -0,0 +1,51 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR GRAVITY
+###################################
+Block GRAVITY
+  1337 1.000000e+00 # kappa
+  1338 4.000000e+00 # dim
+
+###################################
+## INFORMATION FOR SCALARS
+###################################
+Block SCALARS
+  2002 1.000000e+00 # mass_scalar_1
+  2003 2.000000e+00 # mass_scalar_2
+  3002 0.000000e+00 # width_scalar_1
+  3003 0.000000e+00 # width_scalar_2
+#===========================================================
+# QUANTUM NUMBERS OF NEW STATE(S) (NON SM PDG CODE)
+#===========================================================
+
+Block QNUMBERS 2000  # scalar_0
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 2001  # scalar_1
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 2002  # scalar_2
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 1337  # graviton
+        1 0  # 3 times electric charge
+        2 11  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/restrict_full.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/restrict_full.dat
new file mode 100644
index 0000000000..b206643b68
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/restrict_full.dat
@@ -0,0 +1,40 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY GAMMALOOP                   ##
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR SCALARS
+###################################
+Block SCALARS
+  1337 1.000000e+00 # lam
+  2002 1.000000e+00 # mass_scalar_1
+  2003 2.000000e+00 # mass_scalar_2
+  3002 0.000000e+00 # width_scalar_1
+  3003 0.000000e+00 # width_scalar_2
+#===========================================================
+# QUANTUM NUMBERS OF NEW STATE(S) (NON SM PDG CODE)
+#===========================================================
+
+Block QNUMBERS 1000  # scalar_0
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 1001  # scalar_1
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 1002  # scalar_2
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/run_write_param_card.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/run_write_param_card.py
new file mode 100755
index 0000000000..d87ecc25b9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/run_write_param_card.py
@@ -0,0 +1,19 @@
+# type: ignore
+#!/usr/bin/env python
+from __future__ import absolute_import
+from __future__ import print_function
+from six.moves import range
+
+import sys
+import os
+import importlib
+
+if '__main__' == __name__:
+    dir_path = os.path.join(os.path.dirname(__file__))
+    sys.path.insert(0, os.path.join(dir_path, os.path.pardir))
+    pw = importlib.import_module('%s.%s' % (
+        os.path.basename(dir_path), 'write_param_card'))
+    del sys.path[0]
+
+    pw.ParamCardWriter('./param_card.dat', generic=True)
+    print('write ./param_card.dat')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/vertices.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/vertices.py
new file mode 100644
index 0000000000..ca314996c7
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/vertices.py
@@ -0,0 +1,53 @@
+# type: ignore
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:25
+
+
+from __future__ import absolute_import
+from .object_library import all_vertices, Vertex
+from . import particles as P
+from . import couplings as C
+from . import lorentz as L
+from . import parameters as Param
+import itertools
+
+for i_scalar in list(range(Param.N_SCALARS)):
+    Vertex(name='V_S%sS%sGr' % (i_scalar, i_scalar),
+           particles=[P.scalar_particles[i_scalar],
+                      P.scalar_particles[i_scalar], P.graviton],
+           color=['1'],
+           lorentz=[L.SSTmpart, L.SST],
+           couplings={(0, 0): getattr(
+               C, ("SSTmpart%d" % i_scalar)), (0, 1): C.SST}
+           )
+    Vertex(name='V_S%sS%sGrGr' % (i_scalar, i_scalar),
+           particles=[P.scalar_particles[i_scalar],
+                      P.scalar_particles[i_scalar], P.graviton, P.graviton],
+           color=['1'],
+           lorentz=[L.SSTTmpart, L.SSTT],
+           couplings={(0, 0): getattr(
+               C, ("SSTTmpart%d" % i_scalar)), (0, 1): C.SSTT}
+           )
+    Vertex(name='V_S%sS%sGrGrGr' % (i_scalar, i_scalar),
+           particles=[P.scalar_particles[i_scalar],
+                      P.scalar_particles[i_scalar], P.graviton, P.graviton, P.graviton],
+           color=['1'],
+           lorentz=[L.SSTTTmpart, L.SSTTT],
+           couplings={(0, 0): getattr(
+               C, ("SSTTTmpart%d" % i_scalar)), (0, 1): C.SSTTT}
+           )
+
+Vertex(name='V_GrGrGr',
+       particles=[P.graviton, P.graviton, P.graviton],
+       color=['1'],
+       lorentz=[L.TTT],
+       couplings={(0, 0): C.TTT}
+       )
+
+Vertex(name='V_GrGrGrGr',
+       particles=[P.graviton, P.graviton, P.graviton, P.graviton],
+       color=['1'],
+       lorentz=[L.TTTT],
+       couplings={(0, 0): C.TTTT}
+       )
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/write_param_card.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/write_param_card.py
new file mode 100644
index 0000000000..bcf80e9955
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalar_gravity/write_param_card.py
@@ -0,0 +1,174 @@
+# type: ignore
+from __future__ import absolute_import
+from __future__ import print_function
+from six.moves import range
+
+
+class ParamCardWriter(object):
+
+    header = \
+        """######################################################################\n""" + \
+        """## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################\n""" + \
+        """######################################################################\n"""
+
+    def __init__(self, filename, list_of_parameters=None, generic=False):
+        """write a valid param_card.dat"""
+
+        if not list_of_parameters:
+            from .parameters import all_parameters
+            list_of_parameters = [param for param in all_parameters if
+                                  param.nature == 'external']
+
+        self.generic_output = generic
+        if generic:
+            self.define_not_dep_param(list_of_parameters)
+
+        self.fsock = open(filename, 'w')
+        self.fsock.write(self.header)
+
+        self.write_card(list_of_parameters)
+
+    def define_not_dep_param(self, list_of_parameters):
+        """define self.dep_mass and self.dep_width in case that they are
+        requested in the param_card.dat"""
+        from .particles import all_particles
+
+        self.dep_mass = [(part, part.mass) for part in all_particles
+                         if part.pdg_code > 0 and
+                         part.mass not in list_of_parameters]
+        self.dep_width = [(part, part.width) for part in all_particles
+                          if part.pdg_code > 0 and
+                          part.width not in list_of_parameters]
+
+    @staticmethod
+    def order_param(obj1, obj2):
+        """ order parameter of a given block """
+
+        maxlen = min([len(obj1.lhacode), len(obj2.lhacode)])
+
+        for i in range(maxlen):
+            if obj1.lhacode[i] < obj2.lhacode[i]:
+                return -1
+            elif obj1.lhacode[i] == obj2.lhacode[i]:
+                return 0
+            else:
+                return 1
+        # identical up to the first finish
+        if len(obj1.lhacode) > len(obj2.lhacode):
+            return 1
+        elif len(obj1.lhacode) == len(obj2.lhacode):
+            return 0
+        else:
+            return -1
+
+    def write_card(self, all_ext_param):
+        """ """
+
+        # list all lhablock
+        all_lhablock = set([param.lhablock for param in all_ext_param])
+
+        # ordonate lhablock alphabeticaly
+        all_lhablock = list(all_lhablock)
+        all_lhablock.sort()
+        # put at the beginning SMINPUT + MASS + DECAY
+        for name in ['DECAY', 'MASS', 'SMINPUTS']:
+            if name in all_lhablock:
+                all_lhablock.remove(name)
+                all_lhablock.insert(0, name)
+
+        for lhablock in all_lhablock:
+            self.write_block(lhablock)
+            need_writing = [param for param in all_ext_param if
+                            param.lhablock == lhablock]
+            from functools import cmp_to_key
+            need_writing.sort(key=cmp_to_key(self.order_param))
+            [self.write_param(param, lhablock) for param in need_writing]
+
+            if self.generic_output:
+                if lhablock in ['MASS', 'DECAY']:
+                    self.write_dep_param_block(lhablock)
+
+        if self.generic_output:
+            self.write_qnumber()
+
+    def write_block(self, name):
+        """ write a comment for a block"""
+
+        self.fsock.writelines(
+            """\n###################################""" +
+            """\n## INFORMATION FOR %s""" % name.upper() +
+            """\n###################################\n"""
+        )
+        if name != 'DECAY':
+            self.fsock.write("""Block %s \n""" % name)
+
+    def write_param(self, param, lhablock):
+
+        lhacode = ' '.join(['%3s' % key for key in param.lhacode])
+        if lhablock != 'DECAY':
+            text = """  %s %e # %s \n""" % (
+                lhacode, complex(param.value).real, param.name)
+        else:
+            text = '''DECAY %s %e \n''' % (lhacode, complex(param.value).real)
+        self.fsock.write(text)
+
+    def write_dep_param_block(self, lhablock):
+        import cmath
+        from .parameters import all_parameters
+        for parameter in all_parameters:
+            try:
+                exec("%s = %s" % (parameter.name, parameter.value))
+            except Exception:
+                pass
+        text = "##  Not dependent paramater.\n"
+        text += "## Those values should be edited following analytical the \n"
+        text += "## analytical expression. Some generator could simply ignore \n"
+        text += "## those values and use the analytical expression\n"
+
+        if lhablock == 'MASS':
+            data = self.dep_mass
+            prefix = " "
+        else:
+            data = self.dep_width
+            prefix = "DECAY "
+        for part, param in data:
+            if isinstance(param.value, str):
+                value = complex(eval(param.value)).real
+            else:
+                value = param.value
+
+            text += """%s %s %f # %s : %s \n""" % (prefix, part.pdg_code,
+                                                   value, part.name, param.value)
+        self.fsock.write(text)
+
+    sm_pdg = [1, 2, 3, 4, 5, 6, 11, 12, 13, 13, 14, 15, 16, 21, 22, 23, 24, 25]
+    data = """Block QNUMBERS %(pdg)d  # %(name)s
+        1 %(charge)d  # 3 times electric charge
+        2 %(spin)d  # number of spin states (2S+1)
+        3 %(color)d  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 %(antipart)d  # Particle/Antiparticle distinction (0=own anti)\n"""
+
+    def write_qnumber(self):
+        """ write qnumber """
+        from .particles import all_particles
+
+        text = """#===========================================================\n"""
+        text += """# QUANTUM NUMBERS OF NEW STATE(S) (NON SM PDG CODE)\n"""
+        text += """#===========================================================\n\n"""
+
+        for part in all_particles:
+            if part.pdg_code in self.sm_pdg or part.pdg_code < 0:
+                continue
+            text += self.data % {'pdg': part.pdg_code,
+                                 'name': part.name,
+                                 'charge': 3 * part.charge,
+                                 'spin': 2 * part.spin + 1,
+                                 'color': part.color,
+                                 'antipart': part.name != part.antiname and 1 or 0}
+
+        self.fsock.write(text)
+
+
+if '__main__' == __name__:
+    ParamCardWriter('./param_card.dat', generic=True)
+    print('write ./param_card.dat')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/__init__.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/__init__.py
new file mode 100644
index 0000000000..9a3ad6aac9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/__init__.py
@@ -0,0 +1,25 @@
+# type: ignore
+from __future__ import absolute_import
+from . import particles
+from . import couplings
+from . import lorentz
+from . import parameters
+from . import vertices
+from . import coupling_orders
+from . import function_library
+from . import object_library
+
+gauge = [0]
+
+all_particles = particles.all_particles
+all_vertices = vertices.all_vertices
+all_couplings = couplings.all_couplings
+all_lorentz = lorentz.all_lorentz
+all_parameters = parameters.all_parameters
+all_orders = coupling_orders.all_orders
+all_functions = function_library.all_functions
+
+
+__author__ = "Valentin Hirschi"
+__version__ = "1.0"
+__email__ = "valentin.hirschi@gmail.com"
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/coupling_orders.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/coupling_orders.py
new file mode 100644
index 0000000000..cb073b19ef
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/coupling_orders.py
@@ -0,0 +1,12 @@
+# type: ignore
+from __future__ import absolute_import
+from .object_library import all_orders, CouplingOrder
+
+# Keep the coupling order names QCD and QED as they are hard-coded standards in some generators
+QCD = CouplingOrder(name='QCD',
+                    expansion_order=99,
+                    hierarchy=1)
+
+QED = CouplingOrder(name='QED',
+                    expansion_order=99,
+                    hierarchy=2)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/couplings.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/couplings.py
new file mode 100644
index 0000000000..9a3f7c38b0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/couplings.py
@@ -0,0 +1,8 @@
+# type: ignore
+from __future__ import absolute_import
+from .object_library import all_couplings, Coupling
+
+
+SCALAR_COUPLING = Coupling(name='SCALAR_COUPLING',
+                           value='lam*complex(0,1)',
+                           order={'QCD': 1})
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/function_library.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/function_library.py
new file mode 100644
index 0000000000..b2843b6ca0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/function_library.py
@@ -0,0 +1,52 @@
+# type: ignore
+# This file is part of the UFO.
+#
+# This file contains definitions for functions that
+# are extensions of the cmath library, and correspond
+# either to functions that are in cmath, but inconvenient
+# to access from there (e.g. z.conjugate()),
+# or functions that are simply not defined.
+#
+#
+from __future__ import absolute_import
+__date__ = "22 July 2010"
+__author__ = "claude.duhr@durham.ac.uk"
+
+from cmath import cos, sin, acos, asin
+from .object_library import all_functions, Function
+
+#
+# shortcuts for functions from cmath
+#
+
+complexconjugate = Function(name='complexconjugate',
+                            arguments=('z',),
+                            expression='z.conjugate()')
+
+
+re = Function(name='re',
+              arguments=('z',),
+              expression='z.real')
+
+im = Function(name='im',
+              arguments=('z',),
+              expression='z.imag')
+
+
+# New functions (trigonometric)
+
+sec = Function(name='sec',
+               arguments=('z',),
+               expression='1./cos(z)')
+
+asec = Function(name='asec',
+                arguments=('z',),
+                expression='acos(1./z)')
+
+csc = Function(name='csc',
+               arguments=('z',),
+               expression='1./sin(z)')
+
+acsc = Function(name='acsc',
+                arguments=('z',),
+                expression='asin(1./z)')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/lorentz.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/lorentz.py
new file mode 100644
index 0000000000..85a4a01cac
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/lorentz.py
@@ -0,0 +1,18 @@
+# type: ignore
+from __future__ import absolute_import
+from .object_library import all_lorentz, Lorentz
+
+from .function_library import complexconjugate, re, im, csc, sec, acsc, asec
+from . import parameters as Param
+
+try:
+    import form_factors as ForFac
+except ImportError:
+    pass
+
+scalar_lorentz_structures = {}
+for n_point_interaction in Param.N_POINT_INTERACTIONS:
+    scalar_lorentz_structures[n_point_interaction] = Lorentz(name='SCALAR_%d_LORENTZ_STRUCTURE' % n_point_interaction,
+                                                             spins=[
+                                                                 1, ]*n_point_interaction,
+                                                             structure='1')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/object_library.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/object_library.py
new file mode 100644
index 0000000000..85c41db185
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/object_library.py
@@ -0,0 +1,280 @@
+# type: ignore
+##
+##
+# Feynrules Header
+##
+##
+##
+##
+##
+
+from __future__ import absolute_import
+import cmath
+
+
+class UFOBaseClass(object):
+    """The class from which all FeynRules classes are derived."""
+
+    require_args = []
+
+    def __init__(self, *args, **options):
+        assert (len(self.require_args) == len(args))
+
+        for i, name in enumerate(self.require_args):
+            setattr(self, name, args[i])
+
+        for (option, value) in options.items():
+            setattr(self, option, value)
+
+    def get(self, name):
+        return getattr(self, name)
+
+    def set(self, name, value):
+        setattr(self, name, value)
+
+    def get_all(self):
+        """Return a dictionary containing all the information of the object"""
+        return self.__dict__
+
+    def __str__(self):
+        return self.name
+
+    def nice_string(self):
+        """ return string with the full information """
+        return '\n'.join(['%s \t: %s' % (name, value) for name, value in self.__dict__.items()])
+
+    def __repr__(self):
+        replacements = [
+            ('+', '__plus__'),
+            ('-', '__minus__'),
+            ('@', '__at__'),
+            ('!', '__exclam__'),
+            ('?', '__quest__'),
+            ('*', '__star__'),
+            ('~', '__tilde__')
+        ]
+        text = self.name
+        for orig, sub in replacements:
+            text = text.replace(orig, sub)
+        return text
+
+
+all_particles = []
+
+
+class Particle(UFOBaseClass):
+    """A standard Particle"""
+
+    require_args = ['pdg_code', 'name', 'antiname', 'spin',
+                    'color', 'mass', 'width', 'texname', 'antitexname', 'charge']
+
+    require_args_all = ['pdg_code', 'name', 'antiname', 'spin', 'color', 'mass', 'width',
+                        'texname', 'antitexname', 'charge', 'line', 'propagating', 'goldstoneboson']
+
+    def __init__(self, pdg_code, name, antiname, spin, color, mass, width, texname,
+                 antitexname, charge, line=None, propagating=True, goldstoneboson=False, **options):
+
+        args = (pdg_code, name, antiname, spin, color, mass, width, texname,
+                antitexname, float(charge))
+
+        UFOBaseClass.__init__(self, *args,  **options)
+
+        global all_particles
+        all_particles.append(self)
+
+        self.propagating = propagating
+        self.goldstoneboson = goldstoneboson
+
+        self.selfconjugate = (name == antiname)
+        if 1:  # not line:
+            self.line = self.find_line_type()
+        else:
+            self.line = line
+
+    def find_line_type(self):
+        """ find how we draw a line if not defined
+        valid output: dashed/straight/wavy/curly/double/swavy/scurly
+        """
+
+        spin = self.spin
+        color = self.color
+
+        # use default
+        if spin == 1:
+            return 'dashed'
+        elif spin == 2:
+            if not self.selfconjugate:
+                return 'straight'
+            elif color == 1:
+                return 'swavy'
+            else:
+                return 'scurly'
+        elif spin == 3:
+            if color == 1:
+                return 'wavy'
+
+            else:
+                return 'curly'
+        elif spin == 5:
+            return 'double'
+        elif spin == -1:
+            return 'dotted'
+        else:
+            return 'dashed'  # not supported yet
+
+    def anti(self):
+        if self.selfconjugate:
+            raise Exception('%s has no anti particle.' % self.name)
+        outdic = {}
+        for k, v in self.__dict__.items():
+            if k not in self.require_args_all:
+                outdic[k] = -v
+        if self.color in [1, 8]:
+            newcolor = self.color
+        else:
+            newcolor = -self.color
+
+        return Particle(-self.pdg_code, self.antiname, self.name, self.spin, newcolor, self.mass, self.width,
+                        self.antitexname, self.texname, -self.charge, self.line, self.propagating, self.goldstoneboson, **outdic)
+
+
+all_parameters = []
+
+
+class Parameter(UFOBaseClass):
+
+    require_args = ['name', 'nature', 'type', 'value', 'texname']
+
+    def __init__(self, name, nature, type, value, texname, lhablock=None, lhacode=None):
+
+        args = (name, nature, type, value, texname)
+
+        UFOBaseClass.__init__(self, *args)
+
+        args = (name, nature, type, value, texname)
+
+        global all_parameters
+        all_parameters.append(self)
+
+        if (lhablock is None or lhacode is None) and nature == 'external':
+            raise Exception(
+                'Need LHA information for external parameter "%s".' % name)
+        self.lhablock = lhablock
+        self.lhacode = lhacode
+
+
+all_vertices = []
+
+
+class Vertex(UFOBaseClass):
+
+    require_args = ['name', 'particles', 'color', 'lorentz', 'couplings']
+
+    def __init__(self, name, particles, color, lorentz, couplings, **opt):
+
+        args = (name, particles, color, lorentz, couplings)
+
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        args = (particles, color, lorentz, couplings)
+
+        global all_vertices
+        all_vertices.append(self)
+
+
+all_couplings = []
+
+
+class Coupling(UFOBaseClass):
+
+    require_args = ['name', 'value', 'order']
+
+    def __init__(self, name, value, order, **opt):
+
+        args = (name, value, order)
+        UFOBaseClass.__init__(self, *args, **opt)
+        global all_couplings
+        all_couplings.append(self)
+
+
+all_lorentz = []
+
+
+class Lorentz(UFOBaseClass):
+
+    require_args = ['name', 'spins', 'structure']
+
+    def __init__(self, name, spins, structure='external', **opt):
+        args = (name, spins, structure)
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        global all_lorentz
+        all_lorentz.append(self)
+
+
+all_functions = []
+
+
+class Function(object):
+
+    def __init__(self, name, arguments, expression):
+
+        global all_functions
+        all_functions.append(self)
+
+        self.name = name
+        self.arguments = arguments
+        self.expr = expression
+
+    def __call__(self, *opt):
+
+        for i, arg in enumerate(self.arguments):
+            exec('%s = %s' % (arg, opt[i]))
+
+        return eval(self.expr)
+
+
+all_orders = []
+
+
+class CouplingOrder(object):
+
+    def __init__(self, name, expansion_order, hierarchy, perturbative_expansion=0):
+
+        global all_orders
+        all_orders.append(self)
+
+        self.name = name
+        self.expansion_order = expansion_order
+        self.hierarchy = hierarchy
+
+
+all_decays = []
+
+
+class Decay(UFOBaseClass):
+    require_args = ['particle', 'partial_widths']
+
+    def __init__(self, particle, partial_widths, **opt):
+        args = (particle, partial_widths)
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        global all_decays
+        all_decays.append(self)
+
+        # Add the information directly to the particle
+        particle.partial_widths = partial_widths
+
+
+all_form_factors = []
+
+
+class FormFactor(UFOBaseClass):
+    require_args = ['name', 'type', 'value']
+
+    def __init__(self, name, type, value, **opt):
+        args = (name, type, value)
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        global all_form_factors
+        all_form_factors.append(self)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/parameters.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/parameters.py
new file mode 100644
index 0000000000..1c02381ca0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/parameters.py
@@ -0,0 +1,93 @@
+# type: ignore
+from __future__ import absolute_import
+from .object_library import all_parameters, Parameter
+
+from .function_library import complexconjugate, re, im, csc, sec, acsc, asec
+
+# Standalone assets are immutable; model shape must not depend on host state.
+N_SCALARS = 3
+N_POINT_INTERACTIONS = [3, 4, 5, 6, 7, 8, 9, 10]
+
+# This is a default parameter object representing 0.
+ZERO = Parameter(name='ZERO',
+                 nature='internal',
+                 type='real',
+                 value='0.0',
+                 texname='0')
+
+# Introduce the scalar coupling lambda
+lam = Parameter(name='lam',
+                nature='external',
+                type='real',
+                value=1.0,
+                texname='\\lambda',
+                lhablock='SCALARS',
+                lhacode=[1337])
+
+# Assign masses and widths to the scalars
+scalar_mass_parameters = []
+scalar_width_parameters = []
+for i_scalar in range(N_SCALARS):
+    # Set the first scalar with id 0 to always be massless
+    if i_scalar == 0:
+        scalar_mass_parameters.append(ZERO)
+        scalar_width_parameters.append(ZERO)
+        continue
+    # remember that the constructor automatically adds the objects to all_parameters
+    scalar_mass_parameters.append(Parameter(name='mass_scalar_%s' % i_scalar,
+                                            nature='external',
+                                            type='real',
+                                            value=1.0*i_scalar,
+                                            texname='m_%d' % i_scalar,
+                                            lhablock='SCALARS',
+                                            lhacode=[2001+i_scalar]))
+    scalar_width_parameters.append(Parameter(name='width_scalar_%s' % i_scalar,
+                                             nature='external',
+                                             type='real',
+                                             value=0.0,
+                                             texname='w_%d' % i_scalar,
+                                             lhablock='SCALARS',
+                                             lhacode=[3001+i_scalar]))
+
+# User-defined parameters. Keep key SM parameters as their use may be hardcoded in some generators
+aEWM1 = Parameter(name='aEWM1',
+                  nature='external',
+                  type='real',
+                  value=132.50698,
+                  texname='\\text{aEWM1}',
+                  lhablock='SMINPUTS',
+                  lhacode=[1])
+
+Gf = Parameter(name='Gf',
+               nature='external',
+               type='real',
+               value=0.0000116639,
+               texname='G_f',
+               lhablock='SMINPUTS',
+               lhacode=[2])
+
+aS = Parameter(name='aS',
+               nature='external',
+               type='real',
+               value=0.118,
+               texname='\\alpha _s',
+               lhablock='SMINPUTS',
+               lhacode=[3])
+
+aEW = Parameter(name='aEW',
+                nature='internal',
+                type='real',
+                value='1/aEWM1',
+                texname='\\alpha _{\\text{EW}}')
+
+G = Parameter(name='G',
+              nature='internal',
+              type='real',
+              value='2*cmath.sqrt(aS)*cmath.sqrt(cmath.pi)',
+              texname='G')
+
+ee = Parameter(name='ee',
+               nature='internal',
+               type='real',
+               value='2*cmath.sqrt(aEW)*cmath.sqrt(cmath.pi)',
+               texname='e')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/particles.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/particles.py
new file mode 100644
index 0000000000..20399e78be
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/particles.py
@@ -0,0 +1,26 @@
+# type: ignore
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:25
+
+
+from __future__ import division
+from __future__ import absolute_import
+from .object_library import all_particles, Particle  # pylint: disable=unused-import
+from . import parameters as Param
+
+scalar_particles = []
+for i_scalar in range(Param.N_SCALARS):
+    scalar_particles.append(Particle(pdg_code=1000+i_scalar,
+                                     name='scalar_%d' % i_scalar,
+                                     antiname='scalar_%d' % i_scalar,
+                                     spin=1,
+                                     color=1,
+                                     mass=Param.scalar_mass_parameters[i_scalar],
+                                     width=Param.scalar_width_parameters[i_scalar],
+                                     texname='\\phi_%d' % i_scalar,
+                                     antitexname='\\phi_%d' % i_scalar,
+                                     charge=0,
+                                     GhostNumber=0,
+                                     LeptonNumber=0,
+                                     Y=0))
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/restrict_default.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/restrict_default.dat
new file mode 100644
index 0000000000..8d45909b65
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/restrict_default.dat
@@ -0,0 +1,45 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR SCALARS
+###################################
+Block SCALARS
+  1337 1.000000e+00 # lambda
+  2002 1.000000e+00 # mass_scalar_1
+  2003 2.000000e+00 # mass_scalar_2
+  3002 0.000000e+00 # width_scalar_1
+  3003 0.000000e+00 # width_scalar_2
+#===========================================================
+# QUANTUM NUMBERS OF NEW STATE(S) (NON SM PDG CODE)
+#===========================================================
+
+Block QNUMBERS 1000  # scalar_0
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 1001  # scalar_1
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 1002  # scalar_2
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+
+###########################################
+## MadGraph needs at least one DECAY entry
+##########################################
+DECAY  1000 0.000000e+00 # scalar_0
\ No newline at end of file
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/restrict_full.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/restrict_full.dat
new file mode 100644
index 0000000000..b206643b68
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/restrict_full.dat
@@ -0,0 +1,40 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY GAMMALOOP                   ##
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR SCALARS
+###################################
+Block SCALARS
+  1337 1.000000e+00 # lam
+  2002 1.000000e+00 # mass_scalar_1
+  2003 2.000000e+00 # mass_scalar_2
+  3002 0.000000e+00 # width_scalar_1
+  3003 0.000000e+00 # width_scalar_2
+#===========================================================
+# QUANTUM NUMBERS OF NEW STATE(S) (NON SM PDG CODE)
+#===========================================================
+
+Block QNUMBERS 1000  # scalar_0
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 1001  # scalar_1
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 1002  # scalar_2
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/run_write_param_card.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/run_write_param_card.py
new file mode 100755
index 0000000000..d87ecc25b9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/run_write_param_card.py
@@ -0,0 +1,19 @@
+# type: ignore
+#!/usr/bin/env python
+from __future__ import absolute_import
+from __future__ import print_function
+from six.moves import range
+
+import sys
+import os
+import importlib
+
+if '__main__' == __name__:
+    dir_path = os.path.join(os.path.dirname(__file__))
+    sys.path.insert(0, os.path.join(dir_path, os.path.pardir))
+    pw = importlib.import_module('%s.%s' % (
+        os.path.basename(dir_path), 'write_param_card'))
+    del sys.path[0]
+
+    pw.ParamCardWriter('./param_card.dat', generic=True)
+    print('write ./param_card.dat')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/vertices.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/vertices.py
new file mode 100644
index 0000000000..b58af0f4ce
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/vertices.py
@@ -0,0 +1,23 @@
+# type: ignore
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:25
+
+
+from __future__ import absolute_import
+from .object_library import all_vertices, Vertex
+from . import particles as P
+from . import couplings as C
+from . import lorentz as L
+from . import parameters as Param
+import itertools
+
+for n_point_interaction in Param.N_POINT_INTERACTIONS:
+    for i_inter, interaction in enumerate(sorted(list(set(tuple(sorted(inter)) for inter in itertools.product(*[list(range(Param.N_SCALARS)),]*n_point_interaction))))):
+        # Remember that the constructor automatically adds the objects to all_vertices
+        Vertex(name='V_%d_SCALAR_%s' % (n_point_interaction, ''.join('%d' % scalar_id for scalar_id in interaction)),
+               particles=[P.scalar_particles[scalar_id]
+                          for scalar_id in interaction],
+               color=['1'],
+               lorentz=[L.scalar_lorentz_structures[n_point_interaction]],
+               couplings={(0, 0): C.SCALAR_COUPLING})
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/write_param_card.py b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/write_param_card.py
new file mode 100644
index 0000000000..bcf80e9955
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/scalars/write_param_card.py
@@ -0,0 +1,174 @@
+# type: ignore
+from __future__ import absolute_import
+from __future__ import print_function
+from six.moves import range
+
+
+class ParamCardWriter(object):
+
+    header = \
+        """######################################################################\n""" + \
+        """## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################\n""" + \
+        """######################################################################\n"""
+
+    def __init__(self, filename, list_of_parameters=None, generic=False):
+        """write a valid param_card.dat"""
+
+        if not list_of_parameters:
+            from .parameters import all_parameters
+            list_of_parameters = [param for param in all_parameters if
+                                  param.nature == 'external']
+
+        self.generic_output = generic
+        if generic:
+            self.define_not_dep_param(list_of_parameters)
+
+        self.fsock = open(filename, 'w')
+        self.fsock.write(self.header)
+
+        self.write_card(list_of_parameters)
+
+    def define_not_dep_param(self, list_of_parameters):
+        """define self.dep_mass and self.dep_width in case that they are
+        requested in the param_card.dat"""
+        from .particles import all_particles
+
+        self.dep_mass = [(part, part.mass) for part in all_particles
+                         if part.pdg_code > 0 and
+                         part.mass not in list_of_parameters]
+        self.dep_width = [(part, part.width) for part in all_particles
+                          if part.pdg_code > 0 and
+                          part.width not in list_of_parameters]
+
+    @staticmethod
+    def order_param(obj1, obj2):
+        """ order parameter of a given block """
+
+        maxlen = min([len(obj1.lhacode), len(obj2.lhacode)])
+
+        for i in range(maxlen):
+            if obj1.lhacode[i] < obj2.lhacode[i]:
+                return -1
+            elif obj1.lhacode[i] == obj2.lhacode[i]:
+                return 0
+            else:
+                return 1
+        # identical up to the first finish
+        if len(obj1.lhacode) > len(obj2.lhacode):
+            return 1
+        elif len(obj1.lhacode) == len(obj2.lhacode):
+            return 0
+        else:
+            return -1
+
+    def write_card(self, all_ext_param):
+        """ """
+
+        # list all lhablock
+        all_lhablock = set([param.lhablock for param in all_ext_param])
+
+        # ordonate lhablock alphabeticaly
+        all_lhablock = list(all_lhablock)
+        all_lhablock.sort()
+        # put at the beginning SMINPUT + MASS + DECAY
+        for name in ['DECAY', 'MASS', 'SMINPUTS']:
+            if name in all_lhablock:
+                all_lhablock.remove(name)
+                all_lhablock.insert(0, name)
+
+        for lhablock in all_lhablock:
+            self.write_block(lhablock)
+            need_writing = [param for param in all_ext_param if
+                            param.lhablock == lhablock]
+            from functools import cmp_to_key
+            need_writing.sort(key=cmp_to_key(self.order_param))
+            [self.write_param(param, lhablock) for param in need_writing]
+
+            if self.generic_output:
+                if lhablock in ['MASS', 'DECAY']:
+                    self.write_dep_param_block(lhablock)
+
+        if self.generic_output:
+            self.write_qnumber()
+
+    def write_block(self, name):
+        """ write a comment for a block"""
+
+        self.fsock.writelines(
+            """\n###################################""" +
+            """\n## INFORMATION FOR %s""" % name.upper() +
+            """\n###################################\n"""
+        )
+        if name != 'DECAY':
+            self.fsock.write("""Block %s \n""" % name)
+
+    def write_param(self, param, lhablock):
+
+        lhacode = ' '.join(['%3s' % key for key in param.lhacode])
+        if lhablock != 'DECAY':
+            text = """  %s %e # %s \n""" % (
+                lhacode, complex(param.value).real, param.name)
+        else:
+            text = '''DECAY %s %e \n''' % (lhacode, complex(param.value).real)
+        self.fsock.write(text)
+
+    def write_dep_param_block(self, lhablock):
+        import cmath
+        from .parameters import all_parameters
+        for parameter in all_parameters:
+            try:
+                exec("%s = %s" % (parameter.name, parameter.value))
+            except Exception:
+                pass
+        text = "##  Not dependent paramater.\n"
+        text += "## Those values should be edited following analytical the \n"
+        text += "## analytical expression. Some generator could simply ignore \n"
+        text += "## those values and use the analytical expression\n"
+
+        if lhablock == 'MASS':
+            data = self.dep_mass
+            prefix = " "
+        else:
+            data = self.dep_width
+            prefix = "DECAY "
+        for part, param in data:
+            if isinstance(param.value, str):
+                value = complex(eval(param.value)).real
+            else:
+                value = param.value
+
+            text += """%s %s %f # %s : %s \n""" % (prefix, part.pdg_code,
+                                                   value, part.name, param.value)
+        self.fsock.write(text)
+
+    sm_pdg = [1, 2, 3, 4, 5, 6, 11, 12, 13, 13, 14, 15, 16, 21, 22, 23, 24, 25]
+    data = """Block QNUMBERS %(pdg)d  # %(name)s
+        1 %(charge)d  # 3 times electric charge
+        2 %(spin)d  # number of spin states (2S+1)
+        3 %(color)d  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 %(antipart)d  # Particle/Antiparticle distinction (0=own anti)\n"""
+
+    def write_qnumber(self):
+        """ write qnumber """
+        from .particles import all_particles
+
+        text = """#===========================================================\n"""
+        text += """# QUANTUM NUMBERS OF NEW STATE(S) (NON SM PDG CODE)\n"""
+        text += """#===========================================================\n\n"""
+
+        for part in all_particles:
+            if part.pdg_code in self.sm_pdg or part.pdg_code < 0:
+                continue
+            text += self.data % {'pdg': part.pdg_code,
+                                 'name': part.name,
+                                 'charge': 3 * part.charge,
+                                 'spin': 2 * part.spin + 1,
+                                 'color': part.color,
+                                 'antipart': part.name != part.antiname and 1 or 0}
+
+        self.fsock.write(text)
+
+
+if '__main__' == __name__:
+    ParamCardWriter('./param_card.dat', generic=True)
+    print('write ./param_card.dat')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/__init__.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/__init__.py
new file mode 100644
index 0000000000..a4b9447bca
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/__init__.py
@@ -0,0 +1,37 @@
+# type: ignore
+from __future__ import absolute_import
+from . import particles
+from . import couplings
+from . import lorentz
+from . import parameters
+from . import vertices
+from . import coupling_orders
+from . import function_library
+from . import object_library
+# from . import write_param_card
+try:
+    from . import decays
+except ImportError:
+    pass
+try:
+    from . import build_restrict
+except ImportError:
+    pass
+
+# model options
+gauge = [0, 1]
+
+
+all_particles = particles.all_particles
+all_vertices = vertices.all_vertices
+all_couplings = couplings.all_couplings
+all_lorentz = lorentz.all_lorentz
+all_parameters = parameters.all_parameters
+all_orders = coupling_orders.all_orders
+all_functions = function_library.all_functions
+# all_decays = decays.all_decays
+
+
+__author__ = "N. Christensen, C. Duhr"
+__version__ = "1.3"
+__email__ = "neil@pa.msu.edu, claude.duhr@uclouvain.be"
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/build_restrict.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/build_restrict.py
new file mode 100644
index 0000000000..838268f208
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/build_restrict.py
@@ -0,0 +1,70 @@
+# type: ignore
+################################################################################
+#
+# Copyright (c) 2012 The MadGraph5_aMC@NLO Development team and Contributors
+#
+# This file is a part of the MadGraph5_aMC@NLO project, an application which
+# automatically generates Feynman diagrams and matrix elements for arbitrary
+# high-energy processes in the Standard Model and beyond.
+#
+# It is subject to the MadGraph5_aMC@NLO license which should accompany this
+# distribution.
+#
+# For more information, visit madgraph.phys.ucl.ac.be and amcatnlo.web.cern.ch
+#
+################################################################################
+""" This part is not part of the UFO Model but only of MG5 suite.
+This files defines how the restrict card can be build automatically """
+
+### Important Warning ###
+# When you develop such file. Please cross check that they are NO
+# unwanted simplification to your model. This can happen especially
+# if a bunch of value are set to 1.0 by default. This YOUR responsability
+# to check that you get the expected behavior
+### Important Warning ###
+
+from __future__ import absolute_import
+import models.build_restriction_lib as build_restrict_lib
+all_categories = []
+
+
+first_category = build_restrict_lib.Category('sm customization')
+all_categories.append(first_category)
+
+first_category.add_options(name='diagonal ckm',  # name
+                           default=True,          # default
+                           rules=[('WOLFENSTEIN', [1], 0.0),
+                                  ('WOLFENSTEIN', [2], 0.0),
+                                  ('WOLFENSTEIN', [3], 0.0),
+                                  ('WOLFENSTEIN', [4], 0.0)]
+                           )
+
+first_category.add_options(name='c mass = 0',  # name
+                           default=True,        # default
+                           rules=[('MASS', [4], 0.0),
+                                  ('YUKAWA', [4], 0.0)]
+                           )
+
+first_category.add_options(name='b mass = 0',
+                           default=False,
+                           rules=[('MASS', [5], 0.0),
+                                  ('YUKAWA', [5], 0.0)]
+                           )
+
+first_category.add_options(name='tau mass = 0',
+                           default=False,
+                           rules=[('MASS', [15], 0.0),
+                                  ('YUKAWA', [15], 0.0)]
+                           )
+
+first_category.add_options(name='muon mass = 0',
+                           default=True,
+                           rules=[('MASS', [13], 0.0),
+                                  ('YUKAWA', [13], 0.0)]
+                           )
+
+first_category.add_options(name='electron mass = 0',
+                           default=True,
+                           rules=[('MASS', [11], 0.0),
+                                  ('YUKAWA', [11], 0.0)]
+                           )
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/coupling_orders.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/coupling_orders.py
new file mode 100644
index 0000000000..3a0bd46b64
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/coupling_orders.py
@@ -0,0 +1,17 @@
+# type: ignore
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:26
+
+
+from __future__ import absolute_import
+from .object_library import all_orders, CouplingOrder
+
+
+QCD = CouplingOrder(name='QCD',
+                    expansion_order=99,
+                    hierarchy=1)
+
+QED = CouplingOrder(name='QED',
+                    expansion_order=99,
+                    hierarchy=2)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/couplings.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/couplings.py
new file mode 100644
index 0000000000..5e3e67ffd2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/couplings.py
@@ -0,0 +1,443 @@
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:26
+
+
+from __future__ import absolute_import
+from .object_library import all_couplings, Coupling
+
+from .function_library import complexconjugate, re, im, csc, sec, acsc, asec
+
+
+
+GC_1 = Coupling(name = 'GC_1',
+                value = '-(ee*complex(0,1))/3.',
+                order = {'QED':1})
+
+GC_2 = Coupling(name = 'GC_2',
+                value = '(2*ee*complex(0,1))/3.',
+                order = {'QED':1})
+
+GC_3 = Coupling(name = 'GC_3',
+                value = '-(ee*complex(0,1))',
+                order = {'QED':1})
+
+GC_4 = Coupling(name = 'GC_4',
+                value = 'ee*complex(0,1)',
+                order = {'QED':1})
+
+GC_5 = Coupling(name = 'GC_5',
+                value = 'ee**2*complex(0,1)',
+                order = {'QED':2})
+
+GC_6 = Coupling(name = 'GC_6',
+                value = '2*ee**2*complex(0,1)',
+                order = {'QED':2})
+
+GC_7 = Coupling(name = 'GC_7',
+                value = '-ee**2/(2.*cw)',
+                order = {'QED':2})
+
+GC_8 = Coupling(name = 'GC_8',
+                value = '(ee**2*complex(0,1))/(2.*cw)',
+                order = {'QED':2})
+
+GC_9 = Coupling(name = 'GC_9',
+                value = 'ee**2/(2.*cw)',
+                order = {'QED':2})
+
+GC_10 = Coupling(name = 'GC_10',
+                 value = '-G',
+                 order = {'QCD':1})
+
+GC_11 = Coupling(name = 'GC_11',
+                 value = 'complex(0,1)*G',
+                 order = {'QCD':1})
+
+GC_12 = Coupling(name = 'GC_12',
+                 value = 'complex(0,1)*G**2',
+                 order = {'QCD':2})
+
+GC_13 = Coupling(name = 'GC_13',
+                 value = 'I1x31',
+                 order = {'QED':1})
+
+GC_14 = Coupling(name = 'GC_14',
+                 value = 'I1x32',
+                 order = {'QED':1})
+
+GC_15 = Coupling(name = 'GC_15',
+                 value = 'I1x33',
+                 order = {'QED':1})
+
+GC_16 = Coupling(name = 'GC_16',
+                 value = '-I2x12',
+                 order = {'QED':1})
+
+GC_17 = Coupling(name = 'GC_17',
+                 value = '-I2x13',
+                 order = {'QED':1})
+
+GC_18 = Coupling(name = 'GC_18',
+                 value = '-I2x22',
+                 order = {'QED':1})
+
+GC_19 = Coupling(name = 'GC_19',
+                 value = '-I2x23',
+                 order = {'QED':1})
+
+GC_20 = Coupling(name = 'GC_20',
+                 value = '-I2x32',
+                 order = {'QED':1})
+
+GC_21 = Coupling(name = 'GC_21',
+                 value = '-I2x33',
+                 order = {'QED':1})
+
+GC_22 = Coupling(name = 'GC_22',
+                 value = 'I3x21',
+                 order = {'QED':1})
+
+GC_23 = Coupling(name = 'GC_23',
+                 value = 'I3x22',
+                 order = {'QED':1})
+
+GC_24 = Coupling(name = 'GC_24',
+                 value = 'I3x23',
+                 order = {'QED':1})
+
+GC_25 = Coupling(name = 'GC_25',
+                 value = 'I3x31',
+                 order = {'QED':1})
+
+GC_26 = Coupling(name = 'GC_26',
+                 value = 'I3x32',
+                 order = {'QED':1})
+
+GC_27 = Coupling(name = 'GC_27',
+                 value = 'I3x33',
+                 order = {'QED':1})
+
+GC_28 = Coupling(name = 'GC_28',
+                 value = '-I4x13',
+                 order = {'QED':1})
+
+GC_29 = Coupling(name = 'GC_29',
+                 value = '-I4x23',
+                 order = {'QED':1})
+
+GC_30 = Coupling(name = 'GC_30',
+                 value = '-I4x33',
+                 order = {'QED':1})
+
+GC_31 = Coupling(name = 'GC_31',
+                 value = '-2*complex(0,1)*lam',
+                 order = {'QED':2})
+
+GC_32 = Coupling(name = 'GC_32',
+                 value = '-4*complex(0,1)*lam',
+                 order = {'QED':2})
+
+GC_33 = Coupling(name = 'GC_33',
+                 value = '-6*complex(0,1)*lam',
+                 order = {'QED':2})
+
+GC_34 = Coupling(name = 'GC_34',
+                 value = '(ee**2*complex(0,1))/(2.*sw**2)',
+                 order = {'QED':2})
+
+GC_35 = Coupling(name = 'GC_35',
+                 value = '-((ee**2*complex(0,1))/sw**2)',
+                 order = {'QED':2})
+
+GC_36 = Coupling(name = 'GC_36',
+                 value = '(cw**2*ee**2*complex(0,1))/sw**2',
+                 order = {'QED':2})
+
+GC_37 = Coupling(name = 'GC_37',
+                 value = '-ee/(2.*sw)',
+                 order = {'QED':1})
+
+GC_38 = Coupling(name = 'GC_38',
+                 value = '-(ee*complex(0,1))/(2.*sw)',
+                 order = {'QED':1})
+
+GC_39 = Coupling(name = 'GC_39',
+                 value = '(ee*complex(0,1))/(2.*sw)',
+                 order = {'QED':1})
+
+GC_40 = Coupling(name = 'GC_40',
+                 value = '(ee*complex(0,1))/(sw*cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_41 = Coupling(name = 'GC_41',
+                 value = '(CKM1x1*ee*complex(0,1))/(sw*cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_42 = Coupling(name = 'GC_42',
+                 value = '(CKM1x2*ee*complex(0,1))/(sw*cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_43 = Coupling(name = 'GC_43',
+                 value = '(CKM1x3*ee*complex(0,1))/(sw*cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_44 = Coupling(name = 'GC_44',
+                 value = '(CKM2x1*ee*complex(0,1))/(sw*cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_45 = Coupling(name = 'GC_45',
+                 value = '(CKM2x2*ee*complex(0,1))/(sw*cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_46 = Coupling(name = 'GC_46',
+                 value = '(CKM2x3*ee*complex(0,1))/(sw*cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_47 = Coupling(name = 'GC_47',
+                 value = '(CKM3x1*ee*complex(0,1))/(sw*cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_48 = Coupling(name = 'GC_48',
+                 value = '(CKM3x2*ee*complex(0,1))/(sw*cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_49 = Coupling(name = 'GC_49',
+                 value = '(CKM3x3*ee*complex(0,1))/(sw*cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_50 = Coupling(name = 'GC_50',
+                 value = '-(cw*ee*complex(0,1))/(2.*sw)',
+                 order = {'QED':1})
+
+GC_51 = Coupling(name = 'GC_51',
+                 value = '(cw*ee*complex(0,1))/(2.*sw)',
+                 order = {'QED':1})
+
+GC_52 = Coupling(name = 'GC_52',
+                 value = '-((cw*ee*complex(0,1))/sw)',
+                 order = {'QED':1})
+
+GC_53 = Coupling(name = 'GC_53',
+                 value = '(cw*ee*complex(0,1))/sw',
+                 order = {'QED':1})
+
+GC_54 = Coupling(name = 'GC_54',
+                 value = '-ee**2/(2.*sw)',
+                 order = {'QED':2})
+
+GC_55 = Coupling(name = 'GC_55',
+                 value = '-(ee**2*complex(0,1))/(2.*sw)',
+                 order = {'QED':2})
+
+GC_56 = Coupling(name = 'GC_56',
+                 value = 'ee**2/(2.*sw)',
+                 order = {'QED':2})
+
+GC_57 = Coupling(name = 'GC_57',
+                 value = '(-2*cw*ee**2*complex(0,1))/sw',
+                 order = {'QED':2})
+
+GC_58 = Coupling(name = 'GC_58',
+                 value = '-(ee*complex(0,1)*sw)/(6.*cw)',
+                 order = {'QED':1})
+
+GC_59 = Coupling(name = 'GC_59',
+                 value = '(ee*complex(0,1)*sw)/(2.*cw)',
+                 order = {'QED':1})
+
+GC_60 = Coupling(name = 'GC_60',
+                 value = '-(cw*ee)/(2.*sw) - (ee*sw)/(2.*cw)',
+                 order = {'QED':1})
+
+GC_61 = Coupling(name = 'GC_61',
+                 value = '-(cw*ee*complex(0,1))/(2.*sw) + (ee*complex(0,1)*sw)/(2.*cw)',
+                 order = {'QED':1})
+
+GC_62 = Coupling(name = 'GC_62',
+                 value = '(cw*ee*complex(0,1))/(2.*sw) + (ee*complex(0,1)*sw)/(2.*cw)',
+                 order = {'QED':1})
+
+GC_63 = Coupling(name = 'GC_63',
+                 value = '(cw*ee**2*complex(0,1))/sw - (ee**2*complex(0,1)*sw)/cw',
+                 order = {'QED':2})
+
+GC_64 = Coupling(name = 'GC_64',
+                 value = '-(ee**2*complex(0,1)) + (cw**2*ee**2*complex(0,1))/(2.*sw**2) + (ee**2*complex(0,1)*sw**2)/(2.*cw**2)',
+                 order = {'QED':2})
+
+GC_65 = Coupling(name = 'GC_65',
+                 value = 'ee**2*complex(0,1) + (cw**2*ee**2*complex(0,1))/(2.*sw**2) + (ee**2*complex(0,1)*sw**2)/(2.*cw**2)',
+                 order = {'QED':2})
+
+GC_66 = Coupling(name = 'GC_66',
+                 value = '-(ee**2*vev)/(2.*cw)',
+                 order = {'QED':1})
+
+GC_67 = Coupling(name = 'GC_67',
+                 value = '(ee**2*vev)/(2.*cw)',
+                 order = {'QED':1})
+
+GC_68 = Coupling(name = 'GC_68',
+                 value = '-2*complex(0,1)*lam*vev',
+                 order = {'QED':1})
+
+GC_69 = Coupling(name = 'GC_69',
+                 value = '-6*complex(0,1)*lam*vev',
+                 order = {'QED':1})
+
+GC_70 = Coupling(name = 'GC_70',
+                 value = '-(ee**2*vev)/(4.*sw**2)',
+                 order = {'QED':1})
+
+GC_71 = Coupling(name = 'GC_71',
+                 value = '-(ee**2*complex(0,1)*vev)/(4.*sw**2)',
+                 order = {'QED':1})
+
+GC_72 = Coupling(name = 'GC_72',
+                 value = '(ee**2*complex(0,1)*vev)/(2.*sw**2)',
+                 order = {'QED':1})
+
+GC_73 = Coupling(name = 'GC_73',
+                 value = '(ee**2*vev)/(4.*sw**2)',
+                 order = {'QED':1})
+
+GC_74 = Coupling(name = 'GC_74',
+                 value = '-(ee**2*vev)/(2.*sw)',
+                 order = {'QED':1})
+
+GC_75 = Coupling(name = 'GC_75',
+                 value = '(ee**2*vev)/(2.*sw)',
+                 order = {'QED':1})
+
+GC_76 = Coupling(name = 'GC_76',
+                 value = '-(ee**2*vev)/(4.*cw) - (cw*ee**2*vev)/(4.*sw**2)',
+                 order = {'QED':1})
+
+GC_77 = Coupling(name = 'GC_77',
+                 value = '(ee**2*vev)/(4.*cw) - (cw*ee**2*vev)/(4.*sw**2)',
+                 order = {'QED':1})
+
+GC_78 = Coupling(name = 'GC_78',
+                 value = '-(ee**2*vev)/(4.*cw) + (cw*ee**2*vev)/(4.*sw**2)',
+                 order = {'QED':1})
+
+GC_79 = Coupling(name = 'GC_79',
+                 value = '(ee**2*vev)/(4.*cw) + (cw*ee**2*vev)/(4.*sw**2)',
+                 order = {'QED':1})
+
+GC_80 = Coupling(name = 'GC_80',
+                 value = '-(ee**2*complex(0,1)*vev)/2. - (cw**2*ee**2*complex(0,1)*vev)/(4.*sw**2) - (ee**2*complex(0,1)*sw**2*vev)/(4.*cw**2)',
+                 order = {'QED':1})
+
+GC_81 = Coupling(name = 'GC_81',
+                 value = 'ee**2*complex(0,1)*vev + (cw**2*ee**2*complex(0,1)*vev)/(2.*sw**2) + (ee**2*complex(0,1)*sw**2*vev)/(2.*cw**2)',
+                 order = {'QED':1})
+
+GC_82 = Coupling(name = 'GC_82',
+                 value = '-(yb/cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_83 = Coupling(name = 'GC_83',
+                 value = '-((complex(0,1)*yb)/cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_84 = Coupling(name = 'GC_84',
+                 value = '-((complex(0,1)*yc)/cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_85 = Coupling(name = 'GC_85',
+                 value = 'yc/cmath.sqrt(2)',
+                 order = {'QED':1})
+
+GC_86 = Coupling(name = 'GC_86',
+                 value = '-ye',
+                 order = {'QED':1})
+
+GC_87 = Coupling(name = 'GC_87',
+                 value = 'ye',
+                 order = {'QED':1})
+
+GC_88 = Coupling(name = 'GC_88',
+                 value = '-(ye/cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_89 = Coupling(name = 'GC_89',
+                 value = '-((complex(0,1)*ye)/cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_90 = Coupling(name = 'GC_90',
+                 value = '-ym',
+                 order = {'QED':1})
+
+GC_91 = Coupling(name = 'GC_91',
+                 value = 'ym',
+                 order = {'QED':1})
+
+GC_92 = Coupling(name = 'GC_92',
+                 value = '-(ym/cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_93 = Coupling(name = 'GC_93',
+                 value = '-((complex(0,1)*ym)/cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_94 = Coupling(name = 'GC_94',
+                 value = '-((complex(0,1)*yt)/cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_95 = Coupling(name = 'GC_95',
+                 value = 'yt/cmath.sqrt(2)',
+                 order = {'QED':1})
+
+GC_96 = Coupling(name = 'GC_96',
+                 value = '-ytau',
+                 order = {'QED':1})
+
+GC_97 = Coupling(name = 'GC_97',
+                 value = 'ytau',
+                 order = {'QED':1})
+
+GC_98 = Coupling(name = 'GC_98',
+                 value = '-(ytau/cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_99 = Coupling(name = 'GC_99',
+                 value = '-((complex(0,1)*ytau)/cmath.sqrt(2))',
+                 order = {'QED':1})
+
+GC_100 = Coupling(name = 'GC_100',
+                  value = '(ee*complex(0,1)*complexconjugate(CKM1x1))/(sw*cmath.sqrt(2))',
+                  order = {'QED':1})
+
+GC_101 = Coupling(name = 'GC_101',
+                  value = '(ee*complex(0,1)*complexconjugate(CKM1x2))/(sw*cmath.sqrt(2))',
+                  order = {'QED':1})
+
+GC_102 = Coupling(name = 'GC_102',
+                  value = '(ee*complex(0,1)*complexconjugate(CKM1x3))/(sw*cmath.sqrt(2))',
+                  order = {'QED':1})
+
+GC_103 = Coupling(name = 'GC_103',
+                  value = '(ee*complex(0,1)*complexconjugate(CKM2x1))/(sw*cmath.sqrt(2))',
+                  order = {'QED':1})
+
+GC_104 = Coupling(name = 'GC_104',
+                  value = '(ee*complex(0,1)*complexconjugate(CKM2x2))/(sw*cmath.sqrt(2))',
+                  order = {'QED':1})
+
+GC_105 = Coupling(name = 'GC_105',
+                  value = '(ee*complex(0,1)*complexconjugate(CKM2x3))/(sw*cmath.sqrt(2))',
+                  order = {'QED':1})
+
+GC_106 = Coupling(name = 'GC_106',
+                  value = '(ee*complex(0,1)*complexconjugate(CKM3x1))/(sw*cmath.sqrt(2))',
+                  order = {'QED':1})
+
+GC_107 = Coupling(name = 'GC_107',
+                  value = '(ee*complex(0,1)*complexconjugate(CKM3x2))/(sw*cmath.sqrt(2))',
+                  order = {'QED':1})
+
+GC_108 = Coupling(name = 'GC_108',
+                  value = '(ee*complex(0,1)*complexconjugate(CKM3x3))/(sw*cmath.sqrt(2))',
+                  order = {'QED':1})
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/decays.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/decays.py
new file mode 100644
index 0000000000..23af667e4c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/decays.py
@@ -0,0 +1,81 @@
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:26
+
+
+from __future__ import absolute_import
+from .object_library import all_decays, Decay
+from . import particles as P
+
+
+Decay_H = Decay(name = 'Decay_H',
+                particle = P.H,
+                partial_widths = {(P.W__minus__,P.W__plus__):'(((3*ee**4*vev**2)/(4.*sw**4) + (ee**4*MH**4*vev**2)/(16.*MW**4*sw**4) - (ee**4*MH**2*vev**2)/(4.*MW**2*sw**4))*cmath.sqrt(MH**4 - 4*MH**2*MW**2))/(16.*cmath.pi*abs(MH)**3)',
+                                  (P.Z,P.Z):'(((9*ee**4*vev**2)/2. + (3*ee**4*MH**4*vev**2)/(8.*MZ**4) - (3*ee**4*MH**2*vev**2)/(2.*MZ**2) + (3*cw**4*ee**4*vev**2)/(4.*sw**4) + (cw**4*ee**4*MH**4*vev**2)/(16.*MZ**4*sw**4) - (cw**4*ee**4*MH**2*vev**2)/(4.*MZ**2*sw**4) + (3*cw**2*ee**4*vev**2)/sw**2 + (cw**2*ee**4*MH**4*vev**2)/(4.*MZ**4*sw**2) - (cw**2*ee**4*MH**2*vev**2)/(MZ**2*sw**2) + (3*ee**4*sw**2*vev**2)/cw**2 + (ee**4*MH**4*sw**2*vev**2)/(4.*cw**2*MZ**4) - (ee**4*MH**2*sw**2*vev**2)/(cw**2*MZ**2) + (3*ee**4*sw**4*vev**2)/(4.*cw**4) + (ee**4*MH**4*sw**4*vev**2)/(16.*cw**4*MZ**4) - (ee**4*MH**2*sw**4*vev**2)/(4.*cw**4*MZ**2))*cmath.sqrt(MH**4 - 4*MH**2*MZ**2))/(32.*cmath.pi*abs(MH)**3)',
+                                  (P.b,P.b__tilde__):'((-12*MB**2*yb**2 + 3*MH**2*yb**2)*cmath.sqrt(-4*MB**2*MH**2 + MH**4))/(16.*cmath.pi*abs(MH)**3)',
+                                  (P.e__minus__,P.e__plus__):'((-4*Me**2*ye**2 + MH**2*ye**2)*cmath.sqrt(-4*Me**2*MH**2 + MH**4))/(16.*cmath.pi*abs(MH)**3)',
+                                  (P.mu__minus__,P.mu__plus__):'((MH**2*ym**2 - 4*MM**2*ym**2)*cmath.sqrt(MH**4 - 4*MH**2*MM**2))/(16.*cmath.pi*abs(MH)**3)',
+                                  (P.ta__minus__,P.ta__plus__):'((MH**2*ytau**2 - 4*MTA**2*ytau**2)*cmath.sqrt(MH**4 - 4*MH**2*MTA**2))/(16.*cmath.pi*abs(MH)**3)',
+                                  (P.c,P.c__tilde__):'((-12*MC**2*yc**2 + 3*MH**2*yc**2)*cmath.sqrt(-4*MC**2*MH**2 + MH**4))/(16.*cmath.pi*abs(MH)**3)',
+                                  (P.t,P.t__tilde__):'((3*MH**2*yt**2 - 12*MT**2*yt**2)*cmath.sqrt(MH**4 - 4*MH**2*MT**2))/(16.*cmath.pi*abs(MH)**3)'})
+
+Decay_Z = Decay(name = 'Decay_Z',
+                particle = P.Z,
+                partial_widths = {(P.W__minus__,P.W__plus__):'(((-12*cw**2*ee**2*MW**2)/sw**2 - (17*cw**2*ee**2*MZ**2)/sw**2 + (4*cw**2*ee**2*MZ**4)/(MW**2*sw**2) + (cw**2*ee**2*MZ**6)/(4.*MW**4*sw**2))*cmath.sqrt(-4*MW**2*MZ**2 + MZ**4))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.d,P.d__tilde__):'(MZ**2*(ee**2*MZ**2 + (3*cw**2*ee**2*MZ**2)/(2.*sw**2) + (5*ee**2*MZ**2*sw**2)/(6.*cw**2)))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.s,P.s__tilde__):'(MZ**2*(ee**2*MZ**2 + (3*cw**2*ee**2*MZ**2)/(2.*sw**2) + (5*ee**2*MZ**2*sw**2)/(6.*cw**2)))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.b,P.b__tilde__):'((-7*ee**2*MB**2 + ee**2*MZ**2 - (3*cw**2*ee**2*MB**2)/(2.*sw**2) + (3*cw**2*ee**2*MZ**2)/(2.*sw**2) - (17*ee**2*MB**2*sw**2)/(6.*cw**2) + (5*ee**2*MZ**2*sw**2)/(6.*cw**2))*cmath.sqrt(-4*MB**2*MZ**2 + MZ**4))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.e__minus__,P.e__plus__):'((-5*ee**2*Me**2 - ee**2*MZ**2 - (cw**2*ee**2*Me**2)/(2.*sw**2) + (cw**2*ee**2*MZ**2)/(2.*sw**2) + (7*ee**2*Me**2*sw**2)/(2.*cw**2) + (5*ee**2*MZ**2*sw**2)/(2.*cw**2))*cmath.sqrt(-4*Me**2*MZ**2 + MZ**4))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.mu__minus__,P.mu__plus__):'((-5*ee**2*MM**2 - ee**2*MZ**2 - (cw**2*ee**2*MM**2)/(2.*sw**2) + (cw**2*ee**2*MZ**2)/(2.*sw**2) + (7*ee**2*MM**2*sw**2)/(2.*cw**2) + (5*ee**2*MZ**2*sw**2)/(2.*cw**2))*cmath.sqrt(-4*MM**2*MZ**2 + MZ**4))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.ta__minus__,P.ta__plus__):'((-5*ee**2*MTA**2 - ee**2*MZ**2 - (cw**2*ee**2*MTA**2)/(2.*sw**2) + (cw**2*ee**2*MZ**2)/(2.*sw**2) + (7*ee**2*MTA**2*sw**2)/(2.*cw**2) + (5*ee**2*MZ**2*sw**2)/(2.*cw**2))*cmath.sqrt(-4*MTA**2*MZ**2 + MZ**4))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.u,P.u__tilde__):'(MZ**2*(-(ee**2*MZ**2) + (3*cw**2*ee**2*MZ**2)/(2.*sw**2) + (17*ee**2*MZ**2*sw**2)/(6.*cw**2)))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.c,P.c__tilde__):'((-11*ee**2*MC**2 - ee**2*MZ**2 - (3*cw**2*ee**2*MC**2)/(2.*sw**2) + (3*cw**2*ee**2*MZ**2)/(2.*sw**2) + (7*ee**2*MC**2*sw**2)/(6.*cw**2) + (17*ee**2*MZ**2*sw**2)/(6.*cw**2))*cmath.sqrt(-4*MC**2*MZ**2 + MZ**4))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.t,P.t__tilde__):'((-11*ee**2*MT**2 - ee**2*MZ**2 - (3*cw**2*ee**2*MT**2)/(2.*sw**2) + (3*cw**2*ee**2*MZ**2)/(2.*sw**2) + (7*ee**2*MT**2*sw**2)/(6.*cw**2) + (17*ee**2*MZ**2*sw**2)/(6.*cw**2))*cmath.sqrt(-4*MT**2*MZ**2 + MZ**4))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.ve,P.ve__tilde__):'(MZ**2*(ee**2*MZ**2 + (cw**2*ee**2*MZ**2)/(2.*sw**2) + (ee**2*MZ**2*sw**2)/(2.*cw**2)))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.vm,P.vm__tilde__):'(MZ**2*(ee**2*MZ**2 + (cw**2*ee**2*MZ**2)/(2.*sw**2) + (ee**2*MZ**2*sw**2)/(2.*cw**2)))/(48.*cmath.pi*abs(MZ)**3)',
+                                  (P.vt,P.vt__tilde__):'(MZ**2*(ee**2*MZ**2 + (cw**2*ee**2*MZ**2)/(2.*sw**2) + (ee**2*MZ**2*sw**2)/(2.*cw**2)))/(48.*cmath.pi*abs(MZ)**3)'})
+
+Decay_c = Decay(name = 'Decay_c',
+                particle = P.c,
+                partial_widths = {(P.W__plus__,P.d):'((MC**2 - MW**2)*((3*CKM2x1*ee**2*MC**2*complexconjugate(CKM2x1))/(2.*sw**2) + (3*CKM2x1*ee**2*MC**4*complexconjugate(CKM2x1))/(2.*MW**2*sw**2) - (3*CKM2x1*ee**2*MW**2*complexconjugate(CKM2x1))/sw**2))/(96.*cmath.pi*abs(MC)**3)',
+                                  (P.W__plus__,P.s):'((MC**2 - MW**2)*((3*CKM2x2*ee**2*MC**2*complexconjugate(CKM2x2))/(2.*sw**2) + (3*CKM2x2*ee**2*MC**4*complexconjugate(CKM2x2))/(2.*MW**2*sw**2) - (3*CKM2x2*ee**2*MW**2*complexconjugate(CKM2x2))/sw**2))/(96.*cmath.pi*abs(MC)**3)',
+                                  (P.W__plus__,P.b):'(((3*CKM2x3*ee**2*MB**2*complexconjugate(CKM2x3))/(2.*sw**2) + (3*CKM2x3*ee**2*MC**2*complexconjugate(CKM2x3))/(2.*sw**2) + (3*CKM2x3*ee**2*MB**4*complexconjugate(CKM2x3))/(2.*MW**2*sw**2) - (3*CKM2x3*ee**2*MB**2*MC**2*complexconjugate(CKM2x3))/(MW**2*sw**2) + (3*CKM2x3*ee**2*MC**4*complexconjugate(CKM2x3))/(2.*MW**2*sw**2) - (3*CKM2x3*ee**2*MW**2*complexconjugate(CKM2x3))/sw**2)*cmath.sqrt(MB**4 - 2*MB**2*MC**2 + MC**4 - 2*MB**2*MW**2 - 2*MC**2*MW**2 + MW**4))/(96.*cmath.pi*abs(MC)**3)'})
+
+Decay_t = Decay(name = 'Decay_t',
+                particle = P.t,
+                partial_widths = {(P.W__plus__,P.d):'((MT**2 - MW**2)*((3*CKM3x1*ee**2*MT**2*complexconjugate(CKM3x1))/(2.*sw**2) + (3*CKM3x1*ee**2*MT**4*complexconjugate(CKM3x1))/(2.*MW**2*sw**2) - (3*CKM3x1*ee**2*MW**2*complexconjugate(CKM3x1))/sw**2))/(96.*cmath.pi*abs(MT)**3)',
+                                  (P.W__plus__,P.s):'((MT**2 - MW**2)*((3*CKM3x2*ee**2*MT**2*complexconjugate(CKM3x2))/(2.*sw**2) + (3*CKM3x2*ee**2*MT**4*complexconjugate(CKM3x2))/(2.*MW**2*sw**2) - (3*CKM3x2*ee**2*MW**2*complexconjugate(CKM3x2))/sw**2))/(96.*cmath.pi*abs(MT)**3)',
+                                  (P.W__plus__,P.b):'(((3*CKM3x3*ee**2*MB**2*complexconjugate(CKM3x3))/(2.*sw**2) + (3*CKM3x3*ee**2*MT**2*complexconjugate(CKM3x3))/(2.*sw**2) + (3*CKM3x3*ee**2*MB**4*complexconjugate(CKM3x3))/(2.*MW**2*sw**2) - (3*CKM3x3*ee**2*MB**2*MT**2*complexconjugate(CKM3x3))/(MW**2*sw**2) + (3*CKM3x3*ee**2*MT**4*complexconjugate(CKM3x3))/(2.*MW**2*sw**2) - (3*CKM3x3*ee**2*MW**2*complexconjugate(CKM3x3))/sw**2)*cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4))/(96.*cmath.pi*abs(MT)**3)'})
+
+Decay_W__plus__ = Decay(name = 'Decay_W__plus__',
+                        particle = P.W__plus__,
+                        partial_widths = {(P.u,P.d__tilde__):'(CKM1x1*ee**2*MW**4*complexconjugate(CKM1x1))/(16.*cmath.pi*sw**2*abs(MW)**3)',
+                                          (P.u,P.s__tilde__):'(CKM1x2*ee**2*MW**4*complexconjugate(CKM1x2))/(16.*cmath.pi*sw**2*abs(MW)**3)',
+                                          (P.u,P.b__tilde__):'((-MB**2 + MW**2)*((-3*CKM1x3*ee**2*MB**2*complexconjugate(CKM1x3))/(2.*sw**2) - (3*CKM1x3*ee**2*MB**4*complexconjugate(CKM1x3))/(2.*MW**2*sw**2) + (3*CKM1x3*ee**2*MW**2*complexconjugate(CKM1x3))/sw**2))/(48.*cmath.pi*abs(MW)**3)',
+                                          (P.c,P.d__tilde__):'((-MC**2 + MW**2)*((-3*CKM2x1*ee**2*MC**2*complexconjugate(CKM2x1))/(2.*sw**2) - (3*CKM2x1*ee**2*MC**4*complexconjugate(CKM2x1))/(2.*MW**2*sw**2) + (3*CKM2x1*ee**2*MW**2*complexconjugate(CKM2x1))/sw**2))/(48.*cmath.pi*abs(MW)**3)',
+                                          (P.c,P.s__tilde__):'((-MC**2 + MW**2)*((-3*CKM2x2*ee**2*MC**2*complexconjugate(CKM2x2))/(2.*sw**2) - (3*CKM2x2*ee**2*MC**4*complexconjugate(CKM2x2))/(2.*MW**2*sw**2) + (3*CKM2x2*ee**2*MW**2*complexconjugate(CKM2x2))/sw**2))/(48.*cmath.pi*abs(MW)**3)',
+                                          (P.c,P.b__tilde__):'(((-3*CKM2x3*ee**2*MB**2*complexconjugate(CKM2x3))/(2.*sw**2) - (3*CKM2x3*ee**2*MC**2*complexconjugate(CKM2x3))/(2.*sw**2) - (3*CKM2x3*ee**2*MB**4*complexconjugate(CKM2x3))/(2.*MW**2*sw**2) + (3*CKM2x3*ee**2*MB**2*MC**2*complexconjugate(CKM2x3))/(MW**2*sw**2) - (3*CKM2x3*ee**2*MC**4*complexconjugate(CKM2x3))/(2.*MW**2*sw**2) + (3*CKM2x3*ee**2*MW**2*complexconjugate(CKM2x3))/sw**2)*cmath.sqrt(MB**4 - 2*MB**2*MC**2 + MC**4 - 2*MB**2*MW**2 - 2*MC**2*MW**2 + MW**4))/(48.*cmath.pi*abs(MW)**3)',
+                                          (P.t,P.d__tilde__):'((-MT**2 + MW**2)*((-3*CKM3x1*ee**2*MT**2*complexconjugate(CKM3x1))/(2.*sw**2) - (3*CKM3x1*ee**2*MT**4*complexconjugate(CKM3x1))/(2.*MW**2*sw**2) + (3*CKM3x1*ee**2*MW**2*complexconjugate(CKM3x1))/sw**2))/(48.*cmath.pi*abs(MW)**3)',
+                                          (P.t,P.s__tilde__):'((-MT**2 + MW**2)*((-3*CKM3x2*ee**2*MT**2*complexconjugate(CKM3x2))/(2.*sw**2) - (3*CKM3x2*ee**2*MT**4*complexconjugate(CKM3x2))/(2.*MW**2*sw**2) + (3*CKM3x2*ee**2*MW**2*complexconjugate(CKM3x2))/sw**2))/(48.*cmath.pi*abs(MW)**3)',
+                                          (P.t,P.b__tilde__):'(((-3*CKM3x3*ee**2*MB**2*complexconjugate(CKM3x3))/(2.*sw**2) - (3*CKM3x3*ee**2*MT**2*complexconjugate(CKM3x3))/(2.*sw**2) - (3*CKM3x3*ee**2*MB**4*complexconjugate(CKM3x3))/(2.*MW**2*sw**2) + (3*CKM3x3*ee**2*MB**2*MT**2*complexconjugate(CKM3x3))/(MW**2*sw**2) - (3*CKM3x3*ee**2*MT**4*complexconjugate(CKM3x3))/(2.*MW**2*sw**2) + (3*CKM3x3*ee**2*MW**2*complexconjugate(CKM3x3))/sw**2)*cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4))/(48.*cmath.pi*abs(MW)**3)',
+                                          (P.ve,P.e__plus__):'((-Me**2 + MW**2)*(-(ee**2*Me**2)/(2.*sw**2) - (ee**2*Me**4)/(2.*MW**2*sw**2) + (ee**2*MW**2)/sw**2))/(48.*cmath.pi*abs(MW)**3)',
+                                          (P.vm,P.mu__plus__):'((-MM**2 + MW**2)*(-(ee**2*MM**2)/(2.*sw**2) - (ee**2*MM**4)/(2.*MW**2*sw**2) + (ee**2*MW**2)/sw**2))/(48.*cmath.pi*abs(MW)**3)',
+                                          (P.vt,P.ta__plus__):'((-MTA**2 + MW**2)*(-(ee**2*MTA**2)/(2.*sw**2) - (ee**2*MTA**4)/(2.*MW**2*sw**2) + (ee**2*MW**2)/sw**2))/(48.*cmath.pi*abs(MW)**3)'})
+
+Decay_b = Decay(name = 'Decay_b',
+                particle = P.b,
+                partial_widths = {(P.W__minus__,P.u):'((MB**2 - MW**2)*((3*CKM1x3*ee**2*MB**2*complexconjugate(CKM1x3))/(2.*sw**2) + (3*CKM1x3*ee**2*MB**4*complexconjugate(CKM1x3))/(2.*MW**2*sw**2) - (3*CKM1x3*ee**2*MW**2*complexconjugate(CKM1x3))/sw**2))/(96.*cmath.pi*abs(MB)**3)',
+                                  (P.W__minus__,P.c):'(((3*CKM2x3*ee**2*MB**2*complexconjugate(CKM2x3))/(2.*sw**2) + (3*CKM2x3*ee**2*MC**2*complexconjugate(CKM2x3))/(2.*sw**2) + (3*CKM2x3*ee**2*MB**4*complexconjugate(CKM2x3))/(2.*MW**2*sw**2) - (3*CKM2x3*ee**2*MB**2*MC**2*complexconjugate(CKM2x3))/(MW**2*sw**2) + (3*CKM2x3*ee**2*MC**4*complexconjugate(CKM2x3))/(2.*MW**2*sw**2) - (3*CKM2x3*ee**2*MW**2*complexconjugate(CKM2x3))/sw**2)*cmath.sqrt(MB**4 - 2*MB**2*MC**2 + MC**4 - 2*MB**2*MW**2 - 2*MC**2*MW**2 + MW**4))/(96.*cmath.pi*abs(MB)**3)',
+                                  (P.W__minus__,P.t):'(((3*CKM3x3*ee**2*MB**2*complexconjugate(CKM3x3))/(2.*sw**2) + (3*CKM3x3*ee**2*MT**2*complexconjugate(CKM3x3))/(2.*sw**2) + (3*CKM3x3*ee**2*MB**4*complexconjugate(CKM3x3))/(2.*MW**2*sw**2) - (3*CKM3x3*ee**2*MB**2*MT**2*complexconjugate(CKM3x3))/(MW**2*sw**2) + (3*CKM3x3*ee**2*MT**4*complexconjugate(CKM3x3))/(2.*MW**2*sw**2) - (3*CKM3x3*ee**2*MW**2*complexconjugate(CKM3x3))/sw**2)*cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4))/(96.*cmath.pi*abs(MB)**3)'})
+
+Decay_e__minus__ = Decay(name = 'Decay_e__minus__',
+                         particle = P.e__minus__,
+                         partial_widths = {(P.W__minus__,P.ve):'((Me**2 - MW**2)*((ee**2*Me**2)/(2.*sw**2) + (ee**2*Me**4)/(2.*MW**2*sw**2) - (ee**2*MW**2)/sw**2))/(32.*cmath.pi*abs(Me)**3)'})
+
+Decay_mu__minus__ = Decay(name = 'Decay_mu__minus__',
+                          particle = P.mu__minus__,
+                          partial_widths = {(P.W__minus__,P.vm):'((MM**2 - MW**2)*((ee**2*MM**2)/(2.*sw**2) + (ee**2*MM**4)/(2.*MW**2*sw**2) - (ee**2*MW**2)/sw**2))/(32.*cmath.pi*abs(MM)**3)'})
+
+Decay_ta__minus__ = Decay(name = 'Decay_ta__minus__',
+                          particle = P.ta__minus__,
+                          partial_widths = {(P.W__minus__,P.vt):'((MTA**2 - MW**2)*((ee**2*MTA**2)/(2.*sw**2) + (ee**2*MTA**4)/(2.*MW**2*sw**2) - (ee**2*MW**2)/sw**2))/(32.*cmath.pi*abs(MTA)**3)'})
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/function_library.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/function_library.py
new file mode 100644
index 0000000000..33a8975a58
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/function_library.py
@@ -0,0 +1,51 @@
+# This file is part of the UFO.
+#
+# This file contains definitions for functions that
+# are extensions of the cmath library, and correspond
+# either to functions that are in cmath, but inconvenient
+# to access from there (e.g. z.conjugate()),
+# or functions that are simply not defined.
+#
+#
+from __future__ import absolute_import
+__date__ = "22 July 2010"
+__author__ = "claude.duhr@durham.ac.uk"
+
+from cmath import cos, sin, acos, asin
+from .object_library import all_functions, Function
+
+#
+# shortcuts for functions from cmath
+#
+
+complexconjugate = Function(name = 'complexconjugate',
+                            arguments = ('z',),
+                            expression = 'z.conjugate()')
+
+
+re = Function(name = 're',
+              arguments = ('z',),
+              expression = 'z.real')
+
+im = Function(name = 'im',
+              arguments = ('z',),
+              expression = 'z.imag')
+
+
+# New functions (trigonometric)
+
+sec = Function(name = 'sec',
+             arguments = ('z',),
+             expression = '1./cos(z)')
+
+asec = Function(name = 'asec',
+             arguments = ('z',),
+             expression = 'acos(1./z)')
+
+csc = Function(name = 'csc',
+             arguments = ('z',),
+             expression = '1./sin(z)')
+
+acsc = Function(name = 'acsc',
+             arguments = ('z',),
+             expression = 'asin(1./z)')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/lorentz.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/lorentz.py
new file mode 100644
index 0000000000..b4221f8c4d
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/lorentz.py
@@ -0,0 +1,96 @@
+# type: ignore
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:26
+
+
+from __future__ import absolute_import
+
+from .function_library import acsc, asec, complexconjugate, csc, im, re, sec
+from .object_library import Lorentz, all_lorentz
+
+try:
+    import form_factors as ForFac
+except ImportError:
+    pass
+
+
+UUS1 = Lorentz(name="UUS1", spins=[-1, -1, 1], structure="1")
+
+UUV1 = Lorentz(name="UUV1", spins=[-1, -1, 3], structure="-P(3,2)")
+
+SSS1 = Lorentz(name="SSS1", spins=[1, 1, 1], structure="1")
+
+FFS1 = Lorentz(name="FFS1", spins=[2, 2, 1], structure="ProjM(2,1)")
+
+FFS2 = Lorentz(name="FFS2", spins=[2, 2, 1], structure="ProjM(2,1) - ProjP(2,1)")
+
+FFS3 = Lorentz(name="FFS3", spins=[2, 2, 1], structure="ProjP(2,1)")
+
+FFS4 = Lorentz(name="FFS4", spins=[2, 2, 1], structure="ProjM(2,1) + ProjP(2,1)")
+
+FFV1 = Lorentz(name="FFV1", spins=[2, 2, 3], structure="Gamma(3,2,1)")
+
+FFV2 = Lorentz(name="FFV2", spins=[2, 2, 3], structure="Gamma(3,2,-1)*ProjM(-1,1)")
+
+FFV3 = Lorentz(
+    name="FFV3",
+    spins=[2, 2, 3],
+    structure="Gamma(3,2,-1)*ProjM(-1,1) - 2*Gamma(3,2,-1)*ProjP(-1,1)",
+)
+
+FFV4 = Lorentz(
+    name="FFV4",
+    spins=[2, 2, 3],
+    structure="Gamma(3,2,-1)*ProjM(-1,1) + 2*Gamma(3,2,-1)*ProjP(-1,1)",
+)
+
+FFV5 = Lorentz(
+    name="FFV5",
+    spins=[2, 2, 3],
+    structure="Gamma(3,2,-1)*ProjM(-1,1) + 4*Gamma(3,2,-1)*ProjP(-1,1)",
+)
+
+VSS1 = Lorentz(name="VSS1", spins=[3, 1, 1], structure="P(1,2) - P(1,3)")
+
+VVS1 = Lorentz(name="VVS1", spins=[3, 3, 1], structure="Metric(1,2)")
+
+VVV1 = Lorentz(
+    name="VVV1",
+    spins=[3, 3, 3],
+    structure="P(3,1)*Metric(1,2) - P(3,2)*Metric(1,2) - P(2,1)*Metric(1,3) + P(2,3)*Metric(1,3) + P(1,2)*Metric(2,3) - P(1,3)*Metric(2,3)",
+)
+
+SSSS1 = Lorentz(name="SSSS1", spins=[1, 1, 1, 1], structure="1")
+
+VVSS1 = Lorentz(name="VVSS1", spins=[3, 3, 1, 1], structure="Metric(1,2)")
+
+VVVV1 = Lorentz(
+    name="VVVV1",
+    spins=[3, 3, 3, 3],
+    structure="Metric(1,4)*Metric(2,3) - Metric(1,3)*Metric(2,4)",
+)
+
+VVVV2 = Lorentz(
+    name="VVVV2",
+    spins=[3, 3, 3, 3],
+    structure="Metric(1,4)*Metric(2,3) + Metric(1,3)*Metric(2,4) - 2*Metric(1,2)*Metric(3,4)",
+)
+
+VVVV3 = Lorentz(
+    name="VVVV3",
+    spins=[3, 3, 3, 3],
+    structure="Metric(1,4)*Metric(2,3) - Metric(1,2)*Metric(3,4)",
+)
+
+VVVV4 = Lorentz(
+    name="VVVV4",
+    spins=[3, 3, 3, 3],
+    structure="Metric(1,3)*Metric(2,4) - Metric(1,2)*Metric(3,4)",
+)
+
+VVVV5 = Lorentz(
+    name="VVVV5",
+    spins=[3, 3, 3, 3],
+    structure="Metric(1,4)*Metric(2,3) - (Metric(1,3)*Metric(2,4))/2. - (Metric(1,2)*Metric(3,4))/2.",
+)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/object_library.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/object_library.py
new file mode 100644
index 0000000000..d63a4532dd
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/object_library.py
@@ -0,0 +1,270 @@
+##
+##
+## Feynrules Header
+##
+##
+##
+##
+##
+
+from __future__ import absolute_import
+import cmath
+
+
+class UFOBaseClass(object):
+    """The class from which all FeynRules classes are derived."""
+
+    require_args = []
+
+    def __init__(self, *args, **options):
+        assert(len(self.require_args) == len (args))
+
+        for i, name in enumerate(self.require_args):
+            setattr(self, name, args[i])
+
+        for (option, value) in options.items():
+            setattr(self, option, value)
+
+    def get(self, name):
+        return getattr(self, name)
+
+    def set(self, name, value):
+        setattr(self, name, value)
+
+    def get_all(self):
+        """Return a dictionary containing all the information of the object"""
+        return self.__dict__
+
+    def __str__(self):
+        return self.name
+
+    def nice_string(self):
+        """ return string with the full information """
+        return '\n'.join(['%s \t: %s' %(name, value) for name, value in self.__dict__.items()])
+
+    def __repr__(self):
+        replacements = [
+            ('+','__plus__'),
+            ('-','__minus__'),
+            ('@','__at__'),
+            ('!','__exclam__'),
+            ('?','__quest__'),
+            ('*','__star__'),
+            ('~','__tilde__')
+            ]
+        text = self.name
+        for orig,sub in replacements:
+            text = text.replace(orig,sub)
+        return text
+
+
+
+all_particles = []
+
+
+
+class Particle(UFOBaseClass):
+    """A standard Particle"""
+
+    require_args=['pdg_code', 'name', 'antiname', 'spin', 'color', 'mass', 'width', 'texname', 'antitexname', 'charge']
+
+    require_args_all = ['pdg_code', 'name', 'antiname', 'spin', 'color', 'mass', 'width', 'texname', 'antitexname', 'charge', 'line', 'propagating', 'goldstoneboson']
+
+    def __init__(self, pdg_code, name, antiname, spin, color, mass, width, texname,
+                 antitexname, charge , line=None, propagating=True, goldstoneboson=False, **options):
+
+        args= (pdg_code, name, antiname, spin, color, mass, width, texname,
+                 antitexname, float(charge))
+
+        UFOBaseClass.__init__(self, *args,  **options)
+
+        global all_particles
+        all_particles.append(self)
+
+        self.propagating = propagating
+        self.goldstoneboson= goldstoneboson
+
+        self.selfconjugate = (name == antiname)
+        if 1: #not line:
+            self.line = self.find_line_type()
+        else:
+            self.line = line
+
+
+
+
+    def find_line_type(self):
+        """ find how we draw a line if not defined
+        valid output: dashed/straight/wavy/curly/double/swavy/scurly
+        """
+
+        spin = self.spin
+        color = self.color
+
+        #use default
+        if spin == 1:
+            return 'dashed'
+        elif spin == 2:
+            if not self.selfconjugate:
+                return 'straight'
+            elif color == 1:
+                return 'swavy'
+            else:
+                return 'scurly'
+        elif spin == 3:
+            if color == 1:
+                return 'wavy'
+
+            else:
+                return 'curly'
+        elif spin == 5:
+            return 'double'
+        elif spin == -1:
+            return 'dotted'
+        else:
+            return 'dashed' # not supported yet
+
+    def anti(self):
+        if self.selfconjugate:
+            raise Exception('%s has no anti particle.' % self.name)
+        outdic = {}
+        for k,v in self.__dict__.items():
+            if k not in self.require_args_all:
+                outdic[k] = -v
+        if self.color in [1,8]:
+            newcolor = self.color
+        else:
+            newcolor = -self.color
+
+        return Particle(-self.pdg_code, self.antiname, self.name, self.spin, newcolor, self.mass, self.width,
+                        self.antitexname, self.texname, -self.charge, self.line, self.propagating, self.goldstoneboson, **outdic)
+
+
+
+all_parameters = []
+
+class Parameter(UFOBaseClass):
+
+    require_args=['name', 'nature', 'type', 'value', 'texname']
+
+    def __init__(self, name, nature, type, value, texname, lhablock=None, lhacode=None):
+
+        args = (name,nature,type,value,texname)
+
+        UFOBaseClass.__init__(self, *args)
+
+        args=(name,nature,type,value,texname)
+
+        global all_parameters
+        all_parameters.append(self)
+
+        if (lhablock is None or lhacode is None)  and nature == 'external':
+            raise Exception('Need LHA information for external parameter "%s".' % name)
+        self.lhablock = lhablock
+        self.lhacode = lhacode
+
+all_vertices = []
+
+class Vertex(UFOBaseClass):
+
+    require_args=['name', 'particles', 'color', 'lorentz', 'couplings']
+
+    def __init__(self, name, particles, color, lorentz, couplings, **opt):
+
+        args = (name, particles, color, lorentz, couplings)
+
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        args=(particles,color,lorentz,couplings)
+
+        global all_vertices
+        all_vertices.append(self)
+
+all_couplings = []
+
+class Coupling(UFOBaseClass):
+
+    require_args=['name', 'value', 'order']
+
+    def __init__(self, name, value, order, **opt):
+
+        args =(name, value, order)
+        UFOBaseClass.__init__(self, *args, **opt)
+        global all_couplings
+        all_couplings.append(self)
+
+
+
+all_lorentz = []
+
+class Lorentz(UFOBaseClass):
+
+    require_args=['name','spins','structure']
+
+    def __init__(self, name, spins, structure='external', **opt):
+        args = (name, spins, structure)
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        global all_lorentz
+        all_lorentz.append(self)
+
+
+all_functions = []
+
+class Function(object):
+
+    def __init__(self, name, arguments, expression):
+
+        global all_functions
+        all_functions.append(self)
+
+        self.name = name
+        self.arguments = arguments
+        self.expr = expression
+
+    def __call__(self, *opt):
+
+        for i, arg in enumerate(self.arguments):
+            exec('%s = %s' % (arg, opt[i] ))
+
+        return eval(self.expr)
+
+all_orders = []
+
+class CouplingOrder(object):
+
+    def __init__(self, name, expansion_order, hierarchy, perturbative_expansion = 0):
+
+        global all_orders
+        all_orders.append(self)
+
+        self.name = name
+        self.expansion_order = expansion_order
+        self.hierarchy = hierarchy
+
+all_decays = []
+
+class Decay(UFOBaseClass):
+    require_args = ['particle','partial_widths']
+
+    def __init__(self, particle, partial_widths, **opt):
+        args = (particle, partial_widths)
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        global all_decays
+        all_decays.append(self)
+
+        # Add the information directly to the particle
+        particle.partial_widths = partial_widths
+
+all_form_factors = []
+
+class FormFactor(UFOBaseClass):
+    require_args = ['name','type','value']
+
+    def __init__(self, name, type, value, **opt):
+        args = (name, type, value)
+        UFOBaseClass.__init__(self, *args, **opt)
+
+        global all_form_factors
+        all_form_factors.append(self)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/parameters.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/parameters.py
new file mode 100644
index 0000000000..8cf6168093
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/parameters.py
@@ -0,0 +1,495 @@
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:25
+
+
+from __future__ import absolute_import
+from .object_library import all_parameters, Parameter
+
+from .function_library import complexconjugate, re, im, csc, sec, acsc, asec
+
+# This is a default parameter object representing 0.
+ZERO = Parameter(name='ZERO',
+                 nature='internal',
+                 type='real',
+                 value=0.0,
+                 texname='0')
+
+# User-defined parameters.
+aEWM1 = Parameter(name='aEWM1',
+                  nature='external',
+                  type='real',
+                  value=132.50698,
+                  texname='\\text{aEWM1}',
+                  lhablock='SMINPUTS',
+                  lhacode=[1])
+
+Gf = Parameter(name='Gf',
+               nature='external',
+               type='real',
+               value=0.0000116639,
+               texname='G_f',
+               lhablock='SMINPUTS',
+               lhacode=[2])
+
+aS = Parameter(name='aS',
+               nature='external',
+               type='real',
+               value=0.118,
+               texname='\\alpha _s',
+               lhablock='SMINPUTS',
+               lhacode=[3])
+
+lamWS = Parameter(name='lamWS',
+                  nature='external',
+                  type='real',
+                  value=0.2253,
+                  texname='\\text{lamWS}',
+                  lhablock='Wolfenstein',
+                  lhacode=[1])
+
+AWS = Parameter(name='AWS',
+                nature='external',
+                type='real',
+                value=0.808,
+                texname='\\text{AWS}',
+                lhablock='Wolfenstein',
+                lhacode=[2])
+
+rhoWS = Parameter(name='rhoWS',
+                  nature='external',
+                  type='real',
+                  value=0.132,
+                  texname='\\text{rhoWS}',
+                  lhablock='Wolfenstein',
+                  lhacode=[3])
+
+etaWS = Parameter(name='etaWS',
+                  nature='external',
+                  type='real',
+                  value=0.341,
+                  texname='\\text{etaWS}',
+                  lhablock='Wolfenstein',
+                  lhacode=[4])
+
+ymc = Parameter(name='ymc',
+                nature='external',
+                type='real',
+                value=1.27,
+                texname='\\text{ymc}',
+                lhablock='YUKAWA',
+                lhacode=[4])
+
+ymb = Parameter(name='ymb',
+                nature='external',
+                type='real',
+                value=4.2,
+                texname='\\text{ymb}',
+                lhablock='YUKAWA',
+                lhacode=[5])
+
+ymt = Parameter(name='ymt',
+                nature='external',
+                type='real',
+                value=164.5,
+                texname='\\text{ymt}',
+                lhablock='YUKAWA',
+                lhacode=[6])
+
+yme = Parameter(name='yme',
+                nature='external',
+                type='real',
+                value=0.000511,
+                texname='\\text{yme}',
+                lhablock='YUKAWA',
+                lhacode=[11])
+
+ymm = Parameter(name='ymm',
+                nature='external',
+                type='real',
+                value=0.10566,
+                texname='\\text{ymm}',
+                lhablock='YUKAWA',
+                lhacode=[13])
+
+ymtau = Parameter(name='ymtau',
+                  nature='external',
+                  type='real',
+                  value=1.777,
+                  texname='\\text{ymtau}',
+                  lhablock='YUKAWA',
+                  lhacode=[15])
+
+MZ = Parameter(name='MZ',
+               nature='external',
+               type='real',
+               value=91.188,
+               texname='\\text{MZ}',
+               lhablock='MASS',
+               lhacode=[23])
+
+MC = Parameter(name='MC',
+               nature='external',
+               type='real',
+               value=1.27,
+               texname='\\text{MC}',
+               lhablock='MASS',
+               lhacode=[4])
+
+MT = Parameter(name='MT',
+               nature='external',
+               type='real',
+               value=173.,
+               texname='\\text{MT}',
+               lhablock='MASS',
+               lhacode=[6])
+
+MB = Parameter(name='MB',
+               nature='external',
+               type='real',
+               value=4.7,
+               texname='\\text{MB}',
+               lhablock='MASS',
+               lhacode=[5])
+
+MH = Parameter(name='MH',
+               nature='external',
+               type='real',
+               value=125.,
+               texname='\\text{MH}',
+               lhablock='MASS',
+               lhacode=[25])
+
+Me = Parameter(name='Me',
+               nature='external',
+               type='real',
+               value=0.000511,
+               texname='\\text{Me}',
+               lhablock='MASS',
+               lhacode=[11])
+
+MM = Parameter(name='MM',
+               nature='external',
+               type='real',
+               value=0.10566,
+               texname='\\text{MM}',
+               lhablock='MASS',
+               lhacode=[13])
+
+MTA = Parameter(name='MTA',
+                nature='external',
+                type='real',
+                value=1.777,
+                texname='\\text{MTA}',
+                lhablock='MASS',
+                lhacode=[15])
+
+WZ = Parameter(name='WZ',
+               nature='external',
+               type='real',
+               value=2.44140351,
+               texname='\\text{WZ}',
+               lhablock='DECAY',
+               lhacode=[23])
+
+WW = Parameter(name='WW',
+               nature='external',
+               type='real',
+               value=2.04759951,
+               texname='\\text{WW}',
+               lhablock='DECAY',
+               lhacode=[24])
+
+WT = Parameter(name='WT',
+               nature='external',
+               type='real',
+               value=1.50833649,
+               texname='\\text{WT}',
+               lhablock='DECAY',
+               lhacode=[6])
+
+WH = Parameter(name='WH',
+               nature='external',
+               type='real',
+               value=6.38233934e-03,
+               texname='\\text{WH}',
+               lhablock='DECAY',
+               lhacode=[25])
+
+WTau = Parameter(name='WTau',
+                 nature='external',
+                 type='real',
+                 value=2.27e-12,
+                 texname='\\text{WTau}',
+                 lhablock='DECAY',
+                 lhacode=[15])
+
+CKM1x1 = Parameter(name='CKM1x1',
+                   nature='internal',
+                   type='complex',
+                   value='1 - lamWS**2/2.',
+                   texname='\\text{CKM1x1}')
+
+CKM1x2 = Parameter(name='CKM1x2',
+                   nature='internal',
+                   type='complex',
+                   value='lamWS',
+                   texname='\\text{CKM1x2}')
+
+CKM1x3 = Parameter(name='CKM1x3',
+                   nature='internal',
+                   type='complex',
+                   value='AWS*lamWS**3*(-(etaWS*complex(0,1)) + rhoWS)',
+                   texname='\\text{CKM1x3}')
+
+CKM2x1 = Parameter(name='CKM2x1',
+                   nature='internal',
+                   type='complex',
+                   value='-lamWS',
+                   texname='\\text{CKM2x1}')
+
+CKM2x2 = Parameter(name='CKM2x2',
+                   nature='internal',
+                   type='complex',
+                   value='1 - lamWS**2/2.',
+                   texname='\\text{CKM2x2}')
+
+CKM2x3 = Parameter(name='CKM2x3',
+                   nature='internal',
+                   type='complex',
+                   value='AWS*lamWS**2',
+                   texname='\\text{CKM2x3}')
+
+CKM3x1 = Parameter(name='CKM3x1',
+                   nature='internal',
+                   type='complex',
+                   value='AWS*lamWS**3*(1 - etaWS*complex(0,1) - rhoWS)',
+                   texname='\\text{CKM3x1}')
+
+CKM3x2 = Parameter(name='CKM3x2',
+                   nature='internal',
+                   type='complex',
+                   value='-(AWS*lamWS**2)',
+                   texname='\\text{CKM3x2}')
+
+CKM3x3 = Parameter(name='CKM3x3',
+                   nature='internal',
+                   type='complex',
+                   value='1',
+                   texname='\\text{CKM3x3}')
+
+aEW = Parameter(name='aEW',
+                nature='internal',
+                type='real',
+                value='1/aEWM1',
+                texname='\\alpha _{\\text{EW}}')
+
+G = Parameter(name='G',
+              nature='internal',
+              type='real',
+              value='2*cmath.sqrt(aS)*cmath.sqrt(cmath.pi)',
+              texname='G')
+
+MW = Parameter(name='MW',
+               nature='internal',
+               type='real',
+               value='cmath.sqrt(MZ**2/2. + cmath.sqrt(MZ**4/4. - (aEW*cmath.pi*MZ**2)/(Gf*cmath.sqrt(2))))',
+               texname='M_W')
+
+ee = Parameter(name='ee',
+               nature='internal',
+               type='real',
+               value='2*cmath.sqrt(aEW)*cmath.sqrt(cmath.pi)',
+               texname='e')
+
+sw2 = Parameter(name='sw2',
+                nature='internal',
+                type='real',
+                value='1 - MW**2/MZ**2',
+                texname='\\text{sw2}')
+
+cw = Parameter(name='cw',
+               nature='internal',
+               type='real',
+               value='cmath.sqrt(1 - sw2)',
+               texname='c_w')
+
+sw = Parameter(name='sw',
+               nature='internal',
+               type='real',
+               value='cmath.sqrt(sw2)',
+               texname='s_w')
+
+g1 = Parameter(name='g1',
+               nature='internal',
+               type='real',
+               value='ee/cw',
+               texname='g_1')
+
+gw = Parameter(name='gw',
+               nature='internal',
+               type='real',
+               value='ee/sw',
+               texname='g_w')
+
+vev = Parameter(name='vev',
+                nature='internal',
+                type='real',
+                value='(2*MW*sw)/ee',
+                texname='\\text{vev}')
+
+lam = Parameter(name='lam',
+                nature='internal',
+                type='real',
+                value='MH**2/(2.*vev**2)',
+                texname='\\text{lam}')
+
+yb = Parameter(name='yb',
+               nature='internal',
+               type='real',
+               value='(ymb*cmath.sqrt(2))/vev',
+               texname='\\text{yb}')
+
+yc = Parameter(name='yc',
+               nature='internal',
+               type='real',
+               value='(ymc*cmath.sqrt(2))/vev',
+               texname='\\text{yc}')
+
+ye = Parameter(name='ye',
+               nature='internal',
+               type='real',
+               value='(yme*cmath.sqrt(2))/vev',
+               texname='\\text{ye}')
+
+ym = Parameter(name='ym',
+               nature='internal',
+               type='real',
+               value='(ymm*cmath.sqrt(2))/vev',
+               texname='\\text{ym}')
+
+yt = Parameter(name='yt',
+               nature='internal',
+               type='real',
+               value='(ymt*cmath.sqrt(2))/vev',
+               texname='\\text{yt}')
+
+ytau = Parameter(name='ytau',
+                 nature='internal',
+                 type='real',
+                 value='(ymtau*cmath.sqrt(2))/vev',
+                 texname='\\text{ytau}')
+
+muH = Parameter(name='muH',
+                nature='internal',
+                type='real',
+                value='cmath.sqrt(lam*vev**2)',
+                texname='\\mu')
+
+I1x31 = Parameter(name='I1x31',
+                  nature='internal',
+                  type='complex',
+                  value='yb*complexconjugate(CKM1x3)',
+                  texname='\\text{I1x31}')
+
+I1x32 = Parameter(name='I1x32',
+                  nature='internal',
+                  type='complex',
+                  value='yb*complexconjugate(CKM2x3)',
+                  texname='\\text{I1x32}')
+
+I1x33 = Parameter(name='I1x33',
+                  nature='internal',
+                  type='complex',
+                  value='yb*complexconjugate(CKM3x3)',
+                  texname='\\text{I1x33}')
+
+I2x12 = Parameter(name='I2x12',
+                  nature='internal',
+                  type='complex',
+                  value='yc*complexconjugate(CKM2x1)',
+                  texname='\\text{I2x12}')
+
+I2x13 = Parameter(name='I2x13',
+                  nature='internal',
+                  type='complex',
+                  value='yt*complexconjugate(CKM3x1)',
+                  texname='\\text{I2x13}')
+
+I2x22 = Parameter(name='I2x22',
+                  nature='internal',
+                  type='complex',
+                  value='yc*complexconjugate(CKM2x2)',
+                  texname='\\text{I2x22}')
+
+I2x23 = Parameter(name='I2x23',
+                  nature='internal',
+                  type='complex',
+                  value='yt*complexconjugate(CKM3x2)',
+                  texname='\\text{I2x23}')
+
+I2x32 = Parameter(name='I2x32',
+                  nature='internal',
+                  type='complex',
+                  value='yc*complexconjugate(CKM2x3)',
+                  texname='\\text{I2x32}')
+
+I2x33 = Parameter(name='I2x33',
+                  nature='internal',
+                  type='complex',
+                  value='yt*complexconjugate(CKM3x3)',
+                  texname='\\text{I2x33}')
+
+I3x21 = Parameter(name='I3x21',
+                  nature='internal',
+                  type='complex',
+                  value='CKM2x1*yc',
+                  texname='\\text{I3x21}')
+
+I3x22 = Parameter(name='I3x22',
+                  nature='internal',
+                  type='complex',
+                  value='CKM2x2*yc',
+                  texname='\\text{I3x22}')
+
+I3x23 = Parameter(name='I3x23',
+                  nature='internal',
+                  type='complex',
+                  value='CKM2x3*yc',
+                  texname='\\text{I3x23}')
+
+I3x31 = Parameter(name='I3x31',
+                  nature='internal',
+                  type='complex',
+                  value='CKM3x1*yt',
+                  texname='\\text{I3x31}')
+
+I3x32 = Parameter(name='I3x32',
+                  nature='internal',
+                  type='complex',
+                  value='CKM3x2*yt',
+                  texname='\\text{I3x32}')
+
+I3x33 = Parameter(name='I3x33',
+                  nature='internal',
+                  type='complex',
+                  value='CKM3x3*yt',
+                  texname='\\text{I3x33}')
+
+I4x13 = Parameter(name='I4x13',
+                  nature='internal',
+                  type='complex',
+                  value='CKM1x3*yb',
+                  texname='\\text{I4x13}')
+
+I4x23 = Parameter(name='I4x23',
+                  nature='internal',
+                  type='complex',
+                  value='CKM2x3*yb',
+                  texname='\\text{I4x23}')
+
+I4x33 = Parameter(name='I4x33',
+                  nature='internal',
+                  type='complex',
+                  value='CKM3x3*yb',
+                  texname='\\text{I4x33}')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/particles.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/particles.py
new file mode 100644
index 0000000000..161bd4d13e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/particles.py
@@ -0,0 +1,385 @@
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:25
+
+
+from __future__ import division
+from __future__ import absolute_import
+from .object_library import all_particles, Particle
+from . import parameters as Param
+
+a = Particle(pdg_code=22,
+             name='a',
+             antiname='a',
+             spin=3,
+             color=1,
+             mass=Param.ZERO,
+             width=Param.ZERO,
+             texname=r'{\gamma}',
+             antitexname=r'{\gamma}',
+             charge=0,
+             GhostNumber=0,
+             LeptonNumber=0,
+             Y=0)
+
+Z = Particle(pdg_code=23,
+             name='Z',
+             antiname='Z',
+             spin=3,
+             color=1,
+             mass=Param.MZ,
+             width=Param.WZ,
+             texname=r'{Z}',
+             antitexname=r'{Z}',
+             charge=0,
+             GhostNumber=0,
+             LeptonNumber=0,
+             Y=0)
+
+W__plus__ = Particle(pdg_code=24,
+                     name='W+',
+                     antiname='W-',
+                     spin=3,
+                     color=1,
+                     mass=Param.MW,
+                     width=Param.WW,
+                     texname=r'{W^+}',
+                     antitexname=r'{W^-}',
+                     charge=1,
+                     GhostNumber=0,
+                     LeptonNumber=0,
+                     Y=0)
+
+W__minus__ = W__plus__.anti()
+
+g = Particle(pdg_code=21,
+             name='g',
+             antiname='g',
+             spin=3,
+             color=8,
+             mass=Param.ZERO,
+             width=Param.ZERO,
+             texname=r'{g}',
+             antitexname=r'{g}',
+             charge=0,
+             GhostNumber=0,
+             LeptonNumber=0,
+             Y=0)
+
+ghA = Particle(pdg_code=9000001,
+               name='ghA',
+               antiname='ghA~',
+               spin=-1,
+               color=1,
+               mass=Param.ZERO,
+               width=Param.ZERO,
+               texname=r'\tilde{\gamma}',
+               antitexname=r'\overline{\tilde{\gamma}}',
+               charge=0,
+               GhostNumber=1,
+               LeptonNumber=0,
+               Y=0)
+
+ghA__tilde__ = ghA.anti()
+
+ghZ = Particle(pdg_code=9000002,
+               name='ghZ',
+               antiname='ghZ~',
+               spin=-1,
+               color=1,
+               mass=Param.MZ,
+               width=Param.WZ,
+               texname=r'\tilde{Z}',
+               antitexname=r'\bar{\tilde{Z}}',
+               charge=0,
+               GhostNumber=1,
+               LeptonNumber=0,
+               Y=0)
+
+ghZ__tilde__ = ghZ.anti()
+
+ghWp = Particle(pdg_code=9000003,
+                name='ghWp',
+                antiname='ghWp~',
+                spin=-1,
+                color=1,
+                mass=Param.MW,
+                width=Param.WW,
+                texname=r'{\tilde{W}^+}',
+                antitexname=r'{\bar{\tilde{W}}^+}',
+                charge=1,
+                GhostNumber=1,
+                LeptonNumber=0,
+                Y=0)
+
+ghWp__tilde__ = ghWp.anti()
+
+ghWm = Particle(pdg_code=9000004,
+                name='ghWm',
+                antiname='ghWm~',
+                spin=-1,
+                color=1,
+                mass=Param.MW,
+                width=Param.WW,
+                texname=r'{\tilde{W}^-}',
+                antitexname=r'{\bar{\tilde{W}}^-}',
+                charge=-1,
+                GhostNumber=1,
+                LeptonNumber=0,
+                Y=0)
+
+ghWm__tilde__ = ghWm.anti()
+
+ghG = Particle(pdg_code=9000005,
+               name='ghG',
+               antiname='ghG~',
+               spin=-1,
+               color=8,
+               mass=Param.ZERO,
+               width=Param.ZERO,
+               texname=r'{\tilde{g}}',
+               antitexname=r'{\bar{\tilde{g}}}',
+               charge=0,
+               GhostNumber=1,
+               LeptonNumber=0,
+               Y=0)
+
+ghG__tilde__ = ghG.anti()
+
+ve = Particle(pdg_code=12,
+              name='ve',
+              antiname='ve~',
+              spin=2,
+              color=1,
+              mass=Param.ZERO,
+              width=Param.ZERO,
+              texname=r'{\nu_e}',
+              antitexname=r'{\overline{\nu}_e}',
+              charge=0,
+              GhostNumber=0,
+              LeptonNumber=1,
+              Y=0)
+
+ve__tilde__ = ve.anti()
+
+vm = Particle(pdg_code=14,
+              name='vm',
+              antiname='vm~',
+              spin=2,
+              color=1,
+              mass=Param.ZERO,
+              width=Param.ZERO,
+              texname=r'{\nu_\mu}',
+              antitexname=r'{\overline{\nu}_\mu}',
+              charge=0,
+              GhostNumber=0,
+              LeptonNumber=1,
+              Y=0)
+
+vm__tilde__ = vm.anti()
+
+vt = Particle(pdg_code=16,
+              name='vt',
+              antiname='vt~',
+              spin=2,
+              color=1,
+              mass=Param.ZERO,
+              width=Param.ZERO,
+              texname=r'{\nu_\tau}',
+              antitexname=r'{\overline{\nu}_\tau}',
+              charge=0,
+              GhostNumber=0,
+              LeptonNumber=1,
+              Y=0)
+
+vt__tilde__ = vt.anti()
+
+u = Particle(pdg_code=2,
+             name='u',
+             antiname='u~',
+             spin=2,
+             color=3,
+             mass=Param.ZERO,
+             width=Param.ZERO,
+             texname=r'{u}',
+             antitexname=r'{\overline{u}}',
+             charge=2/3,
+             GhostNumber=0,
+             LeptonNumber=0,
+             Y=0)
+
+u__tilde__ = u.anti()
+
+c = Particle(pdg_code=4,
+             name='c',
+             antiname='c~',
+             spin=2,
+             color=3,
+             mass=Param.MC,
+             width=Param.ZERO,
+             texname=r'{c}',
+             antitexname=r'{\overline{c}}',
+             charge=2/3,
+             GhostNumber=0,
+             LeptonNumber=0,
+             Y=0)
+
+c__tilde__ = c.anti()
+
+t = Particle(pdg_code=6,
+             name='t',
+             antiname='t~',
+             spin=2,
+             color=3,
+             mass=Param.MT,
+             width=Param.WT,
+             texname=r'{t}',
+             antitexname=r'{\overline{t}}',
+             charge=2/3,
+             GhostNumber=0,
+             LeptonNumber=0,
+             Y=0)
+
+t__tilde__ = t.anti()
+
+d = Particle(pdg_code=1,
+             name='d',
+             antiname='d~',
+             spin=2,
+             color=3,
+             mass=Param.ZERO,
+             width=Param.ZERO,
+             texname=r'{d}',
+             antitexname=r'{\overline{d}}',
+             charge=-1/3,
+             GhostNumber=0,
+             LeptonNumber=0,
+             Y=0)
+
+d__tilde__ = d.anti()
+
+s = Particle(pdg_code=3,
+             name='s',
+             antiname='s~',
+             spin=2,
+             color=3,
+             mass=Param.ZERO,
+             width=Param.ZERO,
+             texname=r'{s}',
+             antitexname=r'{\overline{s}}',
+             charge=-1/3,
+             GhostNumber=0,
+             LeptonNumber=0,
+             Y=0)
+
+s__tilde__ = s.anti()
+
+b = Particle(pdg_code=5,
+             name='b',
+             antiname='b~',
+             spin=2,
+             color=3,
+             mass=Param.MB,
+             width=Param.ZERO,
+             texname=r'{b}',
+             antitexname=r'{\overline{b}}',
+             charge=-1/3,
+             GhostNumber=0,
+             LeptonNumber=0,
+             Y=0)
+
+b__tilde__ = b.anti()
+
+H = Particle(pdg_code=25,
+             name='H',
+             antiname='H',
+             spin=1,
+             color=1,
+             mass=Param.MH,
+             width=Param.WH,
+             texname=r'{H}',
+             antitexname=r'{H}',
+             charge=0,
+             GhostNumber=0,
+             LeptonNumber=0,
+             Y=0)
+
+G0 = Particle(pdg_code=250,
+              name='G0',
+              antiname='G0',
+              spin=1,
+              color=1,
+              mass=Param.MZ,
+              width=Param.WZ,
+              texname=r'{G_0}',
+              antitexname=r'{G_0}',
+              GoldstoneBoson=True,
+              charge=0,
+              GhostNumber=0,
+              LeptonNumber=0,
+              Y=0)
+
+G__plus__ = Particle(pdg_code=251,
+                     name='G+',
+                     antiname='G-',
+                     spin=1,
+                     color=1,
+                     mass=Param.MW,
+                     width=Param.WW,
+                     texname=r'{G^+}',
+                     antitexname=r'{G^-}',
+                     GoldstoneBoson=True,
+                     charge=1,
+                     GhostNumber=0,
+                     LeptonNumber=0,
+                     Y=0)
+
+G__minus__ = G__plus__.anti()
+
+e__minus__ = Particle(pdg_code=11,
+                      name='e-',
+                      antiname='e+',
+                      spin=2,
+                      color=1,
+                      mass=Param.Me,
+                      width=Param.ZERO,
+                      texname=r'{e^-}',
+                      antitexname=r'{e^+}',
+                      charge=-1,
+                      GhostNumber=0,
+                      LeptonNumber=1,
+                      Y=0)
+
+e__plus__ = e__minus__.anti()
+
+mu__minus__ = Particle(pdg_code=13,
+                       name='mu-',
+                       antiname='mu+',
+                       spin=2,
+                       color=1,
+                       mass=Param.MM,
+                       width=Param.ZERO,
+                       texname=r'{\mu^-}',
+                       antitexname=r'{\mu^+}',
+                       charge=-1,
+                       GhostNumber=0,
+                       LeptonNumber=1,
+                       Y=0)
+
+mu__plus__ = mu__minus__.anti()
+
+ta__minus__ = Particle(pdg_code=15,
+                       name='ta-',
+                       antiname='ta+',
+                       spin=2,
+                       color=1,
+                       mass=Param.MTA,
+                       width=Param.WTau,
+                       texname=r'{\tau^-}',
+                       antitexname=r'{\tau^+}',
+                       charge=-1,
+                       GhostNumber=0,
+                       LeptonNumber=1,
+                       Y=0)
+
+ta__plus__ = ta__minus__.anti()
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_c_mass.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_c_mass.dat
new file mode 100644
index 0000000000..153d8c6509
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_c_mass.dat
@@ -0,0 +1,53 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS
+    4 1.550000e+00 # MC
+    5 4.700000e+00 # MB
+    6 1.730000e+02 # MT
+   11 0.000000e+00 # Me
+   13 0.000000e+00 # MM
+   15 1.777000e+00 # MTA
+   23 9.118800e+01 # MZ
+   25 1.250000e+02 # MH
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 1.491500E+00
+DECAY  15 0.000000e+00
+DECAY  23 2.441404e+00
+DECAY  24 2.047600e+00
+DECAY  25 6.38233934e-03
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein
+    1 0.000000e+00 # lamWS
+    2 0.000000e+00 # AWS
+    3 0.000000e+00 # rhoWS
+    4 0.000000e+00 # etaWS
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA
+    4 1.550000e+00 # ymc
+    5 4.700000e+00 # ymb
+    6 1.730000e+02 # ymt
+   11 0.000000e+00 # yme
+   13 0.000000e+00 # ymm
+   15 1.777000e+00 # ymtau
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_ckm.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_ckm.dat
new file mode 100644
index 0000000000..3b0e9f9db1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_ckm.dat
@@ -0,0 +1,53 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS
+    4 0.000000e+00 # MC
+    5 4.700000e+00 # MB
+    6 1.730000e+02 # MT
+   11 0.000000e+00 # Me
+   13 0.000000e+00 # MM
+   15 1.777000e+00 # MTA
+   23 9.118800e+01 # MZ
+   25 1.250000e+02 # MH
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 1.491500E+00
+DECAY  15 0.000000e+00
+DECAY  23 2.441404e+00
+DECAY  24 2.047600e+00
+DECAY  25 6.38233934e-03
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein
+    1 2.253000e-01 # lamWS
+    2 8.080000e-01 # AWS
+    3 1.320000e-01 # rhoWS
+    4 3.410000e-01 # etaWS
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA
+    4 0.000000e+00 # ymc
+    5 4.700000e+00 # ymb
+    6 1.730000e+02 # ymt
+   11 0.000000e+00 # yme
+   13 0.000000e+00 # ymm
+   15 1.777000e+00 # ymtau
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_default.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_default.dat
new file mode 100644
index 0000000000..2ae557d5ad
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_default.dat
@@ -0,0 +1,53 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS
+    4 0.000000e+00 # MC
+    5 4.700000e+00 # MB
+    6 1.730000e+02 # MT
+   11 0.000000e+00 # Me
+   13 0.000000e+00 # MM
+   15 1.777000e+00 # MTA
+   23 9.118800e+01 # MZ
+   25 1.250000e+02 # MH
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 1.491500E+00 # WT
+DECAY  15 0.000000e+00 # WTau
+DECAY  23 2.441404e+00 # WZ
+DECAY  24 2.047600e+00 # WW
+DECAY  25 6.38233934e-03 # WH
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein
+    1 0.000000e+00 # lamWS
+    2 0.000000e+00 # AWS
+    3 0.000000e+00 # rhoWS
+    4 0.000000e+00 # etaWS
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA
+    4 0.000000e+00 # ymc
+    5 4.700000e+00 # ymb
+    6 1.730000e+02 # ymt
+   11 0.000000e+00 # yme
+   13 0.000000e+00 # ymm
+   15 1.777000e+00 # ymtau
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_full.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_full.dat
new file mode 100644
index 0000000000..38ec0ccc52
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_full.dat
@@ -0,0 +1,128 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY GAMMALOOP                   ##
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS
+    4 1.270000e+00 # MC
+    5 4.700000e+00 # MB
+    6 1.730000e+02 # MT
+   11 5.110000e-04 # Me
+   13 1.056600e-01 # MM
+   15 1.777000e+00 # MTA
+   23 9.118800e+01 # MZ
+   25 1.250000e+02 # MH
+##  Not dependent paramater.
+## Those values should be edited following analytical the
+## analytical expression. Some generator could simply ignore
+## those values and use the analytical expression
+  22 0.000000 # a : None
+  24 80.419000 # W+ : sqrt(1/2*MZ^2+sqrt(1/4*MZ^4-pi*MZ^2*aEW*(Gf*sqrt(2))^-1))
+  21 0.000000 # g : None
+  9000001 0.000000 # ghA : None
+  9000003 80.419000 # ghWp : sqrt(1/2*MZ^2+sqrt(1/4*MZ^4-pi*MZ^2*aEW*(Gf*sqrt(2))^-1))
+  9000004 80.419000 # ghWm : sqrt(1/2*MZ^2+sqrt(1/4*MZ^4-pi*MZ^2*aEW*(Gf*sqrt(2))^-1))
+  9000005 0.000000 # ghG : None
+  12 0.000000 # ve : None
+  14 0.000000 # vm : None
+  16 0.000000 # vt : None
+  2 0.000000 # u : None
+  1 0.000000 # d : None
+  3 0.000000 # s : None
+  251 80.419000 # G+ : sqrt(1/2*MZ^2+sqrt(1/4*MZ^4-pi*MZ^2*aEW*(Gf*sqrt(2))^-1))
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 1.491500E+00 # WT
+DECAY  15 2.270000e-12
+DECAY  23 2.441404e+00
+DECAY  24 2.047600e+00
+DECAY  25 6.382339e-03
+##  Not dependent paramater.
+## Those values should be edited following analytical the
+## analytical expression. Some generator could simply ignore
+## those values and use the analytical expression
+DECAY  22 0.000000 # a : None
+DECAY  21 0.000000 # g : None
+DECAY  9000001 0.000000 # ghA : None
+DECAY  9000005 0.000000 # ghG : None
+DECAY  12 0.000000 # ve : None
+DECAY  14 0.000000 # vm : None
+DECAY  16 0.000000 # vt : None
+DECAY  2 0.000000 # u : None
+DECAY  4 0.000000 # c : None
+DECAY  1 0.000000 # d : None
+DECAY  3 0.000000 # s : None
+DECAY  5 0.000000 # b : None
+DECAY  11 0.000000 # e- : None
+DECAY  13 0.000000 # mu- : None
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein
+    1 2.253000e-01 # lamWS
+    2 8.080000e-01 # AWS
+    3 1.320000e-01 # rhoWS
+    4 3.410000e-01 # etaWS
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA
+    4 1.270000e+00 # ymc
+    5 4.200000e+00 # ymb
+    6 1.645000e+02 # ymt
+   11 5.110000e-04 # yme
+   13 1.056600e-01 # ymm
+   15 1.777000e+00 # ymtau
+#===========================================================
+# QUANTUM NUMBERS OF NEW STATE(S) (NON SM PDG CODE)
+#===========================================================
+
+Block QNUMBERS 9000001  # ghA
+        1 0  # 3 times electric charge
+        2 -1  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 1  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 9000002  # ghZ
+        1 0  # 3 times electric charge
+        2 -1  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 1  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 9000003  # ghWp
+        1 3  # 3 times electric charge
+        2 -1  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 1  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 9000004  # ghWm
+        1 -3  # 3 times electric charge
+        2 -1  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 1  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 9000005  # ghG
+        1 0  # 3 times electric charge
+        2 -1  # number of spin states (2S+1)
+        3 8  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 1  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 250  # G0
+        1 0  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 0  # Particle/Antiparticle distinction (0=own anti)
+Block QNUMBERS 251  # G+
+        1 3  # 3 times electric charge
+        2 3  # number of spin states (2S+1)
+        3 1  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 1  # Particle/Antiparticle distinction (0=own anti)
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_lepton_masses.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_lepton_masses.dat
new file mode 100644
index 0000000000..b8d90f3e35
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_lepton_masses.dat
@@ -0,0 +1,53 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS
+    4 0.000000e+00 # MC
+    5 4.700000e+00 # MB
+    6 1.730000e+02 # MT
+   11 5.110000e-04 # Me
+   13 1.056600e-01 # MM
+   15 1.777000e+00 # MTA
+   23 9.118800e+01 # MZ
+   25 1.250000e+02 # MH
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 1.491500E+00 # WT
+DECAY  15 2.270000e-12 # WTau
+DECAY  23 2.441404e+00 # WZ
+DECAY  24 2.047600e+00 # WW
+DECAY  25 6.38233934e-03 # WH
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein
+    1 0.000000e+00 # lamWS
+    2 0.000000e+00 # AWS
+    3 0.000000e+00 # rhoWS
+    4 0.000000e+00 # etaWS
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA
+    4 0.000000e+00 # ymc
+    5 4.700000e+00 # ymb
+    6 1.730000e+02 # ymt
+   11 5.110000e-04 # yme
+   13 1.056600e-01 # ymm
+   15 1.777000e+00 # ymtau
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_b_mass.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_b_mass.dat
new file mode 100644
index 0000000000..f42e3375d1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_b_mass.dat
@@ -0,0 +1,53 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS
+    4 0.000000e+00 # MC
+    5 0.000000e+00 # MB
+    6 1.730000e+02 # MT
+   11 0.000000e+00 # Me
+   13 0.000000e+00 # MM
+   15 1.777000e+00 # MTA
+   23 9.118800e+01 # MZ
+   25 1.250000e+02 # MH
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 1.491500E+00
+DECAY  15 0.000000e+00
+DECAY  23 2.441404e+00
+DECAY  24 2.047600e+00
+DECAY  25 6.38233934e-03
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein
+    1 0.000000e+00 # lamWS
+    2 0.000000e+00 # AWS
+    3 0.000000e+00 # rhoWS
+    4 0.000000e+00 # etaWS
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA
+    4 0.000000e+00 # ymc
+    5 0.000000e+00 # ymb
+    6 1.730000e+02 # ymt
+   11 0.000000e+00 # yme
+   13 0.000000e+00 # ymm
+   15 1.777000e+00 # ymtau
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_masses.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_masses.dat
new file mode 100644
index 0000000000..31a72cedc7
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_masses.dat
@@ -0,0 +1,53 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS
+    4 0.000000e+00 # MC
+    5 0.000000e+00 # MB
+    6 1.730000e+02 # MT
+   11 0.000000e+00 # Me
+   13 0.000000e+00 # MM
+   15 0.000000e+00 # MTA
+   23 9.118800e+01 # MZ
+   25 1.250000e+02 # MH
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 1.491500E+00
+DECAY  15 0.000000e+00
+DECAY  23 2.441404e+00
+DECAY  24 2.047600e+00
+DECAY  25 6.38233934e-03
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein
+    1 0.000000e+00 # lamWS
+    2 0.000000e+00 # AWS
+    3 0.000000e+00 # rhoWS
+    4 0.000000e+00 # etaWS
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA
+    4 0.000000e+00 # ymc
+    5 0.000000e+00 # ymb
+    6 1.730000e+02 # ymt
+   11 0.000000e+00 # yme
+   13 0.000000e+00 # ymm
+   15 0.000000e+00 # ymtau
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_tau_mass.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_tau_mass.dat
new file mode 100644
index 0000000000..6497e444d2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_tau_mass.dat
@@ -0,0 +1,53 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS
+    4 0.000000e+00 # MC
+    5 4.700000e+00 # MB
+    6 1.730000e+02 # MT
+   11 0.000000e+00 # Me
+   13 0.000000e+00 # MM
+   15 0.000000e+00 # MTA
+   23 9.118800e+01 # MZ
+   25 1.250000e+02 # MH
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 1.491500E+00
+DECAY  15 0.000000e+00
+DECAY  23 2.441404e+00
+DECAY  24 2.047600e+00
+DECAY  25 6.38233934e-03
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein
+    1 0.000000e+00 # lamWS
+    2 0.000000e+00 # AWS
+    3 0.000000e+00 # rhoWS
+    4 0.000000e+00 # etaWS
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA
+    4 0.000000e+00 # ymc
+    5 4.700000e+00 # ymb
+    6 1.730000e+02 # ymt
+   11 0.000000e+00 # yme
+   13 0.000000e+00 # ymm
+   15 0.000000e+00 # ymtau
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_widths.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_widths.dat
new file mode 100644
index 0000000000..55e78884b9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_no_widths.dat
@@ -0,0 +1,53 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS
+    4 0.000000e+00 # MC
+    5 4.700000e+00 # MB
+    6 1.730000e+02 # MT
+   11 0.000000e+00 # Me
+   13 0.000000e+00 # MM
+   15 1.777000e+00 # MTA
+   23 9.118800e+01 # MZ
+   25 1.200000e+02 # MH
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 0.000000E+00
+DECAY  15 0.000000e+00
+DECAY  23 0.000000e+00
+DECAY  24 0.000000e+00
+DECAY  25 0.000000e+00
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein
+    1 0.000000e+00 # lamWS
+    2 0.000000e+00 # AWS
+    3 0.000000e+00 # rhoWS
+    4 0.000000e+00 # etaWS
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA
+    4 0.000000e+00 # ymc
+    5 4.200000e+00 # ymb
+    6 1.645000e+02 # ymt
+   11 0.000000e+00 # yme
+   13 0.000000e+00 # ymm
+   15 1.777000e+00 # ymtau
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_zeromass_ckm.dat b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_zeromass_ckm.dat
new file mode 100644
index 0000000000..c82164bac6
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/restrict_zeromass_ckm.dat
@@ -0,0 +1,53 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS
+    1 1.325070e+02 # aEWM1
+    2 1.166390e-05 # Gf
+    3 1.180000e-01 # aS
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS
+    4 0.000000e+00 # MC
+    5 0.000000e+00 # MB
+    6 1.730000e+02 # MT
+   11 0.000000e+00 # Me
+   13 0.000000e+00 # MM
+   15 0.000000e+00 # MTA
+   23 9.118800e+01 # MZ
+   25 1.250000e+02 # MH
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 1.491500E+00
+DECAY  15 0.000000e+00
+DECAY  23 2.441404e+00
+DECAY  24 2.047600e+00
+DECAY  25 6.38233934e-03
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein
+    1 2.253000e-01 # lamWS
+    2 8.080000e-01 # AWS
+    3 1.320000e-01 # rhoWS
+    4 3.410000e-01 # etaWS
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA
+    4 0.000000e+00 # ymc
+    5 0.000000e+00 # ymb
+    6 1.730000e+02 # ymt
+   11 0.000000e+00 # yme
+   13 0.000000e+00 # ymm
+   15 0.000000e+00 # ymtau
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/run_write_param_card.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/run_write_param_card.py
new file mode 100755
index 0000000000..d87ecc25b9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/run_write_param_card.py
@@ -0,0 +1,19 @@
+# type: ignore
+#!/usr/bin/env python
+from __future__ import absolute_import
+from __future__ import print_function
+from six.moves import range
+
+import sys
+import os
+import importlib
+
+if '__main__' == __name__:
+    dir_path = os.path.join(os.path.dirname(__file__))
+    sys.path.insert(0, os.path.join(dir_path, os.path.pardir))
+    pw = importlib.import_module('%s.%s' % (
+        os.path.basename(dir_path), 'write_param_card'))
+    del sys.path[0]
+
+    pw.ParamCardWriter('./param_card.dat', generic=True)
+    print('write ./param_card.dat')
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/vertices.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/vertices.py
new file mode 100644
index 0000000000..d8c6ceb815
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/vertices.py
@@ -0,0 +1,929 @@
+# This file was automatically created by FeynRules 1.7.69
+# Mathematica version: 8.0 for Mac OS X x86 (64-bit) (November 6, 2010)
+# Date: Mon 1 Oct 2012 14:58:25
+
+
+from __future__ import absolute_import
+from .object_library import all_vertices, Vertex
+from . import particles as P
+from . import couplings as C
+from . import lorentz as L
+
+
+V_1 = Vertex(name = 'V_1',
+             particles = [ P.G0, P.G0, P.G0, P.G0 ],
+             color = [ '1' ],
+             lorentz = [ L.SSSS1 ],
+             couplings = {(0,0):C.GC_33})
+
+V_2 = Vertex(name = 'V_2',
+             particles = [ P.G0, P.G0, P.G__minus__, P.G__plus__ ],
+             color = [ '1' ],
+             lorentz = [ L.SSSS1 ],
+             couplings = {(0,0):C.GC_31})
+
+V_3 = Vertex(name = 'V_3',
+             particles = [ P.G__minus__, P.G__minus__, P.G__plus__, P.G__plus__ ],
+             color = [ '1' ],
+             lorentz = [ L.SSSS1 ],
+             couplings = {(0,0):C.GC_32})
+
+V_4 = Vertex(name = 'V_4',
+             particles = [ P.G0, P.G0, P.H, P.H ],
+             color = [ '1' ],
+             lorentz = [ L.SSSS1 ],
+             couplings = {(0,0):C.GC_31})
+
+V_5 = Vertex(name = 'V_5',
+             particles = [ P.G__minus__, P.G__plus__, P.H, P.H ],
+             color = [ '1' ],
+             lorentz = [ L.SSSS1 ],
+             couplings = {(0,0):C.GC_31})
+
+V_6 = Vertex(name = 'V_6',
+             particles = [ P.H, P.H, P.H, P.H ],
+             color = [ '1' ],
+             lorentz = [ L.SSSS1 ],
+             couplings = {(0,0):C.GC_33})
+
+V_7 = Vertex(name = 'V_7',
+             particles = [ P.G0, P.G0, P.H ],
+             color = [ '1' ],
+             lorentz = [ L.SSS1 ],
+             couplings = {(0,0):C.GC_68})
+
+V_8 = Vertex(name = 'V_8',
+             particles = [ P.G__minus__, P.G__plus__, P.H ],
+             color = [ '1' ],
+             lorentz = [ L.SSS1 ],
+             couplings = {(0,0):C.GC_68})
+
+V_9 = Vertex(name = 'V_9',
+             particles = [ P.H, P.H, P.H ],
+             color = [ '1' ],
+             lorentz = [ L.SSS1 ],
+             couplings = {(0,0):C.GC_69})
+
+V_10 = Vertex(name = 'V_10',
+              particles = [ P.a, P.a, P.G__minus__, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_6})
+
+V_11 = Vertex(name = 'V_11',
+              particles = [ P.a, P.G__minus__, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VSS1 ],
+              couplings = {(0,0):C.GC_3})
+
+V_12 = Vertex(name = 'V_12',
+              particles = [ P.ghA, P.ghWm__tilde__, P.W__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_3})
+
+V_13 = Vertex(name = 'V_13',
+              particles = [ P.ghA, P.ghWp__tilde__, P.W__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_4})
+
+V_14 = Vertex(name = 'V_14',
+              particles = [ P.ghWm, P.ghA__tilde__, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_75})
+
+V_15 = Vertex(name = 'V_15',
+              particles = [ P.ghWm, P.ghA__tilde__, P.W__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_3})
+
+V_16 = Vertex(name = 'V_16',
+              particles = [ P.ghWm, P.ghWm__tilde__, P.G0 ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_70})
+
+V_17 = Vertex(name = 'V_17',
+              particles = [ P.ghWm, P.ghWm__tilde__, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_71})
+
+V_18 = Vertex(name = 'V_18',
+              particles = [ P.ghWm, P.ghWm__tilde__, P.a ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_4})
+
+V_19 = Vertex(name = 'V_19',
+              particles = [ P.ghWm, P.ghWm__tilde__, P.Z ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_53})
+
+V_20 = Vertex(name = 'V_20',
+              particles = [ P.ghWm, P.ghZ__tilde__, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_78})
+
+V_21 = Vertex(name = 'V_21',
+              particles = [ P.ghWm, P.ghZ__tilde__, P.W__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_52})
+
+V_22 = Vertex(name = 'V_22',
+              particles = [ P.ghWp, P.ghA__tilde__, P.G__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_74})
+
+V_23 = Vertex(name = 'V_23',
+              particles = [ P.ghWp, P.ghA__tilde__, P.W__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_4})
+
+V_24 = Vertex(name = 'V_24',
+              particles = [ P.ghWp, P.ghWp__tilde__, P.G0 ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_73})
+
+V_25 = Vertex(name = 'V_25',
+              particles = [ P.ghWp, P.ghWp__tilde__, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_71})
+
+V_26 = Vertex(name = 'V_26',
+              particles = [ P.ghWp, P.ghWp__tilde__, P.a ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_3})
+
+V_27 = Vertex(name = 'V_27',
+              particles = [ P.ghWp, P.ghWp__tilde__, P.Z ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_52})
+
+V_28 = Vertex(name = 'V_28',
+              particles = [ P.ghWp, P.ghZ__tilde__, P.G__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_77})
+
+V_29 = Vertex(name = 'V_29',
+              particles = [ P.ghWp, P.ghZ__tilde__, P.W__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_53})
+
+V_30 = Vertex(name = 'V_30',
+              particles = [ P.ghZ, P.ghWm__tilde__, P.G__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_79})
+
+V_31 = Vertex(name = 'V_31',
+              particles = [ P.ghZ, P.ghWm__tilde__, P.W__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_52})
+
+V_32 = Vertex(name = 'V_32',
+              particles = [ P.ghZ, P.ghWp__tilde__, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_76})
+
+V_33 = Vertex(name = 'V_33',
+              particles = [ P.ghZ, P.ghWp__tilde__, P.W__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_53})
+
+V_34 = Vertex(name = 'V_34',
+              particles = [ P.ghZ, P.ghZ__tilde__, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.UUS1 ],
+              couplings = {(0,0):C.GC_80})
+
+V_35 = Vertex(name = 'V_35',
+              particles = [ P.ghG, P.ghG__tilde__, P.g ],
+              color = [ 'f(3,1,2)' ],
+              lorentz = [ L.UUV1 ],
+              couplings = {(0,0):C.GC_10})
+
+V_36 = Vertex(name = 'V_36',
+              particles = [ P.g, P.g, P.g ],
+              color = [ 'f(1,2,3)' ],
+              lorentz = [ L.VVV1 ],
+              couplings = {(0,0):C.GC_10})
+
+V_37 = Vertex(name = 'V_37',
+              particles = [ P.g, P.g, P.g, P.g ],
+              color = [ 'f(-1,1,2)*f(3,4,-1)', 'f(-1,1,3)*f(2,4,-1)', 'f(-1,1,4)*f(2,3,-1)' ],
+              lorentz = [ L.VVVV1, L.VVVV3, L.VVVV4 ],
+              couplings = {(1,1):C.GC_12,(0,0):C.GC_12,(2,2):C.GC_12})
+
+V_38 = Vertex(name = 'V_38',
+              particles = [ P.a, P.W__minus__, P.G0, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_55})
+
+V_39 = Vertex(name = 'V_39',
+              particles = [ P.a, P.W__minus__, P.G__plus__, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_54})
+
+V_40 = Vertex(name = 'V_40',
+              particles = [ P.a, P.W__minus__, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVS1 ],
+              couplings = {(0,0):C.GC_74})
+
+V_41 = Vertex(name = 'V_41',
+              particles = [ P.W__minus__, P.G0, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VSS1 ],
+              couplings = {(0,0):C.GC_39})
+
+V_42 = Vertex(name = 'V_42',
+              particles = [ P.W__minus__, P.G__plus__, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VSS1 ],
+              couplings = {(0,0):C.GC_37})
+
+V_43 = Vertex(name = 'V_43',
+              particles = [ P.a, P.W__minus__, P.W__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVV1 ],
+              couplings = {(0,0):C.GC_4})
+
+V_44 = Vertex(name = 'V_44',
+              particles = [ P.a, P.W__plus__, P.G0, P.G__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_55})
+
+V_45 = Vertex(name = 'V_45',
+              particles = [ P.a, P.W__plus__, P.G__minus__, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_56})
+
+V_46 = Vertex(name = 'V_46',
+              particles = [ P.a, P.W__plus__, P.G__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVS1 ],
+              couplings = {(0,0):C.GC_75})
+
+V_47 = Vertex(name = 'V_47',
+              particles = [ P.W__plus__, P.G0, P.G__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VSS1 ],
+              couplings = {(0,0):C.GC_38})
+
+V_48 = Vertex(name = 'V_48',
+              particles = [ P.W__plus__, P.G__minus__, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VSS1 ],
+              couplings = {(0,0):C.GC_37})
+
+V_49 = Vertex(name = 'V_49',
+              particles = [ P.W__minus__, P.W__plus__, P.G0, P.G0 ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_34})
+
+V_50 = Vertex(name = 'V_50',
+              particles = [ P.W__minus__, P.W__plus__, P.G__minus__, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_34})
+
+V_51 = Vertex(name = 'V_51',
+              particles = [ P.W__minus__, P.W__plus__, P.H, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_34})
+
+V_52 = Vertex(name = 'V_52',
+              particles = [ P.W__minus__, P.W__plus__, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VVS1 ],
+              couplings = {(0,0):C.GC_72})
+
+V_53 = Vertex(name = 'V_53',
+              particles = [ P.a, P.a, P.W__minus__, P.W__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVVV2 ],
+              couplings = {(0,0):C.GC_5})
+
+V_54 = Vertex(name = 'V_54',
+              particles = [ P.W__minus__, P.W__plus__, P.Z ],
+              color = [ '1' ],
+              lorentz = [ L.VVV1 ],
+              couplings = {(0,0):C.GC_53})
+
+V_55 = Vertex(name = 'V_55',
+              particles = [ P.W__minus__, P.W__minus__, P.W__plus__, P.W__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVVV2 ],
+              couplings = {(0,0):C.GC_35})
+
+V_56 = Vertex(name = 'V_56',
+              particles = [ P.a, P.Z, P.G__minus__, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_63})
+
+V_57 = Vertex(name = 'V_57',
+              particles = [ P.Z, P.G0, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VSS1 ],
+              couplings = {(0,0):C.GC_60})
+
+V_58 = Vertex(name = 'V_58',
+              particles = [ P.Z, P.G__minus__, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VSS1 ],
+              couplings = {(0,0):C.GC_61})
+
+V_59 = Vertex(name = 'V_59',
+              particles = [ P.W__minus__, P.Z, P.G0, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_8})
+
+V_60 = Vertex(name = 'V_60',
+              particles = [ P.W__minus__, P.Z, P.G__plus__, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_9})
+
+V_61 = Vertex(name = 'V_61',
+              particles = [ P.W__minus__, P.Z, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVS1 ],
+              couplings = {(0,0):C.GC_67})
+
+V_62 = Vertex(name = 'V_62',
+              particles = [ P.W__plus__, P.Z, P.G0, P.G__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_8})
+
+V_63 = Vertex(name = 'V_63',
+              particles = [ P.W__plus__, P.Z, P.G__minus__, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_7})
+
+V_64 = Vertex(name = 'V_64',
+              particles = [ P.W__plus__, P.Z, P.G__minus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVS1 ],
+              couplings = {(0,0):C.GC_66})
+
+V_65 = Vertex(name = 'V_65',
+              particles = [ P.a, P.W__minus__, P.W__plus__, P.Z ],
+              color = [ '1' ],
+              lorentz = [ L.VVVV5 ],
+              couplings = {(0,0):C.GC_57})
+
+V_66 = Vertex(name = 'V_66',
+              particles = [ P.Z, P.Z, P.G0, P.G0 ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_65})
+
+V_67 = Vertex(name = 'V_67',
+              particles = [ P.Z, P.Z, P.G__minus__, P.G__plus__ ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_64})
+
+V_68 = Vertex(name = 'V_68',
+              particles = [ P.Z, P.Z, P.H, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VVSS1 ],
+              couplings = {(0,0):C.GC_65})
+
+V_69 = Vertex(name = 'V_69',
+              particles = [ P.Z, P.Z, P.H ],
+              color = [ '1' ],
+              lorentz = [ L.VVS1 ],
+              couplings = {(0,0):C.GC_81})
+
+V_70 = Vertex(name = 'V_70',
+              particles = [ P.W__minus__, P.W__plus__, P.Z, P.Z ],
+              color = [ '1' ],
+              lorentz = [ L.VVVV2 ],
+              couplings = {(0,0):C.GC_36})
+
+V_71 = Vertex(name = 'V_71',
+              particles = [ P.d__tilde__, P.d, P.a ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV1 ],
+              couplings = {(0,0):C.GC_1})
+
+V_72 = Vertex(name = 'V_72',
+              particles = [ P.s__tilde__, P.s, P.a ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV1 ],
+              couplings = {(0,0):C.GC_1})
+
+V_73 = Vertex(name = 'V_73',
+              particles = [ P.b__tilde__, P.b, P.a ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV1 ],
+              couplings = {(0,0):C.GC_1})
+
+V_74 = Vertex(name = 'V_74',
+              particles = [ P.d__tilde__, P.d, P.g ],
+              color = [ 'T(3,2,1)' ],
+              lorentz = [ L.FFV1 ],
+              couplings = {(0,0):C.GC_11})
+
+V_75 = Vertex(name = 'V_75',
+              particles = [ P.s__tilde__, P.s, P.g ],
+              color = [ 'T(3,2,1)' ],
+              lorentz = [ L.FFV1 ],
+              couplings = {(0,0):C.GC_11})
+
+V_76 = Vertex(name = 'V_76',
+              particles = [ P.b__tilde__, P.b, P.g ],
+              color = [ 'T(3,2,1)' ],
+              lorentz = [ L.FFV1 ],
+              couplings = {(0,0):C.GC_11})
+
+V_77 = Vertex(name = 'V_77',
+              particles = [ P.b__tilde__, P.b, P.G0 ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFS2 ],
+              couplings = {(0,0):C.GC_82})
+
+V_78 = Vertex(name = 'V_78',
+              particles = [ P.b__tilde__, P.b, P.H ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFS4 ],
+              couplings = {(0,0):C.GC_83})
+
+V_79 = Vertex(name = 'V_79',
+              particles = [ P.d__tilde__, P.d, P.Z ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2, L.FFV3 ],
+              couplings = {(0,0):C.GC_50,(0,1):C.GC_58})
+
+V_80 = Vertex(name = 'V_80',
+              particles = [ P.s__tilde__, P.s, P.Z ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2, L.FFV3 ],
+              couplings = {(0,0):C.GC_50,(0,1):C.GC_58})
+
+V_81 = Vertex(name = 'V_81',
+              particles = [ P.b__tilde__, P.b, P.Z ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2, L.FFV3 ],
+              couplings = {(0,1):C.GC_58,(0,0):C.GC_50})
+
+V_82 = Vertex(name = 'V_82',
+              particles = [ P.c__tilde__, P.d, P.G__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFS3 ],
+              couplings = {(0,0):C.GC_16})
+
+V_83 = Vertex(name = 'V_83',
+              particles = [ P.t__tilde__, P.d, P.G__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFS3 ],
+              couplings = {(0,0):C.GC_17})
+
+V_84 = Vertex(name = 'V_84',
+              particles = [ P.c__tilde__, P.s, P.G__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFS3 ],
+              couplings = {(0,0):C.GC_18})
+
+V_85 = Vertex(name = 'V_85',
+              particles = [ P.t__tilde__, P.s, P.G__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFS3 ],
+              couplings = {(0,0):C.GC_19})
+
+V_86 = Vertex(name = 'V_86',
+              particles = [ P.u__tilde__, P.b, P.G__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFS1 ],
+              couplings = {(0,0):C.GC_13})
+
+V_87 = Vertex(name = 'V_87',
+              particles = [ P.c__tilde__, P.b, P.G__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFS1, L.FFS3 ],
+              couplings = {(0,0):C.GC_14,(0,1):C.GC_20})
+
+V_88 = Vertex(name = 'V_88',
+              particles = [ P.t__tilde__, P.b, P.G__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFS1, L.FFS3 ],
+              couplings = {(0,0):C.GC_15,(0,1):C.GC_21})
+
+V_89 = Vertex(name = 'V_89',
+              particles = [ P.u__tilde__, P.d, P.W__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2 ],
+              couplings = {(0,0):C.GC_100})
+
+V_90 = Vertex(name = 'V_90',
+              particles = [ P.c__tilde__, P.d, P.W__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2 ],
+              couplings = {(0,0):C.GC_103})
+
+V_91 = Vertex(name = 'V_91',
+              particles = [ P.t__tilde__, P.d, P.W__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2 ],
+              couplings = {(0,0):C.GC_106})
+
+V_92 = Vertex(name = 'V_92',
+              particles = [ P.u__tilde__, P.s, P.W__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2 ],
+              couplings = {(0,0):C.GC_101})
+
+V_93 = Vertex(name = 'V_93',
+              particles = [ P.c__tilde__, P.s, P.W__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2 ],
+              couplings = {(0,0):C.GC_104})
+
+V_94 = Vertex(name = 'V_94',
+              particles = [ P.t__tilde__, P.s, P.W__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2 ],
+              couplings = {(0,0):C.GC_107})
+
+V_95 = Vertex(name = 'V_95',
+              particles = [ P.u__tilde__, P.b, P.W__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2 ],
+              couplings = {(0,0):C.GC_102})
+
+V_96 = Vertex(name = 'V_96',
+              particles = [ P.c__tilde__, P.b, P.W__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2 ],
+              couplings = {(0,0):C.GC_105})
+
+V_97 = Vertex(name = 'V_97',
+              particles = [ P.t__tilde__, P.b, P.W__plus__ ],
+              color = [ 'Identity(1,2)' ],
+              lorentz = [ L.FFV2 ],
+              couplings = {(0,0):C.GC_108})
+
+V_98 = Vertex(name = 'V_98',
+              particles = [ P.e__plus__, P.e__minus__, P.a ],
+              color = [ '1' ],
+              lorentz = [ L.FFV1 ],
+              couplings = {(0,0):C.GC_3})
+
+V_99 = Vertex(name = 'V_99',
+              particles = [ P.mu__plus__, P.mu__minus__, P.a ],
+              color = [ '1' ],
+              lorentz = [ L.FFV1 ],
+              couplings = {(0,0):C.GC_3})
+
+V_100 = Vertex(name = 'V_100',
+               particles = [ P.ta__plus__, P.ta__minus__, P.a ],
+               color = [ '1' ],
+               lorentz = [ L.FFV1 ],
+               couplings = {(0,0):C.GC_3})
+
+V_101 = Vertex(name = 'V_101',
+               particles = [ P.e__plus__, P.e__minus__, P.G0 ],
+               color = [ '1' ],
+               lorentz = [ L.FFS2 ],
+               couplings = {(0,0):C.GC_88})
+
+V_102 = Vertex(name = 'V_102',
+               particles = [ P.mu__plus__, P.mu__minus__, P.G0 ],
+               color = [ '1' ],
+               lorentz = [ L.FFS2 ],
+               couplings = {(0,0):C.GC_92})
+
+V_103 = Vertex(name = 'V_103',
+               particles = [ P.ta__plus__, P.ta__minus__, P.G0 ],
+               color = [ '1' ],
+               lorentz = [ L.FFS2 ],
+               couplings = {(0,0):C.GC_98})
+
+V_104 = Vertex(name = 'V_104',
+               particles = [ P.e__plus__, P.e__minus__, P.H ],
+               color = [ '1' ],
+               lorentz = [ L.FFS4 ],
+               couplings = {(0,0):C.GC_89})
+
+V_105 = Vertex(name = 'V_105',
+               particles = [ P.mu__plus__, P.mu__minus__, P.H ],
+               color = [ '1' ],
+               lorentz = [ L.FFS4 ],
+               couplings = {(0,0):C.GC_93})
+
+V_106 = Vertex(name = 'V_106',
+               particles = [ P.ta__plus__, P.ta__minus__, P.H ],
+               color = [ '1' ],
+               lorentz = [ L.FFS4 ],
+               couplings = {(0,0):C.GC_99})
+
+V_107 = Vertex(name = 'V_107',
+               particles = [ P.e__plus__, P.e__minus__, P.Z ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2, L.FFV4 ],
+               couplings = {(0,0):C.GC_50,(0,1):C.GC_59})
+
+V_108 = Vertex(name = 'V_108',
+               particles = [ P.mu__plus__, P.mu__minus__, P.Z ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2, L.FFV4 ],
+               couplings = {(0,0):C.GC_50,(0,1):C.GC_59})
+
+V_109 = Vertex(name = 'V_109',
+               particles = [ P.ta__plus__, P.ta__minus__, P.Z ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2, L.FFV4 ],
+               couplings = {(0,0):C.GC_50,(0,1):C.GC_59})
+
+V_110 = Vertex(name = 'V_110',
+               particles = [ P.ve__tilde__, P.e__minus__, P.G__plus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFS1 ],
+               couplings = {(0,0):C.GC_87})
+
+V_111 = Vertex(name = 'V_111',
+               particles = [ P.vm__tilde__, P.mu__minus__, P.G__plus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFS1 ],
+               couplings = {(0,0):C.GC_91})
+
+V_112 = Vertex(name = 'V_112',
+               particles = [ P.vt__tilde__, P.ta__minus__, P.G__plus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFS1 ],
+               couplings = {(0,0):C.GC_97})
+
+V_113 = Vertex(name = 'V_113',
+               particles = [ P.ve__tilde__, P.e__minus__, P.W__plus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_40})
+
+V_114 = Vertex(name = 'V_114',
+               particles = [ P.vm__tilde__, P.mu__minus__, P.W__plus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_40})
+
+V_115 = Vertex(name = 'V_115',
+               particles = [ P.vt__tilde__, P.ta__minus__, P.W__plus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_40})
+
+V_116 = Vertex(name = 'V_116',
+               particles = [ P.b__tilde__, P.u, P.G__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS3 ],
+               couplings = {(0,0):C.GC_28})
+
+V_117 = Vertex(name = 'V_117',
+               particles = [ P.d__tilde__, P.c, P.G__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS1 ],
+               couplings = {(0,0):C.GC_22})
+
+V_118 = Vertex(name = 'V_118',
+               particles = [ P.s__tilde__, P.c, P.G__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS1 ],
+               couplings = {(0,0):C.GC_23})
+
+V_119 = Vertex(name = 'V_119',
+               particles = [ P.b__tilde__, P.c, P.G__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS1, L.FFS3 ],
+               couplings = {(0,0):C.GC_24,(0,1):C.GC_29})
+
+V_120 = Vertex(name = 'V_120',
+               particles = [ P.d__tilde__, P.t, P.G__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS1 ],
+               couplings = {(0,0):C.GC_25})
+
+V_121 = Vertex(name = 'V_121',
+               particles = [ P.s__tilde__, P.t, P.G__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS1 ],
+               couplings = {(0,0):C.GC_26})
+
+V_122 = Vertex(name = 'V_122',
+               particles = [ P.b__tilde__, P.t, P.G__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS1, L.FFS3 ],
+               couplings = {(0,0):C.GC_27,(0,1):C.GC_30})
+
+V_123 = Vertex(name = 'V_123',
+               particles = [ P.d__tilde__, P.u, P.W__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_41})
+
+V_124 = Vertex(name = 'V_124',
+               particles = [ P.s__tilde__, P.u, P.W__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_42})
+
+V_125 = Vertex(name = 'V_125',
+               particles = [ P.b__tilde__, P.u, P.W__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_43})
+
+V_126 = Vertex(name = 'V_126',
+               particles = [ P.d__tilde__, P.c, P.W__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_44})
+
+V_127 = Vertex(name = 'V_127',
+               particles = [ P.s__tilde__, P.c, P.W__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_45})
+
+V_128 = Vertex(name = 'V_128',
+               particles = [ P.b__tilde__, P.c, P.W__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_46})
+
+V_129 = Vertex(name = 'V_129',
+               particles = [ P.d__tilde__, P.t, P.W__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_47})
+
+V_130 = Vertex(name = 'V_130',
+               particles = [ P.s__tilde__, P.t, P.W__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_48})
+
+V_131 = Vertex(name = 'V_131',
+               particles = [ P.b__tilde__, P.t, P.W__minus__ ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_49})
+
+V_132 = Vertex(name = 'V_132',
+               particles = [ P.u__tilde__, P.u, P.a ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV1 ],
+               couplings = {(0,0):C.GC_2})
+
+V_133 = Vertex(name = 'V_133',
+               particles = [ P.c__tilde__, P.c, P.a ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV1 ],
+               couplings = {(0,0):C.GC_2})
+
+V_134 = Vertex(name = 'V_134',
+               particles = [ P.t__tilde__, P.t, P.a ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV1 ],
+               couplings = {(0,0):C.GC_2})
+
+V_135 = Vertex(name = 'V_135',
+               particles = [ P.u__tilde__, P.u, P.g ],
+               color = [ 'T(3,2,1)' ],
+               lorentz = [ L.FFV1 ],
+               couplings = {(0,0):C.GC_11})
+
+V_136 = Vertex(name = 'V_136',
+               particles = [ P.c__tilde__, P.c, P.g ],
+               color = [ 'T(3,2,1)' ],
+               lorentz = [ L.FFV1 ],
+               couplings = {(0,0):C.GC_11})
+
+V_137 = Vertex(name = 'V_137',
+               particles = [ P.t__tilde__, P.t, P.g ],
+               color = [ 'T(3,2,1)' ],
+               lorentz = [ L.FFV1 ],
+               couplings = {(0,0):C.GC_11})
+
+V_138 = Vertex(name = 'V_138',
+               particles = [ P.c__tilde__, P.c, P.G0 ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS2 ],
+               couplings = {(0,0):C.GC_85})
+
+V_139 = Vertex(name = 'V_139',
+               particles = [ P.t__tilde__, P.t, P.G0 ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS2 ],
+               couplings = {(0,0):C.GC_95})
+
+V_140 = Vertex(name = 'V_140',
+               particles = [ P.c__tilde__, P.c, P.H ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS4 ],
+               couplings = {(0,0):C.GC_84})
+
+V_141 = Vertex(name = 'V_141',
+               particles = [ P.t__tilde__, P.t, P.H ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFS4 ],
+               couplings = {(0,0):C.GC_94})
+
+V_142 = Vertex(name = 'V_142',
+               particles = [ P.u__tilde__, P.u, P.Z ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2, L.FFV5 ],
+               couplings = {(0,0):C.GC_51,(0,1):C.GC_58})
+
+V_143 = Vertex(name = 'V_143',
+               particles = [ P.c__tilde__, P.c, P.Z ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2, L.FFV5 ],
+               couplings = {(0,0):C.GC_51,(0,1):C.GC_58})
+
+V_144 = Vertex(name = 'V_144',
+               particles = [ P.t__tilde__, P.t, P.Z ],
+               color = [ 'Identity(1,2)' ],
+               lorentz = [ L.FFV2, L.FFV5 ],
+               couplings = {(0,0):C.GC_51,(0,1):C.GC_58})
+
+V_145 = Vertex(name = 'V_145',
+               particles = [ P.e__plus__, P.ve, P.G__minus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFS3 ],
+               couplings = {(0,0):C.GC_86})
+
+V_146 = Vertex(name = 'V_146',
+               particles = [ P.mu__plus__, P.vm, P.G__minus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFS3 ],
+               couplings = {(0,0):C.GC_90})
+
+V_147 = Vertex(name = 'V_147',
+               particles = [ P.ta__plus__, P.vt, P.G__minus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFS3 ],
+               couplings = {(0,0):C.GC_96})
+
+V_148 = Vertex(name = 'V_148',
+               particles = [ P.e__plus__, P.ve, P.W__minus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_40})
+
+V_149 = Vertex(name = 'V_149',
+               particles = [ P.mu__plus__, P.vm, P.W__minus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_40})
+
+V_150 = Vertex(name = 'V_150',
+               particles = [ P.ta__plus__, P.vt, P.W__minus__ ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_40})
+
+V_151 = Vertex(name = 'V_151',
+               particles = [ P.ve__tilde__, P.ve, P.Z ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_62})
+
+V_152 = Vertex(name = 'V_152',
+               particles = [ P.vm__tilde__, P.vm, P.Z ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_62})
+
+V_153 = Vertex(name = 'V_153',
+               particles = [ P.vt__tilde__, P.vt, P.Z ],
+               color = [ '1' ],
+               lorentz = [ L.FFV2 ],
+               couplings = {(0,0):C.GC_62})
diff --git a/pyamplicol/src/pyamplicol/assets/models/ufo/sm/write_param_card.py b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/write_param_card.py
new file mode 100644
index 0000000000..3abf4cff0c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/models/ufo/sm/write_param_card.py
@@ -0,0 +1,184 @@
+
+from __future__ import absolute_import
+from __future__ import print_function
+from six.moves import range
+__date__ = "3 june 2010"
+__author__ = 'olivier.mattelaer@uclouvain.be'
+
+class ParamCardWriter(object):
+
+    header = \
+    """######################################################################\n""" + \
+    """## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################\n""" + \
+    """######################################################################\n"""
+
+    def __init__(self, filename, list_of_parameters=None, generic=False):
+        """write a valid param_card.dat"""
+
+        if not list_of_parameters:
+            from .parameters import all_parameters
+            list_of_parameters = [param for param in all_parameters if \
+                                                       param.nature=='external']
+
+        self.generic_output = generic
+        if generic:
+            self.define_not_dep_param(list_of_parameters)
+
+
+        self.fsock = open(filename, 'w')
+        self.fsock.write(self.header)
+
+        self.write_card(list_of_parameters)
+
+    def define_not_dep_param(self, list_of_parameters):
+        """define self.dep_mass and self.dep_width in case that they are
+        requested in the param_card.dat"""
+        from .particles import all_particles
+
+        self.dep_mass = [(part, part.mass) for part in all_particles \
+                            if part.pdg_code > 0 and \
+                                            part.mass not in list_of_parameters]
+        self.dep_width = [(part, part.width) for part in all_particles\
+                             if part.pdg_code > 0 and \
+                                part.width not in list_of_parameters]
+
+    @staticmethod
+    def order_param(obj1, obj2):
+        """ order parameter of a given block """
+
+        maxlen = min([len(obj1.lhacode), len(obj2.lhacode)])
+
+        for i in range(maxlen):
+            if obj1.lhacode[i] < obj2.lhacode[i]:
+                return -1
+            elif obj1.lhacode[i] == obj2.lhacode[i]:
+                return 0
+            else:
+                return 1
+        #identical up to the first finish
+        if len(obj1.lhacode) > len(obj2.lhacode):
+            return 1
+        elif  len(obj1.lhacode) == len(obj2.lhacode):
+            return 0
+        else:
+            return -1
+
+    def write_card(self, all_ext_param):
+        """ """
+
+        # list all lhablock
+        all_lhablock = set([param.lhablock for param in all_ext_param])
+
+        # ordonate lhablock alphabeticaly
+        all_lhablock = list(all_lhablock)
+        all_lhablock.sort()
+        # put at the beginning SMINPUT + MASS + DECAY
+        for name in ['DECAY', 'MASS','SMINPUTS']:
+            if name in all_lhablock:
+                all_lhablock.remove(name)
+                all_lhablock.insert(0, name)
+
+        for lhablock in all_lhablock:
+            self.write_block(lhablock)
+            need_writing = [ param for param in all_ext_param if \
+                                                     param.lhablock == lhablock]
+            from functools import cmp_to_key
+            need_writing.sort(key=cmp_to_key(self.order_param))
+            [self.write_param(param, lhablock) for param in need_writing]
+
+            if self.generic_output:
+                if lhablock in ['MASS', 'DECAY']:
+                    self.write_dep_param_block(lhablock)
+
+        if self.generic_output:
+            self.write_qnumber()
+
+    def write_block(self, name):
+        """ write a comment for a block"""
+
+        self.fsock.writelines(
+        """\n###################################""" + \
+        """\n## INFORMATION FOR %s""" % name.upper() +\
+        """\n###################################\n"""
+         )
+        if name!='DECAY':
+            self.fsock.write("""Block %s \n""" % name)
+
+    def write_param(self, param, lhablock):
+
+        lhacode=' '.join(['%3s' % key for key in param.lhacode])
+        if lhablock != 'DECAY':
+            text = """  %s %e # %s \n""" % (lhacode, complex(param.value).real, param.name )
+        else:
+            text = '''DECAY %s %e \n''' % (lhacode, complex(param.value).real)
+        self.fsock.write(text)
+
+
+
+
+    def write_dep_param_block(self, lhablock):
+        import cmath
+        from .parameters import all_parameters
+        for parameter in all_parameters:
+            try:
+                exec("%s = %s" % (parameter.name, parameter.value))
+            except Exception:
+                pass
+        text = "##  Not dependent paramater.\n"
+        text += "## Those values should be edited following analytical the \n"
+        text += "## analytical expression. Some generator could simply ignore \n"
+        text += "## those values and use the analytical expression\n"
+
+        if lhablock == 'MASS':
+            data = self.dep_mass
+            prefix = " "
+        else:
+            data = self.dep_width
+            prefix = "DECAY "
+        for part, param in data:
+            if isinstance(param.value, str):
+                value = complex(eval(param.value)).real
+            else:
+                value = param.value
+
+            text += """%s %s %f # %s : %s \n""" %(prefix, part.pdg_code,
+                        value, part.name, param.value)
+        self.fsock.write(text)
+
+    sm_pdg = [1,2,3,4,5,6,11,12,13,13,14,15,16,21,22,23,24,25]
+    data="""Block QNUMBERS %(pdg)d  # %(name)s
+        1 %(charge)d  # 3 times electric charge
+        2 %(spin)d  # number of spin states (2S+1)
+        3 %(color)d  # colour rep (1: singlet, 3: triplet, 8: octet)
+        4 %(antipart)d  # Particle/Antiparticle distinction (0=own anti)\n"""
+
+    def write_qnumber(self):
+        """ write qnumber """
+        from .particles import all_particles
+
+        text="""#===========================================================\n"""
+        text += """# QUANTUM NUMBERS OF NEW STATE(S) (NON SM PDG CODE)\n"""
+        text += """#===========================================================\n\n"""
+
+        for part in all_particles:
+            if part.pdg_code in self.sm_pdg or part.pdg_code < 0:
+                continue
+            text += self.data % {'pdg': part.pdg_code,
+                                 'name': part.name,
+                                 'charge': 3 * part.charge,
+                                 'spin': 2 * part.spin + 1,
+                                 'color': part.color,
+                                 'antipart': part.name != part.antiname and 1 or 0}
+
+        self.fsock.write(text)
+
+
+
+
+
+
+
+
+if '__main__' == __name__:
+    ParamCardWriter('./param_card.dat', generic=True)
+    print('write ./param_card.dat')
diff --git a/pyamplicol/src/pyamplicol/assets/prepared_models/__init__.py b/pyamplicol/src/pyamplicol/assets/prepared_models/__init__.py
new file mode 100644
index 0000000000..b5aa349ed2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/prepared_models/__init__.py
@@ -0,0 +1,367 @@
+# SPDX-License-Identifier: 0BSD
+"""Discovery and validation for wheel-owned prepared model bundles."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import tempfile
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import contextmanager
+from importlib import resources
+from pathlib import Path
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from pyamplicol.models.prepared import PreparedModelBundle
+
+BUILTIN_SM_JIT_O2 = "built-in-sm-jit-o2"
+BUILTIN_SM_HEFT_JIT_O2 = "built-in-sm-heft-jit-o2"
+_PACKAGED_ARCHITECTURES = ("aarch64", "x86_64")
+_MODEL_SOURCE_BY_ID = {
+    BUILTIN_SM_JIT_O2: "built-in-sm",
+    BUILTIN_SM_HEFT_JIT_O2: "built-in-sm-heft",
+}
+_KNOWN_MODELS = tuple(_MODEL_SOURCE_BY_ID)
+_METADATA_KEYS = frozenset(
+    {
+        "backend",
+        "bundle",
+        "bundle_sha256",
+        "bundle_size",
+        "build_contract",
+        "dependencies",
+        "eager_kernel_abi",
+        "id",
+        "jit_optimization_level",
+        "kernel_count",
+        "model",
+        "prepared_model_bundle_schema",
+        "producer",
+        "schema_version",
+        "target",
+    }
+)
+
+
+class PackagedPreparedModelError(RuntimeError):
+    """Raised when an installed prepared-model resource is absent or stale."""
+
+
+def available_prepared_models() -> tuple[str, ...]:
+    """Return stable identifiers for prepared models shipped in this wheel."""
+
+    return _KNOWN_MODELS
+
+
+@contextmanager
+def packaged_prepared_model_path(identifier: str) -> Iterator[Path]:
+    """Materialize and validate one packaged bundle for path-based consumers."""
+
+    if identifier not in _KNOWN_MODELS:
+        choices = ", ".join(_KNOWN_MODELS)
+        raise PackagedPreparedModelError(
+            f"unknown packaged prepared model {identifier!r}; available: {choices}"
+        )
+    from pyamplicol.models.prepared_target import (
+        PreparedTargetError,
+        canonical_architecture,
+    )
+
+    try:
+        architecture = canonical_architecture()
+    except PreparedTargetError as error:
+        raise PackagedPreparedModelError(str(error)) from error
+    if architecture not in _PACKAGED_ARCHITECTURES:  # pragma: no cover
+        raise PackagedPreparedModelError(
+            f"no wheel-owned prepared model supports {architecture!r}"
+        )
+    metadata_name, bundle_name = _asset_names(identifier, architecture)
+    root = resources.files(__package__)
+    metadata_resource = root.joinpath(metadata_name)
+    bundle_resource = root.joinpath(bundle_name)
+    try:
+        metadata = _metadata(
+            json.loads(metadata_resource.read_text(encoding="utf-8")),
+            identifier=identifier,
+            bundle_name=bundle_name,
+        )
+    except (
+        FileNotFoundError,
+        OSError,
+        UnicodeDecodeError,
+        json.JSONDecodeError,
+    ) as error:
+        raise PackagedPreparedModelError(
+            f"cannot read packaged prepared-model metadata: {error}"
+        ) from error
+    with resources.as_file(bundle_resource) as path:
+        bundle_path = Path(path)
+        if not bundle_path.is_file() or bundle_path.is_symlink():
+            raise PackagedPreparedModelError(
+                "packaged prepared-model bundle is not a regular file"
+            )
+        data = bundle_path.read_bytes()
+        if metadata.get("bundle_size") != len(data):
+            raise PackagedPreparedModelError(
+                "packaged prepared-model bundle size does not match metadata"
+            )
+        if metadata.get("bundle_sha256") != hashlib.sha256(data).hexdigest():
+            raise PackagedPreparedModelError(
+                "packaged prepared-model bundle SHA-256 does not match metadata"
+            )
+        _validate_bundle(
+            bundle_path,
+            metadata,
+            identifier=identifier,
+            architecture=architecture,
+        )
+        yield bundle_path
+
+
+@contextmanager
+def open_packaged_prepared_model(
+    identifier: str = BUILTIN_SM_JIT_O2,
+) -> Iterator[PreparedModelBundle]:
+    """Open a validated bundle while keeping zip-installed resources alive."""
+
+    from pyamplicol.models.prepared import load_prepared_model_bundle
+
+    with packaged_prepared_model_path(identifier) as path:
+        yield load_prepared_model_bundle(path)
+
+
+def materialize_packaged_prepared_model(
+    identifier: str = BUILTIN_SM_JIT_O2,
+    *,
+    cache_dir: Path | None = None,
+) -> Path:
+    """Return a stable path for a validated wheel-owned prepared model.
+
+    Installed wheels normally expose resources as ordinary files, but the
+    resource API also permits transient extraction from archive importers.
+    Eager generation retains the bundle path while it copies referenced
+    kernels into the process artifact, so materialize one content-addressed
+    cache entry instead of leaking a temporary resource path.
+    """
+
+    with packaged_prepared_model_path(identifier) as source:
+        bundle_name = source.name
+        data = source.read_bytes()
+    digest = hashlib.sha256(data).hexdigest()
+    if cache_dir is None:
+        from platformdirs import user_cache_path
+
+        root = user_cache_path("pyamplicol") / "prepared_models" / digest
+    else:
+        root = Path(cache_dir).expanduser().resolve(strict=False) / digest
+    root.mkdir(parents=True, exist_ok=True)
+    if root.is_symlink() or not root.is_dir():
+        raise PackagedPreparedModelError(
+            "packaged prepared-model cache must be a regular directory"
+        )
+    output = root / bundle_name
+    if output.exists():
+        if output.is_symlink() or not output.is_file():
+            raise PackagedPreparedModelError(
+                "packaged prepared-model cache entry must be a regular file"
+            )
+        if hashlib.sha256(output.read_bytes()).hexdigest() == digest:
+            return output
+
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{bundle_name}.",
+        suffix=".tmp",
+        dir=root,
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        temporary.replace(output)
+    finally:
+        temporary.unlink(missing_ok=True)
+    if hashlib.sha256(output.read_bytes()).hexdigest() != digest:
+        raise PackagedPreparedModelError(
+            "materialized prepared-model cache entry has a SHA-256 mismatch"
+        )
+    return output
+
+
+def _validate_bundle(
+    path: Path,
+    metadata: Mapping[str, object],
+    *,
+    identifier: str,
+    architecture: str,
+) -> None:
+    from pyamplicol._internal.versions import (
+        COMPILED_MODEL_SCHEMA_VERSION,
+        SYMBOLICA_SERIALIZATION_ABI,
+        SYMJIT_APPLICATION_ABI,
+        SYMJIT_PLANE_APPLICATION_ABI,
+    )
+    from pyamplicol.models.loading import MODEL_COMPILER_VERSION, compiler_fingerprint
+    from pyamplicol.models.prepared import (
+        EAGER_KERNEL_ABI,
+        PREPARED_MODEL_BUNDLE_SCHEMA_VERSION,
+        load_prepared_model_bundle,
+    )
+    from pyamplicol.models.prepared_target import symjit_storage_v3_target
+
+    try:
+        bundle = load_prepared_model_bundle(path)
+    except (OSError, TypeError, ValueError) as error:
+        raise PackagedPreparedModelError(
+            f"packaged prepared-model bundle is invalid: {error}"
+        ) from error
+    pack = bundle.kernel_pack
+    producer = _mapping(metadata.get("producer"), "metadata.producer")
+    dependencies = _mapping(metadata.get("dependencies"), "metadata.dependencies")
+    compiled_producer = _mapping(
+        bundle.compiled_model.get("producer"), "compiled_model.producer"
+    )
+    compiled_source = _mapping(
+        bundle.compiled_model.get("source"), "compiled_model.source"
+    )
+    fingerprint = compiler_fingerprint()
+    expected = {
+        "compiled_model_schema": COMPILED_MODEL_SCHEMA_VERSION,
+        "model_compiler_version": MODEL_COMPILER_VERSION,
+    }
+    for key, value in expected.items():
+        if producer.get(key) != value:
+            raise PackagedPreparedModelError(
+                f"packaged prepared-model producer {key} is stale: "
+                f"expected {value!r}, got {producer.get(key)!r}"
+            )
+    packaged_package_version = producer.get("package_version")
+    if compiled_producer.get("pyamplicol") != packaged_package_version:
+        raise PackagedPreparedModelError(
+            "prepared compiled-model package version disagrees with metadata"
+        )
+    if (
+        compiled_producer.get("compiled_model_schema_version")
+        != expected["compiled_model_schema"]
+    ):
+        raise PackagedPreparedModelError("prepared compiled-model schema is stale")
+    if (
+        compiled_producer.get("model_compiler_version")
+        != expected["model_compiler_version"]
+    ):
+        raise PackagedPreparedModelError("prepared model compiler version is stale")
+    model_source = _MODEL_SOURCE_BY_ID[identifier]
+    if compiled_source.get("kind") != model_source:
+        raise PackagedPreparedModelError(f"prepared model source is not {model_source}")
+    if pack.producer.get("version") != packaged_package_version:
+        raise PackagedPreparedModelError(
+            "prepared kernel-pack package version disagrees with metadata"
+        )
+    dependency_expected = {
+        "symbolica_version": fingerprint["symbolica"],
+        "ufo_model_loader_version": fingerprint["ufo_model_loader"],
+        "symbolica_serialization_abi": SYMBOLICA_SERIALIZATION_ABI,
+        "symjit_application_abi": SYMJIT_APPLICATION_ABI,
+        "symjit_plane_application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+    }
+    for key, value in dependency_expected.items():
+        if dependencies.get(key) != value:
+            raise PackagedPreparedModelError(
+                f"packaged prepared-model dependency {key} is stale"
+            )
+    pack_dependencies = {
+        "symbolica_version": dependencies["symbolica_version"],
+        "symbolica_serialization": dependencies["symbolica_serialization_abi"],
+        "symjit_application": dependencies["symjit_application_abi"],
+        "symjit_plane_application": dependencies["symjit_plane_application_abi"],
+    }
+    for key, value in pack_dependencies.items():
+        if pack.dependency_abis.get(key) != value:
+            raise PackagedPreparedModelError(
+                f"prepared kernel-pack dependency {key} is stale"
+            )
+    if metadata.get("eager_kernel_abi") != EAGER_KERNEL_ABI:
+        raise PackagedPreparedModelError("packaged eager kernel ABI is stale")
+    if (
+        metadata.get("prepared_model_bundle_schema")
+        != PREPARED_MODEL_BUNDLE_SCHEMA_VERSION
+    ):
+        raise PackagedPreparedModelError("packaged model bundle schema is stale")
+    if metadata.get("backend") != "jit" or bundle.backend != "jit":
+        raise PackagedPreparedModelError("packaged built-in model is not JIT-backed")
+    if metadata.get("jit_optimization_level") != 2:
+        raise PackagedPreparedModelError(
+            "packaged built-in model is not portable JIT O2"
+        )
+    if pack.optimization_settings.get("jit_optimization_level") != 2:
+        raise PackagedPreparedModelError("prepared kernel pack is not portable JIT O2")
+    if metadata.get("kernel_count") != len(pack.kernels) or not pack.kernels:
+        raise PackagedPreparedModelError(
+            "packaged prepared-model kernel count is invalid"
+        )
+    target = _plain_json(pack.target)
+    expected_target = symjit_storage_v3_target(machine=architecture)
+    if target != metadata.get("target") or target != expected_target:
+        raise PackagedPreparedModelError(
+            "packaged prepared model target does not match its architecture asset"
+        )
+
+
+def _metadata(
+    value: object,
+    *,
+    identifier: str,
+    bundle_name: str,
+) -> Mapping[str, object]:
+    metadata = _mapping(value, "prepared-model metadata")
+    missing = _METADATA_KEYS - metadata.keys()
+    unknown = metadata.keys() - _METADATA_KEYS
+    if missing or unknown:
+        raise PackagedPreparedModelError(
+            "packaged prepared-model metadata fields are invalid"
+        )
+    if metadata.get("schema_version") != 1:
+        raise PackagedPreparedModelError(
+            "unsupported packaged prepared-model metadata schema"
+        )
+    if metadata.get("id") != identifier:
+        raise PackagedPreparedModelError("packaged prepared-model identity is invalid")
+    if (
+        metadata.get("model") != _MODEL_SOURCE_BY_ID[identifier]
+        or metadata.get("bundle") != bundle_name
+    ):
+        raise PackagedPreparedModelError("packaged prepared-model resource is invalid")
+    return metadata
+
+
+def _asset_names(identifier: str, architecture: str) -> tuple[str, str]:
+    stem = f"{identifier}-{architecture}"
+    return f"{stem}.metadata.json", f"{stem}.pyamplicol-model"
+
+
+def _mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):
+        raise PackagedPreparedModelError(f"{context} must be an object")
+    return cast(Mapping[str, object], value)
+
+
+def _plain_json(value: object) -> object:
+    if isinstance(value, Mapping):
+        return {str(key): _plain_json(item) for key, item in value.items()}
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return [_plain_json(item) for item in value]
+    return value
+
+
+__all__ = [
+    "BUILTIN_SM_HEFT_JIT_O2",
+    "BUILTIN_SM_JIT_O2",
+    "PackagedPreparedModelError",
+    "available_prepared_models",
+    "materialize_packaged_prepared_model",
+    "open_packaged_prepared_model",
+    "packaged_prepared_model_path",
+]
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/c/Makefile b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/c/Makefile
new file mode 100644
index 0000000000..4c0d18953f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/c/Makefile
@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: 0BSD
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell \
+	if command -v "$(RUSTICOL_CONFIG)" >/dev/null 2>&1; then \
+		command -v "$(RUSTICOL_CONFIG)"; \
+	elif [ "$(RUSTICOL_CONFIG)" = rusticol-config ]; then \
+		directory="$(CURDIR)"; \
+		while [ "$$directory" != / ]; do \
+			candidate="$$directory/.venv/bin/rusticol-config"; \
+			if [ -x "$$candidate" ]; then printf '%s\n' "$$candidate"; break; fi; \
+			directory=$$(dirname "$$directory"); \
+		done; \
+	fi)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+CC ?= cc
+ARTIFACT_DIR := $(abspath ../..)
+BUILD_DIR ?= $(abspath ../../..)/.pyamplicol-api-build/$(notdir $(ARTIFACT_DIR))/c
+TARGET := $(BUILD_DIR)/check_standalone
+CPPFLAGS += $(shell "$(RUSTICOL_CONFIG_PATH)" --cflags)
+CFLAGS ?= -O2
+CFLAGS += -std=c11 -Wall -Wextra -pedantic
+LDLIBS += $(shell "$(RUSTICOL_CONFIG_PATH)" --libs)
+
+.PHONY: all check_standalone clean run
+
+all: $(TARGET)
+
+check_standalone: $(TARGET)
+
+$(BUILD_DIR):
+	mkdir -p "$@"
+
+$(TARGET): check_standalone.c | $(BUILD_DIR)
+	$(CC) $(CPPFLAGS) $(CFLAGS) "$<" -o "$@" $(LDLIBS)
+
+run: $(TARGET)
+	cd "$(ARTIFACT_DIR)" && "$(TARGET)" $(ARGS)
+
+clean:
+	$(RM) "$(TARGET)"
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/c/check_standalone.c b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/c/check_standalone.c
new file mode 100644
index 0000000000..defccd3210
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/c/check_standalone.c
@@ -0,0 +1,885 @@
+/* SPDX-License-Identifier: 0BSD */
+
+#include <rusticol.h>
+
+#include <errno.h>
+#include <inttypes.h>
+#include <math.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAX_OVERRIDES 128
+
+typedef struct {
+    const char *process;
+    const char *model_parameters;
+    const char *kinematics;
+    const char *parameter_names[MAX_OVERRIDES];
+    double parameter_real[MAX_OVERRIDES];
+    double parameter_imaginary[MAX_OVERRIDES];
+    size_t parameter_count;
+    int precision;
+    bool json;
+} Options;
+
+typedef struct {
+    char *id;
+    int32_t *values;
+    size_t value_count;
+} HelicityMetadata;
+
+typedef struct {
+    char *id;
+    char *kind;
+    size_t *word;
+    size_t word_count;
+} ColorMetadata;
+
+typedef int (*RuntimeStringGetter)(
+    const RusticolRuntimeHandle *, char *, size_t, size_t *
+);
+typedef int (*IndexedStringGetter)(
+    const RusticolRuntimeHandle *, size_t, char *, size_t, size_t *
+);
+
+static void fail(const char *message) {
+    fprintf(stderr, "check_standalone: %s\n", message);
+    exit(EXIT_FAILURE);
+}
+
+static void fail_errno(const char *operation) {
+    fprintf(stderr, "check_standalone: %s: %s\n", operation, strerror(errno));
+    exit(EXIT_FAILURE);
+}
+
+static void *allocate(size_t count, size_t size) {
+    void *output;
+    if (count != 0 && size > SIZE_MAX / count) {
+        fail("allocation size overflow");
+    }
+    output = calloc(count == 0 ? 1 : count, size == 0 ? 1 : size);
+    if (output == NULL) {
+        fail("out of memory");
+    }
+    return output;
+}
+
+static void *resize(void *pointer, size_t size) {
+    void *output = realloc(pointer, size == 0 ? 1 : size);
+    if (output == NULL) {
+        free(pointer);
+        fail("out of memory");
+    }
+    return output;
+}
+
+static void check_rusticol(int status, const char *operation) {
+    size_t required = 0;
+    char *message = NULL;
+    if (status == RUSTICOL_STATUS_OK) {
+        return;
+    }
+    if (rusticol_last_error_message(NULL, 0, &required) == RUSTICOL_STATUS_OK &&
+        required > 0) {
+        message = allocate(required, sizeof(*message));
+        if (rusticol_last_error_message(message, required, &required) !=
+            RUSTICOL_STATUS_OK) {
+            free(message);
+            message = NULL;
+        }
+    }
+    fprintf(
+        stderr,
+        "check_standalone: %s failed (status %d)%s%s\n",
+        operation,
+        status,
+        message == NULL ? "" : ": ",
+        message == NULL ? "" : message
+    );
+    free(message);
+    exit(EXIT_FAILURE);
+}
+
+static double parse_double(const char *text, const char *description) {
+    char *end = NULL;
+    double value;
+    errno = 0;
+    value = strtod(text, &end);
+    if (text == end || end == NULL || *end != '\0' || errno == ERANGE ||
+        !isfinite(value)) {
+        fprintf(stderr, "check_standalone: invalid %s: %s\n", description, text);
+        exit(EXIT_FAILURE);
+    }
+    return value;
+}
+
+static size_t parse_size(const char *text, const char *description) {
+    char *end = NULL;
+    unsigned long long value;
+    errno = 0;
+    value = strtoull(text, &end, 10);
+    if (text == end || end == NULL || *end != '\0' || errno == ERANGE ||
+        value > SIZE_MAX) {
+        fprintf(stderr, "check_standalone: invalid %s: %s\n", description, text);
+        exit(EXIT_FAILURE);
+    }
+    return (size_t)value;
+}
+
+static Options parse_options(int argc, char **argv) {
+    Options options = {0};
+    int index;
+    options.precision = 16;
+    for (index = 1; index < argc; ++index) {
+        const char *argument = argv[index];
+        if (strcmp(argument, "--") == 0) {
+            continue;
+        }
+        if (strcmp(argument, "--process") == 0) {
+            if (++index >= argc) {
+                fail("missing value after --process");
+            }
+            options.process = argv[index];
+        } else if (strcmp(argument, "--model-parameters") == 0) {
+            if (++index >= argc) {
+                fail("missing value after --model-parameters");
+            }
+            options.model_parameters = argv[index];
+        } else if (strcmp(argument, "--kinematics") == 0) {
+            if (++index >= argc) {
+                fail("missing value after --kinematics");
+            }
+            options.kinematics = argv[index];
+        } else if (strcmp(argument, "--set-parameter") == 0) {
+            size_t slot = options.parameter_count;
+            if (index + 3 >= argc) {
+                fail("--set-parameter requires NAME REAL IMAG");
+            }
+            if (slot >= MAX_OVERRIDES) {
+                fail("too many --set-parameter options");
+            }
+            options.parameter_names[slot] = argv[++index];
+            options.parameter_real[slot] =
+                parse_double(argv[++index], "real model-parameter component");
+            options.parameter_imaginary[slot] =
+                parse_double(argv[++index], "imaginary model-parameter component");
+            options.parameter_count += 1;
+        } else if (strcmp(argument, "--precision") == 0) {
+            size_t precision;
+            if (++index >= argc) {
+                fail("missing value after --precision");
+            }
+            precision = parse_size(argv[index], "--precision value");
+            if (precision > INT32_MAX) {
+                fail("invalid --precision value");
+            }
+            options.precision = (int)precision;
+        } else if (strcmp(argument, "--json") == 0) {
+            options.json = true;
+        } else if (strcmp(argument, "--help") == 0 || strcmp(argument, "-h") == 0) {
+            puts(
+                "usage: check_standalone [--process ID|EXPRESSION] "
+                "[--model-parameters PATH] "
+                "[--kinematics PATH] "
+                "[--set-parameter NAME REAL IMAG] "
+                "[--precision 16] [--json]"
+            );
+            exit(EXIT_SUCCESS);
+        } else {
+            fprintf(stderr, "check_standalone: unknown option: %s\n", argument);
+            exit(EXIT_FAILURE);
+        }
+    }
+    if (options.precision != 16) {
+        fail("the C Rusticol API supports only double precision (--precision 16)");
+    }
+    return options;
+}
+
+static char *runtime_string(
+    const RusticolRuntimeHandle *runtime,
+    RuntimeStringGetter getter,
+    const char *operation
+) {
+    size_t required = 0;
+    char *output;
+    check_rusticol(getter(runtime, NULL, 0, &required), operation);
+    if (required == 0) {
+        fail("Rusticol returned an invalid string size");
+    }
+    output = allocate(required, sizeof(*output));
+    check_rusticol(getter(runtime, output, required, &required), operation);
+    return output;
+}
+
+static char *indexed_string(
+    const RusticolRuntimeHandle *runtime,
+    size_t index,
+    IndexedStringGetter getter,
+    const char *operation
+) {
+    size_t required = 0;
+    char *output;
+    check_rusticol(getter(runtime, index, NULL, 0, &required), operation);
+    if (required == 0) {
+        fail("Rusticol returned an invalid indexed string size");
+    }
+    output = allocate(required, sizeof(*output));
+    check_rusticol(getter(runtime, index, output, required, &required), operation);
+    return output;
+}
+
+static char *read_line(FILE *stream) {
+    size_t capacity = 256;
+    size_t length = 0;
+    char *line = allocate(capacity, sizeof(*line));
+    int character;
+    while ((character = fgetc(stream)) != EOF && character != '\n') {
+        if (length + 1 >= capacity) {
+            if (capacity > SIZE_MAX / 2) {
+                free(line);
+                fail("validation-point row is too large");
+            }
+            capacity *= 2;
+            line = resize(line, capacity);
+        }
+        line[length++] = (char)character;
+    }
+    if (ferror(stream)) {
+        free(line);
+        fail_errno("read API/validation_points.dat");
+    }
+    if (character == EOF && length == 0) {
+        free(line);
+        return NULL;
+    }
+    if (length > 0 && line[length - 1] == '\r') {
+        length -= 1;
+    }
+    line[length] = '\0';
+    return line;
+}
+
+static char *take_field(char **cursor) {
+    char *field;
+    char *separator;
+    if (*cursor == NULL) {
+        return NULL;
+    }
+    field = *cursor;
+    separator = strchr(field, '\t');
+    if (separator == NULL) {
+        *cursor = NULL;
+    } else {
+        *separator = '\0';
+        *cursor = separator + 1;
+    }
+    return field;
+}
+
+static double *load_validation_point(
+    const char *path,
+    const char *process_key,
+    size_t external_count
+) {
+    FILE *input = fopen(path, "r");
+    char *line;
+    if (input == NULL) {
+        if (errno == ENOENT) {
+            return NULL;
+        }
+        fail_errno("open API/validation_points.dat");
+    }
+    line = read_line(input);
+    if (line == NULL || strcmp(line, "RUSTICOL_VALIDATION_POINTS_V1") != 0) {
+        free(line);
+        fclose(input);
+        fail("unsupported validation_points.dat format");
+    }
+    free(line);
+
+    while ((line = read_line(input)) != NULL) {
+        char *cursor = line;
+        char *row_process;
+        char *row_count_text;
+        size_t row_count;
+        size_t momentum_count;
+        size_t index;
+        double *momenta;
+        if (line[0] == '\0' || line[0] == '#') {
+            free(line);
+            continue;
+        }
+        row_process = take_field(&cursor);
+        row_count_text = take_field(&cursor);
+        if (row_process == NULL || row_count_text == NULL) {
+            free(line);
+            fclose(input);
+            fail("invalid validation point row");
+        }
+        if (strcmp(row_process, process_key) != 0) {
+            free(line);
+            continue;
+        }
+        row_count = parse_size(row_count_text, "validation external-particle count");
+        if (row_count != external_count || external_count > SIZE_MAX / 4) {
+            free(line);
+            fclose(input);
+            fail("validation point has an incompatible external-particle count");
+        }
+        momentum_count = 4 * external_count;
+        momenta = allocate(momentum_count, sizeof(*momenta));
+        for (index = 0; index < momentum_count; ++index) {
+            char *component = take_field(&cursor);
+            if (component == NULL) {
+                free(momenta);
+                free(line);
+                fclose(input);
+                fail("validation point has too few momentum components");
+            }
+            momenta[index] =
+                parse_double(component, "validation-point momentum component");
+        }
+        if (cursor != NULL) {
+            free(momenta);
+            free(line);
+            fclose(input);
+            fail("validation point has too many momentum components");
+        }
+        free(line);
+        if (fclose(input) != 0) {
+            free(momenta);
+            fail_errno("close API/validation_points.dat");
+        }
+        return momenta;
+    }
+    if (fclose(input) != 0) {
+        fail_errno("close API/validation_points.dat");
+    }
+    return NULL;
+}
+
+static size_t *load_external_permutation(
+    const RusticolRuntimeHandle *runtime,
+    size_t expected_count
+) {
+    size_t required = 0;
+    size_t *permutation;
+    check_rusticol(
+        rusticol_runtime_external_permutation(runtime, NULL, 0, &required),
+        "query external permutation size"
+    );
+    if (required != expected_count) {
+        fail("external permutation has an incompatible size");
+    }
+    permutation = allocate(required, sizeof(*permutation));
+    check_rusticol(
+        rusticol_runtime_external_permutation(
+            runtime, permutation, required, &required
+        ),
+        "query external permutation"
+    );
+    return permutation;
+}
+
+static double *reorder_validation_point(
+    double *representative,
+    const size_t *permutation,
+    size_t external_count
+) {
+    double *public_point = allocate(4 * external_count, sizeof(*public_point));
+    bool *seen = allocate(external_count, sizeof(*seen));
+    size_t representative_index;
+    for (representative_index = 0; representative_index < external_count;
+         ++representative_index) {
+        size_t public_index = permutation[representative_index];
+        if (public_index >= external_count || seen[public_index]) {
+            free(seen);
+            free(public_point);
+            free(representative);
+            fail("runtime returned an invalid external permutation");
+        }
+        seen[public_index] = true;
+        memcpy(
+            &public_point[4 * public_index],
+            &representative[4 * representative_index],
+            4 * sizeof(*public_point)
+        );
+    }
+    free(seen);
+    free(representative);
+    return public_point;
+}
+
+static double *load_kinematics_json(
+    const RusticolRuntimeHandle *runtime,
+    const char *path,
+    size_t expected_count
+) {
+    size_t required = 0;
+    double *momenta;
+    check_rusticol(
+        rusticol_runtime_load_kinematics_json(
+            runtime, path, NULL, 0, &required
+        ),
+        "query kinematics JSON size"
+    );
+    if (required != 4 * expected_count) {
+        fail("kinematics JSON has an incompatible external-particle count");
+    }
+    momenta = allocate(required, sizeof(*momenta));
+    check_rusticol(
+        rusticol_runtime_load_kinematics_json(
+            runtime, path, momenta, required, &required
+        ),
+        "load kinematics JSON"
+    );
+    return momenta;
+}
+
+static int32_t *load_external_particles(
+    const RusticolRuntimeHandle *runtime,
+    size_t *count
+) {
+    int32_t *particles;
+    size_t index;
+    check_rusticol(
+        rusticol_runtime_external_count(runtime, count),
+        "query external-particle count"
+    );
+    particles = allocate(*count, sizeof(*particles));
+    for (index = 0; index < *count; ++index) {
+        check_rusticol(
+            rusticol_runtime_external_pdg(runtime, index, &particles[index]),
+            "query external-particle PDG"
+        );
+    }
+    return particles;
+}
+
+static HelicityMetadata *load_helicities(
+    const RusticolRuntimeHandle *runtime,
+    size_t *count
+) {
+    HelicityMetadata *items;
+    size_t index;
+    check_rusticol(
+        rusticol_runtime_helicity_count(runtime, count),
+        "query helicity count"
+    );
+    items = allocate(*count, sizeof(*items));
+    for (index = 0; index < *count; ++index) {
+        items[index].id = indexed_string(
+            runtime,
+            index,
+            rusticol_runtime_helicity_id,
+            "query helicity ID"
+        );
+        check_rusticol(
+            rusticol_runtime_helicity_vector(
+                runtime, index, NULL, 0, &items[index].value_count
+            ),
+            "query helicity-vector size"
+        );
+        items[index].values =
+            allocate(items[index].value_count, sizeof(*items[index].values));
+        if (items[index].value_count > 0) {
+            check_rusticol(
+                rusticol_runtime_helicity_vector(
+                    runtime,
+                    index,
+                    items[index].values,
+                    items[index].value_count,
+                    &items[index].value_count
+                ),
+                "query helicity vector"
+            );
+        }
+    }
+    return items;
+}
+
+static ColorMetadata *load_colors(
+    const RusticolRuntimeHandle *runtime,
+    size_t *count
+) {
+    ColorMetadata *items;
+    size_t index;
+    check_rusticol(rusticol_runtime_color_count(runtime, count), "query color count");
+    items = allocate(*count, sizeof(*items));
+    for (index = 0; index < *count; ++index) {
+        items[index].id = indexed_string(
+            runtime, index, rusticol_runtime_color_id, "query color ID"
+        );
+        items[index].kind = indexed_string(
+            runtime, index, rusticol_runtime_color_kind, "query color kind"
+        );
+        check_rusticol(
+            rusticol_runtime_color_word(
+                runtime, index, NULL, 0, &items[index].word_count
+            ),
+            "query color-word size"
+        );
+        items[index].word =
+            allocate(items[index].word_count, sizeof(*items[index].word));
+        if (items[index].word_count > 0) {
+            check_rusticol(
+                rusticol_runtime_color_word(
+                    runtime,
+                    index,
+                    items[index].word,
+                    items[index].word_count,
+                    &items[index].word_count
+                ),
+                "query color word"
+            );
+        }
+    }
+    return items;
+}
+
+static void write_json_string(const char *value) {
+    const unsigned char *cursor = (const unsigned char *)value;
+    putchar('"');
+    while (*cursor != '\0') {
+        unsigned char character = *cursor++;
+        switch (character) {
+        case '"': fputs("\\\"", stdout); break;
+        case '\\': fputs("\\\\", stdout); break;
+        case '\b': fputs("\\b", stdout); break;
+        case '\f': fputs("\\f", stdout); break;
+        case '\n': fputs("\\n", stdout); break;
+        case '\r': fputs("\\r", stdout); break;
+        case '\t': fputs("\\t", stdout); break;
+        default:
+            if (character < 0x20) {
+                printf("\\u%04x", (unsigned int)character);
+            } else {
+                putchar((int)character);
+            }
+        }
+    }
+    putchar('"');
+}
+
+static void write_common_json(
+    const char *process,
+    const char *process_key,
+    const char *color_accuracy,
+    const int32_t *particles,
+    size_t particle_count,
+    const HelicityMetadata *helicities,
+    size_t helicity_count,
+    const ColorMetadata *colors,
+    size_t color_count
+) {
+    size_t index;
+    fputs("\"process\":", stdout);
+    write_json_string(process);
+    fputs(",\"process_key\":", stdout);
+    write_json_string(process_key);
+    fputs(",\"color_accuracy\":", stdout);
+    write_json_string(color_accuracy);
+    fputs(",\"external_particles\":[", stdout);
+    for (index = 0; index < particle_count; ++index) {
+        if (index != 0) {
+            putchar(',');
+        }
+        printf("{\"index\":%zu,\"pdg\":%" PRId32 "}", index, particles[index]);
+    }
+    fputs("],\"helicities\":[", stdout);
+    for (index = 0; index < helicity_count; ++index) {
+        size_t component;
+        if (index != 0) {
+            putchar(',');
+        }
+        fputs("{\"id\":", stdout);
+        write_json_string(helicities[index].id);
+        fputs(",\"helicities\":[", stdout);
+        for (component = 0; component < helicities[index].value_count; ++component) {
+            if (component != 0) {
+                putchar(',');
+            }
+            printf("%" PRId32, helicities[index].values[component]);
+        }
+        fputs("]}", stdout);
+    }
+    fputs("],\"colors\":[", stdout);
+    for (index = 0; index < color_count; ++index) {
+        size_t component;
+        if (index != 0) {
+            putchar(',');
+        }
+        fputs("{\"id\":", stdout);
+        write_json_string(colors[index].id);
+        fputs(",\"kind\":", stdout);
+        write_json_string(colors[index].kind);
+        fputs(",\"word\":[", stdout);
+        for (component = 0; component < colors[index].word_count; ++component) {
+            if (component != 0) {
+                putchar(',');
+            }
+            printf("%zu", colors[index].word[component]);
+        }
+        fputs("]}", stdout);
+    }
+    putchar(']');
+}
+
+static void free_helicities(HelicityMetadata *items, size_t count) {
+    size_t index;
+    for (index = 0; index < count; ++index) {
+        free(items[index].id);
+        free(items[index].values);
+    }
+    free(items);
+}
+
+static void free_colors(ColorMetadata *items, size_t count) {
+    size_t index;
+    for (index = 0; index < count; ++index) {
+        free(items[index].id);
+        free(items[index].kind);
+        free(items[index].word);
+    }
+    free(items);
+}
+
+int main(int argc, char **argv) {
+    Options options = parse_options(argc, argv);
+    RusticolRuntimeHandle *runtime = NULL;
+    FILE *manifest;
+    char *process;
+    char *process_key;
+    char *representative_process_key;
+    char *color_accuracy;
+    int32_t *particles;
+    HelicityMetadata *helicities;
+    ColorMetadata *colors;
+    size_t particle_count = 0;
+    size_t helicity_count = 0;
+    size_t color_count = 0;
+    double *momenta;
+    size_t *external_permutation = NULL;
+    double total = NAN;
+    double *resolved = NULL;
+    size_t resolved_helicity_count = 0;
+    size_t resolved_color_count = 0;
+    size_t resolved_count;
+    double explicit_total = 0.0;
+    size_t index;
+
+    manifest = fopen("artifact.json", "r");
+    if (manifest == NULL) {
+        fail("run check_standalone from a generated artifact directory");
+    }
+    if (fclose(manifest) != 0) {
+        fail_errno("close artifact.json");
+    }
+
+    check_rusticol(
+        rusticol_runtime_load(
+            ".", options.process, options.model_parameters, &runtime
+        ),
+        "load artifact"
+    );
+    if (options.parameter_count > 0) {
+        check_rusticol(
+            rusticol_runtime_set_model_parameters(
+                runtime,
+                options.parameter_names,
+                options.parameter_real,
+                options.parameter_imaginary,
+                options.parameter_count
+            ),
+            "set model parameters"
+        );
+    }
+
+    process = runtime_string(runtime, rusticol_runtime_process, "query process");
+    process_key =
+        runtime_string(runtime, rusticol_runtime_process_key, "query process key");
+    representative_process_key = runtime_string(
+        runtime,
+        rusticol_runtime_representative_process_key,
+        "query representative process key"
+    );
+    color_accuracy = runtime_string(
+        runtime, rusticol_runtime_color_accuracy, "query color accuracy"
+    );
+    particles = load_external_particles(runtime, &particle_count);
+    helicities = load_helicities(runtime, &helicity_count);
+    colors = load_colors(runtime, &color_count);
+    if (options.kinematics != NULL) {
+        momenta = load_kinematics_json(runtime, options.kinematics, particle_count);
+    } else {
+        external_permutation = load_external_permutation(runtime, particle_count);
+        momenta = load_validation_point(
+            "API/validation_points.dat", representative_process_key, particle_count
+        );
+        if (momenta != NULL) {
+            momenta = reorder_validation_point(
+                momenta, external_permutation, particle_count
+            );
+        }
+    }
+
+    if (momenta == NULL) {
+        if (options.json) {
+            fputs("{\"language\":\"c\",\"available\":false,", stdout);
+            write_common_json(
+                process,
+                process_key,
+                color_accuracy,
+                particles,
+                particle_count,
+                helicities,
+                helicity_count,
+                colors,
+                color_count
+            );
+            fputs(
+                ",\"diagnostic\":\"no bundled validation point is available\"}\n",
+                stdout
+            );
+        } else {
+            printf("process: %s\n", process);
+            puts("no bundled validation point is available; metadata load succeeded");
+        }
+    } else {
+        check_rusticol(
+            rusticol_runtime_evaluate_f64(
+                runtime, momenta, 4 * particle_count, 1, &total, 1
+            ),
+            "evaluate compatibility total"
+        );
+        check_rusticol(
+            rusticol_runtime_resolved_shape(
+                runtime,
+                NULL,
+                0,
+                NULL,
+                0,
+                &resolved_helicity_count,
+                &resolved_color_count
+            ),
+            "query resolved shape"
+        );
+        if (resolved_helicity_count != helicity_count ||
+            resolved_color_count != color_count) {
+            fail("resolved shape does not match runtime metadata");
+        }
+        if (resolved_helicity_count != 0 &&
+            resolved_color_count > SIZE_MAX / resolved_helicity_count) {
+            fail("resolved output size overflow");
+        }
+        resolved_count = resolved_helicity_count * resolved_color_count;
+        resolved = allocate(resolved_count, sizeof(*resolved));
+        check_rusticol(
+            rusticol_runtime_evaluate_resolved_f64(
+                runtime,
+                momenta,
+                4 * particle_count,
+                1,
+                NULL,
+                0,
+                NULL,
+                0,
+                resolved,
+                resolved_count,
+                &resolved_helicity_count,
+                &resolved_color_count
+            ),
+            "evaluate resolved components"
+        );
+        if (!isfinite(total)) {
+            fail("matrix-element total is not finite");
+        }
+        for (index = 0; index < resolved_count; ++index) {
+            if (!isfinite(resolved[index])) {
+                fail("resolved matrix-element output is not finite");
+            }
+            explicit_total += resolved[index];
+        }
+
+        if (options.json) {
+            fputs(
+                "{\"language\":\"c\",\"available\":true,\"precision\":16,",
+                stdout
+            );
+            write_common_json(
+                process,
+                process_key,
+                color_accuracy,
+                particles,
+                particle_count,
+                helicities,
+                helicity_count,
+                colors,
+                color_count
+            );
+            printf(
+                ",\"shape\":[1,%zu,%zu],\"values\":[",
+                resolved_helicity_count,
+                resolved_color_count
+            );
+            for (index = 0; index < resolved_count; ++index) {
+                if (index != 0) {
+                    putchar(',');
+                }
+                printf("%.17g", resolved[index]);
+            }
+            printf(
+                "],\"resolved_sum\":[%.17g],\"compatibility_total\":[%.17g]}\n",
+                explicit_total,
+                total
+            );
+        } else {
+            size_t helicity_index;
+            size_t color_index;
+            printf("process: %s [%s]\n", process, process_key);
+            printf(
+                "resolved shape: (1, %zu, %zu)\n",
+                resolved_helicity_count,
+                resolved_color_count
+            );
+            for (helicity_index = 0;
+                 helicity_index < resolved_helicity_count;
+                 ++helicity_index) {
+                for (color_index = 0; color_index < resolved_color_count; ++color_index) {
+                    size_t offset =
+                        helicity_index * resolved_color_count + color_index;
+                    printf(
+                        "  %s  %s  %.17g\n",
+                        helicities[helicity_index].id,
+                        colors[color_index].id,
+                        resolved[offset]
+                    );
+                }
+            }
+            printf("explicit resolved sum: %.17g\n", explicit_total);
+            printf("compatibility total:   %.17g\n", total);
+        }
+        if (!isfinite(explicit_total) ||
+            fabs(explicit_total - total) > 1.0e-12 * fmax(fabs(total), 1.0)) {
+            fail("resolved components do not reproduce the compatibility total");
+        }
+    }
+
+    check_rusticol(rusticol_runtime_free(runtime), "free runtime");
+    free(momenta);
+    free(resolved);
+    free(process);
+    free(process_key);
+    free(representative_process_key);
+    free(external_permutation);
+    free(color_accuracy);
+    free(particles);
+    free_helicities(helicities, helicity_count);
+    free_colors(colors, color_count);
+    return EXIT_SUCCESS;
+}
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/cpp/Makefile b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/cpp/Makefile
new file mode 100644
index 0000000000..3edf40f252
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/cpp/Makefile
@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: 0BSD
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell \
+	if command -v "$(RUSTICOL_CONFIG)" >/dev/null 2>&1; then \
+		command -v "$(RUSTICOL_CONFIG)"; \
+	elif [ "$(RUSTICOL_CONFIG)" = rusticol-config ]; then \
+		directory="$(CURDIR)"; \
+		while [ "$$directory" != / ]; do \
+			candidate="$$directory/.venv/bin/rusticol-config"; \
+			if [ -x "$$candidate" ]; then printf '%s\n' "$$candidate"; break; fi; \
+			directory=$$(dirname "$$directory"); \
+		done; \
+	fi)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+CXX ?= c++
+ARTIFACT_DIR := $(abspath ../..)
+BUILD_DIR ?= $(abspath ../../..)/.pyamplicol-api-build/$(notdir $(ARTIFACT_DIR))/cpp
+TARGET := $(BUILD_DIR)/check_standalone
+CPPFLAGS += $(shell "$(RUSTICOL_CONFIG_PATH)" --cflags)
+CXXFLAGS ?= -O2
+CXXFLAGS += -std=c++17 -Wall -Wextra -pedantic
+LDLIBS += $(shell "$(RUSTICOL_CONFIG_PATH)" --libs)
+
+.PHONY: all check_standalone clean run
+
+all: $(TARGET)
+
+check_standalone: $(TARGET)
+
+$(BUILD_DIR):
+	mkdir -p "$@"
+
+$(TARGET): check_standalone.cpp | $(BUILD_DIR)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) "$<" -o "$@" $(LDLIBS)
+
+run: $(TARGET)
+	cd "$(ARTIFACT_DIR)" && "$(TARGET)" $(ARGS)
+
+clean:
+	$(RM) "$(TARGET)"
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/cpp/check_standalone.cpp b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/cpp/check_standalone.cpp
new file mode 100644
index 0000000000..8938ae2a3b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/cpp/check_standalone.cpp
@@ -0,0 +1,293 @@
+// SPDX-License-Identifier: 0BSD
+
+#include <rusticol.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace fs = std::filesystem;
+
+struct Options {
+    std::string process;
+    std::string model_parameters;
+    std::string kinematics;
+    std::vector<std::string> parameter_names;
+    std::vector<double> parameter_real;
+    std::vector<double> parameter_imaginary;
+    int precision = 16;
+    bool json = false;
+};
+
+std::string json_string(const std::string &value) {
+    std::ostringstream output;
+    output << '"';
+    for (const unsigned char character : value) {
+        switch (character) {
+        case '"': output << "\\\""; break;
+        case '\\': output << "\\\\"; break;
+        case '\n': output << "\\n"; break;
+        case '\r': output << "\\r"; break;
+        case '\t': output << "\\t"; break;
+        default:
+            if (character < 0x20) {
+                output << "\\u" << std::hex << std::setw(4) << std::setfill('0')
+                       << static_cast<int>(character) << std::dec << std::setfill(' ');
+            } else {
+                output << character;
+            }
+        }
+    }
+    output << '"';
+    return output.str();
+}
+
+Options parse_options(int argc, char **argv) {
+    Options options;
+    for (int index = 1; index < argc; ++index) {
+        const std::string argument = argv[index];
+        auto require = [&](int count) {
+            if (index + count >= argc) {
+                throw std::invalid_argument("missing value after " + argument);
+            }
+        };
+        if (argument == "--process") {
+            require(1);
+            options.process = argv[++index];
+        } else if (argument == "--model-parameters") {
+            require(1);
+            options.model_parameters = argv[++index];
+        } else if (argument == "--kinematics") {
+            require(1);
+            options.kinematics = argv[++index];
+        } else if (argument == "--set-parameter") {
+            require(3);
+            options.parameter_names.emplace_back(argv[++index]);
+            options.parameter_real.push_back(std::stod(argv[++index]));
+            options.parameter_imaginary.push_back(std::stod(argv[++index]));
+        } else if (argument == "--precision") {
+            require(1);
+            options.precision = std::stoi(argv[++index]);
+        } else if (argument == "--json") {
+            options.json = true;
+        } else if (argument == "--help" || argument == "-h") {
+            std::cout << "usage: check_standalone [--process ID|EXPRESSION] "
+                         "[--model-parameters PATH] "
+                         "[--kinematics PATH] "
+                         "[--set-parameter NAME REAL IMAG] "
+                         "[--precision 16] [--json]\n";
+            std::exit(0);
+        } else {
+            throw std::invalid_argument("unknown option: " + argument);
+        }
+    }
+    if (options.precision != 16) {
+        throw std::invalid_argument(
+            "the C++ Rusticol API supports only double precision (--precision 16)");
+    }
+    return options;
+}
+
+std::vector<std::string> split_tabs(const std::string &line) {
+    std::vector<std::string> fields;
+    std::size_t start = 0;
+    while (true) {
+        const auto separator = line.find('\t', start);
+        fields.push_back(line.substr(start, separator - start));
+        if (separator == std::string::npos) break;
+        start = separator + 1;
+    }
+    return fields;
+}
+
+std::vector<double> load_validation_point(
+    const fs::path &path, const std::string &process_id, std::size_t external_count) {
+    std::ifstream input(path);
+    if (!input) return {};
+    std::string line;
+    std::getline(input, line);
+    if (line != "RUSTICOL_VALIDATION_POINTS_V1") {
+        throw std::runtime_error("unsupported validation_points.dat format");
+    }
+    while (std::getline(input, line)) {
+        if (line.empty() || line[0] == '#') continue;
+        const auto fields = split_tabs(line);
+        if (fields.size() < 2 || fields[0] != process_id) continue;
+        const auto row_count = static_cast<std::size_t>(std::stoull(fields[1]));
+        if (row_count != external_count || fields.size() != 2 + 4 * external_count) {
+            throw std::runtime_error(
+                "validation point has an incompatible external-particle count");
+        }
+        std::vector<double> values;
+        values.reserve(4 * external_count);
+        for (std::size_t index = 2; index < fields.size(); ++index) {
+            values.push_back(std::stod(fields[index]));
+        }
+        return values;
+    }
+    return {};
+}
+
+std::vector<double> reorder_validation_point(
+    const std::vector<double> &representative,
+    const std::vector<std::size_t> &permutation) {
+    if (representative.empty()) return {};
+    if (representative.size() != 4 * permutation.size()) {
+        throw std::runtime_error("validation point does not match external permutation");
+    }
+    std::vector<double> public_point(representative.size());
+    std::vector<bool> seen(permutation.size(), false);
+    for (std::size_t representative_index = 0;
+         representative_index < permutation.size(); ++representative_index) {
+        const auto public_index = permutation[representative_index];
+        if (public_index >= permutation.size() || seen[public_index]) {
+            throw std::runtime_error("runtime returned an invalid external permutation");
+        }
+        seen[public_index] = true;
+        std::copy_n(
+            representative.begin() + 4 * representative_index,
+            4,
+            public_point.begin() + 4 * public_index);
+    }
+    return public_point;
+}
+
+template <typename Integer>
+void write_integer_array(std::ostream &output, const std::vector<Integer> &values) {
+    output << '[';
+    for (std::size_t index = 0; index < values.size(); ++index) {
+        if (index) output << ',';
+        output << values[index];
+    }
+    output << ']';
+}
+
+void write_common_json(
+    std::ostream &output,
+    const rusticol::Runtime &runtime,
+    const std::vector<rusticol::ExternalParticle> &particles,
+    const std::vector<rusticol::HelicityConfiguration> &helicities,
+    const std::vector<rusticol::ColorComponent> &colors) {
+    output << "\"process\":" << json_string(runtime.process())
+           << ",\"process_key\":" << json_string(runtime.process_key())
+           << ",\"color_accuracy\":" << json_string(runtime.color_accuracy());
+    output << ",\"external_particles\":[";
+    for (std::size_t index = 0; index < particles.size(); ++index) {
+        if (index) output << ',';
+        output << "{\"index\":" << particles[index].index
+               << ",\"pdg\":" << particles[index].pdg << '}';
+    }
+    output << "],\"helicities\":[";
+    for (std::size_t index = 0; index < helicities.size(); ++index) {
+        if (index) output << ',';
+        output << "{\"id\":" << json_string(helicities[index].id)
+               << ",\"helicities\":";
+        write_integer_array(output, helicities[index].helicities);
+        output << '}';
+    }
+    output << "],\"colors\":[";
+    for (std::size_t index = 0; index < colors.size(); ++index) {
+        if (index) output << ',';
+        output << "{\"id\":" << json_string(colors[index].id)
+               << ",\"kind\":" << json_string(colors[index].kind)
+               << ",\"word\":";
+        write_integer_array(output, colors[index].word);
+        output << '}';
+    }
+    output << ']';
+}
+
+int main(int argc, char **argv) {
+    try {
+        const auto options = parse_options(argc, argv);
+        const fs::path executable = fs::weakly_canonical(fs::absolute(argv[0]));
+        fs::path root = fs::current_path();
+        if (!fs::is_regular_file(root / "artifact.json")) {
+            root = executable.parent_path().parent_path().parent_path();
+        }
+        rusticol::Runtime runtime(root.string(), options.process, options.model_parameters);
+        if (!options.parameter_names.empty()) {
+            runtime.set_model_parameters(
+                options.parameter_names,
+                options.parameter_real,
+                options.parameter_imaginary);
+        }
+        const auto particles = runtime.external_particles();
+        const auto helicities = runtime.helicities();
+        const auto colors = runtime.colors();
+        const auto momenta = options.kinematics.empty()
+            ? reorder_validation_point(
+                  load_validation_point(
+                      root / "API" / "validation_points.dat",
+                      runtime.representative_process_key(),
+                      particles.size()),
+                  runtime.external_permutation())
+            : runtime.load_kinematics_json(options.kinematics);
+        if (momenta.empty()) {
+            if (options.json) {
+                std::cout << "{\"language\":\"cpp\",\"available\":false,";
+                write_common_json(std::cout, runtime, particles, helicities, colors);
+                std::cout << ",\"diagnostic\":"
+                             "\"no bundled validation point is available\"}\n";
+            } else {
+                std::cout << "process: " << runtime.process() << "\n"
+                          << "no bundled validation point is available; "
+                             "metadata load succeeded\n";
+            }
+            return 0;
+        }
+        const auto total = runtime.evaluate(momenta, 1);
+        const auto resolved = runtime.evaluate_resolved(momenta, 1);
+        const auto explicit_total = resolved.total();
+
+        if (options.json) {
+            std::cout << std::setprecision(17)
+                      << "{\"language\":\"cpp\",\"available\":true,"
+                         "\"precision\":16,";
+            write_common_json(std::cout, runtime, particles, helicities, colors);
+            std::cout << ",\"shape\":[1," << resolved.helicities.size() << ','
+                      << resolved.colors.size() << "],\"values\":[";
+            for (std::size_t index = 0; index < resolved.values.size(); ++index) {
+                if (index) std::cout << ',';
+                std::cout << resolved.values[index];
+            }
+            std::cout << "],\"resolved_sum\":[" << explicit_total[0]
+                      << "],\"compatibility_total\":[" << total[0] << "]}\n";
+        } else {
+            std::cout << std::setprecision(17)
+                      << "process: " << runtime.process() << " ["
+                      << runtime.process_key() << "]\n"
+                      << "resolved shape: (1, " << resolved.helicities.size() << ", "
+                      << resolved.colors.size() << ")\n";
+            for (std::size_t helicity = 0;
+                 helicity < resolved.helicities.size();
+                 ++helicity) {
+                for (std::size_t color = 0; color < resolved.colors.size(); ++color) {
+                    std::cout << "  " << resolved.helicities[helicity].id << "  "
+                              << resolved.colors[color].id << "  "
+                              << resolved(0, helicity, color) << '\n';
+                }
+            }
+            std::cout << "explicit resolved sum: " << explicit_total[0] << '\n'
+                      << "compatibility total:   " << total[0] << '\n';
+        }
+        const double scale = std::max(std::abs(total[0]), 1.0);
+        if (std::abs(explicit_total[0] - total[0]) > 1.0e-12 * scale) {
+            throw std::runtime_error(
+                "resolved components do not reproduce the compatibility total");
+        }
+        return 0;
+    } catch (const std::exception &error) {
+        std::cerr << "check_standalone: " << error.what() << '\n';
+        return 1;
+    }
+}
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/fortran/Makefile b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/fortran/Makefile
new file mode 100644
index 0000000000..e626df0d15
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/fortran/Makefile
@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: 0BSD
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell \
+	if command -v "$(RUSTICOL_CONFIG)" >/dev/null 2>&1; then \
+		command -v "$(RUSTICOL_CONFIG)"; \
+	elif [ "$(RUSTICOL_CONFIG)" = rusticol-config ]; then \
+		directory="$(CURDIR)"; \
+		while [ "$$directory" != / ]; do \
+			candidate="$$directory/.venv/bin/rusticol-config"; \
+			if [ -x "$$candidate" ]; then printf '%s\n' "$$candidate"; break; fi; \
+			directory=$$(dirname "$$directory"); \
+		done; \
+	fi)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+ifeq ($(origin FC), default)
+FC := gfortran
+endif
+FC ?= gfortran
+ARTIFACT_DIR := $(abspath ../..)
+BUILD_DIR ?= $(abspath ../../..)/.pyamplicol-api-build/$(notdir $(ARTIFACT_DIR))/fortran
+TARGET := $(BUILD_DIR)/check_standalone
+RUSTICOL_FORTRAN := $(shell "$(RUSTICOL_CONFIG_PATH)" --fortran-source)
+FFLAGS ?= -O2
+FFLAGS += -std=f2008 -ffree-line-length-none -Wall -Wextra
+LDLIBS += $(shell "$(RUSTICOL_CONFIG_PATH)" --libs)
+
+.PHONY: all check_standalone clean run
+
+all: $(TARGET)
+
+check_standalone: $(TARGET)
+
+$(BUILD_DIR):
+	mkdir -p "$@"
+
+$(TARGET): check_standalone.f90 | $(BUILD_DIR)
+	test -f "$(RUSTICOL_FORTRAN)"
+	$(FC) $(FFLAGS) -J"$(BUILD_DIR)" "$(RUSTICOL_FORTRAN)" "$<" -o "$@" $(LDLIBS)
+
+run: $(TARGET)
+	cd "$(ARTIFACT_DIR)" && "$(TARGET)" $(ARGS)
+
+clean:
+	$(RM) "$(TARGET)" "$(BUILD_DIR)/rusticol.mod"
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/fortran/check_standalone.f90 b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/fortran/check_standalone.f90
new file mode 100644
index 0000000000..d52a39379a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/fortran/check_standalone.f90
@@ -0,0 +1,374 @@
+! SPDX-License-Identifier: 0BSD
+
+program check_standalone
+  use, intrinsic :: iso_c_binding
+  use, intrinsic :: iso_fortran_env, only: error_unit
+  use rusticol
+  implicit none
+
+  integer, parameter :: MAX_OVERRIDES = 128
+  type(rusticol_runtime) :: runtime
+  type(rusticol_external_particle), allocatable :: particles(:)
+  type(rusticol_helicity_configuration), allocatable :: helicities(:)
+  type(rusticol_color_component), allocatable :: colors(:)
+  character(len=4096) :: process_dir, process_key, representative_process_key
+  character(len=4096) :: model_parameters, kinematics
+  character(len=4096) :: executable
+  character(len=256) :: override_names_buffer(MAX_OVERRIDES)
+  character(len=256), allocatable :: override_names(:)
+  real(c_double) :: override_real_buffer(MAX_OVERRIDES)
+  real(c_double) :: override_imaginary_buffer(MAX_OVERRIDES)
+  real(c_double), allocatable :: override_real(:), override_imaginary(:)
+  real(c_double), allocatable, target :: momenta(:), totals(:), resolved(:, :, :)
+  integer(c_size_t), allocatable :: external_permutation(:)
+  logical :: json_output, point_available
+  integer :: precision, override_count
+  integer(c_int) :: status
+  integer :: color_index, helicity_index
+  real(c_double) :: explicit_total, scale
+
+  call parse_options(process_key, model_parameters, kinematics, precision, json_output, &
+      override_names_buffer, override_real_buffer, override_imaginary_buffer, &
+      override_count)
+  if (precision /= 16) call fail( &
+      "the Fortran Rusticol API supports only double precision (--precision 16)")
+  call resolve_process_dir(executable, process_dir)
+
+  if (len_trim(process_key) > 0 .and. len_trim(model_parameters) > 0) then
+    call runtime%load(trim(process_dir), trim(process_key), &
+        trim(model_parameters), status)
+  else if (len_trim(process_key) > 0) then
+    call runtime%load(trim(process_dir), trim(process_key), ierr=status)
+  else if (len_trim(model_parameters) > 0) then
+    call runtime%load(trim(process_dir), model_parameters=trim(model_parameters), &
+        ierr=status)
+  else
+    call runtime%load(trim(process_dir), ierr=status)
+  end if
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+
+  if (override_count > 0) then
+    allocate(override_names(override_count), override_real(override_count), &
+        override_imaginary(override_count))
+    override_names = override_names_buffer(1:override_count)
+    override_real = override_real_buffer(1:override_count)
+    override_imaginary = override_imaginary_buffer(1:override_count)
+    call runtime%set_model_parameters( &
+        override_names, override_real, override_imaginary, ierr=status)
+    if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  end if
+
+  particles = runtime%external_particles(ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  helicities = runtime%helicities(ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  colors = runtime%colors(ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  process_key = runtime%process_key(ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  if (len_trim(kinematics) > 0) then
+    call runtime%load_kinematics_json(trim(kinematics), momenta, ierr=status)
+    if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+    point_available = .true.
+  else
+    representative_process_key = runtime%representative_process_key(ierr=status)
+    if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+    external_permutation = runtime%external_permutation(ierr=status)
+    if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+    call load_validation_point( &
+        trim(process_dir) // "/API/validation_points.dat", &
+        trim(representative_process_key), size(particles), momenta, point_available)
+    if (point_available) call reorder_validation_point(momenta, external_permutation)
+  end if
+
+  if (.not. point_available) then
+    if (json_output) then
+      call emit_json_prefix(runtime, particles, helicities, colors, .false.)
+      write(*, '(A)') &
+          ',"diagnostic":"no bundled validation point is available"}'
+    else
+      write(*, '(A)') "process: " // runtime%process()
+      write(*, '(A)') &
+          "no bundled validation point is available; metadata load succeeded"
+    end if
+    stop 0
+  end if
+
+  call runtime%evaluate(momenta, 1_c_size_t, totals, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  call runtime%evaluate_resolved(momenta, 1_c_size_t, resolved, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) call fail(rusticol_last_error())
+  explicit_total = sum(resolved(:, :, 1))
+
+  if (json_output) then
+    call emit_json_prefix(runtime, particles, helicities, colors, .true.)
+    write(*, '(A,I0,A,I0,A)', advance='no') &
+        ',"shape":[1,', size(resolved, 2), ',', size(resolved, 1), &
+        '],"values":['
+    do helicity_index = 1, size(resolved, 2)
+      do color_index = 1, size(resolved, 1)
+        if (helicity_index > 1 .or. color_index > 1) &
+            write(*, '(A)', advance='no') ','
+        write(*, '(G0.17)', advance='no') &
+            resolved(color_index, helicity_index, 1)
+      end do
+    end do
+    write(*, '(A,G0.17,A,G0.17,A)') '],"resolved_sum":[', &
+        explicit_total, '],"compatibility_total":[', totals(1), ']}'
+  else
+    write(*, '(A)') "process: " // runtime%process() // &
+        " [" // trim(process_key) // "]"
+    write(*, '(A,I0,A,I0,A)') "resolved shape: (1, ", &
+        size(resolved, 2), ", ", size(resolved, 1), ")"
+    do helicity_index = 1, size(helicities)
+      do color_index = 1, size(colors)
+        write(*, '(2X,A,2X,A,2X,G0.17)') &
+            trim(helicities(helicity_index)%id), &
+            trim(colors(color_index)%id), &
+            resolved(color_index, helicity_index, 1)
+      end do
+    end do
+    write(*, '(A,G0.17)') "explicit resolved sum: ", explicit_total
+    write(*, '(A,G0.17)') "compatibility total:   ", totals(1)
+  end if
+  scale = max(abs(totals(1)), 1.0_c_double)
+  if (abs(explicit_total - totals(1)) > 1.0e-12_c_double * scale) then
+    call fail("resolved components do not reproduce the compatibility total")
+  end if
+
+contains
+
+  subroutine fail(message)
+    character(len=*), intent(in) :: message
+    write(error_unit, '(A)') "check_standalone: " // trim(message)
+    stop 1
+  end subroutine fail
+
+  subroutine parse_options(selected_process, model_card, kinematics_path, selected_precision, &
+      json, names, real_values, imaginary_values, count)
+    character(len=*), intent(out) :: selected_process, model_card, kinematics_path
+    integer, intent(out) :: selected_precision, count
+    logical, intent(out) :: json
+    character(len=*), intent(out) :: names(:)
+    real(c_double), intent(out) :: real_values(:), imaginary_values(:)
+    character(len=4096) :: argument, value
+    integer :: argc, index, parse_status
+
+    selected_process = ""
+    model_card = ""
+    kinematics_path = ""
+    selected_precision = 16
+    count = 0
+    json = .false.
+    argc = command_argument_count()
+    index = 1
+    do while (index <= argc)
+      call get_command_argument(index, argument)
+      select case (trim(argument))
+      case ("--process")
+        if (index + 1 > argc) call fail("missing value after --process")
+        index = index + 1
+        call get_command_argument(index, selected_process)
+      case ("--model-parameters")
+        if (index + 1 > argc) call fail( &
+            "missing value after --model-parameters")
+        index = index + 1
+        call get_command_argument(index, model_card)
+      case ("--kinematics")
+        if (index + 1 > argc) call fail("missing value after --kinematics")
+        index = index + 1
+        call get_command_argument(index, kinematics_path)
+      case ("--set-parameter")
+        if (index + 3 > argc) call fail( &
+            "--set-parameter requires NAME REAL IMAG")
+        if (count >= size(names)) call fail( &
+            "too many --set-parameter options")
+        count = count + 1
+        index = index + 1
+        call get_command_argument(index, names(count))
+        index = index + 1
+        call get_command_argument(index, value)
+        read(value, *, iostat=parse_status) real_values(count)
+        if (parse_status /= 0) call fail( &
+            "invalid real model-parameter component")
+        index = index + 1
+        call get_command_argument(index, value)
+        read(value, *, iostat=parse_status) imaginary_values(count)
+        if (parse_status /= 0) call fail( &
+            "invalid imaginary model-parameter component")
+      case ("--precision")
+        if (index + 1 > argc) call fail("missing value after --precision")
+        index = index + 1
+        call get_command_argument(index, value)
+        read(value, *, iostat=parse_status) selected_precision
+        if (parse_status /= 0) call fail("invalid --precision value")
+      case ("--json")
+        json = .true.
+      case ("--help", "-h")
+        write(*, '(A)') "usage: check_standalone [--process ID|EXPRESSION] " // &
+            "[--model-parameters PATH] [--kinematics PATH] " // &
+            "[--set-parameter NAME REAL IMAG] " // &
+            "[--precision 16] [--json]"
+        stop 0
+      case default
+        call fail("unknown option: " // trim(argument))
+      end select
+      index = index + 1
+    end do
+  end subroutine parse_options
+
+  subroutine resolve_process_dir(program_path, root)
+    character(len=*), intent(out) :: program_path, root
+    integer :: slash
+    logical :: artifact_in_working_directory
+    call get_command_argument(0, program_path)
+    inquire(file="artifact.json", exist=artifact_in_working_directory)
+    if (artifact_in_working_directory) then
+      root = "."
+      return
+    end if
+    slash = scan(trim(program_path), "/", back=.true.)
+    if (slash == 0) then
+      root = "../.."
+    else
+      root = program_path(:slash - 1) // "/../.."
+    end if
+  end subroutine resolve_process_dir
+
+  subroutine load_validation_point(path, key, external_count, values, available)
+    character(len=*), intent(in) :: path, key
+    integer, intent(in) :: external_count
+    real(c_double), allocatable, target, intent(out) :: values(:)
+    logical, intent(out) :: available
+    character(len=65536) :: line
+    character(len=4096) :: row_key
+    integer :: unit, io_status, row_count
+
+    available = .false.
+    allocate(values(4 * external_count))
+    open(newunit=unit, file=path, status="old", action="read", &
+        iostat=io_status)
+    if (io_status /= 0) return
+    read(unit, '(A)', iostat=io_status) line
+    if (io_status /= 0 .or. &
+        trim(line) /= "RUSTICOL_VALIDATION_POINTS_V1") then
+      close(unit)
+      call fail("unsupported validation_points.dat format")
+    end if
+    do
+      read(unit, '(A)', iostat=io_status) line
+      if (io_status /= 0) exit
+      if (len_trim(line) == 0 .or. line(1:1) == "#") cycle
+      read(line, *, iostat=io_status) row_key, row_count
+      if (io_status /= 0 .or. trim(row_key) /= trim(key)) cycle
+      if (row_count /= external_count) then
+        close(unit)
+        call fail( &
+            "validation point has an incompatible external-particle count")
+      end if
+      read(line, *, iostat=io_status) row_key, row_count, values
+      if (io_status /= 0) then
+        close(unit)
+        call fail("invalid validation point row")
+      end if
+      available = .true.
+      exit
+    end do
+    close(unit)
+  end subroutine load_validation_point
+
+  subroutine reorder_validation_point(values, permutation)
+    real(c_double), allocatable, intent(inout) :: values(:)
+    integer(c_size_t), intent(in) :: permutation(:)
+    real(c_double), allocatable :: reordered(:)
+    logical, allocatable :: seen(:)
+    integer :: representative_index, public_index
+
+    if (size(values) /= 4 * size(permutation)) call fail( &
+        "validation point does not match external permutation")
+    allocate(reordered(size(values)), seen(size(permutation)))
+    seen = .false.
+    do representative_index = 1, size(permutation)
+      public_index = int(permutation(representative_index)) + 1
+      if (public_index < 1 .or. public_index > size(permutation) .or. &
+          seen(public_index)) call fail( &
+          "runtime returned an invalid external permutation")
+      seen(public_index) = .true.
+      reordered(4 * public_index - 3:4 * public_index) = &
+          values(4 * representative_index - 3:4 * representative_index)
+    end do
+    call move_alloc(reordered, values)
+  end subroutine reorder_validation_point
+
+  function json_escape(value) result(escaped)
+    character(len=*), intent(in) :: value
+    character(len=:), allocatable :: escaped
+    integer :: index
+    escaped = ""
+    do index = 1, len_trim(value)
+      select case (value(index:index))
+      case ('"')
+        escaped = escaped // '\"'
+      case ('\')
+        escaped = escaped // '\\'
+      case default
+        escaped = escaped // value(index:index)
+      end select
+    end do
+  end function json_escape
+
+  subroutine emit_json_prefix(active_runtime, external, helicity_items, &
+      color_items, available)
+    type(rusticol_runtime), intent(inout) :: active_runtime
+    type(rusticol_external_particle), intent(in) :: external(:)
+    type(rusticol_helicity_configuration), intent(in) :: helicity_items(:)
+    type(rusticol_color_component), intent(in) :: color_items(:)
+    logical, intent(in) :: available
+    integer :: item, component
+
+    write(*, '(A)', advance='no') '{"language":"fortran","available":'
+    if (available) then
+      write(*, '(A)', advance='no') 'true,"precision":16'
+    else
+      write(*, '(A)', advance='no') 'false'
+    end if
+    write(*, '(A)', advance='no') ',"process":"' // &
+        json_escape(active_runtime%process()) // '","process_key":"' // &
+        json_escape(active_runtime%process_key()) // &
+        '","color_accuracy":"' // &
+        json_escape(active_runtime%color_accuracy()) // &
+        '","external_particles":['
+    do item = 1, size(external)
+      if (item > 1) write(*, '(A)', advance='no') ','
+      write(*, '(A,I0,A,I0,A)', advance='no') &
+          '{"index":', external(item)%index, ',"pdg":', &
+          external(item)%pdg, '}'
+    end do
+    write(*, '(A)', advance='no') '],"helicities":['
+    do item = 1, size(helicity_items)
+      if (item > 1) write(*, '(A)', advance='no') ','
+      write(*, '(A)', advance='no') '{"id":"' // &
+          json_escape(helicity_items(item)%id) // '","helicities":['
+      do component = 1, size(helicity_items(item)%helicities)
+        if (component > 1) write(*, '(A)', advance='no') ','
+        write(*, '(I0)', advance='no') &
+            helicity_items(item)%helicities(component)
+      end do
+      write(*, '(A)', advance='no') ']}'
+    end do
+    write(*, '(A)', advance='no') '],"colors":['
+    do item = 1, size(color_items)
+      if (item > 1) write(*, '(A)', advance='no') ','
+      write(*, '(A)', advance='no') '{"id":"' // &
+          json_escape(color_items(item)%id) // '","kind":"' // &
+          json_escape(color_items(item)%kind) // '","word":['
+      do component = 1, size(color_items(item)%word)
+        if (component > 1) write(*, '(A)', advance='no') ','
+        write(*, '(I0)', advance='no') color_items(item)%word(component)
+      end do
+      write(*, '(A)', advance='no') ']}'
+    end do
+    write(*, '(A)', advance='no') ']'
+  end subroutine emit_json_prefix
+
+end program check_standalone
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/python/check_standalone.py b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/python/check_standalone.py
new file mode 100755
index 0000000000..3e22ac3d56
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/python/check_standalone.py
@@ -0,0 +1,401 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Evaluate a generated process through pyAmpliCol's installed Python API."""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import json
+import math
+import os
+import statistics
+import sys
+import time
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+
+
+def _load_pyamplicol() -> Any:
+    try:
+        return importlib.import_module("pyamplicol")
+    except ModuleNotFoundError as error:
+        if error.name != "pyamplicol":
+            raise
+        previous = os.environ.get("_PYAMPLICOL_API_BOOTSTRAP")
+        if previous is not None:
+            raise SystemExit(
+                "pyamplicol remained unavailable after retrying with " + previous
+            ) from error
+        script = Path(__file__).resolve()
+        layouts = (
+            (Path("bin/python"), Path("bin/rusticol-config")),
+            (Path("Scripts/python.exe"), Path("Scripts/rusticol-config.exe")),
+        )
+        for parent in script.parents:
+            for python_relative, config_relative in layouts:
+                python = parent / ".venv" / python_relative
+                config = parent / ".venv" / config_relative
+                if (
+                    not python.is_file()
+                    or not os.access(python, os.X_OK)
+                    or not config.is_file()
+                    or not os.access(config, os.X_OK)
+                ):
+                    continue
+                environment = os.environ.copy()
+                environment["_PYAMPLICOL_API_BOOTSTRAP"] = str(python)
+                os.execve(
+                    python,
+                    (str(python), str(script), *sys.argv[1:]),
+                    environment,
+                )
+        raise SystemExit(
+            "pyamplicol is not importable; activate its environment or place this "
+            "artifact below a checkout containing .venv from `just dev-install`"
+        ) from error
+
+
+pyamplicol = _load_pyamplicol()
+
+
+def _validation_point(path: Path, process_id: str, precision: int):
+    if not path.is_file():
+        return None
+    lines = path.read_text(encoding="ascii").splitlines()
+    if not lines or lines[0] != "RUSTICOL_VALIDATION_POINTS_V1":
+        raise SystemExit("unsupported validation_points.dat format")
+    for line in lines[1:]:
+        if not line or line.startswith("#"):
+            continue
+        fields = line.split("\t")
+        if len(fields) < 2 or fields[0] != process_id:
+            continue
+        external_count = int(fields[1])
+        components = fields[2:]
+        if len(components) != external_count * 4:
+            raise SystemExit(f"invalid validation row for {process_id!r}")
+        convert = float if precision == 16 else Decimal
+        return [
+            [convert(value) for value in components[index : index + 4]]
+            for index in range(0, len(components), 4)
+        ]
+    return None
+
+
+def _reorder_point(
+    point: list[list[Any]], permutation: tuple[int, ...]
+) -> list[list[Any]]:
+    if len(point) != len(permutation) or sorted(permutation) != list(range(len(point))):
+        raise SystemExit("runtime returned an invalid external permutation")
+    reordered: list[list[Any] | None] = [None] * len(point)
+    for representative_index, public_index in enumerate(permutation):
+        reordered[public_index] = point[representative_index]
+    if any(vector is None for vector in reordered):
+        raise SystemExit("runtime returned an incomplete external permutation")
+    return [vector for vector in reordered if vector is not None]
+
+
+def _kinematics(path: str, precision: int, external_count: int) -> list[list[Any]]:
+    source = Path(path).expanduser().resolve(strict=True)
+
+    def invalid_constant(value: str) -> None:
+        raise ValueError(f"non-finite JSON constant {value!r}")
+
+    try:
+        payload = json.loads(
+            source.read_text(encoding="utf-8"),
+            parse_float=Decimal if precision != 16 else float,
+            parse_int=Decimal if precision != 16 else int,
+            parse_constant=invalid_constant,
+        )
+    except (json.JSONDecodeError, OSError, ValueError) as error:
+        raise SystemExit(f"could not read kinematics JSON {source}: {error}") from error
+    if (
+        isinstance(payload, list)
+        and len(payload) == 1
+        and isinstance(payload[0], list)
+        and payload[0]
+        and isinstance(payload[0][0], list)
+    ):
+        payload = payload[0]
+    if not isinstance(payload, list) or len(payload) != external_count:
+        raise SystemExit(
+            f"kinematics JSON must contain one [{external_count}][4] point"
+        )
+    convert = float if precision == 16 else Decimal
+    point: list[list[Any]] = []
+    for leg_index, raw_leg in enumerate(payload):
+        if not isinstance(raw_leg, list) or len(raw_leg) != 4:
+            raise SystemExit(
+                f"kinematics leg {leg_index} must contain [E, px, py, pz]"
+            )
+        leg: list[Any] = []
+        for component_index, raw in enumerate(raw_leg):
+            if isinstance(raw, bool) or not isinstance(raw, (int, float, Decimal, str)):
+                raise SystemExit(
+                    f"kinematics leg {leg_index} component {component_index} "
+                    "must be a number or decimal string"
+                )
+            try:
+                value = convert(raw)
+            except (TypeError, ValueError) as error:
+                raise SystemExit(
+                    f"kinematics leg {leg_index} component {component_index} "
+                    "is not a decimal value"
+                ) from error
+            finite = (
+                math.isfinite(value)
+                if isinstance(value, float)
+                else value.is_finite()
+            )
+            if not finite:
+                raise SystemExit("kinematics components must be finite")
+            leg.append(value)
+        point.append(leg)
+    return point
+
+
+def _repeat_point(point: list[list[Any]], count: int) -> list[list[list[Any]]]:
+    return [point for _ in range(count)]
+
+
+def _flatten(values: Any) -> list[Any]:
+    if hasattr(values, "reshape"):
+        return values.reshape(-1).tolist()
+    output: list[Any] = []
+
+    def visit(value: Any) -> None:
+        if isinstance(value, (list, tuple)):
+            for entry in value:
+                visit(entry)
+        else:
+            output.append(value)
+
+    visit(values)
+    return output
+
+
+def _real(value: Any) -> Any:
+    if isinstance(value, Decimal):
+        return value
+    converted = complex(value)
+    if abs(converted.imag) > 1.0e-14 * max(1.0, abs(converted.real)):
+        raise SystemExit("matrix-element output unexpectedly has an imaginary part")
+    return converted.real
+
+
+def _json_scalar(value: Any, precision: int) -> float | str:
+    real = _real(value)
+    return float(real) if precision == 16 else str(real)
+
+
+def _parameter_component(value: Any) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise SystemExit("model-parameter components must be JSON numbers")
+    component = float(value)
+    if not math.isfinite(component):
+        raise SystemExit("model-parameter components must be finite")
+    return component
+
+
+def _parameter_value(value: Any) -> complex | float:
+    if isinstance(value, list):
+        if len(value) != 2:
+            raise SystemExit("model-parameter arrays must contain [real, imaginary]")
+        return complex(
+            _parameter_component(value[0]),
+            _parameter_component(value[1]),
+        )
+    return _parameter_component(value)
+
+
+def _model_parameters(path: str | None) -> dict[str, complex | float] | None:
+    if path is None:
+        return None
+    source = Path(path).expanduser().resolve(strict=True)
+    payload = json.loads(source.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise SystemExit("model-parameter JSON must be an object")
+    return {str(name): _parameter_value(value) for name, value in payload.items()}
+
+
+def _physics_payload(physics: pyamplicol.ProcessPhysics) -> dict[str, Any]:
+    colors = [
+        {"id": item.id, "kind": "lc-flow", "word": list(item.word)}
+        for item in physics.color_flows
+    ]
+    colors.extend(
+        {"id": item.id, "kind": "contracted-color", "word": []}
+        for item in physics.contracted_color_components
+    )
+    return {
+        "process": physics.process,
+        "process_key": physics.process_id,
+        "color_accuracy": physics.color_accuracy,
+        "external_particles": [
+            {"index": item.index, "pdg": item.pdg_id}
+            for item in physics.external_particles
+        ],
+        "helicities": [
+            {"id": item.id, "helicities": list(item.values)}
+            for item in physics.helicities
+        ],
+        "colors": colors,
+    }
+
+
+def _profile(
+    runtime: pyamplicol.Runtime,
+    point: list[list[Any]],
+    precision: int,
+    target_runtime: float,
+    batch_size: int,
+) -> dict[str, float | int]:
+    samples: list[float] = []
+    elapsed = 0.0
+    while len(samples) < 8 or elapsed < target_runtime:
+        batch = _repeat_point(point, batch_size)
+        started = time.perf_counter()
+        runtime.evaluate(batch, precision=precision)
+        wall = time.perf_counter() - started
+        elapsed += wall
+        samples.append(wall / batch_size)
+    return {
+        "samples": len(samples) * batch_size,
+        "wall_us_per_point": statistics.mean(samples) * 1.0e6,
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Resolved pyAmpliCol Python API example"
+    )
+    parser.add_argument(
+        "--process",
+        help="stable process/alias ID or exact concrete process expression",
+    )
+    parser.add_argument("--model-parameters")
+    parser.add_argument(
+        "--kinematics",
+        help="JSON point in the external-particle order supplied by --process",
+    )
+    parser.add_argument(
+        "--set-parameter",
+        nargs=3,
+        action="append",
+        default=[],
+        metavar=("NAME", "REAL", "IMAG"),
+    )
+    parser.add_argument("--precision", type=int, default=16)
+    parser.add_argument("--profile", action="store_true")
+    parser.add_argument("--target-runtime", type=float, default=10.0)
+    parser.add_argument("--batch-size", type=int, default=128)
+    parser.add_argument("--json", action="store_true")
+    return parser
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    root = Path(__file__).resolve().parents[2]
+    runtime = pyamplicol.Runtime.load(
+        root,
+        process=args.process,
+        model_parameters=_model_parameters(args.model_parameters),
+    )
+    if args.set_parameter:
+        runtime.set_model_parameters(
+            {
+                name: complex(float(real), float(imaginary))
+                for name, real, imaginary in args.set_parameter
+            }
+        )
+    physics = runtime.physics
+    metadata = _physics_payload(physics)
+    if args.kinematics is None:
+        point = _validation_point(
+            root / "API" / "validation_points.dat",
+            runtime.representative_process_key,
+            args.precision,
+        )
+        if point is not None:
+            point = _reorder_point(point, runtime.external_permutation)
+    else:
+        point = _kinematics(
+            args.kinematics,
+            args.precision,
+            len(physics.external_particles),
+        )
+    if point is None:
+        payload = {
+            "language": "python",
+            "available": False,
+            "diagnostic": "no bundled validation point is available",
+            **metadata,
+        }
+        if args.json:
+            print(json.dumps(payload, separators=(",", ":"), sort_keys=True))
+        else:
+            print(f"process: {physics.process}")
+            print("no bundled validation point is available; metadata load succeeded")
+        return 0
+
+    batch = _repeat_point(point, 1)
+    resolved = runtime.evaluate_resolved(batch, precision=args.precision)
+    total = runtime.evaluate(batch, precision=args.precision)
+    values = _flatten(resolved.values)
+    explicit_total = _flatten(resolved.total())
+    compatibility_total = _flatten(total)
+    payload: dict[str, Any] = {
+        "language": "python",
+        "available": True,
+        "precision": args.precision,
+        **metadata,
+        "shape": list(resolved.shape),
+        "values": [_json_scalar(value, args.precision) for value in values],
+        "resolved_sum": [
+            _json_scalar(value, args.precision) for value in explicit_total
+        ],
+        "compatibility_total": [
+            _json_scalar(value, args.precision) for value in compatibility_total
+        ],
+    }
+    if args.profile:
+        payload["profile"] = _profile(
+            runtime,
+            point,
+            args.precision,
+            max(args.target_runtime, 0.0),
+            max(args.batch_size, 1),
+        )
+    if args.json:
+        print(json.dumps(payload, separators=(",", ":"), sort_keys=True))
+        return 0
+
+    print(f"process: {physics.process} [{physics.process_id}]")
+    print(f"resolved shape: {resolved.shape}")
+    color_items = metadata["colors"]
+    color_count = len(color_items)
+    for helicity_index, helicity in enumerate(metadata["helicities"]):
+        for color_index, color in enumerate(color_items):
+            offset = helicity_index * color_count + color_index
+            print(f"  {helicity['id']}  {color['id']}  {values[offset]}")
+    print(f"explicit resolved sum: {explicit_total[0]}")
+    print(f"compatibility total:   {compatibility_total[0]}")
+    if not math.isclose(
+        float(_real(explicit_total[0])),
+        float(_real(compatibility_total[0])),
+        rel_tol=1.0e-12,
+        abs_tol=1.0e-15,
+    ):
+        raise SystemExit("resolved components do not reproduce the compatibility total")
+    if args.profile:
+        profile = payload["profile"]
+        assert isinstance(profile, dict)
+        print(f"timing: {profile['wall_us_per_point']:.6g} us/point")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/rust/Makefile b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/rust/Makefile
new file mode 100644
index 0000000000..3f8824f58a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/rust/Makefile
@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: 0BSD
+RUSTICOL_CONFIG ?= rusticol-config
+RUSTICOL_CONFIG_PATH := $(shell \
+	if command -v "$(RUSTICOL_CONFIG)" >/dev/null 2>&1; then \
+		command -v "$(RUSTICOL_CONFIG)"; \
+	elif [ "$(RUSTICOL_CONFIG)" = rusticol-config ]; then \
+		directory="$(CURDIR)"; \
+		while [ "$$directory" != / ]; do \
+			candidate="$$directory/.venv/bin/rusticol-config"; \
+			if [ -x "$$candidate" ]; then printf '%s\n' "$$candidate"; break; fi; \
+			directory=$$(dirname "$$directory"); \
+		done; \
+	fi)
+ifeq ($(strip $(RUSTICOL_CONFIG_PATH)),)
+$(error rusticol-config is unavailable; activate the pyAmpliCol environment or set RUSTICOL_CONFIG=/absolute/path)
+endif
+RUSTC ?= rustc
+RUST_SCRIPT ?= rust-script
+ARTIFACT_DIR := $(abspath ../..)
+BUILD_DIR ?= $(abspath ../../..)/.pyamplicol-api-build/$(notdir $(ARTIFACT_DIR))/rust
+TARGET := $(BUILD_DIR)/check_standalone
+RUSTFLAGS ?= -C opt-level=2
+RUSTICOL_RUST_SOURCE := $(shell "$(RUSTICOL_CONFIG_PATH)" --rust-source)
+RUSTICOL_RUSTFLAGS := $(shell "$(RUSTICOL_CONFIG_PATH)" --rustflags)
+
+.PHONY: all check_standalone clean run run-script
+
+all: $(TARGET)
+
+check_standalone: $(TARGET)
+
+$(BUILD_DIR):
+	mkdir -p "$@"
+
+$(TARGET): check_standalone.rs | $(BUILD_DIR)
+	RUSTICOL_RUST_SOURCE="$(RUSTICOL_RUST_SOURCE)" \
+		$(RUSTC) --edition=2021 $(RUSTFLAGS) "$<" -o "$@" $(RUSTICOL_RUSTFLAGS)
+
+run: $(TARGET)
+	cd "$(ARTIFACT_DIR)" && "$(TARGET)" $(ARGS)
+
+run-script:
+	cd "$(ARTIFACT_DIR)" && \
+		RUSTICOL_RUST_SOURCE="$(RUSTICOL_RUST_SOURCE)" \
+		CARGO_ENCODED_RUSTFLAGS="$$("$(RUSTICOL_CONFIG_PATH)" --cargo-rustflags)" \
+		$(RUST_SCRIPT) "API/rust/check_standalone.rs" -- $(ARGS)
+
+clean:
+	$(RM) "$(TARGET)"
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/rust/check_standalone.rs b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/rust/check_standalone.rs
new file mode 100644
index 0000000000..5c91f5c862
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/rust/check_standalone.rs
@@ -0,0 +1,454 @@
+#!/usr/bin/env rust-script
+// SPDX-License-Identifier: 0BSD
+//! ```cargo
+//! [package]
+//! edition = "2021"
+//! ```
+
+use std::env;
+use std::fmt::Write as _;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+#[allow(dead_code)]
+mod rusticol {
+    include!(env!("RUSTICOL_RUST_SOURCE"));
+}
+
+use rusticol::{ParameterUpdate, PhysicsMetadata, ResolvedEvaluation, Runtime, Selectors};
+
+#[derive(Default)]
+struct Options {
+    process: Option<String>,
+    model_parameters: Option<String>,
+    kinematics: Option<String>,
+    overrides: Vec<ParameterUpdate>,
+    precision: u32,
+    json: bool,
+    help: bool,
+}
+
+fn sdk<T>(result: rusticol::Result<T>) -> Result<T, String> {
+    result.map_err(|error| error.to_string())
+}
+
+fn usage() -> &'static str {
+    "usage: check_standalone [--process ID|EXPRESSION] [--model-parameters PATH] \
+[--kinematics PATH] [--set-parameter NAME REAL IMAG] [--precision 16] [--json]"
+}
+
+fn parse_options() -> Result<Options, String> {
+    let arguments = env::args().skip(1).collect::<Vec<_>>();
+    let mut options = Options {
+        precision: 16,
+        ..Options::default()
+    };
+    let mut index = 0;
+    while index < arguments.len() {
+        let argument = &arguments[index];
+        match argument.as_str() {
+            "--" => {
+                index += 1;
+            }
+            "--process" => {
+                options.process = Some(required_argument(&arguments, index, 1)?.to_owned());
+                index += 2;
+            }
+            "--model-parameters" => {
+                options.model_parameters =
+                    Some(required_argument(&arguments, index, 1)?.to_owned());
+                index += 2;
+            }
+            "--kinematics" => {
+                options.kinematics =
+                    Some(required_argument(&arguments, index, 1)?.to_owned());
+                index += 2;
+            }
+            "--set-parameter" => {
+                let name = required_argument(&arguments, index, 1)?.to_owned();
+                let real = parse_f64(
+                    required_argument(&arguments, index, 2)?,
+                    "real model-parameter component",
+                )?;
+                let imaginary = parse_f64(
+                    required_argument(&arguments, index, 3)?,
+                    "imaginary model-parameter component",
+                )?;
+                options
+                    .overrides
+                    .push(ParameterUpdate::new(name, real, imaginary));
+                index += 4;
+            }
+            "--precision" => {
+                options.precision = required_argument(&arguments, index, 1)?
+                    .parse()
+                    .map_err(|_| "invalid --precision value".to_owned())?;
+                index += 2;
+            }
+            "--json" => {
+                options.json = true;
+                index += 1;
+            }
+            "--help" | "-h" => {
+                options.help = true;
+                index += 1;
+            }
+            _ => return Err(format!("unknown option: {argument}")),
+        }
+    }
+    if options.precision != 16 {
+        return Err(
+            "the Rust Rusticol API supports only double precision (--precision 16)".to_owned(),
+        );
+    }
+    Ok(options)
+}
+
+fn required_argument<'a>(
+    arguments: &'a [String],
+    option_index: usize,
+    offset: usize,
+) -> Result<&'a str, String> {
+    arguments
+        .get(option_index + offset)
+        .map(String::as_str)
+        .ok_or_else(|| format!("missing value after {}", arguments[option_index]))
+}
+
+fn parse_f64(value: &str, description: &str) -> Result<f64, String> {
+    let parsed = value
+        .parse::<f64>()
+        .map_err(|_| format!("invalid {description}"))?;
+    if parsed.is_finite() {
+        Ok(parsed)
+    } else {
+        Err(format!("invalid {description}"))
+    }
+}
+
+fn artifact_root() -> Result<PathBuf, String> {
+    let current =
+        env::current_dir().map_err(|error| format!("cannot read current directory: {error}"))?;
+    if current.join("artifact.json").is_file() {
+        return Ok(current);
+    }
+
+    let executable = env::current_exe()
+        .map_err(|error| format!("cannot locate check_standalone executable: {error}"))?;
+    for ancestor in executable.ancestors().skip(1) {
+        if ancestor.join("artifact.json").is_file() {
+            return Ok(ancestor.to_path_buf());
+        }
+    }
+
+    let language_dir = executable.parent();
+    let build_artifact = language_dir.and_then(Path::parent);
+    let build_root = build_artifact.and_then(Path::parent);
+    if build_root.and_then(Path::file_name) == Some(".pyamplicol-api-build".as_ref()) {
+        if let (Some(parent), Some(name)) = (
+            build_root.and_then(Path::parent),
+            build_artifact.and_then(Path::file_name),
+        ) {
+            let candidate = parent.join(name);
+            if candidate.join("artifact.json").is_file() {
+                return Ok(candidate);
+            }
+        }
+    }
+
+    Err("run check_standalone from a generated artifact directory".to_owned())
+}
+
+fn load_validation_point(
+    path: &Path,
+    process_key: &str,
+    external_count: usize,
+) -> Result<Option<Vec<f64>>, String> {
+    let contents = match fs::read_to_string(path) {
+        Ok(contents) => contents,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+        Err(error) => return Err(format!("cannot read {}: {error}", path.display())),
+    };
+    let mut lines = contents.lines();
+    if lines.next() != Some("RUSTICOL_VALIDATION_POINTS_V1") {
+        return Err("unsupported validation_points.dat format".to_owned());
+    }
+    for line in lines {
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        let fields = line.split('\t').collect::<Vec<_>>();
+        if fields.len() < 2 || fields[0] != process_key {
+            continue;
+        }
+        let row_count = fields[1]
+            .parse::<usize>()
+            .map_err(|_| "invalid validation point row".to_owned())?;
+        if row_count != external_count || fields.len() != 2 + 4 * external_count {
+            return Err("validation point has an incompatible external-particle count".to_owned());
+        }
+        let momenta = fields[2..]
+            .iter()
+            .map(|value| parse_f64(value, "validation-point component"))
+            .collect::<Result<Vec<_>, _>>()?;
+        return Ok(Some(momenta));
+    }
+    Ok(None)
+}
+
+fn reorder_validation_point(
+    representative: Vec<f64>,
+    permutation: &[usize],
+) -> Result<Vec<f64>, String> {
+    if representative.len() != 4 * permutation.len() {
+        return Err("validation point does not match external permutation".to_owned());
+    }
+    let mut public_point = vec![0.0; representative.len()];
+    let mut seen = vec![false; permutation.len()];
+    for (representative_index, &public_index) in permutation.iter().enumerate() {
+        if public_index >= permutation.len() || seen[public_index] {
+            return Err("runtime returned an invalid external permutation".to_owned());
+        }
+        seen[public_index] = true;
+        public_point[4 * public_index..4 * public_index + 4].copy_from_slice(
+            &representative[4 * representative_index..4 * representative_index + 4],
+        );
+    }
+    Ok(public_point)
+}
+
+fn json_string(value: &str) -> String {
+    let mut output = String::with_capacity(value.len() + 2);
+    output.push('"');
+    for character in value.chars() {
+        match character {
+            '"' => output.push_str("\\\""),
+            '\\' => output.push_str("\\\\"),
+            '\u{08}' => output.push_str("\\b"),
+            '\u{0c}' => output.push_str("\\f"),
+            '\n' => output.push_str("\\n"),
+            '\r' => output.push_str("\\r"),
+            '\t' => output.push_str("\\t"),
+            character if character <= '\u{1f}' => {
+                write!(&mut output, "\\u{:04x}", character as u32)
+                    .expect("writing to a String cannot fail");
+            }
+            character => output.push(character),
+        }
+    }
+    output.push('"');
+    output
+}
+
+fn write_i32_array(output: &mut String, values: &[i32]) {
+    output.push('[');
+    for (index, value) in values.iter().enumerate() {
+        if index != 0 {
+            output.push(',');
+        }
+        write!(output, "{value}").expect("writing to a String cannot fail");
+    }
+    output.push(']');
+}
+
+fn write_usize_array(output: &mut String, values: &[usize]) {
+    output.push('[');
+    for (index, value) in values.iter().enumerate() {
+        if index != 0 {
+            output.push(',');
+        }
+        write!(output, "{value}").expect("writing to a String cannot fail");
+    }
+    output.push(']');
+}
+
+fn write_f64_array(output: &mut String, values: &[f64]) -> Result<(), String> {
+    output.push('[');
+    for (index, value) in values.iter().enumerate() {
+        if !value.is_finite() {
+            return Err("matrix-element output is not finite".to_owned());
+        }
+        if index != 0 {
+            output.push(',');
+        }
+        write!(output, "{value}").expect("writing to a String cannot fail");
+    }
+    output.push(']');
+    Ok(())
+}
+
+fn write_common_json(output: &mut String, metadata: &PhysicsMetadata) {
+    write!(
+        output,
+        "\"process\":{},\"process_key\":{},\"color_accuracy\":{}",
+        json_string(&metadata.process),
+        json_string(&metadata.process_key),
+        json_string(&metadata.color_accuracy),
+    )
+    .expect("writing to a String cannot fail");
+
+    output.push_str(",\"external_particles\":[");
+    for (index, particle) in metadata.external_particles.iter().enumerate() {
+        if index != 0 {
+            output.push(',');
+        }
+        write!(
+            output,
+            "{{\"index\":{},\"pdg\":{}}}",
+            particle.index, particle.pdg
+        )
+        .expect("writing to a String cannot fail");
+    }
+
+    output.push_str("],\"helicities\":[");
+    for (index, helicity) in metadata.helicities.iter().enumerate() {
+        if index != 0 {
+            output.push(',');
+        }
+        write!(
+            output,
+            "{{\"id\":{},\"helicities\":",
+            json_string(&helicity.id)
+        )
+        .expect("writing to a String cannot fail");
+        write_i32_array(output, &helicity.helicities);
+        output.push('}');
+    }
+
+    output.push_str("],\"colors\":[");
+    for (index, color) in metadata.colors.iter().enumerate() {
+        if index != 0 {
+            output.push(',');
+        }
+        write!(
+            output,
+            "{{\"id\":{},\"kind\":{},\"word\":",
+            json_string(&color.id),
+            json_string(&color.kind),
+        )
+        .expect("writing to a String cannot fail");
+        write_usize_array(output, &color.word);
+        output.push('}');
+    }
+    output.push(']');
+}
+
+fn available_json(
+    metadata: &PhysicsMetadata,
+    resolved: &ResolvedEvaluation,
+    explicit_total: f64,
+    total: f64,
+) -> Result<String, String> {
+    let (_, helicity_count, color_count) = resolved.shape();
+    let mut output = "{\"language\":\"rust\",\"available\":true,\"precision\":16,".to_owned();
+    write_common_json(&mut output, metadata);
+    write!(
+        &mut output,
+        ",\"shape\":[1,{helicity_count},{color_count}],\"values\":"
+    )
+    .expect("writing to a String cannot fail");
+    write_f64_array(&mut output, resolved.values())?;
+    output.push_str(",\"resolved_sum\":");
+    write_f64_array(&mut output, &[explicit_total])?;
+    output.push_str(",\"compatibility_total\":");
+    write_f64_array(&mut output, &[total])?;
+    output.push_str("}\n");
+    Ok(output)
+}
+
+fn unavailable_json(metadata: &PhysicsMetadata) -> String {
+    let mut output = "{\"language\":\"rust\",\"available\":false,".to_owned();
+    write_common_json(&mut output, metadata);
+    output.push_str(",\"diagnostic\":\"no bundled validation point is available\"}\n");
+    output
+}
+
+fn run() -> Result<(), String> {
+    let options = parse_options()?;
+    if options.help {
+        println!("{}", usage());
+        return Ok(());
+    }
+    let root = artifact_root()?;
+    let model_parameters = options.model_parameters.as_deref().map(Path::new);
+    let mut runtime = sdk(Runtime::load(
+        &root,
+        options.process.as_deref(),
+        model_parameters,
+    ))?;
+    sdk(runtime.set_model_parameters(&options.overrides))?;
+    let metadata = sdk(runtime.physics())?;
+    let point = if let Some(path) = options.kinematics.as_deref() {
+        Some(sdk(runtime.load_kinematics_json(path))?)
+    } else {
+        load_validation_point(
+            &root.join("API/validation_points.dat"),
+            &sdk(runtime.representative_process_key())?,
+            metadata.external_particles.len(),
+        )?
+        .map(|point| {
+            let permutation = sdk(runtime.external_permutation())?;
+            reorder_validation_point(point, &permutation)
+        })
+        .transpose()?
+    };
+    let Some(momenta) = point else {
+        if options.json {
+            print!("{}", unavailable_json(&metadata));
+        } else {
+            println!("process: {}", metadata.process);
+            println!("no bundled validation point is available; metadata load succeeded");
+        }
+        return Ok(());
+    };
+
+    let totals = sdk(runtime.evaluate_f64(&momenta, 1))?;
+    let total = *totals
+        .first()
+        .ok_or_else(|| "Rusticol returned no compatibility total".to_owned())?;
+    let resolved = sdk(runtime.evaluate_resolved_f64(&momenta, 1, &Selectors::all()))?;
+    let (_, helicity_count, color_count) = resolved.shape();
+    if helicity_count != metadata.helicities.len() || color_count != metadata.colors.len() {
+        return Err("resolved shape does not match runtime metadata".to_owned());
+    }
+    let resolved_totals = resolved.totals();
+    let explicit_total = *resolved_totals
+        .first()
+        .ok_or_else(|| "Rusticol returned no resolved total".to_owned())?;
+    if !explicit_total.is_finite() || !total.is_finite() {
+        return Err("matrix-element output is not finite".to_owned());
+    }
+    let scale = total.abs().max(1.0);
+    if (explicit_total - total).abs() > 1.0e-12 * scale {
+        return Err("resolved components do not reproduce the compatibility total".to_owned());
+    }
+
+    if options.json {
+        print!(
+            "{}",
+            available_json(&metadata, &resolved, explicit_total, total)?
+        );
+        return Ok(());
+    }
+
+    println!("process: {} [{}]", metadata.process, metadata.process_key);
+    println!("resolved shape: (1, {helicity_count}, {color_count})");
+    for (helicity_index, helicity) in resolved.helicities().iter().enumerate() {
+        for (color_index, color) in resolved.colors().iter().enumerate() {
+            let value = resolved
+                .get(0, helicity_index, color_index)
+                .ok_or_else(|| "resolved result index is out of range".to_owned())?;
+            println!("  {}  {}  {}", helicity.id, color.id, value);
+        }
+    }
+    println!("explicit resolved sum: {explicit_total}");
+    println!("compatibility total:   {total}");
+    Ok(())
+}
+
+fn main() {
+    if let Err(error) = run() {
+        eprintln!("check_standalone: {error}");
+        std::process::exit(1);
+    }
+}
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/validation_points.dat b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/validation_points.dat
new file mode 100644
index 0000000000..88c07164fe
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/API/validation_points.dat
@@ -0,0 +1,2 @@
+RUSTICOL_VALIDATION_POINTS_V1
+d_dbar_to_z	3	45.594000000000001	0	0	45.594000000000001	45.594000000000001	0	0	-45.594000000000001	91.188000000000002	0	0	0
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/artifact.json b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/artifact.json
new file mode 100644
index 0000000000..e571bc2687
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/artifact.json
@@ -0,0 +1 @@
+{"artifact_id":"a40595626b095cbbb547b775c57c5a71037c24b3a94effbf13facb2dd819d246","configuration":{"adjustments":[{"path":"evaluator.optimization.cores","reason":"shared affinity-aware CPU budget for Symbolica evaluator work"}],"effective_path":"config/effective.toml","requested_path":"config/requested.toml","toml_schema_version":1},"created_utc":"2026-10-03T12:47:49.472223Z","default_process_id":"d_dbar_to_z","dependencies":[{"license":"Symbolica Software License Agreement","name":"symbolica","source":"https://symbolica.io/","version":"3.0.0"}],"extensions":{"artifact_identity":{"kind":"pyamplicol-runtime-payload-identity","schema_version":1},"evaluator_payload_container":{"index_sha256":"dcf435a1434274e07601f4094d7c24e96d1a7047b3a91040068738a65cb5e412","kind":"pyamplicol-evaluator-payload-container","member_count":24,"path":"evaluators.pacbin","schema_version":1,"storage_abi":"pacbin-v1","unpacked_size_bytes":11078},"generation":{"api_bundle":{"emitted":true,"path":"API","requested":true,"scope":"root-artifact"},"concrete_processes":[{"expression":"d d~ > z","filters":{"dynamic_color_projection":{"abi":"pyamplicol-generic-dag-dynamic-color-projection-v2","after_amplitude_root_count":6,"after_current_count":13,"after_evaluation_count":6,"after_interaction_count":6,"applied":false,"before_amplitude_root_count":6,"before_current_count":13,"before_evaluation_count":6,"before_interaction_count":6,"closure_groups_sha256":"a844600669f75d6d329f9e3f0c8ecc9e5c6a668f8528ce538efd2162192fea1d","current_class_members_sha256":"ebafa2f11a32ca532efe90dd3b0bb40b11f2af3ab3b37132abc92ecc4aed8ff1","current_remap_sha256":"0caccba1e53a62e913e0ee51176dd08f281de9886b7f51ba3d8ec5bfb15fe41b","equality_check_status":"passed-no-projectable-classes","interaction_groups_sha256":"a844600669f75d6d329f9e3f0c8ecc9e5c6a668f8528ce538efd2162192fea1d","old_to_new_current_ids":[0,1,2,3,4,5,6,7,8,9,10,11,12],"projected_current_class_count":0,"rectangle_cardinalities_sha256":"38e050b6fa3804225180673e6fb5ec63776ecaa8063a507902484166d46595cb","rectangular_closure_group_count":0,"rectangular_interaction_group_count":0,"retained_color_metadata":"accuracy-line-groups-basis-key-identical; representative-sector-metadata-only","root_sector_policy":"pre-projection-resolved-sector-is-explicit-and-never-cross-projected","row_identity_sha256":"ab5790a4dacbf477223543dec077842044ad549e8e326b3c4b7ab30009b48889","selector_domains_sha256":"917fbb6f23cc4580be5c90a9e11c6f4d32534c0f7aaaba4d2e586549cf54dc64","source_revision":null,"source_semantics_sha256":"bdc021db2a2392e9ef7cb0e18d7a030f17203de9f67ba2ca59611cf6f1cd1326","split_current_class_count":0},"helicity_recurrence":{"amplitude_class_count":2,"contract_version":1,"materialization_strategy":"quotient","materialized_amplitude_count":2,"materialized_current_count":7,"optimized_amplitude_class_count":2,"optimized_current_count":9,"optimized_recurrence_class_count":3,"physical_helicity_count":12,"recurrence_class_count":7,"residual_amplitude_count":0,"residual_current_count":0,"source_state_mapping_count":7,"structural_zero_helicity_count":6},"lc_flow_layout":"topology-replay","relation_discovery":{"abi":"pyamplicol-artifact-numerical-current-reuse-v1","applied_relation_count":0,"certified_relation_count":0,"effective_mode":"certified-reuse","effective_reuse_state":"enabled","execution_mode":"compiled","lane_count":2,"lanes":{"helicity-sum":{"abi":"pyamplicol-generic-dag-numerical-current-warmup-v1","application":{"abi":"pyamplicol-authenticated-numerical-current-relation-set-v1","applied_relation_count":0,"candidate_capture_sha256":"9a9407d1c969921dab470127ef2b1b57d566d6f5a983a913cf769b519e81df28","certificate_replay":{"algorithm":"authenticated-independent-recursive-decimal-probes-v1","certificate_set_sha256":"dafbcb50c5c5fa03191abda625ab67056f35ff63f18d27c0108bfe8f68c89fef","status":"no_certified_numerical_relation"},"certificates":[],"certified_relation_count":0,"interaction_evaluation_count_before":6,"interaction_evaluation_count_projected":6,"interaction_evaluation_savings_projected":0,"mappings":[],"relation_kind_counts":{"equal":0,"opposite":0,"zero":0},"requested_mode":"certified-reuse","runtime_schema_sha256":"e2ff47ba61f9bb1ac9d9ad57731238ed0734b7c088fc75de57d74446cdffda07","schema_version":1,"scope":{"color_accuracy":"lc","execution_mode":"compiled","representation":"generic-dag"},"source_dag_sha256":"bdc021db2a2392e9ef7cb0e18d7a030f17203de9f67ba2ca59611cf6f1cd1326","source_semantics":{"abi":"pyamplicol-generic-dag-numerical-current-source-v1","sha256":"4794f99ccbc88dea1a22b767b7f8e0e3424eff81bc2731a56304ab1f191692fe"},"state":"no_certified_numerical_relation","verification_capture_sha256":"8ce4ac32cfedaefcbe01591c7a598e49a726b09d313b222248274eb7a94a93bf","warning":{"code":null,"emit":"never","message":null,"required":false}},"application_capture":null,"application_scope":{"abi":"pyamplicol-generic-dag-numerical-relation-application-scope-v1","allowed_relation_kinds":["equal","opposite","zero"],"application_eligible_relation_count":0,"discovered_relation_count":0,"policy":"exact-physical-selector-member-set-v1","reason":"complete-generic-dag","scope_suppressed_relation_count":0},"application_validation":{"checked_component_count":0,"checked_current_count":0,"maximum_absolute_residual":null,"maximum_relative_residual":null,"maximum_tolerance_ratio":null,"status":"not-required-no-applied-relations"},"applied_relation_count":0,"candidate_capture":{"abi":"pyamplicol-generic-dag-current-observation-capture-v2","capture_contract_sha256":"9a9407d1c969921dab470127ef2b1b57d566d6f5a983a913cf769b519e81df28","complete_current_component_digest":true,"components_embedded":false,"current_count":13,"evaluator":"symbolica-interpreted-high-precision-stage-replay","evaluator_output_partition":{"abi":"pyamplicol-generic-dag-current-id-output-partitions-v1","sha256":"91787d155d08a95fdad9fd74653fe688b91501a66209d22788363d1143e102fb"},"kinematic_sha256s":["07e4764a3e34af43f874738e5f1726cc6d45c1317bdabcf6dea30904aa7f991a","70cd9a12303937f454b0c30763aa465692698b281d0a4385a3f2f6357510253b","64b49558828caaedb30476a6de774e99a9b48635bacb4343815901eded648b85","570330aa5081a5326a51192fc9def5fcb0aaf97a59481b2e03728449f3bf4674"],"model_parameter_schema_sha256":"44b9ce16b482f552b778174bed4355f47e6836ce0057d6f8649c2c5242ec2d4d","observation_batch_sha256":"a1f271189335460a687c51a32564d8c413e5d26d419de788023c7624485fa421","parameter_context_sha256s":["7de3097f42e8a88f7c0fc730051918a7241b969722aa9a7cde918ee30a31bc48","798756bb3e1b110e6a1106fe7f8bdfb564095b1bba24c9a75ae1f959c55172d0","e96b72f59471a7c2585673d46f0bf1abd14e9550f0d4698d4c3369846fa7ce54","2d75c06a7a780edfd3553773aa87e6a42a7be8c36bafdb52b6960f004c0bc713"],"parameter_contexts":[["7546771113978883484263437964045806438662111759185791015625e-60","11799999999999999378275106209912337362766265869140625e-53","173e0","14915000000000000479616346638067625463008880615234375e-52","911880000000000023874235921539366245269775390625e-46","2441403999999999907544179222895763814449310302734375e-51","804190024457561634108060388825833797454833984375e-46","204760000000000008668621376273222267627716064453125e-50","125e0","6382338999999999894219282481344635016284883022308349609375e-60","-10244420275940371301004461201955564320087432861328125e-52","1781866674528745642103189084082259796559810638427734375e-55"],["-134847569752588090791494031261965602652708184905350208282470703125e-67","594236468801730715431365890955017761143608368001878261566162109375e-67","180017912417472714819833656645087227587964662234298884868621826171875e-66","1418607520800001666640541972417661876671966282909820125025755491178502191556556541462974507794569944962859153748e-111","8845655440625352648857741117815739972876412900659526159953506315626337854970961949163665849482640624046325683594e-110","2440844827436804634318075561842410785553470886133209208296951315132136921118907041394763268726819660514593124390e-111","7663581892294273545448908358214496202797406717397960807541474497626878947115214302243657584767788648605346679688e-110","1969240825499461802211304919239819353753191159531314854075138421568181711258926913643563239020295441150665283203e-111","1325364572440657479309700206814015555067953755497001111507415771484375e-67","6282212318214615756465681040143778091078274883329868316650390625e-65","-1072072896851752300436215264505413093610426376587095133168104624067673550947285901480121594886441016569733619690e-111","124566021831671000418754850780356235873114201240241527557373046875e-66"],["655617805825475631221880591648076830324498587287962436676025390625e-67","9508743447340736756304320487220849145160173065960407257080078125e-65","1833800730995227375994240863292528143091431047650985419750213623046875e-67","1417917885253575031749239105231976588110775334943781102058718916214643546711612204225261280043923761695623397827e-111","9296679062386854901358783194859654609329226514583805008942638117660874140339710702818365462007932364940643310547e-110","2577944736949078494160337607692592781342881499602461238125442612439294946878425018876868080042186193168163299560e-111","7878882507835004983969788421954676388128613320152368876411796051959239746420582406472021830268204212188720703125e-110","2169217507358018313945853497769126166281712195718656383954739160729475598750337628217721430701203644275665283203e-111","1252367052285700050356484123136036057388764675124548375606536865234375e-67","309195150609194360628341480268232999151223339140415191650390625e-64","-1058333689713571520504797215545769574180750731277403150472198582723563643195538452879134183604037389159202575684e-111","1270997660933430103646587551458058129583150730468332767486572265625e-67"],["-198677693676611585179799836231584464485422358848154544830322265625e-67","57609320846059259091181091461120189478606334887444972991943359375e-66","1775254064703433294292463204451515412785056469147093594074249267578125e-67","1511820147641718622918476971741807207880306295993783934112160787230623145896814610300573633594467537477612495422e-111","960258630601225151717874972757501900456619206584656923989050339660338180547416442323083174414932727813720703125e-109","2440647682677040963607622677350874631388510252718515686492712612734090805608963559159008127608103677630424499512e-111","8465342011233619871896312517565779815734231039347538616153274912377665211739297124182712650508619844913482666016e-110","2026505099471559043755406829896063764118357882619362331215937805892309193141892498246647846826817840337753295898e-111","11831816824116907918028654932152132772671393468044698238372802734375e-65","21978402204792821893046018966177967968178563751280307769775390625e-66","-9864287940456069940876250511362369096925883042059576142516236410718659728842899053757875549308664631098508834839e-112","117420221879594306973841610908237953481147997081279754638671875e-63"]],"point_count":4,"point_major":true,"point_sha256s":["159a3337d66cad590f1248fa621d3f4f35332fdf4d0995d8ba70ab0f5c9f1508","7eb16f897bae1b5c22cd43a774924b49b010f6fb7258b31afd0f8466e1f1ca4a","2bcc3bc060de99925b5f3bd43f2a61e7f11cc081e39c95de695744af1692c471","c22ca25c310ae54fe59d75f21fdf0d15f6098c9c123cffafdb59b5afee38fc3a"],"points":[{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-19.238453227798498","8.8163655276172204","-40.385225668371007"],"pdg":1},{"momentum":["45.594000000000001","19.238453227798498","-8.8163655276172204","40.385225668371007"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":5934198374352107017},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-43.81788816339764","10.048872829830856","-7.6043190194694503"],"pdg":1},{"momentum":["45.594000000000001","43.81788816339764","-10.048872829830856","7.6043190194694503"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":7090654850851803862},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-3.5617290341759489","19.061639270670348","41.264765001171959"],"pdg":1},{"momentum":["45.594000000000001","3.5617290341759489","-19.061639270670348","-41.264765001171959"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":5624516564888253598},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","9.9768452702989343","-21.600291839977629","38.893480004755425"],"pdg":1},{"momentum":["45.594000000000001","-9.9768452702989343","21.600291839977629","-38.893480004755425"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":1523975234645041793}],"precision_digits":96,"runtime_schema_sha256":"e2ff47ba61f9bb1ac9d9ad57731238ed0734b7c088fc75de57d74446cdffda07","source_dag_sha256":"bdc021db2a2392e9ef7cb0e18d7a030f17203de9f67ba2ca59611cf6f1cd1326"},"certified_relation_count":0,"discovery":{"candidate_index":{"algorithm":"complete-contract-anchor-tolerance-window-v1","completeness":"complete-within-configured-tolerance","contract_count":13,"exhaustive_fallback_contract_count":0,"nearest_rejected_scope":"zero-and-tolerance-window-screened-hypotheses","screened_pair_hypothesis_count":0,"theoretical_pair_hypothesis_count":0,"zero_hypothesis_count":6},"certificates":[],"certified_numerical_relation_count":0,"inspected_current_count":13,"nearest_rejected_hypothesis":{"current_id":9,"maximum_absolute_residual":"1164392548371285446027469689761581223628934989881795114030898221715273124934654529090207931656910454026508559578e-111","maximum_relative_residual":"1e0","maximum_tolerance_ratio":"9999999999141183142361652196748286659932854983968146242634831872161993352649924186297596743770544361841046167790e-42","relation_kind":"zero","representative_id":null},"numerical_candidate_count":0,"probe_contract":{"absolute_tolerance_binary64":"0x1.2f8ac174d6123p-266","algorithm":"authenticated-independent-recursive-decimal-probes-v1","candidate_capture_sha256":"9a9407d1c969921dab470127ef2b1b57d566d6f5a983a913cf769b519e81df28","candidate_kinematic_sha256s":["07e4764a3e34af43f874738e5f1726cc6d45c1317bdabcf6dea30904aa7f991a","70cd9a12303937f454b0c30763aa465692698b281d0a4385a3f2f6357510253b","64b49558828caaedb30476a6de774e99a9b48635bacb4343815901eded648b85","570330aa5081a5326a51192fc9def5fcb0aaf97a59481b2e03728449f3bf4674"],"candidate_observation_batch_sha256":"a1f271189335460a687c51a32564d8c413e5d26d419de788023c7624485fa421","candidate_parameter_context_sha256s":["7de3097f42e8a88f7c0fc730051918a7241b969722aa9a7cde918ee30a31bc48","798756bb3e1b110e6a1106fe7f8bdfb564095b1bba24c9a75ae1f959c55172d0","e96b72f59471a7c2585673d46f0bf1abd14e9550f0d4698d4c3369846fa7ce54","2d75c06a7a780edfd3553773aa87e6a42a7be8c36bafdb52b6960f004c0bc713"],"candidate_point_sha256s":["159a3337d66cad590f1248fa621d3f4f35332fdf4d0995d8ba70ab0f5c9f1508","7eb16f897bae1b5c22cd43a774924b49b010f6fb7258b31afd0f8466e1f1ca4a","2bcc3bc060de99925b5f3bd43f2a61e7f11cc081e39c95de695744af1692c471","c22ca25c310ae54fe59d75f21fdf0d15f6098c9c123cffafdb59b5afee38fc3a"],"deterministic":true,"independent_verification":true,"precision_digits":96,"relative_tolerance_binary64":"0x1.615e91d8f359dp-233","seed":1348026701,"verification_capture_sha256":"8ce4ac32cfedaefcbe01591c7a598e49a726b09d313b222248274eb7a94a93bf","verification_kinematic_sha256s":["c31ed6cc961f2a4a241e11711a35b830cc738d555c8e2fc7df00153e0dab3016","b4975d446bde8d6ba5bd12051c7767f1879b754d6e8b2aa492a899a6670b066c","5659e201917daf51114242cee2c73657dba48562762481a9efd8b10627743a36","f5a236b7f8fada514b6063f2dbcc63550f61048a9cc38aeef4a478ba58a4113d"],"verification_observation_batch_sha256":"cc27ba094f29ef2a37a6dc0ca8bdbe7fb9346b53936abad43b8be8b1720dd8bc","verification_parameter_context_sha256s":["8dda4f6392efe352d109ca46ce8f83ed689704d28d89d3c9df321e3f3be0e0fd","5179d9a73795cd5654ab34d720df261807d8ded5ea3a9aebe8c7196c9b701532","53554302860cbb36666f4db3c356be5ab4d8710ea0ebf76d7788bfcd60d0cc2f","76ebd8a6f280948ac619addce844a809e7706fbcf045777db7305eeef1ca8fbb"],"verification_point_sha256s":["38ed0b50de6095b7253d13e8981effe0dfffd4e713e4607112e4e3ecd2fa7cf9","4023248b796ba4b7bc20e64b6b5105aec8dbb8e24e574d6de0941c60a9c9da63","a9921723991888cfd7763f5e2d72dac750e0a48a1cc129ea98e4508dc1bf0757","d528614e20be9132c5681278e00726318484fd834a4a66f2ebbe7bf56d6c2471"]},"rejected_candidate_diagnostics":{"full_census_sha256":"e42bed471be043845d809a9b3b35fa5db88bd3581de89a7febb534fb70e37e8a","full_rejection_sha256":"344c32dc4f15362dc0a54b3a47d636e8160ce4849d84877d02652cab428be888","retained_count":6,"retained_sha256":"2716afbf79e1f11f1a82a46e01ffef60c99988653e889988145fc3b575790fa5","total_rejected_hypothesis_count":6,"truncated":false,"truncation_policy":"first-16-in-canonical-discovery-order-v1"},"rejected_candidates":[{"current_id":7,"maximum_absolute_residual":"1652235580118060607749261511176162534946511739379000450523047197337260455353682209680093564910839189023743200020e-111","maximum_relative_residual":"1e0","maximum_tolerance_ratio":"9999999999394759475969713566174655839364276451377038033568776217365162501060346088283174954243130258240751242537e-42","reason":"candidate-observations-not-equal","relation_kind":"zero","representative_id":null},{"current_id":8,"maximum_absolute_residual":"1168306982819169892451327541493810713291168212890625e-51","maximum_relative_residual":"1e0","maximum_tolerance_ratio":"9999999999144060624488151038517879690206808288796491042162793088938906758252406308380154985900508100600493984810e-42","reason":"candidate-observations-not-equal","relation_kind":"zero","representative_id":null},{"current_id":9,"maximum_absolute_residual":"1164392548371285446027469689761581223628934989881795114030898221715273124934654529090207931656910454026508559578e-111","maximum_relative_residual":"1e0","maximum_tolerance_ratio":"9999999999141183142361652196748286659932854983968146242634831872161993352649924186297596743770544361841046167790e-42","reason":"candidate-observations-not-equal","relation_kind":"zero","representative_id":null},{"current_id":10,"maximum_absolute_residual":"9695657984828618214780757810531834293463132347640931891757681861689768023207352297861870262983611296475618346152e-111","maximum_relative_residual":"1e0","maximum_tolerance_ratio":"9999999999896861091702298446687246774373803108151076260350345999523037547941496937054637321589883566856300078061e-42","reason":"candidate-observations-not-equal","relation_kind":"zero","representative_id":null},{"current_id":11,"maximum_absolute_residual":"68558655091378124524226223002187907695770263671875e-49","maximum_relative_residual":"1e0","maximum_tolerance_ratio":"9999999999854139539125781613658798877168975239601146772161282520238656184075944459478761896242213207914868027014e-42","reason":"candidate-observations-not-equal","relation_kind":"zero","representative_id":null},{"current_id":12,"maximum_absolute_residual":"9499137011509613433159712876250745750736940258969428366405225306572731102076613349371086233989171343803722964041e-111","maximum_relative_residual":"1e0","maximum_tolerance_ratio":"9999999999894727322377979320922707021146156027133230720620324960978969629429517351723925264292341389756253692312e-42","reason":"candidate-observations-not-equal","relation_kind":"zero","representative_id":null}],"rejected_hypothesis_count":6,"runtime_schema_sha256":"e2ff47ba61f9bb1ac9d9ad57731238ed0734b7c088fc75de57d74446cdffda07","schema_version":1,"scope":{"color_accuracy":"lc","execution_mode":"compiled","representation":"generic-dag"},"source_dag_sha256":"bdc021db2a2392e9ef7cb0e18d7a030f17203de9f67ba2ca59611cf6f1cd1326","source_semantics":{"abi":"pyamplicol-generic-dag-numerical-current-source-v1","sha256":"4794f99ccbc88dea1a22b767b7f8e0e3424eff81bc2731a56304ab1f191692fe"},"state":"no_certified_numerical_relation","structurally_proven_current_count":0,"tested_hypothesis_count":6,"verification_rejected_count":0,"warning":{"reason":"discovery alone never warns; the artifact aggregator warns once only when certified proof-less mappings are actually applied","required":false}},"effective_mode":"certified-reuse","effective_reuse_state":"enabled","relation_correctness":{"abi":"pyamplicol-numerical-current-relation-correctness-v1","applied_relation_count":0,"state":"no-applied-relations"},"requested_mode":"certified-reuse","schema_version":1,"scope":{"color_accuracy":"lc","execution_mode":"compiled","representation":"generic-dag"},"source_semantics":{"sha256":"4794f99ccbc88dea1a22b767b7f8e0e3424eff81bc2731a56304ab1f191692fe"},"state":"no_certified_numerical_relation","verification_capture":{"abi":"pyamplicol-generic-dag-current-observation-capture-v2","capture_contract_sha256":"8ce4ac32cfedaefcbe01591c7a598e49a726b09d313b222248274eb7a94a93bf","complete_current_component_digest":true,"components_embedded":false,"current_count":13,"evaluator":"symbolica-interpreted-high-precision-stage-replay","evaluator_output_partition":{"abi":"pyamplicol-generic-dag-current-id-output-partitions-v1","sha256":"91787d155d08a95fdad9fd74653fe688b91501a66209d22788363d1143e102fb"},"kinematic_sha256s":["c31ed6cc961f2a4a241e11711a35b830cc738d555c8e2fc7df00153e0dab3016","b4975d446bde8d6ba5bd12051c7767f1879b754d6e8b2aa492a899a6670b066c","5659e201917daf51114242cee2c73657dba48562762481a9efd8b10627743a36","f5a236b7f8fada514b6063f2dbcc63550f61048a9cc38aeef4a478ba58a4113d"],"model_parameter_schema_sha256":"44b9ce16b482f552b778174bed4355f47e6836ce0057d6f8649c2c5242ec2d4d","observation_batch_sha256":"cc27ba094f29ef2a37a6dc0ca8bdbe7fb9346b53936abad43b8be8b1720dd8bc","parameter_context_sha256s":["8dda4f6392efe352d109ca46ce8f83ed689704d28d89d3c9df321e3f3be0e0fd","5179d9a73795cd5654ab34d720df261807d8ded5ea3a9aebe8c7196c9b701532","53554302860cbb36666f4db3c356be5ab4d8710ea0ebf76d7788bfcd60d0cc2f","76ebd8a6f280948ac619addce844a809e7706fbcf045777db7305eeef1ca8fbb"],"parameter_contexts":[["-428743123839055681839030516322441854981661890633404254913330078125e-67","1229337671608740661891999608468228899482710403390228748321533203125e-67","1814639669513577216059053488252106323130874443450011312961578369140625e-67","1473671772981664783759571700717208013445460371498901712225635926635762647447010914580900475812086369842290878296e-111","8843125580122167002844104223045051953458192202676716725019566046137861397777313321455494588008150458335876464844e-110","2289441304993553825072887073985273072170840029234440951548546443206770741745931935229307896406680811196565628052e-111","8456073069005570746018969754733054419972008814063024396454775721011697868327583460512641977402381598949432373047e-110","2068602749199903732969189208280149108381521728426447693180137255794031212667409558303432959291967563331127166748e-111","1279266708316745219044968141786089432798689813353121280670166015625e-64","524333998498528991750468851440469819635836756788194179534912109375e-67","-1085929727281062708451575873809950624815601737563875183896125805926657086509113520067515423761506099253892898560e-111","1522854766045041089556587310394064616048126481473445892333984375e-64"],["-35418375322064492101881323649070765213764389045536518096923828125e-67","1660962210334748333031315396801641526280945981852710247039794921875e-67","17493592069728094710409529825845265094130809302441775798797607421875e-65","1530406092065955264673871307483923964621295097973176123710813060086357152798225422785094451683107763528823852539e-111","8906689954329377606370498684149517754779489336041931892357142477629163208364959647411751575418747961521148681641e-110","2580121239147156642219500040447588748961658131580312754416048594926021891914156430880566972518863622099161148071e-111","7734081846978071728573140569593726170375753456828630580649800857247352318252220371164185053203254938125610351562e-110","2015701399593413225619641804985017050659171719898402855246566655294162954438486057284762864583171904087066650391e-111","12700791754025640589611904907041406431744690053164958953857421875e-62","-264681122030299864446366113479580661760337534360587596893310546875e-67","-1060901414344373237434382915390280660417560973951806154604697837167962419692305089946593454897083574905991554260e-111","1338982902624709452643375802438630017832110752351582050323486328125e-67"],["-336272653953548561611285212802346933358421665616333484649658203125e-67","88586745445987840038627215977218298803563811816275119781494140625e-66","162846372680865255608016251877290248017970952787436544895172119140625e-66","1492340508937200786725469244048655715224167723830991532060027760483190030217333713058458499745029257610440254211e-111","9421268372781718216318104960461624046206706349307729337504427790325281532636536585556541467667557299137115478516e-110","2483305896079634061934368964301559209718570351082119579049858724800376483070329935998188375378958880901336669922e-111","7983858962816643230338749771824556398846028995714598277998142041976214447647486327497290403698571026325225830078e-110","2113660793170497975583220687988284652552932576582990698851978087427923416784583676708564325963379815220832824707e-111","1324304162192006783244831191227730560200370746315456926822662353515625e-67","-259913796597456512934708368345315676606332999654114246368408203125e-67","-9685953671008229505428711647131589734155372223015304768985735886181764535505112762026058703668240923434495925903e-112","20033115843573731009049330997751070526646799407899379730224609375e-65"],["250919662272214291775661483552273267605414730496704578399658203125e-67","1615809963278920216423850501896719578098782221786677837371826171875e-67","17558079431371018799414138351899783430098977987654507160186767578125e-65","1513783766555074105242574941698622142531153479225013798943917579008455705425655393736583675945439608767628669739e-111","9061637160718448622289697114359255838654422885908568502452253909498135165875853935801842453656718134880065917969e-110","2355706548278581027945285432992524857842153847738050148868578662600358575123209864399242974286607932299375534058e-111","8333521853907423237813651698536875392301829639782776542224265016481447041277186293939394090557470917701721191406e-110","2030340797976007219626355200275548987320739533553519716663044757842158737721691141864255314430920407176017761230e-111","1192779619339804226174202804976187675123355802497826516628265380859375e-67","3364632371368749970386678727063411997733055613934993743896484375e-66","-1065393925959148812223570530257695392403323799708863122130061030802530443710321797490259143614821368828415870666e-111","16553785603523037510951577966356040860773646272718906402587890625e-65"]],"point_count":4,"point_major":true,"point_sha256s":["38ed0b50de6095b7253d13e8981effe0dfffd4e713e4607112e4e3ecd2fa7cf9","4023248b796ba4b7bc20e64b6b5105aec8dbb8e24e574d6de0941c60a9c9da63","a9921723991888cfd7763f5e2d72dac750e0a48a1cc129ea98e4508dc1bf0757","d528614e20be9132c5681278e00726318484fd834a4a66f2ebbe7bf56d6c2471"],"points":[{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-22.698385413478491","25.794624041395899","-29.97054397544742"],"pdg":1},{"momentum":["45.594000000000001","22.698385413478491","-25.794624041395899","29.97054397544742"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":8804252587108628234},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-27.64422199849648","26.414157231586692","24.837514445750397"],"pdg":1},{"momentum":["45.594000000000001","27.64422199849648","-26.414157231586692","-24.837514445750397"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":8157271186662746954},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-7.6309323217086416","26.256974175185977","-36.48496971446076"],"pdg":1},{"momentum":["45.594000000000001","7.6309323217086416","-26.256974175185977","36.48496971446076"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":3763731385338703666},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-40.50878035289923","17.470481847616863","11.516675489595725"],"pdg":1},{"momentum":["45.594000000000001","40.50878035289923","-17.470481847616863","-11.516675489595725"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":5222851728213758142}],"precision_digits":96,"runtime_schema_sha256":"e2ff47ba61f9bb1ac9d9ad57731238ed0734b7c088fc75de57d74446cdffda07","source_dag_sha256":"bdc021db2a2392e9ef7cb0e18d7a030f17203de9f67ba2ca59611cf6f1cd1326"},"warning":{"code":null,"emit":"never","message":null,"required":false}},"primary":{"abi":"pyamplicol-generic-dag-numerical-current-warmup-v1","application":{"abi":"pyamplicol-authenticated-numerical-current-relation-set-v1","applied_relation_count":0,"candidate_capture_sha256":"bcaa65582e991b4a76f8de27ecbaefe690b19ff897485b7c43f2af5ede917dd8","certificate_replay":{"algorithm":"authenticated-independent-recursive-decimal-probes-v1","certificate_set_sha256":"f723a545b9a6993645136423ad45e32094a551327fabf88878a71fef3894783c","status":"no_certified_numerical_relation"},"certificates":[],"certified_relation_count":0,"interaction_evaluation_count_before":2,"interaction_evaluation_count_projected":2,"interaction_evaluation_savings_projected":0,"mappings":[],"relation_kind_counts":{"equal":0,"opposite":0,"zero":0},"requested_mode":"certified-reuse","runtime_schema_sha256":"5489f282ed0ac3fb29ca65a609f7b3a3dcc12d0b631a69a9959182c74ea58be4","schema_version":1,"scope":{"color_accuracy":"lc","execution_mode":"compiled","representation":"generic-dag"},"source_dag_sha256":"b98dd714a832e270769a03580c60dba91db15d6d0198b9cebbca0223072cc2d2","source_semantics":{"abi":"pyamplicol-generic-dag-numerical-current-source-v1","sha256":"e8323adb262a224d3dc35de452f9d139861670bd44715348e16b52578950b127"},"state":"no_certified_numerical_relation","verification_capture_sha256":"eb94dbc941b9dbf25d623f3966178198efe93ee7d16f6fc4eebfa87ad7669c13","warning":{"code":null,"emit":"never","message":null,"required":false}},"application_capture":null,"application_scope":{"abi":"pyamplicol-generic-dag-numerical-relation-application-scope-v1","allowed_relation_kinds":["equal","opposite","zero"],"application_eligible_relation_count":0,"discovered_relation_count":0,"policy":"exact-physical-selector-member-set-v1","reason":"complete-generic-dag","scope_suppressed_relation_count":0},"application_validation":{"checked_component_count":0,"checked_current_count":0,"maximum_absolute_residual":null,"maximum_relative_residual":null,"maximum_tolerance_ratio":null,"status":"not-required-no-applied-relations"},"applied_relation_count":0,"candidate_capture":{"abi":"pyamplicol-generic-dag-current-observation-capture-v2","capture_contract_sha256":"bcaa65582e991b4a76f8de27ecbaefe690b19ff897485b7c43f2af5ede917dd8","complete_current_component_digest":true,"components_embedded":false,"current_count":7,"evaluator":"symbolica-interpreted-high-precision-stage-replay","evaluator_output_partition":{"abi":"pyamplicol-generic-dag-current-id-output-partitions-v1","sha256":"bffc25fd5ab44df7a300465635437af32a2484147204a7942d4c7e1dcb899e06"},"kinematic_sha256s":["07e4764a3e34af43f874738e5f1726cc6d45c1317bdabcf6dea30904aa7f991a","70cd9a12303937f454b0c30763aa465692698b281d0a4385a3f2f6357510253b","64b49558828caaedb30476a6de774e99a9b48635bacb4343815901eded648b85","570330aa5081a5326a51192fc9def5fcb0aaf97a59481b2e03728449f3bf4674"],"model_parameter_schema_sha256":"44b9ce16b482f552b778174bed4355f47e6836ce0057d6f8649c2c5242ec2d4d","observation_batch_sha256":"e2bd8fb3beb6d7a4518d1413f0af42540b9daa23a78fedc4fd0c202556ba8646","parameter_context_sha256s":["7de3097f42e8a88f7c0fc730051918a7241b969722aa9a7cde918ee30a31bc48","798756bb3e1b110e6a1106fe7f8bdfb564095b1bba24c9a75ae1f959c55172d0","e96b72f59471a7c2585673d46f0bf1abd14e9550f0d4698d4c3369846fa7ce54","2d75c06a7a780edfd3553773aa87e6a42a7be8c36bafdb52b6960f004c0bc713"],"parameter_contexts":[["7546771113978883484263437964045806438662111759185791015625e-60","11799999999999999378275106209912337362766265869140625e-53","173e0","14915000000000000479616346638067625463008880615234375e-52","911880000000000023874235921539366245269775390625e-46","2441403999999999907544179222895763814449310302734375e-51","804190024457561634108060388825833797454833984375e-46","204760000000000008668621376273222267627716064453125e-50","125e0","6382338999999999894219282481344635016284883022308349609375e-60","-10244420275940371301004461201955564320087432861328125e-52","1781866674528745642103189084082259796559810638427734375e-55"],["-134847569752588090791494031261965602652708184905350208282470703125e-67","594236468801730715431365890955017761143608368001878261566162109375e-67","180017912417472714819833656645087227587964662234298884868621826171875e-66","1418607520800001666640541972417661876671966282909820125025755491178502191556556541462974507794569944962859153748e-111","8845655440625352648857741117815739972876412900659526159953506315626337854970961949163665849482640624046325683594e-110","2440844827436804634318075561842410785553470886133209208296951315132136921118907041394763268726819660514593124390e-111","7663581892294273545448908358214496202797406717397960807541474497626878947115214302243657584767788648605346679688e-110","1969240825499461802211304919239819353753191159531314854075138421568181711258926913643563239020295441150665283203e-111","1325364572440657479309700206814015555067953755497001111507415771484375e-67","6282212318214615756465681040143778091078274883329868316650390625e-65","-1072072896851752300436215264505413093610426376587095133168104624067673550947285901480121594886441016569733619690e-111","124566021831671000418754850780356235873114201240241527557373046875e-66"],["655617805825475631221880591648076830324498587287962436676025390625e-67","9508743447340736756304320487220849145160173065960407257080078125e-65","1833800730995227375994240863292528143091431047650985419750213623046875e-67","1417917885253575031749239105231976588110775334943781102058718916214643546711612204225261280043923761695623397827e-111","9296679062386854901358783194859654609329226514583805008942638117660874140339710702818365462007932364940643310547e-110","2577944736949078494160337607692592781342881499602461238125442612439294946878425018876868080042186193168163299560e-111","7878882507835004983969788421954676388128613320152368876411796051959239746420582406472021830268204212188720703125e-110","2169217507358018313945853497769126166281712195718656383954739160729475598750337628217721430701203644275665283203e-111","1252367052285700050356484123136036057388764675124548375606536865234375e-67","309195150609194360628341480268232999151223339140415191650390625e-64","-1058333689713571520504797215545769574180750731277403150472198582723563643195538452879134183604037389159202575684e-111","1270997660933430103646587551458058129583150730468332767486572265625e-67"],["-198677693676611585179799836231584464485422358848154544830322265625e-67","57609320846059259091181091461120189478606334887444972991943359375e-66","1775254064703433294292463204451515412785056469147093594074249267578125e-67","1511820147641718622918476971741807207880306295993783934112160787230623145896814610300573633594467537477612495422e-111","960258630601225151717874972757501900456619206584656923989050339660338180547416442323083174414932727813720703125e-109","2440647682677040963607622677350874631388510252718515686492712612734090805608963559159008127608103677630424499512e-111","8465342011233619871896312517565779815734231039347538616153274912377665211739297124182712650508619844913482666016e-110","2026505099471559043755406829896063764118357882619362331215937805892309193141892498246647846826817840337753295898e-111","11831816824116907918028654932152132772671393468044698238372802734375e-65","21978402204792821893046018966177967968178563751280307769775390625e-66","-9864287940456069940876250511362369096925883042059576142516236410718659728842899053757875549308664631098508834839e-112","117420221879594306973841610908237953481147997081279754638671875e-63"]],"point_count":4,"point_major":true,"point_sha256s":["159a3337d66cad590f1248fa621d3f4f35332fdf4d0995d8ba70ab0f5c9f1508","7eb16f897bae1b5c22cd43a774924b49b010f6fb7258b31afd0f8466e1f1ca4a","2bcc3bc060de99925b5f3bd43f2a61e7f11cc081e39c95de695744af1692c471","c22ca25c310ae54fe59d75f21fdf0d15f6098c9c123cffafdb59b5afee38fc3a"],"points":[{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-19.238453227798498","8.8163655276172204","-40.385225668371007"],"pdg":1},{"momentum":["45.594000000000001","19.238453227798498","-8.8163655276172204","40.385225668371007"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":5934198374352107017},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-43.81788816339764","10.048872829830856","-7.6043190194694503"],"pdg":1},{"momentum":["45.594000000000001","43.81788816339764","-10.048872829830856","7.6043190194694503"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":7090654850851803862},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-3.5617290341759489","19.061639270670348","41.264765001171959"],"pdg":1},{"momentum":["45.594000000000001","3.5617290341759489","-19.061639270670348","-41.264765001171959"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":5624516564888253598},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","9.9768452702989343","-21.600291839977629","38.893480004755425"],"pdg":1},{"momentum":["45.594000000000001","-9.9768452702989343","21.600291839977629","-38.893480004755425"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":1523975234645041793}],"precision_digits":96,"runtime_schema_sha256":"5489f282ed0ac3fb29ca65a609f7b3a3dcc12d0b631a69a9959182c74ea58be4","source_dag_sha256":"b98dd714a832e270769a03580c60dba91db15d6d0198b9cebbca0223072cc2d2"},"certified_relation_count":0,"discovery":{"candidate_index":{"algorithm":"complete-contract-anchor-tolerance-window-v1","completeness":"complete-within-configured-tolerance","contract_count":7,"exhaustive_fallback_contract_count":0,"nearest_rejected_scope":"zero-and-tolerance-window-screened-hypotheses","screened_pair_hypothesis_count":0,"theoretical_pair_hypothesis_count":0,"zero_hypothesis_count":2},"certificates":[],"certified_numerical_relation_count":0,"inspected_current_count":7,"nearest_rejected_hypothesis":{"current_id":5,"maximum_absolute_residual":"1652235580118060607749261511176162534946511739379000450523047197337260455353682209680093564910839189023743200020e-111","maximum_relative_residual":"1e0","maximum_tolerance_ratio":"9999999999394759475969713566174655839364276451377038033568776217365162501060346088283174954243130258240751242537e-42","relation_kind":"zero","representative_id":null},"numerical_candidate_count":0,"probe_contract":{"absolute_tolerance_binary64":"0x1.2f8ac174d6123p-266","algorithm":"authenticated-independent-recursive-decimal-probes-v1","candidate_capture_sha256":"bcaa65582e991b4a76f8de27ecbaefe690b19ff897485b7c43f2af5ede917dd8","candidate_kinematic_sha256s":["07e4764a3e34af43f874738e5f1726cc6d45c1317bdabcf6dea30904aa7f991a","70cd9a12303937f454b0c30763aa465692698b281d0a4385a3f2f6357510253b","64b49558828caaedb30476a6de774e99a9b48635bacb4343815901eded648b85","570330aa5081a5326a51192fc9def5fcb0aaf97a59481b2e03728449f3bf4674"],"candidate_observation_batch_sha256":"e2bd8fb3beb6d7a4518d1413f0af42540b9daa23a78fedc4fd0c202556ba8646","candidate_parameter_context_sha256s":["7de3097f42e8a88f7c0fc730051918a7241b969722aa9a7cde918ee30a31bc48","798756bb3e1b110e6a1106fe7f8bdfb564095b1bba24c9a75ae1f959c55172d0","e96b72f59471a7c2585673d46f0bf1abd14e9550f0d4698d4c3369846fa7ce54","2d75c06a7a780edfd3553773aa87e6a42a7be8c36bafdb52b6960f004c0bc713"],"candidate_point_sha256s":["159a3337d66cad590f1248fa621d3f4f35332fdf4d0995d8ba70ab0f5c9f1508","7eb16f897bae1b5c22cd43a774924b49b010f6fb7258b31afd0f8466e1f1ca4a","2bcc3bc060de99925b5f3bd43f2a61e7f11cc081e39c95de695744af1692c471","c22ca25c310ae54fe59d75f21fdf0d15f6098c9c123cffafdb59b5afee38fc3a"],"deterministic":true,"independent_verification":true,"precision_digits":96,"relative_tolerance_binary64":"0x1.615e91d8f359dp-233","seed":1348026701,"verification_capture_sha256":"eb94dbc941b9dbf25d623f3966178198efe93ee7d16f6fc4eebfa87ad7669c13","verification_kinematic_sha256s":["c31ed6cc961f2a4a241e11711a35b830cc738d555c8e2fc7df00153e0dab3016","b4975d446bde8d6ba5bd12051c7767f1879b754d6e8b2aa492a899a6670b066c","5659e201917daf51114242cee2c73657dba48562762481a9efd8b10627743a36","f5a236b7f8fada514b6063f2dbcc63550f61048a9cc38aeef4a478ba58a4113d"],"verification_observation_batch_sha256":"443741c28cb19a946b9189f072a4ed604989d9b73ca885051dc61a51ea096f5f","verification_parameter_context_sha256s":["8dda4f6392efe352d109ca46ce8f83ed689704d28d89d3c9df321e3f3be0e0fd","5179d9a73795cd5654ab34d720df261807d8ded5ea3a9aebe8c7196c9b701532","53554302860cbb36666f4db3c356be5ab4d8710ea0ebf76d7788bfcd60d0cc2f","76ebd8a6f280948ac619addce844a809e7706fbcf045777db7305eeef1ca8fbb"],"verification_point_sha256s":["38ed0b50de6095b7253d13e8981effe0dfffd4e713e4607112e4e3ecd2fa7cf9","4023248b796ba4b7bc20e64b6b5105aec8dbb8e24e574d6de0941c60a9c9da63","a9921723991888cfd7763f5e2d72dac750e0a48a1cc129ea98e4508dc1bf0757","d528614e20be9132c5681278e00726318484fd834a4a66f2ebbe7bf56d6c2471"]},"rejected_candidate_diagnostics":{"full_census_sha256":"789c7ce83848301f8d9c0b84b47dfcf74bf99d42e54580c6ca97f354c7041fd3","full_rejection_sha256":"04ed9fe54992a29b1867ed1134679975d002be41baabddb6bfee516c6a9c1689","retained_count":2,"retained_sha256":"963064c684d2f3d565c58d9375bb19561d0571b31121eebfd58b0652474e8f54","total_rejected_hypothesis_count":2,"truncated":false,"truncation_policy":"first-16-in-canonical-discovery-order-v1"},"rejected_candidates":[{"current_id":5,"maximum_absolute_residual":"1652235580118060607749261511176162534946511739379000450523047197337260455353682209680093564910839189023743200020e-111","maximum_relative_residual":"1e0","maximum_tolerance_ratio":"9999999999394759475969713566174655839364276451377038033568776217365162501060346088283174954243130258240751242537e-42","reason":"candidate-observations-not-equal","relation_kind":"zero","representative_id":null},{"current_id":6,"maximum_absolute_residual":"9695657984828618214780757810531834293463132347640931891757681861689768023207352297861870262983611296475618346152e-111","maximum_relative_residual":"1e0","maximum_tolerance_ratio":"9999999999896861091702298446687246774373803108151076260350345999523037547941496937054637321589883566856300078061e-42","reason":"candidate-observations-not-equal","relation_kind":"zero","representative_id":null}],"rejected_hypothesis_count":2,"runtime_schema_sha256":"5489f282ed0ac3fb29ca65a609f7b3a3dcc12d0b631a69a9959182c74ea58be4","schema_version":1,"scope":{"color_accuracy":"lc","execution_mode":"compiled","representation":"generic-dag"},"source_dag_sha256":"b98dd714a832e270769a03580c60dba91db15d6d0198b9cebbca0223072cc2d2","source_semantics":{"abi":"pyamplicol-generic-dag-numerical-current-source-v1","sha256":"e8323adb262a224d3dc35de452f9d139861670bd44715348e16b52578950b127"},"state":"no_certified_numerical_relation","structurally_proven_current_count":0,"tested_hypothesis_count":2,"verification_rejected_count":0,"warning":{"reason":"discovery alone never warns; the artifact aggregator warns once only when certified proof-less mappings are actually applied","required":false}},"effective_mode":"certified-reuse","effective_reuse_state":"enabled","relation_correctness":{"abi":"pyamplicol-numerical-current-relation-correctness-v1","applied_relation_count":0,"state":"no-applied-relations"},"requested_mode":"certified-reuse","schema_version":1,"scope":{"color_accuracy":"lc","execution_mode":"compiled","representation":"generic-dag"},"source_semantics":{"sha256":"e8323adb262a224d3dc35de452f9d139861670bd44715348e16b52578950b127"},"state":"no_certified_numerical_relation","verification_capture":{"abi":"pyamplicol-generic-dag-current-observation-capture-v2","capture_contract_sha256":"eb94dbc941b9dbf25d623f3966178198efe93ee7d16f6fc4eebfa87ad7669c13","complete_current_component_digest":true,"components_embedded":false,"current_count":7,"evaluator":"symbolica-interpreted-high-precision-stage-replay","evaluator_output_partition":{"abi":"pyamplicol-generic-dag-current-id-output-partitions-v1","sha256":"bffc25fd5ab44df7a300465635437af32a2484147204a7942d4c7e1dcb899e06"},"kinematic_sha256s":["c31ed6cc961f2a4a241e11711a35b830cc738d555c8e2fc7df00153e0dab3016","b4975d446bde8d6ba5bd12051c7767f1879b754d6e8b2aa492a899a6670b066c","5659e201917daf51114242cee2c73657dba48562762481a9efd8b10627743a36","f5a236b7f8fada514b6063f2dbcc63550f61048a9cc38aeef4a478ba58a4113d"],"model_parameter_schema_sha256":"44b9ce16b482f552b778174bed4355f47e6836ce0057d6f8649c2c5242ec2d4d","observation_batch_sha256":"443741c28cb19a946b9189f072a4ed604989d9b73ca885051dc61a51ea096f5f","parameter_context_sha256s":["8dda4f6392efe352d109ca46ce8f83ed689704d28d89d3c9df321e3f3be0e0fd","5179d9a73795cd5654ab34d720df261807d8ded5ea3a9aebe8c7196c9b701532","53554302860cbb36666f4db3c356be5ab4d8710ea0ebf76d7788bfcd60d0cc2f","76ebd8a6f280948ac619addce844a809e7706fbcf045777db7305eeef1ca8fbb"],"parameter_contexts":[["-428743123839055681839030516322441854981661890633404254913330078125e-67","1229337671608740661891999608468228899482710403390228748321533203125e-67","1814639669513577216059053488252106323130874443450011312961578369140625e-67","1473671772981664783759571700717208013445460371498901712225635926635762647447010914580900475812086369842290878296e-111","8843125580122167002844104223045051953458192202676716725019566046137861397777313321455494588008150458335876464844e-110","2289441304993553825072887073985273072170840029234440951548546443206770741745931935229307896406680811196565628052e-111","8456073069005570746018969754733054419972008814063024396454775721011697868327583460512641977402381598949432373047e-110","2068602749199903732969189208280149108381521728426447693180137255794031212667409558303432959291967563331127166748e-111","1279266708316745219044968141786089432798689813353121280670166015625e-64","524333998498528991750468851440469819635836756788194179534912109375e-67","-1085929727281062708451575873809950624815601737563875183896125805926657086509113520067515423761506099253892898560e-111","1522854766045041089556587310394064616048126481473445892333984375e-64"],["-35418375322064492101881323649070765213764389045536518096923828125e-67","1660962210334748333031315396801641526280945981852710247039794921875e-67","17493592069728094710409529825845265094130809302441775798797607421875e-65","1530406092065955264673871307483923964621295097973176123710813060086357152798225422785094451683107763528823852539e-111","8906689954329377606370498684149517754779489336041931892357142477629163208364959647411751575418747961521148681641e-110","2580121239147156642219500040447588748961658131580312754416048594926021891914156430880566972518863622099161148071e-111","7734081846978071728573140569593726170375753456828630580649800857247352318252220371164185053203254938125610351562e-110","2015701399593413225619641804985017050659171719898402855246566655294162954438486057284762864583171904087066650391e-111","12700791754025640589611904907041406431744690053164958953857421875e-62","-264681122030299864446366113479580661760337534360587596893310546875e-67","-1060901414344373237434382915390280660417560973951806154604697837167962419692305089946593454897083574905991554260e-111","1338982902624709452643375802438630017832110752351582050323486328125e-67"],["-336272653953548561611285212802346933358421665616333484649658203125e-67","88586745445987840038627215977218298803563811816275119781494140625e-66","162846372680865255608016251877290248017970952787436544895172119140625e-66","1492340508937200786725469244048655715224167723830991532060027760483190030217333713058458499745029257610440254211e-111","9421268372781718216318104960461624046206706349307729337504427790325281532636536585556541467667557299137115478516e-110","2483305896079634061934368964301559209718570351082119579049858724800376483070329935998188375378958880901336669922e-111","7983858962816643230338749771824556398846028995714598277998142041976214447647486327497290403698571026325225830078e-110","2113660793170497975583220687988284652552932576582990698851978087427923416784583676708564325963379815220832824707e-111","1324304162192006783244831191227730560200370746315456926822662353515625e-67","-259913796597456512934708368345315676606332999654114246368408203125e-67","-9685953671008229505428711647131589734155372223015304768985735886181764535505112762026058703668240923434495925903e-112","20033115843573731009049330997751070526646799407899379730224609375e-65"],["250919662272214291775661483552273267605414730496704578399658203125e-67","1615809963278920216423850501896719578098782221786677837371826171875e-67","17558079431371018799414138351899783430098977987654507160186767578125e-65","1513783766555074105242574941698622142531153479225013798943917579008455705425655393736583675945439608767628669739e-111","9061637160718448622289697114359255838654422885908568502452253909498135165875853935801842453656718134880065917969e-110","2355706548278581027945285432992524857842153847738050148868578662600358575123209864399242974286607932299375534058e-111","8333521853907423237813651698536875392301829639782776542224265016481447041277186293939394090557470917701721191406e-110","2030340797976007219626355200275548987320739533553519716663044757842158737721691141864255314430920407176017761230e-111","1192779619339804226174202804976187675123355802497826516628265380859375e-67","3364632371368749970386678727063411997733055613934993743896484375e-66","-1065393925959148812223570530257695392403323799708863122130061030802530443710321797490259143614821368828415870666e-111","16553785603523037510951577966356040860773646272718906402587890625e-65"]],"point_count":4,"point_major":true,"point_sha256s":["38ed0b50de6095b7253d13e8981effe0dfffd4e713e4607112e4e3ecd2fa7cf9","4023248b796ba4b7bc20e64b6b5105aec8dbb8e24e574d6de0941c60a9c9da63","a9921723991888cfd7763f5e2d72dac750e0a48a1cc129ea98e4508dc1bf0757","d528614e20be9132c5681278e00726318484fd834a4a66f2ebbe7bf56d6c2471"],"points":[{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-22.698385413478491","25.794624041395899","-29.97054397544742"],"pdg":1},{"momentum":["45.594000000000001","22.698385413478491","-25.794624041395899","29.97054397544742"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":8804252587108628234},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-27.64422199849648","26.414157231586692","24.837514445750397"],"pdg":1},{"momentum":["45.594000000000001","27.64422199849648","-26.414157231586692","-24.837514445750397"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":8157271186662746954},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-7.6309323217086416","26.256974175185977","-36.48496971446076"],"pdg":1},{"momentum":["45.594000000000001","7.6309323217086416","-26.256974175185977","36.48496971446076"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":3763731385338703666},{"available":true,"error":null,"kind":"pyamplicol-rusticol-validation-momenta","points":[[{"momentum":["45.594000000000001","-40.50878035289923","17.470481847616863","11.516675489595725"],"pdg":1},{"momentum":["45.594000000000001","40.50878035289923","-17.470481847616863","-11.516675489595725"],"pdg":-1},{"momentum":["91.188000000000002","0","0","0"],"pdg":23}]],"process":"d d~ > z","process_id":"d_dbar_to_z","schema_version":1,"seed":5222851728213758142}],"precision_digits":96,"runtime_schema_sha256":"5489f282ed0ac3fb29ca65a609f7b3a3dcc12d0b631a69a9959182c74ea58be4","source_dag_sha256":"b98dd714a832e270769a03580c60dba91db15d6d0198b9cebbca0223072cc2d2"},"warning":{"code":null,"emit":"never","message":null,"required":false}}},"opt_out_flag":"--no-numerical-current-reuse","relation_correctness":{"abi":"pyamplicol-numerical-current-relation-correctness-v1","applied_relation_count":0,"state":"no-applied-relations"},"requested_mode":"certified-reuse","schema_version":1,"structural_exact_discovery":null,"warning":{"code":null,"emit":"never","message":null,"required":false}},"structural_helicity_reduction":{"after_amplitude_roots":2,"applied":true,"before_amplitude_roots":6,"mode":"proven global-helicity-flip equivalence"}},"helicity_selector_runtime_schema_sha256s":["4dd26bae3d23f4e6de0249aa8fb8534e08c130c1425a2d20a076f9f6ddf3f44c","7a919ac899d90294670b45c8e4ca7c2e1f03552d8c8247af337b910c6b7144a1"],"helicity_sum_runtime_schema_sha256":"e2ff47ba61f9bb1ac9d9ad57731238ed0734b7c088fc75de57d74446cdffda07","id":"d_dbar_to_z","runtime_schema_sha256":"5489f282ed0ac3fb29ca65a609f7b3a3dcc12d0b631a69a9959182c74ea58be4","validation_momenta_path":"processes/d_dbar_to_z/validation-momenta.json"}],"phase_timings_seconds":{"dag":0.0015193750150501728,"evaluator-construction":0.0053629581816494465,"jit":0.4948723749257624,"model-loading":0.06822012504562736,"process-expansion":0.0011749169789254665,"warmup-filter":0.02937237499281764},"schema_version":1}},"kind":"pyamplicol-process","model":{"compiled_schema_version":9,"content_sha256":"db50b0cb34998c1a9f7bf63c2b7a4d80c01f373a00d9bee81372b2d43a506962","name":"built-in-sm","restriction":null,"source_kind":"built-in-sm"},"payloads":[{"executable":false,"media_type":"text/x-makefile","path":"API/c/Makefile","role":"api-build-file","sha256":"732ce49a9d3001664e38a4ef4254eb4a2e60d7c09860d27861b559618abc30c5","size_bytes":1300},{"executable":false,"media_type":"text/x-csrc","path":"API/c/check_standalone.c","role":"api-source","sha256":"a8a32263c2a1db282d15711ebf8fbb68b45fb05af317c18302726b021b862337","size_bytes":27726},{"executable":false,"media_type":"text/x-makefile","path":"API/cpp/Makefile","role":"api-build-file","sha256":"4d14b139fd6ae56345951656ff9a46c478433e4f99eaf039643dd1defdb3d4c3","size_bytes":1315},{"executable":false,"media_type":"text/x-c++src","path":"API/cpp/check_standalone.cpp","role":"api-source","sha256":"35d42c32d6e046f533040f5158ba039a9736fd540d690f71ce8509ef788d8fd2","size_bytes":11822},{"executable":false,"media_type":"text/x-makefile","path":"API/fortran/Makefile","role":"api-build-file","sha256":"264c677c1accb48b00eea59c6787a1a7550541897b0a96b2cffeeb6ba4d42427","size_bytes":1482},{"executable":false,"media_type":"text/x-fortran","path":"API/fortran/check_standalone.f90","role":"api-source","sha256":"530ddeafafd7980fd3e7eafae1149f5a2ce759f3937e9c67751108a7edd7d394","size_bytes":15533},{"executable":true,"media_type":"text/x-python","path":"API/python/check_standalone.py","role":"api-source","sha256":"a1b1c7900737fdf5d1b392e0dd9d048156c49269e3ab3654aca32e348080b490","size_bytes":14172},{"executable":false,"media_type":"text/x-makefile","path":"API/rust/Makefile","role":"api-build-file","sha256":"9116f9eea3414e024107c57043d8898b316abafbe9f8757e5dca3e9878b110d8","size_bytes":1653},{"executable":false,"media_type":"text/x-rust","path":"API/rust/check_standalone.rs","role":"api-source","sha256":"6010ce4ab7f7443a490b12d9a2fcfe99c94ce00246fd9675cec0bad84cbebb2f","size_bytes":15278},{"executable":false,"media_type":"text/tab-separated-values","path":"API/validation_points.dat","role":"validation-momenta","sha256":"aced8cb80350c33759d1f40fcaee8a70af13a1a4214bc7cd4653a6c5d0d7211f","size_bytes":154},{"executable":false,"media_type":"application/toml","path":"config/effective.toml","role":"configuration-effective","sha256":"92efe66607e964cddbfd527bc78c2d3b9c11ba96630d24fca007f73361b86835","size_bytes":1764},{"executable":false,"media_type":"application/toml","path":"config/requested.toml","role":"configuration-requested","sha256":"2001e198cade9cdca3a6f3bebc3c99f3349f7f5b95152ea322410299e926820d","size_bytes":1772},{"executable":false,"media_type":"application/octet-stream","path":"evaluators.pacbin","role":"evaluator-state","sha256":"c213ab3d9e4a562765b1d2f22454747f46a8641f5aa6b07e68f3cb5f077ce805","size_bytes":16000,"target":{"cpu_features":[],"triple":"portable-64le"}},{"executable":false,"media_type":"application/json","path":"model/compiled-model.json","role":"compiled-model","sha256":"895f42c74958c37e91c6a281166a6bd6e720c78b5d57b071624548e6b424316f","size_bytes":230932},{"executable":false,"media_type":"application/json","path":"model/parameters.json","role":"model-parameters","sha256":"e0bc97dba08061be379f09c58ed03bc78c3429be6a5796b8ee39355730e15e86","size_bytes":610},{"executable":false,"media_type":"application/json","path":"processes/d_dbar_to_z/execution.json","process_id":"d_dbar_to_z","role":"evaluator-manifest","sha256":"5d6eff063088c6194f2f2ff163ed6859f6a43b6489a3d7aa466dc2861ba81f18","size_bytes":266668},{"executable":false,"media_type":"application/json","path":"processes/d_dbar_to_z/physics.json","process_id":"d_dbar_to_z","role":"runtime-physics","sha256":"de34d694c7b149e94676f2e9e362ad4b46e20d320133e1197eba82bdb2d3180e","size_bytes":5819},{"executable":false,"media_type":"application/json","path":"processes/d_dbar_to_z/validation-momenta.json","process_id":"d_dbar_to_z","role":"validation-momenta","sha256":"9a552a52ce11ab5d1fbe56c7a87f2fe7face06eb51ca562777efff58b87a9f0a","size_bytes":685},{"executable":false,"media_type":"application/json","path":"processes/evaluators.json","role":"evaluator-manifest","sha256":"c41035da94339a62092ea0ede7349ca3145edade1087f1a8100e43d72affb052","size_bytes":839}],"processes":[{"aliases":[],"color_accuracy":"lc","expression":"d d~ > z","external_pdgs":[1,-1,23],"id":"d_dbar_to_z","physics_path":"processes/d_dbar_to_z/physics.json","required_runtime_capabilities":["compiled-plane-arena-v1","rusticol.compiled.color-topology-lanes.v1","rusticol.compiled.helicity-dual-lane.v1","rusticol.compiled.helicity-selector-union.v1","rusticol.compiled.runtime-selectors.v1","symjit.application.complex-f64.v1"]}],"producer":{"distribution":"pyamplicol","native_build_inputs_sha256":"4ab41fd55da0d2e7cccd1e964b3b087a5bb277fda1c668d1b9848c31cfdcda54","target":{"cpu_features":[],"triple":"portable-64le"},"version":"1.0.0","versions":{"c_abi":1,"compiled_model":9,"process_artifact":3,"python_api":1,"runtime_physics":1,"symbolica_serialization":"symbolica-bincode2-v1","toml":1}},"runtime":{"api_bundle_path":"API","engine":"rusticol","engine_version":"1.0.0","evaluator_manifest_path":"processes/evaluators.json","required_runtime_capabilities":["compiled-plane-arena-v1","rusticol.compiled.color-topology-lanes.v1","rusticol.compiled.helicity-dual-lane.v1","rusticol.compiled.helicity-selector-union.v1","rusticol.compiled.runtime-selectors.v1","symjit.application.complex-f64.v1"]},"schema_version":3}
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/config/effective.toml b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/config/effective.toml
new file mode 100644
index 0000000000..7e17a4edbe
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/config/effective.toml
@@ -0,0 +1,104 @@
+action = "generate"
+schema_version = 1
+
+[model]
+source = "built-in-sm"
+simplify = true
+cache = true
+
+[process]
+entries = [{ expression = "d d~ > z" }]
+flavor_scheme = 5
+coupling_order_policy = "minimal"
+reference_color_order = []
+selected_color_sector_ids = []
+
+[process.multiparticles]
+
+[process.max_coupling_orders]
+
+[process.selected_source_helicities]
+
+[color]
+accuracy = "lc"
+contraction = "direct"
+lc_flow_layout = "topology-replay"
+fft_basis = "trace"
+
+[generation]
+output = "."
+mode = "error"
+workers = 1
+emit_api_bundle = true
+
+[generation.validation]
+enabled = true
+samples = 1
+seed = 12345
+relative_tolerance = 1e-12
+absolute_tolerance = 1e-300
+post_build_validation = false
+
+[generation.relation_discovery]
+mode = "certified-reuse"
+precision_digits = 96
+probe_count = 4
+verification_probe_count = 4
+relative_tolerance = 1e-70
+absolute_tolerance = 1e-80
+seed = 1348026701
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
+batch_size = 128
+output_chunk_size = 512
+
+[evaluator.optimization]
+horner_iterations = 10
+cores = 12
+max_horner_variables = 1000
+max_common_pair_cache_entries = 5000000
+max_common_pair_distance = 1000
+collect_factors = "auto"
+
+[evaluator.jit]
+optimization_level = 2
+compress = true
+
+[evaluator.cpp]
+optimization = "O3"
+native_arch = false
+extra_flags = []
+
+[evaluator.eager]
+point_tile_size = 1024
+workspace_mib = 256
+
+[evaluator.recurrence]
+point_tile_size = 1024
+workspace_mib = 256
+
+[evaluation]
+precision = 16
+resolved = false
+helicity_ids = []
+color_flow_ids = []
+
+[benchmark]
+target_runtime = 10.0
+batch_size = 128
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+helicity_ids = []
+color_flow_ids = []
+
+[output]
+format = "json"
+color = "auto"
+progress = "off"
+log_level = "info"
+
+[symbolica]
+suggest_license = false
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/config/requested.toml b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/config/requested.toml
new file mode 100644
index 0000000000..d5f7e35274
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/config/requested.toml
@@ -0,0 +1,104 @@
+action = "generate"
+schema_version = 1
+
+[model]
+source = "built-in-sm"
+simplify = true
+cache = true
+
+[process]
+entries = [{ expression = "d d~ > z" }]
+flavor_scheme = 5
+coupling_order_policy = "minimal"
+reference_color_order = []
+selected_color_sector_ids = []
+
+[process.multiparticles]
+
+[process.max_coupling_orders]
+
+[process.selected_source_helicities]
+
+[color]
+accuracy = "lc"
+contraction = "direct"
+lc_flow_layout = "topology-replay"
+fft_basis = "adjoint"
+
+[generation]
+output = "."
+mode = "error"
+workers = 1
+emit_api_bundle = true
+
+[generation.validation]
+enabled = true
+samples = 1
+seed = 12345
+relative_tolerance = 1e-12
+absolute_tolerance = 1e-300
+post_build_validation = false
+
+[generation.relation_discovery]
+mode = "certified-reuse"
+precision_digits = 96
+probe_count = 4
+verification_probe_count = 4
+relative_tolerance = 1e-70
+absolute_tolerance = 1e-80
+seed = 1348026701
+
+[evaluator]
+backend = "jit"
+execution_mode = "compiled"
+batch_size = 128
+output_chunk_size = 512
+
+[evaluator.optimization]
+horner_iterations = 10
+cores = "auto"
+max_horner_variables = 1000
+max_common_pair_cache_entries = 5000000
+max_common_pair_distance = 1000
+collect_factors = "auto"
+
+[evaluator.jit]
+optimization_level = 2
+compress = "auto"
+
+[evaluator.cpp]
+optimization = "O3"
+native_arch = false
+extra_flags = []
+
+[evaluator.eager]
+point_tile_size = 1024
+workspace_mib = 256
+
+[evaluator.recurrence]
+point_tile_size = 1024
+workspace_mib = 256
+
+[evaluation]
+precision = 16
+resolved = false
+helicity_ids = []
+color_flow_ids = []
+
+[benchmark]
+target_runtime = 10.0
+batch_size = 128
+precision = 16
+warmup_runs = 2
+minimum_samples = 5
+helicity_ids = []
+color_flow_ids = []
+
+[output]
+format = "json"
+color = "auto"
+progress = "off"
+log_level = "info"
+
+[symbolica]
+suggest_license = false
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/evaluators.pacbin b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/evaluators.pacbin
new file mode 100644
index 0000000000..5405414e6f
Binary files /dev/null and b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/evaluators.pacbin differ
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/model/compiled-model.json b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/model/compiled-model.json
new file mode 100644
index 0000000000..0668f393c7
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/model/compiled-model.json
@@ -0,0 +1 @@
+{"capabilities":{"color_accuracy_modes":["lc","nlc","full"],"color_representations":[-3,1,3,8],"compiled_contact_term_count":0,"compiled_propagator_count":0,"compiled_vertex_term_count":211,"declared_functions":[],"exchange_symmetric_kernel_evaluation_relation_count":0,"expression_functions":[],"form_factor_count":0,"has_custom_propagators":false,"max_vertex_valence":3,"parameter_count":10,"particle_count":38,"reusable_kernel_evaluation_class_count":0,"signed_kernel_evaluation_relation_count":0,"spins":[-1,1,2,3],"supported":true,"swapped_kernel_evaluation_relation_count":0,"unlowered_contact_term_count":0,"verified_kernel_evaluation_class_count":0,"vertex_count":211},"conversion_seconds":0.010124958120286465,"ir":{"closure_contractions":[{"chirality":0,"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"particle":"h"},{"chirality":0,"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"particle":"pdg_125"},{"chirality":0,"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"particle":"pdg_126"},{"chirality":0,"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"particle":"pdg_127"}],"couplings":[],"current_orderings":[],"direct_contractions":[{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"auxiliary:antisymmetric-tensor","metric_signature":null,"name":"antisymmetric-tensor","right_basis":"auxiliary:antisymmetric-tensor"},"left_chirality":0,"left_particle":"pdg_-26","right_chirality":0,"right_particle":"pdg_26"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"lorentz-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"lorentz-vector"},"left_chirality":0,"left_particle":"w-","right_chirality":0,"right_particle":"w+"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"auxiliary:antisymmetric-tensor","metric_signature":null,"name":"antisymmetric-tensor","right_basis":"auxiliary:antisymmetric-tensor"},"left_chirality":0,"left_particle":"pdg_-23","right_chirality":0,"right_particle":"pdg_-23"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"auxiliary:antisymmetric-tensor","metric_signature":null,"name":"antisymmetric-tensor","right_basis":"auxiliary:antisymmetric-tensor"},"left_chirality":0,"left_particle":"pdg_-21","right_chirality":0,"right_particle":"pdg_-21"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"vt~","right_chirality":1,"right_particle":"vt"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"vt~","right_chirality":0,"right_particle":"vt"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"vt~","right_chirality":-1,"right_particle":"vt"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"ta+","right_chirality":1,"right_particle":"ta-"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"ta+","right_chirality":0,"right_particle":"ta-"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"ta+","right_chirality":-1,"right_particle":"ta-"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"vm~","right_chirality":1,"right_particle":"vm"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"vm~","right_chirality":0,"right_particle":"vm"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"vm~","right_chirality":-1,"right_particle":"vm"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"mu+","right_chirality":1,"right_particle":"mu-"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"mu+","right_chirality":0,"right_particle":"mu-"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"mu+","right_chirality":-1,"right_particle":"mu-"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"ve~","right_chirality":1,"right_particle":"ve"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"ve~","right_chirality":0,"right_particle":"ve"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"ve~","right_chirality":-1,"right_particle":"ve"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"e+","right_chirality":1,"right_particle":"e-"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"e+","right_chirality":0,"right_particle":"e-"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"e+","right_chirality":-1,"right_particle":"e-"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"t~","right_chirality":0,"right_particle":"t"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"b~","right_chirality":1,"right_particle":"b"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"b~","right_chirality":0,"right_particle":"b"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"b~","right_chirality":-1,"right_particle":"b"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"c~","right_chirality":1,"right_particle":"c"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"c~","right_chirality":0,"right_particle":"c"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"c~","right_chirality":-1,"right_particle":"c"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"s~","right_chirality":1,"right_particle":"s"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"s~","right_chirality":0,"right_particle":"s"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"s~","right_chirality":-1,"right_particle":"s"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"u~","right_chirality":1,"right_particle":"u"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"u~","right_chirality":0,"right_particle":"u"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"u~","right_chirality":-1,"right_particle":"u"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"d~","right_chirality":1,"right_particle":"d"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"d~","right_chirality":0,"right_particle":"d"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"d~","right_chirality":-1,"right_particle":"d"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"d","right_chirality":1,"right_particle":"d~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"d","right_chirality":0,"right_particle":"d~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"d","right_chirality":-1,"right_particle":"d~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"u","right_chirality":1,"right_particle":"u~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"u","right_chirality":0,"right_particle":"u~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"u","right_chirality":-1,"right_particle":"u~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"s","right_chirality":1,"right_particle":"s~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"s","right_chirality":0,"right_particle":"s~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"s","right_chirality":-1,"right_particle":"s~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"c","right_chirality":1,"right_particle":"c~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"c","right_chirality":0,"right_particle":"c~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"c","right_chirality":-1,"right_particle":"c~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"b","right_chirality":1,"right_particle":"b~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"b","right_chirality":0,"right_particle":"b~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"b","right_chirality":-1,"right_particle":"b~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"t","right_chirality":0,"right_particle":"t~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"e-","right_chirality":1,"right_particle":"e+"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"e-","right_chirality":0,"right_particle":"e+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"e-","right_chirality":-1,"right_particle":"e+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"ve","right_chirality":1,"right_particle":"ve~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"ve","right_chirality":0,"right_particle":"ve~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"ve","right_chirality":-1,"right_particle":"ve~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"mu-","right_chirality":1,"right_particle":"mu+"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"mu-","right_chirality":0,"right_particle":"mu+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"mu-","right_chirality":-1,"right_particle":"mu+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"vm","right_chirality":1,"right_particle":"vm~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"vm","right_chirality":0,"right_particle":"vm~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"vm","right_chirality":-1,"right_particle":"vm~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"ta-","right_chirality":1,"right_particle":"ta+"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"ta-","right_chirality":0,"right_particle":"ta+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"ta-","right_chirality":-1,"right_particle":"ta+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"vt","right_chirality":1,"right_particle":"vt~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"vt","right_chirality":0,"right_particle":"vt~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"vt","right_chirality":-1,"right_particle":"vt~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"lorentz-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"lorentz-vector"},"left_chirality":0,"left_particle":"g","right_chirality":0,"right_particle":"g"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"lorentz-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"lorentz-vector"},"left_chirality":0,"left_particle":"a","right_chirality":0,"right_particle":"a"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"lorentz-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"lorentz-vector"},"left_chirality":0,"left_particle":"z","right_chirality":0,"right_particle":"z"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"lorentz-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"lorentz-vector"},"left_chirality":0,"left_particle":"w+","right_chirality":0,"right_particle":"w-"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"left_chirality":0,"left_particle":"h","right_chirality":0,"right_particle":"h"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"auxiliary:antisymmetric-tensor","metric_signature":null,"name":"antisymmetric-tensor","right_basis":"auxiliary:antisymmetric-tensor"},"left_chirality":0,"left_particle":"pdg_26","right_chirality":0,"right_particle":"pdg_-26"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"auxiliary:u1-subtraction-color-flow-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"auxiliary:u1-subtraction-color-flow-vector"},"left_chirality":0,"left_particle":"pdg_99","right_chirality":0,"right_particle":"pdg_99"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"left_chirality":0,"left_particle":"pdg_125","right_chirality":0,"right_particle":"pdg_125"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"left_chirality":0,"left_particle":"pdg_126","right_chirality":0,"right_particle":"pdg_126"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"left_chirality":0,"left_particle":"pdg_127","right_chirality":0,"right_particle":"pdg_127"}],"goldstone_partners":[],"max_vertex_valence":3,"name":"built-in-sm","orders":[{"expansion_order":99,"hierarchy":1,"name":"QCD"},{"expansion_order":99,"hierarchy":2,"name":"QED"}],"oriented_kernels":[],"parameters":[{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[1],"name":"alpha_ew","nature":"external","parameter_type":"real","resolved_expression":"7.5467711139788835e-3","value":[0.0075467711139788835,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[2],"name":"alpha_s","nature":"external","parameter_type":"real","resolved_expression":"1.18000000000000e-1","value":[0.118,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[3],"name":"mass_23","nature":"external","parameter_type":"real","resolved_expression":"91.1880000000000","value":[91.188,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[4],"name":"mass_24","nature":"external","parameter_type":"real","resolved_expression":"80.41900244575616","value":[80.41900244575616,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[5],"name":"mass_25","nature":"external","parameter_type":"real","resolved_expression":"125.000000000000","value":[125.0,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[6],"name":"mass_6","nature":"external","parameter_type":"real","resolved_expression":"173.000000000000","value":[173.0,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[7],"name":"width_23","nature":"external","parameter_type":"real","resolved_expression":"2.44140400000000","value":[2.441404,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[8],"name":"width_24","nature":"external","parameter_type":"real","resolved_expression":"2.04760000000000","value":[2.0476,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[9],"name":"width_25","nature":"external","parameter_type":"real","resolved_expression":"6.38233900000000e-3","value":[0.006382339,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[10],"name":"width_6","nature":"external","parameter_type":"real","resolved_expression":"1.49150000000000","value":[1.4915,0.0]}],"particles":[{"antiname":"pdg_-23","auxiliary_kind":"antisymmetric-tensor","charge":0.0,"color":1,"color_role":"singlet","component_dimension":6,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"pdg_-23","pdg_code":-23,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":true,"source_orientation":"self-conjugate","spin":-1,"statistics":"auxiliary","wavefunction_family":"auxiliary","width":"ZERO"},{"antiname":"pdg_-21","auxiliary_kind":"antisymmetric-tensor","charge":0.0,"color":8,"color_role":"adjoint","component_dimension":6,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"pdg_-21","pdg_code":-21,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":true,"source_orientation":"self-conjugate","spin":-1,"statistics":"auxiliary","wavefunction_family":"auxiliary","width":"ZERO"},{"antiname":"d~","auxiliary_kind":null,"charge":-0.3333333333333333,"color":3,"color_role":"fundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"d","pdg_code":1,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1/3"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"d","auxiliary_kind":null,"charge":0.3333333333333333,"color":-3,"color_role":"antifundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"d~","pdg_code":-1,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1/3"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"u~","auxiliary_kind":null,"charge":0.6666666666666666,"color":3,"color_role":"fundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"u","pdg_code":2,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","2/3"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"u","auxiliary_kind":null,"charge":-0.6666666666666666,"color":-3,"color_role":"antifundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"u~","pdg_code":-2,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-2/3"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"s~","auxiliary_kind":null,"charge":-0.3333333333333333,"color":3,"color_role":"fundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"s","pdg_code":3,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1/3"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"s","auxiliary_kind":null,"charge":0.3333333333333333,"color":-3,"color_role":"antifundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"s~","pdg_code":-3,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1/3"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"c~","auxiliary_kind":null,"charge":0.6666666666666666,"color":3,"color_role":"fundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"c","pdg_code":4,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","2/3"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"c","auxiliary_kind":null,"charge":-0.6666666666666666,"color":-3,"color_role":"antifundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"c~","pdg_code":-4,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-2/3"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"b~","auxiliary_kind":null,"charge":-0.3333333333333333,"color":3,"color_role":"fundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"b","pdg_code":5,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1/3"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"b","auxiliary_kind":null,"charge":0.3333333333333333,"color":-3,"color_role":"antifundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"b~","pdg_code":-5,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1/3"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"t~","auxiliary_kind":null,"charge":0.6666666666666666,"color":3,"color_role":"fundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"mass_6","name":"t","pdg_code":6,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","2/3"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"width_6"},{"antiname":"t","auxiliary_kind":null,"charge":-0.6666666666666666,"color":-3,"color_role":"antifundamental","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"mass_6","name":"t~","pdg_code":-6,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-2/3"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"width_6"},{"antiname":"e+","auxiliary_kind":null,"charge":-1.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"e-","pdg_code":11,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"e-","auxiliary_kind":null,"charge":1.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"e+","pdg_code":-11,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"ve~","auxiliary_kind":null,"charge":0.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"ve","pdg_code":12,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"ve","auxiliary_kind":null,"charge":-0.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"ve~","pdg_code":-12,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"mu+","auxiliary_kind":null,"charge":-1.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"mu-","pdg_code":13,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"mu-","auxiliary_kind":null,"charge":1.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"mu+","pdg_code":-13,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"vm~","auxiliary_kind":null,"charge":0.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"vm","pdg_code":14,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"vm","auxiliary_kind":null,"charge":-0.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"vm~","pdg_code":-14,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"ta+","auxiliary_kind":null,"charge":-1.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"ta-","pdg_code":15,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"ta-","auxiliary_kind":null,"charge":1.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"ta+","pdg_code":-15,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"vt~","auxiliary_kind":null,"charge":0.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"vt","pdg_code":16,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":false,"source_orientation":"particle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"vt","auxiliary_kind":null,"charge":-0.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"vt~","pdg_code":-16,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":2,"statistics":"fermion","wavefunction_family":"fermion","width":"ZERO"},{"antiname":"g","auxiliary_kind":null,"charge":0.0,"color":8,"color_role":"adjoint","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"g","pdg_code":21,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":true,"source_orientation":"self-conjugate","spin":3,"statistics":"boson","wavefunction_family":"vector","width":"ZERO"},{"antiname":"a","auxiliary_kind":null,"charge":0.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"a","pdg_code":22,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":true,"source_orientation":"self-conjugate","spin":3,"statistics":"boson","wavefunction_family":"vector","width":"ZERO"},{"antiname":"z","auxiliary_kind":null,"charge":0.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"mass_23","name":"z","pdg_code":23,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":true,"source_orientation":"self-conjugate","spin":3,"statistics":"boson","wavefunction_family":"vector","width":"width_23"},{"antiname":"w-","auxiliary_kind":null,"charge":1.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"mass_24","name":"w+","pdg_code":24,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1"]],"self_conjugate":false,"source_orientation":"particle","spin":3,"statistics":"boson","wavefunction_family":"vector","width":"width_24"},{"antiname":"w+","auxiliary_kind":null,"charge":-1.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"mass_24","name":"w-","pdg_code":-24,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":3,"statistics":"boson","wavefunction_family":"vector","width":"width_24"},{"antiname":"h","auxiliary_kind":null,"charge":0.0,"color":1,"color_role":"singlet","component_dimension":1,"ghost_number":0,"goldstoneboson":false,"mass":"mass_25","name":"h","pdg_code":25,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":true,"source_orientation":"self-conjugate","spin":1,"statistics":"boson","wavefunction_family":"scalar","width":"width_25"},{"antiname":"pdg_-26","auxiliary_kind":"antisymmetric-tensor","charge":1.0,"color":1,"color_role":"singlet","component_dimension":6,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"pdg_26","pdg_code":26,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","1"]],"self_conjugate":false,"source_orientation":"particle","spin":-1,"statistics":"auxiliary","wavefunction_family":"auxiliary","width":"ZERO"},{"antiname":"pdg_26","auxiliary_kind":"antisymmetric-tensor","charge":-1.0,"color":1,"color_role":"singlet","component_dimension":6,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"pdg_-26","pdg_code":-26,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","-1"]],"self_conjugate":false,"source_orientation":"antiparticle","spin":-1,"statistics":"auxiliary","wavefunction_family":"auxiliary","width":"ZERO"},{"antiname":"pdg_99","auxiliary_kind":"u1-subtraction-color-flow-vector","charge":0.0,"color":1,"color_role":"singlet","component_dimension":4,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"pdg_99","pdg_code":99,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":true,"source_orientation":"self-conjugate","spin":-1,"statistics":"auxiliary","wavefunction_family":"auxiliary","width":"ZERO"},{"antiname":"pdg_125","auxiliary_kind":null,"charge":0.0,"color":1,"color_role":"singlet","component_dimension":1,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"pdg_125","pdg_code":125,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":true,"source_orientation":"self-conjugate","spin":-1,"statistics":"auxiliary","wavefunction_family":"auxiliary","width":"ZERO"},{"antiname":"pdg_126","auxiliary_kind":null,"charge":0.0,"color":1,"color_role":"singlet","component_dimension":1,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"pdg_126","pdg_code":126,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":true,"source_orientation":"self-conjugate","spin":-1,"statistics":"auxiliary","wavefunction_family":"auxiliary","width":"ZERO"},{"antiname":"pdg_127","auxiliary_kind":null,"charge":0.0,"color":1,"color_role":"singlet","component_dimension":1,"ghost_number":0,"goldstoneboson":false,"mass":"ZERO","name":"pdg_127","pdg_code":127,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"self_conjugate":true,"source_orientation":"self-conjugate","spin":-1,"statistics":"auxiliary","wavefunction_family":"auxiliary","width":"ZERO"}],"propagators":[],"symbol_namespace":"model_built_in_sm_1cbc83b85d7e","tensor_orderings":[],"vertex_terms":[{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_0","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":0,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"0","lorentz_source":"built-in","particles":["g","g","g"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_0"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_1","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":1,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"1","lorentz_source":"built-in","particles":["g","g","pdg_-21"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_1"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_2","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":2,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"2","lorentz_source":"built-in","particles":["pdg_-21","g","g"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_2"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_3","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":3,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"3","lorentz_source":"built-in","particles":["g","pdg_-21","g"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_3"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_4","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":4,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["g","d","d"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_4"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_5","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":5,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["g","d~","d~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_5"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_6","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":6,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["d","g","d"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_6"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_7","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":7,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["d~","g","d~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_7"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_8","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":8,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"9","lorentz_source":"built-in","particles":["d~","d","g"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_8"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_9","coupling_expression":"[0.3333333333333333, 0.0]","coupling_orders":[],"id":9,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"8","lorentz_source":"built-in","particles":["d","d~","pdg_99"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_9"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_10","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":10,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["pdg_99","d","d"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_10"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_11","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":11,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["pdg_99","d~","d~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_11"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_12","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":12,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["d","pdg_99","d"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_12"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_13","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":13,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["d~","pdg_99","d~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_13"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_14","coupling_expression":"[-0.3333333333333333, -0.3333333333333333]","coupling_orders":[],"id":14,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["d","a","d"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_14"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_15","coupling_expression":"[-0.3333333333333333, -0.3333333333333333]","coupling_orders":[],"id":15,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["d~","a","d~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_15"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_16","coupling_expression":"[-1.0244420275940371, 0.17818666745287456]","coupling_orders":[],"id":16,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["d","z","d"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_16"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_17","coupling_expression":"[-1.0244420275940371, 0.17818666745287456]","coupling_orders":[],"id":17,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["d~","z","d~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_17"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_18","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":18,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["d","w+","u"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_18"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_19","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":19,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["d~","w-","u~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_19"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_20","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":20,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["g","u","u"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_20"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_21","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":21,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["g","u~","u~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_21"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_22","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":22,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["u","g","u"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_22"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_23","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":23,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["u~","g","u~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_23"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_24","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":24,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"9","lorentz_source":"built-in","particles":["u~","u","g"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_24"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_25","coupling_expression":"[0.3333333333333333, 0.0]","coupling_orders":[],"id":25,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"8","lorentz_source":"built-in","particles":["u","u~","pdg_99"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_25"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_26","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":26,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["pdg_99","u","u"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_26"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_27","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":27,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["pdg_99","u~","u~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_27"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_28","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":28,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["u","pdg_99","u"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_28"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_29","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":29,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["u~","pdg_99","u~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_29"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_30","coupling_expression":"[0.6666666666666666, 0.6666666666666666]","coupling_orders":[],"id":30,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["u","a","u"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_30"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_31","coupling_expression":"[0.6666666666666666, 0.6666666666666666]","coupling_orders":[],"id":31,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["u~","a","u~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_31"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_32","coupling_expression":"[0.8462553601411626, -0.35637333490574913]","coupling_orders":[],"id":32,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["u","z","u"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_32"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_33","coupling_expression":"[0.8462553601411626, -0.35637333490574913]","coupling_orders":[],"id":33,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["u~","z","u~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_33"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_34","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":34,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["u","w-","d"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_34"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_35","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":35,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["u~","w+","d~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_35"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_36","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":36,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["g","s","s"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_36"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_37","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":37,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["g","s~","s~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_37"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_38","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":38,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["s","g","s"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_38"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_39","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":39,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["s~","g","s~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_39"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_40","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":40,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"9","lorentz_source":"built-in","particles":["s~","s","g"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_40"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_41","coupling_expression":"[0.3333333333333333, 0.0]","coupling_orders":[],"id":41,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"8","lorentz_source":"built-in","particles":["s","s~","pdg_99"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_41"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_42","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":42,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["pdg_99","s","s"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_42"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_43","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":43,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["pdg_99","s~","s~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_43"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_44","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":44,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["s","pdg_99","s"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_44"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_45","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":45,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["s~","pdg_99","s~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_45"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_46","coupling_expression":"[-0.3333333333333333, -0.3333333333333333]","coupling_orders":[],"id":46,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["s","a","s"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_46"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_47","coupling_expression":"[-0.3333333333333333, -0.3333333333333333]","coupling_orders":[],"id":47,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["s~","a","s~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_47"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_48","coupling_expression":"[-1.0244420275940371, 0.17818666745287456]","coupling_orders":[],"id":48,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["s","z","s"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_48"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_49","coupling_expression":"[-1.0244420275940371, 0.17818666745287456]","coupling_orders":[],"id":49,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["s~","z","s~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_49"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_50","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":50,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["s","w+","c"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_50"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_51","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":51,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["s~","w-","c~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_51"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_52","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":52,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["g","c","c"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_52"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_53","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":53,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["g","c~","c~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_53"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_54","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":54,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["c","g","c"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_54"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_55","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":55,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["c~","g","c~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_55"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_56","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":56,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"9","lorentz_source":"built-in","particles":["c~","c","g"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_56"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_57","coupling_expression":"[0.3333333333333333, 0.0]","coupling_orders":[],"id":57,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"8","lorentz_source":"built-in","particles":["c","c~","pdg_99"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_57"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_58","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":58,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["pdg_99","c","c"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_58"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_59","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":59,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["pdg_99","c~","c~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_59"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_60","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":60,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["c","pdg_99","c"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_60"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_61","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":61,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["c~","pdg_99","c~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_61"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_62","coupling_expression":"[0.6666666666666666, 0.6666666666666666]","coupling_orders":[],"id":62,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["c","a","c"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_62"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_63","coupling_expression":"[0.6666666666666666, 0.6666666666666666]","coupling_orders":[],"id":63,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["c~","a","c~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_63"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_64","coupling_expression":"[0.8462553601411626, -0.35637333490574913]","coupling_orders":[],"id":64,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["c","z","c"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_64"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_65","coupling_expression":"[0.8462553601411626, -0.35637333490574913]","coupling_orders":[],"id":65,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["c~","z","c~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_65"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_66","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":66,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["c","w-","s"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_66"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_67","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":67,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["c~","w+","s~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_67"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_68","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":68,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["g","b","b"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_68"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_69","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":69,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["g","b~","b~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_69"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_70","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":70,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["b","g","b"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_70"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_71","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":71,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["b~","g","b~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_71"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_72","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":72,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"9","lorentz_source":"built-in","particles":["b~","b","g"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_72"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_73","coupling_expression":"[0.3333333333333333, 0.0]","coupling_orders":[],"id":73,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"8","lorentz_source":"built-in","particles":["b","b~","pdg_99"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_73"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_74","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":74,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["pdg_99","b","b"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_74"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_75","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":75,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["pdg_99","b~","b~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_75"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_76","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":76,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["b","pdg_99","b"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_76"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_77","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":77,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["b~","pdg_99","b~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_77"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_78","coupling_expression":"[-0.3333333333333333, -0.3333333333333333]","coupling_orders":[],"id":78,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["b","a","b"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_78"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_79","coupling_expression":"[-0.3333333333333333, -0.3333333333333333]","coupling_orders":[],"id":79,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["b~","a","b~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_79"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_80","coupling_expression":"[-1.0244420275940371, 0.17818666745287456]","coupling_orders":[],"id":80,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["b","z","b"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_80"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_81","coupling_expression":"[-1.0244420275940371, 0.17818666745287456]","coupling_orders":[],"id":81,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["b~","z","b~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_81"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_82","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":82,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["b","w+","t"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_82"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_83","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":83,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["b~","w-","t~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_83"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_84","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":84,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["g","t","t"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_84"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_85","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":85,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["g","t~","t~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_85"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_86","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":86,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["t","g","t"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_86"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_87","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":87,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["t~","g","t~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_87"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_88","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":88,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"9","lorentz_source":"built-in","particles":["t~","t","g"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_88"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_89","coupling_expression":"[0.3333333333333333, 0.0]","coupling_orders":[],"id":89,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"8","lorentz_source":"built-in","particles":["t","t~","pdg_99"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_89"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_90","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":90,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"4","lorentz_source":"built-in","particles":["pdg_99","t","t"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_90"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_91","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":91,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"5","lorentz_source":"built-in","particles":["pdg_99","t~","t~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_91"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_92","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":92,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"6","lorentz_source":"built-in","particles":["t","pdg_99","t"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_92"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_93","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":93,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"7","lorentz_source":"built-in","particles":["t~","pdg_99","t~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_93"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_94","coupling_expression":"[0.6666666666666666, 0.6666666666666666]","coupling_orders":[],"id":94,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["t","a","t"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_94"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_95","coupling_expression":"[0.6666666666666666, 0.6666666666666666]","coupling_orders":[],"id":95,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["t~","a","t~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_95"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_96","coupling_expression":"[0.8462553601411626, -0.35637333490574913]","coupling_orders":[],"id":96,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["t","z","t"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_96"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_97","coupling_expression":"[0.8462553601411626, -0.35637333490574913]","coupling_orders":[],"id":97,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["t~","z","t~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_97"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_98","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":98,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["t","w-","b"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_98"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_99","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":99,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["t~","w+","b~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_99"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_100","coupling_expression":"[-1.8706973877352002, 0.0]","coupling_orders":[],"id":100,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["w+","w-","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_100"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_101","coupling_expression":"[1.8706973877352002, 0.0]","coupling_orders":[],"id":101,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["w-","w+","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_101"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_102","coupling_expression":"[-1.0, 0.0]","coupling_orders":[],"id":102,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["w+","w-","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_102"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_103","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":103,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["w-","w+","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_103"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_104","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":104,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["w+","a","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_104"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_105","coupling_expression":"[-1.0, 0.0]","coupling_orders":[],"id":105,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["w-","a","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_105"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_106","coupling_expression":"[-1.0, 0.0]","coupling_orders":[],"id":106,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["a","w+","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_106"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_107","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":107,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["a","w-","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_107"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_108","coupling_expression":"[1.8706973877352002, 0.0]","coupling_orders":[],"id":108,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["w+","z","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_108"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_109","coupling_expression":"[-1.8706973877352002, 0.0]","coupling_orders":[],"id":109,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["w-","z","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_109"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_110","coupling_expression":"[-1.8706973877352002, 0.0]","coupling_orders":[],"id":110,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["z","w+","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_110"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_111","coupling_expression":"[1.8706973877352002, 0.0]","coupling_orders":[],"id":111,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"12","lorentz_source":"built-in","particles":["z","w-","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_111"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_112","coupling_expression":"[2.1212045437626474, 0.0]","coupling_orders":[],"id":112,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"13","lorentz_source":"built-in","particles":["w+","w-","pdg_-23"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_112"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_113","coupling_expression":"[-2.1212045437626474, 0.0]","coupling_orders":[],"id":113,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"13","lorentz_source":"built-in","particles":["w-","w+","pdg_-23"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_113"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_114","coupling_expression":"[2.1212045437626474, 0.0]","coupling_orders":[],"id":114,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"14","lorentz_source":"built-in","particles":["pdg_-23","w+","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_114"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_115","coupling_expression":"[-2.1212045437626474, 0.0]","coupling_orders":[],"id":115,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"14","lorentz_source":"built-in","particles":["pdg_-23","w-","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_115"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_116","coupling_expression":"[-2.1212045437626474, 0.0]","coupling_orders":[],"id":116,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"15","lorentz_source":"built-in","particles":["w+","pdg_-23","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_116"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_117","coupling_expression":"[2.1212045437626474, 0.0]","coupling_orders":[],"id":117,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"15","lorentz_source":"built-in","particles":["w-","pdg_-23","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_117"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_118","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":118,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"13","lorentz_source":"built-in","particles":["w+","a","pdg_26"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_118"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_119","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":119,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"13","lorentz_source":"built-in","particles":["w-","a","pdg_-26"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_119"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_120","coupling_expression":"[-1.0, 0.0]","coupling_orders":[],"id":120,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"13","lorentz_source":"built-in","particles":["a","w+","pdg_26"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_120"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_121","coupling_expression":"[-1.0, 0.0]","coupling_orders":[],"id":121,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"13","lorentz_source":"built-in","particles":["a","w-","pdg_-26"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_121"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_122","coupling_expression":"[1.8706973877352002, 0.0]","coupling_orders":[],"id":122,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"13","lorentz_source":"built-in","particles":["w+","z","pdg_26"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_122"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_123","coupling_expression":"[1.8706973877352002, 0.0]","coupling_orders":[],"id":123,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"13","lorentz_source":"built-in","particles":["w-","z","pdg_-26"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_123"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_124","coupling_expression":"[-1.8706973877352002, 0.0]","coupling_orders":[],"id":124,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"13","lorentz_source":"built-in","particles":["z","w+","pdg_26"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_124"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_125","coupling_expression":"[-1.8706973877352002, 0.0]","coupling_orders":[],"id":125,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"13","lorentz_source":"built-in","particles":["z","w-","pdg_-26"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_125"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_126","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":126,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"14","lorentz_source":"built-in","particles":["pdg_26","a","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_126"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_127","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":127,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"14","lorentz_source":"built-in","particles":["pdg_-26","a","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_127"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_128","coupling_expression":"[-1.0, 0.0]","coupling_orders":[],"id":128,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"14","lorentz_source":"built-in","particles":["pdg_26","w-","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_128"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_129","coupling_expression":"[-1.0, 0.0]","coupling_orders":[],"id":129,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"14","lorentz_source":"built-in","particles":["pdg_-26","w+","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_129"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_130","coupling_expression":"[1.8706973877352002, 0.0]","coupling_orders":[],"id":130,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"14","lorentz_source":"built-in","particles":["pdg_26","z","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_130"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_131","coupling_expression":"[1.8706973877352002, 0.0]","coupling_orders":[],"id":131,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"14","lorentz_source":"built-in","particles":["pdg_-26","z","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_131"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_132","coupling_expression":"[-1.8706973877352002, 0.0]","coupling_orders":[],"id":132,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"14","lorentz_source":"built-in","particles":["pdg_26","w-","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_132"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_133","coupling_expression":"[-1.8706973877352002, 0.0]","coupling_orders":[],"id":133,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"14","lorentz_source":"built-in","particles":["pdg_-26","w+","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_133"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_134","coupling_expression":"[-1.0, 0.0]","coupling_orders":[],"id":134,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"15","lorentz_source":"built-in","particles":["a","pdg_26","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_134"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_135","coupling_expression":"[-1.0, 0.0]","coupling_orders":[],"id":135,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"15","lorentz_source":"built-in","particles":["a","pdg_-26","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_135"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_136","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":136,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"15","lorentz_source":"built-in","particles":["w+","pdg_-26","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_136"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_137","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":137,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"15","lorentz_source":"built-in","particles":["w-","pdg_26","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_137"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_138","coupling_expression":"[-1.8706973877352002, 0.0]","coupling_orders":[],"id":138,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"15","lorentz_source":"built-in","particles":["z","pdg_26","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_138"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_139","coupling_expression":"[-1.8706973877352002, 0.0]","coupling_orders":[],"id":139,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"15","lorentz_source":"built-in","particles":["z","pdg_-26","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_139"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_140","coupling_expression":"[1.8706973877352002, 0.0]","coupling_orders":[],"id":140,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"15","lorentz_source":"built-in","particles":["w+","pdg_-26","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_140"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_141","coupling_expression":"[1.8706973877352002, 0.0]","coupling_orders":[],"id":141,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"15","lorentz_source":"built-in","particles":["w-","pdg_26","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_141"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_142","coupling_expression":"[2.281602450356579, 0.0]","coupling_orders":[],"id":142,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"16","lorentz_source":"built-in","particles":["t","h","t"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_142"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_143","coupling_expression":"[2.281602450356579, 0.0]","coupling_orders":[],"id":143,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"16","lorentz_source":"built-in","particles":["t~","h","t~"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_143"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_144","coupling_expression":"[170.58515339279742, 0.0]","coupling_orders":[],"id":144,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"17","lorentz_source":"built-in","particles":["w+","w-","h"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_144"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_145","coupling_expression":"[170.58515339279742, 0.0]","coupling_orders":[],"id":145,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"17","lorentz_source":"built-in","particles":["w-","w+","h"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_145"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_146","coupling_expression":"[170.58515339279742, 0.0]","coupling_orders":[],"id":146,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"18","lorentz_source":"built-in","particles":["h","w+","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_146"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_147","coupling_expression":"[170.58515339279742, 0.0]","coupling_orders":[],"id":147,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"18","lorentz_source":"built-in","particles":["h","w-","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_147"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_148","coupling_expression":"[170.58515339279742, 0.0]","coupling_orders":[],"id":148,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"19","lorentz_source":"built-in","particles":["w+","h","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_148"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_149","coupling_expression":"[170.58515339279742, 0.0]","coupling_orders":[],"id":149,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"19","lorentz_source":"built-in","particles":["w-","h","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_149"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_150","coupling_expression":"[219.3306108878756, 0.0]","coupling_orders":[],"id":150,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"17","lorentz_source":"built-in","particles":["z","z","h"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_150"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_151","coupling_expression":"[219.3306108878756, 0.0]","coupling_orders":[],"id":151,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"18","lorentz_source":"built-in","particles":["h","z","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_151"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_152","coupling_expression":"[219.3306108878756, 0.0]","coupling_orders":[],"id":152,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"19","lorentz_source":"built-in","particles":["z","h","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_152"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_153","coupling_expression":"[-618.2087564188708, 0.0]","coupling_orders":[],"id":153,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"20","lorentz_source":"built-in","particles":["h","h","h"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_153"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_154","coupling_expression":"[2.2497543582396506, 0.0]","coupling_orders":[],"id":154,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"17","lorentz_source":"built-in","particles":["w+","w-","pdg_127"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_154"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_155","coupling_expression":"[2.2497543582396506, 0.0]","coupling_orders":[],"id":155,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"17","lorentz_source":"built-in","particles":["w-","w+","pdg_127"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_155"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_156","coupling_expression":"[2.892631556300476, 0.0]","coupling_orders":[],"id":156,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"17","lorentz_source":"built-in","particles":["z","z","pdg_127"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_156"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_157","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":157,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"20","lorentz_source":"built-in","particles":["pdg_125","h","h"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_157"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_158","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":158,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"20","lorentz_source":"built-in","particles":["h","pdg_125","h"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_158"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_159","coupling_expression":"[-8.153217418943292, 0.0]","coupling_orders":[],"id":159,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"20","lorentz_source":"built-in","particles":["h","h","pdg_125"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_159"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_160","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":160,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"20","lorentz_source":"built-in","particles":["pdg_127","h","h"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_160"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_161","coupling_expression":"[1.0, 0.0]","coupling_orders":[],"id":161,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"20","lorentz_source":"built-in","particles":["h","pdg_127","h"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_161"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_162","coupling_expression":"[1.0, -10.0]","coupling_orders":[],"id":162,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"20","lorentz_source":"built-in","particles":["h","h","pdg_126"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_162"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_163","coupling_expression":"[-2.892631556300476, 0.0]","coupling_orders":[],"id":163,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"18","lorentz_source":"built-in","particles":["pdg_126","z","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_163"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_164","coupling_expression":"[-2.892631556300476, 0.0]","coupling_orders":[],"id":164,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"19","lorentz_source":"built-in","particles":["z","pdg_126","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_164"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_165","coupling_expression":"[-2.2497543582396506, 0.0]","coupling_orders":[],"id":165,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"18","lorentz_source":"built-in","particles":["pdg_126","w+","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_165"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_166","coupling_expression":"[-2.2497543582396506, 0.0]","coupling_orders":[],"id":166,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"18","lorentz_source":"built-in","particles":["pdg_126","w-","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_166"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_167","coupling_expression":"[-2.2497543582396506, 0.0]","coupling_orders":[],"id":167,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"19","lorentz_source":"built-in","particles":["w+","pdg_126","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_167"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_168","coupling_expression":"[-2.2497543582396506, 0.0]","coupling_orders":[],"id":168,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"19","lorentz_source":"built-in","particles":["w-","pdg_126","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_168"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_169","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":169,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"21","lorentz_source":"built-in","particles":["e-","e+","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_169"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_170","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":170,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"22","lorentz_source":"built-in","particles":["e+","e-","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_170"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_171","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":171,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"21","lorentz_source":"built-in","particles":["e-","e+","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_171"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_172","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":172,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"22","lorentz_source":"built-in","particles":["e+","e-","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_172"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_173","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":173,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"21","lorentz_source":"built-in","particles":["e-","ve~","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_173"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_174","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":174,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"22","lorentz_source":"built-in","particles":["e+","ve","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_174"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_175","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":175,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["e-","a","e-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_175"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_176","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":176,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["e+","a","e+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_176"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_177","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":177,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"23","lorentz_source":"built-in","particles":["a","e-","e-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_177"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_178","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":178,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"24","lorentz_source":"built-in","particles":["a","e+","e+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_178"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_179","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":179,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["e-","z","e-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_179"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_180","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":180,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["e+","z","e+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_180"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_181","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":181,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"23","lorentz_source":"built-in","particles":["z","e-","e-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_181"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_182","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":182,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"24","lorentz_source":"built-in","particles":["z","e+","e+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_182"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_183","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":183,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"21","lorentz_source":"built-in","particles":["mu-","mu+","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_183"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_184","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":184,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"22","lorentz_source":"built-in","particles":["mu+","mu-","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_184"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_185","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":185,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"21","lorentz_source":"built-in","particles":["mu-","mu+","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_185"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_186","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":186,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"22","lorentz_source":"built-in","particles":["mu+","mu-","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_186"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_187","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":187,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"21","lorentz_source":"built-in","particles":["mu-","vm~","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_187"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_188","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":188,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"22","lorentz_source":"built-in","particles":["mu+","vm","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_188"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_189","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":189,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["mu-","a","mu-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_189"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_190","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":190,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["mu+","a","mu+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_190"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_191","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":191,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"23","lorentz_source":"built-in","particles":["a","mu-","mu-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_191"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_192","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":192,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"24","lorentz_source":"built-in","particles":["a","mu+","mu+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_192"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_193","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":193,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["mu-","z","mu-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_193"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_194","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":194,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["mu+","z","mu+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_194"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_195","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":195,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"23","lorentz_source":"built-in","particles":["z","mu-","mu-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_195"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_196","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":196,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"24","lorentz_source":"built-in","particles":["z","mu+","mu+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_196"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_197","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":197,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"21","lorentz_source":"built-in","particles":["ta-","ta+","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_197"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_198","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":198,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"22","lorentz_source":"built-in","particles":["ta+","ta-","a"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_198"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_199","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":199,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"21","lorentz_source":"built-in","particles":["ta-","ta+","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_199"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_200","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":200,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"22","lorentz_source":"built-in","particles":["ta+","ta-","z"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_200"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_201","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":201,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"21","lorentz_source":"built-in","particles":["ta-","vt~","w-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_201"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_202","coupling_expression":"[1.4999181171782847, 0.0]","coupling_orders":[],"id":202,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"22","lorentz_source":"built-in","particles":["ta+","vt","w+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_202"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_203","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":203,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["ta-","a","ta-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_203"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_204","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":204,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["ta+","a","ta+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_204"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_205","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":205,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"23","lorentz_source":"built-in","particles":["a","ta-","ta-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_205"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_206","coupling_expression":"[-1.0, -1.0]","coupling_orders":[],"id":206,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"24","lorentz_source":"built-in","particles":["a","ta+","ta+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_206"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_207","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":207,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"10","lorentz_source":"built-in","particles":["ta-","z","ta-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_207"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_208","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":208,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"11","lorentz_source":"built-in","particles":["ta+","z","ta+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_208"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_209","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":209,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"23","lorentz_source":"built-in","particles":["z","ta-","ta-"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_209"},{"backend":"built-in","color_expression":"built-in","color_index":0,"color_source":"built-in","contact_orbit_certificate":null,"coupling":"builtin_coupling_210","coupling_expression":"[-0.6680686926882882, 0.5345600023586237]","coupling_orders":[],"id":210,"index_bindings":[],"lc_color_normalization_power":0,"lorentz_expression":"built-in","lorentz_index":0,"lorentz_name":"24","lorentz_source":"built-in","particles":["z","ta+","ta+"],"source_ordering_ids":[],"valence":3,"vertex":"builtin_vertex_210"}]},"issues":[],"kind":"pyamplicol-compiled-model","model":{"builtin_model":true,"closure_contractions":[{"chirality":0,"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"particle":"h"},{"chirality":0,"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"particle":"pdg_125"},{"chirality":0,"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"particle":"pdg_126"},{"chirality":0,"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"particle":"pdg_127"}],"couplings":[],"direct_contractions":[{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"auxiliary:antisymmetric-tensor","metric_signature":null,"name":"antisymmetric-tensor","right_basis":"auxiliary:antisymmetric-tensor"},"left_chirality":0,"left_particle":"pdg_-26","right_chirality":0,"right_particle":"pdg_26"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"lorentz-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"lorentz-vector"},"left_chirality":0,"left_particle":"w-","right_chirality":0,"right_particle":"w+"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"auxiliary:antisymmetric-tensor","metric_signature":null,"name":"antisymmetric-tensor","right_basis":"auxiliary:antisymmetric-tensor"},"left_chirality":0,"left_particle":"pdg_-23","right_chirality":0,"right_particle":"pdg_-23"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"auxiliary:antisymmetric-tensor","metric_signature":null,"name":"antisymmetric-tensor","right_basis":"auxiliary:antisymmetric-tensor"},"left_chirality":0,"left_particle":"pdg_-21","right_chirality":0,"right_particle":"pdg_-21"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"vt~","right_chirality":1,"right_particle":"vt"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"vt~","right_chirality":0,"right_particle":"vt"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"vt~","right_chirality":-1,"right_particle":"vt"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"ta+","right_chirality":1,"right_particle":"ta-"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"ta+","right_chirality":0,"right_particle":"ta-"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"ta+","right_chirality":-1,"right_particle":"ta-"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"vm~","right_chirality":1,"right_particle":"vm"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"vm~","right_chirality":0,"right_particle":"vm"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"vm~","right_chirality":-1,"right_particle":"vm"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"mu+","right_chirality":1,"right_particle":"mu-"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"mu+","right_chirality":0,"right_particle":"mu-"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"mu+","right_chirality":-1,"right_particle":"mu-"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"ve~","right_chirality":1,"right_particle":"ve"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"ve~","right_chirality":0,"right_particle":"ve"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"ve~","right_chirality":-1,"right_particle":"ve"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"e+","right_chirality":1,"right_particle":"e-"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"e+","right_chirality":0,"right_particle":"e-"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"e+","right_chirality":-1,"right_particle":"e-"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"t~","right_chirality":0,"right_particle":"t"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"b~","right_chirality":1,"right_particle":"b"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"b~","right_chirality":0,"right_particle":"b"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"b~","right_chirality":-1,"right_particle":"b"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"c~","right_chirality":1,"right_particle":"c"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"c~","right_chirality":0,"right_particle":"c"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"c~","right_chirality":-1,"right_particle":"c"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"s~","right_chirality":1,"right_particle":"s"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"s~","right_chirality":0,"right_particle":"s"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"s~","right_chirality":-1,"right_particle":"s"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"u~","right_chirality":1,"right_particle":"u"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"u~","right_chirality":0,"right_particle":"u"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"u~","right_chirality":-1,"right_particle":"u"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"d~","right_chirality":1,"right_particle":"d"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"d~","right_chirality":0,"right_particle":"d"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"d~","right_chirality":-1,"right_particle":"d"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"d","right_chirality":1,"right_particle":"d~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"d","right_chirality":0,"right_particle":"d~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"d","right_chirality":-1,"right_particle":"d~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"u","right_chirality":1,"right_particle":"u~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"u","right_chirality":0,"right_particle":"u~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"u","right_chirality":-1,"right_particle":"u~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"s","right_chirality":1,"right_particle":"s~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"s","right_chirality":0,"right_particle":"s~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"s","right_chirality":-1,"right_particle":"s~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"c","right_chirality":1,"right_particle":"c~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"c","right_chirality":0,"right_particle":"c~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"c","right_chirality":-1,"right_particle":"c~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"b","right_chirality":1,"right_particle":"b~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"b","right_chirality":0,"right_particle":"b~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"b","right_chirality":-1,"right_particle":"b~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"t","right_chirality":0,"right_particle":"t~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"e-","right_chirality":1,"right_particle":"e+"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"e-","right_chirality":0,"right_particle":"e+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"e-","right_chirality":-1,"right_particle":"e+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"ve","right_chirality":1,"right_particle":"ve~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"ve","right_chirality":0,"right_particle":"ve~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"ve","right_chirality":-1,"right_particle":"ve~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"mu-","right_chirality":1,"right_particle":"mu+"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"mu-","right_chirality":0,"right_particle":"mu+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"mu-","right_chirality":-1,"right_particle":"mu+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"vm","right_chirality":1,"right_particle":"vm~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"vm","right_chirality":0,"right_particle":"vm~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"vm","right_chirality":-1,"right_particle":"vm~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"ta-","right_chirality":1,"right_particle":"ta+"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"ta-","right_chirality":0,"right_particle":"ta+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"ta-","right_chirality":-1,"right_particle":"ta+"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":-1,"left_particle":"vt","right_chirality":1,"right_particle":"vt~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"dirac","metric_signature":null,"name":"dirac","right_basis":"dirac"},"left_chirality":0,"left_particle":"vt","right_chirality":0,"right_particle":"vt~"},{"contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"left_chirality":1,"left_particle":"vt","right_chirality":-1,"right_particle":"vt~"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"lorentz-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"lorentz-vector"},"left_chirality":0,"left_particle":"g","right_chirality":0,"right_particle":"g"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"lorentz-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"lorentz-vector"},"left_chirality":0,"left_particle":"a","right_chirality":0,"right_particle":"a"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"lorentz-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"lorentz-vector"},"left_chirality":0,"left_particle":"z","right_chirality":0,"right_particle":"z"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"lorentz-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"lorentz-vector"},"left_chirality":0,"left_particle":"w+","right_chirality":0,"right_particle":"w-"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"left_chirality":0,"left_particle":"h","right_chirality":0,"right_particle":"h"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0],[1.0,0.0]],"left_basis":"auxiliary:antisymmetric-tensor","metric_signature":null,"name":"antisymmetric-tensor","right_basis":"auxiliary:antisymmetric-tensor"},"left_chirality":0,"left_particle":"pdg_26","right_chirality":0,"right_particle":"pdg_-26"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0],[-1.0,0.0],[-1.0,0.0],[-1.0,0.0]],"left_basis":"auxiliary:u1-subtraction-color-flow-vector","metric_signature":"mostly-minus","name":"lorentz","right_basis":"auxiliary:u1-subtraction-color-flow-vector"},"left_chirality":0,"left_particle":"pdg_99","right_chirality":0,"right_particle":"pdg_99"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"left_chirality":0,"left_particle":"pdg_125","right_chirality":0,"right_particle":"pdg_125"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"left_chirality":0,"left_particle":"pdg_126","right_chirality":0,"right_particle":"pdg_126"},{"contraction_ir":{"chirality_relation":"any","coefficients":[[1.0,0.0]],"left_basis":"scalar","metric_signature":null,"name":"scalar","right_basis":"scalar"},"left_chirality":0,"left_particle":"pdg_127","right_chirality":0,"right_particle":"pdg_127"}],"form_factors":[],"functions":[],"lorentz_structures":[],"name":"built-in-sm","orders":[{"expansion_order":99,"hierarchy":1,"name":"QCD"},{"expansion_order":99,"hierarchy":2,"name":"QED"}],"parameters":[{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[1],"name":"alpha_ew","nature":"external","parameter_type":"real","value":[0.0075467711139788835,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[2],"name":"alpha_s","nature":"external","parameter_type":"real","value":[0.118,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[3],"name":"mass_23","nature":"external","parameter_type":"real","value":[91.188,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[4],"name":"mass_24","nature":"external","parameter_type":"real","value":[80.41900244575616,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[5],"name":"mass_25","nature":"external","parameter_type":"real","value":[125.0,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[6],"name":"mass_6","nature":"external","parameter_type":"real","value":[173.0,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[7],"name":"width_23","nature":"external","parameter_type":"real","value":[2.441404,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[8],"name":"width_24","nature":"external","parameter_type":"real","value":[2.0476,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[9],"name":"width_25","nature":"external","parameter_type":"real","value":[0.006382339,0.0]},{"expression":null,"lhablock":"PYAMPLICOL","lhacode":[10],"name":"width_6","nature":"external","parameter_type":"real","value":[1.4915,0.0]}],"particles":[{"antiname":"pdg_-23","antitexname":"pdg_-23","auxiliary_kind":"antisymmetric-tensor","charge":0.0,"color":1,"component_dimension":6,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"pdg_-23","pdg_code":-23,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":-1,"texname":"pdg_-23","width":"ZERO","y_charge":0},{"antiname":"pdg_-21","antitexname":"pdg_-21","auxiliary_kind":"antisymmetric-tensor","charge":0.0,"color":8,"component_dimension":6,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"pdg_-21","pdg_code":-21,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":-1,"texname":"pdg_-21","width":"ZERO","y_charge":0},{"antiname":"d~","antitexname":"d~","auxiliary_kind":null,"charge":-0.3333333333333333,"color":3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"d","pdg_code":1,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1/3"]],"spin":2,"texname":"d","width":"ZERO","y_charge":0},{"antiname":"d","antitexname":"d","auxiliary_kind":null,"charge":0.3333333333333333,"color":-3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"d~","pdg_code":-1,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1/3"]],"spin":2,"texname":"d~","width":"ZERO","y_charge":0},{"antiname":"u~","antitexname":"u~","auxiliary_kind":null,"charge":0.6666666666666666,"color":3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"u","pdg_code":2,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","2/3"]],"spin":2,"texname":"u","width":"ZERO","y_charge":0},{"antiname":"u","antitexname":"u","auxiliary_kind":null,"charge":-0.6666666666666666,"color":-3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"u~","pdg_code":-2,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-2/3"]],"spin":2,"texname":"u~","width":"ZERO","y_charge":0},{"antiname":"s~","antitexname":"s~","auxiliary_kind":null,"charge":-0.3333333333333333,"color":3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"s","pdg_code":3,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1/3"]],"spin":2,"texname":"s","width":"ZERO","y_charge":0},{"antiname":"s","antitexname":"s","auxiliary_kind":null,"charge":0.3333333333333333,"color":-3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"s~","pdg_code":-3,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1/3"]],"spin":2,"texname":"s~","width":"ZERO","y_charge":0},{"antiname":"c~","antitexname":"c~","auxiliary_kind":null,"charge":0.6666666666666666,"color":3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"c","pdg_code":4,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","2/3"]],"spin":2,"texname":"c","width":"ZERO","y_charge":0},{"antiname":"c","antitexname":"c","auxiliary_kind":null,"charge":-0.6666666666666666,"color":-3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"c~","pdg_code":-4,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-2/3"]],"spin":2,"texname":"c~","width":"ZERO","y_charge":0},{"antiname":"b~","antitexname":"b~","auxiliary_kind":null,"charge":-0.3333333333333333,"color":3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"b","pdg_code":5,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1/3"]],"spin":2,"texname":"b","width":"ZERO","y_charge":0},{"antiname":"b","antitexname":"b","auxiliary_kind":null,"charge":0.3333333333333333,"color":-3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"b~","pdg_code":-5,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1/3"]],"spin":2,"texname":"b~","width":"ZERO","y_charge":0},{"antiname":"t~","antitexname":"t~","auxiliary_kind":null,"charge":0.6666666666666666,"color":3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"mass_6","name":"t","pdg_code":6,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","2/3"]],"spin":2,"texname":"t","width":"width_6","y_charge":0},{"antiname":"t","antitexname":"t","auxiliary_kind":null,"charge":-0.6666666666666666,"color":-3,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"mass_6","name":"t~","pdg_code":-6,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-2/3"]],"spin":2,"texname":"t~","width":"width_6","y_charge":0},{"antiname":"e+","antitexname":"e+","auxiliary_kind":null,"charge":-1.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"e-","pdg_code":11,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1"]],"spin":2,"texname":"e-","width":"ZERO","y_charge":0},{"antiname":"e-","antitexname":"e-","auxiliary_kind":null,"charge":1.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"e+","pdg_code":-11,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1"]],"spin":2,"texname":"e+","width":"ZERO","y_charge":0},{"antiname":"ve~","antitexname":"ve~","auxiliary_kind":null,"charge":0.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"ve","pdg_code":12,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":2,"texname":"ve","width":"ZERO","y_charge":0},{"antiname":"ve","antitexname":"ve","auxiliary_kind":null,"charge":-0.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"ve~","pdg_code":-12,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":2,"texname":"ve~","width":"ZERO","y_charge":0},{"antiname":"mu+","antitexname":"mu+","auxiliary_kind":null,"charge":-1.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"mu-","pdg_code":13,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1"]],"spin":2,"texname":"mu-","width":"ZERO","y_charge":0},{"antiname":"mu-","antitexname":"mu-","auxiliary_kind":null,"charge":1.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"mu+","pdg_code":-13,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1"]],"spin":2,"texname":"mu+","width":"ZERO","y_charge":0},{"antiname":"vm~","antitexname":"vm~","auxiliary_kind":null,"charge":0.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"vm","pdg_code":14,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":2,"texname":"vm","width":"ZERO","y_charge":0},{"antiname":"vm","antitexname":"vm","auxiliary_kind":null,"charge":-0.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"vm~","pdg_code":-14,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":2,"texname":"vm~","width":"ZERO","y_charge":0},{"antiname":"ta+","antitexname":"ta+","auxiliary_kind":null,"charge":-1.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"ta-","pdg_code":15,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1"]],"spin":2,"texname":"ta-","width":"ZERO","y_charge":0},{"antiname":"ta-","antitexname":"ta-","auxiliary_kind":null,"charge":1.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"ta+","pdg_code":-15,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1"]],"spin":2,"texname":"ta+","width":"ZERO","y_charge":0},{"antiname":"vt~","antitexname":"vt~","auxiliary_kind":null,"charge":0.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"vt","pdg_code":16,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":2,"texname":"vt","width":"ZERO","y_charge":0},{"antiname":"vt","antitexname":"vt","auxiliary_kind":null,"charge":-0.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"vt~","pdg_code":-16,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":2,"texname":"vt~","width":"ZERO","y_charge":0},{"antiname":"g","antitexname":"g","auxiliary_kind":null,"charge":0.0,"color":8,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"g","pdg_code":21,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":3,"texname":"g","width":"ZERO","y_charge":0},{"antiname":"a","antitexname":"a","auxiliary_kind":null,"charge":0.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"a","pdg_code":22,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":3,"texname":"a","width":"ZERO","y_charge":0},{"antiname":"z","antitexname":"z","auxiliary_kind":null,"charge":0.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"mass_23","name":"z","pdg_code":23,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":3,"texname":"z","width":"width_23","y_charge":0},{"antiname":"w-","antitexname":"w-","auxiliary_kind":null,"charge":1.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"mass_24","name":"w+","pdg_code":24,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","1"]],"spin":3,"texname":"w+","width":"width_24","y_charge":0},{"antiname":"w+","antitexname":"w+","auxiliary_kind":null,"charge":-1.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"mass_24","name":"w-","pdg_code":-24,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","-1"]],"spin":3,"texname":"w-","width":"width_24","y_charge":0},{"antiname":"h","antitexname":"h","auxiliary_kind":null,"charge":0.0,"color":1,"component_dimension":1,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"mass_25","name":"h","pdg_code":25,"propagating":true,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":1,"texname":"h","width":"width_25","y_charge":0},{"antiname":"pdg_-26","antitexname":"pdg_-26","auxiliary_kind":"antisymmetric-tensor","charge":1.0,"color":1,"component_dimension":6,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"pdg_26","pdg_code":26,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","1"]],"spin":-1,"texname":"pdg_26","width":"ZERO","y_charge":0},{"antiname":"pdg_26","antitexname":"pdg_26","auxiliary_kind":"antisymmetric-tensor","charge":-1.0,"color":1,"component_dimension":6,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"pdg_-26","pdg_code":-26,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","-1"]],"spin":-1,"texname":"pdg_-26","width":"ZERO","y_charge":0},{"antiname":"pdg_99","antitexname":"pdg_99","auxiliary_kind":"u1-subtraction-color-flow-vector","charge":0.0,"color":1,"component_dimension":4,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"pdg_99","pdg_code":99,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":-1,"texname":"pdg_99","width":"ZERO","y_charge":0},{"antiname":"pdg_125","antitexname":"pdg_125","auxiliary_kind":null,"charge":0.0,"color":1,"component_dimension":1,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"pdg_125","pdg_code":125,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":-1,"texname":"pdg_125","width":"ZERO","y_charge":0},{"antiname":"pdg_126","antitexname":"pdg_126","auxiliary_kind":null,"charge":0.0,"color":1,"component_dimension":1,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"pdg_126","pdg_code":126,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":-1,"texname":"pdg_126","width":"ZERO","y_charge":0},{"antiname":"pdg_127","antitexname":"pdg_127","auxiliary_kind":null,"charge":0.0,"color":1,"component_dimension":1,"ghost_number":0,"goldstoneboson":false,"lepton_number":0,"mass":"ZERO","name":"pdg_127","pdg_code":127,"propagating":false,"propagator":null,"quantum_numbers":[["electric_charge","0"]],"spin":-1,"texname":"pdg_127","width":"ZERO","y_charge":0}],"propagators":[],"restriction":null,"vertex_rules":[{"builtin_coupling":[1.0,0.0],"builtin_kind":0,"color_structures":["1"],"couplings":[["builtin_coupling_0"]],"lorentz_structures":["builtin_kind_0"],"name":"builtin_vertex_0","particles":["g","g","g"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":1,"color_structures":["1"],"couplings":[["builtin_coupling_1"]],"lorentz_structures":["builtin_kind_1"],"name":"builtin_vertex_1","particles":["g","g","pdg_-21"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":2,"color_structures":["1"],"couplings":[["builtin_coupling_2"]],"lorentz_structures":["builtin_kind_2"],"name":"builtin_vertex_2","particles":["pdg_-21","g","g"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":3,"color_structures":["1"],"couplings":[["builtin_coupling_3"]],"lorentz_structures":["builtin_kind_3"],"name":"builtin_vertex_3","particles":["g","pdg_-21","g"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_4"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_4","particles":["g","d","d"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_5"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_5","particles":["g","d~","d~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_6"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_6","particles":["d","g","d"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_7"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_7","particles":["d~","g","d~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":9,"color_structures":["1"],"couplings":[["builtin_coupling_8"]],"lorentz_structures":["builtin_kind_9"],"name":"builtin_vertex_8","particles":["d~","d","g"]},{"builtin_coupling":[0.3333333333333333,0.0],"builtin_kind":8,"color_structures":["1"],"couplings":[["builtin_coupling_9"]],"lorentz_structures":["builtin_kind_8"],"name":"builtin_vertex_9","particles":["d","d~","pdg_99"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_10"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_10","particles":["pdg_99","d","d"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_11"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_11","particles":["pdg_99","d~","d~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_12"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_12","particles":["d","pdg_99","d"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_13"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_13","particles":["d~","pdg_99","d~"]},{"builtin_coupling":[-0.3333333333333333,-0.3333333333333333],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_14"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_14","particles":["d","a","d"]},{"builtin_coupling":[-0.3333333333333333,-0.3333333333333333],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_15"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_15","particles":["d~","a","d~"]},{"builtin_coupling":[-1.0244420275940371,0.17818666745287456],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_16"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_16","particles":["d","z","d"]},{"builtin_coupling":[-1.0244420275940371,0.17818666745287456],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_17"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_17","particles":["d~","z","d~"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_18"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_18","particles":["d","w+","u"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_19"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_19","particles":["d~","w-","u~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_20"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_20","particles":["g","u","u"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_21"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_21","particles":["g","u~","u~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_22"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_22","particles":["u","g","u"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_23"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_23","particles":["u~","g","u~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":9,"color_structures":["1"],"couplings":[["builtin_coupling_24"]],"lorentz_structures":["builtin_kind_9"],"name":"builtin_vertex_24","particles":["u~","u","g"]},{"builtin_coupling":[0.3333333333333333,0.0],"builtin_kind":8,"color_structures":["1"],"couplings":[["builtin_coupling_25"]],"lorentz_structures":["builtin_kind_8"],"name":"builtin_vertex_25","particles":["u","u~","pdg_99"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_26"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_26","particles":["pdg_99","u","u"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_27"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_27","particles":["pdg_99","u~","u~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_28"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_28","particles":["u","pdg_99","u"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_29"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_29","particles":["u~","pdg_99","u~"]},{"builtin_coupling":[0.6666666666666666,0.6666666666666666],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_30"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_30","particles":["u","a","u"]},{"builtin_coupling":[0.6666666666666666,0.6666666666666666],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_31"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_31","particles":["u~","a","u~"]},{"builtin_coupling":[0.8462553601411626,-0.35637333490574913],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_32"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_32","particles":["u","z","u"]},{"builtin_coupling":[0.8462553601411626,-0.35637333490574913],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_33"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_33","particles":["u~","z","u~"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_34"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_34","particles":["u","w-","d"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_35"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_35","particles":["u~","w+","d~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_36"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_36","particles":["g","s","s"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_37"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_37","particles":["g","s~","s~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_38"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_38","particles":["s","g","s"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_39"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_39","particles":["s~","g","s~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":9,"color_structures":["1"],"couplings":[["builtin_coupling_40"]],"lorentz_structures":["builtin_kind_9"],"name":"builtin_vertex_40","particles":["s~","s","g"]},{"builtin_coupling":[0.3333333333333333,0.0],"builtin_kind":8,"color_structures":["1"],"couplings":[["builtin_coupling_41"]],"lorentz_structures":["builtin_kind_8"],"name":"builtin_vertex_41","particles":["s","s~","pdg_99"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_42"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_42","particles":["pdg_99","s","s"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_43"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_43","particles":["pdg_99","s~","s~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_44"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_44","particles":["s","pdg_99","s"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_45"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_45","particles":["s~","pdg_99","s~"]},{"builtin_coupling":[-0.3333333333333333,-0.3333333333333333],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_46"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_46","particles":["s","a","s"]},{"builtin_coupling":[-0.3333333333333333,-0.3333333333333333],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_47"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_47","particles":["s~","a","s~"]},{"builtin_coupling":[-1.0244420275940371,0.17818666745287456],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_48"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_48","particles":["s","z","s"]},{"builtin_coupling":[-1.0244420275940371,0.17818666745287456],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_49"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_49","particles":["s~","z","s~"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_50"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_50","particles":["s","w+","c"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_51"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_51","particles":["s~","w-","c~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_52"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_52","particles":["g","c","c"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_53"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_53","particles":["g","c~","c~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_54"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_54","particles":["c","g","c"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_55"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_55","particles":["c~","g","c~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":9,"color_structures":["1"],"couplings":[["builtin_coupling_56"]],"lorentz_structures":["builtin_kind_9"],"name":"builtin_vertex_56","particles":["c~","c","g"]},{"builtin_coupling":[0.3333333333333333,0.0],"builtin_kind":8,"color_structures":["1"],"couplings":[["builtin_coupling_57"]],"lorentz_structures":["builtin_kind_8"],"name":"builtin_vertex_57","particles":["c","c~","pdg_99"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_58"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_58","particles":["pdg_99","c","c"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_59"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_59","particles":["pdg_99","c~","c~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_60"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_60","particles":["c","pdg_99","c"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_61"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_61","particles":["c~","pdg_99","c~"]},{"builtin_coupling":[0.6666666666666666,0.6666666666666666],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_62"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_62","particles":["c","a","c"]},{"builtin_coupling":[0.6666666666666666,0.6666666666666666],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_63"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_63","particles":["c~","a","c~"]},{"builtin_coupling":[0.8462553601411626,-0.35637333490574913],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_64"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_64","particles":["c","z","c"]},{"builtin_coupling":[0.8462553601411626,-0.35637333490574913],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_65"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_65","particles":["c~","z","c~"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_66"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_66","particles":["c","w-","s"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_67"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_67","particles":["c~","w+","s~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_68"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_68","particles":["g","b","b"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_69"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_69","particles":["g","b~","b~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_70"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_70","particles":["b","g","b"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_71"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_71","particles":["b~","g","b~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":9,"color_structures":["1"],"couplings":[["builtin_coupling_72"]],"lorentz_structures":["builtin_kind_9"],"name":"builtin_vertex_72","particles":["b~","b","g"]},{"builtin_coupling":[0.3333333333333333,0.0],"builtin_kind":8,"color_structures":["1"],"couplings":[["builtin_coupling_73"]],"lorentz_structures":["builtin_kind_8"],"name":"builtin_vertex_73","particles":["b","b~","pdg_99"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_74"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_74","particles":["pdg_99","b","b"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_75"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_75","particles":["pdg_99","b~","b~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_76"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_76","particles":["b","pdg_99","b"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_77"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_77","particles":["b~","pdg_99","b~"]},{"builtin_coupling":[-0.3333333333333333,-0.3333333333333333],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_78"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_78","particles":["b","a","b"]},{"builtin_coupling":[-0.3333333333333333,-0.3333333333333333],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_79"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_79","particles":["b~","a","b~"]},{"builtin_coupling":[-1.0244420275940371,0.17818666745287456],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_80"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_80","particles":["b","z","b"]},{"builtin_coupling":[-1.0244420275940371,0.17818666745287456],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_81"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_81","particles":["b~","z","b~"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_82"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_82","particles":["b","w+","t"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_83"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_83","particles":["b~","w-","t~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_84"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_84","particles":["g","t","t"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_85"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_85","particles":["g","t~","t~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_86"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_86","particles":["t","g","t"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_87"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_87","particles":["t~","g","t~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":9,"color_structures":["1"],"couplings":[["builtin_coupling_88"]],"lorentz_structures":["builtin_kind_9"],"name":"builtin_vertex_88","particles":["t~","t","g"]},{"builtin_coupling":[0.3333333333333333,0.0],"builtin_kind":8,"color_structures":["1"],"couplings":[["builtin_coupling_89"]],"lorentz_structures":["builtin_kind_8"],"name":"builtin_vertex_89","particles":["t","t~","pdg_99"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":4,"color_structures":["1"],"couplings":[["builtin_coupling_90"]],"lorentz_structures":["builtin_kind_4"],"name":"builtin_vertex_90","particles":["pdg_99","t","t"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":5,"color_structures":["1"],"couplings":[["builtin_coupling_91"]],"lorentz_structures":["builtin_kind_5"],"name":"builtin_vertex_91","particles":["pdg_99","t~","t~"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":6,"color_structures":["1"],"couplings":[["builtin_coupling_92"]],"lorentz_structures":["builtin_kind_6"],"name":"builtin_vertex_92","particles":["t","pdg_99","t"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":7,"color_structures":["1"],"couplings":[["builtin_coupling_93"]],"lorentz_structures":["builtin_kind_7"],"name":"builtin_vertex_93","particles":["t~","pdg_99","t~"]},{"builtin_coupling":[0.6666666666666666,0.6666666666666666],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_94"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_94","particles":["t","a","t"]},{"builtin_coupling":[0.6666666666666666,0.6666666666666666],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_95"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_95","particles":["t~","a","t~"]},{"builtin_coupling":[0.8462553601411626,-0.35637333490574913],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_96"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_96","particles":["t","z","t"]},{"builtin_coupling":[0.8462553601411626,-0.35637333490574913],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_97"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_97","particles":["t~","z","t~"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_98"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_98","particles":["t","w-","b"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_99"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_99","particles":["t~","w+","b~"]},{"builtin_coupling":[-1.8706973877352002,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_100"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_100","particles":["w+","w-","z"]},{"builtin_coupling":[1.8706973877352002,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_101"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_101","particles":["w-","w+","z"]},{"builtin_coupling":[-1.0,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_102"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_102","particles":["w+","w-","a"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_103"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_103","particles":["w-","w+","a"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_104"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_104","particles":["w+","a","w+"]},{"builtin_coupling":[-1.0,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_105"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_105","particles":["w-","a","w-"]},{"builtin_coupling":[-1.0,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_106"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_106","particles":["a","w+","w+"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_107"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_107","particles":["a","w-","w-"]},{"builtin_coupling":[1.8706973877352002,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_108"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_108","particles":["w+","z","w+"]},{"builtin_coupling":[-1.8706973877352002,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_109"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_109","particles":["w-","z","w-"]},{"builtin_coupling":[-1.8706973877352002,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_110"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_110","particles":["z","w+","w+"]},{"builtin_coupling":[1.8706973877352002,0.0],"builtin_kind":12,"color_structures":["1"],"couplings":[["builtin_coupling_111"]],"lorentz_structures":["builtin_kind_12"],"name":"builtin_vertex_111","particles":["z","w-","w-"]},{"builtin_coupling":[2.1212045437626474,0.0],"builtin_kind":13,"color_structures":["1"],"couplings":[["builtin_coupling_112"]],"lorentz_structures":["builtin_kind_13"],"name":"builtin_vertex_112","particles":["w+","w-","pdg_-23"]},{"builtin_coupling":[-2.1212045437626474,0.0],"builtin_kind":13,"color_structures":["1"],"couplings":[["builtin_coupling_113"]],"lorentz_structures":["builtin_kind_13"],"name":"builtin_vertex_113","particles":["w-","w+","pdg_-23"]},{"builtin_coupling":[2.1212045437626474,0.0],"builtin_kind":14,"color_structures":["1"],"couplings":[["builtin_coupling_114"]],"lorentz_structures":["builtin_kind_14"],"name":"builtin_vertex_114","particles":["pdg_-23","w+","w+"]},{"builtin_coupling":[-2.1212045437626474,0.0],"builtin_kind":14,"color_structures":["1"],"couplings":[["builtin_coupling_115"]],"lorentz_structures":["builtin_kind_14"],"name":"builtin_vertex_115","particles":["pdg_-23","w-","w-"]},{"builtin_coupling":[-2.1212045437626474,0.0],"builtin_kind":15,"color_structures":["1"],"couplings":[["builtin_coupling_116"]],"lorentz_structures":["builtin_kind_15"],"name":"builtin_vertex_116","particles":["w+","pdg_-23","w+"]},{"builtin_coupling":[2.1212045437626474,0.0],"builtin_kind":15,"color_structures":["1"],"couplings":[["builtin_coupling_117"]],"lorentz_structures":["builtin_kind_15"],"name":"builtin_vertex_117","particles":["w-","pdg_-23","w-"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":13,"color_structures":["1"],"couplings":[["builtin_coupling_118"]],"lorentz_structures":["builtin_kind_13"],"name":"builtin_vertex_118","particles":["w+","a","pdg_26"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":13,"color_structures":["1"],"couplings":[["builtin_coupling_119"]],"lorentz_structures":["builtin_kind_13"],"name":"builtin_vertex_119","particles":["w-","a","pdg_-26"]},{"builtin_coupling":[-1.0,0.0],"builtin_kind":13,"color_structures":["1"],"couplings":[["builtin_coupling_120"]],"lorentz_structures":["builtin_kind_13"],"name":"builtin_vertex_120","particles":["a","w+","pdg_26"]},{"builtin_coupling":[-1.0,0.0],"builtin_kind":13,"color_structures":["1"],"couplings":[["builtin_coupling_121"]],"lorentz_structures":["builtin_kind_13"],"name":"builtin_vertex_121","particles":["a","w-","pdg_-26"]},{"builtin_coupling":[1.8706973877352002,0.0],"builtin_kind":13,"color_structures":["1"],"couplings":[["builtin_coupling_122"]],"lorentz_structures":["builtin_kind_13"],"name":"builtin_vertex_122","particles":["w+","z","pdg_26"]},{"builtin_coupling":[1.8706973877352002,0.0],"builtin_kind":13,"color_structures":["1"],"couplings":[["builtin_coupling_123"]],"lorentz_structures":["builtin_kind_13"],"name":"builtin_vertex_123","particles":["w-","z","pdg_-26"]},{"builtin_coupling":[-1.8706973877352002,0.0],"builtin_kind":13,"color_structures":["1"],"couplings":[["builtin_coupling_124"]],"lorentz_structures":["builtin_kind_13"],"name":"builtin_vertex_124","particles":["z","w+","pdg_26"]},{"builtin_coupling":[-1.8706973877352002,0.0],"builtin_kind":13,"color_structures":["1"],"couplings":[["builtin_coupling_125"]],"lorentz_structures":["builtin_kind_13"],"name":"builtin_vertex_125","particles":["z","w-","pdg_-26"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":14,"color_structures":["1"],"couplings":[["builtin_coupling_126"]],"lorentz_structures":["builtin_kind_14"],"name":"builtin_vertex_126","particles":["pdg_26","a","w+"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":14,"color_structures":["1"],"couplings":[["builtin_coupling_127"]],"lorentz_structures":["builtin_kind_14"],"name":"builtin_vertex_127","particles":["pdg_-26","a","w-"]},{"builtin_coupling":[-1.0,0.0],"builtin_kind":14,"color_structures":["1"],"couplings":[["builtin_coupling_128"]],"lorentz_structures":["builtin_kind_14"],"name":"builtin_vertex_128","particles":["pdg_26","w-","a"]},{"builtin_coupling":[-1.0,0.0],"builtin_kind":14,"color_structures":["1"],"couplings":[["builtin_coupling_129"]],"lorentz_structures":["builtin_kind_14"],"name":"builtin_vertex_129","particles":["pdg_-26","w+","a"]},{"builtin_coupling":[1.8706973877352002,0.0],"builtin_kind":14,"color_structures":["1"],"couplings":[["builtin_coupling_130"]],"lorentz_structures":["builtin_kind_14"],"name":"builtin_vertex_130","particles":["pdg_26","z","w+"]},{"builtin_coupling":[1.8706973877352002,0.0],"builtin_kind":14,"color_structures":["1"],"couplings":[["builtin_coupling_131"]],"lorentz_structures":["builtin_kind_14"],"name":"builtin_vertex_131","particles":["pdg_-26","z","w-"]},{"builtin_coupling":[-1.8706973877352002,0.0],"builtin_kind":14,"color_structures":["1"],"couplings":[["builtin_coupling_132"]],"lorentz_structures":["builtin_kind_14"],"name":"builtin_vertex_132","particles":["pdg_26","w-","z"]},{"builtin_coupling":[-1.8706973877352002,0.0],"builtin_kind":14,"color_structures":["1"],"couplings":[["builtin_coupling_133"]],"lorentz_structures":["builtin_kind_14"],"name":"builtin_vertex_133","particles":["pdg_-26","w+","z"]},{"builtin_coupling":[-1.0,0.0],"builtin_kind":15,"color_structures":["1"],"couplings":[["builtin_coupling_134"]],"lorentz_structures":["builtin_kind_15"],"name":"builtin_vertex_134","particles":["a","pdg_26","w+"]},{"builtin_coupling":[-1.0,0.0],"builtin_kind":15,"color_structures":["1"],"couplings":[["builtin_coupling_135"]],"lorentz_structures":["builtin_kind_15"],"name":"builtin_vertex_135","particles":["a","pdg_-26","w-"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":15,"color_structures":["1"],"couplings":[["builtin_coupling_136"]],"lorentz_structures":["builtin_kind_15"],"name":"builtin_vertex_136","particles":["w+","pdg_-26","a"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":15,"color_structures":["1"],"couplings":[["builtin_coupling_137"]],"lorentz_structures":["builtin_kind_15"],"name":"builtin_vertex_137","particles":["w-","pdg_26","a"]},{"builtin_coupling":[-1.8706973877352002,0.0],"builtin_kind":15,"color_structures":["1"],"couplings":[["builtin_coupling_138"]],"lorentz_structures":["builtin_kind_15"],"name":"builtin_vertex_138","particles":["z","pdg_26","w+"]},{"builtin_coupling":[-1.8706973877352002,0.0],"builtin_kind":15,"color_structures":["1"],"couplings":[["builtin_coupling_139"]],"lorentz_structures":["builtin_kind_15"],"name":"builtin_vertex_139","particles":["z","pdg_-26","w-"]},{"builtin_coupling":[1.8706973877352002,0.0],"builtin_kind":15,"color_structures":["1"],"couplings":[["builtin_coupling_140"]],"lorentz_structures":["builtin_kind_15"],"name":"builtin_vertex_140","particles":["w+","pdg_-26","z"]},{"builtin_coupling":[1.8706973877352002,0.0],"builtin_kind":15,"color_structures":["1"],"couplings":[["builtin_coupling_141"]],"lorentz_structures":["builtin_kind_15"],"name":"builtin_vertex_141","particles":["w-","pdg_26","z"]},{"builtin_coupling":[2.281602450356579,0.0],"builtin_kind":16,"color_structures":["1"],"couplings":[["builtin_coupling_142"]],"lorentz_structures":["builtin_kind_16"],"name":"builtin_vertex_142","particles":["t","h","t"]},{"builtin_coupling":[2.281602450356579,0.0],"builtin_kind":16,"color_structures":["1"],"couplings":[["builtin_coupling_143"]],"lorentz_structures":["builtin_kind_16"],"name":"builtin_vertex_143","particles":["t~","h","t~"]},{"builtin_coupling":[170.58515339279742,0.0],"builtin_kind":17,"color_structures":["1"],"couplings":[["builtin_coupling_144"]],"lorentz_structures":["builtin_kind_17"],"name":"builtin_vertex_144","particles":["w+","w-","h"]},{"builtin_coupling":[170.58515339279742,0.0],"builtin_kind":17,"color_structures":["1"],"couplings":[["builtin_coupling_145"]],"lorentz_structures":["builtin_kind_17"],"name":"builtin_vertex_145","particles":["w-","w+","h"]},{"builtin_coupling":[170.58515339279742,0.0],"builtin_kind":18,"color_structures":["1"],"couplings":[["builtin_coupling_146"]],"lorentz_structures":["builtin_kind_18"],"name":"builtin_vertex_146","particles":["h","w+","w+"]},{"builtin_coupling":[170.58515339279742,0.0],"builtin_kind":18,"color_structures":["1"],"couplings":[["builtin_coupling_147"]],"lorentz_structures":["builtin_kind_18"],"name":"builtin_vertex_147","particles":["h","w-","w-"]},{"builtin_coupling":[170.58515339279742,0.0],"builtin_kind":19,"color_structures":["1"],"couplings":[["builtin_coupling_148"]],"lorentz_structures":["builtin_kind_19"],"name":"builtin_vertex_148","particles":["w+","h","w+"]},{"builtin_coupling":[170.58515339279742,0.0],"builtin_kind":19,"color_structures":["1"],"couplings":[["builtin_coupling_149"]],"lorentz_structures":["builtin_kind_19"],"name":"builtin_vertex_149","particles":["w-","h","w-"]},{"builtin_coupling":[219.3306108878756,0.0],"builtin_kind":17,"color_structures":["1"],"couplings":[["builtin_coupling_150"]],"lorentz_structures":["builtin_kind_17"],"name":"builtin_vertex_150","particles":["z","z","h"]},{"builtin_coupling":[219.3306108878756,0.0],"builtin_kind":18,"color_structures":["1"],"couplings":[["builtin_coupling_151"]],"lorentz_structures":["builtin_kind_18"],"name":"builtin_vertex_151","particles":["h","z","z"]},{"builtin_coupling":[219.3306108878756,0.0],"builtin_kind":19,"color_structures":["1"],"couplings":[["builtin_coupling_152"]],"lorentz_structures":["builtin_kind_19"],"name":"builtin_vertex_152","particles":["z","h","z"]},{"builtin_coupling":[-618.2087564188708,0.0],"builtin_kind":20,"color_structures":["1"],"couplings":[["builtin_coupling_153"]],"lorentz_structures":["builtin_kind_20"],"name":"builtin_vertex_153","particles":["h","h","h"]},{"builtin_coupling":[2.2497543582396506,0.0],"builtin_kind":17,"color_structures":["1"],"couplings":[["builtin_coupling_154"]],"lorentz_structures":["builtin_kind_17"],"name":"builtin_vertex_154","particles":["w+","w-","pdg_127"]},{"builtin_coupling":[2.2497543582396506,0.0],"builtin_kind":17,"color_structures":["1"],"couplings":[["builtin_coupling_155"]],"lorentz_structures":["builtin_kind_17"],"name":"builtin_vertex_155","particles":["w-","w+","pdg_127"]},{"builtin_coupling":[2.892631556300476,0.0],"builtin_kind":17,"color_structures":["1"],"couplings":[["builtin_coupling_156"]],"lorentz_structures":["builtin_kind_17"],"name":"builtin_vertex_156","particles":["z","z","pdg_127"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":20,"color_structures":["1"],"couplings":[["builtin_coupling_157"]],"lorentz_structures":["builtin_kind_20"],"name":"builtin_vertex_157","particles":["pdg_125","h","h"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":20,"color_structures":["1"],"couplings":[["builtin_coupling_158"]],"lorentz_structures":["builtin_kind_20"],"name":"builtin_vertex_158","particles":["h","pdg_125","h"]},{"builtin_coupling":[-8.153217418943292,0.0],"builtin_kind":20,"color_structures":["1"],"couplings":[["builtin_coupling_159"]],"lorentz_structures":["builtin_kind_20"],"name":"builtin_vertex_159","particles":["h","h","pdg_125"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":20,"color_structures":["1"],"couplings":[["builtin_coupling_160"]],"lorentz_structures":["builtin_kind_20"],"name":"builtin_vertex_160","particles":["pdg_127","h","h"]},{"builtin_coupling":[1.0,0.0],"builtin_kind":20,"color_structures":["1"],"couplings":[["builtin_coupling_161"]],"lorentz_structures":["builtin_kind_20"],"name":"builtin_vertex_161","particles":["h","pdg_127","h"]},{"builtin_coupling":[1.0,-10.0],"builtin_kind":20,"color_structures":["1"],"couplings":[["builtin_coupling_162"]],"lorentz_structures":["builtin_kind_20"],"name":"builtin_vertex_162","particles":["h","h","pdg_126"]},{"builtin_coupling":[-2.892631556300476,0.0],"builtin_kind":18,"color_structures":["1"],"couplings":[["builtin_coupling_163"]],"lorentz_structures":["builtin_kind_18"],"name":"builtin_vertex_163","particles":["pdg_126","z","z"]},{"builtin_coupling":[-2.892631556300476,0.0],"builtin_kind":19,"color_structures":["1"],"couplings":[["builtin_coupling_164"]],"lorentz_structures":["builtin_kind_19"],"name":"builtin_vertex_164","particles":["z","pdg_126","z"]},{"builtin_coupling":[-2.2497543582396506,0.0],"builtin_kind":18,"color_structures":["1"],"couplings":[["builtin_coupling_165"]],"lorentz_structures":["builtin_kind_18"],"name":"builtin_vertex_165","particles":["pdg_126","w+","w+"]},{"builtin_coupling":[-2.2497543582396506,0.0],"builtin_kind":18,"color_structures":["1"],"couplings":[["builtin_coupling_166"]],"lorentz_structures":["builtin_kind_18"],"name":"builtin_vertex_166","particles":["pdg_126","w-","w-"]},{"builtin_coupling":[-2.2497543582396506,0.0],"builtin_kind":19,"color_structures":["1"],"couplings":[["builtin_coupling_167"]],"lorentz_structures":["builtin_kind_19"],"name":"builtin_vertex_167","particles":["w+","pdg_126","w+"]},{"builtin_coupling":[-2.2497543582396506,0.0],"builtin_kind":19,"color_structures":["1"],"couplings":[["builtin_coupling_168"]],"lorentz_structures":["builtin_kind_19"],"name":"builtin_vertex_168","particles":["w-","pdg_126","w-"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":21,"color_structures":["1"],"couplings":[["builtin_coupling_169"]],"lorentz_structures":["builtin_kind_21"],"name":"builtin_vertex_169","particles":["e-","e+","a"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":22,"color_structures":["1"],"couplings":[["builtin_coupling_170"]],"lorentz_structures":["builtin_kind_22"],"name":"builtin_vertex_170","particles":["e+","e-","a"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":21,"color_structures":["1"],"couplings":[["builtin_coupling_171"]],"lorentz_structures":["builtin_kind_21"],"name":"builtin_vertex_171","particles":["e-","e+","z"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":22,"color_structures":["1"],"couplings":[["builtin_coupling_172"]],"lorentz_structures":["builtin_kind_22"],"name":"builtin_vertex_172","particles":["e+","e-","z"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":21,"color_structures":["1"],"couplings":[["builtin_coupling_173"]],"lorentz_structures":["builtin_kind_21"],"name":"builtin_vertex_173","particles":["e-","ve~","w-"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":22,"color_structures":["1"],"couplings":[["builtin_coupling_174"]],"lorentz_structures":["builtin_kind_22"],"name":"builtin_vertex_174","particles":["e+","ve","w+"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_175"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_175","particles":["e-","a","e-"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_176"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_176","particles":["e+","a","e+"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":23,"color_structures":["1"],"couplings":[["builtin_coupling_177"]],"lorentz_structures":["builtin_kind_23"],"name":"builtin_vertex_177","particles":["a","e-","e-"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":24,"color_structures":["1"],"couplings":[["builtin_coupling_178"]],"lorentz_structures":["builtin_kind_24"],"name":"builtin_vertex_178","particles":["a","e+","e+"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_179"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_179","particles":["e-","z","e-"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_180"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_180","particles":["e+","z","e+"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":23,"color_structures":["1"],"couplings":[["builtin_coupling_181"]],"lorentz_structures":["builtin_kind_23"],"name":"builtin_vertex_181","particles":["z","e-","e-"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":24,"color_structures":["1"],"couplings":[["builtin_coupling_182"]],"lorentz_structures":["builtin_kind_24"],"name":"builtin_vertex_182","particles":["z","e+","e+"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":21,"color_structures":["1"],"couplings":[["builtin_coupling_183"]],"lorentz_structures":["builtin_kind_21"],"name":"builtin_vertex_183","particles":["mu-","mu+","a"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":22,"color_structures":["1"],"couplings":[["builtin_coupling_184"]],"lorentz_structures":["builtin_kind_22"],"name":"builtin_vertex_184","particles":["mu+","mu-","a"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":21,"color_structures":["1"],"couplings":[["builtin_coupling_185"]],"lorentz_structures":["builtin_kind_21"],"name":"builtin_vertex_185","particles":["mu-","mu+","z"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":22,"color_structures":["1"],"couplings":[["builtin_coupling_186"]],"lorentz_structures":["builtin_kind_22"],"name":"builtin_vertex_186","particles":["mu+","mu-","z"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":21,"color_structures":["1"],"couplings":[["builtin_coupling_187"]],"lorentz_structures":["builtin_kind_21"],"name":"builtin_vertex_187","particles":["mu-","vm~","w-"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":22,"color_structures":["1"],"couplings":[["builtin_coupling_188"]],"lorentz_structures":["builtin_kind_22"],"name":"builtin_vertex_188","particles":["mu+","vm","w+"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_189"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_189","particles":["mu-","a","mu-"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_190"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_190","particles":["mu+","a","mu+"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":23,"color_structures":["1"],"couplings":[["builtin_coupling_191"]],"lorentz_structures":["builtin_kind_23"],"name":"builtin_vertex_191","particles":["a","mu-","mu-"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":24,"color_structures":["1"],"couplings":[["builtin_coupling_192"]],"lorentz_structures":["builtin_kind_24"],"name":"builtin_vertex_192","particles":["a","mu+","mu+"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_193"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_193","particles":["mu-","z","mu-"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_194"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_194","particles":["mu+","z","mu+"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":23,"color_structures":["1"],"couplings":[["builtin_coupling_195"]],"lorentz_structures":["builtin_kind_23"],"name":"builtin_vertex_195","particles":["z","mu-","mu-"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":24,"color_structures":["1"],"couplings":[["builtin_coupling_196"]],"lorentz_structures":["builtin_kind_24"],"name":"builtin_vertex_196","particles":["z","mu+","mu+"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":21,"color_structures":["1"],"couplings":[["builtin_coupling_197"]],"lorentz_structures":["builtin_kind_21"],"name":"builtin_vertex_197","particles":["ta-","ta+","a"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":22,"color_structures":["1"],"couplings":[["builtin_coupling_198"]],"lorentz_structures":["builtin_kind_22"],"name":"builtin_vertex_198","particles":["ta+","ta-","a"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":21,"color_structures":["1"],"couplings":[["builtin_coupling_199"]],"lorentz_structures":["builtin_kind_21"],"name":"builtin_vertex_199","particles":["ta-","ta+","z"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":22,"color_structures":["1"],"couplings":[["builtin_coupling_200"]],"lorentz_structures":["builtin_kind_22"],"name":"builtin_vertex_200","particles":["ta+","ta-","z"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":21,"color_structures":["1"],"couplings":[["builtin_coupling_201"]],"lorentz_structures":["builtin_kind_21"],"name":"builtin_vertex_201","particles":["ta-","vt~","w-"]},{"builtin_coupling":[1.4999181171782847,0.0],"builtin_kind":22,"color_structures":["1"],"couplings":[["builtin_coupling_202"]],"lorentz_structures":["builtin_kind_22"],"name":"builtin_vertex_202","particles":["ta+","vt","w+"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_203"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_203","particles":["ta-","a","ta-"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_204"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_204","particles":["ta+","a","ta+"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":23,"color_structures":["1"],"couplings":[["builtin_coupling_205"]],"lorentz_structures":["builtin_kind_23"],"name":"builtin_vertex_205","particles":["a","ta-","ta-"]},{"builtin_coupling":[-1.0,-1.0],"builtin_kind":24,"color_structures":["1"],"couplings":[["builtin_coupling_206"]],"lorentz_structures":["builtin_kind_24"],"name":"builtin_vertex_206","particles":["a","ta+","ta+"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":10,"color_structures":["1"],"couplings":[["builtin_coupling_207"]],"lorentz_structures":["builtin_kind_10"],"name":"builtin_vertex_207","particles":["ta-","z","ta-"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":11,"color_structures":["1"],"couplings":[["builtin_coupling_208"]],"lorentz_structures":["builtin_kind_11"],"name":"builtin_vertex_208","particles":["ta+","z","ta+"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":23,"color_structures":["1"],"couplings":[["builtin_coupling_209"]],"lorentz_structures":["builtin_kind_23"],"name":"builtin_vertex_209","particles":["z","ta-","ta-"]},{"builtin_coupling":[-0.6680686926882882,0.5345600023586237],"builtin_kind":24,"color_structures":["1"],"couplings":[["builtin_coupling_210"]],"lorentz_structures":["builtin_kind_24"],"name":"builtin_vertex_210","particles":["z","ta+","ta+"]}]},"model_compiler_version":16,"parameter_defaults":{"alpha_ew":[0.0075467711139788835,0.0],"alpha_s":[0.118,0.0],"mass_23":[91.188,0.0],"mass_24":[80.41900244575616,0.0],"mass_25":[125.0,0.0],"mass_6":[173.0,0.0],"width_23":[2.441404,0.0],"width_24":[2.0476,0.0],"width_25":[0.006382339,0.0],"width_6":[1.4915,0.0]},"phase_timings":{"model_loading":0.0028243749402463436,"preflight":0.00040449993684887886,"tensor_lowering":0.006884499918669462,"total":0.010124958120286465},"producer":{"compiled_model_schema_version":9,"contact_decomposition_policy":"ufo-four-point-contact-decomposition-v2","model_compiler_sha256":"2a3cce12de8775926f302ed07706c45298727ffe690c3379b010012f7a7b77f8","model_compiler_version":16,"model_environment_policy":"sanitize-historical-scalar-options-v1","pyamplicol":"1.0.0","symbol_namespace_policy":"model-name-and-pyamplicol-registry-v1","symbolica":"3.0.0","symbolica_serialization_abi":"symbolica-bincode2-v1","tensor_ordering_contract":"explicit-canonical-component-order-v1","ufo_model_loader":"1.0.0"},"schema_version":9,"source":{"digest":"db50b0cb34998c1a9f7bf63c2b7a4d80c01f373a00d9bee81372b2d43a506962","kind":"built-in-sm","options":{"restriction":{"kind":"name","value":"default"},"simplify":true},"source_name":null}}
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/model/parameters.json b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/model/parameters.json
new file mode 100644
index 0000000000..3de027c9a2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/model/parameters.json
@@ -0,0 +1,46 @@
+{
+  "kind": "pyamplicol-model-parameter-defaults",
+  "parameters": {
+    "alpha_ew": [
+      0.0075467711139788835,
+      0.0
+    ],
+    "alpha_s": [
+      0.118,
+      0.0
+    ],
+    "mass_23": [
+      91.188,
+      0.0
+    ],
+    "mass_24": [
+      80.41900244575616,
+      0.0
+    ],
+    "mass_25": [
+      125.0,
+      0.0
+    ],
+    "mass_6": [
+      173.0,
+      0.0
+    ],
+    "width_23": [
+      2.441404,
+      0.0
+    ],
+    "width_24": [
+      2.0476,
+      0.0
+    ],
+    "width_25": [
+      0.006382339,
+      0.0
+    ],
+    "width_6": [
+      1.4915,
+      0.0
+    ]
+  },
+  "schema_version": 1
+}
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/d_dbar_to_z/execution.json b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/d_dbar_to_z/execution.json
new file mode 100644
index 0000000000..ef4185d726
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/d_dbar_to_z/execution.json
@@ -0,0 +1 @@
+{"color_accuracy":"lc","compiled":{"helicity_recurrence":{"amplitude_classes":[{"class_id":"helicity-amplitude-sha256:d56fc183f4e6996740930cb59d082773bc739fdc54de6c684a44b2d643911365","members":[{"factor":[1.0,0.0],"root_id":0,"selector_domain_ids":[8]},{"factor":[1.0,0.0],"root_id":1,"selector_domain_ids":[9]},{"factor":[1.0,0.0],"root_id":2,"selector_domain_ids":[10]}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"d56fc183f4e6996740930cb59d082773bc739fdc54de6c684a44b2d643911365","status":"proven","transition_contract_ids":[]},"representative_root_id":0},{"class_id":"helicity-amplitude-sha256:19760a2fbd284e1f9c6b8d22028a99181ead6fa6e4437c0c42786703785a310a","members":[{"factor":[1.0,0.0],"root_id":3,"selector_domain_ids":[4]},{"factor":[1.0,0.0],"root_id":4,"selector_domain_ids":[5]},{"factor":[1.0,0.0],"root_id":5,"selector_domain_ids":[6]}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"19760a2fbd284e1f9c6b8d22028a99181ead6fa6e4437c0c42786703785a310a","status":"proven","transition_contract_ids":[]},"representative_root_id":3}],"amplitude_root_count":6,"contract_version":1,"current_count":13,"diagnostics":[],"kind":"pyamplicol-helicity-recurrence","materialization":{"amplitude_routes":[{"factor":[1.0,0.0],"materialized_root_id":0,"residual":false,"selector_domain_ids":[8]},{"factor":[1.0,0.0],"materialized_root_id":0,"residual":false,"selector_domain_ids":[9]},{"factor":[1.0,0.0],"materialized_root_id":0,"residual":false,"selector_domain_ids":[10]},{"factor":[1.0,0.0],"materialized_root_id":1,"residual":false,"selector_domain_ids":[4]},{"factor":[1.0,0.0],"materialized_root_id":1,"residual":false,"selector_domain_ids":[5]},{"factor":[1.0,0.0],"materialized_root_id":1,"residual":false,"selector_domain_ids":[6]}],"contract_version":1,"kind":"pyamplicol-helicity-recurrence-materialization","materialized_current_count":7,"materialized_root_count":2,"proof_current_count":13,"proof_root_count":6,"proof_to_materialized_current":[0,1,2,3,4,4,4,5,5,5,6,6,6],"selector_schedules":[{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":1,"structural_zero":true},{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":2,"structural_zero":true},{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":3,"structural_zero":true},{"active_current_ids":[0,3,4,6],"active_root_ids":[1],"selector_domain_id":4,"structural_zero":false},{"active_current_ids":[0,3,4,6],"active_root_ids":[1],"selector_domain_id":5,"structural_zero":false},{"active_current_ids":[0,3,4,6],"active_root_ids":[1],"selector_domain_id":6,"structural_zero":false},{"active_current_ids":[1,2,4,5],"active_root_ids":[0],"selector_domain_id":8,"structural_zero":false},{"active_current_ids":[1,2,4,5],"active_root_ids":[0],"selector_domain_id":9,"structural_zero":false},{"active_current_ids":[1,2,4,5],"active_root_ids":[0],"selector_domain_id":10,"structural_zero":false},{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":11,"structural_zero":true},{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":12,"structural_zero":true},{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":13,"structural_zero":true}],"source_routes":[{"chirality":1,"declared_state_index":0,"external_label":1,"factor":[1.0,0.0],"helicity":-1,"materialized_current_id":0,"selector_domain_id":0,"spin_state":1},{"chirality":-1,"declared_state_index":1,"external_label":1,"factor":[1.0,0.0],"helicity":1,"materialized_current_id":1,"selector_domain_id":7,"spin_state":-1},{"chirality":1,"declared_state_index":0,"external_label":2,"factor":[1.0,0.0],"helicity":-1,"materialized_current_id":2,"selector_domain_id":14,"spin_state":1},{"chirality":-1,"declared_state_index":1,"external_label":2,"factor":[1.0,0.0],"helicity":1,"materialized_current_id":3,"selector_domain_id":18,"spin_state":-1},{"chirality":0,"declared_state_index":0,"external_label":3,"factor":[1.0,0.0],"helicity":-1,"materialized_current_id":4,"selector_domain_id":22,"spin_state":-1},{"chirality":0,"declared_state_index":1,"external_label":3,"factor":[1.0,0.0],"helicity":0,"materialized_current_id":4,"selector_domain_id":23,"spin_state":0},{"chirality":0,"declared_state_index":2,"external_label":3,"factor":[1.0,0.0],"helicity":1,"materialized_current_id":4,"selector_domain_id":24,"spin_state":1}],"strategy":"quotient"},"proof_algorithm":"canonical-source-transition-dependency-shape-v1","proof_counts":{"amplitude_class_count":2,"optimized_amplitude_class_count":2,"optimized_current_count":9,"optimized_recurrence_class_count":3,"physical_helicity_count":12,"recurrence_class_count":7,"residual_amplitude_count":0,"residual_current_count":0,"source_state_mapping_count":7,"structural_zero_helicity_count":6},"recurrence_classes":[{"class_id":"helicity-current-sha256:8c682736c4ae8e56465e5fd7b1c300f8379118af92486f9a571ca3a915572ccf","external_labels":[1],"members":[{"current_id":0,"factor":[1.0,0.0],"selector_domain_id":0}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"8c682736c4ae8e56465e5fd7b1c300f8379118af92486f9a571ca3a915572ccf","status":"proven","transition_contract_ids":[]},"representative_current_id":0,"source_class":true},{"class_id":"helicity-current-sha256:20f4ac2ac00a74044681ff5aab37d2abc31e375d1473e8b0a8198af4432c0ad4","external_labels":[1],"members":[{"current_id":1,"factor":[1.0,0.0],"selector_domain_id":7}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"20f4ac2ac00a74044681ff5aab37d2abc31e375d1473e8b0a8198af4432c0ad4","status":"proven","transition_contract_ids":[]},"representative_current_id":1,"source_class":true},{"class_id":"helicity-current-sha256:099ab31b76e6d55df90ac39798446ac28b3bbca173b59d516940595c4f951ec7","external_labels":[2],"members":[{"current_id":2,"factor":[1.0,0.0],"selector_domain_id":14}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"099ab31b76e6d55df90ac39798446ac28b3bbca173b59d516940595c4f951ec7","status":"proven","transition_contract_ids":[]},"representative_current_id":2,"source_class":true},{"class_id":"helicity-current-sha256:1e587b1494ff92be5c28fa63676222417931b6d82f93eb12232f90e10bc22924","external_labels":[2],"members":[{"current_id":3,"factor":[1.0,0.0],"selector_domain_id":18}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"1e587b1494ff92be5c28fa63676222417931b6d82f93eb12232f90e10bc22924","status":"proven","transition_contract_ids":[]},"representative_current_id":3,"source_class":true},{"class_id":"helicity-current-sha256:e9562e75376f52432b31f6754f778a8f5ab63333f8169428a2bbb50dcee492d0","external_labels":[3],"members":[{"current_id":4,"factor":[1.0,0.0],"selector_domain_id":22},{"current_id":5,"factor":[1.0,0.0],"selector_domain_id":23},{"current_id":6,"factor":[1.0,0.0],"selector_domain_id":24}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"e9562e75376f52432b31f6754f778a8f5ab63333f8169428a2bbb50dcee492d0","status":"proven","transition_contract_ids":[]},"representative_current_id":4,"source_class":true},{"class_id":"helicity-current-sha256:11b0f53aeaf5619f44673e1ac3a81db4742588d5f49c08fa7f514b0556bcada7","external_labels":[2,3],"members":[{"current_id":7,"factor":[1.0,0.0],"selector_domain_id":15},{"current_id":8,"factor":[1.0,0.0],"selector_domain_id":16},{"current_id":9,"factor":[1.0,0.0],"selector_domain_id":17}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"11b0f53aeaf5619f44673e1ac3a81db4742588d5f49c08fa7f514b0556bcada7","status":"proven","transition_contract_ids":["builtin-sm:fermion-vector-to-fermion"]},"representative_current_id":7,"source_class":false},{"class_id":"helicity-current-sha256:7690f565a16395860f30f2971bfea1c77a8db9d3e60d91d4e6b2d2f5549153a8","external_labels":[2,3],"members":[{"current_id":10,"factor":[1.0,0.0],"selector_domain_id":19},{"current_id":11,"factor":[1.0,0.0],"selector_domain_id":20},{"current_id":12,"factor":[1.0,0.0],"selector_domain_id":21}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"7690f565a16395860f30f2971bfea1c77a8db9d3e60d91d4e6b2d2f5549153a8","status":"proven","transition_contract_ids":["builtin-sm:fermion-vector-to-fermion"]},"representative_current_id":10,"source_class":false}],"residual_current_ids":[],"residual_root_ids":[],"selector_domains":[{"complete":false,"id":0,"source_states":[{"external_label":1,"helicity":-1}]},{"complete":true,"id":1,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":-1}]},{"complete":true,"id":2,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":0}]},{"complete":true,"id":3,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":1}]},{"complete":true,"id":4,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":-1}]},{"complete":true,"id":5,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":0}]},{"complete":true,"id":6,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":1}]},{"complete":false,"id":7,"source_states":[{"external_label":1,"helicity":1}]},{"complete":true,"id":8,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":-1}]},{"complete":true,"id":9,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":0}]},{"complete":true,"id":10,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":1}]},{"complete":true,"id":11,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":-1}]},{"complete":true,"id":12,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":0}]},{"complete":true,"id":13,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":1}]},{"complete":false,"id":14,"source_states":[{"external_label":2,"helicity":-1}]},{"complete":false,"id":15,"source_states":[{"external_label":2,"helicity":-1},{"external_label":3,"helicity":-1}]},{"complete":false,"id":16,"source_states":[{"external_label":2,"helicity":-1},{"external_label":3,"helicity":0}]},{"complete":false,"id":17,"source_states":[{"external_label":2,"helicity":-1},{"external_label":3,"helicity":1}]},{"complete":false,"id":18,"source_states":[{"external_label":2,"helicity":1}]},{"complete":false,"id":19,"source_states":[{"external_label":2,"helicity":1},{"external_label":3,"helicity":-1}]},{"complete":false,"id":20,"source_states":[{"external_label":2,"helicity":1},{"external_label":3,"helicity":0}]},{"complete":false,"id":21,"source_states":[{"external_label":2,"helicity":1},{"external_label":3,"helicity":1}]},{"complete":false,"id":22,"source_states":[{"external_label":3,"helicity":-1}]},{"complete":false,"id":23,"source_states":[{"external_label":3,"helicity":0}]},{"complete":false,"id":24,"source_states":[{"external_label":3,"helicity":1}]}],"source_state_mappings":[{"chirality":1,"current_id":0,"declared_state_index":0,"external_label":1,"factor":[1.0,0.0],"helicity":-1,"recurrence_class_id":"helicity-current-sha256:8c682736c4ae8e56465e5fd7b1c300f8379118af92486f9a571ca3a915572ccf","representative_current_id":0,"selector_domain_id":0,"source_contract_digest":"44fa57cb6571ac7524f9e30554d29cf20f6e4fbdfd443edf0afdbc8617c0620e","spin_state":1},{"chirality":-1,"current_id":1,"declared_state_index":1,"external_label":1,"factor":[1.0,0.0],"helicity":1,"recurrence_class_id":"helicity-current-sha256:20f4ac2ac00a74044681ff5aab37d2abc31e375d1473e8b0a8198af4432c0ad4","representative_current_id":1,"selector_domain_id":7,"source_contract_digest":"44fa57cb6571ac7524f9e30554d29cf20f6e4fbdfd443edf0afdbc8617c0620e","spin_state":-1},{"chirality":1,"current_id":2,"declared_state_index":0,"external_label":2,"factor":[1.0,0.0],"helicity":-1,"recurrence_class_id":"helicity-current-sha256:099ab31b76e6d55df90ac39798446ac28b3bbca173b59d516940595c4f951ec7","representative_current_id":2,"selector_domain_id":14,"source_contract_digest":"98b493b16090bfd79101115ca8697310721cebf636cced331f90bcbc32cd9ef6","spin_state":1},{"chirality":-1,"current_id":3,"declared_state_index":1,"external_label":2,"factor":[1.0,0.0],"helicity":1,"recurrence_class_id":"helicity-current-sha256:1e587b1494ff92be5c28fa63676222417931b6d82f93eb12232f90e10bc22924","representative_current_id":3,"selector_domain_id":18,"source_contract_digest":"98b493b16090bfd79101115ca8697310721cebf636cced331f90bcbc32cd9ef6","spin_state":-1},{"chirality":0,"current_id":4,"declared_state_index":0,"external_label":3,"factor":[1.0,0.0],"helicity":-1,"recurrence_class_id":"helicity-current-sha256:e9562e75376f52432b31f6754f778a8f5ab63333f8169428a2bbb50dcee492d0","representative_current_id":4,"selector_domain_id":22,"source_contract_digest":"c2bcedb500cc3f9692e3626cf25b332071eba27ad54025db1ddeaa31e0b57124","spin_state":-1},{"chirality":0,"current_id":5,"declared_state_index":1,"external_label":3,"factor":[1.0,0.0],"helicity":0,"recurrence_class_id":"helicity-current-sha256:e9562e75376f52432b31f6754f778a8f5ab63333f8169428a2bbb50dcee492d0","representative_current_id":4,"selector_domain_id":23,"source_contract_digest":"c2bcedb500cc3f9692e3626cf25b332071eba27ad54025db1ddeaa31e0b57124","spin_state":0},{"chirality":0,"current_id":6,"declared_state_index":2,"external_label":3,"factor":[1.0,0.0],"helicity":1,"recurrence_class_id":"helicity-current-sha256:e9562e75376f52432b31f6754f778a8f5ab63333f8169428a2bbb50dcee492d0","representative_current_id":4,"selector_domain_id":24,"source_contract_digest":"c2bcedb500cc3f9692e3626cf25b332071eba27ad54025db1ddeaa31e0b57124","spin_state":1}],"structural_zero_selector_domain_ids":[1,2,3,11,12,13]},"kind":"generic-dag-stage-blueprint","model_parameter_evaluator":null,"momentum_slot_ids":[],"runtime_available":true,"runtime_unavailable_message":null,"stage_evaluators":{"amplitude_stage":{"blockers":[],"compiled_plane_arena":{"application_abi":"pyamplicol-compiled-plane-kernel-v2","element_layout":"split-complex-component-major","input_bindings":[{"component":0,"global_component":0,"kind":"value","parameter_index":0,"real_valued":false,"source_id":0},{"component":1,"global_component":1,"kind":"value","parameter_index":1,"real_valued":false,"source_id":0},{"component":0,"global_component":2,"kind":"value","parameter_index":2,"real_valued":false,"source_id":1},{"component":1,"global_component":3,"kind":"value","parameter_index":3,"real_valued":false,"source_id":1},{"component":0,"global_component":12,"kind":"value","parameter_index":4,"real_valued":false,"source_id":5},{"component":1,"global_component":13,"kind":"value","parameter_index":5,"real_valued":false,"source_id":5},{"component":0,"global_component":14,"kind":"value","parameter_index":6,"real_valued":false,"source_id":6},{"component":1,"global_component":15,"kind":"value","parameter_index":7,"real_valued":false,"source_id":6}],"input_output_aliasing":"forbidden","kind":"compiled-plane-arena-stage","leaves":[{"application_path":"evaluators/generic_amplitude_stage_chunk_0_4b58da2eb1324c828330d810090ae21f.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[2,3,4,5],"input_len":4,"optimization_level":2,"output_len":1,"output_start":0,"output_stop":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},{"application_path":"evaluators/generic_amplitude_stage_chunk_1_7966f81ea457430fb1873046b2986dab.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[0,1,6,7],"input_len":4,"optimization_level":2,"output_len":1,"output_start":1,"output_stop":2,"source_application_abi":"pyamplicol-symjit-plane-application-v2"}],"output_bindings":[{"arena":"amplitude","component":0,"output_index":0},{"arena":"amplitude","component":1,"output_index":1}],"output_factor":"identity","output_operation":"overwrite","output_output_aliasing":"forbidden","schema_version":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},"evaluator":{"chunk_input_indices":[[2,3,4,5],[0,1,6,7]],"chunks":[{"application_abi":"symjit-application-storage-v3","application_path":"evaluators/generic_amplitude_stage_chunk_0_4b58da2eb1324c828330d810090ae21f.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":4,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":1,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"evaluators/generic_amplitude_stage_chunk_0_4b58da2eb1324c828330d810090ae21f.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":4,"input_plane_count":8,"optimization_level":2,"output_complex_count":1,"output_plane_count":2,"simd":true,"source_digest":"db70c7e9412289ef9f4406c1ffbfe8144dc3c67d5801fbf0342dc26d8f30d6ad","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64},{"application_abi":"symjit-application-storage-v3","application_path":"evaluators/generic_amplitude_stage_chunk_1_7966f81ea457430fb1873046b2986dab.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":4,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":1,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"evaluators/generic_amplitude_stage_chunk_1_7966f81ea457430fb1873046b2986dab.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":4,"input_plane_count":8,"optimization_level":2,"output_complex_count":1,"output_plane_count":2,"simd":true,"source_digest":"db70c7e9412289ef9f4406c1ffbfe8144dc3c67d5801fbf0342dc26d8f30d6ad","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64}],"input_len":8,"kind":"chunked-symbolica-evaluator","required_runtime_capabilities":["symjit.application.complex-f64.v1"]},"evaluator_label":"generic_amplitude_stage","expression_ready":true,"input_components":[{"component":0,"global_component":0,"kind":"value","parameter_index":0,"real_valued":false,"source_id":0},{"component":1,"global_component":1,"kind":"value","parameter_index":1,"real_valued":false,"source_id":0},{"component":0,"global_component":2,"kind":"value","parameter_index":2,"real_valued":false,"source_id":1},{"component":1,"global_component":3,"kind":"value","parameter_index":3,"real_valued":false,"source_id":1},{"component":0,"global_component":12,"kind":"value","parameter_index":4,"real_valued":false,"source_id":5},{"component":1,"global_component":13,"kind":"value","parameter_index":5,"real_valued":false,"source_id":5},{"component":0,"global_component":14,"kind":"value","parameter_index":6,"real_valued":false,"source_id":6},{"component":1,"global_component":15,"kind":"value","parameter_index":7,"real_valued":false,"source_id":6}],"input_value_slot_ids":[0,1,5,6],"interaction_ids":[],"model_parameter_count":0,"momentum_parameter_count":0,"output_length":2,"output_slots":[{"color_selector_domain_ids":[0],"component_start":0,"component_stop":1,"current_id":-1,"output_start":0,"output_stop":1,"value_slot_id":-1,"variant":"amplitude-root"},{"color_selector_domain_ids":[0],"component_start":1,"component_stop":2,"current_id":-1,"output_start":1,"output_stop":2,"value_slot_id":-1,"variant":"amplitude-root"}],"output_value_slot_ids":[],"parameter_count":8,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[],"stage_index":0,"stage_kind":"amplitude-roots","subset_size":null,"value_parameter_count":8},"kind":"generic-dag-stage-evaluator-artifacts","model_parameter_count":0,"momentum_parameter_count":0,"parameter_count":0,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[],"required_runtime_capabilities":["compiled-plane-arena-v1","rusticol.compiled.runtime-selectors.v1","symjit.application.complex-f64.v1"],"runtime_available":true,"runtime_unavailable_message":null,"stage_count":2,"stages":[{"blockers":[],"compiled_plane_arena":{"application_abi":"pyamplicol-compiled-plane-kernel-v2","element_layout":"split-complex-component-major","input_bindings":[{"component":0,"global_component":4,"kind":"value","parameter_index":0,"real_valued":false,"source_id":2},{"component":1,"global_component":5,"kind":"value","parameter_index":1,"real_valued":false,"source_id":2},{"component":0,"global_component":6,"kind":"value","parameter_index":2,"real_valued":false,"source_id":3},{"component":1,"global_component":7,"kind":"value","parameter_index":3,"real_valued":false,"source_id":3},{"component":0,"global_component":8,"kind":"value","parameter_index":4,"real_valued":false,"source_id":4},{"component":1,"global_component":9,"kind":"value","parameter_index":5,"real_valued":false,"source_id":4},{"component":2,"global_component":10,"kind":"value","parameter_index":6,"real_valued":false,"source_id":4},{"component":3,"global_component":11,"kind":"value","parameter_index":7,"real_valued":false,"source_id":4},{"component":0,"global_component":20,"kind":"momentum","parameter_index":8,"real_valued":true,"source_id":1},{"component":1,"global_component":21,"kind":"momentum","parameter_index":9,"real_valued":true,"source_id":1},{"component":2,"global_component":22,"kind":"momentum","parameter_index":10,"real_valued":true,"source_id":1},{"component":3,"global_component":23,"kind":"momentum","parameter_index":11,"real_valued":true,"source_id":1},{"component":0,"global_component":24,"kind":"momentum","parameter_index":12,"real_valued":true,"source_id":2},{"component":1,"global_component":25,"kind":"momentum","parameter_index":13,"real_valued":true,"source_id":2},{"component":2,"global_component":26,"kind":"momentum","parameter_index":14,"real_valued":true,"source_id":2},{"component":3,"global_component":27,"kind":"momentum","parameter_index":15,"real_valued":true,"source_id":2},{"component":0,"global_component":28,"kind":"momentum","parameter_index":16,"real_valued":true,"source_id":3},{"component":1,"global_component":29,"kind":"momentum","parameter_index":17,"real_valued":true,"source_id":3},{"component":2,"global_component":30,"kind":"momentum","parameter_index":18,"real_valued":true,"source_id":3},{"component":3,"global_component":31,"kind":"momentum","parameter_index":19,"real_valued":true,"source_id":3},{"component":0,"global_component":42,"kind":"model_parameter","parameter_index":20,"real_valued":true,"source_id":10},{"component":0,"global_component":43,"kind":"model_parameter","parameter_index":21,"real_valued":true,"source_id":11}],"input_output_aliasing":"forbidden","kind":"compiled-plane-arena-stage","leaves":[{"application_path":"evaluators/generic_stage_1_subset_2_chunk_0_8d246ffe1be84520b5f98a14ab9e364a.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[0,1,4,5,6,7,21],"input_len":7,"optimization_level":2,"output_len":2,"output_start":0,"output_stop":2,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},{"application_path":"evaluators/generic_stage_1_subset_2_chunk_1_8e8022a30237453eb7f2c7dd6c975ba3.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[2,3,4,5,6,7,20],"input_len":7,"optimization_level":2,"output_len":2,"output_start":2,"output_stop":4,"source_application_abi":"pyamplicol-symjit-plane-application-v2"}],"output_bindings":[{"arena":"current","component":12,"output_index":0},{"arena":"current","component":13,"output_index":1},{"arena":"current","component":14,"output_index":2},{"arena":"current","component":15,"output_index":3}],"output_factor":"identity","output_operation":"overwrite","output_output_aliasing":"forbidden","schema_version":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},"evaluator":{"chunk_input_indices":[[0,1,4,5,6,7,21],[2,3,4,5,6,7,20]],"chunks":[{"application_abi":"symjit-application-storage-v3","application_path":"evaluators/generic_stage_1_subset_2_chunk_0_8d246ffe1be84520b5f98a14ab9e364a.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":7,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":2,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"evaluators/generic_stage_1_subset_2_chunk_0_8d246ffe1be84520b5f98a14ab9e364a.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":7,"input_plane_count":14,"optimization_level":2,"output_complex_count":2,"output_plane_count":4,"simd":true,"source_digest":"5da722fc102ba7065505a8107012cda41e3946437b0916057ab4d9768a6a6d88","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64},{"application_abi":"symjit-application-storage-v3","application_path":"evaluators/generic_stage_1_subset_2_chunk_1_8e8022a30237453eb7f2c7dd6c975ba3.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":7,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":2,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"evaluators/generic_stage_1_subset_2_chunk_1_8e8022a30237453eb7f2c7dd6c975ba3.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":7,"input_plane_count":14,"optimization_level":2,"output_complex_count":2,"output_plane_count":4,"simd":true,"source_digest":"ba9446d38ebfa0b7b6afa2f706b096589e98f1b3a4f539b5741d59006d305928","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64}],"input_len":22,"kind":"chunked-symbolica-evaluator","required_runtime_capabilities":["symjit.application.complex-f64.v1"]},"evaluator_label":"generic_stage_1_subset_2","expression_ready":true,"input_components":[{"component":0,"global_component":4,"kind":"value","parameter_index":0,"real_valued":false,"source_id":2},{"component":1,"global_component":5,"kind":"value","parameter_index":1,"real_valued":false,"source_id":2},{"component":0,"global_component":6,"kind":"value","parameter_index":2,"real_valued":false,"source_id":3},{"component":1,"global_component":7,"kind":"value","parameter_index":3,"real_valued":false,"source_id":3},{"component":0,"global_component":8,"kind":"value","parameter_index":4,"real_valued":false,"source_id":4},{"component":1,"global_component":9,"kind":"value","parameter_index":5,"real_valued":false,"source_id":4},{"component":2,"global_component":10,"kind":"value","parameter_index":6,"real_valued":false,"source_id":4},{"component":3,"global_component":11,"kind":"value","parameter_index":7,"real_valued":false,"source_id":4},{"component":0,"global_component":20,"kind":"momentum","parameter_index":8,"real_valued":true,"source_id":1},{"component":1,"global_component":21,"kind":"momentum","parameter_index":9,"real_valued":true,"source_id":1},{"component":2,"global_component":22,"kind":"momentum","parameter_index":10,"real_valued":true,"source_id":1},{"component":3,"global_component":23,"kind":"momentum","parameter_index":11,"real_valued":true,"source_id":1},{"component":0,"global_component":24,"kind":"momentum","parameter_index":12,"real_valued":true,"source_id":2},{"component":1,"global_component":25,"kind":"momentum","parameter_index":13,"real_valued":true,"source_id":2},{"component":2,"global_component":26,"kind":"momentum","parameter_index":14,"real_valued":true,"source_id":2},{"component":3,"global_component":27,"kind":"momentum","parameter_index":15,"real_valued":true,"source_id":2},{"component":0,"global_component":28,"kind":"momentum","parameter_index":16,"real_valued":true,"source_id":3},{"component":1,"global_component":29,"kind":"momentum","parameter_index":17,"real_valued":true,"source_id":3},{"component":2,"global_component":30,"kind":"momentum","parameter_index":18,"real_valued":true,"source_id":3},{"component":3,"global_component":31,"kind":"momentum","parameter_index":19,"real_valued":true,"source_id":3},{"component":0,"global_component":42,"kind":"model_parameter","parameter_index":20,"real_valued":true,"source_id":10},{"component":0,"global_component":43,"kind":"model_parameter","parameter_index":21,"real_valued":true,"source_id":11}],"input_value_slot_ids":[2,3,4],"interaction_ids":[0,1],"model_parameter_count":2,"momentum_parameter_count":12,"output_length":4,"output_slots":[{"color_selector_domain_ids":[0],"component_start":12,"component_stop":14,"current_id":5,"output_start":0,"output_stop":2,"value_slot_id":5,"variant":"unpropagated"},{"color_selector_domain_ids":[0],"component_start":14,"component_stop":16,"current_id":6,"output_start":2,"output_stop":4,"value_slot_id":6,"variant":"unpropagated"}],"output_value_slot_ids":[5,6],"parameter_count":22,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[8,9,10,11,12,13,14,15,16,17,18,19,20,21],"stage_index":1,"stage_kind":"current-combine","subset_size":2,"value_parameter_count":8}],"value_parameter_count":0}},"dag_summary":{"amplitude_root_count":2,"current_count":7,"interaction_count":2,"interaction_evaluation_count":2,"source_count":5,"truncated":false},"external_pdg_order":[1,-1,23],"helicity_selector_executions":[{"execution":{"color_accuracy":"lc","compiled":{"kind":"generic-dag-stage-blueprint","model_parameter_evaluator":null,"momentum_slot_ids":[1,2,3],"runtime_available":true,"runtime_unavailable_message":null,"stage_evaluators":{"amplitude_stage":{"blockers":[],"compiled_plane_arena":{"application_abi":"pyamplicol-compiled-plane-kernel-v2","element_layout":"split-complex-component-major","input_bindings":[{"component":0,"global_component":0,"kind":"value","parameter_index":0,"real_valued":false,"source_id":0},{"component":1,"global_component":1,"kind":"value","parameter_index":1,"real_valued":false,"source_id":0},{"component":0,"global_component":2,"kind":"value","parameter_index":2,"real_valued":false,"source_id":1},{"component":1,"global_component":3,"kind":"value","parameter_index":3,"real_valued":false,"source_id":1},{"component":0,"global_component":12,"kind":"value","parameter_index":4,"real_valued":false,"source_id":5},{"component":1,"global_component":13,"kind":"value","parameter_index":5,"real_valued":false,"source_id":5},{"component":0,"global_component":14,"kind":"value","parameter_index":6,"real_valued":false,"source_id":6},{"component":1,"global_component":15,"kind":"value","parameter_index":7,"real_valued":false,"source_id":6}],"input_output_aliasing":"forbidden","kind":"compiled-plane-arena-stage","leaves":[{"application_path":"helicity-selector-union/class-0/evaluators/generic_amplitude_stage_7c8f49c219a64c318bb490009aa01673.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[0,1,2,3,4,5,6,7],"input_len":8,"optimization_level":2,"output_len":2,"output_start":0,"output_stop":2,"source_application_abi":"pyamplicol-symjit-plane-application-v2"}],"output_bindings":[{"arena":"amplitude","component":0,"output_index":0},{"arena":"amplitude","component":1,"output_index":1}],"output_factor":"identity","output_operation":"overwrite","output_output_aliasing":"forbidden","schema_version":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},"evaluator":{"application_abi":"symjit-application-storage-v3","application_path":"helicity-selector-union/class-0/evaluators/generic_amplitude_stage_7c8f49c219a64c318bb490009aa01673.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":8,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":2,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"helicity-selector-union/class-0/evaluators/generic_amplitude_stage_7c8f49c219a64c318bb490009aa01673.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":8,"input_plane_count":16,"optimization_level":2,"output_complex_count":2,"output_plane_count":4,"simd":true,"source_digest":"993dd48ecd84d24358fd411b0f35d3e5a178608a3dd91199c1c0b8b260cfe3b2","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64},"evaluator_label":"generic_amplitude_stage","expression_ready":true,"input_components":[{"component":0,"global_component":0,"kind":"value","parameter_index":0,"real_valued":false,"source_id":0},{"component":1,"global_component":1,"kind":"value","parameter_index":1,"real_valued":false,"source_id":0},{"component":0,"global_component":2,"kind":"value","parameter_index":2,"real_valued":false,"source_id":1},{"component":1,"global_component":3,"kind":"value","parameter_index":3,"real_valued":false,"source_id":1},{"component":0,"global_component":12,"kind":"value","parameter_index":4,"real_valued":false,"source_id":5},{"component":1,"global_component":13,"kind":"value","parameter_index":5,"real_valued":false,"source_id":5},{"component":0,"global_component":14,"kind":"value","parameter_index":6,"real_valued":false,"source_id":6},{"component":1,"global_component":15,"kind":"value","parameter_index":7,"real_valued":false,"source_id":6}],"input_value_slot_ids":[0,1,5,6],"interaction_ids":[],"model_parameter_count":0,"momentum_parameter_count":0,"output_length":2,"output_slots":[{"component_start":0,"component_stop":1,"current_id":-1,"output_start":0,"output_stop":1,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":1,"component_stop":2,"current_id":-1,"output_start":1,"output_stop":2,"value_slot_id":-1,"variant":"amplitude-root"}],"output_value_slot_ids":[],"parameter_count":8,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[],"stage_index":0,"stage_kind":"amplitude-roots","subset_size":null,"value_parameter_count":8},"kind":"generic-dag-stage-evaluator-artifacts","model_parameter_count":0,"momentum_parameter_count":0,"parameter_count":0,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[],"required_runtime_capabilities":["compiled-plane-arena-v1","symjit.application.complex-f64.v1"],"runtime_available":true,"runtime_unavailable_message":null,"stage_count":2,"stages":[{"blockers":[],"compiled_plane_arena":{"application_abi":"pyamplicol-compiled-plane-kernel-v2","element_layout":"split-complex-component-major","input_bindings":[{"component":0,"global_component":6,"kind":"value","parameter_index":0,"real_valued":false,"source_id":3},{"component":1,"global_component":7,"kind":"value","parameter_index":1,"real_valued":false,"source_id":3},{"component":0,"global_component":8,"kind":"value","parameter_index":2,"real_valued":false,"source_id":4},{"component":1,"global_component":9,"kind":"value","parameter_index":3,"real_valued":false,"source_id":4},{"component":2,"global_component":10,"kind":"value","parameter_index":4,"real_valued":false,"source_id":4},{"component":3,"global_component":11,"kind":"value","parameter_index":5,"real_valued":false,"source_id":4},{"component":0,"global_component":20,"kind":"momentum","parameter_index":6,"real_valued":true,"source_id":1},{"component":1,"global_component":21,"kind":"momentum","parameter_index":7,"real_valued":true,"source_id":1},{"component":2,"global_component":22,"kind":"momentum","parameter_index":8,"real_valued":true,"source_id":1},{"component":3,"global_component":23,"kind":"momentum","parameter_index":9,"real_valued":true,"source_id":1},{"component":0,"global_component":24,"kind":"momentum","parameter_index":10,"real_valued":true,"source_id":2},{"component":1,"global_component":25,"kind":"momentum","parameter_index":11,"real_valued":true,"source_id":2},{"component":2,"global_component":26,"kind":"momentum","parameter_index":12,"real_valued":true,"source_id":2},{"component":3,"global_component":27,"kind":"momentum","parameter_index":13,"real_valued":true,"source_id":2},{"component":0,"global_component":28,"kind":"momentum","parameter_index":14,"real_valued":true,"source_id":3},{"component":1,"global_component":29,"kind":"momentum","parameter_index":15,"real_valued":true,"source_id":3},{"component":2,"global_component":30,"kind":"momentum","parameter_index":16,"real_valued":true,"source_id":3},{"component":3,"global_component":31,"kind":"momentum","parameter_index":17,"real_valued":true,"source_id":3},{"component":0,"global_component":42,"kind":"model_parameter","parameter_index":18,"real_valued":true,"source_id":10},{"component":0,"global_component":43,"kind":"model_parameter","parameter_index":19,"real_valued":true,"source_id":11}],"input_output_aliasing":"forbidden","kind":"compiled-plane-arena-stage","leaves":[{"application_path":"helicity-selector-union/class-0/evaluators/generic_stage_1_subset_2_df25a79e1b6e4b8fa69548b41073407f.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19],"input_len":20,"optimization_level":2,"output_len":2,"output_start":0,"output_stop":2,"source_application_abi":"pyamplicol-symjit-plane-application-v2"}],"output_bindings":[{"arena":"current","component":14,"output_index":0},{"arena":"current","component":15,"output_index":1}],"output_factor":"identity","output_operation":"overwrite","output_output_aliasing":"forbidden","schema_version":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},"evaluator":{"application_abi":"symjit-application-storage-v3","application_path":"helicity-selector-union/class-0/evaluators/generic_stage_1_subset_2_df25a79e1b6e4b8fa69548b41073407f.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":20,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":2,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"helicity-selector-union/class-0/evaluators/generic_stage_1_subset_2_df25a79e1b6e4b8fa69548b41073407f.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":20,"input_plane_count":40,"optimization_level":2,"output_complex_count":2,"output_plane_count":4,"simd":true,"source_digest":"faae1df95ce1f1e47f46e9d3f40c7a2ed45e355dbf85badaee6e990c8e3eeced","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64},"evaluator_label":"generic_stage_1_subset_2","expression_ready":true,"input_components":[{"component":0,"global_component":6,"kind":"value","parameter_index":0,"real_valued":false,"source_id":3},{"component":1,"global_component":7,"kind":"value","parameter_index":1,"real_valued":false,"source_id":3},{"component":0,"global_component":8,"kind":"value","parameter_index":2,"real_valued":false,"source_id":4},{"component":1,"global_component":9,"kind":"value","parameter_index":3,"real_valued":false,"source_id":4},{"component":2,"global_component":10,"kind":"value","parameter_index":4,"real_valued":false,"source_id":4},{"component":3,"global_component":11,"kind":"value","parameter_index":5,"real_valued":false,"source_id":4},{"component":0,"global_component":20,"kind":"momentum","parameter_index":6,"real_valued":true,"source_id":1},{"component":1,"global_component":21,"kind":"momentum","parameter_index":7,"real_valued":true,"source_id":1},{"component":2,"global_component":22,"kind":"momentum","parameter_index":8,"real_valued":true,"source_id":1},{"component":3,"global_component":23,"kind":"momentum","parameter_index":9,"real_valued":true,"source_id":1},{"component":0,"global_component":24,"kind":"momentum","parameter_index":10,"real_valued":true,"source_id":2},{"component":1,"global_component":25,"kind":"momentum","parameter_index":11,"real_valued":true,"source_id":2},{"component":2,"global_component":26,"kind":"momentum","parameter_index":12,"real_valued":true,"source_id":2},{"component":3,"global_component":27,"kind":"momentum","parameter_index":13,"real_valued":true,"source_id":2},{"component":0,"global_component":28,"kind":"momentum","parameter_index":14,"real_valued":true,"source_id":3},{"component":1,"global_component":29,"kind":"momentum","parameter_index":15,"real_valued":true,"source_id":3},{"component":2,"global_component":30,"kind":"momentum","parameter_index":16,"real_valued":true,"source_id":3},{"component":3,"global_component":31,"kind":"momentum","parameter_index":17,"real_valued":true,"source_id":3},{"component":0,"global_component":42,"kind":"model_parameter","parameter_index":18,"real_valued":true,"source_id":10},{"component":0,"global_component":43,"kind":"model_parameter","parameter_index":19,"real_valued":true,"source_id":11}],"input_value_slot_ids":[3,4],"interaction_ids":[1],"model_parameter_count":2,"momentum_parameter_count":12,"output_length":2,"output_slots":[{"component_start":14,"component_stop":16,"current_id":6,"output_start":0,"output_stop":2,"value_slot_id":6,"variant":"unpropagated"}],"output_value_slot_ids":[6],"parameter_count":20,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[6,7,8,9,10,11,12,13,14,15,16,17,18,19],"stage_index":1,"stage_kind":"current-combine","subset_size":2,"value_parameter_count":6}],"value_parameter_count":0}},"dag_summary":{"amplitude_root_count":2,"current_count":7,"interaction_count":1,"interaction_evaluation_count":1,"source_count":5,"truncated":false},"external_pdg_order":[1,-1,23],"key":"d_dbar_to_z","kind":"pyamplicol-runtime-execution","materialization_census":{"abi":"pyamplicol-fully-resident-materialization-census-v1","basis":"immutable-fully-resident-compiled-dag","final":{"amplitude_root_count":2,"current_count":7,"interaction_count":1,"interaction_evaluation_count":1,"source_count":5},"final_equals_peak":true,"peak":{"amplitude_root_count":2,"current_count":7,"interaction_count":1,"interaction_evaluation_count":1,"source_count":5}},"physics_reduction":{"groups":[{"id":"reduction:0","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:+1,-1,-1","h:+1,-1,+0","h:+1,-1,+1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:+1,-1,-1"},{"id":"reduction:1","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:-1,+1,-1","h:-1,+1,+0","h:-1,+1,+1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:-1,+1,-1"}],"kind":"lc-diagonal"},"process":"d d~ > z","required_runtime_capabilities":["compiled-plane-arena-v1","symjit.application.complex-f64.v1"],"runtime_schema":{"amplitude_stage":{"color_contraction":null,"color_topology_replay":null,"output_count":2,"roots":[{"all_sector_weight":1.0,"coherent_group_id":0,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":5,"left_slot":{"component_start":12,"component_stop":14,"current_id":5,"dimension":2},"left_value_slot":{"component_start":12,"component_stop":14,"current_id":5,"dimension":2,"value_slot_id":5,"variant":"unpropagated"},"output_index":0,"right_current_id":1,"right_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2},"right_value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"root_id":0,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":1,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":6,"left_slot":{"component_start":14,"component_stop":16,"current_id":6,"dimension":2},"left_value_slot":{"component_start":14,"component_stop":16,"current_id":6,"dimension":2,"value_slot_id":6,"variant":"unpropagated"},"output_index":1,"right_current_id":0,"right_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2},"right_value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"root_id":1,"vertex_kind":null,"vertex_particles":null}],"stage_kind":"amplitude-roots"},"current_storage":{"component_count":16,"current_slots":[{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"external_labels":[1],"external_mask":1,"flavour_flow":[-1],"helicity_ancestry":"0x1","is_source":true,"momentum_mask":1,"particle_id":-1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"external_labels":[1],"external_mask":1,"flavour_flow":[-1],"helicity_ancestry":"0x2","is_source":true,"momentum_mask":1,"particle_id":-1,"spin_state":-1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":4,"component_stop":6,"current_id":2,"dimension":2,"external_labels":[2],"external_mask":2,"flavour_flow":[1],"helicity_ancestry":"0x4","is_source":true,"momentum_mask":2,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":6,"component_stop":8,"current_id":3,"dimension":2,"external_labels":[2],"external_mask":2,"flavour_flow":[1],"helicity_ancestry":"0x8","is_source":true,"momentum_mask":2,"particle_id":1,"spin_state":-1},{"auxiliary_kind":null,"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"component_start":8,"component_stop":12,"current_id":4,"dimension":4,"external_labels":[3],"external_mask":4,"flavour_flow":[23],"helicity_ancestry":"0x10","is_source":true,"momentum_mask":4,"particle_id":23,"spin_state":-1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":12,"component_stop":14,"current_id":5,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x14","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":14,"component_stop":16,"current_id":6,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x18","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":-1}],"metadata_compacted":true,"number_type":"complex"},"external_particles":[{"index":0,"label":1,"momentum_slot":0,"outgoing_pdg":-1,"pdg":1,"role":"initial"},{"index":1,"label":2,"momentum_slot":1,"outgoing_pdg":1,"pdg":-1,"role":"initial"},{"index":2,"label":3,"momentum_slot":2,"outgoing_pdg":23,"pdg":23,"role":"final"}],"kind":"pyamplicol-runtime-execution-plan","model":{"particles":[{"mass":0.0,"mass_parameter":null,"pdg":1},{"mass":91.188,"mass_parameter":"particle.23.mass","pdg":23}]},"model_parameters":[{"default":0.0075467711139788835,"kind":"normalization","name":"normalization.alpha_ew","parameter_index":0},{"default":0.118,"kind":"normalization","name":"normalization.alpha_s_me_check","parameter_index":1},{"default":173.0,"kind":"particle_mass","name":"particle.6.mass","parameter_index":2,"pdg":6},{"default":1.4915,"kind":"particle_width","name":"particle.6.width","parameter_index":3,"pdg":6},{"default":91.188,"kind":"particle_mass","name":"particle.23.mass","parameter_index":4,"pdg":23},{"default":2.441404,"kind":"particle_width","name":"particle.23.width","parameter_index":5,"pdg":23},{"default":80.41900244575616,"kind":"particle_mass","name":"particle.24.mass","parameter_index":6,"pdg":24},{"default":2.0476,"kind":"particle_width","name":"particle.24.width","parameter_index":7,"pdg":24},{"default":125.0,"kind":"particle_mass","name":"particle.25.mass","parameter_index":8,"pdg":25},{"default":0.006382339,"kind":"particle_width","name":"particle.25.width","parameter_index":9,"pdg":25},{"default":-1.0244420275940371,"kind":"coupling_component","name":"coupling.10.1_23_1.component_0","parameter_index":10},{"default":0.17818666745287456,"kind":"coupling_component","name":"coupling.10.1_23_1.component_1","parameter_index":11}],"momentum_slots":[{"component_start":0,"component_stop":4,"external_labels":[1],"momentum_mask":1,"momentum_slot_id":0,"real_valued":true},{"component_start":4,"component_stop":8,"external_labels":[2],"momentum_mask":2,"momentum_slot_id":1,"real_valued":true},{"component_start":8,"component_stop":12,"external_labels":[3],"momentum_mask":4,"momentum_slot_id":2,"real_valued":true},{"component_start":12,"component_stop":16,"external_labels":[2,3],"momentum_mask":6,"momentum_slot_id":3,"real_valued":true}],"normalization":{"average_factor":36.0,"color_factor":3.0,"electroweak_coupling_power":1,"global_coupling_factor":0.18967104551999775,"identical_factor":1.0,"qcd_coupling_power":0},"parameter_layout":{"model_parameter_count":12,"momentum_components_real":true,"momentum_parameter_count":16,"parameter_count_if_flattened":40,"real_valued_inputs":[12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39],"source_component_parameter_count":12,"source_components_complex":true,"value_component_count":16},"process":"d d~ > z","process_key":"d_dbar_to_z","schema_version":3,"source_fill":{"source_count":5,"sources":[{"anti_particle_id":1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":0,"current_component_stop":2,"current_id":0,"dimension":2,"helicity_ancestry":"0x1","input_momentum_slot":0,"leg_label":1,"outgoing_pdg":-1,"particle_id":-1,"physical_pdg":1,"side":"initial","source_basis":"weyl-chiral","source_helicity":-1,"source_id":0,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"antiparticle","source_parameter_start":0,"source_parameter_stop":2,"spin_state":1,"value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":2,"current_component_stop":4,"current_id":1,"dimension":2,"helicity_ancestry":"0x2","input_momentum_slot":0,"leg_label":1,"outgoing_pdg":-1,"particle_id":-1,"physical_pdg":1,"side":"initial","source_basis":"weyl-chiral","source_helicity":1,"source_id":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"antiparticle","source_parameter_start":2,"source_parameter_stop":4,"spin_state":-1,"value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":-1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":4,"current_component_stop":6,"current_id":2,"dimension":2,"helicity_ancestry":"0x4","input_momentum_slot":1,"leg_label":2,"outgoing_pdg":1,"particle_id":1,"physical_pdg":-1,"side":"initial","source_basis":"weyl-chiral","source_helicity":-1,"source_id":2,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"particle","source_parameter_start":4,"source_parameter_stop":6,"spin_state":1,"value_slot":{"component_start":4,"component_stop":6,"current_id":2,"dimension":2,"value_slot_id":2,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":-1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":6,"current_component_stop":8,"current_id":3,"dimension":2,"helicity_ancestry":"0x8","input_momentum_slot":1,"leg_label":2,"outgoing_pdg":1,"particle_id":1,"physical_pdg":-1,"side":"initial","source_basis":"weyl-chiral","source_helicity":1,"source_id":3,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"particle","source_parameter_start":6,"source_parameter_stop":8,"spin_state":-1,"value_slot":{"component_start":6,"component_stop":8,"current_id":3,"dimension":2,"value_slot_id":3,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":23,"applied_crossing":{"chirality_factor":1,"helicity_factor":1,"momentum_transform":"identity","phase":[1.0,0.0],"spin_state_factor":1},"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"crossing":"identity","current_component_start":8,"current_component_stop":12,"current_id":4,"dimension":4,"helicity_ancestry":"0x10","input_momentum_slot":2,"leg_label":3,"outgoing_pdg":23,"particle_id":23,"physical_pdg":23,"side":"final","source_basis":"lorentz-vector","source_helicity":-1,"source_id":4,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":null,"states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"self-conjugate","source_parameter_start":8,"source_parameter_stop":12,"spin_state":-1,"value_slot":{"component_start":8,"component_stop":12,"current_id":4,"dimension":4,"value_slot_id":4,"variant":"source"},"wavefunction_kind":"vector"}]},"stages":[{"input_current_ids":[3,4],"input_value_slot_ids":[3,4],"interaction_count":1,"interaction_ids":[1],"interactions":[],"interactions_compacted":true,"output_current_ids":[6],"output_value_slot_ids":[6],"stage_index":1,"stage_kind":"current-combine","subset_size":2}],"value_storage":{"component_count":16,"metadata_compacted":true,"number_type":"complex","value_slots":[{"applies_propagator":false,"chirality":1,"component_start":0,"component_stop":2,"current_component_start":0,"current_component_stop":2,"current_id":0,"dimension":2,"external_labels":[1],"external_mask":1,"is_source":true,"momentum_mask":1,"particle_id":-1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":-1,"width_parameter":null},"value_slot_id":0,"variant":"source"},{"applies_propagator":false,"chirality":-1,"component_start":2,"component_stop":4,"current_component_start":2,"current_component_stop":4,"current_id":1,"dimension":2,"external_labels":[1],"external_mask":1,"is_source":true,"momentum_mask":1,"particle_id":-1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":-1,"width_parameter":null},"value_slot_id":1,"variant":"source"},{"applies_propagator":false,"chirality":1,"component_start":4,"component_stop":6,"current_component_start":4,"current_component_stop":6,"current_id":2,"dimension":2,"external_labels":[2],"external_mask":2,"is_source":true,"momentum_mask":2,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":2,"variant":"source"},{"applies_propagator":false,"chirality":-1,"component_start":6,"component_stop":8,"current_component_start":6,"current_component_stop":8,"current_id":3,"dimension":2,"external_labels":[2],"external_mask":2,"is_source":true,"momentum_mask":2,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":3,"variant":"source"},{"applies_propagator":false,"chirality":0,"component_start":8,"component_stop":12,"current_component_start":8,"current_component_stop":12,"current_id":4,"dimension":4,"external_labels":[3],"external_mask":4,"is_source":true,"momentum_mask":4,"particle_id":23,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"symbolica","basis":"lorentz-vector","chirality":0,"custom_source":null,"denominator":"momentum_squared-mass_squared+i*mass*width","description":"massive vector propagator with width","full_tensor_network_ready":true,"gauge":"unitary","goldstone_policy":"absorbed","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"kernel":"massive_vector_unitary_gauge","kind":"vector","mass_class":"massive","mass_parameter":null,"numerator":"-i*(metric-momentum_outer/mass_squared)","particle_id":23,"width_parameter":null},"value_slot_id":4,"variant":"source"},{"applies_propagator":false,"chirality":1,"component_start":12,"component_stop":14,"current_component_start":12,"current_component_stop":14,"current_id":5,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":5,"variant":"unpropagated"},{"applies_propagator":false,"chirality":-1,"component_start":14,"component_stop":16,"current_component_start":14,"current_component_stop":16,"current_id":6,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":6,"variant":"unpropagated"}]}},"schema_version":3},"schedule_mode":"parent-closure","selector_domain_ids":[4,5,6]},{"execution":{"color_accuracy":"lc","compiled":{"kind":"generic-dag-stage-blueprint","model_parameter_evaluator":null,"momentum_slot_ids":[1,2,3],"runtime_available":true,"runtime_unavailable_message":null,"stage_evaluators":{"amplitude_stage":{"blockers":[],"compiled_plane_arena":{"application_abi":"pyamplicol-compiled-plane-kernel-v2","element_layout":"split-complex-component-major","input_bindings":[{"component":0,"global_component":0,"kind":"value","parameter_index":0,"real_valued":false,"source_id":0},{"component":1,"global_component":1,"kind":"value","parameter_index":1,"real_valued":false,"source_id":0},{"component":0,"global_component":2,"kind":"value","parameter_index":2,"real_valued":false,"source_id":1},{"component":1,"global_component":3,"kind":"value","parameter_index":3,"real_valued":false,"source_id":1},{"component":0,"global_component":12,"kind":"value","parameter_index":4,"real_valued":false,"source_id":5},{"component":1,"global_component":13,"kind":"value","parameter_index":5,"real_valued":false,"source_id":5},{"component":0,"global_component":14,"kind":"value","parameter_index":6,"real_valued":false,"source_id":6},{"component":1,"global_component":15,"kind":"value","parameter_index":7,"real_valued":false,"source_id":6}],"input_output_aliasing":"forbidden","kind":"compiled-plane-arena-stage","leaves":[{"application_path":"helicity-selector-union/class-1/evaluators/generic_amplitude_stage_9a660a891f3544c5801ca3482ab26b85.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[0,1,2,3,4,5,6,7],"input_len":8,"optimization_level":2,"output_len":2,"output_start":0,"output_stop":2,"source_application_abi":"pyamplicol-symjit-plane-application-v2"}],"output_bindings":[{"arena":"amplitude","component":0,"output_index":0},{"arena":"amplitude","component":1,"output_index":1}],"output_factor":"identity","output_operation":"overwrite","output_output_aliasing":"forbidden","schema_version":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},"evaluator":{"application_abi":"symjit-application-storage-v3","application_path":"helicity-selector-union/class-1/evaluators/generic_amplitude_stage_9a660a891f3544c5801ca3482ab26b85.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":8,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":2,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"helicity-selector-union/class-1/evaluators/generic_amplitude_stage_9a660a891f3544c5801ca3482ab26b85.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":8,"input_plane_count":16,"optimization_level":2,"output_complex_count":2,"output_plane_count":4,"simd":true,"source_digest":"993dd48ecd84d24358fd411b0f35d3e5a178608a3dd91199c1c0b8b260cfe3b2","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64},"evaluator_label":"generic_amplitude_stage","expression_ready":true,"input_components":[{"component":0,"global_component":0,"kind":"value","parameter_index":0,"real_valued":false,"source_id":0},{"component":1,"global_component":1,"kind":"value","parameter_index":1,"real_valued":false,"source_id":0},{"component":0,"global_component":2,"kind":"value","parameter_index":2,"real_valued":false,"source_id":1},{"component":1,"global_component":3,"kind":"value","parameter_index":3,"real_valued":false,"source_id":1},{"component":0,"global_component":12,"kind":"value","parameter_index":4,"real_valued":false,"source_id":5},{"component":1,"global_component":13,"kind":"value","parameter_index":5,"real_valued":false,"source_id":5},{"component":0,"global_component":14,"kind":"value","parameter_index":6,"real_valued":false,"source_id":6},{"component":1,"global_component":15,"kind":"value","parameter_index":7,"real_valued":false,"source_id":6}],"input_value_slot_ids":[0,1,5,6],"interaction_ids":[],"model_parameter_count":0,"momentum_parameter_count":0,"output_length":2,"output_slots":[{"component_start":0,"component_stop":1,"current_id":-1,"output_start":0,"output_stop":1,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":1,"component_stop":2,"current_id":-1,"output_start":1,"output_stop":2,"value_slot_id":-1,"variant":"amplitude-root"}],"output_value_slot_ids":[],"parameter_count":8,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[],"stage_index":0,"stage_kind":"amplitude-roots","subset_size":null,"value_parameter_count":8},"kind":"generic-dag-stage-evaluator-artifacts","model_parameter_count":0,"momentum_parameter_count":0,"parameter_count":0,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[],"required_runtime_capabilities":["compiled-plane-arena-v1","symjit.application.complex-f64.v1"],"runtime_available":true,"runtime_unavailable_message":null,"stage_count":2,"stages":[{"blockers":[],"compiled_plane_arena":{"application_abi":"pyamplicol-compiled-plane-kernel-v2","element_layout":"split-complex-component-major","input_bindings":[{"component":0,"global_component":4,"kind":"value","parameter_index":0,"real_valued":false,"source_id":2},{"component":1,"global_component":5,"kind":"value","parameter_index":1,"real_valued":false,"source_id":2},{"component":0,"global_component":8,"kind":"value","parameter_index":2,"real_valued":false,"source_id":4},{"component":1,"global_component":9,"kind":"value","parameter_index":3,"real_valued":false,"source_id":4},{"component":2,"global_component":10,"kind":"value","parameter_index":4,"real_valued":false,"source_id":4},{"component":3,"global_component":11,"kind":"value","parameter_index":5,"real_valued":false,"source_id":4},{"component":0,"global_component":20,"kind":"momentum","parameter_index":6,"real_valued":true,"source_id":1},{"component":1,"global_component":21,"kind":"momentum","parameter_index":7,"real_valued":true,"source_id":1},{"component":2,"global_component":22,"kind":"momentum","parameter_index":8,"real_valued":true,"source_id":1},{"component":3,"global_component":23,"kind":"momentum","parameter_index":9,"real_valued":true,"source_id":1},{"component":0,"global_component":24,"kind":"momentum","parameter_index":10,"real_valued":true,"source_id":2},{"component":1,"global_component":25,"kind":"momentum","parameter_index":11,"real_valued":true,"source_id":2},{"component":2,"global_component":26,"kind":"momentum","parameter_index":12,"real_valued":true,"source_id":2},{"component":3,"global_component":27,"kind":"momentum","parameter_index":13,"real_valued":true,"source_id":2},{"component":0,"global_component":28,"kind":"momentum","parameter_index":14,"real_valued":true,"source_id":3},{"component":1,"global_component":29,"kind":"momentum","parameter_index":15,"real_valued":true,"source_id":3},{"component":2,"global_component":30,"kind":"momentum","parameter_index":16,"real_valued":true,"source_id":3},{"component":3,"global_component":31,"kind":"momentum","parameter_index":17,"real_valued":true,"source_id":3},{"component":0,"global_component":42,"kind":"model_parameter","parameter_index":18,"real_valued":true,"source_id":10},{"component":0,"global_component":43,"kind":"model_parameter","parameter_index":19,"real_valued":true,"source_id":11}],"input_output_aliasing":"forbidden","kind":"compiled-plane-arena-stage","leaves":[{"application_path":"helicity-selector-union/class-1/evaluators/generic_stage_1_subset_2_aefbc6d0a5894adebc89d2966b0453b1.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19],"input_len":20,"optimization_level":2,"output_len":2,"output_start":0,"output_stop":2,"source_application_abi":"pyamplicol-symjit-plane-application-v2"}],"output_bindings":[{"arena":"current","component":12,"output_index":0},{"arena":"current","component":13,"output_index":1}],"output_factor":"identity","output_operation":"overwrite","output_output_aliasing":"forbidden","schema_version":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},"evaluator":{"application_abi":"symjit-application-storage-v3","application_path":"helicity-selector-union/class-1/evaluators/generic_stage_1_subset_2_aefbc6d0a5894adebc89d2966b0453b1.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":20,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":2,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"helicity-selector-union/class-1/evaluators/generic_stage_1_subset_2_aefbc6d0a5894adebc89d2966b0453b1.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":20,"input_plane_count":40,"optimization_level":2,"output_complex_count":2,"output_plane_count":4,"simd":true,"source_digest":"fb2be831a91ef913681e7f1084e98149caaa2ccf4ce35813ec5ce1b9c3280d49","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64},"evaluator_label":"generic_stage_1_subset_2","expression_ready":true,"input_components":[{"component":0,"global_component":4,"kind":"value","parameter_index":0,"real_valued":false,"source_id":2},{"component":1,"global_component":5,"kind":"value","parameter_index":1,"real_valued":false,"source_id":2},{"component":0,"global_component":8,"kind":"value","parameter_index":2,"real_valued":false,"source_id":4},{"component":1,"global_component":9,"kind":"value","parameter_index":3,"real_valued":false,"source_id":4},{"component":2,"global_component":10,"kind":"value","parameter_index":4,"real_valued":false,"source_id":4},{"component":3,"global_component":11,"kind":"value","parameter_index":5,"real_valued":false,"source_id":4},{"component":0,"global_component":20,"kind":"momentum","parameter_index":6,"real_valued":true,"source_id":1},{"component":1,"global_component":21,"kind":"momentum","parameter_index":7,"real_valued":true,"source_id":1},{"component":2,"global_component":22,"kind":"momentum","parameter_index":8,"real_valued":true,"source_id":1},{"component":3,"global_component":23,"kind":"momentum","parameter_index":9,"real_valued":true,"source_id":1},{"component":0,"global_component":24,"kind":"momentum","parameter_index":10,"real_valued":true,"source_id":2},{"component":1,"global_component":25,"kind":"momentum","parameter_index":11,"real_valued":true,"source_id":2},{"component":2,"global_component":26,"kind":"momentum","parameter_index":12,"real_valued":true,"source_id":2},{"component":3,"global_component":27,"kind":"momentum","parameter_index":13,"real_valued":true,"source_id":2},{"component":0,"global_component":28,"kind":"momentum","parameter_index":14,"real_valued":true,"source_id":3},{"component":1,"global_component":29,"kind":"momentum","parameter_index":15,"real_valued":true,"source_id":3},{"component":2,"global_component":30,"kind":"momentum","parameter_index":16,"real_valued":true,"source_id":3},{"component":3,"global_component":31,"kind":"momentum","parameter_index":17,"real_valued":true,"source_id":3},{"component":0,"global_component":42,"kind":"model_parameter","parameter_index":18,"real_valued":true,"source_id":10},{"component":0,"global_component":43,"kind":"model_parameter","parameter_index":19,"real_valued":true,"source_id":11}],"input_value_slot_ids":[2,4],"interaction_ids":[0],"model_parameter_count":2,"momentum_parameter_count":12,"output_length":2,"output_slots":[{"component_start":12,"component_stop":14,"current_id":5,"output_start":0,"output_stop":2,"value_slot_id":5,"variant":"unpropagated"}],"output_value_slot_ids":[5],"parameter_count":20,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[6,7,8,9,10,11,12,13,14,15,16,17,18,19],"stage_index":1,"stage_kind":"current-combine","subset_size":2,"value_parameter_count":6}],"value_parameter_count":0}},"dag_summary":{"amplitude_root_count":2,"current_count":7,"interaction_count":1,"interaction_evaluation_count":1,"source_count":5,"truncated":false},"external_pdg_order":[1,-1,23],"key":"d_dbar_to_z","kind":"pyamplicol-runtime-execution","materialization_census":{"abi":"pyamplicol-fully-resident-materialization-census-v1","basis":"immutable-fully-resident-compiled-dag","final":{"amplitude_root_count":2,"current_count":7,"interaction_count":1,"interaction_evaluation_count":1,"source_count":5},"final_equals_peak":true,"peak":{"amplitude_root_count":2,"current_count":7,"interaction_count":1,"interaction_evaluation_count":1,"source_count":5}},"physics_reduction":{"groups":[{"id":"reduction:0","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:+1,-1,-1","h:+1,-1,+0","h:+1,-1,+1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:+1,-1,-1"},{"id":"reduction:1","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:-1,+1,-1","h:-1,+1,+0","h:-1,+1,+1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:-1,+1,-1"}],"kind":"lc-diagonal"},"process":"d d~ > z","required_runtime_capabilities":["compiled-plane-arena-v1","symjit.application.complex-f64.v1"],"runtime_schema":{"amplitude_stage":{"color_contraction":null,"color_topology_replay":null,"output_count":2,"roots":[{"all_sector_weight":1.0,"coherent_group_id":0,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":5,"left_slot":{"component_start":12,"component_stop":14,"current_id":5,"dimension":2},"left_value_slot":{"component_start":12,"component_stop":14,"current_id":5,"dimension":2,"value_slot_id":5,"variant":"unpropagated"},"output_index":0,"right_current_id":1,"right_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2},"right_value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"root_id":0,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":1,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":6,"left_slot":{"component_start":14,"component_stop":16,"current_id":6,"dimension":2},"left_value_slot":{"component_start":14,"component_stop":16,"current_id":6,"dimension":2,"value_slot_id":6,"variant":"unpropagated"},"output_index":1,"right_current_id":0,"right_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2},"right_value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"root_id":1,"vertex_kind":null,"vertex_particles":null}],"stage_kind":"amplitude-roots"},"current_storage":{"component_count":16,"current_slots":[{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"external_labels":[1],"external_mask":1,"flavour_flow":[-1],"helicity_ancestry":"0x1","is_source":true,"momentum_mask":1,"particle_id":-1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"external_labels":[1],"external_mask":1,"flavour_flow":[-1],"helicity_ancestry":"0x2","is_source":true,"momentum_mask":1,"particle_id":-1,"spin_state":-1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":4,"component_stop":6,"current_id":2,"dimension":2,"external_labels":[2],"external_mask":2,"flavour_flow":[1],"helicity_ancestry":"0x4","is_source":true,"momentum_mask":2,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":6,"component_stop":8,"current_id":3,"dimension":2,"external_labels":[2],"external_mask":2,"flavour_flow":[1],"helicity_ancestry":"0x8","is_source":true,"momentum_mask":2,"particle_id":1,"spin_state":-1},{"auxiliary_kind":null,"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"component_start":8,"component_stop":12,"current_id":4,"dimension":4,"external_labels":[3],"external_mask":4,"flavour_flow":[23],"helicity_ancestry":"0x10","is_source":true,"momentum_mask":4,"particle_id":23,"spin_state":-1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":12,"component_stop":14,"current_id":5,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x14","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":14,"component_stop":16,"current_id":6,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x18","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":-1}],"metadata_compacted":true,"number_type":"complex"},"external_particles":[{"index":0,"label":1,"momentum_slot":0,"outgoing_pdg":-1,"pdg":1,"role":"initial"},{"index":1,"label":2,"momentum_slot":1,"outgoing_pdg":1,"pdg":-1,"role":"initial"},{"index":2,"label":3,"momentum_slot":2,"outgoing_pdg":23,"pdg":23,"role":"final"}],"kind":"pyamplicol-runtime-execution-plan","model":{"particles":[{"mass":0.0,"mass_parameter":null,"pdg":1},{"mass":91.188,"mass_parameter":"particle.23.mass","pdg":23}]},"model_parameters":[{"default":0.0075467711139788835,"kind":"normalization","name":"normalization.alpha_ew","parameter_index":0},{"default":0.118,"kind":"normalization","name":"normalization.alpha_s_me_check","parameter_index":1},{"default":173.0,"kind":"particle_mass","name":"particle.6.mass","parameter_index":2,"pdg":6},{"default":1.4915,"kind":"particle_width","name":"particle.6.width","parameter_index":3,"pdg":6},{"default":91.188,"kind":"particle_mass","name":"particle.23.mass","parameter_index":4,"pdg":23},{"default":2.441404,"kind":"particle_width","name":"particle.23.width","parameter_index":5,"pdg":23},{"default":80.41900244575616,"kind":"particle_mass","name":"particle.24.mass","parameter_index":6,"pdg":24},{"default":2.0476,"kind":"particle_width","name":"particle.24.width","parameter_index":7,"pdg":24},{"default":125.0,"kind":"particle_mass","name":"particle.25.mass","parameter_index":8,"pdg":25},{"default":0.006382339,"kind":"particle_width","name":"particle.25.width","parameter_index":9,"pdg":25},{"default":-1.0244420275940371,"kind":"coupling_component","name":"coupling.10.1_23_1.component_0","parameter_index":10},{"default":0.17818666745287456,"kind":"coupling_component","name":"coupling.10.1_23_1.component_1","parameter_index":11}],"momentum_slots":[{"component_start":0,"component_stop":4,"external_labels":[1],"momentum_mask":1,"momentum_slot_id":0,"real_valued":true},{"component_start":4,"component_stop":8,"external_labels":[2],"momentum_mask":2,"momentum_slot_id":1,"real_valued":true},{"component_start":8,"component_stop":12,"external_labels":[3],"momentum_mask":4,"momentum_slot_id":2,"real_valued":true},{"component_start":12,"component_stop":16,"external_labels":[2,3],"momentum_mask":6,"momentum_slot_id":3,"real_valued":true}],"normalization":{"average_factor":36.0,"color_factor":3.0,"electroweak_coupling_power":1,"global_coupling_factor":0.18967104551999775,"identical_factor":1.0,"qcd_coupling_power":0},"parameter_layout":{"model_parameter_count":12,"momentum_components_real":true,"momentum_parameter_count":16,"parameter_count_if_flattened":40,"real_valued_inputs":[12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39],"source_component_parameter_count":12,"source_components_complex":true,"value_component_count":16},"process":"d d~ > z","process_key":"d_dbar_to_z","schema_version":3,"source_fill":{"source_count":5,"sources":[{"anti_particle_id":1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":0,"current_component_stop":2,"current_id":0,"dimension":2,"helicity_ancestry":"0x1","input_momentum_slot":0,"leg_label":1,"outgoing_pdg":-1,"particle_id":-1,"physical_pdg":1,"side":"initial","source_basis":"weyl-chiral","source_helicity":-1,"source_id":0,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"antiparticle","source_parameter_start":0,"source_parameter_stop":2,"spin_state":1,"value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":2,"current_component_stop":4,"current_id":1,"dimension":2,"helicity_ancestry":"0x2","input_momentum_slot":0,"leg_label":1,"outgoing_pdg":-1,"particle_id":-1,"physical_pdg":1,"side":"initial","source_basis":"weyl-chiral","source_helicity":1,"source_id":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"antiparticle","source_parameter_start":2,"source_parameter_stop":4,"spin_state":-1,"value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":-1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":4,"current_component_stop":6,"current_id":2,"dimension":2,"helicity_ancestry":"0x4","input_momentum_slot":1,"leg_label":2,"outgoing_pdg":1,"particle_id":1,"physical_pdg":-1,"side":"initial","source_basis":"weyl-chiral","source_helicity":-1,"source_id":2,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"particle","source_parameter_start":4,"source_parameter_stop":6,"spin_state":1,"value_slot":{"component_start":4,"component_stop":6,"current_id":2,"dimension":2,"value_slot_id":2,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":-1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":6,"current_component_stop":8,"current_id":3,"dimension":2,"helicity_ancestry":"0x8","input_momentum_slot":1,"leg_label":2,"outgoing_pdg":1,"particle_id":1,"physical_pdg":-1,"side":"initial","source_basis":"weyl-chiral","source_helicity":1,"source_id":3,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"particle","source_parameter_start":6,"source_parameter_stop":8,"spin_state":-1,"value_slot":{"component_start":6,"component_stop":8,"current_id":3,"dimension":2,"value_slot_id":3,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":23,"applied_crossing":{"chirality_factor":1,"helicity_factor":1,"momentum_transform":"identity","phase":[1.0,0.0],"spin_state_factor":1},"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"crossing":"identity","current_component_start":8,"current_component_stop":12,"current_id":4,"dimension":4,"helicity_ancestry":"0x10","input_momentum_slot":2,"leg_label":3,"outgoing_pdg":23,"particle_id":23,"physical_pdg":23,"side":"final","source_basis":"lorentz-vector","source_helicity":-1,"source_id":4,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":null,"states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"self-conjugate","source_parameter_start":8,"source_parameter_stop":12,"spin_state":-1,"value_slot":{"component_start":8,"component_stop":12,"current_id":4,"dimension":4,"value_slot_id":4,"variant":"source"},"wavefunction_kind":"vector"}]},"stages":[{"input_current_ids":[2,4],"input_value_slot_ids":[2,4],"interaction_count":1,"interaction_ids":[0],"interactions":[],"interactions_compacted":true,"output_current_ids":[5],"output_value_slot_ids":[5],"stage_index":1,"stage_kind":"current-combine","subset_size":2}],"value_storage":{"component_count":16,"metadata_compacted":true,"number_type":"complex","value_slots":[{"applies_propagator":false,"chirality":1,"component_start":0,"component_stop":2,"current_component_start":0,"current_component_stop":2,"current_id":0,"dimension":2,"external_labels":[1],"external_mask":1,"is_source":true,"momentum_mask":1,"particle_id":-1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":-1,"width_parameter":null},"value_slot_id":0,"variant":"source"},{"applies_propagator":false,"chirality":-1,"component_start":2,"component_stop":4,"current_component_start":2,"current_component_stop":4,"current_id":1,"dimension":2,"external_labels":[1],"external_mask":1,"is_source":true,"momentum_mask":1,"particle_id":-1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":-1,"width_parameter":null},"value_slot_id":1,"variant":"source"},{"applies_propagator":false,"chirality":1,"component_start":4,"component_stop":6,"current_component_start":4,"current_component_stop":6,"current_id":2,"dimension":2,"external_labels":[2],"external_mask":2,"is_source":true,"momentum_mask":2,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":2,"variant":"source"},{"applies_propagator":false,"chirality":-1,"component_start":6,"component_stop":8,"current_component_start":6,"current_component_stop":8,"current_id":3,"dimension":2,"external_labels":[2],"external_mask":2,"is_source":true,"momentum_mask":2,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":3,"variant":"source"},{"applies_propagator":false,"chirality":0,"component_start":8,"component_stop":12,"current_component_start":8,"current_component_stop":12,"current_id":4,"dimension":4,"external_labels":[3],"external_mask":4,"is_source":true,"momentum_mask":4,"particle_id":23,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"symbolica","basis":"lorentz-vector","chirality":0,"custom_source":null,"denominator":"momentum_squared-mass_squared+i*mass*width","description":"massive vector propagator with width","full_tensor_network_ready":true,"gauge":"unitary","goldstone_policy":"absorbed","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"kernel":"massive_vector_unitary_gauge","kind":"vector","mass_class":"massive","mass_parameter":null,"numerator":"-i*(metric-momentum_outer/mass_squared)","particle_id":23,"width_parameter":null},"value_slot_id":4,"variant":"source"},{"applies_propagator":false,"chirality":1,"component_start":12,"component_stop":14,"current_component_start":12,"current_component_stop":14,"current_id":5,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":5,"variant":"unpropagated"},{"applies_propagator":false,"chirality":-1,"component_start":14,"component_stop":16,"current_component_start":14,"current_component_stop":16,"current_id":6,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":6,"variant":"unpropagated"}]}},"schema_version":3},"schedule_mode":"parent-closure","selector_domain_ids":[8,9,10]}],"helicity_sum_execution":{"color_accuracy":"lc","color_selector_executions":[{"execution":{"color_accuracy":"lc","compiled":{"kind":"generic-dag-stage-blueprint","model_parameter_evaluator":null,"momentum_slot_ids":[1,2,3],"runtime_available":true,"runtime_unavailable_message":null,"stage_evaluators":{"amplitude_stage":{"blockers":[],"compiled_plane_arena":{"application_abi":"pyamplicol-compiled-plane-kernel-v2","element_layout":"split-complex-component-major","input_bindings":[{"component":0,"global_component":0,"kind":"value","parameter_index":0,"real_valued":false,"source_id":0},{"component":1,"global_component":1,"kind":"value","parameter_index":1,"real_valued":false,"source_id":0},{"component":0,"global_component":2,"kind":"value","parameter_index":2,"real_valued":false,"source_id":1},{"component":1,"global_component":3,"kind":"value","parameter_index":3,"real_valued":false,"source_id":1},{"component":0,"global_component":20,"kind":"value","parameter_index":4,"real_valued":false,"source_id":7},{"component":1,"global_component":21,"kind":"value","parameter_index":5,"real_valued":false,"source_id":7},{"component":0,"global_component":22,"kind":"value","parameter_index":6,"real_valued":false,"source_id":8},{"component":1,"global_component":23,"kind":"value","parameter_index":7,"real_valued":false,"source_id":8},{"component":0,"global_component":24,"kind":"value","parameter_index":8,"real_valued":false,"source_id":9},{"component":1,"global_component":25,"kind":"value","parameter_index":9,"real_valued":false,"source_id":9},{"component":0,"global_component":26,"kind":"value","parameter_index":10,"real_valued":false,"source_id":10},{"component":1,"global_component":27,"kind":"value","parameter_index":11,"real_valued":false,"source_id":10},{"component":0,"global_component":28,"kind":"value","parameter_index":12,"real_valued":false,"source_id":11},{"component":1,"global_component":29,"kind":"value","parameter_index":13,"real_valued":false,"source_id":11},{"component":0,"global_component":30,"kind":"value","parameter_index":14,"real_valued":false,"source_id":12},{"component":1,"global_component":31,"kind":"value","parameter_index":15,"real_valued":false,"source_id":12}],"input_output_aliasing":"forbidden","kind":"compiled-plane-arena-stage","leaves":[{"application_path":"helicity-sum/color-selector/sector-0/evaluators/generic_amplitude_stage_d16d6a1bc14b4523b1ef68089829af31.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],"input_len":16,"optimization_level":2,"output_len":6,"output_start":0,"output_stop":6,"source_application_abi":"pyamplicol-symjit-plane-application-v2"}],"output_bindings":[{"arena":"amplitude","component":0,"output_index":0},{"arena":"amplitude","component":1,"output_index":1},{"arena":"amplitude","component":2,"output_index":2},{"arena":"amplitude","component":3,"output_index":3},{"arena":"amplitude","component":4,"output_index":4},{"arena":"amplitude","component":5,"output_index":5}],"output_factor":"identity","output_operation":"overwrite","output_output_aliasing":"forbidden","schema_version":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},"evaluator":{"application_abi":"symjit-application-storage-v3","application_path":"helicity-sum/color-selector/sector-0/evaluators/generic_amplitude_stage_d16d6a1bc14b4523b1ef68089829af31.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":16,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":6,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"helicity-sum/color-selector/sector-0/evaluators/generic_amplitude_stage_d16d6a1bc14b4523b1ef68089829af31.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":16,"input_plane_count":32,"optimization_level":2,"output_complex_count":6,"output_plane_count":12,"simd":true,"source_digest":"2a37e3f222d3a34a70cc55f8517b6823d0c17e6efad8f06f75e39ed367d6e6b1","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64},"evaluator_label":"generic_amplitude_stage","expression_ready":true,"input_components":[{"component":0,"global_component":0,"kind":"value","parameter_index":0,"real_valued":false,"source_id":0},{"component":1,"global_component":1,"kind":"value","parameter_index":1,"real_valued":false,"source_id":0},{"component":0,"global_component":2,"kind":"value","parameter_index":2,"real_valued":false,"source_id":1},{"component":1,"global_component":3,"kind":"value","parameter_index":3,"real_valued":false,"source_id":1},{"component":0,"global_component":20,"kind":"value","parameter_index":4,"real_valued":false,"source_id":7},{"component":1,"global_component":21,"kind":"value","parameter_index":5,"real_valued":false,"source_id":7},{"component":0,"global_component":22,"kind":"value","parameter_index":6,"real_valued":false,"source_id":8},{"component":1,"global_component":23,"kind":"value","parameter_index":7,"real_valued":false,"source_id":8},{"component":0,"global_component":24,"kind":"value","parameter_index":8,"real_valued":false,"source_id":9},{"component":1,"global_component":25,"kind":"value","parameter_index":9,"real_valued":false,"source_id":9},{"component":0,"global_component":26,"kind":"value","parameter_index":10,"real_valued":false,"source_id":10},{"component":1,"global_component":27,"kind":"value","parameter_index":11,"real_valued":false,"source_id":10},{"component":0,"global_component":28,"kind":"value","parameter_index":12,"real_valued":false,"source_id":11},{"component":1,"global_component":29,"kind":"value","parameter_index":13,"real_valued":false,"source_id":11},{"component":0,"global_component":30,"kind":"value","parameter_index":14,"real_valued":false,"source_id":12},{"component":1,"global_component":31,"kind":"value","parameter_index":15,"real_valued":false,"source_id":12}],"input_value_slot_ids":[0,1,7,8,9,10,11,12],"interaction_ids":[],"model_parameter_count":0,"momentum_parameter_count":0,"output_length":6,"output_slots":[{"component_start":0,"component_stop":1,"current_id":-1,"output_start":0,"output_stop":1,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":1,"component_stop":2,"current_id":-1,"output_start":1,"output_stop":2,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":2,"component_stop":3,"current_id":-1,"output_start":2,"output_stop":3,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":3,"component_stop":4,"current_id":-1,"output_start":3,"output_stop":4,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":4,"component_stop":5,"current_id":-1,"output_start":4,"output_stop":5,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":5,"component_stop":6,"current_id":-1,"output_start":5,"output_stop":6,"value_slot_id":-1,"variant":"amplitude-root"}],"output_value_slot_ids":[],"parameter_count":16,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[],"stage_index":0,"stage_kind":"amplitude-roots","subset_size":null,"value_parameter_count":16},"kind":"generic-dag-stage-evaluator-artifacts","model_parameter_count":0,"momentum_parameter_count":0,"parameter_count":0,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[],"required_runtime_capabilities":["compiled-plane-arena-v1","symjit.application.complex-f64.v1"],"runtime_available":true,"runtime_unavailable_message":null,"stage_count":2,"stages":[{"blockers":[],"compiled_plane_arena":{"application_abi":"pyamplicol-compiled-plane-kernel-v2","element_layout":"split-complex-component-major","input_bindings":[{"component":0,"global_component":4,"kind":"value","parameter_index":0,"real_valued":false,"source_id":2},{"component":1,"global_component":5,"kind":"value","parameter_index":1,"real_valued":false,"source_id":2},{"component":0,"global_component":6,"kind":"value","parameter_index":2,"real_valued":false,"source_id":3},{"component":1,"global_component":7,"kind":"value","parameter_index":3,"real_valued":false,"source_id":3},{"component":0,"global_component":8,"kind":"value","parameter_index":4,"real_valued":false,"source_id":4},{"component":1,"global_component":9,"kind":"value","parameter_index":5,"real_valued":false,"source_id":4},{"component":2,"global_component":10,"kind":"value","parameter_index":6,"real_valued":false,"source_id":4},{"component":3,"global_component":11,"kind":"value","parameter_index":7,"real_valued":false,"source_id":4},{"component":0,"global_component":12,"kind":"value","parameter_index":8,"real_valued":false,"source_id":5},{"component":1,"global_component":13,"kind":"value","parameter_index":9,"real_valued":false,"source_id":5},{"component":2,"global_component":14,"kind":"value","parameter_index":10,"real_valued":false,"source_id":5},{"component":3,"global_component":15,"kind":"value","parameter_index":11,"real_valued":false,"source_id":5},{"component":0,"global_component":16,"kind":"value","parameter_index":12,"real_valued":false,"source_id":6},{"component":1,"global_component":17,"kind":"value","parameter_index":13,"real_valued":false,"source_id":6},{"component":2,"global_component":18,"kind":"value","parameter_index":14,"real_valued":false,"source_id":6},{"component":3,"global_component":19,"kind":"value","parameter_index":15,"real_valued":false,"source_id":6},{"component":0,"global_component":36,"kind":"momentum","parameter_index":16,"real_valued":true,"source_id":1},{"component":1,"global_component":37,"kind":"momentum","parameter_index":17,"real_valued":true,"source_id":1},{"component":2,"global_component":38,"kind":"momentum","parameter_index":18,"real_valued":true,"source_id":1},{"component":3,"global_component":39,"kind":"momentum","parameter_index":19,"real_valued":true,"source_id":1},{"component":0,"global_component":40,"kind":"momentum","parameter_index":20,"real_valued":true,"source_id":2},{"component":1,"global_component":41,"kind":"momentum","parameter_index":21,"real_valued":true,"source_id":2},{"component":2,"global_component":42,"kind":"momentum","parameter_index":22,"real_valued":true,"source_id":2},{"component":3,"global_component":43,"kind":"momentum","parameter_index":23,"real_valued":true,"source_id":2},{"component":0,"global_component":44,"kind":"momentum","parameter_index":24,"real_valued":true,"source_id":3},{"component":1,"global_component":45,"kind":"momentum","parameter_index":25,"real_valued":true,"source_id":3},{"component":2,"global_component":46,"kind":"momentum","parameter_index":26,"real_valued":true,"source_id":3},{"component":3,"global_component":47,"kind":"momentum","parameter_index":27,"real_valued":true,"source_id":3},{"component":0,"global_component":58,"kind":"model_parameter","parameter_index":28,"real_valued":true,"source_id":10},{"component":0,"global_component":59,"kind":"model_parameter","parameter_index":29,"real_valued":true,"source_id":11}],"input_output_aliasing":"forbidden","kind":"compiled-plane-arena-stage","leaves":[{"application_path":"helicity-sum/color-selector/sector-0/evaluators/generic_stage_1_subset_2_bbc3a3ebdb2248798889aa13eafb5e51.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29],"input_len":30,"optimization_level":2,"output_len":12,"output_start":0,"output_stop":12,"source_application_abi":"pyamplicol-symjit-plane-application-v2"}],"output_bindings":[{"arena":"current","component":20,"output_index":0},{"arena":"current","component":21,"output_index":1},{"arena":"current","component":22,"output_index":2},{"arena":"current","component":23,"output_index":3},{"arena":"current","component":24,"output_index":4},{"arena":"current","component":25,"output_index":5},{"arena":"current","component":26,"output_index":6},{"arena":"current","component":27,"output_index":7},{"arena":"current","component":28,"output_index":8},{"arena":"current","component":29,"output_index":9},{"arena":"current","component":30,"output_index":10},{"arena":"current","component":31,"output_index":11}],"output_factor":"identity","output_operation":"overwrite","output_output_aliasing":"forbidden","schema_version":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},"evaluator":{"application_abi":"symjit-application-storage-v3","application_path":"helicity-sum/color-selector/sector-0/evaluators/generic_stage_1_subset_2_bbc3a3ebdb2248798889aa13eafb5e51.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":30,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":12,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"helicity-sum/color-selector/sector-0/evaluators/generic_stage_1_subset_2_bbc3a3ebdb2248798889aa13eafb5e51.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":30,"input_plane_count":60,"optimization_level":2,"output_complex_count":12,"output_plane_count":24,"simd":true,"source_digest":"932205a6edcc3a03c036ff3ac62bcbb2189b3471d544fffa5d82f5a25033b0c2","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64},"evaluator_label":"generic_stage_1_subset_2","expression_ready":true,"input_components":[{"component":0,"global_component":4,"kind":"value","parameter_index":0,"real_valued":false,"source_id":2},{"component":1,"global_component":5,"kind":"value","parameter_index":1,"real_valued":false,"source_id":2},{"component":0,"global_component":6,"kind":"value","parameter_index":2,"real_valued":false,"source_id":3},{"component":1,"global_component":7,"kind":"value","parameter_index":3,"real_valued":false,"source_id":3},{"component":0,"global_component":8,"kind":"value","parameter_index":4,"real_valued":false,"source_id":4},{"component":1,"global_component":9,"kind":"value","parameter_index":5,"real_valued":false,"source_id":4},{"component":2,"global_component":10,"kind":"value","parameter_index":6,"real_valued":false,"source_id":4},{"component":3,"global_component":11,"kind":"value","parameter_index":7,"real_valued":false,"source_id":4},{"component":0,"global_component":12,"kind":"value","parameter_index":8,"real_valued":false,"source_id":5},{"component":1,"global_component":13,"kind":"value","parameter_index":9,"real_valued":false,"source_id":5},{"component":2,"global_component":14,"kind":"value","parameter_index":10,"real_valued":false,"source_id":5},{"component":3,"global_component":15,"kind":"value","parameter_index":11,"real_valued":false,"source_id":5},{"component":0,"global_component":16,"kind":"value","parameter_index":12,"real_valued":false,"source_id":6},{"component":1,"global_component":17,"kind":"value","parameter_index":13,"real_valued":false,"source_id":6},{"component":2,"global_component":18,"kind":"value","parameter_index":14,"real_valued":false,"source_id":6},{"component":3,"global_component":19,"kind":"value","parameter_index":15,"real_valued":false,"source_id":6},{"component":0,"global_component":36,"kind":"momentum","parameter_index":16,"real_valued":true,"source_id":1},{"component":1,"global_component":37,"kind":"momentum","parameter_index":17,"real_valued":true,"source_id":1},{"component":2,"global_component":38,"kind":"momentum","parameter_index":18,"real_valued":true,"source_id":1},{"component":3,"global_component":39,"kind":"momentum","parameter_index":19,"real_valued":true,"source_id":1},{"component":0,"global_component":40,"kind":"momentum","parameter_index":20,"real_valued":true,"source_id":2},{"component":1,"global_component":41,"kind":"momentum","parameter_index":21,"real_valued":true,"source_id":2},{"component":2,"global_component":42,"kind":"momentum","parameter_index":22,"real_valued":true,"source_id":2},{"component":3,"global_component":43,"kind":"momentum","parameter_index":23,"real_valued":true,"source_id":2},{"component":0,"global_component":44,"kind":"momentum","parameter_index":24,"real_valued":true,"source_id":3},{"component":1,"global_component":45,"kind":"momentum","parameter_index":25,"real_valued":true,"source_id":3},{"component":2,"global_component":46,"kind":"momentum","parameter_index":26,"real_valued":true,"source_id":3},{"component":3,"global_component":47,"kind":"momentum","parameter_index":27,"real_valued":true,"source_id":3},{"component":0,"global_component":58,"kind":"model_parameter","parameter_index":28,"real_valued":true,"source_id":10},{"component":0,"global_component":59,"kind":"model_parameter","parameter_index":29,"real_valued":true,"source_id":11}],"input_value_slot_ids":[2,3,4,5,6],"interaction_ids":[0,1,2,3,4,5],"model_parameter_count":2,"momentum_parameter_count":12,"output_length":12,"output_slots":[{"component_start":20,"component_stop":22,"current_id":7,"output_start":0,"output_stop":2,"value_slot_id":7,"variant":"unpropagated"},{"component_start":22,"component_stop":24,"current_id":8,"output_start":2,"output_stop":4,"value_slot_id":8,"variant":"unpropagated"},{"component_start":24,"component_stop":26,"current_id":9,"output_start":4,"output_stop":6,"value_slot_id":9,"variant":"unpropagated"},{"component_start":26,"component_stop":28,"current_id":10,"output_start":6,"output_stop":8,"value_slot_id":10,"variant":"unpropagated"},{"component_start":28,"component_stop":30,"current_id":11,"output_start":8,"output_stop":10,"value_slot_id":11,"variant":"unpropagated"},{"component_start":30,"component_stop":32,"current_id":12,"output_start":10,"output_stop":12,"value_slot_id":12,"variant":"unpropagated"}],"output_value_slot_ids":[7,8,9,10,11,12],"parameter_count":30,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[16,17,18,19,20,21,22,23,24,25,26,27,28,29],"stage_index":1,"stage_kind":"current-combine","subset_size":2,"value_parameter_count":16}],"value_parameter_count":0}},"dag_summary":{"amplitude_root_count":6,"current_count":13,"interaction_count":6,"interaction_evaluation_count":6,"source_count":7,"truncated":false},"external_pdg_order":[1,-1,23],"key":"d_dbar_to_z","kind":"pyamplicol-runtime-execution","materialization_census":{"abi":"pyamplicol-fully-resident-materialization-census-v1","basis":"immutable-fully-resident-compiled-dag","final":{"amplitude_root_count":6,"current_count":13,"interaction_count":6,"interaction_evaluation_count":6,"source_count":7},"final_equals_peak":true,"peak":{"amplitude_root_count":6,"current_count":13,"interaction_count":6,"interaction_evaluation_count":6,"source_count":7}},"physics_reduction":{"groups":[{"id":"reduction:0","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:+1,-1,-1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:+1,-1,-1"},{"id":"reduction:1","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:+1,-1,+0"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:+1,-1,+0"},{"id":"reduction:2","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:+1,-1,+1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:+1,-1,+1"},{"id":"reduction:3","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:-1,+1,-1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:-1,+1,-1"},{"id":"reduction:4","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:-1,+1,+0"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:-1,+1,+0"},{"id":"reduction:5","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:-1,+1,+1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:-1,+1,+1"}],"kind":"lc-diagonal"},"process":"d d~ > z","required_runtime_capabilities":["compiled-plane-arena-v1","symjit.application.complex-f64.v1"],"runtime_schema":{"amplitude_stage":{"color_contraction":null,"color_topology_replay":null,"output_count":6,"roots":[{"all_sector_weight":1.0,"coherent_group_id":0,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":7,"left_slot":{"component_start":20,"component_stop":22,"current_id":7,"dimension":2},"left_value_slot":{"component_start":20,"component_stop":22,"current_id":7,"dimension":2,"value_slot_id":7,"variant":"unpropagated"},"output_index":0,"right_current_id":1,"right_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2},"right_value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"root_id":0,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":1,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":8,"left_slot":{"component_start":22,"component_stop":24,"current_id":8,"dimension":2},"left_value_slot":{"component_start":22,"component_stop":24,"current_id":8,"dimension":2,"value_slot_id":8,"variant":"unpropagated"},"output_index":1,"right_current_id":1,"right_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2},"right_value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"root_id":1,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":2,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":9,"left_slot":{"component_start":24,"component_stop":26,"current_id":9,"dimension":2},"left_value_slot":{"component_start":24,"component_stop":26,"current_id":9,"dimension":2,"value_slot_id":9,"variant":"unpropagated"},"output_index":2,"right_current_id":1,"right_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2},"right_value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"root_id":2,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":3,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":10,"left_slot":{"component_start":26,"component_stop":28,"current_id":10,"dimension":2},"left_value_slot":{"component_start":26,"component_stop":28,"current_id":10,"dimension":2,"value_slot_id":10,"variant":"unpropagated"},"output_index":3,"right_current_id":0,"right_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2},"right_value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"root_id":3,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":4,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":11,"left_slot":{"component_start":28,"component_stop":30,"current_id":11,"dimension":2},"left_value_slot":{"component_start":28,"component_stop":30,"current_id":11,"dimension":2,"value_slot_id":11,"variant":"unpropagated"},"output_index":4,"right_current_id":0,"right_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2},"right_value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"root_id":4,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":5,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":12,"left_slot":{"component_start":30,"component_stop":32,"current_id":12,"dimension":2},"left_value_slot":{"component_start":30,"component_stop":32,"current_id":12,"dimension":2,"value_slot_id":12,"variant":"unpropagated"},"output_index":5,"right_current_id":0,"right_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2},"right_value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"root_id":5,"vertex_kind":null,"vertex_particles":null}],"stage_kind":"amplitude-roots"},"current_storage":{"component_count":32,"current_slots":[{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"external_labels":[1],"external_mask":1,"flavour_flow":[-1],"helicity_ancestry":"0x1","is_source":true,"momentum_mask":1,"particle_id":-1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"external_labels":[1],"external_mask":1,"flavour_flow":[-1],"helicity_ancestry":"0x2","is_source":true,"momentum_mask":1,"particle_id":-1,"spin_state":-1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":4,"component_stop":6,"current_id":2,"dimension":2,"external_labels":[2],"external_mask":2,"flavour_flow":[1],"helicity_ancestry":"0x4","is_source":true,"momentum_mask":2,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":6,"component_stop":8,"current_id":3,"dimension":2,"external_labels":[2],"external_mask":2,"flavour_flow":[1],"helicity_ancestry":"0x8","is_source":true,"momentum_mask":2,"particle_id":1,"spin_state":-1},{"auxiliary_kind":null,"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"component_start":8,"component_stop":12,"current_id":4,"dimension":4,"external_labels":[3],"external_mask":4,"flavour_flow":[23],"helicity_ancestry":"0x10","is_source":true,"momentum_mask":4,"particle_id":23,"spin_state":-1},{"auxiliary_kind":null,"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"component_start":12,"component_stop":16,"current_id":5,"dimension":4,"external_labels":[3],"external_mask":4,"flavour_flow":[23],"helicity_ancestry":"0x20","is_source":true,"momentum_mask":4,"particle_id":23,"spin_state":0},{"auxiliary_kind":null,"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"component_start":16,"component_stop":20,"current_id":6,"dimension":4,"external_labels":[3],"external_mask":4,"flavour_flow":[23],"helicity_ancestry":"0x40","is_source":true,"momentum_mask":4,"particle_id":23,"spin_state":1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":20,"component_stop":22,"current_id":7,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x14","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":22,"component_stop":24,"current_id":8,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x24","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":24,"component_stop":26,"current_id":9,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x44","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":26,"component_stop":28,"current_id":10,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x18","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":-1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":28,"component_stop":30,"current_id":11,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x28","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":-1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":30,"component_stop":32,"current_id":12,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x48","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":-1}],"metadata_compacted":true,"number_type":"complex"},"external_particles":[{"index":0,"label":1,"momentum_slot":0,"outgoing_pdg":-1,"pdg":1,"role":"initial"},{"index":1,"label":2,"momentum_slot":1,"outgoing_pdg":1,"pdg":-1,"role":"initial"},{"index":2,"label":3,"momentum_slot":2,"outgoing_pdg":23,"pdg":23,"role":"final"}],"kind":"pyamplicol-runtime-execution-plan","model":{"particles":[{"mass":0.0,"mass_parameter":null,"pdg":1},{"mass":91.188,"mass_parameter":"particle.23.mass","pdg":23}]},"model_parameters":[{"default":0.0075467711139788835,"kind":"normalization","name":"normalization.alpha_ew","parameter_index":0},{"default":0.118,"kind":"normalization","name":"normalization.alpha_s_me_check","parameter_index":1},{"default":173.0,"kind":"particle_mass","name":"particle.6.mass","parameter_index":2,"pdg":6},{"default":1.4915,"kind":"particle_width","name":"particle.6.width","parameter_index":3,"pdg":6},{"default":91.188,"kind":"particle_mass","name":"particle.23.mass","parameter_index":4,"pdg":23},{"default":2.441404,"kind":"particle_width","name":"particle.23.width","parameter_index":5,"pdg":23},{"default":80.41900244575616,"kind":"particle_mass","name":"particle.24.mass","parameter_index":6,"pdg":24},{"default":2.0476,"kind":"particle_width","name":"particle.24.width","parameter_index":7,"pdg":24},{"default":125.0,"kind":"particle_mass","name":"particle.25.mass","parameter_index":8,"pdg":25},{"default":0.006382339,"kind":"particle_width","name":"particle.25.width","parameter_index":9,"pdg":25},{"default":-1.0244420275940371,"kind":"coupling_component","name":"coupling.10.1_23_1.component_0","parameter_index":10},{"default":0.17818666745287456,"kind":"coupling_component","name":"coupling.10.1_23_1.component_1","parameter_index":11}],"momentum_slots":[{"component_start":0,"component_stop":4,"external_labels":[1],"momentum_mask":1,"momentum_slot_id":0,"real_valued":true},{"component_start":4,"component_stop":8,"external_labels":[2],"momentum_mask":2,"momentum_slot_id":1,"real_valued":true},{"component_start":8,"component_stop":12,"external_labels":[3],"momentum_mask":4,"momentum_slot_id":2,"real_valued":true},{"component_start":12,"component_stop":16,"external_labels":[2,3],"momentum_mask":6,"momentum_slot_id":3,"real_valued":true}],"normalization":{"average_factor":36.0,"color_factor":3.0,"electroweak_coupling_power":1,"global_coupling_factor":0.18967104551999775,"identical_factor":1.0,"qcd_coupling_power":0},"parameter_layout":{"model_parameter_count":12,"momentum_components_real":true,"momentum_parameter_count":16,"parameter_count_if_flattened":48,"real_valued_inputs":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47],"source_component_parameter_count":20,"source_components_complex":true,"value_component_count":32},"process":"d d~ > z","process_key":"d_dbar_to_z","schema_version":3,"source_fill":{"source_count":7,"sources":[{"anti_particle_id":1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":0,"current_component_stop":2,"current_id":0,"dimension":2,"helicity_ancestry":"0x1","input_momentum_slot":0,"leg_label":1,"outgoing_pdg":-1,"particle_id":-1,"physical_pdg":1,"side":"initial","source_basis":"weyl-chiral","source_helicity":-1,"source_id":0,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"antiparticle","source_parameter_start":0,"source_parameter_stop":2,"spin_state":1,"value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":2,"current_component_stop":4,"current_id":1,"dimension":2,"helicity_ancestry":"0x2","input_momentum_slot":0,"leg_label":1,"outgoing_pdg":-1,"particle_id":-1,"physical_pdg":1,"side":"initial","source_basis":"weyl-chiral","source_helicity":1,"source_id":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"antiparticle","source_parameter_start":2,"source_parameter_stop":4,"spin_state":-1,"value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":-1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":4,"current_component_stop":6,"current_id":2,"dimension":2,"helicity_ancestry":"0x4","input_momentum_slot":1,"leg_label":2,"outgoing_pdg":1,"particle_id":1,"physical_pdg":-1,"side":"initial","source_basis":"weyl-chiral","source_helicity":-1,"source_id":2,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"particle","source_parameter_start":4,"source_parameter_stop":6,"spin_state":1,"value_slot":{"component_start":4,"component_stop":6,"current_id":2,"dimension":2,"value_slot_id":2,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":-1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":6,"current_component_stop":8,"current_id":3,"dimension":2,"helicity_ancestry":"0x8","input_momentum_slot":1,"leg_label":2,"outgoing_pdg":1,"particle_id":1,"physical_pdg":-1,"side":"initial","source_basis":"weyl-chiral","source_helicity":1,"source_id":3,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"particle","source_parameter_start":6,"source_parameter_stop":8,"spin_state":-1,"value_slot":{"component_start":6,"component_stop":8,"current_id":3,"dimension":2,"value_slot_id":3,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":23,"applied_crossing":{"chirality_factor":1,"helicity_factor":1,"momentum_transform":"identity","phase":[1.0,0.0],"spin_state_factor":1},"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"crossing":"identity","current_component_start":8,"current_component_stop":12,"current_id":4,"dimension":4,"helicity_ancestry":"0x10","input_momentum_slot":2,"leg_label":3,"outgoing_pdg":23,"particle_id":23,"physical_pdg":23,"side":"final","source_basis":"lorentz-vector","source_helicity":-1,"source_id":4,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":null,"states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"self-conjugate","source_parameter_start":8,"source_parameter_stop":12,"spin_state":-1,"value_slot":{"component_start":8,"component_stop":12,"current_id":4,"dimension":4,"value_slot_id":4,"variant":"source"},"wavefunction_kind":"vector"},{"anti_particle_id":23,"applied_crossing":{"chirality_factor":1,"helicity_factor":1,"momentum_transform":"identity","phase":[1.0,0.0],"spin_state_factor":1},"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"crossing":"identity","current_component_start":12,"current_component_stop":16,"current_id":5,"dimension":4,"helicity_ancestry":"0x20","input_momentum_slot":2,"leg_label":3,"outgoing_pdg":23,"particle_id":23,"physical_pdg":23,"side":"final","source_basis":"lorentz-vector","source_helicity":0,"source_id":5,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":null,"states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"self-conjugate","source_parameter_start":12,"source_parameter_stop":16,"spin_state":0,"value_slot":{"component_start":12,"component_stop":16,"current_id":5,"dimension":4,"value_slot_id":5,"variant":"source"},"wavefunction_kind":"vector"},{"anti_particle_id":23,"applied_crossing":{"chirality_factor":1,"helicity_factor":1,"momentum_transform":"identity","phase":[1.0,0.0],"spin_state_factor":1},"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"crossing":"identity","current_component_start":16,"current_component_stop":20,"current_id":6,"dimension":4,"helicity_ancestry":"0x40","input_momentum_slot":2,"leg_label":3,"outgoing_pdg":23,"particle_id":23,"physical_pdg":23,"side":"final","source_basis":"lorentz-vector","source_helicity":1,"source_id":6,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":null,"states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"self-conjugate","source_parameter_start":16,"source_parameter_stop":20,"spin_state":1,"value_slot":{"component_start":16,"component_stop":20,"current_id":6,"dimension":4,"value_slot_id":6,"variant":"source"},"wavefunction_kind":"vector"}]},"stages":[{"input_current_ids":[2,3,4,5,6],"input_value_slot_ids":[2,3,4,5,6],"interaction_count":6,"interaction_ids":[0,1,2,3,4,5],"interactions":[],"interactions_compacted":true,"output_current_ids":[7,8,9,10,11,12],"output_value_slot_ids":[7,8,9,10,11,12],"stage_index":1,"stage_kind":"current-combine","subset_size":2}],"value_storage":{"component_count":32,"metadata_compacted":true,"number_type":"complex","value_slots":[{"applies_propagator":false,"chirality":1,"component_start":0,"component_stop":2,"current_component_start":0,"current_component_stop":2,"current_id":0,"dimension":2,"external_labels":[1],"external_mask":1,"is_source":true,"momentum_mask":1,"particle_id":-1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":-1,"width_parameter":null},"value_slot_id":0,"variant":"source"},{"applies_propagator":false,"chirality":-1,"component_start":2,"component_stop":4,"current_component_start":2,"current_component_stop":4,"current_id":1,"dimension":2,"external_labels":[1],"external_mask":1,"is_source":true,"momentum_mask":1,"particle_id":-1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":-1,"width_parameter":null},"value_slot_id":1,"variant":"source"},{"applies_propagator":false,"chirality":1,"component_start":4,"component_stop":6,"current_component_start":4,"current_component_stop":6,"current_id":2,"dimension":2,"external_labels":[2],"external_mask":2,"is_source":true,"momentum_mask":2,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":2,"variant":"source"},{"applies_propagator":false,"chirality":-1,"component_start":6,"component_stop":8,"current_component_start":6,"current_component_stop":8,"current_id":3,"dimension":2,"external_labels":[2],"external_mask":2,"is_source":true,"momentum_mask":2,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":3,"variant":"source"},{"applies_propagator":false,"chirality":0,"component_start":8,"component_stop":12,"current_component_start":8,"current_component_stop":12,"current_id":4,"dimension":4,"external_labels":[3],"external_mask":4,"is_source":true,"momentum_mask":4,"particle_id":23,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"symbolica","basis":"lorentz-vector","chirality":0,"custom_source":null,"denominator":"momentum_squared-mass_squared+i*mass*width","description":"massive vector propagator with width","full_tensor_network_ready":true,"gauge":"unitary","goldstone_policy":"absorbed","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"kernel":"massive_vector_unitary_gauge","kind":"vector","mass_class":"massive","mass_parameter":null,"numerator":"-i*(metric-momentum_outer/mass_squared)","particle_id":23,"width_parameter":null},"value_slot_id":4,"variant":"source"},{"applies_propagator":false,"chirality":0,"component_start":12,"component_stop":16,"current_component_start":12,"current_component_stop":16,"current_id":5,"dimension":4,"external_labels":[3],"external_mask":4,"is_source":true,"momentum_mask":4,"particle_id":23,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"symbolica","basis":"lorentz-vector","chirality":0,"custom_source":null,"denominator":"momentum_squared-mass_squared+i*mass*width","description":"massive vector propagator with width","full_tensor_network_ready":true,"gauge":"unitary","goldstone_policy":"absorbed","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"kernel":"massive_vector_unitary_gauge","kind":"vector","mass_class":"massive","mass_parameter":null,"numerator":"-i*(metric-momentum_outer/mass_squared)","particle_id":23,"width_parameter":null},"value_slot_id":5,"variant":"source"},{"applies_propagator":false,"chirality":0,"component_start":16,"component_stop":20,"current_component_start":16,"current_component_stop":20,"current_id":6,"dimension":4,"external_labels":[3],"external_mask":4,"is_source":true,"momentum_mask":4,"particle_id":23,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"symbolica","basis":"lorentz-vector","chirality":0,"custom_source":null,"denominator":"momentum_squared-mass_squared+i*mass*width","description":"massive vector propagator with width","full_tensor_network_ready":true,"gauge":"unitary","goldstone_policy":"absorbed","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"kernel":"massive_vector_unitary_gauge","kind":"vector","mass_class":"massive","mass_parameter":null,"numerator":"-i*(metric-momentum_outer/mass_squared)","particle_id":23,"width_parameter":null},"value_slot_id":6,"variant":"source"},{"applies_propagator":false,"chirality":1,"component_start":20,"component_stop":22,"current_component_start":20,"current_component_stop":22,"current_id":7,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":7,"variant":"unpropagated"},{"applies_propagator":false,"chirality":1,"component_start":22,"component_stop":24,"current_component_start":22,"current_component_stop":24,"current_id":8,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":8,"variant":"unpropagated"},{"applies_propagator":false,"chirality":1,"component_start":24,"component_stop":26,"current_component_start":24,"current_component_stop":26,"current_id":9,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":9,"variant":"unpropagated"},{"applies_propagator":false,"chirality":-1,"component_start":26,"component_stop":28,"current_component_start":26,"current_component_stop":28,"current_id":10,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":10,"variant":"unpropagated"},{"applies_propagator":false,"chirality":-1,"component_start":28,"component_stop":30,"current_component_start":28,"current_component_stop":30,"current_id":11,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":11,"variant":"unpropagated"},{"applies_propagator":false,"chirality":-1,"component_start":30,"component_stop":32,"current_component_start":30,"current_component_stop":32,"current_id":12,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":12,"variant":"unpropagated"}]}},"schema_version":3},"materialized_sector_id":0}],"compiled":{"kind":"generic-dag-stage-blueprint","model_parameter_evaluator":null,"momentum_slot_ids":[1,2,3],"runtime_available":true,"runtime_unavailable_message":null,"stage_evaluators":{"amplitude_stage":{"blockers":[],"compiled_plane_arena":{"application_abi":"pyamplicol-compiled-plane-kernel-v2","element_layout":"split-complex-component-major","input_bindings":[{"component":0,"global_component":0,"kind":"value","parameter_index":0,"real_valued":false,"source_id":0},{"component":1,"global_component":1,"kind":"value","parameter_index":1,"real_valued":false,"source_id":0},{"component":0,"global_component":2,"kind":"value","parameter_index":2,"real_valued":false,"source_id":1},{"component":1,"global_component":3,"kind":"value","parameter_index":3,"real_valued":false,"source_id":1},{"component":0,"global_component":20,"kind":"value","parameter_index":4,"real_valued":false,"source_id":7},{"component":1,"global_component":21,"kind":"value","parameter_index":5,"real_valued":false,"source_id":7},{"component":0,"global_component":22,"kind":"value","parameter_index":6,"real_valued":false,"source_id":8},{"component":1,"global_component":23,"kind":"value","parameter_index":7,"real_valued":false,"source_id":8},{"component":0,"global_component":24,"kind":"value","parameter_index":8,"real_valued":false,"source_id":9},{"component":1,"global_component":25,"kind":"value","parameter_index":9,"real_valued":false,"source_id":9},{"component":0,"global_component":26,"kind":"value","parameter_index":10,"real_valued":false,"source_id":10},{"component":1,"global_component":27,"kind":"value","parameter_index":11,"real_valued":false,"source_id":10},{"component":0,"global_component":28,"kind":"value","parameter_index":12,"real_valued":false,"source_id":11},{"component":1,"global_component":29,"kind":"value","parameter_index":13,"real_valued":false,"source_id":11},{"component":0,"global_component":30,"kind":"value","parameter_index":14,"real_valued":false,"source_id":12},{"component":1,"global_component":31,"kind":"value","parameter_index":15,"real_valued":false,"source_id":12}],"input_output_aliasing":"forbidden","kind":"compiled-plane-arena-stage","leaves":[{"application_path":"helicity-sum/evaluators/generic_amplitude_stage_c364260eb0094c4d9759fd633eb269fe.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],"input_len":16,"optimization_level":2,"output_len":6,"output_start":0,"output_stop":6,"source_application_abi":"pyamplicol-symjit-plane-application-v2"}],"output_bindings":[{"arena":"amplitude","component":0,"output_index":0},{"arena":"amplitude","component":1,"output_index":1},{"arena":"amplitude","component":2,"output_index":2},{"arena":"amplitude","component":3,"output_index":3},{"arena":"amplitude","component":4,"output_index":4},{"arena":"amplitude","component":5,"output_index":5}],"output_factor":"identity","output_operation":"overwrite","output_output_aliasing":"forbidden","schema_version":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},"evaluator":{"application_abi":"symjit-application-storage-v3","application_path":"helicity-sum/evaluators/generic_amplitude_stage_c364260eb0094c4d9759fd633eb269fe.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":16,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":6,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"helicity-sum/evaluators/generic_amplitude_stage_c364260eb0094c4d9759fd633eb269fe.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":16,"input_plane_count":32,"optimization_level":2,"output_complex_count":6,"output_plane_count":12,"simd":true,"source_digest":"2a37e3f222d3a34a70cc55f8517b6823d0c17e6efad8f06f75e39ed367d6e6b1","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64},"evaluator_label":"generic_amplitude_stage","expression_ready":true,"input_components":[{"component":0,"global_component":0,"kind":"value","parameter_index":0,"real_valued":false,"source_id":0},{"component":1,"global_component":1,"kind":"value","parameter_index":1,"real_valued":false,"source_id":0},{"component":0,"global_component":2,"kind":"value","parameter_index":2,"real_valued":false,"source_id":1},{"component":1,"global_component":3,"kind":"value","parameter_index":3,"real_valued":false,"source_id":1},{"component":0,"global_component":20,"kind":"value","parameter_index":4,"real_valued":false,"source_id":7},{"component":1,"global_component":21,"kind":"value","parameter_index":5,"real_valued":false,"source_id":7},{"component":0,"global_component":22,"kind":"value","parameter_index":6,"real_valued":false,"source_id":8},{"component":1,"global_component":23,"kind":"value","parameter_index":7,"real_valued":false,"source_id":8},{"component":0,"global_component":24,"kind":"value","parameter_index":8,"real_valued":false,"source_id":9},{"component":1,"global_component":25,"kind":"value","parameter_index":9,"real_valued":false,"source_id":9},{"component":0,"global_component":26,"kind":"value","parameter_index":10,"real_valued":false,"source_id":10},{"component":1,"global_component":27,"kind":"value","parameter_index":11,"real_valued":false,"source_id":10},{"component":0,"global_component":28,"kind":"value","parameter_index":12,"real_valued":false,"source_id":11},{"component":1,"global_component":29,"kind":"value","parameter_index":13,"real_valued":false,"source_id":11},{"component":0,"global_component":30,"kind":"value","parameter_index":14,"real_valued":false,"source_id":12},{"component":1,"global_component":31,"kind":"value","parameter_index":15,"real_valued":false,"source_id":12}],"input_value_slot_ids":[0,1,7,8,9,10,11,12],"interaction_ids":[],"model_parameter_count":0,"momentum_parameter_count":0,"output_length":6,"output_slots":[{"component_start":0,"component_stop":1,"current_id":-1,"output_start":0,"output_stop":1,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":1,"component_stop":2,"current_id":-1,"output_start":1,"output_stop":2,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":2,"component_stop":3,"current_id":-1,"output_start":2,"output_stop":3,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":3,"component_stop":4,"current_id":-1,"output_start":3,"output_stop":4,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":4,"component_stop":5,"current_id":-1,"output_start":4,"output_stop":5,"value_slot_id":-1,"variant":"amplitude-root"},{"component_start":5,"component_stop":6,"current_id":-1,"output_start":5,"output_stop":6,"value_slot_id":-1,"variant":"amplitude-root"}],"output_value_slot_ids":[],"parameter_count":16,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[],"stage_index":0,"stage_kind":"amplitude-roots","subset_size":null,"value_parameter_count":16},"kind":"generic-dag-stage-evaluator-artifacts","model_parameter_count":0,"momentum_parameter_count":0,"parameter_count":0,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[],"required_runtime_capabilities":["compiled-plane-arena-v1","symjit.application.complex-f64.v1"],"runtime_available":true,"runtime_unavailable_message":null,"stage_count":2,"stages":[{"blockers":[],"compiled_plane_arena":{"application_abi":"pyamplicol-compiled-plane-kernel-v2","element_layout":"split-complex-component-major","input_bindings":[{"component":0,"global_component":4,"kind":"value","parameter_index":0,"real_valued":false,"source_id":2},{"component":1,"global_component":5,"kind":"value","parameter_index":1,"real_valued":false,"source_id":2},{"component":0,"global_component":6,"kind":"value","parameter_index":2,"real_valued":false,"source_id":3},{"component":1,"global_component":7,"kind":"value","parameter_index":3,"real_valued":false,"source_id":3},{"component":0,"global_component":8,"kind":"value","parameter_index":4,"real_valued":false,"source_id":4},{"component":1,"global_component":9,"kind":"value","parameter_index":5,"real_valued":false,"source_id":4},{"component":2,"global_component":10,"kind":"value","parameter_index":6,"real_valued":false,"source_id":4},{"component":3,"global_component":11,"kind":"value","parameter_index":7,"real_valued":false,"source_id":4},{"component":0,"global_component":12,"kind":"value","parameter_index":8,"real_valued":false,"source_id":5},{"component":1,"global_component":13,"kind":"value","parameter_index":9,"real_valued":false,"source_id":5},{"component":2,"global_component":14,"kind":"value","parameter_index":10,"real_valued":false,"source_id":5},{"component":3,"global_component":15,"kind":"value","parameter_index":11,"real_valued":false,"source_id":5},{"component":0,"global_component":16,"kind":"value","parameter_index":12,"real_valued":false,"source_id":6},{"component":1,"global_component":17,"kind":"value","parameter_index":13,"real_valued":false,"source_id":6},{"component":2,"global_component":18,"kind":"value","parameter_index":14,"real_valued":false,"source_id":6},{"component":3,"global_component":19,"kind":"value","parameter_index":15,"real_valued":false,"source_id":6},{"component":0,"global_component":36,"kind":"momentum","parameter_index":16,"real_valued":true,"source_id":1},{"component":1,"global_component":37,"kind":"momentum","parameter_index":17,"real_valued":true,"source_id":1},{"component":2,"global_component":38,"kind":"momentum","parameter_index":18,"real_valued":true,"source_id":1},{"component":3,"global_component":39,"kind":"momentum","parameter_index":19,"real_valued":true,"source_id":1},{"component":0,"global_component":40,"kind":"momentum","parameter_index":20,"real_valued":true,"source_id":2},{"component":1,"global_component":41,"kind":"momentum","parameter_index":21,"real_valued":true,"source_id":2},{"component":2,"global_component":42,"kind":"momentum","parameter_index":22,"real_valued":true,"source_id":2},{"component":3,"global_component":43,"kind":"momentum","parameter_index":23,"real_valued":true,"source_id":2},{"component":0,"global_component":44,"kind":"momentum","parameter_index":24,"real_valued":true,"source_id":3},{"component":1,"global_component":45,"kind":"momentum","parameter_index":25,"real_valued":true,"source_id":3},{"component":2,"global_component":46,"kind":"momentum","parameter_index":26,"real_valued":true,"source_id":3},{"component":3,"global_component":47,"kind":"momentum","parameter_index":27,"real_valued":true,"source_id":3},{"component":0,"global_component":58,"kind":"model_parameter","parameter_index":28,"real_valued":true,"source_id":10},{"component":0,"global_component":59,"kind":"model_parameter","parameter_index":29,"real_valued":true,"source_id":11}],"input_output_aliasing":"forbidden","kind":"compiled-plane-arena-stage","leaves":[{"application_path":"helicity-sum/evaluators/generic_stage_1_subset_2_90fc7853c5a54d81b162083c4bf08e08.plane.symjit","direct_codegen_optimization_level":2,"input_indices":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29],"input_len":30,"optimization_level":2,"output_len":12,"output_start":0,"output_stop":12,"source_application_abi":"pyamplicol-symjit-plane-application-v2"}],"output_bindings":[{"arena":"current","component":20,"output_index":0},{"arena":"current","component":21,"output_index":1},{"arena":"current","component":22,"output_index":2},{"arena":"current","component":23,"output_index":3},{"arena":"current","component":24,"output_index":4},{"arena":"current","component":25,"output_index":5},{"arena":"current","component":26,"output_index":6},{"arena":"current","component":27,"output_index":7},{"arena":"current","component":28,"output_index":8},{"arena":"current","component":29,"output_index":9},{"arena":"current","component":30,"output_index":10},{"arena":"current","component":31,"output_index":11}],"output_factor":"identity","output_operation":"overwrite","output_output_aliasing":"forbidden","schema_version":1,"source_application_abi":"pyamplicol-symjit-plane-application-v2"},"evaluator":{"application_abi":"symjit-application-storage-v3","application_path":"helicity-sum/evaluators/generic_stage_1_subset_2_90fc7853c5a54d81b162083c4bf08e08.symjit","batch_layout":"row-major","compiler_type":"native","element_layout":"complex-f64","endianness":"little","evaluator_state_path":null,"evaluator_state_runtime_capability":null,"input_len":30,"kind":"symjit-application-evaluator","optimization_level":2,"output_len":12,"plane_application":{"application_abi":"pyamplicol-symjit-plane-application-v2","application_path":"helicity-sum/evaluators/generic_stage_1_subset_2_90fc7853c5a54d81b162083c4bf08e08.plane.symjit","compiler_type":"native","complex":true,"compression":true,"descriptor_order":"inputs-re-im-then-outputs-re-im","direct_arena":true,"element_layout":"split-complex-plane-major","fast_complex":false,"fast_math":true,"input_complex_count":30,"input_plane_count":60,"optimization_level":2,"output_complex_count":12,"output_plane_count":24,"simd":true,"source_digest":"932205a6edcc3a03c036ff3ac62bcbb2189b3471d544fffa5d82f5a25033b0c2","storage_abi":"symjit-application-storage-v3","target":{"cpu_features":["aes","bf16","bti","crc","dit","dotprod","dpb","dpb2","fcma","fhm","flagm","fp","fp16","frintts","i8mm","jsconv","lse","lse2","neon","paca","pacg","rcpc","rcpc2","rdm","sb","sha2","sha3","ssbs"],"endianness":"little","triple":"aarch64-apple-darwin","word_bits":64},"threading":false,"translation_mode":"symbolica-structured-instructions"},"required_defuns":[],"runtime_capability":"symjit.application.complex-f64.v1","translation_mode":"indirect","word_bits":64},"evaluator_label":"generic_stage_1_subset_2","expression_ready":true,"input_components":[{"component":0,"global_component":4,"kind":"value","parameter_index":0,"real_valued":false,"source_id":2},{"component":1,"global_component":5,"kind":"value","parameter_index":1,"real_valued":false,"source_id":2},{"component":0,"global_component":6,"kind":"value","parameter_index":2,"real_valued":false,"source_id":3},{"component":1,"global_component":7,"kind":"value","parameter_index":3,"real_valued":false,"source_id":3},{"component":0,"global_component":8,"kind":"value","parameter_index":4,"real_valued":false,"source_id":4},{"component":1,"global_component":9,"kind":"value","parameter_index":5,"real_valued":false,"source_id":4},{"component":2,"global_component":10,"kind":"value","parameter_index":6,"real_valued":false,"source_id":4},{"component":3,"global_component":11,"kind":"value","parameter_index":7,"real_valued":false,"source_id":4},{"component":0,"global_component":12,"kind":"value","parameter_index":8,"real_valued":false,"source_id":5},{"component":1,"global_component":13,"kind":"value","parameter_index":9,"real_valued":false,"source_id":5},{"component":2,"global_component":14,"kind":"value","parameter_index":10,"real_valued":false,"source_id":5},{"component":3,"global_component":15,"kind":"value","parameter_index":11,"real_valued":false,"source_id":5},{"component":0,"global_component":16,"kind":"value","parameter_index":12,"real_valued":false,"source_id":6},{"component":1,"global_component":17,"kind":"value","parameter_index":13,"real_valued":false,"source_id":6},{"component":2,"global_component":18,"kind":"value","parameter_index":14,"real_valued":false,"source_id":6},{"component":3,"global_component":19,"kind":"value","parameter_index":15,"real_valued":false,"source_id":6},{"component":0,"global_component":36,"kind":"momentum","parameter_index":16,"real_valued":true,"source_id":1},{"component":1,"global_component":37,"kind":"momentum","parameter_index":17,"real_valued":true,"source_id":1},{"component":2,"global_component":38,"kind":"momentum","parameter_index":18,"real_valued":true,"source_id":1},{"component":3,"global_component":39,"kind":"momentum","parameter_index":19,"real_valued":true,"source_id":1},{"component":0,"global_component":40,"kind":"momentum","parameter_index":20,"real_valued":true,"source_id":2},{"component":1,"global_component":41,"kind":"momentum","parameter_index":21,"real_valued":true,"source_id":2},{"component":2,"global_component":42,"kind":"momentum","parameter_index":22,"real_valued":true,"source_id":2},{"component":3,"global_component":43,"kind":"momentum","parameter_index":23,"real_valued":true,"source_id":2},{"component":0,"global_component":44,"kind":"momentum","parameter_index":24,"real_valued":true,"source_id":3},{"component":1,"global_component":45,"kind":"momentum","parameter_index":25,"real_valued":true,"source_id":3},{"component":2,"global_component":46,"kind":"momentum","parameter_index":26,"real_valued":true,"source_id":3},{"component":3,"global_component":47,"kind":"momentum","parameter_index":27,"real_valued":true,"source_id":3},{"component":0,"global_component":58,"kind":"model_parameter","parameter_index":28,"real_valued":true,"source_id":10},{"component":0,"global_component":59,"kind":"model_parameter","parameter_index":29,"real_valued":true,"source_id":11}],"input_value_slot_ids":[2,3,4,5,6],"interaction_ids":[0,1,2,3,4,5],"model_parameter_count":2,"momentum_parameter_count":12,"output_length":12,"output_slots":[{"component_start":20,"component_stop":22,"current_id":7,"output_start":0,"output_stop":2,"value_slot_id":7,"variant":"unpropagated"},{"component_start":22,"component_stop":24,"current_id":8,"output_start":2,"output_stop":4,"value_slot_id":8,"variant":"unpropagated"},{"component_start":24,"component_stop":26,"current_id":9,"output_start":4,"output_stop":6,"value_slot_id":9,"variant":"unpropagated"},{"component_start":26,"component_stop":28,"current_id":10,"output_start":6,"output_stop":8,"value_slot_id":10,"variant":"unpropagated"},{"component_start":28,"component_stop":30,"current_id":11,"output_start":8,"output_stop":10,"value_slot_id":11,"variant":"unpropagated"},{"component_start":30,"component_stop":32,"current_id":12,"output_start":10,"output_stop":12,"value_slot_id":12,"variant":"unpropagated"}],"output_value_slot_ids":[7,8,9,10,11,12],"parameter_count":30,"parameter_layout":"stage-local-value-momentum","real_valued_inputs":[16,17,18,19,20,21,22,23,24,25,26,27,28,29],"stage_index":1,"stage_kind":"current-combine","subset_size":2,"value_parameter_count":16}],"value_parameter_count":0}},"dag_summary":{"amplitude_root_count":6,"current_count":13,"interaction_count":6,"interaction_evaluation_count":6,"source_count":7,"truncated":false},"external_pdg_order":[1,-1,23],"key":"d_dbar_to_z","kind":"pyamplicol-runtime-execution","materialization_census":{"abi":"pyamplicol-fully-resident-materialization-census-v1","basis":"immutable-fully-resident-compiled-dag","final":{"amplitude_root_count":6,"current_count":13,"interaction_count":6,"interaction_evaluation_count":6,"source_count":7},"final_equals_peak":true,"peak":{"amplitude_root_count":6,"current_count":13,"interaction_count":6,"interaction_evaluation_count":6,"source_count":7}},"physics_reduction":{"groups":[{"id":"reduction:0","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:+1,-1,-1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:+1,-1,-1"},{"id":"reduction:1","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:+1,-1,+0"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:+1,-1,+0"},{"id":"reduction:2","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:+1,-1,+1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:+1,-1,+1"},{"id":"reduction:3","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:-1,+1,-1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:-1,+1,-1"},{"id":"reduction:4","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:-1,+1,+0"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:-1,+1,+0"},{"id":"reduction:5","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:-1,+1,+1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:-1,+1,+1"}],"kind":"lc-diagonal"},"process":"d d~ > z","required_runtime_capabilities":["compiled-plane-arena-v1","rusticol.compiled.color-topology-lanes.v1","rusticol.compiled.runtime-selectors.v1","symjit.application.complex-f64.v1"],"runtime_schema":{"amplitude_stage":{"color_contraction":null,"color_topology_replay":null,"output_count":6,"roots":[{"all_sector_weight":1.0,"coherent_group_id":0,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":7,"left_slot":{"component_start":20,"component_stop":22,"current_id":7,"dimension":2},"left_value_slot":{"component_start":20,"component_stop":22,"current_id":7,"dimension":2,"value_slot_id":7,"variant":"unpropagated"},"output_index":0,"right_current_id":1,"right_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2},"right_value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"root_id":0,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":1,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":8,"left_slot":{"component_start":22,"component_stop":24,"current_id":8,"dimension":2},"left_value_slot":{"component_start":22,"component_stop":24,"current_id":8,"dimension":2,"value_slot_id":8,"variant":"unpropagated"},"output_index":1,"right_current_id":1,"right_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2},"right_value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"root_id":1,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":2,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":9,"left_slot":{"component_start":24,"component_stop":26,"current_id":9,"dimension":2},"left_value_slot":{"component_start":24,"component_stop":26,"current_id":9,"dimension":2,"value_slot_id":9,"variant":"unpropagated"},"output_index":2,"right_current_id":1,"right_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2},"right_value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"root_id":2,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":3,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":10,"left_slot":{"component_start":26,"component_stop":28,"current_id":10,"dimension":2},"left_value_slot":{"component_start":26,"component_stop":28,"current_id":10,"dimension":2,"value_slot_id":10,"variant":"unpropagated"},"output_index":3,"right_current_id":0,"right_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2},"right_value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"root_id":3,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":4,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":11,"left_slot":{"component_start":28,"component_stop":30,"current_id":11,"dimension":2},"left_value_slot":{"component_start":28,"component_stop":30,"current_id":11,"dimension":2,"value_slot_id":11,"variant":"unpropagated"},"output_index":4,"right_current_id":0,"right_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2},"right_value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"root_id":4,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":5,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":12,"left_slot":{"component_start":30,"component_stop":32,"current_id":12,"dimension":2},"left_value_slot":{"component_start":30,"component_stop":32,"current_id":12,"dimension":2,"value_slot_id":12,"variant":"unpropagated"},"output_index":5,"right_current_id":0,"right_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2},"right_value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"root_id":5,"vertex_kind":null,"vertex_particles":null}],"stage_kind":"amplitude-roots"},"current_storage":{"component_count":32,"current_slots":[{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"external_labels":[1],"external_mask":1,"flavour_flow":[-1],"helicity_ancestry":"0x1","is_source":true,"momentum_mask":1,"particle_id":-1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"external_labels":[1],"external_mask":1,"flavour_flow":[-1],"helicity_ancestry":"0x2","is_source":true,"momentum_mask":1,"particle_id":-1,"spin_state":-1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":4,"component_stop":6,"current_id":2,"dimension":2,"external_labels":[2],"external_mask":2,"flavour_flow":[1],"helicity_ancestry":"0x4","is_source":true,"momentum_mask":2,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":6,"component_stop":8,"current_id":3,"dimension":2,"external_labels":[2],"external_mask":2,"flavour_flow":[1],"helicity_ancestry":"0x8","is_source":true,"momentum_mask":2,"particle_id":1,"spin_state":-1},{"auxiliary_kind":null,"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"component_start":8,"component_stop":12,"current_id":4,"dimension":4,"external_labels":[3],"external_mask":4,"flavour_flow":[23],"helicity_ancestry":"0x10","is_source":true,"momentum_mask":4,"particle_id":23,"spin_state":-1},{"auxiliary_kind":null,"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"component_start":12,"component_stop":16,"current_id":5,"dimension":4,"external_labels":[3],"external_mask":4,"flavour_flow":[23],"helicity_ancestry":"0x20","is_source":true,"momentum_mask":4,"particle_id":23,"spin_state":0},{"auxiliary_kind":null,"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"component_start":16,"component_stop":20,"current_id":6,"dimension":4,"external_labels":[3],"external_mask":4,"flavour_flow":[23],"helicity_ancestry":"0x40","is_source":true,"momentum_mask":4,"particle_id":23,"spin_state":1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":20,"component_stop":22,"current_id":7,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x14","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":22,"component_stop":24,"current_id":8,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x24","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":24,"component_stop":26,"current_id":9,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x44","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":26,"component_stop":28,"current_id":10,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x18","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":-1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":28,"component_stop":30,"current_id":11,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x28","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":-1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":30,"component_stop":32,"current_id":12,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x48","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":-1}],"metadata_compacted":true,"number_type":"complex"},"external_particles":[{"index":0,"label":1,"momentum_slot":0,"outgoing_pdg":-1,"pdg":1,"role":"initial"},{"index":1,"label":2,"momentum_slot":1,"outgoing_pdg":1,"pdg":-1,"role":"initial"},{"index":2,"label":3,"momentum_slot":2,"outgoing_pdg":23,"pdg":23,"role":"final"}],"kind":"pyamplicol-runtime-execution-plan","model":{"particles":[{"mass":0.0,"mass_parameter":null,"pdg":1},{"mass":91.188,"mass_parameter":"particle.23.mass","pdg":23}]},"model_parameters":[{"default":0.0075467711139788835,"kind":"normalization","name":"normalization.alpha_ew","parameter_index":0},{"default":0.118,"kind":"normalization","name":"normalization.alpha_s_me_check","parameter_index":1},{"default":173.0,"kind":"particle_mass","name":"particle.6.mass","parameter_index":2,"pdg":6},{"default":1.4915,"kind":"particle_width","name":"particle.6.width","parameter_index":3,"pdg":6},{"default":91.188,"kind":"particle_mass","name":"particle.23.mass","parameter_index":4,"pdg":23},{"default":2.441404,"kind":"particle_width","name":"particle.23.width","parameter_index":5,"pdg":23},{"default":80.41900244575616,"kind":"particle_mass","name":"particle.24.mass","parameter_index":6,"pdg":24},{"default":2.0476,"kind":"particle_width","name":"particle.24.width","parameter_index":7,"pdg":24},{"default":125.0,"kind":"particle_mass","name":"particle.25.mass","parameter_index":8,"pdg":25},{"default":0.006382339,"kind":"particle_width","name":"particle.25.width","parameter_index":9,"pdg":25},{"default":-1.0244420275940371,"kind":"coupling_component","name":"coupling.10.1_23_1.component_0","parameter_index":10},{"default":0.17818666745287456,"kind":"coupling_component","name":"coupling.10.1_23_1.component_1","parameter_index":11}],"momentum_slots":[{"component_start":0,"component_stop":4,"external_labels":[1],"momentum_mask":1,"momentum_slot_id":0,"real_valued":true},{"component_start":4,"component_stop":8,"external_labels":[2],"momentum_mask":2,"momentum_slot_id":1,"real_valued":true},{"component_start":8,"component_stop":12,"external_labels":[3],"momentum_mask":4,"momentum_slot_id":2,"real_valued":true},{"component_start":12,"component_stop":16,"external_labels":[2,3],"momentum_mask":6,"momentum_slot_id":3,"real_valued":true}],"normalization":{"average_factor":36.0,"color_factor":3.0,"electroweak_coupling_power":1,"global_coupling_factor":0.18967104551999775,"identical_factor":1.0,"qcd_coupling_power":0},"parameter_layout":{"model_parameter_count":12,"momentum_components_real":true,"momentum_parameter_count":16,"parameter_count_if_flattened":48,"real_valued_inputs":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47],"source_component_parameter_count":20,"source_components_complex":true,"value_component_count":32},"process":"d d~ > z","process_key":"d_dbar_to_z","schema_version":3,"source_fill":{"source_count":7,"sources":[{"anti_particle_id":1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":0,"current_component_stop":2,"current_id":0,"dimension":2,"helicity_ancestry":"0x1","input_momentum_slot":0,"leg_label":1,"outgoing_pdg":-1,"particle_id":-1,"physical_pdg":1,"side":"initial","source_basis":"weyl-chiral","source_helicity":-1,"source_id":0,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"antiparticle","source_parameter_start":0,"source_parameter_stop":2,"spin_state":1,"value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":2,"current_component_stop":4,"current_id":1,"dimension":2,"helicity_ancestry":"0x2","input_momentum_slot":0,"leg_label":1,"outgoing_pdg":-1,"particle_id":-1,"physical_pdg":1,"side":"initial","source_basis":"weyl-chiral","source_helicity":1,"source_id":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"antiparticle","source_parameter_start":2,"source_parameter_stop":4,"spin_state":-1,"value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":-1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":4,"current_component_stop":6,"current_id":2,"dimension":2,"helicity_ancestry":"0x4","input_momentum_slot":1,"leg_label":2,"outgoing_pdg":1,"particle_id":1,"physical_pdg":-1,"side":"initial","source_basis":"weyl-chiral","source_helicity":-1,"source_id":2,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"particle","source_parameter_start":4,"source_parameter_stop":6,"spin_state":1,"value_slot":{"component_start":4,"component_stop":6,"current_id":2,"dimension":2,"value_slot_id":2,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":-1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":6,"current_component_stop":8,"current_id":3,"dimension":2,"helicity_ancestry":"0x8","input_momentum_slot":1,"leg_label":2,"outgoing_pdg":1,"particle_id":1,"physical_pdg":-1,"side":"initial","source_basis":"weyl-chiral","source_helicity":1,"source_id":3,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"particle","source_parameter_start":6,"source_parameter_stop":8,"spin_state":-1,"value_slot":{"component_start":6,"component_stop":8,"current_id":3,"dimension":2,"value_slot_id":3,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":23,"applied_crossing":{"chirality_factor":1,"helicity_factor":1,"momentum_transform":"identity","phase":[1.0,0.0],"spin_state_factor":1},"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"crossing":"identity","current_component_start":8,"current_component_stop":12,"current_id":4,"dimension":4,"helicity_ancestry":"0x10","input_momentum_slot":2,"leg_label":3,"outgoing_pdg":23,"particle_id":23,"physical_pdg":23,"side":"final","source_basis":"lorentz-vector","source_helicity":-1,"source_id":4,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":null,"states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"self-conjugate","source_parameter_start":8,"source_parameter_stop":12,"spin_state":-1,"value_slot":{"component_start":8,"component_stop":12,"current_id":4,"dimension":4,"value_slot_id":4,"variant":"source"},"wavefunction_kind":"vector"},{"anti_particle_id":23,"applied_crossing":{"chirality_factor":1,"helicity_factor":1,"momentum_transform":"identity","phase":[1.0,0.0],"spin_state_factor":1},"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"crossing":"identity","current_component_start":12,"current_component_stop":16,"current_id":5,"dimension":4,"helicity_ancestry":"0x20","input_momentum_slot":2,"leg_label":3,"outgoing_pdg":23,"particle_id":23,"physical_pdg":23,"side":"final","source_basis":"lorentz-vector","source_helicity":0,"source_id":5,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":null,"states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"self-conjugate","source_parameter_start":12,"source_parameter_stop":16,"spin_state":0,"value_slot":{"component_start":12,"component_stop":16,"current_id":5,"dimension":4,"value_slot_id":5,"variant":"source"},"wavefunction_kind":"vector"},{"anti_particle_id":23,"applied_crossing":{"chirality_factor":1,"helicity_factor":1,"momentum_transform":"identity","phase":[1.0,0.0],"spin_state_factor":1},"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"crossing":"identity","current_component_start":16,"current_component_stop":20,"current_id":6,"dimension":4,"helicity_ancestry":"0x40","input_momentum_slot":2,"leg_label":3,"outgoing_pdg":23,"particle_id":23,"physical_pdg":23,"side":"final","source_basis":"lorentz-vector","source_helicity":1,"source_id":6,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":null,"states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"self-conjugate","source_parameter_start":16,"source_parameter_stop":20,"spin_state":1,"value_slot":{"component_start":16,"component_stop":20,"current_id":6,"dimension":4,"value_slot_id":6,"variant":"source"},"wavefunction_kind":"vector"}]},"stages":[{"input_current_ids":[2,3,4,5,6],"input_value_slot_ids":[2,3,4,5,6],"interaction_count":6,"interaction_ids":[0,1,2,3,4,5],"interactions":[],"interactions_compacted":true,"output_current_ids":[7,8,9,10,11,12],"output_value_slot_ids":[7,8,9,10,11,12],"stage_index":1,"stage_kind":"current-combine","subset_size":2}],"value_storage":{"component_count":32,"metadata_compacted":true,"number_type":"complex","value_slots":[{"applies_propagator":false,"chirality":1,"component_start":0,"component_stop":2,"current_component_start":0,"current_component_stop":2,"current_id":0,"dimension":2,"external_labels":[1],"external_mask":1,"is_source":true,"momentum_mask":1,"particle_id":-1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":-1,"width_parameter":null},"value_slot_id":0,"variant":"source"},{"applies_propagator":false,"chirality":-1,"component_start":2,"component_stop":4,"current_component_start":2,"current_component_stop":4,"current_id":1,"dimension":2,"external_labels":[1],"external_mask":1,"is_source":true,"momentum_mask":1,"particle_id":-1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":-1,"width_parameter":null},"value_slot_id":1,"variant":"source"},{"applies_propagator":false,"chirality":1,"component_start":4,"component_stop":6,"current_component_start":4,"current_component_stop":6,"current_id":2,"dimension":2,"external_labels":[2],"external_mask":2,"is_source":true,"momentum_mask":2,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":2,"variant":"source"},{"applies_propagator":false,"chirality":-1,"component_start":6,"component_stop":8,"current_component_start":6,"current_component_stop":8,"current_id":3,"dimension":2,"external_labels":[2],"external_mask":2,"is_source":true,"momentum_mask":2,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":3,"variant":"source"},{"applies_propagator":false,"chirality":0,"component_start":8,"component_stop":12,"current_component_start":8,"current_component_stop":12,"current_id":4,"dimension":4,"external_labels":[3],"external_mask":4,"is_source":true,"momentum_mask":4,"particle_id":23,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"symbolica","basis":"lorentz-vector","chirality":0,"custom_source":null,"denominator":"momentum_squared-mass_squared+i*mass*width","description":"massive vector propagator with width","full_tensor_network_ready":true,"gauge":"unitary","goldstone_policy":"absorbed","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"kernel":"massive_vector_unitary_gauge","kind":"vector","mass_class":"massive","mass_parameter":null,"numerator":"-i*(metric-momentum_outer/mass_squared)","particle_id":23,"width_parameter":null},"value_slot_id":4,"variant":"source"},{"applies_propagator":false,"chirality":0,"component_start":12,"component_stop":16,"current_component_start":12,"current_component_stop":16,"current_id":5,"dimension":4,"external_labels":[3],"external_mask":4,"is_source":true,"momentum_mask":4,"particle_id":23,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"symbolica","basis":"lorentz-vector","chirality":0,"custom_source":null,"denominator":"momentum_squared-mass_squared+i*mass*width","description":"massive vector propagator with width","full_tensor_network_ready":true,"gauge":"unitary","goldstone_policy":"absorbed","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"kernel":"massive_vector_unitary_gauge","kind":"vector","mass_class":"massive","mass_parameter":null,"numerator":"-i*(metric-momentum_outer/mass_squared)","particle_id":23,"width_parameter":null},"value_slot_id":5,"variant":"source"},{"applies_propagator":false,"chirality":0,"component_start":16,"component_stop":20,"current_component_start":16,"current_component_stop":20,"current_id":6,"dimension":4,"external_labels":[3],"external_mask":4,"is_source":true,"momentum_mask":4,"particle_id":23,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"symbolica","basis":"lorentz-vector","chirality":0,"custom_source":null,"denominator":"momentum_squared-mass_squared+i*mass*width","description":"massive vector propagator with width","full_tensor_network_ready":true,"gauge":"unitary","goldstone_policy":"absorbed","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"kernel":"massive_vector_unitary_gauge","kind":"vector","mass_class":"massive","mass_parameter":null,"numerator":"-i*(metric-momentum_outer/mass_squared)","particle_id":23,"width_parameter":null},"value_slot_id":6,"variant":"source"},{"applies_propagator":false,"chirality":1,"component_start":20,"component_stop":22,"current_component_start":20,"current_component_stop":22,"current_id":7,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":7,"variant":"unpropagated"},{"applies_propagator":false,"chirality":1,"component_start":22,"component_stop":24,"current_component_start":22,"current_component_stop":24,"current_id":8,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":8,"variant":"unpropagated"},{"applies_propagator":false,"chirality":1,"component_start":24,"component_stop":26,"current_component_start":24,"current_component_stop":26,"current_id":9,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":9,"variant":"unpropagated"},{"applies_propagator":false,"chirality":-1,"component_start":26,"component_stop":28,"current_component_start":26,"current_component_stop":28,"current_id":10,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":10,"variant":"unpropagated"},{"applies_propagator":false,"chirality":-1,"component_start":28,"component_stop":30,"current_component_start":28,"current_component_stop":30,"current_id":11,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":11,"variant":"unpropagated"},{"applies_propagator":false,"chirality":-1,"component_start":30,"component_stop":32,"current_component_start":30,"current_component_stop":32,"current_id":12,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":12,"variant":"unpropagated"}]}},"schema_version":3},"key":"d_dbar_to_z","kind":"pyamplicol-runtime-execution","materialization_census":{"abi":"pyamplicol-fully-resident-materialization-census-v1","basis":"immutable-fully-resident-compiled-dag","final":{"amplitude_root_count":2,"current_count":7,"interaction_count":2,"interaction_evaluation_count":2,"source_count":5},"final_equals_peak":true,"peak":{"amplitude_root_count":2,"current_count":7,"interaction_count":2,"interaction_evaluation_count":2,"source_count":5}},"process":"d d~ > z","required_runtime_capabilities":["compiled-plane-arena-v1","rusticol.compiled.color-topology-lanes.v1","rusticol.compiled.helicity-dual-lane.v1","rusticol.compiled.helicity-selector-union.v1","rusticol.compiled.runtime-selectors.v1","symjit.application.complex-f64.v1"],"runtime_schema":{"amplitude_stage":{"color_contraction":null,"color_topology_replay":null,"output_count":2,"roots":[{"all_sector_weight":1.0,"coherent_group_id":0,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":5,"left_slot":{"component_start":12,"component_stop":14,"current_id":5,"dimension":2},"left_value_slot":{"component_start":12,"component_stop":14,"current_id":5,"dimension":2,"value_slot_id":5,"variant":"unpropagated"},"output_index":0,"right_current_id":1,"right_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2},"right_value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"root_id":0,"vertex_kind":null,"vertex_particles":null},{"all_sector_weight":1.0,"coherent_group_id":1,"color_sector_id":0,"color_weight":[1.0,0.0],"contraction":"weyl","contraction_ir":{"chirality_relation":"opposite","coefficients":[[1.0,0.0],[1.0,0.0]],"left_basis":"weyl-chiral","metric_signature":null,"name":"weyl","right_basis":"weyl-chiral"},"coupling":[1.0,0.0],"helicity_weight":1.0,"kind":"direct-contraction","left_current_id":6,"left_slot":{"component_start":14,"component_stop":16,"current_id":6,"dimension":2},"left_value_slot":{"component_start":14,"component_stop":16,"current_id":6,"dimension":2,"value_slot_id":6,"variant":"unpropagated"},"output_index":1,"right_current_id":0,"right_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2},"right_value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"root_id":1,"vertex_kind":null,"vertex_particles":null}],"stage_kind":"amplitude-roots"},"current_storage":{"component_count":16,"current_slots":[{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"external_labels":[1],"external_mask":1,"flavour_flow":[-1],"helicity_ancestry":"0x1","is_source":true,"momentum_mask":1,"particle_id":-1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"external_labels":[1],"external_mask":1,"flavour_flow":[-1],"helicity_ancestry":"0x2","is_source":true,"momentum_mask":1,"particle_id":-1,"spin_state":-1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":4,"component_stop":6,"current_id":2,"dimension":2,"external_labels":[2],"external_mask":2,"flavour_flow":[1],"helicity_ancestry":"0x4","is_source":true,"momentum_mask":2,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":6,"component_stop":8,"current_id":3,"dimension":2,"external_labels":[2],"external_mask":2,"flavour_flow":[1],"helicity_ancestry":"0x8","is_source":true,"momentum_mask":2,"particle_id":1,"spin_state":-1},{"auxiliary_kind":null,"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"component_start":8,"component_stop":12,"current_id":4,"dimension":4,"external_labels":[3],"external_mask":4,"flavour_flow":[23],"helicity_ancestry":"0x10","is_source":true,"momentum_mask":4,"particle_id":23,"spin_state":-1},{"auxiliary_kind":null,"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":12,"component_stop":14,"current_id":5,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x14","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":1},{"auxiliary_kind":null,"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"component_start":14,"component_stop":16,"current_id":6,"dimension":2,"external_labels":[2,3],"external_mask":6,"flavour_flow":[1],"helicity_ancestry":"0x18","is_source":false,"momentum_mask":6,"particle_id":1,"spin_state":-1}],"metadata_compacted":true,"number_type":"complex"},"external_particles":[{"index":0,"label":1,"momentum_slot":0,"outgoing_pdg":-1,"pdg":1,"role":"initial"},{"index":1,"label":2,"momentum_slot":1,"outgoing_pdg":1,"pdg":-1,"role":"initial"},{"index":2,"label":3,"momentum_slot":2,"outgoing_pdg":23,"pdg":23,"role":"final"}],"helicity_recurrence":{"amplitude_classes":[{"class_id":"helicity-amplitude-sha256:d56fc183f4e6996740930cb59d082773bc739fdc54de6c684a44b2d643911365","members":[{"factor":[1.0,0.0],"root_id":0,"selector_domain_ids":[8]},{"factor":[1.0,0.0],"root_id":1,"selector_domain_ids":[9]},{"factor":[1.0,0.0],"root_id":2,"selector_domain_ids":[10]}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"d56fc183f4e6996740930cb59d082773bc739fdc54de6c684a44b2d643911365","status":"proven","transition_contract_ids":[]},"representative_root_id":0},{"class_id":"helicity-amplitude-sha256:19760a2fbd284e1f9c6b8d22028a99181ead6fa6e4437c0c42786703785a310a","members":[{"factor":[1.0,0.0],"root_id":3,"selector_domain_ids":[4]},{"factor":[1.0,0.0],"root_id":4,"selector_domain_ids":[5]},{"factor":[1.0,0.0],"root_id":5,"selector_domain_ids":[6]}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"19760a2fbd284e1f9c6b8d22028a99181ead6fa6e4437c0c42786703785a310a","status":"proven","transition_contract_ids":[]},"representative_root_id":3}],"amplitude_root_count":6,"contract_version":1,"current_count":13,"diagnostics":[],"kind":"pyamplicol-helicity-recurrence","materialization":{"amplitude_routes":[{"factor":[1.0,0.0],"materialized_root_id":0,"residual":false,"selector_domain_ids":[8]},{"factor":[1.0,0.0],"materialized_root_id":0,"residual":false,"selector_domain_ids":[9]},{"factor":[1.0,0.0],"materialized_root_id":0,"residual":false,"selector_domain_ids":[10]},{"factor":[1.0,0.0],"materialized_root_id":1,"residual":false,"selector_domain_ids":[4]},{"factor":[1.0,0.0],"materialized_root_id":1,"residual":false,"selector_domain_ids":[5]},{"factor":[1.0,0.0],"materialized_root_id":1,"residual":false,"selector_domain_ids":[6]}],"contract_version":1,"kind":"pyamplicol-helicity-recurrence-materialization","materialized_current_count":7,"materialized_root_count":2,"proof_current_count":13,"proof_root_count":6,"proof_to_materialized_current":[0,1,2,3,4,4,4,5,5,5,6,6,6],"selector_schedules":[{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":1,"structural_zero":true},{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":2,"structural_zero":true},{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":3,"structural_zero":true},{"active_current_ids":[0,3,4,6],"active_root_ids":[1],"selector_domain_id":4,"structural_zero":false},{"active_current_ids":[0,3,4,6],"active_root_ids":[1],"selector_domain_id":5,"structural_zero":false},{"active_current_ids":[0,3,4,6],"active_root_ids":[1],"selector_domain_id":6,"structural_zero":false},{"active_current_ids":[1,2,4,5],"active_root_ids":[0],"selector_domain_id":8,"structural_zero":false},{"active_current_ids":[1,2,4,5],"active_root_ids":[0],"selector_domain_id":9,"structural_zero":false},{"active_current_ids":[1,2,4,5],"active_root_ids":[0],"selector_domain_id":10,"structural_zero":false},{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":11,"structural_zero":true},{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":12,"structural_zero":true},{"active_current_ids":[],"active_root_ids":[],"selector_domain_id":13,"structural_zero":true}],"source_routes":[{"chirality":1,"declared_state_index":0,"external_label":1,"factor":[1.0,0.0],"helicity":-1,"materialized_current_id":0,"selector_domain_id":0,"spin_state":1},{"chirality":-1,"declared_state_index":1,"external_label":1,"factor":[1.0,0.0],"helicity":1,"materialized_current_id":1,"selector_domain_id":7,"spin_state":-1},{"chirality":1,"declared_state_index":0,"external_label":2,"factor":[1.0,0.0],"helicity":-1,"materialized_current_id":2,"selector_domain_id":14,"spin_state":1},{"chirality":-1,"declared_state_index":1,"external_label":2,"factor":[1.0,0.0],"helicity":1,"materialized_current_id":3,"selector_domain_id":18,"spin_state":-1},{"chirality":0,"declared_state_index":0,"external_label":3,"factor":[1.0,0.0],"helicity":-1,"materialized_current_id":4,"selector_domain_id":22,"spin_state":-1},{"chirality":0,"declared_state_index":1,"external_label":3,"factor":[1.0,0.0],"helicity":0,"materialized_current_id":4,"selector_domain_id":23,"spin_state":0},{"chirality":0,"declared_state_index":2,"external_label":3,"factor":[1.0,0.0],"helicity":1,"materialized_current_id":4,"selector_domain_id":24,"spin_state":1}],"strategy":"quotient"},"proof_algorithm":"canonical-source-transition-dependency-shape-v1","proof_counts":{"amplitude_class_count":2,"optimized_amplitude_class_count":2,"optimized_current_count":9,"optimized_recurrence_class_count":3,"physical_helicity_count":12,"recurrence_class_count":7,"residual_amplitude_count":0,"residual_current_count":0,"source_state_mapping_count":7,"structural_zero_helicity_count":6},"recurrence_classes":[{"class_id":"helicity-current-sha256:8c682736c4ae8e56465e5fd7b1c300f8379118af92486f9a571ca3a915572ccf","external_labels":[1],"members":[{"current_id":0,"factor":[1.0,0.0],"selector_domain_id":0}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"8c682736c4ae8e56465e5fd7b1c300f8379118af92486f9a571ca3a915572ccf","status":"proven","transition_contract_ids":[]},"representative_current_id":0,"source_class":true},{"class_id":"helicity-current-sha256:20f4ac2ac00a74044681ff5aab37d2abc31e375d1473e8b0a8198af4432c0ad4","external_labels":[1],"members":[{"current_id":1,"factor":[1.0,0.0],"selector_domain_id":7}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"20f4ac2ac00a74044681ff5aab37d2abc31e375d1473e8b0a8198af4432c0ad4","status":"proven","transition_contract_ids":[]},"representative_current_id":1,"source_class":true},{"class_id":"helicity-current-sha256:099ab31b76e6d55df90ac39798446ac28b3bbca173b59d516940595c4f951ec7","external_labels":[2],"members":[{"current_id":2,"factor":[1.0,0.0],"selector_domain_id":14}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"099ab31b76e6d55df90ac39798446ac28b3bbca173b59d516940595c4f951ec7","status":"proven","transition_contract_ids":[]},"representative_current_id":2,"source_class":true},{"class_id":"helicity-current-sha256:1e587b1494ff92be5c28fa63676222417931b6d82f93eb12232f90e10bc22924","external_labels":[2],"members":[{"current_id":3,"factor":[1.0,0.0],"selector_domain_id":18}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"1e587b1494ff92be5c28fa63676222417931b6d82f93eb12232f90e10bc22924","status":"proven","transition_contract_ids":[]},"representative_current_id":3,"source_class":true},{"class_id":"helicity-current-sha256:e9562e75376f52432b31f6754f778a8f5ab63333f8169428a2bbb50dcee492d0","external_labels":[3],"members":[{"current_id":4,"factor":[1.0,0.0],"selector_domain_id":22},{"current_id":5,"factor":[1.0,0.0],"selector_domain_id":23},{"current_id":6,"factor":[1.0,0.0],"selector_domain_id":24}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"e9562e75376f52432b31f6754f778a8f5ab63333f8169428a2bbb50dcee492d0","status":"proven","transition_contract_ids":[]},"representative_current_id":4,"source_class":true},{"class_id":"helicity-current-sha256:11b0f53aeaf5619f44673e1ac3a81db4742588d5f49c08fa7f514b0556bcada7","external_labels":[2,3],"members":[{"current_id":7,"factor":[1.0,0.0],"selector_domain_id":15},{"current_id":8,"factor":[1.0,0.0],"selector_domain_id":16},{"current_id":9,"factor":[1.0,0.0],"selector_domain_id":17}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"11b0f53aeaf5619f44673e1ac3a81db4742588d5f49c08fa7f514b0556bcada7","status":"proven","transition_contract_ids":["builtin-sm:fermion-vector-to-fermion"]},"representative_current_id":7,"source_class":false},{"class_id":"helicity-current-sha256:7690f565a16395860f30f2971bfea1c77a8db9d3e60d91d4e6b2d2f5549153a8","external_labels":[2,3],"members":[{"current_id":10,"factor":[1.0,0.0],"selector_domain_id":19},{"current_id":11,"factor":[1.0,0.0],"selector_domain_id":20},{"current_id":12,"factor":[1.0,0.0],"selector_domain_id":21}],"proof":{"algorithm":"canonical-source-transition-dependency-shape-v1","digest":"7690f565a16395860f30f2971bfea1c77a8db9d3e60d91d4e6b2d2f5549153a8","status":"proven","transition_contract_ids":["builtin-sm:fermion-vector-to-fermion"]},"representative_current_id":10,"source_class":false}],"residual_current_ids":[],"residual_root_ids":[],"selector_domains":[{"complete":false,"id":0,"source_states":[{"external_label":1,"helicity":-1}]},{"complete":true,"id":1,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":-1}]},{"complete":true,"id":2,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":0}]},{"complete":true,"id":3,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":1}]},{"complete":true,"id":4,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":-1}]},{"complete":true,"id":5,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":0}]},{"complete":true,"id":6,"source_states":[{"external_label":1,"helicity":-1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":1}]},{"complete":false,"id":7,"source_states":[{"external_label":1,"helicity":1}]},{"complete":true,"id":8,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":-1}]},{"complete":true,"id":9,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":0}]},{"complete":true,"id":10,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":-1},{"external_label":3,"helicity":1}]},{"complete":true,"id":11,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":-1}]},{"complete":true,"id":12,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":0}]},{"complete":true,"id":13,"source_states":[{"external_label":1,"helicity":1},{"external_label":2,"helicity":1},{"external_label":3,"helicity":1}]},{"complete":false,"id":14,"source_states":[{"external_label":2,"helicity":-1}]},{"complete":false,"id":15,"source_states":[{"external_label":2,"helicity":-1},{"external_label":3,"helicity":-1}]},{"complete":false,"id":16,"source_states":[{"external_label":2,"helicity":-1},{"external_label":3,"helicity":0}]},{"complete":false,"id":17,"source_states":[{"external_label":2,"helicity":-1},{"external_label":3,"helicity":1}]},{"complete":false,"id":18,"source_states":[{"external_label":2,"helicity":1}]},{"complete":false,"id":19,"source_states":[{"external_label":2,"helicity":1},{"external_label":3,"helicity":-1}]},{"complete":false,"id":20,"source_states":[{"external_label":2,"helicity":1},{"external_label":3,"helicity":0}]},{"complete":false,"id":21,"source_states":[{"external_label":2,"helicity":1},{"external_label":3,"helicity":1}]},{"complete":false,"id":22,"source_states":[{"external_label":3,"helicity":-1}]},{"complete":false,"id":23,"source_states":[{"external_label":3,"helicity":0}]},{"complete":false,"id":24,"source_states":[{"external_label":3,"helicity":1}]}],"source_state_mappings":[{"chirality":1,"current_id":0,"declared_state_index":0,"external_label":1,"factor":[1.0,0.0],"helicity":-1,"recurrence_class_id":"helicity-current-sha256:8c682736c4ae8e56465e5fd7b1c300f8379118af92486f9a571ca3a915572ccf","representative_current_id":0,"selector_domain_id":0,"source_contract_digest":"44fa57cb6571ac7524f9e30554d29cf20f6e4fbdfd443edf0afdbc8617c0620e","spin_state":1},{"chirality":-1,"current_id":1,"declared_state_index":1,"external_label":1,"factor":[1.0,0.0],"helicity":1,"recurrence_class_id":"helicity-current-sha256:20f4ac2ac00a74044681ff5aab37d2abc31e375d1473e8b0a8198af4432c0ad4","representative_current_id":1,"selector_domain_id":7,"source_contract_digest":"44fa57cb6571ac7524f9e30554d29cf20f6e4fbdfd443edf0afdbc8617c0620e","spin_state":-1},{"chirality":1,"current_id":2,"declared_state_index":0,"external_label":2,"factor":[1.0,0.0],"helicity":-1,"recurrence_class_id":"helicity-current-sha256:099ab31b76e6d55df90ac39798446ac28b3bbca173b59d516940595c4f951ec7","representative_current_id":2,"selector_domain_id":14,"source_contract_digest":"98b493b16090bfd79101115ca8697310721cebf636cced331f90bcbc32cd9ef6","spin_state":1},{"chirality":-1,"current_id":3,"declared_state_index":1,"external_label":2,"factor":[1.0,0.0],"helicity":1,"recurrence_class_id":"helicity-current-sha256:1e587b1494ff92be5c28fa63676222417931b6d82f93eb12232f90e10bc22924","representative_current_id":3,"selector_domain_id":18,"source_contract_digest":"98b493b16090bfd79101115ca8697310721cebf636cced331f90bcbc32cd9ef6","spin_state":-1},{"chirality":0,"current_id":4,"declared_state_index":0,"external_label":3,"factor":[1.0,0.0],"helicity":-1,"recurrence_class_id":"helicity-current-sha256:e9562e75376f52432b31f6754f778a8f5ab63333f8169428a2bbb50dcee492d0","representative_current_id":4,"selector_domain_id":22,"source_contract_digest":"c2bcedb500cc3f9692e3626cf25b332071eba27ad54025db1ddeaa31e0b57124","spin_state":-1},{"chirality":0,"current_id":5,"declared_state_index":1,"external_label":3,"factor":[1.0,0.0],"helicity":0,"recurrence_class_id":"helicity-current-sha256:e9562e75376f52432b31f6754f778a8f5ab63333f8169428a2bbb50dcee492d0","representative_current_id":4,"selector_domain_id":23,"source_contract_digest":"c2bcedb500cc3f9692e3626cf25b332071eba27ad54025db1ddeaa31e0b57124","spin_state":0},{"chirality":0,"current_id":6,"declared_state_index":2,"external_label":3,"factor":[1.0,0.0],"helicity":1,"recurrence_class_id":"helicity-current-sha256:e9562e75376f52432b31f6754f778a8f5ab63333f8169428a2bbb50dcee492d0","representative_current_id":4,"selector_domain_id":24,"source_contract_digest":"c2bcedb500cc3f9692e3626cf25b332071eba27ad54025db1ddeaa31e0b57124","spin_state":1}],"structural_zero_selector_domain_ids":[1,2,3,11,12,13]},"kind":"pyamplicol-runtime-execution-plan","model":{"particles":[{"mass":0.0,"mass_parameter":null,"pdg":1},{"mass":91.188,"mass_parameter":"particle.23.mass","pdg":23}]},"model_parameters":[{"default":0.0075467711139788835,"kind":"normalization","name":"normalization.alpha_ew","parameter_index":0},{"default":0.118,"kind":"normalization","name":"normalization.alpha_s_me_check","parameter_index":1},{"default":173.0,"kind":"particle_mass","name":"particle.6.mass","parameter_index":2,"pdg":6},{"default":1.4915,"kind":"particle_width","name":"particle.6.width","parameter_index":3,"pdg":6},{"default":91.188,"kind":"particle_mass","name":"particle.23.mass","parameter_index":4,"pdg":23},{"default":2.441404,"kind":"particle_width","name":"particle.23.width","parameter_index":5,"pdg":23},{"default":80.41900244575616,"kind":"particle_mass","name":"particle.24.mass","parameter_index":6,"pdg":24},{"default":2.0476,"kind":"particle_width","name":"particle.24.width","parameter_index":7,"pdg":24},{"default":125.0,"kind":"particle_mass","name":"particle.25.mass","parameter_index":8,"pdg":25},{"default":0.006382339,"kind":"particle_width","name":"particle.25.width","parameter_index":9,"pdg":25},{"default":-1.0244420275940371,"kind":"coupling_component","name":"coupling.10.1_23_1.component_0","parameter_index":10},{"default":0.17818666745287456,"kind":"coupling_component","name":"coupling.10.1_23_1.component_1","parameter_index":11}],"momentum_slots":[{"component_start":0,"component_stop":4,"external_labels":[1],"momentum_mask":1,"momentum_slot_id":0,"real_valued":true},{"component_start":4,"component_stop":8,"external_labels":[2],"momentum_mask":2,"momentum_slot_id":1,"real_valued":true},{"component_start":8,"component_stop":12,"external_labels":[3],"momentum_mask":4,"momentum_slot_id":2,"real_valued":true},{"component_start":12,"component_stop":16,"external_labels":[2,3],"momentum_mask":6,"momentum_slot_id":3,"real_valued":true}],"normalization":{"average_factor":36.0,"color_factor":3.0,"electroweak_coupling_power":1,"global_coupling_factor":0.18967104551999775,"identical_factor":1.0,"qcd_coupling_power":0},"parameter_layout":{"model_parameter_count":12,"momentum_components_real":true,"momentum_parameter_count":16,"parameter_count_if_flattened":40,"real_valued_inputs":[12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39],"source_component_parameter_count":12,"source_components_complex":true,"value_component_count":16},"process":"d d~ > z","process_key":"d_dbar_to_z","schema_version":3,"source_fill":{"source_count":5,"sources":[{"anti_particle_id":1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":0,"current_component_stop":2,"current_id":0,"dimension":2,"helicity_ancestry":"0x1","input_momentum_slot":0,"leg_label":1,"outgoing_pdg":-1,"particle_id":-1,"physical_pdg":1,"side":"initial","source_basis":"weyl-chiral","source_helicity":-1,"source_id":0,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"antiparticle","source_parameter_start":0,"source_parameter_stop":2,"spin_state":1,"value_slot":{"component_start":0,"component_stop":2,"current_id":0,"dimension":2,"value_slot_id":0,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":2,"current_component_stop":4,"current_id":1,"dimension":2,"helicity_ancestry":"0x2","input_momentum_slot":0,"leg_label":1,"outgoing_pdg":-1,"particle_id":-1,"physical_pdg":1,"side":"initial","source_basis":"weyl-chiral","source_helicity":1,"source_id":1,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"antiparticle","source_parameter_start":2,"source_parameter_stop":4,"spin_state":-1,"value_slot":{"component_start":2,"component_stop":4,"current_id":1,"dimension":2,"value_slot_id":1,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":-1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":4,"current_component_stop":6,"current_id":2,"dimension":2,"helicity_ancestry":"0x4","input_momentum_slot":1,"leg_label":2,"outgoing_pdg":1,"particle_id":1,"physical_pdg":-1,"side":"initial","source_basis":"weyl-chiral","source_helicity":-1,"source_id":2,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"particle","source_parameter_start":4,"source_parameter_stop":6,"spin_state":1,"value_slot":{"component_start":4,"component_stop":6,"current_id":2,"dimension":2,"value_slot_id":2,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":-1,"applied_crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"chirality":-1,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[0],"sector_id":0},"crossing":"negate-incoming-momentum","current_component_start":6,"current_component_stop":8,"current_id":3,"dimension":2,"helicity_ancestry":"0x8","input_momentum_slot":1,"leg_label":2,"outgoing_pdg":1,"particle_id":1,"physical_pdg":-1,"side":"initial","source_basis":"weyl-chiral","source_helicity":1,"source_id":3,"source_ir":{"basis":"weyl-chiral","component_dimension":2,"crossing":{"chirality_factor":-1,"helicity_factor":1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"mass_parameter":null,"states":[{"chirality":-1,"helicity":-1,"spin_state":-1},{"chirality":1,"helicity":1,"spin_state":1}],"statistics":"fermion","wavefunction_family":"fermion","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"particle","source_parameter_start":6,"source_parameter_stop":8,"spin_state":-1,"value_slot":{"component_start":6,"component_stop":8,"current_id":3,"dimension":2,"value_slot_id":3,"variant":"source"},"wavefunction_kind":"fermion"},{"anti_particle_id":23,"applied_crossing":{"chirality_factor":1,"helicity_factor":1,"momentum_transform":"identity","phase":[1.0,0.0],"spin_state_factor":1},"chirality":0,"color_state":{"accuracy":"lc","basis_key":[],"line_groups":[],"sector_id":0},"crossing":"identity","current_component_start":8,"current_component_stop":12,"current_id":4,"dimension":4,"helicity_ancestry":"0x10","input_momentum_slot":2,"leg_label":3,"outgoing_pdg":23,"particle_id":23,"physical_pdg":23,"side":"final","source_basis":"lorentz-vector","source_helicity":-1,"source_id":4,"source_ir":{"basis":"lorentz-vector","component_dimension":4,"crossing":{"chirality_factor":1,"helicity_factor":-1,"momentum_transform":"negate-four-momentum","phase":[1.0,0.0],"spin_state_factor":-1},"identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"mass_parameter":null,"states":[{"chirality":0,"helicity":-1,"spin_state":-1},{"chirality":0,"helicity":0,"spin_state":0},{"chirality":0,"helicity":1,"spin_state":1}],"statistics":"boson","wavefunction_family":"vector","width_parameter":null},"source_kind":"external-wavefunction","source_orientation":"self-conjugate","source_parameter_start":8,"source_parameter_stop":12,"spin_state":-1,"value_slot":{"component_start":8,"component_stop":12,"current_id":4,"dimension":4,"value_slot_id":4,"variant":"source"},"wavefunction_kind":"vector"}]},"stages":[{"input_current_ids":[2,3,4],"input_value_slot_ids":[2,3,4],"interaction_count":2,"interaction_ids":[0,1],"interactions":[],"interactions_compacted":true,"output_current_ids":[5,6],"output_value_slot_ids":[5,6],"stage_index":1,"stage_kind":"current-combine","subset_size":2}],"value_storage":{"component_count":16,"metadata_compacted":true,"number_type":"complex","value_slots":[{"applies_propagator":false,"chirality":1,"component_start":0,"component_stop":2,"current_component_start":0,"current_component_stop":2,"current_id":0,"dimension":2,"external_labels":[1],"external_mask":1,"is_source":true,"momentum_mask":1,"particle_id":-1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":-1,"width_parameter":null},"value_slot_id":0,"variant":"source"},{"applies_propagator":false,"chirality":-1,"component_start":2,"component_stop":4,"current_component_start":2,"current_component_stop":4,"current_id":1,"dimension":2,"external_labels":[1],"external_mask":1,"is_source":true,"momentum_mask":1,"particle_id":-1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d","anti_display_name":"d","anti_pdg_label":1,"canonical_id":"model:built-in-sm-leading-color:state:d~","display_name":"d~","orientation":"antiparticle","pdg_label":-1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":-1,"width_parameter":null},"value_slot_id":1,"variant":"source"},{"applies_propagator":false,"chirality":1,"component_start":4,"component_stop":6,"current_component_start":4,"current_component_stop":6,"current_id":2,"dimension":2,"external_labels":[2],"external_mask":2,"is_source":true,"momentum_mask":2,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":2,"variant":"source"},{"applies_propagator":false,"chirality":-1,"component_start":6,"component_stop":8,"current_component_start":6,"current_component_stop":8,"current_id":3,"dimension":2,"external_labels":[2],"external_mask":2,"is_source":true,"momentum_mask":2,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":3,"variant":"source"},{"applies_propagator":false,"chirality":0,"component_start":8,"component_stop":12,"current_component_start":8,"current_component_stop":12,"current_id":4,"dimension":4,"external_labels":[3],"external_mask":4,"is_source":true,"momentum_mask":4,"particle_id":23,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"symbolica","basis":"lorentz-vector","chirality":0,"custom_source":null,"denominator":"momentum_squared-mass_squared+i*mass*width","description":"massive vector propagator with width","full_tensor_network_ready":true,"gauge":"unitary","goldstone_policy":"absorbed","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:z","anti_display_name":"z","anti_pdg_label":23,"canonical_id":"model:built-in-sm-leading-color:state:z","display_name":"z","orientation":"self-conjugate","pdg_label":23,"self_conjugate":true,"species_id":"model:built-in-sm-leading-color:species:z"},"kernel":"massive_vector_unitary_gauge","kind":"vector","mass_class":"massive","mass_parameter":null,"numerator":"-i*(metric-momentum_outer/mass_squared)","particle_id":23,"width_parameter":null},"value_slot_id":4,"variant":"source"},{"applies_propagator":false,"chirality":1,"component_start":12,"component_stop":14,"current_component_start":12,"current_component_stop":14,"current_id":5,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":5,"variant":"unpropagated"},{"applies_propagator":false,"chirality":-1,"component_start":14,"component_stop":16,"current_component_start":14,"current_component_stop":16,"current_id":6,"dimension":2,"external_labels":[2,3],"external_mask":6,"is_source":false,"momentum_mask":6,"particle_id":1,"propagator":{"applies_propagator":true,"auxiliary_policy":null,"backend":"spenso","basis":"weyl-chiral","chirality":-1,"custom_source":null,"denominator":"momentum_squared","description":"massless Weyl fermion propagator","full_tensor_network_ready":true,"gauge":null,"goldstone_policy":"not-applicable","identity":{"anti_canonical_id":"model:built-in-sm-leading-color:state:d~","anti_display_name":"d~","anti_pdg_label":-1,"canonical_id":"model:built-in-sm-leading-color:state:d","display_name":"d","orientation":"particle","pdg_label":1,"self_conjugate":false,"species_id":"model:built-in-sm-leading-color:species:d"},"kernel":"weyl_fermion","kind":"weyl-fermion","mass_class":"massless","mass_parameter":null,"numerator":"i*weyl_slash(momentum)","particle_id":1,"width_parameter":null},"value_slot_id":6,"variant":"unpropagated"}]}},"schema_version":3}
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/d_dbar_to_z/physics.json b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/d_dbar_to_z/physics.json
new file mode 100644
index 0000000000..061afd6fc6
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/d_dbar_to_z/physics.json
@@ -0,0 +1 @@
+{"color_accuracy":"lc","color_components":[{"coefficient":1.0,"computed":true,"id":"flow:2,1","index":0,"kind":"lc-flow","representative_id":"flow:2,1","word":[2,1]}],"coverage":{"color":"complete","color_kind":"physical-lc-flows","helicities":"complete","structural_zero_helicity_count":6},"extensions":{"normalization":{"average_factor":36,"color_accuracy":"lc","color_factor":3,"coupling_policy":"stage evaluators include local vertex couplings","couplings_in_stage_evaluators":true,"electroweak_coupling_power":1,"global_coupling_factor":0.18967104551999775,"identical_factor":1,"qcd_coupling_power":0},"process_key":"d_dbar_to_z","runtime_selectors":{"axes":{"color_flow":{"generation_coverage":"complete","generation_selection":[],"runtime_contract":"complete-reusable"},"helicity":{"generation_coverage":"complete","generation_selection":{},"runtime_contract":"complete-reusable"}},"contract_version":1,"generation_specialized_axes":[],"helicity_recurrence":{"contract_version":1,"execution":"materialized-recurrence-quotient","materialization_strategy":"quotient","materialized_amplitude_count":2,"materialized_current_count":7,"proof_algorithm":"canonical-source-transition-dependency-shape-v1","proof_amplitude_count":6,"proof_counts":{"amplitude_class_count":2,"optimized_amplitude_class_count":2,"optimized_current_count":9,"optimized_recurrence_class_count":3,"physical_helicity_count":12,"recurrence_class_count":7,"residual_amplitude_count":0,"residual_current_count":0,"source_state_mapping_count":7,"structural_zero_helicity_count":6},"proof_current_count":13,"status":"available"},"kind":"pyamplicol-runtime-selectors","provenance":"pyamplicol-runtime-selectors-v1"},"selected_source_helicities":{}},"external_particles":[{"index":0,"label":1,"momentum_components":["E","px","py","pz"],"momentum_slot":0,"particle":"d","pdg":1,"role":"initial"},{"index":1,"label":2,"momentum_components":["E","px","py","pz"],"momentum_slot":1,"particle":"d~","pdg":-1,"role":"initial"},{"index":2,"label":3,"momentum_components":["E","px","py","pz"],"momentum_slot":2,"particle":"z","pdg":23,"role":"final"}],"helicities":[{"coefficient":0.0,"computed":false,"id":"h:-1,-1,-1","index":0,"representative_id":"h:-1,-1,-1","structural_zero":true,"values":[-1,-1,-1]},{"coefficient":0.0,"computed":false,"id":"h:-1,-1,+0","index":1,"representative_id":"h:-1,-1,+0","structural_zero":true,"values":[-1,-1,0]},{"coefficient":0.0,"computed":false,"id":"h:-1,-1,+1","index":2,"representative_id":"h:-1,-1,+1","structural_zero":true,"values":[-1,-1,1]},{"coefficient":1.0,"computed":true,"id":"h:-1,+1,-1","index":3,"representative_id":"h:-1,+1,-1","structural_zero":false,"values":[-1,1,-1]},{"coefficient":1.0,"computed":false,"id":"h:-1,+1,+0","index":4,"representative_id":"h:-1,+1,-1","structural_zero":false,"values":[-1,1,0]},{"coefficient":1.0,"computed":false,"id":"h:-1,+1,+1","index":5,"representative_id":"h:-1,+1,-1","structural_zero":false,"values":[-1,1,1]},{"coefficient":1.0,"computed":true,"id":"h:+1,-1,-1","index":6,"representative_id":"h:+1,-1,-1","structural_zero":false,"values":[1,-1,-1]},{"coefficient":1.0,"computed":false,"id":"h:+1,-1,+0","index":7,"representative_id":"h:+1,-1,-1","structural_zero":false,"values":[1,-1,0]},{"coefficient":1.0,"computed":false,"id":"h:+1,-1,+1","index":8,"representative_id":"h:+1,-1,-1","structural_zero":false,"values":[1,-1,1]},{"coefficient":0.0,"computed":false,"id":"h:+1,+1,-1","index":9,"representative_id":"h:+1,+1,-1","structural_zero":true,"values":[1,1,-1]},{"coefficient":0.0,"computed":false,"id":"h:+1,+1,+0","index":10,"representative_id":"h:+1,+1,+0","structural_zero":true,"values":[1,1,0]},{"coefficient":0.0,"computed":false,"id":"h:+1,+1,+1","index":11,"representative_id":"h:+1,+1,+1","structural_zero":true,"values":[1,1,1]}],"kind":"pyamplicol-resolved-physics","model_parameters":[{"default_imaginary":0.0,"default_real":0.0075467711139788835,"kind":"normalization","mutable":true,"name":"normalization.alpha_ew"},{"default_imaginary":0.0,"default_real":0.118,"kind":"normalization","mutable":true,"name":"normalization.alpha_s_me_check"},{"default_imaginary":0.0,"default_real":173.0,"kind":"mass","mutable":true,"name":"particle.6.mass"},{"default_imaginary":0.0,"default_real":1.4915,"kind":"width","mutable":true,"name":"particle.6.width"},{"default_imaginary":0.0,"default_real":91.188,"kind":"mass","mutable":true,"name":"particle.23.mass"},{"default_imaginary":0.0,"default_real":2.441404,"kind":"width","mutable":true,"name":"particle.23.width"},{"default_imaginary":0.0,"default_real":80.41900244575616,"kind":"mass","mutable":true,"name":"particle.24.mass"},{"default_imaginary":0.0,"default_real":2.0476,"kind":"width","mutable":true,"name":"particle.24.width"},{"default_imaginary":0.0,"default_real":125.0,"kind":"mass","mutable":true,"name":"particle.25.mass"},{"default_imaginary":0.0,"default_real":0.006382339,"kind":"width","mutable":true,"name":"particle.25.width"},{"default_imaginary":0.0,"default_real":-1.0244420275940371,"kind":"coupling","mutable":true,"name":"coupling.10.1_23_1.component_0"},{"default_imaginary":0.0,"default_real":0.17818666745287456,"kind":"coupling","mutable":true,"name":"coupling.10.1_23_1.component_1"}],"process":"d d~ > z","process_id":"d_dbar_to_z","reduction":{"groups":[{"id":"reduction:0","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:+1,-1,-1","h:+1,-1,+0","h:+1,-1,+1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:+1,-1,-1"},{"id":"reduction:1","physical_color_ids":["flow:2,1"],"physical_helicity_ids":["h:-1,+1,-1","h:-1,+1,+0","h:-1,+1,+1"],"representative_color_id":"flow:2,1","representative_helicity_id":"h:-1,+1,-1"}],"kind":"lc-diagonal"},"schema_version":1,"selectors":{"color_flow":true,"contracted_color":false,"helicity":true}}
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/d_dbar_to_z/validation-momenta.json b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/d_dbar_to_z/validation-momenta.json
new file mode 100644
index 0000000000..209c2c78a2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/d_dbar_to_z/validation-momenta.json
@@ -0,0 +1,40 @@
+{
+  "available": true,
+  "error": null,
+  "kind": "pyamplicol-rusticol-validation-momenta",
+  "points": [
+    [
+      {
+        "momentum": [
+          "45.594000000000001",
+          "0",
+          "0",
+          "45.594000000000001"
+        ],
+        "pdg": 1
+      },
+      {
+        "momentum": [
+          "45.594000000000001",
+          "0",
+          "0",
+          "-45.594000000000001"
+        ],
+        "pdg": -1
+      },
+      {
+        "momentum": [
+          "91.188000000000002",
+          "0",
+          "0",
+          "0"
+        ],
+        "pdg": 23
+      }
+    ]
+  ],
+  "process": "d d~ > z",
+  "process_id": "d_dbar_to_z",
+  "schema_version": 1,
+  "seed": 12345
+}
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/evaluators.json b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/evaluators.json
new file mode 100644
index 0000000000..c69209e976
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/artifact/processes/evaluators.json
@@ -0,0 +1,26 @@
+{
+  "kind": "pyamplicol-runtime-execution-set",
+  "processes": [
+    {
+      "manifest_path": "d_dbar_to_z/execution.json",
+      "process_id": "d_dbar_to_z",
+      "required_runtime_capabilities": [
+        "compiled-plane-arena-v1",
+        "rusticol.compiled.color-topology-lanes.v1",
+        "rusticol.compiled.helicity-dual-lane.v1",
+        "rusticol.compiled.helicity-selector-union.v1",
+        "rusticol.compiled.runtime-selectors.v1",
+        "symjit.application.complex-f64.v1"
+      ]
+    }
+  ],
+  "required_runtime_capabilities": [
+    "compiled-plane-arena-v1",
+    "rusticol.compiled.color-topology-lanes.v1",
+    "rusticol.compiled.helicity-dual-lane.v1",
+    "rusticol.compiled.helicity-selector-union.v1",
+    "rusticol.compiled.runtime-selectors.v1",
+    "symjit.application.complex-f64.v1"
+  ],
+  "schema_version": 3
+}
diff --git a/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/expected.json b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/expected.json
new file mode 100644
index 0000000000..8b02d99476
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/assets/selftest/portable-64le/expected.json
@@ -0,0 +1,70 @@
+{
+  "artifact_path": "artifact",
+  "color_ids": [
+    "flow:2,1"
+  ],
+  "compatible_targets": [
+    "aarch64-apple-darwin",
+    "x86_64-apple-darwin",
+    "x86_64-unknown-linux-gnu"
+  ],
+  "helicity_ids": [
+    "h:-1,-1,-1",
+    "h:-1,-1,+0",
+    "h:-1,-1,+1",
+    "h:-1,+1,-1",
+    "h:-1,+1,+0",
+    "h:-1,+1,+1",
+    "h:+1,-1,-1",
+    "h:+1,-1,+0",
+    "h:+1,-1,+1",
+    "h:+1,+1,-1",
+    "h:+1,+1,+0",
+    "h:+1,+1,+1"
+  ],
+  "momenta": [
+    [
+      [
+        45.594,
+        0.0,
+        0.0,
+        45.594
+      ],
+      [
+        45.594,
+        0.0,
+        0.0,
+        -45.594
+      ],
+      [
+        91.188,
+        0.0,
+        0.0,
+        0.0
+      ]
+    ]
+  ],
+  "process": "d d~ > z",
+  "process_id": "d_dbar_to_z",
+  "resolved_shape": [
+    1,
+    12,
+    1
+  ],
+  "schema_version": 1,
+  "serialization": {
+    "endianness": "little",
+    "kind": "symjit-application-mir-v3",
+    "load_behavior": "recompile-mir-for-loading-host",
+    "source_optimization_level": 2,
+    "word_size_bits": 64
+  },
+  "source_generation_target": "portable-64le",
+  "target": "portable-64le",
+  "total": [
+    [
+      142.10653372833232,
+      0.0
+    ]
+  ]
+}
diff --git a/pyamplicol/src/pyamplicol/benchmarking.py b/pyamplicol/src/pyamplicol/benchmarking.py
new file mode 100644
index 0000000000..2a62981c46
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/benchmarking.py
@@ -0,0 +1,2774 @@
+# SPDX-License-Identifier: 0BSD
+"""Typed calibrated runtime profiling for Rusticol runtime backends."""
+
+from __future__ import annotations
+
+import math
+import os
+import platform
+import statistics
+import threading
+import time
+import tomllib
+import warnings
+from collections.abc import Callable, Mapping, Sequence
+from copy import deepcopy
+from dataclasses import dataclass, fields, replace
+from pathlib import Path
+from typing import Any, Literal, cast
+
+from pyamplicol.api.errors import EvaluationError
+from pyamplicol.api.protocols import Momenta, RuntimeBackend
+from pyamplicol.api.results import (
+    BenchmarkComponentTiming,
+    BenchmarkProfileCounters,
+    BenchmarkResult,
+    BenchmarkStageTiming,
+    BenchmarkStatistics,
+    BenchmarkTimingBreakdown,
+    ProcessPhysics,
+)
+from pyamplicol.config import BenchmarkConfig, RunConfig
+from pyamplicol.reporting import (
+    ProgressEnd,
+    ProgressSink,
+    ProgressStart,
+    ProgressUpdate,
+)
+
+_MAX_SAMPLE_RUNTIME_SECONDS = 0.25
+_MAX_CALIBRATION_BLOCKS = 2
+_MAX_REPETITIONS_PER_SAMPLE = 1_000_000_000
+# The calibrated runtime may be optimistic or the host may speed up after
+# warmup. Keep extending complete blocks, but fail closed if timing changes so
+# drastically that four times the initial plan still cannot reach the target.
+_MAX_TARGET_RUNTIME_SAMPLE_FACTOR = 4
+_CALIBRATION_LOWER_RATIO = 0.8
+_CALIBRATION_UPPER_RATIO = 1.25
+_MIN_CLOCK_INTERVAL_SECONDS = 1.0e-12
+_MAX_NATIVE_PROFILE_SAMPLES = 8
+_LC_TOPOLOGY_REPLAY_LAYOUT = "topology-replay"
+_LC_ALL_FLOW_UNION_LAYOUT = "all-flow-union"
+_LC_TOPOLOGY_REPLAY_PROFILE_RECOMMENDATION = (
+    "this LC topology-replay artifact is being profiled outside its optimized "
+    "single-flow/helicity-sum workload; pass exactly one --color-flow and no "
+    "--helicity, or regenerate with --lc-flow-layout all-flow-union for the "
+    "all-flows/single-helicity workload"
+)
+_LC_ALL_FLOW_UNION_PROFILE_RECOMMENDATION = (
+    "this LC all-flow-union artifact is being profiled outside its optimized "
+    "all-flows/single-helicity workload; pass exactly one --helicity and no "
+    "--color-flow"
+)
+_LC_PROFILE_WARNING_ATTRIBUTE = "_pyamplicol_non_hot_profile_warning_emitted"
+_LC_PROFILE_WARNING_LOCK = threading.Lock()
+_LC_PROFILE_WARNING_FALLBACK_OWNERS: dict[int, object] = {}
+_EVALUATOR_TOTAL_SAMPLE_CONTRACT = "accumulated-repeated-warmed-evaluator-total-v1"
+_RECURRENCE_LIKE_EXECUTION_MODES = {"recurrence", "on-the-fly"}
+_OTF_RUNTIME_STATE_CENSUS_KIND = "rusticol-on-the-fly-runtime-state-census-v1"
+_OTF_FAMILY_CACHE_POLICY = "last-family-only"
+_OTF_FAMILY_CACHE_LIMIT = 1
+_OTF_RUNTIME_STATE_COUNT_FIELDS = (
+    "process_preparation_count",
+    "retained_family_count",
+    "pending_family_count",
+    "retained_selection_count",
+    "retained_request_count",
+    "retained_amplitude_destination_count",
+    "retained_executor_handle_count",
+    "retained_query_local_trace_count",
+    "retained_embedded_lookup_key_count",
+    "semantic_executor_binding_count",
+)
+_OTF_RETAINED_STATE_EXECUTABLE_COUNT_FIELDS = (
+    "retained_amplitude_destination_count",
+    "retained_executor_handle_count",
+    "semantic_executor_binding_count",
+)
+_OTF_ACTIVE_FAMILY_COUNT_FIELDS = (
+    "query_count",
+    "union_unique_current_count",
+    "union_unique_current_component_count",
+    "union_source_rows",
+    "union_contribution_rows",
+    "union_finalization_rows",
+    "union_closure_rows",
+    "union_amplitude_destination_count",
+    "union_source_executor_call_groups",
+    "union_contribution_executor_call_groups",
+    "union_finalization_executor_call_groups",
+    "union_closure_executor_call_groups",
+)
+_OTF_OPERATION_ROLES = ("source", "contribution", "finalization", "closure")
+_COMPILED_DIRECT_ARENA_COUNTER_KEYS = (
+    "compiled_direct_arena_engine_count",
+    "compiled_direct_arena_call_count",
+    "compiled_direct_arena_boundary_input_bytes",
+    "compiled_direct_arena_boundary_current_output_bytes",
+    "compiled_direct_arena_boundary_amplitude_output_bytes",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class _Calibration:
+    sample_count: int
+    repetitions_per_sample: int
+    target_sample_seconds: float
+    probe_seconds: float
+    block_count: int
+    evaluation_count: int
+    elapsed_seconds: float
+
+
+@dataclass(frozen=True, slots=True)
+class _CompactBenchmarkContext:
+    process_id: str
+    process_expression: str
+    color_accuracy: str
+    helicity_count: int
+    color_count: int
+    selected_color_ids: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _NativeProfileSample:
+    execution_mode: str | None
+    compiled_direct_arena_active: bool
+    wall_time: float | None
+    native_input_pack_time: float | None
+    native_input_crossing_time: float | None
+    orchestration_time: float | None
+    state_prepare_time: float | None
+    state_clear_time: float | None
+    source_fill_time: float | None
+    momentum_input_setup_time: float | None
+    momentum_setup_time: float | None
+    model_parameter_setup_time: float | None
+    stage_input_pack_time: float | None
+    stage_leaf_input_pack_time: float | None
+    stage_evaluator_call_time: float
+    stage_backend_call_time: float | None
+    stage_evaluator_output_gather_time: float | None
+    output_assign_time: float | None
+    amplitude_input_pack_time: float | None
+    amplitude_evaluator_call_time: float | None
+    amplitude_leaf_input_pack_time: float | None
+    amplitude_backend_call_time: float | None
+    amplitude_evaluator_output_gather_time: float | None
+    amplitude_output_remap_time: float | None
+    reduction_time: float | None
+    total_materialization_time: float | None
+    final_output_copy_time: float | None
+    selector_planner_time: float | None
+    selector_gather_time: float | None
+    selector_scatter_time: float | None
+    other_core_time: float | None
+    stage_input_pack_times: tuple[float, ...] | None
+    stage_leaf_input_pack_times: tuple[float, ...] | None
+    stage_evaluator_call_times: tuple[float, ...] | None
+    stage_backend_call_times: tuple[float, ...] | None
+    stage_evaluator_output_gather_times: tuple[float, ...] | None
+    stage_output_assign_times: tuple[float, ...] | None
+    eager_initialize_time: float | None
+    eager_gather_time: float | None
+    eager_kernel_call_time: float | None
+    eager_invocation_scatter_time: float | None
+    eager_finalization_time: float | None
+    eager_scatter_finalization_time: float | None
+    eager_closure_time: float | None
+    eager_copy_out_time: float | None
+    recurrence_momentum_fill_time: float | None
+    recurrence_union_source_fill_time: float | None
+    recurrence_schedule_time: float | None
+    recurrence_source_kernel_time: float | None
+    recurrence_contribution_kernel_time: float | None
+    recurrence_finalization_time: float | None
+    recurrence_closure_time: float | None
+    recurrence_replay_output_mapping_time: float | None
+    counters: _NativeProfileCounterSample | None
+
+
+@dataclass(frozen=True, slots=True)
+class _NativeProfileCounterSample:
+    native_input_components_per_point: float | None
+    native_input_pack_bytes_per_point: float | None
+    native_input_crossing_bytes_per_point: float | None
+    state_components_per_point: float | None
+    state_clear_components_per_point: float | None
+    source_components_per_point: float | None
+    momentum_components_per_point: float | None
+    model_parameter_components_per_point: float | None
+    stage_input_copy_components_per_point: float | None
+    stage_leaf_input_copy_components_per_point: float | None
+    stage_evaluator_output_gather_components_per_point: float | None
+    stage_output_assign_components_per_point: float | None
+    amplitude_input_copy_components_per_point: float | None
+    amplitude_leaf_input_copy_components_per_point: float | None
+    amplitude_evaluator_output_gather_components_per_point: float | None
+    amplitude_output_remap_components_per_point: float | None
+    reduction_input_components_per_point: float | None
+    selector_gather_points_per_point: float | None
+    selector_gather_bytes_per_point: float | None
+    selector_scatter_values_per_point: float | None
+    resolved_materialized_components_per_point: float | None
+    total_materialized_values_per_point: float | None
+    final_output_copy_values_per_point: float | None
+    native_input_container_allocations_per_call: float | None
+    evaluator_backend_calls_per_call: float | None
+    compiled_direct_arena_engines_per_call: float | None
+    compiled_direct_arena_calls_per_call: float | None
+    compiled_direct_arena_boundary_input_bytes_per_call: float | None
+    compiled_direct_arena_boundary_current_output_bytes_per_call: float | None
+    compiled_direct_arena_boundary_amplitude_output_bytes_per_call: float | None
+    recurrence_momentum_scalar_values_per_point: float | None
+    recurrence_schedule_executions_per_call: float | None
+    recurrence_replay_schedule_executions_per_call: float | None
+    recurrence_union_schedule_executions_per_call: float | None
+    recurrence_union_source_rows_per_call: float | None
+    recurrence_replay_output_values_per_point: float | None
+    recurrence_source_calls_per_call: float | None
+    recurrence_source_rows_per_call: float | None
+    recurrence_contribution_calls_per_call: float | None
+    recurrence_contribution_rows_per_call: float | None
+    recurrence_finalization_calls_per_call: float | None
+    recurrence_finalization_rows_per_call: float | None
+    recurrence_closure_calls_per_call: float | None
+    recurrence_closure_rows_per_call: float | None
+    observed_scratch_reallocations_per_call: float | None
+    native_output_allocations_per_call: float | None
+
+
+def _benchmark_target_path(
+    target: RuntimeBackend | os.PathLike[str] | str,
+) -> Path | None:
+    if not isinstance(target, (str, os.PathLike)):
+        return None
+    return Path(os.fspath(target)).expanduser().resolve(strict=False)
+
+
+class BenchmarkBackend:
+    """Measure the optimized summed runtime path without changing its semantics."""
+
+    def __init__(
+        self,
+        config: BenchmarkConfig | RunConfig | None,
+        progress: ProgressSink | None,
+    ) -> None:
+        self._run_config = config if isinstance(config, RunConfig) else None
+        self._config = (
+            config.benchmark
+            if isinstance(config, RunConfig)
+            else config or BenchmarkConfig()
+        )
+        self._progress = progress
+        self._chunk_guard: Callable[[float | None, str], None] | None = None
+
+    def set_chunk_guard(
+        self,
+        guard: Callable[[float | None, str], None],
+    ) -> None:
+        """Install a report-owned guard called before every profiling chunk."""
+
+        if not callable(guard):
+            raise TypeError("benchmark chunk guard must be callable")
+        self._chunk_guard = guard
+
+    def run(
+        self,
+        target: RuntimeBackend | os.PathLike[str] | str,
+        *,
+        points: Momenta | None = None,
+    ) -> BenchmarkResult:
+        target_path = _benchmark_target_path(target)
+        runtime = self._runtime(target)
+        if (
+            str(getattr(runtime, "execution_mode", "compiled")) == "on-the-fly"
+            and self._config.precision != 16
+        ):
+            raise EvaluationError(
+                "on-the-fly benchmarking supports only precision=16 (native f64); "
+                f"received precision={self._config.precision}"
+            )
+        compact_context = _on_the_fly_benchmark_context(
+            runtime,
+            self._config.color_flow_ids,
+        )
+        physics = None if compact_context is not None else runtime.physics
+        if points is None:
+            loader = getattr(runtime, "validation_momenta", None)
+            points = loader() if callable(loader) else None
+        if points is None or len(points) == 0:
+            raise EvaluationError(
+                "benchmarking requires at least one phase-space point and the "
+                "selected runtime has no deterministic validation point"
+            )
+        batch = _benchmark_batch(points, self._config.batch_size)
+        helicities = self._config.helicity_ids or None
+        color_flows = (
+            compact_context.selected_color_ids
+            if compact_context is not None
+            else _resolve_color_flow_ordinals(
+                cast(ProcessPhysics, physics),
+                self._config.color_flow_ids,
+            )
+        ) or None
+        color_accuracy = (
+            compact_context.color_accuracy
+            if compact_context is not None
+            else cast(ProcessPhysics, physics).color_accuracy
+        )
+        process_id = (
+            compact_context.process_id
+            if compact_context is not None
+            else cast(ProcessPhysics, physics).process_id
+        )
+        process_expression = (
+            compact_context.process_expression
+            if compact_context is not None
+            else cast(ProcessPhysics, physics).process
+        )
+        lc_flow_layout: str | None = None
+        if compact_context is None:
+            artifact_path = target_path or _runtime_artifact_path(runtime)
+            lc_flow_layout = _artifact_lc_flow_layout(artifact_path)
+            helicities, color_flows = _default_lc_profile_selectors(
+                physics=cast(ProcessPhysics, physics),
+                lc_flow_layout=lc_flow_layout,
+                selected_helicity_ids=tuple(helicities or ()),
+                selected_color_ids=tuple(color_flows or ()),
+            )
+        lc_flow_layout_recommendation = _lc_flow_layout_recommendation(
+            color_accuracy=color_accuracy,
+            lc_flow_layout=lc_flow_layout,
+            selected_helicity_ids=tuple(helicities or ()),
+            selected_color_ids=tuple(color_flows or ()),
+        )
+        if lc_flow_layout_recommendation is not None:
+            _warn_non_hot_lc_profile_once(
+                runtime,
+                lc_flow_layout_recommendation,
+            )
+        profiler = _native_profiler(runtime) if self._config.precision == 16 else None
+        repeated_profiler = (
+            _native_repeated_profiler(runtime) if self._config.precision == 16 else None
+        )
+        native_wall_timer = (
+            _native_wall_timer(runtime) if self._config.precision == 16 else None
+        )
+        timer_seconds_per_repetition: float | None = None
+        profiler_seconds_per_repetition: float | None = None
+        chunk_guard_failure: Exception | None = None
+
+        def guard_chunk(estimated_seconds: float | None, description: str) -> None:
+            nonlocal chunk_guard_failure
+            if self._chunk_guard is not None:
+                try:
+                    self._chunk_guard(estimated_seconds, description)
+                except Exception as error:
+                    chunk_guard_failure = error
+                    raise
+
+        def evaluate_once() -> object:
+            return runtime.evaluate(
+                batch,
+                helicities=helicities,
+                color_flows=color_flows,
+                precision=self._config.precision,
+            )
+
+        def measure_repetitions(repetitions: int) -> float:
+            nonlocal timer_seconds_per_repetition
+            estimate = (
+                None
+                if timer_seconds_per_repetition is None
+                else timer_seconds_per_repetition * repetitions
+            )
+            guard_chunk(estimate, "runtime evaluator timing chunk")
+            if native_wall_timer is not None:
+                observed = native_wall_timer(
+                    batch,
+                    repetitions,
+                    helicities=helicities,
+                    color_flows=color_flows,
+                    precision=self._config.precision,
+                )
+            else:
+                observed = _timed_repetitions(evaluate_once, repetitions)
+            timer_seconds_per_repetition = observed / repetitions
+            return observed
+
+        def profile_repetitions(
+            repetitions: int,
+            *,
+            measure_elapsed: bool = True,
+        ) -> tuple[object, float]:
+            nonlocal profiler_seconds_per_repetition
+            estimated_per_repetition = (
+                profiler_seconds_per_repetition
+                if profiler_seconds_per_repetition is not None
+                else timer_seconds_per_repetition
+            )
+            estimate = (
+                None
+                if estimated_per_repetition is None
+                else estimated_per_repetition * repetitions
+            )
+            guard_chunk(estimate, "runtime attribution chunk")
+            started = time.perf_counter() if measure_elapsed else None
+            if repeated_profiler is not None:
+                result = repeated_profiler(
+                    batch,
+                    repetitions,
+                    helicities=helicities,
+                    color_flows=color_flows,
+                    precision=self._config.precision,
+                    include_values=False,
+                )
+                divisor = repetitions
+            elif profiler is not None:
+                result = profiler(
+                    batch,
+                    helicities=helicities,
+                    color_flows=color_flows,
+                    precision=self._config.precision,
+                    include_values=False,
+                )
+                divisor = 1
+            else:  # pragma: no cover - caller checks profiler availability.
+                raise EvaluationError("runtime profiler is unavailable")
+            elapsed_seconds = (
+                (time.perf_counter() - started)
+                if started is not None
+                else (estimate or 0.0)
+            )
+            if elapsed_seconds > 0.0:
+                profiler_seconds_per_repetition = elapsed_seconds / divisor
+            return result, elapsed_seconds
+
+        task_id = "runtime-benchmark"
+        calibration_task_id = "runtime-profile-calibration"
+        active_task_id = calibration_task_id
+        cold_warmup_elapsed: float | None = None
+        cold_warmup_state_before: dict[str, object] | None = None
+        cold_warmup_state_after: dict[str, object] | None = None
+        cold_warmup_runtime_was_cold: bool | None = None
+        cold_warmup_runtime_was_retained: bool | None = None
+        cold_warmup_runtime_is_retained: bool | None = None
+        warmup_elapsed = 0.0
+        warmup_run_outer_wall_seconds: list[float] = []
+        calibration: _Calibration | None = None
+        samples: list[float] = []
+        evaluator_samples: list[float] | None = (
+            [] if profiler is not None or repeated_profiler is not None else None
+        )
+        native_profile_samples: list[_NativeProfileSample] | None = (
+            [] if profiler is not None or repeated_profiler is not None else None
+        )
+        elapsed = 0.0
+        evaluator_total_elapsed = 0.0
+        evaluator_elapsed = 0.0
+        interrupted = False
+        if self._progress is not None:
+            self._progress.emit(
+                ProgressStart(
+                    calibration_task_id,
+                    "Calibrating runtime profile",
+                    total=None,
+                )
+            )
+        try:
+            if compact_context is not None:
+                cold_warmup_state_before = _on_the_fly_runtime_state_census(
+                    runtime,
+                    expected_process_id=compact_context.process_id,
+                )
+                cold_warmup_runtime_was_cold = _on_the_fly_runtime_state_is_cold(
+                    cold_warmup_state_before
+                )
+                cold_warmup_runtime_was_retained = (
+                    _on_the_fly_runtime_state_is_retained(cold_warmup_state_before)
+                )
+                if not (
+                    cold_warmup_runtime_was_cold or cold_warmup_runtime_was_retained
+                ):
+                    raise EvaluationError(
+                        "on-the-fly runtime state before the first requested "
+                        "evaluation is neither cold nor fully retained"
+                    )
+                cold_warmup_started = time.perf_counter()
+                measure_repetitions(1)
+                cold_warmup_elapsed = time.perf_counter() - cold_warmup_started
+                cold_warmup_state_after = _on_the_fly_runtime_state_census(
+                    runtime,
+                    expected_process_id=compact_context.process_id,
+                )
+                cold_warmup_runtime_is_retained = _on_the_fly_runtime_state_is_retained(
+                    cold_warmup_state_after
+                )
+                if not cold_warmup_runtime_is_retained:
+                    raise EvaluationError(
+                        "on-the-fly first requested evaluation did not leave a fully "
+                        "retained runtime family"
+                    )
+                # The required first-selector evaluation can spend minutes
+                # constructing a cold high-multiplicity family. It is reported
+                # separately as OTF warm-up evidence and must not become the
+                # estimate used to guard or calibrate retained evaluations.
+                timer_seconds_per_repetition = None
+            last_warmup_seconds: float | None = None
+            for warmup_index in range(self._config.warmup_runs):
+                warmup_started = time.perf_counter()
+                last_warmup_seconds = measure_repetitions(1)
+                if repeated_profiler is not None or profiler is not None:
+                    profile_repetitions(1, measure_elapsed=False)
+                warmup_run_elapsed = time.perf_counter() - warmup_started
+                warmup_run_outer_wall_seconds.append(warmup_run_elapsed)
+                warmup_elapsed += warmup_run_elapsed
+                if self._progress is not None:
+                    self._progress.emit(
+                        ProgressUpdate(
+                            calibration_task_id,
+                            completed=warmup_index + 1,
+                            total=None,
+                            message="warmup",
+                        )
+                    )
+
+            calibration_outer_started = time.perf_counter()
+            calibration = _calibrate_repetitions(
+                evaluate_once,
+                self._config,
+                initial_seconds=last_warmup_seconds,
+                timer=measure_repetitions,
+            )
+            calibration_outer_elapsed = time.perf_counter() - calibration_outer_started
+            if self._progress is not None:
+                self._progress.emit(
+                    ProgressEnd(
+                        calibration_task_id,
+                        message=(
+                            f"{calibration.sample_count} blocks x "
+                            f"{calibration.repetitions_per_sample} repetitions"
+                        ),
+                    )
+                )
+                self._progress.emit(
+                    ProgressStart(
+                        task_id,
+                        "Profiling runtime",
+                        total=calibration.sample_count,
+                    )
+                )
+            active_task_id = task_id
+            repetitions = calibration.repetitions_per_sample
+            initial_planned_sample_count = calibration.sample_count
+            planned_sample_count = initial_planned_sample_count
+            maximum_sample_count = (
+                initial_planned_sample_count * _MAX_TARGET_RUNTIME_SAMPLE_FACTOR
+            )
+            native_profile_sample_limit = (
+                planned_sample_count
+                if repeated_profiler is not None
+                else min(
+                    planned_sample_count,
+                    max(
+                        1,
+                        min(
+                            self._config.minimum_samples,
+                            _MAX_NATIVE_PROFILE_SAMPLES,
+                        ),
+                    ),
+                )
+            )
+            try:
+                sample_index = 0
+                while sample_index < planned_sample_count:
+                    native_sample: _NativeProfileSample | None = None
+                    profile_duration = 0.0
+                    sample_started = time.perf_counter()
+                    evaluator_total_duration = measure_repetitions(repetitions)
+                    wall_duration = time.perf_counter() - sample_started
+                    sample_seconds_per_point = wall_duration / (
+                        repetitions * len(batch)
+                    )
+                    if repeated_profiler is not None:
+                        profile, profile_duration = profile_repetitions(repetitions)
+                        native_sample = _native_profile_sample(
+                            profile,
+                            len(batch) * repetitions,
+                            repetitions=repetitions,
+                        )
+                        if native_sample.wall_time is None:
+                            raise EvaluationError(
+                                "repeated native profile did not report core wall time"
+                            )
+                    elif (
+                        profiler is not None
+                        and evaluator_samples is not None
+                        and native_profile_samples is not None
+                        and sample_index < native_profile_sample_limit
+                    ):
+                        profile, profile_duration = profile_repetitions(1)
+                        native_sample = _native_profile_sample(profile, len(batch))
+
+                    samples.append(sample_seconds_per_point)
+                    elapsed += wall_duration
+                    evaluator_total_elapsed += evaluator_total_duration
+                    if native_sample is not None:
+                        assert evaluator_samples is not None
+                        assert native_profile_samples is not None
+                        native_profile_samples.append(native_sample)
+                        if (
+                            native_sample.execution_mode
+                            in _RECURRENCE_LIKE_EXECUTION_MODES
+                        ):
+                            if native_sample.recurrence_schedule_time is None:
+                                raise EvaluationError(
+                                    "native recurrence schedule timing is unavailable"
+                                )
+                            evaluator_samples.append(
+                                native_sample.recurrence_schedule_time
+                            )
+                        elif native_sample.compiled_direct_arena_active:
+                            if native_sample.orchestration_time is None:
+                                raise EvaluationError(
+                                    "native compiled Direct-Arena orchestration "
+                                    "timing is unavailable"
+                                )
+                            evaluator_samples.append(native_sample.orchestration_time)
+                        else:
+                            evaluator_samples.append(
+                                native_sample.stage_evaluator_call_time
+                                + (native_sample.amplitude_evaluator_call_time or 0.0)
+                            )
+                        evaluator_elapsed += profile_duration
+                    sample_index += 1
+                    if (
+                        sample_index == planned_sample_count
+                        and elapsed < self._config.target_runtime
+                    ):
+                        if planned_sample_count >= maximum_sample_count:
+                            raise EvaluationError(
+                                "runtime benchmark could not reach its target "
+                                f"duration of {self._config.target_runtime:g}s "
+                                f"within {maximum_sample_count} complete blocks"
+                            )
+                        mean_block_seconds = elapsed / len(samples)
+                        additional_samples = max(
+                            1,
+                            math.ceil(
+                                (self._config.target_runtime - elapsed)
+                                / max(
+                                    mean_block_seconds,
+                                    _MIN_CLOCK_INTERVAL_SECONDS,
+                                )
+                            ),
+                        )
+                        planned_sample_count = min(
+                            maximum_sample_count,
+                            planned_sample_count + additional_samples,
+                        )
+                        if repeated_profiler is not None:
+                            native_profile_sample_limit = planned_sample_count
+                    if self._progress is not None:
+                        message, details = _sample_progress_payload(
+                            samples,
+                            elapsed_seconds=elapsed,
+                            target_seconds=self._config.target_runtime,
+                            repetitions=repetitions,
+                            batch_size=len(batch),
+                        )
+                        self._progress.emit(
+                            ProgressUpdate(
+                                task_id,
+                                completed=len(samples),
+                                total=planned_sample_count,
+                                message=message,
+                                details=details,
+                            )
+                        )
+            except KeyboardInterrupt:
+                if not samples:
+                    raise
+                interrupted = True
+                if self._progress is not None:
+                    self._progress.emit(
+                        ProgressEnd(
+                            task_id,
+                            success=False,
+                            message=(
+                                f"interrupted after {len(samples)}/"
+                                f"{planned_sample_count} complete blocks; "
+                                "reporting partial statistics"
+                            ),
+                        )
+                    )
+        except KeyboardInterrupt:
+            if self._progress is not None:
+                self._progress.emit(
+                    ProgressEnd(
+                        active_task_id,
+                        success=False,
+                        message="interrupted before a complete timing block",
+                    )
+                )
+            raise
+        except Exception as exc:
+            if self._progress is not None:
+                self._progress.emit(
+                    ProgressEnd(active_task_id, success=False, message=str(exc))
+                )
+            if isinstance(exc, EvaluationError):
+                raise
+            if exc is chunk_guard_failure:
+                raise
+            raise EvaluationError(f"runtime benchmark failed: {exc}") from exc
+        if self._progress is not None and not interrupted:
+            self._progress.emit(ProgressEnd(task_id))
+
+        assert calibration is not None
+
+        wall_samples = samples
+        wall_time_source = "python_outer_perf_counter_wall_time"
+        wall_sample_pass = "time.perf_counter[measure_repetitions]"
+        evaluator_total_sample_pass = (
+            "runtime._benchmark_f64_wall_time"
+            if native_wall_timer is not None
+            else "runtime.evaluate"
+        )
+        timing_sample_contract = (
+            "paired_unprofiled_headline_profiled_attribution_v1"
+            if repeated_profiler is not None
+            else "separate_native_profile_diagnostic_v1"
+        )
+        mean, deviation, error, relative_error = _sample_statistics(wall_samples)
+        uncertainty = BenchmarkStatistics(deviation, error, relative_error)
+        compiled_direct_arena_active = False
+        if evaluator_samples is None:
+            evaluator_time_per_point = None
+            evaluator_uncertainty = None
+            timing_breakdown = None
+            evaluator_environment: dict[str, object] = {
+                "wall_time_source": wall_time_source,
+                "wall_time_sample_pass": wall_sample_pass,
+                "evaluator_time_source": "unavailable",
+                "evaluator_time_sample_pass": "unavailable",
+                "timing_sample_contract": "headline_only_no_breakdown_v1",
+                "native_profile_unavailable_reason": (
+                    "non_f64_precision" if self._config.precision != 16 else None
+                ),
+            }
+        else:
+            assert native_profile_samples is not None
+            compiled_direct_arena_states = {
+                sample.compiled_direct_arena_active for sample in native_profile_samples
+            }
+            if len(compiled_direct_arena_states) > 1:
+                raise EvaluationError(
+                    "native compiled Direct-Arena activity changed between samples"
+                )
+            compiled_direct_arena_active = next(
+                iter(compiled_direct_arena_states),
+                False,
+            )
+            (
+                evaluator_time_per_point,
+                evaluator_deviation,
+                evaluator_error,
+                evaluator_relative,
+            ) = _sample_statistics(evaluator_samples)
+            evaluator_uncertainty = BenchmarkStatistics(
+                evaluator_deviation,
+                evaluator_error,
+                evaluator_relative,
+            )
+            timing_breakdown = _timing_breakdown(native_profile_samples)
+            if timing_breakdown.execution_mode in _RECURRENCE_LIKE_EXECUTION_MODES:
+                evaluator_time_source = "runtime_profile_core_recurrence_schedule_time"
+            elif compiled_direct_arena_active:
+                evaluator_time_source = (
+                    "runtime_profile_core_compiled_direct_arena_orchestration_time"
+                )
+            else:
+                evaluator_time_source = "runtime_profile_core_evaluator_call_time"
+            native_profile_repetitions = (
+                calibration.repetitions_per_sample
+                if repeated_profiler is not None
+                else 1
+            )
+            native_profile_warmup_calls = (
+                self._config.warmup_runs
+                if profiler is not None or repeated_profiler is not None
+                else 0
+            )
+            paired_profile_attribution = repeated_profiler is not None
+            evaluator_environment = {
+                "wall_time_source": wall_time_source,
+                "wall_time_sample_pass": wall_sample_pass,
+                "evaluator_time_source": evaluator_time_source,
+                "compiled_direct_arena_active": compiled_direct_arena_active,
+                "evaluator_time_sample_pass": (
+                    "runtime.profile_repeated"
+                    if repeated_profiler is not None
+                    else "runtime.profile"
+                ),
+                "timing_breakdown_sample_pass": (
+                    "runtime.profile_repeated"
+                    if repeated_profiler is not None
+                    else "runtime.profile"
+                ),
+                "evaluator_sample_count": len(evaluator_samples),
+                "evaluator_elapsed_seconds": evaluator_elapsed,
+                "native_profile_sample_count": len(evaluator_samples),
+                "native_profile_sample_limit": native_profile_sample_limit,
+                "native_profile_repetitions_per_sample": (native_profile_repetitions),
+                "native_profile_batch_size": len(batch),
+                "native_profile_points_per_sample": (
+                    native_profile_repetitions * len(batch)
+                ),
+                "native_profile_calls_per_block": (
+                    len(evaluator_samples) / len(samples) if samples else 0.0
+                ),
+                "native_profile_warmup_call_count": native_profile_warmup_calls,
+                "native_profile_total_call_count": (
+                    native_profile_warmup_calls + len(evaluator_samples)
+                ),
+                "profile_attribution_paired_with_headline": (
+                    paired_profile_attribution
+                ),
+                "profile_attribution_identical_batch": paired_profile_attribution,
+                "profile_attribution_identical_repetitions": (
+                    paired_profile_attribution
+                ),
+                "profile_attribution_evaluation_count": (
+                    len(evaluator_samples) * native_profile_repetitions
+                ),
+                "profile_attribution_point_count": (
+                    len(evaluator_samples) * native_profile_repetitions * len(batch)
+                ),
+                "timing_sample_contract": timing_sample_contract,
+                "evaluator_standard_deviation_seconds_per_point": (evaluator_deviation),
+                "evaluator_standard_error_seconds_per_point": evaluator_error,
+                "evaluator_relative_standard_error": evaluator_relative,
+            }
+        raw_evaluator_time_per_point = evaluator_time_per_point
+        evaluator_below_timer_resolution = (
+            raw_evaluator_time_per_point is not None
+            and compiled_direct_arena_active
+            and raw_evaluator_time_per_point == 0.0
+        )
+        if evaluator_below_timer_resolution:
+            evaluator_time_per_point = None
+        evaluator_environment.update(
+            {
+                "evaluator_time_status": (
+                    "below_timer_resolution"
+                    if evaluator_below_timer_resolution
+                    else (
+                        "measured"
+                        if raw_evaluator_time_per_point is not None
+                        else "unavailable"
+                    )
+                ),
+                "evaluator_time_ratio_eligible": (
+                    raw_evaluator_time_per_point is not None
+                    and not evaluator_below_timer_resolution
+                    and raw_evaluator_time_per_point > 0.0
+                ),
+                "evaluator_time_raw_seconds_per_point": (raw_evaluator_time_per_point),
+            }
+        )
+        execution_mode = (
+            timing_breakdown.execution_mode
+            if timing_breakdown is not None
+            else str(getattr(runtime, "execution_mode", "unavailable"))
+        )
+        selected_helicity_ids = tuple(helicities or ())
+        selected_color_ids = tuple(color_flows or ())
+        effective_config = replace(
+            self._config,
+            helicity_ids=selected_helicity_ids,
+            color_flow_ids=selected_color_ids,
+        )
+        measured_evaluations = len(samples) * calibration.repetitions_per_sample
+        measured_point_count = measured_evaluations * len(batch)
+        evaluator_total_time_per_point = evaluator_total_elapsed / measured_point_count
+        layout_environment: dict[str, object] = {}
+        if lc_flow_layout is not None:
+            layout_environment = {
+                "lc_flow_layout": lc_flow_layout,
+                "lc_flow_layout_recommendation": lc_flow_layout_recommendation,
+            }
+        cold_warmup_environment: dict[str, object] = {}
+        if cold_warmup_elapsed is not None:
+            if (
+                cold_warmup_state_before is None
+                or cold_warmup_state_after is None
+                or cold_warmup_runtime_was_cold is None
+                or cold_warmup_runtime_was_retained is None
+                or cold_warmup_runtime_is_retained is None
+            ):
+                raise EvaluationError(
+                    "on-the-fly benchmark did not retain complete runtime state "
+                    "evidence"
+                )
+            cold_warmup_environment = {
+                "cold_warmup_elapsed_seconds": cold_warmup_elapsed,
+                "cold_warmup_run_count": 1,
+                "cold_warmup_batch_size": len(batch),
+                "cold_warmup_point_count": len(batch),
+                "cold_warmup_timer_source": "python_outer_time.perf_counter",
+                "cold_warmup_timing_scope": (
+                    "one initial requested-selector Runtime evaluation on the full "
+                    "benchmark batch; artifact generation and Runtime/artifact load "
+                    "are excluded"
+                ),
+                "cold_warmup_runtime_freshness": (
+                    "authenticated-cold"
+                    if cold_warmup_runtime_was_cold
+                    else "authenticated-already-retained"
+                ),
+                "cold_warmup_runtime_state_evidence": (
+                    "authenticated-native-otf-census-v1"
+                ),
+                "cold_warmup_runtime_state_before": cold_warmup_state_before,
+                "cold_warmup_runtime_state_after": cold_warmup_state_after,
+                "cold_warmup_runtime_cold_before_first_evaluation": (
+                    cold_warmup_runtime_was_cold
+                ),
+                "cold_warmup_runtime_retained_before_first_evaluation": (
+                    cold_warmup_runtime_was_retained
+                ),
+                "cold_warmup_runtime_retained_after_first_evaluation": (
+                    cold_warmup_runtime_is_retained
+                ),
+                "cold_warmup_ratio_eligible": False,
+                "cold_warmup_acceptance_eligible": False,
+            }
+        return BenchmarkResult(
+            requested_config=self._config,
+            effective_config=effective_config,
+            sample_count=len(samples),
+            wall_time_per_point=mean,
+            evaluator_time_per_point=evaluator_time_per_point,
+            uncertainty=uncertainty,
+            environment={
+                "python": platform.python_version(),
+                "platform": platform.platform(),
+                "machine": platform.machine(),
+                "target": None if target_path is None else str(target_path),
+                "batch_size": len(batch),
+                "precision": self._config.precision,
+                "execution_mode": execution_mode,
+                "color_accuracy": color_accuracy,
+                "color_workload": (
+                    _compact_color_workload_text(compact_context, selected_color_ids)
+                    if compact_context is not None
+                    else _color_workload_text(
+                        cast(ProcessPhysics, physics),
+                        selected_color_ids,
+                    )
+                ),
+                "helicity_workload": (
+                    _compact_helicity_workload_text(
+                        compact_context,
+                        selected_helicity_ids,
+                    )
+                    if compact_context is not None
+                    else _helicity_workload_text(
+                        cast(ProcessPhysics, physics),
+                        selected_helicity_ids,
+                    )
+                ),
+                "selected_color_ids": selected_color_ids,
+                "selected_helicity_ids": selected_helicity_ids,
+                "elapsed_seconds": elapsed,
+                "interrupted": interrupted,
+                "completed_sample_count": len(samples),
+                "completion_fraction": len(samples) / planned_sample_count,
+                "warmup_elapsed_seconds": warmup_elapsed,
+                "warmup_configured_run_count": self._config.warmup_runs,
+                "warmup_batch_size": len(batch),
+                "warmup_point_count": self._config.warmup_runs * len(batch),
+                "warmup_run_outer_wall_seconds": tuple(warmup_run_outer_wall_seconds),
+                "first_warmup_run_outer_wall_seconds": (
+                    warmup_run_outer_wall_seconds[0]
+                    if warmup_run_outer_wall_seconds
+                    else None
+                ),
+                "warmup_timer_source": "python_outer_time.perf_counter",
+                "warmup_timing_scope": (
+                    "configured benchmark warm-up iteration outer wall; includes "
+                    "the headline evaluation and optional native-profile warm-up; "
+                    "artifact generation and Runtime/artifact load are excluded"
+                ),
+                "planned_sample_count": planned_sample_count,
+                "initial_planned_sample_count": initial_planned_sample_count,
+                "adaptive_extension_sample_count": (
+                    planned_sample_count - initial_planned_sample_count
+                ),
+                "repetitions_per_sample": calibration.repetitions_per_sample,
+                "measured_evaluation_count": measured_evaluations,
+                "measured_point_count": measured_point_count,
+                "evaluator_total_time_raw_seconds_per_point": (
+                    evaluator_total_time_per_point
+                ),
+                "evaluator_total_time_status": "measured",
+                "evaluator_total_time_ratio_eligible": False,
+                "evaluator_total_time_source": (
+                    f"{evaluator_total_sample_pass}.accumulated"
+                ),
+                "evaluator_total_time_sample_contract": (
+                    _EVALUATOR_TOTAL_SAMPLE_CONTRACT
+                ),
+                "evaluator_total_accumulated_seconds": evaluator_total_elapsed,
+                "target_sample_seconds": calibration.target_sample_seconds,
+                "calibration_probe_seconds": calibration.probe_seconds,
+                "calibration_block_count": calibration.block_count,
+                "calibration_evaluation_count": calibration.evaluation_count,
+                "calibration_elapsed_seconds": calibration.elapsed_seconds,
+                "calibration_outer_elapsed_seconds": calibration_outer_elapsed,
+                **cold_warmup_environment,
+                **layout_environment,
+                **evaluator_environment,
+            },
+            interrupted=interrupted,
+            repetitions_per_sample=calibration.repetitions_per_sample,
+            evaluator_uncertainty=evaluator_uncertainty,
+            evaluator_total_time_per_point=evaluator_total_time_per_point,
+            process_id=process_id,
+            process_expression=process_expression,
+            timing_breakdown=timing_breakdown,
+        )
+
+    def _runtime(
+        self,
+        target: RuntimeBackend | os.PathLike[str] | str,
+    ) -> RuntimeBackend:
+        target_path = _benchmark_target_path(target)
+        if target_path is None:
+            return cast(RuntimeBackend, target)
+        from pyamplicol.runtime import load_runtime_backend
+
+        run = self._run_config
+        process = None if run is None else run.evaluation.process
+        path = target_path
+        task_id = "process-output-load"
+        started = time.perf_counter()
+        if self._progress is not None:
+            self._progress.emit(
+                ProgressStart(
+                    task_id,
+                    f"Loading process output {path}",
+                    details={"step": "loading process output", "path": str(path)},
+                )
+            )
+        try:
+            runtime = load_runtime_backend(
+                path,
+                process=process,
+                model_parameters=None,
+                mute_warnings=False,
+            )
+        except Exception as exc:
+            if self._progress is not None:
+                self._progress.emit(
+                    ProgressEnd(
+                        task_id,
+                        success=False,
+                        message=str(exc),
+                        elapsed_seconds=time.perf_counter() - started,
+                    )
+                )
+            raise
+        if self._progress is not None:
+            self._progress.emit(
+                ProgressEnd(
+                    task_id,
+                    elapsed_seconds=time.perf_counter() - started,
+                )
+            )
+        return runtime
+
+
+def _artifact_lc_flow_layout(target_path: Path | None) -> str | None:
+    if target_path is None:
+        return None
+    effective_path = target_path / "config" / "effective.toml"
+    try:
+        payload = tomllib.loads(effective_path.read_text(encoding="utf-8"))
+    except (OSError, tomllib.TOMLDecodeError):
+        return None
+    color = payload.get("color")
+    if not isinstance(color, Mapping) or color.get("accuracy") != "lc":
+        return None
+    layout = color.get("lc_flow_layout", _LC_TOPOLOGY_REPLAY_LAYOUT)
+    if layout not in {_LC_TOPOLOGY_REPLAY_LAYOUT, _LC_ALL_FLOW_UNION_LAYOUT}:
+        return None
+    return str(layout)
+
+
+def _runtime_artifact_path(runtime: RuntimeBackend) -> Path | None:
+    """Recover the built-in runtime's artifact root without extending the protocol."""
+
+    candidate: object | None = runtime
+    seen: set[int] = set()
+    while candidate is not None and id(candidate) not in seen:
+        seen.add(id(candidate))
+        raw_path = getattr(candidate, "_artifact_path", None)
+        if isinstance(raw_path, (str, os.PathLike)):
+            return Path(os.fspath(raw_path)).expanduser().resolve(strict=False)
+        candidate = getattr(candidate, "_backend", None)
+    return None
+
+
+def _warn_non_hot_lc_profile_once(
+    runtime: RuntimeBackend,
+    message: str,
+) -> None:
+    """Warn once for one loaded process, never once per timing sample."""
+
+    owner: object = runtime
+    seen: set[int] = set()
+    while id(owner) not in seen:
+        seen.add(id(owner))
+        backend = getattr(owner, "_backend", None)
+        if backend is None:
+            break
+        owner = backend
+    with _LC_PROFILE_WARNING_LOCK:
+        if bool(getattr(owner, _LC_PROFILE_WARNING_ATTRIBUTE, False)):
+            return
+        try:
+            setattr(owner, _LC_PROFILE_WARNING_ATTRIBUTE, True)
+        except (AttributeError, TypeError):
+            # Keep an identity-stable fallback for immutable protocol
+            # implementations so they cannot emit once per benchmark run.
+            owner_id = id(owner)
+            if _LC_PROFILE_WARNING_FALLBACK_OWNERS.get(owner_id) is owner:
+                return
+            _LC_PROFILE_WARNING_FALLBACK_OWNERS[owner_id] = owner
+    warnings.warn(message, UserWarning, stacklevel=3)
+
+
+def _default_lc_profile_selectors(
+    *,
+    physics: ProcessPhysics,
+    lc_flow_layout: str | None,
+    selected_helicity_ids: Sequence[str],
+    selected_color_ids: Sequence[str],
+) -> tuple[tuple[str, ...] | None, tuple[str, ...] | None]:
+    """Choose the LC hot workload while preserving explicit subset intent."""
+
+    helicities = tuple(selected_helicity_ids)
+    color_flows = tuple(selected_color_ids)
+    if physics.color_accuracy != "lc" or lc_flow_layout is None:
+        return helicities or None, color_flows or None
+    complete_helicities = _is_complete_selector_set(
+        helicities, physics.helicity_ids
+    )
+    complete_color_flows = _is_complete_selector_set(
+        color_flows, physics.color_ids
+    )
+    if lc_flow_layout == _LC_TOPOLOGY_REPLAY_LAYOUT:
+        normalized_helicities = None if complete_helicities else helicities or None
+        normalized_color_flows = (
+            color_flows
+            if color_flows and (not complete_color_flows or len(color_flows) == 1)
+            else None
+        )
+        if color_flows or normalized_helicities is not None:
+            return normalized_helicities, normalized_color_flows
+        selectable_flows = tuple(
+            flow.id for flow in physics.color_flows if flow.computed
+        )
+        if not selectable_flows:
+            selectable_flows = physics.color_ids
+        if not selectable_flows:
+            raise EvaluationError("LC profiling requires at least one physical flow")
+        return None, (selectable_flows[0],)
+    if lc_flow_layout == _LC_ALL_FLOW_UNION_LAYOUT:
+        normalized_color_flows = None if complete_color_flows else color_flows or None
+        normalized_helicities = (
+            helicities
+            if helicities and (not complete_helicities or len(helicities) == 1)
+            else None
+        )
+        if helicities or normalized_color_flows is not None:
+            return normalized_helicities, normalized_color_flows
+        selectable = tuple(
+            helicity.id
+            for helicity in physics.helicities
+            if helicity.computed and not helicity.structural_zero
+        )
+        if not selectable:
+            selectable = tuple(
+                helicity.id for helicity in physics.helicities if helicity.computed
+            )
+        if not selectable:
+            selectable = physics.helicity_ids
+        if not selectable:
+            raise EvaluationError(
+                "LC profiling requires at least one physical helicity"
+            )
+        return (selectable[0],), None
+    return None, None
+
+
+def _is_complete_selector_set(
+    selected: Sequence[str],
+    available: Sequence[str],
+) -> bool:
+    """Return whether an explicit selector enumerates one complete physical axis."""
+
+    return (
+        bool(selected)
+        and len(selected) == len(available)
+        and set(selected) == set(available)
+    )
+
+
+def _lc_flow_layout_recommendation(
+    *,
+    color_accuracy: str,
+    lc_flow_layout: str | None,
+    selected_helicity_ids: Sequence[str],
+    selected_color_ids: Sequence[str],
+) -> str | None:
+    if color_accuracy != "lc":
+        return None
+    if lc_flow_layout == _LC_TOPOLOGY_REPLAY_LAYOUT:
+        if not selected_helicity_ids and len(selected_color_ids) == 1:
+            return None
+        return _LC_TOPOLOGY_REPLAY_PROFILE_RECOMMENDATION
+    if lc_flow_layout == _LC_ALL_FLOW_UNION_LAYOUT:
+        if len(selected_helicity_ids) == 1 and not selected_color_ids:
+            return None
+        return _LC_ALL_FLOW_UNION_PROFILE_RECOMMENDATION
+    return None
+
+
+def _benchmark_batch(points: Momenta, batch_size: int) -> Momenta:
+    source = tuple(points)
+    return tuple(source[index % len(source)] for index in range(batch_size))
+
+
+def _on_the_fly_benchmark_context(
+    runtime: RuntimeBackend,
+    requested_color_ids: Sequence[str],
+) -> _CompactBenchmarkContext | None:
+    if str(getattr(runtime, "execution_mode", "compiled")) != "on-the-fly":
+        return None
+    loader = getattr(runtime, "_on_the_fly_benchmark_context", None)
+    if not callable(loader):
+        raise EvaluationError(
+            "on-the-fly benchmark requires the installed compact runtime context"
+        )
+    raw = loader(tuple(requested_color_ids))
+    if not isinstance(raw, Mapping):
+        raise EvaluationError("on-the-fly benchmark context is unavailable")
+
+    def required_text(key: str) -> str:
+        value = raw.get(key)
+        if not isinstance(value, str) or not value:
+            raise EvaluationError(
+                f"on-the-fly benchmark context field {key!r} is invalid"
+            )
+        return value
+
+    def required_count(key: str) -> int:
+        value = raw.get(key)
+        if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+            raise EvaluationError(
+                f"on-the-fly benchmark context field {key!r} is invalid"
+            )
+        return value
+
+    selected = raw.get("selected_color_ids")
+    if not isinstance(selected, Sequence) or isinstance(selected, (str, bytes)):
+        raise EvaluationError("on-the-fly benchmark selected color IDs are invalid")
+    selected_color_ids = tuple(str(value) for value in selected)
+    if len(selected_color_ids) != len(requested_color_ids) or any(
+        not value for value in selected_color_ids
+    ):
+        raise EvaluationError(
+            "on-the-fly benchmark selected color IDs do not match the request"
+        )
+    return _CompactBenchmarkContext(
+        process_id=required_text("process_id"),
+        process_expression=required_text("process_expression"),
+        color_accuracy=required_text("color_accuracy"),
+        helicity_count=required_count("helicity_count"),
+        color_count=required_count("color_count"),
+        selected_color_ids=selected_color_ids,
+    )
+
+
+def _on_the_fly_runtime_state_census(
+    runtime: RuntimeBackend,
+    *,
+    expected_process_id: str,
+) -> dict[str, object]:
+    loader = getattr(runtime, "_on_the_fly_runtime_state_census", None)
+    if not callable(loader):
+        raise EvaluationError(
+            "on-the-fly benchmark requires the installed compact runtime state census"
+        )
+    raw = loader()
+    if not isinstance(raw, Mapping):
+        raise EvaluationError("on-the-fly runtime state census is unavailable")
+    value = deepcopy(dict(raw))
+    if value.get("kind") != _OTF_RUNTIME_STATE_CENSUS_KIND:
+        raise EvaluationError("on-the-fly runtime state census has an invalid kind")
+    if value.get("process_id") != expected_process_id:
+        raise EvaluationError(
+            "on-the-fly runtime state census does not match the benchmark process"
+        )
+    if value.get("family_cache_policy") != _OTF_FAMILY_CACHE_POLICY:
+        raise EvaluationError(
+            "on-the-fly runtime state census has an invalid family cache policy"
+        )
+    cache_limit = value.get("family_cache_limit")
+    if (
+        isinstance(cache_limit, bool)
+        or not isinstance(cache_limit, int)
+        or cache_limit != _OTF_FAMILY_CACHE_LIMIT
+    ):
+        raise EvaluationError(
+            "on-the-fly runtime state census has an invalid family cache limit"
+        )
+
+    counts: dict[str, int] = {}
+    for field in _OTF_RUNTIME_STATE_COUNT_FIELDS:
+        count = value.get(field)
+        if isinstance(count, bool) or not isinstance(count, int) or count < 0:
+            raise EvaluationError(
+                f"on-the-fly runtime state census field {field!r} is invalid"
+            )
+        counts[field] = count
+    if counts["retained_family_count"] > _OTF_FAMILY_CACHE_LIMIT:
+        raise EvaluationError(
+            "on-the-fly runtime state census retained family count exceeds its "
+            "cache limit"
+        )
+
+    active = value.get("active_family_union_census")
+    if active is None:
+        return value
+    if not isinstance(active, Mapping):
+        raise EvaluationError(
+            "on-the-fly active-family runtime state census is invalid"
+        )
+    active_value = dict(active)
+    if (
+        active_value.get("basis") != "shared-query-family-union-v1"
+        or active_value.get("scope") != "active-family-union"
+    ):
+        raise EvaluationError(
+            "on-the-fly active-family runtime state census has an invalid identity"
+        )
+    active_counts: dict[str, int] = {}
+    for field in _OTF_ACTIVE_FAMILY_COUNT_FIELDS:
+        count = active_value.get(field)
+        if isinstance(count, bool) or not isinstance(count, int) or count < 0:
+            raise EvaluationError(
+                "on-the-fly active-family runtime state census field "
+                f"{field!r} is invalid"
+            )
+        active_counts[field] = count
+    if (
+        active_counts["query_count"] < 1
+        or active_counts["union_unique_current_count"]
+        > active_counts["union_unique_current_component_count"]
+        or active_counts["union_amplitude_destination_count"] < 1
+        or active_counts["union_amplitude_destination_count"]
+        > active_counts["query_count"]
+        or active_counts["query_count"] > counts["retained_request_count"]
+        or active_counts["union_amplitude_destination_count"]
+        > counts["retained_amplitude_destination_count"]
+    ):
+        raise EvaluationError(
+            "on-the-fly active-family runtime state census is inconsistent"
+        )
+    for role in _OTF_OPERATION_ROLES:
+        if (
+            active_counts[f"union_{role}_executor_call_groups"]
+            > active_counts[f"union_{role}_rows"]
+        ):
+            raise EvaluationError(
+                "on-the-fly active-family runtime state census has more "
+                f"{role} executor call groups than rows"
+            )
+    value["active_family_union_census"] = active_value
+    return value
+
+
+def _on_the_fly_runtime_state_is_cold(census: Mapping[str, object]) -> bool:
+    return all(census[field] == 0 for field in _OTF_RUNTIME_STATE_COUNT_FIELDS) and (
+        census["active_family_union_census"] is None
+    )
+
+
+def _on_the_fly_runtime_state_is_retained(census: Mapping[str, object]) -> bool:
+    if (
+        census["pending_family_count"] != 0
+        or census["process_preparation_count"] != 1
+        or census["retained_family_count"] != _OTF_FAMILY_CACHE_LIMIT
+        or census["retained_selection_count"] != _OTF_FAMILY_CACHE_LIMIT
+        or cast(int, census["retained_request_count"]) < 1
+    ):
+        return False
+    executable_counts = tuple(
+        cast(int, census[field])
+        for field in _OTF_RETAINED_STATE_EXECUTABLE_COUNT_FIELDS
+    )
+    active = census["active_family_union_census"]
+    if isinstance(active, Mapping):
+        return (
+            executable_counts[0] > 0
+            and executable_counts[1] == _OTF_FAMILY_CACHE_LIMIT
+            and executable_counts[2] > 0
+        )
+    return active is None and all(count == 0 for count in executable_counts)
+
+
+def _resolve_color_flow_ordinals(
+    physics: ProcessPhysics,
+    requested: Sequence[str],
+) -> tuple[str, ...]:
+    available = physics.color_ids
+    resolved: list[str] = []
+    for value in requested:
+        if value in available:
+            resolved.append(value)
+            continue
+        try:
+            ordinal = int(value, 10)
+        except ValueError:
+            resolved.append(value)
+            continue
+        if str(ordinal) != value.strip() or ordinal < 1 or ordinal > len(available):
+            maximum = len(available)
+            raise EvaluationError(
+                f"color-flow ordinal {value!r} is out of range; choose 1..{maximum} "
+                "or a stable color component ID"
+            )
+        resolved.append(available[ordinal - 1])
+    return tuple(resolved)
+
+
+def _color_workload_text(
+    physics: ProcessPhysics,
+    selected: Sequence[str],
+) -> str:
+    if physics.color_accuracy != "lc":
+        return f"contracted {physics.color_accuracy.upper()} color total"
+    count = len(physics.color_ids)
+    if not selected:
+        return f"all {count} generated physical LC flows"
+    return f"selected {len(selected)}/{count} physical LC flows: {', '.join(selected)}"
+
+
+def _compact_color_workload_text(
+    context: _CompactBenchmarkContext,
+    selected: Sequence[str],
+) -> str:
+    if context.color_accuracy != "lc":
+        return f"contracted {context.color_accuracy.upper()} color total"
+    if not selected:
+        return f"all {context.color_count} generated physical LC flows"
+    return (
+        f"selected {len(selected)}/{context.color_count} physical LC flows: "
+        f"{', '.join(selected)}"
+    )
+
+
+def _helicity_workload_text(
+    physics: ProcessPhysics,
+    selected: Sequence[str],
+) -> str:
+    count = len(physics.helicity_ids)
+    if not selected:
+        structural = physics.structural_zero_helicity_count
+        suffix = f"; {structural} structural zeros" if structural else ""
+        return f"all {count} generated helicity configurations{suffix}"
+    return f"selected {len(selected)}/{count} helicities: {', '.join(selected)}"
+
+
+def _compact_helicity_workload_text(
+    context: _CompactBenchmarkContext,
+    selected: Sequence[str],
+) -> str:
+    if not selected:
+        return f"all {context.helicity_count} generated helicity configurations"
+    return (
+        f"selected {len(selected)}/{context.helicity_count} helicities: "
+        f"{', '.join(selected)}"
+    )
+
+
+def _sample_progress_payload(
+    samples: list[float],
+    *,
+    elapsed_seconds: float,
+    target_seconds: float,
+    repetitions: int,
+    batch_size: int,
+) -> tuple[str, dict[str, str | int | float | None]]:
+    mean, _deviation, error, relative_error = _sample_statistics(samples)
+    if mean < 1.0e-6:
+        scale, unit = 1.0e9, "ns"
+    elif mean < 1.0e-3:
+        scale, unit = 1.0e6, "us"
+    elif mean < 1.0:
+        scale, unit = 1.0e3, "ms"
+    else:
+        scale, unit = 1.0, "s"
+    uncertainty = (
+        "SE pending"
+        if len(samples) < 2
+        else (
+            f"+/- {error * scale:.2g} {unit} "
+            f"(relative standard error {relative_error:.2%})"
+        )
+    )
+    message = (
+        f"{elapsed_seconds:.3g}/{target_seconds:.3g}s; "
+        f"wall {mean * scale:.5g} {unit}/point {uncertainty}; "
+        f"{repetitions} calls x {batch_size} points"
+    )
+    return message, {
+        "progress_kind": "benchmark-statistics",
+        "elapsed_seconds": elapsed_seconds,
+        "target_seconds": target_seconds,
+        "wall_seconds_per_point": mean,
+        "wall_standard_error_seconds_per_point": (error if len(samples) >= 2 else None),
+        "wall_relative_standard_error": (relative_error if len(samples) >= 2 else None),
+        "repetitions": repetitions,
+        "batch_size": batch_size,
+        "sample_count": len(samples),
+    }
+
+
+def _planned_sample_count(
+    config: BenchmarkConfig,
+    *,
+    probe_seconds: float,
+) -> int:
+    if config.minimum_samples == 1:
+        return 1
+    runtime_samples = math.ceil(config.target_runtime / _MAX_SAMPLE_RUNTIME_SECONDS)
+    desired = max(config.minimum_samples, runtime_samples)
+    maximum_for_runtime = max(
+        math.floor(
+            config.target_runtime / max(probe_seconds, _MIN_CLOCK_INTERVAL_SECONDS)
+        ),
+        1,
+    )
+    return max(config.minimum_samples, min(desired, maximum_for_runtime))
+
+
+def _timed_repetitions(callback: Callable[[], object], repetitions: int) -> float:
+    started = time.perf_counter()
+    for _ in range(repetitions):
+        callback()
+    return time.perf_counter() - started
+
+
+def _estimated_repetitions(
+    current: int,
+    observed_seconds: float,
+    target_seconds: float,
+) -> int:
+    observed = max(observed_seconds, _MIN_CLOCK_INTERVAL_SECONDS)
+    estimate = math.ceil(current * target_seconds / observed)
+    return min(max(estimate, 1), _MAX_REPETITIONS_PER_SAMPLE)
+
+
+def _calibrate_repetitions(
+    callback: Callable[[], object],
+    config: BenchmarkConfig,
+    *,
+    initial_seconds: float | None,
+    timer: Callable[[int], float] | None = None,
+) -> _Calibration:
+    measure = timer or (lambda repetitions: _timed_repetitions(callback, repetitions))
+    block_count = 0
+    evaluation_count = 0
+    calibration_elapsed = 0.0
+    if initial_seconds is None:
+        initial_seconds = measure(1)
+        block_count = 1
+        evaluation_count = 1
+        calibration_elapsed = initial_seconds
+
+    probe_seconds = initial_seconds
+    sample_count = _planned_sample_count(config, probe_seconds=probe_seconds)
+    target_sample_seconds = config.target_runtime / sample_count
+    if sample_count == 1:
+        return _Calibration(
+            sample_count=sample_count,
+            repetitions_per_sample=_estimated_repetitions(
+                1,
+                probe_seconds,
+                target_sample_seconds,
+            ),
+            target_sample_seconds=target_sample_seconds,
+            probe_seconds=probe_seconds,
+            block_count=block_count,
+            evaluation_count=evaluation_count,
+            elapsed_seconds=calibration_elapsed,
+        )
+
+    observed_seconds = initial_seconds
+    repetitions = 1
+    for _ in range(_MAX_CALIBRATION_BLOCKS):
+        candidate = _estimated_repetitions(
+            repetitions,
+            observed_seconds,
+            target_sample_seconds,
+        )
+        if candidate == repetitions:
+            break
+        observed_seconds = measure(candidate)
+        block_count += 1
+        evaluation_count += candidate
+        calibration_elapsed += observed_seconds
+        repetitions = candidate
+        ratio = observed_seconds / target_sample_seconds
+        if _CALIBRATION_LOWER_RATIO <= ratio <= _CALIBRATION_UPPER_RATIO:
+            break
+    else:
+        repetitions = _estimated_repetitions(
+            repetitions,
+            observed_seconds,
+            target_sample_seconds,
+        )
+
+    return _Calibration(
+        sample_count=sample_count,
+        repetitions_per_sample=repetitions,
+        target_sample_seconds=target_sample_seconds,
+        probe_seconds=probe_seconds,
+        block_count=block_count,
+        evaluation_count=evaluation_count,
+        elapsed_seconds=calibration_elapsed,
+    )
+
+
+def _native_profiler(
+    runtime: RuntimeBackend,
+) -> Callable[..., Mapping[str, object]] | None:
+    if getattr(runtime, "supports_profiling", None) is False:
+        return None
+    for name in ("profile", "evaluate_profile"):
+        profiler = getattr(runtime, name, None)
+        if callable(profiler):
+            return cast(Callable[..., Mapping[str, object]], profiler)
+    return None
+
+
+def _native_repeated_profiler(
+    runtime: RuntimeBackend,
+) -> Callable[..., Mapping[str, object]] | None:
+    if getattr(runtime, "supports_profiling", None) is False:
+        return None
+    profiler = getattr(runtime, "profile_repeated", None)
+    return (
+        cast(Callable[..., Mapping[str, object]], profiler)
+        if callable(profiler)
+        else None
+    )
+
+
+def _native_wall_timer(runtime: RuntimeBackend) -> Callable[..., float] | None:
+    timer = getattr(runtime, "_benchmark_f64_wall_time", None)
+    return timer if callable(timer) else None
+
+
+def _profile_float(profile: Mapping[str, object], key: str) -> float:
+    value = profile.get(key)
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise EvaluationError(f"native runtime profile field {key!r} is not numeric")
+    value = float(value)
+    if not math.isfinite(value) or value < 0.0:
+        raise EvaluationError(f"native runtime profile field {key!r} is invalid")
+    return value
+
+
+def _profile_float_or_none(profile: Mapping[str, object], key: str) -> float | None:
+    value = profile.get(key)
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        return None
+    result = float(value)
+    if not math.isfinite(result) or result < 0.0:
+        return None
+    return result
+
+
+def _profile_count_or_none(
+    profile: Mapping[str, object],
+    key: str,
+    *,
+    denominator: int,
+) -> float | None:
+    if key not in profile:
+        return None
+    value = profile[key]
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise EvaluationError(
+            f"native runtime profile counter {key!r} is not a non-negative integer"
+        )
+    return value / denominator
+
+
+def _native_profile_counters(
+    profile: Mapping[str, object],
+    *,
+    points: int,
+    repetitions: int,
+) -> _NativeProfileCounterSample | None:
+    arena_counter_presence = tuple(
+        key in profile for key in _COMPILED_DIRECT_ARENA_COUNTER_KEYS
+    )
+    if any(arena_counter_presence) and not all(arena_counter_presence):
+        missing = tuple(
+            key
+            for key, present in zip(
+                _COMPILED_DIRECT_ARENA_COUNTER_KEYS,
+                arena_counter_presence,
+                strict=True,
+            )
+            if not present
+        )
+        raise EvaluationError(
+            "native compiled Direct-Arena profile counters must be jointly "
+            f"available; missing {missing!r}"
+        )
+
+    def per_point(key: str) -> float | None:
+        return _profile_count_or_none(profile, key, denominator=points)
+
+    def per_call(key: str) -> float | None:
+        return _profile_count_or_none(profile, key, denominator=repetitions)
+
+    counters = _NativeProfileCounterSample(
+        native_input_components_per_point=per_point("native_input_component_count"),
+        native_input_pack_bytes_per_point=per_point("native_input_pack_bytes"),
+        native_input_crossing_bytes_per_point=per_point("native_input_crossing_bytes"),
+        state_components_per_point=per_point("state_component_count"),
+        state_clear_components_per_point=per_point("state_clear_component_count"),
+        source_components_per_point=per_point("source_component_count"),
+        momentum_components_per_point=per_point("momentum_component_count"),
+        model_parameter_components_per_point=per_point(
+            "model_parameter_component_count"
+        ),
+        stage_input_copy_components_per_point=per_point(
+            "stage_input_copy_component_count"
+        ),
+        stage_leaf_input_copy_components_per_point=per_point(
+            "stage_leaf_input_copy_component_count"
+        ),
+        stage_evaluator_output_gather_components_per_point=per_point(
+            "stage_evaluator_output_gather_component_count"
+        ),
+        stage_output_assign_components_per_point=per_point(
+            "stage_output_assign_component_count"
+        ),
+        amplitude_input_copy_components_per_point=per_point(
+            "amplitude_input_copy_component_count"
+        ),
+        amplitude_leaf_input_copy_components_per_point=per_point(
+            "amplitude_leaf_input_copy_component_count"
+        ),
+        amplitude_evaluator_output_gather_components_per_point=per_point(
+            "amplitude_evaluator_output_gather_component_count"
+        ),
+        amplitude_output_remap_components_per_point=per_point(
+            "amplitude_output_remap_component_count"
+        ),
+        reduction_input_components_per_point=per_point(
+            "reduction_input_component_count"
+        ),
+        selector_gather_points_per_point=per_point("selector_gather_point_count"),
+        selector_gather_bytes_per_point=per_point("selector_gather_bytes"),
+        selector_scatter_values_per_point=per_point("selector_scatter_value_count"),
+        resolved_materialized_components_per_point=per_point(
+            "resolved_materialized_component_count"
+        ),
+        total_materialized_values_per_point=per_point("total_materialized_value_count"),
+        final_output_copy_values_per_point=per_point("final_output_copy_value_count"),
+        native_input_container_allocations_per_call=per_call(
+            "native_input_container_allocation_count"
+        ),
+        evaluator_backend_calls_per_call=per_call("evaluator_backend_call_count"),
+        compiled_direct_arena_engines_per_call=per_call(
+            "compiled_direct_arena_engine_count"
+        ),
+        compiled_direct_arena_calls_per_call=per_call(
+            "compiled_direct_arena_call_count"
+        ),
+        compiled_direct_arena_boundary_input_bytes_per_call=per_call(
+            "compiled_direct_arena_boundary_input_bytes"
+        ),
+        compiled_direct_arena_boundary_current_output_bytes_per_call=per_call(
+            "compiled_direct_arena_boundary_current_output_bytes"
+        ),
+        compiled_direct_arena_boundary_amplitude_output_bytes_per_call=per_call(
+            "compiled_direct_arena_boundary_amplitude_output_bytes"
+        ),
+        recurrence_momentum_scalar_values_per_point=per_point(
+            "recurrence_momentum_scalar_value_count"
+        ),
+        recurrence_schedule_executions_per_call=per_call(
+            "recurrence_schedule_execution_count"
+        ),
+        recurrence_replay_schedule_executions_per_call=per_call(
+            "recurrence_replay_schedule_execution_count"
+        ),
+        recurrence_union_schedule_executions_per_call=per_call(
+            "recurrence_union_schedule_execution_count"
+        ),
+        recurrence_union_source_rows_per_call=per_call(
+            "recurrence_union_source_row_count"
+        ),
+        recurrence_replay_output_values_per_point=per_point(
+            "recurrence_replay_output_value_count"
+        ),
+        recurrence_source_calls_per_call=per_call("recurrence_source_call_count"),
+        recurrence_source_rows_per_call=per_call("recurrence_source_row_count"),
+        recurrence_contribution_calls_per_call=per_call(
+            "recurrence_contribution_call_count"
+        ),
+        recurrence_contribution_rows_per_call=per_call(
+            "recurrence_contribution_row_count"
+        ),
+        recurrence_finalization_calls_per_call=per_call(
+            "recurrence_finalization_call_count"
+        ),
+        recurrence_finalization_rows_per_call=per_call(
+            "recurrence_finalization_row_count"
+        ),
+        recurrence_closure_calls_per_call=per_call("recurrence_closure_call_count"),
+        recurrence_closure_rows_per_call=per_call("recurrence_closure_row_count"),
+        observed_scratch_reallocations_per_call=per_call(
+            "observed_scratch_reallocation_count"
+        ),
+        native_output_allocations_per_call=per_call("native_output_allocation_count"),
+    )
+    if not any(getattr(counters, field.name) is not None for field in fields(counters)):
+        return None
+    arena_engines = counters.compiled_direct_arena_engines_per_call
+    if arena_engines is not None:
+        arena_calls = counters.compiled_direct_arena_calls_per_call
+        assert arena_calls is not None
+        boundary_counters = (
+            (
+                "compiled_direct_arena_boundary_input_bytes",
+                counters.compiled_direct_arena_boundary_input_bytes_per_call,
+            ),
+            (
+                "compiled_direct_arena_boundary_current_output_bytes",
+                counters.compiled_direct_arena_boundary_current_output_bytes_per_call,
+            ),
+            (
+                "compiled_direct_arena_boundary_amplitude_output_bytes",
+                counters.compiled_direct_arena_boundary_amplitude_output_bytes_per_call,
+            ),
+        )
+        for name, value in boundary_counters:
+            assert value is not None
+            if value != 0.0:
+                raise EvaluationError(
+                    "native compiled Direct-Arena profile observed forbidden "
+                    f"boundary traffic: {name}={value:g} bytes/runtime call"
+                )
+        if (arena_engines > 0.0) != (arena_calls > 0.0):
+            raise EvaluationError(
+                "native compiled Direct-Arena engine and call counters disagree"
+            )
+        if arena_engines > 0.0:
+            evaluator_calls = counters.evaluator_backend_calls_per_call
+            if evaluator_calls is None or evaluator_calls != arena_calls:
+                raise EvaluationError(
+                    "native compiled Direct-Arena calls do not cover every "
+                    "evaluator backend call"
+                )
+    return counters
+
+
+def _profile_float_sequence(
+    profile: Mapping[str, object], key: str
+) -> tuple[float, ...]:
+    values = profile.get(key)
+    if not isinstance(values, Sequence) or isinstance(values, (str, bytes)):
+        raise EvaluationError(
+            f"native runtime profile field {key!r} is not a numeric sequence"
+        )
+    result: list[float] = []
+    for value in values:
+        if isinstance(value, bool) or not isinstance(value, (float, int)):
+            raise EvaluationError(
+                f"native runtime profile field {key!r} is not a numeric sequence"
+            )
+        entry = float(value)
+        if not math.isfinite(entry) or entry < 0.0:
+            raise EvaluationError(f"native runtime profile field {key!r} is invalid")
+        result.append(entry)
+    return tuple(result)
+
+
+def _profile_float_sequence_or_none(
+    profile: Mapping[str, object], key: str
+) -> tuple[float, ...] | None:
+    if key not in profile:
+        return None
+    values = _profile_float_sequence(profile, key)
+    # Eager execution has no compiled-stage timing vector. Rusticol still
+    # supplies the aggregate evaluator timer, so an empty vector means
+    # "unavailable", not a measured zero.
+    return values or None
+
+
+def _profile_execution_mode(
+    profile: Mapping[str, object],
+    *,
+    stage_vectors_present_but_empty: bool,
+) -> str | None:
+    value = profile.get("execution_mode")
+    if value is not None:
+        if value not in {"compiled", "eager", "recurrence", "on-the-fly"}:
+            raise EvaluationError(
+                "native runtime profile execution_mode must be compiled, eager, "
+                "recurrence, or on-the-fly"
+            )
+        return str(value)
+    stage_aggregate = profile.get("stage_evaluator_call_time_s")
+    amplitude_aggregate = profile.get("amplitude_evaluator_call_time_s")
+    if (
+        stage_vectors_present_but_empty
+        and isinstance(stage_aggregate, (float, int))
+        and not isinstance(stage_aggregate, bool)
+        and float(stage_aggregate) > 0.0
+        and isinstance(amplitude_aggregate, (float, int))
+        and not isinstance(amplitude_aggregate, bool)
+        and float(amplitude_aggregate) == 0.0
+    ):
+        return "eager"
+    return None
+
+
+def _profile_point_count(profile: Mapping[str, object], fallback: int) -> int:
+    value: Any = profile.get("points", fallback)
+    if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+        raise EvaluationError("native runtime profile point count is invalid")
+    return int(value)
+
+
+def _native_profile_sample(
+    profile: Mapping[str, object],
+    fallback_points: int,
+    *,
+    repetitions: int = 1,
+) -> _NativeProfileSample:
+    points = _profile_point_count(profile, fallback_points)
+    if (
+        isinstance(repetitions, bool)
+        or not isinstance(repetitions, int)
+        or repetitions < 1
+    ):
+        raise EvaluationError("native runtime profile repetition count is invalid")
+    if points % repetitions != 0:
+        raise EvaluationError(
+            "native runtime profile point count is not divisible by repetitions"
+        )
+    per_point = 1.0 / points
+    counters = _native_profile_counters(
+        profile,
+        points=points,
+        repetitions=repetitions,
+    )
+    stage_vector_keys = (
+        "stage_input_pack_by_stage_time_s",
+        "stage_evaluator_call_by_stage_time_s",
+        "stage_output_assign_by_stage_time_s",
+    )
+    stage_vectors_present_but_empty = all(
+        key in profile
+        and isinstance(profile[key], Sequence)
+        and not isinstance(profile[key], (str, bytes))
+        and len(profile[key]) == 0  # type: ignore[arg-type]
+        for key in stage_vector_keys
+    )
+    stage_input_pack = _profile_float_sequence_or_none(
+        profile, "stage_input_pack_by_stage_time_s"
+    )
+    stage_leaf_input_pack = _profile_float_sequence_or_none(
+        profile, "stage_leaf_input_pack_by_stage_time_s"
+    )
+    stage_evaluator_call = _profile_float_sequence_or_none(
+        profile, "stage_evaluator_call_by_stage_time_s"
+    )
+    stage_backend_call = _profile_float_sequence_or_none(
+        profile, "stage_backend_call_by_stage_time_s"
+    )
+    stage_evaluator_output_gather = _profile_float_sequence_or_none(
+        profile, "stage_evaluator_output_gather_by_stage_time_s"
+    )
+    stage_output_assign = _profile_float_sequence_or_none(
+        profile, "stage_output_assign_by_stage_time_s"
+    )
+    execution_mode = _profile_execution_mode(
+        profile,
+        stage_vectors_present_but_empty=stage_vectors_present_but_empty,
+    )
+    compiled_direct_arena_active = bool(
+        counters is not None
+        and counters.compiled_direct_arena_engines_per_call is not None
+        and counters.compiled_direct_arena_engines_per_call > 0.0
+    )
+    if compiled_direct_arena_active and execution_mode != "compiled":
+        raise EvaluationError(
+            "native compiled Direct-Arena counters require compiled execution mode"
+        )
+
+    stage_input_pack_total = (
+        sum(stage_input_pack)
+        if stage_input_pack is not None
+        else _profile_float_or_none(profile, "stage_input_pack_time_s")
+    )
+    stage_evaluator_call_total = (
+        sum(stage_evaluator_call)
+        if stage_evaluator_call is not None
+        else _profile_float_or_none(profile, "stage_evaluator_call_time_s")
+    )
+    if (
+        stage_evaluator_call_total is None
+        and execution_mode not in _RECURRENCE_LIKE_EXECUTION_MODES
+    ):
+        raise EvaluationError("native runtime stage evaluator timing is unavailable")
+    if stage_evaluator_call_total is None:
+        stage_evaluator_call_total = 0.0
+    output_assign_total = (
+        sum(stage_output_assign)
+        if stage_output_assign is not None
+        else _profile_float_or_none(profile, "output_assign_time_s")
+    )
+    stage_leaf_input_pack_total = (
+        sum(stage_leaf_input_pack)
+        if stage_leaf_input_pack is not None
+        else _profile_float_or_none(profile, "stage_leaf_input_pack_time_s")
+    )
+    stage_backend_call_total = (
+        sum(stage_backend_call)
+        if stage_backend_call is not None
+        else _profile_float_or_none(profile, "stage_backend_call_time_s")
+    )
+    stage_evaluator_output_gather_total = (
+        sum(stage_evaluator_output_gather)
+        if stage_evaluator_output_gather is not None
+        else _profile_float_or_none(profile, "stage_evaluator_output_gather_time_s")
+    )
+    amplitude_evaluator_call: float | None = None
+    if execution_mode not in {"eager", *_RECURRENCE_LIKE_EXECUTION_MODES}:
+        amplitude_evaluator_call = _profile_float_or_none(
+            profile, "amplitude_evaluator_call_time_s"
+        )
+        if amplitude_evaluator_call is None:
+            amplitude_evaluator_call = _profile_float(
+                profile, "amplitude_evaluator_time_s"
+            )
+
+    def normalized(key: str) -> float | None:
+        value = _profile_float_or_none(profile, key)
+        return None if value is None else value * per_point
+
+    def normalized_sequence(
+        values: tuple[float, ...] | None,
+    ) -> tuple[float, ...] | None:
+        if values is None:
+            return None
+        return tuple(value * per_point for value in values)
+
+    wall_time = normalized("wall_time_s")
+    native_input_pack_time = normalized("native_input_pack_time_s")
+    native_input_crossing_time = normalized("native_input_crossing_time_s")
+    orchestration_time = normalized("orchestration_time_s")
+    if compiled_direct_arena_active and orchestration_time is None:
+        raise EvaluationError(
+            "native compiled Direct-Arena orchestration timing is unavailable"
+        )
+    state_prepare_time = normalized("state_prepare_time_s")
+    state_clear_time = normalized("state_clear_time_s")
+    source_fill_time = normalized("source_fill_time_s")
+    momentum_setup_time = normalized("momentum_setup_time_s")
+    momentum_input_setup_time = normalized("momentum_input_setup_time_s")
+    model_parameter_setup_time = normalized("model_parameter_setup_time_s")
+    if momentum_input_setup_time is None:
+        momentum_input_setup_time = momentum_setup_time
+        if (
+            momentum_input_setup_time is not None
+            and model_parameter_setup_time is not None
+        ):
+            momentum_input_setup_time = max(
+                momentum_input_setup_time - model_parameter_setup_time,
+                0.0,
+            )
+    compiled_profile = execution_mode not in {
+        "eager",
+        *_RECURRENCE_LIKE_EXECUTION_MODES,
+    }
+    stage_input_pack_time = (
+        None
+        if not compiled_profile or stage_input_pack_total is None
+        else stage_input_pack_total * per_point
+    )
+    stage_leaf_input_pack_time = (
+        None
+        if not compiled_profile or stage_leaf_input_pack_total is None
+        else stage_leaf_input_pack_total * per_point
+    )
+    stage_evaluator_call_time = stage_evaluator_call_total * per_point
+    stage_backend_call_time = (
+        None
+        if not compiled_profile or stage_backend_call_total is None
+        else stage_backend_call_total * per_point
+    )
+    stage_evaluator_output_gather_time = (
+        None
+        if not compiled_profile or stage_evaluator_output_gather_total is None
+        else stage_evaluator_output_gather_total * per_point
+    )
+    output_assign_time = (
+        None
+        if not compiled_profile or output_assign_total is None
+        else output_assign_total * per_point
+    )
+    amplitude_input_pack_time = (
+        normalized("amplitude_input_pack_time_s") if compiled_profile else None
+    )
+    amplitude_evaluator_call_time = (
+        None
+        if amplitude_evaluator_call is None
+        else amplitude_evaluator_call * per_point
+    )
+    amplitude_leaf_input_pack_time = (
+        normalized("amplitude_leaf_input_pack_time_s") if compiled_profile else None
+    )
+    amplitude_backend_call_time = (
+        normalized("amplitude_backend_call_time_s") if compiled_profile else None
+    )
+    amplitude_evaluator_output_gather_time = (
+        normalized("amplitude_evaluator_output_gather_time_s")
+        if compiled_profile
+        else None
+    )
+    amplitude_output_remap_time = (
+        normalized("amplitude_output_remap_time_s") if compiled_profile else None
+    )
+    reduction_time = (
+        normalized("eager_reduction_time_s")
+        if execution_mode == "eager"
+        else normalized("reduction_time_s")
+    )
+    total_materialization_time = normalized("total_materialization_time_s")
+    final_output_copy_time = normalized("final_output_copy_time_s")
+    selector_planner_time = normalized("selector_planner_time_s")
+    selector_gather_time = normalized("selector_gather_time_s")
+    selector_scatter_time = normalized("selector_scatter_time_s")
+    eager_execution_time = (
+        stage_evaluator_call_time if execution_mode == "eager" else None
+    )
+    eager_initialize_time = normalized("eager_initialize_time_s")
+    eager_gather_time = normalized("eager_gather_time_s")
+    eager_kernel_call_time = normalized("eager_kernel_call_time_s")
+    eager_invocation_scatter_time = normalized("eager_invocation_scatter_time_s")
+    eager_finalization_time = normalized("eager_finalization_time_s")
+    eager_scatter_finalization_time = normalized("eager_scatter_finalization_time_s")
+    eager_closure_time = normalized("eager_closure_time_s")
+    eager_copy_out_time = normalized("eager_copy_out_time_s")
+    recurrence_momentum_fill_time = normalized("recurrence_momentum_fill_time_s")
+    recurrence_union_source_fill_time = normalized(
+        "recurrence_union_source_fill_time_s"
+    )
+    recurrence_schedule_time = normalized("recurrence_schedule_time_s")
+    recurrence_source_kernel_time = normalized("recurrence_source_kernel_time_s")
+    recurrence_contribution_kernel_time = normalized(
+        "recurrence_contribution_kernel_time_s"
+    )
+    recurrence_finalization_time = normalized("recurrence_finalization_time_s")
+    recurrence_closure_time = normalized("recurrence_closure_time_s")
+    recurrence_replay_output_mapping_time = normalized(
+        "recurrence_replay_output_mapping_time_s"
+    )
+    if (
+        execution_mode in _RECURRENCE_LIKE_EXECUTION_MODES
+        and recurrence_schedule_time is None
+    ):
+        raise EvaluationError("native recurrence-like schedule timing is unavailable")
+
+    common_accounted = (
+        native_input_pack_time,
+        native_input_crossing_time,
+        orchestration_time,
+        state_prepare_time,
+        state_clear_time,
+        source_fill_time,
+        momentum_input_setup_time,
+        model_parameter_setup_time,
+    )
+    if execution_mode == "eager":
+        mode_accounted = (eager_execution_time,)
+    elif execution_mode in _RECURRENCE_LIKE_EXECUTION_MODES:
+        mode_accounted = (
+            recurrence_momentum_fill_time,
+            recurrence_union_source_fill_time,
+            recurrence_schedule_time,
+            recurrence_replay_output_mapping_time,
+            reduction_time,
+        )
+    else:
+        mode_accounted = (
+            stage_input_pack_time,
+            stage_evaluator_call_time,
+            output_assign_time,
+            amplitude_input_pack_time,
+            amplitude_evaluator_call_time,
+            reduction_time,
+        )
+    accounted = (
+        *common_accounted,
+        *mode_accounted,
+        total_materialization_time,
+        final_output_copy_time,
+        selector_planner_time,
+        selector_gather_time,
+        selector_scatter_time,
+    )
+    accounted_total = sum(value or 0.0 for value in accounted)
+    accounting_tolerance = (
+        1.0e-12 if wall_time is None else max(1.0e-12, wall_time * 1.0e-12)
+    )
+    if wall_time is not None and accounted_total > wall_time + accounting_tolerance:
+        raise EvaluationError(
+            "native profile exclusive top-level phases account for "
+            f"{accounted_total:.9e}s/point, exceeding wall time "
+            f"{wall_time:.9e}s/point"
+        )
+    if execution_mode == "eager" and eager_execution_time is not None:
+        scatter_phases = (
+            (eager_invocation_scatter_time, eager_finalization_time)
+            if eager_invocation_scatter_time is not None
+            or eager_finalization_time is not None
+            else (eager_scatter_finalization_time,)
+        )
+        exclusive_eager_phases = (
+            eager_initialize_time,
+            eager_gather_time,
+            eager_kernel_call_time,
+            *scatter_phases,
+            eager_closure_time,
+            reduction_time,
+            eager_copy_out_time,
+        )
+        exclusive_eager_total = sum(value or 0.0 for value in exclusive_eager_phases)
+        if exclusive_eager_total > eager_execution_time + accounting_tolerance:
+            raise EvaluationError(
+                "native eager profile exclusive execution phases account for "
+                f"{exclusive_eager_total:.9e}s/point, exceeding the inclusive "
+                f"eager execution time {eager_execution_time:.9e}s/point"
+            )
+    if (
+        execution_mode in _RECURRENCE_LIKE_EXECUTION_MODES
+        and recurrence_schedule_time is not None
+    ):
+        recurrence_attribution = (
+            recurrence_source_kernel_time,
+            recurrence_contribution_kernel_time,
+            recurrence_finalization_time,
+            recurrence_closure_time,
+        )
+        recurrence_attributed_total = sum(
+            value or 0.0 for value in recurrence_attribution
+        )
+        if recurrence_attributed_total > (
+            recurrence_schedule_time + accounting_tolerance
+        ):
+            raise EvaluationError(
+                "native recurrence profile schedule sub-attribution accounts for "
+                f"{recurrence_attributed_total:.9e}s/point, exceeding the "
+                "inclusive recurrence schedule time "
+                f"{recurrence_schedule_time:.9e}s/point"
+            )
+    other_core_time = (
+        None if wall_time is None else max(wall_time - accounted_total, 0.0)
+    )
+
+    return _NativeProfileSample(
+        execution_mode=execution_mode,
+        compiled_direct_arena_active=compiled_direct_arena_active,
+        wall_time=wall_time,
+        native_input_pack_time=native_input_pack_time,
+        native_input_crossing_time=native_input_crossing_time,
+        orchestration_time=orchestration_time,
+        state_prepare_time=state_prepare_time,
+        state_clear_time=state_clear_time,
+        source_fill_time=source_fill_time,
+        momentum_input_setup_time=momentum_input_setup_time,
+        momentum_setup_time=momentum_setup_time,
+        model_parameter_setup_time=model_parameter_setup_time,
+        stage_input_pack_time=stage_input_pack_time,
+        stage_leaf_input_pack_time=stage_leaf_input_pack_time,
+        stage_evaluator_call_time=stage_evaluator_call_time,
+        stage_backend_call_time=stage_backend_call_time,
+        stage_evaluator_output_gather_time=stage_evaluator_output_gather_time,
+        output_assign_time=output_assign_time,
+        amplitude_input_pack_time=amplitude_input_pack_time,
+        amplitude_evaluator_call_time=amplitude_evaluator_call_time,
+        amplitude_leaf_input_pack_time=amplitude_leaf_input_pack_time,
+        amplitude_backend_call_time=amplitude_backend_call_time,
+        amplitude_evaluator_output_gather_time=(amplitude_evaluator_output_gather_time),
+        amplitude_output_remap_time=amplitude_output_remap_time,
+        reduction_time=reduction_time,
+        total_materialization_time=total_materialization_time,
+        final_output_copy_time=final_output_copy_time,
+        selector_planner_time=selector_planner_time,
+        selector_gather_time=selector_gather_time,
+        selector_scatter_time=selector_scatter_time,
+        other_core_time=other_core_time,
+        stage_input_pack_times=(
+            normalized_sequence(stage_input_pack) if compiled_profile else None
+        ),
+        stage_leaf_input_pack_times=(
+            normalized_sequence(stage_leaf_input_pack) if compiled_profile else None
+        ),
+        stage_evaluator_call_times=(
+            normalized_sequence(stage_evaluator_call) if compiled_profile else None
+        ),
+        stage_backend_call_times=(
+            normalized_sequence(stage_backend_call) if compiled_profile else None
+        ),
+        stage_evaluator_output_gather_times=normalized_sequence(
+            stage_evaluator_output_gather if compiled_profile else None
+        ),
+        stage_output_assign_times=(
+            normalized_sequence(stage_output_assign) if compiled_profile else None
+        ),
+        eager_initialize_time=eager_initialize_time,
+        eager_gather_time=eager_gather_time,
+        eager_kernel_call_time=eager_kernel_call_time,
+        eager_invocation_scatter_time=eager_invocation_scatter_time,
+        eager_finalization_time=eager_finalization_time,
+        eager_scatter_finalization_time=eager_scatter_finalization_time,
+        eager_closure_time=eager_closure_time,
+        eager_copy_out_time=eager_copy_out_time,
+        recurrence_momentum_fill_time=recurrence_momentum_fill_time,
+        recurrence_union_source_fill_time=recurrence_union_source_fill_time,
+        recurrence_schedule_time=recurrence_schedule_time,
+        recurrence_source_kernel_time=recurrence_source_kernel_time,
+        recurrence_contribution_kernel_time=recurrence_contribution_kernel_time,
+        recurrence_finalization_time=recurrence_finalization_time,
+        recurrence_closure_time=recurrence_closure_time,
+        recurrence_replay_output_mapping_time=(recurrence_replay_output_mapping_time),
+        counters=counters,
+    )
+
+
+def _component_timing(
+    values: Sequence[float | None],
+) -> BenchmarkComponentTiming | None:
+    available = [value for value in values if value is not None]
+    if not available:
+        return None
+    mean, deviation, error, relative_error = _sample_statistics(available)
+    return BenchmarkComponentTiming(
+        mean_seconds_per_point=mean,
+        uncertainty=BenchmarkStatistics(deviation, error, relative_error),
+        sample_count=len(available),
+    )
+
+
+def _stage_component_timing(
+    samples: Sequence[_NativeProfileSample],
+    attribute: str,
+    stage_index: int,
+) -> BenchmarkComponentTiming | None:
+    values: list[float | None] = []
+    for sample in samples:
+        stage_values = getattr(sample, attribute)
+        if not isinstance(stage_values, tuple) or stage_index >= len(stage_values):
+            values.append(None)
+        else:
+            values.append(stage_values[stage_index])
+    return _component_timing(values)
+
+
+def _profile_counter_summary(
+    samples: Sequence[_NativeProfileSample],
+) -> BenchmarkProfileCounters | None:
+    counter_samples = [
+        sample.counters for sample in samples if sample.counters is not None
+    ]
+    if not counter_samples:
+        return None
+    if len(counter_samples) != len(samples):
+        raise EvaluationError(
+            "native runtime profile counter availability changed between samples"
+        )
+
+    def mean(attribute: str) -> float | None:
+        values = [
+            cast(float | None, getattr(sample, attribute)) for sample in counter_samples
+        ]
+        available = [value for value in values if value is not None]
+        if available and len(available) != len(values):
+            raise EvaluationError(
+                f"native runtime profile counter {attribute!r} changed availability"
+            )
+        return statistics.fmean(available) if available else None
+
+    return BenchmarkProfileCounters(
+        sample_count=len(counter_samples),
+        native_input_components_per_point=mean("native_input_components_per_point"),
+        native_input_pack_bytes_per_point=mean("native_input_pack_bytes_per_point"),
+        native_input_crossing_bytes_per_point=mean(
+            "native_input_crossing_bytes_per_point"
+        ),
+        state_components_per_point=mean("state_components_per_point"),
+        state_clear_components_per_point=mean("state_clear_components_per_point"),
+        source_components_per_point=mean("source_components_per_point"),
+        momentum_components_per_point=mean("momentum_components_per_point"),
+        model_parameter_components_per_point=mean(
+            "model_parameter_components_per_point"
+        ),
+        stage_input_copy_components_per_point=mean(
+            "stage_input_copy_components_per_point"
+        ),
+        stage_leaf_input_copy_components_per_point=mean(
+            "stage_leaf_input_copy_components_per_point"
+        ),
+        stage_evaluator_output_gather_components_per_point=mean(
+            "stage_evaluator_output_gather_components_per_point"
+        ),
+        stage_output_assign_components_per_point=mean(
+            "stage_output_assign_components_per_point"
+        ),
+        amplitude_input_copy_components_per_point=mean(
+            "amplitude_input_copy_components_per_point"
+        ),
+        amplitude_leaf_input_copy_components_per_point=mean(
+            "amplitude_leaf_input_copy_components_per_point"
+        ),
+        amplitude_evaluator_output_gather_components_per_point=mean(
+            "amplitude_evaluator_output_gather_components_per_point"
+        ),
+        amplitude_output_remap_components_per_point=mean(
+            "amplitude_output_remap_components_per_point"
+        ),
+        reduction_input_components_per_point=mean(
+            "reduction_input_components_per_point"
+        ),
+        selector_gather_points_per_point=mean("selector_gather_points_per_point"),
+        selector_gather_bytes_per_point=mean("selector_gather_bytes_per_point"),
+        selector_scatter_values_per_point=mean("selector_scatter_values_per_point"),
+        resolved_materialized_components_per_point=mean(
+            "resolved_materialized_components_per_point"
+        ),
+        total_materialized_values_per_point=mean("total_materialized_values_per_point"),
+        final_output_copy_values_per_point=mean("final_output_copy_values_per_point"),
+        native_input_container_allocations_per_call=mean(
+            "native_input_container_allocations_per_call"
+        ),
+        evaluator_backend_calls_per_call=mean("evaluator_backend_calls_per_call"),
+        compiled_direct_arena_engines_per_call=mean(
+            "compiled_direct_arena_engines_per_call"
+        ),
+        compiled_direct_arena_calls_per_call=mean(
+            "compiled_direct_arena_calls_per_call"
+        ),
+        compiled_direct_arena_boundary_input_bytes_per_call=mean(
+            "compiled_direct_arena_boundary_input_bytes_per_call"
+        ),
+        compiled_direct_arena_boundary_current_output_bytes_per_call=mean(
+            "compiled_direct_arena_boundary_current_output_bytes_per_call"
+        ),
+        compiled_direct_arena_boundary_amplitude_output_bytes_per_call=mean(
+            "compiled_direct_arena_boundary_amplitude_output_bytes_per_call"
+        ),
+        recurrence_momentum_scalar_values_per_point=mean(
+            "recurrence_momentum_scalar_values_per_point"
+        ),
+        recurrence_schedule_executions_per_call=mean(
+            "recurrence_schedule_executions_per_call"
+        ),
+        recurrence_replay_schedule_executions_per_call=mean(
+            "recurrence_replay_schedule_executions_per_call"
+        ),
+        recurrence_union_schedule_executions_per_call=mean(
+            "recurrence_union_schedule_executions_per_call"
+        ),
+        recurrence_union_source_rows_per_call=mean(
+            "recurrence_union_source_rows_per_call"
+        ),
+        recurrence_replay_output_values_per_point=mean(
+            "recurrence_replay_output_values_per_point"
+        ),
+        recurrence_source_calls_per_call=mean("recurrence_source_calls_per_call"),
+        recurrence_source_rows_per_call=mean("recurrence_source_rows_per_call"),
+        recurrence_contribution_calls_per_call=mean(
+            "recurrence_contribution_calls_per_call"
+        ),
+        recurrence_contribution_rows_per_call=mean(
+            "recurrence_contribution_rows_per_call"
+        ),
+        recurrence_finalization_calls_per_call=mean(
+            "recurrence_finalization_calls_per_call"
+        ),
+        recurrence_finalization_rows_per_call=mean(
+            "recurrence_finalization_rows_per_call"
+        ),
+        recurrence_closure_calls_per_call=mean("recurrence_closure_calls_per_call"),
+        recurrence_closure_rows_per_call=mean("recurrence_closure_rows_per_call"),
+        observed_scratch_reallocations_per_call=mean(
+            "observed_scratch_reallocations_per_call"
+        ),
+        native_output_allocations_per_call=mean("native_output_allocations_per_call"),
+    )
+
+
+def _timing_breakdown(
+    samples: Sequence[_NativeProfileSample],
+) -> BenchmarkTimingBreakdown:
+    if not samples:
+        raise EvaluationError("native runtime profile returned no timing samples")
+    stage_count = max(
+        (
+            len(values)
+            for sample in samples
+            for values in (
+                sample.stage_input_pack_times,
+                sample.stage_leaf_input_pack_times,
+                sample.stage_evaluator_call_times,
+                sample.stage_backend_call_times,
+                sample.stage_evaluator_output_gather_times,
+                sample.stage_output_assign_times,
+            )
+            if values is not None
+        ),
+        default=0,
+    )
+    stages: list[BenchmarkStageTiming] = []
+    for stage_index in range(stage_count):
+        input_pack = _stage_component_timing(
+            samples, "stage_input_pack_times", stage_index
+        )
+        evaluator_call = _stage_component_timing(
+            samples, "stage_evaluator_call_times", stage_index
+        )
+        leaf_input_pack = _stage_component_timing(
+            samples, "stage_leaf_input_pack_times", stage_index
+        )
+        backend_call = _stage_component_timing(
+            samples, "stage_backend_call_times", stage_index
+        )
+        evaluator_output_gather = _stage_component_timing(
+            samples, "stage_evaluator_output_gather_times", stage_index
+        )
+        output_assign = _stage_component_timing(
+            samples, "stage_output_assign_times", stage_index
+        )
+        if any(
+            value is not None
+            for value in (
+                input_pack,
+                evaluator_call,
+                output_assign,
+                leaf_input_pack,
+                backend_call,
+                evaluator_output_gather,
+            )
+        ):
+            stages.append(
+                BenchmarkStageTiming(
+                    stage_index=stage_index + 1,
+                    input_pack_time=input_pack,
+                    evaluator_call_time=evaluator_call,
+                    output_assign_time=output_assign,
+                    leaf_input_pack_time=leaf_input_pack,
+                    backend_call_time=backend_call,
+                    evaluator_output_gather_time=evaluator_output_gather,
+                )
+            )
+
+    execution_modes = {
+        sample.execution_mode for sample in samples if sample.execution_mode is not None
+    }
+    if len(execution_modes) > 1:
+        raise EvaluationError("native runtime profile changed execution mode")
+    execution_mode = cast(
+        Literal["compiled", "eager", "recurrence", "on-the-fly"],
+        next(iter(execution_modes), "compiled"),
+    )
+    evaluator_call_time = _component_timing(
+        [sample.stage_evaluator_call_time for sample in samples]
+    )
+    return BenchmarkTimingBreakdown(
+        sample_count=len(samples),
+        execution_mode=execution_mode,
+        wall_time=_component_timing([sample.wall_time for sample in samples]),
+        native_input_pack_time=_component_timing(
+            [sample.native_input_pack_time for sample in samples]
+        ),
+        native_input_crossing_time=_component_timing(
+            [sample.native_input_crossing_time for sample in samples]
+        ),
+        orchestration_time=_component_timing(
+            [sample.orchestration_time for sample in samples]
+        ),
+        state_prepare_time=_component_timing(
+            [sample.state_prepare_time for sample in samples]
+        ),
+        state_clear_time=_component_timing(
+            [sample.state_clear_time for sample in samples]
+        ),
+        source_fill_time=_component_timing(
+            [sample.source_fill_time for sample in samples]
+        ),
+        momentum_setup_time=_component_timing(
+            [sample.momentum_setup_time for sample in samples]
+        ),
+        momentum_input_setup_time=_component_timing(
+            [sample.momentum_input_setup_time for sample in samples]
+        ),
+        model_parameter_setup_time=_component_timing(
+            [sample.model_parameter_setup_time for sample in samples]
+        ),
+        stage_input_pack_time=_component_timing(
+            [sample.stage_input_pack_time for sample in samples]
+        ),
+        stage_leaf_input_pack_time=_component_timing(
+            [sample.stage_leaf_input_pack_time for sample in samples]
+        ),
+        stage_evaluator_call_time=(
+            None
+            if execution_mode in {"eager", *_RECURRENCE_LIKE_EXECUTION_MODES}
+            else evaluator_call_time
+        ),
+        stage_backend_call_time=_component_timing(
+            [sample.stage_backend_call_time for sample in samples]
+        ),
+        stage_evaluator_output_gather_time=_component_timing(
+            [sample.stage_evaluator_output_gather_time for sample in samples]
+        ),
+        output_assign_time=_component_timing(
+            [sample.output_assign_time for sample in samples]
+        ),
+        amplitude_input_pack_time=_component_timing(
+            [sample.amplitude_input_pack_time for sample in samples]
+        ),
+        amplitude_evaluator_call_time=_component_timing(
+            [sample.amplitude_evaluator_call_time for sample in samples]
+        ),
+        amplitude_leaf_input_pack_time=_component_timing(
+            [sample.amplitude_leaf_input_pack_time for sample in samples]
+        ),
+        amplitude_backend_call_time=_component_timing(
+            [sample.amplitude_backend_call_time for sample in samples]
+        ),
+        amplitude_evaluator_output_gather_time=_component_timing(
+            [sample.amplitude_evaluator_output_gather_time for sample in samples]
+        ),
+        amplitude_output_remap_time=_component_timing(
+            [sample.amplitude_output_remap_time for sample in samples]
+        ),
+        reduction_time=_component_timing([sample.reduction_time for sample in samples]),
+        total_materialization_time=_component_timing(
+            [sample.total_materialization_time for sample in samples]
+        ),
+        final_output_copy_time=_component_timing(
+            [sample.final_output_copy_time for sample in samples]
+        ),
+        selector_planner_time=_component_timing(
+            [sample.selector_planner_time for sample in samples]
+        ),
+        selector_gather_time=_component_timing(
+            [sample.selector_gather_time for sample in samples]
+        ),
+        selector_scatter_time=_component_timing(
+            [sample.selector_scatter_time for sample in samples]
+        ),
+        other_core_time=_component_timing(
+            [sample.other_core_time for sample in samples]
+        ),
+        eager_execution_time=(
+            evaluator_call_time if execution_mode == "eager" else None
+        ),
+        eager_initialize_time=_component_timing(
+            [sample.eager_initialize_time for sample in samples]
+        ),
+        eager_gather_time=_component_timing(
+            [sample.eager_gather_time for sample in samples]
+        ),
+        eager_kernel_call_time=_component_timing(
+            [sample.eager_kernel_call_time for sample in samples]
+        ),
+        eager_invocation_scatter_time=_component_timing(
+            [sample.eager_invocation_scatter_time for sample in samples]
+        ),
+        eager_finalization_time=_component_timing(
+            [sample.eager_finalization_time for sample in samples]
+        ),
+        eager_scatter_finalization_time=_component_timing(
+            [sample.eager_scatter_finalization_time for sample in samples]
+        ),
+        eager_closure_time=_component_timing(
+            [sample.eager_closure_time for sample in samples]
+        ),
+        eager_copy_out_time=_component_timing(
+            [sample.eager_copy_out_time for sample in samples]
+        ),
+        recurrence_momentum_fill_time=_component_timing(
+            [sample.recurrence_momentum_fill_time for sample in samples]
+        ),
+        recurrence_union_source_fill_time=_component_timing(
+            [sample.recurrence_union_source_fill_time for sample in samples]
+        ),
+        recurrence_schedule_time=_component_timing(
+            [sample.recurrence_schedule_time for sample in samples]
+        ),
+        recurrence_source_kernel_time=_component_timing(
+            [sample.recurrence_source_kernel_time for sample in samples]
+        ),
+        recurrence_contribution_kernel_time=_component_timing(
+            [sample.recurrence_contribution_kernel_time for sample in samples]
+        ),
+        recurrence_finalization_time=_component_timing(
+            [sample.recurrence_finalization_time for sample in samples]
+        ),
+        recurrence_closure_time=_component_timing(
+            [sample.recurrence_closure_time for sample in samples]
+        ),
+        recurrence_replay_output_mapping_time=_component_timing(
+            [sample.recurrence_replay_output_mapping_time for sample in samples]
+        ),
+        stages=tuple(stages),
+        counters=_profile_counter_summary(samples),
+    )
+
+
+def _sample_statistics(samples: list[float]) -> tuple[float, float, float, float]:
+    mean = statistics.fmean(samples)
+    deviation = statistics.stdev(samples) if len(samples) > 1 else 0.0
+    error = deviation / math.sqrt(len(samples))
+    relative_error = error / mean if mean > 0.0 else 0.0
+    return mean, deviation, error, relative_error
+
+
+def create_benchmark_backend(
+    config: BenchmarkConfig | RunConfig | None,
+    progress: ProgressSink | None,
+) -> BenchmarkBackend:
+    return BenchmarkBackend(config, progress)
+
+
+__all__ = ["BenchmarkBackend", "create_benchmark_backend"]
diff --git a/pyamplicol/src/pyamplicol/cli/__init__.py b/pyamplicol/src/pyamplicol/cli/__init__.py
new file mode 100644
index 0000000000..925f965073
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/cli/__init__.py
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from .handlers import CliServices, DefaultCliServices, dispatch
+from .licensing import LicenseRequestInvocation
+from .main import main, run_cli, write_result
+from .parser import CliInvocation, build_card_parser, build_parser, parse_cli
+from .utilities import ExampleEntry, UtilityInvocation
+
+__all__ = [
+    "CliInvocation",
+    "CliServices",
+    "DefaultCliServices",
+    "ExampleEntry",
+    "LicenseRequestInvocation",
+    "UtilityInvocation",
+    "build_card_parser",
+    "build_parser",
+    "dispatch",
+    "main",
+    "parse_cli",
+    "run_cli",
+    "write_result",
+]
diff --git a/pyamplicol/src/pyamplicol/cli/__main__.py b/pyamplicol/src/pyamplicol/cli/__main__.py
new file mode 100644
index 0000000000..6ef9301e68
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/cli/__main__.py
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from .main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/src/pyamplicol/cli/handlers.py b/pyamplicol/src/pyamplicol/cli/handlers.py
new file mode 100644
index 0000000000..fcea3f4b51
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/cli/handlers.py
@@ -0,0 +1,643 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import Callable, Mapping
+from dataclasses import fields, replace
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal, Protocol, TypeVar, cast
+
+from pyamplicol.api.errors import ConfigurationError
+from pyamplicol.config import ConfigResolution, EvaluatorConfig, RunConfig
+from pyamplicol.reporting import (
+    ProgressEnd,
+    ProgressSink,
+    ProgressStart,
+    ProgressUpdate,
+)
+
+if TYPE_CHECKING:
+    from pyamplicol.api import ModelSource, ProcessSet
+    from pyamplicol.artifacts.inspection import (
+        ArtifactInspection,
+        ArtifactProcessInspection,
+    )
+    from pyamplicol.correlators import CorrelatorConfig
+    from pyamplicol.models.loading import CompiledModel as _CompiledModelPayload
+
+_T = TypeVar("_T")
+
+
+class CliServices(Protocol):
+    """Command-level service boundary used by CLI handlers."""
+
+    def generate(self, config: RunConfig, progress: ProgressSink) -> object: ...
+
+    def plan(self, config: RunConfig, progress: ProgressSink) -> object: ...
+
+    def evaluate(self, config: RunConfig, progress: ProgressSink) -> object: ...
+
+    def benchmark(self, config: RunConfig, progress: ProgressSink) -> object: ...
+
+    def inspect(
+        self,
+        config: RunConfig,
+        progress: ProgressSink,
+        *,
+        full_physics: bool = False,
+    ) -> object: ...
+
+    def model_inspect(self, config: RunConfig, progress: ProgressSink) -> object: ...
+
+    def model_compile(self, config: RunConfig, progress: ProgressSink) -> object: ...
+
+    def model_processes(self, config: RunConfig, progress: ProgressSink) -> object: ...
+
+    def group_processes(self, config: RunConfig, progress: ProgressSink) -> object: ...
+
+
+def dispatch(
+    config: RunConfig,
+    services: CliServices,
+    progress: ProgressSink,
+    *,
+    dry_run: bool = False,
+    full_physics: bool = False,
+) -> object:
+    """Dispatch a typed config without importing a concrete domain backend."""
+
+    if config.action == "generate":
+        return (
+            services.plan(config, progress)
+            if dry_run
+            else services.generate(config, progress)
+        )
+    if config.action == "evaluate":
+        return services.evaluate(config, progress)
+    if config.action == "benchmark":
+        return services.benchmark(config, progress)
+    if config.action == "inspect":
+        if full_physics:
+            return services.inspect(config, progress, full_physics=True)
+        return services.inspect(config, progress)
+    if config.action == "model-inspect":
+        return services.model_inspect(config, progress)
+    if config.action == "model-compile":
+        return services.model_compile(config, progress)
+    if config.action == "model-processes":
+        return services.model_processes(config, progress)
+    if config.action == "group-processes":
+        return services.group_processes(config, progress)
+    raise ConfigurationError(f"unsupported action {config.action!r}")
+
+
+def _model_source(config: RunConfig) -> ModelSource:
+    from pyamplicol.api import ModelSource
+
+    return ModelSource.from_config(config.model)
+
+
+def _process_set(config: RunConfig) -> ProcessSet:
+    from pyamplicol.api import ProcessRequest, ProcessSet
+
+    requests: list[ProcessRequest] = []
+    errors: list[str] = []
+    for index, entry in enumerate(config.process.entries):
+        try:
+            requests.append(ProcessRequest.parse(entry.expression, name=entry.name))
+        except (TypeError, ValueError) as exc:
+            errors.append(f"process.entries[{index}]: {exc}")
+    if errors:
+        raise ConfigurationError(errors)
+    try:
+        return ProcessSet(tuple(requests))
+    except (TypeError, ValueError) as exc:
+        raise ConfigurationError(str(exc)) from exc
+
+
+def _read_json(path: Path) -> object:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise ConfigurationError(f"cannot read {path}: {exc}") from exc
+    except json.JSONDecodeError as exc:
+        raise ConfigurationError(f"invalid JSON in {path}: {exc}") from exc
+
+
+def _load_process_output(
+    path: Path,
+    progress: ProgressSink,
+    callback: Callable[[], _T],
+) -> _T:
+    resolved = path.expanduser().resolve(strict=False)
+    task_id = "process-output-load"
+    started = time.perf_counter()
+    progress.emit(
+        ProgressStart(
+            task_id,
+            f"Loading process output {resolved}",
+            details={"step": "loading process output", "path": str(resolved)},
+        )
+    )
+    try:
+        result = callback()
+    except Exception as exc:
+        progress.emit(
+            ProgressEnd(
+                task_id,
+                success=False,
+                message=str(exc),
+                elapsed_seconds=time.perf_counter() - started,
+            )
+        )
+        raise
+    progress.emit(
+        ProgressEnd(
+            task_id,
+            elapsed_seconds=time.perf_counter() - started,
+        )
+    )
+    return result
+
+
+def _select_compact_process_inspection(
+    inspection: ArtifactInspection,
+    selector: str,
+) -> ArtifactInspection:
+    """Select one representative without loading its executable runtime."""
+
+    def select(matches: list[ArtifactProcessInspection]) -> ArtifactInspection:
+        representatives = {item.id: item for item in matches}
+        if len(representatives) > 1:
+            identifiers = ", ".join(sorted(representatives))
+            raise ConfigurationError(
+                f"inspect process selector {selector!r} is ambiguous across "
+                f"representatives: {identifiers}"
+            )
+        if representatives:
+            selected = next(iter(representatives.values()))
+            groups = inspection.process_groups
+            if groups is not None:
+                groups = replace(
+                    groups,
+                    groups=tuple(
+                        group
+                        for group in groups.groups
+                        if any(member.id == selected.id for member in group.members)
+                    ),
+                )
+            return replace(inspection, processes=(selected,), process_groups=groups)
+        groups = inspection.process_groups
+        for group in () if groups is None else groups.groups:
+            member = next(
+                (
+                    item
+                    for item in group.members[1:]
+                    if not item.generated and selector in {item.id, item.process}
+                ),
+                None,
+            )
+            if member is not None:
+                raise ConfigurationError(
+                    f"inspect process {member.id} ({member.process}) is a routed "
+                    f"member of process group {group.representative_id} "
+                    f"({group.representative}) with no runtime of its own; "
+                    f"--process {group.representative_id} lists the group, and "
+                    "--full-physics shows the member's relation and physics"
+                )
+        raise ConfigurationError(
+            f"inspect process selector {selector!r} did not match a stable "
+            "representative ID, alias ID, or exact process expression; add "
+            "--full-physics to resolve permutations and process-group members"
+        )
+
+    identifier_matches = [
+        process
+        for process in inspection.processes
+        if process.id == selector
+        or any(alias.id == selector for alias in process.aliases)
+    ]
+    if identifier_matches:
+        return select(identifier_matches)
+    return select(
+        [
+            process
+            for process in inspection.processes
+            if process.expression == selector
+            or any(alias.expression == selector for alias in process.aliases)
+        ]
+    )
+
+
+def _full_physics_inspection(artifact: Path, selector: str | None) -> object:
+    """Return the selected process physics and, when grouped, its relation.
+
+    Rusticol owns process selection, so side permutations and non-generated
+    process-group members resolve as in `evaluate`. A grouped selection keeps
+    every physics field at the top level and adds ``process_group``.
+    """
+
+    from pyamplicol.api import Runtime
+    from pyamplicol.api.results import ProcessPhysics
+    from pyamplicol.artifacts.inspection import process_group_selection
+
+    runtime = Runtime.load(artifact, process=selector)
+    physics = runtime.physics
+    if not isinstance(physics, ProcessPhysics):
+        return physics
+    group = process_group_selection(
+        artifact,
+        physics.process_id,
+        permutation=runtime.external_permutation,
+    )
+    if group is None:
+        return physics
+    return {
+        **{item.name: getattr(physics, item.name) for item in fields(physics)},
+        "process_group": group,
+    }
+
+
+def _compile_configured_model(
+    config: RunConfig,
+    *,
+    require_supported: bool,
+) -> _CompiledModelPayload:
+    from pyamplicol.api.requests import ModelSource, _compile_model_source_payload
+
+    payload = _compile_model_source_payload(
+        ModelSource.from_config(config.model),
+        cache_dir=config.model.cache_dir,
+        use_cache=config.model.cache,
+        require_supported=require_supported,
+    )
+    return cast("_CompiledModelPayload", payload)
+
+
+def _model_inspection_payload(compiled: _CompiledModelPayload) -> dict[str, object]:
+    return {
+        "name": compiled.name,
+        "supported": compiled.supported,
+        "source": dict(compiled.source),
+        "producer": dict(compiled.producer),
+        "capabilities": dict(compiled.capabilities),
+        "issues": [issue.to_dict() for issue in compiled.issues],
+        "conversion_seconds": compiled.conversion_seconds,
+        "phase_timings": dict(compiled.phase_timings),
+        "contents": {
+            "orders": [order.name for order in compiled.ir.orders],
+            "particles": [particle.to_dict() for particle in compiled.ir.particles],
+            "runtime_parameter_names": sorted(compiled.parameter_defaults),
+        },
+    }
+
+
+class DefaultCliServices:
+    """Thin adapters over the public API; backend imports remain first-use only."""
+
+    def __init__(
+        self,
+        *,
+        resolution: ConfigResolution | None = None,
+        correlators: CorrelatorConfig | None = None,
+    ) -> None:
+        self._resolution = resolution
+        self._correlators = correlators
+
+    def _generation_config(self, config: RunConfig) -> RunConfig | ConfigResolution:
+        if self._resolution is None:
+            return config
+        if self._resolution.effective != config:
+            raise ConfigurationError(
+                "CLI generation config does not match its resolved provenance"
+            )
+        return self._resolution
+
+    def generate(self, config: RunConfig, progress: ProgressSink) -> object:
+        from pyamplicol.api import Generator
+
+        if not config.process.entries:
+            raise ConfigurationError("generate requires at least one process request")
+        if config.generation.output is None:
+            raise ConfigurationError("generate requires generation.output")
+        processes = _process_set(config)
+        return Generator(
+            config=self._generation_config(config), progress=progress
+        ).generate(
+            processes,
+            config.generation.output,
+            model=_model_source(config),
+            mode=cast(
+                Literal["error", "append", "replace"],
+                str(config.generation.mode),
+            ),
+            **(
+                {"correlators": self._correlators}
+                if self._correlators is not None
+                else {}
+            ),
+        )
+
+    def plan(self, config: RunConfig, progress: ProgressSink) -> object:
+        from pyamplicol.api import Generator
+
+        if not config.process.entries:
+            raise ConfigurationError("generate --dry-run requires a process request")
+        processes = _process_set(config)
+        return Generator(
+            config=self._generation_config(config), progress=progress
+        ).plan(
+            processes,
+            model=_model_source(config),
+        )
+
+    def evaluate(self, config: RunConfig, progress: ProgressSink) -> object:
+        from pyamplicol.api import Runtime
+
+        if config.evaluation.artifact is None:
+            raise ConfigurationError("evaluate requires evaluation.artifact")
+        if config.evaluation.momenta is None:
+            raise ConfigurationError("evaluate requires evaluation.momenta")
+        parameters: (
+            Mapping[
+                str,
+                complex
+                | float
+                | int
+                | list[float | int]
+                | tuple[float | int, float | int],
+            ]
+            | None
+        ) = None
+        if config.evaluation.model_parameters is not None:
+            raw_parameters = _read_json(config.evaluation.model_parameters)
+            if not isinstance(raw_parameters, Mapping):
+                raise ConfigurationError("model parameter JSON must be an object")
+            parameters = raw_parameters
+        momenta = _read_json(config.evaluation.momenta)
+        if not isinstance(momenta, list):
+            raise ConfigurationError("momenta JSON must be a point list")
+        runtime = _load_process_output(
+            config.evaluation.artifact,
+            progress,
+            lambda: Runtime.load(
+                config.evaluation.artifact,
+                process=config.evaluation.process,
+                model_parameters=parameters,
+            ),
+        )
+        selectors = {
+            "helicities": config.evaluation.helicity_ids or None,
+            "color_flows": config.evaluation.color_flow_ids or None,
+        }
+        if config.evaluation.resolved:
+            return runtime.evaluate_resolved(
+                momenta,
+                precision=config.evaluation.precision,
+                **selectors,
+            )
+        return runtime.evaluate(
+            momenta,
+            precision=config.evaluation.precision,
+            **selectors,
+        )
+
+    def benchmark(self, config: RunConfig, progress: ProgressSink) -> object:
+        from pyamplicol.api import BenchmarkRunner
+
+        if config.evaluation.artifact is None:
+            raise ConfigurationError("benchmark requires an artifact target")
+        points = None
+        if config.evaluation.momenta is not None:
+            raw_points = _read_json(config.evaluation.momenta)
+            if not isinstance(raw_points, list):
+                raise ConfigurationError("momenta JSON must be a point list")
+            points = raw_points
+        return BenchmarkRunner(config=config, progress=progress).run(
+            config.evaluation.artifact,
+            points=points,
+        )
+
+    def inspect(
+        self,
+        config: RunConfig,
+        progress: ProgressSink,
+        *,
+        full_physics: bool = False,
+    ) -> object:
+        if config.evaluation.artifact is None:
+            raise ConfigurationError("inspect requires evaluation.artifact")
+        if full_physics and config.evaluation.process is None:
+            raise ConfigurationError("inspect --full-physics requires --process")
+
+        selector = config.evaluation.process
+        if full_physics:
+            artifact = config.evaluation.artifact
+            return _load_process_output(
+                artifact,
+                progress,
+                lambda: _full_physics_inspection(artifact, selector),
+            )
+
+        from pyamplicol.artifacts import inspect_artifact
+
+        inspection = _load_process_output(
+            config.evaluation.artifact,
+            progress,
+            lambda: inspect_artifact(config.evaluation.artifact),
+        )
+        if selector is None:
+            return inspection
+        return _select_compact_process_inspection(inspection, selector)
+
+    def model_inspect(self, config: RunConfig, progress: ProgressSink) -> object:
+        del progress
+        return _model_inspection_payload(
+            _compile_configured_model(config, require_supported=False)
+        )
+
+    def model_compile(self, config: RunConfig, progress: ProgressSink) -> object:
+        if config.generation.output is None:
+            raise ConfigurationError("model compile requires generation.output")
+        requested_output = config.generation.output
+        prepared_output = requested_output.name.lower().endswith(".pyamplicol-model")
+        default_evaluator = EvaluatorConfig()
+        resolved_default_evaluator = replace(
+            default_evaluator,
+            jit=replace(
+                default_evaluator.jit, compress=default_evaluator.resolved_jit_compress
+            ),
+        )
+        if not prepared_output and config.evaluator not in (
+            default_evaluator,
+            resolved_default_evaluator,
+        ):
+            raise ConfigurationError(
+                "model compile evaluator settings require an output ending "
+                "with '.pyamplicol-model'; IR-only outputs do not compile kernels"
+            )
+        compiled = _compile_configured_model(config, require_supported=True)
+        result: dict[str, object] = {
+            "model": compiled.name,
+            "supported": compiled.supported,
+            "conversion_seconds": compiled.conversion_seconds,
+            "phase_timings": dict(compiled.phase_timings),
+            "source": dict(compiled.source),
+            "capabilities": dict(compiled.capabilities),
+        }
+        if not prepared_output:
+            output = compiled.write(requested_output)
+            result["output"] = str(output)
+            return result
+
+        from pyamplicol.models.prepared_compile import prepare_model_bundle
+
+        task_id = "model-prepare"
+        started = False
+        task_started_at = time.perf_counter()
+        backend = str(config.evaluator.backend).upper()
+
+        def report_preparation(label: str, completed: int, total: int) -> None:
+            nonlocal started
+            if not started:
+                progress.emit(
+                    ProgressStart(
+                        task_id=task_id,
+                        description="Prepare model evaluator kernels",
+                        total=total,
+                        unit="kernels",
+                        details={
+                            "step": "prepared kernel compilation",
+                            "backend": backend,
+                            "kernel_total": total,
+                        },
+                    )
+                )
+                started = True
+            progress.emit(
+                ProgressUpdate(
+                    task_id=task_id,
+                    completed=completed,
+                    total=total,
+                    message=label,
+                    details={
+                        "step": label,
+                        "backend": backend,
+                        "kernel_index": min(completed + 1, total),
+                        "kernel_total": total,
+                    },
+                )
+            )
+
+        try:
+            prepared = prepare_model_bundle(
+                compiled,
+                requested_output,
+                evaluator=config.evaluator,
+                progress=report_preparation,
+            )
+        except BaseException:
+            if started:
+                progress.emit(
+                    ProgressEnd(
+                        task_id=task_id,
+                        success=False,
+                        message="Prepared model compilation failed",
+                        elapsed_seconds=time.perf_counter() - task_started_at,
+                    )
+                )
+            raise
+        if started:
+            progress.emit(
+                ProgressEnd(
+                    task_id=task_id,
+                    message="Prepared model compilation complete",
+                    elapsed_seconds=time.perf_counter() - task_started_at,
+                )
+            )
+        result.update(
+            {
+                "output": str(prepared.output),
+                "prepared_backend": prepared.bundle.backend,
+                "kernel_count": prepared.kernel_count,
+                "preparation_phase_timings": dict(prepared.phase_timings_seconds),
+            }
+        )
+        return result
+
+    def model_processes(self, config: RunConfig, progress: ProgressSink) -> object:
+        del progress
+        if not config.process.entries:
+            raise ConfigurationError("model processes requires a process request")
+
+        from pyamplicol.processes.conservation import conserved_charges
+        from pyamplicol.processes.model import (
+            ModelParticleCatalog,
+            build_model_process_ir,
+            expand_model_processes,
+        )
+
+        compiled = _compile_configured_model(config, require_supported=True)
+        charges = conserved_charges(compiled.ir)
+        catalog = ModelParticleCatalog(
+            compiled.ir.name,
+            compiled.ir.particles,
+            compiled.ir.parameters,
+        )
+        multiparticles = {
+            **catalog.default_multiparticles(),
+            **config.process.multiparticles,
+        }
+        entries: dict[str, dict[str, object]] = {}
+        for entry in config.process.entries:
+            request = entry.expression
+            for process in expand_model_processes(
+                request,
+                catalog,
+                multiparticles=multiparticles,
+                charges=charges,
+            ):
+                process_ir = build_model_process_ir(
+                    process,
+                    compiled.ir,
+                    color_accuracy=config.color.accuracy,
+                )
+                entries.setdefault(
+                    process_ir.key,
+                    {
+                        "key": process_ir.key,
+                        "process": process_ir.process,
+                        "ir": process_ir.to_json_dict(),
+                    },
+                )
+        concrete = list(entries.values())
+        return {
+            "available": True,
+            "model": compiled.name,
+            "model_source": dict(compiled.source),
+            "requests": [entry.expression for entry in config.process.entries],
+            "default_key": concrete[0]["key"] if concrete else None,
+            "n_entries": len(concrete),
+            "multiparticles": {
+                name: list(values) for name, values in sorted(multiparticles.items())
+            },
+            "entries": concrete,
+        }
+
+    def group_processes(self, config: RunConfig, progress: ProgressSink) -> object:
+        del progress
+        if config.evaluation.artifact is None:
+            raise ConfigurationError("group-processes requires an artifact")
+
+        from pyamplicol.api.process_groups import group_processes
+
+        return group_processes(
+            config.evaluation.artifact,
+            analysis=str(config.process.analyze_process_groups),
+            only_unit_multiplier=config.process.only_unit_multiplier,
+            consider_charge_conjugation=config.process.consider_charge_conjugation,
+        )
+
+
+__all__ = ["CliServices", "DefaultCliServices", "dispatch"]
diff --git a/pyamplicol/src/pyamplicol/cli/licensing.py b/pyamplicol/src/pyamplicol/cli/licensing.py
new file mode 100644
index 0000000000..cb9ae458b0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/cli/licensing.py
@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: 0BSD
+"""Transient CLI requests for Symbolica licenses."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal, TextIO
+
+from pyamplicol.licensing import request_hobbyist_license, request_trial_license
+
+LicenseKind = Literal["trial", "hobbyist"]
+
+
+@dataclass(frozen=True, slots=True)
+class LicenseRequestResult:
+    request: LicenseKind
+    status: Literal["accepted"] = "accepted"
+    next_step: str = "The license key will be sent by email."
+
+
+@dataclass(frozen=True, slots=True)
+class LicenseRequestInvocation:
+    kind: LicenseKind
+    name: str | None
+    email: str | None
+    organization: str | None = None
+    assume_yes: bool = False
+    output_format: Literal["human", "json"] = "human"
+    output_color: Literal["auto", "always", "never"] = "auto"
+
+    def run(self, *, stdin: TextIO, stdout: TextIO) -> LicenseRequestResult:
+        if self.output_format == "json" and (
+            self.name is None
+            or self.email is None
+            or (self.kind == "trial" and self.organization is None)
+            or not self.assume_yes
+        ):
+            raise ValueError(
+                "--json license requests require all fields and --yes; "
+                "interactive prompts are disabled to keep stdout machine-readable"
+            )
+        name = self.name or _prompt(stdin, stdout, "Name")
+        email = self.email or _prompt(stdin, stdout, "Email")
+        organization: str | None = None
+        if self.kind == "trial":
+            organization = self.organization or _prompt(
+                stdin,
+                stdout,
+                "Organization",
+            )
+        if not self.assume_yes:
+            if not bool(getattr(stdin, "isatty", lambda: False)()):
+                raise ValueError(
+                    "noninteractive license requests require complete fields and --yes"
+                )
+            answer = _prompt(
+                stdin,
+                stdout,
+                "Submit this request to Symbolica? [y/N]",
+            )
+            if answer.casefold() not in {"y", "yes"}:
+                raise ValueError("Symbolica license request cancelled")
+        if self.kind == "trial":
+            assert organization is not None
+            request_trial_license(name, email, organization)
+        else:
+            request_hobbyist_license(name, email)
+        return LicenseRequestResult(self.kind)
+
+
+def _prompt(stdin: TextIO, stdout: TextIO, label: str) -> str:
+    if not bool(getattr(stdin, "isatty", lambda: False)()):
+        raise ValueError(f"noninteractive license request is missing {label.lower()}")
+    stdout.write(f"{label}: ")
+    stdout.flush()
+    value = stdin.readline()
+    if not value:
+        raise ValueError("unexpected end of input during license request")
+    value = value.strip()
+    if not value:
+        raise ValueError(f"{label} must not be empty")
+    return value
+
+
+__all__ = ["LicenseKind", "LicenseRequestInvocation", "LicenseRequestResult"]
diff --git a/pyamplicol/src/pyamplicol/cli/main.py b/pyamplicol/src/pyamplicol/cli/main.py
new file mode 100644
index 0000000000..de3bd62872
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/cli/main.py
@@ -0,0 +1,221 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Mapping, Sequence
+from dataclasses import fields, is_dataclass
+from decimal import Decimal
+from pathlib import Path
+from typing import TextIO
+
+from pyamplicol.config import PyAmpliColError
+from pyamplicol.licensing import detect_symbolica_license
+from pyamplicol.reporting import (
+    TtyProgressSink,
+    close_progress_sink,
+    configure_cli_logging,
+    get_logger,
+    progress_sink,
+    render_summary,
+    reset_cli_logging,
+)
+
+from .handlers import CliServices, DefaultCliServices, dispatch
+from .licensing import LicenseRequestInvocation
+from .parser import parse_cli
+from .utilities import UtilityInvocation, example_card, execute_utility
+
+
+def _json_value(value: object) -> object:
+    if is_dataclass(value) and not isinstance(value, type):
+        return {
+            item.name: _json_value(getattr(value, item.name)) for item in fields(value)
+        }
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, Mapping):
+        return {str(key): _json_value(entry) for key, entry in value.items()}
+    if isinstance(value, (tuple, list)):
+        return [_json_value(entry) for entry in value]
+    if isinstance(value, complex):
+        return {"real": value.real, "imag": value.imag}
+    if isinstance(value, Decimal):
+        return str(value)
+    if isinstance(value, (str, int, float, bool)) or value is None:
+        return value
+    raise TypeError(f"cannot serialize CLI result of type {type(value).__name__}")
+
+
+def write_result(
+    value: object,
+    *,
+    format: str,
+    stream: TextIO,
+    color: bool = False,
+) -> None:
+    if value is None:
+        return
+    plain = _json_value(value)
+    if format == "json":
+        json.dump(plain, stream, indent=2, sort_keys=True, allow_nan=False)
+        stream.write("\n")
+    elif format == "human":
+        rendered = render_summary(value, color=color)
+        if rendered is None:
+            raise RuntimeError(
+                "human table rendering is unavailable; use --json for "
+                "machine-readable output"
+            )
+        stream.write(f"{rendered}\n")
+    else:
+        raise ValueError(f"unsupported output format {format!r}")
+    stream.flush()
+
+
+def _color_enabled(mode: str, stream: TextIO) -> bool:
+    return mode == "always" or (
+        mode == "auto" and bool(getattr(stream, "isatty", lambda: False)())
+    )
+
+
+def run_cli(
+    argv: Sequence[str] | None = None,
+    *,
+    services: CliServices | None = None,
+    stdin: TextIO | None = None,
+    stdout: TextIO | None = None,
+    stderr: TextIO | None = None,
+) -> int:
+    output_stream = sys.stdout if stdout is None else stdout
+    diagnostic_stream = sys.stderr if stderr is None else stderr
+    input_stream = sys.stdin if stdin is None else stdin
+    logging_configured = False
+    sink = None
+    try:
+        invocation = parse_cli(argv)
+        if isinstance(invocation, LicenseRequestInvocation):
+            result = invocation.run(stdin=input_stream, stdout=output_stream)
+            write_result(
+                result,
+                format=invocation.output_format,
+                stream=output_stream,
+                color=_color_enabled(invocation.output_color, output_stream),
+            )
+            return 0
+        if isinstance(invocation, UtilityInvocation):
+            if invocation.kind == "examples-run":
+                assert invocation.name is not None
+                arguments = [str(example_card(invocation.name))]
+                for override in invocation.overrides:
+                    arguments.extend(("--set", override))
+                if invocation.output_format == "json":
+                    arguments.append("--json")
+                arguments.extend(("--color", invocation.output_color))
+                invocation = parse_cli(arguments)
+                assert not isinstance(
+                    invocation, (LicenseRequestInvocation, UtilityInvocation)
+                )
+            else:
+                result = execute_utility(invocation)
+                write_result(
+                    result,
+                    format=invocation.output_format,
+                    stream=output_stream,
+                    color=_color_enabled(invocation.output_color, output_stream),
+                )
+                if invocation.kind in {"doctor", "self-test"}:
+                    return 0 if bool(getattr(result, "ok", False)) else 1
+                return 0
+        resolution = invocation.resolve()
+        if services is None and resolution.effective.action == "model-compile":
+            initial = resolution.effective
+            detect_symbolica_license(
+                suggest=initial.symbolica.suggest_license,
+                json_mode=initial.output.format == "json",
+                stream=diagnostic_stream,
+            )
+        config = resolution.effective
+        progress_color = _color_enabled(config.output.color, diagnostic_stream)
+        sink = progress_sink(
+            config.output.progress,
+            stream=diagnostic_stream,
+            logger=get_logger("progress"),
+            color=progress_color,
+        )
+        logging_stream = (
+            sink.message_stream
+            if isinstance(sink, TtyProgressSink)
+            else diagnostic_stream
+        )
+        configure_cli_logging(
+            config.output.log_level,
+            stream=logging_stream,
+            color=progress_color,
+        )
+        logging_configured = True
+        selected_services = (
+            DefaultCliServices(resolution=resolution) if services is None else services
+        )
+        if invocation.correlators is not None:
+            from pyamplicol.correlators import CorrelatorConfig
+
+            if invocation.dry_run:
+                raise ValueError("--correlators requires generation, not --dry-run")
+            if services is not None:
+                raise ValueError(
+                    "--correlators requires the built-in generation service"
+                )
+            declarations = CorrelatorConfig.from_json_dict(
+                json.loads(invocation.correlators.read_text())
+            )
+            selected_services = DefaultCliServices(
+                resolution=resolution, correlators=declarations
+            )
+        result = dispatch(
+            config,
+            selected_services,
+            sink,
+            dry_run=invocation.dry_run,
+            full_physics=invocation.full_physics,
+        )
+        close_progress_sink(sink)
+        sink = None
+        color = _color_enabled(config.output.color, output_stream)
+        write_result(
+            result,
+            format=config.output.format,
+            stream=output_stream,
+            color=color,
+        )
+        return 130 if bool(getattr(result, "interrupted", False)) else 0
+    except (PyAmpliColError, OSError, RuntimeError, TypeError, ValueError) as exc:
+        close_progress_sink(sink)
+        sink = None
+        if logging_configured:
+            get_logger("cli").error("%s", exc)
+        else:
+            diagnostic_stream.write(f"error: {exc}\n")
+            diagnostic_stream.flush()
+        return 2
+    except KeyboardInterrupt:
+        close_progress_sink(sink)
+        sink = None
+        message = "interrupted before a complete result was available"
+        if logging_configured:
+            get_logger("cli").warning("%s", message)
+        else:
+            diagnostic_stream.write(f"{message}\n")
+            diagnostic_stream.flush()
+        return 130
+    finally:
+        close_progress_sink(sink)
+        if logging_configured:
+            reset_cli_logging()
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    return run_cli(argv)
+
+
+__all__ = ["main", "run_cli", "write_result"]
diff --git a/pyamplicol/src/pyamplicol/cli/parser.py b/pyamplicol/src/pyamplicol/cli/parser.py
new file mode 100644
index 0000000000..f6699b0868
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/cli/parser.py
@@ -0,0 +1,1045 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from types import MappingProxyType
+
+from pyamplicol.config import (
+    ACTIONS,
+    Action,
+    ClampRequest,
+    ColorContraction,
+    ColorFFTBasis,
+    ConfigResolution,
+    ConfigurationError,
+    EvaluatorExecutionMode,
+    ProcessGroupAnalysis,
+    resolve_config,
+)
+
+from .licensing import LicenseKind, LicenseRequestInvocation
+from .utilities import UtilityInvocation, parse_utility
+
+_LICENSE_ACTIONS: dict[str, LicenseKind] = {
+    "request-symbolica-trial-license": "trial",
+    "request-symbolica-hobbyist-license": "hobbyist",
+}
+_MODEL_ACTIONS: dict[str, Action] = {
+    "inspect": Action.MODEL_INSPECT,
+    "compile": Action.MODEL_COMPILE,
+    "processes": Action.MODEL_PROCESSES,
+}
+_UTILITY_COMMANDS = frozenset(
+    {"config", "examples", "profiling-campaign", "doctor", "self-test"}
+)
+_DIRECT_COMMANDS = frozenset(
+    {
+        *(action.value for action in ACTIONS if not action.value.startswith("model-")),
+        "profile",
+        "model",
+        *_LICENSE_ACTIONS,
+    }
+)
+_REMOVED_FLAT_MODEL_COMMANDS = frozenset(
+    action.value for action in _MODEL_ACTIONS.values()
+)
+
+
+def _freeze(value: object) -> object:
+    if isinstance(value, Mapping):
+        return MappingProxyType(
+            {str(key): _freeze(entry) for key, entry in value.items()}
+        )
+    if isinstance(value, (list, tuple)):
+        return tuple(_freeze(entry) for entry in value)
+    return value
+
+
+def _auto_int(value: str) -> str | int:
+    if value == "auto":
+        return value
+    try:
+        return int(value)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("expected 'auto' or an integer") from exc
+
+
+def _nullable_int(value: str) -> int | None:
+    if value.lower() in ("none", "null"):
+        return None
+    try:
+        return int(value)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("expected an integer or 'null'") from exc
+
+
+def _key_list(value: str) -> tuple[str, tuple[str, ...]]:
+    if "=" not in value:
+        raise argparse.ArgumentTypeError("expected NAME=ITEM[,ITEM...]")
+    key, raw_entries = value.split("=", 1)
+    entries = tuple(entry.strip() for entry in raw_entries.split(",") if entry.strip())
+    if not key.strip() or not entries:
+        raise argparse.ArgumentTypeError("expected NAME=ITEM[,ITEM...]")
+    return key.strip(), entries
+
+
+def _key_int(value: str) -> tuple[str, int]:
+    if "=" not in value:
+        raise argparse.ArgumentTypeError("expected NAME=INTEGER")
+    key, raw_entry = value.split("=", 1)
+    try:
+        entry = int(raw_entry)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("expected NAME=INTEGER") from exc
+    if not key.strip():
+        raise argparse.ArgumentTypeError("expected NAME=INTEGER")
+    return key.strip(), entry
+
+
+@dataclass(frozen=True, slots=True)
+class CliInvocation:
+    action: Action | None
+    card: Path | None
+    dedicated: Mapping[str, object]
+    overrides: tuple[str, ...]
+    dry_run: bool = False
+    full_physics: bool = False
+    correlators: Path | None = None
+
+    def __post_init__(self) -> None:
+        frozen = _freeze(self.dedicated)
+        assert isinstance(frozen, Mapping)
+        object.__setattr__(self, "dedicated", frozen)
+        object.__setattr__(self, "overrides", tuple(self.overrides))
+
+    def resolve(
+        self,
+        *,
+        clamps: Sequence[ClampRequest] = (),
+    ) -> ConfigResolution:
+        if any(
+            str(override).partition("=")[0].strip() == "output.format"
+            and str(override).partition("=")[2].strip().strip("\"'").casefold()
+            == "json"
+            for override in self.overrides
+        ):
+            raise ConfigurationError(
+                "CLI JSON output is selected only with --json; "
+                "remove the output.format override"
+            )
+        return resolve_config(
+            self.card,
+            action=self.action,
+            dedicated=self.dedicated,
+            overrides=self.overrides,
+            clamps=clamps,
+        )
+
+
+def _common_parent(*, include_card: bool = True) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(add_help=False)
+    if include_card:
+        parser.add_argument(
+            "--card",
+            type=Path,
+            default=argparse.SUPPRESS,
+            help="Read defaults from a TOML run card.",
+        )
+    parser.add_argument(
+        "--set",
+        dest="_overrides",
+        action="append",
+        default=argparse.SUPPRESS,
+        metavar="PATH=VALUE",
+        help="Override one schema field; repeat to apply overrides in order.",
+    )
+    parser.add_argument(
+        "--json",
+        dest="_json_output",
+        action="store_true",
+        default=argparse.SUPPRESS,
+        help="Emit machine-readable JSON instead of human-facing tables.",
+    )
+    parser.add_argument(
+        "--color",
+        dest="output.color",
+        choices=("auto", "always", "never"),
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--progress",
+        dest="output.progress",
+        choices=("auto", "tty", "log", "off"),
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--log-level",
+        dest="output.log_level",
+        choices=("debug", "info", "warning", "error"),
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--symbolica-suggestion",
+        dest="symbolica.suggest_license",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+    )
+    return parser
+
+
+def _add_model_options(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--model", dest="model.source", default=argparse.SUPPRESS)
+    parser.add_argument(
+        "--restriction", dest="model.restriction", default=argparse.SUPPRESS
+    )
+    parser.add_argument(
+        "--simplify",
+        dest="model.simplify",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--model-cache",
+        dest="model.cache",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--model-cache-dir",
+        dest="model.cache_dir",
+        type=Path,
+        default=argparse.SUPPRESS,
+    )
+
+
+def _add_process_options(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--name",
+        dest="_process_names",
+        action="append",
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--multiparticle",
+        dest="_multiparticles",
+        type=_key_list,
+        action="append",
+        default=argparse.SUPPRESS,
+        metavar="NAME=ITEM[,ITEM...]",
+    )
+    parser.add_argument(
+        "--flavor-scheme",
+        dest="process.flavor_scheme",
+        type=int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--max-quark-lines",
+        dest="process.max_quark_lines",
+        type=_nullable_int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--coupling-order-policy",
+        dest="process.coupling_order_policy",
+        choices=("minimal", "explicit"),
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--max-coupling-order",
+        dest="_max_coupling_orders",
+        type=_key_int,
+        action="append",
+        default=argparse.SUPPRESS,
+        metavar="NAME=INTEGER",
+    )
+
+
+def _add_process_grouping_options(
+    parser: argparse.ArgumentParser,
+    *,
+    generation: bool,
+) -> None:
+    if generation:
+        parser.add_argument(
+            "--flavor-blind",
+            dest="process.flavor_blind",
+            action="store_true",
+            default=argparse.SUPPRESS,
+            help=(
+                "generate one representative per flavour-relabelling class and "
+                "record the others as its group members (assumed, not verified)"
+            ),
+        )
+    parser.add_argument(
+        "--consider-charge-conjugation",
+        dest="process.consider_charge_conjugation",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+        help="also relate processes through charge conjugation (default: on)",
+    )
+    parser.add_argument(
+        "--only-unit-multiplier",
+        dest="process.only_unit_multiplier",
+        action="store_true",
+        default=argparse.SUPPRESS,
+        help="accept only numerically found relations with factor 1",
+    )
+    parser.add_argument(
+        "--analyze-process-groups",
+        dest="process.analyze_process_groups",
+        choices=tuple(ProcessGroupAnalysis),
+        default=argparse.SUPPRESS if generation else ProcessGroupAnalysis.NUMERICAL,
+        help=(
+            "search for subprocesses with equal matrix elements up to a "
+            f"rational factor (default: {'none' if generation else 'numerical'})"
+        ),
+    )
+
+
+def _add_color_options(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--color-accuracy",
+        dest="color.accuracy",
+        choices=("lc", "nlc", "full"),
+        default=argparse.SUPPRESS,
+    )
+    contraction = parser.add_mutually_exclusive_group()
+    contraction.add_argument(
+        "--color-contraction",
+        dest="color.contraction",
+        choices=tuple(ColorContraction),
+        default=argparse.SUPPRESS,
+        help=(
+            "Default: auto, using adaptive FFT for supported NLC/full recurrence "
+            "or on-the-fly plans and direct otherwise. Select direct to opt out."
+        ),
+    )
+    contraction.add_argument(
+        "--fft",
+        dest="_fft_basis",
+        choices=tuple(ColorFFTBasis),
+        default=argparse.SUPPRESS,
+        help=(
+            "Force symmetric-group FFT contraction. 'adjoint' selects certified "
+            "DDM where applicable, otherwise exact fundamental chains or an "
+            "explicit trace fallback; requires --color-accuracy nlc or full."
+        ),
+    )
+    parser.add_argument(
+        "--lc-flow-layout",
+        dest="color.lc_flow_layout",
+        choices=("topology-replay", "all-flow-union"),
+        default=argparse.SUPPRESS,
+    )
+
+
+def _add_generation_options(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--mode",
+        dest="generation.mode",
+        choices=("error", "append", "replace"),
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--force",
+        dest="generation.mode",
+        action="store_const",
+        const="replace",
+        default=argparse.SUPPRESS,
+        help="atomically replace an existing output artifact",
+    )
+    parser.add_argument(
+        "--workers",
+        dest="generation.workers",
+        type=_auto_int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--emit-api-bundle",
+        dest="generation.emit_api_bundle",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--validation",
+        dest="generation.validation.enabled",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--validation-samples",
+        dest="generation.validation.samples",
+        type=int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--validation-seed",
+        dest="generation.validation.seed",
+        type=int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--relative-tolerance",
+        dest="generation.validation.relative_tolerance",
+        type=float,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--absolute-tolerance",
+        dest="generation.validation.absolute_tolerance",
+        type=float,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--post-build-validation",
+        dest="generation.validation.post_build_validation",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+        help=(
+            "re-open and numerically smoke-test the written artifact (off by default)"
+        ),
+    )
+    numerical_reuse = parser.add_mutually_exclusive_group()
+    numerical_reuse.add_argument(
+        "--numerical-current-reuse",
+        dest="generation.relation_discovery.mode",
+        action="store_const",
+        const="certified-reuse",
+        default=argparse.SUPPRESS,
+        help=(
+            "search for and apply independently certified numerical current "
+            "relations (off by default: the high-precision probes are costly at "
+            "generation time)"
+        ),
+    )
+    numerical_reuse.add_argument(
+        "--no-numerical-current-reuse",
+        dest="generation.relation_discovery.mode",
+        action="store_const",
+        const="off",
+        default=argparse.SUPPRESS,
+        help="disable numerical current-relation discovery and reuse (the default)",
+    )
+
+
+def _add_evaluator_options(
+    parser: argparse.ArgumentParser,
+    *,
+    include_runtime_controls: bool = True,
+) -> None:
+    parser.add_argument(
+        "--backend",
+        dest="evaluator.backend",
+        choices=("jit", "asm", "cpp"),
+        default=argparse.SUPPRESS,
+    )
+    if include_runtime_controls:
+        parser.add_argument(
+            "--execution-mode",
+            dest="evaluator.execution_mode",
+            choices=tuple(mode.value for mode in EvaluatorExecutionMode),
+            default=argparse.SUPPRESS,
+        )
+        parser.add_argument(
+            "--batch-size",
+            dest="evaluator.batch_size",
+            type=int,
+            default=argparse.SUPPRESS,
+        )
+        parser.add_argument(
+            "--output-chunk-size",
+            dest="evaluator.output_chunk_size",
+            type=_nullable_int,
+            default=argparse.SUPPRESS,
+        )
+    parser.add_argument(
+        "--horner-iterations",
+        dest="evaluator.optimization.horner_iterations",
+        type=int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--cpe-iterations",
+        dest="evaluator.optimization.cpe_iterations",
+        type=_nullable_int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--cores",
+        dest="evaluator.optimization.cores",
+        type=_auto_int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--max-horner-variables",
+        dest="evaluator.optimization.max_horner_variables",
+        type=int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--max-common-pair-cache-entries",
+        dest="evaluator.optimization.max_common_pair_cache_entries",
+        type=int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--max-common-pair-distance",
+        dest="evaluator.optimization.max_common_pair_distance",
+        type=int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--collect-factors",
+        dest="evaluator.optimization.collect_factors",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--jit-optimization-level",
+        dest="evaluator.jit.optimization_level",
+        type=int,
+        choices=(0, 1, 2, 3),
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--jit-compress",
+        dest="evaluator.jit.compress",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--cpp-optimization",
+        dest="evaluator.cpp.optimization",
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--cpp-compiler",
+        dest="evaluator.cpp.compiler",
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--cpp-native-arch",
+        dest="evaluator.cpp.native_arch",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--cpp-extra-flag",
+        dest="evaluator.cpp.extra_flags",
+        action="append",
+        default=argparse.SUPPRESS,
+    )
+
+
+def _add_evaluation_options(
+    parser: argparse.ArgumentParser, *, include_artifact: bool = True
+) -> None:
+    if include_artifact:
+        parser.add_argument("artifact", type=Path, nargs="?", default=None)
+    parser.add_argument(
+        "--process",
+        dest="evaluation.process",
+        default=argparse.SUPPRESS,
+        help="stable process/alias ID or exact concrete process expression",
+    )
+    parser.add_argument(
+        "--precision",
+        dest="evaluation.precision",
+        type=int,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--resolved",
+        dest="evaluation.resolved",
+        action=argparse.BooleanOptionalAction,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--helicity",
+        dest="evaluation.helicity_ids",
+        action="append",
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--color-flow",
+        dest="evaluation.color_flow_ids",
+        action="append",
+        default=argparse.SUPPRESS,
+        metavar="ID_OR_NUMBER",
+        help="stable color-flow ID or one-based ordinal shown by inspect",
+    )
+    parser.add_argument(
+        "--model-parameters",
+        dest="evaluation.model_parameters",
+        type=Path,
+        default=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--momenta",
+        dest="evaluation.momenta",
+        type=Path,
+        default=argparse.SUPPRESS,
+    )
+
+
+def _add_profile_options(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("target", type=Path, nargs="?", default=None, metavar="OUTPUT")
+    parser.add_argument(
+        "--process",
+        dest="evaluation.process",
+        default=argparse.SUPPRESS,
+        metavar="PROCESS",
+        help="select a stable process/alias ID or exact process expression",
+    )
+    parser.add_argument(
+        "--target-runtime",
+        dest="benchmark.target_runtime",
+        type=float,
+        default=argparse.SUPPRESS,
+        metavar="SECONDS",
+        help=(
+            "target cumulative Rusticol timing duration; Ctrl-C reports "
+            "statistics from complete samples collected so far"
+        ),
+    )
+    parser.add_argument(
+        "--batch-size",
+        dest="benchmark.batch_size",
+        type=int,
+        default=argparse.SUPPRESS,
+        metavar="POINTS",
+        help="number of phase-space points evaluated by each runtime call",
+    )
+    parser.add_argument(
+        "--precision",
+        dest="benchmark.precision",
+        type=int,
+        default=argparse.SUPPRESS,
+        metavar="DIGITS",
+        help="decimal digits used by the Python runtime evaluator",
+    )
+    parser.add_argument(
+        "--warmup-runs",
+        dest="benchmark.warmup_runs",
+        type=int,
+        default=argparse.SUPPRESS,
+        metavar="COUNT",
+    )
+    parser.add_argument(
+        "--minimum-samples",
+        dest="benchmark.minimum_samples",
+        type=int,
+        default=argparse.SUPPRESS,
+        metavar="COUNT",
+        help="minimum number of independent timed blocks",
+    )
+    parser.add_argument(
+        "--helicity",
+        dest="benchmark.helicity_ids",
+        action="append",
+        default=argparse.SUPPRESS,
+        metavar="ID",
+        help=(
+            "stable helicity ID; omitting both selector options chooses the "
+            "artifact layout's optimized profiling workload"
+        ),
+    )
+    parser.add_argument(
+        "--color-flow",
+        dest="benchmark.color_flow_ids",
+        action="append",
+        default=argparse.SUPPRESS,
+        metavar="ID_OR_NUMBER",
+        help=(
+            "stable color-flow ID or one-based ordinal shown by inspect; "
+            "omitting both selector options chooses the artifact layout's "
+            "optimized profiling workload"
+        ),
+    )
+    parser.add_argument(
+        "--momenta",
+        dest="evaluation.momenta",
+        type=Path,
+        default=argparse.SUPPRESS,
+        metavar="PATH",
+    )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pyamplicol",
+        description=(
+            "Generate, inspect, evaluate, and profile pyAmpliCol process artifacts."
+        ),
+    )
+    subparsers = parser.add_subparsers(dest="_action", required=True)
+    common = _common_parent()
+
+    generate = subparsers.add_parser(
+        "generate",
+        parents=[common],
+        help="Generate a process artifact.",
+    )
+    generate.add_argument("process", nargs="?", default=None)
+    generate.add_argument("output", type=Path, nargs="?", default=None)
+    generate.add_argument(
+        "--process",
+        dest="_extra_processes",
+        action="append",
+        default=argparse.SUPPRESS,
+    )
+    generate.add_argument(
+        "--dry-run",
+        dest="_dry_run",
+        action="store_true",
+        help="Plan and validate generation without writing an artifact.",
+    )
+    _add_model_options(generate)
+    _add_process_options(generate)
+    _add_process_grouping_options(generate, generation=True)
+    _add_color_options(generate)
+    _add_generation_options(generate)
+    generate.add_argument(
+        "--correlators",
+        dest="_correlators",
+        type=Path,
+        default=argparse.SUPPRESS,
+        help="JSON declaration of colour IDs and allowed joint spin-correlation legs",
+    )
+    _add_evaluator_options(generate)
+
+    evaluate = subparsers.add_parser(
+        "evaluate",
+        parents=[common],
+        help="Evaluate momenta with a generated artifact.",
+    )
+    _add_evaluation_options(evaluate)
+
+    profile = subparsers.add_parser(
+        "profile",
+        parents=[common],
+        help="Profile a generated artifact.",
+    )
+    _add_profile_options(profile)
+
+    benchmark = subparsers.add_parser(
+        "benchmark",
+        parents=[common],
+        help="Compatibility alias for the profile command.",
+    )
+    _add_profile_options(benchmark)
+
+    inspect = subparsers.add_parser(
+        "inspect",
+        parents=[common],
+        help="Summarize a generated artifact and its processes.",
+    )
+    inspect.add_argument("artifact", type=Path, nargs="?", default=None)
+    inspect.add_argument(
+        "--process",
+        dest="evaluation.process",
+        default=argparse.SUPPRESS,
+        help=(
+            "show compact metadata for one stable process/alias ID or exact "
+            "concrete process expression"
+        ),
+    )
+    inspect.add_argument(
+        "--full-physics",
+        dest="_full_physics",
+        action="store_true",
+        help=(
+            "load the selected runtime and materialize complete helicity/color "
+            "physics (potentially very large at high multiplicity)"
+        ),
+    )
+
+    group_processes = subparsers.add_parser(
+        "group-processes",
+        parents=[common],
+        help=(
+            "Find generated subprocesses with equal matrix elements and update "
+            "the artifact's process-groups.json in place."
+        ),
+    )
+    group_processes.add_argument("artifact", type=Path, nargs="?", default=None)
+    _add_process_grouping_options(group_processes, generation=False)
+
+    model = subparsers.add_parser(
+        "model",
+        help="Inspect, compile, or enumerate processes for a model.",
+    )
+    model_commands = model.add_subparsers(dest="_model_action", required=True)
+
+    model_inspect = model_commands.add_parser(
+        "inspect",
+        parents=[common],
+        help="Inspect a built-in, UFO, JSON, or compiled model.",
+    )
+    model_inspect.add_argument("source", nargs="?", default=None)
+    _add_model_options(model_inspect)
+
+    model_compile = model_commands.add_parser(
+        "compile",
+        parents=[common],
+        help=(
+            "Compile portable model IR or prepare one evaluator kernel bundle "
+            "shared by eager, recurrence, and on-the-fly execution."
+        ),
+    )
+    model_compile.add_argument("source", nargs="?", default=None)
+    model_compile.add_argument(
+        "output",
+        type=Path,
+        nargs="?",
+        default=None,
+        help=(
+            "IR output path, or a .pyamplicol-model path for a self-contained "
+            "prepared bundle"
+        ),
+    )
+    _add_model_options(model_compile)
+    _add_generation_options(model_compile)
+    _add_evaluator_options(model_compile, include_runtime_controls=False)
+
+    model_processes = model_commands.add_parser(
+        "processes",
+        parents=[common],
+        help="Expand concrete processes using a model's particle catalog.",
+    )
+    model_processes.add_argument("process", nargs="?", default=None)
+    model_processes.add_argument(
+        "--process",
+        dest="_extra_processes",
+        action="append",
+        default=argparse.SUPPRESS,
+    )
+    _add_model_options(model_processes)
+    _add_process_options(model_processes)
+
+    for name, help_text in (
+        ("config", "Create or resolve run configuration."),
+        ("examples", "List, copy, or run packaged examples."),
+        ("profiling-campaign", "Copy the packaged profiling campaign."),
+        ("doctor", "Diagnose the installed pyAmpliCol environment."),
+        ("self-test", "Run the installed-package self-test."),
+    ):
+        subparsers.add_parser(name, help=help_text)
+
+    trial = subparsers.add_parser(
+        "request-symbolica-trial-license",
+        help="Request a Symbolica trial license.",
+    )
+    trial.add_argument("--name")
+    trial.add_argument("--email")
+    trial.add_argument("--organization")
+    trial.add_argument("--yes", dest="assume_yes", action="store_true")
+    trial.add_argument("--json", dest="_json_output", action="store_true")
+    trial.add_argument(
+        "--color",
+        dest="_output_color",
+        choices=("auto", "always", "never"),
+        default="auto",
+    )
+
+    hobbyist = subparsers.add_parser(
+        "request-symbolica-hobbyist-license",
+        help="Request a Symbolica hobbyist license.",
+    )
+    hobbyist.add_argument("--name")
+    hobbyist.add_argument("--email")
+    hobbyist.add_argument("--yes", dest="assume_yes", action="store_true")
+    hobbyist.add_argument("--json", dest="_json_output", action="store_true")
+    hobbyist.add_argument(
+        "--color",
+        dest="_output_color",
+        choices=("auto", "always", "never"),
+        default="auto",
+    )
+    return parser
+
+
+def build_card_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pyamplicol", parents=[_common_parent(include_card=False)]
+    )
+    parser.add_argument("card", type=Path)
+    return parser
+
+
+def _is_prepared_model_output(value: object) -> bool:
+    if value is None or value == argparse.SUPPRESS:
+        return False
+    try:
+        return str(os.fspath(value)).lower().endswith(".pyamplicol-model")
+    except TypeError:
+        return False
+
+
+def _namespace_to_invocation(
+    namespace: argparse.Namespace,
+) -> CliInvocation | LicenseRequestInvocation:
+    raw = vars(namespace).copy()
+    action_value = raw.pop("_action", None)
+    model_action = raw.pop("_model_action", None)
+    if action_value == "model":
+        if model_action not in _MODEL_ACTIONS:
+            raise ValueError("model requires an inspect, compile, or processes command")
+        action_value = _MODEL_ACTIONS[model_action].value
+    if action_value == "profile":
+        action_value = Action.BENCHMARK.value
+    if action_value in _LICENSE_ACTIONS:
+        return LicenseRequestInvocation(
+            kind=_LICENSE_ACTIONS[action_value],
+            name=raw.pop("name", None),
+            email=raw.pop("email", None),
+            organization=raw.pop("organization", None),
+            assume_yes=bool(raw.pop("assume_yes", False)),
+            output_format="json" if bool(raw.pop("_json_output", False)) else "human",
+            output_color=str(raw.pop("_output_color", "auto")),
+        )
+    action = Action(action_value) if action_value is not None else None
+    if action is Action.MODEL_COMPILE:
+        evaluator_arguments = tuple(
+            sorted(key for key in raw if key.startswith("evaluator."))
+        )
+        evaluator_overrides = tuple(
+            value
+            for value in raw.get("_overrides", ())
+            if str(value).partition("=")[0].strip().startswith("evaluator.")
+        )
+        has_evaluator_options = evaluator_arguments or evaluator_overrides
+        if has_evaluator_options and not _is_prepared_model_output(raw.get("output")):
+            raise ConfigurationError(
+                "model compile evaluator options require an output ending with "
+                "'.pyamplicol-model'; IR-only model outputs do not compile kernels"
+            )
+    card_value = raw.pop("card", None)
+    card = (
+        Path(os.fspath(card_value)).expanduser().resolve(strict=False)
+        if card_value is not None
+        else None
+    )
+    overrides = tuple(raw.pop("_overrides", ()))
+    raw["output.format"] = "json" if bool(raw.pop("_json_output", False)) else "human"
+    dry_run = bool(raw.pop("_dry_run", False))
+    full_physics = bool(raw.pop("_full_physics", False))
+    correlators = raw.pop("_correlators", None)
+
+    positional_process = raw.pop("process", None)
+    extra_processes = tuple(raw.pop("_extra_processes", ()))
+    process_names = tuple(raw.pop("_process_names", ()))
+    if positional_process == argparse.SUPPRESS:
+        positional_process = None
+    process_expressions = tuple(
+        entry for entry in (positional_process, *extra_processes) if entry is not None
+    )
+    if process_names and len(process_names) != len(process_expressions):
+        raise ConfigurationError(
+            "direct process names must be empty or aligned with process expressions"
+        )
+    if process_expressions:
+        raw["process.entries"] = tuple(
+            {
+                "expression": expression,
+                **({"name": process_names[index]} if process_names else {}),
+            }
+            for index, expression in enumerate(process_expressions)
+        )
+
+    positional_output = raw.pop("output", None)
+    if positional_output != argparse.SUPPRESS and positional_output is not None:
+        raw["generation.output"] = positional_output
+    positional_artifact = raw.pop("artifact", None)
+    if positional_artifact != argparse.SUPPRESS and positional_artifact is not None:
+        raw["evaluation.artifact"] = positional_artifact
+    positional_target = raw.pop("target", None)
+    if positional_target != argparse.SUPPRESS and positional_target is not None:
+        raw["evaluation.artifact"] = positional_target
+    positional_source = raw.pop("source", None)
+    if positional_source != argparse.SUPPRESS and positional_source is not None:
+        raw["model.source"] = positional_source
+
+    multiparticles = raw.pop("_multiparticles", None)
+    if multiparticles is not None:
+        raw["process.multiparticles"] = dict(multiparticles)
+    coupling_orders = raw.pop("_max_coupling_orders", None)
+    if coupling_orders is not None:
+        raw["process.max_coupling_orders"] = dict(coupling_orders)
+    fft_basis = raw.pop("_fft_basis", None)
+    if fft_basis is not None:
+        raw["color.contraction"] = ColorContraction.SYMMETRIC_GROUP_FFT
+        raw["color.fft_basis"] = fft_basis
+    return CliInvocation(
+        action=action,
+        card=card,
+        dedicated=raw,
+        overrides=overrides,
+        dry_run=dry_run,
+        full_physics=full_physics,
+        correlators=correlators,
+    )
+
+
+def _normalize_direct_arguments(
+    arguments: Sequence[str],
+    command_index: int,
+) -> list[str]:
+    command = arguments[command_index]
+    before = list(arguments[:command_index])
+    after = list(arguments[command_index + 1 :])
+    if command != "model":
+        return [command, *before, *after]
+
+    model_index = next(
+        (index for index, argument in enumerate(after) if argument in _MODEL_ACTIONS),
+        None,
+    )
+    if model_index is None:
+        return [command, *before, *after]
+    return [
+        command,
+        after[model_index],
+        *before,
+        *after[:model_index],
+        *after[model_index + 1 :],
+    ]
+
+
+def parse_cli(
+    argv: Sequence[str] | None = None,
+) -> CliInvocation | LicenseRequestInvocation | UtilityInvocation:
+    arguments = list(sys.argv[1:] if argv is None else argv)
+    if arguments and arguments[0] in _UTILITY_COMMANDS:
+        return parse_utility(arguments)
+    if any(argument in _REMOVED_FLAT_MODEL_COMMANDS for argument in arguments):
+        return _namespace_to_invocation(build_parser().parse_args(arguments))
+    command_index = next(
+        (
+            index
+            for index, argument in enumerate(arguments)
+            if argument in _DIRECT_COMMANDS
+        ),
+        None,
+    )
+    if command_index is not None:
+        normalized = _normalize_direct_arguments(arguments, command_index)
+        return _namespace_to_invocation(build_parser().parse_args(normalized))
+    if arguments == ["--help"]:
+        return _namespace_to_invocation(build_parser().parse_args(arguments))
+    return _namespace_to_invocation(build_card_parser().parse_args(arguments))
+
+
+__all__ = [
+    "CliInvocation",
+    "UtilityInvocation",
+    "build_card_parser",
+    "build_parser",
+    "parse_cli",
+]
diff --git a/pyamplicol/src/pyamplicol/cli/utilities.py b/pyamplicol/src/pyamplicol/cli/utilities.py
new file mode 100644
index 0000000000..3fc3a588bd
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/cli/utilities.py
@@ -0,0 +1,748 @@
+# SPDX-License-Identifier: 0BSD
+"""Checkout-independent utility commands for configuration and examples."""
+
+from __future__ import annotations
+
+import argparse
+import errno
+import os
+import shutil
+import stat
+import sys
+from collections.abc import Sequence
+from dataclasses import dataclass
+from importlib import resources
+from importlib.resources.abc import Traversable
+from pathlib import Path
+from typing import Literal
+
+from pyamplicol.api.errors import ConfigurationError
+from pyamplicol.config import resolution_to_dict, resolve_config
+from pyamplicol.diagnostics import run_doctor, run_self_test
+
+UtilityKind = Literal[
+    "config-template",
+    "config-resolve",
+    "examples-list",
+    "examples-copy",
+    "examples-run",
+    "profiling-campaign-copy",
+    "doctor",
+    "self-test",
+]
+
+_PROFILING_CAMPAIGN_REQUIRED_FILES = (
+    Path("README.md"),
+    Path("TABLE_FILLING.md"),
+    Path("build_pdf.py"),
+    Path("pyAmpliCol.tex"),
+    Path("report-workspace.json"),
+    Path("report_environment.json"),
+    Path("report_environment.tex"),
+    Path("result_tables.py"),
+    Path("result_validation_summary.tex"),
+    Path("steer_performance_campaign.py"),
+)
+_PROFILING_CAMPAIGN_GLOBS = (
+    "result_*_table.tex",
+    "section_*.tex",
+    "results/*.json",
+)
+_PROFILING_CAMPAIGN_FILE_COUNT = 69
+_PROFILING_CAMPAIGN_LOCAL_AMPLICOL = ".pyamplicol-original-amplicol"
+_PROFILING_CAMPAIGN_LOCAL_MADGRAPH = ".pyamplicol-madgraph"
+_PROFILING_CAMPAIGN_STATE = "campaign_artifacts"
+_PROFILING_CAMPAIGN_SUMMARY = "campaign_summary_ids"
+_PROFILING_CAMPAIGN_PDF = "pyAmpliCol.pdf"
+_PROFILING_CAMPAIGN_GENERATED_FILES = (
+    "measurement_lineage.json",
+    "pyAmpliCol.aux",
+    "pyAmpliCol.bbl",
+    "pyAmpliCol.bcf",
+    "pyAmpliCol.blg",
+    "pyAmpliCol.fdb_latexmk",
+    "pyAmpliCol.fls",
+    "pyAmpliCol.log",
+    "pyAmpliCol.out",
+    "pyAmpliCol.run.xml",
+    "pyAmpliCol.synctex.gz",
+    "pyAmpliCol.toc",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class UtilityInvocation:
+    kind: UtilityKind
+    output_format: Literal["human", "json"] = "human"
+    output_color: Literal["auto", "always", "never"] = "auto"
+    path: Path | None = None
+    name: str | None = None
+    force: bool = False
+    overrides: tuple[str, ...] = ()
+    local_amplicol: Path | None = None
+    local_madgraph: Path | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ExampleEntry:
+    name: str
+    action: str
+    description: str
+
+
+@dataclass(frozen=True, slots=True)
+class UtilityResult:
+    operation: str
+    status: Literal["complete"]
+    destination: Path
+
+
+def _add_output_options(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--json",
+        dest="output_format",
+        action="store_const",
+        const="json",
+        default="human",
+        help="emit stable machine-readable JSON instead of a human table",
+    )
+    parser.add_argument(
+        "--color",
+        dest="output_color",
+        choices=("auto", "always", "never"),
+        default="auto",
+        help="detect a terminal, force ANSI color, or disable color",
+    )
+
+
+def _utility_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="pyamplicol")
+    commands = parser.add_subparsers(dest="utility", required=True)
+
+    config = commands.add_parser("config")
+    config_commands = config.add_subparsers(dest="config_command", required=True)
+    template = config_commands.add_parser("template")
+    template.add_argument("output", type=Path, nargs="?")
+    template.add_argument("--force", action="store_true")
+    _add_output_options(template)
+    resolve = config_commands.add_parser("resolve")
+    resolve.add_argument("card", type=Path)
+    resolve.add_argument("--set", dest="overrides", action="append", default=[])
+    _add_output_options(resolve)
+
+    examples = commands.add_parser("examples")
+    example_commands = examples.add_subparsers(dest="examples_command", required=True)
+    listing = example_commands.add_parser("list")
+    _add_output_options(listing)
+    copy = example_commands.add_parser("copy")
+    copy.add_argument("destination", type=Path)
+    copy.add_argument("--force", action="store_true")
+    _add_output_options(copy)
+    runnable_names = _runnable_example_names()
+    run = example_commands.add_parser(
+        "run",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="available names:\n  " + "\n  ".join(runnable_names),
+    )
+    run.add_argument(
+        "name",
+        choices=runnable_names,
+        metavar="NAME",
+        help="packaged example to run",
+    )
+    run.add_argument("--set", dest="overrides", action="append", default=[])
+    _add_output_options(run)
+
+    profiling_campaign = commands.add_parser("profiling-campaign")
+    profiling_commands = profiling_campaign.add_subparsers(
+        dest="profiling_campaign_command", required=True
+    )
+    campaign_copy = profiling_commands.add_parser(
+        "copy",
+        description=(
+            "Create a self-contained profiling campaign. Runtime state is stored "
+            "in the visible DEST/campaign_artifacts directory and moves with DEST."
+        ),
+    )
+    campaign_copy.add_argument("destination", type=Path)
+    campaign_copy.add_argument(
+        "--force",
+        action="store_true",
+        help=(
+            "overwrite the managed template files and reset only "
+            "DEST/campaign_artifacts, DEST/pyAmpliCol.pdf, and "
+            "DEST/campaign_summary_ids, plus known lineage/LaTeX byproducts; "
+            "unrelated files and recorded local AmpliCol/MadGraph installations "
+            "are preserved (stop an active campaign first)"
+        ),
+    )
+    campaign_copy.add_argument(
+        "--local-amplicol",
+        type=Path,
+        metavar="PATH_TO_COMPLETE_CHECKOUT",
+        help=(
+            "Record a clean, complete original-AmpliCol checkout as the "
+            "default for this copied campaign."
+        ),
+    )
+    campaign_copy.add_argument(
+        "--local-madgraph",
+        type=Path,
+        metavar="PATH_TO_INSTALLATION",
+        help=(
+            "Record a complete MadGraph installation as the default for this "
+            "copied campaign."
+        ),
+    )
+    _add_output_options(campaign_copy)
+
+    for name in ("doctor", "self-test"):
+        command = commands.add_parser(name)
+        _add_output_options(command)
+    return parser
+
+
+def parse_utility(argv: Sequence[str]) -> UtilityInvocation:
+    namespace = _utility_parser().parse_args(argv)
+    if namespace.utility == "config":
+        if namespace.config_command == "template":
+            return UtilityInvocation(
+                "config-template",
+                output_format=namespace.output_format,
+                output_color=namespace.output_color,
+                path=namespace.output,
+                force=bool(namespace.force),
+            )
+        return UtilityInvocation(
+            "config-resolve",
+            output_format=namespace.output_format,
+            output_color=namespace.output_color,
+            path=namespace.card,
+            overrides=tuple(namespace.overrides),
+        )
+    if namespace.utility == "examples":
+        if namespace.examples_command == "list":
+            return UtilityInvocation(
+                "examples-list",
+                output_format=namespace.output_format,
+                output_color=namespace.output_color,
+            )
+        if namespace.examples_command == "copy":
+            return UtilityInvocation(
+                "examples-copy",
+                output_format=namespace.output_format,
+                output_color=namespace.output_color,
+                path=namespace.destination,
+                force=bool(namespace.force),
+            )
+        return UtilityInvocation(
+            "examples-run",
+            output_format=namespace.output_format,
+            output_color=namespace.output_color,
+            name=namespace.name,
+            overrides=tuple(namespace.overrides),
+        )
+    if namespace.utility == "profiling-campaign":
+        return UtilityInvocation(
+            "profiling-campaign-copy",
+            output_format=namespace.output_format,
+            output_color=namespace.output_color,
+            path=namespace.destination,
+            force=bool(namespace.force),
+            local_amplicol=namespace.local_amplicol,
+            local_madgraph=namespace.local_madgraph,
+        )
+    return UtilityInvocation(
+        namespace.utility,
+        output_format=namespace.output_format,
+        output_color=namespace.output_color,
+    )
+
+
+def _source_examples_root() -> Path:
+    for parent in Path(__file__).resolve().parents:
+        candidate = parent / "examples"
+        if (candidate / "all_options.toml").is_file():
+            return candidate
+    raise ConfigurationError("packaged examples are unavailable")
+
+
+def examples_root() -> Path:
+    packaged = resources.files("pyamplicol").joinpath("_examples")
+    if not isinstance(packaged, os.PathLike):
+        return _source_examples_root()
+    path = Path(os.fspath(packaged))
+    if (path / "all_options.toml").is_file():
+        return path.resolve()
+    return _source_examples_root()
+
+
+def _runnable_example_names() -> tuple[str, ...]:
+    return tuple(
+        card.stem
+        for card in sorted(examples_root().glob("*.toml"))
+        if card.name != "all_options.toml"
+    )
+
+
+def _profiling_campaign_inventory(source: Path) -> tuple[Path, ...]:
+    selected = set(_PROFILING_CAMPAIGN_REQUIRED_FILES)
+    for pattern in _PROFILING_CAMPAIGN_GLOBS:
+        selected.update(path.relative_to(source) for path in source.glob(pattern))
+    missing = tuple(
+        relative
+        for relative in _PROFILING_CAMPAIGN_REQUIRED_FILES
+        if not (source / relative).is_file()
+    )
+    if missing or len(selected) != _PROFILING_CAMPAIGN_FILE_COUNT:
+        detail = ", ".join(path.as_posix() for path in missing)
+        raise ConfigurationError(
+            "packaged profiling campaign has an invalid inventory"
+            + (f": missing {detail}" if detail else "")
+        )
+    for relative in selected:
+        path = source / relative
+        if path.is_symlink() or not path.is_file():
+            raise ConfigurationError(
+                f"packaged profiling campaign has an unsafe member: {relative}"
+            )
+    return tuple(sorted(selected, key=lambda path: path.as_posix()))
+
+
+def profiling_campaign_root() -> Path:
+    packaged = resources.files("pyamplicol").joinpath("_profiling_campaign")
+    if not isinstance(packaged, os.PathLike):
+        raise ConfigurationError("packaged profiling campaign is unavailable")
+    path = Path(os.fspath(packaged))
+    _profiling_campaign_inventory(path)
+    return path.resolve()
+
+
+def _copy_tree(source: Path, destination: Path, *, force: bool) -> Path:
+    target = destination.expanduser().resolve(strict=False)
+    if target.exists():
+        if not target.is_dir():
+            raise ConfigurationError(f"destination is not a directory: {target}")
+        if any(target.iterdir()) and not force:
+            raise ConfigurationError(
+                f"destination is not empty: {target}; pass --force to merge"
+            )
+    target.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(source, target, dirs_exist_ok=True)
+    return target
+
+
+def _resolved_original_amplicol_checkout(path: Path) -> Path:
+    try:
+        repository = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise ConfigurationError(
+            f"--local-amplicol checkout is unavailable: {path}"
+        ) from error
+    if not repository.is_dir():
+        raise ConfigurationError(f"--local-amplicol is not a directory: {repository}")
+    return repository
+
+
+def _resolved_madgraph_installation(path: Path) -> Path:
+    try:
+        installation = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise ConfigurationError(
+            f"--local-madgraph installation is unavailable: {path}"
+        ) from error
+    if not installation.is_dir():
+        raise ConfigurationError(
+            f"--local-madgraph is not a directory: {installation}"
+        )
+    launcher = installation / "bin" / "mg5_aMC"
+    try:
+        launcher_mode = launcher.stat(follow_symlinks=False).st_mode
+    except OSError as error:
+        raise ConfigurationError(
+            "--local-madgraph must contain a regular executable bin/mg5_aMC"
+        ) from error
+    if not stat.S_ISREG(launcher_mode) or not os.access(launcher, os.X_OK):
+        raise ConfigurationError(
+            "--local-madgraph must contain a regular executable bin/mg5_aMC"
+        )
+    return installation
+
+
+def _literal_campaign_destination(destination: Path) -> Path:
+    """Return an absolute destination without accepting symlink traversal."""
+
+    target = Path(os.path.abspath(os.fspath(destination.expanduser())))
+    try:
+        canonical = target.resolve(strict=False)
+    except OSError as error:
+        raise ConfigurationError(
+            f"profiling campaign destination is unavailable: {target}"
+        ) from error
+    if canonical != target:
+        raise ConfigurationError(
+            "profiling campaign destination must not traverse a symlink: "
+            f"{target}"
+        )
+    if os.path.lexists(target):
+        try:
+            mode = target.lstat().st_mode
+        except OSError as error:
+            raise ConfigurationError(
+                f"cannot inspect profiling campaign destination: {target}"
+            ) from error
+        if stat.S_ISLNK(mode) or not stat.S_ISDIR(mode):
+            raise ConfigurationError(f"destination is not a real directory: {target}")
+    return target
+
+
+def _acquire_campaign_reset_lock(target: Path) -> int:
+    """Exclusively claim one real campaign directory without creating state."""
+
+    import fcntl
+
+    flags = os.O_RDONLY | getattr(os, "O_DIRECTORY", 0)
+    try:
+        descriptor = os.open(target, flags)
+    except OSError as error:
+        raise ConfigurationError(
+            f"cannot open profiling campaign destination: {target}"
+        ) from error
+    try:
+        fcntl.flock(descriptor, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError as error:
+        os.close(descriptor)
+        if error.errno in {errno.EACCES, errno.EAGAIN}:
+            raise ConfigurationError(
+                "profiling campaign is active; stop it before using --force: "
+                f"{target}"
+            ) from None
+        raise ConfigurationError(
+            f"cannot lock profiling campaign destination: {target}"
+        ) from error
+    return descriptor
+
+
+def _release_campaign_reset_lock(descriptor: int) -> None:
+    import fcntl
+
+    try:
+        fcntl.flock(descriptor, fcntl.LOCK_UN)
+    finally:
+        os.close(descriptor)
+
+
+def _require_campaign_member(target: Path, relative: Path) -> Path:
+    """Prove that a literal managed member remains beneath ``target``."""
+
+    if relative.is_absolute() or not relative.parts or any(
+        part in {"", ".", ".."} for part in relative.parts
+    ):
+        raise ConfigurationError(f"invalid profiling campaign member: {relative}")
+    member = target.joinpath(*relative.parts)
+    try:
+        member.relative_to(target)
+        canonical_target = target.resolve(strict=False)
+        member.resolve(strict=False).relative_to(canonical_target)
+    except (OSError, ValueError) as error:
+        raise ConfigurationError(
+            f"profiling campaign member escapes its destination: {relative}"
+        ) from error
+    return member
+
+
+def _preflight_managed_file(target: Path, relative: Path) -> Path:
+    """Reject links or non-files along one managed template output path."""
+
+    output = _require_campaign_member(target, relative)
+    cursor = target
+    for part in relative.parts[:-1]:
+        cursor /= part
+        if not os.path.lexists(cursor):
+            continue
+        mode = cursor.lstat().st_mode
+        if stat.S_ISLNK(mode) or not stat.S_ISDIR(mode):
+            raise ConfigurationError(
+                f"unsafe profiling campaign output ancestor: {cursor}"
+            )
+    if os.path.lexists(output):
+        mode = output.lstat().st_mode
+        if stat.S_ISLNK(mode) or not stat.S_ISREG(mode):
+            raise ConfigurationError(f"unsafe profiling campaign output: {output}")
+    return output
+
+
+def _preflight_removable_tree(path: Path) -> None:
+    """Validate one exact campaign-managed directory before its removal."""
+
+    if not os.path.lexists(path):
+        return
+    mode = path.lstat().st_mode
+    if stat.S_ISLNK(mode) or not stat.S_ISDIR(mode) or os.path.ismount(path):
+        raise ConfigurationError(f"unsafe campaign reset directory: {path}")
+    pending = [path]
+    while pending:
+        directory = pending.pop()
+        try:
+            entries = tuple(os.scandir(directory))
+        except OSError as error:
+            raise ConfigurationError(
+                f"cannot inspect campaign reset directory: {directory}"
+            ) from error
+        for entry in entries:
+            child = Path(entry.path)
+            try:
+                child_mode = entry.stat(follow_symlinks=False).st_mode
+            except OSError as error:
+                raise ConfigurationError(
+                    f"cannot inspect campaign reset member: {child}"
+                ) from error
+            if stat.S_ISLNK(child_mode):
+                raise ConfigurationError(
+                    f"campaign reset directory contains a symlink: {child}"
+                )
+            if stat.S_ISDIR(child_mode):
+                if os.path.ismount(child):
+                    raise ConfigurationError(
+                        f"campaign reset directory contains a mount: {child}"
+                    )
+                pending.append(child)
+            elif not stat.S_ISREG(child_mode):
+                raise ConfigurationError(
+                    f"campaign reset directory contains a special file: {child}"
+                )
+
+
+def _preflight_removable_file(path: Path) -> None:
+    if not os.path.lexists(path):
+        return
+    mode = path.lstat().st_mode
+    if stat.S_ISLNK(mode) or not stat.S_ISREG(mode):
+        raise ConfigurationError(f"unsafe campaign reset file: {path}")
+
+
+def _reset_profiling_campaign_outputs(target: Path) -> None:
+    """Remove only the exact campaign-managed runtime publications."""
+
+    state = _require_campaign_member(target, Path(_PROFILING_CAMPAIGN_STATE))
+    summary = _require_campaign_member(target, Path(_PROFILING_CAMPAIGN_SUMMARY))
+    pdf = _require_campaign_member(target, Path(_PROFILING_CAMPAIGN_PDF))
+    generated = tuple(
+        _require_campaign_member(target, Path(name))
+        for name in _PROFILING_CAMPAIGN_GENERATED_FILES
+    )
+    _preflight_removable_tree(state)
+    _preflight_removable_tree(summary)
+    _preflight_removable_file(pdf)
+    for path in generated:
+        _preflight_removable_file(path)
+    if state.exists():
+        shutil.rmtree(state)
+    if summary.exists():
+        shutil.rmtree(summary)
+    if pdf.exists():
+        pdf.unlink()
+    for path in generated:
+        if path.exists():
+            path.unlink()
+
+
+def _copy_profiling_campaign(
+    destination: Path,
+    *,
+    force: bool,
+    local_amplicol: Path | None = None,
+    local_madgraph: Path | None = None,
+) -> Path:
+    validated_amplicol = (
+        None
+        if local_amplicol is None
+        else _resolved_original_amplicol_checkout(local_amplicol)
+    )
+    validated_madgraph = (
+        None
+        if local_madgraph is None
+        else _resolved_madgraph_installation(local_madgraph)
+    )
+    source = profiling_campaign_root()
+    target = _literal_campaign_destination(destination)
+    if target.exists() and any(target.iterdir()) and not force:
+        raise ConfigurationError(
+            f"destination is not empty: {target}; pass --force to reset"
+        )
+    target.mkdir(parents=True, exist_ok=True)
+    if target.is_symlink() or not target.is_dir():
+        raise ConfigurationError(f"destination is not a real directory: {target}")
+    reset_lock = _acquire_campaign_reset_lock(target)
+    try:
+        inventory = _profiling_campaign_inventory(source)
+        for relative in inventory:
+            _preflight_managed_file(target, relative)
+        if validated_amplicol is not None:
+            _preflight_managed_file(
+                target,
+                Path(_PROFILING_CAMPAIGN_LOCAL_AMPLICOL),
+            )
+        if validated_madgraph is not None:
+            _preflight_managed_file(
+                target,
+                Path(_PROFILING_CAMPAIGN_LOCAL_MADGRAPH),
+            )
+        if force:
+            _reset_profiling_campaign_outputs(target)
+        for relative in inventory:
+            output = target / relative
+            output.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(source / relative, output)
+        launcher = target / "steer_performance_campaign.py"
+        launcher_lines = launcher.read_bytes().splitlines(keepends=True)
+        if not launcher_lines or not launcher_lines[0].startswith(b"#!"):
+            raise ConfigurationError("profiling campaign launcher has no shebang")
+        launcher.write_bytes(
+            f"#!{sys.executable}\n".encode() + b"".join(launcher_lines[1:])
+        )
+        launcher.chmod(
+            launcher.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+        )
+        local_amplicol_path = target / _PROFILING_CAMPAIGN_LOCAL_AMPLICOL
+        if validated_amplicol is not None:
+            local_amplicol_path.write_text(
+                f"{validated_amplicol}\n",
+                encoding="utf-8",
+            )
+        local_madgraph_path = target / _PROFILING_CAMPAIGN_LOCAL_MADGRAPH
+        if validated_madgraph is not None:
+            local_madgraph_path.write_text(
+                f"{validated_madgraph}\n",
+                encoding="utf-8",
+            )
+        state_root = target / _PROFILING_CAMPAIGN_STATE
+        state_root.mkdir()
+    finally:
+        _release_campaign_reset_lock(reset_lock)
+    return target
+
+
+def _copy_resource_tree(source: Traversable, destination: Path) -> None:
+    destination.mkdir(parents=True, exist_ok=True)
+    for child in source.iterdir():
+        if child.name == "__pycache__":
+            continue
+        target = destination / child.name
+        if child.is_dir():
+            _copy_resource_tree(child, target)
+        elif child.is_file():
+            target.write_bytes(child.read_bytes())
+
+
+def _copy_packaged_models(destination: Path) -> None:
+    source = resources.files("pyamplicol.assets").joinpath("models")
+    if not source.is_dir():
+        raise ConfigurationError("packaged model assets are unavailable")
+    _copy_resource_tree(source, destination)
+
+
+def _card_description(path: Path) -> str:
+    descriptions: list[str] = []
+    for line in path.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        description = stripped.lstrip("# ") if stripped.startswith("#") else ""
+        if description.startswith("SPDX-License-Identifier:"):
+            continue
+        if description:
+            descriptions.append(description)
+            continue
+        if descriptions:
+            break
+        if stripped and not stripped.startswith("#"):
+            break
+    return " ".join(descriptions) or "Packaged run-card example"
+
+
+def list_examples() -> tuple[ExampleEntry, ...]:
+    entries: list[ExampleEntry] = []
+    for card in sorted(examples_root().glob("*.toml")):
+        if card.name == "all_options.toml":
+            action = "reference"
+        else:
+            action = str(resolve_config(card).effective.action)
+        entries.append(ExampleEntry(card.stem, action, _card_description(card)))
+    return tuple(entries)
+
+
+def example_card(name: str) -> Path:
+    if not name or Path(name).name != name:
+        raise ConfigurationError("example name must not contain a path")
+    source = examples_root()
+    card = source / f"{name.removesuffix('.toml')}.toml"
+    if not card.is_file() or card.name == "all_options.toml":
+        available = ", ".join(entry.name for entry in list_examples())
+        raise ConfigurationError(f"unknown example {name!r}; available: {available}")
+    override = os.environ.get("PYAMPLICOL_EXAMPLE_CACHE")
+    if override:
+        workspace = Path(override).expanduser().resolve(strict=False)
+    else:
+        from platformdirs import user_cache_path
+
+        from pyamplicol import __version__
+
+        workspace = user_cache_path("pyamplicol") / "examples" / __version__
+    workspace.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(source, workspace, dirs_exist_ok=True)
+    _copy_packaged_models(workspace / "models")
+    return workspace / card.name
+
+
+def execute_utility(invocation: UtilityInvocation) -> object:
+    if invocation.kind == "config-template":
+        destination = (
+            Path("pyamplicol.toml") if invocation.path is None else invocation.path
+        )
+        source = examples_root() / "all_options.toml"
+        target = destination.expanduser().resolve(strict=False)
+        if target.exists() and not invocation.force:
+            raise ConfigurationError(f"configuration file exists: {target}")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target)
+        return UtilityResult("configuration template", "complete", target)
+    if invocation.kind == "config-resolve":
+        assert invocation.path is not None
+        return resolution_to_dict(
+            resolve_config(invocation.path, overrides=invocation.overrides)
+        )
+    if invocation.kind == "examples-list":
+        return list_examples()
+    if invocation.kind == "examples-copy":
+        assert invocation.path is not None
+        destination = _copy_tree(
+            examples_root(), invocation.path, force=invocation.force
+        )
+        _copy_packaged_models(destination / "models")
+        return UtilityResult("examples copy", "complete", destination)
+    if invocation.kind == "profiling-campaign-copy":
+        assert invocation.path is not None
+        destination = _copy_profiling_campaign(
+            invocation.path,
+            force=invocation.force,
+            local_amplicol=invocation.local_amplicol,
+            local_madgraph=invocation.local_madgraph,
+        )
+        return UtilityResult("profiling campaign copy", "complete", destination)
+    if invocation.kind == "doctor":
+        return run_doctor()
+    if invocation.kind == "self-test":
+        return run_self_test()
+    raise ConfigurationError(f"utility {invocation.kind!r} must be dispatched by CLI")
+
+
+__all__ = [
+    "ExampleEntry",
+    "UtilityInvocation",
+    "UtilityResult",
+    "example_card",
+    "examples_root",
+    "execute_utility",
+    "list_examples",
+    "parse_utility",
+    "profiling_campaign_root",
+]
diff --git a/pyamplicol/src/pyamplicol/color/__init__.py b/pyamplicol/src/pyamplicol/color/__init__.py
new file mode 100644
index 0000000000..9dc41adc19
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/__init__.py
@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: 0BSD
+from .contraction import (
+    ColorContractionEntry,
+    ColorContractionPlan,
+    ColorContractionTemplateEntry,
+    ColorGroupDescriptor,
+    FactorizedColorContractionBlock,
+    RepeatedColorContractionBlock,
+    SymmetricGroupColorContractionBlock,
+    build_color_contraction_plan,
+    color_contraction_factor,
+    color_contraction_factors,
+    exact_color_contraction_factor,
+    exact_color_contraction_factors,
+)
+from .plan import (
+    ColorTopologyReplayCertificate,
+    GenericColorPlan,
+    LCColorSector,
+    LCColorSectorReplayPartition,
+    LCColorSectorTopologyGroup,
+    LCColorTopologyReplayPlan,
+    LCOpenColorLine,
+    build_color_plan,
+    build_color_topology_replay_certificate,
+    build_lc_topology_replay_plan,
+    color_topology_replay_partitions,
+)
+from .symmetric_group import (
+    CertifiedSymmetricGroupOrbit,
+    SymmetricGroupOrbitPartition,
+    build_symmetric_group_color_contraction_plan,
+    certify_symmetric_group_orbits,
+    reconstruct_symmetric_group_dense_exact,
+)
+
+__all__ = [
+    "CertifiedSymmetricGroupOrbit",
+    "ColorContractionEntry",
+    "ColorContractionPlan",
+    "ColorContractionTemplateEntry",
+    "ColorGroupDescriptor",
+    "ColorTopologyReplayCertificate",
+    "FactorizedColorContractionBlock",
+    "GenericColorPlan",
+    "LCColorSector",
+    "LCColorSectorReplayPartition",
+    "LCColorSectorTopologyGroup",
+    "LCColorTopologyReplayPlan",
+    "LCOpenColorLine",
+    "RepeatedColorContractionBlock",
+    "SymmetricGroupColorContractionBlock",
+    "SymmetricGroupOrbitPartition",
+    "build_color_contraction_plan",
+    "build_color_plan",
+    "build_color_topology_replay_certificate",
+    "build_lc_topology_replay_plan",
+    "build_symmetric_group_color_contraction_plan",
+    "certify_symmetric_group_orbits",
+    "color_contraction_factor",
+    "color_contraction_factors",
+    "color_topology_replay_partitions",
+    "exact_color_contraction_factor",
+    "exact_color_contraction_factors",
+    "reconstruct_symmetric_group_dense_exact",
+]
diff --git a/pyamplicol/src/pyamplicol/color/adjoint_kernel.py b/pyamplicol/src/pyamplicol/color/adjoint_kernel.py
new file mode 100644
index 0000000000..183aee9fca
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/adjoint_kernel.py
@@ -0,0 +1,167 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact DDM Gram kernels without constructing the quadratic trace matrix.
+
+With Tr(Ta Tb) = delta_ab, a half-ladder is the nested-commutator trace
+Tr([...[T1,T2],...,T(n-1)] Tn).  Both U(1) contributions vanish under the
+commutators, so the inexpensive U(Nc) trace cycle kernel is sufficient.
+Applying the left/right commutator finite differences takes 2*(n-2) sweeps
+over S_(n-1); the result retained on the two-anchor subgroup has (n-2)!
+entries.  All arithmetic is integer, including NLC's Nc-power truncation.
+"""
+
+from __future__ import annotations
+
+import math
+from functools import lru_cache
+from itertools import chain, permutations
+
+import numpy as np
+
+MAX_ADJOINT_GLUONS = 12  # Two anchors plus the supported FFT degree of ten.
+
+
+def _permutation_ranks(rows: np.ndarray) -> np.ndarray:
+    """Rank a batch of image permutations in lexicographic order."""
+
+    degree = rows.shape[1]
+    ranks = np.zeros(len(rows), dtype=np.int64)
+    for position in range(degree - 1):
+        digit = rows[:, position].astype(np.int64)
+        for preceding in range(position):
+            digit -= rows[:, preceding] < rows[:, position]
+        ranks += digit * math.factorial(degree - position - 1)
+    return ranks
+
+
+def _trace_cycle_counts(rows: np.ndarray) -> np.ndarray:
+    """Cycles of c^-1 h c h^-1, with h fixing the final external label."""
+
+    count, degree = rows.shape
+    total = degree + 1
+    indices = np.arange(count)
+    commutator = np.empty((count, total), dtype=np.uint8)
+    for position in range(degree - 1):
+        commutator[indices, rows[:, position]] = (
+            rows[:, position + 1].astype(np.int16) - 1
+        ) % total
+    commutator[indices, rows[:, -1]] = total - 2
+    commutator[:, -1] = (rows[:, 0].astype(np.int16) - 1) % total
+    visited = np.zeros(count, dtype=np.uint32)
+    cycles = np.zeros(count, dtype=np.uint8)
+    bits = np.left_shift(np.uint32(1), np.arange(total, dtype=np.uint32))
+    for start in range(total):
+        active = (visited & bits[start]) == 0
+        cycles += active
+        position = np.full(count, start, dtype=np.uint8)
+        while np.any(active):
+            visited |= np.where(active, bits[position], np.uint32(0))
+            position = commutator[indices, position]
+            active &= (visited & bits[position]) == 0
+    return cycles
+
+
+@lru_cache(maxsize=4)
+def adjoint_color_kernel(
+    total_gluons: int,
+    *,
+    accuracy: str = "full",
+    nc: int = 3,
+    full_col_acc: int = 20,
+) -> np.ndarray:
+    """Return an immutable exact relative DDM kernel in lexicographic order.
+
+    ``lc`` and ``nlc`` retain powers >= n and >= n-2 respectively.  Since the
+    finite differences have Nc-independent integer coefficients, truncating
+    the seed commutes with the basis transformation.  The LC helper exists
+    for factor diagnostics; adjoint generation itself requires NLC/full.
+    """
+
+    if type(total_gluons) is not int or not 2 <= total_gluons <= MAX_ADJOINT_GLUONS:
+        raise ValueError("adjoint colour kernel requires 2 to 12 external adjoints")
+    if accuracy not in {"lc", "nlc", "full"}:
+        raise ValueError(f"unknown adjoint colour accuracy {accuracy!r}")
+    if type(nc) is not int or nc < 2:
+        raise ValueError("adjoint colour kernel requires integer Nc >= 2")
+    if type(full_col_acc) is not int or full_col_acc < 0:
+        raise ValueError("adjoint full-colour accuracy must be nonnegative")
+    if total_gluons == 2:
+        # The degenerate ladder is Tr(Ta Tb)=delta_ab. There is no
+        # commutator to remove U(1), so retain SU(Nc)'s exact dimension.
+        leading_only = accuracy == "lc" or (accuracy == "full" and full_col_acc == 0)
+        kernel = np.asarray([nc * nc - (0 if leading_only else 1)], dtype=np.int64)
+        kernel.flags.writeable = False
+        return kernel
+    degree = total_gluons - 1
+    # Each difference at most doubles the largest absolute input.  Check once
+    # before allocating; numpy's int64 arithmetic must never silently wrap.
+    if nc**total_gluons * 4 ** (total_gluons - 2) > np.iinfo(np.int64).max:
+        raise ValueError("adjoint finite differences exceed exact int64 range")
+    order = math.factorial(degree)
+    rows = np.fromiter(
+        chain.from_iterable(permutations(range(degree))),
+        dtype=np.uint8,
+        count=order * degree,
+    ).reshape(order, degree)
+    cycles = _trace_cycle_counts(rows)
+    powers = np.asarray(
+        [nc**power for power in range(total_gluons + 1)], dtype=np.int64
+    )
+    current = powers[cycles]
+    minimum_power = max(
+        total_gluons
+        - (2 * full_col_acc if accuracy == "full" else 2 if accuracy == "nlc" else 0),
+        0,
+    )
+    if minimum_power:
+        current[cycles < minimum_power] = 0
+    for generator in range(degree, 1, -1):
+        # s_i^-1 acts on images: 0->1->...->i-1->0.
+        relabel = np.arange(degree, dtype=np.uint8)
+        relabel[:generator] = (relabel[:generator] + 1) % generator
+        relative = relabel[rows]
+        ranks = _permutation_ranks(relative)
+        current = current - current[ranks]
+    for generator in range(degree, 1, -1):
+        # Right multiplication by s_i moves position i-1 to the beginning.
+        relative = rows.copy()
+        relative[:, 0] = rows[:, generator - 1]
+        relative[:, 1:generator] = rows[:, : generator - 1]
+        ranks = _permutation_ranks(relative)
+        current = current - current[ranks]
+    kernel = current[: math.factorial(degree - 1)].copy()
+    kernel.flags.writeable = False
+    return kernel
+
+
+def adjoint_color_factor(
+    left: tuple[int, ...],
+    right: tuple[int, ...],
+    *,
+    accuracy: str,
+    nc: int = 3,
+    full_col_acc: int = 20,
+) -> int:
+    """Evaluate one DDM overlap from its middle-label relative permutation."""
+
+    if (
+        len(left) < 2
+        or len(left) != len(right)
+        or left[0] != right[0]
+        or left[-1] != right[-1]
+        or len(set(left)) != len(left)
+        or set(left) != set(right)
+    ):
+        raise ValueError("DDM colour words must have matching fixed endpoints")
+    ranks_by_label = {label: index for index, label in enumerate(left[1:-1])}
+    relative = [ranks_by_label[label] for label in right[1:-1]]
+    rank = 0
+    remaining = list(range(len(relative)))
+    for position, value in enumerate(relative):
+        offset = remaining.index(value)
+        rank += offset * math.factorial(len(relative) - position - 1)
+        remaining.pop(offset)
+    return int(
+        adjoint_color_kernel(
+            len(left), accuracy=accuracy, nc=nc, full_col_acc=full_col_acc
+        )[rank]
+    )
diff --git a/pyamplicol/src/pyamplicol/color/connection_catalogue.py b/pyamplicol/src/pyamplicol/color/connection_catalogue.py
new file mode 100644
index 0000000000..b37ca6addf
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/connection_catalogue.py
@@ -0,0 +1,202 @@
+# SPDX-License-Identifier: 0BSD
+"""Structural catalogues of ordered soft colour connections at arbitrary order.
+
+Every active coloured leg can emit a gluon; only an auxiliary gluon can split
+into a quark pair. Born labels are positive. At order r, the r final auxiliary
+partons receive every assignment of labels -1,...,-r. Retired intermediates
+have separate dummy labels. Only independent chronological interleavings are
+identified: shared-line ordering and creation dependencies are retained.
+
+The catalogue contains all directed overlaps with matching final typed legs,
+including self-overlaps. It is not a minimal operator basis or a subtraction
+formula. No multiplicities, flavour sums, kinematic factors or numerical
+weights are attached to the canonical histories. The complete catalogue can
+grow rapidly; explicit requests remain preferable when only a subset is used.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Iterator, Sequence
+from itertools import permutations
+
+from .connections import (
+    ColorConnection,
+    ColorEmission,
+    ColorLeg,
+    EmitGluon,
+    SplitGluon,
+)
+from .correlator_matrices import ColorCorrelator
+
+_HistoryKey = tuple[tuple[int, ...], ...]
+
+
+def _parent(operation: ColorEmission) -> int:
+    return (
+        operation.emitter_label
+        if isinstance(operation, EmitGluon)
+        else operation.parent_label
+    )
+
+
+def _children(operation: ColorEmission) -> tuple[int, ...]:
+    return (
+        (operation.emitted_label,)
+        if isinstance(operation, EmitGluon)
+        else (operation.quark_label, operation.antiquark_label)
+    )
+
+
+def _operation_key(operation: ColorEmission) -> tuple[int, ...]:
+    return (
+        (0, operation.emitter_label, operation.emitted_label)
+        if isinstance(operation, EmitGluon)
+        else (
+            1,
+            operation.parent_label,
+            operation.quark_label,
+            operation.antiquark_label,
+        )
+    )
+
+
+def _canonical_order(
+    operations: tuple[ColorEmission, ...],
+) -> tuple[_HistoryKey, tuple[ColorEmission, ...]]:
+    """Return a comparison key and a valid chronological representative.
+
+    Sorting operation tokens alone would move consumers before producers.
+    Greedily taking the smallest available token gives the lexicographically
+    first topological order without enumerating independent interleavings.
+    """
+    dependencies = tuple(
+        (before, after)
+        for before in range(len(operations))
+        for after in range(before + 1, len(operations))
+        if _parent(operations[before]) == _parent(operations[after])
+        or _parent(operations[after]) in _children(operations[before])
+    )
+    remaining = set(range(len(operations)))
+    order = []
+    while remaining:
+        available = (
+            index
+            for index in remaining
+            if not any(
+                after == index and before in remaining for before, after in dependencies
+            )
+        )
+        next_index = min(available, key=lambda index: _operation_key(operations[index]))
+        order.append(next_index)
+        remaining.remove(next_index)
+    chronological = tuple(operations[index] for index in order)
+    return tuple(
+        _operation_key(operation) for operation in chronological
+    ), chronological
+
+
+def _rename(operation: ColorEmission, labels: dict[int, int]) -> ColorEmission:
+    def label(original: int) -> int:
+        return labels.get(original, original)
+
+    if isinstance(operation, EmitGluon):
+        return EmitGluon(label(operation.emitter_label), label(operation.emitted_label))
+    return SplitGluon(
+        label(operation.parent_label),
+        label(operation.quark_label),
+        label(operation.antiquark_label),
+    )
+
+
+def _labelled_histories(
+    connection: ColorConnection,
+) -> Iterator[tuple[_HistoryKey, tuple[ColorEmission, ...]]]:
+    final = tuple(leg.label for leg in connection.output_legs if leg.label < 0)
+    created = {child for step in connection.emissions for child in _children(step)}
+    retired = tuple(sorted(created.difference(final)))
+    final_labels = tuple(-index for index in range(1, connection.order + 1))
+    retired_labels = tuple(
+        -connection.order - index for index in range(1, len(retired) + 1)
+    )
+    assert len(final) == connection.order
+    for final_assignment in permutations(final_labels):
+        representatives = []
+        for retired_assignment in permutations(retired_labels):
+            labels = dict(zip(final, final_assignment, strict=True))
+            labels.update(zip(retired, retired_assignment, strict=True))
+            representatives.append(
+                _canonical_order(
+                    tuple(_rename(step, labels) for step in connection.emissions)
+                )
+            )
+        # Retired names are dummy indices, unlike the externally matched final
+        # labels. They must not create additional catalogue connections.
+        yield min(representatives, key=lambda candidate: candidate[0])
+
+
+def _extensions(connection: ColorConnection) -> Iterator[ColorConnection]:
+    created = tuple(child for step in connection.emissions for child in _children(step))
+    fresh = min(created, default=0) - 1
+    for leg in connection.output_legs:
+        if leg.representation == 1:
+            continue
+        yield ColorConnection(
+            connection.initial_legs,
+            (*connection.emissions, EmitGluon(leg.label, fresh)),
+        )
+        if leg.label < 0 and leg.representation == 8:
+            yield ColorConnection(
+                connection.initial_legs,
+                (*connection.emissions, SplitGluon(leg.label, fresh, fresh - 1)),
+            )
+
+
+def build_color_correlator_catalogue(
+    legs: Sequence[ColorLeg], *, through_order: int
+) -> tuple[ColorCorrelator, ...]:
+    """Prepare all ordered soft connections at orders 1 through ``through_order``.
+
+    ``legs`` are all-outgoing Born colour roles with positive public labels.
+    Singlets are allowed but do not emit. ``through_order`` is a positive integer.
+    The ordinary ``born`` identity is not included; ``CorrelatorConfig`` adds it.
+
+    IDs ``N{r}LO/c{i}/c{j}`` use zero-based indices in the deterministically
+    sorted connection list at each order. They are catalogue-local identifiers,
+    not process-independent operator names; the bra/ket operations encode the
+    actual connection. Every compatible directed pair is retained, without
+    assuming that the result is real, nonzero, positive or independent.
+    """
+    if type(through_order) is not int or through_order < 1:
+        raise ValueError("catalogue through_order must be a positive integer")
+    initial = ColorConnection(tuple(legs))
+    if any(leg.label <= 0 for leg in initial.initial_legs):
+        raise ValueError("catalogue Born legs must have positive labels")
+    histories: tuple[ColorConnection, ...] = (initial,)
+    result = []
+    for order in range(1, through_order + 1):
+        histories = tuple(
+            child for parent in histories for child in _extensions(parent)
+        )
+        unique = dict(
+            labelled
+            for connection in histories
+            for labelled in _labelled_histories(connection)
+        )
+        ordered = tuple(unique[key] for key in sorted(unique))
+        by_output: dict[tuple[ColorLeg, ...], list[int]] = defaultdict(list)
+        outputs = tuple(
+            ColorConnection(initial.initial_legs, operations).output_legs
+            for operations in ordered
+        )
+        for index, output in enumerate(outputs):
+            by_output[output].append(index)
+        for left, bra in enumerate(ordered):
+            for right in by_output[outputs[left]]:
+                result.append(
+                    ColorCorrelator(f"N{order}LO/c{left}/c{right}", bra, ordered[right])
+                )
+    return tuple(result)
+
+
+__all__ = ["build_color_correlator_catalogue"]
diff --git a/pyamplicol/src/pyamplicol/color/connections.py b/pyamplicol/src/pyamplicol/color/connections.py
new file mode 100644
index 0000000000..303958b748
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/connections.py
@@ -0,0 +1,612 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact, generation-independent ordered colour connections.
+
+Tensors are literal products of open strings and traces of generators ``tau``
+with ``tr(tau[a] tau[b]) = delta[a,b]``. Physical charges use
+``t = tau / sqrt(2)``. Every emission therefore contributes one common inverse
+sqrt(2), kept outside the rational tensor coefficients until the final overlap.
+The existing exact trace/Fierz reducer supplies the final colour-index sum.
+
+All legs are outgoing. Quark emission prepends a generator, antiquark emission
+appends its negative, and gluon emission replaces ``tau[a]`` by
+``[tau[a], tau[b]]``. A gluon splitting into a quark pair contracts its adjoint
+index against ``t[a]``. Connections are ordered, and later operations may act
+on previously emitted legs. No kinematic splitting factor is included.
+
+There is deliberately no AmpliCol endpoint-pairing phase in a literal tensor.
+A generation adapter must attach its basis convention as a tensor coefficient.
+In particular, overlap matrices are not operator action matrices and must not
+be multiplied to construct higher connections.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from fractions import Fraction
+from functools import cached_property
+from typing import TypeAlias
+
+from .contraction_trace import _simplify_trace_terms_nc_power
+from .contraction_types import NC
+
+COLOR_CONNECTION_CONVENTION = "su3-literal-tau-physical-charge-all-outgoing-v1"
+
+
+def _integer(value: object, name: str) -> int:
+    if type(value) is not int:
+        raise TypeError(f"{name} must be an integer")
+    return value
+
+
+def _fraction(value: int | Fraction) -> Fraction:
+    if not isinstance(value, (int, Fraction)) or isinstance(value, bool):
+        raise TypeError("exact colour coefficients must be integers or Fractions")
+    return Fraction(value)
+
+
+@dataclass(frozen=True)
+class ExactColorCoefficient:
+    """A complex number with exact rational real and imaginary parts."""
+
+    real: Fraction = Fraction(0)
+    imag: Fraction = Fraction(0)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "real", _fraction(self.real))
+        object.__setattr__(self, "imag", _fraction(self.imag))
+
+    def __bool__(self) -> bool:
+        return bool(self.real or self.imag)
+
+    def __complex__(self) -> complex:
+        return complex(float(self.real), float(self.imag))
+
+    def __add__(self, other: ExactColorCoefficient) -> ExactColorCoefficient:
+        return ExactColorCoefficient(self.real + other.real, self.imag + other.imag)
+
+    def __mul__(self, other: ExactColorCoefficient) -> ExactColorCoefficient:
+        return ExactColorCoefficient(
+            self.real * other.real - self.imag * other.imag,
+            self.real * other.imag + self.imag * other.real,
+        )
+
+    def conjugate(self) -> ExactColorCoefficient:
+        return ExactColorCoefficient(self.real, -self.imag)
+
+    def scaled(self, factor: int | Fraction) -> ExactColorCoefficient:
+        factor = _fraction(factor)
+        return ExactColorCoefficient(self.real * factor, self.imag * factor)
+
+
+_ONE = ExactColorCoefficient(1)
+
+
+@dataclass(frozen=True, order=True)
+class ColorLeg:
+    label: int
+    representation: int
+
+    def __post_init__(self) -> None:
+        _integer(self.label, "colour leg label")
+        _integer(self.representation, "colour representation")
+        if self.representation not in (1, 3, -3, 8):
+            raise ValueError("colour connections support only singlets, 3, -3 and 8")
+
+
+def all_outgoing_color_leg(
+    label: int, representation: int, *, incoming: bool = False
+) -> ColorLeg:
+    """Dualize incoming fundamental representations, without changing momenta.
+
+    ``representation`` is the physical particle's signed representation before
+    crossing. Adjoint and singlet representations are self-conjugate.
+    """
+
+    leg = ColorLeg(label, representation)
+    if type(incoming) is not bool:
+        raise TypeError("incoming must be a boolean")
+    return (
+        ColorLeg(label, -representation)
+        if incoming and abs(representation) == 3
+        else leg
+    )
+
+
+@dataclass(frozen=True, order=True)
+class OpenColorString:
+    fundamental_label: int
+    adjoint_labels: tuple[int, ...]
+    antifundamental_label: int
+
+    def __post_init__(self) -> None:
+        _integer(self.fundamental_label, "fundamental label")
+        _integer(self.antifundamental_label, "antifundamental label")
+        labels = tuple(self.adjoint_labels)
+        for label in labels:
+            _integer(label, "adjoint label")
+        object.__setattr__(self, "adjoint_labels", labels)
+
+
+def _canonical_trace(trace: tuple[int, ...]) -> tuple[int, ...]:
+    return (
+        min(trace[index:] + trace[:index] for index in range(len(trace)))
+        if trace
+        else ()
+    )
+
+
+@dataclass(frozen=True, order=True)
+class ColorTensor:
+    """An unordered product of open strings and cyclic (not reflected) traces."""
+
+    open_strings: tuple[OpenColorString, ...] = ()
+    traces: tuple[tuple[int, ...], ...] = ()
+
+    def __post_init__(self) -> None:
+        strings = tuple(self.open_strings)
+        if any(not isinstance(string, OpenColorString) for string in strings):
+            raise TypeError("open strings must be OpenColorString records")
+        traces = tuple(tuple(trace) for trace in self.traces)
+        for trace in traces:
+            for label in trace:
+                _integer(label, "trace adjoint label")
+        object.__setattr__(self, "open_strings", tuple(sorted(strings)))
+        object.__setattr__(
+            self, "traces", tuple(sorted(_canonical_trace(t) for t in traces))
+        )
+
+
+@dataclass(frozen=True)
+class EmitGluon:
+    emitter_label: int
+    emitted_label: int
+
+    def __post_init__(self) -> None:
+        _integer(self.emitter_label, "emitter label")
+        _integer(self.emitted_label, "emitted label")
+
+
+@dataclass(frozen=True)
+class SplitGluon:
+    parent_label: int
+    quark_label: int
+    antiquark_label: int
+
+    def __post_init__(self) -> None:
+        _integer(self.parent_label, "splitting parent label")
+        _integer(self.quark_label, "splitting quark label")
+        _integer(self.antiquark_label, "splitting antiquark label")
+
+
+ColorEmission: TypeAlias = EmitGluon | SplitGluon
+
+
+def _canonical_legs(legs: tuple[ColorLeg, ...]) -> tuple[ColorLeg, ...]:
+    if any(not isinstance(leg, ColorLeg) for leg in legs):
+        raise TypeError("connection legs must be ColorLeg records")
+    if len({leg.label for leg in legs}) != len(legs):
+        raise ValueError("connection leg labels must be unique")
+    return tuple(sorted(legs))
+
+
+@dataclass(frozen=True)
+class ColorConnection:
+    initial_legs: tuple[ColorLeg, ...]
+    emissions: tuple[ColorEmission, ...] = ()
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self, "initial_legs", _canonical_legs(tuple(self.initial_legs))
+        )
+        object.__setattr__(self, "emissions", tuple(self.emissions))
+        _ = self.output_legs  # Validate parents, representations and fresh labels once.
+
+    @property
+    def order(self) -> int:
+        return len(self.emissions)
+
+    @cached_property
+    def output_legs(self) -> tuple[ColorLeg, ...]:
+        active = {leg.label: leg.representation for leg in self.initial_legs}
+        seen = set(active)
+        for emission in self.emissions:
+            if isinstance(emission, EmitGluon):
+                if active.get(emission.emitter_label) not in (3, -3, 8):
+                    raise ValueError("gluon emitter must be an active coloured leg")
+                additions = (ColorLeg(emission.emitted_label, 8),)
+            elif isinstance(emission, SplitGluon):
+                if active.get(emission.parent_label) != 8:
+                    raise ValueError(
+                        "quark-pair splitting parent must be an active gluon"
+                    )
+                additions = (
+                    ColorLeg(emission.quark_label, 3),
+                    ColorLeg(emission.antiquark_label, -3),
+                )
+                del active[emission.parent_label]
+            else:
+                raise TypeError("unknown colour emission record")
+            labels = tuple(leg.label for leg in additions)
+            if len(set(labels)) != len(labels) or seen.intersection(labels):
+                raise ValueError(
+                    "emitted colour labels must be fresh, including retired labels"
+                )
+            seen.update(labels)
+            active.update((leg.label, leg.representation) for leg in additions)
+        return tuple(ColorLeg(label, rep) for label, rep in sorted(active.items()))
+
+
+@dataclass(frozen=True)
+class TensorTerm:
+    coefficient: ExactColorCoefficient
+    tensor: ColorTensor
+    nc_power: int = 0
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.coefficient, ExactColorCoefficient):
+            raise TypeError("tensor coefficients must be ExactColorCoefficient records")
+        if not isinstance(self.tensor, ColorTensor):
+            raise TypeError("tensor terms must contain ColorTensor records")
+        _integer(self.nc_power, "tensor Nc power")
+
+
+def _validate_tensor_legs(tensor: ColorTensor, legs: tuple[ColorLeg, ...]) -> None:
+    labels = []
+    for string in tensor.open_strings:
+        labels.extend(
+            (
+                ColorLeg(string.fundamental_label, 3),
+                ColorLeg(string.antifundamental_label, -3),
+            )
+        )
+        labels.extend(ColorLeg(label, 8) for label in string.adjoint_labels)
+    labels.extend(ColorLeg(label, 8) for trace in tensor.traces for label in trace)
+    if tuple(sorted(labels)) != tuple(leg for leg in legs if leg.representation != 1):
+        raise ValueError(
+            "tensor indices do not match the typed external colour legs exactly once"
+        )
+
+
+def _combine_terms(terms: tuple[TensorTerm, ...]) -> tuple[TensorTerm, ...]:
+    combined: dict[tuple[ColorTensor, int], ExactColorCoefficient] = {}
+    for term in terms:
+        if not isinstance(term, TensorTerm):
+            raise TypeError("connected tensors require TensorTerm records")
+        if any(len(trace) == 1 for trace in term.tensor.traces):
+            continue
+        empty_traces = sum(not trace for trace in term.tensor.traces)
+        tensor = ColorTensor(
+            term.tensor.open_strings, tuple(t for t in term.tensor.traces if t)
+        )
+        key = (tensor, term.nc_power + empty_traces)
+        combined[key] = combined.get(key, ExactColorCoefficient()) + term.coefficient
+    return tuple(
+        TensorTerm(value, tensor, power)
+        for (tensor, power), value in sorted(combined.items())
+        if value
+    )
+
+
+@dataclass(frozen=True)
+class ConnectedColorTensor:
+    legs: tuple[ColorLeg, ...]
+    terms: tuple[TensorTerm, ...]
+    normalization_power: int = 0
+
+    def __post_init__(self) -> None:
+        legs = _canonical_legs(tuple(self.legs))
+        terms = tuple(self.terms)
+        power = _integer(
+            self.normalization_power, "inverse sqrt(2) normalization power"
+        )
+        if power < 0:
+            raise ValueError("normalization power must be nonnegative")
+        for term in terms:
+            if not isinstance(term, TensorTerm):
+                raise TypeError("connected tensors require TensorTerm records")
+            _validate_tensor_legs(term.tensor, legs)
+        object.__setattr__(self, "legs", legs)
+        object.__setattr__(self, "terms", _combine_terms(terms))
+
+
+def _replace_string(
+    tensor: ColorTensor, index: int, replacements: tuple[OpenColorString, ...]
+) -> ColorTensor:
+    return ColorTensor(
+        tensor.open_strings[:index] + replacements + tensor.open_strings[index + 1 :],
+        tensor.traces,
+    )
+
+
+def _emit(
+    tensor: ColorTensor, emission: EmitGluon
+) -> tuple[tuple[Fraction, ColorTensor], ...]:
+    emitter, emitted = emission.emitter_label, emission.emitted_label
+    for index, string in enumerate(tensor.open_strings):
+        q, word, qbar = (
+            string.fundamental_label,
+            string.adjoint_labels,
+            string.antifundamental_label,
+        )
+        if emitter == q:
+            return (
+                (
+                    Fraction(1),
+                    _replace_string(
+                        tensor, index, (OpenColorString(q, (emitted, *word), qbar),)
+                    ),
+                ),
+            )
+        if emitter == qbar:
+            return (
+                (
+                    Fraction(-1),
+                    _replace_string(
+                        tensor, index, (OpenColorString(q, (*word, emitted), qbar),)
+                    ),
+                ),
+            )
+        if emitter in word:
+            position = word.index(emitter)
+            before, after = word[:position], word[position + 1 :]
+            return tuple(
+                (
+                    Fraction(sign),
+                    _replace_string(
+                        tensor,
+                        index,
+                        (OpenColorString(q, before + middle + after, qbar),),
+                    ),
+                )
+                for sign, middle in ((1, (emitter, emitted)), (-1, (emitted, emitter)))
+            )
+    for index, trace in enumerate(tensor.traces):
+        if emitter in trace:
+            position = trace.index(emitter)
+            before, after = trace[:position], trace[position + 1 :]
+            return tuple(
+                (
+                    Fraction(sign),
+                    ColorTensor(
+                        tensor.open_strings,
+                        (
+                            *tensor.traces[:index],
+                            before + middle + after,
+                            *tensor.traces[index + 1 :],
+                        ),
+                    ),
+                )
+                for sign, middle in ((1, (emitter, emitted)), (-1, (emitted, emitter)))
+            )
+    raise ValueError("emitter has no tensor index")
+
+
+def _split(
+    tensor: ColorTensor, emission: SplitGluon
+) -> tuple[tuple[Fraction, int, ColorTensor], ...]:
+    parent, q, qbar = (
+        emission.parent_label,
+        emission.quark_label,
+        emission.antiquark_label,
+    )
+    for index, string in enumerate(tensor.open_strings):
+        if parent not in string.adjoint_labels:
+            continue
+        position = string.adjoint_labels.index(parent)
+        before, after = (
+            string.adjoint_labels[:position],
+            string.adjoint_labels[position + 1 :],
+        )
+        return (
+            (
+                Fraction(1),
+                0,
+                _replace_string(
+                    tensor,
+                    index,
+                    (
+                        OpenColorString(string.fundamental_label, before, qbar),
+                        OpenColorString(q, after, string.antifundamental_label),
+                    ),
+                ),
+            ),
+            (
+                Fraction(-1),
+                -1,
+                _replace_string(
+                    tensor,
+                    index,
+                    (
+                        OpenColorString(
+                            string.fundamental_label,
+                            before + after,
+                            string.antifundamental_label,
+                        ),
+                        OpenColorString(q, (), qbar),
+                    ),
+                ),
+            ),
+        )
+    for index, trace in enumerate(tensor.traces):
+        if parent not in trace:
+            continue
+        position = trace.index(parent)
+        before, after = trace[:position], trace[position + 1 :]
+        remaining = tensor.traces[:index] + tensor.traces[index + 1 :]
+        return (
+            (
+                Fraction(1),
+                0,
+                ColorTensor(
+                    (*tensor.open_strings, OpenColorString(q, after + before, qbar)),
+                    remaining,
+                ),
+            ),
+            (
+                Fraction(-1),
+                -1,
+                ColorTensor(
+                    (*tensor.open_strings, OpenColorString(q, (), qbar)),
+                    (*remaining, before + after),
+                ),
+            ),
+        )
+    raise ValueError("splitting parent has no tensor index")
+
+
+def apply_color_connection(
+    tensor: ColorTensor,
+    connection: ColorConnection,
+    *,
+    coefficient: ExactColorCoefficient = _ONE,
+) -> ConnectedColorTensor:
+    """Apply an ordered connection; at most two word terms arise per operation."""
+
+    if not isinstance(tensor, ColorTensor) or not isinstance(
+        connection, ColorConnection
+    ):
+        raise TypeError("apply_color_connection requires a tensor and a connection")
+    _validate_tensor_legs(tensor, connection.initial_legs)
+    terms = (TensorTerm(coefficient, tensor),)
+    for emission in connection.emissions:
+        transformed = []
+        for term in terms:
+            changes = (
+                tuple(
+                    (factor, 0, image) for factor, image in _emit(term.tensor, emission)
+                )
+                if isinstance(emission, EmitGluon)
+                else _split(term.tensor, emission)
+            )
+            for factor, power, image in changes:
+                transformed.append(
+                    TensorTerm(
+                        term.coefficient.scaled(factor), image, term.nc_power + power
+                    )
+                )
+        terms = _combine_terms(tuple(transformed))
+    return ConnectedColorTensor(connection.output_legs, terms, connection.order)
+
+
+def _literal_tensor_overlap_nc_terms(
+    left: ColorTensor, right: ColorTensor
+) -> Mapping[int, Fraction]:
+    traces = list(right.traces) + [tuple(reversed(trace)) for trace in left.traces]
+    right_by_q = {string.fundamental_label: string for string in right.open_strings}
+    left_by_qbar = {
+        string.antifundamental_label: string for string in left.open_strings
+    }
+    visited: set[int] = set()
+    for start in sorted(right_by_q):
+        if start in visited:
+            continue
+        current = start
+        trace: list[int] = []
+        while current not in visited:
+            visited.add(current)
+            right_string = right_by_q[current]
+            left_string = left_by_qbar[right_string.antifundamental_label]
+            trace.extend(right_string.adjoint_labels)
+            trace.extend(reversed(left_string.adjoint_labels))
+            current = left_string.fundamental_label
+        traces.append(tuple(trace))
+    return _simplify_trace_terms_nc_power(((Fraction(1), 0, tuple(traces)),))
+
+
+def contract_connected_tensor_nc_terms(
+    left: ConnectedColorTensor, right: ConnectedColorTensor
+) -> dict[int, ExactColorCoefficient]:
+    """Return the exact Laurent coefficients of ``left.conjugate() * right``.
+
+    The scalar overlap is sesquilinear, not forcibly real or positive. Matching
+    physical bra/ket connection orders have even combined normalization power.
+    Odd powers (unlike these correlators) need an irrational coefficient type
+    and are rejected instead of silently rounded.
+    """
+
+    if left.legs != right.legs:
+        raise ValueError(
+            "bra and ket connections must have identical typed output legs"
+        )
+    power = left.normalization_power + right.normalization_power
+    if power % 2:
+        raise ValueError("bra/ket normalization has an odd inverse sqrt(2) power")
+    result: dict[int, ExactColorCoefficient] = {}
+    normalization = Fraction(1, 2 ** (power // 2))
+    for left_term in left.terms:
+        for right_term in right.terms:
+            coefficient = (
+                left_term.coefficient.conjugate() * right_term.coefficient
+            ).scaled(normalization)
+            for nc_power, factor in _literal_tensor_overlap_nc_terms(
+                left_term.tensor, right_term.tensor
+            ).items():
+                exponent = nc_power + left_term.nc_power + right_term.nc_power
+                result[exponent] = result.get(
+                    exponent, ExactColorCoefficient()
+                ) + coefficient.scaled(factor)
+    return {power: coefficient for power, coefficient in result.items() if coefficient}
+
+
+def evaluate_color_nc_terms(
+    terms: Mapping[int, ExactColorCoefficient],
+) -> ExactColorCoefficient:
+    """Evaluate retained colour Laurent coefficients at physical ``Nc = 3``."""
+
+    result = ExactColorCoefficient()
+    for power, coefficient in terms.items():
+        result = result + coefficient.scaled(Fraction(NC) ** power)
+    return result
+
+
+def contract_connected_tensors(
+    left: ConnectedColorTensor, right: ConnectedColorTensor
+) -> ExactColorCoefficient:
+    """Sum the full connected colour overlap exactly at physical ``Nc = 3``."""
+
+    return evaluate_color_nc_terms(contract_connected_tensor_nc_terms(left, right))
+
+
+def color_connection_matrix_element(
+    left_tensor: ColorTensor,
+    left_connection: ColorConnection,
+    right_tensor: ColorTensor,
+    right_connection: ColorConnection,
+    *,
+    left_coefficient: ExactColorCoefficient = _ONE,
+    right_coefficient: ExactColorCoefficient = _ONE,
+) -> ExactColorCoefficient:
+    """One exact connected matrix entry, before any amplitude/helicity sum."""
+
+    if left_connection.initial_legs != right_connection.initial_legs:
+        raise ValueError("bra and ket connections must start from identical typed legs")
+    return contract_connected_tensors(
+        apply_color_connection(
+            left_tensor, left_connection, coefficient=left_coefficient
+        ),
+        apply_color_connection(
+            right_tensor, right_connection, coefficient=right_coefficient
+        ),
+    )
+
+
+__all__ = [
+    "COLOR_CONNECTION_CONVENTION",
+    "ColorConnection",
+    "ColorEmission",
+    "ColorLeg",
+    "ColorTensor",
+    "ConnectedColorTensor",
+    "EmitGluon",
+    "ExactColorCoefficient",
+    "OpenColorString",
+    "SplitGluon",
+    "TensorTerm",
+    "all_outgoing_color_leg",
+    "apply_color_connection",
+    "color_connection_matrix_element",
+    "contract_connected_tensor_nc_terms",
+    "contract_connected_tensors",
+    "evaluate_color_nc_terms",
+]
diff --git a/pyamplicol/src/pyamplicol/color/contraction.py b/pyamplicol/src/pyamplicol/color/contraction.py
new file mode 100644
index 0000000000..d22bb9a95e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/contraction.py
@@ -0,0 +1,530 @@
+# SPDX-License-Identifier: 0BSD
+"""Color-contraction planning and public factor selection."""
+
+from __future__ import annotations
+
+import math
+import struct
+from collections.abc import Sequence
+from fractions import Fraction
+
+from .contraction_factors import (
+    _coloured_word,
+    _common_helicity_weight,
+    _is_open_line_pair,
+    _multi_open_line_color_factors,
+    _one_open_line_color_factors,
+    _pure_adjoint_color_factor,
+    _pure_adjoint_color_factors,
+    _two_open_line_color_factors,
+    exact_color_contraction_factor,
+    exact_color_contraction_factors,
+)
+from .contraction_types import (
+    ColorContractionEntry,
+    ColorContractionPlan,
+    ColorContractionTemplateEntry,
+    ColorGroupDescriptor,
+    FactorizedColorContractionBlock,
+    RepeatedColorContractionBlock,
+    SymmetricGroupColorContractionBlock,
+)
+from .plan import GenericColorPlan, LCColorSector
+
+
+def build_color_contraction_plan(
+    color_plan: GenericColorPlan,
+    groups: Sequence[ColorGroupDescriptor],
+) -> ColorContractionPlan | None:
+    """Build the final colour contraction over coherent amplitude groups.
+
+    LC artifacts keep the historical Rusticol diagonal reduction path.  NLC and
+    full-colour artifacts attach an explicit sparse colour matrix whose entries
+    include AmpliCol's colour factors, so no leading-colour scalar factor should
+    be applied again at runtime.
+    """
+
+    accuracy = color_plan.color_accuracy
+    if accuracy == "lc":
+        return None
+    if accuracy not in {"nlc", "full"}:
+        return ColorContractionPlan(
+            color_accuracy=accuracy,
+            supported=False,
+            reason=f"unknown colour accuracy {accuracy!r}",
+            group_count=len(groups),
+            entries=(),
+        )
+    descriptors = tuple(groups)
+    sector_by_id = {sector.id: sector for sector in color_plan.sectors}
+    descriptors_by_helicity: dict[tuple[object, ...], list[ColorGroupDescriptor]] = {}
+    for descriptor in descriptors:
+        descriptors_by_helicity.setdefault(descriptor.helicity_key, []).append(
+            descriptor
+        )
+    components = tuple(
+        tuple(component) for component in descriptors_by_helicity.values()
+    )
+    repeated_block = _build_repeated_color_contraction_block(
+        color_plan,
+        components,
+        sector_by_id=sector_by_id,
+        accuracy=accuracy,
+    )
+    if repeated_block is not None:
+        return ColorContractionPlan(
+            color_accuracy=accuracy,
+            supported=True,
+            reason=None,
+            group_count=len(groups),
+            entries=(),
+            repeated_block=repeated_block,
+        )
+
+    entries: list[ColorContractionEntry] = []
+    factor_cache: dict[tuple[int, int], Fraction] = {}
+    for helicity_descriptors in descriptors_by_helicity.values():
+        for left_offset, left in enumerate(helicity_descriptors):
+            left_sector = sector_by_id.get(left.sector_id)
+            if left_sector is None:
+                return ColorContractionPlan(
+                    color_accuracy=accuracy,
+                    supported=False,
+                    reason=f"missing colour sector {left.sector_id}",
+                    group_count=len(groups),
+                    entries=(),
+                )
+            for right in helicity_descriptors[left_offset:]:
+                right_sector = sector_by_id.get(right.sector_id)
+                if right_sector is None:
+                    return ColorContractionPlan(
+                        color_accuracy=accuracy,
+                        supported=False,
+                        reason=f"missing colour sector {right.sector_id}",
+                        group_count=len(groups),
+                        entries=(),
+                    )
+                sector_pair = (left.sector_id, right.sector_id)
+                weight = factor_cache.get(sector_pair)
+                if weight is None:
+                    weight = exact_color_contraction_factor(
+                        color_plan,
+                        left_sector,
+                        right_sector,
+                        accuracy=accuracy,
+                        full_col_acc=20,
+                    )
+                    factor_cache[sector_pair] = weight
+                if abs(weight) <= 0.0:
+                    continue
+                symmetry = 1.0 if left.group_id == right.group_id else 2.0
+                helicity_weight = _common_helicity_weight(left, right)
+                entries.append(
+                    ColorContractionEntry(
+                        left_group_id=left.group_id,
+                        right_group_id=right.group_id,
+                        weight_re=helicity_weight * float(weight),
+                        symmetry_factor=symmetry,
+                        exact_weight=(Fraction(helicity_weight) * weight, Fraction(0)),
+                    )
+                )
+    return ColorContractionPlan(
+        color_accuracy=accuracy,
+        supported=True,
+        reason=None,
+        group_count=len(groups),
+        entries=tuple(entries),
+    )
+
+
+def _build_repeated_color_contraction_block(
+    color_plan: GenericColorPlan,
+    components: Sequence[Sequence[ColorGroupDescriptor]],
+    *,
+    sector_by_id: dict[int, LCColorSector],
+    accuracy: str,
+) -> RepeatedColorContractionBlock | None:
+    if len(components) < 2 or not components[0]:
+        return None
+    sorted_sector_ids = tuple(
+        sorted(descriptor.sector_id for descriptor in components[0])
+    )
+    if len(set(sorted_sector_ids)) != len(sorted_sector_ids):
+        return None
+    reference_weight_bits = _binary64_bits(components[0][0].helicity_weight)
+    descriptors_by_component_and_sector: list[dict[int, ColorGroupDescriptor]] = []
+    for component in components:
+        component_sector_ids = tuple(
+            sorted(descriptor.sector_id for descriptor in component)
+        )
+        if (
+            component_sector_ids != sorted_sector_ids
+            or len(set(component_sector_ids)) != len(component_sector_ids)
+            or any(
+                _binary64_bits(descriptor.helicity_weight) != reference_weight_bits
+                for descriptor in component
+            )
+        ):
+            return None
+        descriptors_by_component_and_sector.append(
+            {descriptor.sector_id: descriptor for descriptor in component}
+        )
+
+    component_group_ids = tuple(
+        descriptors_by_sector[sector_id].group_id
+        for sector_id in sorted_sector_ids
+        for descriptors_by_sector in descriptors_by_component_and_sector
+    )
+    base_entries: list[ColorContractionTemplateEntry] = []
+    helicity_weight = components[0][0].helicity_weight
+    for left_group_index, left_sector_id in enumerate(sorted_sector_ids):
+        left_sector = sector_by_id.get(left_sector_id)
+        if left_sector is None:
+            return None
+        for right_group_index in range(left_group_index, len(sorted_sector_ids)):
+            right_sector_id = sorted_sector_ids[right_group_index]
+            right_sector = sector_by_id.get(right_sector_id)
+            if right_sector is None:
+                return None
+            weight = exact_color_contraction_factor(
+                color_plan,
+                left_sector,
+                right_sector,
+                accuracy=accuracy,
+                full_col_acc=20,
+            )
+            if abs(weight) <= 0.0:
+                continue
+            base_entries.append(
+                ColorContractionTemplateEntry(
+                    left_group_index=left_group_index,
+                    right_group_index=right_group_index,
+                    weight_re=helicity_weight * float(weight),
+                    symmetry_factor=(
+                        1.0 if left_group_index == right_group_index else 2.0
+                    ),
+                    exact_weight=(Fraction(helicity_weight) * weight, Fraction(0)),
+                )
+            )
+    return RepeatedColorContractionBlock(
+        component_count=len(components),
+        component_group_ids=component_group_ids,
+        entries=tuple(base_entries),
+        factorized_block=_build_walsh_color_contraction_block(
+            tuple(
+                descriptors_by_component_and_sector[0][sector_id].word
+                for sector_id in sorted_sector_ids
+            ),
+            tuple(base_entries),
+        ),
+    )
+
+
+def _build_walsh_color_contraction_block(
+    words: Sequence[Sequence[int]],
+    entries: Sequence[ColorContractionTemplateEntry],
+) -> FactorizedColorContractionBlock | None:
+    """Recognize an exact free elementary-Abelian action on one color matrix."""
+
+    if not words:
+        return None
+    canonical_words = tuple(tuple(word) for word in words)
+    canonical_word = canonical_words[0]
+    if len(set(canonical_word)) != len(canonical_word):
+        return None
+    if any(
+        len(word) != len(canonical_word)
+        or len(set(word)) != len(word)
+        or set(word) != set(canonical_word)
+        for word in canonical_words
+    ):
+        return None
+
+    matrix: dict[tuple[int, int], float] = {}
+    for entry in entries:
+        if (
+            entry.weight_im != 0.0
+            or not math.isfinite(entry.weight_re)
+            or not math.isfinite(entry.symmetry_factor)
+        ):
+            return None
+        left, right = sorted((entry.left_group_index, entry.right_group_index))
+        if (left, right) in matrix:
+            return None
+        weight = (
+            entry.symmetry_factor * entry.weight_re
+            if left == right
+            else 0.5 * entry.symmetry_factor * entry.weight_re
+        )
+        if not math.isfinite(weight):
+            return None
+        matrix[(left, right)] = weight
+
+    def matrix_value(left: int, right: int) -> float:
+        return matrix.get((min(left, right), max(left, right)), 0.0)
+
+    def matrix_is_invariant(action: tuple[int, ...]) -> bool:
+        return all(
+            matrix_value(action[left], action[right]) == weight
+            for (left, right), weight in matrix.items()
+        )
+
+    def action_cosets(
+        actions: Sequence[tuple[int, ...]],
+    ) -> tuple[tuple[int, ...], ...] | None:
+        if len(actions) < 2:
+            return None
+        expected_indices = list(range(len(canonical_words)))
+        for action in actions:
+            if sorted(action) != expected_indices or any(
+                action[action[index]] != index for index in expected_indices
+            ):
+                return None
+        for first_offset, first_action in enumerate(actions):
+            for second_action in actions[first_offset + 1 :]:
+                if any(
+                    first_action[second_action[index]]
+                    != second_action[first_action[index]]
+                    for index in expected_indices
+                ):
+                    return None
+
+        group_actions: list[tuple[int, ...]] = []
+        for mask in range(1 << len(actions)):
+            action = tuple(expected_indices)
+            for generator_index, generator in enumerate(actions):
+                if mask & (1 << generator_index):
+                    action = tuple(generator[index] for index in action)
+            group_actions.append(action)
+
+        remaining = set(expected_indices)
+        cosets: list[tuple[int, ...]] = []
+        while remaining:
+            representative = min(remaining)
+            coset = tuple(action[representative] for action in group_actions)
+            if len(set(coset)) != len(group_actions) or not set(coset).issubset(
+                remaining
+            ):
+                return None
+            cosets.append(coset)
+            remaining.difference_update(coset)
+        return tuple(cosets)
+
+    def matrix_has_walsh_blocks(
+        cosets: Sequence[tuple[int, ...]],
+    ) -> bool:
+        if not cosets:
+            return False
+        group_size = len(cosets[0])
+        if group_size < 4 or any(len(coset) != group_size for coset in cosets):
+            return False
+        return all(
+            matrix_value(
+                left_coset[left_subgroup_index],
+                right_coset[right_subgroup_index],
+            )
+            == matrix_value(
+                left_coset[0],
+                right_coset[left_subgroup_index ^ right_subgroup_index],
+            )
+            for left_coset in cosets
+            for right_coset in cosets
+            for left_subgroup_index in range(group_size)
+            for right_subgroup_index in range(group_size)
+        )
+
+    def factorized_block(
+        actions: Sequence[tuple[int, ...]],
+    ) -> FactorizedColorContractionBlock | None:
+        # H8 is the largest physically measured transform. Preserve K4 as the
+        # fallback and do not emit wider transforms until realistic multi-coset
+        # workloads demonstrate that their locality/transform cost is useful.
+        for rank in range(min(len(actions), 3), 1, -1):
+            cosets = action_cosets(actions[:rank])
+            if cosets is None or not matrix_has_walsh_blocks(cosets):
+                continue
+            if rank == 2:
+                return FactorizedColorContractionBlock(
+                    kind="klein-four-walsh",
+                    cosets=cosets,
+                )
+            return FactorizedColorContractionBlock(
+                kind="elementary-abelian-walsh",
+                rank=rank,
+                cosets=cosets,
+            )
+        return None
+
+    # Preserve the established plan for a complete scalar permutation orbit.
+    positions = {
+        label: tuple(word.index(label) for word in canonical_words)
+        for label in canonical_word
+    }
+    variable_labels = tuple(
+        label for label in canonical_word if len(set(positions[label])) > 1
+    )
+    variable_count = len(variable_labels)
+    if variable_count >= 4 and len(canonical_words) == math.factorial(variable_count):
+        rank_by_label = {
+            label: rank for rank, label in enumerate(sorted(variable_labels))
+        }
+        permutations = tuple(
+            tuple(rank_by_label[label] for label in word if label in rank_by_label)
+            for word in canonical_words
+        )
+        expected_ranks = set(range(variable_count))
+        index_by_permutation = {
+            permutation: index for index, permutation in enumerate(permutations)
+        }
+        if all(
+            set(permutation) == expected_ranks for permutation in permutations
+        ) and len(index_by_permutation) == math.factorial(variable_count):
+            substitutions = tuple(
+                tuple(
+                    pair_start + 1
+                    if rank == pair_start
+                    else pair_start
+                    if rank == pair_start + 1
+                    else rank
+                    for rank in range(variable_count)
+                )
+                for pair_start in range(0, variable_count - 1, 2)
+            )
+            actions = tuple(
+                tuple(
+                    index_by_permutation[
+                        tuple(substitution[rank] for rank in permutation)
+                    ]
+                    for permutation in permutations
+                )
+                for substitution in substitutions
+            )
+            block = factorized_block(actions)
+            if block is not None:
+                return block
+
+    # Multi-open-line bases are often unions of permutation orbits rather than
+    # one full symmetric-group orbit.  Discover exact label-swap automorphisms
+    # of the actual word set and matrix; no particle or process identity is
+    # assumed, and any incomplete or weight-asymmetric orbit falls back.
+    index_by_word = {word: index for index, word in enumerate(canonical_words)}
+    if len(index_by_word) != len(canonical_words):
+        return None
+    invariant_swaps: list[tuple[tuple[int, int], tuple[int, ...]]] = []
+    ordered_labels = sorted(canonical_word)
+    for left_offset, left_label in enumerate(ordered_labels):
+        for right_label in ordered_labels[left_offset + 1 :]:
+            substitution = {left_label: right_label, right_label: left_label}
+            try:
+                action = tuple(
+                    index_by_word[
+                        tuple(substitution.get(label, label) for label in word)
+                    ]
+                    for word in canonical_words
+                )
+            except KeyError:
+                continue
+            if matrix_is_invariant(action):
+                invariant_swaps.append(((left_label, right_label), action))
+
+    selected_actions: list[tuple[int, ...]] = []
+    selected_labels: set[int] = set()
+    for labels, action in invariant_swaps:
+        if selected_labels.isdisjoint(labels):
+            selected_actions.append(action)
+            selected_labels.update(labels)
+    return factorized_block(selected_actions)
+
+
+def _binary64_bits(value: float) -> bytes:
+    return struct.pack(">d", float(value))
+
+
+def color_contraction_factors(
+    color_plan: GenericColorPlan,
+    left: LCColorSector,
+    right: LCColorSector,
+    *,
+    full_col_acc: int = 20,
+) -> tuple[float, float, float]:
+    """Return reference-normalized (LC, NLC, full) colour factors."""
+
+    if color_plan.basis == "adjoint":
+        return tuple(
+            float(value)
+            for value in exact_color_contraction_factors(
+                color_plan, left, right, full_col_acc=full_col_acc
+            )
+        )
+    open_line_count = color_plan.process.color_endpoints.pair_count
+    n_ord = len(_coloured_word(left))
+    if len(_coloured_word(right)) != n_ord:
+        return (0.0, 0.0, 0.0)
+    if open_line_count == 0:
+        return _pure_adjoint_color_factors(left, right, n_ord, full_col_acc)
+    if open_line_count == 1:
+        return _one_open_line_color_factors(left, right, n_ord)
+    if open_line_count == 2:
+        return _two_open_line_color_factors(color_plan, left, right, n_ord)
+    if open_line_count >= 3 and _is_open_line_pair(left, right):
+        return _multi_open_line_color_factors(color_plan, left, right)
+    return (0.0, 0.0, 0.0)
+
+
+def color_contraction_factor(
+    color_plan: GenericColorPlan,
+    left: LCColorSector,
+    right: LCColorSector,
+    *,
+    accuracy: str,
+    full_col_acc: int = 20,
+) -> float:
+    """Return only the requested reference-normalized colour factor."""
+
+    if color_plan.basis == "adjoint":
+        return float(
+            exact_color_contraction_factor(
+                color_plan, left, right, accuracy=accuracy, full_col_acc=full_col_acc
+            )
+        )
+    open_line_count = color_plan.process.color_endpoints.pair_count
+    n_ord = len(_coloured_word(left))
+    if len(_coloured_word(right)) != n_ord:
+        return 0.0
+    if open_line_count == 0:
+        return _pure_adjoint_color_factor(
+            left,
+            right,
+            n_ord,
+            accuracy=accuracy,
+            full_col_acc=full_col_acc,
+        )
+    values = color_contraction_factors(
+        color_plan,
+        left,
+        right,
+        full_col_acc=full_col_acc,
+    )
+    if accuracy == "lc":
+        return values[0]
+    if accuracy == "nlc":
+        return values[1]
+    if accuracy == "full":
+        return values[2]
+    return 0.0
+
+
+__all__ = [
+    "ColorContractionEntry",
+    "ColorContractionPlan",
+    "ColorContractionTemplateEntry",
+    "ColorGroupDescriptor",
+    "FactorizedColorContractionBlock",
+    "RepeatedColorContractionBlock",
+    "SymmetricGroupColorContractionBlock",
+    "build_color_contraction_plan",
+    "color_contraction_factor",
+    "color_contraction_factors",
+    "exact_color_contraction_factor",
+    "exact_color_contraction_factors",
+]
diff --git a/pyamplicol/src/pyamplicol/color/contraction_factors.py b/pyamplicol/src/pyamplicol/color/contraction_factors.py
new file mode 100644
index 0000000000..80f1e70c3b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/contraction_factors.py
@@ -0,0 +1,961 @@
+# SPDX-License-Identifier: 0BSD
+"""Representation-based color-factor algorithms."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from fractions import Fraction
+from functools import lru_cache
+
+from .contraction_trace import (
+    _check_nlc,
+    _check_nlc_one_open_line,
+    _eval_nc_terms,
+    _eval_nc_terms_exact,
+    _eval_trace,
+    _eval_trace_exact,
+    _simplify_trace_terms,
+    _simplify_trace_terms_nc_power,
+)
+from .contraction_types import NC, ColorGroupDescriptor
+from .plan import GenericColorPlan, LCColorSector, LCOpenColorLine
+
+
+def _pure_adjoint_color_factors(
+    left: LCColorSector,
+    right: LCColorSector,
+    n_ord: int,
+    full_col_acc: int,
+) -> tuple[float, float, float]:
+    return (
+        _pure_adjoint_color_factor(
+            left,
+            right,
+            n_ord,
+            accuracy="lc",
+            full_col_acc=full_col_acc,
+        ),
+        _pure_adjoint_color_factor(
+            left,
+            right,
+            n_ord,
+            accuracy="nlc",
+            full_col_acc=full_col_acc,
+        ),
+        _pure_adjoint_color_factor(
+            left,
+            right,
+            n_ord,
+            accuracy="full",
+            full_col_acc=full_col_acc,
+        ),
+    )
+
+
+def _pure_adjoint_color_factors_exact(
+    left: LCColorSector,
+    right: LCColorSector,
+    n_ord: int,
+    full_col_acc: int,
+) -> tuple[Fraction, Fraction, Fraction]:
+    return (
+        _pure_adjoint_color_factor_exact(
+            left,
+            right,
+            n_ord,
+            accuracy="lc",
+            full_col_acc=full_col_acc,
+        ),
+        _pure_adjoint_color_factor_exact(
+            left,
+            right,
+            n_ord,
+            accuracy="nlc",
+            full_col_acc=full_col_acc,
+        ),
+        _pure_adjoint_color_factor_exact(
+            left,
+            right,
+            n_ord,
+            accuracy="full",
+            full_col_acc=full_col_acc,
+        ),
+    )
+
+
+def _pure_adjoint_color_factor(
+    left: LCColorSector,
+    right: LCColorSector,
+    n_ord: int,
+    *,
+    accuracy: str,
+    full_col_acc: int,
+) -> float:
+    iper = _coloured_word(left)
+    jper = _coloured_word(right)
+    if n_ord == 0:
+        return 1.0 if not iper and not jper else 0.0
+    if accuracy == "lc":
+        return float(NC**n_ord) if iper == jper else 0.0
+    if accuracy == "nlc":
+        if n_ord == 2:
+            # Tr(Ta Tb)=delta_ab, whose norm Nc^2-1 is already exact at
+            # NLC. The n>=3 shortcut below would incorrectly count two
+            # independent U(1) subtractions for the same identity tensor.
+            return float(NC**2 - 1)
+        if iper == jper:
+            return float(NC**n_ord - n_ord * NC ** (n_ord - 2))
+        return float(_check_nlc(tuple(jper), tuple(iper)) * NC ** (n_ord - 2))
+    if accuracy != "full":
+        return 0.0
+    relative = _relative_adjoint_permutation(iper, jper)
+    if relative is not None:
+        return _pure_adjoint_full_factor_by_relative_permutation(
+            relative,
+            n_ord,
+            full_col_acc,
+        )
+    return _pure_adjoint_full_factor_uncached(
+        tuple(iper),
+        tuple(jper),
+        n_ord,
+        full_col_acc,
+    )
+
+
+def _pure_adjoint_color_factor_exact(
+    left: LCColorSector,
+    right: LCColorSector,
+    n_ord: int,
+    *,
+    accuracy: str,
+    full_col_acc: int,
+) -> Fraction:
+    iper = _coloured_word(left)
+    jper = _coloured_word(right)
+    if n_ord == 0:
+        return Fraction(1 if not iper and not jper else 0)
+    nc = Fraction(NC)
+    if accuracy == "lc":
+        return nc**n_ord if iper == jper else Fraction(0)
+    if accuracy == "nlc":
+        if n_ord == 2:
+            return nc**2 - 1
+        if iper == jper:
+            return nc**n_ord - n_ord * nc ** (n_ord - 2)
+        return Fraction(_check_nlc(tuple(jper), tuple(iper))) * nc ** (n_ord - 2)
+    if accuracy != "full":
+        return Fraction(0)
+    relative = _relative_adjoint_permutation(iper, jper)
+    if relative is not None:
+        return _pure_adjoint_full_factor_exact_by_relative_permutation(
+            relative,
+            n_ord,
+            full_col_acc,
+        )
+    return _pure_adjoint_full_factor_exact_uncached(
+        tuple(iper),
+        tuple(jper),
+        n_ord,
+        full_col_acc,
+    )
+
+
+def _relative_adjoint_permutation(
+    left: tuple[int, ...],
+    right: tuple[int, ...],
+) -> tuple[int, ...] | None:
+    """Canonicalize a trace pair under simultaneous adjoint relabelling."""
+
+    if len(left) != len(right) or len(set(left)) != len(left):
+        return None
+    position = {label: index for index, label in enumerate(left)}
+    try:
+        relative = tuple(position[label] for label in right)
+    except KeyError:
+        return None
+    if len(set(relative)) != len(relative):
+        return None
+    return relative
+
+
+@lru_cache(maxsize=65536)
+def _pure_adjoint_full_factor_by_relative_permutation(
+    relative: tuple[int, ...],
+    n_ord: int,
+    full_col_acc: int,
+) -> float:
+    canonical = tuple(range(len(relative)))
+    return _pure_adjoint_full_factor_uncached(
+        canonical,
+        relative,
+        n_ord,
+        full_col_acc,
+    )
+
+
+@lru_cache(maxsize=65536)
+def _pure_adjoint_full_factor_exact_by_relative_permutation(
+    relative: tuple[int, ...],
+    n_ord: int,
+    full_col_acc: int,
+) -> Fraction:
+    canonical = tuple(range(len(relative)))
+    return _pure_adjoint_full_factor_exact_uncached(
+        canonical,
+        relative,
+        n_ord,
+        full_col_acc,
+    )
+
+
+def _pure_adjoint_full_factor_uncached(
+    iper: tuple[int, ...],
+    jper: tuple[int, ...],
+    n_ord: int,
+    full_col_acc: int,
+) -> float:
+    full_terms = _simplify_trace_terms(
+        ((Fraction(1), (tuple(iper), tuple(reversed(jper)))),)
+    )
+    return _eval_nc_terms(
+        full_terms,
+        min_power=max(n_ord - 2 * full_col_acc, 0),
+    )
+
+
+def _pure_adjoint_full_factor_exact_uncached(
+    iper: tuple[int, ...],
+    jper: tuple[int, ...],
+    n_ord: int,
+    full_col_acc: int,
+) -> Fraction:
+    full_terms = _simplify_trace_terms(
+        ((Fraction(1), (tuple(iper), tuple(reversed(jper)))),)
+    )
+    return _eval_nc_terms_exact(
+        full_terms,
+        min_power=max(n_ord - 2 * full_col_acc, 0),
+    )
+
+
+def _one_open_line_color_factors(
+    left: LCColorSector,
+    right: LCColorSector,
+    n_ord: int,
+) -> tuple[float, float, float]:
+    iper = _coloured_word(left)
+    jper = _coloured_word(right)
+    lc = float(NC ** (n_ord - 1)) if iper == jper else 0.0
+    full = _eval_trace(
+        (tuple((*iper[1:-1], *reversed(jper[1:-1]))),),
+    )
+    if iper == jper:
+        nlc = full
+    else:
+        acc = _check_nlc_one_open_line(tuple(jper[1:-1]), tuple(iper[1:-1]))
+        nlc = full if acc != 0 else 0.0
+    return (lc, nlc, full)
+
+
+def _one_open_line_color_factors_exact(
+    left: LCColorSector,
+    right: LCColorSector,
+    n_ord: int,
+) -> tuple[Fraction, Fraction, Fraction]:
+    iper = _coloured_word(left)
+    jper = _coloured_word(right)
+    lc = Fraction(NC) ** (n_ord - 1) if iper == jper else Fraction(0)
+    full = _eval_trace_exact(
+        (tuple((*iper[1:-1], *reversed(jper[1:-1]))),),
+    )
+    if iper == jper:
+        nlc = full
+    else:
+        acc = _check_nlc_one_open_line(tuple(jper[1:-1]), tuple(iper[1:-1]))
+        nlc = full if acc != 0 else Fraction(0)
+    return (lc, nlc, full)
+
+
+def _two_open_line_color_factors(
+    color_plan: GenericColorPlan,
+    left: LCColorSector,
+    right: LCColorSector,
+    n_ord: int,
+) -> tuple[float, float, float]:
+    reference_start = _two_line_reference_start(color_plan)
+    iper = _rotate_to_reference_start(_coloured_word(left), reference_start)
+    jper = _rotate_to_reference_start(_coloured_word(right), reference_start)
+    reference = (
+        _rotate_to_reference_start(
+            _coloured_word(color_plan.sectors[0]), reference_start
+        )
+        if color_plan.sectors
+        else iper
+    )
+    gi, ui = _two_line_gi_ui(color_plan, iper, reference)
+    gj, uj = _two_line_gi_ui(color_plan, jper, reference)
+    repeated_fundamental_species = _has_repeated_fundamental_species(color_plan)
+    lc = 0.0
+    if iper == jper:
+        if ui == 1 and uj == 1:
+            lc = float(NC ** (n_ord - 2))
+        elif ui == 2 and uj == 2 and not repeated_fundamental_species:
+            lc = float(NC ** (n_ord - 4) * 9.0)
+        elif ui == 2 and uj == 2 and repeated_fundamental_species:
+            lc = float(NC ** (n_ord - 2))
+    full = _two_open_line_full_factor(
+        iper,
+        jper,
+        n_ord=n_ord,
+        gi=gi,
+        gj=gj,
+        ui=ui,
+        uj=uj,
+    )
+    nlc = 0.0
+    if abs(full) > 0.0:
+        iper_adj, jper_adj = _two_line_ordered_adjoint_strings(
+            color_plan,
+            iper,
+            jper,
+        )
+        iper_ord, jper_ord = _convert_two_line_adjoint_strings(
+            n_ord,
+            iper_adj,
+            jper_adj,
+        )
+        acc = _check_nlc_two_open_lines_same_species(
+            n_ord,
+            iper_ord,
+            jper_ord,
+            gi,
+            gj,
+            ui,
+            uj,
+        )
+        if acc != 0:
+            nlc = full
+    return (lc, nlc, full)
+
+
+def _two_open_line_color_factors_exact(
+    color_plan: GenericColorPlan,
+    left: LCColorSector,
+    right: LCColorSector,
+    n_ord: int,
+) -> tuple[Fraction, Fraction, Fraction]:
+    reference_start = _two_line_reference_start(color_plan)
+    iper = _rotate_to_reference_start(_coloured_word(left), reference_start)
+    jper = _rotate_to_reference_start(_coloured_word(right), reference_start)
+    reference = (
+        _rotate_to_reference_start(
+            _coloured_word(color_plan.sectors[0]), reference_start
+        )
+        if color_plan.sectors
+        else iper
+    )
+    gi, ui = _two_line_gi_ui(color_plan, iper, reference)
+    gj, uj = _two_line_gi_ui(color_plan, jper, reference)
+    repeated_fundamental_species = _has_repeated_fundamental_species(color_plan)
+    lc = Fraction(0)
+    if iper == jper:
+        if ui == 1 and uj == 1:
+            lc = Fraction(NC) ** (n_ord - 2)
+        elif ui == 2 and uj == 2 and not repeated_fundamental_species:
+            lc = Fraction(9) * Fraction(NC) ** (n_ord - 4)
+        elif ui == 2 and uj == 2 and repeated_fundamental_species:
+            lc = Fraction(NC) ** (n_ord - 2)
+    full = _two_open_line_full_factor_exact(
+        iper,
+        jper,
+        n_ord=n_ord,
+        gi=gi,
+        gj=gj,
+        ui=ui,
+        uj=uj,
+    )
+    nlc = Fraction(0)
+    if full:
+        iper_adj, jper_adj = _two_line_ordered_adjoint_strings(
+            color_plan,
+            iper,
+            jper,
+        )
+        iper_ord, jper_ord = _convert_two_line_adjoint_strings(
+            n_ord,
+            iper_adj,
+            jper_adj,
+        )
+        acc = _check_nlc_two_open_lines_same_species(
+            n_ord,
+            iper_ord,
+            jper_ord,
+            gi,
+            gj,
+            ui,
+            uj,
+        )
+        if acc != 0:
+            nlc = full
+    return (lc, nlc, full)
+
+
+def _two_open_line_full_factor(
+    iper: tuple[int, ...],
+    jper: tuple[int, ...],
+    *,
+    n_ord: int,
+    gi: int,
+    gj: int,
+    ui: int,
+    uj: int,
+) -> float:
+    if ui == uj:
+        traces = (
+            tuple((*iper[1 : 1 + gi], *reversed(jper[1 : 1 + gj]))),
+            tuple((*iper[gi + 3 : n_ord - 1], *reversed(jper[gj + 3 : n_ord - 1]))),
+        )
+        coeff = Fraction(1)
+    elif (ui, uj) in {(1, 2), (2, 1)}:
+        traces = (
+            tuple(
+                (
+                    *iper[1 : 1 + gi],
+                    *reversed(jper[gj + 3 : n_ord - 1]),
+                    *iper[gi + 3 : n_ord - 1],
+                    *reversed(jper[1 : 1 + gj]),
+                )
+            ),
+        )
+        coeff = Fraction(-1)
+    else:
+        return 0.0
+    return _eval_trace(traces, coeff=coeff)
+
+
+def _two_open_line_full_factor_exact(
+    iper: tuple[int, ...],
+    jper: tuple[int, ...],
+    *,
+    n_ord: int,
+    gi: int,
+    gj: int,
+    ui: int,
+    uj: int,
+) -> Fraction:
+    if ui == uj:
+        traces = (
+            tuple((*iper[1 : 1 + gi], *reversed(jper[1 : 1 + gj]))),
+            tuple((*iper[gi + 3 : n_ord - 1], *reversed(jper[gj + 3 : n_ord - 1]))),
+        )
+        coeff = Fraction(1)
+    elif (ui, uj) in {(1, 2), (2, 1)}:
+        traces = (
+            tuple(
+                (
+                    *iper[1 : 1 + gi],
+                    *reversed(jper[gj + 3 : n_ord - 1]),
+                    *iper[gi + 3 : n_ord - 1],
+                    *reversed(jper[1 : 1 + gj]),
+                )
+            ),
+        )
+        coeff = Fraction(-1)
+    else:
+        return Fraction(0)
+    return _eval_trace_exact(traces, coeff=coeff)
+
+
+def _is_open_line_pair(
+    left: LCColorSector,
+    right: LCColorSector,
+) -> bool:
+    if left.kind != "open-lines" or right.kind != "open-lines":
+        return False
+    return len(left.open_color_lines) == len(right.open_color_lines)
+
+
+def _multi_open_line_color_factors(
+    color_plan: GenericColorPlan,
+    left: LCColorSector,
+    right: LCColorSector,
+) -> tuple[float, float, float]:
+    """Generic overlap of multi-open-line colour-flow tensors.
+
+    Each sector is a product of open strings
+    ``(T...T)_{i,\bar j}``.  The right sector is conjugated, so its adjoint
+    string is traversed in reverse order, and the fundamental colour indices
+    form closed alternating left/right cycles.  The resulting traces are reduced
+    with the same Fierz machinery used for pure traces, but we keep powers of
+    ``Nc`` symbolic so that NLC can be obtained by dropping terms beyond the
+    first ``1/Nc**2`` suppression.
+    """
+
+    terms = _open_line_nc_power_terms(
+        left.open_color_lines,
+        right.open_color_lines,
+    )
+    if not terms:
+        return (0.0, 0.0, 0.0)
+    leading_power = color_plan.process.color_endpoints.pair_count + len(
+        color_plan.process.adjoint_labels
+    )
+    lc = _eval_nc_terms(terms, min_power=leading_power)
+    full = _eval_nc_terms(terms)
+    # NLC selects matrix entries by their leading Nc power, but retains the
+    # exact coefficient of every selected entry.  Truncating the coefficient
+    # itself changes off-diagonal multi-line contractions once adjoints are
+    # present (for example 8 -> 9 for three open lines plus one adjoint).
+    nlc = full if max(terms) >= leading_power - 2 else 0.0
+    return (lc, nlc, full)
+
+
+def _multi_open_line_color_factors_exact(
+    color_plan: GenericColorPlan,
+    left: LCColorSector,
+    right: LCColorSector,
+) -> tuple[Fraction, Fraction, Fraction]:
+    terms = _open_line_nc_power_terms(
+        left.open_color_lines,
+        right.open_color_lines,
+    )
+    if not terms:
+        return (Fraction(0), Fraction(0), Fraction(0))
+    leading_power = color_plan.process.color_endpoints.pair_count + len(
+        color_plan.process.adjoint_labels
+    )
+    lc = _eval_nc_terms_exact(terms, min_power=leading_power)
+    full = _eval_nc_terms_exact(terms)
+    nlc = full if max(terms) >= leading_power - 2 else Fraction(0)
+    return (lc, nlc, full)
+
+
+def exact_color_contraction_factors(
+    color_plan: GenericColorPlan,
+    left: LCColorSector,
+    right: LCColorSector,
+    *,
+    full_col_acc: int = 20,
+) -> tuple[Fraction, Fraction, Fraction]:
+    """Return exact reference-normalized ``(LC, NLC, full)`` color factors."""
+
+    if color_plan.basis == "adjoint":
+        return tuple(
+            exact_color_contraction_factor(
+                color_plan, left, right, accuracy=accuracy, full_col_acc=full_col_acc
+            )
+            for accuracy in ("lc", "nlc", "full")
+        )
+    open_line_count = color_plan.process.color_endpoints.pair_count
+    n_ord = len(_coloured_word(left))
+    if len(_coloured_word(right)) != n_ord:
+        return (Fraction(0), Fraction(0), Fraction(0))
+    if open_line_count == 0:
+        return _pure_adjoint_color_factors_exact(
+            left,
+            right,
+            n_ord,
+            full_col_acc,
+        )
+    if open_line_count == 1:
+        return _one_open_line_color_factors_exact(left, right, n_ord)
+    if open_line_count == 2:
+        return _two_open_line_color_factors_exact(color_plan, left, right, n_ord)
+    if open_line_count >= 3 and _is_open_line_pair(left, right):
+        return _multi_open_line_color_factors_exact(color_plan, left, right)
+    return (Fraction(0), Fraction(0), Fraction(0))
+
+
+def exact_color_contraction_factor(
+    color_plan: GenericColorPlan,
+    left: LCColorSector,
+    right: LCColorSector,
+    *,
+    accuracy: str,
+    full_col_acc: int = 20,
+) -> Fraction:
+    """Return one exact reference-normalized color factor."""
+
+    if accuracy not in {"lc", "nlc", "full"}:
+        return Fraction(0)
+    if color_plan.basis == "adjoint":
+        from .adjoint_kernel import adjoint_color_factor
+
+        return Fraction(
+            adjoint_color_factor(
+                _coloured_word(left),
+                _coloured_word(right),
+                accuracy=accuracy,
+                nc=NC,
+                full_col_acc=full_col_acc,
+            )
+        )
+    if color_plan.process.color_endpoints.pair_count == 0:
+        n_ord = len(_coloured_word(left))
+        if len(_coloured_word(right)) != n_ord:
+            return Fraction(0)
+        # LC/NLC have direct formulae and must not evaluate the full trace.
+        return _pure_adjoint_color_factor_exact(
+            left,
+            right,
+            n_ord,
+            accuracy=accuracy,
+            full_col_acc=full_col_acc,
+        )
+    values = exact_color_contraction_factors(
+        color_plan,
+        left,
+        right,
+        full_col_acc=full_col_acc,
+    )
+    if accuracy == "lc":
+        return values[0]
+    if accuracy == "nlc":
+        return values[1]
+    if accuracy == "full":
+        return values[2]
+    return Fraction(0)
+
+
+def _open_line_nc_power_terms(
+    left_lines: tuple[LCOpenColorLine, ...],
+    right_lines: tuple[LCOpenColorLine, ...],
+) -> Mapping[int, Fraction]:
+    left_by_fundamental = {line.fundamental_label: line for line in left_lines}
+    right_by_antifundamental = {
+        line.antifundamental_label: line for line in right_lines
+    }
+    if set(left_by_fundamental) != {line.fundamental_label for line in right_lines}:
+        return {}
+    if {line.antifundamental_label for line in left_lines} != set(
+        right_by_antifundamental
+    ):
+        return {}
+
+    visited: set[int] = set()
+    traces: list[tuple[int, ...]] = []
+    for start in sorted(left_by_fundamental):
+        if start in visited:
+            continue
+        current = start
+        trace: list[int] = []
+        while current not in visited:
+            visited.add(current)
+            left_line = left_by_fundamental.get(current)
+            if left_line is None:
+                return {}
+            trace.extend(left_line.adjoint_labels)
+            right_line = right_by_antifundamental.get(left_line.antifundamental_label)
+            if right_line is None:
+                return {}
+            trace.extend(reversed(right_line.adjoint_labels))
+            current = right_line.fundamental_label
+        traces.append(tuple(trace))
+    permutation_sign = -1 if (len(left_lines) - len(traces)) % 2 else 1
+    return _simplify_trace_terms_nc_power(
+        ((Fraction(permutation_sign), 0, tuple(traces)),)
+    )
+
+
+def _coloured_word(sector: LCColorSector) -> tuple[int, ...]:
+    if sector.kind == "single-trace":
+        return tuple(sector.trace_labels)
+    if sector.kind == "open-lines":
+        return tuple(sector.word_labels or sector.color_words[0])
+    return ()
+
+
+def _two_line_reference_start(color_plan: GenericColorPlan) -> int | None:
+    if color_plan.process.fundamental_labels:
+        return int(color_plan.process.fundamental_labels[0])
+    return None
+
+
+def _rotate_to_reference_start(
+    word: tuple[int, ...],
+    reference_start: int | None,
+) -> tuple[int, ...]:
+    if reference_start is None or reference_start not in word:
+        return word
+    offset = word.index(reference_start)
+    return word[offset:] + word[:offset]
+
+
+def _two_line_gi_ui(
+    color_plan: GenericColorPlan,
+    word: tuple[int, ...],
+    reference_word: tuple[int, ...],
+) -> tuple[int, int]:
+    fundamental_endpoints = set(color_plan.process.fundamental_labels) | set(
+        color_plan.process.antifundamental_labels
+    )
+    gi = 0
+    for position in range(1, max(len(word) - 1, 1)):
+        if word[position] in fundamental_endpoints:
+            gi = position - 1
+            break
+    ui = 1
+    if len(word) >= 2 and len(reference_word) >= 2:
+        same_ends = word[0] == reference_word[0] and word[-1] == reference_word[-1]
+        opposite_ends = word[0] != reference_word[0] and word[-1] != reference_word[-1]
+        ui = 1 if same_ends or opposite_ends else 2
+    return gi, ui
+
+
+def _two_line_ordered_adjoint_strings(
+    color_plan: GenericColorPlan,
+    iper: tuple[int, ...],
+    jper: tuple[int, ...],
+) -> tuple[tuple[int, ...], tuple[int, ...]]:
+    fundamental_endpoints = set(color_plan.process.fundamental_labels) | set(
+        color_plan.process.antifundamental_labels
+    )
+    return (
+        tuple(label for label in iper if label not in fundamental_endpoints),
+        tuple(label for label in jper if label not in fundamental_endpoints),
+    )
+
+
+def _convert_two_line_adjoint_strings(
+    n_ord: int,
+    iper: tuple[int, ...],
+    jper: tuple[int, ...],
+) -> tuple[tuple[int, ...], tuple[int, ...]]:
+    """Mirror AmpliCol's ordered-adjoint-string conversion.
+
+    The NLC topology tests depend only on the relative order of adjoints.  The
+    Fortran routine maps the largest external label to 1, the next largest to
+    2, and so on, separately for the row and column strings.
+    """
+
+    expected = max(n_ord - 4, 0)
+    if len(iper) != expected or len(jper) != expected:
+        return iper, jper
+
+    def convert(word: tuple[int, ...]) -> tuple[int, ...]:
+        ordered = sorted(word, reverse=True)
+        rank = {label: index + 1 for index, label in enumerate(ordered)}
+        return tuple(rank[label] for label in word)
+
+    return convert(iper), convert(jper)
+
+
+def _check_nlc_two_open_lines_same_species(
+    n_ord: int,
+    iper: tuple[int, ...],
+    jper: tuple[int, ...],
+    ri: int,
+    rj: int,
+    ii: int,
+    jj: int,
+) -> int:
+    """Port of AmpliCol's same-species two-open-line NLC topology filter.
+
+    It returns 99 for LC-like entries, +/-1 for first subleading entries, and
+    0 for NNLC-or-beyond entries.  The final NLC coefficient is still the full
+    trace overlap; this function only decides whether that overlap belongs in
+    the NLC-expanded matrix.
+    """
+
+    m = max(n_ord - 4, 0)
+    if len(iper) != m or len(jper) != m:
+        return 0
+    if (ii, jj) in {(1, 2), (2, 1)}:
+        temp = (
+            iper[:ri]
+            + tuple(reversed(jper[rj:]))
+            + iper[ri:]
+            + tuple(reversed(jper[:rj]))
+        )
+        return -1 if _nlc_pairing_is_planar(temp, m) else 0
+    if (ii, jj) not in {(1, 1), (2, 2)}:
+        return 0
+    if ri == rj and iper == jper:
+        return 99
+
+    aa = iper[:ri]
+    bb = iper[ri:]
+    cc = jper[:rj]
+    dd = jper[rj:]
+    temp2 = aa + tuple(reversed(cc))
+    temp3 = bb + tuple(reversed(dd))
+    disjoint = not (set(temp2) & set(temp3))
+    if disjoint:
+        if aa and (bb == dd or not bb):
+            return _check_nlc_subword(cc, aa, threshold=m - 4)
+        if bb and (aa == cc or not aa):
+            return _check_nlc_subword(dd, bb, threshold=m - rj - 4)
+        return 0
+    return _check_nlc_two_open_lines_overlap(aa, bb, cc, dd, m, ri, rj)
+
+
+def _nlc_pairing_is_planar(word: tuple[int, ...], m: int) -> bool:
+    if m == 0:
+        return True
+    positions: dict[int, list[int]] = {label: [] for label in range(1, m + 1)}
+    for offset, label in enumerate(word):
+        if label in positions:
+            positions[label].append(offset)
+    if any(len(item) != 2 for item in positions.values()):
+        return False
+    for first, pair in positions.items():
+        if abs(pair[0] - pair[1]) % 2 != 1:
+            return False
+        for second in range(first + 1, m + 1):
+            if not _intervals_disjoint_or_nested(tuple(pair), tuple(positions[second])):
+                return False
+    return True
+
+
+def _intervals_disjoint_or_nested(
+    first: tuple[int, int],
+    second: tuple[int, int],
+) -> bool:
+    a1, a2 = first
+    b1, b2 = second
+    return (
+        (a1 < b1 and a2 < b1)
+        or (a1 > b2 and a2 > b2)
+        or (a1 > b1 and a2 < b2)
+        or (b1 > a1 and b2 < a2)
+    )
+
+
+def _check_nlc_subword(
+    candidate: tuple[int, ...],
+    target: tuple[int, ...],
+    *,
+    threshold: int,
+) -> int:
+    if candidate == target:
+        return 99
+    if not candidate or len(candidate) != len(target):
+        return 0
+    sign = _check_nlc(candidate, target)
+    if sign == 0:
+        return 0
+    if sign < 0:
+        return sign
+    return sign
+
+
+def _check_nlc_two_open_lines_overlap(
+    aa: tuple[int, ...],
+    bb: tuple[int, ...],
+    cc: tuple[int, ...],
+    dd: tuple[int, ...],
+    m: int,
+    ri: int,
+    rj: int,
+) -> int:
+    """Remaining overlapping-sets branch of the two-open-line NLC check."""
+
+    temp2 = aa + tuple(reversed(cc))
+    temp3 = bb + tuple(reversed(dd))
+    common = set(temp2) & set(temp3)
+    if not common:
+        return 0
+    skipped = None
+    ind_i = ind_j = -1
+    for i, label in enumerate(temp2):
+        if label not in common:
+            continue
+        ind_i = i
+        ind_j = temp3.index(label)
+        skipped = label
+        break
+    if skipped is None:
+        return 0
+    if len(temp2) == 1 or len(temp3) == 1:
+        return 0
+
+    perm: tuple[int, ...]
+    if ind_i < ri and ind_j >= len(bb):
+        # Common generator in the A-D pair.
+        perm = (
+            temp2[ind_i + 1 : ri]
+            + temp2[ri : ri + rj]
+            + temp2[:ind_i]
+            + temp3[ind_j + 1 :]
+            + temp3[: len(bb)]
+            + temp3[len(bb) : ind_j]
+        )
+        itemp4 = temp2[:ind_i] + temp2[ind_i + 1 : ri]
+        itemp5 = tuple(reversed(temp3[ind_j + 1 :])) + tuple(
+            reversed(temp3[len(bb) : ind_j])
+        )
+        if rj == ri - 1 and itemp4 == cc:
+            return 0
+        if rj + 1 == ri and itemp5 == bb:
+            return 0
+    elif ind_i >= ri and ind_j < len(bb):
+        # Common generator in the B-C pair.
+        perm = (
+            temp2[ind_i + 1 :]
+            + temp2[:ri]
+            + temp2[ri:ind_i]
+            + temp3[ind_j + 1 : len(bb)]
+            + temp3[len(bb) :]
+            + temp3[:ind_j]
+        )
+        itemp6 = tuple(reversed(temp2[ind_i + 1 :])) + tuple(reversed(temp2[ri:ind_i]))
+        itemp7 = temp3[:ind_j] + temp3[ind_j + 1 : len(bb)]
+        if rj - 1 == ri and itemp6 == aa:
+            return 0
+        if rj == ri + 1 and itemp7 == dd:
+            return 0
+    else:
+        return 0
+
+    positions: dict[int, list[int]] = {label: [] for label in range(1, m + 1)}
+    for offset, label in enumerate(perm):
+        if label == skipped:
+            continue
+        if label in positions:
+            positions[label].append(offset)
+    for label, pair in positions.items():
+        if label == skipped:
+            continue
+        if len(pair) != 2 or abs(pair[0] - pair[1]) % 2 != 1:
+            return 0
+    for first in range(1, m + 1):
+        if first == skipped:
+            continue
+        for second in range(first + 1, m + 1):
+            if second == skipped:
+                continue
+            if not _intervals_disjoint_or_nested(
+                tuple(positions[first]),
+                tuple(positions[second]),
+            ):
+                return 0
+    return 1
+
+
+def _has_repeated_fundamental_species(color_plan: GenericColorPlan) -> bool:
+    pdg_by_label: dict[int, int] = {
+        leg.label: abs(int(leg.outgoing_pdg))
+        for leg in color_plan.process.legs
+        if leg.outgoing_pdg is not None
+    }
+    fundamental_flavours = [
+        pdg_by_label[label]
+        for label in color_plan.process.fundamental_labels
+        if label in pdg_by_label
+    ]
+    return len(set(fundamental_flavours)) < len(fundamental_flavours)
+
+
+def _common_helicity_weight(
+    left: ColorGroupDescriptor,
+    right: ColorGroupDescriptor,
+) -> float:
+    if abs(left.helicity_weight - right.helicity_weight) > 1.0e-12:
+        raise ValueError(
+            "inconsistent helicity weights in color contraction group "
+            f"{left.helicity_key!r}: group {left.group_id} has "
+            f"{left.helicity_weight!r}, group {right.group_id} has "
+            f"{right.helicity_weight!r}"
+        )
+    return left.helicity_weight
diff --git a/pyamplicol/src/pyamplicol/color/contraction_trace.py b/pyamplicol/src/pyamplicol/color/contraction_trace.py
new file mode 100644
index 0000000000..e6771475d9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/contraction_trace.py
@@ -0,0 +1,435 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact trace and NLC algebra used by color contraction."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, Sequence
+from fractions import Fraction
+
+from .contraction_types import NC
+
+
+def _eval_trace(
+    traces: tuple[tuple[int, ...], ...],
+    *,
+    coeff: Fraction = Fraction(1),
+) -> float:
+    terms = _simplify_trace_terms(((coeff, traces),))
+    return _eval_nc_terms(terms)
+
+
+def _eval_trace_exact(
+    traces: tuple[tuple[int, ...], ...],
+    *,
+    coeff: Fraction = Fraction(1),
+) -> Fraction:
+    """Evaluate a trace product at ``Nc`` without passing through binary64."""
+
+    terms = _simplify_trace_terms(((coeff, traces),))
+    return _eval_nc_terms_exact(terms)
+
+
+def _simplify_trace_terms(
+    initial: Iterable[tuple[Fraction, tuple[tuple[int, ...], ...]]],
+) -> Mapping[int, Fraction]:
+    terms: list[tuple[Fraction, tuple[tuple[int, ...], ...]]] = [
+        (coeff, tuple(tuple(trace) for trace in traces))
+        for coeff, traces in initial
+        if coeff
+    ]
+    guard = 0
+    while True:
+        guard += 1
+        if guard > 100000:
+            raise RuntimeError("colour trace simplification did not converge")
+        terms = _simplify_tr1_tr0(terms)
+        if not terms:
+            return {}
+        if all(not traces for _coeff, traces in terms):
+            result: dict[int, Fraction] = {}
+            for coeff, _traces in terms:
+                result[0] = result.get(0, Fraction(0)) + coeff
+            return result
+        next_terms, changed = _trace_pair_simplify(terms)
+        terms = _simplify_tr1_tr0(next_terms)
+        next_terms, changed_dup = _trace_duplicate_simplify(terms)
+        terms = next_terms
+        if not changed and not changed_dup and any(traces for _coeff, traces in terms):
+            raise RuntimeError(f"cannot simplify colour traces: {terms[:3]}")
+
+
+def _simplify_trace_terms_nc_power(
+    initial: Iterable[tuple[Fraction, int, tuple[tuple[int, ...], ...]]],
+) -> Mapping[int, Fraction]:
+    terms: list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]] = [
+        (coeff, power, tuple(tuple(trace) for trace in traces))
+        for coeff, power, traces in initial
+        if coeff
+    ]
+    guard = 0
+    while True:
+        guard += 1
+        if guard > 100000:
+            raise RuntimeError("colour trace simplification did not converge")
+        terms = _simplify_tr1_tr0_nc_power(terms)
+        if not terms:
+            return {}
+        if all(not traces for _coeff, _power, traces in terms):
+            result: dict[int, Fraction] = {}
+            for coeff, power, _traces in terms:
+                result[power] = result.get(power, Fraction(0)) + coeff
+            return {power: coeff for power, coeff in result.items() if coeff}
+        next_terms, changed = _trace_pair_simplify_nc_power(terms)
+        terms = _simplify_tr1_tr0_nc_power(next_terms)
+        next_terms, changed_dup = _trace_duplicate_simplify_nc_power(terms)
+        terms = _combine_nc_power_terms(next_terms)
+        if (
+            not changed
+            and not changed_dup
+            and any(traces for _coeff, _power, traces in terms)
+        ):
+            raise RuntimeError(f"cannot simplify colour traces: {terms[:3]}")
+
+
+def _simplify_tr1_tr0_nc_power(
+    terms: list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]],
+) -> list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]]:
+    result: list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]] = []
+    for coeff, power, traces in terms:
+        if any(len(trace) == 1 for trace in traces):
+            continue
+        extra_power = sum(1 for trace in traces if len(trace) == 0)
+        remaining = tuple(trace for trace in traces if len(trace) != 0)
+        result.append((coeff, power + extra_power, remaining))
+    return _combine_nc_power_terms(result)
+
+
+def _trace_pair_simplify_nc_power(
+    terms: list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]],
+) -> tuple[list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]], bool]:
+    result: list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]] = []
+    changed = False
+    for coeff, power, traces in terms:
+        replaced = False
+        for first_index, first in enumerate(traces):
+            for second_index in range(first_index + 1, len(traces)):
+                second = traces[second_index]
+                found = _first_common_position(first, second)
+                if found is None:
+                    continue
+                first_pos, second_pos = found
+                combined = (
+                    first[:first_pos]
+                    + second[second_pos + 1 :]
+                    + second[:second_pos]
+                    + first[first_pos + 1 :]
+                )
+                rest = tuple(
+                    trace
+                    for index, trace in enumerate(traces)
+                    if index not in {first_index, second_index}
+                )
+                result.append((coeff, power, (combined, *rest)))
+                reduced_first = first[:first_pos] + first[first_pos + 1 :]
+                reduced_second = second[:second_pos] + second[second_pos + 1 :]
+                result.append(
+                    (
+                        -coeff,
+                        power - 1,
+                        tuple(
+                            trace
+                            if index not in {first_index, second_index}
+                            else (
+                                reduced_first
+                                if index == first_index
+                                else reduced_second
+                            )
+                            for index, trace in enumerate(traces)
+                        ),
+                    )
+                )
+                changed = True
+                replaced = True
+                break
+            if replaced:
+                break
+        if not replaced:
+            result.append((coeff, power, traces))
+    return result, changed
+
+
+def _trace_duplicate_simplify_nc_power(
+    terms: list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]],
+) -> tuple[list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]], bool]:
+    result: list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]] = []
+    changed = False
+    for coeff, power, traces in terms:
+        replaced = False
+        for trace_index, trace in enumerate(traces):
+            positions = _first_duplicate_positions(trace)
+            if positions is None:
+                continue
+            first_pos, second_pos = positions
+            a = trace[:first_pos]
+            b = trace[first_pos + 1 : second_pos]
+            c = trace[second_pos + 1 :]
+            rest = tuple(
+                item for index, item in enumerate(traces) if index != trace_index
+            )
+            result.append((coeff, power, (a + c, b, *rest)))
+            result.append((-coeff, power - 1, (a + b + c, *rest)))
+            changed = True
+            replaced = True
+            break
+        if not replaced:
+            result.append((coeff, power, traces))
+    return result, changed
+
+
+def _combine_nc_power_terms(
+    terms: Iterable[tuple[Fraction, int, tuple[tuple[int, ...], ...]]],
+) -> list[tuple[Fraction, int, tuple[tuple[int, ...], ...]]]:
+    combined: dict[tuple[int, tuple[tuple[int, ...], ...]], Fraction] = {}
+    for coeff, power, traces in terms:
+        if not coeff:
+            continue
+        key = (power, tuple(sorted(tuple(trace) for trace in traces)))
+        combined[key] = combined.get(key, Fraction(0)) + coeff
+    return [
+        (coeff, power, traces) for (power, traces), coeff in combined.items() if coeff
+    ]
+
+
+def _simplify_tr1_tr0(
+    terms: list[tuple[Fraction, tuple[tuple[int, ...], ...]]],
+) -> list[tuple[Fraction, tuple[tuple[int, ...], ...]]]:
+    result: list[tuple[Fraction, tuple[tuple[int, ...], ...]]] = []
+    for coeff, traces in terms:
+        if any(len(trace) == 1 for trace in traces):
+            continue
+        power = sum(1 for trace in traces if len(trace) == 0)
+        remaining = tuple(trace for trace in traces if len(trace) != 0)
+        result.append((coeff * (NC**power), remaining))
+    return [(coeff, traces) for coeff, traces in result if coeff]
+
+
+def _trace_pair_simplify(
+    terms: list[tuple[Fraction, tuple[tuple[int, ...], ...]]],
+) -> tuple[list[tuple[Fraction, tuple[tuple[int, ...], ...]]], bool]:
+    result: list[tuple[Fraction, tuple[tuple[int, ...], ...]]] = []
+    changed = False
+    for coeff, traces in terms:
+        replaced = False
+        for first_index, first in enumerate(traces):
+            for second_index in range(first_index + 1, len(traces)):
+                second = traces[second_index]
+                found = _first_common_position(first, second)
+                if found is None:
+                    continue
+                first_pos, second_pos = found
+                combined = (
+                    first[:first_pos]
+                    + second[second_pos + 1 :]
+                    + second[:second_pos]
+                    + first[first_pos + 1 :]
+                )
+                rest = tuple(
+                    trace
+                    for index, trace in enumerate(traces)
+                    if index not in {first_index, second_index}
+                )
+                result.append((coeff, (combined, *rest)))
+                reduced_first = first[:first_pos] + first[first_pos + 1 :]
+                reduced_second = second[:second_pos] + second[second_pos + 1 :]
+                result.append(
+                    (
+                        -coeff / NC,
+                        tuple(
+                            trace
+                            if index not in {first_index, second_index}
+                            else (
+                                reduced_first
+                                if index == first_index
+                                else reduced_second
+                            )
+                            for index, trace in enumerate(traces)
+                        ),
+                    )
+                )
+                changed = True
+                replaced = True
+                break
+            if replaced:
+                break
+        if not replaced:
+            result.append((coeff, traces))
+    return result, changed
+
+
+def _trace_duplicate_simplify(
+    terms: list[tuple[Fraction, tuple[tuple[int, ...], ...]]],
+) -> tuple[list[tuple[Fraction, tuple[tuple[int, ...], ...]]], bool]:
+    result: list[tuple[Fraction, tuple[tuple[int, ...], ...]]] = []
+    changed = False
+    for coeff, traces in terms:
+        replaced = False
+        for trace_index, trace in enumerate(traces):
+            positions = _first_duplicate_positions(trace)
+            if positions is None:
+                continue
+            first_pos, second_pos = positions
+            a = trace[:first_pos]
+            b = trace[first_pos + 1 : second_pos]
+            c = trace[second_pos + 1 :]
+            rest = tuple(
+                item for index, item in enumerate(traces) if index != trace_index
+            )
+            result.append((coeff, (a + c, b, *rest)))
+            result.append((-coeff / NC, (a + b + c, *rest)))
+            changed = True
+            replaced = True
+            break
+        if not replaced:
+            result.append((coeff, traces))
+    return result, changed
+
+
+def _first_common_position(
+    left: Sequence[int],
+    right: Sequence[int],
+) -> tuple[int, int] | None:
+    for left_index, label in enumerate(left):
+        for right_index, other in enumerate(right):
+            if label == other:
+                return left_index, right_index
+    return None
+
+
+def _first_duplicate_positions(trace: Sequence[int]) -> tuple[int, int] | None:
+    seen: dict[int, int] = {}
+    for index, label in enumerate(trace):
+        if label in seen:
+            return seen[label], index
+        seen[label] = index
+    return None
+
+
+def _eval_nc_terms(
+    terms: Mapping[int, Fraction],
+    *,
+    min_power: int | None = None,
+) -> float:
+    value = 0.0
+    for power, coeff in terms.items():
+        if min_power is not None and power < min_power:
+            continue
+        value += float(coeff) * (float(NC) ** power)
+    return value
+
+
+def _eval_nc_terms_exact(
+    terms: Mapping[int, Fraction],
+    *,
+    min_power: int | None = None,
+) -> Fraction:
+    """Evaluate an exact Laurent polynomial in ``Nc`` as a ``Fraction``."""
+
+    value = Fraction(0)
+    nc = Fraction(NC)
+    for power, coeff in terms.items():
+        if min_power is not None and power < min_power:
+            continue
+        value += coeff * nc**power
+    return value
+
+
+def _check_nlc(jper: tuple[int, ...], iper: tuple[int, ...]) -> int:
+    n = len(iper)
+    if n == 0:
+        return 99
+    i1 = next((i for i in range(n) if jper[i] != iper[i]), n)
+    if i1 == n:
+        return 99
+    try:
+        i2 = next(i for i in range(i1 + 1, n) if jper[i] == iper[i1])
+    except StopIteration:
+        return 0
+    offset = 0
+    while (
+        i2 + offset < n and i1 + offset < n and jper[i2 + offset] == iper[i1 + offset]
+    ):
+        offset += 1
+    i3 = i2 + offset - 1
+    i4 = i1 + offset - 1
+    if i4 + 1 >= n:
+        return 0
+    try:
+        i5 = next(i for i in range(i1, n) if jper[i] == iper[i4 + 1])
+    except StopIteration:
+        return 0
+    if i5 > i3:
+        return 0
+    sign = 1
+    if i1 > i5 - 1:
+        left_len = i4 - i1
+        right_len = i2 - 1 - i5
+        if (left_len == 0 and right_len == 0) or (
+            n > 0
+            and (
+                (left_len == 0 and right_len == n - 3)
+                or (left_len == n - 3 and right_len == 0)
+            )
+        ):
+            sign = -1
+        elif left_len == 0 or right_len == 0:
+            return 0
+        elif left_len + right_len <= max(n - 4, 0):
+            pass
+        else:
+            return 0
+    itemp = jper[:i1] + jper[i2 : i3 + 1] + jper[i5:i2] + jper[i1:i5] + jper[i3 + 1 :]
+    return sign if itemp == iper else 0
+
+
+def _check_nlc_one_open_line(jper: tuple[int, ...], iper: tuple[int, ...]) -> int:
+    """Port AmpliCol's one-open-line NLC topology check."""
+
+    n = len(iper)
+    if len(jper) != n:
+        return 0
+    i1 = next((i for i in range(n) if jper[i] != iper[i]), n)
+    if i1 >= n:
+        return 99
+    try:
+        i2 = next(i for i in range(i1 + 1, n) if jper[i] == iper[i1])
+    except StopIteration:
+        return 0
+    offset = 0
+    while (
+        i2 + offset < n and i1 + offset < n and jper[i2 + offset] == iper[i1 + offset]
+    ):
+        offset += 1
+    i3 = i2 + offset - 1
+    i4 = i1 + offset - 1
+    if i4 + 1 >= n:
+        return 0
+    try:
+        i5 = next(i for i in range(i1, n) if jper[i] == iper[i4 + 1])
+    except StopIteration:
+        return 0
+    if i5 > i3:
+        return 0
+    sign = 1
+    if i1 > i5 - 1:
+        left_len = i4 - i1
+        right_len = i2 - 1 - i5
+        if left_len == 0 and right_len == 0:
+            sign = -1
+        elif left_len == 0 or right_len == 0:
+            return 0
+        elif left_len + right_len <= n - 4:
+            pass
+        else:
+            sign = 1
+    itemp = jper[:i1] + jper[i2 : i3 + 1] + jper[i5:i2] + jper[i1:i5] + jper[i3 + 1 :]
+    return sign if itemp == iper else 0
diff --git a/pyamplicol/src/pyamplicol/color/contraction_types.py b/pyamplicol/src/pyamplicol/color/contraction_types.py
new file mode 100644
index 0000000000..9305feda02
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/contraction_types.py
@@ -0,0 +1,575 @@
+# SPDX-License-Identifier: 0BSD
+"""Frozen color-contraction records."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Iterator
+from dataclasses import dataclass
+from fractions import Fraction
+
+NC = 3
+
+
+@dataclass(frozen=True)
+class ColorContractionEntry:
+    left_group_id: int
+    right_group_id: int
+    weight_re: float
+    weight_im: float = 0.0
+    symmetry_factor: float = 1.0
+    exact_weight: tuple[Fraction, Fraction] | None = None
+
+    def to_json_dict(self) -> dict[str, object]:
+        result = {
+            "left_group_id": self.left_group_id,
+            "right_group_id": self.right_group_id,
+            "weight": [self.weight_re, self.weight_im],
+            "symmetry_factor": self.symmetry_factor,
+        }
+        if self.exact_weight is not None:
+            result["exact_weight"] = _exact_weight_payload(self.exact_weight)
+        return result
+
+
+@dataclass(frozen=True)
+class ColorContractionTemplateEntry:
+    left_group_index: int
+    right_group_index: int
+    weight_re: float
+    weight_im: float = 0.0
+    symmetry_factor: float = 1.0
+    exact_weight: tuple[Fraction, Fraction] | None = None
+
+    def to_json_dict(self) -> dict[str, object]:
+        result = {
+            "left_group_index": self.left_group_index,
+            "right_group_index": self.right_group_index,
+            "weight": [self.weight_re, self.weight_im],
+            "symmetry_factor": self.symmetry_factor,
+        }
+        if self.exact_weight is not None:
+            result["exact_weight"] = _exact_weight_payload(self.exact_weight)
+        return result
+
+
+def _exact_weight_payload(weight: tuple[Fraction, Fraction]) -> list[str]:
+    # Strings keep arbitrarily large integers exact in every JSON consumer.
+    return [
+        str(part) for value in weight for part in (value.numerator, value.denominator)
+    ]
+
+
+@dataclass(frozen=True)
+class FactorizedColorContractionBlock:
+    """A compact transform plan for one repeated color matrix.
+
+    ``klein-four-walsh`` records a free action of a Klein-four subgroup.  Each
+    coset is ordered as identity, first generator, second generator, and their
+    product.  The runtime validates the matrix invariance before using the
+    corresponding four-point Walsh transform.
+
+    ``elementary-abelian-walsh`` generalizes the same representation to a
+    free ``C2**rank`` action.  Each coset is ordered by generator bitmask, so
+    group multiplication is bitwise XOR.
+    """
+
+    kind: str
+    cosets: tuple[tuple[int, ...], ...]
+    rank: int | None = None
+
+    def __post_init__(self) -> None:
+        if not self.cosets:
+            raise ValueError("factorized color contraction coset map is empty")
+        if self.kind == "klein-four-walsh":
+            if self.rank is not None:
+                raise ValueError("Klein-four color factorization cannot declare rank")
+            expected_coset_size = 4
+        elif self.kind == "elementary-abelian-walsh":
+            if self.rank is None or self.rank < 3:
+                raise ValueError(
+                    "elementary-Abelian color factorization requires rank >= 3"
+                )
+            expected_coset_size = len(self.cosets[0])
+            if (
+                expected_coset_size & (expected_coset_size - 1)
+                or expected_coset_size.bit_length() - 1 != self.rank
+            ):
+                raise ValueError(
+                    "elementary-Abelian color factorization rank is inconsistent"
+                )
+        else:
+            raise ValueError(f"unknown color contraction factorization {self.kind!r}")
+        if any(len(coset) != expected_coset_size for coset in self.cosets):
+            raise ValueError(
+                "factorized color contraction coset size does not match its rank"
+            )
+        flattened = tuple(index for coset in self.cosets for index in coset)
+        if any(index < 0 for index in flattened):
+            raise ValueError(
+                "factorized color contraction coset map has a negative index"
+            )
+        if len(set(flattened)) != len(flattened):
+            raise ValueError(
+                "factorized color contraction coset map contains duplicate indices"
+            )
+
+    def to_json_dict(self) -> dict[str, object]:
+        cosets = [list(coset) for coset in self.cosets]
+        if self.rank is None:
+            return {"kind": self.kind, "cosets": cosets}
+        return {"kind": self.kind, "rank": self.rank, "cosets": cosets}
+
+
+@dataclass(frozen=True)
+class RepeatedColorContractionBlock:
+    component_count: int
+    component_group_ids: tuple[int, ...]
+    entries: tuple[ColorContractionTemplateEntry, ...]
+    factorized_block: FactorizedColorContractionBlock | None = None
+
+    def __post_init__(self) -> None:
+        if self.component_count < 2:
+            raise ValueError(
+                "repeated color contraction requires at least two components"
+            )
+        if not self.component_group_ids:
+            raise ValueError("repeated color contraction group map is empty")
+        if len(self.component_group_ids) % self.component_count != 0:
+            raise ValueError(
+                "repeated color contraction group IDs do not form a rectangular map"
+            )
+        if len(set(self.component_group_ids)) != len(self.component_group_ids):
+            raise ValueError("repeated color contraction group IDs are not unique")
+        local_group_count = self.local_group_count
+        if any(
+            entry.left_group_index < 0
+            or entry.left_group_index >= local_group_count
+            or entry.right_group_index < 0
+            or entry.right_group_index >= local_group_count
+            for entry in self.entries
+        ):
+            raise ValueError(
+                "repeated color contraction entry references an unknown local group"
+            )
+        if self.factorized_block is not None:
+            flattened = tuple(
+                index for coset in self.factorized_block.cosets for index in coset
+            )
+            if sorted(flattened) != list(range(local_group_count)):
+                raise ValueError(
+                    "factorized color contraction cosets do not partition local groups"
+                )
+
+    @property
+    def local_group_count(self) -> int:
+        return len(self.component_group_ids) // self.component_count
+
+    def to_json_dict(self) -> dict[str, object]:
+        result: dict[str, object] = {
+            "component_count": self.component_count,
+            "component_group_ids": list(self.component_group_ids),
+            "entries": [entry.to_json_dict() for entry in self.entries],
+        }
+        if self.factorized_block is not None:
+            result["factorized_block"] = self.factorized_block.to_json_dict()
+        return result
+
+
+@dataclass(frozen=True)
+class SymmetricGroupColorContractionBlock:
+    """Certified regular symmetric-group orbits plus exact residual metric.
+
+    Local groups are ordered channel-major and permutation-major.  Every
+    channel coset contains the lexicographic permutations of ``range(degree)``
+    with the identity at offset zero.  Groups outside certified ``S_degree``
+    orbits form one consecutive residual suffix.  ``kernel_entries`` stores
+    exactly one complete relative-permutation row for every upper-triangular
+    channel pair; it is not an expanded color matrix.
+
+    The component map follows the existing local-group-major/component-minor
+    convention.  Exact weights are parallel to their binary64 template entries
+    and exclude the entry's upper-triangle symmetry factor.
+    """
+
+    degree: int
+    component_count: int
+    component_group_ids: tuple[int, ...]
+    local_sector_ids: tuple[int, ...]
+    channel_cosets: tuple[tuple[int, ...], ...]
+    kernel_entries: tuple[ColorContractionTemplateEntry, ...]
+    kernel_exact_weights: tuple[Fraction, ...]
+    residual_entries: tuple[ColorContractionTemplateEntry, ...]
+    residual_exact_weights: tuple[Fraction, ...]
+    residual_local_group_indices: tuple[int, ...]
+    hermiticity_check_mode: str = "vacuous"
+    hermiticity_relative_indices: tuple[int, ...] = ()
+
+    def __post_init__(self) -> None:
+        if isinstance(self.degree, bool) or not isinstance(self.degree, int):
+            raise ValueError("symmetric-group degree must be an integer")
+        if self.degree < 2:
+            raise ValueError("symmetric-group degree must be at least two")
+        if self.degree > 10:
+            raise ValueError("symmetric-group degree exceeds the supported maximum 10")
+        if self.component_count < 1:
+            raise ValueError("symmetric-group color contraction requires a component")
+        if not self.component_group_ids:
+            raise ValueError("symmetric-group component group map is empty")
+        if len(self.component_group_ids) % self.component_count:
+            raise ValueError(
+                "symmetric-group component group IDs do not form a rectangular map"
+            )
+        if len(set(self.component_group_ids)) != len(self.component_group_ids):
+            raise ValueError("symmetric-group component group IDs contain duplicates")
+        if any(group_id < 0 for group_id in self.component_group_ids):
+            raise ValueError(
+                "symmetric-group component group IDs contain a negative ID"
+            )
+
+        local_group_count = self.local_group_count
+        if len(self.local_sector_ids) != local_group_count:
+            raise ValueError(
+                "symmetric-group local sector map does not match local groups"
+            )
+        if len(set(self.local_sector_ids)) != len(self.local_sector_ids) or any(
+            sector_id < 0 for sector_id in self.local_sector_ids
+        ):
+            raise ValueError(
+                "symmetric-group local sector map must contain unique nonnegative IDs"
+            )
+        group_order = math.factorial(self.degree)
+        if not self.channel_cosets:
+            raise ValueError("symmetric-group color contraction has no channels")
+        eligible_group_count = len(self.channel_cosets) * group_order
+        if eligible_group_count > local_group_count:
+            raise ValueError(
+                "symmetric-group channel cosets exceed the local group domain"
+            )
+        for channel_index, coset in enumerate(self.channel_cosets):
+            start = channel_index * group_order
+            if coset != tuple(range(start, start + group_order)):
+                raise ValueError(
+                    "symmetric-group channel cosets must be consecutive and "
+                    "channel-major"
+                )
+        expected_residual = tuple(range(eligible_group_count, local_group_count))
+        if self.residual_local_group_indices != expected_residual:
+            raise ValueError(
+                "symmetric-group residual groups must be the consecutive "
+                "complement after channel cosets"
+            )
+
+        expected_kernel_count = (
+            len(self.channel_cosets) * (len(self.channel_cosets) + 1) // 2 * group_order
+        )
+        if len(self.kernel_entries) != expected_kernel_count:
+            raise ValueError(
+                "symmetric-group kernel rows do not cover every channel pair"
+            )
+        if len(self.kernel_exact_weights) != len(self.kernel_entries):
+            raise ValueError(
+                "symmetric-group exact kernel weights do not match kernel entries"
+            )
+        kernel_offset = 0
+        for left_channel, left_coset in enumerate(self.channel_cosets):
+            for right_channel in range(left_channel, len(self.channel_cosets)):
+                right_coset = self.channel_cosets[right_channel]
+                expected_symmetry = 1.0 if left_channel == right_channel else 2.0
+                for relative_index in range(group_order):
+                    entry = self.kernel_entries[kernel_offset]
+                    if (
+                        entry.left_group_index != left_coset[0]
+                        or entry.right_group_index != right_coset[relative_index]
+                        or entry.symmetry_factor != expected_symmetry
+                    ):
+                        raise ValueError(
+                            "symmetric-group kernel rows are not in canonical "
+                            "channel/relative-permutation order"
+                        )
+                    kernel_offset += 1
+        self._validate_exact_entries(
+            self.kernel_entries,
+            self.kernel_exact_weights,
+            local_group_count=local_group_count,
+            label="kernel",
+        )
+
+        if len(self.residual_exact_weights) != len(self.residual_entries):
+            raise ValueError(
+                "symmetric-group exact residual weights do not match residual entries"
+            )
+        expected_residual_pairs = (
+            tuple(
+                (left_index, right_index)
+                for left_index in range(local_group_count)
+                for right_index in range(left_index, local_group_count)
+                if right_index >= eligible_group_count
+            )
+            if self.residual_local_group_indices
+            else ()
+        )
+        residual_pairs = tuple(
+            (entry.left_group_index, entry.right_group_index)
+            for entry in self.residual_entries
+        )
+        if residual_pairs != expected_residual_pairs:
+            raise ValueError(
+                "symmetric-group residual rows must exhaust every canonical pair "
+                "touching the residual suffix"
+            )
+        for entry in self.residual_entries:
+            pair = (entry.left_group_index, entry.right_group_index)
+            expected_symmetry = 1.0 if pair[0] == pair[1] else 2.0
+            if entry.symmetry_factor != expected_symmetry:
+                raise ValueError(
+                    "symmetric-group residual entry has an invalid symmetry factor"
+                )
+        self._validate_exact_entries(
+            self.residual_entries,
+            self.residual_exact_weights,
+            local_group_count=local_group_count,
+            label="residual",
+        )
+
+        cross_channel_count = self.channel_count * (self.channel_count - 1) // 2
+        if cross_channel_count == 0:
+            if (
+                self.hermiticity_check_mode != "vacuous"
+                or self.hermiticity_relative_indices
+            ):
+                raise ValueError(
+                    "single-channel symmetric-group Hermiticity provenance must "
+                    "be vacuous"
+                )
+        elif self.degree <= 4:
+            if (
+                self.hermiticity_check_mode != "full"
+                or self.hermiticity_relative_indices != tuple(range(group_order))
+            ):
+                raise ValueError(
+                    "small symmetric-group cross-channel kernels require a full "
+                    "Hermiticity certificate"
+                )
+        elif (
+            self.hermiticity_check_mode != "deterministic-samples"
+            or not self.hermiticity_relative_indices
+            or self.hermiticity_relative_indices[0] != 0
+            or len(set(self.hermiticity_relative_indices))
+            != len(self.hermiticity_relative_indices)
+            or any(
+                index < 0 or index >= group_order
+                for index in self.hermiticity_relative_indices
+            )
+        ):
+            raise ValueError(
+                "large symmetric-group cross-channel kernels require canonical "
+                "sampled Hermiticity provenance"
+            )
+
+    @staticmethod
+    def _validate_exact_entries(
+        entries: tuple[ColorContractionTemplateEntry, ...],
+        exact_weights: tuple[Fraction, ...],
+        *,
+        local_group_count: int,
+        label: str,
+    ) -> None:
+        for index, (entry, exact) in enumerate(
+            zip(entries, exact_weights, strict=True)
+        ):
+            if not isinstance(exact, Fraction):
+                raise ValueError(
+                    f"symmetric-group {label} exact weight {index} is not a Fraction"
+                )
+            if (
+                entry.left_group_index < 0
+                or entry.left_group_index >= local_group_count
+                or entry.right_group_index < 0
+                or entry.right_group_index >= local_group_count
+            ):
+                raise ValueError(
+                    f"symmetric-group {label} entry references an unknown local group"
+                )
+            if entry.weight_im != 0.0:
+                raise ValueError(
+                    f"symmetric-group {label} entry has a complex color weight"
+                )
+            if not math.isfinite(entry.weight_re) or float(exact) != entry.weight_re:
+                raise ValueError(
+                    f"symmetric-group {label} binary64 and exact weights disagree"
+                )
+
+    @property
+    def local_group_count(self) -> int:
+        return len(self.component_group_ids) // self.component_count
+
+    @property
+    def group_order(self) -> int:
+        return math.factorial(self.degree)
+
+    @property
+    def channel_count(self) -> int:
+        return len(self.channel_cosets)
+
+    @property
+    def stored_entry_count(self) -> int:
+        return len(self.kernel_entries) + len(self.residual_entries)
+
+    @property
+    def hermiticity_check_count(self) -> int:
+        return (
+            self.channel_count
+            * (self.channel_count - 1)
+            // 2
+            * len(self.hermiticity_relative_indices)
+        )
+
+    def to_json_dict(self) -> dict[str, object]:
+        def exact_payload(value: Fraction) -> list[int]:
+            return [value.numerator, value.denominator]
+
+        return {
+            "kind": "symmetric-group-fourier",
+            "degree": self.degree,
+            "component_count": self.component_count,
+            "component_group_ids": list(self.component_group_ids),
+            "local_sector_ids": list(self.local_sector_ids),
+            "channel_cosets": [list(coset) for coset in self.channel_cosets],
+            "kernel_entries": [entry.to_json_dict() for entry in self.kernel_entries],
+            "kernel_exact_weights": [
+                exact_payload(value) for value in self.kernel_exact_weights
+            ],
+            "residual_entries": [
+                entry.to_json_dict() for entry in self.residual_entries
+            ],
+            "residual_exact_weights": [
+                exact_payload(value) for value in self.residual_exact_weights
+            ],
+            "residual_local_group_indices": list(self.residual_local_group_indices),
+            "hermiticity_certificate": {
+                "mode": self.hermiticity_check_mode,
+                "relative_indices": list(self.hermiticity_relative_indices),
+                "check_count": self.hermiticity_check_count,
+            },
+        }
+
+
+@dataclass(frozen=True)
+class ColorContractionPlan:
+    color_accuracy: str
+    supported: bool
+    reason: str | None
+    group_count: int
+    entries: tuple[ColorContractionEntry, ...]
+    repeated_block: RepeatedColorContractionBlock | None = None
+    symmetric_group_block: SymmetricGroupColorContractionBlock | None = None
+    destination_by_group: tuple[int, ...] | None = None
+    includes_color_factor: bool = True
+
+    def __post_init__(self) -> None:
+        storage_count = sum(
+            (
+                bool(self.entries),
+                self.repeated_block is not None,
+                self.symmetric_group_block is not None,
+            )
+        )
+        if storage_count > 1:
+            raise ValueError(
+                "color contraction cannot mix expanded, repeated, and "
+                "symmetric-group storage"
+            )
+        if (
+            self.repeated_block is not None
+            and len(self.repeated_block.component_group_ids) != self.group_count
+        ):
+            raise ValueError(
+                "repeated color contraction group map does not match group count"
+            )
+        if (
+            self.symmetric_group_block is not None
+            and len(self.symmetric_group_block.component_group_ids) != self.group_count
+        ):
+            raise ValueError(
+                "symmetric-group color contraction group map does not match group count"
+            )
+        if self.destination_by_group is not None:
+            if len(self.destination_by_group) != self.group_count:
+                raise ValueError(
+                    "color contraction destination projection does not match "
+                    "group count"
+                )
+            if len(set(self.destination_by_group)) != len(
+                self.destination_by_group
+            ) or any(value < 0 for value in self.destination_by_group):
+                raise ValueError(
+                    "color contraction destination projection must contain "
+                    "unique nonnegative IDs"
+                )
+
+    @property
+    def logical_entry_count(self) -> int:
+        if self.repeated_block is None:
+            if self.symmetric_group_block is None:
+                return len(self.entries)
+            return (
+                self.symmetric_group_block.component_count
+                * self.symmetric_group_block.stored_entry_count
+            )
+        return self.repeated_block.component_count * len(self.repeated_block.entries)
+
+    def iter_logical_entries(self) -> Iterator[ColorContractionEntry]:
+        if self.symmetric_group_block is not None:
+            raise ValueError(
+                "symmetric-group kernel rows are not an expanded color matrix"
+            )
+        if self.repeated_block is None:
+            yield from self.entries
+            return
+        block = self.repeated_block
+        for component_index in range(block.component_count):
+            for entry in block.entries:
+                yield ColorContractionEntry(
+                    left_group_id=block.component_group_ids[
+                        entry.left_group_index * block.component_count + component_index
+                    ],
+                    right_group_id=block.component_group_ids[
+                        entry.right_group_index * block.component_count
+                        + component_index
+                    ],
+                    weight_re=entry.weight_re,
+                    weight_im=entry.weight_im,
+                    symmetry_factor=entry.symmetry_factor,
+                    exact_weight=entry.exact_weight,
+                )
+
+    def to_json_dict(self) -> dict[str, object]:
+        result: dict[str, object] = {
+            "kind": "pyamplicol-color-contraction-plan",
+            "color_accuracy": self.color_accuracy,
+            "supported": self.supported,
+            "reason": self.reason,
+            "group_count": self.group_count,
+            "includes_color_factor": self.includes_color_factor,
+            "entry_count": len(self.entries),
+            "logical_entry_count": self.logical_entry_count,
+            "storage": "upper-triangular sparse metric over coherent amplitude groups",
+            "entries": [entry.to_json_dict() for entry in self.entries],
+        }
+        if self.repeated_block is not None:
+            result["repeated_block"] = self.repeated_block.to_json_dict()
+        if self.symmetric_group_block is not None:
+            result["symmetric_group_block"] = self.symmetric_group_block.to_json_dict()
+        if self.destination_by_group is not None:
+            result["destination_by_group"] = list(self.destination_by_group)
+        return result
+
+
+@dataclass(frozen=True)
+class ColorGroupDescriptor:
+    group_id: int
+    helicity_key: tuple[object, ...]
+    sector_id: int
+    word: tuple[int, ...]
+    helicity_weight: float
diff --git a/pyamplicol/src/pyamplicol/color/correlator_matrices.py b/pyamplicol/src/pyamplicol/color/correlator_matrices.py
new file mode 100644
index 0000000000..762d4e32cd
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/correlator_matrices.py
@@ -0,0 +1,421 @@
+# SPDX-License-Identifier: 0BSD
+"""Direct exact connected matrices in the generated tree colour basis.
+
+The adapter adds the endpoint-pairing phase used by AmpliCol's ordinary metric
+to otherwise literal colour tensors. Every stored entry is directed and means
+``<bra-connected left sector | ket-connected right sector>``; no upper-triangle
+doubling or assumption of Hermiticity is implicit. Runtime contraction therefore
+uses ``conjugate(a[left]) * entry * a[right]``.
+
+Only complete full-colour trace/open-line amplitude plans are accepted, even
+for LC/NLC output. Adjoint DDM sectors retain single-trace ordering records for
+current construction, but these are not their literal colour tensors.
+The approximation acts on the inserted metric at fixed physical amplitudes;
+it is not a strict expansion of their hidden colour weights. The Born matrix
+uses the inherited ordinary factors. The ordinary matrix's zero pattern
+is deliberately not consulted: a connection can turn a zero overlap into a
+nonzero one. Planning is direct and quadratic in the selected basis size, with
+each connected tensor reused across all requested matrix entries.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+
+from ..processes.ir import CanonicalProcessIR
+from .connections import (
+    COLOR_CONNECTION_CONVENTION,
+    ColorConnection,
+    ColorEmission,
+    ColorLeg,
+    ColorTensor,
+    ConnectedColorTensor,
+    EmitGluon,
+    ExactColorCoefficient,
+    OpenColorString,
+    SplitGluon,
+    TensorTerm,
+    _validate_tensor_legs,
+    apply_color_connection,
+    contract_connected_tensor_nc_terms,
+    evaluate_color_nc_terms,
+)
+from .contraction_factors import exact_color_contraction_factor
+from .plan_types import ColorAccuracy, GenericColorPlan, LCColorSector
+
+_COLOR_ROLE_REPRESENTATIONS = {
+    "singlet": 1,
+    "fundamental": 3,
+    "antifundamental": -3,
+    "adjoint": 8,
+}
+
+
+def _emission_json(emission: ColorEmission) -> dict[str, object]:
+    if isinstance(emission, EmitGluon):
+        return {
+            "kind": "emit-gluon",
+            "emitter": emission.emitter_label,
+            "emitted": emission.emitted_label,
+        }
+    return {
+        "kind": "split-gluon",
+        "parent": emission.parent_label,
+        "quark": emission.quark_label,
+        "antiquark": emission.antiquark_label,
+    }
+
+
+@dataclass(frozen=True)
+class ColorCorrelator:
+    """A named pair of ordered colour connections on the same Born amplitude.
+
+    Labels refer to canonical external process labels (positive integers).
+    Fresh negative labels are convenient for auxiliary emitted particles. The
+    bra and ket must finish with identical labelled colour representations.
+    """
+
+    id: str
+    bra: tuple[ColorEmission, ...] = ()
+    ket: tuple[ColorEmission, ...] = ()
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.id, str) or not self.id.strip():
+            raise ValueError("colour correlator ID must be a nonempty string")
+        object.__setattr__(self, "bra", tuple(self.bra))
+        object.__setattr__(self, "ket", tuple(self.ket))
+        if len(self.bra) != len(self.ket):
+            raise ValueError("bra and ket must have the same number of emissions")
+        if any(
+            not isinstance(op, (EmitGluon, SplitGluon)) for op in (*self.bra, *self.ket)
+        ):
+            raise TypeError(
+                "colour correlator operations must be typed emission records"
+            )
+
+    @property
+    def order(self) -> int:
+        return len(self.bra)
+
+    @classmethod
+    def dipole(cls, id: str, left_leg: int, right_leg: int) -> ColorCorrelator:
+        """Request ``<M|T_left . T_right|M>`` using auxiliary gluon label -1."""
+
+        return cls(id, (EmitGluon(left_leg, -1),), (EmitGluon(right_leg, -1),))
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "bra": [_emission_json(op) for op in self.bra],
+            "ket": [_emission_json(op) for op in self.ket],
+        }
+
+
+def process_color_legs(process: CanonicalProcessIR) -> tuple[ColorLeg, ...]:
+    """Read all-outgoing roles from process IR; do not cross them a second time."""
+
+    if not isinstance(process, CanonicalProcessIR):
+        raise TypeError("colour correlators require a CanonicalProcessIR")
+    legs = []
+    for leg in process.legs:
+        if type(leg.label) is not int or leg.label <= 0:
+            raise ValueError(
+                "canonical external colour labels must be positive integers"
+            )
+        try:
+            representation = _COLOR_ROLE_REPRESENTATIONS[leg.color_role]
+        except KeyError as exc:
+            raise ValueError(
+                "colour correlators require concrete resolved colour roles"
+            ) from exc
+        legs.append(ColorLeg(leg.label, representation))
+    return ColorConnection(tuple(legs)).initial_legs
+
+
+def _sector_color_tensor(
+    sector: LCColorSector, legs: tuple[ColorLeg, ...]
+) -> TensorTerm:
+    if not isinstance(sector, LCColorSector):
+        raise TypeError("colour correlator sectors must be LCColorSector records")
+    if sector.kind == "open-lines":
+        strings = tuple(
+            OpenColorString(
+                line.fundamental_label, line.adjoint_labels, line.antifundamental_label
+            )
+            for line in sector.open_color_lines
+        )
+        tensor = ColorTensor(strings)
+        # sign(pairing_left) * sign(pairing_right) is exactly the permutation
+        # parity (-1)^(line_count - alternating_cycle_count) in the legacy metric.
+        paired_antiquarks = tuple(
+            string.antifundamental_label
+            for string in sorted(strings, key=lambda item: item.fundamental_label)
+        )
+        inversions = sum(
+            first > second
+            for index, first in enumerate(paired_antiquarks)
+            for second in paired_antiquarks[index + 1 :]
+        )
+        coefficient = ExactColorCoefficient(-1 if inversions % 2 else 1)
+    elif sector.kind == "single-trace":
+        tensor = ColorTensor(traces=(sector.trace_labels,))
+        coefficient = ExactColorCoefficient(1)
+    elif sector.kind == "singlet":
+        tensor = ColorTensor()
+        coefficient = ExactColorCoefficient(1)
+    else:
+        raise ValueError(f"unsupported colour sector kind {sector.kind!r}")
+    _validate_tensor_legs(tensor, legs)
+    return TensorTerm(coefficient, tensor)
+
+
+def sector_color_tensor(
+    sector: LCColorSector, process: CanonicalProcessIR
+) -> TensorTerm:
+    """Convert one generated sector to a phase-weighted literal tensor."""
+
+    return _sector_color_tensor(sector, process_color_legs(process))
+
+
+@dataclass(frozen=True)
+class ColorCorrelatorMatrixEntry:
+    left_sector_id: int
+    right_sector_id: int
+    weight: ExactColorCoefficient
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "left_sector_id": self.left_sector_id,
+            "right_sector_id": self.right_sector_id,
+            "weight": {
+                "real": [
+                    str(self.weight.real.numerator),
+                    str(self.weight.real.denominator),
+                ],
+                "imag": [
+                    str(self.weight.imag.numerator),
+                    str(self.weight.imag.denominator),
+                ],
+            },
+        }
+
+
+@dataclass(frozen=True)
+class ColorCorrelatorMatrix:
+    id: str
+    order: int
+    sector_ids: tuple[int, ...]
+    output_legs: tuple[ColorLeg, ...]
+    entries: tuple[ColorCorrelatorMatrixEntry, ...]
+    bra: tuple[ColorEmission, ...] = ()
+    ket: tuple[ColorEmission, ...] = ()
+    color_accuracy: ColorAccuracy = "full"
+
+    def to_json_dict(self) -> dict[str, object]:
+        request = ColorCorrelator(self.id, self.bra, self.ket)
+        return {
+            "id": self.id,
+            "order": self.order,
+            "convention": COLOR_CONNECTION_CONVENTION,
+            "color_accuracy": self.color_accuracy,
+            "storage": "sparse-directed",
+            "includes_color_factor": True,
+            "sector_ids": list(self.sector_ids),
+            "output_legs": [
+                {"label": leg.label, "representation": leg.representation}
+                for leg in self.output_legs
+            ],
+            "bra": request.to_json_dict()["bra"],
+            "ket": request.to_json_dict()["ket"],
+            "entries": [entry.to_json_dict() for entry in self.entries],
+        }
+
+
+def _selected_sectors(
+    plan: GenericColorPlan, sector_ids: Sequence[int] | None
+) -> tuple[LCColorSector, ...]:
+    if not isinstance(plan, GenericColorPlan):
+        raise TypeError("colour correlator planning requires a GenericColorPlan")
+    if plan.basis == "adjoint":
+        raise ValueError("colour correlators do not support the adjoint DDM basis")
+    if plan.color_accuracy != "full" or plan.process.color_accuracy != "full":
+        raise ValueError("colour correlators require a full-colour plan")
+    if plan.truncated or plan.trace_reflections_folded or not plan.sectors:
+        raise ValueError("colour correlators require a complete unfolded nonempty plan")
+    by_id = {sector.id: sector for sector in plan.sectors}
+    if len(by_id) != len(plan.sectors) or any(
+        type(index) is not int for index in by_id
+    ):
+        raise ValueError("colour sector IDs must be unique integers")
+    requested = tuple(by_id) if sector_ids is None else tuple(sector_ids)
+    if not requested or any(type(index) is not int for index in requested):
+        raise ValueError("selected colour sector IDs must be nonempty integers")
+    if len(set(requested)) != len(requested) or any(
+        index not in by_id for index in requested
+    ):
+        raise ValueError(
+            "selected colour sector IDs must be unique and belong to the plan"
+        )
+    return tuple(by_id[index] for index in requested)
+
+
+def _select_color_nc_terms(
+    terms: Mapping[int, ExactColorCoefficient],
+    *,
+    color_accuracy: ColorAccuracy,
+    leading_power: int,
+    fundamental_output: bool,
+) -> dict[int, ExactColorCoefficient]:
+    """Apply the inherited matrix-level accuracy style to a complete entry.
+
+    The threshold is shared by the whole connected family, never inferred from
+    this entry. Open-line NLC retains the exact coefficient of an admitted
+    entry, including its lower powers. Thus its coherence is a retained-order
+    statement, not an exact finite-Nc identity.
+    """
+
+    nonzero = {
+        power: coefficient for power, coefficient in terms.items() if coefficient
+    }
+    if color_accuracy == "full":
+        return nonzero
+    if color_accuracy not in ("lc", "nlc"):
+        raise ValueError("colour correlator accuracy must be lc, nlc or full")
+    threshold = leading_power - (2 if color_accuracy == "nlc" else 0)
+    if color_accuracy == "nlc" and fundamental_output:
+        return nonzero if nonzero and max(nonzero) >= threshold else {}
+    return {
+        power: coefficient
+        for power, coefficient in nonzero.items()
+        if power >= threshold
+    }
+
+
+def build_color_correlator_matrices(
+    color_plan: GenericColorPlan,
+    correlators: Sequence[ColorCorrelator],
+    *,
+    sector_ids: Sequence[int] | None = None,
+    color_accuracy: ColorAccuracy = "full",
+) -> tuple[ColorCorrelatorMatrix, ...]:
+    """Build exact directed matrices, sharing graph images within this request.
+
+    ``sector_ids`` may select canonical owners from a complete generated plan;
+    it does not reinterpret a truncated colour plan as a complete amplitude.
+    An empty request is a no-op and leaves the ordinary colour path untouched.
+    ``color_accuracy`` selects inherited LC/NLC/full matrix rules; the supplied
+    plan and physical partial amplitudes always remain complete full colour.
+    """
+
+    requests = tuple(correlators)
+    if not requests:
+        return ()
+    if color_accuracy not in ("lc", "nlc", "full"):
+        raise ValueError("colour correlator accuracy must be lc, nlc or full")
+    if any(not isinstance(request, ColorCorrelator) for request in requests):
+        raise TypeError("colour correlators must be ColorCorrelator requests")
+    if len({request.id for request in requests}) != len(requests):
+        raise ValueError("colour correlator IDs must be unique")
+    sectors = _selected_sectors(color_plan, sector_ids)
+    ids = tuple(sector.id for sector in sectors)
+    legs = process_color_legs(color_plan.process)
+    terms = tuple(_sector_color_tensor(sector, legs) for sector in sectors)
+    images: dict[tuple[ColorEmission, ...], tuple[ConnectedColorTensor, ...]] = {}
+    connections: dict[tuple[ColorEmission, ...], ColorConnection] = {}
+    for request in requests:
+        for emissions in (request.bra, request.ket):
+            if emissions not in connections:
+                connections[emissions] = ColorConnection(legs, emissions)
+        if connections[request.bra].output_legs != connections[request.ket].output_legs:
+            raise ValueError(
+                f"colour correlator {request.id!r} has incompatible "
+                "typed bra/ket outputs"
+            )
+    result = []
+    for request in requests:
+        for emissions in (request.bra, request.ket) if request.order else ():
+            if emissions not in images:
+                images[emissions] = tuple(
+                    apply_color_connection(
+                        term.tensor,
+                        connections[emissions],
+                        coefficient=term.coefficient,
+                    )
+                    for term in terms
+                )
+        output_legs = connections[request.bra].output_legs
+        leading_power = (
+            len(color_plan.process.adjoint_labels)
+            + color_plan.process.color_endpoints.pair_count
+            + request.order
+            - sum(isinstance(step, SplitGluon) for step in request.bra)
+        )
+        fundamental_output = any(abs(leg.representation) == 3 for leg in output_legs)
+        entries = []
+        for left_index, left_sector in enumerate(sectors):
+            for right_index, right_sector in enumerate(sectors):
+                if not request.order:
+                    weight = ExactColorCoefficient(
+                        exact_color_contraction_factor(
+                            color_plan,
+                            left_sector,
+                            right_sector,
+                            accuracy=color_accuracy,
+                        )
+                    )
+                else:
+                    terms_nc = contract_connected_tensor_nc_terms(
+                        images[request.bra][left_index],
+                        images[request.ket][right_index],
+                    )
+                    weight = evaluate_color_nc_terms(
+                        _select_color_nc_terms(
+                            terms_nc,
+                            color_accuracy=color_accuracy,
+                            leading_power=leading_power,
+                            fundamental_output=fundamental_output,
+                        )
+                    )
+                if weight:
+                    entries.append(
+                        ColorCorrelatorMatrixEntry(
+                            left_sector.id, right_sector.id, weight
+                        )
+                    )
+        result.append(
+            ColorCorrelatorMatrix(
+                request.id,
+                request.order,
+                ids,
+                output_legs,
+                tuple(entries),
+                request.bra,
+                request.ket,
+                color_accuracy,
+            )
+        )
+    return tuple(result)
+
+
+def build_color_correlator_matrix(
+    color_plan: GenericColorPlan,
+    correlator: ColorCorrelator,
+    *,
+    sector_ids: Sequence[int] | None = None,
+    color_accuracy: ColorAccuracy = "full",
+) -> ColorCorrelatorMatrix:
+    return build_color_correlator_matrices(
+        color_plan, (correlator,), sector_ids=sector_ids, color_accuracy=color_accuracy
+    )[0]
+
+
+__all__ = [
+    "ColorCorrelator",
+    "ColorCorrelatorMatrix",
+    "ColorCorrelatorMatrixEntry",
+    "build_color_correlator_matrices",
+    "build_color_correlator_matrix",
+    "process_color_legs",
+    "sector_color_tensor",
+]
diff --git a/pyamplicol/src/pyamplicol/color/fft_basis_strategy.py b/pyamplicol/src/pyamplicol/color/fft_basis_strategy.py
new file mode 100644
index 0000000000..5cf753cec3
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/fft_basis_strategy.py
@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: 0BSD
+"""Choose an exact FFT colour representation without inventing amplitude identities.
+
+DDM half-ladders apply only when the model supplies their algebraic certificate.
+Fundamental chains are a different representation, already natural for quark
+amplitudes.  Products of those chains must not be renamed DDM: their coefficients
+are colour-flow amplitudes, not the distinct-flavour Melia/JO primitives.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Literal
+
+from ..processes.ir import CanonicalProcessIR
+
+
+@dataclass(frozen=True)
+class FFTBasisStrategy:
+    """Selected metric and its truthful mathematical description.
+
+    ``actual_basis`` selects the existing metric implementation; ``name`` states
+    the colour tensors used.  ``tensor_count`` counts the complete tensor list,
+    not its rank at a particular Nc or its kinematically nonzero amplitudes.
+    It excludes the construction-only traversal aliases of open-line products.
+    """
+
+    actual_basis: Literal["trace", "adjoint"]
+    name: Literal[
+        "ddm", "fundamental-chain", "fundamental-chain-products", "singlet", "trace"
+    ]
+    reason: str
+    permutation_degree: int
+    tensor_count: int | None
+
+
+def best_general_fft_basis(
+    process: CanonicalProcessIR,
+    *,
+    ddm_proven: bool,
+) -> FFTBasisStrategy:
+    """Select a certified reduction, otherwise retain the exact existing basis.
+
+    This inexpensive decision uses only canonical colour roles and an already
+    computed model certificate.  It deliberately does not infer tree-level
+    Kleiss--Kuijf identities from external adjoint particles alone.  Colourless
+    external particles do not change the permutation group or the tensor count.
+    """
+
+    gluons = len(process.adjoint_labels)
+    fundamentals = len(process.fundamental_labels)
+    antifundamentals = len(process.antifundamental_labels)
+    if fundamentals != antifundamentals:
+        return FFTBasisStrategy(
+            "trace",
+            "trace",
+            "No balanced fundamental-chain domain; ordinary colour validation applies.",
+            gluons,
+            None,
+        )
+    if fundamentals:
+        # Allocate a permutation of m adjoints to k ordered open strings, then
+        # choose the k! antifundamental routings.  Different block traversals
+        # are construction aliases, not additional colour tensors.
+        tensor_count = (
+            math.factorial(fundamentals)
+            * math.factorial(gluons)
+            * math.comb(gluons + fundamentals - 1, fundamentals - 1)
+        )
+        return FFTBasisStrategy(
+            "trace",
+            "fundamental-chain" if fundamentals == 1 else "fundamental-chain-products",
+            (
+                "One open fundamental chain already fixes both quark endpoints; "
+                "there is no trace-to-DDM ordering reduction."
+                if fundamentals == 1
+                else "Retain exact products of fundamental chains and all endpoint "
+                "routings; distinct-flavour DDM generalizations are not identities "
+                "of arbitrary colour-flow amplitudes."
+            ),
+            gluons,
+            tensor_count,
+        )
+    if not gluons:
+        return FFTBasisStrategy(
+            "trace",
+            "singlet",
+            "The colour-singlet domain has one trivial colour tensor.",
+            0,
+            1,
+        )
+    if ddm_proven and gluons >= 2:
+        return FFTBasisStrategy(
+            "adjoint",
+            "ddm",
+            (
+                "The certified two-adjoint metric is the single delta tensor."
+                if gluons == 2
+                else "The model certifies the connected structure-constant "
+                "tree identities."
+            ),
+            gluons - 2,
+            math.factorial(gluons - 2),
+        )
+    return FFTBasisStrategy(
+        "trace",
+        "trace",
+        (
+            "A single adjoint leg leaves no two-anchor DDM domain."
+            if gluons < 2
+            else "No DDM amplitude identity is certified; retain the exact trace basis."
+        ),
+        max(0, gluons - 1),
+        math.factorial(max(0, gluons - 1)),
+    )
diff --git a/pyamplicol/src/pyamplicol/color/plan.py b/pyamplicol/src/pyamplicol/color/plan.py
new file mode 100644
index 0000000000..b06be50662
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/plan.py
@@ -0,0 +1,44 @@
+# SPDX-License-Identifier: 0BSD
+"""Compatibility facade for color-sector planning."""
+
+from __future__ import annotations
+
+from .plan_build import build_color_plan
+from .plan_replay import (
+    build_color_topology_replay_certificate,
+    build_lc_topology_replay_plan,
+    color_topology_replay_partitions,
+    lc_line_pairing_representative_ids,
+    lc_topology_replay_partitions,
+    lc_topology_replay_safe_groups,
+)
+from .plan_types import (
+    ColorAccuracy,
+    ColorSectorKind,
+    ColorTopologyReplayCertificate,
+    GenericColorPlan,
+    LCColorSector,
+    LCColorSectorReplayPartition,
+    LCColorSectorTopologyGroup,
+    LCColorTopologyReplayPlan,
+    LCOpenColorLine,
+)
+
+__all__ = [
+    "ColorAccuracy",
+    "ColorSectorKind",
+    "ColorTopologyReplayCertificate",
+    "GenericColorPlan",
+    "LCColorSector",
+    "LCColorSectorReplayPartition",
+    "LCColorSectorTopologyGroup",
+    "LCColorTopologyReplayPlan",
+    "LCOpenColorLine",
+    "build_color_plan",
+    "build_color_topology_replay_certificate",
+    "build_lc_topology_replay_plan",
+    "color_topology_replay_partitions",
+    "lc_line_pairing_representative_ids",
+    "lc_topology_replay_partitions",
+    "lc_topology_replay_safe_groups",
+]
diff --git a/pyamplicol/src/pyamplicol/color/plan_build.py b/pyamplicol/src/pyamplicol/color/plan_build.py
new file mode 100644
index 0000000000..2b5a28bbe5
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/plan_build.py
@@ -0,0 +1,519 @@
+# SPDX-License-Identifier: 0BSD
+"""Construction of color sectors from canonical process data."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from itertools import permutations
+
+from ..processes.ir import CanonicalProcessIR, ProcessLegIR
+from .plan_types import (
+    GenericColorPlan,
+    LCColorSector,
+    LCOpenColorLine,
+)
+
+
+def build_color_plan(
+    process: CanonicalProcessIR,
+    *,
+    color_accuracy: str = "lc",
+    max_sectors: int | None = None,
+    reference_color_order: Sequence[int] | None = None,
+    fold_trace_reflections: bool = False,
+    basis: str = "trace",
+) -> GenericColorPlan:
+    if not isinstance(process, CanonicalProcessIR):
+        raise TypeError("color planning requires a model-resolved CanonicalProcessIR")
+    process_ir = process
+    max_sector_count = _normalize_sector_cap(max_sectors)
+    if color_accuracy != process_ir.color_accuracy:
+        raise ValueError("color plan accuracy must match the model-resolved process IR")
+    if basis not in {"trace", "adjoint"}:
+        raise ValueError(f"unknown colour basis {basis!r}")
+    if basis == "adjoint":
+        return _build_adjoint_color_plan(
+            process_ir,
+            max_sectors=max_sector_count,
+            reference_color_order=reference_color_order,
+        )
+    fundamental_legs = _legs_by_labels(
+        process_ir,
+        process_ir.fundamental_labels,
+    )
+    antifundamental_legs = _legs_by_labels(
+        process_ir,
+        process_ir.antifundamental_labels,
+    )
+    adjoint_labels = process_ir.adjoint_labels
+    singlet_labels = process_ir.singlet_labels
+    if len(fundamental_legs) != len(antifundamental_legs):
+        return GenericColorPlan(
+            process=process_ir,
+            color_accuracy=color_accuracy,
+            sectors=(),
+            diagnostics=(
+                "leading-colour open-line plan requires balanced outgoing "
+                "fundamental and antifundamental counts",
+            ),
+        )
+    if not fundamental_legs:
+        return _build_no_fundamental_color_plan(
+            process_ir,
+            adjoint_labels=adjoint_labels,
+            singlet_labels=singlet_labels,
+            max_sectors=max_sector_count,
+            reference_color_order=reference_color_order,
+            fold_trace_reflections=fold_trace_reflections,
+        )
+
+    sectors: list[LCColorSector] = list(
+        _reference_lc_color_sectors(process_ir, reference_color_order)
+    )
+    seen_sector_keys = {_sector_dedup_key(sector) for sector in sectors}
+    truncated = False
+    for antifundamental_permutation in permutations(antifundamental_legs):
+        for adjoint_allocation in _iter_ordered_adjoint_allocations(
+            adjoint_labels,
+            len(fundamental_legs),
+        ):
+            lines = tuple(
+                LCOpenColorLine(
+                    fundamental_label=fundamental.label,
+                    antifundamental_label=antifundamental.label,
+                    adjoint_labels=tuple(adjoint_allocation[index]),
+                )
+                for index, (fundamental, antifundamental) in enumerate(
+                    zip(
+                        fundamental_legs,
+                        antifundamental_permutation,
+                        strict=True,
+                    )
+                )
+            )
+            for word_labels in _iter_open_line_color_words(
+                lines,
+                include_block_permutations=color_accuracy != "lc",
+            ):
+                candidate = LCColorSector(
+                    id=len(sectors),
+                    kind="open-lines",
+                    open_color_lines=lines,
+                    singlet_labels=singlet_labels,
+                    word_labels=word_labels,
+                )
+                key = _sector_dedup_key(candidate)
+                if key in seen_sector_keys:
+                    continue
+                seen_sector_keys.add(key)
+                sectors.append(candidate)
+                if max_sector_count is not None and len(sectors) >= max_sector_count:
+                    truncated = True
+                    break
+            if truncated:
+                break
+        if truncated:
+            break
+
+    diagnostics: tuple[str, ...] = ()
+    if truncated:
+        diagnostics = (
+            f"leading-colour sector enumeration reached max_sectors={max_sector_count}",
+        )
+    return GenericColorPlan(
+        process=process_ir,
+        color_accuracy=color_accuracy,
+        sectors=tuple(sectors),
+        diagnostics=diagnostics,
+        truncated=truncated,
+    )
+
+
+def _normalize_sector_cap(value: int | None) -> int | None:
+    if value is None:
+        return None
+    normalized = int(value)
+    return None if normalized < 0 else normalized
+
+
+def _build_adjoint_color_plan(
+    process: CanonicalProcessIR,
+    *,
+    max_sectors: int | None,
+    reference_color_order: Sequence[int] | None,
+) -> GenericColorPlan:
+    """Choose two-anchor primitive words for the DDM half-ladder metric.
+
+    The generation service additionally proves connected f-tree colour for
+    the selected model interactions and coupling orders. These records retain
+    their single-trace *ordering* shape, leaving the ordered-current grammar intact.
+    """
+
+    from .adjoint_kernel import MAX_ADJOINT_GLUONS
+
+    labels = tuple(sorted(process.adjoint_labels))
+    if (
+        len(labels) < 2
+        or len(labels) + len(process.singlet_labels) != len(process.legs)
+        or process.fundamental_labels
+        or process.antifundamental_labels
+    ):
+        raise ValueError(
+            "DDM colour basis requires external adjoints and optional singlets"
+        )
+    if len(labels) > MAX_ADJOINT_GLUONS:
+        raise ValueError(
+            f"adjoint colour basis supports at most {MAX_ADJOINT_GLUONS} "
+            "external gluons"
+        )
+    if process.color_accuracy not in {"nlc", "full"}:
+        raise ValueError("adjoint colour basis requires NLC or full colour")
+    first, last = labels[0], labels[-1]
+    reference = (
+        ()
+        if reference_color_order is None
+        else tuple(int(label) for label in reference_color_order)
+    )
+    if reference:
+        if len(reference) != len(labels) or set(reference) != set(labels):
+            raise ValueError("adjoint reference colour order must cover every gluon")
+        pivot = reference.index(first)
+        reference = reference[pivot:] + reference[:pivot]
+        if reference[-1] != last:
+            raise ValueError(
+                "adjoint reference colour order must preserve both anchors"
+            )
+    sectors: list[LCColorSector] = []
+    if reference and (max_sectors is None or max_sectors > 0):
+        sectors.append(
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=reference,
+                singlet_labels=process.singlet_labels,
+            )
+        )
+    truncated = False
+    for middle in permutations(labels[1:-1]):
+        word = (first, *middle, last)
+        if sectors and word == reference:
+            continue
+        if max_sectors is not None and len(sectors) >= max_sectors:
+            truncated = True
+            break
+        sectors.append(
+            LCColorSector(
+                id=len(sectors),
+                kind="single-trace",
+                trace_labels=word,
+                singlet_labels=process.singlet_labels,
+            )
+        )
+    return GenericColorPlan(
+        process=process,
+        color_accuracy=process.color_accuracy,
+        sectors=tuple(sectors),
+        basis="adjoint",
+        truncated=truncated,
+        diagnostics=(
+            (f"adjoint sector enumeration reached max_sectors={max_sectors}",)
+            if truncated
+            else ()
+        ),
+    )
+
+
+def _build_no_fundamental_color_plan(
+    process: CanonicalProcessIR,
+    *,
+    adjoint_labels: tuple[int, ...],
+    singlet_labels: tuple[int, ...],
+    max_sectors: int | None,
+    reference_color_order: Sequence[int] | None = None,
+    fold_trace_reflections: bool = False,
+) -> GenericColorPlan:
+    if not adjoint_labels:
+        return GenericColorPlan(
+            process=process,
+            color_accuracy=process.color_accuracy,
+            sectors=(
+                LCColorSector(
+                    id=0,
+                    kind="singlet",
+                    singlet_labels=singlet_labels,
+                ),
+            ),
+        )
+
+    first = min(adjoint_labels)
+    rest = tuple(label for label in adjoint_labels if label != first)
+    sectors: list[LCColorSector] = list(
+        _reference_lc_color_sectors(process, reference_color_order)
+    )
+    seen_sector_keys = {_sector_dedup_key(sector) for sector in sectors}
+    truncated = False
+    fold_reflections = process.color_accuracy == "lc" and fold_trace_reflections
+    seen_reversal_classes: set[tuple[int, ...]] = set()
+    for ordered_rest in permutations(rest):
+        if fold_reflections:
+            canonical = min(ordered_rest, tuple(reversed(ordered_rest)))
+            if canonical in seen_reversal_classes:
+                continue
+            seen_reversal_classes.add(canonical)
+        candidate = LCColorSector(
+            id=len(sectors),
+            kind="single-trace",
+            trace_labels=(first, *ordered_rest),
+            singlet_labels=singlet_labels,
+        )
+        key = _sector_dedup_key(candidate)
+        if key in seen_sector_keys:
+            continue
+        seen_sector_keys.add(key)
+        sectors.append(candidate)
+        if max_sectors is not None and len(sectors) >= max_sectors:
+            truncated = True
+            break
+    diagnostics: tuple[str, ...] = ()
+    if truncated:
+        diagnostics = (
+            f"leading-colour trace enumeration reached max_sectors={max_sectors}",
+        )
+    return GenericColorPlan(
+        process=process,
+        color_accuracy=process.color_accuracy,
+        sectors=tuple(sectors),
+        diagnostics=diagnostics,
+        truncated=truncated,
+        trace_reflections_folded=fold_reflections,
+    )
+
+
+def _legs_by_labels(
+    process: CanonicalProcessIR,
+    labels: tuple[int, ...],
+) -> tuple[ProcessLegIR, ...]:
+    by_label = {leg.label: leg for leg in process.legs}
+    return tuple(by_label[label] for label in labels)
+
+
+def _reference_lc_color_sectors(
+    process: CanonicalProcessIR,
+    reference_color_order: Sequence[int] | None,
+) -> tuple[LCColorSector, ...]:
+    if reference_color_order is None:
+        return ()
+    reference = tuple(int(label) for label in reference_color_order)
+    if not reference:
+        return ()
+    by_label = {leg.label: leg for leg in process.legs}
+    coloured_labels = {
+        *process.fundamental_labels,
+        *process.antifundamental_labels,
+        *process.adjoint_labels,
+    }
+    coloured_word = tuple(label for label in reference if label in coloured_labels)
+    if sorted(coloured_word) != sorted(coloured_labels):
+        return ()
+    if not process.fundamental_labels:
+        if (
+            tuple(label for label in coloured_word if label in process.adjoint_labels)
+            != coloured_word
+        ):
+            return ()
+        return (
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=coloured_word,
+                singlet_labels=process.singlet_labels,
+            ),
+        )
+    lines = _reference_open_lines(process, coloured_word, by_label)
+    if lines is None:
+        return ()
+    word_labels = tuple(label for line in lines for label in line.coloured_labels)
+    return (
+        LCColorSector(
+            id=0,
+            kind="open-lines",
+            open_color_lines=lines,
+            singlet_labels=process.singlet_labels,
+            word_labels=word_labels,
+        ),
+    )
+
+
+def _reference_open_lines(
+    process: CanonicalProcessIR,
+    coloured_word: tuple[int, ...],
+    by_label: dict[int, ProcessLegIR],
+) -> tuple[LCOpenColorLine, ...] | None:
+    fundamental_labels = set(process.fundamental_labels)
+    antifundamental_labels = set(process.antifundamental_labels)
+    adjoint_labels = set(process.adjoint_labels)
+    lines: list[LCOpenColorLine] = []
+    offset = 0
+    while offset < len(coloured_word):
+        start = coloured_word[offset]
+        if start in fundamental_labels:
+            end_labels = antifundamental_labels
+            start_is_fundamental = True
+        elif start in antifundamental_labels:
+            end_labels = fundamental_labels
+            start_is_fundamental = False
+        else:
+            return None
+        end = offset + 1
+        while end < len(coloured_word) and coloured_word[end] in adjoint_labels:
+            end += 1
+        if end >= len(coloured_word) or coloured_word[end] not in end_labels:
+            return None
+        middle = coloured_word[offset + 1 : end]
+        if any(label not in adjoint_labels for label in middle):
+            return None
+        stop = coloured_word[end]
+        if start_is_fundamental:
+            fundamental_label = start
+            antifundamental_label = stop
+        else:
+            fundamental_label = stop
+            antifundamental_label = start
+        if by_label[fundamental_label].color_role != "fundamental":
+            return None
+        if by_label[antifundamental_label].color_role != "antifundamental":
+            return None
+        lines.append(
+            LCOpenColorLine(
+                fundamental_label=fundamental_label,
+                antifundamental_label=antifundamental_label,
+                adjoint_labels=middle,
+            )
+        )
+        offset = end + 1
+    if len(lines) != len(process.fundamental_labels):
+        return None
+    return tuple(lines)
+
+
+def _sector_dedup_key(sector: LCColorSector) -> tuple[object, ...]:
+    return (
+        sector.kind,
+        tuple(
+            (
+                line.fundamental_label,
+                line.antifundamental_label,
+                line.adjoint_labels,
+                line.singlet_labels,
+            )
+            for line in sector.open_color_lines
+        ),
+        sector.trace_labels,
+        sector.singlet_labels,
+        sector.word_labels,
+    )
+
+
+def _iter_open_line_color_words(
+    lines: tuple[LCOpenColorLine, ...],
+    *,
+    include_block_permutations: bool = False,
+) -> tuple[tuple[int, ...], ...]:
+    """Return explicit colour words for one open-line pairing/allocation."""
+
+    if not include_block_permutations or len(lines) < 2:
+        return (tuple(label for line in lines for label in line.coloured_labels),)
+    words: list[tuple[int, ...]] = []
+    seen: set[tuple[int, ...]] = set()
+    for line_permutation in permutations(lines):
+        word = tuple(
+            label for line in line_permutation for label in line.coloured_labels
+        )
+        if word in seen:
+            continue
+        seen.add(word)
+        words.append(word)
+    return tuple(words)
+
+
+def _ordered_open_line_blocks(
+    word: tuple[int, ...],
+    lines: tuple[LCOpenColorLine, ...],
+) -> tuple[tuple[int, ...], ...] | None:
+    remaining = list(lines)
+    blocks: list[tuple[int, ...]] = []
+    offset = 0
+    while offset < len(word):
+        matched_index = None
+        for index, line in enumerate(remaining):
+            block = line.coloured_labels
+            if word[offset : offset + len(block)] == block:
+                matched_index = index
+                blocks.append(block)
+                offset += len(block)
+                break
+        if matched_index is None:
+            return None
+        remaining.pop(matched_index)
+    if remaining:
+        return None
+    return tuple(blocks)
+
+
+def _iter_ordered_adjoint_allocations(
+    adjoint_labels: tuple[int, ...],
+    line_count: int,
+) -> Iterable[tuple[tuple[int, ...], ...]]:
+    if line_count <= 0:
+        yield ()
+        return
+    for ordered_adjoint_labels in permutations(adjoint_labels):
+        yield from _iter_split_ordered_sequence(
+            tuple(ordered_adjoint_labels),
+            line_count,
+        )
+
+
+def _iter_ordered_label_allocations(
+    labels: tuple[int, ...],
+    line_count: int,
+) -> Iterable[tuple[tuple[int, ...], ...]]:
+    if line_count <= 0:
+        yield ()
+        return
+    if not labels:
+        yield tuple(() for _ in range(line_count))
+        return
+    buckets: list[list[int]] = [[] for _ in range(line_count)]
+    yield from _assign_unordered_labels_to_buckets(labels, buckets, 0)
+
+
+def _assign_unordered_labels_to_buckets(
+    labels: tuple[int, ...],
+    buckets: list[list[int]],
+    index: int,
+) -> Iterable[tuple[tuple[int, ...], ...]]:
+    if index == len(labels):
+        yield tuple(tuple(bucket) for bucket in buckets)
+        return
+    label = labels[index]
+    for bucket in buckets:
+        bucket.append(label)
+        yield from _assign_unordered_labels_to_buckets(labels, buckets, index + 1)
+        bucket.pop()
+
+
+def _iter_split_ordered_sequence(
+    sequence: tuple[int, ...],
+    bin_count: int,
+) -> Iterable[tuple[tuple[int, ...], ...]]:
+    if bin_count == 1:
+        yield (sequence,)
+        return
+    for split_index in range(len(sequence) + 1):
+        head = sequence[:split_index]
+        for tail in _iter_split_ordered_sequence(
+            sequence[split_index:],
+            bin_count - 1,
+        ):
+            yield (head, *tail)
diff --git a/pyamplicol/src/pyamplicol/color/plan_replay.py b/pyamplicol/src/pyamplicol/color/plan_replay.py
new file mode 100644
index 0000000000..ed359468bf
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/plan_replay.py
@@ -0,0 +1,819 @@
+# SPDX-License-Identifier: 0BSD
+"""Topology grouping and replay safety for color sectors."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping
+from dataclasses import replace
+from typing import TYPE_CHECKING
+
+from ..processes.ir import CanonicalProcessIR
+from .plan_build import _ordered_open_line_blocks
+from .plan_types import (
+    ColorTopologyReplayCertificate,
+    GenericColorPlan,
+    LCColorSector,
+    LCColorSectorReplayPartition,
+    LCColorSectorTopologyGroup,
+    LCColorTopologyReplayPlan,
+)
+
+if TYPE_CHECKING:
+    from ..models.base import Model
+
+_LC_REPLAY_PROOF_ALGORITHM = "canonical-model-contract-label-equivariance-v1"
+_COLOR_REPLAY_PROOF_ALGORITHM = (
+    "canonical-model-contract-color-label-equivariance-v2"
+)
+
+
+def _sector_topology_groups(
+    process: CanonicalProcessIR,
+    sectors: tuple[LCColorSector, ...],
+) -> tuple[LCColorSectorTopologyGroup, ...]:
+    by_signature: dict[tuple[object, ...], list[LCColorSector]] = {}
+    for sector in sectors:
+        by_signature.setdefault(
+            _sector_topology_signature(process, sector),
+            [],
+        ).append(sector)
+
+    groups: list[LCColorSectorTopologyGroup] = []
+    for signature, sector_group in by_signature.items():
+        representative = sector_group[0]
+        representative_labels = _sector_topology_labels(representative)
+        permutations: list[tuple[tuple[int, int], ...]] = []
+        for sector in sector_group:
+            sector_labels = _sector_topology_labels(sector)
+            if len(sector_labels) != len(representative_labels):
+                raise ValueError("isomorphic colour sectors have mismatched labels")
+            permutations.append(
+                tuple(zip(representative_labels, sector_labels, strict=True))
+            )
+        groups.append(
+            LCColorSectorTopologyGroup(
+                signature=signature,
+                representative_sector_id=representative.id,
+                sector_ids=tuple(sector.id for sector in sector_group),
+                label_permutations=tuple(permutations),
+            )
+        )
+    return tuple(groups)
+
+
+def _sector_topology_signature(
+    process: CanonicalProcessIR,
+    sector: LCColorSector,
+) -> tuple[object, ...]:
+    pdg_by_label = {
+        leg.label: leg.outgoing_pdg
+        for leg in process.legs
+        if leg.outgoing_pdg is not None
+    }
+    if sector.kind == "open-lines":
+        line_by_coloured = {
+            line.coloured_labels: line for line in sector.open_color_lines
+        }
+        ordered_blocks = (
+            _ordered_open_line_blocks(sector.word_labels, sector.open_color_lines)
+            if sector.word_labels
+            else None
+        )
+        ordered_lines = (
+            tuple(line_by_coloured[block] for block in ordered_blocks)
+            if ordered_blocks is not None
+            else sector.open_color_lines
+        )
+        return (
+            sector.kind,
+            tuple(
+                (
+                    pdg_by_label[line.fundamental_label],
+                    tuple(pdg_by_label[label] for label in line.adjoint_labels),
+                    pdg_by_label[line.antifundamental_label],
+                    tuple(pdg_by_label[label] for label in line.singlet_labels),
+                )
+                for line in ordered_lines
+            ),
+        )
+    if sector.kind == "single-trace":
+        return (
+            sector.kind,
+            tuple(pdg_by_label[label] for label in sector.trace_labels),
+            tuple(pdg_by_label[label] for label in sector.singlet_labels),
+        )
+    return (
+        sector.kind,
+        tuple(pdg_by_label[label] for label in sector.singlet_labels),
+    )
+
+
+def _sector_topology_labels(sector: LCColorSector) -> tuple[int, ...]:
+    if sector.kind == "open-lines":
+        line_by_coloured = {
+            line.coloured_labels: line for line in sector.open_color_lines
+        }
+        ordered_blocks = (
+            _ordered_open_line_blocks(sector.word_labels, sector.open_color_lines)
+            if sector.word_labels
+            else None
+        )
+        ordered_lines = (
+            tuple(line_by_coloured[block] for block in ordered_blocks)
+            if ordered_blocks is not None
+            else sector.open_color_lines
+        )
+        return tuple(label for line in ordered_lines for label in line.line_labels)
+    if sector.kind == "single-trace":
+        return (*sector.trace_labels, *sector.singlet_labels)
+    return sector.singlet_labels
+
+
+def _jsonable_signature(signature: tuple[object, ...]) -> list[object]:
+    def convert(value: object) -> object:
+        if isinstance(value, tuple):
+            return [convert(item) for item in value]
+        return value
+
+    return [convert(item) for item in signature]
+
+
+def lc_topology_replay_safe_groups(
+    color_plan: GenericColorPlan,
+) -> tuple[LCColorSectorTopologyGroup, ...]:
+    """Return LC topology groups safe for physical-input replay.
+
+    Runtime replay currently evaluates one representative sector with physical
+    external momenta in the user's process ordering.  Therefore every replay
+    permutation must preserve the initial-state label set.  Pure single-trace
+    sectors are also kept out of this fast path for now because their trace
+    symmetries need dedicated colour-convention validation.
+    """
+
+    if color_plan.color_accuracy != "lc":
+        return ()
+    return tuple(
+        group
+        for group in color_plan.topology_groups
+        if _lc_topology_group_replay_safe(color_plan, group)
+    )
+
+
+def color_topology_replay_partitions(
+    color_plan: GenericColorPlan,
+) -> tuple[LCColorSectorReplayPartition, ...]:
+    """Partition topology groups into exact replay-safe representatives.
+
+    The selected-sector ``lc_topology_replay_safe_groups`` helper only accepts
+    groups whose full topology orbit preserves the initial-state label set.
+    Complete artifacts can be more general: they split one topology group into
+    several initial-label-safe blocks and materialize one representative
+    sidecar per block.  The partition is purely structural and is valid for
+    every requested colour accuracy; mode-specific proof and runtime code must
+    still authenticate the color reduction before executing it.
+
+    In particular, a full-color seven-gluon plan has 720 physical trace
+    sectors but exactly six 120-sector partitions.  Those are the same six
+    crossing templates generated by the original AmpliCol library.  Keeping
+    this structural primitive color-generic lets recurrence, compiled, and
+    eager lowering share one fail-closed orbit certificate.
+    """
+
+    if color_plan.color_accuracy not in {"lc", "nlc", "full"}:
+        return ()
+    initial_labels = {leg.label for leg in color_plan.process.initial_legs}
+    if not initial_labels:
+        return ()
+    partitions: list[LCColorSectorReplayPartition] = []
+    for group in color_plan.topology_groups:
+        sectors = tuple(
+            sector
+            for sector_id in group.sector_ids
+            if (sector := color_plan.sector(sector_id)) is not None
+        )
+        if len(sectors) != len(group.sector_ids):
+            continue
+        if any(sector.kind not in {"open-lines", "single-trace"} for sector in sectors):
+            continue
+        base_maps = {
+            int(sector_id): {
+                int(representative_label): int(sector_label)
+                for representative_label, sector_label in permutation
+            }
+            for sector_id, permutation in zip(
+                group.sector_ids,
+                group.label_permutations,
+                strict=True,
+            )
+        }
+        sector_ids_by_initial_preimage: dict[tuple[int, ...], list[int]] = {}
+        complete_initial_maps = True
+        for sector_id in group.sector_ids:
+            sector_map = base_maps[int(sector_id)]
+            inverse_sector_map = {
+                sector_label: representative_label
+                for representative_label, sector_label in sector_map.items()
+            }
+            if not initial_labels.issubset(inverse_sector_map):
+                complete_initial_maps = False
+                break
+            initial_preimage = tuple(
+                sorted(inverse_sector_map[label] for label in initial_labels)
+            )
+            sector_ids_by_initial_preimage.setdefault(initial_preimage, []).append(
+                int(sector_id)
+            )
+        if not complete_initial_maps:
+            continue
+        partition_sector_ids = sorted(
+            sector_ids_by_initial_preimage.values(),
+            key=lambda sector_ids: min(sector_ids),
+        )
+        for grouped_sector_ids in partition_sector_ids:
+            representative = min(grouped_sector_ids)
+            representative_map = base_maps[representative]
+            inverse_representative_map = {
+                sector_label: representative_label
+                for representative_label, sector_label in representative_map.items()
+            }
+            active_sector_ids: list[int] = []
+            relative_permutations: list[tuple[tuple[int, int], ...]] = []
+            replay_weights: list[float] = []
+            grouped_sector_id_set = set(grouped_sector_ids)
+            for sector_id in group.sector_ids:
+                if int(sector_id) not in grouped_sector_id_set:
+                    continue
+                sector = color_plan.sector(int(sector_id))
+                if sector is None:
+                    continue
+                sector_map = base_maps[int(sector_id)]
+                relative_map = {
+                    representative_label: sector_map[
+                        inverse_representative_map[representative_label]
+                    ]
+                    for representative_label in sorted(representative_map.values())
+                }
+                if {relative_map[label] for label in initial_labels} != initial_labels:
+                    raise RuntimeError(
+                        "internal LC replay partitioning error: sectors grouped "
+                        "by initial-label preimage do not preserve the initial set"
+                    )
+                active_sector_ids.append(int(sector_id))
+                relative_permutations.append(tuple(sorted(relative_map.items())))
+                replay_weights.append(
+                    _lc_topology_replay_sector_weight(color_plan, sector)
+                )
+            if not active_sector_ids:
+                raise RuntimeError(
+                    "internal LC replay partitioning error: representative sector "
+                    f"{representative} did not produce a non-empty replay block"
+                )
+            partitions.append(
+                LCColorSectorReplayPartition(
+                    representative_sector_id=representative,
+                    active_sector_ids=tuple(active_sector_ids),
+                    label_permutations=tuple(relative_permutations),
+                    replay_weights=tuple(replay_weights),
+                )
+            )
+    return tuple(partitions)
+
+
+def lc_topology_replay_partitions(
+    color_plan: GenericColorPlan,
+) -> tuple[LCColorSectorReplayPartition, ...]:
+    """Return color-generic partitions only for the existing LC runtime."""
+
+    if color_plan.color_accuracy != "lc":
+        return ()
+    return color_topology_replay_partitions(color_plan)
+
+
+def build_color_topology_replay_certificate(
+    color_plan: GenericColorPlan,
+    model: Model,
+) -> ColorTopologyReplayCertificate | None:
+    """Prove replay orbits without selecting a runtime generation mode.
+
+    The proof binds the requested color accuracy in addition to the canonical
+    model, source, sector, and relabeling contracts.  A consumer may only use
+    these representatives after separately proving that its color reduction
+    accepts replayed physical-sector amplitudes.
+    """
+
+    if (
+        color_plan.color_accuracy not in {"lc", "nlc", "full"}
+        or color_plan.truncated
+        or len(color_plan.sectors) < 2
+    ):
+        return None
+    physical_sector_ids = tuple(sorted(int(sector.id) for sector in color_plan.sectors))
+    try:
+        model_contract_digest = _canonical_contract_digest(
+            _canonical_model_replay_contract(model)
+        )
+    except Exception:
+        return None
+    residual: set[int] = set(physical_sector_ids)
+    proven: list[LCColorSectorReplayPartition] = []
+    diagnostics: list[str] = []
+    for candidate in color_topology_replay_partitions(color_plan):
+        if len(candidate.active_sector_ids) < 2:
+            continue
+        try:
+            proof = _prove_topology_replay_partition(
+                color_plan,
+                candidate,
+                model,
+                model_contract_digest=model_contract_digest,
+                proof_algorithm=_COLOR_REPLAY_PROOF_ALGORITHM,
+                bind_color_accuracy=True,
+            )
+        except Exception as exc:
+            proof = None
+            diagnostics.append(
+                "color replay partition "
+                f"{candidate.representative_sector_id} proof failed closed: {exc}"
+            )
+        if proof is None:
+            diagnostics.append(
+                "color replay partition "
+                f"{candidate.representative_sector_id} remains materialized"
+            )
+            continue
+        proof_digest, replay_signs = proof
+        partition = replace(
+            candidate,
+            materialized_sector_id=candidate.representative_sector_id,
+            replay_signs=replay_signs,
+            proof_algorithm=_COLOR_REPLAY_PROOF_ALGORITHM,
+            proof_digest=proof_digest,
+        )
+        proven.append(partition)
+        residual.difference_update(partition.active_sector_ids)
+    if not proven:
+        return None
+    return ColorTopologyReplayCertificate(
+        color_accuracy=color_plan.color_accuracy,
+        physical_sector_ids=physical_sector_ids,
+        partitions=tuple(proven),
+        residual_sector_ids=tuple(sorted(residual)),
+        diagnostics=tuple(diagnostics),
+    )
+
+
+def build_lc_topology_replay_plan(
+    color_plan: GenericColorPlan,
+    model: Model,
+) -> LCColorTopologyReplayPlan | None:
+    """Build independently proof-gated replay classes for a complete LC plan.
+
+    Candidate topology partitions are cheap structural orbits.  This second
+    pass certifies each orbit against canonical source/kernel contracts and
+    exact relabelled colour structures.  A failed orbit becomes residual
+    materialization without disabling any independently proven orbit.
+    """
+
+    if (
+        color_plan.color_accuracy != "lc"
+        or color_plan.truncated
+        or len(color_plan.sectors) < 2
+    ):
+        return None
+    physical_sector_ids = tuple(sorted(int(sector.id) for sector in color_plan.sectors))
+    try:
+        model_contract_digest = _canonical_contract_digest(
+            _canonical_model_replay_contract(model)
+        )
+    except Exception:
+        return None
+    residual: set[int] = set(physical_sector_ids)
+    proven: list[LCColorSectorReplayPartition] = []
+    diagnostics: list[str] = []
+    for candidate in lc_topology_replay_partitions(color_plan):
+        if len(candidate.active_sector_ids) < 2:
+            continue
+        try:
+            proof = _prove_lc_topology_replay_partition(
+                color_plan,
+                candidate,
+                model,
+                model_contract_digest=model_contract_digest,
+            )
+        except Exception as exc:
+            proof = None
+            diagnostics.append(
+                "LC replay partition "
+                f"{candidate.representative_sector_id} proof failed closed: {exc}"
+            )
+        if proof is None:
+            diagnostics.append(
+                "LC replay partition "
+                f"{candidate.representative_sector_id} remains materialized"
+            )
+            continue
+        proof_digest, replay_signs = proof
+        partition = replace(
+            candidate,
+            materialized_sector_id=candidate.representative_sector_id,
+            replay_signs=replay_signs,
+            proof_algorithm=_LC_REPLAY_PROOF_ALGORITHM,
+            proof_digest=proof_digest,
+        )
+        proven.append(partition)
+        residual.difference_update(partition.active_sector_ids)
+    if not proven:
+        return None
+    return LCColorTopologyReplayPlan(
+        physical_sector_ids=physical_sector_ids,
+        partitions=tuple(proven),
+        residual_sector_ids=tuple(sorted(residual)),
+        diagnostics=tuple(diagnostics),
+    )
+
+
+def _prove_lc_topology_replay_partition(
+    color_plan: GenericColorPlan,
+    partition: LCColorSectorReplayPartition,
+    model: Model,
+    *,
+    model_contract_digest: str,
+) -> tuple[str, tuple[int, ...]] | None:
+    """Preserve the accepted LC proof and digest contract."""
+
+    return _prove_topology_replay_partition(
+        color_plan,
+        partition,
+        model,
+        model_contract_digest=model_contract_digest,
+        proof_algorithm=_LC_REPLAY_PROOF_ALGORITHM,
+        bind_color_accuracy=False,
+    )
+
+
+def _prove_topology_replay_partition(
+    color_plan: GenericColorPlan,
+    partition: LCColorSectorReplayPartition,
+    model: Model,
+    *,
+    model_contract_digest: str,
+    proof_algorithm: str,
+    bind_color_accuracy: bool,
+) -> tuple[str, tuple[int, ...]] | None:
+    """Certify label equivariance for one local replay partition.
+
+    External UFO tensors have already been canonized by the model compiler;
+    their exact oriented-kernel expressions and proof digests are included in
+    the contract below.  Built-in models contribute the same model-generic
+    source/lowering/evaluation contracts.  No process name or SM particle list
+    participates in this proof.
+    """
+
+    representative = color_plan.sector(partition.representative_sector_id)
+    if representative is None:
+        return None
+    labels = tuple(sorted(int(leg.label) for leg in color_plan.process.legs))
+    initial_labels = frozenset(
+        int(leg.label) for leg in color_plan.process.initial_legs
+    )
+    leg_by_label = {int(leg.label): leg for leg in color_plan.process.legs}
+    source_contracts = {
+        label: _canonical_source_contract(model, leg_by_label[label])
+        for label in labels
+    }
+    replay_signs: list[int] = []
+    mapping_contracts: list[dict[str, object]] = []
+    for sector_id, permutation, weight in zip(
+        partition.active_sector_ids,
+        partition.label_permutations,
+        partition.weights,
+        strict=True,
+    ):
+        sector = color_plan.sector(sector_id)
+        if sector is None:
+            return None
+        explicit_mapping = {int(left): int(right) for left, right in permutation}
+        if set(explicit_mapping) != set(explicit_mapping.values()):
+            return None
+        if not set(explicit_mapping).issubset(labels):
+            return None
+        mapping = {
+            label: explicit_mapping.get(label, label)
+            for label in labels
+        }
+        if set(mapping.values()) != set(labels):
+            return None
+        if {mapping[label] for label in initial_labels} != set(initial_labels):
+            return None
+        if _remapped_sector_contract(representative, mapping) != _sector_contract(
+            sector
+        ):
+            return None
+        for source_label, target_label in mapping.items():
+            if source_contracts[source_label] != source_contracts[target_label]:
+                return None
+        sign = _external_fermion_permutation_sign(
+            labels,
+            mapping,
+            source_contracts,
+        )
+        replay_signs.append(sign)
+        mapping_contracts.append(
+            {
+                "sector_id": int(sector_id),
+                "weight": float(weight),
+                "sign": sign,
+                "label_permutation": [
+                    list(item) for item in sorted(explicit_mapping.items())
+                ],
+                "sector_contract": _sector_contract(sector),
+            }
+        )
+    proof_payload = {
+        "algorithm": proof_algorithm,
+        "process": {
+            "initial_labels": sorted(initial_labels),
+            "external_source_contracts": [
+                [label, source_contracts[label]] for label in labels
+            ],
+        },
+        "representative_sector_id": partition.representative_sector_id,
+        "representative_sector_contract": _sector_contract(representative),
+        "mappings": mapping_contracts,
+        "model_contract_digest": model_contract_digest,
+    }
+    if bind_color_accuracy:
+        proof_payload["color_accuracy"] = color_plan.color_accuracy
+    return _canonical_contract_digest(proof_payload), tuple(replay_signs)
+
+
+def _canonical_contract_digest(payload: Mapping[str, object]) -> str:
+    canonical = json.dumps(
+        payload,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(canonical).hexdigest()
+
+
+def _canonical_source_contract(model: Model, leg: object) -> dict[str, object]:
+    outgoing_pdg = getattr(leg, "outgoing_pdg", None)
+    if outgoing_pdg is None:
+        raise ValueError("LC replay source has no outgoing particle identity")
+    source = model._source_ir(int(outgoing_pdg))
+    return {
+        "role": "initial" if bool(getattr(leg, "is_initial", False)) else "final",
+        "source": source.to_json_dict(),
+    }
+
+
+def _canonical_model_replay_contract(model: Model) -> dict[str, object]:
+    oriented_kernels: list[object] = []
+    compiled = getattr(model, "compiled", None)
+    ir = getattr(compiled, "ir", None)
+    for kernel in getattr(ir, "oriented_kernels", ()):
+        serializer = getattr(kernel, "to_dict", None)
+        if callable(serializer):
+            oriented_kernels.append(serializer())
+    vertices = []
+    seen_kinds: set[int] = set()
+    for vertex in sorted(
+        model.vertices,
+        key=lambda item: (int(item.kind), tuple(item.particles), tuple(item.coupling)),
+    ):
+        kind = int(vertex.kind)
+        if kind in seen_kinds:
+            continue
+        seen_kinds.add(kind)
+        vertices.append(
+            {
+                "kind": kind,
+                "lowering": model.vertex_lowering_rule(kind).to_json_dict(),
+                "evaluation_equivalence": (
+                    model.vertex_evaluation_equivalence(kind).to_json_dict()
+                ),
+            }
+        )
+    certificates = getattr(model, "_symmetry_certificates", None)
+    certificate_contract = None
+    if certificates is not None:
+        certificate_contract = {
+            name: _json_contract_value(getattr(certificates, name))
+            for name in getattr(certificates, "__dataclass_fields__", {})
+        }
+    return {
+        "model_type": f"{type(model).__module__}.{type(model).__qualname__}",
+        "vertices": vertices,
+        "oriented_kernels": oriented_kernels,
+        "external_symmetry_certificates": certificate_contract,
+    }
+
+
+def _json_contract_value(value: object) -> object:
+    if isinstance(value, Mapping):
+        return {
+            str(key): _json_contract_value(item)
+            for key, item in sorted(value.items(), key=lambda item: str(item[0]))
+        }
+    if isinstance(value, frozenset | set):
+        return sorted(_json_contract_value(item) for item in value)
+    if isinstance(value, tuple | list):
+        return [_json_contract_value(item) for item in value]
+    return value
+
+
+def _sector_contract(sector: LCColorSector) -> dict[str, object]:
+    return {
+        "kind": sector.kind,
+        "open_color_lines": sorted(
+            (
+                int(line.fundamental_label),
+                int(line.antifundamental_label),
+                tuple(int(label) for label in line.adjoint_labels),
+                tuple(int(label) for label in line.singlet_labels),
+            )
+            for line in sector.open_color_lines
+        ),
+        "trace_labels": tuple(int(label) for label in sector.trace_labels),
+        "singlet_labels": tuple(int(label) for label in sector.singlet_labels),
+        "word_labels": tuple(int(label) for label in sector.word_labels),
+    }
+
+
+def _remapped_sector_contract(
+    sector: LCColorSector,
+    mapping: Mapping[int, int],
+) -> dict[str, object]:
+    def mapped(labels: tuple[int, ...]) -> tuple[int, ...]:
+        return tuple(mapping[int(label)] for label in labels)
+
+    return {
+        "kind": sector.kind,
+        "open_color_lines": sorted(
+            (
+                mapping[int(line.fundamental_label)],
+                mapping[int(line.antifundamental_label)],
+                mapped(line.adjoint_labels),
+                mapped(line.singlet_labels),
+            )
+            for line in sector.open_color_lines
+        ),
+        "trace_labels": mapped(sector.trace_labels),
+        "singlet_labels": mapped(sector.singlet_labels),
+        "word_labels": mapped(sector.word_labels),
+    }
+
+
+def _external_fermion_permutation_sign(
+    labels: tuple[int, ...],
+    mapping: Mapping[int, int],
+    source_contracts: Mapping[int, Mapping[str, object]],
+) -> int:
+    classes: dict[tuple[str, str], list[int]] = {}
+    for label in labels:
+        contract = source_contracts[label]
+        source = contract["source"]
+        if not isinstance(source, Mapping) or source.get("statistics") != "fermion":
+            continue
+        identity = source.get("identity")
+        if not isinstance(identity, Mapping):
+            raise ValueError("fermion source identity contract is missing")
+        classes.setdefault(
+            (str(contract["role"]), str(identity["canonical_id"])),
+            [],
+        ).append(label)
+    sign = 1
+    for class_labels in classes.values():
+        ordered = sorted(class_labels)
+        positions = {label: index for index, label in enumerate(ordered)}
+        permutation = [positions[mapping[label]] for label in ordered]
+        inversions = sum(
+            permutation[left] > permutation[right]
+            for left in range(len(permutation))
+            for right in range(left + 1, len(permutation))
+        )
+        if inversions % 2:
+            sign = -sign
+    return sign
+
+
+def _lc_topology_replay_sector_weight(
+    color_plan: GenericColorPlan,
+    sector: LCColorSector,
+) -> float:
+    """Return the LC multiplicity represented by a materialized sector.
+
+    A model-proven pure single-trace LC plan may fold trace reflections during
+    colour-sector enumeration.  Replaying such a materialized representative
+    with weight two preserves the full ordering sum.
+    """
+
+    if (
+        color_plan.color_accuracy == "lc"
+        and color_plan.trace_reflections_folded
+        and sector.kind == "single-trace"
+        and len(sector.trace_labels) > 2
+    ):
+        return 2.0
+    return 1.0
+
+
+def lc_line_pairing_representative_ids(
+    color_plan: GenericColorPlan,
+) -> tuple[int, ...]:
+    """Return one sector per LC open-line pairing/allocation.
+
+    This is a generic colour-flow pruning helper.  It keeps distinct
+    fundamental-antifundamental pairings and distinct adjoint/singlet
+    attachments, but drops
+    duplicate sectors that only permute complete open-line blocks in the colour
+    word.  It deliberately does not group sectors with different flavour
+    pairings or different particles assigned to a line.
+    """
+
+    if color_plan.color_accuracy != "lc":
+        return ()
+    representatives: list[int] = []
+    seen: set[tuple[object, ...]] = set()
+    pdg_by_label = {
+        leg.label: leg.outgoing_pdg
+        for leg in color_plan.process.legs
+        if leg.outgoing_pdg is not None
+    }
+    for sector in color_plan.sectors:
+        signature = _sector_line_pairing_signature(pdg_by_label, sector)
+        if signature in seen:
+            continue
+        seen.add(signature)
+        representatives.append(int(sector.id))
+    return tuple(representatives)
+
+
+def _sector_line_pairing_signature(
+    pdg_by_label: dict[int, int | None],
+    sector: LCColorSector,
+) -> tuple[object, ...]:
+    if sector.kind == "open-lines":
+        return (
+            sector.kind,
+            tuple(
+                sorted(
+                    (
+                        line.fundamental_label,
+                        pdg_by_label.get(line.fundamental_label),
+                        line.antifundamental_label,
+                        pdg_by_label.get(line.antifundamental_label),
+                        tuple(
+                            (label, pdg_by_label.get(label))
+                            for label in line.adjoint_labels
+                        ),
+                        tuple(
+                            (label, pdg_by_label.get(label))
+                            for label in line.singlet_labels
+                        ),
+                    )
+                    for line in sector.open_color_lines
+                )
+            ),
+        )
+    if sector.kind == "single-trace":
+        canonical_trace = min(sector.trace_labels, tuple(reversed(sector.trace_labels)))
+        return (
+            sector.kind,
+            tuple((label, pdg_by_label.get(label)) for label in canonical_trace),
+            tuple((label, pdg_by_label.get(label)) for label in sector.singlet_labels),
+        )
+    return (
+        sector.kind,
+        tuple((label, pdg_by_label.get(label)) for label in sector.singlet_labels),
+    )
+
+
+def _lc_topology_group_replay_safe(
+    color_plan: GenericColorPlan,
+    group: LCColorSectorTopologyGroup,
+) -> bool:
+    sectors = tuple(
+        sector
+        for sector_id in group.sector_ids
+        if (sector := color_plan.sector(sector_id)) is not None
+    )
+    if len(sectors) != len(group.sector_ids):
+        return False
+    if any(sector.kind != "open-lines" for sector in sectors):
+        return False
+    initial_labels = {leg.label for leg in color_plan.process.initial_legs}
+    if not initial_labels:
+        return False
+    for permutation in group.label_permutations:
+        mapping = {
+            int(representative_label): int(sector_label)
+            for representative_label, sector_label in permutation
+        }
+        if {mapping.get(label) for label in initial_labels} != initial_labels:
+            return False
+    return True
diff --git a/pyamplicol/src/pyamplicol/color/plan_types.py b/pyamplicol/src/pyamplicol/color/plan_types.py
new file mode 100644
index 0000000000..3abff0008f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/plan_types.py
@@ -0,0 +1,663 @@
+# SPDX-License-Identifier: 0BSD
+"""Frozen color-sector and color-plan records."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Iterable
+from dataclasses import dataclass
+from functools import cached_property
+from itertools import permutations
+from typing import Literal
+
+from ..processes.ir import CanonicalProcessIR
+
+ColorAccuracy = Literal["lc", "nlc", "full"]
+ColorSectorKind = Literal["singlet", "open-lines", "single-trace"]
+
+
+def _canonical_open_string_product_key(
+    open_strings: Iterable[tuple[int, Iterable[int], int, Iterable[int]]],
+) -> tuple[tuple[int, tuple[int, ...], int, tuple[int, ...]], ...]:
+    """Return the unordered identity of a product of complete open strings."""
+
+    return tuple(
+        sorted(
+            (
+                int(fundamental),
+                tuple(int(label) for label in adjoints),
+                int(antifundamental),
+                tuple(int(label) for label in singlets),
+            )
+            for fundamental, adjoints, antifundamental, singlets in open_strings
+        )
+    )
+
+
+@dataclass(frozen=True)
+class LCOpenColorLine:
+    """One leading-colour open line in all-outgoing conventions."""
+
+    fundamental_label: int
+    antifundamental_label: int
+    adjoint_labels: tuple[int, ...]
+    singlet_labels: tuple[int, ...] = ()
+
+    @property
+    def coloured_labels(self) -> tuple[int, ...]:
+        return (
+            self.fundamental_label,
+            *self.adjoint_labels,
+            self.antifundamental_label,
+        )
+
+    @property
+    def line_labels(self) -> tuple[int, ...]:
+        return (*self.coloured_labels, *self.singlet_labels)
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "fundamental_label": self.fundamental_label,
+            "antifundamental_label": self.antifundamental_label,
+            "adjoint_labels": list(self.adjoint_labels),
+            "singlet_labels": list(self.singlet_labels),
+            "line_labels": list(self.line_labels),
+        }
+
+
+@dataclass(frozen=True)
+class LCColorSector:
+    """One colour-flow sector produced during generation warmup."""
+
+    id: int
+    kind: ColorSectorKind
+    open_color_lines: tuple[LCOpenColorLine, ...] = ()
+    trace_labels: tuple[int, ...] = ()
+    singlet_labels: tuple[int, ...] = ()
+    word_labels: tuple[int, ...] = ()
+
+    @property
+    def coloured_label_groups(self) -> tuple[tuple[int, ...], ...]:
+        if self.kind == "open-lines":
+            return tuple(line.coloured_labels for line in self.open_color_lines)
+        if self.kind == "single-trace":
+            return (self.trace_labels,)
+        return ()
+
+    @property
+    def line_label_groups(self) -> tuple[tuple[int, ...], ...]:
+        if self.kind == "open-lines":
+            return tuple(line.coloured_labels for line in self.open_color_lines)
+        if self.kind == "single-trace":
+            return ((*self.trace_labels, *self.singlet_labels),)
+        if self.kind == "singlet":
+            return (self.singlet_labels,)
+        return ()
+
+    @cached_property
+    def color_words(self) -> tuple[tuple[int, ...], ...]:
+        if self.word_labels:
+            return (self.word_labels,)
+        if self.kind == "open-lines":
+            return (
+                tuple(
+                    label
+                    for line in self.open_color_lines
+                    for label in line.coloured_labels
+                ),
+            )
+        if self.kind == "single-trace":
+            return (self.trace_labels,)
+        if self.kind == "singlet":
+            return ((),)
+        return ()
+
+    @cached_property
+    def admissible_traversal_words(self) -> tuple[tuple[int, ...], ...]:
+        """Colour words accepted while constructing currents for this sector.
+
+        The sector itself has one physical colour word.  During current
+        construction, however, complete open-line blocks can be traversed
+        in different intermediate orders.  This lets the generic recursion
+        reproduce AmpliCol's colour-ordered current closures without naming a
+        process family.
+        """
+
+        from .plan_build import _ordered_open_line_blocks
+
+        if self.kind != "open-lines" or len(self.open_color_lines) < 2:
+            return self.color_words
+        primary = self.color_words[0]
+        blocks = _ordered_open_line_blocks(primary, self.open_color_lines)
+        if blocks is None or len(blocks) < 2:
+            return self.color_words
+        words: list[tuple[int, ...]] = [primary]
+        seen = {primary}
+        for block_permutation in permutations(blocks):
+            word = tuple(label for block in block_permutation for label in block)
+            if word in seen:
+                continue
+            seen.add(word)
+            words.append(word)
+        return tuple(words)
+
+    def canonical_closure_traversal_word(
+        self,
+        process: CanonicalProcessIR,
+    ) -> tuple[int, ...]:
+        """Return one deterministic block-equivalent traversal for closure.
+
+        Intermediate currents may use every admissible complete-open-line
+        block permutation, but the final amplitude must close on one cyclic
+        traversal.  AmpliCol's representation convention starts with the
+        complete open-line block containing the minimum canonical coloured
+        source slot, preserves the public cyclic block order, and closes on the
+        terminal endpoint of the preceding block.  Colour-singlet sources are
+        skipped when selecting that slot.  This uses only source ordering, the
+        physical colour word, and declared open-line blocks; particle flavour,
+        mass, process identity, and multiplicity do not enter.
+        """
+
+        blocks = self._canonical_closure_blocks(process)
+        return tuple(label for block in blocks for label in block)
+
+    def _canonical_closure_blocks(
+        self,
+        process: CanonicalProcessIR,
+    ) -> tuple[tuple[int, ...], ...]:
+        """Reconstruct open-line blocks with the canonical source block first."""
+
+        primary = self.color_words[0]
+        if self.kind != "open-lines" or not self.open_color_lines:
+            return (primary,)
+        from .plan_build import _ordered_open_line_blocks
+
+        blocks = _ordered_open_line_blocks(primary, self.open_color_lines)
+        if blocks is None or len(blocks) != len(self.open_color_lines):
+            raise ValueError(
+                f"LC sector {self.id} colour word is not a complete open-line "
+                "block traversal"
+            )
+        known_labels = {int(leg.label) for leg in process.legs}
+        coloured_labels = tuple(label for block in blocks for label in block)
+        unknown_labels = sorted(set(coloured_labels) - known_labels)
+        if unknown_labels:
+            raise ValueError(
+                f"LC sector {self.id} closure line references unknown external "
+                f"labels {unknown_labels}"
+            )
+        if not coloured_labels or not process.legs:
+            return blocks
+        coloured_label_set = set(coloured_labels)
+        distinguished_label = next(
+            (
+                int(leg.label)
+                for leg in process.legs
+                if int(leg.label) in coloured_label_set
+            ),
+            None,
+        )
+        if distinguished_label is None:
+            return blocks
+        positions = tuple(
+            index for index, block in enumerate(blocks) if distinguished_label in block
+        )
+        if not positions:
+            return blocks
+        if len(positions) != 1:
+            raise ValueError(
+                f"LC sector {self.id} distinguished source label "
+                f"{distinguished_label} belongs to {len(positions)} open-line blocks"
+            )
+        first_position = positions[0]
+        return (*blocks[first_position:], *blocks[:first_position])
+
+    def canonical_closure_sink_label(self, process: CanonicalProcessIR) -> int | None:
+        """Return the terminal label of the canonical closure traversal."""
+
+        word = self.canonical_closure_traversal_word(process)
+        return None if not word else int(word[-1])
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "kind": self.kind,
+            "open_color_lines": [line.to_json_dict() for line in self.open_color_lines],
+            "trace_labels": list(self.trace_labels),
+            "singlet_labels": list(self.singlet_labels),
+            "word_labels": list(self.word_labels),
+            "coloured_label_groups": [
+                list(group) for group in self.coloured_label_groups
+            ],
+            "line_label_groups": [list(group) for group in self.line_label_groups],
+            "color_words": [list(word) for word in self.color_words],
+            "admissible_traversal_words": [
+                list(word) for word in self.admissible_traversal_words
+            ],
+        }
+
+
+@dataclass(frozen=True)
+class LCColorSectorTopologyGroup:
+    """Colour sectors that can share one compiled current topology.
+
+    The group key is built from model/process data carried by the external
+    labels, not from a process-family name.  Runtime reuse still evaluates each
+    sector with its own external-label permutation, so this is a generation-time
+    sharing plan rather than a physics approximation.
+    """
+
+    signature: tuple[object, ...]
+    representative_sector_id: int
+    sector_ids: tuple[int, ...]
+    label_permutations: tuple[tuple[tuple[int, int], ...], ...]
+
+    def to_json_dict(self) -> dict[str, object]:
+        from .plan_replay import _jsonable_signature
+
+        return {
+            "signature": _jsonable_signature(self.signature),
+            "representative_sector_id": self.representative_sector_id,
+            "sector_ids": list(self.sector_ids),
+            "label_permutations": [
+                [[left, right] for left, right in permutation]
+                for permutation in self.label_permutations
+            ],
+        }
+
+
+@dataclass(frozen=True)
+class LCColorSectorReplayPartition:
+    """Initial-label-safe replay block inside one LC topology group."""
+
+    representative_sector_id: int
+    active_sector_ids: tuple[int, ...]
+    label_permutations: tuple[tuple[tuple[int, int], ...], ...]
+    replay_weights: tuple[float, ...] = ()
+    replay_signs: tuple[int, ...] = ()
+    materialized_sector_id: int | None = None
+    proof_algorithm: str | None = None
+    proof_digest: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.materialized_sector_id is None:
+            object.__setattr__(
+                self,
+                "materialized_sector_id",
+                int(self.representative_sector_id),
+            )
+        count = len(self.active_sector_ids)
+        if len(self.label_permutations) != count:
+            raise ValueError(
+                "LC replay partition permutations do not match active sectors"
+            )
+        if self.replay_weights and len(self.replay_weights) != count:
+            raise ValueError("LC replay partition weights do not match active sectors")
+        if self.replay_signs and len(self.replay_signs) != count:
+            raise ValueError("LC replay partition signs do not match active sectors")
+        if any(not math.isfinite(weight) or weight <= 0.0 for weight in self.weights):
+            raise ValueError("LC replay partition weights must be positive and finite")
+        if any(sign not in {-1, 1} for sign in self.signs):
+            raise ValueError("LC replay partition signs must be -1 or 1")
+        if self.representative_sector_id not in self.active_sector_ids:
+            raise ValueError("LC replay partition does not contain its representative")
+        if self.materialized_sector_id != self.representative_sector_id:
+            raise ValueError(
+                "LC replay currently materializes the partition representative"
+            )
+        if (self.proof_algorithm is None) != (self.proof_digest is None):
+            raise ValueError(
+                "LC replay proof algorithm and digest must be present together"
+            )
+        if self.proof_digest is not None and (
+            len(self.proof_digest) != 64
+            or any(
+                character not in "0123456789abcdef" for character in self.proof_digest
+            )
+        ):
+            raise ValueError("LC replay proof digest must be a lowercase SHA-256")
+
+    @property
+    def weights(self) -> tuple[float, ...]:
+        return self.replay_weights or (1.0,) * len(self.active_sector_ids)
+
+    @property
+    def signs(self) -> tuple[int, ...]:
+        return self.replay_signs or (1,) * len(self.active_sector_ids)
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "representative_sector_id": self.representative_sector_id,
+            "materialized_sector_id": self.materialized_sector_id,
+            "active_sector_ids": list(self.active_sector_ids),
+            "label_permutations": [
+                [[left, right] for left, right in permutation]
+                for permutation in self.label_permutations
+            ],
+            "replay_weights": list(self.weights),
+            "replay_signs": list(self.signs),
+            "proof": (
+                None
+                if self.proof_digest is None
+                else {
+                    "status": "proven",
+                    "algorithm": self.proof_algorithm,
+                    "digest": self.proof_digest,
+                }
+            ),
+        }
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        """Return the additive compiled-runtime replay group contract."""
+
+        return {
+            "representative_sector_id": self.representative_sector_id,
+            "materialized_sector_id": self.materialized_sector_id,
+            "active_sector_ids": list(self.active_sector_ids),
+            "proof": {
+                "status": "proven",
+                "algorithm": self.proof_algorithm,
+                "digest": self.proof_digest,
+            },
+            "sector_permutations": [
+                {
+                    "sector_id": sector_id,
+                    "weight": weight,
+                    "sign": sign,
+                    "factor": [weight * sign, 0.0],
+                    "label_permutation": [
+                        {
+                            "representative_label": representative_label,
+                            "sector_label": sector_label,
+                        }
+                        for representative_label, sector_label in permutation
+                    ],
+                }
+                for sector_id, permutation, weight, sign in zip(
+                    self.active_sector_ids,
+                    self.label_permutations,
+                    self.weights,
+                    self.signs,
+                    strict=True,
+                )
+            ],
+        }
+
+
+@dataclass(frozen=True)
+class ColorTopologyReplayCertificate:
+    """Color-accuracy-bound proof for external-label topology replay.
+
+    This record is deliberately runtime-neutral.  Recurrence, compiled, and
+    eager lowering may consume the same proven partitions, but each mode must
+    separately authenticate how representative amplitudes enter its color
+    reduction.
+    """
+
+    color_accuracy: ColorAccuracy
+    physical_sector_ids: tuple[int, ...]
+    partitions: tuple[LCColorSectorReplayPartition, ...]
+    residual_sector_ids: tuple[int, ...]
+    diagnostics: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.color_accuracy not in {"lc", "nlc", "full"}:
+            raise ValueError(
+                f"unsupported topology replay accuracy {self.color_accuracy!r}"
+            )
+        physical = tuple(sorted(int(value) for value in self.physical_sector_ids))
+        residual = tuple(sorted(int(value) for value in self.residual_sector_ids))
+        object.__setattr__(self, "physical_sector_ids", physical)
+        object.__setattr__(self, "residual_sector_ids", residual)
+        if len(set(physical)) != len(physical):
+            raise ValueError("topology replay physical sectors contain duplicates")
+        if len(set(residual)) != len(residual):
+            raise ValueError("topology replay residual sectors contain duplicates")
+        if any(
+            partition.proof_algorithm is None or partition.proof_digest is None
+            for partition in self.partitions
+        ):
+            raise ValueError(
+                "topology replay certificate contains an unproven partition"
+            )
+        replayed = tuple(
+            sector_id
+            for partition in self.partitions
+            for sector_id in partition.active_sector_ids
+        )
+        if len(set(replayed)) != len(replayed):
+            raise ValueError("topology replay certificate partitions overlap")
+        if set(replayed) & set(residual):
+            raise ValueError("topology replay sectors overlap residual coverage")
+        if set(replayed) | set(residual) != set(physical):
+            raise ValueError(
+                "topology replay certificate does not cover every physical sector"
+            )
+
+    @property
+    def replayed_sector_count(self) -> int:
+        return sum(len(partition.active_sector_ids) for partition in self.partitions)
+
+    @property
+    def materialized_sector_ids(self) -> tuple[int, ...]:
+        return tuple(
+            sorted(
+                {
+                    *(
+                        int(partition.materialized_sector_id)
+                        for partition in self.partitions
+                    ),
+                    *self.residual_sector_ids,
+                }
+            )
+        )
+
+    @property
+    def optimized(self) -> bool:
+        return any(
+            len(partition.active_sector_ids) > 1 for partition in self.partitions
+        )
+
+    def representative_for(self, sector_id: int) -> int:
+        sector_id = int(sector_id)
+        for partition in self.partitions:
+            if sector_id in partition.active_sector_ids:
+                return int(partition.materialized_sector_id)
+        if sector_id in self.residual_sector_ids:
+            return sector_id
+        raise KeyError(f"topology replay certificate has no sector {sector_id}")
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "schema_version": 1,
+            "kind": "pyamplicol-color-topology-replay-certificate",
+            "mode": "external-label-permutation",
+            "color_accuracy": self.color_accuracy,
+            "physical_sector_ids": list(self.physical_sector_ids),
+            "materialized_sector_ids": list(self.materialized_sector_ids),
+            "residual_sector_ids": list(self.residual_sector_ids),
+            "replayed_sector_count": self.replayed_sector_count,
+            "partitions": [partition.to_json_dict() for partition in self.partitions],
+            "diagnostics": list(self.diagnostics),
+        }
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        """Return the color-generic representative-lane runtime contract."""
+
+        return {
+            "enabled": self.optimized,
+            "mode": "external-label-permutation",
+            "contract_version": 3,
+            "color_accuracy": self.color_accuracy,
+            "physical_sector_count": len(self.physical_sector_ids),
+            "replayed_sector_count": self.replayed_sector_count,
+            "materialized_sector_ids": list(self.materialized_sector_ids),
+            "residual_sector_ids": list(self.residual_sector_ids),
+            "groups": [
+                partition.to_runtime_manifest() for partition in self.partitions
+            ],
+        }
+
+
+@dataclass(frozen=True)
+class LCColorTopologyReplayPlan:
+    """Proof-gated replay classes plus independently materialized residuals."""
+
+    physical_sector_ids: tuple[int, ...]
+    partitions: tuple[LCColorSectorReplayPartition, ...]
+    residual_sector_ids: tuple[int, ...]
+    diagnostics: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        physical = tuple(sorted(int(value) for value in self.physical_sector_ids))
+        residual = tuple(sorted(int(value) for value in self.residual_sector_ids))
+        object.__setattr__(self, "physical_sector_ids", physical)
+        object.__setattr__(self, "residual_sector_ids", residual)
+        if len(set(physical)) != len(physical):
+            raise ValueError("LC replay physical sectors contain duplicates")
+        if len(set(residual)) != len(residual):
+            raise ValueError("LC replay residual sectors contain duplicates")
+        if any(
+            partition.proof_algorithm is None or partition.proof_digest is None
+            for partition in self.partitions
+        ):
+            raise ValueError("LC replay plan contains an unproven partition")
+        replayed = tuple(
+            sector_id
+            for partition in self.partitions
+            for sector_id in partition.active_sector_ids
+        )
+        if len(set(replayed)) != len(replayed):
+            raise ValueError("LC replay partitions overlap")
+        if set(replayed) & set(residual):
+            raise ValueError("LC replay sectors overlap residual coverage")
+        if set(replayed) | set(residual) != set(physical):
+            raise ValueError("LC replay plan does not cover every physical sector")
+
+    @property
+    def replayed_sector_count(self) -> int:
+        return sum(len(partition.active_sector_ids) for partition in self.partitions)
+
+    @property
+    def materialized_sector_ids(self) -> tuple[int, ...]:
+        return tuple(
+            sorted(
+                {
+                    *(
+                        int(partition.materialized_sector_id)
+                        for partition in self.partitions
+                    ),
+                    *self.residual_sector_ids,
+                }
+            )
+        )
+
+    @property
+    def optimized(self) -> bool:
+        return any(
+            len(partition.active_sector_ids) > 1 for partition in self.partitions
+        )
+
+    def representative_for(self, sector_id: int) -> int:
+        sector_id = int(sector_id)
+        for partition in self.partitions:
+            if sector_id in partition.active_sector_ids:
+                return int(partition.materialized_sector_id)
+        if sector_id in self.residual_sector_ids:
+            return sector_id
+        raise KeyError(f"LC replay plan has no physical sector {sector_id}")
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "schema_version": 1,
+            "kind": "pyamplicol-lc-topology-replay-plan",
+            "mode": "external-label-permutation",
+            "physical_sector_ids": list(self.physical_sector_ids),
+            "materialized_sector_ids": list(self.materialized_sector_ids),
+            "residual_sector_ids": list(self.residual_sector_ids),
+            "replayed_sector_count": self.replayed_sector_count,
+            "partitions": [partition.to_json_dict() for partition in self.partitions],
+            "diagnostics": list(self.diagnostics),
+        }
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        return {
+            "enabled": self.optimized,
+            "mode": "external-label-permutation",
+            "contract_version": 2,
+            "physical_sector_count": len(self.physical_sector_ids),
+            "replayed_sector_count": self.replayed_sector_count,
+            "materialized_sector_ids": list(self.materialized_sector_ids),
+            "residual_sector_ids": list(self.residual_sector_ids),
+            "groups": [
+                partition.to_runtime_manifest() for partition in self.partitions
+            ],
+        }
+
+
+@dataclass(frozen=True)
+class GenericColorPlan:
+    """Colour-flow planning payload shared by future Python/Rust runtimes."""
+
+    process: CanonicalProcessIR
+    color_accuracy: str
+    sectors: tuple[LCColorSector, ...]
+    diagnostics: tuple[str, ...] = ()
+    truncated: bool = False
+    trace_reflections_folded: bool = False
+    # The ordered words select primitive amplitudes in either basis.  Only the
+    # associated colour tensors/metric differ; adjoint means DDM half-ladders.
+    basis: Literal["trace", "adjoint"] = "trace"
+
+    @property
+    def sector_count(self) -> int:
+        return len(self.sectors)
+
+    @property
+    def ready_for_leading_colour(self) -> bool:
+        return self.color_accuracy == "lc" and bool(self.sectors) and not self.truncated
+
+    @property
+    def ready_for_requested_colour(self) -> bool:
+        return bool(self.sectors) and not self.truncated
+
+    @property
+    def coloured_labels(self) -> tuple[int, ...]:
+        return tuple(
+            sorted(
+                {
+                    *self.process.fundamental_labels,
+                    *self.process.antifundamental_labels,
+                    *self.process.adjoint_labels,
+                }
+            )
+        )
+
+    @cached_property
+    def _sectors_by_id(self) -> dict[int, LCColorSector]:
+        return {int(sector.id): sector for sector in self.sectors}
+
+    def sector(self, color_sector: int) -> LCColorSector | None:
+        return self._sectors_by_id.get(int(color_sector))
+
+    @cached_property
+    def topology_groups(self) -> tuple[LCColorSectorTopologyGroup, ...]:
+        from .plan_replay import _sector_topology_groups
+
+        return _sector_topology_groups(self.process, self.sectors)
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "process": self.process.to_json_dict(),
+            "color_accuracy": self.color_accuracy,
+            **({"basis": self.basis} if self.basis != "trace" else {}),
+            "sector_count": self.sector_count,
+            "truncated": self.truncated,
+            "trace_reflections_folded": self.trace_reflections_folded,
+            "ready_for_leading_colour": self.ready_for_leading_colour,
+            "ready_for_requested_colour": self.ready_for_requested_colour,
+            "coloured_labels": list(self.coloured_labels),
+            "diagnostics": list(self.diagnostics),
+            "sectors": [sector.to_json_dict() for sector in self.sectors],
+            "topology_groups": [group.to_json_dict() for group in self.topology_groups],
+        }
diff --git a/pyamplicol/src/pyamplicol/color/symmetric_group.py b/pyamplicol/src/pyamplicol/color/symmetric_group.py
new file mode 100644
index 0000000000..49528e5d68
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/color/symmetric_group.py
@@ -0,0 +1,1194 @@
+# SPDX-License-Identifier: 0BSD
+"""Generic symmetric-group color-contraction planning.
+
+The planner knows only canonical external color roles and color-sector
+structures.  It discovers complete regular permutation orbits, stores exact
+relative color kernels for those orbits, and leaves every uncertified group in
+an ordinary direct residual.  Model names, particle identities, and process
+families never enter the construction.
+"""
+
+from __future__ import annotations
+
+import math
+import struct
+from collections.abc import Iterator, Sequence
+from dataclasses import dataclass, replace
+from fractions import Fraction
+from typing import cast, overload
+
+from .contraction_factors import exact_color_contraction_factor
+from .contraction_types import (
+    ColorContractionPlan,
+    ColorContractionTemplateEntry,
+    ColorGroupDescriptor,
+    SymmetricGroupColorContractionBlock,
+)
+from .plan_types import GenericColorPlan, LCColorSector, LCOpenColorLine
+
+_MAX_SYMMETRIC_GROUP_DEGREE = 10
+_ZERO_SECTOR_OWNER = 0xFFFF_FFFF
+_SYMMETRIC_GROUP_ORDERS = tuple(
+    math.factorial(degree) for degree in range(_MAX_SYMMETRIC_GROUP_DEGREE + 1)
+)
+
+
+def _symmetric_group_order(degree: int) -> int:
+    if (
+        not isinstance(degree, int)
+        or isinstance(degree, bool)
+        or not 0 <= degree <= _MAX_SYMMETRIC_GROUP_DEGREE
+    ):
+        raise ValueError("symmetric-group degree is unsupported")
+    return _SYMMETRIC_GROUP_ORDERS[degree]
+
+
+def _lexicographic_permutation_rank(
+    permutation: Sequence[int],
+    *,
+    degree: int | None = None,
+) -> int:
+    """Return the checked ``itertools.permutations`` index in ``O(m**2)``."""
+
+    expected_degree = len(permutation) if degree is None else degree
+    _symmetric_group_order(expected_degree)
+    if len(permutation) != expected_degree:
+        raise ValueError("permutation degree is inconsistent")
+    available = list(range(expected_degree))
+    rank = 0
+    for position, value in enumerate(permutation):
+        if not isinstance(value, int) or isinstance(value, bool):
+            raise ValueError("permutation contains a non-integer label")
+        try:
+            available_index = available.index(value)
+        except ValueError as exc:
+            raise ValueError("permutation labels are not a bijection") from exc
+        rank += (
+            available_index * _SYMMETRIC_GROUP_ORDERS[expected_degree - position - 1]
+        )
+        del available[available_index]
+    return rank
+
+
+def _lexicographic_permutation_unrank(
+    degree: int,
+    rank: int,
+) -> tuple[int, ...]:
+    """Return one lexicographic permutation without materializing its group."""
+
+    group_order = _symmetric_group_order(degree)
+    if (
+        not isinstance(rank, int)
+        or isinstance(rank, bool)
+        or not 0 <= rank < group_order
+    ):
+        raise ValueError("permutation rank is out of bounds")
+    available = list(range(degree))
+    permutation: list[int] = []
+    remainder = rank
+    for position in range(degree):
+        suffix_order = _SYMMETRIC_GROUP_ORDERS[degree - position - 1]
+        available_index, remainder = divmod(remainder, suffix_order)
+        permutation.append(available.pop(available_index))
+    return tuple(permutation)
+
+
+@dataclass(frozen=True, slots=True)
+class _LexicographicPermutations(Sequence[tuple[int, ...]]):
+    """Constant-space sequence view of canonical symmetric-group elements."""
+
+    degree: int
+
+    def __post_init__(self) -> None:
+        _symmetric_group_order(self.degree)
+
+    def __len__(self) -> int:
+        return _SYMMETRIC_GROUP_ORDERS[self.degree]
+
+    @overload
+    def __getitem__(self, index: int) -> tuple[int, ...]: ...
+
+    @overload
+    def __getitem__(self, index: slice) -> tuple[tuple[int, ...], ...]: ...
+
+    def __getitem__(
+        self,
+        index: int | slice,
+    ) -> tuple[int, ...] | tuple[tuple[int, ...], ...]:
+        if isinstance(index, slice):
+            return tuple(
+                _lexicographic_permutation_unrank(self.degree, rank)
+                for rank in range(*index.indices(len(self)))
+            )
+        if not isinstance(index, int) or isinstance(index, bool):
+            raise TypeError("permutation index must be an integer or slice")
+        normalized_index = index if index >= 0 else len(self) + index
+        if not 0 <= normalized_index < len(self):
+            raise IndexError("permutation index is out of range")
+        return _lexicographic_permutation_unrank(self.degree, normalized_index)
+
+    def __iter__(self) -> Iterator[tuple[int, ...]]:
+        for rank in range(len(self)):
+            yield _lexicographic_permutation_unrank(self.degree, rank)
+
+
+@dataclass(frozen=True)
+class CertifiedSymmetricGroupOrbit:
+    """One structurally certified regular ``S_m`` color-sector orbit."""
+
+    channel_key: tuple[object, ...]
+    sector_ids: tuple[int, ...]
+    permutations: Sequence[tuple[int, ...]]
+
+    def __post_init__(self) -> None:
+        if not self.permutations:
+            raise ValueError("symmetric-group orbit has no permutations")
+        if isinstance(self.permutations, _LexicographicPermutations):
+            degree = self.permutations.degree
+        else:
+            degree = len(self.permutations[0])
+            _symmetric_group_order(degree)
+            if any(
+                _lexicographic_permutation_rank(permutation, degree=degree) != index
+                for index, permutation in enumerate(self.permutations)
+            ):
+                raise ValueError(
+                    "symmetric-group orbit permutations are not lexicographic"
+                )
+        if len(self.permutations) != _SYMMETRIC_GROUP_ORDERS[degree]:
+            raise ValueError("symmetric-group orbit has the wrong group order")
+        if len(self.sector_ids) != len(self.permutations):
+            raise ValueError(
+                "symmetric-group orbit sectors do not match the group order"
+            )
+        if len(set(self.sector_ids)) != len(self.sector_ids) or any(
+            sector_id < 0 for sector_id in self.sector_ids
+        ):
+            raise ValueError(
+                "symmetric-group orbit sector IDs must be unique and nonnegative"
+            )
+
+    @property
+    def degree(self) -> int:
+        if isinstance(self.permutations, _LexicographicPermutations):
+            return self.permutations.degree
+        return len(self.permutations[0])
+
+
+@dataclass(frozen=True)
+class SymmetricGroupOrbitPartition:
+    """Certified orbit partition of one active structural color domain."""
+
+    degree: int
+    permuted_adjoint_labels: tuple[int, ...]
+    fixed_adjoint_labels: tuple[int, ...]
+    orbits: tuple[CertifiedSymmetricGroupOrbit, ...]
+    residual_sector_ids: tuple[int, ...]
+    sector_owner_ids: tuple[int, ...]
+
+    def __post_init__(self) -> None:
+        if self.degree != len(self.permuted_adjoint_labels):
+            raise ValueError(
+                "symmetric-group degree does not match permuted adjoint labels"
+            )
+        if self.degree < 0 or self.degree > _MAX_SYMMETRIC_GROUP_DEGREE:
+            raise ValueError("symmetric-group orbit degree is unsupported")
+        labels = (*self.fixed_adjoint_labels, *self.permuted_adjoint_labels)
+        if len(set(labels)) != len(labels):
+            raise ValueError("symmetric-group adjoint label partition overlaps")
+        if tuple(sorted(self.residual_sector_ids)) != self.residual_sector_ids:
+            raise ValueError(
+                "symmetric-group residual sectors are not canonically ordered"
+            )
+        covered: set[int] = set()
+        for orbit in self.orbits:
+            previous_count = len(covered)
+            covered.update(orbit.sector_ids)
+            if len(covered) != previous_count + len(orbit.sector_ids):
+                raise ValueError("symmetric-group certified orbits overlap")
+        if covered.intersection(self.residual_sector_ids):
+            raise ValueError("symmetric-group orbit and residual sectors overlap")
+        if any(orbit.degree != self.degree for orbit in self.orbits):
+            raise ValueError("symmetric-group orbit degrees are inconsistent")
+        if self.orbits:
+            # Internally this is one constant-space canonical sequence view;
+            # retain compatibility with explicitly constructed canonical orbits.
+            shared_permutations = self.orbits[0].permutations
+            if any(
+                orbit.permutations is not shared_permutations
+                for orbit in self.orbits[1:]
+            ):
+                raise ValueError(
+                    "symmetric-group channels do not share their canonical view"
+                )
+
+    @property
+    def ordered_sector_ids(self) -> tuple[int, ...]:
+        return (
+            *(sector_id for orbit in self.orbits for sector_id in orbit.sector_ids),
+            *self.residual_sector_ids,
+        )
+
+
+def certify_symmetric_group_orbits(
+    color_plan: GenericColorPlan,
+    sector_ids: Sequence[int],
+    *,
+    sector_owner_ids: Sequence[int] | None = None,
+) -> SymmetricGroupOrbitPartition:
+    """Partition active sectors into complete free adjoint-label orbits.
+
+    Certification is structural: every channel contains exactly one canonical
+    sector for every lexicographic permutation, and each sector differs from
+    the identity only by simultaneous relabelling of the declared adjoint
+    labels.  This is the invariance used by ``exact_color_contraction_factor``;
+    no dense color matrix is constructed here.
+    """
+
+    if not isinstance(color_plan, GenericColorPlan):
+        raise TypeError("symmetric-group planning requires a GenericColorPlan")
+    requested_sector_ids = tuple(sorted(int(value) for value in sector_ids))
+    if len(set(requested_sector_ids)) != len(requested_sector_ids):
+        raise ValueError("symmetric-group active sectors contain duplicates")
+    sectors_by_id = {int(sector.id): sector for sector in color_plan.sectors}
+    if any(sector_id not in sectors_by_id for sector_id in requested_sector_ids):
+        raise ValueError("symmetric-group planning references an unknown sector")
+
+    # The caller supplies the schedule-authenticated alias certificate.  Orbit
+    # discovery operates only on its canonical owners; traversal replicas are
+    # destinations of those owners, never additional FFT channels.
+    owners = _validated_sector_owner_map(color_plan, sector_owner_ids)
+    _validate_owner_structures(color_plan, owners)
+    active_owners = {owners[sector_id] for sector_id in requested_sector_ids}
+    if _ZERO_SECTOR_OWNER in active_owners:
+        raise ValueError(
+            "symmetric-group active sector is certified as structural zero"
+        )
+    active_sector_ids = tuple(sorted(active_owners))
+    permuted_labels, fixed_labels = _adjoint_action_labels(color_plan)
+    degree = len(permuted_labels)
+    if degree > _MAX_SYMMETRIC_GROUP_DEGREE:
+        raise ValueError(
+            "symmetric-group degree exceeds the supported maximum "
+            f"{_MAX_SYMMETRIC_GROUP_DEGREE}"
+        )
+    group_order = _symmetric_group_order(degree)
+    lexicographic_permutations = _LexicographicPermutations(degree)
+
+    buckets: dict[
+        tuple[object, ...],
+        dict[int, int | list[int]],
+    ] = {}
+    residual: set[int] = set()
+    for sector_id in active_sector_ids:
+        candidate = _sector_orbit_coordinate(
+            sectors_by_id[sector_id],
+            permuted_labels=permuted_labels,
+            fixed_labels=fixed_labels,
+            basis=color_plan.basis,
+        )
+        if candidate is None or degree < 2:
+            residual.add(sector_id)
+            continue
+        channel_key, coordinate = candidate
+        try:
+            coordinate_index = _lexicographic_permutation_rank(
+                coordinate,
+                degree=degree,
+            )
+        except ValueError:
+            residual.add(sector_id)
+            continue
+        sectors_by_coordinate = buckets.setdefault(channel_key, {})
+        existing_sector_ids = sectors_by_coordinate.get(coordinate_index)
+        if existing_sector_ids is None:
+            sectors_by_coordinate[coordinate_index] = sector_id
+        elif isinstance(existing_sector_ids, int):
+            sectors_by_coordinate[coordinate_index] = [
+                existing_sector_ids,
+                sector_id,
+            ]
+        else:
+            existing_sector_ids.append(sector_id)
+
+    certified_orbit_rows: list[tuple[tuple[object, ...], tuple[int, ...]]] = []
+    for channel_key in sorted(buckets):
+        sectors_by_coordinate = buckets[channel_key]
+        if len(sectors_by_coordinate) != group_order or any(
+            isinstance(sector_ids_at_coordinate, list)
+            for sector_ids_at_coordinate in sectors_by_coordinate.values()
+        ):
+            for sector_ids_at_coordinate in sectors_by_coordinate.values():
+                if isinstance(sector_ids_at_coordinate, int):
+                    residual.add(sector_ids_at_coordinate)
+                else:
+                    residual.update(sector_ids_at_coordinate)
+            continue
+        orbit_sector_ids = tuple(
+            cast(int, sectors_by_coordinate[coordinate_index])
+            for coordinate_index in range(group_order)
+        )
+        certified_orbit_rows.append(
+            (
+                channel_key,
+                orbit_sector_ids,
+            )
+        )
+
+    if buckets:
+        del sectors_by_coordinate
+    buckets.clear()
+    orbits = tuple(
+        CertifiedSymmetricGroupOrbit(
+            channel_key=channel_key,
+            sector_ids=orbit_sector_ids,
+            permutations=lexicographic_permutations,
+        )
+        for channel_key, orbit_sector_ids in certified_orbit_rows
+    )
+    covered_count = sum(len(orbit.sector_ids) for orbit in orbits)
+    if covered_count + len(residual) != len(active_sector_ids):
+        raise AssertionError("symmetric-group orbit partition lost active sectors")
+    return SymmetricGroupOrbitPartition(
+        degree=degree,
+        permuted_adjoint_labels=permuted_labels,
+        fixed_adjoint_labels=fixed_labels,
+        orbits=orbits,
+        residual_sector_ids=tuple(sorted(residual)),
+        sector_owner_ids=owners,
+    )
+
+
+def build_symmetric_group_color_contraction_plan(
+    color_plan: GenericColorPlan,
+    groups: Sequence[ColorGroupDescriptor],
+    *,
+    sector_owner_ids: Sequence[int] | None = None,
+) -> ColorContractionPlan:
+    """Build exact convolution kernels and a direct residual color metric."""
+
+    accuracy = color_plan.color_accuracy
+    descriptors = tuple(groups)
+    if accuracy not in {"nlc", "full"}:
+        return _unsupported(
+            accuracy,
+            len(descriptors),
+            "symmetric-group FFT requires NLC or full color",
+        )
+    if color_plan.truncated or not color_plan.sectors:
+        return _unsupported(
+            accuracy,
+            len(descriptors),
+            "symmetric-group FFT requires a complete nonempty color plan",
+        )
+    if not descriptors:
+        return _unsupported(
+            accuracy,
+            0,
+            "symmetric-group FFT requires color-contraction groups",
+        )
+
+    try:
+        owners = _validated_sector_owner_map(color_plan, sector_owner_ids)
+        _validate_owner_structures(color_plan, owners)
+    except ValueError as exc:
+        return _unsupported(accuracy, len(descriptors), str(exc))
+    rectangular = _rectangular_components(
+        color_plan,
+        descriptors,
+        owners=owners,
+    )
+    if isinstance(rectangular, str):
+        return _unsupported(accuracy, len(descriptors), rectangular)
+    components, component_sector_ids, helicity_weight = rectangular
+    try:
+        partition = certify_symmetric_group_orbits(
+            color_plan,
+            component_sector_ids,
+            sector_owner_ids=owners,
+        )
+    except ValueError as exc:
+        return _unsupported(accuracy, len(descriptors), str(exc))
+
+    if not partition.orbits and partition.degree >= 2:
+        return _unsupported(
+            accuracy,
+            len(descriptors),
+            "symmetric-group FFT found no certified orbit at nontrivial "
+            f"degree {partition.degree}",
+        )
+
+    # S_0 and S_1 have no useful transform.  They are intentionally represented
+    # by the established exact direct residual rather than an empty FFT payload.
+    if not partition.orbits:
+        from .contraction import build_color_contraction_plan
+
+        normalized_descriptors, destination_by_group = _normalized_descriptors(
+            components,
+            partition.ordered_sector_ids,
+        )
+        direct = build_color_contraction_plan(color_plan, normalized_descriptors)
+        if direct is None:
+            return _unsupported(
+                accuracy,
+                len(descriptors),
+                "could not build the symmetric-group direct residual",
+            )
+        return replace(direct, destination_by_group=destination_by_group)
+
+    local_sector_ids = partition.ordered_sector_ids
+    _, destination_by_group = _normalized_descriptors(
+        components,
+        local_sector_ids,
+    )
+    component_group_ids = tuple(range(len(local_sector_ids) * len(components)))
+    group_order = _symmetric_group_order(partition.degree)
+    channel_cosets = tuple(
+        tuple(
+            range(
+                channel_index * group_order,
+                (channel_index + 1) * group_order,
+            )
+        )
+        for channel_index in range(len(partition.orbits))
+    )
+    residual_local_group_indices = tuple(
+        range(len(channel_cosets) * group_order, len(local_sector_ids))
+    )
+    sector_by_id = {int(sector.id): sector for sector in color_plan.sectors}
+    weight_fraction = Fraction.from_float(helicity_weight)
+
+    kernel_entries: list[ColorContractionTemplateEntry] = []
+    kernel_exact_weights: list[Fraction] = []
+    kernel_exact_by_key: dict[tuple[int, int, int], Fraction] = {}
+    diagonal_trace_exact: dict[tuple[int, tuple[int, ...]], Fraction] = {}
+    for left_channel, left_orbit in enumerate(partition.orbits):
+        left_local_index = channel_cosets[left_channel][0]
+        left_sector = sector_by_id[left_orbit.sector_ids[0]]
+        for right_channel in range(left_channel, len(partition.orbits)):
+            right_orbit = partition.orbits[right_channel]
+            symmetry = 1.0 if left_channel == right_channel else 2.0
+            quotient_diagonal_trace = (
+                left_channel == right_channel
+                and color_plan.basis == "trace"
+                and color_plan.process.color_endpoints.pair_count == 0
+                and left_sector.kind == "single-trace"
+                and left_orbit.channel_key[:1] == ("single-trace",)
+            )
+            for relative_index, right_sector_id in enumerate(right_orbit.sector_ids):
+                right_local_index = channel_cosets[right_channel][relative_index]
+                cache_key = None
+                if quotient_diagonal_trace:
+                    cache_key = (
+                        left_channel,
+                        _single_trace_diagonal_kernel_representative(
+                            _lexicographic_permutation_unrank(
+                                partition.degree,
+                                relative_index,
+                            )
+                        ),
+                    )
+                exact = (
+                    None if cache_key is None else diagonal_trace_exact.get(cache_key)
+                )
+                if exact is None:
+                    exact = weight_fraction * exact_color_contraction_factor(
+                        color_plan,
+                        left_sector,
+                        sector_by_id[right_sector_id],
+                        accuracy=accuracy,
+                        full_col_acc=20,
+                    )
+                    if cache_key is not None:
+                        diagonal_trace_exact[cache_key] = exact
+                kernel_entries.append(
+                    ColorContractionTemplateEntry(
+                        left_group_index=left_local_index,
+                        right_group_index=right_local_index,
+                        weight_re=float(exact),
+                        symmetry_factor=symmetry,
+                    )
+                )
+                kernel_exact_weights.append(exact)
+                kernel_exact_by_key[(left_channel, right_channel, relative_index)] = (
+                    exact
+                )
+
+    hermiticity_relative_indices = _hermiticity_relative_indices(
+        partition.degree,
+        channel_count=len(partition.orbits),
+    )
+    _certify_cross_channel_hermiticity(
+        color_plan,
+        partition,
+        sector_by_id=sector_by_id,
+        accuracy=accuracy,
+        weight_fraction=weight_fraction,
+        kernel_exact_by_key=kernel_exact_by_key,
+        relative_indices=hermiticity_relative_indices,
+    )
+    _certify_sampled_equivariance(
+        color_plan,
+        partition,
+        sector_by_id=sector_by_id,
+        accuracy=accuracy,
+        weight_fraction=weight_fraction,
+        kernel_exact_by_key=kernel_exact_by_key,
+    )
+    hermiticity_check_mode = (
+        "vacuous"
+        if len(partition.orbits) < 2
+        else "full"
+        if partition.degree <= 4
+        else "deterministic-samples"
+    )
+
+    residual_entries: list[ColorContractionTemplateEntry] = []
+    residual_exact_weights: list[Fraction] = []
+    if residual_local_group_indices:
+        residual_set = set(residual_local_group_indices)
+        for left_local_index, left_sector_id in enumerate(local_sector_ids):
+            for right_local_index in range(left_local_index, len(local_sector_ids)):
+                if not residual_set.intersection((left_local_index, right_local_index)):
+                    continue
+                exact = weight_fraction * exact_color_contraction_factor(
+                    color_plan,
+                    sector_by_id[left_sector_id],
+                    sector_by_id[local_sector_ids[right_local_index]],
+                    accuracy=accuracy,
+                    full_col_acc=20,
+                )
+                residual_entries.append(
+                    ColorContractionTemplateEntry(
+                        left_group_index=left_local_index,
+                        right_group_index=right_local_index,
+                        weight_re=float(exact),
+                        symmetry_factor=(
+                            1.0 if left_local_index == right_local_index else 2.0
+                        ),
+                    )
+                )
+                residual_exact_weights.append(exact)
+
+    block = SymmetricGroupColorContractionBlock(
+        degree=partition.degree,
+        component_count=len(components),
+        component_group_ids=component_group_ids,
+        local_sector_ids=local_sector_ids,
+        channel_cosets=channel_cosets,
+        kernel_entries=tuple(kernel_entries),
+        kernel_exact_weights=tuple(kernel_exact_weights),
+        residual_entries=tuple(residual_entries),
+        residual_exact_weights=tuple(residual_exact_weights),
+        residual_local_group_indices=residual_local_group_indices,
+        hermiticity_check_mode=hermiticity_check_mode,
+        hermiticity_relative_indices=hermiticity_relative_indices,
+    )
+    return ColorContractionPlan(
+        color_accuracy=accuracy,
+        supported=True,
+        reason=None,
+        group_count=len(component_group_ids),
+        entries=(),
+        symmetric_group_block=block,
+        destination_by_group=destination_by_group,
+    )
+
+
+def reconstruct_symmetric_group_dense_exact(
+    block: SymmetricGroupColorContractionBlock,
+) -> dict[tuple[int, int], Fraction]:
+    """Expand a small plan for tests and generation-time certification tools."""
+
+    kernel: dict[tuple[int, int, int], Fraction] = {}
+    offset = 0
+    for left_channel in range(block.channel_count):
+        for right_channel in range(left_channel, block.channel_count):
+            for relative_index in range(block.group_order):
+                kernel[(left_channel, right_channel, relative_index)] = (
+                    block.kernel_exact_weights[offset]
+                )
+                offset += 1
+
+    dense: dict[tuple[int, int], Fraction] = {}
+    for left_channel, left_coset in enumerate(block.channel_cosets):
+        for right_channel in range(left_channel, block.channel_count):
+            right_coset = block.channel_cosets[right_channel]
+            for left_permutation_index, left_local in enumerate(left_coset):
+                left_permutation = _lexicographic_permutation_unrank(
+                    block.degree,
+                    left_permutation_index,
+                )
+                for right_permutation_index, right_local in enumerate(right_coset):
+                    if left_local > right_local:
+                        continue
+                    relative = _relative_permutation(
+                        left_permutation,
+                        _lexicographic_permutation_unrank(
+                            block.degree,
+                            right_permutation_index,
+                        ),
+                    )
+                    dense[(left_local, right_local)] = kernel[
+                        (
+                            left_channel,
+                            right_channel,
+                            _lexicographic_permutation_rank(
+                                relative,
+                                degree=block.degree,
+                            ),
+                        )
+                    ]
+    dense.update(
+        (
+            (entry.left_group_index, entry.right_group_index),
+            exact,
+        )
+        for entry, exact in zip(
+            block.residual_entries,
+            block.residual_exact_weights,
+            strict=True,
+        )
+    )
+    return dense
+
+
+def _unsupported(accuracy: str, group_count: int, reason: str) -> ColorContractionPlan:
+    return ColorContractionPlan(
+        color_accuracy=accuracy,
+        supported=False,
+        reason=reason,
+        group_count=group_count,
+        entries=(),
+    )
+
+
+def _rectangular_components(
+    color_plan: GenericColorPlan,
+    descriptors: tuple[ColorGroupDescriptor, ...],
+    *,
+    owners: tuple[int, ...],
+) -> (
+    tuple[
+        tuple[tuple[ColorGroupDescriptor, ...], ...],
+        tuple[int, ...],
+        float,
+    ]
+    | str
+):
+    if len({descriptor.group_id for descriptor in descriptors}) != len(descriptors):
+        return "symmetric-group color groups contain duplicate group IDs"
+    components_by_helicity: dict[tuple[object, ...], list[ColorGroupDescriptor]] = {}
+    for descriptor in descriptors:
+        components_by_helicity.setdefault(descriptor.helicity_key, []).append(
+            descriptor
+        )
+    original_components = tuple(
+        sorted(
+            (
+                tuple(sorted(component, key=lambda descriptor: descriptor.group_id))
+                for component in components_by_helicity.values()
+            ),
+            key=lambda component: component[0].group_id,
+        )
+    )
+    if any(
+        descriptor.sector_id < 0 or descriptor.sector_id >= len(owners)
+        for descriptor in descriptors
+    ):
+        return "symmetric-group color group references an unknown sector"
+    if any(
+        owners[descriptor.sector_id] == _ZERO_SECTOR_OWNER
+        for descriptor in descriptors
+    ):
+        return (
+            "symmetric-group color group references a certified structural-zero sector"
+        )
+    reference_owner_ids = tuple(
+        sorted({owners[descriptor.sector_id] for descriptor in original_components[0]})
+    )
+    if not reference_owner_ids:
+        return "symmetric-group helicity component has no canonical owners"
+    reference_weight = float(original_components[0][0].helicity_weight)
+    if not math.isfinite(reference_weight):
+        return "symmetric-group helicity weight is not finite"
+    reference_weight_bits = struct.pack(">d", reference_weight)
+    components: list[tuple[ColorGroupDescriptor, ...]] = []
+    sectors_by_id = {int(sector.id): sector for sector in color_plan.sectors}
+    for component in original_components:
+        by_sector: dict[int, ColorGroupDescriptor] = {}
+        for descriptor in component:
+            if descriptor.sector_id in by_sector:
+                return "symmetric-group component contains duplicate color sectors"
+            by_sector[descriptor.sector_id] = descriptor
+        descriptors_by_owner: dict[int, list[ColorGroupDescriptor]] = {}
+        for sector_id, descriptor in by_sector.items():
+            descriptors_by_owner.setdefault(owners[sector_id], []).append(descriptor)
+        owner_ids = tuple(sorted(descriptors_by_owner))
+        if owner_ids != reference_owner_ids:
+            return "symmetric-group helicity components do not share one owner domain"
+        if any(
+            not math.isfinite(float(descriptor.helicity_weight))
+            or struct.pack(">d", float(descriptor.helicity_weight))
+            != reference_weight_bits
+            for descriptor in component
+        ):
+            return "symmetric-group helicity components have inconsistent weights"
+        canonical_component: list[ColorGroupDescriptor] = []
+        for owner_id in owner_ids:
+            aliases = descriptors_by_owner[owner_id]
+            source = next(
+                (
+                    descriptor
+                    for descriptor in aliases
+                    if descriptor.sector_id == owner_id
+                ),
+                min(aliases, key=lambda descriptor: descriptor.group_id),
+            )
+            owner_sector = sectors_by_id[owner_id]
+            canonical_component.append(
+                replace(
+                    source,
+                    sector_id=owner_id,
+                    word=owner_sector.color_words[0],
+                )
+            )
+        components.append(tuple(canonical_component))
+
+    reference_sector_ids = reference_owner_ids
+    if len(set(reference_sector_ids)) != len(reference_sector_ids):
+        return "symmetric-group component contains duplicate color sectors"
+    return tuple(components), reference_sector_ids, reference_weight
+
+
+def _normalized_descriptors(
+    components: tuple[tuple[ColorGroupDescriptor, ...], ...],
+    local_sector_ids: tuple[int, ...],
+) -> tuple[tuple[ColorGroupDescriptor, ...], tuple[int, ...]]:
+    by_component_and_sector = tuple(
+        {descriptor.sector_id: descriptor for descriptor in component}
+        for component in components
+    )
+    normalized: list[ColorGroupDescriptor] = []
+    destination_by_group = [0] * (len(local_sector_ids) * len(components))
+    for component_index, descriptors_by_sector in enumerate(by_component_and_sector):
+        for local_index, sector_id in enumerate(local_sector_ids):
+            source = descriptors_by_sector[sector_id]
+            group_id = local_index * len(components) + component_index
+            normalized.append(
+                ColorGroupDescriptor(
+                    group_id=group_id,
+                    helicity_key=source.helicity_key,
+                    sector_id=source.sector_id,
+                    word=source.word,
+                    helicity_weight=source.helicity_weight,
+                )
+            )
+            destination_by_group[group_id] = source.group_id
+    return tuple(normalized), tuple(destination_by_group)
+
+
+def _adjoint_action_labels(
+    color_plan: GenericColorPlan,
+) -> tuple[tuple[int, ...], tuple[int, ...]]:
+    adjoint_labels = tuple(
+        sorted(int(label) for label in color_plan.process.adjoint_labels)
+    )
+    if not adjoint_labels:
+        return (), ()
+    if color_plan.process.fundamental_labels:
+        return adjoint_labels, ()
+    if color_plan.basis == "adjoint":
+        return adjoint_labels[1:-1], (adjoint_labels[0], adjoint_labels[-1])
+    anchor = adjoint_labels[0]
+    return adjoint_labels[1:], (anchor,)
+
+
+def _sector_orbit_coordinate(
+    sector: LCColorSector,
+    *,
+    permuted_labels: tuple[int, ...],
+    fixed_labels: tuple[int, ...],
+    basis: str = "trace",
+) -> tuple[tuple[object, ...], tuple[int, ...]] | None:
+    rank_by_label = {label: rank for rank, label in enumerate(permuted_labels)}
+    if basis == "adjoint":
+        word = tuple(int(label) for label in sector.trace_labels)
+        if (
+            sector.kind != "single-trace"
+            or len(fixed_labels) != 2
+            or len(word) != len(permuted_labels) + 2
+            or word[0] != fixed_labels[0]
+            or word[-1] != fixed_labels[1]
+            or set(word[1:-1]) != set(permuted_labels)
+        ):
+            return None
+        return (
+            ("adjoint", fixed_labels, tuple(sector.singlet_labels)),
+            tuple(rank_by_label[x] for x in word[1:-1]),
+        )
+    if sector.kind == "single-trace":
+        if len(fixed_labels) != 1:
+            return None
+        anchor = fixed_labels[0]
+        trace = tuple(int(label) for label in sector.trace_labels)
+        if len(trace) != len(permuted_labels) + 1 or set(trace) != {
+            anchor,
+            *permuted_labels,
+        }:
+            return None
+        anchor_index = trace.index(anchor)
+        rotated = trace[anchor_index:] + trace[:anchor_index]
+        try:
+            coordinate = tuple(rank_by_label[label] for label in rotated[1:])
+        except KeyError:
+            return None
+        return (
+            ("single-trace", tuple(int(label) for label in sector.singlet_labels)),
+            coordinate,
+        )
+    if sector.kind != "open-lines" or fixed_labels:
+        return None
+
+    ordered_lines = tuple(sorted(sector.open_color_lines, key=_open_line_sort_key))
+    flattened = tuple(
+        int(label) for line in ordered_lines for label in line.adjoint_labels
+    )
+    if len(flattened) != len(permuted_labels) or set(flattened) != set(permuted_labels):
+        return None
+    if _open_line_block_order(sector) is None:
+        return None
+    try:
+        coordinate = tuple(rank_by_label[label] for label in flattened)
+    except KeyError:
+        return None
+    line_skeleton = tuple(
+        (
+            int(line.fundamental_label),
+            int(line.antifundamental_label),
+            len(line.adjoint_labels),
+            tuple(int(label) for label in line.singlet_labels),
+        )
+        for line in ordered_lines
+    )
+    return (
+        (
+            "open-lines",
+            line_skeleton,
+            tuple(int(label) for label in sector.singlet_labels),
+        ),
+        coordinate,
+    )
+
+
+def _open_line_sort_key(line: LCOpenColorLine) -> tuple[object, ...]:
+    return (
+        int(line.fundamental_label),
+        int(line.antifundamental_label),
+        tuple(int(label) for label in line.singlet_labels),
+    )
+
+
+def _open_line_block_order(
+    sector: LCColorSector,
+) -> tuple[tuple[int, int, tuple[int, ...]], ...] | None:
+    lines = tuple(sector.open_color_lines)
+    word = tuple(int(label) for label in sector.color_words[0])
+    remaining = list(lines)
+    order: list[tuple[int, int, tuple[int, ...]]] = []
+    offset = 0
+    while offset < len(word):
+        matching = [
+            line
+            for line in remaining
+            if word[offset : offset + len(line.coloured_labels)] == line.coloured_labels
+        ]
+        if len(matching) != 1:
+            return None
+        line = matching[0]
+        order.append(
+            (
+                int(line.fundamental_label),
+                int(line.antifundamental_label),
+                tuple(int(label) for label in line.singlet_labels),
+            )
+        )
+        offset += len(line.coloured_labels)
+        remaining.remove(line)
+    if remaining:
+        return None
+    return tuple(order)
+
+
+def _validated_sector_owner_map(
+    color_plan: GenericColorPlan,
+    sector_owner_ids: Sequence[int] | None,
+) -> tuple[int, ...]:
+    sector_count = len(color_plan.sectors)
+    owners = (
+        tuple(range(sector_count))
+        if sector_owner_ids is None
+        else tuple(int(value) for value in sector_owner_ids)
+    )
+    if len(owners) != sector_count:
+        raise ValueError("symmetric-group sector owner map has the wrong size")
+    for sector_id, owner_id in enumerate(owners):
+        if owner_id == _ZERO_SECTOR_OWNER:
+            continue
+        if owner_id < 0 or owner_id >= sector_count:
+            raise ValueError("symmetric-group sector owner map is out of bounds")
+        if owners[owner_id] != owner_id:
+            raise ValueError("symmetric-group sector owner map is not idempotent")
+        if owner_id > sector_id:
+            raise ValueError("symmetric-group sector owner is not minimal")
+    return owners
+
+
+def _validate_owner_structures(
+    color_plan: GenericColorPlan,
+    owners: tuple[int, ...],
+) -> None:
+    sectors_by_id = {int(sector.id): sector for sector in color_plan.sectors}
+    if set(sectors_by_id) != set(range(len(color_plan.sectors))):
+        raise ValueError("symmetric-group color sectors are not densely numbered")
+    for sector_id, owner_id in enumerate(owners):
+        if owner_id == _ZERO_SECTOR_OWNER:
+            continue
+        if _owner_tensor_key(sectors_by_id[sector_id]) != _owner_tensor_key(
+            sectors_by_id[owner_id]
+        ):
+            raise ValueError(
+                "symmetric-group sector owner changes the canonical color tensor"
+            )
+
+
+def _owner_tensor_key(sector: LCColorSector) -> tuple[object, ...]:
+    if sector.kind == "open-lines":
+        return (
+            "open-lines",
+            tuple(
+                sorted(
+                    (
+                        int(line.fundamental_label),
+                        tuple(int(label) for label in line.adjoint_labels),
+                        int(line.antifundamental_label),
+                        tuple(int(label) for label in line.singlet_labels),
+                    )
+                    for line in sector.open_color_lines
+                )
+            ),
+            tuple(int(label) for label in sector.singlet_labels),
+        )
+    if sector.kind == "single-trace":
+        return (
+            "single-trace",
+            tuple(int(label) for label in sector.trace_labels),
+            tuple(int(label) for label in sector.singlet_labels),
+        )
+    return (sector.kind, tuple(int(label) for label in sector.singlet_labels))
+
+
+def _relative_permutation(
+    left: tuple[int, ...],
+    right: tuple[int, ...],
+) -> tuple[int, ...]:
+    inverse = [0] * len(left)
+    for position, label in enumerate(left):
+        inverse[label] = position
+    return tuple(inverse[label] for label in right)
+
+
+def _inverse_permutation(permutation: tuple[int, ...]) -> tuple[int, ...]:
+    inverse = [0] * len(permutation)
+    for position, label in enumerate(permutation):
+        inverse[label] = position
+    return tuple(inverse)
+
+
+def _single_trace_diagonal_kernel_representative(
+    permutation: tuple[int, ...],
+) -> tuple[int, ...]:
+    """Canonicalize one anchored trace under cyclic relabelling and inversion."""
+
+    trace_length = len(permutation) + 1
+    anchored_word = (0, *(value + 1 for value in permutation))
+    candidates: list[tuple[int, ...]] = []
+    for shift in range(trace_length):
+        relabelled = tuple((value + shift) % trace_length for value in anchored_word)
+        anchor_index = relabelled.index(0)
+        rotated = relabelled[anchor_index:] + relabelled[:anchor_index]
+        coordinate = tuple(value - 1 for value in rotated[1:])
+        candidates.extend((coordinate, _inverse_permutation(coordinate)))
+    return min(candidates)
+
+
+def _hermiticity_relative_indices(
+    degree: int,
+    *,
+    channel_count: int,
+) -> tuple[int, ...]:
+    if channel_count < 2:
+        return ()
+    group_order = _symmetric_group_order(degree)
+    if degree <= 4:
+        return tuple(range(group_order))
+    samples: list[tuple[int, ...]] = [tuple(range(degree))]
+    for left_position in range(degree - 1):
+        adjacent = list(range(degree))
+        adjacent[left_position], adjacent[left_position + 1] = (
+            adjacent[left_position + 1],
+            adjacent[left_position],
+        )
+        samples.append(tuple(adjacent))
+    non_involution = list(range(degree))
+    non_involution[:3] = (1, 2, 0)
+    samples.append(tuple(non_involution))
+    return tuple(
+        dict.fromkeys(
+            _lexicographic_permutation_rank(sample, degree=degree) for sample in samples
+        )
+    )
+
+
+def _certify_cross_channel_hermiticity(
+    color_plan: GenericColorPlan,
+    partition: SymmetricGroupOrbitPartition,
+    *,
+    sector_by_id: dict[int, LCColorSector],
+    accuracy: str,
+    weight_fraction: Fraction,
+    kernel_exact_by_key: dict[tuple[int, int, int], Fraction],
+    relative_indices: tuple[int, ...],
+) -> None:
+    if not relative_indices:
+        return
+    inverse_indices = tuple(
+        (
+            relative_index,
+            _lexicographic_permutation_rank(
+                _inverse_permutation(
+                    _lexicographic_permutation_unrank(
+                        partition.degree,
+                        relative_index,
+                    )
+                ),
+                degree=partition.degree,
+            ),
+        )
+        for relative_index in relative_indices
+    )
+    for left_channel, left_orbit in enumerate(partition.orbits):
+        for right_channel in range(left_channel + 1, len(partition.orbits)):
+            right_orbit = partition.orbits[right_channel]
+            for relative_index, inverse_index in inverse_indices:
+                reverse = weight_fraction * exact_color_contraction_factor(
+                    color_plan,
+                    sector_by_id[right_orbit.sector_ids[0]],
+                    sector_by_id[left_orbit.sector_ids[inverse_index]],
+                    accuracy=accuracy,
+                    full_col_acc=20,
+                )
+                if (
+                    kernel_exact_by_key[(left_channel, right_channel, relative_index)]
+                    != reverse
+                ):
+                    raise ValueError(
+                        "symmetric-group cross-channel kernel failed its exact "
+                        "Hermiticity certificate"
+                    )
+
+
+def _certify_sampled_equivariance(
+    color_plan: GenericColorPlan,
+    partition: SymmetricGroupOrbitPartition,
+    *,
+    sector_by_id: dict[int, LCColorSector],
+    accuracy: str,
+    weight_fraction: Fraction,
+    kernel_exact_by_key: dict[tuple[int, int, int], Fraction],
+) -> None:
+    """Check exact samples of the structurally proved convolution identity.
+
+    Orbit discovery strips every permuted adjoint label to its rank while
+    retaining the complete non-adjoint trace/open-line skeleton.  A complete
+    coordinate bucket is therefore a bijective simultaneous relabelling by
+    ``S_m``.  Existing SU(3) contractions are invariant under that dummy-label
+    relabelling, which proves dependence on ``p^-1 q``.  These deterministic
+    non-identity samples guard the coordinate/composition implementation
+    without an ``O(channel_count**2 * |S_m|**2)`` dense certificate.
+    """
+
+    left_action = list(range(partition.degree))
+    left_action[0], left_action[1] = left_action[1], left_action[0]
+    left_action_tuple = tuple(left_action)
+    left_action_index = _lexicographic_permutation_rank(
+        left_action_tuple,
+        degree=partition.degree,
+    )
+    relative_indices = _equivariance_sample_indices(partition.degree)
+    right_indices = tuple(
+        (
+            relative_index,
+            _lexicographic_permutation_rank(
+                tuple(
+                    left_action_tuple[position]
+                    for position in _lexicographic_permutation_unrank(
+                        partition.degree,
+                        relative_index,
+                    )
+                ),
+                degree=partition.degree,
+            ),
+        )
+        for relative_index in relative_indices
+    )
+    for left_channel, left_orbit in enumerate(partition.orbits):
+        left_sector = sector_by_id[left_orbit.sector_ids[left_action_index]]
+        for right_channel in range(left_channel, len(partition.orbits)):
+            right_orbit = partition.orbits[right_channel]
+            for relative_index, right_permutation_index in right_indices:
+                exact = weight_fraction * exact_color_contraction_factor(
+                    color_plan,
+                    left_sector,
+                    sector_by_id[right_orbit.sector_ids[right_permutation_index]],
+                    accuracy=accuracy,
+                    full_col_acc=20,
+                )
+                if (
+                    kernel_exact_by_key[(left_channel, right_channel, relative_index)]
+                    != exact
+                ):
+                    raise ValueError(
+                        "symmetric-group kernel failed its exact sampled "
+                        "equivariance certificate"
+                    )
+
+
+def _equivariance_sample_indices(degree: int) -> tuple[int, ...]:
+    _symmetric_group_order(degree)
+    samples: list[tuple[int, ...]] = [tuple(range(degree))]
+    for left_position in range(degree - 1):
+        adjacent = list(range(degree))
+        adjacent[left_position], adjacent[left_position + 1] = (
+            adjacent[left_position + 1],
+            adjacent[left_position],
+        )
+        samples.append(tuple(adjacent))
+    if degree >= 3:
+        non_involution = list(range(degree))
+        non_involution[:3] = (1, 2, 0)
+        samples.append(tuple(non_involution))
+    return tuple(
+        dict.fromkeys(
+            _lexicographic_permutation_rank(sample, degree=degree) for sample in samples
+        )
+    )
+
+
+__all__ = [
+    "CertifiedSymmetricGroupOrbit",
+    "SymmetricGroupOrbitPartition",
+    "build_symmetric_group_color_contraction_plan",
+    "certify_symmetric_group_orbits",
+    "reconstruct_symmetric_group_dense_exact",
+]
diff --git a/pyamplicol/src/pyamplicol/config/__init__.py b/pyamplicol/src/pyamplicol/config/__init__.py
new file mode 100644
index 0000000000..11a48f1f43
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/config/__init__.py
@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from .errors import ConfigurationError, PyAmpliColError
+from .models import (
+    ACTIONS,
+    Action,
+    AutoBool,
+    AutoInt,
+    BenchmarkConfig,
+    ColorAccuracy,
+    ColorConfig,
+    ColorContraction,
+    ColorFFTBasis,
+    ColorMode,
+    CouplingOrderPolicy,
+    CppConfig,
+    EagerEvaluatorConfig,
+    EvaluationConfig,
+    EvaluatorBackend,
+    EvaluatorConfig,
+    EvaluatorExecutionMode,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationMode,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    LCFlowLayout,
+    LogLevel,
+    ModelConfig,
+    OutputConfig,
+    OutputFormat,
+    ProcessConfig,
+    ProcessEntry,
+    ProcessGroupAnalysis,
+    ProgressMode,
+    RecurrenceEvaluatorConfig,
+    RelationDiscoveryMode,
+    RunConfig,
+    SymbolicaConfig,
+)
+from .registry import (
+    CONFIG_SECTIONS,
+    FIELD_REGISTRY,
+    ConfigField,
+    get_config_field,
+)
+from .resolver import (
+    ClampRequest,
+    ConfigClamp,
+    ConfigOverride,
+    ConfigResolution,
+    config_to_dict,
+    config_to_toml,
+    load_config,
+    parse_override,
+    resolution_to_dict,
+    resolve_config,
+)
+
+__all__ = [
+    "ACTIONS",
+    "CONFIG_SECTIONS",
+    "FIELD_REGISTRY",
+    "Action",
+    "AutoBool",
+    "AutoInt",
+    "BenchmarkConfig",
+    "ClampRequest",
+    "ColorAccuracy",
+    "ColorConfig",
+    "ColorContraction",
+    "ColorFFTBasis",
+    "ColorMode",
+    "ConfigClamp",
+    "ConfigField",
+    "ConfigOverride",
+    "ConfigResolution",
+    "ConfigurationError",
+    "CouplingOrderPolicy",
+    "CppConfig",
+    "EagerEvaluatorConfig",
+    "EvaluationConfig",
+    "EvaluatorBackend",
+    "EvaluatorConfig",
+    "EvaluatorExecutionMode",
+    "EvaluatorOptimizationConfig",
+    "GenerationConfig",
+    "GenerationMode",
+    "GenerationRelationDiscoveryConfig",
+    "GenerationValidationConfig",
+    "JITConfig",
+    "LCFlowLayout",
+    "LogLevel",
+    "ModelConfig",
+    "OutputConfig",
+    "OutputFormat",
+    "ProcessConfig",
+    "ProcessEntry",
+    "ProcessGroupAnalysis",
+    "ProgressMode",
+    "PyAmpliColError",
+    "RecurrenceEvaluatorConfig",
+    "RelationDiscoveryMode",
+    "RunConfig",
+    "SymbolicaConfig",
+    "config_to_dict",
+    "config_to_toml",
+    "get_config_field",
+    "load_config",
+    "parse_override",
+    "resolution_to_dict",
+    "resolve_config",
+]
diff --git a/pyamplicol/src/pyamplicol/config/errors.py b/pyamplicol/src/pyamplicol/config/errors.py
new file mode 100644
index 0000000000..89dd51f3db
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/config/errors.py
@@ -0,0 +1,29 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+
+class PyAmpliColError(Exception):
+    """Base class for stable pyAmpliCol errors."""
+
+
+class ConfigurationError(PyAmpliColError, ValueError):
+    """Raised when configuration input violates schema version 1."""
+
+    def __init__(self, message: str | Iterable[str]) -> None:
+        messages = (message,) if isinstance(message, str) else tuple(message)
+        if not messages:
+            messages = ("invalid configuration",)
+        if not all(isinstance(entry, str) and entry for entry in messages):
+            raise TypeError("configuration error messages must be non-empty strings")
+        self.messages = messages
+        rendered = messages[0]
+        if len(messages) > 1:
+            rendered = f"{len(messages)} configuration errors:\n" + "\n".join(
+                f"- {entry}" for entry in messages
+            )
+        super().__init__(rendered)
+
+
+__all__ = ["ConfigurationError", "PyAmpliColError"]
diff --git a/pyamplicol/src/pyamplicol/config/models.py b/pyamplicol/src/pyamplicol/config/models.py
new file mode 100644
index 0000000000..40bc9719da
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/config/models.py
@@ -0,0 +1,1197 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+import os
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field, replace
+from enum import StrEnum
+from pathlib import Path
+from types import MappingProxyType
+from typing import Literal, TypeAlias, TypeVar
+
+from .errors import ConfigurationError
+
+
+class Action(StrEnum):
+    GENERATE = "generate"
+    EVALUATE = "evaluate"
+    BENCHMARK = "benchmark"
+    INSPECT = "inspect"
+    MODEL_INSPECT = "model-inspect"
+    MODEL_COMPILE = "model-compile"
+    MODEL_PROCESSES = "model-processes"
+    GROUP_PROCESSES = "group-processes"
+
+
+class CouplingOrderPolicy(StrEnum):
+    MINIMAL = "minimal"
+    EXPLICIT = "explicit"
+
+
+class ProcessGroupAnalysis(StrEnum):
+    NONE = "none"
+    NUMERICAL = "numerical"
+
+
+class ColorAccuracy(StrEnum):
+    LC = "lc"
+    NLC = "nlc"
+    FULL = "full"
+
+
+class ColorContraction(StrEnum):
+    AUTO = "auto"
+    DIRECT = "direct"
+    SYMMETRIC_GROUP_FFT = "symmetric-group-fft"
+
+
+class ColorFFTBasis(StrEnum):
+    TRACE = "trace"
+    ADJOINT = "adjoint"
+
+
+class LCFlowLayout(StrEnum):
+    TOPOLOGY_REPLAY = "topology-replay"
+    ALL_FLOW_UNION = "all-flow-union"
+
+
+class GenerationMode(StrEnum):
+    ERROR = "error"
+    APPEND = "append"
+    REPLACE = "replace"
+
+
+class RelationDiscoveryMode(StrEnum):
+    OFF = "off"
+    DIAGNOSTIC = "diagnostic"
+    CERTIFIED_REUSE = "certified-reuse"
+
+
+class EvaluatorBackend(StrEnum):
+    JIT = "jit"
+    ASM = "asm"
+    CPP = "cpp"
+
+
+class EvaluatorExecutionMode(StrEnum):
+    COMPILED = "compiled"
+    EAGER = "eager"
+    RECURRENCE = "recurrence"
+    ON_THE_FLY = "on-the-fly"
+
+
+_PORTABLE_CPP_EXTRA_FLAGS = frozenset({"-fno-math-errno"})
+_PROCESS_NAME = re.compile(r"^[A-Za-z][A-Za-z0-9_.-]*$")
+
+
+class OutputFormat(StrEnum):
+    HUMAN = "human"
+    JSON = "json"
+
+
+class ColorMode(StrEnum):
+    AUTO = "auto"
+    ALWAYS = "always"
+    NEVER = "never"
+
+
+class ProgressMode(StrEnum):
+    AUTO = "auto"
+    TTY = "tty"
+    LOG = "log"
+    OFF = "off"
+
+
+class LogLevel(StrEnum):
+    DEBUG = "debug"
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+
+
+AutoInt: TypeAlias = Literal["auto"] | int
+AutoBool: TypeAlias = Literal["auto"] | bool
+
+ACTIONS: tuple[Action, ...] = tuple(Action)
+
+_T = TypeVar("_T")
+_EnumT = TypeVar("_EnumT", bound=StrEnum)
+
+
+def _setting(
+    kind: str,
+    *,
+    nullable: bool = False,
+    choices: Sequence[object] = (),
+    dynamic_kind: str | None = None,
+) -> dict[str, object]:
+    return {
+        "config": {
+            "kind": kind,
+            "nullable": nullable,
+            "choices": tuple(choices),
+            "dynamic_kind": dynamic_kind,
+        }
+    }
+
+
+def _section() -> dict[str, object]:
+    return {"config_section": True}
+
+
+def _path(value: os.PathLike[str] | str | None, name: str) -> Path | None:
+    if value is None:
+        return None
+    try:
+        return Path(os.fspath(value)).expanduser().resolve(strict=False)
+    except TypeError as exc:
+        raise ConfigurationError(f"{name} must be a path or null") from exc
+
+
+def _tuple_of_strings(value: Sequence[str], name: str) -> tuple[str, ...]:
+    if isinstance(value, (str, bytes)):
+        raise ConfigurationError(f"{name} must be a list of strings")
+    result = tuple(value)
+    if not all(isinstance(item, str) and item for item in result):
+        raise ConfigurationError(f"{name} must contain non-empty strings")
+    return result
+
+
+def _tuple_of_ints(value: Sequence[int], name: str) -> tuple[int, ...]:
+    if isinstance(value, (str, bytes)):
+        raise ConfigurationError(f"{name} must be a list of integers")
+    result = tuple(value)
+    if any(isinstance(item, bool) or not isinstance(item, int) for item in result):
+        raise ConfigurationError(f"{name} must contain integers")
+    return result
+
+
+def _string_tuple_mapping(
+    value: Mapping[str, Sequence[str]], name: str
+) -> Mapping[str, tuple[str, ...]]:
+    if not isinstance(value, Mapping):
+        raise ConfigurationError(f"{name} must be a table")
+    result: dict[str, tuple[str, ...]] = {}
+    for key, entries in value.items():
+        if not isinstance(key, str) or not key:
+            raise ConfigurationError(f"{name} keys must be non-empty strings")
+        result[key] = _tuple_of_strings(entries, f"{name}.{key}")
+    return MappingProxyType(result)
+
+
+def _integer_mapping(value: Mapping[str, int], name: str) -> Mapping[str, int]:
+    if not isinstance(value, Mapping):
+        raise ConfigurationError(f"{name} must be a table")
+    result: dict[str, int] = {}
+    for key, entry in value.items():
+        if not isinstance(key, str) or not key:
+            raise ConfigurationError(f"{name} keys must be non-empty strings")
+        if isinstance(entry, bool) or not isinstance(entry, int) or entry < 0:
+            raise ConfigurationError(f"{name}.{key} must be a non-negative integer")
+        result[key] = entry
+    return MappingProxyType(result)
+
+
+def _signed_integer_mapping(value: Mapping[str, int], name: str) -> Mapping[str, int]:
+    if not isinstance(value, Mapping):
+        raise ConfigurationError(f"{name} must be a table")
+    result: dict[str, int] = {}
+    for key, entry in value.items():
+        if not isinstance(key, str) or not key:
+            raise ConfigurationError(f"{name} keys must be non-empty strings")
+        if isinstance(entry, bool) or not isinstance(entry, int):
+            raise ConfigurationError(f"{name}.{key} must be an integer")
+        result[key] = entry
+    return MappingProxyType(result)
+
+
+def _choice(value: _T, choices: Sequence[_T], name: str) -> _T:
+    if value not in choices:
+        allowed = ", ".join(repr(item) for item in choices)
+        raise ConfigurationError(f"{name} must be one of {allowed}; got {value!r}")
+    return value
+
+
+def _enum(value: object, enum_type: type[_EnumT], name: str) -> _EnumT:
+    try:
+        if not isinstance(value, str):
+            raise TypeError
+        return enum_type(value)
+    except (TypeError, ValueError) as exc:
+        allowed = ", ".join(repr(item.value) for item in enum_type)
+        raise ConfigurationError(
+            f"{name} must be one of {allowed}; got {value!r}"
+        ) from exc
+
+
+def _integer(value: int, name: str, *, minimum: int = 1) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < minimum:
+        qualifier = "positive" if minimum == 1 else f">= {minimum}"
+        raise ConfigurationError(f"{name} must be an integer {qualifier}")
+    return value
+
+
+def _optional_integer(value: int | None, name: str, *, minimum: int = 0) -> int | None:
+    if value is None:
+        return None
+    return _integer(value, name, minimum=minimum)
+
+
+def _finite_float(
+    value: float, name: str, *, minimum: float, exclusive: bool = False
+) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ConfigurationError(f"{name} must be a number")
+    result = float(value)
+    invalid = result <= minimum if exclusive else result < minimum
+    if not math.isfinite(result) or invalid:
+        operator = ">" if exclusive else ">="
+        raise ConfigurationError(f"{name} must be finite and {operator} {minimum}")
+    return result
+
+
+def _auto_integer(value: AutoInt, name: str) -> AutoInt:
+    if value == "auto":
+        return value
+    return _integer(value, name)
+
+
+def _auto_bool(value: AutoBool, name: str) -> AutoBool:
+    if value == "auto" or isinstance(value, bool):
+        return value
+    raise ConfigurationError(f"{name} must be 'auto', true, or false")
+
+
+@dataclass(frozen=True, slots=True)
+class ModelConfig:
+    source: str = field(default="built-in-sm", metadata=_setting("str"))
+    restriction: str | None = field(
+        default=None, metadata=_setting("str", nullable=True)
+    )
+    simplify: bool = field(default=True, metadata=_setting("bool"))
+    cache: bool = field(default=True, metadata=_setting("bool"))
+    cache_dir: Path | None = field(
+        default=None, metadata=_setting("path", nullable=True)
+    )
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.source, str) or not self.source:
+            raise ConfigurationError("model.source must be a non-empty string")
+        if self.restriction is not None and not isinstance(self.restriction, str):
+            raise ConfigurationError("model.restriction must be a string or null")
+        if not isinstance(self.simplify, bool):
+            raise ConfigurationError("model.simplify must be a boolean")
+        if not isinstance(self.cache, bool):
+            raise ConfigurationError("model.cache must be a boolean")
+        object.__setattr__(self, "cache_dir", _path(self.cache_dir, "model.cache_dir"))
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessEntry:
+    expression: str
+    name: str | None = None
+
+    def __post_init__(self) -> None:
+        errors: list[str] = []
+        if not isinstance(self.expression, str) or not self.expression.strip():
+            errors.append("process entry expression must be a non-empty string")
+        elif "\n" in self.expression or "\r" in self.expression:
+            errors.append("process entry expression must contain exactly one line")
+        if self.name is not None and (
+            not isinstance(self.name, str) or not _PROCESS_NAME.fullmatch(self.name)
+        ):
+            errors.append(
+                "process entry name must start with a letter and contain only "
+                "letters, digits, '.', '_', or '-'"
+            )
+        if errors:
+            raise ConfigurationError(errors)
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessConfig:
+    entries: tuple[ProcessEntry, ...] = field(
+        default=(), metadata=_setting("process_entries")
+    )
+    multiparticles: Mapping[str, tuple[str, ...]] = field(
+        default_factory=dict,
+        metadata=_setting("map_list_str", dynamic_kind="list_str"),
+    )
+    flavor_scheme: int = field(default=5, metadata=_setting("int"))
+    max_quark_lines: int | None = field(
+        default=None, metadata=_setting("int", nullable=True)
+    )
+    coupling_order_policy: CouplingOrderPolicy = field(
+        default=CouplingOrderPolicy.MINIMAL,
+        metadata=_setting("str", choices=tuple(CouplingOrderPolicy)),
+    )
+    max_coupling_orders: Mapping[str, int] = field(
+        default_factory=dict,
+        metadata=_setting("map_int", dynamic_kind="int"),
+    )
+    max_color_sectors: int | None = field(
+        default=None, metadata=_setting("int", nullable=True)
+    )
+    reference_color_order: tuple[int, ...] = field(
+        default=(), metadata=_setting("list_int")
+    )
+    selected_color_sector_ids: tuple[int, ...] = field(
+        default=(), metadata=_setting("list_int")
+    )
+    selected_source_helicities: Mapping[str, int] = field(
+        default_factory=dict,
+        metadata=_setting("map_int", dynamic_kind="int"),
+    )
+    flavor_blind: bool = field(default=False, metadata=_setting("bool"))
+    consider_charge_conjugation: bool = field(default=True, metadata=_setting("bool"))
+    only_unit_multiplier: bool = field(default=False, metadata=_setting("bool"))
+    analyze_process_groups: ProcessGroupAnalysis = field(
+        default=ProcessGroupAnalysis.NONE,
+        metadata=_setting("str", choices=tuple(ProcessGroupAnalysis)),
+    )
+
+    def __post_init__(self) -> None:
+        if isinstance(self.entries, (str, bytes)):
+            raise ConfigurationError(
+                "process.entries must be a list of process entries"
+            )
+        entries = tuple(self.entries)
+        if not all(isinstance(entry, ProcessEntry) for entry in entries):
+            raise ConfigurationError(
+                "process.entries must contain ProcessEntry objects"
+            )
+        names = tuple(entry.name for entry in entries if entry.name is not None)
+        duplicate_names = sorted(name for name in set(names) if names.count(name) > 1)
+        if duplicate_names:
+            raise ConfigurationError(
+                "process entry names must be unique; duplicates: "
+                + ", ".join(repr(name) for name in duplicate_names)
+            )
+        object.__setattr__(self, "entries", entries)
+        object.__setattr__(
+            self,
+            "multiparticles",
+            _string_tuple_mapping(self.multiparticles, "process.multiparticles"),
+        )
+        object.__setattr__(
+            self,
+            "flavor_scheme",
+            _integer(self.flavor_scheme, "process.flavor_scheme", minimum=0),
+        )
+        object.__setattr__(
+            self,
+            "max_quark_lines",
+            _optional_integer(
+                self.max_quark_lines, "process.max_quark_lines", minimum=0
+            ),
+        )
+        object.__setattr__(
+            self,
+            "coupling_order_policy",
+            _enum(
+                self.coupling_order_policy,
+                CouplingOrderPolicy,
+                "process.coupling_order_policy",
+            ),
+        )
+        object.__setattr__(
+            self,
+            "max_coupling_orders",
+            _integer_mapping(self.max_coupling_orders, "process.max_coupling_orders"),
+        )
+        object.__setattr__(
+            self,
+            "max_color_sectors",
+            _optional_integer(
+                self.max_color_sectors, "process.max_color_sectors", minimum=0
+            ),
+        )
+        object.__setattr__(
+            self,
+            "reference_color_order",
+            _tuple_of_ints(self.reference_color_order, "process.reference_color_order"),
+        )
+        object.__setattr__(
+            self,
+            "selected_color_sector_ids",
+            _tuple_of_ints(
+                self.selected_color_sector_ids,
+                "process.selected_color_sector_ids",
+            ),
+        )
+        object.__setattr__(
+            self,
+            "selected_source_helicities",
+            _signed_integer_mapping(
+                self.selected_source_helicities,
+                "process.selected_source_helicities",
+            ),
+        )
+        for name in (
+            "flavor_blind",
+            "consider_charge_conjugation",
+            "only_unit_multiplier",
+        ):
+            if not isinstance(getattr(self, name), bool):
+                raise ConfigurationError(f"process.{name} must be a boolean")
+        object.__setattr__(
+            self,
+            "analyze_process_groups",
+            _enum(
+                self.analyze_process_groups,
+                ProcessGroupAnalysis,
+                "process.analyze_process_groups",
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ColorConfig:
+    accuracy: ColorAccuracy = field(
+        default=ColorAccuracy.LC,
+        metadata=_setting("str", choices=tuple(ColorAccuracy)),
+    )
+    contraction: ColorContraction = field(
+        default=ColorContraction.AUTO,
+        metadata=_setting("str", choices=tuple(ColorContraction)),
+    )
+    lc_flow_layout: LCFlowLayout = field(
+        default=LCFlowLayout.TOPOLOGY_REPLAY,
+        metadata=_setting("str", choices=tuple(LCFlowLayout)),
+    )
+    fft_basis: ColorFFTBasis = field(
+        default=ColorFFTBasis.ADJOINT,
+        metadata=_setting("str", choices=tuple(ColorFFTBasis)),
+    )
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self, "accuracy", _enum(self.accuracy, ColorAccuracy, "color.accuracy")
+        )
+        object.__setattr__(
+            self,
+            "contraction",
+            _enum(
+                self.contraction,
+                ColorContraction,
+                "color.contraction",
+            ),
+        )
+        object.__setattr__(
+            self,
+            "fft_basis",
+            _enum(self.fft_basis, ColorFFTBasis, "color.fft_basis"),
+        )
+        object.__setattr__(
+            self,
+            "lc_flow_layout",
+            _enum(self.lc_flow_layout, LCFlowLayout, "color.lc_flow_layout"),
+        )
+        if (
+            self.lc_flow_layout is LCFlowLayout.ALL_FLOW_UNION
+            and self.accuracy is not ColorAccuracy.LC
+        ):
+            raise ConfigurationError(
+                "color.lc_flow_layout='all-flow-union' requires color.accuracy='lc'"
+            )
+        if (
+            self.contraction is ColorContraction.SYMMETRIC_GROUP_FFT
+            and self.accuracy is ColorAccuracy.LC
+        ):
+            raise ConfigurationError(
+                "color.contraction='symmetric-group-fft' requires "
+                "color.accuracy='nlc' or 'full'"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class GenerationValidationConfig:
+    enabled: bool = field(default=True, metadata=_setting("bool"))
+    samples: int = field(default=2, metadata=_setting("int"))
+    seed: int = field(default=12345, metadata=_setting("int"))
+    relative_tolerance: float = field(default=1e-12, metadata=_setting("float"))
+    absolute_tolerance: float = field(default=1e-300, metadata=_setting("float"))
+    post_build_validation: bool = field(default=False, metadata=_setting("bool"))
+
+    def __post_init__(self) -> None:
+        for name in (
+            "enabled",
+            "post_build_validation",
+        ):
+            if not isinstance(getattr(self, name), bool):
+                raise ConfigurationError(
+                    f"generation.validation.{name} must be a boolean"
+                )
+        object.__setattr__(
+            self,
+            "samples",
+            _integer(self.samples, "generation.validation.samples"),
+        )
+        object.__setattr__(
+            self,
+            "seed",
+            _integer(self.seed, "generation.validation.seed", minimum=0),
+        )
+        object.__setattr__(
+            self,
+            "relative_tolerance",
+            _finite_float(
+                self.relative_tolerance,
+                "generation.validation.relative_tolerance",
+                minimum=0.0,
+            ),
+        )
+        object.__setattr__(
+            self,
+            "absolute_tolerance",
+            _finite_float(
+                self.absolute_tolerance,
+                "generation.validation.absolute_tolerance",
+                minimum=0.0,
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class GenerationRelationDiscoveryConfig:
+    """Opt-in, replayable current-relation discovery policy (off by default)."""
+
+    mode: RelationDiscoveryMode = field(
+        default=RelationDiscoveryMode.OFF,
+        metadata=_setting("str", choices=tuple(RelationDiscoveryMode)),
+    )
+    precision_digits: int = field(default=96, metadata=_setting("int"))
+    probe_count: int = field(default=4, metadata=_setting("int"))
+    verification_probe_count: int = field(default=4, metadata=_setting("int"))
+    relative_tolerance: float = field(default=1.0e-70, metadata=_setting("float"))
+    absolute_tolerance: float = field(default=1.0e-80, metadata=_setting("float"))
+    seed: int = field(default=0x5059414D, metadata=_setting("int"))
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "mode",
+            _enum(
+                self.mode,
+                RelationDiscoveryMode,
+                "generation.relation_discovery.mode",
+            ),
+        )
+        object.__setattr__(
+            self,
+            "precision_digits",
+            _integer(
+                self.precision_digits,
+                "generation.relation_discovery.precision_digits",
+                minimum=80,
+            ),
+        )
+        object.__setattr__(
+            self,
+            "probe_count",
+            _integer(
+                self.probe_count,
+                "generation.relation_discovery.probe_count",
+                minimum=2,
+            ),
+        )
+        object.__setattr__(
+            self,
+            "verification_probe_count",
+            _integer(
+                self.verification_probe_count,
+                "generation.relation_discovery.verification_probe_count",
+                minimum=2,
+            ),
+        )
+        object.__setattr__(
+            self,
+            "relative_tolerance",
+            _finite_float(
+                self.relative_tolerance,
+                "generation.relation_discovery.relative_tolerance",
+                minimum=0.0,
+            ),
+        )
+        object.__setattr__(
+            self,
+            "absolute_tolerance",
+            _finite_float(
+                self.absolute_tolerance,
+                "generation.relation_discovery.absolute_tolerance",
+                minimum=0.0,
+            ),
+        )
+        if any(
+            value == 0.0 and math.copysign(1.0, value) < 0.0
+            for value in (self.relative_tolerance, self.absolute_tolerance)
+        ):
+            raise ConfigurationError(
+                "generation.relation_discovery tolerances cannot use negative zero"
+            )
+        if self.relative_tolerance == 0.0 and self.absolute_tolerance == 0.0:
+            raise ConfigurationError(
+                "generation.relation_discovery tolerances cannot both be zero"
+            )
+        object.__setattr__(
+            self,
+            "seed",
+            _integer(
+                self.seed,
+                "generation.relation_discovery.seed",
+                minimum=0,
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class GenerationConfig:
+    output: Path | None = field(default=None, metadata=_setting("path", nullable=True))
+    mode: GenerationMode = field(
+        default=GenerationMode.ERROR,
+        metadata=_setting("str", choices=tuple(GenerationMode)),
+    )
+    workers: AutoInt = field(default="auto", metadata=_setting("auto_int"))
+    emit_api_bundle: bool = field(default=True, metadata=_setting("bool"))
+    validation: GenerationValidationConfig = field(
+        default_factory=GenerationValidationConfig, metadata=_section()
+    )
+    relation_discovery: GenerationRelationDiscoveryConfig = field(
+        default_factory=GenerationRelationDiscoveryConfig,
+        metadata=_section(),
+    )
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "output", _path(self.output, "generation.output"))
+        object.__setattr__(
+            self, "mode", _enum(self.mode, GenerationMode, "generation.mode")
+        )
+        object.__setattr__(
+            self, "workers", _auto_integer(self.workers, "generation.workers")
+        )
+        if not isinstance(self.emit_api_bundle, bool):
+            raise ConfigurationError("generation.emit_api_bundle must be a boolean")
+        if not isinstance(self.validation, GenerationValidationConfig):
+            raise ConfigurationError(
+                "generation.validation must be a GenerationValidationConfig"
+            )
+        if not isinstance(
+            self.relation_discovery,
+            GenerationRelationDiscoveryConfig,
+        ):
+            raise ConfigurationError(
+                "generation.relation_discovery must be a "
+                "GenerationRelationDiscoveryConfig"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class EvaluatorOptimizationConfig:
+    horner_iterations: int = field(default=10, metadata=_setting("int"))
+    cpe_iterations: int | None = field(
+        default=None, metadata=_setting("int", nullable=True)
+    )
+    cores: AutoInt = field(default="auto", metadata=_setting("auto_int"))
+    max_horner_variables: int = field(default=1000, metadata=_setting("int"))
+    max_common_pair_cache_entries: int = field(
+        default=5_000_000, metadata=_setting("int")
+    )
+    max_common_pair_distance: int = field(default=1000, metadata=_setting("int"))
+    collect_factors: AutoBool = field(default="auto", metadata=_setting("auto_bool"))
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "horner_iterations",
+            _integer(
+                self.horner_iterations,
+                "evaluator.optimization.horner_iterations",
+                minimum=0,
+            ),
+        )
+        object.__setattr__(
+            self,
+            "cpe_iterations",
+            _optional_integer(
+                self.cpe_iterations,
+                "evaluator.optimization.cpe_iterations",
+                minimum=0,
+            ),
+        )
+        object.__setattr__(
+            self,
+            "cores",
+            _auto_integer(self.cores, "evaluator.optimization.cores"),
+        )
+        for name in (
+            "max_horner_variables",
+            "max_common_pair_cache_entries",
+            "max_common_pair_distance",
+        ):
+            object.__setattr__(
+                self,
+                name,
+                _integer(
+                    getattr(self, name),
+                    f"evaluator.optimization.{name}",
+                    minimum=0,
+                ),
+            )
+        object.__setattr__(
+            self,
+            "collect_factors",
+            _auto_bool(self.collect_factors, "evaluator.optimization.collect_factors"),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class JITConfig:
+    optimization_level: Literal[0, 1, 2, 3] = field(
+        default=2, metadata=_setting("int", choices=(0, 1, 2, 3))
+    )
+    compress: AutoBool = field(default="auto", metadata=_setting("auto_bool"))
+
+    def __post_init__(self) -> None:
+        if isinstance(self.optimization_level, bool) or not isinstance(
+            self.optimization_level, int
+        ):
+            raise ConfigurationError(
+                "evaluator.jit.optimization_level must be an integer"
+            )
+        _choice(
+            self.optimization_level,
+            (0, 1, 2, 3),
+            "evaluator.jit.optimization_level",
+        )
+        object.__setattr__(
+            self,
+            "compress",
+            _auto_bool(self.compress, "evaluator.jit.compress"),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class CppConfig:
+    optimization: str = field(default="O3", metadata=_setting("str"))
+    compiler: str | None = field(default=None, metadata=_setting("str", nullable=True))
+    native_arch: bool = field(default=False, metadata=_setting("bool"))
+    extra_flags: tuple[str, ...] = field(default=(), metadata=_setting("list_str"))
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.optimization, str) or not self.optimization:
+            raise ConfigurationError(
+                "evaluator.cpp.optimization must be a non-empty string"
+            )
+        if self.compiler is not None and not isinstance(self.compiler, str):
+            raise ConfigurationError("evaluator.cpp.compiler must be a string or null")
+        if not isinstance(self.native_arch, bool):
+            raise ConfigurationError("evaluator.cpp.native_arch must be a boolean")
+        extra_flags = _tuple_of_strings(self.extra_flags, "evaluator.cpp.extra_flags")
+        unsupported = tuple(
+            flag for flag in extra_flags if flag not in _PORTABLE_CPP_EXTRA_FLAGS
+        )
+        if unsupported:
+            rendered = ", ".join(repr(flag) for flag in unsupported)
+            allowed = ", ".join(sorted(_PORTABLE_CPP_EXTRA_FLAGS))
+            raise ConfigurationError(
+                "evaluator.cpp.extra_flags contains unsupported compiler arguments "
+                f"({rendered}); arbitrary flags may introduce unrecorded target CPU "
+                f"requirements. Allowed portable flags: {allowed}"
+            )
+        object.__setattr__(self, "extra_flags", extra_flags)
+
+
+@dataclass(frozen=True, slots=True)
+class EagerEvaluatorConfig:
+    point_tile_size: int = field(default=1024, metadata=_setting("int"))
+    # Soft batching target, not a cap on the workspace needed by one point.
+    workspace_mib: int = field(default=256, metadata=_setting("int"))
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "point_tile_size",
+            _integer(
+                self.point_tile_size,
+                "evaluator.eager.point_tile_size",
+                minimum=1,
+            ),
+        )
+        object.__setattr__(
+            self,
+            "workspace_mib",
+            _integer(
+                self.workspace_mib,
+                "evaluator.eager.workspace_mib",
+                minimum=1,
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceEvaluatorConfig:
+    point_tile_size: int = field(default=1024, metadata=_setting("int"))
+    # Soft batching target, not a cap on the workspace needed by one point.
+    workspace_mib: int = field(default=256, metadata=_setting("int"))
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "point_tile_size",
+            _integer(
+                self.point_tile_size,
+                "evaluator.recurrence.point_tile_size",
+                minimum=1,
+            ),
+        )
+        object.__setattr__(
+            self,
+            "workspace_mib",
+            _integer(
+                self.workspace_mib,
+                "evaluator.recurrence.workspace_mib",
+                minimum=1,
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class EvaluatorConfig:
+    backend: EvaluatorBackend = field(
+        default=EvaluatorBackend.JIT,
+        metadata=_setting("str", choices=tuple(EvaluatorBackend)),
+    )
+    execution_mode: EvaluatorExecutionMode = field(
+        default=EvaluatorExecutionMode.RECURRENCE,
+        metadata=_setting("str", choices=tuple(EvaluatorExecutionMode)),
+    )
+    batch_size: int = field(default=128, metadata=_setting("int"))
+    output_chunk_size: int | None = field(
+        default=512, metadata=_setting("int", nullable=True)
+    )
+    optimization: EvaluatorOptimizationConfig = field(
+        default_factory=EvaluatorOptimizationConfig, metadata=_section()
+    )
+    jit: JITConfig = field(default_factory=JITConfig, metadata=_section())
+    cpp: CppConfig = field(default_factory=CppConfig, metadata=_section())
+    eager: EagerEvaluatorConfig = field(
+        default_factory=EagerEvaluatorConfig, metadata=_section()
+    )
+    recurrence: RecurrenceEvaluatorConfig = field(
+        default_factory=RecurrenceEvaluatorConfig, metadata=_section()
+    )
+
+    @property
+    def resolved_jit_compress(self) -> bool:
+        """Use compressed code for compiled O2, preserving explicit choices."""
+
+        if self.jit.compress != "auto":
+            return self.jit.compress
+        return (
+            self.backend is EvaluatorBackend.JIT
+            and self.execution_mode is EvaluatorExecutionMode.COMPILED
+            and self.jit.optimization_level == 2
+        )
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "backend",
+            _enum(self.backend, EvaluatorBackend, "evaluator.backend"),
+        )
+        object.__setattr__(
+            self,
+            "execution_mode",
+            _enum(
+                self.execution_mode,
+                EvaluatorExecutionMode,
+                "evaluator.execution_mode",
+            ),
+        )
+        object.__setattr__(
+            self, "batch_size", _integer(self.batch_size, "evaluator.batch_size")
+        )
+        object.__setattr__(
+            self,
+            "output_chunk_size",
+            _optional_integer(
+                self.output_chunk_size, "evaluator.output_chunk_size", minimum=1
+            ),
+        )
+        if not isinstance(self.optimization, EvaluatorOptimizationConfig):
+            raise ConfigurationError(
+                "evaluator.optimization must be an EvaluatorOptimizationConfig"
+            )
+        if not isinstance(self.jit, JITConfig):
+            raise ConfigurationError("evaluator.jit must be a JITConfig")
+        if not isinstance(self.cpp, CppConfig):
+            raise ConfigurationError("evaluator.cpp must be a CppConfig")
+        if not isinstance(self.eager, EagerEvaluatorConfig):
+            raise ConfigurationError("evaluator.eager must be an EagerEvaluatorConfig")
+        if not isinstance(self.recurrence, RecurrenceEvaluatorConfig):
+            raise ConfigurationError(
+                "evaluator.recurrence must be a RecurrenceEvaluatorConfig"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class EvaluationConfig:
+    artifact: Path | None = field(
+        default=None, metadata=_setting("path", nullable=True)
+    )
+    process: str | None = field(default=None, metadata=_setting("str", nullable=True))
+    precision: int = field(default=16, metadata=_setting("int"))
+    resolved: bool = field(default=False, metadata=_setting("bool"))
+    helicity_ids: tuple[str, ...] = field(default=(), metadata=_setting("list_str"))
+    color_flow_ids: tuple[str, ...] = field(default=(), metadata=_setting("list_str"))
+    model_parameters: Path | None = field(
+        default=None, metadata=_setting("path", nullable=True)
+    )
+    momenta: Path | None = field(default=None, metadata=_setting("path", nullable=True))
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self, "artifact", _path(self.artifact, "evaluation.artifact")
+        )
+        if self.process is not None and not isinstance(self.process, str):
+            raise ConfigurationError("evaluation.process must be a string or null")
+        object.__setattr__(
+            self, "precision", _integer(self.precision, "evaluation.precision")
+        )
+        if not isinstance(self.resolved, bool):
+            raise ConfigurationError("evaluation.resolved must be a boolean")
+        object.__setattr__(
+            self,
+            "helicity_ids",
+            _tuple_of_strings(self.helicity_ids, "evaluation.helicity_ids"),
+        )
+        object.__setattr__(
+            self,
+            "color_flow_ids",
+            _tuple_of_strings(self.color_flow_ids, "evaluation.color_flow_ids"),
+        )
+        object.__setattr__(
+            self,
+            "model_parameters",
+            _path(self.model_parameters, "evaluation.model_parameters"),
+        )
+        object.__setattr__(self, "momenta", _path(self.momenta, "evaluation.momenta"))
+
+
+@dataclass(frozen=True, slots=True)
+class BenchmarkConfig:
+    target_runtime: float = field(default=10.0, metadata=_setting("float"))
+    batch_size: int = field(default=128, metadata=_setting("int"))
+    precision: int = field(default=16, metadata=_setting("int"))
+    warmup_runs: int = field(default=2, metadata=_setting("int"))
+    minimum_samples: int = field(default=5, metadata=_setting("int"))
+    helicity_ids: tuple[str, ...] = field(default=(), metadata=_setting("list_str"))
+    color_flow_ids: tuple[str, ...] = field(default=(), metadata=_setting("list_str"))
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "target_runtime",
+            _finite_float(
+                self.target_runtime,
+                "benchmark.target_runtime",
+                minimum=0.0,
+                exclusive=True,
+            ),
+        )
+        object.__setattr__(
+            self, "batch_size", _integer(self.batch_size, "benchmark.batch_size")
+        )
+        object.__setattr__(
+            self, "precision", _integer(self.precision, "benchmark.precision")
+        )
+        object.__setattr__(
+            self,
+            "warmup_runs",
+            _integer(self.warmup_runs, "benchmark.warmup_runs", minimum=0),
+        )
+        object.__setattr__(
+            self,
+            "minimum_samples",
+            _integer(self.minimum_samples, "benchmark.minimum_samples"),
+        )
+        object.__setattr__(
+            self,
+            "helicity_ids",
+            _tuple_of_strings(self.helicity_ids, "benchmark.helicity_ids"),
+        )
+        object.__setattr__(
+            self,
+            "color_flow_ids",
+            _tuple_of_strings(self.color_flow_ids, "benchmark.color_flow_ids"),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class OutputConfig:
+    format: OutputFormat = field(
+        default=OutputFormat.HUMAN,
+        metadata=_setting("str", choices=tuple(OutputFormat)),
+    )
+    color: ColorMode = field(
+        default=ColorMode.AUTO,
+        metadata=_setting("str", choices=tuple(ColorMode)),
+    )
+    progress: ProgressMode = field(
+        default=ProgressMode.AUTO,
+        metadata=_setting("str", choices=tuple(ProgressMode)),
+    )
+    log_level: LogLevel = field(
+        default=LogLevel.INFO,
+        metadata=_setting("str", choices=tuple(LogLevel)),
+    )
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self, "format", _enum(self.format, OutputFormat, "output.format")
+        )
+        object.__setattr__(self, "color", _enum(self.color, ColorMode, "output.color"))
+        object.__setattr__(
+            self, "progress", _enum(self.progress, ProgressMode, "output.progress")
+        )
+        object.__setattr__(
+            self, "log_level", _enum(self.log_level, LogLevel, "output.log_level")
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class SymbolicaConfig:
+    suggest_license: bool = field(default=True, metadata=_setting("bool"))
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.suggest_license, bool):
+            raise ConfigurationError("symbolica.suggest_license must be a boolean")
+
+
+@dataclass(frozen=True, slots=True)
+class RunConfig:
+    action: Action = field(metadata=_setting("str", choices=ACTIONS))
+    schema_version: int = field(default=1, metadata=_setting("int", choices=(1,)))
+    model: ModelConfig = field(default_factory=ModelConfig, metadata=_section())
+    process: ProcessConfig = field(default_factory=ProcessConfig, metadata=_section())
+    color: ColorConfig = field(default_factory=ColorConfig, metadata=_section())
+    generation: GenerationConfig = field(
+        default_factory=GenerationConfig, metadata=_section()
+    )
+    evaluator: EvaluatorConfig = field(
+        default_factory=EvaluatorConfig, metadata=_section()
+    )
+    evaluation: EvaluationConfig = field(
+        default_factory=EvaluationConfig, metadata=_section()
+    )
+    benchmark: BenchmarkConfig = field(
+        default_factory=BenchmarkConfig, metadata=_section()
+    )
+    output: OutputConfig = field(default_factory=OutputConfig, metadata=_section())
+    symbolica: SymbolicaConfig = field(
+        default_factory=SymbolicaConfig, metadata=_section()
+    )
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "action", _enum(self.action, Action, "action"))
+        if isinstance(self.schema_version, bool) or not isinstance(
+            self.schema_version, int
+        ):
+            raise ConfigurationError("schema_version must be an integer")
+        _choice(self.schema_version, (1,), "schema_version")
+        expected = (
+            ("model", ModelConfig),
+            ("process", ProcessConfig),
+            ("color", ColorConfig),
+            ("generation", GenerationConfig),
+            ("evaluator", EvaluatorConfig),
+            ("evaluation", EvaluationConfig),
+            ("benchmark", BenchmarkConfig),
+            ("output", OutputConfig),
+            ("symbolica", SymbolicaConfig),
+        )
+        for name, expected_type in expected:
+            if not isinstance(getattr(self, name), expected_type):
+                raise ConfigurationError(f"{name} must be a {expected_type.__name__}")
+        if (
+            self.color.contraction is ColorContraction.SYMMETRIC_GROUP_FFT
+            and self.evaluator.execution_mode
+            not in {
+                EvaluatorExecutionMode.RECURRENCE,
+                EvaluatorExecutionMode.ON_THE_FLY,
+            }
+        ):
+            raise ConfigurationError(
+                "color.contraction='symmetric-group-fft' requires "
+                "evaluator.execution_mode='recurrence' or 'on-the-fly'"
+            )
+
+    @property
+    def resolved_color(self) -> ColorConfig:
+        """Keep automatic FFT selection only in its supported execution lanes.
+
+        Eligible automatic requests stay automatic until the process-specific
+        colour plan can certify FFT support. An explicit direct request ignores
+        the FFT basis, including its adaptive default.
+        """
+
+        color = self.color
+        if color.contraction is ColorContraction.DIRECT or (
+            color.contraction is ColorContraction.AUTO
+            and (
+                color.accuracy is ColorAccuracy.LC
+                or self.evaluator.execution_mode
+                not in {
+                    EvaluatorExecutionMode.RECURRENCE,
+                    EvaluatorExecutionMode.ON_THE_FLY,
+                }
+            )
+        ):
+            return replace(
+                color,
+                contraction=ColorContraction.DIRECT,
+                fft_basis=ColorFFTBasis.TRACE,
+            )
+        return color
+
+
+__all__ = [
+    "ACTIONS",
+    "Action",
+    "AutoBool",
+    "AutoInt",
+    "BenchmarkConfig",
+    "ColorAccuracy",
+    "ColorConfig",
+    "ColorContraction",
+    "ColorFFTBasis",
+    "ColorMode",
+    "CouplingOrderPolicy",
+    "CppConfig",
+    "EagerEvaluatorConfig",
+    "EvaluationConfig",
+    "EvaluatorBackend",
+    "EvaluatorConfig",
+    "EvaluatorExecutionMode",
+    "EvaluatorOptimizationConfig",
+    "GenerationConfig",
+    "GenerationMode",
+    "GenerationRelationDiscoveryConfig",
+    "GenerationValidationConfig",
+    "JITConfig",
+    "LCFlowLayout",
+    "LogLevel",
+    "ModelConfig",
+    "OutputConfig",
+    "OutputFormat",
+    "ProcessConfig",
+    "ProcessEntry",
+    "ProcessGroupAnalysis",
+    "ProgressMode",
+    "RecurrenceEvaluatorConfig",
+    "RelationDiscoveryMode",
+    "RunConfig",
+    "SymbolicaConfig",
+]
diff --git a/pyamplicol/src/pyamplicol/config/registry.py b/pyamplicol/src/pyamplicol/config/registry.py
new file mode 100644
index 0000000000..0501669fa7
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/config/registry.py
@@ -0,0 +1,129 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import MISSING, dataclass, fields, is_dataclass
+from types import MappingProxyType
+from typing import cast, get_type_hints
+
+from .errors import ConfigurationError
+from .models import RunConfig
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigField:
+    """One schema-v1 leaf shared by TOML and command-line resolution."""
+
+    path: str
+    kind: str
+    nullable: bool = False
+    choices: tuple[object, ...] = ()
+    dynamic_kind: str | None = None
+    required: bool = False
+    default: object | None = None
+
+
+def _immutable_default(value: object) -> object:
+    if isinstance(value, Mapping):
+        return MappingProxyType(
+            {key: _immutable_default(entry) for key, entry in value.items()}
+        )
+    if isinstance(value, list):
+        return tuple(_immutable_default(entry) for entry in value)
+    return value
+
+
+def _build_registry(
+    cls: type[object], prefix: str = ""
+) -> tuple[dict[str, ConfigField], set[str]]:
+    if not is_dataclass(cls):
+        raise TypeError(f"{cls!r} is not a dataclass")
+    registry: dict[str, ConfigField] = {}
+    sections: set[str] = set()
+    hints = get_type_hints(cls)
+    for item in fields(cls):
+        path = f"{prefix}.{item.name}" if prefix else item.name
+        if item.metadata.get("config_section"):
+            sections.add(path)
+            child_registry, child_sections = _build_registry(hints[item.name], path)
+            registry.update(child_registry)
+            sections.update(child_sections)
+            continue
+
+        raw_spec = item.metadata.get("config")
+        if not isinstance(raw_spec, Mapping):
+            raise TypeError(f"configuration field {path!r} has no registry metadata")
+
+        required = item.default is MISSING and item.default_factory is MISSING
+        if required:
+            default: object | None = None
+        elif item.default is not MISSING:
+            default = item.default
+        else:
+            default_factory = cast(Callable[[], object], item.default_factory)
+            default = default_factory()
+        registry[path] = ConfigField(
+            path=path,
+            kind=str(raw_spec["kind"]),
+            nullable=bool(raw_spec.get("nullable", False)),
+            choices=tuple(raw_spec.get("choices", ())),
+            dynamic_kind=(
+                str(raw_spec["dynamic_kind"])
+                if raw_spec.get("dynamic_kind") is not None
+                else None
+            ),
+            required=required,
+            default=_immutable_default(default),
+        )
+    return registry, sections
+
+
+_REGISTRY, _SECTIONS = _build_registry(RunConfig)
+FIELD_REGISTRY: Mapping[str, ConfigField] = MappingProxyType(_REGISTRY)
+CONFIG_SECTIONS: tuple[str, ...] = tuple(sorted(_SECTIONS))
+
+
+def get_config_field(path: str) -> ConfigField:
+    """Return the exact or schema-approved dynamic field for a dotted path."""
+
+    if path in FIELD_REGISTRY:
+        return FIELD_REGISTRY[path]
+    for parent_path, item in FIELD_REGISTRY.items():
+        prefix = f"{parent_path}."
+        if item.dynamic_kind is not None and path.startswith(prefix):
+            key = path[len(prefix) :]
+            if key and "." not in key:
+                return ConfigField(
+                    path=path,
+                    kind=item.dynamic_kind,
+                    nullable=False,
+                    required=False,
+                )
+    raise ConfigurationError(f"unknown configuration field {path!r}")
+
+
+def default_values() -> dict[str, object]:
+    """Return a fresh flat mapping of every schema default."""
+
+    return {
+        path: _copy_default(item.default)
+        for path, item in FIELD_REGISTRY.items()
+        if not item.required
+    }
+
+
+def _copy_default(value: object) -> object:
+    if isinstance(value, Mapping):
+        return {key: _copy_default(entry) for key, entry in value.items()}
+    if isinstance(value, tuple):
+        return tuple(_copy_default(entry) for entry in value)
+    return value
+
+
+__all__ = [
+    "CONFIG_SECTIONS",
+    "FIELD_REGISTRY",
+    "ConfigField",
+    "default_values",
+    "get_config_field",
+]
diff --git a/pyamplicol/src/pyamplicol/config/resolver.py b/pyamplicol/src/pyamplicol/config/resolver.py
new file mode 100644
index 0000000000..b58e910b74
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/config/resolver.py
@@ -0,0 +1,632 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import difflib
+import os
+import tomllib
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass, fields, is_dataclass, replace
+from pathlib import Path
+from types import MappingProxyType
+from typing import Any, NoReturn, TypeVar, cast, get_type_hints
+
+from .errors import ConfigurationError
+from .models import Action, ProcessEntry, RunConfig
+from .registry import CONFIG_SECTIONS, FIELD_REGISTRY, ConfigField, default_values
+
+_DataclassT = TypeVar("_DataclassT")
+
+
+def _extend_errors(errors: list[str], error: ConfigurationError) -> None:
+    errors.extend(error.messages)
+
+
+def _raise_errors(errors: Sequence[str]) -> None:
+    if errors:
+        raise ConfigurationError(errors)
+
+
+def _freeze_public(value: object) -> object:
+    if isinstance(value, Mapping):
+        return MappingProxyType(
+            {str(key): _freeze_public(entry) for key, entry in value.items()}
+        )
+    if isinstance(value, (list, tuple)):
+        return tuple(_freeze_public(entry) for entry in value)
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigOverride:
+    path: str
+    value: object
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "value", _freeze_public(self.value))
+
+
+@dataclass(frozen=True, slots=True)
+class ClampRequest:
+    path: str
+    effective: object
+    reason: str
+
+    def __post_init__(self) -> None:
+        if not self.reason:
+            raise ConfigurationError("a clamp reason must not be empty")
+        object.__setattr__(self, "effective", _freeze_public(self.effective))
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigClamp:
+    path: str
+    requested: object
+    effective: object
+    reason: str
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "requested", _freeze_public(self.requested))
+        object.__setattr__(self, "effective", _freeze_public(self.effective))
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigResolution:
+    requested: RunConfig
+    effective: RunConfig
+    clamps: tuple[ConfigClamp, ...] = ()
+
+    @property
+    def was_clamped(self) -> bool:
+        return bool(self.clamps)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "clamps", tuple(self.clamps))
+
+
+def _field_for_path(path: str) -> tuple[ConfigField, str | None]:
+    exact = FIELD_REGISTRY.get(path)
+    if exact is not None:
+        return exact, None
+    for parent, item in FIELD_REGISTRY.items():
+        prefix = f"{parent}."
+        if item.dynamic_kind is not None and path.startswith(prefix):
+            dynamic_key = path[len(prefix) :]
+            if dynamic_key and "." not in dynamic_key:
+                return (
+                    ConfigField(path=path, kind=item.dynamic_kind),
+                    dynamic_key,
+                )
+    _unknown_field(path)
+
+
+def _unknown_field(path: str) -> NoReturn:
+    raise ConfigurationError(_unknown_field_message(path))
+
+
+def _unknown_field_message(path: str) -> str:
+    candidates = list(FIELD_REGISTRY)
+    suggestion = difflib.get_close_matches(path, candidates, n=1, cutoff=0.55)
+    suffix = f"; did you mean {suggestion[0]!r}?" if suggestion else ""
+    return f"unknown configuration field {path!r}{suffix}"
+
+
+def _is_section(path: str) -> bool:
+    return path in CONFIG_SECTIONS
+
+
+def _flatten_mapping(
+    value: Mapping[str, object],
+    *,
+    prefix: str = "",
+    _errors: list[str] | None = None,
+) -> dict[str, object]:
+    owns_errors = _errors is None
+    errors = [] if _errors is None else _errors
+    result: dict[str, object] = {}
+    for key, entry in value.items():
+        if not isinstance(key, str) or not key:
+            errors.append("configuration keys must be non-empty strings")
+            continue
+        path = f"{prefix}.{key}" if prefix else key
+        if path in FIELD_REGISTRY:
+            result[path] = entry
+            continue
+        if _is_section(path):
+            if not isinstance(entry, Mapping):
+                errors.append(f"configuration section {path!r} must be a table")
+                continue
+            result.update(_flatten_mapping(entry, prefix=path, _errors=errors))
+            continue
+        # Dotted dedicated inputs may address one dynamic map element directly.
+        try:
+            _spec, dynamic_key = _field_for_path(path)
+        except ConfigurationError as exc:
+            _extend_errors(errors, exc)
+            continue
+        if dynamic_key is None:
+            errors.append(_unknown_field_message(path))
+            continue
+        result[path] = entry
+    if owns_errors:
+        _raise_errors(errors)
+    return result
+
+
+def _normalize_dedicated(
+    value: Mapping[str, object], *, _errors: list[str]
+) -> dict[str, object]:
+    result: dict[str, object] = {}
+    nested: dict[str, object] = {}
+    for key, entry in value.items():
+        if "." in key:
+            result[key] = entry
+        else:
+            nested[key] = entry
+    if nested:
+        result.update(_flatten_mapping(nested, _errors=_errors))
+    return result
+
+
+def _resolve_path(value: object, base_dir: Path, path: str) -> Path:
+    if not isinstance(value, (str, os.PathLike)):
+        raise ConfigurationError(f"{path} must be a path")
+    candidate = Path(os.fspath(value)).expanduser()
+    if not candidate.is_absolute():
+        candidate = base_dir / candidate
+    return candidate.resolve(strict=False)
+
+
+def _coerce_process_entries(value: object, path: str) -> tuple[ProcessEntry, ...]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise ConfigurationError(f"{path} must be a list of process entry tables")
+
+    entries: list[ProcessEntry] = []
+    errors: list[str] = []
+    allowed_fields = ("expression", "name")
+    for index, raw_entry in enumerate(value):
+        entry_path = f"{path}[{index}]"
+        if isinstance(raw_entry, ProcessEntry):
+            entries.append(raw_entry)
+            continue
+        if not isinstance(raw_entry, Mapping):
+            errors.append(f"{entry_path} must be a table")
+            continue
+
+        for key in raw_entry:
+            if not isinstance(key, str) or not key:
+                errors.append(f"{entry_path} keys must be non-empty strings")
+                continue
+            if key not in allowed_fields:
+                suggestion = difflib.get_close_matches(
+                    key, allowed_fields, n=1, cutoff=0.55
+                )
+                suffix = f"; did you mean {suggestion[0]!r}?" if suggestion else ""
+                errors.append(
+                    f"unknown configuration field {entry_path}.{key!s}{suffix}"
+                )
+
+        try:
+            entries.append(
+                ProcessEntry(
+                    expression=cast(str, raw_entry.get("expression")),
+                    name=cast(str | None, raw_entry.get("name")),
+                )
+            )
+        except ConfigurationError as exc:
+            errors.extend(f"{entry_path}: {message}" for message in exc.messages)
+
+    _raise_errors(errors)
+    return tuple(entries)
+
+
+def _coerce(
+    item: ConfigField,
+    value: object,
+    *,
+    base_dir: Path,
+) -> object:
+    if value is None:
+        if item.nullable:
+            return None
+        raise ConfigurationError(f"{item.path} may not be null")
+
+    kind = item.kind
+    result: object
+    if kind == "str":
+        if not isinstance(value, str):
+            raise ConfigurationError(f"{item.path} must be a string")
+        if item.path == "model.source":
+            from .._internal.sm_heft import is_sm_heft_alias
+
+            if value in {"built-in-sm", "builtin_sm"} or is_sm_heft_alias(value):
+                result = value
+            else:
+                result = str(_resolve_path(value, base_dir, item.path))
+        else:
+            result = value
+    elif kind == "path":
+        result = _resolve_path(value, base_dir, item.path)
+    elif kind == "bool":
+        if not isinstance(value, bool):
+            raise ConfigurationError(f"{item.path} must be true or false")
+        result = value
+    elif kind == "int":
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise ConfigurationError(f"{item.path} must be an integer")
+        result = value
+    elif kind == "float":
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            raise ConfigurationError(f"{item.path} must be a number")
+        result = float(value)
+    elif kind == "auto_int":
+        if value == "auto":
+            result = value
+        elif isinstance(value, bool) or not isinstance(value, int):
+            raise ConfigurationError(f"{item.path} must be 'auto' or an integer")
+        else:
+            result = value
+    elif kind == "auto_bool":
+        if value == "auto" or isinstance(value, bool):
+            result = value
+        else:
+            raise ConfigurationError(f"{item.path} must be 'auto', true, or false")
+    elif kind == "list_str":
+        if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+            raise ConfigurationError(f"{item.path} must be a list of strings")
+        if not all(isinstance(entry, str) for entry in value):
+            raise ConfigurationError(f"{item.path} must be a list of strings")
+        result = tuple(cast(Sequence[str], value))
+    elif kind == "list_int":
+        if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+            raise ConfigurationError(f"{item.path} must be a list of integers")
+        if any(
+            isinstance(entry, bool) or not isinstance(entry, int) for entry in value
+        ):
+            raise ConfigurationError(f"{item.path} must be a list of integers")
+        result = tuple(cast(Sequence[int], value))
+    elif kind == "process_entries":
+        result = _coerce_process_entries(value, item.path)
+    elif kind in ("map_list_str", "map_int"):
+        if not isinstance(value, Mapping):
+            raise ConfigurationError(f"{item.path} must be a table")
+        dynamic_kind = "list_str" if kind == "map_list_str" else "int"
+        converted: dict[str, object] = {}
+        for key, entry in value.items():
+            if not isinstance(key, str) or not key:
+                raise ConfigurationError(f"{item.path} keys must be strings")
+            converted[key] = _coerce(
+                ConfigField(path=f"{item.path}.{key}", kind=dynamic_kind),
+                entry,
+                base_dir=base_dir,
+            )
+        result = converted
+    else:
+        raise AssertionError(f"unsupported configuration kind {kind!r}")
+
+    if item.choices and result not in item.choices:
+        allowed = ", ".join(repr(choice) for choice in item.choices)
+        raise ConfigurationError(
+            f"{item.path} must be one of {allowed}; got {result!r}"
+        )
+    return result
+
+
+def parse_override(
+    expression: str,
+    *,
+    base_dir: os.PathLike[str] | str | None = None,
+) -> ConfigOverride:
+    """Parse one schema-aware ``PATH=VALUE`` command-line override."""
+
+    if "=" not in expression:
+        raise ConfigurationError(
+            f"override {expression!r} must use dotted.path=value syntax"
+        )
+    raw_path, raw_value = expression.split("=", 1)
+    path = raw_path.strip()
+    if not path:
+        raise ConfigurationError("override path must not be empty")
+    item, _dynamic_key = _field_for_path(path)
+    value_text = raw_value.strip()
+    if not value_text:
+        raise ConfigurationError(f"override {path!r} has no value")
+
+    # A choice spelled "none" (process.analyze_process_groups) is not null.
+    if value_text.lower() in ("null", "none") and value_text not in item.choices:
+        parsed: object = None
+    else:
+        try:
+            parsed = tomllib.loads(f"value = {value_text}\n")["value"]
+        except tomllib.TOMLDecodeError as exc:
+            if item.kind not in ("str", "path", "auto_int", "auto_bool"):
+                raise ConfigurationError(
+                    f"invalid value for override {path!r}: {value_text!r}"
+                ) from exc
+            parsed = value_text
+
+    root = Path.cwd() if base_dir is None else Path(base_dir)
+    root = root.expanduser().resolve(strict=False)
+    return ConfigOverride(path, _coerce(item, parsed, base_dir=root))
+
+
+def _apply_value(values: dict[str, object], path: str, value: object) -> None:
+    _item, dynamic_key = _field_for_path(path)
+    if dynamic_key is None:
+        values[path] = value
+        return
+    parent_path = path.rsplit(".", 1)[0]
+    current = values.get(parent_path, {})
+    if not isinstance(current, Mapping):
+        raise ConfigurationError(f"{parent_path} must be a table")
+    updated = dict(current)
+    updated[dynamic_key] = value
+    values[parent_path] = updated
+
+
+def _coerce_flat(
+    raw: Mapping[str, object],
+    *,
+    base_dir: Path,
+    _errors: list[str] | None = None,
+) -> dict[str, object]:
+    owns_errors = _errors is None
+    errors = [] if _errors is None else _errors
+    result: dict[str, object] = {}
+    for path, value in raw.items():
+        try:
+            item, _dynamic_key = _field_for_path(path)
+            result[path] = _coerce(item, value, base_dir=base_dir)
+        except ConfigurationError as exc:
+            _extend_errors(errors, exc)
+    if owns_errors:
+        _raise_errors(errors)
+    return result
+
+
+def _build_dataclass(
+    cls: type[_DataclassT], prefix: str, values: Mapping[str, object]
+) -> _DataclassT:
+    kwargs: dict[str, object] = {}
+    errors: list[str] = []
+    hints = get_type_hints(cls)
+    for item in fields(cls):  # type: ignore[arg-type]
+        path = f"{prefix}.{item.name}" if prefix else item.name
+        if item.metadata.get("config_section"):
+            try:
+                kwargs[item.name] = _build_dataclass(hints[item.name], path, values)
+            except ConfigurationError as exc:
+                _extend_errors(errors, exc)
+        else:
+            if path not in values:
+                errors.append(f"missing required configuration field {path!r}")
+            else:
+                kwargs[item.name] = values[path]
+    _raise_errors(errors)
+    return cls(**kwargs)
+
+
+def _make_run_config(values: Mapping[str, object]) -> RunConfig:
+    return _build_dataclass(RunConfig, "", values)
+
+
+def _read_card(path: Path) -> Mapping[str, object]:
+    try:
+        with path.open("rb") as stream:
+            parsed = tomllib.load(stream)
+    except OSError as exc:
+        raise ConfigurationError(
+            f"cannot read configuration card {path}: {exc}"
+        ) from exc
+    except tomllib.TOMLDecodeError as exc:
+        raise ConfigurationError(f"invalid TOML in {path}: {exc}") from exc
+    return cast(Mapping[str, object], parsed)
+
+
+def resolve_config(
+    card: os.PathLike[str] | str | Mapping[str, object] | None = None,
+    *,
+    action: Action | None = None,
+    dedicated: Mapping[str, object] | None = None,
+    overrides: Iterable[str | ConfigOverride] = (),
+    clamps: Iterable[ClampRequest] = (),
+    base_dir: os.PathLike[str] | str | None = None,
+) -> ConfigResolution:
+    """Resolve schema-v1 configuration in its normative precedence order."""
+
+    if isinstance(card, Mapping):
+        raw_card = card
+        root = Path.cwd() if base_dir is None else Path(base_dir)
+        root = root.expanduser().resolve(strict=False)
+    elif card is not None:
+        card_path = Path(os.fspath(card)).expanduser().resolve(strict=False)
+        raw_card = _read_card(card_path)
+        root = card_path.parent
+    else:
+        raw_card = {}
+        root = Path.cwd() if base_dir is None else Path(base_dir)
+        root = root.expanduser().resolve(strict=False)
+
+    values = default_values()
+    card_errors: list[str] = []
+    card_fields = _flatten_mapping(raw_card, _errors=card_errors)
+    card_flat = _coerce_flat(card_fields, base_dir=root, _errors=card_errors)
+    _raise_errors(card_errors)
+    for path, value in card_flat.items():
+        _apply_value(values, path, value)
+
+    if action is not None:
+        action_item = FIELD_REGISTRY["action"]
+        _apply_value(values, "action", _coerce(action_item, action, base_dir=root))
+
+    if dedicated:
+        dedicated_errors: list[str] = []
+        dedicated_fields = _normalize_dedicated(dedicated, _errors=dedicated_errors)
+        dedicated_flat = _coerce_flat(
+            dedicated_fields, base_dir=root, _errors=dedicated_errors
+        )
+        _raise_errors(dedicated_errors)
+        for path, value in dedicated_flat.items():
+            _apply_value(values, path, value)
+
+    override_errors: list[str] = []
+    for raw_override in overrides:
+        try:
+            parsed_override = (
+                raw_override
+                if isinstance(raw_override, ConfigOverride)
+                else parse_override(raw_override, base_dir=root)
+            )
+            item, _dynamic_key = _field_for_path(parsed_override.path)
+            normalized = _coerce(item, parsed_override.value, base_dir=root)
+            _apply_value(values, parsed_override.path, normalized)
+        except ConfigurationError as exc:
+            _extend_errors(override_errors, exc)
+    _raise_errors(override_errors)
+
+    requested = _make_run_config(values)
+
+    effective_values = dict(values)
+    records: list[ConfigClamp] = []
+    clamp_errors: list[str] = []
+    for clamp in clamps:
+        try:
+            item, dynamic_key = _field_for_path(clamp.path)
+            effective_value = _coerce(item, clamp.effective, base_dir=root)
+            if dynamic_key is None:
+                requested_value = effective_values[clamp.path]
+            else:
+                parent = effective_values[clamp.path.rsplit(".", 1)[0]]
+                if not isinstance(parent, Mapping) or dynamic_key not in parent:
+                    raise ConfigurationError(
+                        f"cannot clamp missing configuration field {clamp.path!r}"
+                    )
+                requested_value = parent[dynamic_key]
+            _apply_value(effective_values, clamp.path, effective_value)
+            records.append(
+                ConfigClamp(
+                    path=clamp.path,
+                    requested=requested_value,
+                    effective=effective_value,
+                    reason=clamp.reason,
+                )
+            )
+        except ConfigurationError as exc:
+            _extend_errors(clamp_errors, exc)
+    _raise_errors(clamp_errors)
+
+    effective = _make_run_config(effective_values)
+    effective = replace(effective, color=effective.resolved_color)
+    if effective.evaluator.jit.compress == "auto":
+        effective = replace(
+            effective,
+            evaluator=replace(
+                effective.evaluator,
+                jit=replace(
+                    effective.evaluator.jit,
+                    compress=effective.evaluator.resolved_jit_compress,
+                ),
+            ),
+        )
+    return ConfigResolution(
+        requested=requested,
+        effective=effective,
+        clamps=tuple(records),
+    )
+
+
+def load_config(
+    card: os.PathLike[str] | str,
+    *,
+    dedicated: Mapping[str, object] | None = None,
+    overrides: Iterable[str | ConfigOverride] = (),
+    clamps: Iterable[ClampRequest] = (),
+) -> RunConfig:
+    """Load a card and return its effective immutable configuration."""
+
+    return resolve_config(
+        card,
+        dedicated=dedicated,
+        overrides=overrides,
+        clamps=clamps,
+    ).effective
+
+
+def config_to_dict(config: object) -> dict[str, object]:
+    """Convert a typed config to a stable JSON/TOML-friendly dictionary."""
+
+    if not is_dataclass(config):
+        raise TypeError("config_to_dict expects a configuration dataclass")
+    return cast(dict[str, object], _to_plain(config))
+
+
+def config_to_toml(config: object) -> str:
+    """Serialize one typed configuration as canonical reloadable TOML."""
+
+    try:
+        import tomli_w
+    except ImportError as exc:
+        raise ConfigurationError(
+            "TOML serialization requires the pyAmpliCol runtime dependency 'tomli-w'"
+        ) from exc
+    payload = cast(dict[str, Any], _without_none(config_to_dict(config)))
+    return tomli_w.dumps(payload)
+
+
+def resolution_to_dict(resolution: ConfigResolution) -> dict[str, object]:
+    """Return the requested/effective configuration and every resource clamp."""
+
+    if not isinstance(resolution, ConfigResolution):
+        raise TypeError("resolution_to_dict expects a ConfigResolution")
+    return {
+        "requested": config_to_dict(resolution.requested),
+        "effective": config_to_dict(resolution.effective),
+        "adjustments": [
+            {
+                "path": clamp.path,
+                "requested": _to_plain(clamp.requested),
+                "effective": _to_plain(clamp.effective),
+                "reason": clamp.reason,
+            }
+            for clamp in resolution.clamps
+        ],
+    }
+
+
+def _to_plain(value: object) -> object:
+    if is_dataclass(value) and not isinstance(value, type):
+        return {
+            item.name: _to_plain(getattr(value, item.name)) for item in fields(value)
+        }
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, Mapping):
+        return {str(key): _to_plain(entry) for key, entry in value.items()}
+    if isinstance(value, tuple):
+        return [_to_plain(entry) for entry in value]
+    return value
+
+
+def _without_none(value: object) -> object:
+    if isinstance(value, Mapping):
+        return {
+            str(key): _without_none(entry)
+            for key, entry in value.items()
+            if entry is not None
+        }
+    if isinstance(value, list):
+        return [_without_none(entry) for entry in value]
+    return value
+
+
+__all__ = [
+    "ClampRequest",
+    "ConfigClamp",
+    "ConfigOverride",
+    "ConfigResolution",
+    "config_to_dict",
+    "config_to_toml",
+    "load_config",
+    "parse_override",
+    "resolution_to_dict",
+    "resolve_config",
+]
diff --git a/pyamplicol/src/pyamplicol/correlators.py b/pyamplicol/src/pyamplicol/correlators.py
new file mode 100644
index 0000000000..132c1d5929
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/correlators.py
@@ -0,0 +1,275 @@
+# SPDX-License-Identifier: 0BSD
+"""Opt-in declarations for tree-level colour and spin correlations.
+
+Colour connections are ordered and use all-outgoing colour charges. External
+legs keep the process's one-based labels; negative labels are convenient for
+auxiliary emitted partons. These are colour operations, not additional external
+momenta. The ordinary Born colour metric is always available as ``"born"``.
+
+Spin classes declare the exact sets of vector legs that may be replaced
+simultaneously. Numerical vectors are supplied to the runtime, not generation.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, replace
+from decimal import Decimal
+from typing import cast
+
+from pyamplicol.color.connections import ColorLeg, EmitGluon, SplitGluon
+from pyamplicol.color.correlator_matrices import ColorCorrelator
+
+__all__ = [
+    "ColorCorrelator",
+    "CorrelatedRequest",
+    "CorrelatedValue",
+    "CorrelatorConfig",
+    "EmitGluon",
+    "SplitGluon",
+]
+
+
+@dataclass(frozen=True)
+class CorrelatedRequest:
+    """One labelled request passed to ``Runtime.evaluate_correlated_many``.
+
+    ``spin_vectors=None`` inherits the runtime setter's state at the start of
+    the call; ``{}`` selects ordinary physical helicities for this request.
+    Explicit maps use the setter's broadcast/per-point vector convention.
+    Decimal real components, or pairs of Decimal real/imaginary components,
+    retain their precision until the requested arithmetic is applied.
+    The runtime validates and copies all requests before numerical work.
+    """
+
+    color_correlation: str = "born"
+    spin_vectors: Mapping[int, object] | None = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.color_correlation, str) or not self.color_correlation:
+            raise ValueError("a correlated request requires a colour correlation ID")
+        if self.spin_vectors is not None and not isinstance(self.spin_vectors, Mapping):
+            raise TypeError("spin vectors must map public leg labels to vectors")
+
+
+@dataclass(frozen=True)
+class CorrelatedValue:
+    """One possibly complex correlation, retaining the requested precision.
+
+    ``real`` and ``imag`` are decimals. ``complex(value)`` converts to ordinary
+    double precision. Ordered colour connections need not give a real result;
+    their imaginary part must not be discarded before physical combinations.
+    """
+
+    real: Decimal
+    imag: Decimal = Decimal(0)
+
+    def __complex__(self) -> complex:
+        return complex(float(self.real), float(self.imag))
+
+
+def _fields(value: object, allowed: set[str], context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise TypeError(f"{context} must be an object")
+    unknown = set(value) - allowed
+    if unknown:
+        raise ValueError(f"unknown {context} fields: {sorted(unknown, key=str)}")
+    return value
+
+
+def _sequence(value: object, context: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise TypeError(f"{context} must be a list")
+    return value
+
+
+def _emission_from_json(value: object) -> EmitGluon | SplitGluon:
+    if not isinstance(value, Mapping):
+        raise TypeError("a colour connection step must be an object")
+    kind = value.get("kind")
+    if kind == "emit-gluon":
+        data = _fields(value, {"kind", "emitter", "emitted"}, "gluon emission")
+        try:
+            return EmitGluon(cast(int, data["emitter"]), cast(int, data["emitted"]))
+        except KeyError as exc:
+            raise ValueError(f"gluon emission is missing {exc.args[0]!r}") from exc
+    if kind == "split-gluon":
+        data = _fields(
+            value, {"kind", "parent", "quark", "antiquark"}, "gluon splitting"
+        )
+        try:
+            return SplitGluon(
+                cast(int, data["parent"]),
+                cast(int, data["quark"]),
+                cast(int, data["antiquark"]),
+            )
+        except KeyError as exc:
+            raise ValueError(f"gluon splitting is missing {exc.args[0]!r}") from exc
+    raise ValueError(f"unknown colour connection step {kind!r}")
+
+
+@dataclass(frozen=True)
+class CorrelatorConfig:
+    """The correlations to prepare alongside a complete tree amplitude.
+
+    ``color_correlations`` contains the requested ``bra† ket`` connections,
+    keyed by unique IDs. Each side has the same number of ordered operations.
+    ``spin_correlations=((3,), (3, 4))`` permits replacing leg 3 alone or legs
+    3 and 4 together. An empty runtime vector map always restores the ordinary
+    helicity sum. Each replaced leg contributes one vector state; the usual
+    initial-state averaging and identical-particle factors are retained.
+
+    The first correlated executor uses the generic compiled amplitude and
+    direct exact colour algebra. It does not use FFT or helicity-specific
+    current recycling. Uncorrelated generation does not construct this object.
+    """
+
+    color_correlations: tuple[ColorCorrelator, ...] = ()
+    spin_correlations: tuple[tuple[int, ...], ...] = ()
+    all_color_through_order: int | None = None
+
+    def __post_init__(self) -> None:
+        order = self.all_color_through_order
+        if order is not None and (
+            type(order) is not int or order < 1
+        ):
+            raise ValueError(
+                "all_color_through_order must be a positive integer"
+            )
+        colors = tuple(self.color_correlations)
+        if any(not isinstance(item, ColorCorrelator) for item in colors):
+            raise TypeError("color_correlations must contain ColorCorrelator records")
+        ids = tuple(item.id for item in colors)
+        if "born" in ids:
+            raise ValueError("the colour correlation ID 'born' is reserved")
+        if len(set(ids)) != len(ids):
+            raise ValueError("colour correlation IDs must be unique")
+        if order is not None and any(
+            re.fullmatch(r"N[1-9][0-9]*LO/c[0-9]+/c[0-9]+", identifier)
+            for identifier in ids
+        ):
+            raise ValueError("automatic colour catalogue IDs are reserved")
+        classes: list[tuple[int, ...]] = []
+        for group in self.spin_correlations:
+            legs = tuple(group)
+            if not legs:
+                raise ValueError("a spin-correlation class must contain a leg")
+            if any(type(leg) is not int or leg <= 0 for leg in legs):
+                raise ValueError("spin-correlation legs must be positive integers")
+            if len(set(legs)) != len(legs):
+                raise ValueError("a spin-correlation class repeats a leg")
+            canonical = tuple(sorted(legs))
+            if canonical in classes:
+                raise ValueError("spin-correlation classes must be distinct")
+            classes.append(canonical)
+        object.__setattr__(self, "color_correlations", colors)
+        object.__setattr__(self, "spin_correlations", tuple(sorted(classes)))
+
+    @classmethod
+    def all_color(
+        cls,
+        *,
+        through_order: int,
+        spin_correlations: tuple[tuple[int, ...], ...] = (),
+    ) -> CorrelatorConfig:
+        """Prepare every tree-soft colour connection through N^kLO.
+
+        Generation resolves the coloured Born legs separately for each process.
+        Histories include emission from emitted partons and splitting of emitted
+        gluons into quark pairs; this is not a catalogue of dipole products.
+        All directed overlaps with matching final colour spaces are retained.
+        No splitting kernels, flavour sums or combinatorial weights are included.
+        ``through_order=k`` includes all orders 1 through k without a fixed cap.
+        The complete catalogue is nonminimal and grows rapidly with k.
+        """
+        if type(through_order) is not int or through_order < 1:
+            raise ValueError("all_color_through_order must be a positive integer")
+        return cls(
+            spin_correlations=spin_correlations,
+            all_color_through_order=through_order,
+        )
+
+    def _resolve_color(self, legs: Sequence[ColorLeg]) -> CorrelatorConfig:
+        """Expand the opt-in declaration once the process representations exist."""
+        if self.all_color_through_order is None:
+            return self
+        from pyamplicol.color.connection_catalogue import (
+            build_color_correlator_catalogue,
+        )
+
+        return replace(
+            self,
+            color_correlations=(
+                *self.color_correlations,
+                *build_color_correlator_catalogue(
+                    legs, through_order=self.all_color_through_order
+                ),
+            ),
+            all_color_through_order=None,
+        )
+
+    @property
+    def spin_legs(self) -> tuple[int, ...]:
+        """All external legs whose source vectors must remain unrestricted."""
+        return tuple(sorted({leg for group in self.spin_correlations for leg in group}))
+
+    @property
+    def color_requests(self) -> tuple[ColorCorrelator, ...]:
+        """Requested operators, including the ordinary Born overlap."""
+        if self.all_color_through_order is not None:
+            raise ValueError(
+                "automatic colour requests must first be resolved for a process"
+            )
+        return (ColorCorrelator("born"), *self.color_correlations)
+
+    def to_json_dict(self) -> dict[str, object]:
+        result: dict[str, object] = {
+            "color_correlations": [
+                item.to_json_dict() for item in self.color_correlations
+            ],
+            "spin_correlations": [list(group) for group in self.spin_correlations],
+        }
+        if self.all_color_through_order is not None:
+            result["all_color_through_order"] = self.all_color_through_order
+        return result
+
+    @classmethod
+    def from_json_dict(cls, value: object) -> CorrelatorConfig:
+        """Read the same declaration used by Python and ``--correlators``."""
+        data = _fields(
+            value,
+            {"color_correlations", "spin_correlations", "all_color_through_order"},
+            "correlator declaration",
+        )
+        colors: list[ColorCorrelator] = []
+        for record in _sequence(
+            data.get("color_correlations", ()), "color_correlations"
+        ):
+            item = _fields(record, {"id", "bra", "ket"}, "colour correlation")
+            if "id" not in item:
+                raise ValueError("a colour correlation requires an ID")
+            colors.append(
+                ColorCorrelator(
+                    item["id"],  # type: ignore[arg-type]
+                    tuple(
+                        _emission_from_json(step)
+                        for step in _sequence(item.get("bra", ()), "bra")
+                    ),
+                    tuple(
+                        _emission_from_json(step)
+                        for step in _sequence(item.get("ket", ()), "ket")
+                    ),
+                )
+            )
+        spins = tuple(
+            tuple(_sequence(group, "spin-correlation class"))
+            for group in _sequence(
+                data.get("spin_correlations", ()), "spin_correlations"
+            )
+        )
+        return cls(
+            tuple(colors),
+            cast(tuple[tuple[int, ...], ...], spins),
+            cast(int | None, data.get("all_color_through_order")),
+        )
diff --git a/pyamplicol/src/pyamplicol/diagnostics.py b/pyamplicol/src/pyamplicol/diagnostics.py
new file mode 100644
index 0000000000..260ce586e0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/diagnostics.py
@@ -0,0 +1,264 @@
+# SPDX-License-Identifier: 0BSD
+"""Fast installed-package diagnostics used by ``doctor`` and ``self-test``."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import json
+import math
+import shutil
+import sys
+from dataclasses import dataclass
+from importlib import resources
+from pathlib import Path
+from typing import Literal
+
+from . import __version__
+from ._internal.versions import verify_native_module
+
+CheckStatus = Literal["pass", "warning", "fail"]
+
+
+@dataclass(frozen=True, slots=True)
+class DiagnosticCheck:
+    name: str
+    status: CheckStatus
+    detail: str
+
+
+@dataclass(frozen=True, slots=True)
+class DiagnosticReport:
+    package_version: str
+    checks: tuple[DiagnosticCheck, ...]
+
+    @property
+    def ok(self) -> bool:
+        return all(check.status != "fail" for check in self.checks)
+
+
+def _python_check() -> DiagnosticCheck:
+    version = ".".join(str(item) for item in sys.version_info[:3])
+    status: CheckStatus = "pass" if sys.version_info >= (3, 11) else "fail"
+    return DiagnosticCheck("python", status, version)
+
+
+def _asset_check() -> DiagnosticCheck:
+    root = resources.files("pyamplicol").joinpath("assets", "models")
+    try:
+        lines = (
+            root.joinpath("MANIFEST.sha256").read_text(encoding="utf-8").splitlines()
+        )
+        if not lines:
+            raise ValueError("empty model manifest")
+        for line in lines:
+            digest, separator, relative = line.partition("  ")
+            if not separator or len(digest) != 64 or not relative:
+                raise ValueError(f"malformed model manifest line: {line!r}")
+            payload = root.joinpath(*relative.split("/"))
+            actual = hashlib.sha256(payload.read_bytes()).hexdigest()
+            if actual != digest:
+                raise ValueError(f"model asset digest mismatch: {relative}")
+    except (FileNotFoundError, OSError, ValueError) as exc:
+        return DiagnosticCheck("model-assets", "fail", str(exc))
+    return DiagnosticCheck("model-assets", "pass", f"{len(lines)} verified files")
+
+
+def _native_check(*, required: bool) -> DiagnosticCheck:
+    try:
+        native = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(native)
+        abi_version = int(native.abi_version())
+        native_version = str(native.package_version())
+    except (ImportError, AttributeError, TypeError, ValueError, RuntimeError) as exc:
+        return DiagnosticCheck(
+            "rusticol-python",
+            "fail" if required else "warning",
+            f"native extension unavailable: {exc}",
+        )
+    if abi_version != 1:
+        return DiagnosticCheck(
+            "rusticol-python",
+            "fail",
+            f"unsupported C ABI {abi_version}; expected 1",
+        )
+    return DiagnosticCheck(
+        "rusticol-python", "pass", f"package {native_version}, C ABI {abi_version}"
+    )
+
+
+def _sdk_check(*, required: bool) -> DiagnosticCheck:
+    try:
+        from ._sdk.config import load_sdk_info
+
+        info = load_sdk_info()
+    except (ImportError, OSError, RuntimeError, TypeError, ValueError) as exc:
+        return DiagnosticCheck(
+            "native-sdk",
+            "fail" if required else "warning",
+            f"SDK unavailable: {exc}",
+        )
+    return DiagnosticCheck(
+        "native-sdk",
+        "pass",
+        f"{info.target}; ABI {info.abi_version}; {info.library.name}",
+    )
+
+
+def _complex_pair(value: object, description: str) -> complex:
+    if (
+        not isinstance(value, list)
+        or len(value) != 2
+        or isinstance(value[0], bool)
+        or isinstance(value[1], bool)
+        or not isinstance(value[0], (int, float))
+        or not isinstance(value[1], (int, float))
+    ):
+        raise ValueError(f"{description} must be a [real, imaginary] pair")
+    return complex(float(value[0]), float(value[1]))
+
+
+def _physics_check() -> DiagnosticCheck:
+    try:
+        native = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(native)
+        target = str(native.target_info().triple)
+        fixture = resources.files("pyamplicol").joinpath("assets", "selftest", target)
+        expected_raw = json.loads(
+            fixture.joinpath("expected.json").read_text(encoding="utf-8")
+        )
+        if (
+            not isinstance(expected_raw, dict)
+            or expected_raw.get("schema_version") != 1
+        ):
+            raise ValueError("self-test expectation must be a schema-v1 object")
+        artifact = fixture.joinpath(str(expected_raw.get("artifact_path", "")))
+        artifact_path = Path(str(artifact))
+        if not artifact_path.is_dir():
+            raise ValueError(f"self-test artifact is unavailable for {target}")
+
+        from .api.services import Runtime
+
+        runtime = Runtime.load(artifact_path, mute_warnings=True)
+        process_id = str(expected_raw.get("process_id", ""))
+        if runtime.physics.process_id != process_id:
+            raise ValueError(
+                "self-test process metadata differs from its recorded expectation"
+            )
+        momenta = expected_raw.get("momenta")
+        if not isinstance(momenta, list):
+            raise ValueError("self-test expectation has no momentum batch")
+        total = runtime.evaluate(momenta)
+        resolved = runtime.evaluate_resolved(momenta)
+        expected_total_raw = expected_raw.get("total")
+        if not isinstance(expected_total_raw, list):
+            raise ValueError("self-test expectation has no total values")
+        expected_total = tuple(
+            _complex_pair(value, f"self-test total {index}")
+            for index, value in enumerate(expected_total_raw)
+        )
+        if len(total) != len(expected_total):
+            raise ValueError("self-test total has the wrong point count")
+        for index, (actual, expected) in enumerate(
+            zip(total, expected_total, strict=True)
+        ):
+            value = complex(actual)
+            if not (
+                math.isclose(
+                    value.real, expected.real, rel_tol=1.0e-12, abs_tol=1.0e-14
+                )
+                and math.isclose(
+                    value.imag, expected.imag, rel_tol=1.0e-12, abs_tol=1.0e-14
+                )
+            ):
+                raise ValueError(
+                    f"self-test total {index} is {value!r}, expected {expected!r}"
+                )
+        reduced = tuple(complex(value) for value in resolved.total())
+        for index, (actual, expected) in enumerate(
+            zip(reduced, expected_total, strict=True)
+        ):
+            if not (
+                math.isclose(
+                    actual.real, expected.real, rel_tol=1.0e-12, abs_tol=1.0e-14
+                )
+                and math.isclose(
+                    actual.imag, expected.imag, rel_tol=1.0e-12, abs_tol=1.0e-14
+                )
+            ):
+                raise ValueError(
+                    f"resolved self-test total {index} does not reproduce evaluate()"
+                )
+        expected_shape = expected_raw.get("resolved_shape")
+        if list(resolved.shape) != expected_shape:
+            raise ValueError(
+                f"resolved self-test shape {resolved.shape!r} differs from "
+                f"{expected_shape!r}"
+            )
+    except Exception as exc:
+        return DiagnosticCheck("physics-f64", "fail", str(exc))
+    return DiagnosticCheck(
+        "physics-f64",
+        "pass",
+        f"{process_id}; shape {resolved.shape}; direct SymJIT on {target}",
+    )
+
+
+def _symbolica_check() -> DiagnosticCheck:
+    try:
+        from .licensing import detect_symbolica_license
+
+        state = detect_symbolica_license(suggest=False, json_mode=True)
+    except (ImportError, RuntimeError) as exc:
+        return DiagnosticCheck("symbolica", "fail", str(exc))
+    mode = "licensed" if state.licensed else "restricted single-core"
+    return DiagnosticCheck("symbolica", "pass", mode)
+
+
+def _tool_check(name: str, *, required: bool) -> DiagnosticCheck:
+    path = shutil.which(name)
+    if path is None:
+        return DiagnosticCheck(
+            f"tool:{name}",
+            "fail" if required else "warning",
+            "not found on PATH",
+        )
+    return DiagnosticCheck(f"tool:{name}", "pass", path)
+
+
+def run_doctor() -> DiagnosticReport:
+    """Inspect source/install capabilities without running physics generation."""
+
+    checks = (
+        _python_check(),
+        _asset_check(),
+        _native_check(required=False),
+        _sdk_check(required=False),
+        _symbolica_check(),
+        _tool_check("cc", required=False),
+        _tool_check("c++", required=False),
+        _tool_check("gfortran", required=False),
+    )
+    return DiagnosticReport(__version__, checks)
+
+
+def run_self_test() -> DiagnosticReport:
+    """Run the fast checks required of an installed binary distribution."""
+
+    checks = (
+        _python_check(),
+        _asset_check(),
+        _native_check(required=True),
+        _sdk_check(required=True),
+        _physics_check(),
+    )
+    return DiagnosticReport(__version__, checks)
+
+
+__all__ = [
+    "CheckStatus",
+    "DiagnosticCheck",
+    "DiagnosticReport",
+    "run_doctor",
+    "run_self_test",
+]
diff --git a/pyamplicol/src/pyamplicol/evaluators/__init__.py b/pyamplicol/src/pyamplicol/evaluators/__init__.py
new file mode 100644
index 0000000000..e87112d250
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/evaluators/__init__.py
@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+
+def __getattr__(name: str) -> Any:
+    if name != "SymbolicaEvaluatorSettings":
+        raise AttributeError(name)
+    value = getattr(importlib.import_module(".symbolica", __name__), name)
+    globals()[name] = value
+    return value
+
+
+__all__ = ["SymbolicaEvaluatorSettings"]
diff --git a/pyamplicol/src/pyamplicol/evaluators/execution_schema.py b/pyamplicol/src/pyamplicol/evaluators/execution_schema.py
new file mode 100644
index 0000000000..ae7eedb8f5
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/evaluators/execution_schema.py
@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: 0BSD
+"""Evaluator runtime-capability metadata shared by artifact writers."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, Sequence
+
+from .._internal.physics.types import NativeEvaluationError
+from .._internal.versions import EVALUATOR_RUNTIME_CAPABILITIES
+
+
+def evaluator_runtime_capabilities(
+    manifest: Mapping[str, object],
+) -> tuple[str, ...]:
+    """Return the primary f64 capabilities required by one evaluator tree."""
+
+    kind = str(manifest.get("kind", ""))
+    if kind == "chunked-symbolica-evaluator":
+        chunks = manifest.get("chunks")
+        if isinstance(chunks, str | bytes) or not isinstance(chunks, Sequence):
+            raise NativeEvaluationError(
+                "chunked evaluator capability metadata has no chunk list"
+            )
+        return aggregate_runtime_capabilities(
+            _mapping(chunk, "chunked evaluator entry") for chunk in chunks
+        )
+
+    capability = manifest.get("runtime_capability")
+    if (
+        not isinstance(capability, str)
+        or capability not in EVALUATOR_RUNTIME_CAPABILITIES
+    ):
+        raise NativeEvaluationError(
+            f"evaluator {kind!r} has no supported runtime capability"
+        )
+    return (capability,)
+
+
+def aggregate_runtime_capabilities(
+    manifests: Iterable[Mapping[str, object]],
+) -> tuple[str, ...]:
+    """Return a canonical union of the primary f64 evaluator capabilities."""
+
+    capabilities: set[str] = set()
+    for manifest in manifests:
+        capabilities.update(evaluator_runtime_capabilities(manifest))
+    return tuple(sorted(capabilities))
+
+
+def _mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise NativeEvaluationError(f"{context} is not an object")
+    return {str(key): item for key, item in value.items()}
+
+
+__all__ = ["aggregate_runtime_capabilities", "evaluator_runtime_capabilities"]
diff --git a/pyamplicol/src/pyamplicol/evaluators/native_direct_cpp.py b/pyamplicol/src/pyamplicol/evaluators/native_direct_cpp.py
new file mode 100644
index 0000000000..d5c39aab0e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/evaluators/native_direct_cpp.py
@@ -0,0 +1,1204 @@
+# SPDX-License-Identifier: 0BSD
+"""Generate a genuine plane-native C++ leaf from a Symbolica evaluator.
+
+This module is deliberately a narrow producer prototype.  It consumes
+Symbolica's documented ``Evaluator.get_instructions()`` representation and
+emits that optimized instruction stream a second time against fixed
+split-complex plane/scalar descriptors.  The generated DirectApplication
+entry never calls the historical ``*_complexf64`` function and never builds a
+dense parameter or output row.
+
+Only the instruction subset proved by the retained real-process prototype is
+accepted.  Unknown operations fail closed instead of falling back to the
+dense ABI.
+"""
+
+from __future__ import annotations
+
+import cmath
+import hashlib
+import math
+import os
+import re
+import signal
+import subprocess
+import time
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import contextmanager
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+from typing import Any
+
+from .._internal.physics.types import NativeEvaluationError
+from .._internal.versions import NATIVE_COMPILED_DIRECT_APPLICATION_ABI
+from .symbolica_helpers import _symbolica_instruction_program
+
+_C_IDENTIFIER = re.compile(r"[A-Za-z_][A-Za-z0-9_]*\Z")
+_DIRECT_MARKER = "// pyAmpliCol genuine native DirectApplication producer v1"
+_DIRECT_FLAGS = 0x3F
+_DEFAULT_STACK_LIMIT = 64 * 1024
+_SUPPORTED_LANE_WIDTHS = frozenset({2, 4})
+_COMPILER_GATE_DIR_ENV = "PYAMPLICOL_NATIVE_COMPILER_GATE_DIR"
+_COMPILER_GATE_SLOT_COUNT_ENV = "PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT"
+_COMPILER_GATE_POLL_SECONDS = 0.05
+_MAX_COMPILER_GATE_SLOTS = 64
+_COMPILER_TERMINATE_GRACE_SECONDS = 0.5
+_COMPILER_KILL_GRACE_SECONDS = 5.0
+
+
+class NativeDirectCppParameterKind(StrEnum):
+    """Storage class for one complex Symbolica source parameter."""
+
+    COMPLEX_PLANE = "complex-plane"
+    REAL_PLANE = "real-plane"
+    COMPLEX_SCALAR = "complex-scalar"
+    REAL_SCALAR = "real-scalar"
+
+
+@dataclass(frozen=True, slots=True)
+class NativeDirectCppSpec:
+    """Cold-path code-generation contract for one fused evaluator leaf."""
+
+    function_name: str
+    parameter_kinds: tuple[NativeDirectCppParameterKind, ...]
+    output_count: int
+    target_triple: str
+    cpu_features: tuple[str, ...] = ()
+    simd_lane_width: int = 2
+    max_logical_stack_bytes: int = _DEFAULT_STACK_LIMIT
+
+    def __post_init__(self) -> None:
+        if _C_IDENTIFIER.fullmatch(self.function_name) is None:
+            raise NativeEvaluationError(
+                "native DirectApplication function name is not a portable C identifier"
+            )
+        if not self.parameter_kinds:
+            raise NativeEvaluationError(
+                "native DirectApplication needs at least one source parameter"
+            )
+        if self.output_count < 1:
+            raise NativeEvaluationError(
+                "native DirectApplication needs at least one output"
+            )
+        if not self.target_triple or "\x00" in self.target_triple:
+            raise NativeEvaluationError(
+                "native DirectApplication target triple is invalid"
+            )
+        canonical_features = tuple(sorted(set(self.cpu_features)))
+        if self.cpu_features != canonical_features or any(
+            not feature or "\x00" in feature for feature in self.cpu_features
+        ):
+            raise NativeEvaluationError(
+                "native DirectApplication CPU features must be sorted and unique"
+            )
+        if self.simd_lane_width not in _SUPPORTED_LANE_WIDTHS:
+            raise NativeEvaluationError(
+                "native DirectApplication SIMD lane width must be 2 or 4"
+            )
+        if self.max_logical_stack_bytes < 1:
+            raise NativeEvaluationError(
+                "native DirectApplication logical stack limit must be positive"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class NativeDirectCppSource:
+    """Rendered source and its authenticated producer metadata."""
+
+    source: str
+    target_triple: str
+    cpu_features: tuple[str, ...]
+    simd_lane_width: int
+    evaluator_state_sha256: str
+    instruction_count: int
+    temporary_count: int
+    input_plane_count: int
+    scalar_input_count: int
+    output_plane_count: int
+    logical_stack_bytes: int
+
+
+@dataclass(frozen=True, slots=True)
+class NativeDirectCppCompiler:
+    """Compiler settings matching the ordinary compiled-C++ path."""
+
+    executable: str = "c++"
+    optimization_level: int = 3
+    native_arch: bool = False
+    extra_flags: tuple[str, ...] = ()
+    timeout_seconds: float = 1800.0
+
+    def __post_init__(self) -> None:
+        if not self.executable or "\x00" in self.executable:
+            raise NativeEvaluationError("native DirectApplication compiler is invalid")
+        if self.optimization_level not in (0, 1, 2, 3):
+            raise NativeEvaluationError(
+                "native DirectApplication compiler optimization must be 0 through 3"
+            )
+        if self.timeout_seconds <= 0 or not math.isfinite(self.timeout_seconds):
+            raise NativeEvaluationError(
+                "native DirectApplication compiler timeout must be finite and positive"
+            )
+        if any(not flag or "\x00" in flag for flag in self.extra_flags):
+            raise NativeEvaluationError(
+                "native DirectApplication compiler flags are invalid"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class NativeDirectCppArtifact:
+    """One direct-only native library produced from retained instructions."""
+
+    source_path: Path
+    library_path: Path
+    source: NativeDirectCppSource
+    compiler_command: tuple[str, ...]
+    compile_seconds: float
+    compiler_gate_wait_seconds: float = 0.0
+    compiler_gate_slot_count: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class _NativeCompilerGateLease:
+    wait_seconds: float
+    slot_count: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class _ParameterAccess:
+    kind: NativeDirectCppParameterKind
+    first_index: int
+    second_index: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class _InstructionProgram:
+    statements: tuple[str, ...]
+    instruction_count: int
+    temporary_count: int
+    constants: tuple[complex, ...]
+
+
+def render_native_direct_cpp(
+    evaluator: Any,
+    spec: NativeDirectCppSpec,
+) -> NativeDirectCppSource:
+    """Render one factor-free plane-native entry from a Symbolica evaluator.
+
+    ``Evaluator.get_instructions`` is the only accepted expression source.
+    Generated dense C++ text is never parsed or wrapped.
+    """
+
+    get_instructions = getattr(evaluator, "get_instructions", None)
+    save = getattr(evaluator, "save", None)
+    if not callable(get_instructions) or not callable(save):
+        raise NativeEvaluationError(
+            "this Symbolica evaluator exposes no reusable instruction/state API"
+        )
+    try:
+        raw_program = _symbolica_instruction_program(get_instructions())
+        evaluator_state = save()
+    except Exception as error:
+        raise NativeEvaluationError(
+            "Symbolica could not expose its optimized evaluator instruction stream"
+        ) from error
+    if not isinstance(evaluator_state, bytes) or not evaluator_state:
+        raise NativeEvaluationError(
+            "Symbolica returned an empty or non-bytes evaluator state"
+        )
+
+    accesses, input_plane_count, scalar_input_count = _parameter_accesses(
+        spec.parameter_kinds
+    )
+    program = _lower_instruction_program(raw_program, spec, accesses)
+    logical_stack_bytes = (
+        (program.temporary_count + spec.output_count) * 2 * 8 * spec.simd_lane_width
+    )
+    if logical_stack_bytes > spec.max_logical_stack_bytes:
+        raise NativeEvaluationError(
+            "native DirectApplication logical scratch exceeds its bounded stack "
+            f"contract: {logical_stack_bytes} > {spec.max_logical_stack_bytes}"
+        )
+
+    state_sha256 = hashlib.sha256(evaluator_state).hexdigest()
+    source = _render_translation_unit(
+        spec=spec,
+        program=program,
+        accesses=accesses,
+        input_plane_count=input_plane_count,
+        scalar_input_count=scalar_input_count,
+        evaluator_state_sha256=state_sha256,
+        logical_stack_bytes=logical_stack_bytes,
+    )
+    return NativeDirectCppSource(
+        source=source,
+        target_triple=spec.target_triple,
+        cpu_features=spec.cpu_features,
+        simd_lane_width=spec.simd_lane_width,
+        evaluator_state_sha256=state_sha256,
+        instruction_count=program.instruction_count,
+        temporary_count=program.temporary_count,
+        input_plane_count=input_plane_count,
+        scalar_input_count=scalar_input_count,
+        output_plane_count=2 * spec.output_count,
+        logical_stack_bytes=logical_stack_bytes,
+    )
+
+
+def compile_native_direct_cpp(
+    evaluator: Any,
+    *,
+    spec: NativeDirectCppSpec,
+    compiler: NativeDirectCppCompiler,
+    output_source_path: Path,
+    output_library_path: Path,
+) -> NativeDirectCppArtifact:
+    """Compile one genuine direct-only native leaf.
+
+    The translation unit is generated independently from retained evaluator
+    instructions.  It contains neither the ordinary dense source nor a call to
+    a dense symbol.  Validation may load the original dense library separately
+    as an exact same-expression oracle.
+    """
+
+    rendered = render_native_direct_cpp(evaluator, spec)
+    output_source_path.parent.mkdir(parents=True, exist_ok=True)
+    output_library_path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        output_source_path.write_text(rendered.source, encoding="utf-8")
+    except OSError as error:
+        raise NativeEvaluationError(
+            f"could not write native DirectApplication source: {output_source_path}"
+        ) from error
+
+    temporary_library = output_library_path.with_name(
+        f".{output_library_path.name}.tmp-{os.getpid()}"
+    )
+    command = [
+        compiler.executable,
+        "-std=c++17",
+        "-shared",
+        f"-O{compiler.optimization_level}",
+        "-fPIC",
+        "-ffast-math",
+        "-funsafe-math-optimizations",
+    ]
+    if compiler.native_arch:
+        command.append("-march=native")
+    command.extend(compiler.extra_flags)
+    command.extend(
+        [
+            str(output_source_path),
+            "-o",
+            str(temporary_library),
+        ]
+    )
+    with _native_compiler_gate() as compiler_gate:
+        # Queueing behind another compiler is operational scheduling, not
+        # compilation time.  Start the finite subprocess timeout only after
+        # this worker owns one shared slot.
+        started = time.perf_counter()
+        try:
+            completed = _run_native_compiler(
+                command,
+                timeout_seconds=compiler.timeout_seconds,
+            )
+        except subprocess.TimeoutExpired as error:
+            temporary_library.unlink(missing_ok=True)
+            raise NativeEvaluationError(
+                "native DirectApplication C++ compilation exceeded its finite "
+                f"{compiler.timeout_seconds:g}s timeout"
+            ) from error
+        except NativeEvaluationError:
+            temporary_library.unlink(missing_ok=True)
+            raise
+        except (OSError, subprocess.SubprocessError) as error:
+            temporary_library.unlink(missing_ok=True)
+            raise NativeEvaluationError(
+                "could not execute the native DirectApplication C++ compiler"
+            ) from error
+        except BaseException:
+            # Interrupts must not publish a partial library or release the
+            # shared compiler slot before the detached compiler tree is gone.
+            temporary_library.unlink(missing_ok=True)
+            raise
+    compile_seconds = time.perf_counter() - started
+    if completed.returncode != 0:
+        temporary_library.unlink(missing_ok=True)
+        detail = completed.stderr.strip() or completed.stdout.strip()
+        raise NativeEvaluationError(
+            "native DirectApplication C++ compilation failed"
+            + (f": {detail}" if detail else "")
+        )
+    try:
+        os.replace(temporary_library, output_library_path)
+    except OSError as error:
+        temporary_library.unlink(missing_ok=True)
+        raise NativeEvaluationError(
+            f"could not publish native DirectApplication library: {output_library_path}"
+        ) from error
+    return NativeDirectCppArtifact(
+        source_path=output_source_path,
+        library_path=output_library_path,
+        source=rendered,
+        compiler_command=tuple(command),
+        compile_seconds=compile_seconds,
+        compiler_gate_wait_seconds=compiler_gate.wait_seconds,
+        compiler_gate_slot_count=compiler_gate.slot_count,
+    )
+
+
+def _run_native_compiler(
+    command: Sequence[str],
+    *,
+    timeout_seconds: float,
+) -> subprocess.CompletedProcess[str]:
+    """Run one compiler in a disposable process group with finite cleanup."""
+
+    process = subprocess.Popen(
+        tuple(command),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        start_new_session=os.name == "posix",
+    )
+    try:
+        stdout, stderr = process.communicate(timeout=timeout_seconds)
+    except BaseException:
+        # The compiler owns a new session on POSIX, so caller interruption
+        # does not reach it automatically.  Reap the complete tree before
+        # propagating any timeout, cancellation, or unexpected failure.
+        _terminate_native_compiler_tree(process)
+        raise
+    return subprocess.CompletedProcess(
+        tuple(command),
+        process.returncode,
+        stdout,
+        stderr,
+    )
+
+
+def _terminate_native_compiler_tree(process: subprocess.Popen[str]) -> None:
+    """Terminate and reap a timed-out compiler and all of its descendants."""
+
+    if os.name != "posix":
+        process.kill()
+        try:
+            process.communicate(timeout=_COMPILER_KILL_GRACE_SECONDS)
+        except subprocess.TimeoutExpired as error:
+            raise NativeEvaluationError(
+                "native DirectApplication compiler timeout cleanup failed"
+            ) from error
+        return
+
+    process_group_id = process.pid
+    _signal_process_group(process_group_id, signal.SIGTERM)
+    try:
+        process.communicate(timeout=_COMPILER_TERMINATE_GRACE_SECONDS)
+    except subprocess.TimeoutExpired:
+        pass
+
+    if _process_group_exists(process_group_id):
+        _signal_process_group(process_group_id, signal.SIGKILL)
+    try:
+        process.communicate(timeout=_COMPILER_KILL_GRACE_SECONDS)
+    except subprocess.TimeoutExpired as error:
+        _signal_process_group(process_group_id, signal.SIGKILL)
+        raise NativeEvaluationError(
+            "native DirectApplication compiler timeout cleanup failed"
+        ) from error
+
+    deadline = time.monotonic() + _COMPILER_KILL_GRACE_SECONDS
+    while _process_group_exists(process_group_id):
+        if time.monotonic() >= deadline:
+            _signal_process_group(process_group_id, signal.SIGKILL)
+            raise NativeEvaluationError(
+                "native DirectApplication compiler timeout cleanup left a "
+                "live process group"
+            )
+        time.sleep(0.01)
+
+
+def _signal_process_group(process_group_id: int, signal_number: int) -> None:
+    try:
+        os.killpg(process_group_id, signal_number)
+    except ProcessLookupError:
+        return
+    except OSError as error:
+        raise NativeEvaluationError(
+            "native DirectApplication compiler process-group cleanup failed"
+        ) from error
+
+
+def _process_group_exists(process_group_id: int) -> bool:
+    try:
+        os.killpg(process_group_id, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+@contextmanager
+def _native_compiler_gate() -> Iterator[_NativeCompilerGateLease]:
+    """Lease one optional cross-controller native-compiler slot.
+
+    The report scheduler injects the gate only for the EPYC campaign.  Other
+    callers retain the historical ungated behavior.  Slot paths and wait time
+    are deliberately operational metadata and never enter evaluator identity.
+    """
+
+    raw_directory = os.environ.get(_COMPILER_GATE_DIR_ENV)
+    raw_slot_count = os.environ.get(_COMPILER_GATE_SLOT_COUNT_ENV)
+    if raw_directory is None and raw_slot_count is None:
+        yield _NativeCompilerGateLease(0.0, None)
+        return
+    if raw_directory is None or raw_slot_count is None:
+        raise NativeEvaluationError(
+            "native DirectApplication compiler gate environment is incomplete"
+        )
+    if not raw_directory or "\x00" in raw_directory:
+        raise NativeEvaluationError(
+            "native DirectApplication compiler gate directory is invalid"
+        )
+    try:
+        slot_count = int(raw_slot_count)
+    except ValueError as error:
+        raise NativeEvaluationError(
+            "native DirectApplication compiler gate slot count is invalid"
+        ) from error
+    if not 1 <= slot_count <= _MAX_COMPILER_GATE_SLOTS:
+        raise NativeEvaluationError(
+            "native DirectApplication compiler gate slot count is invalid"
+        )
+    directory = Path(raw_directory)
+    if not directory.is_absolute():
+        raise NativeEvaluationError(
+            "native DirectApplication compiler gate directory must be absolute"
+        )
+
+    descriptors: list[int] = []
+    try:
+        import fcntl
+
+        directory.mkdir(parents=True, exist_ok=True)
+        for index in range(slot_count):
+            descriptors.append(
+                os.open(
+                    directory / f"slot-{index:02d}.lock",
+                    os.O_CREAT | os.O_RDWR,
+                    0o600,
+                )
+            )
+    except (ImportError, OSError) as error:
+        for descriptor in descriptors:
+            try:
+                os.close(descriptor)
+            except OSError:
+                pass
+        raise NativeEvaluationError(
+            "native DirectApplication compiler gate could not be initialized"
+        ) from error
+
+    acquired: int | None = None
+    wait_started = time.perf_counter()
+    try:
+        while acquired is None:
+            for descriptor in descriptors:
+                try:
+                    fcntl.flock(
+                        descriptor,
+                        fcntl.LOCK_EX | fcntl.LOCK_NB,
+                    )
+                except BlockingIOError:
+                    continue
+                except OSError as error:
+                    raise NativeEvaluationError(
+                        "native DirectApplication compiler gate acquisition failed"
+                    ) from error
+                acquired = descriptor
+                break
+            if acquired is None:
+                time.sleep(_COMPILER_GATE_POLL_SECONDS)
+        yield _NativeCompilerGateLease(
+            time.perf_counter() - wait_started,
+            slot_count,
+        )
+    finally:
+        if acquired is not None:
+            try:
+                fcntl.flock(acquired, fcntl.LOCK_UN)
+            except OSError:
+                pass
+        for descriptor in descriptors:
+            try:
+                os.close(descriptor)
+            except OSError:
+                pass
+
+
+def compiler_from_symbolica_settings(
+    settings: Mapping[str, object],
+) -> NativeDirectCppCompiler:
+    """Translate the adapter's recorded settings into the direct compiler."""
+
+    # The direct translation is intentionally independent from Symbolica's
+    # dense scalar-row emitter.  An ``asm`` public backend therefore reuses the
+    # same optimized instruction stream and compiler policy here, without
+    # parsing, wrapping, or calling its inline-ASM row function.
+    executable_value = settings.get("compiler_path")
+    executable = "c++" if executable_value is None else str(executable_value)
+    optimization = settings.get("compiled_optimization_level", 3)
+    if isinstance(optimization, bool) or not isinstance(optimization, int):
+        raise NativeEvaluationError(
+            "native DirectApplication compiler optimization metadata is invalid"
+        )
+    native_arch = settings.get("compiled_native", False)
+    if not isinstance(native_arch, bool):
+        raise NativeEvaluationError(
+            "native DirectApplication native-architecture metadata is invalid"
+        )
+    raw_flags = settings.get(
+        "effective_compiler_flags",
+        settings.get("compiler_flags", ()),
+    )
+    if not isinstance(raw_flags, Sequence) or isinstance(raw_flags, (str, bytes)):
+        raise NativeEvaluationError(
+            "native DirectApplication compiler flag metadata is invalid"
+        )
+    extra_flags = tuple(str(flag) for flag in raw_flags if str(flag) != "-std=c++17")
+    return NativeDirectCppCompiler(
+        executable=executable,
+        optimization_level=optimization,
+        native_arch=native_arch,
+        extra_flags=extra_flags,
+    )
+
+
+def _parameter_accesses(
+    kinds: Sequence[NativeDirectCppParameterKind],
+) -> tuple[tuple[_ParameterAccess, ...], int, int]:
+    plane_index = 0
+    scalar_index = 0
+    accesses: list[_ParameterAccess] = []
+    for raw_kind in kinds:
+        try:
+            kind = NativeDirectCppParameterKind(raw_kind)
+        except ValueError as error:
+            raise NativeEvaluationError(
+                f"unsupported native DirectApplication parameter kind: {raw_kind!r}"
+            ) from error
+        if kind is NativeDirectCppParameterKind.COMPLEX_PLANE:
+            accesses.append(_ParameterAccess(kind, plane_index, plane_index + 1))
+            plane_index += 2
+        elif kind is NativeDirectCppParameterKind.REAL_PLANE:
+            accesses.append(_ParameterAccess(kind, plane_index, None))
+            plane_index += 1
+        elif kind is NativeDirectCppParameterKind.COMPLEX_SCALAR:
+            accesses.append(_ParameterAccess(kind, scalar_index, scalar_index + 1))
+            scalar_index += 2
+        else:
+            accesses.append(_ParameterAccess(kind, scalar_index, None))
+            scalar_index += 1
+    return tuple(accesses), plane_index, scalar_index
+
+
+def _lower_instruction_program(
+    raw_program: object,
+    spec: NativeDirectCppSpec,
+    accesses: Sequence[_ParameterAccess],
+) -> _InstructionProgram:
+    if not isinstance(raw_program, tuple) or len(raw_program) != 3:
+        raise NativeEvaluationError(
+            "Symbolica returned an invalid evaluator instruction program"
+        )
+    raw_instructions, raw_temporary_count, raw_constants = raw_program
+    if not isinstance(raw_instructions, list):
+        raise NativeEvaluationError("Symbolica evaluator instructions are not a list")
+    if (
+        isinstance(raw_temporary_count, bool)
+        or not isinstance(raw_temporary_count, int)
+        or raw_temporary_count < 0
+    ):
+        raise NativeEvaluationError("Symbolica evaluator temporary count is invalid")
+    if not isinstance(raw_constants, list):
+        raise NativeEvaluationError("Symbolica evaluator constants are not a list")
+    constants = tuple(_finite_complex(value) for value in raw_constants)
+
+    written: set[tuple[str, int]] = set()
+    real_values: dict[tuple[str, int], bool] = {}
+    for index, access in enumerate(accesses):
+        real_values[("param", index)] = access.kind in {
+            NativeDirectCppParameterKind.REAL_PLANE,
+            NativeDirectCppParameterKind.REAL_SCALAR,
+        }
+    for index, value in enumerate(constants):
+        real_values[("const", index)] = value.imag == 0.0
+
+    def parse_reference(raw: object, *, destination: bool = False) -> tuple[str, int]:
+        if (
+            not isinstance(raw, tuple)
+            or len(raw) != 2
+            or not isinstance(raw[0], str)
+            or isinstance(raw[1], bool)
+            or not isinstance(raw[1], int)
+            or raw[1] < 0
+        ):
+            raise NativeEvaluationError(
+                "Symbolica evaluator instruction contains an invalid reference"
+            )
+        kind, index = raw
+        allowed = {"temp", "out"} if destination else {"param", "temp", "const", "out"}
+        if kind not in allowed:
+            raise NativeEvaluationError(
+                "Symbolica evaluator instruction reference kind "
+                f"{kind!r} is unsupported"
+            )
+        if kind == "param" and index >= len(accesses):
+            raise NativeEvaluationError(
+                "Symbolica evaluator parameter reference is out of bounds"
+            )
+        if kind == "temp" and index >= raw_temporary_count:
+            raise NativeEvaluationError(
+                "Symbolica evaluator temporary reference is out of bounds"
+            )
+        if kind == "const" and index >= len(constants):
+            raise NativeEvaluationError(
+                "Symbolica evaluator constant reference is out of bounds"
+            )
+        if kind == "out" and index >= spec.output_count:
+            raise NativeEvaluationError(
+                "Symbolica evaluator output reference is out of bounds"
+            )
+        if not destination and kind in {"temp", "out"} and (kind, index) not in written:
+            raise NativeEvaluationError(
+                "Symbolica evaluator reads an uninitialized temporary/output"
+            )
+        return kind, index
+
+    def reference_expression(reference: tuple[str, int]) -> str:
+        kind, index = reference
+        if kind == "temp":
+            return f"temporary[{index}]"
+        if kind == "out":
+            return f"output[{index}]"
+        if kind == "const":
+            value = constants[index]
+            return (
+                f"direct_constant<Lane>({_cpp_f64(value.real)}, {_cpp_f64(value.imag)})"
+            )
+        access = accesses[index]
+        if access.kind is NativeDirectCppParameterKind.COMPLEX_PLANE:
+            assert access.second_index is not None
+            return (
+                "direct_complex_plane<Lane>("
+                f"inputs[{access.first_index}].values, "
+                f"inputs[{access.second_index}].values, point)"
+            )
+        if access.kind is NativeDirectCppParameterKind.REAL_PLANE:
+            return (
+                f"direct_real_plane<Lane>(inputs[{access.first_index}].values, point)"
+            )
+        if access.kind is NativeDirectCppParameterKind.COMPLEX_SCALAR:
+            assert access.second_index is not None
+            return (
+                "direct_complex_scalar<Lane>("
+                f"*scalars[{access.first_index}].value, "
+                f"*scalars[{access.second_index}].value)"
+            )
+        return f"direct_real_scalar<Lane>(*scalars[{access.first_index}].value)"
+
+    statements: list[str] = []
+    for row_index, raw_row in enumerate(raw_instructions):
+        if not isinstance(raw_row, tuple) or not raw_row:
+            raise NativeEvaluationError(
+                f"Symbolica evaluator instruction {row_index} is invalid"
+            )
+        operation = raw_row[0]
+        if operation in {"add", "mul"}:
+            if len(raw_row) != 4 or not isinstance(raw_row[2], list):
+                raise NativeEvaluationError(
+                    f"Symbolica {operation} instruction has an invalid shape"
+                )
+            destination = parse_reference(raw_row[1], destination=True)
+            arguments = tuple(parse_reference(item) for item in raw_row[2])
+            real_count = raw_row[3]
+            if (
+                not arguments
+                or isinstance(real_count, bool)
+                or not isinstance(real_count, int)
+                or real_count < 0
+                or real_count > len(arguments)
+            ):
+                raise NativeEvaluationError(
+                    f"Symbolica {operation} instruction has invalid "
+                    "real-argument metadata"
+                )
+            if any(
+                not real_values.get(argument, False)
+                for argument in arguments[:real_count]
+            ):
+                raise NativeEvaluationError(
+                    f"Symbolica {operation} instruction real-argument "
+                    "metadata is inconsistent"
+                )
+            expression = reference_expression(arguments[0])
+            helper = "direct_add" if operation == "add" else "direct_multiply"
+            for argument in arguments[1:]:
+                expression = f"{helper}({expression}, {reference_expression(argument)})"
+            statements.append(
+                f"    {reference_expression(destination)} = {expression};"
+            )
+            written.add(destination)
+            real_values[destination] = real_count == len(arguments)
+            continue
+        if operation == "pow":
+            if len(raw_row) != 5:
+                raise NativeEvaluationError(
+                    "Symbolica pow instruction has an invalid shape"
+                )
+            destination = parse_reference(raw_row[1], destination=True)
+            base = parse_reference(raw_row[2])
+            exponent = raw_row[3]
+            output_is_real = raw_row[4]
+            if exponent != -1 or not isinstance(output_is_real, bool):
+                raise NativeEvaluationError(
+                    "native DirectApplication only supports Symbolica "
+                    "reciprocal pow(-1)"
+                )
+            if output_is_real and not real_values.get(base, False):
+                raise NativeEvaluationError(
+                    "Symbolica real reciprocal metadata is inconsistent"
+                )
+            helper = (
+                "direct_real_reciprocal"
+                if output_is_real
+                else "direct_complex_reciprocal"
+            )
+            statements.append(
+                f"    {reference_expression(destination)} = "
+                f"{helper}({reference_expression(base)});"
+            )
+            written.add(destination)
+            real_values[destination] = output_is_real
+            continue
+        if operation == "assign":
+            if len(raw_row) != 3:
+                raise NativeEvaluationError(
+                    "Symbolica assign instruction has an invalid shape"
+                )
+            destination = parse_reference(raw_row[1], destination=True)
+            source = parse_reference(raw_row[2])
+            statements.append(
+                f"    {reference_expression(destination)} = "
+                f"{reference_expression(source)};"
+            )
+            written.add(destination)
+            real_values[destination] = real_values.get(source, False)
+            continue
+        if operation == "fun" and len(raw_row) == 6:
+            function_name = getattr(raw_row[2], "get_name", None)
+            arguments = raw_row[4]
+            if (
+                callable(function_name)
+                and function_name() == "symbolica::sqrt"
+                and raw_row[3] == []
+                and isinstance(arguments, list)
+                and len(arguments) == 1
+                and isinstance(raw_row[5], bool)
+            ):
+                destination = parse_reference(raw_row[1], destination=True)
+                source = parse_reference(arguments[0])
+                if source[0] == "const":
+                    # Keep the saved evaluator exact; round constant radicals
+                    # only when emitting this f64 C++ evaluation path.
+                    value = cmath.sqrt(constants[source[1]])
+                    if raw_row[5] and value.imag != 0.0:
+                        raise NativeEvaluationError(
+                            "Symbolica real square-root metadata is inconsistent"
+                        )
+                    statements.append(
+                        f"    {reference_expression(destination)} = "
+                        f"direct_constant<Lane>({_cpp_f64(value.real)}, "
+                        f"{_cpp_f64(value.imag)});"
+                    )
+                    written.add(destination)
+                    real_values[destination] = value.imag == 0.0
+                    continue
+        raise NativeEvaluationError(
+            "native DirectApplication cannot lower Symbolica operation "
+            f"{operation!r}; refusing a dense-row fallback"
+        )
+    missing_outputs = [
+        index for index in range(spec.output_count) if ("out", index) not in written
+    ]
+    if missing_outputs:
+        raise NativeEvaluationError(
+            "Symbolica evaluator instructions do not assign every output: "
+            + ", ".join(str(index) for index in missing_outputs)
+        )
+    return _InstructionProgram(
+        statements=tuple(statements),
+        instruction_count=len(raw_instructions),
+        temporary_count=raw_temporary_count,
+        constants=constants,
+    )
+
+
+def _finite_complex(value: object) -> complex:
+    try:
+        converted = complex(value)
+    except (TypeError, ValueError, OverflowError) as error:
+        raise NativeEvaluationError(
+            "Symbolica evaluator constant cannot be represented as complex-f64"
+        ) from error
+    if not math.isfinite(converted.real) or not math.isfinite(converted.imag):
+        raise NativeEvaluationError(
+            "Symbolica evaluator constant is not finite complex-f64"
+        )
+    return converted
+
+
+def _cpp_f64(value: float) -> str:
+    if not math.isfinite(value):
+        raise NativeEvaluationError(
+            "native DirectApplication cannot emit non-finite constants"
+        )
+    return value.hex()
+
+
+def _cpp_string(value: str) -> str:
+    return (
+        value.replace("\\", "\\\\")
+        .replace('"', '\\"')
+        .replace("\n", "\\n")
+        .replace("\r", "\\r")
+        .replace("\t", "\\t")
+    )
+
+
+def _render_translation_unit(
+    *,
+    spec: NativeDirectCppSpec,
+    program: _InstructionProgram,
+    accesses: Sequence[_ParameterAccess],
+    input_plane_count: int,
+    scalar_input_count: int,
+    evaluator_state_sha256: str,
+    logical_stack_bytes: int,
+) -> str:
+    function_name = spec.function_name
+    vector_bytes = spec.simd_lane_width * 8
+    output_plane_count = 2 * spec.output_count
+    temporary_extent = max(program.temporary_count, 1)
+    output_extent = max(spec.output_count, 1)
+    feature_string = ",".join(spec.cpu_features)
+    statements = "\n".join(program.statements)
+    stores = "\n".join(
+        (
+            f"    direct_store_lane(outputs[{2 * index}].values, point, "
+            f"output[{index}].real);\n"
+            f"    direct_store_lane(outputs[{2 * index + 1}].values, point, "
+            f"output[{index}].imaginary);"
+        )
+        for index in range(spec.output_count)
+    )
+    del accesses  # accesses are fully compiled into the generated statements.
+    return f"""{_DIRECT_MARKER}
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <type_traits>
+
+#if !defined(__clang__) && !defined(__GNUC__)
+#error "pyAmpliCol native DirectApplication requires Clang or GCC vector extensions"
+#endif
+
+namespace pyamplicol_native_direct_{function_name} {{
+
+constexpr std::uint32_t kInputPlaneCount = {input_plane_count}u;
+constexpr std::uint32_t kScalarInputCount = {scalar_input_count}u;
+constexpr std::uint32_t kOutputPlaneCount = {output_plane_count}u;
+constexpr std::uint32_t kSimdLaneWidth = {spec.simd_lane_width}u;
+constexpr std::uint32_t kInstructionCount = {program.instruction_count}u;
+constexpr std::uint32_t kTemporaryCount = {program.temporary_count}u;
+constexpr std::uint32_t kLogicalStackBytes = {logical_stack_bytes}u;
+static_assert(kLogicalStackBytes <= {spec.max_logical_stack_bytes}u);
+
+using DirectVector = double __attribute__((vector_size({vector_bytes})));
+
+template <typename Lane>
+struct DirectComplex {{
+    Lane real;
+    Lane imaginary;
+}};
+
+template <typename Lane>
+inline Lane direct_broadcast(double value) noexcept {{
+    if constexpr (std::is_same_v<Lane, double>) {{
+        return value;
+    }} else {{
+        Lane result{{}};
+        for (std::size_t lane = 0; lane < sizeof(Lane) / sizeof(double); ++lane) {{
+            result[lane] = value;
+        }}
+        return result;
+    }}
+}}
+
+template <typename Lane>
+inline Lane direct_load_lane(const double* values, std::uint32_t point) noexcept {{
+    Lane result;
+    std::memcpy(&result, values + point, sizeof(Lane));
+    return result;
+}}
+
+template <typename Lane>
+inline void direct_store_lane(
+    double* values,
+    std::uint32_t point,
+    Lane value
+) noexcept {{
+    std::memcpy(values + point, &value, sizeof(Lane));
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_constant(double real, double imaginary) noexcept {{
+    return {{direct_broadcast<Lane>(real), direct_broadcast<Lane>(imaginary)}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_complex_plane(
+    const double* real,
+    const double* imaginary,
+    std::uint32_t point
+) noexcept {{
+    return {{direct_load_lane<Lane>(real, point),
+             direct_load_lane<Lane>(imaginary, point)}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_real_plane(
+    const double* real,
+    std::uint32_t point
+) noexcept {{
+    return {{direct_load_lane<Lane>(real, point), direct_broadcast<Lane>(0.0)}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_complex_scalar(
+    double real,
+    double imaginary
+) noexcept {{
+    return direct_constant<Lane>(real, imaginary);
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_real_scalar(double real) noexcept {{
+    return direct_constant<Lane>(real, 0.0);
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_add(
+    DirectComplex<Lane> left,
+    DirectComplex<Lane> right
+) noexcept {{
+    return {{left.real + right.real, left.imaginary + right.imaginary}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_multiply(
+    DirectComplex<Lane> left,
+    DirectComplex<Lane> right
+) noexcept {{
+    return {{
+        left.real * right.real - left.imaginary * right.imaginary,
+        left.real * right.imaginary + left.imaginary * right.real,
+    }};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_real_reciprocal(
+    DirectComplex<Lane> value
+) noexcept {{
+    return {{direct_broadcast<Lane>(1.0) / value.real,
+             direct_broadcast<Lane>(0.0)}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_complex_reciprocal(
+    DirectComplex<Lane> value
+) noexcept {{
+    const Lane denominator =
+        value.real * value.real + value.imaginary * value.imaginary;
+    return {{value.real / denominator, -value.imaginary / denominator}};
+}}
+
+struct NativeCompiledDirectInputPlaneV1 {{
+    const double* values;
+}};
+
+struct NativeCompiledDirectOutputPlaneV1 {{
+    double* values;
+}};
+
+struct NativeCompiledDirectScalarV1 {{
+    const double* value;
+}};
+
+struct NativeCompiledDirectMetadataV1 {{
+    std::uint32_t abi_version;
+    std::uint32_t struct_size;
+    std::uint32_t flags;
+    std::uint32_t input_plane_count;
+    std::uint32_t scalar_input_count;
+    std::uint32_t output_plane_count;
+    std::uint32_t simd_lane_width;
+    std::uint32_t reserved;
+}};
+
+template <typename Lane>
+inline void evaluate_direct_bundle(
+    const NativeCompiledDirectInputPlaneV1* inputs,
+    const NativeCompiledDirectScalarV1* scalars,
+    const NativeCompiledDirectOutputPlaneV1* outputs,
+    std::uint32_t point
+) noexcept {{
+    std::array<DirectComplex<Lane>, {temporary_extent}> temporary;
+    std::array<DirectComplex<Lane>, {output_extent}> output;
+{statements}
+{stores}
+}}
+
+}}  // namespace pyamplicol_native_direct_{function_name}
+
+extern "C" pyamplicol_native_direct_{function_name}::NativeCompiledDirectMetadataV1
+{function_name}_direct_application_v1_metadata() noexcept {{
+    using namespace pyamplicol_native_direct_{function_name};
+    return {{
+        1u,
+        static_cast<std::uint32_t>(sizeof(NativeCompiledDirectMetadataV1)),
+        {_DIRECT_FLAGS}u,
+        kInputPlaneCount,
+        kScalarInputCount,
+        kOutputPlaneCount,
+        kSimdLaneWidth,
+        0u,
+    }};
+}}
+
+extern "C" const char*
+{function_name}_direct_application_v1_target_triple() noexcept {{
+    return "{_cpp_string(spec.target_triple)}";
+}}
+
+extern "C" const char*
+{function_name}_direct_application_v1_cpu_features() noexcept {{
+    return "{_cpp_string(feature_string)}";
+}}
+
+extern "C" const char*
+{function_name}_direct_application_v1_source_sha256() noexcept {{
+    return "{evaluator_state_sha256}";
+}}
+
+extern "C" std::uint32_t
+{function_name}_direct_application_v1_logical_stack_bytes() noexcept {{
+    return pyamplicol_native_direct_{function_name}::kLogicalStackBytes;
+}}
+
+extern "C" int {function_name}_direct_application_v1(
+    const pyamplicol_native_direct_{function_name}::
+        NativeCompiledDirectInputPlaneV1* inputs,
+    std::uint32_t input_count,
+    const pyamplicol_native_direct_{function_name}::
+        NativeCompiledDirectScalarV1* scalars,
+    std::uint32_t scalar_count,
+    const pyamplicol_native_direct_{function_name}::
+        NativeCompiledDirectOutputPlaneV1* outputs,
+    std::uint32_t output_count,
+    std::uint32_t point_start,
+    std::uint32_t point_count
+) noexcept {{
+    using namespace pyamplicol_native_direct_{function_name};
+    try {{
+        if (input_count != kInputPlaneCount ||
+            scalar_count != kScalarInputCount ||
+            output_count != kOutputPlaneCount) {{
+            return 2;
+        }}
+        if ((input_count != 0u && inputs == nullptr) ||
+            (scalar_count != 0u && scalars == nullptr) ||
+            outputs == nullptr) {{
+            return 1;
+        }}
+        for (std::uint32_t input = 0; input < input_count; ++input) {{
+            if (inputs[input].values == nullptr) {{
+                return 3;
+            }}
+        }}
+        for (std::uint32_t scalar = 0; scalar < scalar_count; ++scalar) {{
+            if (scalars[scalar].value == nullptr) {{
+                return 3;
+            }}
+        }}
+        for (std::uint32_t output = 0; output < output_count; ++output) {{
+            if (outputs[output].values == nullptr) {{
+                return 3;
+            }}
+            for (std::uint32_t input = 0; input < input_count; ++input) {{
+                if (outputs[output].values == inputs[input].values) {{
+                    return 4;
+                }}
+            }}
+            for (std::uint32_t earlier = 0; earlier < output; ++earlier) {{
+                if (outputs[output].values == outputs[earlier].values) {{
+                    return 4;
+                }}
+            }}
+        }}
+        if (point_count == 0u) {{
+            return 5;
+        }}
+        const std::uint64_t point_stop_wide =
+            static_cast<std::uint64_t>(point_start) +
+            static_cast<std::uint64_t>(point_count);
+        if (point_stop_wide >
+            static_cast<std::uint64_t>(std::numeric_limits<std::uint32_t>::max())) {{
+            return 5;
+        }}
+        const std::uint32_t point_stop =
+            static_cast<std::uint32_t>(point_stop_wide);
+        const std::uint32_t vector_points =
+            (point_count / kSimdLaneWidth) * kSimdLaneWidth;
+        const std::uint32_t vector_stop = point_start + vector_points;
+        std::uint32_t point = point_start;
+        for (; point < vector_stop; point += kSimdLaneWidth) {{
+            evaluate_direct_bundle<DirectVector>(inputs, scalars, outputs, point);
+        }}
+        for (; point < point_stop; ++point) {{
+            evaluate_direct_bundle<double>(inputs, scalars, outputs, point);
+        }}
+        return 0;
+    }} catch (...) {{
+        return 6;
+    }}
+}}
+"""
+
+
+__all__ = [
+    "NATIVE_COMPILED_DIRECT_APPLICATION_ABI",
+    "NativeDirectCppArtifact",
+    "NativeDirectCppCompiler",
+    "NativeDirectCppParameterKind",
+    "NativeDirectCppSource",
+    "NativeDirectCppSpec",
+    "compile_native_direct_cpp",
+    "compiler_from_symbolica_settings",
+    "render_native_direct_cpp",
+]
diff --git a/pyamplicol/src/pyamplicol/evaluators/native_eager_direct_cpp.py b/pyamplicol/src/pyamplicol/evaluators/native_eager_direct_cpp.py
new file mode 100644
index 0000000000..803bb47bae
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/evaluators/native_eager_direct_cpp.py
@@ -0,0 +1,518 @@
+# SPDX-License-Identifier: 0BSD
+"""Emit a genuine native eager DirectTable callable.
+
+The ordinary compiled prepared-kernel entry accepts one dense complex row.
+This producer deliberately does not call it.  Instead it lowers the retained
+Symbolica instruction program directly into a row-outer, point-inner callable
+whose inputs and ordered fanout destinations are persistent split-complex
+planes.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from typing import Any
+
+from .._internal.physics.types import NativeEvaluationError
+from .native_direct_cpp import (
+    NativeDirectCppParameterKind,
+    NativeDirectCppSpec,
+    _lower_instruction_program,
+    _ParameterAccess,
+)
+from .symbolica_helpers import _symbolica_instruction_program
+
+NATIVE_EAGER_DIRECT_TABLE_APPLICATION_ABI = "pyamplicol-eager-native-direct-table-v1"
+_MARKER = "// pyAmpliCol genuine native eager DirectTable producer v1"
+_SUPPORTED_LANES = frozenset({2, 4})
+
+
+@dataclass(frozen=True, slots=True)
+class NativeEagerDirectTableSource:
+    source: str
+    function_name: str
+    evaluator_state_sha256: str
+    instruction_count: int
+    temporary_count: int
+    input_complex_count: int
+    output_complex_count: int
+    invocation_stride: int
+    attachment_stride: int
+    simd_lane_width: int
+
+
+def render_native_eager_direct_table_cpp(
+    evaluator: Any,
+    *,
+    kernel_id: int,
+    input_complex_count: int,
+    output_complex_count: int,
+    target_triple: str,
+    simd_lane_width: int = 2,
+    real_parameter_indices: tuple[int, ...] = (),
+    evaluator_state_bytes: bytes | None = None,
+) -> NativeEagerDirectTableSource:
+    """Render one direct-only table export from retained evaluator MIR."""
+
+    if kernel_id < 0 or kernel_id >= 2**32:
+        raise NativeEvaluationError("native eager DirectTable kernel ID exceeds u32")
+    if input_complex_count < 1 or output_complex_count < 1:
+        raise NativeEvaluationError(
+            "native eager DirectTable input/output widths must be positive"
+        )
+    if simd_lane_width not in _SUPPORTED_LANES:
+        raise NativeEvaluationError(
+            "native eager DirectTable SIMD width must be 2 or 4"
+        )
+    if not target_triple or "\x00" in target_triple:
+        raise NativeEvaluationError("native eager DirectTable target is invalid")
+
+    function_name = f"pyamplicol_eager_direct_table_k{kernel_id:08x}_v1"
+    get_instructions = getattr(evaluator, "get_instructions", None)
+    save = getattr(evaluator, "save", None)
+    if not callable(get_instructions) or (
+        evaluator_state_bytes is None and not callable(save)
+    ):
+        raise NativeEvaluationError(
+            "native eager DirectTable production requires retained Symbolica "
+            "instructions and evaluator state"
+        )
+    try:
+        raw_program = _symbolica_instruction_program(get_instructions())
+        evaluator_state = (
+            save() if evaluator_state_bytes is None else evaluator_state_bytes
+        )
+    except Exception as error:
+        raise NativeEvaluationError(
+            "Symbolica could not expose the eager DirectTable instruction program"
+        ) from error
+    if not isinstance(evaluator_state, bytes) or not evaluator_state:
+        raise NativeEvaluationError(
+            "Symbolica returned invalid eager DirectTable evaluator state"
+        )
+
+    real_parameters = frozenset(real_parameter_indices)
+    if any(index < 0 or index >= input_complex_count for index in real_parameters):
+        raise NativeEvaluationError(
+            "native eager DirectTable real parameter index is out of bounds"
+        )
+    parameter_kinds = tuple(
+        (
+            NativeDirectCppParameterKind.REAL_PLANE
+            if index in real_parameters
+            else NativeDirectCppParameterKind.COMPLEX_PLANE
+        )
+        for index in range(input_complex_count)
+    )
+    spec = NativeDirectCppSpec(
+        function_name=function_name,
+        parameter_kinds=parameter_kinds,
+        output_count=output_complex_count,
+        target_triple=target_triple,
+        simd_lane_width=simd_lane_width,
+    )
+    accesses = tuple(
+        _ParameterAccess(
+            kind,
+            2 * index,
+            (
+                2 * index + 1
+                if kind is NativeDirectCppParameterKind.COMPLEX_PLANE
+                else None
+            ),
+        )
+        for index, kind in enumerate(parameter_kinds)
+    )
+    input_plane_count = 2 * input_complex_count
+    program = _lower_instruction_program(raw_program, spec, accesses)
+    invocation_stride = (input_plane_count + 2) * 4
+    attachment_stride = (2 * output_complex_count + 2) * 4
+    source = _render_translation_unit(
+        function_name=function_name,
+        statements="\n".join(program.statements),
+        input_plane_count=input_plane_count,
+        output_complex_count=output_complex_count,
+        temporary_count=program.temporary_count,
+        invocation_stride=invocation_stride,
+        attachment_stride=attachment_stride,
+        simd_lane_width=simd_lane_width,
+        evaluator_state_sha256=hashlib.sha256(evaluator_state).hexdigest(),
+        target_triple=target_triple,
+    )
+    return NativeEagerDirectTableSource(
+        source=source,
+        function_name=function_name,
+        evaluator_state_sha256=hashlib.sha256(evaluator_state).hexdigest(),
+        instruction_count=program.instruction_count,
+        temporary_count=program.temporary_count,
+        input_complex_count=input_complex_count,
+        output_complex_count=output_complex_count,
+        invocation_stride=invocation_stride,
+        attachment_stride=attachment_stride,
+        simd_lane_width=simd_lane_width,
+    )
+
+
+def _cpp_string(value: str) -> str:
+    return (
+        value.replace("\\", "\\\\")
+        .replace('"', '\\"')
+        .replace("\n", "\\n")
+        .replace("\r", "\\r")
+        .replace("\t", "\\t")
+    )
+
+
+def _render_translation_unit(
+    *,
+    function_name: str,
+    statements: str,
+    input_plane_count: int,
+    output_complex_count: int,
+    temporary_count: int,
+    invocation_stride: int,
+    attachment_stride: int,
+    simd_lane_width: int,
+    evaluator_state_sha256: str,
+    target_triple: str,
+) -> str:
+    vector_bytes = 8 * simd_lane_width
+    temporary_extent = max(temporary_count, 1)
+    output_extent = max(output_complex_count, 1)
+    input_extent = max(input_plane_count, 1)
+    destination_stores = "\n".join(
+        f"""
+      const std::uint32_t destination_re_{output} =
+          read_u32(attachment + {8 * output}u);
+      const std::uint32_t destination_im_{output} =
+          read_u32(attachment + {8 * output + 4}u);
+      if (destination_re_{output} >= view->plane_count ||
+          destination_im_{output} >= view->plane_count) return 2;
+      const DirectPlane destination_real_{output} =
+          view->planes[destination_re_{output}];
+      const DirectPlane destination_imag_{output} =
+          view->planes[destination_im_{output}];
+      if (destination_real_{output}.values == nullptr ||
+          destination_imag_{output}.values == nullptr ||
+          point_stop > destination_real_{output}.len ||
+          point_stop > destination_imag_{output}.len) return 2;
+      const Lane scaled_re_{output} =
+          output[{output}].real * factor_re -
+          output[{output}].imaginary * factor_im;
+      const Lane scaled_im_{output} =
+          output[{output}].real * factor_im +
+          output[{output}].imaginary * factor_re;
+      if (operation == 0u) {{
+        store_lane(destination_real_{output}.values, point, scaled_re_{output});
+        store_lane(destination_imag_{output}.values, point, scaled_im_{output});
+      }} else {{
+        store_lane(
+            destination_real_{output}.values,
+            point,
+            load_lane<Lane>(destination_real_{output}.values, point) +
+                scaled_re_{output});
+        store_lane(
+            destination_imag_{output}.values,
+            point,
+            load_lane<Lane>(destination_imag_{output}.values, point) +
+                scaled_im_{output});
+      }}"""
+        for output in range(output_complex_count)
+    )
+    return f"""{_MARKER}
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <type_traits>
+
+#if !defined(__clang__) && !defined(__GNUC__)
+#error "pyAmpliCol native eager DirectTable requires Clang or GCC"
+#endif
+
+namespace pyamplicol_native_eager_{function_name} {{
+
+constexpr std::uint32_t kInputPlaneCount = {input_plane_count}u;
+constexpr std::uint32_t kOutputComplexCount = {output_complex_count}u;
+constexpr std::uint32_t kInvocationStride = {invocation_stride}u;
+constexpr std::uint32_t kAttachmentStride = {attachment_stride}u;
+constexpr std::uint32_t kSimdLaneWidth = {simd_lane_width}u;
+
+using DirectVector = double __attribute__((vector_size({vector_bytes})));
+
+template <typename Lane>
+struct DirectComplex {{
+  Lane real;
+  Lane imaginary;
+}};
+
+struct DirectPlane {{
+  double* values;
+  std::size_t len;
+}};
+
+struct DirectScalar {{
+  const double* value;
+}};
+
+struct DirectTableCallViewV1 {{
+  const std::uint8_t* invocations;
+  std::uint32_t invocation_count;
+  std::uint32_t invocation_stride;
+  const std::uint8_t* attachments;
+  std::uint32_t attachment_count;
+  std::uint32_t attachment_stride;
+  const DirectPlane* planes;
+  std::uint32_t plane_count;
+  std::uint32_t scalar_count;
+  const DirectScalar* scalars;
+  const double* factor_re;
+  const double* factor_im;
+  std::uint32_t factor_count;
+  std::uint32_t point_start;
+  std::uint32_t point_count;
+}};
+
+struct NativeEagerDirectTableMetadataV1 {{
+  std::uint32_t struct_size;
+  std::uint32_t abi_version;
+  std::uint32_t flags;
+  std::uint32_t invocation_stride;
+  std::uint32_t attachment_stride;
+  std::uint32_t input_complex_count;
+  std::uint32_t output_complex_count;
+  std::uint32_t simd_lane_width;
+  const char* application_abi;
+  const char* function_name;
+  const char* target_triple;
+  const char* evaluator_state_sha256;
+}};
+
+static_assert(sizeof(void*) == 8u);
+static_assert(sizeof(DirectPlane) == 16u);
+
+inline std::uint32_t read_u32(const std::uint8_t* source) noexcept {{
+  std::uint32_t value = 0u;
+  std::memcpy(&value, source, sizeof(value));
+  return value;
+}}
+
+template <typename Lane>
+inline Lane broadcast(double value) noexcept {{
+  if constexpr (std::is_same_v<Lane, double>) {{
+    return value;
+  }} else {{
+    Lane result{{}};
+    for (std::size_t lane = 0; lane < sizeof(Lane) / sizeof(double); ++lane) {{
+      result[lane] = value;
+    }}
+    return result;
+  }}
+}}
+
+template <typename Lane>
+inline Lane load_lane(const double* values, std::uint32_t point) noexcept {{
+  Lane result;
+  std::memcpy(&result, values + point, sizeof(Lane));
+  return result;
+}}
+
+template <typename Lane>
+inline void store_lane(
+    double* values, std::uint32_t point, Lane value) noexcept {{
+  std::memcpy(values + point, &value, sizeof(Lane));
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_constant(
+    double real, double imaginary) noexcept {{
+  return {{broadcast<Lane>(real), broadcast<Lane>(imaginary)}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_complex_plane(
+    const double* real,
+    const double* imaginary,
+    std::uint32_t point) noexcept {{
+  return {{load_lane<Lane>(real, point), load_lane<Lane>(imaginary, point)}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_real_plane(
+    const double* real, std::uint32_t point) noexcept {{
+  return {{load_lane<Lane>(real, point), broadcast<Lane>(0.0)}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_complex_scalar(
+    double real, double imaginary) noexcept {{
+  return direct_constant<Lane>(real, imaginary);
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_real_scalar(double real) noexcept {{
+  return direct_constant<Lane>(real, 0.0);
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_add(
+    DirectComplex<Lane> left, DirectComplex<Lane> right) noexcept {{
+  return {{left.real + right.real, left.imaginary + right.imaginary}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_multiply(
+    DirectComplex<Lane> left, DirectComplex<Lane> right) noexcept {{
+  return {{
+      left.real * right.real - left.imaginary * right.imaginary,
+      left.real * right.imaginary + left.imaginary * right.real}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_real_reciprocal(
+    DirectComplex<Lane> value) noexcept {{
+  return {{broadcast<Lane>(1.0) / value.real, broadcast<Lane>(0.0)}};
+}}
+
+template <typename Lane>
+inline DirectComplex<Lane> direct_complex_reciprocal(
+    DirectComplex<Lane> value) noexcept {{
+  const Lane denominator =
+      value.real * value.real + value.imaginary * value.imaginary;
+  return {{value.real / denominator, -value.imaginary / denominator}};
+}}
+
+template <typename Lane>
+int evaluate_invocation(
+    const DirectTableCallViewV1* view,
+    const std::array<DirectPlane, {input_extent}>& inputs,
+    std::uint32_t attachment_start,
+    std::uint32_t attachment_count,
+    std::uint32_t point,
+    std::uint32_t point_stop) noexcept {{
+  std::array<DirectComplex<Lane>, {temporary_extent}> temporary;
+  std::array<DirectComplex<Lane>, {output_extent}> output;
+{statements}
+  for (std::uint32_t attachment_index = 0u;
+       attachment_index < attachment_count;
+       ++attachment_index) {{
+    const std::uint8_t* attachment =
+        view->attachments +
+        static_cast<std::size_t>(attachment_start + attachment_index) *
+            kAttachmentStride;
+    const std::uint32_t factor_id =
+        read_u32(attachment + {8 * output_complex_count}u);
+    const std::uint32_t operation =
+        read_u32(attachment + {8 * output_complex_count + 4}u);
+    if (factor_id >= view->factor_count || operation > 1u) return 2;
+    const Lane factor_re = broadcast<Lane>(view->factor_re[factor_id]);
+    const Lane factor_im = broadcast<Lane>(view->factor_im[factor_id]);
+{destination_stores}
+  }}
+  return 0;
+}}
+
+}}  // namespace pyamplicol_native_eager_{function_name}
+
+extern "C" const pyamplicol_native_eager_{function_name}::
+    NativeEagerDirectTableMetadataV1*
+{function_name}_metadata_v1() noexcept {{
+  using Metadata = pyamplicol_native_eager_{function_name}::
+      NativeEagerDirectTableMetadataV1;
+  static const Metadata metadata{{
+      static_cast<std::uint32_t>(sizeof(Metadata)),
+      1u,
+      0x1fu,
+      {invocation_stride}u,
+      {attachment_stride}u,
+      {input_plane_count // 2}u,
+      {output_complex_count}u,
+      {simd_lane_width}u,
+      "{NATIVE_EAGER_DIRECT_TABLE_APPLICATION_ABI}",
+      "{function_name}",
+      "{_cpp_string(target_triple)}",
+      "{evaluator_state_sha256}"}};
+  return &metadata;
+}}
+
+extern "C" const char* {function_name}_target_triple() noexcept {{
+  return "{_cpp_string(target_triple)}";
+}}
+
+extern "C" const char* {function_name}_source_sha256() noexcept {{
+  return "{evaluator_state_sha256}";
+}}
+
+extern "C" int {function_name}(
+    const pyamplicol_native_eager_{function_name}::
+        DirectTableCallViewV1* view) noexcept {{
+  using namespace pyamplicol_native_eager_{function_name};
+  try {{
+    if (view == nullptr || view->invocations == nullptr ||
+        view->planes == nullptr || view->factor_re == nullptr ||
+        view->factor_im == nullptr ||
+        view->invocation_stride != kInvocationStride ||
+        view->attachment_stride != kAttachmentStride ||
+        view->invocation_count == 0u || view->point_count == 0u ||
+        view->scalar_count != 0u ||
+        (view->attachment_count != 0u && view->attachments == nullptr)) {{
+      return 2;
+    }}
+    const std::uint64_t point_stop_wide =
+        static_cast<std::uint64_t>(view->point_start) + view->point_count;
+    if (point_stop_wide >
+        static_cast<std::uint64_t>(
+            std::numeric_limits<std::uint32_t>::max())) return 2;
+    const std::uint32_t point_stop =
+        static_cast<std::uint32_t>(point_stop_wide);
+    for (std::uint32_t invocation_index = 0u;
+         invocation_index < view->invocation_count;
+         ++invocation_index) {{
+      const std::uint8_t* invocation =
+          view->invocations +
+          static_cast<std::size_t>(invocation_index) * kInvocationStride;
+      std::array<DirectPlane, {input_extent}> inputs{{}};
+      for (std::uint32_t input = 0u; input < kInputPlaneCount; ++input) {{
+        const std::uint32_t plane_id = read_u32(invocation + 4u * input);
+        if (plane_id >= view->plane_count) return 2;
+        inputs[input] = view->planes[plane_id];
+        if (inputs[input].values == nullptr ||
+            point_stop > inputs[input].len) return 2;
+      }}
+      const std::uint32_t attachment_start =
+          read_u32(invocation + 4u * kInputPlaneCount);
+      const std::uint32_t attachment_count =
+          read_u32(invocation + 4u * (kInputPlaneCount + 1u));
+      if (static_cast<std::uint64_t>(attachment_start) + attachment_count >
+          view->attachment_count) return 2;
+
+      const std::uint32_t vector_count =
+          (view->point_count / kSimdLaneWidth) * kSimdLaneWidth;
+      const std::uint32_t vector_stop = view->point_start + vector_count;
+      std::uint32_t point = view->point_start;
+      for (; point < vector_stop; point += kSimdLaneWidth) {{
+        const int status = evaluate_invocation<DirectVector>(
+            view, inputs, attachment_start, attachment_count, point, point_stop);
+        if (status != 0) return status;
+      }}
+      for (; point < point_stop; ++point) {{
+        const int status = evaluate_invocation<double>(
+            view, inputs, attachment_start, attachment_count, point, point_stop);
+        if (status != 0) return status;
+      }}
+    }}
+    return 0;
+  }} catch (...) {{
+    return 3;
+  }}
+}}
+"""
+
+
+__all__ = [
+    "NATIVE_EAGER_DIRECT_TABLE_APPLICATION_ABI",
+    "NativeEagerDirectTableSource",
+    "render_native_eager_direct_table_cpp",
+]
diff --git a/pyamplicol/src/pyamplicol/evaluators/symbolica.py b/pyamplicol/src/pyamplicol/evaluators/symbolica.py
new file mode 100644
index 0000000000..d0663000ad
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/evaluators/symbolica.py
@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: 0BSD
+"""Compatibility facade for Symbolica evaluator construction."""
+
+from __future__ import annotations
+
+from .symbolica_adapters import (
+    _ChunkedSymbolicaEvaluator,
+    _load_symbolica_evaluator_artifact,
+)
+from .symbolica_adapters import (
+    _CompiledComplexEvaluatorAdapter as _CompiledComplexEvaluatorAdapter,
+)
+from .symbolica_adapters import (
+    _JITSymbolicaEvaluatorAdapter as _JITSymbolicaEvaluatorAdapter,
+)
+from .symbolica_compile import _compile_symbolica_outputs
+from .symbolica_helpers import (
+    ComplexOutput,
+    _artifact_path_for_manifest,
+    _artifact_path_from_manifest,
+    _evaluate_complex_outputs,
+    _symbolica_evaluator_artifact_manifest,
+)
+from .symbolica_settings import ProgressCallback, SymbolicaEvaluatorSettings
+
+__all__ = [
+    "ComplexOutput",
+    "ProgressCallback",
+    "SymbolicaEvaluatorSettings",
+    "_ChunkedSymbolicaEvaluator",
+    "_artifact_path_for_manifest",
+    "_artifact_path_from_manifest",
+    "_compile_symbolica_outputs",
+    "_evaluate_complex_outputs",
+    "_load_symbolica_evaluator_artifact",
+    "_symbolica_evaluator_artifact_manifest",
+]
diff --git a/pyamplicol/src/pyamplicol/evaluators/symbolica_adapters.py b/pyamplicol/src/pyamplicol/evaluators/symbolica_adapters.py
new file mode 100644
index 0000000000..2acfb58429
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/evaluators/symbolica_adapters.py
@@ -0,0 +1,1040 @@
+# SPDX-License-Identifier: 0BSD
+"""Runtime adapters for JIT, compiled, and chunked Symbolica evaluators."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import struct
+import sys
+import tempfile
+import time
+import uuid
+from collections.abc import Mapping, Sequence
+from concurrent.futures import ThreadPoolExecutor
+from itertools import pairwise
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from .._internal.physics.types import NativeEvaluationError
+from .._internal.versions import (
+    SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+    SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+    SYMJIT_APPLICATION_ABI,
+    SYMJIT_F64_RUNTIME_CAPABILITY,
+    SYMJIT_PLANE_APPLICATION_ABI,
+    verify_native_module,
+)
+from .execution_schema import aggregate_runtime_capabilities
+from .symbolica_helpers import (
+    _artifact_path_for_manifest,
+    _artifact_path_from_manifest,
+    _artifact_subdirectory,
+    _complex128_parameter_rows,
+    _evaluate_prepared_complex,
+    _evaluate_prepared_complex_profiled,
+    _safe_symbol_name,
+    _symbolica_evaluator_artifact_manifest,
+    _symbolica_instruction_program_repr,
+)
+from .symbolica_settings import (
+    ProgressCallback,
+    SymbolicaEvaluatorSettings,
+    _report_progress,
+)
+
+
+class _JITSymbolicaEvaluatorAdapter:
+    def __init__(
+        self,
+        evaluator: Any,
+        settings: SymbolicaEvaluatorSettings,
+        label: str,
+        *,
+        input_len: int,
+        output_len: int,
+        progress_callback: ProgressCallback | None = None,
+    ) -> None:
+        self.input_len = int(input_len)
+        self.output_len = int(output_len)
+        self.backend = settings.backend
+        self.settings = settings.to_json_dict()
+        self.label = _safe_symbol_name(label)
+        self._source_evaluator = evaluator
+        self._progress_callback = progress_callback
+        self.application_path: Path | None = None
+        self.evaluator_state_path: Path | None = None
+        self.build_timing: dict[str, float] = {}
+
+    def evaluate_complex(self, parameter_rows: Any) -> Any:
+        return self._source_evaluator.evaluate_complex(parameter_rows)
+
+    def evaluate_complex_profiled(
+        self, parameter_rows: Any
+    ) -> tuple[Any, tuple[float, float, float]]:
+        return self._evaluate_complex_profiled_prepared(
+            _complex128_parameter_rows(parameter_rows)
+        )
+
+    def supports_complex_profiled(self) -> bool:
+        return callable(
+            getattr(self._source_evaluator, "evaluate_complex_profiled", None)
+        )
+
+    def evaluate(self, parameter_rows: Any) -> Any:
+        return self._source_evaluator.evaluate(parameter_rows)
+
+    def _evaluate_complex_prepared(self, parameter_rows: np.ndarray) -> Any:
+        return self._source_evaluator.evaluate_complex(parameter_rows)
+
+    def _evaluate_complex_profiled_prepared(
+        self, parameter_rows: np.ndarray
+    ) -> tuple[Any, tuple[float, float, float]]:
+        profile = getattr(self._source_evaluator, "evaluate_complex_profiled", None)
+        if not callable(profile):
+            raise NativeEvaluationError(
+                "this Symbolica build does not expose native complex profiling"
+            )
+        output, timing = profile(parameter_rows)
+        if not isinstance(timing, tuple) or len(timing) != 3:
+            raise NativeEvaluationError(
+                "Symbolica returned an invalid native complex profile"
+            )
+        return output, tuple(float(value) for value in timing)
+
+    def materialize(self) -> None:
+        self._ensure_jit_compiled()
+
+    def _ensure_jit_compiled(self) -> None:
+        dummy = np.ones((1, self.input_len), dtype=np.complex128)
+        self._source_evaluator.evaluate_complex(dummy)
+
+    @classmethod
+    def from_artifact(
+        cls,
+        manifest: dict[str, Any],
+        artifact_dir: Path,
+    ) -> _JITSymbolicaEvaluatorAdapter:
+        from symbolica import Evaluator
+
+        instance = cls.__new__(cls)
+        instance.input_len = int(manifest["input_len"])
+        instance.output_len = int(manifest["output_len"])
+        instance.backend = str(manifest["backend"])
+        instance.settings = dict(manifest.get("settings", {}))
+        instance.label = str(manifest.get("label", "jit_symbolica_evaluator"))
+        application_path = manifest.get("application_path")
+        instance.application_path = (
+            None
+            if application_path is None
+            else _artifact_path_from_manifest(str(application_path), artifact_dir)
+        )
+        instance.evaluator_state_path = _artifact_path_from_manifest(
+            str(manifest["evaluator_state_path"]),
+            artifact_dir,
+        )
+        instance._source_evaluator = Evaluator.load(
+            instance.evaluator_state_path.read_bytes()
+        )
+        instance._progress_callback = None
+        instance.build_timing = {}
+        return instance
+
+    def artifact_manifest(self, artifact_dir: Path) -> dict[str, Any]:
+        if bool(self.settings.get("jit_direct_translation")):
+            raise NativeEvaluationError(
+                "direct SymJIT translation cannot be persisted as a portable "
+                "process artifact; use indirect translation"
+            )
+        _report_progress(
+            self._progress_callback,
+            stage="jit materialize",
+            item=self.label,
+        )
+        materialize_started = time.perf_counter()
+        self._ensure_jit_compiled()
+        jit_compile_s = time.perf_counter() - materialize_started
+        _report_progress(
+            self._progress_callback,
+            stage="jit materialized",
+            item=f"{self.label} {jit_compile_s:.3f}s",
+            increment=1,
+        )
+        evaluator_dir = _artifact_subdirectory(artifact_dir, "evaluators")
+        unique = uuid.uuid4().hex
+        application_path = evaluator_dir / f"{self.label}_{unique}.symjit"
+        plane_application_path = evaluator_dir / f"{self.label}_{unique}.plane.symjit"
+        evaluator_state_path = evaluator_dir / f"{self.label}_{unique}.evaluator.bin"
+        save_started = time.perf_counter()
+        application, element_layout = self._export_symjit_application()
+        application_path.write_bytes(application)
+        application_export_s = time.perf_counter() - save_started
+        plane_export_started = time.perf_counter()
+        (
+            plane_application,
+            plane_source_digest,
+            plane_target,
+        ) = self._export_symjit_plane_application(
+            optimization_level=self._optimization_level(),
+        )
+        plane_application_path.write_bytes(plane_application)
+        plane_application_export_s = time.perf_counter() - plane_export_started
+        state_save_started = time.perf_counter()
+        evaluator_state_path.write_bytes(self._source_evaluator.save())
+        evaluator_save_s = time.perf_counter() - save_started
+        evaluator_state_save_s = time.perf_counter() - state_save_started
+        self.application_path = application_path
+        self.evaluator_state_path = evaluator_state_path
+        build_timing = dict(self.build_timing)
+        build_timing["jit_materialize_s"] = jit_compile_s
+        build_timing["symjit_application_export_s"] = application_export_s
+        build_timing["symjit_plane_application_export_s"] = plane_application_export_s
+        build_timing["evaluator_save_s"] = evaluator_state_save_s
+        build_timing["artifact_manifest_s"] = jit_compile_s + evaluator_save_s
+        optimization_level = self._optimization_level()
+        return {
+            "kind": "symjit-application-evaluator",
+            "runtime_capability": SYMJIT_F64_RUNTIME_CAPABILITY,
+            "backend": self.backend,
+            "label": self.label,
+            "input_len": self.input_len,
+            "output_len": self.output_len,
+            "application_path": _artifact_path_for_manifest(
+                application_path, artifact_dir
+            ),
+            "application_abi": SYMJIT_APPLICATION_ABI,
+            "plane_application": {
+                "application_path": _artifact_path_for_manifest(
+                    plane_application_path,
+                    artifact_dir,
+                ),
+                "application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+                "storage_abi": SYMJIT_APPLICATION_ABI,
+                "element_layout": "split-complex-plane-major",
+                "descriptor_order": "inputs-re-im-then-outputs-re-im",
+                "input_complex_count": self.input_len,
+                "output_complex_count": self.output_len,
+                "input_plane_count": 2 * self.input_len,
+                "output_plane_count": 2 * self.output_len,
+                "compiler_type": "native",
+                "translation_mode": "symbolica-structured-instructions",
+                "optimization_level": optimization_level,
+                "simd": True,
+                "complex": True,
+                "fast_math": True,
+                "fast_complex": False,
+                "compression": bool(self.settings.get("jit_compress", False)),
+                "threading": False,
+                "direct_arena": True,
+                "source_digest": plane_source_digest,
+                "target": plane_target,
+            },
+            "element_layout": element_layout,
+            "batch_layout": "row-major",
+            "compiler_type": "native",
+            "translation_mode": "indirect",
+            "optimization_level": optimization_level,
+            "word_bits": struct.calcsize("P") * 8,
+            "endianness": sys.byteorder,
+            "required_defuns": [],
+            "evaluator_state_path": _artifact_path_for_manifest(
+                evaluator_state_path, artifact_dir
+            ),
+            "evaluator_state_runtime_capability": (
+                SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY
+            ),
+            "settings": self.settings,
+            "build_timing": build_timing,
+        }
+
+    def _optimization_level(self) -> int:
+        optimization_level = self.settings.get("jit_optimization_level", 2)
+        if (
+            isinstance(optimization_level, bool)
+            or not isinstance(optimization_level, int)
+            or optimization_level not in {0, 1, 2, 3}
+        ):
+            raise NativeEvaluationError("invalid SymJIT optimization-level metadata")
+        return optimization_level
+
+    def _export_symjit_plane_application(
+        self,
+        *,
+        optimization_level: int,
+    ) -> tuple[bytes, str, dict[str, object]]:
+        """Compile a standard complex P-kernel from Symbolica instructions."""
+
+        instructions = getattr(self._source_evaluator, "get_instructions", None)
+        if not callable(instructions):
+            raise NativeEvaluationError(
+                "this Symbolica build cannot expose structured evaluator "
+                "instructions for a direct-arena P-kernel; install the pinned "
+                "pyAmpliCol candidate dependency"
+            )
+        try:
+            program_repr = _symbolica_instruction_program_repr(instructions())
+        except Exception as error:
+            raise NativeEvaluationError(
+                "Symbolica could not export structured evaluator instructions "
+                "for a direct-arena P-kernel"
+            ) from error
+        if not program_repr:
+            raise NativeEvaluationError(
+                "Symbolica returned empty direct-arena P-kernel instructions"
+            )
+
+        try:
+            rusticol = importlib.import_module("pyamplicol._rusticol")
+            verify_native_module(rusticol)
+        except Exception as error:
+            raise NativeEvaluationError(
+                "the Rusticol extension required to compile a direct-arena "
+                "P-kernel is unavailable; reinstall pyAmpliCol"
+            ) from error
+        compile_plane = getattr(
+            rusticol,
+            "_compile_symjit_plane_application_v2",
+            None,
+        )
+        if not callable(compile_plane):
+            raise NativeEvaluationError(
+                "the installed Rusticol extension does not expose the SymJIT "
+                "2.22 plane compiler; reinstall pyAmpliCol"
+            )
+        try:
+            application = compile_plane(
+                program_repr,
+                self.input_len,
+                self.output_len,
+                optimization_level,
+                bool(self.settings.get("jit_compress", False)),
+            )
+        except Exception as error:
+            raise NativeEvaluationError(
+                "SymJIT could not compile the structured evaluator instructions "
+                "as a complex direct-arena P-kernel"
+            ) from error
+        if not isinstance(application, bytes) or not application:
+            raise NativeEvaluationError(
+                "Rusticol returned an empty or non-bytes direct-arena P-kernel"
+            )
+
+        target_info = getattr(rusticol, "target_info", None)
+        target: dict[str, object] = {
+            "word_bits": struct.calcsize("P") * 8,
+            "endianness": sys.byteorder,
+        }
+        if callable(target_info):
+            info = target_info()
+            triple = getattr(info, "triple", None)
+            cpu_features = getattr(info, "cpu_features", None)
+            if isinstance(triple, str) and triple:
+                target["triple"] = triple
+            if isinstance(cpu_features, list) and all(
+                isinstance(value, str) for value in cpu_features
+            ):
+                target["cpu_features"] = list(cpu_features)
+        return (
+            application,
+            hashlib.sha256(program_repr.encode("utf-8")).hexdigest(),
+            target,
+        )
+
+    def _export_symjit_application(self) -> tuple[bytes, str]:
+        if struct.calcsize("P") * 8 != 64 or sys.byteorder != "little":
+            raise NativeEvaluationError(
+                "direct SymJIT f64 artifacts require a 64-bit little-endian host"
+            )
+        exporter = getattr(self._source_evaluator, "export_symjit", None)
+        if not callable(exporter):
+            raise NativeEvaluationError(
+                "this Symbolica build cannot export a direct SymJIT f64 application; "
+                "install the pinned pyAmpliCol candidate dependency"
+            )
+        try:
+            application = exporter(complex=True)
+        except Exception as error:
+            raise NativeEvaluationError(
+                "Symbolica could not export a self-contained SymJIT f64 application; "
+                "external evaluator functions are not supported in process artifacts"
+            ) from error
+        if not isinstance(application, bytes) or not application:
+            raise NativeEvaluationError(
+                "Symbolica returned an empty or non-bytes SymJIT application"
+            )
+        expected_layout = _symjit_element_layout()
+        return application, expected_layout
+
+
+class _CompiledComplexEvaluatorAdapter:
+    def __init__(
+        self,
+        evaluator: Any,
+        settings: SymbolicaEvaluatorSettings,
+        label: str,
+        *,
+        input_len: int,
+        output_len: int,
+        compile_dense: bool = True,
+    ) -> None:
+        safe_label = _safe_symbol_name(label)
+        unique = uuid.uuid4().hex
+        function_name = f"pyamplicol_{safe_label}_{unique}"
+        self.function_name = function_name
+        self.input_len = int(input_len)
+        self.output_len = int(output_len)
+        self.backend = settings.backend
+        self.settings = settings.to_json_dict()
+        self.runtime_capability = _compiled_runtime_capability(self.settings)
+        self.number_type = "complex"
+        self._source_evaluator = evaluator
+        self.build_timing: dict[str, float] = {}
+        if settings.compiled_output_dir is None:
+            self._tmpdir: tempfile.TemporaryDirectory[str] | None = (
+                tempfile.TemporaryDirectory(prefix="pyamplicol-symbolica-")
+            )
+            path = Path(self._tmpdir.name)
+        else:
+            self._tmpdir = None
+            path = Path(settings.compiled_output_dir).expanduser()
+            path.mkdir(parents=True, exist_ok=True)
+        self.source_path = path / f"{function_name}.cpp"
+        self.library_path = path / f"lib{function_name}"
+        self.evaluator_state_path: Path | None = path / f"{function_name}.evaluator.bin"
+        save = getattr(evaluator, "save", None)
+        if callable(save):
+            save_started = time.perf_counter()
+            self.evaluator_state_path.write_bytes(save())
+            self.build_timing["evaluator_save_s"] = time.perf_counter() - save_started
+        else:
+            self.evaluator_state_path = None
+        self._compiled = None
+        if compile_dense:
+            compile_started = time.perf_counter()
+            compile_kwargs: dict[str, object] = {
+                "inline_asm": settings.compiled_inline_asm,
+                "optimization_level": settings.compiled_optimization_level,
+                "native": settings.compiled_native,
+                "compiler_path": settings.compiler_path,
+                "compiler_flags": _compiled_compiler_flags(settings),
+            }
+            custom_header = _compiled_complex_custom_header(settings)
+            if custom_header is not None:
+                compile_kwargs["custom_header"] = custom_header
+            self._compiled = evaluator.compile(
+                function_name,
+                str(self.source_path),
+                str(self.library_path),
+                self.number_type,
+                **compile_kwargs,
+            )
+            self.build_timing["cxx_compile_s"] = time.perf_counter() - compile_started
+        self.native_direct_application = None
+
+    def evaluate_complex(self, parameter_rows: Any) -> Any:
+        return self._evaluate_complex_prepared(
+            _complex128_parameter_rows(parameter_rows)
+        )
+
+    def _evaluate_complex_prepared(self, parameter_rows: np.ndarray) -> Any:
+        if self._compiled is not None:
+            return self._compiled.evaluate(parameter_rows)
+        if self._source_evaluator is None:
+            raise NativeEvaluationError(
+                "direct-only compiled evaluator has no generation-time source state"
+            )
+        return self._source_evaluator.evaluate_complex(parameter_rows)
+
+    @classmethod
+    def from_artifact(
+        cls,
+        manifest: dict[str, Any],
+        artifact_dir: Path,
+    ) -> _CompiledComplexEvaluatorAdapter:
+        if manifest.get("native_direct_application") is not None:
+            raise NativeEvaluationError(
+                "plane-native compiled process evaluators load only through "
+                "Rusticol Direct-Arena; no dense callable fallback is retained"
+            )
+        from symbolica import CompiledComplexEvaluator
+
+        instance = cls.__new__(cls)
+        instance._tmpdir = None
+        instance.function_name = str(manifest["function_name"])
+        instance.input_len = int(manifest["input_len"])
+        instance.output_len = int(manifest["output_len"])
+        instance.backend = str(manifest["backend"])
+        instance.settings = dict(manifest.get("settings", {}))
+        instance.runtime_capability = str(
+            manifest.get(
+                "runtime_capability",
+                _compiled_runtime_capability(instance.settings),
+            )
+        )
+        instance.number_type = str(manifest["number_type"])
+        instance._source_evaluator = None
+        instance.source_path = _artifact_path_from_manifest(
+            str(manifest["source_path"]),
+            artifact_dir,
+        )
+        instance.library_path = _artifact_path_from_manifest(
+            str(manifest["library_path"]),
+            artifact_dir,
+        )
+        state_path = manifest.get("evaluator_state_path")
+        instance.evaluator_state_path = (
+            None
+            if state_path is None
+            else _artifact_path_from_manifest(str(state_path), artifact_dir)
+        )
+        instance.build_timing = {}
+        instance.native_direct_application = None
+        if instance.number_type != "complex":
+            raise NativeEvaluationError(
+                f"unsupported compiled evaluator number type: {instance.number_type!r}"
+            )
+        instance._compiled = CompiledComplexEvaluator.load(
+            str(instance.library_path),
+            instance.function_name,
+            instance.input_len,
+            instance.output_len,
+        )
+        return instance
+
+    def compile_native_direct_application(
+        self,
+        parameter_kinds: Sequence[object],
+        *,
+        target_triple: str,
+        cpu_features: Sequence[str] = (),
+        simd_lane_width: int = 2,
+        output_dir: Path | None = None,
+    ) -> Any:
+        """Emit this compiled leaf directly against persistent arena planes.
+
+        Stage lowering supplies semantic storage kinds; guessing model scalars
+        from evaluator arity is intentionally forbidden.  Both public native
+        backends use this independent plane-native instruction emitter.  For an
+        ``asm`` selection the historical dense scalar-row library may contain
+        Symbolica inline assembly, while the production DirectApplication is
+        deliberately regenerated as a plane loop from the same optimized
+        instruction stream.  It never wraps or calls that dense entry point.
+        """
+
+        from .native_direct_cpp import (
+            NativeDirectCppParameterKind,
+            NativeDirectCppSpec,
+            compile_native_direct_cpp,
+            compiler_from_symbolica_settings,
+        )
+
+        if self._source_evaluator is None:
+            raise NativeEvaluationError(
+                "native DirectApplication production requires the retained "
+                "Symbolica evaluator state; regenerate this compiled leaf"
+            )
+        if self.runtime_capability not in {
+            SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+            SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+        }:
+            raise NativeEvaluationError(
+                "native DirectApplication production requires a C++ or ASM "
+                "compiled evaluator"
+            )
+        optimization = self.settings.get("compiled_optimization_level", 3)
+        if optimization != 3:
+            raise NativeEvaluationError(
+                "native DirectApplication production requires compiled "
+                "optimization level 3"
+            )
+        try:
+            kinds = tuple(
+                NativeDirectCppParameterKind(kind) for kind in parameter_kinds
+            )
+        except (TypeError, ValueError) as error:
+            raise NativeEvaluationError(
+                "native DirectApplication stage parameter kinds are invalid"
+            ) from error
+        if len(kinds) != self.input_len:
+            raise NativeEvaluationError(
+                "native DirectApplication stage parameter kinds do not match "
+                "the evaluator input width"
+            )
+        features = tuple(str(feature) for feature in cpu_features)
+        destination = self.source_path.parent if output_dir is None else output_dir
+        spec = NativeDirectCppSpec(
+            function_name=self.function_name,
+            parameter_kinds=kinds,
+            output_count=self.output_len,
+            target_triple=target_triple,
+            cpu_features=features,
+            simd_lane_width=simd_lane_width,
+        )
+        compiler = compiler_from_symbolica_settings(self.settings)
+        result = compile_native_direct_cpp(
+            self._source_evaluator,
+            spec=spec,
+            compiler=compiler,
+            output_source_path=destination / f"{self.function_name}.direct.cpp",
+            output_library_path=destination / f"lib{self.function_name}.direct",
+        )
+        self.native_direct_application = result
+        self.build_timing["native_direct_cpp_compile_s"] = result.compile_seconds
+        self.build_timing["native_direct_cpp_gate_wait_s"] = (
+            result.compiler_gate_wait_seconds
+        )
+        if result.compiler_gate_slot_count is not None:
+            self.build_timing["native_direct_cpp_gate_slots"] = float(
+                result.compiler_gate_slot_count
+            )
+        return result
+
+    # Kept as a narrow source-level alias for existing producer tests.  Artifact
+    # production uses ``compile_native_direct_application`` exclusively.
+    compile_native_direct_application_prototype = compile_native_direct_application
+
+    def artifact_manifest(self, artifact_dir: Path) -> dict[str, Any]:
+        direct = self.native_direct_application
+        source_path = self.source_path if direct is None else direct.source_path
+        library_path = self.library_path if direct is None else direct.library_path
+        manifest = {
+            "kind": "compiled-complex-evaluator",
+            "runtime_capability": self.runtime_capability,
+            "backend": self.backend,
+            "number_type": self.number_type,
+            "function_name": self.function_name,
+            "input_len": self.input_len,
+            "output_len": self.output_len,
+            "settings": self.settings,
+            "source_path": _artifact_path_for_manifest(
+                source_path,
+                artifact_dir,
+            ),
+            "library_path": _artifact_path_for_manifest(
+                library_path,
+                artifact_dir,
+            ),
+            "evaluator_state_path": (
+                None
+                if self.evaluator_state_path is None
+                else _artifact_path_for_manifest(
+                    self.evaluator_state_path,
+                    artifact_dir,
+                )
+            ),
+            "build_timing": dict(self.build_timing),
+        }
+        if direct is not None:
+            manifest["native_direct_application"] = _native_direct_application_manifest(
+                direct,
+                artifact_dir,
+                expected_function_name=self.function_name,
+            )
+        return manifest
+
+
+def _native_direct_application_manifest(
+    artifact: Any,
+    artifact_dir: Path,
+    *,
+    expected_function_name: str,
+) -> dict[str, object]:
+    """Serialize one direct-only companion without accepting a dense wrapper."""
+
+    from .native_direct_cpp import (
+        NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+        NativeDirectCppArtifact,
+    )
+
+    if not isinstance(artifact, NativeDirectCppArtifact):
+        raise NativeEvaluationError(
+            "native DirectApplication producer returned an invalid artifact"
+        )
+    source = artifact.source
+    if (
+        not artifact.source_path.is_file()
+        or not artifact.library_path.is_file()
+        or source.input_plane_count < 1
+        or source.output_plane_count < 2
+        or source.output_plane_count % 2 != 0
+        or source.scalar_input_count < 0
+        or source.simd_lane_width not in {2, 4}
+        or source.logical_stack_bytes < 1
+        or source.logical_stack_bytes > 64 * 1024
+        or len(source.evaluator_state_sha256) != 64
+    ):
+        raise NativeEvaluationError(
+            "native DirectApplication artifact metadata is incomplete"
+        )
+    function_name = expected_function_name
+    if _safe_symbol_name(function_name) != function_name:
+        raise NativeEvaluationError(
+            "native DirectApplication function identity is invalid"
+        )
+    return {
+        "application_abi": NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+        "function_name": function_name,
+        "source_path": _artifact_path_for_manifest(
+            artifact.source_path,
+            artifact_dir,
+        ),
+        "library_path": _artifact_path_for_manifest(
+            artifact.library_path,
+            artifact_dir,
+        ),
+        "target": {
+            "triple": source.target_triple,
+            "cpu_features": list(source.cpu_features),
+        },
+        "evaluator_state_sha256": source.evaluator_state_sha256,
+        "instruction_count": source.instruction_count,
+        "temporary_count": source.temporary_count,
+        "input_plane_count": source.input_plane_count,
+        "scalar_input_count": source.scalar_input_count,
+        "output_plane_count": source.output_plane_count,
+        "simd_lane_width": source.simd_lane_width,
+        "logical_stack_bytes": source.logical_stack_bytes,
+        "output_semantics": "factor-free-overwrite",
+    }
+
+
+def compile_native_direct_applications(
+    evaluator: Any,
+    parameter_kinds: Sequence[object],
+    *,
+    target_triple: str,
+    cpu_features: Sequence[str] = (),
+    simd_lane_width: int = 2,
+) -> bool:
+    """Compile every native leaf in one evaluator tree as DirectApplication.
+
+    Chunk input maps are composed here, before artifact serialization, so each
+    leaf receives exactly the semantic storage classes represented by its
+    retained Symbolica instruction stream.
+    """
+
+    kinds = tuple(parameter_kinds)
+    if isinstance(evaluator, _CompiledComplexEvaluatorAdapter):
+        evaluator.compile_native_direct_application(
+            kinds,
+            target_triple=target_triple,
+            cpu_features=cpu_features,
+            simd_lane_width=simd_lane_width,
+        )
+        return True
+    if isinstance(evaluator, _ChunkedSymbolicaEvaluator):
+        compiled = False
+        for child, indices in zip(
+            evaluator._evaluators,
+            evaluator._chunk_input_indices,
+            strict=True,
+        ):
+            child_kinds = tuple(kinds[index] for index in indices)
+            child_compiled = compile_native_direct_applications(
+                child,
+                child_kinds,
+                target_triple=target_triple,
+                cpu_features=cpu_features,
+                simd_lane_width=simd_lane_width,
+            )
+            if compiled and not child_compiled:
+                raise NativeEvaluationError(
+                    "native DirectApplication compilation cannot mix native "
+                    "and non-native evaluator chunks"
+                )
+            compiled = compiled or child_compiled
+        return compiled
+    return False
+
+
+def _compiled_compiler_flags(settings: SymbolicaEvaluatorSettings) -> tuple[str, ...]:
+    flags = tuple(settings.compiler_flags)
+    if settings.backend == "compiled-complex":
+        # Symbolica's generated C++ and pyAmpliCol's injected direct-table
+        # support use C++17 features.  Apple clang otherwise defaults to C++98.
+        return ("-std=c++17", *flags)
+    return flags
+
+
+_CPP_COMPLEX_LITERAL_COMPAT_HEADER = r"""
+template<typename Complex, typename Value>
+inline Complex pyamplicol_complex_literal(Value value) {
+    return Complex(value);
+}
+
+template<typename Complex, typename Real, typename Imag>
+inline Complex pyamplicol_complex_literal(Real real, Imag imag) {
+    return Complex(std::real(real), std::real(imag));
+}
+
+#define T(...) pyamplicol_complex_literal<T>(__VA_ARGS__)
+""".strip()
+
+
+def _compiled_complex_custom_header(
+    settings: SymbolicaEvaluatorSettings,
+) -> str | None:
+    """Adapt Symbolica 2.2 nested complex literals in generated C++ sources."""
+
+    if settings.compiled_inline_asm != "none":
+        return None
+    return _CPP_COMPLEX_LITERAL_COMPAT_HEADER
+
+
+def _symjit_element_layout() -> str:
+    return "complex-f64"
+
+
+def _compiled_runtime_capability(settings: Mapping[str, object]) -> str:
+    if str(settings.get("compiled_inline_asm", "default")) == "none":
+        return SYMBOLICA_CPP_RUNTIME_CAPABILITY
+    return SYMBOLICA_ASM_RUNTIME_CAPABILITY
+
+
+class _ChunkedSymbolicaEvaluator:
+    def __init__(
+        self,
+        evaluators: tuple[Any, ...],
+        *,
+        input_len: int | None = None,
+        chunk_input_indices: tuple[tuple[int, ...], ...] | None = None,
+    ) -> None:
+        if not evaluators:
+            raise NativeEvaluationError("chunked evaluator needs at least one chunk")
+        child_input_lengths = tuple(
+            _evaluator_input_len(evaluator) for evaluator in evaluators
+        )
+        if input_len is None:
+            if len(set(child_input_lengths)) != 1:
+                raise NativeEvaluationError(
+                    "legacy chunked evaluators need equal child input lengths"
+                )
+            input_len = child_input_lengths[0]
+        if (
+            isinstance(input_len, bool)
+            or not isinstance(input_len, int)
+            or input_len < 0
+        ):
+            raise NativeEvaluationError("chunked evaluator input length is invalid")
+        if chunk_input_indices is None:
+            chunk_input_indices = tuple(
+                tuple(range(input_len)) for _evaluator in evaluators
+            )
+        if len(chunk_input_indices) != len(evaluators):
+            raise NativeEvaluationError(
+                "chunked evaluator input maps do not match evaluator chunks"
+            )
+        normalized_indices: list[tuple[int, ...]] = []
+        for child_input_len, raw_indices in zip(
+            child_input_lengths,
+            chunk_input_indices,
+            strict=True,
+        ):
+            indices = tuple(raw_indices)
+            if len(indices) != child_input_len:
+                raise NativeEvaluationError(
+                    "chunked evaluator input map length does not match child "
+                    "input length"
+                )
+            if any(
+                isinstance(index, bool)
+                or not isinstance(index, int)
+                or index < 0
+                or index >= input_len
+                for index in indices
+            ):
+                raise NativeEvaluationError(
+                    "chunked evaluator input map contains an invalid parent index"
+                )
+            if any(left >= right for left, right in pairwise(indices)):
+                raise NativeEvaluationError(
+                    "chunked evaluator input maps must be strictly increasing"
+                )
+            normalized_indices.append(indices)
+        self._evaluators = evaluators
+        self.input_len = input_len
+        self._chunk_input_indices = tuple(normalized_indices)
+        self.build_timing: dict[str, float] = {}
+
+    def evaluate_complex(self, parameter_rows: Any) -> Any:
+        return np.concatenate(self.evaluate_complex_chunks(parameter_rows), axis=1)
+
+    def evaluate_complex_chunks(self, parameter_rows: Any) -> tuple[Any, ...]:
+        prepared_rows = self._prepare_parameter_rows(parameter_rows)
+        return tuple(
+            _evaluate_prepared_complex(
+                evaluator,
+                self._chunk_parameter_rows(prepared_rows, indices),
+            )
+            for evaluator, indices in zip(
+                self._evaluators,
+                self._chunk_input_indices,
+                strict=True,
+            )
+        )
+
+    def evaluate_complex_profiled(
+        self, parameter_rows: Any
+    ) -> tuple[tuple[Any, ...], tuple[float, float, float]]:
+        prepared_rows = self._prepare_parameter_rows(parameter_rows)
+        outputs: list[Any] = []
+        profiles: list[tuple[float, float, float]] = []
+        gather_s = 0.0
+        for evaluator, indices in zip(
+            self._evaluators,
+            self._chunk_input_indices,
+            strict=True,
+        ):
+            gather_started = time.perf_counter()
+            chunk_rows = self._chunk_parameter_rows(prepared_rows, indices)
+            gather_s += time.perf_counter() - gather_started
+            output, profile = _evaluate_prepared_complex_profiled(evaluator, chunk_rows)
+            outputs.append(output)
+            profiles.append(profile)
+        return tuple(outputs), (
+            gather_s + sum(profile[0] for profile in profiles),
+            sum(profile[1] for profile in profiles),
+            sum(profile[2] for profile in profiles),
+        )
+
+    def _prepare_parameter_rows(self, parameter_rows: Any) -> np.ndarray:
+        prepared_rows = _complex128_parameter_rows(parameter_rows)
+        if prepared_rows.ndim != 2 or prepared_rows.shape[1] != self.input_len:
+            raise NativeEvaluationError(
+                "chunked evaluator parameter rows have an inconsistent width"
+            )
+        return prepared_rows
+
+    def _chunk_parameter_rows(
+        self,
+        parameter_rows: np.ndarray,
+        indices: tuple[int, ...],
+    ) -> np.ndarray:
+        if len(indices) == self.input_len and all(
+            index == expected for expected, index in enumerate(indices)
+        ):
+            return parameter_rows
+        return np.ascontiguousarray(parameter_rows[:, indices])
+
+    def supports_complex_profiled(self) -> bool:
+        return all(
+            bool(getattr(evaluator, "supports_complex_profiled", lambda: False)())
+            for evaluator in self._evaluators
+        )
+
+    @classmethod
+    def from_artifact(
+        cls,
+        manifest: dict[str, Any],
+        artifact_dir: Path,
+    ) -> _ChunkedSymbolicaEvaluator:
+        chunks = manifest.get("chunks")
+        if not isinstance(chunks, list):
+            raise NativeEvaluationError("chunked evaluator artifact is missing chunks")
+        raw_input_indices = manifest.get("chunk_input_indices")
+        chunk_input_indices = None
+        if raw_input_indices is not None:
+            if not isinstance(raw_input_indices, list):
+                raise NativeEvaluationError(
+                    "chunked evaluator artifact has invalid input maps"
+                )
+            parsed_indices: list[tuple[int, ...]] = []
+            for indices in raw_input_indices:
+                if not isinstance(indices, list):
+                    raise NativeEvaluationError(
+                        "chunked evaluator artifact has invalid input maps"
+                    )
+                parsed_indices.append(tuple(indices))
+            chunk_input_indices = tuple(parsed_indices)
+        raw_input_len = manifest.get("input_len")
+        if raw_input_len is not None and (
+            isinstance(raw_input_len, bool) or not isinstance(raw_input_len, int)
+        ):
+            raise NativeEvaluationError(
+                "chunked evaluator artifact has an invalid input length"
+            )
+        return cls(
+            tuple(
+                _load_symbolica_evaluator_artifact(chunk, artifact_dir)
+                for chunk in chunks
+            ),
+            input_len=raw_input_len,
+            chunk_input_indices=chunk_input_indices,
+        )
+
+    def artifact_manifest(self, artifact_dir: Path) -> dict[str, Any]:
+        worker_counts = []
+        for evaluator in self._evaluators:
+            settings = getattr(evaluator, "settings", None)
+            if isinstance(settings, Mapping):
+                workers = settings.get("compiled_chunk_compile_workers")
+                if isinstance(workers, int):
+                    worker_counts.append(workers)
+        workers = min(max(worker_counts, default=1), len(self._evaluators))
+        if workers <= 1:
+            chunks = [
+                _symbolica_evaluator_artifact_manifest(evaluator, artifact_dir)
+                for evaluator in self._evaluators
+            ]
+        else:
+            with ThreadPoolExecutor(max_workers=workers) as executor:
+                futures = [
+                    executor.submit(
+                        _symbolica_evaluator_artifact_manifest,
+                        evaluator,
+                        artifact_dir,
+                    )
+                    for evaluator in self._evaluators
+                ]
+                chunks = [future.result() for future in futures]
+        timing_totals = dict(self.build_timing)
+        timing_totals["chunk_count"] = float(len(chunks))
+        for chunk in chunks:
+            chunk_timing = (
+                chunk.get("build_timing") if isinstance(chunk, dict) else None
+            )
+            if not isinstance(chunk_timing, Mapping):
+                continue
+            for key, value in chunk_timing.items():
+                if isinstance(value, (float, int)):
+                    timing_totals[str(key)] = timing_totals.get(str(key), 0.0) + float(
+                        value
+                    )
+        return {
+            "kind": "chunked-symbolica-evaluator",
+            "input_len": self.input_len,
+            "chunk_input_indices": [
+                list(indices) for indices in self._chunk_input_indices
+            ],
+            "chunks": chunks,
+            "required_runtime_capabilities": list(
+                aggregate_runtime_capabilities(chunks)
+            ),
+            "build_timing": timing_totals,
+        }
+
+
+def _evaluator_input_len(evaluator: Any) -> int:
+    value = getattr(evaluator, "input_len", None)
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise NativeEvaluationError("evaluator chunk has no valid input length")
+    return value
+
+
+def _load_symbolica_evaluator_artifact(
+    manifest: Any,
+    artifact_dir: Path,
+) -> Any:
+    if not isinstance(manifest, dict):
+        raise NativeEvaluationError("compiled evaluator artifact entry is invalid")
+    kind = manifest.get("kind")
+    if kind in {"jit-symbolica-evaluator", "symjit-application-evaluator"}:
+        return _JITSymbolicaEvaluatorAdapter.from_artifact(manifest, artifact_dir)
+    if kind == "compiled-complex-evaluator":
+        return _CompiledComplexEvaluatorAdapter.from_artifact(manifest, artifact_dir)
+    if kind == "chunked-symbolica-evaluator":
+        return _ChunkedSymbolicaEvaluator.from_artifact(manifest, artifact_dir)
+    raise NativeEvaluationError(f"unsupported evaluator artifact kind: {kind!r}")
diff --git a/pyamplicol/src/pyamplicol/evaluators/symbolica_compile.py b/pyamplicol/src/pyamplicol/evaluators/symbolica_compile.py
new file mode 100644
index 0000000000..04187a2a34
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/evaluators/symbolica_compile.py
@@ -0,0 +1,584 @@
+# SPDX-License-Identifier: 0BSD
+"""Compilation pipeline for Symbolica evaluator outputs."""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections.abc import Mapping, Sequence
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import replace
+from pathlib import Path
+from typing import Any
+
+from .._internal.physics.types import NativeEvaluationError
+from .symbolica_adapters import (
+    _ChunkedSymbolicaEvaluator,
+    _CompiledComplexEvaluatorAdapter,
+    _JITSymbolicaEvaluatorAdapter,
+)
+from .symbolica_helpers import _progress_outputs, _safe_symbol_name
+from .symbolica_settings import (
+    ProgressCallback,
+    SymbolicaEvaluatorSettings,
+    _report_progress,
+)
+
+
+def _compile_symbolica_outputs(
+    outputs: tuple[Any, ...],
+    params: list[Any],
+    *,
+    merge_evaluators_strategy: bool,
+    verbose_evaluator_build: bool,
+    functions: Mapping[tuple[Any, tuple[Any, ...]], Any] | None = None,
+    real_params: Sequence[int] = (),
+    symbolica_settings: SymbolicaEvaluatorSettings | None = None,
+    jit_compile: bool = True,
+    label: str = "symbolica",
+    progress_callback: ProgressCallback | None = None,
+    output_partitions: Sequence[tuple[int, int]] = (),
+    native_direct_only: bool = False,
+) -> Any:
+    if not outputs:
+        raise NativeEvaluationError("cannot build evaluator with zero outputs")
+    settings = symbolica_settings or SymbolicaEvaluatorSettings()
+    progress_stage = _symbolica_progress_stage(settings, jit_compile=jit_compile)
+    _report_progress(
+        progress_callback,
+        stage=progress_stage,
+        item=f"{label} prepare {len(outputs)}",
+    )
+    total_started = time.perf_counter()
+    prepare_started = time.perf_counter()
+    outputs = tuple(_prepare_symbolica_output(output, settings) for output in outputs)
+    output_prepare_s = time.perf_counter() - prepare_started
+    chunk_size = settings.compiled_output_chunk_size
+    chunk_ranges = _partitioned_output_chunk_ranges(
+        len(outputs),
+        chunk_size=chunk_size,
+        output_partitions=output_partitions,
+    )
+    if len(chunk_ranges) > 1:
+        chunk_output_dir = (
+            None
+            if settings.compiled_output_dir is None
+            else str(Path(settings.compiled_output_dir) / _safe_symbol_name(label))
+        )
+        unchunked_settings = replace(settings, compiled_output_chunk_size=None)
+        if chunk_output_dir is not None:
+            unchunked_settings = replace(
+                unchunked_settings,
+                compiled_output_dir=chunk_output_dir,
+            )
+
+        def compile_chunk(
+            chunk_index: int,
+            start: int,
+            stop: int,
+        ) -> tuple[Any, tuple[int, ...]]:
+            chunk_outputs = outputs[start:stop]
+            chunk_input_indices = _chunk_parameter_indices(
+                chunk_outputs,
+                params,
+                functions=functions,
+            )
+            chunk_params = [params[index] for index in chunk_input_indices]
+            parent_real_params = set(real_params)
+            chunk_real_params = tuple(
+                local_index
+                for local_index, parent_index in enumerate(chunk_input_indices)
+                if parent_index in parent_real_params
+            )
+            _report_progress(
+                progress_callback,
+                stage=progress_stage,
+                item=(
+                    f"{label} chunk {chunk_index + 1}/{len(chunk_ranges)} "
+                    f"p={len(chunk_params)}/{len(params)}"
+                ),
+            )
+            return (
+                _compile_symbolica_outputs(
+                    chunk_outputs,
+                    chunk_params,
+                    merge_evaluators_strategy=merge_evaluators_strategy,
+                    verbose_evaluator_build=verbose_evaluator_build,
+                    functions=functions,
+                    real_params=chunk_real_params,
+                    symbolica_settings=unchunked_settings,
+                    jit_compile=jit_compile,
+                    label=f"{label}_chunk_{chunk_index}",
+                    progress_callback=progress_callback,
+                    output_partitions=(),
+                    native_direct_only=native_direct_only,
+                ),
+                chunk_input_indices,
+            )
+
+        workers = min(settings.compiled_chunk_compile_workers, len(chunk_ranges))
+        if workers <= 1:
+            compiled_chunks = [
+                compile_chunk(chunk_index, start, stop)
+                for chunk_index, (start, stop) in enumerate(chunk_ranges)
+            ]
+        else:
+            with ThreadPoolExecutor(max_workers=workers) as executor:
+                futures = [
+                    executor.submit(compile_chunk, chunk_index, start, stop)
+                    for chunk_index, (start, stop) in enumerate(chunk_ranges)
+                ]
+                compiled_chunks = [future.result() for future in futures]
+        chunks, chunk_input_indices = zip(*compiled_chunks, strict=True)
+        chunked = _ChunkedSymbolicaEvaluator(
+            tuple(chunks),
+            input_len=len(params),
+            chunk_input_indices=tuple(chunk_input_indices),
+        )
+        chunked.build_timing = {
+            "output_prepare_s": output_prepare_s,
+            "symbolica_evaluator_build_s": time.perf_counter() - total_started,
+        }
+        return chunked
+    evaluator_kwargs = _symbolica_evaluator_kwargs(
+        settings,
+        verbose=verbose_evaluator_build,
+        jit_compile=jit_compile,
+    )
+    function_kwargs: dict[str, Any] = {}
+    if functions:
+        from symbolica import FunctionDefinition
+
+        # Process kernels retain one flat instruction program, including bodies
+        # of tagged functions and functions that close over model parameters.
+        function_kwargs["functions"] = [
+            FunctionDefinition(function, arguments, body, inlining="always")
+            for (function, arguments), body in functions.items()
+        ]
+    if merge_evaluators_strategy:
+        _report_progress(
+            progress_callback,
+            stage=progress_stage,
+            item=f"{label} evaluator 1/{len(outputs)}",
+        )
+        _report_jit_boundary(
+            progress_callback,
+            settings,
+            jit_compile=jit_compile,
+            phase="initialize",
+            item=f"{label} eval 1/{len(outputs)} p={len(params)}",
+        )
+        with _JITBoundaryHeartbeat(
+            progress_callback,
+            settings,
+            jit_compile=jit_compile,
+            phase="initialize",
+            item=f"{label} eval 1/{len(outputs)} p={len(params)}",
+        ):
+            evaluator_started = time.perf_counter()
+            evaluator = outputs[0].evaluator(
+                params,
+                **function_kwargs,
+                **evaluator_kwargs,
+            )
+            evaluator_construct_s = time.perf_counter() - evaluator_started
+        _report_jit_boundary(
+            progress_callback,
+            settings,
+            jit_compile=jit_compile,
+            phase="returned",
+            item=f"{label} eval 1/{len(outputs)}",
+        )
+        for expression in _progress_outputs(
+            outputs[1:],
+            enabled=verbose_evaluator_build,
+        ):
+            _report_progress(
+                progress_callback,
+                stage=progress_stage,
+                item=f"{label} merge",
+            )
+            _report_jit_boundary(
+                progress_callback,
+                settings,
+                jit_compile=jit_compile,
+                phase="initialize",
+                item=f"{label} merge p={len(params)}",
+            )
+            with _JITBoundaryHeartbeat(
+                progress_callback,
+                settings,
+                jit_compile=jit_compile,
+                phase="initialize",
+                item=f"{label} merge p={len(params)}",
+            ):
+                merge_construct_started = time.perf_counter()
+                other = expression.evaluator(
+                    params,
+                    **function_kwargs,
+                    **evaluator_kwargs,
+                )
+                evaluator_construct_s += time.perf_counter() - merge_construct_started
+            _report_jit_boundary(
+                progress_callback,
+                settings,
+                jit_compile=jit_compile,
+                phase="returned",
+                item=f"{label} merge",
+            )
+            evaluator.merge(
+                other,
+                cpe_iterations=(
+                    1 if settings.cpe_iterations is None else settings.cpe_iterations
+                ),
+            )
+        if real_params:
+            real_params_started = time.perf_counter()
+            _report_jit_boundary(
+                progress_callback,
+                settings,
+                jit_compile=jit_compile,
+                phase="real params",
+                item=f"{label} real={len(real_params)}",
+            )
+            evaluator.set_real_params(
+                list(real_params),
+                sqrt_real=settings.real_param_sqrt_real,
+                log_real=settings.real_param_log_real,
+                powf_real=settings.real_param_powf_real,
+                real_if_args_real=settings.real_param_real_if_args_real,
+                verbose=verbose_evaluator_build,
+            )
+            real_params_s = time.perf_counter() - real_params_started
+        else:
+            real_params_s = 0.0
+        adapter = _finalize_symbolica_evaluator(
+            evaluator,
+            settings,
+            label,
+            input_len=len(params),
+            output_len=len(outputs),
+            progress_callback=progress_callback,
+            native_direct_only=native_direct_only,
+        )
+        _set_evaluator_build_timing(
+            adapter,
+            {
+                "output_prepare_s": output_prepare_s,
+                "evaluator_construct_s": evaluator_construct_s,
+                "real_params_s": real_params_s,
+                "symbolica_evaluator_build_s": time.perf_counter() - total_started,
+            },
+        )
+        return adapter
+
+    from symbolica import Expression
+
+    _report_progress(
+        progress_callback,
+        stage=progress_stage,
+        item=f"{label} evaluator {len(outputs)}",
+    )
+    _report_jit_boundary(
+        progress_callback,
+        settings,
+        jit_compile=jit_compile,
+        phase="initialize",
+        item=f"{label} out={len(outputs)} p={len(params)}",
+    )
+    with _JITBoundaryHeartbeat(
+        progress_callback,
+        settings,
+        jit_compile=jit_compile,
+        phase="initialize",
+        item=f"{label} out={len(outputs)} p={len(params)}",
+    ):
+        evaluator_started = time.perf_counter()
+        evaluator = Expression.evaluator_multiple(
+            outputs,
+            params,
+            **function_kwargs,
+            **evaluator_kwargs,
+        )
+        evaluator_construct_s = time.perf_counter() - evaluator_started
+    _report_jit_boundary(
+        progress_callback,
+        settings,
+        jit_compile=jit_compile,
+        phase="returned",
+        item=f"{label} out={len(outputs)}",
+    )
+    if real_params:
+        real_params_started = time.perf_counter()
+        _report_jit_boundary(
+            progress_callback,
+            settings,
+            jit_compile=jit_compile,
+            phase="real params",
+            item=f"{label} real={len(real_params)}",
+        )
+        evaluator.set_real_params(
+            list(real_params),
+            sqrt_real=settings.real_param_sqrt_real,
+            log_real=settings.real_param_log_real,
+            powf_real=settings.real_param_powf_real,
+            real_if_args_real=settings.real_param_real_if_args_real,
+            verbose=verbose_evaluator_build,
+        )
+        real_params_s = time.perf_counter() - real_params_started
+    else:
+        real_params_s = 0.0
+    adapter = _finalize_symbolica_evaluator(
+        evaluator,
+        settings,
+        label,
+        input_len=len(params),
+        output_len=len(outputs),
+        progress_callback=progress_callback,
+        native_direct_only=native_direct_only,
+    )
+    _set_evaluator_build_timing(
+        adapter,
+        {
+            "output_prepare_s": output_prepare_s,
+            "evaluator_construct_s": evaluator_construct_s,
+            "real_params_s": real_params_s,
+            "symbolica_evaluator_build_s": time.perf_counter() - total_started,
+        },
+    )
+    return adapter
+
+
+def _partitioned_output_chunk_ranges(
+    output_count: int,
+    *,
+    chunk_size: int | None,
+    output_partitions: Sequence[tuple[int, int]],
+) -> tuple[tuple[int, int], ...]:
+    if output_count < 1:
+        raise NativeEvaluationError("cannot partition zero evaluator outputs")
+    partitions = tuple(output_partitions) or ((0, output_count),)
+    expected_start = 0
+    for start, stop in partitions:
+        if start != expected_start or stop <= start or stop > output_count:
+            raise NativeEvaluationError(
+                "evaluator output partitions must be contiguous and exhaustive"
+            )
+        expected_start = stop
+    if expected_start != output_count:
+        raise NativeEvaluationError(
+            "evaluator output partitions must cover every output"
+        )
+
+    ranges: list[tuple[int, int]] = []
+    for start, stop in partitions:
+        if chunk_size is None:
+            ranges.append((start, stop))
+            continue
+        if chunk_size < 1:
+            raise NativeEvaluationError("evaluator output chunk size must be positive")
+        for chunk_start in range(start, stop, chunk_size):
+            ranges.append((chunk_start, min(chunk_start + chunk_size, stop)))
+    return tuple(ranges)
+
+
+def _chunk_parameter_indices(
+    outputs: Sequence[Any],
+    params: Sequence[Any],
+    *,
+    functions: Mapping[tuple[Any, tuple[Any, ...]], Any] | None = None,
+) -> tuple[int, ...]:
+    """Return parent parameter indices needed by one output chunk.
+
+    Symbolica already exposes structural symbol discovery, including symbols in
+    function arguments.  Function bodies are included
+    conservatively so a model kernel that closes over a runtime parameter can
+    never be under-specified.  Parent ordering is retained to keep generated
+    evaluator signatures and real-parameter metadata deterministic.
+    """
+
+    used_symbols: set[Any] = set()
+    for expression in outputs:
+        used_symbols.update(_expression_symbols(expression))
+    if functions:
+        for body in functions.values():
+            used_symbols.update(_expression_symbols(body))
+    return tuple(
+        index for index, parameter in enumerate(params) if parameter in used_symbols
+    )
+
+
+def _expression_symbols(expression: Any) -> set[Any]:
+    getter = getattr(expression, "get_all_symbols", None)
+    if not callable(getter):
+        raise NativeEvaluationError(
+            "Symbolica expression does not expose structural symbol discovery"
+        )
+    return set(getter(False))
+
+
+def _set_evaluator_build_timing(evaluator: Any, timing: Mapping[str, float]) -> None:
+    try:
+        current = getattr(evaluator, "build_timing", {})
+        if not isinstance(current, dict):
+            current = {}
+        current.update({str(key): float(value) for key, value in timing.items()})
+        evaluator.build_timing = current
+    except Exception:
+        return
+
+
+def _report_jit_boundary(
+    progress_callback: ProgressCallback | None,
+    settings: SymbolicaEvaluatorSettings,
+    *,
+    jit_compile: bool,
+    phase: str,
+    item: str,
+) -> None:
+    if settings.backend != "jit" or not jit_compile:
+        return
+    _report_progress(
+        progress_callback,
+        stage=f"jit {phase}",
+        item=item,
+    )
+
+
+class _JITBoundaryHeartbeat:
+    """Emit progress while Symbolica is inside a blocking JIT build call."""
+
+    def __init__(
+        self,
+        progress_callback: ProgressCallback | None,
+        settings: SymbolicaEvaluatorSettings,
+        *,
+        jit_compile: bool,
+        phase: str,
+        item: str,
+        interval_s: float = 5.0,
+    ) -> None:
+        self.progress_callback = progress_callback
+        self.settings = settings
+        self.jit_compile = jit_compile
+        self.phase = phase
+        self.item = item
+        self.interval_s = max(float(interval_s), 0.01)
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._started_at = 0.0
+
+    def __enter__(self) -> _JITBoundaryHeartbeat:
+        if (
+            self.progress_callback is None
+            or self.settings.backend != "jit"
+            or not self.jit_compile
+        ):
+            return self
+        self._started_at = time.perf_counter()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+        return self
+
+    def __exit__(self, exc_type: object, exc: object, tb: object) -> None:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=1.0)
+
+    def _run(self) -> None:
+        while not self._stop.wait(self.interval_s):
+            elapsed_s = time.perf_counter() - self._started_at
+            _report_progress(
+                self.progress_callback,
+                stage=f"jit {self.phase}",
+                item=f"{self.item} waiting {elapsed_s:.0f}s",
+            )
+
+
+def _symbolica_progress_stage(
+    settings: SymbolicaEvaluatorSettings,
+    *,
+    jit_compile: bool,
+) -> str:
+    if settings.backend == "jit":
+        return "jit compile" if jit_compile else "jit build"
+    if settings.backend == "compiled-complex":
+        return "c++ build"
+    return "eval build"
+
+
+def _prepare_symbolica_output(
+    output: Any,
+    settings: SymbolicaEvaluatorSettings,
+) -> Any:
+    if not settings.collect_factors:
+        return output
+    collect_factors = getattr(output, "collect_factors", None)
+    if callable(collect_factors):
+        return collect_factors()
+    return output
+
+
+def _symbolica_evaluator_kwargs(
+    settings: SymbolicaEvaluatorSettings,
+    *,
+    verbose: bool,
+    jit_compile: bool = True,
+) -> dict[str, Any]:
+    return {
+        "iterations": settings.iterations,
+        "cpe_iterations": settings.cpe_iterations,
+        "n_cores": settings.n_cores,
+        "verbose": verbose,
+        "jit_compile": jit_compile,
+        "direct_translation": settings.direct_translation,
+        "jit_direct_translation": settings.jit_direct_translation,
+        "jit_optimization_level": settings.jit_optimization_level,
+        "jit_options": {"compress": "true" if settings.jit_compress else "false"},
+        "max_horner_scheme_variables": settings.max_horner_scheme_variables,
+        "max_common_pair_cache_entries": settings.max_common_pair_cache_entries,
+        "max_common_pair_distance": settings.max_common_pair_distance,
+    }
+
+
+def _finalize_symbolica_evaluator(
+    evaluator: Any,
+    settings: SymbolicaEvaluatorSettings,
+    label: str,
+    *,
+    input_len: int,
+    output_len: int,
+    progress_callback: ProgressCallback | None = None,
+    native_direct_only: bool = False,
+) -> Any:
+    if settings.backend == "jit":
+        _report_progress(
+            progress_callback,
+            stage="jit ready",
+            item=label,
+        )
+        return _JITSymbolicaEvaluatorAdapter(
+            evaluator,
+            settings,
+            label,
+            input_len=input_len,
+            output_len=output_len,
+            progress_callback=progress_callback,
+        )
+    if settings.backend == "compiled-complex":
+        _report_progress(
+            progress_callback,
+            stage="c++ compile",
+            item=label,
+        )
+        return _CompiledComplexEvaluatorAdapter(
+            evaluator,
+            settings,
+            label,
+            input_len=input_len,
+            output_len=output_len,
+            compile_dense=not native_direct_only,
+        )
+    raise NativeEvaluationError(
+        f"unsupported symbolica evaluator backend: {settings.backend}"
+    )
diff --git a/pyamplicol/src/pyamplicol/evaluators/symbolica_helpers.py b/pyamplicol/src/pyamplicol/evaluators/symbolica_helpers.py
new file mode 100644
index 0000000000..3cc352f2b5
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/evaluators/symbolica_helpers.py
@@ -0,0 +1,169 @@
+# SPDX-License-Identifier: 0BSD
+"""Array, artifact-path, and progress helpers for evaluator adapters."""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from .._internal.physics.types import NativeEvaluationError
+
+ComplexOutput = np.ndarray | tuple[np.ndarray, ...]
+
+
+def _symbolica_instruction_program(exported: Any) -> Any:
+    """Extract the linear program from Symbolica's structured instruction export."""
+    if isinstance(exported, tuple):
+        return exported
+    if exported.sub_evaluators:
+        raise NativeEvaluationError(
+            "native kernels require inlined Symbolica function bodies"
+        )
+    return exported.instructions, exported.temporary_count, exported.constants
+
+
+def _symbolica_instruction_program_repr(exported: Any) -> str:
+    """Spell out unit imaginary coefficients for SymJIT's numeric grammar.
+
+    Symbolica omits coefficients of magnitude one before its imaginary-unit
+    glyph, but SymJIT's instruction parser requires them. Keep the exact
+    rational constants and the original evaluator state unchanged.
+    """
+    instructions, temporary_count, constants = _symbolica_instruction_program(exported)
+    serialized_constants = ", ".join(
+        re.sub(r"(?<![0-9])\U0001d456", "1\U0001d456", repr(value))
+        for value in constants
+    )
+    return f"({instructions!r}, {temporary_count}, [{serialized_constants}])"
+
+
+def _complex128_parameter_rows(parameter_rows: Any) -> np.ndarray:
+    if (
+        isinstance(parameter_rows, np.ndarray)
+        and parameter_rows.dtype == np.complex128
+        and parameter_rows.flags.c_contiguous
+    ):
+        return parameter_rows
+    return np.asarray(parameter_rows, dtype=np.complex128)
+
+
+def _evaluate_prepared_complex(evaluator: Any, parameter_rows: np.ndarray) -> Any:
+    evaluate_prepared = getattr(evaluator, "_evaluate_complex_prepared", None)
+    if callable(evaluate_prepared):
+        return evaluate_prepared(parameter_rows)
+    return evaluator.evaluate_complex(parameter_rows)
+
+
+def _evaluate_prepared_complex_profiled(
+    evaluator: Any,
+    parameter_rows: np.ndarray,
+) -> tuple[Any, tuple[float, float, float]]:
+    evaluate_profiled = getattr(evaluator, "_evaluate_complex_profiled_prepared", None)
+    if not callable(evaluate_profiled):
+        raise NativeEvaluationError(
+            "evaluator does not expose native complex profiling"
+        )
+    return evaluate_profiled(parameter_rows)
+
+
+def _evaluate_complex_outputs(evaluator: Any, parameter_rows: Any) -> ComplexOutput:
+    evaluate_chunks = getattr(evaluator, "evaluate_complex_chunks", None)
+    if callable(evaluate_chunks):
+        return tuple(
+            np.asarray(chunk, dtype=np.complex128)
+            for chunk in evaluate_chunks(parameter_rows)
+        )
+    return np.asarray(evaluator.evaluate_complex(parameter_rows), dtype=np.complex128)
+
+
+def _symbolica_evaluator_artifact_manifest(
+    evaluator: Any,
+    artifact_dir: Path,
+) -> dict[str, Any]:
+    manifest = getattr(evaluator, "artifact_manifest", None)
+    if not callable(manifest):
+        raise NativeEvaluationError(
+            "saving evaluator artifacts is currently supported only for "
+            "Symbolica evaluator adapters"
+        )
+    return manifest(artifact_dir)
+
+
+def _artifact_path_for_manifest(path: Path, artifact_dir: Path) -> str:
+    artifact_root = artifact_dir.resolve()
+    source_path = path.expanduser()
+    source_resolved = source_path.resolve()
+    try:
+        source_resolved.relative_to(artifact_root)
+    except ValueError:
+        if source_path.exists():
+            target_dir = artifact_dir / "compiled" / "repackaged"
+            target_dir.mkdir(parents=True, exist_ok=True)
+            target = target_dir / source_path.name
+            if source_resolved != target.resolve():
+                shutil.copy2(source_path, target)
+            source_path = target
+        else:
+            source_path = source_resolved
+    try:
+        return os.path.relpath(source_path, artifact_dir)
+    except ValueError:
+        return str(source_path)
+
+
+def _artifact_subdirectory(artifact_dir: Path, name: str) -> Path:
+    directory = artifact_dir / name
+    directory.mkdir(parents=True, exist_ok=True)
+    return directory
+
+
+def _artifact_path_from_manifest(path: str, artifact_dir: Path) -> Path:
+    candidate = Path(path)
+    if candidate.is_absolute():
+        return candidate
+    return artifact_dir / candidate
+
+
+def _safe_symbol_name(value: str) -> str:
+    result = "".join(character if character.isalnum() else "_" for character in value)
+    if not result:
+        return "eval"
+    if result[0].isdigit():
+        return f"eval_{result}"
+    return result
+
+
+def _progress_outputs(
+    outputs: tuple[Any, ...],
+    *,
+    enabled: bool,
+) -> Iterable[Any]:
+    if not enabled:
+        return outputs
+    try:
+        from colorama import Fore, Style  # type: ignore[import-untyped]
+        from progressbar import (  # type: ignore[import-not-found]
+            ETA,
+            Bar,
+            Percentage,
+            ProgressBar,
+        )
+    except ImportError:
+        return outputs
+    widgets = [
+        Fore.CYAN,
+        " merging evaluators ",
+        Percentage(),
+        " ",
+        Bar(),
+        " ",
+        ETA(),
+        Style.RESET_ALL,
+    ]
+    return ProgressBar(max_value=len(outputs), widgets=widgets)(outputs)
diff --git a/pyamplicol/src/pyamplicol/evaluators/symbolica_settings.py b/pyamplicol/src/pyamplicol/evaluators/symbolica_settings.py
new file mode 100644
index 0000000000..e188cd7d53
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/evaluators/symbolica_settings.py
@@ -0,0 +1,156 @@
+# SPDX-License-Identifier: 0BSD
+"""Evaluator settings and progress callback contract."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from .._internal.physics.types import NativeEvaluationError
+
+ProgressCallback = Callable[[dict[str, object]], None]
+
+
+def _report_progress(
+    callback: ProgressCallback | None,
+    *,
+    stage: str,
+    item: str,
+    increment: int = 0,
+    total: int | None = None,
+) -> None:
+    if callback is None:
+        return
+    payload: dict[str, object] = {
+        "stage": stage,
+        "item": item,
+    }
+    if increment:
+        payload["increment"] = int(increment)
+    if total is not None:
+        payload["total"] = int(total)
+    callback(payload)
+
+
+@dataclass(frozen=True)
+class SymbolicaEvaluatorSettings:
+    backend: str = "jit"
+    iterations: int = 10
+    cpe_iterations: int | None = None
+    n_cores: int = 4
+    direct_translation: bool = True
+    jit_direct_translation: bool = False
+    jit_optimization_level: int = 2
+    jit_compress: bool = False
+    max_horner_scheme_variables: int = 1000
+    max_common_pair_cache_entries: int = 5000000
+    max_common_pair_distance: int = 1000
+    collect_factors: bool = False
+    compiled_inline_asm: str = "default"
+    compiled_optimization_level: int = 3
+    compiled_native: bool = True
+    compiler_path: str | None = None
+    compiler_flags: tuple[str, ...] = ()
+    compiled_output_chunk_size: int | None = None
+    output_chunk_strategy: str = "uniform"
+    output_chunk_autotune_batch_size: int = 128
+    compiled_chunk_compile_workers: int = 1
+    compiled_output_dir: str | None = None
+    raw_sum_final_stage: bool = False
+    real_param_sqrt_real: bool = False
+    real_param_log_real: bool = False
+    real_param_powf_real: bool = False
+    real_param_real_if_args_real: bool = False
+
+    def __post_init__(self) -> None:
+        if self.backend not in ("jit", "compiled-complex"):
+            raise NativeEvaluationError(
+                "symbolica evaluator backend must be 'jit' or 'compiled-complex'"
+            )
+        if self.iterations < 1:
+            raise NativeEvaluationError("symbolica iterations must be positive")
+        if self.cpe_iterations is not None and self.cpe_iterations < 0:
+            raise NativeEvaluationError("symbolica cpe iterations must be non-negative")
+        if self.n_cores < 1:
+            raise NativeEvaluationError("symbolica n_cores must be positive")
+        if self.jit_optimization_level not in (0, 1, 2, 3):
+            raise NativeEvaluationError(
+                "symbolica jit optimization level must be 0, 1, 2, or 3"
+            )
+        if not isinstance(self.jit_compress, bool):
+            raise NativeEvaluationError("symbolica jit_compress must be a boolean")
+        if self.compiled_optimization_level not in (0, 1, 2, 3):
+            raise NativeEvaluationError(
+                "symbolica compiled optimization level must be 0, 1, 2, or 3"
+            )
+        if (
+            self.compiled_output_chunk_size is not None
+            and self.compiled_output_chunk_size < 1
+        ):
+            raise NativeEvaluationError(
+                "symbolica compiled output chunk size must be positive"
+            )
+        if self.output_chunk_strategy not in (
+            "auto",
+            "uniform",
+            "tapered-stage",
+            "measured-stage",
+        ):
+            raise NativeEvaluationError(
+                "symbolica output chunk strategy must be 'auto', 'uniform', "
+                "'tapered-stage', or 'measured-stage'"
+            )
+        if self.output_chunk_autotune_batch_size < 1:
+            raise NativeEvaluationError(
+                "symbolica output chunk autotune batch size must be positive"
+            )
+        if self.compiled_chunk_compile_workers < 1:
+            raise NativeEvaluationError(
+                "symbolica compiled chunk compile workers must be positive"
+            )
+        if self.max_horner_scheme_variables < 1:
+            raise NativeEvaluationError(
+                "symbolica max_horner_scheme_variables must be positive"
+            )
+        if self.max_common_pair_cache_entries < 1:
+            raise NativeEvaluationError(
+                "symbolica max_common_pair_cache_entries must be positive"
+            )
+        if self.max_common_pair_distance < 1:
+            raise NativeEvaluationError(
+                "symbolica max_common_pair_distance must be positive"
+            )
+
+    def to_json_dict(self) -> dict[str, object]:
+        from .symbolica_adapters import _compiled_compiler_flags
+
+        return {
+            "backend": self.backend,
+            "iterations": self.iterations,
+            "cpe_iterations": self.cpe_iterations,
+            "n_cores": self.n_cores,
+            "direct_translation": self.direct_translation,
+            "jit_direct_translation": self.jit_direct_translation,
+            "jit_optimization_level": self.jit_optimization_level,
+            "jit_compress": self.jit_compress,
+            "max_horner_scheme_variables": self.max_horner_scheme_variables,
+            "max_common_pair_cache_entries": self.max_common_pair_cache_entries,
+            "max_common_pair_distance": self.max_common_pair_distance,
+            "collect_factors": self.collect_factors,
+            "compiled_inline_asm": self.compiled_inline_asm,
+            "compiled_optimization_level": self.compiled_optimization_level,
+            "compiled_native": self.compiled_native,
+            "compiler_path": self.compiler_path,
+            "compiler_flags": list(self.compiler_flags),
+            "effective_compiler_flags": list(_compiled_compiler_flags(self)),
+            "compiled_output_chunk_size": self.compiled_output_chunk_size,
+            "output_chunk_strategy": self.output_chunk_strategy,
+            "output_chunk_autotune_batch_size": (self.output_chunk_autotune_batch_size),
+            "compiled_chunk_compile_workers": self.compiled_chunk_compile_workers,
+            "compiled_output_dir": self.compiled_output_dir,
+            "raw_sum_final_stage": self.raw_sum_final_stage,
+            "real_param_sqrt_real": self.real_param_sqrt_real,
+            "real_param_log_real": self.real_param_log_real,
+            "real_param_powf_real": self.real_param_powf_real,
+            "real_param_real_if_args_real": self.real_param_real_if_args_real,
+        }
diff --git a/pyamplicol/src/pyamplicol/generation/__init__.py b/pyamplicol/src/pyamplicol/generation/__init__.py
new file mode 100644
index 0000000000..bdd776bd79
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: 0BSD
+"""Private process-generation implementation.
+
+Use :class:`pyamplicol.Generator` or :func:`pyamplicol.generate` from the
+supported public API.
+"""
+
+__all__: tuple[str, ...] = ()
diff --git a/pyamplicol/src/pyamplicol/generation/artifact_writer.py b/pyamplicol/src/pyamplicol/generation/artifact_writer.py
new file mode 100644
index 0000000000..be38636aff
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/artifact_writer.py
@@ -0,0 +1,5916 @@
+# SPDX-License-Identifier: 0BSD
+"""Transactional schema-v3 output for compiled concrete processes."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import importlib.metadata
+import json
+import math
+import os
+import re
+import time
+import zipfile
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, replace
+from functools import cache
+from itertools import pairwise
+from pathlib import Path
+from typing import TYPE_CHECKING, BinaryIO, Literal, cast
+
+from pyamplicol.api.requests import ModelSource
+from pyamplicol.artifacts import (
+    ArtifactBuilder,
+    ArtifactManifest,
+    PayloadRecord,
+    load_manifest,
+)
+from pyamplicol.artifacts.manifest import PORTABLE_64LE_TARGET, compute_artifact_id
+from pyamplicol.artifacts.process_groups import (
+    PROCESS_GROUPS_MEDIA_TYPE,
+    initial_process_groups,
+    process_groups_payload,
+    validate_process_groups,
+)
+from pyamplicol.artifacts.security import sha256_file
+from pyamplicol.config import (
+    ConfigClamp,
+    ConfigResolution,
+    GenerationConfig,
+    RunConfig,
+    config_to_dict,
+)
+
+from .._internal.versions import (
+    COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY,
+    COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY,
+    COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY,
+    COMPILED_HELICITY_DUAL_LANE_CAPABILITY,
+    COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY,
+    COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY,
+    COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+    COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+    COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    EAGER_DIRECT_TABLE_BINDING_ABI,
+    EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+    EVALUATOR_RUNTIME_CAPABILITIES,
+    NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+    ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_RUNTIME_CAPABILITY,
+    PROCESS_ARTIFACT_SCHEMA_VERSION,
+    PYTHON_API_VERSION,
+    RECURRENCE_BUILDER_INPUT_ABI,
+    RECURRENCE_COLOR_RUNTIME_CAPABILITY,
+    RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+    RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    RECURRENCE_DIRECT_BACKEND_ABI,
+    RECURRENCE_DIRECT_TEMPLATE_ABI,
+    RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+    RECURRENCE_PLAN_ABI,
+    RECURRENCE_RUNTIME_LAYOUT_ABI,
+    RUNTIME_PHYSICS_SCHEMA_VERSION,
+    SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+    SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+    SYMBOLICA_SERIALIZATION_ABI,
+    SYMJIT_APPLICATION_ABI,
+    SYMJIT_F64_RUNTIME_CAPABILITY,
+    SYMJIT_PLANE_APPLICATION_ABI,
+    SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+    TOML_SCHEMA_VERSION,
+    active_native_build_inputs_sha256,
+    active_source_revision,
+    package_version,
+    verify_native_module,
+)
+from ..evaluators.execution_schema import evaluator_runtime_capabilities
+from ..models.loading import COMPILED_MODEL_SCHEMA_VERSION, CompiledModel
+from ..models.prepared import (
+    PREPARED_KERNEL_PACK_IDENTITY_ABI,
+    prepared_kernel_pack_manifest_identity_sha256,
+)
+from .contracts import RuntimeExpressionSchema
+from .eager_columnar import EAGER_LOWERING_INPUT_ABI
+from .eager_lowering import EAGER_RUNTIME_KIND
+from .eager_tables import EAGER_KERNEL_ABI, EAGER_RUNTIME_CAPABILITY
+from .evaluator_container import (
+    PacbinIndex,
+    PacbinMemberKind,
+    PacbinMemberSource,
+    PacbinReader,
+    write_pacbin_atomic,
+)
+from .process_grouping import PROCESS_GROUPS_PATH, PROCESS_GROUPS_ROLE, ProcessGroupMap
+from .recurrence_schedule_sharing import (
+    RECURRENCE_PROCESS_BINDING_ABI,
+    RECURRENCE_SCHEDULE_INDEX_PATH,
+    RECURRENCE_SCHEDULE_SHARING_SCHEMA_VERSION,
+    RecurrenceProcessBinding,
+    RecurrenceProcessExecutorPack,
+    RecurrenceProcessRemap,
+    RecurrenceScheduleSharingPlan,
+    intern_recurrence_schedules,
+    recurrence_helicity_selector_schedule_digest,
+)
+from .structural_source_proof import (
+    ROLE as STRUCTURAL_SOURCE_PROOF_ROLE,
+)
+from .structural_source_proof import build_generation_structural_proof
+from .validation import ValidationPointRecord, validation_point_map
+
+if TYPE_CHECKING:
+    from pyamplicol.artifacts.transaction import ArtifactWriteMode
+
+ApiBundleHook = Callable[
+    [ArtifactBuilder, Mapping[str, Sequence[Sequence[float]]]],
+    Sequence[object],
+]
+ArtifactPayloadHook = Callable[[ArtifactBuilder], Mapping[str, object]]
+
+_CONFIG_REQUESTED_PATH = "config/requested.toml"
+_CONFIG_EFFECTIVE_PATH = "config/effective.toml"
+_COMPILED_MODEL_PATH = "model/compiled-model.json"
+_MODEL_PARAMETERS_PATH = "model/parameters.json"
+_EVALUATOR_SET_PATH = "processes/evaluators.json"
+_EAGER_KERNEL_PACK_PATH = "model/eager-kernel-pack.json"
+_EAGER_KERNEL_PAYLOAD_ROOT = "model/eager-kernels"
+_HELICITY_SUM_PAYLOAD_ROOT = "helicity-sum"
+_HELICITY_SELECTOR_UNION_PAYLOAD_ROOT = "helicity-selector-union"
+_COLOR_SELECTOR_PAYLOAD_ROOT = "color-selector"
+_EAGER_PACK_IDENTITY_EXTENSION = "eager_prepared_pack"
+_EAGER_PACK_IDENTITY_KIND = "pyamplicol-prepared-kernel-pack-identity"
+_EAGER_PACK_IDENTITY_SCHEMA_VERSION = 1
+_EVALUATOR_PAYLOAD_CONTAINER_EXTENSION = "evaluator_payload_container"
+_RECURRENCE_BOOTSTRAP_FILENAME = "recurrence-bootstrap.bin"
+_EVALUATOR_PAYLOAD_CONTAINER_PATH = "evaluators.pacbin"
+_COMPILED_COLOR_CONTRACTION_MEMBER_PATH = "compiled-color.pacrclr3"
+_EVALUATOR_PAYLOAD_CONTAINER_KIND = "pyamplicol-evaluator-payload-container"
+_EVALUATOR_PAYLOAD_CONTAINER_SCHEMA_VERSION = 1
+_EVALUATOR_PAYLOAD_CONTAINER_STORAGE_ABI = "pacbin-v1"
+EAGER_PLAN_V3_ABI = "pyamplicol-eager-plan-v3"
+EAGER_RUNTIME_LAYOUT_ABI = "pyamplicol-eager-runtime-layout-v1"
+EAGER_PLAN_V3_RUNTIME_CAPABILITY = "rusticol.eager-runtime-layout.complex-f64.v1"
+_EAGER_PLAN_V3_RUNTIME_CAPABILITIES = tuple(
+    sorted(
+        (
+            EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+        )
+    )
+)
+EAGER_RUNTIME_CONTAINER_KIND = "pyamplicol-eager-runtime-container"
+EAGER_RUNTIME_CONTAINER_SCHEMA_VERSION = 1
+EAGER_RUNTIME_STORAGE_ABI = "pacbin-v1"
+_EAGER_RUNTIME_CONTAINER_PATH = "eager-runtime.pacbin"
+RECURRENCE_RUNTIME_KIND = "pyamplicol-runtime-recurrence-execution"
+RECURRENCE_RUNTIME_CONTAINER_KIND = "pyamplicol-recurrence-runtime-container"
+RECURRENCE_RUNTIME_CONTAINER_SCHEMA_VERSION = 1
+RECURRENCE_RUNTIME_STORAGE_ABI = "pacbin-v1"
+_RECURRENCE_RUNTIME_CONTAINER_PATH = "recurrence-runtime.pacbin"
+_RECURRENCE_DIRECT_SCHEDULE_MEMBER_PATH = "schedule/recurrence-direct-schedule-v2.bin"
+_RECURRENCE_COLOR_CONTRACTION_PATH = "recurrence-color.bin"
+_RECURRENCE_SCHEDULE_SHARING_EXTENSION = "recurrence_schedule_sharing"
+_RECURRENCE_HELICITY_SELECTOR_SCHEDULE_ROOT = "recurrence/schedules"
+_RECURRENCE_HELICITY_SELECTOR_BINDING_PATH = "helicity-selector-binding.bin"
+_RECURRENCE_HELICITY_DISPATCH_PATH = "recurrence-helicity-dispatch-v1.bin"
+_RECURRENCE_HELICITY_DISPATCH_ABI = "pyamplicol-recurrence-helicity-dispatch-v1"
+ON_THE_FLY_RUNTIME_KIND = "pyamplicol-runtime-on-the-fly-execution"
+ON_THE_FLY_RUNTIME_CONTAINER_KIND = "pyamplicol-on-the-fly-runtime-container"
+ON_THE_FLY_RUNTIME_CONTAINER_SCHEMA_VERSION = 1
+ON_THE_FLY_RUNTIME_STORAGE_ABI = "pacbin-v1"
+ON_THE_FLY_PUBLIC_METADATA_KIND = "pyamplicol-on-the-fly-public-metadata"
+_RECURRENCE_HELICITY_SELECTOR_COMPANION_V2_KIND = (
+    "pyamplicol-recurrence-helicity-selector-companion-v2"
+)
+_ON_THE_FLY_RUNTIME_CONTAINER_PATH = "on-the-fly-runtime.pacbin"
+_ON_THE_FLY_PROCESS_SEED_MEMBER_PATH = "on-the-fly/process-seed-v1.bin"
+_ON_THE_FLY_COLOR_CONTRACTION_PATH = "on-the-fly-color.bin"
+_SAFE_TOML_KEY = re.compile(r"^[A-Za-z0-9_-]+$")
+_SUPPORTED_ARTIFACT_TARGETS = frozenset(
+    {
+        "aarch64-apple-darwin",
+        "x86_64-apple-darwin",
+        "x86_64-unknown-linux-gnu",
+    }
+)
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledExecutionArtifact:
+    runtime_schema: RuntimeExpressionSchema
+    stage_manifest: Mapping[str, object]
+    model_parameter_evaluator: Mapping[str, object] | None
+    dag_summary: Mapping[str, object]
+    evaluator_root: Path
+    color_selector_executions: tuple[CompiledColorSelectorExecutionArtifact, ...] = ()
+    helicity_selector_executions: tuple[
+        CompiledHelicitySelectorExecutionArtifact, ...
+    ] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledColorSelectorExecutionArtifact:
+    materialized_sector_id: int
+    execution: CompiledExecutionArtifact
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledHelicitySelectorExecutionArtifact:
+    selector_domain_ids: tuple[int, ...]
+    execution: CompiledExecutionArtifact
+    schedule_mode: str = "parent-closure"
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledProcessArtifact:
+    process_id: str
+    expression: str
+    color_accuracy: str
+    external_pdgs: tuple[int, ...]
+    aliases: tuple[Mapping[str, object], ...]
+    runtime_schema: RuntimeExpressionSchema
+    stage_manifest: Mapping[str, object]
+    model_parameter_evaluator: Mapping[str, object] | None
+    dag_summary: Mapping[str, object]
+    evaluator_root: Path
+    validation_point: ValidationPointRecord
+    generation_filters: Mapping[str, object]
+    color_contraction_payload: bytes | None = None
+    helicity_sum_execution: CompiledExecutionArtifact | None = None
+    helicity_selector_executions: tuple[
+        CompiledHelicitySelectorExecutionArtifact, ...
+    ] = ()
+    color_selector_executions: tuple[CompiledColorSelectorExecutionArtifact, ...] = ()
+    umami_physics: Mapping[str, object] | None = None
+    umami_color_sectors: tuple[Mapping[str, object], ...] = ()
+    umami_structural_keys: Mapping[str, str] | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class EagerPlanV3ProcessArtifact:
+    """One Rust-lowered eager runtime plus its bounded publication metadata."""
+
+    process_id: str
+    expression: str
+    color_accuracy: str
+    external_pdgs: tuple[int, ...]
+    aliases: tuple[Mapping[str, object], ...]
+    physics: Mapping[str, object]
+    eager_runtime_path: Path
+    eager_runtime_size_bytes: int
+    eager_runtime_sha256: str
+    eager_runtime_member_count: int
+    eager_runtime_unpacked_size_bytes: int
+    eager_runtime_index_sha256: str
+    lowering_input_sha256: str
+    referenced_kernel_ids: frozenset[int]
+    inspection_summary: Mapping[str, object]
+    point_tile_size: int
+    workspace_mib: int
+    dag_summary: Mapping[str, object]
+    validation_point: ValidationPointRecord
+    generation_filters: Mapping[str, object]
+    umami_physics: Mapping[str, object] | None = None
+    umami_color_sectors: tuple[Mapping[str, object], ...] = ()
+    umami_structural_keys: Mapping[str, str] | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceProcessArtifact:
+    """One compact recurrence runtime plus bounded public metadata."""
+
+    process_id: str
+    expression: str
+    color_accuracy: str
+    external_pdgs: tuple[int, ...]
+    aliases: tuple[Mapping[str, object], ...]
+    physics: Mapping[str, object]
+    recurrence_schedule_path: Path
+    recurrence_schedule_digest: str
+    recurrence_native_schedule_semantic_digest: str
+    recurrence_schedule_size_bytes: int
+    recurrence_schedule_sha256: str
+    recurrence_schedule_member_count: int
+    recurrence_schedule_unpacked_size_bytes: int
+    recurrence_schedule_index_sha256: str
+    builder_input_sha256: str
+    prepared_kernel_pack_digest: str
+    direct_template_catalog_digest: str
+    referenced_kernel_ids: frozenset[int]
+    inspection_summary: Mapping[str, object]
+    runtime_metadata: Mapping[str, object]
+    color_contraction_payload: bytes | None
+    color_contraction_summary: Mapping[str, object] | None
+    point_tile_size: int
+    workspace_mib: int
+    recurrence_summary: Mapping[str, object]
+    validation_point: ValidationPointRecord
+    generation_filters: Mapping[str, object]
+    generation_profile: Mapping[str, object]
+    recurrence_process_remap: RecurrenceProcessRemap
+    recurrence_process_executor_pack: RecurrenceProcessExecutorPack
+    process_digest: str
+    process_support_mask: int = 1
+    helicity_selector_companion: RecurrenceHelicitySelectorPlanArtifact | None = None
+    umami_physics: Mapping[str, object] | None = None
+    umami_color_sectors: tuple[Mapping[str, object], ...] = ()
+    umami_structural_keys: Mapping[str, str] | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceHelicitySelectorPlanArtifact:
+    """Persisted physical-colour schedule for runtime singleton helicities.
+
+    The schedule uses the ordinary recurrence Direct-plan ABI with runtime
+    source-state dispatch.  It deliberately owns neither physics metadata nor
+    prepared-model state: those identities remain authenticated by the
+    enclosing recurrence process.
+    """
+
+    recurrence_schedule_path: Path
+    recurrence_base_schedule_digest: str
+    recurrence_schedule_digest: str
+    recurrence_native_schedule_semantic_digest: str
+    recurrence_schedule_size_bytes: int
+    recurrence_schedule_sha256: str
+    recurrence_schedule_member_count: int
+    recurrence_schedule_unpacked_size_bytes: int
+    recurrence_schedule_index_sha256: str
+    helicity_dispatch_path: Path
+    helicity_dispatch_size_bytes: int
+    helicity_dispatch_sha256: str
+    helicity_dispatch_base_runtime_layout_digest: str
+    helicity_dispatch_resolved_helicity_count: int
+    physical_destination_count: int
+    builder_input_sha256: str
+    inspection_summary: Mapping[str, object]
+    referenced_kernel_ids: frozenset[int]
+    recurrence_process_remap: RecurrenceProcessRemap
+    recurrence_process_executor_pack: RecurrenceProcessExecutorPack
+
+
+@dataclass(frozen=True, slots=True)
+class OnTheFlyProcessArtifact:
+    """One source-only runtime seed plus compact public metadata."""
+
+    process_id: str
+    expression: str
+    color_accuracy: str
+    external_pdgs: tuple[int, ...]
+    aliases: tuple[Mapping[str, object], ...]
+    physics: Mapping[str, object]
+    runtime_path: Path
+    runtime_size_bytes: int
+    runtime_sha256: str
+    runtime_member_count: int
+    runtime_unpacked_size_bytes: int
+    runtime_index_sha256: str
+    referenced_kernel_ids: frozenset[int]
+    runtime_metadata: Mapping[str, object]
+    selector_policy: Mapping[str, object]
+    color_contraction_payload: bytes | None
+    color_contraction_summary: Mapping[str, object] | None
+    point_tile_size: int
+    query_construction_threads: int
+    validation_point: ValidationPointRecord
+    generation_filters: Mapping[str, object]
+    umami_physics: Mapping[str, object] | None = None
+    umami_color_sectors: tuple[Mapping[str, object], ...] = ()
+    umami_structural_keys: Mapping[str, str] | None = None
+
+
+ProcessArtifact = (
+    CompiledProcessArtifact
+    | EagerPlanV3ProcessArtifact
+    | RecurrenceProcessArtifact
+    | OnTheFlyProcessArtifact
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactWriteResult:
+    output: Path
+    files: tuple[Path, ...]
+    validation_points: Mapping[str, Mapping[str, object]]
+    api_bundle_path: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class _GenerationConfigProvenance:
+    requested: GenerationConfig | RunConfig
+    effective: GenerationConfig | RunConfig
+    adjustments: tuple[ConfigClamp, ...] = ()
+
+    @classmethod
+    def from_config(
+        cls,
+        config: GenerationConfig | RunConfig | ConfigResolution | None,
+    ) -> _GenerationConfigProvenance:
+        if isinstance(config, ConfigResolution):
+            effective = replace(config.effective, color=config.effective.resolved_color)
+            return cls(config.requested, effective, config.clamps)
+        effective = GenerationConfig() if config is None else config
+        if isinstance(effective, RunConfig):
+            return cls(effective, replace(effective, color=effective.resolved_color))
+        return cls(effective, effective)
+
+
+class _EvaluatorPayloadCollector:
+    """Collect evaluator payloads and publish one root pacbin container."""
+
+    def __init__(
+        self,
+        builder: ArtifactBuilder,
+        *,
+        existing: ArtifactManifest | None,
+        target: Mapping[str, object],
+    ) -> None:
+        self._builder = builder
+        self._existing = existing
+        self._target = dict(target)
+        self._new_sources: dict[str, PacbinMemberSource] = {}
+        self._staged_loose_paths: set[str] = set()
+        self._discarded_prefixes: set[str] = set()
+
+    def discard_prefix(self, prefix: str) -> None:
+        normalized = prefix.strip("/")
+        if not normalized:
+            raise ValueError("packed evaluator discard prefix must not be empty")
+        self._discarded_prefixes.add(normalized)
+        owned_prefix = normalized + "/"
+        self._new_sources = {
+            path: source
+            for path, source in self._new_sources.items()
+            if path != normalized and not path.startswith(owned_prefix)
+        }
+
+    def add_file(
+        self,
+        relative: str,
+        source: Path,
+        *,
+        process_id: str | None,
+    ) -> PayloadRecord:
+        kind = _packed_evaluator_member_kind(relative)
+        if kind is None:
+            return self._builder.add_file(
+                relative,
+                source,
+                role="evaluator-state",
+                media_type=_media_type(source),
+                target=self._target,
+                process_id=process_id,
+            )
+            return
+        if source.is_symlink() or not source.is_file():
+            raise ValueError(f"evaluator payload must be a regular file: {source}")
+        # Evaluator builders may reuse their temporary output paths while
+        # materializing nested selector lanes.  Snapshot each payload when it
+        # is registered so a later write cannot silently change an earlier
+        # logical container member before publication.
+        record = self._builder.add_file(
+            relative,
+            source,
+            role="evaluator-state",
+            media_type=_media_type(source),
+            target=self._target,
+            process_id=process_id,
+        )
+        self._register_staged_source(relative, kind)
+        return record
+
+    def add_bytes(
+        self,
+        relative: str,
+        content: bytes,
+        *,
+        process_id: str | None,
+        media_type: str | None = None,
+    ) -> PayloadRecord:
+        kind = _packed_evaluator_member_kind(relative)
+        if kind is None:
+            return self._builder.add_bytes(
+                relative,
+                content,
+                role="evaluator-state",
+                media_type=media_type or _media_type(Path(relative)),
+                target=self._target,
+                process_id=process_id,
+            )
+        record = self._builder.add_bytes(
+            relative,
+            content,
+            role="evaluator-state",
+            media_type=media_type or _media_type(Path(relative)),
+            target=self._target,
+            process_id=process_id,
+        )
+        self._register_staged_source(relative, kind)
+        return record
+
+    def add_stream(
+        self,
+        relative: str,
+        source: BinaryIO,
+        *,
+        process_id: str | None,
+        media_type: str | None = None,
+    ) -> None:
+        kind = _packed_evaluator_member_kind(relative)
+        self._builder.add_stream(
+            relative,
+            source,
+            role="evaluator-state",
+            media_type=media_type or _media_type(Path(relative)),
+            target=self._target,
+            process_id=process_id,
+        )
+        if kind is not None:
+            self._register_staged_source(relative, kind)
+
+    def publish(self) -> dict[str, object] | None:
+        existing_container = _existing_evaluator_container_path(self._existing)
+        if existing_container is None:
+            return self._publish_with_old_sources(())
+
+        container_path = self._builder.staged_path(existing_container)
+        with PacbinReader.open(container_path, verify_payloads=True) as reader:
+            old_sources = tuple(
+                PacbinMemberSource(
+                    member.logical_path,
+                    member.kind,
+                    cast("BinaryIO", reader.open_member_stream(member.logical_path)),
+                )
+                for member in reader.members
+                if not self._is_discarded(member.logical_path)
+                and member.logical_path not in self._new_sources
+            )
+            return self._publish_with_old_sources(old_sources)
+
+    def _publish_with_old_sources(
+        self,
+        old_container_sources: Sequence[PacbinMemberSource],
+    ) -> dict[str, object] | None:
+        combined = {source.logical_path: source for source in old_container_sources}
+        loose_paths: set[str] = set(self._staged_loose_paths)
+        if self._existing is not None:
+            for record in self._existing.payloads:
+                kind = _packed_evaluator_member_kind(record.path)
+                if kind is None or self._is_discarded(record.path):
+                    continue
+                path = self._builder.staged_path(record.path)
+                if not path.is_file() or path.is_symlink():
+                    continue
+                loose_paths.add(record.path)
+                combined[record.path] = PacbinMemberSource(
+                    record.path,
+                    kind,
+                    path,
+                )
+        combined.update(self._new_sources)
+        if not combined:
+            self._builder.discard_payloads(_EVALUATOR_PAYLOAD_CONTAINER_PATH)
+            return None
+
+        destination = self._builder.staged_path(
+            _EVALUATOR_PAYLOAD_CONTAINER_PATH,
+            create_parent=True,
+        )
+        written = write_pacbin_atomic(destination, combined.values())
+        with PacbinReader.open(destination, verify_payloads=True) as verified:
+            if verified.index != written:
+                raise ValueError("published evaluator container failed verification")
+            index = verified.index
+
+        for relative in sorted(loose_paths):
+            self._builder.discard_payloads(relative)
+        self._builder.register_staged_file(
+            _EVALUATOR_PAYLOAD_CONTAINER_PATH,
+            role="evaluator-state",
+            media_type="application/octet-stream",
+            target=self._target,
+            process_id=None,
+        )
+        return _evaluator_payload_container_extension(index)
+
+    def _register_staged_source(
+        self,
+        relative: str,
+        kind: PacbinMemberKind,
+    ) -> None:
+        path = self._builder.staged_path(relative)
+        self._new_sources[relative] = PacbinMemberSource(relative, kind, path)
+        self._staged_loose_paths.add(relative)
+
+    def _is_discarded(self, relative: str) -> bool:
+        return any(
+            relative == prefix or relative.startswith(prefix + "/")
+            for prefix in self._discarded_prefixes
+        )
+
+
+def _packed_evaluator_member_kind(relative: str) -> PacbinMemberKind | None:
+    if relative.endswith(".symjit"):
+        return PacbinMemberKind.SYMJIT_APPLICATION
+    if relative.endswith(".evaluator.bin"):
+        return PacbinMemberKind.SYMBOLICA_EXACT_STATE
+    if relative.endswith(".color.pacrclr3") or relative.endswith(
+        "/compiled-color.pacrclr3"
+    ):
+        return PacbinMemberKind.COLOR_CONTRACTION
+    return None
+
+
+def _existing_evaluator_container_path(
+    existing: ArtifactManifest | None,
+) -> str | None:
+    if existing is None:
+        return None
+    raw = existing.extensions.get(_EVALUATOR_PAYLOAD_CONTAINER_EXTENSION)
+    if raw is None:
+        return None
+    extension = _mapping(raw)
+    if str(extension.get("path")) != _EVALUATOR_PAYLOAD_CONTAINER_PATH:
+        raise ValueError("append artifact has an incompatible evaluator container path")
+    return _EVALUATOR_PAYLOAD_CONTAINER_PATH
+
+
+def _evaluator_payload_container_extension(index: PacbinIndex) -> dict[str, object]:
+    return {
+        "kind": _EVALUATOR_PAYLOAD_CONTAINER_KIND,
+        "schema_version": _EVALUATOR_PAYLOAD_CONTAINER_SCHEMA_VERSION,
+        "storage_abi": _EVALUATOR_PAYLOAD_CONTAINER_STORAGE_ABI,
+        "path": _EVALUATOR_PAYLOAD_CONTAINER_PATH,
+        "member_count": len(index.members),
+        "unpacked_size_bytes": sum(member.length for member in index.members),
+        "index_sha256": index.index_sha256,
+    }
+
+
+def _write_recurrence_schedule_roots(
+    builder: ArtifactBuilder,
+    evaluator_payloads: _EvaluatorPayloadCollector,
+    plan: RecurrenceScheduleSharingPlan,
+) -> dict[str, object]:
+    """Stage each interned schedule once and publish its root binding index."""
+
+    for schedule in plan.schedules:
+        record = evaluator_payloads.add_file(
+            schedule.artifact_path,
+            schedule.source_path,
+            process_id=None,
+        )
+        if record.sha256 != schedule.sha256 or record.size_bytes != schedule.size_bytes:
+            raise ValueError(
+                f"interned recurrence schedule {schedule.digest} changed before "
+                "root publication"
+            )
+    index_record = builder.add_json(
+        RECURRENCE_SCHEDULE_INDEX_PATH,
+        plan.to_mapping(),
+        role="evaluator-manifest",
+        compact=True,
+    )
+    return plan.extension_mapping(index_sha256=index_record.sha256)
+
+
+def _validated_recurrence_helicity_selector_schedule_digest(
+    companion: RecurrenceHelicitySelectorPlanArtifact,
+) -> str:
+    base_digest = _canonical_sha256(
+        companion.recurrence_base_schedule_digest,
+        "recurrence helicity-selector base schedule digest",
+    )
+    native_digest = _canonical_sha256(
+        companion.recurrence_native_schedule_semantic_digest,
+        "recurrence helicity-selector native schedule digest",
+    )
+    if base_digest != native_digest:
+        raise ValueError(
+            "recurrence helicity-selector plan must use relation-free native "
+            "schedule identity"
+        )
+    digest = _canonical_sha256(
+        companion.recurrence_schedule_digest,
+        "recurrence helicity-selector schedule digest",
+    )
+    expected = recurrence_helicity_selector_schedule_digest(
+        base_digest,
+        companion.helicity_dispatch_sha256,
+    )
+    if digest != expected:
+        raise ValueError(
+            "recurrence helicity-selector root digest does not bind its Direct "
+            "plan and helicity dispatch"
+        )
+    return digest
+
+
+def _recurrence_helicity_selector_schedule_path(
+    companion: RecurrenceHelicitySelectorPlanArtifact,
+) -> str:
+    digest = _validated_recurrence_helicity_selector_schedule_digest(companion)
+    return (
+        f"{_RECURRENCE_HELICITY_SELECTOR_SCHEDULE_ROOT}/{digest}/"
+        f"{_RECURRENCE_RUNTIME_CONTAINER_PATH}"
+    )
+
+
+def _recurrence_helicity_dispatch_path(
+    companion: RecurrenceHelicitySelectorPlanArtifact,
+) -> str:
+    digest = _validated_recurrence_helicity_selector_schedule_digest(companion)
+    return (
+        f"{_RECURRENCE_HELICITY_SELECTOR_SCHEDULE_ROOT}/{digest}/"
+        f"{_RECURRENCE_HELICITY_DISPATCH_PATH}"
+    )
+
+
+def _write_recurrence_helicity_selector_schedule_roots(
+    evaluator_payloads: _EvaluatorPayloadCollector,
+    processes: Sequence[ProcessArtifact],
+    *,
+    recurrence_sharing: RecurrenceScheduleSharingPlan | None,
+) -> None:
+    """Stage every persisted selector schedule once by semantic digest."""
+
+    primary_by_digest = (
+        {}
+        if recurrence_sharing is None
+        else {schedule.digest: schedule for schedule in recurrence_sharing.schedules}
+    )
+    selector_by_digest: dict[str, RecurrenceHelicitySelectorPlanArtifact] = {}
+    reused_primary_digests: set[str] = set()
+    for process in processes:
+        if not isinstance(process, RecurrenceProcessArtifact):
+            continue
+        companion = process.helicity_selector_companion
+        if not isinstance(companion, RecurrenceHelicitySelectorPlanArtifact):
+            continue
+        digest = _validated_recurrence_helicity_selector_schedule_digest(companion)
+        primary = primary_by_digest.get(digest)
+        if primary is not None:
+            if (
+                primary.sha256 != companion.recurrence_schedule_sha256
+                or primary.size_bytes != companion.recurrence_schedule_size_bytes
+                or primary.member_count != companion.recurrence_schedule_member_count
+                or primary.unpacked_size_bytes
+                != companion.recurrence_schedule_unpacked_size_bytes
+                or primary.index_sha256 != companion.recurrence_schedule_index_sha256
+            ):
+                raise ValueError(
+                    "recurrence selector and primary schedule share a digest but "
+                    "not an identical payload"
+                )
+            selector_by_digest[digest] = companion
+            reused_primary_digests.add(digest)
+            continue
+        previous = selector_by_digest.get(digest)
+        if previous is not None:
+            if (
+                previous.recurrence_schedule_sha256
+                != companion.recurrence_schedule_sha256
+                or previous.recurrence_schedule_size_bytes
+                != companion.recurrence_schedule_size_bytes
+                or previous.recurrence_schedule_member_count
+                != companion.recurrence_schedule_member_count
+                or previous.recurrence_schedule_unpacked_size_bytes
+                != companion.recurrence_schedule_unpacked_size_bytes
+                or previous.recurrence_schedule_index_sha256
+                != companion.recurrence_schedule_index_sha256
+                or previous.helicity_dispatch_sha256
+                != companion.helicity_dispatch_sha256
+                or previous.helicity_dispatch_size_bytes
+                != companion.helicity_dispatch_size_bytes
+                or previous.helicity_dispatch_base_runtime_layout_digest
+                != companion.helicity_dispatch_base_runtime_layout_digest
+                or previous.helicity_dispatch_resolved_helicity_count
+                != companion.helicity_dispatch_resolved_helicity_count
+            ):
+                raise ValueError(
+                    "recurrence helicity-selector schedule digest maps to "
+                    "different payloads"
+                )
+            continue
+        selector_by_digest[digest] = companion
+
+    for digest, companion in sorted(selector_by_digest.items()):
+        if digest not in reused_primary_digests:
+            record = evaluator_payloads.add_file(
+                _recurrence_helicity_selector_schedule_path(companion),
+                companion.recurrence_schedule_path,
+                process_id=None,
+            )
+            if (
+                record.sha256 != companion.recurrence_schedule_sha256
+                or record.size_bytes != companion.recurrence_schedule_size_bytes
+            ):
+                raise ValueError(
+                    f"persisted recurrence helicity-selector schedule {digest} "
+                    "changed before publication"
+                )
+        dispatch_record = evaluator_payloads.add_file(
+            _recurrence_helicity_dispatch_path(companion),
+            companion.helicity_dispatch_path,
+            process_id=None,
+        )
+        if (
+            dispatch_record.sha256 != companion.helicity_dispatch_sha256
+            or dispatch_record.size_bytes != companion.helicity_dispatch_size_bytes
+        ):
+            raise ValueError(
+                f"persisted recurrence helicity dispatch {digest} changed before "
+                "publication"
+            )
+
+
+def _write_umami_bundle(
+    builder: ArtifactBuilder,
+    *,
+    processes: Sequence[ProcessArtifact],
+    process_records: Sequence[Mapping[str, object]],
+    compiled_model: CompiledModel,
+    process_groups: ProcessGroupMap | None = None,
+) -> None:
+    """Add export-only selector tables after runtime physics has been staged."""
+    from ..artifacts.umami import UmamiProcessInput, umami_bundle_payloads
+    from ..artifacts.umami_otf import restore_umami_on_the_fly_input
+
+    new_processes = {process.process_id: process for process in processes}
+    inputs = []
+    previous_umami = None
+    for record in process_records:
+        identifier = str(record["id"])
+        process = new_processes.get(identifier)
+        physics = (
+            process.umami_physics
+            if process is not None and process.umami_physics is not None
+            else json.loads(
+                builder.staged_path(str(record["physics_path"])).read_text(
+                    encoding="utf-8"
+                )
+            )
+        )
+        umami_input = UmamiProcessInput(
+            process_id=identifier,
+            expression=str(record["expression"]),
+            color_accuracy=str(record["color_accuracy"]),
+            external_pdgs=tuple(int(pdg) for pdg in record["external_pdgs"]),
+            physics=physics,
+            aliases=tuple(record.get("aliases", ())),
+            color_sectors=() if process is None else process.umami_color_sectors,
+            structural_keys=(
+                None if process is None else process.umami_structural_keys
+            ),
+            # Flavour-blind members were not generated: they are exported as
+            # selectors evaluated through this representative's runtime.
+            group_members=(
+                ()
+                if process_groups is None or identifier not in process_groups.groups
+                else tuple(
+                    member
+                    for member in process_groups.groups[identifier].members[1:]
+                    if not member.generated
+                )
+            ),
+        )
+        if physics.get("kind") == ON_THE_FLY_PUBLIC_METADATA_KIND:
+            # Appended processes retain compact runtime physics. Their previous
+            # SDK already contains every physical selector and colour tag.
+            if previous_umami is None:
+                try:
+                    previous = json.loads(
+                        builder.staged_path("API/umami/metadata.json").read_text(
+                            encoding="utf-8"
+                        )
+                    )
+                    previous_umami = (
+                        [
+                            json.loads(
+                                builder.staged_path(
+                                    "API/umami/" + str(provider["metadata"])
+                                ).read_text(encoding="utf-8")
+                            )
+                            for provider in previous["providers"]
+                        ]
+                        if previous.get("kind") == "pyamplicol-umami-provider-index"
+                        else [previous]
+                    )
+                except FileNotFoundError as exc:
+                    raise ValueError(
+                        "appending this OTF artifact requires its existing UMAMI "
+                        "metadata; regenerate the complete process set"
+                    ) from exc
+            umami_input = restore_umami_on_the_fly_input(umami_input, previous_umami)
+        inputs.append(umami_input)
+    for payload in umami_bundle_payloads(
+        processes=inputs,
+        compiled_model=compiled_model.to_dict(),
+        artifact_id=compute_artifact_id(
+            {"payloads": [record.as_dict() for record in builder.payload_records()]}
+        ),
+    ):
+        builder.add_bytes(
+            payload.path,
+            payload.content,
+            role=payload.role,
+            media_type=payload.media_type,
+            executable=payload.executable,
+        )
+
+
+def write_schema_v3_artifact(
+    destination: str | Path,
+    *,
+    mode: Literal["error", "append", "replace"],
+    source: ModelSource,
+    compiled_model: CompiledModel,
+    configuration: _GenerationConfigProvenance,
+    processes: Sequence[ProcessArtifact],
+    timings: Mapping[str, float],
+    api_bundle_hook: ApiBundleHook | None = None,
+    progress_callback: Callable[[dict[str, object]], None] | None = None,
+    payload_hook: ArtifactPayloadHook | None = None,
+    process_groups: ProcessGroupMap | None = None,
+) -> ArtifactWriteResult:
+    if not processes:
+        raise ValueError("schema-v3 generation requires at least one concrete process")
+    output = Path(destination).expanduser().resolve(strict=False)
+    existing = load_manifest(output) if mode == "append" else None
+    if existing is not None:
+        _reject_legacy_eager_append(existing)
+    hook = api_bundle_hook or _default_api_bundle_hook()
+    requested_config = _config_payload(configuration.requested)
+    effective_config = _config_payload(configuration.effective)
+    bundle_requested = _bundle_requested(configuration.effective)
+    existing_bundle = _existing_bundle_path(existing)
+    can_emit_bundle = hook is not None or existing_bundle is not None
+    effective_config = _effective_config_payload(
+        effective_config,
+        disable_api_bundle=bundle_requested and not can_emit_bundle,
+    )
+    adjustments = [
+        {"path": adjustment.path, "reason": adjustment.reason}
+        for adjustment in configuration.adjustments
+    ]
+    if bundle_requested and not can_emit_bundle:
+        adjustments.append(
+            {
+                "path": "generation.emit_api_bundle",
+                "reason": "no root API-bundle emitter is installed",
+            }
+        )
+    requested_bytes = _toml_bytes(requested_config)
+    effective_bytes = _toml_bytes(effective_config)
+    required_runtime_capabilities = set(
+        _existing_required_runtime_capabilities(existing)
+    )
+    for process in processes:
+        required_runtime_capabilities.update(_process_runtime_capabilities(process))
+    canonical_runtime_capabilities = tuple(sorted(required_runtime_capabilities))
+    producer = _producer_metadata(
+        configuration.effective,
+        runtime_capabilities=canonical_runtime_capabilities,
+        implicit_portable_jit_evidence=_implicit_generation_portable_jit_evidence(
+            processes
+        ),
+    )
+    model = _model_metadata(source, compiled_model)
+    dependencies = _dependency_metadata(source)
+    eager_pack_identity = _eager_prepared_pack_identity(
+        existing,
+        compiled_model=compiled_model,
+        processes=processes,
+    )
+    recurrence_processes = tuple(
+        process
+        for process in processes
+        if isinstance(process, RecurrenceProcessArtifact)
+    )
+    if existing is not None and recurrence_processes:
+        raise ValueError(
+            "recurrence root schedules and process bindings are immutable; "
+            "regenerate the recurrence process set instead of appending"
+        )
+    recurrence_sharing_plan = (
+        intern_recurrence_schedules(recurrence_processes)
+        if existing is None and recurrence_processes
+        else None
+    )
+    _validate_append_compatibility(
+        existing,
+        producer=producer,
+        model=model,
+        eager_pack_identity=eager_pack_identity,
+        requested_bytes=requested_bytes,
+        effective_bytes=effective_bytes,
+        adjustments=adjustments,
+        processes=processes,
+    )
+    if existing is not None:
+        producer = _plain_mapping(existing.producer)
+        model = _plain_mapping(existing.model)
+        dependencies = tuple(_plain_mapping(item) for item in existing.dependencies)
+
+    target = _mapping(producer["target"])
+    process_records = _existing_process_records(existing)
+    evaluator_entries = _existing_evaluator_entries(existing)
+    execution_manifest_sha256_by_process: dict[str, str] = {}
+    validation_records = tuple(process.validation_point for process in processes)
+    validations = validation_point_map(validation_records)
+    bundle_points = _existing_bundle_points(existing)
+    bundle_points.update(build_api_validation_points(processes))
+    api_bundle_path = existing_bundle
+    write_mode = cast("ArtifactWriteMode", mode)
+    with ArtifactBuilder(
+        output,
+        mode=write_mode,
+        expected_artifact_id=(existing.artifact_id if existing is not None else None),
+    ) as builder:
+        evaluator_payloads = _EvaluatorPayloadCollector(
+            builder,
+            existing=existing,
+            target=target,
+        )
+        recurrence_sharing_extension = (
+            _write_recurrence_schedule_roots(
+                builder,
+                evaluator_payloads,
+                recurrence_sharing_plan,
+            )
+            if recurrence_sharing_plan is not None
+            else None
+        )
+        _write_recurrence_helicity_selector_schedule_roots(
+            evaluator_payloads,
+            processes,
+            recurrence_sharing=recurrence_sharing_plan,
+        )
+        if existing is None:
+            if progress_callback is not None:
+                progress_callback(
+                    {
+                        "step": "global payloads",
+                        "completed": 0,
+                        "total": len(processes) + 2,
+                    }
+                )
+            _write_global_payloads(
+                builder,
+                compiled_model=compiled_model,
+                requested_bytes=requested_bytes,
+                effective_bytes=effective_bytes,
+            )
+        retain_recurrence_templates = (
+            RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY in required_runtime_capabilities
+            or ON_THE_FLY_RUNTIME_CAPABILITY in required_runtime_capabilities
+            or RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY
+            in required_runtime_capabilities
+        )
+        eager_kernel_ids = _prepared_kernel_ids(
+            output,
+            existing,
+            compiled_model=compiled_model,
+            processes=processes,
+            retain_recurrence_templates=retain_recurrence_templates,
+        )
+        if eager_kernel_ids:
+            if progress_callback is not None:
+                progress_callback(
+                    {
+                        "step": "prepared kernel pack",
+                        "completed": 1,
+                        "total": len(processes) + 2,
+                        "kernel_count": len(eager_kernel_ids),
+                    }
+                )
+            _write_eager_kernel_pack(
+                builder,
+                compiled_model,
+                kernel_ids=eager_kernel_ids,
+                evaluator_payloads=evaluator_payloads,
+                require_eager_direct=(
+                    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY
+                    in required_runtime_capabilities
+                    or ON_THE_FLY_RUNTIME_CAPABILITY in required_runtime_capabilities
+                    or RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY
+                    in required_runtime_capabilities
+                ),
+                retain_recurrence_templates=retain_recurrence_templates,
+            )
+        for process_index, process in enumerate(processes, start=1):
+            if progress_callback is not None:
+                progress_callback(
+                    {
+                        "step": "process payloads",
+                        "completed": process_index,
+                        "total": len(processes) + 2,
+                        "process": process.process_id,
+                    }
+                )
+            record, evaluator_entry, execution_sha256 = _write_process_payloads(
+                builder,
+                process,
+                evaluator_payloads=evaluator_payloads,
+                recurrence_sharing=recurrence_sharing_plan,
+            )
+            process_records.append(record)
+            evaluator_entries.append(evaluator_entry)
+            execution_manifest_sha256_by_process[process.process_id] = execution_sha256
+        builder.add_json(
+            _EVALUATOR_SET_PATH,
+            {
+                "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+                "kind": "pyamplicol-runtime-execution-set",
+                "required_runtime_capabilities": list(canonical_runtime_capabilities),
+                "processes": evaluator_entries,
+            },
+            role="evaluator-manifest",
+        )
+        if bundle_requested and hook is not None:
+            api_bundle_path = _call_api_bundle_hook(builder, hook, bundle_points)
+        evaluator_payload_container = evaluator_payloads.publish()
+        source_revision = producer.get("git_revision")
+        native_build_inputs_sha256 = producer.get("native_build_inputs_sha256")
+        evaluator_container_path = (
+            None
+            if evaluator_payload_container is None
+            else str(evaluator_payload_container["path"])
+        )
+        evaluator_container_index_sha256 = (
+            None
+            if evaluator_payload_container is None
+            else str(evaluator_payload_container["index_sha256"])
+        )
+        if isinstance(source_revision, str) and isinstance(
+            native_build_inputs_sha256, str
+        ):
+            staged_root = builder.root
+            if staged_root is None:  # pragma: no cover - builder invariant
+                raise RuntimeError("artifact builder is not active")
+            for process_record in process_records:
+                process_id = str(process_record["id"])
+                execution_path = f"processes/{process_id}/execution.json"
+                execution_file = builder.staged_path(execution_path)
+                execution_payload = json.loads(
+                    execution_file.read_text(encoding="utf-8")
+                )
+                if not isinstance(execution_payload, Mapping):
+                    raise ValueError(
+                        f"execution payload for {process_id!r} is not an object"
+                    )
+                if execution_payload.get("kind") == ON_THE_FLY_RUNTIME_KIND:
+                    continue
+                proof = build_generation_structural_proof(
+                    artifact_root=staged_root,
+                    process_id=process_id,
+                    source_revision=source_revision,
+                    native_build_inputs_sha256=native_build_inputs_sha256,
+                    execution_path=execution_path,
+                    execution_sha256=sha256_file(execution_file),
+                    execution=execution_payload,
+                    evaluator_container_path=evaluator_container_path,
+                    evaluator_container_index_sha256=(evaluator_container_index_sha256),
+                )
+                builder.add_json(
+                    f"processes/{process_id}/structural-source-proof.json",
+                    proof,
+                    role=STRUCTURAL_SOURCE_PROOF_ROLE,
+                    process_id=process_id,
+                    compact=True,
+                )
+        _write_recurrence_bootstraps(
+            builder,
+            processes=recurrence_processes,
+            process_records=process_records,
+            producer=producer,
+            runtime={
+                "engine": "rusticol",
+                "engine_version": str(producer["version"]),
+                "evaluator_manifest_path": _EVALUATOR_SET_PATH,
+                "api_bundle_path": api_bundle_path,
+                "required_runtime_capabilities": list(canonical_runtime_capabilities),
+            },
+            evaluator_payload_container=evaluator_payload_container,
+            target=target,
+        )
+        # Written after the recurrence bootstrap froze its payload inventory:
+        # the map is rewritten in place later and is not part of that image.
+        group_map = _write_process_groups(
+            builder,
+            process_groups=process_groups,
+            process_records=process_records,
+        )
+        extensions = _extensions(
+            existing,
+            processes=processes,
+            timings=timings,
+            api_bundle_requested=bundle_requested,
+            api_bundle_path=api_bundle_path,
+            eager_pack_identity=eager_pack_identity,
+            execution_manifest_sha256_by_process=(execution_manifest_sha256_by_process),
+            evaluator_payload_container=evaluator_payload_container,
+            recurrence_schedule_sharing=recurrence_sharing_extension,
+        )
+        if payload_hook is not None:
+            extensions.update(payload_hook(builder))
+        if bundle_requested and hook is not None:
+            _write_umami_bundle(
+                builder,
+                processes=processes,
+                process_records=process_records,
+                compiled_model=compiled_model,
+                process_groups=group_map,
+            )
+        builder.finalize(
+            kind=(
+                "pyamplicol-process"
+                if len(process_records) == 1
+                else "pyamplicol-process-set"
+            ),
+            producer=producer,
+            model=model,
+            configuration={
+                "toml_schema_version": 1,
+                "requested_path": _CONFIG_REQUESTED_PATH,
+                "effective_path": _CONFIG_EFFECTIVE_PATH,
+                "adjustments": adjustments,
+            },
+            processes=process_records,
+            default_process_id=str(process_records[0]["id"]),
+            runtime={
+                "engine": "rusticol",
+                "engine_version": str(producer["version"]),
+                "evaluator_manifest_path": _EVALUATOR_SET_PATH,
+                "api_bundle_path": api_bundle_path,
+                "required_runtime_capabilities": list(canonical_runtime_capabilities),
+            },
+            dependencies=dependencies,
+            extensions=extensions,
+        )
+        staged = load_manifest(builder.root)
+        _validate_artifact_references(staged)
+        if progress_callback is not None:
+            progress_callback(
+                {
+                    "step": "publishing artifact",
+                    "completed": len(processes) + 2,
+                    "total": len(processes) + 2,
+                    "file_count": len(staged.payloads) + 1,
+                }
+            )
+
+    manifest = load_manifest(output)
+    _validate_artifact_references(manifest)
+    files = tuple(
+        [output / record.path for record in manifest.payloads]
+        + [output / "artifact.json"]
+    )
+    return ArtifactWriteResult(
+        output=output,
+        files=files,
+        validation_points=validations,
+        api_bundle_path=api_bundle_path,
+    )
+
+
+def _write_process_groups(
+    builder: ArtifactBuilder,
+    *,
+    process_groups: ProcessGroupMap | None,
+    process_records: Sequence[Mapping[str, object]],
+) -> ProcessGroupMap:
+    """Stage ``process-groups.json`` covering every process of the artifact.
+
+    An append keeps the stored groups, and a newly generated process leaves a
+    group in which it was only an assumed member. Processes without a recorded
+    group map to themselves.
+    """
+
+    stored = builder.staged_path(PROCESS_GROUPS_PATH)
+    group_map = (
+        ProcessGroupMap.from_json(stored.read_text(encoding="utf-8"))
+        if stored.is_file()
+        else ProcessGroupMap()
+    )
+    record_ids = [str(record["id"]) for record in process_records]
+    new_ids = set(record_ids).difference(
+        member.process_id for member in group_map.members() if member.generated
+    )
+    for group in group_map.groups.values():
+        group.members = [
+            member
+            for member in group.members
+            if member.generated or member.process_id not in new_ids
+        ]
+    if process_groups is not None:
+        for group in process_groups.groups.values():
+            group_map.add_group(
+                [
+                    member
+                    for member in group.members
+                    if member.generated or group_map.group_of(member.process_id) is None
+                ]
+            )
+        group_map.analyses.extend(process_groups.analyses)
+    grouped = {member.process_id for member in group_map.members()}
+    ungrouped = initial_process_groups(
+        (
+            str(record["id"]),
+            str(record["expression"]),
+            cast(Sequence[int], record["external_pdgs"]),
+        )
+        for record in process_records
+        if str(record["id"]) not in grouped
+    )
+    for group in ungrouped.groups.values():
+        group_map.add_group(group.members)
+    validate_process_groups(group_map, record_ids)
+    builder.add_bytes(
+        PROCESS_GROUPS_PATH,
+        process_groups_payload(group_map),
+        role=PROCESS_GROUPS_ROLE,
+        media_type=PROCESS_GROUPS_MEDIA_TYPE,
+    )
+    return group_map
+
+
+def _write_global_payloads(
+    builder: ArtifactBuilder,
+    *,
+    compiled_model: CompiledModel,
+    requested_bytes: bytes,
+    effective_bytes: bytes,
+) -> None:
+    builder.add_bytes(
+        _CONFIG_REQUESTED_PATH,
+        requested_bytes,
+        role="configuration-requested",
+        media_type="application/toml",
+    )
+    builder.add_bytes(
+        _CONFIG_EFFECTIVE_PATH,
+        effective_bytes,
+        role="configuration-effective",
+        media_type="application/toml",
+    )
+    builder.add_json(
+        _COMPILED_MODEL_PATH,
+        compiled_model.to_dict(),
+        role="compiled-model",
+    )
+    builder.add_json(
+        _MODEL_PARAMETERS_PATH,
+        {
+            "schema_version": 1,
+            "kind": "pyamplicol-model-parameter-defaults",
+            "parameters": {
+                name: [float(value[0]), float(value[1])]
+                for name, value in sorted(compiled_model.parameter_defaults.items())
+            },
+        },
+        role="model-parameters",
+    )
+
+
+def _write_eager_kernel_pack(
+    builder: ArtifactBuilder,
+    compiled_model: CompiledModel,
+    *,
+    kernel_ids: frozenset[int],
+    evaluator_payloads: _EvaluatorPayloadCollector,
+    require_eager_direct: bool,
+    retain_recurrence_templates: bool,
+) -> None:
+    bundle = compiled_model.prepared_bundle
+    if bundle is None:
+        raise ValueError(
+            "prepared-kernel artifact writing requires a prepared model bundle"
+        )
+    selected = tuple(
+        kernel
+        for kernel in bundle.kernel_pack.kernels
+        if kernel.kernel_id in kernel_ids
+    )
+    if {kernel.kernel_id for kernel in selected} != set(kernel_ids):
+        missing = sorted(set(kernel_ids) - {kernel.kernel_id for kernel in selected})
+        raise ValueError(f"prepared model omits referenced eager kernels {missing}")
+    selected_variants = tuple(
+        variant
+        for variant in bundle.kernel_pack.kernel_variants
+        if variant.base_kernel_id in kernel_ids
+    )
+    builder.discard_payloads(_EAGER_KERNEL_PACK_PATH)
+    builder.discard_payloads(_EAGER_KERNEL_PAYLOAD_ROOT, recursive=True)
+    evaluator_payloads.discard_prefix(_EAGER_KERNEL_PAYLOAD_ROOT)
+    pack_payload = bundle.kernel_pack.to_dict()
+    pack_payload["eager_kernel_abi"] = EAGER_KERNEL_ABI
+    if not retain_recurrence_templates:
+        # Process artifacts retain only the prepared kernels they execute.  A
+        # model-wide recurrence catalog references kernels outside that
+        # process-local inventory and therefore cannot remain a valid member
+        # of an eager-only kernel pack.  Eager exact execution uses the
+        # prepared kernel records and resolver manifest, not recurrence
+        # templates.
+        pack_payload["recurrence_template"] = None
+        pack_payload["recurrence_direct_template"] = None
+    direct_descriptors: dict[str, bytes] = {}
+    kernel_payloads: list[dict[str, object]] = []
+    for kernel in selected:
+        payload = kernel.to_dict()
+        if require_eager_direct and _requires_eager_direct_table(kernel.contract_kind):
+            manifest = _mapping(payload["f64_evaluator_manifest"])
+            if bundle.kernel_pack.backend == "jit":
+                direct_manifest, descriptor_path, descriptor = (
+                    _eager_direct_evaluator_manifest(
+                        bundle=bundle,
+                        kernel_id=kernel.kernel_id,
+                        input_complex_count=kernel.input_arity,
+                        output_complex_count=kernel.output_arity,
+                        manifest=manifest,
+                    )
+                )
+                direct_descriptors[descriptor_path] = descriptor
+            else:
+                direct_manifest = _eager_native_direct_evaluator_manifest(
+                    backend=bundle.kernel_pack.backend,
+                    bundle=bundle,
+                    kernel_id=kernel.kernel_id,
+                    input_complex_count=kernel.input_arity,
+                    output_complex_count=kernel.output_arity,
+                    manifest=manifest,
+                )
+            payload["f64_evaluator_manifest"] = direct_manifest
+        kernel_payloads.append(payload)
+    pack_payload["kernels"] = kernel_payloads
+    pack_payload["kernel_variants"] = [
+        variant.to_dict() for variant in selected_variants
+    ]
+    pack_payload["resolver_manifest"] = _filtered_eager_resolver_manifest(
+        bundle.kernel_pack.resolver_manifest,
+        kernel_ids,
+    )
+    from ..models.prepared import PreparedKernelPack
+
+    validated_pack_payload = dict(pack_payload)
+    validated_pack_payload.pop("eager_kernel_abi")
+    PreparedKernelPack.from_dict(validated_pack_payload)
+    builder.add_json(
+        _EAGER_KERNEL_PACK_PATH,
+        pack_payload,
+        role="evaluator-manifest",
+        compact=True,
+    )
+    for descriptor_path, descriptor in sorted(direct_descriptors.items()):
+        evaluator_payloads.add_bytes(
+            f"{_EAGER_KERNEL_PAYLOAD_ROOT}/{descriptor_path}",
+            descriptor,
+            process_id=None,
+            media_type="application/octet-stream",
+        )
+    referenced_payloads = {
+        path
+        for record in (*selected, *selected_variants)
+        for path in record.referenced_payload_paths
+    }
+    with zipfile.ZipFile(bundle.path, "r") as archive:
+        for member_path in sorted(referenced_payloads):
+            with archive.open(member_path, "r") as stream:
+                evaluator_payloads.add_stream(
+                    f"{_EAGER_KERNEL_PAYLOAD_ROOT}/{member_path}",
+                    cast("BinaryIO", stream),
+                    process_id=None,
+                    media_type=_media_type(Path(member_path)),
+                )
+
+
+def _requires_eager_direct_table(contract_kind: str) -> bool:
+    """Return whether a prepared kernel executes inside the eager point loop."""
+
+    # Model-parameter derivation is evaluated separately when the artifact is
+    # loaded or an override is applied.  It remains on the ordinary evaluator
+    # path, which supports scalar operations such as square roots that are
+    # deliberately outside the call-free eager DirectTable ABI.
+    return contract_kind != "model-parameter"
+
+
+def _eager_direct_evaluator_manifest(
+    *,
+    bundle: object,
+    kernel_id: int,
+    input_complex_count: int,
+    output_complex_count: int,
+    manifest: Mapping[str, object],
+) -> tuple[dict[str, object], str, bytes]:
+    if manifest.get("kind") != "symjit-application-evaluator":
+        raise ValueError(
+            f"eager-direct-arena-v1 kernel {kernel_id} is not a SymJIT application"
+        )
+    plane_application = manifest.get("plane_application")
+    if not isinstance(plane_application, Mapping):
+        raise ValueError(
+            f"eager-direct-arena-v1 kernel {kernel_id} predates the "
+            "SymJIT plane-application ABI; regenerate the prepared model"
+        )
+    application_path = plane_application.get("application_path")
+    if not isinstance(application_path, str) or not application_path:
+        raise ValueError(
+            f"eager-direct-arena-v1 kernel {kernel_id} has no plane application"
+        )
+    if (
+        plane_application.get("application_abi") != SYMJIT_PLANE_APPLICATION_ABI
+        or plane_application.get("storage_abi") != SYMJIT_APPLICATION_ABI
+        or plane_application.get("input_complex_count") != input_complex_count
+        or plane_application.get("output_complex_count") != output_complex_count
+    ):
+        raise ValueError(
+            f"eager-direct-arena-v1 kernel {kernel_id} has an incompatible "
+            "plane-application contract"
+        )
+    reader = getattr(bundle, "read_payload", None)
+    if not callable(reader):  # pragma: no cover - internal type invariant
+        raise TypeError("prepared model bundle cannot read evaluator payloads")
+    source = reader(application_path)
+    if not isinstance(source, bytes):  # pragma: no cover - bundle invariant
+        raise TypeError("prepared model bundle returned a non-byte evaluator payload")
+    started = time.perf_counter()
+    descriptor = _derive_eager_direct_descriptor(
+        source,
+        input_complex_count=input_complex_count,
+        output_complex_count=output_complex_count,
+    )
+    descriptor_s = time.perf_counter() - started
+    descriptor_path = f"kernels/{kernel_id}/eager-direct-table-descriptor-v1.bin"
+    result = _plain_mapping(manifest)
+    timing = _plain_mapping(_mapping(result.get("build_timing", {})))
+    timing["eager_direct_descriptor_s"] = descriptor_s
+    result["build_timing"] = timing
+    result["direct_table"] = {
+        "capability": EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        "source_application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+        "descriptor_abi": EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+        "binding_abi": EAGER_DIRECT_TABLE_BINDING_ABI,
+        "descriptor_path": descriptor_path,
+        "descriptor_size_bytes": len(descriptor),
+        "descriptor_sha256": hashlib.sha256(descriptor).hexdigest(),
+        "input_complex_count": input_complex_count,
+        "output_complex_count": output_complex_count,
+    }
+    return result, descriptor_path, descriptor
+
+
+def _eager_native_direct_evaluator_manifest(
+    *,
+    backend: str,
+    bundle: object,
+    kernel_id: int,
+    input_complex_count: int,
+    output_complex_count: int,
+    manifest: Mapping[str, object],
+) -> dict[str, object]:
+    del bundle
+    if backend not in {"cpp", "asm"}:
+        raise ValueError(f"unsupported eager native DirectTable backend {backend!r}")
+    if manifest.get("kind") != "compiled-complex-evaluator":
+        raise ValueError(
+            f"eager-direct-arena-v1 kernel {kernel_id} is not a native "
+            "compiled evaluator"
+        )
+    expected_capability = {
+        "cpp": SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+        "asm": SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    }[backend]
+    if manifest.get("runtime_capability") != expected_capability:
+        raise ValueError(
+            f"eager-direct-arena-v1 kernel {kernel_id} native capability "
+            "does not match its prepared backend"
+        )
+    direct = _mapping(manifest.get("direct_table"))
+    from .._internal.versions import (
+        NATIVE_EAGER_DIRECT_TABLE_APPLICATION_ABI,
+    )
+
+    expected = {
+        "capability": EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        "source_application_abi": (NATIVE_EAGER_DIRECT_TABLE_APPLICATION_ABI),
+        "descriptor_abi": EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+        "binding_abi": EAGER_DIRECT_TABLE_BINDING_ABI,
+    }
+    for field, value in expected.items():
+        if direct.get(field) != value:
+            raise ValueError(
+                f"eager-direct-arena-v1 kernel {kernel_id} native "
+                f"DirectTable {field} is incompatible"
+            )
+    library_path = direct.get("library_path")
+    function_name = direct.get("function_name")
+    if (
+        not isinstance(library_path, str)
+        or not library_path
+        or library_path != manifest.get("library_path")
+        or not isinstance(function_name, str)
+        or not function_name
+    ):
+        raise ValueError(
+            f"eager-direct-arena-v1 kernel {kernel_id} native DirectTable "
+            "library binding is invalid"
+        )
+    if (
+        direct.get("input_complex_count") != input_complex_count
+        or direct.get("output_complex_count") != output_complex_count
+    ):
+        raise ValueError(
+            f"eager-direct-arena-v1 kernel {kernel_id} native DirectTable "
+            "width is incompatible"
+        )
+    return _plain_mapping(manifest)
+
+
+def _derive_eager_direct_descriptor(
+    source_application: bytes,
+    *,
+    input_complex_count: int,
+    output_complex_count: int,
+) -> bytes:
+    operation = _eager_direct_descriptor_operation()
+    descriptor = operation(
+        source_application,
+        input_complex_count,
+        output_complex_count,
+    )
+    if not isinstance(descriptor, bytes) or not descriptor:
+        raise RuntimeError("Rusticol returned an invalid eager DirectTable descriptor")
+    return descriptor
+
+
+@cache
+def _eager_direct_descriptor_operation() -> Callable[[bytes, int, int], bytes]:
+    try:
+        rusticol = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(rusticol)
+    except (ImportError, OSError, RuntimeError) as exc:
+        raise RuntimeError(
+            "eager-direct-arena-v1 descriptor generation requires the current "
+            "pyamplicol native extension"
+        ) from exc
+    operation = getattr(rusticol, "_eager_direct_descriptor_v1", None)
+    if not callable(operation):
+        raise RuntimeError(
+            "the current pyamplicol native extension does not expose "
+            "_eager_direct_descriptor_v1; rebuild it before generating artifacts"
+        )
+    return operation
+
+
+def _prepared_kernel_ids(
+    output: Path,
+    existing: ArtifactManifest | None,
+    *,
+    compiled_model: CompiledModel,
+    processes: Sequence[ProcessArtifact],
+    retain_recurrence_templates: bool,
+) -> frozenset[int]:
+    has_prepared_process = any(
+        _is_prepared_kernel_process(process) for process in processes
+    )
+    kernel_ids = {
+        kernel_id
+        for process in processes
+        if _is_prepared_kernel_process(process)
+        for kernel_id in _prepared_referenced_kernel_ids(process)
+    }
+    has_existing_pack = (
+        existing is not None and (output / _EAGER_KERNEL_PACK_PATH).is_file()
+    )
+    if has_existing_pack:
+        try:
+            prior = json.loads(
+                (output / _EAGER_KERNEL_PACK_PATH).read_text(encoding="utf-8")
+            )
+            kernel_ids.update(
+                int(_mapping(item)["kernel_id"])
+                for item in _sequence(_mapping(prior)["kernels"])
+            )
+        except (KeyError, OSError, TypeError, ValueError, json.JSONDecodeError) as exc:
+            raise ValueError(
+                "existing eager kernel pack is malformed; replace the artifact"
+            ) from exc
+    if has_prepared_process or has_existing_pack:
+        bundle = compiled_model.prepared_bundle
+        if bundle is None:
+            raise ValueError(
+                "prepared-kernel artifact writing requires a prepared model bundle"
+            )
+        parameter_kernel_id = bundle.kernel_pack.resolver_manifest.get(
+            "model_parameter_kernel_id"
+        )
+        if parameter_kernel_id is not None:
+            kernel_ids.add(int(parameter_kernel_id))
+        if retain_recurrence_templates:
+            # The authenticated recurrence companions are model-wide rather
+            # than process-local.  Retaining them therefore requires their
+            # complete prepared-kernel inventory, including bindings that a
+            # particular process schedule does not happen to exercise.
+            kernel_ids.update(kernel.kernel_id for kernel in bundle.kernel_pack.kernels)
+    return frozenset(kernel_ids)
+
+
+def _eager_prepared_pack_identity(
+    existing: ArtifactManifest | None,
+    *,
+    compiled_model: CompiledModel,
+    processes: Sequence[ProcessArtifact],
+) -> dict[str, object] | None:
+    existing_uses_eager = existing is not None and (
+        bool(
+            {
+                EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+                EAGER_RUNTIME_CAPABILITY,
+                EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+                RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+                RECURRENCE_COLOR_RUNTIME_CAPABILITY,
+                ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+                ON_THE_FLY_RUNTIME_CAPABILITY,
+                ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+                RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+            }.intersection(_required_runtime_capabilities(existing.runtime))
+        )
+        or any(record.path == _EAGER_KERNEL_PACK_PATH for record in existing.payloads)
+    )
+    incoming_uses_eager = any(
+        _is_prepared_kernel_process(process) for process in processes
+    )
+    if not existing_uses_eager and not incoming_uses_eager:
+        return None
+    bundle = compiled_model.prepared_bundle
+    if bundle is None:
+        raise ValueError(
+            "prepared-kernel artifact writing requires a prepared model bundle"
+        )
+    return {
+        "kind": _EAGER_PACK_IDENTITY_KIND,
+        "schema_version": _EAGER_PACK_IDENTITY_SCHEMA_VERSION,
+        "abi": PREPARED_KERNEL_PACK_IDENTITY_ABI,
+        "eager_kernel_abi": EAGER_KERNEL_ABI,
+        "identity_sha256": prepared_kernel_pack_manifest_identity_sha256(
+            bundle.manifest
+        ),
+        "backend": bundle.kernel_pack.backend,
+        "kernel_count": len(bundle.kernel_pack.kernels),
+    }
+
+
+def _is_prepared_kernel_process(process: ProcessArtifact) -> bool:
+    return isinstance(
+        process,
+        EagerPlanV3ProcessArtifact
+        | RecurrenceProcessArtifact
+        | OnTheFlyProcessArtifact,
+    )
+
+
+def _prepared_referenced_kernel_ids(
+    process: ProcessArtifact,
+) -> frozenset[int]:
+    if isinstance(process, RecurrenceProcessArtifact):
+        return process.referenced_kernel_ids
+    if isinstance(process, EagerPlanV3ProcessArtifact):
+        return process.referenced_kernel_ids
+    if isinstance(process, OnTheFlyProcessArtifact):
+        return process.referenced_kernel_ids
+    raise TypeError("compiled process has no prepared-kernel references")
+
+
+def _filtered_eager_resolver_manifest(
+    manifest: Mapping[str, object],
+    kernel_ids: frozenset[int],
+) -> dict[str, object]:
+    result = _plain_mapping(manifest)
+    for field in (
+        "vertex_bindings",
+        "propagator_bindings",
+        "closure_bindings",
+    ):
+        if field not in manifest:
+            continue
+        result[field] = [
+            _plain_mapping(record)
+            for item in _sequence(manifest[field])
+            if (record := _mapping(item)).get("kernel_id") is None
+            or int(record["kernel_id"]) in kernel_ids
+        ]
+    parameter_kernel_id = manifest.get("model_parameter_kernel_id")
+    if parameter_kernel_id is not None and int(parameter_kernel_id) not in kernel_ids:
+        result["model_parameter_kernel_id"] = None
+    return result
+
+
+def _write_process_payloads(
+    builder: ArtifactBuilder,
+    process: ProcessArtifact,
+    *,
+    evaluator_payloads: _EvaluatorPayloadCollector,
+    recurrence_sharing: RecurrenceScheduleSharingPlan | None = None,
+) -> tuple[
+    dict[str, object],
+    dict[str, object],
+    str,
+]:
+    prefix = f"processes/{process.process_id}"
+    physics_path = f"{prefix}/physics.json"
+    execution_path = f"{prefix}/execution.json"
+    validation_path = f"{prefix}/validation-momenta.json"
+    schema: Mapping[str, object]
+    if isinstance(
+        process,
+        EagerPlanV3ProcessArtifact
+        | RecurrenceProcessArtifact
+        | OnTheFlyProcessArtifact,
+    ):
+        schema = {}
+        physics = _mapping(process.physics)
+    else:
+        schema = _runtime_schema_mapping(process.runtime_schema)
+        physics = _mapping(schema.get("physics"))
+    if physics.get("process_id") != process.process_id:
+        raise ValueError(
+            f"runtime physics process ID does not match {process.process_id!r}"
+        )
+    if isinstance(process, OnTheFlyProcessArtifact):
+        if (
+            physics.get("schema_version") != 1
+            or physics.get("kind") != ON_THE_FLY_PUBLIC_METADATA_KIND
+            or process.color_accuracy not in {"lc", "nlc", "full"}
+            or physics.get("color_accuracy") != process.color_accuracy
+        ):
+            raise ValueError(
+                "on-the-fly generation returned incompatible compact public metadata"
+            )
+    elif isinstance(
+        process, EagerPlanV3ProcessArtifact | RecurrenceProcessArtifact
+    ) and (
+        physics.get("schema_version") != RUNTIME_PHYSICS_SCHEMA_VERSION
+        or physics.get("kind") != "pyamplicol-resolved-physics"
+    ):
+        raise ValueError(
+            "Rust prepared lowering returned incompatible physics metadata"
+        )
+    builder.add_json(
+        physics_path,
+        physics,
+        role="runtime-physics",
+        process_id=process.process_id,
+        compact=True,
+    )
+    if isinstance(process, EagerPlanV3ProcessArtifact):
+        runtime_path = f"{prefix}/{_EAGER_RUNTIME_CONTAINER_PATH}"
+        runtime_record = evaluator_payloads.add_file(
+            runtime_path,
+            process.eager_runtime_path,
+            process_id=process.process_id,
+        )
+        _validate_staged_eager_runtime(process, runtime_record)
+        execution_record = builder.add_bytes(
+            execution_path,
+            _eager_execution_summary(process),
+            role="evaluator-manifest",
+            media_type="application/json",
+            process_id=process.process_id,
+        )
+    elif isinstance(process, RecurrenceProcessArtifact):
+        if recurrence_sharing is None:
+            raise ValueError(
+                "recurrence artifacts require root schedule and process-binding "
+                "publication"
+            )
+        binding = recurrence_sharing.binding(process.process_id)
+        schedule = recurrence_sharing.schedule(binding.schedule_digest)
+        binding_record = evaluator_payloads.add_bytes(
+            binding.artifact_path,
+            binding.payload,
+            process_id=process.process_id,
+        )
+        if binding_record.sha256 != binding.sha256 or binding_record.size_bytes != len(
+            binding.payload
+        ):
+            raise ValueError(
+                f"recurrence process binding {process.process_id!r} changed "
+                "during publication"
+            )
+        color_contraction_record = None
+        if process.color_contraction_payload is not None:
+            if process.color_contraction_summary is None:
+                raise ValueError(
+                    "recurrence color-contraction payload has no bounded summary"
+                )
+            color_contraction_record = evaluator_payloads.add_bytes(
+                f"{prefix}/{_RECURRENCE_COLOR_CONTRACTION_PATH}",
+                process.color_contraction_payload,
+                process_id=process.process_id,
+                media_type="application/octet-stream",
+            )
+        elif process.color_contraction_summary is not None:
+            raise ValueError(
+                "recurrence color-contraction summary has no binary payload"
+            )
+        companion_binding = None
+        companion = process.helicity_selector_companion
+        if isinstance(companion, RecurrenceHelicitySelectorPlanArtifact):
+            if process.color_accuracy not in {"nlc", "full"}:
+                raise ValueError(
+                    "persisted recurrence helicity-selector plan requires NLC/full"
+                )
+            companion_binding_record = RecurrenceProcessBinding(
+                process_id=process.process_id,
+                schedule_digest=companion.recurrence_schedule_digest,
+                native_schedule_semantic_digest=(
+                    companion.recurrence_native_schedule_semantic_digest
+                ),
+                process_digest=process.process_digest,
+                process_semantic_digest=companion.builder_input_sha256,
+                process_support_mask=process.process_support_mask,
+                remap=companion.recurrence_process_remap,
+                executor_pack=companion.recurrence_process_executor_pack,
+            )
+            stored_binding = evaluator_payloads.add_bytes(
+                f"{prefix}/{_RECURRENCE_HELICITY_SELECTOR_BINDING_PATH}",
+                companion_binding_record.payload,
+                process_id=process.process_id,
+            )
+            if (
+                stored_binding.sha256 != companion_binding_record.sha256
+                or stored_binding.size_bytes != len(companion_binding_record.payload)
+            ):
+                raise ValueError(
+                    "recurrence helicity-selector process binding changed during "
+                    "publication"
+                )
+            companion_binding = {
+                **companion_binding_record.to_mapping(),
+                "path": _RECURRENCE_HELICITY_SELECTOR_BINDING_PATH,
+            }
+        elif companion is not None:  # pragma: no cover - dataclass typing guard
+            raise TypeError(
+                "recurrence helicity-selector companion must be a persisted Direct plan"
+            )
+        execution_record = builder.add_bytes(
+            execution_path,
+            _bounded_recurrence_execution_summary(
+                process,
+                schedule_path=schedule.artifact_path,
+                binding=binding.to_mapping(),
+                color_contraction_record=color_contraction_record,
+                companion_binding=companion_binding,
+            ),
+            role="evaluator-manifest",
+            media_type="application/json",
+            process_id=process.process_id,
+        )
+    elif isinstance(process, OnTheFlyProcessArtifact):
+        runtime_path = f"{prefix}/{_ON_THE_FLY_RUNTIME_CONTAINER_PATH}"
+        runtime_record = evaluator_payloads.add_file(
+            runtime_path,
+            process.runtime_path,
+            process_id=process.process_id,
+        )
+        _validate_staged_on_the_fly_runtime(process, runtime_record)
+        color_contraction_record = None
+        if process.color_contraction_payload is not None:
+            if process.color_contraction_summary is None:
+                raise ValueError(
+                    "on-the-fly color-contraction payload has no bounded summary"
+                )
+            color_contraction_record = evaluator_payloads.add_bytes(
+                f"{prefix}/{_ON_THE_FLY_COLOR_CONTRACTION_PATH}",
+                process.color_contraction_payload,
+                process_id=process.process_id,
+                media_type="application/octet-stream",
+            )
+        elif process.color_contraction_summary is not None:
+            raise ValueError(
+                "on-the-fly color-contraction summary has no binary payload"
+            )
+        execution_record = builder.add_bytes(
+            execution_path,
+            _on_the_fly_execution_summary(
+                process,
+                color_contraction_record=color_contraction_record,
+            ),
+            role="evaluator-manifest",
+            media_type="application/json",
+            process_id=process.process_id,
+        )
+    elif isinstance(process, CompiledProcessArtifact):
+        color_contraction_payload_path = None
+        if process.color_contraction_payload is not None:
+            color_contraction_payload_path = _COMPILED_COLOR_CONTRACTION_MEMBER_PATH
+            evaluator_payloads.add_bytes(
+                f"{prefix}/{color_contraction_payload_path}",
+                process.color_contraction_payload,
+                process_id=process.process_id,
+                media_type="application/octet-stream",
+            )
+        execution_record = builder.add_json(
+            execution_path,
+            _execution_manifest(
+                process,
+                schema,
+                color_contraction_payload_path=color_contraction_payload_path,
+            ),
+            role="evaluator-manifest",
+            process_id=process.process_id,
+            compact=True,
+        )
+    else:  # pragma: no cover - exhaustive ProcessArtifact union
+        raise TypeError(f"unsupported process artifact {type(process).__name__}")
+    builder.add_json(
+        validation_path,
+        process.validation_point.to_mapping(),
+        role="validation-momenta",
+        process_id=process.process_id,
+    )
+    if isinstance(process, CompiledProcessArtifact):
+        _copy_evaluator_payloads(
+            evaluator_payloads,
+            process.evaluator_root,
+            prefix=prefix,
+            process_id=process.process_id,
+        )
+        _copy_color_selector_evaluator_payloads(
+            evaluator_payloads,
+            process.color_selector_executions,
+            prefix=prefix,
+            process_id=process.process_id,
+        )
+        if process.helicity_sum_execution is not None:
+            _copy_evaluator_payloads(
+                evaluator_payloads,
+                process.helicity_sum_execution.evaluator_root,
+                prefix=f"{prefix}/{_HELICITY_SUM_PAYLOAD_ROOT}",
+                process_id=process.process_id,
+            )
+            _copy_color_selector_evaluator_payloads(
+                evaluator_payloads,
+                process.helicity_sum_execution.color_selector_executions,
+                prefix=f"{prefix}/{_HELICITY_SUM_PAYLOAD_ROOT}",
+                process_id=process.process_id,
+            )
+        _copy_helicity_selector_evaluator_payloads(
+            evaluator_payloads,
+            process.helicity_selector_executions,
+            prefix=prefix,
+            process_id=process.process_id,
+        )
+    return (
+        {
+            "id": process.process_id,
+            "expression": process.expression,
+            "color_accuracy": process.color_accuracy,
+            "external_pdgs": list(process.external_pdgs),
+            "physics_path": physics_path,
+            "required_runtime_capabilities": list(
+                _process_runtime_capabilities(process)
+            ),
+            "aliases": [dict(alias) for alias in process.aliases],
+        },
+        {
+            "process_id": process.process_id,
+            "manifest_path": f"{process.process_id}/execution.json",
+            "required_runtime_capabilities": list(
+                _process_runtime_capabilities(process)
+            ),
+        },
+        execution_record.sha256,
+    )
+
+
+def _write_recurrence_bootstraps(
+    builder: ArtifactBuilder,
+    *,
+    processes: Sequence[RecurrenceProcessArtifact],
+    process_records: Sequence[Mapping[str, object]],
+    producer: Mapping[str, object],
+    runtime: Mapping[str, object],
+    evaluator_payload_container: Mapping[str, object] | None,
+    target: Mapping[str, object],
+) -> None:
+    """Publish authenticated native recurrence load images.
+
+    This v1 image is deliberately emitted only for a single-process artifact:
+    multiple self-authenticating sidecars would create a cross-hash cycle, and
+    mixed process sets can have artifact-wide capabilities not owned by this
+    recurrence process. Such artifacts retain the generic loader.
+
+    The image contains a process-ready recipe referencing the authoritative
+    schedule/binding payloads, compact physics, and the staged payload
+    inventory *before* the image is added. Finalization then includes the
+    image's own SHA-256 record in the ordinary artifact ID. The private staging
+    root is supplied only while Rust lowers the recipe and is never serialized.
+    """
+
+    if not processes:
+        return
+    if len(processes) != 1 or len(process_records) != 1:
+        return
+    if evaluator_payload_container is None:
+        raise ValueError("recurrence bootstrap requires an evaluator payload container")
+    records_by_id = {str(record["id"]): record for record in process_records}
+    payloads = [record.as_dict() for record in builder.payload_records()]
+    if builder.root is None:
+        raise RuntimeError("recurrence bootstrap requires an active artifact builder")
+    build = _recurrence_bootstrap_operation()
+    for process in processes:
+        process_id = process.process_id
+        prefix = f"processes/{process_id}"
+        execution_path = f"{prefix}/execution.json"
+        physics_path = f"{prefix}/physics.json"
+        context = {
+            "schema_version": 1,
+            "staged_root": str(builder.root),
+            "producer": dict(producer),
+            "runtime": dict(runtime),
+            "process": dict(records_by_id[process_id]),
+            "payloads": payloads,
+            "evaluator_payload_container": dict(evaluator_payload_container),
+        }
+        image = build(
+            json.dumps(
+                context,
+                sort_keys=True,
+                separators=(",", ":"),
+                allow_nan=False,
+            ).encode("utf-8"),
+            builder.staged_path(execution_path).read_bytes(),
+            builder.staged_path(physics_path).read_bytes(),
+        )
+        if not isinstance(image, bytes) or not image:
+            raise RuntimeError(
+                "Rusticol returned an invalid recurrence bootstrap image"
+            )
+        builder.add_bytes(
+            f"{prefix}/{_RECURRENCE_BOOTSTRAP_FILENAME}",
+            image,
+            role="evaluator-state",
+            media_type="application/octet-stream",
+            executable=False,
+            target=target,
+            process_id=process_id,
+        )
+
+
+@cache
+def _recurrence_bootstrap_operation() -> Callable[[bytes, bytes, bytes], bytes]:
+    try:
+        rusticol = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(rusticol)
+    except (ImportError, OSError, RuntimeError) as exc:
+        raise RuntimeError(
+            "recurrence bootstrap generation requires the current pyamplicol "
+            "native extension"
+        ) from exc
+    operation = getattr(rusticol, "_build_recurrence_bootstrap_v1", None)
+    if not callable(operation):
+        raise RuntimeError(
+            "the current pyamplicol native extension does not expose "
+            "_build_recurrence_bootstrap_v1; rebuild it before generating artifacts"
+        )
+    return operation
+
+
+def _runtime_schema_mapping(
+    schema: RuntimeExpressionSchema | Mapping[str, object],
+) -> Mapping[str, object]:
+    if isinstance(schema, RuntimeExpressionSchema):
+        return schema.to_mapping()
+    return schema
+
+
+def _validate_staged_eager_runtime(
+    process: EagerPlanV3ProcessArtifact,
+    record: PayloadRecord,
+) -> None:
+    if process.eager_runtime_size_bytes <= 0:
+        raise ValueError("Rust eager runtime payload must not be empty")
+    payload_sha256 = _canonical_sha256(
+        process.eager_runtime_sha256,
+        "Rust eager runtime payload SHA-256",
+    )
+    if (
+        record.size_bytes != process.eager_runtime_size_bytes
+        or record.sha256 != payload_sha256
+    ):
+        raise ValueError(
+            "Rust eager runtime payload changed after lowering and before publication"
+        )
+
+
+def _validate_staged_on_the_fly_runtime(
+    process: OnTheFlyProcessArtifact,
+    record: PayloadRecord,
+) -> None:
+    payload_sha256 = _canonical_sha256(
+        process.runtime_sha256,
+        "on-the-fly runtime payload SHA-256",
+    )
+    if process.runtime_size_bytes <= 0:
+        raise ValueError("on-the-fly runtime payload must not be empty")
+    if (
+        record.size_bytes != process.runtime_size_bytes
+        or record.sha256 != payload_sha256
+    ):
+        raise ValueError(
+            "on-the-fly runtime payload changed before artifact publication"
+        )
+    with PacbinReader.open(process.runtime_path, verify_payloads=True) as reader:
+        index = reader.index
+        if (
+            len(index.members) != 1
+            or index.members[0].logical_path != _ON_THE_FLY_PROCESS_SEED_MEMBER_PATH
+            or index.members[0].kind is not PacbinMemberKind.ON_THE_FLY_PROCESS_SEED
+        ):
+            raise ValueError(
+                "on-the-fly runtime must contain exactly one canonical process seed"
+            )
+        if (
+            len(index.members) != process.runtime_member_count
+            or sum(member.length for member in index.members)
+            != process.runtime_unpacked_size_bytes
+            or index.index_sha256 != process.runtime_index_sha256
+        ):
+            raise ValueError(
+                "on-the-fly runtime container metadata changed before publication"
+            )
+
+
+def _on_the_fly_execution_summary(
+    process: OnTheFlyProcessArtifact,
+    *,
+    color_contraction_record: PayloadRecord | None = None,
+) -> bytes:
+    capabilities = list(_on_the_fly_process_runtime_capabilities(process))
+    selector_policy = _mapping(process.selector_policy)
+    if set(selector_policy) - {"color_basis"} != {
+        "color_coverage",
+        "reference_color_word",
+        "trace_reflections_folded",
+        "selector_census",
+    }:
+        raise ValueError("on-the-fly selector policy fields are invalid")
+    color_basis = selector_policy.get("color_basis", "trace")
+    if color_basis not in ("trace", "adjoint"):
+        raise ValueError("on-the-fly selector color basis must be trace or adjoint")
+    if color_basis == "adjoint" and process.color_accuracy not in {"nlc", "full"}:
+        raise ValueError("adjoint on-the-fly color requires contracted NLC/full")
+    expected_coverage = "complete" if process.color_accuracy == "lc" else "contracted"
+    if selector_policy.get("color_coverage") != expected_coverage or not isinstance(
+        selector_policy.get("trace_reflections_folded"), bool
+    ):
+        raise ValueError("on-the-fly selector policy is invalid")
+    census = _mapping(selector_policy.get("selector_census"))
+    if set(census) != {
+        "physical_helicity_count",
+        "physical_color_flow_count",
+    }:
+        raise ValueError("on-the-fly selector census fields are invalid")
+    census_counts = {}
+    for field in ("physical_helicity_count", "physical_color_flow_count"):
+        count = _nonnegative_integer(
+            census.get(field),
+            f"on-the-fly selector census {field}",
+            minimum=1,
+        )
+        if count > (1 << 64) - 1:
+            raise ValueError(f"on-the-fly selector census {field} exceeds u64")
+        census_counts[field] = count
+    if process.color_accuracy in {"nlc", "full"} and (
+        census_counts["physical_color_flow_count"] != 1
+        or selector_policy.get("trace_reflections_folded") is not False
+    ):
+        raise ValueError(
+            "contracted on-the-fly selector policy must expose one color "
+            "result without trace-reflection folding"
+        )
+    runtime_metadata = _deep_plain(process.runtime_metadata)
+    if not isinstance(runtime_metadata, dict):
+        raise TypeError("on-the-fly runtime metadata must be a mapping")
+    if color_contraction_record is None:
+        if process.color_accuracy != "lc":
+            raise ValueError("contracted on-the-fly execution has no color payload")
+    else:
+        if process.color_accuracy not in {"nlc", "full"}:
+            raise ValueError("LC on-the-fly execution carries a color payload")
+        summary = _deep_plain(process.color_contraction_summary)
+        if not isinstance(summary, dict):
+            raise TypeError("on-the-fly color-contraction summary must be a mapping")
+        expected_summary_fields = {
+            "abi",
+            "color_accuracy",
+            "storage",
+            "includes_color_factor",
+            "group_count",
+            "sector_count",
+            "active_sector_count",
+            "component_count",
+            "destination_count",
+            "entry_count",
+            "logical_entry_count",
+            "semantic_digest",
+            "factorization",
+        }
+        if (
+            isinstance(summary.get("factorization"), Mapping)
+            and summary["factorization"].get("kind") == "symmetric-group-fourier"
+        ):
+            expected_summary_fields.add("fft_provenance")
+        if set(summary) != expected_summary_fields:
+            raise ValueError("on-the-fly color-contraction summary fields are invalid")
+        factorization = summary.get("factorization")
+        symmetric_group_fft = (
+            isinstance(factorization, Mapping)
+            and factorization.get("kind") == "symmetric-group-fourier"
+        )
+        factorization_rank = (
+            factorization.get("rank") if isinstance(factorization, Mapping) else None
+        )
+        factorization_coset_count = (
+            factorization.get("coset_count")
+            if isinstance(factorization, Mapping)
+            else None
+        )
+        factorization_is_canonical = (
+            factorization is None
+            if not symmetric_group_fft
+            else isinstance(factorization, Mapping)
+            and set(factorization) == {"kind", "rank", "coset_count"}
+            and isinstance(factorization_rank, int)
+            and not isinstance(factorization_rank, bool)
+            and 2 <= factorization_rank <= 10
+            and isinstance(factorization_coset_count, int)
+            and not isinstance(factorization_coset_count, bool)
+            and factorization_coset_count >= 1
+        )
+        _validate_symmetric_group_fft_provenance(
+            summary,
+            context="on-the-fly color-contraction",
+        )
+        if (
+            summary.get("abi") != "pyamplicol-recurrence-color-contraction-v3"
+            or summary.get("color_accuracy") != process.color_accuracy
+            or summary.get("storage")
+            != ("convolution-kernels" if symmetric_group_fft else "expanded")
+            or summary.get("includes_color_factor") is not True
+            or summary.get("component_count") != 1
+            or not factorization_is_canonical
+            or summary.get("active_sector_count") != summary.get("group_count")
+            or summary.get("destination_count") != summary.get("group_count")
+            or summary.get("logical_entry_count") != summary.get("entry_count")
+            or summary.get("semantic_digest") != color_contraction_record.sha256
+        ):
+            raise ValueError("on-the-fly color-contraction summary is noncanonical")
+        runtime_metadata["color_contraction"] = {
+            **summary,
+            "path": _ON_THE_FLY_COLOR_CONTRACTION_PATH,
+            "size_bytes": color_contraction_record.size_bytes,
+            "sha256": color_contraction_record.sha256,
+        }
+    payload = {
+        "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+        "kind": ON_THE_FLY_RUNTIME_KIND,
+        "required_runtime_capabilities": capabilities,
+        "process": process.expression,
+        "key": process.process_id,
+        "color_accuracy": process.color_accuracy,
+        "external_pdg_order": list(process.external_pdgs),
+        "kernel_pack": {
+            "manifest_path": _EAGER_KERNEL_PACK_PATH,
+            "payload_root": _EAGER_KERNEL_PAYLOAD_ROOT,
+        },
+        "runtime_options": {
+            "point_tile_size": _nonnegative_integer(
+                process.point_tile_size,
+                "on-the-fly point tile size",
+                minimum=1,
+            ),
+            "query_construction_threads": _nonnegative_integer(
+                process.query_construction_threads,
+                "on-the-fly query construction threads",
+                minimum=1,
+            ),
+        },
+        "selector_policy": _deep_plain(selector_policy),
+        "runtime_metadata": runtime_metadata,
+        "runtime_container": {
+            "kind": ON_THE_FLY_RUNTIME_CONTAINER_KIND,
+            "schema_version": ON_THE_FLY_RUNTIME_CONTAINER_SCHEMA_VERSION,
+            "storage_abi": ON_THE_FLY_RUNTIME_STORAGE_ABI,
+            "path": _ON_THE_FLY_RUNTIME_CONTAINER_PATH,
+            "seed_member_path": _ON_THE_FLY_PROCESS_SEED_MEMBER_PATH,
+        },
+    }
+    try:
+        return (
+            json.dumps(
+                payload,
+                ensure_ascii=True,
+                allow_nan=False,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            + "\n"
+        ).encode("ascii")
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"on-the-fly execution summary is not canonical JSON: {exc}"
+        ) from exc
+
+
+def _recurrence_helicity_selector_companion_v2_manifest(
+    process: RecurrenceProcessArtifact,
+    companion: RecurrenceHelicitySelectorPlanArtifact,
+    *,
+    binding: Mapping[str, object],
+) -> dict[str, object]:
+    """Describe one pre-lowered, runtime-helicity-dispatched selector plan."""
+
+    process_digest = _canonical_sha256(
+        process.process_digest,
+        "recurrence helicity-selector process digest",
+    )
+    if binding.get("process_digest") != process_digest:
+        raise ValueError(
+            "recurrence helicity-selector binding disagrees with its process digest"
+        )
+    if binding.get("process_semantic_digest") != companion.builder_input_sha256:
+        raise ValueError(
+            "recurrence helicity-selector binding disagrees with its builder input"
+        )
+    if binding.get("schedule_digest") != companion.recurrence_schedule_digest:
+        raise ValueError(
+            "recurrence helicity-selector binding disagrees with its schedule"
+        )
+
+    companion_pack = companion.recurrence_process_executor_pack
+    primary_pack = process.recurrence_process_executor_pack
+    for name in (
+        "compiled_model_digest",
+        "recurrence_template_catalog_digest",
+        "prepared_kernel_pack_digest",
+        "direct_template_catalog_digest",
+    ):
+        if getattr(companion_pack, name) != getattr(primary_pack, name):
+            raise ValueError(
+                "recurrence helicity-selector executor pack disagrees with the "
+                f"primary {name.replace('_', ' ')}"
+            )
+    if (
+        companion_pack.prepared_kernel_pack_digest
+        != process.prepared_kernel_pack_digest
+    ):
+        raise ValueError(
+            "recurrence helicity-selector prepared-kernel identity disagrees "
+            "with its process"
+        )
+    if (
+        companion_pack.direct_template_catalog_digest
+        != process.direct_template_catalog_digest
+    ):
+        raise ValueError(
+            "recurrence helicity-selector direct-template identity disagrees "
+            "with its process"
+        )
+
+    primary_color = _deep_plain(process.color_contraction_summary)
+    if not isinstance(primary_color, dict):
+        raise TypeError(
+            "persisted recurrence helicity-selector plan requires the primary "
+            "color-contraction summary"
+        )
+    if (
+        process.color_accuracy not in {"nlc", "full"}
+        or primary_color.get("abi") != "pyamplicol-recurrence-color-contraction-v3"
+        or primary_color.get("color_accuracy") != process.color_accuracy
+    ):
+        raise ValueError(
+            "recurrence helicity-selector primary local-color view requires a "
+            "compatible complete-color reducer"
+        )
+    _validate_symmetric_group_fft_provenance(
+        primary_color,
+        context="recurrence primary color-contraction",
+    )
+    storage = primary_color.get("storage")
+    factorization_raw = primary_color.get("factorization")
+    factorization_kind = (
+        factorization_raw.get("kind")
+        if isinstance(factorization_raw, Mapping)
+        else None
+    )
+    component_count = _nonnegative_integer(
+        primary_color.get("component_count"),
+        "recurrence primary color-contraction component count",
+        minimum=1,
+    )
+    supported_primary_view = (
+        (storage == "expanded" and factorization_raw is None and component_count == 1)
+        or (
+            storage == "repeated"
+            and factorization_kind
+            in {None, "klein-four-walsh", "elementary-abelian-walsh"}
+        )
+        or (
+            storage == "convolution-kernels"
+            and factorization_kind == "symmetric-group-fourier"
+        )
+    )
+    if not supported_primary_view:
+        raise ValueError(
+            "recurrence helicity-selector primary local-color view requires a "
+            "direct, Walsh, or symmetric-group Fourier reducer"
+        )
+    group_count = _nonnegative_integer(
+        primary_color.get("group_count"),
+        "recurrence primary color-contraction group count",
+        minimum=1,
+    )
+    if group_count % component_count:
+        raise ValueError(
+            "recurrence primary color-contraction groups do not form complete "
+            "local component blocks"
+        )
+    local_group_count = group_count // component_count
+    physical_destination_count = _nonnegative_integer(
+        companion.physical_destination_count,
+        "recurrence helicity-selector physical destination count",
+        minimum=1,
+    )
+    if physical_destination_count != local_group_count:
+        raise ValueError(
+            "recurrence helicity-selector physical destinations do not match "
+            "the primary local color-group domain"
+        )
+    runtime_schedule = {
+        "kind": RECURRENCE_RUNTIME_CONTAINER_KIND,
+        "schema_version": RECURRENCE_RUNTIME_CONTAINER_SCHEMA_VERSION,
+        "storage_abi": RECURRENCE_RUNTIME_STORAGE_ABI,
+        "path": _recurrence_helicity_selector_schedule_path(companion),
+        "plan_member_path": _RECURRENCE_DIRECT_SCHEDULE_MEMBER_PATH,
+        "size_bytes": _nonnegative_integer(
+            companion.recurrence_schedule_size_bytes,
+            "recurrence helicity-selector schedule size",
+            minimum=1,
+        ),
+        "sha256": _canonical_sha256(
+            companion.recurrence_schedule_sha256,
+            "recurrence helicity-selector schedule SHA-256",
+        ),
+        "member_count": _nonnegative_integer(
+            companion.recurrence_schedule_member_count,
+            "recurrence helicity-selector schedule member count",
+            minimum=1,
+        ),
+        "unpacked_size_bytes": _nonnegative_integer(
+            companion.recurrence_schedule_unpacked_size_bytes,
+            "recurrence helicity-selector schedule unpacked size",
+        ),
+        "index_sha256": _canonical_sha256(
+            companion.recurrence_schedule_index_sha256,
+            "recurrence helicity-selector schedule index SHA-256",
+        ),
+    }
+    inspection_summary = _deep_plain(companion.inspection_summary)
+    if not isinstance(inspection_summary, dict):
+        raise TypeError(
+            "recurrence helicity-selector inspection summary must be a mapping"
+        )
+    dispatch_layout_digest = _canonical_sha256(
+        companion.helicity_dispatch_base_runtime_layout_digest,
+        "recurrence helicity-dispatch base runtime-layout digest",
+    )
+    if inspection_summary.get("runtime_layout_digest") != dispatch_layout_digest:
+        raise ValueError(
+            "recurrence helicity dispatch disagrees with its base runtime layout"
+        )
+    native_schedule_digest = _canonical_sha256(
+        binding.get("native_schedule_semantic_digest"),
+        "recurrence helicity-selector binding native schedule digest",
+    )
+    if inspection_summary.get("schedule_digest") != native_schedule_digest:
+        raise ValueError(
+            "recurrence helicity-selector inspection summary disagrees with its "
+            "native Direct-plan identity"
+        )
+    helicity_dispatch = {
+        "abi": _RECURRENCE_HELICITY_DISPATCH_ABI,
+        "path": _recurrence_helicity_dispatch_path(companion),
+        "size_bytes": _nonnegative_integer(
+            companion.helicity_dispatch_size_bytes,
+            "recurrence helicity-dispatch size",
+            minimum=1,
+        ),
+        "sha256": _canonical_sha256(
+            companion.helicity_dispatch_sha256,
+            "recurrence helicity-dispatch SHA-256",
+        ),
+        "base_runtime_layout_digest": dispatch_layout_digest,
+        "resolved_helicity_count": _nonnegative_integer(
+            companion.helicity_dispatch_resolved_helicity_count,
+            "recurrence helicity-dispatch resolved-helicity count",
+            minimum=1,
+        ),
+    }
+    capabilities = list(_recurrence_process_runtime_capabilities(process))
+    plan = {
+        "kind": RECURRENCE_RUNTIME_KIND,
+        "builder_input_abi": RECURRENCE_BUILDER_INPUT_ABI,
+        "recurrence_plan_abi": RECURRENCE_PLAN_ABI,
+        "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_ABI,
+        "direct_template_abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "direct_backend_abi": RECURRENCE_DIRECT_BACKEND_ABI,
+        "builder_input_sha256": _canonical_sha256(
+            companion.builder_input_sha256,
+            "recurrence helicity-selector builder input SHA-256",
+        ),
+        "prepared_kernel_pack_digest": _canonical_sha256(
+            process.prepared_kernel_pack_digest,
+            "recurrence helicity-selector prepared-kernel pack SHA-256",
+        ),
+        "direct_template_catalog_digest": _canonical_sha256(
+            process.direct_template_catalog_digest,
+            "recurrence helicity-selector direct-template catalog SHA-256",
+        ),
+        "required_runtime_capabilities": capabilities,
+        "runtime_schedule": runtime_schedule,
+        "helicity_dispatch": helicity_dispatch,
+        "process_binding": _deep_plain(binding),
+        "inspection_summary": inspection_summary,
+    }
+    return {
+        "schema_version": 2,
+        "kind": _RECURRENCE_HELICITY_SELECTOR_COMPANION_V2_KIND,
+        "process_digest": process_digest,
+        "plan": plan,
+        "color_contraction": {
+            "source": "primary",
+            "view": "primary-local-color-view-v1",
+        },
+    }
+
+
+def _eager_execution_summary(
+    process: EagerPlanV3ProcessArtifact,
+) -> bytes:
+    try:
+        content = (
+            json.dumps(
+                _eager_plan_v3_execution_manifest(process),
+                ensure_ascii=True,
+                allow_nan=False,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            + "\n"
+        ).encode("utf-8")
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"Rust eager execution summary is not canonical JSON: {exc}"
+        ) from exc
+    return content
+
+
+def _eager_plan_v3_execution_manifest(
+    process: EagerPlanV3ProcessArtifact,
+) -> dict[str, object]:
+    lowering_input_sha256 = _canonical_sha256(
+        process.lowering_input_sha256,
+        "eager lowering input SHA-256",
+    )
+    payload_sha256 = _canonical_sha256(
+        process.eager_runtime_sha256,
+        "Rust eager runtime payload SHA-256",
+    )
+    index_sha256 = _canonical_sha256(
+        process.eager_runtime_index_sha256,
+        "Rust eager runtime index SHA-256",
+    )
+    member_count = _nonnegative_integer(
+        process.eager_runtime_member_count,
+        "Rust eager runtime member count",
+        minimum=1,
+    )
+    unpacked_size = _nonnegative_integer(
+        process.eager_runtime_unpacked_size_bytes,
+        "Rust eager runtime unpacked size",
+    )
+    payload_size = _nonnegative_integer(
+        process.eager_runtime_size_bytes,
+        "Rust eager runtime payload size",
+        minimum=1,
+    )
+    capabilities = list(_EAGER_PLAN_V3_RUNTIME_CAPABILITIES)
+    plan = {
+        "kind": EAGER_RUNTIME_KIND,
+        "eager_plan_abi": EAGER_PLAN_V3_ABI,
+        "lowering_input_abi": EAGER_LOWERING_INPUT_ABI,
+        "lowering_input_sha256": lowering_input_sha256,
+        "runtime_layout_abi": EAGER_RUNTIME_LAYOUT_ABI,
+        "required_runtime_capabilities": capabilities,
+        "runtime_container": {
+            "kind": EAGER_RUNTIME_CONTAINER_KIND,
+            "schema_version": EAGER_RUNTIME_CONTAINER_SCHEMA_VERSION,
+            "storage_abi": EAGER_RUNTIME_STORAGE_ABI,
+            "path": _EAGER_RUNTIME_CONTAINER_PATH,
+            "size_bytes": payload_size,
+            "sha256": payload_sha256,
+            "member_count": member_count,
+            "unpacked_size_bytes": unpacked_size,
+            "index_sha256": index_sha256,
+        },
+        "inspection_summary": _deep_plain(process.inspection_summary),
+        "materialization_census": _eager_materialization_census(process),
+    }
+    return {
+        "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+        "kind": EAGER_RUNTIME_KIND,
+        "required_runtime_capabilities": capabilities,
+        "process": process.expression,
+        "key": process.process_id,
+        "color_accuracy": process.color_accuracy,
+        "external_pdg_order": list(process.external_pdgs),
+        "eager_plan_abi": EAGER_PLAN_V3_ABI,
+        "kernel_pack": {
+            "manifest_path": _EAGER_KERNEL_PACK_PATH,
+            "payload_root": _EAGER_KERNEL_PAYLOAD_ROOT,
+        },
+        "runtime_options": {
+            "point_tile_size": process.point_tile_size,
+            "workspace_mib": process.workspace_mib,
+        },
+        "plan": plan,
+        "dag_summary": _dag_summary(process.dag_summary),
+    }
+
+
+def _bounded_recurrence_execution_summary(
+    process: RecurrenceProcessArtifact,
+    *,
+    schedule_path: str,
+    binding: Mapping[str, object],
+    color_contraction_record: PayloadRecord | None,
+    companion_binding: Mapping[str, object] | None = None,
+) -> bytes:
+    try:
+        content = (
+            json.dumps(
+                _recurrence_execution_manifest(
+                    process,
+                    schedule_path=schedule_path,
+                    binding=binding,
+                    color_contraction_record=color_contraction_record,
+                    companion_binding=companion_binding,
+                ),
+                ensure_ascii=True,
+                allow_nan=False,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            + "\n"
+        ).encode("utf-8")
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"Rust recurrence execution summary is not canonical JSON: {exc}"
+        ) from exc
+    return content
+
+
+def _recurrence_execution_manifest(
+    process: RecurrenceProcessArtifact,
+    *,
+    schedule_path: str,
+    binding: Mapping[str, object],
+    color_contraction_record: PayloadRecord | None,
+    companion_binding: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    primary_process_digest = _canonical_sha256(
+        process.process_digest,
+        "recurrence primary process digest",
+    )
+    if binding.get("process_digest") != primary_process_digest:
+        raise ValueError(
+            "recurrence primary process binding disagrees with its process digest"
+        )
+    capabilities = list(_recurrence_process_runtime_capabilities(process))
+    runtime_schedule = {
+        "kind": RECURRENCE_RUNTIME_CONTAINER_KIND,
+        "schema_version": RECURRENCE_RUNTIME_CONTAINER_SCHEMA_VERSION,
+        "storage_abi": RECURRENCE_RUNTIME_STORAGE_ABI,
+        "path": schedule_path,
+        "plan_member_path": _RECURRENCE_DIRECT_SCHEDULE_MEMBER_PATH,
+        "size_bytes": _nonnegative_integer(
+            process.recurrence_schedule_size_bytes,
+            "Rust recurrence runtime payload size",
+            minimum=1,
+        ),
+        "sha256": _canonical_sha256(
+            process.recurrence_schedule_sha256,
+            "Rust recurrence runtime payload SHA-256",
+        ),
+        "member_count": _nonnegative_integer(
+            process.recurrence_schedule_member_count,
+            "Rust recurrence runtime member count",
+            minimum=1,
+        ),
+        "unpacked_size_bytes": _nonnegative_integer(
+            process.recurrence_schedule_unpacked_size_bytes,
+            "Rust recurrence runtime unpacked size",
+        ),
+        "index_sha256": _canonical_sha256(
+            process.recurrence_schedule_index_sha256,
+            "Rust recurrence runtime index SHA-256",
+        ),
+    }
+    plan = {
+        "kind": RECURRENCE_RUNTIME_KIND,
+        "builder_input_abi": RECURRENCE_BUILDER_INPUT_ABI,
+        "recurrence_plan_abi": RECURRENCE_PLAN_ABI,
+        "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_ABI,
+        "direct_template_abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "direct_backend_abi": RECURRENCE_DIRECT_BACKEND_ABI,
+        "builder_input_sha256": _canonical_sha256(
+            process.builder_input_sha256,
+            "recurrence builder input SHA-256",
+        ),
+        "prepared_kernel_pack_digest": _canonical_sha256(
+            process.prepared_kernel_pack_digest,
+            "recurrence prepared-kernel pack SHA-256",
+        ),
+        "direct_template_catalog_digest": _canonical_sha256(
+            process.direct_template_catalog_digest,
+            "recurrence direct-template catalog SHA-256",
+        ),
+        "required_runtime_capabilities": capabilities,
+        "runtime_schedule": runtime_schedule,
+        "process_binding": _deep_plain(binding),
+        "inspection_summary": _deep_plain(process.inspection_summary),
+    }
+    runtime_metadata = _deep_plain(process.runtime_metadata)
+    if not isinstance(runtime_metadata, dict):
+        raise TypeError("recurrence runtime metadata must be a mapping")
+    if color_contraction_record is None:
+        runtime_metadata["color_contraction"] = None
+    else:
+        summary = _deep_plain(process.color_contraction_summary)
+        if not isinstance(summary, dict):
+            raise TypeError("recurrence color-contraction summary must be a mapping")
+        _validate_symmetric_group_fft_provenance(
+            summary,
+            context="recurrence color-contraction",
+        )
+        runtime_metadata["color_contraction"] = {
+            **summary,
+            "path": _RECURRENCE_COLOR_CONTRACTION_PATH,
+            "size_bytes": color_contraction_record.size_bytes,
+            "sha256": color_contraction_record.sha256,
+        }
+    companion = process.helicity_selector_companion
+    if companion is None:
+        if companion_binding is not None:
+            raise ValueError(
+                "recurrence without a helicity-selector companion carries "
+                "companion metadata"
+            )
+        companion_manifest = None
+        process_digest = None
+    elif isinstance(companion, RecurrenceHelicitySelectorPlanArtifact):
+        if color_contraction_record is None or companion_binding is None:
+            raise ValueError(
+                "persisted recurrence helicity-selector companion is missing its "
+                "authenticated plan or primary color metadata"
+            )
+        process_digest = primary_process_digest
+        companion_manifest = _recurrence_helicity_selector_companion_v2_manifest(
+            process,
+            companion,
+            binding=companion_binding,
+        )
+    else:  # pragma: no cover - dataclass typing guards ordinary construction
+        raise TypeError(
+            "recurrence helicity-selector companion must be a persisted Direct plan"
+        )
+    return {
+        "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+        "kind": RECURRENCE_RUNTIME_KIND,
+        "required_runtime_capabilities": capabilities,
+        "process": process.expression,
+        "key": process.process_id,
+        "color_accuracy": process.color_accuracy,
+        "external_pdg_order": list(process.external_pdgs),
+        "process_digest": process_digest,
+        "builder_input_abi": RECURRENCE_BUILDER_INPUT_ABI,
+        "recurrence_plan_abi": RECURRENCE_PLAN_ABI,
+        "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_ABI,
+        "direct_template_abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "direct_backend_abi": RECURRENCE_DIRECT_BACKEND_ABI,
+        "compiled_model_digest": (
+            process.recurrence_process_executor_pack.compiled_model_digest
+        ),
+        "recurrence_template_catalog_digest": (
+            process.recurrence_process_executor_pack.recurrence_template_catalog_digest
+        ),
+        "prepared_kernel_pack_digest": _canonical_sha256(
+            process.prepared_kernel_pack_digest,
+            "recurrence prepared-kernel pack SHA-256",
+        ),
+        "direct_template_catalog_digest": _canonical_sha256(
+            process.direct_template_catalog_digest,
+            "recurrence direct-template catalog SHA-256",
+        ),
+        "kernel_pack": {
+            "manifest_path": _EAGER_KERNEL_PACK_PATH,
+            "payload_root": _EAGER_KERNEL_PAYLOAD_ROOT,
+        },
+        "runtime_options": {
+            "point_tile_size": process.point_tile_size,
+            "workspace_mib": process.workspace_mib,
+        },
+        "runtime_metadata": runtime_metadata,
+        "helicity_selector_companion": companion_manifest,
+        "plan": plan,
+        "recurrence_summary": _deep_plain(process.recurrence_summary),
+    }
+
+
+def _canonical_sha256(value: object, context: str) -> str:
+    if not isinstance(value, str) or re.fullmatch(r"[0-9a-f]{64}", value) is None:
+        raise ValueError(f"{context} must be a lowercase hexadecimal digest")
+    return value
+
+
+def _nonnegative_integer(
+    value: object,
+    context: str,
+    *,
+    minimum: int = 0,
+) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < minimum:
+        raise ValueError(
+            f"{context} must be an integer greater than or equal to {minimum}"
+        )
+    return value
+
+
+def _execution_manifest(
+    process: ProcessArtifact,
+    compiler_schema: Mapping[str, object],
+    *,
+    color_contraction_payload_path: str | None = None,
+) -> dict[str, object]:
+    if isinstance(process, OnTheFlyProcessArtifact):
+        raise TypeError("on-the-fly execution manifests use the compact seed writer")
+    if isinstance(process, RecurrenceProcessArtifact):
+        raise TypeError(
+            "recurrence execution manifests require an interned root schedule "
+            "and process binding"
+        )
+    if isinstance(process, EagerPlanV3ProcessArtifact):
+        return _eager_plan_v3_execution_manifest(process)
+    primary = _compiled_execution_lane_manifest(
+        runtime_schema=compiler_schema,
+        stage_manifest=process.stage_manifest,
+        model_parameter_evaluator=process.model_parameter_evaluator,
+        dag_summary=process.dag_summary,
+        payload_prefix=None,
+    )
+    required_runtime_capabilities = set(_required_runtime_capabilities(primary))
+    if color_contraction_payload_path is not None:
+        required_runtime_capabilities.add(SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY)
+    color_selector_executions = _compiled_color_selector_execution_manifests(
+        process=process,
+        executions=process.color_selector_executions,
+        parent_payload_prefix=None,
+    )
+    if color_selector_executions:
+        required_runtime_capabilities.add(COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY)
+        required_runtime_capabilities.add(COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+        for record in color_selector_executions:
+            required_runtime_capabilities.update(
+                _required_runtime_capabilities(_mapping(record["execution"]))
+            )
+    helicity_sum_execution = process.helicity_sum_execution
+    auxiliary: dict[str, object] | None = None
+    if helicity_sum_execution is not None:
+        auxiliary = _compiled_nested_execution_manifest(
+            process=process,
+            execution=helicity_sum_execution,
+            payload_prefix=_HELICITY_SUM_PAYLOAD_ROOT,
+        )
+        required_runtime_capabilities.update(_required_runtime_capabilities(auxiliary))
+        required_runtime_capabilities.add(COMPILED_HELICITY_DUAL_LANE_CAPABILITY)
+    helicity_selector_executions = _compiled_helicity_selector_execution_manifests(
+        process=process,
+        executions=process.helicity_selector_executions,
+        parent_payload_prefix=None,
+    )
+    if helicity_selector_executions:
+        for record in helicity_selector_executions:
+            required_runtime_capabilities.update(
+                _required_runtime_capabilities(_mapping(record["execution"]))
+            )
+        required_runtime_capabilities.add(COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY)
+        required_runtime_capabilities.add(COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+    if _uses_primary_helicity_recurrence(process):
+        required_runtime_capabilities.add(
+            COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY
+        )
+    return {
+        "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+        "kind": "pyamplicol-runtime-execution",
+        "required_runtime_capabilities": sorted(required_runtime_capabilities),
+        "process": process.expression,
+        "key": process.process_id,
+        "color_accuracy": process.color_accuracy,
+        "external_pdg_order": list(process.external_pdgs),
+        "compiled": primary["compiled"],
+        "dag_summary": primary["dag_summary"],
+        "materialization_census": primary["materialization_census"],
+        "runtime_schema": primary["runtime_schema"],
+        **(
+            {}
+            if color_contraction_payload_path is None
+            else {
+                "color_contraction_payload": {
+                    "path": color_contraction_payload_path,
+                }
+            }
+        ),
+        **({} if auxiliary is None else {"helicity_sum_execution": auxiliary}),
+        **(
+            {}
+            if not helicity_selector_executions
+            else {"helicity_selector_executions": helicity_selector_executions}
+        ),
+        **(
+            {}
+            if not color_selector_executions
+            else {"color_selector_executions": color_selector_executions}
+        ),
+    }
+
+
+def _compiled_helicity_selector_execution_manifests(
+    *,
+    process: CompiledProcessArtifact,
+    executions: Sequence[CompiledHelicitySelectorExecutionArtifact],
+    parent_payload_prefix: str | None,
+) -> list[dict[str, object]]:
+    result: list[dict[str, object]] = []
+    for lane_index, record in enumerate(
+        _ordered_helicity_selector_executions(executions)
+    ):
+        execution = record.execution
+        if execution.color_selector_executions:
+            raise ValueError(
+                "compiled helicity-selector closure execution cannot contain "
+                "nested execution lanes"
+            )
+        lane_prefix = f"{_HELICITY_SELECTOR_UNION_PAYLOAD_ROOT}/class-{lane_index}"
+        payload_prefix = (
+            lane_prefix
+            if parent_payload_prefix is None
+            else f"{parent_payload_prefix.rstrip('/')}/{lane_prefix}"
+        )
+        manifest = _compiled_nested_execution_manifest(
+            process=process,
+            execution=execution,
+            payload_prefix=payload_prefix,
+        )
+        if (
+            record.schedule_mode == "parent-closure"
+            and COMPILED_RUNTIME_SELECTORS_CAPABILITY
+            in _required_runtime_capabilities(manifest)
+        ):
+            raise ValueError(
+                "compiled helicity-selector closure stage evaluators cannot require "
+                "runtime selectors"
+            )
+        result.append(
+            {
+                "selector_domain_ids": list(record.selector_domain_ids),
+                "schedule_mode": record.schedule_mode,
+                "execution": manifest,
+            }
+        )
+    return result
+
+
+def _compiled_nested_execution_manifest(
+    *,
+    process: CompiledProcessArtifact,
+    execution: CompiledExecutionArtifact,
+    payload_prefix: str,
+) -> dict[str, object]:
+    runtime_schema = _runtime_schema_mapping(execution.runtime_schema)
+    lane = _compiled_execution_lane_manifest(
+        runtime_schema=runtime_schema,
+        stage_manifest=execution.stage_manifest,
+        model_parameter_evaluator=execution.model_parameter_evaluator,
+        dag_summary=execution.dag_summary,
+        payload_prefix=payload_prefix,
+    )
+    color_selector_executions = _compiled_color_selector_execution_manifests(
+        process=process,
+        executions=execution.color_selector_executions,
+        parent_payload_prefix=payload_prefix,
+    )
+    required_runtime_capabilities = set(_required_runtime_capabilities(lane))
+    if _runtime_schema_uses_primary_helicity_recurrence(
+        runtime_schema,
+        has_helicity_sum_execution=False,
+    ):
+        required_runtime_capabilities.add(
+            COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY
+        )
+    helicity_selector_executions = _compiled_helicity_selector_execution_manifests(
+        process=process,
+        executions=execution.helicity_selector_executions,
+        parent_payload_prefix=payload_prefix,
+    )
+    if helicity_selector_executions:
+        required_runtime_capabilities.add(COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY)
+        required_runtime_capabilities.add(COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+        for record in helicity_selector_executions:
+            required_runtime_capabilities.update(
+                _required_runtime_capabilities(_mapping(record["execution"]))
+            )
+    if color_selector_executions:
+        required_runtime_capabilities.add(COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY)
+        required_runtime_capabilities.add(COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+        for record in color_selector_executions:
+            required_runtime_capabilities.update(
+                _required_runtime_capabilities(_mapping(record["execution"]))
+            )
+    return {
+        "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+        "kind": "pyamplicol-runtime-execution",
+        "required_runtime_capabilities": sorted(required_runtime_capabilities),
+        "process": process.expression,
+        "key": process.process_id,
+        "color_accuracy": process.color_accuracy,
+        "external_pdg_order": list(process.external_pdgs),
+        "compiled": lane["compiled"],
+        "dag_summary": lane["dag_summary"],
+        "materialization_census": lane["materialization_census"],
+        "runtime_schema": lane["runtime_schema"],
+        "physics_reduction": _plain_mapping(
+            _mapping(_mapping(runtime_schema["physics"])["reduction"])
+        ),
+        **(
+            {}
+            if not color_selector_executions
+            else {"color_selector_executions": color_selector_executions}
+        ),
+        **(
+            {}
+            if not helicity_selector_executions
+            else {"helicity_selector_executions": (helicity_selector_executions)}
+        ),
+    }
+
+
+def _compiled_color_selector_execution_manifests(
+    *,
+    process: CompiledProcessArtifact,
+    executions: Sequence[CompiledColorSelectorExecutionArtifact],
+    parent_payload_prefix: str | None,
+) -> list[dict[str, object]]:
+    result: list[dict[str, object]] = []
+    for record in _ordered_color_selector_executions(executions):
+        lane_prefix = _color_selector_payload_prefix(record.materialized_sector_id)
+        payload_prefix = (
+            lane_prefix
+            if parent_payload_prefix is None
+            else f"{parent_payload_prefix.rstrip('/')}/{lane_prefix}"
+        )
+        result.append(
+            {
+                "materialized_sector_id": record.materialized_sector_id,
+                "execution": _compiled_nested_execution_manifest(
+                    process=process,
+                    execution=record.execution,
+                    payload_prefix=payload_prefix,
+                ),
+            }
+        )
+    return result
+
+
+def _compiled_execution_lane_manifest(
+    *,
+    runtime_schema: Mapping[str, object],
+    stage_manifest: Mapping[str, object],
+    model_parameter_evaluator: Mapping[str, object] | None,
+    dag_summary: Mapping[str, object],
+    payload_prefix: str | None,
+) -> dict[str, object]:
+    serialized_model_parameters = (
+        None
+        if model_parameter_evaluator is None
+        else _model_parameter_evaluator(model_parameter_evaluator)
+    )
+    stage_evaluators = _stage_evaluator_set(stage_manifest)
+    if payload_prefix is not None:
+        stage_evaluators = _prefix_evaluator_payload_paths(
+            stage_evaluators,
+            payload_prefix,
+        )
+        if serialized_model_parameters is not None:
+            serialized_model_parameters = _prefix_evaluator_payload_paths(
+                serialized_model_parameters,
+                payload_prefix,
+            )
+    required_runtime_capabilities = set(
+        _required_runtime_capabilities(stage_evaluators)
+    )
+    required_runtime_capabilities.update(
+        _runtime_schema_walsh_color_contraction_capabilities(runtime_schema)
+    )
+    if serialized_model_parameters is not None:
+        required_runtime_capabilities.update(
+            _required_runtime_capabilities(serialized_model_parameters)
+        )
+    compiled_manifest: dict[str, object] = {
+        "kind": "generic-dag-stage-blueprint",
+        "runtime_available": True,
+        "runtime_unavailable_message": None,
+        "model_parameter_evaluator": serialized_model_parameters,
+        "stage_evaluators": stage_evaluators,
+    }
+    if COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY in required_runtime_capabilities:
+        layout = _mapping(runtime_schema["parameter_layout"])
+        compiled_manifest["momentum_slot_ids"] = _compiled_momentum_slot_ids(
+            stage_evaluators,
+            value_component_count=int(layout["value_component_count"]),
+            momentum_component_count=int(layout["momentum_parameter_count"]),
+        )
+    topology_replay = runtime_schema.get("lc_topology_replay")
+    if topology_replay is not None:
+        compiled_manifest["lc_topology_replay"] = _plain_mapping(
+            _mapping(topology_replay)
+        )
+    color_topology_replay = runtime_schema.get("color_topology_replay")
+    if color_topology_replay is not None:
+        compiled_manifest["color_topology_replay"] = _plain_mapping(
+            _mapping(color_topology_replay)
+        )
+    helicity_recurrence = runtime_schema.get("helicity_recurrence")
+    if helicity_recurrence is not None:
+        compiled_manifest["helicity_recurrence"] = _plain_mapping(
+            _mapping(helicity_recurrence)
+        )
+    serialized_dag_summary = _dag_summary(
+        dag_summary,
+        require_interaction_evaluation_count=True,
+    )
+    return {
+        "kind": "pyamplicol-runtime-compiled-execution",
+        "required_runtime_capabilities": sorted(required_runtime_capabilities),
+        "compiled": compiled_manifest,
+        "dag_summary": serialized_dag_summary,
+        "materialization_census": _fully_resident_materialization_census(
+            serialized_dag_summary,
+            basis="immutable-fully-resident-compiled-dag",
+        ),
+        "runtime_schema": _execution_plan(runtime_schema),
+    }
+
+
+def _compiled_momentum_slot_ids(
+    stage_evaluators: Mapping[str, object],
+    *,
+    value_component_count: int,
+    momentum_component_count: int,
+) -> list[int]:
+    """Retain the union needed by every final compiled leaf in this lane.
+
+    Chunk input maps are final here. Keep canonical momentum-slot numbering
+    and the complete lane's coverage, independently of runtime selectors.
+    """
+    live: set[int] = set()
+    stages = (
+        *_sequence(stage_evaluators["stages"]),
+        stage_evaluators["amplitude_stage"],
+    )
+    for raw_stage in stages:
+        direct = _mapping(_mapping(raw_stage)["compiled_plane_arena"])
+        bindings = _sequence(direct["input_bindings"])
+        for raw_leaf in _sequence(direct["leaves"]):
+            for raw_index in _sequence(_mapping(raw_leaf)["input_indices"]):
+                binding = _mapping(bindings[int(raw_index)])
+                if binding["kind"] != "momentum":
+                    continue
+                component = int(binding["global_component"]) - value_component_count
+                if not 0 <= component < momentum_component_count:
+                    raise ValueError(
+                        "compiled momentum input is outside momentum slots"
+                    )
+                live.add(component // 4)
+    return sorted(live)
+
+
+def _prefix_evaluator_payload_paths(
+    record: Mapping[str, object],
+    prefix: str,
+) -> dict[str, object]:
+    path_fields = {
+        "application_path",
+        "descriptor_path",
+        "evaluator_state_path",
+        "library_path",
+        "source_path",
+    }
+
+    def visit(value: object, *, field: str | None = None) -> object:
+        if field in path_fields and value is not None:
+            if not isinstance(value, str):
+                raise TypeError(f"evaluator payload path {field!r} must be a string")
+            path = Path(value)
+            if path.is_absolute() or ".." in path.parts:
+                raise ValueError(
+                    f"evaluator payload path {value!r} is not artifact-relative"
+                )
+            return f"{prefix.rstrip('/')}/{path.as_posix()}"
+        if isinstance(value, Mapping):
+            return {
+                str(key): visit(item, field=str(key)) for key, item in value.items()
+            }
+        if isinstance(value, list):
+            return [visit(item) for item in value]
+        if isinstance(value, tuple):
+            return [visit(item) for item in value]
+        return value
+
+    result = visit(record)
+    if not isinstance(result, dict):  # pragma: no cover - internal invariant
+        raise TypeError("compiled evaluator manifest must be an object")
+    return result
+
+
+def _execution_plan(schema: Mapping[str, object]) -> dict[str, object]:
+    source_fill = _mapping(schema["source_fill"])
+    source_records = tuple(_mapping(item) for item in _sequence(source_fill["sources"]))
+    source_count = (
+        int(source_records[-1]["source_parameter_stop"]) if source_records else 0
+    )
+    parameter_layout = _mapping(schema["parameter_layout"])
+    value_count = int(parameter_layout["value_component_count"])
+    momentum_count = int(parameter_layout["momentum_parameter_count"])
+    model_parameter_count = int(parameter_layout.get("model_parameter_count", 0))
+    parameters = tuple(
+        _execution_model_parameter(_mapping(item))
+        for item in _sequence(schema.get("model_parameters", ()))
+    )
+    mass_parameters = {
+        int(item["pdg"]): str(item["name"])
+        for item in parameters
+        if item["kind"] == "particle_mass" and item.get("pdg") is not None
+    }
+    model = _mapping(schema.get("model", {}))
+    particles = tuple(_mapping(item) for item in _sequence(model.get("particles", ())))
+    normalization = _mapping(schema.get("normalization", {}))
+    return {
+        "schema_version": PROCESS_ARTIFACT_SCHEMA_VERSION,
+        "kind": "pyamplicol-runtime-execution-plan",
+        "process_key": str(schema["process_key"]),
+        "process": str(schema["process"]),
+        "external_particles": [
+            _select(
+                _mapping(item),
+                "label",
+                "index",
+                "pdg",
+                "outgoing_pdg",
+                "role",
+                "momentum_slot",
+            )
+            for item in _sequence(schema["external_particles"])
+        ],
+        "model": {
+            "particles": [
+                {
+                    "pdg": int(particle["pdg"]),
+                    "mass": float(particle.get("mass", 0.0)),
+                    "mass_parameter": (
+                        str(particle["mass_parameter"])
+                        if particle.get("mass_parameter") is not None
+                        else mass_parameters.get(int(particle["pdg"]))
+                    ),
+                }
+                for particle in particles
+            ]
+        },
+        "model_parameters": list(parameters),
+        "normalization": {
+            "color_factor": float(normalization.get("color_factor", 1.0)),
+            "global_coupling_factor": float(
+                normalization.get("global_coupling_factor", 1.0)
+            ),
+            "average_factor": float(normalization.get("average_factor", 1.0)),
+            "identical_factor": float(normalization.get("identical_factor", 1.0)),
+            "qcd_coupling_power": int(normalization.get("qcd_coupling_power", 0)),
+            "electroweak_coupling_power": int(
+                normalization.get("electroweak_coupling_power", 0)
+            ),
+        },
+        "parameter_layout": {
+            "source_component_parameter_count": source_count,
+            "momentum_parameter_count": momentum_count,
+            "model_parameter_count": model_parameter_count,
+            "parameter_count_if_flattened": (
+                source_count + momentum_count + model_parameter_count
+            ),
+            "value_component_count": value_count,
+            "source_components_complex": True,
+            "momentum_components_real": True,
+            "real_valued_inputs": list(
+                range(
+                    source_count,
+                    source_count + momentum_count + model_parameter_count,
+                )
+            ),
+        },
+        "current_storage": _current_storage(_mapping(schema["current_storage"])),
+        "value_storage": _value_storage(_mapping(schema["value_storage"])),
+        "source_fill": {
+            "source_count": int(source_fill["source_count"]),
+            "sources": [_source_record(item) for item in source_records],
+        },
+        "momentum_slots": [
+            _select(
+                _mapping(item),
+                "momentum_slot_id",
+                "momentum_mask",
+                "external_labels",
+                "component_start",
+                "component_stop",
+                "real_valued",
+            )
+            for item in _sequence(schema["momentum_slots"])
+        ],
+        "stages": [
+            _runtime_stage(_mapping(item)) for item in _sequence(schema["stages"])
+        ],
+        "amplitude_stage": _amplitude_stage(_mapping(schema["amplitude_stage"])),
+        **(
+            {}
+            if schema.get("helicity_recurrence") is None
+            else {
+                "helicity_recurrence": _plain_mapping(
+                    _mapping(schema["helicity_recurrence"])
+                )
+            }
+        ),
+    }
+
+
+def _execution_model_parameter(record: Mapping[str, object]) -> dict[str, object]:
+    result = _select(record, "name", "kind", "parameter_index", "default")
+    for name in ("pdg", "runtime_name", "complex_component"):
+        if record.get(name) is not None:
+            result[name] = record[name]
+    return result
+
+
+def _current_storage(storage: Mapping[str, object]) -> dict[str, object]:
+    fields = (
+        "current_id",
+        "component_start",
+        "component_stop",
+        "dimension",
+        "is_source",
+        "particle_id",
+        "external_mask",
+        "external_labels",
+        "helicity_ancestry",
+        "chirality",
+        "spin_state",
+        "flavour_flow",
+        "color_state",
+        "momentum_mask",
+        "auxiliary_kind",
+    )
+    return {
+        "component_count": int(storage["component_count"]),
+        "number_type": str(storage["number_type"]),
+        "metadata_compacted": True,
+        "current_slots": [
+            _select(_mapping(item), *fields)
+            for item in _sequence(storage["current_slots"])
+        ],
+    }
+
+
+def _value_storage(storage: Mapping[str, object]) -> dict[str, object]:
+    fields = (
+        "value_slot_id",
+        "current_id",
+        "variant",
+        "component_start",
+        "component_stop",
+        "dimension",
+        "current_component_start",
+        "current_component_stop",
+        "is_source",
+        "applies_propagator",
+        "particle_id",
+        "external_mask",
+        "external_labels",
+        "momentum_mask",
+        "chirality",
+        "propagator",
+    )
+    return {
+        "component_count": int(storage["component_count"]),
+        "number_type": str(storage["number_type"]),
+        "metadata_compacted": True,
+        "value_slots": [
+            _select(_mapping(item), *fields)
+            for item in _sequence(storage["value_slots"])
+        ],
+    }
+
+
+def _source_record(record: Mapping[str, object]) -> dict[str, object]:
+    return _select(
+        record,
+        "source_id",
+        "current_id",
+        "current_component_start",
+        "current_component_stop",
+        "value_slot",
+        "source_parameter_start",
+        "source_parameter_stop",
+        "leg_label",
+        "input_momentum_slot",
+        "side",
+        "crossing",
+        "physical_pdg",
+        "outgoing_pdg",
+        "particle_id",
+        "anti_particle_id",
+        "source_kind",
+        "wavefunction_kind",
+        "source_orientation",
+        "source_basis",
+        "source_ir",
+        "applied_crossing",
+        "source_helicity",
+        "chirality",
+        "spin_state",
+        "dimension",
+        "helicity_ancestry",
+        "color_state",
+    )
+
+
+def _runtime_stage(stage: Mapping[str, object]) -> dict[str, object]:
+    interactions_compacted = bool(stage.get("interactions_compacted", False))
+    interaction_ids = (
+        [int(value) for value in _sequence(stage.get("interaction_ids", []))]
+        if interactions_compacted
+        else [
+            int(_mapping(item)["interaction_id"])
+            for item in _sequence(stage["interactions"])
+        ]
+    )
+    if len(interaction_ids) != int(stage["interaction_count"]):
+        raise ValueError("runtime stage interaction count is inconsistent")
+    return {
+        **_select(
+            stage,
+            "stage_index",
+            "stage_kind",
+            "subset_size",
+            "input_current_ids",
+            "output_current_ids",
+            "input_value_slot_ids",
+            "output_value_slot_ids",
+            "interaction_count",
+        ),
+        "interactions_compacted": True,
+        "interaction_ids": interaction_ids,
+        "interactions": [],
+    }
+
+
+def _amplitude_stage(stage: Mapping[str, object]) -> dict[str, object]:
+    contraction = stage.get("color_contraction")
+    color_topology_replay = stage.get("color_topology_replay")
+    return {
+        "stage_kind": str(stage["stage_kind"]),
+        "output_count": int(stage["output_count"]),
+        "color_contraction": (
+            None if contraction is None else _color_contraction(_mapping(contraction))
+        ),
+        "color_topology_replay": (
+            None
+            if color_topology_replay is None
+            else _plain_mapping(_mapping(color_topology_replay))
+        ),
+        "roots": [
+            _select(
+                _mapping(root),
+                "output_index",
+                "root_id",
+                "kind",
+                "left_current_id",
+                "right_current_id",
+                "left_slot",
+                "right_slot",
+                "left_value_slot",
+                "right_value_slot",
+                "vertex_kind",
+                "vertex_particles",
+                "coupling",
+                "color_weight",
+                "color_sector_id",
+                "contraction",
+                "contraction_ir",
+                "coherent_group_id",
+                "helicity_weight",
+                "all_sector_weight",
+            )
+            for root in _sequence(stage["roots"])
+        ],
+    }
+
+
+def _color_contraction(record: Mapping[str, object]) -> dict[str, object]:
+    result: dict[str, object] = {
+        **_select(record, "supported", "reason", "group_count"),
+        "includes_color_factor": bool(record.get("includes_color_factor", False)),
+        "entries": [
+            _color_contraction_entry(
+                _mapping(item),
+                "left_group_id",
+                "right_group_id",
+            )
+            for item in _sequence(record["entries"])
+        ],
+    }
+    repeated_block = record.get("repeated_block")
+    if repeated_block is not None:
+        repeated = _mapping(repeated_block)
+        compact: dict[str, object] = {
+            "component_count": int(repeated["component_count"]),
+            "component_group_ids": [
+                int(value) for value in _sequence(repeated["component_group_ids"])
+            ],
+            "entries": [
+                _color_contraction_entry(
+                    _mapping(item),
+                    "left_group_index",
+                    "right_group_index",
+                )
+                for item in _sequence(repeated["entries"])
+            ],
+        }
+        factorized_block = repeated.get("factorized_block")
+        if factorized_block is not None:
+            factorized = _mapping(factorized_block)
+            compact_factorized: dict[str, object] = {
+                "kind": str(factorized["kind"]),
+            }
+            if "rank" in factorized:
+                compact_factorized["rank"] = int(factorized["rank"])
+            compact_factorized["cosets"] = [
+                [int(value) for value in _sequence(coset)]
+                for coset in _sequence(factorized["cosets"])
+            ]
+            compact["factorized_block"] = compact_factorized
+        result["repeated_block"] = compact
+    return result
+
+
+def _color_contraction_entry(
+    record: Mapping[str, object], left: str, right: str
+) -> dict[str, object]:
+    result = _select(record, left, right, "weight", "symmetry_factor")
+    if "exact_weight" in record:
+        result["exact_weight"] = record["exact_weight"]
+    return result
+
+
+def _stage_evaluator_set(record: Mapping[str, object]) -> dict[str, object]:
+    result = {
+        **_select(
+            record,
+            "kind",
+            "runtime_available",
+            "runtime_unavailable_message",
+            "parameter_count",
+            "value_parameter_count",
+            "momentum_parameter_count",
+            "model_parameter_count",
+            "real_valued_inputs",
+            "parameter_layout",
+            "stage_count",
+            "required_runtime_capabilities",
+        ),
+        "stages": [
+            _serialized_stage(_mapping(item)) for item in _sequence(record["stages"])
+        ],
+        "amplitude_stage": _serialized_stage(_mapping(record["amplitude_stage"])),
+    }
+    evaluator_manifests = [
+        _mapping(_mapping(stage)["evaluator"])
+        for stage in (*_sequence(result["stages"]), result["amplitude_stage"])
+    ]
+    actual = tuple(
+        sorted(
+            {
+                capability
+                for manifest in evaluator_manifests
+                for capability in evaluator_runtime_capabilities(manifest)
+            }
+        )
+    )
+    declared = set(_required_runtime_capabilities(result))
+    direct_stages = [
+        stage.get("compiled_plane_arena") is not None
+        for stage in (*_sequence(result["stages"]), result["amplitude_stage"])
+    ]
+    has_direct_capability = COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY in declared
+    direct_evaluator_capabilities = {
+        SYMJIT_F64_RUNTIME_CAPABILITY,
+        SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+        SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    }
+    if set(actual) & direct_evaluator_capabilities and not bool(
+        direct_stages and all(direct_stages)
+    ):
+        raise ValueError(
+            "compiled f64 artifacts require compiled-plane-arena-v1 metadata "
+            "for every fused stage"
+        )
+    if has_direct_capability != bool(direct_stages and all(direct_stages)):
+        raise ValueError(
+            "compiled plane-arena capability and fused-stage metadata disagree"
+        )
+    if any(direct_stages) and not all(direct_stages):
+        raise ValueError("compiled plane-arena metadata must cover every fused stage")
+    evaluator_capabilities = declared - {
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+        COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+    }
+    if set(actual) != evaluator_capabilities:
+        raise ValueError(
+            "stage evaluator runtime capabilities do not match evaluator payloads"
+        )
+    return result
+
+
+def _serialized_stage(record: Mapping[str, object]) -> dict[str, object]:
+    result = {
+        **_select(
+            record,
+            "stage_index",
+            "stage_kind",
+            "subset_size",
+            "evaluator_label",
+            "parameter_layout",
+            "output_length",
+            "output_slots",
+            "input_value_slot_ids",
+            "output_value_slot_ids",
+            "interaction_ids",
+            "input_components",
+            "parameter_count",
+            "value_parameter_count",
+            "momentum_parameter_count",
+            "model_parameter_count",
+            "real_valued_inputs",
+            "expression_ready",
+            "blockers",
+        ),
+        "evaluator": _evaluator(_mapping(record["evaluator"])),
+    }
+    direct = record.get("compiled_plane_arena")
+    if direct is not None:
+        result["compiled_plane_arena"] = _compiled_plane_arena_stage(
+            _mapping(direct),
+            stage=result,
+        )
+    return result
+
+
+def _compiled_plane_arena_stage(
+    record: Mapping[str, object],
+    *,
+    stage: Mapping[str, object],
+) -> dict[str, object]:
+    result = {
+        **_select(
+            record,
+            "schema_version",
+            "kind",
+            "application_abi",
+            "source_application_abi",
+            "element_layout",
+            "output_operation",
+            "output_factor",
+            "input_output_aliasing",
+            "output_output_aliasing",
+        ),
+        "input_bindings": [
+            _select(
+                _mapping(item),
+                "parameter_index",
+                "kind",
+                "source_id",
+                "component",
+                "global_component",
+                "real_valued",
+            )
+            for item in _sequence(record["input_bindings"])
+        ],
+        "output_bindings": [
+            _select(
+                _mapping(item),
+                "output_index",
+                "arena",
+                "component",
+            )
+            for item in _sequence(record["output_bindings"])
+        ],
+        "leaves": [
+            _select(
+                _mapping(item),
+                "application_path",
+                "source_application_abi",
+                "optimization_level",
+                "direct_codegen_optimization_level",
+                "input_len",
+                "output_len",
+                "input_indices",
+                "output_start",
+                "output_stop",
+            )
+            for item in _sequence(record["leaves"])
+        ],
+    }
+    symjit_contract = (
+        result["application_abi"] == COMPILED_PLANE_DIRECT_APPLICATION_ABI
+        and result["source_application_abi"] == SYMJIT_PLANE_APPLICATION_ABI
+    )
+    native_contract = (
+        result["application_abi"] == NATIVE_COMPILED_DIRECT_APPLICATION_ABI
+        and result["source_application_abi"] == NATIVE_COMPILED_DIRECT_APPLICATION_ABI
+    )
+    if (
+        result["schema_version"] != 1
+        or result["kind"] != "compiled-plane-arena-stage"
+        or not (symjit_contract or native_contract)
+        or result["element_layout"] != "split-complex-component-major"
+        or result["output_operation"] != "overwrite"
+        or result["output_factor"] != "identity"
+        or result["input_output_aliasing"] != "forbidden"
+        or result["output_output_aliasing"] != "forbidden"
+    ):
+        raise ValueError("compiled plane-arena stage contract is incompatible")
+    if len(result["input_bindings"]) != int(stage["parameter_count"]):
+        raise ValueError("compiled plane-arena input binding count is invalid")
+    if len(result["output_bindings"]) != int(stage["output_length"]):
+        raise ValueError("compiled plane-arena output binding count is invalid")
+    if not result["leaves"]:
+        raise ValueError("compiled plane-arena stage has no fused leaves")
+    output_cursor = 0
+    for leaf in result["leaves"]:
+        leaf_map = _mapping(leaf)
+        input_indices = list(_sequence(leaf_map["input_indices"]))
+        if (
+            leaf_map["source_application_abi"] != result["source_application_abi"]
+            or (
+                symjit_contract
+                and leaf_map["direct_codegen_optimization_level"]
+                != leaf_map["optimization_level"]
+            )
+            or (native_contract and leaf_map["direct_codegen_optimization_level"] != 3)
+            or len(input_indices) != int(leaf_map["input_len"])
+            or leaf_map["output_start"] != output_cursor
+            or leaf_map["output_stop"] != output_cursor + int(leaf_map["output_len"])
+        ):
+            raise ValueError("compiled plane-arena leaf bindings are invalid")
+        output_cursor = int(leaf_map["output_stop"])
+    if output_cursor != int(stage["output_length"]):
+        raise ValueError("compiled plane-arena leaves do not cover stage outputs")
+    return result
+
+
+def _model_parameter_evaluator(record: Mapping[str, object]) -> dict[str, object]:
+    result = {
+        **_select(
+            record,
+            "kind",
+            "required_runtime_capabilities",
+            "input_parameter_indices",
+            "outputs",
+        ),
+        "evaluator": _evaluator(_mapping(record["evaluator"])),
+    }
+    if evaluator_runtime_capabilities(_mapping(result["evaluator"])) != (
+        _required_runtime_capabilities(result)
+    ):
+        raise ValueError(
+            "model-parameter evaluator runtime capabilities do not match its payload"
+        )
+    return result
+
+
+def _evaluator(record: Mapping[str, object]) -> dict[str, object]:
+    kind = str(record.get("kind", ""))
+    if kind == "symjit-application-evaluator":
+        result = _select(
+            record,
+            "kind",
+            "runtime_capability",
+            "input_len",
+            "output_len",
+            "application_path",
+            "application_abi",
+            "element_layout",
+            "batch_layout",
+            "compiler_type",
+            "translation_mode",
+            "optimization_level",
+            "word_bits",
+            "endianness",
+            "required_defuns",
+            "evaluator_state_path",
+            "evaluator_state_runtime_capability",
+        )
+        if result["runtime_capability"] != SYMJIT_F64_RUNTIME_CAPABILITY:
+            raise ValueError(
+                "direct SymJIT evaluator has an invalid runtime capability"
+            )
+        if result["application_abi"] != SYMJIT_APPLICATION_ABI:
+            raise ValueError(
+                "direct SymJIT evaluator has an incompatible application ABI"
+            )
+        if (
+            result["evaluator_state_runtime_capability"]
+            != SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY
+        ):
+            raise ValueError(
+                "direct SymJIT evaluator has an invalid fallback capability"
+            )
+        if result["element_layout"] != "complex-f64":
+            raise ValueError("direct SymJIT evaluator has an invalid element layout")
+        if (
+            result["batch_layout"] != "row-major"
+            or result["compiler_type"] != "native"
+            or result["word_bits"] != 64
+            or result["endianness"] != "little"
+            or result["required_defuns"] != []
+        ):
+            raise ValueError("direct SymJIT evaluator has invalid execution metadata")
+        if result["translation_mode"] not in {"direct", "indirect"}:
+            raise ValueError("direct SymJIT evaluator has an invalid translation mode")
+        optimization_level = result["optimization_level"]
+        if (
+            isinstance(optimization_level, bool)
+            or not isinstance(optimization_level, int)
+            or optimization_level not in {0, 1, 2, 3}
+        ):
+            raise ValueError(
+                "direct SymJIT evaluator has an invalid optimization level"
+            )
+        plane = record.get("plane_application")
+        if not isinstance(plane, Mapping):
+            raise ValueError(
+                "direct SymJIT evaluator predates the SymJIT 2.22 plane "
+                "binding ABI; regenerate this artifact"
+            )
+        result["plane_application"] = _symjit_plane_application(
+            plane,
+            input_complex_count=int(result["input_len"]),
+            output_complex_count=int(result["output_len"]),
+        )
+        return result
+    if kind == "jit-symbolica-evaluator":
+        result = _select(
+            record,
+            "kind",
+            "runtime_capability",
+            "input_len",
+            "output_len",
+            "evaluator_state_path",
+        )
+        if result["runtime_capability"] != SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY:
+            raise ValueError("legacy JIT evaluator has an invalid runtime capability")
+        return result
+    if kind == "compiled-complex-evaluator":
+        result = _select(
+            record,
+            "kind",
+            "runtime_capability",
+            "function_name",
+            "input_len",
+            "output_len",
+            "library_path",
+            "evaluator_state_path",
+            "number_type",
+        )
+        if result["runtime_capability"] not in {
+            SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+            SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+        }:
+            raise ValueError("compiled evaluator has an invalid runtime capability")
+        direct = record.get("native_direct_application")
+        if direct is not None:
+            if result["runtime_capability"] not in {
+                SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+                SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+            }:
+                raise ValueError(
+                    "native DirectApplication metadata requires a compiled "
+                    "C++ or ASM evaluator"
+                )
+            direct_application = _native_compiled_direct_application(
+                _mapping(direct),
+                expected_function_name=str(result["function_name"]),
+                expected_output_count=int(result["output_len"]),
+            )
+            if result["library_path"] != direct_application["library_path"]:
+                raise ValueError(
+                    "compiled process DirectApplication must be the sole native "
+                    "library payload; dense/direct dual production is forbidden"
+                )
+            result["native_direct_application"] = direct_application
+        return result
+    if kind == "chunked-symbolica-evaluator":
+        result = {
+            "kind": kind,
+            "input_len": record["input_len"],
+            "chunk_input_indices": [
+                list(_sequence(indices))
+                for indices in _sequence(record["chunk_input_indices"])
+            ],
+            "required_runtime_capabilities": list(
+                _required_runtime_capabilities(record)
+            ),
+            "chunks": [
+                _evaluator(_mapping(item)) for item in _sequence(record["chunks"])
+            ],
+        }
+        actual = evaluator_runtime_capabilities(result)
+        if actual != _required_runtime_capabilities(record):
+            raise ValueError(
+                "chunked evaluator required runtime capabilities do not match chunks"
+            )
+        return result
+    raise ValueError(f"unsupported evaluator artifact kind {kind!r}")
+
+
+def _symjit_plane_application(
+    record: Mapping[str, object],
+    *,
+    input_complex_count: int,
+    output_complex_count: int,
+) -> dict[str, object]:
+    result = _select(
+        record,
+        "application_path",
+        "application_abi",
+        "storage_abi",
+        "element_layout",
+        "descriptor_order",
+        "input_complex_count",
+        "output_complex_count",
+        "input_plane_count",
+        "output_plane_count",
+        "compiler_type",
+        "translation_mode",
+        "optimization_level",
+        "simd",
+        "complex",
+        "fast_math",
+        "fast_complex",
+        "compression",
+        "threading",
+        "direct_arena",
+        "source_digest",
+        "target",
+    )
+    expected = {
+        "application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+        "storage_abi": SYMJIT_APPLICATION_ABI,
+        "element_layout": "split-complex-plane-major",
+        "descriptor_order": "inputs-re-im-then-outputs-re-im",
+        "input_complex_count": input_complex_count,
+        "output_complex_count": output_complex_count,
+        "input_plane_count": 2 * input_complex_count,
+        "output_plane_count": 2 * output_complex_count,
+        "compiler_type": "native",
+        "translation_mode": "symbolica-structured-instructions",
+        "simd": True,
+        "complex": True,
+        "fast_math": True,
+        "fast_complex": False,
+        "threading": False,
+        "direct_arena": True,
+    }
+    for field, expected_value in expected.items():
+        if result[field] != expected_value:
+            raise ValueError(
+                f"direct SymJIT plane application {field} is incompatible; "
+                "regenerate this artifact"
+            )
+    path = result["application_path"]
+    digest = result["source_digest"]
+    optimization_level = result["optimization_level"]
+    if not isinstance(path, str) or not path:
+        raise ValueError("direct SymJIT plane application path is invalid")
+    if (
+        not isinstance(digest, str)
+        or len(digest) != 64
+        or any(character not in "0123456789abcdef" for character in digest)
+    ):
+        raise ValueError("direct SymJIT plane source digest is invalid")
+    if (
+        isinstance(optimization_level, bool)
+        or not isinstance(optimization_level, int)
+        or optimization_level not in {0, 1, 2, 3}
+    ):
+        raise ValueError("direct SymJIT plane optimization level is invalid")
+    if not isinstance(result["compression"], bool):
+        raise ValueError("direct SymJIT plane compression flag is invalid")
+    target = _mapping(result["target"])
+    if target.get("word_bits") != 64 or target.get("endianness") != "little":
+        raise ValueError("direct SymJIT plane target is incompatible")
+    result["target"] = _plain_mapping(target)
+    return result
+
+
+def _native_compiled_direct_application(
+    record: Mapping[str, object],
+    *,
+    expected_function_name: str,
+    expected_output_count: int,
+) -> dict[str, object]:
+    result = _select(
+        record,
+        "application_abi",
+        "function_name",
+        "source_path",
+        "library_path",
+        "target",
+        "evaluator_state_sha256",
+        "instruction_count",
+        "temporary_count",
+        "input_plane_count",
+        "scalar_input_count",
+        "output_plane_count",
+        "simd_lane_width",
+        "logical_stack_bytes",
+        "output_semantics",
+    )
+    if result["application_abi"] != NATIVE_COMPILED_DIRECT_APPLICATION_ABI:
+        raise ValueError("native DirectApplication has an incompatible ABI")
+    if result["function_name"] != expected_function_name:
+        raise ValueError(
+            "native DirectApplication function identity does not match its evaluator"
+        )
+    target = _mapping(result["target"])
+    triple = target.get("triple")
+    cpu_features = target.get("cpu_features")
+    if (
+        not isinstance(triple, str)
+        or triple not in _SUPPORTED_ARTIFACT_TARGETS
+        or isinstance(cpu_features, str | bytes)
+        or not isinstance(cpu_features, Sequence)
+    ):
+        raise ValueError("native DirectApplication target metadata is invalid")
+    features = [str(item) for item in cpu_features]
+    if features != sorted(set(features)) or any(not item for item in features):
+        raise ValueError(
+            "native DirectApplication CPU features must be sorted and unique"
+        )
+    result["target"] = {
+        "triple": triple,
+        "cpu_features": features,
+    }
+    digest = result["evaluator_state_sha256"]
+    if (
+        not isinstance(digest, str)
+        or len(digest) != 64
+        or any(character not in "0123456789abcdef" for character in digest)
+    ):
+        raise ValueError("native DirectApplication evaluator-state digest is invalid")
+    for name, minimum in (
+        ("instruction_count", 1),
+        ("temporary_count", 0),
+        ("input_plane_count", 1),
+        ("scalar_input_count", 0),
+        ("output_plane_count", 2),
+        ("logical_stack_bytes", 1),
+    ):
+        value = result[name]
+        if isinstance(value, bool) or not isinstance(value, int) or value < minimum:
+            raise ValueError(
+                f"native DirectApplication {name.replace('_', ' ')} is invalid"
+            )
+    if result["output_plane_count"] != expected_output_count * 2:
+        raise ValueError(
+            "native DirectApplication output planes do not match evaluator outputs"
+        )
+    if result["simd_lane_width"] not in {2, 4}:
+        raise ValueError("native DirectApplication SIMD width is unsupported")
+    if result["logical_stack_bytes"] > 64 * 1024:
+        raise ValueError("native DirectApplication logical stack exceeds 64 KiB")
+    if result["output_semantics"] != "factor-free-overwrite":
+        raise ValueError("native DirectApplication output semantics are incompatible")
+    for name in ("source_path", "library_path"):
+        value = result[name]
+        if not isinstance(value, str):
+            raise ValueError(f"native DirectApplication {name} must be a string")
+        path = Path(value)
+        if path.is_absolute() or ".." in path.parts:
+            raise ValueError(
+                f"native DirectApplication {name} must be artifact-relative"
+            )
+    return result
+
+
+def _dag_summary(
+    record: Mapping[str, object],
+    *,
+    require_interaction_evaluation_count: bool = False,
+) -> dict[str, object]:
+    result = _select(
+        record,
+        "current_count",
+        "source_count",
+        "interaction_count",
+        "amplitude_root_count",
+        "truncated",
+    )
+    interaction_evaluation_count = record.get("interaction_evaluation_count")
+    if interaction_evaluation_count is None:
+        if require_interaction_evaluation_count:
+            raise ValueError(
+                "compiled DAG summary is missing interaction_evaluation_count"
+            )
+    else:
+        result["interaction_evaluation_count"] = interaction_evaluation_count
+    return result
+
+
+def _fully_resident_materialization_census(
+    counts: Mapping[str, object],
+    *,
+    basis: str,
+) -> dict[str, object]:
+    exact = {
+        str(name): value
+        for name, value in counts.items()
+        if str(name).endswith("_count")
+    }
+    if not exact:
+        raise ValueError("fully resident materialization has no exact counters")
+    for name, value in exact.items():
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise ValueError(
+                f"fully resident materialization counter {name!r} is invalid"
+            )
+    return {
+        "abi": "pyamplicol-fully-resident-materialization-census-v1",
+        "basis": basis,
+        "final": exact,
+        "peak": dict(exact),
+        "final_equals_peak": True,
+    }
+
+
+def _eager_materialization_census(
+    process: EagerPlanV3ProcessArtifact,
+) -> dict[str, object]:
+    inspection = process.inspection_summary
+    counts: dict[str, object] = {
+        "source_count": process.dag_summary["source_count"],
+        "current_count": process.dag_summary["current_count"],
+        "interaction_count": process.dag_summary["interaction_count"],
+        "amplitude_root_count": process.dag_summary["amplitude_root_count"],
+    }
+    for name in (
+        "invocation_count",
+        "attachment_count",
+        "closure_count",
+        "finalization_count",
+    ):
+        value = inspection.get(name)
+        if value is not None:
+            counts[name] = value
+    return _fully_resident_materialization_census(
+        counts,
+        basis="immutable-fully-resident-eager-plan",
+    )
+
+
+def _select(record: Mapping[str, object], *names: str) -> dict[str, object]:
+    missing = [name for name in names if name not in record]
+    if missing:
+        raise ValueError(
+            "runtime execution record is missing fields: " + ", ".join(missing)
+        )
+    return {name: record[name] for name in names}
+
+
+def _sequence(value: object) -> Sequence[object]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise TypeError("runtime execution field must be a sequence")
+    return value
+
+
+def _copy_evaluator_payloads(
+    evaluator_payloads: _EvaluatorPayloadCollector,
+    root: Path,
+    *,
+    prefix: str,
+    process_id: str,
+) -> None:
+    source_root = root.expanduser().resolve(strict=True)
+    for path in sorted(source_root.rglob("*")):
+        if not path.is_file():
+            continue
+        relative = path.relative_to(source_root).as_posix()
+        evaluator_payloads.add_file(
+            f"{prefix}/{relative}",
+            path,
+            process_id=process_id,
+        )
+
+
+def _copy_color_selector_evaluator_payloads(
+    evaluator_payloads: _EvaluatorPayloadCollector,
+    executions: Sequence[CompiledColorSelectorExecutionArtifact],
+    *,
+    prefix: str,
+    process_id: str,
+) -> None:
+    for record in _ordered_color_selector_executions(executions):
+        _copy_evaluator_payloads(
+            evaluator_payloads,
+            record.execution.evaluator_root,
+            prefix=(
+                f"{prefix}/{_color_selector_payload_prefix(record.materialized_sector_id)}"
+            ),
+            process_id=process_id,
+        )
+
+
+def _copy_helicity_selector_evaluator_payloads(
+    evaluator_payloads: _EvaluatorPayloadCollector,
+    executions: Sequence[CompiledHelicitySelectorExecutionArtifact],
+    *,
+    prefix: str,
+    process_id: str,
+) -> None:
+    for lane_index, record in enumerate(
+        _ordered_helicity_selector_executions(executions)
+    ):
+        lane_prefix = (
+            f"{prefix}/{_HELICITY_SELECTOR_UNION_PAYLOAD_ROOT}/class-{lane_index}"
+        )
+        _copy_evaluator_payloads(
+            evaluator_payloads,
+            record.execution.evaluator_root,
+            prefix=lane_prefix,
+            process_id=process_id,
+        )
+        _copy_helicity_selector_evaluator_payloads(
+            evaluator_payloads,
+            record.execution.helicity_selector_executions,
+            prefix=lane_prefix,
+            process_id=process_id,
+        )
+
+
+def _color_selector_payload_prefix(materialized_sector_id: int) -> str:
+    if materialized_sector_id < 0:
+        raise ValueError("materialized colour-sector ids must be non-negative")
+    return f"{_COLOR_SELECTOR_PAYLOAD_ROOT}/sector-{materialized_sector_id}"
+
+
+def _ordered_color_selector_executions(
+    executions: Sequence[CompiledColorSelectorExecutionArtifact],
+) -> tuple[CompiledColorSelectorExecutionArtifact, ...]:
+    ordered = tuple(
+        sorted(executions, key=lambda record: record.materialized_sector_id)
+    )
+    sector_ids = tuple(record.materialized_sector_id for record in ordered)
+    if len(sector_ids) != len(set(sector_ids)):
+        raise ValueError("compiled colour-selector lane ids must be unique")
+    for record in ordered:
+        if record.materialized_sector_id < 0:
+            raise ValueError("materialized colour-sector ids must be non-negative")
+        if record.execution.color_selector_executions:
+            raise ValueError("compiled colour-selector execution lanes cannot nest")
+    return ordered
+
+
+def _ordered_helicity_selector_executions(
+    executions: Sequence[CompiledHelicitySelectorExecutionArtifact],
+) -> tuple[CompiledHelicitySelectorExecutionArtifact, ...]:
+    ordered = tuple(sorted(executions, key=lambda record: record.selector_domain_ids))
+    seen: set[int] = set()
+    for record in ordered:
+        domain_ids = tuple(sorted(set(record.selector_domain_ids)))
+        if not domain_ids or domain_ids != record.selector_domain_ids:
+            raise ValueError(
+                "compiled helicity-selector domain ids must be non-empty, "
+                "sorted, and unique"
+            )
+        overlap = seen.intersection(domain_ids)
+        if overlap:
+            raise ValueError(
+                "compiled helicity-selector lanes overlap selector domains: "
+                + ", ".join(str(item) for item in sorted(overlap))
+            )
+        seen.update(domain_ids)
+        if record.schedule_mode not in {"parent-closure", "nested-runtime"}:
+            raise ValueError(
+                "compiled helicity-selector schedule mode must be "
+                "'parent-closure' or 'nested-runtime'"
+            )
+        if record.execution.color_selector_executions:
+            raise ValueError("compiled helicity-selector execution lanes cannot nest")
+        children = record.execution.helicity_selector_executions
+        if children:
+            if record.schedule_mode != "nested-runtime":
+                raise ValueError(
+                    "only a nested-runtime helicity-selector execution may "
+                    "contain closure lanes"
+                )
+            for child in _ordered_helicity_selector_executions(children):
+                if (
+                    child.schedule_mode != "parent-closure"
+                    or child.execution.helicity_selector_executions
+                    or child.execution.color_selector_executions
+                ):
+                    raise ValueError(
+                        "nested helicity-selector closure lanes must be "
+                        "terminal parent-closure executions"
+                    )
+    return ordered
+
+
+def build_api_validation_points(
+    processes: Sequence[ProcessArtifact],
+) -> dict[str, tuple[tuple[float, float, float, float], ...]]:
+    """Return concrete and crossing-alias points in each public external order."""
+
+    points: dict[str, tuple[tuple[float, float, float, float], ...]] = {}
+    for process in processes:
+        vectors = process.validation_point.four_vectors
+        if not vectors:
+            continue
+        points[process.process_id] = vectors
+        _add_alias_points(points, vectors=vectors, aliases=process.aliases)
+    return points
+
+
+def _existing_bundle_points(
+    existing: ArtifactManifest | None,
+) -> dict[str, tuple[tuple[float, float, float, float], ...]]:
+    if existing is None:
+        return {}
+    points: dict[str, tuple[tuple[float, float, float, float], ...]] = {}
+    for process in existing.processes:
+        process_id = str(process["id"])
+        validation_path = (
+            existing.root / f"processes/{process_id}/validation-momenta.json"
+        )
+        if not validation_path.is_file():
+            continue
+        payload = json.loads(validation_path.read_text(encoding="utf-8"))
+        raw_points = payload.get("points") if isinstance(payload, Mapping) else None
+        if not isinstance(raw_points, list) or not raw_points:
+            continue
+        raw_point = raw_points[0]
+        if not isinstance(raw_point, list):
+            raise ValueError(f"validation point for {process_id!r} is invalid")
+        vectors = tuple(_validation_four_vector(item) for item in raw_point)
+        points[process_id] = vectors
+        aliases = process.get("aliases")
+        if not isinstance(aliases, Sequence):
+            raise ValueError(f"aliases for {process_id!r} are invalid")
+        _add_alias_points(
+            points,
+            vectors=vectors,
+            aliases=tuple(_mapping(alias) for alias in aliases),
+        )
+    return points
+
+
+def _add_alias_points(
+    points: dict[str, tuple[tuple[float, float, float, float], ...]],
+    *,
+    vectors: tuple[tuple[float, float, float, float], ...],
+    aliases: Sequence[Mapping[str, object]],
+) -> None:
+    for alias in aliases:
+        alias_id = str(alias["id"])
+        raw_permutation = alias.get("external_permutation", ())
+        if not isinstance(raw_permutation, Sequence):
+            raise ValueError(f"alias {alias_id!r} permutation is invalid")
+        permutation = tuple(int(index) for index in raw_permutation)
+        if not permutation:
+            permutation = tuple(range(len(vectors)))
+        if sorted(permutation) != list(range(len(vectors))):
+            raise ValueError(
+                f"alias {alias_id!r} permutation does not match its external momenta"
+            )
+        if alias_id in points:
+            raise ValueError(f"duplicate validation-point ID {alias_id!r}")
+        alias_vectors: list[tuple[float, float, float, float] | None] = [
+            None for _ in vectors
+        ]
+        for representative_index, alias_index in enumerate(permutation):
+            alias_vectors[alias_index] = vectors[representative_index]
+        if any(vector is None for vector in alias_vectors):
+            raise ValueError(f"alias {alias_id!r} permutation is incomplete")
+        points[alias_id] = tuple(
+            vector for vector in alias_vectors if vector is not None
+        )
+
+
+def _validation_four_vector(
+    record: object,
+) -> tuple[float, float, float, float]:
+    raw = _mapping(record).get("momentum")
+    if not isinstance(raw, Sequence) or len(raw) != 4:
+        raise ValueError("serialized validation momentum is not a four-vector")
+    values = tuple(float(component) for component in raw)
+    return values[0], values[1], values[2], values[3]
+
+
+def _producer_metadata(
+    config: GenerationConfig | RunConfig,
+    *,
+    runtime_capabilities: Sequence[str] = (),
+    implicit_portable_jit_evidence: bool = False,
+) -> dict[str, object]:
+    version = package_version()
+    target, c_abi = _artifact_target_metadata(
+        config,
+        runtime_capabilities=runtime_capabilities,
+        implicit_portable_jit_evidence=implicit_portable_jit_evidence,
+    )
+    producer: dict[str, object] = {
+        "distribution": "pyamplicol",
+        "version": version,
+        "versions": {
+            "python_api": PYTHON_API_VERSION,
+            "toml": TOML_SCHEMA_VERSION,
+            "compiled_model": COMPILED_MODEL_SCHEMA_VERSION,
+            "process_artifact": PROCESS_ARTIFACT_SCHEMA_VERSION,
+            "runtime_physics": RUNTIME_PHYSICS_SCHEMA_VERSION,
+            "symbolica_serialization": SYMBOLICA_SERIALIZATION_ABI,
+            "c_abi": c_abi,
+        },
+        "target": target,
+    }
+    producer["native_build_inputs_sha256"] = active_native_build_inputs_sha256()
+    source_revision = active_source_revision()
+    if source_revision is not None:
+        producer["git_revision"] = source_revision
+    return producer
+
+
+def _artifact_target_metadata(
+    config: GenerationConfig | RunConfig,
+    *,
+    runtime_capabilities: Sequence[str] = (),
+    implicit_portable_jit_evidence: bool = False,
+) -> tuple[dict[str, object], int]:
+    target, c_abi = _target_metadata(config)
+    requested_portable_jit = (
+        implicit_portable_jit_evidence
+        if isinstance(config, GenerationConfig)
+        else (
+            str(config.evaluator.backend) == "jit"
+            and config.evaluator.jit.optimization_level in {1, 2}
+        )
+    )
+    portable_64le = requested_portable_jit and not {
+        SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+        SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+        SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+    }.intersection(runtime_capabilities)
+    if portable_64le:
+        target = {
+            "triple": PORTABLE_64LE_TARGET,
+            "cpu_features": [],
+        }
+    return target, c_abi
+
+
+def _implicit_generation_portable_jit_evidence(
+    processes: Sequence[ProcessArtifact],
+) -> bool:
+    if not processes or any(
+        not isinstance(process, CompiledProcessArtifact) for process in processes
+    ):
+        return False
+    records: list[Mapping[str, object]] = []
+    for process in cast(Sequence[CompiledProcessArtifact], processes):
+        records.append(process.stage_manifest)
+        if process.model_parameter_evaluator is not None:
+            records.append(process.model_parameter_evaluator)
+        for selector in process.color_selector_executions:
+            records.extend(_compiled_execution_evidence_records(selector.execution))
+        if process.helicity_sum_execution is not None:
+            records.extend(
+                _compiled_execution_evidence_records(process.helicity_sum_execution)
+            )
+        for selector in process.helicity_selector_executions:
+            records.extend(_compiled_execution_evidence_records(selector.execution))
+    evaluator_count = 0
+    for record in records:
+        valid, count = _mapping_has_only_portable_symjit_evaluators(record)
+        if not valid or count == 0:
+            return False
+        evaluator_count += count
+    return evaluator_count > 0
+
+
+def _compiled_execution_evidence_records(
+    execution: CompiledExecutionArtifact,
+) -> list[Mapping[str, object]]:
+    records: list[Mapping[str, object]] = [execution.stage_manifest]
+    if execution.model_parameter_evaluator is not None:
+        records.append(execution.model_parameter_evaluator)
+    for selector in execution.color_selector_executions:
+        records.extend(_compiled_execution_evidence_records(selector.execution))
+    for selector in execution.helicity_selector_executions:
+        records.extend(_compiled_execution_evidence_records(selector.execution))
+    return records
+
+
+def _mapping_has_only_portable_symjit_evaluators(
+    value: Mapping[str, object],
+) -> tuple[bool, int]:
+    evaluator_count = 0
+    valid = True
+
+    def visit(item: object) -> None:
+        nonlocal evaluator_count, valid
+        if not valid:
+            return
+        if isinstance(item, Mapping):
+            kind = item.get("kind")
+            if kind == "symjit-application-evaluator":
+                evaluator_count += 1
+                plane = item.get("plane_application")
+                if (
+                    item.get("optimization_level") not in (1, 2)
+                    or not isinstance(plane, Mapping)
+                    or plane.get("optimization_level") not in (1, 2)
+                ):
+                    valid = False
+                    return
+            elif kind in {"compiled-complex-evaluator", "jit-symbolica-evaluator"}:
+                valid = False
+                return
+            if item.get("source_application_abi") == SYMJIT_PLANE_APPLICATION_ABI:
+                for field in (
+                    "optimization_level",
+                    "direct_codegen_optimization_level",
+                ):
+                    if field in item and item[field] not in (1, 2):
+                        valid = False
+                        return
+            for nested in item.values():
+                visit(nested)
+            return
+        if isinstance(item, Sequence) and not isinstance(item, str | bytes):
+            for nested in item:
+                visit(nested)
+
+    visit(value)
+    return valid, evaluator_count
+
+
+def _target_metadata(
+    config: GenerationConfig | RunConfig,
+) -> tuple[dict[str, object], int]:
+    requires_native_features = (
+        isinstance(config, RunConfig)
+        and str(config.evaluator.backend) != "jit"
+        and config.evaluator.cpp.native_arch
+    )
+    try:
+        rusticol = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(rusticol)
+        info = rusticol.target_info()
+        triple = str(info.triple)
+        available_features = tuple(str(item) for item in info.cpu_features)
+        if available_features != tuple(sorted(set(available_features))):
+            raise RuntimeError(
+                "Rusticol returned non-canonical target CPU feature metadata"
+            )
+        c_abi = int(rusticol.abi_version())
+    except (
+        AttributeError,
+        ImportError,
+        OSError,
+        importlib.metadata.PackageNotFoundError,
+    ) as rusticol_error:
+        try:
+            from pyamplicol._sdk import load_sdk_info
+
+            sdk = load_sdk_info()
+        except (
+            ImportError,
+            OSError,
+            RuntimeError,
+            importlib.metadata.PackageNotFoundError,
+        ) as sdk_error:
+            raise RuntimeError(
+                "Rusticol target metadata is unavailable; install or build the "
+                "pyamplicol native extension before generating process artifacts"
+            ) from sdk_error
+        if requires_native_features:
+            raise RuntimeError(
+                "native C++ evaluator generation requires Rusticol CPU-feature "
+                "introspection; SDK target metadata alone is insufficient"
+            ) from rusticol_error
+        triple = sdk.target
+        available_features = ()
+        c_abi = int(sdk.abi_version)
+    required_features = available_features if requires_native_features else ()
+    if triple not in _SUPPORTED_ARTIFACT_TARGETS:
+        raise RuntimeError(
+            f"Rusticol process artifacts are not supported on target {triple!r}"
+        )
+    if requires_native_features and not required_features:
+        raise RuntimeError(
+            "Rusticol did not detect any CPU features for a native C++ evaluator; "
+            "refusing to emit incomplete target metadata"
+        )
+    return {
+        "triple": triple,
+        "cpu_features": list(required_features),
+    }, c_abi
+
+
+def _model_metadata(
+    source: ModelSource,
+    compiled: CompiledModel,
+) -> dict[str, object]:
+    source_kind = {
+        "built-in-sm": "built-in-sm",
+        "built-in-sm-heft": "built-in-sm-heft",
+        "ufo": "ufo",
+        "json": "ufo-json",
+        "compiled": "compiled-model",
+        "prepared": "compiled-model",
+    }[source.kind]
+    digest = str(compiled.source.get("digest", ""))
+    if source.kind == "compiled" and source.path is not None:
+        digest = hashlib.sha256(source.path.read_bytes()).hexdigest()
+    if len(digest) != 64:
+        raise ValueError("compiled model source has no canonical SHA-256 digest")
+    restriction = (
+        (
+            source.restriction.name
+            if isinstance(source.restriction, Path)
+            else source.restriction
+        )
+        if source.restriction is not None
+        else "default"
+        if source.kind in {"ufo", "json"}
+        else None
+    )
+    return {
+        "name": compiled.name,
+        "source_kind": source_kind,
+        "content_sha256": digest,
+        "compiled_schema_version": COMPILED_MODEL_SCHEMA_VERSION,
+        "restriction": restriction,
+    }
+
+
+def _dependency_metadata(source: ModelSource) -> tuple[dict[str, object], ...]:
+    dependencies: list[dict[str, object]] = [
+        {
+            "name": "symbolica",
+            "version": _distribution_version("symbolica", "unknown"),
+            "source": "https://symbolica.io/",
+            "license": "Symbolica Software License Agreement",
+        }
+    ]
+    if source.kind in {"ufo", "json"}:
+        dependencies.append(
+            {
+                "name": "ufo-model-loader",
+                "version": _distribution_version("ufo-model-loader", "unknown"),
+                "source": "https://github.com/alphal00p/ufo_model_loader",
+                "license": "MIT",
+            }
+        )
+    return tuple(dependencies)
+
+
+def _validate_append_compatibility(
+    existing: ArtifactManifest | None,
+    *,
+    producer: Mapping[str, object],
+    model: Mapping[str, object],
+    eager_pack_identity: Mapping[str, object] | None,
+    requested_bytes: bytes,
+    effective_bytes: bytes,
+    adjustments: Sequence[Mapping[str, str]],
+    processes: Sequence[ProcessArtifact],
+) -> None:
+    if existing is None:
+        return
+    _reject_legacy_eager_append(existing)
+    existing_producer = _plain_mapping(existing.producer)
+    producer_identity_fields = (
+        ("distribution", "distribution"),
+        ("version", "version"),
+        ("git_revision", "source revision"),
+        ("native_build_inputs_sha256", "native build-input digest"),
+    )
+    for field, label in producer_identity_fields:
+        if existing_producer.get(field) != producer.get(field):
+            raise ValueError(
+                f"append producer {label} differs from the existing artifact"
+            )
+    existing_capabilities = _required_runtime_capabilities(existing.runtime)
+    existing_uses_eager = (
+        EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY in existing_capabilities
+        or any(record.path == _EAGER_KERNEL_PACK_PATH for record in existing.payloads)
+    )
+    existing_identity = existing.extensions.get(_EAGER_PACK_IDENTITY_EXTENSION)
+    if existing_uses_eager or existing_identity is not None:
+        if not isinstance(existing_identity, Mapping):
+            raise ValueError(
+                "append eager artifact has no canonical prepared-pack identity; "
+                "replace the artifact"
+            )
+        if eager_pack_identity is None or _plain_mapping(
+            existing_identity
+        ) != _plain_mapping(eager_pack_identity):
+            raise ValueError(
+                "append prepared kernel pack identity differs from the existing "
+                "artifact; replace the artifact"
+            )
+    if _plain_mapping(existing.model) != dict(model):
+        raise ValueError("append model provenance differs from the existing artifact")
+    if existing_producer.get("target") != producer.get("target"):
+        raise ValueError("append target differs from the existing artifact")
+    requested_path = existing.root / str(existing.configuration["requested_path"])
+    effective_path = existing.root / str(existing.configuration["effective_path"])
+    if requested_path.read_bytes() != requested_bytes:
+        raise ValueError("append requested configuration differs from the artifact")
+    if effective_path.read_bytes() != effective_bytes:
+        raise ValueError("append effective configuration differs from the artifact")
+    existing_adjustments: list[dict[str, str]] = []
+    for item in _sequence(existing.configuration["adjustments"]):
+        adjustment = _mapping(item)
+        existing_adjustments.append(
+            {
+                "path": str(adjustment["path"]),
+                "reason": str(adjustment["reason"]),
+            }
+        )
+    if existing_adjustments != list(adjustments):
+        raise ValueError("append configuration adjustments differ from the artifact")
+    existing_ids = {str(record["id"]) for record in existing.processes}
+    duplicates = existing_ids.intersection(process.process_id for process in processes)
+    if duplicates:
+        raise ValueError(
+            "append process IDs already exist: " + ", ".join(sorted(duplicates))
+        )
+
+
+def _reject_legacy_eager_append(existing: ArtifactManifest) -> None:
+    raw_capabilities = existing.runtime.get("required_runtime_capabilities", ())
+    if (
+        not isinstance(raw_capabilities, str | bytes)
+        and isinstance(raw_capabilities, Sequence)
+        and EAGER_RUNTIME_CAPABILITY in raw_capabilities
+    ):
+        raise ValueError(
+            "legacy eager plan-v2 artifacts cannot be extended; regenerate the "
+            "artifact with the current eager plan-v3 runtime or use replace mode"
+        )
+
+
+def _existing_process_records(
+    existing: ArtifactManifest | None,
+) -> list[dict[str, object]]:
+    if existing is None:
+        return []
+    return [_plain_mapping(record) for record in existing.processes]
+
+
+def _existing_evaluator_entries(
+    existing: ArtifactManifest | None,
+) -> list[dict[str, object]]:
+    if existing is None:
+        return []
+    path = existing.root / str(existing.runtime["evaluator_manifest_path"])
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if (
+        not isinstance(payload, dict)
+        or payload.get("schema_version") != PROCESS_ARTIFACT_SCHEMA_VERSION
+        or payload.get("kind") != "pyamplicol-runtime-execution-set"
+    ):
+        raise ValueError("append artifact has an incompatible evaluator-set manifest")
+    entries = payload.get("processes")
+    if not isinstance(entries, list) or not all(
+        isinstance(item, dict) for item in entries
+    ):
+        raise ValueError("append evaluator-set process list is invalid")
+    return [dict(item) for item in entries]
+
+
+def _existing_required_runtime_capabilities(
+    existing: ArtifactManifest | None,
+) -> tuple[str, ...]:
+    if existing is None:
+        return ()
+    return _required_runtime_capabilities(existing.runtime)
+
+
+def _compiled_process_runtime_capabilities(
+    process: CompiledProcessArtifact,
+) -> tuple[str, ...]:
+    capabilities = set(_required_runtime_capabilities(process.stage_manifest))
+    capabilities.update(
+        _runtime_schema_walsh_color_contraction_capabilities(
+            _runtime_schema_mapping(process.runtime_schema)
+        )
+    )
+    if process.color_contraction_payload is not None:
+        capabilities.add(SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY)
+    if process.model_parameter_evaluator is not None:
+        capabilities.update(
+            _required_runtime_capabilities(process.model_parameter_evaluator)
+        )
+    if _uses_primary_helicity_recurrence(process):
+        capabilities.add(COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY)
+    if process.color_selector_executions:
+        capabilities.add(COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY)
+        capabilities.add(COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+        for record in _ordered_color_selector_executions(
+            process.color_selector_executions
+        ):
+            capabilities.update(
+                _compiled_execution_runtime_capabilities(record.execution)
+            )
+    auxiliary = process.helicity_sum_execution
+    if auxiliary is not None:
+        capabilities.add(COMPILED_HELICITY_DUAL_LANE_CAPABILITY)
+        capabilities.update(_compiled_execution_runtime_capabilities(auxiliary))
+    selector_lanes = _ordered_helicity_selector_executions(
+        process.helicity_selector_executions
+    )
+    if selector_lanes:
+        capabilities.add(COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY)
+        capabilities.add(COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+        for record in selector_lanes:
+            capabilities.update(
+                _compiled_execution_runtime_capabilities(record.execution)
+            )
+    return tuple(sorted(capabilities))
+
+
+def _uses_primary_helicity_recurrence(process: CompiledProcessArtifact) -> bool:
+    return _runtime_schema_uses_primary_helicity_recurrence(
+        _runtime_schema_mapping(process.runtime_schema),
+        has_helicity_sum_execution=process.helicity_sum_execution is not None,
+    )
+
+
+def _runtime_schema_uses_primary_helicity_recurrence(
+    runtime_schema: Mapping[str, object],
+    *,
+    has_helicity_sum_execution: bool,
+) -> bool:
+    if has_helicity_sum_execution:
+        return False
+    recurrence = runtime_schema.get("helicity_recurrence")
+    return isinstance(recurrence, Mapping) and isinstance(
+        recurrence.get("materialization"), Mapping
+    )
+
+
+def _runtime_schema_uses_walsh_color_contraction(
+    runtime_schema: Mapping[str, object],
+) -> bool:
+    return bool(_runtime_schema_walsh_color_contraction_capabilities(runtime_schema))
+
+
+def _runtime_schema_walsh_color_contraction_capabilities(
+    runtime_schema: Mapping[str, object],
+) -> frozenset[str]:
+    amplitude_stage = runtime_schema.get("amplitude_stage")
+    if not isinstance(amplitude_stage, Mapping):
+        return frozenset()
+    contraction = amplitude_stage.get("color_contraction")
+    if not isinstance(contraction, Mapping):
+        return frozenset()
+    repeated_block = contraction.get("repeated_block")
+    if not isinstance(repeated_block, Mapping):
+        return frozenset()
+    factorized_block = repeated_block.get("factorized_block")
+    if not isinstance(factorized_block, Mapping):
+        return frozenset()
+    kind = factorized_block.get("kind")
+    if kind == "klein-four-walsh":
+        return frozenset({COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY})
+    if kind == "elementary-abelian-walsh":
+        return frozenset({COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY})
+    return frozenset()
+
+
+def _compiled_execution_runtime_capabilities(
+    execution: CompiledExecutionArtifact,
+) -> tuple[str, ...]:
+    capabilities = set(_required_runtime_capabilities(execution.stage_manifest))
+    capabilities.update(
+        _runtime_schema_walsh_color_contraction_capabilities(
+            _runtime_schema_mapping(execution.runtime_schema)
+        )
+    )
+    if _runtime_schema_uses_primary_helicity_recurrence(
+        _runtime_schema_mapping(execution.runtime_schema),
+        has_helicity_sum_execution=False,
+    ):
+        capabilities.add(COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY)
+    if execution.model_parameter_evaluator is not None:
+        capabilities.update(
+            _required_runtime_capabilities(execution.model_parameter_evaluator)
+        )
+    if execution.color_selector_executions:
+        capabilities.add(COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY)
+        capabilities.add(COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+        for record in _ordered_color_selector_executions(
+            execution.color_selector_executions
+        ):
+            capabilities.update(
+                _compiled_execution_runtime_capabilities(record.execution)
+            )
+    selector_lanes = _ordered_helicity_selector_executions(
+        execution.helicity_selector_executions
+    )
+    if selector_lanes:
+        capabilities.add(COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY)
+        capabilities.add(COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+        for record in selector_lanes:
+            capabilities.update(
+                _compiled_execution_runtime_capabilities(record.execution)
+            )
+    return tuple(sorted(capabilities))
+
+
+def _process_runtime_capabilities(
+    process: ProcessArtifact,
+) -> tuple[str, ...]:
+    if isinstance(process, OnTheFlyProcessArtifact):
+        return _on_the_fly_process_runtime_capabilities(process)
+    if isinstance(process, RecurrenceProcessArtifact):
+        return _recurrence_process_runtime_capabilities(process)
+    if isinstance(process, EagerPlanV3ProcessArtifact):
+        return _EAGER_PLAN_V3_RUNTIME_CAPABILITIES
+    return _compiled_process_runtime_capabilities(process)
+
+
+def _on_the_fly_process_runtime_capabilities(
+    process: OnTheFlyProcessArtifact,
+) -> tuple[str, ...]:
+    if process.color_accuracy == "lc":
+        color_capability = ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY
+    elif process.color_accuracy in {"nlc", "full"}:
+        color_capability = ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY
+    else:
+        raise ValueError(
+            f"unsupported on-the-fly color accuracy {process.color_accuracy!r}"
+        )
+    capabilities = {
+        color_capability,
+        ON_THE_FLY_RUNTIME_CAPABILITY,
+    }
+    if _uses_symmetric_group_fft_color_contraction(process):
+        capabilities.add(SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY)
+    return tuple(sorted(capabilities))
+
+
+def _recurrence_process_runtime_capabilities(
+    process: RecurrenceProcessArtifact,
+) -> tuple[str, ...]:
+    color_capability = (
+        RECURRENCE_COLOR_RUNTIME_CAPABILITY
+        if process.color_accuracy == "lc"
+        else RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY
+    )
+    capabilities = {
+        RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        color_capability,
+    }
+    if process.helicity_selector_companion is not None:
+        capabilities.add(RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY)
+    if _uses_symmetric_group_fft_color_contraction(process):
+        capabilities.add(SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY)
+    return tuple(sorted(capabilities))
+
+
+def _uses_symmetric_group_fft_color_contraction(
+    process: OnTheFlyProcessArtifact | RecurrenceProcessArtifact,
+) -> bool:
+    summary = process.color_contraction_summary
+    if not isinstance(summary, Mapping):
+        return False
+    factorization = summary.get("factorization")
+    return isinstance(factorization, Mapping) and (
+        factorization.get("kind") == "symmetric-group-fourier"
+    )
+
+
+def _validate_symmetric_group_fft_provenance(
+    summary: Mapping[str, object],
+    *,
+    context: str,
+) -> None:
+    factorization_raw = summary.get("factorization")
+    symmetric_group_fft = (
+        isinstance(factorization_raw, Mapping)
+        and factorization_raw.get("kind") == "symmetric-group-fourier"
+    )
+    provenance_raw = summary.get("fft_provenance")
+    if not symmetric_group_fft:
+        if provenance_raw is not None or "fft_provenance" in summary:
+            raise ValueError(f"{context} non-FFT summary carries FFT provenance")
+        return
+    factorization = _mapping(factorization_raw)
+    provenance = _mapping(provenance_raw)
+    if set(provenance) != {
+        "method",
+        "degree",
+        "channel_count",
+        "covered_local_group_count",
+        "residual_group_count",
+        "residual_entry_count",
+        "raw_kernel_bytes",
+        "transformed_kernel_bytes",
+        "capability",
+    }:
+        raise ValueError(f"{context} FFT provenance fields are invalid")
+    degree = _nonnegative_integer(
+        factorization.get("rank"), f"{context} FFT degree", minimum=2
+    )
+    channel_count = _nonnegative_integer(
+        factorization.get("coset_count"), f"{context} FFT channel count", minimum=1
+    )
+    group_count = _nonnegative_integer(
+        summary.get("group_count"), f"{context} group count", minimum=1
+    )
+    component_count = _nonnegative_integer(
+        summary.get("component_count"), f"{context} component count", minimum=1
+    )
+    if degree > 10 or group_count % component_count:
+        raise ValueError(f"{context} FFT group shape is invalid")
+    group_order = math.factorial(degree)
+    covered_local_group_count = channel_count * group_order
+    local_group_count = group_count // component_count
+    if covered_local_group_count > local_group_count:
+        raise ValueError(f"{context} FFT channels exceed local groups")
+    residual_group_count = local_group_count - covered_local_group_count
+    residual_entry_count = (
+        local_group_count * (local_group_count + 1) // 2
+        - covered_local_group_count * (covered_local_group_count + 1) // 2
+    )
+    kernel_entry_count = channel_count * (channel_count + 1) // 2 * group_order
+    raw_kernel_bytes = kernel_entry_count * 16
+    transformed_kernel_bytes = kernel_entry_count * 8
+    expected = {
+        "method": "symmetric-group-fourier",
+        "degree": degree,
+        "channel_count": channel_count,
+        "covered_local_group_count": covered_local_group_count,
+        "residual_group_count": residual_group_count,
+        "residual_entry_count": residual_entry_count,
+        "raw_kernel_bytes": raw_kernel_bytes,
+        "transformed_kernel_bytes": transformed_kernel_bytes,
+        "capability": SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+    }
+    if (
+        dict(provenance) != expected
+        or summary.get("entry_count") != kernel_entry_count + residual_entry_count
+        or summary.get("logical_entry_count")
+        != (kernel_entry_count + residual_entry_count) * component_count
+    ):
+        raise ValueError(f"{context} symmetric-group FFT provenance is inconsistent")
+
+
+def _required_runtime_capabilities(
+    record: Mapping[str, object],
+) -> tuple[str, ...]:
+    raw = record.get("required_runtime_capabilities")
+    if isinstance(raw, str | bytes) or not isinstance(raw, Sequence):
+        raise ValueError("runtime capability metadata must be a sequence")
+    values = tuple(str(item) for item in raw)
+    if values != tuple(sorted(set(values))):
+        raise ValueError("runtime capabilities must be sorted and unique")
+    unknown = set(values) - (
+        EVALUATOR_RUNTIME_CAPABILITIES
+        | {
+            EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+            RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            RECURRENCE_COLOR_RUNTIME_CAPABILITY,
+        }
+    )
+    if unknown:
+        raise ValueError(
+            "unsupported evaluator runtime capabilities: " + ", ".join(sorted(unknown))
+        )
+    return values
+
+
+def _extensions(
+    existing: ArtifactManifest | None,
+    *,
+    processes: Sequence[ProcessArtifact],
+    timings: Mapping[str, float],
+    api_bundle_requested: bool,
+    api_bundle_path: str | None,
+    eager_pack_identity: Mapping[str, object] | None,
+    execution_manifest_sha256_by_process: Mapping[str, str],
+    evaluator_payload_container: Mapping[str, object] | None,
+    recurrence_schedule_sharing: Mapping[str, object] | None,
+) -> dict[str, object]:
+    result = {} if existing is None else _plain_mapping(existing.extensions)
+    previous = result.get("generation")
+    generation = dict(previous) if isinstance(previous, Mapping) else {}
+    concrete = generation.get("concrete_processes")
+    process_records = list(concrete) if isinstance(concrete, list) else []
+    for process in processes:
+        record: dict[str, object] = {
+            "id": process.process_id,
+            "expression": process.expression,
+            "validation_momenta_path": (
+                f"processes/{process.process_id}/validation-momenta.json"
+            ),
+            "filters": dict(process.generation_filters),
+        }
+        if _is_prepared_kernel_process(process):
+            record["execution_manifest_sha256"] = execution_manifest_sha256_by_process[
+                process.process_id
+            ]
+        else:
+            record["runtime_schema_sha256"] = process.runtime_schema.sha256
+            if process.helicity_sum_execution is not None:
+                record["helicity_sum_runtime_schema_sha256"] = (
+                    process.helicity_sum_execution.runtime_schema.sha256
+                )
+            if process.helicity_selector_executions:
+                record["helicity_selector_runtime_schema_sha256s"] = [
+                    lane.execution.runtime_schema.sha256
+                    for lane in _ordered_helicity_selector_executions(
+                        process.helicity_selector_executions
+                    )
+                ]
+        process_records.append(record)
+    recurrence_schedule_profiles: dict[str, object] = {}
+    for process in processes:
+        if not isinstance(process, RecurrenceProcessArtifact):
+            continue
+        schedule_digest = _canonical_sha256(
+            process.recurrence_schedule_digest,
+            f"recurrence schedule {process.process_id!r} generation-profile digest",
+        )
+        profile = _deep_plain(process.generation_profile)
+        previous_profile = recurrence_schedule_profiles.get(schedule_digest)
+        if previous_profile is not None and previous_profile != profile:
+            raise ValueError(
+                "shared recurrence schedule has inconsistent generation telemetry: "
+                f"{schedule_digest}"
+            )
+        recurrence_schedule_profiles[schedule_digest] = profile
+    generation.update(
+        {
+            "schema_version": 1,
+            "concrete_processes": process_records,
+            "phase_timings_seconds": {
+                str(name): float(value) for name, value in timings.items()
+            },
+            "api_bundle": {
+                "requested": api_bundle_requested,
+                "emitted": api_bundle_path is not None,
+                "path": api_bundle_path,
+                "scope": "root-artifact",
+            },
+        }
+    )
+    if recurrence_schedule_profiles:
+        generation["recurrence_schedule_profiles"] = recurrence_schedule_profiles
+    result["generation"] = generation
+    if eager_pack_identity is not None:
+        result[_EAGER_PACK_IDENTITY_EXTENSION] = _plain_mapping(eager_pack_identity)
+    if recurrence_schedule_sharing is not None:
+        result[_RECURRENCE_SCHEDULE_SHARING_EXTENSION] = _plain_mapping(
+            recurrence_schedule_sharing
+        )
+    if evaluator_payload_container is None:
+        result.pop(_EVALUATOR_PAYLOAD_CONTAINER_EXTENSION, None)
+    else:
+        result[_EVALUATOR_PAYLOAD_CONTAINER_EXTENSION] = _plain_mapping(
+            evaluator_payload_container
+        )
+    return result
+
+
+def _default_api_bundle_hook() -> ApiBundleHook | None:
+    try:
+        from pyamplicol.artifacts.api_bundle import emit_api_bundle
+    except ImportError:
+        return None
+    return cast("ApiBundleHook", emit_api_bundle)
+
+
+def _call_api_bundle_hook(
+    builder: ArtifactBuilder,
+    hook: ApiBundleHook,
+    validation_points: Mapping[str, Sequence[Sequence[float]]],
+) -> str:
+    result = hook(builder, validation_points)
+    paths = tuple(
+        str(item["path"])
+        if isinstance(item, Mapping)
+        else str(getattr(item, "path", ""))
+        for item in result
+    )
+    if not paths or any(not path.startswith("API/") for path in paths):
+        raise ValueError("root API-bundle emitter returned an invalid payload set")
+    return "API"
+
+
+def _validate_artifact_references(manifest: ArtifactManifest) -> None:
+    declared = {record.path for record in manifest.payloads}
+    _validate_evaluator_payload_container(manifest)
+    _validate_recurrence_schedule_sharing(manifest)
+    required = {
+        str(manifest.configuration["requested_path"]),
+        str(manifest.configuration["effective_path"]),
+        str(manifest.runtime["evaluator_manifest_path"]),
+        *(str(process["physics_path"]) for process in manifest.processes),
+        *(
+            f"processes/{process['id']}/execution.json"
+            for process in manifest.processes
+        ),
+    }
+    api_path = manifest.runtime.get("api_bundle_path")
+    if api_path is not None:
+        api_prefix = str(api_path).rstrip("/") + "/"
+        if not any(path.startswith(api_prefix) for path in declared):
+            raise ValueError("artifact API bundle has no declared payloads")
+    missing = required - declared
+    if missing:
+        raise ValueError(
+            "artifact references undeclared payloads: " + ", ".join(sorted(missing))
+        )
+    actual = {
+        path.relative_to(manifest.root).as_posix()
+        for path in manifest.root.rglob("*")
+        if path.is_file() and path.name != "artifact.json"
+    }
+    undeclared = actual - declared
+    if undeclared:
+        raise ValueError(
+            "artifact contains undeclared files: " + ", ".join(sorted(undeclared))
+        )
+
+
+def _validate_recurrence_schedule_sharing(manifest: ArtifactManifest) -> None:
+    raw = manifest.extensions.get(_RECURRENCE_SCHEDULE_SHARING_EXTENSION)
+    if raw is None:
+        return
+    extension = _mapping(raw)
+    expected_fields = {
+        "kind",
+        "schema_version",
+        "index_path",
+        "index_sha256",
+        "schedule_count",
+        "binding_count",
+        "schedule_alias_count",
+        "runtime_ownership",
+        "interning_phase",
+    }
+    if set(extension) != expected_fields:
+        raise ValueError("recurrence schedule-sharing extension fields are invalid")
+    if (
+        extension.get("kind") != "pyamplicol-recurrence-schedule-sharing"
+        or extension.get("schema_version") != RECURRENCE_SCHEDULE_SHARING_SCHEMA_VERSION
+        or extension.get("index_path") != RECURRENCE_SCHEDULE_INDEX_PATH
+        or extension.get("runtime_ownership") != "root-schedule-plus-process-binding"
+        or extension.get("interning_phase") != "before-direct-lowering"
+    ):
+        raise ValueError("recurrence schedule-sharing extension is incompatible")
+    records = {record.path: record for record in manifest.payloads}
+    index_record = records.get(RECURRENCE_SCHEDULE_INDEX_PATH)
+    if (
+        index_record is None
+        or index_record.role != "evaluator-manifest"
+        or index_record.process_id is not None
+        or index_record.sha256 != extension.get("index_sha256")
+    ):
+        raise ValueError("recurrence schedule-sharing index record is invalid")
+    index = _mapping(
+        json.loads(
+            (manifest.root / RECURRENCE_SCHEDULE_INDEX_PATH).read_text(encoding="utf-8")
+        )
+    )
+    if (
+        index.get("kind") != extension["kind"]
+        or index.get("schema_version") != extension["schema_version"]
+        or index.get("runtime_ownership") != extension["runtime_ownership"]
+        or index.get("interning_phase") != extension["interning_phase"]
+    ):
+        raise ValueError("recurrence schedule-sharing index is incompatible")
+    schedules = _sequence(index.get("schedules"))
+    bindings = _sequence(index.get("bindings"))
+    counts = {
+        "schedule_count": len(schedules),
+        "binding_count": len(bindings),
+        "schedule_alias_count": len(bindings) - len(schedules),
+    }
+    if any(index.get(name) != value for name, value in counts.items()) or any(
+        extension.get(name) != value for name, value in counts.items()
+    ):
+        raise ValueError("recurrence schedule-sharing counts are inconsistent")
+
+    schedule_paths: dict[str, str] = {}
+    declared_processes_by_schedule: dict[str, tuple[str, ...]] = {}
+    for position, raw_schedule in enumerate(schedules):
+        schedule = _mapping(raw_schedule)
+        digest = _canonical_sha256(
+            schedule.get("digest"),
+            f"recurrence shared schedule {position} digest",
+        )
+        if digest in schedule_paths:
+            raise ValueError(f"recurrence shared schedule {digest} is duplicated")
+        expected_path = f"recurrence/schedules/{digest}/recurrence-runtime.pacbin"
+        if schedule.get("path") != expected_path:
+            raise ValueError(
+                f"recurrence shared schedule {digest} has an invalid root path"
+            )
+        raw_process_ids = _sequence(schedule.get("process_ids"))
+        declared_process_ids = tuple(str(value) for value in raw_process_ids)
+        if not declared_process_ids or declared_process_ids != tuple(
+            sorted(set(declared_process_ids))
+        ):
+            raise ValueError(
+                f"recurrence shared schedule {digest} has invalid process ownership"
+            )
+        record = records.get(expected_path)
+        if (
+            record is None
+            or record.role != "evaluator-state"
+            or record.process_id is not None
+            or record.sha256 != schedule.get("sha256")
+            or record.size_bytes != schedule.get("size_bytes")
+        ):
+            raise ValueError(
+                f"recurrence shared schedule {digest} has an invalid payload record"
+            )
+        schedule_paths[digest] = expected_path
+        declared_processes_by_schedule[digest] = declared_process_ids
+
+    process_ids = {str(process["id"]) for process in manifest.processes}
+    binding_process_ids: set[str] = set()
+    support_masks: set[tuple[int, ...]] = set()
+    bound_processes_by_schedule: dict[str, list[str]] = {}
+    for position, raw_binding in enumerate(bindings):
+        binding = _mapping(raw_binding)
+        process_id = str(binding.get("process_id"))
+        if process_id not in process_ids or process_id in binding_process_ids:
+            raise ValueError(
+                f"recurrence process binding {position} has an invalid process ID"
+            )
+        binding_process_ids.add(process_id)
+        if binding.get("abi") != RECURRENCE_PROCESS_BINDING_ABI:
+            raise ValueError(
+                f"recurrence process binding {process_id!r} has an invalid ABI"
+            )
+        _canonical_sha256(
+            binding.get("process_digest"),
+            f"recurrence process binding {process_id!r} process digest",
+        )
+        _canonical_sha256(
+            binding.get("process_semantic_digest"),
+            f"recurrence process binding {process_id!r} semantic digest",
+        )
+        _recurrence_binding_native_schedule_semantic_digest(
+            binding,
+            process_id=process_id,
+        )
+        _validate_recurrence_process_remap(
+            binding.get("remap"),
+            context=f"recurrence process binding {process_id!r}",
+        )
+        schedule_digest = _canonical_sha256(
+            binding.get("schedule_digest"),
+            f"recurrence process binding {process_id!r} schedule digest",
+        )
+        root_path = schedule_paths.get(schedule_digest)
+        if root_path is None:
+            raise ValueError(
+                f"recurrence process binding {process_id!r} references an unknown "
+                "schedule"
+            )
+        bound_processes_by_schedule.setdefault(schedule_digest, []).append(process_id)
+        raw_support_words = _sequence(binding.get("process_support_words"))
+        support_mask = tuple(raw_support_words)
+        if (
+            not support_mask
+            or any(
+                isinstance(word, bool)
+                or not isinstance(word, int)
+                or word < 0
+                or word > (1 << 64) - 1
+                for word in support_mask
+            )
+            or sum(int(word).bit_count() for word in support_mask) != 1
+            or support_mask[-1] == 0
+            or support_mask in support_masks
+        ):
+            raise ValueError(
+                f"recurrence process binding {process_id!r} has an invalid support mask"
+            )
+        support_masks.add(support_mask)
+        relative_binding_path = binding.get("path")
+        if relative_binding_path != "recurrence-binding.bin":
+            raise ValueError(
+                f"recurrence process binding {process_id!r} has an invalid binding path"
+            )
+        binding_path = f"processes/{process_id}/{relative_binding_path}"
+        binding_record = records.get(binding_path)
+        if (
+            binding_record is None
+            or binding_record.role != "evaluator-state"
+            or binding_record.process_id != process_id
+            or binding_record.sha256 != binding.get("sha256")
+            or binding_record.size_bytes != binding.get("size_bytes")
+        ):
+            raise ValueError(
+                f"recurrence process binding {process_id!r} has an invalid payload"
+            )
+    for digest, declared_process_ids in declared_processes_by_schedule.items():
+        bound_process_ids = tuple(sorted(bound_processes_by_schedule.get(digest, ())))
+        if bound_process_ids != declared_process_ids:
+            raise ValueError(
+                f"recurrence shared schedule {digest} binding ownership is inconsistent"
+            )
+
+
+def _recurrence_binding_native_schedule_semantic_digest(
+    binding: Mapping[str, object],
+    *,
+    process_id: str,
+) -> str:
+    return _canonical_sha256(
+        binding.get("native_schedule_semantic_digest"),
+        (f"recurrence process binding {process_id!r} native schedule semantic digest"),
+    )
+
+
+def _validate_recurrence_process_remap(
+    value: object,
+    *,
+    context: str,
+) -> None:
+    remap = _mapping(value)
+    expected = {
+        "bijection_digest",
+        "source_slots",
+        "source_momentum_signs",
+        "source_helicity_signs",
+        "source_state_offsets",
+        "source_state_indices",
+        "public_flow_ids",
+        "physical_sector_ids",
+        "state_templates",
+        "source_templates",
+        "direct_executors",
+        "parameter_slots",
+    }
+    if set(remap) != expected:
+        raise ValueError(f"{context} remap fields are invalid")
+    _canonical_sha256(
+        remap.get("bijection_digest"),
+        f"{context} process-bijection digest",
+    )
+
+    def permutation(name: str) -> tuple[int, ...]:
+        values = tuple(_sequence(remap.get(name)))
+        if any(
+            isinstance(item, bool) or not isinstance(item, int) or item < 0
+            for item in values
+        ) or tuple(sorted(values)) != tuple(range(len(values))):
+            raise ValueError(f"{context} {name} is not a permutation")
+        return cast(tuple[int, ...], values)
+
+    sources = permutation("source_slots")
+    permutation("public_flow_ids")
+    permutation("physical_sector_ids")
+    for name in ("source_momentum_signs", "source_helicity_signs"):
+        signs = tuple(_sequence(remap.get(name)))
+        if len(signs) != len(sources) or any(sign not in {-1, 1} for sign in signs):
+            raise ValueError(f"{context} {name} is invalid")
+    source_state_offsets = tuple(_sequence(remap.get("source_state_offsets")))
+    source_state_indices = tuple(_sequence(remap.get("source_state_indices")))
+    if (
+        len(source_state_offsets) != len(sources) + 1
+        or not source_state_offsets
+        or source_state_offsets[0] != 0
+        or source_state_offsets[-1] != len(source_state_indices)
+        or any(
+            isinstance(item, bool) or not isinstance(item, int) or item < 0
+            for item in (*source_state_offsets, *source_state_indices)
+        )
+        or any(left > right for left, right in pairwise(source_state_offsets))
+    ):
+        raise ValueError(f"{context} source-state remap is invalid")
+    for start, stop in pairwise(source_state_offsets):
+        if tuple(sorted(source_state_indices[start:stop])) != tuple(
+            range(stop - start)
+        ):
+            raise ValueError(f"{context} source-state remap is not bijective")
+    for name in (
+        "state_templates",
+        "source_templates",
+        "direct_executors",
+        "parameter_slots",
+    ):
+        sparse = _mapping(remap.get(name))
+        if set(sparse) != {"count", "changes"}:
+            raise ValueError(f"{context} {name} fields are invalid")
+        count = sparse.get("count")
+        if isinstance(count, bool) or not isinstance(count, int) or count < 0:
+            raise ValueError(f"{context} {name} count is invalid")
+        changes = tuple(_sequence(sparse.get("changes")))
+        mapping = list(range(count))
+        previous = -1
+        for raw_change in changes:
+            change = tuple(_sequence(raw_change))
+            if (
+                len(change) != 2
+                or any(
+                    isinstance(item, bool)
+                    or not isinstance(item, int)
+                    or item < 0
+                    or item >= count
+                    for item in change
+                )
+                or change[0] <= previous
+                or change[0] == change[1]
+            ):
+                raise ValueError(f"{context} {name} change is invalid")
+            source, target = cast(tuple[int, int], change)
+            mapping[source] = target
+            previous = source
+        if tuple(sorted(mapping)) != tuple(range(count)):
+            raise ValueError(f"{context} {name} is not bijective")
+
+
+def _validate_evaluator_payload_container(manifest: ArtifactManifest) -> None:
+    raw = manifest.extensions.get(_EVALUATOR_PAYLOAD_CONTAINER_EXTENSION)
+    if raw is None:
+        return
+    extension = _mapping(raw)
+    expected_fields = {
+        "kind",
+        "schema_version",
+        "storage_abi",
+        "path",
+        "member_count",
+        "unpacked_size_bytes",
+        "index_sha256",
+    }
+    if set(extension) != expected_fields:
+        raise ValueError("evaluator payload container extension fields are invalid")
+    if extension != {
+        **extension,
+        "kind": _EVALUATOR_PAYLOAD_CONTAINER_KIND,
+        "schema_version": _EVALUATOR_PAYLOAD_CONTAINER_SCHEMA_VERSION,
+        "storage_abi": _EVALUATOR_PAYLOAD_CONTAINER_STORAGE_ABI,
+        "path": _EVALUATOR_PAYLOAD_CONTAINER_PATH,
+    }:
+        raise ValueError("evaluator payload container extension contract is invalid")
+    records = {
+        record.path: record
+        for record in manifest.payloads
+        if record.path == _EVALUATOR_PAYLOAD_CONTAINER_PATH
+    }
+    if len(records) != 1:
+        raise ValueError("evaluator payload container is not a declared payload")
+    record = records[_EVALUATOR_PAYLOAD_CONTAINER_PATH]
+    if (
+        record.role != "evaluator-state"
+        or record.media_type != "application/octet-stream"
+        or record.process_id is not None
+        or record.target != manifest.producer["target"]
+    ):
+        raise ValueError("evaluator payload container manifest record is invalid")
+    loose = sorted(
+        payload.path
+        for payload in manifest.payloads
+        if payload.path != _EVALUATOR_PAYLOAD_CONTAINER_PATH
+        and _packed_evaluator_member_kind(payload.path) is not None
+    )
+    if loose:
+        raise ValueError(
+            "artifact declares loose packed evaluator payloads: " + ", ".join(loose)
+        )
+    with PacbinReader.open(
+        manifest.root / _EVALUATOR_PAYLOAD_CONTAINER_PATH,
+        verify_payloads=False,
+    ) as reader:
+        expected = _evaluator_payload_container_extension(reader.index)
+    if extension != expected:
+        raise ValueError(
+            "evaluator payload container metadata does not match its index"
+        )
+
+
+def _config_payload(config: GenerationConfig | RunConfig) -> dict[str, object]:
+    payload = _plain_mapping(_mapping(config_to_dict(config)))
+    if isinstance(config, GenerationConfig):
+        return {"schema_version": 1, "generation": payload}
+    return payload
+
+
+def _effective_config_payload(
+    requested: Mapping[str, object],
+    *,
+    disable_api_bundle: bool,
+) -> dict[str, object]:
+    result = _deep_plain(requested)
+    if disable_api_bundle:
+        generation = result.get("generation")
+        if not isinstance(generation, dict):
+            raise ValueError("generation configuration section is missing")
+        generation["emit_api_bundle"] = False
+    return result
+
+
+def _bundle_requested(config: GenerationConfig | RunConfig) -> bool:
+    generation = config if isinstance(config, GenerationConfig) else config.generation
+    return bool(generation.emit_api_bundle)
+
+
+def _existing_bundle_path(existing: ArtifactManifest | None) -> str | None:
+    if existing is None:
+        return None
+    value = existing.runtime.get("api_bundle_path")
+    return None if value is None else str(value)
+
+
+def _toml_bytes(payload: Mapping[str, object]) -> bytes:
+    lines: list[str] = []
+    _write_toml_table(lines, (), payload, emit_header=False)
+    return ("\n".join(lines).rstrip() + "\n").encode("utf-8")
+
+
+def _write_toml_table(
+    lines: list[str],
+    path: tuple[str, ...],
+    payload: Mapping[str, object],
+    *,
+    emit_header: bool,
+) -> None:
+    scalars = [
+        (str(key), value)
+        for key, value in payload.items()
+        if value is not None and not isinstance(value, Mapping)
+    ]
+    tables = [
+        (str(key), _mapping(value))
+        for key, value in payload.items()
+        if isinstance(value, Mapping)
+    ]
+    if emit_header:
+        if lines and lines[-1] != "":
+            lines.append("")
+        lines.append("[" + ".".join(_toml_key(part) for part in path) + "]")
+    lines.extend(f"{_toml_key(key)} = {_toml_value(value)}" for key, value in scalars)
+    for key, table in tables:
+        _write_toml_table(lines, (*path, key), table, emit_header=True)
+
+
+def _toml_value(value: object) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, str):
+        return json.dumps(value, ensure_ascii=True)
+    if isinstance(value, os.PathLike):
+        return json.dumps(os.fspath(value), ensure_ascii=True)
+    if isinstance(value, int | float):
+        return repr(value)
+    if isinstance(value, Mapping):
+        entries = (
+            f"{_toml_key(str(key))} = {_toml_value(entry)}"
+            for key, entry in value.items()
+            if entry is not None
+        )
+        return "{ " + ", ".join(entries) + " }"
+    if isinstance(value, Sequence) and not isinstance(value, str | bytes):
+        return "[" + ", ".join(_toml_value(item) for item in value) + "]"
+    raise TypeError(f"configuration value is not TOML serializable: {value!r}")
+
+
+def _toml_key(value: str) -> str:
+    return value if _SAFE_TOML_KEY.fullmatch(value) else json.dumps(value)
+
+
+def _media_type(path: Path) -> str:
+    suffix = path.suffix.lower()
+    if suffix in {".json"}:
+        return "application/json"
+    if suffix in {".c", ".cc", ".cpp", ".cxx", ".h", ".hpp"}:
+        return "text/x-c++src"
+    if suffix == ".symjit":
+        return "application/vnd.symjit.application"
+    return "application/octet-stream"
+
+
+def _distribution_version(name: str, fallback: str) -> str:
+    try:
+        return importlib.metadata.version(name)
+    except importlib.metadata.PackageNotFoundError:
+        return fallback
+
+
+def _mapping(value: object) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise TypeError("artifact metadata value must be an object")
+    return {str(key): item for key, item in value.items()}
+
+
+def _plain_mapping(value: Mapping[str, object]) -> dict[str, object]:
+    return _deep_plain(value)
+
+
+def _deep_plain(value: Mapping[str, object]) -> dict[str, object]:
+    def convert(item: object) -> object:
+        if isinstance(item, Mapping):
+            return {str(key): convert(entry) for key, entry in item.items()}
+        if isinstance(item, Sequence) and not isinstance(item, str | bytes):
+            return [convert(entry) for entry in item]
+        return item
+
+    return {str(key): convert(item) for key, item in value.items()}
+
+
+__all__ = [
+    "EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY",
+    "EAGER_PLAN_V3_ABI",
+    "EAGER_PLAN_V3_RUNTIME_CAPABILITY",
+    "EAGER_RUNTIME_CONTAINER_KIND",
+    "EAGER_RUNTIME_CONTAINER_SCHEMA_VERSION",
+    "EAGER_RUNTIME_LAYOUT_ABI",
+    "EAGER_RUNTIME_STORAGE_ABI",
+    "ON_THE_FLY_PUBLIC_METADATA_KIND",
+    "ON_THE_FLY_RUNTIME_CONTAINER_KIND",
+    "ON_THE_FLY_RUNTIME_CONTAINER_SCHEMA_VERSION",
+    "ON_THE_FLY_RUNTIME_KIND",
+    "ON_THE_FLY_RUNTIME_STORAGE_ABI",
+    "RECURRENCE_COLOR_RUNTIME_CAPABILITY",
+    "RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY",
+    "RECURRENCE_DIRECT_BACKEND_ABI",
+    "RECURRENCE_DIRECT_TEMPLATE_ABI",
+    "RECURRENCE_PLAN_ABI",
+    "RECURRENCE_RUNTIME_CONTAINER_KIND",
+    "RECURRENCE_RUNTIME_CONTAINER_SCHEMA_VERSION",
+    "RECURRENCE_RUNTIME_KIND",
+    "RECURRENCE_RUNTIME_LAYOUT_ABI",
+    "RECURRENCE_RUNTIME_STORAGE_ABI",
+    "ApiBundleHook",
+    "ArtifactWriteResult",
+    "CompiledExecutionArtifact",
+    "CompiledProcessArtifact",
+    "EagerPlanV3ProcessArtifact",
+    "OnTheFlyProcessArtifact",
+    "ProcessArtifact",
+    "RecurrenceHelicitySelectorPlanArtifact",
+    "RecurrenceProcessArtifact",
+    "build_api_validation_points",
+    "write_schema_v3_artifact",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/contracts.py b/pyamplicol/src/pyamplicol/generation/contracts.py
new file mode 100644
index 0000000000..3f2aa4279f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/contracts.py
@@ -0,0 +1,147 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import marshal
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+
+from ..models.base import Model
+from .dag_types import GenericDAG
+
+LC_SECTOR_SELECTOR_PARAMETER = "runtime.lc_sector_id"
+EXPRESSION_SCHEMA_CONTRACT_VERSION = 2
+_REQUIRED_RUNTIME_SCHEMA_KEYS = frozenset(
+    {
+        "amplitude_stage",
+        "current_storage",
+        "momentum_slots",
+        "parameter_layout",
+        "stages",
+        "value_storage",
+    }
+)
+@dataclass(frozen=True, slots=True)
+class RuntimeExpressionSchema:
+    """Canonical, dependency-neutral stage compiler input schema."""
+
+    canonical_json: str
+    contract_version: int = EXPRESSION_SCHEMA_CONTRACT_VERSION
+    _payload_blob: bytes = field(
+        init=False,
+        repr=False,
+        compare=False,
+        hash=False,
+    )
+
+    def __post_init__(self) -> None:
+        if self.contract_version != EXPRESSION_SCHEMA_CONTRACT_VERSION:
+            raise ValueError(
+                "unsupported runtime expression-schema contract version "
+                f"{self.contract_version}"
+            )
+        try:
+            payload = json.loads(self.canonical_json)
+        except json.JSONDecodeError as exc:
+            raise ValueError("runtime expression schema is not valid JSON") from exc
+        if not isinstance(payload, dict):
+            raise ValueError("runtime expression schema root must be an object")
+        missing = sorted(_REQUIRED_RUNTIME_SCHEMA_KEYS - payload.keys())
+        if missing:
+            raise ValueError(
+                "runtime expression schema is missing: " + ", ".join(missing)
+            )
+        # The blob is an immutable, process-local cache of already validated JSON.
+        # It is never persisted or loaded from untrusted input.
+        object.__setattr__(self, "_payload_blob", marshal.dumps(payload))
+
+    @classmethod
+    def from_mapping(
+        cls,
+        payload: Mapping[str, object] | RuntimeExpressionSchema,
+    ) -> RuntimeExpressionSchema:
+        if isinstance(payload, cls):
+            return payload
+        try:
+            canonical = json.dumps(
+                payload,
+                allow_nan=False,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+        except (TypeError, ValueError) as exc:
+            raise ValueError(
+                "runtime expression schema must contain canonical JSON values"
+            ) from exc
+        return cls(canonical_json=canonical)
+
+    def to_mapping(self) -> dict[str, object]:
+        payload = marshal.loads(self._payload_blob)
+        if not isinstance(payload, dict):  # pragma: no cover - internal invariant
+            raise RuntimeError("runtime expression schema cache is not an object")
+        return {str(key): value for key, value in payload.items()}
+
+    def __reduce__(self) -> tuple[object, tuple[str, int]]:
+        return type(self), (self.canonical_json, self.contract_version)
+
+    @property
+    def sha256(self) -> str:
+        return hashlib.sha256(self.canonical_json.encode("utf-8")).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class StageCompilationInput:
+    dag: GenericDAG
+    model: Model
+    runtime_schema: RuntimeExpressionSchema
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.dag, GenericDAG):
+            raise TypeError("stage compilation input requires a GenericDAG")
+        if not isinstance(self.model, Model):
+            raise TypeError("stage compilation input requires a Model")
+        if not isinstance(self.runtime_schema, RuntimeExpressionSchema):
+            raise TypeError(
+                "stage compilation input requires a RuntimeExpressionSchema"
+            )
+
+
+def runtime_coupling_parameter_names(
+    vertex_kind: int,
+    vertex_particles: Sequence[int],
+    coupling: Sequence[object],
+    *,
+    model: Model | None = None,
+) -> list[str | None]:
+    runtime_names = getattr(model, "runtime_parameter_names_for_vertex", None)
+    if callable(runtime_names):
+        return [str(name) for name in runtime_names(int(vertex_kind))]
+    lowering_rule = getattr(model, "vertex_lowering_rule", None)
+    if callable(lowering_rule):
+        rule = lowering_rule(int(vertex_kind))
+        if rule.coupling_mode in {"fixed", "none"}:
+            return [None for _value in coupling]
+    particles = "_".join(str(int(pdg)) for pdg in vertex_particles)
+    base = f"coupling.{int(vertex_kind)}.{particles}"
+    names: list[str | None] = []
+    for component, value in enumerate(coupling):
+        if not isinstance(value, str | int | float):
+            raise TypeError(
+                f"runtime coupling components must be numeric, got {value!r}"
+            )
+        numeric_value = float(value)
+        if component == 1 and numeric_value == -10.0:
+            names.append(None)
+        else:
+            names.append(f"{base}.component_{component}")
+    return names
+
+
+__all__ = [
+    "EXPRESSION_SCHEMA_CONTRACT_VERSION",
+    "LC_SECTOR_SELECTOR_PARAMETER",
+    "RuntimeExpressionSchema",
+    "StageCompilationInput",
+    "runtime_coupling_parameter_names",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/correlated.py b/pyamplicol/src/pyamplicol/generation/correlated.py
new file mode 100644
index 0000000000..dbe8160862
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/correlated.py
@@ -0,0 +1,494 @@
+# SPDX-License-Identifier: 0BSD
+"""Opt-in generation of complete coherent amplitudes and colour operators.
+
+The ordinary generator never imports this module.  This first implementation
+uses the existing generic compiled pipeline, but bypasses reductions whose
+proof applies only to physical-helicity squared amplitudes.  In particular,
+arbitrary external vector sources must not inherit physical-helicity zeros.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, replace
+from os import PathLike
+from pathlib import Path
+from types import MappingProxyType
+from typing import Literal, cast
+
+from pyamplicol.api.errors import GenerationError
+from pyamplicol.api.models import CompiledModel
+from pyamplicol.api.requests import ModelSource, ProcessSet
+from pyamplicol.api.results import GenerationResult
+from pyamplicol.artifacts import ArtifactBuilder
+from pyamplicol.color.correlator_matrices import (
+    build_color_correlator_matrices,
+    process_color_legs,
+)
+from pyamplicol.color.plan import GenericColorPlan, build_color_plan
+from pyamplicol.config import (
+    Action,
+    ColorContraction,
+    ColorFFTBasis,
+    ConfigClamp,
+    ConfigResolution,
+    EvaluatorExecutionMode,
+    GenerationConfig,
+    LCFlowLayout,
+    RelationDiscoveryMode,
+    RunConfig,
+)
+from pyamplicol.correlators import CorrelatorConfig
+from pyamplicol.models.base import Model
+from pyamplicol.processes.ir import CanonicalProcessIR
+from pyamplicol.reporting import ProgressSink
+
+from .artifact_writer import ApiBundleHook, ArtifactWriteResult
+from .contracts import RuntimeExpressionSchema
+from .dag_algorithms import _infer_minimal_coupling_order_limits_from_color_plan
+from .dag_compiler import compile_generic_dag
+from .dag_types import GenericDAG
+from .numerical_current_warmup import generic_dag_numerical_current_opt_out_report
+from .progress import PhaseHandle
+from .service import (
+    GenerationBackend,
+    _CompiledProcess,
+    _DagProcess,
+    _EvaluatorProcess,
+    _NoModelSupportedAmplitudes,
+    _PreparedProcessConstruction,
+    _ProcessSelection,
+)
+from .validation import build_validation_point
+
+CORRELATOR_PAYLOAD_PATH = "correlators.json"
+
+
+def correlated_configuration(
+    config: GenerationConfig | RunConfig | ConfigResolution | None,
+) -> ConfigResolution:
+    """Retain requested colour accuracy with direct/compiled source execution."""
+
+    if isinstance(config, ConfigResolution):
+        requested, effective, clamps = config.requested, config.effective, config.clamps
+    elif isinstance(config, RunConfig):
+        requested = effective = config
+        clamps = ()
+    elif config is None or isinstance(config, GenerationConfig):
+        requested = effective = RunConfig(
+            action=Action.GENERATE,
+            generation=GenerationConfig() if config is None else config,
+        )
+        clamps = ()
+    else:
+        raise TypeError("invalid correlated generation configuration")
+    if (
+        effective.color.contraction is ColorContraction.SYMMETRIC_GROUP_FFT
+        and effective.color.fft_basis is ColorFFTBasis.ADJOINT
+    ):
+        raise ValueError(
+            "adjoint FFT is not supported for correlated matrix elements; "
+            "use the direct colour contraction"
+        )
+    result = replace(
+        effective,
+        color=replace(
+            effective.color,
+            contraction=ColorContraction.DIRECT,
+            fft_basis=ColorFFTBasis.TRACE,
+            lc_flow_layout=LCFlowLayout.TOPOLOGY_REPLAY,
+        ),
+        evaluator=replace(
+            effective.evaluator, execution_mode=EvaluatorExecutionMode.COMPILED
+        ),
+        generation=replace(
+            effective.generation,
+            relation_discovery=replace(
+                effective.generation.relation_discovery, mode=RelationDiscoveryMode.OFF
+            ),
+        ),
+    )
+    paths = (
+        "color.contraction",
+        "color.fft_basis",
+        "color.lc_flow_layout",
+        "evaluator.execution_mode",
+        "generation.relation_discovery.mode",
+    )
+
+    def field(config: RunConfig, path: str) -> object:
+        value: object = config
+        for name in path.split("."):
+            value = getattr(value, name)
+        return value
+
+    adjustments = tuple(
+        ConfigClamp(
+            path=path,
+            requested=field(effective, path),
+            effective=field(result, path),
+            reason="correlations require complete coherent generic compiled amplitudes",
+        )
+        for path in paths
+        if field(effective, path) != field(result, path)
+    )
+    # The source configuration may already have resolved recurrence's auto
+    # compression to false. Re-select the default for this compiled lane, but
+    # retain explicit user or prepared-pack choices.
+    evaluator = result.evaluator
+    if requested.evaluator.jit.compress == "auto" and not any(
+        clamp.path == "evaluator.jit.compress" for clamp in clamps
+    ):
+        evaluator = replace(evaluator, jit=replace(evaluator.jit, compress="auto"))
+    result = replace(
+        result,
+        evaluator=replace(
+            evaluator,
+            jit=replace(evaluator.jit, compress=evaluator.resolved_jit_compress),
+        ),
+    )
+    return ConfigResolution(requested, result, (*clamps, *adjustments))
+
+
+@dataclass(frozen=True)
+class CorrelatedProcessMetadata:
+    """Generation-local inputs; no new serialized copy of the DAG or model."""
+
+    process: CanonicalProcessIR
+    color_plan: GenericColorPlan
+    runtime_schema: RuntimeExpressionSchema
+    aliases: tuple[Mapping[str, object], ...]
+
+
+class CorrelatedGenerationBackend(GenerationBackend):
+    """Safety lane sharing model resolution, stage compilation and publishing."""
+
+    def __init__(
+        self,
+        config: GenerationConfig | RunConfig | ConfigResolution | None,
+        progress: ProgressSink | None,
+        *,
+        declarations: CorrelatorConfig,
+        api_bundle_hook: ApiBundleHook | None = None,
+        process_selection: _ProcessSelection | None = None,
+    ) -> None:
+        if not isinstance(declarations, CorrelatorConfig):
+            raise TypeError("correlators must be a CorrelatorConfig")
+        super().__init__(
+            correlated_configuration(config),
+            progress,
+            api_bundle_hook=api_bundle_hook,
+            process_selection=process_selection,
+        )
+        self.declarations = declarations
+        self._correlated_processes: dict[str, CorrelatedProcessMetadata] = {}
+        selection = self._process_selection
+        partial = tuple(
+            name
+            for name in (
+                "max_color_sectors",
+                "reference_color_order",
+                "selected_color_sector_ids",
+                "selected_source_helicities",
+            )
+            if getattr(selection, name) is not None
+        )
+        if partial:
+            raise GenerationError(
+                "correlated generation requires complete colour and helicity coverage; "
+                "remove " + ", ".join(f"process.{name}" for name in partial)
+            )
+
+    @property
+    def _color_accuracy(self) -> str:
+        # The inherited setting selects the correlated metric, not the source
+        # basis or native ordinary consumer. All amplitudes remain full colour.
+        return "full"
+
+    @property
+    def process_metadata(self) -> Mapping[str, CorrelatedProcessMetadata]:
+        return MappingProxyType(self._correlated_processes)
+
+    def generate(
+        self,
+        processes: ProcessSet,
+        output: PathLike[str] | str,
+        *,
+        model: ModelSource | CompiledModel | None = None,
+        mode: str = "error",
+    ) -> GenerationResult:
+        if mode == "append":
+            raise GenerationError("correlated generation does not support append mode")
+        for alias in processes.aliases:
+            permutation = tuple(alias.particle_permutation)
+            if permutation and permutation != tuple(range(len(permutation))):
+                raise GenerationError(
+                    "correlated generation currently requires identity process aliases"
+                )
+        self._correlated_processes.clear()
+        return super().generate(processes, output, model=model, mode=mode)
+
+    def _prepare_process_construction(
+        self, process: CanonicalProcessIR, model: Model
+    ) -> _PreparedProcessConstruction:
+        if process.color_accuracy != "full":
+            raise GenerationError("correlated process expansion must use full colour")
+        by_label = {leg.label: leg for leg in process.legs}
+        for label in self.declarations.spin_legs:
+            leg = by_label.get(label)
+            if leg is None or leg.outgoing_pdg is None:
+                raise GenerationError(
+                    f"spin-correlated leg {label} is absent from {process.process!r}"
+                )
+            source = model._source_ir(int(leg.outgoing_pdg))
+            if (
+                source.wavefunction_family != "vector"
+                or source.component_dimension != 4
+            ):
+                raise GenerationError(
+                    f"spin-correlated leg {label} requires a full "
+                    "four-component vector source"
+                )
+        plan = build_color_plan(
+            process, color_accuracy="full", fold_trace_reflections=False
+        )
+        if not plan.sectors or plan.truncated:
+            raise GenerationError(
+                f"process {process.process!r} has no complete colour plan"
+            )
+        limits = self._coupling_order_limits
+        run = self._run_config
+        if run is not None and run.process.coupling_order_policy == "minimal":
+            limits = (
+                _infer_minimal_coupling_order_limits_from_color_plan(
+                    process,
+                    model=model,
+                    color_plan=plan,
+                    max_coupling_orders=limits or None,
+                )
+                or limits
+            )
+        return _PreparedProcessConstruction(
+            process=process,
+            complete_color_plan=plan,
+            restricted_color_plan=plan,
+            materialized_sector_ids=None,
+            coupling_order_limits=MappingProxyType(dict(limits)),
+            topology_replay=None,
+        )
+
+    def _compile_concrete_process(
+        self,
+        process: CanonicalProcessIR,
+        model: Model,
+        *,
+        progress_callback: Callable[[Mapping[str, str | int]], None] | None = None,
+    ) -> tuple[GenericDAG, dict[str, object]]:
+        prepared = self._prepare_process_construction(process, model)
+        limits = dict(prepared.coupling_order_limits)
+        dag = compile_generic_dag(
+            process,
+            model=model,
+            color_plan=prepared.complete_color_plan,
+            max_coupling_orders=limits or None,
+            max_quark_pairs=self._max_quark_pairs,
+            selected_source_helicities=None,
+            selected_color_sector_ids=None,
+            online_evaluation_reuse=False,
+            backward_live_planning=False,
+            lc_all_ordering_symmetry=False,
+            closure_side_mask_pruning=False,
+            color_order_mask_pruning=False,
+            species_reachability_pruning=False,
+            progress_callback=progress_callback,
+        )
+        if dag.truncated:
+            raise GenerationError(
+                f"process {process.process!r} DAG was unexpectedly truncated"
+            )
+        if not dag.has_amplitudes:
+            raise _NoModelSupportedAmplitudes(
+                f"process {process.process!r} has no model-supported "
+                "tree-level amplitudes"
+            )
+        return dag, {
+            "key": process.key,
+            "process": process.process,
+            "color_sector_count": dag.color_plan.sector_count,
+            "color_coverage": dag.color_coverage,
+            "helicity_coverage": dag.helicity_coverage,
+            "source_count": len(dag.sources),
+            "current_count": len(dag.currents),
+            "interaction_count": len(dag.interactions),
+            "interaction_evaluation_count": dag.interaction_evaluation_count,
+            "amplitude_root_count": len(dag.amplitude_roots),
+            "coupling_order_limits": limits,
+        }
+
+    def _prepare_warmup_process_inner(
+        self,
+        process: _DagProcess,
+        model: Model,
+        *,
+        index: int,
+        progress: PhaseHandle,
+    ) -> _CompiledProcess:
+        # No parity reduction, source-zero discovery, replay or numerical reuse.
+        # Even exact identities proved only on physical sources are inapplicable.
+        dag = process.dag
+        validation = self._generation_config.validation
+        sample_count = (
+            validation.samples
+            if validation.enabled and validation.post_build_validation
+            else 1
+        )
+        points = tuple(
+            build_validation_point(
+                dag,
+                model,
+                process_id=process.expanded.request.name,
+                seed=validation.seed + index * sample_count + sample_index,
+            )
+            for sample_index in range(sample_count)
+        )
+        relation = generic_dag_numerical_current_opt_out_report(
+            dag, execution_mode="compiled"
+        )
+        filters = {
+            "structural_helicity_reduction": {
+                "applied": False,
+                "before_amplitude_roots": len(dag.amplitude_roots),
+                "after_amplitude_roots": len(dag.amplitude_roots),
+                "mode": "complete correlated source basis",
+            },
+            "relation_discovery": relation,
+        }
+        progress.update(2, message="complete correlated source basis retained")
+        return _CompiledProcess(
+            expanded=process.expanded,
+            dag=dag,
+            helicity_sum_dag=None,
+            helicity_selector_union_dag=None,
+            coverage={**process.coverage, "relation_discovery": relation},
+            filters=filters,
+            validation_points=points,
+        )
+
+    def _construct_evaluator(
+        self, process: _CompiledProcess, model: Model, phase: PhaseHandle
+    ) -> _EvaluatorProcess:
+        result = super()._construct_evaluator(process, model, phase)
+        if (
+            result.helicity_sum_runtime_schema is not None
+            or result.helicity_selector_lanes
+            or result.color_selector_lanes
+        ):
+            raise GenerationError(
+                "correlated generation cannot contain companion or replay lanes"
+            )
+        # Full source coverage does not promise the separate native per-point
+        # selector ABI.  This lane deliberately has no selector/recurrence
+        # schedules; the correlated executor selects its coherent groups itself.
+        payload = result.runtime_schema.to_mapping()
+        physics = dict(cast(Mapping[str, object], payload["physics"]))
+        extensions = dict(cast(Mapping[str, object], physics.get("extensions", {})))
+        extensions.pop("runtime_selectors", None)
+        physics["extensions"] = extensions
+        payload["physics"] = physics
+        schema = RuntimeExpressionSchema.from_mapping(payload)
+        result = replace(
+            result,
+            runtime_schema=schema,
+            stage_input=replace(result.stage_input, runtime_schema=schema),
+        )
+        self._correlated_processes[process.expanded.request.name] = (
+            CorrelatedProcessMetadata(
+                process=process.dag.process,
+                color_plan=process.dag.color_plan,
+                runtime_schema=result.runtime_schema,
+                aliases=process.expanded.aliases,
+            )
+        )
+        return result
+
+    def correlator_payload(self) -> dict[str, object]:
+        """Build the declared exact matrices once, at the ordinary write boundary."""
+
+        processes: dict[str, object] = {}
+        for process_id, metadata in self._correlated_processes.items():
+            declarations = self.declarations._resolve_color(
+                process_color_legs(metadata.process)
+            )
+            amplitude = cast(
+                Mapping[str, object],
+                metadata.runtime_schema.to_mapping()["amplitude_stage"],
+            )
+            groups = cast(Sequence[Mapping[str, object]], amplitude["coherent_groups"])
+            basis_by_helicity: dict[tuple[int, ...], set[int]] = {}
+            for group in groups:
+                helicities = tuple(cast(Sequence[int], group["helicities"]))
+                sector_id = cast(int, group["color_sector_id"])
+                basis = basis_by_helicity.setdefault(helicities, set())
+                basis.add(sector_id)
+            if not basis_by_helicity:
+                raise GenerationError("correlated amplitudes have no coherent groups")
+            owners = next(iter(basis_by_helicity.values()))
+            if any(basis != owners for basis in basis_by_helicity.values()):
+                raise GenerationError(
+                    "correlated colour basis differs between retained helicities"
+                )
+            # Open-line colour plans retain aliases whose amplitudes already
+            # belong to canonical owners.  Never contract those aliases twice.
+            matrices = build_color_correlator_matrices(
+                metadata.color_plan,
+                declarations.color_requests,
+                sector_ids=sorted(owners),
+                color_accuracy=cast(
+                    Literal["lc", "nlc", "full"],
+                    self._run_config.color.accuracy
+                    if self._run_config is not None
+                    else "lc",
+                ),
+            )
+            processes[process_id] = {
+                "declarations": declarations.to_json_dict(),
+                "spin_legs": list(declarations.spin_legs),
+                "matrices": [matrix.to_json_dict() for matrix in matrices],
+                # The native execution schema keeps root group IDs but omits
+                # these compiler descriptors, needed only by this consumer.
+                "coherent_groups": groups,
+            }
+        return {
+            "schema_version": 1,
+            "complete_source_basis": True,
+            "declarations": self.declarations.to_json_dict(),
+            "processes": processes,
+        }
+
+    def _write_correlator_payload(
+        self, builder: ArtifactBuilder
+    ) -> Mapping[str, object]:
+        builder.add_json(
+            CORRELATOR_PAYLOAD_PATH, self.correlator_payload(), role="runtime-physics"
+        )
+        return {"correlators": {"schema_version": 1, "path": CORRELATOR_PAYLOAD_PATH}}
+
+    def _write_artifact(self, *args: object, **kwargs: object) -> ArtifactWriteResult:
+        return super()._write_artifact(
+            *args, **kwargs, payload_hook=self._write_correlator_payload
+        )
+
+
+def generate_correlated(
+    processes: ProcessSet,
+    destination: str | Path,
+    *,
+    declarations: CorrelatorConfig,
+    config: GenerationConfig | RunConfig | ConfigResolution | None = None,
+    progress: ProgressSink | None = None,
+    model: ModelSource | CompiledModel | None = None,
+    mode: Literal["error", "append", "replace"] = "error",
+) -> GenerationResult:
+    return CorrelatedGenerationBackend(
+        config, progress, declarations=declarations
+    ).generate(processes, destination, model=model, mode=mode)
diff --git a/pyamplicol/src/pyamplicol/generation/current_plan.py b/pyamplicol/src/pyamplicol/generation/current_plan.py
new file mode 100644
index 0000000000..0551b52c1c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/current_plan.py
@@ -0,0 +1,509 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+
+from ..color.plan import GenericColorPlan
+from ..models.base import Model
+from ..processes.ir import CanonicalProcessIR
+from .dag_algorithms import contributing_color_sector_ids
+from .dag_compiler import GenericDAGCompiler
+from .dag_types import (
+    AmplitudeRoot,
+    CurrentNode,
+    GenericDAG,
+    InteractionNode,
+)
+
+GenericCurrentNode = CurrentNode
+GenericInteractionNode = InteractionNode
+GenericClosureNode = AmplitudeRoot
+
+
+@dataclass(frozen=True)
+class GenericColorSectorUseSummary:
+    color_sector: int
+    current_count: int
+    interaction_count: int
+    closure_count: int
+    required_vertex_kind_counts: tuple[tuple[int, int], ...]
+    ready_vertex_kinds: tuple[int, ...]
+    pending_vertex_kinds: tuple[int, ...]
+    unimplemented_vertex_kinds: tuple[int, ...]
+
+    @property
+    def full_tensor_network_ready(self) -> bool:
+        return not self.pending_vertex_kinds and not self.unimplemented_vertex_kinds
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "color_sector": self.color_sector,
+            "current_count": self.current_count,
+            "interaction_count": self.interaction_count,
+            "closure_count": self.closure_count,
+            "full_tensor_network_ready": self.full_tensor_network_ready,
+            "required_vertex_kind_counts": [
+                [kind, count] for kind, count in self.required_vertex_kind_counts
+            ],
+            "ready_vertex_kinds": list(self.ready_vertex_kinds),
+            "pending_vertex_kinds": list(self.pending_vertex_kinds),
+            "unimplemented_vertex_kinds": list(self.unimplemented_vertex_kinds),
+        }
+
+
+@dataclass(frozen=True)
+class GenericCurrentStage:
+    stage_index: int
+    subset_size: int
+    current_ids: tuple[int, ...]
+    interaction_ids: tuple[int, ...]
+    required_vertex_kind_counts: tuple[tuple[int, int], ...]
+    ready_vertex_kinds: tuple[int, ...]
+    pending_vertex_kinds: tuple[int, ...]
+    unimplemented_vertex_kinds: tuple[int, ...]
+    color_sector_summaries: tuple[GenericColorSectorUseSummary, ...]
+
+    @property
+    def full_tensor_network_ready(self) -> bool:
+        return not self.pending_vertex_kinds and not self.unimplemented_vertex_kinds
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "stage_index": self.stage_index,
+            "subset_size": self.subset_size,
+            "current_ids": list(self.current_ids),
+            "interaction_ids": list(self.interaction_ids),
+            "interaction_count": len(self.interaction_ids),
+            "full_tensor_network_ready": self.full_tensor_network_ready,
+            "required_vertex_kind_counts": [
+                [kind, count] for kind, count in self.required_vertex_kind_counts
+            ],
+            "ready_vertex_kinds": list(self.ready_vertex_kinds),
+            "pending_vertex_kinds": list(self.pending_vertex_kinds),
+            "unimplemented_vertex_kinds": list(self.unimplemented_vertex_kinds),
+            "color_sector_summaries": [
+                summary.to_json_dict() for summary in self.color_sector_summaries
+            ],
+        }
+
+
+@dataclass(frozen=True)
+class GenericAmplitudeStage:
+    closure_ids: tuple[int, ...]
+    required_vertex_kind_counts: tuple[tuple[int, int], ...]
+    ready_vertex_kinds: tuple[int, ...]
+    pending_vertex_kinds: tuple[int, ...]
+    unimplemented_vertex_kinds: tuple[int, ...]
+    color_sector_summaries: tuple[GenericColorSectorUseSummary, ...]
+
+    @property
+    def full_tensor_network_ready(self) -> bool:
+        return (
+            bool(self.closure_ids)
+            and not self.pending_vertex_kinds
+            and not self.unimplemented_vertex_kinds
+        )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "closure_ids": list(self.closure_ids),
+            "closure_count": len(self.closure_ids),
+            "full_tensor_network_ready": self.full_tensor_network_ready,
+            "required_vertex_kind_counts": [
+                [kind, count] for kind, count in self.required_vertex_kind_counts
+            ],
+            "ready_vertex_kinds": list(self.ready_vertex_kinds),
+            "pending_vertex_kinds": list(self.pending_vertex_kinds),
+            "unimplemented_vertex_kinds": list(self.unimplemented_vertex_kinds),
+            "color_sector_summaries": [
+                summary.to_json_dict() for summary in self.color_sector_summaries
+            ],
+        }
+
+
+@dataclass(frozen=True)
+class GenericStagePlan:
+    process: CanonicalProcessIR
+    current_stages: tuple[GenericCurrentStage, ...]
+    amplitude_stage: GenericAmplitudeStage
+
+    @property
+    def stage_count(self) -> int:
+        return len(self.current_stages) + 1
+
+    @property
+    def full_tensor_network_ready(self) -> bool:
+        return self.amplitude_stage.full_tensor_network_ready and all(
+            stage.full_tensor_network_ready for stage in self.current_stages
+        )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "process": self.process.to_json_dict(),
+            "stage_count": self.stage_count,
+            "full_tensor_network_ready": self.full_tensor_network_ready,
+            "current_stages": [stage.to_json_dict() for stage in self.current_stages],
+            "amplitude_stage": self.amplitude_stage.to_json_dict(),
+        }
+
+
+@dataclass(frozen=True)
+class GenericCurrentPlan:
+    """Compatibility view over the production `GenericDAG`.
+
+    This module intentionally no longer owns an independent recursion
+    implementation.  All current identities come from `generic_dag.CurrentIndex`,
+    so process-support diagnostics and tests inspect the same model-driven DAG
+    compiler used by schema-v3 artifacts.
+    """
+
+    dag: GenericDAG
+    model: Model
+
+    @property
+    def process(self) -> CanonicalProcessIR:
+        return self.dag.process
+
+    @property
+    def color_plan(self) -> GenericColorPlan:
+        return self.dag.color_plan
+
+    @property
+    def currents(self) -> tuple[CurrentNode, ...]:
+        return self.dag.currents
+
+    @property
+    def sources(self) -> tuple[int, ...]:
+        return self.dag.sources
+
+    @property
+    def interactions(self) -> tuple[InteractionNode, ...]:
+        return self.dag.interactions
+
+    @property
+    def closures(self) -> tuple[AmplitudeRoot, ...]:
+        return self.dag.amplitude_roots
+
+    @property
+    def truncated(self) -> bool:
+        return self.dag.truncated
+
+    @property
+    def color_sectors(self) -> tuple[int, ...]:
+        root_sectors = contributing_color_sector_ids(self.dag)
+        if root_sectors:
+            return root_sectors
+        return tuple(
+            sorted({current.index.color_state.sector_id for current in self.currents})
+        )
+
+    @property
+    def has_closure(self) -> bool:
+        return bool(self.closures)
+
+    @property
+    def required_vertex_kind_counts(self) -> tuple[tuple[int, int], ...]:
+        return _vertex_kind_counts(self.interactions, self.closures)
+
+    @property
+    def ready_vertex_kinds(self) -> tuple[int, ...]:
+        return _vertex_kind_status(
+            (kind for kind, _ in self.required_vertex_kind_counts),
+            self.model,
+        )[0]
+
+    @property
+    def pending_vertex_kinds(self) -> tuple[int, ...]:
+        return _vertex_kind_status(
+            (kind for kind, _ in self.required_vertex_kind_counts),
+            self.model,
+        )[1]
+
+    @property
+    def unimplemented_vertex_kinds(self) -> tuple[int, ...]:
+        return _vertex_kind_status(
+            (kind for kind, _ in self.required_vertex_kind_counts),
+            self.model,
+        )[2]
+
+    @property
+    def full_tensor_network_ready(self) -> bool:
+        return (
+            self.has_closure
+            and not self.truncated
+            and not self.pending_vertex_kinds
+            and not self.unimplemented_vertex_kinds
+        )
+
+    def build_stage_plan(self) -> GenericStagePlan:
+        return build_generic_stage_plan(self)
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "process": self.process.to_json_dict(),
+            "color_plan": self.color_plan.to_json_dict(),
+            "current_count": len(self.currents),
+            "source_count": len(self.sources),
+            "interaction_count": len(self.interactions),
+            "closure_count": len(self.closures),
+            "truncated": self.truncated,
+            "has_closure": self.has_closure,
+            "full_tensor_network_ready": self.full_tensor_network_ready,
+            "required_vertex_kind_counts": [
+                [kind, count] for kind, count in self.required_vertex_kind_counts
+            ],
+            "ready_vertex_kinds": list(self.ready_vertex_kinds),
+            "pending_vertex_kinds": list(self.pending_vertex_kinds),
+            "unimplemented_vertex_kinds": list(self.unimplemented_vertex_kinds),
+            "currents": [current.to_json_dict() for current in self.currents],
+            "sources": list(self.sources),
+            "interactions": [
+                interaction.to_json_dict() for interaction in self.interactions
+            ],
+            "closures": [closure.to_json_dict() for closure in self.closures],
+            "color_sector_summaries": [
+                summary.to_json_dict()
+                for summary in _sector_summaries(
+                    self.currents,
+                    self.interactions,
+                    self.closures,
+                    self.model,
+                )
+            ],
+        }
+
+
+def build_generic_current_plan(
+    process: CanonicalProcessIR | GenericDAG,
+    *,
+    model: Model,
+    max_currents: int | None = None,
+    max_color_sectors: int | None = None,
+    reference_color_order: tuple[int, ...] | None = None,
+    selected_color_sector_ids: Iterable[int] | None = None,
+    max_coupling_orders: Mapping[str, int] | None = None,
+    max_lc_current_line_groups: int | None = None,
+    max_quark_pairs: int | None = None,
+    closure_side_mask_pruning: bool = True,
+    color_order_mask_pruning: bool = True,
+    species_reachability_pruning: bool = True,
+    ignored_particle_ids: Iterable[int] | None = None,
+    ignored_vertex_kinds: Iterable[int] | None = None,
+) -> GenericCurrentPlan:
+    dag = (
+        process
+        if isinstance(process, GenericDAG)
+        else GenericDAGCompiler(
+            model=model,
+            max_currents=max_currents,
+            max_color_sectors=max_color_sectors,
+            reference_color_order=reference_color_order,
+            selected_color_sector_ids=selected_color_sector_ids,
+            max_coupling_orders=max_coupling_orders,
+            max_lc_current_line_groups=max_lc_current_line_groups,
+            max_quark_pairs=max_quark_pairs,
+            closure_side_mask_pruning=closure_side_mask_pruning,
+            color_order_mask_pruning=color_order_mask_pruning,
+            species_reachability_pruning=species_reachability_pruning,
+            ignored_particle_ids=ignored_particle_ids,
+            ignored_vertex_kinds=ignored_vertex_kinds,
+        ).compile(process)
+    )
+    return GenericCurrentPlan(dag=dag, model=model)
+
+
+def build_generic_stage_plan(
+    plan: GenericCurrentPlan,
+) -> GenericStagePlan:
+    current_plan = plan
+    stages: list[GenericCurrentStage] = []
+    interactions_by_subset: dict[int, list[InteractionNode]] = {}
+    for interaction in current_plan.interactions:
+        result = current_plan.currents[interaction.result_id]
+        subset_size = len(result.index.external_labels)
+        interactions_by_subset.setdefault(subset_size, []).append(interaction)
+
+    for stage_index, subset_size in enumerate(sorted(interactions_by_subset)):
+        interactions = tuple(interactions_by_subset[subset_size])
+        current_ids = tuple(
+            sorted({interaction.result_id for interaction in interactions})
+        )
+        vertex_counts = _vertex_kind_counts(interactions, ())
+        ready, pending, unimplemented = _vertex_kind_status(
+            (kind for kind, _ in vertex_counts),
+            current_plan.model,
+        )
+        stages.append(
+            GenericCurrentStage(
+                stage_index=stage_index,
+                subset_size=subset_size,
+                current_ids=current_ids,
+                interaction_ids=tuple(interaction.id for interaction in interactions),
+                required_vertex_kind_counts=vertex_counts,
+                ready_vertex_kinds=ready,
+                pending_vertex_kinds=pending,
+                unimplemented_vertex_kinds=unimplemented,
+                color_sector_summaries=_sector_summaries(
+                    current_plan.currents,
+                    interactions,
+                    (),
+                    current_plan.model,
+                ),
+            )
+        )
+
+    closure_counts = _vertex_kind_counts((), current_plan.closures)
+    ready, pending, unimplemented = _vertex_kind_status(
+        (kind for kind, _ in closure_counts),
+        current_plan.model,
+    )
+    amplitude_stage = GenericAmplitudeStage(
+        closure_ids=tuple(closure.id for closure in current_plan.closures),
+        required_vertex_kind_counts=closure_counts,
+        ready_vertex_kinds=ready,
+        pending_vertex_kinds=pending,
+        unimplemented_vertex_kinds=unimplemented,
+        color_sector_summaries=_sector_summaries(
+            current_plan.currents,
+            (),
+            current_plan.closures,
+            current_plan.model,
+        ),
+    )
+    return GenericStagePlan(
+        process=current_plan.process,
+        current_stages=tuple(stages),
+        amplitude_stage=amplitude_stage,
+    )
+
+
+def _vertex_kind_counts(
+    interactions: Iterable[InteractionNode],
+    closures: Iterable[AmplitudeRoot],
+) -> tuple[tuple[int, int], ...]:
+    counts: Counter[int] = Counter(
+        interaction.vertex_kind for interaction in interactions
+    )
+    counts.update(
+        int(closure.vertex_kind)
+        for closure in closures
+        if closure.vertex_kind is not None
+    )
+    return tuple(sorted(counts.items()))
+
+
+def _vertex_kind_status(
+    kinds: Iterable[int],
+    model: Model,
+) -> tuple[tuple[int, ...], tuple[int, ...], tuple[int, ...]]:
+    ready: set[int] = set()
+    pending: set[int] = set()
+    unimplemented: set[int] = set()
+    for kind in kinds:
+        rule = model.vertex_lowering_rule(kind)
+        if rule.backend == "unimplemented":
+            unimplemented.add(kind)
+        elif rule.full_tensor_network_ready:
+            ready.add(kind)
+        else:
+            pending.add(kind)
+    return tuple(sorted(ready)), tuple(sorted(pending)), tuple(sorted(unimplemented))
+
+
+def _sector_summaries(
+    currents: tuple[CurrentNode, ...],
+    interactions: Iterable[InteractionNode],
+    closures: Iterable[AmplitudeRoot],
+    model: Model,
+) -> tuple[GenericColorSectorUseSummary, ...]:
+    current_ids_by_sector: dict[int, set[int]] = {}
+    interactions_by_sector: dict[int, dict[int, InteractionNode]] = {}
+    closures_by_sector: dict[int, list[AmplitudeRoot]] = {}
+    interaction_tuple = tuple(interactions)
+    closure_tuple = tuple(closures)
+    interactions_by_result: dict[int, list[InteractionNode]] = {}
+    for interaction in interaction_tuple:
+        interactions_by_result.setdefault(interaction.result_id, []).append(interaction)
+    if closure_tuple:
+        for closure in closure_tuple:
+            sector = _closure_color_sector(currents, closure)
+            closures_by_sector.setdefault(sector, []).append(closure)
+            seen_currents = current_ids_by_sector.setdefault(sector, set())
+            sector_interactions = interactions_by_sector.setdefault(sector, {})
+            stack = [closure.left_id, closure.right_id]
+            while stack:
+                current_id = stack.pop()
+                if current_id in seen_currents:
+                    continue
+                seen_currents.add(current_id)
+                for interaction in interactions_by_result.get(current_id, ()):
+                    sector_interactions.setdefault(interaction.id, interaction)
+                    stack.extend((interaction.left_id, interaction.right_id))
+    else:
+        for current in currents:
+            current_ids_by_sector.setdefault(
+                current.index.color_state.sector_id,
+                set(),
+            ).add(current.id)
+        for interaction in interaction_tuple:
+            sector = currents[interaction.result_id].index.color_state.sector_id
+            interactions_by_sector.setdefault(sector, {})[interaction.id] = interaction
+            current_ids_by_sector.setdefault(sector, set()).update(
+                (interaction.left_id, interaction.right_id, interaction.result_id)
+            )
+    summaries = []
+    for sector in sorted(
+        set(interactions_by_sector)
+        | set(closures_by_sector)
+        | set(current_ids_by_sector)
+    ):
+        sector_interaction_nodes = tuple(
+            interactions_by_sector.get(sector, {}).values()
+        )
+        sector_closures = tuple(closures_by_sector.get(sector, ()))
+        vertex_counts = _vertex_kind_counts(
+            sector_interaction_nodes,
+            sector_closures,
+        )
+        ready, pending, unimplemented = _vertex_kind_status(
+            (kind for kind, _ in vertex_counts),
+            model,
+        )
+        summaries.append(
+            GenericColorSectorUseSummary(
+                color_sector=sector,
+                current_count=len(current_ids_by_sector.get(sector, ())),
+                interaction_count=len(sector_interaction_nodes),
+                closure_count=len(sector_closures),
+                required_vertex_kind_counts=vertex_counts,
+                ready_vertex_kinds=ready,
+                pending_vertex_kinds=pending,
+                unimplemented_vertex_kinds=unimplemented,
+            )
+        )
+    return tuple(summaries)
+
+
+def _closure_color_sector(
+    currents: tuple[CurrentNode, ...],
+    closure: AmplitudeRoot,
+) -> int:
+    if closure.color_sector_id is not None:
+        return int(closure.color_sector_id)
+    return int(currents[closure.left_id].index.color_state.sector_id)
+
+
+__all__ = [
+    "GenericAmplitudeStage",
+    "GenericClosureNode",
+    "GenericColorSectorUseSummary",
+    "GenericCurrentNode",
+    "GenericCurrentPlan",
+    "GenericCurrentStage",
+    "GenericInteractionNode",
+    "GenericStagePlan",
+    "build_generic_current_plan",
+    "build_generic_stage_plan",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/dag_algorithms.py b/pyamplicol/src/pyamplicol/generation/dag_algorithms.py
new file mode 100644
index 0000000000..dcf526d0aa
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/dag_algorithms.py
@@ -0,0 +1,1883 @@
+# SPDX-License-Identifier: 0BSD
+"""Post-processing and selection transforms for generic DAGs."""
+
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass, field, replace
+from itertools import pairwise
+from typing import cast
+
+from ..color.plan import GenericColorPlan, build_color_plan
+from ..color.plan_types import _canonical_open_string_product_key
+from ..models._physics_ir import ContractionIR
+from ..models.base import (
+    CouplingOrders,
+    Model,
+    QuantumFlow,
+    QuantumNumberFlow,
+    Vertex,
+)
+from ..processes.ir import CanonicalProcessIR
+from .dag_color import ColorEngine
+from .dag_ordering import (
+    _closure_candidate_splits,
+    _closure_side_reachable_masks,
+    _complex_weight_mul,
+    _direct_contraction_ir,
+    _labels_mask,
+    _lc_color_order_reachable_masks,
+    _mask_labels,
+)
+from .dag_reachability import (
+    UsefulStateMap,
+    _closure_total_coupling_orders,
+    _combine_coupling_order_tuples,
+    _coupling_order_degree,
+    _coupling_order_envelope,
+    _coupling_orders_within_limits,
+    _lc_line_groups_within_limit,
+    _mask_allowed_by_reachability,
+    _masks_by_size,
+    _normalize_coupling_order_limits,
+    _ordered_splits,
+    _right_particles_by_left,
+    _state_allowed_by_reachability,
+)
+from .dag_types import (
+    AmplitudeRoot,
+    ColorFlow,
+    ColorState,
+    CurrentIndex,
+    CurrentNode,
+    GenericDAG,
+    InteractionNode,
+)
+from .helicity_replay import _semantic_amplitude_root_alias_signatures
+
+
+def _normalize_generation_cap(value: int | None) -> int | None:
+    if value is None:
+        return None
+    normalized = int(value)
+    return None if normalized < 0 else normalized
+
+
+@dataclass(frozen=True, slots=True)
+class _LiveCurrentShape:
+    external_mask: int
+    external_labels: tuple[int, ...]
+    particle_id: int
+    ordered_external_labels: tuple[int, ...]
+    color_state: ColorState
+    coupling_orders: CouplingOrders
+    chirality: int
+    spin_state: int | tuple[int, ...]
+    flavour_flow: tuple[int, ...]
+    quantum_number_flow: QuantumNumberFlow
+    _hash: int = field(init=False, repr=False, compare=False)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "_hash",
+            hash(
+                (
+                    self.external_mask,
+                    self.external_labels,
+                    self.particle_id,
+                    self.ordered_external_labels,
+                    self.color_state,
+                    self.coupling_orders,
+                    self.chirality,
+                    self.spin_state,
+                    self.flavour_flow,
+                    self.quantum_number_flow,
+                )
+            ),
+        )
+
+    def __hash__(self) -> int:
+        return self._hash
+
+
+@dataclass(frozen=True, slots=True)
+class BackwardLiveTransition:
+    """One model-certified abstract current invocation retained by liveness."""
+
+    left: _LiveCurrentShape
+    right: _LiveCurrentShape
+    result: _LiveCurrentShape
+    vertex_kind: int
+    vertex_particles: tuple[int, int, int]
+    coupling: tuple[float, float]
+    color_weight: tuple[float, float]
+
+
+@dataclass(frozen=True, slots=True)
+class BackwardLiveClosure:
+    """One model-certified abstract amplitude closure."""
+
+    left: _LiveCurrentShape
+    right: _LiveCurrentShape
+    kind: str
+    color_weight: tuple[float, float]
+    contraction_ir: ContractionIR
+    color_sector_id: int | None
+    vertex_kind: int | None = None
+    vertex_particles: tuple[int, int, int] | None = None
+    coupling: tuple[float, float] = (1.0, 0.0)
+
+
+@dataclass(frozen=True, slots=True)
+class BackwardLiveSource:
+    """One retained source with its original ancestry-bit allocation."""
+
+    shape: _LiveCurrentShape
+    helicity_ancestry: int
+    leg_label: int
+    source_helicity: int
+
+
+@dataclass(frozen=True, slots=True)
+class BackwardLiveStatePlan:
+    """Conservative exact-colour states that can feed a physical closure.
+
+    The planner tracks model quantum flow but intentionally omits helicity
+    ancestry and tensor payloads. A retained shape can therefore still produce
+    more than one exact current, while a valid exact current cannot be removed
+    solely because of those omitted fields. This makes the plan suitable as an
+    eager-only construction filter without introducing a second physics
+    implementation.
+    """
+
+    shapes: frozenset[_LiveCurrentShape]
+    active_sector_ids: frozenset[int]
+    transitions: tuple[BackwardLiveTransition, ...]
+    closures: tuple[BackwardLiveClosure, ...]
+    sources: tuple[BackwardLiveSource, ...]
+
+    def allows(self, index: CurrentIndex) -> bool:
+        return _live_current_shape(index) in self.shapes
+
+
+def _live_current_shape(index: CurrentIndex) -> _LiveCurrentShape:
+    return _LiveCurrentShape(
+        external_mask=int(index.external_mask),
+        external_labels=tuple(index.external_labels),
+        particle_id=int(index.particle_id),
+        ordered_external_labels=tuple(index.ordered_external_labels),
+        color_state=index.color_state,
+        coupling_orders=tuple(index.coupling_orders),
+        chirality=int(index.chirality),
+        spin_state=index.spin_state,
+        flavour_flow=tuple(index.flavour_flow),
+        quantum_number_flow=index.quantum_number_flow,
+    )
+
+
+def build_backward_live_state_plan(
+    process: CanonicalProcessIR,
+    *,
+    model: Model,
+    color_engine: ColorEngine,
+    closure_candidate_splits: Sequence[tuple[int, int]],
+    closure_reachable_masks: frozenset[int] | None,
+    color_order_reachable_masks: frozenset[int] | None,
+    useful_states_by_mask: UsefulStateMap | None,
+    max_coupling_orders: Mapping[str, int],
+    max_lc_current_line_groups: int | None,
+    ignored_particle_ids: frozenset[int],
+    ignored_vertex_kinds: frozenset[int],
+    selected_source_helicities: Mapping[int, int] | None,
+    global_flip_anchor: tuple[int, int] | None,
+) -> BackwardLiveStatePlan | None:
+    """Build an eager-only demand plan from physical amplitude sinks.
+
+    Multi-line colour plans may enumerate many traversal sectors although the
+    recursion uses one physical sink.  The forward compiler previously built
+    every helicity and quantum-flow current in all of them before discovering
+    at closure that most sectors were dead.  This prepass first keeps only
+    physical words ending at a configured sink, then performs a lightweight
+    model-driven recursion over particle species, coupling orders, ordered
+    labels, and exact colour states.  A final backward walk retains only shapes
+    feeding a model-supported direct or vertex closure.
+
+    Shared-ordering and single-trace plans already collapse sectors before the
+    current sweep.  They deliberately stay on the existing path because this
+    planner would not remove work there.
+    """
+
+    color_plan = color_engine.color_plan
+    if (
+        color_plan.color_accuracy == "lc"
+        or color_engine.shared_lc_orderings
+        or color_engine.shared_single_trace
+        or len(color_plan.sectors) <= 1
+    ):
+        return None
+
+    active_sector_ids = _physical_sink_sector_ids(
+        color_plan,
+        closure_candidate_splits,
+    )
+    if active_sector_ids is None:
+        return None
+
+    full_mask = _labels_mask(leg.label for leg in process.legs)
+    possible_by_mask: dict[int, list[_LiveCurrentShape]] = {}
+    possible_seen: set[_LiveCurrentShape] = set()
+    reverse_transitions: dict[
+        _LiveCurrentShape,
+        set[tuple[_LiveCurrentShape, _LiveCurrentShape]],
+    ] = {}
+    transitions: list[BackwardLiveTransition] = []
+
+    def state_allowed(shape: _LiveCurrentShape) -> bool:
+        if useful_states_by_mask is None:
+            return True
+        return _state_allowed_by_reachability(
+            useful_states_by_mask,
+            shape.external_mask,
+            shape.particle_id,
+            shape.coupling_orders,
+        )
+
+    def add_shape(shape: _LiveCurrentShape) -> bool:
+        if shape in possible_seen or not state_allowed(shape):
+            return False
+        possible_seen.add(shape)
+        possible_by_mask.setdefault(shape.external_mask, []).append(shape)
+        return True
+
+    source_candidates: list[BackwardLiveSource] = []
+    next_source_bit = 0
+    for leg in process.legs:
+        if leg.outgoing_pdg is None:
+            continue
+        particle_id = int(leg.outgoing_pdg)
+        if particle_id in ignored_particle_ids:
+            continue
+        mask = 1 << (leg.label - 1)
+        source_ir = model._source_ir(particle_id)
+        source_states = tuple(
+            source_ir.crossing.apply(state) if leg.is_initial else state
+            for state in source_ir.states
+        )
+        source_quantum_flow = model.quantum_number_flow(particle_id)
+        for color_state in color_engine.source_states_for_leg(leg):
+            if not _lc_line_groups_within_limit(
+                color_state,
+                max_lc_current_line_groups,
+            ):
+                continue
+            color_state_is_live = color_state.sector_id in active_sector_ids
+            for source_state in source_states:
+                source_helicity = int(source_state.helicity)
+                if (
+                    global_flip_anchor is not None
+                    and leg.label == global_flip_anchor[0]
+                    and source_helicity != global_flip_anchor[1]
+                ):
+                    next_source_bit += 1
+                    continue
+                requested_helicity = (selected_source_helicities or {}).get(
+                    int(leg.label)
+                )
+                if requested_helicity is not None and source_helicity != int(
+                    requested_helicity
+                ):
+                    continue
+                helicity_ancestry = 1 << next_source_bit
+                next_source_bit += 1
+                if not color_state_is_live:
+                    continue
+                source_shape = _LiveCurrentShape(
+                    external_mask=mask,
+                    external_labels=(int(leg.label),),
+                    particle_id=particle_id,
+                    ordered_external_labels=(int(leg.label),),
+                    color_state=color_state,
+                    coupling_orders=(),
+                    chirality=int(source_state.chirality),
+                    spin_state=source_state.spin_state,
+                    flavour_flow=(particle_id,),
+                    quantum_number_flow=source_quantum_flow,
+                )
+                add_shape(source_shape)
+                if source_shape in possible_seen:
+                    source_candidates.append(
+                        BackwardLiveSource(
+                            shape=source_shape,
+                            helicity_ancestry=helicity_ancestry,
+                            leg_label=int(leg.label),
+                            source_helicity=source_helicity,
+                        )
+                    )
+
+    right_particles_by_left = _right_particles_by_left(
+        model,
+        color_accuracy=process.color_accuracy,
+    )
+    vertices_by_input: dict[tuple[int, int], tuple[Vertex, ...]] = {}
+    vertex_allowed_cache: dict[Vertex, bool] = {}
+    duplicate_orientation_cache: dict[Vertex, bool] = {}
+    coupling_orders_cache: dict[Vertex, CouplingOrders] = {}
+    vertex_color_weight_cache: dict[Vertex, tuple[float, float]] = {}
+    combined_orders_cache: dict[
+        tuple[CouplingOrders, CouplingOrders, Vertex],
+        CouplingOrders,
+    ] = {}
+    orders_allowed_cache: dict[CouplingOrders, bool] = {}
+    quantum_flow_cache: dict[tuple[object, ...], tuple[QuantumFlow, ...]] = {}
+    color_flow_cache: dict[tuple[object, ...], tuple[ColorFlow, ...]] = {}
+    for mask in _masks_by_size(full_mask):
+        if mask & (mask - 1) == 0 or mask == full_mask:
+            continue
+        if not _mask_allowed_by_reachability(
+            mask,
+            closure_reachable_masks,
+            color_order_reachable_masks,
+        ):
+            continue
+        if useful_states_by_mask is not None and mask not in useful_states_by_mask:
+            continue
+        labels = _mask_labels(mask)
+        for left_mask, right_mask in _ordered_splits(mask):
+            left_shapes = possible_by_mask.get(left_mask)
+            right_shapes = possible_by_mask.get(right_mask)
+            if not left_shapes or not right_shapes:
+                continue
+            right_by_sector_particle: dict[
+                tuple[int, int], list[_LiveCurrentShape]
+            ] = {}
+            for right_shape in right_shapes:
+                right_by_sector_particle.setdefault(
+                    (
+                        right_shape.color_state.sector_id,
+                        right_shape.particle_id,
+                    ),
+                    [],
+                ).append(right_shape)
+            for left_shape in tuple(left_shapes):
+                left_index = cast(CurrentIndex, left_shape)
+                for right_particle in right_particles_by_left.get(
+                    left_shape.particle_id,
+                    (),
+                ):
+                    for right_shape in right_by_sector_particle.get(
+                        (left_shape.color_state.sector_id, right_particle),
+                        (),
+                    ):
+                        right_index = cast(CurrentIndex, right_shape)
+                        input_key = (
+                            left_shape.particle_id,
+                            right_shape.particle_id,
+                        )
+                        vertices = vertices_by_input.get(input_key)
+                        if vertices is None:
+                            vertices = model.vertices_accepting(
+                                *input_key,
+                                color_accuracy=process.color_accuracy,
+                            )
+                            vertices_by_input[input_key] = vertices
+                        for vertex in vertices:
+                            if (
+                                vertex.kind in ignored_vertex_kinds
+                                or vertex.particles[2] in ignored_particle_ids
+                            ):
+                                continue
+                            vertex_allowed = vertex_allowed_cache.get(vertex)
+                            if vertex_allowed is None:
+                                vertex_allowed = color_engine.vertex_allowed(vertex)
+                                vertex_allowed_cache[vertex] = vertex_allowed
+                            if not vertex_allowed:
+                                continue
+                            duplicate = duplicate_orientation_cache.get(vertex)
+                            if duplicate is None:
+                                duplicate = model.skip_duplicate_vertex_orientation(
+                                    vertex
+                                )
+                                duplicate_orientation_cache[vertex] = duplicate
+                            if duplicate:
+                                continue
+                            vertex_orders = coupling_orders_cache.get(vertex)
+                            if vertex_orders is None:
+                                vertex_orders = model.vertex_coupling_orders(vertex)
+                                coupling_orders_cache[vertex] = vertex_orders
+                            orders_key = (
+                                left_shape.coupling_orders,
+                                right_shape.coupling_orders,
+                                vertex,
+                            )
+                            orders = combined_orders_cache.get(orders_key)
+                            if orders is None:
+                                orders = _combine_coupling_order_tuples(
+                                    left_shape.coupling_orders,
+                                    right_shape.coupling_orders,
+                                    vertex_orders,
+                                )
+                                combined_orders_cache[orders_key] = orders
+                            orders_allowed = orders_allowed_cache.get(orders)
+                            if orders_allowed is None:
+                                orders_allowed = _coupling_orders_within_limits(
+                                    orders,
+                                    max_coupling_orders,
+                                )
+                                orders_allowed_cache[orders] = orders_allowed
+                            if not orders_allowed:
+                                continue
+                            ordered_labels = color_engine.ordered_combination_labels(
+                                left_index,
+                                right_index,
+                                vertex,
+                            )
+                            if ordered_labels is None:
+                                continue
+                            quantum_key = (
+                                vertex.kind,
+                                vertex.particles,
+                                left_shape.particle_id,
+                                left_shape.chirality,
+                                left_shape.spin_state,
+                                left_shape.flavour_flow,
+                                left_shape.quantum_number_flow,
+                                right_shape.particle_id,
+                                right_shape.chirality,
+                                right_shape.spin_state,
+                                right_shape.flavour_flow,
+                                right_shape.quantum_number_flow,
+                            )
+                            quantum_flows = quantum_flow_cache.get(quantum_key)
+                            if quantum_flows is None:
+                                quantum_flows = tuple(
+                                    model.allowed_quantum_flows(
+                                        vertex,
+                                        left_index,
+                                        right_index,
+                                    )
+                                )
+                                quantum_flow_cache[quantum_key] = quantum_flows
+                            if not quantum_flows:
+                                continue
+                            color_key = (
+                                left_shape.color_state,
+                                right_shape.color_state,
+                                vertex,
+                                ordered_labels,
+                            )
+                            color_flows = color_flow_cache.get(color_key)
+                            if color_flows is None:
+                                color_flows = tuple(
+                                    color_engine.combine(
+                                        left_shape.color_state,
+                                        right_shape.color_state,
+                                        vertex,
+                                        ordered_external_labels=ordered_labels,
+                                    )
+                                )
+                                color_flow_cache[color_key] = color_flows
+                            for color_flow in color_flows:
+                                if not _lc_line_groups_within_limit(
+                                    color_flow.state,
+                                    max_lc_current_line_groups,
+                                ):
+                                    continue
+                                for quantum_flow in quantum_flows:
+                                    result_shape = _LiveCurrentShape(
+                                        external_mask=mask,
+                                        external_labels=labels,
+                                        particle_id=int(vertex.particles[2]),
+                                        ordered_external_labels=tuple(ordered_labels),
+                                        color_state=color_flow.state,
+                                        coupling_orders=orders,
+                                        chirality=int(quantum_flow.chirality),
+                                        spin_state=quantum_flow.spin_state,
+                                        flavour_flow=tuple(quantum_flow.flavour_flow),
+                                        quantum_number_flow=(
+                                            quantum_flow.quantum_number_flow
+                                        ),
+                                    )
+                                    if not model.current_allowed(result_shape):
+                                        continue
+                                    add_shape(result_shape)
+                                    reverse_transitions.setdefault(
+                                        result_shape,
+                                        set(),
+                                    ).add((left_shape, right_shape))
+                                    vertex_color_weight = vertex_color_weight_cache.get(
+                                        vertex
+                                    )
+                                    if vertex_color_weight is None:
+                                        vertex_color_weight = model.vertex_color_weight(
+                                            vertex,
+                                            color_accuracy=process.color_accuracy,
+                                        )
+                                        vertex_color_weight_cache[vertex] = (
+                                            vertex_color_weight
+                                        )
+                                    transitions.append(
+                                        BackwardLiveTransition(
+                                            left=left_shape,
+                                            right=right_shape,
+                                            result=result_shape,
+                                            vertex_kind=int(vertex.kind),
+                                            vertex_particles=tuple(vertex.particles),
+                                            coupling=tuple(quantum_flow.coupling),
+                                            color_weight=_complex_weight_mul(
+                                                color_flow.weight,
+                                                vertex_color_weight,
+                                            ),
+                                        )
+                                    )
+
+    closures: list[BackwardLiveClosure] = []
+    for left_mask, right_mask in closure_candidate_splits:
+        left_shapes = possible_by_mask.get(left_mask, ())
+        right_shapes = possible_by_mask.get(right_mask, ())
+        if not left_shapes or not right_shapes:
+            continue
+        right_by_sector: dict[int, list[_LiveCurrentShape]] = {}
+        for right_shape in right_shapes:
+            right_by_sector.setdefault(
+                right_shape.color_state.sector_id,
+                [],
+            ).append(right_shape)
+        for left_shape in left_shapes:
+            left_index = cast(CurrentIndex, left_shape)
+            for right_shape in right_by_sector.get(
+                left_shape.color_state.sector_id,
+                (),
+            ):
+                right_index = cast(CurrentIndex, right_shape)
+                if not color_engine.ordered_closure_allowed(left_index, right_index):
+                    continue
+                color_flows = color_engine.closure_compatible(
+                    left_shape.color_state,
+                    right_shape.color_state,
+                    full_mask=full_mask,
+                )
+                if not color_flows:
+                    continue
+                direct_contraction_ir = _direct_contraction_ir(
+                    model,
+                    left_index,
+                    right_index,
+                )
+                pair_closures: list[BackwardLiveClosure] = []
+                for color_flow in color_flows:
+                    if direct_contraction_ir is not None:
+                        pair_closures.append(
+                            BackwardLiveClosure(
+                                left=left_shape,
+                                right=right_shape,
+                                kind="direct-contraction",
+                                color_weight=color_flow.weight,
+                                contraction_ir=direct_contraction_ir,
+                                color_sector_id=color_flow.state.sector_id,
+                            )
+                        )
+                    for vertex in model.vertices_accepting(
+                        left_shape.particle_id,
+                        right_shape.particle_id,
+                        color_accuracy=process.color_accuracy,
+                    ):
+                        if (
+                            vertex.kind in ignored_vertex_kinds
+                            or vertex.particles[2] in ignored_particle_ids
+                            or not color_engine.vertex_allowed(vertex)
+                            or not model.vertex_closure_allowed(vertex)
+                        ):
+                            continue
+                        closure_contraction_ir = model.closure_contraction_ir(
+                            vertex.particles[2]
+                        )
+                        if closure_contraction_ir is None:
+                            continue
+                        total_orders = model.combine_coupling_orders(
+                            left_index,
+                            right_index,
+                            vertex,
+                        )
+                        if not _coupling_orders_within_limits(
+                            total_orders,
+                            max_coupling_orders,
+                        ) or not model.allowed_quantum_flows(
+                            vertex,
+                            left_index,
+                            right_index,
+                        ):
+                            continue
+                        pair_closures.append(
+                            BackwardLiveClosure(
+                                left=left_shape,
+                                right=right_shape,
+                                kind="vertex-closure",
+                                color_weight=_complex_weight_mul(
+                                    color_flow.weight,
+                                    model.vertex_color_weight(
+                                        vertex,
+                                        color_accuracy=process.color_accuracy,
+                                    ),
+                                ),
+                                contraction_ir=closure_contraction_ir,
+                                color_sector_id=color_flow.state.sector_id,
+                                vertex_kind=vertex.kind,
+                                vertex_particles=vertex.particles,
+                                coupling=vertex.coupling,
+                            )
+                        )
+                if pair_closures:
+                    closures.extend(pair_closures)
+
+    # Keep the union of every model-valid closure traversal.  Whole-sector
+    # ownership is not sound for three or more open fermion lines: different
+    # block traversals can expose distinct closure terms (and identical-line
+    # exchange signs).  Exact semantic alias removal happens only after the
+    # concrete DAG exists and can be certified by the shared replay proof.
+    useful: set[_LiveCurrentShape] = {
+        shape for closure in closures for shape in (closure.left, closure.right)
+    }
+
+    pending = deque(useful)
+    while pending:
+        result_shape = pending.popleft()
+        for left_shape, right_shape in reverse_transitions.get(result_shape, ()):
+            for parent in (left_shape, right_shape):
+                if parent in useful:
+                    continue
+                useful.add(parent)
+                pending.append(parent)
+
+    if not useful:
+        return None
+    return BackwardLiveStatePlan(
+        shapes=frozenset(useful),
+        active_sector_ids=frozenset(shape.color_state.sector_id for shape in useful),
+        transitions=tuple(
+            transition
+            for transition in transitions
+            if transition.result in useful
+            and transition.left in useful
+            and transition.right in useful
+        ),
+        closures=tuple(closures),
+        sources=tuple(source for source in source_candidates if source.shape in useful),
+    )
+
+
+def _physical_sink_sector_ids(
+    color_plan: GenericColorPlan,
+    closure_candidate_splits: Sequence[tuple[int, int]],
+) -> frozenset[int] | None:
+    """Return sectors whose canonical traversal ends at a closure sink.
+
+    Compatibility traversals exist only to build intermediate currents.  The
+    sector's authenticated canonical traversal owns the private recursion sink.
+    Fail closed when a sector has no canonical sink or when a closure side is
+    not a singleton.
+    """
+
+    sink_labels: set[int] = set()
+    for _left_mask, right_mask in closure_candidate_splits:
+        labels = _mask_labels(right_mask)
+        if len(labels) != 1:
+            return None
+        sink_labels.add(labels[0])
+    if not sink_labels:
+        return None
+
+    active: set[int] = set()
+    for sector in color_plan.sectors:
+        sink_label = sector.canonical_closure_sink_label(color_plan.process)
+        if sink_label is None:
+            return None
+        if int(sink_label) in sink_labels:
+            active.add(int(sector.id))
+    if not active:
+        return None
+    return frozenset(active)
+
+
+def _canonical_open_line_alias_owner_sector_ids(
+    color_plan: GenericColorPlan,
+    active_sector_ids: Iterable[int],
+) -> frozenset[int]:
+    """Choose one root-bearing owner per complete-open-line tensor.
+
+    NLC and full-colour plans enumerate permutations of complete open-line
+    blocks as public traversal sectors.  Those permutations are aliases of
+    the same product of colour tensors and must not each contribute a coherent
+    amplitude.  Choose the smallest *active* sector in each alias class: for
+    three or more open lines the smallest public sector can be rootless, so an
+    owner chosen before physical closure would incorrectly erase an amplitude.
+    """
+
+    active = frozenset(int(sector_id) for sector_id in active_sector_ids)
+    sector_by_id = {int(sector.id): sector for sector in color_plan.sectors}
+    unknown = active.difference(sector_by_id)
+    if unknown:
+        raise ValueError(
+            "active colour sectors are absent from the color plan: "
+            + ", ".join(str(sector_id) for sector_id in sorted(unknown))
+        )
+    if color_plan.color_accuracy not in {"nlc", "full"}:
+        return active
+
+    owner_by_key: dict[tuple[object, ...], int] = {}
+    owners: set[int] = set()
+    for sector_id in sorted(active):
+        sector = sector_by_id[sector_id]
+        if sector.kind == "open-lines":
+            open_strings = _canonical_open_string_product_key(
+                (
+                    line.fundamental_label,
+                    line.adjoint_labels,
+                    line.antifundamental_label,
+                    line.singlet_labels,
+                )
+                for line in sector.open_color_lines
+            )
+            key: tuple[object, ...] = ("open-lines", open_strings)
+        else:
+            key = (sector.kind, sector_id)
+        owners.add(owner_by_key.setdefault(key, sector_id))
+    return frozenset(owners)
+
+
+def _canonical_open_line_alias_owner_sector_map(
+    color_plan: GenericColorPlan,
+) -> dict[int, int]:
+    """Map traversal sectors onto canonical complete-open-line tensors."""
+
+    if color_plan.color_accuracy not in {"nlc", "full"}:
+        return {int(sector.id): int(sector.id) for sector in color_plan.sectors}
+    sectors_by_key: dict[tuple[object, ...], list[int]] = {}
+    for sector in color_plan.sectors:
+        sector_id = int(sector.id)
+        if sector.kind == "open-lines":
+            open_strings = _canonical_open_string_product_key(
+                (
+                    line.fundamental_label,
+                    line.adjoint_labels,
+                    line.antifundamental_label,
+                    line.singlet_labels,
+                )
+                for line in sector.open_color_lines
+            )
+            key: tuple[object, ...] = ("open-lines", open_strings)
+        else:
+            key = (sector.kind, sector_id)
+        sectors_by_key.setdefault(key, []).append(sector_id)
+    return {
+        sector_id: min(sector_ids)
+        for sector_ids in sectors_by_key.values()
+        for sector_id in sector_ids
+    }
+
+
+def _retain_canonical_open_line_alias_roots(
+    dag: GenericDAG,
+    model: Model,
+) -> GenericDAG:
+    """Collapse only model-certified traversal aliases of amplitude roots.
+
+    Public NLC/full plans retain every colour sector.  Complete open-line block
+    permutations are private construction aliases, but a sector is not an
+    indivisible ownership unit: with three or more open lines, separate
+    traversals carry separate physical closure terms.  The shared helicity
+    replay signature proves equality of the full recursive closure while a
+    sector projection removes only that traversal identifier.  Distinct source
+    labels, ordered traversals, fermion exchange factors and kernel contracts
+    therefore remain distinct.
+    """
+
+    roots = dag.amplitude_roots
+    color_plan = dag.color_plan
+    if not roots or color_plan.color_accuracy not in {"nlc", "full"}:
+        return dag
+
+    owner_by_sector = _canonical_open_line_alias_owner_sector_map(color_plan)
+    aliases_by_owner: dict[int, set[int]] = {}
+    for sector_id, owner_id in owner_by_sector.items():
+        aliases_by_owner.setdefault(owner_id, set()).add(sector_id)
+    if all(len(sector_ids) == 1 for sector_ids in aliases_by_owner.values()):
+        return dag
+
+    signatures = _semantic_amplitude_root_alias_signatures(
+        dag,
+        model,
+        color_sector_aliases=owner_by_sector,
+    )
+    grouped: dict[
+        tuple[
+            int,
+            str,
+            tuple[tuple[tuple[int, int], ...], ...],
+            tuple[float, float],
+        ],
+        dict[int, list[AmplitudeRoot]],
+    ] = {}
+    untouched: list[AmplitudeRoot] = []
+    for root, signature in zip(roots, signatures, strict=True):
+        if root.color_sector_id is None:
+            untouched.append(root)
+            continue
+        sector_id = int(root.color_sector_id)
+        owner_id = owner_by_sector.get(sector_id, sector_id)
+        if len(aliases_by_owner.get(owner_id, {sector_id})) == 1:
+            untouched.append(root)
+            continue
+        if signature is None:
+            raise ValueError(
+                "open-line traversal alias has no model-certified recursive "
+                f"closure signature: root {root.id}, sector {sector_id}"
+            )
+        key = (
+            owner_id,
+            signature.proof_digest,
+            signature.selector_states,
+            signature.factor,
+        )
+        grouped.setdefault(key, {}).setdefault(sector_id, []).append(root)
+
+    retained = list(untouched)
+    for key in sorted(grouped):
+        roots_by_sector = grouped[key]
+        multiplicities = {
+            sector_id: len(sector_roots)
+            for sector_id, sector_roots in roots_by_sector.items()
+        }
+        if len(set(multiplicities.values())) != 1:
+            detail = ", ".join(
+                f"sector {sector_id}: {count}"
+                for sector_id, count in sorted(multiplicities.items())
+            )
+            raise ValueError(
+                "proof-identical open-line traversal aliases have unequal "
+                f"root multiplicities for owner {key[0]} ({detail})"
+            )
+        representative_sector = min(roots_by_sector)
+        owner_id = key[0]
+        retained.extend(
+            replace(root, color_sector_id=owner_id)
+            for root in roots_by_sector[representative_sector]
+        )
+    retained.sort(key=lambda root: root.id)
+    rebound = tuple(
+        replace(root, id=index) if root.id != index else root
+        for index, root in enumerate(retained)
+    )
+    return dag if rebound == roots else replace(dag, amplitude_roots=rebound)
+
+
+def infer_minimal_coupling_order_limits(
+    process: CanonicalProcessIR,
+    *,
+    model: Model,
+    max_color_sectors: int | None = None,
+    selected_color_sector_ids: Iterable[int] | None = None,
+    max_coupling_orders: Mapping[str, int] | None = None,
+    closure_side_mask_pruning: bool = True,
+    color_order_mask_pruning: bool = True,
+    ignored_particle_ids: Iterable[int] | None = None,
+    ignored_vertex_kinds: Iterable[int] | None = None,
+) -> dict[str, int]:
+    """Infer a generic lowest-order coupling envelope for a process.
+
+    This is an opt-in generation accelerator.  It never recognizes a whole
+    process family; it asks the model which local vertices can connect the
+    external states, tracks UFO-style coupling orders, and returns the
+    component-wise maximum over all closure paths with the lowest
+    model-declared hierarchy-weighted order. The returned dictionary can be
+    used as ordinary ``max_coupling_orders``. Model-declared orders absent from
+    the minimal envelope are returned with a zero limit because an omitted
+    limit means unrestricted to the DAG compiler.
+    """
+
+    if not isinstance(process, CanonicalProcessIR):
+        raise TypeError(
+            "coupling-order inference requires a model-resolved CanonicalProcessIR"
+        )
+    process_ir = process
+    color_plan = build_color_plan(
+        process_ir,
+        color_accuracy=process_ir.color_accuracy,
+        max_sectors=max_color_sectors,
+        fold_trace_reflections=(
+            model.lc_trace_reflection_equivalence_is_proven(process_ir)
+        ),
+    )
+    return _infer_minimal_coupling_order_limits_from_color_plan(
+        process_ir,
+        model=model,
+        color_plan=color_plan,
+        selected_color_sector_ids=selected_color_sector_ids,
+        max_coupling_orders=max_coupling_orders,
+        closure_side_mask_pruning=closure_side_mask_pruning,
+        color_order_mask_pruning=color_order_mask_pruning,
+        ignored_particle_ids=ignored_particle_ids,
+        ignored_vertex_kinds=ignored_vertex_kinds,
+    )
+
+
+def _infer_minimal_coupling_order_limits_from_color_plan(
+    process: CanonicalProcessIR,
+    *,
+    model: Model,
+    color_plan: GenericColorPlan,
+    selected_color_sector_ids: Iterable[int] | None = None,
+    max_coupling_orders: Mapping[str, int] | None = None,
+    closure_side_mask_pruning: bool = True,
+    color_order_mask_pruning: bool = True,
+    ignored_particle_ids: Iterable[int] | None = None,
+    ignored_vertex_kinds: Iterable[int] | None = None,
+) -> dict[str, int]:
+    """Infer the minimal coupling envelope from an already complete color plan."""
+
+    if not isinstance(process, CanonicalProcessIR):
+        raise TypeError(
+            "coupling-order inference requires a model-resolved CanonicalProcessIR"
+        )
+    process_ir = process
+    if color_plan.process is not process_ir and color_plan.process != process_ir:
+        raise ValueError(
+            "coupling-order inference color plan belongs to another process"
+        )
+    explicit_sector_ids = (
+        None
+        if selected_color_sector_ids is None
+        else frozenset(int(sector_id) for sector_id in selected_color_sector_ids)
+    )
+    if explicit_sector_ids is not None and color_plan.color_accuracy == "lc":
+        color_plan = GenericColorPlan(
+            process=color_plan.process,
+            color_accuracy=color_plan.color_accuracy,
+            sectors=tuple(
+                sector
+                for sector in color_plan.sectors
+                if sector.id in explicit_sector_ids
+            ),
+            diagnostics=color_plan.diagnostics,
+            truncated=color_plan.truncated,
+            trace_reflections_folded=color_plan.trace_reflections_folded,
+            basis=color_plan.basis,
+        )
+    totals = _closure_totals_from_color_plan(
+        process_ir,
+        model=model,
+        color_plan=color_plan,
+        max_coupling_orders=max_coupling_orders,
+        closure_side_mask_pruning=closure_side_mask_pruning,
+        color_order_mask_pruning=color_order_mask_pruning,
+        ignored_particle_ids=ignored_particle_ids,
+        ignored_vertex_kinds=ignored_vertex_kinds,
+    )
+    if not totals:
+        return {}
+    hierarchies = {
+        str(name).upper(): max(1, int(value))
+        for name, value in model.coupling_order_hierarchies().items()
+    }
+    minimum_total_order = min(
+        _coupling_order_degree(total, hierarchies=hierarchies) for total in totals
+    )
+    minimal_totals = tuple(
+        total
+        for total in totals
+        if _coupling_order_degree(total, hierarchies=hierarchies) == minimum_total_order
+    )
+    envelope = _coupling_order_envelope(minimal_totals)
+    order_names = set(hierarchies) | set(envelope)
+    for total in totals:
+        order_names.update(name for name, _value in total)
+    return {name: envelope.get(name, 0) for name in sorted(order_names)}
+
+
+def _closure_totals_from_color_plan(
+    process_ir: CanonicalProcessIR,
+    *,
+    model: Model,
+    color_plan: GenericColorPlan,
+    max_coupling_orders: Mapping[str, int] | None = None,
+    closure_side_mask_pruning: bool = True,
+    color_order_mask_pruning: bool = True,
+    ignored_particle_ids: Iterable[int] | None = None,
+    ignored_vertex_kinds: Iterable[int] | None = None,
+) -> tuple[CouplingOrders, ...]:
+    """Coupling-order totals of the closures reachable within the limits."""
+
+    color_engine = ColorEngine(color_plan, model)
+    full_mask = _labels_mask(leg.label for leg in process_ir.legs)
+    closure_candidate_splits = _closure_candidate_splits(
+        process_ir,
+        model,
+        color_engine,
+    )
+    closure_reachable_masks = (
+        _closure_side_reachable_masks(full_mask, closure_candidate_splits)
+        if closure_side_mask_pruning
+        else None
+    )
+    color_order_reachable_masks = (
+        _lc_color_order_reachable_masks(process_ir, color_plan, model)
+        if color_order_mask_pruning
+        else None
+    )
+    return tuple(
+        _closure_total_coupling_orders(
+            process_ir,
+            model,
+            color_engine,
+            closure_candidate_splits,
+            closure_reachable_masks,
+            color_order_reachable_masks,
+            max_coupling_orders=_normalize_coupling_order_limits(max_coupling_orders),
+            ignored_particle_ids=frozenset(
+                int(particle_id) for particle_id in (ignored_particle_ids or ())
+            ),
+            ignored_vertex_kinds=frozenset(
+                int(kind) for kind in (ignored_vertex_kinds or ())
+            ),
+        )
+    )
+
+
+def has_model_supported_amplitudes(
+    process: CanonicalProcessIR,
+    *,
+    model: Model,
+    color_plan: GenericColorPlan,
+    max_coupling_orders: Mapping[str, int] | None = None,
+) -> bool:
+    """Whether any tree-level closure of the process exists in the model.
+
+    Species, colour and coupling-order reachability only; it may overestimate,
+    like the DAG pruning it shares, but never rejects a process with amplitudes.
+    """
+
+    return bool(
+        _closure_totals_from_color_plan(
+            process,
+            model=model,
+            color_plan=color_plan,
+            max_coupling_orders=max_coupling_orders,
+        )
+    )
+
+
+def prune_dag_to_amplitude_roots(dag: GenericDAG) -> GenericDAG:
+    """Drop currents and interactions that cannot feed any amplitude root.
+
+    The forward generic sweep intentionally over-generates valid local currents:
+    it does not know which of them will survive closure until the full table is
+    built.  Production artifacts should mirror AmpliCol's optimized library
+    structure and keep only the backward-reachable sub-DAG feeding retained
+    amplitude roots.
+    """
+
+    if not dag.amplitude_roots:
+        return dag
+
+    required_currents = bytearray(len(dag.currents))
+    for root in dag.amplitude_roots:
+        for current_id in (root.left_id, root.right_id):
+            required_currents[current_id] = 1
+
+    required_interactions = bytearray(len(dag.interactions))
+    # Interactions are emitted in increasing result-subset order. Walking that
+    # table backwards visits every consumer before the interactions producing
+    # its parents and computes the complete live closure in one pass.
+    for interaction in reversed(dag.interactions):
+        if required_currents[interaction.result_id]:
+            required_interactions[interaction.id] = 1
+            required_currents[interaction.left_id] = 1
+            required_currents[interaction.right_id] = 1
+
+    if all(required_currents) and all(required_interactions):
+        return dag
+
+    current_id_map = [-1] * len(dag.currents)
+    next_current_id = 0
+    for old_id, required in enumerate(required_currents):
+        if required:
+            current_id_map[old_id] = next_current_id
+            next_current_id += 1
+    pruned_currents = tuple(
+        CurrentNode(
+            id=current_id_map[current.id],
+            index=current.index,
+            dimension=current.dimension,
+            is_source=current.is_source,
+            source_leg_label=current.source_leg_label,
+            source_helicity=current.source_helicity,
+        )
+        for current in dag.currents
+        if required_currents[current.id]
+    )
+    interaction_id_map = [-1] * len(dag.interactions)
+    next_interaction_id = 0
+    for old_id, required in enumerate(required_interactions):
+        if required:
+            interaction_id_map[old_id] = next_interaction_id
+            next_interaction_id += 1
+    pruned_interactions = tuple(
+        InteractionNode(
+            id=interaction_id_map[interaction.id],
+            vertex_kind=interaction.vertex_kind,
+            vertex_particles=interaction.vertex_particles,
+            left_id=current_id_map[interaction.left_id],
+            right_id=current_id_map[interaction.right_id],
+            result_id=current_id_map[interaction.result_id],
+            coupling=interaction.coupling,
+            color_weight=interaction.color_weight,
+            lowering_backend=interaction.lowering_backend,
+            full_tensor_network_ready=interaction.full_tensor_network_ready,
+            evaluation_group_id=interaction.evaluation_group_id,
+            evaluation_factor=interaction.evaluation_factor,
+        )
+        for interaction in dag.interactions
+        if required_interactions[interaction.id]
+    )
+    pruned_roots = tuple(
+        AmplitudeRoot(
+            id=new_id,
+            kind=root.kind,
+            left_id=current_id_map[root.left_id],
+            right_id=current_id_map[root.right_id],
+            color_weight=root.color_weight,
+            contraction_ir=root.contraction_ir,
+            color_sector_id=root.color_sector_id,
+            vertex_kind=root.vertex_kind,
+            vertex_particles=root.vertex_particles,
+            coupling=root.coupling,
+            helicity_weight=root.helicity_weight,
+        )
+        for new_id, root in enumerate(dag.amplitude_roots)
+    )
+    pruned_sources = tuple(
+        current_id_map[source_id]
+        for source_id in dag.sources
+        if required_currents[source_id]
+    )
+    return GenericDAG(
+        process=dag.process,
+        color_plan=dag.color_plan,
+        currents=pruned_currents,
+        sources=pruned_sources,
+        interactions=pruned_interactions,
+        amplitude_roots=pruned_roots,
+        truncated=dag.truncated,
+        helicity_coverage=dag.helicity_coverage,
+        color_coverage=dag.color_coverage,
+        selected_source_helicities=dag.selected_source_helicities,
+        selected_color_sector_ids=dag.selected_color_sector_ids,
+        lc_topology_replay=dag.lc_topology_replay,
+        color_topology_replay=dag.color_topology_replay,
+    )
+
+
+def prune_global_helicity_flip_equivalent_roots(
+    dag: GenericDAG,
+    model: Model,
+) -> GenericDAG:
+    """Group roots when the model proves a global-helicity-flip identity.
+
+    This is the safe, structural subset of AmpliCol's numerical helicity
+    filtering. Keeping one proven representative with doubled helicity weight
+    reduces amplitude roots, after which dead-tree pruning removes currents
+    that fed only the discarded partner roots.
+    """
+
+    parity_safe, vertex_inventory = _global_helicity_flip_equivalence_proof(
+        dag,
+        model,
+    )
+    if not parity_safe:
+        return dag
+    if not dag.amplitude_roots:
+        return dag
+
+    pure_massless_adjoint = _pure_massless_adjoint_helicity_pruning_safe(
+        dag,
+        model,
+        vertex_inventory,
+    )
+    initial_leg_labels = {
+        int(leg.label) for leg in dag.process.legs if leg.side == "initial"
+    }
+    compact_result = _compact_helicity_flip_representatives(
+        dag,
+        initial_leg_labels=initial_leg_labels,
+        pure_massless_adjoint=pure_massless_adjoint,
+    )
+    if compact_result is None:
+        retained, changed, zero_pruned = _generic_helicity_flip_representatives(
+            dag,
+            initial_leg_labels=initial_leg_labels,
+            pure_massless_adjoint=pure_massless_adjoint,
+        )
+    else:
+        retained, changed, zero_pruned = compact_result
+
+    if not changed and not zero_pruned:
+        return dag
+    return prune_dag_to_amplitude_roots(
+        GenericDAG(
+            process=dag.process,
+            color_plan=dag.color_plan,
+            currents=dag.currents,
+            sources=dag.sources,
+            interactions=dag.interactions,
+            amplitude_roots=tuple(retained),
+            truncated=dag.truncated,
+            helicity_coverage=dag.helicity_coverage,
+            color_coverage=dag.color_coverage,
+            selected_source_helicities=dag.selected_source_helicities,
+            selected_color_sector_ids=dag.selected_color_sector_ids,
+            lc_topology_replay=dag.lc_topology_replay,
+            color_topology_replay=dag.color_topology_replay,
+        )
+    )
+
+
+def _compact_helicity_flip_representatives(
+    dag: GenericDAG,
+    *,
+    initial_leg_labels: set[int],
+    pure_massless_adjoint: bool,
+) -> tuple[list[AmplitudeRoot], bool, bool] | None:
+    """Select flip representatives using dense physical-helicity bit codes.
+
+    Color-decorated DAGs may contain thousands of source currents even though
+    each root depends on one source per external leg. Walking the set ancestry
+    bits avoids scanning every decorated source for every amplitude root. The
+    conservative checks keep unfamiliar source layouts on the generic path.
+    """
+
+    encoding = _compact_source_helicity_encoding(dag, initial_leg_labels)
+    if encoding is None:
+        return None
+    helicity_by_source_bit, leg_by_source_bit, all_legs_mask, initial_mask = encoding
+    leg_count = all_legs_mask.bit_count()
+    stride = all_legs_mask + 1
+    roots_by_key: dict[int, list[AmplitudeRoot]] = {}
+    zero_pruned = False
+
+    for root in dag.amplitude_roots:
+        ancestry = int(
+            dag.currents[root.left_id].index.helicity_ancestry
+            | dag.currents[root.right_id].index.helicity_ancestry
+        )
+        helicity_code = 0
+        present_legs = 0
+        remaining = ancestry
+        while remaining:
+            source_bit = remaining & -remaining
+            bit_index = source_bit.bit_length() - 1
+            if bit_index >= len(helicity_by_source_bit):
+                return None
+            helicity_value = helicity_by_source_bit[bit_index]
+            leg_bit = leg_by_source_bit[bit_index]
+            if helicity_value is None or leg_bit is None or present_legs & leg_bit:
+                return None
+            helicity_code |= helicity_value
+            present_legs |= leg_bit
+            remaining ^= source_bit
+        if present_legs != all_legs_mask:
+            return None
+
+        if pure_massless_adjoint:
+            positive_count = (helicity_code ^ initial_mask).bit_count()
+            if positive_count < 2 or leg_count - positive_count < 2:
+                zero_pruned = True
+                continue
+
+        sector_id = _amplitude_root_color_sector_id(dag, root)
+        key = sector_id * stride + helicity_code
+        roots_by_key.setdefault(key, []).append(root)
+
+    if not roots_by_key:
+        return [], False, False
+
+    retained: list[AmplitudeRoot] = []
+    changed = False
+    for key in sorted(roots_by_key):
+        sector_id, helicity_code = divmod(key, stride)
+        flipped_key = sector_id * stride + (helicity_code ^ all_legs_mask)
+        partner = roots_by_key.get(flipped_key)
+        if partner is not None and flipped_key < key:
+            continue
+        weight = 1.0
+        if partner is not None and flipped_key != key:
+            weight = 2.0
+            changed = True
+        for root in roots_by_key[key]:
+            retained.append(_weighted_amplitude_root(root, len(retained), weight))
+    return retained, changed, zero_pruned
+
+
+def _compact_source_helicity_encoding(
+    dag: GenericDAG,
+    initial_leg_labels: set[int],
+) -> (
+    tuple[
+        list[int | None],
+        list[int | None],
+        int,
+        int,
+    ]
+    | None
+):
+    labels = tuple(sorted(int(leg.label) for leg in dag.process.legs))
+    if not labels or len(set(labels)) != len(labels) or not dag.sources:
+        return None
+    leg_bits = {
+        label: 1 << (len(labels) - index - 1) for index, label in enumerate(labels)
+    }
+
+    source_records: list[tuple[int, int, int]] = []
+    for source_id in dag.sources:
+        current = dag.currents[source_id]
+        ancestry = int(current.index.helicity_ancestry)
+        label = int(current.source_leg_label or 0)
+        helicity = int(current.source_helicity or 0)
+        if (
+            ancestry <= 0
+            or ancestry & (ancestry - 1)
+            or label not in leg_bits
+            or helicity not in {-1, 1}
+        ):
+            return None
+        source_records.append((ancestry, label, helicity))
+    source_records.sort()
+    if any(left[1] > right[1] for left, right in pairwise(source_records)):
+        return None
+
+    table_size = source_records[-1][0].bit_length()
+    helicity_by_source_bit: list[int | None] = [None] * table_size
+    leg_by_source_bit: list[int | None] = [None] * table_size
+    for ancestry, label, helicity in source_records:
+        bit_index = ancestry.bit_length() - 1
+        leg_bit = leg_bits[label]
+        helicity_value = leg_bit if helicity == 1 else 0
+        existing_helicity = helicity_by_source_bit[bit_index]
+        existing_leg = leg_by_source_bit[bit_index]
+        if existing_helicity is not None and (
+            existing_helicity != helicity_value or existing_leg != leg_bit
+        ):
+            return None
+        helicity_by_source_bit[bit_index] = helicity_value
+        leg_by_source_bit[bit_index] = leg_bit
+
+    all_legs_mask = (1 << len(labels)) - 1
+    initial_mask = 0
+    for label in initial_leg_labels:
+        leg_bit = leg_bits.get(label)
+        if leg_bit is None:
+            return None
+        initial_mask |= leg_bit
+    return (
+        helicity_by_source_bit,
+        leg_by_source_bit,
+        all_legs_mask,
+        initial_mask,
+    )
+
+
+def _generic_helicity_flip_representatives(
+    dag: GenericDAG,
+    *,
+    initial_leg_labels: set[int],
+    pure_massless_adjoint: bool,
+) -> tuple[list[AmplitudeRoot], bool, bool]:
+    """Retain the fully generic tuple-signature implementation as fallback."""
+
+    source_by_bit = _source_helicity_signature_by_bit(dag)
+    roots_by_signature: dict[tuple[object, ...], list[AmplitudeRoot]] = {}
+    source_helicities_by_ancestry: dict[int, tuple[tuple[int, int], ...]] = {}
+    zero_pruned = False
+    for root in dag.amplitude_roots:
+        signature = _root_physical_helicity_signature(
+            dag,
+            root,
+            source_by_bit,
+            source_helicities_by_ancestry,
+        )
+        if pure_massless_adjoint and _pure_massless_adjoint_helicity_signature_is_zero(
+            signature,
+            initial_leg_labels,
+        ):
+            zero_pruned = True
+            continue
+        roots_by_signature.setdefault(
+            signature,
+            [],
+        ).append(root)
+    if not roots_by_signature:
+        return [], False, False
+
+    handled: set[tuple[object, ...]] = set()
+    retained: list[AmplitudeRoot] = []
+    changed = False
+    for signature in sorted(roots_by_signature):
+        if signature in handled:
+            continue
+        flipped = _flip_root_physical_helicity_signature(signature)
+        partner = roots_by_signature.get(flipped)
+        handled.add(signature)
+        if partner is not None:
+            handled.add(flipped)
+        weight = 1.0
+        if partner is not None and flipped != signature:
+            weight = 2.0
+            changed = True
+        for root in roots_by_signature[signature]:
+            retained.append(_weighted_amplitude_root(root, len(retained), weight))
+    return retained, changed, zero_pruned
+
+
+def _weighted_amplitude_root(
+    root: AmplitudeRoot,
+    root_id: int,
+    weight: float,
+) -> AmplitudeRoot:
+    return AmplitudeRoot(
+        id=root_id,
+        kind=root.kind,
+        left_id=root.left_id,
+        right_id=root.right_id,
+        color_weight=root.color_weight,
+        contraction_ir=root.contraction_ir,
+        color_sector_id=root.color_sector_id,
+        vertex_kind=root.vertex_kind,
+        vertex_particles=root.vertex_particles,
+        coupling=root.coupling,
+        helicity_weight=root.helicity_weight * weight,
+    )
+
+
+def _global_helicity_flip_equivalence_proof(
+    dag: GenericDAG,
+    model: Model,
+) -> tuple[bool, tuple[Vertex, ...]]:
+    if dag.process.color_accuracy not in {"lc", "nlc", "full"}:
+        return False, ()
+    for leg in dag.process.legs:
+        if leg.outgoing_pdg is None:
+            return False, ()
+        pdg = int(leg.outgoing_pdg)
+        if not (
+            model.is_massless_adjoint_vector(pdg)
+            or model.is_fundamental_colored_fermion(pdg)
+        ):
+            return False, ()
+        if model.mass(pdg) != 0.0:
+            return False, ()
+    vertices = _dag_vertex_inventory(dag)
+    return (
+        model.global_helicity_flip_equivalence_is_proven(vertices),
+        vertices,
+    )
+
+
+def _dag_vertex_inventory(dag: GenericDAG) -> tuple[Vertex, ...]:
+    """Return each local vertex contract once in deterministic order."""
+
+    identities = {
+        (int(interaction.vertex_kind), interaction.vertex_particles)
+        for interaction in dag.interactions
+    }
+    identities.update(
+        (int(root.vertex_kind), root.vertex_particles)
+        for root in dag.amplitude_roots
+        if root.vertex_kind is not None and root.vertex_particles is not None
+    )
+    return tuple(Vertex(kind, particles) for kind, particles in sorted(identities))
+
+
+def _pure_massless_adjoint_helicity_pruning_safe(
+    dag: GenericDAG,
+    model: Model,
+    vertices: Sequence[Vertex] | None = None,
+) -> bool:
+    return model.pure_massless_adjoint_helicity_zero_rule_is_proven(
+        dag.process,
+        _dag_vertex_inventory(dag) if vertices is None else vertices,
+    )
+
+
+def _pure_massless_adjoint_helicity_signature_is_zero(
+    signature: tuple[object, ...],
+    initial_leg_labels: set[int],
+) -> bool:
+    _sector_id, source_helicities = signature
+    helicities = []
+    for label, helicity in cast(Sequence[tuple[int, int]], source_helicities):
+        value = int(helicity)
+        if int(label) in initial_leg_labels:
+            value = -value
+        helicities.append(value)
+    return helicities.count(1) < 2 or helicities.count(-1) < 2
+
+
+def _root_physical_helicity_signature(
+    dag: GenericDAG,
+    root: AmplitudeRoot,
+    source_by_bit: Mapping[int, tuple[int, int]],
+    source_helicities_by_ancestry: dict[
+        int,
+        tuple[tuple[int, int], ...],
+    ]
+    | None = None,
+) -> tuple[object, ...]:
+    left = dag.currents[root.left_id].index
+    right = dag.currents[root.right_id].index
+    ancestry = int(left.helicity_ancestry | right.helicity_ancestry)
+    source_helicities = (
+        None
+        if source_helicities_by_ancestry is None
+        else source_helicities_by_ancestry.get(ancestry)
+    )
+    if source_helicities is None:
+        source_helicities = _source_helicities_for_ancestry(
+            ancestry,
+            source_by_bit,
+        )
+        if source_helicities_by_ancestry is not None:
+            source_helicities_by_ancestry[ancestry] = source_helicities
+    sector_id = _amplitude_root_color_sector_id(dag, root)
+    return (sector_id, source_helicities)
+
+
+def _root_source_helicity_mapping(
+    dag: GenericDAG,
+    root: AmplitudeRoot,
+    source_by_bit: Mapping[int, tuple[int, int]],
+) -> dict[int, int]:
+    left = dag.currents[root.left_id].index
+    right = dag.currents[root.right_id].index
+    ancestry = int(left.helicity_ancestry | right.helicity_ancestry)
+    return {
+        int(label): int(helicity)
+        for label, helicity in _source_helicities_for_ancestry(
+            ancestry,
+            source_by_bit,
+        )
+    }
+
+
+def _source_helicities_for_ancestry(
+    ancestry: int,
+    source_by_bit: Mapping[int, tuple[int, int]],
+) -> tuple[tuple[int, int], ...]:
+    """Resolve only set ancestry bits while preserving ascending-bit order."""
+
+    records: list[tuple[int, int]] = []
+    remaining = int(ancestry)
+    while remaining:
+        bit = remaining & -remaining
+        source = source_by_bit.get(bit)
+        if source is not None:
+            records.append(source)
+        remaining ^= bit
+    return tuple(records)
+
+
+def _source_helicity_signature_by_bit(
+    dag: GenericDAG,
+) -> dict[int, tuple[int, int]]:
+    records: list[tuple[int, tuple[int, int]]] = []
+    for source_id in dag.sources:
+        current = dag.currents[source_id]
+        records.append(
+            (
+                int(current.index.helicity_ancestry),
+                (
+                    int(current.source_leg_label or 0),
+                    int(current.source_helicity or 0),
+                ),
+            )
+        )
+    return dict(sorted(records))
+
+
+def _canonicalize_amplitude_root_order(dag: GenericDAG) -> GenericDAG:
+    """Order roots by their physical colour/helicity representative.
+
+    Eager preselection omits one member of every proven global-helicity-flip
+    pair before source-bit allocation.  Its ancestry integers therefore differ
+    from a complete DAG even though the retained physical states are identical.
+    Canonicalizing by physical source labels keeps public reduction identifiers
+    independent of that implementation detail.
+    """
+
+    source_by_bit = _source_helicity_signature_by_bit(dag)
+    source_helicities_by_ancestry: dict[int, tuple[tuple[int, int], ...]] = {}
+    ordered = tuple(
+        sorted(
+            dag.amplitude_roots,
+            key=lambda root: (
+                _root_physical_helicity_signature(
+                    dag,
+                    root,
+                    source_by_bit,
+                    source_helicities_by_ancestry,
+                ),
+                root.id,
+            ),
+        )
+    )
+    if all(root.id == index for index, root in enumerate(ordered)):
+        return dag
+    return replace(
+        dag,
+        amplitude_roots=tuple(
+            replace(root, id=index) for index, root in enumerate(ordered)
+        ),
+    )
+
+
+def _flip_root_physical_helicity_signature(
+    signature: tuple[object, ...],
+) -> tuple[object, ...]:
+    sector_id, source_helicities = signature
+    return (
+        sector_id,
+        tuple(
+            (int(label), -int(helicity))
+            for label, helicity in cast(
+                Sequence[tuple[int, int]],
+                source_helicities,
+            )
+        ),
+    )
+
+
+def contributing_color_sector_ids(dag: GenericDAG) -> tuple[int, ...]:
+    """Return LC colour sectors that actually contribute amplitude roots."""
+
+    return tuple(
+        sorted(
+            {_amplitude_root_color_sector_id(dag, root) for root in dag.amplitude_roots}
+        )
+    )
+
+
+def _amplitude_root_color_sector_id(dag: GenericDAG, root: AmplitudeRoot) -> int:
+    if root.color_sector_id is not None:
+        return int(root.color_sector_id)
+    left = dag.currents[root.left_id].index
+    if left.color_state.accuracy in {"lc", "nlc", "full"}:
+        return int(left.color_state.sector_id)
+    return 0
+
+
+def filter_dag_to_color_sectors(
+    dag: GenericDAG,
+    sector_ids: Iterable[int],
+) -> GenericDAG:
+    """Return a dense-current DAG restricted to the requested colour sectors.
+
+    Full DAG construction remains useful for diagnostics, but schema-v3 runtime
+    records expect dense current ids. This helper derives the runtime DAG by selecting
+    roots whose LC colour sector is in ``sector_ids``, walking backward through
+    the current DAG, and remapping the required currents/interactions densely.
+    Root-based filtering is required for shared LC all-ordering DAGs where
+    internal currents are sector-neutral but amplitude roots still carry the
+    physical sector identity.
+    """
+
+    selected = set(sector_ids)
+    if not selected:
+        return GenericDAG(
+            process=dag.process,
+            color_plan=dag.color_plan,
+            currents=(),
+            sources=(),
+            interactions=(),
+            amplitude_roots=(),
+            truncated=dag.truncated,
+            helicity_coverage=dag.helicity_coverage,
+            color_coverage="selected",
+            selected_source_helicities=dag.selected_source_helicities,
+            selected_color_sector_ids=tuple(sorted(selected)),
+            lc_topology_replay=None,
+            color_topology_replay=None,
+        )
+
+    selected_roots = tuple(
+        root
+        for root in dag.amplitude_roots
+        if _amplitude_root_color_sector_id(dag, root) in selected
+    )
+    if not selected_roots:
+        return GenericDAG(
+            process=dag.process,
+            color_plan=dag.color_plan,
+            currents=(),
+            sources=(),
+            interactions=(),
+            amplitude_roots=(),
+            truncated=dag.truncated,
+            helicity_coverage=dag.helicity_coverage,
+            color_coverage="selected",
+            selected_source_helicities=dag.selected_source_helicities,
+            selected_color_sector_ids=tuple(sorted(selected)),
+            lc_topology_replay=None,
+            color_topology_replay=None,
+        )
+
+    interactions_by_result: dict[int, list[InteractionNode]] = {}
+    for interaction in dag.interactions:
+        interactions_by_result.setdefault(interaction.result_id, []).append(interaction)
+
+    required_current_ids: set[int] = set()
+    required_interaction_ids: set[int] = set()
+    stack: list[int] = []
+    for root in selected_roots:
+        for current_id in (root.left_id, root.right_id):
+            if current_id not in required_current_ids:
+                required_current_ids.add(current_id)
+                stack.append(current_id)
+
+    while stack:
+        current_id = stack.pop()
+        for interaction in interactions_by_result.get(current_id, ()):
+            if interaction.id in required_interaction_ids:
+                continue
+            required_interaction_ids.add(interaction.id)
+            for parent_id in (interaction.left_id, interaction.right_id):
+                if parent_id not in required_current_ids:
+                    required_current_ids.add(parent_id)
+                    stack.append(parent_id)
+
+    current_id_map: dict[int, int] = {}
+    currents: list[CurrentNode] = []
+    for current in dag.currents:
+        if current.id not in required_current_ids:
+            continue
+        new_id = len(currents)
+        current_id_map[current.id] = new_id
+        currents.append(
+            CurrentNode(
+                id=new_id,
+                index=current.index,
+                dimension=current.dimension,
+                is_source=current.is_source,
+                source_leg_label=current.source_leg_label,
+                source_helicity=current.source_helicity,
+            )
+        )
+
+    sources = tuple(
+        current_id_map[source_id]
+        for source_id in dag.sources
+        if source_id in current_id_map
+    )
+
+    interactions: list[InteractionNode] = []
+    for interaction in dag.interactions:
+        if interaction.id not in required_interaction_ids:
+            continue
+        if (
+            interaction.left_id not in current_id_map
+            or interaction.right_id not in current_id_map
+            or interaction.result_id not in current_id_map
+        ):
+            continue
+        interactions.append(
+            InteractionNode(
+                id=len(interactions),
+                vertex_kind=interaction.vertex_kind,
+                vertex_particles=interaction.vertex_particles,
+                left_id=current_id_map[interaction.left_id],
+                right_id=current_id_map[interaction.right_id],
+                result_id=current_id_map[interaction.result_id],
+                coupling=interaction.coupling,
+                color_weight=interaction.color_weight,
+                lowering_backend=interaction.lowering_backend,
+                full_tensor_network_ready=interaction.full_tensor_network_ready,
+                evaluation_group_id=interaction.evaluation_group_id,
+                evaluation_factor=interaction.evaluation_factor,
+            )
+        )
+
+    amplitude_roots: list[AmplitudeRoot] = []
+    for root in selected_roots:
+        if root.left_id not in current_id_map or root.right_id not in current_id_map:
+            continue
+        amplitude_roots.append(
+            AmplitudeRoot(
+                id=len(amplitude_roots),
+                kind=root.kind,
+                left_id=current_id_map[root.left_id],
+                right_id=current_id_map[root.right_id],
+                color_weight=root.color_weight,
+                contraction_ir=root.contraction_ir,
+                color_sector_id=root.color_sector_id,
+                vertex_kind=root.vertex_kind,
+                vertex_particles=root.vertex_particles,
+                coupling=root.coupling,
+                helicity_weight=root.helicity_weight,
+            )
+        )
+
+    return GenericDAG(
+        process=dag.process,
+        color_plan=dag.color_plan,
+        currents=tuple(currents),
+        sources=sources,
+        interactions=tuple(interactions),
+        amplitude_roots=tuple(amplitude_roots),
+        truncated=dag.truncated,
+        helicity_coverage=dag.helicity_coverage,
+        color_coverage="selected",
+        selected_source_helicities=dag.selected_source_helicities,
+        selected_color_sector_ids=tuple(sorted(selected)),
+        lc_topology_replay=None,
+        color_topology_replay=None,
+    )
+
+
+def filter_dag_to_source_helicities(
+    dag: GenericDAG,
+    source_helicities: Mapping[int, int],
+) -> GenericDAG:
+    """Return a DAG restricted to roots matching fixed source helicities."""
+
+    requested = {
+        int(label): int(helicity) for label, helicity in source_helicities.items()
+    }
+    if not requested:
+        return dag
+
+    source_by_bit = _source_helicity_signature_by_bit(dag)
+    selected_roots = tuple(
+        root
+        for root in dag.amplitude_roots
+        if _root_source_helicity_mapping(dag, root, source_by_bit).items()
+        >= requested.items()
+    )
+    if len(selected_roots) == len(dag.amplitude_roots):
+        return dag
+    return prune_dag_to_amplitude_roots(
+        GenericDAG(
+            process=dag.process,
+            color_plan=dag.color_plan,
+            currents=dag.currents,
+            sources=dag.sources,
+            interactions=dag.interactions,
+            amplitude_roots=selected_roots,
+            truncated=dag.truncated,
+            helicity_coverage="selected",
+            color_coverage=dag.color_coverage,
+            selected_source_helicities=tuple(
+                sorted({**dict(dag.selected_source_helicities), **requested}.items())
+            ),
+            selected_color_sector_ids=dag.selected_color_sector_ids,
+            lc_topology_replay=dag.lc_topology_replay,
+            color_topology_replay=dag.color_topology_replay,
+        )
+    )
diff --git a/pyamplicol/src/pyamplicol/generation/dag_color.py b/pyamplicol/src/pyamplicol/generation/dag_color.py
new file mode 100644
index 0000000000..53cc11d939
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/dag_color.py
@@ -0,0 +1,1132 @@
+# SPDX-License-Identifier: 0BSD
+"""Local color-flow state transitions for generic DAG generation."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from ..color.plan import GenericColorPlan
+from ..models.base import Model, Vertex
+from ..processes.ir import ProcessLegIR
+from .dag_ordering import (
+    _closure_combination_matches_word,
+    _known_color_representation,
+    _known_fermion_statistics,
+    _labels_projected_to_word,
+    _lc_word_with_sink_last,
+    _line_local_singlet_extras_allowed,
+    _mask_labels,
+    _ordered_combination_matches_word,
+    _ordered_combination_segment,
+    _sector_group_indices_for_label,
+    _sector_intermediate_order_words,
+    _word_contains_ordered_segment,
+)
+from .dag_types import (
+    _LC_FIERZ_SINGLET_BASIS,
+    ColorFlow,
+    ColorState,
+    CurrentIndex,
+    _lc_color_identity_closure_key,
+    _lc_color_identity_closures,
+    _lc_color_identity_closures_compatible,
+)
+
+_LC_SECTOR_SUPPORT_PREFIX = "lc-sector-support:"
+
+
+def _lc_sector_support_key(sector_ids: Iterable[int]) -> str:
+    normalized = sorted(set(int(value) for value in sector_ids))
+    return _LC_SECTOR_SUPPORT_PREFIX + ",".join(str(value) for value in normalized)
+
+
+def _lc_sector_support(basis_keys: Iterable[str]) -> frozenset[int] | None:
+    supports: list[frozenset[int]] = []
+    for key in basis_keys:
+        if not key.startswith(_LC_SECTOR_SUPPORT_PREFIX):
+            continue
+        payload = key.removeprefix(_LC_SECTOR_SUPPORT_PREFIX)
+        try:
+            support = frozenset(int(value) for value in payload.split(",") if value)
+        except ValueError:
+            return frozenset()
+        if not support:
+            return frozenset()
+        supports.append(support)
+    if not supports:
+        return None
+    result = set(supports[0])
+    for support in supports[1:]:
+        result.intersection_update(support)
+    return frozenset(result)
+
+
+def _without_lc_sector_support(basis_keys: Iterable[str]) -> set[str]:
+    return {key for key in basis_keys if not key.startswith(_LC_SECTOR_SUPPORT_PREFIX)}
+
+
+class ColorEngine:
+    """Local colour-flow engine used by the process-generic recursion."""
+
+    def __init__(
+        self,
+        color_plan: GenericColorPlan,
+        model: Model,
+        *,
+        shared_lc_all_ordering_symmetry: bool = False,
+        cache_shared_lc_orderings: bool = False,
+    ) -> None:
+        self.color_plan = color_plan
+        self.model = model
+        self._sector_by_id = {sector.id: sector for sector in color_plan.sectors}
+        self._leg_by_label = {leg.label: leg for leg in color_plan.process.legs}
+        self._color_rep_by_label: dict[int, int | None] = {}
+        for label, leg in self._leg_by_label.items():
+            if leg.outgoing_pdg is None:
+                self._color_rep_by_label[label] = None
+                continue
+            self._color_rep_by_label[label] = _known_color_representation(
+                self.model,
+                leg.outgoing_pdg,
+            )
+        self._label_is_color_singlet = {
+            label: representation == 1
+            for label, representation in self._color_rep_by_label.items()
+        }
+        self._shared_lc_coloured_labels = {
+            label
+            for label, representation in self._color_rep_by_label.items()
+            if representation is not None and representation != 1
+        }
+        self._shared_lc_singlet_labels = {
+            label
+            for label, representation in self._color_rep_by_label.items()
+            if representation == 1
+        }
+        self._fundamental_line_auxiliary_ids = (
+            self._find_fundamental_line_auxiliary_ids()
+        )
+        self._fundamental_fermion_pair_count = (
+            self._external_fundamental_fermion_pair_count()
+        )
+        self._vertex_has_colour_cache: dict[tuple[int, int, int, int], bool] = {}
+        self._ordered_combination_labels_cache: dict[
+            tuple[int, tuple[int, ...], tuple[int, ...], int, int, int, int],
+            tuple[int, ...] | None,
+        ] = {}
+        self._shared_lc_proposed_labels_cache: (
+            dict[tuple[tuple[int, ...], bool], tuple[int, ...] | None] | None
+        ) = {} if cache_shared_lc_orderings else None
+        color_plan_matches_model = self._color_plan_matches_model_roles()
+        all_external_massless_adjoint_vectors = (
+            self._all_external_massless_adjoint_vectors()
+        )
+        try:
+            shared_single_trace_color_basis = (
+                self.model.shared_single_trace_color_basis_is_proven(color_plan.process)
+            )
+        except (KeyError, NotImplementedError, TypeError, ValueError):
+            shared_single_trace_color_basis = False
+        self._shared_single_trace = bool(
+            color_plan.color_accuracy in {"nlc", "full"}
+            and bool(color_plan.sectors)
+            and color_plan_matches_model
+            and all_external_massless_adjoint_vectors
+            and shared_single_trace_color_basis
+            and all(sector.kind == "single-trace" for sector in color_plan.sectors)
+        )
+        self._shared_single_trace_words = tuple(
+            word for sector in color_plan.sectors for word in (sector.color_words or ())
+        )
+        self._shared_single_trace_word_set = frozenset(self._shared_single_trace_words)
+        self._shared_single_trace_segments = frozenset(
+            tuple(word[start:stop])
+            for word in self._shared_single_trace_words
+            for start in range(len(word))
+            for stop in range(start + 1, len(word) + 1)
+        )
+        closure_sector_ids_by_word: dict[tuple[int, ...], set[int]] = {}
+        for sector in color_plan.sectors:
+            for word in sector.admissible_traversal_words:
+                closure_sector_ids_by_word.setdefault(tuple(word), set()).add(
+                    int(sector.id)
+                )
+        self._shared_single_trace_closure_sector_ids_by_word = {
+            word: tuple(sorted(sector_ids))
+            for word, sector_ids in closure_sector_ids_by_word.items()
+        }
+        self._shared_lc_orderings = (
+            (
+                color_plan.color_accuracy == "lc"
+                or (
+                    color_plan.color_accuracy in {"nlc", "full"}
+                    and self._fundamental_fermion_pair_count == 1
+                )
+            )
+            and bool(color_plan.sectors)
+            and bool(self._shared_lc_coloured_labels)
+            and color_plan_matches_model
+        )
+        self._shared_lc_all_ordering_symmetry = bool(
+            shared_lc_all_ordering_symmetry
+            and self._shared_lc_orderings
+            and not color_plan.truncated
+        )
+        all_adjoint_process_symmetry = bool(
+            self._shared_lc_all_ordering_symmetry
+            and all_external_massless_adjoint_vectors
+        )
+        self._shared_lc_fixed_sink_label = (
+            max(self._shared_lc_coloured_labels)
+            if all_adjoint_process_symmetry and self._shared_lc_coloured_labels
+            else None
+        )
+        self._shared_lc_words_by_sector = tuple(
+            (
+                sector,
+                tuple(
+                    _lc_word_with_sink_last(
+                        word,
+                        self._shared_lc_fixed_sink_label,
+                    )
+                    for word in _sector_intermediate_order_words(
+                        sector,
+                        include_compatible_traversals=self._shared_lc_orderings,
+                        process=color_plan.process,
+                    )
+                ),
+            )
+            for sector in color_plan.sectors
+        )
+        self._shared_lc_sector_ids_by_word: dict[tuple[int, ...], tuple[int, ...]] = {}
+        self._shared_lc_sector_ids_by_segment: dict[
+            tuple[int, ...], tuple[int, ...]
+        ] = {}
+        if self._shared_lc_orderings:
+            sector_ids_by_word: dict[tuple[int, ...], list[int]] = {}
+            sector_ids_by_segment: dict[tuple[int, ...], set[int]] = {}
+            segments: set[tuple[int, ...]] = set()
+            for sector in color_plan.sectors:
+                for word in _sector_intermediate_order_words(
+                    sector,
+                    process=color_plan.process,
+                ):
+                    normalized_word = _lc_word_with_sink_last(
+                        word,
+                        self._shared_lc_fixed_sink_label,
+                    )
+                    sector_ids_by_word.setdefault(normalized_word, []).append(
+                        int(sector.id)
+                    )
+                for word in _sector_intermediate_order_words(
+                    sector,
+                    process=color_plan.process,
+                ):
+                    normalized_word = _lc_word_with_sink_last(
+                        word,
+                        self._shared_lc_fixed_sink_label,
+                    )
+                    for start in range(len(normalized_word)):
+                        for stop in range(start + 1, len(normalized_word) + 1):
+                            segment = tuple(normalized_word[start:stop])
+                            segments.add(segment)
+                            sector_ids_by_segment.setdefault(segment, set()).add(
+                                int(sector.id)
+                            )
+            self._shared_lc_sector_ids_by_word = {
+                word: tuple(ids) for word, ids in sector_ids_by_word.items()
+            }
+            self._shared_lc_sector_ids_by_segment = {
+                segment: tuple(sorted(ids))
+                for segment, ids in sector_ids_by_segment.items()
+            }
+            self._shared_lc_segments = frozenset(segments)
+        else:
+            self._shared_lc_segments = frozenset()
+
+    def _color_plan_matches_model_roles(self) -> bool:
+        if any(
+            representation is None
+            for representation in self._color_rep_by_label.values()
+        ):
+            return False
+        for sector in self.color_plan.sectors:
+            sector_coloured_labels = {
+                label for group in sector.coloured_label_groups for label in group
+            }
+            if sector_coloured_labels != self._shared_lc_coloured_labels:
+                return False
+            if set(sector.singlet_labels) != self._shared_lc_singlet_labels:
+                return False
+        return True
+
+    def _all_external_massless_adjoint_vectors(self) -> bool:
+        if not self._leg_by_label:
+            return False
+        for leg in self._leg_by_label.values():
+            if leg.outgoing_pdg is None:
+                return False
+            try:
+                if not self.model.is_massless_adjoint_vector(leg.outgoing_pdg):
+                    return False
+            except (KeyError, NotImplementedError, TypeError, ValueError):
+                return False
+        return True
+
+    def _is_fundamental_colored_fermion(self, particle_id: int) -> bool:
+        representation = _known_color_representation(self.model, particle_id)
+        return (
+            representation is not None
+            and abs(representation) == 3
+            and _known_fermion_statistics(self.model, particle_id) is True
+        )
+
+    def _is_fundamental_line_auxiliary(self, particle_id: int) -> bool:
+        try:
+            auxiliary_kind = self.model.auxiliary_kind(particle_id)
+        except (KeyError, NotImplementedError, TypeError, ValueError):
+            return False
+        return auxiliary_kind == "u1-subtraction-color-flow-vector"
+
+    def _find_fundamental_line_auxiliary_ids(self) -> frozenset[int]:
+        """Identify proven unphysical singlet currents attached to fundamental lines."""
+
+        auxiliary_ids: set[int] = set()
+        for vertex in self.model.vertices:
+            for index, particle_id in enumerate(vertex.particles):
+                if not self._is_fundamental_line_auxiliary(particle_id):
+                    continue
+                other_particles = (
+                    vertex.particles[:index] + vertex.particles[index + 1 :]
+                )
+                if all(
+                    self._is_fundamental_colored_fermion(other_particle)
+                    for other_particle in other_particles
+                ):
+                    auxiliary_ids.add(particle_id)
+        return frozenset(auxiliary_ids)
+
+    def _external_fundamental_fermion_pair_count(self) -> int:
+        fundamental_count = 0
+        antifundamental_count = 0
+        for leg in self._leg_by_label.values():
+            if leg.outgoing_pdg is None or not self._is_fundamental_colored_fermion(
+                leg.outgoing_pdg
+            ):
+                continue
+            representation = _known_color_representation(
+                self.model,
+                leg.outgoing_pdg,
+            )
+            if representation == 3:
+                fundamental_count += 1
+            elif representation == -3:
+                antifundamental_count += 1
+        return min(fundamental_count, antifundamental_count)
+
+    def source_states_for_leg(self, leg: ProcessLegIR) -> tuple[ColorState, ...]:
+        if self._shared_lc_orderings:
+            leg_is_singlet = self._label_is_color_singlet.get(leg.label, False)
+            return (
+                ColorState(
+                    accuracy=self.color_plan.color_accuracy,
+                    sector_id=0,
+                    line_groups=() if leg_is_singlet else (0,),
+                ),
+            )
+        if self._shared_single_trace:
+            return (
+                ColorState(
+                    accuracy=self.color_plan.color_accuracy,
+                    sector_id=0,
+                    line_groups=(0,),
+                ),
+            )
+        if not self.color_plan.sectors:
+            return (ColorState(accuracy=self.color_plan.color_accuracy),)
+        states = []
+        leg_is_singlet = self._label_is_color_singlet.get(leg.label, False)
+        for sector in self.color_plan.sectors:
+            groups = (
+                ()
+                if leg_is_singlet
+                else _sector_group_indices_for_label(sector, leg.label)
+            )
+            if groups or leg_is_singlet or not sector.line_label_groups:
+                states.append(
+                    ColorState(
+                        accuracy=self.color_plan.color_accuracy,
+                        sector_id=sector.id,
+                        line_groups=groups,
+                    )
+                )
+        return tuple(states)
+
+    def combine(
+        self,
+        left: ColorState,
+        right: ColorState,
+        vertex: Vertex,
+        *,
+        ordered_external_labels: tuple[int, ...] = (),
+        sector_support_label_variants: tuple[tuple[int, ...], ...] | None = None,
+    ) -> tuple[ColorFlow, ...]:
+        if left.accuracy != right.accuracy:
+            return ()
+        if not self.color_plan.sectors:
+            return (
+                ColorFlow(
+                    state=ColorState(
+                        accuracy=left.accuracy,
+                        basis_key=tuple(
+                            sorted(set(left.basis_key) | set(right.basis_key))
+                        ),
+                    )
+                ),
+            )
+        if self._shared_single_trace:
+            groups = tuple(sorted(set(left.line_groups) | set(right.line_groups)))
+            return (
+                ColorFlow(
+                    state=ColorState(
+                        accuracy=left.accuracy,
+                        sector_id=0,
+                        line_groups=groups or (0,),
+                    )
+                ),
+            )
+        if self._shared_lc_orderings:
+            groups = self._lc_combined_line_groups(left, right, vertex)
+            if groups is None:
+                return ()
+            projections = self._lc_projected_basis_and_weights(
+                left,
+                right,
+                vertex,
+                ordered_external_labels,
+                sector_support_label_variants=sector_support_label_variants,
+            )
+            if not projections:
+                return ()
+            return tuple(
+                ColorFlow(
+                    state=ColorState(
+                        accuracy=left.accuracy,
+                        sector_id=0,
+                        line_groups=groups,
+                        basis_key=basis_key,
+                    ),
+                    weight=weight,
+                )
+                for basis_key, weight in projections
+            )
+        if left.sector_id != right.sector_id:
+            return ()
+        groups = self._lc_combined_line_groups(left, right, vertex)
+        if groups is None:
+            return ()
+        projections = self._lc_projected_basis_and_weights(
+            left,
+            right,
+            vertex,
+            ordered_external_labels,
+            sector_support_label_variants=sector_support_label_variants,
+        )
+        if not projections:
+            return ()
+        return tuple(
+            ColorFlow(
+                state=ColorState(
+                    accuracy=left.accuracy,
+                    sector_id=left.sector_id,
+                    line_groups=groups,
+                    basis_key=basis_key,
+                ),
+                weight=weight,
+            )
+            for basis_key, weight in projections
+        )
+
+    def _lc_projected_basis_and_weights(
+        self,
+        left: ColorState,
+        right: ColorState,
+        vertex: Vertex,
+        ordered_external_labels: tuple[int, ...],
+        *,
+        sector_support_label_variants: tuple[tuple[int, ...], ...] | None = None,
+    ) -> tuple[tuple[tuple[str, ...], tuple[float, float]], ...]:
+        basis_with_support = set(left.basis_key) | set(right.basis_key)
+        inherited_support = _lc_sector_support(basis_with_support)
+        basis = _without_lc_sector_support(basis_with_support)
+        structure = self.model.vertex_color_structure(vertex)
+        reps = tuple(abs(self.model.color_rep(pdg)) for pdg in vertex.particles)
+        has_fierz_singlet = _LC_FIERZ_SINGLET_BASIS in basis
+        if has_fierz_singlet:
+            consumes_singlet_exchange = (
+                structure == "fundamental-generator"
+                and reps[2] == 3
+                and sorted(reps[:2]) == [3, 8]
+            )
+            if not consumes_singlet_exchange:
+                return ()
+            basis.remove(_LC_FIERZ_SINGLET_BASIS)
+
+        creates_fierz_projection = (
+            structure == "fundamental-generator"
+            and reps[:2] == (3, 3)
+            and reps[2] == 8
+            and not self._fundamental_line_auxiliary_ids
+        )
+
+        if (
+            self._shared_lc_orderings
+            and structure == "color-identity"
+            and sorted(reps[:2]) == [3, 3]
+            and reps[2] == 1
+            and vertex.particles[2] not in self._fundamental_line_auxiliary_ids
+        ):
+            colored_labels = tuple(
+                sorted(
+                    label
+                    for label in ordered_external_labels
+                    if label in self._shared_lc_coloured_labels
+                )
+            )
+            if colored_labels:
+                basis.add(_lc_color_identity_closure_key(colored_labels))
+
+        if self._shared_lc_orderings:
+            support_label_variants = (
+                (ordered_external_labels,)
+                if sector_support_label_variants is None
+                else sector_support_label_variants
+            )
+            compatible_sector_ids: set[int] = set()
+            for support_labels in support_label_variants:
+                compatible_sector_ids.update(
+                    self._shared_lc_compatible_sector_ids(support_labels)
+                )
+            if inherited_support is not None:
+                compatible_sector_ids.intersection_update(inherited_support)
+            if not compatible_sector_ids:
+                return ()
+            all_sector_ids = set(self._sector_by_id)
+            track_sector_support = (
+                inherited_support is not None
+                or creates_fierz_projection
+                or (
+                    self.color_plan.color_accuracy == "lc"
+                    and compatible_sector_ids != all_sector_ids
+                )
+            )
+
+            candidates: list[tuple[set[str], tuple[float, float], set[int]]] = []
+            if creates_fierz_projection:
+                fierz_sector_ids = (
+                    self._lc_fierz_sector_ids(ordered_external_labels)
+                    & compatible_sector_ids
+                )
+                ordinary_sector_ids = compatible_sector_ids - fierz_sector_ids
+                if ordinary_sector_ids:
+                    candidates.append((set(basis), (1.0, 0.0), ordinary_sector_ids))
+                if fierz_sector_ids:
+                    fierz_basis = set(basis)
+                    fierz_basis.add(_LC_FIERZ_SINGLET_BASIS)
+                    candidates.append(
+                        (
+                            fierz_basis,
+                            (1.0 / 3.0, 0.0),
+                            fierz_sector_ids,
+                        )
+                    )
+            else:
+                candidates.append((set(basis), (1.0, 0.0), compatible_sector_ids))
+
+            projections: list[tuple[tuple[str, ...], tuple[float, float]]] = []
+            for candidate_basis, weight, support in candidates:
+                if track_sector_support and support != all_sector_ids:
+                    candidate_basis.add(_lc_sector_support_key(support))
+                if not self._shared_lc_basis_has_compatible_sector(
+                    candidate_basis,
+                    ordered_external_labels=ordered_external_labels,
+                ):
+                    continue
+                projections.append((tuple(sorted(candidate_basis)), weight))
+            return tuple(projections)
+
+        if creates_fierz_projection and self._lc_labels_close_one_open_line(
+            ordered_external_labels
+        ):
+            basis.add(_LC_FIERZ_SINGLET_BASIS)
+            return ((tuple(sorted(basis)), (1.0 / 3.0, 0.0)),)
+        return ((tuple(sorted(basis)), (1.0, 0.0)),)
+
+    def _shared_lc_compatible_sector_ids(
+        self,
+        ordered_external_labels: tuple[int, ...],
+    ) -> set[int]:
+        colored = tuple(
+            label
+            for label in ordered_external_labels
+            if label in self._shared_lc_coloured_labels
+        )
+        if not colored:
+            return set(self._sector_by_id)
+        return set(self._shared_lc_sector_ids_by_segment.get(colored, ()))
+
+    def _lc_fierz_sector_ids(
+        self,
+        ordered_external_labels: tuple[int, ...],
+    ) -> set[int]:
+        colored = tuple(
+            label
+            for label in ordered_external_labels
+            if label in self._shared_lc_coloured_labels
+        )
+        labels = set(colored)
+        sector_ids: set[int] = set()
+        if not labels:
+            return sector_ids
+        for sector, words in self._shared_lc_words_by_sector:
+            if not any(_word_contains_ordered_segment(word, colored) for word in words):
+                continue
+            complete_groups = tuple(
+                set(group)
+                for group in sector.line_label_groups
+                if set(group).issubset(labels)
+            )
+            if complete_groups and set().union(*complete_groups) == labels:
+                sector_ids.add(int(sector.id))
+        return sector_ids
+
+    def _shared_lc_basis_has_compatible_sector(
+        self,
+        basis_keys: Iterable[str],
+        *,
+        ordered_external_labels: Iterable[int] = (),
+    ) -> bool:
+        basis_tuple = tuple(basis_keys)
+        closures = _lc_color_identity_closures(basis_tuple)
+        support = _lc_sector_support(basis_tuple)
+        colored_segment = tuple(
+            label
+            for label in ordered_external_labels
+            if label in self._shared_lc_coloured_labels
+        )
+        sector_ids = (
+            self._shared_lc_sector_ids_by_segment.get(colored_segment, ())
+            if colored_segment
+            else tuple(self._sector_by_id)
+        )
+        return any(
+            sector is not None
+            and (support is None or sector_id in support)
+            and _lc_color_identity_closures_compatible(closures, sector)
+            for sector_id in sector_ids
+            for sector in (self._sector_by_id.get(sector_id),)
+        )
+
+    def _lc_labels_close_one_open_line(
+        self,
+        ordered_external_labels: tuple[int, ...],
+    ) -> bool:
+        colored = tuple(
+            label
+            for label in ordered_external_labels
+            if label in self._shared_lc_coloured_labels
+        )
+        if not colored:
+            return False
+        return bool(self._lc_fierz_sector_ids(colored))
+
+    def _lc_combined_line_groups(
+        self,
+        left: ColorState,
+        right: ColorState,
+        vertex: Vertex,
+    ) -> tuple[int, ...] | None:
+        left_colored = self._particle_has_colour(vertex.particles[0])
+        right_colored = self._particle_has_colour(vertex.particles[1])
+        result_colored = self._particle_has_colour(vertex.particles[2])
+        left_groups = set(left.line_groups)
+        right_groups = set(right.line_groups)
+
+        if not left_colored and not right_colored:
+            if left_groups and right_groups and left_groups != right_groups:
+                return None
+            return tuple(sorted(left_groups | right_groups))
+
+        if left_colored != right_colored:
+            colored_groups = left_groups if left_colored else right_groups
+            singlet_groups = right_groups if left_colored else left_groups
+            if (
+                singlet_groups
+                and colored_groups
+                and not singlet_groups.issubset(colored_groups)
+            ):
+                return None
+            return tuple(sorted(colored_groups or singlet_groups))
+
+        if (
+            not result_colored
+            and left_groups
+            and right_groups
+            and left_groups != right_groups
+        ):
+            return None
+        return tuple(sorted(left_groups | right_groups))
+
+    def _particle_has_colour(self, pdg: int) -> bool:
+        representation = _known_color_representation(self.model, pdg)
+        return (
+            representation is not None and representation != 1
+        ) or pdg in self._fundamental_line_auxiliary_ids
+
+    def closure_compatible(
+        self,
+        left: ColorState,
+        right: ColorState,
+        *,
+        full_mask: int,
+    ) -> tuple[ColorFlow, ...]:
+        if left.accuracy != right.accuracy:
+            return ()
+        if not self.color_plan.sectors:
+            return (
+                ColorFlow(
+                    state=ColorState(
+                        accuracy=left.accuracy,
+                        basis_key=tuple(
+                            sorted(set(left.basis_key) | set(right.basis_key))
+                        ),
+                    )
+                ),
+            )
+        if self._shared_single_trace:
+            # Shared single-trace closure needs the endpoint order labels, not
+            # just the state.  _build_amplitude_roots therefore calls
+            # shared_single_trace_closure_flows() with full CurrentIndex data.
+            return ()
+        if left.sector_id != right.sector_id:
+            return ()
+        groups = tuple(sorted(set(left.line_groups) | set(right.line_groups)))
+        sector = self._sector_by_id.get(left.sector_id)
+        if sector is None:
+            return (ColorFlow(state=left),)
+        basis = tuple(sorted(set(left.basis_key) | set(right.basis_key)))
+        if not _lc_color_identity_closures_compatible(
+            _lc_color_identity_closures(basis),
+            sector,
+        ):
+            return ()
+        full_labels = set(_mask_labels(full_mask))
+        sector_labels = set(sector.singlet_labels)
+        for group in sector.line_label_groups:
+            sector_labels.update(group)
+        if full_labels and not full_labels.issubset(sector_labels):
+            return ()
+        return (
+            ColorFlow(
+                state=ColorState(
+                    accuracy=left.accuracy,
+                    sector_id=left.sector_id,
+                    line_groups=groups,
+                )
+            ),
+        )
+
+    def _vertex_has_colour(self, vertex: Vertex) -> bool:
+        key = (vertex.kind, *vertex.particles)
+        cached = self._vertex_has_colour_cache.get(key)
+        if cached is not None:
+            return cached
+        for pdg in vertex.particles:
+            if self._particle_has_colour(pdg):
+                self._vertex_has_colour_cache[key] = True
+                return True
+        self._vertex_has_colour_cache[key] = False
+        return False
+
+    def vertex_allowed(self, vertex: Vertex) -> bool:
+        contains_fundamental_auxiliary = any(
+            particle_id in self._fundamental_line_auxiliary_ids
+            for particle_id in vertex.particles
+        )
+        if contains_fundamental_auxiliary:
+            return self._fundamental_fermion_pair_count >= 2
+        if (
+            self._fundamental_line_auxiliary_ids
+            and self._fundamental_fermion_pair_count >= 2
+            and self.model.vertex_color_structure(vertex) == "fundamental-generator"
+        ):
+            representations = tuple(
+                self.model.color_rep(particle_id) for particle_id in vertex.particles
+            )
+            if representations.count(8) == 1 and sorted(
+                abs(value) for value in representations if value != 8
+            ) == [3, 3]:
+                return representations in {
+                    (3, 8, 3),
+                    (8, -3, -3),
+                    (-3, 3, 8),
+                }
+        return True
+
+    def ordered_combination_allowed(
+        self,
+        left_index: CurrentIndex,
+        right_index: CurrentIndex,
+        vertex: Vertex,
+    ) -> bool:
+        if not self._vertex_has_colour(vertex):
+            return True
+        if self._shared_lc_orderings:
+            return (
+                self._shared_lc_ordered_combination_labels(
+                    left_index,
+                    right_index,
+                )
+                is not None
+            )
+        sector = self._sector_by_id.get(left_index.color_state.sector_id)
+        if sector is None:
+            return True
+        if sector.kind == "singlet" and all(
+            not word for word in sector.admissible_traversal_words
+        ):
+            return True
+        return any(
+            _ordered_combination_matches_word(
+                left_index.ordered_external_labels,
+                right_index.ordered_external_labels,
+                word,
+            )
+            for word in _sector_intermediate_order_words(
+                sector,
+                include_compatible_traversals=False,
+                process=self.color_plan.process,
+            )
+        )
+
+    def ordered_combination_labels(
+        self,
+        left_index: CurrentIndex,
+        right_index: CurrentIndex,
+        vertex: Vertex,
+    ) -> tuple[int, ...] | None:
+        cache_key = (
+            left_index.color_state.sector_id,
+            left_index.ordered_external_labels,
+            right_index.ordered_external_labels,
+            vertex.kind,
+            *vertex.particles,
+        )
+        if cache_key in self._ordered_combination_labels_cache:
+            return self._ordered_combination_labels_cache[cache_key]
+        proposed = (
+            *left_index.ordered_external_labels,
+            *right_index.ordered_external_labels,
+        )
+        singlet_order = self._singlet_order_allowed(
+            left_index,
+            right_index,
+            vertex,
+        )
+        if not singlet_order:
+            self._ordered_combination_labels_cache[cache_key] = None
+            return None
+        if self._shared_single_trace:
+            segment = (
+                *left_index.ordered_external_labels,
+                *right_index.ordered_external_labels,
+            )
+            labels = segment if segment in self._shared_single_trace_segments else None
+            self._ordered_combination_labels_cache[cache_key] = labels
+            return labels
+        if self._shared_lc_orderings:
+            labels = self._shared_lc_ordered_combination_labels(
+                left_index,
+                right_index,
+            )
+            self._ordered_combination_labels_cache[cache_key] = labels
+            return labels
+        sector = self._sector_by_id.get(left_index.color_state.sector_id)
+        if sector is None:
+            self._ordered_combination_labels_cache[cache_key] = proposed
+            return proposed
+        for word in _sector_intermediate_order_words(
+            sector,
+            include_compatible_traversals=False,
+            process=self.color_plan.process,
+        ):
+            segment = _ordered_combination_segment(
+                left_index.ordered_external_labels,
+                right_index.ordered_external_labels,
+                word,
+            )
+            if segment is None:
+                continue
+            word_labels = set(word)
+            extras = tuple(
+                sorted(label for label in proposed if label not in word_labels)
+            )
+            if not _line_local_singlet_extras_allowed(segment, extras, sector):
+                continue
+            labels = (*segment, *extras)
+            self._ordered_combination_labels_cache[cache_key] = labels
+            return labels
+        self._ordered_combination_labels_cache[cache_key] = None
+        return None
+
+    def _singlet_order_allowed(
+        self,
+        left_index: CurrentIndex,
+        right_index: CurrentIndex,
+        vertex: Vertex,
+    ) -> bool:
+        left_singlet = self._all_external_labels_color_singlet(
+            left_index.external_labels
+        )
+        right_singlet = self._all_external_labels_color_singlet(
+            right_index.external_labels
+        )
+        if left_singlet and not right_singlet:
+            return False
+        if left_singlet and right_singlet:
+            return max(left_index.external_labels) < max(right_index.external_labels)
+        return True
+
+    def _all_external_labels_color_singlet(self, labels: Iterable[int]) -> bool:
+        for label in labels:
+            is_singlet = self._label_is_color_singlet.get(label)
+            if is_singlet is None:
+                return False
+            if not is_singlet:
+                return False
+        return True
+
+    def ordered_closure_allowed(
+        self,
+        left_index: CurrentIndex,
+        right_index: CurrentIndex,
+    ) -> bool:
+        if self._shared_single_trace:
+            return (
+                *left_index.ordered_external_labels,
+                *right_index.ordered_external_labels,
+            ) in self._shared_single_trace_word_set
+        if self._shared_lc_orderings:
+            return self._shared_lc_closure_word(left_index, right_index) is not None
+        if left_index.color_state.sector_id != right_index.color_state.sector_id:
+            return False
+        sector = self._sector_by_id.get(left_index.color_state.sector_id)
+        if sector is None:
+            return True
+        if sector.kind == "singlet" and all(
+            not word for word in sector.admissible_traversal_words
+        ):
+            return True
+        if sector.kind == "open-lines":
+            word = sector.canonical_closure_traversal_word(self.color_plan.process)
+            return _closure_combination_matches_word(
+                _labels_projected_to_word(
+                    left_index.ordered_external_labels,
+                    word,
+                ),
+                _labels_projected_to_word(
+                    right_index.ordered_external_labels,
+                    word,
+                ),
+                word,
+            )
+        return any(
+            _closure_combination_matches_word(
+                _labels_projected_to_word(left_index.ordered_external_labels, word),
+                _labels_projected_to_word(right_index.ordered_external_labels, word),
+                word,
+            )
+            for word in sector.admissible_traversal_words
+        )
+
+    def shared_single_trace_closure_flows(
+        self,
+        left_index: CurrentIndex,
+        right_index: CurrentIndex,
+    ) -> tuple[ColorFlow, ...]:
+        if not self._shared_single_trace:
+            return ()
+        closure_word = (
+            *left_index.ordered_external_labels,
+            *right_index.ordered_external_labels,
+        )
+        return tuple(
+            ColorFlow(
+                state=ColorState(
+                    accuracy=self.color_plan.color_accuracy,
+                    sector_id=sector_id,
+                    line_groups=(0,),
+                )
+            )
+            for sector_id in self._shared_single_trace_closure_sector_ids_by_word.get(
+                closure_word,
+                (),
+            )
+        )
+
+    @property
+    def shared_single_trace(self) -> bool:
+        return self._shared_single_trace
+
+    def shared_lc_closure_flows(
+        self,
+        left_index: CurrentIndex,
+        right_index: CurrentIndex,
+    ) -> tuple[ColorFlow, ...]:
+        if not self._shared_lc_orderings:
+            return ()
+        flows: list[ColorFlow] = []
+        closure = self._shared_lc_closure(left_index, right_index)
+        if closure is None:
+            return ()
+        _word, sector_ids = closure
+        for sector_id in sector_ids:
+            flows.append(
+                ColorFlow(
+                    state=ColorState(
+                        accuracy=self.color_plan.color_accuracy,
+                        sector_id=sector_id,
+                        line_groups=(0,),
+                    )
+                )
+            )
+        return tuple(flows)
+
+    @property
+    def shared_lc_orderings(self) -> bool:
+        return self._shared_lc_orderings
+
+    @property
+    def shared_lc_all_ordering_symmetry(self) -> bool:
+        return self._shared_lc_all_ordering_symmetry
+
+    @property
+    def shared_lc_fixed_sink_label(self) -> int | None:
+        return self._shared_lc_fixed_sink_label
+
+    def _shared_lc_ordered_combination_labels(
+        self,
+        left_index: CurrentIndex,
+        right_index: CurrentIndex,
+    ) -> tuple[int, ...] | None:
+        proposed = (
+            *left_index.ordered_external_labels,
+            *right_index.ordered_external_labels,
+        )
+        return self._shared_lc_ordered_proposed_labels(proposed)
+
+    def shared_lc_ordered_proposed_labels(
+        self,
+        proposed: Iterable[int],
+        *,
+        allow_reversed: bool = False,
+    ) -> tuple[int, ...] | None:
+        if not self._shared_lc_orderings:
+            return None
+        return self._shared_lc_ordered_proposed_labels(
+            tuple(proposed),
+            allow_reversed=allow_reversed,
+        )
+
+    def _shared_lc_ordered_proposed_labels(
+        self,
+        proposed: tuple[int, ...],
+        *,
+        allow_reversed: bool = False,
+    ) -> tuple[int, ...] | None:
+        cache = self._shared_lc_proposed_labels_cache
+        cache_key = (proposed, allow_reversed)
+        if cache is not None and cache_key in cache:
+            return cache[cache_key]
+        coloured_segment = tuple(
+            label for label in proposed if label in self._shared_lc_coloured_labels
+        )
+        extras = tuple(
+            sorted(
+                label
+                for label in proposed
+                if label not in self._shared_lc_coloured_labels
+            )
+        )
+        result: tuple[int, ...] | None
+        if extras and not set(extras).issubset(self._shared_lc_singlet_labels):
+            result = None
+        elif not coloured_segment:
+            result = extras
+        elif coloured_segment not in self._shared_lc_segments:
+            reversed_segment = tuple(reversed(coloured_segment))
+            if not (allow_reversed and reversed_segment in self._shared_lc_segments):
+                result = None
+            else:
+                result = (*coloured_segment, *extras)
+        else:
+            result = (*coloured_segment, *extras)
+        if cache is not None:
+            cache[cache_key] = result
+        return result
+
+    def _shared_lc_closure_word(
+        self,
+        left_index: CurrentIndex,
+        right_index: CurrentIndex,
+    ) -> tuple[int, ...] | None:
+        closure = self._shared_lc_closure(left_index, right_index)
+        return None if closure is None else closure[0]
+
+    def _shared_lc_closure(
+        self,
+        left_index: CurrentIndex,
+        right_index: CurrentIndex,
+    ) -> tuple[tuple[int, ...], tuple[int, ...]] | None:
+        left_word = tuple(
+            label
+            for label in left_index.ordered_external_labels
+            if label in self._shared_lc_coloured_labels
+        )
+        right_word = tuple(
+            label
+            for label in right_index.ordered_external_labels
+            if label in self._shared_lc_coloured_labels
+        )
+        if not left_word or not right_word:
+            return None
+        candidates = [(*left_word, *right_word)]
+        if self.color_plan.color_accuracy != "lc":
+            candidates.append((*right_word, *left_word))
+        word = next(
+            (
+                candidate
+                for candidate in candidates
+                if candidate in self._shared_lc_sector_ids_by_word
+            ),
+            None,
+        )
+        if word is None:
+            return None
+        sector_ids = self._shared_lc_sector_ids_by_word[word]
+        basis_keys = (
+            *left_index.color_state.basis_key,
+            *right_index.color_state.basis_key,
+        )
+        closures = _lc_color_identity_closures(basis_keys)
+        support = _lc_sector_support(basis_keys)
+        compatible_sector_ids = tuple(
+            sector_id
+            for sector_id in sector_ids
+            if (sector := self._sector_by_id.get(sector_id)) is not None
+            and (support is None or sector_id in support)
+            and _lc_color_identity_closures_compatible(closures, sector)
+        )
+        if not compatible_sector_ids:
+            return None
+        return word, compatible_sector_ids
diff --git a/pyamplicol/src/pyamplicol/generation/dag_compiler.py b/pyamplicol/src/pyamplicol/generation/dag_compiler.py
new file mode 100644
index 0000000000..8323e61734
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/dag_compiler.py
@@ -0,0 +1,2217 @@
+# SPDX-License-Identifier: 0BSD
+"""Current-table construction for generic process DAGs."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from dataclasses import replace
+
+from ..color.plan import GenericColorPlan, build_color_plan
+from ..models._physics_ir import ContractionIR
+from ..models.base import (
+    CouplingOrders,
+    Model,
+    QuantumFlow,
+    Vertex,
+    VertexEvaluationEquivalence,
+    VertexLoweringRule,
+)
+from ..processes.ir import CanonicalProcessIR
+from .dag_algorithms import (
+    BackwardLiveStatePlan,
+    BackwardLiveTransition,
+    _canonicalize_amplitude_root_order,
+    _LiveCurrentShape,
+    _normalize_generation_cap,
+    _retain_canonical_open_line_alias_roots,
+    build_backward_live_state_plan,
+    prune_dag_to_amplitude_roots,
+)
+from .dag_color import ColorEngine
+from .dag_equivalence import (
+    RecursiveEvaluationReuseTracker,
+    _canonical_kernel_evaluation,
+    assign_recursive_current_evaluation_reuse,
+)
+from .dag_ordering import (
+    _closure_candidate_splits,
+    _closure_combination_matches_word,
+    _closure_side_reachable_masks,
+    _complex_weight_mul,
+    _direct_contraction_ir,
+    _labels_mask,
+    _labels_projected_to_word,
+    _lc_all_adjoint_symmetry_order_variants,
+    _lc_color_order_reachable_masks,
+    _mask_labels,
+)
+from .dag_reachability import (
+    _coupling_orders_within_limits,
+    _lc_line_groups_within_limit,
+    _mask_allowed_by_reachability,
+    _masks_by_size,
+    _normalize_coupling_order_limits,
+    _ordered_splits,
+    _right_particles_by_left,
+    _state_allowed_by_reachability,
+    _useful_states_by_mask,
+)
+from .dag_table import _CurrentTable
+from .dag_types import (
+    AmplitudeRoot,
+    ColorFlow,
+    ColorState,
+    CurrentIndex,
+    CurrentNode,
+    GenericDAG,
+    InteractionNode,
+)
+from .fermion_ordering import apply_fermion_ordering_signs
+
+DAGProgressCallback = Callable[[Mapping[str, str | int]], None]
+
+
+def _restrict_color_plan(
+    color_plan: GenericColorPlan,
+    selected_color_sector_ids: frozenset[int] | None,
+) -> tuple[GenericColorPlan, tuple[int, ...]]:
+    """Apply an explicit sector selection without hiding missing ids."""
+
+    if selected_color_sector_ids is None:
+        return color_plan, ()
+    selected_sectors = tuple(
+        sector
+        for sector in color_plan.sectors
+        if sector.id in selected_color_sector_ids
+    )
+    selected_ids = {sector.id for sector in selected_sectors}
+    missing_sector_ids = tuple(sorted(selected_color_sector_ids - selected_ids))
+    diagnostics = color_plan.diagnostics
+    if missing_sector_ids:
+        diagnostics = (
+            *diagnostics,
+            "selected colour sector ids were not materialized: "
+            + ", ".join(str(sector_id) for sector_id in missing_sector_ids),
+        )
+    return (
+        GenericColorPlan(
+            process=color_plan.process,
+            color_accuracy=color_plan.color_accuracy,
+            sectors=selected_sectors,
+            diagnostics=diagnostics,
+            truncated=color_plan.truncated or bool(missing_sector_ids),
+            trace_reflections_folded=color_plan.trace_reflections_folded,
+            basis=color_plan.basis,
+        ),
+        missing_sector_ids,
+    )
+
+
+class GenericDAGCompiler:
+    """Compile a concrete process into a model-driven current DAG.
+
+    The compiler never classifies the whole process as a family.  It sweeps
+    external subsets, asks the model which local vertices are valid for two
+    current particle ids, asks the colour engine whether their colour states
+    combine, and deduplicates solely by ``CurrentIndex`` equality.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: Model,
+        color_plan: GenericColorPlan | None = None,
+        max_currents: int | None = None,
+        max_color_sectors: int | None = None,
+        reference_color_order: tuple[int, ...] | None = None,
+        selected_color_sector_ids: Iterable[int] | None = None,
+        max_coupling_orders: Mapping[str, int] | None = None,
+        max_lc_current_line_groups: int | None = None,
+        max_quark_pairs: int | None = None,
+        closure_side_mask_pruning: bool = True,
+        color_order_mask_pruning: bool = True,
+        species_reachability_pruning: bool = True,
+        ignored_particle_ids: Iterable[int] | None = None,
+        ignored_vertex_kinds: Iterable[int] | None = None,
+        selected_source_helicities: Mapping[int, int] | None = None,
+        lc_all_ordering_symmetry: bool = True,
+        online_evaluation_reuse: bool = False,
+        backward_live_planning: bool = False,
+        progress_callback: DAGProgressCallback | None = None,
+    ) -> None:
+        self.model = model
+        self.color_plan = color_plan
+        self.max_currents = _normalize_generation_cap(max_currents)
+        self.max_color_sectors = _normalize_generation_cap(max_color_sectors)
+        self.reference_color_order = reference_color_order
+        self.selected_color_sector_ids = (
+            None
+            if selected_color_sector_ids is None
+            else frozenset(int(sector_id) for sector_id in selected_color_sector_ids)
+        )
+        self.max_coupling_orders = _normalize_coupling_order_limits(
+            max_coupling_orders,
+        )
+        self.max_lc_current_line_groups = (
+            None
+            if max_lc_current_line_groups is None
+            else max(0, int(max_lc_current_line_groups))
+        )
+        self.max_quark_pairs = (
+            None if max_quark_pairs is None else max(0, int(max_quark_pairs))
+        )
+        self.closure_side_mask_pruning = bool(closure_side_mask_pruning)
+        self.color_order_mask_pruning = bool(color_order_mask_pruning)
+        self.species_reachability_pruning = bool(species_reachability_pruning)
+        self.ignored_particle_ids = frozenset(
+            int(particle_id) for particle_id in (ignored_particle_ids or ())
+        )
+        self.ignored_vertex_kinds = frozenset(
+            int(kind) for kind in (ignored_vertex_kinds or ())
+        )
+        self.selected_source_helicities = (
+            None
+            if selected_source_helicities is None
+            else {
+                int(label): int(helicity)
+                for label, helicity in selected_source_helicities.items()
+            }
+        )
+        self.lc_all_ordering_symmetry = bool(lc_all_ordering_symmetry)
+        self.online_evaluation_reuse = bool(online_evaluation_reuse)
+        self.backward_live_planning = bool(backward_live_planning)
+        self.progress_callback = progress_callback
+
+    def _report_progress(self, step: str, **details: str | int) -> None:
+        if self.progress_callback is None:
+            return
+        self.progress_callback({"step": step, **details})
+
+    def _apply_fermion_ordering(self, dag: GenericDAG) -> GenericDAG:
+        return apply_fermion_ordering_signs(dag, self.model)
+
+    def compile(self, process: CanonicalProcessIR) -> GenericDAG:
+        if not isinstance(process, CanonicalProcessIR):
+            raise TypeError(
+                "generic DAG compilation requires a model-resolved CanonicalProcessIR"
+            )
+        process_ir = process
+        self._report_progress("colour planning")
+        lc_trace_reflection_proven = bool(
+            self.lc_all_ordering_symmetry
+            and self.model.lc_trace_reflection_equivalence_is_proven(process_ir)
+        )
+        color_plan = self.color_plan
+        if color_plan is None:
+            color_plan = build_color_plan(
+                process_ir,
+                color_accuracy=process_ir.color_accuracy,
+                max_sectors=self.max_color_sectors,
+                reference_color_order=self.reference_color_order,
+                fold_trace_reflections=lc_trace_reflection_proven,
+            )
+        elif color_plan.process != process_ir:
+            raise ValueError("prebuilt color plan does not match the compiled process")
+        elif color_plan.color_accuracy != process_ir.color_accuracy:
+            raise ValueError(
+                "prebuilt color plan accuracy does not match the compiled process"
+            )
+        self._report_progress(
+            "colour-plan",
+            color_sector_count=len(color_plan.sectors),
+        )
+        helicity_coverage = (
+            "selected" if self.selected_source_helicities else "complete"
+        )
+        selected_source_helicities = tuple(
+            sorted((self.selected_source_helicities or {}).items())
+        )
+        selected_color_sector_ids = tuple(sorted(self.selected_color_sector_ids or ()))
+        color_coverage = (
+            "selected"
+            if color_plan.truncated or self.selected_color_sector_ids is not None
+            else "complete"
+        )
+        if (
+            self.max_quark_pairs is not None
+            and process_ir.color_endpoints.pair_count > self.max_quark_pairs
+        ):
+            return self._apply_fermion_ordering(
+                GenericDAG(
+                    process=process_ir,
+                    color_plan=color_plan,
+                    currents=(),
+                    sources=(),
+                    interactions=(),
+                    amplitude_roots=(),
+                    truncated=False,
+                    helicity_coverage=helicity_coverage,
+                    color_coverage=color_coverage,
+                    selected_source_helicities=selected_source_helicities,
+                    selected_color_sector_ids=selected_color_sector_ids,
+                )
+            )
+        complete_sector_ids = {sector.id for sector in color_plan.sectors}
+        color_plan, _missing_sector_ids = _restrict_color_plan(
+            color_plan,
+            self.selected_color_sector_ids,
+        )
+        if (
+            self.selected_color_sector_ids is not None
+            or {sector.id for sector in color_plan.sectors} != complete_sector_ids
+        ):
+            color_coverage = "selected"
+        color_engine = ColorEngine(
+            color_plan,
+            self.model,
+            shared_lc_all_ordering_symmetry=(
+                lc_trace_reflection_proven and self.selected_color_sector_ids is None
+            ),
+            cache_shared_lc_orderings=self.online_evaluation_reuse,
+        )
+        global_flip_anchor = self._eager_global_helicity_flip_anchor(process_ir)
+        interactions: list[InteractionNode] = []
+        interaction_keys: set[tuple[object, ...]] = set()
+        evaluation_group_by_key: dict[tuple[object, ...], int] = {}
+        evaluation_equivalence_by_kind: dict[int, VertexEvaluationEquivalence] = {}
+        evaluation_equivalence_for = self.model.vertex_evaluation_equivalence
+        equivalence_record = VertexEvaluationEquivalence
+        vertices_by_input: dict[tuple[int, int], tuple[Vertex, ...]] = {}
+        right_particles_by_left = _right_particles_by_left(
+            self.model,
+            color_accuracy=process_ir.color_accuracy,
+        )
+        vertex_allowed_cache: dict[tuple[int, int, int, int], bool] = {}
+        quantum_flow_cache: dict[tuple[object, ...], tuple[QuantumFlow, ...]] = {}
+        coupling_order_cache: dict[
+            tuple[CouplingOrders, CouplingOrders, int, tuple[int, int, int]],
+            CouplingOrders,
+        ] = {}
+        coupling_order_limit_cache: dict[CouplingOrders, bool] = {}
+        state_allowed_cache: dict[
+            tuple[int, int, CouplingOrders],
+            bool,
+        ] = {}
+        allowed_current_ids_by_mask: dict[int, tuple[int, ...]] = {}
+        candidate_particles_by_mask: dict[
+            int,
+            dict[int | None, dict[int, list[int]]],
+        ] = {}
+        candidate_right_ids_by_mask_sector_particle: dict[
+            tuple[int, int | None, int],
+            tuple[int, ...],
+        ] = {}
+        reflection_reuse_cache: dict[int, bool] = {}
+        lowering_rule_cache: dict[int, VertexLoweringRule] = {}
+        vertex_color_weight_cache: dict[Vertex, tuple[float, float]] = {}
+        auxiliary_kind_cache: dict[int, str | None] = {}
+        duplicate_orientation_cache: dict[Vertex, bool] = {}
+        color_flow_cache: dict[
+            tuple[
+                ColorState,
+                ColorState,
+                Vertex,
+                tuple[int, ...],
+                tuple[tuple[int, ...], ...],
+            ],
+            tuple[ColorFlow, ...],
+        ] = {}
+        full_mask = _labels_mask(leg.label for leg in process_ir.legs)
+        eager_shared_lc_orderings = (
+            color_engine.shared_lc_orderings if self.online_evaluation_reuse else False
+        )
+        shared_lc_all_ordering_symmetry = color_engine.shared_lc_all_ordering_symmetry
+        adjoint_vector_labels = frozenset(
+            leg.label
+            for leg in process_ir.legs
+            if leg.outgoing_pdg is not None
+            and self.model.is_massless_adjoint_vector(int(leg.outgoing_pdg))
+        )
+        locally_reflectable_current_ids: set[int] = set()
+        closure_candidate_splits = _closure_candidate_splits(
+            process_ir,
+            self.model,
+            color_engine,
+            reference_color_order=self.reference_color_order,
+        )
+        self._report_progress(
+            "reachability",
+            closure_splits=len(closure_candidate_splits),
+        )
+        closure_reachable_masks = (
+            _closure_side_reachable_masks(
+                full_mask,
+                closure_candidate_splits,
+            )
+            if self.closure_side_mask_pruning
+            else None
+        )
+        backward_planner_candidate = bool(
+            self.backward_live_planning
+            and process_ir.color_accuracy in {"nlc", "full"}
+            and not color_engine.shared_lc_orderings
+            and not color_engine.shared_single_trace
+            and len(color_plan.sectors) > 1
+        )
+        color_order_reachable_masks = (
+            _lc_color_order_reachable_masks(
+                process_ir,
+                color_plan,
+                self.model,
+            )
+            if self.color_order_mask_pruning and not backward_planner_candidate
+            else None
+        )
+        useful_states_by_mask = (
+            _useful_states_by_mask(
+                process_ir,
+                self.model,
+                color_engine,
+                closure_candidate_splits,
+                closure_reachable_masks,
+                color_order_reachable_masks,
+                max_coupling_orders=self.max_coupling_orders,
+                ignored_particle_ids=self.ignored_particle_ids,
+                ignored_vertex_kinds=self.ignored_vertex_kinds,
+            )
+            if self.species_reachability_pruning
+            else None
+        )
+        live_state_plan = (
+            build_backward_live_state_plan(
+                process_ir,
+                model=self.model,
+                color_engine=color_engine,
+                closure_candidate_splits=closure_candidate_splits,
+                closure_reachable_masks=closure_reachable_masks,
+                color_order_reachable_masks=color_order_reachable_masks,
+                useful_states_by_mask=useful_states_by_mask,
+                max_coupling_orders=self.max_coupling_orders,
+                max_lc_current_line_groups=self.max_lc_current_line_groups,
+                ignored_particle_ids=self.ignored_particle_ids,
+                ignored_vertex_kinds=self.ignored_vertex_kinds,
+                selected_source_helicities=self.selected_source_helicities,
+                global_flip_anchor=global_flip_anchor,
+            )
+            if self.backward_live_planning
+            else None
+        )
+        if (
+            live_state_plan is None
+            and backward_planner_candidate
+            and self.color_order_mask_pruning
+        ):
+            color_order_reachable_masks = _lc_color_order_reachable_masks(
+                process_ir,
+                color_plan,
+                self.model,
+            )
+            useful_states_by_mask = (
+                _useful_states_by_mask(
+                    process_ir,
+                    self.model,
+                    color_engine,
+                    closure_candidate_splits,
+                    closure_reachable_masks,
+                    color_order_reachable_masks,
+                    max_coupling_orders=self.max_coupling_orders,
+                    ignored_particle_ids=self.ignored_particle_ids,
+                    ignored_vertex_kinds=self.ignored_vertex_kinds,
+                )
+                if self.species_reachability_pruning
+                else None
+            )
+        table = _CurrentTable(self.model)
+        current_index_factory = (
+            CurrentIndex._from_trusted_values
+            if self.online_evaluation_reuse
+            else CurrentIndex
+        )
+        sources = self._build_sources(
+            process_ir,
+            color_engine,
+            table,
+            global_flip_anchor=global_flip_anchor,
+            live_state_plan=live_state_plan,
+        )
+        self._report_progress(
+            "source-currents",
+            current_count=len(table.currents),
+            source_count=len(sources),
+        )
+        reuse_tracker = (
+            RecursiveEvaluationReuseTracker(self.model)
+            if self.online_evaluation_reuse
+            else None
+        )
+        if reuse_tracker is not None:
+            for current in table.currents:
+                reuse_tracker.register_source(current)
+        truncated = False
+        if any(
+            int(leg.outgoing_pdg or 0) in self.ignored_particle_ids
+            for leg in process_ir.legs
+        ):
+            return self._apply_fermion_ordering(
+                GenericDAG(
+                    process=process_ir,
+                    color_plan=color_plan,
+                    currents=tuple(table.currents),
+                    sources=tuple(sources),
+                    interactions=(),
+                    amplitude_roots=(),
+                    truncated=False,
+                    helicity_coverage=helicity_coverage,
+                    color_coverage=color_coverage,
+                    selected_source_helicities=selected_source_helicities,
+                    selected_color_sector_ids=selected_color_sector_ids,
+                )
+            )
+
+        if live_state_plan is not None:
+            return self._apply_fermion_ordering(
+                self._compile_backward_live_plan(
+                    process_ir=process_ir,
+                    color_plan=color_plan,
+                    table=table,
+                    sources=sources,
+                    reuse_tracker=reuse_tracker,
+                    plan=live_state_plan,
+                    global_flip_anchor=global_flip_anchor,
+                    helicity_coverage=helicity_coverage,
+                    color_coverage=color_coverage,
+                    selected_source_helicities=selected_source_helicities,
+                )
+            )
+
+        def state_allowed(
+            mask: int,
+            particle_id: int,
+            coupling_orders: CouplingOrders,
+        ) -> bool:
+            if useful_states_by_mask is None:
+                return True
+            key = (mask, particle_id, coupling_orders)
+            cached = state_allowed_cache.get(key)
+            if cached is not None:
+                return cached
+            allowed = _state_allowed_by_reachability(
+                useful_states_by_mask,
+                mask,
+                particle_id,
+                coupling_orders,
+            )
+            state_allowed_cache[key] = allowed
+            return allowed
+
+        def combined_coupling_orders(
+            left_index: CurrentIndex,
+            right_index: CurrentIndex,
+            vertex: Vertex,
+        ) -> CouplingOrders:
+            key = (
+                left_index.coupling_orders,
+                right_index.coupling_orders,
+                vertex.kind,
+                vertex.particles,
+            )
+            cached = coupling_order_cache.get(key)
+            if cached is not None:
+                return cached
+            orders = self.model.combine_coupling_orders(
+                left_index,
+                right_index,
+                vertex,
+            )
+            coupling_order_cache[key] = orders
+            return orders
+
+        def coupling_orders_allowed(orders: CouplingOrders) -> bool:
+            if not self.online_evaluation_reuse:
+                return _coupling_orders_within_limits(
+                    orders,
+                    self.max_coupling_orders,
+                )
+            cached = coupling_order_limit_cache.get(orders)
+            if cached is None:
+                cached = _coupling_orders_within_limits(
+                    orders,
+                    self.max_coupling_orders,
+                )
+                coupling_order_limit_cache[orders] = cached
+            return cached
+
+        def allowed_current_ids(mask: int) -> tuple[int, ...]:
+            cached = allowed_current_ids_by_mask.get(mask)
+            if cached is None:
+                cached = tuple(
+                    current_id
+                    for current_id in table.ids_by_mask(mask)
+                    if state_allowed(
+                        mask,
+                        table.current(current_id).index.particle_id,
+                        table.current(current_id).index.coupling_orders,
+                    )
+                )
+                allowed_current_ids_by_mask[mask] = cached
+            return cached
+
+        def all_adjoint_vector_current(index: CurrentIndex) -> bool:
+            labels = index.external_labels
+            return bool(labels) and all(
+                label in adjoint_vector_labels for label in labels
+            )
+
+        def reflection_reusable_current(current_id: int) -> bool:
+            if self.online_evaluation_reuse:
+                if not eager_shared_lc_orderings:
+                    return False
+                cached = reflection_reuse_cache.get(current_id)
+                if cached is not None:
+                    return cached
+            elif not color_engine.shared_lc_orderings:
+                return False
+            current = table.current(current_id)
+            if not all_adjoint_vector_current(current.index):
+                return False
+            reusable = (
+                shared_lc_all_ordering_symmetry
+                or current.is_source
+                or current_id in locally_reflectable_current_ids
+            )
+            if self.online_evaluation_reuse:
+                reflection_reuse_cache[current_id] = reusable
+            return reusable
+
+        def candidate_right_ids_for_mask(
+            right_mask: int,
+            color_sector_id: int | None,
+            left_particle_id: int,
+        ) -> tuple[int, ...]:
+            if not self.online_evaluation_reuse:
+                raise AssertionError("eager candidate lookup requires online reuse")
+            key = (right_mask, color_sector_id, left_particle_id)
+            cached = candidate_right_ids_by_mask_sector_particle.get(key)
+            if cached is not None:
+                return cached
+            particles_by_sector = candidate_particles_by_mask.get(right_mask)
+            if particles_by_sector is None:
+                particles_by_sector = {}
+                for current_id in allowed_current_ids(right_mask):
+                    index = table.currents[current_id].index
+                    sector_id = (
+                        None
+                        if eager_shared_lc_orderings
+                        else index.color_state.sector_id
+                    )
+                    ids_by_particle = particles_by_sector.get(sector_id)
+                    if ids_by_particle is None:
+                        ids_by_particle = {}
+                        particles_by_sector[sector_id] = ids_by_particle
+                    ids = ids_by_particle.get(index.particle_id)
+                    if ids is None:
+                        ids = []
+                        ids_by_particle[index.particle_id] = ids
+                    ids.append(current_id)
+                candidate_particles_by_mask[right_mask] = particles_by_sector
+            ids_by_particle = particles_by_sector.get(color_sector_id, {})
+            candidates: list[int] = []
+            for particle_id in right_particles_by_left.get(left_particle_id, ()):
+                candidates.extend(ids_by_particle.get(particle_id, ()))
+            cached = tuple(candidates)
+            candidate_right_ids_by_mask_sector_particle[key] = cached
+            return cached
+
+        def cached_auxiliary_kind(particle_id: int) -> str | None:
+            if particle_id in auxiliary_kind_cache:
+                return auxiliary_kind_cache[particle_id]
+            kind = self.model.auxiliary_kind(particle_id)
+            auxiliary_kind_cache[particle_id] = kind
+            return kind
+
+        def cached_vertex_color_weight(
+            vertex: Vertex,
+        ) -> tuple[float, float]:
+            cached = vertex_color_weight_cache.get(vertex)
+            if cached is not None:
+                return cached
+            weight = self.model.vertex_color_weight(
+                vertex,
+                color_accuracy=process_ir.color_accuracy,
+            )
+            vertex_color_weight_cache[vertex] = weight
+            return weight
+
+        def combined_color_flows(
+            left: CurrentIndex,
+            right: CurrentIndex,
+            vertex: Vertex,
+            ordered_external_labels: tuple[int, ...],
+            sector_support_label_variants: tuple[tuple[int, ...], ...],
+        ) -> tuple[ColorFlow, ...]:
+            if not self.online_evaluation_reuse:
+                return color_engine.combine(
+                    left.color_state,
+                    right.color_state,
+                    vertex,
+                    ordered_external_labels=ordered_external_labels,
+                    sector_support_label_variants=sector_support_label_variants,
+                )
+            key = (
+                left.color_state,
+                right.color_state,
+                vertex,
+                ordered_external_labels,
+                sector_support_label_variants,
+            )
+            cached = color_flow_cache.get(key)
+            if cached is None:
+                cached = color_engine.combine(
+                    left.color_state,
+                    right.color_state,
+                    vertex,
+                    ordered_external_labels=ordered_external_labels,
+                    sector_support_label_variants=sector_support_label_variants,
+                )
+                color_flow_cache[key] = cached
+            return cached
+
+        recursive_masks = tuple(
+            mask
+            for mask in _masks_by_size(full_mask)
+            if mask & (mask - 1) and mask != full_mask
+        )
+        recursion_stage_total = max(len(process_ir.legs) - 2, 1)
+        for mask_index, mask in enumerate(recursive_masks, start=1):
+            labels = _mask_labels(mask)
+            self._report_progress(
+                "recursion",
+                stage_index=max(len(labels) - 1, 1),
+                stage_total=recursion_stage_total,
+                subset_size=len(labels),
+                mask_index=mask_index,
+                mask_total=len(recursive_masks),
+                current_count=len(table.currents),
+                interaction_count=len(interactions),
+            )
+            if not _mask_allowed_by_reachability(
+                mask,
+                closure_reachable_masks,
+                color_order_reachable_masks,
+            ):
+                continue
+            if useful_states_by_mask is not None and mask not in useful_states_by_mask:
+                continue
+            mask_current_start = len(table.currents)
+            for left_mask, right_mask in _ordered_splits(mask):
+                if not (
+                    _mask_allowed_by_reachability(
+                        left_mask,
+                        closure_reachable_masks,
+                        color_order_reachable_masks,
+                    )
+                    and _mask_allowed_by_reachability(
+                        right_mask,
+                        closure_reachable_masks,
+                        color_order_reachable_masks,
+                    )
+                ):
+                    continue
+                if useful_states_by_mask is not None and (
+                    left_mask not in useful_states_by_mask
+                    or right_mask not in useful_states_by_mask
+                ):
+                    continue
+                left_ids = (
+                    allowed_current_ids(left_mask)
+                    if self.online_evaluation_reuse
+                    else table.ids_by_mask(left_mask)
+                )
+                if not left_ids or not table.has_mask(right_mask):
+                    continue
+                split_candidates: dict[
+                    tuple[int | None, int],
+                    tuple[int, ...],
+                ] = {}
+                for left_id in left_ids:
+                    left = table.current(left_id)
+                    if not self.online_evaluation_reuse and not state_allowed(
+                        left_mask,
+                        left.index.particle_id,
+                        left.index.coupling_orders,
+                    ):
+                        continue
+                    color_sector_id = (
+                        None
+                        if (
+                            eager_shared_lc_orderings
+                            if self.online_evaluation_reuse
+                            else color_engine.shared_lc_orderings
+                        )
+                        else left.index.color_state.sector_id
+                    )
+                    if self.online_evaluation_reuse:
+                        candidate_key = (
+                            color_sector_id,
+                            left.index.particle_id,
+                        )
+                        candidate_right_ids_for_left = split_candidates.get(
+                            candidate_key
+                        )
+                        if candidate_right_ids_for_left is None:
+                            candidate_right_ids_for_left = candidate_right_ids_for_mask(
+                                right_mask,
+                                color_sector_id,
+                                left.index.particle_id,
+                            )
+                            split_candidates[candidate_key] = (
+                                candidate_right_ids_for_left
+                            )
+                    else:
+                        possible_right_particles = right_particles_by_left.get(
+                            left.index.particle_id
+                        )
+                        if not possible_right_particles:
+                            continue
+                        candidate_right_ids_for_left = table.ids_by_mask_and_particles(
+                            right_mask,
+                            possible_right_particles,
+                            color_sector_id=color_sector_id,
+                        )
+                    if not candidate_right_ids_for_left:
+                        continue
+                    left_reflection_reusable = reflection_reusable_current(left_id)
+                    for right_id in candidate_right_ids_for_left:
+                        right = table.current(right_id)
+                        right_reflection_reusable = reflection_reusable_current(
+                            right_id
+                        )
+                        if not self.online_evaluation_reuse and not state_allowed(
+                            right_mask,
+                            right.index.particle_id,
+                            right.index.coupling_orders,
+                        ):
+                            continue
+                        vertex_lookup_key = (
+                            left.index.particle_id,
+                            right.index.particle_id,
+                        )
+                        if vertex_lookup_key in vertices_by_input:
+                            vertices = vertices_by_input[vertex_lookup_key]
+                        else:
+                            vertices = self.model.vertices_accepting(
+                                left.index.particle_id,
+                                right.index.particle_id,
+                                color_accuracy=process_ir.color_accuracy,
+                            )
+                            vertices_by_input[vertex_lookup_key] = vertices
+                        for vertex in vertices:
+                            if (
+                                vertex.kind in self.ignored_vertex_kinds
+                                or vertex.particles[2] in self.ignored_particle_ids
+                            ):
+                                continue
+                            if useful_states_by_mask is not None and vertex.particles[
+                                2
+                            ] not in useful_states_by_mask.get(mask, {}):
+                                continue
+                            vertex_key = (vertex.kind, *vertex.particles)
+                            if vertex_key in vertex_allowed_cache:
+                                vertex_allowed = vertex_allowed_cache[vertex_key]
+                            else:
+                                vertex_allowed = color_engine.vertex_allowed(vertex)
+                                vertex_allowed_cache[vertex_key] = vertex_allowed
+                            if not vertex_allowed:
+                                continue
+                            if self.online_evaluation_reuse:
+                                duplicate_orientation = duplicate_orientation_cache.get(
+                                    vertex
+                                )
+                                if duplicate_orientation is None:
+                                    duplicate_orientation = (
+                                        self.model.skip_duplicate_vertex_orientation(
+                                            vertex
+                                        )
+                                    )
+                                    duplicate_orientation_cache[vertex] = (
+                                        duplicate_orientation
+                                    )
+                            else:
+                                duplicate_orientation = (
+                                    self.model.skip_duplicate_vertex_orientation(vertex)
+                                )
+                            if duplicate_orientation:
+                                continue
+                            coupling_orders = combined_coupling_orders(
+                                left.index,
+                                right.index,
+                                vertex,
+                            )
+                            if not coupling_orders_allowed(coupling_orders):
+                                continue
+                            if not state_allowed(
+                                mask,
+                                vertex.particles[2],
+                                coupling_orders,
+                            ):
+                                continue
+                            local_two_source_reflection = (
+                                (
+                                    eager_shared_lc_orderings
+                                    if self.online_evaluation_reuse
+                                    else color_engine.shared_lc_orderings
+                                )
+                                and left.is_source
+                                and right.is_source
+                                and len(left.index.external_labels) == 1
+                                and len(right.index.external_labels) == 1
+                                and left_reflection_reusable
+                                and right_reflection_reusable
+                                and self.model.adjoint_current_reflection_phase(vertex)
+                                == (-1.0, 0.0)
+                            )
+                            result_reflection_proven = (
+                                shared_lc_all_ordering_symmetry
+                                and all_adjoint_vector_current(left.index)
+                                and all_adjoint_vector_current(right.index)
+                            ) or local_two_source_reflection
+                            if result_reflection_proven and max(
+                                left.index.external_labels
+                            ) >= max(right.index.external_labels):
+                                continue
+                            ordered_external_labels = (
+                                color_engine.ordered_combination_labels(
+                                    left.index,
+                                    right.index,
+                                    vertex,
+                                )
+                            )
+                            if ordered_external_labels is None and not (
+                                left_reflection_reusable or right_reflection_reusable
+                            ):
+                                continue
+                            order_variants: tuple[
+                                tuple[
+                                    tuple[int, ...],
+                                    tuple[tuple[int, ...], ...],
+                                    tuple[float, float],
+                                ],
+                                ...,
+                            ]
+                            if left_reflection_reusable or right_reflection_reusable:
+                                variants: list[
+                                    tuple[
+                                        tuple[int, ...],
+                                        tuple[tuple[int, ...], ...],
+                                        tuple[float, float],
+                                    ]
+                                ] = []
+                                for (
+                                    proposed_labels,
+                                    symmetry_weight,
+                                ) in _lc_all_adjoint_symmetry_order_variants(
+                                    left.index.ordered_external_labels,
+                                    right.index.ordered_external_labels,
+                                    left_all_adjoint=left_reflection_reusable,
+                                    right_all_adjoint=right_reflection_reusable,
+                                    result_reflection_proven=(result_reflection_proven),
+                                    fold_result_reflections=(
+                                        color_coverage == "complete"
+                                    ),
+                                ):
+                                    projected = (
+                                        color_engine.shared_lc_ordered_proposed_labels(
+                                            proposed_labels,
+                                            allow_reversed=result_reflection_proven,
+                                        )
+                                    )
+                                    if projected is None:
+                                        continue
+                                    support_label_variants = (proposed_labels,)
+                                    if (
+                                        result_reflection_proven
+                                        and color_coverage == "complete"
+                                    ):
+                                        reflected_labels = tuple(
+                                            reversed(proposed_labels)
+                                        )
+                                        if reflected_labels != proposed_labels:
+                                            support_label_variants = (
+                                                proposed_labels,
+                                                reflected_labels,
+                                            )
+                                    variants.append(
+                                        (
+                                            projected,
+                                            support_label_variants,
+                                            symmetry_weight,
+                                        )
+                                    )
+                                order_variants = tuple(variants)
+                                if not order_variants:
+                                    continue
+                            else:
+                                if ordered_external_labels is None:
+                                    continue
+                                order_variants = (
+                                    (
+                                        ordered_external_labels,
+                                        (ordered_external_labels,),
+                                        (1.0, 0.0),
+                                    ),
+                                )
+                            quantum_flow_key = (
+                                vertex.kind,
+                                vertex.particles,
+                                left.index.particle_id,
+                                left.index.chirality,
+                                left.index.flavour_flow,
+                                right.index.particle_id,
+                                right.index.chirality,
+                                right.index.flavour_flow,
+                            )
+                            if quantum_flow_key in quantum_flow_cache:
+                                quantum_flows = quantum_flow_cache[quantum_flow_key]
+                            else:
+                                quantum_flows = self.model.allowed_quantum_flows(
+                                    vertex,
+                                    left.index,
+                                    right.index,
+                                )
+                                quantum_flow_cache[quantum_flow_key] = quantum_flows
+                            for quantum_flow in quantum_flows:
+                                for variant_index, (
+                                    variant_ordered_labels,
+                                    sector_support_label_variants,
+                                    symmetry_weight,
+                                ) in enumerate(order_variants):
+                                    for color_flow in combined_color_flows(
+                                        left.index,
+                                        right.index,
+                                        vertex,
+                                        variant_ordered_labels,
+                                        sector_support_label_variants,
+                                    ):
+                                        if not _lc_line_groups_within_limit(
+                                            color_flow.state,
+                                            self.max_lc_current_line_groups,
+                                        ):
+                                            continue
+                                        out_index = current_index_factory(
+                                            particle_id=vertex.particles[2],
+                                            external_mask=mask,
+                                            external_labels=labels,
+                                            ordered_external_labels=variant_ordered_labels,
+                                            helicity_ancestry=(
+                                                left.index.helicity_ancestry
+                                                | right.index.helicity_ancestry
+                                            ),
+                                            chirality=quantum_flow.chirality,
+                                            spin_state=quantum_flow.spin_state,
+                                            flavour_flow=quantum_flow.flavour_flow,
+                                            quantum_number_flow=(
+                                                quantum_flow.quantum_number_flow
+                                            ),
+                                            color_state=color_flow.state,
+                                            momentum_mask=(
+                                                left.index.momentum_mask
+                                                | right.index.momentum_mask
+                                            ),
+                                            coupling_orders=coupling_orders,
+                                            auxiliary_kind=(
+                                                cached_auxiliary_kind(
+                                                    vertex.particles[2]
+                                                )
+                                                if self.online_evaluation_reuse
+                                                else self.model.auxiliary_kind(
+                                                    vertex.particles[2]
+                                                )
+                                            ),
+                                        )
+                                        if (
+                                            live_state_plan is not None
+                                            and not live_state_plan.allows(out_index)
+                                        ):
+                                            continue
+                                        if not self.model.current_allowed(out_index):
+                                            continue
+                                        result = table.add_or_get(
+                                            out_index,
+                                            is_source=False,
+                                        )
+                                        if local_two_source_reflection:
+                                            locally_reflectable_current_ids.add(
+                                                result.id
+                                            )
+                                        signed_color_weight = _complex_weight_mul(
+                                            _complex_weight_mul(
+                                                color_flow.weight,
+                                                cached_vertex_color_weight(vertex)
+                                                if self.online_evaluation_reuse
+                                                else self.model.vertex_color_weight(
+                                                    vertex,
+                                                    color_accuracy=(
+                                                        process_ir.color_accuracy
+                                                    ),
+                                                ),
+                                            ),
+                                            symmetry_weight,
+                                        )
+                                        key = (
+                                            vertex.kind,
+                                            left_id,
+                                            right_id,
+                                            result.id,
+                                            variant_index,
+                                            signed_color_weight,
+                                        )
+                                        if key in interaction_keys:
+                                            continue
+                                        interaction_keys.add(key)
+                                        if self.online_evaluation_reuse:
+                                            rule = lowering_rule_cache.get(vertex.kind)
+                                            if rule is None:
+                                                rule = self.model.vertex_lowering_rule(
+                                                    vertex.kind
+                                                )
+                                                lowering_rule_cache[vertex.kind] = rule
+                                        else:
+                                            rule = self.model.vertex_lowering_rule(
+                                                vertex.kind
+                                            )
+                                        if reuse_tracker is not None:
+                                            (
+                                                evaluation_group_id,
+                                                evaluation_factor,
+                                            ) = reuse_tracker.interaction_evaluation(
+                                                vertex_kind=vertex.kind,
+                                                vertex_particles=vertex.particles,
+                                                left_id=left_id,
+                                                right_id=right_id,
+                                                result=result,
+                                                coupling=quantum_flow.coupling,
+                                                color_weight=signed_color_weight,
+                                            )
+                                        else:
+                                            equivalence = (
+                                                evaluation_equivalence_by_kind.get(
+                                                    vertex.kind
+                                                )
+                                            )
+                                            if equivalence is None:
+                                                equivalence = (
+                                                    evaluation_equivalence_for(
+                                                        vertex.kind
+                                                    )
+                                                )
+                                                if not equivalence.verified:
+                                                    model_type = (
+                                                        f"{type(self.model).__module__}."
+                                                        f"{type(self.model).__qualname__}"
+                                                    )
+                                                    equivalence = equivalence_record(
+                                                        class_id=(
+                                                            f"{model_type}:"
+                                                            f"{int(vertex.kind)}"
+                                                        )
+                                                    )
+                                                evaluation_equivalence_by_kind[
+                                                    vertex.kind
+                                                ] = equivalence
+                                            (
+                                                canonical_inputs,
+                                                evaluation_factor,
+                                            ) = _canonical_kernel_evaluation(
+                                                equivalence,
+                                                left_id,
+                                                right_id,
+                                            )
+                                            evaluation_key = (
+                                                equivalence.class_id,
+                                                canonical_inputs,
+                                                int(result.index.particle_id),
+                                                int(result.index.chirality),
+                                                quantum_flow.coupling,
+                                            )
+                                            existing_group_id = (
+                                                evaluation_group_by_key.get(
+                                                    evaluation_key
+                                                )
+                                            )
+                                            if existing_group_id is None:
+                                                existing_group_id = len(
+                                                    evaluation_group_by_key
+                                                )
+                                                evaluation_group_by_key[
+                                                    evaluation_key
+                                                ] = existing_group_id
+                                            evaluation_group_id = existing_group_id
+                                        interactions.append(
+                                            InteractionNode(
+                                                id=len(interactions),
+                                                vertex_kind=vertex.kind,
+                                                vertex_particles=vertex.particles,
+                                                left_id=left_id,
+                                                right_id=right_id,
+                                                result_id=result.id,
+                                                coupling=quantum_flow.coupling,
+                                                color_weight=signed_color_weight,
+                                                lowering_backend=rule.backend,
+                                                full_tensor_network_ready=(
+                                                    rule.full_tensor_network_ready
+                                                ),
+                                                evaluation_group_id=(
+                                                    evaluation_group_id
+                                                ),
+                                                evaluation_factor=evaluation_factor,
+                                            )
+                                        )
+                                        if (
+                                            self.max_currents is not None
+                                            and len(table.currents) > self.max_currents
+                                        ):
+                                            truncated = True
+                                            return self._apply_fermion_ordering(
+                                                GenericDAG(
+                                                    process=process_ir,
+                                                    color_plan=color_plan,
+                                                    currents=tuple(table.currents),
+                                                    sources=tuple(sources),
+                                                    interactions=tuple(interactions),
+                                                    amplitude_roots=tuple(
+                                                        self._build_amplitude_roots(
+                                                            process_ir,
+                                                            table,
+                                                            color_engine,
+                                                            candidate_splits=closure_candidate_splits,
+                                                        )
+                                                    ),
+                                                    truncated=truncated,
+                                                    helicity_coverage=helicity_coverage,
+                                                    color_coverage=color_coverage,
+                                                    selected_source_helicities=(
+                                                        selected_source_helicities
+                                                    ),
+                                                    selected_color_sector_ids=(
+                                                        selected_color_sector_ids
+                                                    ),
+                                                )
+                                            )
+
+            if reuse_tracker is not None:
+                reuse_tracker.finalize_currents(
+                    table.currents[mask_current_start:],
+                )
+
+        self._report_progress(
+            "amplitude-closure",
+            current_count=len(table.currents),
+            interaction_count=len(interactions),
+        )
+        amplitude_roots = tuple(
+            self._build_amplitude_roots(
+                process_ir,
+                table,
+                color_engine,
+                candidate_splits=closure_candidate_splits,
+            )
+        )
+        if global_flip_anchor is not None:
+            amplitude_roots = tuple(
+                replace(
+                    root,
+                    helicity_weight=2.0 * float(root.helicity_weight),
+                )
+                for root in amplitude_roots
+            )
+        dag = GenericDAG(
+            process=process_ir,
+            color_plan=color_plan,
+            currents=tuple(table.currents),
+            sources=tuple(sources),
+            interactions=tuple(interactions),
+            amplitude_roots=amplitude_roots,
+            truncated=truncated,
+            helicity_coverage=helicity_coverage,
+            color_coverage=color_coverage,
+            selected_source_helicities=selected_source_helicities,
+            selected_color_sector_ids=selected_color_sector_ids,
+        )
+        dag = _retain_canonical_open_line_alias_roots(dag, self.model)
+        if global_flip_anchor is not None:
+            dag = _canonicalize_amplitude_root_order(dag)
+        if reuse_tracker is not None:
+            self._report_progress(
+                "symmetry-reuse",
+                current_count=len(dag.currents),
+                interaction_count=len(dag.interactions),
+                amplitude_count=len(dag.amplitude_roots),
+            )
+            return self._apply_fermion_ordering(dag)
+        dag = assign_recursive_current_evaluation_reuse(dag, self.model)
+        self._report_progress(
+            "symmetry-reuse",
+            current_count=len(dag.currents),
+            interaction_count=len(dag.interactions),
+            amplitude_count=len(dag.amplitude_roots),
+        )
+        return self._apply_fermion_ordering(dag)
+
+    def _compile_backward_live_plan(
+        self,
+        *,
+        process_ir: CanonicalProcessIR,
+        color_plan: GenericColorPlan,
+        table: _CurrentTable,
+        sources: Sequence[int],
+        reuse_tracker: RecursiveEvaluationReuseTracker | None,
+        plan: BackwardLiveStatePlan,
+        global_flip_anchor: tuple[int, int] | None,
+        helicity_coverage: str,
+        color_coverage: str,
+        selected_source_helicities: tuple[tuple[int, int], ...],
+    ) -> GenericDAG:
+        """Replay certified live transition templates over exact helicities.
+
+        The backward planner has already performed model, colour, coupling,
+        and quantum-flow resolution.  Replay only expands independent source
+        helicity ancestries and records the ordinary current/interactions DTOs.
+        No backend evaluator or prepared-kernel operation occurs here.
+        """
+
+        if len(plan.sources) != len(sources):
+            raise ValueError("backward-live source plan does not match source table")
+        current_index_factory = (
+            CurrentIndex._from_trusted_values
+            if self.online_evaluation_reuse
+            else CurrentIndex
+        )
+        ids_by_shape: dict[_LiveCurrentShape, dict[int, int]] = {}
+        for source, current_id in zip(plan.sources, sources, strict=True):
+            ids_by_shape.setdefault(source.shape, {})[source.helicity_ancestry] = (
+                current_id
+            )
+        transitions_by_mask: dict[int, list[BackwardLiveTransition]] = {}
+        for transition in plan.transitions:
+            transitions_by_mask.setdefault(
+                transition.result.external_mask,
+                [],
+            ).append(transition)
+
+        interactions: list[InteractionNode] = []
+        interaction_keys: set[tuple[object, ...]] = set()
+        lowering_rules: dict[int, VertexLoweringRule] = {}
+        auxiliary_kinds: dict[int, str | None] = {}
+        full_mask = _labels_mask(leg.label for leg in process_ir.legs)
+        truncated = False
+
+        def replay_transition(
+            transition: BackwardLiveTransition,
+            left_id: int,
+            right_id: int,
+        ) -> None:
+            nonlocal truncated
+            left = table.current(left_id)
+            right = table.current(right_id)
+            rule = lowering_rules.get(transition.vertex_kind)
+            if rule is None:
+                rule = self.model.vertex_lowering_rule(transition.vertex_kind)
+                lowering_rules[transition.vertex_kind] = rule
+            result_ancestry = int(
+                left.index.helicity_ancestry | right.index.helicity_ancestry
+            )
+            result_by_ancestry = ids_by_shape.setdefault(transition.result, {})
+            result_id = result_by_ancestry.get(result_ancestry)
+            if result_id is None:
+                particle_id = transition.result.particle_id
+                if particle_id not in auxiliary_kinds:
+                    auxiliary_kinds[particle_id] = self.model.auxiliary_kind(
+                        particle_id
+                    )
+                result = table.add_or_get(
+                    current_index_factory(
+                        particle_id=particle_id,
+                        external_mask=transition.result.external_mask,
+                        external_labels=transition.result.external_labels,
+                        ordered_external_labels=(
+                            transition.result.ordered_external_labels
+                        ),
+                        helicity_ancestry=result_ancestry,
+                        chirality=transition.result.chirality,
+                        spin_state=transition.result.spin_state,
+                        flavour_flow=transition.result.flavour_flow,
+                        quantum_number_flow=(transition.result.quantum_number_flow),
+                        color_state=transition.result.color_state,
+                        momentum_mask=transition.result.external_mask,
+                        coupling_orders=transition.result.coupling_orders,
+                        auxiliary_kind=auxiliary_kinds[particle_id],
+                    ),
+                    is_source=False,
+                )
+                result_by_ancestry[result_ancestry] = result.id
+            else:
+                result = table.current(result_id)
+            key = (
+                transition.vertex_kind,
+                left_id,
+                right_id,
+                result.id,
+                0,
+                transition.color_weight,
+            )
+            if key in interaction_keys:
+                return
+            interaction_keys.add(key)
+            if reuse_tracker is None:
+                evaluation_group_id = None
+                evaluation_factor = (1.0, 0.0)
+            else:
+                (
+                    evaluation_group_id,
+                    evaluation_factor,
+                ) = reuse_tracker.interaction_evaluation(
+                    vertex_kind=transition.vertex_kind,
+                    vertex_particles=transition.vertex_particles,
+                    left_id=left_id,
+                    right_id=right_id,
+                    result=result,
+                    coupling=transition.coupling,
+                    color_weight=transition.color_weight,
+                )
+            interactions.append(
+                InteractionNode(
+                    id=len(interactions),
+                    vertex_kind=transition.vertex_kind,
+                    vertex_particles=transition.vertex_particles,
+                    left_id=left_id,
+                    right_id=right_id,
+                    result_id=result.id,
+                    coupling=transition.coupling,
+                    color_weight=transition.color_weight,
+                    lowering_backend=rule.backend,
+                    full_tensor_network_ready=rule.full_tensor_network_ready,
+                    evaluation_group_id=evaluation_group_id,
+                    evaluation_factor=evaluation_factor,
+                )
+            )
+            if (
+                self.max_currents is not None
+                and len(table.currents) > self.max_currents
+            ):
+                truncated = True
+
+        recursive_masks = tuple(
+            mask for mask in _masks_by_size(full_mask) if mask in transitions_by_mask
+        )
+        recursion_stage_total = max(len(process_ir.legs) - 2, 1)
+        for mask_index, mask in enumerate(recursive_masks, start=1):
+            stage_transitions = transitions_by_mask[mask]
+            labels = _mask_labels(mask)
+            self._report_progress(
+                "recursion",
+                stage_index=max(len(labels) - 1, 1),
+                stage_total=recursion_stage_total,
+                subset_size=len(labels),
+                mask_index=mask_index,
+                mask_total=len(recursive_masks),
+                current_count=len(table.currents),
+                interaction_count=len(interactions),
+            )
+            mask_current_start = len(table.currents)
+            transitions_by_split: dict[
+                tuple[int, int],
+                list[BackwardLiveTransition],
+            ] = {}
+            for transition in stage_transitions:
+                transitions_by_split.setdefault(
+                    (
+                        transition.left.external_mask,
+                        transition.right.external_mask,
+                    ),
+                    [],
+                ).append(transition)
+            for split_transitions in transitions_by_split.values():
+                transitions_by_left: dict[
+                    _LiveCurrentShape,
+                    list[BackwardLiveTransition],
+                ] = {}
+                for transition in split_transitions:
+                    transitions_by_left.setdefault(transition.left, []).append(
+                        transition
+                    )
+                exact_left_currents = sorted(
+                    (
+                        (left_id, left_shape)
+                        for left_shape in transitions_by_left
+                        for left_id in ids_by_shape.get(left_shape, {}).values()
+                    ),
+                    key=lambda entry: entry[0],
+                )
+                for left_id, left_shape in exact_left_currents:
+                    for transition in transitions_by_left[left_shape]:
+                        right_by_ancestry = ids_by_shape.get(transition.right)
+                        if not right_by_ancestry:
+                            continue
+                        for right_id in sorted(right_by_ancestry.values()):
+                            replay_transition(transition, left_id, right_id)
+                            if truncated:
+                                break
+                        if truncated:
+                            break
+                    if truncated:
+                        break
+                if truncated:
+                    break
+            if reuse_tracker is not None:
+                reuse_tracker.finalize_currents(table.currents[mask_current_start:])
+            if truncated:
+                break
+
+        self._report_progress(
+            "amplitude-closure",
+            current_count=len(table.currents),
+            interaction_count=len(interactions),
+        )
+        amplitude_roots_list: list[AmplitudeRoot] = []
+        seen_roots: set[tuple[object, ...]] = set()
+        for closure in plan.closures:
+            left_by_ancestry = ids_by_shape.get(closure.left)
+            right_by_ancestry = ids_by_shape.get(closure.right)
+            if not left_by_ancestry or not right_by_ancestry:
+                continue
+            for left_id in left_by_ancestry.values():
+                for right_id in right_by_ancestry.values():
+                    root_key = (
+                        closure.kind,
+                        closure.contraction_ir,
+                        left_id,
+                        right_id,
+                        closure.color_sector_id,
+                        closure.vertex_kind,
+                        closure.vertex_particles,
+                        closure.color_weight,
+                    )
+                    if root_key in seen_roots:
+                        continue
+                    seen_roots.add(root_key)
+                    amplitude_roots_list.append(
+                        AmplitudeRoot(
+                            id=len(amplitude_roots_list),
+                            kind=closure.kind,
+                            left_id=left_id,
+                            right_id=right_id,
+                            color_weight=closure.color_weight,
+                            contraction_ir=closure.contraction_ir,
+                            color_sector_id=closure.color_sector_id,
+                            vertex_kind=closure.vertex_kind,
+                            vertex_particles=closure.vertex_particles,
+                            coupling=closure.coupling,
+                        )
+                    )
+        amplitude_roots = tuple(amplitude_roots_list)
+        if global_flip_anchor is not None:
+            amplitude_roots = tuple(
+                replace(
+                    root,
+                    helicity_weight=2.0 * float(root.helicity_weight),
+                )
+                for root in amplitude_roots
+            )
+        dag = GenericDAG(
+            process=process_ir,
+            color_plan=color_plan,
+            currents=tuple(table.currents),
+            sources=tuple(sources),
+            interactions=tuple(interactions),
+            amplitude_roots=amplitude_roots,
+            truncated=truncated,
+            helicity_coverage=helicity_coverage,
+            color_coverage=color_coverage,
+            selected_source_helicities=selected_source_helicities,
+            selected_color_sector_ids=tuple(
+                sorted(self.selected_color_sector_ids or ())
+            ),
+        )
+        dag = _retain_canonical_open_line_alias_roots(dag, self.model)
+        dag = prune_dag_to_amplitude_roots(dag)
+        if global_flip_anchor is not None:
+            dag = _canonicalize_amplitude_root_order(dag)
+        if reuse_tracker is not None:
+            self._report_progress(
+                "symmetry-reuse",
+                current_count=len(dag.currents),
+                interaction_count=len(dag.interactions),
+                amplitude_count=len(dag.amplitude_roots),
+            )
+            return dag
+        dag = assign_recursive_current_evaluation_reuse(dag, self.model)
+        self._report_progress(
+            "symmetry-reuse",
+            current_count=len(dag.currents),
+            interaction_count=len(dag.interactions),
+            amplitude_count=len(dag.amplitude_roots),
+        )
+        return dag
+
+    def _build_sources(
+        self,
+        process_ir: CanonicalProcessIR,
+        color_engine: ColorEngine,
+        table: _CurrentTable,
+        *,
+        global_flip_anchor: tuple[int, int] | None = None,
+        live_state_plan: BackwardLiveStatePlan | None = None,
+    ) -> list[int]:
+        current_index_factory = (
+            CurrentIndex._from_trusted_values
+            if self.online_evaluation_reuse
+            else CurrentIndex
+        )
+        if live_state_plan is not None:
+            sources: list[int] = []
+            auxiliary_kinds: dict[int, str | None] = {}
+            for source in live_state_plan.sources:
+                shape = source.shape
+                particle_id = shape.particle_id
+                if particle_id not in auxiliary_kinds:
+                    auxiliary_kinds[particle_id] = self.model.auxiliary_kind(
+                        particle_id
+                    )
+                current = table.add_or_get(
+                    current_index_factory(
+                        particle_id=particle_id,
+                        external_mask=shape.external_mask,
+                        external_labels=shape.external_labels,
+                        ordered_external_labels=shape.ordered_external_labels,
+                        helicity_ancestry=source.helicity_ancestry,
+                        chirality=shape.chirality,
+                        spin_state=shape.spin_state,
+                        flavour_flow=shape.flavour_flow,
+                        quantum_number_flow=shape.quantum_number_flow,
+                        color_state=shape.color_state,
+                        momentum_mask=shape.external_mask,
+                        coupling_orders=shape.coupling_orders,
+                        auxiliary_kind=auxiliary_kinds[particle_id],
+                    ),
+                    is_source=True,
+                    source_leg_label=source.leg_label,
+                    source_helicity=source.source_helicity,
+                )
+                sources.append(current.id)
+            return sources
+
+        sources: list[int] = []
+        next_source_bit = 0
+        for leg in process_ir.legs:
+            if leg.outgoing_pdg is None:
+                continue
+            particle_id = int(leg.outgoing_pdg)
+            source_ir = self.model._source_ir(particle_id)
+            source_quantum_flow = (
+                self.model.quantum_number_flow(particle_id)
+                if live_state_plan is not None
+                else None
+            )
+            source_auxiliary_kind = (
+                self.model.auxiliary_kind(particle_id)
+                if live_state_plan is not None
+                else None
+            )
+            for color_state in color_engine.source_states_for_leg(leg):
+                if not _lc_line_groups_within_limit(
+                    color_state,
+                    self.max_lc_current_line_groups,
+                ):
+                    continue
+                color_state_is_live = (
+                    live_state_plan is None
+                    or color_state.sector_id in live_state_plan.active_sector_ids
+                )
+                for declared_state in source_ir.states:
+                    source_state = (
+                        source_ir.crossing.apply(declared_state)
+                        if leg.is_initial
+                        else declared_state
+                    )
+                    chirality = source_state.chirality
+                    source_helicity = source_state.helicity
+                    spin_state = source_state.spin_state
+                    if (
+                        global_flip_anchor is not None
+                        and leg.label == global_flip_anchor[0]
+                        and int(source_helicity) != global_flip_anchor[1]
+                    ):
+                        # Preserve the ancestry bit positions of the complete
+                        # source basis. This keeps the retained half directly
+                        # comparable with the existing post-DAG parity prune.
+                        next_source_bit += 1
+                        continue
+                    if (
+                        self.selected_source_helicities is not None
+                        and (
+                            requested_helicity := self.selected_source_helicities.get(
+                                leg.label
+                            )
+                        )
+                        is not None
+                        and int(source_helicity) != requested_helicity
+                    ):
+                        continue
+                    helicity_ancestry = 1 << next_source_bit
+                    next_source_bit += 1
+                    if not color_state_is_live:
+                        continue
+                    if live_state_plan is not None:
+                        assert source_quantum_flow is not None
+                        source_shape = _LiveCurrentShape(
+                            external_mask=1 << (leg.label - 1),
+                            external_labels=(leg.label,),
+                            particle_id=particle_id,
+                            ordered_external_labels=(leg.label,),
+                            color_state=color_state,
+                            coupling_orders=(),
+                            chirality=chirality,
+                            spin_state=spin_state,
+                            flavour_flow=(particle_id,),
+                            quantum_number_flow=source_quantum_flow,
+                        )
+                        if source_shape not in live_state_plan.shapes:
+                            continue
+                    index = current_index_factory(
+                        particle_id=particle_id,
+                        external_mask=1 << (leg.label - 1),
+                        external_labels=(leg.label,),
+                        ordered_external_labels=(leg.label,),
+                        helicity_ancestry=helicity_ancestry,
+                        chirality=chirality,
+                        spin_state=spin_state,
+                        flavour_flow=(particle_id,),
+                        quantum_number_flow=(
+                            source_quantum_flow
+                            if source_quantum_flow is not None
+                            else self.model.quantum_number_flow(particle_id)
+                        ),
+                        color_state=color_state,
+                        momentum_mask=1 << (leg.label - 1),
+                        coupling_orders=(),
+                        auxiliary_kind=(
+                            source_auxiliary_kind
+                            if live_state_plan is not None
+                            else self.model.auxiliary_kind(particle_id)
+                        ),
+                    )
+                    current = table.add_or_get(
+                        index,
+                        is_source=True,
+                        source_leg_label=leg.label,
+                        source_helicity=source_helicity,
+                    )
+                    sources.append(current.id)
+        return sources
+
+    def _eager_global_helicity_flip_anchor(
+        self,
+        process_ir: CanonicalProcessIR,
+    ) -> tuple[int, int] | None:
+        """Return one safely fixed source helicity for eager parity pairing.
+
+        Eager mode can avoid constructing both members of a global-helicity-
+        flip pair when the same model proof used by the structural post-pass is
+        available before recursion. The proof inventory is conservative: it
+        includes every non-ignored model vertex admitted by the requested
+        coupling-order limits, not only vertices expected for this process.
+        """
+
+        if (
+            not self.online_evaluation_reuse
+            or self.selected_source_helicities
+            or process_ir.color_accuracy not in {"lc", "nlc", "full"}
+        ):
+            return None
+
+        has_fundamental = False
+        for leg in process_ir.legs:
+            if leg.outgoing_pdg is None:
+                return None
+            particle_id = int(leg.outgoing_pdg)
+            is_fundamental = self.model.is_fundamental_colored_fermion(particle_id)
+            if not (
+                is_fundamental or self.model.is_massless_adjoint_vector(particle_id)
+            ):
+                return None
+            if self.model.mass(particle_id) != 0.0:
+                return None
+            has_fundamental = has_fundamental or is_fundamental
+        # Pure-adjoint trees also use the stronger all-equal/one-opposite zero
+        # theorem. Leave them to the existing combined proof pass for now.
+        if not has_fundamental:
+            return None
+
+        proof_vertices = tuple(
+            vertex
+            for vertex in self.model.vertices
+            if vertex.kind not in self.ignored_vertex_kinds
+            and not any(
+                particle_id in self.ignored_particle_ids
+                for particle_id in vertex.particles
+            )
+            and _coupling_orders_within_limits(
+                self.model.vertex_coupling_orders(vertex),
+                self.max_coupling_orders,
+            )
+        )
+        if (
+            not proof_vertices
+            or not self.model.global_helicity_flip_equivalence_is_proven(proof_vertices)
+        ):
+            return None
+
+        for leg in process_ir.legs:
+            assert leg.outgoing_pdg is not None
+            source_ir = self.model._source_ir(int(leg.outgoing_pdg))
+            helicities = sorted(
+                {
+                    int(
+                        (
+                            source_ir.crossing.apply(state) if leg.is_initial else state
+                        ).helicity
+                    )
+                    for state in source_ir.states
+                }
+            )
+            if (
+                len(helicities) == 2
+                and helicities[0] != 0
+                and helicities[0] == -helicities[1]
+            ):
+                return int(leg.label), helicities[0]
+        return None
+
+    def _build_amplitude_roots(
+        self,
+        process_ir: CanonicalProcessIR,
+        table: _CurrentTable,
+        color_engine: ColorEngine,
+        *,
+        candidate_splits: tuple[tuple[int, int], ...] | None = None,
+    ) -> list[AmplitudeRoot]:
+        full_mask = _labels_mask(leg.label for leg in process_ir.legs)
+        if candidate_splits is None:
+            candidate_splits = _closure_candidate_splits(
+                process_ir,
+                self.model,
+                color_engine,
+            )
+        roots: list[AmplitudeRoot] = []
+        seen: set[tuple[object, ...]] = set()
+        right_ids_by_mask_sector: dict[tuple[int, int], tuple[int, ...]] = {}
+        eager_color_flows: dict[
+            tuple[
+                tuple[int, ...],
+                tuple[int, ...],
+                ColorState,
+                ColorState,
+            ],
+            tuple[ColorFlow, ...],
+        ] = {}
+        eager_direct_contractions: dict[
+            tuple[int, int, int, int],
+            ContractionIR | None,
+        ] = {}
+        eager_vertices: dict[tuple[int, int], tuple[Vertex, ...]] = {}
+        eager_vertex_allowed: dict[Vertex, bool] = {}
+        eager_vertex_closure_allowed: dict[Vertex, bool] = {}
+        eager_vertex_orders: dict[
+            tuple[CouplingOrders, CouplingOrders, Vertex],
+            CouplingOrders,
+        ] = {}
+        eager_vertex_quantum_flows: dict[
+            tuple[object, ...],
+            tuple[QuantumFlow, ...],
+        ] = {}
+        eager_closure_contractions: dict[int, ContractionIR | None] = {}
+        eager_vertex_color_weights: dict[Vertex, tuple[float, float]] = {}
+
+        def closure_color_flows(
+            left: CurrentNode,
+            right: CurrentNode,
+        ) -> tuple[ColorFlow, ...]:
+            if not self.online_evaluation_reuse:
+                if not color_engine.ordered_closure_allowed(left.index, right.index):
+                    return ()
+                if color_engine.shared_single_trace:
+                    return color_engine.shared_single_trace_closure_flows(
+                        left.index,
+                        right.index,
+                    )
+                if color_engine.shared_lc_orderings:
+                    return color_engine.shared_lc_closure_flows(
+                        left.index,
+                        right.index,
+                    )
+                return color_engine.closure_compatible(
+                    left.index.color_state,
+                    right.index.color_state,
+                    full_mask=full_mask,
+                )
+            key = (
+                left.index.ordered_external_labels,
+                right.index.ordered_external_labels,
+                left.index.color_state,
+                right.index.color_state,
+            )
+            cached = eager_color_flows.get(key)
+            if cached is not None:
+                return cached
+            if color_engine.shared_single_trace:
+                resolved = color_engine.shared_single_trace_closure_flows(
+                    left.index,
+                    right.index,
+                )
+            elif color_engine.shared_lc_orderings:
+                resolved = color_engine.shared_lc_closure_flows(
+                    left.index,
+                    right.index,
+                )
+            elif color_engine.ordered_closure_allowed(left.index, right.index):
+                resolved = color_engine.closure_compatible(
+                    left.index.color_state,
+                    right.index.color_state,
+                    full_mask=full_mask,
+                )
+            else:
+                resolved = ()
+            eager_color_flows[key] = resolved
+            return resolved
+
+        def direct_contraction(
+            left: CurrentNode,
+            right: CurrentNode,
+        ) -> ContractionIR | None:
+            if not self.online_evaluation_reuse:
+                return _direct_contraction_ir(self.model, left.index, right.index)
+            key = (
+                left.index.particle_id,
+                right.index.particle_id,
+                left.index.chirality,
+                right.index.chirality,
+            )
+            if key not in eager_direct_contractions:
+                eager_direct_contractions[key] = _direct_contraction_ir(
+                    self.model,
+                    left.index,
+                    right.index,
+                )
+            return eager_direct_contractions[key]
+
+        def closure_right_ids(
+            right_mask: int,
+            left: CurrentNode,
+        ) -> Sequence[int]:
+            if (
+                not self.online_evaluation_reuse
+                or color_engine.shared_single_trace
+                or color_engine.shared_lc_orderings
+            ):
+                return table.ids_by_mask(right_mask)
+            key = (right_mask, left.index.color_state.sector_id)
+            cached = right_ids_by_mask_sector.get(key)
+            if cached is None:
+                sector_id = key[1]
+                cached = tuple(
+                    current_id
+                    for current_id in table.ids_by_mask(right_mask)
+                    if table.current(current_id).index.color_state.sector_id
+                    == sector_id
+                )
+                right_ids_by_mask_sector[key] = cached
+            return cached
+
+        def closure_vertices(
+            left: CurrentNode,
+            right: CurrentNode,
+        ) -> tuple[Vertex, ...]:
+            key = (left.index.particle_id, right.index.particle_id)
+            if not self.online_evaluation_reuse:
+                return self.model.vertices_accepting(
+                    *key,
+                    color_accuracy=process_ir.color_accuracy,
+                )
+            cached = eager_vertices.get(key)
+            if cached is None:
+                cached = self.model.vertices_accepting(
+                    *key,
+                    color_accuracy=process_ir.color_accuracy,
+                )
+                eager_vertices[key] = cached
+            return cached
+
+        def closure_vertex_allowed(vertex: Vertex) -> bool:
+            if not self.online_evaluation_reuse:
+                return color_engine.vertex_allowed(vertex)
+            cached = eager_vertex_allowed.get(vertex)
+            if cached is None:
+                cached = color_engine.vertex_allowed(vertex)
+                eager_vertex_allowed[vertex] = cached
+            return cached
+
+        def model_vertex_closure_allowed(vertex: Vertex) -> bool:
+            if not self.online_evaluation_reuse:
+                return self.model.vertex_closure_allowed(vertex)
+            cached = eager_vertex_closure_allowed.get(vertex)
+            if cached is None:
+                cached = self.model.vertex_closure_allowed(vertex)
+                eager_vertex_closure_allowed[vertex] = cached
+            return cached
+
+        def closure_coupling_orders(
+            left: CurrentNode,
+            right: CurrentNode,
+            vertex: Vertex,
+        ) -> CouplingOrders:
+            if not self.online_evaluation_reuse:
+                return self.model.combine_coupling_orders(
+                    left.index,
+                    right.index,
+                    vertex,
+                )
+            key = (
+                left.index.coupling_orders,
+                right.index.coupling_orders,
+                vertex,
+            )
+            cached = eager_vertex_orders.get(key)
+            if cached is None:
+                cached = self.model.combine_coupling_orders(
+                    left.index,
+                    right.index,
+                    vertex,
+                )
+                eager_vertex_orders[key] = cached
+            return cached
+
+        def closure_quantum_flows(
+            left: CurrentNode,
+            right: CurrentNode,
+            vertex: Vertex,
+        ) -> tuple[QuantumFlow, ...]:
+            if not self.online_evaluation_reuse:
+                return self.model.allowed_quantum_flows(
+                    vertex,
+                    left.index,
+                    right.index,
+                )
+            key = (
+                vertex,
+                left.index.particle_id,
+                left.index.chirality,
+                left.index.spin_state,
+                left.index.flavour_flow,
+                left.index.quantum_number_flow,
+                right.index.particle_id,
+                right.index.chirality,
+                right.index.spin_state,
+                right.index.flavour_flow,
+                right.index.quantum_number_flow,
+            )
+            cached = eager_vertex_quantum_flows.get(key)
+            if cached is None:
+                cached = self.model.allowed_quantum_flows(
+                    vertex,
+                    left.index,
+                    right.index,
+                )
+                eager_vertex_quantum_flows[key] = cached
+            return cached
+
+        def closure_contraction(vertex: Vertex) -> ContractionIR | None:
+            particle_id = vertex.particles[2]
+            if not self.online_evaluation_reuse:
+                return self.model.closure_contraction_ir(particle_id)
+            if particle_id not in eager_closure_contractions:
+                eager_closure_contractions[particle_id] = (
+                    self.model.closure_contraction_ir(particle_id)
+                )
+            return eager_closure_contractions[particle_id]
+
+        def closure_vertex_color_weight(vertex: Vertex) -> tuple[float, float]:
+            if not self.online_evaluation_reuse:
+                return self.model.vertex_color_weight(
+                    vertex,
+                    color_accuracy=process_ir.color_accuracy,
+                )
+            cached = eager_vertex_color_weights.get(vertex)
+            if cached is None:
+                cached = self.model.vertex_color_weight(
+                    vertex,
+                    color_accuracy=process_ir.color_accuracy,
+                )
+                eager_vertex_color_weights[vertex] = cached
+            return cached
+
+        for left_mask, right_mask in candidate_splits:
+            if left_mask == 0 or right_mask == 0:
+                continue
+            for left_id in table.ids_by_mask(left_mask):
+                left = table.current(left_id)
+                for right_id in closure_right_ids(right_mask, left):
+                    right = table.current(right_id)
+                    if left.index.overlaps(right.index):
+                        continue
+                    color_flows = closure_color_flows(left, right)
+                    if not color_flows:
+                        continue
+                    if (
+                        self.reference_color_order is not None
+                        and process_ir.color_accuracy == "lc"
+                    ):
+                        sector = color_engine.color_plan.sector(
+                            left.index.color_state.sector_id
+                        )
+                        if sector is not None and (
+                            self.reference_color_order
+                            in sector.admissible_traversal_words
+                        ):
+                            closure_word = sector.canonical_closure_traversal_word(
+                                process_ir
+                            )
+                            if not _closure_combination_matches_word(
+                                _labels_projected_to_word(
+                                    left.index.ordered_external_labels,
+                                    closure_word,
+                                ),
+                                _labels_projected_to_word(
+                                    right.index.ordered_external_labels,
+                                    closure_word,
+                                ),
+                                closure_word,
+                            ):
+                                continue
+                    direct_contraction_ir = direct_contraction(left, right)
+                    for color_flow in color_flows:
+                        if direct_contraction_ir is not None:
+                            direct_key: tuple[object, ...] = (
+                                "direct",
+                                direct_contraction_ir,
+                                left_id,
+                                right_id,
+                                color_flow.state,
+                            )
+                            if direct_key not in seen:
+                                seen.add(direct_key)
+                                roots.append(
+                                    AmplitudeRoot(
+                                        id=len(roots),
+                                        kind="direct-contraction",
+                                        left_id=left_id,
+                                        right_id=right_id,
+                                        color_weight=color_flow.weight,
+                                        contraction_ir=direct_contraction_ir,
+                                        color_sector_id=color_flow.state.sector_id,
+                                    )
+                                )
+                        for vertex in closure_vertices(left, right):
+                            if (
+                                vertex.kind in self.ignored_vertex_kinds
+                                or vertex.particles[2] in self.ignored_particle_ids
+                            ):
+                                continue
+                            if not closure_vertex_allowed(vertex):
+                                continue
+                            if not model_vertex_closure_allowed(vertex):
+                                continue
+                            coupling_orders = closure_coupling_orders(
+                                left,
+                                right,
+                                vertex,
+                            )
+                            if not _coupling_orders_within_limits(
+                                coupling_orders,
+                                self.max_coupling_orders,
+                            ):
+                                continue
+                            closure_contraction_ir = closure_contraction(vertex)
+                            if closure_contraction_ir is None:
+                                continue
+                            quantum_flows = closure_quantum_flows(
+                                left,
+                                right,
+                                vertex,
+                            )
+                            if not quantum_flows:
+                                continue
+                            vertex_key: tuple[object, ...] = (
+                                "vertex",
+                                vertex.kind,
+                                vertex.particles,
+                                left_id,
+                                right_id,
+                                color_flow.state,
+                            )
+                            if vertex_key in seen:
+                                continue
+                            seen.add(vertex_key)
+                            roots.append(
+                                AmplitudeRoot(
+                                    id=len(roots),
+                                    kind="vertex-closure",
+                                    left_id=left_id,
+                                    right_id=right_id,
+                                    color_weight=_complex_weight_mul(
+                                        color_flow.weight,
+                                        closure_vertex_color_weight(vertex),
+                                    ),
+                                    contraction_ir=closure_contraction_ir,
+                                    color_sector_id=color_flow.state.sector_id,
+                                    vertex_kind=vertex.kind,
+                                    vertex_particles=vertex.particles,
+                                    coupling=vertex.coupling,
+                                )
+                            )
+        return roots
+
+
+def compile_generic_dag(
+    process: CanonicalProcessIR,
+    *,
+    model: Model,
+    color_plan: GenericColorPlan | None = None,
+    max_currents: int | None = None,
+    max_color_sectors: int | None = None,
+    reference_color_order: tuple[int, ...] | None = None,
+    selected_color_sector_ids: Iterable[int] | None = None,
+    max_coupling_orders: Mapping[str, int] | None = None,
+    max_lc_current_line_groups: int | None = None,
+    max_quark_pairs: int | None = None,
+    closure_side_mask_pruning: bool = True,
+    color_order_mask_pruning: bool = True,
+    species_reachability_pruning: bool = True,
+    ignored_particle_ids: Iterable[int] | None = None,
+    ignored_vertex_kinds: Iterable[int] | None = None,
+    selected_source_helicities: Mapping[int, int] | None = None,
+    lc_all_ordering_symmetry: bool = True,
+    online_evaluation_reuse: bool = False,
+    backward_live_planning: bool = False,
+    progress_callback: DAGProgressCallback | None = None,
+) -> GenericDAG:
+    return GenericDAGCompiler(
+        model=model,
+        color_plan=color_plan,
+        max_currents=max_currents,
+        max_color_sectors=max_color_sectors,
+        reference_color_order=reference_color_order,
+        selected_color_sector_ids=selected_color_sector_ids,
+        max_coupling_orders=max_coupling_orders,
+        max_lc_current_line_groups=max_lc_current_line_groups,
+        max_quark_pairs=max_quark_pairs,
+        closure_side_mask_pruning=closure_side_mask_pruning,
+        color_order_mask_pruning=color_order_mask_pruning,
+        species_reachability_pruning=species_reachability_pruning,
+        ignored_particle_ids=ignored_particle_ids,
+        ignored_vertex_kinds=ignored_vertex_kinds,
+        selected_source_helicities=selected_source_helicities,
+        lc_all_ordering_symmetry=lc_all_ordering_symmetry,
+        online_evaluation_reuse=online_evaluation_reuse,
+        backward_live_planning=backward_live_planning,
+        progress_callback=progress_callback,
+    ).compile(process)
diff --git a/pyamplicol/src/pyamplicol/generation/dag_equivalence.py b/pyamplicol/src/pyamplicol/generation/dag_equivalence.py
new file mode 100644
index 0000000000..c673b8738e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/dag_equivalence.py
@@ -0,0 +1,5691 @@
+# SPDX-License-Identifier: 0BSD
+"""Proof-gated recursive current-value reuse for generated DAGs.
+
+Current identity includes colour-sector and ordering metadata needed to build
+and reduce amplitudes.  Those fields do not necessarily change the numerical
+current value.  This module proves such value equivalences from the complete
+recursive computation instead of guessing them from particle names or PDGs.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections import defaultdict
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass, replace
+from decimal import ROUND_HALF_EVEN, Decimal, localcontext
+from fractions import Fraction
+from math import copysign, fsum, isfinite
+from typing import Literal, TypeAlias
+
+from ..models.base import Model, VertexEvaluationEquivalence
+from .contracts import runtime_coupling_parameter_names
+from .dag_types import AmplitudeRoot, CurrentNode, GenericDAG, InteractionNode
+from .numerical_candidate_index import (
+    NumericalObservationCandidateIndex,
+    build_numerical_observation_candidate_index,
+    numerical_observation_tolerance_window_ids,
+)
+
+_ComplexWeight: TypeAlias = tuple[float, float]
+_CurrentContract: TypeAlias = tuple[object, ...]
+_EvaluationKey: TypeAlias = tuple[object, ...]
+_CurrentTermVector: TypeAlias = tuple[tuple[_EvaluationKey, _ComplexWeight], ...]
+_DiscoveryMode: TypeAlias = Literal["diagnostic", "certified-reuse"]
+
+RELATION_DISCOVERY_SCHEMA_VERSION = 1
+RELATION_DISCOVERY_CERTIFICATE_ALGORITHM = "exact-binary64-term-vector-replay-v1"
+NUMERICAL_CURRENT_RELATION_CERTIFICATE_ALGORITHM = (
+    "authenticated-independent-recursive-decimal-probes-v1"
+)
+GENERIC_DAG_NUMERICAL_SOURCE_SEMANTICS_ABI = (
+    "pyamplicol-generic-dag-numerical-current-source-v1"
+)
+NUMERICAL_CURRENT_RELATION_SET_ABI = (
+    "pyamplicol-authenticated-numerical-current-relation-set-v1"
+)
+NUMERICAL_CURRENT_CAPTURE_ABI = (
+    "pyamplicol-generic-dag-current-observation-capture-v2"
+)
+NUMERICAL_CURRENT_CAPTURE_OUTPUT_PARTITION_ABI = (
+    "pyamplicol-generic-dag-current-id-output-partitions-v1"
+)
+NUMERICAL_CURRENT_RELATION_WARNING_CODE = (
+    "proofless-numerical-current-relations-applied-v1"
+)
+NUMERICAL_CURRENT_RELATION_WARNING = (
+    "applied authenticated numerical equal/opposite/zero current reuse "
+    "without an exact structural proof; disable with "
+    "--no-numerical-current-reuse"
+)
+_MAX_REJECTED_DIAGNOSTICS = 16
+_NUMERICAL_DECIMAL_GUARD_DIGITS = 16
+
+
+def _is_negative_zero(value: float) -> bool:
+    return value == 0.0 and copysign(1.0, value) < 0.0
+
+
+def _rejected_candidate_diagnostics(
+    rows: Sequence[Mapping[str, object]],
+    *,
+    total_rejected: int,
+    full_census: Mapping[str, object],
+    full_rejection_sha256: str,
+) -> dict[str, object]:
+    retained = [dict(row) for row in rows]
+    return {
+        "total_rejected_hypothesis_count": total_rejected,
+        "retained_count": len(retained),
+        "truncated": total_rejected > len(retained),
+        "truncation_policy": (
+            f"first-{_MAX_REJECTED_DIAGNOSTICS}-in-canonical-discovery-order-v1"
+        ),
+        "retained_sha256": _canonical_payload_sha256(
+            {
+                "abi": "pyamplicol-rejected-relation-diagnostics-v1",
+                "rows": retained,
+            }
+        ),
+        "full_census_sha256": _canonical_payload_sha256(
+            {
+                "abi": "pyamplicol-relation-discovery-full-census-v1",
+                **dict(full_census),
+            }
+        ),
+        "full_rejection_sha256": full_rejection_sha256,
+    }
+
+
+def _advance_rejection_digest(previous: str, row: Mapping[str, object]) -> str:
+    encoded = json.dumps(
+        dict(row),
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(bytes.fromhex(previous) + encoded).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class _CurrentValueEquivalence:
+    """Exact relation ``current = factor * representative``."""
+
+    representative_id: int
+    factor: _ComplexWeight
+
+
+@dataclass(frozen=True, slots=True)
+class _CanonicalProjectiveTermVector:
+    """A deterministic lookup key and its concrete normalization factor."""
+
+    term_vector: _CurrentTermVector
+    factor: _ComplexWeight
+
+
+@dataclass(frozen=True, slots=True)
+class _ProjectiveExpressionRepresentative:
+    """One concrete current retained as a projective-class representative."""
+
+    representative_id: int
+    term_vector: _CurrentTermVector
+    normalization_factor: _ComplexWeight
+
+
+@dataclass(frozen=True, slots=True)
+class DynamicColorProjectionCertificate:
+    """Fail-closed proof summary for one multilinear color projection.
+
+    The projection removes only ``CurrentIndex.color_state.sector_id``.
+    Accuracy, line groups, basis keys, every non-colour current field, and the
+    complete downstream physical-selector domain remain part of the class
+    key.  A projected kernel or closure row is emitted only when the old
+    ordered parent tuples are exactly the full Cartesian product of the
+    corresponding member classes, with no duplicate tuple.
+    """
+
+    abi: str
+    source_revision: str | None
+    source_semantics_sha256: str
+    selector_domains_sha256: str
+    current_class_members_sha256: str
+    old_to_new_current_ids: tuple[int, ...]
+    current_remap_sha256: str
+    interaction_groups_sha256: str
+    closure_groups_sha256: str
+    rectangle_cardinalities_sha256: str
+    row_identity_sha256: str
+    equality_check_status: str
+    retained_color_metadata: str
+    root_sector_policy: str
+    before_current_count: int
+    after_current_count: int
+    before_interaction_count: int
+    after_interaction_count: int
+    before_evaluation_count: int
+    after_evaluation_count: int
+    before_amplitude_root_count: int
+    after_amplitude_root_count: int
+    projected_current_class_count: int
+    rectangular_interaction_group_count: int
+    rectangular_closure_group_count: int
+    split_current_class_count: int
+
+    @property
+    def applied(self) -> bool:
+        return (
+            self.after_current_count < self.before_current_count
+            or self.after_interaction_count < self.before_interaction_count
+            or self.after_amplitude_root_count < self.before_amplitude_root_count
+        )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "abi": self.abi,
+            "source_revision": self.source_revision,
+            "source_semantics_sha256": self.source_semantics_sha256,
+            "selector_domains_sha256": self.selector_domains_sha256,
+            "current_class_members_sha256": self.current_class_members_sha256,
+            "old_to_new_current_ids": list(self.old_to_new_current_ids),
+            "current_remap_sha256": self.current_remap_sha256,
+            "interaction_groups_sha256": self.interaction_groups_sha256,
+            "closure_groups_sha256": self.closure_groups_sha256,
+            "rectangle_cardinalities_sha256": (
+                self.rectangle_cardinalities_sha256
+            ),
+            "row_identity_sha256": self.row_identity_sha256,
+            "equality_check_status": self.equality_check_status,
+            "retained_color_metadata": self.retained_color_metadata,
+            "root_sector_policy": self.root_sector_policy,
+            "applied": self.applied,
+            "before_current_count": self.before_current_count,
+            "after_current_count": self.after_current_count,
+            "before_interaction_count": self.before_interaction_count,
+            "after_interaction_count": self.after_interaction_count,
+            "before_evaluation_count": self.before_evaluation_count,
+            "after_evaluation_count": self.after_evaluation_count,
+            "before_amplitude_root_count": self.before_amplitude_root_count,
+            "after_amplitude_root_count": self.after_amplitude_root_count,
+            "projected_current_class_count": self.projected_current_class_count,
+            "rectangular_interaction_group_count": (
+                self.rectangular_interaction_group_count
+            ),
+            "rectangular_closure_group_count": self.rectangular_closure_group_count,
+            "split_current_class_count": self.split_current_class_count,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ExactCurrentRelationCertificate:
+    """Replayable proof that one concrete current is an exact multiple."""
+
+    current_id: int
+    representative_id: int
+    factor: _ComplexWeight
+    current_term_vector_sha256: str
+    representative_term_vector_sha256: str
+    proof_sha256: str
+    algorithm: str = RELATION_DISCOVERY_CERTIFICATE_ALGORITHM
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "algorithm": self.algorithm,
+            "current_id": self.current_id,
+            "representative_id": self.representative_id,
+            "factor_binary64": [self.factor[0].hex(), self.factor[1].hex()],
+            "current_term_vector_sha256": self.current_term_vector_sha256,
+            "representative_term_vector_sha256": (
+                self.representative_term_vector_sha256
+            ),
+            "proof_sha256": self.proof_sha256,
+        }
+
+    @classmethod
+    def from_json_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> ExactCurrentRelationCertificate:
+        """Decode the exact representation emitted into generation metadata."""
+
+        expected_fields = {
+            "algorithm",
+            "current_id",
+            "representative_id",
+            "factor_binary64",
+            "current_term_vector_sha256",
+            "representative_term_vector_sha256",
+            "proof_sha256",
+        }
+        if set(payload) != expected_fields:
+            raise ValueError("relation certificate fields are not canonical")
+        try:
+            algorithm = payload["algorithm"]
+            current_id = payload["current_id"]
+            representative_id = payload["representative_id"]
+            raw_factor = payload["factor_binary64"]
+            current_digest = payload["current_term_vector_sha256"]
+            representative_digest = payload["representative_term_vector_sha256"]
+            proof_digest = payload["proof_sha256"]
+        except KeyError as error:
+            raise ValueError(
+                f"relation certificate is missing {error.args[0]!r}"
+            ) from error
+        if algorithm != RELATION_DISCOVERY_CERTIFICATE_ALGORITHM:
+            raise ValueError("relation certificate uses an unsupported algorithm")
+        if (
+            type(current_id) is not int
+            or type(representative_id) is not int
+            or current_id < 0
+            or representative_id < 0
+        ):
+            raise ValueError("relation certificate current IDs must be nonnegative")
+        if (
+            not isinstance(raw_factor, list)
+            or len(raw_factor) != 2
+            or any(not isinstance(component, str) for component in raw_factor)
+        ):
+            raise ValueError(
+                "relation certificate factor must contain two binary64 hex strings"
+            )
+        try:
+            factor = (float.fromhex(raw_factor[0]), float.fromhex(raw_factor[1]))
+        except ValueError as error:
+            raise ValueError(
+                "relation certificate factor has invalid binary64 encoding"
+            ) from error
+        if not _complex_weight_is_finite(factor) or factor == (0.0, 0.0):
+            raise ValueError("relation certificate factor must be finite and nonzero")
+        digests = (current_digest, representative_digest, proof_digest)
+        if any(
+            not isinstance(digest, str)
+            or len(digest) != 64
+            or any(character not in "0123456789abcdef" for character in digest)
+            for digest in digests
+        ):
+            raise ValueError("relation certificate digests must be lowercase SHA-256")
+        assert isinstance(current_digest, str)
+        assert isinstance(representative_digest, str)
+        assert isinstance(proof_digest, str)
+        certificate = cls(
+            current_id=current_id,
+            representative_id=representative_id,
+            factor=factor,
+            current_term_vector_sha256=current_digest,
+            representative_term_vector_sha256=representative_digest,
+            proof_sha256=proof_digest,
+        )
+        if (
+            _certificate_proof_sha256(
+                current_id=certificate.current_id,
+                representative_id=certificate.representative_id,
+                factor=certificate.factor,
+                current_term_vector_sha256=(certificate.current_term_vector_sha256),
+                representative_term_vector_sha256=(
+                    certificate.representative_term_vector_sha256
+                ),
+            )
+            != certificate.proof_sha256
+        ):
+            raise ValueError("relation certificate proof digest does not replay")
+        return certificate
+
+
+@dataclass(frozen=True, slots=True)
+class NumericalCurrentRelationCertificate:
+    """Replayable evidence for one numerically certified current relation.
+
+    The certificate commits to two disjoint observation sets.  The raw current
+    values remain generation evidence; artifact loading validates this
+    canonical certificate and never reruns relation discovery.
+    """
+
+    current_id: int
+    representative_id: int | None
+    relation_kind: Literal["equal", "opposite", "zero"]
+    factor: _ComplexWeight | None
+    source_semantics_sha256: str
+    runtime_schema_sha256: str
+    source_dag_sha256: str
+    candidate_capture_sha256: str
+    verification_capture_sha256: str
+    candidate_observation_batch_sha256: str
+    verification_observation_batch_sha256: str
+    precision_digits: int
+    seed: int
+    relative_tolerance: float
+    absolute_tolerance: float
+    candidate_probe_count: int
+    verification_probe_count: int
+    current_dimension: int
+    candidate_maximum_absolute_residual: Decimal
+    candidate_maximum_relative_residual: Decimal
+    candidate_maximum_tolerance_ratio: Decimal
+    verification_maximum_absolute_residual: Decimal
+    verification_maximum_relative_residual: Decimal
+    verification_maximum_tolerance_ratio: Decimal
+    candidate_observations_sha256: str
+    verification_observations_sha256: str
+    probe_contract_sha256: str
+    proof_sha256: str
+    proof_kind: str = "authenticated-numerical"
+    algorithm: str = NUMERICAL_CURRENT_RELATION_CERTIFICATE_ALGORITHM
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "algorithm": self.algorithm,
+            "proof_kind": self.proof_kind,
+            "relation_kind": self.relation_kind,
+            "current_id": self.current_id,
+            "representative_id": self.representative_id,
+            "factor_binary64": (
+                None
+                if self.factor is None
+                else [self.factor[0].hex(), self.factor[1].hex()]
+            ),
+            "source_semantics_sha256": self.source_semantics_sha256,
+            "runtime_schema_sha256": self.runtime_schema_sha256,
+            "source_dag_sha256": self.source_dag_sha256,
+            "candidate_capture_sha256": self.candidate_capture_sha256,
+            "verification_capture_sha256": (
+                self.verification_capture_sha256
+            ),
+            "candidate_observation_batch_sha256": (
+                self.candidate_observation_batch_sha256
+            ),
+            "verification_observation_batch_sha256": (
+                self.verification_observation_batch_sha256
+            ),
+            "precision_digits": self.precision_digits,
+            "seed": self.seed,
+            "relative_tolerance_binary64": self.relative_tolerance.hex(),
+            "absolute_tolerance_binary64": self.absolute_tolerance.hex(),
+            "candidate_probe_count": self.candidate_probe_count,
+            "verification_probe_count": self.verification_probe_count,
+            "current_dimension": self.current_dimension,
+            "candidate_maximum_absolute_residual": (
+                _canonical_decimal_string(
+                    self.candidate_maximum_absolute_residual
+                )
+            ),
+            "candidate_maximum_relative_residual": (
+                _canonical_decimal_string(
+                    self.candidate_maximum_relative_residual
+                )
+            ),
+            "candidate_maximum_tolerance_ratio": (
+                _canonical_decimal_string(
+                    self.candidate_maximum_tolerance_ratio
+                )
+            ),
+            "verification_maximum_absolute_residual": (
+                _canonical_decimal_string(
+                    self.verification_maximum_absolute_residual
+                )
+            ),
+            "verification_maximum_relative_residual": (
+                _canonical_decimal_string(
+                    self.verification_maximum_relative_residual
+                )
+            ),
+            "verification_maximum_tolerance_ratio": (
+                _canonical_decimal_string(
+                    self.verification_maximum_tolerance_ratio
+                )
+            ),
+            "candidate_observations_sha256": (
+                self.candidate_observations_sha256
+            ),
+            "verification_observations_sha256": (
+                self.verification_observations_sha256
+            ),
+            "probe_contract_sha256": self.probe_contract_sha256,
+            "proof_sha256": self.proof_sha256,
+        }
+
+    @classmethod
+    def from_json_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> NumericalCurrentRelationCertificate:
+        expected_fields = {
+            "algorithm",
+            "proof_kind",
+            "relation_kind",
+            "current_id",
+            "representative_id",
+            "factor_binary64",
+            "source_semantics_sha256",
+            "runtime_schema_sha256",
+            "source_dag_sha256",
+            "candidate_capture_sha256",
+            "verification_capture_sha256",
+            "candidate_observation_batch_sha256",
+            "verification_observation_batch_sha256",
+            "precision_digits",
+            "seed",
+            "relative_tolerance_binary64",
+            "absolute_tolerance_binary64",
+            "candidate_probe_count",
+            "verification_probe_count",
+            "current_dimension",
+            "candidate_maximum_absolute_residual",
+            "candidate_maximum_relative_residual",
+            "candidate_maximum_tolerance_ratio",
+            "verification_maximum_absolute_residual",
+            "verification_maximum_relative_residual",
+            "verification_maximum_tolerance_ratio",
+            "candidate_observations_sha256",
+            "verification_observations_sha256",
+            "probe_contract_sha256",
+            "proof_sha256",
+        }
+        if set(payload) != expected_fields:
+            raise ValueError(
+                "numerical current relation certificate fields are not canonical"
+            )
+        algorithm = payload["algorithm"]
+        proof_kind = payload["proof_kind"]
+        relation_kind = payload["relation_kind"]
+        current_id = payload["current_id"]
+        representative_id = payload["representative_id"]
+        factor_payload = payload["factor_binary64"]
+        source_digest = payload["source_semantics_sha256"]
+        runtime_schema_digest = payload["runtime_schema_sha256"]
+        source_dag_digest = payload["source_dag_sha256"]
+        candidate_capture_digest = payload["candidate_capture_sha256"]
+        verification_capture_digest = payload[
+            "verification_capture_sha256"
+        ]
+        candidate_batch_digest = payload[
+            "candidate_observation_batch_sha256"
+        ]
+        verification_batch_digest = payload[
+            "verification_observation_batch_sha256"
+        ]
+        precision_digits = payload["precision_digits"]
+        seed = payload["seed"]
+        relative_payload = payload["relative_tolerance_binary64"]
+        absolute_payload = payload["absolute_tolerance_binary64"]
+        candidate_probe_count = payload["candidate_probe_count"]
+        verification_probe_count = payload["verification_probe_count"]
+        current_dimension = payload["current_dimension"]
+        if (
+            algorithm != NUMERICAL_CURRENT_RELATION_CERTIFICATE_ALGORITHM
+            or proof_kind != "authenticated-numerical"
+            or relation_kind not in {"equal", "opposite", "zero"}
+        ):
+            raise ValueError(
+                "numerical current relation certificate has unsupported policy"
+            )
+        if type(current_id) is not int or current_id < 0:
+            raise ValueError(
+                "numerical current relation current ID must be nonnegative"
+            )
+        if representative_id is not None and (
+            type(representative_id) is not int
+            or representative_id < 0
+            or representative_id >= current_id
+        ):
+            raise ValueError(
+                "numerical current relation representative must precede its current"
+            )
+        if (
+            type(precision_digits) is not int
+            or precision_digits < 80
+            or type(seed) is not int
+            or seed < 0
+            or type(candidate_probe_count) is not int
+            or candidate_probe_count < 2
+            or type(verification_probe_count) is not int
+            or verification_probe_count < 2
+            or type(current_dimension) is not int
+            or current_dimension < 1
+        ):
+            raise ValueError(
+                "numerical current relation probe contract is invalid"
+            )
+        if not isinstance(relative_payload, str) or not isinstance(
+            absolute_payload,
+            str,
+        ):
+            raise ValueError(
+                "numerical current relation tolerances must use binary64 hex"
+            )
+        try:
+            relative_tolerance = float.fromhex(relative_payload)
+            absolute_tolerance = float.fromhex(absolute_payload)
+        except ValueError as error:
+            raise ValueError(
+                "numerical current relation tolerance encoding is invalid"
+            ) from error
+        if (
+            not isfinite(relative_tolerance)
+            or not isfinite(absolute_tolerance)
+            or relative_tolerance < 0.0
+            or absolute_tolerance < 0.0
+            or _is_negative_zero(relative_tolerance)
+            or _is_negative_zero(absolute_tolerance)
+            or relative_payload != relative_tolerance.hex()
+            or absolute_payload != absolute_tolerance.hex()
+            or (relative_tolerance == 0.0 and absolute_tolerance == 0.0)
+        ):
+            raise ValueError(
+                "numerical current relation tolerances are invalid"
+            )
+        factor = _decode_numerical_relation_factor(
+            relation_kind,
+            representative_id,
+            factor_payload,
+        )
+        digest_fields = (
+            source_digest,
+            runtime_schema_digest,
+            source_dag_digest,
+            candidate_capture_digest,
+            verification_capture_digest,
+            candidate_batch_digest,
+            verification_batch_digest,
+            payload["candidate_observations_sha256"],
+            payload["verification_observations_sha256"],
+            payload["probe_contract_sha256"],
+            payload["proof_sha256"],
+        )
+        if any(not _is_sha256(value) for value in digest_fields):
+            raise ValueError(
+                "numerical current relation digests must be lowercase SHA-256"
+            )
+        decimal_field_names = (
+            "candidate_maximum_absolute_residual",
+            "candidate_maximum_relative_residual",
+            "candidate_maximum_tolerance_ratio",
+            "verification_maximum_absolute_residual",
+            "verification_maximum_relative_residual",
+            "verification_maximum_tolerance_ratio",
+        )
+        residuals: list[Decimal] = []
+        for field_name in decimal_field_names:
+            raw = payload[field_name]
+            if not isinstance(raw, str):
+                raise ValueError(
+                    "numerical current relation residuals must be decimal strings"
+                )
+            try:
+                residual = Decimal(raw)
+            except ArithmeticError as error:
+                raise ValueError(
+                    "numerical current relation residual encoding is invalid"
+                ) from error
+            if (
+                not residual.is_finite()
+                or residual < 0
+                or raw != _canonical_decimal_string(residual)
+            ):
+                raise ValueError(
+                    "numerical current relation residuals must be finite "
+                    "and nonnegative canonical decimal strings"
+                )
+            residuals.append(residual)
+        certificate = cls(
+            current_id=current_id,
+            representative_id=representative_id,
+            relation_kind=relation_kind,
+            factor=factor,
+            source_semantics_sha256=source_digest,
+            runtime_schema_sha256=str(runtime_schema_digest),
+            source_dag_sha256=str(source_dag_digest),
+            candidate_capture_sha256=str(candidate_capture_digest),
+            verification_capture_sha256=str(
+                verification_capture_digest
+            ),
+            candidate_observation_batch_sha256=str(
+                candidate_batch_digest
+            ),
+            verification_observation_batch_sha256=str(
+                verification_batch_digest
+            ),
+            precision_digits=precision_digits,
+            seed=seed,
+            relative_tolerance=relative_tolerance,
+            absolute_tolerance=absolute_tolerance,
+            candidate_probe_count=candidate_probe_count,
+            verification_probe_count=verification_probe_count,
+            current_dimension=current_dimension,
+            candidate_maximum_absolute_residual=residuals[0],
+            candidate_maximum_relative_residual=residuals[1],
+            candidate_maximum_tolerance_ratio=residuals[2],
+            verification_maximum_absolute_residual=residuals[3],
+            verification_maximum_relative_residual=residuals[4],
+            verification_maximum_tolerance_ratio=residuals[5],
+            candidate_observations_sha256=str(
+                payload["candidate_observations_sha256"]
+            ),
+            verification_observations_sha256=str(
+                payload["verification_observations_sha256"]
+            ),
+            probe_contract_sha256=str(payload["probe_contract_sha256"]),
+            proof_sha256=str(payload["proof_sha256"]),
+        )
+        if not verify_numerical_current_relation_certificate(
+            certificate,
+            source_semantics_sha256=source_digest,
+        ):
+            raise ValueError(
+                "numerical current relation certificate proof does not replay"
+            )
+        return certificate
+
+
+@dataclass(frozen=True, slots=True)
+class NumericalCurrentAppliedMapping:
+    """Execution mapping derived from one authenticated certificate."""
+
+    current_id: int
+    representative_id: int | None
+    execution_representative_id: int
+    relation_kind: Literal["equal", "opposite", "zero"]
+    factor: _ComplexWeight
+    certificate_proof_sha256: str
+    resolved_current_ids: tuple[int, ...]
+    projected_interaction_count: int
+    projected_interaction_ids_sha256: str
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "current_id": self.current_id,
+            "representative_id": self.representative_id,
+            "execution_representative_id": self.execution_representative_id,
+            "relation_kind": self.relation_kind,
+            "factor_binary64": [self.factor[0].hex(), self.factor[1].hex()],
+            "certificate_proof_sha256": self.certificate_proof_sha256,
+            "resolved_current_ids": list(self.resolved_current_ids),
+            "projected_interaction_count": self.projected_interaction_count,
+            "projected_interaction_ids_sha256": (
+                self.projected_interaction_ids_sha256
+            ),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class NumericalCurrentRelationApplicationReport:
+    """Manifest-ready replay result for one generic-DAG relation set."""
+
+    requested_mode: Literal["diagnostic", "certified-reuse"]
+    execution_mode: Literal["compiled", "eager"]
+    color_accuracy: str
+    source_semantics_sha256: str
+    runtime_schema_sha256: str | None
+    source_dag_sha256: str | None
+    candidate_capture_sha256: str | None
+    verification_capture_sha256: str | None
+    state: str
+    certificate_replay_status: str
+    certificate_set_sha256: str
+    certificates: tuple[NumericalCurrentRelationCertificate, ...]
+    mappings: tuple[NumericalCurrentAppliedMapping, ...]
+    interaction_evaluation_count_before: int
+    interaction_evaluation_count_projected: int
+    applied_relation_count: int
+
+    @property
+    def warning_required(self) -> bool:
+        return self.applied_relation_count > 0
+
+    def to_json_dict(self) -> dict[str, object]:
+        relation_kind_counts = {
+            relation_kind: sum(
+                certificate.relation_kind == relation_kind
+                for certificate in self.certificates
+            )
+            for relation_kind in ("equal", "opposite", "zero")
+        }
+        return {
+            "schema_version": 1,
+            "abi": NUMERICAL_CURRENT_RELATION_SET_ABI,
+            "requested_mode": self.requested_mode,
+            "state": self.state,
+            "scope": {
+                "execution_mode": self.execution_mode,
+                "color_accuracy": self.color_accuracy,
+                "representation": "generic-dag",
+            },
+            "source_semantics": {
+                "abi": GENERIC_DAG_NUMERICAL_SOURCE_SEMANTICS_ABI,
+                "sha256": self.source_semantics_sha256,
+            },
+            "runtime_schema_sha256": self.runtime_schema_sha256,
+            "source_dag_sha256": self.source_dag_sha256,
+            "candidate_capture_sha256": self.candidate_capture_sha256,
+            "verification_capture_sha256": (
+                self.verification_capture_sha256
+            ),
+            "certificate_replay": {
+                "algorithm": (
+                    NUMERICAL_CURRENT_RELATION_CERTIFICATE_ALGORITHM
+                ),
+                "status": self.certificate_replay_status,
+                "certificate_set_sha256": self.certificate_set_sha256,
+            },
+            "certified_relation_count": len(self.certificates),
+            "applied_relation_count": self.applied_relation_count,
+            "relation_kind_counts": relation_kind_counts,
+            "interaction_evaluation_count_before": (
+                self.interaction_evaluation_count_before
+            ),
+            "interaction_evaluation_count_projected": (
+                self.interaction_evaluation_count_projected
+            ),
+            "interaction_evaluation_savings_projected": max(
+                0,
+                self.interaction_evaluation_count_before
+                - self.interaction_evaluation_count_projected,
+            ),
+            "certificates": [
+                certificate.to_json_dict()
+                for certificate in self.certificates
+            ],
+            "mappings": [mapping.to_json_dict() for mapping in self.mappings],
+            "warning": (
+                {
+                    "required": True,
+                    "emit": "once-per-generated-artifact",
+                    "code": NUMERICAL_CURRENT_RELATION_WARNING_CODE,
+                    "message": NUMERICAL_CURRENT_RELATION_WARNING,
+                }
+                if self.warning_required
+                else {
+                    "required": False,
+                    "emit": "never",
+                    "code": None,
+                    "message": None,
+                }
+            ),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class NumericalCurrentRelationApplicationResult:
+    dag: GenericDAG
+    report: NumericalCurrentRelationApplicationReport
+
+
+@dataclass(frozen=True, slots=True)
+class NumericalCurrentObservationDiscoveryReport:
+    """Bounded warm-up evidence before any numerical mapping is applied."""
+
+    execution_mode: Literal["compiled", "eager"]
+    color_accuracy: str
+    source_semantics_sha256: str
+    runtime_schema_sha256: str
+    source_dag_sha256: str
+    precision_digits: int
+    seed: int
+    relative_tolerance: float
+    absolute_tolerance: float
+    candidate_point_sha256s: tuple[str, ...]
+    verification_point_sha256s: tuple[str, ...]
+    candidate_kinematic_sha256s: tuple[str, ...]
+    verification_kinematic_sha256s: tuple[str, ...]
+    candidate_parameter_context_sha256s: tuple[str, ...]
+    verification_parameter_context_sha256s: tuple[str, ...]
+    candidate_capture_sha256: str
+    verification_capture_sha256: str
+    candidate_observation_batch_sha256: str
+    verification_observation_batch_sha256: str
+    state: str
+    inspected_current_count: int
+    structurally_proven_current_count: int
+    tested_hypothesis_count: int
+    theoretical_pair_hypothesis_count: int
+    screened_pair_hypothesis_count: int
+    candidate_index_contract_count: int
+    exhaustive_fallback_contract_count: int
+    numerical_candidate_count: int
+    verification_rejected_count: int
+    rejected_hypothesis_count: int
+    rejected_decision_sha256: str
+    certificates: tuple[NumericalCurrentRelationCertificate, ...]
+    rejected_candidates: tuple[dict[str, object], ...]
+    nearest_rejected_hypothesis: dict[str, object] | None
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "schema_version": 1,
+            "state": self.state,
+            "scope": {
+                "execution_mode": self.execution_mode,
+                "color_accuracy": self.color_accuracy,
+                "representation": "generic-dag",
+            },
+            "source_semantics": {
+                "abi": GENERIC_DAG_NUMERICAL_SOURCE_SEMANTICS_ABI,
+                "sha256": self.source_semantics_sha256,
+            },
+            "runtime_schema_sha256": self.runtime_schema_sha256,
+            "source_dag_sha256": self.source_dag_sha256,
+            "probe_contract": {
+                "algorithm": (
+                    NUMERICAL_CURRENT_RELATION_CERTIFICATE_ALGORITHM
+                ),
+                "precision_digits": self.precision_digits,
+                "seed": self.seed,
+                "relative_tolerance_binary64": (
+                    self.relative_tolerance.hex()
+                ),
+                "absolute_tolerance_binary64": (
+                    self.absolute_tolerance.hex()
+                ),
+                "candidate_point_sha256s": list(
+                    self.candidate_point_sha256s
+                ),
+                "verification_point_sha256s": list(
+                    self.verification_point_sha256s
+                ),
+                "candidate_kinematic_sha256s": list(
+                    self.candidate_kinematic_sha256s
+                ),
+                "verification_kinematic_sha256s": list(
+                    self.verification_kinematic_sha256s
+                ),
+                "candidate_parameter_context_sha256s": list(
+                    self.candidate_parameter_context_sha256s
+                ),
+                "verification_parameter_context_sha256s": list(
+                    self.verification_parameter_context_sha256s
+                ),
+                "candidate_capture_sha256": (
+                    self.candidate_capture_sha256
+                ),
+                "verification_capture_sha256": (
+                    self.verification_capture_sha256
+                ),
+                "candidate_observation_batch_sha256": (
+                    self.candidate_observation_batch_sha256
+                ),
+                "verification_observation_batch_sha256": (
+                    self.verification_observation_batch_sha256
+                ),
+                "deterministic": True,
+                "independent_verification": True,
+            },
+            "inspected_current_count": self.inspected_current_count,
+            "structurally_proven_current_count": (
+                self.structurally_proven_current_count
+            ),
+            "tested_hypothesis_count": self.tested_hypothesis_count,
+            "candidate_index": {
+                "algorithm": (
+                    "complete-contract-anchor-tolerance-window-v1"
+                ),
+                "completeness": "complete-within-configured-tolerance",
+                "contract_count": self.candidate_index_contract_count,
+                "exhaustive_fallback_contract_count": (
+                    self.exhaustive_fallback_contract_count
+                ),
+                "theoretical_pair_hypothesis_count": (
+                    self.theoretical_pair_hypothesis_count
+                ),
+                "screened_pair_hypothesis_count": (
+                    self.screened_pair_hypothesis_count
+                ),
+                "zero_hypothesis_count": (
+                    self.tested_hypothesis_count
+                    - self.screened_pair_hypothesis_count
+                ),
+                "nearest_rejected_scope": (
+                    "zero-and-tolerance-window-screened-hypotheses"
+                ),
+            },
+            "numerical_candidate_count": self.numerical_candidate_count,
+            "verification_rejected_count": self.verification_rejected_count,
+            "rejected_hypothesis_count": self.rejected_hypothesis_count,
+            "certified_numerical_relation_count": len(self.certificates),
+            "certificates": [
+                certificate.to_json_dict()
+                for certificate in self.certificates
+            ],
+            "rejected_candidates": list(self.rejected_candidates),
+            "rejected_candidate_diagnostics": (
+                _rejected_candidate_diagnostics(
+                    self.rejected_candidates,
+                    total_rejected=self.rejected_hypothesis_count,
+                    full_census={
+                        "candidate_capture_sha256": (
+                            self.candidate_capture_sha256
+                        ),
+                        "verification_capture_sha256": (
+                            self.verification_capture_sha256
+                        ),
+                        "tested_hypothesis_count": (
+                            self.tested_hypothesis_count
+                        ),
+                        "numerical_candidate_count": (
+                            self.numerical_candidate_count
+                        ),
+                        "verification_rejected_count": (
+                            self.verification_rejected_count
+                        ),
+                        "rejected_hypothesis_count": (
+                            self.rejected_hypothesis_count
+                        ),
+                        "certified_relation_count": len(self.certificates),
+                        "rejection_decision_sha256": (
+                            self.rejected_decision_sha256
+                        ),
+                    },
+                    full_rejection_sha256=self.rejected_decision_sha256,
+                )
+            ),
+            "nearest_rejected_hypothesis": (
+                self.nearest_rejected_hypothesis
+            ),
+            "warning": {
+                "required": False,
+                "reason": (
+                    "discovery alone never warns; the artifact aggregator "
+                    "warns once only when certified proof-less mappings are "
+                    "actually applied"
+                ),
+            },
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class NumericalCurrentObservationDiscoveryResult:
+    certificates: tuple[NumericalCurrentRelationCertificate, ...]
+    report: NumericalCurrentObservationDiscoveryReport
+    structural_equivalences: tuple[_CurrentValueEquivalence, ...]
+
+
+_NumericalObservationCandidateIndex = NumericalObservationCandidateIndex[Decimal]
+
+
+def _build_numerical_observation_candidate_index(
+    member_ids: Sequence[int],
+    observations: Mapping[int, tuple[tuple[Decimal, Decimal], ...]],
+) -> _NumericalObservationCandidateIndex:
+    return build_numerical_observation_candidate_index(
+        member_ids,
+        observations,
+        normalize=lambda value: value,
+    )
+
+
+def _numerical_observation_tolerance_window_ids(
+    index: _NumericalObservationCandidateIndex,
+    current_values: tuple[tuple[Decimal, Decimal], ...],
+    *,
+    relation_kind: Literal["equal", "opposite"],
+    current_id: int,
+    relative_tolerance: Decimal,
+    absolute_tolerance: Decimal,
+    precision_digits: int,
+) -> tuple[int, ...]:
+    """Use the shared sound window under the configured Decimal context."""
+
+    if type(precision_digits) is not int or precision_digits < 80:
+        raise ValueError("numerical candidate index precision is invalid")
+    with localcontext() as context:
+        context.prec = precision_digits + _NUMERICAL_DECIMAL_GUARD_DIGITS
+        context.rounding = ROUND_HALF_EVEN
+        return numerical_observation_tolerance_window_ids(
+            index,
+            current_values,
+            relation_kind=relation_kind,
+            current_id=current_id,
+            relative_tolerance=relative_tolerance,
+            absolute_tolerance=absolute_tolerance,
+            normalize=lambda value: value,
+        )
+
+
+def certify_numerical_current_observations(
+    *,
+    current_id: int,
+    representative_id: int | None,
+    relation_kind: Literal["equal", "opposite", "zero"],
+    source_semantics_sha256: str,
+    runtime_schema_sha256: str,
+    source_dag_sha256: str,
+    candidate_capture_sha256: str,
+    verification_capture_sha256: str,
+    candidate_observation_batch_sha256: str,
+    verification_observation_batch_sha256: str,
+    candidate_current_values: Sequence[tuple[Decimal, Decimal]],
+    candidate_representative_values: (
+        Sequence[tuple[Decimal, Decimal]] | None
+    ),
+    verification_current_values: Sequence[tuple[Decimal, Decimal]],
+    verification_representative_values: (
+        Sequence[tuple[Decimal, Decimal]] | None
+    ),
+    precision_digits: int,
+    seed: int,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+    candidate_probe_count: int | None = None,
+    verification_probe_count: int | None = None,
+) -> NumericalCurrentRelationCertificate | None:
+    """Certify one ±1/zero relation over independent Decimal observations.
+
+    Invalid, non-finite, forward, shape-inconsistent, or unstable hypotheses
+    fail closed by returning ``None``.
+    """
+
+    if (
+        relation_kind not in {"equal", "opposite", "zero"}
+        or type(current_id) is not int
+        or current_id < 0
+        or not _is_sha256(source_semantics_sha256)
+        or any(
+            not _is_sha256(value)
+            for value in (
+                runtime_schema_sha256,
+                source_dag_sha256,
+                candidate_capture_sha256,
+                verification_capture_sha256,
+                candidate_observation_batch_sha256,
+                verification_observation_batch_sha256,
+            )
+        )
+        or candidate_capture_sha256 == verification_capture_sha256
+        or candidate_observation_batch_sha256
+        == verification_observation_batch_sha256
+        or type(precision_digits) is not int
+        or precision_digits < 80
+        or type(seed) is not int
+        or seed < 0
+        or not isinstance(relative_tolerance, int | float)
+        or isinstance(relative_tolerance, bool)
+        or not isinstance(absolute_tolerance, int | float)
+        or isinstance(absolute_tolerance, bool)
+    ):
+        return None
+    relative = float(relative_tolerance)
+    absolute = float(absolute_tolerance)
+    if (
+        not isfinite(relative)
+        or not isfinite(absolute)
+        or relative < 0.0
+        or absolute < 0.0
+        or _is_negative_zero(relative)
+        or _is_negative_zero(absolute)
+        or (relative == 0.0 and absolute == 0.0)
+    ):
+        return None
+    candidate_current = _validated_decimal_observations(
+        candidate_current_values
+    )
+    verification_current = _validated_decimal_observations(
+        verification_current_values
+    )
+    if (
+        candidate_current is None
+        or verification_current is None
+        or len(candidate_current) < 2
+        or len(verification_current) < 2
+    ):
+        return None
+    resolved_candidate_probe_count = (
+        len(candidate_current)
+        if candidate_probe_count is None
+        else candidate_probe_count
+    )
+    resolved_verification_probe_count = (
+        len(verification_current)
+        if verification_probe_count is None
+        else verification_probe_count
+    )
+    if (
+        type(resolved_candidate_probe_count) is not int
+        or resolved_candidate_probe_count < 2
+        or type(resolved_verification_probe_count) is not int
+        or resolved_verification_probe_count < 2
+        or len(candidate_current) % resolved_candidate_probe_count != 0
+        or len(verification_current) % resolved_verification_probe_count != 0
+    ):
+        return None
+    current_dimension = (
+        len(candidate_current) // resolved_candidate_probe_count
+    )
+    if (
+        current_dimension < 1
+        or len(verification_current)
+        // resolved_verification_probe_count
+        != current_dimension
+    ):
+        return None
+    if relation_kind == "zero":
+        if (
+            representative_id is not None
+            or candidate_representative_values is not None
+            or verification_representative_values is not None
+        ):
+            return None
+        candidate_representative = None
+        verification_representative = None
+        factor = None
+    else:
+        if (
+            type(representative_id) is not int
+            or representative_id < 0
+            or representative_id >= current_id
+        ):
+            return None
+        candidate_representative = _validated_decimal_observations(
+            candidate_representative_values
+        )
+        verification_representative = _validated_decimal_observations(
+            verification_representative_values
+        )
+        if (
+            candidate_representative is None
+            or verification_representative is None
+            or len(candidate_representative) != len(candidate_current)
+            or len(verification_representative) != len(verification_current)
+        ):
+            return None
+        factor = (
+            (1.0, 0.0)
+            if relation_kind == "equal"
+            else (-1.0, 0.0)
+        )
+    absolute_decimal = Decimal.from_float(absolute)
+    relative_decimal = Decimal.from_float(relative)
+    candidate_residuals = _numerical_relation_residuals(
+        relation_kind,
+        candidate_current,
+        candidate_representative,
+        relative_tolerance=relative_decimal,
+        absolute_tolerance=absolute_decimal,
+        precision_digits=precision_digits,
+    )
+    verification_residuals = _numerical_relation_residuals(
+        relation_kind,
+        verification_current,
+        verification_representative,
+        relative_tolerance=relative_decimal,
+        absolute_tolerance=absolute_decimal,
+        precision_digits=precision_digits,
+    )
+    if candidate_residuals is None or verification_residuals is None:
+        return None
+    if not _numerical_relation_residuals_pass(
+        candidate_residuals,
+        precision_digits=precision_digits,
+    ) or not _numerical_relation_residuals_pass(
+        verification_residuals,
+        precision_digits=precision_digits,
+    ):
+        return None
+    candidate_digest = _numerical_observations_sha256(
+        relation_kind=relation_kind,
+        current_values=candidate_current,
+        representative_values=candidate_representative,
+    )
+    verification_digest = _numerical_observations_sha256(
+        relation_kind=relation_kind,
+        current_values=verification_current,
+        representative_values=verification_representative,
+    )
+    probe_contract = {
+        "algorithm": NUMERICAL_CURRENT_RELATION_CERTIFICATE_ALGORITHM,
+        "source_semantics_sha256": source_semantics_sha256,
+        "runtime_schema_sha256": runtime_schema_sha256,
+        "source_dag_sha256": source_dag_sha256,
+        "candidate_capture_sha256": candidate_capture_sha256,
+        "verification_capture_sha256": verification_capture_sha256,
+        "candidate_observation_batch_sha256": (
+            candidate_observation_batch_sha256
+        ),
+        "verification_observation_batch_sha256": (
+            verification_observation_batch_sha256
+        ),
+        "current_id": current_id,
+        "representative_id": representative_id,
+        "relation_kind": relation_kind,
+        "precision_digits": precision_digits,
+        "seed": seed,
+        "candidate_domain": "candidate-current-probes-v1",
+        "verification_domain": "independent-verification-current-probes-v1",
+        "relative_tolerance_binary64": relative.hex(),
+        "absolute_tolerance_binary64": absolute.hex(),
+        "candidate_probe_count": resolved_candidate_probe_count,
+        "verification_probe_count": resolved_verification_probe_count,
+        "current_dimension": current_dimension,
+        "candidate_observations_sha256": candidate_digest,
+        "verification_observations_sha256": verification_digest,
+    }
+    probe_contract_digest = _canonical_payload_sha256(probe_contract)
+    proof_payload = {
+        **probe_contract,
+        "proof_kind": "authenticated-numerical",
+        "factor_binary64": (
+            None
+            if factor is None
+            else [factor[0].hex(), factor[1].hex()]
+        ),
+        "candidate_maximum_absolute_residual": _canonical_decimal_string(
+            candidate_residuals[0]
+        ),
+        "candidate_maximum_relative_residual": _canonical_decimal_string(
+            candidate_residuals[1]
+        ),
+        "candidate_maximum_tolerance_ratio": _canonical_decimal_string(
+            candidate_residuals[2]
+        ),
+        "verification_maximum_absolute_residual": _canonical_decimal_string(
+            verification_residuals[0]
+        ),
+        "verification_maximum_relative_residual": _canonical_decimal_string(
+            verification_residuals[1]
+        ),
+        "verification_maximum_tolerance_ratio": _canonical_decimal_string(
+            verification_residuals[2]
+        ),
+        "probe_contract_sha256": probe_contract_digest,
+    }
+    return NumericalCurrentRelationCertificate(
+        current_id=current_id,
+        representative_id=representative_id,
+        relation_kind=relation_kind,
+        factor=factor,
+        source_semantics_sha256=source_semantics_sha256,
+        runtime_schema_sha256=runtime_schema_sha256,
+        source_dag_sha256=source_dag_sha256,
+        candidate_capture_sha256=candidate_capture_sha256,
+        verification_capture_sha256=verification_capture_sha256,
+        candidate_observation_batch_sha256=(
+            candidate_observation_batch_sha256
+        ),
+        verification_observation_batch_sha256=(
+            verification_observation_batch_sha256
+        ),
+        precision_digits=precision_digits,
+        seed=seed,
+        relative_tolerance=relative,
+        absolute_tolerance=absolute,
+        candidate_probe_count=resolved_candidate_probe_count,
+        verification_probe_count=resolved_verification_probe_count,
+        current_dimension=current_dimension,
+        candidate_maximum_absolute_residual=candidate_residuals[0],
+        candidate_maximum_relative_residual=candidate_residuals[1],
+        candidate_maximum_tolerance_ratio=candidate_residuals[2],
+        verification_maximum_absolute_residual=verification_residuals[0],
+        verification_maximum_relative_residual=verification_residuals[1],
+        verification_maximum_tolerance_ratio=verification_residuals[2],
+        candidate_observations_sha256=candidate_digest,
+        verification_observations_sha256=verification_digest,
+        probe_contract_sha256=probe_contract_digest,
+        proof_sha256=_canonical_payload_sha256(proof_payload),
+    )
+
+
+def verify_numerical_current_relation_certificate(
+    certificate: NumericalCurrentRelationCertificate,
+    *,
+    source_semantics_sha256: str,
+) -> bool:
+    """Validate canonical certificate integrity without rediscovery."""
+
+    if (
+        not isinstance(certificate, NumericalCurrentRelationCertificate)
+        or certificate.algorithm
+        != NUMERICAL_CURRENT_RELATION_CERTIFICATE_ALGORITHM
+        or certificate.proof_kind != "authenticated-numerical"
+        or certificate.source_semantics_sha256 != source_semantics_sha256
+        or not _is_sha256(source_semantics_sha256)
+    ):
+        return False
+    try:
+        factor = _decode_numerical_relation_factor(
+            certificate.relation_kind,
+            certificate.representative_id,
+            (
+                None
+                if certificate.factor is None
+                else [
+                    certificate.factor[0].hex(),
+                    certificate.factor[1].hex(),
+                ]
+            ),
+        )
+    except (TypeError, ValueError):
+        return False
+    if factor != certificate.factor:
+        return False
+    if (
+        type(certificate.current_id) is not int
+        or certificate.current_id < 0
+        or type(certificate.precision_digits) is not int
+        or certificate.precision_digits < 80
+        or type(certificate.seed) is not int
+        or certificate.seed < 0
+        or type(certificate.candidate_probe_count) is not int
+        or certificate.candidate_probe_count < 2
+        or type(certificate.verification_probe_count) is not int
+        or certificate.verification_probe_count < 2
+        or type(certificate.current_dimension) is not int
+        or certificate.current_dimension < 1
+        or not isfinite(certificate.relative_tolerance)
+        or not isfinite(certificate.absolute_tolerance)
+        or certificate.relative_tolerance < 0.0
+        or certificate.absolute_tolerance < 0.0
+        or _is_negative_zero(certificate.relative_tolerance)
+        or _is_negative_zero(certificate.absolute_tolerance)
+        or (
+            certificate.relative_tolerance == 0.0
+            and certificate.absolute_tolerance == 0.0
+        )
+        or any(
+            not _is_sha256(value)
+            for value in (
+                certificate.runtime_schema_sha256,
+                certificate.source_dag_sha256,
+                certificate.candidate_capture_sha256,
+                certificate.verification_capture_sha256,
+                certificate.candidate_observation_batch_sha256,
+                certificate.verification_observation_batch_sha256,
+                certificate.candidate_observations_sha256,
+                certificate.verification_observations_sha256,
+                certificate.probe_contract_sha256,
+                certificate.proof_sha256,
+            )
+        )
+        or any(
+            not value.is_finite() or value < 0
+            for value in (
+                certificate.candidate_maximum_absolute_residual,
+                certificate.candidate_maximum_relative_residual,
+                certificate.candidate_maximum_tolerance_ratio,
+                certificate.verification_maximum_absolute_residual,
+                certificate.verification_maximum_relative_residual,
+                certificate.verification_maximum_tolerance_ratio,
+            )
+        )
+        or certificate.candidate_maximum_tolerance_ratio > 1
+        or certificate.verification_maximum_tolerance_ratio > 1
+        or certificate.candidate_capture_sha256
+        == certificate.verification_capture_sha256
+        or certificate.candidate_observation_batch_sha256
+        == certificate.verification_observation_batch_sha256
+    ):
+        return False
+    probe_contract = {
+        "algorithm": certificate.algorithm,
+        "source_semantics_sha256": certificate.source_semantics_sha256,
+        "runtime_schema_sha256": certificate.runtime_schema_sha256,
+        "source_dag_sha256": certificate.source_dag_sha256,
+        "candidate_capture_sha256": certificate.candidate_capture_sha256,
+        "verification_capture_sha256": (
+            certificate.verification_capture_sha256
+        ),
+        "candidate_observation_batch_sha256": (
+            certificate.candidate_observation_batch_sha256
+        ),
+        "verification_observation_batch_sha256": (
+            certificate.verification_observation_batch_sha256
+        ),
+        "current_id": certificate.current_id,
+        "representative_id": certificate.representative_id,
+        "relation_kind": certificate.relation_kind,
+        "precision_digits": certificate.precision_digits,
+        "seed": certificate.seed,
+        "candidate_domain": "candidate-current-probes-v1",
+        "verification_domain": "independent-verification-current-probes-v1",
+        "relative_tolerance_binary64": (
+            certificate.relative_tolerance.hex()
+        ),
+        "absolute_tolerance_binary64": (
+            certificate.absolute_tolerance.hex()
+        ),
+        "candidate_probe_count": certificate.candidate_probe_count,
+        "verification_probe_count": certificate.verification_probe_count,
+        "current_dimension": certificate.current_dimension,
+        "candidate_observations_sha256": (
+            certificate.candidate_observations_sha256
+        ),
+        "verification_observations_sha256": (
+            certificate.verification_observations_sha256
+        ),
+    }
+    if (
+        _canonical_payload_sha256(probe_contract)
+        != certificate.probe_contract_sha256
+    ):
+        return False
+    proof_payload = {
+        **probe_contract,
+        "proof_kind": certificate.proof_kind,
+        "factor_binary64": (
+            None
+            if certificate.factor is None
+            else [
+                certificate.factor[0].hex(),
+                certificate.factor[1].hex(),
+            ]
+        ),
+        "candidate_maximum_absolute_residual": _canonical_decimal_string(
+            certificate.candidate_maximum_absolute_residual
+        ),
+        "candidate_maximum_relative_residual": _canonical_decimal_string(
+            certificate.candidate_maximum_relative_residual
+        ),
+        "candidate_maximum_tolerance_ratio": _canonical_decimal_string(
+            certificate.candidate_maximum_tolerance_ratio
+        ),
+        "verification_maximum_absolute_residual": _canonical_decimal_string(
+            certificate.verification_maximum_absolute_residual
+        ),
+        "verification_maximum_relative_residual": _canonical_decimal_string(
+            certificate.verification_maximum_relative_residual
+        ),
+        "verification_maximum_tolerance_ratio": _canonical_decimal_string(
+            certificate.verification_maximum_tolerance_ratio
+        ),
+        "probe_contract_sha256": certificate.probe_contract_sha256,
+    }
+    return _canonical_payload_sha256(proof_payload) == certificate.proof_sha256
+
+
+def generic_dag_numerical_source_semantics_sha256(
+    dag: GenericDAG,
+    *,
+    execution_mode: Literal["compiled", "eager"],
+) -> str:
+    """Bind numerical observations to an execution-scoped source DAG.
+
+    Evaluation-group IDs and factors are derived optimizations rather than
+    source semantics.  Removing them makes the digest stable across baseline
+    exact sharing and authenticated numerical sharing while retaining every
+    current, interaction, selector, colour, helicity, and model-facing field.
+    """
+
+    if execution_mode not in {"compiled", "eager"}:
+        raise ValueError(
+            "generic-DAG numerical relations require compiled or eager mode"
+        )
+    source_dag = _replace_dag_interactions_preserving_materialization(
+        dag,
+        tuple(
+            replace(
+                interaction,
+                evaluation_group_id=None,
+                evaluation_factor=(1.0, 0.0),
+            )
+            for interaction in dag.interactions
+        ),
+    )
+    return _canonical_payload_sha256(
+        {
+            "abi": GENERIC_DAG_NUMERICAL_SOURCE_SEMANTICS_ABI,
+            "execution_mode": execution_mode,
+            "color_accuracy": str(dag.process.color_accuracy),
+            "dag": source_dag.to_json_dict(),
+        }
+    )
+
+
+def generic_dag_numerical_source_dag_sha256(dag: GenericDAG) -> str:
+    """Return the exact pre-application DAG digest bound into evidence."""
+
+    return _canonical_payload_sha256(dag.to_json_dict())
+
+
+def generic_dag_numerical_runtime_schema_sha256(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str | None = None,
+) -> str:
+    """Return the model- and process-bound runtime schema digest."""
+
+    from .runtime_schema import build_runtime_expression_schema
+
+    return build_runtime_expression_schema(
+        dag,
+        model,
+        process_id=process_id or dag.process.key,
+    ).sha256
+
+
+def generic_dag_numerical_model_parameter_schema_sha256(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str | None = None,
+) -> str:
+    """Bind numerical probes to the ordered runtime-parameter schema."""
+
+    from .runtime_schema import build_runtime_expression_schema
+
+    runtime_schema = build_runtime_expression_schema(
+        dag,
+        model,
+        process_id=process_id or dag.process.key,
+    ).to_mapping()
+    return _canonical_payload_sha256(
+        runtime_schema.get("model_parameters", ())
+    )
+
+
+def generic_dag_numerical_capture_output_partition_sha256(
+    runtime_schema: Mapping[str, object],
+) -> str:
+    """Authenticate current-ID partitions from source runtime-slot geometry."""
+
+    raw_stages = runtime_schema.get("stages")
+    raw_value_storage = runtime_schema.get("value_storage")
+    if not isinstance(raw_stages, list) or not isinstance(
+        raw_value_storage,
+        Mapping,
+    ):
+        raise ValueError(
+            "numerical current partition runtime schema is invalid"
+        )
+    raw_value_slots = raw_value_storage.get("value_slots")
+    if not isinstance(raw_value_slots, list):
+        raise ValueError(
+            "numerical current partition value slots are invalid"
+        )
+    value_slots: dict[int, Mapping[str, object]] = {}
+    for raw_slot in raw_value_slots:
+        if not isinstance(raw_slot, Mapping):
+            raise ValueError(
+                "numerical current partition value slot is invalid"
+            )
+        value_slot_id = raw_slot.get("value_slot_id")
+        if (
+            type(value_slot_id) is not int
+            or value_slot_id < 0
+            or value_slot_id in value_slots
+        ):
+            raise ValueError(
+                "numerical current partition value-slot identity drifted"
+            )
+        value_slots[value_slot_id] = raw_slot
+
+    stage_contracts: list[dict[str, object]] = []
+    previous_stage_index: int | None = None
+    seen_output_slot_ids: set[int] = set()
+    for raw_stage in raw_stages:
+        if not isinstance(raw_stage, Mapping):
+            raise ValueError(
+                "numerical current partition stage is invalid"
+            )
+        stage_index = raw_stage.get("stage_index")
+        stage_kind = raw_stage.get("stage_kind")
+        subset_size = raw_stage.get("subset_size")
+        raw_output_slot_ids = raw_stage.get("output_value_slot_ids")
+        raw_output_current_ids = raw_stage.get("output_current_ids")
+        if (
+            type(stage_index) is not int
+            or (
+                previous_stage_index is not None
+                and stage_index <= previous_stage_index
+            )
+            or not isinstance(stage_kind, str)
+            or type(subset_size) is not int
+            or not isinstance(raw_output_slot_ids, list)
+            or not raw_output_slot_ids
+            or not isinstance(raw_output_current_ids, list)
+        ):
+            raise ValueError(
+                "numerical current partition stage identity drifted"
+            )
+
+        records: list[dict[str, object]] = []
+        partition_slots: list[dict[str, object]] = []
+        partition_start = 0
+        output_start = 0
+        current_id: int | None = None
+        seen_current_ids: set[int] = set()
+
+        def partition_record(
+            *,
+            bound_current_id: int | None,
+            bound_slots: Sequence[Mapping[str, object]],
+            bound_start: int,
+            stop: int,
+        ) -> dict[str, object]:
+            if (
+                bound_current_id is None
+                or not bound_slots
+                or bound_start >= stop
+            ):
+                raise ValueError(
+                    "numerical current partition contains an empty range"
+                )
+            return {
+                "current_id": bound_current_id,
+                "output_start": bound_start,
+                "output_stop": stop,
+                "slots": list(bound_slots),
+            }
+
+        for raw_value_slot_id in raw_output_slot_ids:
+            if (
+                type(raw_value_slot_id) is not int
+                or raw_value_slot_id in seen_output_slot_ids
+                or raw_value_slot_id not in value_slots
+            ):
+                raise ValueError(
+                    "numerical current partition output-slot identity drifted"
+                )
+            slot = value_slots[raw_value_slot_id]
+            slot_current_id = slot.get("current_id")
+            component_start = slot.get("component_start")
+            component_stop = slot.get("component_stop")
+            variant = slot.get("variant")
+            if (
+                type(slot_current_id) is not int
+                or slot_current_id < 0
+                or type(component_start) is not int
+                or type(component_stop) is not int
+                or component_start < 0
+                or component_stop <= component_start
+                or not isinstance(variant, str)
+                or slot.get("is_source") is not False
+            ):
+                raise ValueError(
+                    "numerical current partition output slot is invalid"
+                )
+            if current_id is None:
+                current_id = slot_current_id
+                seen_current_ids.add(current_id)
+            elif slot_current_id != current_id:
+                records.append(
+                    partition_record(
+                        bound_current_id=current_id,
+                        bound_slots=partition_slots,
+                        bound_start=partition_start,
+                        stop=output_start,
+                    )
+                )
+                if (
+                    slot_current_id in seen_current_ids
+                    or slot_current_id <= current_id
+                ):
+                    raise ValueError(
+                        "numerical current partition output current order "
+                        "drifted"
+                    )
+                current_id = slot_current_id
+                seen_current_ids.add(current_id)
+                partition_start = output_start
+                partition_slots = []
+            output_stop = output_start + component_stop - component_start
+            partition_slots.append(
+                {
+                    "value_slot_id": raw_value_slot_id,
+                    "variant": variant,
+                    "component_start": component_start,
+                    "component_stop": component_stop,
+                    "output_start": output_start,
+                    "output_stop": output_stop,
+                }
+            )
+            output_start = output_stop
+            seen_output_slot_ids.add(raw_value_slot_id)
+        records.append(
+            partition_record(
+                bound_current_id=current_id,
+                bound_slots=partition_slots,
+                bound_start=partition_start,
+                stop=output_start,
+            )
+        )
+        if raw_output_current_ids != [
+            record["current_id"] for record in records
+        ]:
+            raise ValueError(
+                "numerical current partition stage current identity drifted"
+            )
+        stage_contracts.append(
+            {
+                "stage_index": stage_index,
+                "stage_kind": stage_kind,
+                "subset_size": subset_size,
+                "output_length": output_start,
+                "partitions": records,
+            }
+        )
+        previous_stage_index = stage_index
+    if not stage_contracts:
+        raise ValueError(
+            "numerical current partition runtime schema has no stages"
+        )
+    return _canonical_payload_sha256(
+        {
+            "abi": NUMERICAL_CURRENT_CAPTURE_OUTPUT_PARTITION_ABI,
+            "strategy": "one-contiguous-output-partition-per-current-id",
+            "stages": stage_contracts,
+        }
+    )
+
+
+def discover_generic_dag_numerical_current_relations(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    candidate_observations: Mapping[
+        int,
+        Sequence[tuple[Decimal, Decimal]],
+    ],
+    verification_observations: Mapping[
+        int,
+        Sequence[tuple[Decimal, Decimal]],
+    ],
+    candidate_point_sha256s: Sequence[str],
+    verification_point_sha256s: Sequence[str],
+    candidate_kinematic_sha256s: Sequence[str],
+    verification_kinematic_sha256s: Sequence[str],
+    candidate_parameter_context_sha256s: Sequence[str],
+    verification_parameter_context_sha256s: Sequence[str],
+    runtime_schema_sha256: str,
+    source_dag_sha256: str,
+    evaluator_output_partition_abi: str,
+    evaluator_output_partition_sha256: str,
+    candidate_capture_sha256: str,
+    verification_capture_sha256: str,
+    process_id: str | None = None,
+    execution_mode: Literal["compiled", "eager"],
+    precision_digits: int,
+    seed: int,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+) -> NumericalCurrentObservationDiscoveryResult:
+    """Discover equal, opposite, and zero currents from complete warm-up data.
+
+    Every generated current is compared exhaustively within its exact runtime
+    contract.  Candidate and verification point domains must be disjoint.
+    Exact structural relations are retained in preference to numerical
+    evidence and are not re-certified as proof-less mappings.
+    """
+
+    source_digest = generic_dag_numerical_source_semantics_sha256(
+        dag,
+        execution_mode=execution_mode,
+    )
+    from .runtime_schema import build_runtime_expression_schema
+
+    actual_runtime_schema = build_runtime_expression_schema(
+        dag,
+        model,
+        process_id=process_id or dag.process.key,
+    )
+    actual_runtime_schema_mapping = actual_runtime_schema.to_mapping()
+    actual_runtime_schema_digest = actual_runtime_schema.sha256
+    actual_model_parameter_schema_digest = _canonical_payload_sha256(
+        actual_runtime_schema_mapping.get("model_parameters", ())
+    )
+    actual_output_partition_digest = (
+        generic_dag_numerical_capture_output_partition_sha256(
+            actual_runtime_schema_mapping
+        )
+    )
+    actual_source_dag_digest = generic_dag_numerical_source_dag_sha256(dag)
+    candidate_points = tuple(candidate_point_sha256s)
+    verification_points = tuple(verification_point_sha256s)
+    candidate_kinematics = tuple(candidate_kinematic_sha256s)
+    verification_kinematics = tuple(verification_kinematic_sha256s)
+    candidate_parameters = tuple(
+        candidate_parameter_context_sha256s
+    )
+    verification_parameters = tuple(
+        verification_parameter_context_sha256s
+    )
+    if (
+        type(precision_digits) is not int
+        or precision_digits < 80
+        or type(seed) is not int
+        or seed < 0
+        or len(candidate_points) < 2
+        or len(verification_points) < 2
+        or any(not _is_sha256(value) for value in candidate_points)
+        or any(not _is_sha256(value) for value in verification_points)
+        or len(set(candidate_points)) != len(candidate_points)
+        or len(set(verification_points)) != len(verification_points)
+        or not set(candidate_points).isdisjoint(verification_points)
+        or len(candidate_kinematics) != len(candidate_points)
+        or len(verification_kinematics) != len(verification_points)
+        or len(candidate_parameters) != len(candidate_points)
+        or len(verification_parameters) != len(verification_points)
+        or any(not _is_sha256(value) for value in candidate_kinematics)
+        or any(not _is_sha256(value) for value in verification_kinematics)
+        or any(not _is_sha256(value) for value in candidate_parameters)
+        or any(not _is_sha256(value) for value in verification_parameters)
+        or len(set(candidate_kinematics)) != len(candidate_kinematics)
+        or len(set(verification_kinematics))
+        != len(verification_kinematics)
+        or not set(candidate_kinematics).isdisjoint(
+            verification_kinematics
+        )
+        or not set(candidate_parameters).isdisjoint(
+            verification_parameters
+        )
+        or any(
+            not _is_sha256(value)
+            for value in (
+                runtime_schema_sha256,
+                source_dag_sha256,
+                evaluator_output_partition_sha256,
+                candidate_capture_sha256,
+                verification_capture_sha256,
+            )
+        )
+        or evaluator_output_partition_abi
+        != NUMERICAL_CURRENT_CAPTURE_OUTPUT_PARTITION_ABI
+        or evaluator_output_partition_sha256
+        != actual_output_partition_digest
+        or candidate_capture_sha256 == verification_capture_sha256
+        or runtime_schema_sha256 != actual_runtime_schema_digest
+        or source_dag_sha256 != actual_source_dag_digest
+    ):
+        raise ValueError(
+            "numerical current discovery point contract is invalid"
+        )
+    if (
+        not isinstance(relative_tolerance, int | float)
+        or isinstance(relative_tolerance, bool)
+        or not isinstance(absolute_tolerance, int | float)
+        or isinstance(absolute_tolerance, bool)
+    ):
+        raise ValueError(
+            "numerical current discovery tolerances must be real numbers"
+        )
+    relative = float(relative_tolerance)
+    absolute = float(absolute_tolerance)
+    if (
+        not isfinite(relative)
+        or not isfinite(absolute)
+        or relative < 0.0
+        or absolute < 0.0
+        or _is_negative_zero(relative)
+        or _is_negative_zero(absolute)
+        or (relative == 0.0 and absolute == 0.0)
+    ):
+        raise ValueError("numerical current discovery tolerances are invalid")
+
+    current_ids = tuple(range(len(dag.currents)))
+    if tuple(current.id for current in dag.currents) != current_ids:
+        raise ValueError(
+            "numerical current discovery requires canonical current IDs"
+        )
+    if set(candidate_observations) != set(current_ids) or set(
+        verification_observations
+    ) != set(current_ids):
+        raise ValueError(
+            "numerical current discovery requires observations for every current"
+        )
+    candidate_values: dict[
+        int,
+        tuple[tuple[Decimal, Decimal], ...],
+    ] = {}
+    verification_values: dict[
+        int,
+        tuple[tuple[Decimal, Decimal], ...],
+    ] = {}
+    for current in dag.currents:
+        candidate = _validated_decimal_observations(
+            candidate_observations[current.id]
+        )
+        verification = _validated_decimal_observations(
+            verification_observations[current.id]
+        )
+        expected_candidate_count = (
+            len(candidate_points) * current.dimension
+        )
+        expected_verification_count = (
+            len(verification_points) * current.dimension
+        )
+        if (
+            candidate is None
+            or verification is None
+            or len(candidate) != expected_candidate_count
+            or len(verification) != expected_verification_count
+        ):
+            raise ValueError(
+                f"numerical observations for current {current.id} do not "
+                "cover every point and component"
+            )
+        candidate_values[current.id] = candidate
+        verification_values[current.id] = verification
+
+    candidate_batch_digest = _numerical_current_observation_batch_sha256(
+        candidate_values,
+        point_sha256s=candidate_points,
+    )
+    verification_batch_digest = _numerical_current_observation_batch_sha256(
+        verification_values,
+        point_sha256s=verification_points,
+    )
+    expected_candidate_capture_digest = _canonical_payload_sha256(
+        {
+            "abi": NUMERICAL_CURRENT_CAPTURE_ABI,
+            "precision_digits": precision_digits,
+            "point_sha256s": list(candidate_points),
+            "kinematic_sha256s": list(candidate_kinematics),
+            "parameter_context_sha256s": list(candidate_parameters),
+            "runtime_schema_sha256": runtime_schema_sha256,
+            "model_parameter_schema_sha256": (
+                actual_model_parameter_schema_digest
+            ),
+            "source_dag_sha256": source_dag_sha256,
+            "evaluator_output_partition_abi": (
+                evaluator_output_partition_abi
+            ),
+            "evaluator_output_partition_sha256": (
+                evaluator_output_partition_sha256
+            ),
+            "observation_batch_sha256": candidate_batch_digest,
+        }
+    )
+    expected_verification_capture_digest = _canonical_payload_sha256(
+        {
+            "abi": NUMERICAL_CURRENT_CAPTURE_ABI,
+            "precision_digits": precision_digits,
+            "point_sha256s": list(verification_points),
+            "kinematic_sha256s": list(verification_kinematics),
+            "parameter_context_sha256s": list(verification_parameters),
+            "runtime_schema_sha256": runtime_schema_sha256,
+            "model_parameter_schema_sha256": (
+                actual_model_parameter_schema_digest
+            ),
+            "source_dag_sha256": source_dag_sha256,
+            "evaluator_output_partition_abi": (
+                evaluator_output_partition_abi
+            ),
+            "evaluator_output_partition_sha256": (
+                evaluator_output_partition_sha256
+            ),
+            "observation_batch_sha256": verification_batch_digest,
+        }
+    )
+    if (
+        candidate_capture_sha256 != expected_candidate_capture_digest
+        or verification_capture_sha256
+        != expected_verification_capture_digest
+    ):
+        raise ValueError(
+            "numerical current capture provenance does not authenticate its "
+            "complete observation batches"
+        )
+    structural = _derive_current_value_equivalences(dag, model)
+    contracts = tuple(
+        _current_evaluation_contract(current) for current in dag.currents
+    )
+    members_by_contract: dict[_CurrentContract, list[int]] = defaultdict(list)
+    for current_id, contract in enumerate(contracts):
+        members_by_contract[contract].append(current_id)
+    candidate_indexes = {
+        contract: _build_numerical_observation_candidate_index(
+            member_ids,
+            candidate_values,
+        )
+        for contract, member_ids in members_by_contract.items()
+    }
+    prior_by_contract: dict[_CurrentContract, list[int]] = defaultdict(list)
+    source_ids = set(dag.sources)
+    relative_decimal = Decimal.from_float(relative)
+    absolute_decimal = Decimal.from_float(absolute)
+    certificates: list[NumericalCurrentRelationCertificate] = []
+    rejected_candidates: list[dict[str, object]] = []
+    nearest_rejected: tuple[
+        Decimal,
+        Decimal,
+        Decimal,
+        int,
+        int,
+        str,
+    ] | None = None
+    structurally_proven_count = 0
+    tested_hypothesis_count = 0
+    theoretical_pair_hypothesis_count = 0
+    screened_pair_hypothesis_count = 0
+    numerical_candidate_count = 0
+    verification_rejected_count = 0
+    rejected_hypothesis_count = 0
+    rejected_decision_sha256 = _canonical_payload_sha256(
+        {
+            "abi": "pyamplicol-generic-dag-rejected-decision-chain-v1",
+            "candidate_capture_sha256": candidate_capture_sha256,
+            "verification_capture_sha256": verification_capture_sha256,
+        }
+    )
+
+    def record_rejected(
+        *,
+        current_id: int,
+        representative_id: int | None,
+        relation_kind: str,
+        residuals: tuple[
+            Decimal,
+            Decimal,
+            Decimal,
+            tuple[tuple[Decimal, Decimal], ...],
+        ],
+        reason: str,
+    ) -> None:
+        nonlocal nearest_rejected
+        nonlocal rejected_decision_sha256
+        nonlocal rejected_hypothesis_count
+        rejected_hypothesis_count += 1
+        candidate = (
+            residuals[2],
+            residuals[0],
+            residuals[1],
+            current_id,
+            -1 if representative_id is None else representative_id,
+            relation_kind,
+        )
+        if nearest_rejected is None or candidate < nearest_rejected:
+            nearest_rejected = candidate
+        row = {
+            "current_id": current_id,
+            "representative_id": representative_id,
+            "relation_kind": relation_kind,
+            "reason": reason,
+            "maximum_absolute_residual": (
+                _canonical_decimal_string(residuals[0])
+            ),
+            "maximum_relative_residual": (
+                _canonical_decimal_string(residuals[1])
+            ),
+            "maximum_tolerance_ratio": (
+                _canonical_decimal_string(residuals[2])
+            ),
+        }
+        rejected_decision_sha256 = _advance_rejection_digest(
+            rejected_decision_sha256,
+            row,
+        )
+        if len(rejected_candidates) < _MAX_REJECTED_DIAGNOSTICS:
+            rejected_candidates.append(row)
+
+    for current in dag.currents:
+        contract = contracts[current.id]
+        prior_ids = prior_by_contract.setdefault(contract, [])
+        if current.id in source_ids or current.is_source:
+            prior_ids.append(current.id)
+            continue
+        baseline = structural[current.id]
+        if (
+            baseline.representative_id != current.id
+            or baseline.factor != (1.0, 0.0)
+        ):
+            structurally_proven_count += 1
+            prior_ids.append(current.id)
+            continue
+
+        equal_representatives = set(
+            _numerical_observation_tolerance_window_ids(
+                candidate_indexes[contract],
+                candidate_values[current.id],
+                relation_kind="equal",
+                current_id=current.id,
+                relative_tolerance=relative_decimal,
+                absolute_tolerance=absolute_decimal,
+                precision_digits=precision_digits,
+            )
+        )
+        opposite_representatives = set(
+            _numerical_observation_tolerance_window_ids(
+                candidate_indexes[contract],
+                candidate_values[current.id],
+                relation_kind="opposite",
+                current_id=current.id,
+                relative_tolerance=relative_decimal,
+                absolute_tolerance=absolute_decimal,
+                precision_digits=precision_digits,
+            )
+        )
+        theoretical_pair_hypothesis_count += 2 * len(prior_ids)
+        screened_pair_hypothesis_count += (
+            len(equal_representatives) + len(opposite_representatives)
+        )
+        hypotheses: list[
+            tuple[
+                Literal["equal", "opposite", "zero"],
+                int | None,
+                tuple[tuple[Decimal, Decimal], ...] | None,
+                tuple[tuple[Decimal, Decimal], ...] | None,
+            ]
+        ] = [
+            ("zero", None, None, None),
+            *[
+                (
+                    relation_kind,
+                    representative_id,
+                    candidate_values[representative_id],
+                    verification_values[representative_id],
+                )
+                for representative_id in sorted(
+                    equal_representatives | opposite_representatives
+                )
+                for relation_kind in (
+                    *(
+                        ("equal",)
+                        if representative_id in equal_representatives
+                        else ()
+                    ),
+                    *(
+                        ("opposite",)
+                        if representative_id in opposite_representatives
+                        else ()
+                    ),
+                )
+            ],
+        ]
+        accepted: NumericalCurrentRelationCertificate | None = None
+        for (
+            relation_kind,
+            representative_id,
+            candidate_representative,
+            verification_representative,
+        ) in hypotheses:
+            tested_hypothesis_count += 1
+            candidate_residuals = _numerical_relation_residuals(
+                relation_kind,
+                candidate_values[current.id],
+                candidate_representative,
+                relative_tolerance=relative_decimal,
+                absolute_tolerance=absolute_decimal,
+                precision_digits=precision_digits,
+            )
+            if candidate_residuals is None:
+                raise ValueError(
+                    "numerical current discovery produced a malformed hypothesis"
+                )
+            if not _numerical_relation_residuals_pass(
+                candidate_residuals,
+                precision_digits=precision_digits,
+            ):
+                record_rejected(
+                    current_id=current.id,
+                    representative_id=representative_id,
+                    relation_kind=relation_kind,
+                    residuals=candidate_residuals,
+                    reason="candidate-observations-not-equal",
+                )
+                continue
+            numerical_candidate_count += 1
+            accepted = certify_numerical_current_observations(
+                current_id=current.id,
+                representative_id=representative_id,
+                relation_kind=relation_kind,
+                source_semantics_sha256=source_digest,
+                runtime_schema_sha256=runtime_schema_sha256,
+                source_dag_sha256=source_dag_sha256,
+                candidate_capture_sha256=candidate_capture_sha256,
+                verification_capture_sha256=(
+                    verification_capture_sha256
+                ),
+                candidate_observation_batch_sha256=(
+                    candidate_batch_digest
+                ),
+                verification_observation_batch_sha256=(
+                    verification_batch_digest
+                ),
+                candidate_current_values=candidate_values[current.id],
+                candidate_representative_values=candidate_representative,
+                verification_current_values=verification_values[current.id],
+                verification_representative_values=(
+                    verification_representative
+                ),
+                precision_digits=precision_digits,
+                seed=seed,
+                relative_tolerance=relative,
+                absolute_tolerance=absolute,
+                candidate_probe_count=len(candidate_points),
+                verification_probe_count=len(verification_points),
+            )
+            if accepted is not None:
+                certificates.append(accepted)
+                break
+            verification_rejected_count += 1
+            verification_residuals = _numerical_relation_residuals(
+                relation_kind,
+                verification_values[current.id],
+                verification_representative,
+                relative_tolerance=relative_decimal,
+                absolute_tolerance=absolute_decimal,
+                precision_digits=precision_digits,
+            )
+            if verification_residuals is None:
+                raise ValueError(
+                    "numerical current verification produced a malformed "
+                    "hypothesis"
+                )
+            record_rejected(
+                current_id=current.id,
+                representative_id=representative_id,
+                relation_kind=relation_kind,
+                residuals=verification_residuals,
+                reason="independent-verification-rejected-candidate",
+            )
+        prior_ids.append(current.id)
+
+    nearest_payload: dict[str, object] | None = None
+    if nearest_rejected is not None:
+        (
+            tolerance_ratio,
+            absolute_residual,
+            relative_residual,
+            current_id,
+            representative_key,
+            nearest_relation_kind,
+        ) = nearest_rejected
+        nearest_payload = {
+            "current_id": current_id,
+            "representative_id": (
+                None if representative_key < 0 else representative_key
+            ),
+            "relation_kind": nearest_relation_kind,
+            "maximum_absolute_residual": (
+                _canonical_decimal_string(absolute_residual)
+            ),
+            "maximum_relative_residual": (
+                _canonical_decimal_string(relative_residual)
+            ),
+            "maximum_tolerance_ratio": (
+                _canonical_decimal_string(tolerance_ratio)
+            ),
+        }
+    certificate_tuple = tuple(certificates)
+    if rejected_hypothesis_count != (
+        tested_hypothesis_count - len(certificate_tuple)
+    ):
+        raise AssertionError(
+            "generic numerical rejection census is internally inconsistent"
+        )
+    state = (
+        "certified_numerical_relations"
+        if certificate_tuple
+        else "no_certified_numerical_relation"
+    )
+    report = NumericalCurrentObservationDiscoveryReport(
+        execution_mode=execution_mode,
+        color_accuracy=str(dag.process.color_accuracy),
+        source_semantics_sha256=source_digest,
+        runtime_schema_sha256=runtime_schema_sha256,
+        source_dag_sha256=source_dag_sha256,
+        precision_digits=precision_digits,
+        seed=seed,
+        relative_tolerance=relative,
+        absolute_tolerance=absolute,
+        candidate_point_sha256s=candidate_points,
+        verification_point_sha256s=verification_points,
+        candidate_kinematic_sha256s=candidate_kinematics,
+        verification_kinematic_sha256s=verification_kinematics,
+        candidate_parameter_context_sha256s=candidate_parameters,
+        verification_parameter_context_sha256s=verification_parameters,
+        candidate_capture_sha256=candidate_capture_sha256,
+        verification_capture_sha256=verification_capture_sha256,
+        candidate_observation_batch_sha256=candidate_batch_digest,
+        verification_observation_batch_sha256=verification_batch_digest,
+        state=state,
+        inspected_current_count=len(dag.currents),
+        structurally_proven_current_count=structurally_proven_count,
+        tested_hypothesis_count=tested_hypothesis_count,
+        theoretical_pair_hypothesis_count=(
+            theoretical_pair_hypothesis_count
+        ),
+        screened_pair_hypothesis_count=screened_pair_hypothesis_count,
+        candidate_index_contract_count=len(candidate_indexes),
+        exhaustive_fallback_contract_count=(
+            len(candidate_indexes) if relative_decimal >= 1 else 0
+        ),
+        numerical_candidate_count=numerical_candidate_count,
+        verification_rejected_count=verification_rejected_count,
+        rejected_hypothesis_count=rejected_hypothesis_count,
+        rejected_decision_sha256=rejected_decision_sha256,
+        certificates=certificate_tuple,
+        rejected_candidates=tuple(rejected_candidates),
+        nearest_rejected_hypothesis=nearest_payload,
+    )
+    return NumericalCurrentObservationDiscoveryResult(
+        certificates=certificate_tuple,
+        report=report,
+        structural_equivalences=structural,
+    )
+
+
+def _numerical_current_observation_batch_sha256(
+    observations: Mapping[
+        int,
+        tuple[tuple[Decimal, Decimal], ...],
+    ],
+    *,
+    point_sha256s: tuple[str, ...],
+) -> str:
+    return _canonical_payload_sha256(
+        {
+            "point_sha256s": list(point_sha256s),
+            "currents": [
+                {
+                    "current_id": current_id,
+                    "values": [
+                        [
+                            _canonical_decimal_string(real),
+                            _canonical_decimal_string(imaginary),
+                        ]
+                        for real, imaginary in observations[current_id]
+                    ],
+                }
+                for current_id in sorted(observations)
+            ],
+        }
+    )
+
+
+def apply_numerical_current_relation_certificates(
+    dag: GenericDAG,
+    model: Model,
+    certificates: Iterable[NumericalCurrentRelationCertificate],
+    *,
+    mode: _DiscoveryMode,
+    execution_mode: Literal["compiled", "eager"],
+    process_id: str | None = None,
+    runtime_schema_sha256: str | None = None,
+    source_dag_sha256: str | None = None,
+    candidate_capture_sha256: str | None = None,
+    verification_capture_sha256: str | None = None,
+    _structural_equivalences: (
+        tuple[_CurrentValueEquivalence, ...] | None
+    ) = None,
+) -> NumericalCurrentRelationApplicationResult:
+    """Replay and apply one canonical authenticated numerical relation set.
+
+    Application is monotonic with respect to the DAG's existing evaluator
+    partition.  Certified zeros suppress only interactions that consume the
+    zero current or an exactly proven member of its structural class.
+    Equal/opposite mappings merge such an interaction into an already
+    compatible concrete evaluator group.  Unaffected interactions are never
+    regrouped, and the evaluator count is forbidden to increase.
+
+    Any malformed, stale, inconsistent, non-topological, or inexact binary64
+    factor composition fails closed.  A valid certificate for which no safe
+    downstream reuse opportunity exists remains recorded but unapplied.
+    """
+
+    if mode not in {"diagnostic", "certified-reuse"}:
+        raise ValueError(f"unsupported relation discovery mode {mode!r}")
+    source_digest = generic_dag_numerical_source_semantics_sha256(
+        dag,
+        execution_mode=execution_mode,
+    )
+    ordered = tuple(certificates)
+    if ordered:
+        resolved_process_id = process_id or dag.process.key
+        actual_runtime_schema_digest = (
+            generic_dag_numerical_runtime_schema_sha256(
+                dag,
+                model,
+                process_id=resolved_process_id,
+            )
+        )
+        actual_source_dag_digest = generic_dag_numerical_source_dag_sha256(
+            dag
+        )
+        expected_runtime_schema_digest = (
+            actual_runtime_schema_digest
+            if runtime_schema_sha256 is None
+            else runtime_schema_sha256
+        )
+        expected_source_dag_digest = (
+            actual_source_dag_digest
+            if source_dag_sha256 is None
+            else source_dag_sha256
+        )
+        if (
+            expected_runtime_schema_digest != actual_runtime_schema_digest
+            or expected_source_dag_digest != actual_source_dag_digest
+            or not _is_sha256(expected_runtime_schema_digest)
+            or not _is_sha256(expected_source_dag_digest)
+        ):
+            raise ValueError(
+                "numerical current application model/schema provenance "
+                "drifted from discovery"
+            )
+        expected_candidate_capture_digest = (
+            ordered[0].candidate_capture_sha256
+            if candidate_capture_sha256 is None
+            else candidate_capture_sha256
+        )
+        expected_verification_capture_digest = (
+            ordered[0].verification_capture_sha256
+            if verification_capture_sha256 is None
+            else verification_capture_sha256
+        )
+        if (
+            not _is_sha256(expected_candidate_capture_digest)
+            or not _is_sha256(expected_verification_capture_digest)
+            or expected_candidate_capture_digest
+            == expected_verification_capture_digest
+        ):
+            raise ValueError(
+                "numerical current application capture provenance is invalid"
+            )
+    else:
+        expected_runtime_schema_digest = runtime_schema_sha256
+        expected_source_dag_digest = source_dag_sha256
+        expected_candidate_capture_digest = candidate_capture_sha256
+        expected_verification_capture_digest = (
+            verification_capture_sha256
+        )
+    if tuple(sorted(ordered, key=lambda item: item.current_id)) != ordered:
+        raise ValueError(
+            "numerical current certificates must use increasing current IDs"
+        )
+    if len({certificate.current_id for certificate in ordered}) != len(ordered):
+        raise ValueError(
+            "numerical current certificates contain duplicate current IDs"
+        )
+
+    source_ids = set(dag.sources)
+    current_contracts = tuple(
+        _current_evaluation_contract(current) for current in dag.currents
+    )
+    common_probe_contract: tuple[object, ...] | None = None
+    authenticated_relations: dict[int, _CurrentValueEquivalence] = {}
+    for certificate in ordered:
+        if not verify_numerical_current_relation_certificate(
+            certificate,
+            source_semantics_sha256=source_digest,
+        ):
+            raise ValueError(
+                f"numerical current certificate {certificate.current_id} "
+                "does not replay against the source DAG"
+            )
+        if (
+            certificate.runtime_schema_sha256
+            != expected_runtime_schema_digest
+            or certificate.source_dag_sha256
+            != expected_source_dag_digest
+            or certificate.candidate_capture_sha256
+            != expected_candidate_capture_digest
+            or certificate.verification_capture_sha256
+            != expected_verification_capture_digest
+        ):
+            raise ValueError(
+                "numerical current certificate evidence provenance drifted "
+                "from its application contract"
+            )
+        current_id = certificate.current_id
+        if (
+            current_id >= len(dag.currents)
+            or current_id in source_ids
+            or dag.currents[current_id].is_source
+            or certificate.current_dimension
+            != dag.currents[current_id].dimension
+        ):
+            raise ValueError(
+                "numerical current relations may target only matching "
+                "generated currents"
+            )
+        probe_contract = (
+            certificate.precision_digits,
+            certificate.seed,
+            certificate.relative_tolerance.hex(),
+            certificate.absolute_tolerance.hex(),
+            certificate.candidate_probe_count,
+            certificate.verification_probe_count,
+            certificate.runtime_schema_sha256,
+            certificate.source_dag_sha256,
+            certificate.candidate_capture_sha256,
+            certificate.verification_capture_sha256,
+            certificate.candidate_observation_batch_sha256,
+            certificate.verification_observation_batch_sha256,
+        )
+        if common_probe_contract is None:
+            common_probe_contract = probe_contract
+        elif common_probe_contract != probe_contract:
+            raise ValueError(
+                "numerical current relation set mixes probe contracts"
+            )
+
+        if certificate.relation_kind == "zero":
+            compatible_representatives = tuple(
+                candidate_id
+                for candidate_id in range(current_id)
+                if current_contracts[candidate_id]
+                == current_contracts[current_id]
+            )
+            execution_representative_id = (
+                compatible_representatives[0]
+                if compatible_representatives
+                else current_id
+            )
+            factor = (0.0, 0.0)
+        else:
+            representative_id = certificate.representative_id
+            if (
+                representative_id is None
+                or representative_id >= current_id
+                or current_contracts[representative_id]
+                != current_contracts[current_id]
+            ):
+                raise ValueError(
+                    "numerical current representative violates its "
+                    "execution contract"
+                )
+            execution_representative_id = representative_id
+            assert certificate.factor is not None
+            factor = certificate.factor
+        authenticated_relations[current_id] = _CurrentValueEquivalence(
+            representative_id=execution_representative_id,
+            factor=factor,
+        )
+
+    if ordered:
+        structural_equivalences = (
+            _derive_current_value_equivalences(dag, model)
+            if _structural_equivalences is None
+            else _structural_equivalences
+        )
+        if len(structural_equivalences) != len(dag.currents):
+            raise ValueError(
+                "numerical current structural equivalence cache drifted"
+            )
+        baseline = _numerical_current_application_baseline(dag, model)
+        (
+            projected,
+            resolved_relations,
+            certificate_chains,
+            projected_interaction_ids,
+        ) = _project_authenticated_numerical_interaction_reuse(
+            baseline,
+            model,
+            authenticated_relations,
+            structural_equivalences=structural_equivalences,
+        )
+    else:
+        baseline = projected = dag
+        resolved_relations = tuple(
+            _CurrentValueEquivalence(current.id, (1.0, 0.0))
+            for current in dag.currents
+        )
+        certificate_chains = tuple(() for _current in dag.currents)
+        projected_interaction_ids = {}
+
+    mappings = [
+        NumericalCurrentAppliedMapping(
+            current_id=certificate.current_id,
+            representative_id=certificate.representative_id,
+            execution_representative_id=(
+                resolved_relations[certificate.current_id].representative_id
+            ),
+            relation_kind=certificate.relation_kind,
+            factor=resolved_relations[certificate.current_id].factor,
+            certificate_proof_sha256=certificate.proof_sha256,
+            resolved_current_ids=tuple(
+                current_id
+                for current_id, chain in enumerate(certificate_chains)
+                if certificate.current_id in chain
+            ),
+            projected_interaction_count=len(
+                projected_interaction_ids.get(certificate.current_id, ())
+            ),
+            projected_interaction_ids_sha256=_canonical_payload_sha256(
+                {
+                    "interaction_ids": list(
+                        projected_interaction_ids.get(
+                            certificate.current_id,
+                            (),
+                        )
+                    )
+                }
+            ),
+        )
+        for certificate in ordered
+    ]
+
+    mapping_payloads = [mapping.to_json_dict() for mapping in mappings]
+    certificate_set_digest = _canonical_payload_sha256(
+        {
+            "abi": NUMERICAL_CURRENT_RELATION_SET_ABI,
+            "source_semantics_sha256": source_digest,
+            "execution_mode": execution_mode,
+            "certificates": [
+                certificate.to_json_dict() for certificate in ordered
+            ],
+            "mappings": mapping_payloads,
+        }
+    )
+    projected_relation_count = sum(
+        bool(interaction_ids)
+        for interaction_ids in projected_interaction_ids.values()
+    )
+    apply_relations = (
+        mode == "certified-reuse" and projected_relation_count > 0
+    )
+    if not ordered:
+        state = "no_certified_numerical_relation"
+        replay_status = "no_certified_numerical_relation"
+    elif apply_relations:
+        state = "authenticated-numerical-applied"
+        replay_status = "verified"
+    elif mode == "certified-reuse":
+        state = "authenticated-numerical-no-reuse-opportunity"
+        replay_status = "verified"
+    else:
+        state = "authenticated-numerical-diagnostic-only"
+        replay_status = "verified"
+    report = NumericalCurrentRelationApplicationReport(
+        requested_mode=mode,
+        execution_mode=execution_mode,
+        color_accuracy=str(dag.process.color_accuracy),
+        source_semantics_sha256=source_digest,
+        runtime_schema_sha256=expected_runtime_schema_digest,
+        source_dag_sha256=expected_source_dag_digest,
+        candidate_capture_sha256=expected_candidate_capture_digest,
+        verification_capture_sha256=(
+            expected_verification_capture_digest
+        ),
+        state=state,
+        certificate_replay_status=replay_status,
+        certificate_set_sha256=certificate_set_digest,
+        certificates=ordered,
+        mappings=tuple(mappings),
+        interaction_evaluation_count_before=(
+            baseline.interaction_evaluation_count
+        ),
+        interaction_evaluation_count_projected=(
+            projected.interaction_evaluation_count
+        ),
+        applied_relation_count=(
+            projected_relation_count if apply_relations else 0
+        ),
+    )
+    return NumericalCurrentRelationApplicationResult(
+        dag=projected if apply_relations else dag,
+        report=report,
+    )
+
+
+def _numerical_current_application_baseline(
+    dag: GenericDAG,
+    model: Model,
+) -> GenericDAG:
+    """Retain an existing evaluator partition or establish one once.
+
+    Final generation DAGs already carry their online structural grouping and
+    must not be globally regrouped by a numerical pass.  Small API-built DAGs
+    with no evaluation metadata at all receive the ordinary exact structural
+    baseline before numerical projection.
+    """
+
+    has_evaluation_metadata = any(
+        interaction.evaluation_group_id is not None
+        or interaction.evaluation_factor != (1.0, 0.0)
+        for interaction in dag.interactions
+    )
+    baseline = (
+        dag
+        if has_evaluation_metadata
+        else assign_recursive_current_evaluation_reuse(dag, model)
+    )
+    _validate_numerical_current_application_baseline(baseline, model)
+    return baseline
+
+
+def _validate_numerical_current_application_baseline(
+    dag: GenericDAG,
+    model: Model,
+) -> None:
+    """Authenticate every live member of the existing evaluator partition."""
+
+    structural = _derive_current_value_equivalences(dag, model)
+    equivalence_by_kind: dict[int, VertexEvaluationEquivalence] = {}
+    key_by_group: dict[int, _EvaluationKey] = {}
+    for interaction in dag.interactions:
+        if not _complex_weight_is_finite(interaction.evaluation_factor):
+            raise ValueError(
+                "numerical current application baseline has a non-finite "
+                "evaluation factor"
+            )
+        if interaction.evaluation_factor == (0.0, 0.0):
+            continue
+        left = structural[interaction.left_id]
+        right = structural[interaction.right_id]
+        parent_factor = _exact_representable_complex_product(
+            left.factor,
+            right.factor,
+        )
+        key, kernel_factor = _numerical_interaction_evaluation_key(
+            dag,
+            model,
+            interaction,
+            left_id=left.representative_id,
+            right_id=right.representative_id,
+            equivalence_by_kind=equivalence_by_kind,
+        )
+        expected_factor = (
+            None
+            if parent_factor is None
+            else _exact_representable_complex_product(
+                kernel_factor,
+                parent_factor,
+            )
+        )
+        if expected_factor is None or not _complex_weight_bits_equal(
+            _canonical_complex_weight(expected_factor),
+            _canonical_complex_weight(interaction.evaluation_factor),
+        ):
+            raise ValueError(
+                "numerical current application baseline evaluation metadata "
+                f"is unauthenticated for interaction {interaction.id}"
+            )
+        group_id = interaction.evaluation_group_id
+        if group_id is None:
+            continue
+        prior = key_by_group.setdefault(group_id, key)
+        if prior != key:
+            raise ValueError(
+                "numerical current application baseline aliases distinct "
+                f"evaluation contracts in group {group_id}"
+            )
+
+
+def _resolve_authenticated_numerical_current_relations(
+    dag: GenericDAG,
+    authenticated_relations: Mapping[int, _CurrentValueEquivalence],
+    *,
+    structural_equivalences: tuple[_CurrentValueEquivalence, ...],
+) -> tuple[
+    tuple[_CurrentValueEquivalence, ...],
+    tuple[tuple[int, ...], ...],
+]:
+    """Resolve authenticated chains through exact structural current classes."""
+
+    resolved: list[_CurrentValueEquivalence] = []
+    certificate_chains: list[tuple[int, ...]] = []
+    for expected_id, current in enumerate(dag.currents):
+        if current.id != expected_id:
+            raise ValueError(
+                "numerical current application requires contiguous current IDs"
+            )
+        structural = structural_equivalences[current.id]
+        if not 0 <= structural.representative_id <= current.id:
+            raise ValueError(
+                "numerical current structural equivalence is not topological"
+            )
+        authenticated = authenticated_relations.get(current.id)
+        if structural.representative_id != current.id:
+            if authenticated is not None:
+                raise ValueError(
+                    "authenticated numerical relations must target exact "
+                    "structural current representatives"
+                )
+            representative = resolved[structural.representative_id]
+            factor = _exact_representable_complex_product(
+                structural.factor,
+                representative.factor,
+            )
+            if factor is None:
+                raise ValueError(
+                    "structural and authenticated numerical current factors "
+                    "are not exactly composable"
+                )
+            resolved.append(
+                _CurrentValueEquivalence(
+                    representative_id=representative.representative_id,
+                    factor=factor,
+                )
+            )
+            certificate_chains.append(
+                certificate_chains[structural.representative_id]
+            )
+            continue
+        if structural.factor != (1.0, 0.0):
+            raise ValueError(
+                "self-represented structural current equivalence is not "
+                "canonical"
+            )
+        if authenticated is None:
+            resolved.append(
+                _CurrentValueEquivalence(current.id, (1.0, 0.0))
+            )
+            certificate_chains.append(())
+            continue
+        if authenticated.factor == (0.0, 0.0):
+            resolved.append(authenticated)
+            certificate_chains.append((current.id,))
+            continue
+        if not 0 <= authenticated.representative_id < current.id:
+            raise ValueError(
+                "authenticated numerical current relation is not topological"
+            )
+        representative = resolved[authenticated.representative_id]
+        factor = _exact_representable_complex_product(
+            authenticated.factor,
+            representative.factor,
+        )
+        if factor is None:
+            raise ValueError(
+                "authenticated numerical current relation factor chain is "
+                "not exactly representable"
+            )
+        resolved.append(
+            _CurrentValueEquivalence(
+                representative_id=representative.representative_id,
+                factor=factor,
+            )
+        )
+        certificate_chains.append(
+            (
+                current.id,
+                *certificate_chains[authenticated.representative_id],
+            )
+        )
+    return tuple(resolved), tuple(certificate_chains)
+
+
+def _numerical_interaction_evaluation_key(
+    dag: GenericDAG,
+    model: Model,
+    interaction: InteractionNode,
+    *,
+    left_id: int,
+    right_id: int,
+    equivalence_by_kind: dict[int, VertexEvaluationEquivalence],
+) -> tuple[_EvaluationKey, _ComplexWeight]:
+    equivalence = _kernel_equivalence(
+        model,
+        interaction.vertex_kind,
+        equivalence_by_kind,
+    )
+    canonical_inputs, kernel_factor = _canonical_kernel_evaluation(
+        equivalence,
+        left_id,
+        right_id,
+    )
+    result = dag.currents[interaction.result_id]
+    return (
+        (
+            equivalence.class_id,
+            canonical_inputs,
+            int(result.index.particle_id),
+            int(result.index.chirality),
+            _runtime_coupling_identity(
+                model,
+                vertex_kind=interaction.vertex_kind,
+                vertex_particles=interaction.vertex_particles,
+                coupling=interaction.coupling,
+            ),
+        ),
+        kernel_factor,
+    )
+
+
+def _project_authenticated_numerical_interaction_reuse(
+    dag: GenericDAG,
+    model: Model,
+    authenticated_relations: Mapping[int, _CurrentValueEquivalence],
+    *,
+    structural_equivalences: tuple[_CurrentValueEquivalence, ...],
+) -> tuple[
+    GenericDAG,
+    tuple[_CurrentValueEquivalence, ...],
+    tuple[tuple[int, ...], ...],
+    dict[int, tuple[int, ...]],
+]:
+    """Monotonically project authenticated current mappings onto interactions."""
+
+    if tuple(interaction.id for interaction in dag.interactions) != tuple(
+        range(len(dag.interactions))
+    ):
+        raise ValueError(
+            "numerical current application requires contiguous interaction IDs"
+        )
+    resolved, certificate_chains = (
+        _resolve_authenticated_numerical_current_relations(
+            dag,
+            authenticated_relations,
+            structural_equivalences=structural_equivalences,
+        )
+    )
+    equivalence_by_kind: dict[int, VertexEvaluationEquivalence] = {}
+    targets_by_key: dict[
+        _EvaluationKey,
+        tuple[int, _ComplexWeight],
+    ] = {}
+    for interaction in dag.interactions:
+        if (
+            interaction.evaluation_factor == (0.0, 0.0)
+            or certificate_chains[interaction.left_id]
+            or certificate_chains[interaction.right_id]
+        ):
+            continue
+        key, kernel_factor = _numerical_interaction_evaluation_key(
+            dag,
+            model,
+            interaction,
+            left_id=interaction.left_id,
+            right_id=interaction.right_id,
+            equivalence_by_kind=equivalence_by_kind,
+        )
+        prior = targets_by_key.get(key)
+        candidate_rank = (
+            interaction.evaluation_group_id is None,
+            interaction.id,
+        )
+        if prior is None:
+            targets_by_key[key] = (interaction.id, kernel_factor)
+            continue
+        prior_interaction = dag.interactions[prior[0]]
+        prior_rank = (
+            prior_interaction.evaluation_group_id is None,
+            prior_interaction.id,
+        )
+        if candidate_rank < prior_rank:
+            targets_by_key[key] = (interaction.id, kernel_factor)
+
+    interactions = list(dag.interactions)
+    next_group_id = 1 + max(
+        (
+            interaction.evaluation_group_id
+            for interaction in dag.interactions
+            if interaction.evaluation_group_id is not None
+        ),
+        default=-1,
+    )
+    projected_interaction_ids: dict[int, list[int]] = defaultdict(list)
+    for interaction in dag.interactions:
+        left = resolved[interaction.left_id]
+        right = resolved[interaction.right_id]
+        left_chain = certificate_chains[interaction.left_id]
+        right_chain = certificate_chains[interaction.right_id]
+        if not left_chain and not right_chain:
+            continue
+
+        if left.factor == (0.0, 0.0) or right.factor == (0.0, 0.0):
+            if interaction.evaluation_factor == (0.0, 0.0):
+                continue
+            interactions[interaction.id] = replace(
+                interaction,
+                evaluation_factor=(0.0, 0.0),
+            )
+            used_chains = (
+                *(left_chain if left.factor == (0.0, 0.0) else ()),
+                *(right_chain if right.factor == (0.0, 0.0) else ()),
+            )
+            for certificate_id in set(used_chains):
+                projected_interaction_ids[certificate_id].append(
+                    interaction.id
+                )
+            continue
+
+        parent_factor = _exact_representable_complex_product(
+            left.factor,
+            right.factor,
+        )
+        if parent_factor is None:
+            continue
+        key, mapped_kernel_factor = _numerical_interaction_evaluation_key(
+            dag,
+            model,
+            interaction,
+            left_id=left.representative_id,
+            right_id=right.representative_id,
+            equivalence_by_kind=equivalence_by_kind,
+        )
+        target = targets_by_key.get(key)
+        if target is None:
+            continue
+        target_id, target_kernel_factor = target
+        target_interaction = interactions[target_id]
+        effective_kernel_factor = _exact_representable_complex_product(
+            mapped_kernel_factor,
+            parent_factor,
+        )
+        if effective_kernel_factor is None:
+            continue
+        relative_factor = _exact_representable_complex_ratio(
+            effective_kernel_factor,
+            target_kernel_factor,
+        )
+        if relative_factor is None:
+            continue
+        evaluation_factor = _exact_representable_complex_product(
+            relative_factor,
+            target_interaction.evaluation_factor,
+        )
+        if evaluation_factor is None or evaluation_factor == (0.0, 0.0):
+            continue
+
+        target_group_id = target_interaction.evaluation_group_id
+        if target_group_id is None:
+            target_group_id = next_group_id
+            next_group_id += 1
+            target_interaction = replace(
+                target_interaction,
+                evaluation_group_id=target_group_id,
+            )
+            interactions[target_id] = target_interaction
+        if interaction.evaluation_group_id == target_group_id:
+            continue
+        interactions[interaction.id] = replace(
+            interaction,
+            evaluation_group_id=target_group_id,
+            evaluation_factor=evaluation_factor,
+        )
+        for certificate_id in set((*left_chain, *right_chain)):
+            projected_interaction_ids[certificate_id].append(interaction.id)
+
+    # A numerical projection may coarsen an existing evaluator partition, but
+    # it must never split one old live group.  If only part of a cached group
+    # found a new target, retain that whole group unchanged and record no
+    # application for those members.
+    members_by_old_group: dict[tuple[str, int], list[int]] = defaultdict(list)
+    for interaction in dag.interactions:
+        if interaction.evaluation_factor == (0.0, 0.0):
+            continue
+        token = (
+            ("group", interaction.evaluation_group_id)
+            if interaction.evaluation_group_id is not None
+            else ("interaction", interaction.id)
+        )
+        members_by_old_group[token].append(interaction.id)
+    reverted_ids: set[int] = set()
+    for member_ids in members_by_old_group.values():
+        projected_live_groups = {
+            (
+                ("group", projected_member.evaluation_group_id)
+                if projected_member.evaluation_group_id is not None
+                else ("interaction", projected_member.id)
+            )
+            for interaction_id in member_ids
+            if (
+                projected_member := interactions[interaction_id]
+            ).evaluation_factor
+            != (0.0, 0.0)
+        }
+        if len(projected_live_groups) <= 1:
+            continue
+        for interaction_id in member_ids:
+            if interactions[interaction_id] != dag.interactions[interaction_id]:
+                interactions[interaction_id] = dag.interactions[
+                    interaction_id
+                ]
+                reverted_ids.add(interaction_id)
+    if reverted_ids:
+        for certificate_id in tuple(projected_interaction_ids):
+            retained = [
+                interaction_id
+                for interaction_id in projected_interaction_ids[
+                    certificate_id
+                ]
+                if interaction_id not in reverted_ids
+            ]
+            if retained:
+                projected_interaction_ids[certificate_id] = retained
+            else:
+                del projected_interaction_ids[certificate_id]
+
+    rewritten = tuple(interactions)
+    projected = (
+        dag
+        if rewritten == dag.interactions
+        else _replace_dag_interactions_preserving_materialization(
+            dag,
+            rewritten,
+        )
+    )
+    if projected.interaction_evaluation_count > dag.interaction_evaluation_count:
+        raise ValueError(
+            "authenticated numerical current application would increase "
+            "the interaction evaluator count"
+        )
+    for member_ids in members_by_old_group.values():
+        projected_live_groups = {
+            (
+                ("group", interaction.evaluation_group_id)
+                if interaction.evaluation_group_id is not None
+                else ("interaction", interaction.id)
+            )
+            for interaction_id in member_ids
+            if (
+                interaction := projected.interactions[interaction_id]
+            ).evaluation_factor
+            != (0.0, 0.0)
+        }
+        if len(projected_live_groups) > 1:
+            raise ValueError(
+                "authenticated numerical current application would split "
+                "an existing evaluator group"
+            )
+    canonical_projected_ids = {
+        certificate_id: tuple(interaction_ids)
+        for certificate_id, interaction_ids in projected_interaction_ids.items()
+    }
+    return projected, resolved, certificate_chains, canonical_projected_ids
+
+
+def _validated_decimal_observations(
+    values: Sequence[tuple[Decimal, Decimal]] | None,
+) -> tuple[tuple[Decimal, Decimal], ...] | None:
+    if values is None or isinstance(values, str | bytes):
+        return None
+    result: list[tuple[Decimal, Decimal]] = []
+    try:
+        for value in values:
+            if (
+                not isinstance(value, tuple)
+                or len(value) != 2
+                or not all(isinstance(component, Decimal) for component in value)
+                or not all(component.is_finite() for component in value)
+            ):
+                return None
+            result.append((value[0], value[1]))
+    except TypeError:
+        return None
+    return tuple(result)
+
+
+def _numerical_relation_residuals(
+    relation_kind: Literal["equal", "opposite", "zero"],
+    current_values: tuple[tuple[Decimal, Decimal], ...],
+    representative_values: tuple[tuple[Decimal, Decimal], ...] | None,
+    *,
+    relative_tolerance: Decimal,
+    absolute_tolerance: Decimal,
+    precision_digits: int,
+) -> tuple[
+    Decimal,
+    Decimal,
+    Decimal,
+    tuple[tuple[Decimal, Decimal], ...],
+] | None:
+    if type(precision_digits) is not int or precision_digits < 80:
+        raise ValueError("numerical residual precision is invalid")
+    with localcontext() as context:
+        context.prec = precision_digits + _NUMERICAL_DECIMAL_GUARD_DIGITS
+        context.rounding = ROUND_HALF_EVEN
+        if relation_kind == "zero":
+            expected = tuple(
+                (Decimal(0), Decimal(0)) for _ in current_values
+            )
+        else:
+            if representative_values is None or len(
+                representative_values
+            ) != len(current_values):
+                return None
+            sign = Decimal(1) if relation_kind == "equal" else Decimal(-1)
+            expected = tuple(
+                (sign * real, sign * imaginary)
+                for real, imaginary in representative_values
+            )
+        maximum_absolute = Decimal(0)
+        maximum_relative = Decimal(0)
+        maximum_tolerance_ratio = Decimal(0)
+        component_checks: list[tuple[Decimal, Decimal]] = []
+        for current, reference in zip(
+            current_values,
+            expected,
+            strict=True,
+        ):
+            difference = max(
+                abs(current[0] - reference[0]),
+                abs(current[1] - reference[1]),
+            )
+            scale = max(
+                abs(current[0]),
+                abs(current[1]),
+                abs(reference[0]),
+                abs(reference[1]),
+            )
+            relative = (
+                Decimal(0)
+                if difference == 0
+                else difference / max(scale, absolute_tolerance)
+            )
+            maximum_absolute = max(maximum_absolute, difference)
+            maximum_relative = max(maximum_relative, relative)
+            allowed = absolute_tolerance + relative_tolerance * scale
+            tolerance_ratio = (
+                Decimal(0) if difference == 0 else difference / allowed
+            )
+            maximum_tolerance_ratio = max(
+                maximum_tolerance_ratio,
+                tolerance_ratio,
+            )
+            component_checks.append((difference, allowed))
+        return (
+            maximum_absolute,
+            maximum_relative,
+            maximum_tolerance_ratio,
+            tuple(component_checks),
+        )
+
+
+def _numerical_relation_residuals_pass(
+    residuals: tuple[
+        Decimal,
+        Decimal,
+        Decimal,
+        tuple[tuple[Decimal, Decimal], ...],
+    ],
+    *,
+    precision_digits: int,
+) -> bool:
+    if type(precision_digits) is not int or precision_digits < 80:
+        raise ValueError("numerical residual precision is invalid")
+    with localcontext() as context:
+        context.prec = precision_digits + _NUMERICAL_DECIMAL_GUARD_DIGITS
+        context.rounding = ROUND_HALF_EVEN
+        return all(
+            difference <= allowed
+            for difference, allowed in residuals[3]
+        )
+
+
+def _numerical_observations_sha256(
+    *,
+    relation_kind: str,
+    current_values: tuple[tuple[Decimal, Decimal], ...],
+    representative_values: tuple[tuple[Decimal, Decimal], ...] | None,
+) -> str:
+    return _canonical_payload_sha256(
+        {
+            "relation_kind": relation_kind,
+            "current": [
+                [
+                    _canonical_decimal_string(real),
+                    _canonical_decimal_string(imaginary),
+                ]
+                for real, imaginary in current_values
+            ],
+            "representative": (
+                None
+                if representative_values is None
+                else [
+                    [
+                        _canonical_decimal_string(real),
+                        _canonical_decimal_string(imaginary),
+                    ]
+                    for real, imaginary in representative_values
+                ]
+            ),
+        }
+    )
+
+
+def _canonical_decimal_string(value: Decimal) -> str:
+    if not value.is_finite():
+        raise ValueError("canonical Decimal serialization requires finiteness")
+    sign, digits, exponent = value.as_tuple()
+    if not any(digits):
+        return "0"
+    if not isinstance(exponent, int):
+        raise ValueError("canonical Decimal serialization requires an exponent")
+    coefficient = "".join(str(digit) for digit in digits)
+    return f"{'-' if sign else ''}{coefficient}e{exponent}"
+
+
+def _is_sha256(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and len(value) == 64
+        and all(character in "0123456789abcdef" for character in value)
+    )
+
+
+def _decode_numerical_relation_factor(
+    relation_kind: object,
+    representative_id: object,
+    payload: object,
+) -> _ComplexWeight | None:
+    expected: _ComplexWeight | None
+    if relation_kind == "zero":
+        if representative_id is not None or payload is not None:
+            raise ValueError("zero-current relation cannot have a representative")
+        return None
+    if relation_kind == "equal":
+        expected = (1.0, 0.0)
+    elif relation_kind == "opposite":
+        expected = (-1.0, 0.0)
+    else:
+        raise ValueError("unsupported numerical current relation kind")
+    if (
+        type(representative_id) is not int
+        or not isinstance(payload, list)
+        or len(payload) != 2
+        or any(not isinstance(component, str) for component in payload)
+    ):
+        raise ValueError("numerical current relation factor is malformed")
+    try:
+        decoded = (float.fromhex(payload[0]), float.fromhex(payload[1]))
+    except ValueError as error:
+        raise ValueError("numerical current relation factor is malformed") from error
+    if not _complex_weight_bits_equal(decoded, expected):
+        raise ValueError("numerical current relation factor disagrees with its kind")
+    return expected
+
+
+@dataclass(frozen=True, slots=True)
+class RelationDiscoveryReport:
+    """Mode- and colour-scoped outcome of one opt-in discovery pass."""
+
+    requested_mode: str
+    state: str
+    execution_mode: str
+    color_accuracy: str
+    representation: str
+    precision_digits: int
+    probe_count: int
+    seed: int
+    probe_status: str
+    certificate_replay_status: str
+    numerical_candidate_count: int
+    uncertified_candidate_count: int
+    exact_certified_relation_count: int
+    applied_relation_count: int
+    interaction_evaluation_count_before: int | None
+    interaction_evaluation_count_after: int | None
+    certificates: tuple[ExactCurrentRelationCertificate, ...] = ()
+    rejected_candidates: tuple[dict[str, object], ...] = ()
+    rejected_decision_sha256: str = ""
+    follow_up_boundary: str | None = None
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "schema_version": RELATION_DISCOVERY_SCHEMA_VERSION,
+            "requested_mode": self.requested_mode,
+            "state": self.state,
+            "scope": {
+                "execution_mode": self.execution_mode,
+                "color_accuracy": self.color_accuracy,
+                "representation": self.representation,
+            },
+            "probe": {
+                "status": self.probe_status,
+                "precision_digits": self.precision_digits,
+                "probe_count": self.probe_count,
+                "seed": self.seed,
+                "deterministic": True,
+                "candidate_only": True,
+            },
+            "certificate_replay": {
+                "algorithm": RELATION_DISCOVERY_CERTIFICATE_ALGORITHM,
+                "status": self.certificate_replay_status,
+            },
+            "numerical_candidate_count": self.numerical_candidate_count,
+            "uncertified_candidate_count": self.uncertified_candidate_count,
+            "rejected_hypothesis_count": self.uncertified_candidate_count,
+            "exact_certified_relation_count": (self.exact_certified_relation_count),
+            "applied_relation_count": self.applied_relation_count,
+            "interaction_evaluation_count_before": (
+                self.interaction_evaluation_count_before
+            ),
+            "interaction_evaluation_count_after": (
+                self.interaction_evaluation_count_after
+            ),
+            "interaction_evaluation_savings": (
+                None
+                if self.interaction_evaluation_count_before is None
+                or self.interaction_evaluation_count_after is None
+                else max(
+                    0,
+                    self.interaction_evaluation_count_before
+                    - self.interaction_evaluation_count_after,
+                )
+            ),
+            "certificates": [
+                certificate.to_json_dict() for certificate in self.certificates
+            ],
+            "rejected_candidates": list(self.rejected_candidates),
+            "rejected_candidate_diagnostics": (
+                _rejected_candidate_diagnostics(
+                    self.rejected_candidates,
+                    total_rejected=self.uncertified_candidate_count,
+                    full_census={
+                        "requested_mode": self.requested_mode,
+                        "numerical_candidate_count": (
+                            self.numerical_candidate_count
+                        ),
+                        "uncertified_candidate_count": (
+                            self.uncertified_candidate_count
+                        ),
+                        "rejected_hypothesis_count": (
+                            self.uncertified_candidate_count
+                        ),
+                        "exact_certified_relation_count": (
+                            self.exact_certified_relation_count
+                        ),
+                        "applied_relation_count": self.applied_relation_count,
+                        "rejection_decision_sha256": (
+                            self.rejected_decision_sha256
+                        ),
+                    },
+                    full_rejection_sha256=self.rejected_decision_sha256,
+                )
+            ),
+            "follow_up_boundary": self.follow_up_boundary,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class RelationDiscoveryResult:
+    dag: GenericDAG
+    report: RelationDiscoveryReport
+
+
+class _NumericalRelationDiscovery:
+    """Nominate projective pairs numerically, then require an exact replay."""
+
+    def __init__(
+        self,
+        *,
+        precision_digits: int,
+        probe_count: int,
+        seed: int,
+    ) -> None:
+        if precision_digits < 80:
+            raise ValueError("relation discovery precision must be at least 80 digits")
+        if probe_count < 2:
+            raise ValueError("relation discovery requires at least two probe points")
+        if seed < 0:
+            raise ValueError("relation discovery seed must be nonnegative")
+        self.precision_digits = int(precision_digits)
+        self.probe_count = int(probe_count)
+        self.seed = int(seed)
+        self.numerical_candidate_count = 0
+        self.uncertified_candidate_count = 0
+        self.certificates: list[ExactCurrentRelationCertificate] = []
+        self.rejected_candidates: list[dict[str, object]] = []
+        self.rejected_decision_sha256 = _canonical_payload_sha256(
+            {
+                "abi": "pyamplicol-exact-rejected-decision-chain-v1",
+                "precision_digits": self.precision_digits,
+                "probe_count": self.probe_count,
+                "seed": self.seed,
+            }
+        )
+        self._representatives_by_fingerprint: dict[
+            tuple[_CurrentContract, tuple[object, ...]],
+            list[tuple[int, _CurrentTermVector]],
+        ] = {}
+
+    def record_rejected(self, row: Mapping[str, object]) -> None:
+        payload = dict(row)
+        self.rejected_decision_sha256 = _advance_rejection_digest(
+            self.rejected_decision_sha256,
+            payload,
+        )
+        if len(self.rejected_candidates) < _MAX_REJECTED_DIAGNOSTICS:
+            self.rejected_candidates.append(payload)
+
+    def consider(
+        self,
+        *,
+        current_id: int,
+        contract: _CurrentContract,
+        term_vector: _CurrentTermVector,
+        baseline: _CurrentValueEquivalence,
+    ) -> _CurrentValueEquivalence:
+        fingerprint = _numerical_projective_fingerprint(
+            term_vector,
+            precision_digits=self.precision_digits,
+            probe_count=self.probe_count,
+            seed=self.seed,
+        )
+        if fingerprint is None:
+            return baseline
+        key = (contract, fingerprint)
+        representatives = self._representatives_by_fingerprint.setdefault(key, [])
+
+        promoted = baseline
+        if baseline.representative_id == current_id and baseline.factor == (1.0, 0.0):
+            exact_matches: list[tuple[int, _ComplexWeight, _CurrentTermVector]] = []
+            for representative_id, representative_vector in representatives:
+                self.numerical_candidate_count += 1
+                factor = _certify_exact_term_vector_relation(
+                    representative_vector,
+                    term_vector,
+                )
+                if factor is None:
+                    self.uncertified_candidate_count += 1
+                    self.record_rejected(
+                        {
+                            "current_id": current_id,
+                            "representative_id": representative_id,
+                            "reason": "numerical-candidate-lacks-exact-certificate",
+                        }
+                    )
+                    continue
+                exact_matches.append((representative_id, factor, representative_vector))
+            if exact_matches:
+                representative_id, factor, representative_vector = min(
+                    exact_matches,
+                    key=lambda item: item[0],
+                )
+                certificate = _build_exact_current_relation_certificate(
+                    current_id=current_id,
+                    representative_id=representative_id,
+                    factor=factor,
+                    current_term_vector=term_vector,
+                    representative_term_vector=representative_vector,
+                )
+                self.certificates.append(certificate)
+                promoted = _CurrentValueEquivalence(
+                    representative_id=representative_id,
+                    factor=factor,
+                )
+
+        representatives.append((current_id, term_vector))
+        return promoted
+
+
+class RecursiveEvaluationReuseTracker:
+    """Certify recursive-current reuse as external subsets are completed."""
+
+    def __init__(self, model: Model) -> None:
+        self._model = model
+        self._kernel_equivalences: dict[int, VertexEvaluationEquivalence] = {}
+        self._runtime_coupling_identities: dict[
+            tuple[int, tuple[int, int, int], tuple[float, float]],
+            tuple[tuple[float, float], tuple[tuple[int, str], ...]],
+        ] = {}
+        self._current_equivalences: list[_CurrentValueEquivalence] = []
+        self._source_representative_by_key: dict[tuple[object, ...], int] = {}
+        self._equivalence_by_expression: dict[
+            tuple[_CurrentContract, _CurrentTermVector], _CurrentValueEquivalence
+        ] = {}
+        self._projective_representatives_by_expression: dict[
+            tuple[_CurrentContract, _CurrentTermVector],
+            list[_ProjectiveExpressionRepresentative],
+        ] = {}
+        self._evaluation_group_by_key: dict[_EvaluationKey, int] = {}
+        self._coefficients_by_result: list[
+            dict[int, _ComplexWeight | list[_ComplexWeight]] | None
+        ] = []
+
+    def register_source(self, current: CurrentNode) -> None:
+        if not current.is_source:
+            raise ValueError("recursive-reuse source registration requires a source")
+        if current.source_leg_label is None or current.source_helicity is None:
+            raise ValueError(
+                f"source current {current.id} lacks physical source metadata"
+            )
+        contract = _current_evaluation_contract(current)
+        source_key = (
+            contract,
+            int(current.source_leg_label),
+            int(current.source_helicity),
+        )
+        representative_id = self._source_representative_by_key.setdefault(
+            source_key,
+            current.id,
+        )
+        self._append_current_equivalence(
+            current,
+            _CurrentValueEquivalence(representative_id, (1.0, 0.0)),
+        )
+
+    def interaction_evaluation(
+        self,
+        *,
+        vertex_kind: int,
+        vertex_particles: tuple[int, int, int],
+        left_id: int,
+        right_id: int,
+        result: CurrentNode,
+        coupling: tuple[float, float],
+        color_weight: _ComplexWeight,
+    ) -> tuple[int, _ComplexWeight]:
+        kernel_equivalence = _kernel_equivalence(
+            self._model,
+            vertex_kind,
+            self._kernel_equivalences,
+        )
+        try:
+            left = self._current_equivalences[left_id]
+            right = self._current_equivalences[right_id]
+        except IndexError as error:
+            raise ValueError(
+                "online recursive reuse requires completed parent subsets"
+            ) from error
+        canonical_inputs, evaluation_factor = _canonical_interaction_evaluation(
+            kernel_equivalence,
+            left_id=left_id,
+            right_id=right_id,
+            left=left,
+            right=right,
+        )
+        coupling_key = (vertex_kind, vertex_particles, coupling)
+        coupling_identity = self._runtime_coupling_identities.get(coupling_key)
+        if coupling_identity is None:
+            coupling_identity = _runtime_coupling_identity(
+                self._model,
+                vertex_kind=vertex_kind,
+                vertex_particles=vertex_particles,
+                coupling=coupling,
+            )
+            self._runtime_coupling_identities[coupling_key] = coupling_identity
+        evaluation_key = (
+            kernel_equivalence.class_id,
+            canonical_inputs,
+            int(result.index.particle_id),
+            int(result.index.chirality),
+            coupling_identity,
+        )
+        evaluation_group_id = self._evaluation_group_by_key.setdefault(
+            evaluation_key,
+            len(self._evaluation_group_by_key),
+        )
+        if result.id >= len(self._coefficients_by_result):
+            self._coefficients_by_result.extend(
+                [None] * (result.id + 1 - len(self._coefficients_by_result))
+            )
+        coefficients_by_group = self._coefficients_by_result[result.id]
+        if coefficients_by_group is None:
+            coefficients_by_group = {}
+            self._coefficients_by_result[result.id] = coefficients_by_group
+        coefficient = _complex_weight_mul(color_weight, evaluation_factor)
+        coefficients = coefficients_by_group.get(evaluation_group_id)
+        if coefficients is None:
+            coefficients_by_group[evaluation_group_id] = coefficient
+        elif isinstance(coefficients, list):
+            coefficients.append(coefficient)
+        else:
+            coefficients_by_group[evaluation_group_id] = [coefficients, coefficient]
+        return evaluation_group_id, evaluation_factor
+
+    def finalize_currents(
+        self,
+        currents: Iterable[CurrentNode],
+    ) -> None:
+        for current in currents:
+            if current.is_source:
+                raise ValueError("generated-current finalization received a source")
+            coefficients_by_group = self._coefficients_by_result[current.id]
+            self._coefficients_by_result[current.id] = None
+            terms: list[tuple[_EvaluationKey, _ComplexWeight]] = []
+            for group_id in sorted(coefficients_by_group or ()):
+                assert coefficients_by_group is not None
+                coefficients = coefficients_by_group[group_id]
+                if isinstance(coefficients, list):
+                    coefficient = (
+                        _canonical_zero(fsum(value[0] for value in coefficients)),
+                        _canonical_zero(fsum(value[1] for value in coefficients)),
+                    )
+                else:
+                    coefficient = _canonical_complex_weight(coefficients)
+                if coefficient != (0.0, 0.0):
+                    terms.append(((group_id,), coefficient))
+            term_vector = tuple(terms)
+            contract = _current_evaluation_contract(current)
+            equivalence = _classify_current_term_vector(
+                current_id=current.id,
+                contract=contract,
+                term_vector=term_vector,
+                equivalence_by_expression=self._equivalence_by_expression,
+                projective_representatives_by_expression=(
+                    self._projective_representatives_by_expression
+                ),
+            )
+            self._append_current_equivalence(
+                current,
+                equivalence,
+            )
+
+    def _append_current_equivalence(
+        self,
+        current: CurrentNode,
+        equivalence: _CurrentValueEquivalence,
+    ) -> None:
+        if current.id != len(self._current_equivalences):
+            raise ValueError(
+                "online recursive reuse requires currents in contiguous ID order"
+            )
+        self._current_equivalences.append(equivalence)
+        if current.id >= len(self._coefficients_by_result):
+            self._coefficients_by_result.append(None)
+
+
+def _canonical_kernel_evaluation(
+    equivalence: VertexEvaluationEquivalence,
+    left_id: int,
+    right_id: int,
+) -> tuple[tuple[int, int], _ComplexWeight]:
+    """Return canonical representative inputs and the concrete-kernel factor."""
+
+    canonical_inputs = (left_id, right_id)
+    if equivalence.input_order == (1, 0):
+        canonical_inputs = (right_id, left_id)
+    factor = equivalence.factor
+    if (
+        equivalence.input_exchange_factor is not None
+        and canonical_inputs[1] < canonical_inputs[0]
+    ):
+        canonical_inputs = (canonical_inputs[1], canonical_inputs[0])
+        factor = _complex_weight_mul(
+            factor,
+            equivalence.input_exchange_factor,
+        )
+    return canonical_inputs, factor
+
+
+def _canonical_interaction_evaluation(
+    equivalence: VertexEvaluationEquivalence,
+    *,
+    left_id: int,
+    right_id: int,
+    left: _CurrentValueEquivalence,
+    right: _CurrentValueEquivalence,
+) -> tuple[tuple[int, int], _ComplexWeight]:
+    """Compose recursive factors exactly or retain the concrete inputs.
+
+    Projective equivalence is an exact statement about the ideal algebraic
+    current.  Its recursive factor may be moved through another kernel only
+    when both complex products remain finite and exactly representable as
+    binary64.  Otherwise this interaction fails closed to its concrete parent
+    IDs while retaining the pre-existing model-certified kernel symmetry.
+    """
+
+    canonical_inputs, kernel_factor = _canonical_kernel_evaluation(
+        equivalence,
+        left.representative_id,
+        right.representative_id,
+    )
+    parent_factor = _exact_representable_complex_product(left.factor, right.factor)
+    if parent_factor is not None:
+        evaluation_factor = _exact_representable_complex_product(
+            kernel_factor,
+            parent_factor,
+        )
+        if evaluation_factor is not None:
+            return canonical_inputs, evaluation_factor
+    return _canonical_kernel_evaluation(equivalence, left_id, right_id)
+
+
+def assign_recursive_current_evaluation_reuse(
+    dag: GenericDAG,
+    model: Model,
+) -> GenericDAG:
+    """Share kernel evaluations through exactly proven current equivalences.
+
+    The proof is recursive.  Duplicate source wavefunctions form the base
+    classes.  A generated current joins an existing class only when its full
+    vector of model-certified kernel terms and coefficients is byte-exactly
+    equal, opposite, or algebraically projective through a finite nonzero
+    binary64 factor whose coefficient reconstruction is bit-exact.  Moving a
+    general projective factor changes floating-point association, so runtime
+    parity remains a tolerance-checked numerical contract rather than a claim
+    of bit-identical materialized currents.  Recursive factor products fail
+    closed unless they are finite and exactly representable.  The current
+    contract keeps every field consumed by source, kernel, and propagator
+    evaluation.  In particular, ordered external labels and helicity
+    ancestry remain part of the contract: both encode physical runtime
+    routing and cannot be inferred from the sorted external-label set.
+    Dynamic colour-sector bookkeeping is deliberately excluded.  Input
+    ordering may differ only through the exact model-certified permutation
+    and reflection factors included in the term signature below.
+
+    This recovers AmpliCol-style reflection fan-out, but also recognizes exact
+    reuse across colour sectors and helicity subgraphs.  No approximate
+    numerical comparison or process/model-family classification is involved.
+    """
+
+    if not dag.interactions:
+        return dag
+
+    equivalence_by_kind: dict[int, VertexEvaluationEquivalence] = {}
+    current_equivalences = _derive_current_value_equivalences(
+        dag,
+        model,
+        equivalence_by_kind=equivalence_by_kind,
+    )
+    return _rewrite_interaction_evaluation_reuse(
+        dag,
+        model,
+        current_equivalences=current_equivalences,
+        equivalence_by_kind=equivalence_by_kind,
+    )
+
+
+def discover_recursive_evaluation_relations(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    mode: _DiscoveryMode,
+    execution_mode: Literal["compiled", "eager"],
+    precision_digits: int = 96,
+    probe_count: int = 4,
+    seed: int = 0x5059414D,
+) -> RelationDiscoveryResult:
+    """Discover candidates numerically and promote only exact DAG relations.
+
+    Probe values are deterministic high-precision synthetic evaluations of the
+    full current term vectors. They are candidate indexes only. Every promoted
+    relation is independently replayed over the complete binary64 coefficient
+    vectors, and unsafe recursive factor composition continues to fail closed.
+    """
+
+    if mode not in {"diagnostic", "certified-reuse"}:
+        raise ValueError(f"unsupported relation discovery mode {mode!r}")
+    if execution_mode not in {"compiled", "eager"}:
+        raise ValueError(
+            "GenericDAG relation discovery supports compiled and eager execution"
+        )
+
+    baseline = assign_recursive_current_evaluation_reuse(dag, model)
+    discovery = _NumericalRelationDiscovery(
+        precision_digits=precision_digits,
+        probe_count=probe_count,
+        seed=seed,
+    )
+    equivalence_by_kind: dict[int, VertexEvaluationEquivalence] = {}
+    current_equivalences = _derive_current_value_equivalences(
+        dag,
+        model,
+        equivalence_by_kind=equivalence_by_kind,
+        discovery=discovery,
+    )
+    promoted = _rewrite_interaction_evaluation_reuse(
+        dag,
+        model,
+        current_equivalences=current_equivalences,
+        equivalence_by_kind=equivalence_by_kind,
+    )
+    if discovery.certificates and not verify_dag_relation_certificates(
+        dag,
+        model,
+        discovery.certificates,
+    ):
+        discovery.uncertified_candidate_count += len(discovery.certificates)
+        for certificate in discovery.certificates:
+            discovery.record_rejected(
+                {
+                    "reason": "exact-certificate-chain-replay-failed",
+                    "current_id": certificate.current_id,
+                    "representative_id": certificate.representative_id,
+                }
+            )
+        discovery.certificates.clear()
+        promoted = baseline
+    interaction_changed = _interaction_reuse_signature(
+        promoted
+    ) != _interaction_reuse_signature(baseline)
+    apply_promotions = (
+        mode == "certified-reuse"
+        and bool(discovery.certificates)
+        and interaction_changed
+    )
+    result_dag = promoted if apply_promotions else dag
+    report = RelationDiscoveryReport(
+        requested_mode=mode,
+        state=("exact-certified-applied" if apply_promotions else "diagnostic-only"),
+        execution_mode=execution_mode,
+        color_accuracy=str(dag.process.color_accuracy),
+        representation="generic-dag",
+        precision_digits=precision_digits,
+        probe_count=probe_count,
+        seed=seed,
+        probe_status="completed",
+        certificate_replay_status=(
+            "verified" if discovery.certificates else "no-certified-relations"
+        ),
+        numerical_candidate_count=discovery.numerical_candidate_count,
+        uncertified_candidate_count=discovery.uncertified_candidate_count,
+        exact_certified_relation_count=len(discovery.certificates),
+        applied_relation_count=(len(discovery.certificates) if apply_promotions else 0),
+        interaction_evaluation_count_before=baseline.interaction_evaluation_count,
+        interaction_evaluation_count_after=(
+            promoted.interaction_evaluation_count
+            if apply_promotions or mode == "diagnostic"
+            else baseline.interaction_evaluation_count
+        ),
+        certificates=tuple(discovery.certificates),
+        rejected_candidates=tuple(discovery.rejected_candidates),
+        rejected_decision_sha256=discovery.rejected_decision_sha256,
+        follow_up_boundary=(
+            "direct vertex-kernel equivalence remains model-certificate-owned; "
+            "this pass promotes exact current proportionality and its induced "
+            "interaction fan-out only"
+        ),
+    )
+    return RelationDiscoveryResult(dag=result_dag, report=report)
+
+
+def _rewrite_interaction_evaluation_reuse(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    current_equivalences: tuple[_CurrentValueEquivalence, ...],
+    equivalence_by_kind: dict[int, VertexEvaluationEquivalence],
+) -> GenericDAG:
+    evaluation_group_by_key: dict[_EvaluationKey, int] = {}
+    interactions: list[InteractionNode] = []
+
+    for interaction in dag.interactions:
+        kernel_equivalence = _kernel_equivalence(
+            model,
+            interaction.vertex_kind,
+            equivalence_by_kind,
+        )
+        left = current_equivalences[interaction.left_id]
+        right = current_equivalences[interaction.right_id]
+        canonical_inputs, evaluation_factor = _canonical_interaction_evaluation(
+            kernel_equivalence,
+            left_id=interaction.left_id,
+            right_id=interaction.right_id,
+            left=left,
+            right=right,
+        )
+        result = dag.currents[interaction.result_id]
+        evaluation_key = (
+            kernel_equivalence.class_id,
+            canonical_inputs,
+            int(result.index.particle_id),
+            int(result.index.chirality),
+            _runtime_coupling_identity(
+                model,
+                vertex_kind=interaction.vertex_kind,
+                vertex_particles=interaction.vertex_particles,
+                coupling=interaction.coupling,
+            ),
+        )
+        evaluation_group_id = evaluation_group_by_key.setdefault(
+            evaluation_key,
+            len(evaluation_group_by_key),
+        )
+        interactions.append(
+            replace(
+                interaction,
+                evaluation_group_id=evaluation_group_id,
+                evaluation_factor=evaluation_factor,
+            )
+        )
+
+    rewritten = tuple(interactions)
+    if rewritten == dag.interactions:
+        return dag
+    return _replace_dag_interactions_preserving_materialization(dag, rewritten)
+
+
+def _replace_dag_interactions_preserving_materialization(
+    dag: GenericDAG,
+    interactions: tuple[InteractionNode, ...],
+) -> GenericDAG:
+    """Replace evaluation metadata without invalidating a quotient witness."""
+
+    materialization = dag.helicity_materialization
+    if materialization is None:
+        return replace(dag, interactions=interactions)
+    rebound_dag = replace(
+        dag,
+        interactions=interactions,
+        helicity_materialization=None,
+    )
+    rebound_materialization = replace(materialization, dag=rebound_dag)
+    return replace(
+        rebound_dag,
+        helicity_materialization=rebound_materialization,
+    )
+
+
+def _canonical_sha256(value: object) -> str:
+    payload = json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=True,
+    ).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _resolved_root_color_sector_id(dag: GenericDAG, root: AmplitudeRoot) -> int:
+    """Resolve the physical sector before any representative is selected."""
+
+    if root.color_sector_id is not None:
+        return int(root.color_sector_id)
+    return int(dag.currents[root.left_id].index.color_state.sector_id)
+
+
+def _downstream_color_selector_domains(
+    dag: GenericDAG,
+) -> tuple[tuple[int, ...], ...]:
+    """Return the complete physical LC selector domain of every current."""
+
+    domains: list[set[int]] = [set() for _current in dag.currents]
+    for root in dag.amplitude_roots:
+        sector_id = _resolved_root_color_sector_id(dag, root)
+        domains[root.left_id].add(sector_id)
+        domains[root.right_id].add(sector_id)
+    for interaction in reversed(dag.interactions):
+        result_domains = domains[interaction.result_id]
+        if not result_domains:
+            continue
+        domains[interaction.left_id].update(result_domains)
+        domains[interaction.right_id].update(result_domains)
+    return tuple(tuple(sorted(values)) for values in domains)
+
+
+def _dynamic_color_projection_key(
+    current: CurrentNode,
+    selector_domains: tuple[int, ...],
+) -> tuple[object, ...]:
+    """Return exact current identity with only dynamic LC sector omitted.
+
+    ``basis_key`` participates in coherent amplitude grouping and eager
+    metadata, while ``line_groups`` is the exact open-colour identity.  Both
+    therefore remain invariant within a projected class.  The lowerings use
+    particle/chirality/momentum plus the explicit row identity for numerical
+    kernels; the retained representative sector is metadata only after every
+    amplitude root has received its pre-projection resolved sector.
+    """
+
+    index = current.index
+    return (
+        int(index.particle_id),
+        int(index.external_mask),
+        index.external_labels,
+        index.ordered_external_labels,
+        int(index.helicity_ancestry),
+        int(index.chirality),
+        index.spin_state,
+        index.flavour_flow,
+        index.quantum_number_flow,
+        index.color_state.accuracy,
+        index.color_state.line_groups,
+        index.color_state.basis_key,
+        int(index.momentum_mask),
+        index.coupling_orders,
+        index.auxiliary_kind,
+        int(current.dimension),
+        selector_domains,
+    )
+
+
+def _projection_partition(
+    dag: GenericDAG,
+    selector_domains: tuple[tuple[int, ...], ...],
+    split_current_ids: set[int],
+) -> tuple[tuple[tuple[int, ...], ...], tuple[int, ...]]:
+    grouped: dict[tuple[object, ...], list[int]] = defaultdict(list)
+    for current in dag.currents:
+        # External source rows remain singleton.  Their physical source route
+        # is an initialization contract, not a multilinear recurrence row.
+        if current.is_source or current.id in split_current_ids:
+            key = ("singleton", current.id)
+        else:
+            key = (
+                "dynamic-color",
+                _dynamic_color_projection_key(
+                    current,
+                    selector_domains[current.id],
+                ),
+            )
+        grouped[key].append(current.id)
+    classes = tuple(
+        sorted(
+            (tuple(sorted(members)) for members in grouped.values()),
+            key=lambda members: (
+                len(dag.currents[members[0]].index.external_labels),
+                members[0],
+            ),
+        )
+    )
+    class_by_current = [-1] * len(dag.currents)
+    for class_id, members in enumerate(classes):
+        for current_id in members:
+            class_by_current[current_id] = class_id
+    if any(class_id < 0 for class_id in class_by_current):
+        raise ValueError("dynamic-color projection left a current unpartitioned")
+    return classes, tuple(class_by_current)
+
+
+def _interaction_projection_key(
+    interaction: InteractionNode,
+    class_by_current: tuple[int, ...],
+    *,
+    keep_row_distinct: bool,
+) -> tuple[object, ...]:
+    return (
+        class_by_current[interaction.result_id],
+        class_by_current[interaction.left_id],
+        class_by_current[interaction.right_id],
+        int(interaction.vertex_kind),
+        interaction.vertex_particles,
+        interaction.coupling,
+        interaction.color_weight,
+        interaction.lowering_backend,
+        bool(interaction.full_tensor_network_ready),
+        interaction.id if keep_row_distinct else None,
+    )
+
+
+def _root_projection_key(
+    dag: GenericDAG,
+    root: AmplitudeRoot,
+    class_by_current: tuple[int, ...],
+    *,
+    keep_row_distinct: bool,
+) -> tuple[object, ...]:
+    return (
+        class_by_current[root.left_id],
+        class_by_current[root.right_id],
+        root.kind,
+        root.color_weight,
+        root.contraction_ir,
+        _resolved_root_color_sector_id(dag, root),
+        root.vertex_kind,
+        root.vertex_particles,
+        root.coupling,
+        float(root.helicity_weight),
+        root.id if keep_row_distinct else None,
+    )
+
+
+def _projection_groups(
+    dag: GenericDAG,
+    classes: tuple[tuple[int, ...], ...],
+    class_by_current: tuple[int, ...],
+) -> tuple[
+    dict[tuple[object, ...], list[InteractionNode]],
+    dict[tuple[object, ...], list[AmplitudeRoot]],
+]:
+    interaction_groups: dict[tuple[object, ...], list[InteractionNode]] = defaultdict(
+        list
+    )
+    for interaction in dag.interactions:
+        involved = (
+            class_by_current[interaction.result_id],
+            class_by_current[interaction.left_id],
+            class_by_current[interaction.right_id],
+        )
+        keep_distinct = all(len(classes[class_id]) == 1 for class_id in involved)
+        interaction_groups[
+            _interaction_projection_key(
+                interaction,
+                class_by_current,
+                keep_row_distinct=keep_distinct,
+            )
+        ].append(interaction)
+
+    root_groups: dict[tuple[object, ...], list[AmplitudeRoot]] = defaultdict(list)
+    for root in dag.amplitude_roots:
+        involved = (
+            class_by_current[root.left_id],
+            class_by_current[root.right_id],
+        )
+        keep_distinct = all(len(classes[class_id]) == 1 for class_id in involved)
+        root_groups[
+            _root_projection_key(
+                dag,
+                root,
+                class_by_current,
+                keep_row_distinct=keep_distinct,
+            )
+        ].append(root)
+    return interaction_groups, root_groups
+
+
+def _invalid_projection_classes(
+    dag: GenericDAG,
+    classes: tuple[tuple[int, ...], ...],
+    class_by_current: tuple[int, ...],
+    interaction_groups: dict[tuple[object, ...], list[InteractionNode]],
+    root_groups: dict[tuple[object, ...], list[AmplitudeRoot]],
+) -> set[int]:
+    """Return every non-singleton class implicated in a non-rectangle."""
+
+    invalid: set[int] = set()
+    produced_by_class: dict[int, set[int]] = defaultdict(set)
+    for rows in interaction_groups.values():
+        first = rows[0]
+        result_class = class_by_current[first.result_id]
+        left_class = class_by_current[first.left_id]
+        right_class = class_by_current[first.right_id]
+        produced_by_class[result_class].update(row.result_id for row in rows)
+        if all(
+            len(classes[class_id]) == 1
+            for class_id in (result_class, left_class, right_class)
+        ):
+            continue
+        actual = [(row.left_id, row.right_id) for row in rows]
+        expected = {
+            (left_id, right_id)
+            for left_id in classes[left_class]
+            for right_id in classes[right_class]
+        }
+        if len(actual) != len(set(actual)) or set(actual) != expected:
+            invalid.update(
+                class_id
+                for class_id in (result_class, left_class, right_class)
+                if len(classes[class_id]) > 1
+            )
+
+    for class_id, members in enumerate(classes):
+        if len(members) == 1 or dag.currents[members[0]].is_source:
+            continue
+        if produced_by_class.get(class_id, set()) != set(members):
+            invalid.add(class_id)
+
+    for roots in root_groups.values():
+        first = roots[0]
+        left_class = class_by_current[first.left_id]
+        right_class = class_by_current[first.right_id]
+        if len(classes[left_class]) == len(classes[right_class]) == 1:
+            continue
+        actual = [(root.left_id, root.right_id) for root in roots]
+        expected = {
+            (left_id, right_id)
+            for left_id in classes[left_class]
+            for right_id in classes[right_class]
+        }
+        if len(actual) != len(set(actual)) or set(actual) != expected:
+            invalid.update(
+                class_id
+                for class_id in (left_class, right_class)
+                if len(classes[class_id]) > 1
+            )
+    return invalid
+
+
+_DYNAMIC_COLOR_PROJECTION_ABI = (
+    "pyamplicol-generic-dag-dynamic-color-projection-v2"
+)
+_RETAINED_COLOR_METADATA_POLICY = (
+    "accuracy-line-groups-basis-key-identical; representative-sector-metadata-only"
+)
+_ROOT_SECTOR_POLICY = (
+    "pre-projection-resolved-sector-is-explicit-and-never-cross-projected"
+)
+
+
+def dynamic_color_projection_not_applicable_report(
+    dag: GenericDAG,
+) -> dict[str, object]:
+    """Return a count-only report when the LC-only projection cannot apply."""
+
+    if dag.process.color_accuracy == "lc":
+        raise ValueError("LC DAGs require the dynamic-color projection pass")
+    return {
+        "abi": _DYNAMIC_COLOR_PROJECTION_ABI,
+        "applied": False,
+        "color_accuracy": str(dag.process.color_accuracy),
+        "equality_check_status": "not-applicable-color-accuracy",
+        "before_current_count": len(dag.currents),
+        "after_current_count": len(dag.currents),
+        "before_interaction_count": len(dag.interactions),
+        "after_interaction_count": len(dag.interactions),
+        "before_evaluation_count": dag.interaction_evaluation_count,
+        "after_evaluation_count": dag.interaction_evaluation_count,
+        "before_amplitude_root_count": len(dag.amplitude_roots),
+        "after_amplitude_root_count": len(dag.amplitude_roots),
+    }
+
+
+def _initial_dynamic_color_projection_certificate(
+    dag: GenericDAG,
+    *,
+    source_revision: str | None,
+    equality_check_status: str,
+) -> DynamicColorProjectionCertificate:
+    identity = tuple(range(len(dag.currents)))
+    return DynamicColorProjectionCertificate(
+        abi=_DYNAMIC_COLOR_PROJECTION_ABI,
+        source_revision=source_revision,
+        source_semantics_sha256=_canonical_sha256(dag.to_json_dict()),
+        selector_domains_sha256=_canonical_sha256([]),
+        current_class_members_sha256=_canonical_sha256(
+            [[current.id] for current in dag.currents]
+        ),
+        old_to_new_current_ids=identity,
+        current_remap_sha256=_canonical_sha256(list(identity)),
+        interaction_groups_sha256=_canonical_sha256(
+            [[interaction.id] for interaction in dag.interactions]
+        ),
+        closure_groups_sha256=_canonical_sha256(
+            [[root.id] for root in dag.amplitude_roots]
+        ),
+        rectangle_cardinalities_sha256=_canonical_sha256([]),
+        row_identity_sha256=_canonical_sha256(
+            {
+                "interactions": [
+                    interaction.to_json_dict() for interaction in dag.interactions
+                ],
+                "roots": [root.to_json_dict() for root in dag.amplitude_roots],
+            }
+        ),
+        equality_check_status=equality_check_status,
+        retained_color_metadata=_RETAINED_COLOR_METADATA_POLICY,
+        root_sector_policy=_ROOT_SECTOR_POLICY,
+        before_current_count=len(dag.currents),
+        after_current_count=len(dag.currents),
+        before_interaction_count=len(dag.interactions),
+        after_interaction_count=len(dag.interactions),
+        before_evaluation_count=dag.interaction_evaluation_count,
+        after_evaluation_count=dag.interaction_evaluation_count,
+        before_amplitude_root_count=len(dag.amplitude_roots),
+        after_amplitude_root_count=len(dag.amplitude_roots),
+        projected_current_class_count=0,
+        rectangular_interaction_group_count=0,
+        rectangular_closure_group_count=0,
+        split_current_class_count=0,
+    )
+
+
+def _projection_proof_payloads(
+    dag: GenericDAG,
+    selector_domains: tuple[tuple[int, ...], ...],
+    classes: tuple[tuple[int, ...], ...],
+    class_by_current: tuple[int, ...],
+    interaction_groups: dict[tuple[object, ...], list[InteractionNode]],
+    root_groups: dict[tuple[object, ...], list[AmplitudeRoot]],
+) -> dict[str, object]:
+    """Return the complete deterministic witness committed by the certificate."""
+
+    ordered_interaction_groups = sorted(
+        interaction_groups.values(),
+        key=lambda rows: min(row.id for row in rows),
+    )
+    ordered_root_groups = sorted(
+        root_groups.values(),
+        key=lambda rows: min(row.id for row in rows),
+    )
+    rectangle_cardinalities: list[dict[str, object]] = []
+    row_identities: list[dict[str, object]] = []
+    for rows in ordered_interaction_groups:
+        first = rows[0]
+        result_class = class_by_current[first.result_id]
+        left_class = class_by_current[first.left_id]
+        right_class = class_by_current[first.right_id]
+        actual_pairs = sorted((row.left_id, row.right_id) for row in rows)
+        rectangle_cardinalities.append(
+            {
+                "kind": "interaction",
+                "row_ids": sorted(row.id for row in rows),
+                "result_class_size": len(classes[result_class]),
+                "left_class_size": len(classes[left_class]),
+                "right_class_size": len(classes[right_class]),
+                "row_count": len(rows),
+                "unique_parent_pair_count": len(set(actual_pairs)),
+                "expected_parent_pair_count": (
+                    len(classes[left_class]) * len(classes[right_class])
+                ),
+            }
+        )
+        row_identities.append(
+            {
+                "kind": "interaction",
+                "result_class_id": result_class,
+                "left_class_id": left_class,
+                "right_class_id": right_class,
+                "vertex_kind": int(first.vertex_kind),
+                "vertex_particles": list(first.vertex_particles),
+                "coupling": list(first.coupling),
+                "color_weight": list(first.color_weight),
+                "lowering_backend": first.lowering_backend,
+                "full_tensor_network_ready": bool(
+                    first.full_tensor_network_ready
+                ),
+                "row_ids": sorted(row.id for row in rows),
+            }
+        )
+    for roots in ordered_root_groups:
+        first = roots[0]
+        left_class = class_by_current[first.left_id]
+        right_class = class_by_current[first.right_id]
+        actual_pairs = sorted((root.left_id, root.right_id) for root in roots)
+        resolved_sector = _resolved_root_color_sector_id(dag, first)
+        rectangle_cardinalities.append(
+            {
+                "kind": "closure",
+                "row_ids": sorted(root.id for root in roots),
+                "left_class_size": len(classes[left_class]),
+                "right_class_size": len(classes[right_class]),
+                "row_count": len(roots),
+                "unique_parent_pair_count": len(set(actual_pairs)),
+                "expected_parent_pair_count": (
+                    len(classes[left_class]) * len(classes[right_class])
+                ),
+                "resolved_color_sector_id": resolved_sector,
+            }
+        )
+        row_identities.append(
+            {
+                "kind": "closure",
+                "left_class_id": left_class,
+                "right_class_id": right_class,
+                "root_kind": first.kind,
+                "color_weight": list(first.color_weight),
+                "contraction_ir": first.contraction_ir.to_json_dict(),
+                "resolved_color_sector_id": resolved_sector,
+                "vertex_kind": first.vertex_kind,
+                "vertex_particles": (
+                    None
+                    if first.vertex_particles is None
+                    else list(first.vertex_particles)
+                ),
+                "coupling": list(first.coupling),
+                "helicity_weight": float(first.helicity_weight),
+                "row_ids": sorted(root.id for root in roots),
+            }
+        )
+    return {
+        "selector_domains_sha256": _canonical_sha256(
+            [list(domain) for domain in selector_domains]
+        ),
+        "current_class_members_sha256": _canonical_sha256(
+            [list(members) for members in classes]
+        ),
+        "current_remap_sha256": _canonical_sha256(list(class_by_current)),
+        "interaction_groups_sha256": _canonical_sha256(
+            [sorted(row.id for row in rows) for rows in ordered_interaction_groups]
+        ),
+        "closure_groups_sha256": _canonical_sha256(
+            [sorted(root.id for root in roots) for roots in ordered_root_groups]
+        ),
+        "rectangle_cardinalities_sha256": _canonical_sha256(
+            rectangle_cardinalities
+        ),
+        "row_identity_sha256": _canonical_sha256(row_identities),
+    }
+
+
+def project_rectangular_dynamic_color_classes(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    source_revision: str | None = None,
+) -> tuple[GenericDAG, DynamicColorProjectionCertificate]:
+    """Project exact dynamic-color rectangles into shared sum currents.
+
+    This is the GenericDAG counterpart of topology-replay value projection.
+    It is intentionally conservative:
+
+    * source currents remain singleton;
+    * every current field except dynamic LC sector remains in the class key;
+    * the downstream physical-selector domain is part of that key;
+    * concrete kernel identity, coupling, coefficient, and parent order remain
+      exact;
+    * both transition and amplitude-closure rows must form complete Cartesian
+      products without duplicates.
+
+    A failed rectangle splits every implicated class and retries to a fixed
+    point.  Therefore a malformed or incomplete color orbit can only reduce
+    optimization, never alter the generated amplitude.
+    """
+
+    before = _initial_dynamic_color_projection_certificate(
+        dag,
+        source_revision=source_revision,
+        equality_check_status="not-applicable",
+    )
+    if (
+        dag.process.color_accuracy != "lc"
+        or not dag.currents
+        or not dag.interactions
+        or not dag.amplitude_roots
+    ):
+        return dag, before
+    if dag.helicity_recurrence is not None or dag.helicity_materialization is not None:
+        raise ValueError(
+            "dynamic-color projection must precede helicity recurrence materialization"
+        )
+
+    selector_domains = _downstream_color_selector_domains(dag)
+    split_current_ids: set[int] = set()
+    split_class_count = 0
+    while True:
+        classes, class_by_current = _projection_partition(
+            dag,
+            selector_domains,
+            split_current_ids,
+        )
+        interaction_groups, root_groups = _projection_groups(
+            dag,
+            classes,
+            class_by_current,
+        )
+        invalid_classes = _invalid_projection_classes(
+            dag,
+            classes,
+            class_by_current,
+            interaction_groups,
+            root_groups,
+        )
+        newly_split = {
+            current_id
+            for class_id in invalid_classes
+            for current_id in classes[class_id]
+            if current_id not in split_current_ids
+        }
+        if not newly_split:
+            break
+        split_class_count += len(invalid_classes)
+        split_current_ids.update(newly_split)
+
+    proof_payloads = _projection_proof_payloads(
+        dag,
+        selector_domains,
+        classes,
+        class_by_current,
+        interaction_groups,
+        root_groups,
+    )
+    projected_class_count = sum(len(members) > 1 for members in classes)
+    if projected_class_count == 0:
+        return dag, replace(
+            before,
+            selector_domains_sha256=str(
+                proof_payloads["selector_domains_sha256"]
+            ),
+            current_class_members_sha256=str(
+                proof_payloads["current_class_members_sha256"]
+            ),
+            old_to_new_current_ids=class_by_current,
+            current_remap_sha256=str(proof_payloads["current_remap_sha256"]),
+            interaction_groups_sha256=str(
+                proof_payloads["interaction_groups_sha256"]
+            ),
+            closure_groups_sha256=str(
+                proof_payloads["closure_groups_sha256"]
+            ),
+            rectangle_cardinalities_sha256=str(
+                proof_payloads["rectangle_cardinalities_sha256"]
+            ),
+            row_identity_sha256=str(proof_payloads["row_identity_sha256"]),
+            equality_check_status="passed-no-projectable-classes",
+            split_current_class_count=split_class_count,
+        )
+
+    old_to_new = class_by_current
+    currents = tuple(
+        replace(dag.currents[members[0]], id=class_id)
+        for class_id, members in enumerate(classes)
+    )
+    sources = tuple(
+        old_to_new[source_id]
+        for source_id in dag.sources
+    )
+    if len(sources) != len(set(sources)):
+        raise ValueError("dynamic-color projection unexpectedly merged source currents")
+
+    interactions: list[InteractionNode] = []
+    rectangular_interaction_count = 0
+    for rows in sorted(
+        interaction_groups.values(),
+        key=lambda rows: min(row.id for row in rows),
+    ):
+        first = rows[0]
+        involved = (
+            old_to_new[first.result_id],
+            old_to_new[first.left_id],
+            old_to_new[first.right_id],
+        )
+        if any(len(classes[class_id]) > 1 for class_id in involved):
+            rectangular_interaction_count += 1
+        interactions.append(
+            replace(
+                first,
+                id=len(interactions),
+                left_id=old_to_new[first.left_id],
+                right_id=old_to_new[first.right_id],
+                result_id=old_to_new[first.result_id],
+                evaluation_group_id=None,
+                evaluation_factor=(1.0, 0.0),
+            )
+        )
+
+    roots: list[AmplitudeRoot] = []
+    rectangular_closure_count = 0
+    for grouped_roots in sorted(
+        root_groups.values(),
+        key=lambda rows: min(row.id for row in rows),
+    ):
+        first = grouped_roots[0]
+        if (
+            len(classes[old_to_new[first.left_id]]) > 1
+            or len(classes[old_to_new[first.right_id]]) > 1
+        ):
+            rectangular_closure_count += 1
+        roots.append(
+            replace(
+                first,
+                id=len(roots),
+                left_id=old_to_new[first.left_id],
+                right_id=old_to_new[first.right_id],
+                color_sector_id=_resolved_root_color_sector_id(dag, first),
+            )
+        )
+
+    projected = replace(
+        dag,
+        currents=currents,
+        sources=sources,
+        interactions=tuple(interactions),
+        amplitude_roots=tuple(roots),
+    )
+    projected = assign_recursive_current_evaluation_reuse(projected, model)
+    certificate = DynamicColorProjectionCertificate(
+        abi=_DYNAMIC_COLOR_PROJECTION_ABI,
+        source_revision=source_revision,
+        source_semantics_sha256=before.source_semantics_sha256,
+        selector_domains_sha256=str(
+            proof_payloads["selector_domains_sha256"]
+        ),
+        current_class_members_sha256=str(
+            proof_payloads["current_class_members_sha256"]
+        ),
+        old_to_new_current_ids=old_to_new,
+        current_remap_sha256=str(proof_payloads["current_remap_sha256"]),
+        interaction_groups_sha256=str(
+            proof_payloads["interaction_groups_sha256"]
+        ),
+        closure_groups_sha256=str(proof_payloads["closure_groups_sha256"]),
+        rectangle_cardinalities_sha256=str(
+            proof_payloads["rectangle_cardinalities_sha256"]
+        ),
+        row_identity_sha256=str(proof_payloads["row_identity_sha256"]),
+        equality_check_status="passed-exact-cartesian-products-no-duplicates",
+        retained_color_metadata=_RETAINED_COLOR_METADATA_POLICY,
+        root_sector_policy=_ROOT_SECTOR_POLICY,
+        before_current_count=len(dag.currents),
+        after_current_count=len(projected.currents),
+        before_interaction_count=len(dag.interactions),
+        after_interaction_count=len(projected.interactions),
+        before_evaluation_count=dag.interaction_evaluation_count,
+        after_evaluation_count=projected.interaction_evaluation_count,
+        before_amplitude_root_count=len(dag.amplitude_roots),
+        after_amplitude_root_count=len(projected.amplitude_roots),
+        projected_current_class_count=projected_class_count,
+        rectangular_interaction_group_count=rectangular_interaction_count,
+        rectangular_closure_group_count=rectangular_closure_count,
+        split_current_class_count=split_class_count,
+    )
+    return projected, certificate
+
+
+def _derive_current_value_equivalences(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    equivalence_by_kind: dict[int, VertexEvaluationEquivalence] | None = None,
+    discovery: _NumericalRelationDiscovery | None = None,
+    authenticated_relations: (
+        Mapping[int, _CurrentValueEquivalence] | None
+    ) = None,
+) -> tuple[_CurrentValueEquivalence, ...]:
+    """Derive current classes in increasing external-subset order."""
+
+    kernel_equivalences = {} if equivalence_by_kind is None else equivalence_by_kind
+    interactions_by_result: dict[int, list[InteractionNode]] = defaultdict(list)
+    for interaction in dag.interactions:
+        interactions_by_result[interaction.result_id].append(interaction)
+
+    current_equivalences: list[_CurrentValueEquivalence | None] = [None] * len(
+        dag.currents
+    )
+    source_representative_by_key: dict[tuple[object, ...], int] = {}
+    equivalence_by_expression: dict[
+        tuple[_CurrentContract, _CurrentTermVector], _CurrentValueEquivalence
+    ] = {}
+    projective_representatives_by_expression: dict[
+        tuple[_CurrentContract, _CurrentTermVector],
+        list[_ProjectiveExpressionRepresentative],
+    ] = {}
+
+    ordered_currents = sorted(
+        dag.currents,
+        key=lambda current: (len(current.index.external_labels), current.id),
+    )
+    for current in ordered_currents:
+        contract = _current_evaluation_contract(current)
+        if current.is_source:
+            if current.source_leg_label is None or current.source_helicity is None:
+                raise ValueError(
+                    f"source current {current.id} lacks physical source metadata"
+                )
+            source_key = (
+                contract,
+                int(current.source_leg_label),
+                int(current.source_helicity),
+            )
+            representative_id = source_representative_by_key.setdefault(
+                source_key,
+                current.id,
+            )
+            current_equivalences[current.id] = _CurrentValueEquivalence(
+                representative_id=representative_id,
+                factor=(1.0, 0.0),
+            )
+            continue
+
+        term_vector = _current_term_vector(
+            dag,
+            current,
+            interactions_by_result[current.id],
+            model,
+            current_equivalences=current_equivalences,
+            equivalence_by_kind=kernel_equivalences,
+        )
+        equivalence = _classify_current_term_vector(
+            current_id=current.id,
+            contract=contract,
+            term_vector=term_vector,
+            equivalence_by_expression=equivalence_by_expression,
+            projective_representatives_by_expression=(
+                projective_representatives_by_expression
+            ),
+        )
+        if discovery is not None:
+            equivalence = discovery.consider(
+                current_id=current.id,
+                contract=contract,
+                term_vector=term_vector,
+                baseline=equivalence,
+            )
+        if authenticated_relations is not None:
+            authenticated = authenticated_relations.get(current.id)
+            if authenticated is not None:
+                if authenticated.representative_id == current.id:
+                    if authenticated.factor != (0.0, 0.0):
+                        raise ValueError(
+                            "self-represented authenticated relation must be zero"
+                        )
+                    equivalence = authenticated
+                else:
+                    representative = current_equivalences[
+                        authenticated.representative_id
+                    ]
+                    if representative is None:
+                        raise ValueError(
+                            "authenticated relation representative is not "
+                            "topologically complete"
+                        )
+                    factor = _exact_representable_complex_product(
+                        authenticated.factor,
+                        representative.factor,
+                    )
+                    if factor is None:
+                        raise ValueError(
+                            "authenticated relation factor composition is not exact"
+                        )
+                    equivalence = _CurrentValueEquivalence(
+                        representative_id=representative.representative_id,
+                        factor=factor,
+                    )
+        current_equivalences[current.id] = equivalence
+
+    if any(item is None for item in current_equivalences):
+        raise ValueError(
+            "current-value equivalence derivation left an unclassified current"
+        )
+    return tuple(item for item in current_equivalences if item is not None)
+
+
+def verify_dag_relation_certificates(
+    dag: GenericDAG,
+    model: Model,
+    certificates: Iterable[ExactCurrentRelationCertificate],
+) -> bool:
+    """Replay a certificate chain without consulting numerical probe results."""
+
+    ordered_certificates = tuple(certificates)
+    if (
+        tuple(sorted(ordered_certificates, key=lambda item: item.current_id))
+        != ordered_certificates
+    ):
+        return False
+    certificate_by_current = {
+        certificate.current_id: certificate for certificate in ordered_certificates
+    }
+    if len(certificate_by_current) != len(ordered_certificates):
+        return False
+
+    try:
+        interactions_by_result: dict[int, list[InteractionNode]] = defaultdict(list)
+        for interaction in dag.interactions:
+            interactions_by_result[interaction.result_id].append(interaction)
+        current_equivalences: list[_CurrentValueEquivalence | None] = [None] * len(
+            dag.currents
+        )
+        source_representative_by_key: dict[tuple[object, ...], int] = {}
+        equivalence_by_expression: dict[
+            tuple[_CurrentContract, _CurrentTermVector], _CurrentValueEquivalence
+        ] = {}
+        projective_representatives_by_expression: dict[
+            tuple[_CurrentContract, _CurrentTermVector],
+            list[_ProjectiveExpressionRepresentative],
+        ] = {}
+        kernel_equivalences: dict[int, VertexEvaluationEquivalence] = {}
+        term_vector_by_current: dict[int, _CurrentTermVector] = {}
+        contract_by_current: dict[int, _CurrentContract] = {}
+        consumed: set[int] = set()
+
+        ordered_currents = sorted(
+            dag.currents,
+            key=lambda current: (len(current.index.external_labels), current.id),
+        )
+        for current in ordered_currents:
+            contract = _current_evaluation_contract(current)
+            contract_by_current[current.id] = contract
+            if current.is_source:
+                if current.id in certificate_by_current:
+                    return False
+                if current.source_leg_label is None or current.source_helicity is None:
+                    return False
+                source_key = (
+                    contract,
+                    int(current.source_leg_label),
+                    int(current.source_helicity),
+                )
+                representative_id = source_representative_by_key.setdefault(
+                    source_key,
+                    current.id,
+                )
+                current_equivalences[current.id] = _CurrentValueEquivalence(
+                    representative_id,
+                    (1.0, 0.0),
+                )
+                continue
+
+            term_vector = _current_term_vector(
+                dag,
+                current,
+                interactions_by_result[current.id],
+                model,
+                current_equivalences=current_equivalences,
+                equivalence_by_kind=kernel_equivalences,
+            )
+            term_vector_by_current[current.id] = term_vector
+            equivalence = _classify_current_term_vector(
+                current_id=current.id,
+                contract=contract,
+                term_vector=term_vector,
+                equivalence_by_expression=equivalence_by_expression,
+                projective_representatives_by_expression=(
+                    projective_representatives_by_expression
+                ),
+            )
+            certificate = certificate_by_current.get(current.id)
+            if certificate is not None:
+                if (
+                    certificate.algorithm != RELATION_DISCOVERY_CERTIFICATE_ALGORITHM
+                    or certificate.representative_id >= current.id
+                    or certificate.representative_id not in term_vector_by_current
+                    or contract_by_current[certificate.representative_id] != contract
+                ):
+                    return False
+                representative_vector = term_vector_by_current[
+                    certificate.representative_id
+                ]
+                factor = _certify_exact_term_vector_relation(
+                    representative_vector,
+                    term_vector,
+                )
+                if factor is None or not _complex_weight_bits_equal(
+                    factor,
+                    certificate.factor,
+                ):
+                    return False
+                if (
+                    _term_vector_sha256(term_vector)
+                    != certificate.current_term_vector_sha256
+                    or _term_vector_sha256(representative_vector)
+                    != certificate.representative_term_vector_sha256
+                    or _certificate_proof_sha256(
+                        current_id=certificate.current_id,
+                        representative_id=certificate.representative_id,
+                        factor=certificate.factor,
+                        current_term_vector_sha256=(
+                            certificate.current_term_vector_sha256
+                        ),
+                        representative_term_vector_sha256=(
+                            certificate.representative_term_vector_sha256
+                        ),
+                    )
+                    != certificate.proof_sha256
+                ):
+                    return False
+                equivalence = _CurrentValueEquivalence(
+                    certificate.representative_id,
+                    certificate.factor,
+                )
+                consumed.add(current.id)
+            current_equivalences[current.id] = equivalence
+        return consumed == set(certificate_by_current)
+    except (IndexError, KeyError, OverflowError, TypeError, ValueError):
+        return False
+
+
+def _numerical_projective_fingerprint(
+    term_vector: _CurrentTermVector,
+    *,
+    precision_digits: int,
+    probe_count: int,
+    seed: int,
+) -> tuple[object, ...] | None:
+    """Return a scale-free high-precision candidate key.
+
+    This fingerprint is deliberately insufficient as a proof. Its only use is
+    to reduce the number of pairs sent to exact coefficient-vector replay.
+    """
+
+    if not _term_vector_is_finite_nonzero(term_vector):
+        return None
+    with localcontext() as context:
+        context.prec = precision_digits
+        values: list[tuple[Decimal, Decimal]] = []
+        for probe_index in range(probe_count):
+            total_real = Decimal(0)
+            total_imaginary = Decimal(0)
+            for evaluation_key, coefficient in term_vector:
+                probe_real, probe_imaginary = _deterministic_decimal_probe_value(
+                    evaluation_key,
+                    seed=seed,
+                    probe_index=probe_index,
+                )
+                coefficient_real = Decimal.from_float(coefficient[0])
+                coefficient_imaginary = Decimal.from_float(coefficient[1])
+                total_real += (
+                    coefficient_real * probe_real
+                    - coefficient_imaginary * probe_imaginary
+                )
+                total_imaginary += (
+                    coefficient_real * probe_imaginary
+                    + coefficient_imaginary * probe_real
+                )
+            values.append((total_real, total_imaginary))
+
+        pivot_index = next(
+            (
+                index
+                for index, value in enumerate(values)
+                if value != (Decimal(0), Decimal(0))
+            ),
+            None,
+        )
+        if pivot_index is None:
+            return None
+        pivot = values[pivot_index]
+        normalized = tuple(_decimal_complex_ratio(value, pivot) for value in values)
+        if any(value is None for value in normalized):
+            return None
+        fingerprint_digits = max(24, precision_digits // 2)
+        return (
+            "deterministic-projective-probe-v1",
+            pivot_index,
+            tuple(
+                (
+                    _decimal_fingerprint_component(value[0], fingerprint_digits),
+                    _decimal_fingerprint_component(value[1], fingerprint_digits),
+                )
+                for value in normalized
+                if value is not None
+            ),
+        )
+
+
+def _deterministic_decimal_probe_value(
+    evaluation_key: _EvaluationKey,
+    *,
+    seed: int,
+    probe_index: int,
+) -> tuple[Decimal, Decimal]:
+    payload = json.dumps(
+        _canonical_proof_value(evaluation_key),
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    digest = hashlib.sha256(f"{seed}:{probe_index}:".encode("ascii") + payload).digest()
+
+    def component(chunk: bytes) -> Decimal:
+        raw = int.from_bytes(chunk, "big", signed=False)
+        value = raw % 2_000_003 - 1_000_001
+        return Decimal(1 if value == 0 else value)
+
+    return component(digest[:8]), component(digest[8:16])
+
+
+def _decimal_complex_ratio(
+    numerator: tuple[Decimal, Decimal],
+    denominator: tuple[Decimal, Decimal],
+) -> tuple[Decimal, Decimal] | None:
+    denominator_norm = denominator[0] * denominator[0] + denominator[1] * denominator[1]
+    if denominator_norm == 0:
+        return None
+    return (
+        (numerator[0] * denominator[0] + numerator[1] * denominator[1])
+        / denominator_norm,
+        (numerator[1] * denominator[0] - numerator[0] * denominator[1])
+        / denominator_norm,
+    )
+
+
+def _decimal_fingerprint_component(value: Decimal, digits: int) -> str:
+    if value == 0:
+        return "0"
+    return format(value, f".{digits}E")
+
+
+def _certify_exact_term_vector_relation(
+    representative: _CurrentTermVector,
+    candidate: _CurrentTermVector,
+) -> _ComplexWeight | None:
+    if (
+        not _term_vector_is_finite_nonzero(representative)
+        or not _term_vector_is_finite_nonzero(candidate)
+        or len(representative) != len(candidate)
+    ):
+        return None
+    if any(
+        representative_key != candidate_key
+        for (representative_key, _), (candidate_key, _) in zip(
+            representative,
+            candidate,
+            strict=True,
+        )
+    ):
+        return None
+    factor = _exact_representable_complex_ratio(
+        candidate[0][1],
+        representative[0][1],
+    )
+    if factor is None or not _term_vector_scaled_exactly(
+        representative,
+        factor,
+        candidate,
+    ):
+        return None
+    return factor
+
+
+def _build_exact_current_relation_certificate(
+    *,
+    current_id: int,
+    representative_id: int,
+    factor: _ComplexWeight,
+    current_term_vector: _CurrentTermVector,
+    representative_term_vector: _CurrentTermVector,
+) -> ExactCurrentRelationCertificate:
+    current_digest = _term_vector_sha256(current_term_vector)
+    representative_digest = _term_vector_sha256(representative_term_vector)
+    return ExactCurrentRelationCertificate(
+        current_id=current_id,
+        representative_id=representative_id,
+        factor=factor,
+        current_term_vector_sha256=current_digest,
+        representative_term_vector_sha256=representative_digest,
+        proof_sha256=_certificate_proof_sha256(
+            current_id=current_id,
+            representative_id=representative_id,
+            factor=factor,
+            current_term_vector_sha256=current_digest,
+            representative_term_vector_sha256=representative_digest,
+        ),
+    )
+
+
+def _certificate_proof_sha256(
+    *,
+    current_id: int,
+    representative_id: int,
+    factor: _ComplexWeight,
+    current_term_vector_sha256: str,
+    representative_term_vector_sha256: str,
+) -> str:
+    return _canonical_payload_sha256(
+        {
+            "algorithm": RELATION_DISCOVERY_CERTIFICATE_ALGORITHM,
+            "current_id": current_id,
+            "representative_id": representative_id,
+            "factor_binary64": [factor[0].hex(), factor[1].hex()],
+            "current_term_vector_sha256": current_term_vector_sha256,
+            "representative_term_vector_sha256": (representative_term_vector_sha256),
+        }
+    )
+
+
+def _term_vector_sha256(term_vector: _CurrentTermVector) -> str:
+    return _canonical_payload_sha256(
+        [
+            {
+                "evaluation_key": _canonical_proof_value(evaluation_key),
+                "coefficient_binary64": [
+                    coefficient[0].hex(),
+                    coefficient[1].hex(),
+                ],
+            }
+            for evaluation_key, coefficient in term_vector
+        ]
+    )
+
+
+def _canonical_payload_sha256(payload: object) -> str:
+    encoded = json.dumps(
+        payload,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _canonical_proof_value(value: object) -> object:
+    if isinstance(value, tuple):
+        return [_canonical_proof_value(item) for item in value]
+    if isinstance(value, float):
+        return {"binary64": value.hex()}
+    if value is None or isinstance(value, bool | int | str):
+        return value
+    raise TypeError(
+        "relation certificate contains a noncanonical evaluation-key value "
+        f"{type(value).__name__}"
+    )
+
+
+def _interaction_reuse_signature(dag: GenericDAG) -> tuple[tuple[object, ...], ...]:
+    canonical_group_by_key: dict[tuple[str, int], int] = {}
+    signature: list[tuple[object, ...]] = []
+    for interaction in dag.interactions:
+        raw_group = (
+            ("group", interaction.evaluation_group_id)
+            if interaction.evaluation_group_id is not None
+            else ("interaction", interaction.id)
+        )
+        canonical_group = canonical_group_by_key.setdefault(
+            raw_group,
+            len(canonical_group_by_key),
+        )
+        signature.append(
+            (
+                canonical_group,
+                interaction.evaluation_factor[0].hex(),
+                interaction.evaluation_factor[1].hex(),
+            )
+        )
+    return tuple(signature)
+
+
+def _classify_current_term_vector(
+    *,
+    current_id: int,
+    contract: _CurrentContract,
+    term_vector: _CurrentTermVector,
+    equivalence_by_expression: dict[
+        tuple[_CurrentContract, _CurrentTermVector], _CurrentValueEquivalence
+    ],
+    projective_representatives_by_expression: dict[
+        tuple[_CurrentContract, _CurrentTermVector],
+        list[_ProjectiveExpressionRepresentative],
+    ],
+) -> _CurrentValueEquivalence:
+    """Return the earliest exactly proven representative for one current.
+
+    Exact equality and sign reuse remain the fast paths.  More general
+    projective reuse is accepted only when a finite, nonzero binary64 factor
+    exists exactly and applying it reproduces every coefficient bit-for-bit.
+    """
+
+    identity = _CurrentValueEquivalence(current_id, (1.0, 0.0))
+    expression_key = (contract, term_vector)
+    if not term_vector:
+        exact_zero = equivalence_by_expression.get(expression_key)
+        if exact_zero is not None:
+            return exact_zero
+        equivalence_by_expression[expression_key] = identity
+        return identity
+    if not _term_vector_is_finite_nonzero(term_vector):
+        return identity
+
+    exact = equivalence_by_expression.get(expression_key)
+    if exact is not None:
+        return exact
+
+    opposite = equivalence_by_expression.get(
+        (contract, _negate_term_vector(term_vector))
+    )
+    if opposite is not None:
+        opposite_factor = (
+            _canonical_zero(-opposite.factor[0]),
+            _canonical_zero(-opposite.factor[1]),
+        )
+        representative_vector = _term_vector_divided_by_exact_factor(
+            term_vector,
+            opposite_factor,
+        )
+        if representative_vector is not None and _term_vector_scaled_exactly(
+            representative_vector,
+            opposite_factor,
+            term_vector,
+        ):
+            equivalence = _CurrentValueEquivalence(
+                opposite.representative_id,
+                opposite_factor,
+            )
+            equivalence_by_expression[expression_key] = equivalence
+            return equivalence
+
+    canonical = _canonicalize_projective_term_vector(term_vector)
+    if canonical is None:
+        equivalence_by_expression[expression_key] = identity
+        return identity
+
+    projective_key = (contract, canonical.term_vector)
+    representatives = projective_representatives_by_expression.get(projective_key)
+    matches: list[_CurrentValueEquivalence] = []
+    if representatives is not None:
+        for representative in representatives:
+            factor = _exact_representable_complex_ratio(
+                canonical.factor,
+                representative.normalization_factor,
+            )
+            if factor is None or not _term_vector_scaled_exactly(
+                representative.term_vector,
+                factor,
+                term_vector,
+            ):
+                continue
+            matches.append(
+                _CurrentValueEquivalence(
+                    representative.representative_id,
+                    factor,
+                )
+            )
+
+    if len(matches) == 1:
+        equivalence = matches[0]
+        equivalence_by_expression[expression_key] = equivalence
+        return equivalence
+
+    # Zero matches mean that the normalized lookup key was only a rounded
+    # collision.  Multiple matches make the concrete representative
+    # ambiguous.  Both cases fail closed by retaining this current.
+    projective_representatives_by_expression.setdefault(
+        projective_key,
+        [],
+    ).append(
+        _ProjectiveExpressionRepresentative(
+            representative_id=current_id,
+            term_vector=term_vector,
+            normalization_factor=canonical.factor,
+        )
+    )
+    equivalence_by_expression[expression_key] = identity
+    return identity
+
+
+def _canonicalize_projective_term_vector(
+    term_vector: _CurrentTermVector,
+) -> _CanonicalProjectiveTermVector | None:
+    """Normalize a finite nonzero vector for projective-class lookup.
+
+    The first canonical term is the deterministic pivot.  The normalized
+    binary64 coefficients are only an index: every accepted equivalence is
+    separately proven with an exactly representable factor and bit-exact
+    coefficient reconstruction.
+    """
+
+    if not term_vector or not _term_vector_is_finite_nonzero(term_vector):
+        return None
+    keys = tuple(key for key, _coefficient in term_vector)
+    if len(set(keys)) != len(keys) or keys != tuple(sorted(keys)):
+        return None
+
+    factor = _canonical_complex_weight(term_vector[0][1])
+    normalized_terms: list[tuple[_EvaluationKey, _ComplexWeight]] = []
+    for key, raw_coefficient in term_vector:
+        coefficient = _canonical_complex_weight(raw_coefficient)
+        normalized = _roundtrip_complex_ratio(coefficient, factor)
+        if normalized is None:
+            return None
+        normalized_terms.append((key, normalized))
+    return _CanonicalProjectiveTermVector(
+        term_vector=tuple(normalized_terms),
+        factor=factor,
+    )
+
+
+def _roundtrip_complex_ratio(
+    numerator: _ComplexWeight,
+    denominator: _ComplexWeight,
+) -> _ComplexWeight | None:
+    """Return a finite lookup ratio that reconstructs ``numerator`` exactly."""
+
+    if (
+        not _complex_weight_is_finite(numerator)
+        or not _complex_weight_is_finite(denominator)
+        or denominator == (0.0, 0.0)
+    ):
+        return None
+    try:
+        quotient = complex(*numerator) / complex(*denominator)
+    except (OverflowError, ZeroDivisionError):
+        return None
+    result = _canonical_complex_weight((quotient.real, quotient.imag))
+    if not _complex_weight_is_finite(result):
+        return None
+    reconstructed = _canonical_complex_weight(_complex_weight_mul(denominator, result))
+    if not _complex_weight_bits_equal(reconstructed, numerator):
+        return None
+    return result
+
+
+def _exact_representable_complex_ratio(
+    numerator: _ComplexWeight,
+    denominator: _ComplexWeight,
+) -> _ComplexWeight | None:
+    """Return the exact binary64 complex quotient, or fail closed.
+
+    ``Fraction`` is used only after two vectors collide on their inexpensive
+    normalized key.  It proves that both quotient components are exactly
+    representable rather than merely rounded values that happen to be close.
+    """
+
+    if (
+        not _complex_weight_is_finite(numerator)
+        or not _complex_weight_is_finite(denominator)
+        or denominator == (0.0, 0.0)
+    ):
+        return None
+    numerator_real = Fraction.from_float(numerator[0])
+    numerator_imag = Fraction.from_float(numerator[1])
+    denominator_real = Fraction.from_float(denominator[0])
+    denominator_imag = Fraction.from_float(denominator[1])
+    denominator_norm = (
+        denominator_real * denominator_real + denominator_imag * denominator_imag
+    )
+    if denominator_norm == 0:
+        return None
+    real = (
+        numerator_real * denominator_real + numerator_imag * denominator_imag
+    ) / denominator_norm
+    imaginary = (
+        numerator_imag * denominator_real - numerator_real * denominator_imag
+    ) / denominator_norm
+    real_f64 = _exact_fraction_as_f64(real)
+    imaginary_f64 = _exact_fraction_as_f64(imaginary)
+    if real_f64 is None or imaginary_f64 is None:
+        return None
+    factor = (real_f64, imaginary_f64)
+    reconstructed = _canonical_complex_weight(_complex_weight_mul(denominator, factor))
+    if not _complex_weight_bits_equal(
+        reconstructed,
+        _canonical_complex_weight(numerator),
+    ):
+        return None
+    return factor
+
+
+def _exact_representable_complex_product(
+    left: _ComplexWeight,
+    right: _ComplexWeight,
+) -> _ComplexWeight | None:
+    """Return the exact binary64 complex product, or fail closed."""
+
+    if not _complex_weight_is_finite(left) or not _complex_weight_is_finite(right):
+        return None
+    left_real = Fraction.from_float(left[0])
+    left_imaginary = Fraction.from_float(left[1])
+    right_real = Fraction.from_float(right[0])
+    right_imaginary = Fraction.from_float(right[1])
+    real = left_real * right_real - left_imaginary * right_imaginary
+    imaginary = left_real * right_imaginary + left_imaginary * right_real
+    real_f64 = _exact_fraction_as_f64(real)
+    imaginary_f64 = _exact_fraction_as_f64(imaginary)
+    if real_f64 is None or imaginary_f64 is None:
+        return None
+    product = (real_f64, imaginary_f64)
+    reconstructed = _canonical_complex_weight(_complex_weight_mul(left, right))
+    if not _complex_weight_bits_equal(reconstructed, product):
+        return None
+    return product
+
+
+def _exact_fraction_as_f64(value: Fraction) -> float | None:
+    try:
+        result = float(value)
+    except OverflowError:
+        return None
+    if not isfinite(result) or Fraction.from_float(result) != value:
+        return None
+    return _canonical_zero(result)
+
+
+def _term_vector_scaled_exactly(
+    representative: _CurrentTermVector,
+    factor: _ComplexWeight,
+    candidate: _CurrentTermVector,
+) -> bool:
+    if (
+        not _complex_weight_is_finite(factor)
+        or factor == (0.0, 0.0)
+        or len(representative) != len(candidate)
+    ):
+        return False
+    for (representative_key, representative_value), (
+        candidate_key,
+        candidate_value,
+    ) in zip(representative, candidate, strict=True):
+        if representative_key != candidate_key:
+            return False
+        scaled = _canonical_complex_weight(
+            _complex_weight_mul(factor, representative_value)
+        )
+        if not _complex_weight_bits_equal(
+            scaled,
+            _canonical_complex_weight(candidate_value),
+        ):
+            return False
+    return True
+
+
+def _term_vector_divided_by_exact_factor(
+    candidate: _CurrentTermVector,
+    factor: _ComplexWeight,
+) -> _CurrentTermVector | None:
+    """Recover a representative vector only for the sign fast path."""
+
+    if factor not in ((1.0, 0.0), (-1.0, 0.0)):
+        return None
+    return tuple(
+        (
+            key,
+            value
+            if factor == (1.0, 0.0)
+            else (_canonical_zero(-value[0]), _canonical_zero(-value[1])),
+        )
+        for key, value in candidate
+    )
+
+
+def _term_vector_is_finite_nonzero(term_vector: _CurrentTermVector) -> bool:
+    return bool(term_vector) and all(
+        coefficient != (0.0, 0.0) and _complex_weight_is_finite(coefficient)
+        for _key, coefficient in term_vector
+    )
+
+
+def _complex_weight_is_finite(value: _ComplexWeight) -> bool:
+    return isfinite(value[0]) and isfinite(value[1])
+
+
+def _canonical_complex_weight(value: _ComplexWeight) -> _ComplexWeight:
+    return (_canonical_zero(value[0]), _canonical_zero(value[1]))
+
+
+def _complex_weight_bits_equal(
+    left: _ComplexWeight,
+    right: _ComplexWeight,
+) -> bool:
+    return left[0].hex() == right[0].hex() and left[1].hex() == right[1].hex()
+
+
+def _current_evaluation_contract(current: CurrentNode) -> _CurrentContract:
+    """Return fields that can affect source, kernel, or propagator values."""
+
+    index = current.index
+    return (
+        int(index.particle_id),
+        int(index.external_mask),
+        index.external_labels,
+        index.ordered_external_labels,
+        int(index.helicity_ancestry),
+        int(index.chirality),
+        index.spin_state,
+        index.flavour_flow,
+        index.quantum_number_flow,
+        int(index.momentum_mask),
+        index.coupling_orders,
+        index.auxiliary_kind,
+        int(current.dimension),
+        bool(current.is_source),
+    )
+
+
+def _current_term_vector(
+    dag: GenericDAG,
+    current: CurrentNode,
+    interactions: list[InteractionNode],
+    model: Model,
+    *,
+    current_equivalences: list[_CurrentValueEquivalence | None],
+    equivalence_by_kind: dict[int, VertexEvaluationEquivalence],
+) -> _CurrentTermVector:
+    coefficients_by_key: dict[_EvaluationKey, list[_ComplexWeight]] = defaultdict(list)
+    for interaction in interactions:
+        kernel_equivalence = _kernel_equivalence(
+            model,
+            interaction.vertex_kind,
+            equivalence_by_kind,
+        )
+        left = current_equivalences[interaction.left_id]
+        right = current_equivalences[interaction.right_id]
+        if left is None or right is None:
+            raise ValueError(
+                "current-value equivalence requires parents from an earlier subset"
+            )
+        canonical_inputs, evaluation_factor = _canonical_interaction_evaluation(
+            kernel_equivalence,
+            left_id=interaction.left_id,
+            right_id=interaction.right_id,
+            left=left,
+            right=right,
+        )
+        term_key = (
+            kernel_equivalence.class_id,
+            canonical_inputs,
+            int(current.index.particle_id),
+            int(current.index.chirality),
+            _runtime_coupling_identity(
+                model,
+                vertex_kind=interaction.vertex_kind,
+                vertex_particles=interaction.vertex_particles,
+                coupling=interaction.coupling,
+            ),
+        )
+        coefficient = _complex_weight_mul(
+            interaction.color_weight,
+            evaluation_factor,
+        )
+        coefficients_by_key[term_key].append(coefficient)
+
+    terms: list[tuple[_EvaluationKey, _ComplexWeight]] = []
+    for grouped_term_key in sorted(coefficients_by_key):
+        coefficients = coefficients_by_key[grouped_term_key]
+        coefficient = (
+            _canonical_zero(fsum(value[0] for value in coefficients)),
+            _canonical_zero(fsum(value[1] for value in coefficients)),
+        )
+        if coefficient != (0.0, 0.0):
+            terms.append((grouped_term_key, coefficient))
+    return tuple(terms)
+
+
+def _kernel_equivalence(
+    model: Model,
+    kind: int,
+    cache: dict[int, VertexEvaluationEquivalence],
+) -> VertexEvaluationEquivalence:
+    cached = cache.get(kind)
+    if cached is not None:
+        return cached
+    equivalence = model.vertex_evaluation_equivalence(kind)
+    if not equivalence.verified:
+        model_type = f"{type(model).__module__}.{type(model).__qualname__}"
+        equivalence = VertexEvaluationEquivalence(class_id=f"{model_type}:{int(kind)}")
+    cache[kind] = equivalence
+    return equivalence
+
+
+def _runtime_coupling_identity(
+    model: Model,
+    *,
+    vertex_kind: int,
+    vertex_particles: tuple[int, int, int],
+    coupling: tuple[float, float],
+) -> tuple[tuple[float, float], tuple[tuple[int, str], ...]]:
+    """Return defaults plus stable mutable-parameter provenance for reuse."""
+
+    names = runtime_coupling_parameter_names(
+        vertex_kind,
+        vertex_particles,
+        coupling,
+        model=model,
+    )
+    provenance = tuple((0, "") if name is None else (1, str(name)) for name in names)
+    return coupling, provenance
+
+
+def _negate_term_vector(vector: _CurrentTermVector) -> _CurrentTermVector:
+    return tuple((key, (-value[0], -value[1])) for key, value in vector)
+
+
+def _complex_weight_mul(
+    left: _ComplexWeight,
+    right: _ComplexWeight,
+) -> _ComplexWeight:
+    return (
+        left[0] * right[0] - left[1] * right[1],
+        left[0] * right[1] + left[1] * right[0],
+    )
+
+
+def _canonical_zero(value: float) -> float:
+    return 0.0 if value == 0.0 else value
+
+
+__all__ = [
+    "GENERIC_DAG_NUMERICAL_SOURCE_SEMANTICS_ABI",
+    "NUMERICAL_CURRENT_CAPTURE_ABI",
+    "NUMERICAL_CURRENT_CAPTURE_OUTPUT_PARTITION_ABI",
+    "NUMERICAL_CURRENT_RELATION_CERTIFICATE_ALGORITHM",
+    "NUMERICAL_CURRENT_RELATION_SET_ABI",
+    "NUMERICAL_CURRENT_RELATION_WARNING",
+    "NUMERICAL_CURRENT_RELATION_WARNING_CODE",
+    "RELATION_DISCOVERY_CERTIFICATE_ALGORITHM",
+    "RELATION_DISCOVERY_SCHEMA_VERSION",
+    "DynamicColorProjectionCertificate",
+    "ExactCurrentRelationCertificate",
+    "NumericalCurrentAppliedMapping",
+    "NumericalCurrentObservationDiscoveryReport",
+    "NumericalCurrentObservationDiscoveryResult",
+    "NumericalCurrentRelationApplicationReport",
+    "NumericalCurrentRelationApplicationResult",
+    "NumericalCurrentRelationCertificate",
+    "RecursiveEvaluationReuseTracker",
+    "RelationDiscoveryReport",
+    "RelationDiscoveryResult",
+    "apply_numerical_current_relation_certificates",
+    "assign_recursive_current_evaluation_reuse",
+    "certify_numerical_current_observations",
+    "discover_generic_dag_numerical_current_relations",
+    "discover_recursive_evaluation_relations",
+    "dynamic_color_projection_not_applicable_report",
+    "generic_dag_numerical_capture_output_partition_sha256",
+    "generic_dag_numerical_model_parameter_schema_sha256",
+    "generic_dag_numerical_runtime_schema_sha256",
+    "generic_dag_numerical_source_dag_sha256",
+    "generic_dag_numerical_source_semantics_sha256",
+    "project_rectangular_dynamic_color_classes",
+    "verify_dag_relation_certificates",
+    "verify_numerical_current_relation_certificate",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/dag_ordering.py b/pyamplicol/src/pyamplicol/generation/dag_ordering.py
new file mode 100644
index 0000000000..9c4509d973
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/dag_ordering.py
@@ -0,0 +1,575 @@
+# SPDX-License-Identifier: 0BSD
+"""Color-order and closure-mask algorithms for generic DAG generation."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+from ..color.plan import GenericColorPlan, LCColorSector
+from ..models._physics_ir import ContractionIR
+from ..models.base import Model
+from ..processes.ir import CanonicalProcessIR
+from .dag_types import CurrentIndex
+
+if TYPE_CHECKING:
+    from .dag_color import ColorEngine
+
+
+def _known_color_representation(model: Model, particle_id: int) -> int | None:
+    """Return explicit model colour metadata without guessing from identity."""
+
+    try:
+        return int(model.color_rep(int(particle_id)))
+    except (KeyError, NotImplementedError, TypeError, ValueError):
+        return None
+
+
+def _known_fermion_statistics(model: Model, particle_id: int) -> bool | None:
+    """Return explicit model statistics, or ``None`` when they are unavailable."""
+
+    try:
+        return bool(model.is_fermion(int(particle_id)))
+    except (KeyError, NotImplementedError, TypeError, ValueError):
+        return None
+
+
+def _direct_contraction_ir(
+    model: Model,
+    left: CurrentIndex,
+    right: CurrentIndex,
+) -> ContractionIR | None:
+    return model.direct_contraction_ir(
+        left.particle_id,
+        right.particle_id,
+        left_chirality=left.chirality,
+        right_chirality=right.chirality,
+    )
+
+
+def _sector_group_indices_for_label(
+    sector: LCColorSector,
+    label: int,
+) -> tuple[int, ...]:
+    return tuple(
+        index
+        for index, group in enumerate(sector.line_label_groups)
+        if label in set(group)
+    )
+
+
+def _line_positions(labels: Iterable[int], order: tuple[int, ...]) -> tuple[int, ...]:
+    positions = {label: index for index, label in enumerate(order)}
+    return tuple(positions[label] for label in labels if label in positions)
+
+
+def _labels_projected_to_word(
+    labels: Iterable[int],
+    word: tuple[int, ...],
+) -> tuple[int, ...]:
+    word_labels = set(word)
+    return tuple(label for label in labels if label in word_labels)
+
+
+def _positions_contiguous(positions: tuple[int, ...]) -> bool:
+    if not positions:
+        return True
+    return positions == tuple(range(positions[0], positions[-1] + 1))
+
+
+def _word_contains_ordered_segment(
+    word: tuple[int, ...],
+    segment: tuple[int, ...],
+) -> bool:
+    if not segment or len(segment) > len(word):
+        return False
+    width = len(segment)
+    return any(
+        tuple(word[start : start + width]) == segment
+        for start in range(len(word) - width + 1)
+    )
+
+
+def _ordered_combination_matches_word(
+    left_labels: Iterable[int],
+    right_labels: Iterable[int],
+    word: tuple[int, ...],
+) -> bool:
+    return _ordered_combination_segment(left_labels, right_labels, word) is not None
+
+
+def _closure_combination_matches_word(
+    left_labels: Iterable[int],
+    right_labels: Iterable[int],
+    word: tuple[int, ...],
+) -> bool:
+    """Return whether two endpoint label sets close one colour word.
+
+    Intermediate current construction must preserve the actual line order because
+    it fixes where colour-singlet insertions may attach.  Final closure is
+    different: the sink current can be oriented opposite to the sector's primary
+    colour word, while still representing the same contiguous endpoint segment.
+    Closure therefore checks contiguity of the projected coloured label sets, not
+    their internal iteration order.
+    """
+
+    left_positions = tuple(sorted(_line_positions(left_labels, word)))
+    right_positions = tuple(sorted(_line_positions(right_labels, word)))
+    if not left_positions or not right_positions:
+        return False
+    if set(left_positions) & set(right_positions):
+        return False
+    union = tuple(sorted((*left_positions, *right_positions)))
+    return (
+        _positions_contiguous(left_positions)
+        and _positions_contiguous(right_positions)
+        and _positions_contiguous(union)
+    )
+
+
+def _shared_single_trace_closure_matches_word(
+    left_labels: Iterable[int],
+    right_labels: Iterable[int],
+    word: tuple[int, ...],
+) -> bool:
+    left_projected = _labels_projected_to_word(left_labels, word)
+    right_projected = _labels_projected_to_word(right_labels, word)
+    return (*left_projected, *right_projected) == word
+
+
+def _shared_lc_closure_matches_word(
+    left_labels: Iterable[int],
+    right_labels: Iterable[int],
+    word: tuple[int, ...],
+) -> bool:
+    left_projected = _labels_projected_to_word(left_labels, word)
+    right_projected = _labels_projected_to_word(right_labels, word)
+    if not left_projected or not right_projected:
+        return False
+    return (*left_projected, *right_projected) == word
+
+
+def _ordered_combination_segment(
+    left_labels: Iterable[int],
+    right_labels: Iterable[int],
+    word: tuple[int, ...],
+) -> tuple[int, ...] | None:
+    left_positions = _line_positions(left_labels, word)
+    right_positions = _line_positions(right_labels, word)
+    if not left_positions and not right_positions:
+        return ()
+    if not left_positions or not right_positions:
+        positions = left_positions or right_positions
+        if not _positions_contiguous(positions):
+            return None
+        return tuple(word[positions[0] : positions[-1] + 1])
+    union = tuple(sorted((*left_positions, *right_positions)))
+    if (
+        _positions_contiguous(left_positions)
+        and _positions_contiguous(right_positions)
+        and _positions_contiguous(union)
+        and max(left_positions) < min(right_positions)
+    ):
+        return tuple(word[union[0] : union[-1] + 1])
+    return None
+
+
+def _lc_all_adjoint_symmetry_order_variants(
+    left: tuple[int, ...],
+    right: tuple[int, ...],
+    *,
+    left_all_adjoint: bool,
+    right_all_adjoint: bool,
+    result_reflection_proven: bool,
+    fold_result_reflections: bool = True,
+) -> tuple[tuple[tuple[int, ...], tuple[float, float]], ...]:
+    """Return signed pure-adjoint LC symmetry variants."""
+
+    n1 = len(left)
+    n2 = len(right)
+    switch1 = 2 if left_all_adjoint and n1 >= 2 else 1
+    switch2 = 2 if right_all_adjoint and n2 >= 2 else 1
+    switch3 = 2 if result_reflection_proven else 1
+    variants: list[tuple[tuple[int, ...], tuple[float, float]]] = []
+    for i in range(1, switch1 + 1):
+        for j in range(1, switch2 + 1):
+            for k in range(1, switch3 + 1):
+                invert = 0
+                if (i == 2 and k == 1) or (j == 2 and k == 2):
+                    invert |= 1
+                if (i == 2 and k == 2) or (j == 2 and k == 1):
+                    invert |= 2
+                if k == 1:
+                    first = tuple(reversed(left)) if invert & 1 else left
+                    second = tuple(reversed(right)) if invert & 2 else right
+                else:
+                    first = tuple(reversed(right)) if invert & 1 else right
+                    second = tuple(reversed(left)) if invert & 2 else left
+                proposed = (*first, *second)
+                if (
+                    result_reflection_proven
+                    and fold_result_reflections
+                    and not _lc_all_adjoint_symmetry_order_kept(proposed)
+                ):
+                    continue
+                negative = (
+                    (k == 2) ^ (j == 2 and n2 % 2 == 0) ^ (i == 2 and n1 % 2 == 0)
+                )
+                variants.append((proposed, (-1.0, 0.0) if negative else (1.0, 0.0)))
+    return tuple(variants)
+
+
+def _lc_all_adjoint_symmetry_order_kept(labels: tuple[int, ...]) -> bool:
+    if not labels:
+        return False
+    min_label = min(labels)
+    max_label = max(labels)
+    return labels.index(min_label) < labels.index(max_label)
+
+
+def _complex_weight_mul(
+    left: tuple[float, float],
+    right: tuple[float, float],
+) -> tuple[float, float]:
+    return (
+        left[0] * right[0] - left[1] * right[1],
+        left[0] * right[1] + left[1] * right[0],
+    )
+
+
+def _canonical_lc_ordered_labels(
+    labels: Iterable[int],
+    sector: LCColorSector,
+) -> tuple[int, ...]:
+    label_tuple = tuple(labels)
+    label_set = set(label_tuple)
+    for word in _sector_intermediate_order_words(sector):
+        positions = _line_positions(label_tuple, word)
+        if not positions:
+            continue
+        if not _positions_contiguous(positions):
+            continue
+        word_labels = set(word)
+        extras = tuple(sorted(label for label in label_set if label not in word_labels))
+        segment = tuple(word[positions[0] : positions[-1] + 1])
+        if not _line_local_singlet_extras_allowed(segment, extras, sector):
+            continue
+        return (*segment, *extras)
+    return tuple(sorted(label_set))
+
+
+def _sector_intermediate_order_words(
+    sector: LCColorSector,
+    *,
+    include_compatible_traversals: bool = True,
+    process: CanonicalProcessIR | None = None,
+) -> tuple[tuple[int, ...], ...]:
+    """Return LC words used for intermediate current construction.
+
+    A physical multi-line sector admits several block traversals.  Cyclically
+    equivalent traversals describe the same closure, so normalize every word
+    to the physical sector's authenticated closure sink and deduplicate it.
+    These are private compatibility words, not public legacy amplitude-order
+    representatives.  This retains the distinct cyclic classes needed by
+    three or more open lines without creating duplicate physical sectors.
+
+    Non-LC recursion keeps one sector-private traversal.  For open lines this
+    is the authenticated canonical closure traversal, so intermediate currents
+    and the final sink use the same orientation without changing the public
+    physical colour word.
+    """
+
+    physical_words = sector.color_words
+    if not include_compatible_traversals:
+        if sector.kind == "open-lines" and process is not None:
+            canonical_word = sector.canonical_closure_traversal_word(process)
+            return (canonical_word,) if canonical_word else physical_words
+        return physical_words or sector.admissible_traversal_words
+    if sector.kind != "open-lines" or not physical_words or not physical_words[0]:
+        return physical_words or sector.admissible_traversal_words
+
+    sink_label = (
+        int(physical_words[0][-1])
+        if process is None
+        else sector.canonical_closure_sink_label(process)
+    )
+    if sink_label is None:
+        return physical_words
+    words: list[tuple[int, ...]] = []
+    seen: set[tuple[int, ...]] = set()
+    for raw_word in sector.admissible_traversal_words:
+        normalized = tuple(int(label) for label in raw_word)
+        if sink_label in normalized:
+            sink_index = normalized.index(sink_label)
+            word = (
+                *normalized[sink_index + 1 :],
+                *normalized[: sink_index + 1],
+            )
+        else:
+            word = normalized
+        if word in seen:
+            continue
+        seen.add(word)
+        words.append(word)
+    return tuple(words)
+
+
+def _lc_word_with_sink_last(
+    word: Iterable[int],
+    sink_label: int | None,
+) -> tuple[int, ...]:
+    normalized = tuple(int(label) for label in word)
+    if sink_label is None or sink_label not in normalized:
+        return normalized
+    sink_index = normalized.index(sink_label)
+    rotated = (
+        *normalized[sink_index + 1 :],
+        *normalized[: sink_index + 1],
+    )
+    current_word = rotated[:-1]
+    if current_word and not _lc_all_adjoint_symmetry_order_kept(current_word):
+        current_word = tuple(reversed(current_word))
+    return (*current_word, rotated[-1])
+
+
+def _line_local_singlet_extras_allowed(
+    colored_segment: Iterable[int],
+    extras: Iterable[int],
+    sector: LCColorSector,
+) -> bool:
+    extra_set = set(extras)
+    if not extra_set:
+        return True
+    if sector.kind != "open-lines":
+        return extra_set.issubset(set(sector.singlet_labels))
+    return extra_set.issubset(set(sector.singlet_labels))
+
+
+def _labels_mask(labels: Iterable[int]) -> int:
+    mask = 0
+    for label in labels:
+        mask |= 1 << (label - 1)
+    return mask
+
+
+def _mask_labels(mask: int) -> tuple[int, ...]:
+    return tuple(index + 1 for index in range(mask.bit_length()) if mask & (1 << index))
+
+
+def _canonical_sink_mask(process_ir: CanonicalProcessIR, model: Model) -> int:
+    fermion_labels = [
+        leg.label
+        for leg in process_ir.legs
+        if leg.outgoing_pdg is not None
+        and _known_fermion_statistics(model, int(leg.outgoing_pdg)) is True
+    ]
+    if fermion_labels:
+        return 1 << (min(fermion_labels) - 1)
+    labels = [leg.label for leg in process_ir.legs if leg.outgoing_pdg is not None]
+    if not labels:
+        return 0
+    return 1 << (min(labels) - 1)
+
+
+def _closure_candidate_splits(
+    process_ir: CanonicalProcessIR,
+    model: Model,
+    color_engine: ColorEngine,
+    *,
+    reference_color_order: tuple[int, ...] | None = None,
+) -> tuple[tuple[int, int], ...]:
+    full_mask = _labels_mask(leg.label for leg in process_ir.legs)
+    splits: list[tuple[int, int]] = []
+    split_seen: set[tuple[int, int]] = set()
+    sink_labels: list[int] = []
+    if color_engine.shared_lc_fixed_sink_label is not None:
+        sink_labels.append(color_engine.shared_lc_fixed_sink_label)
+    sectors = color_engine.color_plan.sectors
+    if not sink_labels and (
+        color_engine.color_plan.color_accuracy == "lc"
+        or color_engine.shared_single_trace
+        or any(sector.kind == "open-lines" for sector in sectors)
+    ):
+        if reference_color_order is not None:
+            selected_sectors = tuple(
+                sector
+                for sector in sectors
+                if reference_color_order in sector.admissible_traversal_words
+            )
+            if selected_sectors:
+                sectors = selected_sectors
+        for sector in sectors:
+            # A public reference word selects a physical sector, but its
+            # terminal label is not a private recursion sink.  Final closure
+            # always uses that sector's authenticated canonical traversal.
+            sink_label = sector.canonical_closure_sink_label(process_ir)
+            if sink_label is not None:
+                sink_labels.append(sink_label)
+    if not sink_labels and reference_color_order:
+        leg_by_label = {leg.label: leg for leg in process_ir.legs}
+        colored_reference_labels: list[int] = []
+        ordered_reference_labels: list[int] = []
+        for raw_label in reference_color_order:
+            label = int(raw_label)
+            if not (full_mask & (1 << (label - 1))):
+                continue
+            ordered_reference_labels.append(label)
+            leg = leg_by_label.get(label)
+            if leg is None or leg.outgoing_pdg is None:
+                continue
+            representation = _known_color_representation(
+                model,
+                int(leg.outgoing_pdg),
+            )
+            if representation is not None and representation != 1:
+                colored_reference_labels.append(label)
+        if colored_reference_labels:
+            sink_labels.append(colored_reference_labels[-1])
+        elif ordered_reference_labels:
+            sink_labels.append(ordered_reference_labels[-1])
+    if not sink_labels:
+        fallback_sink_mask = _canonical_sink_mask(process_ir, model)
+        fallback_sink_labels = _mask_labels(fallback_sink_mask)
+        if fallback_sink_labels:
+            sink_labels.append(fallback_sink_labels[0])
+    seen: set[int] = set()
+    for label in sink_labels:
+        if label in seen:
+            continue
+        seen.add(label)
+        sink_mask = 1 << (label - 1)
+        if not (sink_mask & full_mask):
+            continue
+        split = (full_mask ^ sink_mask, sink_mask)
+        if split in split_seen:
+            continue
+        split_seen.add(split)
+        splits.append(split)
+    return tuple(splits)
+
+
+def _closure_side_reachable_masks(
+    full_mask: int,
+    candidate_splits: Iterable[tuple[int, int]],
+) -> frozenset[int]:
+    """Return current masks that can feed one configured amplitude closure.
+
+    The generic forward sweep otherwise builds every locally valid current for
+    every proper subset, then removes dead currents after closure.  AmpliCol's
+    library generation is faster because it knows which endpoint side each
+    current can ultimately feed.  This helper applies the same idea without
+    naming a process family: once the generic closure splitter has selected the
+    possible amplitude endpoint masks, any useful intermediate current must be
+    a submask of one of those endpoint masks.
+    """
+
+    allowed: set[int] = set()
+    for left_mask, right_mask in candidate_splits:
+        for side_mask in (left_mask, right_mask):
+            submask = side_mask & full_mask
+            while submask:
+                allowed.add(submask)
+                submask = (submask - 1) & side_mask
+    return frozenset(allowed)
+
+
+def _lc_color_order_reachable_masks(
+    process_ir: CanonicalProcessIR,
+    color_plan: GenericColorPlan,
+    model: Model,
+) -> frozenset[int] | None:
+    """Return subset masks compatible with at least one LC colour word.
+
+    This is process-generic pruning.  It only uses model colour
+    representations and the LC words produced by the colour planner.  Any
+    useful coloured current in a colour-ordered recursion must cover a
+    contiguous segment of one compatibility word.  Colour singlets are left as
+    attachments to those segments because their allowed positions are governed
+    by ordinary model vertices and the existing singlet-order rule.
+    """
+
+    if not color_plan.sectors:
+        return None
+
+    full_mask = _labels_mask(leg.label for leg in process_ir.legs)
+    colored_labels: set[int] = set()
+    singlet_labels: set[int] = set()
+    for leg in process_ir.legs:
+        if leg.outgoing_pdg is None:
+            return None
+        representation = _known_color_representation(model, int(leg.outgoing_pdg))
+        if representation is None:
+            return None
+        if representation != 1:
+            colored_labels.add(leg.label)
+        else:
+            singlet_labels.add(leg.label)
+
+    allowed: set[int] = set()
+
+    if not colored_labels:
+        return frozenset(_nonzero_submasks(full_mask))
+
+    for sector in color_plan.sectors:
+        sector_colored_labels = {
+            label for group in sector.coloured_label_groups for label in group
+        }
+        if sector_colored_labels != colored_labels:
+            return None
+        if set(sector.singlet_labels) != singlet_labels:
+            return None
+        if sector.kind == "open-lines":
+            for singlet_submask in _submasks_for_labels(sector.singlet_labels):
+                if singlet_submask:
+                    allowed.add(singlet_submask)
+        for raw_word in sector.admissible_traversal_words:
+            word = tuple(label for label in raw_word if label in colored_labels)
+            for start in range(len(word)):
+                segment_mask = 0
+                for stop in range(start, len(word)):
+                    segment_mask |= 1 << (word[stop] - 1)
+                    allowed.add(segment_mask)
+                    segment_labels = tuple(word[start : stop + 1])
+                    line_singlets = _line_local_singlet_labels_for_segment(
+                        sector,
+                        segment_labels,
+                    )
+                    for singlet_submask in _submasks_for_labels(line_singlets):
+                        allowed.add(segment_mask | singlet_submask)
+
+    for label in colored_labels:
+        allowed.add(1 << (label - 1))
+    for label in singlet_labels:
+        allowed.add(1 << (label - 1))
+    return frozenset(mask for mask in allowed if mask & full_mask)
+
+
+def _line_local_singlet_labels_for_segment(
+    sector: LCColorSector,
+    colored_segment: Iterable[int],
+) -> tuple[int, ...]:
+    if sector.kind != "open-lines":
+        return sector.singlet_labels
+    return sector.singlet_labels
+
+
+def _submasks_for_labels(labels: Iterable[int]) -> tuple[int, ...]:
+    label_tuple = tuple(labels)
+    masks: list[int] = []
+    count = len(label_tuple)
+    for bits in range(1 << count):
+        mask = 0
+        for index, label in enumerate(label_tuple):
+            if bits & (1 << index):
+                mask |= 1 << (label - 1)
+        masks.append(mask)
+    return tuple(masks)
+
+
+def _nonzero_submasks(mask: int) -> tuple[int, ...]:
+    submasks: list[int] = []
+    submask = mask
+    while submask:
+        submasks.append(submask)
+        submask = (submask - 1) & mask
+    return tuple(submasks)
diff --git a/pyamplicol/src/pyamplicol/generation/dag_reachability.py b/pyamplicol/src/pyamplicol/generation/dag_reachability.py
new file mode 100644
index 0000000000..f8da362901
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/dag_reachability.py
@@ -0,0 +1,590 @@
+# SPDX-License-Identifier: 0BSD
+"""Particle-species and coupling-order reachability for generic DAGs."""
+
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Iterable, Mapping
+from typing import TYPE_CHECKING
+
+from ..models.base import CouplingOrders, Model, Vertex
+from ..processes.ir import CanonicalProcessIR
+from .dag_ordering import _labels_mask
+from .dag_types import ColorState
+
+if TYPE_CHECKING:
+    from .dag_color import ColorEngine
+
+
+def _normalize_coupling_order_limits(
+    limits: Mapping[str, int] | None,
+) -> dict[str, int]:
+    if limits is None:
+        return {}
+    return {
+        str(name).upper(): int(value)
+        for name, value in limits.items()
+        if int(value) >= 0
+    }
+
+
+def _coupling_orders_within_limits(
+    orders: tuple[tuple[str, int], ...],
+    limits: Mapping[str, int],
+) -> bool:
+    if not limits:
+        return True
+    order_map = {str(name).upper(): int(value) for name, value in orders}
+    return all(order_map.get(name, 0) <= int(limit) for name, limit in limits.items())
+
+
+def _combine_coupling_order_tuples(
+    *orders: CouplingOrders,
+) -> CouplingOrders:
+    totals: dict[str, int] = {}
+    for order_tuple in orders:
+        for name, value in order_tuple:
+            totals[str(name).upper()] = totals.get(str(name).upper(), 0) + int(value)
+    return tuple(sorted((name, value) for name, value in totals.items() if value))
+
+
+def _lc_line_groups_within_limit(
+    color_state: ColorState,
+    limit: int | None,
+) -> bool:
+    if limit is None or color_state.accuracy != "lc":
+        return True
+    return len(color_state.line_groups) <= limit
+
+
+def _right_particles_by_left(
+    model: Model,
+    *,
+    color_accuracy: str,
+) -> dict[int, tuple[int, ...]]:
+    rights: dict[int, set[int]] = {}
+    for vertex in model.iter_vertices(color_accuracy=color_accuracy):
+        rights.setdefault(vertex.particles[0], set()).add(vertex.particles[1])
+    return {
+        left: tuple(sorted(right_particles)) for left, right_particles in rights.items()
+    }
+
+
+def _closure_right_particles_by_left(
+    model: Model,
+    *,
+    color_accuracy: str,
+) -> dict[int, tuple[int, ...]]:
+    """Return sparse vertex and direct-contraction partners by left species."""
+
+    rights = {
+        left: set(right_particles)
+        for left, right_particles in _right_particles_by_left(
+            model,
+            color_accuracy=color_accuracy,
+        ).items()
+    }
+    for particle in model.particles.values():
+        rights.setdefault(particle.pdg, set()).add(particle.anti_pdg)
+        rights.setdefault(particle.anti_pdg, set()).add(particle.pdg)
+    return {
+        left: tuple(sorted(right_particles)) for left, right_particles in rights.items()
+    }
+
+
+UsefulStateMap = dict[int, dict[int, frozenset[CouplingOrders]]]
+_ReachabilityState = tuple[int, int, CouplingOrders]
+
+
+def _useful_states_by_mask(
+    process_ir: CanonicalProcessIR,
+    model: Model,
+    color_engine: ColorEngine,
+    closure_candidate_splits: Iterable[tuple[int, int]],
+    closure_reachable_masks: frozenset[int] | None,
+    color_order_reachable_masks: frozenset[int] | None,
+    *,
+    max_coupling_orders: Mapping[str, int],
+    ignored_particle_ids: frozenset[int],
+    ignored_vertex_kinds: frozenset[int],
+) -> UsefulStateMap:
+    """Return current states that can feed at least one amplitude closure.
+
+    The full current table is keyed by helicity, chirality, flavour flow and
+    colour state.  This prepass intentionally ignores those expensive labels,
+    but it keeps particle id and model coupling-order totals.  The order
+    tracking lets user-supplied generic constraints such as ``QED=1`` prune
+    impossible branches before the expensive helicity/current sweep, without
+    recognizing any process family.  It is allowed to overestimate, but it must
+    never depend on a process-family name.
+    """
+
+    full_mask = _labels_mask(leg.label for leg in process_ir.legs)
+    possible: dict[int, dict[int, set[CouplingOrders]]] = {}
+    for leg in process_ir.legs:
+        if leg.outgoing_pdg is None:
+            continue
+        particle_id = int(leg.outgoing_pdg)
+        if particle_id in ignored_particle_ids:
+            continue
+        possible.setdefault(1 << (leg.label - 1), {}).setdefault(
+            particle_id,
+            set(),
+        ).add(())
+
+    reverse_transitions: dict[
+        _ReachabilityState,
+        set[tuple[_ReachabilityState, _ReachabilityState]],
+    ] = {}
+    vertices_by_input: dict[tuple[int, int], tuple[Vertex, ...]] = {}
+    right_particles_by_left = _right_particles_by_left(
+        model,
+        color_accuracy=process_ir.color_accuracy,
+    )
+    for mask in _masks_by_size(full_mask):
+        if mask & (mask - 1) == 0 or mask == full_mask:
+            continue
+        if not _mask_allowed_by_reachability(
+            mask,
+            closure_reachable_masks,
+            color_order_reachable_masks,
+        ):
+            continue
+        for left_mask, right_mask in _ordered_splits(mask):
+            if not (
+                _mask_allowed_by_reachability(
+                    left_mask,
+                    closure_reachable_masks,
+                    color_order_reachable_masks,
+                )
+                and _mask_allowed_by_reachability(
+                    right_mask,
+                    closure_reachable_masks,
+                    color_order_reachable_masks,
+                )
+            ):
+                continue
+            left_species = possible.get(left_mask)
+            right_species = possible.get(right_mask)
+            if not left_species or not right_species:
+                continue
+            for left_particle, left_orders_set in tuple(left_species.items()):
+                for right_particle in right_particles_by_left.get(left_particle, ()):
+                    right_orders_set = right_species.get(right_particle)
+                    if not right_orders_set:
+                        continue
+                    vertex_key = (left_particle, right_particle)
+                    vertices = vertices_by_input.get(vertex_key)
+                    if vertices is None:
+                        vertices = model.vertices_accepting(
+                            left_particle,
+                            right_particle,
+                            color_accuracy=process_ir.color_accuracy,
+                        )
+                        vertices_by_input[vertex_key] = vertices
+                    for vertex in vertices:
+                        if (
+                            vertex.kind in ignored_vertex_kinds
+                            or vertex.particles[2] in ignored_particle_ids
+                            or not color_engine.vertex_allowed(vertex)
+                            or model.skip_duplicate_vertex_orientation(vertex)
+                        ):
+                            continue
+                        result_particle = vertex.particles[2]
+                        for left_orders in tuple(left_orders_set):
+                            for right_orders in tuple(right_orders_set):
+                                coupling_orders = _combine_coupling_order_tuples(
+                                    left_orders,
+                                    right_orders,
+                                    model.vertex_coupling_orders(vertex),
+                                )
+                                if not _coupling_orders_within_limits(
+                                    coupling_orders,
+                                    max_coupling_orders,
+                                ):
+                                    continue
+                                possible.setdefault(mask, {}).setdefault(
+                                    result_particle,
+                                    set(),
+                                ).add(coupling_orders)
+                                reverse_transitions.setdefault(
+                                    (mask, result_particle, coupling_orders),
+                                    set(),
+                                ).add(
+                                    (
+                                        (left_mask, left_particle, left_orders),
+                                        (right_mask, right_particle, right_orders),
+                                    )
+                                )
+
+    closure_right_particles_by_left = _closure_right_particles_by_left(
+        model,
+        color_accuracy=process_ir.color_accuracy,
+    )
+    useful: dict[int, dict[int, set[CouplingOrders]]] = {}
+    for left_mask, right_mask in closure_candidate_splits:
+        left_species = possible.get(left_mask)
+        right_species = possible.get(right_mask)
+        if not left_species or not right_species:
+            continue
+        for left_particle, left_orders_set in left_species.items():
+            for right_particle in closure_right_particles_by_left.get(
+                left_particle,
+                (),
+            ):
+                right_orders_set = right_species.get(right_particle)
+                if not right_orders_set:
+                    continue
+                if model.direct_contraction_possible(left_particle, right_particle):
+                    for left_orders in left_orders_set:
+                        for right_orders in right_orders_set:
+                            total_orders = _combine_coupling_order_tuples(
+                                left_orders,
+                                right_orders,
+                                (),
+                            )
+                            if not _coupling_orders_within_limits(
+                                total_orders,
+                                max_coupling_orders,
+                            ):
+                                continue
+                            useful.setdefault(left_mask, {}).setdefault(
+                                left_particle,
+                                set(),
+                            ).add(left_orders)
+                            useful.setdefault(right_mask, {}).setdefault(
+                                right_particle,
+                                set(),
+                            ).add(right_orders)
+                for vertex in model.vertices_accepting(
+                    left_particle,
+                    right_particle,
+                    color_accuracy=process_ir.color_accuracy,
+                ):
+                    if (
+                        vertex.kind in ignored_vertex_kinds
+                        or vertex.particles[2] in ignored_particle_ids
+                        or not color_engine.vertex_allowed(vertex)
+                        or model.skip_duplicate_vertex_orientation(vertex)
+                    ):
+                        continue
+                    if model.closure_contraction_ir(vertex.particles[2]) is None:
+                        continue
+                    vertex_orders = model.vertex_coupling_orders(vertex)
+                    for left_orders in left_orders_set:
+                        for right_orders in right_orders_set:
+                            total_orders = _combine_coupling_order_tuples(
+                                left_orders,
+                                right_orders,
+                                vertex_orders,
+                            )
+                            if not _coupling_orders_within_limits(
+                                total_orders,
+                                max_coupling_orders,
+                            ):
+                                continue
+                            useful.setdefault(left_mask, {}).setdefault(
+                                left_particle,
+                                set(),
+                            ).add(left_orders)
+                            useful.setdefault(right_mask, {}).setdefault(
+                                right_particle,
+                                set(),
+                            ).add(right_orders)
+
+    pending = deque(
+        (mask, particle, orders)
+        for mask, species_orders in useful.items()
+        for particle, order_set in species_orders.items()
+        for orders in order_set
+    )
+    while pending:
+        result_state = pending.popleft()
+        for left_state, right_state in reverse_transitions.get(result_state, ()):
+            for parent_mask, parent_particle, parent_orders in (
+                left_state,
+                right_state,
+            ):
+                parent_useful = useful.setdefault(parent_mask, {}).setdefault(
+                    parent_particle,
+                    set(),
+                )
+                if parent_orders in parent_useful:
+                    continue
+                parent_useful.add(parent_orders)
+                pending.append((parent_mask, parent_particle, parent_orders))
+
+    return {
+        mask: {
+            particle: frozenset(orders)
+            for particle, orders in species_orders.items()
+            if orders
+        }
+        for mask, species_orders in useful.items()
+        if species_orders
+    }
+
+
+def _closure_total_coupling_orders(
+    process_ir: CanonicalProcessIR,
+    model: Model,
+    color_engine: ColorEngine,
+    closure_candidate_splits: Iterable[tuple[int, int]],
+    closure_reachable_masks: frozenset[int] | None,
+    color_order_reachable_masks: frozenset[int] | None,
+    *,
+    max_coupling_orders: Mapping[str, int],
+    ignored_particle_ids: frozenset[int],
+    ignored_vertex_kinds: frozenset[int],
+) -> frozenset[CouplingOrders]:
+    """Return model-reachable total coupling orders for amplitude closures."""
+
+    full_mask = _labels_mask(leg.label for leg in process_ir.legs)
+    possible: dict[int, dict[int, set[CouplingOrders]]] = {}
+    for leg in process_ir.legs:
+        if leg.outgoing_pdg is None:
+            continue
+        particle_id = int(leg.outgoing_pdg)
+        if particle_id in ignored_particle_ids:
+            continue
+        possible.setdefault(1 << (leg.label - 1), {}).setdefault(
+            particle_id,
+            set(),
+        ).add(())
+
+    vertices_by_input: dict[tuple[int, int], tuple[Vertex, ...]] = {}
+    right_particles_by_left = _right_particles_by_left(
+        model,
+        color_accuracy=process_ir.color_accuracy,
+    )
+    for mask in _masks_by_size(full_mask):
+        if mask & (mask - 1) == 0 or mask == full_mask:
+            continue
+        if not _mask_allowed_by_reachability(
+            mask,
+            closure_reachable_masks,
+            color_order_reachable_masks,
+        ):
+            continue
+        for left_mask, right_mask in _ordered_splits(mask):
+            if not (
+                _mask_allowed_by_reachability(
+                    left_mask,
+                    closure_reachable_masks,
+                    color_order_reachable_masks,
+                )
+                and _mask_allowed_by_reachability(
+                    right_mask,
+                    closure_reachable_masks,
+                    color_order_reachable_masks,
+                )
+            ):
+                continue
+            left_species = possible.get(left_mask)
+            right_species = possible.get(right_mask)
+            if not left_species or not right_species:
+                continue
+            for left_particle, left_orders_set in tuple(left_species.items()):
+                for right_particle in right_particles_by_left.get(left_particle, ()):
+                    right_orders_set = right_species.get(right_particle)
+                    if not right_orders_set:
+                        continue
+                    vertex_key = (left_particle, right_particle)
+                    vertices = vertices_by_input.get(vertex_key)
+                    if vertices is None:
+                        vertices = model.vertices_accepting(
+                            left_particle,
+                            right_particle,
+                            color_accuracy=process_ir.color_accuracy,
+                        )
+                        vertices_by_input[vertex_key] = vertices
+                    for vertex in vertices:
+                        if (
+                            vertex.kind in ignored_vertex_kinds
+                            or vertex.particles[2] in ignored_particle_ids
+                            or not color_engine.vertex_allowed(vertex)
+                            or model.skip_duplicate_vertex_orientation(vertex)
+                        ):
+                            continue
+                        result_particle = vertex.particles[2]
+                        order_bucket = possible.setdefault(mask, {}).setdefault(
+                            result_particle,
+                            set(),
+                        )
+                        vertex_orders = model.vertex_coupling_orders(vertex)
+                        for left_orders in tuple(left_orders_set):
+                            for right_orders in tuple(right_orders_set):
+                                coupling_orders = _combine_coupling_order_tuples(
+                                    left_orders,
+                                    right_orders,
+                                    vertex_orders,
+                                )
+                                if not _coupling_orders_within_limits(
+                                    coupling_orders,
+                                    max_coupling_orders,
+                                ):
+                                    continue
+                                order_bucket.add(coupling_orders)
+                        possible[mask][result_particle] = set(
+                            _pareto_minimal_coupling_orders(order_bucket)
+                        )
+
+    closure_right_particles_by_left = _closure_right_particles_by_left(
+        model,
+        color_accuracy=process_ir.color_accuracy,
+    )
+    totals: set[CouplingOrders] = set()
+    for left_mask, right_mask in closure_candidate_splits:
+        left_species = possible.get(left_mask)
+        right_species = possible.get(right_mask)
+        if not left_species or not right_species:
+            continue
+        for left_particle, left_orders_set in left_species.items():
+            for right_particle in closure_right_particles_by_left.get(
+                left_particle,
+                (),
+            ):
+                right_orders_set = right_species.get(right_particle)
+                if not right_orders_set:
+                    continue
+                if model.direct_contraction_possible(left_particle, right_particle):
+                    for left_orders in left_orders_set:
+                        for right_orders in right_orders_set:
+                            total_orders = _combine_coupling_order_tuples(
+                                left_orders,
+                                right_orders,
+                                (),
+                            )
+                            if _coupling_orders_within_limits(
+                                total_orders,
+                                max_coupling_orders,
+                            ):
+                                totals.add(total_orders)
+                for vertex in model.vertices_accepting(
+                    left_particle,
+                    right_particle,
+                    color_accuracy=process_ir.color_accuracy,
+                ):
+                    if (
+                        vertex.kind in ignored_vertex_kinds
+                        or vertex.particles[2] in ignored_particle_ids
+                        or not color_engine.vertex_allowed(vertex)
+                        or model.skip_duplicate_vertex_orientation(vertex)
+                    ):
+                        continue
+                    if model.closure_contraction_ir(vertex.particles[2]) is None:
+                        continue
+                    vertex_orders = model.vertex_coupling_orders(vertex)
+                    for left_orders in left_orders_set:
+                        for right_orders in right_orders_set:
+                            total_orders = _combine_coupling_order_tuples(
+                                left_orders,
+                                right_orders,
+                                vertex_orders,
+                            )
+                            if _coupling_orders_within_limits(
+                                total_orders,
+                                max_coupling_orders,
+                            ):
+                                totals.add(total_orders)
+    return frozenset(_pareto_minimal_coupling_orders(totals))
+
+
+def _coupling_order_degree(
+    orders: CouplingOrders,
+    *,
+    hierarchies: Mapping[str, int] | None = None,
+) -> int:
+    priorities = hierarchies or {}
+    return sum(
+        int(value) * max(1, int(priorities.get(str(name).upper(), 1)))
+        for name, value in orders
+    )
+
+
+def _coupling_order_envelope(orders: Iterable[CouplingOrders]) -> dict[str, int]:
+    envelope: dict[str, int] = {}
+    for order_tuple in orders:
+        for name, value in order_tuple:
+            normalized = str(name).upper()
+            envelope[normalized] = max(envelope.get(normalized, 0), int(value))
+    return envelope
+
+
+def _pareto_minimal_coupling_orders(
+    orders: Iterable[CouplingOrders],
+) -> tuple[CouplingOrders, ...]:
+    normalized = tuple(sorted(set(orders)))
+    minimal: list[CouplingOrders] = []
+    for candidate in normalized:
+        if any(
+            _coupling_orders_dominate(other, candidate)
+            for other in normalized
+            if other != candidate
+        ):
+            continue
+        minimal.append(candidate)
+    return tuple(minimal)
+
+
+def _coupling_orders_dominate(left: CouplingOrders, right: CouplingOrders) -> bool:
+    left_map = dict(left)
+    right_map = dict(right)
+    keys = set(left_map) | set(right_map)
+    return all(left_map.get(key, 0) <= right_map.get(key, 0) for key in keys) and any(
+        left_map.get(key, 0) < right_map.get(key, 0) for key in keys
+    )
+
+
+def _mask_allowed_by_reachability(
+    mask: int,
+    closure_reachable_masks: frozenset[int] | None,
+    color_order_reachable_masks: frozenset[int] | None,
+) -> bool:
+    if closure_reachable_masks is not None and mask not in closure_reachable_masks:
+        return False
+    return not (
+        color_order_reachable_masks is not None
+        and mask not in color_order_reachable_masks
+    )
+
+
+def _state_allowed_by_reachability(
+    useful_states_by_mask: UsefulStateMap,
+    mask: int,
+    particle_id: int,
+    coupling_orders: CouplingOrders,
+) -> bool:
+    return coupling_orders in useful_states_by_mask.get(mask, {}).get(
+        particle_id,
+        (),
+    )
+
+
+def _nonzero_submasks(mask: int) -> tuple[int, ...]:
+    submasks: list[int] = []
+    submask = mask
+    while submask:
+        submasks.append(submask)
+        submask = (submask - 1) & mask
+    return tuple(submasks)
+
+
+def _masks_by_size(full_mask: int) -> tuple[int, ...]:
+    masks = []
+    submask = full_mask
+    while submask:
+        masks.append(submask)
+        submask = (submask - 1) & full_mask
+    return tuple(sorted(masks, key=lambda value: (value.bit_count(), value)))
+
+
+def _ordered_splits(mask: int) -> tuple[tuple[int, int], ...]:
+    splits: list[tuple[int, int]] = []
+    left = (mask - 1) & mask
+    while left:
+        right = mask ^ left
+        if right:
+            splits.append((left, right))
+        left = (left - 1) & mask
+    return tuple(splits)
diff --git a/pyamplicol/src/pyamplicol/generation/dag_table.py b/pyamplicol/src/pyamplicol/generation/dag_table.py
new file mode 100644
index 0000000000..e8495de849
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/dag_table.py
@@ -0,0 +1,100 @@
+# SPDX-License-Identifier: 0BSD
+"""Deduplicated current storage used during DAG compilation."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+
+from ..models.base import Model
+from .dag_types import CurrentIndex, CurrentNode
+
+
+class _CurrentTable:
+    def __init__(self, model: Model) -> None:
+        self.model = model
+        self.currents: list[CurrentNode] = []
+        self._ids: dict[CurrentIndex, int] = {}
+        self._ids_by_mask: dict[int, list[int]] = {}
+        self._ids_by_mask_particle: dict[tuple[int, int], list[int]] = {}
+        self._ids_by_mask_particle_sector: dict[tuple[int, int, int], list[int]] = {}
+
+    def add_or_get(
+        self,
+        index: CurrentIndex,
+        *,
+        is_source: bool,
+        source_leg_label: int | None = None,
+        source_helicity: int | None = None,
+    ) -> CurrentNode:
+        current_id = self._ids.get(index)
+        if current_id is not None:
+            return self.currents[current_id]
+        current_id = len(self.currents)
+        node = CurrentNode(
+            id=current_id,
+            index=index,
+            dimension=self.model.current_dimension(
+                index.particle_id,
+                index.chirality,
+            ),
+            is_source=is_source,
+            source_leg_label=source_leg_label,
+            source_helicity=source_helicity,
+        )
+        self._ids[index] = current_id
+        self.currents.append(node)
+        self._ids_by_mask.setdefault(index.external_mask, []).append(current_id)
+        self._ids_by_mask_particle.setdefault(
+            (index.external_mask, index.particle_id),
+            [],
+        ).append(current_id)
+        self._ids_by_mask_particle_sector.setdefault(
+            (
+                index.external_mask,
+                index.particle_id,
+                index.color_state.sector_id,
+            ),
+            [],
+        ).append(current_id)
+        return node
+
+    def current(self, current_id: int) -> CurrentNode:
+        return self.currents[current_id]
+
+    def has_mask(self, mask: int) -> bool:
+        return mask in self._ids_by_mask
+
+    def ids_by_mask(self, mask: int) -> Sequence[int]:
+        return self._ids_by_mask.get(mask, ())
+
+    def ids_by_mask_and_particles(
+        self,
+        mask: int,
+        particle_ids: Iterable[int],
+        *,
+        color_sector_id: int | None = None,
+    ) -> Sequence[int]:
+        try:
+            particle_count = len(particle_ids)  # type: ignore[arg-type]
+        except TypeError:
+            particle_count = -1
+        if particle_count == 1:
+            particle_id = next(iter(particle_ids))
+            if color_sector_id is None:
+                return self._ids_by_mask_particle.get((mask, particle_id), ())
+            return self._ids_by_mask_particle_sector.get(
+                (mask, particle_id, color_sector_id),
+                (),
+            )
+        ids: list[int] = []
+        for particle_id in particle_ids:
+            if color_sector_id is None:
+                ids.extend(self._ids_by_mask_particle.get((mask, particle_id), ()))
+            else:
+                ids.extend(
+                    self._ids_by_mask_particle_sector.get(
+                        (mask, particle_id, color_sector_id),
+                        (),
+                    )
+                )
+        return ids
diff --git a/pyamplicol/src/pyamplicol/generation/dag_types.py b/pyamplicol/src/pyamplicol/generation/dag_types.py
new file mode 100644
index 0000000000..6e534a0405
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/dag_types.py
@@ -0,0 +1,624 @@
+# SPDX-License-Identifier: 0BSD
+"""Frozen graph records shared by generation phases."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal
+
+from ..color.plan import (
+    ColorTopologyReplayCertificate,
+    GenericColorPlan,
+    LCColorSector,
+    LCColorTopologyReplayPlan,
+)
+from ..models._physics_ir import ContractionIR
+from ..models.base import QuantumNumberFlow
+from ..processes.ir import CanonicalProcessIR
+
+if TYPE_CHECKING:
+    from .helicity_materialization import HelicityMaterialization
+    from .helicity_replay import HelicityRecurrencePlan
+
+ColorAccuracy = Literal["lc", "nlc", "full"]
+
+_LC_FIERZ_SINGLET_BASIS = "lc-fierz-singlet"
+_LC_COLOR_IDENTITY_CLOSURE_PREFIX = "lc-color-identity-closure:"
+
+
+def _lc_color_identity_closure_key(labels: Iterable[int]) -> str:
+    normalized = tuple(sorted(set(int(label) for label in labels)))
+    return _LC_COLOR_IDENTITY_CLOSURE_PREFIX + ",".join(
+        str(label) for label in normalized
+    )
+
+
+def _lc_color_identity_closures(
+    basis_keys: Iterable[str],
+) -> tuple[frozenset[int], ...]:
+    closures: set[frozenset[int]] = set()
+    for key in basis_keys:
+        if not key.startswith(_LC_COLOR_IDENTITY_CLOSURE_PREFIX):
+            continue
+        payload = key.removeprefix(_LC_COLOR_IDENTITY_CLOSURE_PREFIX)
+        try:
+            labels = frozenset(int(label) for label in payload.split(",") if label)
+        except ValueError:
+            return (frozenset(),)
+        if not labels:
+            return (frozenset(),)
+        closures.add(labels)
+    return tuple(sorted(closures, key=lambda labels: tuple(sorted(labels))))
+
+
+def _lc_color_identity_closures_compatible(
+    closures: Iterable[frozenset[int]],
+    sector: LCColorSector,
+) -> bool:
+    groups = tuple(frozenset(group) for group in sector.coloured_label_groups)
+    return all(
+        bool(closure) and any(closure.issubset(group) for group in groups)
+        for closure in closures
+    )
+
+
+@dataclass(frozen=True)
+class ColorState:
+    """Colour identity carried by one current.
+
+    The LC implementation stores the warmup sector and the open-line/trace
+    groups touched by the current.  NLC/full colour will replace ``basis_key``
+    with Idenso basis components without changing the current-index contract.
+    """
+
+    accuracy: str
+    sector_id: int = 0
+    line_groups: tuple[int, ...] = ()
+    basis_key: tuple[str, ...] = ()
+    _key: tuple[object, ...] = field(init=False, repr=False, compare=False)
+    _hash: int = field(init=False, repr=False, compare=False)
+
+    def __post_init__(self) -> None:
+        key = (
+            self.accuracy,
+            self.sector_id,
+            self.line_groups,
+            self.basis_key,
+        )
+        object.__setattr__(self, "_key", key)
+        object.__setattr__(self, "_hash", hash(key))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ColorState):
+            return NotImplemented
+        return self._key == other._key
+
+    def __hash__(self) -> int:
+        return self._hash
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "accuracy": self.accuracy,
+            "sector_id": self.sector_id,
+            "line_groups": list(self.line_groups),
+            "basis_key": list(self.basis_key),
+        }
+
+
+@dataclass(frozen=True)
+class ColorFlow:
+    state: ColorState
+    weight: tuple[float, float] = (1.0, 0.0)
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "state": self.state.to_json_dict(),
+            "weight": list(self.weight),
+        }
+
+
+@dataclass(frozen=True)
+class CurrentIndex:
+    """Complete model-driven current identity.
+
+    Equality of this dataclass is the only current deduplication rule.  It
+    deliberately carries physics state, not a process-family label.
+    """
+
+    particle_id: int
+    external_mask: int
+    external_labels: tuple[int, ...]
+    helicity_ancestry: int
+    chirality: int
+    spin_state: int | tuple[int, ...]
+    flavour_flow: tuple[int, ...]
+    quantum_number_flow: QuantumNumberFlow
+    color_state: ColorState
+    momentum_mask: int
+    coupling_orders: tuple[tuple[str, int], ...] = ()
+    auxiliary_kind: str | None = None
+    ordered_external_labels: tuple[int, ...] = ()
+    _key: tuple[object, ...] = field(init=False, repr=False, compare=False)
+    _hash: int = field(init=False, repr=False, compare=False)
+
+    def __post_init__(self) -> None:
+        labels = tuple(sorted(self.external_labels))
+        if labels != self.external_labels:
+            object.__setattr__(self, "external_labels", labels)
+        if not self.ordered_external_labels:
+            object.__setattr__(self, "ordered_external_labels", labels)
+        elif tuple(sorted(self.ordered_external_labels)) != labels:
+            raise ValueError(
+                "ordered_external_labels must contain the same labels as "
+                "external_labels"
+            )
+        expected_mask = _labels_mask(self.external_labels)
+        if self.external_mask != expected_mask:
+            raise ValueError(
+                "external_mask does not match external_labels: "
+                f"{self.external_mask} != {expected_mask}"
+            )
+        if self.momentum_mask == 0:
+            raise ValueError("momentum_mask must be nonzero for a current")
+        if self.coupling_orders:
+            object.__setattr__(
+                self,
+                "coupling_orders",
+                tuple(
+                    sorted(
+                        (str(name).upper(), int(value))
+                        for name, value in self.coupling_orders
+                        if int(value) != 0
+                    )
+                ),
+            )
+        key = (
+            self.particle_id,
+            self.external_mask,
+            self.external_labels,
+            self.helicity_ancestry,
+            self.chirality,
+            self.spin_state,
+            self.flavour_flow,
+            self.quantum_number_flow,
+            self.color_state,
+            self.momentum_mask,
+            self.coupling_orders,
+            self.auxiliary_kind,
+            self.ordered_external_labels,
+        )
+        object.__setattr__(self, "_key", key)
+        object.__setattr__(self, "_hash", hash(key))
+
+    @classmethod
+    def _from_trusted_values(
+        cls,
+        *,
+        particle_id: int,
+        external_mask: int,
+        external_labels: tuple[int, ...],
+        helicity_ancestry: int,
+        chirality: int,
+        spin_state: int | tuple[int, ...],
+        flavour_flow: tuple[int, ...],
+        quantum_number_flow: QuantumNumberFlow,
+        color_state: ColorState,
+        momentum_mask: int,
+        coupling_orders: tuple[tuple[str, int], ...] = (),
+        auxiliary_kind: str | None = None,
+        ordered_external_labels: tuple[int, ...] = (),
+    ) -> CurrentIndex:
+        """Build an already canonical compiler-owned index.
+
+        Public construction and artifact decoding retain the normal validation
+        path. The eager compiler uses this only after its mask, ordering, and
+        coupling-order planners have produced canonical values.
+        """
+
+        row = object.__new__(cls)
+        object.__setattr__(row, "particle_id", particle_id)
+        object.__setattr__(row, "external_mask", external_mask)
+        object.__setattr__(row, "external_labels", external_labels)
+        object.__setattr__(row, "helicity_ancestry", helicity_ancestry)
+        object.__setattr__(row, "chirality", chirality)
+        object.__setattr__(row, "spin_state", spin_state)
+        object.__setattr__(row, "flavour_flow", flavour_flow)
+        object.__setattr__(row, "quantum_number_flow", quantum_number_flow)
+        object.__setattr__(row, "color_state", color_state)
+        object.__setattr__(row, "momentum_mask", momentum_mask)
+        object.__setattr__(row, "coupling_orders", coupling_orders)
+        object.__setattr__(row, "auxiliary_kind", auxiliary_kind)
+        object.__setattr__(
+            row,
+            "ordered_external_labels",
+            ordered_external_labels or external_labels,
+        )
+        key = (
+            row.particle_id,
+            row.external_mask,
+            row.external_labels,
+            row.helicity_ancestry,
+            row.chirality,
+            row.spin_state,
+            row.flavour_flow,
+            row.quantum_number_flow,
+            row.color_state,
+            row.momentum_mask,
+            row.coupling_orders,
+            row.auxiliary_kind,
+            row.ordered_external_labels,
+        )
+        object.__setattr__(row, "_key", key)
+        object.__setattr__(row, "_hash", hash(key))
+        return row
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CurrentIndex):
+            return NotImplemented
+        return self._key == other._key
+
+    def __hash__(self) -> int:
+        return self._hash
+
+    def overlaps(self, other: CurrentIndex) -> bool:
+        return bool(self.external_mask & other.external_mask)
+
+    def to_json_dict(self) -> dict[str, object]:
+        spin_state: object
+        if isinstance(self.spin_state, tuple):
+            spin_state = list(self.spin_state)
+        else:
+            spin_state = self.spin_state
+        return {
+            "particle_id": self.particle_id,
+            "external_mask": self.external_mask,
+            "external_labels": list(self.external_labels),
+            "ordered_external_labels": list(self.ordered_external_labels),
+            "helicity_ancestry": self.helicity_ancestry,
+            "chirality": self.chirality,
+            "spin_state": spin_state,
+            "flavour_flow": list(self.flavour_flow),
+            "quantum_number_flow": [
+                [name, expression] for name, expression in self.quantum_number_flow
+            ],
+            "color_state": self.color_state.to_json_dict(),
+            "momentum_mask": self.momentum_mask,
+            "coupling_orders": [[name, value] for name, value in self.coupling_orders],
+            "auxiliary_kind": self.auxiliary_kind,
+        }
+
+
+@dataclass(frozen=True)
+class CurrentNode:
+    id: int
+    index: CurrentIndex
+    dimension: int
+    is_source: bool
+    source_leg_label: int | None = None
+    source_helicity: int | None = None
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "index": self.index.to_json_dict(),
+            "dimension": self.dimension,
+            "is_source": self.is_source,
+            "source_leg_label": self.source_leg_label,
+            "source_helicity": self.source_helicity,
+        }
+
+
+@dataclass(frozen=True)
+class InteractionNode:
+    id: int
+    vertex_kind: int
+    vertex_particles: tuple[int, int, int]
+    left_id: int
+    right_id: int
+    result_id: int
+    coupling: tuple[float, float]
+    color_weight: tuple[float, float]
+    lowering_backend: str
+    full_tensor_network_ready: bool
+    evaluation_group_id: int | None = None
+    evaluation_factor: tuple[float, float] = (1.0, 0.0)
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "vertex_kind": self.vertex_kind,
+            "vertex_particles": list(self.vertex_particles),
+            "left_id": self.left_id,
+            "right_id": self.right_id,
+            "result_id": self.result_id,
+            "coupling": list(self.coupling),
+            "color_weight": list(self.color_weight),
+            "lowering_backend": self.lowering_backend,
+            "full_tensor_network_ready": self.full_tensor_network_ready,
+            "evaluation_group_id": self.evaluation_group_id,
+            "evaluation_factor": list(self.evaluation_factor),
+        }
+
+
+@dataclass(frozen=True)
+class AmplitudeRoot:
+    id: int
+    kind: str
+    left_id: int
+    right_id: int
+    color_weight: tuple[float, float]
+    contraction_ir: ContractionIR
+    color_sector_id: int | None = None
+    vertex_kind: int | None = None
+    vertex_particles: tuple[int, int, int] | None = None
+    coupling: tuple[float, float] = (1.0, 0.0)
+    helicity_weight: float = 1.0
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.contraction_ir, ContractionIR):
+            raise TypeError("amplitude root requires a frozen ContractionIR")
+
+    @property
+    def contraction(self) -> str:
+        """Display/wire projection retained for schema compatibility."""
+
+        return self.contraction_ir.name
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "kind": self.kind,
+            "left_id": self.left_id,
+            "right_id": self.right_id,
+            "color_weight": list(self.color_weight),
+            "color_sector_id": self.color_sector_id,
+            "vertex_kind": self.vertex_kind,
+            "vertex_particles": (
+                list(self.vertex_particles)
+                if self.vertex_particles is not None
+                else None
+            ),
+            "coupling": list(self.coupling),
+            "contraction": self.contraction,
+            "contraction_ir": self.contraction_ir.to_json_dict(),
+            "helicity_weight": self.helicity_weight,
+        }
+
+
+@dataclass(frozen=True)
+class GenericDAG:
+    process: CanonicalProcessIR
+    color_plan: GenericColorPlan
+    currents: tuple[CurrentNode, ...]
+    sources: tuple[int, ...]
+    interactions: tuple[InteractionNode, ...]
+    amplitude_roots: tuple[AmplitudeRoot, ...]
+    truncated: bool = False
+    helicity_coverage: str = "complete"
+    color_coverage: str = "complete"
+    selected_source_helicities: tuple[tuple[int, int], ...] = ()
+    selected_color_sector_ids: tuple[int, ...] = ()
+    lc_topology_replay: LCColorTopologyReplayPlan | None = None
+    color_topology_replay: ColorTopologyReplayCertificate | None = None
+    helicity_recurrence: HelicityRecurrencePlan | None = None
+    helicity_materialization: HelicityMaterialization | None = None
+
+    def __post_init__(self) -> None:
+        if self.helicity_coverage not in {"complete", "selected"}:
+            raise ValueError("DAG helicity coverage must be complete or selected")
+        if self.color_coverage not in {"complete", "selected"}:
+            raise ValueError("DAG color coverage must be complete or selected")
+        selected_color_sector_ids = tuple(
+            sorted({int(sector_id) for sector_id in self.selected_color_sector_ids})
+        )
+        object.__setattr__(
+            self,
+            "selected_color_sector_ids",
+            selected_color_sector_ids,
+        )
+        known_sector_ids = {int(sector.id) for sector in self.color_plan.sectors}
+        if not set(selected_color_sector_ids) <= known_sector_ids:
+            raise ValueError(
+                "selected color-sector provenance references an absent sector"
+            )
+        if (
+            self.lc_topology_replay is not None
+            and self.color_topology_replay is not None
+        ):
+            raise ValueError("DAG cannot carry both LC and generic topology replay")
+        if self.lc_topology_replay is not None:
+            if self.process.color_accuracy != "lc":
+                raise ValueError("LC topology replay requires LC color accuracy")
+            if self.color_coverage != "complete":
+                raise ValueError("LC topology replay requires complete color coverage")
+            if selected_color_sector_ids:
+                raise ValueError(
+                    "LC topology replay cannot carry generation-specialized color "
+                    "sectors"
+                )
+            if set(self.lc_topology_replay.physical_sector_ids) != {
+                int(sector.id) for sector in self.color_plan.sectors
+            }:
+                raise ValueError(
+                    "LC topology replay physical sectors do not match the color plan"
+                )
+        if self.color_topology_replay is not None:
+            if self.process.color_accuracy not in {"nlc", "full"}:
+                raise ValueError(
+                    "generic topology replay requires NLC or full color accuracy"
+                )
+            if self.color_topology_replay.color_accuracy != self.process.color_accuracy:
+                raise ValueError(
+                    "generic topology replay color accuracy does not match the DAG"
+                )
+            if self.color_coverage != "complete":
+                raise ValueError(
+                    "generic topology replay requires complete color coverage"
+                )
+            if selected_color_sector_ids:
+                raise ValueError(
+                    "generic topology replay cannot carry generation-specialized "
+                    "color sectors"
+                )
+            if set(self.color_topology_replay.physical_sector_ids) != {
+                int(sector.id) for sector in self.color_plan.sectors
+            }:
+                raise ValueError(
+                    "generic topology replay physical sectors do not match the "
+                    "color plan"
+                )
+        if self.helicity_recurrence is not None and (
+            self.helicity_coverage != "complete"
+            or bool(self.selected_source_helicities)
+        ):
+            raise ValueError(
+                "helicity recurrence metadata requires complete helicity coverage"
+            )
+        if self.helicity_materialization is not None:
+            if self.helicity_recurrence is None:
+                raise ValueError("helicity materialization requires a recurrence proof")
+            if self.helicity_materialization.dag is not self:
+                # The materialization object owns the same immutable payload but
+                # cannot hold the final self-reference after dataclass creation.
+                materialized = self.helicity_materialization.dag
+                if (
+                    materialized.currents != self.currents
+                    or materialized.interactions != self.interactions
+                    or materialized.amplitude_roots != self.amplitude_roots
+                ):
+                    raise ValueError(
+                        "helicity materialization does not describe this DAG"
+                    )
+
+    @property
+    def has_amplitudes(self) -> bool:
+        return bool(self.amplitude_roots)
+
+    @property
+    def required_vertex_kinds(self) -> tuple[int, ...]:
+        return tuple(
+            sorted(
+                {interaction.vertex_kind for interaction in self.interactions}
+                | {
+                    root.vertex_kind
+                    for root in self.amplitude_roots
+                    if root.vertex_kind is not None
+                }
+            )
+        )
+
+    @property
+    def interaction_evaluation_count(self) -> int:
+        return len(
+            {
+                (
+                    "group",
+                    interaction.evaluation_group_id,
+                )
+                if interaction.evaluation_group_id is not None
+                else ("interaction", interaction.id)
+                for interaction in self.interactions
+                if interaction.evaluation_factor != (0.0, 0.0)
+            }
+        )
+
+    @property
+    def interaction_fanout_histogram(self) -> tuple[tuple[int, int], ...]:
+        group_sizes: dict[tuple[str, int], int] = {}
+        for interaction in self.interactions:
+            if interaction.evaluation_factor == (0.0, 0.0):
+                continue
+            group = (
+                ("group", interaction.evaluation_group_id)
+                if interaction.evaluation_group_id is not None
+                else ("interaction", interaction.id)
+            )
+            group_sizes[group] = group_sizes.get(group, 0) + 1
+        histogram: dict[int, int] = {}
+        for size in group_sizes.values():
+            histogram[size] = histogram.get(size, 0) + 1
+        return tuple(sorted(histogram.items()))
+
+    def currents_by_external_labels(
+        self,
+        labels: Iterable[int],
+    ) -> tuple[CurrentNode, ...]:
+        wanted = tuple(sorted(labels))
+        return tuple(
+            current
+            for current in self.currents
+            if current.index.external_labels == wanted
+        )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "process": self.process.to_json_dict(),
+            "color_plan": self.color_plan.to_json_dict(),
+            "current_count": len(self.currents),
+            "source_count": len(self.sources),
+            "helicity_coverage": self.helicity_coverage,
+            "color_coverage": self.color_coverage,
+            "selected_source_helicities": {
+                str(label): helicity
+                for label, helicity in self.selected_source_helicities
+            },
+            **(
+                {}
+                if not self.selected_color_sector_ids
+                else {"selected_color_sector_ids": list(self.selected_color_sector_ids)}
+            ),
+            **(
+                {}
+                if self.lc_topology_replay is None
+                else {"lc_topology_replay": self.lc_topology_replay.to_json_dict()}
+            ),
+            **(
+                {}
+                if self.color_topology_replay is None
+                else {
+                    "color_topology_replay": (self.color_topology_replay.to_json_dict())
+                }
+            ),
+            **(
+                {}
+                if self.helicity_recurrence is None
+                else {
+                    "helicity_recurrence": (
+                        {
+                            **self.helicity_recurrence.to_json_dict(),
+                            **(
+                                {}
+                                if self.helicity_materialization is None
+                                else {
+                                    "materialization": (
+                                        self.helicity_materialization.to_runtime_manifest()
+                                    )
+                                }
+                            ),
+                        }
+                    )
+                }
+            ),
+            "interaction_count": len(self.interactions),
+            "interaction_evaluation_count": self.interaction_evaluation_count,
+            "interaction_fanout_histogram": [
+                [fanout, count] for fanout, count in self.interaction_fanout_histogram
+            ],
+            "amplitude_root_count": len(self.amplitude_roots),
+            "truncated": self.truncated,
+            "required_vertex_kinds": list(self.required_vertex_kinds),
+            "currents": [current.to_json_dict() for current in self.currents],
+            "sources": list(self.sources),
+            "interactions": [
+                interaction.to_json_dict() for interaction in self.interactions
+            ],
+            "amplitude_roots": [root.to_json_dict() for root in self.amplitude_roots],
+        }
+
+
+def _labels_mask(labels: Iterable[int]) -> int:
+    mask = 0
+    for label in labels:
+        mask |= 1 << (label - 1)
+    return mask
diff --git a/pyamplicol/src/pyamplicol/generation/eager_columnar.py b/pyamplicol/src/pyamplicol/generation/eager_columnar.py
new file mode 100644
index 0000000000..813b5ce849
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/eager_columnar.py
@@ -0,0 +1,2745 @@
+# SPDX-License-Identifier: 0BSD
+"""Columnar Python-to-Rust input contract for eager DAG lowering.
+
+This module deliberately stops before executable eager-table construction.  It
+turns the immutable, proof-carrying Python DAG into deterministic primitive
+columns that a later Rust lowerer can consume without first constructing the
+expanded runtime schema.  The production generation path does not use this
+contract yet.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import struct
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from itertools import product
+from typing import Any
+
+import numpy as np
+
+from ..color import build_color_contraction_plan
+from ..color.contraction_types import (
+    ColorContractionEntry,
+    ColorContractionTemplateEntry,
+)
+from ..models.base import Model
+from .contracts import runtime_coupling_parameter_names
+from .dag_types import GenericDAG
+from .eager_lowering import EagerKernelResolver, EagerResolvedKernel
+from .helicity_replay import (
+    HELICITY_RECURRENCE_CONTRACT_VERSION,
+    HELICITY_RECURRENCE_PROOF_ALGORITHM,
+)
+from .runtime_amplitudes import (
+    _amplitude_groups,
+    _color_topology_replay_amplitudes,
+    _has_multiple_lc_root_sectors,
+    _root_all_sector_weight,
+)
+
+EAGER_LOWERING_INPUT_ABI = "pyamplicol-eager-lowering-input-v1"
+EAGER_LOWERING_INPUT_SCHEMA_SHA256 = (
+    "59d5a3193ca25af6224c296297425782c394a34e352be622f47045e90d2bce29"
+)
+MISSING_U32 = (1 << 32) - 1
+MISSING_I32 = -(1 << 31)
+
+FACTOR_EXACT_SOURCE_BINARY64 = 0
+FACTOR_EXACT_SOURCE_CANONICAL_IR = 1
+
+_U8 = np.dtype("u1")
+_U32 = np.dtype("<u4")
+_U64 = np.dtype("<u8")
+_I32 = np.dtype("<i4")
+_F64 = np.dtype("<f8")
+_ALLOWED_DTYPES = frozenset(dtype.str for dtype in (_U8, _U32, _U64, _I32, _F64))
+
+_SEMANTIC_LIMITATIONS = (
+    "Every numeric factor carries both its f64 payload and a canonical exact-IR "
+    "reference. Values whose source contract is intrinsically f64 use an exact "
+    "IEEE-754 binary64 literal, preserving signed zero and every payload bit.",
+    "Rational colour-contraction weights retain their pre-f64 exact source. "
+    "Other GenericDAG proof weights, contraction coefficients, and "
+    "EagerKernelResolver normalization factors do not expose their pre-f64 "
+    "Symbolica expressions. Their exact-IR entries therefore certify the f64 "
+    "value from which current exact and double-double execution deliberately "
+    "starts, not an unavailable algebraic source expression.",
+    "Prepared-kernel exact expressions and evaluator states remain owned by the "
+    "prepared model pack and are selected by kernel ID. The current resolver "
+    "does not expose independent exact references for binding normalization "
+    "factors; extending that resolver is the remaining provenance blocker.",
+    "EagerKernelResolver also does not expose the prepared model-parameter "
+    "derivation kernel ID. Parameter definitions and defaults are represented, "
+    "but integration must supply that pack-owned kernel binding separately.",
+)
+
+
+class EagerColumnarInputError(ValueError):
+    """The proven Python input cannot be represented by the v1 wire contract."""
+
+
+@dataclass(frozen=True, slots=True)
+class EagerColumn:
+    """One immutable primitive column."""
+
+    name: str
+    values: np.ndarray[Any, Any]
+
+    def __post_init__(self) -> None:
+        if not self.name:
+            raise EagerColumnarInputError("column name must not be empty")
+        values = self.values
+        if not isinstance(values, np.ndarray):
+            raise TypeError(f"column {self.name!r} must be a NumPy array")
+        if values.ndim < 1:
+            raise EagerColumnarInputError(
+                f"column {self.name!r} must have a row dimension"
+            )
+        if not values.flags.c_contiguous:
+            raise EagerColumnarInputError(f"column {self.name!r} must be C-contiguous")
+        if values.dtype.str not in _ALLOWED_DTYPES:
+            raise EagerColumnarInputError(
+                f"column {self.name!r} has unsupported dtype {values.dtype.str!r}"
+            )
+        if values.flags.writeable:
+            raise EagerColumnarInputError(f"column {self.name!r} must be read-only")
+
+
+@dataclass(frozen=True, slots=True)
+class EagerColumnarTable:
+    """A deterministic structure-of-arrays table."""
+
+    name: str
+    row_count: int
+    columns: tuple[EagerColumn, ...]
+
+    def __post_init__(self) -> None:
+        if not self.name:
+            raise EagerColumnarInputError("table name must not be empty")
+        _checked_u64(self.row_count, f"{self.name}.row_count")
+        names = tuple(column.name for column in self.columns)
+        if len(set(names)) != len(names):
+            raise EagerColumnarInputError(
+                f"table {self.name!r} contains duplicate column names"
+            )
+        for column in self.columns:
+            if len(column.values) != self.row_count:
+                raise EagerColumnarInputError(
+                    f"table {self.name!r} column {column.name!r} has "
+                    f"{len(column.values)} rows, expected {self.row_count}"
+                )
+
+    def column(self, name: str) -> np.ndarray[Any, Any]:
+        for column in self.columns:
+            if column.name == name:
+                return column.values
+        raise KeyError(f"table {self.name!r} has no column {name!r}")
+
+
+@dataclass(frozen=True, slots=True)
+class EagerLoweringInputV1:
+    """Complete immutable input consumed by the future Rust eager lowerer."""
+
+    abi: str
+    process_key: str
+    model_name: str
+    string_catalog: tuple[str, ...]
+    canonical_ir_catalog: tuple[str, ...]
+    tables: tuple[EagerColumnarTable, ...]
+    semantic_limitations: tuple[str, ...] = _SEMANTIC_LIMITATIONS
+
+    def __post_init__(self) -> None:
+        if self.abi != EAGER_LOWERING_INPUT_ABI:
+            raise EagerColumnarInputError(
+                f"unsupported eager lowering input ABI {self.abi!r}"
+            )
+        if not self.process_key or not self.model_name:
+            raise EagerColumnarInputError(
+                "process key and model name must not be empty"
+            )
+        names = tuple(table.name for table in self.tables)
+        if names != tuple(sorted(names)):
+            raise EagerColumnarInputError(
+                "columnar table names must be sorted deterministically"
+            )
+        if len(set(names)) != len(names):
+            raise EagerColumnarInputError("columnar table names must be unique")
+        _validate_catalog(self.string_catalog, "string")
+        _validate_catalog(self.canonical_ir_catalog, "canonical IR")
+        if not self.semantic_limitations:
+            raise EagerColumnarInputError(
+                "the v1 exact-factor limitation must be reported explicitly"
+            )
+        self._validate_references()
+
+    def table(self, name: str) -> EagerColumnarTable:
+        for table in self.tables:
+            if table.name == name:
+                return table
+        raise KeyError(f"eager lowering input has no table {name!r}")
+
+    @property
+    def digest(self) -> str:
+        """Content digest independent of Python object identity and hash order."""
+
+        digest = hashlib.sha256()
+        for value in (self.abi, self.process_key, self.model_name):
+            _hash_text(digest, value)
+        for catalog in (self.string_catalog, self.canonical_ir_catalog):
+            digest.update(len(catalog).to_bytes(8, "little"))
+            for value in catalog:
+                _hash_text(digest, value)
+        digest.update(len(self.tables).to_bytes(8, "little"))
+        for table in self.tables:
+            _hash_text(digest, table.name)
+            digest.update(table.row_count.to_bytes(8, "little"))
+            digest.update(len(table.columns).to_bytes(4, "little"))
+            for column in table.columns:
+                _hash_text(digest, column.name)
+                _hash_text(digest, column.values.dtype.str)
+                digest.update(len(column.values.shape).to_bytes(1, "little"))
+                for size in column.values.shape:
+                    digest.update(int(size).to_bytes(8, "little"))
+                digest.update(column.values.tobytes(order="C"))
+        for limitation in self.semantic_limitations:
+            _hash_text(digest, limitation)
+        return digest.hexdigest()
+
+    @property
+    def schema_sha256(self) -> str:
+        """Digest the fixed table/column ABI independently of row counts."""
+
+        digest = hashlib.sha256()
+        digest.update(len(self.tables).to_bytes(8, "little"))
+        for table in self.tables:
+            _hash_text(digest, table.name)
+            digest.update(len(table.columns).to_bytes(4, "little"))
+            for column in table.columns:
+                _hash_text(digest, column.name)
+                _hash_text(digest, column.values.dtype.str)
+                digest.update(len(column.values.shape).to_bytes(1, "little"))
+                for size in column.values.shape[1:]:
+                    digest.update(int(size).to_bytes(8, "little"))
+        return digest.hexdigest()
+
+    def _validate_references(self) -> None:
+        current_count = self.table("currents").row_count
+        interaction_count = self.table("interactions").row_count
+        factor_count = self.table("exact_factors").row_count
+        string_count = len(self.string_catalog)
+        ir_count = len(self.canonical_ir_catalog)
+
+        _validate_dense_ids(self.table("currents"), "id")
+        _validate_dense_ids(self.table("interactions"), "id")
+        _validate_dense_ids(self.table("roots"), "id")
+        _validate_bounded_columns(
+            self.table("interactions"),
+            ("left_current_id", "right_current_id", "result_current_id"),
+            current_count,
+        )
+        _validate_bounded_columns(
+            self.table("roots"),
+            ("left_current_id", "right_current_id"),
+            current_count,
+        )
+        _validate_bounded_columns(self.table("sources"), ("current_id",), current_count)
+        _validate_bounded_columns(
+            self.table("interaction_group_members"),
+            ("interaction_id",),
+            interaction_count,
+        )
+        for table in self.tables:
+            factor_columns = tuple(
+                column.name
+                for column in table.columns
+                if column.name.endswith("factor_id")
+            )
+            if factor_columns:
+                _validate_bounded_columns(table, factor_columns, factor_count)
+        _validate_bounded_columns(
+            self.table("exact_factors"), ("exact_ir_id",), ir_count
+        )
+        _validate_optional_bounded_columns(
+            self.table("exact_factors"), ("source_ir_id",), ir_count
+        )
+        _validate_bounded_columns(
+            self.table("exact_factors"), ("canonical_string_id",), string_count
+        )
+        exact_sources = set(
+            int(value) for value in self.table("exact_factors").column("exact_source")
+        )
+        if not exact_sources <= {
+            FACTOR_EXACT_SOURCE_BINARY64,
+            FACTOR_EXACT_SOURCE_CANONICAL_IR,
+        }:
+            raise EagerColumnarInputError(
+                "exact-factor catalog contains an unsupported provenance code"
+            )
+        for table in self.tables:
+            string_columns = tuple(
+                column.name
+                for column in table.columns
+                if column.name.endswith("string_id")
+            )
+            if string_columns:
+                _validate_optional_bounded_columns(table, string_columns, string_count)
+        _validate_optional_bounded_columns(
+            self.table("currents"), ("propagator_ir_id",), ir_count
+        )
+        _validate_bounded_columns(self.table("roots"), ("contraction_ir_id",), ir_count)
+        _validate_bounded_columns(
+            self.table("contraction_coefficients"),
+            ("contraction_ir_id",),
+            ir_count,
+        )
+        _validate_bounded_columns(
+            self.table("sources"), ("source_ir_id", "crossing_ir_id"), ir_count
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class _ModelParameterSpec:
+    name: str
+    kind: str
+    default: float
+    runtime_name: str | None = None
+    complex_component: int = -1
+    parameter_type: str | None = None
+    pdg: int | None = None
+    vertex_kind: int | None = None
+    vertex_particles: tuple[int, int, int] | None = None
+    coupling_component: int | None = None
+    derived: bool = False
+    complex_domain: str | None = None
+    definition: str | None = None
+
+
+class _StringCatalog:
+    def __init__(self) -> None:
+        self.values: list[str] = []
+        self.ids: dict[str, int] = {}
+
+    def add(self, value: str) -> int:
+        if not isinstance(value, str):
+            raise TypeError(f"catalog value must be a string, got {value!r}")
+        existing = self.ids.get(value)
+        if existing is not None:
+            return existing
+        result = _checked_u32(len(self.values), "catalog ID")
+        self.values.append(value)
+        self.ids[value] = result
+        return result
+
+    def optional(self, value: str | None) -> int:
+        return MISSING_U32 if value is None else self.add(value)
+
+
+class _SequenceCatalog:
+    def __init__(self, *, signed: bool) -> None:
+        self.signed = signed
+        self.values: list[tuple[int, ...]] = []
+        self.ids: dict[tuple[int, ...], int] = {}
+
+    def add(self, values: Iterable[int]) -> int:
+        item = tuple(int(value) for value in values)
+        checker = _checked_i32 if self.signed else _checked_u32
+        for index, value in enumerate(item):
+            checker(value, f"sequence component {index}")
+        existing = self.ids.get(item)
+        if existing is not None:
+            return existing
+        result = _checked_u32(len(self.values), "sequence ID")
+        self.values.append(item)
+        self.ids[item] = result
+        return result
+
+    def tables(self, prefix: str) -> tuple[EagerColumnarTable, EagerColumnarTable]:
+        ranges = _allocate(len(self.values), start=_U64, count=_U64)
+        total = sum(len(value) for value in self.values)
+        dtype = _I32 if self.signed else _U32
+        flat = _allocate(total, value=dtype)
+        cursor = 0
+        for index, values in enumerate(self.values):
+            ranges["start"][index] = cursor
+            ranges["count"][index] = len(values)
+            stop = cursor + len(values)
+            flat["value"][cursor:stop] = values
+            cursor = stop
+        return (
+            _freeze_table(f"{prefix}_sequence_ranges", ranges),
+            _freeze_table(f"{prefix}_sequence_values", flat),
+        )
+
+
+class _BitsetCatalog:
+    def __init__(self) -> None:
+        self.values: list[int] = []
+        self.ids: dict[int, int] = {}
+
+    def add(self, value: int, context: str) -> int:
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise TypeError(f"{context} must be an integer")
+        if value < 0:
+            raise EagerColumnarInputError(f"{context} must be nonnegative")
+        existing = self.ids.get(value)
+        if existing is not None:
+            return existing
+        result = _checked_u32(len(self.values), "bitset ID")
+        self.values.append(value)
+        self.ids[value] = result
+        return result
+
+    def tables(self) -> tuple[EagerColumnarTable, EagerColumnarTable]:
+        ranges = _allocate(len(self.values), start=_U64, count=_U64, bit_count=_U64)
+        total = sum((value.bit_length() + 63) // 64 for value in self.values)
+        words = _allocate(total, value=_U64)
+        cursor = 0
+        for index, value in enumerate(self.values):
+            count = (value.bit_length() + 63) // 64
+            ranges["start"][index] = cursor
+            ranges["count"][index] = count
+            ranges["bit_count"][index] = value.bit_count()
+            for word_index in range(count):
+                words["value"][cursor] = (value >> (64 * word_index)) & ((1 << 64) - 1)
+                cursor += 1
+        return (
+            _freeze_table("bitset_ranges", ranges),
+            _freeze_table("bitset_words", words),
+        )
+
+
+class _FactorCatalog:
+    def __init__(self, canonical_ir: _CanonicalIRCatalog) -> None:
+        self.canonical_ir = canonical_ir
+        self.values: list[tuple[tuple[float, float], int, int, int]] = []
+        self.ids: dict[tuple[int, int, int, int, int], int] = {}
+        self.binary_ids: dict[tuple[int, int, int], int] = {}
+
+    def add(
+        self,
+        value: Sequence[object],
+        context: str,
+        *,
+        exact_ir: object | None = None,
+        source_ir_id: int = MISSING_U32,
+    ) -> int:
+        if len(value) != 2:
+            raise EagerColumnarInputError(f"{context} must be a complex pair")
+        pair = (float(value[0]), float(value[1]))
+        if not all(math.isfinite(component) for component in pair):
+            raise EagerColumnarInputError(f"{context} must be finite")
+        if source_ir_id != MISSING_U32:
+            _checked_u32(source_ir_id, f"{context} source IR ID")
+        bits = (_f64_bits(pair[0]), _f64_bits(pair[1]))
+        if exact_ir is None:
+            binary_key = (*bits, source_ir_id)
+            existing = self.binary_ids.get(binary_key)
+            if existing is not None:
+                return existing
+        exact_source = (
+            FACTOR_EXACT_SOURCE_BINARY64
+            if exact_ir is None
+            else FACTOR_EXACT_SOURCE_CANONICAL_IR
+        )
+        exact_payload = (
+            _binary64_exact_ir(pair)
+            if exact_ir is None
+            else {
+                "abi": "pyamplicol-exact-factor-v1",
+                "kind": "canonical-source-ir",
+                "source": exact_ir,
+                "f64_fallback": _binary64_exact_ir(pair),
+            }
+        )
+        exact_ir_id = self.canonical_ir.add(exact_payload, f"{context} exact IR")
+        key = (*bits, exact_source, exact_ir_id, source_ir_id)
+        existing = self.ids.get(key)
+        if existing is not None:
+            return existing
+        result = _checked_u32(len(self.values), "exact-factor ID")
+        self.values.append((pair, exact_source, exact_ir_id, source_ir_id))
+        self.ids[key] = result
+        if exact_ir is None:
+            self.binary_ids[(*bits, source_ir_id)] = result
+        return result
+
+    def pair(self, factor_id: int) -> tuple[float, float]:
+        return self.values[factor_id][0]
+
+    def table(self, strings: _StringCatalog) -> EagerColumnarTable:
+        columns = _allocate(
+            len(self.values),
+            real=_F64,
+            imaginary=_F64,
+            canonical_string_id=_U32,
+            exact_source=_U8,
+            exact_ir_id=_U32,
+            source_ir_id=_U32,
+        )
+        for index, (
+            (real, imaginary),
+            exact_source,
+            exact_ir_id,
+            source_ir_id,
+        ) in enumerate(self.values):
+            columns["real"][index] = real
+            columns["imaginary"][index] = imaginary
+            columns["canonical_string_id"][index] = strings.add(
+                f"complex-f64:{real.hex()}:{imaginary.hex()}"
+            )
+            columns["exact_source"][index] = exact_source
+            columns["exact_ir_id"][index] = exact_ir_id
+            columns["source_ir_id"][index] = source_ir_id
+        return _freeze_table("exact_factors", columns)
+
+
+class _CanonicalIRCatalog:
+    def __init__(self) -> None:
+        self.values: list[str] = []
+        self.ids: dict[str, int] = {}
+
+    def add(self, value: object, context: str) -> int:
+        try:
+            encoded = json.dumps(
+                value,
+                sort_keys=True,
+                separators=(",", ":"),
+                ensure_ascii=True,
+                allow_nan=False,
+            )
+        except (TypeError, ValueError) as error:
+            raise EagerColumnarInputError(
+                f"{context} cannot be represented canonically: {error}"
+            ) from error
+        existing = self.ids.get(encoded)
+        if existing is not None:
+            return existing
+        result = _checked_u32(len(self.values), "canonical IR ID")
+        self.values.append(encoded)
+        self.ids[encoded] = result
+        return result
+
+
+class _Builder:
+    def __init__(
+        self,
+        dag: GenericDAG,
+        model: Model,
+        resolver: EagerKernelResolver,
+        process_id: str | None,
+    ) -> None:
+        if not isinstance(dag, GenericDAG):
+            raise TypeError("eager columnar extraction requires a GenericDAG")
+        if not isinstance(model, Model):
+            raise TypeError("eager columnar extraction requires a Model")
+        self.dag = dag
+        self.model = model
+        self.resolver = resolver
+        self.process_key = process_id or dag.process.key
+        self.strings = _StringCatalog()
+        self.ir = _CanonicalIRCatalog()
+        self.u32_sequences = _SequenceCatalog(signed=False)
+        self.i32_sequences = _SequenceCatalog(signed=True)
+        self.bitsets = _BitsetCatalog()
+        self.factors = _FactorCatalog(self.ir)
+        self.tables: list[EagerColumnarTable] = []
+        self.coupling_specs: list[tuple[int, tuple[int, int, int], int, int]] = []
+        self.coupling_ids: dict[
+            tuple[int, tuple[int, int, int], tuple[float, float]], int
+        ] = {}
+
+        self._validate_dense_dag()
+        self.group_ids, self.group_descriptors = _amplitude_groups(
+            dag, dag.amplitude_roots
+        )
+        self.color_topology_replay = _color_topology_replay_amplitudes(
+            dag, self.group_descriptors
+        )
+
+    def build(self) -> EagerLoweringInputV1:
+        self._metadata()
+        self._currents()
+        self._sources()
+        self._interactions()
+        self._roots()
+        self._interaction_groups()
+        self._color_plan()
+        self._topology_replay()
+        self._color_topology_replay_amplitudes()
+        self._helicity_proof()
+        self._helicity_materialization()
+        self._selectors_and_reductions()
+        self._couplings()
+        self._model_parameters()
+        self.tables.append(self.factors.table(self.strings))
+        self.tables.extend(self.bitsets.tables())
+        self.tables.extend(self.u32_sequences.tables("u32"))
+        self.tables.extend(self.i32_sequences.tables("i32"))
+        return EagerLoweringInputV1(
+            abi=EAGER_LOWERING_INPUT_ABI,
+            process_key=self.process_key,
+            model_name=self.model.name,
+            string_catalog=tuple(self.strings.values),
+            canonical_ir_catalog=tuple(self.ir.values),
+            tables=tuple(sorted(self.tables, key=lambda table: table.name)),
+        )
+
+    def _validate_dense_dag(self) -> None:
+        for context, records in (
+            ("current", self.dag.currents),
+            ("interaction", self.dag.interactions),
+            ("amplitude root", self.dag.amplitude_roots),
+        ):
+            _checked_u32(len(records), f"{context} count")
+            for expected, record in enumerate(records):
+                _checked_u32(record.id, f"{context} id")
+                if record.id != expected:
+                    raise EagerColumnarInputError(
+                        f"{context} ids must be dense; found {record.id} at {expected}"
+                    )
+        current_count = len(self.dag.currents)
+        for interaction in self.dag.interactions:
+            for field, current_id in (
+                ("left", interaction.left_id),
+                ("right", interaction.right_id),
+                ("result", interaction.result_id),
+            ):
+                _require_index(current_id, current_count, f"interaction {field}")
+        for root in self.dag.amplitude_roots:
+            _require_index(root.left_id, current_count, "root left current")
+            _require_index(root.right_id, current_count, "root right current")
+        for source_id in self.dag.sources:
+            _require_index(source_id, current_count, "source current")
+            if not self.dag.currents[source_id].is_source:
+                raise EagerColumnarInputError(
+                    f"DAG source {source_id} is not marked as a source current"
+                )
+
+    def _metadata(self) -> None:
+        columns = _allocate(
+            1,
+            process_ir_id=_U32,
+            normalization_ir_id=_U32,
+            model_name_string_id=_U32,
+            process_key_string_id=_U32,
+            helicity_coverage_string_id=_U32,
+            color_coverage_string_id=_U32,
+            color_accuracy_string_id=_U32,
+            truncated=_U8,
+            color_plan_truncated=_U8,
+            trace_reflections_folded=_U8,
+        )
+        columns["process_ir_id"][0] = self.ir.add(
+            self.dag.process.to_json_dict(), "process IR"
+        )
+        columns["normalization_ir_id"][0] = self.ir.add(
+            dict(self.model.runtime_normalization_payload(self.dag)),
+            "runtime normalization",
+        )
+        columns["model_name_string_id"][0] = self.strings.add(self.model.name)
+        columns["process_key_string_id"][0] = self.strings.add(self.process_key)
+        columns["helicity_coverage_string_id"][0] = self.strings.add(
+            self.dag.helicity_coverage
+        )
+        columns["color_coverage_string_id"][0] = self.strings.add(
+            self.dag.color_coverage
+        )
+        columns["color_accuracy_string_id"][0] = self.strings.add(
+            self.dag.process.color_accuracy
+        )
+        columns["truncated"][0] = self.dag.truncated
+        columns["color_plan_truncated"][0] = self.dag.color_plan.truncated
+        columns["trace_reflections_folded"][0] = (
+            self.dag.color_plan.trace_reflections_folded
+        )
+        self.tables.append(_freeze_table("metadata", columns))
+
+        diagnostics = _allocate(
+            len(self.dag.color_plan.diagnostics), message_string_id=_U32
+        )
+        for row, message in enumerate(self.dag.color_plan.diagnostics):
+            diagnostics["message_string_id"][row] = self.strings.add(str(message))
+        self.tables.append(_freeze_table("color_plan_diagnostics", diagnostics))
+
+        selected_helicities = _allocate(
+            len(self.dag.selected_source_helicities),
+            external_label=_U32,
+            helicity=_I32,
+        )
+        for index, (label, helicity) in enumerate(self.dag.selected_source_helicities):
+            selected_helicities["external_label"][index] = _checked_u32(
+                label, "selected-helicity external label"
+            )
+            selected_helicities["helicity"][index] = _checked_i32(
+                helicity, "selected helicity"
+            )
+        self.tables.append(
+            _freeze_table("selected_source_helicities", selected_helicities)
+        )
+        selected_colors = _allocate(
+            len(self.dag.selected_color_sector_ids), sector_id=_U32
+        )
+        selected_colors["sector_id"][:] = self.dag.selected_color_sector_ids
+        self.tables.append(_freeze_table("selected_color_sectors", selected_colors))
+
+    def _currents(self) -> None:
+        columns = _allocate(
+            len(self.dag.currents),
+            id=_U32,
+            particle_id=_I32,
+            dimension=_U32,
+            is_source=_U8,
+            source_leg_label=_U32,
+            source_helicity=_I32,
+            external_mask_bitset_id=_U32,
+            external_labels_sequence_id=_U32,
+            ordered_external_labels_sequence_id=_U32,
+            helicity_ancestry_bitset_id=_U32,
+            chirality=_I32,
+            spin_state_sequence_id=_U32,
+            flavour_flow_sequence_id=_U32,
+            momentum_mask_bitset_id=_U32,
+            coupling_order_start=_U64,
+            coupling_order_count=_U64,
+            quantum_flow_start=_U64,
+            quantum_flow_count=_U64,
+            color_accuracy_string_id=_U32,
+            color_sector_id=_U32,
+            color_line_groups_sequence_id=_U32,
+            color_basis_keys_sequence_id=_U32,
+            auxiliary_kind_string_id=_U32,
+            propagator_ir_id=_U32,
+            propagator_kernel_id=_U32,
+        )
+        coupling_order_count = sum(
+            len(current.index.coupling_orders) for current in self.dag.currents
+        )
+        quantum_flow_count = sum(
+            len(current.index.quantum_number_flow) for current in self.dag.currents
+        )
+        coupling_orders = _allocate(
+            coupling_order_count, name_string_id=_U32, value=_I32
+        )
+        quantum_flows = _allocate(
+            quantum_flow_count, name_string_id=_U32, expression_string_id=_U32
+        )
+        coupling_cursor = 0
+        quantum_cursor = 0
+        for row, current in enumerate(self.dag.currents):
+            current_index = current.index
+            columns["id"][row] = current.id
+            columns["particle_id"][row] = _checked_i32(
+                current_index.particle_id, "current particle id"
+            )
+            columns["dimension"][row] = _positive_u32(
+                current.dimension, "current dimension"
+            )
+            columns["is_source"][row] = current.is_source
+            columns["source_leg_label"][row] = (
+                MISSING_U32
+                if current.source_leg_label is None
+                else _checked_u32(current.source_leg_label, "source leg label")
+            )
+            columns["source_helicity"][row] = (
+                MISSING_I32
+                if current.source_helicity is None
+                else _checked_i32(current.source_helicity, "source helicity")
+            )
+            columns["external_mask_bitset_id"][row] = self.bitsets.add(
+                current_index.external_mask, "current external mask"
+            )
+            columns["external_labels_sequence_id"][row] = self.u32_sequences.add(
+                current_index.external_labels
+            )
+            columns["ordered_external_labels_sequence_id"][row] = (
+                self.u32_sequences.add(current_index.ordered_external_labels)
+            )
+            columns["helicity_ancestry_bitset_id"][row] = self.bitsets.add(
+                current_index.helicity_ancestry, "current helicity ancestry"
+            )
+            columns["chirality"][row] = _checked_i32(
+                current_index.chirality, "current chirality"
+            )
+            spin_state = (
+                current_index.spin_state
+                if isinstance(current_index.spin_state, tuple)
+                else (current_index.spin_state,)
+            )
+            columns["spin_state_sequence_id"][row] = self.i32_sequences.add(spin_state)
+            columns["flavour_flow_sequence_id"][row] = self.i32_sequences.add(
+                current_index.flavour_flow
+            )
+            columns["momentum_mask_bitset_id"][row] = self.bitsets.add(
+                current_index.momentum_mask, "current momentum mask"
+            )
+            columns["coupling_order_start"][row] = coupling_cursor
+            columns["coupling_order_count"][row] = len(current_index.coupling_orders)
+            for name, value in current_index.coupling_orders:
+                coupling_orders["name_string_id"][coupling_cursor] = self.strings.add(
+                    str(name)
+                )
+                coupling_orders["value"][coupling_cursor] = _checked_i32(
+                    value, "coupling order"
+                )
+                coupling_cursor += 1
+            columns["quantum_flow_start"][row] = quantum_cursor
+            columns["quantum_flow_count"][row] = len(current_index.quantum_number_flow)
+            for name, expression in current_index.quantum_number_flow:
+                quantum_flows["name_string_id"][quantum_cursor] = self.strings.add(
+                    str(name)
+                )
+                quantum_flows["expression_string_id"][quantum_cursor] = (
+                    self.strings.add(str(expression))
+                )
+                quantum_cursor += 1
+            color = current_index.color_state
+            if not all(isinstance(value, str) for value in color.basis_key):
+                raise EagerColumnarInputError(
+                    f"current {current.id} color basis keys must be strings"
+                )
+            columns["color_accuracy_string_id"][row] = self.strings.add(color.accuracy)
+            columns["color_sector_id"][row] = _checked_u32(
+                color.sector_id, "current color sector"
+            )
+            columns["color_line_groups_sequence_id"][row] = self.i32_sequences.add(
+                color.line_groups
+            )
+            columns["color_basis_keys_sequence_id"][row] = self.u32_sequences.add(
+                self.strings.add(value) for value in color.basis_key
+            )
+            columns["auxiliary_kind_string_id"][row] = self.strings.optional(
+                current_index.auxiliary_kind
+            )
+            propagator = self.model._propagator_ir(
+                current_index.particle_id, current_index.chirality
+            )
+            columns["propagator_ir_id"][row] = self.ir.add(
+                propagator.to_json_dict(), "propagator IR"
+            )
+            kernel_id = self.resolver.propagator_kernel_id(
+                current, propagator.to_json_dict()
+            )
+            columns["propagator_kernel_id"][row] = (
+                MISSING_U32
+                if kernel_id is None
+                else _checked_u32(kernel_id, "prepared propagator kernel id")
+            )
+        self.tables.append(_freeze_table("currents", columns))
+        self.tables.append(_freeze_table("coupling_orders", coupling_orders))
+        self.tables.append(_freeze_table("quantum_flows", quantum_flows))
+
+        momentum_masks = sorted(
+            {current.index.momentum_mask for current in self.dag.currents},
+            key=lambda value: (value.bit_count(), value),
+        )
+        momentum_columns = _allocate(len(momentum_masks), slot_id=_U32, bitset_id=_U32)
+        for slot_id, mask in enumerate(momentum_masks):
+            momentum_columns["slot_id"][slot_id] = slot_id
+            momentum_columns["bitset_id"][slot_id] = self.bitsets.add(
+                mask, "momentum mask"
+            )
+        self.tables.append(_freeze_table("momentum_masks", momentum_columns))
+
+    def _sources(self) -> None:
+        columns = _allocate(
+            len(self.dag.sources),
+            source_id=_U32,
+            current_id=_U32,
+            external_label=_U32,
+            input_momentum_slot=_U32,
+            source_ir_id=_U32,
+            crossing_ir_id=_U32,
+            crossing_factor_id=_U32,
+            declared_state_index=_U32,
+        )
+        legs = {leg.label: leg for leg in self.dag.process.legs}
+        for source_id, current_id in enumerate(self.dag.sources):
+            current = self.dag.currents[current_id]
+            if current.source_leg_label is None or current.source_helicity is None:
+                raise EagerColumnarInputError(
+                    f"source current {current_id} lacks leg/helicity provenance"
+                )
+            leg = legs.get(current.source_leg_label)
+            if leg is None:
+                raise EagerColumnarInputError(
+                    f"source current {current_id} refers to unknown external leg"
+                )
+            source_ir = self.model._source_ir(current.index.particle_id)
+            crossing = (
+                source_ir.crossing
+                if leg.is_initial
+                else type(source_ir.crossing).identity()
+            )
+            expected = (
+                current.source_helicity,
+                current.index.chirality,
+                current.index.spin_state,
+            )
+            state_index = next(
+                (
+                    index
+                    for index, state in enumerate(source_ir.states)
+                    if (
+                        (applied := crossing.apply(state)).helicity,
+                        applied.chirality,
+                        applied.spin_state,
+                    )
+                    == expected
+                ),
+                None,
+            )
+            if state_index is None:
+                raise EagerColumnarInputError(
+                    f"source current {current_id} state {expected!r} is not declared"
+                )
+            columns["source_id"][source_id] = source_id
+            columns["current_id"][source_id] = current_id
+            columns["external_label"][source_id] = current.source_leg_label
+            columns["input_momentum_slot"][source_id] = leg.label - 1
+            source_ir_id = self.ir.add(source_ir.to_json_dict(), "source IR")
+            crossing_ir_id = self.ir.add(crossing.to_json_dict(), "source crossing IR")
+            columns["source_ir_id"][source_id] = source_ir_id
+            columns["crossing_ir_id"][source_id] = crossing_ir_id
+            columns["crossing_factor_id"][source_id] = self.factors.add(
+                crossing.phase,
+                "source crossing phase",
+                source_ir_id=crossing_ir_id,
+            )
+            columns["declared_state_index"][source_id] = state_index
+        self.tables.append(_freeze_table("sources", columns))
+
+    def _interactions(self) -> None:
+        group_by_key: dict[tuple[str, int], int] = {}
+        self._interaction_group_members: list[list[int]] = []
+        columns = _allocate(
+            len(self.dag.interactions),
+            id=_U32,
+            stage_subset_size=_U32,
+            vertex_kind=_I32,
+            vertex_particles=(_I32, (3,)),
+            left_current_id=_U32,
+            right_current_id=_U32,
+            result_current_id=_U32,
+            coupling_id=_U32,
+            coupling_factor_id=_U32,
+            color_factor_id=_U32,
+            evaluation_factor_id=_U32,
+            evaluation_group_id=_U32,
+            lowering_backend_string_id=_U32,
+            full_tensor_network_ready=_U8,
+            kernel_id=_U32,
+            canonical_input_order=(_U8, (2,)),
+            kernel_normalization_factor_id=_U32,
+            output_factor_source=_U8,
+        )
+        for row, interaction in enumerate(self.dag.interactions):
+            resolved = self.resolver.vertex_kernel(interaction)
+            coupling_id = self._coupling(
+                interaction.vertex_kind,
+                interaction.vertex_particles,
+                interaction.coupling,
+            )
+            columns["id"][row] = interaction.id
+            columns["stage_subset_size"][row] = len(
+                self.dag.currents[interaction.result_id].index.external_labels
+            )
+            columns["vertex_kind"][row] = _checked_i32(
+                interaction.vertex_kind, "vertex kind"
+            )
+            columns["vertex_particles"][row] = interaction.vertex_particles
+            columns["left_current_id"][row] = interaction.left_id
+            columns["right_current_id"][row] = interaction.right_id
+            columns["result_current_id"][row] = interaction.result_id
+            columns["coupling_id"][row] = coupling_id
+            columns["coupling_factor_id"][row] = self.coupling_specs[coupling_id][2]
+            columns["color_factor_id"][row] = self.factors.add(
+                interaction.color_weight, "interaction color weight"
+            )
+            columns["evaluation_factor_id"][row] = self.factors.add(
+                interaction.evaluation_factor, "interaction evaluation factor"
+            )
+            columns["lowering_backend_string_id"][row] = self.strings.add(
+                interaction.lowering_backend
+            )
+            columns["full_tensor_network_ready"][row] = (
+                interaction.full_tensor_network_ready
+            )
+            _fill_resolved_kernel(columns, row, resolved, self.factors)
+            group_key = (
+                ("group", int(interaction.evaluation_group_id))
+                if interaction.evaluation_group_id is not None
+                else ("interaction", interaction.id)
+            )
+            group_id = group_by_key.get(group_key)
+            if group_id is None:
+                group_id = len(group_by_key)
+                group_by_key[group_key] = group_id
+                self._interaction_group_members.append([])
+            self._interaction_group_members[group_id].append(interaction.id)
+            columns["evaluation_group_id"][row] = group_id
+        self.tables.append(_freeze_table("interactions", columns))
+
+    def _roots(self) -> None:
+        contraction_records: dict[int, object] = {}
+        columns = _allocate(
+            len(self.dag.amplitude_roots),
+            id=_U32,
+            kind_string_id=_U32,
+            left_current_id=_U32,
+            right_current_id=_U32,
+            color_factor_id=_U32,
+            contraction_ir_id=_U32,
+            color_sector_id=_U32,
+            vertex_kind=_I32,
+            vertex_particles=(_I32, (3,)),
+            coupling_id=_U32,
+            coupling_factor_id=_U32,
+            helicity_weight_factor_id=_U32,
+            coherent_group_id=_U32,
+            kernel_id=_U32,
+            canonical_input_order=(_U8, (2,)),
+            kernel_normalization_factor_id=_U32,
+            output_factor_source=_U8,
+        )
+        for row, root in enumerate(self.dag.amplitude_roots):
+            resolved = self.resolver.closure_kernel(root.to_json_dict())
+            columns["id"][row] = root.id
+            columns["kind_string_id"][row] = self.strings.add(root.kind)
+            columns["left_current_id"][row] = root.left_id
+            columns["right_current_id"][row] = root.right_id
+            columns["color_factor_id"][row] = self.factors.add(
+                root.color_weight, "root color weight"
+            )
+            contraction_ir_id = self.ir.add(
+                root.contraction_ir.to_json_dict(), "contraction IR"
+            )
+            columns["contraction_ir_id"][row] = contraction_ir_id
+            contraction_records.setdefault(contraction_ir_id, root.contraction_ir)
+            sector_id = (
+                root.color_sector_id
+                if root.color_sector_id is not None
+                else self.dag.currents[root.left_id].index.color_state.sector_id
+            )
+            columns["color_sector_id"][row] = _checked_u32(
+                sector_id, "root color sector"
+            )
+            columns["vertex_kind"][row] = (
+                MISSING_I32
+                if root.vertex_kind is None
+                else _checked_i32(root.vertex_kind, "root vertex kind")
+            )
+            columns["vertex_particles"][row] = (
+                (MISSING_I32, MISSING_I32, MISSING_I32)
+                if root.vertex_particles is None
+                else root.vertex_particles
+            )
+            coupling_id = (
+                MISSING_U32
+                if root.vertex_kind is None or root.vertex_particles is None
+                else self._coupling(
+                    root.vertex_kind, root.vertex_particles, root.coupling
+                )
+            )
+            columns["coupling_id"][row] = coupling_id
+            columns["coupling_factor_id"][row] = (
+                self.factors.add(root.coupling, "direct root coupling")
+                if coupling_id == MISSING_U32
+                else self.coupling_specs[coupling_id][2]
+            )
+            columns["helicity_weight_factor_id"][row] = self.factors.add(
+                (root.helicity_weight, 0.0), "root helicity weight"
+            )
+            columns["coherent_group_id"][row] = self.group_ids[root.id]
+            if resolved is None:
+                columns["kernel_id"][row] = MISSING_U32
+                columns["canonical_input_order"][row] = (0, 1)
+                columns["kernel_normalization_factor_id"][row] = self.factors.add(
+                    (1.0, 0.0), "direct closure normalization"
+                )
+                columns["output_factor_source"][row] = 0
+            else:
+                _fill_resolved_kernel(columns, row, resolved, self.factors)
+        self.tables.append(_freeze_table("roots", columns))
+
+        coefficient_count = sum(
+            len(record.coefficients) for record in contraction_records.values()
+        )
+        coefficients = _allocate(
+            coefficient_count,
+            contraction_ir_id=_U32,
+            component_index=_U32,
+            factor_id=_U32,
+        )
+        cursor = 0
+        for contraction_ir_id, record in sorted(contraction_records.items()):
+            for component_index, coefficient in enumerate(record.coefficients):
+                coefficients["contraction_ir_id"][cursor] = contraction_ir_id
+                coefficients["component_index"][cursor] = component_index
+                coefficients["factor_id"][cursor] = self.factors.add(
+                    coefficient,
+                    "contraction coefficient",
+                    source_ir_id=contraction_ir_id,
+                )
+                cursor += 1
+        self.tables.append(_freeze_table("contraction_coefficients", coefficients))
+
+    def _interaction_groups(self) -> None:
+        members_by_group = self._interaction_group_members
+        groups = _allocate(
+            len(members_by_group),
+            representative_interaction_id=_U32,
+            member_start=_U64,
+            member_count=_U64,
+        )
+        members = _allocate(len(self.dag.interactions), interaction_id=_U32)
+        cursor = 0
+        for group_id, raw_group_members in enumerate(members_by_group):
+            # Rust normalizes attachment factors by the representative
+            # evaluation factor.  Keep a live member first for mixed groups;
+            # an all-zero group remains explicit in the retained input and is
+            # elided before runtime-plan invocation emission.
+            group_members = sorted(
+                raw_group_members,
+                key=lambda interaction_id: (
+                    self.dag.interactions[
+                        interaction_id
+                    ].evaluation_factor
+                    == (0.0, 0.0)
+                ),
+            )
+            groups["representative_interaction_id"][group_id] = group_members[0]
+            groups["member_start"][group_id] = cursor
+            groups["member_count"][group_id] = len(group_members)
+            stop = cursor + len(group_members)
+            members["interaction_id"][cursor:stop] = group_members
+            cursor = stop
+        self.tables.append(_freeze_table("interaction_groups", groups))
+        self.tables.append(_freeze_table("interaction_group_members", members))
+
+    def _color_plan(self) -> None:
+        sectors = _allocate(
+            len(self.dag.color_plan.sectors),
+            id=_U32,
+            kind_string_id=_U32,
+            open_line_start=_U64,
+            open_line_count=_U64,
+            trace_labels_sequence_id=_U32,
+            singlet_labels_sequence_id=_U32,
+            word_labels_sequence_id=_U32,
+        )
+        open_line_count = sum(
+            len(sector.open_color_lines) for sector in self.dag.color_plan.sectors
+        )
+        open_lines = _allocate(
+            open_line_count,
+            fundamental_label=_U32,
+            antifundamental_label=_U32,
+            adjoint_labels_sequence_id=_U32,
+            singlet_labels_sequence_id=_U32,
+        )
+        cursor = 0
+        for index, sector in enumerate(self.dag.color_plan.sectors):
+            if sector.id != index:
+                raise EagerColumnarInputError("color-sector ids must be dense")
+            sectors["id"][index] = sector.id
+            sectors["kind_string_id"][index] = self.strings.add(sector.kind)
+            sectors["open_line_start"][index] = cursor
+            sectors["open_line_count"][index] = len(sector.open_color_lines)
+            sectors["trace_labels_sequence_id"][index] = self.u32_sequences.add(
+                sector.trace_labels
+            )
+            sectors["singlet_labels_sequence_id"][index] = self.u32_sequences.add(
+                sector.singlet_labels
+            )
+            word = sector.word_labels or sector.color_words[0]
+            sectors["word_labels_sequence_id"][index] = self.u32_sequences.add(word)
+            for line in sector.open_color_lines:
+                open_lines["fundamental_label"][cursor] = line.fundamental_label
+                open_lines["antifundamental_label"][cursor] = line.antifundamental_label
+                open_lines["adjoint_labels_sequence_id"][cursor] = (
+                    self.u32_sequences.add(line.adjoint_labels)
+                )
+                open_lines["singlet_labels_sequence_id"][cursor] = (
+                    self.u32_sequences.add(line.singlet_labels)
+                )
+                cursor += 1
+        self.tables.append(_freeze_table("color_sectors", sectors))
+        self.tables.append(_freeze_table("color_open_lines", open_lines))
+
+    def _topology_replay(self) -> None:
+        replay = self.dag.lc_topology_replay or self.dag.color_topology_replay
+        replay_kind = (
+            0
+            if replay is None
+            else (1 if self.dag.lc_topology_replay is not None else 2)
+        )
+        replay_metadata = _allocate(
+            1,
+            present=_U8,
+            replay_kind=_U8,
+            physical_sector_ids_sequence_id=_U32,
+            materialized_sector_ids_sequence_id=_U32,
+        )
+        replay_metadata["present"][0] = replay is not None
+        replay_metadata["replay_kind"][0] = replay_kind
+        replay_metadata["physical_sector_ids_sequence_id"][0] = (
+            MISSING_U32
+            if replay is None
+            else self.u32_sequences.add(replay.physical_sector_ids)
+        )
+        replay_metadata["materialized_sector_ids_sequence_id"][0] = (
+            MISSING_U32
+            if replay is None
+            else self.u32_sequences.add(replay.materialized_sector_ids)
+        )
+        self.tables.append(_freeze_table("lc_replay_metadata", replay_metadata))
+        diagnostics_values = () if replay is None else replay.diagnostics
+        diagnostics = _allocate(len(diagnostics_values), message_string_id=_U32)
+        for row, message in enumerate(diagnostics_values):
+            diagnostics["message_string_id"][row] = self.strings.add(str(message))
+        self.tables.append(_freeze_table("lc_replay_diagnostics", diagnostics))
+
+        partitions = () if replay is None else replay.partitions
+        partition_columns = _allocate(
+            len(partitions),
+            representative_sector_id=_U32,
+            materialized_sector_id=_U32,
+            member_start=_U64,
+            member_count=_U64,
+            proof_algorithm_string_id=_U32,
+            proof_digest_string_id=_U32,
+        )
+        member_count = sum(len(partition.active_sector_ids) for partition in partitions)
+        members = _allocate(
+            member_count,
+            sector_id=_U32,
+            factor_id=_U32,
+            sign=_I32,
+            permutation_start=_U64,
+            permutation_count=_U64,
+        )
+        permutation_count = sum(
+            len(permutation)
+            for partition in partitions
+            for permutation in partition.label_permutations
+        )
+        permutations = _allocate(
+            permutation_count, representative_label=_U32, sector_label=_U32
+        )
+        member_cursor = 0
+        permutation_cursor = 0
+        for partition_id, partition in enumerate(partitions):
+            partition_columns["representative_sector_id"][partition_id] = (
+                partition.representative_sector_id
+            )
+            partition_columns["materialized_sector_id"][partition_id] = int(
+                partition.materialized_sector_id
+            )
+            partition_columns["member_start"][partition_id] = member_cursor
+            partition_columns["member_count"][partition_id] = len(
+                partition.active_sector_ids
+            )
+            partition_columns["proof_algorithm_string_id"][partition_id] = (
+                self.strings.add(str(partition.proof_algorithm))
+            )
+            partition_columns["proof_digest_string_id"][partition_id] = (
+                self.strings.add(str(partition.proof_digest))
+            )
+            for sector_id, permutation, weight, sign in zip(
+                partition.active_sector_ids,
+                partition.label_permutations,
+                partition.weights,
+                partition.signs,
+                strict=True,
+            ):
+                members["sector_id"][member_cursor] = sector_id
+                members["factor_id"][member_cursor] = self.factors.add(
+                    (weight * sign, 0.0), "LC replay factor"
+                )
+                members["sign"][member_cursor] = sign
+                members["permutation_start"][member_cursor] = permutation_cursor
+                members["permutation_count"][member_cursor] = len(permutation)
+                for representative_label, sector_label in permutation:
+                    permutations["representative_label"][permutation_cursor] = (
+                        representative_label
+                    )
+                    permutations["sector_label"][permutation_cursor] = sector_label
+                    permutation_cursor += 1
+                member_cursor += 1
+        residual_ids = () if replay is None else replay.residual_sector_ids
+        residuals = _allocate(len(residual_ids), sector_id=_U32)
+        residuals["sector_id"][:] = residual_ids
+        self.tables.append(_freeze_table("lc_replay_partitions", partition_columns))
+        self.tables.append(_freeze_table("lc_replay_members", members))
+        self.tables.append(_freeze_table("lc_replay_permutations", permutations))
+        self.tables.append(_freeze_table("lc_replay_residual_sectors", residuals))
+
+    def _color_topology_replay_amplitudes(self) -> None:
+        replay = self.color_topology_replay
+        metadata = _allocate(
+            1,
+            present=_U8,
+            contract_version=_U32,
+            physical_group_count=_U64,
+            mapping_count=_U64,
+        )
+        metadata["present"][0] = replay is not None
+        metadata["contract_version"][0] = 0 if replay is None else 1
+        metadata["physical_group_count"][0] = (
+            0 if replay is None else len(replay.physical_descriptors)
+        )
+        metadata["mapping_count"][0] = (
+            0 if replay is None else len(replay.mappings)
+        )
+        self.tables.append(_freeze_table("color_replay_metadata", metadata))
+
+        physical_groups = () if replay is None else replay.physical_descriptors
+        group_columns = _allocate(
+            len(physical_groups),
+            group_id=_U32,
+            color_sector_id=_U32,
+            color_word_sequence_id=_U32,
+            helicity_values_sequence_id=_U32,
+            helicity_weight_factor_id=_U32,
+        )
+        for row, descriptor in enumerate(physical_groups):
+            group_columns["group_id"][row] = descriptor.group_id
+            group_columns["color_sector_id"][row] = descriptor.sector_id
+            group_columns["color_word_sequence_id"][row] = self.u32_sequences.add(
+                descriptor.word
+            )
+            group_columns["helicity_values_sequence_id"][row] = (
+                self.i32_sequences.add(
+                    _descriptor_helicity_vector(self.dag, descriptor.helicity_key)
+                )
+            )
+            group_columns["helicity_weight_factor_id"][row] = self.factors.add(
+                (descriptor.helicity_weight, 0.0),
+                "color replay physical-group helicity weight",
+            )
+        self.tables.append(
+            _freeze_table("color_replay_physical_groups", group_columns)
+        )
+
+        mappings = () if replay is None else replay.mappings
+        mapping_columns = _allocate(
+            len(mappings),
+            permutation_start=_U64,
+            permutation_count=_U64,
+            route_start=_U64,
+            route_count=_U64,
+        )
+        permutation_count = sum(len(mapping.label_permutation) for mapping in mappings)
+        route_count = sum(len(mapping.group_routes) for mapping in mappings)
+        permutations = _allocate(
+            permutation_count,
+            representative_label=_U32,
+            sector_label=_U32,
+        )
+        routes = _allocate(
+            route_count,
+            source_group_id=_U32,
+            target_group_id=_U32,
+            factor_id=_U32,
+        )
+        permutation_cursor = 0
+        route_cursor = 0
+        for mapping_id, mapping in enumerate(mappings):
+            mapping_columns["permutation_start"][mapping_id] = permutation_cursor
+            mapping_columns["permutation_count"][mapping_id] = len(
+                mapping.label_permutation
+            )
+            mapping_columns["route_start"][mapping_id] = route_cursor
+            mapping_columns["route_count"][mapping_id] = len(mapping.group_routes)
+            for representative_label, sector_label in mapping.label_permutation:
+                permutations["representative_label"][permutation_cursor] = (
+                    representative_label
+                )
+                permutations["sector_label"][permutation_cursor] = sector_label
+                permutation_cursor += 1
+            for route in mapping.group_routes:
+                routes["source_group_id"][route_cursor] = route.source_group_id
+                routes["target_group_id"][route_cursor] = route.target_group_id
+                routes["factor_id"][route_cursor] = self.factors.add(
+                    route.factor,
+                    "color replay amplitude route factor",
+                )
+                route_cursor += 1
+        self.tables.append(_freeze_table("color_replay_mappings", mapping_columns))
+        self.tables.append(
+            _freeze_table("color_replay_permutations", permutations)
+        )
+        self.tables.append(_freeze_table("color_replay_routes", routes))
+
+        contraction = (
+            None
+            if replay is None
+            else build_color_contraction_plan(
+                self.dag.color_plan, replay.physical_descriptors
+            )
+        )
+        if replay is not None and (
+            contraction is None
+            or not contraction.supported
+            or contraction.group_count != len(replay.physical_descriptors)
+        ):
+            raise EagerColumnarInputError(
+                "color replay requires a complete physical color contraction"
+            )
+        contraction_metadata = _allocate(
+            1,
+            present=_U8,
+            group_count=_U64,
+            includes_color_factor=_U8,
+            repeated=_U8,
+            component_count=_U64,
+        )
+        contraction_metadata["present"][0] = contraction is not None
+        contraction_metadata["group_count"][0] = (
+            0 if contraction is None else contraction.group_count
+        )
+        contraction_metadata["includes_color_factor"][0] = (
+            False if contraction is None else contraction.includes_color_factor
+        )
+        repeated = None if contraction is None else contraction.repeated_block
+        contraction_metadata["repeated"][0] = repeated is not None
+        contraction_metadata["component_count"][0] = (
+            0 if repeated is None else repeated.component_count
+        )
+        self.tables.append(
+            _freeze_table(
+                "color_replay_contraction_metadata", contraction_metadata
+            )
+        )
+        component_group_ids = () if repeated is None else repeated.component_group_ids
+        component_groups = _allocate(
+            len(component_group_ids),
+            group_id=_U32,
+        )
+        for row, group_id in enumerate(component_group_ids):
+            component_groups["group_id"][row] = group_id
+        self.tables.append(
+            _freeze_table(
+                "color_replay_contraction_component_groups",
+                component_groups,
+            )
+        )
+
+        entries = (
+            ()
+            if contraction is None
+            else (contraction.entries if repeated is None else repeated.entries)
+        )
+        contraction_entries = _allocate(
+            len(entries),
+            left_group_id=_U32,
+            right_group_id=_U32,
+            left_group_index=_U32,
+            right_group_index=_U32,
+            weight_factor_id=_U32,
+            symmetry_factor_id=_U32,
+        )
+        for row, entry in enumerate(entries):
+            if repeated is None:
+                contraction_entries["left_group_id"][row] = entry.left_group_id
+                contraction_entries["right_group_id"][row] = entry.right_group_id
+                contraction_entries["left_group_index"][row] = MISSING_U32
+                contraction_entries["right_group_index"][row] = MISSING_U32
+            else:
+                contraction_entries["left_group_id"][row] = MISSING_U32
+                contraction_entries["right_group_id"][row] = MISSING_U32
+                contraction_entries["left_group_index"][row] = (
+                    entry.left_group_index
+                )
+                contraction_entries["right_group_index"][row] = (
+                    entry.right_group_index
+                )
+            contraction_entries["weight_factor_id"][row] = self.factors.add(
+                (entry.weight_re, entry.weight_im),
+                "color replay contraction weight",
+                exact_ir=_color_weight_ir(entry),
+            )
+            contraction_entries["symmetry_factor_id"][row] = self.factors.add(
+                (entry.symmetry_factor, 0.0),
+                "color replay contraction symmetry",
+            )
+        self.tables.append(
+            _freeze_table(
+                "color_replay_contraction_entries", contraction_entries
+            )
+        )
+
+    def _helicity_proof(self) -> None:
+        proof = self.dag.helicity_recurrence
+        metadata = _allocate(
+            1,
+            present=_U8,
+            contract_version=_U32,
+            proof_algorithm_string_id=_U32,
+            proof_current_count=_U64,
+            proof_root_count=_U64,
+        )
+        metadata["present"][0] = proof is not None
+        metadata["contract_version"][0] = (
+            0 if proof is None else HELICITY_RECURRENCE_CONTRACT_VERSION
+        )
+        metadata["proof_algorithm_string_id"][0] = (
+            MISSING_U32
+            if proof is None
+            else self.strings.add(HELICITY_RECURRENCE_PROOF_ALGORITHM)
+        )
+        metadata["proof_current_count"][0] = 0 if proof is None else proof.current_count
+        metadata["proof_root_count"][0] = (
+            0 if proof is None else proof.amplitude_root_count
+        )
+        self.tables.append(_freeze_table("helicity_proof_metadata", metadata))
+        diagnostic_values = () if proof is None else proof.diagnostics
+        diagnostics = _allocate(len(diagnostic_values), message_string_id=_U32)
+        for row, message in enumerate(diagnostic_values):
+            diagnostics["message_string_id"][row] = self.strings.add(str(message))
+        self.tables.append(_freeze_table("helicity_proof_diagnostics", diagnostics))
+
+        domains = () if proof is None else proof.selector_domains
+        domain_columns = _allocate(
+            len(domains), id=_U32, complete=_U8, state_start=_U64, state_count=_U64
+        )
+        state_count = sum(len(domain.source_states) for domain in domains)
+        states = _allocate(state_count, external_label=_U32, helicity=_I32)
+        state_cursor = 0
+        for domain in domains:
+            domain_columns["id"][domain.id] = domain.id
+            domain_columns["complete"][domain.id] = domain.complete
+            domain_columns["state_start"][domain.id] = state_cursor
+            domain_columns["state_count"][domain.id] = len(domain.source_states)
+            for label, helicity in domain.source_states:
+                states["external_label"][state_cursor] = label
+                states["helicity"][state_cursor] = helicity
+                state_cursor += 1
+        self.tables.append(_freeze_table("helicity_domains", domain_columns))
+        self.tables.append(_freeze_table("helicity_domain_states", states))
+
+        classes = () if proof is None else proof.recurrence_classes
+        class_columns = _allocate(
+            len(classes),
+            representative_current_id=_U32,
+            external_labels_sequence_id=_U32,
+            source_class=_U8,
+            class_id_string_id=_U32,
+            proof_digest_string_id=_U32,
+            transition_contract_ids_sequence_id=_U32,
+            member_start=_U64,
+            member_count=_U64,
+        )
+        member_count = sum(len(item.members) for item in classes)
+        members = _allocate(
+            member_count,
+            class_index=_U32,
+            current_id=_U32,
+            selector_domain_id=_U32,
+            factor_id=_U32,
+        )
+        class_index_by_id: dict[str, int] = {}
+        cursor = 0
+        for class_index, recurrence in enumerate(classes):
+            class_index_by_id[recurrence.class_id] = class_index
+            class_columns["representative_current_id"][class_index] = (
+                recurrence.representative_current_id
+            )
+            class_columns["external_labels_sequence_id"][class_index] = (
+                self.u32_sequences.add(recurrence.external_labels)
+            )
+            class_columns["source_class"][class_index] = recurrence.source_class
+            class_columns["class_id_string_id"][class_index] = self.strings.add(
+                recurrence.class_id
+            )
+            class_columns["proof_digest_string_id"][class_index] = self.strings.add(
+                recurrence.proof_digest
+            )
+            class_columns["transition_contract_ids_sequence_id"][class_index] = (
+                self.u32_sequences.add(
+                    self.strings.add(value)
+                    for value in recurrence.transition_contract_ids
+                )
+            )
+            class_columns["member_start"][class_index] = cursor
+            class_columns["member_count"][class_index] = len(recurrence.members)
+            for member in recurrence.members:
+                members["class_index"][cursor] = class_index
+                members["current_id"][cursor] = member.current_id
+                members["selector_domain_id"][cursor] = member.selector_domain_id
+                members["factor_id"][cursor] = self.factors.add(
+                    member.factor, "helicity recurrence factor"
+                )
+                cursor += 1
+        self.tables.append(_freeze_table("helicity_recurrence_classes", class_columns))
+        self.tables.append(_freeze_table("helicity_recurrence_members", members))
+
+        source_mappings = () if proof is None else proof.source_state_mappings
+        source_columns = _allocate(
+            len(source_mappings),
+            current_id=_U32,
+            external_label=_U32,
+            helicity=_I32,
+            chirality=_I32,
+            spin_state_sequence_id=_U32,
+            declared_state_index=_U32,
+            selector_domain_id=_U32,
+            recurrence_class_index=_U32,
+            representative_current_id=_U32,
+            source_contract_digest_string_id=_U32,
+            factor_id=_U32,
+        )
+        for row, mapping in enumerate(source_mappings):
+            spin_state = (
+                mapping.spin_state
+                if isinstance(mapping.spin_state, tuple)
+                else (mapping.spin_state,)
+            )
+            source_columns["current_id"][row] = mapping.current_id
+            source_columns["external_label"][row] = mapping.external_label
+            source_columns["helicity"][row] = mapping.helicity
+            source_columns["chirality"][row] = mapping.chirality
+            source_columns["spin_state_sequence_id"][row] = self.i32_sequences.add(
+                spin_state
+            )
+            source_columns["declared_state_index"][row] = mapping.declared_state_index
+            source_columns["selector_domain_id"][row] = mapping.selector_domain_id
+            source_columns["recurrence_class_index"][row] = class_index_by_id[
+                mapping.recurrence_class_id
+            ]
+            source_columns["representative_current_id"][row] = (
+                mapping.representative_current_id
+            )
+            source_columns["source_contract_digest_string_id"][row] = self.strings.add(
+                mapping.source_contract_digest
+            )
+            source_columns["factor_id"][row] = self.factors.add(
+                mapping.factor, "helicity source factor"
+            )
+        self.tables.append(_freeze_table("helicity_source_mappings", source_columns))
+
+        amplitude_classes = () if proof is None else proof.amplitude_classes
+        amplitude_class_columns = _allocate(
+            len(amplitude_classes),
+            representative_root_id=_U32,
+            class_id_string_id=_U32,
+            proof_digest_string_id=_U32,
+            transition_contract_ids_sequence_id=_U32,
+            member_start=_U64,
+            member_count=_U64,
+        )
+        amplitude_member_count = sum(len(item.members) for item in amplitude_classes)
+        amplitude_members = _allocate(
+            amplitude_member_count,
+            class_index=_U32,
+            root_id=_U32,
+            selector_domain_start=_U64,
+            selector_domain_count=_U64,
+            factor_id=_U32,
+        )
+        amplitude_domain_count = sum(
+            len(member.selector_domain_ids)
+            for item in amplitude_classes
+            for member in item.members
+        )
+        amplitude_domains = _allocate(amplitude_domain_count, selector_domain_id=_U32)
+        member_cursor = 0
+        domain_cursor = 0
+        for class_index, recurrence in enumerate(amplitude_classes):
+            amplitude_class_columns["representative_root_id"][class_index] = (
+                recurrence.representative_root_id
+            )
+            amplitude_class_columns["class_id_string_id"][class_index] = (
+                self.strings.add(recurrence.class_id)
+            )
+            amplitude_class_columns["proof_digest_string_id"][class_index] = (
+                self.strings.add(recurrence.proof_digest)
+            )
+            amplitude_class_columns["transition_contract_ids_sequence_id"][
+                class_index
+            ] = self.u32_sequences.add(
+                self.strings.add(value) for value in recurrence.transition_contract_ids
+            )
+            amplitude_class_columns["member_start"][class_index] = member_cursor
+            amplitude_class_columns["member_count"][class_index] = len(
+                recurrence.members
+            )
+            for member in recurrence.members:
+                amplitude_members["class_index"][member_cursor] = class_index
+                amplitude_members["root_id"][member_cursor] = member.root_id
+                amplitude_members["selector_domain_start"][member_cursor] = (
+                    domain_cursor
+                )
+                amplitude_members["selector_domain_count"][member_cursor] = len(
+                    member.selector_domain_ids
+                )
+                for domain_id in member.selector_domain_ids:
+                    amplitude_domains["selector_domain_id"][domain_cursor] = domain_id
+                    domain_cursor += 1
+                amplitude_members["factor_id"][member_cursor] = self.factors.add(
+                    member.factor, "helicity amplitude factor"
+                )
+                member_cursor += 1
+        self.tables.append(
+            _freeze_table("helicity_amplitude_classes", amplitude_class_columns)
+        )
+        self.tables.append(
+            _freeze_table("helicity_amplitude_members", amplitude_members)
+        )
+        self.tables.append(
+            _freeze_table("helicity_amplitude_member_domains", amplitude_domains)
+        )
+
+        for name, values, field_name in (
+            (
+                "helicity_residual_currents",
+                () if proof is None else proof.residual_current_ids,
+                "current_id",
+            ),
+            (
+                "helicity_residual_roots",
+                () if proof is None else proof.residual_root_ids,
+                "root_id",
+            ),
+            (
+                "helicity_structural_zero_domains",
+                () if proof is None else proof.structural_zero_selector_domain_ids,
+                "selector_domain_id",
+            ),
+        ):
+            table = _allocate(len(values), **{field_name: _U32})
+            table[field_name][:] = values
+            self.tables.append(_freeze_table(name, table))
+
+    def _helicity_materialization(self) -> None:
+        materialization = self.dag.helicity_materialization
+        metadata = _allocate(
+            1,
+            present=_U8,
+            strategy_string_id=_U32,
+            proof_current_count=_U64,
+            proof_root_count=_U64,
+            materialized_current_count=_U64,
+            materialized_root_count=_U64,
+        )
+        metadata["present"][0] = materialization is not None
+        metadata["strategy_string_id"][0] = (
+            MISSING_U32
+            if materialization is None
+            else self.strings.add(materialization.strategy)
+        )
+        metadata["proof_current_count"][0] = (
+            0 if materialization is None else materialization.proof_current_count
+        )
+        metadata["proof_root_count"][0] = (
+            0 if materialization is None else materialization.proof_root_count
+        )
+        metadata["materialized_current_count"][0] = (
+            0 if materialization is None else materialization.materialized_current_count
+        )
+        metadata["materialized_root_count"][0] = (
+            0 if materialization is None else materialization.materialized_root_count
+        )
+        self.tables.append(_freeze_table("helicity_materialization_metadata", metadata))
+
+        mapping = (
+            ()
+            if materialization is None
+            else materialization.proof_to_materialized_current
+        )
+        mapping_columns = _allocate(len(mapping), materialized_current_id=_U32)
+        mapping_columns["materialized_current_id"][:] = mapping
+        self.tables.append(
+            _freeze_table("helicity_materialized_current_map", mapping_columns)
+        )
+
+        source_routes = () if materialization is None else materialization.source_routes
+        source_columns = _allocate(
+            len(source_routes),
+            materialized_current_id=_U32,
+            external_label=_U32,
+            helicity=_I32,
+            chirality=_I32,
+            spin_state_sequence_id=_U32,
+            declared_state_index=_U32,
+            selector_domain_id=_U32,
+            factor_id=_U32,
+        )
+        for row, route in enumerate(source_routes):
+            spin_state = (
+                route.spin_state
+                if isinstance(route.spin_state, tuple)
+                else (route.spin_state,)
+            )
+            source_columns["materialized_current_id"][row] = (
+                route.materialized_current_id
+            )
+            source_columns["external_label"][row] = route.external_label
+            source_columns["helicity"][row] = route.helicity
+            source_columns["chirality"][row] = route.chirality
+            source_columns["spin_state_sequence_id"][row] = self.i32_sequences.add(
+                spin_state
+            )
+            source_columns["declared_state_index"][row] = route.declared_state_index
+            source_columns["selector_domain_id"][row] = route.selector_domain_id
+            source_columns["factor_id"][row] = self.factors.add(
+                route.factor, "materialized source factor"
+            )
+        self.tables.append(
+            _freeze_table("helicity_materialized_source_routes", source_columns)
+        )
+
+        amplitude_routes = (
+            () if materialization is None else materialization.amplitude_routes
+        )
+        amplitude_columns = _allocate(
+            len(amplitude_routes),
+            materialized_root_id=_U32,
+            selector_domain_start=_U64,
+            selector_domain_count=_U64,
+            factor_id=_U32,
+            residual=_U8,
+        )
+        domain_count = sum(len(route.selector_domain_ids) for route in amplitude_routes)
+        domains = _allocate(domain_count, selector_domain_id=_U32)
+        cursor = 0
+        for row, route in enumerate(amplitude_routes):
+            amplitude_columns["materialized_root_id"][row] = route.materialized_root_id
+            amplitude_columns["selector_domain_start"][row] = cursor
+            amplitude_columns["selector_domain_count"][row] = len(
+                route.selector_domain_ids
+            )
+            for domain_id in route.selector_domain_ids:
+                domains["selector_domain_id"][cursor] = domain_id
+                cursor += 1
+            amplitude_columns["factor_id"][row] = self.factors.add(
+                route.factor, "materialized amplitude factor"
+            )
+            amplitude_columns["residual"][row] = route.residual
+        self.tables.append(
+            _freeze_table("helicity_materialized_amplitude_routes", amplitude_columns)
+        )
+        self.tables.append(
+            _freeze_table("helicity_materialized_amplitude_domains", domains)
+        )
+
+        schedules = (
+            () if materialization is None else materialization.selector_schedules
+        )
+        schedule_columns = _allocate(
+            len(schedules),
+            selector_domain_id=_U32,
+            active_current_sequence_id=_U32,
+            active_root_sequence_id=_U32,
+            structural_zero=_U8,
+        )
+        for row, schedule in enumerate(schedules):
+            schedule_columns["selector_domain_id"][row] = schedule.selector_domain_id
+            schedule_columns["active_current_sequence_id"][row] = (
+                self.u32_sequences.add(schedule.active_current_ids)
+            )
+            schedule_columns["active_root_sequence_id"][row] = self.u32_sequences.add(
+                schedule.active_root_ids
+            )
+            schedule_columns["structural_zero"][row] = schedule.structural_zero
+        self.tables.append(
+            _freeze_table("helicity_materialized_schedules", schedule_columns)
+        )
+
+    def _selectors_and_reductions(self) -> None:
+        selector_records, selector_id_by_vector = self._helicity_selectors()
+        helicity_selectors = _allocate(
+            len(selector_records),
+            values_sequence_id=_U32,
+            representative_sequence_id=_U32,
+            coefficient_factor_id=_U32,
+            computed=_U8,
+            structural_zero=_U8,
+        )
+        for row, (vector, representative, coefficient, computed, zero) in enumerate(
+            selector_records
+        ):
+            helicity_selectors["values_sequence_id"][row] = self.i32_sequences.add(
+                vector
+            )
+            helicity_selectors["representative_sequence_id"][row] = (
+                self.i32_sequences.add(representative)
+            )
+            helicity_selectors["coefficient_factor_id"][row] = self.factors.add(
+                (coefficient, 0.0), "helicity selector coefficient"
+            )
+            helicity_selectors["computed"][row] = computed
+            helicity_selectors["structural_zero"][row] = zero
+        self.tables.append(_freeze_table("helicity_selectors", helicity_selectors))
+
+        color_records, color_id_by_word = self._color_selectors()
+        color_selectors = _allocate(
+            len(color_records),
+            word_sequence_id=_U32,
+            representative_word_sequence_id=_U32,
+            coefficient_factor_id=_U32,
+            computed=_U8,
+        )
+        for row, (word, representative, coefficient, computed) in enumerate(
+            color_records
+        ):
+            color_selectors["word_sequence_id"][row] = self.u32_sequences.add(word)
+            color_selectors["representative_word_sequence_id"][row] = (
+                self.u32_sequences.add(representative)
+            )
+            color_selectors["coefficient_factor_id"][row] = self.factors.add(
+                (coefficient, 0.0), "color selector coefficient"
+            )
+            color_selectors["computed"][row] = computed
+        self.tables.append(_freeze_table("color_selectors", color_selectors))
+
+        multiple_lc_sectors = _has_multiple_lc_root_sectors(self.dag)
+        group_weights: dict[int, tuple[float, float]] = {}
+        for root in self.dag.amplitude_roots:
+            group_weights.setdefault(
+                self.group_ids[root.id],
+                (
+                    root.helicity_weight,
+                    _root_all_sector_weight(
+                        self.dag,
+                        root,
+                        has_multiple_lc_root_sectors=multiple_lc_sectors,
+                    ),
+                ),
+            )
+        coherent_groups = _allocate(
+            len(self.group_descriptors),
+            id=_U32,
+            color_sector_id=_U32,
+            color_word_sequence_id=_U32,
+            helicity_values_sequence_id=_U32,
+            helicity_weight_factor_id=_U32,
+            all_sector_weight_factor_id=_U32,
+        )
+        reduction_rows: list[tuple[int, int, int]] = []
+        for descriptor in self.group_descriptors:
+            group_id = descriptor.group_id
+            vector = _descriptor_helicity_vector(self.dag, descriptor.helicity_key)
+            word = tuple(int(value) for value in descriptor.word)
+            helicity_weight, all_sector_weight = group_weights[group_id]
+            coherent_groups["id"][group_id] = group_id
+            coherent_groups["color_sector_id"][group_id] = descriptor.sector_id
+            coherent_groups["color_word_sequence_id"][group_id] = (
+                self.u32_sequences.add(word)
+            )
+            coherent_groups["helicity_values_sequence_id"][group_id] = (
+                self.i32_sequences.add(vector)
+            )
+            coherent_groups["helicity_weight_factor_id"][group_id] = self.factors.add(
+                (helicity_weight, 0.0), "group helicity weight"
+            )
+            coherent_groups["all_sector_weight_factor_id"][group_id] = self.factors.add(
+                (all_sector_weight, 0.0), "group all-sector weight"
+            )
+            helicity_members = [vector]
+            if helicity_weight > 1.0 + 1.0e-12:
+                flipped = tuple(-value for value in vector)
+                if flipped != vector:
+                    helicity_members.append(flipped)
+            color_members = [word]
+            if (
+                word
+                and all_sector_weight > helicity_weight + 1.0e-12
+                and (reflected := (word[0], *reversed(word[1:]))) != word
+            ):
+                color_members.append(reflected)
+            for helicity in helicity_members:
+                for color in color_members:
+                    reduction_rows.append(
+                        (
+                            group_id,
+                            selector_id_by_vector[helicity],
+                            (
+                                color_id_by_word[color]
+                                if self.dag.process.color_accuracy == "lc"
+                                else 0
+                            ),
+                        )
+                    )
+        self.tables.append(_freeze_table("coherent_groups", coherent_groups))
+        reductions = _allocate(
+            len(reduction_rows),
+            coherent_group_id=_U32,
+            helicity_selector_id=_U32,
+            color_selector_id=_U32,
+        )
+        for row, values in enumerate(reduction_rows):
+            (
+                reductions["coherent_group_id"][row],
+                reductions["helicity_selector_id"][row],
+                reductions["color_selector_id"][row],
+            ) = values
+        self.tables.append(_freeze_table("reduction_members", reductions))
+
+        contraction = (
+            None
+            if self.color_topology_replay is not None
+            else build_color_contraction_plan(
+                self.dag.color_plan, self.group_descriptors
+            )
+        )
+        contraction_metadata = _allocate(
+            1,
+            present=_U8,
+            color_accuracy_string_id=_U32,
+            supported=_U8,
+            reason_string_id=_U32,
+            group_count=_U64,
+            includes_color_factor=_U8,
+        )
+        contraction_metadata["present"][0] = contraction is not None
+        contraction_metadata["color_accuracy_string_id"][0] = (
+            MISSING_U32
+            if contraction is None
+            else self.strings.add(contraction.color_accuracy)
+        )
+        contraction_metadata["supported"][0] = (
+            False if contraction is None else contraction.supported
+        )
+        contraction_metadata["reason_string_id"][0] = (
+            MISSING_U32
+            if contraction is None or contraction.reason is None
+            else self.strings.add(contraction.reason)
+        )
+        contraction_metadata["group_count"][0] = (
+            0 if contraction is None else contraction.group_count
+        )
+        contraction_metadata["includes_color_factor"][0] = (
+            False if contraction is None else contraction.includes_color_factor
+        )
+        self.tables.append(
+            _freeze_table("color_contraction_metadata", contraction_metadata)
+        )
+        entry_count = 0 if contraction is None else contraction.logical_entry_count
+        contraction_columns = _allocate(
+            entry_count,
+            left_group_id=_U32,
+            right_group_id=_U32,
+            weight_factor_id=_U32,
+            symmetry_factor_id=_U32,
+        )
+        logical_entries = (
+            () if contraction is None else contraction.iter_logical_entries()
+        )
+        for row, entry in enumerate(logical_entries):
+            contraction_columns["left_group_id"][row] = entry.left_group_id
+            contraction_columns["right_group_id"][row] = entry.right_group_id
+            contraction_columns["weight_factor_id"][row] = self.factors.add(
+                (entry.weight_re, entry.weight_im),
+                "color contraction weight",
+                exact_ir=_color_weight_ir(entry),
+            )
+            contraction_columns["symmetry_factor_id"][row] = self.factors.add(
+                (entry.symmetry_factor, 0.0), "color contraction symmetry"
+            )
+        self.tables.append(
+            _freeze_table("color_contraction_entries", contraction_columns)
+        )
+
+    def _helicity_selectors(
+        self,
+    ) -> tuple[
+        tuple[tuple[tuple[int, ...], tuple[int, ...], float, bool, bool], ...],
+        dict[tuple[int, ...], int],
+    ]:
+        represented: dict[tuple[int, ...], tuple[tuple[int, ...], bool, float]] = {}
+        materialization = self.dag.helicity_materialization
+        recurrence = self.dag.helicity_recurrence
+        if materialization is None:
+            for descriptor in self.group_descriptors:
+                vector = _descriptor_helicity_vector(self.dag, descriptor.helicity_key)
+                weight = float(descriptor.helicity_weight)
+                represented.setdefault(vector, (vector, True, 1.0))
+                if weight > 1.0 + 1.0e-12:
+                    if not math.isclose(weight, 2.0, rel_tol=1.0e-12, abs_tol=1.0e-12):
+                        raise EagerColumnarInputError(
+                            f"unsupported helicity reuse weight {weight!r}"
+                        )
+                    flipped = tuple(-value for value in vector)
+                    represented.setdefault(flipped, (vector, False, 1.0))
+        else:
+            if recurrence is None:
+                raise EagerColumnarInputError(
+                    "helicity materialization lacks its recurrence proof"
+                )
+            domain_by_id = {domain.id: domain for domain in recurrence.selector_domains}
+            group_by_root = self.group_ids
+            representative_by_group = {
+                descriptor.group_id: _descriptor_helicity_vector(
+                    self.dag, descriptor.helicity_key
+                )
+                for descriptor in self.group_descriptors
+            }
+            for route in materialization.amplitude_routes:
+                group_id = group_by_root[route.materialized_root_id]
+                representative = representative_by_group[group_id]
+                coefficient = route.factor[0] ** 2 + route.factor[1] ** 2
+                for domain_id in route.selector_domain_ids:
+                    domain = domain_by_id[domain_id]
+                    by_label = dict(domain.source_states)
+                    vector = tuple(
+                        by_label.get(int(leg.label), 0) for leg in self.dag.process.legs
+                    )
+                    candidate = (
+                        representative,
+                        vector == representative,
+                        coefficient,
+                    )
+                    previous = represented.setdefault(vector, candidate)
+                    if previous != candidate:
+                        raise EagerColumnarInputError(
+                            f"inconsistent materialized helicity route {vector}"
+                        )
+
+        possible = _possible_helicity_vectors(self.dag, self.model)
+        rows = []
+        for vector in sorted(possible):
+            if vector in represented:
+                representative, computed, coefficient = represented[vector]
+                rows.append((vector, representative, coefficient, computed, False))
+            else:
+                rows.append((vector, vector, 0.0, False, True))
+        result = tuple(rows)
+        return result, {row[0]: index for index, row in enumerate(result)}
+
+    def _color_selectors(
+        self,
+    ) -> tuple[
+        tuple[tuple[tuple[int, ...], tuple[int, ...], float, bool], ...],
+        dict[tuple[int, ...], int],
+    ]:
+        if self.dag.process.color_accuracy != "lc":
+            records = (((), (), 1.0, True),)
+            return records, {(): 0}
+        replay = self.dag.lc_topology_replay
+        materialized = (
+            set(replay.materialized_sector_ids) if replay is not None else None
+        )
+        records: dict[tuple[int, ...], tuple[tuple[int, ...], float, bool]] = {}
+        for sector in self.dag.color_plan.sectors:
+            word = tuple(sector.word_labels or sector.color_words[0])
+            representative = sector
+            if replay is not None:
+                representative = self.dag.color_plan.sector(
+                    replay.representative_for(sector.id)
+                )
+                if representative is None:
+                    raise EagerColumnarInputError(
+                        f"missing replay representative for sector {sector.id}"
+                    )
+            representative_word = tuple(
+                representative.word_labels or representative.color_words[0]
+            )
+            records.setdefault(
+                word,
+                (
+                    representative_word,
+                    1.0,
+                    materialized is None or sector.id in materialized,
+                ),
+            )
+            if (
+                self.dag.color_plan.trace_reflections_folded
+                and sector.kind == "single-trace"
+                and len(word) > 2
+                and (reflected := (word[0], *reversed(word[1:]))) != word
+            ):
+                records.setdefault(reflected, (representative_word, 1.0, False))
+        rows = tuple((word, *records[word]) for word in sorted(records))
+        return rows, {row[0]: index for index, row in enumerate(rows)}
+
+    def _coupling(
+        self,
+        kind: int,
+        particles: tuple[int, int, int],
+        coupling: tuple[float, float],
+    ) -> int:
+        key = (int(kind), tuple(int(value) for value in particles), tuple(coupling))
+        existing = self.coupling_ids.get(key)
+        if existing is not None:
+            return existing
+        names = runtime_coupling_parameter_names(
+            kind, particles, coupling, model=self.model
+        )
+        exact_ir = (
+            None
+            if not any(name is not None for name in names)
+            else {
+                "abi": "pyamplicol-runtime-coupling-v1",
+                "kind": "model-parameter-components",
+                "components": [
+                    (
+                        {"kind": "binary64-constant", "component": component}
+                        if name is None
+                        else {"kind": "model-parameter", "name": str(name)}
+                    )
+                    for component, name in enumerate(names)
+                ],
+            }
+        )
+        name_sequence_id = self.u32_sequences.add(
+            MISSING_U32 if name is None else self.strings.add(name) for name in names
+        )
+        result = _checked_u32(len(self.coupling_specs), "coupling id")
+        self.coupling_specs.append(
+            (
+                _checked_i32(kind, "coupling vertex kind"),
+                tuple(_checked_i32(value, "coupling particle") for value in particles),
+                self.factors.add(
+                    coupling,
+                    "coupling constant",
+                    exact_ir=exact_ir,
+                ),
+                name_sequence_id,
+            )
+        )
+        self.coupling_ids[key] = result
+        return result
+
+    def _couplings(self) -> None:
+        columns = _allocate(
+            len(self.coupling_specs),
+            vertex_kind=_I32,
+            vertex_particles=(_I32, (3,)),
+            constant_factor_id=_U32,
+            parameter_name_ids_sequence_id=_U32,
+        )
+        for row, (kind, particles, factor_id, names_id) in enumerate(
+            self.coupling_specs
+        ):
+            columns["vertex_kind"][row] = kind
+            columns["vertex_particles"][row] = particles
+            columns["constant_factor_id"][row] = factor_id
+            columns["parameter_name_ids_sequence_id"][row] = names_id
+        self.tables.append(_freeze_table("couplings", columns))
+
+    def _model_parameters(self) -> None:
+        specs = _model_parameter_specs(
+            self.dag,
+            self.model,
+            tuple(
+                (
+                    kind,
+                    particles,
+                    self.factors.pair(factor_id),
+                    tuple(
+                        None if name_id == MISSING_U32 else self.strings.values[name_id]
+                        for name_id in self.u32_sequences.values[names_id]
+                    ),
+                )
+                for kind, particles, factor_id, names_id in self.coupling_specs
+            ),
+        )
+        columns = _allocate(
+            len(specs),
+            name_string_id=_U32,
+            kind_string_id=_U32,
+            default_value=_F64,
+            default_factor_id=_U32,
+            runtime_name_string_id=_U32,
+            complex_component=_I32,
+            parameter_type_string_id=_U32,
+            pdg=_I32,
+            vertex_kind=_I32,
+            vertex_particles=(_I32, (3,)),
+            coupling_component=_I32,
+            derived=_U8,
+            complex_domain_string_id=_U32,
+            definition_string_id=_U32,
+        )
+        for row, spec in enumerate(specs):
+            columns["name_string_id"][row] = self.strings.add(spec.name)
+            columns["kind_string_id"][row] = self.strings.add(spec.kind)
+            columns["default_value"][row] = _finite(spec.default, "parameter default")
+            exact_ir = (
+                None
+                if not spec.derived or spec.definition is None
+                else {
+                    "abi": "pyamplicol-derived-parameter-v1",
+                    "kind": "canonical-expression-component",
+                    "name": spec.runtime_name or spec.name,
+                    "component": spec.complex_component,
+                    "expression": spec.definition,
+                    "domain": spec.complex_domain,
+                }
+            )
+            columns["default_factor_id"][row] = self.factors.add(
+                (spec.default, 0.0),
+                "model parameter default",
+                exact_ir=exact_ir,
+            )
+            columns["runtime_name_string_id"][row] = self.strings.optional(
+                spec.runtime_name
+            )
+            columns["complex_component"][row] = spec.complex_component
+            columns["parameter_type_string_id"][row] = self.strings.optional(
+                spec.parameter_type
+            )
+            columns["pdg"][row] = MISSING_I32 if spec.pdg is None else spec.pdg
+            columns["vertex_kind"][row] = (
+                MISSING_I32 if spec.vertex_kind is None else spec.vertex_kind
+            )
+            columns["vertex_particles"][row] = (
+                (MISSING_I32, MISSING_I32, MISSING_I32)
+                if spec.vertex_particles is None
+                else spec.vertex_particles
+            )
+            columns["coupling_component"][row] = (
+                MISSING_I32
+                if spec.coupling_component is None
+                else spec.coupling_component
+            )
+            columns["derived"][row] = spec.derived
+            columns["complex_domain_string_id"][row] = self.strings.optional(
+                spec.complex_domain
+            )
+            columns["definition_string_id"][row] = self.strings.optional(
+                spec.definition
+            )
+        self.tables.append(_freeze_table("model_parameters", columns))
+
+
+def build_eager_lowering_input_v1(
+    *,
+    dag: GenericDAG,
+    model: Model,
+    resolver: EagerKernelResolver,
+    process_id: str | None = None,
+) -> EagerLoweringInputV1:
+    """Build the v1 lowering input without constructing a runtime schema."""
+
+    return _Builder(dag, model, resolver, process_id).build()
+
+
+def runtime_model_parameter_records_from_eager_input(
+    lowering_input: EagerLoweringInputV1,
+) -> tuple[dict[str, object], ...]:
+    """Project the authoritative eager parameter columns into physics records."""
+
+    table = lowering_input.table("model_parameters")
+    names = table.column("name_string_id")
+    kinds = table.column("kind_string_id")
+    defaults = table.column("default_value")
+    runtime_names = table.column("runtime_name_string_id")
+    components = table.column("complex_component")
+    records: list[dict[str, object]] = []
+    for row in range(table.row_count):
+        runtime_name_id = int(runtime_names[row])
+        component = int(components[row])
+        record: dict[str, object] = {
+            "name": lowering_input.string_catalog[int(names[row])],
+            "kind": lowering_input.string_catalog[int(kinds[row])],
+            "parameter_index": row,
+            "default": float(defaults[row]),
+        }
+        if runtime_name_id != MISSING_U32:
+            record["runtime_name"] = lowering_input.string_catalog[runtime_name_id]
+        if component == 0:
+            record["complex_component"] = "real"
+        elif component == 1:
+            record["complex_component"] = "imag"
+        elif component != -1:
+            raise EagerColumnarInputError(
+                f"model parameter {row} has invalid complex component {component}"
+            )
+        records.append(record)
+    return tuple(records)
+
+
+def _model_parameter_specs(
+    dag: GenericDAG,
+    model: Model,
+    couplings: Sequence[
+        tuple[
+            int,
+            tuple[int, int, int],
+            tuple[float, float],
+            tuple[str | None, ...],
+        ]
+    ],
+) -> tuple[_ModelParameterSpec, ...]:
+    result: list[_ModelParameterSpec] = []
+    seen: set[str] = set()
+
+    def add(spec: _ModelParameterSpec) -> None:
+        if spec.name in seen:
+            return
+        seen.add(spec.name)
+        result.append(spec)
+
+    def add_complex(
+        name: str,
+        value: object,
+        *,
+        kind: str,
+        derived: bool = False,
+        domain: str | None = None,
+        definition: str | None = None,
+    ) -> None:
+        pair = _complex_default(value, name)
+        for component, default in enumerate(pair):
+            add(
+                _ModelParameterSpec(
+                    name=f"{name}.{'real' if component == 0 else 'imag'}",
+                    kind=kind,
+                    default=default,
+                    runtime_name=name,
+                    complex_component=component,
+                    derived=derived,
+                    complex_domain=domain,
+                    definition=definition,
+                )
+            )
+
+    for name, value in sorted(model.runtime_normalization_parameter_defaults().items()):
+        add(
+            _ModelParameterSpec(
+                name=str(name), kind="normalization", default=float(value)
+            )
+        )
+
+    defaults_provider = getattr(model, "runtime_parameter_defaults", None)
+    if callable(defaults_provider):
+        type_provider = getattr(model, "runtime_parameter_type", None)
+        for raw_name, value in sorted(defaults_provider().items()):
+            name = str(raw_name)
+            declared = (
+                str(type_provider(name)).lower()
+                if callable(type_provider)
+                else "complex"
+            )
+            if declared == "complex":
+                add_complex(name, value, kind="external_parameter_component")
+            else:
+                real, imaginary = _complex_default(value, name)
+                if imaginary != 0.0:
+                    raise EagerColumnarInputError(
+                        f"real model parameter {name!r} has imaginary default"
+                    )
+                add(
+                    _ModelParameterSpec(
+                        name=name,
+                        kind="external_parameter",
+                        default=real,
+                        parameter_type=declared,
+                    )
+                )
+        used = {name for *_prefix, names in couplings for name in names if name}
+        particle_names = getattr(model, "runtime_parameter_names_for_particle", None)
+        if callable(particle_names):
+            for particle_id in sorted(
+                {current.index.particle_id for current in dag.currents}
+            ):
+                used.update(str(name) for name in particle_names(particle_id))
+        derived_defaults = getattr(
+            model, "runtime_derived_parameter_defaults_for", None
+        )
+        if callable(derived_defaults):
+            names = tuple(sorted(used))
+            values = derived_defaults(names)
+            domains_provider = getattr(
+                model, "runtime_derived_parameter_domains_for", None
+            )
+            domains = domains_provider(names) if callable(domains_provider) else {}
+            definitions_provider = getattr(
+                model, "runtime_derived_parameter_definitions_for", None
+            )
+            definitions = (
+                definitions_provider(names) if callable(definitions_provider) else {}
+            )
+            for raw_name, value in sorted(values.items()):
+                name = str(raw_name)
+                add_complex(
+                    name,
+                    value,
+                    kind="derived_parameter_component",
+                    derived=True,
+                    domain=str(domains.get(raw_name, domains.get(name, "complex"))),
+                    definition=(
+                        None
+                        if definitions.get(raw_name, definitions.get(name)) is None
+                        else str(definitions.get(raw_name, definitions.get(name)))
+                    ),
+                )
+        return tuple(result)
+
+    for particle in sorted(model.particles.values(), key=lambda item: item.pdg):
+        if float(particle.mass) != 0.0:
+            add(
+                _ModelParameterSpec(
+                    name=f"particle.{particle.pdg}.mass",
+                    kind="particle_mass",
+                    default=float(particle.mass),
+                    pdg=particle.pdg,
+                )
+            )
+        if float(particle.width) != 0.0:
+            add(
+                _ModelParameterSpec(
+                    name=f"particle.{particle.pdg}.width",
+                    kind="particle_width",
+                    default=float(particle.width),
+                    pdg=particle.pdg,
+                )
+            )
+    for kind, particles, coupling, names in sorted(couplings):
+        for component, name in enumerate(names):
+            if name is None:
+                continue
+            add(
+                _ModelParameterSpec(
+                    name=name,
+                    kind="coupling_component",
+                    default=float(coupling[component]),
+                    vertex_kind=kind,
+                    vertex_particles=particles,
+                    coupling_component=component,
+                )
+            )
+    return tuple(result)
+
+
+def _possible_helicity_vectors(
+    dag: GenericDAG, model: Model
+) -> tuple[tuple[int, ...], ...]:
+    selected = dict(dag.selected_source_helicities)
+    per_leg: list[tuple[int, ...]] = []
+    for leg in dag.process.legs:
+        if leg.outgoing_pdg is None:
+            per_leg.append((0,))
+            continue
+        source_ir = model._source_ir(int(leg.outgoing_pdg))
+        values = {
+            int((source_ir.crossing.apply(state) if leg.is_initial else state).helicity)
+            for state in source_ir.states
+        }
+        if leg.label in selected:
+            values.intersection_update((selected[leg.label],))
+            if not values:
+                raise EagerColumnarInputError(
+                    f"selected helicity is unavailable for leg {leg.label}"
+                )
+        per_leg.append(tuple(sorted(values)))
+    return tuple(tuple(values) for values in product(*per_leg))
+
+
+def _descriptor_helicity_vector(
+    dag: GenericDAG, helicity_key: tuple[object, ...]
+) -> tuple[int, ...]:
+    by_label: dict[int, int] = {}
+    for item in helicity_key:
+        if isinstance(item, tuple) and len(item) >= 5:
+            by_label[int(item[0])] = int(item[4])
+    return tuple(by_label.get(leg.label, 0) for leg in dag.process.legs)
+
+
+def _fill_resolved_kernel(
+    columns: Mapping[str, np.ndarray[Any, Any]],
+    row: int,
+    resolved: EagerResolvedKernel,
+    factors: _FactorCatalog,
+) -> None:
+    columns["kernel_id"][row] = _checked_u32(resolved.kernel_id, "prepared kernel id")
+    columns["canonical_input_order"][row] = resolved.canonical_input_order
+    columns["kernel_normalization_factor_id"][row] = factors.add(
+        resolved.normalization_factor, "prepared kernel normalization"
+    )
+    columns["output_factor_source"][row] = _checked_u8(
+        resolved.output_factor_source, "prepared output factor source"
+    )
+
+
+def _allocate(
+    row_count: int,
+    **specifications: np.dtype[Any] | tuple[np.dtype[Any], tuple[int, ...]],
+) -> dict[str, np.ndarray[Any, Any]]:
+    _checked_u64(row_count, "table row count")
+    result: dict[str, np.ndarray[Any, Any]] = {}
+    for name, specification in specifications.items():
+        if isinstance(specification, tuple):
+            dtype, tail_shape = specification
+        else:
+            dtype, tail_shape = specification, ()
+        result[name] = np.empty((row_count, *tail_shape), dtype=dtype, order="C")
+    return result
+
+
+def _freeze_table(
+    name: str,
+    columns: Mapping[str, np.ndarray[Any, Any]],
+) -> EagerColumnarTable:
+    row_counts = {len(values) for values in columns.values()}
+    row_count = row_counts.pop() if row_counts else 0
+    if row_counts:
+        raise EagerColumnarInputError(f"table {name!r} columns have unequal lengths")
+    frozen: list[EagerColumn] = []
+    for column_name, values in columns.items():
+        values.flags.writeable = False
+        frozen.append(EagerColumn(column_name, values))
+    return EagerColumnarTable(name, row_count, tuple(frozen))
+
+
+def _validate_catalog(values: tuple[str, ...], context: str) -> None:
+    if any(not isinstance(value, str) for value in values):
+        raise TypeError(f"{context} catalog must contain strings")
+    if len(set(values)) != len(values):
+        raise EagerColumnarInputError(f"{context} catalog contains duplicates")
+
+
+def _validate_dense_ids(table: EagerColumnarTable, column_name: str) -> None:
+    values = table.column(column_name)
+    expected = np.arange(table.row_count, dtype=_U32)
+    if not np.array_equal(values, expected):
+        raise EagerColumnarInputError(f"table {table.name!r} ids are not dense")
+
+
+def _validate_bounded_columns(
+    table: EagerColumnarTable,
+    columns: Sequence[str],
+    bound: int,
+) -> None:
+    for column_name in columns:
+        values = table.column(column_name)
+        if values.size and int(values.max()) >= bound:
+            raise EagerColumnarInputError(
+                f"{table.name}.{column_name} references an absent row"
+            )
+
+
+def _validate_optional_bounded_columns(
+    table: EagerColumnarTable,
+    columns: Sequence[str],
+    bound: int,
+) -> None:
+    for column_name in columns:
+        values = table.column(column_name)
+        present = values[values != MISSING_U32]
+        if present.size and int(present.max()) >= bound:
+            raise EagerColumnarInputError(
+                f"{table.name}.{column_name} references an absent row"
+            )
+
+
+def _require_index(value: int, bound: int, context: str) -> int:
+    result = _checked_u32(value, context)
+    if result >= bound:
+        raise EagerColumnarInputError(f"{context} {result} is outside [0, {bound})")
+    return result
+
+
+def _checked_u8(value: int, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or not 0 <= value < 256:
+        raise EagerColumnarInputError(f"{context} does not fit u8: {value!r}")
+    return value
+
+
+def _checked_u32(value: int, context: str) -> int:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, int)
+        or not 0 <= value <= MISSING_U32
+    ):
+        raise EagerColumnarInputError(f"{context} does not fit u32: {value!r}")
+    return value
+
+
+def _positive_u32(value: int, context: str) -> int:
+    result = _checked_u32(value, context)
+    if result == 0:
+        raise EagerColumnarInputError(f"{context} must be positive")
+    return result
+
+
+def _checked_u64(value: int, context: str) -> int:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, int)
+        or not 0 <= value < 1 << 64
+    ):
+        raise EagerColumnarInputError(f"{context} does not fit u64: {value!r}")
+    return value
+
+
+def _checked_i32(value: int, context: str) -> int:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, int)
+        or not -(1 << 31) <= value < 1 << 31
+    ):
+        raise EagerColumnarInputError(f"{context} does not fit i32: {value!r}")
+    return value
+
+
+def _finite(value: float, context: str) -> float:
+    result = float(value)
+    if not math.isfinite(result):
+        raise EagerColumnarInputError(f"{context} must be finite")
+    return result
+
+
+def _complex_default(value: object, context: str) -> tuple[float, float]:
+    if isinstance(value, complex):
+        pair = (float(value.real), float(value.imag))
+    elif isinstance(value, Sequence) and not isinstance(value, str | bytes):
+        if len(value) != 2:
+            raise EagerColumnarInputError(f"{context} must be a complex pair")
+        pair = (float(value[0]), float(value[1]))
+    else:
+        pair = (float(value), 0.0)
+    if not all(math.isfinite(component) for component in pair):
+        raise EagerColumnarInputError(f"{context} must be finite")
+    return pair
+
+
+def _f64_bits(value: float) -> int:
+    """Return the exact little-endian IEEE-754 payload for one finite f64."""
+
+    return int.from_bytes(struct.pack("<d", value), "little", signed=False)
+
+
+def _binary64_exact_ir(value: tuple[float, float]) -> dict[str, object]:
+    """Canonical exact representation of a complex value sourced as f64."""
+
+    return {
+        "abi": "pyamplicol-exact-factor-v1",
+        "kind": "complex-ieee754-binary64",
+        "real_bits": f"{_f64_bits(value[0]):016x}",
+        "imaginary_bits": f"{_f64_bits(value[1]):016x}",
+    }
+
+
+def _color_weight_ir(
+    entry: ColorContractionEntry | ColorContractionTemplateEntry,
+) -> dict[str, object] | None:
+    if entry.exact_weight is None:
+        return None
+    return {"kind": "rational-complex", "value": entry.to_json_dict()["exact_weight"]}
+
+
+def _hash_text(digest: Any, value: str) -> None:
+    encoded = value.encode("utf-8")
+    digest.update(len(encoded).to_bytes(8, "little"))
+    digest.update(encoded)
+
+
+__all__ = [
+    "EAGER_LOWERING_INPUT_ABI",
+    "EAGER_LOWERING_INPUT_SCHEMA_SHA256",
+    "FACTOR_EXACT_SOURCE_BINARY64",
+    "FACTOR_EXACT_SOURCE_CANONICAL_IR",
+    "EagerColumn",
+    "EagerColumnarInputError",
+    "EagerColumnarTable",
+    "EagerLoweringInputV1",
+    "build_eager_lowering_input_v1",
+    "runtime_model_parameter_records_from_eager_input",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/eager_lowering.py b/pyamplicol/src/pyamplicol/generation/eager_lowering.py
new file mode 100644
index 0000000000..61ccfaba7b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/eager_lowering.py
@@ -0,0 +1,1515 @@
+# SPDX-License-Identifier: 0BSD
+"""Lower proven process DAGs into backend-independent eager execution tables."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Protocol
+
+from ..models.base import Model
+from ..models.prepared_catalog import (
+    ClosureKernelKey,
+    PropagatorKernelKey,
+    VertexKernelKey,
+)
+from .contracts import runtime_coupling_parameter_names
+from .dag_types import CurrentNode, GenericDAG, InteractionNode
+from .eager_tables import (
+    EAGER_OUTPUT_FACTOR_COUPLING_IMAG,
+    EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+    EAGER_OUTPUT_FACTOR_NONE,
+    EAGER_PLAN_ABI,
+    EAGER_RUNTIME_CAPABILITY,
+    EAGER_SELECTOR_DOMAINS_ABI,
+    MISSING_U32,
+    EagerAttachmentRow,
+    EagerClosureRow,
+    EagerCouplingRow,
+    EagerFinalizationRow,
+    EagerInvocationRow,
+    EagerSelectorDomainIdRow,
+    EagerSelectorDomainRow,
+    EagerSelectorGroupRow,
+    pack_rows,
+)
+from .runtime_schema import RuntimeSchemaLayout, build_runtime_schema_layout
+
+EAGER_RUNTIME_KIND = "pyamplicol-runtime-eager-execution"
+EagerProgressCallback = Callable[[Mapping[str, str | int]], None]
+
+# Dense Python integer masks are substantially cheaper than materialized
+# membership tuples for the selector universes seen in complete LC artifacts.
+# Keep the sparse interning path for unusually large universes, where retaining
+# one arbitrary-width integer per distinct domain would dominate memory.
+_DENSE_SELECTOR_DOMAIN_GROUP_LIMIT = 4096
+
+
+class EagerKernelResolver(Protocol):
+    """Resolve model-local prepared kernels without compiling them."""
+
+    def vertex_kernel(self, interaction: InteractionNode) -> EagerResolvedKernel: ...
+
+    def propagator_kernel_id(
+        self,
+        current: CurrentNode,
+        propagator: Mapping[str, object],
+    ) -> int | None: ...
+
+    def closure_kernel(
+        self, root: Mapping[str, object]
+    ) -> EagerResolvedKernel | None: ...
+
+
+@dataclass(frozen=True, slots=True)
+class EagerResolvedKernel:
+    """Prepared callable plus the exact transformation into its canonical ABI."""
+
+    kernel_id: int
+    canonical_input_order: tuple[int, int] = (0, 1)
+    normalization_factor: tuple[float, float] = (1.0, 0.0)
+    output_factor_source: int = EAGER_OUTPUT_FACTOR_NONE
+
+    def __post_init__(self) -> None:
+        if self.kernel_id < 0:
+            raise ValueError("prepared kernel ID must be nonnegative")
+        if self.canonical_input_order not in ((0, 1), (1, 0)):
+            raise ValueError("prepared binary input order must be a permutation")
+        if complex(*self.normalization_factor) == 0j:
+            raise ValueError("prepared kernel normalization factor must be nonzero")
+        if self.output_factor_source not in (
+            EAGER_OUTPUT_FACTOR_NONE,
+            EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+            EAGER_OUTPUT_FACTOR_COUPLING_IMAG,
+        ):
+            raise ValueError("unsupported prepared output factor source")
+
+
+@dataclass(frozen=True, slots=True)
+class MappingEagerKernelResolver:
+    """Small immutable resolver used by prepared kernel-pack manifests."""
+
+    vertex_kernels: Mapping[int, int]
+    propagator_kernels: Mapping[tuple[int, int], int]
+    closure_kernels: Mapping[tuple[str, int | None], int]
+
+    def vertex_kernel(self, interaction: InteractionNode) -> EagerResolvedKernel:
+        try:
+            return EagerResolvedKernel(
+                int(self.vertex_kernels[interaction.vertex_kind])
+            )
+        except KeyError as error:
+            raise ValueError(
+                f"prepared model has no vertex kernel for kind "
+                f"{interaction.vertex_kind}"
+            ) from error
+
+    def propagator_kernel_id(
+        self,
+        current: CurrentNode,
+        propagator: Mapping[str, object],
+    ) -> int | None:
+        if not bool(propagator.get("applies_propagator", False)):
+            return None
+        key = (int(current.index.particle_id), int(current.index.chirality))
+        try:
+            return int(self.propagator_kernels[key])
+        except KeyError as error:
+            raise ValueError(
+                f"prepared model has no propagator kernel for particle/chirality {key}"
+            ) from error
+
+    def closure_kernel(self, root: Mapping[str, object]) -> EagerResolvedKernel | None:
+        kind = str(root.get("kind"))
+        vertex_kind = root.get("vertex_kind")
+        key = (kind, None if vertex_kind is None else int(vertex_kind))
+        if kind == "direct-contraction":
+            return None
+        try:
+            return EagerResolvedKernel(int(self.closure_kernels[key]))
+        except KeyError as error:
+            raise ValueError(
+                f"prepared model has no closure kernel for {key}"
+            ) from error
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedCatalogEagerKernelIndex:
+    """Model-local resolver index parsed once while loading a prepared pack."""
+
+    vertices: Mapping[VertexKernelKey, EagerResolvedKernel]
+    propagators: Mapping[PropagatorKernelKey, int | None]
+    closures: Mapping[ClosureKernelKey, EagerResolvedKernel]
+
+    @classmethod
+    def from_manifest(
+        cls,
+        manifest: Mapping[str, object],
+    ) -> PreparedCatalogEagerKernelIndex:
+        if manifest.get("abi") != "pyamplicol-prepared-kernel-catalog-v1":
+            raise ValueError("prepared model has an incompatible resolver ABI")
+        vertices: dict[VertexKernelKey, EagerResolvedKernel] = {}
+        propagators: dict[PropagatorKernelKey, int | None] = {}
+        closures: dict[ClosureKernelKey, EagerResolvedKernel] = {}
+        for raw in _mapping_sequence(
+            manifest.get("vertex_bindings"), "resolver.vertex_bindings"
+        ):
+            key = _vertex_kernel_key(_mapping(raw.get("key"), "resolver.vertex.key"))
+            vertices[key] = _resolved_kernel(raw, "resolver.vertex")
+        for raw in _mapping_sequence(
+            manifest.get("propagator_bindings"), "resolver.propagator_bindings"
+        ):
+            key_data = _mapping(raw.get("key"), "resolver.propagator.key")
+            key = PropagatorKernelKey(
+                int(key_data["particle_id"]), int(key_data["chirality"])
+            )
+            kernel_id = raw.get("kernel_id")
+            propagators[key] = None if kernel_id is None else int(kernel_id)
+        for raw in _mapping_sequence(
+            manifest.get("closure_bindings"), "resolver.closure_bindings"
+        ):
+            key = _closure_kernel_key(_mapping(raw.get("key"), "resolver.closure.key"))
+            closures[key] = _resolved_kernel(raw, "resolver.closure")
+        return cls(vertices=vertices, propagators=propagators, closures=closures)
+
+
+class PreparedCatalogEagerKernelResolver:
+    """Bind one process DAG to a validated prepared-model resolver index."""
+
+    def __init__(
+        self,
+        dag: GenericDAG,
+        manifest: Mapping[str, object] | PreparedCatalogEagerKernelIndex,
+    ) -> None:
+        index = (
+            manifest
+            if isinstance(manifest, PreparedCatalogEagerKernelIndex)
+            else PreparedCatalogEagerKernelIndex.from_manifest(manifest)
+        )
+        self._dag = dag
+        self._vertices = index.vertices
+        self._propagators = index.propagators
+        self._closures = index.closures
+
+    def vertex_kernel(self, interaction: InteractionNode) -> EagerResolvedKernel:
+        left = self._dag.currents[interaction.left_id]
+        right = self._dag.currents[interaction.right_id]
+        result = self._dag.currents[interaction.result_id]
+        key = VertexKernelKey(
+            kind=int(interaction.vertex_kind),
+            particles=tuple(int(value) for value in interaction.vertex_particles),
+            left_chirality=int(left.index.chirality),
+            right_chirality=int(right.index.chirality),
+            result_chirality=int(result.index.chirality),
+            coupling=tuple(float(value) for value in interaction.coupling),
+        )
+        try:
+            return self._vertices[key]
+        except KeyError as error:
+            raise ValueError(
+                f"prepared model has no vertex binding for {key}"
+            ) from error
+
+    def propagator_kernel_id(
+        self,
+        current: CurrentNode,
+        propagator: Mapping[str, object],
+    ) -> int | None:
+        if not bool(propagator.get("applies_propagator", False)):
+            return None
+        key = PropagatorKernelKey(
+            int(current.index.particle_id), int(current.index.chirality)
+        )
+        try:
+            kernel_id = self._propagators[key]
+        except KeyError as error:
+            raise ValueError(
+                f"prepared model has no propagator binding for {key}"
+            ) from error
+        if kernel_id is None:
+            raise ValueError(
+                f"prepared propagator binding {key} does not provide a kernel"
+            )
+        return kernel_id
+
+    def closure_kernel(self, root: Mapping[str, object]) -> EagerResolvedKernel | None:
+        if str(root.get("kind")) == "direct-contraction":
+            return None
+        kind = root.get("vertex_kind")
+        particles = root.get("vertex_particles")
+        if kind is None or particles is None:
+            raise ValueError("prepared vertex closure lacks vertex identity")
+        left = self._dag.currents[int(root["left_current_id"])]
+        right = self._dag.currents[int(root["right_current_id"])]
+        key = ClosureKernelKey(
+            kind=int(kind),
+            particles=tuple(
+                int(value) for value in _sequence(particles, "closure.vertex_particles")
+            ),
+            left_chirality=int(left.index.chirality),
+            right_chirality=int(right.index.chirality),
+            coupling=tuple(
+                float(value)
+                for value in _sequence(root.get("coupling"), "closure.coupling")
+            ),
+        )
+        try:
+            return self._closures[key]
+        except KeyError as error:
+            raise ValueError(
+                f"prepared model has no closure binding for {key}"
+            ) from error
+
+
+@dataclass(frozen=True, slots=True)
+class EagerStageTables:
+    stage_index: int
+    subset_size: int
+    invocations: tuple[EagerInvocationRow, ...]
+    attachments: tuple[EagerAttachmentRow, ...]
+    finalizations: tuple[EagerFinalizationRow, ...]
+
+    def __post_init__(self) -> None:
+        cursor = 0
+        for invocation in self.invocations:
+            if invocation.attachment_start != cursor:
+                raise ValueError("eager attachment ranges must be contiguous")
+            cursor += invocation.attachment_count
+        if cursor != len(self.attachments):
+            raise ValueError("eager attachment ranges must cover the attachment table")
+
+
+@dataclass(frozen=True, slots=True)
+class EagerStageSelectorDomains:
+    """Domain references aligned one-for-one with one eager execution stage."""
+
+    stage_index: int
+    invocation_domains: tuple[EagerSelectorDomainIdRow, ...]
+    attachment_domains: tuple[EagerSelectorDomainIdRow, ...]
+    unpropagated_finalization_domains: tuple[EagerSelectorDomainIdRow, ...]
+    propagated_finalization_domains: tuple[EagerSelectorDomainIdRow, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class EagerSelectorClosureTables:
+    """Interned coherent-group dependency domains for selector pruning."""
+
+    domains: tuple[EagerSelectorDomainRow, ...]
+    domain_group_ids: tuple[EagerSelectorGroupRow, ...]
+    stages: tuple[EagerStageSelectorDomains, ...]
+    closure_domains: tuple[EagerSelectorDomainIdRow, ...]
+
+    def __post_init__(self) -> None:
+        cursor = 0
+        for domain_id, domain in enumerate(self.domains):
+            if domain.member_start != cursor:
+                raise ValueError(
+                    f"eager selector domain {domain_id} does not start at {cursor}"
+                )
+            stop = cursor + domain.member_count
+            if stop > len(self.domain_group_ids):
+                raise ValueError(
+                    f"eager selector domain {domain_id} exceeds its membership table"
+                )
+            previous = -1
+            for member_index in range(cursor, stop):
+                member = self.domain_group_ids[member_index].coherent_group_id
+                if member <= previous:
+                    raise ValueError(
+                        f"eager selector domain {domain_id} members must be unique "
+                        "and sorted"
+                    )
+                previous = member
+            cursor = stop
+        if cursor != len(self.domain_group_ids):
+            raise ValueError(
+                "eager selector domains do not cover their membership table"
+            )
+
+        domain_count = len(self.domains)
+        for reference in self._domain_references():
+            if reference.domain_id >= domain_count:
+                raise ValueError(
+                    f"eager selector domain ID {reference.domain_id} is out of range"
+                )
+
+    def _domain_references(self) -> Iterator[EagerSelectorDomainIdRow]:
+        yield from self.closure_domains
+        for stage in self.stages:
+            for references in (
+                stage.invocation_domains,
+                stage.attachment_domains,
+                stage.unpropagated_finalization_domains,
+                stage.propagated_finalization_domains,
+            ):
+                yield from references
+
+    def binary_payloads(self, *, prefix: str) -> dict[str, bytes]:
+        payloads = {
+            f"{prefix}/selector-domains.bin": pack_rows(self.domains),
+            f"{prefix}/selector-domain-group-ids.bin": pack_rows(self.domain_group_ids),
+            f"{prefix}/closure-domains.bin": pack_rows(self.closure_domains),
+        }
+        for stage in self.stages:
+            base = f"{prefix}/stage-{stage.stage_index}"
+            payloads[f"{base}-invocation-domains.bin"] = pack_rows(
+                stage.invocation_domains
+            )
+            payloads[f"{base}-attachment-domains.bin"] = pack_rows(
+                stage.attachment_domains
+            )
+            payloads[f"{base}-unpropagated-finalization-domains.bin"] = pack_rows(
+                stage.unpropagated_finalization_domains
+            )
+            payloads[f"{base}-propagated-finalization-domains.bin"] = pack_rows(
+                stage.propagated_finalization_domains
+            )
+        return payloads
+
+    def to_metadata(self, *, prefix: str) -> dict[str, object]:
+        def table(path: str, count: int, row_size: int) -> dict[str, object]:
+            return {"path": path, "count": count, "row_size": row_size}
+
+        return {
+            "abi": EAGER_SELECTOR_DOMAINS_ABI,
+            "domains": table(
+                f"{prefix}/selector-domains.bin",
+                len(self.domains),
+                EagerSelectorDomainRow._STRUCT.size,
+            ),
+            "domain_group_ids": table(
+                f"{prefix}/selector-domain-group-ids.bin",
+                len(self.domain_group_ids),
+                EagerSelectorGroupRow._STRUCT.size,
+            ),
+            "stages": [
+                {
+                    "stage_index": stage.stage_index,
+                    "invocation_domains": table(
+                        f"{prefix}/stage-{stage.stage_index}-invocation-domains.bin",
+                        len(stage.invocation_domains),
+                        EagerSelectorDomainIdRow._STRUCT.size,
+                    ),
+                    "attachment_domains": table(
+                        f"{prefix}/stage-{stage.stage_index}-attachment-domains.bin",
+                        len(stage.attachment_domains),
+                        EagerSelectorDomainIdRow._STRUCT.size,
+                    ),
+                    "unpropagated_finalization_domains": table(
+                        f"{prefix}/stage-{stage.stage_index}"
+                        "-unpropagated-finalization-domains.bin",
+                        len(stage.unpropagated_finalization_domains),
+                        EagerSelectorDomainIdRow._STRUCT.size,
+                    ),
+                    "propagated_finalization_domains": table(
+                        f"{prefix}/stage-{stage.stage_index}"
+                        "-propagated-finalization-domains.bin",
+                        len(stage.propagated_finalization_domains),
+                        EagerSelectorDomainIdRow._STRUCT.size,
+                    ),
+                }
+                for stage in self.stages
+            ],
+            "closure_domains": table(
+                f"{prefix}/closure-domains.bin",
+                len(self.closure_domains),
+                EagerSelectorDomainIdRow._STRUCT.size,
+            ),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class EagerExecutionTables:
+    process_key: str
+    couplings: tuple[EagerCouplingRow, ...]
+    stages: tuple[EagerStageTables, ...]
+    closures: tuple[EagerClosureRow, ...]
+    selector_closures: EagerSelectorClosureTables | None = None
+
+    def __post_init__(self) -> None:
+        selector_closures = self.selector_closures
+        if selector_closures is None:
+            return
+        if len(selector_closures.stages) != len(self.stages):
+            raise ValueError("eager selector domains do not cover every stage")
+        for stage, domains in zip(
+            self.stages,
+            selector_closures.stages,
+            strict=True,
+        ):
+            if domains.stage_index != stage.stage_index:
+                raise ValueError("eager selector-domain stage index mismatch")
+            expected_counts = (
+                len(stage.invocations),
+                len(stage.attachments),
+                len(stage.finalizations),
+                len(stage.finalizations),
+            )
+            actual_counts = (
+                len(domains.invocation_domains),
+                len(domains.attachment_domains),
+                len(domains.unpropagated_finalization_domains),
+                len(domains.propagated_finalization_domains),
+            )
+            if actual_counts != expected_counts:
+                raise ValueError(
+                    f"eager selector-domain row counts do not match stage "
+                    f"{stage.stage_index}"
+                )
+        if len(selector_closures.closure_domains) != len(self.closures):
+            raise ValueError("eager selector domains do not cover every closure")
+
+    @property
+    def invocation_count(self) -> int:
+        return sum(len(stage.invocations) for stage in self.stages)
+
+    @property
+    def attachment_count(self) -> int:
+        return sum(len(stage.attachments) for stage in self.stages)
+
+    @property
+    def referenced_kernel_ids(self) -> frozenset[int]:
+        return frozenset(
+            {
+                *(row.kernel_id for stage in self.stages for row in stage.invocations),
+                *(
+                    row.kernel_id
+                    for stage in self.stages
+                    for row in stage.finalizations
+                    if row.kernel_id != MISSING_U32
+                ),
+                *(
+                    row.kernel_id
+                    for row in self.closures
+                    if row.kernel_id != MISSING_U32
+                ),
+            }
+        )
+
+    def binary_payloads(self, *, prefix: str = "eager") -> dict[str, bytes]:
+        payloads = {f"{prefix}/couplings.bin": pack_rows(self.couplings)}
+        for stage in self.stages:
+            base = f"{prefix}/stage-{stage.stage_index}"
+            payloads[f"{base}-invocations.bin"] = pack_rows(stage.invocations)
+            payloads[f"{base}-attachments.bin"] = pack_rows(stage.attachments)
+            payloads[f"{base}-finalizations.bin"] = pack_rows(stage.finalizations)
+        payloads[f"{prefix}/closures.bin"] = pack_rows(self.closures)
+        if self.selector_closures is not None:
+            payloads.update(self.selector_closures.binary_payloads(prefix=prefix))
+        return payloads
+
+    def to_metadata(self, *, prefix: str = "eager") -> dict[str, object]:
+        metadata: dict[str, object] = {
+            "kind": EAGER_RUNTIME_KIND,
+            "eager_plan_abi": EAGER_PLAN_ABI,
+            "required_runtime_capabilities": [EAGER_RUNTIME_CAPABILITY],
+            "process_key": self.process_key,
+            "couplings": {
+                "path": f"{prefix}/couplings.bin",
+                "count": len(self.couplings),
+                "row_size": EagerCouplingRow._STRUCT.size,
+            },
+            "stages": [
+                {
+                    "stage_index": stage.stage_index,
+                    "subset_size": stage.subset_size,
+                    "invocations": {
+                        "path": (f"{prefix}/stage-{stage.stage_index}-invocations.bin"),
+                        "count": len(stage.invocations),
+                        "row_size": EagerInvocationRow._STRUCT.size,
+                    },
+                    "attachments": {
+                        "path": (f"{prefix}/stage-{stage.stage_index}-attachments.bin"),
+                        "count": len(stage.attachments),
+                        "row_size": EagerAttachmentRow._STRUCT.size,
+                    },
+                    "finalizations": {
+                        "path": (
+                            f"{prefix}/stage-{stage.stage_index}-finalizations.bin"
+                        ),
+                        "count": len(stage.finalizations),
+                        "row_size": EagerFinalizationRow._STRUCT.size,
+                    },
+                }
+                for stage in self.stages
+            ],
+            "closures": {
+                "path": f"{prefix}/closures.bin",
+                "count": len(self.closures),
+                "row_size": EagerClosureRow._STRUCT.size,
+            },
+        }
+        if self.selector_closures is not None:
+            metadata["selector_closures"] = self.selector_closures.to_metadata(
+                prefix=prefix
+            )
+        return metadata
+
+
+class _CouplingCatalog:
+    def __init__(self, model_parameters: Sequence[Mapping[str, object]]) -> None:
+        self.rows: list[EagerCouplingRow] = []
+        self._row_ids: dict[EagerCouplingRow, int] = {}
+        self._input_ids: dict[
+            tuple[tuple[float, float], tuple[str | None, ...]],
+            int,
+        ] = {}
+        self._direct = {
+            str(record["name"]): int(record["parameter_index"])
+            for record in model_parameters
+        }
+        logical: dict[str, dict[str, int]] = {}
+        for record in model_parameters:
+            runtime_name = record.get("runtime_name")
+            component = record.get("complex_component")
+            if isinstance(runtime_name, str) and component in {"real", "imag"}:
+                logical.setdefault(runtime_name, {})[str(component)] = int(
+                    record["parameter_index"]
+                )
+        self._logical = logical
+
+    def add(
+        self,
+        coupling: Sequence[object],
+        parameter_names: Sequence[object] | None,
+    ) -> int:
+        if len(coupling) != 2:
+            raise ValueError("eager coupling metadata must contain two components")
+        constants = (float(coupling[0]), float(coupling[1]))
+        names = tuple(
+            name if isinstance(name, str) else None for name in (parameter_names or ())
+        )
+        input_key = (constants, names)
+        existing = self._input_ids.get(input_key)
+        if existing is not None:
+            return existing
+        real_parameter = MISSING_U32
+        imag_parameter = MISSING_U32
+
+        first_name = names[0] if names else None
+        if isinstance(first_name, str) and first_name in self._logical:
+            components = self._logical[first_name]
+            if set(components) != {"real", "imag"}:
+                raise ValueError(
+                    f"logical coupling {first_name!r} lacks real/imaginary slots"
+                )
+            real_parameter = components["real"]
+            imag_parameter = components["imag"]
+        else:
+            for component, name in enumerate(names[:2]):
+                if not isinstance(name, str):
+                    continue
+                parameter_id = self._direct.get(name)
+                if parameter_id is None:
+                    continue
+                if component == 0:
+                    real_parameter = parameter_id
+                else:
+                    imag_parameter = parameter_id
+
+        row = EagerCouplingRow._from_trusted_values(
+            real_parameter,
+            imag_parameter,
+            constants[0],
+            constants[1],
+        )
+        existing = self._row_ids.get(row)
+        if existing is not None:
+            self._input_ids[input_key] = existing
+            return existing
+        row_id = len(self.rows)
+        self.rows.append(row)
+        self._row_ids[row] = row_id
+        self._input_ids[input_key] = row_id
+        return row_id
+
+
+@dataclass(frozen=True, slots=True)
+class _EagerStageLoweringInput:
+    record: Mapping[str, object]
+    evaluation_groups: Sequence[Sequence[InteractionNode]]
+    input_value_slot_by_current: Mapping[int, int]
+    output_current_ids: Sequence[int]
+
+
+@dataclass(frozen=True, slots=True)
+class _EagerLoweringInput:
+    process_key: str
+    value_slots: Mapping[int, Mapping[str, object]] | Sequence[Mapping[str, object]]
+    value_slots_by_current_variant: Mapping[tuple[int, str], int]
+    momentum_slot_by_mask: Mapping[int, int]
+    model_parameters: Sequence[Mapping[str, object]]
+    stages: Sequence[_EagerStageLoweringInput]
+    amplitude_stage: Mapping[str, object]
+
+
+def lower_fused_eager_execution(
+    *,
+    dag: GenericDAG,
+    model: Model,
+    resolver: EagerKernelResolver,
+    process_id: str | None = None,
+    progress_callback: EagerProgressCallback | None = None,
+) -> tuple[dict[str, object], EagerExecutionTables]:
+    """Assemble runtime metadata and eager tables from one owned layout."""
+
+    if progress_callback is not None:
+        progress_callback({"step": "runtime-layout"})
+    layout = build_runtime_schema_layout(
+        dag,
+        model,
+        process_id=process_id,
+    )
+    tables = _lower_eager_execution_tables(
+        dag,
+        model,
+        resolver,
+        _lowering_input_from_layout(layout),
+        progress_callback=progress_callback,
+    )
+    return layout.runtime_schema, tables
+
+
+def lower_eager_execution_tables(
+    dag: GenericDAG,
+    model: Model,
+    runtime_schema: Mapping[str, object],
+    resolver: EagerKernelResolver,
+    progress_callback: EagerProgressCallback | None = None,
+) -> EagerExecutionTables:
+    """Lower a proven DAG without constructing any backend evaluator."""
+
+    return _lower_eager_execution_tables(
+        dag,
+        model,
+        resolver,
+        _lowering_input_from_schema(dag, runtime_schema),
+        progress_callback=progress_callback,
+    )
+
+
+def _lowering_input_from_schema(
+    dag: GenericDAG,
+    runtime_schema: Mapping[str, object],
+) -> _EagerLoweringInput:
+    value_slots = {
+        int(slot["value_slot_id"]): slot
+        for slot in _mapping_sequence(
+            _mapping(runtime_schema.get("value_storage"), "value_storage").get(
+                "value_slots"
+            ),
+            "value_storage.value_slots",
+        )
+    }
+    value_slots_by_current_variant = {
+        (int(slot["current_id"]), str(slot["variant"])): int(slot_id)
+        for slot_id, slot in value_slots.items()
+    }
+    momentum_slot_by_mask = {
+        int(slot["momentum_mask"]): int(slot["momentum_slot_id"])
+        for slot in _mapping_sequence(
+            runtime_schema.get("momentum_slots"),
+            "momentum_slots",
+        )
+    }
+    model_parameters = _mapping_sequence(
+        runtime_schema.get("model_parameters"),
+        "model_parameters",
+    )
+    stages: list[_EagerStageLoweringInput] = []
+    for stage_record in _mapping_sequence(runtime_schema.get("stages"), "stages"):
+        interactions = tuple(
+            dag.interactions[int(value)]
+            for value in _sequence(
+                stage_record.get("interaction_ids"),
+                "interaction_ids",
+            )
+        )
+        groups: dict[tuple[str, int], list[InteractionNode]] = {}
+        for interaction in interactions:
+            group_key = (
+                ("group", int(interaction.evaluation_group_id))
+                if interaction.evaluation_group_id is not None
+                else ("interaction", interaction.id)
+            )
+            groups.setdefault(group_key, []).append(interaction)
+        input_value_slot_by_current = {
+            int(value_slots[slot_id]["current_id"]): slot_id
+            for slot_id in (
+                int(value)
+                for value in _sequence(
+                    stage_record.get("input_value_slot_ids"),
+                    "input_value_slot_ids",
+                )
+            )
+        }
+        stages.append(
+            _EagerStageLoweringInput(
+                record=stage_record,
+                evaluation_groups=tuple(tuple(group) for group in groups.values()),
+                input_value_slot_by_current=input_value_slot_by_current,
+                output_current_ids=tuple(
+                    int(value)
+                    for value in _sequence(
+                        stage_record.get("output_current_ids"),
+                        "output_current_ids",
+                    )
+                ),
+            )
+        )
+    return _EagerLoweringInput(
+        process_key=str(runtime_schema.get("process_key", dag.process.key)),
+        value_slots=value_slots,
+        value_slots_by_current_variant=value_slots_by_current_variant,
+        momentum_slot_by_mask=momentum_slot_by_mask,
+        model_parameters=model_parameters,
+        stages=tuple(stages),
+        amplitude_stage=_mapping(
+            runtime_schema.get("amplitude_stage"),
+            "amplitude_stage",
+        ),
+    )
+
+
+def _lowering_input_from_layout(
+    layout: RuntimeSchemaLayout,
+) -> _EagerLoweringInput:
+    stages = tuple(
+        _EagerStageLoweringInput(
+            record=stage.record,
+            evaluation_groups=stage.evaluation_groups,
+            input_value_slot_by_current=stage.input_value_slot_by_current,
+            output_current_ids=stage.output_current_ids,
+        )
+        for stage in layout.stages
+    )
+    return _EagerLoweringInput(
+        process_key=str(layout.runtime_schema["process_key"]),
+        value_slots=layout.value_slots_by_id,
+        value_slots_by_current_variant=layout.value_slot_ids_by_current_variant,
+        momentum_slot_by_mask=layout.momentum_slot_by_mask,
+        model_parameters=layout.model_parameters,
+        stages=stages,
+        amplitude_stage=layout.amplitude_stage,
+    )
+
+
+def _lower_eager_execution_tables(
+    dag: GenericDAG,
+    model: Model,
+    resolver: EagerKernelResolver,
+    lowering: _EagerLoweringInput,
+    *,
+    progress_callback: EagerProgressCallback | None = None,
+) -> EagerExecutionTables:
+    value_slots = lowering.value_slots
+    value_slots_by_current_variant = lowering.value_slots_by_current_variant
+    momentum_slot_by_mask = lowering.momentum_slot_by_mask
+    coupling_catalog = _CouplingCatalog(lowering.model_parameters)
+    coupling_parameter_names: dict[
+        tuple[int, tuple[int, ...], tuple[float, ...]],
+        tuple[str | None, ...],
+    ] = {}
+    resolved_vertex_kernels: dict[
+        tuple[
+            int,
+            tuple[int, int, int],
+            int,
+            int,
+            int,
+            tuple[float, float],
+        ],
+        EagerResolvedKernel,
+    ] = {}
+    propagator_kernel_ids: dict[tuple[int, int], int | None] = {}
+
+    def parameter_names_for(interaction: InteractionNode) -> tuple[str | None, ...]:
+        coupling_key = (
+            interaction.vertex_kind,
+            tuple(interaction.vertex_particles),
+            tuple(interaction.coupling),
+        )
+        parameter_names = coupling_parameter_names.get(coupling_key)
+        if parameter_names is None:
+            parameter_names = tuple(
+                runtime_coupling_parameter_names(
+                    interaction.vertex_kind,
+                    interaction.vertex_particles,
+                    interaction.coupling,
+                    model=model,
+                )
+            )
+            coupling_parameter_names[coupling_key] = parameter_names
+        return parameter_names
+
+    def kernel_for(interaction: InteractionNode) -> EagerResolvedKernel:
+        left = dag.currents[interaction.left_id]
+        right = dag.currents[interaction.right_id]
+        result = dag.currents[interaction.result_id]
+        key = (
+            int(interaction.vertex_kind),
+            interaction.vertex_particles,
+            int(left.index.chirality),
+            int(right.index.chirality),
+            int(result.index.chirality),
+            interaction.coupling,
+        )
+        resolved = resolved_vertex_kernels.get(key)
+        if resolved is None:
+            resolved = resolver.vertex_kernel(interaction)
+            resolved_vertex_kernels[key] = resolved
+        return resolved
+
+    stages: list[EagerStageTables] = []
+
+    stage_total = len(lowering.stages)
+    for stage_position, stage_input in enumerate(lowering.stages, start=1):
+        stage_record = stage_input.record
+        stage_index = int(stage_record["stage_index"])
+        subset_size = int(stage_record["subset_size"])
+        input_slot_by_current = stage_input.input_value_slot_by_current
+
+        invocations: list[EagerInvocationRow] = []
+        attachments: list[EagerAttachmentRow] = []
+        for interactions in stage_input.evaluation_groups:
+            live_interactions = tuple(
+                interaction
+                for interaction in interactions
+                if complex(*interaction.evaluation_factor) != 0j
+            )
+            if not live_interactions:
+                continue
+            representative = live_interactions[0]
+            resolved_kernel = kernel_for(representative)
+            representative_factor = complex(*representative.evaluation_factor)
+            parameter_names = parameter_names_for(representative)
+            coupling_slot_id = coupling_catalog.add(
+                representative.coupling,
+                parameter_names,
+            )
+            attachment_start = len(attachments)
+            group_factor = (
+                complex(*resolved_kernel.normalization_factor)
+                / representative_factor
+            )
+            for interaction in live_interactions:
+                # The compiler's evaluation-group key already proves identical
+                # kernel, coupling, and mutable-parameter provenance. Repeating
+                # those resolver lookups for every fan-out attachment is pure
+                # lowering overhead.
+                factor = (
+                    complex(*interaction.color_weight)
+                    * complex(*interaction.evaluation_factor)
+                    * group_factor
+                )
+                attachments.append(
+                    EagerAttachmentRow._from_trusted_values(
+                        interaction.result_id,
+                        factor.real,
+                        factor.imag,
+                    )
+                )
+            left = dag.currents[representative.left_id]
+            right = dag.currents[representative.right_id]
+            input_currents = (left, right)
+            ordered_currents = tuple(
+                input_currents[index] for index in resolved_kernel.canonical_input_order
+            )
+            invocations.append(
+                EagerInvocationRow._from_trusted_values(
+                    resolved_kernel.kernel_id,
+                    input_slot_by_current[ordered_currents[0].id],
+                    input_slot_by_current[ordered_currents[1].id],
+                    momentum_slot_by_mask[ordered_currents[0].index.momentum_mask],
+                    momentum_slot_by_mask[ordered_currents[1].index.momentum_mask],
+                    coupling_slot_id,
+                    resolved_kernel.output_factor_source,
+                    attachment_start,
+                    len(live_interactions),
+                )
+            )
+
+        finalizations = tuple(
+            _finalization_row(
+                dag.currents[int(current_id)],
+                value_slots,
+                value_slots_by_current_variant,
+                momentum_slot_by_mask,
+                resolver,
+                propagator_kernel_ids,
+            )
+            for current_id in stage_input.output_current_ids
+        )
+        stages.append(
+            EagerStageTables(
+                stage_index=stage_index,
+                subset_size=subset_size,
+                invocations=tuple(invocations),
+                attachments=tuple(attachments),
+                finalizations=finalizations,
+            )
+        )
+        if progress_callback is not None:
+            progress_callback(
+                {
+                    "step": "invocation lowering",
+                    "stage_index": stage_position,
+                    "stage_total": stage_total,
+                    "subset_size": subset_size,
+                    "invocation_count": len(invocations),
+                    "attachment_count": len(attachments),
+                    "finalization_count": len(finalizations),
+                }
+            )
+
+    amplitude_stage = lowering.amplitude_stage
+    if progress_callback is not None:
+        progress_callback(
+            {
+                "step": "amplitude closures",
+                "stage_index": stage_total,
+                "stage_total": stage_total,
+            }
+        )
+    closures: list[EagerClosureRow] = []
+    for root in _mapping_sequence(
+        amplitude_stage.get("roots"), "amplitude_stage.roots"
+    ):
+        closure_kernel = resolver.closure_kernel(root)
+        coupling_slot_id = MISSING_U32
+        if closure_kernel is not None:
+            coupling_slot_id = coupling_catalog.add(
+                _sequence(root.get("coupling"), "root.coupling"),
+                _optional_sequence(root.get("coupling_parameter_names")),
+            )
+        color_weight = _complex_pair(root.get("color_weight"), "root.color_weight")
+        left_slot_id = int(
+            _mapping(root.get("left_value_slot"), "left_value_slot")["value_slot_id"]
+        )
+        right_slot_id = int(
+            _mapping(root.get("right_value_slot"), "right_value_slot")["value_slot_id"]
+        )
+        if closure_kernel is not None:
+            slots = (left_slot_id, right_slot_id)
+            left_slot_id, right_slot_id = (
+                slots[index] for index in closure_kernel.canonical_input_order
+            )
+            color_weight *= complex(*closure_kernel.normalization_factor)
+        closures.append(
+            EagerClosureRow._from_trusted_values(
+                MISSING_U32 if closure_kernel is None else closure_kernel.kernel_id,
+                left_slot_id,
+                right_slot_id,
+                int(root["output_index"]),
+                coupling_slot_id,
+                (
+                    EAGER_OUTPUT_FACTOR_NONE
+                    if closure_kernel is None
+                    else closure_kernel.output_factor_source
+                ),
+                color_weight.real,
+                color_weight.imag,
+            )
+        )
+
+    stage_tables = tuple(stages)
+    closure_rows = tuple(closures)
+    if progress_callback is not None:
+        progress_callback(
+            {
+                "step": "selector closures",
+                "stage_index": stage_total,
+                "stage_total": stage_total,
+                "closure_count": len(closure_rows),
+            }
+        )
+    selector_closures = _build_selector_closure_tables(
+        stage_tables,
+        closure_rows,
+        amplitude_stage,
+        value_slot_count=len(value_slots),
+        current_count=len(dag.currents),
+    )
+    if progress_callback is not None:
+        progress_callback(
+            {
+                "step": "eager plan ready",
+                "stage_index": stage_total,
+                "stage_total": stage_total,
+                "closure_count": len(closure_rows),
+            }
+        )
+    return EagerExecutionTables(
+        process_key=lowering.process_key,
+        couplings=tuple(coupling_catalog.rows),
+        stages=stage_tables,
+        closures=closure_rows,
+        selector_closures=selector_closures,
+    )
+
+
+def _build_selector_closure_tables(
+    stages: tuple[EagerStageTables, ...],
+    closures: tuple[EagerClosureRow, ...],
+    amplitude_stage: Mapping[str, object],
+    *,
+    value_slot_count: int,
+    current_count: int,
+) -> EagerSelectorClosureTables:
+    """Propagate coherent-group dependencies backwards through eager rows."""
+
+    roots = _mapping_sequence(amplitude_stage.get("roots"), "amplitude_stage.roots")
+    if len(roots) != len(closures):
+        raise ValueError("eager closures do not match runtime amplitude roots")
+
+    declared_groups = tuple(
+        int(group["group_id"])
+        for group in _mapping_sequence(
+            amplitude_stage.get("coherent_groups"),
+            "amplitude_stage.coherent_groups",
+        )
+    )
+    if len(declared_groups) != len(set(declared_groups)) or any(
+        group_id < 0 or group_id > MISSING_U32 for group_id in declared_groups
+    ):
+        raise ValueError("runtime coherent-group IDs must be unique unsigned integers")
+    ordered_group_ids = tuple(sorted(declared_groups))
+    group_bit_indices = {
+        group_id: bit_index for bit_index, group_id in enumerate(ordered_group_ids)
+    }
+
+    dense_mask_interning = (
+        len(ordered_group_ids) <= _DENSE_SELECTOR_DOMAIN_GROUP_LIMIT
+    )
+    domain_masks: list[int] = []
+    domain_ids_by_mask: dict[int, int] = {}
+    domain_members: list[tuple[int, ...]] = []
+    domain_ids_by_members: dict[tuple[int, ...], int] = {}
+
+    def intern_members(members: tuple[int, ...]) -> int:
+        existing = domain_ids_by_members.get(members)
+        if existing is not None:
+            return existing
+        domain_id = len(domain_members)
+        domain_members.append(members)
+        domain_ids_by_members[members] = domain_id
+        return domain_id
+
+    def members(domain: int) -> tuple[int, ...]:
+        result: list[int] = []
+        remaining = domain
+        while remaining:
+            lowest = remaining & -remaining
+            result.append(ordered_group_ids[lowest.bit_length() - 1])
+            remaining ^= lowest
+        return tuple(result)
+
+    def intern_mask(domain: int) -> int:
+        existing = domain_ids_by_mask.get(domain)
+        if existing is not None:
+            return existing
+        domain_id = len(domain_masks)
+        domain_masks.append(domain)
+        domain_ids_by_mask[domain] = domain_id
+        return domain_id
+
+    def intern_stage_mask(
+        domain: int,
+        stage_domain_ids_by_mask: dict[int, int],
+    ) -> int:
+        if dense_mask_interning:
+            return intern_mask(domain)
+        existing = stage_domain_ids_by_mask.get(domain)
+        if existing is not None:
+            return existing
+        domain_id = intern_members(members(domain))
+        stage_domain_ids_by_mask[domain] = domain_id
+        return domain_id
+
+    value_domains = [0] * value_slot_count
+    empty_domain_id = intern_mask(0) if dense_mask_interning else intern_members(())
+    closure_domain_ids: list[int] = []
+    for closure, root in zip(closures, roots, strict=True):
+        if closure.amplitude_index != int(root["output_index"]):
+            raise ValueError(
+                "eager closure order does not match runtime amplitude roots"
+            )
+        group_id = int(root["coherent_group_id"])
+        bit_index = group_bit_indices.get(group_id)
+        if bit_index is None:
+            raise ValueError(
+                f"amplitude root references undeclared coherent group {group_id}"
+            )
+        domain = 1 << bit_index
+        closure_domain_ids.append(
+            intern_mask(domain)
+            if dense_mask_interning
+            else intern_members((group_id,))
+        )
+        value_domains[closure.left_value_slot_id] |= domain
+        value_domains[closure.right_value_slot_id] |= domain
+
+    stage_domain_ids_reversed: list[
+        tuple[
+            tuple[int, ...],
+            tuple[int, ...],
+            tuple[int, ...],
+            tuple[int, ...],
+        ],
+    ] = []
+    current_domains = [0] * current_count
+    current_domain_ids = [empty_domain_id] * current_count
+
+    for stage in reversed(stages):
+        stage_domain_ids_by_mask = {0: empty_domain_id}
+
+        unpropagated_domain_ids: list[int] = []
+        propagated_domain_ids: list[int] = []
+        for finalization in stage.finalizations:
+            unpropagated = (
+                value_domains[finalization.unpropagated_value_slot_id]
+                if finalization.stores_unpropagated
+                else 0
+            )
+            propagated = (
+                value_domains[finalization.propagated_value_slot_id]
+                if finalization.stores_propagated
+                else 0
+            )
+            unpropagated_domain_ids.append(
+                intern_stage_mask(unpropagated, stage_domain_ids_by_mask)
+            )
+            propagated_domain_ids.append(
+                intern_stage_mask(propagated, stage_domain_ids_by_mask)
+            )
+            current_domain = unpropagated | propagated
+            current_domains[finalization.current_id] = current_domain
+            current_domain_ids[finalization.current_id] = intern_stage_mask(
+                current_domain,
+                stage_domain_ids_by_mask,
+            )
+            if finalization.stores_unpropagated:
+                value_domains[finalization.unpropagated_value_slot_id] = 0
+            if finalization.stores_propagated:
+                value_domains[finalization.propagated_value_slot_id] = 0
+
+        attachment_domain_ids = [
+            current_domain_ids[attachment.result_current_id]
+            for attachment in stage.attachments
+        ]
+
+        invocation_domain_ids: list[int] = []
+        for invocation in stage.invocations:
+            start = invocation.attachment_start
+            stop = start + invocation.attachment_count
+            domain = 0
+            for attachment_index in range(start, stop):
+                result_current_id = stage.attachments[
+                    attachment_index
+                ].result_current_id
+                domain |= current_domains[result_current_id]
+            invocation_domain_ids.append(
+                intern_stage_mask(domain, stage_domain_ids_by_mask)
+            )
+            value_domains[invocation.left_value_slot_id] |= domain
+            value_domains[invocation.right_value_slot_id] |= domain
+
+        stage_domain_ids_reversed.append(
+            (
+                tuple(invocation_domain_ids),
+                tuple(attachment_domain_ids),
+                tuple(unpropagated_domain_ids),
+                tuple(propagated_domain_ids),
+            )
+        )
+        for finalization in stage.finalizations:
+            current_domains[finalization.current_id] = 0
+            current_domain_ids[finalization.current_id] = empty_domain_id
+        stage_domain_ids_by_mask.clear()
+
+    # Construction-only masks and interning indexes do not participate in final
+    # ID assignment or emission.
+    value_domains.clear()
+    current_domains.clear()
+    current_domain_ids.clear()
+    group_bit_indices.clear()
+
+    # Match the prior dense-mask ordering exactly. For equal-cardinality masks,
+    # integer comparison examines the highest differing bit first, equivalent
+    # to lexicographically comparing the reversed, sorted member tuples.
+    if dense_mask_interning:
+        ordered_provisional_ids = tuple(
+            sorted(
+                range(len(domain_masks)),
+                key=lambda domain_id: (
+                    domain_masks[domain_id].bit_count(),
+                    domain_masks[domain_id],
+                ),
+            )
+        )
+    else:
+        ordered_provisional_ids = tuple(
+            sorted(
+                range(len(domain_members)),
+                key=lambda domain_id: (
+                    len(domain_members[domain_id]),
+                    tuple(reversed(domain_members[domain_id])),
+                ),
+            )
+        )
+    final_domain_ids = [0] * len(ordered_provisional_ids)
+    for final_domain_id, provisional_domain_id in enumerate(ordered_provisional_ids):
+        final_domain_ids[provisional_domain_id] = final_domain_id
+
+    domain_rows: list[EagerSelectorDomainRow] = []
+    group_rows: list[EagerSelectorGroupRow] = []
+    group_rows_by_bit_index = tuple(
+        EagerSelectorGroupRow._from_trusted_values(group_id)
+        for group_id in ordered_group_ids
+    )
+    group_row_by_id = (
+        {}
+        if dense_mask_interning
+        else {
+            group_id: group_rows_by_bit_index[bit_index]
+            for bit_index, group_id in enumerate(ordered_group_ids)
+        }
+    )
+    for provisional_domain_id in ordered_provisional_ids:
+        if dense_mask_interning:
+            domain = domain_masks[provisional_domain_id]
+            member_count = domain.bit_count()
+        else:
+            resolved_members = domain_members[provisional_domain_id]
+            member_count = len(resolved_members)
+        domain_rows.append(
+            EagerSelectorDomainRow._from_trusted_values(
+                len(group_rows), member_count
+            )
+        )
+        if dense_mask_interning:
+            while domain:
+                lowest = domain & -domain
+                group_rows.append(
+                    group_rows_by_bit_index[lowest.bit_length() - 1]
+                )
+                domain ^= lowest
+        else:
+            group_rows.extend(
+                group_row_by_id[group_id] for group_id in resolved_members
+            )
+
+    domain_count = len(ordered_provisional_ids)
+    domain_masks.clear()
+    domain_ids_by_mask.clear()
+    domain_members.clear()
+    domain_ids_by_members.clear()
+    group_row_by_id.clear()
+    domain_reference_rows = tuple(
+        EagerSelectorDomainIdRow._from_trusted_values(domain_id)
+        for domain_id in range(domain_count)
+    )
+
+    def references(
+        provisional_domain_ids: Sequence[int],
+    ) -> tuple[EagerSelectorDomainIdRow, ...]:
+        return tuple(
+            domain_reference_rows[final_domain_ids[provisional_domain_id]]
+            for provisional_domain_id in provisional_domain_ids
+        )
+
+    selector_stages = []
+    for stage, domain_ids in zip(
+        stages,
+        reversed(stage_domain_ids_reversed),
+        strict=True,
+    ):
+        (
+            stage_invocation_domain_ids,
+            stage_attachment_domain_ids,
+            stage_unpropagated_domain_ids,
+            stage_propagated_domain_ids,
+        ) = domain_ids
+        selector_stages.append(
+            EagerStageSelectorDomains(
+                stage_index=stage.stage_index,
+                invocation_domains=references(stage_invocation_domain_ids),
+                attachment_domains=references(stage_attachment_domain_ids),
+                unpropagated_finalization_domains=references(
+                    stage_unpropagated_domain_ids
+                ),
+                propagated_finalization_domains=references(stage_propagated_domain_ids),
+            )
+        )
+
+    return EagerSelectorClosureTables(
+        domains=tuple(domain_rows),
+        domain_group_ids=tuple(group_rows),
+        stages=tuple(selector_stages),
+        closure_domains=references(closure_domain_ids),
+    )
+
+
+def _finalization_row(
+    current: CurrentNode,
+    value_slots: Mapping[int, Mapping[str, object]] | Sequence[Mapping[str, object]],
+    value_slots_by_current_variant: Mapping[tuple[int, str], int],
+    momentum_slot_by_mask: Mapping[int, int],
+    resolver: EagerKernelResolver,
+    propagator_kernel_ids: dict[tuple[int, int], int | None],
+) -> EagerFinalizationRow:
+    unpropagated = value_slots_by_current_variant.get(
+        (current.id, "unpropagated"),
+        MISSING_U32,
+    )
+    propagated = value_slots_by_current_variant.get(
+        (current.id, "propagated"),
+        MISSING_U32,
+    )
+    if unpropagated == MISSING_U32 and propagated == MISSING_U32:
+        raise ValueError(f"eager current {current.id} has no output value slot")
+    propagator_slot_id = propagated if propagated != MISSING_U32 else unpropagated
+    output_slot = value_slots[propagator_slot_id]
+    propagator = _mapping(
+        output_slot.get("propagator"),
+        f"current {current.id} propagator",
+    )
+    propagator_key = (current.index.particle_id, current.index.chirality)
+    if not bool(output_slot.get("applies_propagator", False)):
+        kernel_id = None
+    elif propagator_key in propagator_kernel_ids:
+        kernel_id = propagator_kernel_ids[propagator_key]
+    else:
+        kernel_id = resolver.propagator_kernel_id(current, propagator)
+        propagator_kernel_ids[propagator_key] = kernel_id
+    if propagated != MISSING_U32 and kernel_id is None:
+        raise ValueError(
+            f"eager propagated current {current.id} has no prepared propagator kernel"
+        )
+    return EagerFinalizationRow._from_trusted_values(
+        MISSING_U32 if kernel_id is None else kernel_id,
+        current.id,
+        unpropagated,
+        propagated,
+        momentum_slot_by_mask[current.index.momentum_mask],
+    )
+
+
+def _mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise TypeError(f"{context} must be a mapping")
+    return value
+
+
+def _sequence(value: object, context: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise TypeError(f"{context} must be a sequence")
+    return value
+
+
+def _optional_sequence(value: object) -> Sequence[object] | None:
+    if value is None:
+        return None
+    return _sequence(value, "optional sequence")
+
+
+def _mapping_sequence(value: object, context: str) -> tuple[Mapping[str, object], ...]:
+    return tuple(
+        _mapping(item, f"{context}[{index}]")
+        for index, item in enumerate(_sequence(value, context))
+    )
+
+
+def _complex_pair(value: object, context: str) -> complex:
+    components = _sequence(value, context)
+    if len(components) != 2:
+        raise ValueError(f"{context} must contain two components")
+    return complex(float(components[0]), float(components[1]))
+
+
+def _resolved_kernel(
+    record: Mapping[str, object],
+    context: str,
+) -> EagerResolvedKernel:
+    order = tuple(
+        int(value)
+        for value in _sequence(
+            record.get("canonical_input_order"),
+            f"{context}.canonical_input_order",
+        )
+    )
+    factor = tuple(
+        float(value)
+        for value in _sequence(
+            record.get("equivalence_factor"),
+            f"{context}.equivalence_factor",
+        )
+    )
+    if len(order) != 2 or len(factor) != 2:
+        raise ValueError(f"{context} has malformed input transformation metadata")
+    factor_source = {
+        "none": EAGER_OUTPUT_FACTOR_NONE,
+        "coupling-real": EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+        "coupling-imag": EAGER_OUTPUT_FACTOR_COUPLING_IMAG,
+    }.get(str(record.get("output_factor_source", "none")))
+    if factor_source is None:
+        raise ValueError(f"{context} has an unsupported output factor source")
+    return EagerResolvedKernel(
+        kernel_id=int(record["kernel_id"]),
+        canonical_input_order=(order[0], order[1]),
+        normalization_factor=(factor[0], factor[1]),
+        output_factor_source=factor_source,
+    )
+
+
+def _vertex_kernel_key(record: Mapping[str, object]) -> VertexKernelKey:
+    particles = tuple(
+        int(value) for value in _sequence(record.get("particles"), "vertex.particles")
+    )
+    coupling = tuple(
+        float(value) for value in _sequence(record.get("coupling"), "vertex.coupling")
+    )
+    if len(particles) != 3 or len(coupling) != 2:
+        raise ValueError("prepared vertex key has malformed particles or coupling")
+    return VertexKernelKey(
+        kind=int(record["kind"]),
+        particles=(particles[0], particles[1], particles[2]),
+        left_chirality=int(record["left_chirality"]),
+        right_chirality=int(record["right_chirality"]),
+        result_chirality=int(record["result_chirality"]),
+        coupling=(coupling[0], coupling[1]),
+    )
+
+
+def _closure_kernel_key(record: Mapping[str, object]) -> ClosureKernelKey:
+    particles = tuple(
+        int(value) for value in _sequence(record.get("particles"), "closure.particles")
+    )
+    coupling = tuple(
+        float(value) for value in _sequence(record.get("coupling"), "closure.coupling")
+    )
+    if len(particles) != 3 or len(coupling) != 2:
+        raise ValueError("prepared closure key has malformed particles or coupling")
+    return ClosureKernelKey(
+        kind=int(record["kind"]),
+        particles=(particles[0], particles[1], particles[2]),
+        left_chirality=int(record["left_chirality"]),
+        right_chirality=int(record["right_chirality"]),
+        coupling=(coupling[0], coupling[1]),
+    )
+
+
+__all__ = [
+    "EAGER_RUNTIME_KIND",
+    "EagerExecutionTables",
+    "EagerKernelResolver",
+    "EagerResolvedKernel",
+    "EagerSelectorClosureTables",
+    "EagerStageSelectorDomains",
+    "EagerStageTables",
+    "MappingEagerKernelResolver",
+    "PreparedCatalogEagerKernelIndex",
+    "PreparedCatalogEagerKernelResolver",
+    "lower_eager_execution_tables",
+    "lower_fused_eager_execution",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/eager_tables.py b/pyamplicol/src/pyamplicol/generation/eager_tables.py
new file mode 100644
index 0000000000..05d64812d0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/eager_tables.py
@@ -0,0 +1,512 @@
+# SPDX-License-Identifier: 0BSD
+"""Fixed-width little-endian tables for eager DAG execution."""
+
+from __future__ import annotations
+
+import struct
+from collections.abc import Iterable
+from dataclasses import dataclass
+from math import isfinite
+from typing import ClassVar, Protocol, TypeVar
+
+from .._internal.versions import EAGER_DAG_F64_RUNTIME_CAPABILITY
+from ..models.prepared import EAGER_KERNEL_ABI
+
+EAGER_PLAN_ABI = "pyamplicol-eager-plan-v2"
+EAGER_RUNTIME_CAPABILITY = EAGER_DAG_F64_RUNTIME_CAPABILITY
+EAGER_SELECTOR_DOMAINS_ABI = "pyamplicol-eager-selector-domains-v1"
+MISSING_U32 = (1 << 32) - 1
+EAGER_OUTPUT_FACTOR_NONE = 0
+EAGER_OUTPUT_FACTOR_COUPLING_REAL = 1
+EAGER_OUTPUT_FACTOR_COUPLING_IMAG = 2
+_EAGER_OUTPUT_FACTOR_SOURCES = frozenset(
+    (
+        EAGER_OUTPUT_FACTOR_NONE,
+        EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+        EAGER_OUTPUT_FACTOR_COUPLING_IMAG,
+    )
+)
+
+
+class _FixedWidthRow(Protocol):
+    _STRUCT: ClassVar[struct.Struct]
+
+    def _values(self) -> tuple[int | float, ...]: ...
+
+    @classmethod
+    def _from_values(cls, values: tuple[int | float, ...]) -> _FixedWidthRow: ...
+
+
+_RowT = TypeVar("_RowT", bound=_FixedWidthRow)
+
+
+def _u32(value: int, field: str) -> int:
+    integer = int(value)
+    if integer < 0 or integer > MISSING_U32:
+        raise ValueError(f"{field} must fit in an unsigned 32-bit integer")
+    return integer
+
+
+def _u64(value: int, field: str) -> int:
+    integer = int(value)
+    if integer < 0 or integer >= 1 << 64:
+        raise ValueError(f"{field} must fit in an unsigned 64-bit integer")
+    return integer
+
+
+@dataclass(frozen=True, slots=True)
+class EagerInvocationRow:
+    """One canonical local-kernel evaluation and its attachment range."""
+
+    kernel_id: int
+    left_value_slot_id: int
+    right_value_slot_id: int
+    left_momentum_slot_id: int
+    right_momentum_slot_id: int
+    coupling_slot_id: int
+    output_factor_source: int
+    attachment_start: int
+    attachment_count: int
+
+    _STRUCT: ClassVar[struct.Struct] = struct.Struct("<IIIIIIIQQ")
+
+    def __post_init__(self) -> None:
+        for field in (
+            "kernel_id",
+            "left_value_slot_id",
+            "right_value_slot_id",
+            "left_momentum_slot_id",
+            "right_momentum_slot_id",
+            "coupling_slot_id",
+            "output_factor_source",
+        ):
+            object.__setattr__(self, field, _u32(getattr(self, field), field))
+        if self.output_factor_source not in _EAGER_OUTPUT_FACTOR_SOURCES:
+            raise ValueError("unsupported eager invocation output factor source")
+        for field in ("attachment_start", "attachment_count"):
+            object.__setattr__(self, field, _u64(getattr(self, field), field))
+
+    def _values(self) -> tuple[int | float, ...]:
+        return (
+            self.kernel_id,
+            self.left_value_slot_id,
+            self.right_value_slot_id,
+            self.left_momentum_slot_id,
+            self.right_momentum_slot_id,
+            self.coupling_slot_id,
+            self.output_factor_source,
+            self.attachment_start,
+            self.attachment_count,
+        )
+
+    @classmethod
+    def _from_values(cls, values: tuple[int | float, ...]) -> EagerInvocationRow:
+        return cls(*(int(value) for value in values))
+
+    @classmethod
+    def _from_trusted_values(
+        cls,
+        kernel_id: int,
+        left_value_slot_id: int,
+        right_value_slot_id: int,
+        left_momentum_slot_id: int,
+        right_momentum_slot_id: int,
+        coupling_slot_id: int,
+        output_factor_source: int,
+        attachment_start: int,
+        attachment_count: int,
+    ) -> EagerInvocationRow:
+        """Construct an internally proven row without repeating boundary checks."""
+
+        row = object.__new__(cls)
+        object.__setattr__(row, "kernel_id", kernel_id)
+        object.__setattr__(row, "left_value_slot_id", left_value_slot_id)
+        object.__setattr__(row, "right_value_slot_id", right_value_slot_id)
+        object.__setattr__(row, "left_momentum_slot_id", left_momentum_slot_id)
+        object.__setattr__(row, "right_momentum_slot_id", right_momentum_slot_id)
+        object.__setattr__(row, "coupling_slot_id", coupling_slot_id)
+        object.__setattr__(row, "output_factor_source", output_factor_source)
+        object.__setattr__(row, "attachment_start", attachment_start)
+        object.__setattr__(row, "attachment_count", attachment_count)
+        return row
+
+
+@dataclass(frozen=True, slots=True)
+class EagerAttachmentRow:
+    """Fan-out from one canonical evaluation to one accumulated current."""
+
+    result_current_id: int
+    factor_real: float
+    factor_imag: float
+
+    _STRUCT: ClassVar[struct.Struct] = struct.Struct("<Idd")
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "result_current_id",
+            _u32(self.result_current_id, "result_current_id"),
+        )
+        object.__setattr__(self, "factor_real", float(self.factor_real))
+        object.__setattr__(self, "factor_imag", float(self.factor_imag))
+        if not isfinite(self.factor_real) or not isfinite(self.factor_imag):
+            raise ValueError("attachment factor must be finite")
+
+    def _values(self) -> tuple[int | float, ...]:
+        return self.result_current_id, self.factor_real, self.factor_imag
+
+    @classmethod
+    def _from_values(cls, values: tuple[int | float, ...]) -> EagerAttachmentRow:
+        return cls(int(values[0]), float(values[1]), float(values[2]))
+
+    @classmethod
+    def _from_trusted_values(
+        cls,
+        result_current_id: int,
+        factor_real: float,
+        factor_imag: float,
+    ) -> EagerAttachmentRow:
+        row = object.__new__(cls)
+        object.__setattr__(row, "result_current_id", result_current_id)
+        object.__setattr__(row, "factor_real", factor_real)
+        object.__setattr__(row, "factor_imag", factor_imag)
+        return row
+
+
+@dataclass(frozen=True, slots=True)
+class EagerCouplingRow:
+    """Resolve one complex coupling from constants and/or model parameters."""
+
+    real_parameter_id: int
+    imag_parameter_id: int
+    constant_real: float
+    constant_imag: float
+
+    _STRUCT: ClassVar[struct.Struct] = struct.Struct("<IIdd")
+
+    def __post_init__(self) -> None:
+        for field in ("real_parameter_id", "imag_parameter_id"):
+            object.__setattr__(self, field, _u32(getattr(self, field), field))
+        object.__setattr__(self, "constant_real", float(self.constant_real))
+        object.__setattr__(self, "constant_imag", float(self.constant_imag))
+        if not isfinite(self.constant_real) or not isfinite(self.constant_imag):
+            raise ValueError("coupling constants must be finite")
+
+    def _values(self) -> tuple[int | float, ...]:
+        return (
+            self.real_parameter_id,
+            self.imag_parameter_id,
+            self.constant_real,
+            self.constant_imag,
+        )
+
+    @classmethod
+    def _from_values(cls, values: tuple[int | float, ...]) -> EagerCouplingRow:
+        return cls(
+            int(values[0]),
+            int(values[1]),
+            float(values[2]),
+            float(values[3]),
+        )
+
+    @classmethod
+    def _from_trusted_values(
+        cls,
+        real_parameter_id: int,
+        imag_parameter_id: int,
+        constant_real: float,
+        constant_imag: float,
+    ) -> EagerCouplingRow:
+        row = object.__new__(cls)
+        object.__setattr__(row, "real_parameter_id", real_parameter_id)
+        object.__setattr__(row, "imag_parameter_id", imag_parameter_id)
+        object.__setattr__(row, "constant_real", constant_real)
+        object.__setattr__(row, "constant_imag", constant_imag)
+        return row
+
+
+@dataclass(frozen=True, slots=True)
+class EagerFinalizationRow:
+    """Finalize one accumulated current, applying its propagator at most once."""
+
+    kernel_id: int
+    current_id: int
+    unpropagated_value_slot_id: int
+    propagated_value_slot_id: int
+    momentum_slot_id: int
+
+    _STRUCT: ClassVar[struct.Struct] = struct.Struct("<IIIII")
+
+    def __post_init__(self) -> None:
+        for field in (
+            "kernel_id",
+            "current_id",
+            "unpropagated_value_slot_id",
+            "propagated_value_slot_id",
+            "momentum_slot_id",
+        ):
+            object.__setattr__(self, field, _u32(getattr(self, field), field))
+
+    @property
+    def applies_kernel(self) -> bool:
+        return self.kernel_id != MISSING_U32
+
+    @property
+    def stores_unpropagated(self) -> bool:
+        return self.unpropagated_value_slot_id != MISSING_U32
+
+    @property
+    def stores_propagated(self) -> bool:
+        return self.propagated_value_slot_id != MISSING_U32
+
+    def _values(self) -> tuple[int | float, ...]:
+        return (
+            self.kernel_id,
+            self.current_id,
+            self.unpropagated_value_slot_id,
+            self.propagated_value_slot_id,
+            self.momentum_slot_id,
+        )
+
+    @classmethod
+    def _from_values(cls, values: tuple[int | float, ...]) -> EagerFinalizationRow:
+        return cls(*(int(value) for value in values))
+
+    @classmethod
+    def _from_trusted_values(
+        cls,
+        kernel_id: int,
+        current_id: int,
+        unpropagated_value_slot_id: int,
+        propagated_value_slot_id: int,
+        momentum_slot_id: int,
+    ) -> EagerFinalizationRow:
+        row = object.__new__(cls)
+        object.__setattr__(row, "kernel_id", kernel_id)
+        object.__setattr__(row, "current_id", current_id)
+        object.__setattr__(
+            row,
+            "unpropagated_value_slot_id",
+            unpropagated_value_slot_id,
+        )
+        object.__setattr__(row, "propagated_value_slot_id", propagated_value_slot_id)
+        object.__setattr__(row, "momentum_slot_id", momentum_slot_id)
+        return row
+
+
+@dataclass(frozen=True, slots=True)
+class EagerClosureRow:
+    """One prepared amplitude-closure call and its physical output slot."""
+
+    kernel_id: int
+    left_value_slot_id: int
+    right_value_slot_id: int
+    amplitude_index: int
+    coupling_slot_id: int
+    output_factor_source: int
+    factor_real: float
+    factor_imag: float
+
+    _STRUCT: ClassVar[struct.Struct] = struct.Struct("<IIIIIIdd")
+
+    def __post_init__(self) -> None:
+        for field in (
+            "kernel_id",
+            "left_value_slot_id",
+            "right_value_slot_id",
+            "amplitude_index",
+            "coupling_slot_id",
+            "output_factor_source",
+        ):
+            object.__setattr__(self, field, _u32(getattr(self, field), field))
+        if self.output_factor_source not in _EAGER_OUTPUT_FACTOR_SOURCES:
+            raise ValueError("unsupported eager closure output factor source")
+        object.__setattr__(self, "factor_real", float(self.factor_real))
+        object.__setattr__(self, "factor_imag", float(self.factor_imag))
+        if not isfinite(self.factor_real) or not isfinite(self.factor_imag):
+            raise ValueError("closure factor must be finite")
+
+    def _values(self) -> tuple[int | float, ...]:
+        return (
+            self.kernel_id,
+            self.left_value_slot_id,
+            self.right_value_slot_id,
+            self.amplitude_index,
+            self.coupling_slot_id,
+            self.output_factor_source,
+            self.factor_real,
+            self.factor_imag,
+        )
+
+    @classmethod
+    def _from_values(cls, values: tuple[int | float, ...]) -> EagerClosureRow:
+        return cls(
+            int(values[0]),
+            int(values[1]),
+            int(values[2]),
+            int(values[3]),
+            int(values[4]),
+            int(values[5]),
+            float(values[6]),
+            float(values[7]),
+        )
+
+    @classmethod
+    def _from_trusted_values(
+        cls,
+        kernel_id: int,
+        left_value_slot_id: int,
+        right_value_slot_id: int,
+        amplitude_index: int,
+        coupling_slot_id: int,
+        output_factor_source: int,
+        factor_real: float,
+        factor_imag: float,
+    ) -> EagerClosureRow:
+        row = object.__new__(cls)
+        object.__setattr__(row, "kernel_id", kernel_id)
+        object.__setattr__(row, "left_value_slot_id", left_value_slot_id)
+        object.__setattr__(row, "right_value_slot_id", right_value_slot_id)
+        object.__setattr__(row, "amplitude_index", amplitude_index)
+        object.__setattr__(row, "coupling_slot_id", coupling_slot_id)
+        object.__setattr__(row, "output_factor_source", output_factor_source)
+        object.__setattr__(row, "factor_real", factor_real)
+        object.__setattr__(row, "factor_imag", factor_imag)
+        return row
+
+
+@dataclass(frozen=True, slots=True)
+class EagerSelectorDomainRow:
+    """One range into the flattened coherent-group membership table."""
+
+    member_start: int
+    member_count: int
+
+    _STRUCT: ClassVar[struct.Struct] = struct.Struct("<QQ")
+
+    def __post_init__(self) -> None:
+        for field in ("member_start", "member_count"):
+            object.__setattr__(self, field, _u64(getattr(self, field), field))
+
+    def _values(self) -> tuple[int | float, ...]:
+        return self.member_start, self.member_count
+
+    @classmethod
+    def _from_values(cls, values: tuple[int | float, ...]) -> EagerSelectorDomainRow:
+        return cls(int(values[0]), int(values[1]))
+
+    @classmethod
+    def _from_trusted_values(
+        cls,
+        member_start: int,
+        member_count: int,
+    ) -> EagerSelectorDomainRow:
+        row = object.__new__(cls)
+        object.__setattr__(row, "member_start", member_start)
+        object.__setattr__(row, "member_count", member_count)
+        return row
+
+
+@dataclass(frozen=True, slots=True)
+class EagerSelectorGroupRow:
+    """One coherent reduction-group member of an interned selector domain."""
+
+    coherent_group_id: int
+
+    _STRUCT: ClassVar[struct.Struct] = struct.Struct("<I")
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "coherent_group_id",
+            _u32(self.coherent_group_id, "coherent_group_id"),
+        )
+
+    def _values(self) -> tuple[int | float, ...]:
+        return (self.coherent_group_id,)
+
+    @classmethod
+    def _from_values(cls, values: tuple[int | float, ...]) -> EagerSelectorGroupRow:
+        return cls(int(values[0]))
+
+    @classmethod
+    def _from_trusted_values(cls, coherent_group_id: int) -> EagerSelectorGroupRow:
+        row = object.__new__(cls)
+        object.__setattr__(row, "coherent_group_id", coherent_group_id)
+        return row
+
+
+@dataclass(frozen=True, slots=True)
+class EagerSelectorDomainIdRow:
+    """One reference to an interned selector domain."""
+
+    domain_id: int
+
+    _STRUCT: ClassVar[struct.Struct] = struct.Struct("<I")
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "domain_id", _u32(self.domain_id, "domain_id"))
+
+    def _values(self) -> tuple[int | float, ...]:
+        return (self.domain_id,)
+
+    @classmethod
+    def _from_values(cls, values: tuple[int | float, ...]) -> EagerSelectorDomainIdRow:
+        return cls(int(values[0]))
+
+    @classmethod
+    def _from_trusted_values(cls, domain_id: int) -> EagerSelectorDomainIdRow:
+        row = object.__new__(cls)
+        object.__setattr__(row, "domain_id", domain_id)
+        return row
+
+
+def pack_rows(rows: Iterable[_FixedWidthRow]) -> bytes:
+    """Serialize homogeneous rows without padding or a redundant header."""
+
+    records = tuple(rows)
+    if not records:
+        return b""
+    row_type = type(records[0])
+    if any(type(row) is not row_type for row in records):
+        raise TypeError("eager binary tables must contain one row type")
+    layout = records[0]._STRUCT
+    payload = bytearray(len(records) * layout.size)
+    for row_index, row in enumerate(records):
+        layout.pack_into(payload, row_index * layout.size, *row._values())
+    return bytes(payload)
+
+
+def unpack_rows(payload: bytes, row_type: type[_RowT]) -> tuple[_RowT, ...]:
+    """Deserialize one table, rejecting truncated or extended row payloads."""
+
+    layout = row_type._STRUCT
+    if len(payload) % layout.size:
+        raise ValueError(
+            f"eager table has {len(payload)} bytes, not a multiple of {layout.size}"
+        )
+    return tuple(
+        row_type._from_values(tuple(values)) for values in layout.iter_unpack(payload)
+    )
+
+
+__all__ = [
+    "EAGER_KERNEL_ABI",
+    "EAGER_OUTPUT_FACTOR_COUPLING_IMAG",
+    "EAGER_OUTPUT_FACTOR_COUPLING_REAL",
+    "EAGER_OUTPUT_FACTOR_NONE",
+    "EAGER_PLAN_ABI",
+    "EAGER_RUNTIME_CAPABILITY",
+    "EAGER_SELECTOR_DOMAINS_ABI",
+    "MISSING_U32",
+    "EagerAttachmentRow",
+    "EagerClosureRow",
+    "EagerCouplingRow",
+    "EagerFinalizationRow",
+    "EagerInvocationRow",
+    "EagerSelectorDomainIdRow",
+    "EagerSelectorDomainRow",
+    "EagerSelectorGroupRow",
+    "pack_rows",
+    "unpack_rows",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/evaluator_container.py b/pyamplicol/src/pyamplicol/generation/evaluator_container.py
new file mode 100644
index 0000000000..e8a5a0fffe
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/evaluator_container.py
@@ -0,0 +1,957 @@
+# SPDX-License-Identifier: 0BSD
+"""Portable binary containers for generated evaluator payloads.
+
+``pacbin-v1`` is deliberately independent of Python serialization formats.  A
+container consists of a fixed 64-byte header, 64-byte-aligned uncompressed
+member payloads, a sorted variable-width index, and a fixed 64-byte footer.
+Every integer is little-endian.  The footer authenticates the exact index
+bytes, while every index entry authenticates its member payload with SHA-256.
+
+This module implements the producer-side codec. Artifact publication uses it
+to write one evaluator pack, while Rusticol implements the independent native
+reader for runtime loading.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import struct
+import tempfile
+import unicodedata
+from collections.abc import Iterable, Iterator
+from contextlib import contextmanager, suppress
+from dataclasses import dataclass
+from enum import IntEnum
+from pathlib import Path
+from typing import BinaryIO
+
+PACBIN_VERSION = 1
+PACBIN_ALIGNMENT = 64
+
+_HEADER_MAGIC = b"PACBIN\x00\x00"
+_INDEX_MAGIC = b"PACIDX\x00\x00"
+_FOOTER_MAGIC = b"PACEND\x00\x00"
+_SUPPORTED_FLAGS = 0
+_INDEX_ALIGNMENT = 8
+_DEFAULT_CHUNK_SIZE = 1024 * 1024
+_MAX_U32 = (1 << 32) - 1
+_MAX_U64 = (1 << 64) - 1
+
+# magic, version, size, flags, alignment, reserved, index offset, member count,
+# reserved.  Keeping the header exactly one payload-alignment unit makes the
+# first member naturally aligned.
+_HEADER_STRUCT = struct.Struct("<8sHHIIIQQ24s")
+# magic, version, size, flags, member count, reserved
+_INDEX_HEADER_STRUCT = struct.Struct("<8sHHIQQ")
+# path byte count, kind, flags, payload offset, payload length, payload digest
+_INDEX_ENTRY_STRUCT = struct.Struct("<IHHQQ32s")
+# magic, version, size, flags, index offset, member count, index digest
+_FOOTER_STRUCT = struct.Struct("<8sHHIQQ32s")
+
+
+class PacbinError(ValueError):
+    """A malformed container or invalid codec request."""
+
+
+class PacbinMemberKind(IntEnum):
+    """Portable evaluator payload kinds encoded by pacbin-v1."""
+
+    SYMJIT_APPLICATION = 1
+    SYMBOLICA_EXACT_STATE = 2
+    NATIVE_LIBRARY = 3
+    EAGER_RUNTIME_METADATA = 4
+    EAGER_RUNTIME_TABLE = 5
+    RECURRENCE_DIRECT_PLAN = 7
+    RECURRENCE_COLOR_PROJECTION_CERTIFICATE = 8
+    ON_THE_FLY_PROCESS_SEED = 9
+    COLOR_CONTRACTION = 10
+
+
+@dataclass(frozen=True, slots=True)
+class PacbinMemberSource:
+    """One logical member and the stream from which its bytes are copied.
+
+    A path source is opened from its beginning.  A binary file object is read
+    from its current position to EOF and is never closed by the writer.
+    """
+
+    logical_path: str
+    kind: PacbinMemberKind
+    source: str | os.PathLike[str] | BinaryIO
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "logical_path",
+            normalize_logical_path(self.logical_path),
+        )
+        try:
+            kind = PacbinMemberKind(self.kind)
+        except (TypeError, ValueError) as exc:
+            raise PacbinError(f"unknown pacbin member kind: {self.kind!r}") from exc
+        object.__setattr__(self, "kind", kind)
+
+
+@dataclass(frozen=True, slots=True)
+class PacbinMember:
+    """Validated metadata for one indexed member."""
+
+    logical_path: str
+    kind: PacbinMemberKind
+    offset: int
+    length: int
+    sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class PacbinIndex:
+    """Validated top-level metadata returned by the writer or reader."""
+
+    version: int
+    index_offset: int
+    index_sha256: str
+    file_size: int
+    members: tuple[PacbinMember, ...]
+
+    def member(self, logical_path: str) -> PacbinMember:
+        """Return one member by normalized logical path."""
+
+        normalized = normalize_logical_path(logical_path)
+        for member in self.members:
+            if member.logical_path == normalized:
+                return member
+        raise KeyError(normalized)
+
+
+def normalize_logical_path(value: str) -> str:
+    """Return the canonical NFC POSIX path used in a pacbin index."""
+
+    if not isinstance(value, str):
+        raise TypeError("pacbin logical path must be a string")
+    if not value or "\x00" in value:
+        raise PacbinError("pacbin logical path must be non-empty and contain no NUL")
+    if "\\" in value:
+        raise PacbinError("pacbin logical path must use POSIX '/' separators")
+    if value.startswith("/"):
+        raise PacbinError("pacbin logical path must be relative")
+
+    parts: list[str] = []
+    for part in value.split("/"):
+        if part in {"", "."}:
+            continue
+        if part == "..":
+            raise PacbinError("pacbin logical path must not contain '..'")
+        parts.append(unicodedata.normalize("NFC", part))
+    if not parts:
+        raise PacbinError("pacbin logical path must name a member")
+    return "/".join(parts)
+
+
+def write_pacbin(
+    destination: str | os.PathLike[str] | BinaryIO,
+    members: Iterable[PacbinMemberSource],
+    *,
+    chunk_size: int = _DEFAULT_CHUNK_SIZE,
+) -> PacbinIndex:
+    """Stream ``members`` into one deterministic pacbin-v1 container.
+
+    Member descriptors and index metadata are retained in memory, but payload
+    contents are copied and hashed in bounded chunks.  File-object destinations
+    must be seekable because the completed index location is written back into
+    the header.
+    """
+
+    chunk_size = _checked_chunk_size(chunk_size)
+    ordered = _ordered_sources(members)
+    expected_index_size = _validate_index_bounds(ordered)
+    with _open_destination(destination) as stream:
+        _require_seekable(stream, "pacbin destination")
+        stream.seek(0)
+        stream.truncate(0)
+        _write_all(stream, b"\x00" * _HEADER_STRUCT.size, "pacbin header")
+
+        indexed_members: list[PacbinMember] = []
+        for source in ordered:
+            _write_alignment_padding(stream, PACBIN_ALIGNMENT)
+            offset = _checked_u64_position(stream.tell(), "pacbin member offset")
+            digest = hashlib.sha256()
+            length = 0
+            with _open_member_source(source.source) as member_stream:
+                while True:
+                    chunk = member_stream.read(chunk_size)
+                    if not isinstance(chunk, bytes | bytearray | memoryview):
+                        raise TypeError("pacbin member source must return bytes")
+                    if not chunk:
+                        break
+                    if len(chunk) > chunk_size:
+                        raise PacbinError(
+                            "pacbin member source returned more bytes than requested"
+                        )
+                    if len(chunk) > _MAX_U64 - length:
+                        raise PacbinError("pacbin member length exceeds u64")
+                    length += len(chunk)
+                    digest.update(chunk)
+                    _write_all(stream, chunk, "pacbin member payload")
+            indexed_members.append(
+                PacbinMember(
+                    logical_path=source.logical_path,
+                    kind=source.kind,
+                    offset=offset,
+                    length=length,
+                    sha256=digest.hexdigest(),
+                )
+            )
+
+        _write_alignment_padding(stream, PACBIN_ALIGNMENT)
+        index_offset = _checked_u64_position(stream.tell(), "pacbin index offset")
+        index_digest = hashlib.sha256()
+        _write_hashed(
+            stream,
+            index_digest,
+            _INDEX_HEADER_STRUCT.pack(
+                _INDEX_MAGIC,
+                PACBIN_VERSION,
+                _INDEX_HEADER_STRUCT.size,
+                _SUPPORTED_FLAGS,
+                len(indexed_members),
+                0,
+            ),
+        )
+        for member in indexed_members:
+            path_bytes = member.logical_path.encode("utf-8")
+            if len(path_bytes) > _MAX_U32:
+                raise PacbinError("pacbin logical path exceeds u32 byte length")
+            prefix = _INDEX_ENTRY_STRUCT.pack(
+                len(path_bytes),
+                int(member.kind),
+                _SUPPORTED_FLAGS,
+                member.offset,
+                member.length,
+                bytes.fromhex(member.sha256),
+            )
+            _write_hashed(stream, index_digest, prefix)
+            _write_hashed(stream, index_digest, path_bytes)
+            padding = _padding_length(len(prefix) + len(path_bytes), _INDEX_ALIGNMENT)
+            if padding:
+                _write_hashed(stream, index_digest, b"\x00" * padding)
+
+        index_sha256 = index_digest.digest()
+        if stream.tell() - index_offset != expected_index_size:
+            raise PacbinError("pacbin index size disagrees with preflight")
+        _write_all(
+            stream,
+            _FOOTER_STRUCT.pack(
+                _FOOTER_MAGIC,
+                PACBIN_VERSION,
+                _FOOTER_STRUCT.size,
+                _SUPPORTED_FLAGS,
+                index_offset,
+                len(indexed_members),
+                index_sha256,
+            ),
+            "pacbin footer",
+        )
+        file_size = _checked_u64_position(stream.tell(), "pacbin file size")
+        stream.seek(0)
+        _write_all(
+            stream,
+            _HEADER_STRUCT.pack(
+                _HEADER_MAGIC,
+                PACBIN_VERSION,
+                _HEADER_STRUCT.size,
+                _SUPPORTED_FLAGS,
+                PACBIN_ALIGNMENT,
+                0,
+                index_offset,
+                len(indexed_members),
+                b"\x00" * 24,
+            ),
+            "pacbin header",
+        )
+        stream.seek(file_size)
+        stream.truncate()
+        stream.flush()
+
+    return PacbinIndex(
+        version=PACBIN_VERSION,
+        index_offset=index_offset,
+        index_sha256=index_sha256.hex(),
+        file_size=file_size,
+        members=tuple(indexed_members),
+    )
+
+
+def write_pacbin_atomic(
+    destination: str | os.PathLike[str],
+    members: Iterable[PacbinMemberSource],
+    *,
+    chunk_size: int = _DEFAULT_CHUNK_SIZE,
+    mode: int = 0o644,
+) -> PacbinIndex:
+    """Atomically publish a complete container at ``destination``.
+
+    The container is written, flushed, and synced through a uniquely named
+    temporary file in the destination directory before ``os.replace`` makes
+    it visible.  Any failure before replacement leaves an existing
+    destination untouched and removes the temporary file.  Directory syncing
+    is best effort because not every supported filesystem exposes it.
+    """
+
+    if not isinstance(mode, int) or isinstance(mode, bool) or not 0 <= mode <= 0o777:
+        raise PacbinError("pacbin publication mode must be between 0o000 and 0o777")
+    path = Path(destination)
+    parent = path.parent
+    if not parent.is_dir():
+        raise PacbinError(f"pacbin destination directory does not exist: {parent}")
+
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+        dir=parent,
+    )
+    temporary_path = Path(temporary_name)
+    descriptor_open = True
+    try:
+        with os.fdopen(descriptor, "w+b") as stream:
+            descriptor_open = False
+            index = write_pacbin(stream, members, chunk_size=chunk_size)
+            os.chmod(temporary_path, mode)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary_path, path)
+        _fsync_directory_best_effort(parent)
+        return index
+    finally:
+        if descriptor_open:
+            os.close(descriptor)
+        with suppress(FileNotFoundError):
+            temporary_path.unlink()
+
+
+class PacbinReader:
+    """Strict, bounded-access reader for one pacbin-v1 container."""
+
+    def __init__(
+        self,
+        stream: BinaryIO,
+        *,
+        owns_stream: bool,
+        verify_payloads: bool,
+        chunk_size: int,
+    ) -> None:
+        self._stream = stream
+        self._owns_stream = owns_stream
+        self._closed = False
+        self._chunk_size = _checked_chunk_size(chunk_size)
+        self._require_readable_seekable()
+        self.index = self._load_index()
+        self._members_by_path = {
+            member.logical_path: member for member in self.index.members
+        }
+        if verify_payloads:
+            self.verify_payloads()
+
+    @classmethod
+    def open(
+        cls,
+        source: str | os.PathLike[str] | BinaryIO,
+        *,
+        verify_payloads: bool = True,
+        chunk_size: int = _DEFAULT_CHUNK_SIZE,
+    ) -> PacbinReader:
+        """Open and structurally validate a container.
+
+        Payload digests are verified by default.  Passing an existing binary
+        stream leaves ownership with the caller.
+        """
+
+        if isinstance(source, str | os.PathLike):
+            # The returned reader owns this stream until PacbinReader.close().
+            stream = Path(source).open("rb")  # noqa: SIM115
+            owns_stream = True
+        else:
+            stream = source
+            owns_stream = False
+        try:
+            return cls(
+                stream,
+                owns_stream=owns_stream,
+                verify_payloads=verify_payloads,
+                chunk_size=chunk_size,
+            )
+        except BaseException:
+            if owns_stream:
+                stream.close()
+            raise
+
+    @property
+    def members(self) -> tuple[PacbinMember, ...]:
+        """Return members in canonical logical-path order."""
+
+        return self.index.members
+
+    def member(self, logical_path: str) -> PacbinMember:
+        """Return metadata for one logical member."""
+
+        self._ensure_open()
+        normalized = normalize_logical_path(logical_path)
+        try:
+            return self._members_by_path[normalized]
+        except KeyError as exc:
+            raise KeyError(normalized) from exc
+
+    def read_member(
+        self,
+        logical_path: str,
+        *,
+        offset: int = 0,
+        length: int,
+    ) -> bytes:
+        """Read exactly one bounded range relative to a member's start."""
+
+        self._ensure_open()
+        member = self.member(logical_path)
+        if not isinstance(offset, int) or isinstance(offset, bool) or offset < 0:
+            raise PacbinError("member read offset must be a non-negative integer")
+        if not isinstance(length, int) or isinstance(length, bool) or length < 0:
+            raise PacbinError("member read length must be a non-negative integer")
+        if offset > member.length or length > member.length - offset:
+            raise PacbinError("member read exceeds indexed payload bounds")
+        self._stream.seek(member.offset + offset)
+        return _read_exact(self._stream, length, "member payload")
+
+    def open_member_stream(self, logical_path: str) -> PacbinMemberStream:
+        """Return a bounded streaming view over one member.
+
+        The returned view never materializes the complete member and remains
+        valid only while this reader is open.  Each read seeks to its indexed
+        position, so several member views may safely be consumed in any
+        sequential order while repacking a container.
+        """
+
+        self._ensure_open()
+        return PacbinMemberStream(self, self.member(logical_path))
+
+    def verify_payloads(self) -> None:
+        """Stream and verify every indexed member digest."""
+
+        self._ensure_open()
+        for member in self.index.members:
+            digest = hashlib.sha256()
+            remaining = member.length
+            self._stream.seek(member.offset)
+            while remaining:
+                requested = min(self._chunk_size, remaining)
+                chunk = self._stream.read(requested)
+                if not chunk:
+                    raise PacbinError(
+                        f"truncated pacbin member payload: {member.logical_path}"
+                    )
+                if not isinstance(chunk, bytes | bytearray | memoryview):
+                    raise TypeError("pacbin member source must return bytes")
+                if len(chunk) > requested:
+                    raise PacbinError(
+                        f"oversized read for pacbin member: {member.logical_path}"
+                    )
+                digest.update(chunk)
+                remaining -= len(chunk)
+            if digest.hexdigest() != member.sha256:
+                raise PacbinError(
+                    f"pacbin member digest mismatch: {member.logical_path}"
+                )
+
+    def close(self) -> None:
+        """Close an owned stream and invalidate further reads."""
+
+        if self._closed:
+            return
+        self._closed = True
+        if self._owns_stream:
+            self._stream.close()
+
+    def __enter__(self) -> PacbinReader:
+        self._ensure_open()
+        return self
+
+    def __exit__(self, *_args: object) -> None:
+        self.close()
+
+    def _require_readable_seekable(self) -> None:
+        _require_seekable(self._stream, "pacbin source")
+        readable = getattr(self._stream, "readable", None)
+        if callable(readable) and not readable():
+            raise PacbinError("pacbin source must be readable")
+
+    def _load_index(self) -> PacbinIndex:
+        stream = self._stream
+        stream.seek(0, os.SEEK_END)
+        file_size = stream.tell()
+        if file_size < 0 or file_size > _MAX_U64:
+            raise PacbinError("pacbin file size exceeds u64")
+        minimum_size = (
+            _HEADER_STRUCT.size + _INDEX_HEADER_STRUCT.size + _FOOTER_STRUCT.size
+        )
+        if file_size < minimum_size:
+            raise PacbinError("truncated pacbin container")
+
+        stream.seek(0)
+        header = _HEADER_STRUCT.unpack(
+            _read_exact(stream, _HEADER_STRUCT.size, "pacbin header")
+        )
+        (
+            magic,
+            version,
+            header_size,
+            flags,
+            alignment,
+            reserved,
+            index_offset,
+            member_count,
+            reserved_bytes,
+        ) = header
+        if magic != _HEADER_MAGIC:
+            raise PacbinError("invalid pacbin header magic")
+        _validate_version_size_flags(
+            "header", version, header_size, _HEADER_STRUCT.size, flags
+        )
+        if alignment != PACBIN_ALIGNMENT:
+            raise PacbinError(f"unsupported pacbin payload alignment: {alignment}")
+        if reserved != 0 or reserved_bytes != b"\x00" * 24:
+            raise PacbinError("pacbin header reserved fields must be zero")
+        if index_offset % PACBIN_ALIGNMENT:
+            raise PacbinError("pacbin index offset is not payload-aligned")
+
+        footer_offset = file_size - _FOOTER_STRUCT.size
+        if index_offset < _HEADER_STRUCT.size or index_offset >= footer_offset:
+            raise PacbinError("pacbin index offset is out of bounds")
+        stream.seek(footer_offset)
+        footer = _FOOTER_STRUCT.unpack(
+            _read_exact(stream, _FOOTER_STRUCT.size, "pacbin footer")
+        )
+        (
+            footer_magic,
+            footer_version,
+            footer_size,
+            footer_flags,
+            footer_index_offset,
+            footer_member_count,
+            expected_index_digest,
+        ) = footer
+        if footer_magic != _FOOTER_MAGIC:
+            raise PacbinError("invalid pacbin footer magic")
+        _validate_version_size_flags(
+            "footer",
+            footer_version,
+            footer_size,
+            _FOOTER_STRUCT.size,
+            footer_flags,
+        )
+        if footer_index_offset != index_offset:
+            raise PacbinError("pacbin footer index offset disagrees with header")
+        if footer_member_count != member_count:
+            raise PacbinError("pacbin footer member count disagrees with header")
+
+        stream.seek(index_offset)
+        index_digest = hashlib.sha256()
+        index_header_bytes = _read_exact(
+            stream, _INDEX_HEADER_STRUCT.size, "pacbin index header"
+        )
+        index_digest.update(index_header_bytes)
+        (
+            index_magic,
+            index_version,
+            index_header_size,
+            index_flags,
+            index_member_count,
+            index_reserved,
+        ) = _INDEX_HEADER_STRUCT.unpack(index_header_bytes)
+        if index_magic != _INDEX_MAGIC:
+            raise PacbinError("invalid pacbin index magic")
+        _validate_version_size_flags(
+            "index",
+            index_version,
+            index_header_size,
+            _INDEX_HEADER_STRUCT.size,
+            index_flags,
+        )
+        if index_reserved != 0:
+            raise PacbinError("pacbin index reserved field must be zero")
+        if index_member_count != member_count:
+            raise PacbinError("pacbin index member count disagrees with header")
+        available_index_bytes = footer_offset - index_offset
+        if member_count > available_index_bytes // (_INDEX_ENTRY_STRUCT.size + 8):
+            raise PacbinError("pacbin member count cannot fit in index")
+
+        members: list[PacbinMember] = []
+        seen_paths: set[str] = set()
+        seen_folded_paths: set[str] = set()
+        previous_path_bytes: bytes | None = None
+        for _entry_index in range(member_count):
+            prefix = _read_index_bytes(
+                stream,
+                index_digest,
+                _INDEX_ENTRY_STRUCT.size,
+                footer_offset,
+                "pacbin index entry",
+            )
+            path_length, kind_value, entry_flags, offset, length, digest = (
+                _INDEX_ENTRY_STRUCT.unpack(prefix)
+            )
+            if entry_flags != _SUPPORTED_FLAGS:
+                raise PacbinError(f"unknown pacbin member flags: {entry_flags}")
+            try:
+                kind = PacbinMemberKind(kind_value)
+            except ValueError as exc:
+                raise PacbinError(f"unknown pacbin member kind: {kind_value}") from exc
+            path_bytes = _read_index_bytes(
+                stream,
+                index_digest,
+                path_length,
+                footer_offset,
+                "pacbin member path",
+            )
+            try:
+                logical_path = path_bytes.decode("utf-8")
+            except UnicodeDecodeError as exc:
+                raise PacbinError("pacbin member path is not valid UTF-8") from exc
+            if normalize_logical_path(logical_path) != logical_path:
+                raise PacbinError(
+                    f"pacbin member path is not canonical: {logical_path!r}"
+                )
+            folded = logical_path.casefold()
+            if logical_path in seen_paths:
+                raise PacbinError(f"duplicate pacbin member path: {logical_path}")
+            if folded in seen_folded_paths:
+                raise PacbinError(f"case-colliding pacbin member path: {logical_path}")
+            if previous_path_bytes is not None and path_bytes <= previous_path_bytes:
+                raise PacbinError("pacbin index paths are not strictly sorted")
+            previous_path_bytes = path_bytes
+            seen_paths.add(logical_path)
+            seen_folded_paths.add(folded)
+            padding = _padding_length(
+                _INDEX_ENTRY_STRUCT.size + path_length, _INDEX_ALIGNMENT
+            )
+            if padding:
+                padding_bytes = _read_index_bytes(
+                    stream,
+                    index_digest,
+                    padding,
+                    footer_offset,
+                    "pacbin index padding",
+                )
+                if padding_bytes != b"\x00" * padding:
+                    raise PacbinError("pacbin index padding must be zero")
+            members.append(
+                PacbinMember(
+                    logical_path=logical_path,
+                    kind=kind,
+                    offset=offset,
+                    length=length,
+                    sha256=digest.hex(),
+                )
+            )
+
+        if stream.tell() != footer_offset:
+            raise PacbinError("pacbin index has trailing or missing bytes")
+        if index_digest.digest() != expected_index_digest:
+            raise PacbinError("pacbin index digest mismatch")
+        _validate_canonical_payload_layout(stream, members, index_offset)
+        return PacbinIndex(
+            version=version,
+            index_offset=index_offset,
+            index_sha256=index_digest.hexdigest(),
+            file_size=file_size,
+            members=tuple(members),
+        )
+
+    def _ensure_open(self) -> None:
+        if self._closed:
+            raise ValueError("I/O operation on closed pacbin reader")
+
+
+class PacbinMemberStream:
+    """Read-only, bounded view over one member owned by a :class:`PacbinReader`."""
+
+    def __init__(self, reader: PacbinReader, member: PacbinMember) -> None:
+        self._reader = reader
+        self.member = member
+        self._position = 0
+
+    def readable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return False
+
+    def tell(self) -> int:
+        return self._position
+
+    def read(self, size: int = -1) -> bytes:
+        self._reader._ensure_open()
+        if not isinstance(size, int) or isinstance(size, bool):
+            raise TypeError("pacbin member stream read size must be an integer")
+        if size < 0:
+            raise PacbinError("pacbin member stream requires a bounded read size")
+        remaining = self.member.length - self._position
+        if size == 0 or remaining == 0:
+            return b""
+        requested = min(size, remaining)
+        self._reader._stream.seek(self.member.offset + self._position)
+        payload = _read_exact(
+            self._reader._stream,
+            requested,
+            f"pacbin member {self.member.logical_path!r}",
+        )
+        self._position += len(payload)
+        return payload
+
+
+def _ordered_sources(
+    members: Iterable[PacbinMemberSource],
+) -> tuple[PacbinMemberSource, ...]:
+    prepared = tuple(members)
+    if not all(isinstance(member, PacbinMemberSource) for member in prepared):
+        raise TypeError("pacbin members must be PacbinMemberSource instances")
+    ordered = tuple(
+        sorted(prepared, key=lambda member: member.logical_path.encode("utf-8"))
+    )
+    seen_paths: set[str] = set()
+    seen_folded_paths: set[str] = set()
+    for member in ordered:
+        folded = member.logical_path.casefold()
+        if member.logical_path in seen_paths:
+            raise PacbinError(f"duplicate pacbin member path: {member.logical_path}")
+        if folded in seen_folded_paths:
+            raise PacbinError(
+                f"case-colliding pacbin member path: {member.logical_path}"
+            )
+        seen_paths.add(member.logical_path)
+        seen_folded_paths.add(folded)
+    return ordered
+
+
+def _validate_index_bounds(members: tuple[PacbinMemberSource, ...]) -> int:
+    if len(members) > _MAX_U64:
+        raise PacbinError("pacbin member count exceeds u64")
+    index_size = _INDEX_HEADER_STRUCT.size
+    for member in members:
+        path_length = len(member.logical_path.encode("utf-8"))
+        if path_length > _MAX_U32:
+            raise PacbinError("pacbin logical path exceeds u32 byte length")
+        record_size = _INDEX_ENTRY_STRUCT.size + path_length
+        record_size += _padding_length(record_size, _INDEX_ALIGNMENT)
+        if record_size > _MAX_U64 - index_size:
+            raise PacbinError("pacbin index size exceeds u64")
+        index_size += record_size
+    return index_size
+
+
+@contextmanager
+def _open_destination(
+    destination: str | os.PathLike[str] | BinaryIO,
+) -> Iterator[BinaryIO]:
+    if isinstance(destination, str | os.PathLike):
+        with Path(destination).open("w+b") as stream:
+            yield stream
+    else:
+        yield destination
+
+
+@contextmanager
+def _open_member_source(
+    source: str | os.PathLike[str] | BinaryIO,
+) -> Iterator[BinaryIO]:
+    if isinstance(source, str | os.PathLike):
+        path = Path(source)
+        if not path.is_file():
+            raise PacbinError(f"pacbin member source is not a file: {path}")
+        with path.open("rb") as stream:
+            yield stream
+    else:
+        read = getattr(source, "read", None)
+        if not callable(read):
+            raise TypeError("pacbin member source must be a path or binary file object")
+        yield source
+
+
+def _checked_chunk_size(value: int) -> int:
+    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+        raise PacbinError("pacbin chunk size must be a positive integer")
+    return value
+
+
+def _require_seekable(stream: BinaryIO, label: str) -> None:
+    seekable = getattr(stream, "seekable", None)
+    if not callable(seekable) or not seekable():
+        raise PacbinError(f"{label} must be seekable")
+
+
+def _padding_length(position: int, alignment: int) -> int:
+    return (-position) % alignment
+
+
+def _write_alignment_padding(stream: BinaryIO, alignment: int) -> None:
+    padding = _padding_length(stream.tell(), alignment)
+    if padding:
+        _write_all(stream, b"\x00" * padding, "pacbin payload padding")
+
+
+def _write_hashed(stream: BinaryIO, digest: object, payload: bytes) -> None:
+    _write_all(stream, payload, "pacbin index")
+    digest.update(payload)  # type: ignore[attr-defined]
+
+
+def _write_all(
+    stream: BinaryIO,
+    payload: bytes | bytearray | memoryview,
+    label: str,
+) -> None:
+    view = memoryview(payload)
+    written_total = 0
+    while written_total < len(view):
+        written = stream.write(view[written_total:])
+        if (
+            not isinstance(written, int)
+            or isinstance(written, bool)
+            or written <= 0
+            or written > len(view) - written_total
+        ):
+            raise PacbinError(f"short write while writing {label}")
+        written_total += written
+
+
+def _checked_u64_position(value: int, label: str) -> int:
+    if (
+        not isinstance(value, int)
+        or isinstance(value, bool)
+        or not 0 <= value <= _MAX_U64
+    ):
+        raise PacbinError(f"{label} exceeds u64")
+    return value
+
+
+def _read_exact(stream: BinaryIO, length: int, label: str) -> bytes:
+    remaining = length
+    chunks: list[bytes] = []
+    while remaining:
+        chunk = stream.read(remaining)
+        if not chunk:
+            raise PacbinError(f"truncated {label}")
+        if not isinstance(chunk, bytes | bytearray | memoryview):
+            raise TypeError(f"{label} source must return bytes")
+        if len(chunk) > remaining:
+            raise PacbinError(f"oversized read while reading {label}")
+        chunks.append(bytes(chunk))
+        remaining -= len(chunk)
+    return b"".join(chunks)
+
+
+def _read_index_bytes(
+    stream: BinaryIO,
+    digest: object,
+    length: int,
+    footer_offset: int,
+    label: str,
+) -> bytes:
+    if length < 0 or stream.tell() > footer_offset - length:
+        raise PacbinError(f"truncated {label}")
+    payload = _read_exact(stream, length, label)
+    digest.update(payload)  # type: ignore[attr-defined]
+    return payload
+
+
+def _validate_version_size_flags(
+    label: str,
+    version: int,
+    encoded_size: int,
+    expected_size: int,
+    flags: int,
+) -> None:
+    if version != PACBIN_VERSION:
+        raise PacbinError(f"unsupported pacbin {label} version: {version}")
+    if encoded_size != expected_size:
+        raise PacbinError(f"unsupported pacbin {label} size: {encoded_size}")
+    if flags != _SUPPORTED_FLAGS:
+        raise PacbinError(f"unknown pacbin {label} flags: {flags}")
+
+
+def _validate_canonical_payload_layout(
+    stream: BinaryIO,
+    members: list[PacbinMember],
+    index_offset: int,
+) -> None:
+    expected_offset = _HEADER_STRUCT.size
+    for member in members:
+        if member.length > _MAX_U64 - member.offset:
+            raise PacbinError(
+                f"pacbin member range overflows u64: {member.logical_path}"
+            )
+        unaligned_offset = expected_offset
+        padding_length = _padding_length(unaligned_offset, PACBIN_ALIGNMENT)
+        expected_offset += padding_length
+        if member.offset < expected_offset:
+            raise PacbinError(
+                f"overlapping pacbin member payload: {member.logical_path}"
+            )
+        if member.offset > expected_offset:
+            raise PacbinError(f"non-canonical pacbin member gap: {member.logical_path}")
+        if member.offset % PACBIN_ALIGNMENT:
+            raise PacbinError(f"unaligned pacbin member payload: {member.logical_path}")
+        end = member.offset + member.length
+        if end > index_offset:
+            raise PacbinError(
+                f"pacbin member payload is out of bounds: {member.logical_path}"
+            )
+        if padding_length:
+            stream.seek(unaligned_offset)
+            if _read_exact(stream, padding_length, "pacbin payload padding") != (
+                b"\x00" * padding_length
+            ):
+                raise PacbinError("pacbin payload padding must be zero")
+        expected_offset = end
+
+    payload_end = expected_offset
+    canonical_index_offset = payload_end + _padding_length(
+        payload_end, PACBIN_ALIGNMENT
+    )
+    if canonical_index_offset != index_offset:
+        if canonical_index_offset > index_offset:
+            raise PacbinError("pacbin payloads overlap the index")
+        raise PacbinError("pacbin payload region has a non-canonical trailing gap")
+    padding_length = index_offset - payload_end
+    if padding_length:
+        stream.seek(payload_end)
+        if _read_exact(stream, padding_length, "pacbin payload padding") != (
+            b"\x00" * padding_length
+        ):
+            raise PacbinError("pacbin payload padding must be zero")
+
+
+def _fsync_directory_best_effort(path: Path) -> None:
+    flags = os.O_RDONLY | getattr(os, "O_DIRECTORY", 0)
+    try:
+        descriptor = os.open(path, flags)
+    except OSError:
+        return
+    try:
+        with suppress(OSError):
+            os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+__all__ = [
+    "PACBIN_ALIGNMENT",
+    "PACBIN_VERSION",
+    "PacbinError",
+    "PacbinIndex",
+    "PacbinMember",
+    "PacbinMemberKind",
+    "PacbinMemberSource",
+    "PacbinMemberStream",
+    "PacbinReader",
+    "normalize_logical_path",
+    "write_pacbin",
+    "write_pacbin_atomic",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/fermion_ordering.py b/pyamplicol/src/pyamplicol/generation/fermion_ordering.py
new file mode 100644
index 0000000000..48f9e1c1be
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/fermion_ordering.py
@@ -0,0 +1,246 @@
+# SPDX-License-Identifier: 0BSD
+"""Generation-time external-fermion ordering signs.
+
+Numerical current kernels commute their already-evaluated inputs.  Wick
+contractions do not: every binary current merge must first restore the
+canonical source order of its external fermions, and a two-fermion kernel has
+one additional sign when its oriented inputs are particle--antiparticle rather
+than antiparticle--particle.  Folding this exact ``+/-1`` into the generated
+coefficient realizes the exterior algebra without adding runtime state or
+splitting currents by factorially many Wick lineages.
+
+Color-connected fundamental open lines already carry this ordering in their
+authenticated color-flow construction.  This pass therefore owns only
+color-singlet fermion sources; applying it to fundamental lines would count
+the same exchange sign twice.
+"""
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+from ..models.base import Model
+from ..processes.ir import CanonicalProcessIR
+from .dag_types import CurrentIndex, GenericDAG
+
+
+def _external_fermion_requires_exterior_sign(
+    statistics: str,
+    color_role: str,
+) -> bool:
+    """Classify one canonical source without guessing unsupported color roles."""
+
+    if statistics != "fermion":
+        return False
+    if color_role == "singlet":
+        return True
+    if color_role in {"fundamental", "antifundamental"}:
+        return False
+    raise ValueError(
+        f"external-fermion ordering does not support fermion color role {color_role!r}"
+    )
+
+
+def _fermion_rep_requires_exterior_sign(color_representation: int) -> bool:
+    """Return sign ownership for a model fermion in the supported UFO scope."""
+
+    color_representation = int(color_representation)
+    if color_representation == 1:
+        return True
+    if abs(color_representation) == 3:
+        return False
+    raise ValueError(
+        "external-fermion ordering does not support fermion color "
+        f"representation {color_representation}"
+    )
+
+
+def _external_fermion_support_sign(
+    left_labels: tuple[int, ...],
+    right_labels: tuple[int, ...],
+    fermion_source_ranks: dict[int, int],
+) -> int:
+    """Return the Koszul sign for concatenating two disjoint supports."""
+
+    left_ranks = tuple(
+        fermion_source_ranks[label]
+        for label in left_labels
+        if label in fermion_source_ranks
+    )
+    right_ranks = tuple(
+        fermion_source_ranks[label]
+        for label in right_labels
+        if label in fermion_source_ranks
+    )
+    inversions = sum(
+        left_rank > right_rank for left_rank in left_ranks for right_rank in right_ranks
+    )
+    return -1 if inversions % 2 else 1
+
+
+def _fermion_input_orientation_sign(
+    left_is_fermion: bool,
+    left_orientation: str,
+    left_requires_exterior_sign: bool,
+    right_is_fermion: bool,
+    right_orientation: str,
+    right_requires_exterior_sign: bool,
+) -> int:
+    """Return the field-order sign of one oriented two-fermion kernel."""
+
+    if not (left_is_fermion and right_is_fermion):
+        return 1
+    if left_requires_exterior_sign != right_requires_exterior_sign:
+        raise ValueError(
+            "external-fermion ordering encountered mixed color-sign ownership"
+        )
+    if not left_requires_exterior_sign:
+        return 1
+    supported = {"particle", "antiparticle"}
+    if left_orientation not in supported or right_orientation not in supported:
+        raise ValueError(
+            "external-fermion ordering requires non-self-conjugate model orientations"
+        )
+    pair = (left_orientation, right_orientation)
+    if pair == ("antiparticle", "particle"):
+        return 1
+    if pair == ("particle", "antiparticle"):
+        return -1
+    raise ValueError("external-fermion ordering requires opposite Dirac orientations")
+
+
+class FermionOrderingSign:
+    """Cached model/process contract for cold DAG construction."""
+
+    __slots__ = (
+        "_merge_cache",
+        "_model",
+        "_particle_contract_cache",
+        "_source_ranks",
+    )
+
+    def __init__(self, process: CanonicalProcessIR, model: Model) -> None:
+        self._model = model
+        source_ranks: dict[int, int] = {}
+        for source_slot, leg in enumerate(process.legs):
+            if _external_fermion_requires_exterior_sign(
+                leg.statistics,
+                leg.color_role,
+            ):
+                source_ranks[int(leg.label)] = source_slot
+        self._source_ranks = source_ranks
+        self._particle_contract_cache: dict[int, tuple[bool, str, bool]] = {}
+        self._merge_cache: dict[
+            tuple[tuple[int, ...], tuple[int, ...], int, int], int
+        ] = {}
+
+    @property
+    def active(self) -> bool:
+        """Whether this process has any source whose sign is owned here."""
+
+        return bool(self._source_ranks)
+
+    def _particle_contract(self, particle_id: int) -> tuple[bool, str, bool]:
+        particle_id = int(particle_id)
+        cached = self._particle_contract_cache.get(particle_id)
+        if cached is not None:
+            return cached
+        is_fermion = bool(self._model.is_fermion(particle_id))
+        orientation = (
+            str(self._model.source_orientation(particle_id))
+            if is_fermion
+            else "self-conjugate"
+        )
+        requires_exterior_sign = (
+            _fermion_rep_requires_exterior_sign(self._model.color_rep(particle_id))
+            if is_fermion
+            else False
+        )
+        result = (is_fermion, orientation, requires_exterior_sign)
+        self._particle_contract_cache[particle_id] = result
+        return result
+
+    def merge_sign(self, left: CurrentIndex, right: CurrentIndex) -> int:
+        key = (
+            left.external_labels,
+            right.external_labels,
+            int(left.particle_id),
+            int(right.particle_id),
+        )
+        cached = self._merge_cache.get(key)
+        if cached is not None:
+            return cached
+        (
+            left_is_fermion,
+            left_orientation,
+            left_requires_exterior_sign,
+        ) = self._particle_contract(left.particle_id)
+        (
+            right_is_fermion,
+            right_orientation,
+            right_requires_exterior_sign,
+        ) = self._particle_contract(right.particle_id)
+        sign = _external_fermion_support_sign(
+            left.external_labels,
+            right.external_labels,
+            self._source_ranks,
+        )
+        sign *= _fermion_input_orientation_sign(
+            left_is_fermion,
+            left_orientation,
+            left_requires_exterior_sign,
+            right_is_fermion,
+            right_orientation,
+            right_requires_exterior_sign,
+        )
+        self._merge_cache[key] = sign
+        return sign
+
+
+def apply_fermion_ordering_signs(dag: GenericDAG, model: Model) -> GenericDAG:
+    """Fold every merge sign into existing DAG constants exactly once."""
+
+    if not dag.interactions and not dag.amplitude_roots:
+        return dag
+    ordering = FermionOrderingSign(dag.process, model)
+    if not ordering.active:
+        return dag
+    currents = dag.currents
+
+    def signed_weight(
+        weight: tuple[float, float], left_id: int, right_id: int
+    ) -> tuple[float, float]:
+        sign = ordering.merge_sign(
+            currents[left_id].index,
+            currents[right_id].index,
+        )
+        return weight if sign == 1 else (-weight[0], -weight[1])
+
+    def signed_interaction(interaction):
+        color_weight = signed_weight(
+            interaction.color_weight,
+            interaction.left_id,
+            interaction.right_id,
+        )
+        if color_weight is interaction.color_weight:
+            return interaction
+        return replace(interaction, color_weight=color_weight)
+
+    def signed_root(root):
+        color_weight = signed_weight(
+            root.color_weight,
+            root.left_id,
+            root.right_id,
+        )
+        if color_weight is root.color_weight:
+            return root
+        return replace(root, color_weight=color_weight)
+
+    return replace(
+        dag,
+        interactions=tuple(signed_interaction(row) for row in dag.interactions),
+        amplitude_roots=tuple(signed_root(row) for row in dag.amplitude_roots),
+    )
+
+
+__all__ = ["FermionOrderingSign", "apply_fermion_ordering_signs"]
diff --git a/pyamplicol/src/pyamplicol/generation/helicity_materialization.py b/pyamplicol/src/pyamplicol/generation/helicity_materialization.py
new file mode 100644
index 0000000000..bfa7456cea
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/helicity_materialization.py
@@ -0,0 +1,652 @@
+# SPDX-License-Identifier: 0BSD
+"""Materialize one compiled recurrence representative per helicity proof class."""
+
+from __future__ import annotations
+
+import math
+from collections import defaultdict
+from collections.abc import Mapping
+from dataclasses import dataclass, replace
+
+from .dag_types import AmplitudeRoot, GenericDAG, InteractionNode
+from .helicity_replay import HelicityRecurrencePlan
+
+_Weight = tuple[float, float]
+
+
+@dataclass(frozen=True, slots=True)
+class MaterializedSourceRoute:
+    materialized_current_id: int
+    external_label: int
+    helicity: int
+    chirality: int
+    spin_state: int | tuple[int, ...]
+    declared_state_index: int
+    selector_domain_id: int
+    factor: _Weight
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        spin_state: object = self.spin_state
+        if isinstance(spin_state, tuple):
+            spin_state = list(spin_state)
+        return {
+            "materialized_current_id": self.materialized_current_id,
+            "external_label": self.external_label,
+            "helicity": self.helicity,
+            "chirality": self.chirality,
+            "spin_state": spin_state,
+            "declared_state_index": self.declared_state_index,
+            "selector_domain_id": self.selector_domain_id,
+            "factor": list(self.factor),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class MaterializedAmplitudeRoute:
+    materialized_root_id: int
+    selector_domain_ids: tuple[int, ...]
+    factor: _Weight
+    residual: bool = False
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        return {
+            "materialized_root_id": self.materialized_root_id,
+            "selector_domain_ids": list(self.selector_domain_ids),
+            "factor": list(self.factor),
+            "residual": self.residual,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class MaterializedSelectorSchedule:
+    selector_domain_id: int
+    active_current_ids: tuple[int, ...]
+    active_root_ids: tuple[int, ...]
+    structural_zero: bool
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        return {
+            "selector_domain_id": self.selector_domain_id,
+            "active_current_ids": list(self.active_current_ids),
+            "active_root_ids": list(self.active_root_ids),
+            "structural_zero": self.structural_zero,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class HelicityMaterialization:
+    strategy: str
+    dag: GenericDAG
+    proof_current_count: int
+    proof_root_count: int
+    proof_to_materialized_current: tuple[int, ...]
+    source_routes: tuple[MaterializedSourceRoute, ...]
+    amplitude_routes: tuple[MaterializedAmplitudeRoute, ...]
+    selector_schedules: tuple[MaterializedSelectorSchedule, ...]
+
+    @property
+    def materialized_current_count(self) -> int:
+        return len(self.dag.currents)
+
+    @property
+    def materialized_root_count(self) -> int:
+        return len(self.dag.amplitude_roots)
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        return {
+            "kind": "pyamplicol-helicity-recurrence-materialization",
+            "contract_version": 1,
+            "strategy": self.strategy,
+            "proof_current_count": self.proof_current_count,
+            "proof_root_count": self.proof_root_count,
+            "materialized_current_count": self.materialized_current_count,
+            "materialized_root_count": self.materialized_root_count,
+            "proof_to_materialized_current": list(self.proof_to_materialized_current),
+            "source_routes": [
+                route.to_runtime_manifest() for route in self.source_routes
+            ],
+            "amplitude_routes": [
+                route.to_runtime_manifest() for route in self.amplitude_routes
+            ],
+            "selector_schedules": [
+                schedule.to_runtime_manifest() for schedule in self.selector_schedules
+            ],
+        }
+
+
+def materialize_helicity_recurrence(
+    dag: GenericDAG,
+    plan: HelicityRecurrencePlan,
+) -> HelicityMaterialization:
+    """Build the quotient DAG certified by ``plan``.
+
+    Every proven recurrence class contributes exactly one current. Residual
+    currents remain one-to-one. Parent recurrence factors are folded into the
+    remapped interaction coefficient, so compiled kernels see ordinary current
+    slots and require no selector-dependent branches.
+    """
+
+    if plan.current_count != len(dag.currents):
+        raise ValueError("helicity proof current count does not match the DAG")
+    if plan.amplitude_root_count != len(dag.amplitude_roots):
+        raise ValueError("helicity proof root count does not match the DAG")
+
+    class_by_current: dict[int, tuple[object, _Weight]] = {}
+    representative_factor_by_class: dict[str, _Weight] = {}
+    target_old_ids: set[int] = set(plan.residual_current_ids)
+    for recurrence in plan.recurrence_classes:
+        representative = next(
+            member
+            for member in recurrence.members
+            if member.current_id == recurrence.representative_current_id
+        )
+        representative_factor_by_class[recurrence.class_id] = representative.factor
+        target_old_ids.add(recurrence.representative_current_id)
+        for member in recurrence.members:
+            class_by_current[member.current_id] = (recurrence, member.factor)
+
+    target_order = tuple(
+        sorted(
+            target_old_ids,
+            key=lambda current_id: (
+                len(dag.currents[current_id].index.external_labels),
+                current_id,
+            ),
+        )
+    )
+    target_new_id = {old_id: new_id for new_id, old_id in enumerate(target_order)}
+
+    proof_to_materialized: list[int] = [-1] * len(dag.currents)
+    factor_by_proof_current: list[_Weight] = [(1.0, 0.0)] * len(dag.currents)
+    materialized_factor_by_proof_current: list[_Weight] = [(1.0, 0.0)] * len(
+        dag.currents
+    )
+    residual_ids = set(plan.residual_current_ids)
+    for current in dag.currents:
+        if current.id in residual_ids:
+            proof_to_materialized[current.id] = target_new_id[current.id]
+            continue
+        recurrence, factor = class_by_current[current.id]
+        representative_id = recurrence.representative_current_id
+        proof_to_materialized[current.id] = target_new_id[representative_id]
+        factor_by_proof_current[current.id] = factor
+        materialized_factor_by_proof_current[current.id] = (
+            representative_factor_by_class[recurrence.class_id]
+        )
+    if any(current_id < 0 for current_id in proof_to_materialized):
+        raise ValueError("helicity quotient left a proof current unmapped")
+
+    currents = tuple(
+        replace(dag.currents[old_id], id=new_id)
+        for new_id, old_id in enumerate(target_order)
+    )
+    interactions_by_result: dict[int, list[InteractionNode]] = defaultdict(list)
+    for interaction in dag.interactions:
+        interactions_by_result[interaction.result_id].append(interaction)
+    interactions: list[InteractionNode] = []
+    for old_result_id in target_order:
+        new_result_id = target_new_id[old_result_id]
+        for interaction in interactions_by_result[old_result_id]:
+            left_ratio = _divide_weight(
+                factor_by_proof_current[interaction.left_id],
+                materialized_factor_by_proof_current[interaction.left_id],
+            )
+            right_ratio = _divide_weight(
+                factor_by_proof_current[interaction.right_id],
+                materialized_factor_by_proof_current[interaction.right_id],
+            )
+            interactions.append(
+                replace(
+                    interaction,
+                    id=len(interactions),
+                    left_id=proof_to_materialized[interaction.left_id],
+                    right_id=proof_to_materialized[interaction.right_id],
+                    result_id=new_result_id,
+                    color_weight=_multiply_weight(
+                        interaction.color_weight,
+                        _multiply_weight(left_ratio, right_ratio),
+                    ),
+                )
+            )
+
+    roots: list[AmplitudeRoot] = []
+    amplitude_routes: list[MaterializedAmplitudeRoute] = []
+    retained_roots: list[tuple[AmplitudeRoot, object | None]] = []
+    for recurrence in plan.amplitude_classes:
+        representative = next(
+            member
+            for member in recurrence.members
+            if member.root_id == recurrence.representative_root_id
+        )
+        retained_roots.append(
+            (dag.amplitude_roots[recurrence.representative_root_id], recurrence)
+        )
+        materialized_root_id = len(retained_roots) - 1
+        for member in recurrence.members:
+            amplitude_routes.append(
+                MaterializedAmplitudeRoute(
+                    materialized_root_id=materialized_root_id,
+                    selector_domain_ids=member.selector_domain_ids,
+                    factor=_divide_weight(member.factor, representative.factor),
+                )
+            )
+    for root_id in plan.residual_root_ids:
+        retained_roots.append((dag.amplitude_roots[root_id], None))
+
+    domain_by_state = {
+        domain.source_states: domain.id for domain in plan.selector_domains
+    }
+    source_state_by_bit = _source_state_by_ancestry_bit(dag)
+    for root, recurrence in retained_roots:
+        left_ratio = _divide_weight(
+            factor_by_proof_current[root.left_id],
+            materialized_factor_by_proof_current[root.left_id],
+        )
+        right_ratio = _divide_weight(
+            factor_by_proof_current[root.right_id],
+            materialized_factor_by_proof_current[root.right_id],
+        )
+        materialized_root_id = len(roots)
+        roots.append(
+            replace(
+                root,
+                id=materialized_root_id,
+                left_id=proof_to_materialized[root.left_id],
+                right_id=proof_to_materialized[root.right_id],
+                color_weight=_multiply_weight(
+                    root.color_weight,
+                    _multiply_weight(left_ratio, right_ratio),
+                ),
+                helicity_weight=1.0,
+            )
+        )
+        if recurrence is None:
+            selector_states = _residual_root_selector_states(
+                dag,
+                root,
+                source_state_by_bit,
+            )
+            selector_domain_ids = tuple(
+                domain_by_state[state]
+                for state in selector_states
+                if state in domain_by_state
+            )
+            if len(selector_domain_ids) != len(selector_states):
+                raise ValueError(
+                    "residual amplitude root has no runtime selector domain"
+                )
+            amplitude_routes.append(
+                MaterializedAmplitudeRoute(
+                    materialized_root_id=materialized_root_id,
+                    selector_domain_ids=selector_domain_ids,
+                    factor=(1.0, 0.0),
+                    residual=True,
+                )
+            )
+
+    source_routes: list[MaterializedSourceRoute] = []
+    for mapping in plan.source_state_mappings:
+        recurrence, _factor = class_by_current[mapping.current_id]
+        representative_factor = representative_factor_by_class[recurrence.class_id]
+        source_routes.append(
+            MaterializedSourceRoute(
+                materialized_current_id=proof_to_materialized[mapping.current_id],
+                external_label=mapping.external_label,
+                helicity=mapping.helicity,
+                chirality=mapping.chirality,
+                spin_state=mapping.spin_state,
+                declared_state_index=mapping.declared_state_index,
+                selector_domain_id=mapping.selector_domain_id,
+                factor=_divide_weight(mapping.factor, representative_factor),
+            )
+        )
+
+    materialized = GenericDAG(
+        process=dag.process,
+        color_plan=dag.color_plan,
+        currents=currents,
+        sources=tuple(
+            target_new_id[old_id]
+            for old_id in target_order
+            if dag.currents[old_id].is_source
+        ),
+        interactions=tuple(interactions),
+        amplitude_roots=tuple(roots),
+        truncated=dag.truncated,
+        helicity_coverage=dag.helicity_coverage,
+        color_coverage=dag.color_coverage,
+        selected_source_helicities=dag.selected_source_helicities,
+        selected_color_sector_ids=dag.selected_color_sector_ids,
+        lc_topology_replay=dag.lc_topology_replay,
+        color_topology_replay=dag.color_topology_replay,
+    )
+    routes_by_domain: dict[int, set[int]] = defaultdict(set)
+    for route in amplitude_routes:
+        for domain_id in route.selector_domain_ids:
+            routes_by_domain[domain_id].add(route.materialized_root_id)
+    interactions_by_materialized_result: dict[int, list[InteractionNode]] = defaultdict(
+        list
+    )
+    for interaction in interactions:
+        interactions_by_materialized_result[interaction.result_id].append(interaction)
+    compiled_dependencies = _compiled_representative_dependencies(materialized)
+    structural_zeros = set(plan.structural_zero_selector_domain_ids)
+    selector_schedules: list[MaterializedSelectorSchedule] = []
+    for domain in plan.selector_domains:
+        if not domain.complete:
+            continue
+        active_roots = tuple(sorted(routes_by_domain.get(domain.id, set())))
+        active_currents = _active_current_closure(
+            materialized,
+            active_roots,
+            interactions_by_materialized_result,
+            compiled_dependencies=compiled_dependencies,
+        )
+        structural_zero = domain.id in structural_zeros
+        if structural_zero != (not active_roots):
+            raise ValueError(
+                "helicity selector schedule disagrees with structural-zero proof"
+            )
+        selector_schedules.append(
+            MaterializedSelectorSchedule(
+                selector_domain_id=domain.id,
+                active_current_ids=active_currents,
+                active_root_ids=active_roots,
+                structural_zero=structural_zero,
+            )
+        )
+    return HelicityMaterialization(
+        strategy="quotient",
+        dag=materialized,
+        proof_current_count=len(dag.currents),
+        proof_root_count=len(dag.amplitude_roots),
+        proof_to_materialized_current=tuple(proof_to_materialized),
+        source_routes=tuple(source_routes),
+        amplitude_routes=tuple(amplitude_routes),
+        selector_schedules=tuple(selector_schedules),
+    )
+
+
+def retain_helicity_recurrence_graph(
+    dag: GenericDAG,
+    plan: HelicityRecurrencePlan,
+) -> HelicityMaterialization:
+    """Attach selector schedules while retaining the shared proof DAG.
+
+    Compiled summed-helicity execution benefits from common subexpressions
+    between physical helicities.  Quotienting the graph to one current per
+    recurrence class removes that sharing and requires repeated evaluator
+    calls.  This form keeps every proof current for the fused summed-axis hot
+    path, while selector schedules identify the exact chunk closure needed by
+    a runtime-selected helicity.
+    """
+
+    if plan.current_count != len(dag.currents):
+        raise ValueError("helicity proof current count does not match the DAG")
+    if plan.amplitude_root_count != len(dag.amplitude_roots):
+        raise ValueError("helicity proof root count does not match the DAG")
+
+    amplitude_routes: list[MaterializedAmplitudeRoute] = []
+    routed_root_ids: set[int] = set()
+    for recurrence in plan.amplitude_classes:
+        for member in recurrence.members:
+            if member.root_id in routed_root_ids:
+                raise ValueError("helicity proof amplitude root is routed twice")
+            routed_root_ids.add(member.root_id)
+            root_weight = float(dag.amplitude_roots[member.root_id].helicity_weight)
+            if not math.isfinite(root_weight) or root_weight <= 0.0:
+                raise ValueError(
+                    "retained amplitude root has an invalid helicity weight"
+                )
+            amplitude_routes.append(
+                MaterializedAmplitudeRoute(
+                    materialized_root_id=member.root_id,
+                    selector_domain_ids=member.selector_domain_ids,
+                    # The fused sum keeps the root's physical-helicity weight.
+                    # Selecting one member must remove that multiplicity before
+                    # the amplitude is squared.
+                    factor=(1.0 / math.sqrt(root_weight), 0.0),
+                )
+            )
+
+    domain_by_state = {
+        domain.source_states: domain.id for domain in plan.selector_domains
+    }
+    source_state_by_bit = _source_state_by_ancestry_bit(dag)
+    for root_id in plan.residual_root_ids:
+        if root_id in routed_root_ids:
+            raise ValueError("residual amplitude root is also proof-routed")
+        root = dag.amplitude_roots[root_id]
+        selector_states = _residual_root_selector_states(
+            dag,
+            root,
+            source_state_by_bit,
+        )
+        selector_domain_ids = tuple(
+            domain_by_state[state]
+            for state in selector_states
+            if state in domain_by_state
+        )
+        if len(selector_domain_ids) != len(selector_states):
+            raise ValueError("residual amplitude root has no runtime selector domain")
+        routed_root_ids.add(root_id)
+        root_weight = float(root.helicity_weight)
+        if not math.isfinite(root_weight) or root_weight <= 0.0:
+            raise ValueError("retained residual root has an invalid helicity weight")
+        amplitude_routes.append(
+            MaterializedAmplitudeRoute(
+                materialized_root_id=root_id,
+                selector_domain_ids=selector_domain_ids,
+                factor=(1.0 / math.sqrt(root_weight), 0.0),
+                residual=True,
+            )
+        )
+    if routed_root_ids != set(range(len(dag.amplitude_roots))):
+        raise ValueError("helicity proof does not route every retained amplitude root")
+
+    source_routes = tuple(
+        MaterializedSourceRoute(
+            materialized_current_id=mapping.current_id,
+            external_label=mapping.external_label,
+            helicity=mapping.helicity,
+            chirality=mapping.chirality,
+            spin_state=mapping.spin_state,
+            declared_state_index=mapping.declared_state_index,
+            selector_domain_id=mapping.selector_domain_id,
+            factor=(1.0, 0.0),
+        )
+        for mapping in plan.source_state_mappings
+    )
+
+    routes_by_domain: dict[int, set[int]] = defaultdict(set)
+    for route in amplitude_routes:
+        for domain_id in route.selector_domain_ids:
+            routes_by_domain[domain_id].add(route.materialized_root_id)
+    interactions_by_result: dict[int, list[InteractionNode]] = defaultdict(list)
+    for interaction in dag.interactions:
+        interactions_by_result[interaction.result_id].append(interaction)
+    compiled_dependencies = _compiled_representative_dependencies(dag)
+    structural_zeros = set(plan.structural_zero_selector_domain_ids)
+    selector_schedules: list[MaterializedSelectorSchedule] = []
+    for domain in plan.selector_domains:
+        if not domain.complete:
+            continue
+        active_roots = tuple(sorted(routes_by_domain.get(domain.id, set())))
+        active_currents = _active_current_closure(
+            dag,
+            active_roots,
+            interactions_by_result,
+            compiled_dependencies=compiled_dependencies,
+        )
+        structural_zero = domain.id in structural_zeros
+        if structural_zero != (not active_roots):
+            raise ValueError(
+                "helicity selector schedule disagrees with structural-zero proof"
+            )
+        selector_schedules.append(
+            MaterializedSelectorSchedule(
+                selector_domain_id=domain.id,
+                active_current_ids=active_currents,
+                active_root_ids=active_roots,
+                structural_zero=structural_zero,
+            )
+        )
+
+    return HelicityMaterialization(
+        strategy="retained-proof-graph",
+        dag=dag,
+        proof_current_count=len(dag.currents),
+        proof_root_count=len(dag.amplitude_roots),
+        proof_to_materialized_current=tuple(range(len(dag.currents))),
+        source_routes=source_routes,
+        amplitude_routes=tuple(
+            sorted(amplitude_routes, key=lambda route: route.materialized_root_id)
+        ),
+        selector_schedules=tuple(selector_schedules),
+    )
+
+
+def _active_current_closure(
+    dag: GenericDAG,
+    root_ids: tuple[int, ...],
+    interactions_by_result: dict[int, list[InteractionNode]],
+    *,
+    compiled_dependencies: Mapping[int, tuple[int, ...]] | None = None,
+) -> tuple[int, ...]:
+    active: set[int] = set()
+    pending: list[int] = []
+    for root_id in root_ids:
+        root = dag.amplitude_roots[root_id]
+        pending.extend((root.left_id, root.right_id))
+    while pending:
+        current_id = pending.pop()
+        if current_id in active:
+            continue
+        active.add(current_id)
+        for interaction in interactions_by_result.get(current_id, ()):
+            pending.extend((interaction.left_id, interaction.right_id))
+        if compiled_dependencies is not None:
+            pending.extend(compiled_dependencies.get(current_id, ()))
+    return tuple(sorted(active))
+
+
+def _compiled_representative_dependencies(
+    dag: GenericDAG,
+) -> dict[int, tuple[int, ...]]:
+    """Return the concrete parents read after evaluation-group reuse.
+
+    A compiled stage caches the first interaction in each evaluation group and
+    reuses that expression for later group members. Selector schedules must
+    therefore retain the representative interaction's parents in addition to
+    each current's physical DAG parents.
+    """
+
+    interactions_by_stage: dict[int, dict[int, list[InteractionNode]]] = {}
+    for interaction in dag.interactions:
+        result_id = int(interaction.result_id)
+        subset_size = len(dag.currents[result_id].index.external_labels)
+        interactions_by_stage.setdefault(subset_size, {}).setdefault(
+            result_id, []
+        ).append(interaction)
+
+    dependencies: dict[int, set[int]] = {}
+    for results in interactions_by_stage.values():
+        representative_by_group: dict[int, InteractionNode] = {}
+        for result_id in sorted(results):
+            for interaction in results[result_id]:
+                group_id = interaction.evaluation_group_id
+                representative = interaction
+                if group_id is not None:
+                    representative = representative_by_group.setdefault(
+                        int(group_id), interaction
+                    )
+                dependencies.setdefault(result_id, set()).update(
+                    (int(representative.left_id), int(representative.right_id))
+                )
+    return {
+        current_id: tuple(sorted(parent_ids))
+        for current_id, parent_ids in dependencies.items()
+    }
+
+
+def _source_state_by_ancestry_bit(
+    dag: GenericDAG,
+) -> dict[int, tuple[int, int]]:
+    result: dict[int, tuple[int, int]] = {}
+    for current in dag.currents:
+        if not current.is_source:
+            continue
+        ancestry = int(current.index.helicity_ancestry)
+        if ancestry <= 0 or ancestry & (ancestry - 1):
+            continue
+        if current.source_leg_label is None or current.source_helicity is None:
+            continue
+        result[ancestry.bit_length() - 1] = (
+            int(current.source_leg_label),
+            int(current.source_helicity),
+        )
+    return result
+
+
+def _root_selector_state(
+    dag: GenericDAG,
+    root: AmplitudeRoot,
+    source_state_by_bit: dict[int, tuple[int, int]],
+) -> tuple[tuple[int, int], ...]:
+    ancestry = int(
+        dag.currents[root.left_id].index.helicity_ancestry
+        | dag.currents[root.right_id].index.helicity_ancestry
+    )
+    state: dict[int, int] = {}
+    while ancestry:
+        bit = ancestry & -ancestry
+        selector = source_state_by_bit.get(bit.bit_length() - 1)
+        if selector is None:
+            raise ValueError("residual root has an unknown source ancestry bit")
+        label, helicity = selector
+        previous = state.setdefault(label, helicity)
+        if previous != helicity:
+            raise ValueError("residual root selects two helicities for one leg")
+        ancestry ^= bit
+    return tuple(sorted(state.items()))
+
+
+def _residual_root_selector_states(
+    dag: GenericDAG,
+    root: AmplitudeRoot,
+    source_state_by_bit: dict[int, tuple[int, int]],
+) -> tuple[tuple[tuple[int, int], ...], ...]:
+    selector_state = _root_selector_state(dag, root, source_state_by_bit)
+    selector_states = [selector_state]
+    if math.isclose(root.helicity_weight, 2.0, rel_tol=1.0e-12, abs_tol=1.0e-12):
+        flipped = tuple((label, -helicity) for label, helicity in selector_state)
+        if flipped != selector_state:
+            selector_states.append(flipped)
+    elif not math.isclose(
+        root.helicity_weight,
+        1.0,
+        rel_tol=1.0e-12,
+        abs_tol=1.0e-12,
+    ):
+        raise ValueError(
+            "residual amplitude root has unsupported helicity multiplicity "
+            f"{root.helicity_weight}"
+        )
+    return tuple(selector_states)
+
+
+def _multiply_weight(left: _Weight, right: _Weight) -> _Weight:
+    value = complex(*left) * complex(*right)
+    if not math.isfinite(value.real) or not math.isfinite(value.imag):
+        raise ValueError("helicity replay produced a non-finite weight")
+    return (float(value.real), float(value.imag))
+
+
+def _divide_weight(numerator: _Weight, denominator: _Weight) -> _Weight:
+    denominator_value = complex(*denominator)
+    if denominator_value == 0j:
+        raise ValueError("helicity replay representative factor is zero")
+    value = complex(*numerator) / denominator_value
+    if not math.isfinite(value.real) or not math.isfinite(value.imag):
+        raise ValueError("helicity replay produced a non-finite factor ratio")
+    return (float(value.real), float(value.imag))
diff --git a/pyamplicol/src/pyamplicol/generation/helicity_replay.py b/pyamplicol/src/pyamplicol/generation/helicity_replay.py
new file mode 100644
index 0000000000..96f7277c61
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/helicity_replay.py
@@ -0,0 +1,1330 @@
+# SPDX-License-Identifier: 0BSD
+"""Proof-gated reusable-helicity recurrence metadata.
+
+This module derives the model-generic contract describing which currents have
+the same recurrence shape once runtime source states are treated as inputs.
+Compiled generation retains the shared summed-helicity graph and attaches the
+certified selector closures to it. Rusticol routes explicit runtime helicity
+selectors through those closures; independently unproven currents remain
+localized residuals rather than disabling proven reuse classes.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections import defaultdict
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from itertools import product
+from math import fsum
+from typing import TypeAlias
+
+from ..models.base import Model
+from .contracts import runtime_coupling_parameter_names
+from .dag_types import AmplitudeRoot, CurrentNode, GenericDAG, InteractionNode
+
+HELICITY_RECURRENCE_CONTRACT_VERSION = 1
+HELICITY_RECURRENCE_PROOF_ALGORITHM = (
+    "canonical-source-transition-dependency-shape-v1"
+)
+RUNTIME_SELECTOR_PROVENANCE = "pyamplicol-runtime-selectors-v1"
+
+_ComplexWeight: TypeAlias = tuple[float, float]
+_SelectorState: TypeAlias = tuple[tuple[int, int], ...]
+_ColorSectorAliases: TypeAlias = Mapping[int, int]
+
+
+@dataclass(frozen=True, slots=True)
+class HelicitySelectorDomain:
+    """One partial or complete assignment of external source helicities."""
+
+    id: int
+    source_states: _SelectorState
+    complete: bool
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "complete": self.complete,
+            "source_states": [
+                {"external_label": label, "helicity": helicity}
+                for label, helicity in self.source_states
+            ],
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class HelicityCurrentReplayMember:
+    current_id: int
+    selector_domain_id: int
+    factor: _ComplexWeight = (1.0, 0.0)
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        return {
+            "current_id": self.current_id,
+            "selector_domain_id": self.selector_domain_id,
+            "factor": list(self.factor),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class HelicityRecurrenceClass:
+    """Currents sharing one exact source/transition dependency shape."""
+
+    class_id: str
+    representative_current_id: int
+    external_labels: tuple[int, ...]
+    source_class: bool
+    members: tuple[HelicityCurrentReplayMember, ...]
+    proof_digest: str
+    transition_contract_ids: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        if not self.class_id:
+            raise ValueError("helicity recurrence class id must not be empty")
+        if not self.members:
+            raise ValueError("helicity recurrence class must have members")
+        if self.representative_current_id not in {
+            member.current_id for member in self.members
+        }:
+            raise ValueError("helicity recurrence representative is not a member")
+        _validate_digest(self.proof_digest, context="helicity recurrence proof")
+
+    @property
+    def optimized(self) -> bool:
+        return len(self.members) > 1
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        return {
+            "class_id": self.class_id,
+            "representative_current_id": self.representative_current_id,
+            "external_labels": list(self.external_labels),
+            "source_class": self.source_class,
+            "members": [member.to_runtime_manifest() for member in self.members],
+            "proof": {
+                "status": "proven",
+                "algorithm": HELICITY_RECURRENCE_PROOF_ALGORITHM,
+                "digest": self.proof_digest,
+                "transition_contract_ids": list(self.transition_contract_ids),
+            },
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class HelicitySourceStateMapping:
+    current_id: int
+    external_label: int
+    helicity: int
+    chirality: int
+    spin_state: int | tuple[int, ...]
+    declared_state_index: int
+    selector_domain_id: int
+    recurrence_class_id: str
+    representative_current_id: int
+    source_contract_digest: str
+    factor: _ComplexWeight = (1.0, 0.0)
+
+    def __post_init__(self) -> None:
+        _validate_digest(
+            self.source_contract_digest,
+            context="helicity source contract",
+        )
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        spin_state: object = self.spin_state
+        if isinstance(spin_state, tuple):
+            spin_state = list(spin_state)
+        return {
+            "current_id": self.current_id,
+            "external_label": self.external_label,
+            "helicity": self.helicity,
+            "chirality": self.chirality,
+            "spin_state": spin_state,
+            "declared_state_index": self.declared_state_index,
+            "selector_domain_id": self.selector_domain_id,
+            "recurrence_class_id": self.recurrence_class_id,
+            "representative_current_id": self.representative_current_id,
+            "source_contract_digest": self.source_contract_digest,
+            "factor": list(self.factor),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class HelicityAmplitudeReplayMember:
+    root_id: int
+    selector_domain_ids: tuple[int, ...]
+    factor: _ComplexWeight = (1.0, 0.0)
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        return {
+            "root_id": self.root_id,
+            "selector_domain_ids": list(self.selector_domain_ids),
+            "factor": list(self.factor),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class HelicityAmplitudeReplayClass:
+    class_id: str
+    representative_root_id: int
+    members: tuple[HelicityAmplitudeReplayMember, ...]
+    proof_digest: str
+    transition_contract_ids: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        if not self.members:
+            raise ValueError("helicity amplitude recurrence class must have members")
+        if self.representative_root_id not in {
+            member.root_id for member in self.members
+        }:
+            raise ValueError("helicity amplitude representative is not a member")
+        _validate_digest(self.proof_digest, context="helicity amplitude proof")
+
+    @property
+    def optimized(self) -> bool:
+        return len(self.members) > 1
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        return {
+            "class_id": self.class_id,
+            "representative_root_id": self.representative_root_id,
+            "members": [member.to_runtime_manifest() for member in self.members],
+            "proof": {
+                "status": "proven",
+                "algorithm": HELICITY_RECURRENCE_PROOF_ALGORITHM,
+                "digest": self.proof_digest,
+                "transition_contract_ids": list(self.transition_contract_ids),
+            },
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class HelicityRecurrencePlan:
+    """Strict additive contract for reusable complete-helicity artifacts."""
+
+    current_count: int
+    amplitude_root_count: int
+    selector_domains: tuple[HelicitySelectorDomain, ...]
+    source_state_mappings: tuple[HelicitySourceStateMapping, ...]
+    recurrence_classes: tuple[HelicityRecurrenceClass, ...]
+    amplitude_classes: tuple[HelicityAmplitudeReplayClass, ...]
+    residual_current_ids: tuple[int, ...]
+    residual_root_ids: tuple[int, ...]
+    structural_zero_selector_domain_ids: tuple[int, ...]
+    diagnostics: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.current_count < 0 or self.amplitude_root_count < 0:
+            raise ValueError("helicity recurrence object counts must be nonnegative")
+        domain_ids = tuple(domain.id for domain in self.selector_domains)
+        if domain_ids != tuple(range(len(domain_ids))):
+            raise ValueError("helicity selector domain ids must be contiguous")
+        known_domains = set(domain_ids)
+        referenced_domains = {
+            member.selector_domain_id
+            for recurrence in self.recurrence_classes
+            for member in recurrence.members
+        } | {
+            domain_id
+            for recurrence in self.amplitude_classes
+            for member in recurrence.members
+            for domain_id in member.selector_domain_ids
+        } | set(self.structural_zero_selector_domain_ids)
+        if not referenced_domains <= known_domains:
+            raise ValueError("helicity replay references an unknown selector domain")
+        class_current_ids = {
+            member.current_id
+            for recurrence in self.recurrence_classes
+            for member in recurrence.members
+        }
+        if class_current_ids & set(self.residual_current_ids):
+            raise ValueError("helicity recurrence classes overlap residual currents")
+        if class_current_ids | set(self.residual_current_ids) != set(
+            range(self.current_count)
+        ):
+            raise ValueError(
+                "helicity recurrence current ids do not cover the final dense DAG"
+            )
+        class_root_ids = {
+            member.root_id
+            for recurrence in self.amplitude_classes
+            for member in recurrence.members
+        }
+        if class_root_ids & set(self.residual_root_ids):
+            raise ValueError("helicity amplitude classes overlap residual roots")
+        if class_root_ids | set(self.residual_root_ids) != set(
+            range(self.amplitude_root_count)
+        ):
+            raise ValueError(
+                "helicity recurrence root ids do not cover the final dense DAG"
+            )
+        source_ids = {mapping.current_id for mapping in self.source_state_mappings}
+        if not source_ids <= class_current_ids:
+            raise ValueError("helicity source mapping refers to a residual current")
+
+    @property
+    def optimized_class_count(self) -> int:
+        return sum(item.optimized for item in self.recurrence_classes)
+
+    @property
+    def optimized_current_count(self) -> int:
+        return sum(
+            len(item.members) for item in self.recurrence_classes if item.optimized
+        )
+
+    @property
+    def optimized_amplitude_class_count(self) -> int:
+        return sum(item.optimized for item in self.amplitude_classes)
+
+    @property
+    def physical_helicity_count(self) -> int:
+        return sum(domain.complete for domain in self.selector_domains)
+
+    def proof_counts(self) -> dict[str, int]:
+        return {
+            "recurrence_class_count": len(self.recurrence_classes),
+            "optimized_recurrence_class_count": self.optimized_class_count,
+            "optimized_current_count": self.optimized_current_count,
+            "residual_current_count": len(self.residual_current_ids),
+            "amplitude_class_count": len(self.amplitude_classes),
+            "optimized_amplitude_class_count": (
+                self.optimized_amplitude_class_count
+            ),
+            "residual_amplitude_count": len(self.residual_root_ids),
+            "source_state_mapping_count": len(self.source_state_mappings),
+            "physical_helicity_count": self.physical_helicity_count,
+            "structural_zero_helicity_count": len(
+                self.structural_zero_selector_domain_ids
+            ),
+        }
+
+    def to_json_dict(self) -> dict[str, object]:
+        return self.to_runtime_manifest()
+
+    def to_runtime_manifest(self) -> dict[str, object]:
+        return {
+            "kind": "pyamplicol-helicity-recurrence",
+            "contract_version": HELICITY_RECURRENCE_CONTRACT_VERSION,
+            "proof_algorithm": HELICITY_RECURRENCE_PROOF_ALGORITHM,
+            "current_count": self.current_count,
+            "amplitude_root_count": self.amplitude_root_count,
+            "proof_counts": self.proof_counts(),
+            "selector_domains": [
+                domain.to_runtime_manifest() for domain in self.selector_domains
+            ],
+            "source_state_mappings": [
+                mapping.to_runtime_manifest()
+                for mapping in self.source_state_mappings
+            ],
+            "recurrence_classes": [
+                recurrence.to_runtime_manifest()
+                for recurrence in self.recurrence_classes
+            ],
+            "amplitude_classes": [
+                recurrence.to_runtime_manifest()
+                for recurrence in self.amplitude_classes
+            ],
+            "residual_current_ids": list(self.residual_current_ids),
+            "residual_root_ids": list(self.residual_root_ids),
+            "structural_zero_selector_domain_ids": list(
+                self.structural_zero_selector_domain_ids
+            ),
+            "diagnostics": list(self.diagnostics),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class _CurrentProof:
+    class_index: int | None
+    factor: _ComplexWeight
+    selector_state: _SelectorState
+    residual_reason: str | None = None
+
+
+@dataclass(slots=True)
+class _PendingCurrentClass:
+    class_id: str
+    representative_current_id: int
+    external_labels: tuple[int, ...]
+    source_class: bool
+    proof_digest: str
+    transition_contract_ids: tuple[str, ...]
+    members: list[tuple[int, _SelectorState, _ComplexWeight]]
+
+
+@dataclass(slots=True)
+class _PendingAmplitudeClass:
+    class_id: str
+    representative_root_id: int
+    proof_digest: str
+    transition_contract_ids: tuple[str, ...]
+    members: list[tuple[int, tuple[_SelectorState, ...], _ComplexWeight]]
+
+
+@dataclass(frozen=True, slots=True)
+class _SemanticAmplitudeRootSignature:
+    """Exact model-certified identity used only for construction aliases."""
+
+    proof_digest: str
+    selector_states: tuple[_SelectorState, ...]
+    factor: _ComplexWeight
+
+
+def _derive_current_replay_proofs(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    color_sector_aliases: _ColorSectorAliases | None = None,
+) -> tuple[
+    dict[int, tuple[int, int]],
+    dict[int, dict[str, object]],
+    list[_PendingCurrentClass],
+    tuple[_CurrentProof, ...],
+    list[int],
+    list[str],
+]:
+    """Build the shared exact recursive-current proof graph.
+
+    ``color_sector_aliases`` projects only the traversal-sector identifier.
+    Every external label, ordered traversal, line group, flavour flow, kernel
+    contract, coupling and coefficient remains part of the proof.  The normal
+    helicity-replay path passes no projection; contracted open-line
+    construction uses the projection to recognize only proven block-order
+    aliases.
+    """
+
+    source_by_bit, source_contracts, source_diagnostics = _source_contracts(
+        dag,
+        model,
+    )
+    interactions_by_result: dict[int, list[InteractionNode]] = defaultdict(list)
+    for interaction in dag.interactions:
+        interactions_by_result[int(interaction.result_id)].append(interaction)
+
+    pending_classes: list[_PendingCurrentClass] = []
+    class_by_signature: dict[str, int] = {}
+    current_proofs: list[_CurrentProof | None] = [None] * len(dag.currents)
+    residual_current_ids: list[int] = []
+    diagnostics = list(source_diagnostics)
+
+    ordered_currents = sorted(
+        dag.currents,
+        key=lambda current: (len(current.index.external_labels), current.id),
+    )
+    for current in ordered_currents:
+        selector_state, selector_error = _selector_state_for_ancestry(
+            int(current.index.helicity_ancestry),
+            source_by_bit,
+        )
+        if selector_error is not None:
+            _record_residual_current(
+                current,
+                selector_state,
+                selector_error,
+                current_proofs,
+                residual_current_ids,
+                diagnostics,
+            )
+            continue
+
+        if current.is_source:
+            source_contract = source_contracts.get(current.id)
+            if source_contract is None:
+                _record_residual_current(
+                    current,
+                    selector_state,
+                    "source state has no exact SourceIR contract",
+                    current_proofs,
+                    residual_current_ids,
+                    diagnostics,
+                )
+                continue
+            signature_payload = {
+                "kind": "source",
+                "current_contract": _current_contract(
+                    current,
+                    include_spin_state=False,
+                    color_sector_aliases=color_sector_aliases,
+                ),
+                "source_topology": source_contract["topology"],
+                "source_contract_digest": source_contract["digest"],
+            }
+            class_index, factor = _register_current_class(
+                current,
+                selector_state,
+                signature_payload,
+                transition_contract_ids=(),
+                source_class=True,
+                class_by_signature=class_by_signature,
+                pending_classes=pending_classes,
+            )
+            current_proofs[current.id] = _CurrentProof(
+                class_index=class_index,
+                factor=factor,
+                selector_state=selector_state,
+            )
+            continue
+
+        candidate = _generated_current_signature(
+            dag,
+            current,
+            interactions_by_result[current.id],
+            model,
+            current_proofs,
+            color_sector_aliases=color_sector_aliases,
+        )
+        if isinstance(candidate, str):
+            _record_residual_current(
+                current,
+                selector_state,
+                candidate,
+                current_proofs,
+                residual_current_ids,
+                diagnostics,
+            )
+            continue
+        signature_payload, transition_contract_ids = candidate
+        class_index, factor = _register_current_class(
+            current,
+            selector_state,
+            signature_payload,
+            transition_contract_ids=transition_contract_ids,
+            source_class=False,
+            class_by_signature=class_by_signature,
+            pending_classes=pending_classes,
+        )
+        current_proofs[current.id] = _CurrentProof(
+            class_index=class_index,
+            factor=factor,
+            selector_state=selector_state,
+        )
+
+    if any(item is None for item in current_proofs):
+        raise ValueError("helicity recurrence derivation left a current unclassified")
+    return (
+        source_by_bit,
+        source_contracts,
+        pending_classes,
+        tuple(item for item in current_proofs if item is not None),
+        residual_current_ids,
+        diagnostics,
+    )
+
+
+def build_helicity_recurrence_plan(
+    dag: GenericDAG,
+    model: Model,
+) -> HelicityRecurrencePlan | None:
+    """Derive reusable recurrence classes for a complete-helicity DAG.
+
+    The selected-helicity generation path deliberately returns ``None`` and is
+    therefore byte-for-byte unchanged.  Proof failures are attached only to the
+    affected current and descendants that depend on it; independent classes are
+    retained.
+    """
+
+    if dag.helicity_coverage != "complete" or dag.selected_source_helicities:
+        return None
+
+    (
+        source_by_bit,
+        source_contracts,
+        pending_classes,
+        proven_currents,
+        residual_current_ids,
+        diagnostics,
+    ) = _derive_current_replay_proofs(dag, model)
+
+    pending_amplitudes, residual_root_ids, root_diagnostics = _amplitude_classes(
+        dag,
+        model,
+        proven_currents,
+        source_by_bit,
+    )
+    diagnostics.extend(root_diagnostics)
+
+    residual_root_selector_states: dict[int, tuple[_SelectorState, ...]] = {}
+    for root_id in residual_root_ids:
+        selector_states, selector_error = _root_selector_states(
+            dag.amplitude_roots[root_id],
+            dag,
+            source_by_bit,
+        )
+        if selector_error is not None:
+            diagnostics.append(
+                f"amplitude root {root_id}: residual selector routing failed: "
+                f"{selector_error}"
+            )
+            continue
+        residual_root_selector_states[root_id] = selector_states
+
+    possible_helicities = _possible_helicity_states(dag, model)
+    represented_helicities = {
+        state
+        for recurrence in pending_amplitudes
+        for _root_id, states, _factor in recurrence.members
+        for state in states
+    } | {
+        state
+        for states in residual_root_selector_states.values()
+        for state in states
+    }
+    structural_zeros = tuple(
+        sorted(set(possible_helicities) - represented_helicities)
+    )
+    all_selector_states = {
+        proof.selector_state for proof in proven_currents
+    } | {
+        state
+        for recurrence in pending_amplitudes
+        for _root_id, states, _factor in recurrence.members
+        for state in states
+    } | {
+        state
+        for states in residual_root_selector_states.values()
+        for state in states
+    } | set(structural_zeros)
+    domain_id_by_state = {
+        state: index for index, state in enumerate(sorted(all_selector_states))
+    }
+    complete_label_count = len(
+        [leg for leg in dag.process.legs if leg.outgoing_pdg is not None]
+    )
+    selector_domains = tuple(
+        HelicitySelectorDomain(
+            id=index,
+            source_states=state,
+            complete=len(state) == complete_label_count,
+        )
+        for state, index in sorted(
+            domain_id_by_state.items(),
+            key=lambda item: item[1],
+        )
+    )
+
+    recurrence_classes = tuple(
+        HelicityRecurrenceClass(
+            class_id=item.class_id,
+            representative_current_id=item.representative_current_id,
+            external_labels=item.external_labels,
+            source_class=item.source_class,
+            members=tuple(
+                HelicityCurrentReplayMember(
+                    current_id=current_id,
+                    selector_domain_id=domain_id_by_state[state],
+                    factor=factor,
+                )
+                for current_id, state, factor in item.members
+            ),
+            proof_digest=item.proof_digest,
+            transition_contract_ids=item.transition_contract_ids,
+        )
+        for item in pending_classes
+    )
+    amplitude_classes = tuple(
+        HelicityAmplitudeReplayClass(
+            class_id=item.class_id,
+            representative_root_id=item.representative_root_id,
+            members=tuple(
+                HelicityAmplitudeReplayMember(
+                    root_id=root_id,
+                    selector_domain_ids=tuple(
+                        domain_id_by_state[state] for state in states
+                    ),
+                    factor=factor,
+                )
+                for root_id, states, factor in item.members
+            ),
+            proof_digest=item.proof_digest,
+            transition_contract_ids=item.transition_contract_ids,
+        )
+        for item in pending_amplitudes
+    )
+
+    class_by_current = {
+        member.current_id: recurrence
+        for recurrence in recurrence_classes
+        for member in recurrence.members
+    }
+    source_state_mappings: list[HelicitySourceStateMapping] = []
+    for current in dag.currents:
+        if not current.is_source or current.id not in source_contracts:
+            continue
+        recurrence = class_by_current.get(current.id)
+        if recurrence is None:
+            continue
+        member = next(
+            member for member in recurrence.members if member.current_id == current.id
+        )
+        source_contract = source_contracts[current.id]
+        source_state_mappings.append(
+            HelicitySourceStateMapping(
+                current_id=current.id,
+                external_label=int(current.source_leg_label or 0),
+                helicity=int(current.source_helicity or 0),
+                chirality=int(current.index.chirality),
+                spin_state=current.index.spin_state,
+                declared_state_index=int(source_contract["declared_state_index"]),
+                selector_domain_id=member.selector_domain_id,
+                recurrence_class_id=recurrence.class_id,
+                representative_current_id=recurrence.representative_current_id,
+                source_contract_digest=str(source_contract["digest"]),
+                factor=member.factor,
+            )
+        )
+
+    return HelicityRecurrencePlan(
+        current_count=len(dag.currents),
+        amplitude_root_count=len(dag.amplitude_roots),
+        selector_domains=selector_domains,
+        source_state_mappings=tuple(source_state_mappings),
+        recurrence_classes=recurrence_classes,
+        amplitude_classes=amplitude_classes,
+        residual_current_ids=tuple(sorted(residual_current_ids)),
+        residual_root_ids=tuple(sorted(residual_root_ids)),
+        structural_zero_selector_domain_ids=tuple(
+            domain_id_by_state[state] for state in structural_zeros
+        ),
+        diagnostics=tuple(diagnostics),
+    )
+
+
+def _source_contracts(
+    dag: GenericDAG,
+    model: Model,
+) -> tuple[
+    dict[int, tuple[int, int]],
+    dict[int, dict[str, object]],
+    tuple[str, ...],
+]:
+    """Return ancestry-bit source selectors and exact SourceIR contracts."""
+
+    leg_by_label = {int(leg.label): leg for leg in dag.process.legs}
+    source_by_bit: dict[int, tuple[int, int]] = {}
+    contracts: dict[int, dict[str, object]] = {}
+    diagnostics: list[str] = []
+    for current in dag.currents:
+        if not current.is_source:
+            continue
+        ancestry = int(current.index.helicity_ancestry)
+        label = current.source_leg_label
+        helicity = current.source_helicity
+        if (
+            ancestry <= 0
+            or ancestry & (ancestry - 1)
+            or label is None
+            or helicity is None
+        ):
+            diagnostics.append(
+                f"source current {current.id} has non-canonical ancestry metadata"
+            )
+            continue
+        bit = ancestry.bit_length() - 1
+        selector = (int(label), int(helicity))
+        previous = source_by_bit.setdefault(bit, selector)
+        if previous != selector:
+            diagnostics.append(
+                f"source ancestry bit {bit} maps to inconsistent physical states"
+            )
+            continue
+        leg = leg_by_label.get(int(label))
+        if leg is None or leg.outgoing_pdg is None:
+            diagnostics.append(
+                f"source current {current.id} refers to absent external leg {label}"
+            )
+            continue
+        try:
+            source_ir = model._source_ir(int(leg.outgoing_pdg))
+            matched_index = None
+            for index, declared in enumerate(source_ir.states):
+                state = (
+                    source_ir.crossing.apply(declared)
+                    if leg.is_initial
+                    else declared
+                )
+                if (
+                    int(state.helicity) == int(helicity)
+                    and int(state.chirality) == int(current.index.chirality)
+                    and state.spin_state == current.index.spin_state
+                ):
+                    matched_index = index
+                    break
+            if matched_index is None:
+                diagnostics.append(
+                    f"source current {current.id} is not declared by its SourceIR"
+                )
+                continue
+            exact_payload = {
+                "source_ir": source_ir.to_json_dict(),
+                "initial_state_crossed": bool(leg.is_initial),
+            }
+            contracts[current.id] = {
+                "digest": _digest(exact_payload),
+                "declared_state_index": matched_index,
+                "topology": {
+                    "external_label": int(label),
+                    "statistics": source_ir.statistics,
+                    "wavefunction_family": source_ir.wavefunction_family,
+                    "component_dimension": int(source_ir.component_dimension),
+                    "basis": source_ir.basis,
+                    "orientation": source_ir.identity.orientation,
+                    "self_conjugate": bool(source_ir.identity.self_conjugate),
+                    "chirality": int(current.index.chirality),
+                    "spin_state_shape": _spin_state_shape(
+                        current.index.spin_state
+                    ),
+                    "crossing": source_ir.crossing.to_json_dict(),
+                    "has_mass_parameter": source_ir.mass_parameter is not None,
+                    "has_width_parameter": source_ir.width_parameter is not None,
+                },
+            }
+        except Exception as error:
+            diagnostics.append(
+                f"source current {current.id} contract derivation failed: {error}"
+            )
+    return source_by_bit, contracts, tuple(diagnostics)
+
+
+def _generated_current_signature(
+    dag: GenericDAG,
+    current: CurrentNode,
+    interactions: Sequence[InteractionNode],
+    model: Model,
+    current_proofs: Sequence[_CurrentProof | None],
+    *,
+    color_sector_aliases: _ColorSectorAliases | None = None,
+) -> tuple[dict[str, object], tuple[str, ...]] | str:
+    terms_by_key: dict[str, list[_ComplexWeight]] = defaultdict(list)
+    transition_contracts: set[str] = set()
+    for interaction in interactions:
+        left = current_proofs[interaction.left_id]
+        right = current_proofs[interaction.right_id]
+        if left is None or right is None:
+            return "transition depends on an unclassified parent current"
+        if left.class_index is None or right.class_index is None:
+            return "transition depends on a localized residual parent current"
+        try:
+            equivalence = model.vertex_evaluation_equivalence(
+                int(interaction.vertex_kind)
+            )
+        except Exception as error:
+            return f"vertex transition contract failed: {error}"
+        if not equivalence.verified or not equivalence.class_id:
+            return (
+                "vertex transition has no verified canonical kernel contract: "
+                f"kind {interaction.vertex_kind}"
+            )
+        transition_contracts.add(equivalence.class_id)
+        parent_classes = (left.class_index, right.class_index)
+        if equivalence.input_order == (1, 0):
+            parent_classes = (parent_classes[1], parent_classes[0])
+        kernel_factor = equivalence.factor
+        if (
+            equivalence.input_exchange_factor is not None
+            and parent_classes[1] < parent_classes[0]
+        ):
+            parent_classes = (parent_classes[1], parent_classes[0])
+            kernel_factor = _complex_mul(
+                kernel_factor,
+                equivalence.input_exchange_factor,
+            )
+        coupling_identity = _runtime_coupling_identity(model, interaction)
+        term_key = _canonical_json(
+            {
+                "kernel_contract_id": equivalence.class_id,
+                "parent_recurrence_classes": list(parent_classes),
+                "result_particle_id": int(current.index.particle_id),
+                "result_chirality": int(current.index.chirality),
+                "coupling_identity": coupling_identity,
+            }
+        )
+        coefficient = _complex_mul(
+            interaction.color_weight,
+            _complex_mul(kernel_factor, _complex_mul(left.factor, right.factor)),
+        )
+        terms_by_key[term_key].append(coefficient)
+
+    terms = []
+    for term_key in sorted(terms_by_key):
+        coefficient = _sum_weights(terms_by_key[term_key])
+        if coefficient == (0.0, 0.0):
+            continue
+        terms.append(
+            {
+                "transition": json.loads(term_key),
+                "coefficient": list(coefficient),
+            }
+        )
+    try:
+        propagator = model._propagator_ir(
+            int(current.index.particle_id),
+            int(current.index.chirality),
+        ).to_json_dict()
+    except Exception as error:
+        return f"current finalization contract failed: {error}"
+    return (
+        {
+            "kind": "generated-current",
+            "current_contract": _current_contract(
+                current,
+                color_sector_aliases=color_sector_aliases,
+            ),
+            "propagator_contract": propagator,
+            "terms": terms,
+        },
+        tuple(sorted(transition_contracts)),
+    )
+
+
+def _register_current_class(
+    current: CurrentNode,
+    selector_state: _SelectorState,
+    signature_payload: Mapping[str, object],
+    *,
+    transition_contract_ids: tuple[str, ...],
+    source_class: bool,
+    class_by_signature: dict[str, int],
+    pending_classes: list[_PendingCurrentClass],
+) -> tuple[int, _ComplexWeight]:
+    direct_signature = _canonical_json(signature_payload)
+    opposite_payload = _negated_signature_payload(signature_payload)
+    opposite_signature = _canonical_json(opposite_payload)
+    class_index = class_by_signature.get(direct_signature)
+    factor: _ComplexWeight = (1.0, 0.0)
+    if class_index is None and opposite_signature != direct_signature:
+        class_index = class_by_signature.get(opposite_signature)
+        if class_index is not None:
+            factor = (-1.0, 0.0)
+    if class_index is None:
+        proof_digest = hashlib.sha256(direct_signature.encode("ascii")).hexdigest()
+        class_index = len(pending_classes)
+        class_by_signature[direct_signature] = class_index
+        pending_classes.append(
+            _PendingCurrentClass(
+                class_id=f"helicity-current-sha256:{proof_digest}",
+                representative_current_id=current.id,
+                external_labels=tuple(current.index.external_labels),
+                source_class=source_class,
+                proof_digest=proof_digest,
+                transition_contract_ids=transition_contract_ids,
+                members=[],
+            )
+        )
+    pending_classes[class_index].members.append(
+        (current.id, selector_state, factor)
+    )
+    return class_index, factor
+
+
+def _record_residual_current(
+    current: CurrentNode,
+    selector_state: _SelectorState,
+    reason: str,
+    current_proofs: list[_CurrentProof | None],
+    residual_current_ids: list[int],
+    diagnostics: list[str],
+) -> None:
+    current_proofs[current.id] = _CurrentProof(
+        class_index=None,
+        factor=(1.0, 0.0),
+        selector_state=selector_state,
+        residual_reason=reason,
+    )
+    residual_current_ids.append(current.id)
+    diagnostics.append(f"current {current.id}: {reason}")
+
+
+def _amplitude_classes(
+    dag: GenericDAG,
+    model: Model,
+    current_proofs: Sequence[_CurrentProof],
+    source_by_bit: Mapping[int, tuple[int, int]],
+    *,
+    color_sector_aliases: _ColorSectorAliases | None = None,
+) -> tuple[list[_PendingAmplitudeClass], list[int], list[str]]:
+    pending: list[_PendingAmplitudeClass] = []
+    class_by_signature: dict[str, int] = {}
+    residual: list[int] = []
+    diagnostics: list[str] = []
+    for root in dag.amplitude_roots:
+        left = current_proofs[root.left_id]
+        right = current_proofs[root.right_id]
+        selector_states, selector_error = _root_selector_states(
+            root,
+            dag,
+            source_by_bit,
+        )
+        if selector_error is not None:
+            residual.append(root.id)
+            diagnostics.append(f"amplitude root {root.id}: {selector_error}")
+            continue
+        if left.class_index is None or right.class_index is None:
+            residual.append(root.id)
+            diagnostics.append(
+                f"amplitude root {root.id}: closure depends on a residual current"
+            )
+            continue
+
+        parent_classes = (left.class_index, right.class_index)
+        factor = _complex_mul(left.factor, right.factor)
+        contract_ids: tuple[str, ...] = ()
+        if root.vertex_kind is not None:
+            try:
+                equivalence = model.vertex_evaluation_equivalence(root.vertex_kind)
+            except Exception as error:
+                residual.append(root.id)
+                diagnostics.append(
+                    f"amplitude root {root.id}: closure contract failed: {error}"
+                )
+                continue
+            if not equivalence.verified or not equivalence.class_id:
+                residual.append(root.id)
+                diagnostics.append(
+                    f"amplitude root {root.id}: unverified closure kernel "
+                    f"{root.vertex_kind}"
+                )
+                continue
+            if equivalence.input_order == (1, 0):
+                parent_classes = (parent_classes[1], parent_classes[0])
+            kernel_factor = equivalence.factor
+            if (
+                equivalence.input_exchange_factor is not None
+                and parent_classes[1] < parent_classes[0]
+            ):
+                parent_classes = (parent_classes[1], parent_classes[0])
+                kernel_factor = _complex_mul(
+                    kernel_factor,
+                    equivalence.input_exchange_factor,
+                )
+            factor = _complex_mul(factor, kernel_factor)
+            contract_ids = (equivalence.class_id,)
+
+        payload = {
+            "kind": "amplitude-closure",
+            "root_contract": _root_contract(
+                root,
+                color_sector_aliases=color_sector_aliases,
+            ),
+            "parent_recurrence_classes": list(parent_classes),
+        }
+        direct_signature = _canonical_json(payload)
+        opposite_signature = _canonical_json(_negated_root_payload(payload))
+        class_index = class_by_signature.get(direct_signature)
+        member_factor = factor
+        if class_index is None and direct_signature != opposite_signature:
+            class_index = class_by_signature.get(opposite_signature)
+            if class_index is not None:
+                member_factor = _complex_mul(member_factor, (-1.0, 0.0))
+        if class_index is None:
+            proof_digest = hashlib.sha256(direct_signature.encode("ascii")).hexdigest()
+            class_index = len(pending)
+            class_by_signature[direct_signature] = class_index
+            pending.append(
+                _PendingAmplitudeClass(
+                    class_id=f"helicity-amplitude-sha256:{proof_digest}",
+                    representative_root_id=root.id,
+                    proof_digest=proof_digest,
+                    transition_contract_ids=contract_ids,
+                    members=[],
+                )
+            )
+        pending[class_index].members.append(
+            (root.id, selector_states, member_factor)
+        )
+    return pending, residual, diagnostics
+
+
+def _semantic_amplitude_root_alias_signatures(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    color_sector_aliases: _ColorSectorAliases,
+) -> tuple[_SemanticAmplitudeRootSignature | None, ...]:
+    """Return exact root signatures under one traversal-sector projection.
+
+    This is deliberately a construction-only view of the same proof machinery
+    used by helicity replay.  The projection changes only sector identifiers;
+    traversal order, source labels, fermion exchange factors and every model
+    kernel contract remain exact.  A ``None`` entry means that no proof was
+    available and callers must fail closed rather than remove that root.
+    """
+
+    (
+        source_by_bit,
+        _source_contracts_by_id,
+        _pending_classes,
+        current_proofs,
+        _residual_current_ids,
+        _diagnostics,
+    ) = _derive_current_replay_proofs(
+        dag,
+        model,
+        color_sector_aliases=color_sector_aliases,
+    )
+    pending, residual, _root_diagnostics = _amplitude_classes(
+        dag,
+        model,
+        current_proofs,
+        source_by_bit,
+        color_sector_aliases=color_sector_aliases,
+    )
+    signatures: list[_SemanticAmplitudeRootSignature | None] = [
+        None
+    ] * len(dag.amplitude_roots)
+    for recurrence in pending:
+        for root_id, selector_states, factor in recurrence.members:
+            signatures[root_id] = _SemanticAmplitudeRootSignature(
+                proof_digest=recurrence.proof_digest,
+                selector_states=selector_states,
+                factor=factor,
+            )
+    for root_id in residual:
+        signatures[root_id] = None
+    return tuple(signatures)
+
+
+def _root_selector_states(
+    root: AmplitudeRoot,
+    dag: GenericDAG,
+    source_by_bit: Mapping[int, tuple[int, int]],
+) -> tuple[tuple[_SelectorState, ...], str | None]:
+    selector_state, selector_error = _root_selector_state(
+        root,
+        dag,
+        source_by_bit,
+    )
+    if selector_error is not None:
+        return (), selector_error
+    selector_states = [selector_state]
+    if math.isclose(root.helicity_weight, 2.0, rel_tol=1.0e-12, abs_tol=1.0e-12):
+        flipped = tuple((label, -helicity) for label, helicity in selector_state)
+        if flipped != selector_state:
+            selector_states.append(flipped)
+    elif not math.isclose(
+        root.helicity_weight,
+        1.0,
+        rel_tol=1.0e-12,
+        abs_tol=1.0e-12,
+    ):
+        return (
+            (),
+            f"unsupported helicity multiplicity {root.helicity_weight}",
+        )
+    return tuple(selector_states), None
+
+
+def _root_selector_state(
+    root: AmplitudeRoot,
+    dag: GenericDAG,
+    source_by_bit: Mapping[int, tuple[int, int]],
+) -> tuple[_SelectorState, str | None]:
+    ancestry = int(
+        dag.currents[root.left_id].index.helicity_ancestry
+        | dag.currents[root.right_id].index.helicity_ancestry
+    )
+    return _selector_state_for_ancestry(ancestry, source_by_bit)
+
+
+def _selector_state_for_ancestry(
+    ancestry: int,
+    source_by_bit: Mapping[int, tuple[int, int]],
+) -> tuple[_SelectorState, str | None]:
+    states: dict[int, int] = {}
+    remaining = int(ancestry)
+    while remaining:
+        least = remaining & -remaining
+        bit = least.bit_length() - 1
+        source = source_by_bit.get(bit)
+        if source is None:
+            return tuple(sorted(states.items())), f"unknown source ancestry bit {bit}"
+        label, helicity = source
+        previous = states.setdefault(label, helicity)
+        if previous != helicity:
+            return (
+                tuple(sorted(states.items())),
+                f"ancestry selects multiple helicities for external leg {label}",
+            )
+        remaining ^= least
+    return tuple(sorted(states.items())), None
+
+
+def _possible_helicity_states(
+    dag: GenericDAG,
+    model: Model,
+) -> tuple[_SelectorState, ...]:
+    labels: list[int] = []
+    per_leg: list[tuple[int, ...]] = []
+    for leg in dag.process.legs:
+        if leg.outgoing_pdg is None:
+            continue
+        source_ir = model._source_ir(int(leg.outgoing_pdg))
+        values = {
+            int(
+                (source_ir.crossing.apply(state) if leg.is_initial else state).helicity
+            )
+            for state in source_ir.states
+        }
+        labels.append(int(leg.label))
+        per_leg.append(tuple(sorted(values)))
+    return tuple(
+        tuple(zip(labels, values, strict=True)) for values in product(*per_leg)
+    )
+
+
+def _current_contract(
+    current: CurrentNode,
+    *,
+    include_spin_state: bool = True,
+    color_sector_aliases: _ColorSectorAliases | None = None,
+) -> dict[str, object]:
+    index = current.index
+    color_state = index.color_state.to_json_dict()
+    if color_sector_aliases is not None:
+        sector_id = int(color_state["sector_id"])
+        color_state["sector_id"] = int(
+            color_sector_aliases.get(sector_id, sector_id)
+        )
+    payload: dict[str, object] = {
+        "particle_id": int(index.particle_id),
+        "external_mask": int(index.external_mask),
+        "external_labels": list(index.external_labels),
+        "ordered_external_labels": list(index.ordered_external_labels),
+        "chirality": int(index.chirality),
+        "flavour_flow": list(index.flavour_flow),
+        "quantum_number_flow": [list(item) for item in index.quantum_number_flow],
+        "color_state": color_state,
+        "momentum_mask": int(index.momentum_mask),
+        "coupling_orders": [list(item) for item in index.coupling_orders],
+        "auxiliary_kind": index.auxiliary_kind,
+        "dimension": int(current.dimension),
+        "is_source": bool(current.is_source),
+    }
+    if include_spin_state:
+        payload["spin_state"] = _json_spin_state(index.spin_state)
+    return payload
+
+
+def _root_contract(
+    root: AmplitudeRoot,
+    *,
+    color_sector_aliases: _ColorSectorAliases | None = None,
+) -> dict[str, object]:
+    color_sector_id = root.color_sector_id
+    if color_sector_id is not None and color_sector_aliases is not None:
+        color_sector_id = int(
+            color_sector_aliases.get(int(color_sector_id), int(color_sector_id))
+        )
+    return {
+        "kind": root.kind,
+        "color_weight": list(root.color_weight),
+        "color_sector_id": color_sector_id,
+        "vertex_kind": root.vertex_kind,
+        "vertex_particles": (
+            None if root.vertex_particles is None else list(root.vertex_particles)
+        ),
+        "coupling": list(root.coupling),
+        "contraction_ir": root.contraction_ir.to_json_dict(),
+    }
+
+
+def _runtime_coupling_identity(
+    model: Model,
+    interaction: InteractionNode,
+) -> dict[str, object]:
+    names = runtime_coupling_parameter_names(
+        interaction.vertex_kind,
+        interaction.vertex_particles,
+        interaction.coupling,
+        model=model,
+    )
+    return {
+        "default": list(interaction.coupling),
+        "runtime_parameters": [name for name in names],
+    }
+
+
+def _negated_signature_payload(
+    payload: Mapping[str, object],
+) -> dict[str, object]:
+    result = json.loads(_canonical_json(payload))
+    terms = result.get("terms")
+    if not isinstance(terms, list):
+        return result
+    for term in terms:
+        if not isinstance(term, dict):
+            continue
+        coefficient = term.get("coefficient")
+        if isinstance(coefficient, list) and len(coefficient) == 2:
+            term["coefficient"] = [-float(coefficient[0]), -float(coefficient[1])]
+    return result
+
+
+def _negated_root_payload(payload: Mapping[str, object]) -> dict[str, object]:
+    result = json.loads(_canonical_json(payload))
+    root = result.get("root_contract")
+    if not isinstance(root, dict):
+        return result
+    weight = root.get("color_weight")
+    if isinstance(weight, list) and len(weight) == 2:
+        root["color_weight"] = [-float(weight[0]), -float(weight[1])]
+    return result
+
+
+def _spin_state_shape(value: int | tuple[int, ...]) -> dict[str, object]:
+    if isinstance(value, tuple):
+        return {"kind": "tuple", "length": len(value)}
+    return {"kind": "scalar"}
+
+
+def _json_spin_state(value: int | tuple[int, ...]) -> object:
+    return list(value) if isinstance(value, tuple) else value
+
+
+def _complex_mul(left: _ComplexWeight, right: _ComplexWeight) -> _ComplexWeight:
+    return (
+        _canonical_zero(left[0] * right[0] - left[1] * right[1]),
+        _canonical_zero(left[0] * right[1] + left[1] * right[0]),
+    )
+
+
+def _sum_weights(values: Sequence[_ComplexWeight]) -> _ComplexWeight:
+    return (
+        _canonical_zero(fsum(value[0] for value in values)),
+        _canonical_zero(fsum(value[1] for value in values)),
+    )
+
+
+def _canonical_zero(value: float) -> float:
+    return 0.0 if value == 0.0 else value
+
+
+def _canonical_json(value: object) -> str:
+    return json.dumps(
+        value,
+        ensure_ascii=True,
+        allow_nan=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    )
+
+
+def _digest(value: object) -> str:
+    return hashlib.sha256(_canonical_json(value).encode("ascii")).hexdigest()
+
+
+def _validate_digest(value: str, *, context: str) -> None:
+    if len(value) != 64 or any(
+        character not in "0123456789abcdef" for character in value
+    ):
+        raise ValueError(f"{context} must be a lowercase SHA-256")
+
+
+__all__ = [
+    "HELICITY_RECURRENCE_CONTRACT_VERSION",
+    "HELICITY_RECURRENCE_PROOF_ALGORITHM",
+    "RUNTIME_SELECTOR_PROVENANCE",
+    "HelicityRecurrencePlan",
+    "build_helicity_recurrence_plan",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/numerical_candidate_index.py b/pyamplicol/src/pyamplicol/generation/numerical_candidate_index.py
new file mode 100644
index 0000000000..958da377af
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/numerical_candidate_index.py
@@ -0,0 +1,143 @@
+# SPDX-License-Identifier: 0BSD
+"""Complete scalar tolerance-window candidate indexes.
+
+The index is only a screening device.  Callers must still replay every
+returned candidate against every captured component.  For one selected
+complex observation, let ``X`` and ``Y`` be the infinity norms of the current
+and signed representative, and ``D`` their infinity-norm residual.  Passing
+gives ``D <= a + r*max(X,Y)``; reverse triangle gives ``Y <= X+D``.  Thus, for
+``r < 1``, ``D <= (a+rX)/(1-r)``, and the chosen scalar residual is no larger
+than ``D``.  The returned one-dimensional window therefore has no false
+negatives.  Residual tolerance is independent per complex observation, so an
+unrelated large observation does not enlarge the selected pair's bound.
+Policies with ``r >= 1`` deliberately fall back to the complete earlier set.
+"""
+
+from __future__ import annotations
+
+from bisect import bisect_left, bisect_right
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any, Generic, Literal, TypeVar
+
+_RawScalar = TypeVar("_RawScalar")
+_IndexScalar = TypeVar("_IndexScalar")
+
+
+@dataclass(frozen=True, slots=True)
+class NumericalObservationCandidateIndex(Generic[_IndexScalar]):
+    """Most-discriminating deterministic scalar projection for one contract."""
+
+    observation_index: int
+    scalar_component: int
+    entries: tuple[tuple[_IndexScalar, int], ...]
+
+
+def build_numerical_observation_candidate_index(
+    member_ids: Sequence[int],
+    observations: Mapping[
+        int,
+        Sequence[tuple[_RawScalar, _RawScalar]],
+    ],
+    *,
+    normalize: Callable[[_RawScalar], _IndexScalar],
+) -> NumericalObservationCandidateIndex[_IndexScalar]:
+    """Build one deterministic complete index without copying full vectors."""
+
+    members = tuple(member_ids)
+    if not members:
+        raise ValueError("numerical candidate index has no members")
+    observation_count = len(observations[members[0]])
+    if observation_count == 0 or any(
+        len(observations[current_id]) != observation_count for current_id in members
+    ):
+        raise ValueError("numerical candidate index members have inconsistent widths")
+
+    def discrimination(choice: tuple[int, int]) -> tuple[int, int, int, int]:
+        observation_index, scalar_component = choice
+        distinct_values: set[_RawScalar] = set()
+        nonzero_count = 0
+        for current_id in members:
+            value = observations[current_id][observation_index][scalar_component]
+            distinct_values.add(value)
+            nonzero_count += value != 0
+        return (
+            len(distinct_values),
+            nonzero_count,
+            -observation_index,
+            -scalar_component,
+        )
+
+    observation_index, scalar_component = max(
+        (
+            (observation_index, scalar_component)
+            for observation_index in range(observation_count)
+            for scalar_component in (0, 1)
+        ),
+        key=discrimination,
+    )
+    entries = tuple(
+        sorted(
+            (
+                normalize(
+                    observations[current_id][observation_index][scalar_component]
+                ),
+                current_id,
+            )
+            for current_id in members
+        )
+    )
+    return NumericalObservationCandidateIndex(
+        observation_index=observation_index,
+        scalar_component=scalar_component,
+        entries=entries,
+    )
+
+
+def numerical_observation_tolerance_window_ids(
+    index: NumericalObservationCandidateIndex[_IndexScalar],
+    current_values: Sequence[tuple[_RawScalar, _RawScalar]],
+    *,
+    relation_kind: Literal["equal", "opposite"],
+    current_id: int,
+    relative_tolerance: _IndexScalar,
+    absolute_tolerance: _IndexScalar,
+    normalize: Callable[[_RawScalar], _IndexScalar],
+) -> tuple[int, ...]:
+    """Return every earlier representative that can pass the full test."""
+
+    if relation_kind not in {"equal", "opposite"}:
+        raise ValueError("numerical candidate index relation is unsupported")
+    if not 0 <= index.observation_index < len(current_values):
+        raise ValueError("numerical candidate index observation is invalid")
+    relative: Any = relative_tolerance
+    absolute: Any = absolute_tolerance
+    if relative >= 1:
+        return tuple(
+            representative_id
+            for _value, representative_id in index.entries
+            if representative_id < current_id
+        )
+    selected = current_values[index.observation_index]
+    selected_scalar: Any = normalize(selected[index.scalar_component])
+    target = selected_scalar if relation_kind == "equal" else -selected_scalar
+    current_scale = max(
+        abs(normalize(selected[0])),
+        abs(normalize(selected[1])),
+    )
+    radius = (absolute + relative * current_scale) / (1 - relative)
+    entries: Any = index.entries
+    lower = bisect_left(entries, (target - radius, -1))
+    upper = bisect_right(entries, (target + radius, current_id - 1))
+    return tuple(
+        representative_id
+        for _value, representative_id in entries[lower:upper]
+        if representative_id < current_id
+    )
+
+
+__all__ = [
+    "NumericalObservationCandidateIndex",
+    "build_numerical_observation_candidate_index",
+    "numerical_observation_tolerance_window_ids",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/numerical_current_warmup.py b/pyamplicol/src/pyamplicol/generation/numerical_current_warmup.py
new file mode 100644
index 0000000000..462f07e1c8
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/numerical_current_warmup.py
@@ -0,0 +1,1473 @@
+# SPDX-License-Identifier: 0BSD
+"""High-precision current snapshots for bounded relation-discovery warm-up."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from decimal import ROUND_HALF_EVEN, Decimal, localcontext
+from itertools import pairwise
+from math import isfinite
+from typing import Any, Literal
+
+from ..evaluators.symbolica_compile import _compile_symbolica_outputs
+from ..evaluators.symbolica_settings import SymbolicaEvaluatorSettings
+from ..models.base import Model
+from ..runtime.symbolica_exact import (
+    _decimal,
+    _fill_momenta,
+    _fill_sources,
+)
+from .contracts import RuntimeExpressionSchema, StageCompilationInput
+from .dag_equivalence import (
+    NUMERICAL_CURRENT_CAPTURE_ABI,
+    NUMERICAL_CURRENT_CAPTURE_OUTPUT_PARTITION_ABI,
+    NumericalCurrentObservationDiscoveryResult,
+    NumericalCurrentRelationApplicationResult,
+    NumericalCurrentRelationCertificate,
+    apply_numerical_current_relation_certificates,
+    discover_generic_dag_numerical_current_relations,
+    generic_dag_numerical_capture_output_partition_sha256,
+)
+from .dag_types import GenericDAG
+from .recurrence_numerical_current_warmup import (
+    numerical_relation_correctness_payload,
+)
+from .runtime_schema import build_runtime_expression_schema
+from .stage_planning import build_generic_stage_compiler_blueprint
+from .stage_types import GenericCompiledStageBlueprint
+from .validation import (
+    ValidationPointRecord,
+    build_validation_point,
+    rotate_validation_point,
+)
+
+_ComplexDecimal = tuple[Decimal, Decimal]
+_CAPTURE_ABI = NUMERICAL_CURRENT_CAPTURE_ABI
+_WARMUP_ABI = "pyamplicol-generic-dag-numerical-current-warmup-v1"
+_CAPTURE_OUTPUT_PARTITION_ABI = NUMERICAL_CURRENT_CAPTURE_OUTPUT_PARTITION_ABI
+_NUMERICAL_DECIMAL_GUARD_DIGITS = 16
+
+
+@dataclass(frozen=True, slots=True)
+class GenericDAGCurrentObservationCapture:
+    """Complete point-major current observations and replay provenance."""
+
+    precision_digits: int
+    points: tuple[ValidationPointRecord, ...]
+    point_sha256s: tuple[str, ...]
+    kinematic_sha256s: tuple[str, ...]
+    parameter_contexts: tuple[tuple[Decimal, ...], ...]
+    parameter_context_sha256s: tuple[str, ...]
+    observations: Mapping[int, tuple[_ComplexDecimal, ...]]
+    runtime_schema_sha256: str
+    model_parameter_schema_sha256: str
+    source_dag_sha256: str
+    evaluator_output_partition_abi: str
+    evaluator_output_partition_sha256: str
+    observation_batch_sha256: str
+    capture_contract_sha256: str
+
+    @property
+    def point_count(self) -> int:
+        return len(self.point_sha256s)
+
+    @property
+    def current_count(self) -> int:
+        return len(self.observations)
+
+    def to_provenance_dict(self) -> dict[str, object]:
+        return {
+            "abi": _CAPTURE_ABI,
+            "precision_digits": self.precision_digits,
+            "point_count": self.point_count,
+            "point_sha256s": list(self.point_sha256s),
+            "kinematic_sha256s": list(self.kinematic_sha256s),
+            "points": [point.to_mapping() for point in self.points],
+            "parameter_contexts": [
+                [_decimal_string(value) for value in context]
+                for context in self.parameter_contexts
+            ],
+            "parameter_context_sha256s": list(self.parameter_context_sha256s),
+            "current_count": self.current_count,
+            "runtime_schema_sha256": self.runtime_schema_sha256,
+            "model_parameter_schema_sha256": (self.model_parameter_schema_sha256),
+            "source_dag_sha256": self.source_dag_sha256,
+            "evaluator_output_partition": {
+                "abi": self.evaluator_output_partition_abi,
+                "sha256": self.evaluator_output_partition_sha256,
+            },
+            "observation_batch_sha256": self.observation_batch_sha256,
+            "capture_contract_sha256": self.capture_contract_sha256,
+            "complete_current_component_digest": True,
+            "components_embedded": False,
+            "point_major": True,
+            "evaluator": "symbolica-interpreted-high-precision-stage-replay",
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class _PartitionedCurrentCaptureStageEvaluator:
+    """Warm-up-only exact replay over current-ID-isolated evaluator leaves."""
+
+    evaluators: tuple[Any, ...]
+    chunk_input_indices: tuple[tuple[int, ...], ...]
+    output_partitions: tuple[tuple[int, int], ...]
+    input_len: int
+    output_len: int
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.input_len) is not int
+            or self.input_len < 0
+            or type(self.output_len) is not int
+            or self.output_len < 1
+            or len(self.evaluators) != len(self.chunk_input_indices)
+            or len(self.evaluators) != len(self.output_partitions)
+            or not self.evaluators
+        ):
+            raise ValueError("numerical current partitioned evaluator shape is invalid")
+        expected_output_start = 0
+        for evaluator, indices, partition in zip(
+            self.evaluators,
+            self.chunk_input_indices,
+            self.output_partitions,
+            strict=True,
+        ):
+            start, stop = partition
+            if (
+                start != expected_output_start
+                or stop <= start
+                or stop > self.output_len
+                or any(
+                    type(index) is not int or index < 0 or index >= self.input_len
+                    for index in indices
+                )
+                or any(left >= right for left, right in pairwise(indices))
+                or getattr(evaluator, "input_len", None) != len(indices)
+            ):
+                raise ValueError(
+                    "numerical current partitioned evaluator mapping drifted"
+                )
+            expected_output_start = stop
+        if expected_output_start != self.output_len:
+            raise ValueError(
+                "numerical current partitioned evaluator outputs are not exhaustive"
+            )
+
+    def evaluate_complex_with_prec(
+        self,
+        values: Sequence[_ComplexDecimal],
+        precision: int,
+    ) -> tuple[object, ...]:
+        prepared = tuple(values)
+        if len(prepared) != self.input_len:
+            raise ValueError(
+                "numerical current partitioned evaluator input width drifted"
+            )
+        outputs: list[object] = []
+        for evaluator, indices, (start, stop) in zip(
+            self.evaluators,
+            self.chunk_input_indices,
+            self.output_partitions,
+            strict=True,
+        ):
+            source = getattr(evaluator, "_source_evaluator", None)
+            evaluate = getattr(source, "evaluate_complex_with_prec", None)
+            if not callable(evaluate):
+                raise ValueError(
+                    "numerical current warm-up evaluator leaf lacks "
+                    "high-precision replay"
+                )
+            chunk_outputs = tuple(
+                evaluate(
+                    tuple(prepared[index] for index in indices),
+                    precision,
+                )
+            )
+            if len(chunk_outputs) != stop - start:
+                raise ValueError(
+                    "numerical current warm-up evaluator leaf returned the "
+                    "wrong output width"
+                )
+            outputs.extend(chunk_outputs)
+        if len(outputs) != self.output_len:
+            raise ValueError(
+                "numerical current partitioned evaluator output width drifted"
+            )
+        return tuple(outputs)
+
+
+@dataclass(frozen=True, slots=True)
+class _GenericDAGCurrentCaptureSession:
+    """Reusable interpreted stage evaluators for one immutable source DAG."""
+
+    dag: GenericDAG
+    process_id: str
+    runtime_schema: RuntimeExpressionSchema
+    schema: Mapping[str, object]
+    stages: tuple[GenericCompiledStageBlueprint, ...]
+    stage_evaluators: tuple[Any, ...]
+    model_parameters: tuple[Decimal, ...]
+    source_dag_sha256: str
+    evaluator_output_partition_abi: str
+    evaluator_output_partition_sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class GenericDAGNumericalCurrentWarmupResult:
+    """One complete discovery, verification, and application transaction."""
+
+    dag: GenericDAG
+    requested_mode: Literal["diagnostic", "certified-reuse"]
+    execution_mode: Literal["compiled", "eager"]
+    candidate_capture: GenericDAGCurrentObservationCapture
+    verification_capture: GenericDAGCurrentObservationCapture
+    application_capture: GenericDAGCurrentObservationCapture | None
+    application_validation: Mapping[str, object]
+    discovery: NumericalCurrentObservationDiscoveryResult
+    application: NumericalCurrentRelationApplicationResult
+    application_scope: Mapping[str, object]
+
+    @property
+    def warning_required(self) -> bool:
+        return self.application.report.warning_required
+
+    def to_json_dict(self) -> dict[str, object]:
+        applied_relation_count = self.application.report.applied_relation_count
+        return {
+            "schema_version": 1,
+            "abi": _WARMUP_ABI,
+            "requested_mode": self.requested_mode,
+            "effective_mode": self.requested_mode,
+            "effective_reuse_state": "enabled",
+            "state": self.application.report.state,
+            "scope": {
+                "execution_mode": self.execution_mode,
+                "color_accuracy": str(self.dag.process.color_accuracy),
+                "representation": "generic-dag",
+            },
+            "source_semantics": {
+                "sha256": (self.application.report.source_semantics_sha256),
+            },
+            "candidate_capture": (self.candidate_capture.to_provenance_dict()),
+            "verification_capture": (self.verification_capture.to_provenance_dict()),
+            "application_capture": (
+                None
+                if self.application_capture is None
+                else self.application_capture.to_provenance_dict()
+            ),
+            "application_validation": dict(self.application_validation),
+            "application_scope": dict(self.application_scope),
+            "discovery": self.discovery.report.to_json_dict(),
+            "application": self.application.report.to_json_dict(),
+            "certified_relation_count": len(self.discovery.certificates),
+            "applied_relation_count": applied_relation_count,
+            "relation_correctness": numerical_relation_correctness_payload(
+                applied_relation_count
+            ),
+            "warning": (self.application.report.to_json_dict()["warning"]),
+        }
+
+
+def run_generic_dag_numerical_current_warmup(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str,
+    mode: Literal["diagnostic", "certified-reuse"],
+    execution_mode: Literal["compiled", "eager"],
+    precision_digits: int,
+    probe_count: int,
+    verification_probe_count: int,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+    seed: int,
+    application_relation_kinds: Sequence[Literal["equal", "opposite", "zero"]] = (
+        "equal",
+        "opposite",
+        "zero",
+    ),
+    application_scope_reason: str = "complete-generic-dag",
+) -> GenericDAGNumericalCurrentWarmupResult:
+    """Run the bounded default-on numerical relation transaction."""
+
+    if mode not in {"diagnostic", "certified-reuse"}:
+        raise ValueError(
+            "generic-DAG numerical current warm-up requires diagnostic or "
+            "certified-reuse mode"
+        )
+    allowed_relation_kinds = _validated_application_relation_kinds(
+        application_relation_kinds
+    )
+    if not isinstance(application_scope_reason, str) or not application_scope_reason:
+        raise ValueError("generic-DAG numerical relation application scope is invalid")
+    candidate_points, verification_points = build_numerical_current_probe_points(
+        dag,
+        model,
+        process_id=process_id,
+        seed=seed,
+        candidate_count=probe_count,
+        verification_count=verification_probe_count,
+    )
+    baseline_session = _build_current_capture_session(
+        dag,
+        model,
+        process_id=process_id,
+    )
+    candidate_parameter_contexts = _build_parameter_probe_contexts(
+        baseline_session.model_parameters,
+        precision_digits=precision_digits,
+        seed=seed,
+        domain="candidate-current-parameter-probes-v1",
+        count=len(candidate_points),
+        include_defaults=True,
+    )
+    verification_parameter_contexts = _build_parameter_probe_contexts(
+        baseline_session.model_parameters,
+        precision_digits=precision_digits,
+        seed=seed,
+        domain="independent-verification-current-parameter-probes-v1",
+        count=len(verification_points),
+        include_defaults=False,
+    )
+    candidate = capture_generic_dag_current_observations(
+        dag,
+        model,
+        candidate_points,
+        precision_digits=precision_digits,
+        parameter_contexts=candidate_parameter_contexts,
+        _session=baseline_session,
+    )
+    verification = capture_generic_dag_current_observations(
+        dag,
+        model,
+        verification_points,
+        precision_digits=precision_digits,
+        parameter_contexts=verification_parameter_contexts,
+        _session=baseline_session,
+    )
+    validate_independent_current_observation_captures(
+        candidate,
+        verification,
+    )
+    discovery = discover_generic_dag_numerical_current_relations(
+        dag,
+        model,
+        candidate_observations=candidate.observations,
+        verification_observations=verification.observations,
+        candidate_point_sha256s=candidate.point_sha256s,
+        verification_point_sha256s=verification.point_sha256s,
+        candidate_kinematic_sha256s=candidate.kinematic_sha256s,
+        verification_kinematic_sha256s=verification.kinematic_sha256s,
+        candidate_parameter_context_sha256s=(candidate.parameter_context_sha256s),
+        verification_parameter_context_sha256s=(verification.parameter_context_sha256s),
+        runtime_schema_sha256=candidate.runtime_schema_sha256,
+        source_dag_sha256=candidate.source_dag_sha256,
+        evaluator_output_partition_abi=(candidate.evaluator_output_partition_abi),
+        evaluator_output_partition_sha256=(candidate.evaluator_output_partition_sha256),
+        candidate_capture_sha256=candidate.capture_contract_sha256,
+        verification_capture_sha256=(verification.capture_contract_sha256),
+        process_id=process_id,
+        execution_mode=execution_mode,
+        precision_digits=precision_digits,
+        seed=seed,
+        relative_tolerance=relative_tolerance,
+        absolute_tolerance=absolute_tolerance,
+    )
+    if (
+        discovery.report.candidate_observation_batch_sha256
+        != candidate.observation_batch_sha256
+        or discovery.report.verification_observation_batch_sha256
+        != verification.observation_batch_sha256
+        or discovery.report.runtime_schema_sha256 != candidate.runtime_schema_sha256
+        or discovery.report.source_dag_sha256 != candidate.source_dag_sha256
+        or discovery.report.candidate_capture_sha256
+        != candidate.capture_contract_sha256
+        or discovery.report.verification_capture_sha256
+        != verification.capture_contract_sha256
+    ):
+        raise ValueError(
+            "numerical current detector did not authenticate the captured "
+            "observation batches"
+        )
+    applicable_certificates = _application_scoped_certificates(
+        discovery.certificates,
+        allowed_relation_kinds=allowed_relation_kinds,
+    )
+    application = apply_numerical_current_relation_certificates(
+        dag,
+        model,
+        applicable_certificates,
+        mode=mode,
+        execution_mode=execution_mode,
+        process_id=process_id,
+        runtime_schema_sha256=candidate.runtime_schema_sha256,
+        source_dag_sha256=candidate.source_dag_sha256,
+        candidate_capture_sha256=candidate.capture_contract_sha256,
+        verification_capture_sha256=(verification.capture_contract_sha256),
+        _structural_equivalences=discovery.structural_equivalences,
+    )
+    if (
+        application.report.certificates != applicable_certificates
+        or application.report.source_semantics_sha256
+        != discovery.report.source_semantics_sha256
+    ):
+        raise ValueError("numerical current application replay drifted from discovery")
+    application_capture: GenericDAGCurrentObservationCapture | None = None
+    if application.report.applied_relation_count:
+        application_capture = capture_generic_dag_current_observations(
+            application.dag,
+            model,
+            verification_points,
+            precision_digits=precision_digits,
+            parameter_contexts=verification_parameter_contexts,
+        )
+        application_validation = _validate_applied_current_observations(
+            verification,
+            application_capture,
+            relative_tolerance=relative_tolerance,
+            absolute_tolerance=absolute_tolerance,
+        )
+    else:
+        application_validation = {
+            "status": "not-required-no-applied-relations",
+            "checked_current_count": 0,
+            "checked_component_count": 0,
+            "maximum_absolute_residual": None,
+            "maximum_relative_residual": None,
+            "maximum_tolerance_ratio": None,
+        }
+    return GenericDAGNumericalCurrentWarmupResult(
+        dag=application.dag,
+        requested_mode=mode,
+        execution_mode=execution_mode,
+        candidate_capture=candidate,
+        verification_capture=verification,
+        application_capture=application_capture,
+        application_validation=application_validation,
+        discovery=discovery,
+        application=application,
+        application_scope={
+            "abi": ("pyamplicol-generic-dag-numerical-relation-application-scope-v1"),
+            "policy": "exact-physical-selector-member-set-v1",
+            "reason": application_scope_reason,
+            "allowed_relation_kinds": list(allowed_relation_kinds),
+            "discovered_relation_count": len(discovery.certificates),
+            "application_eligible_relation_count": len(applicable_certificates),
+            "scope_suppressed_relation_count": (
+                len(discovery.certificates) - len(applicable_certificates)
+            ),
+        },
+    )
+
+
+def _validated_application_relation_kinds(
+    values: Sequence[Literal["equal", "opposite", "zero"]],
+) -> tuple[Literal["equal", "opposite", "zero"], ...]:
+    resolved = tuple(values)
+    if len(set(resolved)) != len(resolved) or any(
+        relation_kind not in {"equal", "opposite", "zero"} for relation_kind in resolved
+    ):
+        raise ValueError("generic-DAG numerical relation application scope is invalid")
+    return resolved
+
+
+def _application_scoped_certificates(
+    certificates: Sequence[NumericalCurrentRelationCertificate],
+    *,
+    allowed_relation_kinds: Sequence[Literal["equal", "opposite", "zero"]],
+) -> tuple[NumericalCurrentRelationCertificate, ...]:
+    """Contain application without changing authenticated discovery evidence."""
+
+    allowed = frozenset(_validated_application_relation_kinds(allowed_relation_kinds))
+    result: list[NumericalCurrentRelationCertificate] = []
+    for certificate in certificates:
+        relation_kind = getattr(certificate, "relation_kind", None)
+        if relation_kind not in {"equal", "opposite", "zero"}:
+            raise ValueError(
+                "generic-DAG numerical certificate relation kind is invalid"
+            )
+        if relation_kind in allowed:
+            result.append(certificate)
+    return tuple(result)
+
+
+def generic_dag_numerical_current_opt_out_report(
+    dag: GenericDAG,
+    *,
+    execution_mode: Literal["compiled", "eager"],
+) -> dict[str, object]:
+    """Report the explicit opt-out without hashing unused source semantics."""
+
+    return {
+        "schema_version": 1,
+        "abi": _WARMUP_ABI,
+        "requested_mode": "off",
+        "effective_mode": "off",
+        "effective_reuse_state": "disabled",
+        "state": "disabled-by-user",
+        "scope": {
+            "execution_mode": execution_mode,
+            "color_accuracy": str(dag.process.color_accuracy),
+            "representation": "generic-dag",
+        },
+        "candidate_capture": None,
+        "verification_capture": None,
+        "application_capture": None,
+        "application_validation": {
+            "status": "disabled-by-user",
+            "checked_current_count": 0,
+            "checked_component_count": 0,
+            "maximum_absolute_residual": None,
+            "maximum_relative_residual": None,
+            "maximum_tolerance_ratio": None,
+        },
+        "application_scope": {
+            "abi": ("pyamplicol-generic-dag-numerical-relation-application-scope-v1"),
+            "policy": "disabled-by-user",
+            "reason": "explicit-opt-out",
+            "allowed_relation_kinds": [],
+            "discovered_relation_count": 0,
+            "application_eligible_relation_count": 0,
+            "scope_suppressed_relation_count": 0,
+        },
+        "discovery": None,
+        "application": None,
+        "certified_relation_count": 0,
+        "applied_relation_count": 0,
+        "relation_correctness": numerical_relation_correctness_payload(0),
+        "warning": {
+            "required": False,
+            "emit": "never",
+            "code": None,
+            "message": None,
+        },
+    }
+
+
+def build_numerical_current_probe_points(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str,
+    seed: int,
+    candidate_count: int,
+    verification_count: int,
+) -> tuple[
+    tuple[ValidationPointRecord, ...],
+    tuple[ValidationPointRecord, ...],
+]:
+    """Build deterministic domain-separated physical warm-up points."""
+
+    if (
+        type(seed) is not int
+        or seed < 0
+        or type(candidate_count) is not int
+        or candidate_count < 2
+        or type(verification_count) is not int
+        or verification_count < 2
+    ):
+        raise ValueError("numerical current probe-point contract is invalid")
+
+    def domain_points(
+        domain: str,
+        count: int,
+    ) -> tuple[ValidationPointRecord, ...]:
+        return tuple(
+            rotate_validation_point(
+                build_validation_point(
+                    dag,
+                    model,
+                    process_id=process_id,
+                    seed=_domain_seed(seed, domain=domain, index=index),
+                ),
+                rotation_seed=_domain_seed(
+                    seed,
+                    domain=f"{domain}:spatial-rotation-v1",
+                    index=index,
+                ),
+            )
+            for index in range(count)
+        )
+
+    candidate = domain_points("candidate-current-probes-v1", candidate_count)
+    verification = domain_points(
+        "independent-verification-current-probes-v1",
+        verification_count,
+    )
+    if any(not point.available for point in (*candidate, *verification)):
+        errors = tuple(
+            point.error for point in (*candidate, *verification) if not point.available
+        )
+        raise ValueError(
+            "numerical current probe-point generation failed: "
+            + "; ".join(str(error) for error in errors)
+        )
+    candidate_hashes = {_kinematic_sha256(point) for point in candidate}
+    verification_hashes = {_kinematic_sha256(point) for point in verification}
+    if (
+        len(candidate_hashes) != len(candidate)
+        or len(verification_hashes) != len(verification)
+        or not candidate_hashes.isdisjoint(verification_hashes)
+    ):
+        raise ValueError(
+            "numerical current probe domains do not contain distinct, "
+            "independent physical momentum records"
+        )
+    return candidate, verification
+
+
+def capture_generic_dag_current_observations(
+    dag: GenericDAG,
+    model: Model,
+    points: Sequence[ValidationPointRecord],
+    *,
+    precision_digits: int,
+    parameter_contexts: Sequence[Sequence[Decimal]] | None = None,
+    _session: _GenericDAGCurrentCaptureSession | None = None,
+) -> GenericDAGCurrentObservationCapture:
+    """Evaluate and snapshot every current at every supplied physical point.
+
+    The evaluators remain interpreted Symbolica states: this warm-up does not
+    launch a JIT, C++, ASM, or native compiler.  Current components are copied
+    immediately after their producing stage, before value-slot recycling can
+    overwrite them.
+    """
+
+    if type(precision_digits) is not int or precision_digits < 80:
+        raise ValueError(
+            "numerical current capture precision must be at least 80 digits"
+        )
+    point_records = tuple(points)
+    if len(point_records) < 2:
+        raise ValueError(
+            "numerical current capture requires at least two physical points"
+        )
+    if any(
+        not isinstance(point, ValidationPointRecord) or not point.available
+        for point in point_records
+    ):
+        raise ValueError("numerical current capture received an unavailable point")
+    if any(point.process != dag.process.process for point in point_records):
+        raise ValueError(
+            "numerical current capture point process does not match the DAG"
+        )
+    process_ids = {point.process_id for point in point_records}
+    if len(process_ids) != 1:
+        raise ValueError("numerical current capture points mix process identities")
+    process_id = next(iter(process_ids))
+    session = (
+        _build_current_capture_session(
+            dag,
+            model,
+            process_id=process_id,
+        )
+        if _session is None
+        else _session
+    )
+    if session.dag is not dag or session.process_id != process_id:
+        raise ValueError(
+            "numerical current capture session drifted from its source DAG"
+        )
+
+    schema = session.schema
+    blueprint_stages = session.stages
+    stage_evaluators = session.stage_evaluators
+    model_parameters = session.model_parameters
+    resolved_parameter_contexts = (
+        tuple(model_parameters for _point in point_records)
+        if parameter_contexts is None
+        else tuple(tuple(context) for context in parameter_contexts)
+    )
+    if len(resolved_parameter_contexts) != len(point_records) or any(
+        len(context) != len(model_parameters)
+        or any(
+            not isinstance(value, Decimal) or not value.is_finite() for value in context
+        )
+        for context in resolved_parameter_contexts
+    ):
+        raise ValueError(
+            "numerical current parameter-probe contexts do not match the runtime schema"
+        )
+    point_hashes = tuple(_validation_point_sha256(point) for point in point_records)
+    parameter_context_hashes = tuple(
+        _canonical_sha256(
+            {
+                "abi": "pyamplicol-numerical-current-parameter-context-v1",
+                "point_index": point_index,
+                "point_sha256": point_hash,
+                "values": [_decimal_string(value) for value in context],
+            }
+        )
+        for point_index, (point_hash, context) in enumerate(
+            zip(
+                point_hashes,
+                resolved_parameter_contexts,
+                strict=True,
+            )
+        )
+    )
+    kinematic_hashes = tuple(_kinematic_sha256(point) for point in point_records)
+    if len(set(kinematic_hashes)) != len(kinematic_hashes):
+        raise ValueError("numerical current capture requires distinct physical momenta")
+    captured_by_current: dict[int, list[_ComplexDecimal]] = {
+        current.id: [] for current in dag.currents
+    }
+    working_precision = precision_digits + _NUMERICAL_DECIMAL_GUARD_DIGITS
+    with localcontext() as context:
+        context.prec = working_precision
+        context.rounding = ROUND_HALF_EVEN
+        for point, parameter_context in zip(
+            point_records,
+            resolved_parameter_contexts,
+            strict=True,
+        ):
+            point_values = tuple(
+                tuple(Decimal.from_float(float(value)) for value in momentum)
+                for momentum in point.four_vectors
+            )
+            point_capture = _capture_one_point(
+                dag,
+                schema,
+                blueprint_stages,
+                stage_evaluators,
+                point_values,
+                parameter_context,
+                precision=working_precision,
+            )
+            for current in dag.currents:
+                values = point_capture[current.id]
+                if len(values) != current.dimension:
+                    raise ValueError(
+                        f"numerical current {current.id} capture has "
+                        f"{len(values)} components, expected {current.dimension}"
+                    )
+                captured_by_current[current.id].extend(values)
+
+    observations = {
+        current_id: tuple(values) for current_id, values in captured_by_current.items()
+    }
+    if any(
+        not real.is_finite() or not imaginary.is_finite()
+        for values in observations.values()
+        for real, imaginary in values
+    ):
+        raise ValueError("numerical current capture produced a non-finite component")
+    observation_digest = _current_observation_batch_sha256(
+        observations,
+        point_sha256s=point_hashes,
+    )
+    model_parameter_schema_digest = _canonical_sha256(
+        schema.get("model_parameters", ())
+    )
+    capture_contract_digest = _canonical_sha256(
+        {
+            "abi": _CAPTURE_ABI,
+            "precision_digits": precision_digits,
+            "point_sha256s": list(point_hashes),
+            "kinematic_sha256s": list(kinematic_hashes),
+            "parameter_context_sha256s": list(parameter_context_hashes),
+            "runtime_schema_sha256": session.runtime_schema.sha256,
+            "model_parameter_schema_sha256": (model_parameter_schema_digest),
+            "source_dag_sha256": session.source_dag_sha256,
+            "evaluator_output_partition_abi": (session.evaluator_output_partition_abi),
+            "evaluator_output_partition_sha256": (
+                session.evaluator_output_partition_sha256
+            ),
+            "observation_batch_sha256": observation_digest,
+        }
+    )
+    return GenericDAGCurrentObservationCapture(
+        precision_digits=precision_digits,
+        points=point_records,
+        point_sha256s=point_hashes,
+        kinematic_sha256s=kinematic_hashes,
+        parameter_contexts=resolved_parameter_contexts,
+        parameter_context_sha256s=parameter_context_hashes,
+        observations=observations,
+        runtime_schema_sha256=session.runtime_schema.sha256,
+        model_parameter_schema_sha256=model_parameter_schema_digest,
+        source_dag_sha256=session.source_dag_sha256,
+        evaluator_output_partition_abi=(session.evaluator_output_partition_abi),
+        evaluator_output_partition_sha256=(session.evaluator_output_partition_sha256),
+        observation_batch_sha256=observation_digest,
+        capture_contract_sha256=capture_contract_digest,
+    )
+
+
+def _current_observation_batch_sha256(
+    observations: Mapping[int, tuple[_ComplexDecimal, ...]],
+    *,
+    point_sha256s: tuple[str, ...],
+) -> str:
+    return _canonical_sha256(
+        {
+            "point_sha256s": list(point_sha256s),
+            "currents": [
+                {
+                    "current_id": current_id,
+                    "values": [
+                        [_decimal_string(real), _decimal_string(imaginary)]
+                        for real, imaginary in observations[current_id]
+                    ],
+                }
+                for current_id in sorted(observations)
+            ],
+        }
+    )
+
+
+def _current_capture_output_partitions(
+    stage: GenericCompiledStageBlueprint,
+) -> tuple[tuple[tuple[int, int], ...], dict[str, object]]:
+    """Return exhaustive current-ID output partitions and their identity."""
+
+    if (
+        type(stage.output_length) is not int
+        or stage.output_length < 1
+        or not stage.output_slots
+    ):
+        raise ValueError("numerical current capture stage has no partitionable outputs")
+    slot_ids = tuple(slot.value_slot_id for slot in stage.output_slots)
+    if slot_ids != stage.output_value_slot_ids:
+        raise ValueError("numerical current capture output-slot identity drifted")
+
+    ranges: list[tuple[int, int]] = []
+    records: list[dict[str, object]] = []
+    current_id: int | None = None
+    partition_start = 0
+    partition_slots: list[dict[str, object]] = []
+    seen_current_ids: set[int] = set()
+    seen_value_slot_ids: set[int] = set()
+    expected_output_start = 0
+
+    def finish_partition(stop: int) -> None:
+        if current_id is None or not partition_slots or partition_start >= stop:
+            raise ValueError("numerical current capture output partition is empty")
+        ranges.append((partition_start, stop))
+        records.append(
+            {
+                "current_id": current_id,
+                "output_start": partition_start,
+                "output_stop": stop,
+                "slots": list(partition_slots),
+            }
+        )
+
+    for slot in stage.output_slots:
+        if (
+            type(slot.current_id) is not int
+            or slot.current_id < 0
+            or type(slot.value_slot_id) is not int
+            or slot.value_slot_id < 0
+            or slot.value_slot_id in seen_value_slot_ids
+            or type(slot.output_start) is not int
+            or type(slot.output_stop) is not int
+            or slot.output_start != expected_output_start
+            or slot.output_stop <= slot.output_start
+            or slot.output_stop > stage.output_length
+            or slot.output_stop - slot.output_start
+            != slot.component_stop - slot.component_start
+        ):
+            raise ValueError(
+                "numerical current capture output slots overlap, gap, or "
+                "have an invalid identity"
+            )
+        if current_id is None:
+            current_id = slot.current_id
+            seen_current_ids.add(current_id)
+        elif slot.current_id != current_id:
+            finish_partition(slot.output_start)
+            if slot.current_id in seen_current_ids or slot.current_id <= current_id:
+                raise ValueError(
+                    "numerical current capture output-slot current order drifted"
+                )
+            current_id = slot.current_id
+            seen_current_ids.add(current_id)
+            partition_start = slot.output_start
+            partition_slots = []
+        seen_value_slot_ids.add(slot.value_slot_id)
+        partition_slots.append(
+            {
+                "value_slot_id": slot.value_slot_id,
+                "variant": slot.variant,
+                "component_start": slot.component_start,
+                "component_stop": slot.component_stop,
+                "output_start": slot.output_start,
+                "output_stop": slot.output_stop,
+            }
+        )
+        expected_output_start = slot.output_stop
+
+    if expected_output_start != stage.output_length:
+        raise ValueError(
+            "numerical current capture output partitions are not exhaustive"
+        )
+    finish_partition(stage.output_length)
+    return tuple(ranges), {
+        "stage_index": stage.stage_index,
+        "stage_kind": stage.stage_kind,
+        "subset_size": stage.subset_size,
+        "output_length": stage.output_length,
+        "partitions": records,
+    }
+
+
+def _current_capture_partition_plan(
+    stages: Sequence[GenericCompiledStageBlueprint],
+) -> tuple[tuple[tuple[tuple[int, int], ...], ...], str]:
+    """Authenticate one stable current-ID partition plan for all stages."""
+
+    stage_partitions: list[tuple[tuple[int, int], ...]] = []
+    stage_contracts: list[dict[str, object]] = []
+    previous_stage_index: int | None = None
+    for stage in stages:
+        if type(stage.stage_index) is not int or (
+            previous_stage_index is not None
+            and stage.stage_index <= previous_stage_index
+        ):
+            raise ValueError("numerical current capture stage order drifted")
+        partitions, contract = _current_capture_output_partitions(stage)
+        stage_partitions.append(partitions)
+        stage_contracts.append(contract)
+        previous_stage_index = stage.stage_index
+    if not stage_partitions:
+        raise ValueError("numerical current capture has no evaluator stages")
+    payload = {
+        "abi": _CAPTURE_OUTPUT_PARTITION_ABI,
+        "strategy": "one-contiguous-output-partition-per-current-id",
+        "stages": stage_contracts,
+    }
+    return tuple(stage_partitions), _canonical_sha256(payload)
+
+
+def _build_current_capture_session(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str,
+) -> _GenericDAGCurrentCaptureSession:
+    runtime_schema = build_runtime_expression_schema(
+        dag,
+        model,
+        process_id=process_id,
+    )
+    schema = runtime_schema.to_mapping()
+    blueprint = build_generic_stage_compiler_blueprint(
+        StageCompilationInput(dag, model, runtime_schema)
+    )
+    if not blueprint.expression_ready:
+        raise ValueError(
+            "numerical current capture cannot lower stage expressions: "
+            + "; ".join(blueprint.blockers)
+        )
+    settings = SymbolicaEvaluatorSettings(
+        iterations=1,
+        cpe_iterations=0,
+        n_cores=1,
+        direct_translation=False,
+        jit_direct_translation=False,
+        jit_optimization_level=0,
+        compiled_output_chunk_size=None,
+        output_chunk_strategy="uniform",
+        compiled_chunk_compile_workers=1,
+    )
+    stage_output_partitions, output_partition_digest = _current_capture_partition_plan(
+        blueprint.stages
+    )
+    runtime_output_partition_digest = (
+        generic_dag_numerical_capture_output_partition_sha256(schema)
+    )
+    if output_partition_digest != runtime_output_partition_digest:
+        raise ValueError(
+            "numerical current capture evaluator partitions drifted from "
+            "runtime output-slot geometry"
+        )
+    stage_evaluators = tuple(
+        _build_interpreted_stage_evaluator(
+            stage,
+            settings=settings,
+            output_partitions=output_partitions,
+        )
+        for stage, output_partitions in zip(
+            blueprint.stages,
+            stage_output_partitions,
+            strict=True,
+        )
+    )
+    model_parameters = _runtime_model_parameter_values(schema)
+    return _GenericDAGCurrentCaptureSession(
+        dag=dag,
+        process_id=process_id,
+        runtime_schema=runtime_schema,
+        schema=schema,
+        stages=blueprint.stages,
+        stage_evaluators=stage_evaluators,
+        model_parameters=model_parameters,
+        source_dag_sha256=_canonical_sha256(dag.to_json_dict()),
+        evaluator_output_partition_abi=_CAPTURE_OUTPUT_PARTITION_ABI,
+        evaluator_output_partition_sha256=output_partition_digest,
+    )
+
+
+def validate_independent_current_observation_captures(
+    candidate: GenericDAGCurrentObservationCapture,
+    verification: GenericDAGCurrentObservationCapture,
+) -> None:
+    """Fail closed unless two capture batches form one independent contract."""
+
+    if (
+        candidate.precision_digits != verification.precision_digits
+        or candidate.runtime_schema_sha256 != verification.runtime_schema_sha256
+        or candidate.model_parameter_schema_sha256
+        != verification.model_parameter_schema_sha256
+        or candidate.source_dag_sha256 != verification.source_dag_sha256
+        or candidate.evaluator_output_partition_abi
+        != verification.evaluator_output_partition_abi
+        or candidate.evaluator_output_partition_sha256
+        != verification.evaluator_output_partition_sha256
+        or set(candidate.observations) != set(verification.observations)
+        or candidate.point_count < 2
+        or verification.point_count < 2
+        or len(set(candidate.point_sha256s)) != candidate.point_count
+        or len(set(verification.point_sha256s)) != verification.point_count
+        or not set(candidate.point_sha256s).isdisjoint(verification.point_sha256s)
+        or len(set(candidate.kinematic_sha256s)) != candidate.point_count
+        or len(set(verification.kinematic_sha256s)) != verification.point_count
+        or not set(candidate.kinematic_sha256s).isdisjoint(
+            verification.kinematic_sha256s
+        )
+        or len(candidate.parameter_context_sha256s) != candidate.point_count
+        or len(verification.parameter_context_sha256s) != verification.point_count
+        or not set(candidate.parameter_context_sha256s).isdisjoint(
+            verification.parameter_context_sha256s
+        )
+    ):
+        raise ValueError(
+            "numerical current candidate and verification captures do not "
+            "form independent replay domains"
+        )
+    for current_id in candidate.observations:
+        candidate_values = candidate.observations[current_id]
+        verification_values = verification.observations[current_id]
+        if (
+            len(candidate_values) % candidate.point_count != 0
+            or len(verification_values) % verification.point_count != 0
+            or len(candidate_values) // candidate.point_count
+            != len(verification_values) // verification.point_count
+        ):
+            raise ValueError(
+                f"numerical current {current_id} capture widths drifted "
+                "between candidate and verification domains"
+            )
+
+
+def _validate_applied_current_observations(
+    reference: GenericDAGCurrentObservationCapture,
+    applied: GenericDAGCurrentObservationCapture,
+    *,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+) -> dict[str, object]:
+    """Authenticate that reuse application preserves every observed current."""
+
+    if (
+        reference.precision_digits != applied.precision_digits
+        or reference.point_sha256s != applied.point_sha256s
+        or reference.kinematic_sha256s != applied.kinematic_sha256s
+        or reference.parameter_contexts != applied.parameter_contexts
+        or reference.parameter_context_sha256s != applied.parameter_context_sha256s
+        or reference.model_parameter_schema_sha256
+        != applied.model_parameter_schema_sha256
+        or reference.evaluator_output_partition_abi
+        != applied.evaluator_output_partition_abi
+        or reference.evaluator_output_partition_sha256
+        != applied.evaluator_output_partition_sha256
+        or set(reference.observations) != set(applied.observations)
+    ):
+        raise ValueError("numerical current application validation provenance drifted")
+    with localcontext() as context:
+        context.prec = reference.precision_digits + _NUMERICAL_DECIMAL_GUARD_DIGITS
+        context.rounding = ROUND_HALF_EVEN
+        relative = Decimal.from_float(float(relative_tolerance))
+        absolute = Decimal.from_float(float(absolute_tolerance))
+        if (
+            not relative.is_finite()
+            or not absolute.is_finite()
+            or relative < 0
+            or absolute < 0
+            or (relative == 0 and absolute == 0)
+        ):
+            raise ValueError(
+                "numerical current application validation tolerances are invalid"
+            )
+        maximum_absolute = Decimal(0)
+        maximum_relative = Decimal(0)
+        maximum_tolerance_ratio = Decimal(0)
+        checked_components = 0
+        for current_id in sorted(reference.observations):
+            before = reference.observations[current_id]
+            after = applied.observations[current_id]
+            if len(before) != len(after):
+                raise ValueError(
+                    f"numerical current {current_id} application width drifted"
+                )
+            for observation_index, (baseline, optimized) in enumerate(
+                zip(before, after, strict=True)
+            ):
+                difference = max(
+                    abs(baseline[0] - optimized[0]),
+                    abs(baseline[1] - optimized[1]),
+                )
+                scale = max(
+                    abs(baseline[0]),
+                    abs(baseline[1]),
+                    abs(optimized[0]),
+                    abs(optimized[1]),
+                )
+                allowed = absolute + relative * scale
+                relative_residual = (
+                    Decimal(0) if difference == 0 else difference / max(scale, absolute)
+                )
+                tolerance_ratio = (
+                    Decimal(0) if difference == 0 else difference / allowed
+                )
+                maximum_absolute = max(maximum_absolute, difference)
+                maximum_relative = max(
+                    maximum_relative,
+                    relative_residual,
+                )
+                maximum_tolerance_ratio = max(
+                    maximum_tolerance_ratio,
+                    tolerance_ratio,
+                )
+                checked_components += 1
+                if not difference <= allowed:
+                    raise ValueError(
+                        "numerical current application changed current "
+                        f"{current_id} observation {observation_index} beyond "
+                        "its authenticated tolerance: "
+                        f"difference={_decimal_string(difference)}, "
+                        f"allowed={_decimal_string(allowed)}, "
+                        "tolerance_ratio="
+                        f"{_decimal_string(tolerance_ratio)}"
+                    )
+        return {
+            "status": "verified",
+            "checked_current_count": len(reference.observations),
+            "checked_component_count": checked_components,
+            "maximum_absolute_residual": _decimal_string(maximum_absolute),
+            "maximum_relative_residual": _decimal_string(maximum_relative),
+            "maximum_tolerance_ratio": _decimal_string(maximum_tolerance_ratio),
+            "reference_observation_batch_sha256": (reference.observation_batch_sha256),
+            "applied_observation_batch_sha256": (applied.observation_batch_sha256),
+            "evaluator_output_partition_abi": (
+                reference.evaluator_output_partition_abi
+            ),
+            "evaluator_output_partition_sha256": (
+                reference.evaluator_output_partition_sha256
+            ),
+        }
+
+
+def _build_interpreted_stage_evaluator(
+    stage: GenericCompiledStageBlueprint,
+    *,
+    settings: SymbolicaEvaluatorSettings,
+    output_partitions: Sequence[tuple[int, int]],
+) -> Any:
+    evaluator = _compile_symbolica_outputs(
+        stage.output_expressions,
+        list(stage.parameter_symbols),
+        merge_evaluators_strategy=False,
+        verbose_evaluator_build=False,
+        functions={
+            (function, arguments): body
+            for function, arguments, body in stage.symbolica_functions
+        },
+        real_params=stage.real_valued_inputs,
+        symbolica_settings=settings,
+        jit_compile=False,
+        label=f"numerical_current_warmup_stage_{stage.stage_index}",
+        output_partitions=output_partitions,
+    )
+    partitions = tuple(output_partitions)
+    if len(partitions) == 1:
+        evaluators = (evaluator,)
+        chunk_input_indices = (tuple(range(stage.parameter_count)),)
+    else:
+        evaluators = getattr(evaluator, "_evaluators", None)
+        chunk_input_indices = getattr(
+            evaluator,
+            "_chunk_input_indices",
+            None,
+        )
+        if not isinstance(evaluators, tuple) or not isinstance(
+            chunk_input_indices,
+            tuple,
+        ):
+            raise ValueError(
+                "numerical current warm-up partition compilation did not "
+                "retain its evaluator leaves"
+            )
+    return _PartitionedCurrentCaptureStageEvaluator(
+        evaluators=evaluators,
+        chunk_input_indices=chunk_input_indices,
+        output_partitions=partitions,
+        input_len=stage.parameter_count,
+        output_len=stage.output_length,
+    )
+
+
+def _capture_one_point(
+    dag: GenericDAG,
+    schema: Mapping[str, object],
+    stages: tuple[GenericCompiledStageBlueprint, ...],
+    evaluators: tuple[Any, ...],
+    point: tuple[tuple[Decimal, ...], ...],
+    model_parameters: tuple[Decimal, ...],
+    *,
+    precision: int,
+) -> dict[int, tuple[_ComplexDecimal, ...]]:
+    layout = _mapping(schema.get("parameter_layout"), "parameter layout")
+    value_count = _integer(layout.get("value_component_count"))
+    momentum_count = _integer(layout.get("momentum_parameter_count"))
+    flattened_count = _integer(layout.get("parameter_count_if_flattened"))
+    model_start = value_count + momentum_count
+    state = [
+        (Decimal(0), Decimal(0))
+        for _index in range(max(flattened_count, model_start + len(model_parameters)))
+    ]
+    _fill_sources(state, point, schema, model_parameters)
+    _fill_momenta(state, point, schema)
+    for index, value in enumerate(model_parameters):
+        state[model_start + index] = (value, Decimal(0))
+
+    captured: dict[int, tuple[_ComplexDecimal, ...]] = {}
+    source_fill = _mapping(schema.get("source_fill"), "source fill")
+    sources = _sequence(source_fill.get("sources"), "source rows")
+    for raw_source in sources:
+        source = _mapping(raw_source, "source row")
+        slot = _mapping(source.get("value_slot"), "source value slot")
+        current_id = _integer(source.get("current_id"))
+        start = _integer(slot.get("component_start"))
+        stop = _integer(slot.get("component_stop"))
+        if current_id in captured or not 0 <= start <= stop <= len(state):
+            raise ValueError("numerical current source capture has an invalid slot")
+        captured[current_id] = tuple(state[start:stop])
+
+    for stage, evaluator in zip(stages, evaluators, strict=True):
+        inputs: list[_ComplexDecimal | None] = [None] * stage.parameter_count
+        for component in stage.input_components:
+            if (
+                not 0 <= component.parameter_index < len(inputs)
+                or not 0 <= component.global_component < len(state)
+                or inputs[component.parameter_index] is not None
+            ):
+                raise ValueError("numerical current stage input mapping is invalid")
+            inputs[component.parameter_index] = state[component.global_component]
+        if any(value is None for value in inputs):
+            raise ValueError("numerical current stage input mapping is incomplete")
+        outputs = _evaluate_interpreted_stage(
+            evaluator,
+            tuple(value for value in inputs if value is not None),
+            precision=precision,
+        )
+        if len(outputs) != stage.output_length:
+            raise ValueError(
+                "numerical current stage evaluator returned the wrong width"
+            )
+        for slot in stage.output_slots:
+            values = outputs[slot.output_start : slot.output_stop]
+            if (
+                slot.current_id in captured
+                or len(values) != slot.component_stop - slot.component_start
+                or not 0 <= slot.component_start <= slot.component_stop <= len(state)
+            ):
+                raise ValueError("numerical current stage output mapping is invalid")
+            state[slot.component_start : slot.component_stop] = values
+            captured[slot.current_id] = values
+    if set(captured) != {current.id for current in dag.currents}:
+        raise ValueError(
+            "numerical current capture did not visit every current exactly once"
+        )
+    return captured
+
+
+def _evaluate_interpreted_stage(
+    evaluator: Any,
+    values: tuple[_ComplexDecimal, ...],
+    *,
+    precision: int,
+) -> tuple[_ComplexDecimal, ...]:
+    evaluate = getattr(evaluator, "evaluate_complex_with_prec", None)
+    if not callable(evaluate):
+        raise ValueError(
+            "numerical current warm-up evaluator lacks high-precision replay"
+        )
+    try:
+        raw = evaluate(values, precision)
+    except Exception as error:
+        raise ValueError(
+            f"numerical current high-precision stage replay failed: {error}"
+        ) from error
+    return tuple(
+        (
+            _decimal(real, "numerical current real component"),
+            _decimal(imaginary, "numerical current imaginary component"),
+        )
+        for value in raw
+        for real, imaginary in (value.to_decimal_tuple(),)
+    )
+
+
+def _runtime_model_parameter_values(
+    schema: Mapping[str, object],
+) -> tuple[Decimal, ...]:
+    records = _sequence(schema.get("model_parameters", ()), "model parameters")
+    ordered: list[Decimal | None] = [None] * len(records)
+    for raw_record in records:
+        record = _mapping(raw_record, "model parameter")
+        index = _integer(record.get("parameter_index"))
+        if (
+            not 0 <= index < len(ordered)
+            or ordered[index] is not None
+            or "default" not in record
+        ):
+            raise ValueError("numerical current model-parameter layout is invalid")
+        value = float(record["default"])
+        if not isfinite(value):
+            raise ValueError("numerical current model parameter is non-finite")
+        ordered[index] = Decimal.from_float(value)
+    if any(value is None for value in ordered):
+        raise ValueError("numerical current model-parameter layout is incomplete")
+    return tuple(value for value in ordered if value is not None)
+
+
+def _build_parameter_probe_contexts(
+    defaults: tuple[Decimal, ...],
+    *,
+    precision_digits: int,
+    seed: int,
+    domain: str,
+    count: int,
+    include_defaults: bool,
+) -> tuple[tuple[Decimal, ...], ...]:
+    """Build independent deterministic probes over every runtime slot.
+
+    Runtime APIs can override external and derived flattened parameter slots.
+    Sampling every slot independently is therefore a conservative check: a
+    relation that exists only at the model defaults is not eligible for
+    permanent evaluator reuse.
+    """
+
+    if (
+        type(precision_digits) is not int
+        or precision_digits < 80
+        or type(seed) is not int
+        or seed < 0
+        or not isinstance(domain, str)
+        or not domain
+        or type(count) is not int
+        or count < 2
+    ):
+        raise ValueError("numerical current parameter-probe contract is invalid")
+    working_precision = precision_digits + 16
+    contexts: list[tuple[Decimal, ...]] = []
+    with localcontext() as context:
+        context.prec = working_precision
+        context.rounding = ROUND_HALF_EVEN
+        for probe_index in range(count):
+            if include_defaults and probe_index == 0:
+                contexts.append(defaults)
+                continue
+            values: list[Decimal] = []
+            for parameter_index, default in enumerate(defaults):
+                digest = hashlib.sha256(
+                    (f"{seed}:{domain}:{probe_index}:{parameter_index}").encode("ascii")
+                ).digest()
+                signed = int.from_bytes(digest[:8], "big") - (1 << 63)
+                if signed == 0:
+                    signed = 1
+                # At most a 1/16 perturbation of max(|default|, 1).
+                relative_offset = Decimal(signed) / Decimal(1 << 67)
+                scale = max(abs(default), Decimal(1))
+                values.append(default + scale * relative_offset)
+            contexts.append(tuple(values))
+    return tuple(contexts)
+
+
+def _validation_point_sha256(point: ValidationPointRecord) -> str:
+    return _canonical_sha256(point.to_mapping())
+
+
+def _kinematic_sha256(point: ValidationPointRecord) -> str:
+    return _canonical_sha256(
+        [
+            {
+                "pdg": pdg,
+                "momentum": [format(float(value), ".17g") for value in momentum],
+            }
+            for pdg, momentum in point.particles
+        ]
+    )
+
+
+def _domain_seed(seed: int, *, domain: str, index: int) -> int:
+    digest = hashlib.sha256(f"{seed}:{domain}:{index}".encode("ascii")).digest()
+    return int.from_bytes(digest[:8], "big") & ((1 << 63) - 1)
+
+
+def _canonical_sha256(value: object) -> str:
+    payload = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _decimal_string(value: Decimal) -> str:
+    if not value.is_finite():
+        raise ValueError("canonical Decimal serialization requires finiteness")
+    sign, digits, exponent = value.as_tuple()
+    if not any(digits):
+        return "0"
+    if not isinstance(exponent, int):
+        raise ValueError("canonical Decimal serialization requires an exponent")
+    coefficient = "".join(str(digit) for digit in digits)
+    return f"{'-' if sign else ''}{coefficient}e{exponent}"
+
+
+def _mapping(value: object, label: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise ValueError(f"numerical current {label} is not an object")
+    return value
+
+
+def _sequence(value: object, label: str) -> Sequence[object]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise ValueError(f"numerical current {label} is not a sequence")
+    return value
+
+
+def _integer(value: object) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise ValueError("numerical current layout integer is invalid")
+    return value
+
+
+__all__ = [
+    "GenericDAGCurrentObservationCapture",
+    "GenericDAGNumericalCurrentWarmupResult",
+    "build_numerical_current_probe_points",
+    "capture_generic_dag_current_observations",
+    "generic_dag_numerical_current_opt_out_report",
+    "run_generic_dag_numerical_current_warmup",
+    "validate_independent_current_observation_captures",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/on_the_fly_seed.py b/pyamplicol/src/pyamplicol/generation/on_the_fly_seed.py
new file mode 100644
index 0000000000..b4815ada43
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/on_the_fly_seed.py
@@ -0,0 +1,288 @@
+# SPDX-License-Identifier: 0BSD
+"""Compact source projection for the private on-the-fly lane.
+
+This boundary deliberately stops before color-sector planning, process-DAG
+construction, recurrence schedule lowering, and numerical relation discovery.
+It retains only the canonical external source domain and the model-owned roots
+needed by Rust to discover one requested recurrence at runtime.  Contracted
+NLC/full generation additionally retains a Python-only color plan beside the
+seed; it never enters the process-seed-v1 wire contract.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Final, Literal
+
+from ..color import GenericColorPlan, build_color_plan
+from ..models.base import Model
+from ..models.recurrence_template import RecurrenceTemplateCatalog
+from ..processes.ir import CanonicalProcessIR
+from .recurrence_columnar import (
+    ExactComplexRationalV1,
+    RecurrenceCouplingLimitV1,
+    RecurrenceExternalLegV1,
+    RecurrenceNormalizationV1,
+    RecurrenceParameterProjectionV1,
+)
+from .recurrence_fermion_pairing import (
+    FermionPairingRootsV1,
+    build_recurrence_fermion_pairing_roots_v1,
+)
+from .recurrence_physics import build_recurrence_normalization
+from .recurrence_projection import (
+    RecurrenceProjectionError,
+    _digest,
+    _project_coupling_limits,
+    _project_external_legs,
+    _project_parameters,
+    _project_template_references,
+)
+
+ON_THE_FLY_SOURCE_PROJECTION_SCHEMA: Final = 1
+
+
+@dataclass(frozen=True, slots=True)
+class OnTheFlyProcessSeedProjectionV1:
+    """Minimal deterministic input to the native process-seed builder."""
+
+    process_digest: str
+    external_sources: tuple[RecurrenceExternalLegV1, ...]
+    external_permutation: tuple[int, ...]
+    parameter_projection: tuple[RecurrenceParameterProjectionV1, ...]
+    coupling_order_policy: Literal["minimal", "explicit"]
+    coupling_hierarchies: tuple[tuple[str, int], ...]
+    coupling_limits: tuple[RecurrenceCouplingLimitV1, ...]
+    fermion_pairing: FermionPairingRootsV1 | None
+    normalization: RecurrenceNormalizationV1
+
+    def to_json_dict(self) -> dict[str, object]:
+        """Return the exact private JSON root accepted by the Rust builder."""
+
+        return {
+            "schema_version": ON_THE_FLY_SOURCE_PROJECTION_SCHEMA,
+            "process_digest": self.process_digest,
+            "external_permutation": list(self.external_permutation),
+            "external_sources": [
+                {
+                    "source_slot": leg.source_slot,
+                    "public_label": leg.public_label,
+                    "is_initial": leg.is_initial,
+                    "states": [
+                        {
+                            "state_index": state.state_index,
+                            "public_helicity": state.public_helicity,
+                            # The direct source executor consumes the same
+                            # crossed helicity as the public recurrence source
+                            # state.  The source template retains the declared
+                            # (outgoing-basis) helicity separately by ID.
+                            "source_helicity": state.public_helicity,
+                            "source_template_id": state.source_template_id,
+                            "current_state_template_id": (
+                                state.current_state_template_id
+                            ),
+                            "momentum_sign": state.momentum_sign,
+                            "crossing_phase": _exact_json(state.crossing_phase),
+                            "spin_state": state.spin_state,
+                            "chirality": state.chirality,
+                        }
+                        for state in leg.source_states
+                    ],
+                }
+                for leg in self.external_sources
+            ],
+            "parameter_projection": [
+                {
+                    "parameter_template_id": row.parameter_template_id,
+                    "prepared_parameter_id": row.prepared_parameter_id,
+                    "component": row.component,
+                }
+                for row in self.parameter_projection
+            ],
+            "coupling_order_policy": self.coupling_order_policy,
+            "coupling_hierarchies": [
+                {"name": name, "hierarchy": hierarchy}
+                for name, hierarchy in self.coupling_hierarchies
+            ],
+            "coupling_limits": [
+                {"name": row.name, "maximum": row.maximum}
+                for row in self.coupling_limits
+            ],
+            "fermion_pairing": (
+                None
+                if self.fermion_pairing is None
+                else {
+                    "endpoints": [
+                        {
+                            "source_slot": endpoint.source_slot,
+                            "color_orientation": endpoint.color_orientation,
+                            "contract_digest": endpoint.contract_digest,
+                        }
+                        for endpoint in self.fermion_pairing.endpoints
+                    ],
+                    "classes": [
+                        {
+                            "species": pairing_class.species,
+                            "proof_digest": pairing_class.proof_digest,
+                            "fundamental_source_slots": list(
+                                pairing_class.fundamental_source_slots
+                            ),
+                            "antifundamental_source_slots": list(
+                                pairing_class.antifundamental_source_slots
+                            ),
+                        }
+                        for pairing_class in self.fermion_pairing.classes
+                    ],
+                }
+            ),
+            "normalization": {
+                "factor": _exact_json(self.normalization.factor),
+                "convention": self.normalization.convention,
+                "semantic_digest": self.normalization.semantic_digest,
+            },
+        }
+
+    def to_json_bytes(self) -> bytes:
+        """Encode canonical ASCII without adding a second artifact identity."""
+
+        return json.dumps(
+            self.to_json_dict(),
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+
+
+@dataclass(frozen=True, slots=True)
+class OnTheFlyGenerationProjectionV1:
+    """Source seed plus existing runtime-normalization metadata for the writer."""
+
+    seed: OnTheFlyProcessSeedProjectionV1
+    runtime_normalization: Mapping[str, object]
+    color_plan: GenericColorPlan | None = None
+
+
+def project_on_the_fly_process_seed_v1(
+    process: CanonicalProcessIR,
+    template_catalog: RecurrenceTemplateCatalog,
+    model: Model,
+    *,
+    coupling_order_policy: Literal["minimal", "explicit"],
+    coupling_order_limits: Mapping[str, int],
+    reference_color_order: Sequence[int] | None = None,
+    color_basis: Literal["trace", "adjoint"] = "trace",
+) -> OnTheFlyGenerationProjectionV1:
+    """Project one complete source domain without materializing a process DAG.
+
+    The projection always retains every source state. Runtime selectors choose
+    helicities after loading.  LC also chooses a color flow lazily; NLC/full
+    carries a separate contracted-color payload over the same structural
+    selector domain.
+    """
+
+    if not isinstance(process, CanonicalProcessIR):
+        raise TypeError("on-the-fly projection requires a CanonicalProcessIR")
+    if process.color_accuracy not in {"lc", "nlc", "full"}:
+        raise RecurrenceProjectionError(
+            "on-the-fly source projection requires LC, NLC, or full color"
+        )
+    if not isinstance(template_catalog, RecurrenceTemplateCatalog):
+        raise TypeError(
+            "on-the-fly projection requires a validated recurrence template catalog"
+        )
+    if coupling_order_policy not in {"minimal", "explicit"}:
+        raise RecurrenceProjectionError(
+            "on-the-fly coupling-order policy must be 'minimal' or 'explicit'"
+        )
+
+    template_ids, _template_references = _project_template_references(template_catalog)
+    external_sources, selected_sources = _project_external_legs(
+        process,
+        template_catalog,
+        template_ids,
+        None,
+        1,
+    )
+    if selected_sources is not None:  # pragma: no cover - fixed by this call
+        raise AssertionError("complete on-the-fly source projection was trimmed")
+    pairing = build_recurrence_fermion_pairing_roots_v1(
+        process,
+        template_catalog.current_states,
+        quantum_flows=template_catalog.quantum_flows,
+    )
+    normalization, runtime_normalization = build_recurrence_normalization(
+        process,
+        model,
+    )
+    color_plan = None
+    if process.color_accuracy in {"nlc", "full"}:
+        color_plan = build_color_plan(
+            process,
+            basis=color_basis,
+            color_accuracy=process.color_accuracy,
+            reference_color_order=reference_color_order,
+            fold_trace_reflections=False,
+        )
+        if color_plan.truncated or not color_plan.sectors:
+            detail = "; ".join(color_plan.diagnostics) or "no color sectors"
+            raise RecurrenceProjectionError(
+                "on-the-fly contracted-color projection has no complete color "
+                f"plan: {detail}"
+            )
+    coupling_order_names = sorted(
+        {
+            str(name).upper()
+            for records in (
+                template_catalog.quantum_flows,
+                template_catalog.transitions,
+                template_catalog.closures,
+            )
+            for record in records
+            for name, _power in record.coupling_orders
+        }
+    )
+    projected_coupling_limits = _project_coupling_limits(coupling_order_limits)
+    model_hierarchies = {
+        str(name).upper(): max(1, int(value))
+        for name, value in model.coupling_order_hierarchies().items()
+    }
+    seed = OnTheFlyProcessSeedProjectionV1(
+        process_digest=_digest(process.to_json_dict()),
+        external_sources=external_sources,
+        external_permutation=tuple(range(len(process.legs))),
+        parameter_projection=_project_parameters(template_catalog, template_ids),
+        coupling_order_policy=coupling_order_policy,
+        coupling_hierarchies=tuple(
+            (name, model_hierarchies.get(name, 1)) for name in coupling_order_names
+        ),
+        coupling_limits=tuple(
+            row for row in projected_coupling_limits if row.name in coupling_order_names
+        ),
+        fermion_pairing=(None if not pairing.endpoints else pairing),
+        normalization=normalization,
+    )
+    return OnTheFlyGenerationProjectionV1(
+        seed=seed,
+        runtime_normalization=runtime_normalization,
+        color_plan=color_plan,
+    )
+
+
+def _exact_json(value: ExactComplexRationalV1) -> dict[str, str]:
+    return {
+        "real_numerator": str(value.real_numerator),
+        "real_denominator": str(value.real_denominator),
+        "imag_numerator": str(value.imag_numerator),
+        "imag_denominator": str(value.imag_denominator),
+    }
+
+
+__all__ = [
+    "ON_THE_FLY_SOURCE_PROJECTION_SCHEMA",
+    "OnTheFlyGenerationProjectionV1",
+    "OnTheFlyProcessSeedProjectionV1",
+    "project_on_the_fly_process_seed_v1",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/phase_space.py b/pyamplicol/src/pyamplicol/generation/phase_space.py
new file mode 100644
index 0000000000..744c7cd449
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/phase_space.py
@@ -0,0 +1,183 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+from collections.abc import Sequence
+
+import numpy as np
+
+from .._internal.physics.types import FourMomentum, NativeEvaluationError
+
+
+def massive_rambo_final_state(
+    multiplicity: int,
+    *,
+    sqrt_s: float,
+    masses: Sequence[float],
+    seed: int,
+) -> tuple[FourMomentum, ...]:
+    """Generate a deterministic massive RAMBO final state.
+
+    This process-independent helper is the public version of the RAMBO
+    construction used by the generic DAG artifact writer.  It returns momenta
+    in the centre-of-mass frame with total four-momentum
+    ``(sqrt_s, 0, 0, 0)``.
+    """
+
+    return _massive_rambo_final_state(
+        multiplicity,
+        sqrt_s=sqrt_s,
+        masses=masses,
+        rng=np.random.default_rng(seed),
+    )
+
+
+def _massive_rambo_final_state(
+    multiplicity: int,
+    *,
+    sqrt_s: float,
+    masses: Sequence[float],
+    rng: np.random.Generator,
+) -> tuple[FourMomentum, ...]:
+    if multiplicity != len(masses):
+        raise NativeEvaluationError("RAMBO mass list length mismatch")
+    massless = _massless_rambo_final_state(multiplicity, sqrt_s=sqrt_s, rng=rng)
+    spatial_norms = tuple(
+        math.sqrt(momentum[1] ** 2 + momentum[2] ** 2 + momentum[3] ** 2)
+        for momentum in massless
+    )
+    scale = _massive_spatial_scale(spatial_norms, masses, sqrt_s=sqrt_s)
+    final: list[FourMomentum] = []
+    for momentum, mass, spatial_norm in zip(
+        massless,
+        masses,
+        spatial_norms,
+        strict=True,
+    ):
+        px = scale * momentum[1]
+        py = scale * momentum[2]
+        pz = scale * momentum[3]
+        energy = math.sqrt(mass * mass + (scale * spatial_norm) ** 2)
+        final.append((energy, px, py, pz))
+    return tuple(final)
+
+
+def _massless_rambo_final_state(
+    multiplicity: int,
+    *,
+    sqrt_s: float,
+    rng: np.random.Generator,
+) -> tuple[FourMomentum, ...]:
+    if multiplicity < 2:
+        raise NativeEvaluationError("RAMBO needs at least two final particles")
+    raw: list[FourMomentum] = []
+    for _ in range(multiplicity):
+        r = rng.random(4)
+        costheta = 2.0 * r[0] - 1.0
+        sintheta = math.sqrt(max(0.0, 1.0 - costheta * costheta))
+        phi = 2.0 * math.pi * r[1]
+        energy = -math.log(max(r[2] * r[3], np.finfo(float).tiny))
+        raw.append(
+            (
+                energy,
+                energy * sintheta * math.cos(phi),
+                energy * sintheta * math.sin(phi),
+                energy * costheta,
+            )
+        )
+
+    total = _sum_momenta(raw)
+    invariant = _minkowski_square(total)
+    if invariant <= 0.0:
+        raise NativeEvaluationError("RAMBO generated a non-timelike total momentum")
+    mass = math.sqrt(invariant)
+    beta_to_rest = (
+        -total[1] / total[0],
+        -total[2] / total[0],
+        -total[3] / total[0],
+    )
+    scale = sqrt_s / mass
+    return tuple(
+        (
+            scale * boosted[0],
+            scale * boosted[1],
+            scale * boosted[2],
+            scale * boosted[3],
+        )
+        for boosted in (_boost_from_rest(momentum, beta_to_rest) for momentum in raw)
+    )
+
+
+def _boost_from_rest(
+    momentum: FourMomentum, beta: tuple[float, float, float]
+) -> FourMomentum:
+    beta2 = beta[0] ** 2 + beta[1] ** 2 + beta[2] ** 2
+    if beta2 == 0.0:
+        return momentum
+    if beta2 >= 1.0:
+        raise NativeEvaluationError("invalid canonical boost with beta >= 1")
+    gamma = 1.0 / math.sqrt(1.0 - beta2)
+    beta_dot_p = beta[0] * momentum[1] + beta[1] * momentum[2] + beta[2] * momentum[3]
+    spatial_factor = ((gamma - 1.0) * beta_dot_p / beta2) + gamma * momentum[0]
+    return (
+        gamma * (momentum[0] + beta_dot_p),
+        momentum[1] + spatial_factor * beta[0],
+        momentum[2] + spatial_factor * beta[1],
+        momentum[3] + spatial_factor * beta[2],
+    )
+
+
+def _massive_spatial_scale(
+    spatial_norms: Sequence[float],
+    masses: Sequence[float],
+    *,
+    sqrt_s: float,
+) -> float:
+    if sum(masses) >= sqrt_s:
+        raise NativeEvaluationError("massive RAMBO point is below threshold")
+    low = 0.0
+    high = 1.0
+    while _massive_energy_sum(spatial_norms, masses, high) < sqrt_s:
+        high *= 2.0
+    for _ in range(128):
+        mid = 0.5 * (low + high)
+        if _massive_energy_sum(spatial_norms, masses, mid) > sqrt_s:
+            high = mid
+        else:
+            low = mid
+    return 0.5 * (low + high)
+
+
+def _massive_energy_sum(
+    spatial_norms: Sequence[float],
+    masses: Sequence[float],
+    scale: float,
+) -> float:
+    return sum(
+        math.sqrt(mass * mass + (scale * spatial_norm) ** 2)
+        for spatial_norm, mass in zip(spatial_norms, masses, strict=True)
+    )
+
+
+def _sum_momenta(momenta: Sequence[FourMomentum]) -> FourMomentum:
+    total = (0.0, 0.0, 0.0, 0.0)
+    for momentum in momenta:
+        total = (
+            total[0] + momentum[0],
+            total[1] + momentum[1],
+            total[2] + momentum[2],
+            total[3] + momentum[3],
+        )
+    return total
+
+
+def _minkowski_square(momentum: FourMomentum) -> float:
+    return (
+        momentum[0] * momentum[0]
+        - momentum[1] * momentum[1]
+        - momentum[2] * momentum[2]
+        - momentum[3] * momentum[3]
+    )
+
+
+__all__ = ["massive_rambo_final_state"]
diff --git a/pyamplicol/src/pyamplicol/generation/physics_metadata.py b/pyamplicol/src/pyamplicol/generation/physics_metadata.py
new file mode 100644
index 0000000000..6a0437716b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/physics_metadata.py
@@ -0,0 +1,988 @@
+# SPDX-License-Identifier: 0BSD
+"""Strict runtime-physics-v1 metadata derived from one compiled DAG."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping, Sequence
+from itertools import product
+from typing import Any
+
+from ..models.base import Model
+from .contracts import runtime_coupling_parameter_names
+from .dag_types import GenericDAG
+from .helicity_replay import (
+    HELICITY_RECURRENCE_CONTRACT_VERSION,
+    HELICITY_RECURRENCE_PROOF_ALGORITHM,
+    RUNTIME_SELECTOR_PROVENANCE,
+)
+from .runtime_amplitudes import build_runtime_amplitude_metadata
+
+_HELICITY_WEIGHT_TOLERANCE = 1.0e-12
+NATIVE_REDUCTION_GROUPS_EXTENSION_KEY = "native_reduction_groups"
+EAGER_PLAN_V3_REDUCTION_GROUPS_KIND = "pyamplicol-eager-plan-v3-reduction-groups"
+EAGER_PLAN_V3_REDUCTION_GROUPS_SCHEMA_VERSION = 1
+EAGER_PLAN_V3_REDUCTION_GROUPS_STORAGE_ABI = "pacbin-v1"
+EAGER_PLAN_V3_REDUCTION_GROUPS_RUNTIME_LAYOUT_ABI = "pyamplicol-eager-runtime-layout-v1"
+EAGER_PLAN_V3_REDUCTION_GROUPS_CONTAINER_PATH = "eager-runtime.pacbin"
+EAGER_PLAN_V3_REDUCTION_GROUPS_MEMBER = "reductions/groups.bin"
+EAGER_PLAN_V3_REDUCTION_ENTRIES_MEMBER = "reductions/entries.bin"
+_NORMALIZATION_EXTENSION_KEYS = (
+    "color_accuracy",
+    "color_factor",
+    "average_factor",
+    "identical_factor",
+    "global_coupling_factor",
+    "qcd_coupling_power",
+    "electroweak_coupling_power",
+    "couplings_in_stage_evaluators",
+    "coupling_policy",
+)
+
+
+def build_resolved_physics_from_dag(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str | None = None,
+    native_eager_plan_v3_reduction_groups: bool = False,
+    runtime_model_parameters: Sequence[Mapping[str, object]] | None = None,
+) -> dict[str, object]:
+    """Build strict public physics without constructing runtime storage layouts."""
+
+    amplitude_metadata = build_runtime_amplitude_metadata(dag, model)
+    model_parameters = (
+        build_runtime_model_parameter_records(
+            dag,
+            model,
+            amplitude_stage=amplitude_metadata,
+        )
+        if runtime_model_parameters is None
+        else list(runtime_model_parameters)
+    )
+    return build_resolved_physics_payload(
+        dag,
+        model,
+        process_id=process_id or dag.process.key,
+        amplitude_stage=amplitude_metadata,
+        model_parameters=model_parameters,
+        normalization=build_runtime_normalization(dag, model),
+        native_eager_plan_v3_reduction_groups=(native_eager_plan_v3_reduction_groups),
+    )
+
+
+def build_resolved_physics_payload(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str,
+    amplitude_stage: Mapping[str, object],
+    model_parameters: Sequence[Mapping[str, object]],
+    normalization: Mapping[str, object],
+    native_eager_plan_v3_reduction_groups: bool = False,
+) -> dict[str, object]:
+    """Build strict public axes and exact representative-reuse metadata."""
+
+    coherent_groups = _mapping_sequence(amplitude_stage.get("coherent_groups", ()))
+    helicities, group_helicities, structural_zero_count = _helicity_metadata(
+        dag,
+        model,
+        coherent_groups,
+        _mapping_sequence(amplitude_stage.get("roots", ())),
+    )
+    color_components, group_colors = _color_metadata(dag, coherent_groups)
+    if native_eager_plan_v3_reduction_groups:
+        reduction_groups: list[dict[str, object]] = []
+        native_reduction_extension = {
+            NATIVE_REDUCTION_GROUPS_EXTENSION_KEY: {
+                "kind": EAGER_PLAN_V3_REDUCTION_GROUPS_KIND,
+                "schema_version": EAGER_PLAN_V3_REDUCTION_GROUPS_SCHEMA_VERSION,
+                "storage_abi": EAGER_PLAN_V3_REDUCTION_GROUPS_STORAGE_ABI,
+                "runtime_layout_abi": (
+                    EAGER_PLAN_V3_REDUCTION_GROUPS_RUNTIME_LAYOUT_ABI
+                ),
+                "container_path": EAGER_PLAN_V3_REDUCTION_GROUPS_CONTAINER_PATH,
+                "group_member": EAGER_PLAN_V3_REDUCTION_GROUPS_MEMBER,
+                "entry_member": EAGER_PLAN_V3_REDUCTION_ENTRIES_MEMBER,
+                "group_count": len(coherent_groups),
+            }
+        }
+    else:
+        helicity_ids = {
+            tuple(_integer(value) for value in _sequence(record["values"])): str(
+                record["id"]
+            )
+            for record in helicities
+        }
+        reduction_groups = _reduction_groups(
+            coherent_groups,
+            group_helicities=group_helicities,
+            group_colors=group_colors,
+            helicity_ids=helicity_ids,
+        )
+        native_reduction_extension = {}
+    lc_color_complete = (
+        dag.color_coverage == "complete"
+        and not dag.selected_color_sector_ids
+        and not dag.color_plan.truncated
+        and len(color_components) == _expected_lc_physical_color_count(dag)
+    )
+    is_lc = dag.process.color_accuracy == "lc"
+    return {
+        "schema_version": 1,
+        "kind": "pyamplicol-resolved-physics",
+        "process_id": process_id,
+        "process": dag.process.process,
+        "color_accuracy": dag.process.color_accuracy,
+        "coverage": {
+            "helicities": dag.helicity_coverage,
+            "color": ("complete" if is_lc and lc_color_complete else "selected")
+            if is_lc
+            else "contracted",
+            "color_kind": "physical-lc-flows" if is_lc else "contracted-color",
+            "structural_zero_helicity_count": structural_zero_count,
+        },
+        "external_particles": _external_particles(dag),
+        "helicities": helicities,
+        "color_components": color_components,
+        "reduction": {
+            "kind": "lc-diagonal" if is_lc else "contracted-color",
+            "groups": reduction_groups,
+        },
+        "model_parameters": _public_model_parameters(model_parameters),
+        "selectors": {
+            "helicity": True,
+            "color_flow": is_lc,
+            "contracted_color": False,
+        },
+        "extensions": {
+            "process_key": dag.process.key,
+            "normalization": {
+                key: normalization[key]
+                for key in _NORMALIZATION_EXTENSION_KEYS
+                if key in normalization
+            },
+            "selected_source_helicities": {
+                str(label): helicity
+                for label, helicity in dag.selected_source_helicities
+            },
+            **(
+                {}
+                if dag.lc_topology_replay is None
+                else {"lc_topology_replay": dag.lc_topology_replay.to_json_dict()}
+            ),
+            **(
+                {}
+                if dag.color_topology_replay is None
+                else {
+                    "color_topology_replay": (dag.color_topology_replay.to_json_dict())
+                }
+            ),
+            **_runtime_selector_extension(dag),
+            **native_reduction_extension,
+        },
+    }
+
+
+def build_runtime_model_parameter_records(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    amplitude_stage: Mapping[str, object],
+) -> list[dict[str, object]]:
+    """Build the shared runtime parameter catalog used by execution and physics."""
+
+    records: list[dict[str, object]] = []
+    seen: set[str] = set()
+
+    def add(name: str, kind: str, default: float, **metadata: object) -> None:
+        if name in seen:
+            return
+        seen.add(name)
+        records.append(
+            {
+                "name": name,
+                "kind": kind,
+                "parameter_index": len(records),
+                "default": float(default),
+                **metadata,
+            }
+        )
+
+    def add_complex(
+        name: str,
+        value: object,
+        *,
+        kind: str,
+        **metadata: object,
+    ) -> None:
+        real, imaginary = _complex_pair(value, name)
+        for component, default in (("real", real), ("imag", imaginary)):
+            add(
+                f"{name}.{component}",
+                kind,
+                default,
+                runtime_name=name,
+                complex_component=component,
+                **metadata,
+            )
+
+    for raw_name, value in sorted(
+        model.runtime_normalization_parameter_defaults().items()
+    ):
+        add(str(raw_name), "normalization", float(value))
+    defaults_provider = getattr(model, "runtime_parameter_defaults", None)
+    if callable(defaults_provider):
+        type_provider = getattr(model, "runtime_parameter_type", None)
+        for raw_name, value in sorted(defaults_provider().items()):
+            name = str(raw_name)
+            declared = (
+                str(type_provider(name)).lower()
+                if callable(type_provider)
+                else "complex"
+            )
+            if declared == "complex":
+                add_complex(name, value, kind="external_parameter_component")
+            else:
+                real, imaginary = _complex_pair(value, name)
+                if imaginary != 0.0:
+                    raise ValueError(
+                        "real runtime model parameter "
+                        f"{name!r} has an imaginary default"
+                    )
+                add(name, "external_parameter", real, parameter_type=declared)
+        _add_derived_parameter_records(
+            dag,
+            model,
+            amplitude_stage=amplitude_stage,
+            add_complex=add_complex,
+        )
+        return records
+
+    for particle in sorted(model.particles.values(), key=lambda item: item.pdg):
+        if float(particle.mass) != 0.0:
+            add(
+                f"particle.{particle.pdg}.mass",
+                "particle_mass",
+                float(particle.mass),
+                pdg=particle.pdg,
+            )
+        if float(particle.width) != 0.0:
+            add(
+                f"particle.{particle.pdg}.width",
+                "particle_width",
+                float(particle.width),
+                pdg=particle.pdg,
+            )
+    for kind, particles, coupling in _coupling_signatures(dag, amplitude_stage):
+        names = runtime_coupling_parameter_names(
+            kind,
+            particles,
+            coupling,
+            model=model,
+        )
+        for component, name in enumerate(names):
+            if name is None:
+                continue
+            add(
+                name,
+                "coupling_component",
+                float(coupling[component]),
+                vertex_kind=kind,
+                vertex_particles=list(particles),
+                component=component,
+            )
+    return records
+
+
+def build_runtime_normalization(
+    dag: GenericDAG,
+    model: Model,
+) -> dict[str, object]:
+    """Build the shared runtime normalization payload for one DAG."""
+
+    return dict(model.runtime_normalization_payload(dag))
+
+
+def _add_derived_parameter_records(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    amplitude_stage: Mapping[str, object],
+    add_complex: Any,
+) -> None:
+    defaults_provider = getattr(model, "runtime_derived_parameter_defaults_for", None)
+    if not callable(defaults_provider):
+        return
+    used = _used_coupling_parameter_names(dag, model, amplitude_stage)
+    values = defaults_provider(tuple(sorted(used)))
+    domains_provider = getattr(model, "runtime_derived_parameter_domains_for", None)
+    domains = (
+        domains_provider(tuple(sorted(used))) if callable(domains_provider) else {}
+    )
+    for raw_name, value in sorted(values.items()):
+        name = str(raw_name)
+        domain = str(domains.get(raw_name, domains.get(name, "complex")))
+        if domain not in {"real", "imaginary", "complex"}:
+            raise ValueError(f"unsupported runtime parameter domain {domain!r}")
+        add_complex(
+            name,
+            value,
+            kind="derived_parameter_component",
+            derived=True,
+            complex_domain=domain,
+        )
+
+
+def _used_coupling_parameter_names(
+    dag: GenericDAG,
+    model: Model,
+    amplitude_stage: Mapping[str, object],
+) -> set[str]:
+    names = {
+        name
+        for interaction in dag.interactions
+        for name in runtime_coupling_parameter_names(
+            interaction.vertex_kind,
+            interaction.vertex_particles,
+            interaction.coupling,
+            model=model,
+        )
+        if name is not None
+    }
+    for root in _mapping_sequence(amplitude_stage["roots"]):
+        raw_names = root.get("coupling_parameter_names")
+        if isinstance(raw_names, list):
+            names.update(str(name) for name in raw_names if isinstance(name, str))
+    runtime_particle_names = getattr(
+        model,
+        "runtime_parameter_names_for_particle",
+        None,
+    )
+    if callable(runtime_particle_names):
+        for particle_id in {current.index.particle_id for current in dag.currents}:
+            names.update(str(name) for name in runtime_particle_names(int(particle_id)))
+    return names
+
+
+def _coupling_signatures(
+    dag: GenericDAG,
+    amplitude_stage: Mapping[str, object],
+) -> tuple[tuple[int, tuple[int, ...], tuple[float, ...]], ...]:
+    signatures = {
+        (
+            interaction.vertex_kind,
+            tuple(interaction.vertex_particles),
+            tuple(interaction.coupling),
+        )
+        for interaction in dag.interactions
+    }
+    for root in _mapping_sequence(amplitude_stage["roots"]):
+        kind = root.get("vertex_kind")
+        particles = root.get("vertex_particles")
+        coupling = root.get("coupling")
+        if (
+            isinstance(kind, int)
+            and isinstance(particles, list)
+            and isinstance(coupling, list)
+        ):
+            signatures.add(
+                (
+                    kind,
+                    tuple(int(pdg) for pdg in particles),
+                    tuple(float(value) for value in coupling),
+                )
+            )
+    return tuple(sorted(signatures))
+
+
+def _runtime_selector_extension(dag: GenericDAG) -> dict[str, object]:
+    """Emit independent runtime contracts for both selector axes."""
+
+    recurrence = dag.helicity_recurrence
+    helicity_complete = (
+        dag.helicity_coverage == "complete" and not dag.selected_source_helicities
+    )
+    recurrence_payload: dict[str, object] | None
+    if not helicity_complete:
+        recurrence_payload = None
+    elif recurrence is None:
+        recurrence_payload = {
+            "contract_version": HELICITY_RECURRENCE_CONTRACT_VERSION,
+            "proof_algorithm": HELICITY_RECURRENCE_PROOF_ALGORITHM,
+            "status": "unavailable",
+            "proof_counts": {},
+        }
+    else:
+        recurrence_payload = {
+            "contract_version": HELICITY_RECURRENCE_CONTRACT_VERSION,
+            "proof_algorithm": HELICITY_RECURRENCE_PROOF_ALGORITHM,
+            "status": "available",
+            "proof_counts": recurrence.proof_counts(),
+            **(
+                {}
+                if dag.helicity_materialization is None
+                else {
+                    "execution": (
+                        "materialized-recurrence-retained-proof-graph"
+                        if dag.helicity_materialization.strategy
+                        == "retained-proof-graph"
+                        else "materialized-recurrence-quotient"
+                    ),
+                    "materialization_strategy": (dag.helicity_materialization.strategy),
+                    "proof_current_count": (
+                        dag.helicity_materialization.proof_current_count
+                    ),
+                    "proof_amplitude_count": (
+                        dag.helicity_materialization.proof_root_count
+                    ),
+                    "materialized_current_count": (
+                        dag.helicity_materialization.materialized_current_count
+                    ),
+                    "materialized_amplitude_count": (
+                        dag.helicity_materialization.materialized_root_count
+                    ),
+                }
+            ),
+        }
+    is_lc = dag.process.color_accuracy == "lc"
+    color_complete = (
+        is_lc and dag.color_coverage == "complete" and not dag.selected_color_sector_ids
+    )
+    specialized_axes = [
+        *([] if helicity_complete else ["helicity"]),
+        *([] if not is_lc or color_complete else ["color_flow"]),
+    ]
+    selector_payload: dict[str, object] = {
+        "kind": "pyamplicol-runtime-selectors",
+        "contract_version": 1,
+        "provenance": RUNTIME_SELECTOR_PROVENANCE,
+        "axes": {
+            "helicity": {
+                "generation_coverage": dag.helicity_coverage,
+                "generation_selection": {
+                    str(label): int(helicity)
+                    for label, helicity in dag.selected_source_helicities
+                },
+                "runtime_contract": (
+                    "complete-reusable"
+                    if helicity_complete
+                    else "generation-specialized"
+                ),
+            },
+            "color_flow": {
+                "generation_coverage": (dag.color_coverage if is_lc else "contracted"),
+                "generation_selection": list(dag.selected_color_sector_ids),
+                "runtime_contract": (
+                    "complete-reusable"
+                    if color_complete
+                    else "generation-specialized"
+                    if is_lc
+                    else "contracted-color"
+                ),
+            },
+        },
+        "generation_specialized_axes": specialized_axes,
+    }
+    if recurrence_payload is not None:
+        selector_payload["helicity_recurrence"] = recurrence_payload
+    return {"runtime_selectors": selector_payload}
+
+
+def _helicity_metadata(
+    dag: GenericDAG,
+    model: Model,
+    groups: Sequence[Mapping[str, object]],
+    roots: Sequence[Mapping[str, object]],
+) -> tuple[list[dict[str, object]], dict[int, tuple[tuple[int, ...], ...]], int]:
+    if dag.helicity_materialization is not None:
+        return _materialized_helicity_metadata(dag, model, groups, roots)
+
+    represented: dict[tuple[int, ...], tuple[tuple[int, ...], bool]] = {}
+    group_members: dict[int, tuple[tuple[int, ...], ...]] = {}
+    for group in groups:
+        group_id = _integer(group["group_id"])
+        vector = tuple(_integer(value) for value in _sequence(group["helicities"]))
+        weight = _number(group.get("helicity_weight", 1.0))
+        if not math.isfinite(weight) or weight <= 0.0:
+            raise ValueError(f"invalid helicity weight {weight!r} in group {group_id}")
+        members = [vector]
+        if weight > 1.0 + _HELICITY_WEIGHT_TOLERANCE:
+            if not math.isclose(
+                weight,
+                2.0,
+                rel_tol=_HELICITY_WEIGHT_TOLERANCE,
+                abs_tol=_HELICITY_WEIGHT_TOLERANCE,
+            ):
+                raise ValueError(
+                    f"unsupported helicity reuse weight {weight!r} in group {group_id}"
+                )
+            flipped = tuple(-value for value in vector)
+            if flipped != vector:
+                members.append(flipped)
+        group_members[group_id] = tuple(members)
+        for index, member in enumerate(members):
+            candidate = (vector, index == 0)
+            previous = represented.setdefault(member, candidate)
+            if previous != candidate:
+                raise ValueError(
+                    f"inconsistent helicity representative for physical state {member}"
+                )
+
+    possible = _possible_helicity_vectors(dag, model)
+    structural_zeros = sorted(set(possible) - represented.keys())
+    for vector in structural_zeros:
+        represented[vector] = (vector, False)
+
+    identifiers = {vector: _helicity_id(vector) for vector in represented}
+    records: list[dict[str, object]] = []
+    for index, vector in enumerate(sorted(represented)):
+        representative, computed = represented[vector]
+        structural_zero = vector in structural_zeros
+        records.append(
+            {
+                "id": identifiers[vector],
+                "index": index,
+                "values": list(vector),
+                "computed": computed and not structural_zero,
+                "structural_zero": structural_zero,
+                "representative_id": identifiers[representative],
+                "coefficient": 0.0 if structural_zero else 1.0,
+            }
+        )
+    return records, group_members, len(structural_zeros)
+
+
+def _materialized_helicity_metadata(
+    dag: GenericDAG,
+    model: Model,
+    groups: Sequence[Mapping[str, object]],
+    roots: Sequence[Mapping[str, object]],
+) -> tuple[list[dict[str, object]], dict[int, tuple[tuple[int, ...], ...]], int]:
+    materialization = dag.helicity_materialization
+    recurrence = dag.helicity_recurrence
+    if materialization is None or recurrence is None:
+        raise ValueError("materialized helicity metadata requires its proof")
+
+    group_by_root_id = {
+        _integer(root["dag_root_id"]): _integer(root["coherent_group_id"])
+        for root in roots
+    }
+    domain_by_id = {domain.id: domain for domain in recurrence.selector_domains}
+    route_vectors_by_group: dict[int, set[tuple[int, ...]]] = {
+        _integer(group["group_id"]): set() for group in groups
+    }
+    route_coefficients: dict[tuple[int, ...], float] = {}
+    for route in materialization.amplitude_routes:
+        group_id = group_by_root_id.get(route.materialized_root_id)
+        if group_id is None:
+            raise ValueError(
+                "helicity route refers to an absent materialized amplitude root"
+            )
+        coefficient = route.factor[0] ** 2 + route.factor[1] ** 2
+        for domain_id in route.selector_domain_ids:
+            domain = domain_by_id.get(domain_id)
+            if domain is None or not domain.complete:
+                raise ValueError(
+                    "amplitude route refers to a non-complete selector domain"
+                )
+            by_label = dict(domain.source_states)
+            vector = tuple(by_label.get(int(leg.label), 0) for leg in dag.process.legs)
+            route_vectors_by_group[group_id].add(vector)
+            previous = route_coefficients.setdefault(vector, coefficient)
+            if not math.isclose(
+                previous,
+                coefficient,
+                rel_tol=_HELICITY_WEIGHT_TOLERANCE,
+                abs_tol=_HELICITY_WEIGHT_TOLERANCE,
+            ):
+                raise ValueError(
+                    f"inconsistent recurrence factor for physical helicity {vector}"
+                )
+
+    represented: dict[tuple[int, ...], tuple[tuple[int, ...], bool, float]] = {}
+    group_members: dict[int, tuple[tuple[int, ...], ...]] = {}
+    for group in groups:
+        group_id = _integer(group["group_id"])
+        representative = tuple(
+            _integer(value) for value in _sequence(group["helicities"])
+        )
+        members = tuple(sorted(route_vectors_by_group[group_id]))
+        if not members:
+            raise ValueError(
+                f"materialized helicity group {group_id} has no physical routes"
+            )
+        group_members[group_id] = members
+        for member in members:
+            candidate = (
+                representative,
+                member == representative,
+                route_coefficients[member],
+            )
+            previous = represented.setdefault(member, candidate)
+            if previous != candidate:
+                raise ValueError(
+                    f"inconsistent helicity representative for physical state {member}"
+                )
+
+    possible = _possible_helicity_vectors(dag, model)
+    structural_zeros = sorted(set(possible) - represented.keys())
+    expected_zero_domains = {
+        tuple(
+            dict(domain_by_id[domain_id].source_states).get(int(leg.label), 0)
+            for leg in dag.process.legs
+        )
+        for domain_id in recurrence.structural_zero_selector_domain_ids
+    }
+    if set(structural_zeros) != expected_zero_domains:
+        raise ValueError(
+            "materialized helicity routes do not match certified structural zeros"
+        )
+    for vector in structural_zeros:
+        represented[vector] = (vector, False, 0.0)
+
+    identifiers = {vector: _helicity_id(vector) for vector in represented}
+    records: list[dict[str, object]] = []
+    for index, vector in enumerate(sorted(represented)):
+        representative, computed, coefficient = represented[vector]
+        structural_zero = vector in structural_zeros
+        records.append(
+            {
+                "id": identifiers[vector],
+                "index": index,
+                "values": list(vector),
+                "computed": computed and not structural_zero,
+                "structural_zero": structural_zero,
+                "representative_id": identifiers[representative],
+                "coefficient": 0.0 if structural_zero else coefficient,
+            }
+        )
+    return records, group_members, len(structural_zeros)
+
+
+def _possible_helicity_vectors(
+    dag: GenericDAG,
+    model: Model,
+) -> tuple[tuple[int, ...], ...]:
+    selected = dict(dag.selected_source_helicities)
+    per_leg: list[tuple[int, ...]] = []
+    for leg in dag.process.legs:
+        if leg.outgoing_pdg is None:
+            per_leg.append((0,))
+            continue
+        particle_id = int(leg.outgoing_pdg)
+        source_ir = model._source_ir(particle_id)
+        values: set[int] = set()
+        for declared_state in source_ir.states:
+            state = (
+                source_ir.crossing.apply(declared_state)
+                if leg.is_initial
+                else declared_state
+            )
+            values.add(int(state.helicity))
+        if leg.label in selected:
+            requested = selected[leg.label]
+            values.intersection_update((requested,))
+            if not values:
+                raise ValueError(
+                    f"selected helicity {requested} is unavailable for external "
+                    f"leg {leg.label}"
+                )
+        per_leg.append(tuple(sorted(values)))
+    return tuple(tuple(values) for values in product(*per_leg))
+
+
+def _color_metadata(
+    dag: GenericDAG,
+    groups: Sequence[Mapping[str, object]],
+) -> tuple[list[dict[str, object]], dict[int, tuple[str, ...]]]:
+    if dag.process.color_accuracy != "lc":
+        identifier = "color:contracted"
+        return [
+            {
+                "kind": "contracted-color",
+                "id": identifier,
+                "index": 0,
+                "description": "coherent sparse contraction of the full color basis",
+            }
+        ], {_integer(group["group_id"]): (identifier,) for group in groups}
+
+    records: dict[str, dict[str, object]] = {}
+    members_by_group: dict[int, tuple[str, ...]] = {}
+    for group in groups:
+        group_id = _integer(group["group_id"])
+        word = tuple(_integer(value) for value in _sequence(group["color_word"]))
+        identifier = _color_id(word)
+        members = [identifier]
+        records.setdefault(
+            identifier,
+            {
+                "kind": "lc-flow",
+                "id": identifier,
+                "word": list(word),
+                "computed": True,
+                "representative_id": identifier,
+                "coefficient": 1.0,
+            },
+        )
+        helicity_weight = _number(group.get("helicity_weight", 1.0))
+        all_sector_weight = _number(group.get("all_sector_weight", helicity_weight))
+        if word and all_sector_weight > helicity_weight + _HELICITY_WEIGHT_TOLERANCE:
+            reflected = (word[0], *reversed(word[1:]))
+            reflected_id = _color_id(reflected)
+            if reflected_id != identifier:
+                members.append(reflected_id)
+                records.setdefault(
+                    reflected_id,
+                    {
+                        "kind": "lc-flow",
+                        "id": reflected_id,
+                        "word": list(reflected),
+                        "computed": False,
+                        "representative_id": identifier,
+                        "coefficient": 1.0,
+                    },
+                )
+        members_by_group[group_id] = tuple(members)
+    if dag.lc_topology_replay is not None:
+        _add_replayed_lc_color_components(dag, records)
+    components = [records[key] for key in sorted(records)]
+    for index, component in enumerate(components):
+        component["index"] = index
+    return components, members_by_group
+
+
+def _add_replayed_lc_color_components(
+    dag: GenericDAG,
+    records: dict[str, dict[str, object]],
+) -> None:
+    replay = dag.lc_topology_replay
+    if replay is None:
+        return
+    materialized = set(replay.materialized_sector_ids)
+    for sector in dag.color_plan.sectors:
+        word = tuple(sector.word_labels or sector.color_words[0])
+        identifier = _color_id(word)
+        representative = dag.color_plan.sector(replay.representative_for(sector.id))
+        if representative is None:
+            raise ValueError(
+                f"LC replay representative for sector {sector.id} is missing"
+            )
+        representative_word = tuple(
+            representative.word_labels or representative.color_words[0]
+        )
+        representative_id = _color_id(representative_word)
+        records.setdefault(
+            identifier,
+            {
+                "kind": "lc-flow",
+                "id": identifier,
+                "word": list(word),
+                "computed": int(sector.id) in materialized,
+                "representative_id": representative_id,
+                "coefficient": 1.0,
+            },
+        )
+        if not (
+            dag.color_plan.trace_reflections_folded
+            and sector.kind == "single-trace"
+            and len(sector.trace_labels) > 2
+        ):
+            continue
+        reflected = (word[0], *reversed(word[1:]))
+        reflected_id = _color_id(reflected)
+        if reflected_id == identifier:
+            continue
+        records.setdefault(
+            reflected_id,
+            {
+                "kind": "lc-flow",
+                "id": reflected_id,
+                "word": list(reflected),
+                "computed": False,
+                "representative_id": representative_id,
+                "coefficient": 1.0,
+            },
+        )
+
+
+def _reduction_groups(
+    groups: Sequence[Mapping[str, object]],
+    *,
+    group_helicities: Mapping[int, tuple[tuple[int, ...], ...]],
+    group_colors: Mapping[int, tuple[str, ...]],
+    helicity_ids: Mapping[tuple[int, ...], str],
+) -> list[dict[str, object]]:
+    records: list[dict[str, object]] = []
+    for group in groups:
+        group_id = _integer(group["group_id"])
+        helicities = group_helicities[group_id]
+        colors = group_colors[group_id]
+        representative = tuple(
+            _integer(value) for value in _sequence(group["helicities"])
+        )
+        if representative not in helicities:
+            raise ValueError(
+                f"helicity representative is not a member of group {group_id}"
+            )
+        records.append(
+            {
+                "id": f"reduction:{group_id}",
+                "representative_helicity_id": helicity_ids[representative],
+                "representative_color_id": colors[0],
+                "physical_helicity_ids": [
+                    helicity_ids[helicity] for helicity in helicities
+                ],
+                "physical_color_ids": list(colors),
+            }
+        )
+    return records
+
+
+def _public_model_parameters(
+    records: Sequence[Mapping[str, object]],
+) -> list[dict[str, object]]:
+    parameters: dict[str, dict[str, object]] = {}
+    for record in records:
+        raw_kind = str(record.get("kind", ""))
+        if raw_kind == "runtime_control":
+            continue
+        name = str(record.get("runtime_name", record.get("name", "")))
+        if not name:
+            raise ValueError("runtime model parameter has no name")
+        kind = _public_parameter_kind(raw_kind)
+        parameter = parameters.setdefault(
+            name,
+            {
+                "name": name,
+                "kind": kind,
+                "default_real": 0.0,
+                "default_imaginary": 0.0,
+                "mutable": kind != "derived",
+            },
+        )
+        if parameter["kind"] != kind:
+            raise ValueError(f"runtime parameter {name!r} has inconsistent kinds")
+        component = str(record.get("complex_component", "real"))
+        field = "default_imaginary" if component == "imag" else "default_real"
+        parameter[field] = _number(record.get("default", 0.0))
+    return list(parameters.values())
+
+
+def _public_parameter_kind(kind: str) -> str:
+    if kind == "normalization":
+        return "normalization"
+    if kind == "particle_mass":
+        return "mass"
+    if kind == "particle_width":
+        return "width"
+    if kind == "coupling_component":
+        return "coupling"
+    if kind in {"external_parameter", "external_parameter_component"}:
+        return "external"
+    if kind == "derived_parameter_component":
+        return "derived"
+    raise ValueError(f"unsupported public model-parameter kind {kind!r}")
+
+
+def _external_particles(dag: GenericDAG) -> list[dict[str, object]]:
+    return [
+        {
+            "index": index,
+            "label": leg.label,
+            "particle": leg.particle,
+            "pdg": leg.pdg,
+            "role": "initial" if leg.is_initial else "final",
+            "momentum_slot": index,
+            "momentum_components": ["E", "px", "py", "pz"],
+        }
+        for index, leg in enumerate(dag.process.legs)
+    ]
+
+
+def _expected_lc_physical_color_count(dag: GenericDAG) -> int:
+    if dag.process.color_accuracy != "lc":
+        return 0
+    count = 0
+    for sector in dag.color_plan.sectors:
+        count += 1
+        if (
+            dag.color_plan.trace_reflections_folded
+            and sector.kind == "single-trace"
+            and len(sector.trace_labels) > 2
+        ):
+            reflected = (sector.trace_labels[0], *reversed(sector.trace_labels[1:]))
+            if reflected != sector.trace_labels:
+                count += 1
+    return count
+
+
+def _helicity_id(values: Sequence[int]) -> str:
+    return "h:" + ",".join(f"{int(value):+d}" for value in values)
+
+
+def _color_id(word: Sequence[int]) -> str:
+    if word:
+        return "flow:" + ",".join(str(int(label)) for label in word)
+    return "flow:singlet"
+
+
+def _complex_pair(value: object, name: str) -> tuple[float, float]:
+    if isinstance(value, complex):
+        return float(value.real), float(value.imag)
+    if isinstance(value, Sequence) and not isinstance(value, str | bytes):
+        if len(value) != 2:
+            raise ValueError(
+                f"runtime model parameter {name!r} must have two components"
+            )
+        return float(value[0]), float(value[1])
+    if not isinstance(value, str | int | float):
+        raise ValueError(f"runtime model parameter {name!r} is not numeric")
+    return float(value), 0.0
+
+
+def _mapping(value: object) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise TypeError("runtime physics record must be a mapping")
+    return {str(key): item for key, item in value.items()}
+
+
+def _mapping_sequence(value: object) -> tuple[Mapping[str, object], ...]:
+    return tuple(_mapping(item) for item in _sequence(value))
+
+
+def _sequence(value: object) -> Sequence[object]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise TypeError("runtime physics field must be a sequence")
+    return value
+
+
+def _integer(value: object) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError("runtime physics integer field is invalid")
+    return value
+
+
+def _number(value: object) -> float:
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        raise TypeError("runtime physics numeric field is invalid")
+    result = float(value)
+    if not math.isfinite(result):
+        raise ValueError("runtime physics numeric field must be finite")
+    return result
+
+
+__all__ = [
+    "EAGER_PLAN_V3_REDUCTION_ENTRIES_MEMBER",
+    "EAGER_PLAN_V3_REDUCTION_GROUPS_CONTAINER_PATH",
+    "EAGER_PLAN_V3_REDUCTION_GROUPS_KIND",
+    "EAGER_PLAN_V3_REDUCTION_GROUPS_MEMBER",
+    "EAGER_PLAN_V3_REDUCTION_GROUPS_RUNTIME_LAYOUT_ABI",
+    "EAGER_PLAN_V3_REDUCTION_GROUPS_SCHEMA_VERSION",
+    "EAGER_PLAN_V3_REDUCTION_GROUPS_STORAGE_ABI",
+    "NATIVE_REDUCTION_GROUPS_EXTENSION_KEY",
+    "build_resolved_physics_from_dag",
+    "build_resolved_physics_payload",
+    "build_runtime_model_parameter_records",
+    "build_runtime_normalization",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/process_grouping.py b/pyamplicol/src/pyamplicol/generation/process_grouping.py
new file mode 100644
index 0000000000..3069806a50
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/process_grouping.py
@@ -0,0 +1,800 @@
+# SPDX-License-Identifier: 0BSD
+"""Flavour-profile canonicalization and process-group maps.
+
+Two processes are candidates for one matrix element when their external legs
+have the same particle types. A particle type is the spin, the SU(3) dimension,
+the resolved mass and width and self-conjugacy; particles and antiparticles
+share a type. The leg mapping between two candidates is derived from flavour
+profiles: each flavour of a process is described by how many times it appears
+as a particle and as an antiparticle in the initial and in the final state.
+Sorting legs by profile, and only then by PDG, gives positions that follow any
+flavour relabelling, which sorting by PDG alone does not.
+
+A group map records, for each representative, the members whose matrix
+element equals ``factor`` times the representative's at permuted momenta:
+``ME_member(p) = factor * ME_representative(q)`` with
+``q[r] = p[permutation[r]]``, so ``permutation`` maps representative legs to
+member legs. ``conjugated`` members are related by charge conjugation, so LC
+colour-flow words map with reversed order.
+"""
+
+from __future__ import annotations
+
+import itertools
+import json
+from collections.abc import Iterable, Iterator, Mapping, Sequence
+from dataclasses import dataclass, field, replace
+from enum import StrEnum
+from fractions import Fraction
+from typing import Any
+
+PROCESS_GROUPS_PATH = "process-groups.json"
+PROCESS_GROUPS_ROLE = "process-groups"
+PROCESS_GROUPS_KIND = "pyamplicol-process-groups"
+PROCESS_GROUPS_SCHEMA_VERSION = 1
+MAX_RATIONAL = 99
+"""Largest numerator and denominator of a recorded group factor."""
+
+_ZERO_EXPRESSIONS = frozenset({"0", "0.0", "-0", "-0.0", "zero"})
+
+
+class GroupingBasis(StrEnum):
+    IDENTITY = "identity"
+    FLAVOR_BLIND = "flavor-blind"
+    NUMERICAL = "numerical"
+
+
+# The least verified link decides the basis of a composed relation.
+_BASIS_STRENGTH = {
+    GroupingBasis.IDENTITY: 0,
+    GroupingBasis.NUMERICAL: 1,
+    GroupingBasis.FLAVOR_BLIND: 2,
+}
+
+
+class GroupingAnalysis(StrEnum):
+    NONE = "none"
+    NUMERICAL = "numerical"
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class ParticleType:
+    """Everything a flavour relabelling must preserve about one particle."""
+
+    spin: int
+    color: int
+    mass: str
+    width: str
+    self_conjugate: bool
+
+
+@dataclass(frozen=True, slots=True)
+class GroupingParticle:
+    pdg: int
+    name: str
+    type: ParticleType
+
+
+ParticleTable = Mapping[int, GroupingParticle]
+
+
+@dataclass(frozen=True, slots=True)
+class GroupingProcess:
+    process_id: str
+    expression: str
+    pdgs: tuple[int, ...]
+    initial_count: int
+    generated: bool = True
+
+    def __post_init__(self) -> None:
+        if not 0 < self.initial_count < len(self.pdgs):
+            raise ValueError(
+                f"process {self.process_id!r} needs initial and final legs"
+            )
+
+
+def resolved_parameter_name(
+    name: str,
+    parameters: Mapping[str, object],
+) -> str:
+    """Return ``ZERO`` for compile-time zero parameters, otherwise ``name``."""
+
+    if not name or name.strip().casefold() == "zero":
+        return "ZERO"
+    record = parameters.get(name)
+    resolved = getattr(record, "resolved_expression", None)
+    if isinstance(resolved, str) and resolved.strip().casefold() in _ZERO_EXPRESSIONS:
+        return "ZERO"
+    return name
+
+
+def particle_table(
+    particles: Iterable[object],
+    parameters: Mapping[str, object],
+) -> dict[int, GroupingParticle]:
+    """Build the grouping view of compiled particle records.
+
+    ``particles`` are ``CompiledParticleRecord``-like objects and
+    ``parameters`` maps parameter names to records with a
+    ``resolved_expression``, as in ``CompiledModelIR``.
+    """
+
+    table: dict[int, GroupingParticle] = {}
+    for particle in particles:
+        pdg = int(particle.pdg_code)  # type: ignore[attr-defined]
+        name = str(particle.name)  # type: ignore[attr-defined]
+        antiname = str(particle.antiname)  # type: ignore[attr-defined]
+        declared = getattr(particle, "self_conjugate", None)
+        self_conjugate = bool(declared) if declared is not None else name == antiname
+        table[pdg] = GroupingParticle(
+            pdg=pdg,
+            name=name,
+            type=ParticleType(
+                spin=int(particle.spin),  # type: ignore[attr-defined]
+                color=abs(int(particle.color)),  # type: ignore[attr-defined]
+                mass=resolved_parameter_name(
+                    str(particle.mass),  # type: ignore[attr-defined]
+                    parameters,
+                ),
+                width=resolved_parameter_name(
+                    str(particle.width),  # type: ignore[attr-defined]
+                    parameters,
+                ),
+                self_conjugate=self_conjugate,
+            ),
+        )
+    return table
+
+
+@dataclass(frozen=True, slots=True)
+class _Leg:
+    index: int
+    initial: bool
+    pdg: int
+    flavour: int
+    orientation: int
+    type: ParticleType
+
+
+def _particle(table: ParticleTable, pdg: int) -> GroupingParticle:
+    try:
+        return table[pdg]
+    except KeyError as error:
+        raise ValueError(f"PDG code {pdg} is absent from the model") from error
+
+
+def _legs(
+    process: GroupingProcess,
+    table: ParticleTable,
+    *,
+    conjugate: bool = False,
+) -> tuple[_Leg, ...]:
+    legs = []
+    for index, pdg in enumerate(process.pdgs):
+        particle = _particle(table, pdg)
+        if particle.type.self_conjugate:
+            flavour, orientation = abs(pdg), 0
+        else:
+            flavour, orientation = abs(pdg), (1 if pdg > 0 else -1)
+            if conjugate:
+                orientation = -orientation
+        legs.append(
+            _Leg(
+                index=index,
+                initial=index < process.initial_count,
+                pdg=pdg if not conjugate or orientation == 0 else -pdg,
+                flavour=flavour,
+                orientation=orientation,
+                type=particle.type,
+            )
+        )
+    return tuple(legs)
+
+
+Profile = tuple[int, int, int, int]
+
+
+def _profiles(legs: Sequence[_Leg]) -> dict[int, Profile]:
+    counts: dict[int, list[int]] = {}
+    for leg in legs:
+        slot = (0 if leg.initial else 2) + (1 if leg.orientation < 0 else 0)
+        counts.setdefault(leg.flavour, [0, 0, 0, 0])[slot] += 1
+    return {flavour: tuple(values) for flavour, values in counts.items()}  # type: ignore[misc]
+
+
+def coarse_key(process: GroupingProcess, table: ParticleTable) -> tuple[Any, ...]:
+    """Particle types of each side, with particles and antiparticles merged."""
+
+    legs = _legs(process, table)
+    return (
+        process.initial_count,
+        tuple(sorted(leg.type for leg in legs if leg.initial)),
+        tuple(sorted(leg.type for leg in legs if not leg.initial)),
+    )
+
+
+def profile_key(
+    process: GroupingProcess,
+    table: ParticleTable,
+    *,
+    conjugate: bool = False,
+) -> tuple[Any, ...]:
+    """Equal for exactly the processes related by a type-preserving relabelling."""
+
+    legs = _legs(process, table, conjugate=conjugate)
+    types = {leg.flavour: leg.type for leg in legs}
+    profiles = _profiles(legs)
+    return (
+        process.initial_count,
+        len(legs),
+        tuple(
+            sorted((types[flavour], profile) for flavour, profile in profiles.items())
+        ),
+    )
+
+
+def flavor_class_key(
+    process: GroupingProcess,
+    table: ParticleTable,
+    *,
+    consider_charge_conjugation: bool,
+) -> tuple[Any, ...]:
+    """Class of processes assumed equal by ``--flavor-blind``."""
+
+    key = profile_key(process, table)
+    if consider_charge_conjugation:
+        key = min(key, profile_key(process, table, conjugate=True))
+    return key
+
+
+def _ordered_legs(
+    legs: Sequence[_Leg],
+    ranks: Mapping[int, int],
+    profiles: Mapping[int, Profile],
+) -> tuple[_Leg, ...]:
+    return tuple(
+        sorted(
+            legs,
+            key=lambda leg: (
+                not leg.initial,
+                leg.type,
+                profiles[leg.flavour],
+                ranks[leg.flavour],
+                -leg.orientation,
+                leg.index,
+            ),
+        )
+    )
+
+
+def _flavour_groups(legs: Sequence[_Leg]) -> dict[tuple[Any, ...], list[int]]:
+    """Flavours with equal (type, profile), in a fixed order."""
+
+    types = {leg.flavour: leg.type for leg in legs}
+    profiles = _profiles(legs)
+    groups: dict[tuple[Any, ...], list[int]] = {}
+    for flavour in sorted(profiles):
+        groups.setdefault((types[flavour], profiles[flavour]), []).append(flavour)
+    return groups
+
+
+def _profile_order(
+    legs: Sequence[_Leg],
+    assignment: Mapping[tuple[Any, ...], Sequence[int]],
+) -> tuple[_Leg, ...]:
+    ranks = {
+        flavour: rank
+        for flavours in assignment.values()
+        for rank, flavour in enumerate(flavours)
+    }
+    return _ordered_legs(legs, ranks, _profiles(legs))
+
+
+@dataclass(frozen=True, slots=True)
+class LegMapping:
+    """One candidate relation ``member -> representative``."""
+
+    permutation: tuple[int, ...]
+    conjugated: bool
+    method: str
+
+
+def _mapping(
+    member: Sequence[_Leg],
+    representative: Sequence[_Leg],
+    *,
+    conjugated: bool,
+    method: str,
+) -> LegMapping:
+    permutation = [0] * len(representative)
+    for member_leg, representative_leg in zip(member, representative, strict=True):
+        if (
+            member_leg.initial != representative_leg.initial
+            or member_leg.type != representative_leg.type
+            or member_leg.orientation != representative_leg.orientation
+        ):
+            raise ValueError("leg orders do not describe the same process shape")
+        permutation[representative_leg.index] = member_leg.index
+    return LegMapping(tuple(permutation), conjugated, method)
+
+
+def profile_mappings(
+    member: GroupingProcess,
+    representative: GroupingProcess,
+    table: ParticleTable,
+    *,
+    conjugated: bool = False,
+    limit: int = 24,
+) -> tuple[LegMapping, ...]:
+    """Leg mappings induced by flavour relabellings, at most ``limit``.
+
+    Flavours with the same type and profile can be paired in any order; each
+    pairing is one mapping, the first one pairs them by increasing ``|PDG|``.
+    """
+
+    member_legs = _legs(member, table, conjugate=conjugated)
+    representative_legs = _legs(representative, table)
+    if profile_key(member, table, conjugate=conjugated) != profile_key(
+        representative, table
+    ):
+        return ()
+    representative_order = _profile_order(
+        representative_legs, _flavour_groups(representative_legs)
+    )
+    member_groups = _flavour_groups(member_legs)
+    keys = list(member_groups)
+    choices = [itertools.permutations(member_groups[key]) for key in keys]
+    mappings: list[LegMapping] = []
+    for combination in itertools.product(*choices):
+        member_order = _profile_order(
+            member_legs, dict(zip(keys, combination, strict=True))
+        )
+        mapping = _mapping(
+            member_order,
+            representative_order,
+            conjugated=conjugated,
+            method="flavor-profile",
+        )
+        if mapping not in mappings:
+            mappings.append(mapping)
+        if len(mappings) >= limit:
+            break
+    return tuple(mappings)
+
+
+def signed_pdg_mapping(
+    member: GroupingProcess,
+    representative: GroupingProcess,
+    table: ParticleTable,
+) -> LegMapping | None:
+    """Pair legs by sorting each side by type and signed PDG."""
+
+    if coarse_key(member, table) != coarse_key(representative, table):
+        return None
+
+    def order(process: GroupingProcess) -> tuple[_Leg, ...]:
+        return tuple(
+            sorted(
+                _legs(process, table),
+                key=lambda leg: (not leg.initial, leg.type, leg.pdg, leg.index),
+            )
+        )
+
+    permutation = [0] * len(representative.pdgs)
+    for member_leg, representative_leg in zip(
+        order(member), order(representative), strict=True
+    ):
+        permutation[representative_leg.index] = member_leg.index
+    return LegMapping(tuple(permutation), False, "signed-pdg")
+
+
+def candidate_mappings(
+    member: GroupingProcess,
+    representative: GroupingProcess,
+    table: ParticleTable,
+    *,
+    consider_charge_conjugation: bool,
+    limit: int = 24,
+) -> tuple[LegMapping, ...]:
+    """All leg mappings worth testing numerically, most natural first."""
+
+    mappings = list(profile_mappings(member, representative, table, limit=limit))
+    if consider_charge_conjugation:
+        mappings.extend(
+            profile_mappings(
+                member, representative, table, conjugated=True, limit=limit
+            )
+        )
+    fallback = signed_pdg_mapping(member, representative, table)
+    if fallback is not None and all(
+        (fallback.permutation, False) != (mapping.permutation, mapping.conjugated)
+        for mapping in mappings
+    ):
+        mappings.append(fallback)
+    return tuple(mappings)
+
+
+def flavor_blind_mapping(
+    member: GroupingProcess,
+    representative: GroupingProcess,
+    table: ParticleTable,
+    *,
+    consider_charge_conjugation: bool,
+) -> LegMapping:
+    """The mapping assumed by ``--flavor-blind`` within one flavour class."""
+
+    mappings = profile_mappings(member, representative, table, limit=1)
+    if not mappings and consider_charge_conjugation:
+        mappings = profile_mappings(
+            member, representative, table, conjugated=True, limit=1
+        )
+    if not mappings:
+        raise ValueError(
+            f"{member.expression!r} and {representative.expression!r} are not "
+            "related by a flavour relabelling"
+        )
+    return replace(mappings[0], method="flavor-blind")
+
+
+def representative_key(
+    process: GroupingProcess,
+    table: ParticleTable,
+) -> tuple[Any, ...]:
+    """Canonical order of processes: type signature, then PDGs.
+
+    Smaller ``|PDG|`` comes first and particles precede antiparticles, so
+    ``d d~ > g g`` represents ``u u~ > g g`` and ``u g > u g`` represents
+    ``u~ g > u~ g``.
+    """
+
+    legs = sorted(
+        _legs(process, table),
+        key=lambda leg: (
+            not leg.initial,
+            leg.type,
+            abs(leg.pdg),
+            leg.pdg < 0,
+            leg.index,
+        ),
+    )
+    return (
+        coarse_key(process, table),
+        tuple((leg.initial, abs(leg.pdg), leg.pdg < 0) for leg in legs),
+        process.process_id,
+    )
+
+
+def flavor_blind_classes(
+    processes: Sequence[GroupingProcess],
+    table: ParticleTable,
+    *,
+    consider_charge_conjugation: bool,
+) -> list[list[GroupingProcess]]:
+    """Partition ``processes`` into flavour classes, representative first."""
+
+    classes: dict[tuple[Any, ...], list[GroupingProcess]] = {}
+    for process in processes:
+        key = flavor_class_key(
+            process,
+            table,
+            consider_charge_conjugation=consider_charge_conjugation,
+        )
+        classes.setdefault(key, []).append(process)
+    result = []
+    for members in classes.values():
+        members.sort(key=lambda process: representative_key(process, table))
+        result.append(members)
+    return result
+
+
+# --------------------------------------------------------------------------
+# Relations and group maps
+
+
+def identity_permutation(count: int) -> tuple[int, ...]:
+    return tuple(range(count))
+
+
+def compose_permutations(
+    member_to_middle: Sequence[int],
+    middle_to_representative: Sequence[int],
+) -> tuple[int, ...]:
+    """Compose ``member -> middle`` with ``middle -> representative``."""
+
+    return tuple(member_to_middle[index] for index in middle_to_representative)
+
+
+def invert_permutation(permutation: Sequence[int]) -> tuple[int, ...]:
+    inverse = [0] * len(permutation)
+    for representative_index, member_index in enumerate(permutation):
+        inverse[member_index] = representative_index
+    return tuple(inverse)
+
+
+@dataclass(frozen=True, slots=True)
+class GroupMember:
+    process_id: str
+    expression: str
+    pdgs: tuple[int, ...]
+    initial_count: int
+    factor: Fraction = Fraction(1)
+    permutation: tuple[int, ...] = ()
+    conjugated: bool = False
+    basis: GroupingBasis = GroupingBasis.IDENTITY
+    generated: bool = True
+    warning: str | None = None
+
+    @classmethod
+    def identity(cls, process: GroupingProcess) -> GroupMember:
+        return cls(
+            process_id=process.process_id,
+            expression=process.expression,
+            pdgs=process.pdgs,
+            initial_count=process.initial_count,
+            permutation=identity_permutation(len(process.pdgs)),
+            generated=process.generated,
+        )
+
+    @property
+    def process(self) -> GroupingProcess:
+        return GroupingProcess(
+            process_id=self.process_id,
+            expression=self.expression,
+            pdgs=self.pdgs,
+            initial_count=self.initial_count,
+            generated=self.generated,
+        )
+
+    def related(
+        self,
+        mapping: LegMapping,
+        *,
+        factor: Fraction,
+        basis: GroupingBasis,
+        warning: str | None = None,
+    ) -> GroupMember:
+        return replace(
+            self,
+            factor=Fraction(factor),
+            permutation=tuple(mapping.permutation),
+            conjugated=mapping.conjugated,
+            basis=basis,
+            warning=warning,
+        )
+
+    def through(self, middle: GroupMember) -> GroupMember:
+        """Re-express ``self -> A`` through ``A -> B`` as ``self -> B``.
+
+        ``middle`` is the relation of the old representative ``A`` to the new
+        representative ``B``.
+        """
+
+        return replace(
+            self,
+            factor=self.factor * middle.factor,
+            permutation=compose_permutations(self.permutation, middle.permutation),
+            conjugated=self.conjugated != middle.conjugated,
+            basis=max(self.basis, middle.basis, key=_BASIS_STRENGTH.__getitem__),
+            warning=self.warning or middle.warning,
+        )
+
+    def inverted_to(self, representative: GroupMember) -> GroupMember:
+        """Relation of ``representative`` to ``self``, the inverse of ``self``."""
+
+        return replace(
+            representative,
+            factor=1 / self.factor,
+            permutation=invert_permutation(self.permutation),
+            conjugated=self.conjugated,
+            basis=self.basis,
+            warning=self.warning,
+        )
+
+    def as_dict(self) -> dict[str, object]:
+        record: dict[str, object] = {
+            "process_id": self.process_id,
+            "process": self.expression,
+            "pdgs": list(self.pdgs),
+            "initial_count": self.initial_count,
+            "factor": {
+                "numerator": self.factor.numerator,
+                "denominator": self.factor.denominator,
+            },
+            "permutation": list(self.permutation),
+            "conjugated": self.conjugated,
+            "basis": str(self.basis),
+            "generated": self.generated,
+        }
+        if self.warning:
+            record["warning"] = self.warning
+        return record
+
+    @classmethod
+    def from_dict(cls, value: Mapping[str, object]) -> GroupMember:
+        factor = value["factor"]
+        if not isinstance(factor, Mapping):
+            raise ValueError("process-group factor must be an object")
+        return cls(
+            process_id=str(value["process_id"]),
+            expression=str(value["process"]),
+            pdgs=tuple(int(pdg) for pdg in value["pdgs"]),  # type: ignore[attr-defined]
+            initial_count=int(value["initial_count"]),  # type: ignore[call-overload]
+            factor=Fraction(
+                int(factor["numerator"]),
+                int(factor["denominator"]),
+            ),
+            permutation=tuple(int(i) for i in value["permutation"]),  # type: ignore[attr-defined]
+            conjugated=bool(value["conjugated"]),
+            basis=GroupingBasis(str(value["basis"])),
+            generated=bool(value["generated"]),
+            warning=(str(value["warning"]) if value.get("warning") else None),
+        )
+
+
+@dataclass(slots=True)
+class ProcessGroup:
+    """A representative and every member, the representative first."""
+
+    members: list[GroupMember]
+
+    @property
+    def representative(self) -> GroupMember:
+        return self.members[0]
+
+    def as_dict(self) -> dict[str, object]:
+        representative = self.representative
+        return {
+            "representative": {
+                "process_id": representative.process_id,
+                "process": representative.expression,
+            },
+            "members": [member.as_dict() for member in self.members],
+        }
+
+
+@dataclass(slots=True)
+class ProcessGroupMap:
+    """Process groups keyed by representative process ID."""
+
+    groups: dict[str, ProcessGroup] = field(default_factory=dict)
+    analyses: list[dict[str, object]] = field(default_factory=list)
+
+    @classmethod
+    def trivial(cls, processes: Iterable[GroupingProcess]) -> ProcessGroupMap:
+        result = cls()
+        for process in processes:
+            result.add_group([GroupMember.identity(process)])
+        return result
+
+    def add_group(self, members: Sequence[GroupMember]) -> None:
+        representative = members[0]
+        if not representative.generated:
+            raise ValueError(
+                f"representative {representative.process_id!r} was not generated"
+            )
+        for member in members:
+            if self.group_of(member.process_id) is not None:
+                raise ValueError(
+                    f"process {member.process_id!r} already belongs to a group"
+                )
+        self.groups[representative.process_id] = ProcessGroup(list(members))
+
+    def group_of(self, process_id: str) -> ProcessGroup | None:
+        for group in self.groups.values():
+            if any(member.process_id == process_id for member in group.members):
+                return group
+        return None
+
+    @property
+    def representatives(self) -> tuple[GroupMember, ...]:
+        return tuple(group.representative for group in self.groups.values())
+
+    def members(self) -> Iterator[GroupMember]:
+        for group in self.groups.values():
+            yield from group.members
+
+    def merge(
+        self,
+        member_representative: str,
+        relation: GroupMember,
+        table: ParticleTable,
+    ) -> str:
+        """Join two groups given ``relation``, the relation of one
+        representative (``relation.process_id``) to another
+        (``member_representative`` is the target). Returns the representative
+        of the merged group, the canonically smallest generated one."""
+
+        if relation.process_id == member_representative:
+            raise ValueError("cannot merge a group with itself")
+        source = self.groups.pop(relation.process_id)
+        target = self.groups.pop(member_representative)
+        source_key = representative_key(source.representative.process, table)
+        target_key = representative_key(target.representative.process, table)
+        if target_key <= source_key:
+            keep, moved, link = target, source, relation
+        else:
+            keep, moved = source, target
+            link = relation.inverted_to(target.representative)
+        merged = list(keep.members)
+        merged.extend(member.through(link) for member in moved.members)
+        self.groups[keep.representative.process_id] = ProcessGroup(merged)
+        return keep.representative.process_id
+
+    def as_document(self) -> dict[str, object]:
+        groups = sorted(
+            self.groups.values(), key=lambda group: group.representative.process_id
+        )
+        return {
+            "kind": PROCESS_GROUPS_KIND,
+            "schema_version": PROCESS_GROUPS_SCHEMA_VERSION,
+            "analyses": list(self.analyses),
+            "groups": [group.as_dict() for group in groups],
+        }
+
+    def to_json(self) -> str:
+        return json.dumps(self.as_document(), indent=2, sort_keys=False) + "\n"
+
+    @classmethod
+    def from_document(cls, document: Mapping[str, object]) -> ProcessGroupMap:
+        if document.get("kind") != PROCESS_GROUPS_KIND:
+            raise ValueError("document is not a pyAmpliCol process-group map")
+        if document.get("schema_version") != PROCESS_GROUPS_SCHEMA_VERSION:
+            raise ValueError("unsupported process-group map schema version")
+        result = cls(analyses=[dict(entry) for entry in document.get("analyses", [])])  # type: ignore[attr-defined]
+        for group in document.get("groups", []):  # type: ignore[attr-defined]
+            members = [GroupMember.from_dict(member) for member in group["members"]]
+            result.add_group(members)
+        return result
+
+    @classmethod
+    def from_json(cls, text: str) -> ProcessGroupMap:
+        return cls.from_document(json.loads(text))
+
+
+def rational_factor(value: float, *, tolerance: float) -> Fraction | None:
+    """Return ``value`` as a fraction with |numerator|, denominator <= 99."""
+
+    if value == 0 or value != value:
+        return None
+    fraction = Fraction(value).limit_denominator(MAX_RATIONAL)
+    if (
+        fraction == 0
+        or abs(fraction.numerator) > MAX_RATIONAL
+        or abs(float(fraction) - value) > tolerance * abs(value)
+    ):
+        return None
+    return fraction
+
+
+__all__ = [
+    "MAX_RATIONAL",
+    "PROCESS_GROUPS_KIND",
+    "PROCESS_GROUPS_PATH",
+    "PROCESS_GROUPS_ROLE",
+    "PROCESS_GROUPS_SCHEMA_VERSION",
+    "GroupMember",
+    "GroupingAnalysis",
+    "GroupingBasis",
+    "GroupingParticle",
+    "GroupingProcess",
+    "LegMapping",
+    "ParticleTable",
+    "ParticleType",
+    "ProcessGroup",
+    "ProcessGroupMap",
+    "candidate_mappings",
+    "coarse_key",
+    "compose_permutations",
+    "flavor_blind_classes",
+    "flavor_blind_mapping",
+    "flavor_class_key",
+    "identity_permutation",
+    "invert_permutation",
+    "particle_table",
+    "profile_key",
+    "profile_mappings",
+    "rational_factor",
+    "representative_key",
+    "resolved_parameter_name",
+    "signed_pdg_mapping",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/process_grouping_numerical.py b/pyamplicol/src/pyamplicol/generation/process_grouping_numerical.py
new file mode 100644
index 0000000000..bce9fc726b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/process_grouping_numerical.py
@@ -0,0 +1,784 @@
+# SPDX-License-Identifier: 0BSD
+"""Numerical discovery of process groups in a generated artifact.
+
+Every stored representative is evaluated in f64 at three on-shell points. Each
+point has its own deterministic variation of the free model inputs (external
+and normalization parameters other than masses and widths, within
+``PARAMETER_VARIATION``); a member and a representative are always compared
+with the same values. A relation is
+accepted when, through one leg mapping of
+:func:`~pyamplicol.generation.process_grouping.candidate_mappings`, every
+resolved helicity and colour component of the member is one common rational
+factor times the matching component of the representative, at every point.
+
+Helicity values map unchanged, also under charge conjugation. LC colour-flow
+words are relabelled and, for conjugated mappings, reversed; they are compared
+as sets of open fundamental chains or as one cyclic adjoint trace.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import math
+from collections.abc import Collection, Hashable, Mapping, Sequence
+from dataclasses import dataclass
+from fractions import Fraction
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any, cast
+
+from ..api.errors import ArtifactError, PyAmpliColError
+from ..api.results import ResolvedEvaluation
+from ..artifacts.manifest import load_manifest
+from ..artifacts.process_groups import (
+    initial_process_groups,
+    read_process_groups,
+    write_process_groups,
+)
+from ..artifacts.security import confined_path
+from .phase_space import massive_rambo_final_state
+from .process_grouping import (
+    GroupingAnalysis,
+    GroupingBasis,
+    GroupingProcess,
+    GroupMember,
+    LegMapping,
+    ParticleTable,
+    ProcessGroupMap,
+    candidate_mappings,
+    coarse_key,
+    identity_permutation,
+    invert_permutation,
+    particle_table,
+    rational_factor,
+    representative_key,
+    resolved_parameter_name,
+)
+
+POINTS = 3
+PARAMETER_VARIATION = 0.1
+TOLERANCE = 1.0e-9
+DEFAULT_SEED = 20260917
+_VARIED_KINDS = frozenset({"external", "normalization"})
+# Components below _ZERO times the largest one at a point count as zero. The
+# others must agree to TOLERANCE relative to themselves, but never more tightly
+# than TOLERANCE times _FLOOR times the largest component.
+_ZERO = 1.0e-12
+_FLOOR = 1.0e-4
+_MINIMUM_SQRT_S = 1000.0
+_LOGGER = logging.getLogger("pyamplicol.generation")
+
+FourMomentum = tuple[float, float, float, float]
+Point = tuple[FourMomentum, ...]
+ComponentKey = tuple[tuple[int, ...], Hashable]
+Components = dict[ComponentKey, complex]
+
+
+class _Unanalysable(Exception):
+    """A representative that cannot take part in the comparison."""
+
+
+# --------------------------------------------------------------------------
+# Pure helpers
+
+
+def parameter_variation(
+    parameters: Sequence[Any],
+    *,
+    point: int,
+    seed: int = DEFAULT_SEED,
+    fixed: Collection[str] = frozenset(),
+) -> dict[str, float | complex]:
+    """Varied values of the free inputs among ``parameters`` at ``point``.
+
+    ``parameters`` are ``ModelParameter``-like records; ``fixed`` names the
+    mass and width parameters, which UFO models declare as external inputs.
+    The factor of each parameter depends only on its name, the point and the
+    seed, so every process sees the same values for the parameters it shares.
+    """
+
+    values: dict[str, float | complex] = {}
+    for parameter in parameters:
+        if (
+            parameter.kind not in _VARIED_KINDS
+            or not parameter.mutable
+            or parameter.name in fixed
+        ):
+            continue
+        digest = hashlib.sha256(f"{seed}:{point}:{parameter.name}".encode()).digest()
+        uniform = int.from_bytes(digest[:8], "big") / float(1 << 64)
+        factor = 1.0 + PARAMETER_VARIATION * (2.0 * uniform - 1.0)
+        if parameter.default_imaginary:
+            values[parameter.name] = factor * complex(
+                parameter.default_real, parameter.default_imaginary
+            )
+        else:
+            values[parameter.name] = factor * parameter.default_real
+    return values
+
+
+def on_shell_point(
+    initial_masses: Sequence[float],
+    final_masses: Sequence[float],
+    *,
+    seed: int,
+) -> Point | None:
+    """A deterministic on-shell point in the centre-of-mass frame.
+
+    Beams may be massive; a single initial particle decays at rest. Returns
+    ``None`` when the masses leave no phase space.
+    """
+
+    final_masses = tuple(final_masses)
+    if len(initial_masses) == 1:
+        (mass,) = initial_masses
+        if len(final_masses) < 2 or mass <= sum(final_masses):
+            return None
+        return ((mass, 0.0, 0.0, 0.0), *_final_state(final_masses, mass, seed))
+    first, second = initial_masses
+    if len(final_masses) == 1:
+        sqrt_s = final_masses[0]
+        if sqrt_s <= first + second:
+            return None
+        final: tuple[FourMomentum, ...] = ((sqrt_s, 0.0, 0.0, 0.0),)
+    else:
+        threshold = max(first + second, sum(final_masses))
+        sqrt_s = max(_MINIMUM_SQRT_S, 2.0 * threshold)
+        final = _final_state(final_masses, sqrt_s, seed)
+    s = sqrt_s * sqrt_s
+    first_energy = (s + first * first - second * second) / (2.0 * sqrt_s)
+    momentum = math.sqrt(max(0.0, first_energy * first_energy - first * first))
+    return (
+        (first_energy, 0.0, 0.0, momentum),
+        (sqrt_s - first_energy, 0.0, 0.0, -momentum),
+        *final,
+    )
+
+
+def _final_state(
+    masses: Sequence[float],
+    sqrt_s: float,
+    seed: int,
+) -> tuple[FourMomentum, ...]:
+    return massive_rambo_final_state(
+        len(masses), sqrt_s=sqrt_s, masses=masses, seed=seed
+    )
+
+
+def _point_seed(seed: int, point: int) -> int:
+    digest = hashlib.sha256(f"{seed}:{point}:phase-space".encode()).digest()
+    return int.from_bytes(digest[:8], "big")
+
+
+def member_point(representative: Point, permutation: Sequence[int]) -> Point:
+    """Momenta of the member such that ``q[r] = p[permutation[r]]``."""
+
+    member: list[FourMomentum] = [representative[0]] * len(representative)
+    for representative_index, member_index in enumerate(permutation):
+        member[member_index] = representative[representative_index]
+    return tuple(member)
+
+
+def color_roles(
+    pdgs: Sequence[int],
+    initial_count: int,
+    colors: Mapping[int, int],
+) -> tuple[int, ...]:
+    """Colour representation of each leg with all legs outgoing."""
+
+    roles = []
+    for index, pdg in enumerate(pdgs):
+        color = colors.get(pdg)
+        if color is None:
+            color = -colors[-pdg] if abs(colors[-pdg]) == 3 else colors[-pdg]
+        if index < initial_count and abs(color) == 3:
+            color = -color
+        roles.append(color)
+    return tuple(roles)
+
+
+def flow_key(
+    word: Sequence[int],
+    roles: Sequence[int],
+    relabel: Sequence[int],
+    *,
+    reverse: bool,
+) -> Hashable:
+    """Canonical colour tensor of an LC flow word in target leg indices.
+
+    ``word`` holds zero-based source leg indices, ``roles`` their all-outgoing
+    representations and ``relabel`` maps source to target indices. Open lines
+    run from a fundamental through adjoints to an antifundamental and are
+    compared as a set; a pure-adjoint word is one trace, compared up to
+    rotation. ``reverse`` reverses every line and trace (charge conjugation).
+    A word that is neither is kept verbatim.
+    """
+
+    chains: list[tuple[int, ...]] = []
+    trace: list[int] = []
+    current: list[int] | None = None
+    decodable = True
+    for index in word:
+        role = roles[index]
+        if role == 3 and current is None:
+            current = [index]
+        elif role == -3 and current is not None:
+            current.append(index)
+            chains.append(tuple(current))
+            current = None
+        elif role == 8:
+            (trace if current is None else current).append(index)
+        elif role != 1:
+            decodable = False
+
+    def mapped(line: Sequence[int]) -> tuple[int, ...]:
+        result = tuple(relabel[index] for index in line)
+        return result[::-1] if reverse else result
+
+    if not decodable or current is not None or (chains and trace):
+        return ("word", mapped(word))
+    if chains:
+        return ("lines", tuple(sorted(mapped(chain) for chain in chains)))
+    cycle = mapped(trace)
+    if not cycle:
+        return ("singlet",)
+    start = cycle.index(min(cycle))
+    return ("trace", cycle[start:] + cycle[:start])
+
+
+def resolved_components(
+    resolved: ResolvedEvaluation,
+    point: int,
+    *,
+    helicities: Mapping[str, Sequence[int]],
+    words: Mapping[str, Sequence[int]],
+    roles: Sequence[int],
+    mapping: LegMapping | None,
+) -> Components:
+    """One point of a member's resolved values keyed in representative legs.
+
+    ``helicities`` and ``words`` give the member's helicity values and LC
+    flow words (zero-based leg indices) by ID; ``mapping`` is the candidate
+    relation to the representative, ``None`` for the identity.
+    """
+
+    count = len(roles)
+    permutation = (
+        identity_permutation(count) if mapping is None else mapping.permutation
+    )
+    relabel = invert_permutation(permutation)
+    conjugated = mapping is not None and mapping.conjugated
+    helicity_keys = [
+        tuple(helicities[identifier][index] for index in permutation)
+        for identifier in resolved.helicity_ids
+    ]
+    color_keys = [
+        flow_key(words[identifier], roles, relabel, reverse=conjugated)
+        if resolved.color_accuracy == "lc"
+        else identifier
+        for identifier in resolved.color_ids
+    ]
+    return {
+        (helicity, color): complex(cast(complex, value))
+        for helicity, row in zip(helicity_keys, resolved.values[point], strict=True)
+        for color, value in zip(color_keys, row, strict=True)
+    }
+
+
+def common_factor(
+    member: Sequence[Components],
+    representative: Sequence[Components],
+    *,
+    tolerance: float = TOLERANCE,
+) -> complex | None:
+    """The common ratio ``member / representative`` of all components.
+
+    Both sequences hold one component table per point. Components that are
+    zero on one side must be zero on the other; a point that vanishes
+    entirely on either side gives no ratio.
+    """
+
+    factor: complex | None = None
+    for member_point_values, representative_point_values in zip(
+        member, representative, strict=True
+    ):
+        ratio = _point_factor(
+            member_point_values, representative_point_values, tolerance
+        )
+        if ratio is None:
+            return None
+        if factor is None:
+            factor = ratio
+        elif abs(ratio - factor) > tolerance * abs(factor):
+            return None
+    return factor
+
+
+def _point_factor(
+    member: Components,
+    representative: Components,
+    tolerance: float,
+) -> complex | None:
+    member_scale = max(map(abs, member.values()), default=0.0)
+    representative_scale = max(map(abs, representative.values()), default=0.0)
+    if member_scale == 0.0 or representative_scale == 0.0:
+        return None
+    pivot = max(representative, key=lambda key: abs(representative[key]))
+    ratio = member.get(pivot, 0j) / representative[pivot]
+    if ratio == 0:
+        return None
+    for key in member.keys() | representative.keys():
+        member_value = member.get(key, 0j)
+        representative_value = representative.get(key, 0j)
+        member_zero = abs(member_value) <= _ZERO * member_scale
+        representative_zero = abs(representative_value) <= _ZERO * representative_scale
+        if member_zero or representative_zero:
+            if member_zero != representative_zero:
+                return None
+            continue
+        allowed = tolerance * max(abs(member_value), _FLOOR * member_scale)
+        if abs(member_value - ratio * representative_value) > allowed:
+            return None
+    return ratio
+
+
+def accepted_factor(
+    value: complex | None,
+    *,
+    only_unit_multiplier: bool,
+    tolerance: float = TOLERANCE,
+) -> Fraction | None:
+    """The recordable rational factor of a numerical ratio, if any."""
+
+    if value is None or abs(value.imag) > tolerance * abs(value):
+        return None
+    factor = rational_factor(value.real, tolerance=tolerance)
+    if factor is None or (only_unit_multiplier and factor != 1):
+        return None
+    return factor
+
+
+# --------------------------------------------------------------------------
+# Artifact model and runtimes
+
+
+@dataclass(frozen=True, slots=True)
+class _Model:
+    table: ParticleTable
+    colors: Mapping[int, int]
+    mass_names: Mapping[int, str]
+    fixed: frozenset[str]
+    defaults: Mapping[str, float]
+    complex_externals: frozenset[str]
+
+
+def _artifact_model(artifact: Path) -> _Model:
+    manifest = load_manifest(artifact)
+    records = [item for item in manifest.payloads if item.role == "compiled-model"]
+    if len(records) != 1:
+        raise ArtifactError("process grouping requires one compiled-model payload")
+    ir = json.loads(
+        confined_path(manifest.root, records[0].path).read_text(encoding="utf-8")
+    )["ir"]
+    parameters = {
+        str(record["name"]): SimpleNamespace(**record) for record in ir["parameters"]
+    }
+    particles = [SimpleNamespace(**record) for record in ir["particles"]]
+    return _Model(
+        table=particle_table(particles, parameters),
+        colors={int(record.pdg_code): int(record.color) for record in particles},
+        mass_names={
+            int(record.pdg_code): resolved_parameter_name(str(record.mass), parameters)
+            for record in particles
+        },
+        fixed=frozenset(
+            str(name) for record in particles for name in (record.mass, record.width)
+        ),
+        defaults={
+            name: float((record.value or (0.0, 0.0))[0])
+            for name, record in parameters.items()
+        },
+        complex_externals=frozenset(
+            name
+            for name, record in parameters.items()
+            if record.nature == "external" and record.parameter_type == "complex"
+        ),
+    )
+
+
+@dataclass(slots=True)
+class _Reference:
+    """A representative's own points and resolved components."""
+
+    process: GroupingProcess
+    accuracy: str
+    points: tuple[Point, ...]
+    components: tuple[Components, ...]
+
+
+class _Probe:
+    """One loaded process and the component view of its evaluations."""
+
+    def __init__(
+        self,
+        artifact: Path,
+        process: GroupingProcess,
+        model: _Model,
+        seed: int,
+    ) -> None:
+        from ..api import Runtime
+
+        self.process = process
+        self._model = model
+        self._seed = seed
+        self.runtime = Runtime.load(
+            artifact, process=process.process_id, mute_warnings=True
+        )
+        physics = self.runtime.physics
+        if physics.helicity_coverage != "complete":
+            raise _Unanalysable("helicity coverage is selected")
+        if physics.color_coverage == "selected":
+            raise _Unanalysable("colour coverage is selected")
+        pdgs = tuple(particle.pdg_id for particle in physics.external_particles)
+        if pdgs != process.pdgs:
+            raise _Unanalysable("runtime legs differ from the process map")
+        self.accuracy = physics.color_accuracy
+        self.parameters = physics.model_parameters
+        # Masses are never varied: only derived ones need the runtime state.
+        derived = {item.name for item in self.parameters if item.kind == "derived"}
+        self._slots = (
+            self._parameter_slots()
+            if any(model.mass_names[pdg] in derived for pdg in pdgs)
+            else None
+        )
+        self._helicities = {item.id: item.values for item in physics.helicities}
+        index_of_label = {
+            particle.label: particle.index for particle in physics.external_particles
+        }
+        self._words = {
+            item.id: tuple(index_of_label[label] for label in item.word)
+            for item in physics.color_flows
+        }
+        self._roles = color_roles(pdgs, process.initial_count, model.colors)
+
+    def _parameter_slots(self) -> dict[str, int] | None:
+        """Index of each real parameter in the runtime's current values.
+
+        Derived and complex external parameters occupy a real and an
+        imaginary slot. ``None`` when the runtime does not expose them.
+        """
+
+        values = self._current_values()
+        if values is None:
+            return None
+        slots: dict[str, int] = {}
+        defaults: list[float] = []
+        for parameter in self.parameters:
+            slots[parameter.name] = len(defaults)
+            defaults.append(parameter.default_real)
+            if (
+                parameter.kind == "derived"
+                or parameter.name in self._model.complex_externals
+            ):
+                defaults.append(parameter.default_imaginary)
+        if len(defaults) != len(values) or not all(
+            math.isclose(value, default, rel_tol=1e-9, abs_tol=1e-12)
+            for value, default in zip(values, defaults, strict=True)
+        ):
+            raise _Unanalysable("runtime model-parameter layout is not recognised")
+        return slots
+
+    def _current_values(self) -> tuple[float, ...] | None:
+        native = getattr(getattr(self.runtime, "_backend", None), "_runtime", None)
+        if native is None:
+            return None
+        from ..runtime._native_selection import exact_runtime_state_payload
+
+        values = exact_runtime_state_payload(native)["model_parameter_values"]
+        return tuple(float(value) for value in cast(Sequence[float], values))
+
+    def apply(self, point: int) -> None:
+        values = parameter_variation(
+            self.parameters, point=point, seed=self._seed, fixed=self._model.fixed
+        )
+        if values:
+            self.runtime.set_model_parameters(values)
+
+    def masses(self) -> tuple[float, ...]:
+        """Current mass of every leg, derived ones read back from the runtime."""
+
+        current = self._current_values() if self._slots is not None else None
+        if current is not None and self._slots is not None:
+            known = {name: current[slot] for name, slot in self._slots.items()}
+        else:
+            known = {
+                parameter.name: parameter.default_real for parameter in self.parameters
+            }
+        masses = []
+        for pdg in self.process.pdgs:
+            name = self._model.mass_names[pdg]
+            if name == "ZERO":
+                masses.append(0.0)
+                continue
+            for candidate in (name, f"particle.{abs(pdg)}.mass"):
+                if candidate in known:
+                    masses.append(abs(known[candidate]))
+                    break
+            else:
+                masses.append(abs(self._model.defaults.get(name, 0.0)))
+        return tuple(masses)
+
+    def reference(self) -> _Reference:
+        points = []
+        components = []
+        count = self.process.initial_count
+        for point in range(POINTS):
+            self.apply(point)
+            masses = self.masses()
+            momenta = on_shell_point(
+                masses[:count], masses[count:], seed=_point_seed(self._seed, point)
+            )
+            if momenta is None:
+                raise _Unanalysable("no on-shell phase space for the leg masses")
+            resolved = self.runtime.evaluate_resolved([momenta])
+            points.append(momenta)
+            components.append(self.components(resolved, 0, None))
+        return _Reference(self.process, self.accuracy, tuple(points), tuple(components))
+
+    def components(
+        self,
+        resolved: ResolvedEvaluation,
+        point: int,
+        mapping: LegMapping | None,
+    ) -> Components:
+        return resolved_components(
+            resolved,
+            point,
+            helicities=self._helicities,
+            words=self._words,
+            roles=self._roles,
+            mapping=mapping,
+        )
+
+    def relation(
+        self,
+        reference: _Reference,
+        mappings: Sequence[LegMapping],
+        *,
+        only_unit_multiplier: bool,
+    ) -> tuple[LegMapping, Fraction] | None:
+        """The first mapping relating this process to ``reference``.
+
+        Each point is evaluated for all mappings still consistent with the
+        previous points, in one batch.
+        """
+
+        alive = list(mappings)
+        evaluated: dict[LegMapping, list[Components]] = {
+            mapping: [] for mapping in alive
+        }
+        for point in range(POINTS):
+            if not alive:
+                return None
+            self.apply(point)
+            resolved = self.runtime.evaluate_resolved(
+                [
+                    member_point(reference.points[point], mapping.permutation)
+                    for mapping in alive
+                ]
+            )
+            survivors = []
+            for index, mapping in enumerate(alive):
+                evaluated[mapping].append(self.components(resolved, index, mapping))
+                if (
+                    common_factor(evaluated[mapping], reference.components[: point + 1])
+                    is not None
+                ):
+                    survivors.append(mapping)
+            alive = survivors
+        for mapping in alive:
+            factor = accepted_factor(
+                common_factor(evaluated[mapping], reference.components),
+                only_unit_multiplier=only_unit_multiplier,
+            )
+            if factor is not None:
+                return mapping, factor
+        return None
+
+
+# --------------------------------------------------------------------------
+# Analysis and storage
+
+
+def analyse_process_groups(
+    artifact: str | Path,
+    group_map: ProcessGroupMap,
+    *,
+    only_unit_multiplier: bool = False,
+    consider_charge_conjugation: bool = True,
+    seed: int = DEFAULT_SEED,
+) -> dict[str, object]:
+    """Merge numerically equal representatives of ``group_map`` in place.
+
+    Representatives are visited in canonical order and compared with the
+    earlier ones that kept their group; the canonically smaller one stays the
+    representative of a merged group.
+    """
+
+    root = Path(artifact).expanduser().resolve(strict=True)
+    model = _artifact_model(root)
+    processes = sorted(
+        (member.process for member in group_map.representatives if member.generated),
+        key=lambda process: representative_key(process, model.table),
+    )
+    kept: list[_Reference] = []
+    relations: list[dict[str, object]] = []
+    skipped: list[dict[str, str]] = []
+    for process in processes:
+        try:
+            probe = _Probe(root, process, model, seed)
+            key = coarse_key(process, model.table)
+            found = None
+            for reference in kept:
+                if (
+                    reference.accuracy != probe.accuracy
+                    or coarse_key(reference.process, model.table) != key
+                ):
+                    continue
+                mappings = candidate_mappings(
+                    process,
+                    reference.process,
+                    model.table,
+                    consider_charge_conjugation=consider_charge_conjugation,
+                )
+                result = probe.relation(
+                    reference,
+                    mappings,
+                    only_unit_multiplier=only_unit_multiplier,
+                )
+                if result is not None:
+                    found = reference, *result
+                    break
+            if found is None:
+                kept.append(probe.reference())
+                continue
+        except (_Unanalysable, PyAmpliColError) as error:
+            _LOGGER.warning("process grouping skips %s: %s", process.process_id, error)
+            skipped.append({"process_id": process.process_id, "reason": str(error)})
+            continue
+        reference, mapping, factor = found
+        relation = GroupMember.identity(process).related(
+            mapping, factor=factor, basis=GroupingBasis.NUMERICAL
+        )
+        group_map.merge(reference.process.process_id, relation, model.table)
+        relations.append(
+            {
+                "process_id": process.process_id,
+                "process": process.expression,
+                "representative": reference.process.process_id,
+                "factor": str(factor),
+                "permutation": list(mapping.permutation),
+                "conjugated": mapping.conjugated,
+            }
+        )
+    return {
+        "processes_analysed": len(processes) - len(skipped),
+        "new_relations": relations,
+        "skipped": skipped,
+    }
+
+
+def _analysis_record(
+    *,
+    only_unit_multiplier: bool,
+    consider_charge_conjugation: bool,
+    seed: int,
+) -> dict[str, object]:
+    return {
+        "variant": str(GroupingAnalysis.NUMERICAL),
+        "consider_charge_conjugation": consider_charge_conjugation,
+        "only_unit_multiplier": only_unit_multiplier,
+        "points": POINTS,
+        "parameter_variation": PARAMETER_VARIATION,
+        "tolerance": TOLERANCE,
+        "seed": seed,
+    }
+
+
+def update_artifact_process_groups(
+    artifact: str | Path,
+    *,
+    analysis: GroupingAnalysis | str,
+    only_unit_multiplier: bool,
+    consider_charge_conjugation: bool,
+) -> dict[str, object]:
+    """Analyse an artifact's representatives and rewrite its group map.
+
+    ``"none"`` only writes the trivial map when the artifact has none. The
+    numerical analysis merges new relations into the stored map; the artifact
+    identity is unchanged. Returns a summary of the update.
+    """
+
+    analysis = GroupingAnalysis(analysis)
+    root = Path(artifact).expanduser().resolve(strict=True)
+    group_map = read_process_groups(root)
+    changed = group_map is None
+    if group_map is None:
+        group_map = initial_process_groups(
+            (
+                str(process["id"]),
+                str(process["expression"]),
+                cast(Sequence[int], process["external_pdgs"]),
+            )
+            for process in load_manifest(root).processes
+        )
+    summary: dict[str, object] = {
+        "artifact": str(root),
+        "analysis": str(analysis),
+        "groups_before": len(group_map.groups),
+        "processes_analysed": 0,
+        "new_relations": [],
+        "skipped": [],
+    }
+    if analysis is GroupingAnalysis.NUMERICAL:
+        summary.update(
+            analyse_process_groups(
+                root,
+                group_map,
+                only_unit_multiplier=only_unit_multiplier,
+                consider_charge_conjugation=consider_charge_conjugation,
+            )
+        )
+        record = _analysis_record(
+            only_unit_multiplier=only_unit_multiplier,
+            consider_charge_conjugation=consider_charge_conjugation,
+            seed=DEFAULT_SEED,
+        )
+        if record not in group_map.analyses:
+            group_map.analyses.append(record)
+            changed = True
+        changed = changed or bool(summary["new_relations"])
+    if changed:
+        write_process_groups(root, group_map)
+    summary["groups_after"] = len(group_map.groups)
+    return summary
+
+
+__all__ = [
+    "DEFAULT_SEED",
+    "PARAMETER_VARIATION",
+    "POINTS",
+    "TOLERANCE",
+    "accepted_factor",
+    "analyse_process_groups",
+    "color_roles",
+    "common_factor",
+    "flow_key",
+    "member_point",
+    "on_shell_point",
+    "parameter_variation",
+    "resolved_components",
+    "update_artifact_process_groups",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/process_grouping_symmetry.py b/pyamplicol/src/pyamplicol/generation/process_grouping_symmetry.py
new file mode 100644
index 0000000000..188de906b5
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/process_grouping_symmetry.py
@@ -0,0 +1,297 @@
+# SPDX-License-Identifier: 0BSD
+"""Whether a flavour-blind relation is a symmetry of the allowed model vertices.
+
+``--flavor-blind`` assumes that processes related by a type-preserving flavour
+relabelling, optionally combined with charge conjugation, have equal matrix
+elements. That holds when the relation maps the vertices the representative is
+generated with onto themselves, which this module checks locally:
+
+* The relabelling of the member's flavours onto the representative's is
+  completed to a permutation of the model's particles (flavours present on
+  one side only are paired by particle type) and applied to every allowed
+  vertex. Each moved vertex must have an allowed image with the same particles
+  in the same order and the same structure and coupling: Lorentz and colour
+  expressions and resolved coupling for compiled models, kernel kind and
+  coupling for the built-in SM.
+* Charge conjugation with unchanged helicities is a symmetry of vector-like
+  interactions only. It is accepted when the conjugate of every allowed
+  vertex is allowed and no allowed vertex couples fermions chirally: a
+  Lorentz structure that changes when its left- and right-handed projectors
+  are exchanged (or contains ``gamma5``), or a built-in electroweak current
+  with different left- and right-handed couplings.
+
+Allowed vertices are those whose coupling orders fit ``process.max_coupling_orders``
+and, under the default ``minimal`` coupling-order policy, the representative's
+minimal coupling-order envelope. Masses and widths already belong to the
+particle type of a flavour class. The check inspects vertices, not diagrams,
+so it may warn about a relation that happens to hold for the processes at hand.
+"""
+
+from __future__ import annotations
+
+import functools
+import re
+from collections import Counter
+from collections.abc import Hashable, Iterable, Mapping, Sequence
+from dataclasses import dataclass, field
+
+from ..models.base import Model
+from ..models.contracts import CompiledModelIR
+from .process_grouping import GroupingProcess, LegMapping, ParticleTable
+
+
+@dataclass(frozen=True, slots=True)
+class SymmetryVertex:
+    particles: tuple[int, ...]
+    orders: tuple[tuple[str, int], ...]
+    signature: Hashable
+    """Structure and coupling that a symmetry must preserve."""
+    chiral: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class _AllowedVertices:
+    by_particles: Mapping[tuple[int, ...], Counter[Hashable]]
+    multisets: frozenset[tuple[int, ...]]
+    chiral: tuple[tuple[int, ...], ...]
+
+
+def _orders_allowed(
+    orders: Iterable[tuple[str, int]],
+    limits: Mapping[str, int],
+) -> bool:
+    return all(
+        int(value) <= limits.get(str(name).upper(), int(value))
+        for name, value in orders
+    )
+
+
+_PROJECTOR = re.compile(r"(proj)([mp])", re.IGNORECASE)
+_EXCHANGED_PROJECTOR = {"m": "p", "p": "m", "M": "P", "P": "M"}
+
+
+@functools.cache
+def _lorentz_is_chiral(expression: str) -> bool:
+    if "gamma5" in expression.casefold():
+        return True
+    if _PROJECTOR.search(expression) is None:
+        return False
+    from ..models import compiler_symbolica as _sym
+
+    _sym._ensure_symbolica()
+    exchanged = _PROJECTOR.sub(
+        lambda match: match.group(1) + _EXCHANGED_PROJECTOR[match.group(2)],
+        expression,
+    )
+    try:
+        return bool(
+            _sym.E(expression).expand().to_canonical_string()
+            != _sym.E(exchanged).expand().to_canonical_string()
+        )
+    except Exception:  # an unparsable structure is not assumed vector-like
+        return True
+
+
+@dataclass(slots=True)
+class VertexSymmetryTable:
+    """Model vertices and antiparticles, indexed per set of coupling limits."""
+
+    vertices: Sequence[SymmetryVertex]
+    antiparticles: Mapping[int, int]
+    _allowed: dict[tuple[tuple[str, int], ...], _AllowedVertices] = field(
+        default_factory=dict
+    )
+
+    @classmethod
+    def from_compiled_ir(cls, model: CompiledModelIR) -> VertexSymmetryTable:
+        by_name = {particle.name: particle for particle in model.particles}
+        couplings = {
+            coupling.name: coupling.resolved_expression for coupling in model.couplings
+        }
+        vertices = [
+            SymmetryVertex(
+                particles=tuple(by_name[name].pdg_code for name in term.particles),
+                orders=tuple(term.coupling_orders),
+                signature=(
+                    term.lorentz_expression,
+                    term.color_expression,
+                    couplings.get(term.coupling, term.coupling_expression),
+                ),
+                chiral=_lorentz_is_chiral(term.lorentz_expression),
+            )
+            for term in model.vertex_terms
+        ]
+        antiparticles = {
+            particle.pdg_code: by_name[particle.antiname].pdg_code
+            for particle in model.particles
+            if particle.antiname in by_name
+        }
+        return cls(vertices, antiparticles)
+
+    @classmethod
+    def from_builtin_model(cls, model: Model) -> VertexSymmetryTable:
+        vertices = []
+        for vertex in model.vertices:
+            rule = model.vertex_lowering_rule(vertex.kind)
+            vertices.append(
+                SymmetryVertex(
+                    particles=tuple(vertex.particles),
+                    orders=tuple(model.vertex_coupling_orders(vertex)),
+                    signature=(vertex.kind, tuple(vertex.coupling)),
+                    # Built-in electroweak fermion currents carry (left, right)
+                    # couplings.
+                    chiral=rule.expression_head == "fermion_gauge_weyl_current"
+                    and vertex.coupling[0] != vertex.coupling[1],
+                )
+            )
+        antiparticles = {
+            pdg: particle.anti_pdg for pdg, particle in model.particles.items()
+        }
+        return cls(vertices, antiparticles)
+
+    def _antiparticle(self, pdg: int) -> int:
+        return self.antiparticles.get(pdg, -pdg)
+
+    def allowed(self, limits: Mapping[str, int]) -> _AllowedVertices:
+        key = tuple(
+            sorted((str(name).upper(), int(value)) for name, value in limits.items())
+        )
+        cached = self._allowed.get(key)
+        if cached is not None:
+            return cached
+        upper = dict(key)
+        by_particles: dict[tuple[int, ...], Counter[Hashable]] = {}
+        chiral: dict[tuple[int, ...], None] = {}
+        for vertex in self.vertices:
+            if not _orders_allowed(vertex.orders, upper):
+                continue
+            by_particles.setdefault(vertex.particles, Counter())[vertex.signature] += 1
+            if vertex.chiral:
+                chiral.setdefault(vertex.particles, None)
+        result = _AllowedVertices(
+            by_particles=by_particles,
+            multisets=frozenset(tuple(sorted(particles)) for particles in by_particles),
+            chiral=tuple(chiral),
+        )
+        self._allowed[key] = result
+        return result
+
+    def relabelling(
+        self,
+        member: GroupingProcess,
+        representative: GroupingProcess,
+        mapping: LegMapping,
+        table: ParticleTable,
+    ) -> dict[int, int]:
+        """The particle permutation induced by ``mapping``, conjugation aside."""
+
+        partial: dict[int, int] = {}
+        for representative_leg, member_leg in enumerate(mapping.permutation):
+            source = member.pdgs[member_leg]
+            if mapping.conjugated:
+                source = self._antiparticle(source)
+            target = representative.pdgs[representative_leg]
+            for one, other in (
+                (source, target),
+                (self._antiparticle(source), self._antiparticle(target)),
+            ):
+                if partial.setdefault(one, other) != other:
+                    raise ValueError("leg mapping is not a flavour relabelling")
+        if len(set(partial.values())) != len(partial):
+            raise ValueError("leg mapping is not a flavour relabelling")
+        # Complete the injection to a permutation: particles that are only
+        # images receive the particles that are only sources, type by type.
+        sources = sorted(
+            (pdg for pdg in partial if pdg not in partial.values()),
+            key=lambda pdg: (table[pdg].type, abs(pdg), pdg),
+        )
+        images = sorted(
+            (pdg for pdg in partial.values() if pdg not in partial),
+            key=lambda pdg: (table[pdg].type, abs(pdg), pdg),
+        )
+        partial.update(zip(images, sources, strict=True))
+        return {
+            source: target for source, target in partial.items() if source != target
+        }
+
+    def relation_warning(
+        self,
+        member: GroupingProcess,
+        representative: GroupingProcess,
+        mapping: LegMapping,
+        table: ParticleTable,
+        *,
+        limits: Mapping[str, int],
+    ) -> str | None:
+        """Why ``mapping`` may not be a symmetry, or ``None``."""
+
+        allowed = self.allowed(limits)
+
+        def name(pdg: int) -> str:
+            particle = table.get(pdg)
+            return particle.name if particle is not None else str(pdg)
+
+        def vertex_text(particles: Sequence[int]) -> str:
+            return "[" + " ".join(name(pdg) for pdg in particles) + "]"
+
+        relation = (
+            f"{member.expression!r} assumed equal to {representative.expression!r}"
+        )
+        reasons = []
+        permutation = self.relabelling(member, representative, mapping, table)
+        for particles, signatures in allowed.by_particles.items():
+            image = tuple(permutation.get(pdg, pdg) for pdg in particles)
+            if image != particles and allowed.by_particles.get(image) != signatures:
+                moved = ", ".join(
+                    f"{name(source)}->{name(target)}"
+                    for source, target in sorted(permutation.items())
+                    if source > 0 or table[source].type.self_conjugate
+                )
+                reasons.append(
+                    f"relabelling {moved} changes the allowed vertex "
+                    f"{vertex_text(particles)}"
+                )
+                break
+        if mapping.conjugated:
+            if allowed.chiral:
+                # Prefer an example that involves the flavours of the process.
+                flavours = {abs(pdg) for pdg in representative.pdgs}
+                chiral = next(
+                    (
+                        particles
+                        for particles in allowed.chiral
+                        if flavours & {abs(pdg) for pdg in particles}
+                    ),
+                    allowed.chiral[0],
+                )
+                reasons.append(
+                    "charge conjugation is broken by the chiral allowed vertex "
+                    f"{vertex_text(chiral)}"
+                )
+            else:
+                missing = next(
+                    (
+                        particles
+                        for particles in allowed.multisets
+                        if tuple(sorted(self._antiparticle(pdg) for pdg in particles))
+                        not in allowed.multisets
+                    ),
+                    None,
+                )
+                if missing is not None:
+                    reasons.append(
+                        "charge conjugation has no allowed image of the vertex "
+                        f"{vertex_text(missing)}"
+                    )
+        if not reasons:
+            return None
+        limit_text = ", ".join(
+            f"{key}<={value}" for key, value in sorted(limits.items())
+        )
+        return (
+            f"{relation}, but {' and '.join(reasons)} "
+            f"(coupling orders: {limit_text or 'unrestricted'})"
+        )
+
+
+__all__ = ["SymmetryVertex", "VertexSymmetryTable"]
diff --git a/pyamplicol/src/pyamplicol/generation/progress.py b/pyamplicol/src/pyamplicol/generation/progress.py
new file mode 100644
index 0000000000..60c7a9e595
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/progress.py
@@ -0,0 +1,237 @@
+# SPDX-License-Identifier: 0BSD
+"""Typed progress phases for the generation service."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from threading import Lock
+
+from pyamplicol.reporting import (
+    NullProgressSink,
+    ProgressEnd,
+    ProgressSink,
+    ProgressStart,
+    ProgressUpdate,
+)
+from pyamplicol.reporting.progress import ProgressDetailValue
+
+
+@dataclass(slots=True)
+class PhaseHandle:
+    task_id: str
+    sink: ProgressSink | None
+    total: int | None
+    completed: int = 0
+    _lock: Lock = field(default_factory=Lock, init=False, repr=False)
+
+    def update(
+        self,
+        completed: int,
+        *,
+        message: str | None = None,
+        total: int | None = None,
+        details: Mapping[str, ProgressDetailValue] | None = None,
+    ) -> None:
+        with self._lock:
+            self._update_locked(
+                completed,
+                message=message,
+                total=total,
+                details=details,
+            )
+
+    def advance(
+        self,
+        *,
+        message: str | None = None,
+        details: Mapping[str, ProgressDetailValue] | None = None,
+    ) -> None:
+        with self._lock:
+            self._update_locked(
+                self.completed + 1,
+                message=message,
+                total=None,
+                details=details,
+            )
+
+    def _update_locked(
+        self,
+        completed: int,
+        *,
+        message: str | None,
+        total: int | None,
+        details: Mapping[str, ProgressDetailValue] | None,
+    ) -> None:
+        active_total = self.total if total is None else total
+        if total is not None:
+            self.total = total
+        bounded = completed
+        if active_total is not None:
+            bounded = min(completed, active_total)
+        self.completed = max(self.completed, bounded)
+        if self.sink is not None:
+            self.sink.emit(
+                ProgressUpdate(
+                    self.task_id,
+                    completed=self.completed,
+                    total=active_total,
+                    message=message,
+                    details={} if details is None else details,
+                )
+            )
+
+    @contextmanager
+    def child(
+        self,
+        key: str,
+        description: str,
+        *,
+        total: int | None = None,
+        unit: str = "items",
+        details: Mapping[str, ProgressDetailValue] | None = None,
+    ) -> Iterator[PhaseHandle]:
+        task_id = f"{self.task_id}:{key}"
+        if self.sink is not None:
+            self.sink.emit(
+                ProgressStart(
+                    task_id,
+                    description,
+                    total=total,
+                    parent_task_id=self.task_id,
+                    unit=unit,
+                    details={} if details is None else details,
+                )
+            )
+        handle = PhaseHandle(task_id, self.sink, total)
+        started = time.perf_counter()
+        try:
+            yield handle
+        except BaseException as exc:
+            elapsed = time.perf_counter() - started
+            if self.sink is not None:
+                self.sink.emit(
+                    ProgressEnd(
+                        task_id,
+                        success=False,
+                        message=f"{type(exc).__name__}: {exc}",
+                        elapsed_seconds=elapsed,
+                    )
+                )
+            raise
+        elapsed = time.perf_counter() - started
+        if total is not None and handle.completed < total:
+            handle.update(total)
+        if self.sink is not None:
+            self.sink.emit(ProgressEnd(task_id, elapsed_seconds=elapsed))
+
+
+@dataclass(slots=True)
+class GenerationPhaseReporter:
+    sink: ProgressSink | None
+    timings: dict[str, float] = field(default_factory=dict)
+    root: PhaseHandle | None = None
+    _root_started_at: float | None = None
+
+    def __post_init__(self) -> None:
+        # Progress-off must not install callbacks into generation machinery.
+        if isinstance(self.sink, NullProgressSink):
+            self.sink = None
+
+    def start_generation(
+        self,
+        *,
+        total: int,
+        details: Mapping[str, ProgressDetailValue],
+    ) -> None:
+        task_id = "generation"
+        self._root_started_at = time.perf_counter()
+        if self.sink is not None:
+            self.sink.emit(
+                ProgressStart(
+                    task_id,
+                    "Generating processes",
+                    total=total,
+                    unit="phases",
+                    details=details,
+                )
+            )
+        self.root = PhaseHandle(task_id, self.sink, total)
+
+    def finish_generation(
+        self,
+        *,
+        success: bool = True,
+        message: str | None = None,
+    ) -> None:
+        if self.root is None or self._root_started_at is None:
+            return
+        elapsed = time.perf_counter() - self._root_started_at
+        if (
+            success
+            and self.root.total is not None
+            and self.root.completed < self.root.total
+        ):
+            self.root.update(self.root.total)
+        if self.sink is not None:
+            self.sink.emit(
+                ProgressEnd(
+                    self.root.task_id,
+                    success=success,
+                    message=message,
+                    elapsed_seconds=elapsed,
+                )
+            )
+        self._root_started_at = None
+
+    @contextmanager
+    def phase(
+        self,
+        name: str,
+        description: str,
+        *,
+        total: int | None = None,
+    ) -> Iterator[PhaseHandle]:
+        task_id = f"generation:{name}"
+        if self.sink is not None:
+            self.sink.emit(
+                ProgressStart(
+                    task_id,
+                    description,
+                    total=total,
+                    parent_task_id=None if self.root is None else self.root.task_id,
+                )
+            )
+        handle = PhaseHandle(task_id, self.sink, total)
+        started = time.perf_counter()
+        try:
+            yield handle
+        except BaseException as exc:
+            elapsed = time.perf_counter() - started
+            self.timings[name] = elapsed
+            if self.sink is not None:
+                self.sink.emit(
+                    ProgressEnd(
+                        task_id,
+                        success=False,
+                        message=f"{type(exc).__name__}: {exc}",
+                        elapsed_seconds=elapsed,
+                    )
+                )
+            raise
+        elapsed = time.perf_counter() - started
+        self.timings[name] = elapsed
+        if total is not None and handle.completed < total:
+            handle.update(total)
+        if self.sink is not None:
+            self.sink.emit(ProgressEnd(task_id, elapsed_seconds=elapsed))
+        if self.root is not None:
+            self.root.advance(
+                message=description,
+                details={"step": description},
+            )
+
+
+__all__ = ["GenerationPhaseReporter", "PhaseHandle"]
diff --git a/pyamplicol/src/pyamplicol/generation/recurrence_color.py b/pyamplicol/src/pyamplicol/generation/recurrence_color.py
new file mode 100644
index 0000000000..54716a889f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/recurrence_color.py
@@ -0,0 +1,987 @@
+# SPDX-License-Identifier: 0BSD
+"""Bounded binary codec for process-owned recurrence color contraction."""
+
+from __future__ import annotations
+
+import math
+import struct
+from collections.abc import Sequence
+from hashlib import sha256
+
+from pyamplicol.color import (
+    ColorContractionEntry,
+    ColorContractionPlan,
+    ColorContractionTemplateEntry,
+    FactorizedColorContractionBlock,
+    SymmetricGroupColorContractionBlock,
+)
+from pyamplicol.generation.recurrence_columnar import ExactComplexRationalV1
+
+RECURRENCE_COLOR_CONTRACTION_CODEC_ABI = "pyamplicol-recurrence-color-contraction-v3"
+RECURRENCE_COLOR_CONTRACTION_MAGIC = b"PACRCLR3"
+
+_VERSION = 3
+_STORAGE_EXPANDED = 1
+_STORAGE_REPEATED = 2
+_STORAGE_CONVOLUTION_KERNELS = 3
+_ACCURACY_NLC = 1
+_ACCURACY_FULL = 2
+_FACTOR_NONE = 0
+_FACTOR_KLEIN_FOUR = 1
+_FACTOR_ELEMENTARY_ABELIAN = 2
+_FACTOR_SYMMETRIC_GROUP_FOURIER = 3
+_FLAG_INCLUDES_COLOR_FACTOR = 1 << 0
+_KNOWN_FLAGS = _FLAG_INCLUDES_COLOR_FACTOR
+_MAX_FACTOR_RANK = 31  # 2**rank must fit the u32 local-group count.
+_MAX_SYMMETRIC_GROUP_DEGREE = 10
+_ZERO_SECTOR_OWNER = 0xFFFF_FFFF
+
+# magic; 14 u32 fields; 7 u64 fields
+_HEADER = struct.Struct("<8s14I7Q")
+# left/right group or local-group IDs; raw complex weight; raw symmetry factor;
+# exact, symmetry-folded coefficient catalog ID.
+_ENTRY = struct.Struct("<IIdddI")
+_EXACT_FACTOR_BYTES = 64
+_U32 = struct.Struct("<I")
+
+
+class RecurrenceColorCodecError(ValueError):
+    """The color-contraction plan cannot be represented by the fixed ABI."""
+
+
+def encode_recurrence_color_contraction(
+    plan: ColorContractionPlan,
+    *,
+    sector_count: int,
+    component_count: int,
+    ordered_group_ids: Sequence[int],
+    destination_by_group: Sequence[int],
+    group_sector_ids: Sequence[int],
+    group_component_ids: Sequence[int],
+    sector_owner_ids: Sequence[int],
+    exact_coefficients: Sequence[ExactComplexRationalV1],
+    destination_count: int,
+) -> bytes:
+    """Encode one supported NLC/full color-contraction plan.
+
+    The caller owns payload hashing and container authentication. The codec
+    deliberately preserves raw weights and symmetry factors as distinct f64
+    fields while binding every row to a canonical exact coefficient.
+
+    >>> plan = ColorContractionPlan(
+    ...     color_accuracy="nlc",
+    ...     supported=True,
+    ...     reason=None,
+    ...     group_count=2,
+    ...     entries=(
+    ...         ColorContractionEntry(0, 0, 3.0),
+    ...         ColorContractionEntry(0, 1, 2.0, symmetry_factor=2.0),
+    ...     ),
+    ... )
+    >>> payload = encode_recurrence_color_contraction(
+    ...     plan,
+    ...     sector_count=2,
+    ...     component_count=1,
+    ...     ordered_group_ids=(0, 1),
+    ...     destination_by_group=(7, 9),
+    ...     group_sector_ids=(0, 1),
+    ...     group_component_ids=(0, 0),
+    ...     sector_owner_ids=(0, 1),
+    ...     exact_coefficients=(
+    ...         ExactComplexRationalV1(3),
+    ...         ExactComplexRationalV1(4),
+    ...     ),
+    ...     destination_count=10,
+    ... )
+    >>> payload[:8] == RECURRENCE_COLOR_CONTRACTION_MAGIC
+    True
+    >>> len(payload) == (
+    ...     _HEADER.size
+    ...     + 2 * _ENTRY.size
+    ...     + 2 * _EXACT_FACTOR_BYTES
+    ...     + 10 * _U32.size
+    ... )
+    True
+    """
+
+    if not isinstance(plan, ColorContractionPlan):
+        raise RecurrenceColorCodecError(
+            "recurrence color payload requires a ColorContractionPlan"
+        )
+    if not plan.supported:
+        raise RecurrenceColorCodecError(
+            "unsupported color-contraction plans cannot be encoded"
+        )
+    if plan.reason is not None:
+        raise RecurrenceColorCodecError(
+            "a supported color-contraction plan cannot carry a failure reason"
+        )
+    accuracy = _encode_accuracy(plan.color_accuracy)
+    group_count = _checked_u32("group_count", plan.group_count)
+    if group_count == 0:
+        raise RecurrenceColorCodecError("group_count must be positive")
+    sector_count = _checked_u32("sector_count", sector_count)
+    component_count = _checked_u32("component_count", component_count)
+    if sector_count == 0 or component_count == 0:
+        raise RecurrenceColorCodecError(
+            "sector_count and component_count must be positive"
+        )
+    ordered_groups = tuple(
+        _checked_u32("ordered group ID", value) for value in ordered_group_ids
+    )
+    destinations = tuple(
+        _checked_u32("Direct-Arena destination ID", value)
+        for value in destination_by_group
+    )
+    sectors = tuple(
+        _checked_u32("group sector ID", value) for value in group_sector_ids
+    )
+    components = tuple(
+        _checked_u32("group component ID", value) for value in group_component_ids
+    )
+    owners = tuple(
+        _checked_u32("physical sector owner ID", value) for value in sector_owner_ids
+    )
+    destination_count = _checked_u32("destination_count", destination_count)
+    if destination_count == 0:
+        raise RecurrenceColorCodecError("destination_count must be positive")
+    if len(ordered_groups) != group_count:
+        raise RecurrenceColorCodecError(
+            "ordered group map count does not match group_count"
+        )
+    if sorted(ordered_groups) != list(range(group_count)):
+        raise RecurrenceColorCodecError(
+            "ordered group map is not a permutation of all group IDs"
+        )
+    if len(destinations) != group_count:
+        raise RecurrenceColorCodecError(
+            "destination map count does not match group_count"
+        )
+    if len(set(destinations)) != len(destinations):
+        raise RecurrenceColorCodecError(
+            "destination map contains duplicate Direct-Arena destinations"
+        )
+    if any(value >= destination_count for value in destinations):
+        raise RecurrenceColorCodecError(
+            "destination map references an out-of-bounds Direct-Arena destination"
+        )
+    _validate_group_coordinates(
+        group_count=group_count,
+        sector_count=sector_count,
+        component_count=component_count,
+        group_sector_ids=sectors,
+        group_component_ids=components,
+    )
+    _validate_sector_owners(
+        sector_count=sector_count,
+        owner_by_sector=owners,
+        active_sector_ids=set(sectors),
+    )
+
+    flags = _FLAG_INCLUDES_COLOR_FACTOR if plan.includes_color_factor else 0
+    if flags & ~_KNOWN_FLAGS:
+        raise AssertionError("internal recurrence color flag drift")
+
+    repeated = plan.repeated_block
+    symmetric_group = plan.symmetric_group_block
+    if repeated is None and symmetric_group is None:
+        storage = _STORAGE_EXPANDED
+        local_group_count = 0
+        entries: Sequence[ColorContractionEntry | ColorContractionTemplateEntry] = (
+            plan.entries
+        )
+        factor_kind = _FACTOR_NONE
+        factor_rank = 0
+        cosets: tuple[tuple[int, ...], ...] = ()
+        _validate_entries(entries, group_count=group_count, label="expanded")
+        _validate_expanded_components(
+            entries,
+            group_component_ids=components,
+        )
+        logical_entry_count = len(entries)
+    elif repeated is not None:
+        if plan.entries:
+            raise RecurrenceColorCodecError(
+                "expanded and repeated color-contraction storage cannot be mixed"
+            )
+        storage = _STORAGE_REPEATED
+        repeated_component_count = _checked_u32(
+            "repeated component_count", repeated.component_count
+        )
+        if repeated_component_count < 2:
+            raise RecurrenceColorCodecError(
+                "repeated storage requires at least two components"
+            )
+        if repeated_component_count != component_count:
+            raise RecurrenceColorCodecError(
+                "repeated component_count does not match the explicit component_count"
+            )
+        repeated_group_map = tuple(
+            _checked_u32("repeated component group ID", value)
+            for value in repeated.component_group_ids
+        )
+        if len(repeated_group_map) != group_count:
+            raise RecurrenceColorCodecError(
+                "repeated group map count does not match group_count"
+            )
+        if repeated_group_map != ordered_groups:
+            raise RecurrenceColorCodecError(
+                "ordered group map does not match repeated local-color-major/"
+                "component-minor storage"
+            )
+        if len(set(repeated_group_map)) != len(repeated_group_map):
+            raise RecurrenceColorCodecError(
+                "repeated group map contains duplicate group IDs"
+            )
+        if any(value >= group_count for value in repeated_group_map):
+            raise RecurrenceColorCodecError(
+                "repeated group map references an out-of-bounds group"
+            )
+        if len(repeated_group_map) % component_count:
+            raise RecurrenceColorCodecError("repeated group map is not rectangular")
+        local_group_count = len(repeated_group_map) // component_count
+        if local_group_count == 0:
+            raise RecurrenceColorCodecError(
+                "repeated storage requires at least one local color group"
+            )
+        _validate_repeated_group_coordinates(
+            ordered_group_ids=ordered_groups,
+            group_sector_ids=sectors,
+            group_component_ids=components,
+            sector_count=sector_count,
+            component_count=component_count,
+            local_group_count=local_group_count,
+        )
+        entries = repeated.entries
+        _validate_entries(
+            entries,
+            group_count=local_group_count,
+            label="repeated",
+        )
+        factor_kind, factor_rank, cosets = _encode_factorization(
+            repeated.factorized_block,
+            local_group_count=local_group_count,
+            entries=repeated.entries,
+        )
+        logical_entry_count = _checked_product(
+            "logical entry count", component_count, len(entries)
+        )
+    else:
+        if symmetric_group is None:
+            raise AssertionError("unreachable symmetric-group storage branch")
+        if plan.entries or repeated is not None:
+            raise RecurrenceColorCodecError(
+                "convolution-kernel storage cannot be mixed with expanded or "
+                "repeated color contraction"
+            )
+        storage = _STORAGE_CONVOLUTION_KERNELS
+        if symmetric_group.component_count != component_count:
+            raise RecurrenceColorCodecError(
+                "symmetric-group component_count does not match the explicit "
+                "component_count"
+            )
+        symmetric_group_map = tuple(
+            _checked_u32("symmetric-group component group ID", value)
+            for value in symmetric_group.component_group_ids
+        )
+        if symmetric_group_map != ordered_groups:
+            raise RecurrenceColorCodecError(
+                "ordered group map does not match symmetric-group local-color-major/"
+                "component-minor storage"
+            )
+        if len(symmetric_group_map) % component_count:
+            raise RecurrenceColorCodecError(
+                "symmetric-group component map is not rectangular"
+            )
+        local_group_count = len(symmetric_group_map) // component_count
+        if local_group_count == 0:
+            raise RecurrenceColorCodecError(
+                "convolution-kernel storage requires at least one local color group"
+            )
+        if _checked_u32("symmetric-group local_group_count", local_group_count) != (
+            symmetric_group.local_group_count
+        ):
+            raise RecurrenceColorCodecError(
+                "symmetric-group local group count is inconsistent"
+            )
+        _validate_repeated_group_coordinates(
+            ordered_group_ids=ordered_groups,
+            group_sector_ids=sectors,
+            group_component_ids=components,
+            sector_count=sector_count,
+            component_count=component_count,
+            local_group_count=local_group_count,
+        )
+        local_sector_ids = tuple(
+            sectors[symmetric_group_map[index * component_count]]
+            for index in range(local_group_count)
+        )
+        if local_sector_ids != symmetric_group.local_sector_ids:
+            raise RecurrenceColorCodecError(
+                "symmetric-group local sector order disagrees with the group map"
+            )
+        entries = (*symmetric_group.kernel_entries, *symmetric_group.residual_entries)
+        _validate_entries(
+            entries,
+            group_count=local_group_count,
+            label="convolution-kernel",
+        )
+        factor_kind, factor_rank, cosets = _encode_symmetric_group_convolution(
+            symmetric_group,
+            local_group_count=local_group_count,
+            entries=entries,
+        )
+        expected_exact_coefficients = _symmetric_group_exact_coefficients(
+            symmetric_group
+        )
+        if tuple(exact_coefficients) != expected_exact_coefficients:
+            raise RecurrenceColorCodecError(
+                "symmetric-group exact color coefficients disagree with the "
+                "certified convolution plan"
+            )
+        logical_entry_count = _checked_product(
+            "logical entry count", component_count, len(entries)
+        )
+
+    entry_count = _checked_u64("entry_count", len(entries))
+    if len(exact_coefficients) != len(entries):
+        raise RecurrenceColorCodecError(
+            "exact color coefficient count does not match entry_count"
+        )
+    exact_catalog: list[ExactComplexRationalV1] = []
+    exact_id_by_key: dict[tuple[int, int, int, int], int] = {}
+    exact_factor_ids: list[int] = []
+    for index, (entry, factor) in enumerate(
+        zip(entries, exact_coefficients, strict=True)
+    ):
+        if not isinstance(factor, ExactComplexRationalV1):
+            raise RecurrenceColorCodecError(
+                f"exact color coefficient {index} is not canonical"
+            )
+        _validate_exact_matches_f64(entry, factor, index)
+        factor_id = exact_id_by_key.get(factor.canonical_key)
+        if factor_id is None:
+            factor_id = len(exact_catalog)
+            _checked_u32("exact color factor ID", factor_id)
+            exact_id_by_key[factor.canonical_key] = factor_id
+            exact_catalog.append(factor)
+        exact_factor_ids.append(factor_id)
+    exact_factor_count = _checked_u64("exact_factor_count", len(exact_catalog))
+    coset_count = _checked_u64("coset_count", len(cosets))
+    flattened_cosets = tuple(value for coset in cosets for value in coset)
+    coset_index_count = _checked_u64("coset_index_count", len(flattened_cosets))
+    logical_entry_count_u64 = _checked_u64("logical_entry_count", logical_entry_count)
+    owner_map_count = _checked_u64("owner_map_count", len(owners))
+
+    payload_size = _checked_payload_size(
+        entry_count=entry_count,
+        exact_factor_count=exact_factor_count,
+        group_count=group_count,
+        sector_count=sector_count,
+        coset_index_count=coset_index_count,
+    )
+    header = _HEADER.pack(
+        RECURRENCE_COLOR_CONTRACTION_MAGIC,
+        _VERSION,
+        _HEADER.size,
+        storage,
+        accuracy,
+        flags,
+        group_count,
+        sector_count,
+        component_count,
+        local_group_count,
+        destination_count,
+        factor_kind,
+        factor_rank,
+        _ENTRY.size,
+        _EXACT_FACTOR_BYTES,
+        entry_count,
+        exact_factor_count,
+        coset_count,
+        coset_index_count,
+        logical_entry_count_u64,
+        owner_map_count,
+        payload_size,
+    )
+    output = bytearray(_HEADER.size + payload_size)
+    output[: _HEADER.size] = header
+    offset = _HEADER.size
+    for entry, exact_factor_id in zip(entries, exact_factor_ids, strict=True):
+        _ENTRY.pack_into(
+            output,
+            offset,
+            _entry_left(entry),
+            _entry_right(entry),
+            float(entry.weight_re),
+            float(entry.weight_im),
+            float(entry.symmetry_factor),
+            exact_factor_id,
+        )
+        offset += _ENTRY.size
+    for factor in exact_catalog:
+        offset = _pack_exact_factor(output, offset, factor)
+    for value in ordered_groups:
+        _U32.pack_into(output, offset, value)
+        offset += _U32.size
+    for value in destinations:
+        _U32.pack_into(output, offset, value)
+        offset += _U32.size
+    for value in sectors:
+        _U32.pack_into(output, offset, value)
+        offset += _U32.size
+    for value in components:
+        _U32.pack_into(output, offset, value)
+        offset += _U32.size
+    for value in owners:
+        _U32.pack_into(output, offset, value)
+        offset += _U32.size
+    for value in flattened_cosets:
+        _U32.pack_into(output, offset, value)
+        offset += _U32.size
+    if offset != len(output):
+        raise AssertionError("internal recurrence color payload size drift")
+    return bytes(output)
+
+
+def _encode_accuracy(value: str) -> int:
+    if value == "nlc":
+        return _ACCURACY_NLC
+    if value == "full":
+        return _ACCURACY_FULL
+    raise RecurrenceColorCodecError(
+        f"recurrence color payload requires nlc or full accuracy, got {value!r}"
+    )
+
+
+def _entry_left(
+    entry: ColorContractionEntry | ColorContractionTemplateEntry,
+) -> int:
+    if isinstance(entry, ColorContractionEntry):
+        return entry.left_group_id
+    return entry.left_group_index
+
+
+def _entry_right(
+    entry: ColorContractionEntry | ColorContractionTemplateEntry,
+) -> int:
+    if isinstance(entry, ColorContractionEntry):
+        return entry.right_group_id
+    return entry.right_group_index
+
+
+def _validate_entries(
+    entries: Sequence[ColorContractionEntry | ColorContractionTemplateEntry],
+    *,
+    group_count: int,
+    label: str,
+) -> None:
+    seen: set[tuple[int, int]] = set()
+    for index, entry in enumerate(entries):
+        left = _checked_u32(f"{label} entry {index} left ID", _entry_left(entry))
+        right = _checked_u32(f"{label} entry {index} right ID", _entry_right(entry))
+        if left >= group_count or right >= group_count:
+            raise RecurrenceColorCodecError(
+                f"{label} entry {index} references an out-of-bounds group"
+            )
+        if left > right:
+            raise RecurrenceColorCodecError(
+                f"{label} entry {index} is not canonical upper triangular"
+            )
+        pair = (left, right)
+        if pair in seen:
+            raise RecurrenceColorCodecError(
+                f"{label} entries contain duplicate pair {pair}"
+            )
+        seen.add(pair)
+        values = (
+            float(entry.weight_re),
+            float(entry.weight_im),
+            float(entry.symmetry_factor),
+        )
+        if not all(math.isfinite(value) for value in values):
+            raise RecurrenceColorCodecError(
+                f"{label} entry {index} contains a non-finite f64"
+            )
+        if not all(
+            math.isfinite(float(entry.symmetry_factor) * value)
+            for value in (float(entry.weight_re), float(entry.weight_im))
+        ):
+            raise RecurrenceColorCodecError(
+                f"{label} entry {index} overflows after symmetry folding"
+            )
+
+
+def _validate_expanded_components(
+    entries: Sequence[ColorContractionEntry | ColorContractionTemplateEntry],
+    *,
+    group_component_ids: Sequence[int],
+) -> None:
+    for index, entry in enumerate(entries):
+        if (
+            group_component_ids[_entry_left(entry)]
+            != group_component_ids[_entry_right(entry)]
+        ):
+            raise RecurrenceColorCodecError(
+                f"expanded entry {index} couples groups from different components"
+            )
+
+
+def _validate_exact_matches_f64(
+    entry: ColorContractionEntry | ColorContractionTemplateEntry,
+    factor: ExactComplexRationalV1,
+    index: int,
+) -> None:
+    actual = (
+        float(entry.weight_re) * float(entry.symmetry_factor),
+        float(entry.weight_im) * float(entry.symmetry_factor),
+    )
+    expected = (
+        factor.real_numerator / factor.real_denominator,
+        factor.imag_numerator / factor.imag_denominator,
+    )
+    for component, actual_value, expected_value in zip(
+        ("real", "imaginary"),
+        actual,
+        expected,
+        strict=True,
+    ):
+        tolerance = max(math.ulp(actual_value), math.ulp(expected_value))
+        if not math.isclose(
+            actual_value,
+            expected_value,
+            rel_tol=0.0,
+            abs_tol=tolerance,
+        ):
+            raise RecurrenceColorCodecError(
+                f"entry {index} {component} f64 coefficient disagrees with its "
+                "exact color factor"
+            )
+
+
+def _validate_group_coordinates(
+    *,
+    group_count: int,
+    sector_count: int,
+    component_count: int,
+    group_sector_ids: Sequence[int],
+    group_component_ids: Sequence[int],
+) -> None:
+    if len(group_sector_ids) != group_count or len(group_component_ids) != group_count:
+        raise RecurrenceColorCodecError(
+            "group coordinate map count does not match group_count"
+        )
+    if any(value >= sector_count for value in group_sector_ids):
+        raise RecurrenceColorCodecError(
+            "group sector map references an out-of-bounds physical sector"
+        )
+    if any(value >= component_count for value in group_component_ids):
+        raise RecurrenceColorCodecError(
+            "group component map references an out-of-bounds resolved component"
+        )
+    coordinates = tuple(zip(group_sector_ids, group_component_ids, strict=True))
+    if len(set(coordinates)) != group_count:
+        raise RecurrenceColorCodecError(
+            "group coordinate maps contain a duplicate sector/component pair"
+        )
+
+
+def _validate_sector_owners(
+    *,
+    sector_count: int,
+    owner_by_sector: Sequence[int],
+    active_sector_ids: set[int],
+) -> None:
+    if len(owner_by_sector) != sector_count:
+        raise RecurrenceColorCodecError(
+            "physical sector owner map count does not match sector_count"
+        )
+    fixed_points: set[int] = set()
+    for sector_id, owner_id in enumerate(owner_by_sector):
+        if owner_id == _ZERO_SECTOR_OWNER:
+            continue
+        if owner_id >= sector_count:
+            raise RecurrenceColorCodecError(
+                f"physical sector {sector_id} has an out-of-bounds owner"
+            )
+        if owner_id > sector_id:
+            raise RecurrenceColorCodecError(
+                f"physical sector {sector_id} does not use its minimal owner"
+            )
+        if owner_by_sector[owner_id] != owner_id:
+            raise RecurrenceColorCodecError(
+                f"physical sector {sector_id} has a non-idempotent owner"
+            )
+        if owner_id == sector_id:
+            fixed_points.add(sector_id)
+    if fixed_points != active_sector_ids:
+        raise RecurrenceColorCodecError(
+            "active recurrence sectors are not exactly the authenticated "
+            "physical-sector owners"
+        )
+
+
+def _validate_repeated_group_coordinates(
+    *,
+    ordered_group_ids: Sequence[int],
+    group_sector_ids: Sequence[int],
+    group_component_ids: Sequence[int],
+    sector_count: int,
+    component_count: int,
+    local_group_count: int,
+) -> None:
+    row_sectors: list[int] = []
+    for local_group_id in range(local_group_count):
+        start = local_group_id * component_count
+        row = ordered_group_ids[start : start + component_count]
+        sectors = {group_sector_ids[group_id] for group_id in row}
+        components = tuple(group_component_ids[group_id] for group_id in row)
+        if len(sectors) != 1 or components != tuple(range(component_count)):
+            raise RecurrenceColorCodecError(
+                "repeated local color row does not cover one physical sector "
+                "and every component exactly once"
+            )
+        row_sectors.append(next(iter(sectors)))
+    if len(set(row_sectors)) != len(row_sectors) or any(
+        sector_id >= sector_count for sector_id in row_sectors
+    ):
+        raise RecurrenceColorCodecError(
+            "repeated local color rows do not identify unique physical sectors"
+        )
+
+
+def _encode_factorization(
+    factorization: FactorizedColorContractionBlock | None,
+    *,
+    local_group_count: int,
+    entries: Sequence[ColorContractionTemplateEntry],
+) -> tuple[int, int, tuple[tuple[int, ...], ...]]:
+    if factorization is None:
+        return _FACTOR_NONE, 0, ()
+    if factorization.kind == "klein-four-walsh":
+        factor_kind = _FACTOR_KLEIN_FOUR
+        rank = 2
+    elif factorization.kind == "elementary-abelian-walsh":
+        factor_kind = _FACTOR_ELEMENTARY_ABELIAN
+        if factorization.rank is None:
+            raise RecurrenceColorCodecError(
+                "elementary-Abelian factorization is missing its rank"
+            )
+        rank = _checked_u32("factorization rank", factorization.rank)
+        if rank < 3 or rank > _MAX_FACTOR_RANK:
+            raise RecurrenceColorCodecError(
+                f"elementary-Abelian factorization rank must be in "
+                f"[3, {_MAX_FACTOR_RANK}]"
+            )
+    else:
+        raise RecurrenceColorCodecError(
+            f"unknown color-contraction factorization {factorization.kind!r}"
+        )
+    subgroup_order = 1 << rank
+    cosets = tuple(
+        tuple(_checked_u32("factorization local group ID", value) for value in coset)
+        for coset in factorization.cosets
+    )
+    if not cosets or any(len(coset) != subgroup_order for coset in cosets):
+        raise RecurrenceColorCodecError(
+            "factorization coset sizes are inconsistent with its rank"
+        )
+    flattened = tuple(value for coset in cosets for value in coset)
+    if len(flattened) != local_group_count:
+        raise RecurrenceColorCodecError(
+            "factorization cosets do not cover every local group"
+        )
+    if sorted(flattened) != list(range(local_group_count)):
+        raise RecurrenceColorCodecError(
+            "factorization cosets are not a partition of local groups"
+        )
+    _validate_walsh_invariance(cosets, entries)
+    return factor_kind, rank, cosets
+
+
+def _encode_symmetric_group_convolution(
+    block: SymmetricGroupColorContractionBlock,
+    *,
+    local_group_count: int,
+    entries: Sequence[ColorContractionTemplateEntry],
+) -> tuple[int, int, tuple[tuple[int, ...], ...]]:
+    """Validate and encode canonical ``S_m`` convolution-kernel storage.
+
+    For every channel pair ``c <= d`` and relative permutation ``r``, the
+    fixed-width entry IDs are ``channel[c][identity]`` and ``channel[d][r]``.
+    Kernel rows precede ordinary upper-triangle rows touching the consecutive
+    residual suffix.  Zero kernel and residual coefficients remain explicit so
+    the payload authenticates the complete convolution/direct decomposition.
+    """
+
+    degree = _checked_u32("symmetric-group degree", block.degree)
+    if degree < 2 or degree > _MAX_SYMMETRIC_GROUP_DEGREE:
+        raise RecurrenceColorCodecError(
+            "symmetric-group convolution degree must be in "
+            f"[2, {_MAX_SYMMETRIC_GROUP_DEGREE}]"
+        )
+    group_order = math.factorial(degree)
+    channels = tuple(
+        tuple(
+            _checked_u32("symmetric-group channel local group ID", value)
+            for value in channel
+        )
+        for channel in block.channel_cosets
+    )
+    if not channels:
+        raise RecurrenceColorCodecError(
+            "symmetric-group convolution requires at least one complete channel"
+        )
+    eligible_group_count = _checked_product(
+        "symmetric-group eligible group count", len(channels), group_order
+    )
+    if eligible_group_count > local_group_count:
+        raise RecurrenceColorCodecError(
+            "symmetric-group channels exceed the local group domain"
+        )
+    flattened_channels = tuple(value for channel in channels for value in channel)
+    if flattened_channels != tuple(range(eligible_group_count)):
+        raise RecurrenceColorCodecError(
+            "symmetric-group channels are not canonical channel-major/"
+            "permutation-major local indices"
+        )
+    if tuple(block.residual_local_group_indices) != tuple(
+        range(eligible_group_count, local_group_count)
+    ):
+        raise RecurrenceColorCodecError(
+            "symmetric-group residual groups are not the consecutive local suffix"
+        )
+
+    kernel_entry_count = _checked_product(
+        "symmetric-group kernel entry count",
+        len(channels) * (len(channels) + 1) // 2,
+        group_order,
+    )
+    if kernel_entry_count != len(block.kernel_entries):
+        raise RecurrenceColorCodecError(
+            "symmetric-group kernel rows do not cover every channel pair"
+        )
+    if tuple(entries[:kernel_entry_count]) != block.kernel_entries:
+        raise RecurrenceColorCodecError(
+            "symmetric-group kernel rows are not the leading entry section"
+        )
+    offset = 0
+    for left_channel, left_coset in enumerate(channels):
+        for right_channel in range(left_channel, len(channels)):
+            right_coset = channels[right_channel]
+            symmetry = 1.0 if left_channel == right_channel else 2.0
+            for relative_index in range(group_order):
+                entry = entries[offset]
+                if (
+                    _entry_left(entry) != left_coset[0]
+                    or _entry_right(entry) != right_coset[relative_index]
+                    or entry.symmetry_factor != symmetry
+                ):
+                    raise RecurrenceColorCodecError(
+                        "symmetric-group kernel rows are not canonical "
+                        "(channel, channel, relative-permutation) records"
+                    )
+                offset += 1
+            if left_channel == right_channel:
+                kernel = block.kernel_exact_weights[offset - group_order : offset]
+                for relative_index, exact in enumerate(kernel):
+                    inverse_index = _inverse_lexicographic_permutation_index(
+                        degree, relative_index
+                    )
+                    if exact != kernel[inverse_index]:
+                        raise RecurrenceColorCodecError(
+                            "symmetric-group diagonal kernel violates inverse "
+                            "Hermiticity"
+                        )
+
+    residual_entries = tuple(entries[kernel_entry_count:])
+    if residual_entries != block.residual_entries:
+        raise RecurrenceColorCodecError(
+            "symmetric-group residual rows are not the trailing entry section"
+        )
+    residual_pairs = tuple(
+        (_entry_left(entry), _entry_right(entry)) for entry in residual_entries
+    )
+    expected_residual_pairs = (
+        tuple(
+            (left, right)
+            for left in range(local_group_count)
+            for right in range(left, local_group_count)
+            if right >= eligible_group_count
+        )
+        if block.residual_local_group_indices
+        else ()
+    )
+    if residual_pairs != expected_residual_pairs:
+        raise RecurrenceColorCodecError(
+            "symmetric-group residual rows do not exhaust the canonical pairs "
+            "touching the residual suffix"
+        )
+    for entry in residual_entries:
+        if entry.weight_im != 0.0:
+            raise RecurrenceColorCodecError(
+                "symmetric-group residual row contains a complex coefficient"
+            )
+        expected_symmetry = 1.0 if _entry_left(entry) == _entry_right(entry) else 2.0
+        if entry.symmetry_factor != expected_symmetry:
+            raise RecurrenceColorCodecError(
+                "symmetric-group residual row has a noncanonical symmetry factor"
+            )
+    return _FACTOR_SYMMETRIC_GROUP_FOURIER, degree, channels
+
+
+def _symmetric_group_exact_coefficients(
+    block: SymmetricGroupColorContractionBlock,
+) -> tuple[ExactComplexRationalV1, ...]:
+    entries = (*block.kernel_entries, *block.residual_entries)
+    exact_weights = (*block.kernel_exact_weights, *block.residual_exact_weights)
+    result = []
+    for entry, exact in zip(entries, exact_weights, strict=True):
+        symmetry = int(entry.symmetry_factor)
+        if float(symmetry) != entry.symmetry_factor or symmetry not in {1, 2}:
+            raise RecurrenceColorCodecError(
+                "symmetric-group entry has a noncanonical symmetry factor"
+            )
+        folded = exact * symmetry
+        result.append(
+            ExactComplexRationalV1(
+                real_numerator=folded.numerator,
+                real_denominator=folded.denominator,
+            )
+        )
+    return tuple(result)
+
+
+def _inverse_lexicographic_permutation_index(degree: int, index: int) -> int:
+    """Return the lexicographic rank of a ranked permutation's inverse."""
+
+    remaining = list(range(degree))
+    permutation: list[int] = []
+    rank = index
+    for width in range(degree, 0, -1):
+        stride = math.factorial(width - 1)
+        quotient, rank = divmod(rank, stride)
+        permutation.append(remaining.pop(quotient))
+    inverse = [0] * degree
+    for position, value in enumerate(permutation):
+        inverse[value] = position
+    remaining = list(range(degree))
+    inverse_rank = 0
+    for position, value in enumerate(inverse):
+        offset = remaining.index(value)
+        inverse_rank += offset * math.factorial(degree - position - 1)
+        remaining.pop(offset)
+    return inverse_rank
+
+
+def _validate_walsh_invariance(
+    cosets: Sequence[Sequence[int]],
+    entries: Sequence[ColorContractionTemplateEntry],
+) -> None:
+    matrix: dict[tuple[int, int], float] = {}
+    for index, entry in enumerate(entries):
+        if entry.weight_im != 0.0:
+            raise RecurrenceColorCodecError(
+                "factorized color contraction requires real weights"
+            )
+        left = entry.left_group_index
+        right = entry.right_group_index
+        coefficient = float(entry.symmetry_factor) * float(entry.weight_re)
+        if left != right:
+            coefficient *= 0.5
+        if not math.isfinite(coefficient):
+            raise RecurrenceColorCodecError(
+                f"factorized entry {index} has a non-finite matrix coefficient"
+            )
+        matrix[(left, right)] = coefficient
+
+    def value(left: int, right: int) -> float:
+        return matrix.get((min(left, right), max(left, right)), 0.0)
+
+    subgroup_order = len(cosets[0])
+    for left_coset in cosets:
+        for right_coset in cosets:
+            for left_index in range(subgroup_order):
+                for right_index in range(subgroup_order):
+                    if value(left_coset[left_index], right_coset[right_index]) != value(
+                        left_coset[0],
+                        right_coset[left_index ^ right_index],
+                    ):
+                        raise RecurrenceColorCodecError(
+                            "factorization cosets are inconsistent with the "
+                            "canonical color matrix"
+                        )
+
+
+def _checked_u32(label: str, value: int) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise RecurrenceColorCodecError(f"{label} must be an integer")
+    if value < 0 or value > 0xFFFF_FFFF:
+        raise RecurrenceColorCodecError(f"{label} exceeds the u32 domain")
+    return value
+
+
+def _checked_u64(label: str, value: int) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise RecurrenceColorCodecError(f"{label} must be an integer")
+    if value < 0 or value > 0xFFFF_FFFF_FFFF_FFFF:
+        raise RecurrenceColorCodecError(f"{label} exceeds the u64 domain")
+    return value
+
+
+def _checked_product(label: str, left: int, right: int) -> int:
+    result = left * right
+    return _checked_u64(label, result)
+
+
+def _checked_payload_size(
+    *,
+    entry_count: int,
+    exact_factor_count: int,
+    group_count: int,
+    sector_count: int,
+    coset_index_count: int,
+) -> int:
+    size = (
+        entry_count * _ENTRY.size
+        + exact_factor_count * _EXACT_FACTOR_BYTES
+        + 2 * group_count * _U32.size
+        + 2 * group_count * _U32.size
+        + sector_count * _U32.size
+        + coset_index_count * _U32.size
+    )
+    return _checked_u64("recurrence color payload byte count", size)
+
+
+def _pack_exact_factor(
+    output: bytearray,
+    offset: int,
+    factor: ExactComplexRationalV1,
+) -> int:
+    for value in factor.canonical_key:
+        if value < -(1 << 127) or value >= 1 << 127:
+            raise RecurrenceColorCodecError(
+                "exact color coefficient exceeds the signed i128 domain"
+            )
+        output[offset : offset + 16] = value.to_bytes(
+            16,
+            byteorder="little",
+            signed=True,
+        )
+        offset += 16
+    return offset
+
+
+def recurrence_color_contraction_digest(payload: bytes) -> str:
+    """Return the caller-owned deterministic SHA-256 payload digest."""
+
+    return sha256(payload).hexdigest()
+
+
+__all__ = [
+    "RECURRENCE_COLOR_CONTRACTION_CODEC_ABI",
+    "RECURRENCE_COLOR_CONTRACTION_MAGIC",
+    "RecurrenceColorCodecError",
+    "encode_recurrence_color_contraction",
+    "recurrence_color_contraction_digest",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/recurrence_columnar.py b/pyamplicol/src/pyamplicol/generation/recurrence_columnar.py
new file mode 100644
index 0000000000..cb22c6010f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/recurrence_columnar.py
@@ -0,0 +1,2795 @@
+# SPDX-License-Identifier: 0BSD
+"""Columnar Python-to-Rust contract for recurrence construction.
+
+This module owns only the compact, model-generic input boundary described by
+``pyamplicol-recurrence-builder-input-v2``.  Callers provide immutable logical
+records produced after process expansion and LC colour planning.  The builder
+normalises those records into deterministic, owned NumPy columns; it neither
+imports nor constructs the process ``GenericDAG`` representation.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any, Final, Literal
+
+import numpy as np
+
+from .recurrence_fermion_pairing import FermionPairingCatalogV1
+
+RECURRENCE_BUILDER_INPUT_ABI: Final = "pyamplicol-recurrence-builder-input-v2"
+RECURRENCE_BUILDER_INPUT_SCHEMA_VERSION: Final = 1
+MISSING_U32: Final = (1 << 32) - 1
+_DYNAMIC_UNION_SOURCE_SPIN_STATE: Final = -(1 << 31)
+
+RecurrenceLCFlowLayout = Literal[
+    "topology-replay",
+    "all-flow-union",
+    "contracted-color-union",
+]
+LCColorSectorKind = Literal["singlet", "open-lines", "single-trace"]
+
+_LAYOUT_CODES: Final = {
+    "topology-replay": 0,
+    "all-flow-union": 1,
+    "contracted-color-union": 2,
+}
+_SECTOR_KIND_CODES: Final = {"singlet": 0, "open-lines": 1, "single-trace": 2}
+_REQUIRED_HEADER_DIGEST_ROLES: Final = frozenset(
+    {"process", "model-catalog", "prepared-catalog", "color-plan"}
+)
+
+_U8 = np.dtype("u1")
+_U32 = np.dtype("<u4")
+_U64 = np.dtype("<u8")
+_I32 = np.dtype("<i4")
+_ALLOWED_DTYPES = frozenset(dtype.str for dtype in (_U8, _U32, _U64, _I32))
+
+
+class RecurrenceColumnarInputError(ValueError):
+    """A logical record or primitive recurrence column violates ABI v2."""
+
+
+@dataclass(frozen=True, slots=True)
+class ExactComplexRationalV1:
+    """Canonical exact complex rational used by recurrence proofs."""
+
+    real_numerator: int
+    real_denominator: int = 1
+    imag_numerator: int = 0
+    imag_denominator: int = 1
+
+    def __post_init__(self) -> None:
+        _validate_fraction(
+            self.real_numerator,
+            self.real_denominator,
+            "real recurrence factor",
+        )
+        _validate_fraction(
+            self.imag_numerator,
+            self.imag_denominator,
+            "imaginary recurrence factor",
+        )
+
+    @property
+    def canonical_key(self) -> tuple[int, int, int, int]:
+        return (
+            self.real_numerator,
+            self.real_denominator,
+            self.imag_numerator,
+            self.imag_denominator,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceSemanticDigestV1:
+    """One named semantic SHA-256 bound by the builder header."""
+
+    role: str
+    digest: str
+
+    def __post_init__(self) -> None:
+        _nonempty_text(self.role, "semantic digest role")
+        _sha256_bytes(self.digest, f"semantic digest {self.role!r}")
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceSourceStateV1:
+    """One public source state retained for an external leg."""
+
+    state_index: int
+    public_helicity: int
+    chirality: int
+    spin_state: int
+    current_state_template_id: int
+    source_template_id: int
+    momentum_sign: int = 1
+    crossing_phase: ExactComplexRationalV1 = field(
+        default_factory=lambda: ExactComplexRationalV1(1)
+    )
+
+    def __post_init__(self) -> None:
+        _checked_u32(self.state_index, "source-state index")
+        _checked_i32(self.public_helicity, "public source helicity")
+        _checked_i32(self.chirality, "source chirality")
+        _checked_concrete_spin_state(self.spin_state, "source spin state")
+        _checked_u32(
+            self.current_state_template_id,
+            "source current-state template ID",
+        )
+        _checked_u32(self.source_template_id, "source template ID")
+        if self.momentum_sign not in {-1, 1}:
+            raise RecurrenceColumnarInputError("source momentum sign must be -1 or 1")
+        if not isinstance(self.crossing_phase, ExactComplexRationalV1):
+            raise RecurrenceColumnarInputError(
+                "source crossing phase must be an exact complex rational"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceExternalLegV1:
+    """External process leg and complete generated source-state coverage."""
+
+    source_slot: int
+    public_label: int
+    physical_pdg: int
+    outgoing_pdg: int
+    is_initial: bool
+    is_fermionic: bool
+    source_states: tuple[RecurrenceSourceStateV1, ...]
+    momentum_mask: int
+    support_mask: int
+
+    def __post_init__(self) -> None:
+        _checked_u32(self.source_slot, "external source slot")
+        _checked_u32(self.public_label, "external public label")
+        _checked_i32(self.physical_pdg, "physical PDG")
+        _checked_i32(self.outgoing_pdg, "outgoing PDG")
+        if type(self.is_initial) is not bool:
+            raise RecurrenceColumnarInputError(
+                "external initial-state marker must be boolean"
+            )
+        if type(self.is_fermionic) is not bool:
+            raise RecurrenceColumnarInputError(
+                "external fermionic-state marker must be boolean"
+            )
+        _validate_nonnegative_mask(self.momentum_mask, "external momentum mask")
+        _validate_nonnegative_mask(self.support_mask, "external support mask")
+        if not self.source_states:
+            raise RecurrenceColumnarInputError(
+                "every external leg must retain at least one source state"
+            )
+        indices = tuple(state.state_index for state in self.source_states)
+        if indices != tuple(range(len(indices))):
+            raise RecurrenceColumnarInputError(
+                "source-state indices must be dense and ordered from zero"
+            )
+        helicities = tuple(state.public_helicity for state in self.source_states)
+        if len(set(helicities)) != len(helicities):
+            raise RecurrenceColumnarInputError(
+                "one external leg cannot expose a public helicity more than once"
+            )
+        source_template_ids = tuple(
+            state.source_template_id for state in self.source_states
+        )
+        if len(set(source_template_ids)) != len(source_template_ids):
+            raise RecurrenceColumnarInputError(
+                "one external leg cannot expose a source template more than once"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceLCOpenStringV1:
+    """One ordered open fundamental colour string, using source slots."""
+
+    fundamental_source_slot: int
+    antifundamental_source_slot: int
+    adjoint_source_slots: tuple[int, ...] = ()
+    singlet_source_slots: tuple[int, ...] = ()
+
+    def __post_init__(self) -> None:
+        _checked_u32(self.fundamental_source_slot, "fundamental source slot")
+        _checked_u32(
+            self.antifundamental_source_slot,
+            "antifundamental source slot",
+        )
+        _validate_u32_sequence(self.adjoint_source_slots, "adjoint source slots")
+        _validate_u32_sequence(self.singlet_source_slots, "singlet source slots")
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrencePhysicalLCSectorV1:
+    """One physical LC sector before recurrence state construction."""
+
+    sector_id: int
+    public_id: str
+    kind: LCColorSectorKind
+    closure_source_slot: int
+    closure_proof_algorithm: str
+    closure_proof_digest: str
+    open_strings: tuple[RecurrenceLCOpenStringV1, ...] = ()
+    trace_source_slots: tuple[int, ...] = ()
+    singlet_source_slots: tuple[int, ...] = ()
+    word_source_slots: tuple[int, ...] = ()
+    support_mask: int = 0
+
+    def __post_init__(self) -> None:
+        _checked_u32(self.sector_id, "physical LC sector ID")
+        _nonempty_text(self.public_id, "physical LC sector public ID")
+        if self.kind not in _SECTOR_KIND_CODES:
+            raise RecurrenceColumnarInputError(
+                f"unsupported physical LC sector kind {self.kind!r}"
+            )
+        _checked_u32(self.closure_source_slot, "LC closure source slot")
+        _nonempty_text(self.closure_proof_algorithm, "LC closure proof algorithm")
+        _sha256_bytes(self.closure_proof_digest, "LC closure proof digest")
+        _validate_u32_sequence(self.trace_source_slots, "trace source slots")
+        _validate_u32_sequence(self.singlet_source_slots, "singlet source slots")
+        _validate_u32_sequence(self.word_source_slots, "colour-word source slots")
+        _validate_nonnegative_mask(self.support_mask, "LC sector support mask")
+        if self.kind == "open-lines" and not self.open_strings:
+            raise RecurrenceColumnarInputError(
+                "an open-lines LC sector must contain at least one open string"
+            )
+        if self.kind != "open-lines" and self.open_strings:
+            raise RecurrenceColumnarInputError(
+                f"an LC sector of kind {self.kind!r} cannot contain open strings"
+            )
+        if self.kind == "single-trace" and not self.trace_source_slots:
+            raise RecurrenceColumnarInputError(
+                "a single-trace LC sector must contain a trace word"
+            )
+        if self.kind != "single-trace" and self.trace_source_slots:
+            raise RecurrenceColumnarInputError(
+                f"an LC sector of kind {self.kind!r} cannot contain a trace word"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrencePublicLCFlowV1:
+    """One runtime-visible flow mapped onto a construction sector.
+
+    ``source_slot_permutation`` is a gather mapping: construction slot ``i``
+    receives the public-flow source at ``source_slot_permutation[i]``.
+    """
+
+    flow_id: int
+    public_id: str
+    construction_sector_id: int
+    word_source_slots: tuple[int, ...]
+    source_slot_permutation: tuple[int, ...]
+    reduction_weight: ExactComplexRationalV1 = field(
+        default_factory=lambda: ExactComplexRationalV1(1)
+    )
+
+    def __post_init__(self) -> None:
+        _checked_u32(self.flow_id, "public LC flow ID")
+        _nonempty_text(self.public_id, "public LC flow identifier")
+        _checked_u32(self.construction_sector_id, "construction LC sector ID")
+        _validate_u32_sequence(self.word_source_slots, "public LC flow word")
+        _validate_u32_sequence(
+            self.source_slot_permutation,
+            "public LC flow source-slot permutation",
+        )
+        if not isinstance(self.reduction_weight, ExactComplexRationalV1):
+            raise RecurrenceColumnarInputError(
+                "public LC flow weight must be an exact complex rational"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceReplayTargetV1:
+    """Exact mapping from a replay representative to one physical sector.
+
+    Both permutations are gather mappings: representative slot ``i`` receives
+    target slot ``permutation[i]``.  They are equal in recurrence ABI v2; both
+    names are retained to keep the proof and runtime contracts explicit.
+    """
+
+    sector_id: int
+    external_permutation: tuple[int, ...]
+    source_slot_permutation: tuple[int, ...]
+    amplitude_phase: ExactComplexRationalV1 = field(
+        default_factory=lambda: ExactComplexRationalV1(1)
+    )
+    fermion_sign: int = 1
+
+    def __post_init__(self) -> None:
+        _checked_u32(self.sector_id, "replay target sector ID")
+        _validate_u32_sequence(
+            self.external_permutation,
+            "replay external permutation",
+        )
+        _validate_u32_sequence(
+            self.source_slot_permutation,
+            "replay source-slot permutation",
+        )
+        if not isinstance(self.amplitude_phase, ExactComplexRationalV1):
+            raise RecurrenceColumnarInputError(
+                "replay amplitude phase must be an exact complex rational"
+            )
+        if self.fermion_sign not in {-1, 1}:
+            raise RecurrenceColumnarInputError("replay fermion sign must be -1 or 1")
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceReplayPartitionV1:
+    """One exactly certified physical-flow replay partition."""
+
+    representative_sector_id: int
+    materialized_sector_id: int
+    proof_algorithm: str
+    proof_digest: str
+    targets: tuple[RecurrenceReplayTargetV1, ...]
+
+    def __post_init__(self) -> None:
+        _checked_u32(self.representative_sector_id, "replay representative sector")
+        _checked_u32(self.materialized_sector_id, "replay materialized sector")
+        _nonempty_text(self.proof_algorithm, "replay proof algorithm")
+        _sha256_bytes(self.proof_digest, "replay proof digest")
+        if not self.targets:
+            raise RecurrenceColumnarInputError(
+                "a replay partition must contain at least one target"
+            )
+        target_ids = tuple(target.sector_id for target in self.targets)
+        if len(set(target_ids)) != len(target_ids):
+            raise RecurrenceColumnarInputError(
+                "a replay partition contains duplicate target sectors"
+            )
+        if self.representative_sector_id not in target_ids:
+            raise RecurrenceColumnarInputError(
+                "a replay partition must contain its representative sector"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceSelectedSourceCoverageV1:
+    """Generation-retained local source states for one external leg."""
+
+    source_slot: int
+    source_state_indices: tuple[int, ...]
+
+    def __post_init__(self) -> None:
+        _checked_u32(self.source_slot, "selected source slot")
+        _validate_u32_sequence(
+            self.source_state_indices,
+            "selected source-state indices",
+        )
+        if not self.source_state_indices:
+            raise RecurrenceColumnarInputError(
+                "selected source coverage cannot be empty"
+            )
+        if len(set(self.source_state_indices)) != len(self.source_state_indices):
+            raise RecurrenceColumnarInputError(
+                "selected source coverage contains duplicate states"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceCouplingLimitV1:
+    """Resolved inclusive bounds for one coupling-order axis."""
+
+    name: str
+    minimum: int
+    maximum: int
+
+    def __post_init__(self) -> None:
+        _nonempty_text(self.name, "coupling-order name")
+        minimum = _checked_u32(self.minimum, f"coupling-order {self.name} minimum")
+        maximum = _checked_u32(self.maximum, f"coupling-order {self.name} maximum")
+        if minimum > maximum:
+            raise RecurrenceColumnarInputError(
+                f"coupling-order {self.name!r} minimum exceeds its maximum"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceSemanticTemplateReferenceV1:
+    """Content-addressed recurrence template and optional callable binding."""
+
+    kind: str
+    template_id: int
+    semantic_digest: str
+    prepared_kernel_id: int | None = None
+
+    def __post_init__(self) -> None:
+        _nonempty_text(self.kind, "semantic-template kind")
+        _checked_u32(self.template_id, "semantic-template ID")
+        _sha256_bytes(self.semantic_digest, "semantic-template digest")
+        if self.prepared_kernel_id is not None:
+            if self.prepared_kernel_id == MISSING_U32:
+                raise RecurrenceColumnarInputError(
+                    "prepared-kernel ID reserves the u32 sentinel"
+                )
+            _checked_u32(self.prepared_kernel_id, "prepared-kernel ID")
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceNormalizationV1:
+    """Exact process normalization and its semantic convention."""
+
+    factor: ExactComplexRationalV1
+    convention: str
+    semantic_digest: str
+
+    def __post_init__(self) -> None:
+        _nonempty_text(self.convention, "normalization convention")
+        _sha256_bytes(self.semantic_digest, "normalization semantic digest")
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceParameterProjectionV1:
+    """Map one public runtime parameter slot to a prepared-model slot."""
+
+    runtime_slot: int
+    runtime_name: str
+    parameter_template_id: int
+    prepared_parameter_id: int | None
+    component: int = 0
+
+    def __post_init__(self) -> None:
+        _checked_u32(self.runtime_slot, "runtime parameter slot")
+        _nonempty_text(self.runtime_name, "runtime parameter name")
+        _checked_u32(self.parameter_template_id, "parameter-template ID")
+        if self.prepared_parameter_id is not None:
+            if self.prepared_parameter_id == MISSING_U32:
+                raise RecurrenceColumnarInputError(
+                    "prepared parameter ID reserves the u32 sentinel"
+                )
+            _checked_u32(self.prepared_parameter_id, "prepared parameter ID")
+        _checked_u32(self.component, "parameter component")
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceBuilderLogicalInputV1:
+    """Compact logical records accepted by the recurrence column encoder."""
+
+    process_id: str
+    layout: RecurrenceLCFlowLayout
+    semantic_digests: tuple[RecurrenceSemanticDigestV1, ...]
+    external_legs: tuple[RecurrenceExternalLegV1, ...]
+    physical_sectors: tuple[RecurrencePhysicalLCSectorV1, ...]
+    public_flows: tuple[RecurrencePublicLCFlowV1, ...]
+    semantic_template_references: tuple[RecurrenceSemanticTemplateReferenceV1, ...]
+    normalization: RecurrenceNormalizationV1
+    fermion_pairing_catalog: FermionPairingCatalogV1 | None = None
+    replay_partitions: tuple[RecurrenceReplayPartitionV1, ...] = ()
+    selected_public_flow_ids: tuple[int, ...] | None = None
+    selected_source_coverage: tuple[RecurrenceSelectedSourceCoverageV1, ...] | None = (
+        None
+    )
+    coupling_limits: tuple[RecurrenceCouplingLimitV1, ...] = ()
+    parameter_projection: tuple[RecurrenceParameterProjectionV1, ...] = ()
+    process_support_mask: int = 0
+
+    def __post_init__(self) -> None:
+        _nonempty_text(self.process_id, "recurrence process ID")
+        if self.layout not in _LAYOUT_CODES:
+            raise RecurrenceColumnarInputError(
+                f"unsupported recurrence LC flow layout {self.layout!r}"
+            )
+        _validate_nonnegative_mask(self.process_support_mask, "process support mask")
+        if self.fermion_pairing_catalog is not None and not isinstance(
+            self.fermion_pairing_catalog,
+            FermionPairingCatalogV1,
+        ):
+            raise TypeError(
+                "recurrence fermion pairing must be FermionPairingCatalogV1"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceColumn:
+    """One owned, immutable primitive recurrence column."""
+
+    name: str
+    values: np.ndarray[Any, Any]
+
+    def __post_init__(self) -> None:
+        _nonempty_text(self.name, "column name")
+        values = self.values
+        if not isinstance(values, np.ndarray):
+            raise TypeError(f"column {self.name!r} must be a NumPy array")
+        if values.ndim < 1:
+            raise RecurrenceColumnarInputError(
+                f"column {self.name!r} must have a row dimension"
+            )
+        if not values.flags.c_contiguous:
+            raise RecurrenceColumnarInputError(
+                f"column {self.name!r} must be C-contiguous"
+            )
+        if not values.flags.owndata:
+            raise RecurrenceColumnarInputError(
+                f"column {self.name!r} must own its storage"
+            )
+        if values.flags.writeable:
+            raise RecurrenceColumnarInputError(
+                f"column {self.name!r} must be read-only"
+            )
+        if values.dtype.str not in _ALLOWED_DTYPES:
+            raise RecurrenceColumnarInputError(
+                f"column {self.name!r} has unsupported or non-little-endian "
+                f"dtype {values.dtype.str!r}"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceColumnarTable:
+    """One deterministic structure-of-arrays recurrence table."""
+
+    name: str
+    row_count: int
+    columns: tuple[RecurrenceColumn, ...]
+
+    def __post_init__(self) -> None:
+        _nonempty_text(self.name, "table name")
+        _checked_u64(self.row_count, f"{self.name}.row_count")
+        names = tuple(column.name for column in self.columns)
+        if len(set(names)) != len(names):
+            raise RecurrenceColumnarInputError(
+                f"table {self.name!r} contains duplicate column names"
+            )
+        for column in self.columns:
+            if len(column.values) != self.row_count:
+                raise RecurrenceColumnarInputError(
+                    f"table {self.name!r} column {column.name!r} has "
+                    f"{len(column.values)} rows, expected {self.row_count}"
+                )
+
+    def column(self, name: str) -> np.ndarray[Any, Any]:
+        for column in self.columns:
+            if column.name == name:
+                return column.values
+        raise KeyError(f"table {self.name!r} has no column {name!r}")
+
+
+_ColumnSpec = tuple[str, tuple[int, ...]]
+
+_TABLE_SCHEMAS: Final[dict[str, tuple[_ColumnSpec, ...]]] = {
+    "bitset_ranges": (
+        ("id", ()),
+        ("start", ()),
+        ("count", ()),
+        ("bit_count", ()),
+    ),
+    "bitset_words": (("value", ()),),
+    "coupling_limits": (
+        ("name_string_id", ()),
+        ("minimum", ()),
+        ("maximum", ()),
+    ),
+    "digest_catalog": (("id", ()), ("value", (32,))),
+    "exact_factors": (
+        ("id", ()),
+        ("real_numerator_string_id", ()),
+        ("real_denominator_string_id", ()),
+        ("imag_numerator_string_id", ()),
+        ("imag_denominator_string_id", ()),
+    ),
+    "external_legs": (
+        ("source_slot", ()),
+        ("public_label", ()),
+        ("physical_pdg", ()),
+        ("outgoing_pdg", ()),
+        ("is_initial", ()),
+        ("is_fermionic", ()),
+        ("source_state_start", ()),
+        ("source_state_count", ()),
+        ("momentum_mask_id", ()),
+        ("support_mask_id", ()),
+    ),
+    "header": (
+        ("schema_version", ()),
+        ("abi_string_id", ()),
+        ("process_id_string_id", ()),
+        ("layout", ()),
+        ("selected_flow_mode", ()),
+        ("selected_source_mode", ()),
+        ("external_leg_count", ()),
+        ("physical_sector_count", ()),
+        ("public_flow_count", ()),
+        ("replay_partition_count", ()),
+        ("coupling_limit_count", ()),
+        ("parameter_projection_count", ()),
+        ("process_support_mask_id", ()),
+    ),
+    "header_digests": (("role_string_id", ()), ("digest_id", ())),
+    "lc_open_strings": (
+        ("sector_id", ()),
+        ("ordinal", ()),
+        ("fundamental_source_slot", ()),
+        ("antifundamental_source_slot", ()),
+        ("adjoint_sequence_id", ()),
+        ("singlet_sequence_id", ()),
+    ),
+    "normalization": (
+        ("factor_id", ()),
+        ("convention_string_id", ()),
+        ("semantic_digest_id", ()),
+    ),
+    "parameter_projection": (
+        ("runtime_slot", ()),
+        ("runtime_name_string_id", ()),
+        ("parameter_template_id", ()),
+        ("prepared_parameter_id", ()),
+        ("component", ()),
+    ),
+    "physical_lc_sectors": (
+        ("sector_id", ()),
+        ("public_id_string_id", ()),
+        ("kind", ()),
+        ("closure_source_slot", ()),
+        ("closure_proof_algorithm_string_id", ()),
+        ("closure_proof_digest_id", ()),
+        ("open_string_start", ()),
+        ("open_string_count", ()),
+        ("trace_sequence_id", ()),
+        ("singlet_sequence_id", ()),
+        ("word_sequence_id", ()),
+        ("support_mask_id", ()),
+    ),
+    "public_lc_flows": (
+        ("flow_id", ()),
+        ("public_id_string_id", ()),
+        ("construction_sector_id", ()),
+        ("word_sequence_id", ()),
+        ("source_slot_permutation_sequence_id", ()),
+        ("reduction_weight_factor_id", ()),
+    ),
+    "replay_partitions": (
+        ("partition_id", ()),
+        ("representative_sector_id", ()),
+        ("materialized_sector_id", ()),
+        ("target_start", ()),
+        ("target_count", ()),
+        ("proof_algorithm_string_id", ()),
+        ("proof_digest_id", ()),
+    ),
+    "replay_targets": (
+        ("partition_id", ()),
+        ("sector_id", ()),
+        ("external_permutation_sequence_id", ()),
+        ("source_slot_permutation_sequence_id", ()),
+        ("amplitude_phase_factor_id", ()),
+        ("fermion_sign", ()),
+    ),
+    "selected_public_flow_coverage": (("flow_id", ()),),
+    "selected_source_coverage": (
+        ("source_slot", ()),
+        ("source_state_index", ()),
+    ),
+    "semantic_template_references": (
+        ("kind_string_id", ()),
+        ("template_id", ()),
+        ("semantic_digest_id", ()),
+        ("prepared_kernel_id", ()),
+    ),
+    "source_states": (
+        ("source_slot", ()),
+        ("state_index", ()),
+        ("public_helicity", ()),
+        ("chirality", ()),
+        ("spin_state", ()),
+        ("current_state_template_id", ()),
+        ("source_template_id", ()),
+        ("momentum_sign", ()),
+        ("crossing_phase_factor_id", ()),
+    ),
+    "string_bytes": (("value", ()),),
+    "string_ranges": (("start", ()), ("count", ())),
+    "u32_sequence_ranges": (("start", ()), ("count", ())),
+    "u32_sequence_values": (("value", ()),),
+}
+
+_U8_COLUMN_KEYS: Final = frozenset(
+    {
+        ("digest_catalog", "value"),
+        ("header", "layout"),
+        ("header", "selected_flow_mode"),
+        ("header", "selected_source_mode"),
+        ("external_legs", "is_initial"),
+        ("external_legs", "is_fermionic"),
+        ("physical_lc_sectors", "kind"),
+        ("string_bytes", "value"),
+    }
+)
+_U64_COLUMN_KEYS: Final = frozenset(
+    {
+        ("bitset_ranges", "start"),
+        ("bitset_ranges", "count"),
+        ("bitset_ranges", "bit_count"),
+        ("bitset_words", "value"),
+        ("external_legs", "source_state_start"),
+        ("external_legs", "source_state_count"),
+        ("physical_lc_sectors", "open_string_start"),
+        ("physical_lc_sectors", "open_string_count"),
+        ("replay_partitions", "target_start"),
+        ("replay_partitions", "target_count"),
+        ("string_ranges", "start"),
+        ("string_ranges", "count"),
+        ("u32_sequence_ranges", "start"),
+        ("u32_sequence_ranges", "count"),
+    }
+)
+_I32_COLUMN_KEYS: Final = frozenset(
+    {
+        ("external_legs", "physical_pdg"),
+        ("external_legs", "outgoing_pdg"),
+        ("replay_targets", "fermion_sign"),
+        ("source_states", "public_helicity"),
+        ("source_states", "chirality"),
+        ("source_states", "spin_state"),
+        ("source_states", "momentum_sign"),
+    }
+)
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceBuilderInputV1:
+    """Validated immutable payload passed to the future Rust builder."""
+
+    abi: str
+    tables: tuple[RecurrenceColumnarTable, ...]
+    fermion_pairing_tables: tuple[RecurrenceColumnarTable, ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.abi != RECURRENCE_BUILDER_INPUT_ABI:
+            raise RecurrenceColumnarInputError(
+                f"unsupported recurrence builder input ABI {self.abi!r}"
+            )
+        names = tuple(table.name for table in self.tables)
+        expected_names = tuple(sorted(_TABLE_SCHEMAS))
+        if names != expected_names:
+            raise RecurrenceColumnarInputError(
+                "recurrence columnar tables must match the sorted v2 inventory; "
+                f"got {names!r}"
+            )
+        self._validate_schemas()
+        self._validate_catalogs()
+        self._validate_references()
+        self._validate_fermion_pairing()
+
+    def table(self, name: str) -> RecurrenceColumnarTable:
+        for table in self.tables:
+            if table.name == name:
+                return table
+        raise KeyError(f"recurrence builder input has no table {name!r}")
+
+    @property
+    def layout(self) -> RecurrenceLCFlowLayout:
+        code = int(self.table("header").column("layout")[0])
+        for layout, candidate in _LAYOUT_CODES.items():
+            if candidate == code:
+                return layout
+        raise RecurrenceColumnarInputError(
+            f"recurrence header contains unknown layout code {code}"
+        )
+
+    def fermion_pairing_table(self, name: str) -> RecurrenceColumnarTable:
+        """Return one table from the private process-owned pairing payload."""
+
+        for table in self.fermion_pairing_tables:
+            if table.name == name:
+                return table
+        raise KeyError(f"recurrence fermion pairing has no table {name!r}")
+
+    @property
+    def fermion_pairing_digest(self) -> str | None:
+        """Digest the exact private table representation for a future decoder."""
+
+        if not self.fermion_pairing_tables:
+            return None
+        from .recurrence_pairing_columnar import _PAIRING_COLUMNAR_ABI
+
+        digest = hashlib.sha256()
+        _hash_text(digest, _PAIRING_COLUMNAR_ABI)
+        _hash_columnar_tables(digest, self.fermion_pairing_tables)
+        return digest.hexdigest()
+
+    @property
+    def canonical_digest(self) -> str:
+        """SHA-256 over ABI, table schemas, shapes, and canonical bytes."""
+
+        digest = hashlib.sha256()
+        _hash_text(digest, self.abi)
+        _hash_columnar_tables(digest, self.tables)
+        return digest.hexdigest()
+
+    @property
+    def digest(self) -> str:
+        """Compatibility spelling for consumers passing the digest to Rust."""
+
+        return self.canonical_digest
+
+    def require_digest(self, expected: str) -> None:
+        """Fail before GIL release when a supplied input digest is stale."""
+
+        _sha256_bytes(expected, "expected recurrence input digest")
+        if self.canonical_digest != expected:
+            raise RecurrenceColumnarInputError(
+                "recurrence builder input canonical digest does not match"
+            )
+
+    def _validate_schemas(self) -> None:
+        for table in self.tables:
+            expected = _TABLE_SCHEMAS[table.name]
+            names = tuple(column.name for column in table.columns)
+            expected_names = tuple(name for name, _shape in expected)
+            if names != expected_names:
+                raise RecurrenceColumnarInputError(
+                    f"table {table.name!r} columns do not match ABI v1: {names!r}"
+                )
+            for column, (_name, tail_shape) in zip(
+                table.columns,
+                expected,
+                strict=True,
+            ):
+                expected_dtype = _column_dtype(table.name, column.name)
+                if column.values.dtype.str != expected_dtype.str:
+                    raise RecurrenceColumnarInputError(
+                        f"table {table.name!r} column {column.name!r} has dtype "
+                        f"{column.values.dtype.str!r}, expected "
+                        f"{expected_dtype.str!r}"
+                    )
+                if column.values.shape[1:] != tail_shape:
+                    raise RecurrenceColumnarInputError(
+                        f"table {table.name!r} column {column.name!r} has tail "
+                        f"shape {column.values.shape[1:]!r}, expected {tail_shape!r}"
+                    )
+
+    def _validate_catalogs(self) -> None:
+        strings = _decode_flat_strings(
+            self.table("string_ranges"),
+            self.table("string_bytes"),
+        )
+        if strings != tuple(sorted(strings, key=lambda value: value.encode("utf-8"))):
+            raise RecurrenceColumnarInputError(
+                "flat string catalog is not in canonical byte order"
+            )
+        if len(set(strings)) != len(strings):
+            raise RecurrenceColumnarInputError(
+                "flat string catalog contains duplicates"
+            )
+
+        _validate_flat_ranges(
+            self.table("u32_sequence_ranges"),
+            self.table("u32_sequence_values").row_count,
+            "u32 sequence catalog",
+        )
+        _validate_flat_ranges(
+            self.table("bitset_ranges"),
+            self.table("bitset_words").row_count,
+            "bitset catalog",
+        )
+        _validate_dense_ids(self.table("bitset_ranges"), "id")
+        _validate_dense_ids(self.table("digest_catalog"), "id")
+        _validate_dense_ids(self.table("exact_factors"), "id")
+
+        words = self.table("bitset_words").column("value")
+        ranges = self.table("bitset_ranges")
+        for row in range(ranges.row_count):
+            start = int(ranges.column("start")[row])
+            count = int(ranges.column("count")[row])
+            if count and int(words[start + count - 1]) == 0:
+                raise RecurrenceColumnarInputError(
+                    "bitset catalog contains a noncanonical leading zero word"
+                )
+            value = sum(
+                int(words[start + offset]) << (64 * offset) for offset in range(count)
+            )
+            if value.bit_count() != int(ranges.column("bit_count")[row]):
+                raise RecurrenceColumnarInputError(
+                    "bitset catalog bit count does not match its words"
+                )
+
+    def _validate_references(self) -> None:
+        string_count = self.table("string_ranges").row_count
+        digest_count = self.table("digest_catalog").row_count
+        sequence_count = self.table("u32_sequence_ranges").row_count
+        bitset_count = self.table("bitset_ranges").row_count
+        factor_count = self.table("exact_factors").row_count
+        external_count = self.table("external_legs").row_count
+        sector_count = self.table("physical_lc_sectors").row_count
+        public_flow_count = self.table("public_lc_flows").row_count
+        partition_count = self.table("replay_partitions").row_count
+
+        _validate_dense_ids(self.table("external_legs"), "source_slot")
+        _validate_dense_ids(self.table("physical_lc_sectors"), "sector_id")
+        _validate_dense_ids(self.table("public_lc_flows"), "flow_id")
+        _validate_dense_ids(self.table("replay_partitions"), "partition_id")
+        _validate_dense_ids(self.table("parameter_projection"), "runtime_slot")
+
+        for table, columns in (
+            (self.table("header"), ("abi_string_id", "process_id_string_id")),
+            (self.table("header_digests"), ("role_string_id",)),
+            (self.table("coupling_limits"), ("name_string_id",)),
+            (
+                self.table("exact_factors"),
+                (
+                    "real_numerator_string_id",
+                    "real_denominator_string_id",
+                    "imag_numerator_string_id",
+                    "imag_denominator_string_id",
+                ),
+            ),
+            (
+                self.table("physical_lc_sectors"),
+                ("public_id_string_id", "closure_proof_algorithm_string_id"),
+            ),
+            (self.table("public_lc_flows"), ("public_id_string_id",)),
+            (self.table("replay_partitions"), ("proof_algorithm_string_id",)),
+            (self.table("semantic_template_references"), ("kind_string_id",)),
+            (self.table("normalization"), ("convention_string_id",)),
+            (self.table("parameter_projection"), ("runtime_name_string_id",)),
+        ):
+            _validate_bounded_columns(table, columns, string_count)
+
+        for table, columns in (
+            (self.table("header_digests"), ("digest_id",)),
+            (self.table("physical_lc_sectors"), ("closure_proof_digest_id",)),
+            (self.table("replay_partitions"), ("proof_digest_id",)),
+            (self.table("semantic_template_references"), ("semantic_digest_id",)),
+            (self.table("normalization"), ("semantic_digest_id",)),
+        ):
+            _validate_bounded_columns(table, columns, digest_count)
+
+        for table, columns in (
+            (
+                self.table("lc_open_strings"),
+                (
+                    "adjoint_sequence_id",
+                    "singlet_sequence_id",
+                ),
+            ),
+            (
+                self.table("physical_lc_sectors"),
+                (
+                    "trace_sequence_id",
+                    "singlet_sequence_id",
+                    "word_sequence_id",
+                ),
+            ),
+            (
+                self.table("replay_targets"),
+                (
+                    "external_permutation_sequence_id",
+                    "source_slot_permutation_sequence_id",
+                ),
+            ),
+            (
+                self.table("public_lc_flows"),
+                ("word_sequence_id", "source_slot_permutation_sequence_id"),
+            ),
+        ):
+            _validate_bounded_columns(table, columns, sequence_count)
+
+        for table, columns in (
+            (self.table("header"), ("process_support_mask_id",)),
+            (self.table("external_legs"), ("momentum_mask_id", "support_mask_id")),
+            (self.table("physical_lc_sectors"), ("support_mask_id",)),
+        ):
+            _validate_bounded_columns(table, columns, bitset_count)
+
+        _validate_bounded_columns(
+            self.table("replay_targets"),
+            ("amplitude_phase_factor_id",),
+            factor_count,
+        )
+        _validate_bounded_columns(
+            self.table("public_lc_flows"),
+            ("reduction_weight_factor_id",),
+            factor_count,
+        )
+        _validate_bounded_columns(
+            self.table("source_states"),
+            ("crossing_phase_factor_id",),
+            factor_count,
+        )
+        _validate_bounded_columns(
+            self.table("normalization"),
+            ("factor_id",),
+            factor_count,
+        )
+
+        for table, columns in (
+            (
+                self.table("lc_open_strings"),
+                (
+                    "fundamental_source_slot",
+                    "antifundamental_source_slot",
+                ),
+            ),
+            (self.table("source_states"), ("source_slot",)),
+            (self.table("selected_source_coverage"), ("source_slot",)),
+            (self.table("physical_lc_sectors"), ("closure_source_slot",)),
+        ):
+            _validate_bounded_columns(table, columns, external_count)
+
+        for table, columns in (
+            (self.table("lc_open_strings"), ("sector_id",)),
+            (
+                self.table("replay_partitions"),
+                (
+                    "representative_sector_id",
+                    "materialized_sector_id",
+                ),
+            ),
+            (self.table("replay_targets"), ("sector_id",)),
+            (self.table("public_lc_flows"), ("construction_sector_id",)),
+        ):
+            _validate_bounded_columns(table, columns, sector_count)
+        _validate_bounded_columns(
+            self.table("selected_public_flow_coverage"),
+            ("flow_id",),
+            public_flow_count,
+        )
+        _validate_bounded_columns(
+            self.table("replay_targets"),
+            ("partition_id",),
+            partition_count,
+        )
+
+        _validate_parent_ranges(
+            self.table("external_legs"),
+            "source_state_start",
+            "source_state_count",
+            self.table("source_states").row_count,
+            "external source-state",
+        )
+        _validate_parent_ranges(
+            self.table("physical_lc_sectors"),
+            "open_string_start",
+            "open_string_count",
+            self.table("lc_open_strings").row_count,
+            "LC open-string",
+        )
+        _validate_parent_ranges(
+            self.table("replay_partitions"),
+            "target_start",
+            "target_count",
+            self.table("replay_targets").row_count,
+            "replay target",
+        )
+
+        header = self.table("header")
+        if header.row_count != 1:
+            raise RecurrenceColumnarInputError("recurrence header must have one row")
+        if (
+            int(header.column("schema_version")[0])
+            != RECURRENCE_BUILDER_INPUT_SCHEMA_VERSION
+        ):
+            raise RecurrenceColumnarInputError(
+                "recurrence header has the wrong schema version"
+            )
+        expected_counts = {
+            "external_leg_count": external_count,
+            "physical_sector_count": sector_count,
+            "public_flow_count": self.table("public_lc_flows").row_count,
+            "replay_partition_count": partition_count,
+            "coupling_limit_count": self.table("coupling_limits").row_count,
+            "parameter_projection_count": self.table("parameter_projection").row_count,
+        }
+        for column, expected in expected_counts.items():
+            if int(header.column(column)[0]) != expected:
+                raise RecurrenceColumnarInputError(
+                    f"recurrence header {column} does not match its table"
+                )
+
+        strings = _decode_flat_strings(
+            self.table("string_ranges"),
+            self.table("string_bytes"),
+        )
+        abi_id = int(header.column("abi_string_id")[0])
+        if strings[abi_id] != self.abi:
+            raise RecurrenceColumnarInputError(
+                "recurrence header ABI string does not match the payload ABI"
+            )
+        roles = tuple(
+            strings[int(value)]
+            for value in self.table("header_digests").column("role_string_id")
+        )
+        if len(set(roles)) != len(roles):
+            raise RecurrenceColumnarInputError(
+                "recurrence header contains duplicate semantic digest roles"
+            )
+        if not set(roles) >= _REQUIRED_HEADER_DIGEST_ROLES:
+            missing = sorted(_REQUIRED_HEADER_DIGEST_ROLES - set(roles))
+            raise RecurrenceColumnarInputError(
+                f"recurrence header is missing semantic digests: {missing!r}"
+            )
+
+        selected_flows = self.table("selected_public_flow_coverage").row_count
+        selected_sources = self.table("selected_source_coverage").row_count
+        if bool(int(header.column("selected_flow_mode")[0])) != bool(selected_flows):
+            raise RecurrenceColumnarInputError(
+                "selected-flow header mode disagrees with its coverage table"
+            )
+        if bool(int(header.column("selected_source_mode")[0])) != bool(
+            selected_sources
+        ):
+            raise RecurrenceColumnarInputError(
+                "selected-source header mode disagrees with its coverage table"
+            )
+        if any(
+            int(value) not in {-1, 1}
+            for value in self.table("source_states").column("momentum_sign")
+        ):
+            raise RecurrenceColumnarInputError(
+                "source-state momentum signs must be -1 or 1"
+            )
+
+    def _validate_fermion_pairing(self) -> None:
+        roles = self._semantic_digest_roles()
+        pairing_roles = {
+            "fermion-pairing-semantic",
+            "fermion-pairing-topology",
+        }
+        if not self.fermion_pairing_tables:
+            unexpected = sorted(pairing_roles & roles.keys())
+            if unexpected:
+                raise RecurrenceColumnarInputError(
+                    "recurrence header claims fermion-pairing semantics without "
+                    f"fixed-width tables: {unexpected!r}"
+                )
+            return
+
+        from .recurrence_pairing_columnar import (
+            _PAIRING_COLUMNAR_ABI,
+            _FermionPairingColumnarV1,
+        )
+
+        payload = _FermionPairingColumnarV1(
+            _PAIRING_COLUMNAR_ABI,
+            self.fermion_pairing_tables,
+        )
+        missing = sorted(pairing_roles - roles.keys())
+        if missing:
+            raise RecurrenceColumnarInputError(
+                "recurrence fermion-pairing tables lack semantic header digests: "
+                f"{missing!r}"
+            )
+
+        header = payload.table("header")
+        external_legs = self.table("external_legs")
+        if int(header.column("source_count")[0]) != external_legs.row_count:
+            raise RecurrenceColumnarInputError(
+                "fermion-pairing source count does not match external legs"
+            )
+        topology_digest = bytes(header.column("topology_digest")[0]).hex()
+        semantic_digest = bytes(header.column("semantic_digest")[0]).hex()
+        if roles["fermion-pairing-topology"] != topology_digest:
+            raise RecurrenceColumnarInputError(
+                "fermion-pairing topology digest disagrees with the process header"
+            )
+        if roles["fermion-pairing-semantic"] != semantic_digest:
+            raise RecurrenceColumnarInputError(
+                "fermion-pairing semantic digest disagrees with the process header"
+            )
+
+        pairing_strings = _decode_pairing_strings(payload)
+        process_key_id = int(header.column("process_key_string_id")[0])
+        process_key = pairing_strings[process_key_id]
+        main_header = self.table("header")
+        main_strings = _decode_flat_strings(
+            self.table("string_ranges"),
+            self.table("string_bytes"),
+        )
+        process_id = main_strings[int(main_header.column("process_id_string_id")[0])]
+        if process_key != process_id:
+            raise RecurrenceColumnarInputError(
+                "fermion-pairing process key does not match recurrence process ID"
+            )
+
+        endpoints = payload.table("endpoints")
+        endpoint_slots = tuple(int(value) for value in endpoints.column("source_slot"))
+        if len(endpoint_slots) != len(set(endpoint_slots)):
+            raise RecurrenceColumnarInputError(
+                "fermion-pairing endpoint source slots must be unique"
+            )
+        expected_orientations: dict[int, int] = {}
+        open_strings = self.table("lc_open_strings")
+        for row in range(open_strings.row_count):
+            for column, orientation in (
+                ("fundamental_source_slot", 0),
+                ("antifundamental_source_slot", 1),
+            ):
+                source_slot = int(open_strings.column(column)[row])
+                previous = expected_orientations.setdefault(source_slot, orientation)
+                if previous != orientation:
+                    raise RecurrenceColumnarInputError(
+                        "LC sectors assign inconsistent color orientations to one "
+                        "fermion endpoint"
+                    )
+        if set(endpoint_slots) != set(expected_orientations):
+            raise RecurrenceColumnarInputError(
+                "fermion-pairing endpoints do not cover the LC open-line endpoints"
+            )
+        public_labels = external_legs.column("public_label")
+        fermionic = external_legs.column("is_fermionic")
+        endpoint_labels = endpoints.column("public_label")
+        endpoint_orientations = endpoints.column("color_orientation")
+        for row, source_slot in enumerate(endpoint_slots):
+            if not int(fermionic[source_slot]):
+                raise RecurrenceColumnarInputError(
+                    "fermion-pairing endpoint references a non-fermionic source"
+                )
+            if int(endpoint_labels[row]) != int(public_labels[source_slot]):
+                raise RecurrenceColumnarInputError(
+                    "fermion-pairing endpoint public label disagrees with its source"
+                )
+            if int(endpoint_orientations[row]) != expected_orientations[source_slot]:
+                raise RecurrenceColumnarInputError(
+                    "fermion-pairing endpoint orientation disagrees with LC sectors"
+                )
+
+    def _semantic_digest_roles(self) -> dict[str, str]:
+        strings = _decode_flat_strings(
+            self.table("string_ranges"),
+            self.table("string_bytes"),
+        )
+        digests = self.table("digest_catalog").column("value")
+        result: dict[str, str] = {}
+        table = self.table("header_digests")
+        for row in range(table.row_count):
+            role = strings[int(table.column("role_string_id")[row])]
+            digest = bytes(digests[int(table.column("digest_id")[row])]).hex()
+            result[role] = digest
+        return result
+
+
+class _StringCatalog:
+    def __init__(self, values: Iterable[str]) -> None:
+        unique = {_nonempty_text(value, "string catalog value") for value in values}
+        self.values = tuple(sorted(unique, key=lambda value: value.encode("utf-8")))
+        self.ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, value: str) -> int:
+        try:
+            return self.ids[value]
+        except KeyError as error:
+            raise RecurrenceColumnarInputError(
+                f"string {value!r} was not collected before table construction"
+            ) from error
+
+    def tables(self) -> tuple[RecurrenceColumnarTable, RecurrenceColumnarTable]:
+        encoded = tuple(value.encode("utf-8") for value in self.values)
+        ranges = _allocate(len(encoded), start=_U64, count=_U64)
+        flat = _allocate(sum(len(value) for value in encoded), value=_U8)
+        cursor = 0
+        for row, value in enumerate(encoded):
+            ranges["start"][row] = cursor
+            ranges["count"][row] = len(value)
+            if value:
+                flat["value"][cursor : cursor + len(value)] = np.frombuffer(
+                    value,
+                    dtype=_U8,
+                )
+            cursor += len(value)
+        return (
+            _freeze_table("string_ranges", ranges),
+            _freeze_table("string_bytes", flat),
+        )
+
+
+class _DigestCatalog:
+    def __init__(self, values: Iterable[str]) -> None:
+        raw = {_sha256_bytes(value, "semantic digest") for value in values}
+        self.values = tuple(sorted(raw))
+        self.ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, value: str) -> int:
+        return self.ids[_sha256_bytes(value, "semantic digest")]
+
+    def table(self) -> RecurrenceColumnarTable:
+        columns = _allocate(len(self.values), id=_U32, value=(_U8, (32,)))
+        for row, value in enumerate(self.values):
+            columns["id"][row] = row
+            columns["value"][row] = np.frombuffer(value, dtype=_U8)
+        return _freeze_table("digest_catalog", columns)
+
+
+class _U32SequenceCatalog:
+    def __init__(self, values: Iterable[Sequence[int]]) -> None:
+        canonical: set[tuple[int, ...]] = set()
+        for value in values:
+            item = tuple(value)
+            _validate_u32_sequence(item, "u32 sequence catalog value")
+            canonical.add(item)
+        self.values = tuple(sorted(canonical))
+        self.ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, value: Sequence[int]) -> int:
+        item = tuple(value)
+        try:
+            return self.ids[item]
+        except KeyError as error:
+            raise RecurrenceColumnarInputError(
+                f"u32 sequence {item!r} was not collected"
+            ) from error
+
+    def tables(self) -> tuple[RecurrenceColumnarTable, RecurrenceColumnarTable]:
+        ranges = _allocate(len(self.values), start=_U64, count=_U64)
+        flat = _allocate(sum(len(value) for value in self.values), value=_U32)
+        cursor = 0
+        for row, value in enumerate(self.values):
+            ranges["start"][row] = cursor
+            ranges["count"][row] = len(value)
+            if value:
+                flat["value"][cursor : cursor + len(value)] = value
+            cursor += len(value)
+        return (
+            _freeze_table("u32_sequence_ranges", ranges),
+            _freeze_table("u32_sequence_values", flat),
+        )
+
+
+class _BitsetCatalog:
+    def __init__(self, values: Iterable[int]) -> None:
+        canonical: set[int] = set()
+        for value in values:
+            _validate_nonnegative_mask(value, "bitset catalog value")
+            canonical.add(value)
+        self.values = tuple(sorted(canonical))
+        self.ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, value: int) -> int:
+        return self.ids[value]
+
+    def tables(self) -> tuple[RecurrenceColumnarTable, RecurrenceColumnarTable]:
+        ranges = _allocate(
+            len(self.values),
+            id=_U32,
+            start=_U64,
+            count=_U64,
+            bit_count=_U64,
+        )
+        total_words = sum((value.bit_length() + 63) // 64 for value in self.values)
+        words = _allocate(total_words, value=_U64)
+        cursor = 0
+        for row, value in enumerate(self.values):
+            count = (value.bit_length() + 63) // 64
+            ranges["id"][row] = row
+            ranges["start"][row] = cursor
+            ranges["count"][row] = count
+            ranges["bit_count"][row] = value.bit_count()
+            for offset in range(count):
+                words["value"][cursor] = (value >> (64 * offset)) & ((1 << 64) - 1)
+                cursor += 1
+        return (
+            _freeze_table("bitset_ranges", ranges),
+            _freeze_table("bitset_words", words),
+        )
+
+
+class _FactorCatalog:
+    def __init__(self, values: Iterable[ExactComplexRationalV1]) -> None:
+        unique = {value.canonical_key: value for value in values}
+        self.values = tuple(unique[key] for key in sorted(unique))
+        self.ids = {
+            value.canonical_key: index for index, value in enumerate(self.values)
+        }
+
+    def id(self, value: ExactComplexRationalV1) -> int:
+        return self.ids[value.canonical_key]
+
+    def table(self, strings: _StringCatalog) -> RecurrenceColumnarTable:
+        columns = _allocate(
+            len(self.values),
+            id=_U32,
+            real_numerator_string_id=_U32,
+            real_denominator_string_id=_U32,
+            imag_numerator_string_id=_U32,
+            imag_denominator_string_id=_U32,
+        )
+        for row, value in enumerate(self.values):
+            columns["id"][row] = row
+            columns["real_numerator_string_id"][row] = strings.id(
+                str(value.real_numerator)
+            )
+            columns["real_denominator_string_id"][row] = strings.id(
+                str(value.real_denominator)
+            )
+            columns["imag_numerator_string_id"][row] = strings.id(
+                str(value.imag_numerator)
+            )
+            columns["imag_denominator_string_id"][row] = strings.id(
+                str(value.imag_denominator)
+            )
+        return _freeze_table("exact_factors", columns)
+
+
+def build_recurrence_builder_input_v1(
+    logical: RecurrenceBuilderLogicalInputV1,
+) -> RecurrenceBuilderInputV1:
+    """Validate and flatten compact logical recurrence records.
+
+    The caller retains no mutable storage reachable from the returned payload.
+    Record collections whose order is not semantic are canonicalised before
+    catalog and table construction.
+    """
+
+    if not isinstance(logical, RecurrenceBuilderLogicalInputV1):
+        raise TypeError("recurrence columnar extraction requires logical v1 records")
+
+    external_legs = tuple(
+        sorted(logical.external_legs, key=lambda leg: leg.source_slot)
+    )
+    sectors = tuple(
+        sorted(logical.physical_sectors, key=lambda sector: sector.sector_id)
+    )
+    public_flows = tuple(sorted(logical.public_flows, key=lambda flow: flow.flow_id))
+    partitions = tuple(
+        sorted(
+            logical.replay_partitions,
+            key=lambda partition: (
+                partition.representative_sector_id,
+                partition.materialized_sector_id,
+            ),
+        )
+    )
+    digests = tuple(sorted(logical.semantic_digests, key=lambda item: item.role))
+    template_refs = tuple(
+        sorted(
+            logical.semantic_template_references,
+            key=lambda item: (item.kind, item.template_id, item.semantic_digest),
+        )
+    )
+    coupling_limits = tuple(sorted(logical.coupling_limits, key=lambda item: item.name))
+    parameter_projection = tuple(
+        sorted(logical.parameter_projection, key=lambda item: item.runtime_slot)
+    )
+    selected_flows = (
+        None
+        if logical.selected_public_flow_ids is None
+        else tuple(sorted(logical.selected_public_flow_ids))
+    )
+    selected_sources = (
+        None
+        if logical.selected_source_coverage is None
+        else tuple(
+            sorted(
+                logical.selected_source_coverage,
+                key=lambda item: item.source_slot,
+            )
+        )
+    )
+
+    _validate_logical_relations(
+        logical,
+        external_legs=external_legs,
+        sectors=sectors,
+        public_flows=public_flows,
+        partitions=partitions,
+        digests=digests,
+        template_refs=template_refs,
+        coupling_limits=coupling_limits,
+        parameter_projection=parameter_projection,
+        selected_flows=selected_flows,
+        selected_sources=selected_sources,
+    )
+
+    pairing_tables: tuple[RecurrenceColumnarTable, ...] = ()
+    if logical.fermion_pairing_catalog is not None:
+        from .recurrence_pairing_columnar import (
+            _encode_fermion_pairing_catalog_v1,
+        )
+
+        pairing_tables = _encode_fermion_pairing_catalog_v1(
+            logical.fermion_pairing_catalog
+        ).tables
+
+    all_factors = [logical.normalization.factor]
+    all_factors.extend(
+        target.amplitude_phase
+        for partition in partitions
+        for target in partition.targets
+    )
+    all_factors.extend(flow.reduction_weight for flow in public_flows)
+    all_factors.extend(
+        state.crossing_phase for leg in external_legs for state in leg.source_states
+    )
+    factor_catalog = _FactorCatalog(all_factors)
+
+    string_values: list[str] = [
+        RECURRENCE_BUILDER_INPUT_ABI,
+        logical.process_id,
+        logical.normalization.convention,
+    ]
+    string_values.extend(item.role for item in digests)
+    string_values.extend(item.public_id for item in sectors)
+    string_values.extend(item.closure_proof_algorithm for item in sectors)
+    string_values.extend(item.public_id for item in public_flows)
+    string_values.extend(partition.proof_algorithm for partition in partitions)
+    string_values.extend(limit.name for limit in coupling_limits)
+    string_values.extend(item.kind for item in template_refs)
+    string_values.extend(item.runtime_name for item in parameter_projection)
+    for factor in factor_catalog.values:
+        string_values.extend(str(value) for value in factor.canonical_key)
+    strings = _StringCatalog(string_values)
+
+    digest_values = [item.digest for item in digests]
+    digest_values.extend(sector.closure_proof_digest for sector in sectors)
+    digest_values.extend(partition.proof_digest for partition in partitions)
+    digest_values.extend(item.semantic_digest for item in template_refs)
+    digest_values.append(logical.normalization.semantic_digest)
+    digest_catalog = _DigestCatalog(digest_values)
+
+    sequence_values: list[Sequence[int]] = [()]
+    for sector in sectors:
+        sequence_values.extend(
+            (
+                sector.trace_source_slots,
+                sector.singlet_source_slots,
+                sector.word_source_slots,
+            )
+        )
+        for line in sector.open_strings:
+            sequence_values.extend(
+                (line.adjoint_source_slots, line.singlet_source_slots)
+            )
+    for partition in partitions:
+        for target in partition.targets:
+            sequence_values.extend(
+                (
+                    target.external_permutation,
+                    target.source_slot_permutation,
+                )
+            )
+    for flow in public_flows:
+        sequence_values.extend((flow.word_source_slots, flow.source_slot_permutation))
+    sequences = _U32SequenceCatalog(sequence_values)
+
+    bitsets = _BitsetCatalog(
+        (
+            logical.process_support_mask,
+            *(leg.momentum_mask for leg in external_legs),
+            *(leg.support_mask for leg in external_legs),
+            *(sector.support_mask for sector in sectors),
+        )
+    )
+
+    tables: list[RecurrenceColumnarTable] = []
+    tables.extend(bitsets.tables())
+    tables.append(_build_coupling_limits(coupling_limits, strings))
+    tables.append(digest_catalog.table())
+    tables.append(factor_catalog.table(strings))
+    external_table, source_state_table = _build_external_tables(
+        external_legs,
+        bitsets,
+        factor_catalog,
+    )
+    tables.extend((external_table, source_state_table))
+    tables.append(
+        _build_header(
+            logical,
+            strings,
+            bitsets,
+            external_count=len(external_legs),
+            sector_count=len(sectors),
+            public_flow_count=len(public_flows),
+            partition_count=len(partitions),
+            coupling_limit_count=len(coupling_limits),
+            parameter_count=len(parameter_projection),
+            selected_flow_mode=selected_flows is not None,
+            selected_source_mode=selected_sources is not None,
+        )
+    )
+    tables.append(_build_header_digests(digests, strings, digest_catalog))
+    sector_table, open_string_table = _build_sector_tables(
+        sectors,
+        strings,
+        digest_catalog,
+        sequences,
+        bitsets,
+    )
+    tables.extend((sector_table, open_string_table))
+    tables.append(_build_public_flows(public_flows, strings, sequences, factor_catalog))
+    tables.append(
+        _build_normalization(
+            logical.normalization,
+            strings,
+            digest_catalog,
+            factor_catalog,
+        )
+    )
+    tables.append(_build_parameter_projection(parameter_projection, strings))
+    partition_table, target_table = _build_replay_tables(
+        partitions,
+        strings,
+        digest_catalog,
+        sequences,
+        factor_catalog,
+    )
+    tables.extend((partition_table, target_table))
+    tables.append(_build_selected_flows(selected_flows))
+    tables.append(_build_selected_sources(selected_sources))
+    tables.append(_build_template_references(template_refs, strings, digest_catalog))
+    string_ranges, string_bytes = strings.tables()
+    tables.extend((string_ranges, string_bytes))
+    sequence_ranges, sequence_values_table = sequences.tables()
+    tables.extend((sequence_ranges, sequence_values_table))
+
+    return RecurrenceBuilderInputV1(
+        abi=RECURRENCE_BUILDER_INPUT_ABI,
+        tables=tuple(sorted(tables, key=lambda table: table.name)),
+        fermion_pairing_tables=pairing_tables,
+    )
+
+
+def _validate_logical_relations(
+    logical: RecurrenceBuilderLogicalInputV1,
+    *,
+    external_legs: tuple[RecurrenceExternalLegV1, ...],
+    sectors: tuple[RecurrencePhysicalLCSectorV1, ...],
+    public_flows: tuple[RecurrencePublicLCFlowV1, ...],
+    partitions: tuple[RecurrenceReplayPartitionV1, ...],
+    digests: tuple[RecurrenceSemanticDigestV1, ...],
+    template_refs: tuple[RecurrenceSemanticTemplateReferenceV1, ...],
+    coupling_limits: tuple[RecurrenceCouplingLimitV1, ...],
+    parameter_projection: tuple[RecurrenceParameterProjectionV1, ...],
+    selected_flows: tuple[int, ...] | None,
+    selected_sources: tuple[RecurrenceSelectedSourceCoverageV1, ...] | None,
+) -> None:
+    source_slots = tuple(leg.source_slot for leg in external_legs)
+    if source_slots != tuple(range(len(source_slots))):
+        raise RecurrenceColumnarInputError(
+            "external source slots must be dense from zero"
+        )
+    public_labels = tuple(leg.public_label for leg in external_legs)
+    if len(set(public_labels)) != len(public_labels):
+        raise RecurrenceColumnarInputError("external public labels must be unique")
+    sector_ids = tuple(sector.sector_id for sector in sectors)
+    if sector_ids != tuple(range(len(sector_ids))):
+        raise RecurrenceColumnarInputError(
+            "physical LC sector IDs must be dense from zero"
+        )
+    public_sector_ids = tuple(sector.public_id for sector in sectors)
+    if len(set(public_sector_ids)) != len(public_sector_ids):
+        raise RecurrenceColumnarInputError(
+            "physical LC sector public IDs must be unique"
+        )
+    if not sectors:
+        raise RecurrenceColumnarInputError(
+            "recurrence v2 requires at least one physical LC sector"
+        )
+    flow_ids = tuple(flow.flow_id for flow in public_flows)
+    if flow_ids != tuple(range(len(flow_ids))):
+        raise RecurrenceColumnarInputError("public LC flow IDs must be dense from zero")
+    public_flow_ids = tuple(flow.public_id for flow in public_flows)
+    if not public_flows or len(set(public_flow_ids)) != len(public_flow_ids):
+        raise RecurrenceColumnarInputError(
+            "public LC flow identifiers must be nonempty and unique"
+        )
+    for flow in public_flows:
+        _require_index(
+            flow.construction_sector_id,
+            len(sectors),
+            "public flow construction sector",
+        )
+        _validate_permutation(
+            flow.source_slot_permutation,
+            len(external_legs),
+            "public flow source-slot permutation",
+        )
+        _validate_source_contract_permutation(
+            external_legs,
+            flow.source_slot_permutation,
+            f"public LC flow {flow.flow_id}",
+        )
+        construction_word = sectors[flow.construction_sector_id].word_source_slots
+        mapped_word = tuple(
+            flow.source_slot_permutation[source_slot]
+            for source_slot in construction_word
+        )
+        construction_sector = sectors[flow.construction_sector_id]
+        reflected_trace = (
+            construction_sector.kind == "single-trace"
+            and len(construction_word) > 2
+            and flow.word_source_slots
+            == (construction_word[0], *reversed(construction_word[1:]))
+            and flow.source_slot_permutation == tuple(range(len(external_legs)))
+        )
+        if mapped_word != flow.word_source_slots and not reflected_trace:
+            raise RecurrenceColumnarInputError(
+                "public flow word is neither its gathered construction word nor "
+                "an anchored folded-trace reflection"
+            )
+
+    roles = tuple(item.role for item in digests)
+    if len(set(roles)) != len(roles):
+        raise RecurrenceColumnarInputError(
+            "semantic header digest roles must be unique"
+        )
+    if not set(roles) >= _REQUIRED_HEADER_DIGEST_ROLES:
+        missing = sorted(_REQUIRED_HEADER_DIGEST_ROLES - set(roles))
+        raise RecurrenceColumnarInputError(
+            f"recurrence logical input is missing semantic digests: {missing!r}"
+        )
+    pairing_roles = {
+        item.role: item.digest
+        for item in digests
+        if item.role.startswith("fermion-pairing-")
+    }
+    pairing = logical.fermion_pairing_catalog
+    if pairing is None:
+        if pairing_roles:
+            raise RecurrenceColumnarInputError(
+                "recurrence logical input claims fermion-pairing digests without "
+                "an exact pairing catalog"
+            )
+    else:
+        expected_pairing_roles = {
+            "fermion-pairing-semantic": pairing.semantic_digest,
+            "fermion-pairing-topology": pairing.topology_digest,
+        }
+        if pairing_roles != expected_pairing_roles:
+            raise RecurrenceColumnarInputError(
+                "recurrence fermion-pairing digest roles are missing or stale"
+            )
+        if pairing.process_key != logical.process_id:
+            raise RecurrenceColumnarInputError(
+                "fermion-pairing process key does not match recurrence process ID"
+            )
+        if pairing.source_count != len(external_legs):
+            raise RecurrenceColumnarInputError(
+                "fermion-pairing source count does not match external legs"
+            )
+
+    names = tuple(limit.name for limit in coupling_limits)
+    if len(set(names)) != len(names):
+        raise RecurrenceColumnarInputError("coupling-order names must be unique")
+    slots = tuple(item.runtime_slot for item in parameter_projection)
+    if slots != tuple(range(len(slots))):
+        raise RecurrenceColumnarInputError(
+            "runtime parameter slots must be dense from zero"
+        )
+    runtime_components = tuple(
+        (item.runtime_name, item.component) for item in parameter_projection
+    )
+    if len(set(runtime_components)) != len(runtime_components):
+        raise RecurrenceColumnarInputError(
+            "runtime parameter name/component pairs must be unique"
+        )
+    template_keys = tuple((item.kind, item.template_id) for item in template_refs)
+    if len(set(template_keys)) != len(template_keys):
+        raise RecurrenceColumnarInputError(
+            "semantic-template kind/ID pairs must be unique"
+        )
+    available_templates = set(template_keys)
+    for leg in external_legs:
+        for state in leg.source_states:
+            if (
+                "current-state",
+                state.current_state_template_id,
+            ) not in available_templates:
+                raise RecurrenceColumnarInputError(
+                    "external source coverage references an absent current-state "
+                    "template"
+                )
+            if ("source", state.source_template_id) not in available_templates:
+                raise RecurrenceColumnarInputError(
+                    "external source coverage references an absent source template"
+                )
+    for projection in parameter_projection:
+        if ("parameter", projection.parameter_template_id) not in available_templates:
+            raise RecurrenceColumnarInputError(
+                "parameter projection references an absent parameter template"
+            )
+
+    for sector in sectors:
+        _require_index(
+            sector.closure_source_slot,
+            len(external_legs),
+            "LC closure source slot",
+        )
+        if sector.word_source_slots:
+            if sector.closure_proof_algorithm == "canonical-lc-closure-anchor-v2":
+                if sector.closure_source_slot != sector.word_source_slots[-1]:
+                    raise RecurrenceColumnarInputError(
+                        "v2 LC closure source slot must be the terminal "
+                        "colour-word endpoint"
+                    )
+            elif sector.closure_proof_algorithm == "canonical-lc-closure-anchor-v4":
+                # The producer owns this inherited provenance; the typed Rust
+                # process boundary validates its structural preconditions once.
+                pass
+            elif sector.closure_proof_algorithm == "canonical-lc-closure-anchor-v3":
+                if sector.kind != "open-lines":
+                    raise RecurrenceColumnarInputError(
+                        "v3 LC closure anchoring is available only for "
+                        "open-line sectors"
+                    )
+                open_blocks = tuple(
+                    (
+                        line.fundamental_source_slot,
+                        *line.adjoint_source_slots,
+                        line.antifundamental_source_slot,
+                    )
+                    for line in sector.open_strings
+                )
+                physical_blocks: list[tuple[int, ...]] = []
+                unused = set(range(len(open_blocks)))
+                cursor = 0
+                while cursor < len(sector.word_source_slots):
+                    matches = tuple(
+                        index
+                        for index in sorted(unused)
+                        if sector.word_source_slots[
+                            cursor : cursor + len(open_blocks[index])
+                        ]
+                        == open_blocks[index]
+                    )
+                    if len(matches) != 1:
+                        raise RecurrenceColumnarInputError(
+                            "v3 LC public word does not have one exact open-line "
+                            f"block at source position {cursor}"
+                        )
+                    block_index = matches[0]
+                    unused.remove(block_index)
+                    block = open_blocks[block_index]
+                    physical_blocks.append(block)
+                    cursor += len(block)
+                if unused or cursor != len(sector.word_source_slots):
+                    raise RecurrenceColumnarInputError(
+                        "v3 LC public word is not an exact complete-open-line "
+                        "block traversal"
+                    )
+                distinguished_source_slot = min(sector.word_source_slots)
+                distinguished_positions = tuple(
+                    index
+                    for index, block in enumerate(physical_blocks)
+                    if distinguished_source_slot in block
+                )
+                if len(distinguished_positions) != 1:
+                    raise RecurrenceColumnarInputError(
+                        "v3 LC minimum coloured source slot must belong to "
+                        "exactly one open-line block"
+                    )
+                first = distinguished_positions[0]
+                closure_blocks = (
+                    *physical_blocks[first:],
+                    *physical_blocks[:first],
+                )
+                closure_traversal = tuple(
+                    slot for block in closure_blocks for slot in block
+                )
+                if (
+                    not closure_traversal
+                    or sector.closure_source_slot != closure_traversal[-1]
+                ):
+                    raise RecurrenceColumnarInputError(
+                        "v3 LC closure source slot does not match the independently "
+                        "reconstructed minimum-coloured-source block rotation"
+                    )
+                payload = {
+                    "algorithm": "canonical-lc-closure-anchor-v3",
+                    "closure_block_source_slots": closure_blocks,
+                    "closure_source_slot": sector.closure_source_slot,
+                    "closure_traversal_source_slots": closure_traversal,
+                    "component_order_policy": (
+                        "independent-open-string-block-permutation"
+                        if len(open_blocks) > 1
+                        else "exact-ordered-components"
+                    ),
+                    "distinguished_source_block": closure_blocks[0],
+                    "distinguished_source_slot": distinguished_source_slot,
+                    "external_source_count": len(external_legs),
+                    "fermionic_source_slots": tuple(
+                        leg.source_slot for leg in external_legs if leg.is_fermionic
+                    ),
+                    "open_string_count": len(open_blocks),
+                    "physical_block_source_slots": physical_blocks,
+                    "policy": ("minimum-coloured-source-slot-open-line-block-rotation"),
+                    "process_source_label_order": tuple(
+                        leg.public_label for leg in external_legs
+                    ),
+                    "sector_id": sector.sector_id,
+                    "sector_kind": sector.kind,
+                    "selected_closure_block": closure_blocks[-1],
+                    "singlet_source_slots": sector.singlet_source_slots,
+                    "word_source_slots": sector.word_source_slots,
+                }
+                expected_digest = hashlib.sha256(
+                    json.dumps(
+                        payload,
+                        allow_nan=False,
+                        ensure_ascii=True,
+                        separators=(",", ":"),
+                        sort_keys=True,
+                    ).encode("ascii")
+                ).hexdigest()
+                if sector.closure_proof_digest != expected_digest:
+                    raise RecurrenceColumnarInputError(
+                        "v3 LC closure proof digest does not match the independently "
+                        "reconstructed minimum-coloured-source block rotation"
+                    )
+            else:
+                raise RecurrenceColumnarInputError(
+                    "unsupported LC closure-anchor proof algorithm "
+                    f"{sector.closure_proof_algorithm!r}"
+                )
+        elif sector.kind != "singlet":
+            raise RecurrenceColumnarInputError(
+                "an LC sector without a colour word must be all-singlet"
+            )
+        elif tuple(sorted(sector.singlet_source_slots)) != tuple(
+            range(len(external_legs))
+        ):
+            raise RecurrenceColumnarInputError(
+                "an all-singlet LC sector must cover every external source"
+            )
+        else:
+            fermionic_slots = tuple(
+                leg.source_slot for leg in external_legs if leg.is_fermionic
+            )
+            expected_anchor = min(fermionic_slots) if fermionic_slots else 0
+            if sector.closure_source_slot != expected_anchor:
+                raise RecurrenceColumnarInputError(
+                    "an all-singlet LC sector must use the smallest fermionic "
+                    "source slot, or the smallest source slot when no fermion "
+                    "is present"
+                )
+        referenced_slots: list[int] = [
+            *sector.trace_source_slots,
+            *sector.singlet_source_slots,
+            *sector.word_source_slots,
+        ]
+        for line in sector.open_strings:
+            referenced_slots.extend(
+                (
+                    line.fundamental_source_slot,
+                    line.antifundamental_source_slot,
+                    *line.adjoint_source_slots,
+                    *line.singlet_source_slots,
+                )
+            )
+        for source_slot in referenced_slots:
+            _require_index(source_slot, len(external_legs), "LC source slot")
+
+    covered_targets: set[int] = set()
+    for partition in partitions:
+        _require_index(
+            partition.representative_sector_id,
+            len(sectors),
+            "replay representative sector",
+        )
+        _require_index(
+            partition.materialized_sector_id,
+            len(sectors),
+            "replay materialized sector",
+        )
+        representative_word = sectors[
+            partition.representative_sector_id
+        ].word_source_slots
+        representative_anchor = sectors[
+            partition.representative_sector_id
+        ].closure_source_slot
+        for target in sorted(partition.targets, key=lambda item: item.sector_id):
+            _require_index(target.sector_id, len(sectors), "replay target sector")
+            if target.sector_id in covered_targets:
+                raise RecurrenceColumnarInputError(
+                    "replay partitions overlap one physical sector"
+                )
+            covered_targets.add(target.sector_id)
+            _validate_permutation(
+                target.external_permutation,
+                len(external_legs),
+                "replay external permutation",
+            )
+            if len(target.source_slot_permutation) != len(external_legs):
+                raise RecurrenceColumnarInputError(
+                    "replay source-slot permutation must cover every external leg"
+                )
+            _validate_permutation(
+                target.source_slot_permutation,
+                len(external_legs),
+                "replay source-slot permutation",
+            )
+            if target.external_permutation != target.source_slot_permutation:
+                raise RecurrenceColumnarInputError(
+                    "recurrence ABI v2 requires identical replay external and "
+                    "source-slot permutations"
+                )
+            _validate_source_contract_permutation(
+                external_legs,
+                target.source_slot_permutation,
+                f"replay target sector {target.sector_id}",
+            )
+            mapped_word = tuple(
+                target.source_slot_permutation[source_slot]
+                for source_slot in representative_word
+            )
+            if mapped_word != sectors[target.sector_id].word_source_slots:
+                raise RecurrenceColumnarInputError(
+                    "replay target word does not match its gather permutation"
+                )
+            mapped_anchor = target.source_slot_permutation[representative_anchor]
+            if mapped_anchor != sectors[target.sector_id].closure_source_slot:
+                raise RecurrenceColumnarInputError(
+                    "replay target permutation does not map the representative "
+                    "closure anchor onto the target anchor"
+                )
+
+    if selected_flows is not None:
+        if not selected_flows:
+            raise RecurrenceColumnarInputError(
+                "selected generation flow coverage cannot be empty"
+            )
+        if len(set(selected_flows)) != len(selected_flows):
+            raise RecurrenceColumnarInputError(
+                "selected generation flow coverage contains duplicates"
+            )
+        for flow_id in selected_flows:
+            _require_index(flow_id, len(public_flows), "selected public flow")
+
+    if selected_sources is not None:
+        if not selected_sources:
+            raise RecurrenceColumnarInputError(
+                "selected source generation coverage cannot be empty"
+            )
+        selected_slots = tuple(item.source_slot for item in selected_sources)
+        if len(set(selected_slots)) != len(selected_slots):
+            raise RecurrenceColumnarInputError(
+                "selected source generation coverage repeats a source slot"
+            )
+        if tuple(sorted(selected_slots)) != tuple(range(len(external_legs))):
+            raise RecurrenceColumnarInputError(
+                "selected source generation coverage must retain at least one "
+                "state for every external source slot"
+            )
+        for item in selected_sources:
+            source_slot = _require_index(
+                item.source_slot,
+                len(external_legs),
+                "selected source slot",
+            )
+            state_count = len(external_legs[source_slot].source_states)
+            for state_index in item.source_state_indices:
+                _require_index(
+                    state_index,
+                    state_count,
+                    "selected source-state index",
+                )
+
+
+def _build_header(
+    logical: RecurrenceBuilderLogicalInputV1,
+    strings: _StringCatalog,
+    bitsets: _BitsetCatalog,
+    *,
+    external_count: int,
+    sector_count: int,
+    public_flow_count: int,
+    partition_count: int,
+    coupling_limit_count: int,
+    parameter_count: int,
+    selected_flow_mode: bool,
+    selected_source_mode: bool,
+) -> RecurrenceColumnarTable:
+    columns = _allocate(
+        1,
+        schema_version=_U32,
+        abi_string_id=_U32,
+        process_id_string_id=_U32,
+        layout=_U8,
+        selected_flow_mode=_U8,
+        selected_source_mode=_U8,
+        external_leg_count=_U32,
+        physical_sector_count=_U32,
+        public_flow_count=_U32,
+        replay_partition_count=_U32,
+        coupling_limit_count=_U32,
+        parameter_projection_count=_U32,
+        process_support_mask_id=_U32,
+    )
+    columns["schema_version"][0] = RECURRENCE_BUILDER_INPUT_SCHEMA_VERSION
+    columns["abi_string_id"][0] = strings.id(RECURRENCE_BUILDER_INPUT_ABI)
+    columns["process_id_string_id"][0] = strings.id(logical.process_id)
+    columns["layout"][0] = _LAYOUT_CODES[logical.layout]
+    columns["selected_flow_mode"][0] = int(selected_flow_mode)
+    columns["selected_source_mode"][0] = int(selected_source_mode)
+    columns["external_leg_count"][0] = _checked_u32(external_count, "external count")
+    columns["physical_sector_count"][0] = _checked_u32(sector_count, "sector count")
+    columns["public_flow_count"][0] = _checked_u32(
+        public_flow_count,
+        "public flow count",
+    )
+    columns["replay_partition_count"][0] = _checked_u32(
+        partition_count,
+        "replay partition count",
+    )
+    columns["coupling_limit_count"][0] = _checked_u32(
+        coupling_limit_count,
+        "coupling-limit count",
+    )
+    columns["parameter_projection_count"][0] = _checked_u32(
+        parameter_count,
+        "parameter-projection count",
+    )
+    columns["process_support_mask_id"][0] = bitsets.id(logical.process_support_mask)
+    return _freeze_table("header", columns)
+
+
+def _build_header_digests(
+    values: tuple[RecurrenceSemanticDigestV1, ...],
+    strings: _StringCatalog,
+    digests: _DigestCatalog,
+) -> RecurrenceColumnarTable:
+    columns = _allocate(len(values), role_string_id=_U32, digest_id=_U32)
+    for row, value in enumerate(values):
+        columns["role_string_id"][row] = strings.id(value.role)
+        columns["digest_id"][row] = digests.id(value.digest)
+    return _freeze_table("header_digests", columns)
+
+
+def _build_external_tables(
+    values: tuple[RecurrenceExternalLegV1, ...],
+    bitsets: _BitsetCatalog,
+    factors: _FactorCatalog,
+) -> tuple[RecurrenceColumnarTable, RecurrenceColumnarTable]:
+    legs = _allocate(
+        len(values),
+        source_slot=_U32,
+        public_label=_U32,
+        physical_pdg=_I32,
+        outgoing_pdg=_I32,
+        is_initial=_U8,
+        is_fermionic=_U8,
+        source_state_start=_U64,
+        source_state_count=_U64,
+        momentum_mask_id=_U32,
+        support_mask_id=_U32,
+    )
+    state_count = sum(len(value.source_states) for value in values)
+    states = _allocate(
+        state_count,
+        source_slot=_U32,
+        state_index=_U32,
+        public_helicity=_I32,
+        chirality=_I32,
+        spin_state=_I32,
+        current_state_template_id=_U32,
+        source_template_id=_U32,
+        momentum_sign=_I32,
+        crossing_phase_factor_id=_U32,
+    )
+    cursor = 0
+    for row, value in enumerate(values):
+        legs["source_slot"][row] = value.source_slot
+        legs["public_label"][row] = value.public_label
+        legs["physical_pdg"][row] = value.physical_pdg
+        legs["outgoing_pdg"][row] = value.outgoing_pdg
+        legs["is_initial"][row] = int(value.is_initial)
+        legs["is_fermionic"][row] = int(value.is_fermionic)
+        legs["source_state_start"][row] = cursor
+        legs["source_state_count"][row] = len(value.source_states)
+        legs["momentum_mask_id"][row] = bitsets.id(value.momentum_mask)
+        legs["support_mask_id"][row] = bitsets.id(value.support_mask)
+        for state in value.source_states:
+            states["source_slot"][cursor] = value.source_slot
+            states["state_index"][cursor] = state.state_index
+            states["public_helicity"][cursor] = state.public_helicity
+            states["chirality"][cursor] = state.chirality
+            states["spin_state"][cursor] = state.spin_state
+            states["current_state_template_id"][cursor] = (
+                state.current_state_template_id
+            )
+            states["source_template_id"][cursor] = state.source_template_id
+            states["momentum_sign"][cursor] = state.momentum_sign
+            states["crossing_phase_factor_id"][cursor] = factors.id(
+                state.crossing_phase
+            )
+            cursor += 1
+    return (
+        _freeze_table("external_legs", legs),
+        _freeze_table("source_states", states),
+    )
+
+
+def _build_sector_tables(
+    values: tuple[RecurrencePhysicalLCSectorV1, ...],
+    strings: _StringCatalog,
+    digests: _DigestCatalog,
+    sequences: _U32SequenceCatalog,
+    bitsets: _BitsetCatalog,
+) -> tuple[RecurrenceColumnarTable, RecurrenceColumnarTable]:
+    sectors = _allocate(
+        len(values),
+        sector_id=_U32,
+        public_id_string_id=_U32,
+        kind=_U8,
+        closure_source_slot=_U32,
+        closure_proof_algorithm_string_id=_U32,
+        closure_proof_digest_id=_U32,
+        open_string_start=_U64,
+        open_string_count=_U64,
+        trace_sequence_id=_U32,
+        singlet_sequence_id=_U32,
+        word_sequence_id=_U32,
+        support_mask_id=_U32,
+    )
+    line_count = sum(len(value.open_strings) for value in values)
+    lines = _allocate(
+        line_count,
+        sector_id=_U32,
+        ordinal=_U32,
+        fundamental_source_slot=_U32,
+        antifundamental_source_slot=_U32,
+        adjoint_sequence_id=_U32,
+        singlet_sequence_id=_U32,
+    )
+    cursor = 0
+    for row, value in enumerate(values):
+        sectors["sector_id"][row] = value.sector_id
+        sectors["public_id_string_id"][row] = strings.id(value.public_id)
+        sectors["kind"][row] = _SECTOR_KIND_CODES[value.kind]
+        sectors["closure_source_slot"][row] = value.closure_source_slot
+        sectors["closure_proof_algorithm_string_id"][row] = strings.id(
+            value.closure_proof_algorithm
+        )
+        sectors["closure_proof_digest_id"][row] = digests.id(value.closure_proof_digest)
+        sectors["open_string_start"][row] = cursor
+        sectors["open_string_count"][row] = len(value.open_strings)
+        sectors["trace_sequence_id"][row] = sequences.id(value.trace_source_slots)
+        sectors["singlet_sequence_id"][row] = sequences.id(value.singlet_source_slots)
+        sectors["word_sequence_id"][row] = sequences.id(value.word_source_slots)
+        sectors["support_mask_id"][row] = bitsets.id(value.support_mask)
+        for ordinal, line in enumerate(value.open_strings):
+            lines["sector_id"][cursor] = value.sector_id
+            lines["ordinal"][cursor] = ordinal
+            lines["fundamental_source_slot"][cursor] = line.fundamental_source_slot
+            lines["antifundamental_source_slot"][cursor] = (
+                line.antifundamental_source_slot
+            )
+            lines["adjoint_sequence_id"][cursor] = sequences.id(
+                line.adjoint_source_slots
+            )
+            lines["singlet_sequence_id"][cursor] = sequences.id(
+                line.singlet_source_slots
+            )
+            cursor += 1
+    return (
+        _freeze_table("physical_lc_sectors", sectors),
+        _freeze_table("lc_open_strings", lines),
+    )
+
+
+def _build_public_flows(
+    values: tuple[RecurrencePublicLCFlowV1, ...],
+    strings: _StringCatalog,
+    sequences: _U32SequenceCatalog,
+    factors: _FactorCatalog,
+) -> RecurrenceColumnarTable:
+    columns = _allocate(
+        len(values),
+        flow_id=_U32,
+        public_id_string_id=_U32,
+        construction_sector_id=_U32,
+        word_sequence_id=_U32,
+        source_slot_permutation_sequence_id=_U32,
+        reduction_weight_factor_id=_U32,
+    )
+    for row, value in enumerate(values):
+        columns["flow_id"][row] = value.flow_id
+        columns["public_id_string_id"][row] = strings.id(value.public_id)
+        columns["construction_sector_id"][row] = value.construction_sector_id
+        columns["word_sequence_id"][row] = sequences.id(value.word_source_slots)
+        columns["source_slot_permutation_sequence_id"][row] = sequences.id(
+            value.source_slot_permutation
+        )
+        columns["reduction_weight_factor_id"][row] = factors.id(value.reduction_weight)
+    return _freeze_table("public_lc_flows", columns)
+
+
+def _build_replay_tables(
+    values: tuple[RecurrenceReplayPartitionV1, ...],
+    strings: _StringCatalog,
+    digests: _DigestCatalog,
+    sequences: _U32SequenceCatalog,
+    factors: _FactorCatalog,
+) -> tuple[RecurrenceColumnarTable, RecurrenceColumnarTable]:
+    partitions = _allocate(
+        len(values),
+        partition_id=_U32,
+        representative_sector_id=_U32,
+        materialized_sector_id=_U32,
+        target_start=_U64,
+        target_count=_U64,
+        proof_algorithm_string_id=_U32,
+        proof_digest_id=_U32,
+    )
+    target_count = sum(len(value.targets) for value in values)
+    targets = _allocate(
+        target_count,
+        partition_id=_U32,
+        sector_id=_U32,
+        external_permutation_sequence_id=_U32,
+        source_slot_permutation_sequence_id=_U32,
+        amplitude_phase_factor_id=_U32,
+        fermion_sign=_I32,
+    )
+    cursor = 0
+    for partition_id, value in enumerate(values):
+        partitions["partition_id"][partition_id] = partition_id
+        partitions["representative_sector_id"][partition_id] = (
+            value.representative_sector_id
+        )
+        partitions["materialized_sector_id"][partition_id] = (
+            value.materialized_sector_id
+        )
+        partitions["target_start"][partition_id] = cursor
+        partitions["target_count"][partition_id] = len(value.targets)
+        partitions["proof_algorithm_string_id"][partition_id] = strings.id(
+            value.proof_algorithm
+        )
+        partitions["proof_digest_id"][partition_id] = digests.id(value.proof_digest)
+        for target in sorted(value.targets, key=lambda item: item.sector_id):
+            targets["partition_id"][cursor] = partition_id
+            targets["sector_id"][cursor] = target.sector_id
+            targets["external_permutation_sequence_id"][cursor] = sequences.id(
+                target.external_permutation
+            )
+            targets["source_slot_permutation_sequence_id"][cursor] = sequences.id(
+                target.source_slot_permutation
+            )
+            targets["amplitude_phase_factor_id"][cursor] = factors.id(
+                target.amplitude_phase
+            )
+            targets["fermion_sign"][cursor] = target.fermion_sign
+            cursor += 1
+    return (
+        _freeze_table("replay_partitions", partitions),
+        _freeze_table("replay_targets", targets),
+    )
+
+
+def _build_selected_flows(
+    values: tuple[int, ...] | None,
+) -> RecurrenceColumnarTable:
+    selected = () if values is None else values
+    columns = _allocate(len(selected), flow_id=_U32)
+    if selected:
+        columns["flow_id"][:] = selected
+    return _freeze_table("selected_public_flow_coverage", columns)
+
+
+def _build_selected_sources(
+    values: tuple[RecurrenceSelectedSourceCoverageV1, ...] | None,
+) -> RecurrenceColumnarTable:
+    rows = (
+        ()
+        if values is None
+        else tuple(
+            (item.source_slot, state_index)
+            for item in values
+            for state_index in sorted(item.source_state_indices)
+        )
+    )
+    columns = _allocate(len(rows), source_slot=_U32, source_state_index=_U32)
+    for row, (source_slot, state_index) in enumerate(rows):
+        columns["source_slot"][row] = source_slot
+        columns["source_state_index"][row] = state_index
+    return _freeze_table("selected_source_coverage", columns)
+
+
+def _build_coupling_limits(
+    values: tuple[RecurrenceCouplingLimitV1, ...],
+    strings: _StringCatalog,
+) -> RecurrenceColumnarTable:
+    columns = _allocate(
+        len(values),
+        name_string_id=_U32,
+        minimum=_U32,
+        maximum=_U32,
+    )
+    for row, value in enumerate(values):
+        columns["name_string_id"][row] = strings.id(value.name)
+        columns["minimum"][row] = value.minimum
+        columns["maximum"][row] = value.maximum
+    return _freeze_table("coupling_limits", columns)
+
+
+def _build_template_references(
+    values: tuple[RecurrenceSemanticTemplateReferenceV1, ...],
+    strings: _StringCatalog,
+    digests: _DigestCatalog,
+) -> RecurrenceColumnarTable:
+    columns = _allocate(
+        len(values),
+        kind_string_id=_U32,
+        template_id=_U32,
+        semantic_digest_id=_U32,
+        prepared_kernel_id=_U32,
+    )
+    for row, value in enumerate(values):
+        columns["kind_string_id"][row] = strings.id(value.kind)
+        columns["template_id"][row] = value.template_id
+        columns["semantic_digest_id"][row] = digests.id(value.semantic_digest)
+        columns["prepared_kernel_id"][row] = (
+            MISSING_U32
+            if value.prepared_kernel_id is None
+            else value.prepared_kernel_id
+        )
+    return _freeze_table("semantic_template_references", columns)
+
+
+def _build_normalization(
+    value: RecurrenceNormalizationV1,
+    strings: _StringCatalog,
+    digests: _DigestCatalog,
+    factors: _FactorCatalog,
+) -> RecurrenceColumnarTable:
+    columns = _allocate(
+        1,
+        factor_id=_U32,
+        convention_string_id=_U32,
+        semantic_digest_id=_U32,
+    )
+    columns["factor_id"][0] = factors.id(value.factor)
+    columns["convention_string_id"][0] = strings.id(value.convention)
+    columns["semantic_digest_id"][0] = digests.id(value.semantic_digest)
+    return _freeze_table("normalization", columns)
+
+
+def _build_parameter_projection(
+    values: tuple[RecurrenceParameterProjectionV1, ...],
+    strings: _StringCatalog,
+) -> RecurrenceColumnarTable:
+    columns = _allocate(
+        len(values),
+        runtime_slot=_U32,
+        runtime_name_string_id=_U32,
+        parameter_template_id=_U32,
+        prepared_parameter_id=_U32,
+        component=_U32,
+    )
+    for row, value in enumerate(values):
+        columns["runtime_slot"][row] = value.runtime_slot
+        columns["runtime_name_string_id"][row] = strings.id(value.runtime_name)
+        columns["parameter_template_id"][row] = value.parameter_template_id
+        columns["prepared_parameter_id"][row] = (
+            MISSING_U32
+            if value.prepared_parameter_id is None
+            else value.prepared_parameter_id
+        )
+        columns["component"][row] = value.component
+    return _freeze_table("parameter_projection", columns)
+
+
+def _allocate(
+    row_count: int,
+    **specifications: np.dtype[Any] | tuple[np.dtype[Any], tuple[int, ...]],
+) -> dict[str, np.ndarray[Any, Any]]:
+    _checked_u64(row_count, "table row count")
+    result: dict[str, np.ndarray[Any, Any]] = {}
+    for name, specification in specifications.items():
+        if isinstance(specification, tuple):
+            dtype, tail_shape = specification
+        else:
+            dtype, tail_shape = specification, ()
+        result[name] = np.empty((row_count, *tail_shape), dtype=dtype, order="C")
+    return result
+
+
+def _freeze_table(
+    name: str,
+    columns: Mapping[str, np.ndarray[Any, Any]],
+) -> RecurrenceColumnarTable:
+    row_counts = {len(values) for values in columns.values()}
+    row_count = row_counts.pop() if row_counts else 0
+    if row_counts:
+        raise RecurrenceColumnarInputError(
+            f"table {name!r} columns have unequal lengths"
+        )
+    frozen: list[RecurrenceColumn] = []
+    for column_name, values in columns.items():
+        if values.flags.owndata and values.flags.c_contiguous:
+            owned = values
+        else:
+            owned = np.array(values, dtype=values.dtype, order="C", copy=True)
+        owned.flags.writeable = False
+        frozen.append(RecurrenceColumn(column_name, owned))
+    return RecurrenceColumnarTable(name, row_count, tuple(frozen))
+
+
+def _decode_flat_strings(
+    ranges: RecurrenceColumnarTable,
+    values: RecurrenceColumnarTable,
+) -> tuple[str, ...]:
+    _validate_flat_ranges(ranges, values.row_count, "string catalog")
+    flat = values.column("value")
+    result: list[str] = []
+    for row in range(ranges.row_count):
+        start = int(ranges.column("start")[row])
+        count = int(ranges.column("count")[row])
+        try:
+            result.append(bytes(flat[start : start + count]).decode("utf-8"))
+        except UnicodeDecodeError as error:
+            raise RecurrenceColumnarInputError(
+                "flat string catalog contains invalid UTF-8"
+            ) from error
+    return tuple(result)
+
+
+def _column_dtype(table_name: str, column_name: str) -> np.dtype[Any]:
+    key = (table_name, column_name)
+    if key in _U8_COLUMN_KEYS:
+        return _U8
+    if key in _U64_COLUMN_KEYS:
+        return _U64
+    if key in _I32_COLUMN_KEYS:
+        return _I32
+    return _U32
+
+
+def _validate_flat_ranges(
+    ranges: RecurrenceColumnarTable,
+    value_count: int,
+    context: str,
+) -> None:
+    cursor = 0
+    for row in range(ranges.row_count):
+        start = int(ranges.column("start")[row])
+        count = int(ranges.column("count")[row])
+        if start != cursor:
+            raise RecurrenceColumnarInputError(
+                f"{context} ranges are not contiguous and canonical"
+            )
+        stop = start + count
+        if stop > value_count:
+            raise RecurrenceColumnarInputError(
+                f"{context} range references values outside its flat catalog"
+            )
+        cursor = stop
+    if cursor != value_count:
+        raise RecurrenceColumnarInputError(
+            f"{context} does not account for every flat value"
+        )
+
+
+def _validate_parent_ranges(
+    table: RecurrenceColumnarTable,
+    start_column: str,
+    count_column: str,
+    child_count: int,
+    context: str,
+) -> None:
+    cursor = 0
+    for row in range(table.row_count):
+        start = int(table.column(start_column)[row])
+        count = int(table.column(count_column)[row])
+        if start != cursor or start + count > child_count:
+            raise RecurrenceColumnarInputError(
+                f"{context} ranges are not contiguous or are out of bounds"
+            )
+        cursor = start + count
+    if cursor != child_count:
+        raise RecurrenceColumnarInputError(
+            f"{context} ranges do not cover every child row"
+        )
+
+
+def _validate_dense_ids(table: RecurrenceColumnarTable, column_name: str) -> None:
+    expected = np.arange(table.row_count, dtype=_U32)
+    if not np.array_equal(table.column(column_name), expected):
+        raise RecurrenceColumnarInputError(
+            f"table {table.name!r} column {column_name!r} is not dense"
+        )
+
+
+def _validate_bounded_columns(
+    table: RecurrenceColumnarTable,
+    columns: Sequence[str],
+    bound: int,
+) -> None:
+    for column_name in columns:
+        values = table.column(column_name)
+        if values.size and int(values.max()) >= bound:
+            raise RecurrenceColumnarInputError(
+                f"{table.name}.{column_name} references an absent row"
+            )
+
+
+def _validate_fraction(numerator: int, denominator: int, context: str) -> None:
+    if isinstance(numerator, bool) or not isinstance(numerator, int):
+        raise TypeError(f"{context} numerator must be an integer")
+    if isinstance(denominator, bool) or not isinstance(denominator, int):
+        raise TypeError(f"{context} denominator must be an integer")
+    if denominator <= 0:
+        raise RecurrenceColumnarInputError(f"{context} denominator must be positive")
+    if numerator == 0 and denominator != 1:
+        raise RecurrenceColumnarInputError(f"{context} zero must be encoded as 0/1")
+    if math.gcd(abs(numerator), denominator) != 1:
+        raise RecurrenceColumnarInputError(f"{context} must be reduced")
+
+
+def _nonempty_text(value: str, context: str) -> str:
+    if not isinstance(value, str):
+        raise TypeError(f"{context} must be a string")
+    if not value:
+        raise RecurrenceColumnarInputError(f"{context} must not be empty")
+    return value
+
+
+def _sha256_bytes(value: str, context: str) -> bytes:
+    if (
+        not isinstance(value, str)
+        or len(value) != 64
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise RecurrenceColumnarInputError(f"{context} must be a lowercase SHA-256")
+    return bytes.fromhex(value)
+
+
+def _validate_nonnegative_mask(value: int, context: str) -> None:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{context} must be an integer")
+    if value < 0:
+        raise RecurrenceColumnarInputError(f"{context} must be nonnegative")
+
+
+def _validate_u32_sequence(values: Sequence[int], context: str) -> None:
+    for index, value in enumerate(values):
+        _checked_u32(value, f"{context}[{index}]")
+
+
+def _validate_permutation(values: Sequence[int], size: int, context: str) -> None:
+    if tuple(sorted(values)) != tuple(range(size)):
+        raise RecurrenceColumnarInputError(
+            f"{context} must be a permutation of [0, {size})"
+        )
+
+
+def _validate_source_contract_permutation(
+    external_legs: Sequence[RecurrenceExternalLegV1],
+    permutation: Sequence[int],
+    context: str,
+) -> None:
+    for representative_slot, target_slot in enumerate(permutation):
+        representative = external_legs[representative_slot]
+        target = external_legs[target_slot]
+        if representative.is_initial != target.is_initial:
+            raise RecurrenceColumnarInputError(
+                f"{context} maps source slot {representative_slot} across the "
+                "initial/final crossing boundary"
+            )
+        representative_contracts = {
+            state.source_template_id: (
+                state.momentum_sign,
+                state.crossing_phase.canonical_key,
+            )
+            for state in representative.source_states
+        }
+        target_contracts = {
+            state.source_template_id: (
+                state.momentum_sign,
+                state.crossing_phase.canonical_key,
+            )
+            for state in target.source_states
+        }
+        if representative_contracts != target_contracts:
+            raise RecurrenceColumnarInputError(
+                f"{context} maps source slot {representative_slot} onto slot "
+                f"{target_slot} with a different source crossing contract"
+            )
+
+
+def _require_index(value: int, bound: int, context: str) -> int:
+    result = _checked_u32(value, context)
+    if result >= bound:
+        raise RecurrenceColumnarInputError(
+            f"{context} {result} is outside [0, {bound})"
+        )
+    return result
+
+
+def _checked_u32(value: int, context: str) -> int:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, int)
+        or not 0 <= value <= MISSING_U32
+    ):
+        raise RecurrenceColumnarInputError(f"{context} does not fit u32: {value!r}")
+    return value
+
+
+def _checked_u64(value: int, context: str) -> int:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, int)
+        or not 0 <= value < 1 << 64
+    ):
+        raise RecurrenceColumnarInputError(f"{context} does not fit u64: {value!r}")
+    return value
+
+
+def _checked_i32(value: int, context: str) -> int:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, int)
+        or not -(1 << 31) <= value < 1 << 31
+    ):
+        raise RecurrenceColumnarInputError(f"{context} does not fit i32: {value!r}")
+    return value
+
+
+def _checked_concrete_spin_state(value: int, context: str) -> int:
+    result = _checked_i32(value, context)
+    if result == _DYNAMIC_UNION_SOURCE_SPIN_STATE:
+        raise RecurrenceColumnarInputError(
+            f"{context} uses the reserved dynamic-union sentinel"
+        )
+    return result
+
+
+def _hash_text(digest: Any, value: str) -> None:
+    encoded = value.encode("utf-8")
+    digest.update(len(encoded).to_bytes(8, "little"))
+    digest.update(encoded)
+
+
+def _hash_columnar_tables(
+    digest: Any,
+    tables: Sequence[RecurrenceColumnarTable],
+) -> None:
+    digest.update(len(tables).to_bytes(8, "little"))
+    for table in tables:
+        _hash_text(digest, table.name)
+        digest.update(table.row_count.to_bytes(8, "little"))
+        digest.update(len(table.columns).to_bytes(4, "little"))
+        for column in table.columns:
+            _hash_text(digest, column.name)
+            _hash_text(digest, column.values.dtype.str)
+            digest.update(len(column.values.shape).to_bytes(1, "little"))
+            for dimension in column.values.shape:
+                digest.update(int(dimension).to_bytes(8, "little"))
+            digest.update(column.values.tobytes(order="C"))
+
+
+def _decode_pairing_strings(payload: Any) -> tuple[str, ...]:
+    ranges = payload.table("string_ranges")
+    values = payload.table("string_bytes").column("value")
+    decoded: list[str] = []
+    for row in range(ranges.row_count):
+        start = int(ranges.column("start")[row])
+        count = int(ranges.column("count")[row])
+        try:
+            decoded.append(bytes(values[start : start + count]).decode("utf-8"))
+        except UnicodeDecodeError as error:
+            raise RecurrenceColumnarInputError(
+                "fermion-pairing string catalog is not valid UTF-8"
+            ) from error
+    return tuple(decoded)
+
+
+__all__ = [
+    "MISSING_U32",
+    "RECURRENCE_BUILDER_INPUT_ABI",
+    "RECURRENCE_BUILDER_INPUT_SCHEMA_VERSION",
+    "ExactComplexRationalV1",
+    "LCColorSectorKind",
+    "RecurrenceBuilderInputV1",
+    "RecurrenceBuilderLogicalInputV1",
+    "RecurrenceColumn",
+    "RecurrenceColumnarInputError",
+    "RecurrenceColumnarTable",
+    "RecurrenceCouplingLimitV1",
+    "RecurrenceExternalLegV1",
+    "RecurrenceLCFlowLayout",
+    "RecurrenceLCOpenStringV1",
+    "RecurrenceNormalizationV1",
+    "RecurrenceParameterProjectionV1",
+    "RecurrencePhysicalLCSectorV1",
+    "RecurrencePublicLCFlowV1",
+    "RecurrenceReplayPartitionV1",
+    "RecurrenceReplayTargetV1",
+    "RecurrenceSelectedSourceCoverageV1",
+    "RecurrenceSemanticDigestV1",
+    "RecurrenceSemanticTemplateReferenceV1",
+    "RecurrenceSourceStateV1",
+    "build_recurrence_builder_input_v1",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/recurrence_fermion_pairing.py b/pyamplicol/src/pyamplicol/generation/recurrence_fermion_pairing.py
new file mode 100644
index 0000000000..05a84c197b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/recurrence_fermion_pairing.py
@@ -0,0 +1,801 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact external-fermion pairing rules for recurrence closure reconstruction.
+
+The catalog in this module is intentionally process-local and bounded.  It
+uses canonical process roles to bind external source slots to model-owned
+current-state contracts, then enumerates only species-compatible Wick
+pairings.  Particle numbers are used solely to bind a process leg to its
+authenticated state contract; all physics matching uses the contract's
+species, antiparticle relation, statistics, orientation, and LC color shape.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import itertools
+import json
+import math
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from typing import Final, Literal, TypeVar, cast
+
+from pyamplicol.models.recurrence_template import (
+    CurrentStateTemplateV1,
+    ExactComplexRationalV1,
+    QuantumFlowTemplateV1,
+)
+from pyamplicol.processes.ir import CanonicalProcessIR, ProcessLegIR
+
+FermionColorOrientation = Literal["fundamental", "antifundamental"]
+_ValueT = TypeVar("_ValueT")
+
+NO_FERMION_LINE: Final = 0xFFFF_FFFF
+PAIRING_PROOF_ALGORITHM: Final = "canonical-external-fermion-pairing-v1"
+
+
+class RecurrenceFermionPairingError(ValueError):
+    """A process/model contract cannot define a bounded exact pairing catalog."""
+
+
+@dataclass(frozen=True, slots=True)
+class FermionPairingLimitsV1:
+    """Explicit guards against factorial closure-rule materialization."""
+
+    max_endpoints: int = 16
+    max_pairings_per_species: int = 720
+    max_total_rules: int = 4096
+
+    def __post_init__(self) -> None:
+        for name, value in (
+            ("max_endpoints", self.max_endpoints),
+            ("max_pairings_per_species", self.max_pairings_per_species),
+            ("max_total_rules", self.max_total_rules),
+        ):
+            if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+                raise ValueError(f"{name} must be a positive integer")
+
+
+@dataclass(frozen=True, slots=True)
+class ExternalFermionEndpointRowV1:
+    """One colored external fermion bound to canonical model state contracts."""
+
+    endpoint_id: int
+    source_slot: int
+    public_label: int
+    species_class_id: int
+    species_id: str
+    particle_orientation: str
+    color_orientation: FermionColorOrientation
+    state_template_ids: tuple[str, ...]
+    anti_state_template_ids: tuple[str, ...]
+    basis_ids: tuple[str, ...]
+    color_representations: tuple[int, ...]
+    contract_digest: str
+
+
+@dataclass(frozen=True, slots=True)
+class FermionPairingClassRowV1:
+    """One model-compatible fundamental/antifundamental endpoint set."""
+
+    class_id: int
+    species_class_id: int
+    species_id: str
+    fundamental_source_slots: tuple[int, ...]
+    antifundamental_source_slots: tuple[int, ...]
+    reference_pairings: tuple[tuple[int, int], ...]
+    pairing_count: int
+    proof_digest: str
+
+
+@dataclass(frozen=True, slots=True)
+class FermionPairingRuleRowV1:
+    """One exact product of species-local Wick pairings."""
+
+    rule_id: int
+    class_pairing_indices: tuple[tuple[int, int], ...]
+    endpoint_pairings: tuple[tuple[int, int], ...]
+    source_slot_permutation: tuple[int, ...]
+    lineage_by_source_slot: tuple[int, ...]
+    fermion_parity: int
+    exact_factor: ExactComplexRationalV1
+    multiplicity: int
+    proof_algorithm: str
+    proof_digest: str
+
+
+@dataclass(frozen=True, slots=True)
+class FermionPairingCatalogV1:
+    """Immutable endpoint, pairing-class, and closure reconstruction rows."""
+
+    process_key: str
+    source_count: int
+    endpoints: tuple[ExternalFermionEndpointRowV1, ...]
+    pairing_classes: tuple[FermionPairingClassRowV1, ...]
+    rules: tuple[FermionPairingRuleRowV1, ...]
+    topology_digest: str
+    semantic_digest: str
+
+
+@dataclass(frozen=True, slots=True)
+class FermionPairingRootEndpointV1:
+    """One compact endpoint retained before any pairing is selected."""
+
+    source_slot: int
+    color_orientation: FermionColorOrientation
+    contract_digest: str
+
+
+@dataclass(frozen=True, slots=True)
+class FermionPairingRootClassV1:
+    """One model-proven pairing class without factorial rule expansion."""
+
+    species: str
+    proof_digest: str
+    fundamental_source_slots: tuple[int, ...]
+    antifundamental_source_slots: tuple[int, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class FermionPairingRootsV1:
+    """O(external-leg) roots from which one runtime pairing can be derived."""
+
+    endpoints: tuple[FermionPairingRootEndpointV1, ...]
+    classes: tuple[FermionPairingRootClassV1, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _EndpointContract:
+    source_slot: int
+    public_label: int
+    species_id: str
+    particle_orientation: str
+    color_orientation: FermionColorOrientation
+    state_template_ids: tuple[str, ...]
+    anti_state_template_ids: tuple[str, ...]
+    basis_ids: tuple[str, ...]
+    color_representations: tuple[int, ...]
+    contract_digest: str
+
+
+@dataclass(frozen=True, slots=True)
+class _LocalPairing:
+    index: int
+    antifundamental_slots: tuple[int, ...]
+    parity: int
+
+
+def build_recurrence_fermion_pairing_roots_v1(
+    process: CanonicalProcessIR,
+    current_states: Sequence[CurrentStateTemplateV1],
+    *,
+    quantum_flows: Sequence[QuantumFlowTemplateV1] = (),
+) -> FermionPairingRootsV1:
+    """Derive compact model-compatible pairing roots without enumerating rules.
+
+    The ordinary recurrence builder expands permutations because it publishes a
+    complete process schedule.  The on-the-fly lane instead selects one pairing
+    at runtime, so retaining endpoints and compatibility classes is sufficient
+    and scales linearly with the external process.  No resource-policy ceiling
+    belongs at this semantic projection boundary.
+    """
+
+    if not isinstance(process, CanonicalProcessIR):
+        raise TypeError("fermion pairing roots require a CanonicalProcessIR")
+    states = tuple(current_states)
+    if any(not isinstance(state, CurrentStateTemplateV1) for state in states):
+        raise TypeError(
+            "fermion pairing root current states must be CurrentStateTemplateV1 rows"
+        )
+    flows = tuple(quantum_flows)
+    if any(not isinstance(flow, QuantumFlowTemplateV1) for flow in flows):
+        raise TypeError(
+            "fermion pairing root quantum flows must be QuantumFlowTemplateV1 rows"
+        )
+
+    contracts = tuple(
+        contract
+        for source_slot, leg in enumerate(process.legs)
+        if (contract := _derive_endpoint(source_slot, leg, states)) is not None
+    )
+    compatibility_ids = _fermion_compatibility_ids(states, flows)
+    grouped: dict[str, list[_EndpointContract]] = {}
+    for contract in contracts:
+        species = compatibility_ids.get(contract.species_id, contract.species_id)
+        grouped.setdefault(species, []).append(contract)
+
+    classes: list[FermionPairingRootClassV1] = []
+    for species, group in sorted(
+        grouped.items(),
+        key=lambda item: tuple(sorted(row.source_slot for row in item[1])),
+    ):
+        fundamental = tuple(
+            sorted(
+                row.source_slot
+                for row in group
+                if row.color_orientation == "fundamental"
+            )
+        )
+        antifundamental = tuple(
+            sorted(
+                row.source_slot
+                for row in group
+                if row.color_orientation == "antifundamental"
+            )
+        )
+        if not fundamental or len(fundamental) != len(antifundamental):
+            raise RecurrenceFermionPairingError(
+                "incompatible fermion species endpoints: species contract "
+                f"{species!r} has {len(fundamental)} fundamental and "
+                f"{len(antifundamental)} antifundamental endpoints"
+            )
+        proof_payload = {
+            "algorithm": PAIRING_PROOF_ALGORITHM,
+            "antifundamental_source_slots": antifundamental,
+            "fundamental_source_slots": fundamental,
+            "reference_pairings": tuple(
+                zip(fundamental, antifundamental, strict=True)
+            ),
+            "species_contract_digests": tuple(
+                sorted(row.contract_digest for row in group)
+            ),
+        }
+        classes.append(
+            FermionPairingRootClassV1(
+                species=species,
+                proof_digest=_digest(proof_payload),
+                fundamental_source_slots=fundamental,
+                antifundamental_source_slots=antifundamental,
+            )
+        )
+
+    return FermionPairingRootsV1(
+        endpoints=tuple(
+            FermionPairingRootEndpointV1(
+                source_slot=contract.source_slot,
+                color_orientation=contract.color_orientation,
+                contract_digest=contract.contract_digest,
+            )
+            for contract in sorted(contracts, key=lambda row: row.source_slot)
+        ),
+        classes=tuple(classes),
+    )
+
+
+def build_recurrence_fermion_pairing_catalog_v1(
+    process: CanonicalProcessIR,
+    current_states: Sequence[CurrentStateTemplateV1],
+    *,
+    quantum_flows: Sequence[QuantumFlowTemplateV1] = (),
+    limits: FermionPairingLimitsV1 | None = None,
+) -> FermionPairingCatalogV1:
+    """Derive all bounded, model-compatible external-fermion pairings.
+
+    Color-singlet fermions do not define LC open-string endpoints and are
+    intentionally absent.  A process with no colored fermion endpoints has one
+    trivial parity-even rule, which is convenient for later closure lowering.
+
+    Fermion species connected by an authenticated model quantum flow share a
+    pairing class.  This is required for charged-current lines, where a
+    fundamental endpoint can carry a different species from its
+    antifundamental endpoint.  In the absence of such a witness the original
+    same-species rule remains exact.
+    """
+
+    if not isinstance(process, CanonicalProcessIR):
+        raise TypeError("fermion pairing requires a CanonicalProcessIR")
+    active_limits = limits or FermionPairingLimitsV1()
+    if not isinstance(active_limits, FermionPairingLimitsV1):
+        raise TypeError("fermion pairing limits must be FermionPairingLimitsV1")
+    states = tuple(current_states)
+    if any(not isinstance(state, CurrentStateTemplateV1) for state in states):
+        raise TypeError(
+            "fermion pairing current states must be CurrentStateTemplateV1 rows"
+        )
+    flows = tuple(quantum_flows)
+    if any(not isinstance(flow, QuantumFlowTemplateV1) for flow in flows):
+        raise TypeError(
+            "fermion pairing quantum flows must be QuantumFlowTemplateV1 rows"
+        )
+
+    contracts = tuple(
+        contract
+        for source_slot, leg in enumerate(process.legs)
+        if (contract := _derive_endpoint(source_slot, leg, states)) is not None
+    )
+    if len(contracts) > active_limits.max_endpoints:
+        raise RecurrenceFermionPairingError(
+            "colored fermion endpoint count exceeds the configured pairing bound: "
+            f"{len(contracts)} > {active_limits.max_endpoints}"
+        )
+
+    compatibility_ids = _fermion_compatibility_ids(states, flows)
+    grouped: dict[str, list[_EndpointContract]] = {}
+    for contract in contracts:
+        grouped.setdefault(
+            compatibility_ids.get(contract.species_id, contract.species_id),
+            [],
+        ).append(contract)
+    ordered_groups = sorted(
+        grouped.values(),
+        key=lambda group: tuple(sorted(item.source_slot for item in group)),
+    )
+    species_class_ids = {
+        compatibility_ids.get(group[0].species_id, group[0].species_id): class_id
+        for class_id, group in enumerate(ordered_groups)
+    }
+    endpoints = tuple(
+        ExternalFermionEndpointRowV1(
+            endpoint_id=endpoint_id,
+            source_slot=contract.source_slot,
+            public_label=contract.public_label,
+            species_class_id=species_class_ids[
+                compatibility_ids.get(contract.species_id, contract.species_id)
+            ],
+            species_id=compatibility_ids.get(
+                contract.species_id, contract.species_id
+            ),
+            particle_orientation=contract.particle_orientation,
+            color_orientation=contract.color_orientation,
+            state_template_ids=contract.state_template_ids,
+            anti_state_template_ids=contract.anti_state_template_ids,
+            basis_ids=contract.basis_ids,
+            color_representations=contract.color_representations,
+            contract_digest=contract.contract_digest,
+        )
+        for endpoint_id, contract in enumerate(
+            sorted(contracts, key=lambda item: item.source_slot)
+        )
+    )
+
+    pairing_classes: list[FermionPairingClassRowV1] = []
+    local_options: list[tuple[_LocalPairing, ...]] = []
+    total_rule_count = 1
+    for class_id, group in enumerate(ordered_groups):
+        class_species_id = compatibility_ids.get(
+            group[0].species_id, group[0].species_id
+        )
+        fundamental = tuple(
+            sorted(
+                item.source_slot
+                for item in group
+                if item.color_orientation == "fundamental"
+            )
+        )
+        antifundamental = tuple(
+            sorted(
+                item.source_slot
+                for item in group
+                if item.color_orientation == "antifundamental"
+            )
+        )
+        if len(fundamental) != len(antifundamental):
+            raise RecurrenceFermionPairingError(
+                "incompatible fermion species endpoints: species contract "
+                f"{class_species_id!r} has {len(fundamental)} fundamental "
+                f"and {len(antifundamental)} antifundamental endpoints"
+            )
+        pairing_count = math.factorial(len(fundamental))
+        if pairing_count > active_limits.max_pairings_per_species:
+            raise RecurrenceFermionPairingError(
+                "model-compatible fermion pairings exceed the configured bound: "
+                f"{pairing_count} > {active_limits.max_pairings_per_species}"
+            )
+        total_rule_count *= pairing_count
+        if total_rule_count > active_limits.max_total_rules:
+            raise RecurrenceFermionPairingError(
+                "combined fermion pairing rules exceed the configured bound: "
+                f"{total_rule_count} > {active_limits.max_total_rules}"
+            )
+
+        reference = tuple(zip(fundamental, antifundamental, strict=True))
+        class_payload = {
+            "algorithm": PAIRING_PROOF_ALGORITHM,
+            "antifundamental_source_slots": antifundamental,
+            "fundamental_source_slots": fundamental,
+            "reference_pairings": reference,
+            "species_contract_digests": tuple(
+                sorted(item.contract_digest for item in group)
+            ),
+        }
+        pairing_classes.append(
+            FermionPairingClassRowV1(
+                class_id=class_id,
+                species_class_id=class_id,
+                species_id=class_species_id,
+                fundamental_source_slots=fundamental,
+                antifundamental_source_slots=antifundamental,
+                reference_pairings=reference,
+                pairing_count=pairing_count,
+                proof_digest=_digest(class_payload),
+            )
+        )
+        local_options.append(
+            tuple(
+                _LocalPairing(
+                    index=index,
+                    antifundamental_slots=permutation,
+                    parity=_permutation_parity(antifundamental, permutation),
+                )
+                for index, permutation in enumerate(
+                    itertools.permutations(antifundamental)
+                )
+            )
+        )
+
+    rules = _build_rules(
+        tuple(pairing_classes),
+        tuple(local_options),
+        source_count=len(process.legs),
+    )
+    topology_payload = _topology_payload(
+        len(process.legs), endpoints, pairing_classes, rules
+    )
+    semantic_payload = {
+        "process_key": process.key,
+        "topology": topology_payload,
+        "endpoint_contracts": tuple(
+            {
+                "anti_state_template_ids": endpoint.anti_state_template_ids,
+                "basis_ids": endpoint.basis_ids,
+                "color_representations": endpoint.color_representations,
+                "contract_digest": endpoint.contract_digest,
+                "particle_orientation": endpoint.particle_orientation,
+                "species_id": endpoint.species_id,
+                "state_template_ids": endpoint.state_template_ids,
+            }
+            for endpoint in endpoints
+        ),
+    }
+    return FermionPairingCatalogV1(
+        process_key=process.key,
+        source_count=len(process.legs),
+        endpoints=endpoints,
+        pairing_classes=tuple(pairing_classes),
+        rules=rules,
+        topology_digest=_digest(topology_payload),
+        semantic_digest=_digest(semantic_payload),
+    )
+
+
+def _fermion_compatibility_ids(
+    states: tuple[CurrentStateTemplateV1, ...],
+    flows: tuple[QuantumFlowTemplateV1, ...],
+) -> dict[str, str]:
+    """Return exact model-proven fermion-line compatibility components."""
+
+    state_by_id = {state.template_id: state for state in states}
+    fermion_species = tuple(
+        sorted({state.species_id for state in states if state.statistics == "fermion"})
+    )
+    parent = {species_id: species_id for species_id in fermion_species}
+
+    def find(species_id: str) -> str:
+        root = species_id
+        while parent[root] != root:
+            root = parent[root]
+        while parent[species_id] != species_id:
+            next_species = parent[species_id]
+            parent[species_id] = root
+            species_id = next_species
+        return root
+
+    def union(left: str, right: str) -> None:
+        left_root = find(left)
+        right_root = find(right)
+        if left_root == right_root:
+            return
+        low, high = sorted((left_root, right_root))
+        parent[high] = low
+
+    for flow in flows:
+        referenced = (
+            *flow.input_state_template_ids,
+            flow.result_state_template_id,
+        )
+        try:
+            flow_states = tuple(state_by_id[template_id] for template_id in referenced)
+        except KeyError as error:
+            raise RecurrenceFermionPairingError(
+                "fermion pairing quantum flow references an unknown current-state "
+                f"template {error.args[0]!r}"
+            ) from error
+        species = tuple(
+            sorted(
+                {
+                    state.species_id
+                    for state in flow_states
+                    if state.statistics == "fermion"
+                }
+            )
+        )
+        if len(species) == 2:
+            union(*species)
+
+    components: dict[str, list[str]] = {}
+    for species_id in fermion_species:
+        components.setdefault(find(species_id), []).append(species_id)
+    result: dict[str, str] = {}
+    for members in components.values():
+        canonical_members = tuple(sorted(members))
+        compatibility_id = (
+            canonical_members[0]
+            if len(canonical_members) == 1
+            else f"model-fermion-transition-component:{_digest(canonical_members)}"
+        )
+        result.update(
+            (species_id, compatibility_id) for species_id in canonical_members
+        )
+    return result
+
+
+def _derive_endpoint(
+    source_slot: int,
+    leg: ProcessLegIR,
+    states: tuple[CurrentStateTemplateV1, ...],
+) -> _EndpointContract | None:
+    statistics_is_fermion = leg.statistics == "fermion"
+    family_is_fermion = leg.wavefunction_family == "fermion"
+    if statistics_is_fermion != family_is_fermion:
+        raise RecurrenceFermionPairingError(
+            f"external leg {leg.label} has inconsistent fermion contracts"
+        )
+    if not statistics_is_fermion:
+        return None
+    if leg.color_role == "singlet":
+        return None
+    if leg.color_role not in {"fundamental", "antifundamental"}:
+        raise RecurrenceFermionPairingError(
+            f"fermion leg {leg.label} has unsupported LC color role {leg.color_role!r}"
+        )
+    if leg.outgoing_pdg is None:
+        raise RecurrenceFermionPairingError(
+            f"fermion leg {leg.label} has no concrete outgoing state identifier"
+        )
+
+    candidates = tuple(
+        state
+        for state in states
+        if state.particle_id == leg.outgoing_pdg
+        and state.statistics == "fermion"
+        and state.auxiliary_kind is None
+    )
+    if not candidates:
+        raise RecurrenceFermionPairingError(
+            f"fermion leg {leg.label} has no canonical current-state contract"
+        )
+    species = _one_value(
+        (state.species_id for state in candidates),
+        f"fermion leg {leg.label} species",
+    )
+    orientation = _one_value(
+        (state.orientation for state in candidates),
+        f"fermion leg {leg.label} particle orientation",
+    )
+    anti_particle_id = _one_value(
+        (state.anti_particle_id for state in candidates),
+        f"fermion leg {leg.label} antiparticle state",
+    )
+    expected_shape = {
+        "fundamental": "fundamental-open-string",
+        "antifundamental": "antifundamental-open-string",
+    }[leg.color_role]
+    if any(state.lc_color_shape_kind != expected_shape for state in candidates):
+        raise RecurrenceFermionPairingError(
+            f"fermion leg {leg.label} color role disagrees with its state contract"
+        )
+    if leg.source_orientation != "inclusive" and orientation != leg.source_orientation:
+        raise RecurrenceFermionPairingError(
+            f"fermion leg {leg.label} source orientation disagrees with its state "
+            "contract"
+        )
+    if orientation not in {"particle", "antiparticle"}:
+        raise RecurrenceFermionPairingError(
+            "self-conjugate or inclusive fermion pairing is not certified"
+        )
+
+    anti_orientation = "antiparticle" if orientation == "particle" else "particle"
+    anti_candidates = tuple(
+        state
+        for state in states
+        if state.particle_id == anti_particle_id
+        and state.anti_particle_id == leg.outgoing_pdg
+        and state.species_id == species
+        and state.statistics == "fermion"
+        and state.orientation == anti_orientation
+        and state.auxiliary_kind is None
+    )
+    if not anti_candidates:
+        raise RecurrenceFermionPairingError(
+            f"fermion leg {leg.label} has no involutive antiparticle state contract"
+        )
+
+    state_template_ids = tuple(sorted(state.template_id for state in candidates))
+    anti_state_template_ids = tuple(
+        sorted(state.template_id for state in anti_candidates)
+    )
+    basis_ids = tuple(sorted({state.basis for state in candidates}))
+    color_representations = tuple(
+        sorted({state.color_representation for state in candidates})
+    )
+    payload = {
+        "anti_state_contract_digests": tuple(
+            sorted(state.semantic_digest for state in anti_candidates)
+        ),
+        "color_orientation": leg.color_role,
+        "public_label": leg.label,
+        "source_slot": source_slot,
+        "state_contract_digests": tuple(
+            sorted(state.semantic_digest for state in candidates)
+        ),
+    }
+    return _EndpointContract(
+        source_slot=source_slot,
+        public_label=int(leg.label),
+        species_id=species,
+        particle_orientation=orientation,
+        color_orientation=cast(FermionColorOrientation, leg.color_role),
+        state_template_ids=state_template_ids,
+        anti_state_template_ids=anti_state_template_ids,
+        basis_ids=basis_ids,
+        color_representations=color_representations,
+        contract_digest=_digest(payload),
+    )
+
+
+def _build_rules(
+    pairing_classes: tuple[FermionPairingClassRowV1, ...],
+    local_options: tuple[tuple[_LocalPairing, ...], ...],
+    *,
+    source_count: int,
+) -> tuple[FermionPairingRuleRowV1, ...]:
+    combinations: Sequence[tuple[_LocalPairing, ...]] = (
+        tuple(itertools.product(*local_options)) if local_options else ((),)
+    )
+    rules: list[FermionPairingRuleRowV1] = []
+    for rule_id, selected in enumerate(combinations):
+        endpoint_pairings: list[tuple[int, int]] = []
+        source_permutation = list(range(source_count))
+        parity = 1
+        class_pairing_indices: list[tuple[int, int]] = []
+        for pairing_class, local in zip(pairing_classes, selected, strict=True):
+            class_pairing_indices.append((pairing_class.class_id, local.index))
+            parity *= local.parity
+            endpoint_pairings.extend(
+                zip(
+                    pairing_class.fundamental_source_slots,
+                    local.antifundamental_slots,
+                    strict=True,
+                )
+            )
+            for reference_slot, selected_slot in zip(
+                pairing_class.antifundamental_source_slots,
+                local.antifundamental_slots,
+                strict=True,
+            ):
+                source_permutation[reference_slot] = selected_slot
+        endpoint_pairings.sort()
+        lineage = [NO_FERMION_LINE] * source_count
+        for line_id, (fundamental_slot, antifundamental_slot) in enumerate(
+            endpoint_pairings
+        ):
+            lineage[fundamental_slot] = line_id
+            lineage[antifundamental_slot] = line_id
+        rule_payload = {
+            "algorithm": PAIRING_PROOF_ALGORITHM,
+            "class_pairing_indices": tuple(class_pairing_indices),
+            "endpoint_pairings": tuple(endpoint_pairings),
+            "fermion_parity": parity,
+            "lineage_by_source_slot": tuple(lineage),
+            "source_slot_permutation": tuple(source_permutation),
+        }
+        rules.append(
+            FermionPairingRuleRowV1(
+                rule_id=rule_id,
+                class_pairing_indices=tuple(class_pairing_indices),
+                endpoint_pairings=tuple(endpoint_pairings),
+                source_slot_permutation=tuple(source_permutation),
+                lineage_by_source_slot=tuple(lineage),
+                fermion_parity=parity,
+                exact_factor=ExactComplexRationalV1(parity, 1, 0, 1),
+                multiplicity=1,
+                proof_algorithm=PAIRING_PROOF_ALGORITHM,
+                proof_digest=_digest(rule_payload),
+            )
+        )
+    return tuple(rules)
+
+
+def _permutation_parity(
+    reference: tuple[int, ...],
+    candidate: tuple[int, ...],
+) -> int:
+    if len(reference) != len(candidate) or set(reference) != set(candidate):
+        raise RecurrenceFermionPairingError(
+            "fermion parity requires a permutation of the reference endpoints"
+        )
+    ranks = {value: index for index, value in enumerate(reference)}
+    permutation = tuple(ranks[value] for value in candidate)
+    inversions = sum(
+        left > right
+        for index, left in enumerate(permutation)
+        for right in permutation[index + 1 :]
+    )
+    return -1 if inversions % 2 else 1
+
+
+def _one_value(values: Iterable[_ValueT], context: str) -> _ValueT:
+    materialized = tuple(values)
+    unique = set(materialized)
+    if len(unique) != 1:
+        raise RecurrenceFermionPairingError(
+            f"{context} must be uniquely defined, found {materialized!r}"
+        )
+    return materialized[0]
+
+
+def _topology_payload(
+    source_count: int,
+    endpoints: tuple[ExternalFermionEndpointRowV1, ...],
+    pairing_classes: Sequence[FermionPairingClassRowV1],
+    rules: tuple[FermionPairingRuleRowV1, ...],
+) -> dict[str, object]:
+    return {
+        "algorithm": PAIRING_PROOF_ALGORITHM,
+        "source_count": source_count,
+        "endpoints": tuple(
+            (
+                endpoint.source_slot,
+                endpoint.public_label,
+                endpoint.species_class_id,
+                endpoint.color_orientation,
+            )
+            for endpoint in endpoints
+        ),
+        "pairing_classes": tuple(
+            (
+                row.class_id,
+                row.fundamental_source_slots,
+                row.antifundamental_source_slots,
+                row.reference_pairings,
+                row.pairing_count,
+            )
+            for row in pairing_classes
+        ),
+        "rules": tuple(
+            (
+                rule.class_pairing_indices,
+                rule.endpoint_pairings,
+                rule.source_slot_permutation,
+                rule.lineage_by_source_slot,
+                rule.fermion_parity,
+            )
+            for rule in rules
+        ),
+    }
+
+
+def _digest(payload: object) -> str:
+    encoded = json.dumps(
+        payload,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+__all__ = [
+    "NO_FERMION_LINE",
+    "PAIRING_PROOF_ALGORITHM",
+    "ExternalFermionEndpointRowV1",
+    "FermionPairingCatalogV1",
+    "FermionPairingClassRowV1",
+    "FermionPairingLimitsV1",
+    "FermionPairingRootClassV1",
+    "FermionPairingRootEndpointV1",
+    "FermionPairingRootsV1",
+    "FermionPairingRuleRowV1",
+    "RecurrenceFermionPairingError",
+    "build_recurrence_fermion_pairing_catalog_v1",
+    "build_recurrence_fermion_pairing_roots_v1",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/recurrence_numerical_current_warmup.py b/pyamplicol/src/pyamplicol/generation/recurrence_numerical_current_warmup.py
new file mode 100644
index 0000000000..94f27ec804
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/recurrence_numerical_current_warmup.py
@@ -0,0 +1,4150 @@
+# SPDX-License-Identifier: 0BSD
+"""Authenticated high-precision current reuse for recurrence Direct plans.
+
+The first native lowering is an unpublished baseline.  This module evaluates
+that exact plan at disjoint Decimal/Symbolica probe domains, certifies only
+equal, opposite, and zero relations, and emits canonical evidence for a
+second native lowering.  No binary64 runtime result participates in discovery.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import pickle
+import struct
+import tempfile
+import time
+import zlib
+from collections import defaultdict
+from collections.abc import Iterator, Mapping, Sequence
+from dataclasses import dataclass, field, replace
+from decimal import ROUND_HALF_EVEN, Decimal, localcontext
+from fractions import Fraction
+from math import copysign, isfinite
+from types import MappingProxyType
+from typing import TYPE_CHECKING, BinaryIO, Literal, cast
+
+from pyamplicol.api.errors import ArtifactError
+from pyamplicol.models.base import Model
+from pyamplicol.runtime.recurrence_exact._execution import (
+    _evaluate_contracted_point,
+    _evaluate_replay_point,
+    _evaluate_union_point,
+)
+from pyamplicol.runtime.recurrence_exact._plan import _RecurrenceExactPlan
+from pyamplicol.runtime.recurrence_exact._plan_v2 import (
+    DIRECT_NONE_U32,
+    _Current,
+    _RecurrenceExactSectionsV1,
+)
+from pyamplicol.runtime.symbolica_exact import _ComplexDecimal
+
+from .dag_equivalence import (
+    NUMERICAL_CURRENT_RELATION_WARNING,
+    NUMERICAL_CURRENT_RELATION_WARNING_CODE,
+)
+from .numerical_candidate_index import (
+    NumericalObservationCandidateIndex,
+    build_numerical_observation_candidate_index,
+    numerical_observation_tolerance_window_ids,
+)
+from .validation import (
+    ValidationPointRecord,
+    build_process_validation_point,
+    rotate_validation_point,
+)
+
+if TYPE_CHECKING:
+    from pyamplicol.processes.ir import CanonicalProcessIR
+
+_CAPTURE_ABI = "pyamplicol-recurrence-current-observation-capture-v2"
+_EVIDENCE_ABI = "pyamplicol-recurrence-numerical-current-evidence-v3"
+_SOURCE_ABI = "pyamplicol-recurrence-numerical-current-source-v3"
+_WARMUP_ABI = "pyamplicol-recurrence-numerical-current-warmup-v1"
+_RELATION_SET_ABI = "pyamplicol-authenticated-numerical-current-relation-set-v2"
+_OBSERVATION_BATCH_ABI = "pyamplicol-recurrence-current-observation-batch-v2"
+_PARAMETER_CONTEXT_ABI = "pyamplicol-recurrence-parameter-context-v1"
+_PARAMETER_SCHEMA_ABI = "pyamplicol-recurrence-runtime-parameter-schema-v2"
+_RELATION_OBSERVATION_ABI = "pyamplicol-recurrence-relation-observation-v2"
+_DECISION_CHAIN_ABI = "pyamplicol-recurrence-numerical-decision-chain-v1"
+_REJECTION_CHAIN_ABI = "pyamplicol-recurrence-rejected-numerical-decision-chain-v1"
+_PERSISTED_EVIDENCE_ABI = "pyamplicol-recurrence-numerical-persisted-evidence-v1"
+# Select a sequential spool for large captures; this is not a memory ceiling.
+_RAW_EVIDENCE_MEMORY_TARGET_BYTES = 1 << 30
+_COMPRESSED_EVIDENCE_MAGIC = b"PACNCEZ1"
+_COMPRESSED_EVIDENCE_HEADER = struct.Struct(">8sQ32s")
+_COMPRESSED_EVIDENCE_ENCODING = "zlib-canonical-json-v1"
+_RAW_EVIDENCE_ENCODING = "canonical-json-v3"
+_SPOOLED_CAPTURE_COMPRESSION_RESERVE_BYTES = 8 << 20
+_SPOOLED_CANDIDATE_INDEX_BYTES_PER_CURRENT = 1_024
+# The producer-side peak ends when the canonical bytes have been encoded and
+# the complete Decimal graphs are detached.  The per-scalar allowance covers
+# the Python Decimal/tuple capture graph and encoder temporaries; the row
+# allowance covers capture dictionaries and rows. These estimates select
+# resident or spooled storage; native validates the observations independently
+# without imposing a fixed memory ceiling.
+_RAW_EVIDENCE_SCALAR_RESIDENT_BYTES = 640
+_RAW_EVIDENCE_ROW_RESIDENT_BYTES = 512
+_RAW_EVIDENCE_FIXED_RESERVE_BYTES = 32 << 20
+_RAW_EVIDENCE_WIRE_PEAK_COPIES = 2
+_MIN_RAW_EVIDENCE_WIRE_BYTES = 1 << 20
+_RECURRENCE_CERTIFICATE_ALGORITHM = (
+    "authenticated-independent-recursive-decimal-raw-probes-v2"
+)
+_MAX_REJECTED_DIAGNOSTICS = 32
+_CANDIDATE_INDEX_ALGORITHM = "complete-contract-anchor-tolerance-window-v1"
+_APPLICATION_SCOPE_ABI = "pyamplicol-recurrence-numerical-relation-application-scope-v1"
+NUMERICAL_RELATION_CORRECTNESS_ABI = (
+    "pyamplicol-numerical-current-relation-correctness-v1"
+)
+NUMERICAL_RELATION_FALLBACK_ABI = "pyamplicol-numerical-current-reuse-fallback-v1"
+EVIDENCE_ENVELOPE_FALLBACK_REASON = "evidence-envelope-fallback"
+EVIDENCE_ENVELOPE_FALLBACK_WARNING = (
+    "Numerical-current reuse was disabled because its optional evidence "
+    "geometry exceeds the bounded memory envelope; recurrence generation "
+    "continues without numerical relations."
+)
+
+_RelationKind = Literal["equal", "opposite", "zero"]
+_Mode = Literal["diagnostic", "certified-reuse"]
+_Point = tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]
+_CurrentContract = tuple[object, ...]
+_EvidenceEncoding = Literal["canonical-json-v3", "zlib-canonical-json-v1"]
+_Residuals = tuple[Fraction, Fraction, Fraction]
+_ResidualStrings = tuple[str, str, str]
+_Tolerance = Decimal | Fraction
+
+
+@dataclass(frozen=True, slots=True)
+class _RawEvidenceStorageGeometry:
+    scalar_count: int
+    row_count: int
+    canonical_byte_limit: int | None
+    encoding: _EvidenceEncoding
+    producer_resident_upper_bound: int
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceNumericalEvidenceGeometry:
+    """Allocation-free shape of one optional numerical-evidence capture."""
+
+    current_count: int
+    component_count: int
+    candidate_probe_count: int
+    verification_probe_count: int
+    runtime_parameter_count: int
+    scalar_count: int
+    row_count: int
+
+    @classmethod
+    def from_counts(
+        cls,
+        *,
+        current_count: int,
+        component_count: int,
+        candidate_probe_count: int,
+        verification_probe_count: int,
+        runtime_parameter_count: int,
+    ) -> RecurrenceNumericalEvidenceGeometry:
+        values = (
+            current_count,
+            component_count,
+            candidate_probe_count,
+            verification_probe_count,
+            runtime_parameter_count,
+        )
+        if (
+            any(type(value) is not int or value < 0 for value in values)
+            or candidate_probe_count == 0
+            or verification_probe_count == 0
+        ):
+            raise ValueError("recurrence raw-evidence probe geometry is invalid")
+        point_count = candidate_probe_count + verification_probe_count
+        return cls(
+            current_count=current_count,
+            component_count=component_count,
+            candidate_probe_count=candidate_probe_count,
+            verification_probe_count=verification_probe_count,
+            runtime_parameter_count=runtime_parameter_count,
+            scalar_count=(
+                2 * component_count * point_count
+                + runtime_parameter_count * point_count
+            ),
+            row_count=current_count * 2 + runtime_parameter_count,
+        )
+
+    def to_json_dict(self) -> dict[str, int]:
+        return {
+            "current_count": self.current_count,
+            "component_count": self.component_count,
+            "candidate_probe_count": self.candidate_probe_count,
+            "verification_probe_count": self.verification_probe_count,
+            "runtime_parameter_count": self.runtime_parameter_count,
+            "scalar_count": self.scalar_count,
+            "row_count": self.row_count,
+        }
+
+    def spooled_producer_resident_upper_bound(self) -> int:
+        """Recompute the sequential-spool producer bound for this geometry."""
+
+        return _spooled_capture_memory_upper_bound(
+            current_count=self.current_count,
+            component_count=self.component_count,
+            maximum_probe_count=max(
+                self.candidate_probe_count,
+                self.verification_probe_count,
+            ),
+            runtime_parameter_count=self.runtime_parameter_count,
+        )
+
+
+class RecurrenceNumericalEvidenceEnvelopeExceeded(ValueError):
+    """Optional recurrence evidence cannot fit its authenticated envelope."""
+
+    def __init__(
+        self,
+        geometry: RecurrenceNumericalEvidenceGeometry,
+        *,
+        memory_envelope_bytes: int,
+        spooled_producer_resident_bytes: int,
+        raw_reason: str,
+    ) -> None:
+        self.geometry = geometry
+        self.memory_envelope_bytes = memory_envelope_bytes
+        self.spooled_producer_resident_bytes = spooled_producer_resident_bytes
+        self.raw_reason = raw_reason
+        values = geometry.to_json_dict()
+        super().__init__(
+            "recurrence optional numerical evidence cannot fit its bounded "
+            "resident or transport envelope "
+            f"(currents={values['current_count']}, "
+            f"components={values['component_count']}, "
+            f"candidate_points={values['candidate_probe_count']}, "
+            f"verification_points={values['verification_probe_count']}, "
+            f"runtime_parameters={values['runtime_parameter_count']}, "
+            f"scalars={values['scalar_count']}, rows={values['row_count']}, "
+            "spooled_producer_resident="
+            f"{spooled_producer_resident_bytes}, raw_reason={raw_reason})"
+        )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "reason": EVIDENCE_ENVELOPE_FALLBACK_REASON,
+            "memory_envelope_bytes": self.memory_envelope_bytes,
+            "spooled_producer_resident_bytes": (self.spooled_producer_resident_bytes),
+            "geometry": self.geometry.to_json_dict(),
+        }
+
+
+class _RawEvidenceWireEnvelopeExceeded(ValueError):
+    """The validated raw-wire shape cannot fit its bounded envelope."""
+
+
+class _CanonicalEvidenceCapacityExceeded(ValueError):
+    """A valid optional-evidence encoding cannot fit its bounded transport."""
+
+
+class _IndependentVerificationRequired(Exception):
+    """Candidate screening found a hypothesis that needs independent probes."""
+
+
+_NATIVE_OPTIONAL_EVIDENCE_CAPACITY_MARKERS = (
+    "raw numerical evidence exceeds the explicit pre-metadata 1 GiB resident "
+    "memory envelope",
+    "compressed numerical evidence exceeds the explicit pre-shape 1 GiB resident "
+    "memory envelope",
+    "compressed numerical relation evidence exceeds the explicit native 1 GiB "
+    "resident memory envelope",
+    "raw numerical evidence exceeds the streaming 1 GiB resident memory envelope",
+    "raw numerical capture geometry leaves no minimum canonical wire reserve "
+    "inside the 1 GiB resident memory envelope",
+    "raw numerical sequential-spool capture geometry exceeds the explicit 1 GiB "
+    "resident memory envelope",
+    "could not reserve bounded decompressed numerical evidence",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class _WarmupStaticContext:
+    current_dimensions: Mapping[int, int]
+    current_contracts: tuple[_CurrentContract, ...]
+    runtime_defaults: tuple[Decimal, ...]
+    runtime_parameter_schema: Mapping[str, object]
+    runtime_parameter_schema_sha256: str
+    source_semantics: Mapping[str, object]
+    source_semantics_sha256: str
+
+
+class _SpooledObservationMapping(Mapping[int, tuple[_ComplexDecimal, ...]]):
+    """Trusted temporary row store with bounded one-row materialization."""
+
+    def __init__(
+        self,
+        observations: Mapping[int, Sequence[_ComplexDecimal]],
+        *,
+        candidate_indexes: Mapping[
+            _CurrentContract,
+            NumericalObservationCandidateIndex[Fraction],
+        ]
+        | None = None,
+    ) -> None:
+        self._stream: BinaryIO = tempfile.TemporaryFile(  # noqa: SIM115
+            prefix="pyamplicol-recurrence-current-observations-",
+        )
+        self._rows: dict[int, tuple[int, int]] = {}
+        self._candidate_indexes_row: tuple[int, int] | None = None
+        self._closed = False
+        try:
+            for current_id in sorted(observations):
+                offset = self._stream.tell()
+                pickle.dump(
+                    tuple(observations[current_id]),
+                    self._stream,
+                    protocol=pickle.HIGHEST_PROTOCOL,
+                )
+                self._rows[current_id] = (
+                    offset,
+                    self._stream.tell() - offset,
+                )
+            if candidate_indexes is not None:
+                offset = self._stream.tell()
+                pickle.dump(
+                    dict(candidate_indexes),
+                    self._stream,
+                    protocol=pickle.HIGHEST_PROTOCOL,
+                )
+                self._candidate_indexes_row = (
+                    offset,
+                    self._stream.tell() - offset,
+                )
+            self._stream.flush()
+        except BaseException:
+            self.close()
+            raise
+
+    @property
+    def candidate_indexes(
+        self,
+    ) -> (
+        Mapping[
+            _CurrentContract,
+            NumericalObservationCandidateIndex[Fraction],
+        ]
+        | None
+    ):
+        if self._candidate_indexes_row is None:
+            return None
+        if self._closed:
+            raise RuntimeError("recurrence observation spool is closed")
+        offset, length = self._candidate_indexes_row
+        self._stream.seek(offset)
+        payload = self._stream.read(length)
+        if len(payload) != length:
+            raise ValueError("recurrence candidate-index spool row is truncated")
+        return cast(
+            dict[
+                _CurrentContract,
+                NumericalObservationCandidateIndex[Fraction],
+            ],
+            pickle.loads(payload),
+        )
+
+    def __getitem__(self, current_id: int) -> tuple[_ComplexDecimal, ...]:
+        if self._closed:
+            raise RuntimeError("recurrence observation spool is closed")
+        try:
+            offset, length = self._rows[current_id]
+        except KeyError:
+            raise KeyError(current_id) from None
+        self._stream.seek(offset)
+        payload = self._stream.read(length)
+        if len(payload) != length:
+            raise ValueError("recurrence observation spool row is truncated")
+        values = pickle.loads(payload)
+        if not isinstance(values, tuple):
+            raise ValueError("recurrence observation spool row is malformed")
+        return cast(tuple[_ComplexDecimal, ...], values)
+
+    def __iter__(self) -> Iterator[int]:
+        return iter(self._rows)
+
+    def __len__(self) -> int:
+        return len(self._rows)
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        self._stream.close()
+
+
+class _CanonicalJsonStreamValue:
+    """A value that writes canonical JSON without first building a JSON graph."""
+
+    def iter_canonical_json_chunks(self) -> Iterator[bytes]:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True, slots=True)
+class _ObservationValuesStream(_CanonicalJsonStreamValue):
+    values: Sequence[_ComplexDecimal]
+
+    def iter_canonical_json_chunks(self) -> Iterator[bytes]:
+        yield b"["
+        for index, (real, imaginary) in enumerate(self.values):
+            if index:
+                yield b","
+            yield b"["
+            yield from _iter_canonical_json_chunks(_decimal_string(real))
+            yield b","
+            yield from _iter_canonical_json_chunks(_decimal_string(imaginary))
+            yield b"]"
+        yield b"]"
+
+
+@dataclass(frozen=True, slots=True)
+class _ObservationRowsStream(_CanonicalJsonStreamValue):
+    observations: Mapping[int, Sequence[_ComplexDecimal]]
+    dimensions: Mapping[int, int]
+
+    def iter_canonical_json_chunks(self) -> Iterator[bytes]:
+        yield b"["
+        for index, current_id in enumerate(sorted(self.observations)):
+            if index:
+                yield b","
+            yield from _iter_canonical_json_chunks(
+                {
+                    "current_id": current_id,
+                    "dimension": self.dimensions[current_id],
+                    "values": _ObservationValuesStream(self.observations[current_id]),
+                }
+            )
+        yield b"]"
+
+
+@dataclass(frozen=True, slots=True)
+class _DimensionRowsStream(_CanonicalJsonStreamValue):
+    dimensions: Mapping[int, int]
+
+    def iter_canonical_json_chunks(self) -> Iterator[bytes]:
+        yield b"["
+        for index, (current_id, dimension) in enumerate(
+            sorted(self.dimensions.items())
+        ):
+            if index:
+                yield b","
+            yield from _iter_canonical_json_chunks(
+                {"current_id": current_id, "dimension": dimension}
+            )
+        yield b"]"
+
+
+@dataclass(frozen=True, slots=True)
+class _CertificateRowsStream(_CanonicalJsonStreamValue):
+    certificates: Sequence[RecurrenceNumericalCurrentCertificate]
+
+    def iter_canonical_json_chunks(self) -> Iterator[bytes]:
+        yield b"["
+        for index, certificate in enumerate(self.certificates):
+            if index:
+                yield b","
+            yield from _iter_canonical_json_chunks(certificate.to_json_dict())
+        yield b"]"
+
+
+@dataclass(frozen=True, slots=True)
+class _MappingRowsStream(_CanonicalJsonStreamValue):
+    certificates: Sequence[RecurrenceNumericalCurrentCertificate]
+
+    def iter_canonical_json_chunks(self) -> Iterator[bytes]:
+        yield b"["
+        for index, certificate in enumerate(self.certificates):
+            if index:
+                yield b","
+            yield from _iter_canonical_json_chunks(_mapping_payload(certificate))
+        yield b"]"
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceCurrentObservationCapture:
+    """Complete point-major exact current observations."""
+
+    precision_digits: int
+    points: tuple[ValidationPointRecord, ...]
+    point_sha256s: tuple[str, ...]
+    kinematic_sha256s: tuple[str, ...]
+    kinematic_binary64: tuple[tuple[str, ...], ...]
+    selector_contexts: tuple[object, ...]
+    context_sha256s: tuple[str, ...]
+    parameter_contexts: tuple[tuple[Decimal, ...], ...]
+    parameter_context_sha256s: tuple[str, ...]
+    observations: Mapping[int, tuple[_ComplexDecimal, ...]]
+    current_dimensions: Mapping[int, int]
+    runtime_parameter_schema_sha256: str
+    source_semantics_sha256: str
+    observation_batch_sha256: str
+    capture_contract_sha256: str
+    context_policy: str
+    full_current_count: int | None = None
+    complete_observations_retained: bool = True
+
+    @property
+    def point_count(self) -> int:
+        return len(self.points)
+
+    @property
+    def current_count(self) -> int:
+        return (
+            len(self.observations)
+            if self.full_current_count is None
+            else self.full_current_count
+        )
+
+    def detached_for_replay(
+        self,
+        current_ids: Sequence[int],
+    ) -> RecurrenceCurrentObservationCapture:
+        """Retain only rows needed by the persisted certificate replay."""
+
+        selected = tuple(sorted(set(current_ids)))
+        if any(current_id not in self.observations for current_id in selected):
+            raise ValueError(
+                "certificate replay references an absent recurrence current"
+            )
+        return replace(
+            self,
+            observations={
+                current_id: self.observations[current_id] for current_id in selected
+            },
+            full_current_count=self.current_count,
+            complete_observations_retained=False,
+        )
+
+    def to_provenance_dict(self) -> dict[str, object]:
+        return {
+            "abi": _CAPTURE_ABI,
+            "precision_digits": self.precision_digits,
+            "point_count": self.point_count,
+            "point_sha256s": list(self.point_sha256s),
+            "kinematic_sha256s": list(self.kinematic_sha256s),
+            "parameter_contexts": [
+                [_decimal_string(value) for value in context]
+                for context in self.parameter_contexts
+            ],
+            "parameter_context_sha256s": list(self.parameter_context_sha256s),
+            "context_sha256s": list(self.context_sha256s),
+            "points": [point.to_mapping() for point in self.points],
+            "current_count": self.current_count,
+            "runtime_parameter_schema_sha256": (self.runtime_parameter_schema_sha256),
+            "source_semantics_sha256": self.source_semantics_sha256,
+            "observation_batch_sha256": self.observation_batch_sha256,
+            "capture_contract_sha256": self.capture_contract_sha256,
+            "context_policy": self.context_policy,
+            "complete_current_components": True,
+            "point_major": True,
+            "current_dimensions_sha256": _canonical_sha256(
+                {
+                    str(current_id): dimension
+                    for current_id, dimension in sorted(self.current_dimensions.items())
+                }
+            ),
+            "evaluator": "recurrence-direct-plan-decimal-symbolica-exact",
+        }
+
+    def to_evidence_dict(self) -> dict[str, object]:
+        if not self.complete_observations_retained:
+            raise ValueError(
+                "detached recurrence observations cannot recreate raw evidence"
+            )
+        return {
+            **self.to_provenance_dict(),
+            "kinematic_binary64": [list(row) for row in self.kinematic_binary64],
+            "selector_contexts": list(self.selector_contexts),
+            "current_dimensions": [
+                {"current_id": current_id, "dimension": dimension}
+                for current_id, dimension in sorted(self.current_dimensions.items())
+            ],
+            "observations": [
+                {
+                    "current_id": current_id,
+                    "dimension": self.current_dimensions[current_id],
+                    "values": [
+                        [_decimal_string(real), _decimal_string(imaginary)]
+                        for real, imaginary in self.observations[current_id]
+                    ],
+                }
+                for current_id in sorted(self.observations)
+            ],
+        }
+
+    def to_certificate_replay_dict(
+        self,
+        current_ids: Sequence[int],
+    ) -> dict[str, object]:
+        """Return deduplicated raw rows needed to replay applied certificates."""
+
+        selected = tuple(sorted(set(current_ids)))
+        if any(current_id not in self.observations for current_id in selected):
+            raise ValueError(
+                "certificate replay references an absent recurrence current"
+            )
+        observation_rows: list[object] = []
+        for current_id in selected:
+            row = {
+                "current_id": current_id,
+                "dimension": self.current_dimensions[current_id],
+                "values": [
+                    [_decimal_string(real), _decimal_string(imaginary)]
+                    for real, imaginary in self.observations[current_id]
+                ],
+            }
+            observation_rows.append(row)
+        return {
+            "abi": "pyamplicol-recurrence-certificate-capture-replay-v1",
+            "precision_digits": self.precision_digits,
+            "points": [point.to_mapping() for point in self.points],
+            "kinematic_binary64": [list(row) for row in self.kinematic_binary64],
+            "selector_contexts": list(self.selector_contexts),
+            "parameter_contexts": [
+                [_decimal_string(value) for value in context]
+                for context in self.parameter_contexts
+            ],
+            "point_sha256s": list(self.point_sha256s),
+            "kinematic_sha256s": list(self.kinematic_sha256s),
+            "selector_context_sha256s": list(self.context_sha256s),
+            "parameter_context_sha256s": list(self.parameter_context_sha256s),
+            "runtime_parameter_schema_sha256": (self.runtime_parameter_schema_sha256),
+            "source_semantics_sha256": self.source_semantics_sha256,
+            "certificate_current_ids": list(selected),
+            "observations": observation_rows,
+            "full_batch_commitment": {
+                "current_count": self.current_count,
+                "current_dimensions_sha256": _canonical_sha256(
+                    {
+                        str(current_id): dimension
+                        for current_id, dimension in sorted(
+                            self.current_dimensions.items()
+                        )
+                    }
+                ),
+                "observation_batch_sha256": self.observation_batch_sha256,
+                "capture_contract_sha256": self.capture_contract_sha256,
+            },
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceNumericalCurrentCertificate:
+    """Canonical candidate plus independent-verification evidence."""
+
+    current_id: int
+    representative_id: int | None
+    execution_representative_id: int
+    relation_kind: _RelationKind
+    factor: tuple[int, int]
+    source_semantics_sha256: str
+    precision_digits: int
+    seed: int
+    relative_tolerance: float
+    absolute_tolerance: float
+    candidate_probe_count: int
+    verification_probe_count: int
+    current_dimension: int
+    runtime_parameter_schema_sha256: str
+    candidate_capture_sha256: str
+    verification_capture_sha256: str
+    candidate_maximum_absolute_residual: Fraction
+    candidate_maximum_relative_residual: Fraction
+    candidate_maximum_tolerance_ratio: Fraction
+    verification_maximum_absolute_residual: Fraction
+    verification_maximum_relative_residual: Fraction
+    verification_maximum_tolerance_ratio: Fraction
+    candidate_observations_sha256: str
+    verification_observations_sha256: str
+    probe_contract_sha256: str
+    proof_sha256: str
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "algorithm": _RECURRENCE_CERTIFICATE_ALGORITHM,
+            "proof_kind": "authenticated-numerical",
+            "relation_kind": self.relation_kind,
+            "current_id": self.current_id,
+            "representative_id": self.representative_id,
+            "execution_representative_id": self.execution_representative_id,
+            "factor_integer": list(self.factor),
+            "source_semantics_sha256": self.source_semantics_sha256,
+            "precision_digits": self.precision_digits,
+            "seed": self.seed,
+            "relative_tolerance_binary64": self.relative_tolerance.hex(),
+            "absolute_tolerance_binary64": self.absolute_tolerance.hex(),
+            "candidate_probe_count": self.candidate_probe_count,
+            "verification_probe_count": self.verification_probe_count,
+            "current_dimension": self.current_dimension,
+            "runtime_parameter_schema_sha256": (self.runtime_parameter_schema_sha256),
+            "candidate_capture_sha256": self.candidate_capture_sha256,
+            "verification_capture_sha256": self.verification_capture_sha256,
+            "candidate_maximum_absolute_residual": _fraction_string(
+                self.candidate_maximum_absolute_residual
+            ),
+            "candidate_maximum_relative_residual": _fraction_string(
+                self.candidate_maximum_relative_residual
+            ),
+            "candidate_maximum_tolerance_ratio": _fraction_string(
+                self.candidate_maximum_tolerance_ratio
+            ),
+            "verification_maximum_absolute_residual": _fraction_string(
+                self.verification_maximum_absolute_residual
+            ),
+            "verification_maximum_relative_residual": _fraction_string(
+                self.verification_maximum_relative_residual
+            ),
+            "verification_maximum_tolerance_ratio": _fraction_string(
+                self.verification_maximum_tolerance_ratio
+            ),
+            "candidate_observations_sha256": (self.candidate_observations_sha256),
+            "verification_observations_sha256": (self.verification_observations_sha256),
+            "probe_contract_sha256": self.probe_contract_sha256,
+            "proof_sha256": self.proof_sha256,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceNumericalCurrentWarmupResult:
+    """One unpublished-baseline discovery transaction."""
+
+    requested_mode: _Mode
+    effective_mode: _Mode
+    color_accuracy: str
+    source_semantics_sha256: str
+    runtime_parameter_schema: Mapping[str, object]
+    candidate_capture: RecurrenceCurrentObservationCapture
+    verification_capture: RecurrenceCurrentObservationCapture | None
+    certificates: tuple[RecurrenceNumericalCurrentCertificate, ...]
+    evidence_json: bytes
+    evidence_transport_bytes: int
+    evidence_encoding: _EvidenceEncoding | None
+    evidence_canonical_bytes: int
+    discovery_report: Mapping[str, object]
+    application_validation: Mapping[str, object]
+    generation_profile_timings: Mapping[str, float] = field(
+        default_factory=dict,
+        compare=False,
+        repr=False,
+    )
+
+    @property
+    def applied_relation_count(self) -> int:
+        return len(self.applied_certificates)
+
+    @property
+    def applied_certificates(self) -> tuple[RecurrenceNumericalCurrentCertificate, ...]:
+        """Keep discovery complete while applying only supported relations."""
+
+        if self.effective_mode != "certified-reuse":
+            return ()
+        return _applicable_numerical_certificates(
+            self.certificates,
+            application_scope=cast(
+                Mapping[str, object], self.discovery_report["application_scope"]
+            ),
+        )
+
+    @property
+    def warning_required(self) -> bool:
+        return self.applied_relation_count > 0
+
+    @property
+    def effective_mode_reason(self) -> str | None:
+        """Explain a conservative requested-to-effective mode downgrade."""
+
+        if self.effective_mode == self.requested_mode:
+            return None
+        application_scope = cast(
+            Mapping[str, object],
+            self.discovery_report["application_scope"],
+        )
+        if cast(Sequence[int], application_scope["suppressed_selector_domain_ids"]):
+            return "multi-helicity-all-flow-member-scope-unproven"
+        if any(
+            certificate.relation_kind == "opposite" for certificate in self.certificates
+        ):
+            return "contracted-opposite-binary64-disabled"
+        raise AssertionError("recurrence numerical mode changed without a reason")
+
+    def with_application_validation(
+        self,
+        payload: Mapping[str, object],
+    ) -> RecurrenceNumericalCurrentWarmupResult:
+        return replace(self, application_validation=dict(payload))
+
+    def without_evidence_transport(
+        self,
+    ) -> RecurrenceNumericalCurrentWarmupResult:
+        """Release the native-only transport after second-pass lowering."""
+
+        return replace(self, evidence_json=b"")
+
+    def close(self) -> None:
+        """Close any trusted temporary observation stores owned by the result."""
+
+        for capture in (self.candidate_capture, self.verification_capture):
+            if capture is not None and isinstance(
+                capture.observations,
+                _SpooledObservationMapping,
+            ):
+                capture.observations.close()
+
+    def to_json_dict(self) -> dict[str, object]:
+        if not self.certificates:
+            state = "no_certified_numerical_relation"
+        elif self.effective_mode == "certified-reuse":
+            state = "authenticated-numerical-applied"
+        else:
+            state = "authenticated-numerical-diagnostic-only"
+        warning = _warning_payload(self.warning_required)
+        relation_correctness = numerical_relation_correctness_payload(
+            self.applied_relation_count
+        )
+        applied_current_ids = (
+            tuple(
+                current_id
+                for certificate in self.applied_certificates
+                for current_id in (
+                    certificate.current_id,
+                    certificate.representative_id,
+                )
+                if current_id is not None
+            )
+            if self.effective_mode == "certified-reuse"
+            else ()
+        )
+        persisted_evidence = {
+            "abi": _PERSISTED_EVIDENCE_ABI,
+            "generation_raw_evidence_bytes": self.evidence_canonical_bytes,
+            "generation_evidence_transport_bytes": self.evidence_transport_bytes,
+            "generation_evidence_encoding": self.evidence_encoding,
+            "raw_evidence_retained": False,
+            "runtime_parameter_schema": dict(self.runtime_parameter_schema),
+            "runtime_parameter_schema_sha256": (
+                self.candidate_capture.runtime_parameter_schema_sha256
+            ),
+            "candidate_capture": self.candidate_capture.to_certificate_replay_dict(
+                applied_current_ids
+            ),
+            "verification_capture": (
+                None
+                if self.verification_capture is None
+                else self.verification_capture.to_certificate_replay_dict(
+                    applied_current_ids,
+                )
+            ),
+            "full_census": {
+                "inspected_current_count": self.discovery_report[
+                    "inspected_current_count"
+                ],
+                "tested_hypothesis_count": self.discovery_report[
+                    "tested_hypothesis_count"
+                ],
+                "candidate_index": dict(
+                    cast(
+                        Mapping[str, object],
+                        self.discovery_report["candidate_index"],
+                    )
+                ),
+                "numerical_candidate_count": self.discovery_report[
+                    "numerical_candidate_count"
+                ],
+                "verification_rejected_count": self.discovery_report[
+                    "verification_rejected_count"
+                ],
+                "uncertified_candidate_count": self.discovery_report[
+                    "verification_rejected_count"
+                ],
+                "certified_relation_count": len(self.certificates),
+                "rejected_hypothesis_count": self.discovery_report[
+                    "rejected_hypothesis_count"
+                ],
+                "decision_sha256": self.discovery_report["decision_sha256"],
+                "rejection_decision_sha256": self.discovery_report[
+                    "rejection_decision_sha256"
+                ],
+                "certificate_set_sha256": _certificate_set_sha256(self.certificates),
+            },
+        }
+        persisted_encoded = _bounded_canonical_json_bytes(
+            persisted_evidence,
+            byte_limit=None,
+            label="recurrence persisted numerical evidence",
+        )
+        persisted_evidence["measured_payload_bytes"] = len(persisted_encoded)
+        persisted_evidence["sha256"] = _canonical_sha256(persisted_evidence)
+        application_scope = dict(
+            cast(
+                Mapping[str, object],
+                self.discovery_report["application_scope"],
+            )
+        )
+        application_scope["effective_mode_reason"] = self.effective_mode_reason
+        return {
+            "schema_version": 1,
+            "abi": _WARMUP_ABI,
+            "requested_mode": self.requested_mode,
+            "effective_mode": self.effective_mode,
+            "effective_mode_reason": self.effective_mode_reason,
+            "effective_reuse_state": (
+                "enabled"
+                if self.effective_mode == "certified-reuse"
+                or self.requested_mode == "diagnostic"
+                else "disabled"
+            ),
+            "state": state,
+            "scope": {
+                "execution_mode": "recurrence",
+                "color_accuracy": self.color_accuracy,
+                "representation": "recurrence-direct-plan-v2",
+            },
+            "source_semantics": {
+                "abi": _SOURCE_ABI,
+                "sha256": self.source_semantics_sha256,
+            },
+            "candidate_capture": self.candidate_capture.to_provenance_dict(),
+            "verification_capture": (
+                None
+                if self.verification_capture is None
+                else self.verification_capture.to_provenance_dict()
+            ),
+            "application_capture": (
+                self.application_validation.get("application_capture")
+            ),
+            "application_validation": dict(self.application_validation),
+            "application_scope": application_scope,
+            "persisted_numerical_evidence": persisted_evidence,
+            "discovery": dict(self.discovery_report),
+            "application": {
+                "schema_version": 1,
+                "abi": _RELATION_SET_ABI,
+                "requested_mode": self.requested_mode,
+                "effective_mode": self.effective_mode,
+                "state": state,
+                "certificate_replay": {
+                    "algorithm": _RECURRENCE_CERTIFICATE_ALGORITHM,
+                    "status": (
+                        "verified"
+                        if self.certificates
+                        else "no_certified_numerical_relation"
+                    ),
+                    "certificate_set_sha256": _certificate_set_sha256(
+                        self.certificates
+                    ),
+                },
+                "certified_relation_count": len(self.certificates),
+                "applied_relation_count": self.applied_relation_count,
+                "relation_kind_counts": {
+                    kind: sum(
+                        certificate.relation_kind == kind
+                        for certificate in self.certificates
+                    )
+                    for kind in ("equal", "opposite", "zero")
+                },
+                "certificates": [
+                    certificate.to_json_dict() for certificate in self.certificates
+                ],
+                "mappings": [
+                    _mapping_payload(certificate) for certificate in self.certificates
+                ],
+                "warning": warning,
+            },
+            "certified_relation_count": len(self.certificates),
+            "applied_relation_count": self.applied_relation_count,
+            "relation_correctness": relation_correctness,
+            "warning": warning,
+        }
+
+
+def run_recurrence_numerical_current_warmup(
+    plan: _RecurrenceExactPlan,
+    *,
+    candidate_points: Sequence[ValidationPointRecord],
+    verification_points: Sequence[ValidationPointRecord],
+    mode: _Mode,
+    color_accuracy: str,
+    precision_digits: int,
+    seed: int,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+) -> RecurrenceNumericalCurrentWarmupResult:
+    """Capture, discover, certify, and encode a second-pass relation set."""
+
+    if mode not in {"diagnostic", "certified-reuse"}:
+        raise ValueError(
+            "recurrence numerical current warm-up requires diagnostic or "
+            "certified-reuse mode"
+        )
+    _validated_tolerances(relative_tolerance, absolute_tolerance)
+    relative_tolerance = float(relative_tolerance)
+    absolute_tolerance = float(absolute_tolerance)
+    generation_profile_timings: dict[str, float] = {}
+    geometry_started = time.perf_counter()
+    geometry = _select_raw_evidence_storage_geometry(
+        plan.sections,
+        candidate_probe_count=len(candidate_points),
+        verification_probe_count=len(verification_points),
+        runtime_parameter_count=len(plan.runtime_parameter_schema),
+    )
+    generation_profile_timings["warmup_geometry"] = (
+        time.perf_counter() - geometry_started
+    )
+    static_context_started = time.perf_counter()
+    static_context = _build_warmup_static_context(plan)
+    generation_profile_timings["warmup_static_context"] = (
+        time.perf_counter() - static_context_started
+    )
+    source_digest = static_context.source_semantics_sha256
+    runtime_parameter_schema = static_context.runtime_parameter_schema
+    runtime_parameter_schema_sha256 = static_context.runtime_parameter_schema_sha256
+    runtime_defaults = static_context.runtime_defaults
+    probe_policies = tuple(row.probe_policy for row in plan.runtime_parameter_schema)
+    candidate_parameter_contexts = _build_parameter_probe_contexts(
+        runtime_defaults,
+        probe_policies=probe_policies,
+        precision_digits=precision_digits,
+        seed=seed,
+        domain="candidate-current-parameter-probes-v1",
+        count=len(candidate_points),
+        include_defaults=True,
+    )
+    candidate_spool: _SpooledObservationMapping | None = None
+    verification_spool: _SpooledObservationMapping | None = None
+    evidence_spool: BinaryIO | None = None
+    try:
+        candidate_probe_timings: list[float] = []
+        candidate_capture_started = time.perf_counter()
+        candidate = _capture_recurrence_current_observations(
+            plan,
+            candidate_points,
+            precision_digits=precision_digits,
+            source_semantics_sha256=source_digest,
+            seed=seed,
+            domain="candidate-current-probes-v1",
+            parameter_contexts=candidate_parameter_contexts,
+            runtime_parameter_schema_sha256=runtime_parameter_schema_sha256,
+            static_context=static_context,
+            probe_timings=candidate_probe_timings,
+        )
+        generation_profile_timings["warmup_candidate_capture"] = (
+            time.perf_counter() - candidate_capture_started
+        )
+        generation_profile_timings.update(
+            {
+                f"warmup_candidate_probe_{index}": seconds
+                for index, seconds in enumerate(candidate_probe_timings)
+            }
+        )
+        candidate_index_started = time.perf_counter()
+        candidate_indexes: (
+            Mapping[
+                _CurrentContract,
+                NumericalObservationCandidateIndex[Fraction],
+            ]
+            | None
+        ) = _build_candidate_indexes(
+            plan.sections,
+            candidate.observations,
+            contracts=static_context.current_contracts,
+        )
+        generation_profile_timings["warmup_candidate_index"] = (
+            time.perf_counter() - candidate_index_started
+        )
+        candidate_preflight_started = time.perf_counter()
+        try:
+            certificates, discovery = _discover_relations(
+                plan.sections,
+                candidate,
+                None,
+                source_semantics_sha256=source_digest,
+                precision_digits=precision_digits,
+                seed=seed,
+                relative_tolerance=relative_tolerance,
+                absolute_tolerance=absolute_tolerance,
+                color_accuracy=color_accuracy,
+                contracts=static_context.current_contracts,
+                candidate_indexes=candidate_indexes,
+            )
+        except _IndependentVerificationRequired:
+            generation_profile_timings["warmup_candidate_preflight"] = (
+                time.perf_counter() - candidate_preflight_started
+            )
+        else:
+            generation_profile_timings["warmup_relation_discovery"] = (
+                time.perf_counter() - candidate_preflight_started
+            )
+            if certificates:
+                raise AssertionError(
+                    "candidate-only recurrence discovery produced certificates"
+                )
+            effective_mode = _effective_numerical_relation_mode(
+                plan.sections,
+                requested_mode=mode,
+                certificates=certificates,
+            )
+            candidate = candidate.detached_for_replay(())
+            return RecurrenceNumericalCurrentWarmupResult(
+                requested_mode=mode,
+                effective_mode=effective_mode,
+                color_accuracy=color_accuracy,
+                source_semantics_sha256=source_digest,
+                runtime_parameter_schema=runtime_parameter_schema,
+                candidate_capture=candidate,
+                verification_capture=None,
+                certificates=certificates,
+                evidence_json=b"",
+                evidence_transport_bytes=0,
+                evidence_encoding=None,
+                evidence_canonical_bytes=0,
+                discovery_report=discovery,
+                application_validation={
+                    "status": "not-required-no-applied-relations",
+                    "checked_current_count": 0,
+                    "checked_component_count": 0,
+                    "maximum_absolute_residual": None,
+                    "maximum_relative_residual": None,
+                    "maximum_tolerance_ratio": None,
+                    "application_capture": None,
+                },
+                generation_profile_timings=MappingProxyType(
+                    dict(generation_profile_timings)
+                ),
+            )
+        if geometry.encoding == _COMPRESSED_EVIDENCE_ENCODING:
+            candidate_spool_started = time.perf_counter()
+            candidate_spool = _SpooledObservationMapping(
+                candidate.observations,
+                candidate_indexes=candidate_indexes,
+            )
+            candidate = replace(candidate, observations=candidate_spool)
+            # The verification capture can itself be large.  Keep the exact
+            # reusable index on disk until relation discovery instead of
+            # retaining both resident captures and the index simultaneously.
+            candidate_indexes = None
+            generation_profile_timings["warmup_candidate_spool"] = (
+                time.perf_counter() - candidate_spool_started
+            )
+        verification_parameter_contexts = _build_parameter_probe_contexts(
+            runtime_defaults,
+            probe_policies=probe_policies,
+            precision_digits=precision_digits,
+            seed=seed,
+            domain="independent-verification-current-parameter-probes-v1",
+            count=len(verification_points),
+            include_defaults=False,
+        )
+        verification_probe_timings: list[float] = []
+        verification_capture_started = time.perf_counter()
+        verification = _capture_recurrence_current_observations(
+            plan,
+            verification_points,
+            precision_digits=precision_digits,
+            source_semantics_sha256=source_digest,
+            seed=seed,
+            domain="independent-verification-current-probes-v1",
+            parameter_contexts=verification_parameter_contexts,
+            runtime_parameter_schema_sha256=runtime_parameter_schema_sha256,
+            static_context=static_context,
+            probe_timings=verification_probe_timings,
+        )
+        generation_profile_timings["warmup_verification_capture"] = (
+            time.perf_counter() - verification_capture_started
+        )
+        generation_profile_timings.update(
+            {
+                f"warmup_verification_probe_{index}": seconds
+                for index, seconds in enumerate(verification_probe_timings)
+            }
+        )
+        if geometry.encoding == _COMPRESSED_EVIDENCE_ENCODING:
+            verification_spool_started = time.perf_counter()
+            verification_spool = _SpooledObservationMapping(verification.observations)
+            verification = replace(
+                verification,
+                observations=verification_spool,
+            )
+            generation_profile_timings["warmup_verification_spool"] = (
+                time.perf_counter() - verification_spool_started
+            )
+        _validate_independent_captures(candidate, verification)
+        discovery_started = time.perf_counter()
+        certificates, discovery = _discover_relations(
+            plan.sections,
+            candidate,
+            verification,
+            source_semantics_sha256=source_digest,
+            precision_digits=precision_digits,
+            seed=seed,
+            relative_tolerance=relative_tolerance,
+            absolute_tolerance=absolute_tolerance,
+            color_accuracy=color_accuracy,
+            contracts=static_context.current_contracts,
+            candidate_indexes=candidate_indexes,
+        )
+        generation_profile_timings["warmup_relation_discovery"] = (
+            time.perf_counter() - discovery_started
+        )
+        evidence_payload_started = time.perf_counter()
+        effective_mode = _effective_numerical_relation_mode(
+            plan.sections,
+            requested_mode=mode,
+            certificates=certificates,
+        )
+        evidence = _evidence_payload(
+            plan.sections,
+            mode=effective_mode,
+            source_semantics=static_context.source_semantics,
+            source_semantics_sha256=source_digest,
+            certificates=certificates,
+            discovery=discovery,
+            precision_digits=precision_digits,
+            seed=seed,
+            relative_tolerance=relative_tolerance,
+            absolute_tolerance=absolute_tolerance,
+            probe_count=candidate.point_count,
+            verification_probe_count=verification.point_count,
+            runtime_parameter_schema=runtime_parameter_schema,
+            candidate=candidate,
+            verification=verification,
+        )
+        generation_profile_timings["warmup_evidence_payload"] = (
+            time.perf_counter() - evidence_payload_started
+        )
+        evidence_serialization_started = time.perf_counter()
+        if geometry.encoding == _RAW_EVIDENCE_ENCODING:
+            encoded = _bounded_canonical_json_bytes(
+                evidence,
+                byte_limit=geometry.canonical_byte_limit,
+                label="recurrence numerical raw evidence",
+            )
+            canonical_byte_count = len(encoded)
+        else:
+            evidence_spool = tempfile.TemporaryFile(  # noqa: SIM115
+                prefix="pyamplicol-recurrence-evidence-",
+            )
+            canonical_byte_count = _write_compressed_canonical_evidence(
+                evidence,
+                evidence_spool,
+                canonical_byte_limit=geometry.canonical_byte_limit,
+            )
+            encoded = b""
+        generation_profile_timings["warmup_evidence_serialization"] = (
+            time.perf_counter() - evidence_serialization_started
+        )
+        replay_current_ids = (
+            tuple(
+                current_id
+                for certificate in _applicable_numerical_certificates(
+                    certificates,
+                    application_scope=cast(
+                        Mapping[str, object], discovery["application_scope"]
+                    ),
+                )
+                for current_id in (
+                    certificate.current_id,
+                    certificate.representative_id,
+                )
+                if current_id is not None
+            )
+            if effective_mode == "certified-reuse"
+            else ()
+        )
+        if not isinstance(candidate.observations, _SpooledObservationMapping):
+            candidate = candidate.detached_for_replay(replay_current_ids)
+            verification = verification.detached_for_replay(replay_current_ids)
+        else:
+            # Transfer both trusted row stores to the result. Certificate
+            # replay and application validation consume rows lazily, so the
+            # resident graph never grows with the number of relations.
+            candidate_spool = None
+            verification_spool = None
+        # The streamed evidence mapping owns wrappers pointing at the complete
+        # captures. Drop it before reading the compressed transport bytes.
+        del evidence
+        if evidence_spool is not None:
+            evidence_transport_started = time.perf_counter()
+            encoded = _read_compressed_evidence_spool(evidence_spool)
+            evidence_spool.close()
+            evidence_spool = None
+            generation_profile_timings["warmup_evidence_transport_read"] = (
+                time.perf_counter() - evidence_transport_started
+            )
+        return RecurrenceNumericalCurrentWarmupResult(
+            requested_mode=mode,
+            effective_mode=effective_mode,
+            color_accuracy=color_accuracy,
+            source_semantics_sha256=source_digest,
+            runtime_parameter_schema=runtime_parameter_schema,
+            candidate_capture=candidate,
+            verification_capture=verification,
+            certificates=certificates,
+            evidence_json=encoded,
+            evidence_transport_bytes=len(encoded),
+            evidence_encoding=geometry.encoding,
+            evidence_canonical_bytes=canonical_byte_count,
+            discovery_report=discovery,
+            application_validation={
+                "status": (
+                    "pending-second-pass-validation"
+                    if effective_mode == "certified-reuse" and certificates
+                    else "not-required-no-applied-relations"
+                ),
+                "checked_current_count": 0,
+                "checked_component_count": 0,
+                "maximum_absolute_residual": None,
+                "maximum_relative_residual": None,
+                "maximum_tolerance_ratio": None,
+                "application_capture": None,
+            },
+            generation_profile_timings=MappingProxyType(
+                dict(generation_profile_timings)
+            ),
+        )
+    finally:
+        if candidate_spool is not None:
+            candidate_spool.close()
+        if verification_spool is not None:
+            verification_spool.close()
+        if evidence_spool is not None:
+            evidence_spool.close()
+
+
+def build_recurrence_numerical_current_probe_points(
+    process: CanonicalProcessIR,
+    model: Model,
+    *,
+    process_id: str,
+    seed: int,
+    candidate_count: int,
+    verification_count: int,
+) -> tuple[
+    tuple[ValidationPointRecord, ...],
+    tuple[ValidationPointRecord, ...],
+]:
+    """Build disjoint deterministic physical points for recurrence probes."""
+
+    if (
+        type(seed) is not int
+        or seed < 0
+        or type(candidate_count) is not int
+        or candidate_count < 2
+        or type(verification_count) is not int
+        or verification_count < 2
+    ):
+        raise ValueError("recurrence numerical probe-point contract is invalid")
+
+    def points(domain: str, count: int) -> tuple[ValidationPointRecord, ...]:
+        return tuple(
+            rotate_validation_point(
+                build_process_validation_point(
+                    process,
+                    model,
+                    process_id=process_id,
+                    seed=_domain_seed(seed, domain=domain, index=index),
+                ),
+                rotation_seed=_domain_seed(
+                    seed,
+                    domain=f"{domain}:spatial-rotation-v1",
+                    index=index,
+                ),
+            )
+            for index in range(count)
+        )
+
+    candidate = points("candidate-current-probes-v1", candidate_count)
+    verification = points(
+        "independent-verification-current-probes-v1",
+        verification_count,
+    )
+    if any(not point.available for point in (*candidate, *verification)):
+        errors = tuple(
+            point.error for point in (*candidate, *verification) if not point.available
+        )
+        raise ValueError(
+            "recurrence numerical probe-point generation failed: "
+            + "; ".join(str(error) for error in errors)
+        )
+    candidate_hashes = {_kinematic_sha256(point) for point in candidate}
+    verification_hashes = {_kinematic_sha256(point) for point in verification}
+    if (
+        len(candidate_hashes) != len(candidate)
+        or len(verification_hashes) != len(verification)
+        or not candidate_hashes.isdisjoint(verification_hashes)
+    ):
+        raise ValueError("recurrence numerical probe domains are not independent")
+    return candidate, verification
+
+
+def validate_recurrence_numerical_current_application(
+    baseline: RecurrenceNumericalCurrentWarmupResult,
+    applied_plan: _RecurrenceExactPlan,
+    *,
+    baseline_plan: _RecurrenceExactPlan,
+    precision_digits: int,
+    seed: int,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+) -> RecurrenceNumericalCurrentWarmupResult:
+    """Fail closed unless every second-pass current replays on verification."""
+
+    if not baseline.applied_relation_count:
+        return baseline.with_application_validation(
+            {
+                "status": "not-required-no-applied-relations",
+                "checked_current_count": 0,
+                "checked_component_count": 0,
+                "maximum_absolute_residual": None,
+                "maximum_relative_residual": None,
+                "maximum_tolerance_ratio": None,
+                "application_capture": None,
+            }
+        )
+    verification_capture = baseline.verification_capture
+    if verification_capture is None:
+        raise ValueError(
+            "applied recurrence numerical relations lack verification observations"
+        )
+    reference_spool: _SpooledObservationMapping | None = None
+    try:
+        reference = capture_recurrence_current_observations(
+            baseline_plan,
+            verification_capture.points,
+            precision_digits=precision_digits,
+            source_semantics_sha256=baseline.source_semantics_sha256,
+            seed=seed,
+            domain="independent-verification-current-probes-v1",
+            parameter_contexts=verification_capture.parameter_contexts,
+            runtime_parameter_schema_sha256=(
+                verification_capture.runtime_parameter_schema_sha256
+            ),
+        )
+        _validate_recaptured_reference(
+            verification_capture,
+            reference,
+        )
+        reference_spool = _SpooledObservationMapping(reference.observations)
+        reference = replace(reference, observations=reference_spool)
+        applied = capture_recurrence_current_observations(
+            applied_plan,
+            verification_capture.points,
+            precision_digits=precision_digits,
+            source_semantics_sha256=baseline.source_semantics_sha256,
+            seed=seed,
+            domain="independent-verification-current-probes-v1",
+            parameter_contexts=verification_capture.parameter_contexts,
+            runtime_parameter_schema_sha256=(
+                verification_capture.runtime_parameter_schema_sha256
+            ),
+        )
+        validation = _validate_applied_observations(
+            reference,
+            applied,
+            relative_tolerance=relative_tolerance,
+            absolute_tolerance=absolute_tolerance,
+        )
+        validation["application_capture"] = applied.to_provenance_dict()
+        return baseline.with_application_validation(validation)
+    finally:
+        if reference_spool is not None:
+            reference_spool.close()
+
+
+def recurrence_numerical_current_opt_out_report(
+    sections: _RecurrenceExactSectionsV1,
+    *,
+    color_accuracy: str,
+) -> dict[str, object]:
+    """Return stable provenance without evaluating a single exact current."""
+
+    return {
+        "schema_version": 1,
+        "abi": _WARMUP_ABI,
+        "requested_mode": "off",
+        "effective_mode": "off",
+        "effective_reuse_state": "disabled",
+        "state": "disabled-by-user",
+        "scope": {
+            "execution_mode": "recurrence",
+            "color_accuracy": color_accuracy,
+            "representation": "recurrence-direct-plan-v2",
+        },
+        "source_semantics": {
+            "abi": _SOURCE_ABI,
+            "sha256": recurrence_numerical_source_semantics_sha256(sections),
+        },
+        "candidate_capture": None,
+        "verification_capture": None,
+        "application_capture": None,
+        "application_validation": {
+            "status": "disabled-by-user",
+            "checked_current_count": 0,
+            "checked_component_count": 0,
+            "maximum_absolute_residual": None,
+            "maximum_relative_residual": None,
+            "maximum_tolerance_ratio": None,
+            "application_capture": None,
+        },
+        "application_scope": {
+            "abi": _APPLICATION_SCOPE_ABI,
+            "policy": "disabled-by-user",
+            "layout": sections.strategy,
+            "suppressed_selector_domain_ids": [],
+            "contracted_opposite_application": "not-applicable",
+            "suppressed_current_count": 0,
+        },
+        "discovery": None,
+        "application": None,
+        "certified_relation_count": 0,
+        "applied_relation_count": 0,
+        "relation_correctness": numerical_relation_correctness_payload(0),
+        "warning": _warning_payload(False),
+    }
+
+
+def recurrence_numerical_current_envelope_fallback_report(
+    sections: _RecurrenceExactSectionsV1,
+    *,
+    color_accuracy: str,
+    requested_mode: _Mode,
+    outcome: RecurrenceNumericalEvidenceEnvelopeExceeded,
+) -> dict[str, object]:
+    """Publish the explicit reuse-off result of one safe geometry fallback."""
+
+    if requested_mode != "certified-reuse":
+        raise ValueError("the evidence-envelope fallback is limited to certified reuse")
+    fallback = outcome.to_json_dict()
+    warning = {
+        "required": True,
+        "emit": "once-per-generated-artifact",
+        "code": EVIDENCE_ENVELOPE_FALLBACK_REASON,
+        "message": EVIDENCE_ENVELOPE_FALLBACK_WARNING,
+    }
+    return {
+        "schema_version": 1,
+        "abi": _WARMUP_ABI,
+        "requested_mode": requested_mode,
+        "effective_mode": "off",
+        "effective_reuse_state": "disabled",
+        "state": "disabled-evidence-envelope-fallback",
+        "fallback": fallback,
+        "scope": {
+            "execution_mode": "recurrence",
+            "color_accuracy": color_accuracy,
+            "representation": "recurrence-direct-plan-v2",
+        },
+        "source_semantics": {
+            "abi": _SOURCE_ABI,
+            "sha256": recurrence_numerical_source_semantics_sha256(sections),
+        },
+        "candidate_capture": None,
+        "verification_capture": None,
+        "application_capture": None,
+        "application_validation": {
+            "status": "not-required-reuse-disabled",
+            "checked_current_count": 0,
+            "checked_component_count": 0,
+            "maximum_absolute_residual": None,
+            "maximum_relative_residual": None,
+            "maximum_tolerance_ratio": None,
+            "application_capture": None,
+        },
+        "application_scope": {
+            "abi": _APPLICATION_SCOPE_ABI,
+            "policy": "evidence-envelope-fallback",
+            "layout": sections.strategy,
+            "suppressed_selector_domain_ids": [],
+            "contracted_opposite_application": "not-applicable",
+            "suppressed_current_count": 0,
+        },
+        "discovery": None,
+        "application": None,
+        "certified_relation_count": 0,
+        "applied_relation_count": 0,
+        "relation_correctness": numerical_relation_correctness_payload(0),
+        "warning": warning,
+    }
+
+
+def capture_recurrence_current_observations(
+    plan: _RecurrenceExactPlan,
+    points: Sequence[ValidationPointRecord],
+    *,
+    precision_digits: int,
+    source_semantics_sha256: str,
+    seed: int,
+    domain: str,
+    parameter_contexts: Sequence[Sequence[Decimal]] | None = None,
+    runtime_parameter_schema_sha256: str | None = None,
+) -> RecurrenceCurrentObservationCapture:
+    """Evaluate every current before Direct-Arena stage recycling."""
+
+    return _capture_recurrence_current_observations(
+        plan,
+        points,
+        precision_digits=precision_digits,
+        source_semantics_sha256=source_semantics_sha256,
+        seed=seed,
+        domain=domain,
+        parameter_contexts=parameter_contexts,
+        runtime_parameter_schema_sha256=runtime_parameter_schema_sha256,
+        static_context=None,
+        probe_timings=None,
+    )
+
+
+def _capture_recurrence_current_observations(
+    plan: _RecurrenceExactPlan,
+    points: Sequence[ValidationPointRecord],
+    *,
+    precision_digits: int,
+    source_semantics_sha256: str,
+    seed: int,
+    domain: str,
+    parameter_contexts: Sequence[Sequence[Decimal]] | None,
+    runtime_parameter_schema_sha256: str | None,
+    static_context: _WarmupStaticContext | None,
+    probe_timings: list[float] | None,
+) -> RecurrenceCurrentObservationCapture:
+    records = tuple(points)
+    if (
+        type(precision_digits) is not int
+        or precision_digits < 80
+        or len(records) < 2
+        or any(not isinstance(point, ValidationPointRecord) for point in records)
+        or any(not point.available for point in records)
+        or len({point.process_id for point in records}) != 1
+    ):
+        raise ValueError("recurrence current capture point contract is invalid")
+    sections = plan.sections
+    dimensions = (
+        {current.semantic_id: current.component_count for current in sections.currents}
+        if static_context is None
+        else static_context.current_dimensions
+    )
+    expected_current_ids = frozenset(dimensions)
+    observations: dict[int, list[_ComplexDecimal]] = {
+        current_id: [] for current_id in dimensions
+    }
+    point_sha256s = tuple(_canonical_sha256(point.to_mapping()) for point in records)
+    kinematic_binary64 = tuple(_kinematic_binary64(point) for point in records)
+    kinematic_sha256s = tuple(_canonical_sha256(row) for row in kinematic_binary64)
+    if len(set(point_sha256s)) != len(records) or len(set(kinematic_sha256s)) != len(
+        records
+    ):
+        raise ValueError("recurrence current capture requires distinct physical points")
+    if static_context is None:
+        runtime_defaults = _runtime_parameter_defaults(plan)
+        schema_payload = _runtime_parameter_schema_payload(
+            plan,
+            defaults=runtime_defaults,
+        )
+        actual_schema_sha256 = _canonical_sha256(schema_payload)
+    else:
+        runtime_defaults = static_context.runtime_defaults
+        actual_schema_sha256 = static_context.runtime_parameter_schema_sha256
+    if (
+        runtime_parameter_schema_sha256 is not None
+        and runtime_parameter_schema_sha256 != actual_schema_sha256
+    ):
+        raise ValueError("recurrence runtime parameter schema digest drifted")
+    resolved_parameter_contexts = (
+        tuple(runtime_defaults for _record in records)
+        if parameter_contexts is None
+        else tuple(tuple(values) for values in parameter_contexts)
+    )
+    if (
+        len(resolved_parameter_contexts) != len(records)
+        or any(
+            len(values) != len(runtime_defaults)
+            or any(
+                not isinstance(value, Decimal) or not value.is_finite()
+                for value in values
+            )
+            for values in resolved_parameter_contexts
+        )
+        or any(
+            row.probe_policy == "derived-overwritten-fixed-zero-v1"
+            and any(
+                values[row.runtime_slot] != runtime_defaults[row.runtime_slot]
+                for values in resolved_parameter_contexts
+            )
+            for row in plan.runtime_parameter_schema
+        )
+    ):
+        raise ValueError(
+            "recurrence parameter contexts do not cover every flattened runtime slot"
+        )
+    parameter_context_sha256s = tuple(
+        _canonical_sha256(
+            {
+                "abi": _PARAMETER_CONTEXT_ABI,
+                "domain": domain,
+                "point_index": point_index,
+                "point_sha256": point_sha256,
+                "runtime_parameter_schema_sha256": actual_schema_sha256,
+                "values": [_decimal_string(value) for value in values],
+            }
+        )
+        for point_index, (point_sha256, values) in enumerate(
+            zip(point_sha256s, resolved_parameter_contexts, strict=True)
+        )
+    )
+    context_payloads: list[object] = []
+    working_precision = precision_digits + 16
+    with localcontext() as context:
+        context.prec = working_precision
+        context.rounding = ROUND_HALF_EVEN
+        for point_index, (record, parameter_context) in enumerate(
+            zip(records, resolved_parameter_contexts, strict=True)
+        ):
+            probe_started = time.perf_counter()
+            parameters = plan.resolve_model_parameters(
+                parameter_context,
+                working_precision,
+            )
+            point = cast(
+                _Point,
+                tuple(
+                    tuple(Decimal.from_float(float(value)) for value in momentum)
+                    for momentum in record.four_vectors
+                ),
+            )
+            captured, context_payload = _capture_one_point(
+                plan,
+                point,
+                parameters.prepared,
+                working_precision,
+                selector_seed=_domain_seed(
+                    seed,
+                    domain=domain,
+                    index=point_index,
+                ),
+                expected_current_ids=expected_current_ids,
+            )
+            if probe_timings is not None:
+                probe_timings.append(time.perf_counter() - probe_started)
+            context_payloads.append(context_payload)
+            if captured.keys() != expected_current_ids:
+                raise ValueError("recurrence exact current capture is incomplete")
+            for current_id, dimension in dimensions.items():
+                values = captured[current_id]
+                if len(values) != dimension:
+                    raise ValueError(
+                        f"recurrence current {current_id} capture width "
+                        f"{len(values)} does not match {dimension}"
+                    )
+                observations[current_id].extend(values)
+    frozen = {current_id: tuple(values) for current_id, values in observations.items()}
+    if any(
+        not real.is_finite() or not imaginary.is_finite()
+        for values in frozen.values()
+        for real, imaginary in values
+    ):
+        raise ValueError(
+            "recurrence exact current capture produced a non-finite component"
+        )
+    context_sha256s = tuple(_canonical_sha256(payload) for payload in context_payloads)
+    batch_digest = _canonical_sha256(
+        {
+            "abi": _OBSERVATION_BATCH_ABI,
+            "source_semantics_sha256": source_semantics_sha256,
+            "runtime_parameter_schema_sha256": actual_schema_sha256,
+            "point_sha256s": list(point_sha256s),
+            "selector_context_sha256s": list(context_sha256s),
+            "parameter_context_sha256s": list(parameter_context_sha256s),
+            "currents": _ObservationRowsStream(frozen, dimensions),
+        }
+    )
+    context_policy = _context_policy(sections.strategy)
+    capture_contract_sha256 = _canonical_sha256(
+        {
+            "abi": _CAPTURE_ABI,
+            "precision_digits": precision_digits,
+            "source_semantics_sha256": source_semantics_sha256,
+            "runtime_parameter_schema_sha256": actual_schema_sha256,
+            "point_sha256s": list(point_sha256s),
+            "kinematic_sha256s": list(kinematic_sha256s),
+            "selector_context_sha256s": list(context_sha256s),
+            "parameter_context_sha256s": list(parameter_context_sha256s),
+            "current_dimensions": _DimensionRowsStream(dimensions),
+            "observation_batch_sha256": batch_digest,
+            "context_policy": context_policy,
+        }
+    )
+    capture_dimensions = dimensions if static_context is None else dict(dimensions)
+    return RecurrenceCurrentObservationCapture(
+        precision_digits=precision_digits,
+        points=records,
+        point_sha256s=point_sha256s,
+        kinematic_sha256s=kinematic_sha256s,
+        kinematic_binary64=kinematic_binary64,
+        selector_contexts=tuple(context_payloads),
+        context_sha256s=context_sha256s,
+        parameter_contexts=resolved_parameter_contexts,
+        parameter_context_sha256s=parameter_context_sha256s,
+        observations=frozen,
+        current_dimensions=capture_dimensions,
+        runtime_parameter_schema_sha256=actual_schema_sha256,
+        source_semantics_sha256=source_semantics_sha256,
+        observation_batch_sha256=batch_digest,
+        capture_contract_sha256=capture_contract_sha256,
+        context_policy=context_policy,
+    )
+
+
+def recurrence_numerical_source_semantics_sha256(
+    sections: _RecurrenceExactSectionsV1,
+) -> str:
+    """Bind probes to the baseline semantic schedule and current contracts."""
+
+    return _canonical_sha256(_source_semantics_payload(sections))
+
+
+def _source_semantics_payload(
+    sections: _RecurrenceExactSectionsV1,
+    *,
+    contracts: tuple[_CurrentContract, ...] | None = None,
+) -> dict[str, object]:
+    if contracts is None:
+        contracts = _current_contracts(sections)
+    if sections.strategy == "topology-replay":
+        selector_schedule: object = {
+            "policy": _context_policy(sections.strategy),
+            "replay_targets": [
+                {
+                    "target_index": target_index,
+                    "public_flow_id": target.public_flow_id,
+                    "representative_id": target.representative_id,
+                    "selector_domain_id": target.selector_domain_id,
+                }
+                for target_index, target in enumerate(sections.replay_targets)
+            ],
+        }
+    elif sections.strategy == "all-flow-union":
+        selector_schedule = {
+            "policy": _context_policy(sections.strategy),
+            "resolved_helicities": [
+                {
+                    "helicity_index": helicity_index,
+                    "helicity_id": helicity.helicity_id,
+                    "selector_domain_id": helicity.selector_domain_id,
+                }
+                for helicity_index, helicity in enumerate(sections.resolved_helicities)
+            ],
+        }
+    else:
+        selector_schedule = {
+            "policy": _context_policy(sections.strategy),
+            "fixed_source_schedule": True,
+        }
+    return {
+        "abi": _SOURCE_ABI,
+        "process_id": sections.process_id,
+        "strategy": sections.strategy,
+        "schedule_semantic_digest": sections.semantic_digest,
+        "baseline_runtime_layout_digest": sections.runtime_layout_digest,
+        "selector_schedule": selector_schedule,
+        "currents": [
+            {
+                "current_id": current.semantic_id,
+                "is_source": current.source_row != DIRECT_NONE_U32,
+                "contract": _plain_contract(contracts[current.semantic_id]),
+            }
+            for current in sections.currents
+        ],
+    }
+
+
+def _capture_one_point(
+    plan: _RecurrenceExactPlan,
+    point: _Point,
+    prepared_parameters: Sequence[_ComplexDecimal],
+    precision: int,
+    *,
+    selector_seed: int,
+    expected_current_ids: frozenset[int],
+) -> tuple[dict[int, tuple[_ComplexDecimal, ...]], object]:
+    sections = plan.sections
+    if sections.strategy == "topology-replay":
+        if not sections.replay_targets:
+            raise ArtifactError("topology replay has no exact probe target")
+        target_index = selector_seed % len(sections.replay_targets)
+        target = sections.replay_targets[target_index]
+        captured = _capture_execution(
+            sections,
+            lambda observer: _evaluate_replay_point(
+                plan,
+                point,
+                target,
+                prepared_parameters,
+                precision,
+                current_observer=observer,
+            ),
+            expected_current_ids=expected_current_ids,
+        )
+        return captured, {
+            "strategy": sections.strategy,
+            "target_index": target_index,
+            "public_flow_id": target.public_flow_id,
+            "representative_id": target.representative_id,
+            "selector_domain_id": target.selector_domain_id,
+        }
+    if sections.strategy == "all-flow-union":
+        if not sections.resolved_helicities:
+            raise ArtifactError("all-flow union has no exact probe helicity")
+        by_domain: dict[int, list[int]] = defaultdict(list)
+        for index, helicity in enumerate(sections.resolved_helicities):
+            by_domain[helicity.selector_domain_id].append(index)
+        captures: dict[int, dict[int, tuple[_ComplexDecimal, ...]]] = {}
+        selected: list[dict[str, int]] = []
+        for domain_id, indices in sorted(by_domain.items()):
+            position = selector_seed % len(indices)
+            helicity_index = indices[position]
+            helicity = sections.resolved_helicities[helicity_index]
+            captures[domain_id] = _capture_execution(
+                sections,
+                lambda observer, helicity=helicity: _evaluate_union_point(
+                    plan,
+                    point,
+                    helicity,
+                    prepared_parameters,
+                    precision,
+                    current_observer=observer,
+                ),
+                expected_current_ids=expected_current_ids,
+            )
+            selected.append(
+                {
+                    "selector_domain_id": domain_id,
+                    "helicity_index": helicity_index,
+                    "helicity_id": helicity.helicity_id,
+                }
+            )
+        default_capture = captures[min(captures)]
+        merged = {
+            current.semantic_id: captures.get(
+                current.selector_domain_id,
+                default_capture,
+            )[current.semantic_id]
+            for current in sections.currents
+        }
+        return merged, {
+            "strategy": sections.strategy,
+            "selector_domain_helicities": selected,
+        }
+    captured = _capture_execution(
+        sections,
+        lambda observer: _evaluate_contracted_point(
+            plan,
+            point,
+            prepared_parameters,
+            precision,
+            current_observer=observer,
+        ),
+        expected_current_ids=expected_current_ids,
+    )
+    return captured, {
+        "strategy": sections.strategy,
+        "fixed_source_schedule": True,
+    }
+
+
+def _capture_execution(
+    sections: _RecurrenceExactSectionsV1,
+    operation: object,
+    *,
+    expected_current_ids: frozenset[int] | None = None,
+) -> dict[int, tuple[_ComplexDecimal, ...]]:
+    captured: dict[int, tuple[_ComplexDecimal, ...]] = {}
+
+    def observe(
+        current_id: int,
+        values: tuple[_ComplexDecimal, ...],
+    ) -> None:
+        if current_id in captured:
+            raise ArtifactError(
+                f"recurrence current {current_id} was observed more than once"
+            )
+        captured[current_id] = values
+
+    if not callable(operation):  # pragma: no cover - internal type contract
+        raise TypeError("recurrence capture operation is not callable")
+    operation(observe)
+    expected = (
+        frozenset(current.semantic_id for current in sections.currents)
+        if expected_current_ids is None
+        else expected_current_ids
+    )
+    if captured.keys() != expected:
+        missing = sorted(expected - captured.keys())
+        raise ArtifactError(
+            f"recurrence current observation missed semantic currents {missing[:8]}"
+        )
+    return captured
+
+
+def _build_raw_numerical_candidate_index(
+    member_ids: Sequence[int],
+    observations: Mapping[int, Sequence[_ComplexDecimal]],
+) -> NumericalObservationCandidateIndex[Fraction]:
+    return build_numerical_observation_candidate_index(
+        member_ids,
+        observations,
+        normalize=Fraction,
+    )
+
+
+def _raw_numerical_tolerance_window_ids(
+    index: NumericalObservationCandidateIndex[Fraction],
+    current_values: Sequence[_ComplexDecimal],
+    *,
+    relation_kind: Literal["equal", "opposite"],
+    current_id: int,
+    relative_tolerance: Fraction,
+    absolute_tolerance: Fraction,
+) -> tuple[int, ...]:
+    return numerical_observation_tolerance_window_ids(
+        index,
+        current_values,
+        relation_kind=relation_kind,
+        current_id=current_id,
+        relative_tolerance=relative_tolerance,
+        absolute_tolerance=absolute_tolerance,
+        normalize=Fraction,
+    )
+
+
+def _build_candidate_indexes(
+    sections: _RecurrenceExactSectionsV1,
+    observations: Mapping[int, Sequence[_ComplexDecimal]],
+    *,
+    contracts: tuple[_CurrentContract, ...] | None = None,
+) -> dict[
+    _CurrentContract,
+    NumericalObservationCandidateIndex[Fraction],
+]:
+    if contracts is None:
+        contracts = _current_contracts(sections)
+    members_by_contract: dict[_CurrentContract, list[int]] = defaultdict(list)
+    for current in sections.currents:
+        members_by_contract[contracts[current.semantic_id]].append(current.semantic_id)
+    return {
+        contract: _build_raw_numerical_candidate_index(
+            member_ids,
+            observations,
+        )
+        for contract, member_ids in members_by_contract.items()
+    }
+
+
+def _numerical_relation_application_scope(
+    sections: _RecurrenceExactSectionsV1,
+) -> dict[str, object]:
+    """Return the narrow execution members eligible for numerical reuse."""
+
+    helicities_by_domain: dict[int, int] = defaultdict(int)
+    for helicity in sections.resolved_helicities:
+        helicities_by_domain[helicity.selector_domain_id] += 1
+    unsafe_all_flow_domains = (
+        tuple(
+            domain_id
+            for domain_id, member_count in sorted(helicities_by_domain.items())
+            if member_count > 1
+        )
+        if sections.strategy == "all-flow-union"
+        else ()
+    )
+    return {
+        "abi": _APPLICATION_SCOPE_ABI,
+        "policy": "exact-physical-selector-member-set-v1",
+        "layout": sections.strategy,
+        "multi_helicity_all_flow_domain_ids": list(unsafe_all_flow_domains),
+        "multi_helicity_all_flow_application": (
+            "disabled" if unsafe_all_flow_domains else "not-applicable"
+        ),
+        "suppressed_selector_domain_ids": list(unsafe_all_flow_domains),
+        "contracted_opposite_application": (
+            "disabled"
+            if sections.strategy == "contracted-color-union"
+            else "not-applicable"
+        ),
+    }
+
+
+def _effective_numerical_relation_mode(
+    sections: _RecurrenceExactSectionsV1,
+    *,
+    requested_mode: _Mode,
+    certificates: Sequence[RecurrenceNumericalCurrentCertificate],
+) -> _Mode:
+    """Contain relations that the native mapper cannot apply member-wise."""
+
+    if requested_mode != "certified-reuse":
+        return requested_mode
+    scope = _numerical_relation_application_scope(sections)
+    if cast(Sequence[int], scope["suppressed_selector_domain_ids"]):
+        return "diagnostic"
+    if certificates and not _applicable_numerical_certificates(
+        certificates, application_scope=scope
+    ):
+        return "diagnostic"
+    return requested_mode
+
+
+def _applicable_numerical_certificates(
+    certificates: Sequence[RecurrenceNumericalCurrentCertificate],
+    *,
+    application_scope: Mapping[str, object],
+) -> tuple[RecurrenceNumericalCurrentCertificate, ...]:
+    """Mirror native application containment without changing its evidence.
+
+    A skipped opposite relation keeps its original current evaluation. Equal
+    relations may therefore still refer to that current; no representative is
+    rewritten and no relation depends on applying a skipped certificate.
+    """
+
+    if application_scope["suppressed_selector_domain_ids"]:
+        return ()
+    suppress_opposite = (
+        application_scope["contracted_opposite_application"] == "disabled"
+    )
+    return tuple(
+        certificate
+        for certificate in certificates
+        if not (suppress_opposite and certificate.relation_kind == "opposite")
+    )
+
+
+def _discover_relations(
+    sections: _RecurrenceExactSectionsV1,
+    candidate: RecurrenceCurrentObservationCapture,
+    verification: RecurrenceCurrentObservationCapture | None,
+    *,
+    source_semantics_sha256: str,
+    precision_digits: int,
+    seed: int,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+    color_accuracy: str,
+    contracts: tuple[_CurrentContract, ...] | None = None,
+    candidate_indexes: Mapping[
+        _CurrentContract,
+        NumericalObservationCandidateIndex[Fraction],
+    ]
+    | None = None,
+) -> tuple[
+    tuple[RecurrenceNumericalCurrentCertificate, ...],
+    dict[str, object],
+]:
+    relative, absolute = _validated_tolerances(
+        relative_tolerance,
+        absolute_tolerance,
+    )
+    relative_fraction = Fraction(relative)
+    absolute_fraction = Fraction(absolute)
+    application_scope = _numerical_relation_application_scope(sections)
+    unsafe_selector_domains = frozenset(
+        cast(
+            Sequence[int],
+            application_scope["suppressed_selector_domain_ids"],
+        )
+    )
+    if contracts is None:
+        contracts = _current_contracts(sections)
+    if candidate_indexes is None:
+        spooled_indexes = (
+            candidate.observations.candidate_indexes
+            if isinstance(candidate.observations, _SpooledObservationMapping)
+            else None
+        )
+        candidate_indexes = spooled_indexes
+    if candidate_indexes is None:
+        candidate_indexes = _build_candidate_indexes(
+            sections,
+            candidate.observations,
+            contracts=contracts,
+        )
+    prior_by_contract: dict[_CurrentContract, list[int]] = defaultdict(list)
+    certificates: list[RecurrenceNumericalCurrentCertificate] = []
+    rejected: list[dict[str, object]] = []
+    nearest: tuple[Fraction, Fraction, Fraction, int, int, str] | None = None
+    tested = 0
+    theoretical_pair_hypotheses = 0
+    screened_pair_hypotheses = 0
+    zero_hypotheses = 0
+    candidates = 0
+    verification_rejected = 0
+    rejected_hypotheses = 0
+    scope_suppressed_current_count = 0
+    decision_chain = _canonical_sha256(
+        {
+            "abi": _DECISION_CHAIN_ABI,
+            "source_semantics_sha256": source_semantics_sha256,
+            "candidate_capture_sha256": candidate.capture_contract_sha256,
+            "verification_capture_sha256": (
+                None if verification is None else verification.capture_contract_sha256
+            ),
+        }
+    )
+    rejection_chain = _canonical_sha256(
+        {
+            "abi": _REJECTION_CHAIN_ABI,
+            "source_semantics_sha256": source_semantics_sha256,
+            "candidate_capture_sha256": candidate.capture_contract_sha256,
+            "verification_capture_sha256": (
+                None if verification is None else verification.capture_contract_sha256
+            ),
+        }
+    )
+
+    def record_decision(
+        *,
+        current_id: int,
+        representative_id: int | None,
+        relation_kind: _RelationKind,
+        candidate_residuals: _Residuals,
+        candidate_residual_strings: _ResidualStrings,
+        verification_residuals: _Residuals | None,
+        verification_residual_strings: _ResidualStrings | None,
+        selected: bool,
+    ) -> None:
+        nonlocal decision_chain
+        decision_chain = hashlib.sha256(
+            bytes.fromhex(decision_chain)
+            + _canonical_json_bytes(
+                {
+                    "current_id": current_id,
+                    "representative_id": representative_id,
+                    "relation_kind": relation_kind,
+                    "candidate_maximum_absolute_residual": (
+                        candidate_residual_strings[0]
+                    ),
+                    "candidate_maximum_relative_residual": (
+                        candidate_residual_strings[1]
+                    ),
+                    "candidate_maximum_tolerance_ratio": (
+                        candidate_residual_strings[2]
+                    ),
+                    "candidate_accepted": candidate_residuals[2] <= 1,
+                    "verification_maximum_absolute_residual": (
+                        None
+                        if verification_residual_strings is None
+                        else verification_residual_strings[0]
+                    ),
+                    "verification_maximum_relative_residual": (
+                        None
+                        if verification_residual_strings is None
+                        else verification_residual_strings[1]
+                    ),
+                    "verification_maximum_tolerance_ratio": (
+                        None
+                        if verification_residual_strings is None
+                        else verification_residual_strings[2]
+                    ),
+                    "verification_accepted": (
+                        None
+                        if verification_residuals is None
+                        else verification_residuals[2] <= 1
+                    ),
+                    "selected": selected,
+                }
+            )
+        ).hexdigest()
+
+    def record_rejected(
+        *,
+        current_id: int,
+        representative_id: int | None,
+        relation_kind: _RelationKind,
+        residuals: _Residuals,
+        residual_strings: _ResidualStrings,
+        reason: str,
+    ) -> None:
+        nonlocal nearest, rejected_hypotheses, rejection_chain
+        rejected_hypotheses += 1
+        rejected_row = {
+            "current_id": current_id,
+            "representative_id": representative_id,
+            "relation_kind": relation_kind,
+            "reason": reason,
+            "maximum_absolute_residual": residual_strings[0],
+            "maximum_relative_residual": residual_strings[1],
+            "maximum_tolerance_ratio": residual_strings[2],
+        }
+        rejection_chain = hashlib.sha256(
+            bytes.fromhex(rejection_chain) + _canonical_json_bytes(rejected_row)
+        ).hexdigest()
+        item = (
+            residuals[2],
+            residuals[0],
+            residuals[1],
+            current_id,
+            -1 if representative_id is None else representative_id,
+            relation_kind,
+        )
+        if nearest is None or item < nearest:
+            nearest = item
+        if len(rejected) < _MAX_REJECTED_DIAGNOSTICS:
+            rejected.append(rejected_row)
+
+    for current in sections.currents:
+        contract = contracts[current.semantic_id]
+        prior = prior_by_contract[contract]
+        if current.source_row != DIRECT_NONE_U32:
+            prior.append(current.semantic_id)
+            continue
+        if current.selector_domain_id in unsafe_selector_domains:
+            scope_suppressed_current_count += 1
+            continue
+        candidate_current_observations = candidate.observations[current.semantic_id]
+        equal_representatives = set(
+            _raw_numerical_tolerance_window_ids(
+                candidate_indexes[contract],
+                candidate_current_observations,
+                relation_kind="equal",
+                current_id=current.semantic_id,
+                relative_tolerance=relative_fraction,
+                absolute_tolerance=absolute_fraction,
+            )
+        )
+        opposite_representatives = set(
+            _raw_numerical_tolerance_window_ids(
+                candidate_indexes[contract],
+                candidate_current_observations,
+                relation_kind="opposite",
+                current_id=current.semantic_id,
+                relative_tolerance=relative_fraction,
+                absolute_tolerance=absolute_fraction,
+            )
+        )
+        theoretical_pair_hypotheses += 2 * len(prior)
+        screened_pair_hypotheses += len(equal_representatives) + len(
+            opposite_representatives
+        )
+        zero_hypotheses += 1
+        hypotheses: list[tuple[_RelationKind, int | None]] = [
+            ("zero", None),
+            *[
+                (relation_kind, representative_id)
+                for representative_id in sorted(
+                    equal_representatives | opposite_representatives
+                )
+                for relation_kind in (
+                    *(("equal",) if representative_id in equal_representatives else ()),
+                    *(
+                        ("opposite",)
+                        if representative_id in opposite_representatives
+                        else ()
+                    ),
+                )
+            ],
+        ]
+        accepted = False
+        verification_current_observations: Sequence[_ComplexDecimal] | None = None
+        for relation_kind, representative_id in hypotheses:
+            tested += 1
+            candidate_residuals = _relation_residuals(
+                relation_kind,
+                candidate_current_observations,
+                (
+                    None
+                    if representative_id is None
+                    else candidate.observations[representative_id]
+                ),
+                relative_tolerance=relative_fraction,
+                absolute_tolerance=absolute_fraction,
+            )
+            candidate_residual_strings = _residual_strings(candidate_residuals)
+            if candidate_residuals[2] > 1:
+                record_decision(
+                    current_id=current.semantic_id,
+                    representative_id=representative_id,
+                    relation_kind=relation_kind,
+                    candidate_residuals=candidate_residuals,
+                    candidate_residual_strings=candidate_residual_strings,
+                    verification_residuals=None,
+                    verification_residual_strings=None,
+                    selected=False,
+                )
+                record_rejected(
+                    current_id=current.semantic_id,
+                    representative_id=representative_id,
+                    relation_kind=relation_kind,
+                    residuals=candidate_residuals,
+                    residual_strings=candidate_residual_strings,
+                    reason="candidate-observations-not-equal",
+                )
+                continue
+            if verification is None:
+                raise _IndependentVerificationRequired
+            candidates += 1
+            if verification_current_observations is None:
+                verification_current_observations = verification.observations[
+                    current.semantic_id
+                ]
+            verification_residuals = _relation_residuals(
+                relation_kind,
+                verification_current_observations,
+                (
+                    None
+                    if representative_id is None
+                    else verification.observations[representative_id]
+                ),
+                relative_tolerance=relative_fraction,
+                absolute_tolerance=absolute_fraction,
+            )
+            verification_residual_strings = _residual_strings(verification_residuals)
+            if verification_residuals[2] > 1:
+                verification_rejected += 1
+                record_decision(
+                    current_id=current.semantic_id,
+                    representative_id=representative_id,
+                    relation_kind=relation_kind,
+                    candidate_residuals=candidate_residuals,
+                    candidate_residual_strings=candidate_residual_strings,
+                    verification_residuals=verification_residuals,
+                    verification_residual_strings=(verification_residual_strings),
+                    selected=False,
+                )
+                record_rejected(
+                    current_id=current.semantic_id,
+                    representative_id=representative_id,
+                    relation_kind=relation_kind,
+                    residuals=verification_residuals,
+                    residual_strings=verification_residual_strings,
+                    reason="independent-verification-rejected-candidate",
+                )
+                continue
+            if relation_kind == "zero":
+                execution_representative_id = prior[0] if prior else current.semantic_id
+            else:
+                if representative_id is None:
+                    raise AssertionError(
+                        "non-zero recurrence relation lacks a representative"
+                    )
+                execution_representative_id = representative_id
+            certificates.append(
+                _build_certificate(
+                    current=current,
+                    representative_id=representative_id,
+                    execution_representative_id=(execution_representative_id),
+                    relation_kind=relation_kind,
+                    source_semantics_sha256=source_semantics_sha256,
+                    candidate=candidate,
+                    verification=verification,
+                    candidate_residuals=candidate_residuals,
+                    candidate_residual_strings=candidate_residual_strings,
+                    verification_residuals=verification_residuals,
+                    verification_residual_strings=(verification_residual_strings),
+                    precision_digits=precision_digits,
+                    seed=seed,
+                    relative_tolerance=relative_tolerance,
+                    absolute_tolerance=absolute_tolerance,
+                )
+            )
+            record_decision(
+                current_id=current.semantic_id,
+                representative_id=representative_id,
+                relation_kind=relation_kind,
+                candidate_residuals=candidate_residuals,
+                candidate_residual_strings=candidate_residual_strings,
+                verification_residuals=verification_residuals,
+                verification_residual_strings=verification_residual_strings,
+                selected=True,
+            )
+            accepted = True
+            break
+        prior.append(current.semantic_id)
+        if accepted:
+            continue
+
+    nearest_payload = None
+    if nearest is not None:
+        ratio, absolute_residual, relative_residual, current_id, rep, kind = nearest
+        nearest_payload = {
+            "current_id": current_id,
+            "representative_id": None if rep < 0 else rep,
+            "relation_kind": kind,
+            "maximum_absolute_residual": _fraction_string(absolute_residual),
+            "maximum_relative_residual": _fraction_string(relative_residual),
+            "maximum_tolerance_ratio": _fraction_string(ratio),
+        }
+    certificate_tuple = tuple(certificates)
+    decision_sha256 = _canonical_sha256(
+        {
+            "abi": _DECISION_CHAIN_ABI,
+            "chain_tail_sha256": decision_chain,
+            "tested_hypothesis_count": tested,
+            "theoretical_pair_hypothesis_count": (theoretical_pair_hypotheses),
+            "screened_pair_hypothesis_count": screened_pair_hypotheses,
+            "zero_hypothesis_count": zero_hypotheses,
+            "numerical_candidate_count": candidates,
+            "verification_rejected_count": verification_rejected,
+            "rejected_hypothesis_count": rejected_hypotheses,
+            "certified_relation_count": len(certificate_tuple),
+        }
+    )
+    rejection_sha256 = rejection_chain
+    rejected_diagnostics = {
+        "total_rejected_hypothesis_count": rejected_hypotheses,
+        "retained_count": len(rejected),
+        "truncated": rejected_hypotheses > len(rejected),
+        "truncation_policy": (
+            f"first-{_MAX_REJECTED_DIAGNOSTICS}-in-canonical-decision-order-v1"
+        ),
+        "retained_sha256": _canonical_sha256(
+            {
+                "abi": ("pyamplicol-recurrence-rejected-numerical-diagnostics-v1"),
+                "rows": rejected,
+            }
+        ),
+        "full_decision_sha256": decision_sha256,
+        "full_rejection_sha256": rejection_sha256,
+    }
+    report: dict[str, object] = {
+        "schema_version": 1,
+        "state": (
+            "certified_numerical_relations"
+            if certificate_tuple
+            else "no_certified_numerical_relation"
+        ),
+        "scope": {
+            "execution_mode": "recurrence",
+            "color_accuracy": color_accuracy,
+            "representation": "recurrence-direct-plan-v2",
+            "lc_flow_layout": sections.strategy,
+        },
+        "application_scope": {
+            **application_scope,
+            "suppressed_current_count": scope_suppressed_current_count,
+        },
+        "source_semantics": {
+            "abi": _SOURCE_ABI,
+            "sha256": source_semantics_sha256,
+        },
+        "probe_contract": {
+            "algorithm": _RECURRENCE_CERTIFICATE_ALGORITHM,
+            "precision_digits": precision_digits,
+            "seed": seed,
+            "relative_tolerance_binary64": relative_tolerance.hex(),
+            "absolute_tolerance_binary64": absolute_tolerance.hex(),
+            "candidate_point_sha256s": list(candidate.point_sha256s),
+            "verification_point_sha256s": (
+                [] if verification is None else list(verification.point_sha256s)
+            ),
+            "candidate_context_sha256s": list(candidate.context_sha256s),
+            "verification_context_sha256s": (
+                [] if verification is None else list(verification.context_sha256s)
+            ),
+            "candidate_parameter_context_sha256s": list(
+                candidate.parameter_context_sha256s
+            ),
+            "verification_parameter_context_sha256s": list(
+                () if verification is None else verification.parameter_context_sha256s
+            ),
+            "runtime_parameter_schema_sha256": (
+                candidate.runtime_parameter_schema_sha256
+            ),
+            "candidate_capture_sha256": candidate.capture_contract_sha256,
+            "verification_capture_sha256": (
+                None if verification is None else verification.capture_contract_sha256
+            ),
+            "candidate_observation_batch_sha256": (candidate.observation_batch_sha256),
+            "verification_observation_batch_sha256": (
+                None if verification is None else verification.observation_batch_sha256
+            ),
+            "deterministic": True,
+            "independent_verification": verification is not None,
+            **(
+                {"verification_status": ("not-required-no-candidate-hypothesis")}
+                if verification is None
+                else {}
+            ),
+            "current_dimension_bound": True,
+        },
+        "inspected_current_count": len(sections.currents),
+        "structurally_proven_current_count": 0,
+        "tested_hypothesis_count": tested,
+        "candidate_index": {
+            "algorithm": _CANDIDATE_INDEX_ALGORITHM,
+            "completeness": "complete-within-configured-tolerance",
+            "contract_count": len(candidate_indexes),
+            "exhaustive_fallback_contract_count": (
+                len(candidate_indexes) if relative_fraction >= 1 else 0
+            ),
+            "theoretical_pair_hypothesis_count": (theoretical_pair_hypotheses),
+            "screened_pair_hypothesis_count": screened_pair_hypotheses,
+            "zero_hypothesis_count": zero_hypotheses,
+            "nearest_rejected_scope": ("zero-and-tolerance-window-screened-hypotheses"),
+        },
+        "numerical_candidate_count": candidates,
+        "verification_rejected_count": verification_rejected,
+        "rejected_hypothesis_count": rejected_hypotheses,
+        "decision_sha256": decision_sha256,
+        "rejection_decision_sha256": rejection_sha256,
+        "certified_numerical_relation_count": len(certificate_tuple),
+        "certificates": [
+            certificate.to_json_dict() for certificate in certificate_tuple
+        ],
+        "rejected_candidates": rejected,
+        "rejected_candidate_diagnostics": rejected_diagnostics,
+        "nearest_rejected_hypothesis": nearest_payload,
+        "warning": _warning_payload(False),
+    }
+    return certificate_tuple, report
+
+
+def _build_certificate(
+    *,
+    current: _Current,
+    representative_id: int | None,
+    execution_representative_id: int,
+    relation_kind: _RelationKind,
+    source_semantics_sha256: str,
+    candidate: RecurrenceCurrentObservationCapture,
+    verification: RecurrenceCurrentObservationCapture,
+    candidate_residuals: _Residuals,
+    candidate_residual_strings: _ResidualStrings,
+    verification_residuals: _Residuals,
+    verification_residual_strings: _ResidualStrings,
+    precision_digits: int,
+    seed: int,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+) -> RecurrenceNumericalCurrentCertificate:
+    factor = {
+        "equal": (1, 0),
+        "opposite": (-1, 0),
+        "zero": (0, 0),
+    }[relation_kind]
+    candidate_digest = _relation_observation_sha256(
+        current.semantic_id,
+        representative_id,
+        relation_kind,
+        candidate,
+    )
+    verification_digest = _relation_observation_sha256(
+        current.semantic_id,
+        representative_id,
+        relation_kind,
+        verification,
+    )
+    probe_contract = {
+        "algorithm": _RECURRENCE_CERTIFICATE_ALGORITHM,
+        "source_semantics_sha256": source_semantics_sha256,
+        "current_id": current.semantic_id,
+        "representative_id": representative_id,
+        "execution_representative_id": execution_representative_id,
+        "relation_kind": relation_kind,
+        "precision_digits": precision_digits,
+        "seed": seed,
+        "candidate_domain": "candidate-current-probes-v1",
+        "verification_domain": ("independent-verification-current-probes-v1"),
+        "relative_tolerance_binary64": relative_tolerance.hex(),
+        "absolute_tolerance_binary64": absolute_tolerance.hex(),
+        "candidate_probe_count": candidate.point_count,
+        "verification_probe_count": verification.point_count,
+        "current_dimension": current.component_count,
+        "runtime_parameter_schema_sha256": (candidate.runtime_parameter_schema_sha256),
+        "candidate_capture_sha256": candidate.capture_contract_sha256,
+        "verification_capture_sha256": verification.capture_contract_sha256,
+        "candidate_observations_sha256": candidate_digest,
+        "verification_observations_sha256": verification_digest,
+    }
+    probe_digest = _canonical_sha256(probe_contract)
+    proof_payload = {
+        **probe_contract,
+        "proof_kind": "authenticated-numerical",
+        "factor_integer": list(factor),
+        "candidate_maximum_absolute_residual": candidate_residual_strings[0],
+        "candidate_maximum_relative_residual": candidate_residual_strings[1],
+        "candidate_maximum_tolerance_ratio": candidate_residual_strings[2],
+        "verification_maximum_absolute_residual": verification_residual_strings[0],
+        "verification_maximum_relative_residual": verification_residual_strings[1],
+        "verification_maximum_tolerance_ratio": verification_residual_strings[2],
+        "probe_contract_sha256": probe_digest,
+    }
+    return RecurrenceNumericalCurrentCertificate(
+        current_id=current.semantic_id,
+        representative_id=representative_id,
+        execution_representative_id=execution_representative_id,
+        relation_kind=relation_kind,
+        factor=factor,
+        source_semantics_sha256=source_semantics_sha256,
+        precision_digits=precision_digits,
+        seed=seed,
+        relative_tolerance=relative_tolerance,
+        absolute_tolerance=absolute_tolerance,
+        candidate_probe_count=candidate.point_count,
+        verification_probe_count=verification.point_count,
+        current_dimension=current.component_count,
+        runtime_parameter_schema_sha256=(candidate.runtime_parameter_schema_sha256),
+        candidate_capture_sha256=candidate.capture_contract_sha256,
+        verification_capture_sha256=verification.capture_contract_sha256,
+        candidate_maximum_absolute_residual=candidate_residuals[0],
+        candidate_maximum_relative_residual=candidate_residuals[1],
+        candidate_maximum_tolerance_ratio=candidate_residuals[2],
+        verification_maximum_absolute_residual=verification_residuals[0],
+        verification_maximum_relative_residual=verification_residuals[1],
+        verification_maximum_tolerance_ratio=verification_residuals[2],
+        candidate_observations_sha256=candidate_digest,
+        verification_observations_sha256=verification_digest,
+        probe_contract_sha256=probe_digest,
+        proof_sha256=_canonical_sha256(proof_payload),
+    )
+
+
+def _evidence_payload(
+    sections: _RecurrenceExactSectionsV1,
+    *,
+    mode: _Mode,
+    source_semantics: Mapping[str, object],
+    source_semantics_sha256: str,
+    certificates: tuple[RecurrenceNumericalCurrentCertificate, ...],
+    discovery: Mapping[str, object],
+    precision_digits: int,
+    seed: int,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+    probe_count: int,
+    verification_probe_count: int,
+    runtime_parameter_schema: Mapping[str, object],
+    candidate: RecurrenceCurrentObservationCapture,
+    verification: RecurrenceCurrentObservationCapture,
+) -> dict[str, object]:
+    numerical_candidate_count = _required_report_integer(
+        discovery,
+        "numerical_candidate_count",
+    )
+    verification_rejected_count = _required_report_integer(
+        discovery,
+        "verification_rejected_count",
+    )
+    tested_hypothesis_count = _required_report_integer(
+        discovery,
+        "tested_hypothesis_count",
+    )
+    rejected_hypothesis_count = _required_report_integer(
+        discovery,
+        "rejected_hypothesis_count",
+    )
+    return {
+        "abi": _EVIDENCE_ABI,
+        "requested_mode": mode,
+        "schedule_semantic_digest": sections.semantic_digest,
+        "baseline_runtime_layout_digest": sections.runtime_layout_digest,
+        "source_semantics": source_semantics,
+        "source_semantics_sha256": source_semantics_sha256,
+        "runtime_parameter_schema": dict(runtime_parameter_schema),
+        "runtime_parameter_schema_sha256": (candidate.runtime_parameter_schema_sha256),
+        "candidate_capture": _capture_evidence_payload(candidate),
+        "verification_capture": _capture_evidence_payload(verification),
+        "certificate_algorithm": _RECURRENCE_CERTIFICATE_ALGORITHM,
+        "certificate_set_sha256": _certificate_set_sha256(certificates),
+        "precision_digits": precision_digits,
+        "probe_count": probe_count,
+        "verification_probe_count": verification_probe_count,
+        "relative_tolerance_binary64": relative_tolerance.hex(),
+        "absolute_tolerance_binary64": absolute_tolerance.hex(),
+        "seed": seed,
+        "candidate_index": dict(
+            cast(Mapping[str, object], discovery["candidate_index"])
+        ),
+        "numerical_candidate_count": numerical_candidate_count,
+        "verification_rejected_count": verification_rejected_count,
+        "rejected_hypothesis_count": rejected_hypothesis_count,
+        "tested_hypothesis_count": tested_hypothesis_count,
+        "decision_sha256": str(discovery["decision_sha256"]),
+        "rejection_decision_sha256": str(discovery["rejection_decision_sha256"]),
+        "certificates": _CertificateRowsStream(certificates),
+        "mappings": _MappingRowsStream(certificates),
+    }
+
+
+def _capture_evidence_payload(
+    capture: RecurrenceCurrentObservationCapture,
+) -> dict[str, object]:
+    """Return a small mapping whose large rows are streamed during encoding."""
+
+    return {
+        "abi": _CAPTURE_ABI,
+        "precision_digits": capture.precision_digits,
+        "point_count": capture.point_count,
+        "point_sha256s": capture.point_sha256s,
+        "kinematic_sha256s": capture.kinematic_sha256s,
+        "parameter_contexts": tuple(
+            tuple(_decimal_string(value) for value in context)
+            for context in capture.parameter_contexts
+        ),
+        "parameter_context_sha256s": capture.parameter_context_sha256s,
+        "context_sha256s": capture.context_sha256s,
+        "points": tuple(point.to_mapping() for point in capture.points),
+        "current_count": capture.current_count,
+        "runtime_parameter_schema_sha256": (capture.runtime_parameter_schema_sha256),
+        "source_semantics_sha256": capture.source_semantics_sha256,
+        "observation_batch_sha256": capture.observation_batch_sha256,
+        "capture_contract_sha256": capture.capture_contract_sha256,
+        "context_policy": capture.context_policy,
+        "complete_current_components": True,
+        "point_major": True,
+        "current_dimensions_sha256": _canonical_sha256(
+            {
+                str(current_id): dimension
+                for current_id, dimension in sorted(capture.current_dimensions.items())
+            }
+        ),
+        "evaluator": "recurrence-direct-plan-decimal-symbolica-exact",
+        "kinematic_binary64": capture.kinematic_binary64,
+        "selector_contexts": capture.selector_contexts,
+        "current_dimensions": _DimensionRowsStream(capture.current_dimensions),
+        "observations": _ObservationRowsStream(
+            capture.observations,
+            capture.current_dimensions,
+        ),
+    }
+
+
+def _required_report_integer(
+    report: Mapping[str, object],
+    key: str,
+) -> int:
+    value = report.get(key)
+    if type(value) is not int:
+        raise ValueError(f"recurrence numerical report {key!r} is not an integer")
+    return value
+
+
+def _mapping_payload(
+    certificate: RecurrenceNumericalCurrentCertificate,
+) -> dict[str, object]:
+    return {
+        "current_id": certificate.current_id,
+        "representative_id": certificate.representative_id,
+        "execution_representative_id": (certificate.execution_representative_id),
+        "relation_kind": certificate.relation_kind,
+        "factor_integer": list(certificate.factor),
+        "current_dimension": certificate.current_dimension,
+        "certificate_proof_sha256": certificate.proof_sha256,
+        "candidate_observations_sha256": (certificate.candidate_observations_sha256),
+        "verification_observations_sha256": (
+            certificate.verification_observations_sha256
+        ),
+    }
+
+
+def _current_contracts(
+    sections: _RecurrenceExactSectionsV1,
+) -> tuple[_CurrentContract, ...]:
+    finalization_executors: dict[int, int] = {}
+    for group in sections.row_groups:
+        if group.role == 2:
+            for row_id in range(group.row_start, group.row_start + group.row_count):
+                if row_id in finalization_executors:
+                    raise ArtifactError(
+                        "recurrence finalization row belongs to multiple groups"
+                    )
+                finalization_executors[row_id] = group.executor_id
+    factors = tuple(
+        (
+            str(factor.real_numerator),
+            str(factor.real_denominator),
+            str(factor.imaginary_numerator),
+            str(factor.imaginary_denominator),
+        )
+        for factor in sections.exact_factors
+    )
+    result = []
+    for current in sections.currents:
+        if current.finalization_row == DIRECT_NONE_U32:
+            finalization = (
+                DIRECT_NONE_U32,
+                DIRECT_NONE_U32,
+                ("1", "1", "0", "1"),
+            )
+        else:
+            try:
+                row = sections.finalizations[current.finalization_row]
+                executor_id = finalization_executors[current.finalization_row]
+                factor = factors[row.exact_factor_id]
+            except (IndexError, KeyError) as exc:
+                raise ArtifactError(
+                    f"recurrence current {current.semantic_id} has an invalid "
+                    "finalization contract"
+                ) from exc
+            finalization = (executor_id, row.momentum_form_id, factor)
+        result.append(
+            (
+                current.node_kind,
+                current.stage,
+                current.state_template_id,
+                current.component_count,
+                current.momentum_form_id,
+                current.selector_domain_id,
+                *finalization,
+            )
+        )
+    return tuple(result)
+
+
+def _validate_independent_captures(
+    candidate: RecurrenceCurrentObservationCapture,
+    verification: RecurrenceCurrentObservationCapture,
+) -> None:
+    if (
+        candidate.precision_digits != verification.precision_digits
+        or candidate.source_semantics_sha256 != verification.source_semantics_sha256
+        or candidate.runtime_parameter_schema_sha256
+        != verification.runtime_parameter_schema_sha256
+        or candidate.current_dimensions != verification.current_dimensions
+        or set(candidate.observations) != set(verification.observations)
+        or candidate.point_count < 2
+        or verification.point_count < 2
+        or not set(candidate.point_sha256s).isdisjoint(verification.point_sha256s)
+        or not set(candidate.kinematic_sha256s).isdisjoint(
+            verification.kinematic_sha256s
+        )
+        or len(candidate.parameter_context_sha256s) != candidate.point_count
+        or len(verification.parameter_context_sha256s) != verification.point_count
+        or not set(candidate.parameter_context_sha256s).isdisjoint(
+            verification.parameter_context_sha256s
+        )
+    ):
+        raise ValueError(
+            "recurrence candidate and verification captures are not independent"
+        )
+    for current_id, dimension in candidate.current_dimensions.items():
+        if (
+            len(candidate.observations[current_id]) != candidate.point_count * dimension
+            or len(verification.observations[current_id])
+            != verification.point_count * dimension
+        ):
+            raise ValueError(f"recurrence current {current_id} probe geometry drifted")
+
+
+def _validate_applied_observations(
+    reference: RecurrenceCurrentObservationCapture,
+    applied: RecurrenceCurrentObservationCapture,
+    *,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+) -> dict[str, object]:
+    if (
+        reference.precision_digits != applied.precision_digits
+        or reference.point_sha256s != applied.point_sha256s
+        or reference.kinematic_sha256s != applied.kinematic_sha256s
+        or reference.kinematic_binary64 != applied.kinematic_binary64
+        or reference.selector_contexts != applied.selector_contexts
+        or reference.context_sha256s != applied.context_sha256s
+        or reference.parameter_contexts != applied.parameter_contexts
+        or reference.parameter_context_sha256s != applied.parameter_context_sha256s
+        or reference.runtime_parameter_schema_sha256
+        != applied.runtime_parameter_schema_sha256
+        or reference.current_dimensions != applied.current_dimensions
+        or set(reference.observations) != set(applied.observations)
+    ):
+        raise ValueError("recurrence application validation provenance drifted")
+    relative, absolute = _validated_tolerances(
+        relative_tolerance,
+        absolute_tolerance,
+    )
+    relative_fraction = Fraction(relative)
+    absolute_fraction = Fraction(absolute)
+    maximum_absolute = Fraction(0)
+    maximum_relative = Fraction(0)
+    maximum_ratio = Fraction(0)
+    checked = 0
+    for current_id in sorted(reference.observations):
+        before = reference.observations[current_id]
+        after = applied.observations[current_id]
+        if len(before) != len(after):
+            raise ValueError(
+                f"recurrence current {current_id} application width drifted"
+            )
+        residuals = _pair_residuals(
+            before,
+            after,
+            sign=1,
+            relative_tolerance=relative_fraction,
+            absolute_tolerance=absolute_fraction,
+        )
+        maximum_absolute = max(maximum_absolute, residuals[0])
+        maximum_relative = max(maximum_relative, residuals[1])
+        maximum_ratio = max(maximum_ratio, residuals[2])
+        checked += len(before)
+        if residuals[2] > 1:
+            raise ValueError(
+                "recurrence numerical reuse changed current "
+                f"{current_id} beyond its authenticated tolerance"
+            )
+    return {
+        "status": "verified",
+        "checked_current_count": len(reference.observations),
+        "checked_component_count": checked,
+        "maximum_absolute_residual": _fraction_string(maximum_absolute),
+        "maximum_relative_residual": _fraction_string(maximum_relative),
+        "maximum_tolerance_ratio": _fraction_string(maximum_ratio),
+        "reference_observation_batch_sha256": (reference.observation_batch_sha256),
+        "applied_observation_batch_sha256": (applied.observation_batch_sha256),
+    }
+
+
+def _validate_recaptured_reference(
+    authenticated: RecurrenceCurrentObservationCapture,
+    recaptured: RecurrenceCurrentObservationCapture,
+) -> None:
+    """Bind a post-native baseline recapture to the original full commitment."""
+
+    if (
+        authenticated.precision_digits != recaptured.precision_digits
+        or authenticated.points != recaptured.points
+        or authenticated.point_sha256s != recaptured.point_sha256s
+        or authenticated.kinematic_sha256s != recaptured.kinematic_sha256s
+        or authenticated.kinematic_binary64 != recaptured.kinematic_binary64
+        or authenticated.selector_contexts != recaptured.selector_contexts
+        or authenticated.context_sha256s != recaptured.context_sha256s
+        or authenticated.parameter_contexts != recaptured.parameter_contexts
+        or authenticated.parameter_context_sha256s
+        != recaptured.parameter_context_sha256s
+        or authenticated.runtime_parameter_schema_sha256
+        != recaptured.runtime_parameter_schema_sha256
+        or authenticated.source_semantics_sha256 != recaptured.source_semantics_sha256
+        or authenticated.current_dimensions != recaptured.current_dimensions
+        or authenticated.current_count != recaptured.current_count
+        or authenticated.observation_batch_sha256 != recaptured.observation_batch_sha256
+        or authenticated.capture_contract_sha256 != recaptured.capture_contract_sha256
+        or authenticated.context_policy != recaptured.context_policy
+    ):
+        raise ValueError(
+            "recurrence baseline application reference did not reproduce its "
+            "authenticated capture commitment"
+        )
+
+
+def _relation_residuals(
+    relation_kind: _RelationKind,
+    current: Sequence[_ComplexDecimal],
+    representative: Sequence[_ComplexDecimal] | None,
+    *,
+    relative_tolerance: _Tolerance,
+    absolute_tolerance: _Tolerance,
+) -> _Residuals:
+    if relation_kind == "zero":
+        return _zero_residuals(
+            current,
+            relative_tolerance=relative_tolerance,
+            absolute_tolerance=absolute_tolerance,
+        )
+    if representative is None or len(current) != len(representative):
+        raise ValueError("recurrence numerical relation width is invalid")
+    return _pair_residuals(
+        current,
+        representative,
+        sign=1 if relation_kind == "equal" else -1,
+        relative_tolerance=relative_tolerance,
+        absolute_tolerance=absolute_tolerance,
+    )
+
+
+def _zero_residuals(
+    current: Sequence[_ComplexDecimal],
+    *,
+    relative_tolerance: _Tolerance,
+    absolute_tolerance: _Tolerance,
+) -> _Residuals:
+    maximum_absolute = Fraction(0)
+    maximum_relative = Fraction(0)
+    maximum_ratio = Fraction(0)
+    relative_fraction = _tolerance_fraction(relative_tolerance)
+    absolute_fraction = _tolerance_fraction(absolute_tolerance)
+    for current_value in current:
+        current_real = Fraction(current_value[0])
+        current_imaginary = Fraction(current_value[1])
+        difference = max(abs(current_real), abs(current_imaginary))
+        allowed = absolute_fraction + relative_fraction * difference
+        relative = (
+            Fraction(0)
+            if difference == 0
+            else difference / max(difference, absolute_fraction)
+        )
+        ratio = Fraction(0) if difference == 0 else difference / allowed
+        maximum_absolute = max(maximum_absolute, difference)
+        maximum_relative = max(maximum_relative, relative)
+        maximum_ratio = max(maximum_ratio, ratio)
+    return maximum_absolute, maximum_relative, maximum_ratio
+
+
+def _pair_residuals(
+    left: Sequence[_ComplexDecimal],
+    right: Sequence[_ComplexDecimal],
+    *,
+    sign: int,
+    relative_tolerance: _Tolerance,
+    absolute_tolerance: _Tolerance,
+) -> _Residuals:
+    if len(left) != len(right):
+        raise ValueError("recurrence numerical comparison width is invalid")
+    maximum_absolute = Fraction(0)
+    maximum_relative = Fraction(0)
+    maximum_ratio = Fraction(0)
+    relative_fraction = _tolerance_fraction(relative_tolerance)
+    absolute_fraction = _tolerance_fraction(absolute_tolerance)
+    for left_value, right_value in zip(left, right, strict=True):
+        left_real = Fraction(left_value[0])
+        left_imaginary = Fraction(left_value[1])
+        right_real = Fraction(right_value[0])
+        right_imaginary = Fraction(right_value[1])
+        signed = (
+            (right_real, right_imaginary)
+            if sign == 1
+            else (-right_real, -right_imaginary)
+        )
+        difference = max(
+            abs(left_real - signed[0]),
+            abs(left_imaginary - signed[1]),
+        )
+        scale = max(
+            abs(left_real),
+            abs(left_imaginary),
+            abs(right_real),
+            abs(right_imaginary),
+        )
+        allowed = absolute_fraction + relative_fraction * scale
+        relative = (
+            Fraction(0)
+            if difference == 0
+            else difference / max(scale, absolute_fraction)
+        )
+        ratio = Fraction(0) if difference == 0 else difference / allowed
+        maximum_absolute = max(maximum_absolute, difference)
+        maximum_relative = max(maximum_relative, relative)
+        maximum_ratio = max(maximum_ratio, ratio)
+    return maximum_absolute, maximum_relative, maximum_ratio
+
+
+def _tolerance_fraction(value: _Tolerance) -> Fraction:
+    return value if isinstance(value, Fraction) else Fraction(value)
+
+
+def _relation_observation_sha256(
+    current_id: int,
+    representative_id: int | None,
+    relation_kind: _RelationKind,
+    capture: RecurrenceCurrentObservationCapture,
+) -> str:
+    return _canonical_sha256(
+        {
+            "abi": _RELATION_OBSERVATION_ABI,
+            "capture_contract_sha256": capture.capture_contract_sha256,
+            "current_id": current_id,
+            "representative_id": representative_id,
+            "relation_kind": relation_kind,
+            "current_dimension": capture.current_dimensions[current_id],
+            "current_values": [
+                [_decimal_string(real), _decimal_string(imaginary)]
+                for real, imaginary in capture.observations[current_id]
+            ],
+            "representative_values": (
+                None
+                if representative_id is None
+                else [
+                    [_decimal_string(real), _decimal_string(imaginary)]
+                    for real, imaginary in capture.observations[representative_id]
+                ]
+            ),
+        }
+    )
+
+
+def _runtime_parameter_defaults(
+    plan: _RecurrenceExactPlan,
+) -> tuple[Decimal, ...]:
+    if (
+        len(plan.runtime_parameter_schema) != len(plan.runtime_defaults)
+        or any(
+            row.runtime_slot != index
+            for index, row in enumerate(plan.runtime_parameter_schema)
+        )
+        or any(
+            row.runtime_slot >= len(plan.runtime_defaults)
+            for row in plan.parameter_projection
+        )
+    ):
+        raise ArtifactError(
+            "recurrence runtime parameter schema/defaults are incomplete"
+        )
+    defaults: list[Decimal] = []
+    for row, default in zip(
+        plan.runtime_parameter_schema, plan.runtime_defaults, strict=True
+    ):
+        if row.probe_policy == "derived-overwritten-fixed-zero-v1":
+            defaults.append(Decimal(0))
+            continue
+        if row.probe_policy != "native-template-default-perturbed-v1":
+            raise ArtifactError(
+                "recurrence runtime parameter schema has an unsupported "
+                "numerical probe policy"
+            )
+        binary64_default = float(default)
+        if not isfinite(binary64_default):
+            raise ArtifactError(
+                "recurrence runtime parameter default is not finite binary64"
+            )
+        defaults.append(Decimal.from_float(binary64_default))
+    return tuple(defaults)
+
+
+def _runtime_parameter_schema_payload(
+    plan: _RecurrenceExactPlan,
+    *,
+    defaults: tuple[Decimal, ...] | None = None,
+) -> dict[str, object]:
+    if defaults is None:
+        defaults = _runtime_parameter_defaults(plan)
+    return {
+        "abi": _PARAMETER_SCHEMA_ABI,
+        "parameters": [
+            {
+                "runtime_slot": row.runtime_slot,
+                "runtime_name": row.runtime_name,
+                "parameter_template_id": row.parameter_template_id,
+                "prepared_parameter_id": row.prepared_parameter_id,
+                "component": row.component,
+                "default_binary64": float(default).hex(),
+                "probe_policy": row.probe_policy,
+            }
+            for row, default in zip(
+                plan.runtime_parameter_schema, defaults, strict=True
+            )
+        ],
+    }
+
+
+def _build_warmup_static_context(
+    plan: _RecurrenceExactPlan,
+) -> _WarmupStaticContext:
+    """Build immutable generation-scoped data shared by every warm-up pass."""
+
+    current_dimensions = {
+        current.semantic_id: current.component_count
+        for current in plan.sections.currents
+    }
+    current_contracts = _current_contracts(plan.sections)
+    source_semantics = _source_semantics_payload(
+        plan.sections,
+        contracts=current_contracts,
+    )
+    source_semantics_sha256 = _canonical_sha256(source_semantics)
+    runtime_defaults = _runtime_parameter_defaults(plan)
+    runtime_parameter_schema = _runtime_parameter_schema_payload(
+        plan,
+        defaults=runtime_defaults,
+    )
+    return _WarmupStaticContext(
+        current_dimensions=current_dimensions,
+        current_contracts=current_contracts,
+        runtime_defaults=runtime_defaults,
+        runtime_parameter_schema=runtime_parameter_schema,
+        runtime_parameter_schema_sha256=_canonical_sha256(runtime_parameter_schema),
+        source_semantics=source_semantics,
+        source_semantics_sha256=source_semantics_sha256,
+    )
+
+
+def _build_parameter_probe_contexts(
+    defaults: tuple[Decimal, ...],
+    *,
+    probe_policies: tuple[str, ...],
+    precision_digits: int,
+    seed: int,
+    domain: str,
+    count: int,
+    include_defaults: bool,
+) -> tuple[tuple[Decimal, ...], ...]:
+    if (
+        type(precision_digits) is not int
+        or precision_digits < 80
+        or type(seed) is not int
+        or seed < 0
+        or not isinstance(domain, str)
+        or not domain
+        or type(count) is not int
+        or count < 2
+        or len(probe_policies) != len(defaults)
+        or any(
+            policy
+            not in {
+                "native-template-default-perturbed-v1",
+                "derived-overwritten-fixed-zero-v1",
+            }
+            for policy in probe_policies
+        )
+        or any(not value.is_finite() for value in defaults)
+    ):
+        raise ValueError("recurrence numerical parameter-probe contract is invalid")
+    contexts: list[tuple[Decimal, ...]] = []
+    for probe_index in range(count):
+        if include_defaults and probe_index == 0:
+            contexts.append(defaults)
+            continue
+        values: list[Decimal] = []
+        for parameter_index, (default, probe_policy) in enumerate(
+            zip(defaults, probe_policies, strict=True)
+        ):
+            if probe_policy == "derived-overwritten-fixed-zero-v1":
+                values.append(default)
+                continue
+            digest = hashlib.sha256(
+                (f"{seed}:{domain}:{probe_index}:{parameter_index}").encode("ascii")
+            ).digest()
+            signed = int.from_bytes(digest[:8], "big") - (1 << 63)
+            if signed == 0:
+                signed = 1
+            scale = max(abs(Fraction(default)), Fraction(1))
+            value = Fraction(default) + scale * Fraction(signed, 1 << 67)
+            values.append(_terminating_fraction_decimal(value))
+        contexts.append(tuple(values))
+    return tuple(contexts)
+
+
+def _validated_tolerances(
+    relative_tolerance: float,
+    absolute_tolerance: float,
+) -> tuple[Decimal, Decimal]:
+    if (
+        isinstance(relative_tolerance, bool)
+        or not isinstance(relative_tolerance, int | float)
+        or isinstance(absolute_tolerance, bool)
+        or not isinstance(absolute_tolerance, int | float)
+        or not isfinite(relative_tolerance)
+        or not isfinite(absolute_tolerance)
+        or relative_tolerance < 0
+        or absolute_tolerance < 0
+        or (
+            float(relative_tolerance) == 0.0
+            and copysign(1.0, float(relative_tolerance)) < 0
+        )
+        or (
+            float(absolute_tolerance) == 0.0
+            and copysign(1.0, float(absolute_tolerance)) < 0
+        )
+        or (relative_tolerance == 0 and absolute_tolerance == 0)
+    ):
+        raise ValueError("recurrence numerical current tolerances are invalid")
+    return (
+        Decimal.from_float(float(relative_tolerance)),
+        Decimal.from_float(float(absolute_tolerance)),
+    )
+
+
+def _certificate_set_sha256(
+    certificates: Sequence[RecurrenceNumericalCurrentCertificate],
+) -> str:
+    return _canonical_sha256(
+        {
+            "abi": _RELATION_SET_ABI,
+            "certificates": _CertificateRowsStream(certificates),
+            "mappings": _MappingRowsStream(certificates),
+        }
+    )
+
+
+def _kinematic_binary64(
+    point: ValidationPointRecord,
+) -> tuple[tuple[str, ...], ...]:
+    return tuple(
+        tuple(float(value).hex() for value in momentum)
+        for momentum in point.four_vectors
+    )
+
+
+def _kinematic_sha256(point: ValidationPointRecord) -> str:
+    return _canonical_sha256(_kinematic_binary64(point))
+
+
+def _domain_seed(seed: int, *, domain: str, index: int) -> int:
+    digest = hashlib.sha256(f"{seed}:{domain}:{index}".encode("ascii")).digest()
+    return int.from_bytes(digest[:8], "big")
+
+
+def _context_policy(strategy: str) -> str:
+    return {
+        "topology-replay": "seeded-replay-target-per-physical-point-v1",
+        "all-flow-union": ("seeded-helicity-per-selector-domain-and-physical-point-v1"),
+        "contracted-color-union": "fixed-contracted-source-schedule-v1",
+    }[strategy]
+
+
+def _plain_contract(contract: _CurrentContract) -> list[object]:
+    result = []
+    for value in contract:
+        result.append(list(value) if isinstance(value, tuple) else value)
+    return result
+
+
+def _warning_payload(required: bool) -> dict[str, object]:
+    return (
+        {
+            "required": True,
+            "emit": "once-per-generated-artifact",
+            "code": NUMERICAL_CURRENT_RELATION_WARNING_CODE,
+            "message": NUMERICAL_CURRENT_RELATION_WARNING,
+        }
+        if required
+        else {
+            "required": False,
+            "emit": "never",
+            "code": None,
+            "message": None,
+        }
+    )
+
+
+def numerical_relation_correctness_payload(
+    applied_relation_count: int,
+) -> dict[str, object]:
+    if type(applied_relation_count) is not int or applied_relation_count < 0:
+        raise ValueError("numerical relation application count is invalid")
+    return {
+        "abi": NUMERICAL_RELATION_CORRECTNESS_ABI,
+        "state": (
+            "member-scoped-v1" if applied_relation_count else "no-applied-relations"
+        ),
+        "applied_relation_count": applied_relation_count,
+    }
+
+
+def recurrence_numerical_relation_correctness_summary(
+    report: Mapping[str, object],
+) -> dict[str, object]:
+    """Extract the compact metadata needed for lightweight result reuse."""
+
+    value = report.get("relation_correctness")
+    if not isinstance(value, Mapping):
+        raise ValueError(
+            "recurrence numerical relation report has no correctness state"
+        )
+    applied = report.get("applied_relation_count")
+    if type(applied) is not int or applied < 0:
+        raise ValueError(
+            "recurrence numerical relation report has an invalid applied count"
+        )
+    expected = numerical_relation_correctness_payload(applied)
+    if any(value.get(key) != expected[key] for key in expected):
+        raise ValueError(
+            "recurrence numerical relation correctness state is inconsistent"
+        )
+    return dict(expected)
+
+
+def validate_recurrence_numerical_evidence_fallback(
+    value: object,
+) -> dict[str, object]:
+    """Validate one full evidence-envelope fallback payload."""
+
+    required_fields = {
+        "reason",
+        "memory_envelope_bytes",
+        "spooled_producer_resident_bytes",
+        "geometry",
+    }
+    if not isinstance(value, Mapping) or set(value) != required_fields:
+        raise ValueError("recurrence numerical current fallback provenance is invalid")
+    if value.get("reason") != EVIDENCE_ENVELOPE_FALLBACK_REASON:
+        raise ValueError("recurrence numerical current fallback reason is invalid")
+
+    def required_integer(
+        raw: object,
+        *,
+        name: str,
+        minimum: int,
+    ) -> int:
+        if type(raw) is not int or raw < minimum:
+            raise ValueError(f"recurrence numerical fallback {name} is invalid")
+        return raw
+
+    memory_envelope_bytes = required_integer(
+        value.get("memory_envelope_bytes"),
+        name="memory envelope",
+        minimum=1,
+    )
+    producer_resident_bytes = required_integer(
+        value.get("spooled_producer_resident_bytes"),
+        name="producer resident bound",
+        minimum=1,
+    )
+    raw_geometry = value.get("geometry")
+    geometry_fields = {
+        "current_count",
+        "component_count",
+        "candidate_probe_count",
+        "verification_probe_count",
+        "runtime_parameter_count",
+        "scalar_count",
+        "row_count",
+    }
+    if not isinstance(raw_geometry, Mapping) or set(raw_geometry) != geometry_fields:
+        raise ValueError("recurrence numerical current fallback geometry is invalid")
+    counts = {
+        key: required_integer(
+            raw_geometry.get(key),
+            name=f"geometry {key}",
+            minimum=(
+                1 if key in {"candidate_probe_count", "verification_probe_count"} else 0
+            ),
+        )
+        for key in geometry_fields
+    }
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=counts["current_count"],
+        component_count=counts["component_count"],
+        candidate_probe_count=counts["candidate_probe_count"],
+        verification_probe_count=counts["verification_probe_count"],
+        runtime_parameter_count=counts["runtime_parameter_count"],
+    )
+    expected_geometry = geometry.to_json_dict()
+    expected_producer_resident_bytes = geometry.spooled_producer_resident_upper_bound()
+    # A fallback may occur either before capture because this producer bound
+    # exceeds the envelope, or later at a recognized canonical/native
+    # transport boundary.  In both cases the recomputed bound must be exact;
+    # it need not itself be the boundary that fired.
+    if (
+        counts != expected_geometry
+        or producer_resident_bytes != expected_producer_resident_bytes
+    ):
+        raise ValueError(
+            "recurrence numerical current fallback geometry is inconsistent"
+        )
+    return {
+        "reason": EVIDENCE_ENVELOPE_FALLBACK_REASON,
+        "memory_envelope_bytes": memory_envelope_bytes,
+        "spooled_producer_resident_bytes": producer_resident_bytes,
+        "geometry": expected_geometry,
+    }
+
+
+def recurrence_numerical_relation_fallback_summary(
+    report: Mapping[str, object],
+) -> dict[str, object] | None:
+    """Extract lightweight fallback provenance without expanding correctness ABI."""
+
+    fallback = report.get("fallback")
+    if fallback is None:
+        if (
+            report.get("requested_mode") == "certified-reuse"
+            and report.get("effective_mode") == "off"
+        ):
+            raise ValueError(
+                "recurrence numerical relation fallback provenance is absent"
+            )
+        return None
+    certified = _required_report_integer(report, "certified_relation_count")
+    applied = _required_report_integer(report, "applied_relation_count")
+    if (
+        report.get("requested_mode") != "certified-reuse"
+        or report.get("effective_mode") != "off"
+        or report.get("effective_reuse_state") != "disabled"
+        or certified != 0
+        or applied != 0
+    ):
+        raise ValueError("recurrence numerical relation fallback state is inconsistent")
+    validated = validate_recurrence_numerical_evidence_fallback(fallback)
+    return {
+        "abi": NUMERICAL_RELATION_FALLBACK_ABI,
+        "requested_mode": "certified-reuse",
+        "effective_mode": "off",
+        "effective_reuse_state": "disabled",
+        "reason": EVIDENCE_ENVELOPE_FALLBACK_REASON,
+        "geometry": dict(cast(Mapping[str, int], validated["geometry"])),
+        "certified_relation_count": 0,
+        "applied_relation_count": 0,
+    }
+
+
+def _decimal_string(value: Decimal) -> str:
+    if not value.is_finite():
+        raise ValueError("non-finite Decimal cannot be canonicalized")
+    if value == 0:
+        return "0"
+    text = format(value, "f")
+    if "." in text:
+        text = text.rstrip("0").rstrip(".")
+    return "0" if text in {"-0", "+0", ""} else text
+
+
+def _fraction_string(value: Fraction) -> str:
+    return (
+        str(value.numerator)
+        if value.denominator == 1
+        else f"{value.numerator}/{value.denominator}"
+    )
+
+
+def _residual_strings(residuals: _Residuals) -> _ResidualStrings:
+    return (
+        _fraction_string(residuals[0]),
+        _fraction_string(residuals[1]),
+        _fraction_string(residuals[2]),
+    )
+
+
+def _terminating_fraction_decimal(value: Fraction) -> Decimal:
+    denominator = value.denominator
+    twos = 0
+    fives = 0
+    while denominator % 2 == 0:
+        denominator //= 2
+        twos += 1
+    while denominator % 5 == 0:
+        denominator //= 5
+        fives += 1
+    if denominator != 1:
+        raise ValueError("recurrence parameter context is not a finite decimal")
+    places = max(twos, fives)
+    scaled = value.numerator
+    scaled *= 2 ** (places - twos)
+    scaled *= 5 ** (places - fives)
+    sign = "-" if scaled < 0 else ""
+    digits = str(abs(scaled))
+    if places == 0:
+        return Decimal(f"{sign}{digits}")
+    digits = digits.rjust(places + 1, "0")
+    return Decimal(f"{sign}{digits[:-places]}.{digits[-places:]}")
+
+
+def _canonical_sha256(value: object) -> str:
+    digest = hashlib.sha256()
+    for chunk in _iter_canonical_json_chunks(value):
+        digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _canonical_json_bytes(value: object) -> bytes:
+    if isinstance(value, _CanonicalJsonStreamValue):
+        return b"".join(_iter_canonical_json_chunks(value))
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+def _iter_canonical_json_chunks(value: object) -> Iterator[bytes]:
+    """Yield the unique ASCII encoding accepted at the native boundary."""
+
+    if isinstance(value, _CanonicalJsonStreamValue):
+        yield from value.iter_canonical_json_chunks()
+        return
+    if value is None:
+        yield b"null"
+        return
+    if value is True:
+        yield b"true"
+        return
+    if value is False:
+        yield b"false"
+        return
+    if type(value) is int:
+        yield str(value).encode("ascii")
+        return
+    if isinstance(value, str):
+        yield json.dumps(value, ensure_ascii=True).encode("ascii")
+        return
+    if isinstance(value, Mapping):
+        if not all(isinstance(key, str) for key in value):
+            raise TypeError("canonical JSON mappings require string keys")
+        yield b"{"
+        for index, key in enumerate(sorted(value)):
+            if index:
+                yield b","
+            yield json.dumps(key, ensure_ascii=True).encode("ascii")
+            yield b":"
+            yield from _iter_canonical_json_chunks(value[key])
+        yield b"}"
+        return
+    if isinstance(value, Sequence) and not isinstance(
+        value,
+        str | bytes | bytearray,
+    ):
+        yield b"["
+        for index, item in enumerate(value):
+            if index:
+                yield b","
+            yield from _iter_canonical_json_chunks(item)
+        yield b"]"
+        return
+    if isinstance(value, float):
+        raise TypeError(
+            "canonical recurrence evidence uses binary64 hex strings, not "
+            "JSON float spellings"
+        )
+    raise TypeError(f"unsupported canonical JSON value {type(value).__name__}")
+
+
+def _bounded_canonical_json_bytes(
+    value: object,
+    *,
+    byte_limit: int | None,
+    label: str,
+) -> bytes:
+    """Encode canonically, honoring an explicitly requested byte limit."""
+
+    if byte_limit is not None and byte_limit <= 0:
+        raise ValueError(f"{label} byte limit is invalid")
+    encoded = bytearray()
+    for chunk in _iter_canonical_json_chunks(value):
+        next_size = len(encoded) + len(chunk)
+        if byte_limit is not None and next_size > byte_limit:
+            raise _CanonicalEvidenceCapacityExceeded(
+                f"{label} exceeds the explicit {byte_limit}-byte canonical boundary"
+            )
+        encoded.extend(chunk)
+    return bytes(encoded)
+
+
+def _write_compressed_canonical_evidence(
+    value: object,
+    stream: BinaryIO,
+    *,
+    canonical_byte_limit: int | None,
+) -> int:
+    """Stream canonical JSON into one zlib transport envelope."""
+
+    if canonical_byte_limit is not None and canonical_byte_limit <= 0:
+        raise ValueError("recurrence compressed evidence canonical boundary is invalid")
+    stream.seek(0)
+    stream.truncate(0)
+    stream.write(b"\0" * _COMPRESSED_EVIDENCE_HEADER.size)
+    compressor = zlib.compressobj(level=1, wbits=zlib.MAX_WBITS)
+    digest = hashlib.sha256()
+    canonical_byte_count = 0
+    transport_byte_count = _COMPRESSED_EVIDENCE_HEADER.size
+
+    def write_compressed(chunk: bytes) -> None:
+        nonlocal transport_byte_count
+        if not chunk:
+            return
+        transport_byte_count += len(chunk)
+        stream.write(chunk)
+
+    for chunk in _iter_canonical_json_chunks(value):
+        canonical_byte_count += len(chunk)
+        if (
+            canonical_byte_limit is not None
+            and canonical_byte_count > canonical_byte_limit
+        ):
+            raise _CanonicalEvidenceCapacityExceeded(
+                "recurrence numerical raw evidence exceeds the explicit "
+                f"{canonical_byte_limit}-byte decompression boundary"
+            )
+        digest.update(chunk)
+        write_compressed(compressor.compress(chunk))
+    write_compressed(compressor.flush())
+    stream.seek(0)
+    stream.write(
+        _COMPRESSED_EVIDENCE_HEADER.pack(
+            _COMPRESSED_EVIDENCE_MAGIC,
+            canonical_byte_count,
+            digest.digest(),
+        )
+    )
+    stream.flush()
+    stream.seek(0, 2)
+    if stream.tell() != transport_byte_count:
+        raise ValueError("recurrence compressed evidence spool length drifted")
+    return canonical_byte_count
+
+
+def _read_compressed_evidence_spool(stream: BinaryIO) -> bytes:
+    stream.seek(0)
+    encoded = stream.read()
+    if len(encoded) < _COMPRESSED_EVIDENCE_HEADER.size:
+        raise ValueError("recurrence compressed evidence spool is truncated")
+    magic, _canonical_byte_count, _digest = _COMPRESSED_EVIDENCE_HEADER.unpack_from(
+        encoded
+    )
+    if magic != _COMPRESSED_EVIDENCE_MAGIC:
+        raise ValueError("recurrence compressed evidence spool has invalid magic")
+    return encoded
+
+
+def _validate_raw_evidence_canonical_size(
+    size: int,
+    *,
+    byte_limit: int | None = None,
+) -> None:
+    if size < 0 or (byte_limit is not None and (byte_limit <= 0 or size > byte_limit)):
+        raise ValueError(
+            "recurrence numerical raw evidence exceeds its explicit memory envelope "
+            f"(size={size}, byte_limit={byte_limit})"
+        )
+
+
+def _raw_evidence_wire_byte_limit(
+    *,
+    scalar_count: int,
+    row_count: int,
+    memory_envelope_bytes: int = _RAW_EVIDENCE_MEMORY_TARGET_BYTES,
+) -> int:
+    """Return the per-shape wire allowance for a supplied batching target."""
+
+    if (
+        scalar_count < 0
+        or row_count < 0
+        or type(memory_envelope_bytes) is not int
+        or memory_envelope_bytes <= 0
+    ):
+        raise ValueError("recurrence raw-evidence memory geometry is invalid")
+    resident_without_wire = _raw_evidence_memory_upper_bound(
+        0,
+        scalar_count=scalar_count,
+        row_count=row_count,
+    )
+    minimum_resident = resident_without_wire + (
+        _MIN_RAW_EVIDENCE_WIRE_BYTES * _RAW_EVIDENCE_WIRE_PEAK_COPIES
+    )
+    if minimum_resident > memory_envelope_bytes:
+        raise _RawEvidenceWireEnvelopeExceeded(
+            "recurrence raw-evidence capture geometry leaves less than the "
+            f"required {_MIN_RAW_EVIDENCE_WIRE_BYTES}-byte canonical wire "
+            f"reserve inside its {memory_envelope_bytes}-byte memory "
+            f"envelope (scalars={scalar_count}, rows={row_count}, "
+            f"resident_without_wire={resident_without_wire})"
+        )
+    return (
+        memory_envelope_bytes - resident_without_wire
+    ) // _RAW_EVIDENCE_WIRE_PEAK_COPIES
+
+
+def _raw_evidence_geometry_counts(
+    sections: _RecurrenceExactSectionsV1,
+    *,
+    candidate_probe_count: int,
+    verification_probe_count: int,
+    runtime_parameter_count: int,
+) -> tuple[int, int, int, int]:
+    if (
+        candidate_probe_count <= 0
+        or verification_probe_count <= 0
+        or runtime_parameter_count < 0
+    ):
+        raise ValueError("recurrence raw-evidence probe geometry is invalid")
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=len(sections.currents),
+        component_count=sum(current.component_count for current in sections.currents),
+        candidate_probe_count=candidate_probe_count,
+        verification_probe_count=verification_probe_count,
+        runtime_parameter_count=runtime_parameter_count,
+    )
+    return (
+        geometry.current_count,
+        geometry.component_count,
+        geometry.scalar_count,
+        geometry.row_count,
+    )
+
+
+def _spooled_capture_memory_upper_bound(
+    *,
+    current_count: int,
+    component_count: int,
+    maximum_probe_count: int,
+    runtime_parameter_count: int,
+    include_candidate_index: bool = True,
+) -> int:
+    """Bound one capture graph plus the global index before both are spooled."""
+
+    values = (
+        current_count,
+        component_count,
+        maximum_probe_count,
+        runtime_parameter_count,
+    )
+    if any(value < 0 for value in values) or maximum_probe_count == 0:
+        raise ValueError("recurrence spooled capture geometry is invalid")
+    scalar_count = (
+        2 * component_count * maximum_probe_count
+        + runtime_parameter_count * maximum_probe_count
+    )
+    row_count = current_count + runtime_parameter_count
+    return (
+        _RAW_EVIDENCE_FIXED_RESERVE_BYTES
+        + scalar_count * _RAW_EVIDENCE_SCALAR_RESIDENT_BYTES
+        + row_count * _RAW_EVIDENCE_ROW_RESIDENT_BYTES
+        + _SPOOLED_CAPTURE_COMPRESSION_RESERVE_BYTES
+        + (
+            current_count * _SPOOLED_CANDIDATE_INDEX_BYTES_PER_CURRENT
+            if include_candidate_index
+            else 0
+        )
+    )
+
+
+def _select_raw_evidence_storage_geometry(
+    sections: _RecurrenceExactSectionsV1,
+    *,
+    candidate_probe_count: int,
+    verification_probe_count: int,
+    runtime_parameter_count: int,
+) -> _RawEvidenceStorageGeometry:
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=len(sections.currents),
+        component_count=sum(current.component_count for current in sections.currents),
+        candidate_probe_count=candidate_probe_count,
+        verification_probe_count=verification_probe_count,
+        runtime_parameter_count=runtime_parameter_count,
+    )
+    return _select_raw_evidence_storage_geometry_for_counts(geometry)
+
+
+def _select_raw_evidence_storage_geometry_for_counts(
+    geometry: RecurrenceNumericalEvidenceGeometry,
+    *,
+    memory_envelope_bytes: int | None = None,
+) -> _RawEvidenceStorageGeometry:
+    """Select storage from scalar geometry before allocating observations."""
+
+    if memory_envelope_bytes is not None and (
+        type(memory_envelope_bytes) is not int or memory_envelope_bytes <= 0
+    ):
+        raise ValueError("recurrence raw-evidence memory envelope is invalid")
+    try:
+        byte_limit = _raw_evidence_wire_byte_limit(
+            scalar_count=geometry.scalar_count,
+            row_count=geometry.row_count,
+            memory_envelope_bytes=(
+                memory_envelope_bytes or _RAW_EVIDENCE_MEMORY_TARGET_BYTES
+            ),
+        )
+    except _RawEvidenceWireEnvelopeExceeded as raw_error:
+        return _compressed_raw_evidence_storage_geometry_for_counts(
+            geometry,
+            memory_envelope_bytes=memory_envelope_bytes,
+            raw_reason=str(raw_error),
+        )
+    return _RawEvidenceStorageGeometry(
+        scalar_count=geometry.scalar_count,
+        row_count=geometry.row_count,
+        canonical_byte_limit=byte_limit if memory_envelope_bytes is not None else None,
+        encoding=_RAW_EVIDENCE_ENCODING,
+        producer_resident_upper_bound=_raw_evidence_memory_upper_bound(
+            _MIN_RAW_EVIDENCE_WIRE_BYTES,
+            scalar_count=geometry.scalar_count,
+            row_count=geometry.row_count,
+        ),
+    )
+
+
+def _compressed_raw_evidence_storage_geometry_for_counts(
+    geometry: RecurrenceNumericalEvidenceGeometry,
+    *,
+    memory_envelope_bytes: int | None = None,
+    raw_reason: str,
+) -> _RawEvidenceStorageGeometry:
+    """Select the sequential compressed spool or return the typed fallback."""
+
+    producer_bound = geometry.spooled_producer_resident_upper_bound()
+    if memory_envelope_bytes is not None and producer_bound > memory_envelope_bytes:
+        raise RecurrenceNumericalEvidenceEnvelopeExceeded(
+            geometry,
+            memory_envelope_bytes=memory_envelope_bytes,
+            spooled_producer_resident_bytes=producer_bound,
+            raw_reason=raw_reason,
+        )
+    return _RawEvidenceStorageGeometry(
+        scalar_count=geometry.scalar_count,
+        row_count=geometry.row_count,
+        canonical_byte_limit=None,
+        encoding=_COMPRESSED_EVIDENCE_ENCODING,
+        producer_resident_upper_bound=producer_bound,
+    )
+
+
+def recurrence_numerical_evidence_capacity_outcome(
+    sections: _RecurrenceExactSectionsV1,
+    *,
+    candidate_probe_count: int,
+    verification_probe_count: int,
+    runtime_parameter_count: int,
+    error: BaseException,
+) -> RecurrenceNumericalEvidenceEnvelopeExceeded | None:
+    """Map only recognized native optional-evidence capacity failures.
+
+    Integrity, lexical, structural, and relation-correctness failures remain
+    fail-closed.  The native messages listed here are the bounded-memory exits
+    emitted after (or while establishing) authenticated evidence geometry.
+    """
+
+    reason = str(error)
+    if not any(
+        marker in reason for marker in _NATIVE_OPTIONAL_EVIDENCE_CAPACITY_MARKERS
+    ):
+        return None
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=len(sections.currents),
+        component_count=sum(current.component_count for current in sections.currents),
+        candidate_probe_count=candidate_probe_count,
+        verification_probe_count=verification_probe_count,
+        runtime_parameter_count=runtime_parameter_count,
+    )
+    return RecurrenceNumericalEvidenceEnvelopeExceeded(
+        geometry,
+        memory_envelope_bytes=_RAW_EVIDENCE_MEMORY_TARGET_BYTES,
+        spooled_producer_resident_bytes=(
+            geometry.spooled_producer_resident_upper_bound()
+        ),
+        raw_reason=reason,
+    )
+
+
+def _validate_raw_evidence_geometry(
+    sections: _RecurrenceExactSectionsV1,
+    *,
+    candidate_probe_count: int,
+    verification_probe_count: int,
+    runtime_parameter_count: int,
+) -> tuple[int, int, None]:
+    """Validate capture dimensions without imposing a memory ceiling."""
+
+    _current_count, _component_count, scalar_count, row_count = (
+        _raw_evidence_geometry_counts(
+            sections,
+            candidate_probe_count=candidate_probe_count,
+            verification_probe_count=verification_probe_count,
+            runtime_parameter_count=runtime_parameter_count,
+        )
+    )
+    return scalar_count, row_count, None
+
+
+def _raw_evidence_memory_upper_bound(
+    size: int,
+    *,
+    scalar_count: int,
+    row_count: int,
+) -> int:
+    if size < 0 or scalar_count < 0 or row_count < 0:
+        raise ValueError("recurrence raw-evidence memory geometry is invalid")
+    return (
+        _RAW_EVIDENCE_FIXED_RESERVE_BYTES
+        + scalar_count * _RAW_EVIDENCE_SCALAR_RESIDENT_BYTES
+        + row_count * _RAW_EVIDENCE_ROW_RESIDENT_BYTES
+        + size * _RAW_EVIDENCE_WIRE_PEAK_COPIES
+    )
+
+
+def _synthetic_raw_evidence_bytes(
+    current_count: int,
+    *,
+    component_count: int,
+    candidate_probe_count: int,
+    verification_probe_count: int,
+    decimal_characters: int,
+) -> int:
+    """Measure the canonical raw-observation footprint without allocating it."""
+
+    if (
+        current_count < 0
+        or component_count <= 0
+        or candidate_probe_count <= 0
+        or verification_probe_count <= 0
+        or decimal_characters <= 0
+    ):
+        raise ValueError("synthetic raw-evidence geometry is invalid")
+    return _synthetic_raw_evidence_bytes_by_dimension_counts(
+        {component_count: current_count},
+        candidate_probe_count=candidate_probe_count,
+        verification_probe_count=verification_probe_count,
+        decimal_characters=decimal_characters,
+    )
+
+
+def _synthetic_raw_evidence_bytes_by_dimension_counts(
+    dimension_counts: Mapping[int, int],
+    *,
+    candidate_probe_count: int,
+    verification_probe_count: int,
+    decimal_characters: int,
+) -> int:
+    """Measure a mixed-dimension canonical raw-observation footprint."""
+
+    if (
+        not dimension_counts
+        or candidate_probe_count <= 0
+        or verification_probe_count <= 0
+        or decimal_characters <= 0
+        or any(
+            dimension <= 0 or count < 0 for dimension, count in dimension_counts.items()
+        )
+    ):
+        raise ValueError("synthetic raw-evidence geometry is invalid")
+    dimensions = tuple(
+        dimension
+        for dimension, count in sorted(dimension_counts.items())
+        for _ in range(count)
+    )
+    current_count = len(dimensions)
+    scalar = "1" + "2" * (decimal_characters - 1)
+
+    def array_size(point_count: int) -> int:
+        total = 2 + max(0, current_count - 1)
+        for current_id, dimension in enumerate(dimensions):
+            values = [[scalar, f"-{scalar}"]] * (dimension * point_count)
+            total += len(
+                _canonical_json_bytes(
+                    {
+                        "current_id": current_id,
+                        "dimension": dimension,
+                        "values": values,
+                    }
+                )
+            )
+        return total
+
+    skeleton_size = len(
+        _canonical_json_bytes(
+            {
+                "candidate_capture": {"observations": []},
+                "verification_capture": {"observations": []},
+            }
+        )
+    )
+    return (
+        skeleton_size
+        + array_size(candidate_probe_count)
+        + array_size(verification_probe_count)
+        - 4
+    )
+
+
+__all__ = [
+    "EVIDENCE_ENVELOPE_FALLBACK_REASON",
+    "EVIDENCE_ENVELOPE_FALLBACK_WARNING",
+    "NUMERICAL_RELATION_CORRECTNESS_ABI",
+    "NUMERICAL_RELATION_FALLBACK_ABI",
+    "RecurrenceCurrentObservationCapture",
+    "RecurrenceNumericalCurrentCertificate",
+    "RecurrenceNumericalCurrentWarmupResult",
+    "RecurrenceNumericalEvidenceEnvelopeExceeded",
+    "RecurrenceNumericalEvidenceGeometry",
+    "build_recurrence_numerical_current_probe_points",
+    "capture_recurrence_current_observations",
+    "numerical_relation_correctness_payload",
+    "recurrence_numerical_current_envelope_fallback_report",
+    "recurrence_numerical_current_opt_out_report",
+    "recurrence_numerical_evidence_capacity_outcome",
+    "recurrence_numerical_relation_correctness_summary",
+    "recurrence_numerical_relation_fallback_summary",
+    "recurrence_numerical_source_semantics_sha256",
+    "run_recurrence_numerical_current_warmup",
+    "validate_recurrence_numerical_current_application",
+    "validate_recurrence_numerical_evidence_fallback",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/recurrence_pairing_columnar.py b/pyamplicol/src/pyamplicol/generation/recurrence_pairing_columnar.py
new file mode 100644
index 0000000000..da2d36e7ae
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/recurrence_pairing_columnar.py
@@ -0,0 +1,1200 @@
+# SPDX-License-Identifier: 0BSD
+"""Private fixed-width encoder for external-fermion pairing catalogs.
+
+This module is an intentionally unintegrated staging contract for a future
+Rust recurrence-builder ABI.  It turns :class:`FermionPairingCatalogV1` into
+owned, immutable NumPy structure-of-arrays tables without object dtypes.
+Variable-length records use contiguous ``u64`` ranges, exact integers use
+signed-magnitude little-endian ``u64`` limbs, and textual model contracts use
+a deterministic UTF-8 catalog.
+
+The leading underscore on the encoder and payload is deliberate.  Consumers
+must not depend on this ABI until a matching Rust decoder is frozen.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import itertools
+import json
+import math
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any, Final
+
+import numpy as np
+
+from pyamplicol.generation.recurrence_columnar import (
+    RecurrenceColumn,
+    RecurrenceColumnarInputError,
+    RecurrenceColumnarTable,
+)
+from pyamplicol.generation.recurrence_fermion_pairing import (
+    NO_FERMION_LINE,
+    PAIRING_PROOF_ALGORITHM,
+    ExternalFermionEndpointRowV1,
+    FermionPairingCatalogV1,
+    FermionPairingClassRowV1,
+    FermionPairingRuleRowV1,
+)
+from pyamplicol.models.recurrence_template import ExactComplexRationalV1
+
+_PAIRING_COLUMNAR_ABI: Final = "pyamplicol-recurrence-fermion-pairing-columnar-v1"
+_PAIRING_COLUMNAR_SCHEMA_VERSION: Final = 1
+_U8 = np.dtype("u1")
+_U32 = np.dtype("<u4")
+_U64 = np.dtype("<u8")
+_I32 = np.dtype("<i4")
+
+_PARTICLE_ORIENTATION_CODES: Final = {"particle": 0, "antiparticle": 1}
+_COLOR_ORIENTATION_CODES: Final = {"fundamental": 0, "antifundamental": 1}
+
+_ColumnSpec = tuple[str, np.dtype[Any], tuple[int, ...]]
+_TABLE_SCHEMAS: Final[dict[str, tuple[_ColumnSpec, ...]]] = {
+    "header": (
+        ("schema_version", _U32, ()),
+        ("abi_string_id", _U32, ()),
+        ("process_key_string_id", _U32, ()),
+        ("proof_algorithm_string_id", _U32, ()),
+        ("source_count", _U32, ()),
+        ("endpoint_count", _U32, ()),
+        ("pairing_class_count", _U32, ()),
+        ("rule_count", _U32, ()),
+        ("endpoint_state_template_count", _U64, ()),
+        ("endpoint_anti_state_template_count", _U64, ()),
+        ("endpoint_basis_count", _U64, ()),
+        ("endpoint_color_representation_count", _U64, ()),
+        ("class_fundamental_slot_count", _U64, ()),
+        ("class_antifundamental_slot_count", _U64, ()),
+        ("class_reference_pairing_count", _U64, ()),
+        ("rule_class_pairing_index_count", _U64, ()),
+        ("rule_endpoint_pairing_count", _U64, ()),
+        ("rule_source_permutation_count", _U64, ()),
+        ("rule_lineage_count", _U64, ()),
+        ("exact_integer_count", _U32, ()),
+        ("exact_integer_limb_count", _U64, ()),
+        ("string_count", _U32, ()),
+        ("string_byte_count", _U64, ()),
+        ("no_fermion_line", _U32, ()),
+        ("topology_digest", _U8, (32,)),
+        ("semantic_digest", _U8, (32,)),
+    ),
+    "endpoints": (
+        ("endpoint_id", _U32, ()),
+        ("source_slot", _U32, ()),
+        ("public_label", _U32, ()),
+        ("species_class_id", _U32, ()),
+        ("species_string_id", _U32, ()),
+        ("particle_orientation", _U8, ()),
+        ("color_orientation", _U8, ()),
+        ("state_template_start", _U64, ()),
+        ("state_template_count", _U64, ()),
+        ("anti_state_template_start", _U64, ()),
+        ("anti_state_template_count", _U64, ()),
+        ("basis_start", _U64, ()),
+        ("basis_count", _U64, ()),
+        ("color_representation_start", _U64, ()),
+        ("color_representation_count", _U64, ()),
+        ("contract_digest", _U8, (32,)),
+    ),
+    "endpoint_state_template_ids": (("string_id", _U32, ()),),
+    "endpoint_anti_state_template_ids": (("string_id", _U32, ()),),
+    "endpoint_basis_ids": (("string_id", _U32, ()),),
+    "endpoint_color_representations": (("value", _I32, ()),),
+    "pairing_classes": (
+        ("class_id", _U32, ()),
+        ("species_class_id", _U32, ()),
+        ("species_string_id", _U32, ()),
+        ("fundamental_slot_start", _U64, ()),
+        ("fundamental_slot_count", _U64, ()),
+        ("antifundamental_slot_start", _U64, ()),
+        ("antifundamental_slot_count", _U64, ()),
+        ("reference_pairing_start", _U64, ()),
+        ("reference_pairing_count", _U64, ()),
+        ("pairing_count", _U64, ()),
+        ("proof_digest", _U8, (32,)),
+    ),
+    "class_fundamental_slots": (("source_slot", _U32, ()),),
+    "class_antifundamental_slots": (("source_slot", _U32, ()),),
+    "class_reference_pairings": (
+        ("fundamental_source_slot", _U32, ()),
+        ("antifundamental_source_slot", _U32, ()),
+    ),
+    "rules": (
+        ("rule_id", _U32, ()),
+        ("class_pairing_index_start", _U64, ()),
+        ("class_pairing_index_count", _U64, ()),
+        ("endpoint_pairing_start", _U64, ()),
+        ("endpoint_pairing_count", _U64, ()),
+        ("source_permutation_start", _U64, ()),
+        ("source_permutation_count", _U64, ()),
+        ("lineage_start", _U64, ()),
+        ("lineage_count", _U64, ()),
+        ("fermion_parity", _I32, ()),
+        ("real_numerator_integer_id", _U32, ()),
+        ("real_denominator_integer_id", _U32, ()),
+        ("imag_numerator_integer_id", _U32, ()),
+        ("imag_denominator_integer_id", _U32, ()),
+        ("multiplicity", _U64, ()),
+        ("proof_algorithm_string_id", _U32, ()),
+        ("proof_digest", _U8, (32,)),
+    ),
+    "rule_class_pairing_indices": (
+        ("class_id", _U32, ()),
+        ("pairing_index", _U64, ()),
+    ),
+    "rule_endpoint_pairings": (
+        ("fundamental_source_slot", _U32, ()),
+        ("antifundamental_source_slot", _U32, ()),
+    ),
+    "rule_source_slot_permutations": (("source_slot", _U32, ()),),
+    "rule_lineages": (("line_id", _U32, ()),),
+    "exact_integers": (
+        ("integer_id", _U32, ()),
+        ("sign", _I32, ()),
+        ("limb_start", _U64, ()),
+        ("limb_count", _U64, ()),
+    ),
+    "exact_integer_limbs": (("value", _U64, ()),),
+    "string_ranges": (
+        ("string_id", _U32, ()),
+        ("start", _U64, ()),
+        ("count", _U64, ()),
+    ),
+    "string_bytes": (("value", _U8, ()),),
+}
+_TABLE_ORDER: Final = tuple(_TABLE_SCHEMAS)
+
+
+@dataclass(frozen=True, slots=True)
+class _FermionPairingColumnarV1:
+    """Owned fixed-width pairing payload awaiting a future Rust decoder."""
+
+    abi: str
+    tables: tuple[RecurrenceColumnarTable, ...]
+
+    def __post_init__(self) -> None:
+        if self.abi != _PAIRING_COLUMNAR_ABI:
+            raise RecurrenceColumnarInputError(
+                f"unsupported fermion-pairing columnar ABI {self.abi!r}"
+            )
+        _validate_encoded_tables(self.tables)
+
+    def table(self, name: str) -> RecurrenceColumnarTable:
+        """Return one immutable table by its private ABI name."""
+
+        for table in self.tables:
+            if table.name == name:
+                return table
+        raise KeyError(f"fermion-pairing payload has no table {name!r}")
+
+
+class _StringCatalog:
+    def __init__(self, values: Iterable[str]) -> None:
+        canonical = {_nonempty_text(value, "pairing string") for value in values}
+        self.values = tuple(sorted(canonical))
+        _checked_u32(len(self.values), "pairing string count")
+        self._ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, value: str) -> int:
+        try:
+            return self._ids[value]
+        except KeyError as error:
+            raise RecurrenceColumnarInputError(
+                f"pairing string {value!r} was not collected"
+            ) from error
+
+
+class _ExactIntegerCatalog:
+    def __init__(self, values: Iterable[int]) -> None:
+        canonical = {_checked_int(value, "exact factor integer") for value in values}
+        self.values = tuple(sorted(canonical))
+        _checked_u32(len(self.values), "exact integer count")
+        self._ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, value: int) -> int:
+        try:
+            return self._ids[value]
+        except KeyError as error:
+            raise RecurrenceColumnarInputError(
+                f"exact integer {value} was not collected"
+            ) from error
+
+
+def _encode_fermion_pairing_catalog_v1(
+    catalog: FermionPairingCatalogV1,
+) -> _FermionPairingColumnarV1:
+    """Validate and encode a canonical pairing catalog.
+
+    The function is private because no Rust consumer is frozen yet.  It is
+    deterministic for semantically identical input and fails before allocation
+    of large flat arrays when IDs, ranges, proofs, or exact factors are stale.
+    """
+
+    _validate_logical_catalog(catalog)
+    strings = _StringCatalog(_catalog_strings(catalog))
+    exact_integers = _ExactIntegerCatalog(_catalog_exact_integers(catalog))
+
+    endpoint_state_ids = [
+        strings.id(value)
+        for endpoint in catalog.endpoints
+        for value in endpoint.state_template_ids
+    ]
+    endpoint_anti_state_ids = [
+        strings.id(value)
+        for endpoint in catalog.endpoints
+        for value in endpoint.anti_state_template_ids
+    ]
+    endpoint_basis_ids = [
+        strings.id(value)
+        for endpoint in catalog.endpoints
+        for value in endpoint.basis_ids
+    ]
+    endpoint_color_representations = [
+        value
+        for endpoint in catalog.endpoints
+        for value in endpoint.color_representations
+    ]
+    class_fundamental_slots = [
+        value
+        for pairing_class in catalog.pairing_classes
+        for value in pairing_class.fundamental_source_slots
+    ]
+    class_antifundamental_slots = [
+        value
+        for pairing_class in catalog.pairing_classes
+        for value in pairing_class.antifundamental_source_slots
+    ]
+    class_reference_pairings = [
+        value
+        for pairing_class in catalog.pairing_classes
+        for value in pairing_class.reference_pairings
+    ]
+    rule_class_indices = [
+        value for rule in catalog.rules for value in rule.class_pairing_indices
+    ]
+    rule_endpoint_pairings = [
+        value for rule in catalog.rules for value in rule.endpoint_pairings
+    ]
+    rule_source_permutations = [
+        value for rule in catalog.rules for value in rule.source_slot_permutation
+    ]
+    rule_lineages = [
+        value for rule in catalog.rules for value in rule.lineage_by_source_slot
+    ]
+
+    integer_limbs = [
+        limb for value in exact_integers.values for limb in _unsigned_limbs(value)
+    ]
+    string_payloads = [value.encode("utf-8") for value in strings.values]
+    string_bytes = b"".join(string_payloads)
+
+    tables: list[RecurrenceColumnarTable] = []
+    tables.append(
+        _build_header_table(
+            catalog,
+            strings,
+            exact_integers,
+            endpoint_state_ids=endpoint_state_ids,
+            endpoint_anti_state_ids=endpoint_anti_state_ids,
+            endpoint_basis_ids=endpoint_basis_ids,
+            endpoint_color_representations=endpoint_color_representations,
+            class_fundamental_slots=class_fundamental_slots,
+            class_antifundamental_slots=class_antifundamental_slots,
+            class_reference_pairings=class_reference_pairings,
+            rule_class_indices=rule_class_indices,
+            rule_endpoint_pairings=rule_endpoint_pairings,
+            rule_source_permutations=rule_source_permutations,
+            rule_lineages=rule_lineages,
+            integer_limbs=integer_limbs,
+            string_bytes=string_bytes,
+        )
+    )
+    tables.append(_build_endpoints_table(catalog.endpoints, strings))
+    tables.append(_one_column_table("endpoint_state_template_ids", endpoint_state_ids))
+    tables.append(
+        _one_column_table("endpoint_anti_state_template_ids", endpoint_anti_state_ids)
+    )
+    tables.append(_one_column_table("endpoint_basis_ids", endpoint_basis_ids))
+    tables.append(
+        _one_column_table(
+            "endpoint_color_representations", endpoint_color_representations
+        )
+    )
+    tables.append(_build_pairing_classes_table(catalog.pairing_classes, strings))
+    tables.append(_one_column_table("class_fundamental_slots", class_fundamental_slots))
+    tables.append(
+        _one_column_table("class_antifundamental_slots", class_antifundamental_slots)
+    )
+    tables.append(_pair_table("class_reference_pairings", class_reference_pairings))
+    tables.append(_build_rules_table(catalog.rules, strings, exact_integers))
+    tables.append(_class_index_table(rule_class_indices))
+    tables.append(_pair_table("rule_endpoint_pairings", rule_endpoint_pairings))
+    tables.append(
+        _one_column_table("rule_source_slot_permutations", rule_source_permutations)
+    )
+    tables.append(_one_column_table("rule_lineages", rule_lineages))
+    tables.extend(_build_exact_integer_tables(exact_integers))
+    tables.extend(_build_string_tables(strings, string_payloads))
+    return _FermionPairingColumnarV1(_PAIRING_COLUMNAR_ABI, tuple(tables))
+
+
+def _validate_logical_catalog(catalog: FermionPairingCatalogV1) -> None:
+    if not isinstance(catalog, FermionPairingCatalogV1):
+        raise TypeError("pairing columnar encoding requires FermionPairingCatalogV1")
+    _nonempty_text(catalog.process_key, "pairing process key")
+    source_count = _checked_u32(catalog.source_count, "pairing source count")
+    topology_digest = _digest_bytes(catalog.topology_digest, "topology digest")
+    semantic_digest = _digest_bytes(catalog.semantic_digest, "semantic digest")
+    del topology_digest, semantic_digest
+
+    endpoints = tuple(catalog.endpoints)
+    pairing_classes = tuple(catalog.pairing_classes)
+    rules = tuple(catalog.rules)
+    _checked_u32(len(endpoints), "pairing endpoint count")
+    _checked_u32(len(pairing_classes), "pairing class count")
+    _checked_u32(len(rules), "pairing rule count")
+    if not rules:
+        raise RecurrenceColumnarInputError(
+            "a fermion pairing catalog must contain its trivial or physical rule"
+        )
+
+    endpoint_by_slot: dict[int, ExternalFermionEndpointRowV1] = {}
+    for expected_id, endpoint in enumerate(endpoints):
+        if not isinstance(endpoint, ExternalFermionEndpointRowV1):
+            raise TypeError("pairing endpoints must be endpoint row v1 values")
+        if endpoint.endpoint_id != expected_id:
+            raise RecurrenceColumnarInputError(
+                "pairing endpoint IDs must be dense and canonical"
+            )
+        source_slot = _bounded_u32(
+            endpoint.source_slot, source_count, "pairing endpoint source slot"
+        )
+        if source_slot in endpoint_by_slot:
+            raise RecurrenceColumnarInputError(
+                "pairing endpoint source slots must be unique"
+            )
+        endpoint_by_slot[source_slot] = endpoint
+        _checked_u32(endpoint.public_label, "pairing endpoint public label")
+        _bounded_u32(
+            endpoint.species_class_id,
+            len(pairing_classes),
+            "endpoint species class",
+        )
+        _nonempty_text(endpoint.species_id, "endpoint species ID")
+        if endpoint.particle_orientation not in _PARTICLE_ORIENTATION_CODES:
+            raise RecurrenceColumnarInputError(
+                "endpoint particle orientation is not canonical"
+            )
+        if endpoint.color_orientation not in _COLOR_ORIENTATION_CODES:
+            raise RecurrenceColumnarInputError(
+                "endpoint color orientation is not canonical"
+            )
+        _canonical_strings(endpoint.state_template_ids, "state template IDs")
+        _canonical_strings(
+            endpoint.anti_state_template_ids, "antiparticle state template IDs"
+        )
+        _canonical_strings(endpoint.basis_ids, "endpoint basis IDs")
+        _canonical_i32s(
+            endpoint.color_representations, "endpoint color representations"
+        )
+        _digest_bytes(endpoint.contract_digest, "endpoint contract digest")
+    if tuple(endpoint_by_slot) != tuple(sorted(endpoint_by_slot)):
+        raise RecurrenceColumnarInputError(
+            "pairing endpoints must be ordered by source slot"
+        )
+
+    expected_class_order: list[tuple[int, ...]] = []
+    class_permutations: dict[int, tuple[tuple[int, ...], ...]] = {}
+    for expected_id, pairing_class in enumerate(pairing_classes):
+        if not isinstance(pairing_class, FermionPairingClassRowV1):
+            raise TypeError("pairing classes must be pairing class row v1 values")
+        if (
+            pairing_class.class_id != expected_id
+            or pairing_class.species_class_id != expected_id
+        ):
+            raise RecurrenceColumnarInputError(
+                "pairing class IDs must be dense, aligned, and canonical"
+            )
+        _nonempty_text(pairing_class.species_id, "pairing class species ID")
+        fundamental = _canonical_u32_slots(
+            pairing_class.fundamental_source_slots,
+            source_count,
+            "fundamental pairing slots",
+        )
+        antifundamental = _canonical_u32_slots(
+            pairing_class.antifundamental_source_slots,
+            source_count,
+            "antifundamental pairing slots",
+        )
+        if len(fundamental) != len(antifundamental):
+            raise RecurrenceColumnarInputError(
+                "pairing classes require balanced endpoint orientations"
+            )
+        expected_reference = tuple(zip(fundamental, antifundamental, strict=True))
+        if pairing_class.reference_pairings != expected_reference:
+            raise RecurrenceColumnarInputError(
+                "pairing class reference pairings are stale"
+            )
+        expected_count = math.factorial(len(fundamental))
+        if pairing_class.pairing_count != expected_count:
+            raise RecurrenceColumnarInputError("pairing class pairing count is stale")
+        _checked_u64(pairing_class.pairing_count, "pairing class pairing count")
+        class_endpoints = tuple(
+            endpoint
+            for endpoint in endpoints
+            if endpoint.species_class_id == expected_id
+        )
+        expected_fundamental = tuple(
+            endpoint.source_slot
+            for endpoint in class_endpoints
+            if endpoint.color_orientation == "fundamental"
+        )
+        expected_antifundamental = tuple(
+            endpoint.source_slot
+            for endpoint in class_endpoints
+            if endpoint.color_orientation == "antifundamental"
+        )
+        if (
+            fundamental != expected_fundamental
+            or antifundamental != expected_antifundamental
+            or any(
+                endpoint.species_id != pairing_class.species_id
+                for endpoint in class_endpoints
+            )
+        ):
+            raise RecurrenceColumnarInputError(
+                "pairing class endpoint membership is inconsistent"
+            )
+        expected_class_order.append(tuple(sorted((*fundamental, *antifundamental))))
+        class_payload = {
+            "algorithm": PAIRING_PROOF_ALGORITHM,
+            "antifundamental_source_slots": antifundamental,
+            "fundamental_source_slots": fundamental,
+            "reference_pairings": expected_reference,
+            "species_contract_digests": tuple(
+                sorted(endpoint.contract_digest for endpoint in class_endpoints)
+            ),
+        }
+        if pairing_class.proof_digest != _digest(class_payload):
+            raise RecurrenceColumnarInputError("pairing class proof digest is stale")
+        class_permutations[expected_id] = tuple(itertools.permutations(antifundamental))
+    if expected_class_order != sorted(expected_class_order):
+        raise RecurrenceColumnarInputError(
+            "pairing classes are not in canonical source-slot order"
+        )
+    if len({row.species_id for row in pairing_classes}) != len(pairing_classes):
+        raise RecurrenceColumnarInputError("pairing class species IDs must be unique")
+
+    expected_rule_count = math.prod(
+        pairing_class.pairing_count for pairing_class in pairing_classes
+    )
+    if len(rules) != expected_rule_count:
+        raise RecurrenceColumnarInputError("pairing rule product is incomplete")
+    for expected_id, rule in enumerate(rules):
+        _validate_rule(
+            rule,
+            expected_id=expected_id,
+            source_count=source_count,
+            pairing_classes=pairing_classes,
+            class_permutations=class_permutations,
+        )
+
+    topology_payload = _topology_payload(
+        source_count, endpoints, pairing_classes, rules
+    )
+    if catalog.topology_digest != _digest(topology_payload):
+        raise RecurrenceColumnarInputError("pairing topology digest is stale")
+    semantic_payload = {
+        "process_key": catalog.process_key,
+        "topology": topology_payload,
+        "endpoint_contracts": tuple(
+            {
+                "anti_state_template_ids": endpoint.anti_state_template_ids,
+                "basis_ids": endpoint.basis_ids,
+                "color_representations": endpoint.color_representations,
+                "contract_digest": endpoint.contract_digest,
+                "particle_orientation": endpoint.particle_orientation,
+                "species_id": endpoint.species_id,
+                "state_template_ids": endpoint.state_template_ids,
+            }
+            for endpoint in endpoints
+        ),
+    }
+    if catalog.semantic_digest != _digest(semantic_payload):
+        raise RecurrenceColumnarInputError("pairing semantic digest is stale")
+
+
+def _validate_rule(
+    rule: FermionPairingRuleRowV1,
+    *,
+    expected_id: int,
+    source_count: int,
+    pairing_classes: tuple[FermionPairingClassRowV1, ...],
+    class_permutations: Mapping[int, tuple[tuple[int, ...], ...]],
+) -> None:
+    if not isinstance(rule, FermionPairingRuleRowV1):
+        raise TypeError("pairing rules must be pairing rule row v1 values")
+    if rule.rule_id != expected_id:
+        raise RecurrenceColumnarInputError(
+            "pairing rule IDs must be dense and canonical"
+        )
+    expected_class_ids = tuple(range(len(pairing_classes)))
+    if tuple(item[0] for item in rule.class_pairing_indices) != expected_class_ids:
+        raise RecurrenceColumnarInputError(
+            "pairing rule class indices must cover every class in order"
+        )
+
+    endpoint_pairings: list[tuple[int, int]] = []
+    source_permutation = list(range(source_count))
+    parity = 1
+    for class_id, pairing_index in rule.class_pairing_indices:
+        _checked_u32(class_id, "rule pairing class ID")
+        _checked_u64(pairing_index, "rule class-local pairing index")
+        permutations = class_permutations[class_id]
+        if pairing_index >= len(permutations):
+            raise RecurrenceColumnarInputError(
+                "rule class-local pairing index is out of bounds"
+            )
+        pairing_class = pairing_classes[class_id]
+        selected = permutations[pairing_index]
+        parity *= _permutation_parity(
+            pairing_class.antifundamental_source_slots, selected
+        )
+        endpoint_pairings.extend(
+            zip(pairing_class.fundamental_source_slots, selected, strict=True)
+        )
+        for reference_slot, selected_slot in zip(
+            pairing_class.antifundamental_source_slots, selected, strict=True
+        ):
+            source_permutation[reference_slot] = selected_slot
+    expected_pairings = tuple(sorted(endpoint_pairings))
+    if rule.endpoint_pairings != expected_pairings:
+        raise RecurrenceColumnarInputError("rule endpoint pairings are stale")
+    if rule.source_slot_permutation != tuple(source_permutation):
+        raise RecurrenceColumnarInputError("rule source-slot permutation is stale")
+
+    lineage = [NO_FERMION_LINE] * source_count
+    for line_id, (fundamental_slot, antifundamental_slot) in enumerate(
+        expected_pairings
+    ):
+        lineage[fundamental_slot] = line_id
+        lineage[antifundamental_slot] = line_id
+    if rule.lineage_by_source_slot != tuple(lineage):
+        raise RecurrenceColumnarInputError("rule fermion lineage is stale")
+    if rule.fermion_parity != parity or rule.fermion_parity not in {-1, 1}:
+        raise RecurrenceColumnarInputError("rule fermion parity is stale")
+    expected_factor = ExactComplexRationalV1(parity, 1, 0, 1)
+    if rule.exact_factor != expected_factor:
+        raise RecurrenceColumnarInputError(
+            "rule exact factor does not reproduce its fermion parity"
+        )
+    if rule.multiplicity != 1:
+        raise RecurrenceColumnarInputError("pairing rule multiplicity is not canonical")
+    _checked_u64(rule.multiplicity, "pairing rule multiplicity")
+    if rule.proof_algorithm != PAIRING_PROOF_ALGORITHM:
+        raise RecurrenceColumnarInputError("pairing rule proof algorithm is stale")
+    rule_payload = {
+        "algorithm": PAIRING_PROOF_ALGORITHM,
+        "class_pairing_indices": rule.class_pairing_indices,
+        "endpoint_pairings": rule.endpoint_pairings,
+        "fermion_parity": rule.fermion_parity,
+        "lineage_by_source_slot": rule.lineage_by_source_slot,
+        "source_slot_permutation": rule.source_slot_permutation,
+    }
+    if rule.proof_digest != _digest(rule_payload):
+        raise RecurrenceColumnarInputError("pairing rule proof digest is stale")
+
+
+def _build_header_table(
+    catalog: FermionPairingCatalogV1,
+    strings: _StringCatalog,
+    exact_integers: _ExactIntegerCatalog,
+    **flat_values: Sequence[object] | bytes,
+) -> RecurrenceColumnarTable:
+    columns = _allocate("header", 1)
+    columns["schema_version"][0] = _PAIRING_COLUMNAR_SCHEMA_VERSION
+    columns["abi_string_id"][0] = strings.id(_PAIRING_COLUMNAR_ABI)
+    columns["process_key_string_id"][0] = strings.id(catalog.process_key)
+    columns["proof_algorithm_string_id"][0] = strings.id(PAIRING_PROOF_ALGORITHM)
+    columns["source_count"][0] = catalog.source_count
+    columns["endpoint_count"][0] = len(catalog.endpoints)
+    columns["pairing_class_count"][0] = len(catalog.pairing_classes)
+    columns["rule_count"][0] = len(catalog.rules)
+    count_columns = {
+        "endpoint_state_template_count": "endpoint_state_ids",
+        "endpoint_anti_state_template_count": "endpoint_anti_state_ids",
+        "endpoint_basis_count": "endpoint_basis_ids",
+        "endpoint_color_representation_count": "endpoint_color_representations",
+        "class_fundamental_slot_count": "class_fundamental_slots",
+        "class_antifundamental_slot_count": "class_antifundamental_slots",
+        "class_reference_pairing_count": "class_reference_pairings",
+        "rule_class_pairing_index_count": "rule_class_indices",
+        "rule_endpoint_pairing_count": "rule_endpoint_pairings",
+        "rule_source_permutation_count": "rule_source_permutations",
+        "rule_lineage_count": "rule_lineages",
+        "exact_integer_limb_count": "integer_limbs",
+        "string_byte_count": "string_bytes",
+    }
+    for column_name, value_name in count_columns.items():
+        columns[column_name][0] = _checked_u64(
+            len(flat_values[value_name]), column_name
+        )
+    columns["exact_integer_count"][0] = len(exact_integers.values)
+    columns["string_count"][0] = len(strings.values)
+    columns["no_fermion_line"][0] = NO_FERMION_LINE
+    columns["topology_digest"][0] = np.frombuffer(
+        _digest_bytes(catalog.topology_digest, "topology digest"), dtype=_U8
+    )
+    columns["semantic_digest"][0] = np.frombuffer(
+        _digest_bytes(catalog.semantic_digest, "semantic digest"), dtype=_U8
+    )
+    return _freeze_table("header", columns)
+
+
+def _build_endpoints_table(
+    endpoints: Sequence[ExternalFermionEndpointRowV1],
+    strings: _StringCatalog,
+) -> RecurrenceColumnarTable:
+    columns = _allocate("endpoints", len(endpoints))
+    state_cursor = anti_cursor = basis_cursor = color_cursor = 0
+    for row, endpoint in enumerate(endpoints):
+        columns["endpoint_id"][row] = endpoint.endpoint_id
+        columns["source_slot"][row] = endpoint.source_slot
+        columns["public_label"][row] = endpoint.public_label
+        columns["species_class_id"][row] = endpoint.species_class_id
+        columns["species_string_id"][row] = strings.id(endpoint.species_id)
+        columns["particle_orientation"][row] = _PARTICLE_ORIENTATION_CODES[
+            endpoint.particle_orientation
+        ]
+        columns["color_orientation"][row] = _COLOR_ORIENTATION_CODES[
+            endpoint.color_orientation
+        ]
+        for prefix, cursor, values in (
+            ("state_template", state_cursor, endpoint.state_template_ids),
+            ("anti_state_template", anti_cursor, endpoint.anti_state_template_ids),
+            ("basis", basis_cursor, endpoint.basis_ids),
+            (
+                "color_representation",
+                color_cursor,
+                endpoint.color_representations,
+            ),
+        ):
+            columns[f"{prefix}_start"][row] = cursor
+            columns[f"{prefix}_count"][row] = len(values)
+        state_cursor += len(endpoint.state_template_ids)
+        anti_cursor += len(endpoint.anti_state_template_ids)
+        basis_cursor += len(endpoint.basis_ids)
+        color_cursor += len(endpoint.color_representations)
+        columns["contract_digest"][row] = np.frombuffer(
+            _digest_bytes(endpoint.contract_digest, "endpoint contract digest"),
+            dtype=_U8,
+        )
+    return _freeze_table("endpoints", columns)
+
+
+def _build_pairing_classes_table(
+    pairing_classes: Sequence[FermionPairingClassRowV1],
+    strings: _StringCatalog,
+) -> RecurrenceColumnarTable:
+    columns = _allocate("pairing_classes", len(pairing_classes))
+    fundamental_cursor = antifundamental_cursor = reference_cursor = 0
+    for row, pairing_class in enumerate(pairing_classes):
+        columns["class_id"][row] = pairing_class.class_id
+        columns["species_class_id"][row] = pairing_class.species_class_id
+        columns["species_string_id"][row] = strings.id(pairing_class.species_id)
+        columns["fundamental_slot_start"][row] = fundamental_cursor
+        columns["fundamental_slot_count"][row] = len(
+            pairing_class.fundamental_source_slots
+        )
+        columns["antifundamental_slot_start"][row] = antifundamental_cursor
+        columns["antifundamental_slot_count"][row] = len(
+            pairing_class.antifundamental_source_slots
+        )
+        columns["reference_pairing_start"][row] = reference_cursor
+        columns["reference_pairing_count"][row] = len(pairing_class.reference_pairings)
+        columns["pairing_count"][row] = pairing_class.pairing_count
+        columns["proof_digest"][row] = np.frombuffer(
+            _digest_bytes(pairing_class.proof_digest, "pairing class proof digest"),
+            dtype=_U8,
+        )
+        fundamental_cursor += len(pairing_class.fundamental_source_slots)
+        antifundamental_cursor += len(pairing_class.antifundamental_source_slots)
+        reference_cursor += len(pairing_class.reference_pairings)
+    return _freeze_table("pairing_classes", columns)
+
+
+def _build_rules_table(
+    rules: Sequence[FermionPairingRuleRowV1],
+    strings: _StringCatalog,
+    exact_integers: _ExactIntegerCatalog,
+) -> RecurrenceColumnarTable:
+    columns = _allocate("rules", len(rules))
+    class_cursor = pair_cursor = permutation_cursor = lineage_cursor = 0
+    for row, rule in enumerate(rules):
+        columns["rule_id"][row] = rule.rule_id
+        columns["class_pairing_index_start"][row] = class_cursor
+        columns["class_pairing_index_count"][row] = len(rule.class_pairing_indices)
+        columns["endpoint_pairing_start"][row] = pair_cursor
+        columns["endpoint_pairing_count"][row] = len(rule.endpoint_pairings)
+        columns["source_permutation_start"][row] = permutation_cursor
+        columns["source_permutation_count"][row] = len(rule.source_slot_permutation)
+        columns["lineage_start"][row] = lineage_cursor
+        columns["lineage_count"][row] = len(rule.lineage_by_source_slot)
+        columns["fermion_parity"][row] = rule.fermion_parity
+        factor = rule.exact_factor
+        columns["real_numerator_integer_id"][row] = exact_integers.id(
+            factor.real_numerator
+        )
+        columns["real_denominator_integer_id"][row] = exact_integers.id(
+            factor.real_denominator
+        )
+        columns["imag_numerator_integer_id"][row] = exact_integers.id(
+            factor.imag_numerator
+        )
+        columns["imag_denominator_integer_id"][row] = exact_integers.id(
+            factor.imag_denominator
+        )
+        columns["multiplicity"][row] = rule.multiplicity
+        columns["proof_algorithm_string_id"][row] = strings.id(rule.proof_algorithm)
+        columns["proof_digest"][row] = np.frombuffer(
+            _digest_bytes(rule.proof_digest, "pairing rule proof digest"), dtype=_U8
+        )
+        class_cursor += len(rule.class_pairing_indices)
+        pair_cursor += len(rule.endpoint_pairings)
+        permutation_cursor += len(rule.source_slot_permutation)
+        lineage_cursor += len(rule.lineage_by_source_slot)
+    return _freeze_table("rules", columns)
+
+
+def _build_exact_integer_tables(
+    catalog: _ExactIntegerCatalog,
+) -> tuple[RecurrenceColumnarTable, RecurrenceColumnarTable]:
+    columns = _allocate("exact_integers", len(catalog.values))
+    flat_limbs: list[int] = []
+    for row, value in enumerate(catalog.values):
+        limbs = _unsigned_limbs(value)
+        columns["integer_id"][row] = row
+        columns["sign"][row] = -1 if value < 0 else (1 if value > 0 else 0)
+        columns["limb_start"][row] = len(flat_limbs)
+        columns["limb_count"][row] = len(limbs)
+        flat_limbs.extend(limbs)
+    return (
+        _freeze_table("exact_integers", columns),
+        _one_column_table("exact_integer_limbs", flat_limbs),
+    )
+
+
+def _build_string_tables(
+    strings: _StringCatalog,
+    payloads: Sequence[bytes],
+) -> tuple[RecurrenceColumnarTable, RecurrenceColumnarTable]:
+    ranges = _allocate("string_ranges", len(strings.values))
+    cursor = 0
+    for row, payload in enumerate(payloads):
+        ranges["string_id"][row] = row
+        ranges["start"][row] = cursor
+        ranges["count"][row] = len(payload)
+        cursor += len(payload)
+    values = _allocate("string_bytes", cursor)
+    if cursor:
+        values["value"][:] = np.frombuffer(b"".join(payloads), dtype=_U8)
+    return (
+        _freeze_table("string_ranges", ranges),
+        _freeze_table("string_bytes", values),
+    )
+
+
+def _one_column_table(name: str, values: Sequence[int]) -> RecurrenceColumnarTable:
+    columns = _allocate(name, len(values))
+    column_name = _TABLE_SCHEMAS[name][0][0]
+    if values:
+        columns[column_name][:] = values
+    return _freeze_table(name, columns)
+
+
+def _pair_table(
+    name: str, values: Sequence[tuple[int, int]]
+) -> RecurrenceColumnarTable:
+    columns = _allocate(name, len(values))
+    left_name, right_name = (item[0] for item in _TABLE_SCHEMAS[name])
+    for row, (left, right) in enumerate(values):
+        columns[left_name][row] = left
+        columns[right_name][row] = right
+    return _freeze_table(name, columns)
+
+
+def _class_index_table(
+    values: Sequence[tuple[int, int]],
+) -> RecurrenceColumnarTable:
+    columns = _allocate("rule_class_pairing_indices", len(values))
+    for row, (class_id, pairing_index) in enumerate(values):
+        columns["class_id"][row] = class_id
+        columns["pairing_index"][row] = pairing_index
+    return _freeze_table("rule_class_pairing_indices", columns)
+
+
+def _allocate(name: str, row_count: int) -> dict[str, np.ndarray[Any, Any]]:
+    _checked_u64(row_count, f"{name} row count")
+    result: dict[str, np.ndarray[Any, Any]] = {}
+    for column_name, dtype, tail_shape in _TABLE_SCHEMAS[name]:
+        result[column_name] = np.empty((row_count, *tail_shape), dtype=dtype, order="C")
+    return result
+
+
+def _freeze_table(
+    name: str, columns: Mapping[str, np.ndarray[Any, Any]]
+) -> RecurrenceColumnarTable:
+    expected_names = tuple(item[0] for item in _TABLE_SCHEMAS[name])
+    if tuple(columns) != expected_names:
+        raise RecurrenceColumnarInputError(
+            f"table {name!r} columns do not match its private ABI schema"
+        )
+    frozen: list[RecurrenceColumn] = []
+    for column_name, expected_dtype, expected_tail_shape in _TABLE_SCHEMAS[name]:
+        values = columns[column_name]
+        can_adopt = (
+            values.flags.owndata
+            and values.flags.c_contiguous
+            and values.dtype == expected_dtype
+            and values.shape[1:] == expected_tail_shape
+        )
+        owned = (
+            values
+            if can_adopt
+            else np.array(values, dtype=values.dtype, order="C", copy=True)
+        )
+        owned.flags.writeable = False
+        frozen.append(RecurrenceColumn(column_name, owned))
+    row_count = len(frozen[0].values) if frozen else 0
+    return RecurrenceColumnarTable(name, row_count, tuple(frozen))
+
+
+def _validate_encoded_tables(tables: tuple[RecurrenceColumnarTable, ...]) -> None:
+    if tuple(table.name for table in tables) != _TABLE_ORDER:
+        raise RecurrenceColumnarInputError(
+            "fermion-pairing tables do not match the private ABI order"
+        )
+    by_name = {table.name: table for table in tables}
+    for table in tables:
+        schema = _TABLE_SCHEMAS[table.name]
+        if tuple(column.name for column in table.columns) != tuple(
+            item[0] for item in schema
+        ):
+            raise RecurrenceColumnarInputError(
+                f"table {table.name!r} does not match its column schema"
+            )
+        for column, (_, dtype, tail_shape) in zip(table.columns, schema, strict=True):
+            if column.values.dtype != dtype or column.values.shape[1:] != tail_shape:
+                raise RecurrenceColumnarInputError(
+                    f"table {table.name!r} column {column.name!r} has the wrong "
+                    "little-endian fixed-width representation"
+                )
+    header = by_name["header"]
+    if header.row_count != 1:
+        raise RecurrenceColumnarInputError("pairing header must contain one row")
+    if int(header.column("schema_version")[0]) != _PAIRING_COLUMNAR_SCHEMA_VERSION:
+        raise RecurrenceColumnarInputError("pairing columnar schema version is stale")
+    if int(header.column("no_fermion_line")[0]) != NO_FERMION_LINE:
+        raise RecurrenceColumnarInputError("pairing lineage sentinel is stale")
+    row_counts = {
+        "endpoint_count": "endpoints",
+        "pairing_class_count": "pairing_classes",
+        "rule_count": "rules",
+        "exact_integer_count": "exact_integers",
+        "string_count": "string_ranges",
+    }
+    for count_column, table_name in row_counts.items():
+        if int(header.column(count_column)[0]) != by_name[table_name].row_count:
+            raise RecurrenceColumnarInputError(
+                f"header {count_column!r} does not match table {table_name!r}"
+            )
+    flat_counts = {
+        "endpoint_state_template_count": "endpoint_state_template_ids",
+        "endpoint_anti_state_template_count": "endpoint_anti_state_template_ids",
+        "endpoint_basis_count": "endpoint_basis_ids",
+        "endpoint_color_representation_count": "endpoint_color_representations",
+        "class_fundamental_slot_count": "class_fundamental_slots",
+        "class_antifundamental_slot_count": "class_antifundamental_slots",
+        "class_reference_pairing_count": "class_reference_pairings",
+        "rule_class_pairing_index_count": "rule_class_pairing_indices",
+        "rule_endpoint_pairing_count": "rule_endpoint_pairings",
+        "rule_source_permutation_count": "rule_source_slot_permutations",
+        "rule_lineage_count": "rule_lineages",
+        "exact_integer_limb_count": "exact_integer_limbs",
+        "string_byte_count": "string_bytes",
+    }
+    for count_column, table_name in flat_counts.items():
+        if int(header.column(count_column)[0]) != by_name[table_name].row_count:
+            raise RecurrenceColumnarInputError(
+                f"header {count_column!r} does not match table {table_name!r}"
+            )
+    _validate_dense_ids(by_name["endpoints"], "endpoint_id")
+    _validate_dense_ids(by_name["pairing_classes"], "class_id")
+    _validate_dense_ids(by_name["rules"], "rule_id")
+    _validate_dense_ids(by_name["exact_integers"], "integer_id")
+    _validate_dense_ids(by_name["string_ranges"], "string_id")
+    _validate_ranges(
+        by_name["string_ranges"],
+        "start",
+        "count",
+        by_name["string_bytes"].row_count,
+        "pairing string catalog",
+    )
+    _validate_ranges(
+        by_name["exact_integers"],
+        "limb_start",
+        "limb_count",
+        by_name["exact_integer_limbs"].row_count,
+        "pairing exact-integer catalog",
+    )
+    range_groups = (
+        ("endpoints", "state_template", "endpoint_state_template_ids"),
+        (
+            "endpoints",
+            "anti_state_template",
+            "endpoint_anti_state_template_ids",
+        ),
+        ("endpoints", "basis", "endpoint_basis_ids"),
+        (
+            "endpoints",
+            "color_representation",
+            "endpoint_color_representations",
+        ),
+        ("pairing_classes", "fundamental_slot", "class_fundamental_slots"),
+        (
+            "pairing_classes",
+            "antifundamental_slot",
+            "class_antifundamental_slots",
+        ),
+        (
+            "pairing_classes",
+            "reference_pairing",
+            "class_reference_pairings",
+        ),
+        ("rules", "class_pairing_index", "rule_class_pairing_indices"),
+        ("rules", "endpoint_pairing", "rule_endpoint_pairings"),
+        ("rules", "source_permutation", "rule_source_slot_permutations"),
+        ("rules", "lineage", "rule_lineages"),
+    )
+    for parent_name, prefix, child_name in range_groups:
+        _validate_ranges(
+            by_name[parent_name],
+            f"{prefix}_start",
+            f"{prefix}_count",
+            by_name[child_name].row_count,
+            f"{parent_name}.{prefix}",
+        )
+
+
+def _validate_dense_ids(table: RecurrenceColumnarTable, column: str) -> None:
+    if not np.array_equal(table.column(column), np.arange(table.row_count, dtype=_U32)):
+        raise RecurrenceColumnarInputError(
+            f"table {table.name!r} IDs are not dense and canonical"
+        )
+
+
+def _validate_ranges(
+    table: RecurrenceColumnarTable,
+    start_column: str,
+    count_column: str,
+    child_count: int,
+    context: str,
+) -> None:
+    cursor = 0
+    for row in range(table.row_count):
+        start = int(table.column(start_column)[row])
+        count = int(table.column(count_column)[row])
+        if start != cursor or start + count > child_count:
+            raise RecurrenceColumnarInputError(
+                f"{context} ranges are not contiguous or are out of bounds"
+            )
+        cursor += count
+    if cursor != child_count:
+        raise RecurrenceColumnarInputError(
+            f"{context} ranges do not cover every flattened row"
+        )
+
+
+def _catalog_strings(catalog: FermionPairingCatalogV1) -> Iterable[str]:
+    yield _PAIRING_COLUMNAR_ABI
+    yield catalog.process_key
+    yield PAIRING_PROOF_ALGORITHM
+    for endpoint in catalog.endpoints:
+        yield endpoint.species_id
+        yield from endpoint.state_template_ids
+        yield from endpoint.anti_state_template_ids
+        yield from endpoint.basis_ids
+    for pairing_class in catalog.pairing_classes:
+        yield pairing_class.species_id
+    for rule in catalog.rules:
+        yield rule.proof_algorithm
+
+
+def _catalog_exact_integers(catalog: FermionPairingCatalogV1) -> Iterable[int]:
+    for rule in catalog.rules:
+        yield rule.exact_factor.real_numerator
+        yield rule.exact_factor.real_denominator
+        yield rule.exact_factor.imag_numerator
+        yield rule.exact_factor.imag_denominator
+
+
+def _topology_payload(
+    source_count: int,
+    endpoints: tuple[ExternalFermionEndpointRowV1, ...],
+    pairing_classes: tuple[FermionPairingClassRowV1, ...],
+    rules: tuple[FermionPairingRuleRowV1, ...],
+) -> dict[str, object]:
+    return {
+        "algorithm": PAIRING_PROOF_ALGORITHM,
+        "source_count": source_count,
+        "endpoints": tuple(
+            (
+                endpoint.source_slot,
+                endpoint.public_label,
+                endpoint.species_class_id,
+                endpoint.color_orientation,
+            )
+            for endpoint in endpoints
+        ),
+        "pairing_classes": tuple(
+            (
+                row.class_id,
+                row.fundamental_source_slots,
+                row.antifundamental_source_slots,
+                row.reference_pairings,
+                row.pairing_count,
+            )
+            for row in pairing_classes
+        ),
+        "rules": tuple(
+            (
+                rule.class_pairing_indices,
+                rule.endpoint_pairings,
+                rule.source_slot_permutation,
+                rule.lineage_by_source_slot,
+                rule.fermion_parity,
+            )
+            for rule in rules
+        ),
+    }
+
+
+def _permutation_parity(reference: Sequence[int], candidate: Sequence[int]) -> int:
+    ranks = {value: index for index, value in enumerate(reference)}
+    permutation = tuple(ranks[value] for value in candidate)
+    inversions = sum(
+        left > right
+        for index, left in enumerate(permutation)
+        for right in permutation[index + 1 :]
+    )
+    return -1 if inversions % 2 else 1
+
+
+def _unsigned_limbs(value: int) -> tuple[int, ...]:
+    magnitude = abs(_checked_int(value, "exact integer"))
+    limbs: list[int] = []
+    while magnitude:
+        limbs.append(magnitude & ((1 << 64) - 1))
+        magnitude >>= 64
+    return tuple(limbs)
+
+
+def _canonical_strings(values: Sequence[str], context: str) -> tuple[str, ...]:
+    materialized = tuple(_nonempty_text(value, context) for value in values)
+    if materialized != tuple(sorted(set(materialized))):
+        raise RecurrenceColumnarInputError(f"{context} are not canonical")
+    return materialized
+
+
+def _canonical_i32s(values: Sequence[int], context: str) -> tuple[int, ...]:
+    materialized = tuple(_checked_i32(value, context) for value in values)
+    if materialized != tuple(sorted(set(materialized))):
+        raise RecurrenceColumnarInputError(f"{context} are not canonical")
+    return materialized
+
+
+def _canonical_u32_slots(
+    values: Sequence[int], bound: int, context: str
+) -> tuple[int, ...]:
+    materialized = tuple(_bounded_u32(value, bound, context) for value in values)
+    if materialized != tuple(sorted(set(materialized))):
+        raise RecurrenceColumnarInputError(f"{context} are not canonical")
+    return materialized
+
+
+def _nonempty_text(value: object, context: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise RecurrenceColumnarInputError(f"{context} must be nonempty text")
+    try:
+        value.encode("utf-8")
+    except UnicodeEncodeError as error:
+        raise RecurrenceColumnarInputError(
+            f"{context} is not valid UTF-8 text"
+        ) from error
+    return value
+
+
+def _checked_int(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise RecurrenceColumnarInputError(f"{context} must be an integer")
+    return value
+
+
+def _checked_u32(value: object, context: str) -> int:
+    parsed = _checked_int(value, context)
+    if not 0 <= parsed < (1 << 32):
+        raise RecurrenceColumnarInputError(f"{context} does not fit u32")
+    return parsed
+
+
+def _checked_u64(value: object, context: str) -> int:
+    parsed = _checked_int(value, context)
+    if not 0 <= parsed < (1 << 64):
+        raise RecurrenceColumnarInputError(f"{context} does not fit u64")
+    return parsed
+
+
+def _checked_i32(value: object, context: str) -> int:
+    parsed = _checked_int(value, context)
+    if not -(1 << 31) <= parsed < (1 << 31):
+        raise RecurrenceColumnarInputError(f"{context} does not fit i32")
+    return parsed
+
+
+def _bounded_u32(value: object, bound: int, context: str) -> int:
+    parsed = _checked_u32(value, context)
+    if parsed >= bound:
+        raise RecurrenceColumnarInputError(f"{context} is out of bounds")
+    return parsed
+
+
+def _digest_bytes(value: object, context: str) -> bytes:
+    if not isinstance(value, str) or len(value) != 64:
+        raise RecurrenceColumnarInputError(
+            f"{context} must be a lowercase SHA-256 digest"
+        )
+    try:
+        decoded = bytes.fromhex(value)
+    except ValueError as error:
+        raise RecurrenceColumnarInputError(
+            f"{context} must be a lowercase SHA-256 digest"
+        ) from error
+    if decoded.hex() != value:
+        raise RecurrenceColumnarInputError(
+            f"{context} must be a lowercase SHA-256 digest"
+        )
+    return decoded
+
+
+def _digest(payload: object) -> str:
+    encoded = json.dumps(
+        payload,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+__all__: tuple[str, ...] = ()
diff --git a/pyamplicol/src/pyamplicol/generation/recurrence_physics.py b/pyamplicol/src/pyamplicol/generation/recurrence_physics.py
new file mode 100644
index 0000000000..84e2405548
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/recurrence_physics.py
@@ -0,0 +1,1168 @@
+# SPDX-License-Identifier: 0BSD
+"""Public physics and parameter metadata for compact recurrence artifacts.
+
+The recurrence builder forks before :class:`GenericDAG`, so its public axes
+must be derived from the authenticated process projection rather than from a
+materialized DAG.  This module keeps that derivation small and deterministic.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from itertools import product
+from types import SimpleNamespace
+from typing import Any
+
+from .._internal.versions import (
+    RECURRENCE_BUILDER_INPUT_ABI,
+    RECURRENCE_DIRECT_TEMPLATE_ABI,
+    RECURRENCE_PLAN_ABI,
+    RECURRENCE_RUNTIME_LAYOUT_ABI,
+)
+from ..color import (
+    ColorContractionPlan,
+    ColorGroupDescriptor,
+    GenericColorPlan,
+    build_color_contraction_plan,
+    build_symmetric_group_color_contraction_plan,
+    exact_color_contraction_factor,
+)
+from ..color.plan_types import _canonical_open_string_product_key
+from ..models.base import Model, _runtime_particle_parameter_name
+from ..models.recurrence_template import RecurrenceTemplateCatalog
+from ..processes.ir import CanonicalProcessIR
+from .recurrence_columnar import (
+    ExactComplexRationalV1,
+    RecurrenceBuilderLogicalInputV1,
+    RecurrenceExternalLegV1,
+    RecurrenceNormalizationV1,
+    RecurrenceParameterProjectionV1,
+    RecurrencePublicLCFlowV1,
+)
+
+_NORMALIZATION_EXTENSION_KEYS = (
+    "color_accuracy",
+    "color_factor",
+    "average_factor",
+    "identical_factor",
+    "global_coupling_factor",
+    "qcd_coupling_power",
+    "electroweak_coupling_power",
+    "couplings_in_stage_evaluators",
+    "coupling_policy",
+)
+_GLOBAL_HELICITY_FLIP_EQUIVALENCE_ROLE = "helicity-equivalence:global-flip-v1"
+_ZERO_SECTOR_OWNER = 0xFFFF_FFFF
+
+
+def build_recurrence_normalization(
+    process: CanonicalProcessIR,
+    model: Model,
+) -> tuple[RecurrenceNormalizationV1, dict[str, object]]:
+    """Bind the existing process normalization without constructing a DAG."""
+
+    # Existing model implementations inspect only ``dag.process``.  Keep the
+    # compatibility adapter local while preserving the established payload.
+    payload = dict(
+        model.runtime_normalization_payload(SimpleNamespace(process=process))
+    )
+    encoded = json.dumps(
+        payload,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return (
+        RecurrenceNormalizationV1(
+            factor=ExactComplexRationalV1(1),
+            convention="runtime-normalization-extension-v1",
+            semantic_digest=hashlib.sha256(encoded).hexdigest(),
+        ),
+        payload,
+    )
+
+
+def build_recurrence_physics(
+    process: CanonicalProcessIR,
+    logical: RecurrenceBuilderLogicalInputV1,
+    catalog: RecurrenceTemplateCatalog,
+    *,
+    process_id: str,
+    resolved_helicities: Sequence[Sequence[int]],
+    normalization: Mapping[str, object],
+    selected_color_sector_ids: Sequence[int] | None,
+    color_plan: GenericColorPlan | None = None,
+) -> dict[str, object]:
+    """Build strict ``pyamplicol-resolved-physics`` metadata pre-DAG."""
+
+    if logical.process_id != process.key:
+        raise ValueError("recurrence projection does not belong to the process IR")
+    if process.color_accuracy != "lc" and color_plan is None:
+        raise ValueError("contracted recurrence physics requires its color plan")
+    if logical.layout != "all-flow-union" and not resolved_helicities:
+        raise ValueError("fixed-source recurrence has no resolved helicities")
+
+    possible_helicities = _possible_helicities(logical)
+    resolved = {tuple(int(value) for value in row) for row in resolved_helicities}
+    unknown = resolved - set(possible_helicities)
+    if unknown:
+        raise ValueError(
+            "recurrence lowering returned helicities outside generated coverage: "
+            f"{sorted(unknown)!r}"
+        )
+    # All-flow-union selects source states at runtime and deliberately has no
+    # helicity-expanded destinations.  Every retained assignment is therefore
+    # executable even though some may evaluate to zero dynamically.
+    computed_helicities = (
+        set(possible_helicities) if logical.layout == "all-flow-union" else resolved
+    )
+    parity_proof = next(
+        (
+            row
+            for row in getattr(logical, "semantic_digests", ())
+            if row.role == _GLOBAL_HELICITY_FLIP_EQUIVALENCE_ROLE
+        ),
+        None,
+    )
+    parity_reduced = parity_proof is not None and logical.layout != "all-flow-union"
+    if parity_reduced:
+        for values in resolved:
+            flipped = tuple(-value for value in values)
+            if flipped != values and flipped in resolved:
+                raise ValueError(
+                    "recurrence parity proof retained both members of global "
+                    f"helicity-flip orbit {values!r} / {flipped!r}"
+                )
+    helicities = []
+    structural_zero_count = 0
+    parity_aliases: list[dict[str, str]] = []
+    for index, values in enumerate(possible_helicities):
+        identifier = _helicity_id(values)
+        representative = values
+        computed = values in computed_helicities
+        if parity_reduced and not computed:
+            flipped = tuple(-value for value in values)
+            if flipped in resolved:
+                representative = flipped
+        structural_zero = not computed and representative == values
+        structural_zero_count += int(structural_zero)
+        representative_id = _helicity_id(representative)
+        if representative != values:
+            parity_aliases.append(
+                {
+                    "physical_id": identifier,
+                    "representative_id": representative_id,
+                }
+            )
+        helicities.append(
+            {
+                "id": identifier,
+                "index": index,
+                "values": list(values),
+                "computed": computed,
+                "structural_zero": structural_zero,
+                "representative_id": representative_id,
+                "coefficient": 0.0 if structural_zero else 1.0,
+            }
+        )
+    if parity_reduced:
+        nonzero_physical = len(helicities) - structural_zero_count
+        if nonzero_physical != 2 * len(resolved) or len(parity_aliases) != len(
+            resolved
+        ):
+            raise ValueError(
+                "recurrence global-helicity-flip reduction does not form complete "
+                "two-member nonzero orbits"
+            )
+
+    selected_flow_ids = (
+        None
+        if logical.selected_public_flow_ids is None
+        else set(logical.selected_public_flow_ids)
+    )
+    selected_sector_ids = (
+        None
+        if selected_color_sector_ids is None
+        else tuple(sorted({int(value) for value in selected_color_sector_ids}))
+    )
+    if (selected_flow_ids is None) != (selected_sector_ids is None):
+        raise ValueError(
+            "recurrence selected public flows and requested color sectors must "
+            "be recorded together"
+        )
+    if selected_sector_ids == ():
+        raise ValueError("recurrence selected color sectors cannot be empty")
+    retained_flows = _retained_public_flows(logical)
+    if not retained_flows:
+        raise ValueError("recurrence physics has no retained public LC flow")
+    labels_by_slot = {
+        leg.source_slot: leg.public_label for leg in logical.external_legs
+    }
+    if process.color_accuracy == "lc":
+        color_components = []
+        for index, flow in enumerate(retained_flows):
+            weight = _complex_factor(flow.reduction_weight)
+            color_components.append(
+                {
+                    "kind": "lc-flow",
+                    "id": flow.public_id,
+                    "index": index,
+                    "word": [labels_by_slot[slot] for slot in flow.word_source_slots],
+                    "computed": True,
+                    "representative_id": flow.public_id,
+                    "coefficient": float(
+                        weight.real * weight.real + weight.imag * weight.imag
+                    ),
+                }
+            )
+    else:
+        color_components = [
+            {
+                "kind": "contracted-color",
+                "id": "color:contracted",
+                "index": 0,
+                "description": (
+                    "coherent sparse contraction of the complete ordered color basis"
+                ),
+            }
+        ]
+
+    selected_sources = {
+        row.source_slot: tuple(row.source_state_indices)
+        for row in logical.selected_source_coverage or ()
+    }
+    selected_source_helicities = {}
+    for leg in logical.external_legs:
+        retained = selected_sources.get(leg.source_slot)
+        if retained is None:
+            continue
+        retained_helicities = {
+            leg.source_states[index].public_helicity for index in retained
+        }
+        if len(retained_helicities) == 1:
+            selected_source_helicities[str(leg.public_label)] = (
+                retained_helicities.pop()
+            )
+
+    color_coverage = (
+        ("complete" if selected_flow_ids is None else "selected")
+        if process.color_accuracy == "lc"
+        else "contracted"
+    )
+    helicity_coverage = (
+        "complete" if logical.selected_source_coverage is None else "selected"
+    )
+    public_parameters = _public_model_parameters(catalog)
+    return {
+        "schema_version": 1,
+        "kind": "pyamplicol-resolved-physics",
+        "process_id": process_id,
+        "process": process.process,
+        "color_accuracy": process.color_accuracy,
+        "coverage": {
+            "helicities": helicity_coverage,
+            "color": color_coverage,
+            "color_kind": (
+                "physical-lc-flows"
+                if process.color_accuracy == "lc"
+                else "contracted-color"
+            ),
+            "structural_zero_helicity_count": structural_zero_count,
+        },
+        "external_particles": [
+            {
+                "index": index,
+                "label": int(leg.label),
+                "particle": str(leg.particle),
+                "pdg": int(leg.pdg),
+                "role": "initial" if leg.is_initial else "final",
+                "momentum_slot": index,
+                "momentum_components": ["E", "px", "py", "pz"],
+            }
+            for index, leg in enumerate(process.legs)
+        ],
+        "helicities": helicities,
+        "color_components": color_components,
+        # The compact recurrence plan owns the high-cardinality destination
+        # expansion.  Rusticol hydrates these groups while loading the plan.
+        "reduction": {
+            "kind": (
+                "lc-diagonal" if process.color_accuracy == "lc" else "contracted-color"
+            ),
+            "groups": [],
+        },
+        "model_parameters": public_parameters,
+        "selectors": {
+            "helicity": True,
+            "color_flow": process.color_accuracy == "lc",
+            "contracted_color": False,
+        },
+        "extensions": {
+            "process_key": process.key,
+            "normalization": {
+                key: normalization[key]
+                for key in _NORMALIZATION_EXTENSION_KEYS
+                if key in normalization
+            },
+            "selected_source_helicities": selected_source_helicities,
+            "runtime_selectors": {
+                "kind": "pyamplicol-runtime-selectors",
+                "contract_version": 1,
+                "provenance": RECURRENCE_PLAN_ABI,
+                "axes": {
+                    "helicity": {
+                        "generation_coverage": helicity_coverage,
+                        "generation_selection": selected_source_helicities,
+                        "runtime_contract": (
+                            "complete-reusable"
+                            if helicity_coverage == "complete"
+                            else "generation-specialized"
+                        ),
+                    },
+                    "color_flow": {
+                        "generation_coverage": color_coverage,
+                        "generation_selection": list(selected_sector_ids or ()),
+                        "runtime_contract": (
+                            "complete-reusable"
+                            if color_coverage == "complete"
+                            else (
+                                "generation-specialized"
+                                if color_coverage == "selected"
+                                else "contracted-color"
+                            )
+                        ),
+                    },
+                },
+                "generation_specialized_axes": [
+                    *([] if helicity_coverage == "complete" else ["helicity"]),
+                    *(["color_flow"] if color_coverage == "selected" else []),
+                ],
+            },
+            "recurrence_runtime_reduction": {
+                "kind": "pyamplicol-recurrence-native-reduction-v2",
+                "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_ABI,
+                "container_path": "recurrence-runtime.pacbin",
+                "plan_member_path": "schedule/recurrence-direct-schedule-v2.bin",
+            },
+            "recurrence": {
+                "builder_input_abi": RECURRENCE_BUILDER_INPUT_ABI,
+                "plan_abi": RECURRENCE_PLAN_ABI,
+                "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_ABI,
+                "direct_template_abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+                "lc_flow_layout": logical.layout,
+            },
+            **(
+                {}
+                if not parity_reduced
+                else {
+                    "global_helicity_flip_reduction": {
+                        "kind": "pyamplicol-global-helicity-flip-reduction-v1",
+                        "proof_role": parity_proof.role,
+                        "proof_digest": parity_proof.digest,
+                        "physical_nonzero_helicity_count": (
+                            len(helicities) - structural_zero_count
+                        ),
+                        "representative_helicity_count": len(resolved),
+                        "aliases": parity_aliases,
+                    }
+                }
+            ),
+        },
+    }
+
+
+def build_recurrence_runtime_metadata(
+    logical: RecurrenceBuilderLogicalInputV1,
+    catalog: RecurrenceTemplateCatalog,
+    model: Model,
+    normalization: Mapping[str, object],
+) -> dict[str, object]:
+    """Return bounded source, parameter, and normalization runtime metadata."""
+
+    return _build_recurrence_runtime_metadata(
+        logical,
+        catalog,
+        model,
+        normalization,
+    )
+
+
+def build_on_the_fly_public_metadata(
+    process: CanonicalProcessIR,
+    catalog: RecurrenceTemplateCatalog,
+    *,
+    process_id: str,
+) -> dict[str, object]:
+    """Return compact O(externals + parameters) public display metadata."""
+
+    return {
+        "schema_version": 1,
+        "kind": "pyamplicol-on-the-fly-public-metadata",
+        "process_id": process_id,
+        "process": process.process,
+        "color_accuracy": process.color_accuracy,
+        "external_particles": [
+            {
+                "index": index,
+                "label": int(leg.label),
+                "particle": str(leg.particle),
+                "pdg": int(leg.pdg),
+                "role": "initial" if leg.is_initial else "final",
+                "momentum_slot": index,
+                "momentum_components": ["E", "px", "py", "pz"],
+            }
+            for index, leg in enumerate(process.legs)
+        ],
+        "model_parameters": _public_model_parameters(catalog),
+    }
+
+
+def build_on_the_fly_runtime_metadata(
+    external_legs: Sequence[RecurrenceExternalLegV1],
+    parameter_projection: Sequence[RecurrenceParameterProjectionV1],
+    catalog: RecurrenceTemplateCatalog,
+    model: Model,
+    normalization: Mapping[str, object],
+) -> dict[str, object]:
+    """Return irreducible runtime support for the source-only OTF lane."""
+
+    # The established recurrence implementation below already owns parameter
+    # defaults, source masses, external-slot order, and normalization.  Feed it
+    # only those shared structural rows and discard its recurrence-only source
+    # replicas instead of introducing a second metadata implementation.
+    support = _build_recurrence_runtime_metadata(
+        SimpleNamespace(
+            parameter_projection=tuple(parameter_projection),
+            external_legs=tuple(external_legs),
+            # This branch suppresses public flow projection; the on-the-fly
+            # selector adapter derives that axis lazily from the compact seed.
+            layout="contracted-color-union",
+        ),
+        catalog,
+        model,
+        normalization,
+        include_source_templates=False,
+    )
+    return {
+        name: support[name]
+        for name in (
+            "runtime_parameters",
+            "prepared_parameter_defaults",
+            "parameter_projection",
+            "external_legs",
+            "particle_masses",
+            "normalization",
+        )
+    }
+
+
+def _build_recurrence_runtime_metadata(
+    logical: Any,
+    catalog: RecurrenceTemplateCatalog,
+    model: Model,
+    normalization: Mapping[str, object],
+    *,
+    include_source_templates: bool = True,
+) -> dict[str, object]:
+    """Build shared prepared-runtime support and recurrence-only companions."""
+
+    parameter_projection = logical.parameter_projection
+    external_legs = logical.external_legs
+    layout = logical.layout
+
+    values_by_name: dict[str, complex] = {}
+    for provider_name in (
+        "runtime_parameter_defaults",
+        "runtime_derived_parameter_defaults",
+    ):
+        provider = getattr(model, provider_name, None)
+        if not callable(provider):
+            continue
+        for name, raw_value in provider().items():
+            values_by_name[str(name)] = _complex_value(raw_value)
+
+    prepared_defaults = [0j] * len(catalog.parameters)
+    for parameter in catalog.parameters:
+        prepared_id = parameter.prepared_parameter_id
+        if prepared_id is None:
+            continue
+        if prepared_id >= len(prepared_defaults):
+            raise ValueError(
+                f"prepared parameter ID {prepared_id} exceeds catalog size"
+            )
+        value = values_by_name.get(parameter.name)
+        if value is None and parameter.default_value is not None:
+            value = _complex_factor(parameter.default_value)
+        if value is None:
+            raise ValueError(
+                f"recurrence prepared parameter {parameter.name!r} has no default"
+            )
+        prepared_defaults[prepared_id] = value
+
+    runtime_parameters = []
+    for projection in sorted(
+        parameter_projection, key=lambda item: item.runtime_slot
+    ):
+        parameter = catalog.parameters[projection.parameter_template_id]
+        if parameter.name != projection.runtime_name:
+            raise ValueError(
+                "recurrence parameter projection name disagrees with its template"
+            )
+        value = values_by_name.get(parameter.name)
+        if value is None and parameter.default_value is not None:
+            value = _complex_factor(parameter.default_value)
+        if value is None:
+            raise ValueError(
+                f"recurrence runtime parameter {parameter.name!r} has no default"
+            )
+        is_complex = parameter.value_type == "complex"
+        component_name = "real" if projection.component == 0 else "imag"
+        runtime_parameters.append(
+            {
+                "name": (
+                    f"{parameter.name}.{component_name}"
+                    if is_complex
+                    else parameter.name
+                ),
+                "kind": (
+                    "derived_parameter_component"
+                    if parameter.parameter_kind == "derived"
+                    else parameter.parameter_kind
+                ),
+                "parameter_index": projection.runtime_slot,
+                "default": float(
+                    value.real if projection.component == 0 else value.imag
+                ),
+                "runtime_name": parameter.name if is_complex else None,
+                "complex_component": component_name if is_complex else None,
+            }
+        )
+
+    state_index_by_id = {
+        state.template_id: index for index, state in enumerate(catalog.current_states)
+    }
+    referenced_source_ids = sorted(
+        {
+            state.source_template_id
+            for leg in external_legs
+            for state in leg.source_states
+        }
+    )
+    source_templates = []
+    particle_masses: dict[int, float] = {}
+    parameter_names = {parameter.name for parameter in catalog.parameters}
+    for source_template_id in referenced_source_ids:
+        source = catalog.sources[source_template_id]
+        state = next(
+            item
+            for item in catalog.current_states
+            if item.template_id == source.state_template_id
+        )
+        source_ir = model._source_ir(state.particle_id)
+        particle = model.particle(state.particle_id)
+        mass_parameter = _runtime_particle_parameter_name(
+            source_ir.mass_parameter,
+            particle_pdg=int(particle.pdg),
+            kind="mass",
+            available_names=parameter_names,
+        )
+        if include_source_templates:
+            width_parameter = _runtime_particle_parameter_name(
+                source_ir.width_parameter,
+                particle_pdg=int(particle.pdg),
+                kind="width",
+                available_names=parameter_names,
+            )
+            try:
+                crossing = _runtime_crossing(json.loads(source.crossing))
+            except json.JSONDecodeError as exc:  # pragma: no cover - validated
+                raise ValueError(
+                    f"recurrence source {source.template_id!r} has malformed "
+                    "crossing JSON"
+                ) from exc
+            source_ir_payload = source_ir.to_json_dict()
+            # Built-in models expose particle masses directly rather than
+            # through named SourceIR parameters. Prepared kernels use the
+            # generic particle fallback; retain the same name here.
+            source_ir_payload["mass_parameter"] = mass_parameter
+            source_ir_payload["width_parameter"] = width_parameter
+            if crossing != source_ir_payload["crossing"]:
+                raise ValueError(
+                    f"recurrence source {source.template_id!r} crossing disagrees "
+                    "with its typed SourceIR"
+                )
+            source_templates.append(
+                {
+                    "source_template_id": source_template_id,
+                    "current_state_template_id": state_index_by_id[state.template_id],
+                    "dimension": state.dimension,
+                    "helicity": source.helicity,
+                    "chirality": state.chirality,
+                    "spin_state": source.spin_state,
+                    "source_ir": source_ir_payload,
+                    "crossing": crossing,
+                }
+            )
+        mass = float(model.mass(state.particle_id))
+        if mass_parameter is not None:
+            mass_value = values_by_name.get(mass_parameter)
+            if mass_value is not None:
+                if mass_value.imag != 0.0:
+                    raise ValueError(
+                        "recurrence source mass parameter must be real: "
+                        f"{mass_parameter!r}"
+                    )
+                mass = float(mass_value.real)
+        previous = particle_masses.setdefault(state.particle_id, mass)
+        if previous != mass:
+            raise ValueError(
+                "recurrence particle "
+                f"{state.particle_id} has inconsistent source masses"
+            )
+
+    return {
+        "public_color_flows": (
+            [
+                {
+                    "public_id": flow.public_id,
+                    "construction_sector_id": flow.construction_sector_id,
+                    "target_sector_id": target_sector_id,
+                }
+                for target_sector_id, flow in enumerate(_retained_public_flows(logical))
+            ]
+            if layout != "contracted-color-union"
+            else []
+        ),
+        "runtime_parameters": runtime_parameters,
+        "prepared_parameter_defaults": [
+            [float(value.real), float(value.imag)] for value in prepared_defaults
+        ],
+        "parameter_projection": [
+            {
+                "runtime_slot": row.runtime_slot,
+                "runtime_name": row.runtime_name,
+                "parameter_template_id": row.parameter_template_id,
+                "prepared_parameter_id": row.prepared_parameter_id,
+                "component": row.component,
+            }
+            for row in parameter_projection
+        ],
+        "source_templates": source_templates,
+        "external_legs": [
+            {
+                "source_slot": leg.source_slot,
+                "public_label": leg.public_label,
+                "physical_pdg": leg.physical_pdg,
+                "outgoing_pdg": leg.outgoing_pdg,
+                "is_initial": leg.is_initial,
+            }
+            for leg in external_legs
+        ],
+        "particle_masses": [
+            {"outgoing_pdg": pdg, "mass": mass}
+            for pdg, mass in sorted(particle_masses.items())
+        ],
+        "normalization": {
+            key: normalization[key]
+            for key in _NORMALIZATION_EXTENSION_KEYS
+            if key in normalization
+        },
+    }
+
+
+def build_recurrence_color_contraction(
+    logical: RecurrenceBuilderLogicalInputV1,
+    color_plan: GenericColorPlan,
+    resolved_helicities: Sequence[Sequence[int]],
+    amplitude_destinations: Sequence[tuple[int, int | None]],
+    certified_structural_zero_sector_ids: Sequence[int],
+    *,
+    contraction: str = "direct",
+) -> ColorContractionPlan | None:
+    if color_plan.color_accuracy == "lc":
+        return None
+    if logical.layout != "contracted-color-union":
+        raise ValueError("NLC/full recurrence requires contracted-color-union")
+    if not logical.physical_sectors or not resolved_helicities:
+        raise ValueError("contracted recurrence has an empty color/helicity domain")
+    contraction_destinations = recurrence_color_contraction_destinations(
+        logical,
+        resolved_helicities,
+        amplitude_destinations,
+    )
+    labels_by_slot = {
+        leg.source_slot: leg.public_label for leg in logical.external_legs
+    }
+    sectors_by_id = {sector.sector_id: sector for sector in logical.physical_sectors}
+    descriptors = []
+    for group_id, (sector_id, helicity_id) in enumerate(contraction_destinations):
+        try:
+            sector = sectors_by_id[sector_id]
+        except KeyError as exc:
+            raise ValueError(
+                f"contracted recurrence destination {group_id} references "
+                f"unknown physical sector {sector_id}"
+            ) from exc
+        if helicity_id is None:
+            raise ValueError(
+                f"contracted recurrence destination {group_id} has no helicity"
+            )
+        try:
+            helicity = resolved_helicities[helicity_id]
+        except IndexError as exc:
+            raise ValueError(
+                f"contracted recurrence destination {group_id} references "
+                f"unknown resolved helicity {helicity_id}"
+            ) from exc
+        descriptors.append(
+            ColorGroupDescriptor(
+                group_id=group_id,
+                helicity_key=tuple(int(value) for value in helicity),
+                sector_id=sector.sector_id,
+                word=tuple(labels_by_slot[slot] for slot in sector.word_source_slots),
+                helicity_weight=1.0,
+            )
+        )
+    if not descriptors:
+        raise ValueError("contracted recurrence has no nonzero amplitude destination")
+    if contraction == "direct":
+        contraction_plan = build_color_contraction_plan(
+            color_plan,
+            tuple(descriptors),
+        )
+    elif contraction in {"auto", "symmetric-group-fft"}:
+        active_sector_ids = {descriptor.sector_id for descriptor in descriptors}
+        contraction_plan = build_symmetric_group_color_contraction_plan(
+            color_plan,
+            tuple(descriptors),
+            sector_owner_ids=recurrence_color_sector_owner_map(
+                logical,
+                active_sector_ids,
+                set(certified_structural_zero_sector_ids),
+            ),
+        )
+        if contraction == "auto" and not contraction_plan.supported:
+            contraction_plan = build_color_contraction_plan(
+                color_plan, tuple(descriptors)
+            )
+    else:
+        raise ValueError(f"unknown color contraction method {contraction!r}")
+    if contraction_plan is None or not contraction_plan.supported:
+        reason = None if contraction_plan is None else contraction_plan.reason
+        raise ValueError(
+            f"could not build recurrence color contraction: {reason or 'unsupported'}"
+        )
+    return contraction_plan
+
+
+def build_on_the_fly_color_contraction(
+    color_plan: GenericColorPlan,
+    *,
+    contraction: str = "direct",
+) -> tuple[ColorContractionPlan, tuple[int, ...], tuple[int, ...]]:
+    """Build the one-component metric over OTF structural color selectors.
+
+    Full/NLC color plans explicitly contain whole-open-string block-order
+    replicas.  The native query decoder already erases that traversal-only
+    ordering, so one runtime amplitude is requested for each canonical tensor
+    owner and the color metric contracts those owner amplitudes into one public
+    result.
+    """
+
+    if color_plan.color_accuracy not in {"nlc", "full"}:
+        raise ValueError("on-the-fly color contraction requires NLC or full color")
+    if color_plan.trace_reflections_folded:
+        raise ValueError(
+            "on-the-fly contracted color cannot fold trace reflections"
+        )
+    owner_by_sector = on_the_fly_color_sector_owner_map(color_plan)
+    owner_sector_ids = tuple(
+        sector_id
+        for sector_id, owner_id in enumerate(owner_by_sector)
+        if sector_id == owner_id
+    )
+    sector_by_id = {int(sector.id): sector for sector in color_plan.sectors}
+    descriptors = tuple(
+        ColorGroupDescriptor(
+            group_id=group_id,
+            # All structural selectors contribute to the same contracted
+            # component.  A single component forces expanded v3 storage.
+            helicity_key=(),
+            sector_id=sector_id,
+            word=tuple(sector_by_id[sector_id].color_words[0]),
+            helicity_weight=1.0,
+        )
+        for group_id, sector_id in enumerate(owner_sector_ids)
+    )
+    if contraction == "direct":
+        contraction_plan = build_color_contraction_plan(color_plan, descriptors)
+    elif contraction in {"auto", "symmetric-group-fft"}:
+        contraction_plan = build_symmetric_group_color_contraction_plan(
+            color_plan,
+            descriptors,
+            sector_owner_ids=owner_by_sector,
+        )
+        if contraction == "auto" and not contraction_plan.supported:
+            contraction_plan = build_color_contraction_plan(color_plan, descriptors)
+    else:
+        raise ValueError(f"unknown color contraction method {contraction!r}")
+    if contraction_plan is None or not contraction_plan.supported:
+        reason = None if contraction_plan is None else contraction_plan.reason
+        raise ValueError(
+            "could not build on-the-fly color contraction: "
+            f"{reason or 'unsupported'}"
+        )
+    if contraction_plan.repeated_block is not None:
+        raise ValueError(
+            "one-component on-the-fly color contraction must use expanded storage"
+        )
+    return contraction_plan, owner_by_sector, owner_sector_ids
+
+
+def on_the_fly_color_sector_owner_map(
+    color_plan: GenericColorPlan,
+) -> tuple[int, ...]:
+    """Return each full/NLC sector's canonical structural-selector owner.
+
+    Only permutations of complete open strings are aliases.  Reversing a
+    string, trace orientation, and every other physical sector distinction are
+    retained.  Owner sectors appear in the same order as the lazy compact LC
+    selector axis, including an optional ordinary reference flow moved first.
+    """
+
+    sectors = tuple(sorted(color_plan.sectors, key=lambda item: int(item.id)))
+    if tuple(int(sector.id) for sector in sectors) != tuple(range(len(sectors))):
+        raise ValueError("on-the-fly physical color sectors are not densely numbered")
+    if not sectors:
+        raise ValueError("on-the-fly contracted color plan has no physical sectors")
+
+    owner_by_key: dict[tuple[object, ...], int] = {}
+    owners: list[int] = []
+    for sector in sectors:
+        sector_id = int(sector.id)
+        if sector.kind == "open-lines":
+            open_strings = _canonical_open_string_product_key(
+                (
+                    line.fundamental_label,
+                    line.adjoint_labels,
+                    line.antifundamental_label,
+                    line.singlet_labels,
+                )
+                for line in sector.open_color_lines
+            )
+            key: tuple[object, ...] = ("open-lines", open_strings)
+        else:
+            key = (sector.kind, sector_id)
+        owners.append(owner_by_key.setdefault(key, sector_id))
+    return tuple(owners)
+
+
+def recurrence_color_contraction_destinations(
+    logical: RecurrenceBuilderLogicalInputV1,
+    resolved_helicities: Sequence[Sequence[int]],
+    amplitude_destinations: Sequence[tuple[int, int | None]],
+) -> tuple[tuple[int, int | None], ...]:
+    """Return the physical amplitude domain consumed by color contraction.
+
+    A contracted topology-replay schedule materializes only one representative
+    per certified partition.  Color contraction still acts on the complete
+    physical color basis, so its destination domain is the dense
+    sector-major/helicity-minor replay scratch rather than the smaller Direct
+    schedule destination table.
+    """
+
+    if logical.layout != "contracted-color-union" or not logical.replay_partitions:
+        return tuple(amplitude_destinations)
+    return tuple(
+        (sector.sector_id, helicity_id)
+        for sector in sorted(logical.physical_sectors, key=lambda item: item.sector_id)
+        for helicity_id in range(len(resolved_helicities))
+    )
+
+
+def recurrence_color_sector_owner_map(
+    logical: RecurrenceBuilderLogicalInputV1,
+    active_sector_ids: set[int],
+    certified_structural_zero_sector_ids: set[int],
+) -> tuple[int, ...]:
+    """Return the independently derived canonical owner of every color sector.
+
+    Contracted recurrence construction treats permutations of complete open
+    strings as aliases of the same product of color tensors.  This map binds
+    that reduction into the process artifact so the loader can reject a
+    schedule that silently omits, duplicates, or changes an alias class.
+    """
+
+    sectors = tuple(sorted(logical.physical_sectors, key=lambda item: item.sector_id))
+    if tuple(sector.sector_id for sector in sectors) != tuple(range(len(sectors))):
+        raise ValueError("recurrence physical color sectors are not densely numbered")
+
+    owner_by_key: dict[tuple[object, ...], int] = {}
+    owners: list[int] = []
+    for sector in sectors:
+        if sector.kind == "open-lines":
+            open_strings = _canonical_open_string_product_key(
+                (
+                    string.fundamental_source_slot,
+                    string.adjoint_source_slots,
+                    string.antifundamental_source_slot,
+                    string.singlet_source_slots,
+                )
+                for string in sector.open_strings
+            )
+            key: tuple[object, ...] = ("open-lines", open_strings)
+        else:
+            # Trace orientation and singlet sectors are already canonicalized
+            # by their construction-sector identity.  Rust does not alias them.
+            key = (sector.kind, sector.sector_id)
+        owner = owner_by_key.setdefault(key, sector.sector_id)
+        owners.append(owner)
+    active = set(active_sector_ids)
+    unknown = active.difference(range(len(sectors)))
+    if unknown:
+        raise ValueError(
+            f"recurrence color destinations reference unknown sectors {sorted(unknown)}"
+        )
+    certified = set(certified_structural_zero_sector_ids)
+    unknown_certified = certified.difference(range(len(sectors)))
+    if unknown_certified:
+        raise ValueError(
+            "recurrence structural-zero certificate references unknown sectors "
+            f"{sorted(unknown_certified)}"
+        )
+    overlap = certified.intersection(active)
+    if overlap:
+        raise ValueError(
+            "recurrence structural-zero certificate overlaps active sectors "
+            f"{sorted(overlap)}"
+        )
+    members_by_owner: dict[int, set[int]] = {}
+    for sector_id, owner_id in enumerate(owners):
+        members_by_owner.setdefault(owner_id, set()).add(sector_id)
+    result = []
+    for _sector_id, owner_id in enumerate(owners):
+        if owner_id in active:
+            result.append(owner_id)
+            continue
+        active_members = members_by_owner[owner_id].intersection(active)
+        if active_members:
+            raise ValueError(
+                f"recurrence color sector class owned by {owner_id} has active "
+                f"non-owner sectors {sorted(active_members)}"
+            )
+        uncertified = members_by_owner[owner_id].difference(certified)
+        if uncertified:
+            raise ValueError(
+                f"recurrence color sector class owned by {owner_id} has no active "
+                "destination and no complete structural-zero certificate; "
+                f"uncertified sectors={sorted(uncertified)}"
+            )
+        result.append(_ZERO_SECTOR_OWNER)
+    return tuple(result)
+
+
+def recurrence_exact_color_coefficients(
+    color_plan: GenericColorPlan,
+    contraction: ColorContractionPlan,
+    group_sector_ids: Sequence[int],
+) -> tuple[ExactComplexRationalV1, ...]:
+    """Return exact symmetry-folded coefficients in compact entry order."""
+
+    symmetric_group = contraction.symmetric_group_block
+    if symmetric_group is not None:
+        entries = (
+            *symmetric_group.kernel_entries,
+            *symmetric_group.residual_entries,
+        )
+        exact_weights = (
+            *symmetric_group.kernel_exact_weights,
+            *symmetric_group.residual_exact_weights,
+        )
+        result = []
+        for entry, exact in zip(entries, exact_weights, strict=True):
+            symmetry = int(entry.symmetry_factor)
+            if symmetry not in {1, 2} or float(symmetry) != entry.symmetry_factor:
+                raise ValueError(
+                    "symmetric-group color contraction has a noncanonical "
+                    "symmetry factor"
+                )
+            result.append(
+                ExactComplexRationalV1(
+                    real_numerator=exact.numerator * symmetry,
+                    real_denominator=exact.denominator,
+                )
+            )
+        return tuple(result)
+
+    sector_by_id = {sector.id: sector for sector in color_plan.sectors}
+    repeated = contraction.repeated_block
+    entries = contraction.entries if repeated is None else repeated.entries
+    component_count = 1 if repeated is None else repeated.component_count
+
+    result = []
+    for entry in entries:
+        if repeated is None:
+            left_group_id = entry.left_group_id
+            right_group_id = entry.right_group_id
+        else:
+            left_group_id = repeated.component_group_ids[
+                entry.left_group_index * component_count
+            ]
+            right_group_id = repeated.component_group_ids[
+                entry.right_group_index * component_count
+            ]
+        try:
+            left_sector = sector_by_id[group_sector_ids[left_group_id]]
+            right_sector = sector_by_id[group_sector_ids[right_group_id]]
+        except (IndexError, KeyError) as exc:
+            raise ValueError(
+                "recurrence color entry references an unknown physical sector"
+            ) from exc
+        exact = exact_color_contraction_factor(
+            color_plan,
+            left_sector,
+            right_sector,
+            accuracy=contraction.color_accuracy,
+            full_col_acc=20,
+        )
+        symmetry = entry.symmetry_factor
+        if symmetry not in {1.0, 2.0}:
+            raise ValueError(
+                "recurrence color contraction has a non-integral symmetry factor"
+            )
+        folded = exact * int(symmetry)
+        result.append(
+            ExactComplexRationalV1(
+                real_numerator=folded.numerator,
+                real_denominator=folded.denominator,
+            )
+        )
+    return tuple(result)
+
+
+def _retained_public_flows(
+    logical: RecurrenceBuilderLogicalInputV1,
+) -> tuple[RecurrencePublicLCFlowV1, ...]:
+    selected = (
+        None
+        if logical.selected_public_flow_ids is None
+        else set(logical.selected_public_flow_ids)
+    )
+    retained = tuple(
+        flow
+        for flow in logical.public_flows
+        if selected is None or flow.flow_id in selected
+    )
+    if not retained:
+        raise ValueError("recurrence metadata has no retained public LC flow")
+    return retained
+
+
+def recurrence_referenced_kernel_ids(
+    logical: RecurrenceBuilderLogicalInputV1,
+) -> frozenset[int]:
+    """Return exactly the prepared kernels named by process template references."""
+
+    return frozenset(
+        reference.prepared_kernel_id
+        for reference in logical.semantic_template_references
+        if reference.prepared_kernel_id is not None
+    )
+
+
+def _possible_helicities(
+    logical: RecurrenceBuilderLogicalInputV1,
+) -> tuple[tuple[int, ...], ...]:
+    selected = {
+        row.source_slot: set(row.source_state_indices)
+        for row in logical.selected_source_coverage or ()
+    }
+    choices = []
+    for leg in logical.external_legs:
+        retained = selected.get(leg.source_slot)
+        choices.append(
+            tuple(
+                state.public_helicity
+                for state in leg.source_states
+                if retained is None or state.state_index in retained
+            )
+        )
+    return tuple(sorted(product(*choices)))
+
+
+def _public_model_parameters(
+    catalog: RecurrenceTemplateCatalog,
+) -> list[dict[str, object]]:
+    result = []
+    for parameter in sorted(catalog.parameters, key=lambda item: item.name):
+        if parameter.parameter_kind == "constant":
+            continue
+        default = (
+            0j
+            if parameter.default_value is None
+            else _complex_factor(parameter.default_value)
+        )
+        if parameter.name.startswith("normalization."):
+            kind = "normalization"
+        elif parameter.parameter_kind == "derived":
+            kind = "derived"
+        else:
+            kind = "external"
+        result.append(
+            {
+                "name": parameter.name,
+                "kind": kind,
+                "default_real": float(default.real),
+                "default_imaginary": float(default.imag),
+                "mutable": bool(parameter.mutable),
+            }
+        )
+    return result
+
+
+def _complex_factor(value: object) -> complex:
+    return complex(
+        int(value.real_numerator) / int(value.real_denominator),
+        int(value.imag_numerator) / int(value.imag_denominator),
+    )
+
+
+def _runtime_crossing(value: object) -> dict[str, object]:
+    if not isinstance(value, Mapping):
+        raise ValueError("recurrence source crossing must be an object")
+    result = dict(value)
+    phase = result.get("phase")
+    if not isinstance(phase, Mapping):
+        raise ValueError("recurrence source crossing phase must be exact")
+    result["phase"] = [
+        int(phase["real_numerator"]) / int(phase["real_denominator"]),
+        int(phase["imag_numerator"]) / int(phase["imag_denominator"]),
+    ]
+    return result
+
+
+def _complex_value(value: object) -> complex:
+    if isinstance(value, tuple):
+        return complex(*value)
+    return complex(value)  # type: ignore[arg-type]
+
+
+def _helicity_id(values: Sequence[int]) -> str:
+    return "h:" + ",".join(f"{int(value):+d}" for value in values)
+
+
+__all__ = [
+    "build_on_the_fly_public_metadata",
+    "build_on_the_fly_runtime_metadata",
+    "build_recurrence_color_contraction",
+    "build_recurrence_normalization",
+    "build_recurrence_physics",
+    "build_recurrence_runtime_metadata",
+    "recurrence_color_contraction_destinations",
+    "recurrence_color_sector_owner_map",
+    "recurrence_exact_color_coefficients",
+    "recurrence_referenced_kernel_ids",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/recurrence_projection.py b/pyamplicol/src/pyamplicol/generation/recurrence_projection.py
new file mode 100644
index 0000000000..1d8b430a5f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/recurrence_projection.py
@@ -0,0 +1,1747 @@
+# SPDX-License-Identifier: 0BSD
+"""Project proven process semantics into recurrence-builder logical records.
+
+The projector is deliberately upstream of generic DAG construction.  It maps
+only canonical process IR, a complete LC colour plan, an optional exact replay
+proof, and a prepared recurrence-template catalog into the compact logical ABI
+consumed by :mod:`pyamplicol.generation.recurrence_columnar`.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, replace
+from typing import Final
+
+from ..color.plan import (
+    ColorTopologyReplayCertificate,
+    GenericColorPlan,
+    LCColorTopologyReplayPlan,
+)
+from ..color.plan_build import _ordered_open_line_blocks
+from ..color.plan_types import _canonical_open_string_product_key
+from ..models.base import Model, Vertex
+from ..models.recurrence_template import (
+    CurrentStateTemplateV1,
+    EvaluatorBindingV1,
+    RecurrenceTemplateCatalog,
+    SourceTemplateV1,
+)
+from ..models.recurrence_template import (
+    ExactComplexRationalV1 as ModelExactComplexRationalV1,
+)
+from ..processes.ir import CanonicalProcessIR, ProcessLegIR
+from .recurrence_columnar import (
+    ExactComplexRationalV1,
+    RecurrenceBuilderLogicalInputV1,
+    RecurrenceCouplingLimitV1,
+    RecurrenceExternalLegV1,
+    RecurrenceLCFlowLayout,
+    RecurrenceLCOpenStringV1,
+    RecurrenceNormalizationV1,
+    RecurrenceParameterProjectionV1,
+    RecurrencePhysicalLCSectorV1,
+    RecurrencePublicLCFlowV1,
+    RecurrenceReplayPartitionV1,
+    RecurrenceReplayTargetV1,
+    RecurrenceSelectedSourceCoverageV1,
+    RecurrenceSemanticDigestV1,
+    RecurrenceSemanticTemplateReferenceV1,
+    RecurrenceSourceStateV1,
+)
+from .recurrence_fermion_pairing import (
+    FermionPairingCatalogV1,
+    build_recurrence_fermion_pairing_catalog_v1,
+)
+
+_TEMPLATE_SECTIONS: Final = (
+    ("parameter", "parameters"),
+    ("current-state", "current_states"),
+    ("source", "sources"),
+    ("quantum-flow", "quantum_flows"),
+    ("transition", "transitions"),
+    ("propagator", "propagators"),
+    ("closure", "closures"),
+    ("color-contraction", "color_contractions"),
+    ("symmetry-proof", "symmetry_proofs"),
+)
+_CLOSURE_ANCHOR_PROOF_ALGORITHM_V2: Final = "canonical-lc-closure-anchor-v2"
+_CLOSURE_ANCHOR_PROOF_ALGORITHM_V3: Final = "canonical-lc-closure-anchor-v3"
+_CLOSURE_ANCHOR_PROOF_ALGORITHM_V4: Final = "canonical-lc-closure-anchor-v4"
+_IDENTITY_REPLAY_PROOF_ALGORITHM: Final = (
+    "canonical-recurrence-identity-materialization-v1"
+)
+_PURE_MASSLESS_ADJOINT_HELICITY_SUPPORT_ROLE: Final = (
+    "helicity-support:pure-massless-adjoint-tree-v1"
+)
+_GLOBAL_HELICITY_FLIP_EQUIVALENCE_ROLE: Final = "helicity-equivalence:global-flip-v1"
+
+
+class RecurrenceProjectionError(ValueError):
+    """The supplied process semantics cannot be projected exactly."""
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceGenerationSliceV1:
+    """Explicit generation-time coverage retained by recurrence v1."""
+
+    selected_public_flow_ids: tuple[int, ...] | None = None
+    selected_source_helicities: tuple[tuple[int, int], ...] | None = None
+
+    def __post_init__(self) -> None:
+        if self.selected_public_flow_ids is not None:
+            flows = tuple(sorted(int(value) for value in self.selected_public_flow_ids))
+            if not flows or len(flows) != len(set(flows)):
+                raise RecurrenceProjectionError(
+                    "selected recurrence public flows must be nonempty and unique"
+                )
+            object.__setattr__(self, "selected_public_flow_ids", flows)
+        if self.selected_source_helicities is not None:
+            selected = tuple(
+                sorted(
+                    (int(label), int(helicity))
+                    for label, helicity in self.selected_source_helicities
+                )
+            )
+            labels = tuple(label for label, _ in selected)
+            if not selected or len(labels) != len(set(labels)):
+                raise RecurrenceProjectionError(
+                    "selected recurrence source labels must be nonempty and unique"
+                )
+            object.__setattr__(self, "selected_source_helicities", selected)
+
+
+def project_recurrence_process_v1(
+    process: CanonicalProcessIR,
+    color_plan: GenericColorPlan,
+    template_catalog: RecurrenceTemplateCatalog,
+    *,
+    layout: RecurrenceLCFlowLayout,
+    normalization: RecurrenceNormalizationV1,
+    topology_replay: (
+        LCColorTopologyReplayPlan | ColorTopologyReplayCertificate | None
+    ) = None,
+    generation_slice: RecurrenceGenerationSliceV1 | None = None,
+    coupling_order_limits: Mapping[str, int] | None = None,
+    process_support_mask: int = 1,
+    model: Model | None = None,
+    prefer_symmetric_group_closure_anchor: bool = False,
+    contracted_physical_color_union: bool = False,
+) -> RecurrenceBuilderLogicalInputV1:
+    """Return deterministic recurrence-builder records for one LC process.
+
+    Normalization is supplied as an exact, model-owned contract because it is
+    process dependent and intentionally absent from the process-independent
+    recurrence template catalog.
+    """
+
+    _validate_projection_roots(
+        process,
+        color_plan,
+        template_catalog,
+        layout,
+        contracted_physical_color_union=contracted_physical_color_union,
+    )
+    if not isinstance(normalization, RecurrenceNormalizationV1):
+        raise TypeError("recurrence projection requires exact normalization v1")
+    if (
+        isinstance(process_support_mask, bool)
+        or not isinstance(process_support_mask, int)
+        or process_support_mask <= 0
+    ):
+        raise RecurrenceProjectionError(
+            "recurrence process support mask must be a positive integer bitmap"
+        )
+    selection = generation_slice or RecurrenceGenerationSliceV1()
+    if contracted_physical_color_union and (
+        topology_replay is not None
+        or selection.selected_public_flow_ids is not None
+        or selection.selected_source_helicities is not None
+    ):
+        raise RecurrenceProjectionError(
+            "contracted physical-color union requires complete runtime flow and "
+            "source coverage without replay"
+        )
+    projected_color_plan = (
+        _physical_color_owner_plan(color_plan)
+        if contracted_physical_color_union
+        else color_plan
+    )
+    reflection_contract = _closure_reflection_contract(
+        template_catalog,
+        required=projected_color_plan.trace_reflections_folded,
+    )
+
+    template_ids, template_references = _project_template_references(template_catalog)
+    external_legs, selected_sources = _project_external_legs(
+        process,
+        template_catalog,
+        template_ids,
+        selection.selected_source_helicities,
+        process_support_mask,
+    )
+    physical_sectors, public_flows = _project_physical_sectors(
+        projected_color_plan,
+        process,
+        external_legs,
+        process_support_mask,
+    )
+    selected_flows = selection.selected_public_flow_ids
+    if selected_flows is not None:
+        available_flow_ids = {flow.flow_id for flow in public_flows}
+        unknown = tuple(sorted(set(selected_flows) - available_flow_ids))
+        if unknown:
+            raise RecurrenceProjectionError(
+                f"generation slice references unknown public LC flows {unknown!r}"
+            )
+    replay_partitions = _project_replay_partitions(
+        process,
+        projected_color_plan,
+        physical_sectors,
+        external_legs,
+        topology_replay,
+        layout,
+    )
+    if prefer_symmetric_group_closure_anchor:
+        physical_sectors = _project_cyclic_trace_closure_anchors(
+            physical_sectors,
+            replay_partitions,
+            external_legs,
+            template_catalog,
+        )
+    fermion_pairing = build_recurrence_fermion_pairing_catalog_v1(
+        process,
+        template_catalog.current_states,
+        quantum_flows=template_catalog.quantum_flows,
+    )
+    closure_reconstruction_digest = _project_closure_obligation_roots_digest(
+        process,
+        projected_color_plan,
+        template_catalog,
+        physical_sectors,
+        fermion_pairing,
+        reflection_contract=reflection_contract,
+    )
+    helicity_support = _project_helicity_support_proof(
+        process,
+        model,
+        model_catalog_digest=template_catalog.header.compiled_model_digest,
+        coupling_order_limits=coupling_order_limits,
+    )
+    global_helicity_flip = _project_global_helicity_flip_proof(
+        process,
+        external_legs,
+        model,
+        model_catalog_digest=template_catalog.header.compiled_model_digest,
+        coupling_order_limits=coupling_order_limits,
+        generation_selected=selection.selected_source_helicities is not None,
+    )
+
+    return RecurrenceBuilderLogicalInputV1(
+        process_id=process.key,
+        layout=layout,
+        semantic_digests=(
+            RecurrenceSemanticDigestV1("process", _digest(process.to_json_dict())),
+            RecurrenceSemanticDigestV1(
+                "model-catalog", template_catalog.header.compiled_model_digest
+            ),
+            RecurrenceSemanticDigestV1(
+                "prepared-catalog", template_catalog.catalog_digest
+            ),
+            RecurrenceSemanticDigestV1(
+                "color-plan", _digest(projected_color_plan.to_json_dict())
+            ),
+            RecurrenceSemanticDigestV1(
+                "fermion-pairing-semantic", fermion_pairing.semantic_digest
+            ),
+            RecurrenceSemanticDigestV1(
+                "fermion-pairing-topology", fermion_pairing.topology_digest
+            ),
+            RecurrenceSemanticDigestV1(
+                "closure-reconstruction",
+                closure_reconstruction_digest,
+            ),
+            *(() if helicity_support is None else (helicity_support,)),
+            *(() if global_helicity_flip is None else (global_helicity_flip,)),
+        ),
+        external_legs=external_legs,
+        physical_sectors=physical_sectors,
+        public_flows=public_flows,
+        semantic_template_references=template_references,
+        normalization=normalization,
+        fermion_pairing_catalog=fermion_pairing,
+        replay_partitions=replay_partitions,
+        selected_public_flow_ids=selected_flows,
+        selected_source_coverage=selected_sources,
+        coupling_limits=_project_coupling_limits(coupling_order_limits),
+        parameter_projection=_project_parameters(template_catalog, template_ids),
+        process_support_mask=process_support_mask,
+    )
+
+
+def _project_closure_obligation_roots_digest(
+    process: CanonicalProcessIR,
+    color_plan: GenericColorPlan,
+    template_catalog: RecurrenceTemplateCatalog,
+    sectors: tuple[RecurrencePhysicalLCSectorV1, ...],
+    pairing: FermionPairingCatalogV1,
+    *,
+    reflection_contract: tuple[
+        ModelExactComplexRationalV1 | None,
+        str | None,
+    ],
+) -> str:
+    """Bind the exact catalogs from which Rust derives closure obligations.
+
+    This digest is deliberately not an expected-row list. Rust independently
+    derives complete three-line traversal, fermion-pairing, and folded-trace
+    obligation multisets from these authenticated roots and compares them with
+    the closure rows it emits.
+    """
+
+    reflection_phase, reflection_proof_digest = reflection_contract
+    return _digest(
+        {
+            "algorithm": "model-generic-closure-obligation-roots-v2",
+            "color_plan_digest": _digest(color_plan.to_json_dict()),
+            "fermion_pairing_semantic_digest": pairing.semantic_digest,
+            "fermion_pairing_topology_digest": pairing.topology_digest,
+            "model_catalog_digest": template_catalog.catalog_digest,
+            "process_digest": _digest(process.to_json_dict()),
+            "reflection_phase": (
+                None if reflection_phase is None else reflection_phase.to_dict()
+            ),
+            "reflection_proof_digest": reflection_proof_digest,
+            "sectors": tuple(
+                {
+                    "closure_proof_algorithm": sector.closure_proof_algorithm,
+                    "closure_proof_digest": sector.closure_proof_digest,
+                    "kind": sector.kind,
+                    "open_strings": tuple(
+                        (
+                            line.fundamental_source_slot,
+                            *line.adjoint_source_slots,
+                            line.antifundamental_source_slot,
+                        )
+                        for line in sector.open_strings
+                    ),
+                    "sector_id": sector.sector_id,
+                    "trace_word": sector.trace_source_slots,
+                    "word": sector.word_source_slots,
+                }
+                for sector in sectors
+            ),
+        }
+    )
+
+
+def _closure_reflection_contract(
+    template_catalog: RecurrenceTemplateCatalog,
+    *,
+    required: bool,
+) -> tuple[ModelExactComplexRationalV1 | None, str | None]:
+    proofs = tuple(
+        proof
+        for proof in template_catalog.symmetry_proofs
+        if proof.proof_algorithm == "canonical-current-word-reversal-v1"
+    )
+    if not proofs:
+        if required:
+            raise RecurrenceProjectionError(
+                "folded LC trace reflections require an exact model "
+                "current-reflection proof"
+            )
+        return None, None
+    phases = {proof.exact_phase for proof in proofs}
+    if len(phases) != 1:
+        raise RecurrenceProjectionError(
+            "model current-reflection proofs carry inconsistent exact phases"
+        )
+    return next(iter(phases)), _digest(
+        {
+            "algorithm": "model-current-reflection-proof-set-v1",
+            "proofs": tuple(proof.to_dict() for proof in proofs),
+        }
+    )
+
+
+def _project_helicity_support_proof(
+    process: CanonicalProcessIR,
+    model: Model | None,
+    *,
+    model_catalog_digest: str,
+    coupling_order_limits: Mapping[str, int] | None,
+) -> RecurrenceSemanticDigestV1 | None:
+    """Project a fail-closed exact theorem without constructing a process DAG."""
+
+    if model is None:
+        return None
+    limits = {
+        str(name).upper(): int(value)
+        for name, value in (coupling_order_limits or {}).items()
+        if int(value) >= 0
+    }
+    vertices = _reachable_vertex_inventory(
+        process,
+        model,
+        coupling_order_limits=limits,
+    )
+    if not model.pure_massless_adjoint_helicity_zero_rule_is_proven(
+        process,
+        vertices,
+    ):
+        return None
+    return RecurrenceSemanticDigestV1(
+        _PURE_MASSLESS_ADJOINT_HELICITY_SUPPORT_ROLE,
+        _digest(
+            {
+                "algorithm": _PURE_MASSLESS_ADJOINT_HELICITY_SUPPORT_ROLE,
+                "coupling_order_limits": sorted(limits.items()),
+                "model_catalog_digest": model_catalog_digest,
+                "process": process.to_json_dict(),
+                "reachable_vertices": [
+                    {
+                        "kind": int(vertex.kind),
+                        "particles": [int(value) for value in vertex.particles],
+                    }
+                    for vertex in vertices
+                ],
+            }
+        ),
+    )
+
+
+def _project_global_helicity_flip_proof(
+    process: CanonicalProcessIR,
+    external_legs: Sequence[RecurrenceExternalLegV1],
+    model: Model | None,
+    *,
+    model_catalog_digest: str,
+    coupling_order_limits: Mapping[str, int] | None,
+    generation_selected: bool,
+) -> RecurrenceSemanticDigestV1 | None:
+    """Project the same fail-closed parity theorem used by DAG generation.
+
+    The recurrence builder operates before a :class:`GenericDAG` exists, so it
+    cannot consume the DAG post-pass directly.  Instead, bind the exact model
+    predicate, reachable vertex inventory, and complete two-state external
+    helicity axes into the process projection.  Generation-specialized
+    helicity slices remain untouched because they need not contain both orbit
+    members.
+    """
+
+    if model is None or generation_selected:
+        return None
+    if len(external_legs) != len(process.legs):
+        raise RecurrenceProjectionError(
+            "recurrence parity proof external-leg projection is incomplete"
+        )
+
+    external_axes: list[tuple[int, tuple[int, int]]] = []
+    for process_leg, projected_leg in zip(process.legs, external_legs, strict=True):
+        outgoing_pdg = process_leg.outgoing_pdg
+        if outgoing_pdg is None:
+            return None
+        particle_id = int(outgoing_pdg)
+        if model.mass(particle_id) != 0.0 or not (
+            model.is_fundamental_colored_fermion(particle_id)
+            or model.is_massless_adjoint_vector(particle_id)
+        ):
+            return None
+        helicities = tuple(
+            sorted(
+                {int(state.public_helicity) for state in projected_leg.source_states}
+            )
+        )
+        if (
+            len(helicities) != 2
+            or helicities[0] == 0
+            or helicities[0] != -helicities[1]
+        ):
+            return None
+        external_axes.append((int(projected_leg.source_slot), helicities))
+
+    limits = {
+        str(name).upper(): int(value)
+        for name, value in (coupling_order_limits or {}).items()
+        if int(value) >= 0
+    }
+    vertices = _reachable_vertex_inventory(
+        process,
+        model,
+        coupling_order_limits=limits,
+    )
+    if not vertices or not model.global_helicity_flip_equivalence_is_proven(vertices):
+        return None
+    return RecurrenceSemanticDigestV1(
+        _GLOBAL_HELICITY_FLIP_EQUIVALENCE_ROLE,
+        _digest(
+            {
+                "algorithm": _GLOBAL_HELICITY_FLIP_EQUIVALENCE_ROLE,
+                "coupling_order_limits": sorted(limits.items()),
+                "external_helicity_axes": external_axes,
+                "model_catalog_digest": model_catalog_digest,
+                "process": process.to_json_dict(),
+                "reachable_vertices": [
+                    {
+                        "kind": int(vertex.kind),
+                        "particles": [int(value) for value in vertex.particles],
+                    }
+                    for vertex in vertices
+                ],
+            }
+        ),
+    )
+
+
+def _reachable_vertex_inventory(
+    process: CanonicalProcessIR,
+    model: Model,
+    *,
+    coupling_order_limits: Mapping[str, int],
+) -> tuple[Vertex, ...]:
+    """Conservatively close the process species under allowed local vertices."""
+
+    reachable = {
+        int(leg.outgoing_pdg) for leg in process.legs if leg.outgoing_pdg is not None
+    }
+    used: set[Vertex] = set()
+    vertices = tuple(model.iter_vertices(color_accuracy=process.color_accuracy))
+    changed = True
+    while changed:
+        changed = False
+        for vertex in vertices:
+            left, right, result = (int(value) for value in vertex.particles)
+            if left not in reachable or right not in reachable:
+                continue
+            orders = {
+                str(name).upper(): int(value)
+                for name, value in model.vertex_coupling_orders(vertex)
+            }
+            if any(
+                orders.get(name, 0) > limit
+                for name, limit in coupling_order_limits.items()
+            ):
+                continue
+            used.add(vertex)
+            if result not in reachable:
+                reachable.add(result)
+                changed = True
+    return tuple(
+        sorted(
+            used,
+            key=lambda vertex: (
+                int(vertex.kind),
+                tuple(int(value) for value in vertex.particles),
+            ),
+        )
+    )
+
+
+def _validate_projection_roots(
+    process: CanonicalProcessIR,
+    color_plan: GenericColorPlan,
+    template_catalog: RecurrenceTemplateCatalog,
+    layout: str,
+    *,
+    contracted_physical_color_union: bool,
+) -> None:
+    if not isinstance(process, CanonicalProcessIR):
+        raise TypeError("recurrence projection requires CanonicalProcessIR")
+    if not isinstance(color_plan, GenericColorPlan):
+        raise TypeError("recurrence projection requires GenericColorPlan")
+    if not isinstance(template_catalog, RecurrenceTemplateCatalog):
+        raise TypeError("recurrence projection requires RecurrenceTemplateCatalog")
+    if type(contracted_physical_color_union) is not bool:
+        raise TypeError("contracted physical-color union opt-in must be boolean")
+    if layout not in {
+        "topology-replay",
+        "all-flow-union",
+        "contracted-color-union",
+    }:
+        raise RecurrenceProjectionError(
+            f"unsupported recurrence flow layout {layout!r}"
+        )
+    if process.color_accuracy != color_plan.color_accuracy:
+        raise RecurrenceProjectionError(
+            "recurrence process and color-plan accuracies disagree"
+        )
+    if contracted_physical_color_union and (
+        process.color_accuracy not in {"nlc", "full"}
+        or layout != "all-flow-union"
+        or color_plan.trace_reflections_folded
+    ):
+        raise RecurrenceProjectionError(
+            "contracted physical-color union requires complete NLC/full color, "
+            "an all-flow-union layout, and unfolded physical sectors"
+        )
+    if process.color_accuracy == "lc" and layout == "contracted-color-union":
+        raise RecurrenceProjectionError(
+            "LC recurrence requires topology-replay or all-flow-union"
+        )
+    if (
+        process.color_accuracy in {"nlc", "full"}
+        and layout != "contracted-color-union"
+        and not contracted_physical_color_union
+    ):
+        raise RecurrenceProjectionError(
+            "NLC/full recurrence requires the contracted-color-union strategy"
+        )
+    if process.color_accuracy not in {"lc", "nlc", "full"}:
+        raise RecurrenceProjectionError(
+            f"unsupported recurrence color accuracy {process.color_accuracy!r}"
+        )
+    if color_plan.process != process:
+        raise RecurrenceProjectionError(
+            "recurrence color plan does not belong to the supplied process IR"
+        )
+    if color_plan.truncated:
+        raise RecurrenceProjectionError(
+            "recurrence projection rejects truncated color plans"
+        )
+    if not color_plan.sectors:
+        raise RecurrenceProjectionError(
+            "recurrence projection requires physical LC sectors"
+        )
+    sector_ids = tuple(sorted(int(sector.id) for sector in color_plan.sectors))
+    if sector_ids != tuple(range(len(sector_ids))):
+        raise RecurrenceProjectionError(
+            "recurrence projection requires dense physical LC sector IDs"
+        )
+
+
+def _physical_color_owner_plan(color_plan: GenericColorPlan) -> GenericColorPlan:
+    """Return dense canonical tensor owners for one complete physical plan."""
+
+    owner_by_key: dict[tuple[object, ...], int] = {}
+    owners = []
+    for sector in sorted(color_plan.sectors, key=lambda item: int(item.id)):
+        sector_id = int(sector.id)
+        if sector.kind == "open-lines":
+            key: tuple[object, ...] = (
+                "open-lines",
+                _canonical_open_string_product_key(
+                    (
+                        line.fundamental_label,
+                        line.adjoint_labels,
+                        line.antifundamental_label,
+                        line.singlet_labels,
+                    )
+                    for line in sector.open_color_lines
+                ),
+            )
+        else:
+            key = (sector.kind, sector_id)
+        if owner_by_key.setdefault(key, sector_id) != sector_id:
+            continue
+        owners.append(replace(sector, id=len(owners)))
+    if not owners:
+        raise RecurrenceProjectionError(
+            "contracted physical-color union has no canonical owner sectors"
+        )
+    return replace(color_plan, sectors=tuple(owners))
+
+
+def _project_template_references(
+    catalog: RecurrenceTemplateCatalog,
+) -> tuple[
+    dict[tuple[str, str], int],
+    tuple[RecurrenceSemanticTemplateReferenceV1, ...],
+]:
+    binding_by_template: dict[str, EvaluatorBindingV1] = {}
+    for binding in catalog.evaluator_bindings:
+        for semantic_id in binding.semantic_template_ids:
+            previous = binding_by_template.setdefault(semantic_id, binding)
+            if previous != binding:
+                raise RecurrenceProjectionError(
+                    f"semantic template {semantic_id!r} has multiple callables"
+                )
+
+    numeric_ids: dict[tuple[str, str], int] = {}
+    references: list[RecurrenceSemanticTemplateReferenceV1] = []
+    for kind, attribute in _TEMPLATE_SECTIONS:
+        records = tuple(
+            sorted(getattr(catalog, attribute), key=lambda item: item.template_id)
+        )
+        for numeric_id, record in enumerate(records):
+            key = (kind, record.template_id)
+            numeric_ids[key] = numeric_id
+            binding = binding_by_template.get(record.template_id)
+            prepared_kernel_id = None if binding is None else binding.prepared_kernel_id
+            references.append(
+                RecurrenceSemanticTemplateReferenceV1(
+                    kind=kind,
+                    template_id=numeric_id,
+                    semantic_digest=record.semantic_digest,
+                    prepared_kernel_id=prepared_kernel_id,
+                )
+            )
+    return numeric_ids, tuple(references)
+
+
+def _project_external_legs(
+    process: CanonicalProcessIR,
+    catalog: RecurrenceTemplateCatalog,
+    template_ids: Mapping[tuple[str, str], int],
+    selected_helicities: tuple[tuple[int, int], ...] | None,
+    support_mask: int,
+) -> tuple[
+    tuple[RecurrenceExternalLegV1, ...],
+    tuple[RecurrenceSelectedSourceCoverageV1, ...] | None,
+]:
+    selected = dict(selected_helicities or ())
+    known_labels = {int(leg.label) for leg in process.legs}
+    unknown_labels = tuple(sorted(set(selected) - known_labels))
+    if unknown_labels:
+        raise RecurrenceProjectionError(
+            f"generation slice references unknown source labels {unknown_labels!r}"
+        )
+
+    states_by_id = {record.template_id: record for record in catalog.current_states}
+    states_by_execution_key: dict[tuple[object, ...], CurrentStateTemplateV1] = {}
+    for record in catalog.current_states:
+        key = _current_state_execution_key(record)
+        previous = states_by_execution_key.setdefault(key, record)
+        if previous.template_id != record.template_id:
+            raise RecurrenceProjectionError(
+                "recurrence current-state catalog contains duplicate execution "
+                f"contracts {previous.template_id!r} and {record.template_id!r}"
+            )
+    source_rows: dict[
+        int,
+        list[tuple[SourceTemplateV1, CurrentStateTemplateV1]],
+    ] = {}
+    for source in catalog.sources:
+        try:
+            current = states_by_id[source.state_template_id]
+        except KeyError as exc:
+            raise RecurrenceProjectionError(
+                f"source template {source.template_id!r} references a missing state"
+            ) from exc
+        source_rows.setdefault(int(current.particle_id), []).append((source, current))
+
+    external: list[RecurrenceExternalLegV1] = []
+    selected_coverage: list[RecurrenceSelectedSourceCoverageV1] = []
+    for source_slot, leg in enumerate(process.legs):
+        is_fermionic = _is_fermionic_process_leg(leg)
+        if leg.pdg is None or leg.outgoing_pdg is None:
+            raise RecurrenceProjectionError(
+                f"external leg {leg.label} has no concrete physical/outgoing PDG"
+            )
+        candidates = source_rows.get(int(leg.outgoing_pdg), ())
+        projected: list[
+            tuple[
+                SourceTemplateV1,
+                CurrentStateTemplateV1,
+                int,
+                int,
+                int,
+                int,
+                ExactComplexRationalV1,
+            ]
+        ] = []
+        for source, current in candidates:
+            if source.wavefunction_family != leg.wavefunction_family:
+                continue
+            helicity = int(source.helicity)
+            chirality = int(current.chirality)
+            spin_state = int(source.spin_state)
+            crossing = _crossing_contract(source)
+            momentum_sign = 1
+            phase = ExactComplexRationalV1(1)
+            if leg.is_initial:
+                helicity *= crossing[0]
+                chirality *= crossing[1]
+                spin_state *= crossing[2]
+                momentum_sign = crossing[3]
+                phase = crossing[4]
+            execution_key = _current_state_execution_key(
+                current,
+                chirality=chirality,
+            )
+            try:
+                execution_current = states_by_execution_key[execution_key]
+            except KeyError as exc:
+                raise RecurrenceProjectionError(
+                    "recurrence template catalog has no current-state contract for "
+                    f"crossed source {source.template_id!r}: particle="
+                    f"{current.particle_id}, chirality={chirality}"
+                ) from exc
+            projected.append(
+                (
+                    source,
+                    execution_current,
+                    helicity,
+                    chirality,
+                    spin_state,
+                    momentum_sign,
+                    phase,
+                )
+            )
+        projected.sort(
+            key=lambda item: (
+                item[2],
+                item[3],
+                item[4],
+                item[1].template_id,
+                item[0].template_id,
+            )
+        )
+        if not projected:
+            raise RecurrenceProjectionError(
+                "recurrence template catalog has no supported source semantics for "
+                f"external leg {leg.label} (outgoing PDG {leg.outgoing_pdg})"
+            )
+
+        source_states = tuple(
+            RecurrenceSourceStateV1(
+                state_index=index,
+                public_helicity=helicity,
+                chirality=chirality,
+                spin_state=spin_state,
+                current_state_template_id=_template_id(
+                    template_ids,
+                    "current-state",
+                    current.template_id,
+                ),
+                source_template_id=_template_id(
+                    template_ids, "source", source.template_id
+                ),
+                momentum_sign=momentum_sign,
+                crossing_phase=phase,
+            )
+            for index, (
+                source,
+                current,
+                helicity,
+                chirality,
+                spin_state,
+                momentum_sign,
+                phase,
+            ) in enumerate(projected)
+        )
+        external.append(
+            RecurrenceExternalLegV1(
+                source_slot=source_slot,
+                public_label=int(leg.label),
+                physical_pdg=int(leg.pdg),
+                outgoing_pdg=int(leg.outgoing_pdg),
+                is_initial=bool(leg.is_initial),
+                is_fermionic=is_fermionic,
+                source_states=source_states,
+                momentum_mask=1 << source_slot,
+                support_mask=support_mask,
+            )
+        )
+        if selected_helicities is not None:
+            requested = selected.get(int(leg.label))
+            retained = tuple(
+                index
+                for index, (
+                    _source,
+                    _current,
+                    helicity,
+                    _chirality,
+                    _spin_state,
+                    _momentum_sign,
+                    _phase,
+                ) in enumerate(projected)
+                if requested is None or helicity == requested
+            )
+            if not retained:
+                available = tuple(sorted({item[2] for item in projected}))
+                raise RecurrenceProjectionError(
+                    f"selected helicity {requested} is unavailable for source "
+                    f"label {leg.label}; available={available!r}"
+                )
+            selected_coverage.append(
+                RecurrenceSelectedSourceCoverageV1(source_slot, retained)
+            )
+
+    return (
+        tuple(external),
+        None if selected_helicities is None else tuple(selected_coverage),
+    )
+
+
+def _current_state_execution_key(
+    state: CurrentStateTemplateV1,
+    *,
+    chirality: int | None = None,
+) -> tuple[object, ...]:
+    """Identity of a current state after applying external crossing.
+
+    Crossing may change the chiral representation used by subsequent
+    recurrence transitions, but it does not change the model-owned particle,
+    basis, colour, tensor, or parameter contracts.
+    """
+
+    return (
+        state.particle_id,
+        state.anti_particle_id,
+        state.species_id,
+        state.orientation,
+        state.statistics,
+        state.color_representation,
+        state.basis,
+        state.tensor_ordering,
+        state.dimension,
+        state.chirality if chirality is None else chirality,
+        state.lc_color_shape_kind,
+        state.auxiliary_kind,
+        state.mass_parameter_id,
+        state.width_parameter_id,
+    )
+
+
+def _is_fermionic_process_leg(leg: ProcessLegIR) -> bool:
+    concrete_statistics = {"auxiliary", "boson", "fermion", "ghost"}
+    concrete_families = {
+        "auxiliary",
+        "fermion",
+        "ghost",
+        "scalar",
+        "spin2",
+        "vector",
+    }
+    if (
+        leg.statistics not in concrete_statistics
+        or leg.wavefunction_family not in concrete_families
+    ):
+        raise RecurrenceProjectionError(
+            "recurrence closure-anchor classification requires concrete external "
+            f"statistics and spin metadata for leg {leg.label}"
+        )
+    statistics_is_fermionic = leg.statistics == "fermion"
+    family_is_fermionic = leg.wavefunction_family == "fermion"
+    if statistics_is_fermionic != family_is_fermionic:
+        raise RecurrenceProjectionError(
+            "recurrence closure-anchor classification found inconsistent "
+            f"statistics and spin metadata for leg {leg.label}"
+        )
+    return statistics_is_fermionic
+
+
+def _crossing_contract(
+    source: SourceTemplateV1,
+) -> tuple[int, int, int, int, ExactComplexRationalV1]:
+    try:
+        payload = json.loads(source.crossing)
+        helicity = payload["helicity_factor"]
+        chirality = payload["chirality_factor"]
+        spin_state = payload["spin_state_factor"]
+        momentum_transform = payload["momentum_transform"]
+        phase = payload["phase"]
+    except (json.JSONDecodeError, KeyError, TypeError) as exc:
+        raise RecurrenceProjectionError(
+            f"source template {source.template_id!r} has malformed crossing semantics"
+        ) from exc
+    if (
+        helicity not in {-1, 1}
+        or chirality not in {-1, 1}
+        or spin_state not in {-1, 1}
+        or momentum_transform not in {"identity", "negate-four-momentum"}
+        or not isinstance(phase, Mapping)
+    ):
+        raise RecurrenceProjectionError(
+            f"source template {source.template_id!r} has unsupported crossing factors"
+        )
+    try:
+        exact_phase = ExactComplexRationalV1(
+            int(phase["real_numerator"]),
+            int(phase["real_denominator"]),
+            int(phase["imag_numerator"]),
+            int(phase["imag_denominator"]),
+        )
+    except (KeyError, TypeError, ValueError) as exc:
+        raise RecurrenceProjectionError(
+            f"source template {source.template_id!r} has malformed crossing phase"
+        ) from exc
+    momentum_sign = -1 if momentum_transform == "negate-four-momentum" else 1
+    return int(helicity), int(chirality), int(spin_state), momentum_sign, exact_phase
+
+
+def _project_physical_sectors(
+    color_plan: GenericColorPlan,
+    process: CanonicalProcessIR,
+    external_legs: tuple[RecurrenceExternalLegV1, ...],
+    support_mask: int,
+) -> tuple[
+    tuple[RecurrencePhysicalLCSectorV1, ...],
+    tuple[RecurrencePublicLCFlowV1, ...],
+]:
+    slot_by_label = {
+        int(leg.label): source_slot for source_slot, leg in enumerate(process.legs)
+    }
+
+    def slots(labels: Sequence[int], context: str) -> tuple[int, ...]:
+        try:
+            return tuple(slot_by_label[int(label)] for label in labels)
+        except KeyError as exc:
+            raise RecurrenceProjectionError(
+                f"{context} references unknown external label {exc.args[0]}"
+            ) from exc
+
+    result: list[RecurrencePhysicalLCSectorV1] = []
+    public_flows: list[RecurrencePublicLCFlowV1] = []
+    identity_permutation = tuple(range(len(process.legs)))
+    for sector in sorted(color_plan.sectors, key=lambda item: item.id):
+        words = sector.color_words
+        if not words:
+            raise RecurrenceProjectionError(
+                f"LC sector {sector.id} has no physical color word"
+            )
+        word = sector.word_labels or words[0]
+        public_id = (
+            "flow:" + ",".join(str(int(label)) for label in word)
+            if word
+            else "flow:singlet"
+        )
+        open_strings = tuple(
+            RecurrenceLCOpenStringV1(
+                fundamental_source_slot=slots(
+                    (line.fundamental_label,), "LC fundamental endpoint"
+                )[0],
+                antifundamental_source_slot=slots(
+                    (line.antifundamental_label,), "LC antifundamental endpoint"
+                )[0],
+                adjoint_source_slots=slots(
+                    line.adjoint_labels, "LC open-string adjoints"
+                ),
+                singlet_source_slots=slots(
+                    line.singlet_labels, "LC open-string singlets"
+                ),
+            )
+            for line in sector.open_color_lines
+        )
+        trace_source_slots = slots(sector.trace_labels, "LC trace")
+        singlet_source_slots = slots(sector.singlet_labels, "LC singlets")
+        word_source_slots = slots(word, "LC color word")
+        closure_word = sector.canonical_closure_traversal_word(process)
+        closure_word_source_slots = slots(
+            closure_word,
+            "LC closure traversal",
+        )
+        physical_blocks = (
+            _ordered_open_line_blocks(tuple(word), sector.open_color_lines)
+            if sector.kind == "open-lines"
+            else ()
+        )
+        closure_blocks = (
+            _ordered_open_line_blocks(closure_word, sector.open_color_lines)
+            if sector.kind == "open-lines"
+            else ()
+        )
+        if physical_blocks is None or closure_blocks is None:
+            raise RecurrenceProjectionError(
+                f"LC sector {sector.id} open-line blocks cannot be reconstructed"
+            )
+        (
+            closure_source_slot,
+            closure_proof_algorithm,
+            closure_proof_digest,
+        ) = _closure_anchor_contract(
+            sector_id=int(sector.id),
+            sector_kind=sector.kind,
+            open_string_count=len(open_strings),
+            word_source_slots=word_source_slots,
+            closure_word_source_slots=closure_word_source_slots,
+            physical_block_source_slots=tuple(
+                slots(block, "LC physical open-line block") for block in physical_blocks
+            ),
+            closure_block_source_slots=tuple(
+                slots(block, "LC closure open-line block") for block in closure_blocks
+            ),
+            process_source_label_order=tuple(int(leg.label) for leg in process.legs),
+            singlet_source_slots=singlet_source_slots,
+            external_legs=external_legs,
+        )
+        result.append(
+            RecurrencePhysicalLCSectorV1(
+                sector_id=int(sector.id),
+                public_id=public_id,
+                kind=sector.kind,
+                closure_source_slot=closure_source_slot,
+                closure_proof_algorithm=closure_proof_algorithm,
+                closure_proof_digest=closure_proof_digest,
+                open_strings=open_strings,
+                trace_source_slots=trace_source_slots,
+                singlet_source_slots=singlet_source_slots,
+                word_source_slots=word_source_slots,
+                support_mask=support_mask,
+            )
+        )
+        public_flows.append(
+            RecurrencePublicLCFlowV1(
+                flow_id=len(public_flows),
+                public_id=public_id,
+                construction_sector_id=int(sector.id),
+                word_source_slots=word_source_slots,
+                source_slot_permutation=identity_permutation,
+            )
+        )
+        if not (
+            color_plan.trace_reflections_folded
+            and sector.kind == "single-trace"
+            and len(word) > 2
+        ):
+            continue
+        reflected = (word[0], *reversed(word[1:]))
+        if reflected == tuple(word):
+            continue
+        public_flows.append(
+            RecurrencePublicLCFlowV1(
+                flow_id=len(public_flows),
+                public_id="flow:" + ",".join(str(int(label)) for label in reflected),
+                construction_sector_id=int(sector.id),
+                word_source_slots=slots(reflected, "reflected LC public color word"),
+                # Exact trace reflection changes only the ordered colour word.
+                # External states and momenta remain attached to their public
+                # labels; the reflection proof supplies the amplitude relation.
+                source_slot_permutation=identity_permutation,
+            )
+        )
+    return tuple(result), tuple(public_flows)
+
+
+def _closure_anchor_contract(
+    *,
+    sector_id: int,
+    sector_kind: str,
+    open_string_count: int,
+    word_source_slots: tuple[int, ...],
+    closure_word_source_slots: tuple[int, ...],
+    physical_block_source_slots: tuple[tuple[int, ...], ...],
+    closure_block_source_slots: tuple[tuple[int, ...], ...],
+    process_source_label_order: tuple[int, ...],
+    singlet_source_slots: tuple[int, ...],
+    external_legs: tuple[RecurrenceExternalLegV1, ...],
+) -> tuple[int, str, str]:
+    external_source_count = len(external_legs)
+    if external_source_count <= 0:
+        raise RecurrenceProjectionError(
+            "a physical LC sector requires at least one external source"
+        )
+    if word_source_slots:
+        if not closure_word_source_slots:
+            raise RecurrenceProjectionError(
+                "a coloured LC sector has an empty closure traversal"
+            )
+        if set(closure_word_source_slots) != set(word_source_slots):
+            raise RecurrenceProjectionError(
+                "LC closure traversal does not preserve the physical colour word"
+            )
+        closure_source_slot = closure_word_source_slots[-1]
+        # Newly projected open-line sectors always carry the v3 structural
+        # proof, including the no-rotation case.  The decoder retains v2 for
+        # already encoded terminal-word contracts.
+        proof_algorithm = (
+            _CLOSURE_ANCHOR_PROOF_ALGORITHM_V3
+            if sector_kind == "open-lines"
+            else _CLOSURE_ANCHOR_PROOF_ALGORITHM_V2
+        )
+        policy = (
+            "terminal-colour-word-endpoint"
+            if proof_algorithm == _CLOSURE_ANCHOR_PROOF_ALGORITHM_V2
+            else "minimum-coloured-source-slot-open-line-block-rotation"
+        )
+    else:
+        if sector_kind != "singlet" or tuple(sorted(singlet_source_slots)) != tuple(
+            range(external_source_count)
+        ):
+            raise RecurrenceProjectionError(
+                "an LC sector without a colour word must be an all-singlet sector"
+            )
+        fermionic_source_slots = tuple(
+            leg.source_slot for leg in external_legs if leg.is_fermionic
+        )
+        if fermionic_source_slots:
+            policy = "minimum-fermionic-source-slot"
+            closure_source_slot = min(fermionic_source_slots)
+        else:
+            policy = "minimum-source-slot"
+            closure_source_slot = min(leg.source_slot for leg in external_legs)
+        proof_algorithm = _CLOSURE_ANCHOR_PROOF_ALGORITHM_V2
+    proof_payload: dict[str, object] = {
+        "algorithm": proof_algorithm,
+        "closure_source_slot": closure_source_slot,
+        "component_order_policy": (
+            "independent-open-string-block-permutation"
+            if sector_kind == "open-lines" and open_string_count > 1
+            else "exact-ordered-components"
+        ),
+        "external_source_count": external_source_count,
+        "fermionic_source_slots": tuple(
+            leg.source_slot for leg in external_legs if leg.is_fermionic
+        ),
+        "open_string_count": open_string_count,
+        "policy": policy,
+        "sector_id": sector_id,
+        "sector_kind": sector_kind,
+        "singlet_source_slots": singlet_source_slots,
+        "word_source_slots": word_source_slots,
+    }
+    if proof_algorithm == _CLOSURE_ANCHOR_PROOF_ALGORITHM_V3:
+        if not physical_block_source_slots or not closure_block_source_slots:
+            raise RecurrenceProjectionError(
+                "v3 LC closure anchor requires reconstructed open-line blocks"
+            )
+        distinguished_source_slot = min(word_source_slots)
+        if distinguished_source_slot not in closure_block_source_slots[0]:
+            raise RecurrenceProjectionError(
+                "v3 LC closure traversal does not start with the block containing "
+                "the minimum coloured source slot"
+            )
+        proof_payload.update(
+            {
+                "closure_block_source_slots": closure_block_source_slots,
+                "closure_traversal_source_slots": closure_word_source_slots,
+                "distinguished_source_slot": distinguished_source_slot,
+                "distinguished_source_block": closure_block_source_slots[0],
+                "physical_block_source_slots": physical_block_source_slots,
+                "process_source_label_order": process_source_label_order,
+                "selected_closure_block": closure_block_source_slots[-1],
+            }
+        )
+    proof_digest = _digest(proof_payload)
+    return closure_source_slot, proof_algorithm, proof_digest
+
+
+def _project_cyclic_trace_closure_anchors(
+    sectors: tuple[RecurrencePhysicalLCSectorV1, ...],
+    replay_partitions: tuple[RecurrenceReplayPartitionV1, ...],
+    external_legs: tuple[RecurrenceExternalLegV1, ...],
+    template_catalog: RecurrenceTemplateCatalog,
+) -> tuple[RecurrencePhysicalLCSectorV1, ...]:
+    """Fix one authenticated adjoint trace source as the closure sink.
+
+    This is deliberately an opt-in projection for the symmetric-group colour
+    lane.  It uses only cyclic trace equivalence plus process/template
+    contracts.  Any heterogeneous, open-line, fermionic, auxiliary, or
+    replay-incompatible channel retains its established v2/v3 anchor.
+    """
+
+    # Replay and reflection folding choose their canonical owners independently.
+    # A replay representative can therefore be the non-canonical member of a
+    # reflection orbit whose owner belongs to another replay partition.  Keep
+    # the established per-sector anchors until those two proofs are composed.
+    if replay_partitions:
+        return sectors
+
+    state_template_id = _cyclic_trace_state_template_id(
+        external_legs,
+        template_catalog,
+    )
+    if state_template_id is None:
+        return sectors
+
+    candidates: dict[int, int] = {}
+    full_source_domain = tuple(range(len(external_legs)))
+    for sector in sectors:
+        if (
+            sector.kind != "single-trace"
+            or sector.open_strings
+            or sector.singlet_source_slots
+            or not sector.trace_source_slots
+            or sector.trace_source_slots != sector.word_source_slots
+            or tuple(sorted(sector.word_source_slots)) != full_source_domain
+        ):
+            continue
+        candidates[sector.sector_id] = min(sector.word_source_slots)
+
+    # A replayed representative must keep the same distinguished source under
+    # every exact target mapping.  Fall back for the complete partition when
+    # any target cannot preserve that closure ancestry.
+    rejected: set[int] = set()
+    for partition in replay_partitions:
+        partition_sector_ids = {target.sector_id for target in partition.targets}
+        representative_anchor = candidates.get(partition.representative_sector_id)
+        if representative_anchor is None or not partition_sector_ids.issubset(
+            candidates
+        ):
+            rejected.update(partition_sector_ids)
+            continue
+        if any(
+            target.source_slot_permutation[representative_anchor]
+            != candidates[target.sector_id]
+            for target in partition.targets
+        ):
+            rejected.update(partition_sector_ids)
+
+    result: list[RecurrencePhysicalLCSectorV1] = []
+    process_source_label_order = tuple(leg.public_label for leg in external_legs)
+    fermionic_source_slots = tuple(
+        leg.source_slot for leg in external_legs if leg.is_fermionic
+    )
+    for sector in sectors:
+        closure_source_slot = candidates.get(sector.sector_id)
+        if closure_source_slot is None or sector.sector_id in rejected:
+            result.append(sector)
+            continue
+        proof_payload = {
+            "algorithm": _CLOSURE_ANCHOR_PROOF_ALGORITHM_V4,
+            "closure_source_slot": closure_source_slot,
+            "component_order_policy": "cyclic-single-trace",
+            "external_source_count": len(external_legs),
+            "fermionic_source_slots": fermionic_source_slots,
+            "open_string_count": 0,
+            "policy": "minimum-source-slot-cyclic-single-trace",
+            "process_source_label_order": process_source_label_order,
+            "sector_id": sector.sector_id,
+            "sector_kind": sector.kind,
+            "singlet_source_slots": sector.singlet_source_slots,
+            "state_template_id": state_template_id,
+            "trace_source_slots": sector.trace_source_slots,
+            "word_source_slots": sector.word_source_slots,
+        }
+        result.append(
+            replace(
+                sector,
+                closure_source_slot=closure_source_slot,
+                closure_proof_algorithm=_CLOSURE_ANCHOR_PROOF_ALGORITHM_V4,
+                closure_proof_digest=_digest(proof_payload),
+            )
+        )
+    return tuple(result)
+
+
+def _cyclic_trace_state_template_id(
+    external_legs: tuple[RecurrenceExternalLegV1, ...],
+    catalog: RecurrenceTemplateCatalog,
+) -> int | None:
+    """Return one process-wide state ID only for the certified adjoint case."""
+
+    if not external_legs or any(
+        leg.is_fermionic or not leg.source_states for leg in external_legs
+    ):
+        return None
+    state_ids = {
+        state.current_state_template_id
+        for leg in external_legs
+        for state in leg.source_states
+    }
+    if len(state_ids) != 1:
+        return None
+    state_template_id = next(iter(state_ids))
+    try:
+        state = catalog.current_states[state_template_id]
+    except IndexError:
+        return None
+    if (
+        state.orientation != "self-conjugate"
+        or state.statistics != "boson"
+        or state.particle_id != state.anti_particle_id
+        or state.color_representation != 8
+        or state.lc_color_shape_kind != "adjoint-segment"
+        or state.auxiliary_kind is not None
+    ):
+        return None
+
+    bindings = {binding.resolver_key: binding for binding in catalog.evaluator_bindings}
+    colors = {color.template_id: color for color in catalog.color_contractions}
+    for closure in catalog.closures:
+        if (
+            closure.input_state_template_ids != (state.template_id, state.template_id)
+            or closure.result_state_template_id is not None
+            or closure.coupling_parameter_ids
+            or closure.coupling_orders
+            or closure.eligible_quantum_flow_template_ids
+            or closure.output_factor_source != "none"
+            or closure.equivalence_class != "direct-contraction"
+        ):
+            continue
+        binding = bindings.get(closure.evaluator_resolver_key)
+        color = colors.get(closure.color_contraction_template_id)
+        if (
+            binding is not None
+            and binding.callable_kind == "rusticol-template"
+            and binding.contract_kind == "closure"
+            and binding.input_state_template_ids
+            == (state.template_id, state.template_id)
+            and binding.output_state_template_id is None
+            and color is not None
+            and color.input_representations == (8, 8)
+            and color.output_representation is None
+        ):
+            return state_template_id
+    return None
+
+
+def _project_replay_partitions(
+    process: CanonicalProcessIR,
+    color_plan: GenericColorPlan,
+    physical_sectors: tuple[RecurrencePhysicalLCSectorV1, ...],
+    external_legs: tuple[RecurrenceExternalLegV1, ...],
+    replay: LCColorTopologyReplayPlan | ColorTopologyReplayCertificate | None,
+    layout: RecurrenceLCFlowLayout,
+) -> tuple[RecurrenceReplayPartitionV1, ...]:
+    if layout not in {"topology-replay", "contracted-color-union"}:
+        return ()
+    if replay is None:
+        return ()
+    if layout == "topology-replay" and not isinstance(
+        replay, LCColorTopologyReplayPlan
+    ):
+        raise RecurrenceProjectionError(
+            "LC topology-replay layout requires an LC replay plan"
+        )
+    if layout == "contracted-color-union" and not isinstance(
+        replay, ColorTopologyReplayCertificate
+    ):
+        raise RecurrenceProjectionError(
+            "contracted-color-union replay requires a color-generic certificate"
+        )
+    if isinstance(replay, ColorTopologyReplayCertificate) and (
+        replay.color_accuracy != color_plan.color_accuracy
+    ):
+        raise RecurrenceProjectionError(
+            "topology replay certificate color accuracy does not match the plan"
+        )
+    physical_ids = tuple(sorted(int(sector.id) for sector in color_plan.sectors))
+    if replay.physical_sector_ids != physical_ids:
+        raise RecurrenceProjectionError(
+            "topology replay proof does not cover this physical LC plan"
+        )
+
+    source_slot_by_label = {
+        int(leg.label): source_slot for source_slot, leg in enumerate(process.legs)
+    }
+    labels = set(source_slot_by_label)
+    physical_sector_by_id = {sector.sector_id: sector for sector in physical_sectors}
+    partitions: list[RecurrenceReplayPartitionV1] = []
+    identity_materializations: dict[
+        int, tuple[str, int, Mapping[str, object] | None]
+    ] = {}
+    for partition in replay.partitions:
+        if partition.proof_algorithm is None or partition.proof_digest is None:
+            raise RecurrenceProjectionError(
+                "topology replay partition lacks an exact proof certificate"
+            )
+        representative_sector_id = int(partition.representative_sector_id)
+        try:
+            representative_sector = physical_sector_by_id[representative_sector_id]
+        except KeyError as exc:
+            raise RecurrenceProjectionError(
+                "topology replay references a missing representative LC sector "
+                f"{representative_sector_id}"
+            ) from exc
+        representative_anchor = representative_sector.closure_source_slot
+        projected_targets: list[
+            tuple[RecurrenceReplayTargetV1, bool, int, Mapping[str, object]]
+        ] = []
+        for sector_id, raw_mapping, weight, sign in zip(
+            partition.active_sector_ids,
+            partition.label_permutations,
+            partition.weights,
+            partition.signs,
+            strict=True,
+        ):
+            mapping = {int(left): int(right) for left, right in raw_mapping}
+            if not set(mapping).issubset(labels) or not set(mapping.values()).issubset(
+                labels
+            ):
+                raise RecurrenceProjectionError(
+                    "topology replay maps an unknown external label"
+                )
+            complete = {label: mapping.get(label, label) for label in labels}
+            if set(complete.values()) != labels:
+                raise RecurrenceProjectionError(
+                    "topology replay external mapping is not a bijection"
+                )
+            permutation = tuple(
+                source_slot_by_label[complete[int(leg.label)]] for leg in process.legs
+            )
+            for representative_slot, target_slot in enumerate(permutation):
+                if (
+                    process.legs[representative_slot].side
+                    != process.legs[target_slot].side
+                ):
+                    raise RecurrenceProjectionError(
+                        "topology replay maps an external source across the "
+                        "initial/final crossing boundary"
+                    )
+            sector = color_plan.sector(int(sector_id))
+            if sector is None:
+                raise RecurrenceProjectionError(
+                    f"topology replay references missing LC sector {sector_id}"
+                )
+            expected_weight = (
+                2.0
+                if isinstance(replay, LCColorTopologyReplayPlan)
+                and color_plan.trace_reflections_folded
+                and sector.kind == "single-trace"
+                and len(sector.trace_labels) > 2
+                else 1.0
+            )
+            if not math.isclose(
+                float(weight),
+                expected_weight,
+                rel_tol=0.0,
+                abs_tol=0.0,
+            ):
+                raise RecurrenceProjectionError(
+                    "topology replay carries an unsupported non-public-flow "
+                    f"multiplicity {weight!r} for sector {sector_id}"
+                )
+            target_sector = physical_sector_by_id[int(sector_id)]
+            target = RecurrenceReplayTargetV1(
+                sector_id=int(sector_id),
+                external_permutation=permutation,
+                source_slot_permutation=permutation,
+                # Rust derives and certifies source-state and closure
+                # bijections from this exact slot permutation.
+                amplitude_phase=ExactComplexRationalV1(1),
+                fermion_sign=int(sign),
+            )
+            target_anchor = target_sector.closure_source_slot
+            anchor_compatible = permutation[representative_anchor] == target_anchor
+            source_replay = {
+                "fermion_sign": int(sign),
+                "partition_proof_algorithm": partition.proof_algorithm,
+                "partition_proof_digest": partition.proof_digest,
+                "representative_sector_id": representative_sector_id,
+                "source_slot_permutation": permutation,
+            }
+            projected_targets.append(
+                (target, anchor_compatible, int(expected_weight), source_replay)
+            )
+
+        if not isinstance(replay, LCColorTopologyReplayPlan) and any(
+            not anchor_compatible for _, anchor_compatible, _, _ in projected_targets
+        ):
+            raise RecurrenceProjectionError(
+                "topology replay does not map the representative closure "
+                "anchor onto the target sector anchor"
+            )
+        representative_is_compatible = any(
+            target.sector_id == representative_sector_id and anchor_compatible
+            for target, anchor_compatible, _, _ in projected_targets
+        )
+        retained_targets = (
+            tuple(
+                target
+                for target, anchor_compatible, _, _ in projected_targets
+                if anchor_compatible
+            )
+            if representative_is_compatible
+            else ()
+        )
+        if retained_targets:
+            partitions.append(
+                RecurrenceReplayPartitionV1(
+                    representative_sector_id=representative_sector_id,
+                    materialized_sector_id=int(partition.materialized_sector_id),
+                    proof_algorithm=partition.proof_algorithm,
+                    proof_digest=partition.proof_digest,
+                    targets=retained_targets,
+                )
+            )
+        for target, anchor_compatible, multiplicity, source_replay in projected_targets:
+            if representative_is_compatible and anchor_compatible:
+                continue
+            target_sector = physical_sector_by_id[target.sector_id]
+            mapped_word = tuple(
+                target.source_slot_permutation[source_slot]
+                for source_slot in representative_sector.word_source_slots
+            )
+            if mapped_word != target_sector.word_source_slots:
+                raise RecurrenceProjectionError(
+                    "topology replay does not map the representative LC word "
+                    "onto the target sector word"
+                )
+            for representative_slot, target_slot in enumerate(
+                target.source_slot_permutation
+            ):
+                representative_leg = external_legs[representative_slot]
+                target_leg = external_legs[target_slot]
+                representative_contracts = {
+                    state.source_template_id: (
+                        state.momentum_sign,
+                        state.crossing_phase.canonical_key,
+                    )
+                    for state in representative_leg.source_states
+                }
+                target_contracts = {
+                    state.source_template_id: (
+                        state.momentum_sign,
+                        state.crossing_phase.canonical_key,
+                    )
+                    for state in target_leg.source_states
+                }
+                if representative_contracts != target_contracts:
+                    raise RecurrenceProjectionError(
+                        "topology replay maps an external source onto one with "
+                        "a different crossing contract"
+                    )
+            identity_materializations[target.sector_id] = (
+                (
+                    "closure-anchor-incompatible"
+                    if representative_is_compatible
+                    else "representative-closure-anchor-incompatible"
+                ),
+                multiplicity,
+                source_replay,
+            )
+
+    if isinstance(replay, LCColorTopologyReplayPlan):
+        for sector_id in replay.residual_sector_ids:
+            sector = color_plan.sector(int(sector_id))
+            if sector is None:
+                raise RecurrenceProjectionError(
+                    f"topology replay references missing residual LC sector {sector_id}"
+                )
+            multiplicity = (
+                2
+                if color_plan.trace_reflections_folded
+                and sector.kind == "single-trace"
+                and len(sector.trace_labels) > 2
+                else 1
+            )
+            identity_materializations[int(sector_id)] = (
+                "replay-plan-residual",
+                multiplicity,
+                None,
+            )
+
+    identity_permutation = tuple(range(len(process.legs)))
+    for sector_id in sorted(identity_materializations):
+        reason, multiplicity, source_replay = identity_materializations[sector_id]
+        sector = physical_sector_by_id[sector_id]
+        proof_payload = {
+            "algorithm": _IDENTITY_REPLAY_PROOF_ALGORITHM,
+            "closure_proof_algorithm": sector.closure_proof_algorithm,
+            "closure_proof_digest": sector.closure_proof_digest,
+            "closure_source_slot": sector.closure_source_slot,
+            "identity_source_slot_permutation": identity_permutation,
+            "policy": "materialize-physical-sector-with-identity-replay",
+            "process_source_label_order": tuple(int(leg.label) for leg in process.legs),
+            "public_flow_multiplicity": multiplicity,
+            "reason": reason,
+            "sector_id": sector_id,
+            "source_replay": source_replay,
+            "word_source_slots": sector.word_source_slots,
+        }
+        partitions.append(
+            RecurrenceReplayPartitionV1(
+                representative_sector_id=sector_id,
+                materialized_sector_id=sector_id,
+                proof_algorithm=_IDENTITY_REPLAY_PROOF_ALGORITHM,
+                proof_digest=_digest(proof_payload),
+                targets=(
+                    RecurrenceReplayTargetV1(
+                        sector_id=sector_id,
+                        external_permutation=identity_permutation,
+                        source_slot_permutation=identity_permutation,
+                        amplitude_phase=ExactComplexRationalV1(1),
+                        fermion_sign=1,
+                    ),
+                ),
+            )
+        )
+    return tuple(partitions)
+
+
+def _project_coupling_limits(
+    limits: Mapping[str, int] | None,
+) -> tuple[RecurrenceCouplingLimitV1, ...]:
+    normalized = tuple(
+        sorted(
+            (str(raw_name).upper(), raw_maximum)
+            for raw_name, raw_maximum in (limits or {}).items()
+        )
+    )
+    names = tuple(name for name, _ in normalized)
+    if len(names) != len(set(names)):
+        raise RecurrenceProjectionError(
+            "coupling-order names must be unique after canonicalization"
+        )
+    result: list[RecurrenceCouplingLimitV1] = []
+    for name, raw_maximum in normalized:
+        if not name:
+            raise RecurrenceProjectionError("coupling-order names must be nonempty")
+        if isinstance(raw_maximum, bool) or not isinstance(raw_maximum, int):
+            raise RecurrenceProjectionError(
+                f"coupling-order limit {name!r} must be an integer"
+            )
+        if raw_maximum < 0:
+            raise RecurrenceProjectionError(
+                f"coupling-order limit {name!r} must be nonnegative"
+            )
+        result.append(RecurrenceCouplingLimitV1(name, 0, raw_maximum))
+    return tuple(result)
+
+
+def _project_parameters(
+    catalog: RecurrenceTemplateCatalog,
+    template_ids: Mapping[tuple[str, str], int],
+) -> tuple[RecurrenceParameterProjectionV1, ...]:
+    runtime_parameters = tuple(
+        sorted(
+            (
+                parameter
+                for parameter in catalog.parameters
+                if parameter.mutable or parameter.parameter_kind == "derived"
+            ),
+            key=lambda item: (item.name, item.template_id),
+        )
+    )
+    names = tuple(parameter.name for parameter in runtime_parameters)
+    if len(names) != len(set(names)):
+        raise RecurrenceProjectionError(
+            "recurrence catalog exposes duplicate runtime parameter names"
+        )
+    result: list[RecurrenceParameterProjectionV1] = []
+    for parameter in runtime_parameters:
+        components = (0,) if parameter.value_type == "real" else (0, 1)
+        for component in components:
+            result.append(
+                RecurrenceParameterProjectionV1(
+                    runtime_slot=len(result),
+                    runtime_name=parameter.name,
+                    parameter_template_id=_template_id(
+                        template_ids, "parameter", parameter.template_id
+                    ),
+                    prepared_parameter_id=parameter.prepared_parameter_id,
+                    component=component,
+                )
+            )
+    return tuple(result)
+
+
+def _template_id(
+    template_ids: Mapping[tuple[str, str], int],
+    kind: str,
+    semantic_id: str,
+) -> int:
+    try:
+        return template_ids[(kind, semantic_id)]
+    except KeyError as exc:
+        raise RecurrenceProjectionError(
+            f"missing {kind} semantic template {semantic_id!r}"
+        ) from exc
+
+
+def _digest(payload: object) -> str:
+    try:
+        encoded = json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    except (TypeError, ValueError) as exc:
+        raise RecurrenceProjectionError(
+            "recurrence projection input is not canonical JSON"
+        ) from exc
+    return hashlib.sha256(encoded).hexdigest()
+
+
+__all__ = [
+    "RecurrenceGenerationSliceV1",
+    "RecurrenceProjectionError",
+    "project_recurrence_process_v1",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/recurrence_schedule_sharing.py b/pyamplicol/src/pyamplicol/generation/recurrence_schedule_sharing.py
new file mode 100644
index 0000000000..5ea6aed790
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/recurrence_schedule_sharing.py
@@ -0,0 +1,2504 @@
+# SPDX-License-Identifier: 0BSD
+"""Content-addressed recurrence schedules and compact process bindings."""
+
+from __future__ import annotations
+
+import hashlib
+import itertools
+import json
+import math
+import re
+import struct
+from collections.abc import Callable, Mapping, Sequence
+from concurrent.futures import Future
+from dataclasses import dataclass, fields, is_dataclass
+from pathlib import Path
+from threading import Lock
+from typing import Generic, Protocol, TypeVar
+
+from .recurrence_columnar import (
+    RecurrenceBuilderLogicalInputV1,
+    RecurrenceExternalLegV1,
+    RecurrencePhysicalLCSectorV1,
+    RecurrencePublicLCFlowV1,
+    RecurrenceSourceStateV1,
+)
+
+RECURRENCE_SCHEDULE_SHARING_KIND = "pyamplicol-recurrence-schedule-sharing"
+RECURRENCE_SCHEDULE_SHARING_SCHEMA_VERSION = 3
+RECURRENCE_SCHEDULE_INDEX_PATH = "recurrence/schedule-index.json"
+RECURRENCE_PROCESS_BINDING_ABI = "pyamplicol-recurrence-process-binding-v4"
+RECURRENCE_PROCESS_BINDING_MAGIC = b"PACRDBN4"
+_PROCESS_BINDING_VERSION = 4
+_PROCESS_BINDING_FIXED_SIZE = 344
+_MAX_SOURCE_BIJECTIONS = 4096
+
+_DIRECT_ROLE = {
+    "source": 0,
+    "contribution": 1,
+    "finalization": 2,
+    "closure": 3,
+}
+_DIRECT_BACKEND = {"jit": 0, "cpp": 1, "asm": 2}
+_DIRECT_BINDING_SOURCE = 0
+_DIRECT_BINDING_INTRINSIC = 1
+_DIRECT_BINDING_JIT = 2
+_DIRECT_BINDING_NATIVE = 3
+_DIRECT_FLAG_USES_EXACT_FACTOR = 1 << 0
+_MISSING_U32 = (1 << 32) - 1
+_PROCESS_VARIABLE_SEMANTIC_ROLES = frozenset(
+    {
+        "process",
+        "color-plan",
+        "fermion-pairing-semantic",
+        "fermion-pairing-topology",
+        "closure-reconstruction",
+        "helicity-support:pure-massless-adjoint-tree-v1",
+        "helicity-equivalence:global-flip-v1",
+    }
+)
+
+_SHA256 = re.compile(r"^[0-9a-f]{64}$")
+_T = TypeVar("_T")
+
+
+class RecurrenceScheduleSharingError(ValueError):
+    """Raised when recurrence schedules cannot be shared exactly."""
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceProcessExecutorPack:
+    """Process-owned sparse Direct executor records for one fixed schedule."""
+
+    compiled_model_digest: str
+    recurrence_template_catalog_digest: str
+    prepared_kernel_pack_digest: str
+    direct_template_catalog_digest: str
+    runtime_layout_digest: str
+    backend: str
+    target_triple: str
+    portable: bool
+    cpu_features: tuple[str, ...]
+    catalog_executor_count: int
+    executor_ids: tuple[int, ...]
+    descriptor_payloads: tuple[bytes, ...]
+
+    def __post_init__(self) -> None:
+        for value, label in (
+            (self.compiled_model_digest, "compiled-model digest"),
+            (
+                self.recurrence_template_catalog_digest,
+                "recurrence-template catalog digest",
+            ),
+            (self.prepared_kernel_pack_digest, "prepared-kernel pack digest"),
+            (self.direct_template_catalog_digest, "direct-template catalog digest"),
+            (self.runtime_layout_digest, "runtime-layout digest"),
+        ):
+            _require_sha256(value, label)
+        if self.backend not in _DIRECT_BACKEND:
+            raise RecurrenceScheduleSharingError(
+                f"unsupported process executor backend {self.backend!r}"
+            )
+        _nonempty_text(self.target_triple, "process executor target triple")
+        if type(self.portable) is not bool:
+            raise RecurrenceScheduleSharingError(
+                "process executor portability must be boolean"
+            )
+        if self.cpu_features != tuple(sorted(set(self.cpu_features))) or any(
+            not isinstance(feature, str) or not feature for feature in self.cpu_features
+        ):
+            raise RecurrenceScheduleSharingError(
+                "process executor CPU features must be sorted and unique"
+            )
+        count = _nonnegative_integer(
+            self.catalog_executor_count, "direct-executor catalog count"
+        )
+        if count > _MISSING_U32:
+            raise RecurrenceScheduleSharingError(
+                "direct-executor catalog count exceeds the u32 wire domain"
+            )
+        if self.executor_ids != tuple(sorted(set(self.executor_ids))):
+            raise RecurrenceScheduleSharingError(
+                "process executor IDs must be sorted and unique"
+            )
+        if len(self.executor_ids) > _MISSING_U32 or any(
+            isinstance(executor_id, bool)
+            or not isinstance(executor_id, int)
+            or executor_id < 0
+            or executor_id >= count
+            for executor_id in self.executor_ids
+        ):
+            raise RecurrenceScheduleSharingError(
+                "process executor ID is outside the complete catalog domain"
+            )
+        if len(self.executor_ids) != len(self.descriptor_payloads) or any(
+            not isinstance(payload, bytes) or len(payload) < 16
+            for payload in self.descriptor_payloads
+        ):
+            raise RecurrenceScheduleSharingError(
+                "process executor descriptors do not match their selected IDs"
+            )
+        for expected_id, payload in zip(
+            self.executor_ids, self.descriptor_payloads, strict=True
+        ):
+            record_size, executor_id = struct.unpack_from("<II", payload)
+            if record_size != len(payload) or executor_id != expected_id:
+                raise RecurrenceScheduleSharingError(
+                    "process executor descriptor header disagrees with its selected ID"
+                )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceProcessRemap:
+    """Authenticated root-schedule to concrete-process binding.
+
+    Dense source, flow, and sector maps are deliberately explicit. Model-wide
+    template/executor/parameter domains use sparse changes over an identity
+    bijection so a binding remains small even for a large prepared catalog.
+    """
+
+    source_slots: tuple[int, ...]
+    source_momentum_signs: tuple[int, ...]
+    source_helicity_signs: tuple[int, ...]
+    source_state_offsets: tuple[int, ...]
+    source_state_indices: tuple[int, ...]
+    public_flow_ids: tuple[int, ...]
+    physical_sector_ids: tuple[int, ...]
+    state_template_count: int
+    source_template_count: int
+    direct_executor_count: int
+    parameter_slot_count: int
+    state_template_changes: tuple[tuple[int, int], ...] = ()
+    source_template_changes: tuple[tuple[int, int], ...] = ()
+    direct_executor_changes: tuple[tuple[int, int], ...] = ()
+    parameter_slot_changes: tuple[tuple[int, int], ...] = ()
+    bijection_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _permutation(self.source_slots, "source-slot remap")
+        _signs(self.source_momentum_signs, len(self.source_slots), "momentum signs")
+        _signs(self.source_helicity_signs, len(self.source_slots), "helicity signs")
+        _ragged_permutations(
+            self.source_state_offsets,
+            self.source_state_indices,
+            len(self.source_slots),
+            "source-state remap",
+        )
+        _permutation(self.public_flow_ids, "public-flow remap")
+        _permutation(self.physical_sector_ids, "physical-sector remap")
+        for count, label in (
+            (self.state_template_count, "state-template count"),
+            (self.source_template_count, "source-template count"),
+            (self.direct_executor_count, "direct-executor count"),
+            (self.parameter_slot_count, "parameter-slot count"),
+        ):
+            _nonnegative_integer(count, label)
+        for changes, count, label in (
+            (
+                self.state_template_changes,
+                self.state_template_count,
+                "state-template remap",
+            ),
+            (
+                self.source_template_changes,
+                self.source_template_count,
+                "source-template remap",
+            ),
+            (
+                self.direct_executor_changes,
+                self.direct_executor_count,
+                "direct-executor remap",
+            ),
+            (
+                self.parameter_slot_changes,
+                self.parameter_slot_count,
+                "parameter-slot remap",
+            ),
+        ):
+            _sparse_permutation(changes, count, label)
+        if self.bijection_digest:
+            _require_sha256(self.bijection_digest, "process-bijection digest")
+
+    @classmethod
+    def identity(
+        cls,
+        logical: RecurrenceBuilderLogicalInputV1,
+        *,
+        direct_executor_count: int,
+        parameter_slot_count: int,
+    ) -> RecurrenceProcessRemap:
+        state_count = _template_count(logical, "current-state")
+        source_count = _template_count(logical, "source")
+        source_state_offsets = [0]
+        source_state_indices: list[int] = []
+        for leg in logical.external_legs:
+            source_state_indices.extend(range(len(leg.source_states)))
+            source_state_offsets.append(len(source_state_indices))
+        result = cls(
+            source_slots=tuple(range(len(logical.external_legs))),
+            source_momentum_signs=(1,) * len(logical.external_legs),
+            source_helicity_signs=(1,) * len(logical.external_legs),
+            source_state_offsets=tuple(source_state_offsets),
+            source_state_indices=tuple(source_state_indices),
+            public_flow_ids=tuple(range(len(logical.public_flows))),
+            physical_sector_ids=tuple(range(_physical_sector_domain_count(logical))),
+            state_template_count=state_count,
+            source_template_count=source_count,
+            direct_executor_count=_nonnegative_integer(
+                direct_executor_count, "direct-executor count"
+            ),
+            parameter_slot_count=_nonnegative_integer(
+                parameter_slot_count, "parameter-slot count"
+            ),
+        )
+        return result.with_digest(
+            _canonical_digest(
+                {
+                    "contract": "pyamplicol-recurrence-process-bijection-v1",
+                    "process": logical.process_id,
+                    "remap": result._digest_payload(),
+                    "relation": "identity",
+                }
+            )
+        )
+
+    def with_digest(self, digest: str) -> RecurrenceProcessRemap:
+        return RecurrenceProcessRemap(
+            source_slots=self.source_slots,
+            source_momentum_signs=self.source_momentum_signs,
+            source_helicity_signs=self.source_helicity_signs,
+            source_state_offsets=self.source_state_offsets,
+            source_state_indices=self.source_state_indices,
+            public_flow_ids=self.public_flow_ids,
+            physical_sector_ids=self.physical_sector_ids,
+            state_template_count=self.state_template_count,
+            source_template_count=self.source_template_count,
+            direct_executor_count=self.direct_executor_count,
+            parameter_slot_count=self.parameter_slot_count,
+            state_template_changes=self.state_template_changes,
+            source_template_changes=self.source_template_changes,
+            direct_executor_changes=self.direct_executor_changes,
+            parameter_slot_changes=self.parameter_slot_changes,
+            bijection_digest=_require_sha256(digest, "process-bijection digest"),
+        )
+
+    def remap_resolved_helicities(
+        self,
+        rows: tuple[tuple[int, ...], ...],
+    ) -> tuple[tuple[int, ...], ...]:
+        result: list[tuple[int, ...]] = []
+        for row in rows:
+            if len(row) != len(self.source_slots):
+                raise RecurrenceScheduleSharingError(
+                    "resolved helicity width disagrees with process binding"
+                )
+            target = [0] * len(row)
+            for root_slot, target_slot in enumerate(self.source_slots):
+                target[target_slot] = (
+                    row[root_slot] * self.source_helicity_signs[root_slot]
+                )
+            result.append(tuple(target))
+        if len(set(result)) != len(result):
+            raise RecurrenceScheduleSharingError(
+                "process binding collapses distinct resolved helicities"
+            )
+        return tuple(result)
+
+    def to_mapping(self) -> dict[str, object]:
+        return {
+            "bijection_digest": self.bijection_digest,
+            "source_slots": list(self.source_slots),
+            "source_momentum_signs": list(self.source_momentum_signs),
+            "source_helicity_signs": list(self.source_helicity_signs),
+            "source_state_offsets": list(self.source_state_offsets),
+            "source_state_indices": list(self.source_state_indices),
+            "public_flow_ids": list(self.public_flow_ids),
+            "physical_sector_ids": list(self.physical_sector_ids),
+            "state_templates": _sparse_mapping(
+                self.state_template_count, self.state_template_changes
+            ),
+            "source_templates": _sparse_mapping(
+                self.source_template_count, self.source_template_changes
+            ),
+            "direct_executors": _sparse_mapping(
+                self.direct_executor_count, self.direct_executor_changes
+            ),
+            "parameter_slots": _sparse_mapping(
+                self.parameter_slot_count, self.parameter_slot_changes
+            ),
+        }
+
+    def _digest_payload(self) -> dict[str, object]:
+        payload = self.to_mapping()
+        payload["bijection_digest"] = None
+        return payload
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceSharedLoweringResult(Generic[_T]):
+    output: _T
+    schedule_digest: str
+    native_schedule_semantic_digest: str
+    remap: RecurrenceProcessRemap
+
+
+@dataclass(slots=True)
+class _PendingLowering(Generic[_T]):
+    logical: RecurrenceBuilderLogicalInputV1
+    direct_executor_count: int
+    parameter_slot_count: int
+    schedule_digest: str
+    sharing_domain_digest: str
+    native_schedule_semantic_digest: str
+    future: Future[_T]
+
+
+class RecurrenceScheduleLoweringCache(Generic[_T]):
+    """Thread-safe single-flight cache keyed before native lowering."""
+
+    def __init__(self) -> None:
+        self._lock = Lock()
+        self._pending: dict[str, Future[_T]] = {}
+        self._processes: list[_PendingLowering[_T]] = []
+
+    def lower_once(self, digest: str, lower: Callable[[], _T]) -> _T:
+        key = _require_sha256(digest, "pre-lowering schedule digest")
+        with self._lock:
+            pending = self._pending.get(key)
+            if pending is None:
+                pending = Future()
+                self._pending[key] = pending
+                owner = True
+            else:
+                owner = False
+        if not owner:
+            return pending.result()
+        try:
+            result = lower()
+        except BaseException as exc:
+            pending.set_exception(exc)
+            try:
+                pending.exception()
+            finally:
+                raise
+        pending.set_result(result)
+        return result
+
+    def lower_process(
+        self,
+        logical: RecurrenceBuilderLogicalInputV1,
+        *,
+        schedule_digest: str,
+        sharing_domain_digest: str,
+        native_schedule_semantic_digest: str,
+        direct_executor_count: int,
+        parameter_slot_count: int,
+        lower: Callable[[], _T],
+    ) -> RecurrenceSharedLoweringResult[_T]:
+        """Lower once across exact process-isomorphic recurrence schedules."""
+
+        digest = _require_sha256(schedule_digest, "pre-lowering schedule digest")
+        sharing_domain = _require_sha256(
+            sharing_domain_digest,
+            "pre-lowering schedule-sharing domain digest",
+        )
+        native_semantics = _require_sha256(
+            native_schedule_semantic_digest,
+            "native schedule semantic digest",
+        )
+        executor_count = _nonnegative_integer(
+            direct_executor_count, "direct-executor count"
+        )
+        parameter_count = _nonnegative_integer(
+            parameter_slot_count, "parameter-slot count"
+        )
+        with self._lock:
+            owner: _PendingLowering[_T] | None = None
+            remap: RecurrenceProcessRemap | None = None
+            for candidate in self._processes:
+                if (
+                    candidate.sharing_domain_digest != sharing_domain
+                    or candidate.direct_executor_count != executor_count
+                    or candidate.parameter_slot_count != parameter_count
+                ):
+                    continue
+                remap = exact_recurrence_process_bijection(
+                    candidate.logical,
+                    logical,
+                    direct_executor_count=executor_count,
+                    parameter_slot_count=parameter_count,
+                )
+                if remap is not None:
+                    owner = candidate
+                    break
+            if owner is None:
+                future: Future[_T] = Future()
+                owner = _PendingLowering(
+                    logical=logical,
+                    direct_executor_count=executor_count,
+                    parameter_slot_count=parameter_count,
+                    schedule_digest=digest,
+                    sharing_domain_digest=sharing_domain,
+                    native_schedule_semantic_digest=native_semantics,
+                    future=future,
+                )
+                self._processes.append(owner)
+                remap = RecurrenceProcessRemap.identity(
+                    logical,
+                    direct_executor_count=executor_count,
+                    parameter_slot_count=parameter_count,
+                )
+                owns_lowering = True
+            else:
+                owns_lowering = False
+        assert remap is not None
+        if owns_lowering:
+            try:
+                output = lower()
+            except BaseException as exc:
+                owner.future.set_exception(exc)
+                try:
+                    owner.future.exception()
+                finally:
+                    raise
+            owner.future.set_result(output)
+        else:
+            output = owner.future.result()
+        return RecurrenceSharedLoweringResult(
+            output=output,
+            schedule_digest=owner.schedule_digest,
+            native_schedule_semantic_digest=(owner.native_schedule_semantic_digest),
+            remap=remap,
+        )
+
+
+class RecurrenceScheduleProcess(Protocol):
+    process_id: str
+    recurrence_schedule_path: Path
+    recurrence_schedule_digest: str
+    recurrence_native_schedule_semantic_digest: str
+    recurrence_schedule_size_bytes: int
+    recurrence_schedule_sha256: str
+    recurrence_schedule_member_count: int
+    recurrence_schedule_unpacked_size_bytes: int
+    recurrence_schedule_index_sha256: str
+    builder_input_sha256: str
+    process_digest: str
+    process_support_mask: int
+    recurrence_process_remap: RecurrenceProcessRemap
+    recurrence_process_executor_pack: RecurrenceProcessExecutorPack
+
+
+def _recurrence_schedule_identity_payload(
+    logical: RecurrenceBuilderLogicalInputV1,
+    *,
+    prepared_kernel_pack_digest: str,
+    direct_template_catalog_digest: str,
+    point_tile_size: int,
+    workspace_mib: int,
+) -> dict[str, object]:
+    domain = _recurrence_schedule_domain_payload(
+        prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+        direct_template_catalog_digest=direct_template_catalog_digest,
+        point_tile_size=point_tile_size,
+        workspace_mib=workspace_mib,
+    )
+    return {
+        "contract": "pyamplicol-recurrence-prelower-schedule-identity-v1",
+        "logical": _schedule_plain(logical),
+        **domain,
+    }
+
+
+def _recurrence_schedule_domain_payload(
+    *,
+    prepared_kernel_pack_digest: str,
+    direct_template_catalog_digest: str,
+    point_tile_size: int,
+    workspace_mib: int,
+) -> dict[str, object]:
+    return {
+        "prepared_kernel_pack_digest": _require_sha256(
+            prepared_kernel_pack_digest, "prepared-kernel pack digest"
+        ),
+        "direct_template_catalog_digest": _require_sha256(
+            direct_template_catalog_digest, "direct-template catalog digest"
+        ),
+        "point_tile_size": _positive_integer(point_tile_size, "point tile size"),
+        "workspace_mib": _positive_integer(workspace_mib, "workspace MiB"),
+    }
+
+
+def _recurrence_schedule_semantic_digests(
+    logical: RecurrenceBuilderLogicalInputV1,
+    *,
+    prepared_kernel_pack_digest: str,
+    direct_template_catalog_digest: str,
+    point_tile_size: int,
+    workspace_mib: int,
+    relation_discovery: Mapping[str, object] | None = None,
+) -> tuple[str, str, str]:
+    """Return native, request, and sharing-domain schedule identities."""
+
+    domain = _recurrence_schedule_domain_payload(
+        prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+        direct_template_catalog_digest=direct_template_catalog_digest,
+        point_tile_size=point_tile_size,
+        workspace_mib=workspace_mib,
+    )
+    payload = {
+        "contract": "pyamplicol-recurrence-prelower-schedule-identity-v1",
+        "logical": _schedule_plain(logical),
+        **domain,
+    }
+    native_digest = _canonical_digest(payload)
+    request_payload = dict(payload)
+    sharing_domain_payload = {
+        "contract": "pyamplicol-recurrence-schedule-sharing-domain-v1",
+        **domain,
+    }
+    if relation_discovery is not None:
+        plain_relation = _schedule_plain(relation_discovery)
+        request_payload["relation_discovery"] = plain_relation
+        sharing_domain_payload["relation_discovery"] = plain_relation
+    return (
+        native_digest,
+        _canonical_digest(request_payload),
+        _canonical_digest(sharing_domain_payload),
+    )
+
+
+def recurrence_helicity_selector_schedule_digest(
+    base_schedule_digest: str,
+    helicity_dispatch_sha256: str,
+) -> str:
+    """Bind one Direct plan and its exact-helicity dispatch into one root ID."""
+
+    return _canonical_digest(
+        {
+            "contract": "pyamplicol-recurrence-helicity-selector-schedule-v1",
+            "base_schedule_digest": _require_sha256(
+                base_schedule_digest,
+                "helicity-selector base schedule digest",
+            ),
+            "helicity_dispatch": {
+                "abi": "pyamplicol-recurrence-helicity-dispatch-v1",
+                "sha256": _require_sha256(
+                    helicity_dispatch_sha256,
+                    "helicity-selector dispatch SHA-256",
+                ),
+            },
+        }
+    )
+
+
+def recurrence_native_schedule_semantic_digest(
+    logical: RecurrenceBuilderLogicalInputV1,
+    *,
+    prepared_kernel_pack_digest: str,
+    direct_template_catalog_digest: str,
+    point_tile_size: int,
+    workspace_mib: int,
+) -> str:
+    """Return the relation-independent semantic identity embedded by native lowering.
+
+    Only concrete process ownership is normalized. All model, crossing,
+    selector, color, proof, parameter, and runtime-option semantics remain in
+    the digest. Relation-discovery policy is deliberately excluded: it governs
+    the lowering request, while certified relations themselves are authenticated
+    separately and a request that applies none must retain the source schedule's
+    byte identity.
+    """
+
+    return _canonical_digest(
+        _recurrence_schedule_identity_payload(
+            logical,
+            prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+            direct_template_catalog_digest=direct_template_catalog_digest,
+            point_tile_size=point_tile_size,
+            workspace_mib=workspace_mib,
+        )
+    )
+
+
+def recurrence_schedule_semantic_digest(
+    logical: RecurrenceBuilderLogicalInputV1,
+    *,
+    prepared_kernel_pack_digest: str,
+    direct_template_catalog_digest: str,
+    point_tile_size: int,
+    workspace_mib: int,
+    relation_discovery: Mapping[str, object] | None = None,
+) -> str:
+    """Return the policy-bearing request/cache identity for schedule lowering.
+
+    This identity isolates discovery policies in temporary paths, lowering
+    cache ownership, and artifact grouping. Native serialization receives
+    :func:`recurrence_native_schedule_semantic_digest` instead, so policy alone
+    cannot perturb a schedule when no certified relation is applied.
+    """
+
+    payload = _recurrence_schedule_identity_payload(
+        logical,
+        prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+        direct_template_catalog_digest=direct_template_catalog_digest,
+        point_tile_size=point_tile_size,
+        workspace_mib=workspace_mib,
+    )
+    if relation_discovery is not None:
+        payload["relation_discovery"] = _schedule_plain(relation_discovery)
+    return _canonical_digest(payload)
+
+
+def build_recurrence_process_executor_pack(
+    *,
+    direct_catalog: object,
+    kernel_pack: object,
+    required_executor_ids: Sequence[int],
+    runtime_layout_digest: str,
+) -> RecurrenceProcessExecutorPack:
+    """Project one validated model catalog to its exact fixed-plan executor set."""
+
+    direct_mapping = _object_mapping(direct_catalog, "direct-template catalog")
+    pack_mapping = _object_mapping(kernel_pack, "prepared-kernel pack")
+    raw_templates = _object_sequence(
+        direct_mapping.get("templates"), "direct-template catalog templates"
+    )
+    catalog_count = len(raw_templates)
+    templates: dict[int, Mapping[str, object]] = {}
+    for expected_id, raw_template in enumerate(raw_templates):
+        template = _require_mapping(raw_template, "direct-template descriptor")
+        executor_id = _wire_u32(
+            template.get("direct_executor_id"), "direct-template executor ID"
+        )
+        if executor_id != expected_id or executor_id in templates:
+            raise RecurrenceScheduleSharingError(
+                "direct-template executor IDs must be dense, ordered, and unique"
+            )
+        templates[executor_id] = template
+
+    selected_ids = tuple(
+        _wire_u32(value, "required direct-executor ID")
+        for value in required_executor_ids
+    )
+    if selected_ids != tuple(sorted(set(selected_ids))):
+        raise RecurrenceScheduleSharingError(
+            "required direct-executor IDs must be sorted and unique"
+        )
+    if any(executor_id not in templates for executor_id in selected_ids):
+        raise RecurrenceScheduleSharingError(
+            "required direct-executor ID is absent from its complete catalog"
+        )
+
+    raw_kernels = _object_sequence(
+        pack_mapping.get("kernels"), "prepared-kernel pack kernels"
+    )
+    kernels: dict[int, Mapping[str, object]] = {}
+    for raw_kernel in raw_kernels:
+        kernel = _require_mapping(raw_kernel, "prepared-kernel descriptor")
+        kernel_id = _wire_u32(kernel.get("kernel_id"), "prepared-kernel ID")
+        if kernel_id in kernels:
+            raise RecurrenceScheduleSharingError(
+                f"prepared-kernel pack repeats kernel {kernel_id}"
+            )
+        kernels[kernel_id] = kernel
+
+    backend = _wire_text(direct_mapping.get("backend"), "direct backend")
+    if backend != pack_mapping.get("backend") or backend not in _DIRECT_BACKEND:
+        raise RecurrenceScheduleSharingError(
+            "direct-template and prepared-kernel backends disagree"
+        )
+    target = _require_mapping(pack_mapping.get("target"), "prepared-kernel target")
+    target_triple = _wire_text(target.get("target_triple"), "target triple")
+    if target_triple != direct_mapping.get("target_triple"):
+        raise RecurrenceScheduleSharingError(
+            "direct-template and prepared-kernel targets disagree"
+        )
+    portable = target.get("portable")
+    if type(portable) is not bool or portable != direct_mapping.get("portable"):
+        raise RecurrenceScheduleSharingError(
+            "direct-template and prepared-kernel portability disagree"
+        )
+    if target.get("word_bits") != 64 or target.get("endianness") != "little":
+        raise RecurrenceScheduleSharingError(
+            "process executor packs require a 64-bit little-endian target"
+        )
+    cpu_features = tuple(
+        _wire_text(value, "target CPU feature")
+        for value in _object_sequence(target.get("cpu_features"), "target CPU features")
+    )
+    if cpu_features != tuple(sorted(set(cpu_features))):
+        raise RecurrenceScheduleSharingError(
+            "target CPU features must be sorted and unique"
+        )
+
+    descriptors = tuple(
+        _encode_process_executor_descriptor(
+            templates[executor_id],
+            backend=backend,
+            kernels=kernels,
+        )
+        for executor_id in selected_ids
+    )
+    return RecurrenceProcessExecutorPack(
+        compiled_model_digest=_wire_sha256(
+            direct_mapping.get("compiled_model_digest"), "compiled-model digest"
+        ),
+        recurrence_template_catalog_digest=_wire_sha256(
+            direct_mapping.get("recurrence_template_catalog_digest"),
+            "recurrence-template catalog digest",
+        ),
+        prepared_kernel_pack_digest=_wire_sha256(
+            direct_mapping.get("prepared_kernel_pack_digest"),
+            "prepared-kernel pack digest",
+        ),
+        direct_template_catalog_digest=_wire_sha256(
+            direct_mapping.get("catalog_digest"), "direct-template catalog digest"
+        ),
+        runtime_layout_digest=_wire_sha256(
+            runtime_layout_digest, "runtime-layout digest"
+        ),
+        backend=backend,
+        target_triple=target_triple,
+        portable=portable,
+        cpu_features=cpu_features,
+        catalog_executor_count=catalog_count,
+        executor_ids=selected_ids,
+        descriptor_payloads=descriptors,
+    )
+
+
+def _encode_process_executor_descriptor(
+    template: Mapping[str, object],
+    *,
+    backend: str,
+    kernels: Mapping[int, Mapping[str, object]],
+) -> bytes:
+    executor_id = _wire_u32(template.get("direct_executor_id"), "direct executor ID")
+    role = _wire_text(template.get("role"), "direct executor role")
+    role_tag = _DIRECT_ROLE.get(role)
+    if role_tag is None:
+        raise RecurrenceScheduleSharingError(
+            f"unsupported direct executor role {role!r}"
+        )
+    destination_count = _wire_u32(
+        template.get("destination_component_count"),
+        "direct destination component count",
+        positive=True,
+    )
+    binding = _require_mapping(
+        template.get("payload_binding"), "direct executor payload binding"
+    )
+    binding_kind = _wire_text(binding.get("kind"), "direct binding kind")
+    exact_factor_slots = _object_sequence(
+        binding.get("exact_factor_scalar_slots"), "exact-factor scalar slots"
+    )
+    flags = _DIRECT_FLAG_USES_EXACT_FACTOR if len(exact_factor_slots) != 0 else 0
+    if role == "source":
+        record_kind = _DIRECT_BINDING_SOURCE
+        body = b""
+    elif binding_kind == "rusticol-intrinsic":
+        record_kind = _DIRECT_BINDING_INTRINSIC
+        body = _encode_intrinsic_binding(binding, role=role)
+    elif binding_kind == "prepared-direct-call" and backend == "jit":
+        record_kind = _DIRECT_BINDING_JIT
+        body = _encode_jit_binding(binding, template=template, kernels=kernels)
+    elif binding_kind == "prepared-direct-call" and backend in {"cpp", "asm"}:
+        record_kind = _DIRECT_BINDING_NATIVE
+        body = _encode_native_binding(binding, template=template, kernels=kernels)
+    else:
+        raise RecurrenceScheduleSharingError(
+            f"unsupported executable direct binding {binding_kind!r} for {backend!r}"
+        )
+    size = 16 + len(body)
+    if size > _MISSING_U32:
+        raise RecurrenceScheduleSharingError(
+            "process direct-executor descriptor exceeds the u32 wire domain"
+        )
+    return (
+        struct.pack(
+            "<IIBBHI",
+            size,
+            executor_id,
+            role_tag,
+            record_kind,
+            flags,
+            destination_count,
+        )
+        + body
+    )
+
+
+def _encode_intrinsic_binding(binding: Mapping[str, object], *, role: str) -> bytes:
+    runtime_template = _wire_text(
+        binding.get("runtime_template"), "intrinsic runtime template"
+    )
+    raw_projections = _object_sequence(
+        binding.get("scalar_projections"), "intrinsic scalar projections"
+    )
+    if role == "contribution":
+        if len(raw_projections) != 1:
+            raise RecurrenceScheduleSharingError(
+                "contribution intrinsic requires exactly one scale projection"
+            )
+        projection = _require_mapping(
+            raw_projections[0], "contribution intrinsic scale"
+        )
+        if projection.get("kind") != "intrinsic-scale-v1":
+            raise RecurrenceScheduleSharingError(
+                "contribution intrinsic has an unsupported scale projection"
+            )
+        real_bits = _wire_u64(
+            projection.get("constant_real_bits"), "intrinsic real bits"
+        )
+        imag_bits = _wire_u64(
+            projection.get("constant_imag_bits"), "intrinsic imaginary bits"
+        )
+        raw_parameter = projection.get("parameter_index")
+        parameter = (
+            _MISSING_U32
+            if raw_parameter is None
+            else _wire_u32(raw_parameter, "intrinsic parameter index")
+        )
+        has_scale = 1
+    else:
+        if raw_projections:
+            raise RecurrenceScheduleSharingError(
+                "non-contribution intrinsic cannot carry scalar projections"
+            )
+        real_bits = 0
+        imag_bits = 0
+        parameter = _MISSING_U32
+        has_scale = 0
+    return struct.pack(
+        "<B3xQQI", has_scale, real_bits, imag_bits, parameter
+    ) + _encode_wire_text(runtime_template, "intrinsic runtime template")
+
+
+def _encode_jit_binding(
+    binding: Mapping[str, object],
+    *,
+    template: Mapping[str, object],
+    kernels: Mapping[int, Mapping[str, object]],
+) -> bytes:
+    kernel_id = _wire_u32(binding.get("prepared_kernel_id"), "prepared JIT kernel ID")
+    kernel = kernels.get(kernel_id)
+    if kernel is None:
+        raise RecurrenceScheduleSharingError(
+            f"prepared JIT kernel {kernel_id} is absent"
+        )
+    evaluator = _require_mapping(
+        kernel.get("f64_evaluator_manifest"), "prepared JIT evaluator"
+    )
+    plane = _require_mapping(
+        evaluator.get("plane_application"), "prepared JIT plane application"
+    )
+    compression = plane.get("compression")
+    if type(compression) is not bool:
+        raise RecurrenceScheduleSharingError(
+            "prepared JIT plane compression must be boolean"
+        )
+    optimization_level = _wire_u32(
+        template.get("optimization_level"), "prepared JIT optimization level"
+    )
+    source_path = _wire_text(
+        binding.get("source_application_path"), "prepared JIT source path"
+    )
+    source_sha256 = _wire_sha256(
+        binding.get("source_application_sha256"), "prepared JIT source digest"
+    )
+    source_abi = _wire_text(
+        binding.get("source_application_abi"), "prepared JIT source ABI"
+    )
+    parameter_bindings = _object_sequence(
+        binding.get("parameter_bindings"), "prepared JIT parameter bindings"
+    )
+    plane_projections = _object_sequence(
+        binding.get("input_plane_projections"), "prepared JIT plane projections"
+    )
+    scalar_projections = _object_sequence(
+        binding.get("scalar_projections"), "prepared JIT scalar projections"
+    )
+    output_aliases = tuple(
+        _wire_u32(value, "prepared JIT output alias")
+        for value in _object_sequence(
+            binding.get("output_alias_inputs"), "prepared JIT output aliases"
+        )
+    )
+    counts = tuple(
+        _wire_u32(len(values), f"prepared JIT {label} count")
+        for values, label in (
+            (parameter_bindings, "parameter-binding"),
+            (plane_projections, "plane-projection"),
+            (scalar_projections, "scalar-projection"),
+            (output_aliases, "output-alias"),
+        )
+    )
+    return b"".join(
+        (
+            struct.pack(
+                "<IIB3x",
+                kernel_id,
+                optimization_level,
+                int(compression),
+            ),
+            bytes.fromhex(source_sha256),
+            _encode_wire_text(source_path, "prepared JIT source path"),
+            _encode_wire_text(source_abi, "prepared JIT source ABI"),
+            struct.pack("<4I", *counts),
+            *(_encode_parameter_binding(value) for value in parameter_bindings),
+            *(_encode_plane_projection(value) for value in plane_projections),
+            *(_encode_scalar_projection(value) for value in scalar_projections),
+            struct.pack(f"<{len(output_aliases)}I", *output_aliases),
+        )
+    )
+
+
+def _encode_native_binding(
+    binding: Mapping[str, object],
+    *,
+    template: Mapping[str, object],
+    kernels: Mapping[int, Mapping[str, object]],
+) -> bytes:
+    kernel_id = _wire_u32(
+        binding.get("prepared_kernel_id"), "prepared native kernel ID"
+    )
+    kernel = kernels.get(kernel_id)
+    if kernel is None:
+        raise RecurrenceScheduleSharingError(
+            f"prepared native kernel {kernel_id} is absent"
+        )
+    source_path = _wire_text(
+        binding.get("source_application_path"), "prepared native library path"
+    )
+    entry_point = _wire_text(
+        binding.get("native_entry_point"), "prepared native entry point"
+    )
+    coupling = _prepared_native_coupling(binding, kernel)
+    if coupling is None:
+        has_coupling = 0
+        coupling_real_bits = 0
+        coupling_imag_bits = 0
+    else:
+        has_coupling = 1
+        coupling_real_bits = _f64_bits(coupling[0])
+        coupling_imag_bits = _f64_bits(coupling[1])
+    return b"".join(
+        (
+            struct.pack(
+                "<IB3xQQ",
+                kernel_id,
+                has_coupling,
+                coupling_real_bits,
+                coupling_imag_bits,
+            ),
+            _encode_wire_text(source_path, "prepared native library path"),
+            _encode_wire_text(entry_point, "prepared native entry point"),
+        )
+    )
+
+
+def _prepared_native_coupling(
+    binding: Mapping[str, object],
+    kernel: Mapping[str, object],
+) -> tuple[float, float] | None:
+    parameter_bindings = _object_sequence(
+        binding.get("parameter_bindings"), "native parameter bindings"
+    )
+    input_contracts = _object_sequence(
+        kernel.get("input_contracts"), "native kernel input contracts"
+    )
+    if len(parameter_bindings) != 2 * len(input_contracts):
+        raise RecurrenceScheduleSharingError(
+            "native direct parameter bindings do not match the kernel inputs"
+        )
+    scalars = _object_sequence(
+        binding.get("scalar_projections"), "native scalar projections"
+    )
+    coupling_real: float | None = None
+    coupling_imag: float | None = None
+    for input_index, raw_contract in enumerate(input_contracts):
+        contract = _require_mapping(raw_contract, "native kernel input contract")
+        role = contract.get("role")
+        if role not in {"coupling-real", "coupling-imag"}:
+            continue
+        value = _native_literal_binding(
+            parameter_bindings,
+            scalars,
+            2 * input_index,
+        )
+        imaginary = _native_literal_binding(
+            parameter_bindings,
+            scalars,
+            2 * input_index + 1,
+        )
+        if imaginary != 0.0:
+            raise RecurrenceScheduleSharingError(
+                "native direct coupling scalar lane has a nonzero imaginary part"
+            )
+        if role == "coupling-real":
+            if coupling_real is not None:
+                raise RecurrenceScheduleSharingError(
+                    "native direct kernel repeats its real coupling input"
+                )
+            coupling_real = value
+        else:
+            if coupling_imag is not None:
+                raise RecurrenceScheduleSharingError(
+                    "native direct kernel repeats its imaginary coupling input"
+                )
+            coupling_imag = value
+    if coupling_real is None and coupling_imag is None:
+        return None
+    return (
+        0.0 if coupling_real is None else coupling_real,
+        0.0 if coupling_imag is None else coupling_imag,
+    )
+
+
+def _native_literal_binding(
+    parameter_bindings: Sequence[object],
+    scalars: Sequence[object],
+    parameter_index: int,
+) -> float:
+    binding = _require_mapping(
+        parameter_bindings[parameter_index], "native scalar parameter binding"
+    )
+    if binding.get("kind") != "scalar":
+        raise RecurrenceScheduleSharingError(
+            "native direct coupling is not bound to a scalar"
+        )
+    scalar_index = _wire_u32(binding.get("index"), "native scalar index")
+    if scalar_index >= len(scalars):
+        raise RecurrenceScheduleSharingError(
+            "native direct coupling scalar index is out of bounds"
+        )
+    scalar = _require_mapping(scalars[scalar_index], "native literal scalar")
+    raw_value = scalar.get("value")
+    if (
+        scalar.get("kind") != "literal"
+        or isinstance(raw_value, bool)
+        or not isinstance(raw_value, int | float)
+    ):
+        raise RecurrenceScheduleSharingError(
+            "native direct coupling is not an immutable literal"
+        )
+    value = float(raw_value)
+    if not math.isfinite(value):
+        raise RecurrenceScheduleSharingError(
+            "native direct coupling literal is not finite"
+        )
+    return value
+
+
+def _encode_parameter_binding(value: object) -> bytes:
+    binding = _require_mapping(value, "JIT parameter binding")
+    kind = binding.get("kind")
+    tag = 0 if kind == "plane" else 1 if kind == "scalar" else None
+    if tag is None:
+        raise RecurrenceScheduleSharingError(
+            f"unsupported JIT parameter binding {kind!r}"
+        )
+    index = _wire_u32(binding.get("index"), "JIT parameter-binding index")
+    return struct.pack("<B3xI", tag, index)
+
+
+def _encode_plane_projection(value: object) -> bytes:
+    projection = _require_mapping(value, "JIT plane projection")
+    kind = projection.get("kind")
+    if kind == "parent-current":
+        tag = 0
+        operand = _wire_u8(projection.get("parent"), "JIT parent index")
+        component = _wire_u16(projection.get("component"), "JIT parent component")
+        imaginary = _wire_bool(projection.get("imaginary"), "JIT imaginary flag")
+    elif kind == "momentum":
+        tag = 1
+        operand = _wire_u8(projection.get("operand"), "JIT momentum operand")
+        component = _wire_u16(
+            projection.get("lorentz_component"), "JIT Lorentz component"
+        )
+        imaginary = False
+    elif kind in {"destination-current", "destination-amplitude"}:
+        tag = 2 if kind == "destination-current" else 3
+        operand = 0
+        component = _wire_u16(projection.get("component"), "JIT destination component")
+        imaginary = _wire_bool(projection.get("imaginary"), "JIT imaginary flag")
+    else:
+        raise RecurrenceScheduleSharingError(
+            f"unsupported JIT plane projection {kind!r}"
+        )
+    return struct.pack("<BBHB3x", tag, operand, component, int(imaginary))
+
+
+def _encode_scalar_projection(value: object) -> bytes:
+    projection = _require_mapping(value, "JIT scalar projection")
+    kind = projection.get("kind")
+    if kind == "exact-factor":
+        tag = 0
+        imaginary = _wire_bool(projection.get("imaginary"), "JIT imaginary flag")
+        index = 0
+        bits = 0
+    elif kind == "parameter":
+        tag = 1
+        imaginary = _wire_bool(projection.get("imaginary"), "JIT imaginary flag")
+        index = _wire_u32(projection.get("index"), "JIT parameter index")
+        bits = 0
+    elif kind == "literal":
+        tag = 2
+        imaginary = False
+        index = 0
+        raw_value = projection.get("value")
+        if isinstance(raw_value, bool) or not isinstance(raw_value, int | float):
+            raise RecurrenceScheduleSharingError("JIT literal must be numeric")
+        value = float(raw_value)
+        if not math.isfinite(value):
+            raise RecurrenceScheduleSharingError("JIT literal must be finite")
+        bits = _f64_bits(value)
+    else:
+        raise RecurrenceScheduleSharingError(
+            f"unsupported JIT scalar projection {kind!r}"
+        )
+    return struct.pack("<BBHIQ", tag, int(imaginary), 0, index, bits)
+
+
+def _object_mapping(value: object, context: str) -> Mapping[str, object]:
+    operation = getattr(value, "to_dict", None)
+    if not callable(operation):
+        raise RecurrenceScheduleSharingError(f"{context} is not a typed model object")
+    return _require_mapping(operation(), context)
+
+
+def _require_mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise RecurrenceScheduleSharingError(f"{context} must be a mapping")
+    return value
+
+
+def _object_sequence(value: object, context: str) -> tuple[object, ...]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise RecurrenceScheduleSharingError(f"{context} must be a sequence")
+    return tuple(value)
+
+
+def _wire_text(value: object, context: str) -> str:
+    return _nonempty_text(value, context)
+
+
+def _wire_sha256(value: object, context: str) -> str:
+    return _require_sha256(value, context)
+
+
+def _wire_bool(value: object, context: str) -> bool:
+    if type(value) is not bool:
+        raise RecurrenceScheduleSharingError(f"{context} must be boolean")
+    return value
+
+
+def _wire_integer(
+    value: object,
+    context: str,
+    maximum: int,
+    *,
+    positive: bool = False,
+) -> int:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, int)
+        or value < int(positive)
+        or value > maximum
+    ):
+        qualifier = "positive " if positive else ""
+        raise RecurrenceScheduleSharingError(
+            f"{context} must be a {qualifier}integer no larger than {maximum}"
+        )
+    return value
+
+
+def _wire_u8(value: object, context: str) -> int:
+    return _wire_integer(value, context, (1 << 8) - 1)
+
+
+def _wire_u16(value: object, context: str) -> int:
+    return _wire_integer(value, context, (1 << 16) - 1)
+
+
+def _wire_u32(value: object, context: str, *, positive: bool = False) -> int:
+    return _wire_integer(value, context, _MISSING_U32, positive=positive)
+
+
+def _wire_u64(value: object, context: str) -> int:
+    return _wire_integer(value, context, (1 << 64) - 1)
+
+
+def _f64_bits(value: float) -> int:
+    return struct.unpack("<Q", struct.pack("<d", value))[0]
+
+
+def _encode_wire_text(value: str, context: str) -> bytes:
+    encoded = value.encode("utf-8")
+    if not encoded or len(encoded) > _MISSING_U32:
+        raise RecurrenceScheduleSharingError(
+            f"{context} has an invalid UTF-8 wire length"
+        )
+    return struct.pack("<I", len(encoded)) + encoded
+
+
+def exact_recurrence_process_bijection(
+    root: RecurrenceBuilderLogicalInputV1,
+    target: RecurrenceBuilderLogicalInputV1,
+    *,
+    direct_executor_count: int,
+    parameter_slot_count: int,
+) -> RecurrenceProcessRemap | None:
+    """Return an exact root-to-target schedule binding or fail closed.
+
+    V1 sharing is intentionally limited to complete topology-replay schedules.
+    The relation is an all-outgoing external-state isomorphism, not a particle
+    label erasure: every source state, color forest, replay selector, parameter
+    projection, and fermion-pairing row must map bijectively.
+    """
+
+    if (
+        root.layout != "topology-replay"
+        or target.layout != "topology-replay"
+        or len(root.external_legs) != len(target.external_legs)
+        or root.coupling_limits != target.coupling_limits
+        or root.parameter_projection != target.parameter_projection
+        or root.semantic_template_references != target.semantic_template_references
+        or root.selected_public_flow_ids is not None
+        or target.selected_public_flow_ids is not None
+        or root.selected_source_coverage is not None
+        or target.selected_source_coverage is not None
+        or not _fixed_semantic_digests_match(root, target)
+    ):
+        return None
+
+    candidates = _source_slot_bijections(root.external_legs, target.external_legs)
+    for source_slots in candidates:
+        source_relation = _external_source_relation(
+            root.external_legs,
+            target.external_legs,
+            source_slots,
+        )
+        if source_relation is None:
+            continue
+        (
+            momentum_signs,
+            helicity_signs,
+            source_state_offsets,
+            source_state_indices,
+            source_template_changes,
+        ) = source_relation
+        sector_ids = _sector_bijection(
+            root.physical_sectors,
+            target.physical_sectors,
+            source_slots,
+        )
+        if sector_ids is None:
+            continue
+        flow_ids = _flow_bijection(
+            root.public_flows,
+            target.public_flows,
+            source_slots,
+            sector_ids,
+        )
+        if flow_ids is None:
+            continue
+        # Direct-Arena proof metadata still owns physical sector IDs. Until
+        # that metadata has an explicit remap ABI, share only schedules whose
+        # physical/public sector numbering is already identical.
+        if sector_ids != tuple(range(len(sector_ids))) or flow_ids != tuple(
+            range(len(flow_ids))
+        ):
+            continue
+        if not _replay_contracts_match(
+            root,
+            target,
+            source_slots=source_slots,
+            sector_ids=sector_ids,
+        ):
+            continue
+        if not _fermion_pairing_contracts_match(
+            root.fermion_pairing_catalog,
+            target.fermion_pairing_catalog,
+            source_slots,
+        ):
+            continue
+
+        result = RecurrenceProcessRemap(
+            source_slots=source_slots,
+            source_momentum_signs=momentum_signs,
+            source_helicity_signs=helicity_signs,
+            source_state_offsets=source_state_offsets,
+            source_state_indices=source_state_indices,
+            public_flow_ids=flow_ids,
+            physical_sector_ids=tuple(range(_physical_sector_domain_count(root))),
+            state_template_count=_template_count(root, "current-state"),
+            source_template_count=_template_count(root, "source"),
+            direct_executor_count=_nonnegative_integer(
+                direct_executor_count, "direct-executor count"
+            ),
+            parameter_slot_count=_nonnegative_integer(
+                parameter_slot_count, "parameter-slot count"
+            ),
+            source_template_changes=source_template_changes,
+        )
+        relation_digest = _canonical_digest(
+            {
+                "contract": "pyamplicol-recurrence-process-bijection-v1",
+                "root_process": root.process_id,
+                "target_process": target.process_id,
+                "root_variable_semantics": _variable_semantic_digests(root),
+                "target_variable_semantics": _variable_semantic_digests(target),
+                "root_pairing": _pairing_proof_digests(root.fermion_pairing_catalog),
+                "target_pairing": _pairing_proof_digests(
+                    target.fermion_pairing_catalog
+                ),
+                "root_sector_proofs": [
+                    [sector.closure_proof_algorithm, sector.closure_proof_digest]
+                    for sector in root.physical_sectors
+                ],
+                "target_sector_proofs": [
+                    [sector.closure_proof_algorithm, sector.closure_proof_digest]
+                    for sector in target.physical_sectors
+                ],
+                "root_replay_proofs": [
+                    [partition.proof_algorithm, partition.proof_digest]
+                    for partition in root.replay_partitions
+                ],
+                "target_replay_proofs": [
+                    [partition.proof_algorithm, partition.proof_digest]
+                    for partition in target.replay_partitions
+                ],
+                "remap": result._digest_payload(),
+            }
+        )
+        return result.with_digest(relation_digest)
+    return None
+
+
+def _fixed_semantic_digests_match(
+    root: RecurrenceBuilderLogicalInputV1,
+    target: RecurrenceBuilderLogicalInputV1,
+) -> bool:
+    root_rows = {row.role: row.digest for row in root.semantic_digests}
+    target_rows = {row.role: row.digest for row in target.semantic_digests}
+    return set(root_rows) == set(target_rows) and {
+        role: digest
+        for role, digest in root_rows.items()
+        if role not in _PROCESS_VARIABLE_SEMANTIC_ROLES
+    } == {
+        role: digest
+        for role, digest in target_rows.items()
+        if role not in _PROCESS_VARIABLE_SEMANTIC_ROLES
+    }
+
+
+def _variable_semantic_digests(
+    logical: RecurrenceBuilderLogicalInputV1,
+) -> dict[str, str]:
+    return {
+        row.role: row.digest
+        for row in logical.semantic_digests
+        if row.role in _PROCESS_VARIABLE_SEMANTIC_ROLES
+    }
+
+
+def _source_slot_bijections(
+    root: tuple[RecurrenceExternalLegV1, ...],
+    target: tuple[RecurrenceExternalLegV1, ...],
+) -> tuple[tuple[int, ...], ...]:
+    root_groups: dict[tuple[object, ...], list[int]] = {}
+    target_groups: dict[tuple[object, ...], list[int]] = {}
+    for leg in root:
+        root_groups.setdefault(_external_leg_orbit_key(leg), []).append(leg.source_slot)
+    for leg in target:
+        target_groups.setdefault(_external_leg_orbit_key(leg), []).append(
+            leg.source_slot
+        )
+    if set(root_groups) != set(target_groups):
+        return ()
+    groups: list[tuple[tuple[int, ...], tuple[tuple[int, ...], ...]]] = []
+    count = 1
+    for key in sorted(root_groups, key=repr):
+        left = tuple(root_groups[key])
+        right = tuple(target_groups[key])
+        if len(left) != len(right):
+            return ()
+        permutations = tuple(itertools.permutations(right))
+        count *= len(permutations)
+        if count > _MAX_SOURCE_BIJECTIONS:
+            return ()
+        groups.append((left, permutations))
+    result: list[tuple[int, ...]] = []
+    for selection in itertools.product(*(rows[1] for rows in groups)):
+        mapping = [0] * len(root)
+        for (root_slots, _), target_slots in zip(groups, selection, strict=True):
+            for root_slot, target_slot in zip(root_slots, target_slots, strict=True):
+                mapping[root_slot] = target_slot
+        result.append(tuple(mapping))
+    return tuple(result)
+
+
+def _external_leg_orbit_key(leg: RecurrenceExternalLegV1) -> tuple[object, ...]:
+    return (
+        leg.outgoing_pdg,
+        leg.is_fermionic,
+        tuple(
+            sorted(
+                (
+                    state.current_state_template_id,
+                    state.chirality,
+                    state.spin_state,
+                    state.crossing_phase.canonical_key,
+                )
+                for state in leg.source_states
+            )
+        ),
+    )
+
+
+def _external_source_relation(
+    root: tuple[RecurrenceExternalLegV1, ...],
+    target: tuple[RecurrenceExternalLegV1, ...],
+    source_slots: tuple[int, ...],
+) -> (
+    tuple[
+        tuple[int, ...],
+        tuple[int, ...],
+        tuple[int, ...],
+        tuple[int, ...],
+        tuple[tuple[int, int], ...],
+    ]
+    | None
+):
+    momentum_signs: list[int] = []
+    helicity_signs: list[int] = []
+    source_state_offsets = [0]
+    source_state_indices: list[int] = []
+    source_templates: dict[int, int] = {}
+    reverse_source_templates: dict[int, int] = {}
+    for root_slot, target_slot in enumerate(source_slots):
+        left = root[root_slot]
+        right = target[target_slot]
+        if (
+            left.outgoing_pdg != right.outgoing_pdg
+            or left.is_fermionic != right.is_fermionic
+            or len(left.source_states) != len(right.source_states)
+        ):
+            return None
+        right_states: dict[tuple[object, ...], RecurrenceSourceStateV1] = {}
+        for state in right.source_states:
+            key = _source_state_execution_key(state)
+            if key in right_states:
+                return None
+            right_states[key] = state
+        momentum_factor: int | None = None
+        helicity_factor: int | None = None
+        state_indices = [0] * len(left.source_states)
+        for state in left.source_states:
+            other = right_states.get(_source_state_execution_key(state))
+            if other is None:
+                return None
+            state_indices[state.state_index] = other.state_index
+            candidate_momentum = other.momentum_sign * state.momentum_sign
+            if momentum_factor is None:
+                momentum_factor = candidate_momentum
+            elif momentum_factor != candidate_momentum:
+                return None
+            candidate_helicity = _signed_value_relation(
+                state.public_helicity,
+                other.public_helicity,
+            )
+            if candidate_helicity is None:
+                return None
+            if helicity_factor is None:
+                helicity_factor = candidate_helicity
+            elif helicity_factor != candidate_helicity:
+                return None
+            previous = source_templates.setdefault(
+                state.source_template_id, other.source_template_id
+            )
+            reverse = reverse_source_templates.setdefault(
+                other.source_template_id, state.source_template_id
+            )
+            if (
+                previous != other.source_template_id
+                or reverse != state.source_template_id
+            ):
+                return None
+        momentum_signs.append(1 if momentum_factor is None else momentum_factor)
+        helicity_signs.append(1 if helicity_factor is None else helicity_factor)
+        if not _is_permutation(state_indices):
+            return None
+        source_state_indices.extend(state_indices)
+        source_state_offsets.append(len(source_state_indices))
+    changes = tuple(
+        (source, target_id)
+        for source, target_id in sorted(source_templates.items())
+        if source != target_id
+    )
+    return (
+        tuple(momentum_signs),
+        tuple(helicity_signs),
+        tuple(source_state_offsets),
+        tuple(source_state_indices),
+        changes,
+    )
+
+
+def _source_state_execution_key(
+    state: RecurrenceSourceStateV1,
+) -> tuple[object, ...]:
+    return (
+        state.current_state_template_id,
+        state.chirality,
+        state.spin_state,
+        state.crossing_phase.canonical_key,
+    )
+
+
+def _signed_value_relation(left: int, right: int) -> int | None:
+    if left == 0 or right == 0:
+        return 1 if left == right else None
+    if right == left:
+        return 1
+    if right == -left:
+        return -1
+    return None
+
+
+def _sector_bijection(
+    root: tuple[RecurrencePhysicalLCSectorV1, ...],
+    target: tuple[RecurrencePhysicalLCSectorV1, ...],
+    source_slots: tuple[int, ...],
+) -> tuple[int, ...] | None:
+    inverse = _inverse_permutation(source_slots)
+    targets: dict[tuple[object, ...], int] = {}
+    for sector in target:
+        key = _sector_key(sector, inverse)
+        if key in targets:
+            return None
+        targets[key] = sector.sector_id
+    result: list[int] = []
+    for sector in root:
+        target_id = targets.get(_sector_key(sector, tuple(range(len(source_slots)))))
+        if target_id is None:
+            return None
+        result.append(target_id)
+    return tuple(result) if _is_permutation(result) else None
+
+
+def _sector_key(
+    sector: RecurrencePhysicalLCSectorV1,
+    slots: tuple[int, ...],
+) -> tuple[object, ...]:
+    def mapped(values: Sequence[int]) -> tuple[int, ...]:
+        return tuple(slots[value] for value in values)
+
+    return (
+        sector.kind,
+        slots[sector.closure_source_slot],
+        sector.closure_proof_algorithm,
+        tuple(
+            (
+                slots[row.fundamental_source_slot],
+                slots[row.antifundamental_source_slot],
+                mapped(row.adjoint_source_slots),
+                mapped(row.singlet_source_slots),
+            )
+            for row in sector.open_strings
+        ),
+        mapped(sector.trace_source_slots),
+        mapped(sector.singlet_source_slots),
+        mapped(sector.word_source_slots),
+    )
+
+
+def _flow_bijection(
+    root: tuple[RecurrencePublicLCFlowV1, ...],
+    target: tuple[RecurrencePublicLCFlowV1, ...],
+    source_slots: tuple[int, ...],
+    sector_ids: tuple[int, ...],
+) -> tuple[int, ...] | None:
+    inverse_slots = _inverse_permutation(source_slots)
+    inverse_sectors = _inverse_permutation(sector_ids)
+    targets: dict[tuple[object, ...], int] = {}
+    for flow in target:
+        permutation = tuple(
+            inverse_slots[flow.source_slot_permutation[source_slots[root_slot]]]
+            for root_slot in range(len(source_slots))
+        )
+        key = (
+            inverse_sectors[flow.construction_sector_id],
+            tuple(inverse_slots[value] for value in flow.word_source_slots),
+            permutation,
+            flow.reduction_weight.canonical_key,
+        )
+        if key in targets:
+            return None
+        targets[key] = flow.flow_id
+    result = []
+    for flow in root:
+        key = (
+            flow.construction_sector_id,
+            flow.word_source_slots,
+            flow.source_slot_permutation,
+            flow.reduction_weight.canonical_key,
+        )
+        target_id = targets.get(key)
+        if target_id is None:
+            return None
+        result.append(target_id)
+    return tuple(result) if _is_permutation(result) else None
+
+
+def _replay_contracts_match(
+    root: RecurrenceBuilderLogicalInputV1,
+    target: RecurrenceBuilderLogicalInputV1,
+    *,
+    source_slots: tuple[int, ...],
+    sector_ids: tuple[int, ...],
+) -> bool:
+    inverse_sectors = _inverse_permutation(sector_ids)
+    left = tuple(
+        _replay_partition_key(
+            row,
+            tuple(range(len(source_slots))),
+            tuple(range(len(source_slots))),
+            tuple(range(len(sector_ids))),
+        )
+        for row in root.replay_partitions
+    )
+    right = tuple(
+        _replay_partition_key(
+            row,
+            source_slots,
+            _inverse_permutation(source_slots),
+            inverse_sectors,
+        )
+        for row in target.replay_partitions
+    )
+    return left == right
+
+
+def _replay_partition_key(
+    row: object,
+    root_to_concrete: tuple[int, ...],
+    concrete_to_root: tuple[int, ...],
+    sectors: tuple[int, ...],
+) -> tuple[object, ...]:
+    def conjugate(values: Sequence[int]) -> tuple[int, ...]:
+        return tuple(
+            concrete_to_root[values[root_to_concrete[root_slot]]]
+            for root_slot in range(len(root_to_concrete))
+        )
+
+    return (
+        sectors[row.representative_sector_id],
+        sectors[row.materialized_sector_id],
+        row.proof_algorithm,
+        tuple(
+            (
+                sectors[target.sector_id],
+                conjugate(target.external_permutation),
+                conjugate(target.source_slot_permutation),
+                target.amplitude_phase.canonical_key,
+                target.fermion_sign,
+            )
+            for target in row.targets
+        ),
+    )
+
+
+def _fermion_pairing_contracts_match(
+    root: object,
+    target: object,
+    source_slots: tuple[int, ...],
+) -> bool:
+    if (root is None) != (target is None):
+        return False
+    if root is None:
+        return True
+    inverse = _inverse_permutation(source_slots)
+    return _pairing_key(root, tuple(range(len(source_slots)))) == _pairing_key(
+        target, inverse
+    )
+
+
+def _pairing_key(catalog: object, slots: tuple[int, ...]) -> tuple[object, ...]:
+    concrete_to_root = slots
+    root_to_concrete = _inverse_permutation(concrete_to_root)
+    endpoints = tuple(
+        sorted(
+            (
+                concrete_to_root[row.source_slot],
+                row.species_id,
+                row.particle_orientation,
+                row.color_orientation,
+                row.state_template_ids,
+                row.anti_state_template_ids,
+                row.basis_ids,
+                row.color_representations,
+            )
+            for row in catalog.endpoints
+        )
+    )
+    classes = tuple(
+        sorted(
+            (
+                row.species_id,
+                tuple(
+                    concrete_to_root[value] for value in row.fundamental_source_slots
+                ),
+                tuple(
+                    concrete_to_root[value]
+                    for value in row.antifundamental_source_slots
+                ),
+                tuple(
+                    (
+                        concrete_to_root[left],
+                        concrete_to_root[right],
+                    )
+                    for left, right in row.reference_pairings
+                ),
+                row.pairing_count,
+            )
+            for row in catalog.pairing_classes
+        )
+    )
+    rules = tuple(
+        sorted(
+            (
+                row.class_pairing_indices,
+                tuple(
+                    (
+                        concrete_to_root[left],
+                        concrete_to_root[right],
+                    )
+                    for left, right in row.endpoint_pairings
+                ),
+                tuple(
+                    concrete_to_root[
+                        row.source_slot_permutation[root_to_concrete[root_slot]]
+                    ]
+                    for root_slot in range(len(slots))
+                ),
+                tuple(
+                    row.lineage_by_source_slot[root_to_concrete[root_slot]]
+                    for root_slot in range(len(slots))
+                ),
+                row.fermion_parity,
+                (
+                    row.exact_factor.real_numerator,
+                    row.exact_factor.real_denominator,
+                    row.exact_factor.imag_numerator,
+                    row.exact_factor.imag_denominator,
+                ),
+                row.multiplicity,
+                row.proof_algorithm,
+            )
+            for row in catalog.rules
+        )
+    )
+    return catalog.source_count, endpoints, classes, rules
+
+
+def _pairing_proof_digests(catalog: object) -> object:
+    if catalog is None:
+        return None
+    return {
+        "semantic": catalog.semantic_digest,
+        "topology": catalog.topology_digest,
+        "endpoints": [row.contract_digest for row in catalog.endpoints],
+        "classes": [row.proof_digest for row in catalog.pairing_classes],
+        "rules": [row.proof_digest for row in catalog.rules],
+    }
+
+
+class RecurrenceSharedSchedule:
+    """One immutable root Direct-Arena schedule."""
+
+    __slots__ = (
+        "digest",
+        "index_sha256",
+        "member_count",
+        "process_ids",
+        "sha256",
+        "size_bytes",
+        "source_path",
+        "unpacked_size_bytes",
+    )
+
+    def __init__(
+        self,
+        *,
+        digest: str,
+        source_path: Path,
+        sha256: str,
+        size_bytes: int,
+        member_count: int,
+        unpacked_size_bytes: int,
+        index_sha256: str,
+        process_ids: tuple[str, ...],
+    ) -> None:
+        self.digest = _require_sha256(digest, "schedule digest")
+        self.source_path = source_path
+        self.sha256 = _require_sha256(sha256, "schedule payload SHA-256")
+        self.size_bytes = _positive_integer(size_bytes, "schedule payload size")
+        self.member_count = _positive_integer(member_count, "schedule member count")
+        self.unpacked_size_bytes = _positive_integer(
+            unpacked_size_bytes, "schedule unpacked size"
+        )
+        self.index_sha256 = _require_sha256(
+            index_sha256, "schedule PACBIN index SHA-256"
+        )
+        self.process_ids = process_ids
+
+    @property
+    def artifact_path(self) -> str:
+        return f"recurrence/schedules/{self.digest}/recurrence-runtime.pacbin"
+
+    def to_mapping(self) -> dict[str, object]:
+        return {
+            "digest": self.digest,
+            "path": self.artifact_path,
+            "sha256": self.sha256,
+            "size_bytes": self.size_bytes,
+            "member_count": self.member_count,
+            "unpacked_size_bytes": self.unpacked_size_bytes,
+            "index_sha256": self.index_sha256,
+            "process_ids": list(self.process_ids),
+        }
+
+
+class RecurrenceProcessBinding:
+    """One independent concrete-process binding to a root schedule."""
+
+    __slots__ = (
+        "executor_pack",
+        "native_schedule_semantic_digest",
+        "payload",
+        "process_digest",
+        "process_id",
+        "process_semantic_digest",
+        "process_support_mask",
+        "process_support_words",
+        "remap",
+        "schedule_digest",
+        "sha256",
+    )
+
+    def __init__(
+        self,
+        *,
+        process_id: str,
+        schedule_digest: str,
+        native_schedule_semantic_digest: str,
+        process_digest: str,
+        process_semantic_digest: str,
+        process_support_mask: int,
+        remap: RecurrenceProcessRemap,
+        executor_pack: RecurrenceProcessExecutorPack,
+    ) -> None:
+        self.process_id = _nonempty_text(process_id, "process ID")
+        self.schedule_digest = _require_sha256(schedule_digest, "schedule digest")
+        self.native_schedule_semantic_digest = _require_sha256(
+            native_schedule_semantic_digest,
+            "native schedule semantic digest",
+        )
+        self.process_digest = _require_sha256(process_digest, "process digest")
+        self.process_semantic_digest = _require_sha256(
+            process_semantic_digest, "process semantic digest"
+        )
+        self.process_support_mask = _single_bit(
+            process_support_mask, "process support mask"
+        )
+        self.process_support_words = tuple(
+            (self.process_support_mask >> shift) & ((1 << 64) - 1)
+            for shift in range(0, max(1, self.process_support_mask.bit_length()), 64)
+        )
+        if not isinstance(remap, RecurrenceProcessRemap):
+            raise RecurrenceScheduleSharingError(
+                "recurrence process binding requires an exact process remap"
+            )
+        if not remap.bijection_digest:
+            raise RecurrenceScheduleSharingError(
+                "recurrence process remap has no authenticated bijection digest"
+            )
+        self.remap = remap
+        if not isinstance(executor_pack, RecurrenceProcessExecutorPack):
+            raise RecurrenceScheduleSharingError(
+                "recurrence process binding requires a typed executor pack"
+            )
+        if executor_pack.catalog_executor_count != remap.direct_executor_count:
+            raise RecurrenceScheduleSharingError(
+                "recurrence process executor domain disagrees with its remap"
+            )
+        self.executor_pack = executor_pack
+        self.payload = encode_recurrence_process_binding(
+            process_id=self.process_id,
+            schedule_digest=self.schedule_digest,
+            process_digest=self.process_digest,
+            process_semantic_digest=self.process_semantic_digest,
+            process_support_mask=self.process_support_mask,
+            remap=self.remap,
+            executor_pack=self.executor_pack,
+        )
+        self.sha256 = hashlib.sha256(self.payload).hexdigest()
+
+    @property
+    def artifact_path(self) -> str:
+        return f"processes/{self.process_id}/recurrence-binding.bin"
+
+    def to_mapping(self) -> dict[str, object]:
+        return {
+            "abi": RECURRENCE_PROCESS_BINDING_ABI,
+            "process_id": self.process_id,
+            "schedule_digest": self.schedule_digest,
+            "native_schedule_semantic_digest": (self.native_schedule_semantic_digest),
+            "process_digest": self.process_digest,
+            "process_semantic_digest": self.process_semantic_digest,
+            "process_support_words": list(self.process_support_words),
+            "remap": self.remap.to_mapping(),
+            "path": "recurrence-binding.bin",
+            "size_bytes": len(self.payload),
+            "sha256": self.sha256,
+        }
+
+
+class RecurrenceScheduleSharingPlan:
+    __slots__ = ("bindings", "schedules")
+
+    def __init__(
+        self,
+        *,
+        schedules: tuple[RecurrenceSharedSchedule, ...],
+        bindings: tuple[RecurrenceProcessBinding, ...],
+    ) -> None:
+        self.schedules = schedules
+        self.bindings = bindings
+
+    def schedule(self, digest: str) -> RecurrenceSharedSchedule:
+        for schedule in self.schedules:
+            if schedule.digest == digest:
+                return schedule
+        raise RecurrenceScheduleSharingError(f"unknown recurrence schedule {digest!r}")
+
+    def binding(self, process_id: str) -> RecurrenceProcessBinding:
+        for binding in self.bindings:
+            if binding.process_id == process_id:
+                return binding
+        raise RecurrenceScheduleSharingError(
+            f"process {process_id!r} has no recurrence binding"
+        )
+
+    def to_mapping(self) -> dict[str, object]:
+        return {
+            "kind": RECURRENCE_SCHEDULE_SHARING_KIND,
+            "schema_version": RECURRENCE_SCHEDULE_SHARING_SCHEMA_VERSION,
+            "schedule_count": len(self.schedules),
+            "binding_count": len(self.bindings),
+            "schedule_alias_count": len(self.bindings) - len(self.schedules),
+            "runtime_ownership": "root-schedule-plus-process-binding",
+            "interning_phase": "before-direct-lowering",
+            "schedules": [item.to_mapping() for item in self.schedules],
+            "bindings": [item.to_mapping() for item in self.bindings],
+        }
+
+    def extension_mapping(self, *, index_sha256: str) -> dict[str, object]:
+        return {
+            "kind": RECURRENCE_SCHEDULE_SHARING_KIND,
+            "schema_version": RECURRENCE_SCHEDULE_SHARING_SCHEMA_VERSION,
+            "index_path": RECURRENCE_SCHEDULE_INDEX_PATH,
+            "index_sha256": _require_sha256(index_sha256, "schedule index SHA-256"),
+            "schedule_count": len(self.schedules),
+            "binding_count": len(self.bindings),
+            "schedule_alias_count": len(self.bindings) - len(self.schedules),
+            "runtime_ownership": "root-schedule-plus-process-binding",
+            "interning_phase": "before-direct-lowering",
+        }
+
+
+def intern_recurrence_schedules(
+    processes: Sequence[RecurrenceScheduleProcess],
+) -> RecurrenceScheduleSharingPlan:
+    """Validate and intern already pre-lowered root schedules."""
+
+    schedules: dict[str, RecurrenceSharedSchedule] = {}
+    schedule_processes: dict[str, list[str]] = {}
+    schedule_native_semantics: dict[str, str] = {}
+    bindings: list[RecurrenceProcessBinding] = []
+    process_ids: set[str] = set()
+    support_masks: set[int] = set()
+
+    for process in processes:
+        process_id = _nonempty_text(process.process_id, "recurrence process ID")
+        if process_id in process_ids:
+            raise RecurrenceScheduleSharingError(
+                f"duplicate recurrence process binding {process_id!r}"
+            )
+        process_ids.add(process_id)
+        support_mask = _single_bit(
+            process.process_support_mask, f"process {process_id!r} support mask"
+        )
+        if support_mask in support_masks:
+            raise RecurrenceScheduleSharingError(
+                f"recurrence support mask {support_mask} is reused"
+            )
+        support_masks.add(support_mask)
+
+        digest = _require_sha256(
+            process.recurrence_schedule_digest,
+            f"process {process_id!r} schedule digest",
+        )
+        native_semantic_digest = _require_sha256(
+            process.recurrence_native_schedule_semantic_digest,
+            f"process {process_id!r} native schedule semantic digest",
+        )
+        candidate = RecurrenceSharedSchedule(
+            digest=digest,
+            source_path=process.recurrence_schedule_path,
+            sha256=process.recurrence_schedule_sha256,
+            size_bytes=process.recurrence_schedule_size_bytes,
+            member_count=process.recurrence_schedule_member_count,
+            unpacked_size_bytes=process.recurrence_schedule_unpacked_size_bytes,
+            index_sha256=process.recurrence_schedule_index_sha256,
+            process_ids=(),
+        )
+        previous = schedules.get(digest)
+        if previous is not None and (
+            previous.sha256 != candidate.sha256
+            or previous.size_bytes != candidate.size_bytes
+            or previous.member_count != candidate.member_count
+            or previous.unpacked_size_bytes != candidate.unpacked_size_bytes
+            or previous.index_sha256 != candidate.index_sha256
+        ):
+            raise RecurrenceScheduleSharingError(
+                f"schedule digest {digest} maps to different payloads"
+            )
+        previous_native_semantic_digest = schedule_native_semantics.get(digest)
+        if (
+            previous_native_semantic_digest is not None
+            and previous_native_semantic_digest != native_semantic_digest
+        ):
+            raise RecurrenceScheduleSharingError(
+                f"schedule digest {digest} maps to different native semantics"
+            )
+        schedules.setdefault(digest, candidate)
+        schedule_native_semantics.setdefault(digest, native_semantic_digest)
+        schedule_processes.setdefault(digest, []).append(process_id)
+        bindings.append(
+            RecurrenceProcessBinding(
+                process_id=process_id,
+                schedule_digest=digest,
+                native_schedule_semantic_digest=native_semantic_digest,
+                process_digest=process.process_digest,
+                process_semantic_digest=process.builder_input_sha256,
+                process_support_mask=support_mask,
+                remap=process.recurrence_process_remap,
+                executor_pack=process.recurrence_process_executor_pack,
+            )
+        )
+
+    shared = tuple(
+        RecurrenceSharedSchedule(
+            digest=digest,
+            source_path=schedule.source_path,
+            sha256=schedule.sha256,
+            size_bytes=schedule.size_bytes,
+            member_count=schedule.member_count,
+            unpacked_size_bytes=schedule.unpacked_size_bytes,
+            index_sha256=schedule.index_sha256,
+            process_ids=tuple(sorted(schedule_processes[digest])),
+        )
+        for digest, schedule in sorted(schedules.items())
+    )
+    return RecurrenceScheduleSharingPlan(
+        schedules=shared,
+        bindings=tuple(sorted(bindings, key=lambda item: item.process_id)),
+    )
+
+
+def encode_recurrence_process_binding(
+    *,
+    process_id: str,
+    schedule_digest: str,
+    process_digest: str,
+    process_semantic_digest: str,
+    process_support_mask: int,
+    remap: RecurrenceProcessRemap,
+    executor_pack: RecurrenceProcessExecutorPack,
+) -> bytes:
+    process = _nonempty_text(process_id, "process ID").encode("utf-8")
+    if len(process) > 4096:
+        raise RecurrenceScheduleSharingError("process ID exceeds 4096 UTF-8 bytes")
+    mask = _single_bit(process_support_mask, "process support mask")
+    words = tuple(
+        (mask >> shift) & ((1 << 64) - 1)
+        for shift in range(0, max(1, mask.bit_length()), 64)
+    )
+    if not isinstance(remap, RecurrenceProcessRemap) or not remap.bijection_digest:
+        raise RecurrenceScheduleSharingError(
+            "recurrence process binding requires an authenticated process remap"
+        )
+    if not isinstance(executor_pack, RecurrenceProcessExecutorPack):
+        raise RecurrenceScheduleSharingError(
+            "recurrence process binding requires a typed executor pack"
+        )
+    if executor_pack.catalog_executor_count != remap.direct_executor_count:
+        raise RecurrenceScheduleSharingError(
+            "recurrence process executor domain disagrees with its remap"
+        )
+    target = executor_pack.target_triple.encode("utf-8")
+    if len(target) > _MISSING_U32:
+        raise RecurrenceScheduleSharingError(
+            "process executor target triple exceeds the u32 wire domain"
+        )
+    counts = (
+        len(remap.source_slots),
+        len(remap.public_flow_ids),
+        len(remap.physical_sector_ids),
+        remap.state_template_count,
+        remap.source_template_count,
+        remap.direct_executor_count,
+        remap.parameter_slot_count,
+        len(remap.state_template_changes),
+        len(remap.source_template_changes),
+        len(remap.direct_executor_changes),
+        len(remap.parameter_slot_changes),
+    )
+    for value in counts:
+        if value > (1 << 32) - 1:
+            raise RecurrenceScheduleSharingError(
+                "recurrence process remap exceeds the u32 binding ABI"
+            )
+    for value, context in (
+        (len(words), "support-word count"),
+        (len(executor_pack.cpu_features), "CPU-feature count"),
+        (len(executor_pack.executor_ids), "executor-descriptor count"),
+    ):
+        if value > _MISSING_U32:
+            raise RecurrenceScheduleSharingError(
+                f"recurrence process {context} exceeds the u32 binding ABI"
+            )
+    header = b"".join(
+        (
+            RECURRENCE_PROCESS_BINDING_MAGIC,
+            struct.pack(
+                "<8I",
+                _PROCESS_BINDING_VERSION,
+                _PROCESS_BINDING_FIXED_SIZE,
+                len(process),
+                len(words),
+                len(target),
+                len(executor_pack.cpu_features),
+                len(executor_pack.executor_ids),
+                executor_pack.catalog_executor_count,
+            ),
+            struct.pack(
+                "<4B",
+                _DIRECT_BACKEND[executor_pack.backend],
+                int(executor_pack.portable),
+                64,
+                0,
+            ),
+            struct.pack("<11I", *counts),
+            bytes.fromhex(_require_sha256(schedule_digest, "schedule digest")),
+            bytes.fromhex(
+                _require_sha256(process_semantic_digest, "process semantic digest")
+            ),
+            bytes.fromhex(
+                _require_sha256(
+                    executor_pack.compiled_model_digest,
+                    "compiled-model digest",
+                )
+            ),
+            bytes.fromhex(executor_pack.recurrence_template_catalog_digest),
+            bytes.fromhex(executor_pack.prepared_kernel_pack_digest),
+            bytes.fromhex(executor_pack.direct_template_catalog_digest),
+            bytes.fromhex(executor_pack.runtime_layout_digest),
+            bytes.fromhex(_require_sha256(process_digest, "process digest")),
+        )
+    )
+    if len(header) != _PROCESS_BINDING_FIXED_SIZE:
+        raise AssertionError("recurrence process-binding header size drifted")
+    sparse_changes = (
+        remap.state_template_changes,
+        remap.source_template_changes,
+        remap.direct_executor_changes,
+        remap.parameter_slot_changes,
+    )
+    return b"".join(
+        (
+            header,
+            process,
+            target,
+            *(
+                _encode_wire_text(feature, "target CPU feature")
+                for feature in executor_pack.cpu_features
+            ),
+            struct.pack(f"<{len(words)}Q", *words),
+            struct.pack(f"<{len(remap.source_slots)}I", *remap.source_slots),
+            struct.pack(
+                f"<{len(remap.source_momentum_signs)}i",
+                *remap.source_momentum_signs,
+            ),
+            struct.pack(
+                f"<{len(remap.source_helicity_signs)}i",
+                *remap.source_helicity_signs,
+            ),
+            struct.pack(
+                f"<{len(remap.source_state_offsets)}I",
+                *remap.source_state_offsets,
+            ),
+            struct.pack(
+                f"<{len(remap.source_state_indices)}I",
+                *remap.source_state_indices,
+            ),
+            struct.pack(
+                f"<{len(remap.public_flow_ids)}I",
+                *remap.public_flow_ids,
+            ),
+            struct.pack(
+                f"<{len(remap.physical_sector_ids)}I",
+                *remap.physical_sector_ids,
+            ),
+            *(
+                struct.pack(
+                    f"<{2 * len(changes)}I",
+                    *(value for pair in changes for value in pair),
+                )
+                for changes in sparse_changes
+            ),
+            *executor_pack.descriptor_payloads,
+        )
+    )
+
+
+def _schedule_plain(value: object) -> object:
+    if is_dataclass(value) and not isinstance(value, type):
+        result: dict[str, object] = {}
+        for item in fields(value):
+            if item.name == "process_id":
+                result[item.name] = "<shared-schedule>"
+            elif item.name in {"process_support_mask", "support_mask"}:
+                result[item.name] = 1
+            else:
+                result[item.name] = _schedule_plain(getattr(value, item.name))
+        return result
+    if isinstance(value, Mapping):
+        return {
+            str(key): _schedule_plain(item)
+            for key, item in sorted(value.items(), key=lambda row: str(row[0]))
+        }
+    if isinstance(value, (tuple, list)):
+        return [_schedule_plain(item) for item in value]
+    if isinstance(value, (set, frozenset)):
+        return [_schedule_plain(item) for item in sorted(value, key=repr)]
+    if isinstance(value, Path):
+        return value.as_posix()
+    return value
+
+
+def _canonical_digest(value: object) -> str:
+    payload = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _nonempty_text(value: object, context: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise RecurrenceScheduleSharingError(f"{context} must be nonempty text")
+    return value
+
+
+def _require_sha256(value: object, context: str) -> str:
+    if not isinstance(value, str) or _SHA256.fullmatch(value) is None:
+        raise RecurrenceScheduleSharingError(
+            f"{context} must be a lowercase hexadecimal SHA-256 digest"
+        )
+    return value
+
+
+def _positive_integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+        raise RecurrenceScheduleSharingError(f"{context} must be a positive integer")
+    return value
+
+
+def _nonnegative_integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise RecurrenceScheduleSharingError(f"{context} must be a nonnegative integer")
+    return value
+
+
+def _single_bit(value: object, context: str) -> int:
+    result = _positive_integer(value, context)
+    if result & (result - 1):
+        raise RecurrenceScheduleSharingError(f"{context} must contain one bit")
+    return result
+
+
+def _permutation(values: Sequence[int], context: str) -> tuple[int, ...]:
+    result = tuple(_nonnegative_integer(value, f"{context} value") for value in values)
+    if not _is_permutation(result):
+        raise RecurrenceScheduleSharingError(
+            f"{context} must be a dense zero-based permutation"
+        )
+    return result
+
+
+def _is_permutation(values: Sequence[int]) -> bool:
+    return tuple(sorted(values)) == tuple(range(len(values)))
+
+
+def _inverse_permutation(values: Sequence[int]) -> tuple[int, ...]:
+    permutation = _permutation(values, "permutation")
+    inverse = [0] * len(permutation)
+    for source, target in enumerate(permutation):
+        inverse[target] = source
+    return tuple(inverse)
+
+
+def _signs(
+    values: Sequence[int],
+    expected_count: int,
+    context: str,
+) -> tuple[int, ...]:
+    result = tuple(values)
+    if len(result) != expected_count or any(value not in {-1, 1} for value in result):
+        raise RecurrenceScheduleSharingError(
+            f"{context} must contain {expected_count} signs in {{-1, 1}}"
+        )
+    return result
+
+
+def _ragged_permutations(
+    offsets: Sequence[int],
+    values: Sequence[int],
+    row_count: int,
+    context: str,
+) -> tuple[tuple[int, ...], tuple[int, ...]]:
+    checked_offsets = tuple(
+        _nonnegative_integer(value, f"{context} offset") for value in offsets
+    )
+    checked_values = tuple(
+        _nonnegative_integer(value, f"{context} value") for value in values
+    )
+    if (
+        len(checked_offsets) != row_count + 1
+        or not checked_offsets
+        or checked_offsets[0] != 0
+        or checked_offsets[-1] != len(checked_values)
+        or any(left > right for left, right in itertools.pairwise(checked_offsets))
+    ):
+        raise RecurrenceScheduleSharingError(
+            f"{context} offsets do not partition {row_count} rows"
+        )
+    for row, (start, stop) in enumerate(itertools.pairwise(checked_offsets)):
+        if not _is_permutation(checked_values[start:stop]):
+            raise RecurrenceScheduleSharingError(
+                f"{context} row {row} is not a dense zero-based permutation"
+            )
+    return checked_offsets, checked_values
+
+
+def _sparse_permutation(
+    changes: Sequence[tuple[int, int]],
+    count: int,
+    context: str,
+) -> tuple[tuple[int, int], ...]:
+    size = _nonnegative_integer(count, f"{context} domain size")
+    result = tuple(changes)
+    if result != tuple(sorted(result)):
+        raise RecurrenceScheduleSharingError(f"{context} changes must be ordered")
+    sources: set[int] = set()
+    mapping = list(range(size))
+    for source, target in result:
+        source = _nonnegative_integer(source, f"{context} source")
+        target = _nonnegative_integer(target, f"{context} target")
+        if source >= size or target >= size:
+            raise RecurrenceScheduleSharingError(
+                f"{context} change is outside its declared domain"
+            )
+        if source == target:
+            raise RecurrenceScheduleSharingError(
+                f"{context} must omit identity changes"
+            )
+        if source in sources:
+            raise RecurrenceScheduleSharingError(f"{context} repeats source {source}")
+        sources.add(source)
+        mapping[source] = target
+    if not _is_permutation(mapping):
+        raise RecurrenceScheduleSharingError(
+            f"{context} changes do not define a bijection"
+        )
+    return result
+
+
+def _sparse_mapping(
+    count: int,
+    changes: Sequence[tuple[int, int]],
+) -> dict[str, object]:
+    return {
+        "count": _nonnegative_integer(count, "sparse mapping count"),
+        "changes": [list(pair) for pair in changes],
+    }
+
+
+def _template_count(
+    logical: RecurrenceBuilderLogicalInputV1,
+    kind: str,
+) -> int:
+    identifiers = tuple(
+        row.template_id
+        for row in logical.semantic_template_references
+        if row.kind == kind
+    )
+    if not identifiers:
+        raise RecurrenceScheduleSharingError(
+            f"recurrence process has no {kind!r} template domain"
+        )
+    if identifiers != tuple(range(len(identifiers))):
+        raise RecurrenceScheduleSharingError(
+            f"recurrence {kind!r} template IDs are not dense and ordered"
+        )
+    return len(identifiers)
+
+
+def _physical_sector_domain_count(
+    logical: RecurrenceBuilderLogicalInputV1,
+) -> int:
+    if logical.layout == "topology-replay":
+        return len(logical.public_flows)
+    return len(logical.physical_sectors)
+
+
+__all__ = [
+    "RECURRENCE_PROCESS_BINDING_ABI",
+    "RECURRENCE_PROCESS_BINDING_MAGIC",
+    "RECURRENCE_SCHEDULE_INDEX_PATH",
+    "RECURRENCE_SCHEDULE_SHARING_KIND",
+    "RECURRENCE_SCHEDULE_SHARING_SCHEMA_VERSION",
+    "RecurrenceProcessBinding",
+    "RecurrenceProcessExecutorPack",
+    "RecurrenceProcessRemap",
+    "RecurrenceScheduleLoweringCache",
+    "RecurrenceScheduleSharingError",
+    "RecurrenceScheduleSharingPlan",
+    "RecurrenceSharedLoweringResult",
+    "RecurrenceSharedSchedule",
+    "build_recurrence_process_executor_pack",
+    "encode_recurrence_process_binding",
+    "exact_recurrence_process_bijection",
+    "intern_recurrence_schedules",
+    "recurrence_helicity_selector_schedule_digest",
+    "recurrence_native_schedule_semantic_digest",
+    "recurrence_schedule_semantic_digest",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/recurrence_template_columnar.py b/pyamplicol/src/pyamplicol/generation/recurrence_template_columnar.py
new file mode 100644
index 0000000000..aaa151445c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/recurrence_template_columnar.py
@@ -0,0 +1,1801 @@
+# SPDX-License-Identifier: 0BSD
+"""Compact Python-to-Rust projection of recurrence-template-v1.
+
+The prepared recurrence catalog is model-wide, while
+``recurrence_columnar`` is process-specific.  Keeping the two authenticated
+inputs separate lets a process set reuse one decoded model catalog without
+copying it into every process builder input.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import operator
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from typing import Any, Final
+
+import numpy as np
+
+from ..models.recurrence_template import (
+    ExactComplexRationalV1,
+    RecurrenceTemplateCatalog,
+)
+from .recurrence_columnar import (
+    MISSING_U32,
+    RecurrenceColumn,
+    RecurrenceColumnarInputError,
+    RecurrenceColumnarTable,
+)
+
+RECURRENCE_TEMPLATE_INPUT_ABI: Final = "pyamplicol-recurrence-template-input-v1"
+RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION: Final = 2
+
+_U8 = np.dtype("u1")
+_U32 = np.dtype("<u4")
+_U64 = np.dtype("<u8")
+_I32 = np.dtype("<i4")
+
+_PARAMETER_KIND = {"external": 0, "derived": 1, "constant": 2}
+_PARAMETER_VALUE_TYPE = {"real": 0, "complex": 1}
+_ORIENTATION = {"particle": 0, "antiparticle": 1, "self-conjugate": 2}
+_STATISTICS = {"boson": 0, "fermion": 1}
+_CONTRACT_KIND = {
+    "source": 0,
+    "vertex": 1,
+    "propagator": 2,
+    "closure": 3,
+    "model-parameter": 4,
+}
+_CALLABLE_KIND = {"prepared-kernel": 0, "rusticol-template": 1}
+_OUTPUT_FACTOR_SOURCE = {"none": 0, "coupling-real": 1, "coupling-imag": 2}
+_LC_COLOR_COMPONENT_OPERATION = {
+    "concatenate-join": 0,
+    "concatenate-keep": 1,
+    "inherit-left": 2,
+    "inherit-right": 3,
+    "empty": 4,
+    "close": 5,
+}
+_LC_COLOR_COMPONENT_KIND = {"open-string": 0, "adjoint-segment": 1, "trace": 2}
+_LC_COLOR_COMPONENT_ROLE = {"active": 0, "passive": 1, "none": 2}
+_LC_COLOR_SOURCE_SEED_OPERATION = {"empty": 0, "singleton": 1}
+_I128_MAX = (1 << 127) - 1
+_I128_MIN = -_I128_MAX
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceTemplateInputV1:
+    """Owned immutable model-wide recurrence columns."""
+
+    abi: str
+    catalog_digest: str
+    compiled_model_digest: str
+    prepared_kernel_pack_digest: str
+    tables: tuple[RecurrenceColumnarTable, ...]
+
+    def __post_init__(self) -> None:
+        if self.abi != RECURRENCE_TEMPLATE_INPUT_ABI:
+            raise RecurrenceColumnarInputError(
+                f"unsupported recurrence template input ABI {self.abi!r}"
+            )
+        _require_sha256(self.catalog_digest, "recurrence catalog digest")
+        _require_sha256(self.compiled_model_digest, "compiled-model digest")
+        _require_sha256(self.prepared_kernel_pack_digest, "prepared kernel pack digest")
+        names = tuple(table.name for table in self.tables)
+        if names != tuple(sorted(names)) or len(names) != len(set(names)):
+            raise RecurrenceColumnarInputError(
+                "recurrence template tables must be uniquely named and sorted"
+            )
+
+    @property
+    def canonical_digest(self) -> str:
+        digest = hashlib.sha256()
+        _hash_text(digest, self.abi)
+        digest.update(bytes.fromhex(self.catalog_digest))
+        digest.update(bytes.fromhex(self.compiled_model_digest))
+        digest.update(bytes.fromhex(self.prepared_kernel_pack_digest))
+        digest.update(len(self.tables).to_bytes(8, "little"))
+        for table in self.tables:
+            _hash_text(digest, table.name)
+            digest.update(table.row_count.to_bytes(8, "little"))
+            digest.update(len(table.columns).to_bytes(4, "little"))
+            for column in table.columns:
+                _hash_text(digest, column.name)
+                _hash_text(digest, column.values.dtype.str)
+                digest.update(len(column.values.shape).to_bytes(1, "little"))
+                for dimension in column.values.shape:
+                    digest.update(int(dimension).to_bytes(8, "little"))
+                digest.update(column.values.tobytes(order="C"))
+        return digest.hexdigest()
+
+    @property
+    def digest(self) -> str:
+        return self.canonical_digest
+
+
+class _StringCatalog:
+    def __init__(self, values: Iterable[str]) -> None:
+        self.values = tuple(sorted(set(values)))
+        self._ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, value: str | None) -> int:
+        if value is None:
+            return MISSING_U32
+        return self._ids[value]
+
+
+class _DigestCatalog:
+    def __init__(self, values: Iterable[str]) -> None:
+        self.values = tuple(sorted(set(values)))
+        self._ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, value: str | None) -> int:
+        if value is None:
+            return MISSING_U32
+        return self._ids[value]
+
+
+class _FactorCatalog:
+    def __init__(self, values: Iterable[ExactComplexRationalV1]) -> None:
+        by_key = {_factor_key(value): value for value in values}
+        self.values = tuple(by_key[key] for key in sorted(by_key))
+        self._ids = {
+            _factor_key(value): index for index, value in enumerate(self.values)
+        }
+
+    def id(self, value: ExactComplexRationalV1 | None) -> int:
+        if value is None:
+            return MISSING_U32
+        return self._ids[_factor_key(value)]
+
+
+class _SequenceCatalog:
+    def __init__(self, values: Iterable[Sequence[int]]) -> None:
+        self.values = tuple(
+            sorted(set(tuple(int(item) for item in value) for value in values))
+        )
+        self._ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, values: Sequence[int]) -> int:
+        return self._ids[tuple(int(value) for value in values)]
+
+
+class _QuantumNumberFlowCatalog:
+    def __init__(self, values: Iterable[Sequence[tuple[str, str]]]) -> None:
+        self.values = tuple(
+            sorted(
+                set(
+                    tuple((str(name), str(expression)) for name, expression in value)
+                    for value in values
+                )
+            )
+        )
+        self._ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, values: Sequence[tuple[str, str]]) -> int:
+        key = tuple((str(name), str(expression)) for name, expression in values)
+        return self._ids[key]
+
+
+class _CouplingOrderCatalog:
+    def __init__(self, values: Iterable[Sequence[tuple[str, int]]]) -> None:
+        self.values = tuple(
+            sorted(
+                set(
+                    tuple((str(name), int(power)) for name, power in value)
+                    for value in values
+                )
+            )
+        )
+        self._ids = {value: index for index, value in enumerate(self.values)}
+
+    def id(self, values: Sequence[tuple[str, int]]) -> int:
+        key = tuple((str(name), int(power)) for name, power in values)
+        return self._ids[key]
+
+
+def build_recurrence_template_input_v1(
+    catalog: RecurrenceTemplateCatalog,
+) -> RecurrenceTemplateInputV1:
+    """Flatten a validated semantic catalog into deterministic primitive columns."""
+
+    if not isinstance(catalog, RecurrenceTemplateCatalog):
+        raise TypeError("recurrence template extraction requires a validated catalog")
+    _validate_i128_factors(catalog)
+
+    sections = {
+        "parameters": tuple(catalog.parameters),
+        "current_states": tuple(catalog.current_states),
+        "sources": tuple(catalog.sources),
+        "quantum_flows": tuple(catalog.quantum_flows),
+        "contact_orbit_certificates": tuple(catalog.contact_orbit_certificates),
+        "contact_orbit_steps": tuple(catalog.contact_orbit_steps),
+        "transitions": tuple(catalog.transitions),
+        "propagators": tuple(catalog.propagators),
+        "closures": tuple(catalog.closures),
+        "color_contractions": tuple(catalog.color_contractions),
+        "symmetry_proofs": tuple(catalog.symmetry_proofs),
+        "runtime_helicity_contracts": tuple(catalog.runtime_helicity_contracts),
+        "evaluator_bindings": tuple(catalog.evaluator_bindings),
+    }
+    ids = {
+        name: {
+            _record_identity(record, name): index
+            for index, record in enumerate(records)
+        }
+        for name, records in sections.items()
+    }
+
+    strings = _StringCatalog(_all_strings(catalog))
+    digests = _DigestCatalog(_all_digests(catalog))
+    factors = _FactorCatalog(_all_factors(catalog))
+    flavour_flows = _SequenceCatalog(_all_flavour_flows(catalog))
+    quantum_number_flows = _QuantumNumberFlowCatalog(_all_quantum_number_flows(catalog))
+    u32_sequences = _SequenceCatalog(
+        _all_u32_sequences(
+            catalog,
+            ids,
+            strings,
+            digests,
+            factors,
+            flavour_flows,
+            quantum_number_flows,
+        )
+    )
+    i32_sequences = _SequenceCatalog(_all_i32_sequences(catalog))
+    coupling_orders = _CouplingOrderCatalog(_all_coupling_orders(catalog))
+    string_ranges, string_bytes = _string_tables(strings)
+
+    tables = [
+        _header_table(catalog, strings, digests, sections),
+        _catalog_ranges("coupling_order", coupling_orders.values, 2),
+        _coupling_order_terms(coupling_orders, strings),
+        _contact_orbit_certificates_table(
+            catalog, strings, digests, factors, u32_sequences
+        ),
+        _contact_orbit_steps_table(
+            catalog, ids, strings, digests, factors, u32_sequences, i32_sequences
+        ),
+        _current_states_table(catalog, ids, strings, digests, u32_sequences),
+        _digest_table(digests),
+        _evaluator_bindings_table(catalog, ids, strings, digests, u32_sequences),
+        _exact_factor_table(factors, strings),
+        *_flatten_sequence_tables("flavour_flow", flavour_flows, _I32),
+        *_flatten_sequence_tables("i32_sequence", i32_sequences, _I32),
+        _parameters_table(catalog, ids, strings, digests, factors, u32_sequences),
+        _propagators_table(catalog, ids, strings, digests),
+        _quantum_flows_table(
+            catalog,
+            ids,
+            strings,
+            digests,
+            factors,
+            u32_sequences,
+            i32_sequences,
+            coupling_orders,
+            flavour_flows,
+            quantum_number_flows,
+        ),
+        _quantum_number_flow_ranges(quantum_number_flows),
+        _quantum_number_flow_terms(quantum_number_flows, strings),
+        *_runtime_helicity_tables(catalog, ids, strings, digests, factors),
+        _sources_table(
+            catalog,
+            ids,
+            strings,
+            digests,
+            flavour_flows,
+            quantum_number_flows,
+            u32_sequences,
+        ),
+        string_ranges,
+        string_bytes,
+        _symmetry_proofs_table(catalog, strings, digests, factors, u32_sequences),
+        _transitions_table(
+            catalog,
+            ids,
+            strings,
+            digests,
+            factors,
+            u32_sequences,
+            coupling_orders,
+        ),
+        _closures_table(
+            catalog,
+            ids,
+            strings,
+            digests,
+            factors,
+            u32_sequences,
+            coupling_orders,
+        ),
+        _color_contractions_table(catalog, strings, digests, factors, i32_sequences),
+        _lc_color_transition_witnesses_table(
+            catalog,
+            strings,
+            digests,
+            factors,
+            u32_sequences,
+        ),
+        _color_nc_terms_table(catalog, factors),
+        *_flatten_sequence_tables("u32_sequence", u32_sequences, _U32),
+    ]
+    tables.sort(key=lambda table: table.name)
+    return RecurrenceTemplateInputV1(
+        abi=RECURRENCE_TEMPLATE_INPUT_ABI,
+        catalog_digest=catalog.header.catalog_digest,
+        compiled_model_digest=catalog.header.compiled_model_digest,
+        prepared_kernel_pack_digest=catalog.header.prepared_kernel_pack_digest,
+        tables=tuple(tables),
+    )
+
+
+def _record_identity(record: object, section: str) -> str:
+    attribute = "resolver_key" if section == "evaluator_bindings" else "template_id"
+    return str(getattr(record, attribute))
+
+
+def _all_strings(catalog: RecurrenceTemplateCatalog) -> Iterable[str]:
+    yield RECURRENCE_TEMPLATE_INPUT_ABI
+    yield catalog.header.abi
+    yield catalog.header.canonicalization_abi
+    yield catalog.header.exact_scalar_abi
+    for record in catalog.parameters:
+        yield from (
+            record.template_id,
+            record.name,
+            *record.dependency_parameter_ids,
+        )
+    for record in catalog.current_states:
+        yield from (
+            record.template_id,
+            record.species_id,
+            record.basis,
+            record.lc_color_shape_kind,
+            *record.tensor_ordering,
+        )
+        yield from _present(
+            record.auxiliary_kind, record.mass_parameter_id, record.width_parameter_id
+        )
+    for record in catalog.sources:
+        yield from (
+            record.template_id,
+            record.crossing,
+            record.wavefunction_family,
+            record.evaluator_resolver_key,
+            record.lc_color_seed.output_shape_kind,
+        )
+        for key, value in record.lc_color_seed.provenance:
+            yield key
+            yield value
+        for name, expression in record.quantum_number_flow:
+            yield name
+            yield expression
+    for record in catalog.quantum_flows:
+        yield record.template_id
+        yield record.flavour_flow_operation
+        yield record.quantum_number_flow_operation
+        for flow in (
+            *record.input_quantum_number_flows,
+            record.result_quantum_number_flow,
+        ):
+            for name, expression in flow:
+                yield name
+                yield expression
+        yield from (name for name, _ in record.coupling_orders)
+    for record in catalog.contact_orbit_certificates:
+        yield from (
+            record.template_id,
+            record.algorithm,
+            record.vertex,
+            *record.particles,
+            record.evaluator_class,
+        )
+    for record in catalog.contact_orbit_steps:
+        yield from (
+            record.template_id,
+            record.certificate_template_id,
+            record.stage,
+        )
+    for record in catalog.transitions:
+        yield from (
+            record.template_id,
+            record.evaluator_resolver_key,
+            *record.momentum_convention,
+            record.output_factor_source,
+            record.equivalence_class,
+            record.output_projection,
+        )
+        yield from (name for name, _ in record.coupling_orders)
+    for record in catalog.propagators:
+        yield record.template_id
+        yield from _present(record.evaluator_resolver_key, record.gauge)
+    for record in catalog.closures:
+        yield from (
+            record.template_id,
+            record.evaluator_resolver_key,
+            record.output_factor_source,
+            record.equivalence_class,
+            record.projection,
+            record.chirality_relation,
+        )
+        yield from _present(record.metric_signature)
+        yield from (name for name, _ in record.coupling_orders)
+    for record in catalog.color_contractions:
+        yield from (record.template_id, record.rule_kind)
+        for witness in record.transition_witnesses:
+            yield from witness.input_shape_kinds
+            yield from _present(witness.result_shape_kind)
+            for key, value in witness.provenance:
+                yield key
+                yield value
+    for record in catalog.symmetry_proofs:
+        yield from (
+            record.template_id,
+            record.proof_algorithm,
+            *record.subject_template_ids,
+        )
+    for record in catalog.runtime_helicity_contracts:
+        yield from (
+            record.template_id,
+            record.full_state_template_id,
+            record.proof_algorithm,
+        )
+        for variant in record.variants:
+            yield variant.source_template_id
+            yield variant.source_state_template_id
+    for record in catalog.evaluator_bindings:
+        yield from (
+            record.resolver_key,
+            *record.input_layout,
+            *record.output_layout,
+            *record.semantic_template_ids,
+        )
+        yield from _present(record.runtime_template)
+    for factor in _all_factors(catalog):
+        yield from (str(value) for value in _factor_key(factor))
+
+
+def _all_digests(catalog: RecurrenceTemplateCatalog) -> Iterable[str]:
+    yield catalog.header.catalog_digest
+    yield catalog.header.compiled_model_digest
+    yield catalog.header.prepared_kernel_pack_digest
+    for records in (
+        catalog.parameters,
+        catalog.current_states,
+        catalog.sources,
+        catalog.quantum_flows,
+        catalog.contact_orbit_certificates,
+        catalog.contact_orbit_steps,
+        catalog.transitions,
+        catalog.propagators,
+        catalog.closures,
+        catalog.color_contractions,
+        catalog.symmetry_proofs,
+        catalog.runtime_helicity_contracts,
+        catalog.evaluator_bindings,
+    ):
+        for record in records:
+            yield record.semantic_digest
+    for record in catalog.parameters:
+        yield from _present(record.exact_expression_digest)
+    for record in catalog.sources:
+        yield record.wavefunction_expression_digest
+        yield record.lc_color_seed.proof_digest
+    for record in catalog.quantum_flows:
+        yield record.predicate_digest
+    for record in catalog.propagators:
+        yield from _present(
+            record.numerator_expression_digest, record.denominator_expression_digest
+        )
+    for record in catalog.color_contractions:
+        yield record.expression_digest
+        yield from (witness.proof_digest for witness in record.transition_witnesses)
+    for record in catalog.symmetry_proofs:
+        yield record.witness_digest
+        yield from record.expression_digests
+    for record in catalog.runtime_helicity_contracts:
+        yield record.proof_digest
+        yield from (variant.proof_digest for variant in record.variants)
+    for record in catalog.evaluator_bindings:
+        yield record.callable_signature
+        yield from record.exact_expression_digests
+
+
+def _all_factors(
+    catalog: RecurrenceTemplateCatalog,
+) -> Iterable[ExactComplexRationalV1]:
+    for record in catalog.parameters:
+        if record.default_value is not None:
+            yield record.default_value
+    for record in catalog.transitions:
+        yield record.binding_coupling
+        yield record.exact_factor
+        if record.input_exchange_factor is not None:
+            yield record.input_exchange_factor
+    for record in catalog.contact_orbit_certificates:
+        yield record.reconstruction_factor
+    for record in catalog.contact_orbit_steps:
+        yield record.reconstruction_factor
+    for record in catalog.quantum_flows:
+        yield record.exact_coupling
+    for record in catalog.closures:
+        yield record.binding_coupling
+        yield record.exact_factor
+        if record.input_exchange_factor is not None:
+            yield record.input_exchange_factor
+        yield from record.component_coefficients
+    for record in catalog.color_contractions:
+        yield record.exact_coefficient
+        yield from (factor for _, factor in record.nc_polynomial)
+        yield from (witness.exact_factor for witness in record.transition_witnesses)
+    for record in catalog.symmetry_proofs:
+        yield record.exact_phase
+    for record in catalog.runtime_helicity_contracts:
+        for variant in record.variants:
+            yield from variant.embedding_factors
+
+
+def _all_coupling_orders(
+    catalog: RecurrenceTemplateCatalog,
+) -> Iterable[Sequence[tuple[str, int]]]:
+    yield ()
+    yield from (record.coupling_orders for record in catalog.quantum_flows)
+    yield from (record.coupling_orders for record in catalog.transitions)
+    yield from (record.coupling_orders for record in catalog.closures)
+
+
+def _all_u32_sequences(
+    catalog: RecurrenceTemplateCatalog,
+    ids: dict[str, dict[str, int]],
+    strings: _StringCatalog,
+    digests: _DigestCatalog,
+    factors: _FactorCatalog,
+    flavour_flows: _SequenceCatalog,
+    quantum_number_flows: _QuantumNumberFlowCatalog,
+) -> Iterable[Sequence[int]]:
+    yield ()
+    for record in catalog.parameters:
+        yield tuple(
+            ids["parameters"][value] for value in record.dependency_parameter_ids
+        )
+    for record in catalog.current_states:
+        yield tuple(strings.id(value) for value in record.tensor_ordering)
+    for record in catalog.sources:
+        yield tuple(
+            strings.id(item)
+            for pair in record.lc_color_seed.provenance
+            for item in pair
+        )
+    for record in catalog.quantum_flows:
+        yield tuple(
+            ids["current_states"][value] for value in record.input_state_template_ids
+        )
+        yield tuple(flavour_flows.id(value) for value in record.input_flavour_flows)
+        yield tuple(
+            quantum_number_flows.id(value)
+            for value in record.input_quantum_number_flows
+        )
+    for record in catalog.transitions:
+        yield tuple(
+            ids["current_states"][value] for value in record.input_state_template_ids
+        )
+        yield record.canonical_input_order
+        yield tuple(strings.id(value) for value in record.momentum_convention)
+        yield tuple(ids["parameters"][value] for value in record.coupling_parameter_ids)
+        yield tuple(
+            ids["contact_orbit_steps"][value]
+            for value in record.contact_orbit_step_template_ids
+        )
+        yield tuple(
+            digests.id(value)
+            for value in record.contact_orbit_step_semantic_digests
+        )
+    for record in catalog.contact_orbit_certificates:
+        yield tuple(strings.id(value) for value in record.particles)
+        yield record.physical_leg_equivalence_classes
+    for record in catalog.contact_orbit_steps:
+        yield record.left_covered_legs
+        yield record.right_covered_legs
+    for record in catalog.closures:
+        yield tuple(
+            ids["current_states"][value] for value in record.input_state_template_ids
+        )
+        yield record.canonical_input_order
+        yield tuple(ids["parameters"][value] for value in record.coupling_parameter_ids)
+        yield tuple(
+            ids["quantum_flows"][value]
+            for value in record.eligible_quantum_flow_template_ids
+        )
+        yield tuple(factors.id(value) for value in record.component_coefficients)
+    for record in catalog.color_contractions:
+        for witness in record.transition_witnesses:
+            yield tuple(
+                value
+                for pairing in witness.input_port_pairings
+                for port in pairing
+                for value in port
+            )
+            yield tuple(
+                value for port in witness.result_port_bindings for value in port
+            )
+            yield tuple(
+                strings.id(item) for pair in witness.provenance for item in pair
+            )
+    for record in catalog.symmetry_proofs:
+        yield tuple(strings.id(value) for value in record.subject_template_ids)
+        yield record.input_permutation
+        yield tuple(digests.id(value) for value in record.expression_digests)
+    for record in catalog.evaluator_bindings:
+        yield tuple(
+            ids["current_states"][value] for value in record.input_state_template_ids
+        )
+        yield tuple(strings.id(value) for value in record.input_layout)
+        yield tuple(strings.id(value) for value in record.output_layout)
+        yield tuple(digests.id(value) for value in record.exact_expression_digests)
+        yield tuple(strings.id(value) for value in record.semantic_template_ids)
+
+
+def _all_i32_sequences(catalog: RecurrenceTemplateCatalog) -> Iterable[Sequence[int]]:
+    yield ()
+    yield from (record.input_spin_states for record in catalog.quantum_flows)
+    yield from (record.input_representations for record in catalog.color_contractions)
+    yield from (
+        record.source_particle_legs for record in catalog.contact_orbit_steps
+    )
+
+
+def _all_flavour_flows(
+    catalog: RecurrenceTemplateCatalog,
+) -> Iterable[Sequence[int]]:
+    yield from (record.flavour_flow for record in catalog.sources)
+    for record in catalog.quantum_flows:
+        yield from record.input_flavour_flows
+        yield record.result_flavour_flow
+
+
+def _all_quantum_number_flows(
+    catalog: RecurrenceTemplateCatalog,
+) -> Iterable[Sequence[tuple[str, str]]]:
+    yield from (record.quantum_number_flow for record in catalog.sources)
+    for record in catalog.quantum_flows:
+        yield from record.input_quantum_number_flows
+        yield record.result_quantum_number_flow
+
+
+def _header_table(catalog, strings, digests, sections):
+    names = (
+        "schema_version",
+        "abi_string_id",
+        "canonicalization_abi_string_id",
+        "exact_scalar_abi_string_id",
+        "compiled_model_digest_id",
+        "prepared_kernel_pack_digest_id",
+        "catalog_digest_id",
+        "parameter_count",
+        "current_state_count",
+        "source_count",
+        "quantum_flow_count",
+        "contact_orbit_certificate_count",
+        "contact_orbit_step_count",
+        "transition_count",
+        "propagator_count",
+        "closure_count",
+        "color_contraction_count",
+        "symmetry_proof_count",
+        "runtime_helicity_contract_count",
+        "evaluator_binding_count",
+    )
+    values = (
+        RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION,
+        strings.id(catalog.header.abi),
+        strings.id(catalog.header.canonicalization_abi),
+        strings.id(catalog.header.exact_scalar_abi),
+        digests.id(catalog.header.compiled_model_digest),
+        digests.id(catalog.header.prepared_kernel_pack_digest),
+        digests.id(catalog.header.catalog_digest),
+        *(len(sections[name]) for name in sections),
+    )
+    return _table(
+        "catalog_header",
+        {
+            name: _array([value], _U32)
+            for name, value in zip(names, values, strict=True)
+        },
+    )
+
+
+def _parameters_table(catalog, ids, strings, digests, factors, sequences):
+    rows = []
+    for index, record in enumerate(catalog.parameters):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                strings.id(record.name),
+                _PARAMETER_KIND[record.parameter_kind],
+                _PARAMETER_VALUE_TYPE[record.value_type],
+                int(record.mutable),
+                factors.id(record.default_value),
+                digests.id(record.exact_expression_digest),
+                sequences.id(
+                    tuple(
+                        ids["parameters"][value]
+                        for value in record.dependency_parameter_ids
+                    )
+                ),
+                MISSING_U32
+                if record.prepared_parameter_id is None
+                else record.prepared_parameter_id,
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "parameters",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("name_string_id", _U32),
+            ("kind", _U8),
+            ("value_type", _U8),
+            ("mutable", _U8),
+            ("default_factor_id", _U32),
+            ("exact_expression_digest_id", _U32),
+            ("dependency_sequence_id", _U32),
+            ("prepared_parameter_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _current_states_table(catalog, ids, strings, digests, sequences):
+    del ids
+    rows = []
+    parameter_ids = {
+        record.template_id: i for i, record in enumerate(catalog.parameters)
+    }
+    for index, record in enumerate(catalog.current_states):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                record.particle_id,
+                record.anti_particle_id,
+                strings.id(record.species_id),
+                _ORIENTATION[record.orientation],
+                _STATISTICS[record.statistics],
+                record.color_representation,
+                strings.id(record.basis),
+                sequences.id(
+                    tuple(strings.id(value) for value in record.tensor_ordering)
+                ),
+                record.dimension,
+                record.chirality,
+                strings.id(record.lc_color_shape_kind),
+                strings.id(record.auxiliary_kind),
+                _optional_reference(record.mass_parameter_id, parameter_ids),
+                _optional_reference(record.width_parameter_id, parameter_ids),
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "current_states",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("particle_id", _I32),
+            ("anti_particle_id", _I32),
+            ("species_string_id", _U32),
+            ("orientation", _U8),
+            ("statistics", _U8),
+            ("color_representation", _I32),
+            ("basis_string_id", _U32),
+            ("tensor_ordering_sequence_id", _U32),
+            ("dimension", _U32),
+            ("chirality", _I32),
+            ("lc_color_shape_string_id", _U32),
+            ("auxiliary_kind_string_id", _U32),
+            ("mass_parameter_id", _U32),
+            ("width_parameter_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _runtime_helicity_tables(catalog, ids, strings, digests, factors):
+    contract_rows = []
+    variant_rows = []
+    embedding_rows = []
+    projection_rows = []
+    variant_offset = 0
+    embedding_offset = 0
+    projection_offset = 0
+    for contract_id, contract in enumerate(catalog.runtime_helicity_contracts):
+        contract_rows.append(
+            (
+                contract_id,
+                strings.id(contract.template_id),
+                ids["current_states"][contract.full_state_template_id],
+                variant_offset,
+                len(contract.variants),
+                strings.id(contract.proof_algorithm),
+                digests.id(contract.proof_digest),
+                digests.id(contract.semantic_digest),
+            )
+        )
+        for variant in contract.variants:
+            variant_id = len(variant_rows)
+            variant_rows.append(
+                (
+                    variant_id,
+                    contract_id,
+                    ids["sources"][variant.source_template_id],
+                    ids["current_states"][variant.source_state_template_id],
+                    embedding_offset,
+                    len(variant.embedding_source_components),
+                    projection_offset,
+                    len(variant.projection_full_components),
+                    digests.id(variant.proof_digest),
+                )
+            )
+            for full_component, (source_component, factor) in enumerate(
+                zip(
+                    variant.embedding_source_components,
+                    variant.embedding_factors,
+                    strict=True,
+                )
+            ):
+                embedding_rows.append(
+                    (
+                        variant_id,
+                        full_component,
+                        MISSING_U32 if source_component is None else source_component,
+                        factors.id(factor),
+                    )
+                )
+            for source_component, full_component in enumerate(
+                variant.projection_full_components
+            ):
+                projection_rows.append((variant_id, source_component, full_component))
+            embedding_offset += len(variant.embedding_source_components)
+            projection_offset += len(variant.projection_full_components)
+        variant_offset += len(contract.variants)
+    return (
+        _rows(
+            "runtime_helicity_contracts",
+            contract_rows,
+            (
+                ("id", _U32),
+                ("template_string_id", _U32),
+                ("full_state_template_id", _U32),
+                ("variant_offset", _U32),
+                ("variant_count", _U32),
+                ("proof_algorithm_string_id", _U32),
+                ("proof_digest_id", _U32),
+                ("semantic_digest_id", _U32),
+            ),
+        ),
+        _rows(
+            "runtime_helicity_variants",
+            variant_rows,
+            (
+                ("id", _U32),
+                ("contract_id", _U32),
+                ("source_template_id", _U32),
+                ("source_state_template_id", _U32),
+                ("embedding_offset", _U32),
+                ("embedding_count", _U32),
+                ("projection_offset", _U32),
+                ("projection_count", _U32),
+                ("proof_digest_id", _U32),
+            ),
+        ),
+        _rows(
+            "runtime_helicity_embeddings",
+            embedding_rows,
+            (
+                ("variant_id", _U32),
+                ("full_component", _U32),
+                ("source_component", _U32),
+                ("factor_id", _U32),
+            ),
+        ),
+        _rows(
+            "runtime_helicity_projections",
+            projection_rows,
+            (
+                ("variant_id", _U32),
+                ("source_component", _U32),
+                ("full_component", _U32),
+            ),
+        ),
+    )
+
+
+def _sources_table(
+    catalog,
+    ids,
+    strings,
+    digests,
+    flavour_flows,
+    quantum_number_flows,
+    sequences,
+):
+    parameter_ids = ids["parameters"]
+    rows = []
+    for index, record in enumerate(catalog.sources):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                ids["current_states"][record.state_template_id],
+                strings.id(record.crossing),
+                strings.id(record.wavefunction_family),
+                record.helicity,
+                record.spin_state,
+                flavour_flows.id(record.flavour_flow),
+                quantum_number_flows.id(record.quantum_number_flow),
+                _LC_COLOR_SOURCE_SEED_OPERATION[record.lc_color_seed.operation],
+                strings.id(record.lc_color_seed.output_shape_kind),
+                (
+                    255
+                    if record.lc_color_seed.component_kind is None
+                    else _LC_COLOR_COMPONENT_KIND[record.lc_color_seed.component_kind]
+                ),
+                _LC_COLOR_COMPONENT_ROLE[record.lc_color_seed.component_role],
+                digests.id(record.lc_color_seed.proof_digest),
+                sequences.id(
+                    tuple(
+                        strings.id(item)
+                        for pair in record.lc_color_seed.provenance
+                        for item in pair
+                    )
+                ),
+                digests.id(record.wavefunction_expression_digest),
+                ids["evaluator_bindings"][record.evaluator_resolver_key],
+                _optional_reference(record.mass_parameter_id, parameter_ids),
+                _optional_reference(record.width_parameter_id, parameter_ids),
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "sources",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("state_template_id", _U32),
+            ("crossing_string_id", _U32),
+            ("wavefunction_family_string_id", _U32),
+            ("helicity", _I32),
+            ("spin_state", _I32),
+            ("flavour_flow_id", _U32),
+            ("quantum_number_flow_id", _U32),
+            ("lc_color_seed_operation", _U8),
+            ("lc_color_seed_shape_string_id", _U32),
+            ("lc_color_seed_component_kind", _U8),
+            ("lc_color_seed_component_role", _U8),
+            ("lc_color_seed_proof_digest_id", _U32),
+            ("lc_color_seed_provenance_sequence_id", _U32),
+            ("wavefunction_expression_digest_id", _U32),
+            ("evaluator_binding_id", _U32),
+            ("mass_parameter_id", _U32),
+            ("width_parameter_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _quantum_flows_table(
+    catalog,
+    ids,
+    strings,
+    digests,
+    factors,
+    u32_sequences,
+    i32_sequences,
+    coupling_orders,
+    flavour_flows,
+    quantum_number_flows,
+):
+    rows = []
+    for index, record in enumerate(catalog.quantum_flows):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                u32_sequences.id(
+                    tuple(
+                        ids["current_states"][value]
+                        for value in record.input_state_template_ids
+                    )
+                ),
+                i32_sequences.id(record.input_spin_states),
+                u32_sequences.id(
+                    tuple(
+                        flavour_flows.id(value) for value in record.input_flavour_flows
+                    )
+                ),
+                u32_sequences.id(
+                    tuple(
+                        quantum_number_flows.id(value)
+                        for value in record.input_quantum_number_flows
+                    )
+                ),
+                strings.id(record.flavour_flow_operation),
+                strings.id(record.quantum_number_flow_operation),
+                coupling_orders.id(record.coupling_orders),
+                ids["current_states"][record.result_state_template_id],
+                record.result_spin_state,
+                flavour_flows.id(record.result_flavour_flow),
+                quantum_number_flows.id(record.result_quantum_number_flow),
+                factors.id(record.exact_coupling),
+                digests.id(record.predicate_digest),
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "quantum_flows",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("input_state_sequence_id", _U32),
+            ("input_spin_sequence_id", _U32),
+            ("input_flavour_sequence_id", _U32),
+            ("input_quantum_sequence_id", _U32),
+            ("flavour_flow_operation_string_id", _U32),
+            ("quantum_number_flow_operation_string_id", _U32),
+            ("coupling_order_set_id", _U32),
+            ("result_state_template_id", _U32),
+            ("result_spin_state", _I32),
+            ("result_flavour_flow_id", _U32),
+            ("result_quantum_number_flow_id", _U32),
+            ("exact_coupling_factor_id", _U32),
+            ("predicate_digest_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _transitions_table(
+    catalog, ids, strings, digests, factors, sequences, coupling_orders
+):
+    rows = []
+    for index, record in enumerate(catalog.transitions):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                sequences.id(
+                    tuple(
+                        ids["current_states"][value]
+                        for value in record.input_state_template_ids
+                    )
+                ),
+                ids["current_states"][record.result_state_template_id],
+                ids["quantum_flows"][record.quantum_flow_template_id],
+                ids["evaluator_bindings"][record.evaluator_resolver_key],
+                sequences.id(record.canonical_input_order),
+                sequences.id(
+                    tuple(strings.id(value) for value in record.momentum_convention)
+                ),
+                sequences.id(
+                    tuple(
+                        ids["parameters"][value]
+                        for value in record.coupling_parameter_ids
+                    )
+                ),
+                coupling_orders.id(record.coupling_orders),
+                ids["color_contractions"][record.color_contraction_template_id],
+                factors.id(record.binding_coupling),
+                factors.id(record.exact_factor),
+                _OUTPUT_FACTOR_SOURCE[record.output_factor_source],
+                strings.id(record.equivalence_class),
+                factors.id(record.input_exchange_factor),
+                strings.id(record.output_projection),
+                sequences.id(
+                    tuple(
+                        ids["contact_orbit_steps"][value]
+                        for value in record.contact_orbit_step_template_ids
+                    )
+                ),
+                sequences.id(
+                    tuple(
+                        digests.id(value)
+                        for value in record.contact_orbit_step_semantic_digests
+                    )
+                ),
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "transitions",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("input_state_sequence_id", _U32),
+            ("result_state_template_id", _U32),
+            ("quantum_flow_template_id", _U32),
+            ("evaluator_binding_id", _U32),
+            ("canonical_input_order_sequence_id", _U32),
+            ("momentum_convention_sequence_id", _U32),
+            ("coupling_parameter_sequence_id", _U32),
+            ("coupling_order_set_id", _U32),
+            ("color_contraction_template_id", _U32),
+            ("binding_coupling_factor_id", _U32),
+            ("exact_factor_id", _U32),
+            ("output_factor_source", _U8),
+            ("equivalence_class_string_id", _U32),
+            ("input_exchange_factor_id", _U32),
+            ("output_projection_string_id", _U32),
+            ("contact_orbit_step_sequence_id", _U32),
+            ("contact_orbit_step_semantic_digest_sequence_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _contact_orbit_certificates_table(
+    catalog, strings, digests, factors, sequences
+):
+    rows = []
+    for index, record in enumerate(catalog.contact_orbit_certificates):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                strings.id(record.algorithm),
+                record.algorithm_version,
+                record.term_id,
+                strings.id(record.vertex),
+                sequences.id(tuple(strings.id(value) for value in record.particles)),
+                strings.id(record.evaluator_class),
+                sequences.id(record.physical_leg_equivalence_classes),
+                factors.id(record.reconstruction_factor),
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "contact_orbit_certificates",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("algorithm_string_id", _U32),
+            ("algorithm_version", _U32),
+            ("term_id", _U32),
+            ("vertex_string_id", _U32),
+            ("particle_string_sequence_id", _U32),
+            ("evaluator_class_string_id", _U32),
+            ("physical_leg_equivalence_sequence_id", _U32),
+            ("reconstruction_factor_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _contact_orbit_steps_table(
+    catalog, ids, strings, digests, factors, u32_sequences, i32_sequences
+):
+    rows = []
+    stage_ids = {"partial": 0, "final": 1}
+    for index, record in enumerate(catalog.contact_orbit_steps):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                ids["contact_orbit_certificates"][record.certificate_template_id],
+                stage_ids[record.stage],
+                record.result_leg,
+                u32_sequences.id(record.left_covered_legs),
+                u32_sequences.id(record.right_covered_legs),
+                i32_sequences.id(record.source_particle_legs),
+                factors.id(record.reconstruction_factor),
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "contact_orbit_steps",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("certificate_id", _U32),
+            ("stage", _U8),
+            ("result_leg", _U8),
+            ("left_covered_leg_sequence_id", _U32),
+            ("right_covered_leg_sequence_id", _U32),
+            ("source_particle_leg_sequence_id", _U32),
+            ("reconstruction_factor_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _propagators_table(catalog, ids, strings, digests):
+    rows = []
+    for index, record in enumerate(catalog.propagators):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                ids["current_states"][record.state_template_id],
+                int(record.applies_propagator),
+                _optional_reference(
+                    record.evaluator_resolver_key, ids["evaluator_bindings"]
+                ),
+                digests.id(record.numerator_expression_digest),
+                digests.id(record.denominator_expression_digest),
+                _optional_reference(record.mass_parameter_id, ids["parameters"]),
+                _optional_reference(record.width_parameter_id, ids["parameters"]),
+                strings.id(record.gauge),
+                _optional_reference(
+                    record.linearity_proof_template_id, ids["symmetry_proofs"]
+                ),
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "propagators",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("state_template_id", _U32),
+            ("applies_propagator", _U8),
+            ("evaluator_binding_id", _U32),
+            ("numerator_expression_digest_id", _U32),
+            ("denominator_expression_digest_id", _U32),
+            ("mass_parameter_id", _U32),
+            ("width_parameter_id", _U32),
+            ("gauge_string_id", _U32),
+            ("linearity_proof_template_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _closures_table(
+    catalog, ids, strings, digests, factors, sequences, coupling_orders
+):
+    rows = []
+    for index, record in enumerate(catalog.closures):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                sequences.id(
+                    tuple(
+                        ids["current_states"][value]
+                        for value in record.input_state_template_ids
+                    )
+                ),
+                _optional_reference(
+                    record.result_state_template_id, ids["current_states"]
+                ),
+                ids["evaluator_bindings"][record.evaluator_resolver_key],
+                sequences.id(record.canonical_input_order),
+                sequences.id(
+                    tuple(
+                        ids["parameters"][value]
+                        for value in record.coupling_parameter_ids
+                    )
+                ),
+                coupling_orders.id(record.coupling_orders),
+                sequences.id(
+                    tuple(
+                        ids["quantum_flows"][value]
+                        for value in record.eligible_quantum_flow_template_ids
+                    )
+                ),
+                ids["color_contractions"][record.color_contraction_template_id],
+                factors.id(record.binding_coupling),
+                factors.id(record.exact_factor),
+                _OUTPUT_FACTOR_SOURCE[record.output_factor_source],
+                strings.id(record.equivalence_class),
+                factors.id(record.input_exchange_factor),
+                strings.id(record.projection),
+                sequences.id(
+                    tuple(factors.id(value) for value in record.component_coefficients)
+                ),
+                strings.id(record.chirality_relation),
+                strings.id(record.metric_signature),
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "closures",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("input_state_sequence_id", _U32),
+            ("result_state_template_id", _U32),
+            ("evaluator_binding_id", _U32),
+            ("canonical_input_order_sequence_id", _U32),
+            ("coupling_parameter_sequence_id", _U32),
+            ("coupling_order_set_id", _U32),
+            ("eligible_quantum_flow_sequence_id", _U32),
+            ("color_contraction_template_id", _U32),
+            ("binding_coupling_factor_id", _U32),
+            ("exact_factor_id", _U32),
+            ("output_factor_source", _U8),
+            ("equivalence_class_string_id", _U32),
+            ("input_exchange_factor_id", _U32),
+            ("projection_string_id", _U32),
+            ("component_coefficient_sequence_id", _U32),
+            ("chirality_relation_string_id", _U32),
+            ("metric_signature_string_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _color_contractions_table(catalog, strings, digests, factors, i32_sequences):
+    rows = []
+    witness_offset = 0
+    nc_offset = 0
+    for index, record in enumerate(catalog.color_contractions):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                strings.id(record.rule_kind),
+                i32_sequences.id(record.input_representations),
+                int(record.output_representation is not None),
+                0
+                if record.output_representation is None
+                else record.output_representation,
+                record.ordered_open_string_arity,
+                factors.id(record.exact_coefficient),
+                witness_offset,
+                len(record.transition_witnesses),
+                nc_offset,
+                len(record.nc_polynomial),
+                digests.id(record.expression_digest),
+                digests.id(record.semantic_digest),
+            )
+        )
+        witness_offset += len(record.transition_witnesses)
+        nc_offset += len(record.nc_polynomial)
+    return _rows(
+        "color_contractions",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("rule_kind_string_id", _U32),
+            ("input_representation_sequence_id", _U32),
+            ("has_output_representation", _U8),
+            ("output_representation", _I32),
+            ("ordered_open_string_arity", _U32),
+            ("exact_coefficient_factor_id", _U32),
+            ("witness_start", _U64),
+            ("witness_count", _U64),
+            ("nc_term_start", _U64),
+            ("nc_term_count", _U64),
+            ("expression_digest_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _lc_color_transition_witnesses_table(
+    catalog,
+    strings,
+    digests,
+    factors,
+    sequences,
+):
+    rows = []
+    for color_id, record in enumerate(catalog.color_contractions):
+        for ordinal, witness in enumerate(record.transition_witnesses):
+            rows.append(
+                (
+                    color_id,
+                    ordinal,
+                    strings.id(witness.input_shape_kinds[0]),
+                    strings.id(witness.input_shape_kinds[1]),
+                    0 if witness.input_permutation == (0, 1) else 1,
+                    witness.reverse_parent_mask,
+                    _LC_COLOR_COMPONENT_OPERATION[witness.component_operation],
+                    (
+                        255
+                        if witness.result_component_kind is None
+                        else _LC_COLOR_COMPONENT_KIND[witness.result_component_kind]
+                    ),
+                    _LC_COLOR_COMPONENT_ROLE[witness.result_component_role],
+                    strings.id(witness.result_shape_kind),
+                    factors.id(witness.exact_factor),
+                    digests.id(witness.proof_digest),
+                    sequences.id(
+                        tuple(
+                            value
+                            for pairing in witness.input_port_pairings
+                            for port in pairing
+                            for value in port
+                        )
+                    ),
+                    sequences.id(
+                        tuple(
+                            value
+                            for port in witness.result_port_bindings
+                            for value in port
+                        )
+                    ),
+                    sequences.id(
+                        tuple(
+                            strings.id(item)
+                            for pair in witness.provenance
+                            for item in pair
+                        )
+                    ),
+                )
+            )
+    return _rows(
+        "lc_color_transition_witnesses",
+        rows,
+        (
+            ("color_contraction_id", _U32),
+            ("ordinal", _U32),
+            ("left_shape_string_id", _U32),
+            ("right_shape_string_id", _U32),
+            ("input_permutation", _U8),
+            ("reverse_parent_mask", _U8),
+            ("component_operation", _U8),
+            ("result_component_kind", _U8),
+            ("result_component_role", _U8),
+            ("result_shape_string_id", _U32),
+            ("exact_factor_id", _U32),
+            ("proof_digest_id", _U32),
+            ("input_port_pairing_sequence_id", _U32),
+            ("result_port_binding_sequence_id", _U32),
+            ("provenance_sequence_id", _U32),
+        ),
+    )
+
+
+def _color_nc_terms_table(catalog, factors):
+    rows = [
+        (color_id, exponent, factors.id(factor))
+        for color_id, record in enumerate(catalog.color_contractions)
+        for exponent, factor in record.nc_polynomial
+    ]
+    return _rows(
+        "color_nc_terms",
+        rows,
+        (
+            ("color_contraction_id", _U32),
+            ("exponent", _I32),
+            ("factor_id", _U32),
+        ),
+    )
+
+
+def _symmetry_proofs_table(catalog, strings, digests, factors, sequences):
+    rows = []
+    for index, record in enumerate(catalog.symmetry_proofs):
+        rows.append(
+            (
+                index,
+                strings.id(record.template_id),
+                strings.id(record.proof_algorithm),
+                sequences.id(
+                    tuple(strings.id(value) for value in record.subject_template_ids)
+                ),
+                sequences.id(record.input_permutation),
+                factors.id(record.exact_phase),
+                sequences.id(
+                    tuple(digests.id(value) for value in record.expression_digests)
+                ),
+                digests.id(record.witness_digest),
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "symmetry_proofs",
+        rows,
+        (
+            ("id", _U32),
+            ("template_string_id", _U32),
+            ("proof_algorithm_string_id", _U32),
+            ("subject_template_sequence_id", _U32),
+            ("input_permutation_sequence_id", _U32),
+            ("exact_phase_factor_id", _U32),
+            ("expression_digest_sequence_id", _U32),
+            ("witness_digest_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _evaluator_bindings_table(catalog, ids, strings, digests, sequences):
+    rows = []
+    for index, record in enumerate(catalog.evaluator_bindings):
+        rows.append(
+            (
+                index,
+                strings.id(record.resolver_key),
+                MISSING_U32
+                if record.prepared_kernel_id is None
+                else record.prepared_kernel_id,
+                _CONTRACT_KIND[record.contract_kind],
+                digests.id(record.callable_signature),
+                sequences.id(
+                    tuple(
+                        ids["current_states"][value]
+                        for value in record.input_state_template_ids
+                    )
+                ),
+                _optional_reference(
+                    record.output_state_template_id, ids["current_states"]
+                ),
+                sequences.id(tuple(strings.id(value) for value in record.input_layout)),
+                sequences.id(
+                    tuple(strings.id(value) for value in record.output_layout)
+                ),
+                sequences.id(
+                    tuple(
+                        digests.id(value) for value in record.exact_expression_digests
+                    )
+                ),
+                sequences.id(
+                    tuple(strings.id(value) for value in record.semantic_template_ids)
+                ),
+                _CALLABLE_KIND[record.callable_kind],
+                strings.id(record.runtime_template),
+                digests.id(record.semantic_digest),
+            )
+        )
+    return _rows(
+        "evaluator_bindings",
+        rows,
+        (
+            ("id", _U32),
+            ("resolver_key_string_id", _U32),
+            ("prepared_kernel_id", _U32),
+            ("contract_kind", _U8),
+            ("callable_signature_digest_id", _U32),
+            ("input_state_sequence_id", _U32),
+            ("output_state_template_id", _U32),
+            ("input_layout_sequence_id", _U32),
+            ("output_layout_sequence_id", _U32),
+            ("exact_expression_digest_sequence_id", _U32),
+            ("semantic_template_sequence_id", _U32),
+            ("callable_kind", _U8),
+            ("runtime_template_string_id", _U32),
+            ("semantic_digest_id", _U32),
+        ),
+    )
+
+
+def _coupling_order_terms(catalog: _CouplingOrderCatalog, strings: _StringCatalog):
+    rows = [
+        (set_id, strings.id(name), power)
+        for set_id, values in enumerate(catalog.values)
+        for name, power in values
+    ]
+    return _rows(
+        "coupling_order_terms",
+        rows,
+        (
+            ("set_id", _U32),
+            ("name_string_id", _U32),
+            ("power", _U32),
+        ),
+    )
+
+
+def _catalog_ranges(prefix: str, values: Sequence[Sequence[object]], _width: int):
+    del _width
+    rows = []
+    offset = 0
+    for index, value in enumerate(values):
+        rows.append((index, offset, len(value)))
+        offset += len(value)
+    return _rows(
+        f"{prefix}_ranges", rows, (("id", _U32), ("start", _U64), ("count", _U64))
+    )
+
+
+def _flatten_sequence_tables(
+    prefix: str,
+    catalog: _SequenceCatalog,
+    dtype: np.dtype[Any],
+) -> tuple[RecurrenceColumnarTable, RecurrenceColumnarTable]:
+    ranges = _catalog_ranges(prefix, catalog.values, 1)
+    values = _table(
+        f"{prefix}_values",
+        {
+            "value": _array(
+                [value for sequence in catalog.values for value in sequence], dtype
+            )
+        },
+    )
+    return ranges, values
+
+
+def _quantum_number_flow_ranges(
+    catalog: _QuantumNumberFlowCatalog,
+) -> RecurrenceColumnarTable:
+    return _catalog_ranges("quantum_number_flow", catalog.values, 2)
+
+
+def _quantum_number_flow_terms(
+    catalog: _QuantumNumberFlowCatalog,
+    strings: _StringCatalog,
+) -> RecurrenceColumnarTable:
+    rows = [
+        (flow_id, strings.id(name), strings.id(expression))
+        for flow_id, flow in enumerate(catalog.values)
+        for name, expression in flow
+    ]
+    return _rows(
+        "quantum_number_flow_terms",
+        rows,
+        (
+            ("flow_id", _U32),
+            ("name_string_id", _U32),
+            ("expression_string_id", _U32),
+        ),
+    )
+
+
+def _string_tables(
+    strings: _StringCatalog,
+) -> tuple[RecurrenceColumnarTable, RecurrenceColumnarTable]:
+    encoded = tuple(value.encode("utf-8") for value in strings.values)
+    ranges = []
+    offset = 0
+    for value in encoded:
+        ranges.append((offset, len(value)))
+        offset += len(value)
+    return (
+        _rows("string_ranges", ranges, (("start", _U64), ("count", _U64))),
+        _table("string_bytes", {"value": _array(b"".join(encoded), _U8)}),
+    )
+
+
+def _digest_table(catalog: _DigestCatalog) -> RecurrenceColumnarTable:
+    values = np.empty((len(catalog.values), 32), dtype=_U8)
+    for row, value in enumerate(catalog.values):
+        values[row, :] = np.frombuffer(bytes.fromhex(value), dtype=_U8)
+    return _table(
+        "digest_catalog",
+        {"id": _array(range(len(catalog.values)), _U32), "value": values},
+    )
+
+
+def _exact_factor_table(catalog: _FactorCatalog, strings: _StringCatalog):
+    rows = [
+        (index, *(strings.id(str(value)) for value in _factor_key(factor)))
+        for index, factor in enumerate(catalog.values)
+    ]
+    return _rows(
+        "exact_factors",
+        rows,
+        (
+            ("id", _U32),
+            ("real_numerator_string_id", _U32),
+            ("real_denominator_string_id", _U32),
+            ("imag_numerator_string_id", _U32),
+            ("imag_denominator_string_id", _U32),
+        ),
+    )
+
+
+def _table(
+    name: str, columns: dict[str, np.ndarray[Any, Any]]
+) -> RecurrenceColumnarTable:
+    frozen = []
+    for column_name, values in columns.items():
+        owned = (
+            values
+            if values.flags.owndata and values.flags.c_contiguous
+            else np.ascontiguousarray(values).copy()
+        )
+        owned.flags.writeable = False
+        frozen.append(RecurrenceColumn(column_name, owned))
+    row_count = 0 if not frozen else len(frozen[0].values)
+    return RecurrenceColumnarTable(name, row_count, tuple(frozen))
+
+
+def _rows(
+    name: str,
+    rows: Sequence[Sequence[int]],
+    schema: Sequence[tuple[str, np.dtype[Any]]],
+):
+    columns = {
+        column_name: _array(
+            (row[index] for row in rows),
+            dtype,
+            context=f"{name}.{column_name}",
+        )
+        for index, (column_name, dtype) in enumerate(schema)
+    }
+    return _table(name, columns)
+
+
+def _array(
+    values: Iterable[int] | bytes,
+    dtype: np.dtype[Any],
+    *,
+    context: str = "recurrence template column",
+) -> np.ndarray[Any, Any]:
+    if isinstance(values, bytes):
+        return np.frombuffer(values, dtype=_U8).copy()
+    materialized = tuple(values)
+    limits = np.iinfo(dtype)
+    checked: list[int] = []
+    for row, value in enumerate(materialized):
+        try:
+            integer = operator.index(value)
+        except TypeError as error:
+            raise RecurrenceColumnarInputError(
+                f"{context} row {row} must be an integer, got {value!r}"
+            ) from error
+        if integer < limits.min or integer > limits.max:
+            raise RecurrenceColumnarInputError(
+                f"{context} row {row} value {integer} does not fit {dtype.str}"
+            )
+        checked.append(integer)
+    return np.asarray(checked, dtype=dtype)
+
+
+def _optional_reference(value: str | None, values: dict[str, int]) -> int:
+    return MISSING_U32 if value is None else values[value]
+
+
+def _present(*values: str | None) -> Iterable[str]:
+    return (value for value in values if value is not None)
+
+
+def _factor_key(value: ExactComplexRationalV1) -> tuple[int, int, int, int]:
+    return (
+        value.real_numerator,
+        value.real_denominator,
+        value.imag_numerator,
+        value.imag_denominator,
+    )
+
+
+def _validate_i128_factors(catalog: RecurrenceTemplateCatalog) -> None:
+    for factor_index, factor in enumerate(_all_factors(catalog)):
+        for component in (
+            "real_numerator",
+            "real_denominator",
+            "imag_numerator",
+            "imag_denominator",
+        ):
+            value = getattr(factor, component)
+            if value < _I128_MIN or value > _I128_MAX:
+                raise RecurrenceColumnarInputError(
+                    "recurrence exact factor cannot cross the Rust ABI as i128: "
+                    f"factor {factor_index} {component}={value}"
+                )
+
+
+def _require_sha256(value: str, context: str) -> None:
+    if len(value) != 64 or any(
+        character not in "0123456789abcdef" for character in value
+    ):
+        raise RecurrenceColumnarInputError(f"{context} must be a lowercase SHA-256")
+
+
+def _hash_text(digest: Any, value: str) -> None:
+    encoded = value.encode("utf-8")
+    digest.update(len(encoded).to_bytes(8, "little"))
+    digest.update(encoded)
+
+
+__all__ = [
+    "RECURRENCE_TEMPLATE_INPUT_ABI",
+    "RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION",
+    "RecurrenceTemplateInputV1",
+    "build_recurrence_template_input_v1",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/runtime_amplitudes.py b/pyamplicol/src/pyamplicol/generation/runtime_amplitudes.py
new file mode 100644
index 0000000000..59d72fb488
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/runtime_amplitudes.py
@@ -0,0 +1,740 @@
+# SPDX-License-Identifier: 0BSD
+"""Amplitude grouping and color-contraction runtime records."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+
+from ..color import (
+    ColorContractionPlan,
+    ColorGroupDescriptor,
+    build_color_contraction_plan,
+    build_symmetric_group_color_contraction_plan,
+)
+from ..color.plan_types import LCColorSectorReplayPartition
+from ..models.base import Model
+from .contracts import runtime_coupling_parameter_names
+from .dag_types import AmplitudeRoot, CurrentNode, GenericDAG
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeAmplitudeStageLayout:
+    """Runtime amplitude record plus its typed colour-contraction input."""
+
+    record: dict[str, object]
+    color_contraction: ColorContractionPlan | None
+    contraction_descriptors: tuple[ColorGroupDescriptor, ...]
+
+
+def build_runtime_amplitude_stage(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    current_slots: Sequence[Mapping[str, object]],
+    value_slots: Mapping[tuple[int, str], Mapping[str, object]],
+    color_contraction: str = "direct",
+) -> dict[str, object]:
+    """Build evaluator roots and physical coherent-amplitude metadata."""
+
+    return build_runtime_amplitude_stage_layout(
+        dag,
+        model,
+        current_slots=current_slots,
+        value_slots=value_slots,
+        color_contraction=color_contraction,
+    ).record
+
+
+def build_runtime_amplitude_stage_layout(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    current_slots: Sequence[Mapping[str, object]],
+    value_slots: Mapping[tuple[int, str], Mapping[str, object]],
+    color_contraction: str = "direct",
+) -> RuntimeAmplitudeStageLayout:
+    """Build an amplitude record while retaining its authenticated plan."""
+
+    metadata, contraction, contraction_descriptors = (
+        _build_runtime_amplitude_metadata_layout(
+            dag,
+            model,
+            color_contraction=color_contraction,
+        )
+    )
+    metadata_roots = _mapping_sequence(metadata["roots"])
+    roots: list[dict[str, object]] = []
+    for root, record in zip(dag.amplitude_roots, metadata_roots, strict=True):
+        roots.append(
+            {
+                "output_index": record["output_index"],
+                "root_id": record["root_id"],
+                "dag_root_id": record["dag_root_id"],
+                "kind": record["kind"],
+                "left_current_id": record["left_current_id"],
+                "right_current_id": record["right_current_id"],
+                "left_slot": _current_slot_ref(current_slots[root.left_id]),
+                "right_slot": _current_slot_ref(current_slots[root.right_id]),
+                "left_value_slot": _value_slot_ref(
+                    _amplitude_value_slot(dag.currents[root.left_id], value_slots)
+                ),
+                "right_value_slot": _value_slot_ref(
+                    _amplitude_value_slot(dag.currents[root.right_id], value_slots)
+                ),
+                "vertex_kind": record["vertex_kind"],
+                "vertex_particles": record["vertex_particles"],
+                "coupling": record["coupling"],
+                "coupling_parameter_names": record["coupling_parameter_names"],
+                "color_weight": record["color_weight"],
+                "color_sector_id": record["color_sector_id"],
+                "contraction": record["contraction"],
+                "contraction_ir": record["contraction_ir"],
+                "coherent_group_id": record["coherent_group_id"],
+                "helicity_weight": record["helicity_weight"],
+                "all_sector_weight": record["all_sector_weight"],
+            }
+        )
+    return RuntimeAmplitudeStageLayout(
+        record={**metadata, "roots": roots},
+        color_contraction=contraction,
+        contraction_descriptors=contraction_descriptors,
+    )
+
+
+def build_runtime_amplitude_metadata(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    color_contraction: str = "direct",
+) -> dict[str, object]:
+    """Build slot-free amplitude and coherent-group metadata for one DAG."""
+
+    metadata, _, _ = _build_runtime_amplitude_metadata_layout(
+        dag,
+        model,
+        color_contraction=color_contraction,
+    )
+    return metadata
+
+
+def _build_runtime_amplitude_metadata_layout(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    color_contraction: str,
+) -> tuple[
+    dict[str, object],
+    ColorContractionPlan | None,
+    tuple[ColorGroupDescriptor, ...],
+]:
+    if color_contraction not in {"direct", "symmetric-group-fft"}:
+        raise ValueError(
+            f"unsupported runtime colour contraction {color_contraction!r}"
+        )
+
+    group_ids, descriptors = _amplitude_groups(dag, dag.amplitude_roots)
+    replay = _color_topology_replay_amplitudes(dag, descriptors)
+    contraction_descriptors = (
+        descriptors if replay is None else replay.physical_descriptors
+    )
+    contraction = (
+        build_color_contraction_plan(dag.color_plan, contraction_descriptors)
+        if color_contraction == "direct"
+        else build_symmetric_group_color_contraction_plan(
+            dag.color_plan,
+            contraction_descriptors,
+        )
+    )
+    multiple_lc_sectors = _has_multiple_lc_root_sectors(dag)
+    roots: list[dict[str, object]] = []
+    group_weights: dict[int, tuple[float, float]] = {}
+    for output_index, root in enumerate(dag.amplitude_roots):
+        group_id = group_ids[root.id]
+        all_sector_weight = _root_all_sector_weight(
+            dag,
+            root,
+            has_multiple_lc_root_sectors=multiple_lc_sectors,
+        )
+        group_weights.setdefault(
+            group_id,
+            (float(root.helicity_weight), float(all_sector_weight)),
+        )
+        roots.append(
+            {
+                "output_index": output_index,
+                "root_id": output_index,
+                "dag_root_id": root.id,
+                "kind": root.kind,
+                "left_current_id": root.left_id,
+                "right_current_id": root.right_id,
+                "vertex_kind": root.vertex_kind,
+                "vertex_particles": (
+                    None
+                    if root.vertex_particles is None
+                    else list(root.vertex_particles)
+                ),
+                "coupling": list(root.coupling),
+                "coupling_parameter_names": (
+                    None
+                    if root.vertex_kind is None or root.vertex_particles is None
+                    else runtime_coupling_parameter_names(
+                        root.vertex_kind,
+                        root.vertex_particles,
+                        root.coupling,
+                        model=model,
+                    )
+                ),
+                "color_weight": list(root.color_weight),
+                "color_sector_id": _root_color_sector_id(dag, root),
+                "contraction": root.contraction,
+                "contraction_ir": root.contraction_ir.to_json_dict(),
+                "coherent_group_id": group_id,
+                "helicity_weight": root.helicity_weight,
+                "all_sector_weight": all_sector_weight,
+            }
+        )
+
+    coherent_groups = []
+    for descriptor in descriptors:
+        helicity_weight, all_sector_weight = group_weights[descriptor.group_id]
+        coherent_groups.append(
+            {
+                "group_id": descriptor.group_id,
+                "helicities": _helicity_vector(dag, descriptor.helicity_key),
+                "color_sector_id": descriptor.sector_id,
+                "color_word": list(descriptor.word),
+                "helicity_weight": helicity_weight,
+                "all_sector_weight": all_sector_weight,
+            }
+        )
+
+    return (
+        {
+            "stage_kind": "amplitude-roots",
+            "output_count": len(roots),
+            "selected_color_sector_ids": None,
+            "coherent_groups": coherent_groups,
+            "color_topology_replay": (
+                None if replay is None else replay.to_runtime_manifest(dag)
+            ),
+            "roots": roots,
+            "final_reduction": {
+                "status": (
+                    "sparse-color-contraction"
+                    if contraction is not None
+                    else "coherent-leading-color-diagonal"
+                ),
+                "operation": (
+                    "sum root outputs into coherent helicity/color amplitudes, "
+                    "then apply the requested color contraction"
+                ),
+            },
+            "color_contraction": (
+                None if contraction is None else contraction.to_json_dict()
+            ),
+        },
+        contraction,
+        contraction_descriptors,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class _ColorReplayGroupRoute:
+    source_group_id: int
+    target_group_id: int
+    factor: tuple[float, float]
+
+
+@dataclass(frozen=True, slots=True)
+class _ColorReplayMapping:
+    label_permutation: tuple[tuple[int, int], ...]
+    group_routes: tuple[_ColorReplayGroupRoute, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _ColorReplayAmplitudePlan:
+    physical_descriptors: tuple[ColorGroupDescriptor, ...]
+    mappings: tuple[_ColorReplayMapping, ...]
+
+    def to_runtime_manifest(self, dag: GenericDAG) -> dict[str, object]:
+        groups = []
+        for descriptor in self.physical_descriptors:
+            groups.append(
+                {
+                    "group_id": descriptor.group_id,
+                    "helicities": _helicity_vector(dag, descriptor.helicity_key),
+                    "color_sector_id": descriptor.sector_id,
+                    "color_word": list(descriptor.word),
+                    "helicity_weight": descriptor.helicity_weight,
+                }
+            )
+        return {
+            "contract_version": 1,
+            "physical_group_count": len(groups),
+            "physical_groups": groups,
+            "mappings": [
+                {
+                    "label_permutation": [
+                        {
+                            "representative_label": representative,
+                            "sector_label": sector,
+                        }
+                        for representative, sector in mapping.label_permutation
+                    ],
+                    "group_routes": [
+                        {
+                            "source_group_id": route.source_group_id,
+                            "target_group_id": route.target_group_id,
+                            "factor": list(route.factor),
+                        }
+                        for route in mapping.group_routes
+                    ],
+                }
+                for mapping in self.mappings
+            ],
+        }
+
+
+def _color_topology_replay_amplitudes(
+    dag: GenericDAG,
+    materialized_descriptors: Sequence[ColorGroupDescriptor],
+) -> _ColorReplayAmplitudePlan | None:
+    """Derive the amplitude-level gather authenticated by the color proof.
+
+    The generated DAG contains only representative sectors.  NLC/full color
+    contraction is nevertheless defined over every physical sector, so the
+    runtime must evaluate representatives at the proven external-label
+    permutations, gather coherent complex amplitudes into the complete
+    physical group domain, and only then apply the unchanged color metric.
+    """
+
+    certificate = dag.color_topology_replay
+    if certificate is None or not certificate.optimized:
+        return None
+    materialized_by_sector: dict[int, list[ColorGroupDescriptor]] = {}
+    for descriptor in materialized_descriptors:
+        materialized_by_sector.setdefault(descriptor.sector_id, []).append(descriptor)
+    expected_materialized = set(certificate.materialized_sector_ids)
+    if set(materialized_by_sector) != expected_materialized:
+        raise ValueError(
+            "color topology replay materialized amplitude sectors do not match "
+            "the proof certificate"
+        )
+
+    pending_routes: list[
+        tuple[
+            tuple[tuple[int, int], ...],
+            int,
+            tuple[object, ...],
+            int,
+            tuple[int, ...],
+            float,
+        ]
+    ] = []
+    for partition in certificate.partitions:
+        source_descriptors = materialized_by_sector.get(
+            int(partition.materialized_sector_id)
+        )
+        if not source_descriptors:
+            raise ValueError(
+                "color topology replay partition has no materialized amplitudes"
+            )
+        _append_color_replay_partition_routes(
+            dag,
+            partition,
+            source_descriptors,
+            pending_routes,
+        )
+    for sector_id in certificate.residual_sector_ids:
+        source_descriptors = materialized_by_sector.get(int(sector_id))
+        if not source_descriptors:
+            raise ValueError(
+                f"color topology replay residual sector {sector_id} is absent"
+            )
+        for source in source_descriptors:
+            pending_routes.append(
+                (
+                    (),
+                    source.group_id,
+                    source.helicity_key,
+                    int(sector_id),
+                    source.word,
+                    source.helicity_weight,
+                )
+            )
+
+    physical_keys = sorted(
+        {
+            (helicity_key, sector_id, word, helicity_weight)
+            for (
+                _permutation,
+                _source_group_id,
+                helicity_key,
+                sector_id,
+                word,
+                helicity_weight,
+            ) in pending_routes
+        },
+        key=repr,
+    )
+    physical_id_by_key = {key: group_id for group_id, key in enumerate(physical_keys)}
+    physical_descriptors = tuple(
+        ColorGroupDescriptor(
+            group_id=group_id,
+            helicity_key=helicity_key,
+            sector_id=sector_id,
+            word=word,
+            helicity_weight=helicity_weight,
+        )
+        for group_id, (helicity_key, sector_id, word, helicity_weight) in enumerate(
+            physical_keys
+        )
+    )
+    routes_by_mapping: dict[
+        tuple[tuple[int, int], ...],
+        list[_ColorReplayGroupRoute],
+    ] = {}
+    target_ids: list[int] = []
+    for (
+        permutation,
+        source_group_id,
+        helicity_key,
+        sector_id,
+        word,
+        helicity_weight,
+    ) in pending_routes:
+        target_group_id = physical_id_by_key[
+            (helicity_key, sector_id, word, helicity_weight)
+        ]
+        routes_by_mapping.setdefault(permutation, []).append(
+            _ColorReplayGroupRoute(
+                source_group_id=source_group_id,
+                target_group_id=target_group_id,
+                factor=(1.0, 0.0),
+            )
+        )
+        target_ids.append(target_group_id)
+    if sorted(target_ids) != list(range(len(physical_descriptors))):
+        raise ValueError(
+            "color topology replay amplitude gather is not a physical-group bijection"
+        )
+    mappings = tuple(
+        _ColorReplayMapping(
+            label_permutation=permutation,
+            group_routes=tuple(
+                sorted(
+                    routes,
+                    key=lambda route: (
+                        route.target_group_id,
+                        route.source_group_id,
+                    ),
+                )
+            ),
+        )
+        for permutation, routes in sorted(routes_by_mapping.items())
+    )
+    if not mappings or any(not mapping.group_routes for mapping in mappings):
+        raise ValueError("color topology replay amplitude gather is empty")
+    return _ColorReplayAmplitudePlan(
+        physical_descriptors=physical_descriptors,
+        mappings=mappings,
+    )
+
+
+def _append_color_replay_partition_routes(
+    dag: GenericDAG,
+    partition: LCColorSectorReplayPartition,
+    source_descriptors: Sequence[ColorGroupDescriptor],
+    pending_routes: list[
+        tuple[
+            tuple[tuple[int, int], ...],
+            int,
+            tuple[object, ...],
+            int,
+            tuple[int, ...],
+            float,
+        ]
+    ],
+) -> None:
+    for sector_id, permutation, weight, sign in zip(
+        partition.active_sector_ids,
+        partition.label_permutations,
+        partition.weights,
+        partition.signs,
+        strict=True,
+    ):
+        if weight != 1.0 or sign != 1:
+            raise ValueError(
+                "color topology replay amplitude gather currently requires "
+                "unit positive proof factors"
+            )
+        target_sector = dag.color_plan.sector(int(sector_id))
+        if target_sector is None:
+            raise ValueError(
+                f"color topology replay target sector {sector_id} is absent"
+            )
+        target_word = tuple(target_sector.word_labels or target_sector.color_words[0])
+        normalized_permutation = tuple(
+            sorted(
+                (int(left), int(right))
+                for left, right in permutation
+                if int(left) != int(right)
+            )
+        )
+        for source in source_descriptors:
+            pending_routes.append(
+                (
+                    normalized_permutation,
+                    source.group_id,
+                    _permute_helicity_key(source.helicity_key, normalized_permutation),
+                    int(sector_id),
+                    target_word,
+                    source.helicity_weight,
+                )
+            )
+
+
+def _permute_helicity_key(
+    helicity_key: tuple[object, ...],
+    permutation: Sequence[tuple[int, int]],
+) -> tuple[object, ...]:
+    by_label = dict(permutation)
+    result: list[object] = []
+    for item in helicity_key:
+        if not isinstance(item, tuple) or len(item) < 5:
+            raise ValueError(
+                "color topology replay requires explicit external-label helicity keys"
+            )
+        result.append((by_label.get(int(item[0]), int(item[0])), *item[1:]))
+    return tuple(sorted(result))
+
+
+def _mapping_sequence(value: object) -> tuple[Mapping[str, object], ...]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise TypeError("runtime amplitude field must be an array")
+    result: list[Mapping[str, object]] = []
+    for item in value:
+        if not isinstance(item, Mapping):
+            raise TypeError("runtime amplitude record must be an object")
+        result.append(item)
+    return tuple(result)
+
+
+def _amplitude_groups(
+    dag: GenericDAG,
+    roots: Sequence[AmplitudeRoot],
+) -> tuple[dict[int, int], tuple[ColorGroupDescriptor, ...]]:
+    ids: dict[tuple[object, ...], int] = {}
+    result: dict[int, int] = {}
+    descriptors: dict[int, ColorGroupDescriptor] = {}
+    source_by_ancestry = {
+        int(current.index.helicity_ancestry): (
+            int(current.source_leg_label or 0),
+            int(current.index.particle_id),
+            int(current.index.chirality),
+            current.index.spin_state,
+            current.source_helicity,
+        )
+        for current in dag.currents
+        if current.is_source
+    }
+    single_bit_ancestry = all(
+        bit > 0 and bit & (bit - 1) == 0 for bit in source_by_ancestry
+    )
+    physical_sources_cache: dict[int, tuple[object, ...]] = {}
+    materialized_source_keys = _materialized_root_source_keys(dag)
+
+    def physical_sources(ancestry: int) -> tuple[object, ...]:
+        cached = physical_sources_cache.get(ancestry)
+        if cached is not None:
+            return cached
+        if single_bit_ancestry:
+            sources: list[tuple[object, ...]] = []
+            remaining = ancestry
+            while remaining:
+                bit = remaining & -remaining
+                source = source_by_ancestry.get(bit)
+                if source is not None:
+                    sources.append(source)
+                remaining ^= bit
+            value: tuple[object, ...] = tuple(sorted(sources))
+        else:
+            value = tuple(
+                sorted(
+                    source
+                    for bit, source in source_by_ancestry.items()
+                    if ancestry & bit
+                )
+            )
+        physical_sources_cache[ancestry] = value
+        return value
+
+    for root in roots:
+        left = dag.currents[root.left_id].index
+        right = dag.currents[root.right_id].index
+        ancestry = int(left.helicity_ancestry | right.helicity_ancestry)
+        source_key = materialized_source_keys.get(root.id) or physical_sources(ancestry)
+        sector_id = _root_color_sector_id(dag, root)
+        sector = dag.color_plan.sector(sector_id)
+        word = (
+            tuple(sector.word_labels or sector.color_words[0])
+            if sector is not None and sector.color_words
+            else ()
+        )
+        color_key = (
+            left.color_state.accuracy,
+            word or sector_id,
+            tuple(
+                sorted(
+                    set(left.color_state.basis_key) | set(right.color_state.basis_key)
+                )
+            ),
+            tuple(root.color_weight),
+        )
+        key = (source_key or ancestry, color_key)
+        group_id = ids.setdefault(key, len(ids))
+        result[root.id] = group_id
+        descriptors.setdefault(
+            group_id,
+            ColorGroupDescriptor(
+                group_id=group_id,
+                helicity_key=source_key or (ancestry,),
+                sector_id=sector_id,
+                word=word,
+                helicity_weight=float(root.helicity_weight),
+            ),
+        )
+    return result, tuple(descriptors[index] for index in sorted(descriptors))
+
+
+def _materialized_root_source_keys(
+    dag: GenericDAG,
+) -> dict[int, tuple[object, ...]]:
+    materialization = dag.helicity_materialization
+    recurrence = dag.helicity_recurrence
+    if materialization is None or recurrence is None:
+        return {}
+    if materialization.strategy == "retained-proof-graph":
+        # The retained graph keeps the original physical roots and their
+        # ancestry. Preserve the established coherent grouping so selector
+        # metadata cannot change cancellations in the summed workload.
+        return {}
+    domain_by_id = {domain.id: domain for domain in recurrence.selector_domains}
+    routes_by_root: dict[int, list[object]] = {}
+    for route in materialization.amplitude_routes:
+        routes_by_root.setdefault(route.materialized_root_id, []).append(route)
+    result: dict[int, tuple[object, ...]] = {}
+    for root_id, routes in routes_by_root.items():
+        first_domain_id = next(
+            (domain_id for route in routes for domain_id in route.selector_domain_ids),
+            None,
+        )
+        if first_domain_id is None:
+            raise ValueError(
+                f"materialized amplitude root {root_id} has no selector domain"
+            )
+        domain = domain_by_id.get(first_domain_id)
+        if domain is None or not domain.complete:
+            raise ValueError(
+                f"materialized amplitude root {root_id} has an invalid selector domain"
+            )
+        result[root_id] = tuple(
+            (label, 0, 0, 0, helicity) for label, helicity in domain.source_states
+        )
+    return result
+
+
+def _helicity_vector(
+    dag: GenericDAG,
+    helicity_key: tuple[object, ...],
+) -> list[int]:
+    by_label: dict[int, int] = {}
+    for item in helicity_key:
+        if not isinstance(item, tuple) or len(item) < 5:
+            continue
+        by_label[int(item[0])] = int(item[4])
+    return [by_label.get(leg.label, 0) for leg in dag.process.legs]
+
+
+def _root_color_sector_id(dag: GenericDAG, root: AmplitudeRoot) -> int:
+    if root.color_sector_id is not None:
+        return int(root.color_sector_id)
+    return int(dag.currents[root.left_id].index.color_state.sector_id)
+
+
+def _root_all_sector_weight(
+    dag: GenericDAG,
+    root: AmplitudeRoot,
+    *,
+    has_multiple_lc_root_sectors: bool,
+) -> float:
+    weight = float(root.helicity_weight)
+    if dag.process.color_accuracy != "lc":
+        return weight
+    if dag.color_plan.process.color_endpoints.pair_count != 0:
+        return weight
+    if not dag.color_plan.trace_reflections_folded:
+        return weight
+    if not has_multiple_lc_root_sectors:
+        return weight
+    sector = dag.color_plan.sector(_root_color_sector_id(dag, root))
+    if sector is None or sector.kind != "single-trace":
+        return weight
+    trace = tuple(int(label) for label in sector.trace_labels)
+    if len(trace) <= 2 or trace[1:] == tuple(reversed(trace[1:])):
+        return weight
+    return 2.0 * weight
+
+
+def _has_multiple_lc_root_sectors(dag: GenericDAG) -> bool:
+    if dag.process.color_accuracy != "lc":
+        return False
+    if dag.color_plan.process.color_endpoints.pair_count != 0:
+        return False
+    return len({_root_color_sector_id(dag, root) for root in dag.amplitude_roots}) > 1
+
+
+def _current_slot_ref(slot: Mapping[str, object]) -> dict[str, object]:
+    return {
+        key: slot[key]
+        for key in (
+            "current_id",
+            "component_start",
+            "component_stop",
+            "dimension",
+        )
+    }
+
+
+def _value_slot_ref(slot: Mapping[str, object]) -> dict[str, object]:
+    return {
+        key: slot[key]
+        for key in (
+            "value_slot_id",
+            "current_id",
+            "variant",
+            "component_start",
+            "component_stop",
+            "dimension",
+        )
+    }
+
+
+def _amplitude_value_slot(
+    current: CurrentNode,
+    value_slots: Mapping[tuple[int, str], Mapping[str, object]],
+) -> Mapping[str, object]:
+    variant = "source" if current.is_source else "unpropagated"
+    try:
+        return value_slots[(current.id, variant)]
+    except KeyError as exc:
+        raise ValueError(
+            f"amplitude current {current.id} has no {variant} runtime value slot"
+        ) from exc
+
+
+__all__ = [
+    "build_runtime_amplitude_metadata",
+    "build_runtime_amplitude_stage",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/runtime_schema.py b/pyamplicol/src/pyamplicol/generation/runtime_schema.py
new file mode 100644
index 0000000000..b895c29904
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/runtime_schema.py
@@ -0,0 +1,876 @@
+# SPDX-License-Identifier: 0BSD
+"""Neutral schema-v3 runtime layout assembly for generated DAGs."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+from ..color import ColorContractionPlan, ColorGroupDescriptor
+from ..models.base import Model
+from .contracts import RuntimeExpressionSchema
+from .dag_types import CurrentNode, GenericDAG, InteractionNode
+from .physics_metadata import (
+    build_resolved_physics_payload,
+    build_runtime_model_parameter_records,
+    build_runtime_normalization,
+)
+from .runtime_amplitudes import build_runtime_amplitude_stage_layout
+
+RUNTIME_PHYSICS_SCHEMA_VERSION = 1
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeStageLayout:
+    """One runtime stage plus indexes retained for eager table lowering."""
+
+    record: dict[str, object]
+    interactions: tuple[InteractionNode, ...]
+    evaluation_groups: tuple[tuple[InteractionNode, ...], ...]
+    input_value_slot_by_current: dict[int, int]
+    output_current_ids: tuple[int, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeSchemaLayout:
+    """Owned runtime schema plus the indexes used to assemble it.
+
+    The eager lane consumes these indexes directly so it never has to parse the
+    freshly constructed JSON-shaped schema back into Python lookup tables.
+    """
+
+    runtime_schema: dict[str, object]
+    current_slots: list[dict[str, object]]
+    value_slots_by_id: tuple[dict[str, object], ...]
+    value_slot_ids_by_current_variant: dict[tuple[int, str], int]
+    momentum_slot_by_mask: dict[int, int]
+    stages: tuple[RuntimeStageLayout, ...]
+    amplitude_stage: dict[str, object]
+    color_contraction: ColorContractionPlan | None
+    color_contraction_descriptors: tuple[ColorGroupDescriptor, ...]
+    model_parameters: list[dict[str, object]]
+
+
+@dataclass(frozen=True, slots=True)
+class _SourceDescriptor:
+    source_ir: Any
+    applied_crossing: Any
+    expected_states: frozenset[tuple[int, int, object]]
+    crossing: str
+    source_ir_payload: dict[str, object]
+    applied_crossing_payload: dict[str, object]
+
+
+@dataclass(frozen=True, slots=True)
+class _ValueSlotLayout:
+    records: list[dict[str, object]]
+    by_current_variant: dict[tuple[int, str], dict[str, object]]
+    slot_ids_by_current_variant: dict[tuple[int, str], int]
+    input_slot_id_by_current: dict[int, int]
+    result_slot_ids_by_current: dict[int, tuple[int, ...]]
+
+
+def build_runtime_expression_schema(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str | None = None,
+    color_contraction: str = "direct",
+) -> RuntimeExpressionSchema:
+    return RuntimeExpressionSchema.from_mapping(
+        build_runtime_schema(
+            dag,
+            model,
+            process_id=process_id,
+            color_contraction=color_contraction,
+        )
+    )
+
+
+def build_runtime_schema(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str | None = None,
+    color_contraction: str = "direct",
+) -> dict[str, object]:
+    """Build the stage compiler and runtime metadata for one concrete process."""
+
+    return build_runtime_schema_layout(
+        dag,
+        model,
+        process_id=process_id,
+        color_contraction=color_contraction,
+    ).runtime_schema
+
+
+def build_runtime_schema_layout(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str | None = None,
+    color_contraction: str = "direct",
+) -> RuntimeSchemaLayout:
+    """Build runtime metadata while retaining its typed construction indexes."""
+
+    public_process_id = process_id or dag.process.key
+
+    color_state_payloads: dict[object, dict[str, object]] = {}
+    current_slots = _current_slots(
+        dag,
+        color_state_payloads=color_state_payloads,
+    )
+    interactions_by_size, interaction_inputs = _interaction_indexes(dag)
+    amplitude_inputs = {
+        current_id
+        for root in dag.amplitude_roots
+        for current_id in (root.left_id, root.right_id)
+    }
+    propagators_by_current = _propagators_by_current(dag, model)
+    propagator_payloads: dict[tuple[int, int], dict[str, object]] = {}
+    value_slot_layout = _value_slots(
+        dag,
+        current_slots=current_slots,
+        interaction_inputs=interaction_inputs,
+        amplitude_inputs=amplitude_inputs,
+        propagators_by_current=propagators_by_current,
+        propagator_payloads=propagator_payloads,
+    )
+    value_slot_records = value_slot_layout.records
+    value_slots = value_slot_layout.by_current_variant
+    momentum_slots = _momentum_slots(dag)
+    momentum_slot_by_mask = {
+        int(slot["momentum_mask"]): int(slot["momentum_slot_id"])
+        for slot in momentum_slots
+    }
+    amplitude_stage_layout = build_runtime_amplitude_stage_layout(
+        dag,
+        model,
+        current_slots=current_slots,
+        value_slots=value_slots,
+        color_contraction=color_contraction,
+    )
+    amplitude_stage = amplitude_stage_layout.record
+    model_parameters = build_runtime_model_parameter_records(
+        dag,
+        model,
+        amplitude_stage=amplitude_stage,
+    )
+    stage_layouts = _stage_layouts(
+        dag,
+        input_value_slot_id_by_current=(value_slot_layout.input_slot_id_by_current),
+        result_value_slot_ids_by_current=(value_slot_layout.result_slot_ids_by_current),
+        momentum_slot_by_mask=momentum_slot_by_mask,
+        interactions_by_size=interactions_by_size,
+    )
+    stages = [stage.record for stage in stage_layouts]
+    external_particles = _external_particles(dag)
+    normalization = build_runtime_normalization(dag, model)
+    physics = build_resolved_physics_payload(
+        dag,
+        model,
+        process_id=public_process_id,
+        amplitude_stage=amplitude_stage,
+        model_parameters=model_parameters,
+        normalization=normalization,
+    )
+    value_count = (
+        int(value_slot_records[-1]["component_stop"]) if value_slot_records else 0
+    )
+    momentum_count = 4 * len(momentum_slots)
+    source_records = _source_records(
+        dag,
+        model,
+        current_slots=current_slots,
+        value_slots=value_slots,
+        color_state_payloads=color_state_payloads,
+    )
+
+    runtime_schema: dict[str, object] = {
+        "schema_version": 1,
+        "kind": "pyamplicol-runtime-expression-schema",
+        "process_key": public_process_id,
+        "process": dag.process.process,
+        "color_accuracy": dag.process.color_accuracy,
+        "external_particles": external_particles,
+        "momentum_conventions": _momentum_conventions(dag),
+        "model": _model_payload(dag, model),
+        "normalization": normalization,
+        "parameter_layout": {
+            "value_component_count": value_count,
+            "momentum_parameter_count": momentum_count,
+            "model_parameter_count": len(model_parameters),
+            "parameter_count_if_flattened": (
+                value_count + momentum_count + len(model_parameters)
+            ),
+            "momentum_components_real": True,
+            "model_parameters_real": True,
+        },
+        "model_parameters": model_parameters,
+        "physics": physics,
+        "current_storage": {
+            "component_count": (
+                int(current_slots[-1]["component_stop"]) if current_slots else 0
+            ),
+            "number_type": "complex",
+            "current_slots": current_slots,
+        },
+        "value_storage": {
+            "component_count": value_count,
+            "number_type": "complex",
+            "value_slots": value_slot_records,
+        },
+        "source_fill": {
+            "source_count": len(dag.sources),
+            "sources": source_records,
+        },
+        "momentum_slots": momentum_slots,
+        "stages": stages,
+        "amplitude_stage": amplitude_stage,
+    }
+    if dag.lc_topology_replay is not None:
+        runtime_schema["lc_topology_replay"] = (
+            dag.lc_topology_replay.to_runtime_manifest()
+        )
+    if dag.color_topology_replay is not None:
+        runtime_schema["color_topology_replay"] = (
+            dag.color_topology_replay.to_runtime_manifest()
+        )
+    if dag.helicity_recurrence is not None:
+        runtime_schema["helicity_recurrence"] = {
+            **dag.helicity_recurrence.to_runtime_manifest(),
+            **(
+                {}
+                if dag.helicity_materialization is None
+                else {
+                    "materialization": (
+                        dag.helicity_materialization.to_runtime_manifest()
+                    )
+                }
+            ),
+        }
+    return RuntimeSchemaLayout(
+        runtime_schema=runtime_schema,
+        current_slots=current_slots,
+        value_slots_by_id=tuple(value_slot_records),
+        value_slot_ids_by_current_variant=(
+            value_slot_layout.slot_ids_by_current_variant
+        ),
+        momentum_slot_by_mask=momentum_slot_by_mask,
+        stages=stage_layouts,
+        amplitude_stage=amplitude_stage,
+        color_contraction=amplitude_stage_layout.color_contraction,
+        color_contraction_descriptors=(amplitude_stage_layout.contraction_descriptors),
+        model_parameters=model_parameters,
+    )
+
+
+def _current_slots(
+    dag: GenericDAG,
+    *,
+    color_state_payloads: dict[object, dict[str, object]] | None = None,
+) -> list[dict[str, object]]:
+    offset = 0
+    slots: list[dict[str, object]] = []
+    color_payloads = {} if color_state_payloads is None else color_state_payloads
+    for current in dag.currents:
+        index = current.index
+        start = offset
+        offset += current.dimension
+        color_state = color_payloads.get(index.color_state)
+        if color_state is None:
+            color_state = index.color_state.to_json_dict()
+            color_payloads[index.color_state] = color_state
+        slots.append(
+            {
+                "current_id": current.id,
+                "component_start": start,
+                "component_stop": offset,
+                "dimension": current.dimension,
+                "is_source": current.is_source,
+                "particle_id": index.particle_id,
+                "external_mask": index.external_mask,
+                "external_labels": list(index.external_labels),
+                "momentum_mask": index.momentum_mask,
+                # Decimal conversion is capped by Python for very wide
+                # full-colour helicity masks.  The runtime contract accepts
+                # canonical hexadecimal integers and does not interpret this
+                # diagnostic-only field on the hot path.
+                "helicity_ancestry": hex(index.helicity_ancestry),
+                "chirality": index.chirality,
+                "spin_state": _spin_state(index.spin_state),
+                "flavour_flow": list(index.flavour_flow),
+                "quantum_number_flow": [
+                    [name, expression] for name, expression in index.quantum_number_flow
+                ],
+                "color_state": color_state,
+                "auxiliary_kind": index.auxiliary_kind,
+            }
+        )
+    return slots
+
+
+def _value_slots(
+    dag: GenericDAG,
+    *,
+    current_slots: Sequence[Mapping[str, object]],
+    interaction_inputs: set[int],
+    amplitude_inputs: set[int],
+    propagators_by_current: Sequence[Any],
+    propagator_payloads: dict[tuple[int, int], dict[str, object]],
+) -> _ValueSlotLayout:
+    records: list[dict[str, object]] = []
+    by_current_variant: dict[tuple[int, str], dict[str, object]] = {}
+    slot_ids_by_current_variant: dict[tuple[int, str], int] = {}
+    input_slot_id_by_current: dict[int, int] = {}
+    result_slot_ids_by_current: dict[int, tuple[int, ...]] = {}
+    offset = 0
+
+    def add(
+        current: CurrentNode,
+        variant: str,
+        applies_propagator: bool,
+    ) -> int:
+        nonlocal offset
+        current_slot = current_slots[current.id]
+        propagator = propagators_by_current[current.id]
+        propagator_key = (
+            current.index.particle_id,
+            current.index.chirality,
+        )
+        propagator_payload = propagator_payloads.get(propagator_key)
+        if propagator_payload is None:
+            propagator_payload = propagator.to_json_dict()
+            propagator_payloads[propagator_key] = propagator_payload
+        start = offset
+        offset += current.dimension
+        slot_id = len(records)
+        record: dict[str, object] = {
+            "value_slot_id": slot_id,
+            "current_id": current.id,
+            "variant": variant,
+            "component_start": start,
+            "component_stop": offset,
+            "dimension": current.dimension,
+            "current_component_start": current_slot["component_start"],
+            "current_component_stop": current_slot["component_stop"],
+            "is_source": current.is_source,
+            "applies_propagator": applies_propagator,
+            "particle_id": current.index.particle_id,
+            "external_mask": current.index.external_mask,
+            "external_labels": current_slot["external_labels"],
+            "momentum_mask": current.index.momentum_mask,
+            "chirality": current.index.chirality,
+            "propagator": propagator_payload,
+            "used_as_interaction_input": current.id in interaction_inputs,
+            "used_as_amplitude_input": current.id in amplitude_inputs,
+        }
+        records.append(record)
+        key = (current.id, variant)
+        by_current_variant[key] = record
+        slot_ids_by_current_variant[key] = slot_id
+        return slot_id
+
+    for current in dag.currents:
+        if current.is_source:
+            source_slot_id = add(current, "source", False)
+            result_slot_ids_by_current[current.id] = (source_slot_id,)
+            if current.id in interaction_inputs:
+                input_slot_id_by_current[current.id] = source_slot_id
+            continue
+        propagator = propagators_by_current[current.id]
+        needs_propagated = (
+            current.id in interaction_inputs and propagator.applies_propagator
+        )
+        needs_unpropagated = current.id in amplitude_inputs
+        unpropagated_slot_id: int | None = None
+        if (
+            needs_unpropagated
+            or not needs_propagated
+            or (current.id in interaction_inputs and not propagator.applies_propagator)
+        ):
+            unpropagated_slot_id = add(current, "unpropagated", False)
+        propagated_slot_id: int | None = None
+        if needs_propagated:
+            propagated_slot_id = add(current, "propagated", True)
+        result_slot_ids = tuple(
+            slot_id
+            for slot_id in (unpropagated_slot_id, propagated_slot_id)
+            if slot_id is not None
+        )
+        if not result_slot_ids:
+            raise ValueError(f"result current {current.id} has no runtime value slots")
+        result_slot_ids_by_current[current.id] = result_slot_ids
+        if current.id in interaction_inputs:
+            input_slot_id = (
+                propagated_slot_id
+                if propagator.applies_propagator
+                else unpropagated_slot_id
+            )
+            if input_slot_id is None:
+                variant = (
+                    "propagated" if propagator.applies_propagator else "unpropagated"
+                )
+                raise ValueError(
+                    f"interaction current {current.id} has no {variant} "
+                    "runtime value slot"
+                )
+            input_slot_id_by_current[current.id] = input_slot_id
+    return _ValueSlotLayout(
+        records=records,
+        by_current_variant=by_current_variant,
+        slot_ids_by_current_variant=slot_ids_by_current_variant,
+        input_slot_id_by_current=input_slot_id_by_current,
+        result_slot_ids_by_current=result_slot_ids_by_current,
+    )
+
+
+def _momentum_slots(dag: GenericDAG) -> list[dict[str, object]]:
+    masks = sorted(
+        {current.index.momentum_mask for current in dag.currents},
+        key=lambda mask: (mask.bit_count(), mask),
+    )
+    incoming = {leg.label for leg in dag.process.initial_legs}
+    result: list[dict[str, object]] = []
+    for slot_id, mask in enumerate(masks):
+        labels = _mask_labels(mask)
+        start = 4 * slot_id
+        result.append(
+            {
+                "momentum_slot_id": slot_id,
+                "momentum_mask": mask,
+                "external_labels": list(labels),
+                "component_start": start,
+                "component_stop": start + 4,
+                "component_order": ["E", "px", "py", "pz"],
+                "real_valued": True,
+                "crossed_incoming_labels": [
+                    label for label in labels if label in incoming
+                ],
+                "construction": (
+                    "sum all-outgoing momenta for external labels; negate "
+                    "physical incoming momenta first"
+                ),
+            }
+        )
+    return result
+
+
+def _stage_layouts(
+    dag: GenericDAG,
+    *,
+    input_value_slot_id_by_current: Mapping[int, int],
+    result_value_slot_ids_by_current: Mapping[int, tuple[int, ...]],
+    momentum_slot_by_mask: Mapping[int, int],
+    interactions_by_size: Mapping[int, Sequence[InteractionNode]],
+) -> tuple[RuntimeStageLayout, ...]:
+    stages: list[RuntimeStageLayout] = []
+    for stage_index, size in enumerate(sorted(interactions_by_size), start=1):
+        interactions = tuple(interactions_by_size[size])
+        input_current_ids: set[int] = set()
+        output_current_ids: set[int] = set()
+        input_value_slot_ids: set[int] = set()
+        output_value_slot_ids: set[int] = set()
+        momentum_ids: set[int] = set()
+        evaluation_groups: dict[tuple[str, int], list[InteractionNode]] = {}
+        for interaction in interactions:
+            left_id = interaction.left_id
+            right_id = interaction.right_id
+            result_id = interaction.result_id
+            input_current_ids.add(left_id)
+            input_current_ids.add(right_id)
+            output_current_ids.add(result_id)
+            input_value_slot_ids.add(input_value_slot_id_by_current[left_id])
+            input_value_slot_ids.add(input_value_slot_id_by_current[right_id])
+            output_value_slot_ids.update(result_value_slot_ids_by_current[result_id])
+            momentum_ids.add(
+                momentum_slot_by_mask[dag.currents[left_id].index.momentum_mask]
+            )
+            momentum_ids.add(
+                momentum_slot_by_mask[dag.currents[right_id].index.momentum_mask]
+            )
+            momentum_ids.add(
+                momentum_slot_by_mask[dag.currents[result_id].index.momentum_mask]
+            )
+            group_key = (
+                ("group", int(interaction.evaluation_group_id))
+                if interaction.evaluation_group_id is not None
+                else ("interaction", interaction.id)
+            )
+            if interaction.evaluation_factor != (0.0, 0.0):
+                evaluation_groups.setdefault(group_key, []).append(interaction)
+
+        ordered_output_current_ids = tuple(sorted(output_current_ids))
+        record: dict[str, object] = {
+            "stage_index": stage_index,
+            "stage_kind": "current-combine",
+            "subset_size": size,
+            "input_current_ids": sorted(input_current_ids),
+            "output_current_ids": list(ordered_output_current_ids),
+            "input_value_slot_ids": sorted(input_value_slot_ids),
+            "output_value_slot_ids": sorted(output_value_slot_ids),
+            "input_momentum_slot_ids": sorted(momentum_ids),
+            "interaction_count": len(interactions),
+            "interaction_evaluation_count": len(evaluation_groups),
+            "interaction_ids": [interaction.id for interaction in interactions],
+            "interactions_compacted": True,
+            "interactions": [],
+        }
+        stages.append(
+            RuntimeStageLayout(
+                record=record,
+                interactions=interactions,
+                evaluation_groups=tuple(
+                    tuple(group) for group in evaluation_groups.values()
+                ),
+                input_value_slot_by_current={
+                    current_id: input_value_slot_id_by_current[current_id]
+                    for current_id in input_current_ids
+                },
+                output_current_ids=ordered_output_current_ids,
+            )
+        )
+    return tuple(stages)
+
+
+def _interaction_indexes(
+    dag: GenericDAG,
+) -> tuple[dict[int, list[InteractionNode]], set[int]]:
+    by_size: dict[int, list[InteractionNode]] = {}
+    inputs: set[int] = set()
+    for interaction in dag.interactions:
+        size = len(dag.currents[interaction.result_id].index.external_labels)
+        by_size.setdefault(size, []).append(interaction)
+        inputs.add(interaction.left_id)
+        inputs.add(interaction.right_id)
+    return by_size, inputs
+
+
+def _propagators_by_current(dag: GenericDAG, model: Model) -> list[Any]:
+    cache: dict[tuple[int, int], Any] = {}
+    result: list[Any] = []
+    for current in dag.currents:
+        key = (current.index.particle_id, current.index.chirality)
+        propagator = cache.get(key)
+        if propagator is None:
+            propagator = model._propagator_ir(*key)
+            cache[key] = propagator
+        result.append(propagator)
+    return result
+
+
+def _source_records(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    current_slots: Sequence[Mapping[str, object]],
+    value_slots: Mapping[tuple[int, str], Mapping[str, object]],
+    color_state_payloads: Mapping[object, dict[str, object]],
+) -> list[dict[str, object]]:
+    records: list[dict[str, object]] = []
+    source_start = 0
+    legs_by_label = {leg.label: leg for leg in dag.process.legs}
+    descriptors: dict[tuple[int, bool], _SourceDescriptor] = {}
+    for source_index, current_id in enumerate(dag.sources):
+        current = dag.currents[current_id]
+        source_leg_label = current.source_leg_label
+        leg = (
+            legs_by_label.get(source_leg_label)
+            if source_leg_label is not None
+            else None
+        )
+        descriptor_key = (
+            current.index.particle_id,
+            bool(leg is not None and leg.is_initial),
+        )
+        descriptor = descriptors.get(descriptor_key)
+        if descriptor is None:
+            descriptor = _source_descriptor(
+                model,
+                particle_id=current.index.particle_id,
+                crossed=descriptor_key[1],
+            )
+            descriptors[descriptor_key] = descriptor
+        records.append(
+            _source_record(
+                current,
+                leg=leg,
+                descriptor=descriptor,
+                current_id=current_id,
+                source_index=source_index,
+                source_start=source_start,
+                current_slot=current_slots[current_id],
+                value_slot=value_slots[(current_id, "source")],
+                color_state_payload=color_state_payloads[current.index.color_state],
+            )
+        )
+        source_start += current.dimension
+    return records
+
+
+def _source_descriptor(
+    model: Model,
+    *,
+    particle_id: int,
+    crossed: bool,
+) -> _SourceDescriptor:
+    source_ir = model._source_ir(particle_id)
+    applied_crossing = (
+        source_ir.crossing if crossed else type(source_ir.crossing).identity()
+    )
+    expected_states = frozenset(
+        (state.helicity, state.chirality, state.spin_state)
+        for state in (
+            applied_crossing.apply(declared_state)
+            for declared_state in source_ir.states
+        )
+    )
+    return _SourceDescriptor(
+        source_ir=source_ir,
+        applied_crossing=applied_crossing,
+        expected_states=expected_states,
+        crossing=(
+            "negate-incoming-momentum"
+            if applied_crossing.momentum_transform == "negate-four-momentum"
+            else "identity"
+        ),
+        source_ir_payload=source_ir.to_json_dict(),
+        applied_crossing_payload=applied_crossing.to_json_dict(),
+    )
+
+
+def _source_record(
+    current: CurrentNode,
+    *,
+    leg: Any,
+    descriptor: _SourceDescriptor,
+    current_id: int,
+    source_index: int,
+    source_start: int,
+    current_slot: Mapping[str, object],
+    value_slot: Mapping[str, object],
+    color_state_payload: dict[str, object],
+) -> dict[str, object]:
+    if current.source_helicity is None:
+        raise ValueError(f"source current {current_id} has no source helicity")
+    current_state = (
+        int(current.source_helicity),
+        int(current.index.chirality),
+        current.index.spin_state,
+    )
+    if current_state not in descriptor.expected_states:
+        raise ValueError(
+            f"source current {current_id} state {current_state!r} is not declared "
+            f"by model source metadata"
+        )
+    source_ir = descriptor.source_ir
+    return {
+        "source_id": source_index,
+        "current_id": current_id,
+        "current_component_start": current_slot["component_start"],
+        "current_component_stop": current_slot["component_stop"],
+        "value_slot": _value_slot_ref(value_slot),
+        "source_parameter_start": source_start,
+        "source_parameter_stop": source_start + current.dimension,
+        "leg_label": current.source_leg_label,
+        "input_momentum_slot": None if leg is None else leg.label - 1,
+        "side": None if leg is None else leg.side,
+        "crossing": descriptor.crossing,
+        "physical_pdg": None if leg is None else leg.pdg,
+        "outgoing_pdg": current.index.particle_id,
+        "particle_id": current.index.particle_id,
+        "anti_particle_id": source_ir.identity.anti_pdg_label,
+        "source_kind": "external-wavefunction",
+        "wavefunction_kind": source_ir.wavefunction_family,
+        "source_orientation": source_ir.identity.orientation,
+        "source_basis": source_ir.basis,
+        "source_ir": descriptor.source_ir_payload,
+        "applied_crossing": descriptor.applied_crossing_payload,
+        "source_helicity": current.source_helicity,
+        "chirality": current.index.chirality,
+        "spin_state": current_slot["spin_state"],
+        "dimension": current.dimension,
+        "helicity_ancestry": current_slot["helicity_ancestry"],
+        "color_state": color_state_payload,
+    }
+
+
+def _model_payload(dag: GenericDAG, model: Model) -> dict[str, object]:
+    particle_ids = {current.index.particle_id for current in dag.currents}
+    vertex_kinds = {interaction.vertex_kind for interaction in dag.interactions}
+    vertex_kinds.update(
+        root.vertex_kind for root in dag.amplitude_roots if root.vertex_kind is not None
+    )
+    return {
+        "name": model.name,
+        "particles": [
+            {
+                "pdg": particle.pdg,
+                "anti_pdg": particle.anti_pdg,
+                "spin": particle.spin,
+                "dimension": particle.dimension,
+                "color_rep": particle.color_rep,
+                "mass": particle.mass,
+                "width": particle.width,
+                "mass_parameter": _runtime_particle_parameter_name(
+                    model,
+                    particle.pdg,
+                    kind="mass",
+                ),
+                "width_parameter": _runtime_particle_parameter_name(
+                    model,
+                    particle.pdg,
+                    kind="width",
+                ),
+                "charge": particle.charge,
+            }
+            for particle in sorted(model.particles.values(), key=lambda item: item.pdg)
+            if particle.pdg in particle_ids or particle.anti_pdg in particle_ids
+        ],
+        "vertices": [
+            {
+                "kind": vertex.kind,
+                "particles": list(vertex.particles),
+                "coupling": list(vertex.coupling),
+                "lowering": model.vertex_lowering_rule(vertex.kind).to_json_dict(),
+            }
+            for vertex in model.vertices
+            if vertex.kind in vertex_kinds
+        ],
+    }
+
+
+def _runtime_particle_parameter_name(
+    model: Model,
+    pdg: int,
+    *,
+    kind: str,
+) -> str | None:
+    provider = getattr(model, f"runtime_{kind}_parameter_name", None)
+    if not callable(provider):
+        return None
+    name = provider(int(pdg))
+    return None if name is None else str(name)
+
+
+def _external_particles(dag: GenericDAG) -> list[dict[str, object]]:
+    return [
+        {
+            "label": leg.label,
+            "index": leg.label - 1,
+            "side": leg.side,
+            "role": "initial" if leg.is_initial else "final",
+            "particle": leg.particle,
+            "outgoing_particle": leg.outgoing_particle,
+            "pdg": leg.pdg,
+            "outgoing_pdg": leg.outgoing_pdg,
+            "statistics": leg.statistics,
+            "wavefunction_family": leg.wavefunction_family,
+            "color_role": leg.color_role,
+            "source_orientation": leg.source_orientation,
+            "momentum_slot": leg.label - 1,
+            "momentum_components": ["E", "px", "py", "pz"],
+        }
+        for leg in dag.process.legs
+    ]
+
+
+def _momentum_conventions(dag: GenericDAG) -> dict[str, object]:
+    incoming = [leg.label for leg in dag.process.initial_legs]
+    return {
+        "input_shape": ["batch", len(dag.process.legs), 4],
+        "component_order": ["E", "px", "py", "pz"],
+        "input_momenta": "physical external four-momenta in process order",
+        "incoming_labels": incoming,
+        "final_state_labels": [leg.label for leg in dag.process.final_legs],
+        "all_outgoing_convention": {
+            "crossed_incoming_labels": incoming,
+            "operation": "negate incoming four-vectors before current/source use",
+        },
+        "metric": "mostly-minus",
+    }
+
+
+def _input_value_slot(
+    current: CurrentNode,
+    model: Model,
+    value_slots: Mapping[tuple[int, str], Mapping[str, object]],
+) -> Mapping[str, object]:
+    if current.is_source:
+        variant = "source"
+    else:
+        propagator = model._propagator_ir(
+            current.index.particle_id,
+            current.index.chirality,
+        )
+        variant = "propagated" if propagator.applies_propagator else "unpropagated"
+    try:
+        return value_slots[(current.id, variant)]
+    except KeyError as exc:
+        raise ValueError(
+            f"interaction current {current.id} has no {variant} runtime value slot"
+        ) from exc
+
+
+def _result_value_slots(
+    current: CurrentNode,
+    value_slots: Mapping[tuple[int, str], Mapping[str, object]],
+) -> tuple[Mapping[str, object], ...]:
+    result = tuple(
+        value_slots[(current.id, variant)]
+        for variant in ("unpropagated", "propagated")
+        if (current.id, variant) in value_slots
+    )
+    if result:
+        return result
+    if current.is_source:
+        return (value_slots[(current.id, "source")],)
+    raise ValueError(f"result current {current.id} has no runtime value slots")
+
+
+def _value_slot_ref(slot: Mapping[str, object]) -> dict[str, object]:
+    return {
+        key: slot[key]
+        for key in (
+            "value_slot_id",
+            "current_id",
+            "variant",
+            "component_start",
+            "component_stop",
+            "dimension",
+        )
+    }
+
+
+def _spin_state(value: object) -> object:
+    return list(value) if isinstance(value, tuple) else value
+
+
+def _mask_labels(mask: int) -> tuple[int, ...]:
+    return tuple(index + 1 for index in range(mask.bit_length()) if mask & (1 << index))
+
+
+def _mapping(value: object) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise TypeError("runtime schema value must be an object")
+    return value
+
+
+def _sequence(value: object) -> Sequence[object]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise TypeError("runtime schema value must be an array")
+    return value
+
+
+def _mapping_sequence(value: object) -> tuple[Mapping[str, object], ...]:
+    return tuple(_mapping(item) for item in _sequence(value))
+
+
+__all__ = [
+    "RUNTIME_PHYSICS_SCHEMA_VERSION",
+    "RuntimeSchemaLayout",
+    "build_runtime_expression_schema",
+    "build_runtime_schema",
+    "build_runtime_schema_layout",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/service.py b/pyamplicol/src/pyamplicol/generation/service.py
new file mode 100644
index 0000000000..55dc5f2729
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/service.py
@@ -0,0 +1,8784 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import gc
+import hashlib
+import importlib
+import io
+import json
+import logging
+import math
+import os
+import time
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait
+from dataclasses import dataclass, replace
+from fractions import Fraction
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from threading import Lock
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Any, Literal, Protocol, TypeVar, cast
+
+from pyamplicol._internal.versions import (
+    SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+    active_source_revision,
+    verify_native_module,
+)
+from pyamplicol.api.errors import (
+    ArtifactError,
+    GenerationError,
+    ModelError,
+    PyAmpliColError,
+)
+from pyamplicol.api.models import CompiledModel, _compiled_model_payload
+from pyamplicol.api.requests import (
+    ModelSource,
+    ProcessAlias,
+    ProcessRequest,
+    ProcessSet,
+)
+from pyamplicol.api.results import GenerationPlan, GenerationResult, ProcessPhysics
+from pyamplicol.artifacts.process_groups import initial_process_groups
+from pyamplicol.config import (
+    ClampRequest,
+    ConfigResolution,
+    GenerationConfig,
+    RunConfig,
+    config_to_dict,
+    resolve_config,
+)
+from pyamplicol.reporting import (
+    ProgressEnd,
+    ProgressSink,
+    ProgressStart,
+)
+
+from ..color.fft_basis_strategy import best_general_fft_basis
+from ..color.plan import (
+    ColorTopologyReplayCertificate,
+    GenericColorPlan,
+    LCColorTopologyReplayPlan,
+    build_color_plan,
+    build_color_topology_replay_certificate,
+    build_lc_topology_replay_plan,
+)
+from ..models.adjoint_color_certificate import adjoint_tree_color_basis_is_proven
+from ..models.base import Model
+from ..models.loading import CompiledModel as _CompiledModelPayload
+from ..models.prepared import PreparedKernelPack, PreparedModelBundle
+from ..models.prepared_target import PreparedTargetError, validate_prepared_target
+from ..models.recurrence_direct_template import (
+    RECURRENCE_DIRECT_TEMPLATE_ABI,
+    RecurrenceDirectTemplateCatalogV1,
+)
+from ..models.recurrence_template import RecurrenceTemplateCatalog
+from ..processes.ir import CanonicalProcessIR, ProcessLegIR
+from ..runtime.recurrence_exact._plan import _RecurrenceExactPlan
+from ..runtime.recurrence_exact._plan_v2 import DIRECT_NONE_U32, _parse_exact_sections
+from .artifact_writer import (
+    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    EAGER_PLAN_V3_ABI,
+    EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+    EAGER_RUNTIME_CONTAINER_KIND,
+    EAGER_RUNTIME_CONTAINER_SCHEMA_VERSION,
+    EAGER_RUNTIME_LAYOUT_ABI,
+    EAGER_RUNTIME_STORAGE_ABI,
+    RECURRENCE_COLOR_RUNTIME_CAPABILITY,
+    RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+    RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    RECURRENCE_PLAN_ABI,
+    RECURRENCE_RUNTIME_CONTAINER_KIND,
+    RECURRENCE_RUNTIME_CONTAINER_SCHEMA_VERSION,
+    RECURRENCE_RUNTIME_LAYOUT_ABI,
+    RECURRENCE_RUNTIME_STORAGE_ABI,
+    ArtifactWriteResult,
+    CompiledColorSelectorExecutionArtifact,
+    CompiledExecutionArtifact,
+    CompiledHelicitySelectorExecutionArtifact,
+    CompiledProcessArtifact,
+    EagerPlanV3ProcessArtifact,
+    OnTheFlyProcessArtifact,
+    RecurrenceHelicitySelectorPlanArtifact,
+    RecurrenceProcessArtifact,
+    _GenerationConfigProvenance,
+    write_schema_v3_artifact,
+)
+from .contracts import RuntimeExpressionSchema, StageCompilationInput
+from .dag_algorithms import (
+    _infer_minimal_coupling_order_limits_from_color_plan,
+    contributing_color_sector_ids,
+    filter_dag_to_color_sectors,
+    has_model_supported_amplitudes,
+    infer_minimal_coupling_order_limits,
+    prune_dag_to_amplitude_roots,
+    prune_global_helicity_flip_equivalent_roots,
+)
+from .dag_compiler import _restrict_color_plan, compile_generic_dag
+from .dag_equivalence import (
+    NUMERICAL_CURRENT_RELATION_WARNING,
+    NUMERICAL_CURRENT_RELATION_WARNING_CODE,
+    dynamic_color_projection_not_applicable_report,
+    project_rectangular_dynamic_color_classes,
+)
+from .dag_types import GenericDAG
+from .eager_columnar import (
+    EAGER_LOWERING_INPUT_ABI,
+    EagerLoweringInputV1,
+    build_eager_lowering_input_v1,
+    runtime_model_parameter_records_from_eager_input,
+)
+from .eager_lowering import (
+    PreparedCatalogEagerKernelIndex,
+    PreparedCatalogEagerKernelResolver,
+)
+from .eager_tables import MISSING_U32
+from .evaluator_container import (
+    PacbinMemberKind,
+    PacbinMemberSource,
+    write_pacbin_atomic,
+)
+from .helicity_materialization import materialize_helicity_recurrence
+from .helicity_replay import (
+    HELICITY_RECURRENCE_CONTRACT_VERSION,
+    build_helicity_recurrence_plan,
+)
+from .numerical_current_warmup import (
+    generic_dag_numerical_current_opt_out_report,
+    run_generic_dag_numerical_current_warmup,
+)
+from .on_the_fly_seed import (
+    OnTheFlyGenerationProjectionV1,
+    OnTheFlyProcessSeedProjectionV1,
+    project_on_the_fly_process_seed_v1,
+)
+from .physics_metadata import build_resolved_physics_from_dag
+from .process_grouping import (
+    GroupingBasis,
+    GroupingParticle,
+    GroupingProcess,
+    GroupMember,
+    LegMapping,
+    flavor_blind_classes,
+    flavor_blind_mapping,
+    particle_table,
+)
+from .progress import GenerationPhaseReporter, PhaseHandle
+from .recurrence_color import (
+    RECURRENCE_COLOR_CONTRACTION_CODEC_ABI,
+    encode_recurrence_color_contraction,
+    recurrence_color_contraction_digest,
+)
+from .recurrence_columnar import (
+    RECURRENCE_BUILDER_INPUT_ABI,
+    RecurrenceBuilderInputV1,
+    RecurrenceBuilderLogicalInputV1,
+    build_recurrence_builder_input_v1,
+)
+from .recurrence_numerical_current_warmup import (
+    EVIDENCE_ENVELOPE_FALLBACK_REASON,
+    EVIDENCE_ENVELOPE_FALLBACK_WARNING,
+    RecurrenceNumericalCurrentWarmupResult,
+    RecurrenceNumericalEvidenceEnvelopeExceeded,
+    build_recurrence_numerical_current_probe_points,
+    numerical_relation_correctness_payload,
+    recurrence_numerical_current_envelope_fallback_report,
+    recurrence_numerical_current_opt_out_report,
+    recurrence_numerical_evidence_capacity_outcome,
+    recurrence_numerical_relation_correctness_summary,
+    run_recurrence_numerical_current_warmup,
+    validate_recurrence_numerical_current_application,
+    validate_recurrence_numerical_evidence_fallback,
+)
+from .recurrence_physics import (
+    build_on_the_fly_color_contraction,
+    build_on_the_fly_public_metadata,
+    build_on_the_fly_runtime_metadata,
+    build_recurrence_color_contraction,
+    build_recurrence_normalization,
+    build_recurrence_physics,
+    build_recurrence_runtime_metadata,
+    recurrence_color_contraction_destinations,
+    recurrence_color_sector_owner_map,
+    recurrence_exact_color_coefficients,
+    recurrence_referenced_kernel_ids,
+)
+from .recurrence_projection import (
+    RecurrenceGenerationSliceV1,
+    project_recurrence_process_v1,
+)
+from .recurrence_projection import (
+    _digest as _recurrence_projection_digest,
+)
+from .recurrence_schedule_sharing import (
+    RecurrenceProcessRemap,
+    RecurrenceScheduleLoweringCache,
+    _recurrence_schedule_semantic_digests,
+    build_recurrence_process_executor_pack,
+    recurrence_helicity_selector_schedule_digest,
+)
+from .recurrence_template_columnar import (
+    RECURRENCE_TEMPLATE_INPUT_ABI,
+    RecurrenceTemplateInputV1,
+    build_recurrence_template_input_v1,
+)
+from .runtime_schema import (
+    RuntimeSchemaLayout,
+    build_runtime_expression_schema,
+    build_runtime_schema_layout,
+)
+from .stage_compiler import (
+    build_and_write_generic_stage_evaluator_artifacts,
+    write_model_parameter_evaluator_artifact,
+)
+from .validation import (
+    ValidationPointRecord,
+    build_process_validation_point,
+    build_validation_point,
+)
+
+if TYPE_CHECKING:
+    from ..licensing import SymbolicaLicenseState
+    from .artifact_writer import ApiBundleHook, ProcessArtifact
+    from .process_grouping import ProcessGroupMap
+
+
+_ProcessInput = TypeVar("_ProcessInput")
+_ProcessOutput = TypeVar("_ProcessOutput")
+_MISSING_PROCESS_RESULT = object()
+_LOGGER = logging.getLogger("pyamplicol.generation")
+_MAX_FUSED_HELICITY_SELECTOR_SECTORS = 128
+_MAX_POST_BUILD_RESOLVED_COMPONENTS = 1_000_000
+_EAGER_LOWERING_RESULT_KIND = "pyamplicol-eager-runtime-lowering-result"
+_EAGER_LOWERING_RESULT_SCHEMA_VERSION = 1
+_RECURRENCE_LOWERING_RESULT_KIND = "pyamplicol-recurrence-direct-lowering-result"
+_RECURRENCE_LOWERING_RESULT_SCHEMA_VERSION = 4
+_RECURRENCE_HELICITY_DISPATCH_ABI = "pyamplicol-recurrence-helicity-dispatch-v1"
+_RECURRENCE_STRUCTURAL_ZERO_SECTOR_PROOF_KIND = (
+    "complete-recurrence-closure-target-domain-v1"
+)
+_RECURRENCE_GENERATION_PROFILE_TIMINGS = frozenset(
+    {
+        "transition-catalog",
+        "structural-feasibility",
+        "color-target-index",
+        "structural-demand",
+        "support-indexing",
+        "candidate-processing",
+        "closure-processing",
+        "canonical-emission",
+        "python-extraction",
+        "catalog-authentication",
+        "semantic-construction-total",
+        "direct-lowering",
+        "serialization",
+        "native-total",
+    }
+)
+_RECURRENCE_GENERATION_PROFILE_COUNTERS = frozenset(
+    {
+        "support_bucket_count",
+        "support_bucket_probe_count",
+        "support_bucket_cache_hit_count",
+        "support_bucket_cache_miss_count",
+        "candidate_parent_pair_theoretical_count",
+        "candidate_parent_pair_visited_count",
+        "structural_feasible_support_count",
+        "structural_decomposition_count",
+        "structural_forward_transition_probe_count",
+        "structural_demand_support_count",
+        "structural_demand_state_count",
+        "structural_reject_count",
+        "transition_index_hit_count",
+        "transition_index_miss_count",
+        "transition_candidate_count",
+        "quantum_match_count",
+        "coupling_match_count",
+        "transition_accept_count",
+        "color_shape_match_count",
+        "color_result_count",
+        "color_target_accept_count",
+        "color_target_reject_count",
+        "color_acceptance_cache_hit_count",
+        "color_acceptance_cache_miss_count",
+        "color_fragment_bucket_count",
+        "color_fragment_hash_lookup_count",
+        "color_posting_incidence_count",
+        "color_sparse_posting_bucket_count",
+        "color_dense_posting_bucket_count",
+        "color_sparse_posting_bytes",
+        "color_dense_posting_bytes",
+        "accepted_parent_key_clone_count",
+        "current_key_lookup_count",
+        "current_key_hit_count",
+        "current_insert_count",
+        "current_key_clone_count",
+        "indexed_hash_lookup_count",
+        "contribution_attempt_count",
+        "contribution_insert_count",
+        "contribution_merge_count",
+        "closure_candidate_theoretical_count",
+        "closure_candidate_count",
+        "closure_support_lookup_count",
+        "closure_state_match_count",
+        "closure_color_attempt_count",
+        "closure_group_count",
+        "closure_proof_contribution_count",
+        "constructed_current_count",
+        "constructed_contribution_count",
+        "constructed_interaction_count",
+        "constructed_dynamic_color_state_count",
+        "emitted_current_count",
+        "emitted_contribution_count",
+        "emitted_interaction_count",
+        "emitted_finalization_count",
+        "emitted_closure_count",
+    }
+)
+_RECURRENCE_GENERATION_PROFILE_SERIALIZED_BYTES = frozenset(
+    {"plan_payload", "container", "unpacked_container"}
+)
+# Symbolica releases the GIL while retaining process-wide mutable symbol state.
+# Keep each complete lowering/compilation transaction atomic across generators.
+_SYMBOLICA_MATERIALIZATION_LOCK = Lock()
+_RECURRENCE_PROFILE_LOCK = Lock()
+
+
+def _post_build_validation_slices(
+    physics: ProcessPhysics,
+    sample_count: int,
+) -> tuple[tuple[str, tuple[str, ...], tuple[str, ...]], ...]:
+    """Keep resolved-output validation below a bounded component count."""
+
+    helicities = physics.helicities
+    color_flows = physics.color_flows
+    contracted = physics.contracted_color_components
+    color_count = len(color_flows) or len(contracted)
+    full_component_count = sample_count * len(helicities) * color_count
+    if full_component_count <= _MAX_POST_BUILD_RESOLVED_COMPONENTS:
+        return (("complete", (), ()),)
+
+    helicity = next(
+        (item for item in helicities if item.computed and not item.structural_zero),
+        next(
+            (item for item in helicities if not item.structural_zero),
+            helicities[0],
+        ),
+    )
+    helicity_ids = (str(helicity.id),)
+    slices: list[tuple[str, tuple[str, ...], tuple[str, ...]]] = []
+    if sample_count * color_count <= _MAX_POST_BUILD_RESOLVED_COMPONENTS:
+        slices.append(("selected-helicity", helicity_ids, ()))
+
+    if color_flows:
+        color_flow = next(
+            (item for item in color_flows if item.computed),
+            color_flows[0],
+        )
+        color_flow_ids = (str(color_flow.id),)
+        if sample_count * len(helicities) <= _MAX_POST_BUILD_RESOLVED_COMPONENTS:
+            slices.append(("selected-flow", (), color_flow_ids))
+        if not slices:
+            slices.append(("selected-helicity-and-flow", helicity_ids, color_flow_ids))
+    elif not slices:
+        slices.append(("selected-helicity", helicity_ids, ()))
+    return tuple(slices)
+
+
+class _ValidationSelector(Protocol):
+    id: str
+
+
+class _ValidationHelicity(_ValidationSelector, Protocol):
+    structural_zero: bool
+
+
+class _ValidationPhysics(Protocol):
+    color_flows: Sequence[_ValidationSelector]
+    helicities: Sequence[_ValidationHelicity]
+
+
+def _spread_selector_ids(values: Sequence[_ValidationSelector]) -> tuple[str, ...]:
+    """Pick deterministic endpoints and a midpoint without copying an axis."""
+
+    if not values:
+        return ()
+    positions = (0, len(values) // 2, len(values) - 1)
+    selected: list[str] = []
+    for position in positions:
+        identifier = str(values[position].id)
+        if identifier not in selected:
+            selected.append(identifier)
+    return tuple(selected)
+
+
+def _recurrence_validation_selector_cases(
+    physics: _ValidationPhysics,
+) -> tuple[tuple[str, dict[str, tuple[str, ...]]], ...]:
+    """Bound recurrence validation by axis size instead of their product."""
+
+    color_flows = tuple(physics.color_flows)
+    helicities = tuple(physics.helicities)
+    live_helicities = tuple(
+        helicity for helicity in helicities if not helicity.structural_zero
+    )
+    structural_zeros = tuple(
+        helicity for helicity in helicities if helicity.structural_zero
+    )
+    color_ids = _spread_selector_ids(color_flows)
+    helicity_ids = _spread_selector_ids(live_helicities)
+    cases: list[tuple[str, dict[str, tuple[str, ...]]]] = []
+    cases.extend(
+        (
+            f"flow {identifier}",
+            {"color_flows": (identifier,)},
+        )
+        for identifier in color_ids
+    )
+    cases.extend(
+        (
+            f"helicity {identifier}",
+            {"helicities": (identifier,)},
+        )
+        for identifier in helicity_ids
+    )
+    if color_ids and helicity_ids:
+        cases.append(
+            (
+                "combined flow and helicity",
+                {
+                    "color_flows": (color_ids[0],),
+                    "helicities": (helicity_ids[0],),
+                },
+            )
+        )
+    if color_ids and structural_zeros:
+        zero_id = str(structural_zeros[0].id)
+        cases.append(
+            (
+                "structural-zero helicity",
+                {
+                    "color_flows": (color_ids[0],),
+                    "helicities": (zero_id,),
+                },
+            )
+        )
+    return tuple(cases)
+
+
+class _RustEagerLoweringBinding(Protocol):
+    def __call__(
+        self,
+        lowering_input: EagerLoweringInputV1,
+        destination: str,
+        /,
+    ) -> object: ...
+
+
+class _RustRecurrenceLoweringBinding(Protocol):
+    def __call__(
+        self,
+        builder_input: RecurrenceBuilderInputV1,
+        template_input: RecurrenceTemplateInputV1,
+        direct_template_catalog_json: bytes,
+        prepared_kernel_pack_digest: str,
+        schedule_semantic_digest: str,
+        destination: str,
+        /,
+        *,
+        point_tile_size: int,
+        workspace_mib: int,
+        relation_discovery_mode: str,
+        relation_discovery_precision_digits: int,
+        relation_discovery_probe_count: int,
+        relation_discovery_verification_probe_count: int,
+        relation_discovery_relative_tolerance: float,
+        relation_discovery_absolute_tolerance: float,
+        relation_discovery_seed: int,
+        color_accuracy: str,
+        relation_discovery_evidence_json: bytes | None,
+        helicity_dispatch_destination: str | None,
+        progress_callback: Callable[[Mapping[str, object]], None] | None,
+    ) -> object: ...
+
+
+class _RustOnTheFlySeedsBinding(Protocol):
+    def __call__(
+        self,
+        ordered_source_projection_jsons: tuple[bytes, ...],
+        recurrence_template_catalog_json: bytes,
+        direct_template_catalog_json: bytes,
+        prepared_kernel_pack_digest: str,
+        /,
+    ) -> object: ...
+
+
+class _RustOnTheFlySeedInspectorBinding(Protocol):
+    def __call__(self, payload: bytes, /) -> object: ...
+
+
+@dataclass(frozen=True, slots=True)
+class _RustEagerLoweringOutput:
+    inspection_summary: Mapping[str, object]
+    payload_path: Path
+    payload_size_bytes: int
+    payload_sha256: str
+    member_count: int
+    unpacked_size_bytes: int
+    index_sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class _RustRecurrenceHelicityDispatchOutput:
+    payload_path: Path
+    payload_size_bytes: int
+    payload_sha256: str
+    base_runtime_layout_digest: str
+    resolved_helicity_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class _RustRecurrenceStructuralZeroSectorCertificate:
+    sector_ids: tuple[int, ...]
+    semantic_digest: str
+    sector_count: int
+    resolved_helicity_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class _RustRecurrenceLoweringOutput:
+    inspection_summary: Mapping[str, object]
+    resolved_helicities: tuple[tuple[int, ...], ...]
+    amplitude_destinations: tuple[tuple[int, int | None], ...]
+    structural_zero_physical_sector_certificate: (
+        _RustRecurrenceStructuralZeroSectorCertificate | None
+    )
+    exact_sections: Mapping[str, object]
+    generation_profile: Mapping[str, object]
+    numerical_current_reuse_report: Mapping[str, object] | None
+    payload_path: Path
+    payload_size_bytes: int
+    payload_sha256: str
+    member_count: int
+    unpacked_size_bytes: int
+    index_sha256: str
+    helicity_dispatch: _RustRecurrenceHelicityDispatchOutput | None = None
+
+
+def _process_scoped_recurrence_inspection_summary(
+    inspection_summary: Mapping[str, object],
+    *,
+    process_id: str,
+    semantic_digest: str,
+    schedule_digest: str,
+) -> dict[str, object]:
+    """Bind native inspection metadata to its published process identity."""
+
+    result = dict(inspection_summary)
+    result["process_id"] = process_id
+    result["semantic_digest"] = semantic_digest
+    result["schedule_digest"] = schedule_digest
+    return result
+
+
+def _required_process_direct_executor_ids(
+    exact_sections: Mapping[str, object],
+    remap: object,
+) -> tuple[int, ...]:
+    raw_groups = exact_sections.get("row_groups")
+    if isinstance(raw_groups, str | bytes) or not isinstance(raw_groups, Sequence):
+        raise GenerationError(
+            "recurrence exact sections have no typed row-group sequence"
+        )
+    root_ids: set[int] = set()
+    for index, raw_group in enumerate(raw_groups):
+        if (
+            isinstance(raw_group, str | bytes)
+            or not isinstance(raw_group, Sequence)
+            or len(raw_group) != 6
+        ):
+            raise GenerationError(
+                f"recurrence row group {index} does not match plan-v2"
+            )
+        raw_executor_id = raw_group[3]
+        if (
+            isinstance(raw_executor_id, bool)
+            or not isinstance(raw_executor_id, int)
+            or raw_executor_id < 0
+            or raw_executor_id > DIRECT_NONE_U32
+        ):
+            raise GenerationError(
+                f"recurrence row group {index} has an invalid executor ID"
+            )
+        if raw_executor_id != DIRECT_NONE_U32:
+            root_ids.add(raw_executor_id)
+    changes = getattr(remap, "direct_executor_changes", None)
+    count = getattr(remap, "direct_executor_count", None)
+    if (
+        not isinstance(changes, tuple)
+        or isinstance(count, bool)
+        or not isinstance(count, int)
+    ):
+        raise GenerationError("recurrence process has no typed executor remap")
+    mapping = dict(changes)
+    result = tuple(
+        sorted(mapping.get(executor_id, executor_id) for executor_id in root_ids)
+    )
+    if (
+        len(result) != len(root_ids)
+        or len(set(result)) != len(result)
+        or any(executor_id < 0 or executor_id >= count for executor_id in result)
+    ):
+        raise GenerationError(
+            "recurrence process executor remap does not preserve its required set"
+        )
+    return result
+
+
+def _validated_recurrence_evidence_fallback(
+    value: object,
+) -> dict[str, object]:
+    """Validate the one narrow recurrence evidence-fallback record."""
+
+    try:
+        return validate_recurrence_numerical_evidence_fallback(value)
+    except ValueError as exc:
+        raise GenerationError(str(exc)) from exc
+
+
+def _recurrence_relation_reporting(
+    inspection: Mapping[str, object],
+    *,
+    mode: str,
+    lane_report: Mapping[str, object],
+    zero_certificate_baseline_reused: bool = False,
+) -> tuple[dict[str, object], dict[str, object]]:
+    """Separate strict runtime inspection from artifact-wide provenance."""
+
+    if mode not in {"off", "diagnostic", "certified-reuse"}:
+        raise GenerationError(f"unsupported recurrence numerical current mode {mode!r}")
+    certified = _result_integer(
+        lane_report.get("certified_relation_count"),
+        "recurrence certified relation count",
+        minimum=0,
+    )
+    applied = _result_integer(
+        lane_report.get("applied_relation_count"),
+        "recurrence applied relation count",
+        minimum=0,
+    )
+    if lane_report.get("requested_mode") != mode:
+        raise GenerationError(
+            "recurrence numerical current lane mode disagrees with generation"
+        )
+    effective_mode = lane_report.get("effective_mode")
+    effective_reuse_state = lane_report.get("effective_reuse_state")
+    effective_mode_reason = lane_report.get("effective_mode_reason")
+    lane_state = lane_report.get("state")
+    fallback_payload = lane_report.get("fallback")
+    warning = lane_report.get("warning")
+    if not isinstance(warning, Mapping):
+        raise GenerationError(
+            "recurrence numerical current report has no warning contract"
+        )
+    try:
+        relation_correctness = recurrence_numerical_relation_correctness_summary(
+            lane_report
+        )
+    except ValueError as exc:
+        raise GenerationError(str(exc)) from exc
+    no_warning: dict[str, object] = {
+        "required": False,
+        "emit": "never",
+        "code": None,
+        "message": None,
+    }
+    validated_fallback: dict[str, object] | None = None
+    if mode == "off":
+        if (
+            effective_mode != "off"
+            or effective_reuse_state != "disabled"
+            or lane_state != "disabled-by-user"
+            or fallback_payload is not None
+            or certified != 0
+            or applied != 0
+        ):
+            raise GenerationError(
+                "explicit recurrence numerical opt-out metadata is inconsistent"
+            )
+        aggregate_warning = no_warning
+    elif effective_mode == "off":
+        if (
+            mode != "certified-reuse"
+            or effective_reuse_state != "disabled"
+            or lane_state != "disabled-evidence-envelope-fallback"
+            or certified != 0
+            or applied != 0
+        ):
+            raise GenerationError(
+                "recurrence numerical reuse fallback metadata is inconsistent"
+            )
+        validated_fallback = _validated_recurrence_evidence_fallback(fallback_payload)
+        aggregate_warning = {
+            "required": True,
+            "emit": "once-per-generated-artifact",
+            "code": EVIDENCE_ENVELOPE_FALLBACK_REASON,
+            "message": EVIDENCE_ENVELOPE_FALLBACK_WARNING,
+        }
+    elif effective_mode in {"diagnostic", "certified-reuse"}:
+        expected_applied = certified if effective_mode == "certified-reuse" else 0
+        application_scope = lane_report.get("application_scope")
+        if (
+            effective_mode == "certified-reuse"
+            and isinstance(application_scope, Mapping)
+            and application_scope.get("contracted_opposite_application") == "disabled"
+        ):
+            application = lane_report.get("application")
+            relation_counts = (
+                application.get("relation_kind_counts")
+                if isinstance(application, Mapping)
+                else None
+            )
+            if not isinstance(relation_counts, Mapping):
+                raise GenerationError(
+                    "recurrence numerical application has no relation-kind counts"
+                )
+            expected_applied -= _result_integer(
+                relation_counts.get("opposite"),
+                "recurrence suppressed opposite relation count",
+                minimum=0,
+            )
+        expected_state = (
+            "no_certified_numerical_relation"
+            if certified == 0
+            else (
+                "authenticated-numerical-applied"
+                if effective_mode == "certified-reuse"
+                else "authenticated-numerical-diagnostic-only"
+            )
+        )
+        expected_reuse_state = (
+            "enabled"
+            if effective_mode == "certified-reuse" or mode == "diagnostic"
+            else "disabled"
+        )
+        if mode == "certified-reuse" and effective_mode == "diagnostic":
+            if (
+                effective_mode_reason
+                not in {
+                    "multi-helicity-all-flow-member-scope-unproven",
+                    "contracted-opposite-binary64-disabled",
+                }
+                or not isinstance(application_scope, Mapping)
+                or application_scope.get("effective_mode_reason")
+                != effective_mode_reason
+            ):
+                raise GenerationError(
+                    "recurrence numerical diagnostic containment has no "
+                    "application-scope reason"
+                )
+        elif effective_mode_reason is not None:
+            raise GenerationError(
+                "recurrence numerical current mode has a spurious downgrade reason"
+            )
+        if (
+            (effective_mode == "certified-reuse" and mode != "certified-reuse")
+            or effective_reuse_state != expected_reuse_state
+            or lane_state != expected_state
+            or fallback_payload is not None
+            or applied != expected_applied
+        ):
+            raise GenerationError(
+                "active recurrence numerical current metadata is inconsistent"
+            )
+        aggregate_warning = (
+            {
+                "required": True,
+                "emit": "once-per-generated-artifact",
+                "code": NUMERICAL_CURRENT_RELATION_WARNING_CODE,
+                "message": NUMERICAL_CURRENT_RELATION_WARNING,
+            }
+            if applied
+            else no_warning
+        )
+    else:
+        raise GenerationError(
+            "recurrence numerical current effective mode is inconsistent"
+        )
+    if dict(warning) != aggregate_warning:
+        raise GenerationError(
+            "recurrence numerical current report changed its warning contract"
+        )
+    warning_required = bool(aggregate_warning["required"])
+    warning_code = aggregate_warning["code"]
+    runtime_inspection = dict(inspection)
+    native = runtime_inspection.pop("relation_discovery", None)
+    if native is not None and not isinstance(native, Mapping):
+        raise GenerationError(
+            "native recurrence relation application report is not a mapping"
+        )
+    if effective_mode == "off":
+        if native is not None:
+            raise GenerationError(
+                "disabled recurrence numerical current lane published application state"
+            )
+    elif native is None and zero_certificate_baseline_reused:
+        if certified != 0 or applied != 0:
+            raise GenerationError(
+                "recurrence baseline reuse requires an empty certificate set"
+            )
+    else:
+        if not isinstance(native, Mapping):
+            raise GenerationError(
+                "recurrence numerical current lane has no native application report"
+            )
+        native_certified = _result_integer(
+            native.get("exact_certified_relation_count"),
+            "native recurrence certified relation count",
+            minimum=0,
+        )
+        native_applied = _result_integer(
+            native.get("applied_relation_count"),
+            "native recurrence applied relation count",
+            minimum=0,
+        )
+        native_certificate_count = _result_integer(
+            native.get("certificate_count"),
+            "native recurrence certificate count",
+            minimum=0,
+        )
+        if (
+            native.get("requested_mode") != effective_mode
+            or native_certified != certified
+            or native_applied != applied
+            or native_certificate_count != certified
+        ):
+            raise GenerationError(
+                "native recurrence relation counts disagree with the "
+                "authenticated warm-up"
+            )
+        if warning_required != (applied > 0) or (
+            warning_required and warning_code != NUMERICAL_CURRENT_RELATION_WARNING_CODE
+        ):
+            raise GenerationError(
+                "recurrence numerical current application or warning state "
+                "is inconsistent"
+            )
+        application = lane_report.get("application")
+        native_replay = native.get("certificate_replay")
+        if not isinstance(application, Mapping) or not isinstance(
+            native_replay, Mapping
+        ):
+            raise GenerationError(
+                "recurrence numerical current certificate replay metadata is absent"
+            )
+        lane_replay = application.get("certificate_replay")
+        if not isinstance(lane_replay, Mapping) or any(
+            native_replay.get(key) != lane_replay.get(key)
+            for key in ("algorithm", "certificate_set_sha256")
+        ):
+            raise GenerationError(
+                "native recurrence certificate replay disagrees with the warm-up"
+            )
+        candidate_capture = lane_report.get("candidate_capture")
+        verification_capture = lane_report.get("verification_capture")
+        native_probe = native.get("probe")
+        if (
+            not isinstance(candidate_capture, Mapping)
+            or not isinstance(verification_capture, Mapping)
+            or not isinstance(native_probe, Mapping)
+            or native_probe.get("probe_count") != candidate_capture.get("point_count")
+            or native_probe.get("verification_probe_count")
+            != verification_capture.get("point_count")
+        ):
+            raise GenerationError(
+                "native recurrence probe counts disagree with the warm-up"
+            )
+        discovery = lane_report.get("discovery")
+        if not isinstance(discovery, Mapping) or any(
+            native_value != discovery.get(discovery_key)
+            for native_value, discovery_key in (
+                (
+                    native.get("numerical_candidate_count"),
+                    "numerical_candidate_count",
+                ),
+                (
+                    native_probe.get("verification_rejected_count"),
+                    "verification_rejected_count",
+                ),
+                (
+                    native.get("uncertified_candidate_count"),
+                    "verification_rejected_count",
+                ),
+                (
+                    native.get("rejected_hypothesis_count"),
+                    "rejected_hypothesis_count",
+                ),
+                (
+                    native_probe.get("tested_hypothesis_count"),
+                    "tested_hypothesis_count",
+                ),
+            )
+        ):
+            raise GenerationError(
+                "native recurrence candidate counters disagree with the warm-up"
+            )
+        candidate_commitment = candidate_capture.get("observation_batch_sha256")
+        verification_commitment = verification_capture.get("observation_batch_sha256")
+        if any(
+            native_probe.get(key) != expected
+            for key, expected in (
+                (
+                    "runtime_parameter_schema_sha256",
+                    candidate_capture.get("runtime_parameter_schema_sha256"),
+                ),
+                (
+                    "candidate_observation_batch_sha256",
+                    candidate_commitment,
+                ),
+                (
+                    "verification_observation_batch_sha256",
+                    verification_commitment,
+                ),
+                ("decision_sha256", discovery.get("decision_sha256")),
+                (
+                    "rejection_decision_sha256",
+                    discovery.get("rejection_decision_sha256"),
+                ),
+            )
+        ):
+            raise GenerationError(
+                "native recurrence raw-evidence commitments disagree with "
+                "the authenticated warm-up"
+            )
+        rejected_diagnostics = native.get("rejected_candidate_diagnostics")
+        if (
+            not isinstance(rejected_diagnostics, Mapping)
+            or rejected_diagnostics.get("total_rejected_hypothesis_count")
+            != discovery.get("rejected_hypothesis_count")
+            or rejected_diagnostics.get("full_rejection_sha256")
+            != discovery.get("rejection_decision_sha256")
+        ):
+            raise GenerationError(
+                "native recurrence rejected-hypothesis diagnostics disagree "
+                "with the authenticated warm-up"
+            )
+    aggregate = {
+        "schema_version": 1,
+        "abi": "pyamplicol-artifact-numerical-current-reuse-v1",
+        "requested_mode": mode,
+        "effective_mode": effective_mode,
+        "effective_reuse_state": effective_reuse_state,
+        "execution_mode": "recurrence",
+        "lane_count": 1,
+        "lanes": {"primary": dict(lane_report)},
+        "certified_relation_count": certified,
+        "applied_relation_count": applied,
+        "relation_correctness": relation_correctness,
+        "structural_exact_discovery": None,
+        "opt_out_flag": "--no-numerical-current-reuse",
+        "fallback": validated_fallback,
+        "warning": aggregate_warning,
+        "native_relation_application": (None if native is None else dict(native)),
+    }
+    return runtime_inspection, aggregate
+
+
+def _publish_validated_recurrence_baseline(
+    *,
+    baseline: _RustRecurrenceLoweringOutput,
+    final_schedule_path: Path,
+) -> _RustRecurrenceLoweringOutput:
+    """Move one validated mode-off payload to its final destination."""
+
+    if final_schedule_path.exists() or final_schedule_path.is_symlink():
+        raise GenerationError(
+            f"recurrence schedule destination already exists: {final_schedule_path}"
+        )
+    try:
+        final_schedule_path.parent.mkdir(parents=True, exist_ok=True)
+        baseline.payload_path.replace(final_schedule_path)
+    except OSError as exc:
+        raise GenerationError(
+            "failed to publish the validated recurrence baseline payload"
+        ) from exc
+    return replace(baseline, payload_path=final_schedule_path)
+
+
+def _lower_recurrence_after_numerical_warmup(
+    *,
+    lower_once: Callable[..., _RustRecurrenceLoweringOutput],
+    final_schedule_path: Path,
+    baseline: _RustRecurrenceLoweringOutput,
+    warmup: RecurrenceNumericalCurrentWarmupResult,
+    requested_mode: str,
+) -> tuple[_RustRecurrenceLoweringOutput, bool]:
+    """Lower any certified relation set, or publish its unchanged baseline."""
+
+    if warmup.certificates:
+        return (
+            lower_once(
+                final_schedule_path,
+                mode=warmup.effective_mode,
+                evidence=warmup.evidence_json,
+                report_progress=False,
+                timing_name="native-final-generation",
+            ),
+            True,
+        )
+    runtime_inspection, aggregate_report = _recurrence_relation_reporting(
+        baseline.inspection_summary,
+        mode=requested_mode,
+        lane_report=warmup.to_json_dict(),
+        zero_certificate_baseline_reused=True,
+    )
+    published = _publish_validated_recurrence_baseline(
+        baseline=baseline,
+        final_schedule_path=final_schedule_path,
+    )
+    return (
+        replace(
+            published,
+            inspection_summary=runtime_inspection,
+            generation_profile={
+                "schema_version": 1,
+                "native_passes": {"final": dict(baseline.generation_profile)},
+            },
+            numerical_current_reuse_report=aggregate_report,
+        ),
+        False,
+    )
+
+
+def _complete_recurrence_evidence_envelope_fallback(
+    *,
+    final_schedule_path: Path,
+    baseline: _RustRecurrenceLoweringOutput,
+    baseline_plan: _RecurrenceExactPlan,
+    color_accuracy: str,
+    outcome: RecurrenceNumericalEvidenceEnvelopeExceeded,
+    warmup_owner: list[RecurrenceNumericalCurrentWarmupResult] | None = None,
+) -> _RustRecurrenceLoweringOutput:
+    """Publish the validated mode-off baseline after a reuse fallback."""
+
+    if warmup_owner is None:
+        warmup = None
+    else:
+        if len(warmup_owner) != 1:
+            raise AssertionError(
+                "recurrence fallback requires exactly one warm-up owner"
+            )
+        warmup = warmup_owner.pop()
+        warmup.close()
+    # Drop the transport, both captures and their spool owners before the
+    # baseline payload is published.  The caller has already cleared exception
+    # chains and transferred its only warm-up reference through this owner.
+    warmup = None
+    lane_report = recurrence_numerical_current_envelope_fallback_report(
+        baseline_plan.sections,
+        color_accuracy=color_accuracy,
+        requested_mode="certified-reuse",
+        outcome=outcome,
+    )
+    runtime_inspection, aggregate_report = _recurrence_relation_reporting(
+        baseline.inspection_summary,
+        mode="certified-reuse",
+        lane_report=lane_report,
+    )
+    published = _publish_validated_recurrence_baseline(
+        baseline=baseline,
+        final_schedule_path=final_schedule_path,
+    )
+    return replace(
+        published,
+        inspection_summary=runtime_inspection,
+        generation_profile={
+            "schema_version": 1,
+            "native_passes": {"final": dict(baseline.generation_profile)},
+        },
+        numerical_current_reuse_report=aggregate_report,
+    )
+
+
+def _detached_recurrence_evidence_envelope_outcome(
+    outcome: RecurrenceNumericalEvidenceEnvelopeExceeded,
+    *,
+    source_error: BaseException,
+) -> RecurrenceNumericalEvidenceEnvelopeExceeded:
+    """Copy fallback metadata while releasing exception-retained work state."""
+
+    detached = RecurrenceNumericalEvidenceEnvelopeExceeded(
+        outcome.geometry,
+        memory_envelope_bytes=outcome.memory_envelope_bytes,
+        spooled_producer_resident_bytes=(outcome.spooled_producer_resident_bytes),
+        raw_reason=outcome.raw_reason,
+    )
+    pending = [source_error]
+    if outcome is not source_error:
+        pending.append(outcome)
+    seen: set[int] = set()
+    while pending:
+        error = pending.pop()
+        identity = id(error)
+        if identity in seen:
+            continue
+        seen.add(identity)
+        cause = error.__cause__
+        context = error.__context__
+        error.__traceback__ = None
+        error.__cause__ = None
+        error.__context__ = None
+        if cause is not None:
+            pending.append(cause)
+        if context is not None:
+            pending.append(context)
+    return detached
+
+
+def _invoke_rust_eager_lowering_v1(
+    lowering_input: EagerLoweringInputV1,
+    destination: Path,
+) -> _RustEagerLoweringOutput:
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(module)
+    except ImportError as exc:
+        raise GenerationError(
+            "eager generation requires pyamplicol._rusticol with the "
+            "eager plan-v3 lowering binding"
+        ) from exc
+    candidate = getattr(module, "_lower_eager_runtime_v1", None)
+    if not callable(candidate):
+        raise GenerationError(
+            "pyamplicol._rusticol does not provide the required private "
+            "_lower_eager_runtime_v1 binding for eager plan-v3 generation"
+        )
+    binding = cast(_RustEagerLoweringBinding, candidate)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if destination.exists() or destination.is_symlink():
+        raise GenerationError(
+            f"Rust eager lowering destination already exists: {destination}"
+        )
+    try:
+        raw_result = binding(lowering_input, os.fspath(destination))
+        result = _validate_rust_eager_lowering_result(raw_result, lowering_input)
+        if destination.is_symlink() or not destination.is_file():
+            raise GenerationError(
+                "Rust eager lowering did not produce a regular eager-runtime.pacbin"
+            )
+        payload_size = destination.stat().st_size
+        if payload_size <= 0:
+            raise GenerationError(
+                "Rust eager lowering produced an empty runtime payload"
+            )
+        payload_sha256 = _file_sha256(destination)
+    except Exception as exc:
+        _discard_rust_eager_output(destination)
+        if isinstance(exc, GenerationError):
+            raise
+        raise GenerationError(f"Rust eager plan-v3 lowering failed: {exc}") from exc
+    return _RustEagerLoweringOutput(
+        inspection_summary=result["inspection_summary"],
+        payload_path=destination,
+        payload_size_bytes=payload_size,
+        payload_sha256=payload_sha256,
+        member_count=cast(int, result["member_count"]),
+        unpacked_size_bytes=cast(int, result["unpacked_size_bytes"]),
+        index_sha256=cast(str, result["index_sha256"]),
+    )
+
+
+def _invoke_rust_on_the_fly_seed_batch_builder_v1(
+    ordered_source_projection_jsons: Sequence[bytes],
+    recurrence_template_catalog_json: bytes,
+    direct_template_catalog_json: bytes,
+    prepared_kernel_pack_digest: str,
+    *,
+    process_identities: Sequence[str] = (),
+) -> tuple[bytes, ...]:
+    ordered_sources = tuple(ordered_source_projection_jsons)
+    identities = tuple(process_identities)
+    if identities and len(identities) != len(ordered_sources):
+        raise GenerationError(
+            "on-the-fly process identities do not align with source projections"
+        )
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(module)
+    except (ImportError, OSError, RuntimeError) as exc:
+        raise GenerationError(
+            "on-the-fly generation requires the current native "
+            "_build_on_the_fly_process_seeds_v1 binding"
+        ) from exc
+    candidate = getattr(module, "_build_on_the_fly_process_seeds_v1", None)
+    if not callable(candidate):
+        raise GenerationError(
+            "pyamplicol._rusticol does not provide the private "
+            "_build_on_the_fly_process_seeds_v1 binding"
+        )
+    binding = cast(_RustOnTheFlySeedsBinding, candidate)
+    try:
+        result = binding(
+            ordered_sources,
+            recurrence_template_catalog_json,
+            direct_template_catalog_json,
+            prepared_kernel_pack_digest,
+        )
+    except Exception as exc:
+        detail = str(exc)
+        attributed = next(
+            (
+                (index, identities[index])
+                for index in range(len(identities) - 1, -1, -1)
+                if f"index {index} " in detail
+            ),
+            None,
+        )
+        context = (
+            ""
+            if attributed is None
+            else f" for process index {attributed[0]} {attributed[1]!r}"
+        )
+        raise GenerationError(
+            f"on-the-fly process-seed construction failed{context}: {detail}"
+        ) from exc
+    if not isinstance(result, (list, tuple)) or len(result) != len(ordered_sources):
+        raise GenerationError(
+            "native on-the-fly process-seed builder returned a result with the "
+            "wrong process count"
+        )
+    payloads: list[bytes] = []
+    for index, payload in enumerate(result):
+        if not isinstance(payload, bytes) or not payload:
+            identity = "" if not identities else f" {identities[index]!r}"
+            raise GenerationError(
+                "native on-the-fly process-seed builder returned an empty payload "
+                f"for process index {index}{identity}"
+            )
+        payloads.append(payload)
+    return tuple(payloads)
+
+
+def _invoke_rust_on_the_fly_seed_builder_v1(
+    source_projection_json: bytes,
+    recurrence_template_catalog_json: bytes,
+    direct_template_catalog_json: bytes,
+    prepared_kernel_pack_digest: str,
+) -> bytes:
+    """Retain the original singleton bridge as a plural-path wrapper."""
+
+    return _invoke_rust_on_the_fly_seed_batch_builder_v1(
+        (source_projection_json,),
+        recurrence_template_catalog_json,
+        direct_template_catalog_json,
+        prepared_kernel_pack_digest,
+    )[0]
+
+
+_ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI = "pyamplicol-on-the-fly-process-seed-identity-v1"
+_U64_MAX = (1 << 64) - 1
+_ON_THE_FLY_PROCESS_SEED_IDENTITY_FIELDS = frozenset(
+    {
+        "abi",
+        "process_digest",
+        "compiled_model_digest",
+        "recurrence_template_catalog_digest",
+        "prepared_kernel_pack_digest",
+        "recurrence_direct_template_catalog_digest",
+        "semantic_digest",
+        "external_permutation",
+        "external_sources",
+    }
+)
+
+
+def _on_the_fly_selector_census_v1(
+    projection: OnTheFlyProcessSeedProjectionV1,
+    process: CanonicalProcessIR,
+) -> dict[str, int]:
+    """Count complete compact selector axes without materializing either axis."""
+
+    helicity_count = math.prod(
+        len(source.source_states) for source in projection.external_sources
+    )
+    if len(projection.external_sources) != len(process.legs) or any(
+        leg.color_role == "inclusive" for leg in process.legs
+    ):
+        raise GenerationError(
+            "on-the-fly selector census requires one concrete source per process leg"
+        )
+    fundamental_count = len(process.fundamental_labels)
+    antifundamental_count = len(process.antifundamental_labels)
+    adjoint_count = len(process.adjoint_labels)
+    if fundamental_count != antifundamental_count:
+        raise GenerationError(
+            "on-the-fly selector census found unbalanced LC open-line endpoints"
+        )
+    if fundamental_count:
+        color_flow_count = (
+            math.factorial(fundamental_count)
+            * math.factorial(adjoint_count)
+            * math.comb(
+                adjoint_count + fundamental_count - 1,
+                fundamental_count - 1,
+            )
+        )
+    elif adjoint_count:
+        color_flow_count = math.factorial(max(adjoint_count - 1, 0))
+    else:
+        color_flow_count = 1
+    census = {
+        "physical_helicity_count": helicity_count,
+        # Contracted NLC/full exposes one physical result; ``color_flow_count``
+        # remains the private structural-selector domain bound by the color
+        # payload destinations.
+        "physical_color_flow_count": (
+            color_flow_count if getattr(process, "color_accuracy", "lc") == "lc" else 1
+        ),
+    }
+    for name, count in census.items():
+        if count < 1 or count > _U64_MAX:
+            raise GenerationError(
+                f"on-the-fly selector census {name} is outside the positive u64 domain"
+            )
+    return census
+
+
+def _on_the_fly_validation_selectors_v1(
+    projection: OnTheFlyProcessSeedProjectionV1,
+    *,
+    color_accuracy: str = "lc",
+) -> Mapping[str, tuple[str, ...]]:
+    """Choose one deterministic compact selector without opening dense axes."""
+
+    helicities: list[int] = []
+    for source_index, source in enumerate(projection.external_sources):
+        if not source.source_states:
+            raise GenerationError(
+                "on-the-fly validation source "
+                f"{source_index} exposes no public helicity states"
+            )
+        helicities.append(int(source.source_states[0].public_helicity))
+    if not helicities:
+        raise GenerationError("on-the-fly validation requires external sources")
+    helicity_id = "h:" + ",".join(f"{value:+d}" for value in helicities)
+    return MappingProxyType(
+        {
+            "helicities": (helicity_id,),
+            "color_flows": (() if color_accuracy in {"nlc", "full"} else ("1",)),
+        }
+    )
+
+
+def _build_on_the_fly_contracted_color_payload_v1(
+    color_plan: GenericColorPlan,
+    *,
+    contraction: str = "direct",
+) -> _OnTheFlyContractedColorPayloadV1:
+    """Encode the contracted metric over compact structural selector ordinals."""
+
+    contraction, sector_owner_ids, owner_sector_ids = (
+        build_on_the_fly_color_contraction(
+            color_plan,
+            contraction=contraction,
+        )
+    )
+    group_count = contraction.group_count
+    destination_count = len(owner_sector_ids)
+    destination_by_group = (
+        tuple(range(group_count))
+        if contraction.destination_by_group is None
+        else contraction.destination_by_group
+    )
+    if (
+        len(destination_by_group) != group_count
+        or len(set(destination_by_group)) != group_count
+        or any(
+            destination_id < 0 or destination_id >= destination_count
+            for destination_id in destination_by_group
+        )
+    ):
+        raise ValueError(
+            "on-the-fly color contraction has an invalid destination projection"
+        )
+    normalized_owner_sector_ids = tuple(
+        owner_sector_ids[destination_id] for destination_id in destination_by_group
+    )
+    payload = encode_recurrence_color_contraction(
+        contraction,
+        sector_count=color_plan.sector_count,
+        component_count=1,
+        ordered_group_ids=tuple(range(group_count)),
+        destination_by_group=destination_by_group,
+        destination_count=destination_count,
+        group_sector_ids=normalized_owner_sector_ids,
+        group_component_ids=(0,) * group_count,
+        sector_owner_ids=sector_owner_ids,
+        exact_coefficients=recurrence_exact_color_coefficients(
+            color_plan,
+            contraction,
+            normalized_owner_sector_ids,
+        ),
+    )
+    semantic_digest = recurrence_color_contraction_digest(payload)
+    symmetric_group = contraction.symmetric_group_block
+    summary = MappingProxyType(
+        {
+            "abi": RECURRENCE_COLOR_CONTRACTION_CODEC_ABI,
+            "color_accuracy": contraction.color_accuracy,
+            "storage": (
+                "convolution-kernels" if symmetric_group is not None else "expanded"
+            ),
+            "includes_color_factor": contraction.includes_color_factor,
+            "group_count": group_count,
+            "sector_count": color_plan.sector_count,
+            "active_sector_count": group_count,
+            "component_count": 1,
+            "destination_count": destination_count,
+            "entry_count": (
+                len(contraction.entries)
+                if symmetric_group is None
+                else symmetric_group.stored_entry_count
+            ),
+            "logical_entry_count": contraction.logical_entry_count,
+            "semantic_digest": semantic_digest,
+            "factorization": (
+                None
+                if symmetric_group is None
+                else {
+                    "kind": "symmetric-group-fourier",
+                    "rank": symmetric_group.degree,
+                    "coset_count": symmetric_group.channel_count,
+                }
+            ),
+            **(
+                {}
+                if symmetric_group is None
+                else {
+                    "fft_provenance": {
+                        "method": "symmetric-group-fourier",
+                        "degree": symmetric_group.degree,
+                        "channel_count": symmetric_group.channel_count,
+                        "covered_local_group_count": (
+                            symmetric_group.channel_count
+                            * math.factorial(symmetric_group.degree)
+                        ),
+                        "residual_group_count": len(
+                            symmetric_group.residual_local_group_indices
+                        ),
+                        "residual_entry_count": len(symmetric_group.residual_entries),
+                        "raw_kernel_bytes": len(symmetric_group.kernel_entries) * 16,
+                        "transformed_kernel_bytes": (
+                            len(symmetric_group.kernel_entries) * 8
+                        ),
+                        "capability": (SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY),
+                    }
+                }
+            ),
+        }
+    )
+    return _OnTheFlyContractedColorPayloadV1(
+        payload=payload,
+        summary=summary,
+        owner_sector_ids=normalized_owner_sector_ids,
+        destination_by_group=destination_by_group,
+    )
+
+
+def _validate_on_the_fly_process_seed_identity_v1(
+    value: object,
+) -> dict[str, object]:
+    if not isinstance(value, Mapping) or set(value) != (
+        _ON_THE_FLY_PROCESS_SEED_IDENTITY_FIELDS
+    ):
+        raise GenerationError(
+            "native on-the-fly process-seed identity has the wrong fields"
+        )
+    result = {str(key): item for key, item in value.items()}
+    if result["abi"] != _ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI:
+        raise GenerationError(
+            "native on-the-fly process-seed identity has an unsupported ABI"
+        )
+    for field in (
+        "process_digest",
+        "compiled_model_digest",
+        "recurrence_template_catalog_digest",
+        "prepared_kernel_pack_digest",
+        "recurrence_direct_template_catalog_digest",
+        "semantic_digest",
+    ):
+        digest = result[field]
+        if (
+            not isinstance(digest, str)
+            or len(digest) != 64
+            or any(character not in "0123456789abcdef" for character in digest)
+        ):
+            raise GenerationError(
+                f"native on-the-fly process-seed identity {field} is not SHA-256"
+            )
+    permutation = result["external_permutation"]
+    sources = result["external_sources"]
+    if (
+        not isinstance(permutation, list)
+        or not isinstance(sources, list)
+        or not sources
+        or len(permutation) != len(sources)
+        or any(
+            isinstance(slot, bool) or not isinstance(slot, int) for slot in permutation
+        )
+        or sorted(permutation) != list(range(len(permutation)))
+    ):
+        raise GenerationError(
+            "native on-the-fly process-seed identity has an invalid external domain"
+        )
+    labels: set[int] = set()
+    for source_index, raw_source in enumerate(sources):
+        if not isinstance(raw_source, Mapping) or set(raw_source) != {
+            "source_slot",
+            "public_label",
+            "is_initial",
+            "states",
+        }:
+            raise GenerationError(
+                "native on-the-fly process-seed identity has an invalid source row"
+            )
+        source_slot = raw_source["source_slot"]
+        public_label = raw_source["public_label"]
+        states = raw_source["states"]
+        if (
+            isinstance(source_slot, bool)
+            or source_slot != source_index
+            or isinstance(public_label, bool)
+            or not isinstance(public_label, int)
+            or public_label < 1
+            or public_label in labels
+            or not isinstance(raw_source["is_initial"], bool)
+            or not isinstance(states, list)
+            or not states
+        ):
+            raise GenerationError(
+                "native on-the-fly process-seed identity has a noncanonical "
+                "source domain"
+            )
+        labels.add(public_label)
+        previous_state_index = -1
+        for raw_state in states:
+            if not isinstance(raw_state, Mapping) or set(raw_state) != {
+                "state_index",
+                "public_helicity",
+                "prepared_mass_parameter_slot",
+            }:
+                raise GenerationError(
+                    "native on-the-fly process-seed identity has an invalid "
+                    "source state"
+                )
+            state_index = raw_state["state_index"]
+            helicity = raw_state["public_helicity"]
+            mass_slot = raw_state["prepared_mass_parameter_slot"]
+            if (
+                isinstance(state_index, bool)
+                or not isinstance(state_index, int)
+                or state_index <= previous_state_index
+                or isinstance(helicity, bool)
+                or not isinstance(helicity, int)
+                or (
+                    mass_slot is not None
+                    and (
+                        isinstance(mass_slot, bool)
+                        or not isinstance(mass_slot, int)
+                        or mass_slot < 0
+                    )
+                )
+            ):
+                raise GenerationError(
+                    "native on-the-fly process-seed identity has a noncanonical "
+                    "source state"
+                )
+            previous_state_index = state_index
+    return result
+
+
+def _bind_on_the_fly_process_seed_identity_v1(
+    identity: Mapping[str, object],
+    projection: OnTheFlyProcessSeedProjectionV1,
+) -> None:
+    """Bind the native seed identity to its authoritative Python projection."""
+
+    if identity["process_digest"] != projection.process_digest:
+        raise GenerationError(
+            "native on-the-fly process-seed process digest disagrees with "
+            "the source projection"
+        )
+    if identity["external_permutation"] != list(projection.external_permutation):
+        raise GenerationError(
+            "native on-the-fly process-seed external permutation disagrees "
+            "with the source projection"
+        )
+
+    native_sources = cast(list[Mapping[str, object]], identity["external_sources"])
+    native_domain = tuple(
+        (
+            source["source_slot"],
+            source["public_label"],
+            source["is_initial"],
+            tuple(
+                (state["state_index"], state["public_helicity"])
+                for state in cast(list[Mapping[str, object]], source["states"])
+            ),
+        )
+        for source in native_sources
+    )
+    projected_domain = tuple(
+        (
+            source.source_slot,
+            source.public_label,
+            source.is_initial,
+            tuple(
+                (state.state_index, state.public_helicity)
+                for state in source.source_states
+            ),
+        )
+        for source in projection.external_sources
+    )
+    if native_domain != projected_domain:
+        raise GenerationError(
+            "native on-the-fly process-seed external source domain "
+            "disagrees with the source projection"
+        )
+
+
+def _invoke_rust_on_the_fly_seed_inspector_v1(
+    seed_payload: bytes,
+) -> dict[str, object]:
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(module)
+    except (ImportError, OSError, RuntimeError) as exc:
+        raise GenerationError(
+            "on-the-fly generation requires the current native "
+            "_inspect_on_the_fly_process_seed_v1 binding"
+        ) from exc
+    candidate = getattr(module, "_inspect_on_the_fly_process_seed_v1", None)
+    if not callable(candidate):
+        raise GenerationError(
+            "pyamplicol._rusticol does not provide the private "
+            "_inspect_on_the_fly_process_seed_v1 binding"
+        )
+    binding = cast(_RustOnTheFlySeedInspectorBinding, candidate)
+    try:
+        encoded = binding(seed_payload)
+        if not isinstance(encoded, str):
+            raise TypeError("native inspector did not return JSON text")
+        decoded = json.loads(encoded)
+    except (TypeError, ValueError) as exc:
+        raise GenerationError(
+            f"native on-the-fly process-seed inspection failed: {exc}"
+        ) from exc
+    except Exception as exc:
+        raise GenerationError(
+            f"native on-the-fly process-seed inspection failed: {exc}"
+        ) from exc
+    return _validate_on_the_fly_process_seed_identity_v1(decoded)
+
+
+def _invoke_rust_recurrence_lowering_v2(
+    builder_input: RecurrenceBuilderInputV1,
+    template_input: RecurrenceTemplateInputV1,
+    direct_template_catalog: RecurrenceDirectTemplateCatalogV1,
+    prepared_kernel_pack_digest: str,
+    schedule_semantic_digest: str,
+    destination: Path,
+    *,
+    point_tile_size: int,
+    workspace_mib: int,
+    relation_discovery_mode: str,
+    relation_discovery_precision_digits: int,
+    relation_discovery_probe_count: int,
+    relation_discovery_verification_probe_count: int,
+    relation_discovery_relative_tolerance: float,
+    relation_discovery_absolute_tolerance: float,
+    relation_discovery_seed: int,
+    color_accuracy: str,
+    relation_discovery_evidence_json: bytes | None = None,
+    helicity_dispatch_destination: Path | None = None,
+    progress_callback: Callable[[Mapping[str, object]], None] | None = None,
+    direct_template_catalog_json: bytes | None = None,
+) -> _RustRecurrenceLoweringOutput:
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(module)
+    except ImportError as exc:
+        raise GenerationError(
+            "recurrence generation requires the native "
+            "_lower_recurrence_direct_v2 binding"
+        ) from exc
+    candidate = getattr(module, "_lower_recurrence_direct_v2", None)
+    if not callable(candidate):
+        raise GenerationError(
+            "pyamplicol._rusticol does not provide the private "
+            "_lower_recurrence_direct_v2 binding"
+        )
+    binding = cast(_RustRecurrenceLoweringBinding, candidate)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if destination.exists() or destination.is_symlink():
+        raise GenerationError(
+            f"Rust recurrence lowering destination already exists: {destination}"
+        )
+    if helicity_dispatch_destination is not None:
+        helicity_dispatch_destination.parent.mkdir(parents=True, exist_ok=True)
+        if (
+            helicity_dispatch_destination.exists()
+            or helicity_dispatch_destination.is_symlink()
+        ):
+            raise GenerationError(
+                "Rust recurrence helicity-dispatch destination already exists: "
+                f"{helicity_dispatch_destination}"
+            )
+    try:
+        encoded_direct_template_catalog = (
+            json.dumps(
+                direct_template_catalog.to_dict(),
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            ).encode("ascii")
+            if direct_template_catalog_json is None
+            else direct_template_catalog_json
+        )
+        raw_result = binding(
+            builder_input,
+            template_input,
+            encoded_direct_template_catalog,
+            prepared_kernel_pack_digest,
+            schedule_semantic_digest,
+            os.fspath(destination),
+            point_tile_size=point_tile_size,
+            workspace_mib=workspace_mib,
+            relation_discovery_mode=relation_discovery_mode,
+            relation_discovery_precision_digits=(relation_discovery_precision_digits),
+            relation_discovery_probe_count=relation_discovery_probe_count,
+            relation_discovery_verification_probe_count=(
+                relation_discovery_verification_probe_count
+            ),
+            relation_discovery_relative_tolerance=(
+                relation_discovery_relative_tolerance
+            ),
+            relation_discovery_absolute_tolerance=(
+                relation_discovery_absolute_tolerance
+            ),
+            relation_discovery_seed=relation_discovery_seed,
+            color_accuracy=color_accuracy,
+            relation_discovery_evidence_json=relation_discovery_evidence_json,
+            helicity_dispatch_destination=(
+                None
+                if helicity_dispatch_destination is None
+                else os.fspath(helicity_dispatch_destination)
+            ),
+            progress_callback=progress_callback,
+        )
+        result = _validate_rust_recurrence_lowering_result(
+            raw_result,
+            builder_input=builder_input,
+            template_input=template_input,
+            prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+            direct_template_catalog_digest=direct_template_catalog.catalog_digest,
+            expect_helicity_dispatch=(helicity_dispatch_destination is not None),
+        )
+        if destination.is_symlink() or not destination.is_file():
+            raise GenerationError(
+                "Rust recurrence lowering did not produce a regular "
+                "recurrence-runtime.pacbin"
+            )
+        payload_size = destination.stat().st_size
+        if payload_size <= 0:
+            raise GenerationError(
+                "Rust recurrence lowering produced an empty runtime payload"
+            )
+        serialized_bytes = cast(
+            Mapping[str, object],
+            cast(Mapping[str, object], result["generation_profile"])[
+                "serialized_bytes"
+            ],
+        )
+        if serialized_bytes.get("container") != payload_size:
+            raise GenerationError(
+                "Rust recurrence generation serialized-byte telemetry disagrees "
+                "with the emitted runtime container"
+            )
+        payload_sha256 = _file_sha256(destination)
+        dispatch_output = None
+        dispatch_metadata = result["helicity_dispatch"]
+        if helicity_dispatch_destination is not None:
+            if (
+                helicity_dispatch_destination.is_symlink()
+                or not helicity_dispatch_destination.is_file()
+            ):
+                raise GenerationError(
+                    "Rust recurrence lowering did not produce a regular "
+                    "helicity-dispatch payload"
+                )
+            if not isinstance(dispatch_metadata, Mapping):
+                raise AssertionError(
+                    "validated recurrence lowering omitted helicity dispatch"
+                )
+            dispatch_size = helicity_dispatch_destination.stat().st_size
+            dispatch_sha256 = _file_sha256(helicity_dispatch_destination)
+            if (
+                dispatch_size != dispatch_metadata["size_bytes"]
+                or dispatch_sha256 != dispatch_metadata["sha256"]
+            ):
+                raise GenerationError(
+                    "Rust recurrence helicity-dispatch metadata disagrees with "
+                    "the emitted payload"
+                )
+            dispatch_output = _RustRecurrenceHelicityDispatchOutput(
+                payload_path=helicity_dispatch_destination,
+                payload_size_bytes=dispatch_size,
+                payload_sha256=dispatch_sha256,
+                base_runtime_layout_digest=cast(
+                    str,
+                    dispatch_metadata["base_runtime_layout_digest"],
+                ),
+                resolved_helicity_count=cast(
+                    int,
+                    dispatch_metadata["resolved_helicity_count"],
+                ),
+            )
+    except Exception as exc:
+        _discard_rust_eager_output(destination)
+        if helicity_dispatch_destination is not None:
+            _discard_rust_eager_output(helicity_dispatch_destination)
+        if isinstance(exc, GenerationError | ArtifactError):
+            raise
+        raise GenerationError(f"Rust recurrence lowering failed: {exc}") from exc
+    return _RustRecurrenceLoweringOutput(
+        inspection_summary=cast(Mapping[str, object], result["inspection_summary"]),
+        resolved_helicities=cast(
+            tuple[tuple[int, ...], ...], result["resolved_helicities"]
+        ),
+        amplitude_destinations=cast(
+            tuple[tuple[int, int | None], ...],
+            result["amplitude_destinations"],
+        ),
+        structural_zero_physical_sector_certificate=cast(
+            _RustRecurrenceStructuralZeroSectorCertificate | None,
+            result["structural_zero_physical_sector_certificate"],
+        ),
+        exact_sections=cast(Mapping[str, object], result["exact_sections"]),
+        generation_profile=cast(Mapping[str, object], result["generation_profile"]),
+        numerical_current_reuse_report=None,
+        payload_path=destination,
+        payload_size_bytes=payload_size,
+        payload_sha256=payload_sha256,
+        member_count=cast(int, result["member_count"]),
+        unpacked_size_bytes=cast(int, result["unpacked_size_bytes"]),
+        index_sha256=cast(str, result["index_sha256"]),
+        helicity_dispatch=dispatch_output,
+    )
+
+
+def _validate_rust_recurrence_lowering_result(
+    value: object,
+    *,
+    builder_input: RecurrenceBuilderInputV1,
+    template_input: RecurrenceTemplateInputV1,
+    prepared_kernel_pack_digest: str,
+    direct_template_catalog_digest: str,
+    expect_helicity_dispatch: bool,
+) -> dict[str, object]:
+    result = _strict_mapping(
+        value,
+        "Rust recurrence lowering result",
+        {
+            "kind",
+            "schema_version",
+            "builder_input_abi",
+            "builder_input_sha256",
+            "template_input_abi",
+            "template_input_sha256",
+            "prepared_kernel_pack_digest",
+            "direct_template_abi",
+            "direct_template_catalog_digest",
+            "recurrence_plan_abi",
+            "runtime_layout_abi",
+            "required_runtime_capabilities",
+            "runtime_container",
+            "inspection_summary",
+            "resolved_helicities",
+            "amplitude_destinations",
+            "structural_zero_physical_sector_certificate",
+            "helicity_dispatch",
+            "exact_sections",
+            "generation_profile",
+        },
+    )
+    expected = {
+        "kind": _RECURRENCE_LOWERING_RESULT_KIND,
+        "schema_version": _RECURRENCE_LOWERING_RESULT_SCHEMA_VERSION,
+        "builder_input_abi": RECURRENCE_BUILDER_INPUT_ABI,
+        "builder_input_sha256": builder_input.digest,
+        "template_input_abi": RECURRENCE_TEMPLATE_INPUT_ABI,
+        "template_input_sha256": template_input.digest,
+        "prepared_kernel_pack_digest": prepared_kernel_pack_digest,
+        "direct_template_abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "direct_template_catalog_digest": direct_template_catalog_digest,
+        "recurrence_plan_abi": RECURRENCE_PLAN_ABI,
+        "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_ABI,
+    }
+    mismatched = [
+        name
+        for name, expected_value in expected.items()
+        if result[name] != expected_value
+    ]
+    if mismatched:
+        raise GenerationError(
+            "Rust recurrence lowering result has incompatible contract fields: "
+            + ", ".join(mismatched)
+        )
+    capabilities = result["required_runtime_capabilities"]
+    color_capability = (
+        RECURRENCE_CONTRACTED_COLOR_RUNTIME_CAPABILITY
+        if builder_input.layout == "contracted-color-union"
+        else RECURRENCE_COLOR_RUNTIME_CAPABILITY
+    )
+    expected_capabilities = tuple(
+        sorted(
+            {
+                RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+                color_capability,
+            }
+        )
+    )
+    if (
+        isinstance(capabilities, str | bytes)
+        or not isinstance(capabilities, Sequence)
+        or tuple(capabilities) != expected_capabilities
+    ):
+        raise GenerationError(
+            "Rust recurrence lowering result has incompatible runtime capabilities"
+        )
+    container = _strict_mapping(
+        result["runtime_container"],
+        "Rust recurrence runtime container metadata",
+        {
+            "kind",
+            "schema_version",
+            "storage_abi",
+            "member_count",
+            "unpacked_size_bytes",
+            "index_sha256",
+        },
+    )
+    if container["kind"] != RECURRENCE_RUNTIME_CONTAINER_KIND:
+        raise GenerationError("Rust recurrence runtime container kind is incompatible")
+    if container["schema_version"] != RECURRENCE_RUNTIME_CONTAINER_SCHEMA_VERSION:
+        raise GenerationError(
+            "Rust recurrence runtime container schema is incompatible"
+        )
+    if container["storage_abi"] != RECURRENCE_RUNTIME_STORAGE_ABI:
+        raise GenerationError(
+            "Rust recurrence runtime container storage ABI is incompatible"
+        )
+    member_count = _result_integer(
+        container["member_count"],
+        "Rust recurrence runtime member count",
+        minimum=1,
+    )
+    unpacked_size = _result_integer(
+        container["unpacked_size_bytes"],
+        "Rust recurrence runtime unpacked size",
+        minimum=0,
+    )
+    index_sha256 = _result_sha256(
+        container["index_sha256"],
+        "Rust recurrence runtime index SHA-256",
+    )
+    inspection = _canonical_json_mapping(
+        result["inspection_summary"],
+        "Rust recurrence inspection summary",
+    )
+    exact_sections = _canonical_json_mapping(
+        result["exact_sections"],
+        "Rust recurrence exact sections",
+    )
+    generation_profile = _validate_recurrence_generation_profile(
+        result["generation_profile"],
+        inspection=inspection,
+        unpacked_size_bytes=unpacked_size,
+    )
+    raw_dispatch = result["helicity_dispatch"]
+    dispatch: dict[str, object] | None
+    if raw_dispatch is None:
+        if expect_helicity_dispatch:
+            raise GenerationError(
+                "Rust recurrence lowering omitted the requested helicity dispatch"
+            )
+        dispatch = None
+    else:
+        if not expect_helicity_dispatch:
+            raise GenerationError(
+                "Rust recurrence lowering emitted an unrequested helicity dispatch"
+            )
+        dispatch = _strict_mapping(
+            raw_dispatch,
+            "Rust recurrence helicity-dispatch metadata",
+            {
+                "abi",
+                "size_bytes",
+                "sha256",
+                "base_runtime_layout_digest",
+                "resolved_helicity_count",
+            },
+        )
+        if dispatch["abi"] != _RECURRENCE_HELICITY_DISPATCH_ABI:
+            raise GenerationError(
+                "Rust recurrence helicity dispatch has an incompatible ABI"
+            )
+        dispatch["size_bytes"] = _result_integer(
+            dispatch["size_bytes"],
+            "Rust recurrence helicity-dispatch size",
+            minimum=1,
+        )
+        dispatch["sha256"] = _result_sha256(
+            dispatch["sha256"],
+            "Rust recurrence helicity-dispatch SHA-256",
+        )
+        dispatch["base_runtime_layout_digest"] = _result_sha256(
+            dispatch["base_runtime_layout_digest"],
+            "Rust recurrence helicity-dispatch runtime-layout digest",
+        )
+        dispatch["resolved_helicity_count"] = _result_integer(
+            dispatch["resolved_helicity_count"],
+            "Rust recurrence helicity-dispatch resolved-helicity count",
+            minimum=1,
+        )
+        if dispatch["base_runtime_layout_digest"] != inspection.get(
+            "runtime_layout_digest"
+        ):
+            raise GenerationError(
+                "Rust recurrence helicity dispatch disagrees with its runtime layout"
+            )
+    raw_helicities = result["resolved_helicities"]
+    if isinstance(raw_helicities, str | bytes) or not isinstance(
+        raw_helicities, Sequence
+    ):
+        raise GenerationError("Rust recurrence resolved helicities must be a list")
+    resolved_helicities = []
+    for raw_row in raw_helicities:
+        if isinstance(raw_row, str | bytes) or not isinstance(raw_row, Sequence):
+            raise GenerationError(
+                "Rust recurrence resolved helicity rows must be lists"
+            )
+        row = tuple(
+            _result_signed_integer(value, "Rust recurrence helicity")
+            for value in raw_row
+        )
+        resolved_helicities.append(row)
+    if len(set(resolved_helicities)) != len(resolved_helicities):
+        raise GenerationError("Rust recurrence resolved helicities are not unique")
+    if dispatch is not None and dispatch["resolved_helicity_count"] != len(
+        resolved_helicities
+    ):
+        raise GenerationError(
+            "Rust recurrence helicity dispatch disagrees with the resolved-helicity "
+            "domain"
+        )
+    raw_destinations = result["amplitude_destinations"]
+    if isinstance(raw_destinations, str | bytes) or not isinstance(
+        raw_destinations, Sequence
+    ):
+        raise GenerationError("Rust recurrence amplitude destinations must be a list")
+    amplitude_destinations = []
+    for destination_id, raw_row in enumerate(raw_destinations):
+        if (
+            isinstance(raw_row, str | bytes)
+            or not isinstance(raw_row, Sequence)
+            or len(raw_row) != 2
+        ):
+            raise GenerationError(
+                "Rust recurrence amplitude destination rows must be "
+                "[sector_id, helicity_id-or-null]"
+            )
+        sector_id = _result_integer(
+            raw_row[0],
+            f"Rust recurrence amplitude destination {destination_id} sector ID",
+            minimum=0,
+        )
+        raw_helicity_id = raw_row[1]
+        helicity_id = (
+            None
+            if raw_helicity_id is None
+            else _result_integer(
+                raw_helicity_id,
+                (f"Rust recurrence amplitude destination {destination_id} helicity ID"),
+                minimum=0,
+            )
+        )
+        amplitude_destinations.append((sector_id, helicity_id))
+    if len(set(amplitude_destinations)) != len(amplitude_destinations):
+        raise GenerationError(
+            "Rust recurrence amplitude destinations repeat a sector/helicity pair"
+        )
+    raw_zero_certificate = result["structural_zero_physical_sector_certificate"]
+    zero_certificate: _RustRecurrenceStructuralZeroSectorCertificate | None
+    if raw_zero_certificate is None:
+        if builder_input.layout == "contracted-color-union":
+            raise GenerationError(
+                "Rust contracted recurrence lowering omitted its complete "
+                "structural-zero physical-sector certificate"
+            )
+        zero_certificate = None
+    else:
+        if builder_input.layout != "contracted-color-union":
+            raise GenerationError(
+                "Rust recurrence lowering emitted a structural-zero physical-sector "
+                "certificate outside contracted color"
+            )
+        certificate = _strict_mapping(
+            raw_zero_certificate,
+            "Rust recurrence structural-zero physical-sector certificate",
+            {
+                "proof_kind",
+                "sector_ids",
+                "semantic_digest",
+                "sector_count",
+                "resolved_helicity_count",
+            },
+        )
+        if certificate["proof_kind"] != _RECURRENCE_STRUCTURAL_ZERO_SECTOR_PROOF_KIND:
+            raise GenerationError(
+                "Rust recurrence structural-zero physical-sector certificate "
+                "has an incompatible proof kind"
+            )
+        sector_count = _result_integer(
+            certificate["sector_count"],
+            "Rust recurrence structural-zero certificate sector count",
+            minimum=1,
+        )
+        inspection_sector_count = _result_integer(
+            inspection.get("sector_count"),
+            "Rust recurrence inspection sector count",
+            minimum=1,
+        )
+        if sector_count != inspection_sector_count:
+            raise GenerationError(
+                "Rust recurrence structural-zero certificate disagrees with the "
+                "physical-sector domain"
+            )
+        resolved_count = _result_integer(
+            certificate["resolved_helicity_count"],
+            "Rust recurrence structural-zero certificate resolved-helicity count",
+            minimum=1,
+        )
+        if resolved_count != len(resolved_helicities):
+            raise GenerationError(
+                "Rust recurrence structural-zero certificate disagrees with the "
+                "resolved-helicity domain"
+            )
+        raw_sector_ids = certificate["sector_ids"]
+        if isinstance(raw_sector_ids, str | bytes) or not isinstance(
+            raw_sector_ids, Sequence
+        ):
+            raise GenerationError(
+                "Rust recurrence structural-zero physical-sector IDs must be a list"
+            )
+        sector_ids = tuple(
+            _result_integer(
+                value,
+                "Rust recurrence certified structural-zero physical-sector ID",
+                minimum=0,
+            )
+            for value in raw_sector_ids
+        )
+        if tuple(sorted(set(sector_ids))) != sector_ids or any(
+            sector_id >= sector_count for sector_id in sector_ids
+        ):
+            raise GenerationError(
+                "Rust recurrence certified structural-zero physical-sector IDs "
+                "are not canonical"
+            )
+        active_sector_ids = {sector_id for sector_id, _ in amplitude_destinations}
+        if active_sector_ids.intersection(sector_ids):
+            raise GenerationError(
+                "Rust recurrence structural-zero certificate overlaps active "
+                "amplitude destinations"
+            )
+        zero_certificate = _RustRecurrenceStructuralZeroSectorCertificate(
+            sector_ids=sector_ids,
+            semantic_digest=_result_sha256(
+                certificate["semantic_digest"],
+                "Rust recurrence structural-zero certificate semantic digest",
+            ),
+            sector_count=sector_count,
+            resolved_helicity_count=resolved_count,
+        )
+        provenance = _strict_mapping(
+            inspection.get("structural_zero_physical_sector_certificate"),
+            "Rust recurrence structural-zero physical-sector provenance",
+            {
+                "proof_kind",
+                "semantic_digest",
+                "sector_count",
+                "resolved_helicity_count",
+                "certified_structural_zero_sector_count",
+            },
+        )
+        expected_provenance = {
+            "proof_kind": _RECURRENCE_STRUCTURAL_ZERO_SECTOR_PROOF_KIND,
+            "semantic_digest": zero_certificate.semantic_digest,
+            "sector_count": zero_certificate.sector_count,
+            "resolved_helicity_count": zero_certificate.resolved_helicity_count,
+            "certified_structural_zero_sector_count": len(zero_certificate.sector_ids),
+        }
+        if provenance != expected_provenance:
+            raise GenerationError(
+                "Rust recurrence structural-zero physical-sector provenance "
+                "disagrees with its certificate"
+            )
+    return {
+        "inspection_summary": inspection,
+        "resolved_helicities": tuple(resolved_helicities),
+        "amplitude_destinations": tuple(amplitude_destinations),
+        "structural_zero_physical_sector_certificate": zero_certificate,
+        "exact_sections": exact_sections,
+        "generation_profile": generation_profile,
+        "member_count": member_count,
+        "unpacked_size_bytes": unpacked_size,
+        "index_sha256": index_sha256,
+        "helicity_dispatch": dispatch,
+    }
+
+
+def _validate_recurrence_generation_profile(
+    value: object,
+    *,
+    inspection: Mapping[str, object],
+    unpacked_size_bytes: int,
+) -> dict[str, object]:
+    profile = _strict_mapping(
+        value,
+        "Rust recurrence generation profile",
+        {
+            "schema_version",
+            "scope",
+            "timings_seconds",
+            "operation_counters",
+            "serialized_bytes",
+        },
+    )
+    if profile["schema_version"] != 1 or profile["scope"] != "generation-only":
+        raise GenerationError(
+            "Rust recurrence generation profile has an incompatible contract"
+        )
+    timings = _strict_mapping(
+        profile["timings_seconds"],
+        "Rust recurrence generation timings",
+        set(_RECURRENCE_GENERATION_PROFILE_TIMINGS),
+    )
+    normalized_timings: dict[str, float] = {}
+    for name, value in timings.items():
+        if (
+            isinstance(value, bool)
+            or not isinstance(value, int | float)
+            or not math.isfinite(float(value))
+            or float(value) < 0.0
+        ):
+            raise GenerationError(
+                f"Rust recurrence generation timing {name!r} is invalid"
+            )
+        normalized_timings[name] = float(value)
+
+    counters = _strict_mapping(
+        profile["operation_counters"],
+        "Rust recurrence generation operation counters",
+        set(_RECURRENCE_GENERATION_PROFILE_COUNTERS),
+    )
+    normalized_counters = {
+        name: _result_integer(
+            counter,
+            f"Rust recurrence generation counter {name!r}",
+            minimum=0,
+        )
+        for name, counter in counters.items()
+    }
+    serialized = _strict_mapping(
+        profile["serialized_bytes"],
+        "Rust recurrence generation serialized bytes",
+        set(_RECURRENCE_GENERATION_PROFILE_SERIALIZED_BYTES),
+    )
+    normalized_serialized = {
+        name: _result_integer(
+            count,
+            f"Rust recurrence generation serialized byte count {name!r}",
+            minimum=0,
+        )
+        for name, count in serialized.items()
+    }
+    member = inspection.get("runtime_container_member")
+    if not isinstance(member, Mapping):
+        raise GenerationError(
+            "Rust recurrence inspection has no runtime-container member metadata"
+        )
+    expected_serialized = {
+        "plan_payload": _result_integer(
+            member.get("size_bytes"),
+            "Rust recurrence runtime plan payload size",
+            minimum=0,
+        ),
+        "container": _result_integer(
+            member.get("container_size_bytes"),
+            "Rust recurrence runtime container size",
+            minimum=0,
+        ),
+        "unpacked_container": unpacked_size_bytes,
+    }
+    if normalized_serialized != expected_serialized:
+        raise GenerationError(
+            "Rust recurrence generation serialized-byte telemetry disagrees "
+            "with authenticated container metadata"
+        )
+    return {
+        "schema_version": 1,
+        "scope": "generation-only",
+        "timings_seconds": normalized_timings,
+        "operation_counters": normalized_counters,
+        "serialized_bytes": normalized_serialized,
+    }
+
+
+def _validate_rust_eager_lowering_result(
+    value: object,
+    lowering_input: EagerLoweringInputV1,
+) -> dict[str, object]:
+    result = _strict_mapping(
+        value,
+        "Rust eager lowering result",
+        {
+            "kind",
+            "schema_version",
+            "lowering_input_abi",
+            "lowering_input_sha256",
+            "eager_plan_abi",
+            "runtime_layout_abi",
+            "required_runtime_capabilities",
+            "runtime_container",
+            "inspection_summary",
+        },
+    )
+    expected = {
+        "kind": _EAGER_LOWERING_RESULT_KIND,
+        "schema_version": _EAGER_LOWERING_RESULT_SCHEMA_VERSION,
+        "lowering_input_abi": EAGER_LOWERING_INPUT_ABI,
+        "lowering_input_sha256": lowering_input.digest,
+        "eager_plan_abi": EAGER_PLAN_V3_ABI,
+        "runtime_layout_abi": EAGER_RUNTIME_LAYOUT_ABI,
+    }
+    mismatched = [
+        name
+        for name, expected_value in expected.items()
+        if result[name] != expected_value
+    ]
+    if mismatched:
+        raise GenerationError(
+            "Rust eager lowering result has incompatible contract fields: "
+            + ", ".join(mismatched)
+        )
+    capabilities = result["required_runtime_capabilities"]
+    if (
+        isinstance(capabilities, str | bytes)
+        or not isinstance(capabilities, Sequence)
+        or tuple(capabilities)
+        != tuple(
+            sorted(
+                (
+                    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+                    EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+                )
+            )
+        )
+    ):
+        raise GenerationError(
+            "Rust eager lowering result has an incompatible runtime capability"
+        )
+    container = _strict_mapping(
+        result["runtime_container"],
+        "Rust eager runtime container metadata",
+        {
+            "kind",
+            "schema_version",
+            "storage_abi",
+            "member_count",
+            "unpacked_size_bytes",
+            "index_sha256",
+        },
+    )
+    if container["kind"] != EAGER_RUNTIME_CONTAINER_KIND:
+        raise GenerationError("Rust eager runtime container kind is incompatible")
+    if container["schema_version"] != EAGER_RUNTIME_CONTAINER_SCHEMA_VERSION:
+        raise GenerationError("Rust eager runtime container schema is incompatible")
+    if container["storage_abi"] != EAGER_RUNTIME_STORAGE_ABI:
+        raise GenerationError(
+            "Rust eager runtime container storage ABI is incompatible"
+        )
+    member_count = _result_integer(
+        container["member_count"],
+        "Rust eager runtime member count",
+        minimum=1,
+    )
+    unpacked_size = _result_integer(
+        container["unpacked_size_bytes"],
+        "Rust eager runtime unpacked size",
+        minimum=0,
+    )
+    index_sha256 = _result_sha256(
+        container["index_sha256"],
+        "Rust eager runtime index SHA-256",
+    )
+    inspection = _canonical_json_mapping(
+        result["inspection_summary"],
+        "Rust eager inspection summary",
+    )
+    return {
+        "inspection_summary": inspection,
+        "member_count": member_count,
+        "unpacked_size_bytes": unpacked_size,
+        "index_sha256": index_sha256,
+    }
+
+
+def _strict_mapping(
+    value: object,
+    context: str,
+    fields: set[str],
+) -> dict[str, object]:
+    if not isinstance(value, Mapping):
+        raise GenerationError(f"{context} must be an object")
+    result = {str(key): item for key, item in value.items()}
+    if set(result) != fields:
+        raise GenerationError(f"{context} fields do not match the v1 binding protocol")
+    return result
+
+
+def _canonical_json_mapping(value: object, context: str) -> dict[str, object]:
+    if not isinstance(value, Mapping):
+        raise GenerationError(f"{context} must be an object")
+    try:
+        payload = json.dumps(
+            value,
+            ensure_ascii=True,
+            allow_nan=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        result = json.loads(payload)
+    except (TypeError, ValueError) as exc:
+        raise GenerationError(f"{context} is not canonical JSON: {exc}") from exc
+    if not isinstance(result, dict):  # pragma: no cover - Mapping encoded above
+        raise GenerationError(f"{context} must encode as an object")
+    return cast(dict[str, object], result)
+
+
+def _result_integer(value: object, context: str, *, minimum: int) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < minimum:
+        raise GenerationError(f"{context} must be at least {minimum}")
+    return value
+
+
+def _result_signed_integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise GenerationError(f"{context} must be an integer")
+    return value
+
+
+def _result_sha256(value: object, context: str) -> str:
+    if (
+        not isinstance(value, str)
+        or len(value) != 64
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise GenerationError(f"{context} must be a lowercase hexadecimal digest")
+    return value
+
+
+def _file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _discard_rust_eager_output(path: Path) -> None:
+    try:
+        if path.is_symlink() or path.is_file():
+            path.unlink()
+    except OSError:
+        pass
+
+
+def _eager_lowering_kernel_ids(
+    lowering_input: EagerLoweringInputV1,
+) -> frozenset[int]:
+    references: set[int] = set()
+    for table_name, column_name in (
+        ("currents", "propagator_kernel_id"),
+        ("interactions", "kernel_id"),
+        ("roots", "kernel_id"),
+    ):
+        for raw_value in lowering_input.table(table_name).column(column_name):
+            value = int(raw_value)
+            if value != MISSING_U32:
+                references.add(value)
+    return frozenset(references)
+
+
+def _builtin_sm_model() -> Model:
+    from ..models import BuiltinSMModel
+
+    return BuiltinSMModel()
+
+
+def _nested_config_value(values: Mapping[str, object], path: str) -> object:
+    current: object = values
+    for component in path.split("."):
+        if not isinstance(current, Mapping) or component not in current:
+            raise GenerationError(
+                f"prepared model references unknown configuration path {path!r}"
+            )
+        current = current[component]
+    return current
+
+
+def _prepared_pack_effective_values(
+    pack: PreparedKernelPack,
+) -> dict[str, object]:
+    settings = pack.optimization_settings
+
+    def required(name: str) -> object:
+        if name not in settings:
+            raise GenerationError(
+                f"prepared kernel pack omits optimization setting {name!r}"
+            )
+        return settings[name]
+
+    def required_bool(name: str) -> bool:
+        value = required(name)
+        if not isinstance(value, bool):
+            raise GenerationError(
+                f"prepared kernel pack has a non-boolean optimization setting {name!r}"
+            )
+        return value
+
+    values: dict[str, object] = {
+        "evaluator.backend": pack.backend,
+        "evaluator.optimization.horner_iterations": required("iterations"),
+        "evaluator.optimization.cpe_iterations": required("cpe_iterations"),
+        "evaluator.optimization.max_horner_variables": required(
+            "max_horner_scheme_variables"
+        ),
+        "evaluator.optimization.max_common_pair_cache_entries": required(
+            "max_common_pair_cache_entries"
+        ),
+        "evaluator.optimization.max_common_pair_distance": required(
+            "max_common_pair_distance"
+        ),
+        "evaluator.optimization.collect_factors": required("collect_factors"),
+    }
+    if pack.backend == "jit":
+        values["evaluator.jit.optimization_level"] = required("jit_optimization_level")
+        values["evaluator.jit.compress"] = required_bool("jit_compress")
+        return values
+    optimization_level = required("compiled_optimization_level")
+    if isinstance(optimization_level, bool) or not isinstance(optimization_level, int):
+        raise GenerationError(
+            "prepared native kernel pack has an invalid optimization level"
+        )
+    values.update(
+        {
+            "evaluator.cpp.optimization": f"O{optimization_level}",
+            "evaluator.cpp.native_arch": required("compiled_native"),
+            "evaluator.cpp.compiler": required("compiler_path"),
+            "evaluator.cpp.extra_flags": required("compiler_flags"),
+        }
+    )
+    return values
+
+
+@dataclass(frozen=True, slots=True)
+class _ResolvedModel:
+    source: ModelSource
+    model: Model | None
+    compiled: _CompiledModelPayload | None = None
+    use_compiled_process_catalog: bool = True
+    eager_kernel_index: PreparedCatalogEagerKernelIndex | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class _ProcessSelection:
+    max_color_sectors: int | None = None
+    reference_color_order: tuple[int, ...] | None = None
+    selected_color_sector_ids: frozenset[int] | None = None
+    selected_source_helicities: Mapping[int, int] | None = None
+
+    def __post_init__(self) -> None:
+        if self.reference_color_order is not None:
+            object.__setattr__(
+                self,
+                "reference_color_order",
+                tuple(int(label) for label in self.reference_color_order),
+            )
+        if self.selected_color_sector_ids is not None:
+            object.__setattr__(
+                self,
+                "selected_color_sector_ids",
+                frozenset(int(value) for value in self.selected_color_sector_ids),
+            )
+        if self.selected_source_helicities is not None:
+            object.__setattr__(
+                self,
+                "selected_source_helicities",
+                MappingProxyType(
+                    {
+                        int(label): int(helicity)
+                        for label, helicity in self.selected_source_helicities.items()
+                    }
+                ),
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class _ExpandedProcess:
+    request: ProcessRequest
+    process_ir: CanonicalProcessIR
+    aliases: tuple[Mapping[str, object], ...] = ()
+    source_expansion_size: int = 1
+    source_request: ProcessRequest | None = None
+    # Flavour-blind members represented by this process, never generated.
+    group_members: tuple[GroupMember, ...] = ()
+
+
+class _NoModelSupportedAmplitudes(GenerationError):
+    """A concrete tree-level subprocess has no amplitude in the active model."""
+
+
+@dataclass(frozen=True, slots=True)
+class _UnsupportedProcess:
+    expanded: _ExpandedProcess
+    reason: str
+
+
+_SupportedT = TypeVar("_SupportedT", "_DagProcess", _ExpandedProcess)
+
+
+def _source_request(expanded: _ExpandedProcess) -> ProcessRequest:
+    return expanded.source_request or expanded.request
+
+
+def _partition_model_supported_processes(
+    results: Sequence[_SupportedT | _UnsupportedProcess],
+) -> tuple[tuple[_SupportedT, ...], tuple[_UnsupportedProcess, ...]]:
+    """Retain supported children without silently dropping a whole request."""
+
+    unsupported = tuple(
+        result for result in results if isinstance(result, _UnsupportedProcess)
+    )
+    supported = tuple(
+        cast(_SupportedT, result)
+        for result in results
+        if not isinstance(result, _UnsupportedProcess)
+    )
+    supported_request_names = {
+        _source_request(
+            result if isinstance(result, _ExpandedProcess) else result.expanded
+        ).name
+        for result in supported
+    }
+    unsupported_by_request: dict[str, list[_UnsupportedProcess]] = {}
+    for result in unsupported:
+        source = _source_request(result.expanded)
+        unsupported_by_request.setdefault(source.name, []).append(result)
+    empty_requests = tuple(
+        (request_name, entries)
+        for request_name, entries in unsupported_by_request.items()
+        if request_name not in supported_request_names
+    )
+    if empty_requests:
+        details = []
+        for _request_name, entries in empty_requests:
+            source = _source_request(entries[0].expanded)
+            reasons = "; ".join(entry.reason for entry in entries)
+            details.append(f"{source.expression!r}: {reasons}")
+        raise GenerationError(
+            "process expansion produced no model-supported tree-level amplitudes "
+            "for requested process"
+            + ("es" if len(details) != 1 else "")
+            + ": "
+            + "; ".join(details)
+        )
+    return supported, unsupported
+
+
+def _warn_unsupported_processes(unsupported: Sequence[_UnsupportedProcess]) -> None:
+    if not unsupported:
+        return
+    rendered = ", ".join(
+        f"{item.expanded.request.name} ({item.expanded.process_ir.process}"
+        + (
+            f", with {len(item.expanded.group_members)} flavor-blind member(s)"
+            if item.expanded.group_members
+            else ""
+        )
+        + ")"
+        for item in unsupported
+    )
+    _LOGGER.warning(
+        "Skipped %d concrete subprocess%s with no model-supported tree-level "
+        "amplitudes: %s",
+        len(unsupported),
+        "" if len(unsupported) == 1 else "es",
+        rendered,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class _PreparedProcessConstruction:
+    process: CanonicalProcessIR
+    complete_color_plan: GenericColorPlan
+    restricted_color_plan: GenericColorPlan
+    materialized_sector_ids: frozenset[int] | None
+    coupling_order_limits: Mapping[str, int]
+    topology_replay: LCColorTopologyReplayPlan | ColorTopologyReplayCertificate | None
+
+
+@dataclass(frozen=True, slots=True)
+class _DagProcess:
+    expanded: _ExpandedProcess
+    dag: GenericDAG
+    coverage: Mapping[str, object]
+
+
+@dataclass(frozen=True, slots=True)
+class _CompiledProcess:
+    expanded: _ExpandedProcess
+    dag: GenericDAG
+    helicity_sum_dag: GenericDAG | None
+    helicity_selector_union_dag: GenericDAG | None
+    coverage: Mapping[str, object]
+    filters: Mapping[str, object]
+    validation_points: tuple[ValidationPointRecord, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _GeneratedRecurrenceProcess:
+    expanded: _ExpandedProcess
+    artifact: RecurrenceProcessArtifact
+    validation_points: tuple[ValidationPointRecord, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _GeneratedOnTheFlyProcess:
+    expanded: _ExpandedProcess
+    artifact: OnTheFlyProcessArtifact
+    validation_points: tuple[ValidationPointRecord, ...]
+    validation_selectors: Mapping[str, tuple[str, ...]]
+
+
+@dataclass(frozen=True, slots=True)
+class _ProjectedOnTheFlyProcess:
+    index: int
+    expanded: _ExpandedProcess
+    projection: OnTheFlyGenerationProjectionV1
+
+
+@dataclass(frozen=True, slots=True)
+class _OnTheFlyContractedColorPayloadV1:
+    payload: bytes
+    summary: Mapping[str, object]
+    owner_sector_ids: tuple[int, ...]
+    destination_by_group: tuple[int, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _RecurrenceModelInputs:
+    bundle: PreparedModelBundle
+    catalog: RecurrenceTemplateCatalog
+    template_catalog_json: bytes
+    template_input: RecurrenceTemplateInputV1
+    direct_template_catalog: RecurrenceDirectTemplateCatalogV1
+    direct_template_catalog_json: bytes
+    prepared_kernel_pack_digest: str
+
+
+@dataclass(frozen=True, slots=True)
+class _EvaluatorProcess:
+    compiled: _CompiledProcess
+    runtime_schema: RuntimeExpressionSchema
+    stage_input: StageCompilationInput
+    color_contraction_payload: bytes | None = None
+    helicity_sum_runtime_schema: RuntimeExpressionSchema | None = None
+    helicity_sum_stage_input: StageCompilationInput | None = None
+    helicity_selector_lanes: tuple[_HelicitySelectorLane, ...] = ()
+    color_selector_lanes: tuple[_ColorSelectorLane, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class _ColorSelectorLane:
+    materialized_sector_id: int
+    dag: GenericDAG
+    runtime_schema: RuntimeExpressionSchema
+    stage_input: StageCompilationInput
+
+
+@dataclass(frozen=True, slots=True)
+class _HelicitySelectorLane:
+    selector_domain_ids: tuple[int, ...]
+    active_current_ids: tuple[int, ...]
+    active_root_ids: tuple[int, ...]
+    dag: GenericDAG
+    runtime_schema: RuntimeExpressionSchema
+    stage_input: StageCompilationInput
+    schedule_mode: Literal["parent-closure", "nested-runtime"] = "parent-closure"
+    child_lanes: tuple[_HelicitySelectorLane, ...] = ()
+
+
+def _validate_compiled_symmetric_group_diagnostic_process(
+    process: _CompiledProcess,
+) -> None:
+    """Fail closed outside the deliberately narrow compiled diagnostic lane."""
+
+    dag = process.dag
+    if dag.color_plan.color_accuracy != "full":
+        raise GenerationError(
+            "compiled symmetric-group FFT diagnostic execution requires FullColour"
+        )
+    if not dag.selected_source_helicities or dag.helicity_coverage != "selected":
+        raise GenerationError(
+            "compiled symmetric-group FFT diagnostic execution requires one "
+            "generation-time selected source-helicity assignment"
+        )
+    selected_source_labels = {
+        int(label) for label, _helicity in dag.selected_source_helicities
+    }
+    external_source_labels = {int(leg.label) for leg in dag.process.legs}
+    if selected_source_labels != external_source_labels:
+        raise GenerationError(
+            "compiled symmetric-group FFT diagnostic execution requires the "
+            "selected source-label domain to match every resolved external leg"
+        )
+    if (
+        process.helicity_sum_dag is not None
+        or process.helicity_selector_union_dag is not None
+        or dag.helicity_recurrence is not None
+        or dag.helicity_materialization is not None
+    ):
+        raise GenerationError(
+            "compiled symmetric-group FFT diagnostic execution does not support "
+            "helicity selector or materialization lanes"
+        )
+    if dag.lc_topology_replay is not None or dag.color_topology_replay is not None:
+        raise GenerationError(
+            "compiled symmetric-group FFT diagnostic execution does not support "
+            "colour-topology replay"
+        )
+
+
+def _compiled_symmetric_group_color_contraction_payload(
+    dag: GenericDAG,
+    layout: RuntimeSchemaLayout,
+) -> bytes:
+    contraction = layout.color_contraction
+    if contraction is None or not contraction.supported:
+        reason = None if contraction is None else contraction.reason
+        raise GenerationError(
+            "compiled symmetric-group FFT colour contraction is unavailable"
+            + ("" if reason is None else f": {reason}")
+        )
+    block = contraction.symmetric_group_block
+    if block is None:
+        raise GenerationError(
+            "compiled symmetric-group FFT is not applicable to this process: "
+            "color planning found no certified nontrivial symmetric-group orbit "
+            "to Fourier transform; compiled direct contraction remains supported "
+            "with color.contraction='direct'"
+        )
+    if block.component_count != 1:
+        raise GenerationError(
+            "compiled symmetric-group FFT diagnostic execution requires exactly "
+            "one selected-helicity contraction component"
+        )
+    group_count = contraction.group_count
+    descriptor_by_group = {
+        descriptor.group_id: descriptor
+        for descriptor in layout.color_contraction_descriptors
+    }
+    if len(descriptor_by_group) != group_count or set(descriptor_by_group) != set(
+        range(group_count)
+    ):
+        raise GenerationError(
+            "compiled symmetric-group FFT coherent group IDs are not a dense "
+            "authenticated destination domain"
+        )
+    destination_by_group = (
+        tuple(range(group_count))
+        if contraction.destination_by_group is None
+        else contraction.destination_by_group
+    )
+    if len(destination_by_group) != group_count or set(destination_by_group) != set(
+        range(group_count)
+    ):
+        raise GenerationError(
+            "compiled symmetric-group FFT destination projection is not a "
+            "permutation of coherent group IDs"
+        )
+    group_sector_ids = tuple(
+        descriptor_by_group[destination_id].sector_id
+        for destination_id in destination_by_group
+    )
+    active_sector_ids = frozenset(group_sector_ids)
+    return encode_recurrence_color_contraction(
+        contraction,
+        sector_count=dag.color_plan.sector_count,
+        component_count=1,
+        ordered_group_ids=block.component_group_ids,
+        destination_by_group=destination_by_group,
+        destination_count=group_count,
+        group_sector_ids=group_sector_ids,
+        group_component_ids=(0,) * group_count,
+        sector_owner_ids=tuple(
+            sector_id if sector_id in active_sector_ids else MISSING_U32
+            for sector_id in range(dag.color_plan.sector_count)
+        ),
+        exact_coefficients=recurrence_exact_color_coefficients(
+            dag.color_plan,
+            contraction,
+            group_sector_ids,
+        ),
+    )
+
+
+def _compiled_lc_color_selector_lane_dags(
+    dag: GenericDAG,
+) -> tuple[tuple[int, GenericDAG], ...]:
+    if dag.color_plan.color_accuracy != "lc" or dag.color_coverage != "complete":
+        return ()
+    lanes: list[tuple[int, GenericDAG]] = []
+    for sector_id in contributing_color_sector_ids(dag):
+        lane_dag = filter_dag_to_color_sectors(dag, (sector_id,))
+        if not lane_dag.amplitude_roots:
+            raise GenerationError(
+                "compiled LC colour-selector lane has no amplitude roots for "
+                f"materialized sector {sector_id}"
+            )
+        lanes.append((sector_id, lane_dag))
+    return tuple(lanes)
+
+
+def _compiled_helicity_selector_closure_lanes(
+    dag: GenericDAG,
+    schema: RuntimeExpressionSchema,
+    model: Model,
+) -> tuple[_HelicitySelectorLane, ...]:
+    """Compile no-replay LC evaluator lanes for exact helicity closures."""
+
+    materialization = dag.helicity_materialization
+    if (
+        materialization is None
+        or dag.lc_topology_replay is not None
+        or dag.color_topology_replay is not None
+    ):
+        return ()
+    grouped_domains: dict[
+        tuple[tuple[int, ...], tuple[int, ...]],
+        list[int],
+    ] = {}
+    for schedule in materialization.selector_schedules:
+        if schedule.structural_zero:
+            continue
+        closure = (schedule.active_current_ids, schedule.active_root_ids)
+        grouped_domains.setdefault(closure, []).append(schedule.selector_domain_id)
+
+    stripped_dag = replace(
+        dag,
+        helicity_recurrence=None,
+        helicity_materialization=None,
+    )
+    compile_dag = replace(
+        stripped_dag,
+        lc_topology_replay=None,
+        color_topology_replay=None,
+    )
+    lanes: list[_HelicitySelectorLane] = []
+    for (active_current_ids, active_root_ids), domain_ids in sorted(
+        grouped_domains.items(),
+        key=lambda item: tuple(item[1]),
+    ):
+        lane_schema = _helicity_closure_runtime_schema(
+            schema,
+            dag,
+            active_current_ids=active_current_ids,
+        )
+        if lane_schema is None:
+            # Keep the exact partitioned primary path for an unusual closure
+            # that does not traverse every compiled recursion stage.
+            continue
+        lanes.append(
+            _HelicitySelectorLane(
+                selector_domain_ids=tuple(sorted(domain_ids)),
+                active_current_ids=active_current_ids,
+                active_root_ids=active_root_ids,
+                dag=stripped_dag,
+                runtime_schema=lane_schema,
+                stage_input=StageCompilationInput(
+                    compile_dag,
+                    model,
+                    lane_schema,
+                ),
+            )
+        )
+    return tuple(lanes)
+
+
+def _helicity_closure_runtime_schema(
+    schema: RuntimeExpressionSchema,
+    dag: GenericDAG,
+    *,
+    active_current_ids: Sequence[int],
+) -> RuntimeExpressionSchema | None:
+    """Filter compiled stages while retaining the parent's stable storage ABI."""
+
+    payload = schema.to_mapping()
+    if payload.pop("helicity_recurrence", None) is None:
+        raise GenerationError(
+            "compiled helicity closure lane has no recurrence metadata to strip"
+        )
+    active = {int(current_id) for current_id in active_current_ids}
+    value_slots = {
+        int(record["value_slot_id"]): record
+        for record in cast(
+            "Sequence[Mapping[str, object]]",
+            cast("Mapping[str, object]", payload["value_storage"])["value_slots"],
+        )
+    }
+    momentum_slot_by_mask = {
+        int(record["momentum_mask"]): int(record["momentum_slot_id"])
+        for record in cast(
+            "Sequence[Mapping[str, object]]",
+            payload["momentum_slots"],
+        )
+    }
+    filtered_stages: list[dict[str, object]] = []
+    for raw_stage in cast("Sequence[Mapping[str, object]]", payload["stages"]):
+        stage = dict(raw_stage)
+        interaction_ids = tuple(
+            int(interaction_id)
+            for interaction_id in cast(
+                "Sequence[object]",
+                stage.get("interaction_ids", ()),
+            )
+            if dag.interactions[int(interaction_id)].result_id in active
+        )
+        if not interaction_ids:
+            return None
+        interactions = tuple(dag.interactions[item] for item in interaction_ids)
+        input_current_ids = {
+            current_id
+            for interaction in interactions
+            for current_id in (interaction.left_id, interaction.right_id)
+        }
+        output_current_ids = {interaction.result_id for interaction in interactions}
+        input_value_slot_ids = tuple(
+            sorted(
+                int(slot_id)
+                for slot_id in cast(
+                    "Sequence[object]",
+                    stage["input_value_slot_ids"],
+                )
+                if int(value_slots[int(slot_id)]["current_id"]) in input_current_ids
+            )
+        )
+        output_value_slot_ids = tuple(
+            sorted(
+                int(slot_id)
+                for slot_id in cast(
+                    "Sequence[object]",
+                    stage["output_value_slot_ids"],
+                )
+                if int(value_slots[int(slot_id)]["current_id"]) in output_current_ids
+            )
+        )
+        momentum_slot_ids = {
+            momentum_slot_by_mask[dag.currents[current_id].index.momentum_mask]
+            for interaction in interactions
+            for current_id in (
+                interaction.left_id,
+                interaction.right_id,
+                interaction.result_id,
+            )
+        }
+        evaluation_groups = {
+            (
+                "group",
+                int(interaction.evaluation_group_id),
+            )
+            if interaction.evaluation_group_id is not None
+            else ("interaction", interaction.id)
+            for interaction in interactions
+        }
+        stage.update(
+            {
+                "input_current_ids": sorted(input_current_ids),
+                "output_current_ids": sorted(output_current_ids),
+                "input_value_slot_ids": list(input_value_slot_ids),
+                "output_value_slot_ids": list(output_value_slot_ids),
+                "input_momentum_slot_ids": sorted(momentum_slot_ids),
+                "interaction_count": len(interaction_ids),
+                "interaction_evaluation_count": len(evaluation_groups),
+                "interaction_ids": list(interaction_ids),
+                "interactions_compacted": True,
+                "interactions": [],
+            }
+        )
+        filtered_stages.append(stage)
+    payload["stages"] = filtered_stages
+    return RuntimeExpressionSchema.from_mapping(payload)
+
+
+def _complete_helicity_domain_contract(
+    dag: GenericDAG,
+) -> tuple[
+    frozenset[tuple[tuple[int, int], ...]],
+    frozenset[tuple[tuple[int, int], ...]],
+]:
+    plan = dag.helicity_recurrence
+    if plan is None:
+        raise GenerationError("helicity selector lane has no recurrence proof")
+    complete_by_id = {
+        domain.id: domain.source_states
+        for domain in plan.selector_domains
+        if domain.complete
+    }
+    complete = frozenset(complete_by_id.values())
+    structural_zero = frozenset(
+        complete_by_id[domain_id]
+        for domain_id in plan.structural_zero_selector_domain_ids
+        if domain_id in complete_by_id
+    )
+    return complete, structural_zero
+
+
+def _validate_matching_helicity_selector_domains(
+    parent: GenericDAG,
+    nested: GenericDAG,
+) -> None:
+    parent_complete, parent_zero = _complete_helicity_domain_contract(parent)
+    nested_complete, nested_zero = _complete_helicity_domain_contract(nested)
+    if parent_complete != nested_complete:
+        raise GenerationError(
+            "complete-color helicity selector lane disagrees with the parent "
+            "source-state domain"
+        )
+    if parent_zero != nested_zero:
+        raise GenerationError(
+            "complete-color helicity selector lane disagrees with the parent "
+            "structural-zero domain"
+        )
+
+
+def _numerical_current_warning_required(value: object) -> bool:
+    if not isinstance(value, Mapping):
+        return False
+    warning = value.get("warning")
+    return isinstance(warning, Mapping) and warning.get("required") is True
+
+
+def _map_process_phase(
+    items: Sequence[_ProcessInput],
+    operation: Callable[[_ProcessInput], _ProcessOutput],
+    *,
+    executor: ThreadPoolExecutor | None,
+    max_in_flight: int,
+    phase_name: str,
+    item_name: Callable[[_ProcessInput], str],
+) -> tuple[_ProcessOutput, ...]:
+    """Apply one process phase with bounded submissions and stable output order."""
+
+    if max_in_flight < 1:
+        raise ValueError("process phase max_in_flight must be positive")
+    if executor is None:
+        results: list[_ProcessOutput] = []
+        for item in items:
+            try:
+                results.append(operation(item))
+            except Exception as exc:
+                raise GenerationError(
+                    f"{phase_name} failed for process {item_name(item)!r}: {exc}"
+                ) from exc
+        return tuple(results)
+
+    ordered: list[_ProcessOutput | object] = [_MISSING_PROCESS_RESULT for _ in items]
+    active: dict[Future[_ProcessOutput], int] = {}
+    next_index = 0
+
+    def submit_one(index: int) -> None:
+        item = items[index]
+        try:
+            future = executor.submit(operation, item)
+        except Exception as exc:
+            for pending in active:
+                pending.cancel()
+            if active:
+                wait(tuple(active))
+            raise GenerationError(
+                f"{phase_name} failed to schedule process {item_name(item)!r}: {exc}"
+            ) from exc
+        active[future] = index
+
+    while next_index < len(items) and len(active) < max_in_flight:
+        submit_one(next_index)
+        next_index += 1
+
+    while active:
+        done, _pending = wait(tuple(active), return_when=FIRST_COMPLETED)
+        failures: list[tuple[int, Exception]] = []
+        for future in done:
+            index = active.pop(future)
+            try:
+                ordered[index] = future.result()
+            except Exception as exc:
+                failures.append((index, exc))
+        if failures:
+            for pending in active:
+                pending.cancel()
+            if active:
+                wait(tuple(active))
+            index, exc = min(failures, key=lambda failure: failure[0])
+            item = items[index]
+            raise GenerationError(
+                f"{phase_name} failed for process {item_name(item)!r}: {exc}"
+            ) from exc
+        while next_index < len(items) and len(active) < max_in_flight:
+            submit_one(next_index)
+            next_index += 1
+
+    if any(result is _MISSING_PROCESS_RESULT for result in ordered):
+        raise GenerationError(f"{phase_name} did not produce every process result")
+    return tuple(cast(_ProcessOutput, result) for result in ordered)
+
+
+def _initial_process_groups(
+    artifact_processes: Sequence[ProcessArtifact],
+    expanded: Iterable[_ExpandedProcess],
+) -> ProcessGroupMap:
+    """Each written process with the members recorded at expansion."""
+
+    members = {entry.request.name: entry.group_members for entry in expanded}
+    return initial_process_groups(
+        (
+            (process.process_id, process.expression, process.external_pdgs)
+            for process in artifact_processes
+        ),
+        members,
+    )
+
+
+class GenerationBackend:
+    def __init__(
+        self,
+        config: GenerationConfig | RunConfig | ConfigResolution | None,
+        progress: ProgressSink | None,
+        *,
+        api_bundle_hook: ApiBundleHook | None = None,
+        process_selection: _ProcessSelection | None = None,
+    ) -> None:
+        self._resource_config = config
+        self._configuration = _GenerationConfigProvenance.from_config(config)
+        self._config = self._configuration.effective
+        self._progress = progress
+        self._api_bundle_hook = api_bundle_hook
+        self._process_selection_override = process_selection
+        self._prepared_pack_warning_emitted = False
+
+    def plan(
+        self,
+        processes: ProcessSet,
+        *,
+        model: ModelSource | CompiledModel | None = None,
+    ) -> GenerationPlan:
+        source = model or self._configured_model_source()
+        task_id = "generation-plan"
+        if self._progress is not None:
+            self._progress.emit(
+                ProgressStart(
+                    task_id,
+                    "Planning processes",
+                    total=len(processes.requests),
+                )
+            )
+        try:
+            self._validate_recurrence_request()
+            self._validate_on_the_fly_process_selection()
+            license_state = self._detect_symbolica_license()
+            self._apply_symbolica_resource_policy(license_state)
+            resolved_model = self._resolve_model_for_plan(source)
+            self._require_eager_kernel_pack(resolved_model)
+            self._apply_prepared_kernel_pack_policy(resolved_model)
+            if resolved_model.model is None and (
+                self._on_the_fly_execution_enabled
+                or (
+                    self._run_config is not None
+                    and self._run_config.color.fft_basis.value == "adjoint"
+                )
+            ):
+                compiled = resolved_model.compiled
+                if compiled is None:  # pragma: no cover - model preflight invariant
+                    raise GenerationError(
+                        "on-the-fly or adjoint FFT planning requires a resolved model"
+                    )
+                from ..models.external import CompiledUFOModel
+
+                resolved_model = replace(
+                    resolved_model,
+                    model=CompiledUFOModel(compiled),
+                )
+            expanded = self._expand_process_set(
+                processes,
+                resolved_model,
+                PhaseHandle(task_id, self._progress, len(processes.requests)),
+            )
+            self._apply_symbolica_resource_policy(
+                license_state,
+                process_count=len(expanded),
+            )
+            coverage: list[dict[str, object]] = []
+            if self._on_the_fly_execution_enabled:
+                generation_model = resolved_model.model
+                if generation_model is None:  # pragma: no cover - guarded above
+                    raise GenerationError(
+                        "on-the-fly planning requires a resolved model"
+                    )
+                model_inputs = self._recurrence_model_inputs(resolved_model)
+                for index, entry in enumerate(expanded):
+                    coverage.append(
+                        self._plan_on_the_fly_process(
+                            self._project_on_the_fly_process(
+                                entry,
+                                generation_model,
+                                model_inputs,
+                                index=index,
+                            )
+                        )
+                    )
+            else:
+                for entry in expanded:
+                    coverage.append(
+                        self._plan_concrete_process(
+                            entry.process_ir,
+                            model=resolved_model.model,
+                        )
+                    )
+            result = GenerationPlan(
+                concrete_processes=tuple(entry.request for entry in expanded),
+                estimated_coverage={
+                    "model_kind": resolved_model.source.kind,
+                    "color_accuracy": self._color_accuracy,
+                    "process_count": len(expanded),
+                    "alias_count": sum(len(entry.aliases) for entry in expanded),
+                    "processes": tuple(coverage),
+                },
+                requested_settings=self._configuration.requested,
+                effective_settings=self._config,
+                adjustments=self._configuration.adjustments,
+                unsupported_features=(),
+            )
+        except Exception as exc:
+            if self._progress is not None:
+                self._progress.emit(
+                    ProgressEnd(task_id, success=False, message=str(exc))
+                )
+            if isinstance(exc, (GenerationError, ModelError)):
+                raise
+            raise GenerationError(str(exc)) from exc
+        if self._progress is not None:
+            self._progress.emit(ProgressEnd(task_id))
+        return result
+
+    def generate(
+        self,
+        processes: ProcessSet,
+        output: os.PathLike[str] | str,
+        *,
+        model: ModelSource | CompiledModel | None = None,
+        mode: str = "error",
+    ) -> GenerationResult:
+        if mode not in ("error", "append", "replace"):
+            raise ValueError("generation mode must be 'error', 'append', or 'replace'")
+        write_mode = cast(Literal["error", "append", "replace"], mode)
+        reporter = GenerationPhaseReporter(self._progress)
+        run_config = self._run_config
+        execution_mode = (
+            "compiled"
+            if run_config is None
+            else str(run_config.evaluator.execution_mode)
+        )
+        numerical_current_warning_required = False
+        backend = "jit" if run_config is None else str(run_config.evaluator.backend)
+        if run_config is None:
+            optimization = "O2"
+        elif backend == "jit":
+            optimization = f"O{run_config.evaluator.jit.optimization_level}"
+        else:
+            optimization = str(run_config.evaluator.cpp.optimization)
+        reporter.start_generation(
+            total=(
+                5
+                if execution_mode in {"recurrence", "on-the-fly"}
+                else 7
+                if execution_mode == "eager"
+                else 8
+            )
+            + int(self._numerical_process_grouping),
+            details={
+                "execution_mode": execution_mode,
+                "backend": backend.upper(),
+                "optimization": optimization.upper(),
+            },
+        )
+        generation_started = time.perf_counter()
+        try:
+            self._validate_recurrence_request()
+            self._validate_on_the_fly_process_selection()
+            license_state = self._detect_symbolica_license()
+            self._apply_symbolica_resource_policy(license_state)
+            source = model or self._configured_model_source()
+            with reporter.phase(
+                "model-loading",
+                "Loading and compiling model",
+                total=1,
+            ) as phase:
+                resolved_model = self._resolve_model(source)
+                artifact_model = self._artifact_model(resolved_model)
+                self._require_eager_kernel_pack(resolved_model)
+                resolved_model = self._index_eager_kernel_pack(resolved_model)
+                self._apply_prepared_kernel_pack_policy(resolved_model)
+                phase.update(1, message=artifact_model.name)
+            generation_model = resolved_model.model
+            if generation_model is None:
+                raise GenerationError("generation model resolution produced no model")
+
+            with reporter.phase(
+                "process-expansion",
+                "Expanding concrete processes",
+                total=len(processes.requests),
+            ) as phase:
+                expanded = self._expand_process_set(processes, resolved_model, phase)
+            self._apply_symbolica_resource_policy(
+                license_state,
+                process_count=len(expanded),
+            )
+
+            if self._on_the_fly_execution_enabled:
+                return self._generate_on_the_fly_processes(
+                    expanded,
+                    output=Path(output),
+                    write_mode=write_mode,
+                    requested_processes=processes,
+                    resolved_model=resolved_model,
+                    artifact_model=artifact_model,
+                    generation_model=generation_model,
+                    reporter=reporter,
+                    generation_started=generation_started,
+                )
+
+            if self._recurrence_execution_enabled:
+                return self._generate_recurrence_processes(
+                    expanded,
+                    output=Path(output),
+                    write_mode=write_mode,
+                    requested_processes=processes,
+                    resolved_model=resolved_model,
+                    artifact_model=artifact_model,
+                    generation_model=generation_model,
+                    reporter=reporter,
+                    generation_started=generation_started,
+                )
+
+            with TemporaryDirectory(prefix="pyamplicol-generation-") as temporary:
+                temporary_root = Path(temporary)
+                worker_count = self._process_worker_count(len(expanded))
+                executor = (
+                    ThreadPoolExecutor(
+                        max_workers=worker_count,
+                        thread_name_prefix="pyamplicol-generation",
+                    )
+                    if worker_count > 1
+                    else None
+                )
+                try:
+                    with reporter.phase(
+                        "dag",
+                        "Compiling process DAGs",
+                        total=len(expanded),
+                    ) as phase:
+                        dag_results = _map_process_phase(
+                            expanded,
+                            lambda entry: self._compile_for_generation(
+                                entry,
+                                generation_model,
+                                phase,
+                            ),
+                            executor=executor,
+                            max_in_flight=worker_count,
+                            phase_name="DAG compilation",
+                            item_name=lambda entry: entry.request.name,
+                        )
+                        compiled, unsupported = _partition_model_supported_processes(
+                            dag_results
+                        )
+                        _warn_unsupported_processes(unsupported)
+                        del dag_results
+                        del unsupported
+
+                    indexed_compiled = tuple(enumerate(compiled))
+                    with reporter.phase(
+                        "warmup-filter",
+                        (
+                            "Applying structural reductions and preparing "
+                            "validation points"
+                        ),
+                        total=len(compiled),
+                    ) as phase:
+                        prepared = _map_process_phase(
+                            indexed_compiled,
+                            lambda indexed: self._prepare_warmup_process(
+                                indexed[1],
+                                generation_model,
+                                index=indexed[0],
+                                phase=phase,
+                            ),
+                            executor=executor,
+                            max_in_flight=worker_count,
+                            phase_name="warmup and validation-point preparation",
+                            item_name=lambda indexed: indexed[1].expanded.request.name,
+                        )
+                    numerical_current_warning_required = any(
+                        _numerical_current_warning_required(
+                            entry.filters.get("relation_discovery")
+                        )
+                        for entry in prepared
+                    )
+
+                    if self._eager_execution_enabled:
+                        with reporter.phase(
+                            "eager-lowering",
+                            "Lowering prepared-kernel DAG invocation tables",
+                            total=len(prepared),
+                        ) as phase:
+                            artifact_processes = _map_process_phase(
+                                prepared,
+                                lambda entry: self._construct_eager_artifact(
+                                    entry,
+                                    generation_model,
+                                    resolved_model,
+                                    temporary_root,
+                                    phase,
+                                ),
+                                executor=executor,
+                                max_in_flight=worker_count,
+                                phase_name="eager DAG-table lowering",
+                                item_name=lambda entry: entry.expanded.request.name,
+                            )
+                    else:
+                        with reporter.phase(
+                            "evaluator-construction",
+                            "Constructing runtime evaluator schemas",
+                            total=len(prepared),
+                        ) as phase:
+                            evaluators = _map_process_phase(
+                                prepared,
+                                lambda entry: self._construct_evaluator(
+                                    entry,
+                                    generation_model,
+                                    phase,
+                                ),
+                                executor=executor,
+                                max_in_flight=worker_count,
+                                phase_name="runtime evaluator-schema construction",
+                                item_name=lambda entry: entry.expanded.request.name,
+                            )
+
+                        jit_total = sum(
+                            _runtime_stage_count(evaluator.runtime_schema)
+                            + 1
+                            + (
+                                0
+                                if evaluator.helicity_sum_runtime_schema is None
+                                else _runtime_stage_count(
+                                    evaluator.helicity_sum_runtime_schema
+                                )
+                                + 1
+                            )
+                            + sum(
+                                _helicity_selector_lane_compile_task_count(lane)
+                                for lane in evaluator.helicity_selector_lanes
+                            )
+                            + sum(
+                                _runtime_stage_count(lane.runtime_schema) + 1
+                                for lane in evaluator.color_selector_lanes
+                            )
+                            for evaluator in evaluators
+                        )
+                        with reporter.phase(
+                            "jit",
+                            "Compiling and materializing stage evaluators",
+                            total=jit_total,
+                        ) as phase:
+                            # Symbolica expressions are created while resolving the
+                            # model on this caller thread. Keep materialization on that
+                            # same thread. The process-wide lock already made this phase
+                            # serial; moving between worker threads can violate backend
+                            # thread affinity.
+                            artifact_processes = _map_process_phase(
+                                evaluators,
+                                lambda evaluator: self._materialize_evaluator(
+                                    evaluator,
+                                    generation_model,
+                                    temporary_root,
+                                    phase,
+                                ),
+                                executor=None,
+                                max_in_flight=1,
+                                phase_name="evaluator materialization",
+                                item_name=lambda evaluator: (
+                                    evaluator.compiled.expanded.request.name
+                                ),
+                            )
+                finally:
+                    if executor is not None:
+                        executor.shutdown(wait=True, cancel_futures=True)
+
+                with reporter.phase(
+                    "artifact-writing",
+                    "Writing schema-v3 artifact",
+                    total=1,
+                ) as phase:
+
+                    def artifact_progress(event: dict[str, object]) -> None:
+                        details = {
+                            str(key): value
+                            for key, value in event.items()
+                            if isinstance(value, (str, int, float, bool, type(None)))
+                        }
+                        phase.update(
+                            int(event.get("completed", phase.completed)),
+                            total=(
+                                None
+                                if event.get("total") is None
+                                else int(event["total"])
+                            ),
+                            message=str(event.get("step", "writing artifact")),
+                            details=details,
+                        )
+
+                    write_result = self._write_artifact(
+                        Path(output),
+                        mode=write_mode,
+                        source=resolved_model.source,
+                        compiled_model=artifact_model,
+                        configuration=self._configuration,
+                        processes=artifact_processes,
+                        timings=reporter.timings,
+                        api_bundle_hook=self._api_bundle_hook,
+                        progress_callback=(
+                            artifact_progress if phase.sink is not None else None
+                        ),
+                        process_groups=_initial_process_groups(
+                            artifact_processes,
+                            (entry.expanded for entry in prepared),
+                        ),
+                    )
+                    phase.update(
+                        phase.total or phase.completed,
+                        message=str(write_result.output),
+                        details={
+                            "step": "artifact ready",
+                            "file_count": len(write_result.files),
+                        },
+                    )
+                if numerical_current_warning_required:
+                    _LOGGER.warning(
+                        "%s [%s]",
+                        NUMERICAL_CURRENT_RELATION_WARNING,
+                        NUMERICAL_CURRENT_RELATION_WARNING_CODE,
+                    )
+
+                concrete_requests = tuple(entry.expanded.request for entry in prepared)
+                validation_points_by_process = {
+                    process.expanded.request.name: process.validation_points
+                    for process in prepared
+                }
+                expected_process_ids = tuple(
+                    process.process_id for process in artifact_processes
+                )
+                del compiled
+                del indexed_compiled
+                del prepared
+                del artifact_processes
+                gc.collect()
+                # After releasing the generation state: analysis loads runtimes.
+                self._analyze_process_groups(write_result.output, reporter)
+
+            with reporter.phase(
+                "validation",
+                "Validating generated artifact",
+                total=1,
+            ) as phase:
+                validation = self._generation_config.validation
+                if validation.post_build_validation:
+                    self._validate_generated_artifact(
+                        write_result.output,
+                        expected_process_ids,
+                        validation_points=validation_points_by_process,
+                        expected_api_bundle_path=write_result.api_bundle_path,
+                        progress=phase,
+                    )
+                    message = (
+                        f"schema and {validation.samples} numerical samples"
+                        if validation.enabled
+                        else "schema, references, hashes, and target"
+                    )
+                else:
+                    message = "post-build validation disabled"
+                phase.update(1, message=message)
+
+            reporter.timings["total"] = time.perf_counter() - generation_started
+        except KeyboardInterrupt:
+            reporter.finish_generation(success=False, message="interrupted")
+            raise
+        except Exception as exc:
+            reporter.finish_generation(success=False, message=str(exc))
+            if isinstance(exc, PyAmpliColError):
+                raise
+            raise GenerationError(str(exc)) from exc
+
+        reporter.finish_generation()
+        return GenerationResult(
+            output=write_result.output,
+            processes=ProcessSet(
+                requests=concrete_requests,
+                aliases=processes.aliases,
+            ),
+            mode=write_mode,
+            files=write_result.files,
+        )
+
+    def _generate_on_the_fly_processes(
+        self,
+        expanded: tuple[_ExpandedProcess, ...],
+        *,
+        output: Path,
+        write_mode: Literal["error", "append", "replace"],
+        requested_processes: ProcessSet,
+        resolved_model: _ResolvedModel,
+        artifact_model: _CompiledModelPayload,
+        generation_model: Model,
+        reporter: GenerationPhaseReporter,
+        generation_started: float,
+    ) -> GenerationResult:
+        """Build source-only LC seeds before any color plan or process DAG."""
+
+        inputs_started = time.perf_counter()
+        model_inputs = self._recurrence_model_inputs(resolved_model)
+        reporter.timings["on-the-fly-model-input-preparation"] = (
+            time.perf_counter() - inputs_started
+        )
+        with TemporaryDirectory(prefix="pyamplicol-on-the-fly-generation-") as root:
+            temporary_root = Path(root)
+            indexed = tuple(enumerate(expanded))
+            with reporter.phase(
+                "on-the-fly-construction",
+                "Constructing compact on-the-fly process seeds",
+                total=len(indexed),
+            ) as phase:
+                projected = _map_process_phase(
+                    indexed,
+                    lambda item: self._project_on_the_fly_process(
+                        item[1],
+                        generation_model,
+                        model_inputs,
+                        index=item[0],
+                    ),
+                    executor=None,
+                    max_in_flight=1,
+                    phase_name="on-the-fly source projection",
+                    item_name=lambda item: item[1].request.name,
+                )
+                seed_payloads = _invoke_rust_on_the_fly_seed_batch_builder_v1(
+                    tuple(item.projection.seed.to_json_bytes() for item in projected),
+                    model_inputs.template_catalog_json,
+                    model_inputs.direct_template_catalog_json,
+                    model_inputs.prepared_kernel_pack_digest,
+                    process_identities=tuple(
+                        item.expanded.request.name for item in projected
+                    ),
+                )
+                packaged = tuple(zip(projected, seed_payloads, strict=True))
+                generated = _map_process_phase(
+                    packaged,
+                    lambda item: self._construct_on_the_fly_artifact(
+                        item[0],
+                        item[1],
+                        generation_model,
+                        model_inputs,
+                        temporary_root,
+                        phase=phase,
+                    ),
+                    executor=None,
+                    max_in_flight=1,
+                    phase_name="on-the-fly artifact packaging",
+                    item_name=lambda item: item[0].expanded.request.name,
+                )
+
+            artifact_processes = tuple(item.artifact for item in generated)
+            with reporter.phase(
+                "artifact-writing",
+                "Writing schema-v3 artifact",
+                total=1,
+            ) as phase:
+
+                def artifact_progress(event: dict[str, object]) -> None:
+                    details = {
+                        str(key): value
+                        for key, value in event.items()
+                        if isinstance(value, (str, int, float, bool, type(None)))
+                    }
+                    phase.update(
+                        int(event.get("completed", phase.completed)),
+                        total=(
+                            None if event.get("total") is None else int(event["total"])
+                        ),
+                        message=str(event.get("step", "writing artifact")),
+                        details=details,
+                    )
+
+                write_result = write_schema_v3_artifact(
+                    output,
+                    mode=write_mode,
+                    source=resolved_model.source,
+                    compiled_model=artifact_model,
+                    configuration=self._configuration,
+                    processes=artifact_processes,
+                    timings=reporter.timings,
+                    api_bundle_hook=self._api_bundle_hook,
+                    progress_callback=(
+                        artifact_progress if phase.sink is not None else None
+                    ),
+                    process_groups=_initial_process_groups(
+                        artifact_processes,
+                        (item.expanded for item in generated),
+                    ),
+                )
+                phase.update(
+                    phase.total or phase.completed,
+                    message=str(write_result.output),
+                    details={
+                        "step": "artifact ready",
+                        "file_count": len(write_result.files),
+                    },
+                )
+            validation_points_by_process = {
+                item.expanded.request.name: item.validation_points for item in generated
+            }
+            validation_selectors_by_process = {
+                item.expanded.request.name: item.validation_selectors
+                for item in generated
+            }
+            expected_process_ids = tuple(
+                process.process_id for process in artifact_processes
+            )
+            concrete_requests = tuple(item.expanded.request for item in generated)
+            del artifact_processes
+            del generated
+            gc.collect()
+            self._analyze_process_groups(write_result.output, reporter)
+
+        with reporter.phase(
+            "validation",
+            "Validating generated artifact",
+            total=1,
+        ) as phase:
+            validation = self._generation_config.validation
+            if validation.post_build_validation:
+                numerical_sample_count = sum(
+                    1
+                    for points in validation_points_by_process.values()
+                    if any(point.available for point in points)
+                )
+                self._validate_generated_artifact(
+                    write_result.output,
+                    expected_process_ids,
+                    validation_points=validation_points_by_process,
+                    compact_validation_selectors=(validation_selectors_by_process),
+                    expected_api_bundle_path=write_result.api_bundle_path,
+                    progress=phase,
+                )
+                if not validation.enabled:
+                    message = "compact schema, seed, selectors, and prepared model"
+                elif numerical_sample_count == 0:
+                    message = "compact schema; zero numerical samples available"
+                else:
+                    suffix = "" if numerical_sample_count == 1 else "s"
+                    message = (
+                        f"compact schema and {numerical_sample_count} "
+                        f"selector-bounded numerical sample{suffix}"
+                    )
+            else:
+                message = "post-build validation disabled"
+            phase.update(1, message=message)
+
+        reporter.timings["total"] = time.perf_counter() - generation_started
+        reporter.finish_generation()
+        return GenerationResult(
+            output=write_result.output,
+            processes=ProcessSet(
+                requests=concrete_requests,
+                aliases=requested_processes.aliases,
+            ),
+            mode=write_mode,
+            files=write_result.files,
+        )
+
+    def _project_on_the_fly_process(
+        self,
+        expanded: _ExpandedProcess,
+        model: Model,
+        model_inputs: _RecurrenceModelInputs,
+        *,
+        index: int,
+    ) -> _ProjectedOnTheFlyProcess:
+        run = self._run_config
+        if run is None:  # pragma: no cover - guarded by execution mode
+            raise GenerationError("on-the-fly generation requires RunConfig")
+        self._validate_on_the_fly_process_selection()
+        coupling_policy = str(run.process.coupling_order_policy)
+        explicit_limits = self._coupling_order_limits
+        projection = project_on_the_fly_process_seed_v1(
+            expanded.process_ir,
+            model_inputs.catalog,
+            model,
+            coupling_order_policy=cast(
+                Literal["minimal", "explicit"],
+                coupling_policy,
+            ),
+            coupling_order_limits=explicit_limits,
+            reference_color_order=self._process_selection.reference_color_order,
+            color_basis=self._fft_color_basis(expanded.process_ir, model),
+        )
+        return _ProjectedOnTheFlyProcess(
+            index=index,
+            expanded=expanded,
+            projection=projection,
+        )
+
+    def _validate_on_the_fly_process_selection(self) -> None:
+        if not self._on_the_fly_execution_enabled:
+            return
+        selection = self._process_selection
+        incompatible = []
+        if selection.max_color_sectors is not None:
+            incompatible.append("process.max_color_sectors")
+        if selection.selected_color_sector_ids is not None:
+            incompatible.append("process.selected_color_sector_ids")
+        if selection.selected_source_helicities is not None:
+            incompatible.append("process.selected_source_helicities")
+        if incompatible:
+            raise GenerationError(
+                "on-the-fly artifacts retain complete runtime selector coverage; "
+                "remove " + ", ".join(incompatible)
+            )
+
+    def _recurrence_helicity_selector_plan_enabled(self) -> bool:
+        """Return whether generation can retain the complete selector plan."""
+
+        selection = self._process_selection
+        return self._color_accuracy in {"nlc", "full"} and all(
+            value is None
+            for value in (
+                selection.max_color_sectors,
+                selection.selected_color_sector_ids,
+                selection.selected_source_helicities,
+            )
+        )
+
+    def _construct_on_the_fly_artifact(
+        self,
+        projected: _ProjectedOnTheFlyProcess,
+        seed_payload: bytes,
+        model: Model,
+        model_inputs: _RecurrenceModelInputs,
+        temporary_root: Path,
+        *,
+        phase: PhaseHandle,
+    ) -> _GeneratedOnTheFlyProcess:
+        expanded = projected.expanded
+        projection = projected.projection
+        index = projected.index
+        process_id = expanded.request.name
+        run = self._run_config
+        if run is None:  # pragma: no cover - guarded by execution mode
+            raise GenerationError("on-the-fly generation requires RunConfig")
+        query_construction_threads = run.evaluator.optimization.cores
+        if (
+            isinstance(query_construction_threads, bool)
+            or not isinstance(query_construction_threads, int)
+            or query_construction_threads < 1
+        ):
+            raise GenerationError(
+                "on-the-fly generation requires resolved positive "
+                "evaluator.optimization.cores"
+            )
+        selection = self._process_selection
+        coupling_policy = str(run.process.coupling_order_policy)
+        explicit_limits = self._coupling_order_limits
+        process_seed_identity = _invoke_rust_on_the_fly_seed_inspector_v1(seed_payload)
+        _bind_on_the_fly_process_seed_identity_v1(
+            process_seed_identity,
+            projection.seed,
+        )
+        color_accuracy = str(expanded.process_ir.color_accuracy)
+        contracted_color = None
+        if color_accuracy in {"nlc", "full"}:
+            if projection.color_plan is None:
+                raise GenerationError(
+                    "on-the-fly contracted-color projection has no color plan"
+                )
+            try:
+                contracted_color = _build_on_the_fly_contracted_color_payload_v1(
+                    projection.color_plan,
+                    contraction=run.color.contraction.value,
+                )
+            except ValueError as exc:
+                raise GenerationError(
+                    f"process {process_id!r} on-the-fly color contraction failed: {exc}"
+                ) from exc
+        elif projection.color_plan is not None:
+            raise GenerationError("LC on-the-fly projection carries a color plan")
+        validation_selectors = _on_the_fly_validation_selectors_v1(
+            projection.seed,
+            color_accuracy=color_accuracy,
+        )
+        selector_census = _on_the_fly_selector_census_v1(
+            projection.seed,
+            expanded.process_ir,
+        )
+        runtime_path = (
+            temporary_root
+            / "on-the-fly-runtimes"
+            / process_id
+            / "on-the-fly-runtime.pacbin"
+        )
+        runtime_path.parent.mkdir(parents=True, exist_ok=True)
+        runtime_index = write_pacbin_atomic(
+            runtime_path,
+            (
+                PacbinMemberSource(
+                    "on-the-fly/process-seed-v1.bin",
+                    PacbinMemberKind.ON_THE_FLY_PROCESS_SEED,
+                    io.BytesIO(seed_payload),
+                ),
+            ),
+        )
+        runtime_metadata = {
+            **build_on_the_fly_runtime_metadata(
+                projection.seed.external_sources,
+                projection.seed.parameter_projection,
+                model_inputs.catalog,
+                model,
+                projection.runtime_normalization,
+            ),
+            "process_seed_identity": process_seed_identity,
+        }
+        public_metadata = build_on_the_fly_public_metadata(
+            expanded.process_ir,
+            model_inputs.catalog,
+            process_id=process_id,
+        )
+        umami_physics = None
+        umami_sectors = ()
+        if run.generation.emit_api_bundle:
+            from ..artifacts.umami_otf import build_umami_on_the_fly_physics
+
+            umami_physics, umami_sectors = build_umami_on_the_fly_physics(
+                public_metadata, expanded.process_ir, projection.seed
+            )
+        validation = self._generation_config.validation
+        sample_count = (
+            validation.samples
+            if validation.enabled and validation.post_build_validation
+            else 1
+        )
+        points = tuple(
+            build_process_validation_point(
+                expanded.process_ir,
+                model,
+                process_id=process_id,
+                seed=validation.seed + index * sample_count + sample_index,
+            )
+            for sample_index in range(sample_count)
+        )
+        phase.advance(
+            message=process_id,
+            details={
+                "process": process_id,
+                "step": "compact on-the-fly seed ready",
+                "seed_size_bytes": len(seed_payload),
+            },
+        )
+        artifact = OnTheFlyProcessArtifact(
+            process_id=process_id,
+            expression=expanded.process_ir.process,
+            color_accuracy=str(expanded.process_ir.color_accuracy),
+            external_pdgs=tuple(int(leg.pdg) for leg in expanded.process_ir.legs),
+            aliases=expanded.aliases,
+            physics=public_metadata,
+            umami_physics=umami_physics,
+            umami_color_sectors=umami_sectors,
+            runtime_path=runtime_path,
+            runtime_size_bytes=runtime_index.file_size,
+            runtime_sha256=_file_sha256(runtime_path),
+            runtime_member_count=len(runtime_index.members),
+            runtime_unpacked_size_bytes=sum(
+                member.length for member in runtime_index.members
+            ),
+            runtime_index_sha256=runtime_index.index_sha256,
+            referenced_kernel_ids=frozenset(
+                kernel.kernel_id for kernel in model_inputs.bundle.kernel_pack.kernels
+            ),
+            runtime_metadata=runtime_metadata,
+            selector_policy={
+                **(
+                    {"color_basis": projection.color_plan.basis}
+                    if projection.color_plan is not None
+                    and projection.color_plan.basis != "trace"
+                    else {}
+                ),
+                "color_coverage": (
+                    "complete" if contracted_color is None else "contracted"
+                ),
+                "reference_color_word": (
+                    None
+                    if selection.reference_color_order is None
+                    else list(
+                        projection.color_plan.sectors[0].trace_labels
+                        if projection.color_plan is not None
+                        and projection.color_plan.basis == "adjoint"
+                        else selection.reference_color_order
+                    )
+                ),
+                "trace_reflections_folded": bool(
+                    contracted_color is None
+                    and model.lc_trace_reflection_equivalence_is_proven(
+                        expanded.process_ir
+                    )
+                ),
+                "selector_census": selector_census,
+            },
+            color_contraction_payload=(
+                None if contracted_color is None else contracted_color.payload
+            ),
+            color_contraction_summary=(
+                None if contracted_color is None else contracted_color.summary
+            ),
+            point_tile_size=run.evaluator.recurrence.point_tile_size,
+            query_construction_threads=query_construction_threads,
+            validation_point=points[0],
+            generation_filters={
+                **self._fft_basis_metadata(projection.color_plan),
+                "on_the_fly": {
+                    "coupling_order_policy": coupling_policy,
+                    "coupling_order_limits": dict(explicit_limits),
+                    "selector_coverage": (
+                        "complete" if contracted_color is None else "contracted"
+                    ),
+                },
+            },
+        )
+        return _GeneratedOnTheFlyProcess(
+            expanded=expanded,
+            artifact=artifact,
+            validation_points=points,
+            validation_selectors=validation_selectors,
+        )
+
+    def _generate_recurrence_processes(
+        self,
+        expanded: tuple[_ExpandedProcess, ...],
+        *,
+        output: Path,
+        write_mode: Literal["error", "append", "replace"],
+        requested_processes: ProcessSet,
+        resolved_model: _ResolvedModel,
+        artifact_model: _CompiledModelPayload,
+        generation_model: Model,
+        reporter: GenerationPhaseReporter,
+        generation_started: float,
+    ) -> GenerationResult:
+        """Build and publish compact recurrence schedules before GenericDAG."""
+
+        expanded = self._drop_processes_without_amplitudes(expanded, generation_model)
+        model_inputs_started = time.perf_counter()
+        model_inputs = self._recurrence_model_inputs(resolved_model)
+        reporter.timings["recurrence-model-input-preparation"] = (
+            time.perf_counter() - model_inputs_started
+        )
+        with TemporaryDirectory(
+            prefix="pyamplicol-recurrence-generation-"
+        ) as temporary:
+            temporary_root = Path(temporary)
+            worker_count = self._process_worker_count(len(expanded))
+            executor = (
+                ThreadPoolExecutor(
+                    max_workers=worker_count,
+                    thread_name_prefix="pyamplicol-recurrence-generation",
+                )
+                if worker_count > 1
+                else None
+            )
+            try:
+                indexed = tuple(enumerate(expanded))
+                lowering_cache = RecurrenceScheduleLoweringCache[
+                    _RustRecurrenceLoweringOutput
+                ]()
+                with reporter.phase(
+                    "recurrence-construction",
+                    "Constructing compact process recurrences",
+                    total=len(expanded),
+                ) as phase:
+                    generated = _map_process_phase(
+                        indexed,
+                        lambda item: self._construct_recurrence_artifact(
+                            item[1],
+                            generation_model,
+                            model_inputs,
+                            temporary_root,
+                            index=item[0],
+                            phase=phase,
+                            lowering_cache=lowering_cache,
+                            generation_timings=reporter.timings,
+                        ),
+                        executor=executor,
+                        max_in_flight=worker_count,
+                        phase_name="compact recurrence construction",
+                        item_name=lambda item: item[1].request.name,
+                    )
+            finally:
+                if executor is not None:
+                    executor.shutdown(wait=True, cancel_futures=True)
+
+            artifact_processes = tuple(item.artifact for item in generated)
+            recurrence_warnings: list[tuple[str, str]] = []
+            for process in artifact_processes:
+                relation_report = process.generation_filters.get("relation_discovery")
+                if not isinstance(relation_report, Mapping):
+                    continue
+                warning = relation_report.get("warning")
+                if (
+                    not isinstance(warning, Mapping)
+                    or warning.get("required") is not True
+                ):
+                    continue
+                code = warning.get("code")
+                message = warning.get("message")
+                if not isinstance(code, str) or not isinstance(message, str):
+                    raise GenerationError(
+                        "recurrence numerical warning metadata is malformed"
+                    )
+                item = (code, message)
+                if item not in recurrence_warnings:
+                    recurrence_warnings.append(item)
+            with reporter.phase(
+                "artifact-writing",
+                "Writing schema-v3 artifact",
+                total=1,
+            ) as phase:
+
+                def artifact_progress(event: dict[str, object]) -> None:
+                    details = {
+                        str(key): value
+                        for key, value in event.items()
+                        if isinstance(value, (str, int, float, bool, type(None)))
+                    }
+                    phase.update(
+                        int(event.get("completed", phase.completed)),
+                        total=(
+                            None if event.get("total") is None else int(event["total"])
+                        ),
+                        message=str(event.get("step", "writing artifact")),
+                        details=details,
+                    )
+
+                write_result = write_schema_v3_artifact(
+                    output,
+                    mode=write_mode,
+                    source=resolved_model.source,
+                    compiled_model=artifact_model,
+                    configuration=self._configuration,
+                    processes=artifact_processes,
+                    timings=reporter.timings,
+                    api_bundle_hook=self._api_bundle_hook,
+                    progress_callback=(
+                        artifact_progress if phase.sink is not None else None
+                    ),
+                    process_groups=_initial_process_groups(
+                        artifact_processes,
+                        (item.expanded for item in generated),
+                    ),
+                )
+                phase.update(
+                    phase.total or phase.completed,
+                    message=str(write_result.output),
+                    details={
+                        "step": "artifact ready",
+                        "file_count": len(write_result.files),
+                    },
+                )
+            for warning_code, warning_message in recurrence_warnings:
+                _LOGGER.warning(
+                    "%s [%s]",
+                    warning_message,
+                    warning_code,
+                )
+
+            validation_points_by_process = {
+                item.expanded.request.name: item.validation_points for item in generated
+            }
+            expected_process_ids = tuple(
+                process.process_id for process in artifact_processes
+            )
+            concrete_requests = tuple(item.expanded.request for item in generated)
+            del artifact_processes
+            del generated
+            gc.collect()
+            self._analyze_process_groups(write_result.output, reporter)
+
+        with reporter.phase(
+            "validation",
+            "Validating generated artifact",
+            total=1,
+        ) as phase:
+            validation = self._generation_config.validation
+            if validation.post_build_validation:
+                self._validate_generated_artifact(
+                    write_result.output,
+                    expected_process_ids,
+                    validation_points=validation_points_by_process,
+                    expected_api_bundle_path=write_result.api_bundle_path,
+                    progress=phase,
+                )
+                message = (
+                    f"schema and {validation.samples} numerical samples"
+                    if validation.enabled
+                    else "schema, references, hashes, and target"
+                )
+            else:
+                message = "post-build validation disabled"
+            phase.update(1, message=message)
+
+        reporter.timings["total"] = time.perf_counter() - generation_started
+        reporter.finish_generation()
+        return GenerationResult(
+            output=write_result.output,
+            processes=ProcessSet(
+                requests=concrete_requests,
+                aliases=requested_processes.aliases,
+            ),
+            mode=write_mode,
+            files=write_result.files,
+        )
+
+    def _artifact_model(self, resolved: _ResolvedModel) -> _CompiledModelPayload:
+        if resolved.compiled is not None:
+            return resolved.compiled
+        from ..models.loading import compile_model_source
+
+        return compile_model_source("BUILTIN_SM", use_cache=False)
+
+    def _expand_process_set(
+        self,
+        processes: ProcessSet,
+        resolved: _ResolvedModel,
+        phase: PhaseHandle,
+    ) -> tuple[_ExpandedProcess, ...]:
+        aliases_by_target: dict[str, list[ProcessAlias]] = {}
+        for alias in processes.aliases:
+            aliases_by_target.setdefault(alias.process_name, []).append(alias)
+        result: list[_ExpandedProcess] = []
+        names: set[str] = set()
+        for request_index, request in enumerate(processes.requests, start=1):
+            expanded = self._expand_request(request, resolved)
+            request_aliases = aliases_by_target.get(request.name, [])
+            if request_aliases and len(expanded) != 1:
+                raise GenerationError(
+                    f"process aliases for {request.name!r} are ambiguous after "
+                    f"expansion into {len(expanded)} concrete processes"
+                )
+            side_permutation_classes: set[tuple[tuple[str, ...], tuple[str, ...]]] = (
+                set()
+            )
+            for concrete_index, process_ir in enumerate(expanded, start=1):
+                permutation_class = _process_side_permutation_class(process_ir)
+                if permutation_class in side_permutation_classes:
+                    continue
+                side_permutation_classes.add(permutation_class)
+                name = _expanded_name(
+                    request.name,
+                    concrete_index,
+                    len(expanded),
+                )
+                if name in names:
+                    raise GenerationError(f"expanded process ID is not unique: {name}")
+                names.add(name)
+                concrete = ProcessRequest.parse(process_ir.process, name=name)
+                alias_records: list[Mapping[str, object]] = []
+                for alias in request_aliases:
+                    permutation = tuple(alias.particle_permutation) or tuple(
+                        range(len(process_ir.legs))
+                    )
+                    if len(permutation) != len(process_ir.legs):
+                        raise GenerationError(
+                            f"alias {alias.name!r} permutation has length "
+                            f"{len(permutation)}, expected {len(process_ir.legs)}"
+                        )
+                    if any(
+                        process_ir.legs[representative_index].side
+                        != process_ir.legs[public_index].side
+                        for representative_index, public_index in enumerate(permutation)
+                    ):
+                        raise GenerationError(
+                            f"alias {alias.name!r} may only permute particles "
+                            "within the incoming and outgoing sides"
+                        )
+                    alias_expression, alias_pdgs = _permuted_process_identity(
+                        process_ir,
+                        permutation,
+                    )
+                    alias_records.append(
+                        {
+                            "id": alias.name,
+                            "expression": alias_expression,
+                            "external_pdgs": list(alias_pdgs),
+                            "external_permutation": list(permutation),
+                        }
+                    )
+                result.append(
+                    _ExpandedProcess(
+                        request=concrete,
+                        process_ir=process_ir,
+                        aliases=tuple(alias_records),
+                        source_expansion_size=len(expanded),
+                        source_request=request,
+                    )
+                )
+            phase.update(request_index, message=request.name)
+        if self._flavor_blind:
+            # Names are assigned above, so process IDs do not depend on the flag.
+            table = self._grouping_particle_table(resolved)
+            result = _collapse_flavor_blind_classes(
+                result,
+                table,
+                consider_charge_conjugation=self._consider_charge_conjugation,
+                relation_warning=self._flavor_blind_relation_warning(resolved, table),
+            )
+        return tuple(result)
+
+    def _grouping_particle_table(
+        self,
+        resolved: _ResolvedModel,
+    ) -> dict[int, GroupingParticle]:
+        """Particle types for process grouping, from the compiled model."""
+
+        model = self._artifact_model(resolved).ir
+        return particle_table(
+            model.particles,
+            {parameter.name: parameter for parameter in model.parameters},
+        )
+
+    def _flavor_blind_relation_warning(
+        self,
+        resolved: _ResolvedModel,
+        table: Mapping[int, GroupingParticle],
+    ) -> _RelationWarning:
+        """Check relations against the vertices each representative is built from."""
+
+        from .process_grouping_symmetry import VertexSymmetryTable
+
+        model = resolved.model
+        compiled = resolved.compiled
+        if compiled is not None and resolved.use_compiled_process_catalog:
+            symmetry = VertexSymmetryTable.from_compiled_ir(compiled.ir)
+        else:
+            model = model or _builtin_sm_model()
+            symmetry = VertexSymmetryTable.from_builtin_model(model)
+        explicit = self._coupling_order_limits
+        run = self._run_config
+        minimal = run is not None and run.process.coupling_order_policy == "minimal"
+        limits_by_representative: dict[str, Mapping[str, int]] = {}
+
+        def warning(
+            member: GroupingProcess,
+            representative: GroupingProcess,
+            mapping: LegMapping,
+            representative_ir: CanonicalProcessIR,
+        ) -> str | None:
+            nonlocal model
+            limits = limits_by_representative.get(representative.process_id)
+            if limits is None:
+                limits = explicit
+                if minimal:
+                    if model is None:
+                        from ..models.external import CompiledUFOModel
+
+                        model = CompiledUFOModel(cast(_CompiledModelPayload, compiled))
+                    limits = (
+                        infer_minimal_coupling_order_limits(
+                            representative_ir,
+                            model=model,
+                            max_coupling_orders=explicit or None,
+                        )
+                        or explicit
+                    )
+                limits_by_representative[representative.process_id] = limits
+            return symmetry.relation_warning(
+                member, representative, mapping, table, limits=limits
+            )
+
+        return warning
+
+    def _compile_for_generation(
+        self,
+        expanded: _ExpandedProcess,
+        model: Model,
+        phase: PhaseHandle,
+    ) -> _DagProcess | _UnsupportedProcess:
+        process_name = expanded.request.name
+        with phase.child(
+            process_name,
+            f"{process_name}: DAG construction",
+            details={
+                "process": process_name,
+                "step": "colour-plan",
+            },
+        ) as task:
+
+            def report(details: Mapping[str, str | int]) -> None:
+                payload = {"process": process_name, **details}
+                completed = task.completed
+                total: int | None = None
+                if "mask_index" in details and "mask_total" in details:
+                    completed = int(details["mask_index"])
+                    total = int(details["mask_total"])
+                task.update(
+                    completed,
+                    total=total,
+                    message=str(details.get("step", "DAG construction")),
+                    details=payload,
+                )
+
+            try:
+                dag, coverage = self._compile_concrete_process(
+                    expanded.process_ir,
+                    model,
+                    progress_callback=report if task.sink is not None else None,
+                )
+            except _NoModelSupportedAmplitudes as exc:
+                if expanded.source_expansion_size <= 1:
+                    raise
+                result: _DagProcess | _UnsupportedProcess = _UnsupportedProcess(
+                    expanded=expanded,
+                    reason=str(exc),
+                )
+                step = "unsupported tree-level subprocess"
+                task.update(
+                    task.completed,
+                    message=step,
+                    details={
+                        "process": process_name,
+                        "step": step,
+                        "amplitude_count": 0,
+                    },
+                )
+            else:
+                result = _DagProcess(
+                    expanded=expanded,
+                    dag=dag,
+                    coverage=coverage,
+                )
+                step = "DAG complete"
+                task.update(
+                    task.completed,
+                    message=step,
+                    details={
+                        "process": process_name,
+                        "step": step,
+                        "current_count": len(dag.currents),
+                        "interaction_count": len(dag.interactions),
+                        "amplitude_count": len(dag.amplitude_roots),
+                    },
+                )
+        phase.advance(
+            message=process_name,
+            details={"process": process_name, "step": step},
+        )
+        return result
+
+    def _prepare_warmup_process(
+        self,
+        process: _DagProcess,
+        model: Model,
+        *,
+        index: int,
+        phase: PhaseHandle,
+    ) -> _CompiledProcess:
+        process_name = process.expanded.request.name
+        with phase.child(
+            process_name,
+            f"{process_name}: structural reduction",
+            total=2,
+            details={"process": process_name, "step": "structural reduction"},
+        ) as task:
+            result = self._prepare_warmup_process_inner(
+                process,
+                model,
+                index=index,
+                progress=task,
+            )
+        phase.advance(
+            message=process_name,
+            details={"process": process_name, "step": "validation points ready"},
+        )
+        return result
+
+    def _write_artifact(self, *args: Any, **kwargs: Any) -> ArtifactWriteResult:
+        """Keep optional payloads inside the existing publication transaction."""
+        return write_schema_v3_artifact(*args, **kwargs)
+
+    @property
+    def _numerical_process_grouping(self) -> bool:
+        run = self._run_config
+        return run is not None and run.process.analyze_process_groups == "numerical"
+
+    def _analyze_process_groups(
+        self,
+        artifact: Path,
+        reporter: GenerationPhaseReporter,
+    ) -> None:
+        """Merge numerically found process groups into the written artifact."""
+
+        run = self._run_config
+        if run is None or not self._numerical_process_grouping:
+            return
+        from .process_grouping_numerical import update_artifact_process_groups
+
+        with reporter.phase(
+            "process-grouping",
+            "Analyzing process groups numerically",
+            total=1,
+        ) as phase:
+            update_artifact_process_groups(
+                artifact,
+                analysis=str(run.process.analyze_process_groups),
+                only_unit_multiplier=run.process.only_unit_multiplier,
+                consider_charge_conjugation=run.process.consider_charge_conjugation,
+            )
+            phase.update(1, message="process-groups.json updated")
+
+    def _prepare_warmup_process_inner(
+        self,
+        process: _DagProcess,
+        model: Model,
+        *,
+        index: int,
+        progress: PhaseHandle,
+    ) -> _CompiledProcess:
+        process_name = process.expanded.request.name
+        progress.update(
+            0,
+            message="structural reduction",
+            details={
+                "process": process_name,
+                "step": "structural reduction",
+                "current_count": len(process.dag.currents),
+                "interaction_count": len(process.dag.interactions),
+                "amplitude_count": len(process.dag.amplitude_roots),
+            },
+        )
+        parity_preweighted = any(
+            float(root.helicity_weight) > 1.0 for root in process.dag.amplitude_roots
+        )
+        reduced = (
+            prune_dag_to_amplitude_roots(process.dag)
+            if parity_preweighted
+            else prune_global_helicity_flip_equivalent_roots(process.dag, model)
+        )
+        if reduced.process.color_accuracy == "lc":
+            reduced, dynamic_color_projection_certificate = (
+                project_rectangular_dynamic_color_classes(
+                    reduced,
+                    model,
+                    source_revision=active_source_revision(),
+                )
+            )
+            dynamic_color_projection = (
+                dynamic_color_projection_certificate.to_json_dict()
+            )
+        else:
+            dynamic_color_projection = dynamic_color_projection_not_applicable_report(
+                reduced
+            )
+        helicity_sum_dag: GenericDAG | None = None
+        helicity_selector_union_dag: GenericDAG | None = None
+        all_flow_union = self._all_flow_union_enabled
+        helicity_recurrence = build_helicity_recurrence_plan(reduced, model)
+        if helicity_recurrence is not None:
+            if self._eager_execution_enabled:
+                # Eager invocation tables already carry selector domains. Keep
+                # the exact recurrence proof, but do not serialize the
+                # compiled lane's evaluator-chunk schedules into an eager
+                # artifact.
+                reduced = replace(
+                    reduced,
+                    helicity_recurrence=helicity_recurrence,
+                    helicity_materialization=None,
+                )
+            else:
+                # Topology replay keeps its existing fused helicity-sum lane.
+                # The all-flow union is itself the primary reusable lane, so
+                # compiling that second payload would duplicate the expensive
+                # cross-flow recurrence without helping its target workload.
+                if not all_flow_union:
+                    helicity_sum_dag = replace(
+                        reduced,
+                        helicity_recurrence=None,
+                        helicity_materialization=None,
+                    )
+                materialization = materialize_helicity_recurrence(
+                    reduced,
+                    helicity_recurrence,
+                )
+                reduced = replace(
+                    materialization.dag,
+                    helicity_recurrence=helicity_recurrence,
+                    helicity_materialization=materialization,
+                )
+                if not all_flow_union:
+                    helicity_selector_union_dag = (
+                        self._compile_complete_color_helicity_selector_union(
+                            process,
+                            model,
+                        )
+                    )
+                if helicity_selector_union_dag is not None:
+                    _validate_matching_helicity_selector_domains(
+                        reduced,
+                        helicity_selector_union_dag,
+                    )
+        relation_config = self._generation_config.relation_discovery
+        relation_mode = str(relation_config.mode)
+        relation_execution_mode = cast(
+            Literal["compiled", "eager"],
+            "eager" if self._eager_execution_enabled else "compiled",
+        )
+        relation_lanes: dict[str, object] = {}
+        certified_relation_count = 0
+        applied_relation_count = 0
+        relation_warning_required = False
+
+        def apply_numerical_relations(
+            lane: str,
+            lane_dag: GenericDAG,
+        ) -> GenericDAG:
+            nonlocal applied_relation_count
+            nonlocal certified_relation_count
+            nonlocal relation_warning_required
+            if relation_mode == "off":
+                relation_lanes[lane] = generic_dag_numerical_current_opt_out_report(
+                    lane_dag,
+                    execution_mode=relation_execution_mode,
+                )
+                return lane_dag
+            if all_flow_union or lane == "helicity-selector-union":
+                application_relation_kinds: tuple[
+                    Literal["equal", "opposite", "zero"], ...
+                ] = ()
+                application_scope_reason = "multi-helicity-all-flow-selector-domain"
+            elif self._color_accuracy in {"nlc", "full"}:
+                application_relation_kinds = ("zero", "equal")
+                application_scope_reason = "contracted-binary64-opposite-contained"
+            else:
+                application_relation_kinds = ("equal", "opposite", "zero")
+                application_scope_reason = "complete-generic-dag"
+            try:
+                # Symbolica evaluator construction is process-global. Keep
+                # bounded high-precision captures serial even when independent
+                # process DAGs are prepared by worker threads.
+                with _SYMBOLICA_MATERIALIZATION_LOCK:
+                    result = run_generic_dag_numerical_current_warmup(
+                        lane_dag,
+                        model,
+                        process_id=process_name,
+                        mode=cast(
+                            Literal["diagnostic", "certified-reuse"],
+                            relation_mode,
+                        ),
+                        execution_mode=relation_execution_mode,
+                        precision_digits=relation_config.precision_digits,
+                        probe_count=relation_config.probe_count,
+                        verification_probe_count=(
+                            relation_config.verification_probe_count
+                        ),
+                        relative_tolerance=relation_config.relative_tolerance,
+                        absolute_tolerance=relation_config.absolute_tolerance,
+                        seed=relation_config.seed,
+                        application_relation_kinds=(application_relation_kinds),
+                        application_scope_reason=application_scope_reason,
+                    )
+            except ValueError as exc:
+                raise GenerationError(
+                    f"process {process_name!r} numerical current warm-up "
+                    f"failed closed in lane {lane!r}: {exc}"
+                ) from exc
+            certified_relation_count += len(result.discovery.certificates)
+            applied_relation_count += result.application.report.applied_relation_count
+            payload = result.to_json_dict()
+            if result.warning_required:
+                warning = payload.get("warning")
+                if (
+                    not isinstance(warning, Mapping)
+                    or warning.get("code") != NUMERICAL_CURRENT_RELATION_WARNING_CODE
+                    or warning.get("message") != NUMERICAL_CURRENT_RELATION_WARNING
+                ):
+                    raise GenerationError(
+                        "numerical current warm-up requested a warning "
+                        "without its stable warning contract"
+                    )
+                relation_warning_required = True
+            relation_lanes[lane] = payload
+            return result.dag
+
+        progress.update(
+            1,
+            message="authenticated numerical current warm-up",
+            details={
+                "process": process_name,
+                "step": "authenticated numerical current warm-up",
+                "mode": relation_mode,
+            },
+        )
+        reduced = apply_numerical_relations("primary", reduced)
+        if helicity_sum_dag is not None:
+            helicity_sum_dag = apply_numerical_relations(
+                "helicity-sum",
+                helicity_sum_dag,
+            )
+        if helicity_selector_union_dag is not None:
+            helicity_selector_union_dag = apply_numerical_relations(
+                "helicity-selector-union",
+                helicity_selector_union_dag,
+            )
+        warning_required = relation_warning_required
+        relation_discovery_payload: dict[str, object] = {
+            "schema_version": 1,
+            "abi": "pyamplicol-artifact-numerical-current-reuse-v1",
+            "requested_mode": relation_mode,
+            "effective_mode": relation_mode,
+            "effective_reuse_state": (
+                "disabled" if relation_mode == "off" else "enabled"
+            ),
+            "execution_mode": relation_execution_mode,
+            "lane_count": len(relation_lanes),
+            "lanes": relation_lanes,
+            "certified_relation_count": certified_relation_count,
+            "applied_relation_count": applied_relation_count,
+            "relation_correctness": numerical_relation_correctness_payload(
+                applied_relation_count
+            ),
+            "structural_exact_discovery": None,
+            "opt_out_flag": "--no-numerical-current-reuse",
+            "warning": (
+                {
+                    "required": True,
+                    "emit": "once-per-generated-artifact",
+                    "code": NUMERICAL_CURRENT_RELATION_WARNING_CODE,
+                    "message": NUMERICAL_CURRENT_RELATION_WARNING,
+                }
+                if warning_required
+                else {
+                    "required": False,
+                    "emit": "never",
+                    "code": None,
+                    "message": None,
+                }
+            ),
+        }
+        before_amplitude_roots = (
+            round(
+                sum(float(root.helicity_weight) for root in process.dag.amplitude_roots)
+            )
+            if parity_preweighted
+            else len(process.dag.amplitude_roots)
+        )
+        validation = self._generation_config.validation
+        filters: dict[str, object] = {
+            **(
+                {}
+                if self._color_accuracy != "lc"
+                else {
+                    "lc_flow_layout": (
+                        "all-flow-union" if all_flow_union else "topology-replay"
+                    )
+                }
+            ),
+            "structural_helicity_reduction": {
+                "applied": parity_preweighted or reduced is not process.dag,
+                "before_amplitude_roots": before_amplitude_roots,
+                "after_amplitude_roots": len(reduced.amplitude_roots),
+                "mode": "proven global-helicity-flip equivalence",
+            },
+            "dynamic_color_projection": dict(dynamic_color_projection),
+            "relation_discovery": relation_discovery_payload,
+            **(
+                {}
+                if reduced.helicity_recurrence is None
+                else {
+                    "helicity_recurrence": {
+                        "contract_version": (HELICITY_RECURRENCE_CONTRACT_VERSION),
+                        **reduced.helicity_recurrence.proof_counts(),
+                        **(
+                            {}
+                            if reduced.helicity_materialization is None
+                            else {
+                                "materialized_current_count": (
+                                    reduced.helicity_materialization.materialized_current_count
+                                ),
+                                "materialized_amplitude_count": (
+                                    reduced.helicity_materialization.materialized_root_count
+                                ),
+                                "materialization_strategy": (
+                                    reduced.helicity_materialization.strategy
+                                ),
+                            }
+                        ),
+                    }
+                }
+            ),
+        }
+        progress.update(
+            1,
+            message="validation-point preparation",
+            details={
+                "process": process_name,
+                "step": "validation-point preparation",
+                "current_count": len(reduced.currents),
+                "interaction_count": len(reduced.interactions),
+                "amplitude_count": len(reduced.amplitude_roots),
+            },
+        )
+        sample_count = (
+            validation.samples
+            if validation.enabled and validation.post_build_validation
+            else 1
+        )
+        points = tuple(
+            build_validation_point(
+                reduced,
+                model,
+                process_id=process.expanded.request.name,
+                seed=validation.seed + index * sample_count + sample_index,
+            )
+            for sample_index in range(sample_count)
+        )
+        point = points[0]
+        progress.update(
+            2,
+            message=(
+                process_name
+                if point.available
+                else f"{process_name}: metadata-only validation"
+            ),
+            details={
+                "process": process_name,
+                "step": "validation points ready",
+                "samples": len(points),
+            },
+        )
+        coverage = {
+            **dict(process.coverage),
+            "current_count": len(reduced.currents),
+            "interaction_count": len(reduced.interactions),
+            "interaction_evaluation_count": reduced.interaction_evaluation_count,
+            "amplitude_root_count": len(reduced.amplitude_roots),
+            "dynamic_color_projection": dict(dynamic_color_projection),
+            "relation_discovery": relation_discovery_payload,
+            **(
+                {}
+                if reduced.helicity_recurrence is None
+                else {
+                    "helicity_recurrence_contract_version": (
+                        HELICITY_RECURRENCE_CONTRACT_VERSION
+                    ),
+                    **reduced.helicity_recurrence.proof_counts(),
+                    **(
+                        {}
+                        if reduced.helicity_materialization is None
+                        else {
+                            "proof_current_count": (
+                                reduced.helicity_materialization.proof_current_count
+                            ),
+                            "proof_amplitude_count": (
+                                reduced.helicity_materialization.proof_root_count
+                            ),
+                            "helicity_materialization_strategy": (
+                                reduced.helicity_materialization.strategy
+                            ),
+                        }
+                    ),
+                }
+            ),
+        }
+        return _CompiledProcess(
+            expanded=process.expanded,
+            dag=reduced,
+            helicity_sum_dag=helicity_sum_dag,
+            helicity_selector_union_dag=helicity_selector_union_dag,
+            coverage=coverage,
+            filters=filters,
+            validation_points=points,
+        )
+
+    def _recurrence_model_inputs(
+        self,
+        resolved_model: _ResolvedModel,
+    ) -> _RecurrenceModelInputs:
+        compiled = resolved_model.compiled
+        bundle = None if compiled is None else compiled.prepared_bundle
+        if bundle is None:  # pragma: no cover - preflighted during model loading
+            raise GenerationError("recurrence generation has no prepared model bundle")
+        catalog = bundle.kernel_pack.recurrence_template_catalog
+        if catalog is None:  # pragma: no cover - preflighted during model loading
+            raise GenerationError(
+                "recurrence generation has no recurrence-template-v1 catalog"
+            )
+        direct_catalog = bundle.kernel_pack.recurrence_direct_template_catalog
+        if direct_catalog is None:  # pragma: no cover - preflighted during loading
+            raise GenerationError(
+                "recurrence generation has no recurrence-direct-template-v1 catalog"
+            )
+        return _RecurrenceModelInputs(
+            bundle=bundle,
+            catalog=catalog,
+            template_catalog_json=json.dumps(
+                catalog.to_dict(),
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            ).encode("ascii"),
+            template_input=build_recurrence_template_input_v1(catalog),
+            direct_template_catalog=direct_catalog,
+            direct_template_catalog_json=json.dumps(
+                direct_catalog.to_dict(),
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            ).encode("ascii"),
+            prepared_kernel_pack_digest=(catalog.header.prepared_kernel_pack_digest),
+        )
+
+    def _lower_recurrence_helicity_selector_plan(
+        self,
+        logical: RecurrenceBuilderLogicalInputV1,
+        color_plan: GenericColorPlan,
+        model_inputs: _RecurrenceModelInputs,
+        temporary_root: Path,
+        *,
+        process_id: str,
+        progress_callback: Callable[[Mapping[str, object]], None] | None = None,
+    ) -> RecurrenceHelicitySelectorPlanArtifact:
+        """Lower and bind one persisted physical-colour/runtime-H schedule.
+
+        The native lowering emits the authenticated dispatch sidecar together
+        with the ordinary Direct plan; no OTF seed or query family is built.
+        """
+
+        if logical.layout != "all-flow-union" or logical.replay_partitions:
+            raise GenerationError(
+                "recurrence helicity-selector plan requires physical "
+                "all-flow-union without replay"
+            )
+        if color_plan.color_accuracy not in {"nlc", "full"}:
+            raise GenerationError(
+                "recurrence helicity-selector plan requires complete NLC/full color"
+            )
+        run = self._run_config
+        if run is None:  # pragma: no cover - recurrence requires RunConfig
+            raise GenerationError(
+                "recurrence helicity-selector lowering has no evaluator config"
+            )
+        recurrence_evaluator = run.evaluator.recurrence
+        builder_input = build_recurrence_builder_input_v1(logical)
+        native_schedule_digest, base_schedule_digest, sharing_domain_digest = (
+            _recurrence_schedule_semantic_digests(
+                logical,
+                prepared_kernel_pack_digest=(model_inputs.prepared_kernel_pack_digest),
+                direct_template_catalog_digest=(
+                    model_inputs.direct_template_catalog.catalog_digest
+                ),
+                point_tile_size=recurrence_evaluator.point_tile_size,
+                workspace_mib=recurrence_evaluator.workspace_mib,
+                relation_discovery=None,
+            )
+        )
+
+        relation_discovery = self._generation_config.relation_discovery
+
+        def lower_schedule() -> _RustRecurrenceLoweringOutput:
+            output_root = (
+                temporary_root
+                / "recurrence-helicity-selector-schedules"
+                / base_schedule_digest
+            )
+            return _invoke_rust_recurrence_lowering_v2(
+                builder_input,
+                model_inputs.template_input,
+                model_inputs.direct_template_catalog,
+                model_inputs.prepared_kernel_pack_digest,
+                native_schedule_digest,
+                output_root / "recurrence-runtime.pacbin",
+                point_tile_size=recurrence_evaluator.point_tile_size,
+                workspace_mib=recurrence_evaluator.workspace_mib,
+                relation_discovery_mode="off",
+                relation_discovery_precision_digits=(
+                    relation_discovery.precision_digits
+                ),
+                relation_discovery_probe_count=relation_discovery.probe_count,
+                relation_discovery_verification_probe_count=(
+                    relation_discovery.verification_probe_count
+                ),
+                relation_discovery_relative_tolerance=(
+                    relation_discovery.relative_tolerance
+                ),
+                relation_discovery_absolute_tolerance=(
+                    relation_discovery.absolute_tolerance
+                ),
+                relation_discovery_seed=relation_discovery.seed,
+                color_accuracy=str(color_plan.color_accuracy),
+                helicity_dispatch_destination=(
+                    output_root / "recurrence-helicity-dispatch-v1.bin"
+                ),
+                progress_callback=progress_callback,
+                direct_template_catalog_json=(
+                    model_inputs.direct_template_catalog_json
+                ),
+            )
+
+        process_scoped_cache = RecurrenceScheduleLoweringCache[
+            _RustRecurrenceLoweringOutput
+        ]()
+        shared = process_scoped_cache.lower_process(
+            logical,
+            schedule_digest=base_schedule_digest,
+            sharing_domain_digest=sharing_domain_digest,
+            native_schedule_semantic_digest=native_schedule_digest,
+            direct_executor_count=len(model_inputs.direct_template_catalog.templates),
+            parameter_slot_count=len(model_inputs.catalog.parameters),
+            lower=lower_schedule,
+        )
+        expected_identity_remap = RecurrenceProcessRemap.identity(
+            logical,
+            direct_executor_count=len(model_inputs.direct_template_catalog.templates),
+            parameter_slot_count=len(model_inputs.catalog.parameters),
+        )
+        if shared.remap != expected_identity_remap:
+            raise GenerationError(
+                "recurrence helicity-selector AllFlow plan acquired a nonidentity "
+                "cross-process remap"
+            )
+        output = shared.output
+        dispatch = output.helicity_dispatch
+        if dispatch is None:
+            raise GenerationError(
+                "native recurrence helicity-selector lowering omitted its exact "
+                "dispatch"
+            )
+        if output.inspection_summary.get("lc_flow_layout") != "all-flow-union":
+            raise GenerationError(
+                "native recurrence helicity-selector lowering changed its layout"
+            )
+        resolved_helicities = shared.remap.remap_resolved_helicities(
+            output.resolved_helicities
+        )
+        if dispatch.resolved_helicity_count != len(resolved_helicities):
+            raise GenerationError(
+                "recurrence helicity dispatch does not cover the auxiliary full "
+                "helicity domain"
+            )
+        try:
+            destinations = tuple(
+                (
+                    shared.remap.physical_sector_ids[sector_id],
+                    helicity_id,
+                )
+                for sector_id, helicity_id in output.amplitude_destinations
+            )
+        except IndexError as exc:
+            raise GenerationError(
+                "recurrence helicity-selector destination lies outside its "
+                "physical-owner binding"
+            ) from exc
+        expected_destinations = tuple(
+            (sector_id, None) for sector_id in range(len(logical.physical_sectors))
+        )
+        if destinations != expected_destinations:
+            raise GenerationError(
+                "recurrence helicity-selector destinations are not dense "
+                "runtime-helicity physical owners"
+            )
+
+        required_direct_executor_ids = _required_process_direct_executor_ids(
+            output.exact_sections,
+            shared.remap,
+        )
+        process_executor_pack = build_recurrence_process_executor_pack(
+            direct_catalog=model_inputs.direct_template_catalog,
+            kernel_pack=model_inputs.bundle.kernel_pack,
+            required_executor_ids=required_direct_executor_ids,
+            runtime_layout_digest=dispatch.base_runtime_layout_digest,
+        )
+        selector_schedule_digest = recurrence_helicity_selector_schedule_digest(
+            shared.schedule_digest,
+            dispatch.payload_sha256,
+        )
+        inspection_summary = _process_scoped_recurrence_inspection_summary(
+            output.inspection_summary,
+            process_id=process_id,
+            semantic_digest=builder_input.digest,
+            schedule_digest=shared.schedule_digest,
+        )
+        return RecurrenceHelicitySelectorPlanArtifact(
+            recurrence_schedule_path=output.payload_path,
+            recurrence_base_schedule_digest=shared.schedule_digest,
+            recurrence_schedule_digest=selector_schedule_digest,
+            recurrence_native_schedule_semantic_digest=(
+                shared.native_schedule_semantic_digest
+            ),
+            recurrence_schedule_size_bytes=output.payload_size_bytes,
+            recurrence_schedule_sha256=output.payload_sha256,
+            recurrence_schedule_member_count=output.member_count,
+            recurrence_schedule_unpacked_size_bytes=output.unpacked_size_bytes,
+            recurrence_schedule_index_sha256=output.index_sha256,
+            helicity_dispatch_path=dispatch.payload_path,
+            helicity_dispatch_size_bytes=dispatch.payload_size_bytes,
+            helicity_dispatch_sha256=dispatch.payload_sha256,
+            helicity_dispatch_base_runtime_layout_digest=(
+                dispatch.base_runtime_layout_digest
+            ),
+            helicity_dispatch_resolved_helicity_count=(
+                dispatch.resolved_helicity_count
+            ),
+            physical_destination_count=len(destinations),
+            builder_input_sha256=builder_input.digest,
+            inspection_summary=inspection_summary,
+            referenced_kernel_ids=recurrence_referenced_kernel_ids(logical),
+            recurrence_process_remap=shared.remap,
+            recurrence_process_executor_pack=process_executor_pack,
+        )
+
+    def _drop_processes_without_amplitudes(
+        self,
+        expanded: tuple[_ExpandedProcess, ...],
+        model: Model,
+    ) -> tuple[_ExpandedProcess, ...]:
+        """Skip children of a multiparticle request that the model cannot connect.
+
+        The recurrence builders, unlike the DAG compiler, need an amplitude.
+        """
+
+        results: list[_ExpandedProcess | _UnsupportedProcess] = []
+        for entry in expanded:
+            process = entry.process_ir
+            supported = entry.source_expansion_size <= 1 or (
+                has_model_supported_amplitudes(
+                    process,
+                    model=model,
+                    color_plan=build_color_plan(
+                        process,
+                        color_accuracy=self._color_accuracy,
+                        fold_trace_reflections=(
+                            model.lc_trace_reflection_equivalence_is_proven(process)
+                        ),
+                    ),
+                    max_coupling_orders=self._coupling_order_limits or None,
+                )
+            )
+            results.append(
+                entry
+                if supported
+                else _UnsupportedProcess(
+                    expanded=entry,
+                    reason=(
+                        f"process {process.process!r} has no model-supported "
+                        "tree-level amplitudes"
+                    ),
+                )
+            )
+        kept, unsupported = _partition_model_supported_processes(results)
+        _warn_unsupported_processes(unsupported)
+        return kept
+
+    def _construct_recurrence_artifact(
+        self,
+        expanded: _ExpandedProcess,
+        model: Model,
+        model_inputs: _RecurrenceModelInputs,
+        temporary_root: Path,
+        *,
+        index: int,
+        phase: PhaseHandle,
+        lowering_cache: RecurrenceScheduleLoweringCache[_RustRecurrenceLoweringOutput],
+        generation_timings: dict[str, float] | None = None,
+    ) -> _GeneratedRecurrenceProcess:
+        process_name = expanded.request.name
+        profile_started = time.perf_counter()
+        profile: dict[str, float] = {}
+        selector_plan_enabled = self._recurrence_helicity_selector_plan_enabled()
+        with phase.child(
+            process_name,
+            f"{process_name}: compact recurrence construction",
+            total=3,
+            details={"process": process_name, "step": "colour planning"},
+        ) as task:
+            preparation_started = time.perf_counter()
+            prepared = self._prepare_process_construction(expanded.process_ir, model)
+            profile["process-model-color-preparation"] = (
+                time.perf_counter() - preparation_started
+            )
+            normalization_started = time.perf_counter()
+            normalization_contract, normalization_payload = (
+                build_recurrence_normalization(expanded.process_ir, model)
+            )
+            profile["normalization"] = time.perf_counter() - normalization_started
+            layout = (
+                "contracted-color-union"
+                if self._color_accuracy in {"nlc", "full"}
+                else (
+                    "all-flow-union"
+                    if self._all_flow_union_enabled
+                    else "topology-replay"
+                )
+            )
+            typed_layout = cast(
+                Literal[
+                    "topology-replay",
+                    "all-flow-union",
+                    "contracted-color-union",
+                ],
+                layout,
+            )
+            selection = self._process_selection
+            if (
+                layout == "contracted-color-union"
+                and selection.selected_color_sector_ids is not None
+            ):
+                raise GenerationError(
+                    "NLC/full recurrence contracts the complete color basis and "
+                    "does not support generation-selected color sectors"
+                )
+            source_selection = (
+                None
+                if selection.selected_source_helicities is None
+                else tuple(sorted(selection.selected_source_helicities.items()))
+            )
+            projection_color_plan = prepared.complete_color_plan
+            if selection.selected_color_sector_ids is not None:
+                # Compact recurrence tables require dense physical-sector IDs.
+                # A generation-specialized artifact owns only its restricted
+                # sector domain, so remap that domain before projection instead
+                # of retaining the unrequested complete-plan aliases.
+                projection_color_plan = replace(
+                    prepared.restricted_color_plan,
+                    sectors=tuple(
+                        replace(sector, id=dense_id)
+                        for dense_id, sector in enumerate(
+                            prepared.restricted_color_plan.sectors
+                        )
+                    ),
+                )
+            projection_started = time.perf_counter()
+            logical = project_recurrence_process_v1(
+                expanded.process_ir,
+                projection_color_plan,
+                model_inputs.catalog,
+                layout=typed_layout,
+                normalization=normalization_contract,
+                topology_replay=prepared.topology_replay,
+                generation_slice=RecurrenceGenerationSliceV1(
+                    selected_source_helicities=source_selection,
+                ),
+                coupling_order_limits=prepared.coupling_order_limits,
+                model=model,
+                prefer_symmetric_group_closure_anchor=(
+                    self._run_config is not None
+                    and self._run_config.color.contraction.value
+                    in {"auto", "symmetric-group-fft"}
+                ),
+            )
+            if selection.selected_color_sector_ids is not None:
+                selected_public_flow_ids = tuple(
+                    flow.flow_id for flow in logical.public_flows
+                )
+                logical = replace(
+                    logical,
+                    selected_public_flow_ids=selected_public_flow_ids,
+                )
+            profile["projection-semantic-catalog"] = (
+                time.perf_counter() - projection_started
+            )
+            task.update(
+                1,
+                message="columnar recurrence input",
+                details={
+                    "process": process_name,
+                    "step": "columnar recurrence input",
+                    "color_sector_count": len(logical.physical_sectors),
+                    "public_flow_count": len(logical.public_flows),
+                },
+            )
+            columnar_started = time.perf_counter()
+            builder_input = build_recurrence_builder_input_v1(logical)
+            profile["columnar-normalization"] = time.perf_counter() - columnar_started
+            native_process_id = logical.process_id
+            runtime_metadata_started = time.perf_counter()
+            runtime_metadata = build_recurrence_runtime_metadata(
+                logical,
+                model_inputs.catalog,
+                model,
+                normalization_payload,
+            )
+            profile["runtime-metadata"] = time.perf_counter() - runtime_metadata_started
+            run = self._run_config
+            if run is None:  # pragma: no cover - recurrence requires RunConfig
+                raise GenerationError(
+                    "recurrence generation has no evaluator configuration"
+                )
+            recurrence_evaluator = run.evaluator.recurrence
+            relation_discovery = self._generation_config.relation_discovery
+            relation_discovery_mode = str(relation_discovery.mode)
+            relation_discovery_identity = (
+                None
+                if relation_discovery_mode == "off"
+                else {
+                    "mode": relation_discovery_mode,
+                    "precision_digits": relation_discovery.precision_digits,
+                    "probe_count": relation_discovery.probe_count,
+                    "verification_probe_count": (
+                        relation_discovery.verification_probe_count
+                    ),
+                    "relative_tolerance": (relation_discovery.relative_tolerance),
+                    "absolute_tolerance": (relation_discovery.absolute_tolerance),
+                    "seed": relation_discovery.seed,
+                    "color_accuracy": str(expanded.process_ir.color_accuracy),
+                    "probe_process_id": native_process_id,
+                }
+            )
+            schedule_digest_started = time.perf_counter()
+            (
+                native_schedule_semantic_digest,
+                request_schedule_digest,
+                sharing_domain_digest,
+            ) = _recurrence_schedule_semantic_digests(
+                logical,
+                prepared_kernel_pack_digest=(model_inputs.prepared_kernel_pack_digest),
+                direct_template_catalog_digest=(
+                    model_inputs.direct_template_catalog.catalog_digest
+                ),
+                point_tile_size=recurrence_evaluator.point_tile_size,
+                workspace_mib=recurrence_evaluator.workspace_mib,
+                relation_discovery=relation_discovery_identity,
+            )
+            profile["schedule-normalization-and-digests"] = (
+                time.perf_counter() - schedule_digest_started
+            )
+            task.update(
+                2,
+                message="Rust recurrence builder",
+                details={
+                    "process": process_name,
+                    "step": "Rust recurrence builder",
+                },
+            )
+            native_phase_total = len(logical.external_legs) + 1
+            with task.child(
+                "rust-builder",
+                f"{process_name}: Rust recurrence construction",
+                total=native_phase_total,
+                unit="phases",
+                details={
+                    "process": process_name,
+                    "step": "source construction",
+                },
+            ) as native_task:
+
+                def report_native(details: Mapping[str, object]) -> None:
+                    progress_index = int(
+                        details.get("phase_index", native_task.completed)
+                    )
+                    progress_total = int(details.get("phase_total", native_phase_total))
+                    contribution_count = int(details.get("contribution_count", 0))
+                    display_details = {
+                        "process": process_name,
+                        "step": str(details.get("step", "recurrence construction")),
+                        "stage_total": int(details.get("stage_total", 0)),
+                        "candidate_parent_pair_count": int(
+                            details.get("candidate_parent_pair_count", 0)
+                        ),
+                        "current_count": int(details.get("current_count", 0)),
+                        "contribution_count": contribution_count,
+                        "dynamic_color_state_count": int(
+                            details.get("dynamic_color_state_count", 0)
+                        ),
+                        "color_target_prune_count": int(
+                            details.get("color_target_prune_count", 0)
+                        ),
+                    }
+                    for name in (
+                        "stage_index",
+                        "subset_size",
+                        "candidate_parent_pair_total",
+                    ):
+                        value = details.get(name)
+                        if value is not None:
+                            display_details[name] = int(value)
+                    native_task.update(
+                        progress_index,
+                        total=progress_total,
+                        message=str(details.get("step", "recurrence construction")),
+                        details=display_details,
+                    )
+
+                final_schedule_path = (
+                    temporary_root
+                    / "recurrence-schedules"
+                    / request_schedule_digest
+                    / "recurrence-runtime.pacbin"
+                )
+
+                def lower_schedule() -> _RustRecurrenceLoweringOutput:
+                    def lower_once(
+                        destination: Path,
+                        *,
+                        mode: str,
+                        evidence: bytes | None,
+                        report_progress: bool,
+                        timing_name: str,
+                    ) -> _RustRecurrenceLoweringOutput:
+                        lowering_started = time.perf_counter()
+                        try:
+                            return _invoke_rust_recurrence_lowering_v2(
+                                builder_input,
+                                model_inputs.template_input,
+                                model_inputs.direct_template_catalog,
+                                model_inputs.prepared_kernel_pack_digest,
+                                native_schedule_semantic_digest,
+                                destination,
+                                point_tile_size=(recurrence_evaluator.point_tile_size),
+                                workspace_mib=recurrence_evaluator.workspace_mib,
+                                relation_discovery_mode=mode,
+                                relation_discovery_precision_digits=(
+                                    relation_discovery.precision_digits
+                                ),
+                                relation_discovery_probe_count=(
+                                    relation_discovery.probe_count
+                                ),
+                                relation_discovery_verification_probe_count=(
+                                    relation_discovery.verification_probe_count
+                                ),
+                                relation_discovery_relative_tolerance=(
+                                    relation_discovery.relative_tolerance
+                                ),
+                                relation_discovery_absolute_tolerance=(
+                                    relation_discovery.absolute_tolerance
+                                ),
+                                relation_discovery_seed=relation_discovery.seed,
+                                color_accuracy=str(expanded.process_ir.color_accuracy),
+                                relation_discovery_evidence_json=evidence,
+                                progress_callback=(
+                                    report_native
+                                    if report_progress and native_task.sink is not None
+                                    else None
+                                ),
+                                direct_template_catalog_json=(
+                                    model_inputs.direct_template_catalog_json
+                                ),
+                            )
+                        finally:
+                            profile[timing_name] = (
+                                time.perf_counter() - lowering_started
+                            )
+
+                    if relation_discovery_mode == "off":
+                        output = lower_once(
+                            final_schedule_path,
+                            mode="off",
+                            evidence=None,
+                            report_progress=True,
+                            timing_name="native-final-generation",
+                        )
+                        lane_report = recurrence_numerical_current_opt_out_report(
+                            _parse_exact_sections(
+                                output.exact_sections,
+                                native_process_id,
+                            ),
+                            color_accuracy=str(expanded.process_ir.color_accuracy),
+                        )
+                        runtime_inspection, aggregate_report = (
+                            _recurrence_relation_reporting(
+                                output.inspection_summary,
+                                mode=relation_discovery_mode,
+                                lane_report=lane_report,
+                            )
+                        )
+                        return replace(
+                            output,
+                            inspection_summary=runtime_inspection,
+                            generation_profile={
+                                "schema_version": 1,
+                                "native_passes": {
+                                    "final": dict(output.generation_profile)
+                                },
+                            },
+                            numerical_current_reuse_report=aggregate_report,
+                        )
+
+                    baseline = lower_once(
+                        temporary_root
+                        / ".numerical-current-baseline"
+                        / request_schedule_digest
+                        / "recurrence-runtime.pacbin",
+                        mode="off",
+                        evidence=None,
+                        report_progress=True,
+                        timing_name="native-baseline-generation",
+                    )
+                    probe_points_started = time.perf_counter()
+                    candidate_points, verification_points = (
+                        build_recurrence_numerical_current_probe_points(
+                            expanded.process_ir,
+                            model,
+                            process_id=native_process_id,
+                            seed=relation_discovery.seed,
+                            candidate_count=relation_discovery.probe_count,
+                            verification_count=(
+                                relation_discovery.verification_probe_count
+                            ),
+                        )
+                    )
+                    profile["numerical-probe-point-preparation"] = (
+                        time.perf_counter() - probe_points_started
+                    )
+                    envelope_fallback: (
+                        RecurrenceNumericalEvidenceEnvelopeExceeded | None
+                    ) = None
+                    warmup = None
+                    try:
+                        with _SYMBOLICA_MATERIALIZATION_LOCK:
+                            baseline_plan_started = time.perf_counter()
+                            baseline_plan = _RecurrenceExactPlan.from_generation(
+                                raw_sections=baseline.exact_sections,
+                                process_id=native_process_id,
+                                bundle=model_inputs.bundle,
+                                runtime_metadata=runtime_metadata,
+                            )
+                            profile["numerical-baseline-plan-load"] = (
+                                time.perf_counter() - baseline_plan_started
+                            )
+                            warmup_started = time.perf_counter()
+                            warmup = run_recurrence_numerical_current_warmup(
+                                baseline_plan,
+                                candidate_points=candidate_points,
+                                verification_points=verification_points,
+                                mode=cast(
+                                    Literal[
+                                        "diagnostic",
+                                        "certified-reuse",
+                                    ],
+                                    relation_discovery_mode,
+                                ),
+                                color_accuracy=str(expanded.process_ir.color_accuracy),
+                                precision_digits=(relation_discovery.precision_digits),
+                                seed=relation_discovery.seed,
+                                relative_tolerance=(
+                                    relation_discovery.relative_tolerance
+                                ),
+                                absolute_tolerance=(
+                                    relation_discovery.absolute_tolerance
+                                ),
+                            )
+                            profile["numerical-warmup-total"] = (
+                                time.perf_counter() - warmup_started
+                            )
+                            profile.update(
+                                {
+                                    f"numerical-{name}": seconds
+                                    for name, seconds in (
+                                        warmup.generation_profile_timings.items()
+                                    )
+                                }
+                            )
+                    except RecurrenceNumericalEvidenceEnvelopeExceeded as exc:
+                        profile["numerical-warmup-total"] = (
+                            time.perf_counter() - warmup_started
+                        )
+                        if relation_discovery_mode != "certified-reuse":
+                            raise GenerationError(
+                                f"process {process_name!r} recurrence numerical "
+                                "diagnostic evidence exceeds its memory envelope"
+                            ) from exc
+                        envelope_fallback = (
+                            _detached_recurrence_evidence_envelope_outcome(
+                                exc,
+                                source_error=exc,
+                            )
+                        )
+                    except (ArtifactError, ValueError) as exc:
+                        raise GenerationError(
+                            f"process {process_name!r} recurrence numerical "
+                            f"current warm-up failed closed: {exc}"
+                        ) from exc
+                    if envelope_fallback is not None:
+                        fallback_details = envelope_fallback.to_json_dict()
+                        geometry_details = cast(
+                            Mapping[str, object],
+                            fallback_details["geometry"],
+                        )
+                        native_task.update(
+                            native_task.completed,
+                            message=EVIDENCE_ENVELOPE_FALLBACK_WARNING,
+                            details={
+                                "process": process_name,
+                                "step": "numerical-current reuse disabled",
+                                "warning_code": (EVIDENCE_ENVELOPE_FALLBACK_REASON),
+                                "current_count": int(geometry_details["current_count"]),
+                                "component_count": int(
+                                    geometry_details["component_count"]
+                                ),
+                                "scalar_count": int(geometry_details["scalar_count"]),
+                                "row_count": int(geometry_details["row_count"]),
+                            },
+                        )
+                        warmup_owner = None
+                        if warmup is not None:
+                            warmup_owner = [warmup]
+                            warmup = None
+                        return _complete_recurrence_evidence_envelope_fallback(
+                            final_schedule_path=final_schedule_path,
+                            baseline=baseline,
+                            baseline_plan=baseline_plan,
+                            color_accuracy=str(expanded.process_ir.color_accuracy),
+                            outcome=envelope_fallback,
+                            warmup_owner=warmup_owner,
+                        )
+                    if warmup is None:
+                        raise AssertionError(
+                            "recurrence numerical warm-up completed without a result"
+                        )
+                    try:
+                        native_capacity_fallback: (
+                            RecurrenceNumericalEvidenceEnvelopeExceeded | None
+                        ) = None
+                        try:
+                            if not warmup.certificates:
+                                warmup = warmup.without_evidence_transport()
+                            output, application_validation_required = (
+                                _lower_recurrence_after_numerical_warmup(
+                                    lower_once=lower_once,
+                                    final_schedule_path=final_schedule_path,
+                                    baseline=baseline,
+                                    warmup=warmup,
+                                    requested_mode=relation_discovery_mode,
+                                )
+                            )
+                        except (ArtifactError, GenerationError) as exc:
+                            native_capacity_fallback = (
+                                recurrence_numerical_evidence_capacity_outcome(
+                                    baseline_plan.sections,
+                                    candidate_probe_count=len(candidate_points),
+                                    verification_probe_count=len(verification_points),
+                                    runtime_parameter_count=len(
+                                        baseline_plan.runtime_parameter_schema
+                                    ),
+                                    error=exc,
+                                )
+                            )
+                            if (
+                                native_capacity_fallback is None
+                                or relation_discovery_mode != "certified-reuse"
+                            ):
+                                raise
+                            native_capacity_fallback = (
+                                _detached_recurrence_evidence_envelope_outcome(
+                                    native_capacity_fallback,
+                                    source_error=exc,
+                                )
+                            )
+                        if native_capacity_fallback is not None:
+                            # The failed native call can retain its evidence
+                            # argument through exception frames.  The handler
+                            # above detached those frames; close both trusted
+                            # spools and drop the result (including the evidence
+                            # transport) before publishing the already
+                            # validated reuse-off baseline.
+                            fallback_details = native_capacity_fallback.to_json_dict()
+                            geometry_details = cast(
+                                Mapping[str, object],
+                                fallback_details["geometry"],
+                            )
+                            native_task.update(
+                                native_task.completed,
+                                message=EVIDENCE_ENVELOPE_FALLBACK_WARNING,
+                                details={
+                                    "process": process_name,
+                                    "step": "numerical-current reuse disabled",
+                                    "warning_code": (EVIDENCE_ENVELOPE_FALLBACK_REASON),
+                                    "current_count": int(
+                                        geometry_details["current_count"]
+                                    ),
+                                    "component_count": int(
+                                        geometry_details["component_count"]
+                                    ),
+                                    "scalar_count": int(
+                                        geometry_details["scalar_count"]
+                                    ),
+                                    "row_count": int(geometry_details["row_count"]),
+                                },
+                            )
+                            fallback_color_accuracy = str(
+                                expanded.process_ir.color_accuracy
+                            )
+                            warmup_owner = [warmup]
+                            warmup = None
+                            return _complete_recurrence_evidence_envelope_fallback(
+                                final_schedule_path=final_schedule_path,
+                                baseline=baseline,
+                                baseline_plan=baseline_plan,
+                                color_accuracy=fallback_color_accuracy,
+                                outcome=native_capacity_fallback,
+                                warmup_owner=warmup_owner,
+                            )
+                        if warmup is None:
+                            raise AssertionError(
+                                "recurrence numerical warm-up was released "
+                                "without a fallback"
+                            )
+                        if not application_validation_required:
+                            return output
+                        warmup = warmup.without_evidence_transport()
+                        try:
+                            with _SYMBOLICA_MATERIALIZATION_LOCK:
+                                applied_plan_started = time.perf_counter()
+                                applied_plan = _RecurrenceExactPlan.from_generation(
+                                    raw_sections=output.exact_sections,
+                                    process_id=native_process_id,
+                                    bundle=model_inputs.bundle,
+                                    runtime_metadata=runtime_metadata,
+                                )
+                                profile["numerical-application-plan-load"] = (
+                                    time.perf_counter() - applied_plan_started
+                                )
+                                application_validation_started = time.perf_counter()
+                                warmup = (
+                                    validate_recurrence_numerical_current_application(
+                                        warmup,
+                                        applied_plan,
+                                        baseline_plan=baseline_plan,
+                                        precision_digits=(
+                                            relation_discovery.precision_digits
+                                        ),
+                                        seed=relation_discovery.seed,
+                                        relative_tolerance=(
+                                            relation_discovery.relative_tolerance
+                                        ),
+                                        absolute_tolerance=(
+                                            relation_discovery.absolute_tolerance
+                                        ),
+                                    )
+                                )
+                                profile["numerical-application-validation"] = (
+                                    time.perf_counter() - application_validation_started
+                                )
+                        except (ArtifactError, ValueError) as exc:
+                            raise GenerationError(
+                                f"process {process_name!r} optimized recurrence "
+                                f"current replay failed closed: {exc}"
+                            ) from exc
+                        runtime_inspection, aggregate_report = (
+                            _recurrence_relation_reporting(
+                                output.inspection_summary,
+                                mode=relation_discovery_mode,
+                                lane_report=warmup.to_json_dict(),
+                            )
+                        )
+                        return replace(
+                            output,
+                            inspection_summary=runtime_inspection,
+                            generation_profile={
+                                "schema_version": 1,
+                                "native_passes": {
+                                    "baseline": dict(baseline.generation_profile),
+                                    "final": dict(output.generation_profile),
+                                },
+                            },
+                            numerical_current_reuse_report=aggregate_report,
+                        )
+                    finally:
+                        if warmup is not None:
+                            warmup.close()
+
+                schedule_lowering_started = time.perf_counter()
+                shared = lowering_cache.lower_process(
+                    logical,
+                    schedule_digest=request_schedule_digest,
+                    sharing_domain_digest=sharing_domain_digest,
+                    native_schedule_semantic_digest=(native_schedule_semantic_digest),
+                    direct_executor_count=len(
+                        model_inputs.direct_template_catalog.templates
+                    ),
+                    parameter_slot_count=len(model_inputs.catalog.parameters),
+                    lower=lower_schedule,
+                )
+                profile["schedule-sharing-and-lowering"] = (
+                    time.perf_counter() - schedule_lowering_started
+                )
+                output = shared.output
+                schedule_digest = shared.schedule_digest
+                native_schedule_semantic_digest = shared.native_schedule_semantic_digest
+                process_remap = shared.remap
+            task.update(
+                3,
+                message="compact recurrence runtime ready",
+                details={
+                    "process": process_name,
+                    "step": "compact recurrence runtime ready",
+                },
+            )
+        companion_artifact = None
+        if selector_plan_enabled:
+            selector_phase_total = len(expanded.process_ir.legs) + 2
+            with phase.child(
+                f"{process_name}:helicity-selector",
+                f"{process_name}: persisted helicity-selector plan",
+                total=selector_phase_total,
+                unit="phases",
+                details={
+                    "process": process_name,
+                    "step": "physical-color selector projection",
+                },
+            ) as selector_task:
+                companion_projection_started = time.perf_counter()
+                companion_logical = project_recurrence_process_v1(
+                    expanded.process_ir,
+                    prepared.complete_color_plan,
+                    model_inputs.catalog,
+                    layout="all-flow-union",
+                    normalization=normalization_contract,
+                    topology_replay=None,
+                    generation_slice=RecurrenceGenerationSliceV1(),
+                    coupling_order_limits=prepared.coupling_order_limits,
+                    model=model,
+                    prefer_symmetric_group_closure_anchor=(
+                        run.color.contraction.value in {"auto", "symmetric-group-fft"}
+                    ),
+                    contracted_physical_color_union=True,
+                )
+                profile["helicity-selector-physical-projection"] = (
+                    time.perf_counter() - companion_projection_started
+                )
+                selector_task.update(
+                    1,
+                    message="physical-color selector input ready",
+                    details={
+                        "process": process_name,
+                        "step": "physical-color selector input ready",
+                        "color_sector_count": len(companion_logical.physical_sectors),
+                    },
+                )
+
+                def report_selector(details: Mapping[str, object]) -> None:
+                    phase_index = int(details.get("phase_index", 0))
+                    phase_total = int(
+                        details.get("phase_total", selector_phase_total - 1)
+                    )
+                    selector_task.update(
+                        1 + phase_index,
+                        total=1 + phase_total,
+                        message=str(
+                            details.get(
+                                "step",
+                                "persisted helicity-selector construction",
+                            )
+                        ),
+                        details={
+                            "process": process_name,
+                            "step": str(
+                                details.get(
+                                    "step",
+                                    "persisted helicity-selector construction",
+                                )
+                            ),
+                            "current_count": int(details.get("current_count", 0)),
+                            "contribution_count": int(
+                                details.get("contribution_count", 0)
+                            ),
+                        },
+                    )
+
+                companion_lowering_started = time.perf_counter()
+                companion_artifact = self._lower_recurrence_helicity_selector_plan(
+                    companion_logical,
+                    prepared.complete_color_plan,
+                    model_inputs,
+                    temporary_root / f"recurrence-helicity-selector-process-{index}",
+                    process_id=process_name,
+                    progress_callback=(
+                        report_selector if selector_task.sink is not None else None
+                    ),
+                )
+                profile["helicity-selector-physical-lowering"] = (
+                    time.perf_counter() - companion_lowering_started
+                )
+                selector_task.update(
+                    selector_task.total or selector_task.completed,
+                    message="persisted helicity-selector plan ready",
+                    details={
+                        "process": process_name,
+                        "step": "persisted helicity-selector plan ready",
+                    },
+                )
+        phase.advance(
+            message=process_name,
+            details={"process": process_name, "step": "recurrence runtime ready"},
+        )
+
+        process_binding_started = time.perf_counter()
+        validation = self._generation_config.validation
+        sample_count = (
+            validation.samples
+            if validation.enabled and validation.post_build_validation
+            else 1
+        )
+        points = tuple(
+            build_process_validation_point(
+                expanded.process_ir,
+                model,
+                process_id=process_name,
+                seed=validation.seed + index * sample_count + sample_index,
+            )
+            for sample_index in range(sample_count)
+        )
+        process_digest = _recurrence_projection_digest(
+            expanded.process_ir.to_json_dict()
+        )
+        resolved_helicities = process_remap.remap_resolved_helicities(
+            output.resolved_helicities
+        )
+        try:
+            amplitude_destinations = tuple(
+                (
+                    process_remap.physical_sector_ids[sector_id],
+                    helicity_id,
+                )
+                for sector_id, helicity_id in output.amplitude_destinations
+            )
+        except IndexError as exc:
+            raise GenerationError(
+                "shared recurrence schedule references a physical sector outside "
+                "the concrete process binding"
+            ) from exc
+        structural_zero_certificate = output.structural_zero_physical_sector_certificate
+        if structural_zero_certificate is None:
+            certified_structural_zero_sector_ids: tuple[int, ...] = ()
+        else:
+            if structural_zero_certificate.sector_count != len(
+                process_remap.physical_sector_ids
+            ):
+                raise GenerationError(
+                    "shared recurrence structural-zero certificate disagrees with "
+                    "its physical-sector remap"
+                )
+            try:
+                certified_structural_zero_sector_ids = tuple(
+                    sorted(
+                        process_remap.physical_sector_ids[sector_id]
+                        for sector_id in structural_zero_certificate.sector_ids
+                    )
+                )
+            except IndexError as exc:
+                raise GenerationError(
+                    "shared recurrence structural-zero certificate lies outside "
+                    "the concrete process binding"
+                ) from exc
+        profile["process-binding-and-validation-points"] = (
+            time.perf_counter() - process_binding_started
+        )
+        physics_started = time.perf_counter()
+        physics = build_recurrence_physics(
+            expanded.process_ir,
+            logical,
+            model_inputs.catalog,
+            process_id=process_name,
+            resolved_helicities=resolved_helicities,
+            normalization=normalization_payload,
+            selected_color_sector_ids=(
+                None
+                if selection.selected_color_sector_ids is None
+                else tuple(sorted(selection.selected_color_sector_ids))
+            ),
+            color_plan=prepared.complete_color_plan,
+        )
+        profile["physics-metadata"] = time.perf_counter() - physics_started
+        run = self._run_config
+        assert run is not None
+        schedule_summary = output.inspection_summary.get("schedule", {})
+        recurrence_summary = {
+            "lc_flow_layout": layout,
+            "builder_input_abi": RECURRENCE_BUILDER_INPUT_ABI,
+            "template_input_abi": RECURRENCE_TEMPLATE_INPUT_ABI,
+            "current_count": (
+                schedule_summary.get("current_count", 0)
+                if isinstance(schedule_summary, Mapping)
+                else 0
+            ),
+            "contribution_count": (
+                schedule_summary.get("contribution_count", 0)
+                if isinstance(schedule_summary, Mapping)
+                else 0
+            ),
+            "closure_term_count": (
+                schedule_summary.get("closure_term_count", 0)
+                if isinstance(schedule_summary, Mapping)
+                else 0
+            ),
+        }
+        inspection_summary = _process_scoped_recurrence_inspection_summary(
+            output.inspection_summary,
+            process_id=process_name,
+            semantic_digest=builder_input.digest,
+            schedule_digest=schedule_digest,
+        )
+        color_contraction_started = time.perf_counter()
+        color_contraction = build_recurrence_color_contraction(
+            logical,
+            prepared.complete_color_plan,
+            resolved_helicities,
+            amplitude_destinations,
+            certified_structural_zero_sector_ids,
+            contraction=run.color.contraction.value,
+        )
+        color_contraction_payload = None
+        color_contraction_summary = None
+        if color_contraction is not None:
+            sector_count = len(logical.physical_sectors)
+            component_count = len(resolved_helicities)
+            group_count = color_contraction.group_count
+            schedule_destination_count = int(
+                schedule_summary.get("amplitude_destination_count", 0)
+                if isinstance(schedule_summary, Mapping)
+                else 0
+            )
+            if schedule_destination_count != len(amplitude_destinations):
+                raise GenerationError(
+                    "contracted recurrence destination metadata does not match "
+                    "its Direct schedule"
+                )
+            contraction_destinations = recurrence_color_contraction_destinations(
+                logical,
+                resolved_helicities,
+                amplitude_destinations,
+            )
+            destination_count = len(contraction_destinations)
+            if destination_count < group_count:
+                raise GenerationError(
+                    "contracted recurrence physical replay domain is smaller "
+                    "than its color-contraction group domain"
+                )
+            if any(helicity_id is None for _, helicity_id in amplitude_destinations):
+                raise GenerationError(
+                    "contracted recurrence exposes a destination without a "
+                    "resolved helicity"
+                )
+            destination_by_group = (
+                tuple(range(group_count))
+                if color_contraction.destination_by_group is None
+                else color_contraction.destination_by_group
+            )
+            if (
+                len(destination_by_group) != group_count
+                or len(set(destination_by_group)) != group_count
+                or any(
+                    destination_id < 0 or destination_id >= destination_count
+                    for destination_id in destination_by_group
+                )
+            ):
+                raise GenerationError(
+                    "contracted recurrence color plan has an invalid destination "
+                    "projection"
+                )
+            normalized_destinations = tuple(
+                contraction_destinations[destination_id]
+                for destination_id in destination_by_group
+            )
+            group_sector_ids = tuple(
+                sector_id for sector_id, _ in normalized_destinations
+            )
+            group_component_ids = tuple(
+                cast(int, helicity_id) for _, helicity_id in normalized_destinations
+            )
+            repeated = color_contraction.repeated_block
+            symmetric_group = color_contraction.symmetric_group_block
+            ordered_group_ids = (
+                repeated.component_group_ids
+                if repeated is not None
+                else symmetric_group.component_group_ids
+                if symmetric_group is not None
+                else tuple(range(group_count))
+            )
+            color_contraction_payload = encode_recurrence_color_contraction(
+                color_contraction,
+                sector_count=sector_count,
+                component_count=component_count,
+                ordered_group_ids=ordered_group_ids,
+                destination_by_group=destination_by_group,
+                destination_count=destination_count,
+                group_sector_ids=group_sector_ids,
+                group_component_ids=group_component_ids,
+                sector_owner_ids=recurrence_color_sector_owner_map(
+                    logical,
+                    set(group_sector_ids),
+                    set(certified_structural_zero_sector_ids),
+                ),
+                exact_coefficients=recurrence_exact_color_coefficients(
+                    prepared.complete_color_plan,
+                    color_contraction,
+                    group_sector_ids,
+                ),
+            )
+            color_digest = recurrence_color_contraction_digest(
+                color_contraction_payload
+            )
+            color_contraction_summary = {
+                "abi": RECURRENCE_COLOR_CONTRACTION_CODEC_ABI,
+                "color_accuracy": color_contraction.color_accuracy,
+                "storage": (
+                    "convolution-kernels"
+                    if symmetric_group is not None
+                    else "expanded"
+                    if repeated is None
+                    else "repeated"
+                ),
+                "includes_color_factor": color_contraction.includes_color_factor,
+                "group_count": group_count,
+                "sector_count": sector_count,
+                "active_sector_count": len(set(group_sector_ids)),
+                "component_count": component_count,
+                "destination_count": destination_count,
+                "materialized_destination_count": schedule_destination_count,
+                "entry_count": (
+                    symmetric_group.stored_entry_count
+                    if symmetric_group is not None
+                    else len(color_contraction.entries)
+                    if repeated is None
+                    else len(repeated.entries)
+                ),
+                "logical_entry_count": color_contraction.logical_entry_count,
+                "semantic_digest": color_digest,
+                "factorization": (
+                    {
+                        "kind": "symmetric-group-fourier",
+                        "rank": symmetric_group.degree,
+                        "coset_count": symmetric_group.channel_count,
+                    }
+                    if symmetric_group is not None
+                    else None
+                    if repeated is None or repeated.factorized_block is None
+                    else {
+                        "kind": repeated.factorized_block.kind,
+                        "rank": (
+                            2
+                            if repeated.factorized_block.kind == "klein-four-walsh"
+                            else repeated.factorized_block.rank
+                        ),
+                        "coset_count": len(repeated.factorized_block.cosets),
+                    }
+                ),
+                **(
+                    {}
+                    if symmetric_group is None
+                    else {
+                        "fft_provenance": {
+                            "method": "symmetric-group-fourier",
+                            "degree": symmetric_group.degree,
+                            "channel_count": symmetric_group.channel_count,
+                            "covered_local_group_count": (
+                                symmetric_group.channel_count
+                                * math.factorial(symmetric_group.degree)
+                            ),
+                            "residual_group_count": len(
+                                symmetric_group.residual_local_group_indices
+                            ),
+                            "residual_entry_count": len(
+                                symmetric_group.residual_entries
+                            ),
+                            "raw_kernel_bytes": (
+                                len(symmetric_group.kernel_entries) * 16
+                            ),
+                            "transformed_kernel_bytes": (
+                                len(symmetric_group.kernel_entries) * 8
+                            ),
+                            "capability": (
+                                SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY
+                            ),
+                        }
+                    }
+                ),
+            }
+        profile["color-contraction"] = time.perf_counter() - color_contraction_started
+        relation_discovery_payload: dict[str, object]
+        numerical_current_reuse = output.numerical_current_reuse_report
+        if not isinstance(numerical_current_reuse, Mapping):
+            raise GenerationError(
+                "recurrence numerical current lowering did not publish its "
+                "aggregate report"
+            )
+        relation_discovery_payload = dict(numerical_current_reuse)
+        artifact_record_started = time.perf_counter()
+        required_direct_executor_ids = _required_process_direct_executor_ids(
+            output.exact_sections,
+            process_remap,
+        )
+        process_executor_pack = build_recurrence_process_executor_pack(
+            direct_catalog=model_inputs.direct_template_catalog,
+            kernel_pack=model_inputs.bundle.kernel_pack,
+            required_executor_ids=required_direct_executor_ids,
+            runtime_layout_digest=str(inspection_summary["runtime_layout_digest"]),
+        )
+        umami_keys = None
+        umami_physics = None
+        umami_sectors = ()
+        if run.generation.emit_api_bundle:
+            umami_sectors = tuple(
+                sector.to_json_dict() for sector in prepared.complete_color_plan.sectors
+            )
+            umami_physics = dict(physics)
+            from .umami_semantics import recurrence_structural_keys
+
+            umami_keys = recurrence_structural_keys(
+                exact_sections=output.exact_sections,
+                runtime_metadata=runtime_metadata,
+                kernel_pack=model_inputs.bundle.kernel_pack,
+                ir=model_inputs.bundle.compiled_model["ir"],
+                physics=physics,
+                remap=process_remap,
+                color_contraction_payload=color_contraction_payload,
+            )
+            replay = (
+                prepared.topology_replay
+                if isinstance(prepared.topology_replay, LCColorTopologyReplayPlan)
+                else build_lc_topology_replay_plan(prepared.complete_color_plan, model)
+            )
+            if replay is not None:
+                umami_physics["extensions"] = {
+                    **cast(Mapping[str, object], physics.get("extensions", {})),
+                    "lc_topology_replay": replay.to_json_dict(),
+                }
+        artifact = RecurrenceProcessArtifact(
+            process_id=process_name,
+            expression=expanded.process_ir.process,
+            color_accuracy=expanded.process_ir.color_accuracy,
+            external_pdgs=(
+                *expanded.process_ir.initial_pdgs,
+                *expanded.process_ir.final_pdgs,
+            ),
+            aliases=expanded.aliases,
+            physics=physics,
+            umami_physics=umami_physics,
+            umami_color_sectors=umami_sectors,
+            umami_structural_keys=umami_keys,
+            recurrence_schedule_path=output.payload_path,
+            recurrence_schedule_digest=schedule_digest,
+            recurrence_native_schedule_semantic_digest=(
+                native_schedule_semantic_digest
+            ),
+            recurrence_schedule_size_bytes=output.payload_size_bytes,
+            recurrence_schedule_sha256=output.payload_sha256,
+            recurrence_schedule_member_count=output.member_count,
+            recurrence_schedule_unpacked_size_bytes=output.unpacked_size_bytes,
+            recurrence_schedule_index_sha256=output.index_sha256,
+            builder_input_sha256=builder_input.digest,
+            prepared_kernel_pack_digest=model_inputs.prepared_kernel_pack_digest,
+            direct_template_catalog_digest=(
+                model_inputs.direct_template_catalog.catalog_digest
+            ),
+            referenced_kernel_ids=(
+                recurrence_referenced_kernel_ids(logical)
+                if companion_artifact is None
+                else frozenset(
+                    kernel.kernel_id
+                    for kernel in model_inputs.bundle.kernel_pack.kernels
+                )
+            ),
+            inspection_summary=inspection_summary,
+            runtime_metadata=runtime_metadata,
+            color_contraction_payload=color_contraction_payload,
+            color_contraction_summary=color_contraction_summary,
+            point_tile_size=run.evaluator.recurrence.point_tile_size,
+            workspace_mib=run.evaluator.recurrence.workspace_mib,
+            recurrence_summary=recurrence_summary,
+            validation_point=points[0],
+            generation_filters={
+                **self._fft_basis_metadata(prepared.complete_color_plan),
+                "lc_flow_layout": layout,
+                "recurrence": recurrence_summary,
+                "relation_discovery": relation_discovery_payload,
+            },
+            generation_profile=output.generation_profile,
+            process_support_mask=1 << index,
+            recurrence_process_remap=process_remap,
+            recurrence_process_executor_pack=process_executor_pack,
+            helicity_selector_companion=companion_artifact,
+            process_digest=process_digest,
+        )
+        profile["artifact-record-assembly"] = (
+            time.perf_counter() - artifact_record_started
+        )
+        profile["process-total"] = time.perf_counter() - profile_started
+        if generation_timings is not None:
+            timing_prefix = f"recurrence-process-{index}:{process_name}:"
+            with _RECURRENCE_PROFILE_LOCK:
+                generation_timings.update(
+                    {
+                        f"{timing_prefix}{name}": seconds
+                        for name, seconds in profile.items()
+                    }
+                )
+        _LOGGER.debug(
+            "recurrence generation profile for %s: %s",
+            process_name,
+            json.dumps(profile, allow_nan=False, sort_keys=True),
+        )
+        return _GeneratedRecurrenceProcess(
+            expanded=expanded,
+            artifact=artifact,
+            validation_points=points,
+        )
+
+    def _construct_evaluator(
+        self,
+        process: _CompiledProcess,
+        model: Model,
+        phase: PhaseHandle,
+    ) -> _EvaluatorProcess:
+        process_name = process.expanded.request.name
+        run = self._run_config
+        compiled_symmetric_group = (
+            run is not None and run.color.contraction.value == "symmetric-group-fft"
+        )
+        with phase.child(
+            process_name,
+            f"{process_name}: runtime schema",
+            details={"process": process_name, "step": "runtime layout"},
+        ) as task:
+            color_contraction_payload = None
+            if compiled_symmetric_group:
+                _validate_compiled_symmetric_group_diagnostic_process(process)
+                schema_layout = build_runtime_schema_layout(
+                    process.dag,
+                    model,
+                    process_id=process_name,
+                    color_contraction="symmetric-group-fft",
+                )
+                schema = RuntimeExpressionSchema.from_mapping(
+                    schema_layout.runtime_schema
+                )
+                color_contraction_payload = (
+                    _compiled_symmetric_group_color_contraction_payload(
+                        process.dag,
+                        schema_layout,
+                    )
+                )
+            else:
+                schema = build_runtime_expression_schema(
+                    process.dag,
+                    model,
+                    process_id=process_name,
+                )
+            helicity_sum_schema = (
+                None
+                if process.helicity_sum_dag is None
+                else build_runtime_expression_schema(
+                    process.helicity_sum_dag,
+                    model,
+                    process_id=process_name,
+                )
+            )
+            helicity_selector_lanes: tuple[_HelicitySelectorLane, ...] = ()
+            if (
+                process.dag.helicity_coverage == "complete"
+                and not process.dag.selected_source_helicities
+                and process.dag.helicity_recurrence is not None
+                and process.dag.helicity_materialization is not None
+            ):
+                union_dag = process.helicity_selector_union_dag
+                if union_dag is not None:
+                    union_schema = build_runtime_expression_schema(
+                        union_dag,
+                        model,
+                        process_id=process_name,
+                    )
+                    materialization = process.dag.helicity_materialization
+                    assert materialization is not None
+                    helicity_selector_lanes = (
+                        _HelicitySelectorLane(
+                            selector_domain_ids=tuple(
+                                sorted(
+                                    schedule.selector_domain_id
+                                    for schedule in materialization.selector_schedules
+                                    if not schedule.structural_zero
+                                )
+                            ),
+                            active_current_ids=(),
+                            active_root_ids=(),
+                            dag=union_dag,
+                            runtime_schema=union_schema,
+                            stage_input=StageCompilationInput(
+                                union_dag,
+                                model,
+                                union_schema,
+                            ),
+                            schedule_mode="nested-runtime",
+                            child_lanes=(),
+                        ),
+                    )
+                elif process.dag.process.color_accuracy == "lc":
+                    helicity_selector_lanes = _compiled_helicity_selector_closure_lanes(
+                        process.dag,
+                        schema,
+                        model,
+                    )
+            color_selector_dag = (
+                process.dag
+                if process.helicity_sum_dag is None
+                else process.helicity_sum_dag
+            )
+            color_selector_lanes: list[_ColorSelectorLane] = []
+            sector_lanes = (
+                ()
+                if self._all_flow_union_enabled
+                else _compiled_lc_color_selector_lane_dags(color_selector_dag)
+            )
+            for sector_id, lane_dag in sector_lanes:
+                lane_schema = build_runtime_expression_schema(
+                    lane_dag,
+                    model,
+                    process_id=process_name,
+                )
+                color_selector_lanes.append(
+                    _ColorSelectorLane(
+                        materialized_sector_id=sector_id,
+                        dag=lane_dag,
+                        runtime_schema=lane_schema,
+                        stage_input=StageCompilationInput(
+                            lane_dag,
+                            model,
+                            lane_schema,
+                        ),
+                    )
+                )
+            stage_count = _runtime_stage_count(schema) + (
+                0
+                if helicity_sum_schema is None
+                else _runtime_stage_count(helicity_sum_schema)
+            )
+            stage_count += sum(
+                _helicity_selector_lane_stage_count(lane)
+                for lane in helicity_selector_lanes
+            )
+            stage_count += sum(
+                _runtime_stage_count(lane.runtime_schema)
+                for lane in color_selector_lanes
+            )
+            task.update(
+                stage_count,
+                total=stage_count,
+                message="runtime schema ready",
+                details={
+                    "process": process_name,
+                    "step": "runtime schema ready",
+                    "stage_index": stage_count,
+                    "stage_total": stage_count,
+                    "current_count": len(process.dag.currents),
+                    "interaction_count": len(process.dag.interactions),
+                    "output_count": len(process.dag.amplitude_roots),
+                    "helicity_sum_lane": helicity_sum_schema is not None,
+                    "helicity_selector_closure_lane_count": len(
+                        helicity_selector_lanes
+                    ),
+                    "color_selector_lane_count": len(color_selector_lanes),
+                },
+            )
+        phase.advance(
+            message=process_name,
+            details={"process": process_name, "step": "runtime schema ready"},
+        )
+        return _EvaluatorProcess(
+            compiled=process,
+            runtime_schema=schema,
+            stage_input=StageCompilationInput(process.dag, model, schema),
+            color_contraction_payload=color_contraction_payload,
+            helicity_sum_runtime_schema=helicity_sum_schema,
+            helicity_sum_stage_input=(
+                None
+                if helicity_sum_schema is None or process.helicity_sum_dag is None
+                else StageCompilationInput(
+                    process.helicity_sum_dag,
+                    model,
+                    helicity_sum_schema,
+                )
+            ),
+            helicity_selector_lanes=helicity_selector_lanes,
+            color_selector_lanes=tuple(color_selector_lanes),
+        )
+
+    def _construct_eager_artifact(
+        self,
+        process: _CompiledProcess,
+        model: Model,
+        resolved_model: _ResolvedModel,
+        temporary_root: Path,
+        phase: PhaseHandle,
+    ) -> EagerPlanV3ProcessArtifact:
+        eager_kernel_index = resolved_model.eager_kernel_index
+        if eager_kernel_index is None:
+            raise GenerationError(
+                "eager DAG lowering requires an indexed prepared model bundle"
+            )
+        resolver = PreparedCatalogEagerKernelResolver(
+            process.dag,
+            eager_kernel_index,
+        )
+        return self._construct_eager_plan_v3_artifact(
+            process,
+            model,
+            resolver,
+            temporary_root,
+            phase,
+        )
+
+    def _construct_eager_plan_v3_artifact(
+        self,
+        process: _CompiledProcess,
+        model: Model,
+        resolver: PreparedCatalogEagerKernelResolver,
+        temporary_root: Path,
+        phase: PhaseHandle,
+    ) -> EagerPlanV3ProcessArtifact:
+        process_name = process.expanded.request.name
+        with phase.child(
+            process_name,
+            f"{process_name}: Rust eager runtime lowering",
+            total=2,
+            details={"process": process_name, "step": "columnar lowering input"},
+        ) as task:
+            lowering_input = build_eager_lowering_input_v1(
+                dag=process.dag,
+                model=model,
+                resolver=resolver,
+                process_id=process_name,
+            )
+            task.update(
+                1,
+                message="columnar lowering input ready",
+                details={
+                    "process": process_name,
+                    "step": "columnar lowering input ready",
+                },
+            )
+            output = _invoke_rust_eager_lowering_v1(
+                lowering_input,
+                temporary_root
+                / "eager-plan-v3"
+                / process_name
+                / "eager-runtime.pacbin",
+            )
+            task.update(
+                2,
+                message="Rust eager runtime ready",
+                details={"process": process_name, "step": "eager runtime ready"},
+            )
+        phase.advance(
+            message=process_name,
+            details={"process": process_name, "step": "eager runtime ready"},
+        )
+        run = self._run_config
+        if run is None:  # pragma: no cover - eager mode requires RunConfig
+            raise GenerationError("eager generation has no evaluator configuration")
+        ir = process.expanded.process_ir
+        dag = process.dag
+        physics = build_resolved_physics_from_dag(
+            dag,
+            model,
+            process_id=process_name,
+            native_eager_plan_v3_reduction_groups=True,
+            runtime_model_parameters=(
+                runtime_model_parameter_records_from_eager_input(lowering_input)
+            ),
+        )
+        return EagerPlanV3ProcessArtifact(
+            process_id=process_name,
+            expression=ir.process,
+            color_accuracy=ir.color_accuracy,
+            external_pdgs=(*ir.initial_pdgs, *ir.final_pdgs),
+            aliases=process.expanded.aliases,
+            physics=physics,
+            umami_color_sectors=tuple(
+                sector.to_json_dict() for sector in dag.color_plan.sectors
+            )
+            if run.generation.emit_api_bundle
+            else (),
+            eager_runtime_path=output.payload_path,
+            eager_runtime_size_bytes=output.payload_size_bytes,
+            eager_runtime_sha256=output.payload_sha256,
+            eager_runtime_member_count=output.member_count,
+            eager_runtime_unpacked_size_bytes=output.unpacked_size_bytes,
+            eager_runtime_index_sha256=output.index_sha256,
+            lowering_input_sha256=lowering_input.digest,
+            referenced_kernel_ids=_eager_lowering_kernel_ids(lowering_input),
+            inspection_summary=output.inspection_summary,
+            point_tile_size=run.evaluator.eager.point_tile_size,
+            workspace_mib=run.evaluator.eager.workspace_mib,
+            dag_summary={
+                "current_count": len(dag.currents),
+                "source_count": len(dag.sources),
+                "interaction_count": len(dag.interactions),
+                "interaction_evaluation_count": dag.interaction_evaluation_count,
+                "amplitude_root_count": len(dag.amplitude_roots),
+                "truncated": False,
+            },
+            validation_point=process.validation_points[0],
+            generation_filters=process.filters,
+        )
+
+    def _materialize_evaluator(
+        self,
+        process: _EvaluatorProcess,
+        model: Model,
+        temporary_root: Path,
+        phase: PhaseHandle,
+    ) -> CompiledProcessArtifact:
+        process_id = process.compiled.expanded.request.name
+        run = self._run_config
+        backend = "JIT" if run is None else str(run.evaluator.backend).upper()
+        with phase.child(
+            process_id,
+            f"{process_id}: evaluator compilation",
+            details={
+                "process": process_id,
+                "step": "waiting for compiler",
+                "backend": backend,
+            },
+        ) as task:
+            task.update(
+                0,
+                message="waiting for compiler",
+                details={
+                    "process": process_id,
+                    "step": "waiting for compiler",
+                    "backend": backend,
+                },
+            )
+            with _SYMBOLICA_MATERIALIZATION_LOCK:
+                return self._materialize_evaluator_unlocked(
+                    process,
+                    model,
+                    temporary_root,
+                    phase,
+                    task,
+                    backend=backend,
+                )
+
+    def _materialize_evaluator_unlocked(
+        self,
+        process: _EvaluatorProcess,
+        model: Model,
+        temporary_root: Path,
+        phase: PhaseHandle,
+        progress: PhaseHandle,
+        *,
+        backend: str,
+    ) -> CompiledProcessArtifact:
+        process_id = process.compiled.expanded.request.name
+        evaluator_root = temporary_root / process_id
+        total_stage_count = _runtime_stage_count(process.runtime_schema) + 1
+        if process.helicity_sum_runtime_schema is not None:
+            total_stage_count += (
+                _runtime_stage_count(process.helicity_sum_runtime_schema) + 1
+            )
+        total_stage_count += sum(
+            _helicity_selector_lane_compile_task_count(lane)
+            for lane in process.helicity_selector_lanes
+        )
+        total_stage_count += sum(
+            _runtime_stage_count(lane.runtime_schema) + 1
+            for lane in process.color_selector_lanes
+        )
+
+        def evaluator_progress(
+            event: dict[str, object],
+            *,
+            execution_lane: str,
+        ) -> None:
+            details = {
+                str(key): value
+                for key, value in event.items()
+                if isinstance(value, (str, int, float, bool, type(None)))
+            }
+            details.update(
+                {
+                    "process": process_id,
+                    "backend": backend,
+                    "execution_lane": execution_lane,
+                    "lane_stage_total": event.get("total"),
+                }
+            )
+            if event.get("stage") == "stage complete":
+                completed = progress.completed + int(event.get("increment", 1))
+                progress.update(
+                    completed,
+                    total=total_stage_count,
+                    message=str(event.get("item", "stage complete")),
+                    details=details,
+                )
+                phase.advance(
+                    message=str(event.get("item", process_id)),
+                    details=details,
+                )
+                return
+            progress.update(
+                progress.completed,
+                total=total_stage_count,
+                message=str(event.get("item", event.get("stage", "compiling"))),
+                details=details,
+            )
+
+        def compile_lane(
+            stage_input: StageCompilationInput,
+            runtime_schema: RuntimeExpressionSchema,
+            output_root: Path,
+            *,
+            execution_lane: str,
+        ) -> tuple[Mapping[str, object], Mapping[str, object] | None]:
+            callback = (
+                None
+                if progress.sink is None
+                else lambda event: evaluator_progress(
+                    event,
+                    execution_lane=execution_lane,
+                )
+            )
+            _blueprint, stage_manifest = (
+                build_and_write_generic_stage_evaluator_artifacts(
+                    stage_input,
+                    runtime_schema.to_mapping(),
+                    output_root,
+                    model=model,
+                    stage_local_parameter_layout=True,
+                    symbolica_settings=self._symbolica_settings(),
+                    jit_compile=True,
+                    evaluator_progress_callback=callback,
+                )
+            )
+            if not bool(stage_manifest.get("runtime_available")):
+                raise GenerationError(
+                    f"{execution_lane} stage evaluator for {process_id!r} "
+                    "is not runtime-available"
+                )
+            model_parameter_evaluator = write_model_parameter_evaluator_artifact(
+                model,
+                runtime_schema.to_mapping(),
+                output_root,
+                symbolica_settings=self._symbolica_settings(),
+                jit_compile=True,
+                progress_callback=callback,
+            )
+            return stage_manifest, model_parameter_evaluator
+
+        stage_manifest, model_parameter_evaluator = compile_lane(
+            process.stage_input,
+            process.runtime_schema,
+            evaluator_root,
+            execution_lane="selected-helicity",
+        )
+        helicity_sum_execution: CompiledExecutionArtifact | None = None
+        if (
+            process.helicity_sum_runtime_schema is not None
+            or process.helicity_sum_stage_input is not None
+        ):
+            if (
+                process.helicity_sum_runtime_schema is None
+                or process.helicity_sum_stage_input is None
+                or process.compiled.helicity_sum_dag is None
+            ):
+                raise GenerationError(
+                    f"helicity-sum execution inputs for {process_id!r} are inconsistent"
+                )
+            helicity_sum_root = temporary_root / ".helicity-sum" / process_id
+            (
+                helicity_sum_stage_manifest,
+                helicity_sum_model_parameter_evaluator,
+            ) = compile_lane(
+                process.helicity_sum_stage_input,
+                process.helicity_sum_runtime_schema,
+                helicity_sum_root,
+                execution_lane="helicity-sum",
+            )
+            helicity_sum_dag = process.compiled.helicity_sum_dag
+            helicity_sum_execution = CompiledExecutionArtifact(
+                runtime_schema=process.helicity_sum_runtime_schema,
+                stage_manifest=helicity_sum_stage_manifest,
+                model_parameter_evaluator=(helicity_sum_model_parameter_evaluator),
+                dag_summary={
+                    "current_count": len(helicity_sum_dag.currents),
+                    "source_count": len(helicity_sum_dag.sources),
+                    "interaction_count": len(helicity_sum_dag.interactions),
+                    "interaction_evaluation_count": (
+                        helicity_sum_dag.interaction_evaluation_count
+                    ),
+                    "amplitude_root_count": len(helicity_sum_dag.amplitude_roots),
+                    "truncated": False,
+                },
+                evaluator_root=helicity_sum_root,
+            )
+        helicity_selector_executions: list[
+            CompiledHelicitySelectorExecutionArtifact
+        ] = []
+
+        def compile_helicity_selector_lane(
+            lane: _HelicitySelectorLane,
+            lane_root: Path,
+            *,
+            execution_lane: str,
+        ) -> CompiledHelicitySelectorExecutionArtifact:
+            lane_stage_manifest, lane_model_parameter_evaluator = compile_lane(
+                lane.stage_input,
+                lane.runtime_schema,
+                lane_root,
+                execution_lane=execution_lane,
+            )
+            child_executions = tuple(
+                compile_helicity_selector_lane(
+                    child,
+                    lane_root.parent / f"{lane_root.name}-closure-{child_index}",
+                    execution_lane=(f"{execution_lane}-closure-{child_index}"),
+                )
+                for child_index, child in enumerate(lane.child_lanes)
+            )
+            return CompiledHelicitySelectorExecutionArtifact(
+                selector_domain_ids=lane.selector_domain_ids,
+                schedule_mode=lane.schedule_mode,
+                execution=CompiledExecutionArtifact(
+                    runtime_schema=lane.runtime_schema,
+                    stage_manifest=lane_stage_manifest,
+                    model_parameter_evaluator=(lane_model_parameter_evaluator),
+                    # Closure lanes retain their parent's stable current and
+                    # amplitude storage ABI while filtering stage interactions.
+                    dag_summary=_runtime_schema_dag_summary(lane.runtime_schema),
+                    evaluator_root=lane_root,
+                    helicity_selector_executions=child_executions,
+                ),
+            )
+
+        for lane_index, lane in enumerate(process.helicity_selector_lanes):
+            helicity_selector_root = (
+                temporary_root
+                / ".helicity-selector-union"
+                / process_id
+                / f"class-{lane_index}"
+            )
+            helicity_selector_executions.append(
+                compile_helicity_selector_lane(
+                    lane,
+                    helicity_selector_root,
+                    execution_lane=f"helicity-selector-class-{lane_index}",
+                )
+            )
+        color_selector_executions: list[CompiledColorSelectorExecutionArtifact] = []
+        selector_root_name = (
+            ".helicity-sum-color-selector"
+            if helicity_sum_execution is not None
+            else ".color-selector"
+        )
+        for lane in process.color_selector_lanes:
+            lane_root = (
+                temporary_root
+                / selector_root_name
+                / process_id
+                / f"sector-{lane.materialized_sector_id}"
+            )
+            lane_stage_manifest, lane_model_parameter_evaluator = compile_lane(
+                lane.stage_input,
+                lane.runtime_schema,
+                lane_root,
+                execution_lane=(f"color-selector sector-{lane.materialized_sector_id}"),
+            )
+            color_selector_executions.append(
+                CompiledColorSelectorExecutionArtifact(
+                    materialized_sector_id=lane.materialized_sector_id,
+                    execution=CompiledExecutionArtifact(
+                        runtime_schema=lane.runtime_schema,
+                        stage_manifest=lane_stage_manifest,
+                        model_parameter_evaluator=(lane_model_parameter_evaluator),
+                        dag_summary={
+                            "current_count": len(lane.dag.currents),
+                            "source_count": len(lane.dag.sources),
+                            "interaction_count": len(lane.dag.interactions),
+                            "interaction_evaluation_count": (
+                                lane.dag.interaction_evaluation_count
+                            ),
+                            "amplitude_root_count": len(lane.dag.amplitude_roots),
+                            "truncated": False,
+                        },
+                        evaluator_root=lane_root,
+                    ),
+                )
+            )
+        primary_color_selector_executions: tuple[
+            CompiledColorSelectorExecutionArtifact, ...
+        ] = tuple(color_selector_executions)
+        if helicity_sum_execution is not None:
+            helicity_sum_execution = replace(
+                helicity_sum_execution,
+                color_selector_executions=tuple(color_selector_executions),
+            )
+            primary_color_selector_executions = ()
+        progress.update(
+            progress.completed,
+            message="model parameters ready",
+            details={
+                "process": process_id,
+                "step": "model parameters ready",
+                "backend": backend,
+            },
+        )
+        phase.advance(
+            message=f"{process_id}: model parameters",
+            details={
+                "process": process_id,
+                "step": "model parameters ready",
+                "backend": backend,
+            },
+        )
+        ir = process.compiled.expanded.process_ir
+        dag = process.compiled.dag
+        return CompiledProcessArtifact(
+            process_id=process_id,
+            expression=ir.process,
+            color_accuracy=ir.color_accuracy,
+            external_pdgs=(*ir.initial_pdgs, *ir.final_pdgs),
+            aliases=process.compiled.expanded.aliases,
+            runtime_schema=process.runtime_schema,
+            umami_color_sectors=tuple(
+                sector.to_json_dict() for sector in dag.color_plan.sectors
+            )
+            if self._generation_config.emit_api_bundle
+            else (),
+            stage_manifest=stage_manifest,
+            model_parameter_evaluator=model_parameter_evaluator,
+            dag_summary={
+                "current_count": len(dag.currents),
+                "source_count": len(dag.sources),
+                "interaction_count": len(dag.interactions),
+                "interaction_evaluation_count": dag.interaction_evaluation_count,
+                "amplitude_root_count": len(dag.amplitude_roots),
+                "truncated": False,
+            },
+            evaluator_root=evaluator_root,
+            color_contraction_payload=process.color_contraction_payload,
+            validation_point=process.compiled.validation_points[0],
+            generation_filters=process.compiled.filters,
+            helicity_sum_execution=helicity_sum_execution,
+            helicity_selector_executions=tuple(helicity_selector_executions),
+            color_selector_executions=primary_color_selector_executions,
+        )
+
+    def _process_worker_count(self, process_count: int) -> int:
+        if process_count < 1:
+            return 1
+        configured = self._generation_config.workers
+        requested = (
+            max(1, os.cpu_count() or 1)
+            if configured == "auto"
+            else max(1, int(configured))
+        )
+        return min(process_count, requested)
+
+    def _detect_symbolica_license(self) -> SymbolicaLicenseState:
+        from ..licensing import detect_symbolica_license
+
+        run = self._run_config
+        return detect_symbolica_license(
+            suggest=True if run is None else run.symbolica.suggest_license,
+            json_mode=False if run is None else str(run.output.format) == "json",
+        )
+
+    def _apply_symbolica_resource_policy(
+        self,
+        state: SymbolicaLicenseState,
+        *,
+        process_count: int | None = None,
+    ) -> None:
+        from ..licensing import resolve_symbolica_resource_config
+
+        resolution = resolve_symbolica_resource_config(
+            self._resource_config,
+            state,
+            process_count=process_count,
+        )
+        self._resource_config = resolution
+        self._configuration = _GenerationConfigProvenance.from_config(resolution)
+        self._config = resolution.effective
+
+    def _symbolica_settings(self) -> object:
+        from ..evaluators.symbolica import SymbolicaEvaluatorSettings
+
+        run = self._run_config
+        if run is None:
+            return SymbolicaEvaluatorSettings(jit_compress=True)
+        optimization = run.evaluator.optimization
+        if optimization.horner_iterations < 1:
+            raise GenerationError(
+                "evaluator.optimization.horner_iterations must be positive "
+                "for generation"
+            )
+        backend = str(run.evaluator.backend)
+        evaluator_backend = "jit" if backend == "jit" else "compiled-complex"
+        cores = (
+            max(1, os.cpu_count() or 1)
+            if optimization.cores == "auto"
+            else int(optimization.cores)
+        )
+        collect_factors = (
+            False
+            if optimization.collect_factors == "auto"
+            else bool(optimization.collect_factors)
+        )
+        cpp_level = _cpp_optimization_level(run.evaluator.cpp.optimization)
+        return SymbolicaEvaluatorSettings(
+            backend=evaluator_backend,
+            iterations=optimization.horner_iterations,
+            cpe_iterations=optimization.cpe_iterations,
+            n_cores=cores,
+            jit_direct_translation=False,
+            jit_optimization_level=run.evaluator.jit.optimization_level,
+            jit_compress=run.evaluator.resolved_jit_compress,
+            max_horner_scheme_variables=optimization.max_horner_variables,
+            max_common_pair_cache_entries=(optimization.max_common_pair_cache_entries),
+            max_common_pair_distance=optimization.max_common_pair_distance,
+            collect_factors=collect_factors,
+            compiled_inline_asm="default" if backend == "asm" else "none",
+            compiled_optimization_level=cpp_level,
+            compiled_native=run.evaluator.cpp.native_arch,
+            compiler_path=run.evaluator.cpp.compiler,
+            compiler_flags=run.evaluator.cpp.extra_flags,
+            compiled_output_chunk_size=run.evaluator.output_chunk_size,
+            output_chunk_strategy="uniform",
+            output_chunk_autotune_batch_size=run.evaluator.batch_size,
+            compiled_chunk_compile_workers=1,
+        )
+
+    def _validate_generated_artifact(
+        self,
+        output: Path,
+        process_ids: Sequence[str],
+        *,
+        validation_points: Mapping[str, Sequence[ValidationPointRecord]],
+        expected_api_bundle_path: str | None,
+        compact_validation_selectors: Mapping[str, Mapping[str, tuple[str, ...]]]
+        | None = None,
+        progress: PhaseHandle | None = None,
+    ) -> None:
+        import cmath
+
+        from pyamplicol.api import Runtime
+        from pyamplicol.artifacts import load_manifest
+
+        manifest = load_manifest(output)
+        expected_ids = set(process_ids)
+        actual_ids = {str(process["id"]) for process in manifest.processes}
+        if not expected_ids.issubset(actual_ids):
+            raise GenerationError("generated artifact omitted concrete processes")
+        by_path = {record.path: record for record in manifest.payloads}
+        process_record_by_id = {
+            str(process["id"]): process for process in manifest.processes
+        }
+        process_total = len(process_ids)
+        for process_index, process_id in enumerate(process_ids, start=1):
+            if progress is not None:
+                progress.update(
+                    process_index - 1,
+                    total=process_total,
+                    message=f"loading {process_id}",
+                    details={
+                        "process": process_id,
+                        "step": "runtime validation",
+                        "sample_index": 0,
+                    },
+                )
+            prefix = f"processes/{process_id}"
+            required = {
+                f"{prefix}/physics.json",
+                f"{prefix}/execution.json",
+                f"{prefix}/validation-momenta.json",
+            }
+            if self._on_the_fly_execution_enabled:
+                required.add(f"{prefix}/on-the-fly-runtime.pacbin")
+                if process_record_by_id[process_id].get("color_accuracy") in {
+                    "nlc",
+                    "full",
+                }:
+                    required.add(f"{prefix}/on-the-fly-color.bin")
+            if not required.issubset(by_path):
+                raise GenerationError(
+                    f"artifact payload set is incomplete for {process_id!r}"
+                )
+            runtime = Runtime.load(output, process=process_id)
+            validation = self._generation_config.validation
+            samples = tuple(
+                point.four_vectors
+                for point in validation_points.get(process_id, ())
+                if point.available
+            )
+            if self._on_the_fly_execution_enabled:
+                if runtime.artifact_id != manifest.artifact_id:
+                    raise GenerationError(
+                        "Rusticol loaded the wrong artifact while validating "
+                        f"{process_id!r}"
+                    )
+                if runtime.execution_mode != "on-the-fly":
+                    raise GenerationError(
+                        f"Rusticol selected the wrong execution mode for {process_id!r}"
+                    )
+                if runtime.representative_process_key != process_id:
+                    raise GenerationError(
+                        f"Rusticol selected the wrong process for {process_id!r}"
+                    )
+                validated_samples = 0
+                if validation.enabled and samples:
+                    raw_selectors = (
+                        None
+                        if compact_validation_selectors is None
+                        else compact_validation_selectors.get(process_id)
+                    )
+                    if not isinstance(raw_selectors, Mapping) or set(raw_selectors) != {
+                        "helicities",
+                        "color_flows",
+                    }:
+                        raise GenerationError(
+                            "on-the-fly validation has no authenticated compact "
+                            f"selector for {process_id!r}"
+                        )
+                    helicities = raw_selectors.get("helicities")
+                    color_flows = raw_selectors.get("color_flows")
+                    contracted_color = process_record_by_id[process_id].get(
+                        "color_accuracy"
+                    ) in {"nlc", "full"}
+                    if (
+                        not isinstance(helicities, tuple)
+                        or len(helicities) != 1
+                        or not isinstance(helicities[0], str)
+                        or not helicities[0].startswith("h:")
+                        or not isinstance(color_flows, tuple)
+                        or color_flows != (() if contracted_color else ("1",))
+                    ):
+                        raise GenerationError(
+                            "on-the-fly validation compact selector is malformed "
+                            f"for {process_id!r}"
+                        )
+                    selector_label = (
+                        "compact helicity+contracted-color"
+                        if contracted_color
+                        else "compact helicity+flow"
+                    )
+                    selectors = {"helicities": helicities}
+                    if color_flows:
+                        selectors["color_flows"] = color_flows
+                    selected_samples = samples[:1]
+                    total = runtime.evaluate(selected_samples, **selectors)
+                    resolved_total = runtime.evaluate_resolved(
+                        selected_samples, **selectors
+                    ).total()
+                    if len(total) != 1 or len(resolved_total) != 1:
+                        raise GenerationError(
+                            f"Rusticol returned an invalid validation shape for "
+                            f"{process_id!r} ({selector_label})"
+                        )
+                    summed = total[0]
+                    resolved = resolved_total[0]
+                    if progress is not None:
+                        progress.update(
+                            process_index - 1,
+                            total=process_total,
+                            message=f"{process_id}: {selector_label}, sample 1",
+                            details={
+                                "process": process_id,
+                                "step": "numerical validation",
+                                "selector_case": selector_label,
+                                "validation_slice": selector_label,
+                                "sample_index": 1,
+                                "sample_total": 1,
+                            },
+                        )
+                    difference = abs(complex(summed) - complex(resolved))
+                    if not cmath.isclose(
+                        complex(summed),
+                        complex(resolved),
+                        rel_tol=validation.relative_tolerance,
+                        abs_tol=validation.absolute_tolerance,
+                    ):
+                        raise GenerationError(
+                            "resolved Rusticol validation does not reduce to "
+                            f"the total for {process_id!r} ({selector_label}) "
+                            "sample 1 "
+                            f"(absolute difference {difference:.3e})"
+                        )
+                    validated_samples = 1
+                if progress is not None:
+                    progress.update(
+                        process_index,
+                        total=process_total,
+                        message=process_id,
+                        details={
+                            "process": process_id,
+                            "step": "validated",
+                            "samples": validated_samples,
+                        },
+                    )
+                continue
+            if runtime.physics.process_id != process_id:
+                raise GenerationError(
+                    f"Rusticol selected the wrong process for {process_id!r}"
+                )
+            if validation.enabled and samples:
+                selector_cases = (
+                    _recurrence_validation_selector_cases(runtime.physics)
+                    if self._recurrence_execution_enabled
+                    else tuple(
+                        (
+                            validation_slice,
+                            {
+                                **({"helicities": helicities} if helicities else {}),
+                                **({"color_flows": color_flows} if color_flows else {}),
+                            },
+                        )
+                        for validation_slice, helicities, color_flows in (
+                            _post_build_validation_slices(
+                                runtime.physics,
+                                len(samples),
+                            )
+                        )
+                    )
+                )
+                if not selector_cases:
+                    raise GenerationError(
+                        f"generated recurrence exposes no selectable components "
+                        f"for {process_id!r}"
+                    )
+                for selector_label, selectors in selector_cases:
+                    total = runtime.evaluate(samples, **selectors)
+                    resolved_total = runtime.evaluate_resolved(
+                        samples, **selectors
+                    ).total()
+                    if len(total) != len(samples) or len(resolved_total) != len(
+                        samples
+                    ):
+                        raise GenerationError(
+                            f"Rusticol returned an invalid validation shape for "
+                            f"{process_id!r} ({selector_label})"
+                        )
+                    for sample_index, (summed, resolved) in enumerate(
+                        zip(total, resolved_total, strict=True),
+                        start=1,
+                    ):
+                        if progress is not None:
+                            progress.update(
+                                process_index - 1,
+                                total=process_total,
+                                message=(
+                                    f"{process_id}: {selector_label}, "
+                                    f"sample {sample_index}"
+                                ),
+                                details={
+                                    "process": process_id,
+                                    "step": "numerical validation",
+                                    "selector_case": selector_label,
+                                    "validation_slice": selector_label,
+                                    "sample_index": sample_index,
+                                    "sample_total": len(samples),
+                                },
+                            )
+                        difference = abs(complex(summed) - complex(resolved))
+                        if not cmath.isclose(
+                            complex(summed),
+                            complex(resolved),
+                            rel_tol=validation.relative_tolerance,
+                            abs_tol=validation.absolute_tolerance,
+                        ):
+                            raise GenerationError(
+                                "resolved Rusticol validation does not reduce to "
+                                f"the total for {process_id!r} ({selector_label}) "
+                                f"sample {sample_index} "
+                                f"(absolute difference {difference:.3e})"
+                            )
+            if progress is not None:
+                progress.update(
+                    process_index,
+                    total=process_total,
+                    message=process_id,
+                    details={
+                        "process": process_id,
+                        "step": "validated",
+                        "samples": len(samples),
+                    },
+                )
+        actual_api_bundle_path = manifest.runtime.get("api_bundle_path")
+        if actual_api_bundle_path != expected_api_bundle_path:
+            raise GenerationError("artifact API bundle outcome is inconsistent")
+
+    @property
+    def _run_config(self) -> RunConfig | None:
+        return self._config if isinstance(self._config, RunConfig) else None
+
+    @property
+    def _eager_execution_enabled(self) -> bool:
+        run = self._run_config
+        return run is not None and str(run.evaluator.execution_mode) == "eager"
+
+    @property
+    def _recurrence_execution_enabled(self) -> bool:
+        run = self._run_config
+        return run is not None and str(run.evaluator.execution_mode) == "recurrence"
+
+    @property
+    def _on_the_fly_execution_enabled(self) -> bool:
+        run = self._run_config
+        return run is not None and str(run.evaluator.execution_mode) == "on-the-fly"
+
+    @property
+    def _prepared_execution_enabled(self) -> bool:
+        return (
+            self._eager_execution_enabled
+            or self._recurrence_execution_enabled
+            or self._on_the_fly_execution_enabled
+        )
+
+    def _validate_recurrence_request(self) -> None:
+        """Keep recurrence-family requests out of compiled/eager lanes."""
+
+        if self._on_the_fly_execution_enabled and self._color_accuracy not in {
+            "lc",
+            "nlc",
+            "full",
+        }:
+            raise GenerationError(
+                "on-the-fly execution supports LC, NLC, and full color; "
+                f"got color.accuracy={self._color_accuracy!r}"
+            )
+        if self._recurrence_execution_enabled and self._color_accuracy not in {
+            "lc",
+            "nlc",
+            "full",
+        }:
+            raise GenerationError(
+                "recurrence execution supports LC, NLC, and full color; "
+                f"got color.accuracy={self._color_accuracy!r}"
+            )
+
+    @property
+    def _all_flow_union_enabled(self) -> bool:
+        run = self._run_config
+        if run is None:
+            return False
+        return str(getattr(run.color, "lc_flow_layout", "topology-replay")) == (
+            "all-flow-union"
+        )
+
+    @property
+    def _generation_config(self) -> GenerationConfig:
+        config = self._config
+        return config.generation if isinstance(config, RunConfig) else config
+
+    @property
+    def _builtin_process_options(self):
+        from ..models.builtin.process_types import BuiltinProcessOptions
+
+        run = self._run_config
+        if run is None:
+            return BuiltinProcessOptions()
+        max_lines = run.process.max_quark_lines
+        return BuiltinProcessOptions(
+            flavour_scheme=run.process.flavor_scheme,
+            include_3qqbar=max_lines is None or max_lines >= 3,
+        )
+
+    @property
+    def _max_quark_pairs(self) -> int | None:
+        run = self._run_config
+        return None if run is None else run.process.max_quark_lines
+
+    @property
+    def _color_accuracy(self) -> str:
+        run = self._run_config
+        return "lc" if run is None else run.color.accuracy
+
+    @property
+    def _coupling_order_limits(self) -> dict[str, int]:
+        run = self._run_config
+        if run is None:
+            return {}
+        return {
+            str(name).upper(): int(value)
+            for name, value in run.process.max_coupling_orders.items()
+        }
+
+    @property
+    def _flavor_blind(self) -> bool:
+        run = self._run_config
+        return run is not None and run.process.flavor_blind
+
+    @property
+    def _consider_charge_conjugation(self) -> bool:
+        run = self._run_config
+        return run is None or run.process.consider_charge_conjugation
+
+    @property
+    def _process_selection(self) -> _ProcessSelection:
+        if self._process_selection_override is not None:
+            return self._process_selection_override
+        run = self._run_config
+        if run is None:
+            return _ProcessSelection()
+        process = run.process
+        return _ProcessSelection(
+            max_color_sectors=process.max_color_sectors,
+            reference_color_order=(
+                tuple(int(label) for label in process.reference_color_order)
+                if process.reference_color_order
+                else None
+            ),
+            selected_color_sector_ids=(
+                frozenset(
+                    int(sector_id) for sector_id in process.selected_color_sector_ids
+                )
+                if process.selected_color_sector_ids
+                else None
+            ),
+            selected_source_helicities=(
+                {
+                    int(label): int(helicity)
+                    for label, helicity in process.selected_source_helicities.items()
+                }
+                if process.selected_source_helicities
+                else None
+            ),
+        )
+
+    def _configured_model_source(self) -> ModelSource:
+        run = self._run_config
+        if run is None:
+            return ModelSource.built_in_sm()
+        return ModelSource.from_config(run.model)
+
+    def _resolve_model_for_plan(
+        self,
+        source: ModelSource | CompiledModel,
+    ) -> _ResolvedModel:
+        if isinstance(source, CompiledModel):
+            compiled = self._private_compiled_model(source)
+            is_builtin = self._is_builtin_compiled_model(compiled)
+            return _ResolvedModel(
+                self._source_for_compiled_model(compiled),
+                _builtin_sm_model() if is_builtin else None,
+                compiled,
+                use_compiled_process_catalog=not is_builtin,
+            )
+        if source.kind in {"built-in-sm", "built-in-sm-heft"}:
+            if source.kind == "built-in-sm" and not self._prepared_execution_enabled:
+                return _ResolvedModel(source, _builtin_sm_model())
+            if self._prepared_execution_enabled:
+                source = self._packaged_builtin_prepared_source(source.kind)
+        source_input: str | Path
+        if source.kind == "built-in-sm-heft":
+            source_input = "built-in-sm-heft"
+        elif source.path is not None:
+            source_input = source.path
+        else:
+            raise ModelError("external model source has no path")
+
+        from .._internal.sm_heft import load_cached_sm_heft_source
+        from ..models.loading import load_cached_model_source, load_compiled_model
+
+        try:
+            if source.kind in {"compiled", "prepared"}:
+                compiled = load_compiled_model(source.path)
+            else:
+                run = self._run_config
+                use_cache = True if run is None else run.model.cache
+                if not use_cache:
+                    raise ModelError(
+                        "dry-run does not compile external model sources and model "
+                        "caching is disabled; compile the ModelSource explicitly and "
+                        "pass its CompiledModel"
+                    )
+                cache_dir = None if run is None else run.model.cache_dir
+                compiled = (
+                    load_cached_sm_heft_source(cache_dir=cache_dir)
+                    if source.kind == "built-in-sm-heft"
+                    else load_cached_model_source(
+                        source_input,
+                        restriction=(
+                            "default"
+                            if source.restriction is None
+                            else str(source.restriction)
+                        ),
+                        simplify=source.simplify,
+                        cache_dir=cache_dir,
+                    )
+                )
+                if compiled is None:
+                    raise ModelError(
+                        "dry-run does not compile external model sources; call "
+                        "ModelSource.compile() first and pass the returned "
+                        "CompiledModel, or populate the configured model cache"
+                    )
+        except ModelError:
+            raise
+        except (OSError, RuntimeError, TypeError, ValueError) as exc:
+            raise ModelError(str(exc)) from exc
+        is_builtin = self._is_builtin_compiled_model(compiled)
+        return _ResolvedModel(
+            source,
+            _builtin_sm_model() if is_builtin else None,
+            compiled,
+            use_compiled_process_catalog=not is_builtin,
+        )
+
+    @staticmethod
+    def _private_compiled_model(compiled: CompiledModel) -> _CompiledModelPayload:
+        payload = _compiled_model_payload(compiled)
+        if not isinstance(payload, _CompiledModelPayload):
+            raise ModelError("compiled model handle has an invalid private payload")
+        return payload
+
+    @staticmethod
+    def _source_for_compiled_model(compiled: _CompiledModelPayload) -> ModelSource:
+        if compiled.prepared_bundle is not None:
+            return ModelSource(kind="prepared", path=compiled.prepared_bundle.path)
+        return ModelSource(kind="compiled", path=compiled._serialized_path)
+
+    @staticmethod
+    def _is_builtin_compiled_model(compiled: _CompiledModelPayload) -> bool:
+        return compiled.source.get("kind") == "built-in-sm"
+
+    def _resolve_model(
+        self,
+        source: ModelSource | CompiledModel,
+    ) -> _ResolvedModel:
+        if isinstance(source, CompiledModel):
+            compiled = self._private_compiled_model(source)
+            if self._is_builtin_compiled_model(compiled):
+                return _ResolvedModel(
+                    self._source_for_compiled_model(compiled),
+                    _builtin_sm_model(),
+                    compiled,
+                    use_compiled_process_catalog=False,
+                )
+
+            from ..models.external import CompiledUFOModel
+
+            return _ResolvedModel(
+                self._source_for_compiled_model(compiled),
+                CompiledUFOModel(compiled),
+                compiled,
+            )
+        if source.kind in {"built-in-sm", "built-in-sm-heft"}:
+            if source.kind == "built-in-sm" and not self._prepared_execution_enabled:
+                return _ResolvedModel(source, _builtin_sm_model())
+            if self._prepared_execution_enabled:
+                source = self._packaged_builtin_prepared_source(source.kind)
+        source_input: str | Path
+        if source.kind == "built-in-sm-heft":
+            source_input = "built-in-sm-heft"
+        elif source.path is not None:
+            source_input = source.path
+        else:
+            raise ModelError("external model source has no path")
+        from .._internal.sm_heft import compile_sm_heft_source
+        from ..models.external import CompiledUFOModel
+        from ..models.loading import compile_model_source, load_compiled_model
+
+        try:
+            if source.kind in {"compiled", "prepared"}:
+                compiled = load_compiled_model(source.path)
+            else:
+                run = self._run_config
+                use_cache = True if run is None else run.model.cache
+                cache_dir = None if run is None else run.model.cache_dir
+                compiled = (
+                    compile_sm_heft_source(
+                        cache_dir=cache_dir,
+                        use_cache=use_cache,
+                    )
+                    if source.kind == "built-in-sm-heft"
+                    else compile_model_source(
+                        source_input,
+                        restriction=(
+                            "default"
+                            if source.restriction is None
+                            else str(source.restriction)
+                        ),
+                        simplify=source.simplify,
+                        cache_dir=cache_dir,
+                        use_cache=use_cache,
+                    )
+                )
+        except (OSError, RuntimeError, TypeError, ValueError) as exc:
+            raise ModelError(str(exc)) from exc
+        if self._is_builtin_compiled_model(compiled):
+            return _ResolvedModel(
+                source,
+                _builtin_sm_model(),
+                compiled,
+                use_compiled_process_catalog=False,
+            )
+        return _ResolvedModel(source, CompiledUFOModel(compiled), compiled)
+
+    @staticmethod
+    def _packaged_builtin_prepared_source(source_kind: str) -> ModelSource:
+        from ..assets.prepared_models import (
+            BUILTIN_SM_HEFT_JIT_O2,
+            BUILTIN_SM_JIT_O2,
+            PackagedPreparedModelError,
+            materialize_packaged_prepared_model,
+        )
+
+        identifiers = {
+            "built-in-sm": BUILTIN_SM_JIT_O2,
+            "built-in-sm-heft": BUILTIN_SM_HEFT_JIT_O2,
+        }
+        try:
+            identifier = identifiers[source_kind]
+        except KeyError as exc:  # pragma: no cover - private caller contract
+            raise ModelError(
+                f"no packaged prepared model is registered for {source_kind!r}"
+            ) from exc
+        try:
+            path = materialize_packaged_prepared_model(identifier)
+        except (OSError, PackagedPreparedModelError, RuntimeError, ValueError) as exc:
+            raise ModelError(
+                f"the wheel-owned prepared {source_kind} model is unavailable "
+                f"or stale: {exc}"
+            ) from exc
+        return ModelSource.from_path(path)
+
+    def _require_eager_kernel_pack(self, resolved: _ResolvedModel) -> None:
+        run = self._run_config
+        if run is None or not self._prepared_execution_enabled:
+            return
+        execution_mode = str(run.evaluator.execution_mode)
+        compiled = resolved.compiled
+        if compiled is None or compiled.prepared_bundle is None:
+            source = resolved.source.path or resolved.source.kind
+            backend = str(run.evaluator.backend)
+            raise GenerationError(
+                f"{execution_mode} generation requires a prepared model kernel "
+                "pack; run: "
+                f"pyamplicol model compile {source} MODEL.pyamplicol-model "
+                f"--backend {backend}"
+            )
+        pack = compiled.prepared_bundle.kernel_pack
+        recurrence_family = execution_mode in {"recurrence", "on-the-fly"}
+        if recurrence_family and pack.recurrence_template is None:
+            source = resolved.source.path or resolved.source.kind
+            backend = str(run.evaluator.backend)
+            raise GenerationError(
+                "prepared model kernel pack does not contain "
+                "pyamplicol-recurrence-template-v1; rebuild it with: "
+                f"pyamplicol model compile {source} MODEL.pyamplicol-model "
+                f"--backend {backend}"
+            )
+        if recurrence_family:
+            direct_catalog = pack.recurrence_direct_template_catalog
+            if direct_catalog is None:
+                source = resolved.source.path or resolved.source.kind
+                backend = str(run.evaluator.backend)
+                raise GenerationError(
+                    "prepared model kernel pack does not contain "
+                    "pyamplicol-recurrence-direct-template-v1; rebuild it with: "
+                    f"pyamplicol model compile {source} MODEL.pyamplicol-model "
+                    f"--backend {backend}"
+                )
+            pending = tuple(
+                template.direct_executor_id
+                for template in direct_catalog.templates
+                if not template.payload_binding.executable
+            )
+            if pending:
+                raise GenerationError(
+                    "prepared model recurrence direct-template catalog contains "
+                    "non-executable bindings "
+                    f"{pending}; rebuild the prepared model with a Direct-Arena "
+                    "capable backend"
+                )
+        try:
+            validate_prepared_target(
+                pack.target,
+                backend=pack.backend,
+                symjit_application_abi=cast(
+                    str | None,
+                    pack.dependency_abis.get("symjit_application"),
+                ),
+            )
+        except PreparedTargetError as exc:
+            source = resolved.source.path or resolved.source.kind
+            raise GenerationError(
+                f"{execution_mode} prepared model is incompatible with this "
+                f"host: {exc}; "
+                "prepare a matching bundle with: "
+                f"pyamplicol model compile {source} MODEL.pyamplicol-model "
+                f"--backend {pack.backend}"
+            ) from exc
+
+    def _index_eager_kernel_pack(self, resolved: _ResolvedModel) -> _ResolvedModel:
+        if not self._eager_execution_enabled:
+            return resolved
+        compiled = resolved.compiled
+        bundle = None if compiled is None else compiled.prepared_bundle
+        if bundle is None:  # pragma: no cover - guarded by _require_eager_kernel_pack
+            raise GenerationError("eager generation has no prepared kernel pack")
+        try:
+            index = PreparedCatalogEagerKernelIndex.from_manifest(
+                bundle.kernel_pack.resolver_manifest
+            )
+        except (KeyError, TypeError, ValueError) as exc:
+            raise GenerationError(
+                f"prepared model has an invalid eager kernel resolver: {exc}"
+            ) from exc
+        return replace(resolved, eager_kernel_index=index)
+
+    def _apply_prepared_kernel_pack_policy(self, resolved: _ResolvedModel) -> None:
+        if not self._prepared_execution_enabled:
+            return
+        run = self._run_config
+        if run is None:  # pragma: no cover - guarded by property above
+            return
+        execution_mode = str(run.evaluator.execution_mode)
+        compiled = resolved.compiled
+        bundle = None if compiled is None else compiled.prepared_bundle
+        if bundle is None:  # pragma: no cover - guarded by _require_eager_kernel_pack
+            raise GenerationError(
+                f"{execution_mode} generation has no prepared kernel pack"
+            )
+        resolution = self._resource_config
+        if not isinstance(resolution, ConfigResolution):
+            resolution = resolve_config(config_to_dict(self._config))
+        effective_values = config_to_dict(resolution.effective)
+        pack_values = _prepared_pack_effective_values(bundle.kernel_pack)
+        replacement_paths = frozenset(pack_values)
+        inherited = [
+            ClampRequest(item.path, item.effective, item.reason)
+            for item in resolution.clamps
+            if item.path not in replacement_paths
+        ]
+        prepared_clamps: list[ClampRequest] = []
+        for path, value in pack_values.items():
+            if _nested_config_value(effective_values, path) == value:
+                continue
+            prepared_clamps.append(
+                ClampRequest(
+                    path,
+                    value,
+                    f"prepared {execution_mode} kernel pack is authoritative for "
+                    "backend "
+                    "and code-shaping optimization settings",
+                )
+            )
+        if not prepared_clamps:
+            return
+        updated = resolve_config(
+            config_to_dict(resolution.requested),
+            clamps=(*inherited, *prepared_clamps),
+        )
+        self._resource_config = updated
+        self._configuration = _GenerationConfigProvenance.from_config(updated)
+        self._config = updated.effective
+        if not self._prepared_pack_warning_emitted:
+            rendered = ", ".join(clamp.path for clamp in prepared_clamps)
+            _LOGGER.warning(
+                "%s generation uses prepared model settings for: %s",
+                execution_mode,
+                rendered,
+            )
+            self._prepared_pack_warning_emitted = True
+
+    def _expand_request(
+        self,
+        request: ProcessRequest,
+        resolved_model: _ResolvedModel,
+    ) -> tuple[CanonicalProcessIR, ...]:
+        if (
+            resolved_model.compiled is None
+            or not resolved_model.use_compiled_process_catalog
+        ):
+            from ..models.builtin.process_catalog import PDGS
+            from ..models.builtin.process_ir import build_process_ir
+            from ..models.builtin.process_selection import (
+                enumerate_generic_process_set,
+            )
+            from ..processes.core_syntax import expand_process_variants
+
+            multiparticles = {"all": tuple(PDGS)}
+            if self._run_config is not None:
+                multiparticles.update(self._run_config.process.multiparticles)
+            expanded_request = " | ".join(
+                expand_process_variants(
+                    request.expression,
+                    aliases=multiparticles,
+                )
+            )
+
+            enumeration = enumerate_generic_process_set(
+                expanded_request,
+                self._builtin_process_options,
+                max_quark_pairs=self._max_quark_pairs,
+            )
+            return tuple(
+                build_process_ir(
+                    entry.process,
+                    color_accuracy=self._color_accuracy,
+                    options=self._builtin_process_options,
+                )
+                for entry in enumeration.entries
+            )
+
+        from ..processes.conservation import conserved_charges
+        from ..processes.model import (
+            ModelParticleCatalog,
+            build_model_process_ir,
+            expand_model_processes,
+        )
+
+        catalog = ModelParticleCatalog(
+            resolved_model.compiled.ir.name,
+            resolved_model.compiled.ir.particles,
+            resolved_model.compiled.ir.parameters,
+        )
+        run = self._run_config
+        multiparticles = None if run is None else run.process.multiparticles
+        candidates = tuple(
+            build_model_process_ir(
+                process,
+                resolved_model.compiled.ir,
+                color_accuracy=self._color_accuracy,
+            )
+            for process in expand_model_processes(
+                request.expression,
+                catalog,
+                multiparticles=multiparticles,
+                charges=conserved_charges(resolved_model.compiled.ir),
+            )
+        )
+        if not candidates:
+            raise GenerationError(
+                f"process request {request.expression!r} has no concrete process "
+                "conserving the additive charges of the model vertices"
+            )
+        selected, rejected = _select_color_ready_processes(
+            candidates,
+            color_accuracy=self._color_accuracy,
+            # Structural colour coverage is independent of the requested
+            # reduction. Model/coupling-order certification happens below.
+            basis="trace",
+        )
+        if not selected:
+            detail = "; ".join(rejected) or "no concrete processes"
+            raise GenerationError(
+                f"process request {request.expression!r} has no usable color plan: "
+                f"{detail}"
+            )
+        return selected
+
+    def _fft_color_basis(
+        self, process: CanonicalProcessIR, model: Model | None
+    ) -> Literal["trace", "adjoint"]:
+        """Select a suitable exact basis, never assume unproved identities."""
+
+        if (
+            self._run_config is None
+            or self._run_config.color.contraction.value == "direct"
+            or self._run_config.color.fft_basis.value == "trace"
+        ):
+            return "trace"
+        if self._automatic_adjoint_basis_limit(process) is not None:
+            return "trace"
+        ddm_proven = (
+            model is not None
+            and not process.fundamental_labels
+            and not process.antifundamental_labels
+            and len(process.adjoint_labels) >= 2
+            and adjoint_tree_color_basis_is_proven(
+                model, process, max_coupling_orders=self._coupling_order_limits or None
+            )
+        )
+        return best_general_fft_basis(process, ddm_proven=ddm_proven).actual_basis
+
+    def _automatic_adjoint_basis_limit(self, process: CanonicalProcessIR) -> str | None:
+        """Known representation limits must not make automatic requests fail."""
+
+        run = self._run_config
+        if run is None or run.color.contraction.value != "auto":
+            return None
+        if process.fundamental_labels or process.antifundamental_labels:
+            return None
+        from ..color.adjoint_kernel import MAX_ADJOINT_GLUONS
+
+        labels = tuple(sorted(process.adjoint_labels))
+        if len(labels) > MAX_ADJOINT_GLUONS:
+            return "The adjoint metric size limit requires the original trace basis."
+        reference = self._process_selection.reference_color_order
+        if labels and reference and set(reference) == set(labels):
+            pivot = reference.index(labels[0])
+            if reference[pivot - 1] != labels[-1]:
+                return (
+                    "The requested colour ordering requires the original trace basis."
+                )
+        return None
+
+    def _fft_basis_metadata(
+        self, color_plan: GenericColorPlan | None
+    ) -> dict[str, object]:
+        """Expose the actual representation without changing runtime identity."""
+
+        run = self._run_config
+        if (
+            color_plan is None
+            or run is None
+            or run.color.contraction.value == "direct"
+            or run.color.fft_basis.value != "adjoint"
+        ):
+            return {}
+        strategy = best_general_fft_basis(
+            color_plan.process, ddm_proven=color_plan.basis == "adjoint"
+        )
+        return {
+            "fft_basis_selection": {
+                "requested": "adjoint",
+                "actual_basis": strategy.actual_basis,
+                "name": strategy.name,
+                "reason": (
+                    self._automatic_adjoint_basis_limit(color_plan.process)
+                    or strategy.reason
+                ),
+                "permutation_degree": strategy.permutation_degree,
+                "tensor_count": strategy.tensor_count,
+            }
+        }
+
+    def _plan_concrete_process(
+        self,
+        process: CanonicalProcessIR,
+        *,
+        model: Model | None,
+    ) -> dict[str, object]:
+        selection = self._process_selection
+        self._validate_lc_flow_layout(selection)
+        if (
+            selection.selected_color_sector_ids is not None
+            and self._color_accuracy != "lc"
+        ):
+            raise GenerationError(
+                "process.selected_color_sector_ids is available only for LC generation"
+            )
+        color_plan = build_color_plan(
+            process,
+            basis=self._fft_color_basis(process, model),
+            color_accuracy=self._color_accuracy,
+            max_sectors=selection.max_color_sectors,
+            reference_color_order=selection.reference_color_order,
+            fold_trace_reflections=(
+                model is not None
+                and model.lc_trace_reflection_equivalence_is_proven(process)
+            ),
+        )
+        color_plan, missing_sector_ids = _restrict_color_plan(
+            color_plan,
+            selection.selected_color_sector_ids,
+        )
+        if missing_sector_ids:
+            raise GenerationError(
+                f"process {process.process!r} did not materialize requested LC "
+                "colour sector ids: "
+                + ", ".join(str(sector_id) for sector_id in missing_sector_ids)
+            )
+        if not color_plan.sectors:
+            detail = "; ".join(color_plan.diagnostics) or "no color sectors"
+            raise GenerationError(
+                f"process {process.process!r} has no usable color plan: {detail}"
+            )
+        return {
+            "key": process.key,
+            "process": process.process,
+            "external_particle_count": len(process.legs),
+            "color_sector_count": color_plan.sector_count,
+            "color_coverage": (
+                "selected"
+                if color_plan.truncated
+                or selection.selected_color_sector_ids is not None
+                else "complete"
+            ),
+            "helicity_coverage": (
+                "selected"
+                if selection.selected_source_helicities is not None
+                else "complete"
+            ),
+            "color_diagnostics": tuple(color_plan.diagnostics),
+            **self._fft_basis_metadata(color_plan),
+            "coupling_order_limits": self._coupling_order_limits,
+            "dag_compilation_deferred": True,
+        }
+
+    def _plan_on_the_fly_process(
+        self,
+        projected: _ProjectedOnTheFlyProcess,
+    ) -> dict[str, object]:
+        process = projected.expanded.process_ir
+        census = _on_the_fly_selector_census_v1(
+            projected.projection.seed,
+            process,
+        )
+        color_plan = projected.projection.color_plan
+        return {
+            "key": process.key,
+            "process": process.process,
+            "external_particle_count": len(process.legs),
+            "execution_mode": "on-the-fly",
+            "selector_representation": "compact-query-local",
+            "physical_helicity_count": census["physical_helicity_count"],
+            "physical_color_flow_count": census["physical_color_flow_count"],
+            "color_sector_count": census["physical_color_flow_count"],
+            "color_coverage": "complete" if color_plan is None else "contracted",
+            "helicity_coverage": "complete",
+            "color_diagnostics": (
+                () if color_plan is None else tuple(color_plan.diagnostics)
+            ),
+            **self._fft_basis_metadata(color_plan),
+            "coupling_order_limits": self._coupling_order_limits,
+            "color_plan_materialized": color_plan is not None,
+            "source_projection_validated": True,
+            "native_seed_construction_deferred": True,
+            "dag_compilation_deferred": True,
+        }
+
+    def _compile_concrete_process(
+        self,
+        process: CanonicalProcessIR,
+        model: Model,
+        *,
+        progress_callback: Callable[[Mapping[str, str | int]], None] | None = None,
+    ) -> tuple[GenericDAG, dict[str, object]]:
+        self._validate_recurrence_request()
+        prepared = self._prepare_process_construction(process, model)
+        if self._recurrence_execution_enabled:
+            raise GenerationError(
+                "recurrence execution is not available in this development "
+                "milestone: prepared recurrence-template-v1 is validated, but "
+                "Rust recurrence builder construction has not been installed"
+            )
+        complete_color_plan = prepared.complete_color_plan
+        materialized_sector_ids = prepared.materialized_sector_ids
+        limits = dict(prepared.coupling_order_limits)
+        replay_plan = prepared.topology_replay
+        selection = self._process_selection
+        dag = compile_generic_dag(
+            process,
+            model=model,
+            color_plan=complete_color_plan,
+            max_color_sectors=selection.max_color_sectors,
+            reference_color_order=selection.reference_color_order,
+            selected_color_sector_ids=materialized_sector_ids,
+            max_coupling_orders=limits or None,
+            max_quark_pairs=self._max_quark_pairs,
+            selected_source_helicities=selection.selected_source_helicities,
+            online_evaluation_reuse=(
+                self._eager_execution_enabled or self._all_flow_union_enabled
+            ),
+            backward_live_planning=self._eager_execution_enabled,
+            progress_callback=progress_callback,
+        )
+        if replay_plan is not None and replay_plan.optimized:
+            root_sector_ids = {
+                int(root.color_sector_id)
+                if root.color_sector_id is not None
+                else int(dag.currents[root.left_id].index.color_state.sector_id)
+                for root in dag.amplitude_roots
+            }
+            missing_representatives = {
+                int(partition.materialized_sector_id)
+                for partition in replay_plan.partitions
+                if int(partition.materialized_sector_id) not in root_sector_ids
+            }
+            if missing_representatives:
+                replay_plan = None
+                dag = compile_generic_dag(
+                    process,
+                    model=model,
+                    color_plan=complete_color_plan,
+                    max_color_sectors=selection.max_color_sectors,
+                    reference_color_order=selection.reference_color_order,
+                    selected_color_sector_ids=None,
+                    max_coupling_orders=limits or None,
+                    max_quark_pairs=self._max_quark_pairs,
+                    selected_source_helicities=selection.selected_source_helicities,
+                    online_evaluation_reuse=self._eager_execution_enabled,
+                    backward_live_planning=self._eager_execution_enabled,
+                    progress_callback=progress_callback,
+                )
+        if replay_plan is not None and replay_plan.optimized:
+            dag = replace(
+                dag,
+                color_plan=complete_color_plan,
+                color_coverage="complete",
+                selected_color_sector_ids=(),
+                lc_topology_replay=(
+                    replay_plan
+                    if isinstance(replay_plan, LCColorTopologyReplayPlan)
+                    else None
+                ),
+                color_topology_replay=(
+                    replay_plan
+                    if isinstance(replay_plan, ColorTopologyReplayCertificate)
+                    else None
+                ),
+            )
+        if dag.truncated:
+            raise GenerationError(
+                f"process {process.process!r} DAG was unexpectedly truncated"
+            )
+        if not dag.has_amplitudes:
+            raise _NoModelSupportedAmplitudes(
+                f"process {process.process!r} has no model-supported tree-level "
+                "amplitudes"
+            )
+        return (
+            dag,
+            {
+                "key": process.key,
+                "process": process.process,
+                "color_sector_count": dag.color_plan.sector_count,
+                **(
+                    {}
+                    if self._color_accuracy != "lc"
+                    else {
+                        "lc_flow_layout": (
+                            "all-flow-union"
+                            if self._all_flow_union_enabled
+                            else "topology-replay"
+                        )
+                    }
+                ),
+                **(
+                    {}
+                    if (
+                        dag.lc_topology_replay is None
+                        and dag.color_topology_replay is None
+                    )
+                    else {
+                        "materialized_color_sector_count": len(
+                            (
+                                dag.lc_topology_replay or dag.color_topology_replay
+                            ).materialized_sector_ids
+                        ),
+                        "replayed_color_sector_count": (
+                            (
+                                dag.lc_topology_replay or dag.color_topology_replay
+                            ).replayed_sector_count
+                        ),
+                        "residual_color_sector_count": len(
+                            (
+                                dag.lc_topology_replay or dag.color_topology_replay
+                            ).residual_sector_ids
+                        ),
+                    }
+                ),
+                "color_coverage": dag.color_coverage,
+                "helicity_coverage": dag.helicity_coverage,
+                "source_count": len(dag.sources),
+                "current_count": len(dag.currents),
+                "interaction_count": len(dag.interactions),
+                "interaction_evaluation_count": dag.interaction_evaluation_count,
+                "amplitude_root_count": len(dag.amplitude_roots),
+                "coupling_order_limits": limits,
+            },
+        )
+
+    def _prepare_process_construction(
+        self,
+        process: CanonicalProcessIR,
+        model: Model,
+    ) -> _PreparedProcessConstruction:
+        """Prepare the shared model/color contract before choosing a builder."""
+
+        selection = self._process_selection
+        self._validate_lc_flow_layout(selection)
+        if (
+            selection.selected_color_sector_ids is not None
+            and self._color_accuracy != "lc"
+        ):
+            raise GenerationError(
+                "process.selected_color_sector_ids is available only for LC generation"
+            )
+        complete_color_plan = build_color_plan(
+            process,
+            basis=self._fft_color_basis(process, model),
+            color_accuracy=self._color_accuracy,
+            max_sectors=selection.max_color_sectors,
+            reference_color_order=selection.reference_color_order,
+            fold_trace_reflections=(
+                model.lc_trace_reflection_equivalence_is_proven(process)
+            ),
+        )
+        color_plan, missing_sector_ids = _restrict_color_plan(
+            complete_color_plan,
+            selection.selected_color_sector_ids,
+        )
+        if missing_sector_ids:
+            raise GenerationError(
+                f"process {process.process!r} did not materialize requested LC "
+                "colour sector ids: "
+                + ", ".join(str(sector_id) for sector_id in missing_sector_ids)
+            )
+        if not color_plan.sectors:
+            detail = "; ".join(color_plan.diagnostics) or "no color sectors"
+            raise GenerationError(
+                f"process {process.process!r} has no usable color plan: {detail}"
+            )
+        limits = self._coupling_order_limits
+        run = self._run_config
+        if run is not None and run.process.coupling_order_policy == "minimal":
+            if (
+                selection.max_color_sectors is None
+                and selection.reference_color_order is None
+                and complete_color_plan.color_accuracy == process.color_accuracy
+            ):
+                inferred = _infer_minimal_coupling_order_limits_from_color_plan(
+                    process,
+                    model=model,
+                    color_plan=complete_color_plan,
+                    max_coupling_orders=limits or None,
+                )
+            else:
+                inferred = infer_minimal_coupling_order_limits(
+                    process,
+                    model=model,
+                    max_coupling_orders=limits or None,
+                )
+            limits = inferred or limits
+        replay_plan = None
+        materialized_sector_ids = selection.selected_color_sector_ids
+        if (
+            self._color_accuracy == "lc"
+            and not self._all_flow_union_enabled
+            and selection.selected_color_sector_ids is None
+            and selection.selected_source_helicities is None
+        ):
+            replay_plan = build_lc_topology_replay_plan(
+                complete_color_plan,
+                model,
+            )
+            if replay_plan is not None and replay_plan.optimized:
+                materialized_sector_ids = frozenset(replay_plan.materialized_sector_ids)
+        elif (
+            self._color_accuracy in {"nlc", "full"}
+            and selection.selected_color_sector_ids is None
+            and selection.selected_source_helicities is None
+            and all(abs(int(leg.outgoing_pdg or 0)) == 21 for leg in process.legs)
+        ):
+            # The first contracted-color consumer is deliberately scoped to
+            # pure adjoint amplitudes.  Their relabeling phase is exactly +1,
+            # so recurrence, compiled, and eager modes can consume the same
+            # certificate without introducing a fermion-crossing convention.
+            replay_plan = build_color_topology_replay_certificate(
+                complete_color_plan,
+                model,
+            )
+            if replay_plan is not None and replay_plan.optimized:
+                materialized_sector_ids = frozenset(replay_plan.materialized_sector_ids)
+        return _PreparedProcessConstruction(
+            process=process,
+            complete_color_plan=complete_color_plan,
+            restricted_color_plan=color_plan,
+            materialized_sector_ids=materialized_sector_ids,
+            coupling_order_limits=MappingProxyType(dict(limits)),
+            topology_replay=replay_plan,
+        )
+
+    def _validate_lc_flow_layout(self, selection: _ProcessSelection) -> None:
+        if not self._all_flow_union_enabled:
+            return
+        if self._color_accuracy != "lc":
+            raise GenerationError(
+                "color.lc_flow_layout='all-flow-union' is available only for "
+                "LC generation"
+            )
+        incompatible: list[str] = []
+        if selection.max_color_sectors is not None:
+            incompatible.append("process.max_color_sectors")
+        if not self._recurrence_execution_enabled:
+            if selection.selected_color_sector_ids is not None:
+                incompatible.append("process.selected_color_sector_ids")
+            if selection.selected_source_helicities is not None:
+                incompatible.append("process.selected_source_helicities")
+        if incompatible:
+            raise GenerationError(
+                "color.lc_flow_layout='all-flow-union' requires complete runtime "
+                "flow and helicity coverage; remove " + ", ".join(incompatible)
+            )
+
+    def _compile_complete_color_helicity_selector_union(
+        self,
+        process: _DagProcess,
+        model: Model,
+    ) -> GenericDAG | None:
+        """Build a bounded all-colour lane for runtime helicity selection.
+
+        The ordinary complete artifact keeps topology replay for fast runtime
+        colour selection and helicity sums. Replaying that compact DAG once per
+        physical colour sector is inefficient for the complementary
+        all-colours/selected-helicity workload, so bounded colour spaces receive
+        an auxiliary complete-colour recurrence quotient.
+        """
+
+        parent = process.dag
+        accuracy = parent.process.color_accuracy
+        replay = (
+            parent.lc_topology_replay
+            if accuracy == "lc"
+            else parent.color_topology_replay
+            if accuracy in {"nlc", "full"}
+            else None
+        )
+        if (
+            self._eager_execution_enabled
+            or accuracy not in {"lc", "nlc", "full"}
+            or parent.color_coverage != "complete"
+            or parent.selected_color_sector_ids
+            or parent.selected_source_helicities
+            or parent.helicity_coverage != "complete"
+            or replay is None
+            or len(parent.color_plan.sectors) > _MAX_FUSED_HELICITY_SELECTOR_SECTORS
+        ):
+            return None
+
+        limits_payload = process.coverage.get("coupling_order_limits", {})
+        if not isinstance(limits_payload, Mapping):
+            raise GenerationError("process coupling-order coverage is not a mapping")
+        limits = {str(name): int(value) for name, value in limits_payload.items()}
+        selection = self._process_selection
+        union = compile_generic_dag(
+            process.expanded.process_ir,
+            model=model,
+            color_plan=parent.color_plan,
+            max_color_sectors=None,
+            reference_color_order=selection.reference_color_order,
+            selected_color_sector_ids=None,
+            max_coupling_orders=limits or None,
+            max_quark_pairs=self._max_quark_pairs,
+            selected_source_helicities=None,
+            online_evaluation_reuse=False,
+            backward_live_planning=False,
+            progress_callback=None,
+        )
+        if union.truncated or not union.has_amplitudes:
+            raise GenerationError(
+                "complete-color helicity selector lane did not produce a "
+                "complete amplitude DAG"
+            )
+        parity_preweighted = any(
+            float(root.helicity_weight) > 1.0 for root in union.amplitude_roots
+        )
+        reduced = (
+            prune_dag_to_amplitude_roots(union)
+            if parity_preweighted
+            else prune_global_helicity_flip_equivalent_roots(union, model)
+        )
+        recurrence = build_helicity_recurrence_plan(reduced, model)
+        if recurrence is None:
+            return None
+        materialization = materialize_helicity_recurrence(
+            reduced,
+            recurrence,
+        )
+        return replace(
+            materialization.dag,
+            lc_topology_replay=None,
+            color_topology_replay=None,
+            helicity_recurrence=recurrence,
+            helicity_materialization=materialization,
+        )
+
+
+def _runtime_stage_count(schema: RuntimeExpressionSchema) -> int:
+    stages = schema.to_mapping().get("stages")
+    if isinstance(stages, str | bytes) or not isinstance(stages, Sequence):
+        raise GenerationError("runtime expression schema stages must be a sequence")
+    return len(stages)
+
+
+def _helicity_selector_lane_stage_count(
+    lane: _HelicitySelectorLane,
+) -> int:
+    return _runtime_stage_count(lane.runtime_schema) + sum(
+        _helicity_selector_lane_stage_count(child) for child in lane.child_lanes
+    )
+
+
+def _helicity_selector_lane_compile_task_count(
+    lane: _HelicitySelectorLane,
+) -> int:
+    return (
+        _runtime_stage_count(lane.runtime_schema)
+        + 1
+        + sum(
+            _helicity_selector_lane_compile_task_count(child)
+            for child in lane.child_lanes
+        )
+    )
+
+
+def _runtime_schema_dag_summary(
+    schema: RuntimeExpressionSchema,
+) -> dict[str, object]:
+    payload = schema.to_mapping()
+    current_storage = cast("Mapping[str, object]", payload["current_storage"])
+    source_fill = cast("Mapping[str, object]", payload["source_fill"])
+    amplitude_stage = cast("Mapping[str, object]", payload["amplitude_stage"])
+    stages = cast("Sequence[Mapping[str, object]]", payload["stages"])
+    current_slots = cast("Sequence[object]", current_storage["current_slots"])
+    return {
+        "current_count": len(current_slots),
+        "source_count": int(source_fill["source_count"]),
+        "interaction_count": sum(int(stage["interaction_count"]) for stage in stages),
+        "interaction_evaluation_count": sum(
+            int(stage["interaction_evaluation_count"]) for stage in stages
+        ),
+        "amplitude_root_count": int(amplitude_stage["output_count"]),
+        "truncated": False,
+    }
+
+
+def _select_color_ready_processes(
+    processes: Sequence[CanonicalProcessIR],
+    *,
+    color_accuracy: str,
+    basis: str = "trace",
+) -> tuple[tuple[CanonicalProcessIR, ...], tuple[str, ...]]:
+    """Drop structurally impossible children of an external multiparticle request."""
+
+    selected: list[CanonicalProcessIR] = []
+    rejected: list[str] = []
+    for process in processes:
+        color_plan = build_color_plan(
+            process,
+            color_accuracy=color_accuracy,
+            basis=basis,
+            max_sectors=1,
+        )
+        # This is only a structural existence probe. Its deliberately capped
+        # plan may be truncated; complete basis construction happens later.
+        if color_plan.sectors:
+            selected.append(process)
+            continue
+        detail = "; ".join(color_plan.diagnostics) or "no color sectors"
+        rejected.append(f"{process.process}: {detail}")
+    return tuple(selected), tuple(rejected)
+
+
+def _expanded_name(base: str, index: int, count: int) -> str:
+    return base if count == 1 else f"{base}_{index}"
+
+
+def _process_side_permutation_class(
+    process: CanonicalProcessIR,
+) -> tuple[tuple[str, ...], tuple[str, ...]]:
+    """Identify one reusable representative per unordered external side."""
+
+    return (
+        tuple(sorted(leg.particle.casefold() for leg in process.initial_legs)),
+        tuple(sorted(leg.particle.casefold() for leg in process.final_legs)),
+    )
+
+
+_RelationWarning = Callable[
+    [GroupingProcess, GroupingProcess, LegMapping, CanonicalProcessIR],
+    str | None,
+]
+
+
+def _grouping_process(entry: _ExpandedProcess) -> GroupingProcess:
+    pdgs = tuple(leg.pdg for leg in entry.process_ir.legs)
+    if any(pdg is None for pdg in pdgs):
+        raise GenerationError(
+            f"process {entry.request.name!r} has an unresolved external particle"
+        )
+    return GroupingProcess(
+        process_id=entry.request.name,
+        expression=entry.request.expression,
+        pdgs=tuple(int(cast(int, pdg)) for pdg in pdgs),
+        initial_count=len(entry.process_ir.initial_legs),
+    )
+
+
+def _collapse_flavor_blind_classes(
+    entries: Sequence[_ExpandedProcess],
+    table: Mapping[int, GroupingParticle],
+    *,
+    consider_charge_conjugation: bool,
+    relation_warning: _RelationWarning,
+) -> list[_ExpandedProcess]:
+    """Keep the representative of each flavour class and record the others on it.
+
+    Processes with explicit aliases keep their own artifact entry.
+    """
+
+    by_name = {entry.request.name: entry for entry in entries}
+    members: dict[str, list[GroupMember]] = {}
+    warnings: list[str] = []
+    for flavour_class in flavor_blind_classes(
+        [_grouping_process(entry) for entry in entries],
+        table,
+        consider_charge_conjugation=consider_charge_conjugation,
+    ):
+        representative = flavour_class[0]
+        for process in flavour_class[1:]:
+            if by_name[process.process_id].aliases:
+                continue
+            mapping = flavor_blind_mapping(
+                process,
+                representative,
+                table,
+                consider_charge_conjugation=consider_charge_conjugation,
+            )
+            warning = relation_warning(
+                process,
+                representative,
+                mapping,
+                by_name[representative.process_id].process_ir,
+            )
+            if warning is not None:
+                warnings.append(warning)
+            members.setdefault(representative.process_id, []).append(
+                GroupMember.identity(replace(process, generated=False)).related(
+                    mapping,
+                    factor=Fraction(1),
+                    basis=GroupingBasis.FLAVOR_BLIND,
+                    warning=warning,
+                )
+            )
+    if warnings:
+        _LOGGER.warning(
+            "flavor-blind grouping assumes %d relation(s) that are not symmetries "
+            "of the model vertices allowed by the coupling orders, e.g. %s",
+            len(warnings),
+            "; ".join(warnings[:3]),
+        )
+    grouped = {member.process_id for group in members.values() for member in group}
+    conjugated = sum(
+        member.conjugated for group in members.values() for member in group
+    )
+    _LOGGER.info(
+        "Flavor-blind grouping: %d subprocess%s -> %d generated "
+        "representative%s; %d routed member%s (%d by charge conjugation%s); "
+        "%d relabelling warning%s",
+        len(entries),
+        "" if len(entries) == 1 else "es",
+        len(entries) - len(grouped),
+        "" if len(entries) - len(grouped) == 1 else "s",
+        len(grouped),
+        "" if len(grouped) == 1 else "s",
+        conjugated,
+        "" if consider_charge_conjugation else ", disabled",
+        len(warnings),
+        "" if len(warnings) == 1 else "s",
+    )
+    return [
+        replace(entry, group_members=tuple(members.get(entry.request.name, ())))
+        for entry in entries
+        if entry.request.name not in grouped
+    ]
+
+
+def _permuted_process_identity(
+    process: CanonicalProcessIR,
+    representative_to_alias: Sequence[int],
+) -> tuple[str, tuple[int, ...]]:
+    """Return public process metadata in a side-preserving alias order."""
+
+    legs = process.legs
+    if len(representative_to_alias) != len(legs) or sorted(
+        representative_to_alias
+    ) != list(range(len(legs))):
+        raise GenerationError("alias particle permutation is not complete")
+    alias_legs: list[ProcessLegIR | None] = [None] * len(legs)
+    for representative_index, alias_index in enumerate(representative_to_alias):
+        alias_legs[alias_index] = legs[representative_index]
+    if any(leg is None for leg in alias_legs):
+        raise GenerationError("alias particle permutation is incomplete")
+    ordered_legs = tuple(cast(ProcessLegIR, leg) for leg in alias_legs)
+    if any(leg.pdg is None for leg in ordered_legs):
+        raise GenerationError("process alias has an unresolved external particle")
+    initial = " ".join(leg.particle for leg in ordered_legs if leg.is_initial)
+    final = " ".join(leg.particle for leg in ordered_legs if leg.is_final)
+    if not initial or not final:
+        raise GenerationError("process alias must retain initial and final states")
+    return (
+        f"{initial} > {final}",
+        tuple(int(leg.pdg) for leg in ordered_legs if leg.pdg is not None),
+    )
+
+
+def _cpp_optimization_level(value: str) -> int:
+    normalized = value.strip().upper()
+    if normalized.startswith("-"):
+        normalized = normalized[1:]
+    if normalized not in {"O0", "O1", "O2", "O3"}:
+        raise GenerationError("evaluator.cpp.optimization must be O0, O1, O2, or O3")
+    return int(normalized[1])
+
+
+def create_generator_backend(
+    config: GenerationConfig | RunConfig | ConfigResolution | None,
+    progress: ProgressSink | None,
+    *,
+    api_bundle_hook: ApiBundleHook | None = None,
+) -> GenerationBackend:
+    return GenerationBackend(config, progress, api_bundle_hook=api_bundle_hook)
+
+
+__all__ = ["GenerationBackend", "create_generator_backend"]
diff --git a/pyamplicol/src/pyamplicol/generation/stage_artifacts.py b/pyamplicol/src/pyamplicol/generation/stage_artifacts.py
new file mode 100644
index 0000000000..110825081c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/stage_artifacts.py
@@ -0,0 +1,1309 @@
+# SPDX-License-Identifier: 0BSD
+"""Compilation and persistence of stage evaluator artifacts."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import replace
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from .._internal.physics.parameters import ParamBuilder
+from .._internal.physics.symbols import symbols
+from .._internal.versions import (
+    COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+    COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+    COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+    NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+    SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+    SYMJIT_APPLICATION_ABI,
+    SYMJIT_F64_RUNTIME_CAPABILITY,
+    SYMJIT_PLANE_APPLICATION_ABI,
+)
+from ..evaluators.execution_schema import (
+    aggregate_runtime_capabilities,
+    evaluator_runtime_capabilities,
+)
+from ..models.base import Model
+from .contracts import StageCompilationInput
+from .dag_types import GenericDAG
+from .stage_parameters import _dict, _list, _logical_model_parameter_symbols
+from .stage_planning import (
+    _prepare_stage_for_output_chunking,
+    build_generic_stage_compiler_blueprint,
+)
+from .stage_settings import _stage_symbolica_settings
+from .stage_types import (
+    GenericCompiledStageBlueprint,
+    GenericStageCompilerBlueprint,
+    StageBlueprintProgress,
+    StageEvaluatorCompiler,
+)
+
+_EXPRESSION_PREVIEW_LIMIT = 512
+
+
+def write_generic_stage_evaluator_artifacts(
+    blueprint: GenericStageCompilerBlueprint,
+    artifact_dir: str | Path,
+    *,
+    compiler: StageEvaluatorCompiler | None = None,
+    symbolica_settings: Any | None = None,
+    merge_evaluators_strategy: bool = False,
+    verbose_evaluator_build: bool = False,
+    jit_compile: bool = True,
+    progress_callback: Any | None = None,
+) -> dict[str, object]:
+    """Serialize evaluator artifacts for a schema-v3 stage blueprint.
+
+    The function is intentionally opt-in. Normal schema-v3 process manifest
+    generation remains cheap, while this path is the bridge from the
+    process-generic current DAG to concrete Symbolica evaluator artifacts.
+    The native runtime can validate, load, and execute the resulting metadata
+    through its generic staged runtime.
+    """
+
+    if not blueprint.expression_ready:
+        raise ValueError(
+            "cannot write generic evaluator artifacts with lowering blockers: "
+            + "; ".join(blueprint.blockers)
+        )
+
+    output_dir = Path(artifact_dir).expanduser()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    build_started = time.perf_counter()
+    if progress_callback is not None:
+        progress_callback(
+            {
+                "stage": "stage compile",
+                "item": "start",
+                "total": blueprint.stage_count,
+            }
+        )
+
+    def compile_stage(stage: GenericCompiledStageBlueprint) -> dict[str, object]:
+        return _compile_stage_evaluator_artifact(
+            stage,
+            output_dir,
+            compiler=compiler,
+            blueprint=blueprint,
+            symbolica_settings=symbolica_settings,
+            merge_evaluators_strategy=merge_evaluators_strategy,
+            verbose_evaluator_build=verbose_evaluator_build,
+            jit_compile=jit_compile,
+            progress_callback=progress_callback,
+        )
+
+    stage_payloads = []
+    stage_timings: list[dict[str, object]] = []
+    for stage in blueprint.stages:
+        prepared_stage = _prepare_stage_for_output_chunking(
+            stage,
+            blueprint=blueprint,
+            symbolica_settings=symbolica_settings,
+        )
+        payload = prepared_stage.to_json_dict()
+        payload["evaluator"] = compile_stage(prepared_stage)
+        direct = _compiled_plane_arena_stage(payload)
+        if direct is not None:
+            payload["compiled_plane_arena"] = direct
+        stage_timings.append(
+            _stage_build_timing_record(
+                prepared_stage.evaluator_label,
+                payload["evaluator"],
+            )
+        )
+        stage_payloads.append(payload)
+        if progress_callback is not None:
+            timing = stage_timings[-1]
+            progress_callback(
+                {
+                    "stage": "stage complete",
+                    "item": stage.evaluator_label,
+                    "increment": 1,
+                    "total": blueprint.stage_count,
+                    "duration_s": timing["stage_evaluator_build_s"],
+                }
+            )
+
+    prepared_amplitude_stage = _prepare_stage_for_output_chunking(
+        blueprint.amplitude_stage,
+        blueprint=blueprint,
+        symbolica_settings=symbolica_settings,
+    )
+    amplitude_payload = prepared_amplitude_stage.to_json_dict()
+    amplitude_payload["evaluator"] = compile_stage(prepared_amplitude_stage)
+    direct = _compiled_plane_arena_stage(amplitude_payload)
+    if direct is not None:
+        amplitude_payload["compiled_plane_arena"] = direct
+    stage_timings.append(
+        _stage_build_timing_record(
+            blueprint.amplitude_stage.evaluator_label,
+            amplitude_payload["evaluator"],
+        )
+    )
+    if progress_callback is not None:
+        timing = stage_timings[-1]
+        progress_callback(
+            {
+                "stage": "stage complete",
+                "item": blueprint.amplitude_stage.evaluator_label,
+                "increment": 1,
+                "total": blueprint.stage_count,
+                "duration_s": timing["stage_evaluator_build_s"],
+            }
+        )
+
+    return _finalize_stage_evaluator_payload(
+        blueprint,
+        stage_payloads=stage_payloads,
+        amplitude_payload=amplitude_payload,
+        stage_timings=stage_timings,
+        build_started=build_started,
+    )
+
+
+def write_model_parameter_evaluator_artifact(
+    model: Model,
+    runtime_schema: Mapping[str, object],
+    artifact_dir: str | Path,
+    *,
+    symbolica_settings: Any | None = None,
+    jit_compile: bool = True,
+    progress_callback: Any | None = None,
+) -> dict[str, object] | None:
+    schema = _dict(runtime_schema)
+    records = tuple(
+        sorted(
+            (_dict(item) for item in _list(schema.get("model_parameters", []))),
+            key=lambda item: int(item["parameter_index"]),
+        )
+    )
+    input_records = tuple(
+        record
+        for record in records
+        if str(record.get("kind"))
+        in {"external_parameter", "external_parameter_component"}
+    )
+    derived_components: dict[str, dict[str, int]] = {}
+    for record in records:
+        if str(record.get("kind")) != "derived_parameter_component":
+            continue
+        runtime_name = record.get("runtime_name")
+        component = record.get("complex_component")
+        if isinstance(runtime_name, str) and component in {"real", "imag"}:
+            derived_components.setdefault(runtime_name, {})[str(component)] = int(
+                record["parameter_index"]
+            )
+    requested_output_names = tuple(
+        name
+        for name, components in sorted(
+            derived_components.items(),
+            key=lambda item: min(item[1].values()),
+        )
+        if set(components) == {"real", "imag"}
+    )
+    if not requested_output_names:
+        return None
+
+    definitions_provider = getattr(
+        model,
+        "runtime_derived_parameter_definitions",
+        None,
+    )
+    if not callable(definitions_provider):
+        return None
+    definitions_subset_provider = getattr(
+        model,
+        "runtime_derived_parameter_definitions_for",
+        None,
+    )
+    definition_values = (
+        definitions_subset_provider(requested_output_names)
+        if callable(definitions_subset_provider)
+        else definitions_provider()
+    )
+    definitions = {
+        str(name): str(expression)
+        for name, expression in definition_values.items()
+        if str(name) in requested_output_names
+    }
+    output_names = tuple(name for name in requested_output_names if name in definitions)
+    if not output_names:
+        return None
+
+    # Planning imports this module without compiling model parameters.
+    from ..models.compiler_records import _replace_evaluator_constants
+
+    builder = ParamBuilder()
+    model_symbols = symbols.model(getattr(model, "name", "unnamed-model"))
+    parameter_symbols = tuple(
+        builder.add_parameter_list(
+            ("artifact_schema_v3", "external_model_parameters"),
+            len(input_records),
+            role="generic_external_model_parameters",
+            real_valued=True,
+        )
+    )
+    slot_symbols = {
+        str(record["name"]): parameter_symbols[index]
+        for index, record in enumerate(input_records)
+    }
+    logical_symbols = _logical_model_parameter_symbols(
+        input_records,
+        slot_symbols,
+    )
+    outputs = []
+    for name in output_names:
+        expression = model_symbols.expression(definitions[name])
+        for parameter_name, symbol in logical_symbols.items():
+            expression = expression.replace(
+                model_symbols.symbol(parameter_name),
+                symbol,
+            )
+        outputs.append(expression)
+
+    stage = GenericCompiledStageBlueprint(
+        stage_index=0,
+        stage_kind="model-parameter-derivation",
+        subset_size=None,
+        evaluator_label="generic_model_parameter_derivation",
+        parameter_layout="external-model-parameters",
+        output_length=len(outputs),
+        output_slots=(),
+        input_value_slot_ids=(),
+        output_value_slot_ids=(),
+        interaction_ids=(),
+        input_components=(),
+        parameter_count=len(parameter_symbols),
+        value_parameter_count=0,
+        momentum_parameter_count=0,
+        model_parameter_count=len(parameter_symbols),
+        real_valued_inputs=tuple(range(len(parameter_symbols))),
+        expression_ready=True,
+        blockers=(),
+        first_output_previews=tuple(
+            expression.to_canonical_string()[:_EXPRESSION_PREVIEW_LIMIT]
+            for expression in outputs[:3]
+        ),
+        parameter_symbols=parameter_symbols,
+        output_expressions=tuple(outputs),
+    )
+    parameter_evaluator_settings = (
+        None
+        if symbolica_settings is None
+        else replace(
+            symbolica_settings,
+            compiled_output_chunk_size=None,
+            output_chunk_strategy="uniform",
+        )
+    )
+    evaluator = _compile_stage_evaluator_artifact(
+        # Native evaluators use f64 constants, whereas the retained compiled
+        # model keeps the exact definitions used by the high-precision path.
+        replace(
+            stage,
+            output_expressions=tuple(
+                _replace_evaluator_constants(expression) for expression in outputs
+            ),
+        ),
+        Path(artifact_dir).expanduser(),
+        compiler=None,
+        blueprint=None,
+        symbolica_settings=parameter_evaluator_settings,
+        merge_evaluators_strategy=False,
+        verbose_evaluator_build=False,
+        jit_compile=jit_compile,
+        progress_callback=progress_callback,
+    )
+    return {
+        "kind": "generic-model-parameter-evaluator",
+        "required_runtime_capabilities": list(
+            evaluator_runtime_capabilities(evaluator)
+        ),
+        "input_parameter_indices": [
+            int(record["parameter_index"]) for record in input_records
+        ],
+        "outputs": [
+            {
+                "runtime_name": name,
+                "output_index": output_index,
+                "real_parameter_index": derived_components[name]["real"],
+                "imag_parameter_index": derived_components[name]["imag"],
+            }
+            for output_index, name in enumerate(output_names)
+        ],
+        "evaluator": evaluator,
+    }
+
+
+def _compiled_plane_arena_stage(
+    stage: Mapping[str, object],
+) -> dict[str, object] | None:
+    """Freeze one fused SymJIT stage's direct plane bindings.
+
+    The ordinary SymJIT application remains a cold source payload.  Its
+    row-major interface is not the execution contract: this record fixes the
+    canonical preorder leaf maps, arena inputs, and overwrite destinations
+    used to lower and bind the factor-free DirectApplication at load time.
+    """
+
+    if stage.get("parameter_layout") != "stage-local-value-momentum":
+        return None
+    evaluator = stage.get("evaluator")
+    if not isinstance(evaluator, Mapping):
+        raise ValueError("compiled stage evaluator metadata is invalid")
+    parameter_count = stage.get("parameter_count")
+    output_length = stage.get("output_length")
+    if (
+        isinstance(parameter_count, bool)
+        or not isinstance(parameter_count, int)
+        or parameter_count < 0
+        or isinstance(output_length, bool)
+        or not isinstance(output_length, int)
+        or output_length < 1
+    ):
+        raise ValueError("compiled stage dimensions are invalid")
+
+    leaves, output_stop, application_abi, source_application_abi = (
+        _compiled_plane_arena_leaves(
+            evaluator,
+            tuple(range(parameter_count)),
+            0,
+        )
+    )
+    if leaves is None:
+        return None
+    if output_stop != output_length:
+        raise ValueError(
+            "compiled plane-arena leaves do not cover the fused stage outputs"
+        )
+
+    raw_inputs = stage.get("input_components")
+    if not isinstance(raw_inputs, Sequence) or isinstance(raw_inputs, (str, bytes)):
+        raise ValueError("compiled plane-arena input bindings are absent")
+    inputs: list[dict[str, object] | None] = [None] * parameter_count
+    for raw in raw_inputs:
+        if not isinstance(raw, Mapping):
+            raise ValueError("compiled plane-arena input binding is invalid")
+        parameter_index = raw.get("parameter_index")
+        kind = raw.get("kind")
+        if (
+            isinstance(parameter_index, bool)
+            or not isinstance(parameter_index, int)
+            or not 0 <= parameter_index < parameter_count
+            or inputs[parameter_index] is not None
+            or kind not in {"value", "momentum", "model_parameter"}
+        ):
+            raise ValueError("compiled plane-arena input bindings are inconsistent")
+        inputs[parameter_index] = {
+            "parameter_index": parameter_index,
+            "kind": kind,
+            "source_id": _required_nonnegative_int(raw, "source_id"),
+            "component": _required_nonnegative_int(raw, "component"),
+            "global_component": _required_nonnegative_int(raw, "global_component"),
+            "real_valued": bool(raw.get("real_valued", False)),
+        }
+    if any(binding is None for binding in inputs):
+        raise ValueError("compiled plane-arena input bindings are incomplete")
+
+    raw_slots = stage.get("output_slots")
+    if not isinstance(raw_slots, Sequence) or isinstance(raw_slots, (str, bytes)):
+        raise ValueError("compiled plane-arena output bindings are absent")
+    arena = (
+        "amplitude"
+        if str(stage.get("stage_kind", "")).startswith("amplitude")
+        else "current"
+    )
+    outputs: list[dict[str, object] | None] = [None] * output_length
+    seen_components: set[int] = set()
+    for raw in raw_slots:
+        if not isinstance(raw, Mapping):
+            raise ValueError("compiled plane-arena output slot is invalid")
+        output_start = _required_nonnegative_int(raw, "output_start")
+        output_stop = _required_nonnegative_int(raw, "output_stop")
+        component_start = _required_nonnegative_int(raw, "component_start")
+        component_stop = _required_nonnegative_int(raw, "component_stop")
+        if (
+            output_stop < output_start
+            or component_stop - component_start != output_stop - output_start
+            or output_stop > output_length
+        ):
+            raise ValueError("compiled plane-arena output slot range is invalid")
+        for offset in range(output_stop - output_start):
+            output_index = output_start + offset
+            component = component_start + offset
+            if outputs[output_index] is not None or component in seen_components:
+                raise ValueError("compiled plane-arena output bindings alias")
+            seen_components.add(component)
+            outputs[output_index] = {
+                "output_index": output_index,
+                "arena": arena,
+                "component": component,
+            }
+    if any(binding is None for binding in outputs):
+        raise ValueError("compiled plane-arena output bindings are incomplete")
+
+    return {
+        "schema_version": 1,
+        "kind": "compiled-plane-arena-stage",
+        "application_abi": application_abi,
+        "source_application_abi": source_application_abi,
+        "element_layout": "split-complex-component-major",
+        "output_operation": "overwrite",
+        "output_factor": "identity",
+        "input_output_aliasing": "forbidden",
+        "output_output_aliasing": "forbidden",
+        "input_bindings": inputs,
+        "output_bindings": outputs,
+        "leaves": leaves,
+    }
+
+
+def _compiled_plane_arena_leaves(
+    evaluator: Mapping[str, object],
+    parent_inputs: tuple[int, ...],
+    output_start: int,
+) -> tuple[
+    list[dict[str, object]] | None,
+    int,
+    str | None,
+    str | None,
+]:
+    kind = evaluator.get("kind")
+    if kind == "chunked-symbolica-evaluator":
+        chunks = evaluator.get("chunks")
+        if not isinstance(chunks, Sequence) or isinstance(chunks, (str, bytes)):
+            raise ValueError("compiled chunked evaluator has invalid children")
+        input_len = evaluator.get("input_len")
+        if input_len is not None and input_len != len(parent_inputs):
+            raise ValueError("compiled chunked evaluator input width changed")
+        raw_maps = evaluator.get("chunk_input_indices")
+        if raw_maps is None:
+            input_maps = [parent_inputs] * len(chunks)
+        else:
+            if (
+                not isinstance(raw_maps, Sequence)
+                or isinstance(raw_maps, (str, bytes))
+                or len(raw_maps) != len(chunks)
+            ):
+                raise ValueError("compiled chunk input maps are invalid")
+            input_maps = []
+            for raw_map in raw_maps:
+                if not isinstance(raw_map, Sequence) or isinstance(
+                    raw_map, (str, bytes)
+                ):
+                    raise ValueError("compiled chunk input map is invalid")
+                mapped: list[int] = []
+                for raw_index in raw_map:
+                    if (
+                        isinstance(raw_index, bool)
+                        or not isinstance(raw_index, int)
+                        or not 0 <= raw_index < len(parent_inputs)
+                    ):
+                        raise ValueError(
+                            "compiled chunk input map references an absent input"
+                        )
+                    mapped.append(parent_inputs[raw_index])
+                input_maps.append(tuple(mapped))
+        result: list[dict[str, object]] = []
+        cursor = output_start
+        application_abi: str | None = None
+        source_application_abi: str | None = None
+        for raw_chunk, mapped in zip(chunks, input_maps, strict=True):
+            if not isinstance(raw_chunk, Mapping):
+                raise ValueError("compiled evaluator child is invalid")
+            child, cursor, child_application_abi, child_source_abi = (
+                _compiled_plane_arena_leaves(raw_chunk, mapped, cursor)
+            )
+            if child is None:
+                return None, output_start, None, None
+            if application_abi is None:
+                application_abi = child_application_abi
+                source_application_abi = child_source_abi
+            elif (
+                child_application_abi != application_abi
+                or child_source_abi != source_application_abi
+            ):
+                raise ValueError(
+                    "compiled plane-arena evaluator chunks mix direct ABIs"
+                )
+            result.extend(child)
+        return result, cursor, application_abi, source_application_abi
+
+    if kind == "symjit-application-evaluator":
+        if (
+            evaluator.get("runtime_capability") != SYMJIT_F64_RUNTIME_CAPABILITY
+            or evaluator.get("application_abi") != SYMJIT_APPLICATION_ABI
+            or evaluator.get("element_layout") != "complex-f64"
+            or evaluator.get("batch_layout") != "row-major"
+        ):
+            raise ValueError("compiled SymJIT leaf has an incompatible source ABI")
+        plane = evaluator.get("plane_application")
+        if not isinstance(plane, Mapping):
+            raise ValueError(
+                "compiled SymJIT leaf predates the SymJIT 2.22 plane ABI; "
+                "regenerate this artifact"
+            )
+        if (
+            plane.get("application_abi") != SYMJIT_PLANE_APPLICATION_ABI
+            or plane.get("storage_abi") != SYMJIT_APPLICATION_ABI
+            or plane.get("element_layout") != "split-complex-plane-major"
+            or plane.get("descriptor_order") != "inputs-re-im-then-outputs-re-im"
+        ):
+            raise ValueError("compiled SymJIT leaf has an incompatible plane ABI")
+        application_path = plane.get("application_path")
+        source_application_abi = SYMJIT_PLANE_APPLICATION_ABI
+        application_abi = COMPILED_PLANE_DIRECT_APPLICATION_ABI
+        optimization_level = _required_nonnegative_int(
+            plane,
+            "optimization_level",
+        )
+        direct_codegen_optimization_level = optimization_level
+        if optimization_level not in {0, 1, 2, 3}:
+            raise ValueError(
+                "compiled SymJIT plane-arena optimization level must be 0, 1, 2, or 3"
+            )
+    elif kind == "compiled-complex-evaluator":
+        if evaluator.get("runtime_capability") not in {
+            SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+            SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+        }:
+            raise ValueError(
+                "compiled native leaf has an incompatible runtime capability"
+            )
+        direct = evaluator.get("native_direct_application")
+        if not isinstance(direct, Mapping):
+            raise ValueError(
+                "compiled native leaf has no plane-native DirectApplication"
+            )
+        application_abi = direct.get("application_abi")
+        application_path = direct.get("library_path")
+        source_application_abi = application_abi
+        optimization_level = 3
+        direct_codegen_optimization_level = 3
+        if application_abi != NATIVE_COMPILED_DIRECT_APPLICATION_ABI:
+            raise ValueError("compiled native leaf has an incompatible direct ABI")
+    else:
+        return None, output_start, None, None
+
+    input_len = _required_nonnegative_int(evaluator, "input_len")
+    output_len = _required_nonnegative_int(evaluator, "output_len")
+    if (
+        input_len != len(parent_inputs)
+        or output_len < 1
+        or not isinstance(application_path, str)
+        or not application_path
+    ):
+        raise ValueError("compiled SymJIT leaf metadata is invalid")
+    output_stop = output_start + output_len
+    return (
+        [
+            {
+                "application_path": application_path,
+                "source_application_abi": source_application_abi,
+                "optimization_level": optimization_level,
+                "direct_codegen_optimization_level": (
+                    direct_codegen_optimization_level
+                ),
+                "input_len": input_len,
+                "output_len": output_len,
+                "input_indices": list(parent_inputs),
+                "output_start": output_start,
+                "output_stop": output_stop,
+            }
+        ],
+        output_stop,
+        str(application_abi),
+        str(source_application_abi),
+    )
+
+
+def _required_nonnegative_int(
+    record: Mapping[str, object],
+    name: str,
+) -> int:
+    value = record.get(name)
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise ValueError(f"compiled plane-arena {name.replace('_', ' ')} is invalid")
+    return value
+
+
+def _finalize_stage_evaluator_payload(
+    blueprint: GenericStageCompilerBlueprint,
+    *,
+    stage_payloads: list[dict[str, object]],
+    amplitude_payload: dict[str, object],
+    stage_timings: list[dict[str, object]],
+    build_started: float,
+    total_build_s_override: float | None = None,
+) -> dict[str, object]:
+    stage_local_layout = (
+        blueprint.amplitude_stage.parameter_layout == "stage-local-value-momentum"
+        and all(
+            stage.parameter_layout == "stage-local-value-momentum"
+            for stage in blueprint.stages
+        )
+    )
+    total_build_s = (
+        time.perf_counter() - build_started
+        if total_build_s_override is None
+        else float(total_build_s_override)
+    )
+    jit_compile_s = sum(
+        float(record.get("jit_compile_s") or 0.0) for record in stage_timings
+    )
+    timing_totals: dict[str, object] = {}
+    non_additive_stage_timing_keys = {
+        "output_chunk_autotune_batch_size",
+        "output_chunk_autotune_baseline_size",
+        "output_chunk_autotune_selected_size",
+        "output_chunk_autotune_baseline_us",
+        "output_chunk_autotune_selected_us",
+        "output_chunk_autotune_gain",
+        "output_chunk_autotune_shared_pack_scoring",
+    }
+    for record in stage_timings:
+        for key, value in record.items():
+            if (
+                key == "evaluator_label"
+                or key == "jit_compile_s"
+                or key in non_additive_stage_timing_keys
+            ):
+                continue
+            if isinstance(value, (float, int)):
+                timing_totals[key] = float(timing_totals.get(key, 0.0)) + float(value)
+    timing_totals["stage_evaluator_build_s"] = total_build_s
+    timing_totals["jit_compile_s"] = jit_compile_s
+    timing_totals["jit_fraction_of_stage_evaluator_build"] = (
+        None if total_build_s <= 0.0 else jit_compile_s / total_build_s
+    )
+    timing_totals["stages"] = stage_timings
+    evaluator_manifests = [
+        _dict(payload["evaluator"]) for payload in (*stage_payloads, amplitude_payload)
+    ]
+    required_runtime_capabilities = set(
+        aggregate_runtime_capabilities(evaluator_manifests)
+    )
+    if any(
+        slot.selector_domain_ids or slot.color_selector_domain_ids
+        for stage in (*blueprint.stages, blueprint.amplitude_stage)
+        for slot in stage.output_slots
+    ):
+        required_runtime_capabilities.add(COMPILED_RUNTIME_SELECTORS_CAPABILITY)
+    direct_stage_count = sum(
+        "compiled_plane_arena" in payload
+        for payload in (*stage_payloads, amplitude_payload)
+    )
+    stage_count = len(stage_payloads) + 1
+    requires_direct = bool(
+        required_runtime_capabilities
+        & {
+            SYMJIT_F64_RUNTIME_CAPABILITY,
+            SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+            SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+        }
+    )
+    if requires_direct and direct_stage_count != stage_count:
+        raise ValueError(
+            "compiled f64 artifacts require compiled-plane-arena-v1 metadata "
+            "for every fused stage"
+        )
+    if direct_stage_count:
+        if direct_stage_count != stage_count:
+            raise ValueError(
+                "compiled plane-arena metadata must cover every fused stage"
+            )
+        required_runtime_capabilities.add(COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY)
+    return {
+        "kind": "generic-dag-stage-evaluator-artifacts",
+        "required_runtime_capabilities": sorted(required_runtime_capabilities),
+        "runtime_available": True,
+        "runtime_unavailable_message": None,
+        "parameter_count": 0 if stage_local_layout else blueprint.parameter_count,
+        "value_parameter_count": (
+            0 if stage_local_layout else blueprint.value_parameter_count
+        ),
+        "momentum_parameter_count": (
+            0 if stage_local_layout else blueprint.momentum_parameter_count
+        ),
+        "model_parameter_count": (
+            0 if stage_local_layout else blueprint.model_parameter_count
+        ),
+        "real_valued_inputs": (
+            [] if stage_local_layout else list(blueprint.real_valued_inputs)
+        ),
+        "parameter_layout": (
+            "stage-local-value-momentum"
+            if stage_local_layout
+            else "global-value-momentum"
+        ),
+        "stage_count": blueprint.stage_count,
+        "build_timing": timing_totals,
+        "stages": stage_payloads,
+        "amplitude_stage": amplitude_payload,
+    }
+
+
+def _compile_stage_evaluator_artifact(
+    stage: GenericCompiledStageBlueprint,
+    artifact_dir: Path,
+    *,
+    compiler: StageEvaluatorCompiler | None,
+    blueprint: GenericStageCompilerBlueprint | None,
+    symbolica_settings: Any | None,
+    merge_evaluators_strategy: bool,
+    verbose_evaluator_build: bool,
+    jit_compile: bool,
+    progress_callback: Any | None,
+    current_stage_position: int | None = None,
+    current_stage_count: int | None = None,
+) -> dict[str, object]:
+    if not stage.output_expressions:
+        raise ValueError(
+            f"generic stage {stage.evaluator_label!r} has no output expressions"
+        )
+    started = time.perf_counter()
+    if compiler is not None:
+        manifest = compiler(
+            stage,
+            stage.parameter_symbols,
+            stage.real_valued_inputs,
+        )
+    else:
+        manifest = _compile_default_stage_evaluator(
+            stage,
+            blueprint,
+            artifact_dir,
+            symbolica_settings=symbolica_settings,
+            merge_evaluators_strategy=merge_evaluators_strategy,
+            verbose_evaluator_build=verbose_evaluator_build,
+            jit_compile=jit_compile,
+            progress_callback=progress_callback,
+            current_stage_position=current_stage_position,
+            current_stage_count=current_stage_count,
+        )
+    if not isinstance(manifest, dict):
+        raise TypeError(
+            f"generic stage compiler for {stage.evaluator_label!r} "
+            "did not return a manifest dictionary"
+        )
+    build_s = time.perf_counter() - started
+    manifest.setdefault("build_timing", {})
+    timing = manifest["build_timing"]
+    if isinstance(timing, dict):
+        previous_stage_build_s = timing.get("stage_evaluator_build_s")
+        timing["stage_evaluator_build_s"] = build_s
+        if previous_stage_build_s is not None:
+            timing["stage_compiler_wrapper_s"] = build_s - float(previous_stage_build_s)
+        timing.setdefault("symbolica_evaluator_build_s", build_s)
+        if _manifest_uses_jit_evaluator(manifest):
+            timing.setdefault("jit_compile_s", build_s)
+    return manifest
+
+
+def build_and_write_generic_stage_evaluator_artifacts(
+    manifest: StageCompilationInput | GenericDAG,
+    runtime_schema: Mapping[str, object],
+    artifact_dir: str | Path,
+    *,
+    model: Model | None = None,
+    enable_lc_sector_runtime_selector: bool | None = None,
+    stage_local_parameter_layout: bool = True,
+    compiler: StageEvaluatorCompiler | None = None,
+    symbolica_settings: Any | None = None,
+    merge_evaluators_strategy: bool = False,
+    verbose_evaluator_build: bool = False,
+    jit_compile: bool = True,
+    blueprint_progress_callback: StageBlueprintProgress | None = None,
+    evaluator_progress_callback: Any | None = None,
+) -> tuple[GenericStageCompilerBlueprint, dict[str, object]]:
+    """Lower, compile, and release one recursion stage at a time."""
+
+    output_dir = Path(artifact_dir).expanduser()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    schema = _dict(runtime_schema)
+    current_stage_count = len(_list(schema["stages"]))
+    stage_count = current_stage_count + 1
+    build_started = time.perf_counter()
+    if evaluator_progress_callback is not None:
+        evaluator_progress_callback(
+            {
+                "stage": "stage compile",
+                "item": "start",
+                "total": stage_count,
+                "step": "evaluator compilation",
+                "stage_total": stage_count,
+            }
+        )
+
+    stage_payloads: list[dict[str, object]] = []
+    amplitude_payload: dict[str, object] | None = None
+    stage_timings: list[dict[str, object]] = []
+
+    def consume_stage(
+        stage: GenericCompiledStageBlueprint,
+        position: int,
+        reported_current_stage_count: int,
+    ) -> None:
+        nonlocal amplitude_payload
+        if reported_current_stage_count != current_stage_count:
+            raise ValueError("streamed stage count changed during blueprint lowering")
+        if not stage.expression_ready:
+            raise ValueError(
+                "cannot write generic evaluator artifact with lowering blockers: "
+                + "; ".join(stage.blockers)
+            )
+        prepared_stage = _prepare_stage_for_output_chunking(
+            stage,
+            blueprint=None,
+            symbolica_settings=symbolica_settings,
+            current_stage_position=position,
+            current_stage_count=current_stage_count,
+        )
+        payload = prepared_stage.to_json_dict()
+        payload["evaluator"] = _compile_stage_evaluator_artifact(
+            prepared_stage,
+            output_dir,
+            compiler=compiler,
+            blueprint=None,
+            symbolica_settings=symbolica_settings,
+            merge_evaluators_strategy=merge_evaluators_strategy,
+            verbose_evaluator_build=verbose_evaluator_build,
+            jit_compile=jit_compile,
+            progress_callback=evaluator_progress_callback,
+            current_stage_position=position,
+            current_stage_count=current_stage_count,
+        )
+        direct = _compiled_plane_arena_stage(payload)
+        if direct is not None:
+            payload["compiled_plane_arena"] = direct
+        timing = _stage_build_timing_record(
+            prepared_stage.evaluator_label,
+            payload["evaluator"],
+        )
+        stage_timings.append(timing)
+        if str(prepared_stage.stage_kind).startswith("amplitude"):
+            amplitude_payload = payload
+        else:
+            stage_payloads.append(payload)
+        if evaluator_progress_callback is not None:
+            evaluator_progress_callback(
+                {
+                    "stage": "stage complete",
+                    "item": prepared_stage.evaluator_label,
+                    "increment": 1,
+                    "total": stage_count,
+                    "duration_s": timing["stage_evaluator_build_s"],
+                    "step": "stage complete",
+                    "stage_index": position + 1,
+                    "stage_total": stage_count,
+                    "subset_size": prepared_stage.subset_size,
+                    "interaction_count": len(prepared_stage.interaction_ids),
+                    "input_count": prepared_stage.parameter_count,
+                    "output_count": prepared_stage.output_length,
+                }
+            )
+
+    blueprint = build_generic_stage_compiler_blueprint(
+        manifest,
+        model=model,
+        enable_lc_sector_runtime_selector=enable_lc_sector_runtime_selector,
+        runtime_schema=schema,
+        stage_local_parameter_layout=stage_local_parameter_layout,
+        progress_callback=blueprint_progress_callback,
+        stage_consumer=consume_stage,
+        release_consumed_expressions=True,
+    )
+    if amplitude_payload is None or len(stage_payloads) != current_stage_count:
+        raise ValueError("streamed stage compilation produced incomplete metadata")
+    return blueprint, _finalize_stage_evaluator_payload(
+        blueprint,
+        stage_payloads=stage_payloads,
+        amplitude_payload=amplitude_payload,
+        stage_timings=stage_timings,
+        build_started=build_started,
+        total_build_s_override=sum(
+            float(timing["stage_evaluator_build_s"]) for timing in stage_timings
+        ),
+    )
+
+
+def _stage_build_timing_record(
+    evaluator_label: str,
+    evaluator_manifest: object,
+) -> dict[str, object]:
+    manifest = evaluator_manifest if isinstance(evaluator_manifest, dict) else {}
+    raw_timing = manifest.get("build_timing") if isinstance(manifest, dict) else None
+    timing = raw_timing if isinstance(raw_timing, dict) else {}
+    record: dict[str, object] = {
+        "evaluator_label": evaluator_label,
+        "stage_evaluator_build_s": float(timing.get("stage_evaluator_build_s") or 0.0),
+        "symbolica_evaluator_build_s": float(
+            timing.get("symbolica_evaluator_build_s") or 0.0
+        ),
+        "jit_compile_s": (
+            None
+            if timing.get("jit_compile_s") is None
+            else float(timing.get("jit_compile_s") or 0.0)
+        ),
+    }
+    for key, value in timing.items():
+        if key in record:
+            continue
+        if isinstance(value, (float, int)):
+            record[str(key)] = float(value)
+    return record
+
+
+def _manifest_uses_jit_evaluator(manifest: Mapping[str, object]) -> bool:
+    if str(manifest.get("kind", "")) in {
+        "jit-symbolica-evaluator",
+        "symjit-application-evaluator",
+    }:
+        return True
+    if str(manifest.get("kind", "")) == "chunked-symbolica-evaluator":
+        chunks = manifest.get("chunks")
+        if isinstance(chunks, Sequence) and chunks:
+            return all(
+                isinstance(chunk, Mapping) and _manifest_uses_jit_evaluator(chunk)
+                for chunk in chunks
+            )
+    settings = manifest.get("settings")
+    if isinstance(settings, Mapping):
+        return str(settings.get("backend", "")) == "jit"
+    return False
+
+
+def _compile_default_stage_evaluator(
+    stage: GenericCompiledStageBlueprint,
+    blueprint: GenericStageCompilerBlueprint | None,
+    artifact_dir: Path,
+    *,
+    symbolica_settings: Any | None,
+    merge_evaluators_strategy: bool,
+    verbose_evaluator_build: bool,
+    jit_compile: bool,
+    progress_callback: Any | None,
+    current_stage_position: int | None = None,
+    current_stage_count: int | None = None,
+) -> dict[str, object]:
+    from ..evaluators.symbolica import (
+        SymbolicaEvaluatorSettings,
+        _compile_symbolica_outputs,
+        _symbolica_evaluator_artifact_manifest,
+    )
+
+    settings = _stage_symbolica_settings(
+        stage,
+        blueprint,
+        symbolica_settings or SymbolicaEvaluatorSettings(),
+        current_stage_position=current_stage_position,
+        current_stage_count=current_stage_count,
+    )
+    symbolica_started = time.perf_counter()
+    params = list(stage.parameter_symbols)
+
+    def compile_with(candidate_settings: Any, candidate_label: str) -> Any:
+        return _compile_symbolica_outputs(
+            stage.output_expressions,
+            params,
+            merge_evaluators_strategy=merge_evaluators_strategy,
+            verbose_evaluator_build=verbose_evaluator_build,
+            real_params=stage.real_valued_inputs,
+            symbolica_settings=candidate_settings,
+            jit_compile=jit_compile,
+            label=candidate_label,
+            progress_callback=progress_callback,
+            functions={
+                (function, arguments): body
+                for function, arguments, body in stage.symbolica_functions
+            },
+            output_partitions=stage.selector_output_partitions,
+            native_direct_only=(
+                getattr(candidate_settings, "backend", None) == "compiled-complex"
+                and stage.parameter_layout == "stage-local-value-momentum"
+            ),
+        )
+
+    autotune_timing: dict[str, float] = {}
+    if getattr(settings, "output_chunk_strategy", "uniform") == "measured-stage":
+        evaluator, autotune_timing = _compile_measured_stage_output_chunks(
+            settings=settings,
+            output_count=len(stage.output_expressions),
+            parameter_count=len(params),
+            real_params=stage.real_valued_inputs,
+            label=stage.evaluator_label,
+            compile_with=compile_with,
+            progress_callback=progress_callback,
+            jit_compile=jit_compile,
+        )
+    else:
+        evaluator = compile_with(settings, stage.evaluator_label)
+    _compile_native_stage_direct_applications(
+        evaluator,
+        stage,
+        settings,
+    )
+    symbolica_build_s = time.perf_counter() - symbolica_started
+    artifact_started = time.perf_counter()
+    manifest = _symbolica_evaluator_artifact_manifest(evaluator, artifact_dir)
+    artifact_manifest_s = time.perf_counter() - artifact_started
+    timing = manifest.setdefault("build_timing", {})
+    if isinstance(timing, dict):
+        timing.update(autotune_timing)
+        timing["symbolica_evaluator_build_s"] = symbolica_build_s
+        timing["artifact_manifest_s"] = artifact_manifest_s
+        timing["stage_evaluator_build_s"] = symbolica_build_s + artifact_manifest_s
+    return manifest
+
+
+def _compile_native_stage_direct_applications(
+    evaluator: Any,
+    stage: GenericCompiledStageBlueprint,
+    settings: Any,
+) -> None:
+    """Produce the direct-only native companion before serialization."""
+
+    if getattr(settings, "backend", None) != "compiled-complex":
+        return
+    if stage.parameter_layout != "stage-local-value-momentum":
+        return
+    from ..evaluators.native_direct_cpp import NativeDirectCppParameterKind
+    from ..evaluators.symbolica_adapters import (
+        compile_native_direct_applications,
+    )
+    from ..models.prepared_target import native_prepared_target
+
+    components: list[object | None] = [None] * stage.parameter_count
+    for component in stage.input_components:
+        if (
+            component.parameter_index >= len(components)
+            or components[component.parameter_index] is not None
+        ):
+            raise ValueError(
+                "native DirectApplication stage input bindings are invalid"
+            )
+        if component.kind == "model_parameter":
+            kind = (
+                NativeDirectCppParameterKind.REAL_SCALAR
+                if component.real_valued
+                else NativeDirectCppParameterKind.COMPLEX_SCALAR
+            )
+        else:
+            kind = (
+                NativeDirectCppParameterKind.REAL_PLANE
+                if component.real_valued
+                else NativeDirectCppParameterKind.COMPLEX_PLANE
+            )
+        components[component.parameter_index] = kind
+    if any(component is None for component in components):
+        missing = tuple(
+            index for index, component in enumerate(components) if component is None
+        )
+        raise ValueError(
+            "native DirectApplication stage input bindings are incomplete: "
+            f"stage={stage.evaluator_label!r}, parameter_count="
+            f"{stage.parameter_count}, input_component_count="
+            f"{len(stage.input_components)}, missing_parameter_indices={missing!r}"
+        )
+
+    include_features = bool(getattr(settings, "compiled_native", False))
+    target = native_prepared_target(include_cpu_features=include_features)
+    target_triple = str(target["target_triple"])
+    cpu_features = tuple(str(item) for item in target["cpu_features"])
+    simd_lane_width = (
+        4 if target_triple.startswith("x86_64") and "avx2" in cpu_features else 2
+    )
+    if not compile_native_direct_applications(
+        evaluator,
+        components,
+        target_triple=target_triple,
+        cpu_features=cpu_features,
+        simd_lane_width=simd_lane_width,
+    ):
+        raise ValueError(
+            "compiled native stage did not produce a plane-native DirectApplication"
+        )
+
+
+def _compile_measured_stage_output_chunks(
+    *,
+    settings: Any,
+    output_count: int,
+    parameter_count: int,
+    real_params: Sequence[int],
+    label: str,
+    compile_with: Callable[[Any, str], Any],
+    progress_callback: Any | None,
+    jit_compile: bool,
+) -> tuple[Any, dict[str, float]]:
+    base = getattr(settings, "compiled_output_chunk_size", None)
+    if base is None or getattr(settings, "backend", None) != "jit" or not jit_compile:
+        uniform = replace(settings, output_chunk_strategy="uniform")
+        return compile_with(uniform, label), {}
+
+    requested_sizes = (
+        int(base),
+        max(1, int(base) // 2),
+        max(1, 3 * int(base) // 4),
+        max(1, 3 * int(base) // 2),
+        int(base) * 2,
+        None,
+    )
+    effective_sizes: list[int | None] = []
+    for requested in requested_sizes:
+        effective = (
+            None
+            if requested is None or output_count <= int(requested)
+            else int(requested)
+        )
+        if effective not in effective_sizes:
+            effective_sizes.append(effective)
+    baseline_size = None if output_count <= int(base) else int(base)
+
+    started = time.perf_counter()
+    candidates: dict[int | None, Any] = {}
+    for chunk_size in effective_sizes:
+        suffix = "none" if chunk_size is None else str(chunk_size)
+        candidate_settings = replace(
+            settings,
+            compiled_output_chunk_size=chunk_size,
+            output_chunk_strategy="uniform",
+        )
+        candidate_label = (
+            label if chunk_size == baseline_size else f"{label}_autotune_chunk_{suffix}"
+        )
+        candidates[chunk_size] = compile_with(candidate_settings, candidate_label)
+
+    autotune_batch_size = int(
+        getattr(settings, "output_chunk_autotune_batch_size", 128)
+    )
+    rows = np.full(
+        (autotune_batch_size, parameter_count),
+        complex(0.75, 0.125),
+        dtype=np.complex128,
+    )
+    if real_params:
+        rows[:, list(real_params)] = 0.75
+
+    materialize_started = time.perf_counter()
+    for evaluator in candidates.values():
+        evaluator.evaluate_complex(rows)
+    materialize_s = time.perf_counter() - materialize_started
+
+    shared_pack_scoring = all(
+        bool(getattr(evaluator, "supports_complex_profiled", lambda: False)())
+        for evaluator in candidates.values()
+    )
+
+    def score_candidate(evaluator: Any) -> float:
+        if shared_pack_scoring:
+            _output, profile = evaluator.evaluate_complex_profiled(rows)
+            return max(sum(float(value) for value in profile), 1.0e-9)
+        probe_started = time.perf_counter()
+        evaluator.evaluate_complex(rows)
+        return max(time.perf_counter() - probe_started, 1.0e-6)
+
+    benchmark_started = time.perf_counter()
+    scores: dict[int | None, float] = {}
+    repeats: dict[int | None, int] = {}
+    for chunk_size, evaluator in candidates.items():
+        probe_s = max(score_candidate(evaluator), 1.0e-6)
+        repeats[chunk_size] = max(1, min(256, int(0.01 / probe_s)))
+        scores[chunk_size] = probe_s
+
+    samples: dict[int | None, list[float]] = {
+        chunk_size: [] for chunk_size in candidates
+    }
+    ordered_sizes = list(candidates)
+    for round_index in range(5):
+        rotated = ordered_sizes[round_index:] + ordered_sizes[:round_index]
+        for chunk_size in rotated:
+            evaluator = candidates[chunk_size]
+            count = repeats[chunk_size]
+            if shared_pack_scoring:
+                samples[chunk_size].append(
+                    sum(score_candidate(evaluator) for _ in range(count)) / count
+                )
+            else:
+                sample_started = time.perf_counter()
+                for _ in range(count):
+                    evaluator.evaluate_complex(rows)
+                samples[chunk_size].append(
+                    (time.perf_counter() - sample_started) / count
+                )
+    scores = {
+        chunk_size: sorted(values)[len(values) // 2]
+        for chunk_size, values in samples.items()
+    }
+    benchmark_s = time.perf_counter() - benchmark_started
+    selected_size = _select_measured_chunk_candidate(
+        scores,
+        baseline_size=baseline_size,
+        minimum_gain=0.05,
+    )
+    selected = candidates[selected_size]
+    baseline_score = scores[baseline_size]
+    selected_score = scores[selected_size]
+    autotune_s = time.perf_counter() - started
+    if progress_callback is not None:
+        progress_callback(
+            {
+                "stage": "chunk autotune",
+                "item": (
+                    f"{label} base={baseline_size or 'none'} "
+                    f"selected={selected_size or 'none'} "
+                    f"gain={(1.0 - selected_score / baseline_score):.1%}"
+                    + (" shared-pack" if shared_pack_scoring else "")
+                ),
+            }
+        )
+    evaluator_timing = getattr(selected, "build_timing", None)
+    if isinstance(evaluator_timing, dict):
+        evaluator_timing.update(
+            {
+                "output_chunk_autotune_s": autotune_s,
+                "output_chunk_autotune_materialize_s": materialize_s,
+                "output_chunk_autotune_benchmark_s": benchmark_s,
+                "output_chunk_autotune_candidate_count": float(len(candidates)),
+                "output_chunk_autotune_batch_size": float(autotune_batch_size),
+                "output_chunk_autotune_baseline_size": float(baseline_size or 0),
+                "output_chunk_autotune_selected_size": float(selected_size or 0),
+                "output_chunk_autotune_baseline_us": baseline_score * 1.0e6,
+                "output_chunk_autotune_selected_us": selected_score * 1.0e6,
+                "output_chunk_autotune_gain": 1.0 - selected_score / baseline_score,
+                "output_chunk_autotune_shared_pack_scoring": float(shared_pack_scoring),
+            }
+        )
+    return selected, {
+        "output_chunk_autotune_s": autotune_s,
+        "output_chunk_autotune_materialize_s": materialize_s,
+        "output_chunk_autotune_benchmark_s": benchmark_s,
+        "output_chunk_autotune_candidate_count": float(len(candidates)),
+        "output_chunk_autotune_batch_size": float(autotune_batch_size),
+        "output_chunk_autotune_baseline_size": float(baseline_size or 0),
+        "output_chunk_autotune_selected_size": float(selected_size or 0),
+        "output_chunk_autotune_baseline_us": baseline_score * 1.0e6,
+        "output_chunk_autotune_selected_us": selected_score * 1.0e6,
+        "output_chunk_autotune_gain": 1.0 - selected_score / baseline_score,
+        "output_chunk_autotune_shared_pack_scoring": float(shared_pack_scoring),
+    }
+
+
+def _select_measured_chunk_candidate(
+    scores: Mapping[int | None, float],
+    *,
+    baseline_size: int | None,
+    minimum_gain: float,
+) -> int | None:
+    if baseline_size not in scores:
+        raise ValueError("measured chunk scores do not include the baseline")
+    best_size = min(scores, key=scores.__getitem__)
+    if scores[best_size] <= scores[baseline_size] * (1.0 - minimum_gain):
+        return best_size
+    return baseline_size
diff --git a/pyamplicol/src/pyamplicol/generation/stage_compiler.py b/pyamplicol/src/pyamplicol/generation/stage_compiler.py
new file mode 100644
index 0000000000..28566078cd
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/stage_compiler.py
@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: 0BSD
+"""Compatibility facade for stage blueprint and evaluator compilation."""
+
+from __future__ import annotations
+
+from .stage_artifacts import (
+    build_and_write_generic_stage_evaluator_artifacts,
+    write_generic_stage_evaluator_artifacts,
+    write_model_parameter_evaluator_artifact,
+)
+from .stage_planning import (
+    _fanout_aware_current_order as _fanout_aware_current_order,
+)
+from .stage_planning import (
+    build_generic_stage_compiler_blueprint,
+)
+from .stage_types import (
+    GenericCompiledStageBlueprint,
+    GenericStageCompilerBlueprint,
+    GenericStageInputComponent,
+    GenericStageOutputSlot,
+)
+
+__all__ = [
+    "GenericCompiledStageBlueprint",
+    "GenericStageCompilerBlueprint",
+    "GenericStageInputComponent",
+    "GenericStageOutputSlot",
+    "build_and_write_generic_stage_evaluator_artifacts",
+    "build_generic_stage_compiler_blueprint",
+    "write_generic_stage_evaluator_artifacts",
+    "write_model_parameter_evaluator_artifact",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/stage_expressions.py b/pyamplicol/src/pyamplicol/generation/stage_expressions.py
new file mode 100644
index 0000000000..7b15e5d294
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/stage_expressions.py
@@ -0,0 +1,713 @@
+# SPDX-License-Identifier: 0BSD
+"""Symbolic expression construction for current and amplitude stages."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from ..models._physics_ir import ContractionIR, PropagatorIR
+from ..models.base import Model
+from ..models.expressions import _exact_complex_expression
+from .contracts import (
+    runtime_coupling_parameter_names as _runtime_coupling_parameter_names,
+)
+from .dag_types import GenericDAG
+from .stage_parameters import (
+    _amplitude_stage_model_parameter_records,
+    _contract_components,
+    _coupling,
+    _current_stage_model_parameter_records,
+    _dict,
+    _expression_previews,
+    _global_stage_inputs,
+    _list,
+    _model_symbolica_functions,
+    _momentum_components,
+    _project_components,
+    _runtime_coupling,
+    _specialize_stage_symbolica_functions,
+    _stage_input_momentum_slot_ids,
+    _stage_local_inputs,
+    _sum_components,
+    _value_components,
+)
+from .stage_types import (
+    GenericCompiledStageBlueprint,
+    GenericStageOutputSlot,
+    _RuntimeParameterizedModel,
+)
+
+
+def _compile_current_stage_blueprint(
+    dag: GenericDAG,
+    model: Model,
+    stage: dict[str, Any],
+    *,
+    value_slots: dict[int, dict[str, Any]],
+    current_slots: dict[int, dict[str, Any]],
+    momentum_slots: dict[int, dict[str, Any]],
+    global_value_component_count: int,
+    global_momentum_parameter_count: int,
+    model_parameter_records: Sequence[dict[str, Any]],
+    global_parameter_symbols: Sequence[Any],
+    global_value_symbols: Sequence[Any],
+    global_momentum_symbols: Sequence[Any],
+    global_model_parameter_symbols: Mapping[str, Any],
+    global_real_valued_inputs: Sequence[int],
+    stage_local_parameter_layout: bool,
+) -> GenericCompiledStageBlueprint:
+    blockers: list[str] = []
+    outputs: list[Any] = []
+    output_slots: list[GenericStageOutputSlot] = []
+    interactions_compacted = bool(stage.get("interactions_compacted", False))
+    interactions = (
+        []
+        if interactions_compacted
+        else [_dict(item) for item in _list(stage["interactions"])]
+    )
+    interaction_ids = (
+        tuple(int(value) for value in _list(stage.get("interaction_ids", [])))
+        if interactions_compacted
+        else tuple(int(interaction["interaction_id"]) for interaction in interactions)
+    )
+    input_value_slot_ids = tuple(
+        int(value) for value in _list(stage["input_value_slot_ids"])
+    )
+    input_momentum_slot_ids = (
+        tuple(int(value) for value in _list(stage.get("input_momentum_slot_ids", [])))
+        if interactions_compacted
+        else _stage_input_momentum_slot_ids(interactions)
+    )
+    output_slot_ids = tuple(
+        int(value) for value in _list(stage["output_value_slot_ids"])
+    )
+    output_slots_by_current: dict[int, list[dict[str, Any]]] = {}
+    for slot_id in output_slot_ids:
+        slot = value_slots[int(slot_id)]
+        output_slots_by_current.setdefault(int(slot["current_id"]), []).append(slot)
+    stage_model_parameter_records = (
+        _current_stage_model_parameter_records(
+            model,
+            model_parameter_records,
+            dag=dag,
+            interactions=interactions,
+            interaction_ids=interaction_ids,
+            output_slots_by_current=output_slots_by_current,
+            current_slots=current_slots,
+        )
+        if stage_local_parameter_layout
+        else model_parameter_records
+    )
+    local_inputs = (
+        _stage_local_inputs(
+            value_slot_ids=input_value_slot_ids,
+            momentum_slot_ids=input_momentum_slot_ids,
+            value_slots=value_slots,
+            momentum_slots=momentum_slots,
+            global_value_component_count=global_value_component_count,
+            global_momentum_parameter_count=global_momentum_parameter_count,
+            model_parameter_records=stage_model_parameter_records,
+        )
+        if stage_local_parameter_layout
+        else _global_stage_inputs(
+            parameter_symbols=global_parameter_symbols,
+            value_symbols=global_value_symbols,
+            momentum_symbols=global_momentum_symbols,
+            model_parameter_symbols=global_model_parameter_symbols,
+            value_parameter_count=global_value_component_count,
+            momentum_parameter_count=len(global_momentum_symbols),
+            model_parameter_count=len(model_parameter_records),
+            real_valued_inputs=global_real_valued_inputs,
+        )
+    )
+    stage_model = (
+        model.with_runtime_parameters(local_inputs.model_parameter_symbols)
+        if hasattr(model, "with_runtime_parameters")
+        else _RuntimeParameterizedModel(model, local_inputs.model_parameter_symbols)
+    )
+    interactions_by_result: dict[int, list[dict[str, Any] | int]] = {}
+    if interactions_compacted:
+        for interaction_id in interaction_ids:
+            interactions_by_result.setdefault(
+                int(dag.interactions[interaction_id].result_id),
+                [],
+            ).append(interaction_id)
+    else:
+        for interaction in interactions:
+            interactions_by_result.setdefault(
+                int(interaction["result_current_id"]),
+                [],
+            ).append(interaction)
+    value_components_by_slot_id = {
+        int(slot_id): _value_components(
+            value_slots[int(slot_id)],
+            local_inputs.value_symbols,
+        )
+        for slot_id in input_value_slot_ids
+    }
+    momentum_components_by_slot_id = {
+        int(slot_id): _momentum_components(
+            int(slot_id),
+            local_inputs.momentum_symbols,
+            momentum_slots,
+            by_slot_id=True,
+        )
+        for slot_id in input_momentum_slot_ids
+    }
+    momentum_components_by_mask = {
+        int(slot["momentum_mask"]): momentum_components_by_slot_id[int(slot_id)]
+        for slot_id, slot in momentum_slots.items()
+        if int(slot_id) in momentum_components_by_slot_id
+    }
+    input_value_slot_by_current_id = {
+        int(value_slots[slot_id]["current_id"]): int(slot_id)
+        for slot_id in input_value_slot_ids
+    }
+    momentum_slot_by_mask = {
+        int(slot["momentum_mask"]): int(slot_id)
+        for slot_id, slot in momentum_slots.items()
+    }
+    compact_coupling_cache: dict[
+        tuple[int, tuple[int, ...], tuple[float, ...]],
+        tuple[Any, Any],
+    ] = {}
+    compact_evaluation_cache: dict[int, tuple[Any, ...]] = {}
+    evaluation_groups_by_current = tuple(
+        (
+            current_id,
+            tuple(
+                sorted(
+                    {
+                        (
+                            int(interaction.evaluation_group_id)
+                            if interaction.evaluation_group_id is not None
+                            else -(interaction.id + 1)
+                        )
+                        for interaction_item in interactions_by_result[current_id]
+                        for interaction in (
+                            dag.interactions[
+                                _interaction_item_id(
+                                    interaction_item,
+                                    compacted=interactions_compacted,
+                                )
+                            ],
+                        )
+                        if interaction.evaluation_factor != (0.0, 0.0)
+                    }
+                )
+            ),
+        )
+        for current_id in sorted(interactions_by_result)
+    )
+
+    for current_id in sorted(interactions_by_result):
+        current_slot = current_slots[current_id]
+        dimension = int(current_slot["dimension"])
+        total = tuple(0j for _ in range(dimension))
+        for interaction_item in interactions_by_result[current_id]:
+            interaction_id = _interaction_item_id(
+                interaction_item,
+                compacted=interactions_compacted,
+            )
+            try:
+                contribution = _compact_interaction_contribution(
+                    dag,
+                    stage_model,
+                    interaction_id,
+                    value_components_by_slot_id=value_components_by_slot_id,
+                    input_value_slot_by_current_id=input_value_slot_by_current_id,
+                    momentum_components_by_slot_id=momentum_components_by_slot_id,
+                    momentum_slot_by_mask=momentum_slot_by_mask,
+                    model_parameter_symbols=local_inputs.model_parameter_symbols,
+                    coupling_cache=compact_coupling_cache,
+                    evaluation_cache=compact_evaluation_cache,
+                )
+            except ValueError as error:
+                blockers.append(f"interaction {interaction_id}: {error}")
+                continue
+            total = _sum_components(total, contribution)
+        result_slots = output_slots_by_current.get(current_id, ())
+        for slot in result_slots:
+            variant = str(slot["variant"])
+            try:
+                components = (
+                    stage_model.propagator_component_expression(
+                        int(current_slot["particle_id"]),
+                        total,
+                        momentum_components_by_mask[int(current_slot["momentum_mask"])],
+                        chirality=int(current_slot["chirality"]),
+                        propagator=PropagatorIR.from_json_dict(
+                            _dict(slot["propagator"])
+                        ),
+                    )
+                    if variant == "propagated"
+                    else total
+                )
+            except ValueError as error:
+                blockers.append(f"value slot {slot['value_slot_id']}: {error}")
+                continue
+            start = len(outputs)
+            outputs.extend(components)
+            output_slots.append(
+                GenericStageOutputSlot(
+                    value_slot_id=int(slot["value_slot_id"]),
+                    current_id=current_id,
+                    variant=variant,
+                    component_start=int(slot["component_start"]),
+                    component_stop=int(slot["component_stop"]),
+                    output_start=start,
+                    output_stop=len(outputs),
+                )
+            )
+
+    specialized_outputs, symbolica_functions = _specialize_stage_symbolica_functions(
+        outputs,
+        _model_symbolica_functions(stage_model),
+    )
+    return GenericCompiledStageBlueprint(
+        stage_index=int(stage["stage_index"]),
+        stage_kind=str(stage["stage_kind"]),
+        subset_size=int(stage["subset_size"]),
+        evaluator_label=(
+            f"generic_stage_{int(stage['stage_index'])}_subset_{int(stage['subset_size'])}"
+        ),
+        parameter_layout=(
+            "stage-local-value-momentum"
+            if stage_local_parameter_layout
+            else "global-value-momentum"
+        ),
+        output_length=len(outputs),
+        output_slots=tuple(output_slots),
+        input_value_slot_ids=input_value_slot_ids,
+        output_value_slot_ids=output_slot_ids,
+        interaction_ids=interaction_ids,
+        input_components=local_inputs.input_components,
+        parameter_count=len(local_inputs.parameter_symbols),
+        value_parameter_count=local_inputs.value_parameter_count,
+        momentum_parameter_count=local_inputs.momentum_parameter_count,
+        model_parameter_count=local_inputs.model_parameter_count,
+        real_valued_inputs=local_inputs.real_valued_inputs,
+        expression_ready=not blockers,
+        blockers=tuple(blockers),
+        first_output_previews=_expression_previews(specialized_outputs),
+        evaluation_groups_by_current=evaluation_groups_by_current,
+        parameter_symbols=local_inputs.parameter_symbols,
+        output_expressions=specialized_outputs,
+        symbolica_functions=symbolica_functions,
+    )
+
+
+def _compile_amplitude_stage_blueprint(
+    model: Model,
+    stage: dict[str, Any],
+    *,
+    value_slots: dict[int, dict[str, Any]],
+    global_value_component_count: int,
+    global_momentum_parameter_count: int,
+    model_parameter_records: Sequence[dict[str, Any]],
+    global_parameter_symbols: Sequence[Any],
+    global_value_symbols: Sequence[Any],
+    global_model_parameter_symbols: Mapping[str, Any],
+    global_real_valued_inputs: Sequence[int],
+    stage_local_parameter_layout: bool,
+) -> GenericCompiledStageBlueprint:
+    blockers: list[str] = []
+    outputs: list[Any] = []
+    output_slots: list[GenericStageOutputSlot] = []
+    input_value_slot_ids = tuple(
+        sorted(
+            {
+                int(root[side]["value_slot_id"])
+                for root in (_dict(item) for item in _list(stage["roots"]))
+                for side in ("left_value_slot", "right_value_slot")
+            }
+        )
+    )
+    local_inputs = (
+        _stage_local_inputs(
+            value_slot_ids=input_value_slot_ids,
+            momentum_slot_ids=(),
+            value_slots=value_slots,
+            momentum_slots={},
+            global_value_component_count=global_value_component_count,
+            global_momentum_parameter_count=global_momentum_parameter_count,
+            model_parameter_records=(
+                _amplitude_stage_model_parameter_records(
+                    model_parameter_records,
+                    roots=tuple(_dict(item) for item in _list(stage["roots"])),
+                )
+                if stage_local_parameter_layout
+                else model_parameter_records
+            ),
+        )
+        if stage_local_parameter_layout
+        else _global_stage_inputs(
+            parameter_symbols=global_parameter_symbols,
+            value_symbols=global_value_symbols,
+            momentum_symbols=(),
+            model_parameter_symbols=global_model_parameter_symbols,
+            value_parameter_count=global_value_component_count,
+            momentum_parameter_count=0,
+            model_parameter_count=len(model_parameter_records),
+            real_valued_inputs=global_real_valued_inputs,
+        )
+    )
+    stage_model = (
+        model.with_runtime_parameters(local_inputs.model_parameter_symbols)
+        if hasattr(model, "with_runtime_parameters")
+        else _RuntimeParameterizedModel(model, local_inputs.model_parameter_symbols)
+    )
+    for root in (_dict(item) for item in _list(stage["roots"])):
+        try:
+            output = _amplitude_root_expression(
+                stage_model,
+                root,
+                value_symbols=local_inputs.value_symbols,
+                model_parameter_symbols=local_inputs.model_parameter_symbols,
+                value_slots=value_slots,
+            )
+        except (TypeError, ValueError) as error:
+            blockers.append(f"amplitude root {root['root_id']}: {error}")
+            continue
+        start = len(outputs)
+        outputs.append(output)
+        output_slots.append(
+            GenericStageOutputSlot(
+                value_slot_id=-1,
+                current_id=-1,
+                variant="amplitude-root",
+                component_start=int(root["output_index"]),
+                component_stop=int(root["output_index"]) + 1,
+                output_start=start,
+                output_stop=len(outputs),
+            )
+        )
+    return GenericCompiledStageBlueprint(
+        stage_index=0,
+        stage_kind=str(stage["stage_kind"]),
+        subset_size=None,
+        evaluator_label="generic_amplitude_stage",
+        parameter_layout=(
+            "stage-local-value-momentum"
+            if stage_local_parameter_layout
+            else "global-value-momentum"
+        ),
+        output_length=len(outputs),
+        output_slots=tuple(output_slots),
+        input_value_slot_ids=input_value_slot_ids,
+        output_value_slot_ids=(),
+        interaction_ids=(),
+        input_components=local_inputs.input_components,
+        parameter_count=len(local_inputs.parameter_symbols),
+        value_parameter_count=local_inputs.value_parameter_count,
+        momentum_parameter_count=local_inputs.momentum_parameter_count,
+        model_parameter_count=local_inputs.model_parameter_count,
+        real_valued_inputs=local_inputs.real_valued_inputs,
+        expression_ready=not blockers,
+        blockers=tuple(blockers),
+        first_output_previews=_expression_previews(outputs),
+        parameter_symbols=local_inputs.parameter_symbols,
+        output_expressions=tuple(outputs),
+    )
+
+
+def _interaction_contribution(
+    dag: GenericDAG,
+    model: Model,
+    interaction: dict[str, Any],
+    *,
+    value_components_by_slot_id: Mapping[int, tuple[Any, ...]],
+    momentum_components_by_slot_id: Mapping[int, tuple[Any, ...]],
+    model_parameter_symbols: Mapping[str, Any],
+) -> tuple[Any, ...]:
+    left_slot = _dict(interaction["left_value_slot"])
+    right_slot = _dict(interaction["right_value_slot"])
+    left = value_components_by_slot_id[int(left_slot["value_slot_id"])]
+    right = value_components_by_slot_id[int(right_slot["value_slot_id"])]
+    momenta = _dict(interaction["momentum_slots"])
+    left_current = dag.currents[int(interaction["left_current_id"])]
+    right_current = dag.currents[int(interaction["right_current_id"])]
+    result_current = dag.currents[int(interaction["result_current_id"])]
+    components = model.vertex_component_expression(
+        int(interaction["vertex_kind"]),
+        left,
+        right,
+        result_particle_id=int(result_current.index.particle_id),
+        result_chirality=int(result_current.index.chirality),
+        left_chirality=int(left_current.index.chirality),
+        right_chirality=int(right_current.index.chirality),
+        coupling=_runtime_coupling(interaction, model_parameter_symbols),
+        left_momentum=momentum_components_by_slot_id[int(momenta["left"])],
+        right_momentum=momentum_components_by_slot_id[int(momenta["right"])],
+    )
+    color_weight = _coupling(interaction.get("color_weight"))
+    if color_weight == (1.0, 0.0):
+        return components
+    weight = _exact_complex_expression(complex(*color_weight))
+    return tuple(weight * component for component in components)
+
+
+def _compact_interaction_contribution(
+    dag: GenericDAG,
+    model: Model,
+    interaction_id: int,
+    *,
+    value_components_by_slot_id: Mapping[int, tuple[Any, ...]],
+    input_value_slot_by_current_id: Mapping[int, int],
+    momentum_components_by_slot_id: Mapping[int, tuple[Any, ...]],
+    momentum_slot_by_mask: Mapping[int, int],
+    model_parameter_symbols: Mapping[str, Any],
+    coupling_cache: dict[
+        tuple[int, tuple[int, ...], tuple[float, ...]],
+        tuple[Any, Any],
+    ],
+    evaluation_cache: dict[int, tuple[Any, ...]],
+) -> tuple[Any, ...]:
+    interaction = dag.interactions[interaction_id]
+    evaluation_group_id = interaction.evaluation_group_id
+    canonical_components = (
+        None
+        if evaluation_group_id is None
+        else evaluation_cache.get(evaluation_group_id)
+    )
+    evaluation_factor = complex(*interaction.evaluation_factor)
+    if evaluation_factor == 0j:
+        # Authenticated numerical zero-current relations propagate an exact
+        # zero attachment into downstream interactions.  Do not evaluate a
+        # kernel whose contribution is certified to be zero.
+        return tuple(
+            0j for _component in range(dag.currents[interaction.result_id].dimension)
+        )
+    if canonical_components is None:
+        left_current = dag.currents[interaction.left_id]
+        right_current = dag.currents[interaction.right_id]
+        result_current = dag.currents[interaction.result_id]
+        left = value_components_by_slot_id[
+            input_value_slot_by_current_id[interaction.left_id]
+        ]
+        right = value_components_by_slot_id[
+            input_value_slot_by_current_id[interaction.right_id]
+        ]
+        coupling_key = (
+            int(interaction.vertex_kind),
+            interaction.vertex_particles,
+            interaction.coupling,
+        )
+        coupling = coupling_cache.get(coupling_key)
+        if coupling is None:
+            resolved_coupling = list(interaction.coupling)
+            names = _runtime_coupling_parameter_names(
+                interaction.vertex_kind,
+                interaction.vertex_particles,
+                interaction.coupling,
+                model=model,
+            )
+            for index, name in enumerate(names):
+                if isinstance(name, str) and name in model_parameter_symbols:
+                    resolved_coupling[index] = model_parameter_symbols[name]
+            coupling = (resolved_coupling[0], resolved_coupling[1])
+            coupling_cache[coupling_key] = coupling
+        components = model.vertex_component_expression(
+            int(interaction.vertex_kind),
+            left,
+            right,
+            result_particle_id=int(result_current.index.particle_id),
+            result_chirality=int(result_current.index.chirality),
+            left_chirality=int(left_current.index.chirality),
+            right_chirality=int(right_current.index.chirality),
+            coupling=coupling,
+            left_momentum=momentum_components_by_slot_id[
+                momentum_slot_by_mask[left_current.index.momentum_mask]
+            ],
+            right_momentum=momentum_components_by_slot_id[
+                momentum_slot_by_mask[right_current.index.momentum_mask]
+            ],
+        )
+        if evaluation_factor == 1.0 + 0.0j:
+            canonical_components = components
+        else:
+            exact_factor = _exact_complex_expression(evaluation_factor)
+            canonical_components = tuple(
+                component / exact_factor for component in components
+            )
+        if evaluation_group_id is not None:
+            evaluation_cache[evaluation_group_id] = canonical_components
+    color_weight = complex(*interaction.color_weight)
+    if color_weight == evaluation_factor == 1.0 + 0.0j:
+        return canonical_components
+    weight = _exact_complex_expression(color_weight) * _exact_complex_expression(
+        evaluation_factor
+    )
+    return tuple(weight * component for component in canonical_components)
+
+
+def _amplitude_root_expression(
+    model: Model,
+    root: dict[str, Any],
+    *,
+    value_symbols: Sequence[Any] | Mapping[int, tuple[Any, ...]],
+    model_parameter_symbols: Mapping[str, Any],
+    value_slots: dict[int, dict[str, Any]],
+) -> Any:
+    left_value_slot = _dict(root["left_value_slot"])
+    right_value_slot = _dict(root["right_value_slot"])
+    left = _value_components(left_value_slot, value_symbols)
+    right = _value_components(right_value_slot, value_symbols)
+    left_value_metadata = _amplitude_value_slot_metadata(
+        left_value_slot,
+        value_slots,
+    )
+    right_value_metadata = _amplitude_value_slot_metadata(
+        right_value_slot,
+        value_slots,
+    )
+    kind = str(root["kind"])
+    contraction_ir = _root_contraction_ir(root)
+    coupling = _runtime_coupling(root, model_parameter_symbols)
+    color_weight = _coupling(root.get("color_weight"))
+    if kind == "direct-contraction":
+        _validate_direct_contraction_metadata(
+            contraction_ir,
+            left_value_slot,
+            right_value_slot,
+            left_value_metadata,
+            right_value_metadata,
+        )
+        return _apply_amplitude_color_weight(
+            color_weight,
+            _contract_components(contraction_ir, left, right),
+        )
+    if kind == "vertex-closure":
+        _validate_scalar_projection(contraction_ir)
+        vertex_kind = root.get("vertex_kind")
+        particles = root.get("vertex_particles")
+        if (
+            vertex_kind is None
+            or not isinstance(particles, list)
+            or len(particles) != 3
+        ):
+            raise ValueError("vertex closure is missing vertex metadata")
+        components = model.vertex_component_expression(
+            int(vertex_kind),
+            left,
+            right,
+            result_particle_id=int(particles[2]),
+            result_chirality=0,
+            left_chirality=int(left_value_metadata["chirality"]),
+            right_chirality=int(right_value_metadata["chirality"]),
+            coupling=coupling,
+        )
+        return _apply_amplitude_color_weight(
+            color_weight,
+            _project_components(contraction_ir, components),
+        )
+    raise ValueError(f"unsupported amplitude root kind {kind!r}")
+
+
+def _root_contraction_ir(root: Mapping[str, Any]) -> ContractionIR:
+    payload = root.get("contraction_ir")
+    if not isinstance(payload, Mapping):
+        raise TypeError("amplitude root contraction_ir must be a mapping")
+    contraction_ir = ContractionIR.from_json_dict(payload)
+    if root.get("contraction") != contraction_ir.name:
+        raise ValueError(
+            "amplitude root contraction projection does not match ContractionIR"
+        )
+    return contraction_ir
+
+
+def _amplitude_value_slot_metadata(
+    reference: Mapping[str, Any],
+    value_slots: Mapping[int, dict[str, Any]],
+) -> dict[str, Any]:
+    try:
+        value_slot_id = int(reference["value_slot_id"])
+        return value_slots[value_slot_id]
+    except (KeyError, TypeError, ValueError) as error:
+        raise ValueError("amplitude root references an unknown value slot") from error
+
+
+def _validate_direct_contraction_metadata(
+    contraction_ir: ContractionIR,
+    left_reference: Mapping[str, Any],
+    right_reference: Mapping[str, Any],
+    left_value_slot: Mapping[str, Any],
+    right_value_slot: Mapping[str, Any],
+) -> None:
+    dimension = len(contraction_ir.coefficients)
+    for side, reference, value_slot, basis in (
+        (
+            "left",
+            left_reference,
+            left_value_slot,
+            contraction_ir.left_basis,
+        ),
+        (
+            "right",
+            right_reference,
+            right_value_slot,
+            contraction_ir.right_basis,
+        ),
+    ):
+        if (
+            int(reference.get("dimension", -1)) != dimension
+            or int(value_slot.get("dimension", -1)) != dimension
+        ):
+            raise ValueError(
+                f"direct contraction {side} value slot dimension does not match "
+                "ContractionIR"
+            )
+        propagator = value_slot.get("propagator")
+        if not isinstance(propagator, Mapping) or propagator.get("basis") != basis:
+            raise ValueError(
+                f"direct contraction {side} value slot basis does not match "
+                "ContractionIR"
+            )
+
+    left_chirality = int(left_value_slot["chirality"])
+    right_chirality = int(right_value_slot["chirality"])
+    relation_matches = (
+        contraction_ir.chirality_relation == "any"
+        or (
+            contraction_ir.chirality_relation == "equal"
+            and left_chirality == right_chirality
+        )
+        or (
+            contraction_ir.chirality_relation == "opposite"
+            and left_chirality == -right_chirality
+        )
+    )
+    if not relation_matches:
+        raise ValueError("direct contraction violates ContractionIR chirality relation")
+
+
+def _validate_scalar_projection(contraction_ir: ContractionIR) -> None:
+    if (
+        len(contraction_ir.coefficients) != 1
+        or contraction_ir.left_basis != "scalar"
+        or contraction_ir.right_basis != "scalar"
+        or contraction_ir.chirality_relation != "any"
+    ):
+        raise ValueError("vertex closure does not declare a scalar projection IR")
+
+
+def _apply_amplitude_color_weight(
+    color_weight: tuple[Any, Any],
+    expression: Any,
+) -> Any:
+    if color_weight == (1.0, 0.0):
+        return expression
+    return _exact_complex_expression(complex(*color_weight)) * expression
+
+
+def _interaction_item_id(
+    item: dict[str, Any] | int,
+    *,
+    compacted: bool,
+) -> int:
+    if compacted:
+        if not isinstance(item, int):
+            raise TypeError("compacted stage interaction must be an integer id")
+        return item
+    return int(_dict(item)["interaction_id"])
diff --git a/pyamplicol/src/pyamplicol/generation/stage_parameters.py b/pyamplicol/src/pyamplicol/generation/stage_parameters.py
new file mode 100644
index 0000000000..881af43ba2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/stage_parameters.py
@@ -0,0 +1,638 @@
+# SPDX-License-Identifier: 0BSD
+"""Stage-local parameter layouts and expression utility functions."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, Sequence
+from typing import Any
+
+from .._internal.physics.parameters import ParamBuilder
+from .._internal.physics.symbols import symbols
+from ..models._physics_ir import ContractionIR
+from ..models.base import Model
+from ..models.expressions import _exact_complex_expression
+from .contracts import StageCompilationInput
+from .contracts import (
+    runtime_coupling_parameter_names as _runtime_coupling_parameter_names,
+)
+from .dag_types import GenericDAG
+from .stage_types import GenericStageInputComponent, _StageLocalInputs
+
+_EXPRESSION_PREVIEW_LIMIT = 512
+_MODEL_FUNCTION_INLINE_MAX_BYTES = 1024
+
+
+def _contract_components(
+    contraction_ir: ContractionIR,
+    left: Sequence[Any],
+    right: Sequence[Any],
+) -> Any:
+    dimension = len(contraction_ir.coefficients)
+    if len(left) != dimension or len(right) != dimension:
+        raise ValueError(
+            f"contraction {contraction_ir.name!r} requires {dimension} components, "
+            f"got {len(left)} and {len(right)}"
+        )
+    return _sum_contraction_terms(
+        _apply_contraction_coefficient(
+            coefficient,
+            left[index] * right[index],
+        )
+        for index, coefficient in enumerate(contraction_ir.coefficients)
+    )
+
+
+def _project_components(
+    contraction_ir: ContractionIR,
+    components: Sequence[Any],
+) -> Any:
+    dimension = len(contraction_ir.coefficients)
+    if len(components) != dimension:
+        raise ValueError(
+            f"projection {contraction_ir.name!r} requires {dimension} components, "
+            f"got {len(components)}"
+        )
+    return _sum_contraction_terms(
+        _apply_contraction_coefficient(coefficient, components[index])
+        for index, coefficient in enumerate(contraction_ir.coefficients)
+    )
+
+
+def _apply_contraction_coefficient(
+    coefficient: tuple[float, float],
+    expression: Any,
+) -> Any:
+    if coefficient == (1.0, 0.0):
+        return expression
+    if coefficient == (-1.0, 0.0):
+        return -expression
+    if isinstance(expression, int | float | complex):
+        return complex(*coefficient) * expression
+    return _exact_complex_expression(complex(*coefficient)) * expression
+
+
+def _sum_contraction_terms(terms: Iterable[Any]) -> Any:
+    iterator = iter(terms)
+    result = next(iterator)
+    for term in iterator:
+        result = result + term
+    return result
+
+
+def _stage_input_momentum_slot_ids(
+    interactions: Sequence[dict[str, Any]],
+) -> tuple[int, ...]:
+    slot_ids: set[int] = set()
+    for interaction in interactions:
+        momentum_slots = _dict(interaction["momentum_slots"])
+        for key in ("left", "right", "result"):
+            slot_ids.add(int(momentum_slots[key]))
+    return tuple(sorted(slot_ids))
+
+
+def _current_stage_model_parameter_records(
+    model: Model,
+    model_parameter_records: Sequence[dict[str, Any]],
+    *,
+    dag: GenericDAG,
+    interactions: Sequence[dict[str, Any]],
+    interaction_ids: Sequence[int],
+    output_slots_by_current: Mapping[int, Sequence[dict[str, Any]]],
+    current_slots: Mapping[int, dict[str, Any]],
+) -> tuple[dict[str, Any], ...]:
+    used_names = _coupling_parameter_names_used_by_records(interactions)
+    if not interactions:
+        processed_signatures: set[tuple[int, tuple[int, ...], tuple[float, ...]]] = (
+            set()
+        )
+        for interaction_id in interaction_ids:
+            interaction = dag.interactions[int(interaction_id)]
+            signature = (
+                int(interaction.vertex_kind),
+                interaction.vertex_particles,
+                interaction.coupling,
+            )
+            if signature in processed_signatures:
+                continue
+            processed_signatures.add(signature)
+            used_names.update(
+                name
+                for name in _runtime_coupling_parameter_names(
+                    interaction.vertex_kind,
+                    interaction.vertex_particles,
+                    interaction.coupling,
+                    model=model,
+                )
+                if isinstance(name, str)
+            )
+    for current_id, slots in output_slots_by_current.items():
+        if not any(str(slot["variant"]) == "propagated" for slot in slots):
+            continue
+        current_slot = current_slots[int(current_id)]
+        used_names.update(
+            _particle_model_parameter_names(
+                model,
+                int(current_slot["particle_id"]),
+            )
+        )
+    return _filter_model_parameter_records(model_parameter_records, used_names)
+
+
+def _amplitude_stage_model_parameter_records(
+    model_parameter_records: Sequence[dict[str, Any]],
+    *,
+    roots: Sequence[dict[str, Any]],
+) -> tuple[dict[str, Any], ...]:
+    used_names = _coupling_parameter_names_used_by_records(roots)
+    return _filter_model_parameter_records(model_parameter_records, used_names)
+
+
+def _coupling_parameter_names_used_by_records(
+    records: Sequence[dict[str, Any]],
+) -> set[str]:
+    used_names: set[str] = set()
+    for record in records:
+        names = record.get("coupling_parameter_names")
+        if not isinstance(names, list):
+            continue
+        for name in names:
+            if isinstance(name, str):
+                used_names.add(name)
+    return used_names
+
+
+def _particle_model_parameter_names(model: Model, pdg: int) -> tuple[str, ...]:
+    runtime_names = getattr(model, "runtime_parameter_names_for_particle", None)
+    if callable(runtime_names):
+        return tuple(str(name) for name in runtime_names(int(pdg)))
+    try:
+        particle = model.particle(pdg)
+    except KeyError:
+        return ()
+    return (
+        f"particle.{int(particle.pdg)}.mass",
+        f"particle.{int(particle.pdg)}.width",
+    )
+
+
+def _filter_model_parameter_records(
+    model_parameter_records: Sequence[dict[str, Any]],
+    used_names: set[str],
+) -> tuple[dict[str, Any], ...]:
+    return tuple(
+        record
+        for record in sorted(
+            model_parameter_records,
+            key=lambda item: int(item["parameter_index"]),
+        )
+        if str(record.get("runtime_name", record["name"])) in used_names
+        and not (
+            record.get("complex_domain") == "real"
+            and record.get("complex_component") == "imag"
+        )
+        and not (
+            record.get("complex_domain") == "imaginary"
+            and record.get("complex_component") == "real"
+        )
+    )
+
+
+def _logical_model_parameter_symbols(
+    model_parameter_records: Sequence[dict[str, Any]],
+    slot_symbols: Mapping[str, Any],
+) -> dict[str, Any]:
+    logical_symbols: dict[str, Any] = {}
+    complex_components: dict[str, dict[str, Any]] = {}
+    complex_domains: dict[str, str] = {}
+    for record in model_parameter_records:
+        slot_name = str(record["name"])
+        symbol = slot_symbols[slot_name]
+        runtime_name = record.get("runtime_name")
+        component = record.get("complex_component")
+        if isinstance(runtime_name, str) and component in {"real", "imag"}:
+            complex_components.setdefault(runtime_name, {})[str(component)] = symbol
+            domain = str(record.get("complex_domain", "complex"))
+            previous = complex_domains.setdefault(runtime_name, domain)
+            if previous != domain:
+                raise ValueError(
+                    f"runtime model parameter {runtime_name!r} has conflicting domains"
+                )
+        else:
+            logical_symbols[slot_name] = symbol
+    for runtime_name, components in complex_components.items():
+        domain = complex_domains[runtime_name]
+        if "real" not in components and domain == "imaginary":
+            components["real"] = 0.0
+        if "imag" not in components and domain == "real":
+            components["imag"] = 0.0
+        if set(components) != {"real", "imag"}:
+            raise ValueError(
+                f"runtime model parameter {runtime_name!r} is missing a real "
+                "or imaginary slot"
+            )
+        logical_symbols[runtime_name] = components["real"] + 1j * components["imag"]
+    return logical_symbols
+
+
+def _stage_local_inputs(
+    *,
+    value_slot_ids: Sequence[int],
+    momentum_slot_ids: Sequence[int],
+    value_slots: Mapping[int, dict[str, Any]],
+    momentum_slots: Mapping[int, dict[str, Any]],
+    global_value_component_count: int,
+    global_momentum_parameter_count: int,
+    model_parameter_records: Sequence[dict[str, Any]],
+) -> _StageLocalInputs:
+    builder = ParamBuilder()
+    input_components: list[GenericStageInputComponent] = []
+    value_symbols: dict[int, tuple[Any, ...]] = {}
+    momentum_symbols: dict[int, tuple[Any, ...]] = {}
+    model_parameter_slot_symbols: dict[str, Any] = {}
+
+    value_spans = tuple(
+        (
+            int(value_slot_id),
+            int(value_slots[int(value_slot_id)]["component_start"]),
+            int(value_slots[int(value_slot_id)]["component_stop"]),
+        )
+        for value_slot_id in value_slot_ids
+    )
+    momentum_spans = tuple(
+        (
+            int(momentum_slot_id),
+            int(momentum_slots[int(momentum_slot_id)]["component_start"]),
+            int(momentum_slots[int(momentum_slot_id)]["component_stop"]),
+        )
+        for momentum_slot_id in momentum_slot_ids
+    )
+    sorted_model_parameter_records = tuple(
+        sorted(
+            model_parameter_records,
+            key=lambda item: int(item["parameter_index"]),
+        )
+    )
+    value_parameter_count = sum(stop - start for _, start, stop in value_spans)
+    momentum_parameter_count = sum(stop - start for _, start, stop in momentum_spans)
+    model_parameter_count = len(sorted_model_parameter_records)
+    parameter_count = (
+        value_parameter_count + momentum_parameter_count + model_parameter_count
+    )
+    parameter_symbols = (
+        builder.add_parameter_list(
+            ("artifact_schema_v3_stage", "inputs"),
+            parameter_count,
+            role="generic_stage_input_storage",
+        )
+        if parameter_count
+        else ()
+    )
+    real_parameter_start = value_parameter_count
+    builder.real_valued_inputs.extend(range(real_parameter_start, parameter_count))
+    parameter_cursor = 0
+
+    for value_slot_id, start, stop in value_spans:
+        length = stop - start
+        local_symbols = parameter_symbols[parameter_cursor : parameter_cursor + length]
+        value_symbols[value_slot_id] = local_symbols
+        parameter_start = len(input_components)
+        for component, global_component in enumerate(range(start, stop)):
+            input_components.append(
+                GenericStageInputComponent(
+                    kind="value",
+                    source_id=int(value_slot_id),
+                    component=component,
+                    global_component=global_component,
+                    parameter_index=parameter_start + component,
+                    real_valued=False,
+                )
+            )
+        parameter_cursor += length
+
+    for momentum_slot_id, start, stop in momentum_spans:
+        length = stop - start
+        local_symbols = parameter_symbols[parameter_cursor : parameter_cursor + length]
+        momentum_symbols[momentum_slot_id] = local_symbols
+        parameter_start = len(input_components)
+        for component, local_component in enumerate(range(start, stop)):
+            input_components.append(
+                GenericStageInputComponent(
+                    kind="momentum",
+                    source_id=int(momentum_slot_id),
+                    component=component,
+                    global_component=global_value_component_count + local_component,
+                    parameter_index=parameter_start + component,
+                    real_valued=True,
+                )
+            )
+        parameter_cursor += length
+
+    model_parameter_global_start = (
+        global_value_component_count + global_momentum_parameter_count
+    )
+    for record in sorted_model_parameter_records:
+        name = str(record["name"])
+        parameter_index = int(record["parameter_index"])
+        symbol = parameter_symbols[parameter_cursor]
+        model_parameter_slot_symbols[name] = symbol
+        input_components.append(
+            GenericStageInputComponent(
+                kind="model_parameter",
+                source_id=parameter_index,
+                component=0,
+                global_component=model_parameter_global_start + parameter_index,
+                parameter_index=len(input_components),
+                real_valued=True,
+            )
+        )
+        parameter_cursor += 1
+
+    if parameter_cursor != parameter_count:
+        raise RuntimeError("stage-local parameter layout cursor mismatch")
+
+    model_parameter_symbols = _logical_model_parameter_symbols(
+        sorted_model_parameter_records,
+        model_parameter_slot_symbols,
+    )
+
+    return _StageLocalInputs(
+        parameter_symbols=tuple(parameter_symbols),
+        input_components=tuple(input_components),
+        value_symbols=value_symbols,
+        momentum_symbols=momentum_symbols,
+        model_parameter_symbols=model_parameter_symbols,
+        value_parameter_count=value_parameter_count,
+        momentum_parameter_count=momentum_parameter_count,
+        model_parameter_count=model_parameter_count,
+        real_valued_inputs=tuple(int(index) for index in builder.real_valued_inputs),
+    )
+
+
+def _global_stage_inputs(
+    *,
+    parameter_symbols: Sequence[Any],
+    value_symbols: Sequence[Any],
+    momentum_symbols: Sequence[Any],
+    model_parameter_symbols: Mapping[str, Any],
+    value_parameter_count: int,
+    momentum_parameter_count: int,
+    model_parameter_count: int,
+    real_valued_inputs: Sequence[int],
+) -> _StageLocalInputs:
+    return _StageLocalInputs(
+        parameter_symbols=tuple(parameter_symbols),
+        input_components=(),
+        value_symbols=tuple(value_symbols),
+        momentum_symbols=tuple(momentum_symbols),
+        model_parameter_symbols=dict(model_parameter_symbols),
+        value_parameter_count=int(value_parameter_count),
+        momentum_parameter_count=int(momentum_parameter_count),
+        model_parameter_count=int(model_parameter_count),
+        real_valued_inputs=tuple(int(index) for index in real_valued_inputs),
+    )
+
+
+def _parameter_builder(schema: dict[str, Any]) -> ParamBuilder:
+    layout = _dict(schema["parameter_layout"])
+    builder = ParamBuilder()
+    value_component_count = int(layout["value_component_count"])
+    if value_component_count:
+        builder.add_parameter_list(
+            ("artifact_schema_v3", "values"),
+            value_component_count,
+            role="generic_value_storage",
+        )
+    momentum_parameter_count = int(layout["momentum_parameter_count"])
+    if momentum_parameter_count:
+        builder.add_parameter_list(
+            ("artifact_schema_v3", "momenta"),
+            momentum_parameter_count,
+            role="generic_momentum_storage",
+            real_valued=True,
+        )
+    model_parameter_count = int(layout.get("model_parameter_count", 0))
+    if model_parameter_count:
+        builder.add_parameter_list(
+            ("artifact_schema_v3", "model_parameters"),
+            model_parameter_count,
+            role="generic_model_parameters",
+            real_valued=True,
+        )
+    return builder
+
+
+def _manifest_model(manifest: StageCompilationInput | GenericDAG) -> Model:
+    if isinstance(manifest, StageCompilationInput):
+        return manifest.model
+    raise ValueError("GenericDAG stage compilation requires an explicit model")
+
+
+def _model_symbolica_functions(
+    model: Model,
+) -> tuple[tuple[Any, tuple[Any, ...], Any], ...]:
+    getter = getattr(model, "symbolica_function_definitions", None)
+    if not callable(getter):
+        return ()
+    definitions = getter()
+    if not isinstance(definitions, Mapping):
+        raise TypeError("model Symbolica function definitions must be a mapping")
+    return tuple(
+        (function, tuple(arguments), body)
+        for (function, arguments), body in definitions.items()
+    )
+
+
+def _specialize_stage_symbolica_functions(
+    outputs: Sequence[Any],
+    definitions: Sequence[tuple[Any, tuple[Any, ...], Any]],
+) -> tuple[
+    tuple[Any, ...],
+    tuple[tuple[Any, tuple[Any, ...], Any], ...],
+]:
+    """Inline model-kernel calls before constructing a stage evaluator."""
+
+    output_expressions = tuple(outputs)
+    function_definitions = tuple(definitions)
+    if not output_expressions or not function_definitions:
+        return output_expressions, ()
+
+    from symbolica import Replacement
+
+    replacements: list[Any] = []
+    for definition_index, (function, arguments, body) in enumerate(
+        function_definitions
+    ):
+        if int(body.get_byte_size()) > _MODEL_FUNCTION_INLINE_MAX_BYTES:
+            continue
+        wildcards = tuple(
+            symbols.inline_function_wildcard(
+                definition_index,
+                argument_index,
+            )
+            for argument_index in range(len(arguments))
+        )
+        pattern = function(*wildcards)
+        replacement = body
+        for argument, wildcard in zip(arguments, wildcards, strict=True):
+            replacement = replacement.replace(
+                argument,
+                wildcard,
+                allow_new_wildcards_on_rhs=True,
+            )
+        replacements.append(
+            Replacement(
+                pattern,
+                replacement,
+                allow_new_wildcards_on_rhs=True,
+            )
+        )
+
+    rewritten = tuple(
+        expression.replace_multiple(replacements, repeat=True)
+        for expression in output_expressions
+    )
+
+    function_names = {function for function, _arguments, _body in function_definitions}
+    required = {
+        symbol
+        for expression in rewritten
+        for symbol in _expression_symbols(expression, enter_functions=True)
+        if symbol in function_names
+    }
+    while True:
+        dependencies = {
+            symbol
+            for function, _arguments, body in function_definitions
+            if function in required
+            for symbol in _expression_symbols(body, enter_functions=True)
+            if symbol in function_names
+        }
+        expanded = required | dependencies
+        if expanded == required:
+            break
+        required = expanded
+    retained = tuple(
+        definition for definition in function_definitions if definition[0] in required
+    )
+    return rewritten, retained
+
+
+def _expression_symbols(
+    expression: Any,
+    *,
+    enter_functions: bool,
+) -> set[Any]:
+    getter = getattr(expression, "get_all_symbols", None)
+    if not callable(getter):
+        return set()
+    return set(getter(enter_functions))
+
+
+def _value_components(
+    slot: dict[str, Any],
+    value_symbols: Sequence[Any] | Mapping[int, tuple[Any, ...]],
+) -> tuple[Any, ...]:
+    if isinstance(value_symbols, Mapping):
+        return tuple(value_symbols[int(slot["value_slot_id"])])
+    start = int(slot["component_start"])
+    stop = int(slot["component_stop"])
+    return tuple(value_symbols[index] for index in range(start, stop))
+
+
+def _momentum_components(
+    key: int,
+    momentum_symbols: Sequence[Any] | Mapping[int, tuple[Any, ...]],
+    momentum_slots: dict[int, dict[str, Any]],
+    *,
+    by_slot_id: bool = False,
+) -> tuple[Any, ...]:
+    slot = (
+        momentum_slots[key]
+        if by_slot_id
+        else _momentum_slot_by_mask(momentum_slots, key)
+    )
+    if isinstance(momentum_symbols, Mapping):
+        return tuple(momentum_symbols[int(slot["momentum_slot_id"])])
+    start = int(slot["component_start"])
+    stop = int(slot["component_stop"])
+    return tuple(momentum_symbols[index] for index in range(start, stop))
+
+
+def _momentum_slot_by_mask(
+    momentum_slots: dict[int, dict[str, Any]],
+    momentum_mask: int,
+) -> dict[str, Any]:
+    for slot in momentum_slots.values():
+        if int(slot["momentum_mask"]) == momentum_mask:
+            return slot
+    raise ValueError(f"no momentum slot for mask {momentum_mask}")
+
+
+def _value_slots_by_id(schema: dict[str, Any]) -> dict[int, dict[str, Any]]:
+    storage = _dict(schema["value_storage"])
+    return {
+        int(slot["value_slot_id"]): _dict(slot)
+        for slot in _list(storage["value_slots"])
+    }
+
+
+def _current_slots_by_id(schema: dict[str, Any]) -> dict[int, dict[str, Any]]:
+    storage = _dict(schema["current_storage"])
+    return {
+        int(slot["current_id"]): _dict(slot) for slot in _list(storage["current_slots"])
+    }
+
+
+def _momentum_slots_by_id(schema: dict[str, Any]) -> dict[int, dict[str, Any]]:
+    return {
+        int(slot["momentum_slot_id"]): _dict(slot)
+        for slot in _list(schema["momentum_slots"])
+    }
+
+
+def _sum_components(left: Sequence[Any], right: Sequence[Any]) -> tuple[Any, ...]:
+    if len(left) != len(right):
+        raise ValueError(f"component dimensions differ: {len(left)} != {len(right)}")
+    return tuple(left[index] + right[index] for index in range(len(left)))
+
+
+def _coupling(value: object) -> tuple[Any, Any]:
+    if not isinstance(value, list | tuple) or len(value) != 2:
+        raise ValueError("coupling metadata must have two entries")
+    return value[0], value[1]
+
+
+def _runtime_coupling(
+    record: Mapping[str, Any],
+    model_parameter_symbols: Mapping[str, Any],
+) -> tuple[Any, Any]:
+    values = list(_coupling(record.get("coupling")))
+    names = record.get("coupling_parameter_names")
+    if isinstance(names, list):
+        for index, name in enumerate(names[: len(values)]):
+            if isinstance(name, str) and name in model_parameter_symbols:
+                values[index] = model_parameter_symbols[name]
+    return values[0], values[1]
+
+
+def _expression_previews(expressions: Sequence[Any]) -> tuple[str, ...]:
+    return tuple(_preview_expression(expression) for expression in expressions[:4])
+
+
+def _preview_expression(expression: Any) -> str:
+    text = str(expression)
+    if len(text) <= _EXPRESSION_PREVIEW_LIMIT:
+        return text
+    return text[:_EXPRESSION_PREVIEW_LIMIT] + "...<truncated>"
+
+
+def _dict(value: object) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise TypeError("expected JSON object")
+    return value
+
+
+def _list(value: object) -> list[Any]:
+    if not isinstance(value, list):
+        raise TypeError("expected JSON array")
+    return value
diff --git a/pyamplicol/src/pyamplicol/generation/stage_planning.py b/pyamplicol/src/pyamplicol/generation/stage_planning.py
new file mode 100644
index 0000000000..3bbd95119f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/stage_planning.py
@@ -0,0 +1,745 @@
+# SPDX-License-Identifier: 0BSD
+"""Stage blueprint assembly and fanout-aware output scheduling."""
+
+from __future__ import annotations
+
+import heapq
+from collections import Counter
+from collections.abc import Mapping, Sequence
+from dataclasses import replace
+from typing import Any
+
+from ..models.base import Model
+from .contracts import StageCompilationInput
+from .dag_types import GenericDAG
+from .helicity_materialization import _compiled_representative_dependencies
+from .stage_expressions import (
+    _compile_amplitude_stage_blueprint,
+    _compile_current_stage_blueprint,
+)
+from .stage_parameters import (
+    _current_slots_by_id,
+    _dict,
+    _expression_previews,
+    _list,
+    _logical_model_parameter_symbols,
+    _manifest_model,
+    _momentum_slots_by_id,
+    _parameter_builder,
+    _value_slots_by_id,
+)
+from .stage_settings import _stage_symbolica_settings
+from .stage_types import (
+    GenericCompiledStageBlueprint,
+    GenericStageCompilerBlueprint,
+    GenericStageOutputSlot,
+    StageBlueprintConsumer,
+    StageBlueprintProgress,
+    _RuntimeParameterizedModel,
+)
+
+
+def build_generic_stage_compiler_blueprint(
+    manifest: StageCompilationInput | GenericDAG,
+    *,
+    model: Model | None = None,
+    selected_color_sector_ids: set[int] | None = None,
+    enable_lc_sector_runtime_selector: bool | None = None,
+    runtime_schema: Mapping[str, object] | None = None,
+    stage_local_parameter_layout: bool = True,
+    progress_callback: StageBlueprintProgress | None = None,
+    stage_consumer: StageBlueprintConsumer | None = None,
+    release_consumed_expressions: bool = False,
+) -> GenericStageCompilerBlueprint:
+    """Build evaluator-ready symbolic stages from a neutral runtime schema.
+
+    This is intentionally separate from the legacy shared-current table path.
+    It consumes the process-generic current DAG and runtime schema, asks the
+    model for local vertex and propagator component expressions, and records
+    stage output slots in terms of stable value-slot identifiers.
+    """
+
+    dag = manifest.dag if isinstance(manifest, StageCompilationInput) else manifest
+    if (
+        isinstance(manifest, StageCompilationInput)
+        and model is not None
+        and model is not manifest.model
+    ):
+        raise ValueError("stage model override conflicts with compilation input")
+    if not stage_local_parameter_layout:
+        raise ValueError("stage-local parameter layout is mandatory")
+    if selected_color_sector_ids is not None:
+        raise ValueError(
+            "selected color sectors must already be encoded in the runtime schema"
+        )
+    if enable_lc_sector_runtime_selector is not None:
+        raise ValueError(
+            "the LC selector policy must already be encoded in the runtime schema"
+        )
+    if runtime_schema is not None:
+        schema = _dict(runtime_schema)
+    elif isinstance(manifest, StageCompilationInput):
+        schema = _dict(manifest.runtime_schema.to_mapping())
+    else:
+        raise ValueError(
+            "GenericDAG stage compilation requires an explicit runtime schema"
+        )
+    selected_model = model or _manifest_model(manifest)
+    parameter_layout = _dict(schema["parameter_layout"])
+    global_value_component_count = int(parameter_layout["value_component_count"])
+    global_momentum_parameter_count = int(parameter_layout["momentum_parameter_count"])
+    global_model_parameter_count = int(parameter_layout.get("model_parameter_count", 0))
+    global_parameter_count = (
+        global_value_component_count
+        + global_momentum_parameter_count
+        + global_model_parameter_count
+    )
+    if stage_local_parameter_layout:
+        # Every compiled stage constructs its own compact symbols below. Avoid
+        # materializing the large, otherwise-unused global Symbolica input set.
+        parameter_symbols: tuple[Any, ...] = ()
+        value_symbols: tuple[Any, ...] = ()
+        momentum_symbols: tuple[Any, ...] = ()
+        model_parameter_symbols: tuple[Any, ...] = ()
+        global_real_valued_inputs = tuple(
+            range(global_value_component_count, global_parameter_count)
+        )
+    else:
+        builder = _parameter_builder(schema)
+        parameter_symbols = tuple(builder.parameter_symbols())
+        value_symbols = parameter_symbols[:global_value_component_count]
+        momentum_start = global_value_component_count
+        momentum_stop = momentum_start + global_momentum_parameter_count
+        momentum_symbols = parameter_symbols[momentum_start:momentum_stop]
+        model_parameter_symbols = parameter_symbols[momentum_stop:]
+        global_real_valued_inputs = tuple(
+            int(index) for index in builder.real_valued_inputs
+        )
+    model_parameter_records = tuple(
+        _dict(item) for item in _list(schema.get("model_parameters", []))
+    )
+    model_parameter_symbols_by_name = (
+        {}
+        if stage_local_parameter_layout
+        else _logical_model_parameter_symbols(
+            model_parameter_records,
+            {
+                str(record["name"]): model_parameter_symbols[
+                    int(record["parameter_index"])
+                ]
+                for record in model_parameter_records
+            },
+        )
+    )
+    expression_model = (
+        selected_model.with_runtime_parameters(model_parameter_symbols_by_name)
+        if hasattr(selected_model, "with_runtime_parameters")
+        else _RuntimeParameterizedModel(
+            selected_model,
+            model_parameter_symbols_by_name,
+        )
+    )
+    value_slots = _value_slots_by_id(schema)
+    current_slots = _current_slots_by_id(schema)
+    momentum_slots = _momentum_slots_by_id(schema)
+    stage_records = tuple(_dict(stage) for stage in _list(schema["stages"]))
+    stage_total = len(stage_records) + 1
+    compiled_stages: list[GenericCompiledStageBlueprint] = []
+    for stage_index, stage in enumerate(stage_records, start=1):
+        if progress_callback is not None:
+            progress_callback("current stage", stage_index, stage_total)
+        compiled_stage = _compile_current_stage_blueprint(
+            dag,
+            expression_model,
+            stage,
+            value_slots=value_slots,
+            current_slots=current_slots,
+            momentum_slots=momentum_slots,
+            global_value_component_count=global_value_component_count,
+            global_momentum_parameter_count=global_momentum_parameter_count,
+            model_parameter_records=model_parameter_records,
+            global_parameter_symbols=parameter_symbols,
+            global_value_symbols=value_symbols,
+            global_momentum_symbols=momentum_symbols,
+            global_model_parameter_symbols=model_parameter_symbols_by_name,
+            global_real_valued_inputs=global_real_valued_inputs,
+            stage_local_parameter_layout=stage_local_parameter_layout,
+        )
+        compiled_stage = _stage_with_selector_domain_memberships(
+            compiled_stage,
+            dag,
+        )
+        if stage_consumer is not None:
+            stage_consumer(compiled_stage, stage_index - 1, len(stage_records))
+        if release_consumed_expressions and stage_consumer is not None:
+            compiled_stage = replace(
+                compiled_stage,
+                parameter_symbols=(),
+                output_expressions=(),
+                symbolica_functions=(),
+            )
+        compiled_stages.append(compiled_stage)
+    stages = tuple(compiled_stages)
+    if progress_callback is not None:
+        progress_callback("amplitude stage", stage_total, stage_total)
+    amplitude_stage = _compile_amplitude_stage_blueprint(
+        expression_model,
+        _dict(schema["amplitude_stage"]),
+        value_slots=value_slots,
+        global_value_component_count=global_value_component_count,
+        global_momentum_parameter_count=global_momentum_parameter_count,
+        model_parameter_records=model_parameter_records,
+        global_parameter_symbols=parameter_symbols,
+        global_value_symbols=value_symbols,
+        global_model_parameter_symbols=model_parameter_symbols_by_name,
+        global_real_valued_inputs=global_real_valued_inputs,
+        stage_local_parameter_layout=stage_local_parameter_layout,
+    )
+    amplitude_stage = _stage_with_selector_domain_memberships(
+        amplitude_stage,
+        dag,
+    )
+    if stage_consumer is not None:
+        stage_consumer(amplitude_stage, len(stage_records), len(stage_records))
+    if release_consumed_expressions and stage_consumer is not None:
+        amplitude_stage = replace(
+            amplitude_stage,
+            parameter_symbols=(),
+            output_expressions=(),
+            symbolica_functions=(),
+        )
+    blockers = tuple(
+        blocker for stage in (*stages, amplitude_stage) for blocker in stage.blockers
+    )
+    return GenericStageCompilerBlueprint(
+        kind="pyamplicol-generic-stage-compiler-blueprint",
+        runtime_available=False,
+        parameter_count=global_parameter_count,
+        value_parameter_count=int(schema["parameter_layout"]["value_component_count"]),
+        momentum_parameter_count=global_momentum_parameter_count,
+        model_parameter_count=global_model_parameter_count,
+        real_valued_inputs=global_real_valued_inputs,
+        stage_count=len(stages) + 1,
+        stages=stages,
+        amplitude_stage=amplitude_stage,
+        expression_ready=not blockers,
+        blockers=blockers,
+        parameter_symbols=parameter_symbols,
+    )
+
+
+def _chunk_evaluation_occurrence_count(
+    current_order: Sequence[int],
+    *,
+    output_size_by_current: Mapping[int, int],
+    evaluation_groups_by_current: Mapping[int, frozenset[int]],
+    chunk_size: int,
+) -> int:
+    chunk_groups: list[set[int]] = []
+    output_offset = 0
+    for current_id in current_order:
+        output_size = int(output_size_by_current[current_id])
+        if output_size <= 0:
+            continue
+        first_chunk = output_offset // chunk_size
+        last_chunk = (output_offset + output_size - 1) // chunk_size
+        while len(chunk_groups) <= last_chunk:
+            chunk_groups.append(set())
+        groups = evaluation_groups_by_current.get(current_id, frozenset())
+        for chunk_index in range(first_chunk, last_chunk + 1):
+            chunk_groups[chunk_index].update(groups)
+        output_offset += output_size
+    return sum(len(groups) for groups in chunk_groups)
+
+
+def _fanout_aware_current_order(
+    current_ids: Sequence[int],
+    *,
+    output_size_by_current: Mapping[int, int],
+    evaluation_groups_by_current: Mapping[int, frozenset[int]],
+    chunk_size: int,
+) -> tuple[tuple[int, ...], int, int]:
+    """Cluster current outputs whose kernel evaluations have shared fan-out.
+
+    Shared evaluation groups form a sparse hypergraph over result currents.
+    Indexed heaps reproduce the overlap/benefit greedy choice without scanning
+    every unplaced current.  Pathologically large fan-outs use a deterministic
+    anchor-group sort, keeping the construction bounded for very large stages.
+    """
+
+    natural_order = tuple(int(current_id) for current_id in current_ids)
+    before = _chunk_evaluation_occurrence_count(
+        natural_order,
+        output_size_by_current=output_size_by_current,
+        evaluation_groups_by_current=evaluation_groups_by_current,
+        chunk_size=chunk_size,
+    )
+    frequencies = Counter(
+        group_id
+        for current_id in natural_order
+        for group_id in evaluation_groups_by_current.get(current_id, frozenset())
+    )
+    shared_groups = {
+        group_id for group_id, frequency in frequencies.items() if frequency > 1
+    }
+    if not shared_groups or len(natural_order) < 2:
+        return natural_order, before, before
+
+    shared_by_current = {
+        current_id: tuple(
+            sorted(
+                group_id
+                for group_id in evaluation_groups_by_current.get(
+                    current_id,
+                    frozenset(),
+                )
+                if group_id in shared_groups
+            )
+        )
+        for current_id in natural_order
+    }
+    members_by_group: dict[int, list[int]] = {
+        group_id: [] for group_id in shared_groups
+    }
+    for current_id, group_ids in shared_by_current.items():
+        for group_id in group_ids:
+            members_by_group[group_id].append(current_id)
+
+    benefit_by_current = {
+        current_id: sum(
+            frequencies[group_id] - 1 for group_id in shared_by_current[current_id]
+        )
+        for current_id in natural_order
+    }
+    large_fanout_limit = max(1024, 8 * chunk_size)
+    if max(frequencies.values()) > large_fanout_limit:
+
+        def anchor_key(current_id: int) -> tuple[int, int, int, int, int]:
+            group_ids = shared_by_current[current_id]
+            if not group_ids:
+                return (1, 0, 0, 0, current_id)
+            anchor = min(
+                group_ids,
+                key=lambda group_id: (-frequencies[group_id], group_id),
+            )
+            return (
+                0,
+                -frequencies[anchor],
+                anchor,
+                -benefit_by_current[current_id],
+                current_id,
+            )
+
+        candidate_order = tuple(sorted(natural_order, key=anchor_key))
+    else:
+        remaining = set(natural_order)
+        seed_heap = [
+            (
+                -benefit_by_current[current_id],
+                -len(
+                    evaluation_groups_by_current.get(
+                        current_id,
+                        frozenset(),
+                    )
+                ),
+                current_id,
+            )
+            for current_id in natural_order
+        ]
+        heapq.heapify(seed_heap)
+        fitting_heaps: dict[int, list[tuple[int, int]]] = {}
+        for current_id in natural_order:
+            size = int(output_size_by_current[current_id])
+            fitting_heaps.setdefault(size, []).append(
+                (-benefit_by_current[current_id], current_id)
+            )
+        for heap in fitting_heaps.values():
+            heapq.heapify(heap)
+        output_sizes = tuple(sorted(fitting_heaps))
+
+        def pop_seed() -> int:
+            while seed_heap:
+                _benefit, _group_count, current_id = heapq.heappop(seed_heap)
+                if current_id in remaining:
+                    return current_id
+            raise ValueError("fan-out ordering lost an unplaced current")
+
+        def pop_fitting(capacity: int) -> int | None:
+            selected_size: int | None = None
+            selected_key: tuple[int, int, int] | None = None
+            for size in output_sizes:
+                if size > capacity:
+                    break
+                heap = fitting_heaps[size]
+                while heap and heap[0][1] not in remaining:
+                    heapq.heappop(heap)
+                if not heap:
+                    continue
+                benefit, current_id = heap[0]
+                key = (benefit, -size, current_id)
+                if selected_key is None or key < selected_key:
+                    selected_size = size
+                    selected_key = key
+            if selected_size is None:
+                return None
+            _benefit, current_id = heapq.heappop(fitting_heaps[selected_size])
+            return current_id
+
+        bins: list[list[int]] = []
+        while remaining:
+            seed = pop_seed()
+            current_bin: list[int] = []
+            groups_in_bin: set[int] = set()
+            overlap_by_current: dict[int, int] = {}
+            candidate_heap: list[tuple[int, int, int, int]] = []
+            used = 0
+
+            def add_current(
+                current_id: int,
+                current_bin: list[int],
+                groups_in_bin: set[int],
+                overlap_by_current: dict[int, int],
+                candidate_heap: list[tuple[int, int, int, int]],
+            ) -> None:
+                nonlocal used
+                remaining.remove(current_id)
+                current_bin.append(current_id)
+                used += int(output_size_by_current[current_id])
+                for group_id in shared_by_current[current_id]:
+                    if group_id in groups_in_bin:
+                        continue
+                    groups_in_bin.add(group_id)
+                    for candidate_id in members_by_group[group_id]:
+                        if candidate_id not in remaining:
+                            continue
+                        overlap = overlap_by_current.get(candidate_id, 0) + 1
+                        overlap_by_current[candidate_id] = overlap
+                        heapq.heappush(
+                            candidate_heap,
+                            (
+                                -overlap,
+                                -benefit_by_current[candidate_id],
+                                -int(output_size_by_current[candidate_id]),
+                                candidate_id,
+                            ),
+                        )
+
+            def pop_overlapping(
+                capacity: int,
+                candidate_heap: list[tuple[int, int, int, int]],
+                overlap_by_current: dict[int, int],
+            ) -> int | None:
+                postponed: list[tuple[int, int, int, int]] = []
+                selected: int | None = None
+                while candidate_heap:
+                    item = heapq.heappop(candidate_heap)
+                    overlap, _benefit, _size, current_id = item
+                    if current_id not in remaining:
+                        continue
+                    if -overlap != overlap_by_current.get(current_id, 0):
+                        continue
+                    if int(output_size_by_current[current_id]) > capacity:
+                        postponed.append(item)
+                        continue
+                    selected = current_id
+                    break
+                for item in postponed:
+                    heapq.heappush(candidate_heap, item)
+                return selected
+
+            add_current(
+                seed,
+                current_bin,
+                groups_in_bin,
+                overlap_by_current,
+                candidate_heap,
+            )
+            while remaining:
+                capacity = chunk_size - used
+                if capacity < 0:
+                    break
+                selected = pop_overlapping(
+                    capacity,
+                    candidate_heap,
+                    overlap_by_current,
+                )
+                if selected is None:
+                    selected = pop_fitting(capacity)
+                if selected is None:
+                    break
+                add_current(
+                    selected,
+                    current_bin,
+                    groups_in_bin,
+                    overlap_by_current,
+                    candidate_heap,
+                )
+            bins.append(current_bin)
+
+        candidate_order = tuple(
+            current_id for current_bin in bins for current_id in current_bin
+        )
+    after = _chunk_evaluation_occurrence_count(
+        candidate_order,
+        output_size_by_current=output_size_by_current,
+        evaluation_groups_by_current=evaluation_groups_by_current,
+        chunk_size=chunk_size,
+    )
+    if after >= before:
+        return natural_order, before, before
+    return candidate_order, before, after
+
+
+def _stage_with_selector_domain_memberships(
+    stage: GenericCompiledStageBlueprint,
+    dag: GenericDAG,
+) -> GenericCompiledStageBlueprint:
+    materialization = dag.helicity_materialization
+    replay = dag.lc_topology_replay
+    if materialization is None and replay is None:
+        return stage
+    domains_by_current: dict[int, list[int]] = {}
+    domains_by_root: dict[int, list[int]] = {}
+    if materialization is not None:
+        for schedule in materialization.selector_schedules:
+            if schedule.structural_zero:
+                continue
+            for current_id in schedule.active_current_ids:
+                domains_by_current.setdefault(int(current_id), []).append(
+                    int(schedule.selector_domain_id)
+                )
+            for root_id in schedule.active_root_ids:
+                domains_by_root.setdefault(int(root_id), []).append(
+                    int(schedule.selector_domain_id)
+                )
+    color_domains_by_current, color_domains_by_root = (
+        _lc_materialized_sector_memberships(dag)
+    )
+    output_slots = []
+    for slot in stage.output_slots:
+        owner_id = (
+            int(slot.component_start)
+            if str(stage.stage_kind).startswith("amplitude")
+            else int(slot.current_id)
+        )
+        domains = (
+            domains_by_root.get(owner_id, ())
+            if str(stage.stage_kind).startswith("amplitude")
+            else domains_by_current.get(owner_id, ())
+        )
+        output_slots.append(
+            replace(
+                slot,
+                selector_domain_ids=tuple(sorted(set(domains))),
+                color_selector_domain_ids=(
+                    color_domains_by_root.get(owner_id, ())
+                    if str(stage.stage_kind).startswith("amplitude")
+                    else color_domains_by_current.get(owner_id, ())
+                ),
+            )
+        )
+    return replace(stage, output_slots=tuple(output_slots))
+
+
+def _lc_materialized_sector_memberships(
+    dag: GenericDAG,
+) -> tuple[dict[int, tuple[int, ...]], dict[int, tuple[int, ...]]]:
+    if dag.process.color_accuracy != "lc" or dag.color_coverage != "complete":
+        return {}, {}
+    replay = dag.lc_topology_replay
+    materialized_sector_ids = (
+        {int(sector.id) for sector in dag.color_plan.sectors}
+        if replay is None
+        else set(replay.materialized_sector_ids)
+    )
+    roots_by_sector: dict[int, list[int]] = {
+        sector_id: [] for sector_id in materialized_sector_ids
+    }
+    root_by_id = {int(root.id): root for root in dag.amplitude_roots}
+    for root in dag.amplitude_roots:
+        sector_id = (
+            int(root.color_sector_id)
+            if root.color_sector_id is not None
+            else int(dag.currents[root.left_id].index.color_state.sector_id)
+        )
+        if sector_id in roots_by_sector:
+            roots_by_sector[sector_id].append(int(root.id))
+
+    interactions_by_result: dict[int, list[tuple[int, int]]] = {}
+    for interaction in dag.interactions:
+        interactions_by_result.setdefault(int(interaction.result_id), []).append(
+            (int(interaction.left_id), int(interaction.right_id))
+        )
+    compiled_dependencies = _compiled_representative_dependencies(dag)
+
+    sectors_by_current: dict[int, set[int]] = {}
+    sectors_by_root: dict[int, set[int]] = {}
+    for sector_id, root_ids in roots_by_sector.items():
+        if not root_ids:
+            raise ValueError(
+                "LC topology replay materialized sector "
+                f"{sector_id} has no amplitude root"
+            )
+        active_currents: set[int] = set()
+        pending: list[int] = []
+        for root_id in root_ids:
+            root = root_by_id[root_id]
+            sectors_by_root.setdefault(root_id, set()).add(sector_id)
+            pending.extend((int(root.left_id), int(root.right_id)))
+        while pending:
+            current_id = pending.pop()
+            if current_id in active_currents:
+                continue
+            active_currents.add(current_id)
+            for left_id, right_id in interactions_by_result.get(current_id, ()):
+                pending.extend((left_id, right_id))
+            pending.extend(compiled_dependencies.get(current_id, ()))
+        for current_id in active_currents:
+            sectors_by_current.setdefault(current_id, set()).add(sector_id)
+
+    return (
+        {
+            current_id: tuple(sorted(sector_ids))
+            for current_id, sector_ids in sectors_by_current.items()
+        },
+        {
+            root_id: tuple(sorted(sector_ids))
+            for root_id, sector_ids in sectors_by_root.items()
+        },
+    )
+
+
+def _stage_with_fanout_aware_output_order(
+    stage: GenericCompiledStageBlueprint,
+    *,
+    chunk_size: int | None,
+) -> GenericCompiledStageBlueprint:
+    if not stage.output_slots:
+        return stage
+
+    amplitude_stage = str(stage.stage_kind).startswith("amplitude")
+    slots_by_owner: dict[int, list[GenericStageOutputSlot]] = {}
+    for slot_index, slot in enumerate(stage.output_slots):
+        owner_id = slot_index if amplitude_stage else int(slot.current_id)
+        slots_by_owner.setdefault(owner_id, []).append(slot)
+    natural_order = tuple(slots_by_owner)
+    output_size_by_owner = {
+        owner_id: sum(slot.output_stop - slot.output_start for slot in slots)
+        for owner_id, slots in slots_by_owner.items()
+    }
+    groups_by_current = {
+        int(current_id): frozenset(int(group_id) for group_id in group_ids)
+        for current_id, group_ids in stage.evaluation_groups_by_current
+        if current_id in slots_by_owner
+    }
+    signature_by_owner = {
+        owner_id: (
+            slots[0].selector_domain_ids,
+            slots[0].color_selector_domain_ids,
+        )
+        for owner_id, slots in slots_by_owner.items()
+    }
+    selector_partitioning = any(
+        helicity_ids or color_ids
+        for helicity_ids, color_ids in signature_by_owner.values()
+    )
+    owners_by_signature: dict[
+        tuple[tuple[int, ...], tuple[int, ...]], list[int]
+    ] = {}
+    for owner_id in natural_order:
+        owners_by_signature.setdefault(
+            signature_by_owner[owner_id], []
+        ).append(owner_id)
+
+    owner_order: list[int] = []
+    before = 0
+    after = 0
+    for signature_owners in owners_by_signature.values():
+        ordered = tuple(signature_owners)
+        if (
+            not amplitude_stage
+            and chunk_size is not None
+            and int(chunk_size) > 0
+            and groups_by_current
+        ):
+            ordered, group_before, group_after = _fanout_aware_current_order(
+                ordered,
+                output_size_by_current=output_size_by_owner,
+                evaluation_groups_by_current=groups_by_current,
+                chunk_size=int(chunk_size),
+            )
+            before += group_before
+            after += group_after
+        owner_order.extend(ordered)
+
+    if not selector_partitioning and tuple(owner_order) == natural_order:
+        if chunk_size is None or int(chunk_size) < 1 or amplitude_stage:
+            return stage
+        return replace(
+            stage,
+            fanout_chunk_size=int(chunk_size),
+            fanout_evaluation_occurrences_before=before,
+            fanout_evaluation_occurrences_after=after,
+        )
+
+    outputs: list[Any] = []
+    output_slots: list[GenericStageOutputSlot] = []
+    selector_output_partitions: list[tuple[int, int]] = []
+    active_signature: tuple[tuple[int, ...], tuple[int, ...]] | None = None
+    partition_start = 0
+    for owner_id in owner_order:
+        signature = signature_by_owner[owner_id]
+        if active_signature is None:
+            active_signature = signature
+        elif signature != active_signature:
+            selector_output_partitions.append((partition_start, len(outputs)))
+            partition_start = len(outputs)
+            active_signature = signature
+        for slot in slots_by_owner[owner_id]:
+            components = stage.output_expressions[slot.output_start : slot.output_stop]
+            start = len(outputs)
+            outputs.extend(components)
+            output_slots.append(
+                replace(
+                    slot,
+                    output_start=start,
+                    output_stop=len(outputs),
+                )
+            )
+    if selector_partitioning:
+        selector_output_partitions.append((partition_start, len(outputs)))
+    if len(outputs) != len(stage.output_expressions):
+        raise ValueError("fan-out output ordering lost stage expressions")
+    return replace(
+        stage,
+        output_slots=tuple(output_slots),
+        first_output_previews=_expression_previews(outputs),
+        output_expressions=tuple(outputs),
+        fanout_chunk_size=(None if chunk_size is None else int(chunk_size)),
+        fanout_evaluation_occurrences_before=(before or None),
+        fanout_evaluation_occurrences_after=(after or None),
+        selector_output_partitions=tuple(selector_output_partitions),
+    )
+
+
+def _prepare_stage_for_output_chunking(
+    stage: GenericCompiledStageBlueprint,
+    *,
+    blueprint: GenericStageCompilerBlueprint | None,
+    symbolica_settings: Any | None,
+    current_stage_position: int | None = None,
+    current_stage_count: int | None = None,
+) -> GenericCompiledStageBlueprint:
+    if symbolica_settings is None:
+        return stage
+    settings = _stage_symbolica_settings(
+        stage,
+        blueprint,
+        symbolica_settings,
+        current_stage_position=current_stage_position,
+        current_stage_count=current_stage_count,
+    )
+    return _stage_with_fanout_aware_output_order(
+        stage,
+        chunk_size=getattr(settings, "compiled_output_chunk_size", None),
+    )
diff --git a/pyamplicol/src/pyamplicol/generation/stage_settings.py b/pyamplicol/src/pyamplicol/generation/stage_settings.py
new file mode 100644
index 0000000000..8e43c96db1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/stage_settings.py
@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: 0BSD
+"""Per-stage evaluator settings."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import Any
+
+from .stage_types import GenericCompiledStageBlueprint, GenericStageCompilerBlueprint
+
+_LOW_RANK_CURRENT_COMPONENT_LIMIT = 8
+_HIGH_RANK_CURRENT_CHUNK_LIMIT = 256
+
+
+def _stage_symbolica_settings(
+    stage: GenericCompiledStageBlueprint,
+    blueprint: GenericStageCompilerBlueprint | None,
+    settings: Any,
+    *,
+    current_stage_position: int | None = None,
+    current_stage_count: int | None = None,
+) -> Any:
+    """Derive the stage-specific evaluator output-chunk policy."""
+
+    settings = _bound_high_rank_current_chunk(stage, settings)
+
+    strategy = getattr(settings, "output_chunk_strategy", "uniform")
+    if strategy == "auto":
+        base = getattr(settings, "compiled_output_chunk_size", None)
+        output_count = int(
+            getattr(
+                stage,
+                "output_length",
+                0 if base is None else int(base) + 1,
+            )
+        )
+        strategy = (
+            "measured-stage"
+            if getattr(settings, "backend", None) == "jit"
+            and base is not None
+            and int(base) <= 256
+            and output_count > int(base)
+            else "uniform"
+        )
+        settings = replace(settings, output_chunk_strategy=strategy)
+    if strategy != "tapered-stage":
+        return settings
+    base = getattr(settings, "compiled_output_chunk_size", None)
+    if base is None:
+        return settings
+    if str(stage.stage_kind).startswith("amplitude"):
+        return replace(settings, compiled_output_chunk_size=None)
+
+    if blueprint is not None:
+        try:
+            position = next(
+                index
+                for index, current_stage in enumerate(blueprint.stages)
+                if current_stage.stage_index == stage.stage_index
+            )
+        except StopIteration:
+            return settings
+        stage_count = len(blueprint.stages)
+    else:
+        if current_stage_position is None or current_stage_count is None:
+            return settings
+        position = int(current_stage_position)
+        stage_count = int(current_stage_count)
+    remaining = stage_count - position - 1
+    if position < 2:
+        chunk_size = None
+    elif remaining == 0:
+        chunk_size = max(1, int(base) // 2)
+    elif remaining <= 2:
+        chunk_size = int(base)
+    else:
+        chunk_size = int(base) * 2
+    return replace(settings, compiled_output_chunk_size=chunk_size)
+
+
+def _bound_high_rank_current_chunk(
+    stage: GenericCompiledStageBlueprint,
+    settings: Any,
+) -> Any:
+    """Keep native evaluators for higher-rank current states at a safe size."""
+
+    chunk_size = getattr(settings, "compiled_output_chunk_size", None)
+    if (
+        chunk_size is None
+        or int(chunk_size) <= _HIGH_RANK_CURRENT_CHUNK_LIMIT
+        or str(stage.stage_kind).startswith("amplitude")
+    ):
+        return settings
+    max_slot_width = max(
+        (
+            int(slot.component_stop) - int(slot.component_start)
+            for slot in stage.output_slots
+        ),
+        default=0,
+    )
+    if max_slot_width <= _LOW_RANK_CURRENT_COMPONENT_LIMIT:
+        return settings
+    return replace(
+        settings,
+        compiled_output_chunk_size=_HIGH_RANK_CURRENT_CHUNK_LIMIT,
+    )
diff --git a/pyamplicol/src/pyamplicol/generation/stage_types.py b/pyamplicol/src/pyamplicol/generation/stage_types.py
new file mode 100644
index 0000000000..d1830da395
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/stage_types.py
@@ -0,0 +1,282 @@
+# SPDX-License-Identifier: 0BSD
+"""Frozen stage compilation records and runtime-model adapter."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any, cast
+
+from ..models._physics_ir import PropagatorIR
+from ..models.base import Model
+
+
+@dataclass(frozen=True)
+class GenericStageInputComponent:
+    kind: str
+    source_id: int
+    component: int
+    global_component: int
+    parameter_index: int
+    real_valued: bool = False
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "kind": self.kind,
+            "source_id": self.source_id,
+            "component": self.component,
+            "global_component": self.global_component,
+            "parameter_index": self.parameter_index,
+            "real_valued": self.real_valued,
+        }
+
+
+@dataclass(frozen=True)
+class GenericStageOutputSlot:
+    value_slot_id: int
+    current_id: int
+    variant: str
+    component_start: int
+    component_stop: int
+    output_start: int
+    output_stop: int
+    selector_domain_ids: tuple[int, ...] = field(
+        default=(),
+        repr=False,
+        compare=False,
+    )
+    color_selector_domain_ids: tuple[int, ...] = field(
+        default=(),
+        repr=False,
+        compare=False,
+    )
+
+    def to_json_dict(self) -> dict[str, object]:
+        result: dict[str, object] = {
+            "value_slot_id": self.value_slot_id,
+            "current_id": self.current_id,
+            "variant": self.variant,
+            "component_start": self.component_start,
+            "component_stop": self.component_stop,
+            "output_start": self.output_start,
+            "output_stop": self.output_stop,
+        }
+        if self.color_selector_domain_ids:
+            result["color_selector_domain_ids"] = list(
+                self.color_selector_domain_ids
+            )
+        return result
+
+
+@dataclass(frozen=True)
+class GenericCompiledStageBlueprint:
+    stage_index: int
+    stage_kind: str
+    subset_size: int | None
+    evaluator_label: str
+    parameter_layout: str
+    output_length: int
+    output_slots: tuple[GenericStageOutputSlot, ...]
+    input_value_slot_ids: tuple[int, ...]
+    output_value_slot_ids: tuple[int, ...]
+    interaction_ids: tuple[int, ...]
+    input_components: tuple[GenericStageInputComponent, ...]
+    parameter_count: int
+    value_parameter_count: int
+    momentum_parameter_count: int
+    model_parameter_count: int
+    real_valued_inputs: tuple[int, ...]
+    expression_ready: bool
+    blockers: tuple[str, ...]
+    first_output_previews: tuple[str, ...]
+    evaluation_groups_by_current: tuple[tuple[int, tuple[int, ...]], ...] = field(
+        default=(),
+        repr=False,
+        compare=False,
+    )
+    fanout_chunk_size: int | None = None
+    fanout_evaluation_occurrences_before: int | None = None
+    fanout_evaluation_occurrences_after: int | None = None
+    selector_output_partitions: tuple[tuple[int, int], ...] = field(
+        default=(),
+        repr=False,
+        compare=False,
+    )
+    parameter_symbols: tuple[Any, ...] = field(
+        default=(),
+        repr=False,
+        compare=False,
+    )
+    output_expressions: tuple[Any, ...] = field(
+        default=(),
+        repr=False,
+        compare=False,
+    )
+    symbolica_functions: tuple[tuple[Any, tuple[Any, ...], Any], ...] = field(
+        default=(),
+        repr=False,
+        compare=False,
+    )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "stage_index": self.stage_index,
+            "stage_kind": self.stage_kind,
+            "subset_size": self.subset_size,
+            "evaluator_label": self.evaluator_label,
+            "parameter_layout": self.parameter_layout,
+            "output_length": self.output_length,
+            "output_slots": [slot.to_json_dict() for slot in self.output_slots],
+            "input_value_slot_ids": list(self.input_value_slot_ids),
+            "output_value_slot_ids": list(self.output_value_slot_ids),
+            "interaction_ids": list(self.interaction_ids),
+            "input_components": [
+                component.to_json_dict() for component in self.input_components
+            ],
+            "parameter_count": self.parameter_count,
+            "value_parameter_count": self.value_parameter_count,
+            "momentum_parameter_count": self.momentum_parameter_count,
+            "model_parameter_count": self.model_parameter_count,
+            "real_valued_inputs": list(self.real_valued_inputs),
+            "expression_ready": self.expression_ready,
+            "blockers": list(self.blockers),
+            "first_output_previews": list(self.first_output_previews),
+            "symbolica_function_count": len(self.symbolica_functions),
+            "evaluation_fanout": {
+                "strategy": (
+                    "shared-evaluation-affinity"
+                    if self.fanout_chunk_size is not None
+                    else "natural-current-order"
+                ),
+                "chunk_size": self.fanout_chunk_size,
+                "evaluation_occurrences_before": (
+                    self.fanout_evaluation_occurrences_before
+                ),
+                "evaluation_occurrences_after": (
+                    self.fanout_evaluation_occurrences_after
+                ),
+            },
+        }
+
+
+@dataclass(frozen=True)
+class GenericStageCompilerBlueprint:
+    kind: str
+    runtime_available: bool
+    parameter_count: int
+    value_parameter_count: int
+    momentum_parameter_count: int
+    model_parameter_count: int
+    real_valued_inputs: tuple[int, ...]
+    stage_count: int
+    stages: tuple[GenericCompiledStageBlueprint, ...]
+    amplitude_stage: GenericCompiledStageBlueprint
+    expression_ready: bool
+    blockers: tuple[str, ...]
+    parameter_symbols: tuple[Any, ...] = field(
+        default=(),
+        repr=False,
+        compare=False,
+    )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "kind": self.kind,
+            "runtime_available": self.runtime_available,
+            "parameter_count": self.parameter_count,
+            "value_parameter_count": self.value_parameter_count,
+            "momentum_parameter_count": self.momentum_parameter_count,
+            "model_parameter_count": self.model_parameter_count,
+            "real_valued_inputs": list(self.real_valued_inputs),
+            "stage_count": self.stage_count,
+            "stages": [stage.to_json_dict() for stage in self.stages],
+            "amplitude_stage": self.amplitude_stage.to_json_dict(),
+            "expression_ready": self.expression_ready,
+            "blockers": list(self.blockers),
+        }
+
+
+@dataclass(frozen=True)
+class _StageLocalInputs:
+    parameter_symbols: tuple[Any, ...]
+    input_components: tuple[GenericStageInputComponent, ...]
+    value_symbols: tuple[Any, ...] | Mapping[int, tuple[Any, ...]]
+    momentum_symbols: tuple[Any, ...] | Mapping[int, tuple[Any, ...]]
+    model_parameter_symbols: Mapping[str, Any]
+    value_parameter_count: int
+    momentum_parameter_count: int
+    model_parameter_count: int
+    real_valued_inputs: tuple[int, ...]
+
+
+StageEvaluatorCompiler = Callable[
+    [GenericCompiledStageBlueprint, tuple[Any, ...], tuple[int, ...]],
+    dict[str, object],
+]
+StageBlueprintProgress = Callable[[str, int, int], None]
+StageBlueprintConsumer = Callable[
+    [GenericCompiledStageBlueprint, int, int],
+    None,
+]
+
+
+class _RuntimeParameterizedModel:
+    """Overlay runtime parameters while delegating every model decision.
+
+    This proxy deliberately does not inherit any concrete model. Models with a
+    specialized runtime-parameter implementation can still provide
+    ``with_runtime_parameters`` and bypass it.
+    """
+
+    def __init__(self, base: Model, parameters: Mapping[str, Any]) -> None:
+        self._base_model = base
+        self._runtime_parameters = parameters
+        self.name = base.name
+        self.particles = base.particles
+        self.vertices = base.vertices
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._base_model, name)
+
+    def mass(self, pdg: int) -> Any:
+        particle = self._base_model.particle(pdg)
+        name = f"particle.{int(particle.pdg)}.mass"
+        return self._runtime_parameters.get(name, self._base_model.mass(pdg))
+
+    def width(self, pdg: int) -> Any:
+        particle = self._base_model.particle(pdg)
+        name = f"particle.{int(particle.pdg)}.width"
+        return self._runtime_parameters.get(name, self._base_model.width(pdg))
+
+    def propagator_lowering_rule(self, particle_id: int, chirality: int = 0) -> Any:
+        return self._base_model.propagator_lowering_rule(particle_id, chirality)
+
+    def propagator_component_expression(
+        self,
+        particle_id: int,
+        value: Sequence[Any],
+        momentum: Sequence[Any],
+        *,
+        chirality: int = 0,
+        propagator: PropagatorIR | None = None,
+    ) -> tuple[Any, ...]:
+        return cast(
+            tuple[Any, ...],
+            type(self._base_model).propagator_component_expression(
+                self,
+                particle_id,
+                value,
+                momentum,
+                chirality=chirality,
+                propagator=propagator,
+            ),
+        )
+
+    def is_chiral_eligible(self, pdg: int) -> bool:
+        return self._base_model.is_chiral_eligible(pdg)
+
+    def with_runtime_parameters(
+        self,
+        parameters: Mapping[str, Any],
+    ) -> _RuntimeParameterizedModel:
+        return _RuntimeParameterizedModel(self._base_model, parameters)
diff --git a/pyamplicol/src/pyamplicol/generation/structural_source_proof.py b/pyamplicol/src/pyamplicol/generation/structural_source_proof.py
new file mode 100644
index 0000000000..ee865f980a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/structural_source_proof.py
@@ -0,0 +1,649 @@
+# SPDX-License-Identifier: 0BSD
+"""Generation-time structural source and physical-lane evidence.
+
+This module deliberately operates before ``artifact.json`` exists. Its output
+is provenance rather than runtime state, so callers bind its declared payload
+SHA directly when a later numerical witness needs the proof identity.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from pyamplicol.artifacts.security import sha256_file
+
+from .evaluator_container import PacbinReader
+
+SCHEMA = "pyamplicol-generation-structural-source-proof-v1"
+ROLE = "structural-source-proof"
+SEMANTIC_MAP_DOMAINS = {
+    "current_member_map": "current_member_map-v1",
+    "interaction_row_map": "interaction_row_map-v1",
+    "closure_map": "closure_map-v1",
+    "source_contract": "source_contract-v1",
+}
+# Compiler executables record provenance; they are not members of the artifact payload.
+_DIAGNOSTIC_PATH_FIELDS = frozenset({"compiler_path"})
+
+
+def canonical_sha256(domain: str, value: object) -> str:
+    """Hash canonical JSON under a distinct semantic domain."""
+
+    encoded = json.dumps(
+        {"domain": domain, "value": value},
+        ensure_ascii=True,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def semantic_map_witnesses(execution: Mapping[str, object]) -> dict[str, object]:
+    """Project one execution DTO into four non-interchangeable exact maps."""
+
+    predicates = {
+        "current_member_map": lambda key: (
+            "current" in key
+            or key
+            in {
+                "source_count",
+                "source_fill",
+                "source_row_count",
+                "sources",
+                "value_storage",
+            }
+        ),
+        "interaction_row_map": lambda key: (
+            "interaction" in key
+            or "contribution" in key
+            or key in {"stages", "schedule"}
+        ),
+        "closure_map": lambda key: (
+            "closure" in key
+            or "amplitude" in key
+            or "destination" in key
+            or "reduction" in key
+        ),
+        "source_contract": lambda key: key
+        in {
+            "color_accuracy",
+            "external_particles",
+            "external_pdg_order",
+            "kind",
+            "model",
+            "normalization",
+            "parameter_layout",
+            "process",
+            "process_key",
+            "runtime_metadata",
+            "schema_version",
+        },
+    }
+
+    def project(predicate: Any) -> list[dict[str, object]]:
+        rows: list[dict[str, object]] = []
+
+        def visit(value: object, path: str) -> None:
+            if isinstance(value, Mapping):
+                for raw_key in sorted(value, key=str):
+                    key = str(raw_key)
+                    child = value[raw_key]
+                    child_path = f"{path}.{key}" if path else key
+                    if predicate(key):
+                        rows.append({"path": child_path, "value": child})
+                    else:
+                        visit(child, child_path)
+            elif isinstance(value, Sequence) and not isinstance(value, str | bytes):
+                for index, child in enumerate(value):
+                    visit(child, f"{path}[{index}]")
+
+        visit(execution, "")
+        if not rows:
+            raise ValueError("execution lacks a required exact semantic-map witness")
+        return rows
+
+    result: dict[str, object] = {}
+    identities: set[str] = set()
+    for name, predicate in predicates.items():
+        rows = project(predicate)
+        digest = canonical_sha256(SEMANTIC_MAP_DOMAINS[name], rows)
+        if digest in identities:
+            raise ValueError("semantic maps repeat one content identity")
+        identities.add(digest)
+        result[name] = {"sha256": digest, "rows": rows}
+    return result
+
+
+def _payload_paths(value: object) -> tuple[str, ...]:
+    paths: set[str] = set()
+
+    def visit(item: object, field: str | None = None) -> None:
+        if isinstance(item, Mapping):
+            for key, child in item.items():
+                visit(child, str(key))
+        elif isinstance(item, Sequence) and not isinstance(item, str | bytes):
+            for child in item:
+                visit(child, field)
+        elif (
+            isinstance(item, str)
+            and field is not None
+            and field not in _DIAGNOSTIC_PATH_FIELDS
+            and (field == "path" or field.endswith("_path"))
+            and item
+        ):
+            candidate = Path(item)
+            if candidate.is_absolute() or ".." in candidate.parts:
+                raise ValueError(f"execution payload path is not confined: {item!r}")
+            paths.add(candidate.as_posix())
+
+    visit(value)
+    return tuple(sorted(paths))
+
+
+def _structural_metrics(value: object) -> list[dict[str, object]]:
+    """Retain every explicit structural counter without inferred aliases."""
+
+    rows: list[dict[str, object]] = []
+
+    def visit(item: object, path: str) -> None:
+        if isinstance(item, Mapping):
+            for raw_key in sorted(item, key=str):
+                key = str(raw_key)
+                child = item[raw_key]
+                child_path = f"{path}.{key}" if path else key
+                if (
+                    isinstance(child, int)
+                    and not isinstance(child, bool)
+                    and (
+                        key.endswith("_count")
+                        or key.endswith("_size")
+                        or key.endswith("_size_bytes")
+                    )
+                ):
+                    if child < 0:
+                        raise ValueError(
+                            f"structural counter {child_path} must be non-negative"
+                        )
+                    rows.append({"path": child_path, "value": child})
+                else:
+                    visit(child, child_path)
+        elif isinstance(item, Sequence) and not isinstance(item, str | bytes):
+            for index, child in enumerate(item):
+                visit(child, f"{path}[{index}]")
+
+    visit(value, "")
+    if not rows:
+        raise ValueError("execution lane has no explicit structural counters")
+    return rows
+
+
+def execution_lanes(
+    execution: Mapping[str, object],
+) -> tuple[tuple[str, Mapping[str, object]], ...]:
+    """Enumerate each logical execution lane; preserve physical aliases."""
+
+    kind = execution.get("kind")
+    if kind != "pyamplicol-runtime-execution":
+        return (("primary", execution),)
+
+    lanes: list[tuple[str, Mapping[str, object]]] = []
+
+    def add(record: object, path: str) -> None:
+        if not isinstance(record, Mapping):
+            raise ValueError(f"compiled execution lane {path} is malformed")
+        if not isinstance(record.get("dag_summary"), Mapping):
+            raise ValueError(f"compiled execution lane {path} lacks a DAG summary")
+        lanes.append((path, record))
+        helicity_sum = record.get("helicity_sum_execution")
+        if helicity_sum is not None:
+            add(helicity_sum, f"{path}.helicity_sum_execution")
+        for key in ("color_selector_executions", "helicity_selector_executions"):
+            wrappers = record.get(key, ())
+            if wrappers is None:
+                continue
+            if not isinstance(wrappers, Sequence) or isinstance(wrappers, str | bytes):
+                raise ValueError(f"compiled execution {path}.{key} is malformed")
+            for index, wrapper in enumerate(wrappers):
+                if not isinstance(wrapper, Mapping):
+                    raise ValueError(
+                        f"compiled execution {path}.{key}[{index}] is malformed"
+                    )
+                add(wrapper.get("execution"), f"{path}.{key}[{index}].execution")
+
+    add(execution, "primary")
+    return tuple(lanes)
+
+
+def _resolve_loose_payload(
+    root: Path,
+    process_id: str,
+    relative: str,
+) -> str | None:
+    candidates = (relative, f"processes/{process_id}/{relative}")
+    for candidate in candidates:
+        path = root / candidate
+        if path.is_file() and not path.is_symlink():
+            return candidate
+    return None
+
+
+def build_generation_structural_proof(
+    *,
+    artifact_root: Path,
+    process_id: str,
+    source_revision: str,
+    native_build_inputs_sha256: str,
+    execution_path: str,
+    execution_sha256: str,
+    execution: Mapping[str, object],
+    evaluator_container_path: str | None,
+    evaluator_container_index_sha256: str | None,
+) -> dict[str, object]:
+    """Build exact source/lane evidence from the private artifact staging tree."""
+
+    lanes = execution_lanes(execution)
+    member_records: dict[str, dict[str, object]] = {}
+    container_record: dict[str, object] | None = None
+    if evaluator_container_path is not None:
+        container = artifact_root / evaluator_container_path
+        if not container.is_file() or container.is_symlink():
+            raise ValueError("evaluator container is absent during structural proof")
+        with PacbinReader.open(container, verify_payloads=True) as reader:
+            if (
+                evaluator_container_index_sha256 is None
+                or reader.index.index_sha256 != evaluator_container_index_sha256
+            ):
+                raise ValueError("evaluator container index identity changed")
+            member_records = {
+                member.logical_path: {
+                    "logical_path": member.logical_path,
+                    "kind": member.kind.name.lower(),
+                    "length": member.length,
+                    "sha256": member.sha256,
+                }
+                for member in reader.members
+            }
+            container_record = {
+                "path": evaluator_container_path,
+                "sha256": sha256_file(container),
+                "size_bytes": container.stat().st_size,
+                "index_sha256": reader.index.index_sha256,
+                "member_count": len(reader.members),
+            }
+
+    loose_objects: dict[str, dict[str, object]] = {
+        execution_path: {
+            "path": execution_path,
+            "sha256": execution_sha256,
+            "size_bytes": (artifact_root / execution_path).stat().st_size,
+        }
+    }
+    used_members: set[str] = set()
+    lane_records: list[dict[str, object]] = []
+    roles: list[dict[str, str]] = []
+    for lane_id, lane in lanes:
+        referenced_loose: set[str] = {execution_path}
+        referenced_members: set[str] = set()
+
+        def include(
+            relative: str,
+            lane_loose: set[str],
+            lane_members: set[str],
+        ) -> None:
+            if relative in member_records:
+                lane_members.add(relative)
+                used_members.add(relative)
+                return
+            loose = _resolve_loose_payload(artifact_root, process_id, relative)
+            if loose is None:
+                # Some manifest paths are logical roots interpreted by the
+                # runtime rather than physical files.  Preserve them in the
+                # lane source map, but never claim them as persisted objects.
+                return
+            if loose in lane_loose:
+                return
+            lane_loose.add(loose)
+            path = artifact_root / loose
+            loose_objects.setdefault(
+                loose,
+                {
+                    "path": loose,
+                    "sha256": sha256_file(path),
+                    "size_bytes": path.stat().st_size,
+                },
+            )
+            if path.suffix == ".json":
+                try:
+                    nested = json.loads(path.read_text(encoding="utf-8"))
+                except (OSError, json.JSONDecodeError) as error:
+                    raise ValueError(
+                        f"referenced lane manifest is not valid JSON: {loose}"
+                    ) from error
+                for nested_relative in _payload_paths(nested):
+                    include(nested_relative, lane_loose, lane_members)
+
+        for relative in _payload_paths(lane):
+            include(relative, referenced_loose, referenced_members)
+        metrics = _structural_metrics(lane)
+        subtree_sha = canonical_sha256("execution-lane-subtree-v1", lane)
+        metric_sha = canonical_sha256("execution-lane-structural-metrics-v1", metrics)
+        lane_records.append(
+            {
+                "lane_id": lane_id,
+                "subtree_sha256": subtree_sha,
+                "structural_metrics_sha256": metric_sha,
+                "structural_metrics": metrics,
+                "loose_payload_paths": sorted(referenced_loose),
+                "pacbin_member_paths": sorted(referenced_members),
+            }
+        )
+        roles.extend(
+            {
+                "lane_id": lane_id,
+                "object_kind": "loose-payload",
+                "object_path": path,
+            }
+            for path in sorted(referenced_loose)
+        )
+        roles.extend(
+            {
+                "lane_id": lane_id,
+                "object_kind": "pacbin-member",
+                "object_path": path,
+            }
+            for path in sorted(referenced_members)
+        )
+
+    inventory: dict[str, object] = {
+        "status": "complete",
+        "loose_payloads": [loose_objects[path] for path in sorted(loose_objects)],
+        "pacbin_container": container_record,
+        "pacbin_members": [member_records[path] for path in sorted(used_members)],
+        "lanes": lane_records,
+        "roles": roles,
+    }
+    inventory["inventory_sha256"] = canonical_sha256(
+        "physical-lane-inventory-v1",
+        inventory,
+    )
+    proof: dict[str, object] = {
+        "schema": SCHEMA,
+        "status": "complete",
+        "process_id": process_id,
+        "source_identity": {
+            "git_revision": source_revision,
+            "native_build_inputs_sha256": native_build_inputs_sha256,
+        },
+        "execution": {
+            "path": execution_path,
+            "sha256": execution_sha256,
+            "kind": execution.get("kind"),
+            "color_accuracy": execution.get("color_accuracy"),
+        },
+        "semantic_maps": semantic_map_witnesses(execution),
+        "physical_lane_inventory": inventory,
+    }
+    proof["proof_content_sha256"] = canonical_sha256(
+        "generation-structural-source-proof-v1",
+        proof,
+    )
+    return proof
+
+
+def validate_generation_structural_proof(
+    raw: Mapping[str, object],
+    *,
+    artifact_root: Path,
+    expected_process_id: str,
+    expected_source_revision: str,
+    expected_native_build_inputs_sha256: str | None = None,
+    expected_execution_path: str | None = None,
+    expected_execution_sha256: str | None = None,
+    execution: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    """Recompute a generation proof and authenticate its persisted inventory."""
+
+    proof = dict(raw)
+    if proof.get("schema") != SCHEMA or proof.get("status") != "complete":
+        raise ValueError("generation structural proof schema/status is invalid")
+    if proof.get("process_id") != expected_process_id:
+        raise ValueError("generation structural proof process identity changed")
+    source_identity = proof.get("source_identity")
+    if not isinstance(source_identity, Mapping) or (
+        source_identity.get("git_revision") != expected_source_revision
+    ):
+        raise ValueError("generation structural proof source revision changed")
+    native_inputs = source_identity.get("native_build_inputs_sha256")
+    if (
+        not isinstance(native_inputs, str)
+        or len(native_inputs) != 64
+        or (
+            expected_native_build_inputs_sha256 is not None
+            and native_inputs != expected_native_build_inputs_sha256
+        )
+    ):
+        raise ValueError("generation structural proof native-input identity changed")
+    execution_identity = proof.get("execution")
+    if not isinstance(execution_identity, Mapping):
+        raise ValueError("generation structural proof execution identity is absent")
+    execution_path = execution_identity.get("path")
+    execution_sha = execution_identity.get("sha256")
+    if (
+        not isinstance(execution_path, str)
+        or not isinstance(execution_sha, str)
+        or (
+            expected_execution_path is not None
+            and execution_path != expected_execution_path
+        )
+        or (
+            expected_execution_sha256 is not None
+            and execution_sha != expected_execution_sha256
+        )
+    ):
+        raise ValueError("generation structural proof execution identity changed")
+    execution_file = artifact_root / execution_path
+    if (
+        not execution_file.is_file()
+        or execution_file.is_symlink()
+        or sha256_file(execution_file) != execution_sha
+    ):
+        raise ValueError("generation structural proof execution payload changed")
+    if execution is None:
+        loaded = json.loads(execution_file.read_text(encoding="utf-8"))
+        if not isinstance(loaded, Mapping):
+            raise ValueError("generation structural execution is not an object")
+        execution = loaded
+    if execution_identity.get("kind") != execution.get("kind") or (
+        execution_identity.get("color_accuracy") != execution.get("color_accuracy")
+    ):
+        raise ValueError("generation structural execution semantics changed")
+
+    maps = proof.get("semantic_maps")
+    if not isinstance(maps, Mapping):
+        raise ValueError("generation structural semantic maps are absent")
+    expected_maps = semantic_map_witnesses(execution)
+    if dict(maps) != expected_maps:
+        raise ValueError("generation structural semantic maps do not recompute")
+
+    inventory = proof.get("physical_lane_inventory")
+    if not isinstance(inventory, Mapping) or inventory.get("status") != "complete":
+        raise ValueError("generation structural physical inventory is incomplete")
+    inventory_value = dict(inventory)
+    declared_inventory_sha = inventory_value.pop("inventory_sha256", None)
+    if declared_inventory_sha != canonical_sha256(
+        "physical-lane-inventory-v1",
+        inventory_value,
+    ):
+        raise ValueError("generation structural inventory digest changed")
+
+    loose = inventory.get("loose_payloads")
+    if not isinstance(loose, list) or not loose:
+        raise ValueError("generation structural loose-payload inventory is empty")
+    loose_paths: set[str] = set()
+    content_ids: set[str] = set()
+    for index, item in enumerate(loose):
+        if not isinstance(item, Mapping):
+            raise ValueError(f"generation structural loose payload {index} is invalid")
+        path = item.get("path")
+        digest = item.get("sha256")
+        size = item.get("size_bytes")
+        if (
+            not isinstance(path, str)
+            or path in loose_paths
+            or not isinstance(digest, str)
+            or not isinstance(size, int)
+            or isinstance(size, bool)
+            or size < 0
+        ):
+            raise ValueError(f"generation structural loose payload {index} is invalid")
+        loose_paths.add(path)
+        concrete = artifact_root / path
+        if (
+            not concrete.is_file()
+            or concrete.is_symlink()
+            or concrete.stat().st_size != size
+            or sha256_file(concrete) != digest
+        ):
+            raise ValueError(f"generation structural loose payload {path} changed")
+        content_ids.add(digest)
+
+    members = inventory.get("pacbin_members")
+    if not isinstance(members, list):
+        raise ValueError("generation structural pacbin member inventory is invalid")
+    container = inventory.get("pacbin_container")
+    actual_members: dict[str, dict[str, object]] = {}
+    if container is not None:
+        if not isinstance(container, Mapping):
+            raise ValueError("generation structural pacbin container is invalid")
+        path = container.get("path")
+        if not isinstance(path, str):
+            raise ValueError("generation structural pacbin container path is invalid")
+        concrete = artifact_root / path
+        if (
+            not concrete.is_file()
+            or concrete.is_symlink()
+            or concrete.stat().st_size != container.get("size_bytes")
+            or sha256_file(concrete) != container.get("sha256")
+        ):
+            raise ValueError("generation structural pacbin container changed")
+        with PacbinReader.open(concrete, verify_payloads=True) as reader:
+            if reader.index.index_sha256 != container.get("index_sha256") or len(
+                reader.members
+            ) != container.get("member_count"):
+                raise ValueError("generation structural pacbin index changed")
+            actual_members = {
+                member.logical_path: {
+                    "logical_path": member.logical_path,
+                    "kind": member.kind.name.lower(),
+                    "length": member.length,
+                    "sha256": member.sha256,
+                }
+                for member in reader.members
+            }
+    declared_member_paths: set[str] = set()
+    for index, item in enumerate(members):
+        if not isinstance(item, Mapping):
+            raise ValueError(f"generation structural pacbin member {index} is invalid")
+        path = item.get("logical_path")
+        if not isinstance(path, str) or path in declared_member_paths:
+            raise ValueError(f"generation structural pacbin member {index} is invalid")
+        declared_member_paths.add(path)
+        if actual_members.get(path) != dict(item):
+            raise ValueError(f"generation structural pacbin member {path} changed")
+        digest = item.get("sha256")
+        if isinstance(digest, str):
+            content_ids.add(digest)
+    if container is None and members:
+        raise ValueError("generation structural pacbin members lack a container")
+
+    lane_values = inventory.get("lanes")
+    roles = inventory.get("roles")
+    if not isinstance(lane_values, list) or not isinstance(roles, list):
+        raise ValueError("generation structural lane/role inventory is invalid")
+    expected_lanes = execution_lanes(execution)
+    if len(lane_values) != len(expected_lanes):
+        raise ValueError("generation structural lane count changed")
+    lane_ids: set[str] = set()
+    for raw_lane, (lane_id, lane) in zip(
+        lane_values,
+        expected_lanes,
+        strict=True,
+    ):
+        if not isinstance(raw_lane, Mapping) or raw_lane.get("lane_id") != lane_id:
+            raise ValueError("generation structural lane identity changed")
+        if lane_id in lane_ids:
+            raise ValueError("generation structural lane identity is duplicated")
+        lane_ids.add(lane_id)
+        metrics = _structural_metrics(lane)
+        if (
+            raw_lane.get("subtree_sha256")
+            != canonical_sha256("execution-lane-subtree-v1", lane)
+            or raw_lane.get("structural_metrics") != metrics
+            or raw_lane.get("structural_metrics_sha256")
+            != canonical_sha256("execution-lane-structural-metrics-v1", metrics)
+        ):
+            raise ValueError("generation structural lane evidence changed")
+        loose_refs = raw_lane.get("loose_payload_paths")
+        member_refs = raw_lane.get("pacbin_member_paths")
+        if (
+            not isinstance(loose_refs, list)
+            or not set(loose_refs) <= loose_paths
+            or not isinstance(member_refs, list)
+            or not set(member_refs) <= declared_member_paths
+        ):
+            raise ValueError("generation structural lane references are incomplete")
+    expected_roles = {
+        (
+            str(lane["lane_id"]),
+            "loose-payload",
+            str(path),
+        )
+        for lane in lane_values
+        if isinstance(lane, Mapping)
+        for path in lane.get("loose_payload_paths", ())
+    } | {
+        (
+            str(lane["lane_id"]),
+            "pacbin-member",
+            str(path),
+        )
+        for lane in lane_values
+        if isinstance(lane, Mapping)
+        for path in lane.get("pacbin_member_paths", ())
+    }
+    actual_roles = {
+        (
+            str(role.get("lane_id")),
+            str(role.get("object_kind")),
+            str(role.get("object_path")),
+        )
+        for role in roles
+        if isinstance(role, Mapping)
+    }
+    if actual_roles != expected_roles or len(actual_roles) != len(roles):
+        raise ValueError("generation structural role coverage is not exact")
+
+    declared_proof_sha = proof.pop("proof_content_sha256", None)
+    if declared_proof_sha != canonical_sha256(
+        "generation-structural-source-proof-v1",
+        proof,
+    ):
+        raise ValueError("generation structural proof content digest changed")
+    return dict(raw)
+
+
+__all__ = [
+    "ROLE",
+    "SCHEMA",
+    "SEMANTIC_MAP_DOMAINS",
+    "build_generation_structural_proof",
+    "canonical_sha256",
+    "execution_lanes",
+    "semantic_map_witnesses",
+    "validate_generation_structural_proof",
+]
diff --git a/pyamplicol/src/pyamplicol/generation/umami_semantics.py b/pyamplicol/src/pyamplicol/generation/umami_semantics.py
new file mode 100644
index 0000000000..ca2a6371fc
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/umami_semantics.py
@@ -0,0 +1,461 @@
+# SPDX-License-Identifier: 0BSD
+"""Conservative, model-independent equality keys for UMAMI representatives.
+
+These keys describe the executed recurrence circuit, not its particle names or
+its values at sample points.  Local callable expressions are interned after
+binding their inputs; mutable parameter names remain free symbols.  Different
+arena layouts can miss an equality, which is preferable to guessing one.
+This export-only analysis never modifies the numerical schedule.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING
+
+from .._internal.physics.symbols import ModelSymbolRegistry
+from ..api.errors import ArtifactError
+
+if TYPE_CHECKING:
+    from ..models.contracts import CompiledModelIR
+    from ..models.prepared import PreparedKernelPack, PreparedKernelRecord
+    from .recurrence_schedule_sharing import RecurrenceProcessRemap
+
+_TOKEN = re.compile(r"[A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*")
+_NONE = (1 << 32) - 1
+
+
+def _key(value: object) -> str:
+    digest = hashlib.sha256()
+    for chunk in json.JSONEncoder(
+        sort_keys=True, separators=(",", ":"), allow_nan=False
+    ).iterencode(value):
+        digest.update(chunk.encode("utf-8"))
+    return digest.hexdigest()
+
+
+class ParameterSemantics:
+    """Resolve definitions, never substitute the defaults of external inputs."""
+
+    def __init__(
+        self,
+        ir: CompiledModelIR | Mapping[str, object],
+        catalog_parameters: Sequence[object] = (),
+    ):
+        payload = ir if isinstance(ir, Mapping) else ir.to_dict()
+        self._parameters = {str(p["name"]): p for p in _objects(payload["parameters"])}
+        self._couplings = {str(c["name"]): c for c in _objects(payload["couplings"])}
+        parameter_names = {
+            p.template_id: p.name
+            for p in catalog_parameters
+            if hasattr(p, "template_id")
+        }
+        # Contact decomposition can introduce derived couplings not present in
+        # the original UFO IR. The catalog already certifies their exact
+        # expression and external dependencies; do not compare their defaults.
+        self._derived = {
+            p.name: (
+                p.value_type,
+                p.exact_expression_digest,
+                tuple(parameter_names[i] for i in p.dependency_parameter_ids),
+            )
+            for p in catalog_parameters
+            if getattr(p, "parameter_kind", None) == "derived"
+        }
+        registry = ModelSymbolRegistry(str(payload["name"]))
+        self._names = {
+            spelling: name
+            for name in (*self._parameters, *self._couplings, *self._derived)
+            for spelling in (name, registry.qualified_name(name))
+        }
+        self._cache: dict[str, object] = {}
+        self._active: set[str] = set()
+
+    def parameter(self, name: str) -> object:
+        if name in self._cache:
+            return self._cache[name]
+        if name in self._active:
+            raise ValueError("cyclic symbolic parameter definition")
+        self._active.add(name)
+        try:
+            parameter = self._parameters.get(name)
+            coupling = self._couplings.get(name)
+            if parameter is not None:
+                if parameter["nature"] == "external":
+                    value: object = ("external", name, parameter["parameter_type"])
+                elif parameter.get("expression") is not None:
+                    value = self.expression(
+                        str(
+                            parameter.get("resolved_expression")
+                            or parameter["expression"]
+                        )
+                    )
+                else:
+                    value = (
+                        "constant",
+                        parameter["parameter_type"],
+                        parameter.get("value"),
+                    )
+            elif coupling is not None:
+                value = self.expression(
+                    str(coupling.get("resolved_expression") or coupling["expression"])
+                )
+            elif name in self._derived:
+                value_type, expression_digest, dependencies = self._derived[name]
+                if not expression_digest:
+                    raise ValueError("derived parameter has no exact expression")
+                value = (
+                    "derived-catalog-parameter",
+                    value_type,
+                    expression_digest,
+                    tuple(self.parameter(dependency) for dependency in dependencies),
+                )
+            else:
+                # Runtime-owned parameters retain their actual names.  There
+                # is no model-specific interpretation or default-value match.
+                value = ("runtime-parameter", name)
+            self._cache[name] = value
+            return value
+        finally:
+            self._active.remove(name)
+
+    def expression(
+        self, expression: str, bindings: Mapping[str, object] | None = None
+    ) -> object:
+        local = bindings or {}
+        # A prepared input can be a Symbolica function atom such as p(0),
+        # rather than an identifier. Match complete declared inputs before
+        # ordinary tokens, so their roles/components cannot be lost.
+        scanner = (
+            re.compile(
+                r"(?<![A-Za-z_0-9:])(?:"
+                + "|".join(
+                    re.escape(name) for name in sorted(local, key=len, reverse=True)
+                )
+                + r")(?![A-Za-z_0-9:])|"
+                + _TOKEN.pattern
+            )
+            if local
+            else _TOKEN
+        )
+        pieces: list[object] = []
+        end = 0
+        for match in scanner.finditer(expression):
+            pieces.append(expression[end : match.start()])
+            token = match.group()
+            if token in local:
+                pieces.append(("input", local[token]))
+            elif token in self._names:
+                pieces.append(("parameter", self.parameter(self._names[token])))
+            else:
+                pieces.append(token)
+            end = match.end()
+        pieces.append(expression[end:])
+        return ("expression", tuple(pieces))
+
+
+def _kernel_key(
+    kernel: PreparedKernelRecord,
+    parameters: ParameterSemantics,
+    parameter_names: Mapping[int, str],
+    coupling: object,
+    parent_permutation: tuple[int, int],
+) -> str:
+    bindings: dict[str, object] = {}
+    for contract in kernel.input_contracts:
+        role = str(contract["role"])
+        component = int(contract["component"])
+        if role == "model-parameter":
+            name = parameter_names[int(contract["model_parameter_index"])]
+            value: object = (role, parameters.parameter(name), component)
+        elif role in {"coupling-real", "coupling-imag"}:
+            value = (role, coupling, component)
+        else:
+            value = (role, component)
+        bindings[str(contract["symbol"])] = value
+    return _key(
+        (
+            kernel.contract_kind,
+            # The ordered expressions define the output coordinates. Display
+            # labels may contain auxiliary/contact IDs, which are not algebra.
+            len(kernel.output_layout),
+            parent_permutation,
+            [
+                parameters.expression(expr, bindings)
+                for expr in kernel.exact_expressions
+            ],
+        )
+    )
+
+
+def _exact_executor_couplings(pack, exact_ids: Mapping[int, int]) -> dict[int, object]:
+    """Bind exact rationals, without Decimal rounding at ambient precision."""
+    catalog = pack.recurrence_template_catalog
+    records = {
+        record.template_id: record
+        for record in (*catalog.transitions, *catalog.closures)
+    }
+    kernels = {record.kernel_id: record for record in pack.kernels}
+    result = {}
+    for direct in pack.recurrence_direct_template_catalog.templates:
+        kernel_id = exact_ids.get(direct.direct_executor_id)
+        if kernel_id is None or not any(
+            contract["role"] in {"coupling-real", "coupling-imag"}
+            for contract in kernels[kernel_id].input_contracts
+        ):
+            continue
+        values = set()
+        for template_id in direct.semantic_template_ids:
+            value = records[template_id].binding_coupling
+            values.add(
+                (
+                    int(value.real_numerator),
+                    int(value.real_denominator),
+                    int(value.imag_numerator),
+                    int(value.imag_denominator),
+                )
+            )
+        if len(values) != 1:
+            raise ValueError("executor has no uniform exact coupling")
+        result[direct.direct_executor_id] = next(iter(values))
+    return result
+
+
+def recurrence_structural_keys(
+    *,
+    exact_sections: Mapping[str, object],
+    runtime_metadata: Mapping[str, object],
+    kernel_pack: PreparedKernelPack,
+    ir: CompiledModelIR | Mapping[str, object],
+    physics: Mapping[str, object],
+    remap: RecurrenceProcessRemap,
+    color_contraction_payload: bytes | None,
+) -> dict[str, str]:
+    """Prove equality only for fully comparable, unremapped exact circuits.
+
+    The same ordered instruction graph and fully bound local operations imply the
+    same amplitudes for every momentum/parameter value.  Colour contraction and
+    normalization are included, so equality is of the complete squared observable.
+    Unknown plans return no key; ordinary generation/evaluation stays available.
+    """
+    if exact_sections.get("abi") != "pyamplicol-recurrence-exact-sections-v1":
+        return {}
+    if physics.get("color_accuracy") != "lc" and color_contraction_payload is None:
+        return {}
+    if (
+        remap.source_slots != tuple(range(len(remap.source_slots)))
+        or any(
+            v != 1 for v in (*remap.source_momentum_signs, *remap.source_helicity_signs)
+        )
+        or remap.state_template_changes
+        or remap.source_template_changes
+        or remap.direct_executor_changes
+        or remap.parameter_slot_changes
+        or any(
+            remap.source_state_indices[start:end] != tuple(range(end - start))
+            for start, end in zip(
+                remap.source_state_offsets[:-1],
+                remap.source_state_offsets[1:],
+                strict=True,
+            )
+        )
+        or remap.public_flow_ids != tuple(range(len(remap.public_flow_ids)))
+        or remap.physical_sector_ids != tuple(range(len(remap.physical_sector_ids)))
+    ):
+        return {}
+    catalog = kernel_pack.recurrence_template_catalog
+    direct_catalog = kernel_pack.recurrence_direct_template_catalog
+    if catalog is None or direct_catalog is None:
+        return {}
+    # Reuse the exact executor's authoritative bindings, including intrinsics
+    # whose algebraic kernel is distinct from their native callable payload.
+    from ..runtime.recurrence_exact._plan import (
+        _executor_exact_kernel_ids,
+        _executor_parent_permutations,
+    )
+
+    try:
+        exact_ids = _executor_exact_kernel_ids(kernel_pack)
+        couplings = _exact_executor_couplings(kernel_pack, exact_ids)
+        parent_orders = _executor_parent_permutations(kernel_pack)
+        parameter_names = {
+            p.prepared_parameter_id: p.name
+            for p in catalog.parameters
+            if p.prepared_parameter_id is not None
+        }
+        parameters = ParameterSemantics(ir, catalog.parameters)
+        kernels = {k.kernel_id: k for k in kernel_pack.kernels}
+        # The exported executor catalog can cover the entire prepared model;
+        # only referenced operations are part of this process's circuit.
+        used_executors = {int(r[3]) for r in _rows(exact_sections["row_groups"])} | {
+            int(r[10]) for r in _rows(exact_sections["source_dispatch_variants"])
+        }
+        used_executors.discard(_NONE)
+        executor_keys: dict[int, str] = {}
+        for row in _rows(exact_sections["executors"]):
+            executor_id = int(row[0])
+            if executor_id not in used_executors:
+                continue
+            kernel_id = exact_ids.get(executor_id)
+            expression = (
+                _kernel_key(
+                    kernels[kernel_id],
+                    parameters,
+                    parameter_names,
+                    couplings.get(executor_id, ()),
+                    parent_orders.get(executor_id, (0, 1)),
+                )
+                if kernel_id is not None
+                else ("intrinsic", row[7])
+            )
+            if kernel_id is None:
+                # Source algorithms are specified by the source IR below;
+                # diagonal closure reduction uses the retained exact factors
+                # and closure rows. The identity finalizer is parameter-free.
+                from ..models.recurrence_direct_template import (
+                    RECURRENCE_DIRECT_IDENTITY_FINALIZER,
+                )
+
+                closure_reduction = row[1] == "closure" and re.fullmatch(
+                    r"rusticol\.closure-reduce\.v1:[0-9a-f]{24}", str(row[7])
+                )
+                if row[7] is None or (
+                    row[1] != "source"
+                    and not closure_reduction
+                    and row[7] != RECURRENCE_DIRECT_IDENTITY_FINALIZER
+                ):
+                    return {}
+                if row[1] == "source":
+                    # The suffix identifies a source's full catalog record
+                    # (including flavour labels); its executable algorithm is
+                    # the prefix and its bound physics is the SourceIR below.
+                    # Strip only this documented digest format, not arbitrary
+                    # text from an unfamiliar source implementation.
+                    source_algorithm = re.fullmatch(
+                        r"(rusticol\.source-fill\.[a-z0-9_-]+\.v1):[0-9a-f]{24}",
+                        str(row[7]),
+                    )
+                    if source_algorithm is None:
+                        return {}
+                    expression = ("intrinsic", source_algorithm[1])
+            executor_keys[executor_id] = _key((row[1:6], expression))
+        source_keys: dict[int, str] = {}
+        for item in _objects(runtime_metadata["source_templates"]):
+            source_ir = _mapping(item["source_ir"])
+            identity = _mapping(source_ir["identity"])
+            mass_name = source_ir.get("mass_parameter")
+            source_keys[int(item["source_template_id"])] = _key(
+                (
+                    item["dimension"],
+                    item["helicity"],
+                    item["chirality"],
+                    item["spin_state"],
+                    source_ir["wavefunction_family"],
+                    identity["orientation"],
+                    item["crossing"],
+                    source_ir["statistics"],
+                    source_ir["component_dimension"],
+                    source_ir["basis"],
+                    None
+                    if source_ir.get("width_parameter") is None
+                    else parameters.parameter(str(source_ir["width_parameter"])),
+                    None if mass_name is None else parameters.parameter(str(mass_name)),
+                )
+            )
+        program = {
+            k: v
+            for k, v in exact_sections.items()
+            if k
+            not in {
+                "process_id",
+                "semantic_digest",
+                "runtime_layout_digest",
+                "executors",
+            }
+        }
+        # Current IDs and state-template IDs are diagnostic; the actual arena
+        # ranges, stage clearing, bound source operations and kernels remain.
+        program["currents"] = [
+            [None, r[1], None, *r[3:]] for r in _rows(program["currents"])
+        ]
+        program["row_groups"] = [
+            [*r[:3], None if r[3] == _NONE else executor_keys[int(r[3])], *r[4:]]
+            for r in _rows(program["row_groups"])
+        ]
+        if program["strategy"] != "all-flow-union":
+            program["sources"] = [
+                [*r[:3], source_keys[int(r[3])], *r[4:]]
+                for r in _rows(program["sources"])
+            ]
+        program["source_dispatch_variants"] = [
+            [
+                *r[:6],
+                source_keys[int(r[6])],
+                None,
+                None,
+                r[9],
+                None if r[10] == _NONE else executor_keys[int(r[10])],
+                *r[11:],
+            ]
+            for r in _rows(program["source_dispatch_variants"])
+        ]
+        # Keep all normalization dependencies, not just their default number.
+        normalization = runtime_metadata["normalization"]
+        external_layout = [
+            (v["source_slot"], v["is_initial"])
+            for v in _objects(runtime_metadata["external_legs"])
+        ]
+        parameter_projection = [
+            (
+                v["runtime_slot"],
+                parameters.parameter(str(v["runtime_name"])),
+                v["component"],
+            )
+            for v in _objects(runtime_metadata["parameter_projection"])
+        ]
+        color_key = (
+            None
+            if color_contraction_payload is None
+            else hashlib.sha256(color_contraction_payload).hexdigest()
+        )
+        circuit = _key(
+            (
+                program,
+                normalization,
+                external_layout,
+                parameter_projection,
+                physics["color_accuracy"],
+                color_key,
+                [h["values"] for h in _objects(physics["helicities"])],
+            )
+        )
+        return {
+            str(c["id"]): _key((circuit, c["index"], c.get("coefficient", 1.0)))
+            for c in _objects(physics["color_components"])
+        }
+    except (ArtifactError, KeyError, TypeError, ValueError, IndexError):
+        # Unsupported/missing semantic data cannot authorize grouping.
+        return {}
+
+
+def _mapping(value: object) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise TypeError("semantic record must be a mapping")
+    return value
+
+
+def _sequence(value: object) -> Sequence[object]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise TypeError("semantic records must be a sequence")
+    return value
+
+
+def _rows(value: object) -> tuple[Sequence[object], ...]:
+    return tuple(_sequence(v) for v in _sequence(value))
+
+
+def _objects(value: object) -> tuple[Mapping[str, object], ...]:
+    return tuple(_mapping(v) for v in _sequence(value))
diff --git a/pyamplicol/src/pyamplicol/generation/validation.py b/pyamplicol/src/pyamplicol/generation/validation.py
new file mode 100644
index 0000000000..f3dff78d21
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/generation/validation.py
@@ -0,0 +1,226 @@
+# SPDX-License-Identifier: 0BSD
+"""Deterministic validation-point records for generated process artifacts."""
+
+from __future__ import annotations
+
+import hashlib
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING
+
+from ..models.base import Model
+from .dag_types import GenericDAG
+from .phase_space import massive_rambo_final_state
+
+if TYPE_CHECKING:
+    from .contracts import CanonicalProcessIR
+
+FourMomentum = tuple[float, float, float, float]
+
+
+@dataclass(frozen=True, slots=True)
+class ValidationPointRecord:
+    process_id: str
+    process: str
+    seed: int
+    particles: tuple[tuple[int, FourMomentum], ...] = ()
+    error: str | None = None
+
+    @property
+    def available(self) -> bool:
+        return self.error is None
+
+    @property
+    def four_vectors(self) -> tuple[FourMomentum, ...]:
+        if not self.available:
+            return ()
+        return tuple(momentum for _pdg, momentum in self.particles)
+
+    def to_mapping(self) -> dict[str, object]:
+        points: list[object] = []
+        if self.available:
+            points.append(
+                [
+                    {
+                        "pdg": pdg,
+                        "momentum": [_decimal_string(value) for value in momentum],
+                    }
+                    for pdg, momentum in self.particles
+                ]
+            )
+        return {
+            "schema_version": 1,
+            "kind": "pyamplicol-rusticol-validation-momenta",
+            "process_id": self.process_id,
+            "process": self.process,
+            "seed": self.seed,
+            "available": self.available,
+            "error": self.error,
+            "points": points,
+        }
+
+
+def build_validation_point(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    process_id: str,
+    seed: int,
+) -> ValidationPointRecord:
+    return build_process_validation_point(
+        dag.process,
+        model,
+        process_id=process_id,
+        seed=seed,
+    )
+
+
+def build_process_validation_point(
+    process: CanonicalProcessIR,
+    model: Model,
+    *,
+    process_id: str,
+    seed: int,
+) -> ValidationPointRecord:
+    """Build validation momenta without requiring a materialized DAG."""
+
+    try:
+        particles = _build_particles(process, model, seed=seed)
+    except (ArithmeticError, KeyError, RuntimeError, ValueError) as exc:
+        return ValidationPointRecord(
+            process_id=process_id,
+            process=process.process,
+            seed=seed,
+            error=str(exc),
+        )
+    return ValidationPointRecord(
+        process_id=process_id,
+        process=process.process,
+        seed=seed,
+        particles=particles,
+    )
+
+
+def rotate_validation_point(
+    point: ValidationPointRecord,
+    *,
+    rotation_seed: int,
+) -> ValidationPointRecord:
+    """Apply a deterministic proper rotation to one physical event."""
+
+    if not point.available:
+        return point
+    digest = hashlib.sha256(
+        f"{rotation_seed}:proper-spatial-rotation-v1".encode("ascii")
+    ).digest()
+    denominator = float(1 << 64)
+    azimuth = 2.0 * math.pi * (
+        (int.from_bytes(digest[:8], "big") + 0.5) / denominator
+    )
+    cosine_polar = (
+        2.0 * ((int.from_bytes(digest[8:16], "big") + 0.5) / denominator)
+        - 1.0
+    )
+    sine_polar = math.sqrt(max(0.0, 1.0 - cosine_polar * cosine_polar))
+    cos_azimuth = math.cos(azimuth)
+    sin_azimuth = math.sin(azimuth)
+    # Rz(azimuth) Ry(polar), a proper orthogonal map taking +z to the
+    # deterministic direction above.
+    rotation = (
+        (
+            cos_azimuth * cosine_polar,
+            -sin_azimuth,
+            cos_azimuth * sine_polar,
+        ),
+        (
+            sin_azimuth * cosine_polar,
+            cos_azimuth,
+            sin_azimuth * sine_polar,
+        ),
+        (-sine_polar, 0.0, cosine_polar),
+    )
+
+    def rotated(momentum: FourMomentum) -> FourMomentum:
+        energy, x_component, y_component, z_component = momentum
+        spatial = (x_component, y_component, z_component)
+        return (
+            energy,
+            *tuple(
+                sum(row[column] * spatial[column] for column in range(3))
+                for row in rotation
+            ),
+        )
+
+    return replace(
+        point,
+        particles=tuple(
+            (pdg, rotated(momentum)) for pdg, momentum in point.particles
+        ),
+    )
+
+
+def validation_point_map(
+    records: tuple[ValidationPointRecord, ...],
+) -> Mapping[str, Mapping[str, object]]:
+    return {record.process_id: record.to_mapping() for record in records}
+
+
+def _build_particles(
+    process: CanonicalProcessIR,
+    model: Model,
+    *,
+    seed: int,
+) -> tuple[tuple[int, FourMomentum], ...]:
+    initial_pdgs = tuple(int(pdg) for pdg in process.initial_pdgs)
+    final_pdgs = tuple(int(pdg) for pdg in process.final_pdgs)
+    if len(initial_pdgs) != 2:
+        raise ValueError("validation momenta require a two-particle initial state")
+    if not final_pdgs:
+        raise ValueError("validation momenta require at least one final-state particle")
+    final_masses = tuple(_mass(model, pdg) for pdg in final_pdgs)
+    threshold = sum(final_masses)
+    if len(final_pdgs) == 1:
+        if threshold <= 0.0:
+            raise ValueError(
+                "no finite center-of-mass point exists for one massless final state"
+            )
+        sqrt_s = threshold
+        final_momenta: tuple[FourMomentum, ...] = ((float(sqrt_s), 0.0, 0.0, 0.0),)
+    else:
+        sqrt_s = max(1000.0, threshold + 100.0)
+        final_momenta = massive_rambo_final_state(
+            len(final_pdgs),
+            sqrt_s=sqrt_s,
+            masses=final_masses,
+            seed=seed,
+        )
+    beam_energy = 0.5 * sqrt_s
+    particles = (
+        (initial_pdgs[0], (beam_energy, 0.0, 0.0, beam_energy)),
+        (initial_pdgs[1], (beam_energy, 0.0, 0.0, -beam_energy)),
+        *tuple(zip(final_pdgs, final_momenta, strict=True)),
+    )
+    if not all(math.isfinite(value) for _, momentum in particles for value in momentum):
+        raise ArithmeticError("validation momenta contain non-finite components")
+    return particles
+
+
+def _mass(model: Model, pdg: int) -> float:
+    value = float(model.mass(pdg))
+    if not math.isfinite(value) or value < 0.0:
+        raise ValueError(f"particle {pdg} has invalid mass {value!r}")
+    return value
+
+
+def _decimal_string(value: float) -> str:
+    return format(float(value), ".17g")
+
+
+__all__ = [
+    "ValidationPointRecord",
+    "build_process_validation_point",
+    "build_validation_point",
+    "rotate_validation_point",
+    "validation_point_map",
+]
diff --git a/pyamplicol/src/pyamplicol/licensing.py b/pyamplicol/src/pyamplicol/licensing.py
new file mode 100644
index 0000000000..f8bf9bda9f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/licensing.py
@@ -0,0 +1,311 @@
+# SPDX-License-Identifier: 0BSD
+"""Symbolica licensing and generation-resource policy."""
+
+from __future__ import annotations
+
+import importlib
+import os
+import sys
+import threading
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from types import ModuleType
+from typing import TextIO
+
+from pyamplicol.config import (
+    Action,
+    ClampRequest,
+    ConfigResolution,
+    GenerationConfig,
+    RunConfig,
+    config_to_dict,
+    resolve_config,
+)
+
+_SUGGESTION_LOCK = threading.Lock()
+_SUGGESTION_EMITTED = False
+_RESOURCE_PATHS = frozenset(
+    {
+        "generation.workers",
+        "evaluator.optimization.cores",
+    }
+)
+
+
+@dataclass(frozen=True, slots=True)
+class SymbolicaLicenseState:
+    licensed: bool
+    restricted: bool
+
+
+def _load_symbolica() -> ModuleType:
+    return importlib.import_module("symbolica")
+
+
+def prepare_symbolica_environment(*, suppress_banner: bool) -> None:
+    """Set banner policy before Symbolica's first import."""
+
+    if suppress_banner:
+        os.environ["SYMBOLICA_HIDE_BANNER"] = "1"
+
+
+def detect_symbolica_license(
+    *,
+    suggest: bool = True,
+    json_mode: bool = False,
+    stream: TextIO | None = None,
+    loader: Callable[[], ModuleType] = _load_symbolica,
+) -> SymbolicaLicenseState:
+    """Query Symbolica's actual package-or-personal license state.
+
+    This call must stay within pyamplicol: OEM licenses are package-scoped.
+    """
+
+    prepare_symbolica_environment(suppress_banner=not suggest or json_mode)
+    module = loader()
+    checker = getattr(module, "is_licensed", None)
+    if not callable(checker):
+        raise RuntimeError("installed Symbolica does not provide is_licensed()")
+    licensed = bool(checker())
+    if not licensed and suggest and not json_mode:
+        _suggest_license(sys.stderr if stream is None else stream)
+    return SymbolicaLicenseState(licensed=licensed, restricted=not licensed)
+
+
+def _suggest_license(stream: TextIO) -> None:
+    global _SUGGESTION_EMITTED
+    with _SUGGESTION_LOCK:
+        if _SUGGESTION_EMITTED:
+            return
+        stream.write(
+            "pyAmpliCol is using Symbolica restricted mode (one generation "
+            "worker and one Symbolica core). Request a free license with "
+            "'pyamplicol request-symbolica-trial-license' or "
+            "'pyamplicol request-symbolica-hobbyist-license'.\n"
+        )
+        stream.flush()
+        _SUGGESTION_EMITTED = True
+
+
+def reset_suggestion_state_for_tests() -> None:
+    global _SUGGESTION_EMITTED
+    with _SUGGESTION_LOCK:
+        _SUGGESTION_EMITTED = False
+
+
+def _cpu_budget() -> int:
+    affinity = getattr(os, "sched_getaffinity", None)
+    if callable(affinity):
+        try:
+            return max(1, len(affinity(0)))
+        except OSError:
+            pass
+    return max(1, os.cpu_count() or 1)
+
+
+def symbolica_resource_clamps(
+    config: RunConfig,
+    state: SymbolicaLicenseState,
+    *,
+    cpu_budget: int | None = None,
+    process_count: int | None = None,
+) -> tuple[ClampRequest, ...]:
+    """Share one CPU budget across concrete-process workers and evaluator cores.
+
+    Licensed partitioning is deferred when the concrete process count is not yet
+    known. Restricted mode does not need that count and is always clamped eagerly.
+    """
+
+    if cpu_budget is not None and (
+        isinstance(cpu_budget, bool)
+        or not isinstance(cpu_budget, int)
+        or cpu_budget < 1
+    ):
+        raise ValueError("cpu_budget must be a positive integer")
+    if process_count is not None and (
+        isinstance(process_count, bool)
+        or not isinstance(process_count, int)
+        or process_count < 1
+    ):
+        raise ValueError("process_count must be a positive integer")
+    requested_workers = config.generation.workers
+    requested_cores = config.evaluator.optimization.cores
+    clamps: list[ClampRequest] = []
+
+    if state.restricted:
+        if requested_workers != 1:
+            clamps.append(
+                ClampRequest(
+                    "generation.workers",
+                    1,
+                    "Symbolica restricted mode permits one generation instance",
+                )
+            )
+        if requested_cores != 1:
+            clamps.append(
+                ClampRequest(
+                    "evaluator.optimization.cores",
+                    1,
+                    "Symbolica restricted mode permits one Symbolica core",
+                )
+            )
+        return tuple(clamps)
+
+    if process_count is None:
+        return ()
+
+    budget = _cpu_budget() if cpu_budget is None else cpu_budget
+    assert budget is not None
+    workers = (
+        min(process_count, budget)
+        if requested_workers == "auto"
+        else min(requested_workers, process_count, budget)
+    )
+    if requested_workers != workers:
+        clamps.append(
+            ClampRequest(
+                "generation.workers",
+                workers,
+                "shared affinity-aware CPU budget for concurrent process generation",
+            )
+        )
+    cores = (
+        max(1, budget // workers)
+        if requested_cores == "auto"
+        else min(requested_cores, max(1, budget // workers))
+    )
+    if requested_cores != cores:
+        clamps.append(
+            ClampRequest(
+                "evaluator.optimization.cores",
+                cores,
+                "shared affinity-aware CPU budget for Symbolica evaluator work",
+            )
+        )
+    return tuple(clamps)
+
+
+def resolve_symbolica_resource_config(
+    config: GenerationConfig | RunConfig | ConfigResolution | None,
+    state: SymbolicaLicenseState,
+    *,
+    cpu_budget: int | None = None,
+    process_count: int | None = None,
+) -> ConfigResolution:
+    """Apply current resource policy without losing original provenance.
+
+    Resource clamps are recalculated from the original requested values. This
+    removes provisional or stale process-count clamps while preserving unrelated
+    adjustments and their ordering.
+    """
+
+    if isinstance(config, ConfigResolution):
+        requested = config.requested
+        inherited = config.clamps
+    else:
+        requested = (
+            RunConfig(action=Action.GENERATE)
+            if config is None
+            else RunConfig(action=Action.GENERATE, generation=config)
+            if isinstance(config, GenerationConfig)
+            else config
+        )
+        inherited = ()
+
+    preserved = tuple(
+        ClampRequest(item.path, item.effective, item.reason)
+        for item in inherited
+        if item.path not in _RESOURCE_PATHS
+    )
+    base = resolve_config(config_to_dict(requested), clamps=preserved)
+    policy = symbolica_resource_clamps(
+        base.effective,
+        state,
+        cpu_budget=cpu_budget,
+        process_count=process_count,
+    )
+    replacements = {item.path: item for item in policy}
+    merged: list[ClampRequest] = []
+    emitted: set[str] = set()
+    for inherited_clamp in inherited:
+        if inherited_clamp.path in _RESOURCE_PATHS:
+            replacement = replacements.get(inherited_clamp.path)
+            if replacement is not None and inherited_clamp.path not in emitted:
+                merged.append(replacement)
+                emitted.add(inherited_clamp.path)
+            continue
+        merged.append(
+            ClampRequest(
+                inherited_clamp.path,
+                inherited_clamp.effective,
+                inherited_clamp.reason,
+            )
+        )
+    for policy_clamp in policy:
+        if policy_clamp.path not in emitted:
+            merged.append(policy_clamp)
+            emitted.add(policy_clamp.path)
+
+    return resolve_config(config_to_dict(requested), clamps=merged)
+
+
+def request_trial_license(
+    name: str,
+    email: str,
+    organization: str,
+    *,
+    loader: Callable[[], ModuleType] = _load_symbolica,
+) -> None:
+    _validate_identity((name, email, organization), requires_organization=True)
+    function = getattr(loader(), "request_trial_license", None)
+    if not callable(function):
+        raise RuntimeError(
+            "installed Symbolica does not provide request_trial_license()"
+        )
+    function(name, email, organization)
+
+
+def request_hobbyist_license(
+    name: str,
+    email: str,
+    *,
+    loader: Callable[[], ModuleType] = _load_symbolica,
+) -> None:
+    _validate_identity((name, email), requires_organization=False)
+    function = getattr(loader(), "request_hobbyist_license", None)
+    if not callable(function):
+        raise RuntimeError(
+            "installed Symbolica does not provide request_hobbyist_license()"
+        )
+    function(name, email)
+
+
+def _validate_identity(
+    values: Sequence[str],
+    *,
+    requires_organization: bool,
+) -> None:
+    expected = 3 if requires_organization else 2
+    if len(values) != expected or any(
+        not isinstance(value, str) or not value.strip() for value in values
+    ):
+        fields = (
+            "name, email, and organization"
+            if requires_organization
+            else "name and email"
+        )
+        raise ValueError(f"Symbolica license requests require non-empty {fields}")
+    email = values[1]
+    if "@" not in email or email.startswith("@") or email.endswith("@"):
+        raise ValueError("Symbolica license requests require a valid email address")
+
+
+__all__ = [
+    "SymbolicaLicenseState",
+    "detect_symbolica_license",
+    "prepare_symbolica_environment",
+    "request_hobbyist_license",
+    "request_trial_license",
+    "resolve_symbolica_resource_config",
+    "symbolica_resource_clamps",
+]
diff --git a/pyamplicol/src/pyamplicol/models/__init__.py b/pyamplicol/src/pyamplicol/models/__init__.py
new file mode 100644
index 0000000000..cdd2f889ec
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/__init__.py
@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+_LAZY_EXPORTS = {
+    "BuiltinSMModel": (".builtin", "BuiltinSMModel"),
+    "CompiledUFOModel": (".external", "CompiledUFOModel"),
+    "ModelCompileOptions": (".loading", "ModelCompileOptions"),
+    "compile_builtin_model_ir": (".compiler", "compile_builtin_model_ir"),
+    "compile_model_source": (".loading", "compile_model_source"),
+    "compile_ufo_model_ir": (".compiler", "compile_ufo_model_ir"),
+    "load_compiled_model": (".loading", "load_compiled_model"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    target = _LAZY_EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(name)
+    module_name, attribute = target
+    value = getattr(importlib.import_module(module_name, __name__), attribute)
+    globals()[name] = value
+    return value
+
+
+__all__ = [
+    "BuiltinSMModel",
+    "CompiledUFOModel",
+    "ModelCompileOptions",
+    "compile_builtin_model_ir",
+    "compile_model_source",
+    "compile_ufo_model_ir",
+    "load_compiled_model",
+]
diff --git a/pyamplicol/src/pyamplicol/models/_physics_ir.py b/pyamplicol/src/pyamplicol/models/_physics_ir.py
new file mode 100644
index 0000000000..4a888356ab
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/_physics_ir.py
@@ -0,0 +1,1108 @@
+# SPDX-License-Identifier: 0BSD
+"""Canonical, model-owned physics contracts used by generation and runtimes."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from numbers import Real
+from typing import Literal, cast
+
+ParticleOrientation = Literal["particle", "antiparticle", "self-conjugate"]
+ParticleStatistics = Literal["boson", "fermion", "ghost", "auxiliary"]
+WavefunctionFamily = Literal[
+    "scalar",
+    "fermion",
+    "vector",
+    "spin2",
+    "ghost",
+    "auxiliary",
+]
+MomentumTransform = Literal["identity", "negate-four-momentum"]
+PropagatorKind = Literal[
+    "identity",
+    "scalar",
+    "weyl-fermion",
+    "dirac-fermion",
+    "vector",
+    "spin2",
+    "custom",
+    "unsupported",
+]
+PropagatorGauge = Literal[
+    "feynman",
+    "unitary",
+    "de-donder",
+    "fierz-pauli",
+    "model-supplied",
+]
+PropagatorMassClass = Literal["massless", "massive", "not-applicable"]
+GoldstonePolicy = Literal[
+    "not-applicable",
+    "absorbed",
+    "explicit",
+    "model-supplied",
+]
+TensorFlattening = Literal["row-major-last-axis-fastest"]
+TENSOR_ORDERING_CONTRACT_VERSION = 1
+
+
+def _strict_ir_fields(
+    payload: Mapping[str, object],
+    *,
+    required: set[str],
+    context: str,
+) -> Mapping[str, object]:
+    if not isinstance(payload, Mapping):
+        raise TypeError(f"{context} must be a mapping")
+    fields = set(payload)
+    missing = required - fields
+    if missing:
+        names = ", ".join(sorted(missing))
+        raise ValueError(f"{context} is missing required fields: {names}")
+    unknown = fields - required
+    if unknown:
+        names = ", ".join(sorted(str(name) for name in unknown))
+        raise ValueError(f"{context} has unknown fields: {names}")
+    return payload
+
+
+def _strict_ir_sequence(value: object, context: str) -> tuple[object, ...]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise TypeError(f"{context} must be an array")
+    return tuple(value)
+
+
+@dataclass(frozen=True, slots=True)
+class TensorAxisIR:
+    """One semantic tensor axis, independent of a source UFO index label."""
+
+    name: str
+    space: str
+    extent: int
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.name, str) or not self.name:
+            raise ValueError("tensor axis name must be a non-empty string")
+        if not isinstance(self.space, str) or not self.space:
+            raise ValueError("tensor axis space must be a non-empty string")
+        if isinstance(self.extent, bool) or not isinstance(self.extent, int):
+            raise TypeError("tensor axis extent must be an integer")
+        if self.extent <= 0:
+            raise ValueError("tensor axis extent must be positive")
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {"name": self.name, "space": self.space, "extent": self.extent}
+
+    @classmethod
+    def from_json_dict(cls, payload: Mapping[str, object]) -> TensorAxisIR:
+        fields = _strict_ir_fields(
+            payload,
+            required={"name", "space", "extent"},
+            context="tensor axis IR",
+        )
+        name = fields["name"]
+        space = fields["space"]
+        extent = fields["extent"]
+        if not isinstance(name, str) or not isinstance(space, str):
+            raise TypeError("tensor axis name and space must be strings")
+        if isinstance(extent, bool) or not isinstance(extent, int):
+            raise TypeError("tensor axis extent must be an integer")
+        return cls(name=name, space=space, extent=extent)
+
+
+@dataclass(frozen=True, slots=True)
+class TensorOrderingIR:
+    """Content-addressed mapping from stored components to a canonical tensor."""
+
+    ordering_id: str
+    basis: str
+    axes: tuple[TensorAxisIR, ...]
+    flattening: TensorFlattening
+    component_basis: tuple[int, ...]
+    component_expansion: tuple[tuple[int, int] | None, ...]
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.basis, str) or not self.basis:
+            raise ValueError("tensor ordering basis must be a non-empty string")
+        if self.flattening != "row-major-last-axis-fastest":
+            raise ValueError(f"unsupported tensor flattening {self.flattening!r}")
+        if not all(isinstance(axis, TensorAxisIR) for axis in self.axes):
+            raise TypeError("tensor ordering axes must contain TensorAxisIR records")
+        axis_names = tuple(axis.name for axis in self.axes)
+        if len(set(axis_names)) != len(axis_names):
+            raise ValueError("tensor ordering axis names must be unique")
+        if not self.component_basis:
+            raise ValueError("tensor ordering component basis must not be empty")
+        if any(
+            isinstance(index, bool) or not isinstance(index, int)
+            for index in self.component_basis
+        ):
+            raise TypeError("tensor ordering component basis must contain integers")
+        canonical_size = self.canonical_size
+        if len(self.component_expansion) != canonical_size:
+            raise ValueError(
+                "tensor ordering expansion size does not match its canonical axes"
+            )
+        if len(set(self.component_basis)) != len(self.component_basis):
+            raise ValueError("tensor ordering component basis must be unique")
+        if any(index < 0 or index >= canonical_size for index in self.component_basis):
+            raise ValueError("tensor ordering component basis index is out of range")
+        referenced_slots: set[int] = set()
+        for entry in self.component_expansion:
+            if entry is None:
+                continue
+            if (
+                not isinstance(entry, tuple)
+                or len(entry) != 2
+                or any(
+                    isinstance(value, bool) or not isinstance(value, int)
+                    for value in entry
+                )
+            ):
+                raise TypeError(
+                    "tensor ordering expansion entries must be (slot, sign) pairs"
+                )
+            slot, sign = entry
+            if slot < 0 or slot >= self.stored_size:
+                raise ValueError("tensor ordering expansion refers to an absent slot")
+            if sign not in {-1, 1}:
+                raise ValueError("tensor ordering expansion sign must be +/-1")
+            referenced_slots.add(slot)
+        if referenced_slots != set(range(self.stored_size)):
+            raise ValueError(
+                "tensor ordering expansion does not cover every stored slot"
+            )
+        for slot, canonical_component in enumerate(self.component_basis):
+            if self.component_expansion[canonical_component] != (slot, 1):
+                raise ValueError(
+                    "tensor ordering component basis disagrees with its expansion"
+                )
+        expected_id = self.content_id(
+            basis=self.basis,
+            axes=self.axes,
+            flattening=self.flattening,
+            component_basis=self.component_basis,
+            component_expansion=self.component_expansion,
+        )
+        if self.ordering_id != expected_id:
+            raise ValueError(
+                "tensor ordering ID does not match its semantic component contract"
+            )
+
+    @property
+    def canonical_size(self) -> int:
+        return math.prod(axis.extent for axis in self.axes) if self.axes else 1
+
+    @property
+    def stored_size(self) -> int:
+        return len(self.component_basis)
+
+    @classmethod
+    def identity(
+        cls,
+        *,
+        basis: str,
+        axes: Sequence[TensorAxisIR],
+    ) -> TensorOrderingIR:
+        axis_tuple = tuple(axes)
+        size = math.prod(axis.extent for axis in axis_tuple) if axis_tuple else 1
+        component_basis = tuple(range(size))
+        component_expansion = tuple((index, 1) for index in range(size))
+        return cls.create(
+            basis=basis,
+            axes=axis_tuple,
+            component_basis=component_basis,
+            component_expansion=component_expansion,
+        )
+
+    @classmethod
+    def create(
+        cls,
+        *,
+        basis: str,
+        axes: Sequence[TensorAxisIR],
+        component_basis: Sequence[int],
+        component_expansion: Sequence[tuple[int, int] | None],
+        flattening: TensorFlattening = "row-major-last-axis-fastest",
+    ) -> TensorOrderingIR:
+        axis_tuple = tuple(axes)
+        basis_tuple = tuple(component_basis)
+        expansion_tuple = tuple(component_expansion)
+        return cls(
+            ordering_id=cls.content_id(
+                basis=basis,
+                axes=axis_tuple,
+                flattening=flattening,
+                component_basis=basis_tuple,
+                component_expansion=expansion_tuple,
+            ),
+            basis=basis,
+            axes=axis_tuple,
+            flattening=flattening,
+            component_basis=basis_tuple,
+            component_expansion=expansion_tuple,
+        )
+
+    @staticmethod
+    def content_id(
+        *,
+        basis: str,
+        axes: Sequence[TensorAxisIR],
+        flattening: TensorFlattening,
+        component_basis: Sequence[int],
+        component_expansion: Sequence[tuple[int, int] | None],
+    ) -> str:
+        payload = {
+            "basis": basis,
+            "axes": [axis.to_json_dict() for axis in axes],
+            "flattening": flattening,
+            "component_basis": list(component_basis),
+            "component_expansion": [
+                None if entry is None else list(entry) for entry in component_expansion
+            ],
+        }
+        canonical = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+        return "tensor-ordering-sha256:" + hashlib.sha256(
+            canonical.encode("utf-8")
+        ).hexdigest()
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "ordering_id": self.ordering_id,
+            "basis": self.basis,
+            "axes": [axis.to_json_dict() for axis in self.axes],
+            "flattening": self.flattening,
+            "component_basis": list(self.component_basis),
+            "component_expansion": [
+                None if entry is None else list(entry)
+                for entry in self.component_expansion
+            ],
+        }
+
+    @classmethod
+    def from_json_dict(cls, payload: Mapping[str, object]) -> TensorOrderingIR:
+        fields = _strict_ir_fields(
+            payload,
+            required={
+                "ordering_id",
+                "basis",
+                "axes",
+                "flattening",
+                "component_basis",
+                "component_expansion",
+            },
+            context="tensor ordering IR",
+        )
+        ordering_id = fields["ordering_id"]
+        basis = fields["basis"]
+        flattening = fields["flattening"]
+        if not all(
+            isinstance(value, str) for value in (ordering_id, basis, flattening)
+        ):
+            raise TypeError("tensor ordering ID, basis, and flattening must be strings")
+        axes = tuple(
+            TensorAxisIR.from_json_dict(axis)
+            for axis in _strict_ir_sequence(fields["axes"], "tensor ordering axes")
+            if isinstance(axis, Mapping)
+        )
+        axis_values = _strict_ir_sequence(fields["axes"], "tensor ordering axes")
+        if len(axes) != len(axis_values):
+            raise TypeError("tensor ordering axes must contain mappings")
+        component_basis_values = _strict_ir_sequence(
+            fields["component_basis"], "tensor ordering component basis"
+        )
+        if any(
+            isinstance(value, bool) or not isinstance(value, int)
+            for value in component_basis_values
+        ):
+            raise TypeError("tensor ordering component basis must contain integers")
+        expansion_values = _strict_ir_sequence(
+            fields["component_expansion"], "tensor ordering component expansion"
+        )
+        expansion: list[tuple[int, int] | None] = []
+        for entry in expansion_values:
+            if entry is None:
+                expansion.append(None)
+                continue
+            pair = _strict_ir_sequence(entry, "tensor ordering expansion entry")
+            if len(pair) != 2 or any(
+                isinstance(value, bool) or not isinstance(value, int) for value in pair
+            ):
+                raise TypeError(
+                    "tensor ordering expansion entry must be an integer pair"
+                )
+            expansion.append((pair[0], pair[1]))
+        return cls(
+            ordering_id=ordering_id,
+            basis=basis,
+            axes=axes,
+            flattening=cast(TensorFlattening, flattening),
+            component_basis=cast(tuple[int, ...], component_basis_values),
+            component_expansion=tuple(expansion),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class TensorIndexBindingIR:
+    """Provenance for one normalized tensor index used by a UFO vertex term."""
+
+    origin: str
+    space: str
+    source_component: int | None
+    source_leg: int | None
+    source_dummy: int | None
+    normalized_name: str
+
+    def __post_init__(self) -> None:
+        for field_name in ("origin", "space", "normalized_name"):
+            value = getattr(self, field_name)
+            if not isinstance(value, str) or not value:
+                raise ValueError(f"tensor index binding {field_name} must not be empty")
+        if (self.source_leg is None) == (self.source_dummy is None):
+            raise ValueError(
+                "tensor index binding must identify exactly one source leg or dummy"
+            )
+        for field_name in ("source_component", "source_leg", "source_dummy"):
+            value = getattr(self, field_name)
+            if value is not None and (
+                isinstance(value, bool) or not isinstance(value, int)
+            ):
+                raise TypeError(f"tensor index binding {field_name} must be an integer")
+        if self.source_component is not None and self.source_component < 0:
+            raise ValueError("tensor index source component must be non-negative")
+        if self.source_leg is not None and self.source_leg <= 0:
+            raise ValueError("tensor index source leg must be positive")
+        if self.source_dummy == 0:
+            raise ValueError("tensor index source dummy must be nonzero")
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "origin": self.origin,
+            "space": self.space,
+            "source_component": self.source_component,
+            "source_leg": self.source_leg,
+            "source_dummy": self.source_dummy,
+            "normalized_name": self.normalized_name,
+        }
+
+    @classmethod
+    def from_json_dict(cls, payload: Mapping[str, object]) -> TensorIndexBindingIR:
+        fields = _strict_ir_fields(
+            payload,
+            required={
+                "origin",
+                "space",
+                "source_component",
+                "source_leg",
+                "source_dummy",
+                "normalized_name",
+            },
+            context="tensor index binding IR",
+        )
+        for field_name in ("origin", "space", "normalized_name"):
+            if not isinstance(fields[field_name], str):
+                raise TypeError(f"tensor index binding {field_name} must be a string")
+        for field_name in ("source_component", "source_leg", "source_dummy"):
+            value = fields[field_name]
+            if value is not None and (
+                isinstance(value, bool) or not isinstance(value, int)
+            ):
+                raise TypeError(f"tensor index binding {field_name} must be an integer")
+        return cls(
+            origin=cast(str, fields["origin"]),
+            space=cast(str, fields["space"]),
+            source_component=cast(int | None, fields["source_component"]),
+            source_leg=cast(int | None, fields["source_leg"]),
+            source_dummy=cast(int | None, fields["source_dummy"]),
+            normalized_name=cast(str, fields["normalized_name"]),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledCurrentOrderingRecord:
+    """Map one stored current state to the full ordering used by kernels."""
+
+    particle: str
+    chirality: int
+    ordering_id: str
+    kernel_ordering_id: str
+    input_embedding: tuple[int | None, ...]
+    result_projection: tuple[int, ...]
+
+    def __post_init__(self) -> None:
+        for field_name in ("particle", "ordering_id", "kernel_ordering_id"):
+            value = getattr(self, field_name)
+            if not isinstance(value, str) or not value:
+                raise ValueError(f"current ordering {field_name} must not be empty")
+        if isinstance(self.chirality, bool) or not isinstance(self.chirality, int):
+            raise TypeError("current ordering chirality must be an integer")
+        if any(
+            value is not None
+            and (isinstance(value, bool) or not isinstance(value, int))
+            for value in self.input_embedding
+        ):
+            raise TypeError("current input embedding must contain integers or null")
+        if any(
+            isinstance(value, bool) or not isinstance(value, int)
+            for value in self.result_projection
+        ):
+            raise TypeError("current result projection must contain integers")
+
+    @property
+    def selector(self) -> tuple[str, int]:
+        return self.particle, self.chirality
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "particle": self.particle,
+            "chirality": self.chirality,
+            "ordering_id": self.ordering_id,
+            "kernel_ordering_id": self.kernel_ordering_id,
+            "input_embedding": list(self.input_embedding),
+            "result_projection": list(self.result_projection),
+        }
+
+    @classmethod
+    def from_json_dict(
+        cls, payload: Mapping[str, object]
+    ) -> CompiledCurrentOrderingRecord:
+        fields = _strict_ir_fields(
+            payload,
+            required={
+                "particle",
+                "chirality",
+                "ordering_id",
+                "kernel_ordering_id",
+                "input_embedding",
+                "result_projection",
+            },
+            context="compiled current ordering",
+        )
+        for field_name in ("particle", "ordering_id", "kernel_ordering_id"):
+            if not isinstance(fields[field_name], str):
+                raise TypeError(f"current ordering {field_name} must be a string")
+        chirality = fields["chirality"]
+        if isinstance(chirality, bool) or not isinstance(chirality, int):
+            raise TypeError("current ordering chirality must be an integer")
+        embedding = _strict_ir_sequence(
+            fields["input_embedding"], "current input embedding"
+        )
+        projection = _strict_ir_sequence(
+            fields["result_projection"], "current result projection"
+        )
+        return cls(
+            particle=cast(str, fields["particle"]),
+            chirality=chirality,
+            ordering_id=cast(str, fields["ordering_id"]),
+            kernel_ordering_id=cast(str, fields["kernel_ordering_id"]),
+            input_embedding=cast(tuple[int | None, ...], embedding),
+            result_projection=cast(tuple[int, ...], projection),
+        )
+
+
+def _integer(value: object, label: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{label} must be an integer")
+    return value
+
+
+def _boolean(value: object, label: str) -> bool:
+    if not isinstance(value, bool):
+        raise TypeError(f"{label} must be a boolean")
+    return value
+
+
+def _optional_string(value: object) -> str | None:
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise TypeError("optional propagator metadata must be a string or null")
+    return value
+
+
+def _particle_orientation(value: object) -> ParticleOrientation:
+    if value not in {"particle", "antiparticle", "self-conjugate"}:
+        raise ValueError(f"invalid particle orientation {value!r}")
+    return cast(ParticleOrientation, value)
+
+
+def _propagator_kind(value: object) -> PropagatorKind:
+    if value not in {
+        "identity",
+        "scalar",
+        "weyl-fermion",
+        "dirac-fermion",
+        "vector",
+        "spin2",
+        "custom",
+        "unsupported",
+    }:
+        raise ValueError(f"invalid propagator kind {value!r}")
+    return cast(PropagatorKind, value)
+
+
+def _optional_propagator_gauge(value: object) -> PropagatorGauge | None:
+    if value is None:
+        return None
+    if value not in {
+        "feynman",
+        "unitary",
+        "de-donder",
+        "fierz-pauli",
+        "model-supplied",
+    }:
+        raise ValueError(f"invalid propagator gauge {value!r}")
+    return cast(PropagatorGauge, value)
+
+
+def _goldstone_policy(value: object) -> GoldstonePolicy:
+    if value not in {
+        "not-applicable",
+        "absorbed",
+        "explicit",
+        "model-supplied",
+    }:
+        raise ValueError(f"invalid propagator Goldstone policy {value!r}")
+    return cast(GoldstonePolicy, value)
+
+
+def _propagator_mass_class(value: object) -> PropagatorMassClass:
+    if value not in {"massless", "massive", "not-applicable"}:
+        raise ValueError(f"invalid propagator mass class {value!r}")
+    return cast(PropagatorMassClass, value)
+
+
+@dataclass(frozen=True, slots=True)
+class ParticleIdentityIR:
+    """Identity of one oriented model state, independent of SM taxonomy."""
+
+    canonical_id: str
+    species_id: str
+    anti_canonical_id: str
+    display_name: str
+    anti_display_name: str
+    pdg_label: int
+    anti_pdg_label: int
+    orientation: ParticleOrientation
+    self_conjugate: bool
+
+    def __post_init__(self) -> None:
+        for field_name in (
+            "canonical_id",
+            "species_id",
+            "anti_canonical_id",
+            "display_name",
+            "anti_display_name",
+        ):
+            if not getattr(self, field_name):
+                raise ValueError(f"particle identity {field_name} must not be empty")
+        for field_name in ("pdg_label", "anti_pdg_label"):
+            value = getattr(self, field_name)
+            if isinstance(value, bool) or not isinstance(value, int):
+                raise TypeError(f"particle identity {field_name} must be an integer")
+        if self.orientation not in {
+            "particle",
+            "antiparticle",
+            "self-conjugate",
+        }:
+            raise ValueError(f"invalid particle orientation {self.orientation!r}")
+        if self.self_conjugate != (self.canonical_id == self.anti_canonical_id):
+            raise ValueError(
+                "particle self-conjugacy must agree with its canonical anti relation"
+            )
+        if self.self_conjugate != (self.pdg_label == self.anti_pdg_label):
+            raise ValueError(
+                "particle self-conjugacy must agree with its PDG-label anti relation"
+            )
+        if (self.orientation == "self-conjugate") != self.self_conjugate:
+            raise ValueError(
+                "self-conjugate source orientation must agree with particle identity"
+            )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "canonical_id": self.canonical_id,
+            "species_id": self.species_id,
+            "anti_canonical_id": self.anti_canonical_id,
+            "display_name": self.display_name,
+            "anti_display_name": self.anti_display_name,
+            "pdg_label": self.pdg_label,
+            "anti_pdg_label": self.anti_pdg_label,
+            "orientation": self.orientation,
+            "self_conjugate": self.self_conjugate,
+        }
+
+    @classmethod
+    def from_json_dict(cls, payload: Mapping[str, object]) -> ParticleIdentityIR:
+        return cls(
+            canonical_id=str(payload["canonical_id"]),
+            species_id=str(payload["species_id"]),
+            anti_canonical_id=str(payload["anti_canonical_id"]),
+            display_name=str(payload["display_name"]),
+            anti_display_name=str(payload["anti_display_name"]),
+            pdg_label=_integer(payload["pdg_label"], "particle PDG label"),
+            anti_pdg_label=_integer(
+                payload["anti_pdg_label"],
+                "antiparticle PDG label",
+            ),
+            orientation=_particle_orientation(payload["orientation"]),
+            self_conjugate=_boolean(
+                payload["self_conjugate"],
+                "particle self-conjugacy",
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class SourceStateIR:
+    helicity: int
+    chirality: int
+    spin_state: int | tuple[int, ...]
+
+    def __post_init__(self) -> None:
+        for field_name in ("helicity", "chirality"):
+            value = getattr(self, field_name)
+            if isinstance(value, bool) or not isinstance(value, int):
+                raise TypeError(f"source state {field_name} must be an integer")
+        if isinstance(self.spin_state, bool) or not isinstance(
+            self.spin_state, (int, tuple)
+        ):
+            raise TypeError("source spin state must be an integer or integer tuple")
+        if isinstance(self.spin_state, tuple) and not all(
+            isinstance(value, int) and not isinstance(value, bool)
+            for value in self.spin_state
+        ):
+            raise TypeError("source spin-state tuples must contain only integers")
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "helicity": self.helicity,
+            "chirality": self.chirality,
+            "spin_state": (
+                list(self.spin_state)
+                if isinstance(self.spin_state, tuple)
+                else self.spin_state
+            ),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class CrossingIR:
+    """Transform an outgoing source basis into an incoming physical leg."""
+
+    momentum_transform: MomentumTransform = "negate-four-momentum"
+    helicity_factor: int = 1
+    chirality_factor: int = 1
+    spin_state_factor: int = 1
+    phase: tuple[float, float] = (1.0, 0.0)
+
+    def __post_init__(self) -> None:
+        if self.momentum_transform not in {"identity", "negate-four-momentum"}:
+            raise ValueError(
+                f"unsupported crossing momentum transform {self.momentum_transform!r}"
+            )
+        for field_name in (
+            "helicity_factor",
+            "chirality_factor",
+            "spin_state_factor",
+        ):
+            value = getattr(self, field_name)
+            if isinstance(value, bool) or not isinstance(value, int):
+                raise TypeError(f"crossing {field_name} must be an integer")
+            if value not in {-1, 1}:
+                raise ValueError(f"crossing {field_name} must be -1 or 1")
+        if not isinstance(self.phase, (tuple, list)) or len(self.phase) != 2:
+            raise ValueError("crossing phase must be a finite complex pair")
+        if any(
+            isinstance(value, bool) or not isinstance(value, Real)
+            for value in self.phase
+        ):
+            raise TypeError("crossing phase components must be real numbers")
+        phase = (float(self.phase[0]), float(self.phase[1]))
+        if not all(math.isfinite(value) for value in phase):
+            raise ValueError("crossing phase must be a finite complex pair")
+        if phase == (0.0, 0.0):
+            raise ValueError("crossing phase must be nonzero")
+        object.__setattr__(self, "phase", phase)
+
+    @classmethod
+    def identity(cls) -> CrossingIR:
+        return cls(momentum_transform="identity")
+
+    def apply(self, state: SourceStateIR) -> SourceStateIR:
+        spin_state = state.spin_state
+        if self.spin_state_factor != 1:
+            if not isinstance(spin_state, int):
+                raise TypeError(
+                    "crossing cannot multiply a structured source spin state"
+                )
+            spin_state *= self.spin_state_factor
+        return SourceStateIR(
+            helicity=state.helicity * self.helicity_factor,
+            chirality=state.chirality * self.chirality_factor,
+            spin_state=spin_state,
+        )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "momentum_transform": self.momentum_transform,
+            "helicity_factor": self.helicity_factor,
+            "chirality_factor": self.chirality_factor,
+            "spin_state_factor": self.spin_state_factor,
+            "phase": list(self.phase),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class SourceIR:
+    identity: ParticleIdentityIR
+    statistics: ParticleStatistics
+    wavefunction_family: WavefunctionFamily
+    component_dimension: int
+    states: tuple[SourceStateIR, ...]
+    crossing: CrossingIR
+    basis: str
+    mass_parameter: str | None = None
+    width_parameter: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.statistics not in {"boson", "fermion", "ghost", "auxiliary"}:
+            raise ValueError(f"invalid source statistics {self.statistics!r}")
+        if self.wavefunction_family not in {
+            "scalar",
+            "fermion",
+            "vector",
+            "spin2",
+            "ghost",
+            "auxiliary",
+        }:
+            raise ValueError(
+                f"invalid source wavefunction family {self.wavefunction_family!r}"
+            )
+        expected_statistics: ParticleStatistics
+        if self.wavefunction_family == "fermion":
+            expected_statistics = "fermion"
+        elif self.wavefunction_family == "ghost":
+            expected_statistics = "ghost"
+        elif self.wavefunction_family == "auxiliary":
+            expected_statistics = "auxiliary"
+        else:
+            expected_statistics = "boson"
+        if self.statistics != expected_statistics:
+            raise ValueError(
+                f"source wavefunction family {self.wavefunction_family!r} requires "
+                f"statistics {expected_statistics!r}, got {self.statistics!r}"
+            )
+        if isinstance(self.component_dimension, bool) or not isinstance(
+            self.component_dimension, int
+        ):
+            raise TypeError("source component dimension must be an integer")
+        if self.component_dimension < 1:
+            raise ValueError("source component dimension must be positive")
+        if not self.states:
+            raise ValueError("source metadata must declare at least one spin state")
+        if not self.basis:
+            raise ValueError("source basis must not be empty")
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "identity": self.identity.to_json_dict(),
+            "statistics": self.statistics,
+            "wavefunction_family": self.wavefunction_family,
+            "component_dimension": self.component_dimension,
+            "states": [state.to_json_dict() for state in self.states],
+            "crossing": self.crossing.to_json_dict(),
+            "basis": self.basis,
+            "mass_parameter": self.mass_parameter,
+            "width_parameter": self.width_parameter,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class PropagatorIR:
+    identity: ParticleIdentityIR
+    chirality: int
+    kind: PropagatorKind
+    backend: str
+    basis: str
+    applies_propagator: bool
+    kernel: str
+    full_tensor_network_ready: bool
+    mass_class: PropagatorMassClass
+    gauge: PropagatorGauge | None = None
+    numerator: str | None = None
+    denominator: str | None = None
+    mass_parameter: str | None = None
+    width_parameter: str | None = None
+    custom_source: str | None = None
+    auxiliary_policy: str | None = None
+    goldstone_policy: GoldstonePolicy = "not-applicable"
+    description: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.backend or not self.basis or not self.kernel:
+            raise ValueError("propagator backend, basis, and kernel must not be empty")
+        if self.kind not in {
+            "identity",
+            "scalar",
+            "weyl-fermion",
+            "dirac-fermion",
+            "vector",
+            "spin2",
+            "custom",
+            "unsupported",
+        }:
+            raise ValueError(f"invalid propagator kind {self.kind!r}")
+        if self.gauge not in {
+            None,
+            "feynman",
+            "unitary",
+            "de-donder",
+            "fierz-pauli",
+            "model-supplied",
+        }:
+            raise ValueError(f"invalid propagator gauge {self.gauge!r}")
+        if self.goldstone_policy not in {
+            "not-applicable",
+            "absorbed",
+            "explicit",
+            "model-supplied",
+        }:
+            raise ValueError(
+                f"invalid propagator Goldstone policy {self.goldstone_policy!r}"
+            )
+        if self.mass_class not in {"massless", "massive", "not-applicable"}:
+            raise ValueError(f"invalid propagator mass class {self.mass_class!r}")
+        if not self.applies_propagator and self.auxiliary_policy is None:
+            raise ValueError(
+                "a no-propagator current must declare its auxiliary policy"
+            )
+        if not self.applies_propagator and self.kind != "identity":
+            raise ValueError("a no-propagator current must use the identity kind")
+        if self.applies_propagator and self.kind == "identity":
+            raise ValueError("an identity current cannot apply a propagator")
+        if (self.kind == "identity") != (self.mass_class == "not-applicable"):
+            raise ValueError(
+                "only identity currents may use a not-applicable mass class"
+            )
+        if self.kind == "vector" and self.gauge is None:
+            raise ValueError("a vector propagator must declare its gauge")
+        if self.kind == "custom" and (
+            self.gauge != "model-supplied" or not self.custom_source
+        ):
+            raise ValueError(
+                "a custom propagator must declare its model-supplied source"
+            )
+        if self.goldstone_policy == "absorbed" and not (
+            self.kind == "vector" and self.gauge == "unitary"
+        ):
+            raise ValueError(
+                "an absorbed Goldstone mode requires a unitary-gauge vector"
+            )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "identity": self.identity.to_json_dict(),
+            "particle_id": self.identity.pdg_label,
+            "chirality": self.chirality,
+            "kind": self.kind,
+            "backend": self.backend,
+            "basis": self.basis,
+            "applies_propagator": self.applies_propagator,
+            "kernel": self.kernel,
+            "full_tensor_network_ready": self.full_tensor_network_ready,
+            "mass_class": self.mass_class,
+            "gauge": self.gauge,
+            "numerator": self.numerator,
+            "denominator": self.denominator,
+            "mass_parameter": self.mass_parameter,
+            "width_parameter": self.width_parameter,
+            "custom_source": self.custom_source,
+            "auxiliary_policy": self.auxiliary_policy,
+            "goldstone_policy": self.goldstone_policy,
+            "description": self.description,
+        }
+
+    @classmethod
+    def from_json_dict(cls, payload: Mapping[str, object]) -> PropagatorIR:
+        identity = payload.get("identity")
+        if not isinstance(identity, Mapping):
+            raise TypeError("propagator identity must be a mapping")
+        return cls(
+            identity=ParticleIdentityIR.from_json_dict(identity),
+            chirality=_integer(payload["chirality"], "propagator chirality"),
+            kind=_propagator_kind(payload["kind"]),
+            backend=str(payload["backend"]),
+            basis=str(payload["basis"]),
+            applies_propagator=_boolean(
+                payload["applies_propagator"],
+                "propagator application flag",
+            ),
+            kernel=str(payload["kernel"]),
+            full_tensor_network_ready=_boolean(
+                payload["full_tensor_network_ready"],
+                "propagator tensor-network readiness",
+            ),
+            mass_class=_propagator_mass_class(payload["mass_class"]),
+            gauge=_optional_propagator_gauge(payload.get("gauge")),
+            numerator=_optional_string(payload.get("numerator")),
+            denominator=_optional_string(payload.get("denominator")),
+            mass_parameter=_optional_string(payload.get("mass_parameter")),
+            width_parameter=_optional_string(payload.get("width_parameter")),
+            custom_source=_optional_string(payload.get("custom_source")),
+            auxiliary_policy=_optional_string(payload.get("auxiliary_policy")),
+            goldstone_policy=_goldstone_policy(
+                payload.get("goldstone_policy", "not-applicable")
+            ),
+            description=str(payload.get("description", "")),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ContractionIR:
+    name: str
+    left_basis: str
+    right_basis: str
+    coefficients: tuple[tuple[float, float], ...]
+    chirality_relation: Literal["any", "equal", "opposite"] = "any"
+    metric_signature: str | None = None
+
+    def __post_init__(self) -> None:
+        for field_name in ("name", "left_basis", "right_basis"):
+            value = getattr(self, field_name)
+            if not isinstance(value, str):
+                raise TypeError(f"contraction {field_name} must be a string")
+        if not self.name or not self.left_basis or not self.right_basis:
+            raise ValueError("contraction name and bases must not be empty")
+        if isinstance(self.coefficients, (str, bytes)) or not isinstance(
+            self.coefficients, Sequence
+        ):
+            raise TypeError("contraction coefficients must be a sequence")
+        if not self.coefficients:
+            raise ValueError("contraction must declare component coefficients")
+        coefficients: list[tuple[float, float]] = []
+        for index, value in enumerate(self.coefficients):
+            if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+                raise TypeError(
+                    f"contraction coefficient {index} must be a complex pair"
+                )
+            if len(value) != 2:
+                raise ValueError(
+                    "contraction coefficients must be finite complex pairs"
+                )
+            if any(
+                isinstance(component, bool) or not isinstance(component, Real)
+                for component in value
+            ):
+                raise TypeError(
+                    "contraction coefficient components must be real numbers"
+                )
+            coefficient = (float(value[0]), float(value[1]))
+            if not all(math.isfinite(component) for component in coefficient):
+                raise ValueError(
+                    "contraction coefficients must be finite complex pairs"
+                )
+            coefficients.append(coefficient)
+        normalized_coefficients = tuple(coefficients)
+        if not any(value != (0.0, 0.0) for value in normalized_coefficients):
+            raise ValueError("contraction must have a nonzero component coefficient")
+        object.__setattr__(self, "coefficients", normalized_coefficients)
+        if not isinstance(self.chirality_relation, str):
+            raise TypeError("contraction chirality relation must be a string")
+        if self.chirality_relation not in {"any", "equal", "opposite"}:
+            raise ValueError(
+                f"invalid contraction chirality relation {self.chirality_relation!r}"
+            )
+        if self.metric_signature is not None:
+            if not isinstance(self.metric_signature, str):
+                raise TypeError("contraction metric signature must be a string or null")
+            if not self.metric_signature:
+                raise ValueError("contraction metric signature must not be empty")
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "name": self.name,
+            "left_basis": self.left_basis,
+            "right_basis": self.right_basis,
+            "coefficients": [list(value) for value in self.coefficients],
+            "chirality_relation": self.chirality_relation,
+            "metric_signature": self.metric_signature,
+        }
+
+    @classmethod
+    def from_json_dict(cls, payload: Mapping[str, object]) -> ContractionIR:
+        if not isinstance(payload, Mapping):
+            raise TypeError("contraction IR must be a mapping")
+        required_fields = {
+            "name",
+            "left_basis",
+            "right_basis",
+            "coefficients",
+            "chirality_relation",
+            "metric_signature",
+        }
+        fields = set(payload)
+        missing = required_fields - fields
+        if missing:
+            names = ", ".join(sorted(missing))
+            raise ValueError(f"contraction IR is missing required fields: {names}")
+        unknown = fields - required_fields
+        if unknown:
+            names = ", ".join(sorted(str(name) for name in unknown))
+            raise ValueError(f"contraction IR has unknown fields: {names}")
+
+        coefficients = payload["coefficients"]
+        if isinstance(coefficients, (str, bytes)) or not isinstance(
+            coefficients, Sequence
+        ):
+            raise TypeError("contraction coefficients must be an array")
+        parsed_coefficients: list[tuple[float, float]] = []
+        for index, value in enumerate(coefficients):
+            if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+                raise TypeError(
+                    f"contraction coefficient {index} must be a complex pair"
+                )
+            if len(value) != 2:
+                raise ValueError(
+                    f"contraction coefficient {index} must have two components"
+                )
+            if any(
+                isinstance(component, bool) or not isinstance(component, Real)
+                for component in value
+            ):
+                raise TypeError(
+                    "contraction coefficient components must be real numbers"
+                )
+            parsed_coefficients.append((float(value[0]), float(value[1])))
+
+        name = payload["name"]
+        left_basis = payload["left_basis"]
+        right_basis = payload["right_basis"]
+        if not isinstance(name, str):
+            raise TypeError("contraction name must be a string")
+        if not isinstance(left_basis, str) or not isinstance(right_basis, str):
+            raise TypeError("contraction bases must be strings")
+        metric_signature = payload["metric_signature"]
+        if metric_signature is not None and not isinstance(metric_signature, str):
+            raise TypeError("contraction metric signature must be a string or null")
+        chirality_relation = payload["chirality_relation"]
+        if not isinstance(chirality_relation, str):
+            raise TypeError("contraction chirality relation must be a string")
+        if chirality_relation not in {"any", "equal", "opposite"}:
+            raise ValueError(
+                f"invalid contraction chirality relation {chirality_relation!r}"
+            )
+        return cls(
+            name=name,
+            left_basis=left_basis,
+            right_basis=right_basis,
+            coefficients=tuple(parsed_coefficients),
+            chirality_relation=cast(
+                Literal["any", "equal", "opposite"], chirality_relation
+            ),
+            metric_signature=metric_signature,
+        )
diff --git a/pyamplicol/src/pyamplicol/models/adjoint_color_certificate.py b/pyamplicol/src/pyamplicol/models/adjoint_color_certificate.py
new file mode 100644
index 0000000000..612368b5f5
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/adjoint_color_certificate.py
@@ -0,0 +1,201 @@
+# SPDX-License-Identifier: 0BSD
+"""Colour-only certificates for a connected DDM tree with singlet spectators.
+
+This is not a Yang--Mills helicity theorem.  Arbitrary Lorentz interactions
+are permitted when their *actual compiled colour tensors* are connected trees
+of structure constants and adjoint identities.  A colourless propagator
+between two such trees would instead produce a colour forest.  Until a
+forest decomposition is selected, the proof therefore permits at most one
+mixed coloured/singlet vertex in a complete tree amplitude.
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+from collections import Counter
+from collections.abc import Mapping
+from functools import lru_cache
+from typing import TYPE_CHECKING
+
+from .tensors import normalize_color_expression
+
+if TYPE_CHECKING:
+    from ..processes.ir import CanonicalProcessIR
+    from .base import Model
+    from .contracts import CompiledModelIR
+
+
+def adjoint_tree_color_basis_is_proven(
+    model: Model,
+    process: CanonicalProcessIR,
+    *,
+    max_coupling_orders: Mapping[str, int] | None = None,
+) -> bool:
+    """Dispatch the model-owned connected-adjoint-tree certificate."""
+
+    return model.adjoint_tree_color_basis_is_proven(
+        process, max_coupling_orders=max_coupling_orders
+    )
+
+
+def compiled_adjoint_tree_color_basis_is_proven(
+    ir: CompiledModelIR,
+    process: CanonicalProcessIR,
+    *,
+    max_coupling_orders: Mapping[str, int] | None = None,
+) -> bool:
+    """Conservatively prove connected f-tree colour for this process domain.
+
+    Species closure deliberately overestimates reachable vertices; no colour
+    tensor can be discarded by a numerical probe or by a UFO/model name.
+    A common positive order with a one-insertion budget proves that two
+    mixed vertices cannot occur.  For example HIG <= 1 certifies a single
+    effective Higgs insertion, while unrestricted Higgs exchange is rejected.
+    """
+
+    if (
+        len(process.adjoint_labels) < 2
+        or process.fundamental_labels
+        or process.antifundamental_labels
+        or len(process.adjoint_labels) + len(process.singlet_labels)
+        != len(process.legs)
+    ):
+        return False
+    particles = {particle.name: particle for particle in ir.particles}
+    by_pdg = {particle.pdg_code: particle for particle in ir.particles}
+    reachable: set[str] = set()
+    for leg in process.legs:
+        if leg.outgoing_pdg is None or leg.outgoing_pdg not in by_pdg:
+            return False
+        reachable.add(by_pdg[leg.outgoing_pdg].name)
+    limits = {
+        str(name).upper(): int(value)
+        for name, value in (max_coupling_orders or {}).items()
+    }
+    active = {}
+    changed = True
+    while changed:
+        changed = False
+        for term in ir.vertex_terms:
+            orders = {name.upper(): value for name, value in term.coupling_orders}
+            # Nonnegative coupling orders make per-vertex pruning sound.
+            if any(value < 0 for value in orders.values()):
+                return False
+            if any(orders.get(name, 0) > limit for name, limit in limits.items()):
+                continue
+            for output_index, output_name in enumerate(term.particles):
+                if not all(
+                    name in reachable
+                    for index, name in enumerate(term.particles)
+                    if index != output_index
+                ):
+                    continue
+                active[term.id] = term
+                result = particles[output_name].antiname
+                if result not in reachable:
+                    reachable.add(result)
+                    changed = True
+    mixed_orders = []
+    found_coloured_tree = False
+    for term in active.values():
+        representations = tuple(particles[name].color for name in term.particles)
+        coloured_count = sum(color != 1 for color in representations)
+        if not coloured_count:
+            continue
+        if any(color not in {1, 8} for color in representations):
+            return False
+        if not _is_connected_adjoint_tree_tensor(
+            term.color_source, term.color_expression, representations
+        ):
+            return False
+        found_coloured_tree = True
+        if coloured_count != len(representations):
+            mixed_orders.append(
+                {name.upper(): value for name, value in term.coupling_orders}
+            )
+    if mixed_orders and not any(
+        0 <= limit < 2 * min(orders.get(name, 0) for orders in mixed_orders)
+        for name, limit in limits.items()
+    ):
+        return False
+    return found_coloured_tree
+
+
+@lru_cache(maxsize=512)
+def _is_connected_adjoint_tree_tensor(
+    source: str, expression: str, representations: tuple[int, ...]
+) -> bool:
+    """Prove each source monomial is a tree, then bind it to the compiled tensor."""
+
+    coloured_legs = {
+        index for index, color in enumerate(representations, start=1) if color != 1
+    }
+    if len(coloured_legs) < 2 or any(color not in {1, 8} for color in representations):
+        return False
+    source_python = re.sub(r"UFO::(?:\{\}::)?", "", source)
+    try:
+        monomials = _tensor_monomials(ast.parse(source_python, mode="eval").body)
+    except (SyntaxError, TypeError, ValueError):
+        return False
+    if not monomials or not all(
+        _monomial_is_tree(factors, coloured_legs) for factors in monomials
+    ):
+        return False
+    from . import compiler_symbolica as _sym
+
+    _sym._ensure_symbolica()
+    try:
+        normalized = normalize_color_expression(source, representations).expression
+        return (_sym.E(expression) - _sym.E(normalized)).expand() == _sym.E("0")
+    except (RuntimeError, TypeError, ValueError):
+        return False
+
+
+def _tensor_monomials(node: ast.AST) -> list[tuple[tuple[int, ...], ...]]:
+    """Expand a small UFO colour polynomial, never evaluating Python code."""
+
+    if isinstance(node, ast.Constant) and isinstance(node.value, int | float | complex):
+        return [()]
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.UAdd | ast.USub):
+        return _tensor_monomials(node.operand)
+    if isinstance(node, ast.BinOp):
+        left = _tensor_monomials(node.left)
+        right = _tensor_monomials(node.right)
+        if isinstance(node.op, ast.Add | ast.Sub):
+            return left + right
+        if isinstance(node.op, ast.Mult):
+            return [(*a, *b) for a in left for b in right]
+        if isinstance(node.op, ast.Div) and right == [()]:
+            return left
+    if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+        arity = {"f": 3, "Identity": 2}.get(node.func.id)
+        if arity is None or len(node.args) != arity or node.keywords:
+            raise ValueError("not a structure constant or adjoint identity")
+        labels = tuple(ast.literal_eval(argument) for argument in node.args)
+        if any(type(label) is not int or label == 0 for label in labels):
+            raise ValueError("colour tensor indices must be nonzero integers")
+        return [(labels,)]
+    raise ValueError("not a polynomial of structure constants and identities")
+
+
+def _monomial_is_tree(
+    factors: tuple[tuple[int, ...], ...], coloured_legs: set[int]
+) -> bool:
+    counts = Counter(label for factor in factors for label in factor)
+    if {label for label in counts if label > 0} != coloured_legs:
+        return False
+    if any(count != (1 if label > 0 else 2) for label, count in counts.items()):
+        return False
+    if sum(label < 0 for label in counts) != len(factors) - 1:
+        return False
+    reached = {0}
+    changed = True
+    while changed:
+        changed = False
+        indices = {label for index in reached for label in factors[index] if label < 0}
+        for index, factor in enumerate(factors):
+            if index not in reached and indices.intersection(factor):
+                reached.add(index)
+                changed = True
+    return len(reached) == len(factors)
diff --git a/pyamplicol/src/pyamplicol/models/base.py b/pyamplicol/src/pyamplicol/models/base.py
new file mode 100644
index 0000000000..9fdc32948b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/base.py
@@ -0,0 +1,1586 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+from collections.abc import Collection, Mapping, Sequence
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import Any, Literal, cast
+
+from ._physics_ir import (
+    ContractionIR,
+    CrossingIR,
+    GoldstonePolicy,
+    ParticleIdentityIR,
+    ParticleOrientation,
+    ParticleStatistics,
+    PropagatorGauge,
+    PropagatorIR,
+    PropagatorKind,
+    PropagatorMassClass,
+    SourceIR,
+    SourceStateIR,
+    WavefunctionFamily,
+)
+from .contact_decomposition import (
+    CompiledContactOrbitCertificate,
+    CompiledContactOrbitStep,
+)
+
+
+@dataclass(frozen=True)
+class Particle:
+    pdg: int
+    anti_pdg: int
+    spin: int
+    dimension: int
+    color_rep: int
+    mass: float = 0.0
+    width: float = 0.0
+    charge: float = 0.0
+    weak_isospin: tuple[float, float] = (0.0, 0.0)
+    weak_hypercharge: tuple[float, float] = (0.0, 0.0)
+
+
+def _runtime_particle_parameter_name(
+    declared: str | None,
+    *,
+    particle_pdg: int,
+    kind: str,
+    available_names: Collection[str],
+) -> str | None:
+    """Resolve a model-owned name or its prepared-catalog fallback."""
+
+    if declared is not None:
+        return declared
+    fallback = f"particle.{particle_pdg}.{kind}"
+    return fallback if fallback in available_names else None
+
+
+@dataclass(frozen=True)
+class Vertex:
+    kind: int
+    particles: tuple[int, int, int]
+    coupling: tuple[float, float] = (1.0, 0.0)
+
+
+CouplingOrders = tuple[tuple[str, int], ...]
+QuantumNumberFlow = tuple[tuple[str, str], ...]
+RecurrenceFlavourFlowOperation = Literal[
+    "constant-result",
+    "append-left-result",
+    "append-right-result",
+    "concat-left-right-result",
+]
+RecurrenceQuantumNumberFlowOperation = Literal["particle-static-result"]
+RecurrenceLCColorShapeKind = Literal[
+    "singlet-forest",
+    "fundamental-open-string",
+    "antifundamental-open-string",
+    "adjoint-segment",
+]
+RecurrenceLCColorComponentKind = Literal["open-string", "adjoint-segment", "trace"]
+RecurrenceLCColorComponentRole = Literal["active", "passive", "none"]
+RecurrenceLCColorSourceSeedOperation = Literal["empty", "singleton"]
+RecurrenceLCColorOperation = Literal[
+    "concatenate-join",
+    "concatenate-keep",
+    "inherit-left",
+    "inherit-right",
+    "empty",
+    "close",
+]
+
+
+@dataclass(frozen=True)
+class SourceSpinState:
+    helicity: int
+    chirality: int
+    spin_state: int | tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class QuantumFlow:
+    chirality: int
+    spin_state: int | tuple[int, ...]
+    flavour_flow: tuple[int, ...]
+    quantum_number_flow: QuantumNumberFlow
+    coupling: tuple[float, float]
+
+
+@dataclass(frozen=True)
+class RecurrenceQuantumFlowContract:
+    """Declarative dynamic-flow contract consumed by recurrence generation."""
+
+    flavour_flow_operation: RecurrenceFlavourFlowOperation
+    quantum_number_flow_operation: RecurrenceQuantumNumberFlowOperation
+    admission_scope: Literal["static-input-contract"] = "static-input-contract"
+
+    def __post_init__(self) -> None:
+        if self.flavour_flow_operation not in {
+            "constant-result",
+            "append-left-result",
+            "append-right-result",
+            "concat-left-right-result",
+        }:
+            raise ValueError(
+                "unsupported recurrence flavour-flow operation "
+                f"{self.flavour_flow_operation!r}"
+            )
+        if self.quantum_number_flow_operation != "particle-static-result":
+            raise ValueError(
+                "unsupported recurrence quantum-number-flow operation "
+                f"{self.quantum_number_flow_operation!r}"
+            )
+        if self.admission_scope != "static-input-contract":
+            raise ValueError(
+                f"unsupported recurrence admission scope {self.admission_scope!r}"
+            )
+
+    def to_json_dict(self) -> dict[str, str]:
+        return {
+            "admission_scope": self.admission_scope,
+            "flavour_flow_operation": self.flavour_flow_operation,
+            "quantum_number_flow_operation": self.quantum_number_flow_operation,
+        }
+
+
+@dataclass(frozen=True)
+class RecurrenceCurrentEmbeddingContract:
+    """Exact embedding of one source current into a full runtime current."""
+
+    input_embedding: tuple[int | None, ...]
+    source_dimension: int
+    full_dimension: int
+    source_basis: str
+    full_basis: str
+    proof_kind: str
+    provenance: tuple[tuple[str, str], ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.source_dimension <= 0 or self.full_dimension <= 0:
+            raise ValueError("recurrence current dimensions must be positive")
+        if len(self.input_embedding) != self.full_dimension:
+            raise ValueError(
+                "recurrence current embedding length must equal the full dimension"
+            )
+        populated = tuple(
+            int(component)
+            for component in self.input_embedding
+            if component is not None
+        )
+        if tuple(sorted(populated)) != tuple(range(self.source_dimension)):
+            raise ValueError(
+                "recurrence current embedding must use every source component "
+                "exactly once"
+            )
+        if not self.source_basis or not self.full_basis or not self.proof_kind:
+            raise ValueError(
+                "recurrence current embedding basis and proof labels must be nonempty"
+            )
+        if self.provenance != tuple(sorted(set(self.provenance))):
+            raise ValueError(
+                "recurrence current embedding provenance must be sorted and unique"
+            )
+
+    @property
+    def source_projection(self) -> tuple[int, ...]:
+        """Return full-component indices ordered by source component."""
+
+        inverse = [-1] * self.source_dimension
+        for full_component, source_component in enumerate(self.input_embedding):
+            if source_component is not None:
+                inverse[int(source_component)] = full_component
+        return tuple(inverse)
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "full_basis": self.full_basis,
+            "full_dimension": self.full_dimension,
+            "input_embedding": list(self.input_embedding),
+            "proof_kind": self.proof_kind,
+            "provenance": [list(item) for item in self.provenance],
+            "source_basis": self.source_basis,
+            "source_dimension": self.source_dimension,
+            "source_projection": list(self.source_projection),
+        }
+
+
+@dataclass(frozen=True)
+class RecurrenceLCColorSourceSeedContract:
+    """Compiler-owned LC forest seed for one external source current."""
+
+    operation: RecurrenceLCColorSourceSeedOperation
+    output_shape_kind: RecurrenceLCColorShapeKind
+    component_kind: RecurrenceLCColorComponentKind | None
+    component_role: RecurrenceLCColorComponentRole
+    proof_digest: str | None = None
+    provenance: tuple[tuple[str, str], ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.operation not in {"empty", "singleton"}:
+            raise ValueError(
+                f"unsupported recurrence LC source operation {self.operation!r}"
+            )
+        if self.output_shape_kind not in {
+            "singlet-forest",
+            "fundamental-open-string",
+            "antifundamental-open-string",
+            "adjoint-segment",
+        }:
+            raise ValueError(
+                f"unsupported recurrence LC source shape {self.output_shape_kind!r}"
+            )
+        if self.component_role not in {"active", "passive", "none"}:
+            raise ValueError(
+                f"unsupported recurrence LC source role {self.component_role!r}"
+            )
+        if self.operation == "empty":
+            if self.component_kind is not None or self.component_role != "none":
+                raise ValueError(
+                    "an empty recurrence LC source cannot declare a component"
+                )
+        elif self.component_kind is None or self.component_role == "none":
+            raise ValueError(
+                "a singleton recurrence LC source requires component kind and role"
+            )
+        expected = {
+            "singlet-forest": ("empty", None, "none"),
+            "fundamental-open-string": ("singleton", "open-string", "active"),
+            "antifundamental-open-string": (
+                "singleton",
+                "open-string",
+                "active",
+            ),
+            "adjoint-segment": ("singleton", "adjoint-segment", "active"),
+        }[self.output_shape_kind]
+        if (self.operation, self.component_kind, self.component_role) != expected:
+            raise ValueError(
+                "recurrence LC source seed does not match its output shape"
+            )
+        if self.proof_digest is not None and (
+            len(self.proof_digest) != 64
+            or any(
+                character not in "0123456789abcdef"
+                for character in self.proof_digest
+            )
+        ):
+            raise ValueError(
+                "recurrence LC source proof digest must be lowercase SHA-256"
+            )
+        if self.provenance != tuple(sorted(set(self.provenance))):
+            raise ValueError(
+                "recurrence LC source provenance must be sorted and unique"
+            )
+
+
+@dataclass(frozen=True)
+class RecurrenceLCColorWitnessContract:
+    """One exact ordered-word term in a model-owned LC transition contract."""
+
+    input_permutation: tuple[int, int]
+    reverse_parent_mask: int
+    component_operation: RecurrenceLCColorOperation
+    result_component_kind: RecurrenceLCColorComponentKind | None
+    result_component_role: RecurrenceLCColorComponentRole
+    exact_factor: tuple[float, float] = (1.0, 0.0)
+    proof_digest: str | None = None
+    provenance: tuple[tuple[str, str], ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.input_permutation not in {(0, 1), (1, 0)}:
+            raise ValueError(
+                "recurrence LC color input permutation must be (0, 1) or (1, 0)"
+            )
+        if self.reverse_parent_mask not in range(4):
+            raise ValueError("recurrence LC color reversal mask must fit two inputs")
+        if self.component_operation not in {
+            "concatenate-join",
+            "concatenate-keep",
+            "inherit-left",
+            "inherit-right",
+            "empty",
+            "close",
+        }:
+            raise ValueError(
+                "unsupported recurrence LC color operation "
+                f"{self.component_operation!r}"
+            )
+        if self.result_component_role not in {"active", "passive", "none"}:
+            raise ValueError(
+                f"unsupported recurrence LC result role {self.result_component_role!r}"
+            )
+        if self.component_operation == "concatenate-join":
+            if (
+                self.result_component_kind is None
+                or self.result_component_role == "none"
+            ):
+                raise ValueError(
+                    "an LC join requires a result component kind and "
+                    "active/passive role"
+                )
+        elif self.component_operation == "close":
+            if self.result_component_role != "none":
+                raise ValueError(
+                    "an LC closure cannot declare a recurrence result component"
+                )
+        elif (
+            self.result_component_kind is not None
+            or self.result_component_role
+            != (
+                "active"
+                if self.component_operation in {"inherit-left", "inherit-right"}
+                else "none"
+            )
+        ):
+            raise ValueError(
+                "LC non-join result roles must match their exact component operation"
+            )
+        if self.exact_factor == (0.0, 0.0):
+            raise ValueError("recurrence LC color witness factor must be nonzero")
+        if self.proof_digest is not None and (
+            len(self.proof_digest) != 64
+            or any(
+                character not in "0123456789abcdef" for character in self.proof_digest
+            )
+        ):
+            raise ValueError(
+                "recurrence LC color witness proof digest must be lowercase SHA-256"
+            )
+        if self.provenance != tuple(sorted(set(self.provenance))):
+            raise ValueError(
+                "recurrence LC color witness provenance must be sorted and unique"
+            )
+
+
+@dataclass(frozen=True)
+class RecurrenceLCColorTransitionContract:
+    """Closed, compiler-owned color-state contract for one local transition."""
+
+    rule_kind: str
+    witnesses: tuple[RecurrenceLCColorWitnessContract, ...]
+
+    def __post_init__(self) -> None:
+        if not self.rule_kind:
+            raise ValueError("recurrence LC color rule kind must be nonempty")
+        if not self.witnesses:
+            raise ValueError("recurrence LC color transition requires exact witnesses")
+
+
+@dataclass(frozen=True)
+class VertexLoweringRule:
+    kind: int
+    backend: str
+    tensor_names: tuple[str, ...] = ()
+    expression_head: str = ""
+    full_tensor_network_ready: bool = False
+    description: str = ""
+    kernel: str = ""
+    input_roles: tuple[str, str] = ("", "")
+    output_role: str = ""
+    coupling_mode: str = "none"
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "kind": self.kind,
+            "backend": self.backend,
+            "tensor_names": list(self.tensor_names),
+            "expression_head": self.expression_head,
+            "full_tensor_network_ready": self.full_tensor_network_ready,
+            "description": self.description,
+            "kernel": self.kernel,
+            "input_roles": list(self.input_roles),
+            "output_role": self.output_role,
+            "coupling_mode": self.coupling_mode,
+        }
+
+
+@dataclass(frozen=True)
+class VertexEvaluationEquivalence:
+    """Verified relation between oriented kernels used for evaluation reuse.
+
+    ``factor`` states that the concrete oriented kernel equals ``factor`` times
+    its equivalence-class representative after applying ``input_order``.
+    ``input_exchange_factor``, when present, additionally proves that exchanging
+    the representative's two inputs multiplies it by that factor. Keeping this
+    model-owned lets compiled UFO models persist relations proven from their
+    actual lowered Symbolica expressions.
+    """
+
+    class_id: str
+    factor: tuple[float, float] = (1.0, 0.0)
+    input_order: tuple[int, int] = (0, 1)
+    input_exchange_factor: tuple[float, float] | None = None
+    verified: bool = True
+
+    def __post_init__(self) -> None:
+        if not self.class_id:
+            raise ValueError("vertex evaluation equivalence class must be non-empty")
+        if self.input_order not in {(0, 1), (1, 0)}:
+            raise ValueError("vertex evaluation input order must be (0, 1) or (1, 0)")
+        if not all(math.isfinite(component) for component in self.factor):
+            raise ValueError("vertex evaluation equivalence factor must be finite")
+        if self.factor == (0.0, 0.0):
+            raise ValueError("vertex evaluation equivalence factor must be nonzero")
+        if self.input_exchange_factor is not None:
+            if not all(
+                math.isfinite(component) for component in self.input_exchange_factor
+            ):
+                raise ValueError(
+                    "vertex evaluation input-exchange factor must be finite"
+                )
+            if self.input_exchange_factor == (0.0, 0.0):
+                raise ValueError(
+                    "vertex evaluation input-exchange factor must be nonzero"
+                )
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "class_id": self.class_id,
+            "factor": list(self.factor),
+            "input_order": list(self.input_order),
+            "input_exchange_factor": (
+                None
+                if self.input_exchange_factor is None
+                else list(self.input_exchange_factor)
+            ),
+            "verified": self.verified,
+        }
+
+
+@dataclass(frozen=True)
+class PropagatorLoweringRule:
+    particle_id: int
+    chirality: int
+    backend: str
+    full_tensor_network_ready: bool
+    applies_propagator: bool
+    kernel: str
+    kind: PropagatorKind
+    mass_class: PropagatorMassClass
+    gauge: PropagatorGauge | None = None
+    numerator: str | None = None
+    denominator: str | None = None
+    custom_source: str | None = None
+    auxiliary_policy: str | None = None
+    goldstone_policy: GoldstonePolicy = "not-applicable"
+    description: str = ""
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "particle_id": self.particle_id,
+            "chirality": self.chirality,
+            "backend": self.backend,
+            "full_tensor_network_ready": self.full_tensor_network_ready,
+            "applies_propagator": self.applies_propagator,
+            "kernel": self.kernel,
+            "kind": self.kind,
+            "mass_class": self.mass_class,
+            "gauge": self.gauge,
+            "numerator": self.numerator,
+            "denominator": self.denominator,
+            "custom_source": self.custom_source,
+            "auxiliary_policy": self.auxiliary_policy,
+            "goldstone_policy": self.goldstone_policy,
+            "description": self.description,
+        }
+
+
+@dataclass
+class Model:
+    name: str
+    compiled: Any | None = field(default=None, repr=False, compare=False)
+    particles: dict[int, Particle] = field(default_factory=dict)
+    vertices: tuple[Vertex, ...] = ()
+    _source_ir_by_particle: dict[int, SourceIR] = field(
+        default_factory=dict,
+        init=False,
+        repr=False,
+        compare=False,
+    )
+    _propagator_ir_by_state: dict[tuple[int, int], PropagatorIR] = field(
+        default_factory=dict,
+        init=False,
+        repr=False,
+        compare=False,
+    )
+    _direct_contraction_ir_by_state: dict[
+        tuple[int, int, int, int], ContractionIR | None
+    ] = field(
+        default_factory=dict,
+        init=False,
+        repr=False,
+        compare=False,
+    )
+    _closure_contraction_ir_by_state: dict[tuple[int, int], ContractionIR | None] = (
+        field(
+            default_factory=dict,
+            init=False,
+            repr=False,
+            compare=False,
+        )
+    )
+
+    @cached_property
+    def _species_by_pdg(self) -> dict[int, Particle]:
+        species: dict[int, Particle] = {}
+        for particle in self.particles.values():
+            species.setdefault(particle.pdg, particle)
+            species.setdefault(particle.anti_pdg, particle)
+        return species
+
+    @cached_property
+    def _property_sign_by_pdg(self) -> dict[int, int]:
+        signs: dict[int, int] = {}
+        for particle in self.particles.values():
+            signs.setdefault(particle.pdg, 1)
+            if particle.anti_pdg != particle.pdg:
+                signs.setdefault(particle.anti_pdg, -1)
+            else:
+                signs.setdefault(particle.anti_pdg, 1)
+        return signs
+
+    @cached_property
+    def _vertices_by_input(self) -> dict[tuple[str, int, int], tuple[Vertex, ...]]:
+        return {}
+
+    def particle(self, pdg: int) -> Particle:
+        species = self._species_by_pdg.get(pdg)
+        if species is None:
+            raise KeyError(f"particle not in model: {pdg}")
+        return species
+
+    def anti_particle(self, pdg: int) -> int:
+        particle = self.particle(pdg)
+        return particle.anti_pdg if particle.pdg == pdg else particle.pdg
+
+    def mass(self, pdg: int) -> float:
+        return self.particle(pdg).mass
+
+    def width(self, pdg: int) -> float:
+        return self.particle(pdg).width
+
+    def spin(self, pdg: int) -> int:
+        spin = self.particle(pdg).spin
+        if spin < 0:
+            raise ValueError(f"spin is ill-defined for particle {pdg}")
+        return spin
+
+    def dimension(self, pdg: int) -> int:
+        return self.particle(pdg).dimension
+
+    def charge(self, pdg: int) -> float:
+        return self._property_sign(pdg) * self.particle(pdg).charge
+
+    def weak_isospin_l(self, pdg: int) -> float:
+        return self._property_sign(pdg) * self.particle(pdg).weak_isospin[0]
+
+    def weak_isospin_r(self, pdg: int) -> float:
+        return self._property_sign(pdg) * self.particle(pdg).weak_isospin[1]
+
+    def color_rep(self, pdg: int) -> int:
+        del pdg
+        raise NotImplementedError("model does not define colour representations")
+
+    def color_dim(self, pdg: int) -> int:
+        return abs(self.color_rep(pdg))
+
+    def is_fermion(self, pdg: int) -> bool:
+        del pdg
+        raise NotImplementedError("model does not define a fermion role")
+
+    def is_chiral_eligible(self, pdg: int) -> bool:
+        del pdg
+        raise NotImplementedError("model does not define chiral source eligibility")
+
+    def is_fundamental_colored_fermion(self, pdg: int) -> bool:
+        del pdg
+        raise NotImplementedError(
+            "model does not define a fundamental colored-fermion role"
+        )
+
+    def is_massless_adjoint_vector(self, pdg: int) -> bool:
+        del pdg
+        raise NotImplementedError(
+            "model does not define a massless adjoint-vector role"
+        )
+
+    def is_singlet(self, pdg: int) -> bool:
+        return self.color_rep(pdg) == 1
+
+    def vertex_lowering_rule(self, kind: int) -> VertexLoweringRule:
+        raise NotImplementedError
+
+    def vertex_evaluation_equivalence(
+        self,
+        kind: int,
+    ) -> VertexEvaluationEquivalence:
+        """Return a conservative, always-safe evaluation equivalence class.
+
+        Models with compiled symbolic kernels may override this with broader
+        classes.  A class unique to one model type and vertex kind still enables
+        exact fan-out reuse when several DAG attachments use the same kernel and
+        input currents.
+        """
+
+        model_type = f"{type(self).__module__}.{type(self).__qualname__}"
+        return VertexEvaluationEquivalence(class_id=f"{model_type}:{int(kind)}")
+
+    def vertex_contact_orbit_contracts(
+        self,
+        kind: int,
+    ) -> tuple[
+        tuple[CompiledContactOrbitCertificate, ...],
+        tuple[CompiledContactOrbitStep, ...],
+    ]:
+        """Return compiler-owned contact-path orbit proofs when they exist."""
+
+        del kind
+        return (), ()
+
+    def global_helicity_flip_equivalence_is_proven(
+        self,
+        vertices: Sequence[Vertex],
+    ) -> bool:
+        """Return whether the model proves parity pairing for these vertices.
+
+        Coupling-order names and particle labels are not such a proof. External
+        models therefore remain fail-closed until their compiler records an
+        expression-level equivalence certificate.
+        """
+
+        del vertices
+        return False
+
+    def pure_massless_adjoint_helicity_zero_rule_is_proven(
+        self,
+        process: Any,
+        vertices: Sequence[Vertex],
+    ) -> bool:
+        """Return whether all-equal and one-opposite helicities vanish.
+
+        This tree-amplitude identity requires more than massless adjoint-vector
+        external states. Generic and external models therefore remain
+        fail-closed until their compiler can provide an expression-level proof.
+        """
+
+        del process, vertices
+        return False
+
+    def adjoint_current_reflection_phase(
+        self,
+        vertex: Vertex,
+    ) -> tuple[float, float] | None:
+        """Return a proven two-input adjoint-current reflection phase.
+
+        A non-null result certifies the local off-shell identity obtained by
+        exchanging the two inputs of ``vertex``.  This is deliberately
+        separate from full-amplitude LC trace reflection: a pure gauge
+        subcurrent may be reusable inside a mixed process even when the full
+        process has no trace-reflection reduction.  Generic models remain
+        fail-closed until their lowered component expressions prove the
+        identity.
+        """
+
+        del vertex
+        return None
+
+    def lc_trace_reflection_equivalence_is_proven(self, process: Any) -> bool:
+        """Return whether one LC trace may represent its reversed ordering.
+
+        Reflection folding is an amplitude-level identity, not a consequence of
+        adjoint colour alone.  External models therefore remain fail-closed
+        unless their compiled model records a proof and overrides this hook.
+        """
+
+        del process
+        return False
+
+    def shared_single_trace_color_basis_is_proven(self, process: Any) -> bool:
+        """Return whether NLC/full may use the shared single-trace recursion.
+
+        Adjoint representation metadata alone does not prove that the model's
+        color tensors obey the Yang--Mills trace relations assumed by that
+        optimized recursion. Generic models therefore remain fail-closed.
+        """
+
+        del process
+        return False
+
+    def adjoint_tree_color_basis_is_proven(
+        self,
+        process: Any,
+        *,
+        max_coupling_orders: Mapping[str, int] | None = None,
+    ) -> bool:
+        """Prove connected DDM colour, independently of helicity identities.
+
+        Singlet exchange can produce a colour forest even when every local
+        adjoint tensor is a structure constant.  Implementations must account
+        for the selected interactions and coupling-order limits.
+        """
+
+        del process, max_coupling_orders
+        return False
+
+    def propagator_lowering_rule(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> PropagatorLoweringRule:
+        del particle_id, chirality
+        raise NotImplementedError("model does not define propagator lowering")
+
+    def source_spin_states(self, particle_id: int) -> tuple[SourceSpinState, ...]:
+        if self.is_chiral_eligible(particle_id):
+            return (
+                SourceSpinState(helicity=-1, chirality=-1, spin_state=-1),
+                SourceSpinState(helicity=1, chirality=1, spin_state=1),
+            )
+        spin = self.spin(particle_id)
+        if spin == 1:
+            return (SourceSpinState(helicity=0, chirality=0, spin_state=0),)
+        if spin == 2:
+            return (
+                SourceSpinState(helicity=-1, chirality=0, spin_state=-1),
+                SourceSpinState(helicity=1, chirality=0, spin_state=1),
+            )
+        if spin == 3:
+            return (
+                SourceSpinState(helicity=-1, chirality=0, spin_state=-1),
+                SourceSpinState(helicity=0, chirality=0, spin_state=0),
+                SourceSpinState(helicity=1, chirality=0, spin_state=1),
+            )
+        return (SourceSpinState(helicity=0, chirality=0, spin_state=0),)
+
+    def source_wavefunction_kind(self, particle_id: int) -> str:
+        dimension = self.current_dimension(particle_id)
+        if self.is_fermion(particle_id):
+            return "fermion"
+        if dimension == 1:
+            return "scalar"
+        if dimension in {2, 4}:
+            return "vector"
+        if dimension == 16:
+            return "spin2"
+        return "unknown"
+
+    def source_orientation(self, particle_id: int) -> str:
+        """Return the source orientation from the model's anti-particle relation."""
+
+        particle = self.particle(particle_id)
+        antiparticle_id = self.anti_particle(particle_id)
+        if self.anti_particle(antiparticle_id) != particle_id:
+            raise ValueError(
+                f"particle/antiparticle relation is not involutive for source "
+                f"particle {particle_id}"
+            )
+        if antiparticle_id == particle_id:
+            orientation = "self-conjugate"
+        elif particle_id == particle.pdg and antiparticle_id == particle.anti_pdg:
+            orientation = "particle"
+        elif particle_id == particle.anti_pdg and antiparticle_id == particle.pdg:
+            orientation = "antiparticle"
+        else:
+            raise ValueError(
+                f"source particle {particle_id} is inconsistent with its model-owned "
+                "particle/antiparticle relation"
+            )
+        if orientation == "self-conjugate" and self.is_fermion(particle_id):
+            raise ValueError(
+                f"unsupported self-conjugate fermion source {particle_id}: "
+                "Majorana/FNV source wavefunctions are not implemented"
+            )
+        return orientation
+
+    def _particle_identity_ir(self, particle_id: int) -> ParticleIdentityIR:
+        """Return canonical oriented identity without assigning an SM role."""
+
+        particle_id = int(particle_id)
+        particle = self.particle(particle_id)
+        anti_particle_id = int(self.anti_particle(particle_id))
+        self_conjugate = particle_id == anti_particle_id
+        canonical_id = f"model:{self.name}:state:{particle_id}"
+        anti_canonical_id = f"model:{self.name}:state:{anti_particle_id}"
+        return ParticleIdentityIR(
+            canonical_id=canonical_id,
+            species_id=f"model:{self.name}:species:{particle.pdg}",
+            anti_canonical_id=anti_canonical_id,
+            display_name=f"pdg_{particle_id}",
+            anti_display_name=f"pdg_{anti_particle_id}",
+            pdg_label=particle_id,
+            anti_pdg_label=anti_particle_id,
+            orientation=cast(ParticleOrientation, self.source_orientation(particle_id)),
+            self_conjugate=self_conjugate,
+        )
+
+    def _source_crossing_ir(self, particle_id: int) -> CrossingIR:
+        """Return the model-owned transform from outgoing to incoming source."""
+
+        particle_id = int(particle_id)
+        if self.is_chiral_eligible(particle_id):
+            return CrossingIR(chirality_factor=-1, spin_state_factor=-1)
+        if self.source_wavefunction_kind(particle_id) in {"vector", "spin2"}:
+            return CrossingIR(helicity_factor=-1, spin_state_factor=-1)
+        return CrossingIR()
+
+    def _source_ir(self, particle_id: int) -> SourceIR:
+        """Return the canonical source contract for one oriented particle.
+
+        A compiled model's structural metadata is immutable during generation.
+        Caching here ensures DAG construction, physics metadata, and execution
+        schemas all consume the same contract object.
+        """
+
+        particle_id = int(particle_id)
+        cache = self.__dict__.setdefault("_source_ir_by_particle", {})
+        cached = cache.get(particle_id)
+        if cached is not None:
+            return cached
+        source_ir = self._build_source_ir(particle_id)
+        return cache.setdefault(particle_id, source_ir)
+
+    def _build_source_ir(self, particle_id: int) -> SourceIR:
+        """Build an uncached source contract for an oriented particle."""
+
+        states = tuple(
+            SourceStateIR(
+                helicity=int(state.helicity),
+                chirality=int(state.chirality),
+                spin_state=state.spin_state,
+            )
+            for state in self.source_spin_states(particle_id)
+        )
+        dimensions = {
+            int(self.current_dimension(particle_id, state.chirality))
+            for state in states
+        }
+        if len(dimensions) != 1:
+            raise ValueError(
+                f"source {particle_id} has state-dependent component dimensions: "
+                f"{sorted(dimensions)}"
+            )
+        wavefunction_family = self.source_wavefunction_kind(particle_id)
+        if wavefunction_family not in {
+            "scalar",
+            "fermion",
+            "vector",
+            "spin2",
+            "ghost",
+            "auxiliary",
+        }:
+            raise ValueError(
+                f"source {particle_id} has unsupported wavefunction family "
+                f"{wavefunction_family!r}"
+            )
+        auxiliary = self.auxiliary_kind(particle_id)
+        statistics: ParticleStatistics
+        if auxiliary is not None:
+            statistics = "auxiliary"
+        elif self.spin(particle_id) < 0:
+            statistics = "ghost"
+        elif self.is_fermion(particle_id):
+            statistics = "fermion"
+        else:
+            statistics = "boson"
+        return SourceIR(
+            identity=self._particle_identity_ir(particle_id),
+            statistics=statistics,
+            wavefunction_family=cast(WavefunctionFamily, wavefunction_family),
+            component_dimension=dimensions.pop(),
+            states=states,
+            crossing=self._source_crossing_ir(particle_id),
+            basis=self._current_basis(particle_id, states[0].chirality),
+            mass_parameter=self._runtime_parameter_name(particle_id, "mass"),
+            width_parameter=self._runtime_parameter_name(particle_id, "width"),
+        )
+
+    def _propagator_ir(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> PropagatorIR:
+        """Project the active propagator lowering into a typed model contract."""
+
+        particle_id = int(particle_id)
+        chirality = int(chirality)
+        key = (particle_id, chirality)
+        cache = self.__dict__.setdefault("_propagator_ir_by_state", {})
+        cached = cache.get(key)
+        if cached is not None:
+            return cached
+        rule = self.propagator_lowering_rule(particle_id, chirality)
+        auxiliary_policy = rule.auxiliary_policy
+        if not rule.applies_propagator:
+            auxiliary_policy = (
+                auxiliary_policy or self.auxiliary_kind(particle_id) or rule.kernel
+            )
+        default_numerator, default_denominator = _propagator_formula_metadata(
+            rule.kind, rule.gauge
+        )
+        result = PropagatorIR(
+            identity=self._particle_identity_ir(particle_id),
+            chirality=chirality,
+            kind=rule.kind,
+            backend=rule.backend,
+            basis=self._current_basis(particle_id, chirality),
+            applies_propagator=rule.applies_propagator,
+            kernel=rule.kernel,
+            full_tensor_network_ready=rule.full_tensor_network_ready,
+            mass_class=rule.mass_class,
+            gauge=rule.gauge,
+            numerator=rule.numerator or default_numerator,
+            denominator=rule.denominator or default_denominator,
+            mass_parameter=self._runtime_parameter_name(particle_id, "mass"),
+            width_parameter=self._runtime_parameter_name(particle_id, "width"),
+            custom_source=rule.custom_source,
+            auxiliary_policy=auxiliary_policy,
+            goldstone_policy=rule.goldstone_policy,
+            description=rule.description,
+        )
+        return cache.setdefault(key, result)
+
+    def _current_basis(self, particle_id: int, chirality: int = 0) -> str:
+        dimension = int(self.current_dimension(particle_id, chirality))
+        auxiliary = self.auxiliary_kind(particle_id)
+        if auxiliary is not None:
+            return f"auxiliary:{auxiliary}"
+        if self.is_fermion(particle_id):
+            return "weyl-chiral" if dimension == 2 else "dirac"
+        family = self.source_wavefunction_kind(particle_id)
+        if family == "scalar" and dimension == 1:
+            return "scalar"
+        if family == "vector" and dimension == 4:
+            return "lorentz-vector"
+        if family == "spin2" and dimension == 16:
+            return "lorentz-rank-2"
+        if dimension == 6:
+            return "antisymmetric-lorentz-pair"
+        return f"components:{dimension}"
+
+    def _runtime_parameter_name(self, particle_id: int, kind: str) -> str | None:
+        provider = getattr(self, f"runtime_{kind}_parameter_name", None)
+        if not callable(provider):
+            return None
+        name = provider(int(particle_id))
+        return None if name is None else str(name)
+
+    def runtime_normalization_payload(self, dag: Any) -> dict[str, object]:
+        """Return model-owned averaging, symmetry, color, and coupling factors."""
+
+        del dag
+        raise NotImplementedError("model does not define runtime normalization")
+
+    def runtime_normalization_parameter_defaults(self) -> Mapping[str, float]:
+        """Return mutable runtime parameters used by normalization only."""
+
+        return {}
+
+    def recurrence_quantum_flow_contract(
+        self,
+        vertex: Vertex,
+        left_particle_id: int,
+        right_particle_id: int,
+    ) -> RecurrenceQuantumFlowContract:
+        """Declare the finite dynamic-flow law used by recurrence generation."""
+
+        del vertex, left_particle_id, right_particle_id
+        raise NotImplementedError(
+            "model does not declare a recurrence quantum-flow contract"
+        )
+
+    def recurrence_current_embedding_contract(
+        self,
+        particle_id: int,
+        source_chirality: int,
+    ) -> RecurrenceCurrentEmbeddingContract:
+        """Declare how a source state embeds into a runtime full current."""
+
+        del particle_id, source_chirality
+        raise NotImplementedError(
+            "model does not declare recurrence current-embedding contracts"
+        )
+
+    def _standard_recurrence_current_embedding_contract(
+        self,
+        particle_id: int,
+        source_chirality: int,
+    ) -> RecurrenceCurrentEmbeddingContract:
+        """Return the standard Weyl-to-Dirac current embedding."""
+
+        particle = int(particle_id)
+        chirality = int(source_chirality)
+        if chirality not in {-1, 1} or not self.is_chiral_eligible(particle):
+            raise NotImplementedError(
+                "standard recurrence current embedding requires a massless "
+                "chiral fermion source"
+            )
+        source_dimension = int(self.current_dimension(particle, chirality))
+        full_dimension = int(self.current_dimension(particle, 0))
+        source_basis = self._current_basis(particle, chirality)
+        full_basis = self._current_basis(particle, 0)
+        if (
+            source_dimension != 2
+            or full_dimension != 4
+            or source_basis != "weyl-chiral"
+            or full_basis != "dirac"
+        ):
+            raise NotImplementedError(
+                "standard recurrence current embedding supports a two-component "
+                "Weyl source in a four-component Dirac current"
+            )
+        embedding = (
+            (0, 1, None, None)
+            if chirality == 1
+            else (None, None, 0, 1)
+        )
+        return RecurrenceCurrentEmbeddingContract(
+            input_embedding=embedding,
+            source_dimension=source_dimension,
+            full_dimension=full_dimension,
+            source_basis=source_basis,
+            full_basis=full_basis,
+            proof_kind="standard-weyl-dirac-current-ordering-v1",
+            provenance=(
+                ("chirality", f"{chirality:+d}"),
+                ("contract", "standard-weyl-dirac-current-ordering-v1"),
+                (
+                    "particle-identity",
+                    self._particle_identity_ir(particle).canonical_id,
+                ),
+            ),
+        )
+
+    def _standard_recurrence_quantum_flow_contract(
+        self,
+        vertex: Vertex,
+        left_particle_id: int,
+        right_particle_id: int,
+    ) -> RecurrenceQuantumFlowContract:
+        """Return the exact contract implemented by ``combine_flavour_flow``."""
+
+        result_particle = int(vertex.particles[2])
+        left_particle = int(left_particle_id)
+        right_particle = int(right_particle_id)
+        if self.is_fermion(result_particle):
+            if self.is_fermion(left_particle):
+                operation: RecurrenceFlavourFlowOperation = "append-left-result"
+            elif self.is_fermion(right_particle):
+                operation = "append-right-result"
+            else:
+                operation = "constant-result"
+        else:
+            operation = "constant-result"
+        return RecurrenceQuantumFlowContract(
+            flavour_flow_operation=operation,
+            quantum_number_flow_operation="particle-static-result",
+        )
+
+    def recurrence_lc_color_shape_contract(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> RecurrenceLCColorShapeKind:
+        """Declare the ordered partial-color shape of one current state."""
+
+        del particle_id, chirality
+        raise NotImplementedError(
+            "model does not declare recurrence LC color-shape contracts"
+        )
+
+    def recurrence_lc_source_color_contract(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> RecurrenceLCColorSourceSeedContract:
+        """Declare the exact LC forest seeded by one external source."""
+
+        del particle_id, chirality
+        raise NotImplementedError(
+            "model does not declare recurrence LC source-color contracts"
+        )
+
+    def _standard_recurrence_lc_source_color_contract(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> RecurrenceLCColorSourceSeedContract:
+        shape = self._standard_recurrence_lc_color_shape_contract(
+            particle_id,
+            chirality,
+        )
+        representation = int(self.color_rep(int(particle_id)))
+        provenance = tuple(
+            sorted(
+                (
+                    ("contract", "standard-lc-source-seed-v1"),
+                    ("color-representation", str(representation)),
+                    ("shape", shape),
+                )
+            )
+        )
+        if shape == "singlet-forest":
+            return RecurrenceLCColorSourceSeedContract(
+                "empty",
+                shape,
+                None,
+                "none",
+                provenance=provenance,
+            )
+        component_kind: RecurrenceLCColorComponentKind = (
+            "adjoint-segment" if shape == "adjoint-segment" else "open-string"
+        )
+        return RecurrenceLCColorSourceSeedContract(
+            "singleton",
+            shape,
+            component_kind,
+            "active",
+            provenance=provenance,
+        )
+
+    def _standard_recurrence_lc_color_shape_contract(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> RecurrenceLCColorShapeKind:
+        del chirality
+        representation = int(self.color_rep(int(particle_id)))
+        if representation == 1:
+            return "singlet-forest"
+        if representation == 3:
+            return "fundamental-open-string"
+        if representation == -3:
+            return "antifundamental-open-string"
+        if representation == 8:
+            return "adjoint-segment"
+        raise NotImplementedError(
+            "standard recurrence LC color shapes support only representations "
+            f"1, 3, -3, and 8; got {representation}"
+        )
+
+    def recurrence_lc_color_transition_contract(
+        self,
+        vertex: Vertex,
+        *,
+        closure: bool,
+    ) -> RecurrenceLCColorTransitionContract:
+        """Declare exact ordered partial-color operations for one transition."""
+
+        del vertex, closure
+        raise NotImplementedError(
+            "model does not declare recurrence LC color-transition contracts"
+        )
+
+    def _standard_recurrence_lc_color_transition_contract(
+        self,
+        vertex: Vertex,
+        *,
+        closure: bool,
+    ) -> RecurrenceLCColorTransitionContract:
+        representations = tuple(
+            int(self.color_rep(particle)) for particle in vertex.particles
+        )
+        rule_kind = str(self.vertex_color_structure(vertex))
+        if rule_kind in {"model-defined", "generic-tensor"}:
+            absolute = tuple(abs(value) for value in representations)
+            if all(value == 1 for value in absolute):
+                rule_kind = "singlet"
+            else:
+                raise NotImplementedError(
+                    "colored recurrence tensors require an exact model-owned "
+                    "color projection; got an unresolved tensor for "
+                    f"representations {representations!r}"
+                )
+        if closure:
+            if any(abs(value) != 1 for value in representations):
+                raise NotImplementedError(
+                    "colored recurrence closures require compiler-owned LC "
+                    "closure terms"
+                )
+            return RecurrenceLCColorTransitionContract(
+                rule_kind,
+                (
+                    RecurrenceLCColorWitnessContract(
+                        input_permutation=(0, 1),
+                        reverse_parent_mask=0,
+                        component_operation="close",
+                        result_component_kind=None,
+                        result_component_role="none",
+                    ),
+                ),
+            )
+        if rule_kind != "singlet":
+            raise NotImplementedError(
+                "colored recurrence transitions require compiler-owned ordered-word "
+                f"terms; generic rule {rule_kind!r} is validation metadata only"
+            )
+        if rule_kind == "singlet":
+            return RecurrenceLCColorTransitionContract(
+                rule_kind,
+                (
+                    RecurrenceLCColorWitnessContract(
+                        input_permutation=(0, 1),
+                        reverse_parent_mask=0,
+                        component_operation="empty",
+                        result_component_kind=None,
+                        result_component_role="none",
+                    ),
+                ),
+            )
+        raise NotImplementedError(f"unsupported recurrence LC color rule {rule_kind!r}")
+
+    def allowed_quantum_flows(
+        self,
+        vertex: Vertex,
+        left_index: Any,
+        right_index: Any,
+    ) -> tuple[QuantumFlow, ...]:
+        result_particle = vertex.particles[2]
+        chiralities = _model_vertex_result_chiralities(
+            self,
+            vertex,
+            left_index,
+            right_index,
+        )
+        flows: list[QuantumFlow] = []
+        for chirality in chiralities:
+            flows.append(
+                QuantumFlow(
+                    chirality=chirality,
+                    spin_state=self.result_spin_state(result_particle, chirality),
+                    flavour_flow=self.combine_flavour_flow(
+                        result_particle,
+                        left_index,
+                        right_index,
+                    ),
+                    quantum_number_flow=self.quantum_number_flow(result_particle),
+                    coupling=vertex.coupling,
+                )
+            )
+        return tuple(flows)
+
+    def combine_flavour_flow(
+        self,
+        result_particle: int,
+        left_index: Any,
+        right_index: Any,
+    ) -> tuple[int, ...]:
+        left_pdg = _index_particle_id(left_index)
+        right_pdg = _index_particle_id(right_index)
+        left_flow = _index_flavour_flow(left_index)
+        right_flow = _index_flavour_flow(right_index)
+
+        if self.is_fermion(result_particle):
+            if self.is_fermion(left_pdg):
+                return _append_flavour_transition(left_flow, result_particle)
+            if self.is_fermion(right_pdg):
+                return _append_flavour_transition(right_flow, result_particle)
+
+        return (result_particle,)
+
+    def result_spin_state(self, particle_id: int, chirality: int) -> int:
+        if self.is_fermion(particle_id):
+            return chirality
+        return 0
+
+    def current_dimension(self, particle_id: int, chirality: int = 0) -> int:
+        if chirality != 0 and self.is_chiral_eligible(particle_id):
+            return 2
+        try:
+            return self.dimension(particle_id)
+        except KeyError:
+            return 0
+
+    def direct_contraction_ir(
+        self,
+        left_particle_id: int,
+        right_particle_id: int,
+        left_chirality: int = 0,
+        right_chirality: int = 0,
+    ) -> ContractionIR | None:
+        """Return an explicitly installed contraction for two current states."""
+
+        key = (
+            int(left_particle_id),
+            int(left_chirality),
+            int(right_particle_id),
+            int(right_chirality),
+        )
+        return self._direct_contraction_ir_by_state.get(key)
+
+    def closure_contraction_ir(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> ContractionIR | None:
+        """Return an explicitly installed one-current closure projection."""
+
+        key = (int(particle_id), int(chirality))
+        return self._closure_contraction_ir_by_state.get(key)
+
+    def direct_contraction_possible(
+        self,
+        left_particle_id: int,
+        right_particle_id: int,
+    ) -> bool:
+        """Over-approximate closure using only declared contraction records."""
+
+        left = int(left_particle_id)
+        right = int(right_particle_id)
+        return any(
+            value is not None and key[0] == left and key[2] == right
+            for key, value in self._direct_contraction_ir_by_state.items()
+        )
+
+    def quantum_number_flow(self, particle_id: int) -> QuantumNumberFlow:
+        del particle_id
+        raise NotImplementedError("model does not define exact quantum-number flow")
+
+    def auxiliary_kind(self, particle_id: int) -> str | None:
+        del particle_id
+        return None
+
+    def vertex_component_expression(
+        self,
+        kind: int,
+        left: Sequence[Any],
+        right: Sequence[Any],
+        *,
+        result_particle_id: int,
+        result_chirality: int,
+        left_chirality: int = 0,
+        right_chirality: int = 0,
+        coupling: tuple[Any, Any] = (1.0, 0.0),
+        left_momentum: Sequence[Any] | None = None,
+        right_momentum: Sequence[Any] | None = None,
+    ) -> tuple[Any, ...]:
+        raise NotImplementedError
+
+    def propagator_component_expression(
+        self,
+        particle_id: int,
+        value: Sequence[Any],
+        momentum: Sequence[Any],
+        *,
+        chirality: int = 0,
+        propagator: PropagatorIR | None = None,
+    ) -> tuple[Any, ...]:
+        del propagator
+        raise NotImplementedError
+
+    def iter_vertices(self, *, color_accuracy: str = "lc") -> tuple[Vertex, ...]:
+        if color_accuracy == "lc":
+            return tuple(self.vertices)
+        if color_accuracy in {"nlc", "full"}:
+            return tuple(self.vertices)
+        raise ValueError(f"unknown colour accuracy: {color_accuracy}")
+
+    def vertices_for_inputs(
+        self,
+        left_pdg: int,
+        right_pdg: int,
+        *,
+        color_accuracy: str = "lc",
+    ) -> tuple[Vertex, ...]:
+        key = (color_accuracy, int(left_pdg), int(right_pdg))
+        if key not in self._vertices_by_input:
+            self._vertices_by_input[key] = tuple(
+                vertex
+                for vertex in self.iter_vertices(color_accuracy=color_accuracy)
+                if vertex.particles[0] == left_pdg and vertex.particles[1] == right_pdg
+            )
+        return self._vertices_by_input[key]
+
+    def vertices_accepting(
+        self,
+        left_pdg: int,
+        right_pdg: int,
+        *,
+        color_accuracy: str = "lc",
+    ) -> tuple[Vertex, ...]:
+        """Return model vertices for a local current-current combination.
+
+        This is the process-generic name used by the DAG compiler.  It is a
+        thin alias around the model table lookup, but keeping the name at the
+        model boundary prevents production code from classifying whole process
+        families before asking which local interactions are allowed.
+        """
+
+        return self.vertices_for_inputs(
+            left_pdg,
+            right_pdg,
+            color_accuracy=color_accuracy,
+        )
+
+    def skip_duplicate_vertex_orientation(self, vertex: Vertex) -> bool:
+        """Return whether a mirrored table entry should be skipped by DAG sweeps.
+
+        Generic DAG generation asks the model because duplicated orientations are
+        a model-table convention, not a process-family rule.
+        """
+
+        return False
+
+    def vertex_closure_allowed(self, vertex: Vertex) -> bool:
+        """Return whether a scalar vertex result represents a vacuum closure.
+
+        The legacy built-in model uses auxiliary scalar result particles for a
+        few contact interactions. Generic UFO particles are ordinary currents
+        unless their compiled lowering explicitly introduces such an auxiliary.
+        """
+
+        return True
+
+    def vertex_coupling_orders(self, vertex: Vertex) -> CouplingOrders:
+        """Return model-generic coupling-order increments for one vertex.
+
+        The keys intentionally mirror UFO-style coupling-order names.  They are
+        used only as local model metadata, so DAG pruning can cap e.g. QCD or
+        QED order without recognizing whole process families.
+        """
+
+        del vertex
+        return ()
+
+    def coupling_order_hierarchies(self) -> dict[str, int]:
+        """Return UFO-style priorities used by minimal-order generation.
+
+        A lower hierarchy value is preferred. Models without explicit order
+        metadata conservatively assign equal priority to every observed order.
+        """
+
+        return {}
+
+    def vertex_color_weight(
+        self,
+        vertex: Vertex,
+        *,
+        color_accuracy: str,
+    ) -> tuple[float, float]:
+        """Return the model-owned coefficient for one projected color vertex."""
+
+        del vertex, color_accuracy
+        return (1.0, 0.0)
+
+    def vertex_color_structure(self, vertex: Vertex) -> str:
+        """Return the model-level color tensor family for local projection.
+
+        Built-in kernels already encode their projected color algebra. External
+        tensor models override this hook so the generic color engine can apply
+        flow-dependent identities without recognizing particles or processes.
+        """
+
+        del vertex
+        return "model-defined"
+
+    def vertex_is_internal_contact_fragment(self, vertex: Vertex) -> bool:
+        del vertex
+        return False
+
+    def combine_coupling_orders(
+        self,
+        left_index: Any,
+        right_index: Any,
+        vertex: Vertex,
+    ) -> CouplingOrders:
+        totals: dict[str, int] = {}
+        for orders in (
+            _index_coupling_orders(left_index),
+            _index_coupling_orders(right_index),
+            self.vertex_coupling_orders(vertex),
+        ):
+            for name, value in orders:
+                totals[str(name).upper()] = totals.get(str(name).upper(), 0) + int(
+                    value
+                )
+        return tuple(sorted((name, value) for name, value in totals.items() if value))
+
+    def current_allowed(self, index: Any) -> bool:
+        """Return whether a generated current index is valid in this model."""
+
+        try:
+            particle_id = int(index.particle_id)
+            chirality = int(getattr(index, "chirality", 0))
+            if chirality != 0 and self.is_chiral_eligible(particle_id):
+                return True
+            return self.dimension(particle_id) > 0
+        except (KeyError, TypeError, ValueError):
+            return False
+
+    def _species_particle(self, pdg: int) -> Particle | None:
+        return self._species_by_pdg.get(pdg)
+
+    def _property_sign(self, pdg: int) -> int:
+        try:
+            return self._property_sign_by_pdg[pdg]
+        except KeyError as exc:
+            raise KeyError(f"particle not in model: {pdg}") from exc
+
+
+def _propagator_formula_metadata(
+    kind: PropagatorKind,
+    gauge: PropagatorGauge | None,
+) -> tuple[str | None, str | None]:
+    """Return descriptive formulas for the implemented propagator kernel."""
+
+    if kind == "identity":
+        return ("identity", "1")
+    if kind == "custom":
+        return (None, None)
+    if kind == "weyl-fermion":
+        return ("i*weyl_slash(momentum)", "momentum_squared")
+    if kind == "dirac-fermion":
+        return (
+            "i*(dirac_slash(momentum)+oriented_mass)",
+            "momentum_squared-mass_squared+i*mass*width",
+        )
+    if kind == "vector" and gauge == "feynman":
+        return ("-i*metric", "momentum_squared")
+    if kind == "vector" and gauge == "unitary":
+        return (
+            "-i*(metric-momentum_outer/mass_squared)",
+            "momentum_squared-mass_squared+i*mass*width",
+        )
+    if kind == "spin2":
+        return (
+            "i*spin2_projector",
+            "momentum_squared-mass_squared+i*mass*width",
+        )
+    if kind == "scalar":
+        return ("i", "momentum_squared-mass_squared+i*mass*width")
+    return (None, None)
+
+
+from .expressions import (  # noqa: E402
+    _append_flavour_transition,
+    _index_coupling_orders,
+    _index_flavour_flow,
+    _index_particle_id,
+    _model_vertex_result_chiralities,
+)
+
+__all__ = [
+    "ContractionIR",
+    "CouplingOrders",
+    "Model",
+    "Particle",
+    "PropagatorLoweringRule",
+    "QuantumFlow",
+    "QuantumNumberFlow",
+    "RecurrenceCurrentEmbeddingContract",
+    "RecurrenceFlavourFlowOperation",
+    "RecurrenceLCColorComponentKind",
+    "RecurrenceLCColorComponentRole",
+    "RecurrenceLCColorOperation",
+    "RecurrenceLCColorShapeKind",
+    "RecurrenceLCColorSourceSeedContract",
+    "RecurrenceLCColorSourceSeedOperation",
+    "RecurrenceLCColorTransitionContract",
+    "RecurrenceLCColorWitnessContract",
+    "RecurrenceQuantumFlowContract",
+    "RecurrenceQuantumNumberFlowOperation",
+    "SourceSpinState",
+    "Vertex",
+    "VertexEvaluationEquivalence",
+    "VertexLoweringRule",
+]
diff --git a/pyamplicol/src/pyamplicol/models/builtin/__init__.py b/pyamplicol/src/pyamplicol/models/builtin/__init__.py
new file mode 100644
index 0000000000..a375f4e4c8
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/__init__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from .model import BuiltinSMModel
+
+__all__ = ["BuiltinSMModel"]
diff --git a/pyamplicol/src/pyamplicol/models/builtin/adapters.py b/pyamplicol/src/pyamplicol/models/builtin/adapters.py
new file mode 100644
index 0000000000..69dae50c38
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/adapters.py
@@ -0,0 +1,185 @@
+# SPDX-License-Identifier: 0BSD
+"""Adapters from the hand-written built-in SM to canonical model records."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+from .model import BuiltinSMModel
+from .process_catalog import PDGS
+
+
+def build_model_payload() -> tuple[dict[str, object], dict[str, tuple[float, float]]]:
+    """Return the canonical compiler payload for the built-in SM."""
+
+    model = BuiltinSMModel()
+    particles = []
+    parameters: dict[str, tuple[float, float]] = {
+        "alpha_s": (0.118, 0.0),
+        "alpha_ew": (float(model.alpha_ew), 0.0),
+    }
+    for _key, particle in sorted(model.particles.items()):
+        mass_name = (
+            _parameter_name("mass", particle.pdg)
+            if float(particle.mass) != 0.0
+            else "ZERO"
+        )
+        width_name = (
+            _parameter_name("width", particle.pdg)
+            if float(particle.width) != 0.0
+            else "ZERO"
+        )
+        if mass_name != "ZERO":
+            parameters[mass_name] = (float(particle.mass), 0.0)
+        if width_name != "ZERO":
+            parameters[width_name] = (float(particle.width), 0.0)
+        for pdg in dict.fromkeys((particle.pdg, particle.anti_pdg)):
+            is_antiparticle = pdg != particle.pdg
+            anti_pdg = particle.pdg if is_antiparticle else particle.anti_pdg
+            color = particle.color_rep
+            if is_antiparticle and abs(color) in {3, 6}:
+                color = -color
+            particles.append(
+                {
+                    "pdg_code": pdg,
+                    "name": _particle_name(pdg),
+                    "antiname": _particle_name(anti_pdg),
+                    "spin": _ufo_spin(pdg, particle.spin),
+                    "color": color,
+                    "mass": mass_name,
+                    "width": width_name,
+                    "texname": _particle_name(pdg),
+                    "antitexname": _particle_name(anti_pdg),
+                    "charge": -particle.charge if is_antiparticle else particle.charge,
+                    "quantum_numbers": [
+                        list(item) for item in model.quantum_number_flow(pdg)
+                    ],
+                    "ghost_number": 0,
+                    "lepton_number": 0,
+                    "y_charge": 0,
+                    "propagating": particle.spin >= 0,
+                    "goldstoneboson": False,
+                    "propagator": None,
+                    "component_dimension": particle.dimension,
+                    "auxiliary_kind": model.auxiliary_kind(pdg),
+                }
+            )
+    return (
+        {
+            "name": "built-in-sm",
+            "restriction": None,
+            "orders": [
+                {"name": "QCD", "expansion_order": 99, "hierarchy": 1},
+                {"name": "QED", "expansion_order": 99, "hierarchy": 2},
+            ],
+            "parameters": [
+                {
+                    "name": name,
+                    "nature": "external",
+                    "parameter_type": "real",
+                    "value": [value[0], value[1]],
+                    "expression": None,
+                    "lhablock": "PYAMPLICOL",
+                    "lhacode": [index],
+                }
+                for index, (name, value) in enumerate(
+                    sorted(parameters.items()),
+                    start=1,
+                )
+            ],
+            "particles": particles,
+            "propagators": [],
+            "lorentz_structures": [],
+            "couplings": [],
+            "vertex_rules": [
+                {
+                    "name": f"builtin_vertex_{index}",
+                    "particles": [_particle_name(pdg) for pdg in vertex.particles],
+                    "color_structures": ["1"],
+                    "lorentz_structures": [f"builtin_kind_{vertex.kind}"],
+                    "couplings": [[f"builtin_coupling_{index}"]],
+                    "builtin_kind": vertex.kind,
+                    "builtin_coupling": list(vertex.coupling),
+                }
+                for index, vertex in enumerate(model.vertices)
+            ],
+            "functions": [],
+            "form_factors": [],
+            "direct_contractions": [
+                {
+                    "left_particle": _particle_name(left_particle),
+                    "left_chirality": left_chirality,
+                    "right_particle": _particle_name(right_particle),
+                    "right_chirality": right_chirality,
+                    "contraction_ir": contraction_ir.to_json_dict(),
+                }
+                for (
+                    left_particle,
+                    left_chirality,
+                    right_particle,
+                    right_chirality,
+                ), contraction_ir in sorted(
+                    model._direct_contraction_ir_by_state.items()
+                )
+                if contraction_ir is not None
+            ],
+            "closure_contractions": [
+                {
+                    "particle": _particle_name(particle),
+                    "chirality": chirality,
+                    "contraction_ir": contraction_ir.to_json_dict(),
+                }
+                for (particle, chirality), contraction_ir in sorted(
+                    model._closure_contraction_ir_by_state.items()
+                )
+                if contraction_ir is not None
+            ],
+            "builtin_model": True,
+        },
+        parameters,
+    )
+
+
+def source_digest() -> str:
+    """Hash all implementation files behind the built-in model boundary."""
+
+    digest = hashlib.sha256()
+    root = Path(__file__).resolve().parent
+    for path in sorted(root.glob("*.py")):
+        digest.update(path.name.encode("utf-8") + b"\0")
+        digest.update(path.read_bytes())
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def _parameter_name(field: str, pdg: int) -> str:
+    pdg_token = f"m{abs(int(pdg))}" if int(pdg) < 0 else str(int(pdg))
+    return f"{field}_{pdg_token}"
+
+
+def _particle_name(pdg: int) -> str:
+    candidates = [name for name, value in PDGS.items() if int(value) == pdg]
+    if candidates:
+        return min(candidates, key=lambda name: (len(name), name))
+    return f"pdg_{pdg}"
+
+
+def _ufo_spin(pdg: int, internal_spin: int) -> int:
+    """Translate the legacy kernel spin tag to the UFO 2S+1 convention."""
+
+    if internal_spin < 0:
+        return -1
+    absolute_pdg = abs(pdg)
+    if 1 <= absolute_pdg <= 6 or 11 <= absolute_pdg <= 16:
+        return 2
+    if absolute_pdg in {21, 22, 23, 24}:
+        return 3
+    if absolute_pdg == 25:
+        return 1
+    raise ValueError(
+        f"cannot map built-in particle {pdg} with spin tag {internal_spin} to UFO spin"
+    )
+
+
+__all__ = ["build_model_payload", "source_digest"]
diff --git a/pyamplicol/src/pyamplicol/models/builtin/compiler.py b/pyamplicol/src/pyamplicol/models/builtin/compiler.py
new file mode 100644
index 0000000000..cdeab56efd
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/compiler.py
@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: 0BSD
+"""Canonical IR compilation for the hand-written built-in SM."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from .. import compiler_symbolica as _sym
+from ..compiler_gauge import compile_goldstone_partner_records
+from ..compiler_records import (
+    _mappings,
+    _order,
+    _parameter,
+    _particle_record,
+    _sequence,
+)
+from ..contracts import (
+    CompiledClosureContractionRecord,
+    CompiledDirectContractionRecord,
+    CompiledModelIR,
+    CompiledVertexTerm,
+)
+
+
+def compile_model_ir(model: Mapping[str, object]) -> CompiledModelIR:
+    _sym._ensure_symbolica()
+    particles = tuple(
+        _particle_record(item) for item in _mappings(model.get("particles"))
+    )
+    terms = tuple(
+        CompiledVertexTerm(
+            id=index,
+            vertex=str(vertex["name"]),
+            particles=tuple(str(value) for value in _sequence(vertex["particles"])),
+            color_index=0,
+            lorentz_index=0,
+            color_source="built-in",
+            color_expression="built-in",
+            lorentz_name=str(vertex["builtin_kind"]),
+            lorentz_source="built-in",
+            lorentz_expression="built-in",
+            coupling=f"builtin_coupling_{index}",
+            coupling_expression=str(vertex.get("builtin_coupling", [1.0, 0.0])),
+            coupling_orders=(),
+            backend="built-in",
+        )
+        for index, vertex in enumerate(_mappings(model.get("vertex_rules")))
+    )
+    parameters = tuple(
+        _parameter(item) for item in _mappings(model.get("parameters"))
+    )
+    return CompiledModelIR(
+        name=str(model.get("name", "built-in-sm")),
+        orders=tuple(_order(item) for item in _mappings(model.get("orders"))),
+        parameters=parameters,
+        particles=particles,
+        couplings=(),
+        propagators=(),
+        vertex_terms=terms,
+        oriented_kernels=(),
+        direct_contractions=tuple(
+            CompiledDirectContractionRecord.from_dict(item)
+            for item in _mappings(model.get("direct_contractions"))
+        ),
+        closure_contractions=tuple(
+            CompiledClosureContractionRecord.from_dict(item)
+            for item in _mappings(model.get("closure_contractions"))
+        ),
+        goldstone_partners=compile_goldstone_partner_records(
+            particles,
+            parameters,
+            (),
+        ),
+    )
+
+
+__all__ = ["compile_model_ir"]
diff --git a/pyamplicol/src/pyamplicol/models/builtin/definitions.py b/pyamplicol/src/pyamplicol/models/builtin/definitions.py
new file mode 100644
index 0000000000..5263b13a9c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/definitions.py
@@ -0,0 +1,341 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from ..base import (
+    Particle,
+    Vertex,
+)
+
+
+class BuiltinSMDefinitionMixin:
+    def _build_particles(self) -> list[Particle]:
+        particles: list[Particle] = []
+        for i in range(1, 6):
+            if i % 2 == 0:
+                particles.append(
+                    Particle(
+                        i,
+                        -i,
+                        2,
+                        4,
+                        3,
+                        charge=2.0 / 3.0,
+                        weak_isospin=(0.5, 0.0),
+                        weak_hypercharge=(1.0 / 3.0, 4.0 / 3.0),
+                    )
+                )
+            else:
+                particles.append(
+                    Particle(
+                        i,
+                        -i,
+                        2,
+                        4,
+                        3,
+                        charge=-1.0 / 3.0,
+                        weak_isospin=(-0.5, 0.0),
+                        weak_hypercharge=(1.0 / 3.0, -2.0 / 3.0),
+                    )
+                )
+        particles.extend(
+            [
+                Particle(
+                    6,
+                    -6,
+                    2,
+                    4,
+                    3,
+                    mass=173.0,
+                    width=1.491500,
+                    charge=2.0 / 3.0,
+                    weak_isospin=(0.5, 0.0),
+                    weak_hypercharge=(1.0 / 3.0, 4.0 / 3.0),
+                ),
+                Particle(21, 21, 2, 4, 8),
+                Particle(99, 99, -1, 4, 1),
+                Particle(-21, -21, -1, 6, 8),
+                Particle(22, 22, 2, 4, 1),
+                Particle(23, 23, 3, 4, 1, mass=91.188, width=2.441404),
+                Particle(-23, -23, -1, 6, 1),
+                Particle(
+                    24,
+                    -24,
+                    3,
+                    4,
+                    1,
+                    mass=80.419002445756163,
+                    width=2.0476,
+                    charge=1.0,
+                    weak_isospin=(1.0, 1.0),
+                ),
+                Particle(
+                    25,
+                    25,
+                    1,
+                    1,
+                    1,
+                    mass=125.0,
+                    width=0.0063823389999999999,
+                    weak_isospin=(-0.5, -0.5),
+                    weak_hypercharge=(1.0, 1.0),
+                ),
+                Particle(125, 125, -1, 1, 1),
+                Particle(126, 126, -1, 1, 1),
+                Particle(127, 127, -1, 1, 1),
+                Particle(26, -26, -1, 6, 1, charge=1.0, weak_isospin=(1.0, 1.0)),
+            ]
+        )
+        for i in range(1, 4):
+            charged = 11 + (2 * i - 2)
+            neutrino = 12 + (2 * i - 2)
+            particles.append(
+                Particle(
+                    charged,
+                    -charged,
+                    2,
+                    4,
+                    1,
+                    charge=-1.0,
+                    weak_isospin=(-0.5, 0.0),
+                    weak_hypercharge=(-1.0, -2.0),
+                )
+            )
+            particles.append(
+                Particle(
+                    neutrino,
+                    -neutrino,
+                    2,
+                    4,
+                    1,
+                    weak_isospin=(0.5, 0.0),
+                    weak_hypercharge=(-1.0, 0.0),
+                )
+            )
+        return particles
+
+    def _build_vertices(self) -> list[Vertex]:
+        vertices: list[Vertex] = [
+            Vertex(0, (21, 21, 21)),
+            Vertex(1, (21, 21, -21)),
+            Vertex(2, (-21, 21, 21)),
+            Vertex(3, (21, -21, 21)),
+        ]
+        self._extend_quark_gluon_vertices(vertices)
+        self._extend_electroweak_gauge_vertices(vertices)
+        self._extend_higgs_vertices(vertices)
+        self._extend_lepton_vertices(vertices)
+        return vertices
+
+    def _extend_quark_gluon_vertices(self, vertices: list[Vertex]) -> None:
+        for i in range(1, 7):
+            vertices.extend(
+                [
+                    Vertex(4, (21, i, i)),
+                    Vertex(5, (21, -i, -i)),
+                    Vertex(6, (i, 21, i)),
+                    Vertex(7, (-i, 21, -i)),
+                    Vertex(9, (-i, i, 21)),
+                    Vertex(8, (i, -i, 99), (1.0 / 3.0, 0.0)),
+                    Vertex(4, (99, i, i)),
+                    Vertex(5, (99, -i, -i)),
+                    Vertex(6, (i, 99, i)),
+                    Vertex(7, (-i, 99, -i)),
+                    Vertex(10, (i, 22, i), self.photon_fermion_coupling(i)),
+                    Vertex(11, (-i, 22, -i), self.photon_fermion_coupling(-i)),
+                    Vertex(10, (i, 23, i), self.z_fermion_coupling(i)),
+                    Vertex(11, (-i, 23, -i), self.z_fermion_coupling(-i)),
+                ]
+            )
+            if i % 2 == 0:
+                vertices.append(
+                    Vertex(10, (i, -24, i - 1), (self.charged_current_coupling(), 0.0))
+                )
+                vertices.append(
+                    Vertex(11, (-i, 24, -i + 1), (self.charged_current_coupling(), 0.0))
+                )
+            else:
+                vertices.append(
+                    Vertex(10, (i, 24, i + 1), (self.charged_current_coupling(), 0.0))
+                )
+                vertices.append(
+                    Vertex(
+                        11, (-i, -24, -i - 1), (self.charged_current_coupling(), 0.0)
+                    )
+                )
+
+    def _extend_electroweak_gauge_vertices(self, vertices: list[Vertex]) -> None:
+        ngc = self.neutral_gauge_coupling()
+        wc = self.weak_coupling()
+        vertices.extend(
+            [
+                Vertex(12, (24, -24, 23), (-ngc, 0.0)),
+                Vertex(12, (-24, 24, 23), (ngc, 0.0)),
+                Vertex(12, (24, -24, 22), (-self.charge(24), 0.0)),
+                Vertex(12, (-24, 24, 22), (self.charge(24), 0.0)),
+                Vertex(12, (24, 22, 24), (self.charge(24), 0.0)),
+                Vertex(12, (-24, 22, -24), (self.charge(-24), 0.0)),
+                Vertex(12, (22, 24, 24), (-self.charge(24), 0.0)),
+                Vertex(12, (22, -24, -24), (-self.charge(-24), 0.0)),
+                Vertex(12, (24, 23, 24), (ngc, 0.0)),
+                Vertex(12, (-24, 23, -24), (-ngc, 0.0)),
+                Vertex(12, (23, 24, 24), (-ngc, 0.0)),
+                Vertex(12, (23, -24, -24), (ngc, 0.0)),
+                Vertex(13, (24, -24, -23), (wc, 0.0)),
+                Vertex(13, (-24, 24, -23), (-wc, 0.0)),
+                Vertex(14, (-23, 24, 24), (wc, 0.0)),
+                Vertex(14, (-23, -24, -24), (-wc, 0.0)),
+                Vertex(15, (24, -23, 24), (-wc, 0.0)),
+                Vertex(15, (-24, -23, -24), (wc, 0.0)),
+                Vertex(13, (24, 22, 26), (self.charge(24), 0.0)),
+                Vertex(13, (-24, 22, -26), (-self.charge(-24), 0.0)),
+                Vertex(13, (22, 24, 26), (-self.charge(24), 0.0)),
+                Vertex(13, (22, -24, -26), (self.charge(-24), 0.0)),
+                Vertex(13, (24, 23, 26), (ngc, 0.0)),
+                Vertex(13, (-24, 23, -26), (ngc, 0.0)),
+                Vertex(13, (23, 24, 26), (-ngc, 0.0)),
+                Vertex(13, (23, -24, -26), (-ngc, 0.0)),
+                Vertex(14, (26, 22, 24), (self.charge(26), 0.0)),
+                Vertex(14, (-26, 22, -24), (-self.charge(-26), 0.0)),
+                Vertex(14, (26, -24, 22), (-self.charge(26), 0.0)),
+                Vertex(14, (-26, 24, 22), (self.charge(-26), 0.0)),
+                Vertex(14, (26, 23, 24), (ngc, 0.0)),
+                Vertex(14, (-26, 23, -24), (ngc, 0.0)),
+                Vertex(14, (26, -24, 23), (-ngc, 0.0)),
+                Vertex(14, (-26, 24, 23), (-ngc, 0.0)),
+                Vertex(15, (22, 26, 24), (-self.charge(26), 0.0)),
+                Vertex(15, (22, -26, -24), (self.charge(-26), 0.0)),
+                Vertex(15, (24, -26, 22), (self.charge(24), 0.0)),
+                Vertex(15, (-24, 26, 22), (-self.charge(-24), 0.0)),
+                Vertex(15, (23, 26, 24), (-ngc, 0.0)),
+                Vertex(15, (23, -26, -24), (-ngc, 0.0)),
+                Vertex(15, (24, -26, 23), (ngc, 0.0)),
+                Vertex(15, (-24, 26, 23), (ngc, 0.0)),
+            ]
+        )
+
+    def _extend_higgs_vertices(self, vertices: list[Vertex]) -> None:
+        wc = self.weak_coupling()
+        wc2 = wc**2
+        cw2 = self.cos_weak**2
+        for i in range(1, 7):
+            if self.mass(i) == 0.0:
+                continue
+            coupling = self.mass(i) * wc / (self.mass(24) * 2.0)
+            vertices.append(Vertex(16, (i, 25, i), (coupling, 0.0)))
+            vertices.append(Vertex(16, (-i, 25, -i), (coupling, 0.0)))
+        vertices.extend(
+            [
+                Vertex(17, (24, -24, 25), (self.mass(24) * wc, 0.0)),
+                Vertex(17, (-24, 24, 25), (self.mass(24) * wc, 0.0)),
+                Vertex(18, (25, 24, 24), (self.mass(24) * wc, 0.0)),
+                Vertex(18, (25, -24, -24), (self.mass(24) * wc, 0.0)),
+                Vertex(19, (24, 25, 24), (self.mass(24) * wc, 0.0)),
+                Vertex(19, (-24, 25, -24), (self.mass(24) * wc, 0.0)),
+                Vertex(
+                    17,
+                    (23, 23, 25),
+                    (self.mass(23) * self.weak_coupling_over_cosine(), 0.0),
+                ),
+                Vertex(
+                    18,
+                    (25, 23, 23),
+                    (self.mass(23) * self.weak_coupling_over_cosine(), 0.0),
+                ),
+                Vertex(
+                    19,
+                    (23, 25, 23),
+                    (self.mass(23) * self.weak_coupling_over_cosine(), 0.0),
+                ),
+                Vertex(
+                    20,
+                    (25, 25, 25),
+                    ((-3.0 / 2.0) * wc * (self.mass(25) ** 2 / self.mass(24)), 0.0),
+                ),
+                Vertex(17, (24, -24, 127), (0.5 * wc2, 0.0)),
+                Vertex(17, (-24, 24, 127), (0.5 * wc2, 0.0)),
+                Vertex(17, (23, 23, 127), (0.5 * wc2 / cw2, 0.0)),
+                Vertex(20, (125, 25, 25), (1.0, 0.0)),
+                Vertex(20, (25, 125, 25), (1.0, 0.0)),
+                Vertex(
+                    20,
+                    (25, 25, 125),
+                    ((-3.0 / 4.0) * wc2 * self.mass(25) ** 2 / self.mass(24) ** 2, 0.0),
+                ),
+                Vertex(20, (127, 25, 25), (1.0, 0.0)),
+                Vertex(20, (25, 127, 25), (1.0, 0.0)),
+                Vertex(20, (25, 25, 126), (1.0, -10.0)),
+                Vertex(18, (126, 23, 23), (-0.5 * wc2 / cw2, 0.0)),
+                Vertex(19, (23, 126, 23), (-0.5 * wc2 / cw2, 0.0)),
+                Vertex(18, (126, 24, 24), (-0.5 * wc2, 0.0)),
+                Vertex(18, (126, -24, -24), (-0.5 * wc2, 0.0)),
+                Vertex(19, (24, 126, 24), (-0.5 * wc2, 0.0)),
+                Vertex(19, (-24, 126, -24), (-0.5 * wc2, 0.0)),
+            ]
+        )
+
+    def _extend_lepton_vertices(self, vertices: list[Vertex]) -> None:
+        for i in range(1, 4):
+            charged = 11 + (2 * i - 2)
+            neutrino = 12 + (2 * i - 2)
+            vertices.extend(
+                [
+                    Vertex(
+                        21,
+                        (charged, -charged, 22),
+                        self.photon_fermion_coupling(charged),
+                    ),
+                    Vertex(
+                        22,
+                        (-charged, charged, 22),
+                        self.photon_fermion_coupling(-charged),
+                    ),
+                    Vertex(
+                        21, (charged, -charged, 23), self.z_fermion_coupling(charged)
+                    ),
+                    Vertex(
+                        22, (-charged, charged, 23), self.z_fermion_coupling(-charged)
+                    ),
+                    Vertex(
+                        21,
+                        (charged, -neutrino, -24),
+                        (self.charged_current_coupling(), 0.0),
+                    ),
+                    Vertex(
+                        22,
+                        (-charged, neutrino, 24),
+                        (self.charged_current_coupling(), 0.0),
+                    ),
+                    Vertex(
+                        10,
+                        (charged, 22, charged),
+                        self.photon_fermion_coupling(charged),
+                    ),
+                    Vertex(
+                        11,
+                        (-charged, 22, -charged),
+                        self.photon_fermion_coupling(-charged),
+                    ),
+                    Vertex(
+                        23,
+                        (22, charged, charged),
+                        self.photon_fermion_coupling(charged),
+                    ),
+                    Vertex(
+                        24,
+                        (22, -charged, -charged),
+                        self.photon_fermion_coupling(-charged),
+                    ),
+                    Vertex(
+                        10, (charged, 23, charged), self.z_fermion_coupling(charged)
+                    ),
+                    Vertex(
+                        11, (-charged, 23, -charged), self.z_fermion_coupling(-charged)
+                    ),
+                    Vertex(
+                        23, (23, charged, charged), self.z_fermion_coupling(charged)
+                    ),
+                    Vertex(
+                        24, (23, -charged, -charged), self.z_fermion_coupling(-charged)
+                    ),
+                ]
+            )
diff --git a/pyamplicol/src/pyamplicol/models/builtin/expressions.py b/pyamplicol/src/pyamplicol/models/builtin/expressions.py
new file mode 100644
index 0000000000..9657eb70be
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/expressions.py
@@ -0,0 +1,503 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+from functools import cache
+from numbers import Number
+from typing import Any
+
+from ..base import Model, Vertex
+from ..expressions import (
+    _expr_minkowski_dot,
+    _index_particle_id,
+)
+
+
+@cache
+def _exact_imaginary_inverse_sqrt_two() -> Any:
+    from symbolica import E
+
+    return E("1i/sqrt(2)")
+
+
+def _imaginary_inverse_sqrt_two(*values: Any) -> Any:
+    """Keep symbolic vertices exact without changing direct numeric evaluation."""
+
+    if all(isinstance(value, Number) for value in values):
+        return 1j / math.sqrt(2.0)
+    return _exact_imaginary_inverse_sqrt_two()
+
+
+def _flat_index(indices: tuple[int, ...], dims: tuple[int, ...]) -> int:
+    index = 0
+    for value, dim in zip(indices, dims, strict=True):
+        index = index * dim + value
+    return index
+
+
+def _index_chirality(index: Any) -> int:
+    return int(getattr(index, "chirality", 0))
+
+
+def _expr_vector_slash_terms(
+    vector: tuple[Any, ...],
+) -> tuple[Any, Any, Any, Any]:
+    v0, v1, v2, v3 = vector
+    return v0 + v3, v0 - v3, v1 + 1j * v2, v1 - 1j * v2
+
+
+def _builtin_vertex_result_chiralities(
+    model: Model,
+    vertex: Vertex,
+    left_index: Any,
+    right_index: Any,
+) -> tuple[int, ...]:
+    result_pdg = vertex.particles[2]
+    if model.is_chiral_eligible(result_pdg):
+        input_chirality = _model_fermion_input_chirality(model, left_index, right_index)
+        if input_chirality == 0:
+            return (0,)
+        if not _model_weyl_vertex_allowed(vertex, result_pdg, input_chirality):
+            return ()
+        return (input_chirality,)
+
+    if _model_is_fermion_pair_to_vector_vertex(vertex.kind):
+        left_pdg = _index_particle_id(left_index)
+        right_pdg = _index_particle_id(right_index)
+        left_chirality = (
+            _index_chirality(left_index) if model.is_fermion(left_pdg) else 0
+        )
+        right_chirality = (
+            _index_chirality(right_index) if model.is_fermion(right_pdg) else 0
+        )
+        if (
+            left_chirality != 0
+            and right_chirality != 0
+            and left_chirality != -right_chirality
+        ):
+            return ()
+        if not _model_fermion_pair_vector_coupling_allowed(
+            vertex,
+            left_chirality,
+            right_chirality,
+        ):
+            return ()
+    return (0,)
+
+
+def _model_fermion_input_chirality(
+    model: Model,
+    left_index: Any,
+    right_index: Any,
+) -> int:
+    left_pdg = _index_particle_id(left_index)
+    right_pdg = _index_particle_id(right_index)
+    left_chirality = _index_chirality(left_index)
+    right_chirality = _index_chirality(right_index)
+    if model.is_fermion(left_pdg) and left_chirality != 0:
+        return left_chirality
+    if model.is_fermion(right_pdg) and right_chirality != 0:
+        return right_chirality
+    return 0
+
+
+def _model_weyl_vertex_allowed(
+    vertex: Vertex,
+    result_pdg: int,
+    chirality: int,
+) -> bool:
+    if vertex.kind == 16:
+        return False
+    if vertex.kind in {10, 11, 23, 24}:
+        index = _model_fermion_coupling_index(result_pdg, chirality)
+        return vertex.coupling[index] != 0.0
+    return True
+
+
+def _model_fermion_coupling_index(pdg: int, chirality: int) -> int:
+    if pdg > 0:
+        return 0 if chirality == -1 else 1
+    return 0 if chirality == 1 else 1
+
+
+def _model_is_fermion_pair_to_vector_vertex(kind: int) -> bool:
+    return kind in {8, 9, 21, 22}
+
+
+def _model_fermion_pair_vector_coupling_allowed(
+    vertex: Vertex,
+    left_chirality: int,
+    right_chirality: int,
+) -> bool:
+    if vertex.kind in {8, 9}:
+        return True
+    if left_chirality == 0 or right_chirality == 0:
+        return any(component != 0.0 for component in vertex.coupling)
+    if vertex.kind == 21:
+        index = 0 if left_chirality == -1 and right_chirality == 1 else 1
+        return vertex.coupling[index] != 0.0
+    if vertex.kind == 22:
+        index = 0 if left_chirality == 1 and right_chirality == -1 else 1
+        return vertex.coupling[index] != 0.0
+    return True
+
+
+def _expr_three_vector_current(
+    left: tuple[Any, ...],
+    left_momentum: tuple[Any, ...],
+    right: tuple[Any, ...],
+    right_momentum: tuple[Any, ...],
+) -> tuple[Any, ...]:
+    dot = _expr_minkowski_dot(left, right)
+    left_dot_right_momentum = _expr_minkowski_dot(left, right_momentum)
+    right_dot_left_momentum = _expr_minkowski_dot(right, left_momentum)
+    prefactor = _imaginary_inverse_sqrt_two(
+        *left, *left_momentum, *right, *right_momentum
+    )
+    return tuple(
+        prefactor
+        * (
+            dot * (left_momentum[index] - right_momentum[index])
+            + 2.0
+            * (
+                left_dot_right_momentum * right[index]
+                - right_dot_left_momentum * left[index]
+            )
+        )
+        for index in range(4)
+    )
+
+
+def _expr_three_vector_current_coupled(
+    left: tuple[Any, ...],
+    left_momentum: tuple[Any, ...],
+    right: tuple[Any, ...],
+    right_momentum: tuple[Any, ...],
+    coupling: tuple[Any, Any],
+) -> tuple[Any, ...]:
+    dot = _expr_minkowski_dot(left, right)
+    tmp2_momentum = tuple(
+        2.0 * right_momentum[index] + left_momentum[index] for index in range(4)
+    )
+    tmp3_momentum = tuple(
+        -2.0 * left_momentum[index] - right_momentum[index] for index in range(4)
+    )
+    tmp2 = _expr_minkowski_dot(left, tmp2_momentum)
+    tmp3 = _expr_minkowski_dot(right, tmp3_momentum)
+    prefactor = (
+        _imaginary_inverse_sqrt_two(
+            *left, *left_momentum, *right, *right_momentum, *coupling
+        )
+        * coupling[0]
+    )
+    return tuple(
+        prefactor
+        * (
+            dot * (left_momentum[index] - right_momentum[index])
+            + tmp2 * right[index]
+            + tmp3 * left[index]
+        )
+        for index in range(4)
+    )
+
+
+def _expr_two_vector_to_tensor(
+    left: tuple[Any, ...],
+    right: tuple[Any, ...],
+) -> tuple[Any, ...]:
+    return (
+        left[0] * right[1] - left[1] * right[0],
+        left[0] * right[2] - left[2] * right[0],
+        left[0] * right[3] - left[3] * right[0],
+        left[1] * right[2] - left[2] * right[1],
+        left[1] * right[3] - left[3] * right[1],
+        left[2] * right[3] - left[3] * right[2],
+    )
+
+
+def _expr_tensor_vector_to_vector(
+    tensor: tuple[Any, ...],
+    vector: tuple[Any, ...],
+) -> tuple[Any, ...]:
+    prefactor = 0.5j
+    return (
+        (tensor[0] * vector[1] + tensor[1] * vector[2] + tensor[2] * vector[3])
+        * prefactor,
+        (tensor[0] * vector[0] + tensor[3] * vector[2] + tensor[4] * vector[3])
+        * prefactor,
+        (tensor[1] * vector[0] - tensor[3] * vector[1] + tensor[5] * vector[3])
+        * prefactor,
+        (tensor[2] * vector[0] - tensor[4] * vector[1] - tensor[5] * vector[2])
+        * prefactor,
+    )
+
+
+def _expr_vector_tensor_to_vector(
+    vector: tuple[Any, ...],
+    tensor: tuple[Any, ...],
+) -> tuple[Any, ...]:
+    prefactor = 0.5j
+    return (
+        (-vector[1] * tensor[0] - vector[2] * tensor[1] - vector[3] * tensor[2])
+        * prefactor,
+        (-vector[0] * tensor[0] - vector[2] * tensor[3] - vector[3] * tensor[4])
+        * prefactor,
+        (-vector[0] * tensor[1] + vector[1] * tensor[3] - vector[3] * tensor[5])
+        * prefactor,
+        (-vector[0] * tensor[2] + vector[1] * tensor[4] + vector[2] * tensor[5])
+        * prefactor,
+    )
+
+
+def _expr_fermion_vector_weyl(
+    fermion: tuple[Any, ...],
+    vector: tuple[Any, ...],
+    chirality: int,
+    *,
+    antifermion: bool,
+    coupling: tuple[Any, Any] | None,
+) -> tuple[Any, ...]:
+    tmp1, tmp2, tmp3, tmp4 = _expr_vector_slash_terms(vector)
+    prefactor = _imaginary_inverse_sqrt_two(*fermion, *vector, *(coupling or ()))
+    f1, f2 = fermion
+    if antifermion:
+        if chirality == 1:
+            factor = prefactor if coupling is None else prefactor * coupling[0]
+            return (
+                factor * (tmp1 * f1 + tmp4 * f2),
+                factor * (tmp2 * f2 + tmp3 * f1),
+            )
+        if chirality == -1:
+            factor = prefactor if coupling is None else prefactor * coupling[1]
+            return (
+                factor * (tmp2 * f1 - tmp4 * f2),
+                factor * (tmp1 * f2 - tmp3 * f1),
+            )
+    else:
+        if chirality == 1:
+            factor = prefactor if coupling is None else prefactor * coupling[1]
+            return (
+                factor * (tmp2 * f1 - tmp3 * f2),
+                factor * (tmp1 * f2 - tmp4 * f1),
+            )
+        if chirality == -1:
+            factor = prefactor if coupling is None else prefactor * coupling[0]
+            return (
+                factor * (tmp1 * f1 + tmp3 * f2),
+                factor * (tmp2 * f2 + tmp4 * f1),
+            )
+    raise ValueError("fermion-vector Weyl kernel needs nonzero chirality")
+
+
+def _embed_weyl_current_in_dirac(
+    current: tuple[Any, ...],
+    chirality: int,
+) -> tuple[Any, ...]:
+    """Embed a massless chiral current in the built-in Dirac basis."""
+
+    if len(current) != 2:
+        raise ValueError("Weyl-to-Dirac embedding expects two components")
+    zero = current[0] * 0
+    if chirality == -1:
+        return (*current, zero, zero)
+    if chirality == 1:
+        return (zero, zero, *current)
+    raise ValueError("Weyl-to-Dirac embedding needs nonzero chirality")
+
+
+def _expr_fermion_vector_dirac(
+    fermion: tuple[Any, ...],
+    vector: tuple[Any, ...],
+    *,
+    antifermion: bool,
+    coupling: tuple[Any, Any] | None,
+) -> tuple[Any, ...]:
+    if len(fermion) != 4 or len(vector) != 4:
+        raise ValueError("Dirac fermion-vector current expects dimensions 4 and 4")
+    tmp1, tmp2, tmp3, tmp4 = _expr_vector_slash_terms(vector)
+    prefactor = _imaginary_inverse_sqrt_two(*fermion, *vector, *(coupling or ()))
+    f1, f2, f3, f4 = fermion
+    if coupling is None:
+        left_coupling = 1.0
+        right_coupling = 1.0
+    else:
+        left_coupling, right_coupling = coupling
+    if antifermion:
+        upper = prefactor * right_coupling
+        lower = prefactor * left_coupling
+        return (
+            upper * (tmp2 * f3 - tmp4 * f4),
+            upper * (tmp1 * f4 - tmp3 * f3),
+            lower * (tmp1 * f1 + tmp4 * f2),
+            lower * (tmp2 * f2 + tmp3 * f1),
+        )
+    upper = prefactor * left_coupling
+    lower = prefactor * right_coupling
+    return (
+        upper * (tmp1 * f3 + tmp3 * f4),
+        upper * (tmp2 * f4 + tmp4 * f3),
+        lower * (tmp2 * f1 - tmp3 * f2),
+        lower * (tmp1 * f2 - tmp4 * f1),
+    )
+
+
+def _expr_fermion_antifermion_to_vector_weyl(
+    *,
+    fermion: tuple[Any, ...],
+    antifermion: tuple[Any, ...],
+    coupling: tuple[Any, Any],
+    fermion_chirality: int,
+    antifermion_chirality: int,
+) -> tuple[Any, ...]:
+    prefactor = _imaginary_inverse_sqrt_two(*fermion, *antifermion, *coupling)
+    left, right = coupling
+    f1, f2 = fermion
+    a1, a2 = antifermion
+    if fermion_chirality == -1 and antifermion_chirality == 1:
+        factor = prefactor * left
+        return (
+            factor * (f1 * a1 + f2 * a2),
+            -factor * (f2 * a1 + f1 * a2),
+            1j * factor * (-f2 * a1 + f1 * a2),
+            factor * (-f1 * a1 + f2 * a2),
+        )
+    if fermion_chirality == 1 and antifermion_chirality == -1:
+        factor = prefactor * right
+        return (
+            factor * (f1 * a1 + f2 * a2),
+            factor * (f1 * a2 + f2 * a1),
+            1j * factor * (-f1 * a2 + f2 * a1),
+            factor * (f1 * a1 - f2 * a2),
+        )
+    return (0j, 0j, 0j, 0j)
+
+
+def _expr_fermion_antifermion_to_vector_dirac(
+    *,
+    fermion: tuple[Any, ...],
+    antifermion: tuple[Any, ...],
+    coupling: tuple[Any, Any],
+) -> tuple[Any, ...]:
+    if len(fermion) != 4 or len(antifermion) != 4:
+        raise ValueError(
+            "Dirac fermion-antifermion vector current expects dimensions 4 and 4"
+        )
+    prefactor = _imaginary_inverse_sqrt_two(*fermion, *antifermion, *coupling)
+    left_coupling, right_coupling = coupling
+    f1, f2, f3, f4 = fermion
+    a1, a2, a3, a4 = antifermion
+    left = (
+        f3 * a1 + f4 * a2,
+        -(f4 * a1 + f3 * a2),
+        1j * (-f4 * a1 + f3 * a2),
+        -f3 * a1 + f4 * a2,
+    )
+    right = (
+        f1 * a3 + f2 * a4,
+        f1 * a4 + f2 * a3,
+        1j * (-f1 * a4 + f2 * a3),
+        f1 * a3 - f2 * a4,
+    )
+    return tuple(
+        prefactor * (left_coupling * left[index] + right_coupling * right[index])
+        for index in range(4)
+    )
+
+
+def _expr_fermion_scalar_to_fermion(
+    fermion: tuple[Any, ...],
+    scalar: tuple[Any, ...],
+    coupling: tuple[Any, Any],
+) -> tuple[Any, ...]:
+    if len(fermion) != 4 or len(scalar) != 1:
+        raise ValueError("Dirac fermion-scalar current expects dimensions 4 and 1")
+    prefactor = -_imaginary_inverse_sqrt_two(*fermion, *scalar, *coupling)
+    return tuple(
+        prefactor * coupling[0] * scalar[0] * component for component in fermion
+    )
+
+
+def _two_gluon_to_tensor_data() -> list[complex]:
+    data = [0j] * (6 * 4 * 4)
+    metric = (1.0, -1.0, -1.0, -1.0)
+    for tensor_index, (i, j) in enumerate(_ANTISYM_PAIRS):
+        data[_flat_index((i, j, tensor_index), (4, 4, 6))] = (
+            1.0 / (metric[i] * metric[j])
+        ) + 0j
+        data[_flat_index((j, i, tensor_index), (4, 4, 6))] = (
+            -1.0 / (metric[j] * metric[i])
+        ) + 0j
+    return data
+
+
+def _tensor_gluon_to_gluon_data() -> list[complex]:
+    data = [0j] * (6 * 4 * 4)
+    prefactor = 0.5j
+    metric = (1.0, -1.0, -1.0, -1.0)
+    rows = {
+        0: ((0, 1, 1), (1, 2, 1), (2, 3, 1)),
+        1: ((0, 0, 1), (3, 2, 1), (4, 3, 1)),
+        2: ((1, 0, 1), (3, 1, -1), (5, 3, 1)),
+        3: ((2, 0, 1), (4, 1, -1), (5, 2, -1)),
+    }
+    for out, entries in rows.items():
+        for tensor_index, gluon_index, sign in entries:
+            data[_flat_index((tensor_index, gluon_index, out), (6, 4, 4))] = (
+                sign * prefactor / metric[gluon_index]
+            )
+    return data
+
+
+def _gluon_tensor_to_gluon_data() -> list[complex]:
+    data = [0j] * (6 * 4 * 4)
+    prefactor = 0.5j
+    metric = (1.0, -1.0, -1.0, -1.0)
+    rows = {
+        0: ((1, 0, -1), (2, 1, -1), (3, 2, -1)),
+        1: ((0, 0, -1), (2, 3, -1), (3, 4, -1)),
+        2: ((0, 1, -1), (1, 3, 1), (3, 5, -1)),
+        3: ((0, 2, -1), (1, 4, 1), (2, 5, 1)),
+    }
+    for out, entries in rows.items():
+        for gluon_index, tensor_index, sign in entries:
+            data[_flat_index((gluon_index, tensor_index, out), (4, 6, 4))] = (
+                sign * prefactor / metric[gluon_index]
+            )
+    return data
+
+
+def _quark_vector_weyl_data(*, chirality: int) -> list[Any]:
+    prefactor = _exact_imaginary_inverse_sqrt_two()
+    data: list[Any] = [prefactor * 0] * (2 * 4 * 2)
+    metric = (1.0, -1.0, -1.0, -1.0)
+
+    def add(q_in: int, vector: int, q_out: int, coefficient: Any) -> None:
+        # Tensor.dense accepts logical interface order, not canonical storage order.
+        data[_flat_index((q_in, vector, q_out), (2, 4, 2))] = (
+            coefficient / metric[vector]
+        )
+
+    if chirality == 1:
+        add(0, 0, 0, prefactor)
+        add(0, 3, 0, -prefactor)
+        add(1, 1, 0, -prefactor)
+        add(1, 2, 0, -1j * prefactor)
+        add(1, 0, 1, prefactor)
+        add(1, 3, 1, prefactor)
+        add(0, 1, 1, -prefactor)
+        add(0, 2, 1, 1j * prefactor)
+        return data
+    if chirality == -1:
+        add(0, 0, 0, prefactor)
+        add(0, 3, 0, prefactor)
+        add(1, 1, 0, prefactor)
+        add(1, 2, 0, 1j * prefactor)
+        add(1, 0, 1, prefactor)
+        add(1, 3, 1, -prefactor)
+        add(0, 1, 1, prefactor)
+        add(0, 2, 1, -1j * prefactor)
+        return data
+    raise ValueError(f"unsupported Weyl chirality: {chirality}")
+
+
+_ANTISYM_PAIRS = ((0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3))
diff --git a/pyamplicol/src/pyamplicol/models/builtin/lowering.py b/pyamplicol/src/pyamplicol/models/builtin/lowering.py
new file mode 100644
index 0000000000..ec0e68ed83
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/lowering.py
@@ -0,0 +1,876 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from .._physics_ir import PropagatorIR
+from ..base import (
+    VertexEvaluationEquivalence,
+    VertexLoweringRule,
+)
+from ..expressions import (
+    _as_expression,
+    _expr_antifermion_propagator_dirac,
+    _expr_antifermion_propagator_weyl,
+    _expr_fermion_propagator_dirac,
+    _expr_fermion_propagator_weyl,
+    _expr_minkowski_dot,
+    _minkowski_square_expression,
+    _number,
+)
+from .expressions import (
+    _embed_weyl_current_in_dirac,
+    _exact_imaginary_inverse_sqrt_two,
+    _expr_fermion_antifermion_to_vector_dirac,
+    _expr_fermion_antifermion_to_vector_weyl,
+    _expr_fermion_scalar_to_fermion,
+    _expr_fermion_vector_dirac,
+    _expr_fermion_vector_weyl,
+    _expr_tensor_vector_to_vector,
+    _expr_three_vector_current,
+    _expr_three_vector_current_coupled,
+    _expr_two_vector_to_tensor,
+    _expr_vector_tensor_to_vector,
+    _flat_index,
+    _gluon_tensor_to_gluon_data,
+    _imaginary_inverse_sqrt_two,
+    _quark_vector_weyl_data,
+    _tensor_gluon_to_gluon_data,
+    _two_gluon_to_tensor_data,
+)
+from .symbols import symbols
+
+
+def _as_dirac_current(
+    current: tuple[Any, ...],
+    chirality: int,
+) -> tuple[Any, ...]:
+    if len(current) == 4:
+        return current
+    return _embed_weyl_current_in_dirac(current, chirality)
+
+
+class BuiltinSMLoweringMixin:
+    def build_tensor_library(self) -> Any:
+        from symbolica.community.tensor import (
+            Representation,
+            Tensor,
+            TensorLibrary,
+            TensorName,
+        )
+
+        library = TensorLibrary.hep_lib_atom()
+        mink = Representation.mink(4)
+        antisym = Representation(symbols.antisymmetric_lorentz_pair_name, 6)
+        weyl = Representation(symbols.weyl_spinor_name, 2)
+        two_gluon_to_tensor = TensorName(symbols.display_name("two_gluon_to_tensor"))
+        tensor_gluon_to_gluon = TensorName(
+            symbols.display_name("tensor_gluon_to_gluon")
+        )
+        gluon_tensor_to_gluon = TensorName(
+            symbols.display_name("gluon_tensor_to_gluon")
+        )
+        quark_vector_weyl_plus = TensorName(
+            symbols.display_name("quark_vector_weyl_plus")
+        )
+        quark_vector_weyl_minus = TensorName(
+            symbols.display_name("quark_vector_weyl_minus")
+        )
+
+        library.register(
+            Tensor.dense(
+                two_gluon_to_tensor(mink, mink, antisym),
+                _two_gluon_to_tensor_data(),
+            )
+        )
+        library.register(
+            Tensor.dense(
+                tensor_gluon_to_gluon(antisym, mink, mink),
+                _tensor_gluon_to_gluon_data(),
+            )
+        )
+        library.register(
+            Tensor.dense(
+                gluon_tensor_to_gluon(mink, antisym, mink),
+                _gluon_tensor_to_gluon_data(),
+            )
+        )
+        library.register(
+            Tensor.dense(
+                quark_vector_weyl_plus(weyl, mink, weyl),
+                _quark_vector_weyl_data(chirality=1),
+            )
+        )
+        library.register(
+            Tensor.dense(
+                quark_vector_weyl_minus(weyl, mink, weyl),
+                _quark_vector_weyl_data(chirality=-1),
+            )
+        )
+        return library
+
+    def vertex_lowering_rule(self, kind: int) -> VertexLoweringRule:
+        if kind == 0:
+            return VertexLoweringRule(
+                kind=kind,
+                backend="spenso",
+                tensor_names=("g", symbols.display_name("current_momentum")),
+                expression_head="three_gluon_current",
+                full_tensor_network_ready=True,
+                description="color-ordered three-gluon current",
+                kernel="three_vector_current",
+                input_roles=("vector", "vector"),
+                output_role="vector",
+                coupling_mode="fixed",
+            )
+        if kind == 1:
+            return VertexLoweringRule(
+                kind=kind,
+                backend="spenso",
+                tensor_names=(symbols.display_name("two_gluon_to_tensor"),),
+                expression_head=symbols.display_name("two_gluon_to_tensor"),
+                full_tensor_network_ready=True,
+                description="two gluons to auxiliary antisymmetric tensor",
+                kernel="two_vector_to_tensor",
+                input_roles=("vector", "vector"),
+                output_role="antisymmetric_tensor",
+                coupling_mode="fixed",
+            )
+        if kind == 2:
+            return VertexLoweringRule(
+                kind=kind,
+                backend="spenso",
+                tensor_names=(symbols.display_name("tensor_gluon_to_gluon"),),
+                expression_head=symbols.display_name("tensor_gluon_to_gluon"),
+                full_tensor_network_ready=True,
+                description="auxiliary tensor and gluon to gluon current",
+                kernel="tensor_vector_to_vector",
+                input_roles=("antisymmetric_tensor", "vector"),
+                output_role="vector",
+                coupling_mode="fixed",
+            )
+        if kind == 3:
+            return VertexLoweringRule(
+                kind=kind,
+                backend="spenso",
+                tensor_names=(symbols.display_name("gluon_tensor_to_gluon"),),
+                expression_head=symbols.display_name("gluon_tensor_to_gluon"),
+                full_tensor_network_ready=True,
+                description="gluon and auxiliary tensor to gluon current",
+                kernel="vector_tensor_to_vector",
+                input_roles=("vector", "antisymmetric_tensor"),
+                output_role="vector",
+                coupling_mode="fixed",
+            )
+        if kind == 6:
+            return VertexLoweringRule(
+                kind=kind,
+                backend="spenso",
+                tensor_names=(
+                    symbols.display_name("quark_vector_weyl_minus"),
+                    symbols.display_name("quark_vector_weyl_plus"),
+                ),
+                expression_head="quark_gluon_weyl_current",
+                full_tensor_network_ready=True,
+                description="Weyl quark-gluon current",
+                kernel="fermion_vector_to_fermion",
+                input_roles=("fermion", "vector"),
+                output_role="fermion",
+                coupling_mode="fixed",
+            )
+        if kind in {4, 5, 7, 9}:
+            qcd_role_map: dict[int, tuple[tuple[str, str], str, str]] = {
+                4: (("vector", "fermion"), "fermion", "vector-fermion current"),
+                5: (
+                    ("vector", "antifermion"),
+                    "antifermion",
+                    "vector-antifermion current",
+                ),
+                7: (
+                    ("antifermion", "vector"),
+                    "antifermion",
+                    "antifermion-vector current",
+                ),
+                9: (
+                    ("antifermion", "fermion"),
+                    "vector",
+                    "antifermion-fermion vector current",
+                ),
+            }
+            input_roles, output_role, description = qcd_role_map[kind]
+            return VertexLoweringRule(
+                kind=kind,
+                backend="symbolica",
+                expression_head="quark_gluon_weyl_current",
+                full_tensor_network_ready=True,
+                description=f"Weyl QCD {description}",
+                kernel=(
+                    "fermion_pair_to_vector"
+                    if kind == 9
+                    else "fermion_vector_to_fermion"
+                ),
+                input_roles=input_roles,
+                output_role=output_role,
+                coupling_mode="fixed",
+            )
+        if kind == 10:
+            return VertexLoweringRule(
+                kind=kind,
+                backend="spenso",
+                tensor_names=(
+                    symbols.display_name("quark_vector_weyl_minus"),
+                    symbols.display_name("quark_vector_weyl_plus"),
+                ),
+                expression_head="fermion_gauge_weyl_current",
+                full_tensor_network_ready=True,
+                description="Weyl fermion electroweak current with graph coupling",
+                kernel="fermion_vector_to_fermion",
+                input_roles=("fermion", "vector"),
+                output_role="fermion",
+                coupling_mode="vertex",
+            )
+        if kind in {11, 21, 22, 23, 24}:
+            fermion_gauge_role_map: dict[
+                int,
+                tuple[tuple[str, str], str, str, str],
+            ] = {
+                11: (
+                    ("antifermion", "vector"),
+                    "antifermion",
+                    "antifermion electroweak current",
+                    "fermion_vector_to_fermion",
+                ),
+                21: (
+                    ("fermion", "antifermion"),
+                    "vector",
+                    "lepton-antilepton electroweak current",
+                    "fermion_pair_to_vector",
+                ),
+                22: (
+                    ("antifermion", "fermion"),
+                    "vector",
+                    "antilepton-lepton electroweak current",
+                    "fermion_pair_to_vector",
+                ),
+                23: (
+                    ("vector", "fermion"),
+                    "fermion",
+                    "vector-fermion electroweak current",
+                    "fermion_vector_to_fermion",
+                ),
+                24: (
+                    ("vector", "antifermion"),
+                    "antifermion",
+                    "vector-antifermion electroweak current",
+                    "fermion_vector_to_fermion",
+                ),
+            }
+            input_roles, output_role, description, kernel = fermion_gauge_role_map[kind]
+            return VertexLoweringRule(
+                kind=kind,
+                backend="symbolica",
+                expression_head="fermion_gauge_weyl_current",
+                full_tensor_network_ready=True,
+                description=f"Weyl {description} with runtime coupling",
+                kernel=kernel,
+                input_roles=input_roles,
+                output_role=output_role,
+                coupling_mode="vertex",
+            )
+        if kind == 8:
+            return VertexLoweringRule(
+                kind=kind,
+                backend="symbolica",
+                expression_head="qcd_u1_subtraction_current",
+                full_tensor_network_ready=True,
+                description="QCD U(1) subtraction current",
+                kernel="fermion_pair_to_vector",
+                input_roles=("fermion", "antifermion"),
+                output_role="vector",
+                coupling_mode="vertex",
+            )
+        if kind in {12, 13, 14, 15}:
+            vector_role_map: dict[int, tuple[str, tuple[str, str], str, str]] = {
+                12: (
+                    "three_vector_current",
+                    ("vector", "vector"),
+                    "vector",
+                    "electroweak three-vector current",
+                ),
+                13: (
+                    "two_vector_to_tensor",
+                    ("vector", "vector"),
+                    "antisymmetric_tensor",
+                    "two electroweak vectors to auxiliary tensor",
+                ),
+                14: (
+                    "tensor_vector_to_vector",
+                    ("antisymmetric_tensor", "vector"),
+                    "vector",
+                    "auxiliary tensor and vector to electroweak vector",
+                ),
+                15: (
+                    "vector_tensor_to_vector",
+                    ("vector", "antisymmetric_tensor"),
+                    "vector",
+                    "electroweak vector and auxiliary tensor to vector",
+                ),
+            }
+            kernel, input_roles, output_role, description = vector_role_map[kind]
+            return VertexLoweringRule(
+                kind=kind,
+                backend="symbolica",
+                expression_head=kernel,
+                full_tensor_network_ready=True,
+                description=f"{description} with runtime coupling",
+                kernel=kernel,
+                input_roles=input_roles,
+                output_role=output_role,
+                coupling_mode="vertex",
+            )
+        if kind == 16:
+            return VertexLoweringRule(
+                kind=kind,
+                backend="symbolica",
+                expression_head="fermion_scalar_to_fermion",
+                description=("massive Dirac fermion-scalar Yukawa current"),
+                full_tensor_network_ready=True,
+                kernel="fermion_scalar_to_fermion",
+                input_roles=("fermion", "scalar"),
+                output_role="fermion",
+                coupling_mode="vertex",
+            )
+        if kind in {17, 18, 19, 20}:
+            scalar_role_map: dict[int, tuple[str, tuple[str, str], str, str]] = {
+                17: (
+                    "two_vector_to_scalar",
+                    ("vector", "vector"),
+                    "scalar",
+                    "two vectors to scalar current",
+                ),
+                18: (
+                    "scalar_vector_to_vector",
+                    ("scalar", "vector"),
+                    "vector",
+                    "scalar-vector to vector current",
+                ),
+                19: (
+                    "vector_scalar_to_vector",
+                    ("vector", "scalar"),
+                    "vector",
+                    "vector-scalar to vector current",
+                ),
+                20: (
+                    "two_scalar_to_scalar",
+                    ("scalar", "scalar"),
+                    "scalar",
+                    "scalar-scalar to scalar current",
+                ),
+            }
+            kernel, input_roles, output_role, description = scalar_role_map[kind]
+            return VertexLoweringRule(
+                kind=kind,
+                backend="symbolica",
+                expression_head=kernel,
+                full_tensor_network_ready=True,
+                description=f"{description} with runtime coupling",
+                kernel=kernel,
+                input_roles=input_roles,
+                output_role=output_role,
+                coupling_mode="vertex",
+            )
+        return VertexLoweringRule(
+            kind=kind,
+            backend="unimplemented",
+            description="no native pyamplicol lowering rule is registered yet",
+            kernel="unknown",
+        )
+
+    def vertex_evaluation_equivalence(
+        self,
+        kind: int,
+    ) -> VertexEvaluationEquivalence:
+        """Expose exact input-orientation identities of built-in kernels."""
+
+        antisymmetric_same_inputs = {
+            0: "three-vector-current",
+            1: "two-vector-to-tensor",
+        }
+        if kind in antisymmetric_same_inputs:
+            return VertexEvaluationEquivalence(
+                class_id=f"builtin-sm:{antisymmetric_same_inputs[kind]}",
+                input_exchange_factor=(-1.0, 0.0),
+            )
+
+        pure_gauge_orientations = {
+            2: ("tensor-vector-to-vector", (0, 1), (1.0, 0.0)),
+            3: ("tensor-vector-to-vector", (1, 0), (-1.0, 0.0)),
+        }
+        relation = pure_gauge_orientations.get(kind)
+        if relation is not None:
+            class_name, input_order, factor = relation
+            return VertexEvaluationEquivalence(
+                class_id=f"builtin-sm:{class_name}",
+                factor=factor,
+                input_order=input_order,
+            )
+
+        quark_gluon_orientations = {
+            4: ("quark-gluon-to-quark", (1, 0)),
+            6: ("quark-gluon-to-quark", (0, 1)),
+            5: ("antiquark-gluon-to-antiquark", (1, 0)),
+            7: ("antiquark-gluon-to-antiquark", (0, 1)),
+        }
+        relation = quark_gluon_orientations.get(kind)
+        if relation is not None:
+            class_name, input_order = relation
+            return VertexEvaluationEquivalence(
+                class_id=f"builtin-sm:{class_name}",
+                input_order=input_order,
+            )
+
+        fermion_gauge_orientations = {
+            10: ("fermion-vector-to-fermion", (0, 1)),
+            23: ("fermion-vector-to-fermion", (1, 0)),
+            11: ("antifermion-vector-to-antifermion", (0, 1)),
+            24: ("antifermion-vector-to-antifermion", (1, 0)),
+        }
+        relation = fermion_gauge_orientations.get(kind)
+        if relation is not None:
+            class_name, input_order = relation
+            return VertexEvaluationEquivalence(
+                class_id=f"builtin-sm:{class_name}",
+                input_order=input_order,
+            )
+
+        fermion_pair_orientations = {
+            21: (0, 1),
+            22: (1, 0),
+        }
+        input_order = fermion_pair_orientations.get(kind)
+        if input_order is not None:
+            return VertexEvaluationEquivalence(
+                class_id="builtin-sm:fermion-pair-to-vector",
+                input_order=input_order,
+            )
+
+        scalar_vector_orientations = {
+            18: (0, 1),
+            19: (1, 0),
+        }
+        input_order = scalar_vector_orientations.get(kind)
+        if input_order is not None:
+            return VertexEvaluationEquivalence(
+                class_id="builtin-sm:scalar-vector-to-vector",
+                input_order=input_order,
+            )
+
+        return super().vertex_evaluation_equivalence(kind)
+
+    def vertex_component_expression(
+        self,
+        kind: int,
+        left: Sequence[Any],
+        right: Sequence[Any],
+        *,
+        result_particle_id: int,
+        result_chirality: int,
+        left_chirality: int = 0,
+        right_chirality: int = 0,
+        coupling: tuple[Any, Any] = (1.0, 0.0),
+        left_momentum: Sequence[Any] | None = None,
+        right_momentum: Sequence[Any] | None = None,
+    ) -> tuple[Any, ...]:
+        """Lower a local model vertex into component expressions.
+
+        The inputs are already component tuples for the two parent currents.
+        This method is intentionally process-blind: all decisions are local to
+        the vertex kind, chirality labels, particle id, coupling, and optional
+        current momenta.
+        """
+
+        if kind == 0:
+            if left_momentum is None or right_momentum is None:
+                raise ValueError("three-vector current requires parent momenta")
+            return _expr_three_vector_current(
+                tuple(left),
+                tuple(left_momentum),
+                tuple(right),
+                tuple(right_momentum),
+            )
+        if kind == 1:
+            return _expr_two_vector_to_tensor(tuple(left), tuple(right))
+        if kind == 2:
+            return _expr_tensor_vector_to_vector(tuple(left), tuple(right))
+        if kind == 3:
+            return _expr_vector_tensor_to_vector(tuple(left), tuple(right))
+        if kind == 12:
+            if left_momentum is None or right_momentum is None:
+                raise ValueError("three-vector current requires parent momenta")
+            return _expr_three_vector_current_coupled(
+                tuple(left),
+                tuple(left_momentum),
+                tuple(right),
+                tuple(right_momentum),
+                coupling,
+            )
+        if kind == 13:
+            return tuple(
+                coupling[0] * component
+                for component in _expr_two_vector_to_tensor(tuple(left), tuple(right))
+            )
+        if kind == 14:
+            return tuple(
+                coupling[0] * component
+                for component in _expr_tensor_vector_to_vector(
+                    tuple(left),
+                    tuple(right),
+                )
+            )
+        if kind == 15:
+            return tuple(
+                coupling[0] * component
+                for component in _expr_vector_tensor_to_vector(
+                    tuple(left),
+                    tuple(right),
+                )
+            )
+        if kind == 16:
+            return _expr_fermion_scalar_to_fermion(
+                tuple(left),
+                tuple(right),
+                coupling,
+            )
+        if kind == 17:
+            return (
+                _imaginary_inverse_sqrt_two(*left, *right, *coupling)
+                * coupling[0]
+                * _expr_minkowski_dot(tuple(left), tuple(right)),
+            )
+        if kind == 18:
+            prefactor = _imaginary_inverse_sqrt_two(*left, *right, *coupling)
+            return tuple(
+                prefactor * coupling[0] * left[0] * component
+                for component in tuple(right)
+            )
+        if kind == 19:
+            prefactor = _imaginary_inverse_sqrt_two(*left, *right, *coupling)
+            return tuple(
+                prefactor * coupling[0] * right[0] * component
+                for component in tuple(left)
+            )
+        if kind == 20:
+            phase = 1j if coupling[1] == -10.0 else 1.0
+            prefactor = _imaginary_inverse_sqrt_two(*left, *right, *coupling)
+            return (prefactor * phase * coupling[0] * left[0] * right[0],)
+        if kind in {4, 6}:
+            fermion, vector = (
+                (tuple(right), tuple(left))
+                if kind == 4
+                else (tuple(left), tuple(right))
+            )
+            if len(fermion) == 4:
+                return _expr_fermion_vector_dirac(
+                    fermion,
+                    vector,
+                    antifermion=False,
+                    coupling=None,
+                )
+            return _expr_fermion_vector_weyl(
+                fermion,
+                vector,
+                result_chirality,
+                antifermion=False,
+                coupling=None,
+            )
+        if kind in {5, 7}:
+            antifermion, vector = (
+                (tuple(right), tuple(left))
+                if kind == 5
+                else (tuple(left), tuple(right))
+            )
+            if len(antifermion) == 4:
+                return _expr_fermion_vector_dirac(
+                    antifermion,
+                    vector,
+                    antifermion=True,
+                    coupling=None,
+                )
+            return _expr_fermion_vector_weyl(
+                antifermion,
+                vector,
+                result_chirality,
+                antifermion=True,
+                coupling=None,
+            )
+        if kind == 9:
+            fermion = tuple(right)
+            antifermion = tuple(left)
+            if len(fermion) == 4 or len(antifermion) == 4:
+                return _expr_fermion_antifermion_to_vector_dirac(
+                    fermion=_as_dirac_current(fermion, right_chirality),
+                    antifermion=_as_dirac_current(antifermion, left_chirality),
+                    coupling=(1.0, 1.0),
+                )
+            return _expr_fermion_antifermion_to_vector_weyl(
+                fermion=fermion,
+                antifermion=antifermion,
+                coupling=(1.0, 1.0),
+                fermion_chirality=right_chirality,
+                antifermion_chirality=left_chirality,
+            )
+        if kind == 8:
+            qcd_coupling = (coupling[0], coupling[0])
+            fermion = tuple(left)
+            antifermion = tuple(right)
+            if len(fermion) == 4 or len(antifermion) == 4:
+                return _expr_fermion_antifermion_to_vector_dirac(
+                    fermion=_as_dirac_current(fermion, left_chirality),
+                    antifermion=_as_dirac_current(antifermion, right_chirality),
+                    coupling=qcd_coupling,
+                )
+            return _expr_fermion_antifermion_to_vector_weyl(
+                fermion=fermion,
+                antifermion=antifermion,
+                coupling=qcd_coupling,
+                fermion_chirality=left_chirality,
+                antifermion_chirality=right_chirality,
+            )
+        if kind in {10, 23}:
+            fermion, vector = (
+                (tuple(left), tuple(right))
+                if kind == 10
+                else (tuple(right), tuple(left))
+            )
+            input_chirality = left_chirality if kind == 10 else right_chirality
+            if len(fermion) == 4:
+                return _expr_fermion_vector_dirac(
+                    fermion,
+                    vector,
+                    antifermion=False,
+                    coupling=coupling,
+                )
+            current = _expr_fermion_vector_weyl(
+                fermion,
+                vector,
+                input_chirality,
+                antifermion=False,
+                coupling=coupling,
+            )
+            if self.current_dimension(result_particle_id, result_chirality) == 4:
+                return _embed_weyl_current_in_dirac(current, input_chirality)
+            return current
+        if kind in {11, 24}:
+            antifermion, vector = (
+                (tuple(left), tuple(right))
+                if kind == 11
+                else (tuple(right), tuple(left))
+            )
+            input_chirality = left_chirality if kind == 11 else right_chirality
+            if len(antifermion) == 4:
+                return _expr_fermion_vector_dirac(
+                    antifermion,
+                    vector,
+                    antifermion=True,
+                    coupling=coupling,
+                )
+            current = _expr_fermion_vector_weyl(
+                antifermion,
+                vector,
+                input_chirality,
+                antifermion=True,
+                coupling=coupling,
+            )
+            if self.current_dimension(result_particle_id, result_chirality) == 4:
+                return _embed_weyl_current_in_dirac(current, input_chirality)
+            return current
+        if kind == 21:
+            fermion = tuple(left)
+            antifermion = tuple(right)
+            if len(fermion) == 4 or len(antifermion) == 4:
+                return _expr_fermion_antifermion_to_vector_dirac(
+                    fermion=_as_dirac_current(fermion, left_chirality),
+                    antifermion=_as_dirac_current(antifermion, right_chirality),
+                    coupling=coupling,
+                )
+            return _expr_fermion_antifermion_to_vector_weyl(
+                fermion=fermion,
+                antifermion=antifermion,
+                coupling=coupling,
+                fermion_chirality=left_chirality,
+                antifermion_chirality=right_chirality,
+            )
+        if kind == 22:
+            fermion = tuple(right)
+            antifermion = tuple(left)
+            if len(fermion) == 4 or len(antifermion) == 4:
+                return _expr_fermion_antifermion_to_vector_dirac(
+                    fermion=_as_dirac_current(fermion, right_chirality),
+                    antifermion=_as_dirac_current(antifermion, left_chirality),
+                    coupling=coupling,
+                )
+            return _expr_fermion_antifermion_to_vector_weyl(
+                fermion=fermion,
+                antifermion=antifermion,
+                coupling=coupling,
+                fermion_chirality=right_chirality,
+                antifermion_chirality=left_chirality,
+            )
+        raise ValueError(f"vertex kind {kind} has no component expression lowering")
+
+    def propagator_component_expression(
+        self,
+        particle_id: int,
+        value: Sequence[Any],
+        momentum: Sequence[Any],
+        *,
+        chirality: int = 0,
+        propagator: PropagatorIR | None = None,
+    ) -> tuple[Any, ...]:
+        metadata = propagator or self._propagator_ir(particle_id, chirality)
+        if metadata.identity.canonical_id != self._particle_identity_ir(
+            particle_id
+        ).canonical_id or metadata.chirality != int(chirality):
+            raise ValueError("propagator metadata does not match the current")
+        components = tuple(value)
+        current_momentum = tuple(momentum)
+        if not metadata.applies_propagator:
+            return components
+        if metadata.kind == "vector" and metadata.gauge == "feynman":
+            denominator = _minkowski_square_expression(current_momentum)
+            prefactor = -1j / denominator
+            return tuple(component * prefactor for component in components)
+        if metadata.kind == "vector" and metadata.gauge == "unitary":
+            mass = self.mass(particle_id)
+            width = self.width(particle_id)
+            denominator = (
+                _minkowski_square_expression(current_momentum)
+                - mass * mass
+                + 1j * mass * width
+            )
+            prefactor = -1j / denominator
+            longitudinal = _expr_minkowski_dot(components, current_momentum) / (
+                mass * mass
+            )
+            return tuple(
+                (components[index] - current_momentum[index] * longitudinal) * prefactor
+                for index in range(4)
+            )
+        if metadata.kind == "weyl-fermion":
+            if metadata.identity.orientation == "antiparticle":
+                return _expr_antifermion_propagator_weyl(
+                    components,
+                    current_momentum,
+                    chirality,
+                )
+            return _expr_fermion_propagator_weyl(
+                components,
+                current_momentum,
+                chirality,
+            )
+        if metadata.kind == "dirac-fermion":
+            if metadata.identity.orientation == "antiparticle":
+                return _expr_antifermion_propagator_dirac(
+                    components,
+                    current_momentum,
+                    self.mass(particle_id),
+                    self.width(particle_id),
+                )
+            return _expr_fermion_propagator_dirac(
+                components,
+                current_momentum,
+                self.mass(particle_id),
+                self.width(particle_id),
+            )
+        if metadata.kind == "scalar":
+            mass = self.mass(particle_id)
+            width = self.width(particle_id)
+            denominator = (
+                _minkowski_square_expression(current_momentum)
+                - mass * mass
+                + 1j * mass * width
+            )
+            prefactor = 1j / denominator
+            return tuple(component * prefactor for component in components)
+        raise ValueError(
+            f"propagator kind {metadata.kind!r} in gauge {metadata.gauge!r} "
+            f"is not lowered for particle "
+            f"{particle_id}"
+        )
+
+    def three_gluon_current_expression(
+        self,
+        *,
+        left_slot: Any,
+        right_slot: Any,
+        output_slot: Any,
+        left_momentum_tensor_name: str,
+        right_momentum_tensor_name: str,
+        dummy_prefix: str,
+    ) -> Any:
+        from symbolica import Expression
+        from symbolica.community.tensor import Representation, TensorName
+
+        mink = Representation.mink(4)
+        metric = TensorName.g()
+        left_momentum = TensorName(left_momentum_tensor_name)
+        right_momentum = TensorName(right_momentum_tensor_name)
+        left_dot_slot = mink(f"{dummy_prefix}_left_dot")
+        right_dot_slot = mink(f"{dummy_prefix}_right_dot")
+        prefactor = _exact_imaginary_inverse_sqrt_two()
+
+        return prefactor * (
+            metric(left_slot, right_slot).to_expression()
+            * (
+                left_momentum(output_slot).to_expression()
+                - right_momentum(output_slot).to_expression()
+            )
+            + Expression.num(2.0)
+            * (
+                metric(left_slot, left_dot_slot).to_expression()
+                * right_momentum(left_dot_slot).to_expression()
+                * metric(right_slot, output_slot).to_expression()
+                - metric(right_slot, right_dot_slot).to_expression()
+                * left_momentum(right_dot_slot).to_expression()
+                * metric(left_slot, output_slot).to_expression()
+            )
+        )
+
+    def gluon_propagator_tensor_data(
+        self,
+        momentum: Sequence[Any],
+    ) -> list[Any]:
+        prefactor = _number(-1j) / _minkowski_square_expression(momentum)
+        metric = (1.0, -1.0, -1.0, -1.0)
+        data = [_number(0.0)] * (4 * 4)
+        for index, sign in enumerate(metric):
+            data[_flat_index((index, index), (4, 4))] = _number(sign) * prefactor
+        return data
+
+    def quark_weyl_propagator_tensor_data(
+        self,
+        momentum: Sequence[Any],
+        *,
+        chirality: int,
+    ) -> list[Any]:
+        prefactor = _number(1j) / _minkowski_square_expression(momentum)
+        p0, p1, p2, p3 = (_as_expression(value) for value in momentum)
+        data = [_number(0.0)] * (2 * 2)
+
+        def set_entry(q_in: int, q_out: int, value: Any) -> None:
+            data[_flat_index((q_in, q_out), (2, 2))] = prefactor * value
+
+        if chirality == 1:
+            set_entry(0, 0, p0 + p3)
+            set_entry(1, 0, p1 + _number(1j) * p2)
+            set_entry(0, 1, p1 - _number(1j) * p2)
+            set_entry(1, 1, p0 - p3)
+            return data
+        if chirality == -1:
+            set_entry(0, 0, p0 - p3)
+            set_entry(1, 0, -(p1 + _number(1j) * p2))
+            set_entry(0, 1, -(p1 - _number(1j) * p2))
+            set_entry(1, 1, p0 + p3)
+            return data
+        raise ValueError(f"unsupported Weyl chirality: {chirality}")
diff --git a/pyamplicol/src/pyamplicol/models/builtin/lowering_reports.py b/pyamplicol/src/pyamplicol/models/builtin/lowering_reports.py
new file mode 100644
index 0000000000..4d22d03465
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/lowering_reports.py
@@ -0,0 +1,386 @@
+# SPDX-License-Identifier: 0BSD
+"""Built-in-model diagnostics for symbolic recursion lowering."""
+
+from __future__ import annotations
+
+import time
+from collections import Counter
+from typing import Any
+
+from .lowering_tensor import (
+    _build_auxiliary_tensor_probe,
+    _build_color_probe,
+    _clean_symbolica_string,
+    _current_dimension,
+    _current_momentum_currents,
+    _GraphTensorExpressionBuilder,
+    _preview_expression,
+    _propagator_lowering_ready,
+    _register_parametric_current_momenta,
+    _register_parametric_source_currents,
+    _source_current_count,
+    _source_currents,
+)
+from .lowering_types import (
+    RecursionLoweringPlan,
+    SymbolicLoweringReport,
+    TensorNetworkBlueprint,
+    VertexLoweringReport,
+    VertexLoweringStep,
+)
+from .model import BuiltinSMModel
+from .symbols import symbols
+
+_MAX_RECURSION_EXPRESSION_PREVIEW = 4096
+
+
+def build_symbolic_lowering_report(
+    model: BuiltinSMModel,
+    graph: Any | None = None,
+) -> SymbolicLoweringReport:
+    """Exercise the real Symbolica tensor hooks used by ME lowering.
+
+    This is intentionally a small, deterministic probe: it validates that the
+    model-owned auxiliary four-gluon tensors are registered in spenso and that
+    symbolic color simplification is available. It is not the full ME evaluator.
+    """
+
+    tensor_probe = _build_auxiliary_tensor_probe(model)
+    color_probe = _build_color_probe()
+    recursion_plan = None if graph is None else _build_recursion_plan(graph)
+    vertex_lowering = (
+        None if graph is None else _build_vertex_lowering_report(model, graph)
+    )
+    tensor_network_blueprint = (
+        None if graph is None else _build_tensor_network_blueprint(model, graph)
+    )
+    full_me_tensor_network_ready = (
+        tensor_network_blueprint.full_me_tensor_network_ready
+        if tensor_network_blueprint is not None
+        else False
+    )
+    return SymbolicLoweringReport(
+        tensor_library="TensorLibrary.hep_lib_atom",
+        tensor_network_probe=tensor_probe,
+        color_algebra_probe=color_probe,
+        recursion_plan=recursion_plan,
+        vertex_lowering=vertex_lowering,
+        tensor_network_blueprint=tensor_network_blueprint,
+        full_me_tensor_network_ready=full_me_tensor_network_ready,
+    )
+
+
+def _build_recursion_plan(graph: Any) -> RecursionLoweringPlan:
+    assignments = tuple(
+        _interaction_assignment(interaction) for interaction in graph.interactions
+    )
+    amplitudes = tuple(
+        symbols.amplitude(
+            _current_atom(left),
+            _current_atom(right),
+        )
+        for left, right in graph.amplitudes
+    )
+    assignment_sum = _sum_expressions(assignments)
+    amplitude_sum = _sum_expressions(amplitudes)
+    plan_expression = symbols.matrix_element_plan(assignment_sum, amplitude_sum)
+    vertex_kind_counts = Counter(
+        int(interaction.vertex_kind) for interaction in graph.interactions
+    )
+    expression = _clean_symbolica_string(str(plan_expression))
+    tensor_route_vertex_kinds = tuple(
+        kind for kind in (1, 2, 3) if vertex_kind_counts.get(kind, 0) > 0
+    )
+    first_assignments = tuple(
+        _clean_symbolica_string(str(assignment)) for assignment in assignments[:5]
+    )
+    return RecursionLoweringPlan(
+        engine="symbolica",
+        current_count=len(graph.currents),
+        interaction_count=len(graph.interactions),
+        amplitude_count=len(graph.amplitudes),
+        source_current_count=_source_current_count(graph),
+        vertex_kind_counts=tuple(sorted(vertex_kind_counts.items())),
+        tensor_route_vertex_kinds=tensor_route_vertex_kinds,
+        color_order=tuple(int(index) for index in graph.color_order),
+        expression=_preview_expression(expression),
+        expression_length=len(expression),
+        expression_truncated=len(expression) > _MAX_RECURSION_EXPRESSION_PREVIEW,
+        first_assignments=first_assignments,
+    )
+
+
+def _interaction_assignment(interaction: Any) -> Any:
+    return symbols.assignment(
+        _current_atom(interaction.result),
+        symbols.vertex(
+            int(interaction.vertex_kind),
+            _current_atom(interaction.left),
+            _current_atom(interaction.right),
+            _number(interaction.coupling[0]),
+            _number(interaction.coupling[1]),
+        ),
+    )
+
+
+def _current_atom(current: Any) -> Any:
+    return symbols.current(
+        int(current.pdg),
+        _label_atom(tuple(int(label) for label in current.external_labels)),
+        int(current.chirality),
+    )
+
+
+def _label_atom(labels: tuple[int, ...]) -> Any:
+    return symbols.label(labels)
+
+
+def _number(value: float) -> Any:
+    from symbolica import Expression
+
+    return Expression.num(value)
+
+
+def _sum_expressions(expressions: tuple[Any, ...]) -> Any:
+    from symbolica import Expression
+
+    total = Expression.num(0)
+    for expression in expressions:
+        total = total + expression
+    return total
+
+
+def _current_key_tuple(current: Any) -> tuple[int, tuple[int, ...], int]:
+    return (
+        int(current.pdg),
+        tuple(int(label) for label in current.external_labels),
+        int(current.chirality),
+    )
+
+
+def _build_vertex_lowering_report(
+    model: BuiltinSMModel,
+    graph: Any,
+) -> VertexLoweringReport:
+    steps = tuple(
+        _vertex_lowering_step(model, index, interaction)
+        for index, interaction in enumerate(graph.interactions, start=1)
+    )
+    backend_counts = Counter(step.backend for step in steps)
+    ready_kind_counts = Counter(
+        step.vertex_kind for step in steps if step.full_tensor_network_ready
+    )
+    pending_kind_counts = Counter(
+        step.vertex_kind for step in steps if not step.full_tensor_network_ready
+    )
+    tensor_names = tuple(
+        sorted({tensor_name for step in steps for tensor_name in step.tensor_names})
+    )
+    return VertexLoweringReport(
+        total_interactions=len(steps),
+        full_tensor_network_ready=bool(steps)
+        and all(step.full_tensor_network_ready for step in steps),
+        backend_counts=tuple(sorted(backend_counts.items())),
+        ready_vertex_kind_counts=tuple(sorted(ready_kind_counts.items())),
+        pending_vertex_kind_counts=tuple(sorted(pending_kind_counts.items())),
+        tensor_names=tensor_names,
+        first_steps=steps[:8],
+    )
+
+
+def _vertex_lowering_step(
+    model: BuiltinSMModel,
+    index: int,
+    interaction: Any,
+) -> VertexLoweringStep:
+    rule = model.vertex_lowering_rule(int(interaction.vertex_kind))
+    return VertexLoweringStep(
+        index=index,
+        vertex_kind=int(interaction.vertex_kind),
+        backend=rule.backend,
+        tensor_names=rule.tensor_names,
+        expression_head=rule.expression_head,
+        full_tensor_network_ready=rule.full_tensor_network_ready,
+        result_current=_clean_symbolica_string(str(_current_atom(interaction.result))),
+        left_current=_clean_symbolica_string(str(_current_atom(interaction.left))),
+        right_current=_clean_symbolica_string(str(_current_atom(interaction.right))),
+    )
+
+
+def _build_tensor_network_blueprint(
+    model: BuiltinSMModel,
+    graph: Any,
+) -> TensorNetworkBlueprint:
+    from symbolica.community.tensor import TensorNetwork, as_tensor
+
+    max_interactions_to_build = 96
+    max_interactions_to_execute = 40
+    vertex_lowering = _build_vertex_lowering_report(model, graph)
+    ready_interactions = sum(
+        count for _, count in vertex_lowering.ready_vertex_kind_counts
+    )
+    pending_interactions = sum(
+        count for _, count in vertex_lowering.pending_vertex_kind_counts
+    )
+    placeholder_vertex_kinds = tuple(
+        kind for kind, _ in vertex_lowering.pending_vertex_kind_counts
+    )
+    registered_tensor_names = vertex_lowering.tensor_names
+    source_currents = _source_currents(graph)
+    momentum_currents = _current_momentum_currents(graph)
+    current_leaf_count = len(source_currents)
+    source_parameter_count = sum(
+        _current_dimension(current) for current in source_currents
+    )
+    momentum_parameter_count = 4 * len(momentum_currents)
+    parametric_parameter_count = source_parameter_count + momentum_parameter_count
+    propagator_ready = _propagator_lowering_ready(graph)
+    full_ready = vertex_lowering.full_tensor_network_ready and propagator_ready
+
+    if len(graph.interactions) > max_interactions_to_build:
+        return TensorNetworkBlueprint(
+            engine="spenso",
+            status="size-guarded",
+            current_count=len(graph.currents),
+            interaction_count=len(graph.interactions),
+            amplitude_count=len(graph.amplitudes),
+            expression_built=False,
+            expression_executed=False,
+            full_me_tensor_network_ready=False,
+            propagator_lowering_ready=propagator_ready,
+            ready_interactions=ready_interactions,
+            pending_interactions=pending_interactions,
+            placeholder_vertex_kinds=placeholder_vertex_kinds,
+            registered_tensor_names=registered_tensor_names,
+            current_leaf_count=current_leaf_count,
+            parametric_external_current_count=current_leaf_count,
+            parametric_source_current_parameter_count=source_parameter_count,
+            parametric_current_momentum_count=len(momentum_currents),
+            parametric_momentum_parameter_count=momentum_parameter_count,
+            parametric_parameter_count=parametric_parameter_count,
+            expression=None,
+            expression_length=None,
+            expression_truncated=None,
+            executed_expression=None,
+            executed_expression_length=None,
+            executed_expression_truncated=None,
+            execution_time_s=None,
+        )
+
+    try:
+        builder = _GraphTensorExpressionBuilder(model, graph)
+        raw_expression = builder.matrix_element_skeleton()
+        expression = (
+            as_tensor(raw_expression)
+            .simplify_algebra(
+                gamma=False,
+                color=True,
+                contract="none",
+                color_substitute_cof_dimension_invariants=True,
+            )
+            .to_expression()
+        )
+        expression_text = _clean_symbolica_string(str(expression))
+        if len(graph.interactions) > max_interactions_to_execute:
+            return TensorNetworkBlueprint(
+                engine="spenso",
+                status="execution-size-guarded",
+                current_count=len(graph.currents),
+                interaction_count=len(graph.interactions),
+                amplitude_count=len(graph.amplitudes),
+                expression_built=True,
+                expression_executed=False,
+                full_me_tensor_network_ready=False,
+                propagator_lowering_ready=propagator_ready,
+                ready_interactions=ready_interactions,
+                pending_interactions=pending_interactions,
+                placeholder_vertex_kinds=placeholder_vertex_kinds,
+                registered_tensor_names=registered_tensor_names,
+                current_leaf_count=current_leaf_count,
+                parametric_external_current_count=current_leaf_count,
+                parametric_source_current_parameter_count=source_parameter_count,
+                parametric_current_momentum_count=len(momentum_currents),
+                parametric_momentum_parameter_count=momentum_parameter_count,
+                parametric_parameter_count=parametric_parameter_count,
+                expression=_preview_expression(expression_text),
+                expression_length=len(expression_text),
+                expression_truncated=(
+                    len(expression_text) > _MAX_RECURSION_EXPRESSION_PREVIEW
+                ),
+                executed_expression=None,
+                executed_expression_length=None,
+                executed_expression_truncated=None,
+                execution_time_s=None,
+            )
+
+        start = time.perf_counter()
+        library = model.build_tensor_library()
+        _register_parametric_source_currents(library, graph)
+        _register_parametric_current_momenta(model, library, graph)
+        network = TensorNetwork(expression, library)
+        network.execute(library=library)
+        scalar = network.result_scalar()
+        execution_time_s = time.perf_counter() - start
+        executed_text = _clean_symbolica_string(str(scalar))
+        dangling = as_tensor(scalar).list_dangling()
+        status = "scalar-skeleton" if not dangling else "dangling-indices"
+    except (RuntimeError, TypeError, ValueError) as exc:
+        return TensorNetworkBlueprint(
+            engine="spenso",
+            status=f"failed: {exc}",
+            current_count=len(graph.currents),
+            interaction_count=len(graph.interactions),
+            amplitude_count=len(graph.amplitudes),
+            expression_built=False,
+            expression_executed=False,
+            full_me_tensor_network_ready=False,
+            propagator_lowering_ready=propagator_ready,
+            ready_interactions=ready_interactions,
+            pending_interactions=pending_interactions,
+            placeholder_vertex_kinds=placeholder_vertex_kinds,
+            registered_tensor_names=registered_tensor_names,
+            current_leaf_count=current_leaf_count,
+            parametric_external_current_count=current_leaf_count,
+            parametric_source_current_parameter_count=source_parameter_count,
+            parametric_current_momentum_count=len(momentum_currents),
+            parametric_momentum_parameter_count=momentum_parameter_count,
+            parametric_parameter_count=parametric_parameter_count,
+            expression=None,
+            expression_length=None,
+            expression_truncated=None,
+            executed_expression=None,
+            executed_expression_length=None,
+            executed_expression_truncated=None,
+            execution_time_s=None,
+        )
+
+    return TensorNetworkBlueprint(
+        engine="spenso",
+        status=status,
+        current_count=len(graph.currents),
+        interaction_count=len(graph.interactions),
+        amplitude_count=len(graph.amplitudes),
+        expression_built=True,
+        expression_executed=True,
+        full_me_tensor_network_ready=full_ready,
+        propagator_lowering_ready=propagator_ready,
+        ready_interactions=ready_interactions,
+        pending_interactions=pending_interactions,
+        placeholder_vertex_kinds=placeholder_vertex_kinds,
+        registered_tensor_names=registered_tensor_names,
+        current_leaf_count=current_leaf_count,
+        parametric_external_current_count=current_leaf_count,
+        parametric_source_current_parameter_count=source_parameter_count,
+        parametric_current_momentum_count=len(momentum_currents),
+        parametric_momentum_parameter_count=momentum_parameter_count,
+        parametric_parameter_count=parametric_parameter_count,
+        expression=_preview_expression(expression_text),
+        expression_length=len(expression_text),
+        expression_truncated=len(expression_text) > _MAX_RECURSION_EXPRESSION_PREVIEW,
+        executed_expression=_preview_expression(executed_text),
+        executed_expression_length=len(executed_text),
+        executed_expression_truncated=(
+            len(executed_text) > _MAX_RECURSION_EXPRESSION_PREVIEW
+        ),
+        execution_time_s=execution_time_s,
+    )
diff --git a/pyamplicol/src/pyamplicol/models/builtin/lowering_shared.py b/pyamplicol/src/pyamplicol/models/builtin/lowering_shared.py
new file mode 100644
index 0000000000..9be5706a8a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/lowering_shared.py
@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: 0BSD
+"""Small expression helpers shared by built-in-SM lowering phases."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def _number(value: float) -> Any:
+    from symbolica import Expression
+
+    return Expression.num(value)
+
+
+def _current_key_tuple(current: Any) -> tuple[int, tuple[int, ...], int]:
+    return (
+        int(current.pdg),
+        tuple(int(label) for label in current.external_labels),
+        int(current.chirality),
+    )
diff --git a/pyamplicol/src/pyamplicol/models/builtin/lowering_tensor.py b/pyamplicol/src/pyamplicol/models/builtin/lowering_tensor.py
new file mode 100644
index 0000000000..7285b14e43
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/lowering_tensor.py
@@ -0,0 +1,911 @@
+# SPDX-License-Identifier: 0BSD
+"""Built-in-model tensor-network expression construction and Symbolica probes."""
+
+from __future__ import annotations
+
+import re
+import time
+from typing import Any
+
+from ..._internal.physics.parameters import ParamBuilder, SymbolicaEvaluatorBundle
+from .lowering_shared import _current_key_tuple, _number
+from .lowering_types import ColorAlgebraProbe, TensorNetworkProbe
+from .model import BuiltinSMModel
+from .symbols import symbols
+
+_MAX_RECURSION_EXPRESSION_PREVIEW = 4096
+
+
+def build_tensor_network_scalar_bundle(
+    model: BuiltinSMModel,
+    graph: Any,
+    *,
+    name: str,
+    collect_expression_metadata: bool = False,
+) -> SymbolicaEvaluatorBundle:
+    """Build a Symbolica evaluator bundle from the propagated tensor network."""
+
+    from symbolica.community.tensor import TensorNetwork, as_tensor
+
+    total_start = time.perf_counter()
+    library = model.build_tensor_library()
+    param_builder = ParamBuilder()
+    _register_parametric_source_currents(library, graph, param_builder)
+    _register_parametric_current_momenta(model, library, graph, param_builder)
+    raw_expression = _GraphTensorExpressionBuilder(
+        model, graph
+    ).matrix_element_skeleton()
+    expression = as_tensor(raw_expression).simplify_algebra(
+        gamma=False,
+        contract="none",
+        color_substitute_cof_dimension_invariants=True,
+    )
+    network = TensorNetwork(expression, library)
+    reduction_start = time.perf_counter()
+    network.execute(library=library)
+    scalar = network.result_scalar()
+    reduction_time_s = time.perf_counter() - reduction_start
+    evaluator_start = time.perf_counter()
+    evaluator = scalar.evaluator(param_builder.parameter_symbols())
+    if param_builder.real_valued_inputs:
+        evaluator.set_real_params(param_builder.real_valued_inputs)
+    evaluator_build_time_s = time.perf_counter() - evaluator_start
+    total_build_time_s = time.perf_counter() - total_start
+    expression_length = None
+    executed_expression_length = None
+    if collect_expression_metadata:
+        expression_length = len(_clean_symbolica_string(str(expression)))
+        executed_expression_length = len(_clean_symbolica_string(str(scalar)))
+    return SymbolicaEvaluatorBundle(
+        name=name,
+        evaluator=evaluator,
+        param_builder=param_builder,
+        complex_inputs=True,
+        metadata={
+            "engine": "symbolica",
+            "kernel": "tensor-network-scalar",
+            "current_count": len(graph.currents),
+            "interaction_count": len(graph.interactions),
+            "amplitude_count": len(graph.amplitudes),
+            "expression_length": expression_length,
+            "executed_expression_length": executed_expression_length,
+            "expression_metadata_collected": collect_expression_metadata,
+            "tensor_network_reduction_s": reduction_time_s,
+            "symbolica_evaluator_build_s": evaluator_build_time_s,
+            "total_build_s": total_build_time_s,
+        },
+    )
+
+
+def build_interleaved_tensor_network_scalar_bundle(
+    model: BuiltinSMModel,
+    graph: Any,
+    *,
+    name: str,
+    collect_expression_metadata: bool = False,
+) -> SymbolicaEvaluatorBundle:
+    """Build a Symbolica evaluator by executing one aggregate TensorNetwork in steps."""
+
+    total_start = time.perf_counter()
+    library = model.build_tensor_library()
+    param_builder = ParamBuilder()
+    _register_parametric_source_currents(library, graph, param_builder)
+    _register_parametric_current_momenta(model, library, graph, param_builder)
+
+    build_start = time.perf_counter()
+    builder = _GraphTensorExpressionBuilder(model, graph)
+    network, interleaved_metadata = builder.matrix_element_interleaved_network(
+        library,
+        execute_between=True,
+    )
+    network_build_s = time.perf_counter() - build_start
+
+    final_start = time.perf_counter()
+    network.execute(library=library)
+    scalar = network.result_scalar()
+    final_reduction_s = time.perf_counter() - final_start
+
+    evaluator_start = time.perf_counter()
+    evaluator = scalar.evaluator(param_builder.parameter_symbols())
+    if param_builder.real_valued_inputs:
+        evaluator.set_real_params(param_builder.real_valued_inputs)
+    evaluator_build_time_s = time.perf_counter() - evaluator_start
+    total_build_time_s = time.perf_counter() - total_start
+    return SymbolicaEvaluatorBundle(
+        name=name,
+        evaluator=evaluator,
+        param_builder=param_builder,
+        complex_inputs=True,
+        metadata={
+            "engine": "symbolica",
+            "kernel": "interleaved-tensor-network-scalar",
+            "strategy": "interleaved",
+            "current_count": len(graph.currents),
+            "interaction_count": len(graph.interactions),
+            "amplitude_count": len(graph.amplitudes),
+            "network_build_s": network_build_s,
+            "interleaved_execution_s": interleaved_metadata["execution_s"],
+            "interleaved_execution_count": interleaved_metadata["execution_count"],
+            "interleaved_multiplication_count": interleaved_metadata[
+                "multiplication_count"
+            ],
+            "interleaved_addition_count": interleaved_metadata["addition_count"],
+            "tensor_network_reduction_s": final_reduction_s,
+            "symbolica_evaluator_build_s": evaluator_build_time_s,
+            "total_build_s": total_build_time_s,
+            "executed_expression_length": (
+                len(_clean_symbolica_string(str(scalar)))
+                if collect_expression_metadata
+                else None
+            ),
+            "expression_metadata_collected": collect_expression_metadata,
+        },
+    )
+
+
+class _GraphTensorExpressionBuilder:
+    def __init__(self, model: BuiltinSMModel, graph: Any) -> None:
+        from symbolica.community.tensor import Representation, TensorName
+
+        self.model = model
+        self.graph = graph
+        self._mink = Representation.mink(4)
+        self._aux6 = Representation(symbols.antisymmetric_lorentz_pair_name, 6)
+        self._weyl = Representation(symbols.weyl_spinor_name, 2)
+        self._tensor_name = TensorName
+        self._interactions_by_result: dict[
+            tuple[int, tuple[int, ...], int], list[Any]
+        ] = {}
+        for interaction in graph.interactions:
+            self._interactions_by_result.setdefault(
+                _current_key_tuple(interaction.result),
+                [],
+            ).append(interaction)
+
+    def matrix_element_skeleton(self) -> Any:
+        from symbolica import Expression
+
+        total = Expression.num(0)
+        for amplitude_index, (left, right) in enumerate(self.graph.amplitudes, start=1):
+            slots = self._slots_for_current(left, f"amp_{amplitude_index}")
+            total = total + (
+                self._current_expression(left, slots)
+                * self._current_expression(right, slots)
+            )
+        return total
+
+    def matrix_element_interleaved_network(
+        self,
+        library: Any,
+        *,
+        execute_between: bool = True,
+    ) -> tuple[Any, dict[str, float | int]]:
+        from symbolica.community.tensor import TensorNetwork
+
+        metadata: dict[str, float | int] = {
+            "execution_s": 0.0,
+            "execution_count": 0,
+            "multiplication_count": 0,
+            "addition_count": 0,
+        }
+        total = None
+        for amplitude_index, (left, right) in enumerate(self.graph.amplitudes, start=1):
+            slots = self._slots_for_current(left, f"amp_{amplitude_index}")
+            left_network = self._current_network(
+                left,
+                slots,
+                library,
+                execute_between=execute_between,
+                metadata=metadata,
+            )
+            right_network = self._current_network(
+                right,
+                slots,
+                library,
+                execute_between=execute_between,
+                metadata=metadata,
+            )
+            amplitude_network = self._multiply_networks(
+                left_network,
+                right_network,
+                library,
+                execute_between=execute_between,
+                metadata=metadata,
+            )
+            total = (
+                amplitude_network
+                if total is None
+                else self._add_networks(
+                    total,
+                    amplitude_network,
+                    library,
+                    execute_between=execute_between,
+                    metadata=metadata,
+                )
+            )
+        if total is None:
+            total = TensorNetwork.zero()
+        return total, metadata
+
+    def _current_network(
+        self,
+        current: Any,
+        output_slots: tuple[Any, ...],
+        library: Any,
+        *,
+        execute_between: bool,
+        metadata: dict[str, float | int],
+    ) -> Any:
+        from symbolica.community.tensor import TensorNetwork, as_tensor
+
+        interactions = self._interactions_by_result.get(_current_key_tuple(current))
+        if not interactions:
+            expression = self._current_leaf(current, output_slots)
+            return TensorNetwork(
+                as_tensor(expression) if output_slots else expression, library
+            )
+
+        needs_propagator = _current_needs_propagator(self.graph, current)
+        result_slots = (
+            self._slots_for_current(
+                current,
+                self._propagator_dummy_prefix(current),
+            )
+            if needs_propagator
+            else output_slots
+        )
+        total = None
+        for interaction_index, interaction in enumerate(interactions, start=1):
+            left_slots = self._slots_for_current(
+                interaction.left,
+                self._dummy_prefix(interaction, interaction_index, "left"),
+            )
+            right_slots = self._slots_for_current(
+                interaction.right,
+                self._dummy_prefix(interaction, interaction_index, "right"),
+            )
+            expression = self._vertex_tensor(
+                interaction, left_slots, right_slots, result_slots
+            )
+            term = TensorNetwork(
+                as_tensor(expression)
+                if left_slots or right_slots or result_slots
+                else expression,
+                library,
+            )
+            term = self._multiply_networks(
+                term,
+                self._current_network(
+                    interaction.left,
+                    left_slots,
+                    library,
+                    execute_between=execute_between,
+                    metadata=metadata,
+                ),
+                library,
+                execute_between=execute_between,
+                metadata=metadata,
+            )
+            term = self._multiply_networks(
+                term,
+                self._current_network(
+                    interaction.right,
+                    right_slots,
+                    library,
+                    execute_between=execute_between,
+                    metadata=metadata,
+                ),
+                library,
+                execute_between=execute_between,
+                metadata=metadata,
+            )
+            if needs_propagator:
+                expression = self._propagator_tensor(
+                    current, result_slots, output_slots
+                )
+                term = self._multiply_networks(
+                    TensorNetwork(
+                        as_tensor(expression)
+                        if result_slots or output_slots
+                        else expression,
+                        library,
+                    ),
+                    term,
+                    library,
+                    execute_between=execute_between,
+                    metadata=metadata,
+                )
+            total = (
+                term
+                if total is None
+                else self._add_networks(
+                    total,
+                    term,
+                    library,
+                    execute_between=execute_between,
+                    metadata=metadata,
+                )
+            )
+        if total is None:
+            return TensorNetwork.zero()
+        return total
+
+    def _multiply_networks(
+        self,
+        left: Any,
+        right: Any,
+        library: Any,
+        *,
+        execute_between: bool,
+        metadata: dict[str, float | int],
+    ) -> Any:
+        result = left * right
+        metadata["multiplication_count"] = int(metadata["multiplication_count"]) + 1
+        if execute_between:
+            result = self._execute_network(result, library, metadata)
+        return result
+
+    def _add_networks(
+        self,
+        left: Any,
+        right: Any,
+        library: Any,
+        *,
+        execute_between: bool,
+        metadata: dict[str, float | int],
+    ) -> Any:
+        result = left + right
+        metadata["addition_count"] = int(metadata["addition_count"]) + 1
+        if execute_between:
+            result = self._execute_network(result, library, metadata)
+        return result
+
+    def _execute_network(
+        self,
+        network: Any,
+        library: Any,
+        metadata: dict[str, float | int],
+    ) -> Any:
+        from symbolica.community.tensor import TensorNetwork
+
+        start = time.perf_counter()
+        network.execute(library=library)
+        metadata["execution_s"] = float(metadata["execution_s"]) + (
+            time.perf_counter() - start
+        )
+        metadata["execution_count"] = int(metadata["execution_count"]) + 1
+        return TensorNetwork.one() * network.result_tensor(library)
+
+    def _current_expression(self, current: Any, output_slots: tuple[Any, ...]) -> Any:
+        from symbolica import Expression
+
+        key = _current_key_tuple(current)
+        interactions = self._interactions_by_result.get(key)
+        if not interactions:
+            return self._current_leaf(current, output_slots)
+
+        needs_propagator = _current_needs_propagator(self.graph, current)
+        result_slots = (
+            self._slots_for_current(
+                current,
+                self._propagator_dummy_prefix(current),
+            )
+            if needs_propagator
+            else output_slots
+        )
+        total = Expression.num(0)
+        for interaction_index, interaction in enumerate(interactions, start=1):
+            left_slots = self._slots_for_current(
+                interaction.left,
+                self._dummy_prefix(interaction, interaction_index, "left"),
+            )
+            right_slots = self._slots_for_current(
+                interaction.right,
+                self._dummy_prefix(interaction, interaction_index, "right"),
+            )
+            total = total + (
+                self._vertex_tensor(interaction, left_slots, right_slots, result_slots)
+                * self._current_expression(interaction.left, left_slots)
+                * self._current_expression(interaction.right, right_slots)
+            )
+        if needs_propagator:
+            total = self._propagator_tensor(current, result_slots, output_slots) * total
+        return total
+
+    def _current_leaf(self, current: Any, output_slots: tuple[Any, ...]) -> Any:
+        return self._tensor_name(_current_tensor_name(current))(
+            *output_slots
+        ).to_expression()
+
+    def _vertex_tensor(
+        self,
+        interaction: Any,
+        left_slots: tuple[Any, ...],
+        right_slots: tuple[Any, ...],
+        output_slots: tuple[Any, ...],
+    ) -> Any:
+        kind = int(interaction.vertex_kind)
+        if kind == 0:
+            return self.model.three_gluon_current_expression(
+                left_slot=left_slots[0],
+                right_slot=right_slots[0],
+                output_slot=output_slots[0],
+                left_momentum_tensor_name=_current_momentum_tensor_name(
+                    interaction.left
+                ),
+                right_momentum_tensor_name=_current_momentum_tensor_name(
+                    interaction.right
+                ),
+                dummy_prefix=self._dummy_prefix(interaction, 0, "three_gluon"),
+            )
+        if kind == 1:
+            return self._tensor_name(symbols.two_gluon_to_tensor_name)(
+                left_slots[0],
+                right_slots[0],
+                output_slots[0],
+            ).to_expression()
+        if kind == 2:
+            return self._tensor_name(symbols.tensor_gluon_to_gluon_name)(
+                left_slots[0],
+                right_slots[0],
+                output_slots[0],
+            ).to_expression()
+        if kind == 3:
+            return self._tensor_name(symbols.gluon_tensor_to_gluon_name)(
+                left_slots[0],
+                right_slots[0],
+                output_slots[0],
+            ).to_expression()
+        if kind == 6:
+            return self._tensor_name(
+                _quark_vector_weyl_tensor_name(int(interaction.result.chirality))
+            )(
+                left_slots[0],
+                right_slots[0],
+                output_slots[0],
+            ).to_expression()
+        if kind == 10:
+            return (
+                _number(
+                    _weyl_coupling_for_chirality(
+                        int(interaction.result.chirality),
+                        _coupling_pair(interaction.coupling),
+                    )
+                )
+                * self._tensor_name(
+                    _quark_vector_weyl_tensor_name(int(interaction.result.chirality))
+                )(
+                    left_slots[0],
+                    right_slots[0],
+                    output_slots[0],
+                ).to_expression()
+            )
+        return self._tensor_name(symbols.vertex_kind_tensor_name(kind))(
+            *left_slots,
+            *right_slots,
+            *output_slots,
+            _number(float(interaction.coupling[0])),
+            _number(float(interaction.coupling[1])),
+        ).to_expression()
+
+    def _propagator_tensor(
+        self,
+        current: Any,
+        input_slots: tuple[Any, ...],
+        output_slots: tuple[Any, ...],
+    ) -> Any:
+        return self._tensor_name(_propagator_tensor_name(current))(
+            input_slots[0],
+            output_slots[0],
+        ).to_expression()
+
+    def _slots_for_current(self, current: Any, prefix: str) -> tuple[Any, ...]:
+        pdg = int(current.pdg)
+        if pdg == -21:
+            return (self._aux6(f"{prefix}_A"),)
+        if _is_lorentz_vector_current_pdg(pdg):
+            return (self._mink(f"{prefix}_mu"),)
+        if 1 <= abs(pdg) <= 6 or 11 <= abs(pdg) <= 16:
+            return (self._weyl(f"{prefix}_alpha"),)
+        return ()
+
+    def _dummy_prefix(self, interaction: Any, index: int, side: str) -> str:
+        labels = "_".join(str(label) for label in interaction.result.external_labels)
+        chirality = int(interaction.result.chirality)
+        return (
+            f"v{int(interaction.vertex_kind)}_{labels}_"
+            f"{_signed_label(chirality)}_{index}_{side}"
+        )
+
+    def _propagator_dummy_prefix(self, current: Any) -> str:
+        labels = "_".join(str(label) for label in current.external_labels)
+        return (
+            f"prop_{_signed_label(int(current.pdg))}_{labels}_"
+            f"{_signed_label(int(current.chirality))}"
+        )
+
+    def _current_output_prefix(self, current: Any) -> str:
+        labels = "_".join(str(label) for label in current.external_labels)
+        return (
+            f"cur_{_signed_label(int(current.pdg))}_{labels}_"
+            f"{_signed_label(int(current.chirality))}"
+        )
+
+
+def _current_tensor_name(current: Any) -> str:
+    labels = "_".join(str(label) for label in current.external_labels)
+    return symbols.qualified_name(
+        f"current_{_signed_label(int(current.pdg))}_{labels}_"
+        f"{_signed_label(int(current.chirality))}"
+    )
+
+
+def _signed_label(value: int) -> str:
+    if value < 0:
+        return f"m{abs(value)}"
+    return f"p{value}"
+
+
+def _quark_vector_weyl_tensor_name(chirality: int) -> str:
+    if chirality == 1:
+        return symbols.quark_vector_weyl_plus_name
+    if chirality == -1:
+        return symbols.quark_vector_weyl_minus_name
+    raise ValueError(f"Weyl vector tensor requires nonzero chirality, got {chirality}")
+
+
+def _weyl_coupling_for_chirality(
+    chirality: int,
+    coupling: tuple[float, float],
+) -> float:
+    if chirality == 1:
+        return coupling[1]
+    if chirality == -1:
+        return coupling[0]
+    raise ValueError(f"Weyl coupling requires nonzero chirality, got {chirality}")
+
+
+def _coupling_pair(coupling: Any) -> tuple[float, float]:
+    if len(coupling) != 2:
+        raise ValueError(f"expected a two-component coupling, got {coupling}")
+    return float(coupling[0]), float(coupling[1])
+
+
+def _source_current_count(graph: Any) -> int:
+    return len(_source_currents(graph))
+
+
+def _source_currents(graph: Any) -> tuple[Any, ...]:
+    interactions_by_result: dict[tuple[int, tuple[int, ...], int], list[Any]] = {}
+    for interaction in graph.interactions:
+        interactions_by_result.setdefault(
+            _current_key_tuple(interaction.result),
+            [],
+        ).append(interaction)
+    source_keys: set[tuple[int, tuple[int, ...], int]] = set()
+    seen: set[tuple[int, tuple[int, ...], int]] = set()
+
+    def visit(current: Any) -> None:
+        key = _current_key_tuple(current)
+        if key in seen:
+            return
+        seen.add(key)
+        interactions = interactions_by_result.get(key)
+        if not interactions:
+            source_keys.add(key)
+            return
+        for interaction in interactions:
+            visit(interaction.left)
+            visit(interaction.right)
+
+    for left, right in graph.amplitudes:
+        visit(left)
+        visit(right)
+    return tuple(
+        current
+        for current in graph.currents
+        if _current_key_tuple(current) in source_keys
+    )
+
+
+def _register_parametric_source_currents(
+    library: Any,
+    graph: Any,
+    builder: ParamBuilder | None = None,
+) -> ParamBuilder:
+    from symbolica.community.tensor import Representation
+
+    if builder is None:
+        builder = ParamBuilder()
+    mink = Representation.mink(4)
+    aux6 = Representation(symbols.antisymmetric_lorentz_pair_name, 6)
+    weyl = Representation(symbols.weyl_spinor_name, 2)
+    for current in _source_currents(graph):
+        pdg = int(current.pdg)
+        if pdg == -21:
+            representation = aux6
+        elif _is_lorentz_vector_current_pdg(pdg):
+            representation = mink
+        elif 1 <= abs(pdg) <= 6 or 11 <= abs(pdg) <= 16:
+            representation = weyl
+        else:
+            continue
+        builder.register_rank1_tensor(
+            library,
+            tensor_name=_current_tensor_name(current),
+            representation=representation,
+            head=_current_parameter_head(current),
+            length=_current_dimension(current),
+            role="source_current",
+        )
+    return builder
+
+
+def _register_parametric_current_momenta(
+    model: BuiltinSMModel,
+    library: Any,
+    graph: Any,
+    builder: ParamBuilder | None = None,
+) -> ParamBuilder:
+    from symbolica.community.tensor import Representation, Tensor, TensorName
+
+    if builder is None:
+        builder = ParamBuilder()
+    mink = Representation.mink(4)
+    weyl = Representation(symbols.weyl_spinor_name, 2)
+    momentum_symbols_by_current: dict[
+        tuple[int, tuple[int, ...], int], tuple[Any, ...]
+    ] = {}
+    for current in _current_momentum_currents(graph):
+        momentum_symbols = builder.register_rank1_tensor(
+            library,
+            tensor_name=_current_momentum_tensor_name(current),
+            representation=mink,
+            head=_current_momentum_parameter_head(current),
+            length=4,
+            role="current_momentum",
+            real_valued=True,
+        )
+        momentum_symbols_by_current[_current_key_tuple(current)] = momentum_symbols
+
+    for current in _propagating_currents(graph):
+        momentum_symbols = momentum_symbols_by_current[_current_key_tuple(current)]
+        pdg = int(current.pdg)
+        if pdg == 21:
+            library.register(
+                Tensor.dense(
+                    TensorName(_propagator_tensor_name(current))(mink, mink),
+                    model.gluon_propagator_tensor_data(momentum_symbols),
+                )
+            )
+        elif _is_weyl_fermion_current(current):
+            library.register(
+                Tensor.dense(
+                    TensorName(_propagator_tensor_name(current))(weyl, weyl),
+                    model.quark_weyl_propagator_tensor_data(
+                        momentum_symbols,
+                        chirality=int(current.chirality),
+                    ),
+                )
+            )
+    return builder
+
+
+def _current_momentum_currents(graph: Any) -> tuple[Any, ...]:
+    currents: dict[tuple[int, tuple[int, ...], int], Any] = {}
+    for interaction in graph.interactions:
+        if int(interaction.vertex_kind) == 0:
+            currents.setdefault(_current_key_tuple(interaction.left), interaction.left)
+            currents.setdefault(
+                _current_key_tuple(interaction.right), interaction.right
+            )
+    for current in _propagating_currents(graph):
+        currents.setdefault(_current_key_tuple(current), current)
+    return tuple(currents.values())
+
+
+def _propagating_currents(graph: Any) -> tuple[Any, ...]:
+    result_keys = {
+        _current_key_tuple(interaction.result) for interaction in graph.interactions
+    }
+    amplitude_keys = {
+        _current_key_tuple(current)
+        for amplitude in graph.amplitudes
+        for current in amplitude
+    }
+    return tuple(
+        current
+        for current in graph.currents
+        if _current_key_tuple(current) in result_keys
+        and _current_key_tuple(current) not in amplitude_keys
+        and _has_supported_propagator(current)
+    )
+
+
+def _current_needs_propagator(graph: Any, current: Any) -> bool:
+    propagating_keys = {
+        _current_key_tuple(propagating_current)
+        for propagating_current in _propagating_currents(graph)
+    }
+    return _current_key_tuple(current) in propagating_keys
+
+
+def _has_supported_propagator(current: Any) -> bool:
+    pdg = int(current.pdg)
+    return pdg == 21 or _is_weyl_fermion_current(current)
+
+
+def _is_weyl_fermion_current(current: Any) -> bool:
+    pdg = int(current.pdg)
+    return (1 <= abs(pdg) <= 6 or 11 <= abs(pdg) <= 16) and int(current.chirality) != 0
+
+
+def _is_lorentz_vector_current_pdg(pdg: int) -> bool:
+    return pdg in (21, 22, 23, 24, -24)
+
+
+def _current_dimension(current: Any) -> int:
+    pdg = int(current.pdg)
+    if pdg == -21:
+        return 6
+    if _is_lorentz_vector_current_pdg(pdg):
+        return 4
+    if 1 <= abs(pdg) <= 6 or 11 <= abs(pdg) <= 16:
+        return 2
+    return 0
+
+
+def _current_parameter_head(current: Any) -> tuple[str, ...]:
+    labels = tuple(str(label) for label in current.external_labels)
+    return (
+        "current",
+        _signed_label(int(current.pdg)),
+        "_".join(labels) if labels else "empty",
+        _signed_label(int(current.chirality)),
+    )
+
+
+def _current_momentum_tensor_name(current: Any) -> str:
+    labels = "_".join(str(label) for label in current.external_labels)
+    return symbols.qualified_name(
+        f"current_momentum_{_signed_label(int(current.pdg))}_{labels}_"
+        f"{_signed_label(int(current.chirality))}"
+    )
+
+
+def _propagator_tensor_name(current: Any) -> str:
+    labels = "_".join(str(label) for label in current.external_labels)
+    if int(current.pdg) == 21:
+        head = "gluon_propagator"
+    elif _is_weyl_fermion_current(current):
+        head = "quark_weyl_propagator"
+    else:
+        head = "propagator"
+    return symbols.qualified_name(
+        f"{head}_{_signed_label(int(current.pdg))}_{labels}_"
+        f"{_signed_label(int(current.chirality))}"
+    )
+
+
+def _current_momentum_parameter_head(current: Any) -> tuple[str, ...]:
+    labels = tuple(str(label) for label in current.external_labels)
+    return (
+        "current_momentum",
+        _signed_label(int(current.pdg)),
+        "_".join(labels) if labels else "empty",
+        _signed_label(int(current.chirality)),
+    )
+
+
+def _propagator_lowering_ready(graph: Any) -> bool:
+    result_currents = {
+        _current_key_tuple(interaction.result): interaction.result
+        for interaction in graph.interactions
+    }
+    amplitude_keys = {
+        _current_key_tuple(current)
+        for amplitude in graph.amplitudes
+        for current in amplitude
+    }
+    for key, current in result_currents.items():
+        if key in amplitude_keys or int(current.pdg) == -21:
+            continue
+        if not _has_supported_propagator(current):
+            return False
+    return bool(graph.interactions)
+
+
+def _build_auxiliary_tensor_probe(
+    model: BuiltinSMModel,
+) -> TensorNetworkProbe:
+    from symbolica.community.tensor import (
+        Representation,
+        TensorName,
+        TensorNetwork,
+        as_tensor,
+    )
+
+    library = model.build_tensor_library()
+    mink = Representation.mink(4)
+    antisym = Representation(symbols.antisymmetric_lorentz_pair_name, 6)
+    two_gluon_to_tensor = TensorName(symbols.two_gluon_to_tensor_name)
+    tensor_gluon_to_gluon = TensorName(symbols.tensor_gluon_to_gluon_name)
+
+    expression = (
+        two_gluon_to_tensor(
+            mink("mu"),
+            mink("nu"),
+            antisym("A"),
+        ).to_expression()
+        * tensor_gluon_to_gluon(
+            antisym("A"),
+            mink("nu"),
+            mink("rho"),
+        ).to_expression()
+    )
+    network = TensorNetwork(as_tensor(expression), library)
+    network.execute(library=library)
+    result = network.result_tensor(library)
+    output_size = len(result)
+    structure = result.structure
+    entries = tuple(complex(result[i]) for i in range(output_size))
+    nonzero = tuple(
+        (index, value) for index, value in enumerate(entries) if abs(value) > 1.0e-15
+    )
+    weighted_checksum = sum((index + 1) * value for index, value in enumerate(entries))
+    return TensorNetworkProbe(
+        engine="spenso",
+        tensor_names=(
+            symbols.two_gluon_to_tensor_name,
+            symbols.tensor_gluon_to_gluon_name,
+        ),
+        expression=_clean_symbolica_string(str(expression)),
+        output_structure=_clean_symbolica_string(str(structure)),
+        output_rank=2,
+        output_size=output_size,
+        nonzero_entries=len(nonzero),
+        max_abs_entry=max((abs(value) for value in entries), default=0.0),
+        weighted_checksum=(weighted_checksum.real, weighted_checksum.imag),
+        first_nonzero_entries=tuple(
+            (index, _format_complex(value)) for index, value in nonzero[:4]
+        ),
+    )
+
+
+def _build_color_probe() -> ColorAlgebraProbe:
+    from symbolica.community.tensor import TensorExpression
+
+    structure_constant = TensorExpression.color_f(8)
+
+    def color_f(i: int, j: int, k: int) -> Any:
+        return structure_constant(i, j, k)
+
+    expression = color_f(1, 2, 3) * color_f(3, 2, 1)
+    simplified = expression.simplify_algebra(
+        gamma=False,
+        contract="none",
+        color_substitute_cof_dimension_invariants=True,
+    )
+    return ColorAlgebraProbe(
+        engine="tensor",
+        input_expression=_clean_symbolica_string(str(expression)),
+        simplified_expression=_clean_symbolica_string(str(simplified)),
+    )
+
+
+def _format_complex(value: complex) -> str:
+    real = 0.0 if abs(value.real) < 1.0e-15 else value.real
+    imag = 0.0 if abs(value.imag) < 1.0e-15 else value.imag
+    return f"{real:.16g}{imag:+.16g}j"
+
+
+def _clean_symbolica_string(value: str) -> str:
+    return re.sub(r"\x1b\[[0-9;]*m", "", value)
+
+
+def _preview_expression(value: str) -> str:
+    if len(value) <= _MAX_RECURSION_EXPRESSION_PREVIEW:
+        return value
+    suffix = "...<truncated>"
+    preview_length = _MAX_RECURSION_EXPRESSION_PREVIEW - len(suffix)
+    return f"{value[:preview_length]}{suffix}"
diff --git a/pyamplicol/src/pyamplicol/models/builtin/lowering_types.py b/pyamplicol/src/pyamplicol/models/builtin/lowering_types.py
new file mode 100644
index 0000000000..ed56385356
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/lowering_types.py
@@ -0,0 +1,108 @@
+# SPDX-License-Identifier: 0BSD
+"""Built-in-SM diagnostics for symbolic lowering results."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class TensorNetworkProbe:
+    engine: str
+    tensor_names: tuple[str, ...]
+    expression: str
+    output_structure: str
+    output_rank: int
+    output_size: int
+    nonzero_entries: int
+    max_abs_entry: float
+    weighted_checksum: tuple[float, float]
+    first_nonzero_entries: tuple[tuple[int, str], ...]
+
+
+@dataclass(frozen=True)
+class ColorAlgebraProbe:
+    engine: str
+    input_expression: str
+    simplified_expression: str
+
+
+@dataclass(frozen=True)
+class RecursionLoweringPlan:
+    engine: str
+    current_count: int
+    interaction_count: int
+    amplitude_count: int
+    source_current_count: int
+    vertex_kind_counts: tuple[tuple[int, int], ...]
+    tensor_route_vertex_kinds: tuple[int, ...]
+    color_order: tuple[int, ...]
+    expression: str
+    expression_length: int
+    expression_truncated: bool
+    first_assignments: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class VertexLoweringStep:
+    index: int
+    vertex_kind: int
+    backend: str
+    tensor_names: tuple[str, ...]
+    expression_head: str
+    full_tensor_network_ready: bool
+    result_current: str
+    left_current: str
+    right_current: str
+
+
+@dataclass(frozen=True)
+class VertexLoweringReport:
+    total_interactions: int
+    full_tensor_network_ready: bool
+    backend_counts: tuple[tuple[str, int], ...]
+    ready_vertex_kind_counts: tuple[tuple[int, int], ...]
+    pending_vertex_kind_counts: tuple[tuple[int, int], ...]
+    tensor_names: tuple[str, ...]
+    first_steps: tuple[VertexLoweringStep, ...]
+
+
+@dataclass(frozen=True)
+class TensorNetworkBlueprint:
+    engine: str
+    status: str
+    current_count: int
+    interaction_count: int
+    amplitude_count: int
+    expression_built: bool
+    expression_executed: bool
+    full_me_tensor_network_ready: bool
+    propagator_lowering_ready: bool
+    ready_interactions: int
+    pending_interactions: int
+    placeholder_vertex_kinds: tuple[int, ...]
+    registered_tensor_names: tuple[str, ...]
+    current_leaf_count: int
+    parametric_external_current_count: int
+    parametric_source_current_parameter_count: int
+    parametric_current_momentum_count: int
+    parametric_momentum_parameter_count: int
+    parametric_parameter_count: int
+    expression: str | None
+    expression_length: int | None
+    expression_truncated: bool | None
+    executed_expression: str | None
+    executed_expression_length: int | None
+    executed_expression_truncated: bool | None
+    execution_time_s: float | None
+
+
+@dataclass(frozen=True)
+class SymbolicLoweringReport:
+    tensor_library: str
+    tensor_network_probe: TensorNetworkProbe
+    color_algebra_probe: ColorAlgebraProbe
+    recursion_plan: RecursionLoweringPlan | None = None
+    vertex_lowering: VertexLoweringReport | None = None
+    tensor_network_blueprint: TensorNetworkBlueprint | None = None
+    full_me_tensor_network_ready: bool = False
diff --git a/pyamplicol/src/pyamplicol/models/builtin/model.py b/pyamplicol/src/pyamplicol/models/builtin/model.py
new file mode 100644
index 0000000000..5949f79bd6
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/model.py
@@ -0,0 +1,811 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+from collections import Counter
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any, Literal, cast
+
+from .._physics_ir import ContractionIR, ParticleIdentityIR, ParticleOrientation
+from ..base import (
+    CouplingOrders,
+    Model,
+    PropagatorLoweringRule,
+    QuantumNumberFlow,
+    RecurrenceCurrentEmbeddingContract,
+    RecurrenceLCColorComponentKind,
+    RecurrenceLCColorOperation,
+    RecurrenceLCColorShapeKind,
+    RecurrenceLCColorSourceSeedContract,
+    RecurrenceLCColorTransitionContract,
+    RecurrenceLCColorWitnessContract,
+    RecurrenceQuantumFlowContract,
+    Vertex,
+)
+from .definitions import BuiltinSMDefinitionMixin
+from .expressions import _builtin_vertex_result_chiralities
+from .lowering import BuiltinSMLoweringMixin
+from .process_catalog import PDGS
+
+_ELECTRIC_CHARGE_BY_PARTICLE = {
+    1: "-1/3",
+    2: "2/3",
+    3: "-1/3",
+    4: "2/3",
+    5: "-1/3",
+    6: "2/3",
+    11: "-1",
+    13: "-1",
+    15: "-1",
+    24: "1",
+    26: "1",
+}
+
+
+class BuiltinModel(Model):
+    """Legacy built-in-model conventions isolated from external UFO models."""
+
+    @cached_property
+    def _color_rep_by_pdg(self) -> dict[int, int]:
+        reps: dict[int, int] = {}
+        for pdg, particle in self._species_by_pdg.items():
+            color = particle.color_rep
+            if self._property_sign_by_pdg[pdg] < 0 and abs(color) == 3:
+                reps[pdg] = -color
+            else:
+                reps[pdg] = color
+        return reps
+
+    def color_rep(self, pdg: int) -> int:
+        try:
+            return self._color_rep_by_pdg[pdg]
+        except KeyError as exc:
+            raise KeyError(f"particle not in model: {pdg}") from exc
+
+    def is_quark(self, pdg: int) -> bool:
+        return 1 <= pdg <= 6
+
+    def is_antiquark(self, pdg: int) -> bool:
+        return -6 <= pdg <= -1
+
+    def is_lepton(self, pdg: int) -> bool:
+        return 11 <= pdg <= 16
+
+    def is_antilepton(self, pdg: int) -> bool:
+        return -16 <= pdg <= -11
+
+    def is_fermion(self, pdg: int) -> bool:
+        return (
+            self.is_quark(pdg)
+            or self.is_antiquark(pdg)
+            or self.is_lepton(pdg)
+            or self.is_antilepton(pdg)
+        )
+
+    def is_chiral_eligible(self, pdg: int) -> bool:
+        return self.is_fermion(pdg) and self.mass(pdg) == 0.0
+
+    def _vertex_result_chiralities(
+        self,
+        vertex: Vertex,
+        left_index: Any,
+        right_index: Any,
+    ) -> tuple[int, ...]:
+        return _builtin_vertex_result_chiralities(
+            self,
+            vertex,
+            left_index,
+            right_index,
+        )
+
+    def recurrence_quantum_flow_contract(
+        self,
+        vertex: Vertex,
+        left_particle_id: int,
+        right_particle_id: int,
+    ) -> RecurrenceQuantumFlowContract:
+        return self._standard_recurrence_quantum_flow_contract(
+            vertex,
+            left_particle_id,
+            right_particle_id,
+        )
+
+    def recurrence_current_embedding_contract(
+        self,
+        particle_id: int,
+        source_chirality: int,
+    ) -> RecurrenceCurrentEmbeddingContract:
+        return self._standard_recurrence_current_embedding_contract(
+            particle_id,
+            source_chirality,
+        )
+
+    def recurrence_lc_color_shape_contract(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> RecurrenceLCColorShapeKind:
+        return self._standard_recurrence_lc_color_shape_contract(
+            particle_id,
+            chirality,
+        )
+
+    def recurrence_lc_source_color_contract(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> RecurrenceLCColorSourceSeedContract:
+        return self._standard_recurrence_lc_source_color_contract(
+            particle_id,
+            chirality,
+        )
+
+    def recurrence_lc_color_transition_contract(
+        self,
+        vertex: Vertex,
+        *,
+        closure: bool,
+    ) -> RecurrenceLCColorTransitionContract:
+        rule_kind = self.vertex_color_structure(vertex)
+        representations = tuple(
+            self.color_rep(particle) for particle in vertex.particles
+        )
+        if closure:
+            if all(abs(value) == 1 for value in representations[:2]):
+                closure_kind = None
+            elif {representations[0], representations[1]} == {3, -3}:
+                closure_kind = "open-string"
+            elif representations[0] == representations[1] == 8:
+                closure_kind = "trace"
+            else:
+                raise ValueError(
+                    "built-in recurrence closure has unsupported color inputs "
+                    f"{representations[:2]!r}"
+                )
+            return RecurrenceLCColorTransitionContract(
+                rule_kind,
+                (
+                    RecurrenceLCColorWitnessContract(
+                        input_permutation=(0, 1),
+                        reverse_parent_mask=0,
+                        component_operation="close",
+                        result_component_kind=closure_kind,
+                        result_component_role="none",
+                    ),
+                ),
+            )
+
+        def witness(
+            permutation: tuple[int, int],
+            operation: RecurrenceLCColorOperation,
+            result_component: RecurrenceLCColorComponentKind | None,
+            factor: tuple[float, float] = (1.0, 0.0),
+        ) -> RecurrenceLCColorWitnessContract:
+            result_role = (
+                "passive"
+                if operation == "concatenate-join" and abs(representations[2]) == 1
+                else "active"
+                if operation
+                in {"concatenate-join", "inherit-left", "inherit-right"}
+                else "none"
+            )
+            return RecurrenceLCColorWitnessContract(
+                input_permutation=permutation,
+                reverse_parent_mask=0,
+                component_operation=operation,
+                result_component_kind=result_component,
+                result_component_role=result_role,
+                exact_factor=factor,
+            )
+
+        if rule_kind == "adjoint-structure-constant":
+            return RecurrenceLCColorTransitionContract(
+                rule_kind,
+                (
+                    witness((0, 1), "concatenate-join", "adjoint-segment"),
+                    witness(
+                        (1, 0),
+                        "concatenate-join",
+                        "adjoint-segment",
+                        (-1.0, 0.0),
+                    ),
+                ),
+            )
+        if rule_kind == "fundamental-generator":
+            orientation = {
+                # The open color word is always fundamental -> adjoints ->
+                # antifundamental, independently of the Lorentz input order.
+                4: ((1, 0), "open-string"),
+                5: ((0, 1), "open-string"),
+                6: ((0, 1), "open-string"),
+                7: ((1, 0), "open-string"),
+                9: ((1, 0), "adjoint-segment"),
+            }.get(vertex.kind)
+            if orientation is None:
+                raise ValueError(
+                    f"built-in fundamental-generator kernel {vertex.kind} has no "
+                    "compiler-owned LC orientation"
+                )
+            permutation, result_component = orientation
+            return RecurrenceLCColorTransitionContract(
+                rule_kind,
+                (witness(permutation, "concatenate-join", result_component),),
+            )
+        if rule_kind == "color-identity":
+            colored_inputs = tuple(
+                index
+                for index, representation in enumerate(representations[:2])
+                if abs(representation) != 1
+            )
+            if len(colored_inputs) == 0:
+                operation = "empty"
+                permutation = (0, 1)
+                result_component = None
+            elif len(colored_inputs) == 1:
+                operation = (
+                    "inherit-left" if colored_inputs[0] == 0 else "inherit-right"
+                )
+                permutation = (0, 1)
+                result_component = None
+            elif len(colored_inputs) == 2 and abs(representations[2]) == 1:
+                operation = "concatenate-join"
+                permutation = (
+                    (0, 1)
+                    if representations[0] == 3 or representations[1] == -3
+                    else (1, 0)
+                )
+                result_component = "open-string"
+            else:
+                raise ValueError(
+                    "built-in color-identity kernel has unsupported recurrence "
+                    f"representations {representations!r}"
+                )
+            return RecurrenceLCColorTransitionContract(
+                rule_kind,
+                (witness(permutation, operation, result_component),),
+            )
+        if rule_kind == "singlet":
+            return RecurrenceLCColorTransitionContract(
+                rule_kind,
+                (witness((0, 1), "empty", None),),
+            )
+        raise ValueError(
+            f"built-in kernel {vertex.kind} has unsupported recurrence color rule "
+            f"{rule_kind!r}"
+        )
+
+    def vertex_color_structure(self, vertex: Vertex) -> str:
+        """Return the exact built-in tensor family for one oriented vertex."""
+
+        representations = tuple(
+            self.color_rep(particle) for particle in vertex.particles
+        )
+        absolute = tuple(abs(value) for value in representations)
+        if all(value == 1 for value in absolute):
+            return "singlet"
+        if all(value == 8 for value in representations):
+            if vertex.kind not in {0, 1, 2, 3}:
+                raise ValueError(
+                    f"built-in vertex kind {vertex.kind} has an unknown adjoint tensor"
+                )
+            return "adjoint-structure-constant"
+        if sorted(absolute) == [1, 3, 3]:
+            return "color-identity"
+        if sorted(absolute) == [3, 3, 8]:
+            if vertex.kind not in {4, 5, 6, 7, 9}:
+                raise ValueError(
+                    f"built-in vertex kind {vertex.kind} has an unknown "
+                    "quark-gluon tensor"
+                )
+            return "fundamental-generator"
+        raise ValueError(
+            f"built-in vertex kind {vertex.kind} has unsupported color representations "
+            f"{representations!r}"
+        )
+
+    def is_fundamental_colored_fermion(self, pdg: int) -> bool:
+        return self.is_quark(pdg) or self.is_antiquark(pdg)
+
+    def is_massless_adjoint_vector(self, pdg: int) -> bool:
+        return pdg == 21
+
+    def is_gluon(self, pdg: int) -> bool:
+        return pdg in (21, 99)
+
+    def is_singlet(self, pdg: int) -> bool:
+        return not (abs(pdg) <= 6 or pdg == 21)
+
+    def is_tensor(self, pdg: int) -> bool:
+        return pdg in (-21, -23, 26, -26)
+
+    def is_massive_boson(self, pdg: int) -> bool:
+        return pdg == 23 or abs(pdg) == 24
+
+    def is_photon(self, pdg: int) -> bool:
+        return pdg == 22
+
+    def is_higgs(self, pdg: int) -> bool:
+        return pdg == 25
+
+    def quantum_number_flow(self, particle_id: int) -> QuantumNumberFlow:
+        particle = self.particle(particle_id)
+        expression = _ELECTRIC_CHARGE_BY_PARTICLE.get(particle.pdg, "0")
+        if expression != "0" and self._property_sign(particle_id) < 0:
+            expression = (
+                expression.removeprefix("-")
+                if expression.startswith("-")
+                else f"-{expression}"
+            )
+        return (("electric_charge", expression),)
+
+    def _particle_identity_ir(self, particle_id: int) -> ParticleIdentityIR:
+        particle_id = int(particle_id)
+        anti_particle_id = int(self.anti_particle(particle_id))
+        particle = self.particle(particle_id)
+        display_name = _display_name(particle_id)
+        anti_display_name = _display_name(anti_particle_id)
+        species_name = _display_name(particle.pdg)
+        return ParticleIdentityIR(
+            canonical_id=f"model:{self.name}:state:{display_name}",
+            species_id=f"model:{self.name}:species:{species_name}",
+            anti_canonical_id=f"model:{self.name}:state:{anti_display_name}",
+            display_name=display_name,
+            anti_display_name=anti_display_name,
+            pdg_label=particle_id,
+            anti_pdg_label=anti_particle_id,
+            orientation=cast(ParticleOrientation, self.source_orientation(particle_id)),
+            self_conjugate=particle_id == anti_particle_id,
+        )
+
+    def propagator_lowering_rule(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> PropagatorLoweringRule:
+        if self.is_tensor(particle_id):
+            return PropagatorLoweringRule(
+                particle_id=particle_id,
+                chirality=chirality,
+                backend="identity",
+                full_tensor_network_ready=True,
+                applies_propagator=False,
+                kernel="auxiliary_tensor_embedded_propagator",
+                kind="identity",
+                mass_class="not-applicable",
+                auxiliary_policy="antisymmetric-tensor",
+                description=(
+                    "auxiliary-tensor propagator factors are embedded in the "
+                    "adjacent built-in-SM vertex kernels"
+                ),
+            )
+        if particle_id in (125, 126, 127):
+            return PropagatorLoweringRule(
+                particle_id=particle_id,
+                chirality=chirality,
+                backend="identity",
+                full_tensor_network_ready=True,
+                applies_propagator=False,
+                kernel="auxiliary_scalar_no_propagator",
+                kind="identity",
+                mass_class="not-applicable",
+                auxiliary_policy="builtin-higgsor-scalar",
+                description=(
+                    "Higgsor auxiliary scalar currents are non-propagating in "
+                    "the built-in-SM model"
+                ),
+            )
+        if particle_id in (21, 22, 99):
+            return PropagatorLoweringRule(
+                particle_id=particle_id,
+                chirality=chirality,
+                backend="symbolica",
+                full_tensor_network_ready=True,
+                applies_propagator=True,
+                kernel="massless_vector_feynman_gauge",
+                kind="vector",
+                mass_class="massless",
+                gauge="feynman",
+                description="massless vector propagator in mostly-minus metric",
+            )
+        if abs(particle_id) == 24 or particle_id == 23:
+            return PropagatorLoweringRule(
+                particle_id=particle_id,
+                chirality=chirality,
+                backend="symbolica",
+                full_tensor_network_ready=True,
+                applies_propagator=True,
+                kernel="massive_vector_unitary_gauge",
+                kind="vector",
+                mass_class="massive",
+                gauge="unitary",
+                goldstone_policy="absorbed",
+                description="massive vector propagator with width",
+            )
+        if self.is_chiral_eligible(particle_id) and chirality != 0:
+            return PropagatorLoweringRule(
+                particle_id=particle_id,
+                chirality=chirality,
+                backend="spenso",
+                full_tensor_network_ready=True,
+                applies_propagator=True,
+                kernel="weyl_fermion",
+                kind="weyl-fermion",
+                mass_class="massless",
+                description="massless Weyl fermion propagator",
+            )
+        if self.is_fermion(particle_id) and (
+            self.mass(particle_id) != 0.0 or chirality == 0
+        ):
+            return PropagatorLoweringRule(
+                particle_id=particle_id,
+                chirality=chirality,
+                backend="symbolica",
+                full_tensor_network_ready=True,
+                applies_propagator=True,
+                kernel=(
+                    "massive_dirac_fermion"
+                    if self.mass(particle_id) != 0.0
+                    else "massless_dirac_fermion"
+                ),
+                kind="dirac-fermion",
+                mass_class=("massive" if self.mass(particle_id) != 0.0 else "massless"),
+                description=(
+                    "massive Dirac fermion propagator"
+                    if self.mass(particle_id) != 0.0
+                    else "massless full-Dirac fermion propagator"
+                ),
+            )
+        if self.is_higgs(particle_id):
+            return PropagatorLoweringRule(
+                particle_id=particle_id,
+                chirality=chirality,
+                backend="symbolica",
+                full_tensor_network_ready=True,
+                applies_propagator=True,
+                kernel="scalar_with_width",
+                kind="scalar",
+                mass_class="massive",
+                description="scalar propagator with optional width",
+            )
+        return PropagatorLoweringRule(
+            particle_id=particle_id,
+            chirality=chirality,
+            backend="unimplemented",
+            full_tensor_network_ready=False,
+            applies_propagator=True,
+            kernel="unknown",
+            kind="unsupported",
+            mass_class=("massive" if self.mass(particle_id) != 0.0 else "massless"),
+            description="no built-in-model propagator lowering is registered",
+        )
+
+    def auxiliary_kind(self, particle_id: int) -> str | None:
+        if particle_id == 99:
+            return "u1-subtraction-color-flow-vector"
+        if self.is_tensor(particle_id):
+            return "antisymmetric-tensor"
+        return None
+
+    def _install_builtin_contractions(self) -> None:
+        """Install the built-in model's explicit current bilinear forms."""
+
+        direct: dict[tuple[int, int, int, int], ContractionIR | None] = {}
+        closure: dict[tuple[int, int], ContractionIR | None] = {}
+        particle_ids = tuple(sorted(self._species_by_pdg))
+        for left_particle_id in particle_ids:
+            right_particle_id = self.anti_particle(left_particle_id)
+            for left_chirality in self._builtin_contraction_chiralities(
+                left_particle_id
+            ):
+                for right_chirality in self._builtin_contraction_chiralities(
+                    right_particle_id
+                ):
+                    contraction_ir = self._builtin_direct_contraction_ir(
+                        left_particle_id,
+                        right_particle_id,
+                        left_chirality=left_chirality,
+                        right_chirality=right_chirality,
+                    )
+                    if contraction_ir is not None:
+                        direct[
+                            (
+                                left_particle_id,
+                                left_chirality,
+                                right_particle_id,
+                                right_chirality,
+                            )
+                        ] = contraction_ir
+            for chirality in self._builtin_contraction_chiralities(left_particle_id):
+                if self.current_dimension(left_particle_id, chirality) == 1:
+                    closure[(left_particle_id, chirality)] = ContractionIR(
+                        name="scalar",
+                        left_basis="scalar",
+                        right_basis="scalar",
+                        coefficients=((1.0, 0.0),),
+                        chirality_relation="any",
+                        metric_signature=None,
+                    )
+        self._direct_contraction_ir_by_state = direct
+        self._closure_contraction_ir_by_state = closure
+
+    def _builtin_contraction_chiralities(self, particle_id: int) -> tuple[int, ...]:
+        if self.is_chiral_eligible(particle_id):
+            return (-1, 0, 1)
+        return (0,)
+
+    def _builtin_direct_contraction_ir(
+        self,
+        left_particle_id: int,
+        right_particle_id: int,
+        *,
+        left_chirality: int,
+        right_chirality: int,
+    ) -> ContractionIR | None:
+        left_dimension = self.current_dimension(left_particle_id, left_chirality)
+        right_dimension = self.current_dimension(right_particle_id, right_chirality)
+        if left_dimension != right_dimension:
+            return None
+
+        chirality_relation: Literal["any", "opposite"] = "any"
+        metric_signature: str | None = None
+        if left_dimension == 1:
+            name = "scalar"
+            coefficients = ((1.0, 0.0),)
+        elif left_dimension == 2:
+            if left_chirality != -right_chirality:
+                return None
+            name = "weyl"
+            coefficients = ((1.0, 0.0), (1.0, 0.0))
+            chirality_relation = "opposite"
+        elif left_dimension == 4:
+            if self.is_fermion(left_particle_id) != self.is_fermion(right_particle_id):
+                return None
+            if self.is_fermion(left_particle_id):
+                name = "dirac"
+                coefficients = ((1.0, 0.0),) * 4
+            else:
+                name = "lorentz"
+                coefficients = (
+                    (1.0, 0.0),
+                    (-1.0, 0.0),
+                    (-1.0, 0.0),
+                    (-1.0, 0.0),
+                )
+                metric_signature = "mostly-minus"
+        elif left_dimension == 6:
+            name = "antisymmetric-tensor"
+            coefficients = ((1.0, 0.0),) * 6
+        else:
+            return None
+        return ContractionIR(
+            name=name,
+            left_basis=self._current_basis(left_particle_id, left_chirality),
+            right_basis=self._current_basis(right_particle_id, right_chirality),
+            coefficients=coefficients,
+            chirality_relation=chirality_relation,
+            metric_signature=metric_signature,
+        )
+
+
+@dataclass
+class BuiltinSMModel(BuiltinSMLoweringMixin, BuiltinSMDefinitionMixin, BuiltinModel):
+    """Built-in Standard Model production path with pinned reference conventions."""
+
+    name: str = "built-in-sm-leading-color"
+    alpha_s_mz: float = 0.119
+    alpha_s_me_check: float = 0.118
+    alpha_ew: float = 1.0 / 132.507
+    sin_weak: float = 0.47143025548407230
+    sqrt_s: float = 14000.0
+
+    def __post_init__(self) -> None:
+        self.particles = {
+            particle.pdg: particle for particle in self._build_particles()
+        }
+        self.vertices = tuple(self._build_vertices())
+        self._install_builtin_contractions()
+
+    @cached_property
+    def cos_weak(self) -> float:
+        return math.sqrt(1.0 - self.sin_weak**2)
+
+    def weak_coupling(self) -> float:
+        return 1.0 / self.sin_weak
+
+    def neutral_gauge_coupling(self) -> float:
+        return self.weak_coupling() * self.cos_weak
+
+    def charged_current_coupling(self) -> float:
+        return self.weak_coupling() / math.sqrt(2.0)
+
+    def weak_coupling_over_cosine(self) -> float:
+        return self.weak_coupling() / self.cos_weak
+
+    def photon_fermion_coupling(self, pdg: int) -> tuple[float, float]:
+        particle = self.particle(pdg)
+        return particle.charge, particle.charge
+
+    def z_fermion_coupling(self, pdg: int) -> tuple[float, float]:
+        particle = self.particle(pdg)
+        charge = particle.charge
+        left = particle.weak_isospin[0]
+        right = particle.weak_isospin[1]
+        prefactor = self.weak_coupling_over_cosine()
+        return (
+            prefactor * (left - charge * self.sin_weak**2),
+            prefactor * (right - charge * self.sin_weak**2),
+        )
+
+    def leading_color_factor(self, process: Iterable[int]) -> int:
+        exponent_twice = 0
+        for pdg in process:
+            if pdg == 21:
+                exponent_twice += 2
+            elif 1 <= abs(pdg) <= 6:
+                exponent_twice += 1
+        if exponent_twice % 2:
+            raise ValueError(f"non-integer leading-color exponent for {tuple(process)}")
+        return 3 ** (exponent_twice // 2)
+
+    def runtime_normalization_payload(self, dag: Any) -> dict[str, object]:
+        """Preserve the established built-in-SM normalization convention."""
+
+        initial = tuple(int(pdg) for pdg in dag.process.initial_pdgs)
+        final = tuple(int(pdg) for pdg in dag.process.final_pdgs)
+        average_factor = 1
+        for pdg in initial:
+            if pdg == 21:
+                average_factor *= 16
+            elif 1 <= abs(pdg) <= 6:
+                average_factor *= 6
+            else:
+                average_factor *= 2
+        identical_factor = math.prod(
+            math.factorial(count) for count in Counter(final).values()
+        )
+        electroweak_power = (
+            max(1, len(dag.process.singlet_labels)) if dag.process.singlet_labels else 0
+        )
+        qcd_power = max(0, len(dag.process.legs) - 2 - electroweak_power)
+        return {
+            "color_accuracy": dag.process.color_accuracy,
+            "color_factor": int(self.leading_color_factor((*initial, *final))),
+            "average_factor": average_factor,
+            "identical_factor": identical_factor,
+            "global_coupling_factor": (
+                (4.0 * math.pi * self.alpha_s_me_check) ** qcd_power
+                * (2.0 * 4.0 * math.pi * self.alpha_ew) ** electroweak_power
+            ),
+            "qcd_coupling_power": qcd_power,
+            "electroweak_coupling_power": electroweak_power,
+            "couplings_in_stage_evaluators": True,
+            "coupling_policy": "stage evaluators include local vertex couplings",
+        }
+
+    def runtime_normalization_parameter_defaults(self) -> dict[str, float]:
+        """Expose the built-in SM coupling normalization as runtime inputs."""
+
+        return {
+            "normalization.alpha_s_me_check": float(self.alpha_s_me_check),
+            "normalization.alpha_ew": float(self.alpha_ew),
+        }
+
+    def skip_duplicate_vertex_orientation(self, vertex: Vertex) -> bool:
+        """Skip mirrored model-table entries already covered by DAG sweeps."""
+
+        return False
+
+    def vertex_coupling_orders(self, vertex: Vertex) -> CouplingOrders:
+        """Classify built-in SM vertices by UFO-style coupling order."""
+
+        if vertex.kind in {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}:
+            return (("QCD", 1),)
+        return (("QED", 1),)
+
+    def global_helicity_flip_equivalence_is_proven(
+        self,
+        vertices: Iterable[Vertex],
+    ) -> bool:
+        """Use the pinned built-in-SM QCD kernel inventory as the proof source."""
+
+        for vertex in vertices:
+            orders = self.vertex_coupling_orders(vertex)
+            if not orders and self.vertex_is_internal_contact_fragment(vertex):
+                continue
+            if not orders or any(name != "QCD" for name, _value in orders):
+                return False
+        return True
+
+    def pure_massless_adjoint_helicity_zero_rule_is_proven(
+        self,
+        process: Any,
+        vertices: Iterable[Vertex],
+    ) -> bool:
+        """Prove the tree-level Yang--Mills helicity-zero rule.
+
+        The proof is deliberately tied to the built-in model's registered
+        massless-adjoint and auxiliary-tensor kernels. A QCD coupling-order
+        label alone would also admit quark vertices and is not sufficient.
+        """
+
+        legs = tuple(getattr(process, "legs", ()))
+        if not legs or any(
+            getattr(leg, "outgoing_pdg", None) is None
+            or not self.is_massless_adjoint_vector(int(leg.outgoing_pdg))
+            or self.mass(int(leg.outgoing_pdg)) != 0.0
+            for leg in legs
+        ):
+            return False
+
+        pure_gauge_inventory = {
+            vertex
+            for vertex in self.vertices
+            if all(
+                self.is_massless_adjoint_vector(particle_id)
+                or self.auxiliary_kind(particle_id) == "antisymmetric-tensor"
+                for particle_id in vertex.particles
+            )
+        }
+        used_vertices = tuple(vertices)
+        return bool(used_vertices) and all(
+            vertex in pure_gauge_inventory for vertex in used_vertices
+        )
+
+    def adjoint_current_reflection_phase(
+        self,
+        vertex: Vertex,
+    ) -> tuple[float, float] | None:
+        """Expose the pinned three-gauge-boson current antisymmetry."""
+
+        if vertex.kind != 0 or not all(
+            self.is_massless_adjoint_vector(particle_id)
+            for particle_id in vertex.particles
+        ):
+            return None
+        return (-1.0, 0.0)
+
+    def lc_trace_reflection_equivalence_is_proven(self, process: Any) -> bool:
+        """Prove reflection folding for the pinned pure-gluon implementation."""
+
+        legs = tuple(getattr(process, "legs", ()))
+        return bool(legs) and all(
+            getattr(leg, "outgoing_pdg", None) is not None
+            and self.is_massless_adjoint_vector(int(leg.outgoing_pdg))
+            for leg in legs
+        )
+
+    def shared_single_trace_color_basis_is_proven(self, process: Any) -> bool:
+        """Prove the shared NLC/full trace basis for built-in Yang--Mills."""
+
+        return self.lc_trace_reflection_equivalence_is_proven(process)
+
+    def adjoint_tree_color_basis_is_proven(
+        self,
+        process: Any,
+        *,
+        max_coupling_orders: Mapping[str, int] | None = None,
+    ) -> bool:
+        """Certify only the pinned implementation's connected pure-gluon trees."""
+
+        del max_coupling_orders
+        # Subclasses may change the interaction inventory and must prove their
+        # own certificate rather than inherit the pinned SM's reflection hook.
+        return (
+            type(self) is BuiltinSMModel
+            and self.lc_trace_reflection_equivalence_is_proven(process)
+        )
+
+    def coupling_order_hierarchies(self) -> dict[str, int]:
+        return {"QCD": 1, "QED": 2}
+
+
+def _display_name(particle_id: int) -> str:
+    candidates = [name for name, pdg in PDGS.items() if int(pdg) == particle_id]
+    if not candidates:
+        return f"pdg_{particle_id}"
+    return min(candidates, key=lambda name: (len(name), name))
+
+
+__all__ = ["BuiltinModel", "BuiltinSMModel"]
diff --git a/pyamplicol/src/pyamplicol/models/builtin/process_catalog.py b/pyamplicol/src/pyamplicol/models/builtin/process_catalog.py
new file mode 100644
index 0000000000..2ddac7cfd1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/process_catalog.py
@@ -0,0 +1,335 @@
+# SPDX-License-Identifier: 0BSD
+"""Legacy built-in Standard Model process catalog."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ...processes.core_syntax import (
+    _anonymous_options,
+    _split_repeat_token,
+    _tokenize_side,
+)
+from .process_types import BuiltinParsedProcess as ParsedProcess
+from .process_types import (
+    BuiltinProcessEnumeration as ProcessEnumeration,
+)
+from .process_types import (
+    BuiltinSubprocessRecord as SubprocessRecord,
+)
+
+QUARKS = frozenset({"d", "u", "s", "c", "b", "t"})
+ANTIQUARKS = frozenset({f"{q}~" for q in QUARKS})
+SINGLETS = frozenset(
+    {
+        "a",
+        "z",
+        "w+",
+        "w-",
+        "e+",
+        "e-",
+        "mu+",
+        "mu-",
+        "ta+",
+        "ta-",
+        "ve",
+        "ve~",
+        "vm",
+        "vm~",
+        "vt",
+        "vt~",
+        "h",
+    }
+)
+GLUONS = frozenset({"g"})
+ALL_COLOURED = QUARKS | ANTIQUARKS | GLUONS
+PDGS = {
+    "g": "21",
+    "d": "1",
+    "u": "2",
+    "s": "3",
+    "c": "4",
+    "b": "5",
+    "t": "6",
+    "d~": "-1",
+    "u~": "-2",
+    "s~": "-3",
+    "c~": "-4",
+    "b~": "-5",
+    "t~": "-6",
+    "a": "22",
+    "z": "23",
+    "w+": "24",
+    "w-": "-24",
+    "e+": "-11",
+    "e-": "11",
+    "mu+": "-13",
+    "mu-": "13",
+    "ta+": "-15",
+    "ta-": "15",
+    "ve": "12",
+    "ve~": "-12",
+    "vm": "14",
+    "vm~": "-14",
+    "vt": "16",
+    "vt~": "-16",
+    "h": "25",
+}
+ANTI_PARTICLE = {
+    "g": "g",
+    "d": "d~",
+    "u": "u~",
+    "s": "s~",
+    "c": "c~",
+    "b": "b~",
+    "t": "t~",
+    "d~": "d",
+    "u~": "u",
+    "s~": "s",
+    "c~": "c",
+    "b~": "b",
+    "t~": "t",
+    "a": "a",
+    "z": "z",
+    "w+": "w-",
+    "w-": "w+",
+    "e+": "e-",
+    "e-": "e+",
+    "mu+": "mu-",
+    "mu-": "mu+",
+    "ta+": "ta-",
+    "ta-": "ta+",
+    "ve": "ve~",
+    "ve~": "ve",
+    "vm": "vm~",
+    "vm~": "vm",
+    "vt": "vt~",
+    "vt~": "vt",
+    "h": "h",
+}
+SORT_PARTICLES = {
+    "g": 13,
+    "d": 1,
+    "u": 2,
+    "s": 3,
+    "c": 4,
+    "b": 5,
+    "t": 6,
+    "d~": 7,
+    "u~": 8,
+    "s~": 9,
+    "c~": 10,
+    "b~": 11,
+    "t~": 12,
+    "a": 80,
+    "z": 81,
+    "w+": 82,
+    "w-": 83,
+    "e+": 84,
+    "e-": 85,
+    "mu+": 86,
+    "mu-": 87,
+    "ta+": 88,
+    "ta-": 89,
+    "ve": 90,
+    "ve~": 91,
+    "vm": 92,
+    "vm~": 93,
+    "vt": 94,
+    "vt~": 95,
+    "h": 96,
+}
+CHARGES3 = {
+    "g": 0,
+    "d": -1,
+    "u": 2,
+    "s": -1,
+    "c": 2,
+    "b": -1,
+    "t": 2,
+    "d~": 1,
+    "u~": -2,
+    "s~": 1,
+    "c~": -2,
+    "b~": 1,
+    "t~": -2,
+    "a": 0,
+    "z": 0,
+    "w+": 3,
+    "w-": -3,
+    "e+": 3,
+    "e-": -3,
+    "mu+": 3,
+    "mu-": -3,
+    "ta+": 3,
+    "ta-": -3,
+    "ve": 0,
+    "ve~": 0,
+    "vm": 0,
+    "vm~": 0,
+    "vt": 0,
+    "vt~": 0,
+    "h": 0,
+}
+FAMILY = {
+    "g": 0,
+    "d": 1,
+    "u": 1,
+    "s": 11,
+    "c": 11,
+    "b": 21,
+    "t": 21,
+    "d~": -1,
+    "u~": -1,
+    "s~": -11,
+    "c~": -11,
+    "b~": -21,
+    "t~": -21,
+    "a": 0,
+    "z": 0,
+    "w+": 0,
+    "w-": 0,
+    "e+": -31,
+    "e-": 31,
+    "mu+": -41,
+    "mu-": 41,
+    "ta+": -51,
+    "ta-": 51,
+    "ve": 31,
+    "ve~": -31,
+    "vm": 41,
+    "vm~": -41,
+    "vt": 51,
+    "vt~": -51,
+    "h": 0,
+}
+
+
+@dataclass(frozen=True)
+class ParticleSelectionMetadata:
+    name: str
+    pdg: int
+    anti_name: str
+    charge3: int
+    family: int
+    color_rep: int
+    is_fermion: bool
+    is_antiparticle: bool
+
+    @property
+    def is_colored(self) -> bool:
+        return self.color_rep != 1
+
+
+def selection_metadata(name: str) -> ParticleSelectionMetadata:
+    return _PARTICLE_SELECTION_METADATA[name]
+
+
+def _metadata_color_rep(name: str) -> int:
+    if name in QUARKS:
+        return 3
+    if name in ANTIQUARKS:
+        return -3
+    if name in GLUONS:
+        return 8
+    return 1
+
+
+_PARTICLE_SELECTION_METADATA = {
+    name: ParticleSelectionMetadata(
+        name=name,
+        pdg=int(PDGS[name]),
+        anti_name=ANTI_PARTICLE[name],
+        charge3=CHARGES3[name],
+        family=FAMILY[name],
+        color_rep=_metadata_color_rep(name),
+        is_fermion=name in QUARKS
+        or name in ANTIQUARKS
+        or abs(int(PDGS[name])) in range(11, 17),
+        is_antiparticle=name in ANTIQUARKS or int(PDGS[name]) < 0,
+    )
+    for name in PDGS
+}
+
+
+def process_uses_inclusive_labels(process: str) -> bool:
+    parts = process.lower().replace("bar", "~").split(">")
+    if len(parts) != 2:
+        raise ValueError("invalid collision format; expected 'initial > final'")
+    for token in (*_tokenize_side(parts[0].strip()), *_tokenize_side(parts[1].strip())):
+        _, item = _split_repeat_token(token)
+        if item in {"p", "j"}:
+            return True
+        if (
+            item.startswith("[")
+            and item.endswith("]")
+            and any(option in {"p", "j"} for option in _anonymous_options(item))
+        ):
+            return True
+    return False
+
+
+def request_allows_charged_current(request: ParsedProcess) -> bool:
+    """Return whether built-in request quantum numbers imply charged-current flow."""
+
+    if "w+" in request.rest or "w-" in request.rest:
+        return True
+    non_qcd_rest = [
+        particle
+        for particle in request.rest
+        if particle not in ALL_COLOURED and particle in CHARGES3
+    ]
+    return abs(sum(CHARGES3[particle] for particle in non_qcd_rest)) == 3
+
+
+def concrete_processes_from_inclusive_enumeration(
+    enumeration: ProcessEnumeration,
+) -> tuple[str, ...]:
+    processes: dict[str, None] = {}
+    for group in enumeration.groups:
+        for record in group.records:
+            processes.setdefault(_record_to_physical_process(record), None)
+    return tuple(sorted(processes, key=_concrete_process_sort_key))
+
+
+def _record_to_physical_process(record: SubprocessRecord) -> str:
+    initial = tuple(ANTI_PARTICLE[p] for p in record.process[:2])
+    final = record.process[2:]
+    return f"{' '.join(initial)} > {' '.join(final)}"
+
+
+def _concrete_process_sort_key(process: str) -> tuple[object, ...]:
+    initial, _, final = process.partition(">")
+    initial_tokens = tuple(_tokenize_side(initial.strip()))
+    final_tokens = tuple(_tokenize_side(final.strip()))
+    q_qbar_first = not (
+        len(initial_tokens) == 2
+        and not initial_tokens[0].endswith("~")
+        and initial_tokens[1].endswith("~")
+    )
+    return (
+        q_qbar_first,
+        tuple(SORT_PARTICLES.get(token, 999) for token in initial_tokens),
+        tuple(SORT_PARTICLES.get(token, 999) for token in final_tokens),
+        initial_tokens,
+        final_tokens,
+    )
+
+
+__all__ = [
+    "ALL_COLOURED",
+    "ANTIQUARKS",
+    "ANTI_PARTICLE",
+    "CHARGES3",
+    "FAMILY",
+    "GLUONS",
+    "PDGS",
+    "QUARKS",
+    "SINGLETS",
+    "SORT_PARTICLES",
+    "ParticleSelectionMetadata",
+    "concrete_processes_from_inclusive_enumeration",
+    "process_uses_inclusive_labels",
+    "request_allows_charged_current",
+    "selection_metadata",
+]
diff --git a/pyamplicol/src/pyamplicol/models/builtin/process_enumeration.py b/pyamplicol/src/pyamplicol/models/builtin/process_enumeration.py
new file mode 100644
index 0000000000..8a5a227a7c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/process_enumeration.py
@@ -0,0 +1,646 @@
+# SPDX-License-Identifier: 0BSD
+"""Legacy built-in-SM concrete subprocess enumeration."""
+
+from __future__ import annotations
+
+import itertools
+import math
+import re
+from collections import Counter
+from collections.abc import Iterable, Sequence
+from dataclasses import replace
+
+from ...processes.core_syntax import (
+    OrderTuple,
+    ProcessTuple,
+    _tokenize_side,
+    expand_process_variants,
+)
+from .process_catalog import (
+    ALL_COLOURED,
+    ANTI_PARTICLE,
+    ANTIQUARKS,
+    CHARGES3,
+    FAMILY,
+    GLUONS,
+    PDGS,
+    QUARKS,
+    SINGLETS,
+    SORT_PARTICLES,
+)
+from .process_catalog import (
+    request_allows_charged_current as _request_allows_charged_current,
+)
+from .process_types import BuiltinParsedProcess as ParsedProcess
+from .process_types import (
+    BuiltinPhaseSpaceGroup as PhaseSpaceGroup,
+)
+from .process_types import (
+    BuiltinProcessEnumeration as ProcessEnumeration,
+)
+from .process_types import (
+    BuiltinProcessOptions as ProcessOptions,
+)
+from .process_types import (
+    BuiltinSubprocessRecord as SubprocessRecord,
+)
+
+
+def _ordered_compositions(total: int, parts: int) -> tuple[tuple[int, ...], ...]:
+    if parts <= 0:
+        return ((),) if total == 0 else ()
+    if parts == 1:
+        return ((total,),)
+    return tuple(
+        (first, *rest)
+        for first in range(total + 1)
+        for rest in _ordered_compositions(total - first, parts - 1)
+    )
+
+
+def _chunk_sequence(
+    values: Sequence[int],
+    chunk_lengths: Sequence[int],
+) -> tuple[tuple[int, ...], ...]:
+    chunks: list[tuple[int, ...]] = []
+    start = 0
+    for length in chunk_lengths:
+        chunks.append(tuple(values[start : start + length]))
+        start += length
+    return tuple(chunks)
+
+
+class ProcessEnumerator:
+    """Structured port of the legacy process_list.py enumeration logic."""
+
+    def __init__(self, options: ProcessOptions | None = None) -> None:
+        self.options = options or ProcessOptions()
+        self.flavour_scheme = self._flavour_scheme(self.options.flavour_scheme)
+        self.massless_qcd = (
+            self.flavour_scheme
+            | frozenset(f"{q}~" for q in self.flavour_scheme)
+            | GLUONS
+        )
+        self.proton = self.massless_qcd
+        self.jet = self.massless_qcd
+        self._phase_space_orders: dict[OrderTuple, list[SubprocessRecord]] = {}
+        self._all_keys_sorted: list[OrderTuple] = []
+        self._process_order_to_index: dict[tuple[ProcessTuple, OrderTuple], int] = {}
+
+    def parse(self, process_string: str) -> ParsedProcess:
+        variants = expand_process_variants(process_string)
+        if len(variants) != 1:
+            raise ValueError(
+                "ProcessEnumerator.parse expects one concrete process; "
+                "use enumerate_process_set for process sets or multiparticle expansion"
+            )
+        input_string = variants[0].lower().replace("bar", "~")
+        parts = input_string.split(">")
+        if len(parts) != 2:
+            raise ValueError("invalid collision format; expected 'initial > final'")
+
+        initial_state = _tokenize_side(parts[0].strip())
+        if len(initial_state) != 2:
+            raise ValueError("exactly two incoming particles are required")
+        crossed_initial = tuple(
+            ANTI_PARTICLE[p] if p not in {"p", "j"} else p for p in initial_state
+        )
+
+        final_state = _tokenize_side(parts[1].strip())
+        jet_count = 0
+        rest: list[str] = []
+        for token in final_state:
+            jet_match = re.fullmatch(r"(\d+)j", token)
+            if token == "j":
+                jet_count += 1
+            elif jet_match:
+                jet_count += int(jet_match.group(1))
+            else:
+                rest.append(token)
+        leptons: list[str] = []
+        if self.options.include_resonance:
+            leptons = [p for p in rest if 11 <= abs(int(PDGS[p])) <= 16]
+            for lepton in leptons:
+                rest.remove(lepton)
+            charge = sum(CHARGES3[p] for p in leptons)
+            if charge == 0:
+                rest.append("z")
+            elif charge < 0:
+                rest.append("w-")
+            else:
+                rest.append("w+")
+
+        self._validate_particles([*crossed_initial, *rest])
+        return ParsedProcess(crossed_initial, jet_count, tuple(rest), tuple(leptons))
+
+    def enumerate(self, process_string: str) -> ProcessEnumeration:
+        request = self.parse(process_string)
+        unique_processes = self._generate_all_unique_processes(request)
+        subprocesses = self._generate_all_processes(unique_processes, request)
+        self._phase_space_orders = self._combine_results(
+            self._process_subprocess(proc) for proc in subprocesses
+        )
+        self._all_keys_sorted = sorted(self._phase_space_orders)
+        self._determine_multichannel_partners_and_symmetry_factor()
+        self._check_consistency()
+
+        groups = tuple(
+            PhaseSpaceGroup(
+                group_id=i + 1,
+                phase_space_order=key,
+                records=tuple(
+                    sorted(self._phase_space_orders[key], key=self._sort_record)
+                ),
+            )
+            for i, key in enumerate(self._all_keys_sorted)
+        )
+        return ProcessEnumeration(
+            request=request,
+            options=self.options,
+            unique_processes=tuple(
+                tuple(proc)
+                for proc in sorted(
+                    (
+                        tuple(sorted(p, key=lambda x: SORT_PARTICLES[x]))
+                        for p in unique_processes
+                    ),
+                    key=self._sort_process,
+                )
+            ),
+            groups=groups,
+        )
+
+    def enumerate_color_complete(self, process_string: str) -> ProcessEnumeration:
+        """Enumerate a reference-only colour-complete legacy process file.
+
+        The production LC process list deliberately removes colour-order
+        representatives related by legacy symmetries.  That is correct for
+        ordinary integration and LC library timing, but NLC/full-colour
+        generated-library validation needs raw amplitudes for every colour
+        basis row used by AmpliCol's colour matrix.  This reference path keeps
+        all model-compatible candidate colour words in a single phase-space
+        group and avoids process-family assumptions.
+        """
+
+        request = self.parse(process_string)
+        unique_processes = self._generate_all_unique_processes(request)
+        subprocesses = self._generate_all_processes(unique_processes, request)
+        records: list[SubprocessRecord] = []
+        seen: set[tuple[ProcessTuple, OrderTuple]] = set()
+        for proc in sorted(subprocesses, key=self._sort_process):
+            for perm in self._candidate_color_orders(proc):
+                order = tuple(perm)
+                key = (proc, order)
+                if key in seen:
+                    continue
+                seen.add(key)
+                records.append(
+                    SubprocessRecord(
+                        process=proc,
+                        color_order=order,
+                        multichannel_partners=(0,),
+                        identical_factor=self._identical_particle_symmetry_factor(proc),
+                    )
+                )
+        if not records:
+            return ProcessEnumeration(
+                request=request,
+                options=self.options,
+                unique_processes=(),
+                groups=(),
+            )
+        return ProcessEnumeration(
+            request=request,
+            options=self.options,
+            unique_processes=tuple(
+                tuple(proc)
+                for proc in sorted(
+                    (
+                        tuple(sorted(p, key=lambda x: SORT_PARTICLES[x]))
+                        for p in unique_processes
+                    ),
+                    key=self._sort_process,
+                )
+            ),
+            groups=(
+                PhaseSpaceGroup(
+                    group_id=1,
+                    phase_space_order=tuple(range(len(records[0].process))),
+                    records=tuple(records),
+                ),
+            ),
+        )
+
+    def _flavour_scheme(self, value: int) -> frozenset[str]:
+        flavours = ("d", "u", "s", "c", "b", "t")
+        if not 1 <= value <= 6:
+            raise ValueError(f"unknown flavour scheme: {value}")
+        return frozenset(flavours[:value])
+
+    def _validate_particles(self, particles: Iterable[str]) -> None:
+        unknown = sorted(set(particles).difference(PDGS).difference({"p", "j"}))
+        if unknown:
+            raise ValueError(f"unknown particle name(s): {unknown}")
+
+    def _valid_color_order(self, proc: ProcessTuple, perm: OrderTuple) -> bool:
+        found_quark = found_antiquark = found_singlet = found_gluon = found_first = (
+            False
+        )
+        quark_idx = -1
+        for idx in perm:
+            if idx == 0:
+                found_first = True
+            particle = proc[idx]
+            if particle in QUARKS:
+                if found_quark or found_gluon:
+                    return False
+                found_quark = True
+                found_antiquark = found_singlet = found_gluon = False
+                quark_idx = idx
+            elif particle in ANTIQUARKS:
+                if found_antiquark or found_singlet or not found_quark:
+                    return False
+                if not found_first:
+                    return False
+                found_antiquark = True
+                found_quark = found_singlet = found_gluon = False
+                _ = quark_idx
+            elif particle in GLUONS:
+                if found_antiquark or found_singlet:
+                    return False
+                found_gluon = True
+            else:
+                if found_quark or found_gluon or not found_antiquark:
+                    return False
+                found_singlet = True
+        return not (found_gluon and perm[0] != 0)
+
+    def _unique_color_order(self, proc: ProcessTuple, perm: OrderTuple) -> bool:
+        zero = perm.index(0)
+        perm_mapped = perm[zero:] + perm[:zero]
+        for particle in ALL_COLOURED:
+            particle_positions = [
+                i + 2 for i, part in enumerate(proc[2:]) if part == particle
+            ]
+            previous_position = 0
+            for position in particle_positions:
+                mapped_position = perm_mapped.index(position)
+                if mapped_position < previous_position:
+                    return False
+                previous_position = mapped_position
+        return True
+
+    def _order_proc_perm(
+        self, proc: ProcessTuple, perm: OrderTuple
+    ) -> tuple[ProcessTuple, OrderTuple]:
+        zero = perm.index(0)
+        perm_mapped = list(perm[zero:] + perm[:zero])
+        elements_to_order = [
+            i for i in perm_mapped if proc[i] in self.massless_qcd and i > 1
+        ]
+        indices = [perm_mapped.index(x) for x in elements_to_order]
+        for idx, value in zip(indices, sorted(elements_to_order), strict=True):
+            perm_mapped[idx] = value
+        perm_ordered = tuple(
+            perm_mapped[len(perm) - zero :] + perm_mapped[: len(perm) - zero]
+        )
+        proc_ordered: list[str | None] = [None] * len(proc)
+        for i, perm_index in enumerate(perm_ordered):
+            proc_ordered[perm_index] = proc[perm[i]]
+        return tuple(x for x in proc_ordered if x is not None), perm_ordered
+
+    def _process_subprocess(
+        self, proc: ProcessTuple
+    ) -> dict[OrderTuple, list[SubprocessRecord]]:
+        local: dict[OrderTuple, list[SubprocessRecord]] = {}
+        for perm in self._candidate_color_orders(proc):
+            order = tuple(perm)
+            if not self._valid_color_order(proc, order):
+                continue
+            if not self._unique_color_order(proc, order):
+                continue
+            ordered_proc, ordered_perm = self._order_proc_perm(proc, order)
+            zero = ordered_perm.index(0)
+            perm_mapped = tuple(ordered_perm[zero:] + ordered_perm[:zero])
+            local.setdefault(perm_mapped, []).append(
+                SubprocessRecord(ordered_proc, ordered_perm)
+            )
+        return local
+
+    def _candidate_color_orders(self, proc: ProcessTuple) -> Iterable[OrderTuple]:
+        quark_indices = tuple(
+            i for i, particle in enumerate(proc) if particle in QUARKS
+        )
+        anti_indices = tuple(
+            i for i, particle in enumerate(proc) if particle in ANTIQUARKS
+        )
+        gluon_indices = tuple(
+            i for i, particle in enumerate(proc) if particle in GLUONS
+        )
+        singlet_indices = tuple(
+            i for i, particle in enumerate(proc) if particle in SINGLETS
+        )
+        if not quark_indices:
+            for tail in itertools.permutations(
+                index for index in gluon_indices if index != 0
+            ):
+                yield (0, *tail)
+            return
+
+        if singlet_indices:
+            singlet_perms = tuple(itertools.permutations(singlet_indices))
+        else:
+            singlet_perms = ((),)
+        gluon_compositions = _ordered_compositions(
+            len(gluon_indices),
+            len(quark_indices),
+        )
+        singlet_compositions = _ordered_compositions(
+            len(singlet_indices),
+            len(quark_indices),
+        )
+        for quark_order in itertools.permutations(quark_indices):
+            for anti_order in itertools.permutations(anti_indices):
+                for gluon_perm in itertools.permutations(gluon_indices):
+                    for gluon_chunks in gluon_compositions:
+                        gluon_by_line = _chunk_sequence(gluon_perm, gluon_chunks)
+                        for singlet_perm in singlet_perms:
+                            for singlet_chunks in singlet_compositions:
+                                singlet_by_line = _chunk_sequence(
+                                    singlet_perm,
+                                    singlet_chunks,
+                                )
+                                order: list[int] = []
+                                for line in range(len(quark_indices)):
+                                    order.append(quark_order[line])
+                                    order.extend(gluon_by_line[line])
+                                    order.append(anti_order[line])
+                                    order.extend(singlet_by_line[line])
+                                yield tuple(order)
+
+    def _valid_process(
+        self,
+        proc: Sequence[str],
+        *,
+        allow_charged_current: bool | None = None,
+    ) -> bool:
+        allow_cc = (
+            self.options.include_cc
+            if allow_charged_current is None
+            else allow_charged_current
+        )
+        nq = self._count_matching(proc, QUARKS)
+        naq = self._count_matching(proc, ANTIQUARKS)
+        if nq != naq:
+            return False
+        if sum(CHARGES3[x] for x in proc) != 0:
+            return False
+        if not self.options.include_cc and sum(FAMILY[x] for x in proc) != 0:
+            return False
+        if not allow_cc and "w+" not in proc and "w-" not in proc:
+            for q in QUARKS:
+                if self._count_matching(proc, [q]) != self._count_matching(
+                    proc, [f"{q}~"]
+                ):
+                    return False
+        return not (nq == 0 and self._count_matching(proc, SINGLETS) > 0)
+
+    def _compatible_unique_process(
+        self, request: ParsedProcess, proc: Sequence[str]
+    ) -> bool:
+        mandatory = [p for p in request.initial_state if p not in {"p", "j"}]
+        mandatory.extend(request.rest)
+        proc_local = list(proc)
+        try:
+            for particle in mandatory:
+                proc_local.remove(particle)
+        except ValueError:
+            return False
+        return True
+
+    def _compatible_process(self, request: ParsedProcess, proc: ProcessTuple) -> bool:
+        proc_local = list(proc[2:])
+        for i in (0, 1):
+            if (
+                request.initial_state[i] not in {"p", "j"}
+                and proc[i] != request.initial_state[i]
+            ):
+                return False
+        try:
+            for particle in request.rest:
+                proc_local.remove(particle)
+        except ValueError:
+            return False
+        return True
+
+    def _generate_all_unique_processes(
+        self, request: ParsedProcess
+    ) -> set[ProcessTuple]:
+        processes: list[list[str]] = [[]]
+        for part in request.initial_state:
+            if part not in {"p", "j"} and part not in self.massless_qcd:
+                raise ValueError(
+                    "initial state should be a proton or massless QCD parton"
+                )
+
+        if request.jet_count == 0 and all(
+            part not in {"p", "j"} for part in request.initial_state
+        ):
+            fixed_process = tuple(
+                sorted(
+                    (*request.initial_state, *request.rest),
+                    key=lambda item: SORT_PARTICLES[item],
+                )
+            )
+            if self._valid_process(
+                fixed_process,
+                allow_charged_current=_request_allows_charged_current(request),
+            ) and self._compatible_unique_process(request, fixed_process):
+                return {fixed_process}
+            return set()
+
+        qcd_rest = sum(1 for part in request.rest if part in self.massless_qcd)
+        for _part_index in range(request.jet_count + 2 + qcd_rest):
+            new_processes: list[list[str]] = []
+            for candidate in processes:
+                for particle in self.massless_qcd:
+                    new_processes.append(sorted([*candidate, particle]))
+            processes = new_processes
+
+        for part in request.rest:
+            if part in self.massless_qcd:
+                continue
+            for candidate in processes:
+                candidate.append(part)
+
+        return {
+            tuple(proc)
+            for proc in processes
+            if self._valid_process(
+                proc,
+                allow_charged_current=_request_allows_charged_current(request),
+            )
+            and self._compatible_unique_process(request, proc)
+        }
+
+    def _generate_all_processes(
+        self, unique_processes: set[ProcessTuple], request: ParsedProcess
+    ) -> set[ProcessTuple]:
+        processes: set[ProcessTuple] = set()
+        for proc in unique_processes:
+            for i, j in itertools.combinations(range(len(proc)), 2):
+                if proc[i] in self.jet and proc[j] in self.jet:
+                    remaining = [
+                        entry for k, entry in enumerate(proc) if k not in (i, j)
+                    ]
+                    proc1 = (proc[i], proc[j], *remaining)
+                    proc2 = (proc[j], proc[i], *remaining)
+                    if self._compatible_process(request, proc1):
+                        processes.add(proc1)
+                    if self._compatible_process(request, proc2):
+                        processes.add(proc2)
+        return processes
+
+    def _combine_results(
+        self, results: Iterable[dict[OrderTuple, list[SubprocessRecord]]]
+    ) -> dict[OrderTuple, list[SubprocessRecord]]:
+        combined: dict[OrderTuple, list[SubprocessRecord]] = {}
+        for result in results:
+            for key, value in result.items():
+                combined.setdefault(key, []).extend(value)
+        return combined
+
+    def _determine_multichannel_partners_and_symmetry_factor(self) -> None:
+        self._build_process_index()
+        for key in self._all_keys_sorted:
+            for index, record in enumerate(tuple(self._phase_space_orders[key])):
+                self._phase_space_orders[key][index] = self._record_with_partners(
+                    record
+                )
+
+        for key in self._all_keys_sorted:
+            for index, record in enumerate(tuple(self._phase_space_orders[key])):
+                self._phase_space_orders[key][index] = replace(
+                    record,
+                    identical_factor=record.identical_factor
+                    * self._identical_particle_symmetry_factor(record.process),
+                )
+
+    def _build_process_index(self) -> None:
+        self._process_order_to_index = {}
+        for i, key in enumerate(self._all_keys_sorted):
+            for record in self._phase_space_orders[key]:
+                self._process_order_to_index[(record.process, record.color_order)] = i
+
+    def _record_with_partners(self, record: SubprocessRecord) -> SubprocessRecord:
+        proc = record.process
+        perm = record.color_order
+        singlet_indices = [perm.index(i) for i, p in enumerate(proc) if p in SINGLETS]
+        anti_quark_indices = tuple(
+            perm.index(i) for i, p in enumerate(proc) if p in ANTIQUARKS
+        )
+        nsinglets = len(singlet_indices)
+        if len(singlet_indices) > 1:
+            singlet_perms = tuple(itertools.permutations(singlet_indices))
+        elif len(singlet_indices) == 1:
+            singlet_perms = (tuple(singlet_indices),)
+        else:
+            singlet_perms = ()
+
+        iden = float(math.factorial(max(len(anti_quark_indices) - 1, 0)))
+        possible: list[tuple[OrderTuple, ProcessTuple]] = []
+        if not singlet_perms:
+            possible.append((perm, proc))
+        elif anti_quark_indices:
+            for singlets in singlet_perms:
+                for chunks in _ordered_compositions(
+                    nsinglets,
+                    len(anti_quark_indices),
+                ):
+                    starts = [0]
+                    for chunk in chunks[:-1]:
+                        starts.append(starts[-1] + chunk)
+                    singlet_chunks = tuple(
+                        singlets[start : start + chunk]
+                        for start, chunk in zip(starts, chunks, strict=True)
+                    )
+                    order_list: list[int] = []
+                    for i in range(len(perm)):
+                        if i in anti_quark_indices:
+                            anti_index = anti_quark_indices.index(i)
+                            order_list.extend(
+                                perm[p]
+                                for p in (
+                                    (anti_quark_indices[anti_index],)
+                                    + singlet_chunks[anti_index]
+                                )
+                            )
+                        elif i not in singlet_indices:
+                            order_list.append(perm[i])
+                    possible.append((tuple(order_list), proc))
+        else:
+            raise RuntimeError(
+                "colour-singlet partners require at least one quark line"
+            )
+
+        partners: list[int] = []
+        for possible_order, process in possible:
+            partner = self._process_order_to_index.get((process, possible_order))
+            if partner is None:
+                raise RuntimeError(
+                    "expected multichannel partner not found for "
+                    f"{process} {possible_order}"
+                )
+            if partner in partners:
+                raise RuntimeError(
+                    f"duplicate multichannel partner for {process} {possible_order}"
+                )
+            partners.append(partner)
+        return replace(
+            record,
+            multichannel_partners=tuple(sorted(partners)),
+            identical_factor=1.0 / iden,
+        )
+
+    def _identical_particle_symmetry_factor(self, proc: ProcessTuple) -> float:
+        factor = 1.0
+        for particle in ALL_COLOURED:
+            factor *= max(1, math.factorial(proc[2:].count(particle)))
+        return factor
+
+    def _check_consistency(self) -> None:
+        all_processes: dict[ProcessTuple, float] = {}
+        for key in self._all_keys_sorted:
+            for record in self._phase_space_orders[key]:
+                proc = (
+                    record.process[0],
+                    record.process[1],
+                    *sorted(record.process[2:], key=lambda x: SORT_PARTICLES[x]),
+                )
+                all_processes[proc] = all_processes.get(proc, 0.0) + (
+                    record.identical_factor / len(record.multichannel_partners)
+                )
+        for proc, count in all_processes.items():
+            expected = self.expected_number_of_dual_amplitudes(proc)
+            if abs(count - expected) > 1e-5:
+                raise RuntimeError(
+                    f"inconsistent number of dual amplitudes for {proc}: "
+                    f"{count}, expected {expected}"
+                )
+
+    def expected_number_of_dual_amplitudes(self, proc: Sequence[str]) -> float:
+        nq = self._count_matching(proc, QUARKS)
+        ng = self._count_matching(proc, GLUONS)
+        if nq == 0:
+            return math.factorial(ng - 1)
+        return math.factorial(ng) * math.comb(ng + nq - 1, nq - 1) * math.factorial(nq)
+
+    def _count_matching(self, main: Sequence[str], check: Iterable[str]) -> int:
+        counts = Counter(main)
+        return sum(counts[item] for item in check if item in counts)
+
+
+def enumerate_processes(
+    process_string: str, options: ProcessOptions | None = None
+) -> ProcessEnumeration:
+    return ProcessEnumerator(options).enumerate(process_string)
diff --git a/pyamplicol/src/pyamplicol/models/builtin/process_ir.py b/pyamplicol/src/pyamplicol/models/builtin/process_ir.py
new file mode 100644
index 0000000000..374510bc1c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/process_ir.py
@@ -0,0 +1,220 @@
+# SPDX-License-Identifier: 0BSD
+"""Legacy built-in-SM process IR construction."""
+
+from __future__ import annotations
+
+from collections import Counter
+
+from ...processes.core_syntax import (
+    canonical_process_key,
+)
+from ...processes.ir import (
+    CanonicalProcessIR,
+    ColorEndpointSummary,
+    ColorRole,
+    LegSide,
+    ParticleStatistics,
+    ProcessLegIR,
+    ProcessSetEntryIR,
+    ProcessSetIR,
+    SourceOrientation,
+    WavefunctionFamily,
+)
+from .process_catalog import (
+    ANTI_PARTICLE,
+    ANTIQUARKS,
+    GLUONS,
+    PDGS,
+    QUARKS,
+    SINGLETS,
+)
+from .process_enumeration import ProcessEnumerator
+from .process_selection import enumerate_generic_process_set, enumerate_process_set
+from .process_types import (
+    BuiltinProcessOptions as ProcessOptions,
+)
+from .process_types import (
+    BuiltinProcessSetEntry as ProcessSetEntry,
+)
+
+_VECTOR_NAMES = frozenset({"a", "z", "w+", "w-"})
+
+
+def build_process_ir(
+    process: str,
+    *,
+    color_accuracy: str = "lc",
+    options: ProcessOptions | None = None,
+) -> CanonicalProcessIR:
+    parsed = ProcessEnumerator(options).parse(process)
+    physical_initial = tuple(
+        particle if particle in {"p", "j"} else ANTI_PARTICLE[particle]
+        for particle in parsed.initial_state
+    )
+    canonical = f"{' '.join(physical_initial)} > {' '.join(parsed.rest)}"
+    legs = tuple(
+        [
+            *(
+                _leg_ir(
+                    label=index + 1,
+                    side="initial",
+                    particle=particle,
+                    outgoing_particle=parsed.initial_state[index],
+                )
+                for index, particle in enumerate(physical_initial)
+            ),
+            *(
+                _leg_ir(
+                    label=index + 3,
+                    side="final",
+                    particle=particle,
+                    outgoing_particle=particle,
+                )
+                for index, particle in enumerate(parsed.rest)
+            ),
+        ]
+    )
+    counts = Counter(leg.color_role for leg in legs)
+    return CanonicalProcessIR(
+        process=canonical,
+        key=canonical_process_key(canonical),
+        color_accuracy=color_accuracy,
+        legs=legs,
+        color_endpoints=ColorEndpointSummary(
+            fundamental_count=counts["fundamental"],
+            antifundamental_count=counts["antifundamental"],
+            pair_count=min(
+                counts["fundamental"],
+                counts["antifundamental"],
+            ),
+        ),
+    )
+
+
+def build_process_set_ir(
+    process_string: str,
+    *,
+    color_accuracy: str = "lc",
+    options: ProcessOptions | None = None,
+    generic: bool = False,
+    max_quark_pairs: int | None = None,
+) -> ProcessSetIR:
+    enumeration = (
+        enumerate_generic_process_set(
+            process_string,
+            options=options,
+            max_quark_pairs=max_quark_pairs,
+        )
+        if generic
+        else enumerate_process_set(process_string, options=options)
+    )
+    entries = tuple(
+        _process_set_entry_ir(entry, color_accuracy=color_accuracy)
+        for entry in enumeration.entries
+    )
+    return ProcessSetIR(
+        request=enumeration.request,
+        color_accuracy=color_accuracy,
+        entries=entries,
+    )
+
+
+def _process_set_entry_ir(
+    entry: ProcessSetEntry,
+    *,
+    color_accuracy: str,
+) -> ProcessSetEntryIR:
+    ir = build_process_ir(
+        entry.process,
+        color_accuracy=color_accuracy,
+        options=entry.enumeration.options,
+    )
+    return ProcessSetEntryIR(
+        key=entry.key,
+        process=entry.process,
+        ir=ir,
+        n_groups=len(entry.enumeration.groups),
+        n_records=entry.enumeration.n_records,
+        n_unique_processes=len(entry.enumeration.unique_processes),
+    )
+
+
+def _leg_ir(
+    *,
+    label: int,
+    side: LegSide,
+    particle: str,
+    outgoing_particle: str,
+) -> ProcessLegIR:
+    statistics, wavefunction_family, color_role, source_orientation = _structural_roles(
+        outgoing_particle
+    )
+    return ProcessLegIR(
+        label=label,
+        side=side,
+        particle=particle,
+        outgoing_particle=outgoing_particle,
+        pdg=_pdg_or_none(particle),
+        outgoing_pdg=_pdg_or_none(outgoing_particle),
+        statistics=statistics,
+        wavefunction_family=wavefunction_family,
+        color_role=color_role,
+        source_orientation=source_orientation,
+    )
+
+
+def _pdg_or_none(particle: str) -> int | None:
+    if particle in {"p", "j"}:
+        return None
+    return int(PDGS[particle])
+
+
+def _structural_roles(
+    outgoing_particle: str,
+) -> tuple[
+    ParticleStatistics,
+    WavefunctionFamily,
+    ColorRole,
+    SourceOrientation,
+]:
+    if outgoing_particle in {"p", "j"}:
+        return "inclusive", "inclusive", "inclusive", "inclusive"
+
+    pdg = abs(int(PDGS[outgoing_particle]))
+    if (
+        outgoing_particle in QUARKS
+        or outgoing_particle in ANTIQUARKS
+        or pdg in {11, 12, 13, 14, 15, 16}
+    ):
+        statistics: ParticleStatistics = "fermion"
+        wavefunction_family: WavefunctionFamily = "fermion"
+    elif outgoing_particle in GLUONS or outgoing_particle in _VECTOR_NAMES:
+        statistics = "boson"
+        wavefunction_family = "vector"
+    elif outgoing_particle == "h" or outgoing_particle in SINGLETS:
+        statistics = "boson"
+        wavefunction_family = "scalar"
+    else:
+        raise ValueError(f"unknown built-in particle role for {outgoing_particle!r}")
+
+    color_role: ColorRole
+    if outgoing_particle in QUARKS:
+        color_role = "fundamental"
+    elif outgoing_particle in ANTIQUARKS:
+        color_role = "antifundamental"
+    elif outgoing_particle in GLUONS:
+        color_role = "adjoint"
+    else:
+        color_role = "singlet"
+
+    if ANTI_PARTICLE[outgoing_particle] == outgoing_particle:
+        source_orientation: SourceOrientation = "self-conjugate"
+    elif int(PDGS[outgoing_particle]) > 0:
+        source_orientation = "particle"
+    else:
+        source_orientation = "antiparticle"
+
+    return statistics, wavefunction_family, color_role, source_orientation
+
+
+__all__ = ["build_process_ir", "build_process_set_ir"]
diff --git a/pyamplicol/src/pyamplicol/models/builtin/process_selection.py b/pyamplicol/src/pyamplicol/models/builtin/process_selection.py
new file mode 100644
index 0000000000..42e0d2b787
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/process_selection.py
@@ -0,0 +1,595 @@
+# SPDX-License-Identifier: 0BSD
+"""Legacy built-in-SM process-set selection and compatibility reporting."""
+
+from __future__ import annotations
+
+import itertools
+import time
+from collections import Counter
+from collections.abc import Sequence
+
+from ...processes.core_syntax import (
+    ProcessTuple,
+    _tokenize_side,
+    canonical_process_key,
+    expand_process_variants,
+)
+from .process_catalog import (
+    ANTI_PARTICLE,
+    ANTIQUARKS,
+    QUARKS,
+    SORT_PARTICLES,
+    concrete_processes_from_inclusive_enumeration,
+    process_uses_inclusive_labels,
+    request_allows_charged_current,
+    selection_metadata,
+)
+from .process_enumeration import ProcessEnumerator
+from .process_types import (
+    BuiltinPhaseSpaceGroup as PhaseSpaceGroup,
+)
+from .process_types import (
+    BuiltinProcessEnumeration as ProcessEnumeration,
+)
+from .process_types import (
+    BuiltinProcessOptions as ProcessOptions,
+)
+from .process_types import (
+    BuiltinProcessSelectionRecord as ProcessSelectionRecord,
+)
+from .process_types import (
+    BuiltinProcessSelectionReport as ProcessSelectionReport,
+)
+from .process_types import (
+    BuiltinProcessSetEntry as ProcessSetEntry,
+)
+from .process_types import (
+    BuiltinProcessSetEnumeration as ProcessSetEnumeration,
+)
+from .process_types import (
+    BuiltinSubprocessRecord as SubprocessRecord,
+)
+
+
+def enumerate_process_set(
+    process_string: str,
+    options: ProcessOptions | None = None,
+) -> ProcessSetEnumeration:
+    active_options = options or ProcessOptions()
+    entries: list[ProcessSetEntry] = []
+    seen: set[str] = set()
+    for process in expand_process_variants(process_string):
+        inclusive_enumeration: ProcessEnumeration | None = None
+        if process_uses_inclusive_labels(process):
+            inclusive_enumeration = ProcessEnumerator(active_options).enumerate(process)
+            concrete_processes = concrete_processes_from_inclusive_enumeration(
+                inclusive_enumeration
+            )
+        else:
+            concrete_processes = (process,)
+        for concrete_process in concrete_processes:
+            key = canonical_process_key(concrete_process)
+            if key in seen:
+                continue
+            seen.add(key)
+            enumeration = ProcessEnumerator(active_options).enumerate(concrete_process)
+            if enumeration.n_records == 0:
+                continue
+            entries.append(
+                ProcessSetEntry(
+                    key=key,
+                    process=concrete_process,
+                    enumeration=enumeration,
+                )
+            )
+    if not entries:
+        raise ValueError(f"no valid processes found for {process_string!r}")
+    return ProcessSetEnumeration(
+        request=process_string,
+        options=active_options,
+        entries=tuple(entries),
+    )
+
+
+def enumerate_generic_process_set(
+    process_string: str,
+    options: ProcessOptions | None = None,
+    *,
+    max_quark_pairs: int | None = None,
+    use_prefilter: bool = True,
+) -> ProcessSetEnumeration:
+    """Expand process-set syntax for generic DAG generation.
+
+    The generic compiler only needs concrete subprocess keys and parser
+    metadata.  It should not pay the legacy phase-space/color-order enumeration
+    cost for an already concrete partonic process; colour sectors and closures
+    are discovered later by the model-driven DAG.  Inclusive ``p``/``j``
+    requests still use the legacy enumerator once to obtain concrete children.
+    """
+
+    active_options = options or ProcessOptions()
+    report = build_generic_process_selection_report(
+        process_string,
+        active_options,
+        max_quark_pairs=max_quark_pairs,
+        use_prefilter=use_prefilter,
+    )
+    if not report.entries:
+        raise ValueError(f"no valid processes found for {process_string!r}")
+    return ProcessSetEnumeration(
+        request=process_string,
+        options=active_options,
+        entries=report.entries,
+        selection_report=report,
+    )
+
+
+def build_generic_process_selection_report(
+    process_string: str,
+    options: ProcessOptions | None = None,
+    *,
+    max_quark_pairs: int | None = None,
+    use_prefilter: bool = True,
+) -> ProcessSelectionReport:
+    """Return selected generic subprocesses plus enumeration diagnostics."""
+
+    started = time.perf_counter()
+    active_options = options or ProcessOptions()
+    entries: list[ProcessSetEntry] = []
+    seen: set[str] = set()
+    records: list[ProcessSelectionRecord] = []
+    rejection_counts: Counter[str] = Counter()
+    candidate_count = 0
+    evaluated_count = 0
+    stage_timings: list[tuple[str, float]] = []
+
+    stage_started = time.perf_counter()
+    variants = expand_process_variants(process_string)
+    stage_timings.append(("expand", time.perf_counter() - stage_started))
+
+    stage_started = time.perf_counter()
+    for process in variants:
+        if use_prefilter:
+            result = _generic_selection_records_from_request(
+                process,
+                active_options,
+                max_quark_pairs=max_quark_pairs,
+                seen=seen,
+            )
+        else:
+            result = _legacy_selection_records_from_request(
+                process,
+                active_options,
+                max_quark_pairs=max_quark_pairs,
+                seen=seen,
+            )
+        candidate_count += result[0]
+        evaluated_count += result[1]
+        rejection_counts.update(result[2])
+        records.extend(result[3])
+    stage_timings.append(("prefilter", time.perf_counter() - stage_started))
+
+    stage_started = time.perf_counter()
+    for record in records:
+        if record.status != "selected":
+            continue
+        enumeration = _lightweight_concrete_process_enumeration(
+            record.process,
+            active_options,
+        )
+        if enumeration.n_records == 0:
+            rejection_counts["model-reachability"] += 1
+            continue
+        entries.append(
+            ProcessSetEntry(
+                key=record.key,
+                process=record.process,
+                enumeration=enumeration,
+            )
+        )
+    stage_timings.append(("canonicalize", time.perf_counter() - stage_started))
+    duplicate_count = sum(1 for record in records if record.status == "duplicate")
+    selected_count = len(entries)
+    rejected_count = candidate_count - selected_count - duplicate_count
+    return ProcessSelectionReport(
+        request=process_string,
+        options=active_options,
+        entries=tuple(entries),
+        records=tuple(records),
+        candidate_count=candidate_count,
+        evaluated_count=evaluated_count,
+        selected_count=selected_count,
+        duplicate_count=duplicate_count,
+        rejected_count=max(rejected_count, 0),
+        rejection_counts=tuple(sorted(rejection_counts.items())),
+        stage_timings=tuple(stage_timings),
+        elapsed_s=time.perf_counter() - started,
+        prefilter_enabled=use_prefilter,
+    )
+
+
+def _generic_selection_records_from_request(
+    process: str,
+    options: ProcessOptions,
+    *,
+    max_quark_pairs: int | None,
+    seen: set[str],
+) -> tuple[int, int, Counter[str], list[ProcessSelectionRecord]]:
+    if process_uses_inclusive_labels(process):
+        return _prefilter_inclusive_request(
+            process,
+            options,
+            max_quark_pairs=max_quark_pairs,
+            seen=seen,
+        )
+    return _classify_concrete_request(
+        process,
+        options,
+        max_quark_pairs=max_quark_pairs,
+        seen=seen,
+        source=process,
+        symmetric_initial=False,
+    )
+
+
+def _legacy_selection_records_from_request(
+    process: str,
+    options: ProcessOptions,
+    *,
+    max_quark_pairs: int | None,
+    seen: set[str],
+) -> tuple[int, int, Counter[str], list[ProcessSelectionRecord]]:
+    if process_uses_inclusive_labels(process):
+        enumeration = ProcessEnumerator(options).enumerate(process)
+        concrete_processes = concrete_processes_from_inclusive_enumeration(enumeration)
+    else:
+        concrete_processes = (process,)
+    records: list[ProcessSelectionRecord] = []
+    rejection_counts: Counter[str] = Counter()
+    candidate_count = 0
+    evaluated_count = 0
+    for concrete_process in concrete_processes:
+        result = _classify_concrete_request(
+            concrete_process,
+            options,
+            max_quark_pairs=max_quark_pairs,
+            seen=seen,
+            source=process,
+            symmetric_initial=False,
+        )
+        candidate_count += result[0]
+        evaluated_count += result[1]
+        rejection_counts.update(result[2])
+        records.extend(result[3])
+    return candidate_count, evaluated_count, rejection_counts, records
+
+
+def _classify_concrete_request(
+    process: str,
+    options: ProcessOptions,
+    *,
+    max_quark_pairs: int | None,
+    seen: set[str],
+    source: str,
+    symmetric_initial: bool,
+) -> tuple[int, int, Counter[str], list[ProcessSelectionRecord]]:
+    enumerator = ProcessEnumerator(options)
+    request = enumerator.parse(process)
+    physical_initial = tuple(ANTI_PARTICLE[p] for p in request.initial_state)
+    final_state = tuple(request.rest)
+    return _classify_physical_candidate(
+        enumerator,
+        physical_initial,
+        final_state,
+        source=source,
+        allow_charged_current=request_allows_charged_current(request),
+        max_quark_pairs=max_quark_pairs,
+        seen=seen,
+        symmetric_initial=symmetric_initial,
+    )
+
+
+def _prefilter_inclusive_request(
+    process: str,
+    options: ProcessOptions,
+    *,
+    max_quark_pairs: int | None,
+    seen: set[str],
+) -> tuple[int, int, Counter[str], list[ProcessSelectionRecord]]:
+    enumerator = ProcessEnumerator(options)
+    request = enumerator.parse(process)
+    initial_options: list[tuple[str, ...]] = []
+    parton_options = tuple(
+        sorted(enumerator.massless_qcd, key=lambda p: SORT_PARTICLES[p])
+    )
+    for crossed_particle in request.initial_state:
+        if crossed_particle in {"p", "j"}:
+            initial_options.append(parton_options)
+        else:
+            initial_options.append((ANTI_PARTICLE[crossed_particle],))
+
+    symmetric_initial = (
+        len(request.initial_state) == 2
+        and request.initial_state[0] == request.initial_state[1]
+        and request.initial_state[0] in {"p", "j"}
+    )
+    final_candidates = tuple(
+        _generic_final_candidate(request.rest, jets)
+        for jets in itertools.combinations_with_replacement(
+            parton_options,
+            request.jet_count,
+        )
+    )
+    final_by_charge: Counter[int] = Counter(
+        final_charge for _, final_charge, _, _, _ in final_candidates
+    )
+    final_by_charge_family: Counter[tuple[int, int]] = Counter(
+        (final_charge, final_family)
+        for _, final_charge, final_family, _, _ in final_candidates
+    )
+    bucketed_finals: dict[
+        tuple[int, int | None], list[tuple[ProcessTuple, int, int, int, int]]
+    ] = {}
+    for candidate in final_candidates:
+        final_state, final_charge, final_family, _, _ = candidate
+        del final_state
+        bucketed_finals.setdefault((final_charge, None), []).append(candidate)
+        bucketed_finals.setdefault((final_charge, final_family), []).append(candidate)
+
+    allow_charged_current = request_allows_charged_current(request)
+    records: list[ProcessSelectionRecord] = []
+    rejection_counts: Counter[str] = Counter()
+    candidate_count = 0
+    evaluated_count = 0
+    for initial_state in itertools.product(*initial_options):
+        crossed_initial = tuple(ANTI_PARTICLE[p] for p in initial_state)
+        initial_charge = _charge3_sum(crossed_initial)
+        initial_family = _family_sum(crossed_initial)
+        candidate_count += len(final_candidates)
+        charge_key = -initial_charge
+        charge_matches = final_by_charge[charge_key]
+        rejection_counts["charge"] += len(final_candidates) - charge_matches
+        if options.include_cc:
+            candidate_bucket = bucketed_finals.get((charge_key, None), ())
+        else:
+            family_key = -initial_family
+            family_matches = final_by_charge_family[(charge_key, family_key)]
+            rejection_counts["fermion-family"] += charge_matches - family_matches
+            candidate_bucket = bucketed_finals.get((charge_key, family_key), ())
+        for final_state, _, _, _, _ in candidate_bucket:
+            result = _classify_physical_candidate(
+                enumerator,
+                initial_state,
+                final_state,
+                source=process,
+                allow_charged_current=allow_charged_current,
+                max_quark_pairs=max_quark_pairs,
+                seen=seen,
+                symmetric_initial=symmetric_initial,
+                prechecked_charge_family=True,
+            )
+            candidate_count += result[0] - 1
+            evaluated_count += result[1]
+            rejection_counts.update(result[2])
+            records.extend(result[3])
+    return candidate_count, evaluated_count, rejection_counts, records
+
+
+def _classify_physical_candidate(
+    enumerator: ProcessEnumerator,
+    physical_initial: Sequence[str],
+    final_state: Sequence[str],
+    *,
+    source: str,
+    allow_charged_current: bool,
+    max_quark_pairs: int | None,
+    seen: set[str],
+    symmetric_initial: bool,
+    prechecked_charge_family: bool = False,
+) -> tuple[int, int, Counter[str], list[ProcessSelectionRecord]]:
+    display_process = _canonical_physical_process(
+        physical_initial,
+        final_state,
+        symmetric_initial=symmetric_initial,
+    )
+    canonical_initial, _, canonical_final = display_process.partition(">")
+    canonical_crossed_initial = tuple(
+        ANTI_PARTICLE[p] for p in _tokenize_side(canonical_initial.strip())
+    )
+    canonical_final_state = tuple(_tokenize_side(canonical_final.strip()))
+    all_outgoing = (*canonical_crossed_initial, *canonical_final_state)
+    charge3 = _charge3_sum(all_outgoing)
+    family = _family_sum(all_outgoing)
+    quark_lines = _quark_pair_count(all_outgoing)
+    records: list[ProcessSelectionRecord] = []
+    rejection_counts: Counter[str] = Counter()
+    evaluated_count = 1
+    reason = ""
+    if not prechecked_charge_family and charge3 != 0:
+        reason = "charge"
+    elif (
+        not prechecked_charge_family
+        and not enumerator.options.include_cc
+        and family != 0
+    ):
+        reason = "fermion-family"
+    elif max_quark_pairs is not None and quark_lines > int(max_quark_pairs):
+        reason = "max-quark-lines"
+    elif _single_impossible_colored_state(all_outgoing):
+        reason = "single-coloured-state"
+    elif not _valid_generic_process(
+        enumerator,
+        all_outgoing,
+        allow_charged_current=allow_charged_current,
+    ):
+        reason = "model-reachability"
+
+    key = canonical_process_key(display_process)
+    dedupe_key = _process_dedupe_signature(
+        physical_initial,
+        final_state,
+        symmetric_initial=symmetric_initial,
+    )
+    if reason:
+        rejection_counts[reason] += 1
+        return 1, evaluated_count, rejection_counts, []
+    if dedupe_key in seen:
+        records.append(
+            ProcessSelectionRecord(
+                source=source,
+                process=display_process,
+                key=key,
+                status="duplicate",
+                reason="canonical-duplicate",
+                quark_lines=quark_lines,
+                charge3=charge3,
+                family=family,
+            )
+        )
+        return 1, evaluated_count, rejection_counts, records
+    seen.add(dedupe_key)
+    records.append(
+        ProcessSelectionRecord(
+            source=source,
+            process=display_process,
+            key=key,
+            status="selected",
+            reason="selected",
+            quark_lines=quark_lines,
+            charge3=charge3,
+            family=family,
+        )
+    )
+    return 1, evaluated_count, rejection_counts, records
+
+
+def _canonical_physical_process(
+    initial_state: Sequence[str],
+    final_state: Sequence[str],
+    *,
+    symmetric_initial: bool,
+) -> str:
+    initial = tuple(initial_state)
+    if symmetric_initial:
+        initial = tuple(sorted(initial, key=lambda particle: SORT_PARTICLES[particle]))
+    final = tuple(final_state)
+    return f"{' '.join(initial)} > {' '.join(final)}"
+
+
+def _process_dedupe_signature(
+    initial_state: Sequence[str],
+    final_state: Sequence[str],
+    *,
+    symmetric_initial: bool,
+) -> str:
+    initial = tuple(initial_state)
+    if symmetric_initial:
+        initial = tuple(sorted(initial, key=lambda particle: SORT_PARTICLES[particle]))
+    final = tuple(sorted(final_state, key=lambda particle: SORT_PARTICLES[particle]))
+    return f"{' '.join(initial)} > {' '.join(final)}"
+
+
+def _single_impossible_colored_state(process: Sequence[str]) -> bool:
+    return (
+        sum(1 for particle in process if selection_metadata(particle).is_colored) == 1
+    )
+
+
+def _valid_generic_process(
+    enumerator: ProcessEnumerator,
+    process: Sequence[str],
+    *,
+    allow_charged_current: bool,
+) -> bool:
+    if enumerator._valid_process(
+        process,
+        allow_charged_current=allow_charged_current,
+    ):
+        return True
+    if any(selection_metadata(particle).is_colored for particle in process):
+        return False
+    if _charge3_sum(process) != 0:
+        return False
+    return enumerator.options.include_cc or _family_sum(process) == 0
+
+
+def _quark_pair_count(process: Sequence[str]) -> int:
+    quarks, antiquarks = _quark_counts(process)
+    return min(quarks, antiquarks)
+
+
+def _charge3_sum(process: Sequence[str]) -> int:
+    return sum(selection_metadata(particle).charge3 for particle in process)
+
+
+def _family_sum(process: Sequence[str]) -> int:
+    return sum(selection_metadata(particle).family for particle in process)
+
+
+def _quark_counts(process: Sequence[str]) -> tuple[int, int]:
+    counts = Counter(process)
+    quarks = sum(counts[item] for item in QUARKS if item in counts)
+    antiquarks = sum(counts[item] for item in ANTIQUARKS if item in counts)
+    return quarks, antiquarks
+
+
+def _generic_final_candidate(
+    rest: Sequence[str],
+    jets: Sequence[str],
+) -> tuple[ProcessTuple, int, int, int, int]:
+    final_state = tuple(
+        sorted(
+            (*rest, *jets),
+            key=lambda particle: SORT_PARTICLES[particle],
+        )
+    )
+    quarks, antiquarks = _quark_counts(final_state)
+    return (
+        final_state,
+        _charge3_sum(final_state),
+        _family_sum(final_state),
+        quarks,
+        antiquarks,
+    )
+
+
+def _lightweight_concrete_process_enumeration(
+    process: str,
+    options: ProcessOptions,
+) -> ProcessEnumeration:
+    enumerator = ProcessEnumerator(options)
+    request = enumerator.parse(process)
+    all_outgoing = (*request.initial_state, *request.rest)
+    if not _valid_generic_process(
+        enumerator,
+        all_outgoing,
+        allow_charged_current=request_allows_charged_current(request),
+    ):
+        return ProcessEnumeration(
+            request=request,
+            options=options,
+            unique_processes=(),
+            groups=(),
+        )
+    order = tuple(range(len(all_outgoing)))
+    return ProcessEnumeration(
+        request=request,
+        options=options,
+        unique_processes=(
+            tuple(sorted(all_outgoing, key=lambda item: SORT_PARTICLES[item])),
+        ),
+        groups=(
+            PhaseSpaceGroup(
+                group_id=1,
+                phase_space_order=order,
+                records=(
+                    SubprocessRecord(
+                        process=tuple(all_outgoing),
+                        color_order=order,
+                        multichannel_partners=(0,),
+                        identical_factor=1.0,
+                    ),
+                ),
+            ),
+        ),
+    )
diff --git a/pyamplicol/src/pyamplicol/models/builtin/process_types.py b/pyamplicol/src/pyamplicol/models/builtin/process_types.py
new file mode 100644
index 0000000000..27ddcb4ba6
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/process_types.py
@@ -0,0 +1,135 @@
+# SPDX-License-Identifier: 0BSD
+"""Built-in-SM process enumeration and selection records.
+
+These records describe the historical built-in process catalogue.  They are
+not part of the model-neutral process syntax or external-model API.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ...processes.core_syntax import OrderTuple, ProcessTuple
+
+
+@dataclass(frozen=True)
+class BuiltinParsedProcess:
+    initial_state: ProcessTuple
+    jet_count: int
+    rest: ProcessTuple
+    leptons: ProcessTuple = ()
+
+
+@dataclass(frozen=True)
+class BuiltinProcessOptions:
+    flavour_scheme: int = 5
+    include_3qqbar: bool = False
+    include_cc: bool = False
+    include_resonance: bool = False
+    serial: bool = True
+
+
+@dataclass(frozen=True)
+class BuiltinSubprocessRecord:
+    process: ProcessTuple
+    color_order: OrderTuple
+    multichannel_partners: tuple[int, ...] = ()
+    identical_factor: float = 1.0
+
+
+@dataclass(frozen=True)
+class BuiltinPhaseSpaceGroup:
+    group_id: int
+    phase_space_order: OrderTuple
+    records: tuple[BuiltinSubprocessRecord, ...]
+
+
+@dataclass(frozen=True)
+class BuiltinProcessEnumeration:
+    request: BuiltinParsedProcess
+    options: BuiltinProcessOptions
+    unique_processes: tuple[ProcessTuple, ...]
+    groups: tuple[BuiltinPhaseSpaceGroup, ...]
+
+    @property
+    def n_external(self) -> int:
+        if self.unique_processes:
+            return len(self.unique_processes[0])
+        if self.groups and self.groups[0].records:
+            return len(self.groups[0].records[0].process)
+        return 0
+
+    @property
+    def n_records(self) -> int:
+        return sum(len(group.records) for group in self.groups)
+
+
+@dataclass(frozen=True)
+class BuiltinProcessSetEntry:
+    key: str
+    process: str
+    enumeration: BuiltinProcessEnumeration
+
+
+@dataclass(frozen=True)
+class BuiltinProcessSelectionRecord:
+    source: str
+    process: str
+    key: str
+    status: str
+    reason: str
+    quark_lines: int
+    charge3: int
+    family: int
+
+
+@dataclass(frozen=True)
+class BuiltinProcessSelectionReport:
+    request: str
+    options: BuiltinProcessOptions
+    entries: tuple[BuiltinProcessSetEntry, ...]
+    records: tuple[BuiltinProcessSelectionRecord, ...]
+    candidate_count: int
+    evaluated_count: int
+    selected_count: int
+    duplicate_count: int
+    rejected_count: int
+    rejection_counts: tuple[tuple[str, int], ...]
+    stage_timings: tuple[tuple[str, float], ...]
+    elapsed_s: float
+    prefilter_enabled: bool
+
+    @property
+    def selected_records(self) -> tuple[BuiltinProcessSelectionRecord, ...]:
+        return tuple(record for record in self.records if record.status == "selected")
+
+    @property
+    def duplicate_records(self) -> tuple[BuiltinProcessSelectionRecord, ...]:
+        return tuple(record for record in self.records if record.status == "duplicate")
+
+
+@dataclass(frozen=True)
+class BuiltinProcessSetEnumeration:
+    request: str
+    options: BuiltinProcessOptions
+    entries: tuple[BuiltinProcessSetEntry, ...]
+    selection_report: BuiltinProcessSelectionReport | None = None
+
+    @property
+    def default_key(self) -> str:
+        if not self.entries:
+            raise ValueError("process set is empty")
+        return self.entries[0].key
+
+
+__all__ = [
+    "BuiltinParsedProcess",
+    "BuiltinPhaseSpaceGroup",
+    "BuiltinProcessEnumeration",
+    "BuiltinProcessOptions",
+    "BuiltinProcessSelectionRecord",
+    "BuiltinProcessSelectionReport",
+    "BuiltinProcessSetEntry",
+    "BuiltinProcessSetEnumeration",
+    "BuiltinSubprocessRecord",
+]
diff --git a/pyamplicol/src/pyamplicol/models/builtin/symbols.py b/pyamplicol/src/pyamplicol/models/builtin/symbols.py
new file mode 100644
index 0000000000..713273220b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/symbols.py
@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from functools import cached_property
+from typing import Any
+
+from ..._internal.physics.symbols import SymbolRegistry
+
+
+class BuiltinSymbolRegistry(SymbolRegistry):
+    """Symbolica heads owned exclusively by built-in-SM lowering."""
+
+    @cached_property
+    def antisymmetric_lorentz_pair_name(self) -> str:
+        return self.qualified_name("antisymmetric_lorentz_pair")
+
+    @cached_property
+    def weyl_spinor_name(self) -> str:
+        return self.qualified_name("weyl_spinor")
+
+    def vertex_kind_tensor_name(self, kind: int) -> str:
+        return self.qualified_name(f"vertex_kind_{int(kind)}")
+
+    def label(self, labels: tuple[int, ...]) -> Any:
+        return self.symbol("label::" + "_".join(str(label) for label in labels))
+
+    @cached_property
+    def two_gluon_to_tensor_name(self) -> str:
+        return self.qualified_name("two_gluon_to_tensor")
+
+    @cached_property
+    def tensor_gluon_to_gluon_name(self) -> str:
+        return self.qualified_name("tensor_gluon_to_gluon")
+
+    @cached_property
+    def gluon_tensor_to_gluon_name(self) -> str:
+        return self.qualified_name("gluon_tensor_to_gluon")
+
+    @cached_property
+    def quark_vector_weyl_plus_name(self) -> str:
+        return self.qualified_name("quark_vector_weyl_plus")
+
+    @cached_property
+    def quark_vector_weyl_minus_name(self) -> str:
+        return self.qualified_name("quark_vector_weyl_minus")
+
+    @cached_property
+    def current(self) -> Any:
+        return self.symbol("current")
+
+    @cached_property
+    def vertex(self) -> Any:
+        return self.symbol("vertex")
+
+    @cached_property
+    def assignment(self) -> Any:
+        return self.symbol("assign")
+
+    @cached_property
+    def amplitude(self) -> Any:
+        return self.symbol("amplitude")
+
+    @cached_property
+    def matrix_element_plan(self) -> Any:
+        return self.symbol("matrix_element_plan")
+
+    @cached_property
+    def momentum(self) -> Any:
+        return self.symbol("momentum")
+
+    @cached_property
+    def current_momentum(self) -> Any:
+        return self.symbol("current_momentum")
+
+    @cached_property
+    def polarization(self) -> Any:
+        return self.symbol("polarization")
+
+
+symbols = BuiltinSymbolRegistry()
+
+
+__all__ = ["BuiltinSymbolRegistry", "symbols"]
diff --git a/pyamplicol/src/pyamplicol/models/builtin/validation.py b/pyamplicol/src/pyamplicol/models/builtin/validation.py
new file mode 100644
index 0000000000..6894bda6ed
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/builtin/validation.py
@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: 0BSD
+"""Legacy built-in-SM validation kinematics."""
+
+from __future__ import annotations
+
+from ..._internal.physics.types import ExternalMomentum, NativeEvaluationError
+from ...generation.phase_space import massive_rambo_final_state
+from .model import BuiltinSMModel
+from .process_ir import build_process_ir
+
+
+def legacy_rambo_z_gluon_point(
+    process: str,
+    model: BuiltinSMModel,
+    *,
+    gluon_count: int,
+    sqrt_s: float,
+    seed: int,
+) -> tuple[ExternalMomentum, ...]:
+    """Generate a deterministic RAMBO point for q q~ -> Z + n g."""
+
+    if gluon_count < 1:
+        raise NativeEvaluationError("RAMBO Z-gluon points need at least one gluon")
+    z_mass = model.mass(23)
+    if sqrt_s <= z_mass:
+        raise NativeEvaluationError("sqrt(s) must be above the Z mass")
+    pdgs = _physical_pdgs(process)
+    expected = gluon_count + 3
+    if len(pdgs) != expected:
+        raise NativeEvaluationError(
+            f"expected {expected} external particles for q q~ -> Z + {gluon_count} g"
+        )
+    final_pdgs = (*((21,) * gluon_count), 23)
+    final_masses = tuple(0.0 if pdg == 21 else model.mass(pdg) for pdg in final_pdgs)
+    if sum(final_masses) >= sqrt_s:
+        raise NativeEvaluationError("final-state masses exceed sqrt(s)")
+    final_momenta = massive_rambo_final_state(
+        len(final_masses),
+        sqrt_s=sqrt_s,
+        masses=final_masses,
+        seed=seed,
+    )
+    beam_energy = 0.5 * sqrt_s
+    return (
+        ExternalMomentum(pdgs[0], (beam_energy, 0.0, 0.0, beam_energy)),
+        ExternalMomentum(pdgs[1], (beam_energy, 0.0, 0.0, -beam_energy)),
+        *(
+            ExternalMomentum(pdg, momentum)
+            for pdg, momentum in zip(final_pdgs, final_momenta, strict=True)
+        ),
+    )
+
+
+def generic_validation_point(
+    process: str,
+    *,
+    model: BuiltinSMModel | None = None,
+    sqrt_s: float | None = None,
+    seed: int = 101,
+) -> tuple[ExternalMomentum, ...]:
+    """Return deterministic two-beam kinematics for a built-in-SM process."""
+
+    model = model or BuiltinSMModel()
+    ir = build_process_ir(process)
+    initial_pdgs = tuple(int(pdg) for pdg in ir.initial_pdgs)
+    final_pdgs = tuple(int(pdg) for pdg in ir.final_pdgs)
+    if len(initial_pdgs) != 2:
+        raise NativeEvaluationError(
+            "generic validation momenta currently require a two-body initial state"
+        )
+    if not final_pdgs:
+        raise NativeEvaluationError(
+            "generic validation momenta require at least one final-state particle"
+        )
+    final_masses = tuple(float(model.mass(pdg)) for pdg in final_pdgs)
+    threshold = sum(final_masses)
+    if sqrt_s is None:
+        sqrt_s = threshold if len(final_pdgs) == 1 else max(1000.0, threshold + 100.0)
+    if sqrt_s < threshold:
+        raise NativeEvaluationError("sqrt(s) is below the final-state mass threshold")
+    if len(final_pdgs) == 1:
+        if threshold <= 0.0:
+            raise NativeEvaluationError(
+                "no finite centre-of-mass validation point exists for one "
+                "massless final state"
+            )
+        final_momenta = ((float(sqrt_s), 0.0, 0.0, 0.0),)
+    else:
+        final_momenta = massive_rambo_final_state(
+            len(final_pdgs),
+            sqrt_s=float(sqrt_s),
+            masses=final_masses,
+            seed=seed,
+        )
+    beam_energy = 0.5 * float(sqrt_s)
+    return (
+        ExternalMomentum(initial_pdgs[0], (beam_energy, 0.0, 0.0, beam_energy)),
+        ExternalMomentum(initial_pdgs[1], (beam_energy, 0.0, 0.0, -beam_energy)),
+        *(
+            ExternalMomentum(pdg, momentum)
+            for pdg, momentum in zip(final_pdgs, final_momenta, strict=True)
+        ),
+    )
+
+
+def _physical_pdgs(process: str) -> tuple[int, ...]:
+    ir = build_process_ir(process)
+    return (*ir.initial_pdgs, *ir.final_pdgs)
+
+
+__all__ = ["generic_validation_point", "legacy_rambo_z_gluon_point"]
diff --git a/pyamplicol/src/pyamplicol/models/compiler.py b/pyamplicol/src/pyamplicol/models/compiler.py
new file mode 100644
index 0000000000..5f1671025b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler.py
@@ -0,0 +1,53 @@
+# SPDX-License-Identifier: 0BSD
+"""Compatibility facade for model IR compilation."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from .compiler_contact_trees import eager_color_singlet_vertex_term_components
+from .compiler_entry import compile_ufo_model_ir
+from .compiler_kernels import (
+    _as_expression as _as_expression,
+)
+from .compiler_kernels import (
+    _spin_representations as _spin_representations,
+)
+from .compiler_kernels import (
+    _spin_slots as _spin_slots,
+)
+from .compiler_records import (
+    _replace_evaluator_constants as _replace_evaluator_constants,
+)
+from .contracts import (
+    CompiledCouplingOrder,
+    CompiledCouplingRecord,
+    CompiledModelIR,
+    CompiledParameterRecord,
+    CompiledParticleRecord,
+    CompiledPropagatorRecord,
+    CompiledVertexTerm,
+)
+from .contracts import (
+    CompiledOrientedKernel as CompiledOrientedKernel,
+)
+
+
+def compile_builtin_model_ir(model: Mapping[str, object]) -> CompiledModelIR:
+    """Compile the built-in model without loading it on external-model imports."""
+    from .builtin.compiler import compile_model_ir
+
+    return compile_model_ir(model)
+
+__all__ = [
+    "CompiledCouplingOrder",
+    "CompiledCouplingRecord",
+    "CompiledModelIR",
+    "CompiledParameterRecord",
+    "CompiledParticleRecord",
+    "CompiledPropagatorRecord",
+    "CompiledVertexTerm",
+    "compile_builtin_model_ir",
+    "compile_ufo_model_ir",
+    "eager_color_singlet_vertex_term_components",
+]
diff --git a/pyamplicol/src/pyamplicol/models/compiler_auxiliary_components.py b/pyamplicol/src/pyamplicol/models/compiler_auxiliary_components.py
new file mode 100644
index 0000000000..e2eb9a867c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_auxiliary_components.py
@@ -0,0 +1,298 @@
+# SPDX-License-Identifier: 0BSD
+"""Remove unobservable components from compiler-owned contact-tree currents."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import replace
+
+from .._internal.physics.symbols import ModelSymbolRegistry
+from . import compiler_symbolica as _sym
+from .compiler_kernels import _canonicalize_oriented_kernel_component
+from .contracts import CompiledOrientedKernel, CompiledParticleRecord
+
+# A reduced component is a signed sum of original producer components.  Only
+# identical/opposite consumer columns are combined; no numerical rank decision
+# or parameter-dependent change of basis is involved.
+_ComponentGroup = tuple[tuple[int, int], ...]
+_ComponentBasis = tuple[_ComponentGroup, ...]
+
+
+def reduce_contact_auxiliary_components(
+    particles: Sequence[CompiledParticleRecord],
+    kernels: Sequence[CompiledOrientedKernel],
+    *,
+    auxiliary_particles: Sequence[CompiledParticleRecord],
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[tuple[CompiledParticleRecord, ...], tuple[CompiledOrientedKernel, ...]]:
+    """Reduce opaque auxiliaries before ordering/kernel preparation.
+
+    The caller supplies only its newly lowered contact-tree auxiliaries.  Their
+    sole consumers are oriented kernels: unlike physical particles and other
+    auxiliary representations, they have no wavefunctions, propagators, direct
+    contractions, or externally prescribed tensor basis to preserve.
+
+    For every input orientation, certify ``F(v) = sum_i C_i v_i`` exactly.  A
+    zero column is unused; columns ``C_i = +/- C_j`` need only the corresponding
+    signed sum of producer components.  All kernels and both input sides are
+    considered before changing any representation.  Repeat after a reduction
+    so that discarded downstream components can expose upstream reductions.
+    """
+    candidates = {particle.name for particle in auxiliary_particles}
+    particles, kernels = tuple(particles), tuple(kernels)
+    if not candidates:
+        return particles, kernels
+    _sym._ensure_symbolica()
+    while True:
+        bases: dict[str, _ComponentBasis] = {}
+        dimensions: dict[str, int] = {}
+        exact_kernels: dict[int, tuple[_sym.Expression, ...] | None] = {}
+        for particle in particles:
+            if (
+                particle.name not in candidates
+                or particle.spin != -1
+                or particle.propagating
+                or particle.propagator is not None
+                or particle.antiname != particle.name
+                or particle.component_dimension is None
+                or particle.component_dimension <= 1
+            ):
+                continue
+            involved = tuple(
+                kernel for kernel in kernels if particle.name in kernel.particles
+            )
+            producers = tuple(
+                kernel for kernel in involved if kernel.particles[2] == particle.name
+            )
+            # Basis-sensitive metadata is derived later, not rewritten here.
+            if not producers or any(
+                kernel.input_ordering_ids
+                or kernel.output_ordering_id
+                or kernel.evaluation_equivalence_verified
+                or any(
+                    name == particle.name and leg != -1
+                    for name, leg in zip(
+                        kernel.particles, kernel.source_particle_legs, strict=True
+                    )
+                )
+                for kernel in involved
+            ):
+                continue
+            dimension = particle.component_dimension
+            if any(
+                len(kernel.component_expressions) != dimension for kernel in producers
+            ):
+                continue
+            for kernel in involved:
+                if kernel.kind not in exact_kernels:
+                    exact_kernels[kernel.kind] = _exact_kernel_components(kernel)
+            # Algebra on an unsupported floating coefficient could round away
+            # a small difference. Leave that whole current basis untouched.
+            if any(exact_kernels[kernel.kind] is None for kernel in involved):
+                continue
+            basis = _consumer_basis(
+                particle.name,
+                dimension,
+                involved,
+                exact_kernels=exact_kernels,
+                model_symbols=model_symbols,
+            )
+            # Keep an entirely unobserved family unchanged: removing its last
+            # component would require eliminating the family, not a basis change.
+            if basis and len(basis) < dimension:
+                bases[particle.name] = basis
+                dimensions[particle.name] = dimension
+        if not bases:
+            return particles, kernels
+        particles = tuple(
+            replace(particle, component_dimension=len(bases[particle.name]))
+            if particle.name in bases
+            else particle
+            for particle in particles
+        )
+        kernels = tuple(
+            _reduce_kernel(
+                kernel,
+                bases,
+                dimensions,
+                exact_kernels=exact_kernels,
+                model_symbols=model_symbols,
+            )
+            for kernel in kernels
+        )
+
+
+def _exact_kernel_components(
+    kernel: CompiledOrientedKernel,
+) -> tuple[_sym.Expression, ...] | None:
+    """Admit only numeric atoms on which the change of basis is exact."""
+    from symbolica import AtomType
+
+    expressions = tuple(
+        _sym._exact_binary64_coefficients(_sym.E(source))
+        for source in kernel.component_expressions
+    )
+    pending = list(expressions)
+    checked: list[_sym.Expression] = []
+    exact_units = tuple(_sym.E(str(value)) for value in (0, 1, -1))
+    unit_replacements: list[_sym.Replacement] = []
+    imaginary_unit = _sym.E("1i")
+    while pending:
+        atom = pending.pop()
+        kind = atom.get_type()
+        if kind == AtomType.Var:
+            continue
+        if kind != AtomType.Num:
+            pending.extend(atom)
+            continue
+        if any(bool(atom.matches(previous)) for previous in checked):
+            continue
+        checked.append(atom)
+        # Numeric equality uses the exact stored rational value of Float atoms
+        # in Symbolica, including arbitrary precision. It therefore recognizes
+        # floating units without rounding a nearby coefficient onto that unit.
+        unit = next((value for value in exact_units if bool(atom == value)), None)
+        if unit is not None:
+            if not bool(atom.matches(unit)):
+                unit_replacements.append(_sym.Replacement(atom, unit))
+            continue
+        # Symbolica's rational-polynomial conversion rejects floats, but also
+        # complex rational numbers. Split the latter and require a literal
+        # roundtrip, so this check never promotes a rounded Float to a rational.
+        try:
+            real = ((atom + atom.conj()) / 2).to_rational_polynomial().to_expression()
+            imag = (
+                ((atom - atom.conj()) / (2 * imaginary_unit))
+                .to_rational_polynomial()
+                .to_expression()
+            )
+        except (TypeError, ValueError):
+            return None
+        if not bool(atom.matches(real + imaginary_unit * imag)):
+            return None
+    return tuple(
+        expression.replace_multiple(unit_replacements)
+        if unit_replacements
+        else expression
+        for expression in expressions
+    )
+
+
+def _consumer_basis(
+    particle: str,
+    dimension: int,
+    kernels: Sequence[CompiledOrientedKernel],
+    *,
+    exact_kernels: Mapping[int, tuple[_sym.Expression, ...] | None],
+    model_symbols: ModelSymbolRegistry,
+) -> _ComponentBasis | None:
+    zero = _sym.E("0")
+    columns: list[list[_sym.Expression]] = [[] for _ in range(dimension)]
+    for kernel in kernels:
+        for side, name in zip(("left", "right"), kernel.particles[:2], strict=True):
+            if name != particle:
+                continue
+            currents = tuple(
+                model_symbols.kernel_component(kernel.kind, side, index)
+                for index in range(dimension)
+            )
+            current_symbols = set(currents)
+            expressions = exact_kernels[kernel.kind]
+            assert expressions is not None
+            for expression in expressions:
+                expanded = expression.expand()
+                present = set(expanded.get_all_symbols(False))
+                try:
+                    coefficients = tuple(
+                        expanded.coefficient(current).expand()
+                        if current in present
+                        else zero
+                        for current in currents
+                    )
+                except (TypeError, ValueError):
+                    return None
+                if any(
+                    current_symbols.intersection(coefficient.get_all_symbols(False))
+                    for coefficient in coefficients
+                ):
+                    return None
+                reconstructed = sum(
+                    (
+                        coefficient * current
+                        for coefficient, current in zip(
+                            coefficients, currents, strict=True
+                        )
+                    ),
+                    zero,
+                )
+                if (expanded - reconstructed).expand().to_canonical_string() != "0":
+                    return None
+                for column, coefficient in zip(columns, coefficients, strict=True):
+                    column.append(coefficient)
+
+    groups: list[list[tuple[int, int]]] = []
+    known: dict[tuple[_sym.Expression, ...], tuple[int, int]] = {}
+    for index, column in enumerate(columns):
+        # Compare expanded atoms themselves, independently of text formatting
+        # and the parentheses chosen for complex numeric coefficients.
+        key = tuple(column)
+        if not key or all(value == zero for value in key):
+            continue
+        existing = known.get(key)
+        if existing is None:
+            group = len(groups)
+            groups.append([(index, 1)])
+            known[key] = (group, 1)
+            negative = tuple((-value).expand() for value in column)
+            known[negative] = (group, -1)
+        else:
+            group, sign = existing
+            groups[group].append((index, sign))
+    return tuple(tuple(group) for group in groups)
+
+
+def _reduce_kernel(
+    kernel: CompiledOrientedKernel,
+    bases: dict[str, _ComponentBasis],
+    dimensions: dict[str, int],
+    *,
+    exact_kernels: Mapping[int, tuple[_sym.Expression, ...] | None],
+    model_symbols: ModelSymbolRegistry,
+) -> CompiledOrientedKernel:
+    if not any(name in bases for name in kernel.particles):
+        return kernel
+    zero = _sym.E("0")
+    expressions = exact_kernels[kernel.kind]
+    assert expressions is not None
+    output_basis = bases.get(kernel.particles[2])
+    if output_basis is not None:
+        expressions = tuple(
+            sum((sign * expressions[index] for index, sign in group), zero)
+            for group in output_basis
+        )
+    replacements: list[_sym.Replacement] = []
+    for side, name in zip(("left", "right"), kernel.particles[:2], strict=True):
+        if name not in bases:
+            continue
+        representatives = {
+            group[0][0]: model_symbols.kernel_component(kernel.kind, side, index)
+            for index, group in enumerate(bases[name])
+        }
+        replacements.extend(
+            _sym.Replacement(
+                model_symbols.kernel_component(kernel.kind, side, index),
+                representatives.get(index, zero),
+            )
+            for index in range(dimensions[name])
+        )
+    return replace(
+        kernel,
+        component_expressions=tuple(
+            _canonicalize_oriented_kernel_component(
+                expression.replace_multiple(replacements)
+                if replacements
+                else expression
+            ).to_canonical_string()
+            for expression in expressions
+        ),
+    )
diff --git a/pyamplicol/src/pyamplicol/models/compiler_color_flow.py b/pyamplicol/src/pyamplicol/models/compiler_color_flow.py
new file mode 100644
index 0000000000..024df21180
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_color_flow.py
@@ -0,0 +1,527 @@
+# SPDX-License-Identifier: 0BSD
+"""Compiler-owned color-flow auxiliaries derived from proven model tensors."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Sequence
+from dataclasses import replace
+
+from .._internal.physics.symbols import ModelSymbolRegistry
+from . import compiler_symbolica as _sym
+from .compiler_kernels import (
+    _canonicalize_oriented_kernel_component,
+    _remap_kernel_symbols,
+)
+from .contracts import (
+    CompiledLCColorTransitionTerm,
+    CompiledOrientedKernel,
+    CompiledParticleRecord,
+    CompiledPropagatorRecord,
+    compiled_particle_component_dimension,
+)
+from .tensors import normalize_color_expression
+
+_U1_SUBTRACTION_AUXILIARY = "u1-subtraction-color-flow-vector"
+
+
+class _CompiledLCColorTransitionCompilation(tuple):
+    """Transition tuple carrying compiler-owned closure companions.
+
+    The oriented-kernel compiler call site predates recurrence closure
+    contracts and assigns only the transition tuple. ``CompiledOrientedKernel``
+    consumes this private companion immediately and persists the two catalogs
+    as separate fields.
+    """
+
+    compiler_closure_terms: tuple[CompiledLCColorTransitionTerm, ...]
+
+    def __new__(
+        cls,
+        transition_terms: tuple[CompiledLCColorTransitionTerm, ...],
+        closure_terms: tuple[CompiledLCColorTransitionTerm, ...],
+    ) -> _CompiledLCColorTransitionCompilation:
+        instance = super().__new__(cls, transition_terms)
+        instance.compiler_closure_terms = closure_terms
+        return instance
+
+
+def compile_lc_color_transition_terms(
+    kernel: CompiledOrientedKernel,
+    oriented_representations: tuple[int, int, int],
+    *,
+    proof_source: str,
+    provenance: tuple[tuple[str, str], ...] = (),
+    tensor_role_representations: tuple[int, int, int] | None = None,
+) -> tuple[CompiledLCColorTransitionTerm, ...]:
+    """Compile exact ordered-word operations from a certified local tensor.
+
+    This function is part of model compilation. Runtime and recurrence-builder
+    code consume its closed records and never repeat tensor-family inference.
+    """
+
+    structure = kernel.color_projection_structure
+    if structure is None:
+        raise ValueError(f"kernel {kernel.kind} has no certified color projection")
+    tensor_representations = (
+        oriented_representations
+        if tensor_role_representations is None
+        else tuple(int(value) for value in tensor_role_representations)
+    )
+    if tuple(abs(value) for value in tensor_representations) != tuple(
+        abs(value) for value in oriented_representations
+    ):
+        raise ValueError(
+            f"kernel {kernel.kind} tensor-role representations "
+            f"{tensor_representations!r} do not match its oriented current shapes "
+            f"{oriented_representations!r}"
+        )
+    shapes = tuple(_lc_color_shape(value) for value in oriented_representations)
+    result_shape = shapes[2]
+
+    def term(
+        permutation: tuple[int, int],
+        operation: str,
+        result_component_kind: str | None,
+        exact_factor_expression: str = "1",
+        *,
+        closure: bool = False,
+    ) -> CompiledLCColorTransitionTerm:
+        result_component_role = (
+            "passive"
+            if operation == "concatenate-join" and abs(output_representation) == 1
+            else "active"
+            if operation in {"concatenate-join", "inherit-left", "inherit-right"}
+            else "none"
+        )
+        payload = {
+            "color_expression": kernel.color_expression,
+            "color_source": kernel.color_source,
+            "exact_factor_expression": exact_factor_expression,
+            "input_permutation": list(permutation),
+            "input_shape_kinds": list(shapes[:2]),
+            "kernel_kind": kernel.kind,
+            "operation": operation,
+            "oriented_representations": list(oriented_representations),
+            "tensor_role_representations": list(tensor_representations),
+            "proof_source": proof_source,
+            "result_component_kind": result_component_kind,
+            "result_component_role": result_component_role,
+            "result_shape_kind": None if closure else result_shape,
+            "source_particle_legs": list(kernel.source_particle_legs),
+            "structure": structure,
+        }
+        digest = hashlib.sha256(
+            json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
+        ).hexdigest()
+        term_provenance = tuple(
+            sorted(
+                (
+                    ("compiler-proof-source", proof_source),
+                    (
+                        "contract-kind",
+                        "closure" if closure else "transition",
+                    ),
+                    ("kernel-kind", str(kernel.kind)),
+                    (
+                        "source-particle-legs",
+                        ",".join(str(value) for value in kernel.source_particle_legs),
+                    ),
+                    *provenance,
+                )
+            )
+        )
+        return CompiledLCColorTransitionTerm(
+            input_permutation=permutation,
+            reverse_parent_mask=0,
+            component_operation=operation,
+            result_component_kind=result_component_kind,
+            result_component_role=result_component_role,
+            input_shape_kinds=(shapes[0], shapes[1]),
+            result_shape_kind=None if closure else result_shape,
+            exact_factor_expression=exact_factor_expression,
+            proof_digest=digest,
+            provenance=term_provenance,
+        )
+
+    def compiled(
+        *transition_terms: CompiledLCColorTransitionTerm,
+    ) -> tuple[CompiledLCColorTransitionTerm, ...]:
+        left_representation, right_representation = oriented_representations[:2]
+        if abs(left_representation) == abs(right_representation) == 1:
+            closure_kind = None
+        elif {left_representation, right_representation} == {3, -3}:
+            closure_kind = "open-string"
+        elif left_representation == right_representation == 8:
+            closure_kind = "trace"
+        else:
+            closure_terms: tuple[CompiledLCColorTransitionTerm, ...] = ()
+            return _CompiledLCColorTransitionCompilation(
+                tuple(transition_terms),
+                closure_terms,
+            )
+        closure_terms = (
+            term(
+                (0, 1),
+                "close",
+                closure_kind,
+                closure=True,
+            ),
+        )
+        return _CompiledLCColorTransitionCompilation(
+            tuple(transition_terms),
+            closure_terms,
+        )
+
+    left_representation, right_representation, output_representation = (
+        oriented_representations
+    )
+    if structure == "singlet":
+        if oriented_representations != (1, 1, 1):
+            raise ValueError(
+                "a colored literal-singlet transition requires explicit contact "
+                f"provenance; kernel {kernel.kind} has {oriented_representations!r}"
+            )
+        return compiled(term((0, 1), "empty", None))
+    if structure == "color-identity":
+        colored_inputs = tuple(
+            index
+            for index, representation in enumerate(oriented_representations[:2])
+            if abs(representation) != 1
+        )
+        if len(colored_inputs) == 0:
+            return compiled(term((0, 1), "empty", None))
+        if len(colored_inputs) == 1:
+            operation = "inherit-left" if colored_inputs[0] == 0 else "inherit-right"
+            return compiled(term((0, 1), operation, None))
+        if len(colored_inputs) == 2 and abs(output_representation) == 1:
+            if {left_representation, right_representation} == {3, -3}:
+                permutation = (0, 1) if left_representation == 3 else (1, 0)
+                result_component = "open-string"
+            elif left_representation == right_representation == 8:
+                permutation = (0, 1)
+                result_component = "trace"
+            else:
+                raise ValueError(
+                    f"kernel {kernel.kind} has unsupported identity contraction "
+                    f"{oriented_representations!r}"
+                )
+            return compiled(
+                term(
+                    permutation,
+                    "concatenate-join",
+                    result_component,
+                )
+            )
+        raise ValueError(
+            f"kernel {kernel.kind} has unsupported color-identity orientation "
+            f"{oriented_representations!r}"
+        )
+    if structure == "fundamental-generator":
+        try:
+            fundamental = tensor_representations.index(3)
+            antifundamental = tensor_representations.index(-3)
+            adjoint = tensor_representations.index(8)
+        except ValueError as exc:
+            raise ValueError(
+                f"kernel {kernel.kind} fundamental generator has invalid oriented "
+                f"tensor roles {tensor_representations!r} for current shapes "
+                f"{oriented_representations!r}"
+            ) from exc
+        tensor_output_representation = tensor_representations[2]
+        if tensor_output_representation == -3:
+            permutation = (fundamental, adjoint)
+            result_component = "open-string"
+        elif tensor_output_representation == 3:
+            permutation = (adjoint, antifundamental)
+            result_component = "open-string"
+        elif tensor_output_representation == 8:
+            permutation = (fundamental, antifundamental)
+            result_component = "adjoint-segment"
+        else:
+            raise ValueError(
+                f"kernel {kernel.kind} fundamental generator has unsupported output "
+                f"tensor representation {tensor_output_representation}"
+            )
+        if set(permutation) != {0, 1}:
+            raise ValueError(
+                f"kernel {kernel.kind} fundamental generator output is not slot 2"
+            )
+        return compiled(
+            term(
+                permutation,
+                "concatenate-join",
+                result_component,
+            )
+        )
+    if structure == "adjoint-structure-constant":
+        if oriented_representations != (8, 8, 8):
+            raise ValueError(
+                f"kernel {kernel.kind} structure constant has representations "
+                f"{oriented_representations!r}"
+            )
+        return compiled(
+            term((0, 1), "concatenate-join", "adjoint-segment"),
+            term(
+                (1, 0),
+                "concatenate-join",
+                "adjoint-segment",
+                "-1",
+            ),
+        )
+    raise ValueError(
+        f"kernel {kernel.kind} has unsupported recurrence color projection "
+        f"{structure!r}"
+    )
+
+
+def _lc_color_shape(representation: int) -> str:
+    return {
+        1: "singlet-forest",
+        3: "fundamental-open-string",
+        -3: "antifundamental-open-string",
+        8: "adjoint-segment",
+    }.get(representation) or _unsupported_lc_color_shape(representation)
+
+
+def _unsupported_lc_color_shape(representation: int) -> str:
+    raise ValueError(
+        f"recurrence LC color witnesses do not support representation {representation}"
+    )
+
+
+def synthesize_fundamental_fierz_auxiliaries(
+    particles: Sequence[CompiledParticleRecord],
+    kernels: Sequence[CompiledOrientedKernel],
+    propagators: Sequence[CompiledPropagatorRecord],
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[tuple[CompiledParticleRecord, ...], tuple[CompiledOrientedKernel, ...]]:
+    """Materialize the singlet term of a proven fundamental Fierz identity.
+
+    A certified ``T^a_ij`` kernel implies the SU(3) color-flow decomposition
+    into an ordinary line connection and a ``1 / N_c`` singlet subtraction.
+    The synthetic current reuses the exact compiled Lorentz/coupling kernel;
+    no particle name or PDG label participates in the proof.
+
+    This milestone deliberately targets the supported QCD-like contract:
+    massless self-conjugate adjoint vectors with a default propagator and
+    fundamental fermion lines. Models outside that contract keep the existing
+    exact sector-partition fallback instead of acquiring an unproven auxiliary.
+    """
+
+    particle_by_name = {particle.name: particle for particle in particles}
+    propagator_by_particle = {
+        propagator.particle: propagator for propagator in propagators
+    }
+    eligible_sources: set[str] = set()
+    for kernel in kernels:
+        source_name = _eligible_adjoint_source(
+            kernel,
+            particle_by_name,
+            propagator_by_particle,
+        )
+        if source_name is not None:
+            eligible_sources.add(source_name)
+    if not eligible_sources:
+        return tuple(particles), tuple(kernels)
+
+    used_pdgs = {abs(particle.pdg_code) for particle in particles}
+    next_pdg = max(9_100_000, max(used_pdgs, default=0) + 1)
+
+    def allocate_pdg() -> int:
+        nonlocal next_pdg
+        while next_pdg in used_pdgs:
+            next_pdg += 1
+        result = next_pdg
+        used_pdgs.add(result)
+        next_pdg += 1
+        return result
+
+    quantum_number_names = sorted(
+        {
+            name
+            for particle in particles
+            for name, _expression in particle.quantum_numbers
+        }
+        | {"electric_charge"}
+    )
+    auxiliary_by_source: dict[str, CompiledParticleRecord] = {}
+    for source_name in sorted(eligible_sources):
+        source = particle_by_name[source_name]
+        auxiliary_name = f"__pyamplicol_u1_subtraction_{source_name}"
+        auxiliary_by_source[source_name] = CompiledParticleRecord(
+            name=auxiliary_name,
+            antiname=auxiliary_name,
+            pdg_code=allocate_pdg(),
+            spin=source.spin,
+            color=1,
+            mass=source.mass,
+            width=source.width,
+            charge=0.0,
+            quantum_numbers=tuple((name, "0") for name in quantum_number_names),
+            ghost_number=0,
+            propagating=False,
+            goldstoneboson=False,
+            propagator=None,
+            component_dimension=compiled_particle_component_dimension(source),
+            auxiliary_kind=_U1_SUBTRACTION_AUXILIARY,
+        )
+
+    synthetic: list[CompiledOrientedKernel] = []
+    next_kind = max((kernel.kind for kernel in kernels), default=-1) + 1
+    for kernel in kernels:
+        source_name = _kernel_adjoint_source(
+            kernel,
+            particle_by_name,
+            eligible_sources,
+        )
+        if source_name is None:
+            continue
+        source_slot = kernel.particles.index(source_name)
+        representations = tuple(
+            particle_by_name[name].color for name in kernel.particles
+        )
+        if source_slot == 2 and representations[:2] != (3, -3):
+            # Match the canonical oriented closure used by the LC recursion.
+            # The reverse input ordering is an equivalent physical kernel, but
+            # materializing both would create duplicate subtraction currents.
+            continue
+
+        auxiliary = auxiliary_by_source[source_name]
+        synthetic_particles = list(kernel.particles)
+        synthetic_particles[source_slot] = auxiliary.name
+        synthetic_representations = tuple(
+            auxiliary.color if index == source_slot else representations[index]
+            for index in range(3)
+        )
+        colored_legs = tuple(
+            index + 1
+            for index, representation in enumerate(synthetic_representations)
+            if abs(representation) != 1
+        )
+        if len(colored_legs) != 2:
+            raise ValueError(
+                f"Fierz auxiliary for kernel {kernel.kind} did not leave two "
+                "fundamental color legs"
+            )
+        color_source = f"UFO::Identity({colored_legs[0]},{colored_legs[1]})"
+        color_expression = normalize_color_expression(
+            color_source,
+            synthetic_representations,
+        ).expression
+
+        kind = next_kind + len(synthetic)
+        coefficient = complex(*(kernel.color_projection_coefficient or (1.0, 0.0)))
+        if source_slot == 2:
+            fundamental_dimension = abs(representations[0])
+            coefficient /= fundamental_dimension
+        source_legs = list(kernel.source_particle_legs)
+        source_legs[source_slot] = -1
+        synthetic_kernel = CompiledOrientedKernel(
+            kind=kind,
+            term_id=kernel.term_id,
+            vertex=f"{kernel.vertex}::u1-subtraction",
+            particles=tuple(synthetic_particles),
+            source_particle_legs=tuple(source_legs),
+            component_expressions=tuple(
+                _canonicalize_oriented_kernel_component(
+                    _remap_kernel_symbols(
+                        _sym.E(component),
+                        old_kind=kernel.kind,
+                        new_kind=kind,
+                        model_symbols=model_symbols,
+                    )
+                ).to_canonical_string()
+                for component in kernel.component_expressions
+            ),
+            coupling_expression=kernel.coupling_expression,
+            coupling_orders=kernel.coupling_orders,
+            runtime_parameters=kernel.runtime_parameters,
+            color_source=color_source,
+            color_expression=color_expression,
+            color_projection_structure="color-identity",
+            color_projection_coefficient=(
+                float(coefficient.real),
+                float(coefficient.imag),
+            ),
+            lc_color_normalization_power=kernel.lc_color_normalization_power,
+            term_ids=kernel.term_ids,
+        )
+        synthetic.append(
+            replace(
+                synthetic_kernel,
+                lc_color_transition_terms=compile_lc_color_transition_terms(
+                    synthetic_kernel,
+                    synthetic_representations,  # type: ignore[arg-type]
+                    proof_source="fundamental-fierz-identity-v1",
+                    provenance=(("source-kernel-kind", str(kernel.kind)),),
+                ),
+            )
+        )
+
+    return (
+        (*particles, *auxiliary_by_source.values()),
+        (*kernels, *synthetic),
+    )
+
+
+def _kernel_adjoint_source(
+    kernel: CompiledOrientedKernel,
+    particles: dict[str, CompiledParticleRecord],
+    eligible_sources: set[str],
+) -> str | None:
+    if kernel.color_projection_structure != "fundamental-generator":
+        return None
+    matches = tuple(name for name in kernel.particles if name in eligible_sources)
+    if len(matches) != 1:
+        return None
+    source_name = matches[0]
+    representations = tuple(particles[name].color for name in kernel.particles)
+    if representations.count(8) != 1:
+        return None
+    if sorted(abs(value) for value in representations if value != 8) != [3, 3]:
+        return None
+    return source_name
+
+
+def _eligible_adjoint_source(
+    kernel: CompiledOrientedKernel,
+    particles: dict[str, CompiledParticleRecord],
+    propagators: dict[str, CompiledPropagatorRecord],
+) -> str | None:
+    if kernel.color_projection_structure != "fundamental-generator":
+        return None
+    representations = tuple(particles[name].color for name in kernel.particles)
+    adjoint_slots = tuple(
+        index
+        for index, representation in enumerate(representations)
+        if representation == 8
+    )
+    if len(adjoint_slots) != 1:
+        return None
+    if sorted(abs(value) for value in representations if value != 8) != [3, 3]:
+        return None
+    if not all(
+        particles[name].statistics == "fermion"
+        for index, name in enumerate(kernel.particles)
+        if index != adjoint_slots[0]
+    ):
+        return None
+    source = particles[kernel.particles[adjoint_slots[0]]]
+    propagator = propagators.get(source.name)
+    if (
+        source.spin != 3
+        or source.mass.upper() != "ZERO"
+        or source.width.upper() != "ZERO"
+        or not source.self_conjugate
+        or (propagator is not None and propagator.custom)
+    ):
+        return None
+    return source.name
+
+
+__all__ = [
+    "synthesize_fundamental_fierz_auxiliaries",
+]
diff --git a/pyamplicol/src/pyamplicol/models/compiler_contact_trees.py b/pyamplicol/src/pyamplicol/models/compiler_contact_trees.py
new file mode 100644
index 0000000000..e444bf87b0
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_contact_trees.py
@@ -0,0 +1,1765 @@
+# SPDX-License-Identifier: 0BSD
+"""Color-singlet four-point contact-tree compilation."""
+
+from __future__ import annotations
+
+import math
+import re
+import sys
+from collections.abc import Mapping, Sequence
+from dataclasses import replace
+from itertools import product
+
+from .._internal.physics.symbols import ModelSymbolRegistry, symbols
+from . import compiler_symbolica as _sym
+from .compiler_contacts import (
+    _execute_dense_tensor,
+    _normalized_structure_constant_factors,
+    _source_structure_constant_factor_orientations,
+    _source_structure_constant_product_coefficient,
+)
+from .compiler_kernels import (
+    _as_expression,
+    _canonicalize_oriented_kernel_component,
+    _function_arguments,
+    _permutation_sign,
+    _remap_kernel_symbols,
+    _replace_expression_symbols,
+    _spin_axis_labels,
+    _spin_dimension,
+    _spin_representations,
+    _spin_slots,
+)
+from .compiler_records import _replace_evaluator_constants
+from .contact_decomposition import (
+    CONTACT_ORBIT_ALGORITHM,
+    CONTACT_ORBIT_ALGORITHM_VERSION,
+    HEFT_CONTACT_ORBIT_EVALUATOR_CLASS,
+    CompiledContactOrbitCertificate,
+    CompiledContactOrbitStep,
+    canonical_contact_orbit_steps,
+)
+from .contracts import (
+    CompiledOrientedKernel,
+    CompiledParticleRecord,
+    CompiledVertexTerm,
+    _ContactTreeNode,
+    compiled_particle_component_dimension,
+)
+from .tensors import normalize_color_expression, project_trilinear_color_expression
+
+_DIRECT_DENSE_CONTACT_INPUT_WORK = 1_024
+_MAX_STAGED_CONTACT_INPUT_WORK = 256
+
+
+def _compile_color_singlet_contact_trees(
+    terms: Sequence[CompiledVertexTerm],
+    particles: Sequence[CompiledParticleRecord],
+    *,
+    start_kind: int,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[tuple[CompiledParticleRecord, ...], tuple[CompiledOrientedKernel, ...]]:
+    """Lower arbitrary color-singlet contacts to balanced trivalent trees."""
+
+    particle_by_name = {particle.name: particle for particle in particles}
+    used_pdgs = {abs(particle.pdg_code) for particle in particles}
+    next_pdg = max(9_000_000, max(used_pdgs, default=0) + 1)
+    auxiliary_particles: list[CompiledParticleRecord] = []
+    kernels: list[CompiledOrientedKernel] = []
+    final_template_cache: dict[
+        tuple[object, ...],
+        tuple[int, tuple[_sym.Expression, ...]],
+    ] = {}
+
+    def allocate_pdg() -> int:
+        nonlocal next_pdg
+        while next_pdg in used_pdgs:
+            next_pdg += 1
+        result = next_pdg
+        used_pdgs.add(result)
+        next_pdg += 1
+        return result
+
+    for term in terms:
+        if term.valence < 4 or not _contact_term_is_color_singlet(term):
+            continue
+        if term.valence == 4 and "ufo_momentum_" not in term.lorentz_expression:
+            continue
+        source_particles = tuple(particle_by_name[name] for name in term.particles)
+        scalar_product_tree = all(particle.spin == 1 for particle in source_particles)
+        oriented_result_particles: set[str] = set()
+        for result_leg in range(term.valence):
+            source_result = source_particles[result_leg]
+            if source_result.name in oriented_result_particles:
+                continue
+            oriented_result_particles.add(source_result.name)
+            input_legs = tuple(leg for leg in range(term.valence) if leg != result_leg)
+
+            def build_node(
+                legs: tuple[int, ...],
+                *,
+                source_particles: tuple[CompiledParticleRecord, ...] = source_particles,
+                scalar_product_tree: bool = scalar_product_tree,
+                term: CompiledVertexTerm = term,
+                result_leg: int = result_leg,
+            ) -> _ContactTreeNode:
+                if len(legs) == 1:
+                    leg = legs[0]
+                    return _ContactTreeNode(
+                        legs=legs,
+                        particle=source_particles[leg],
+                        physical_leg=leg,
+                    )
+                split = len(legs) // 2
+                left_node = build_node(legs[:split])
+                right_node = build_node(legs[split:])
+                auxiliary_name = (
+                    f"__pyamplicol_contact_tree_{term.id}_r{result_leg}_"
+                    + "_".join(str(leg) for leg in legs)
+                )
+                auxiliary_dimension = (
+                    1
+                    if scalar_product_tree
+                    else sum(
+                        _spin_dimension(source_particles[leg].spin) + 4 for leg in legs
+                    )
+                )
+                auxiliary = CompiledParticleRecord(
+                    name=auxiliary_name,
+                    antiname=auxiliary_name,
+                    pdg_code=allocate_pdg(),
+                    spin=-1,
+                    color=1,
+                    mass="ZERO",
+                    width="ZERO",
+                    charge=0.0,
+                    quantum_numbers=(("electric_charge", "0"),),
+                    ghost_number=0,
+                    propagating=False,
+                    goldstoneboson=False,
+                    propagator=None,
+                    component_dimension=auxiliary_dimension,
+                    auxiliary_kind=(
+                        f"ufo-contact-tree:{term.id}:result-{result_leg}:"
+                        + ",".join(str(leg) for leg in legs)
+                    ),
+                )
+                auxiliary_particles.append(auxiliary)
+                node = _ContactTreeNode(
+                    legs=legs,
+                    particle=auxiliary,
+                    left=left_node,
+                    right=right_node,
+                )
+                _append_contact_tree_partial_kernels(
+                    kernels,
+                    term=term,
+                    node=node,
+                    source_particles=source_particles,
+                    scalar_product_tree=scalar_product_tree,
+                    start_kind=start_kind,
+                    model_symbols=model_symbols,
+                )
+                return node
+
+            split = len(input_legs) // 2
+            left_root = build_node(input_legs[:split])
+            right_root = build_node(input_legs[split:])
+            assignment_multiplicity = _contact_tree_assignment_multiplicity(
+                input_legs,
+                source_particles,
+                left_root,
+                right_root,
+            )
+            _append_contact_tree_final_kernels(
+                kernels,
+                term=term,
+                source_particles=source_particles,
+                left_node=left_root,
+                right_node=right_root,
+                result_leg=result_leg,
+                result_name=particle_by_name[source_result.antiname].name,
+                scalar_product_tree=scalar_product_tree,
+                assignment_multiplicity=assignment_multiplicity,
+                start_kind=start_kind,
+                template_cache=final_template_cache,
+                model_symbols=model_symbols,
+            )
+    return tuple(auxiliary_particles), tuple(kernels)
+
+
+def _compile_heft_colored_contact_trees(
+    terms: Sequence[CompiledVertexTerm],
+    particles: Sequence[CompiledParticleRecord],
+    *,
+    start_kind: int,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[tuple[CompiledParticleRecord, ...], tuple[CompiledOrientedKernel, ...]]:
+    """Lower only the scalar-HEFT one- and two-``f`` contact families."""
+
+    particle_by_name = {particle.name: particle for particle in particles}
+    used_pdgs = {abs(particle.pdg_code) for particle in particles}
+    next_pdg = max(9_050_000, max(used_pdgs, default=0) + 1)
+    auxiliary_particles: list[CompiledParticleRecord] = []
+    kernels: list[CompiledOrientedKernel] = []
+
+    def allocate_pdg() -> int:
+        nonlocal next_pdg
+        while next_pdg in used_pdgs:
+            next_pdg += 1
+        result = next_pdg
+        used_pdgs.add(result)
+        next_pdg += 1
+        return result
+
+    for term in terms:
+        source_particles = tuple(particle_by_name[name] for name in term.particles)
+        topology = _heft_contact_color_topology(
+            term,
+            source_particles,
+            model_symbols=model_symbols,
+        )
+        if topology is None:
+            continue
+        factors, source_coefficient = topology
+        singlet_leg = next(
+            index
+            for index, particle in enumerate(source_particles)
+            if particle.color == 1
+        )
+        colored_legs = tuple(
+            index
+            for index, particle in enumerate(source_particles)
+            if particle.color == 8
+        )
+
+        def leaf(
+            leg: int,
+            *,
+            source_particles: tuple[CompiledParticleRecord, ...] = source_particles,
+        ) -> _ContactTreeNode:
+            return _ContactTreeNode(
+                legs=(leg,),
+                particle=source_particles[leg],
+                physical_leg=leg,
+            )
+
+        def combine(
+            left: _ContactTreeNode,
+            right: _ContactTreeNode,
+            *,
+            result_leg: int,
+            label: str,
+            factor: tuple[int, int, int] | None,
+            left_token: int | None,
+            right_token: int | None,
+            output_token: int,
+            term: CompiledVertexTerm = term,
+            source_particles: tuple[CompiledParticleRecord, ...] = source_particles,
+        ) -> _ContactTreeNode:
+            legs = (*left.legs, *right.legs)
+            auxiliary_name = (
+                f"__pyamplicol_heft_contact_{term.id}_r{result_leg}_{label}"
+            )
+            auxiliary = CompiledParticleRecord(
+                name=auxiliary_name,
+                antiname=auxiliary_name,
+                pdg_code=allocate_pdg(),
+                spin=-1,
+                color=8,
+                mass="ZERO",
+                width="ZERO",
+                charge=0.0,
+                quantum_numbers=(("electric_charge", "0"),),
+                ghost_number=0,
+                propagating=False,
+                goldstoneboson=False,
+                propagator=None,
+                component_dimension=_heft_node_component_dimension(
+                    legs,
+                    source_particles,
+                    include_momenta=term.valence == 4,
+                ),
+                auxiliary_kind=(
+                    f"ufo-heft-contact-tree:{term.id}:result-{result_leg}:"
+                    + ",".join(str(leg) for leg in legs)
+                ),
+            )
+            auxiliary_particles.append(auxiliary)
+            node = _ContactTreeNode(
+                legs=legs,
+                particle=auxiliary,
+                left=left,
+                right=right,
+            )
+            _append_heft_contact_partial_kernels(
+                kernels,
+                term=term,
+                node=node,
+                result_leg=result_leg,
+                source_particles=source_particles,
+                factor=factor,
+                left_token=left_token,
+                right_token=right_token,
+                output_token=output_token,
+                include_momenta=term.valence == 4,
+                start_kind=start_kind,
+                model_symbols=model_symbols,
+            )
+            return node
+
+        oriented_result_particles: set[str] = set()
+        for result_leg, source_result in enumerate(source_particles):
+            if source_result.name in oriented_result_particles:
+                continue
+            oriented_result_particles.add(source_result.name)
+            result_token = result_leg + 1 if source_result.color == 8 else None
+            input_legs = tuple(leg for leg in range(term.valence) if leg != result_leg)
+
+            if term.valence == 4:
+                factor = factors[0]
+                if result_token is None:
+                    pair_legs = tuple(sorted(colored_legs[:2]))
+                    pair_tokens = (pair_legs[0] + 1, pair_legs[1] + 1)
+                    output_token = next(
+                        token for token in factor if token not in set(pair_tokens)
+                    )
+                    left_root = combine(
+                        leaf(pair_legs[0]),
+                        leaf(pair_legs[1]),
+                        result_leg=result_leg,
+                        label="f",
+                        factor=factor,
+                        left_token=pair_tokens[0],
+                        right_token=pair_tokens[1],
+                        output_token=output_token,
+                    )
+                    remaining_leg = next(
+                        leg for leg in input_legs if leg not in set(pair_legs)
+                    )
+                    right_root = leaf(remaining_leg)
+                    left_token = output_token
+                    right_token = remaining_leg + 1
+                    final_factor = None
+                else:
+                    remaining_colored = tuple(
+                        leg for leg in colored_legs if leg != result_leg
+                    )
+                    if len(remaining_colored) != 2:
+                        raise ValueError("scalar-HEFT Hggg tree has no gluon pair")
+                    standalone_leg, identity_leg = remaining_colored
+                    left_root = leaf(standalone_leg)
+                    right_root = combine(
+                        leaf(identity_leg),
+                        leaf(singlet_leg),
+                        result_leg=result_leg,
+                        label="identity",
+                        factor=None,
+                        left_token=identity_leg + 1,
+                        right_token=None,
+                        output_token=identity_leg + 1,
+                    )
+                    left_token = standalone_leg + 1
+                    right_token = identity_leg + 1
+                    final_factor = factor
+            else:
+                dummy = next(value for value in factors[0] if value < 0)
+                if result_token is None:
+                    roots: list[_ContactTreeNode] = []
+                    for index, factor in enumerate(factors):
+                        pair_legs = tuple(
+                            sorted(value - 1 for value in factor if value > 0)
+                        )
+                        roots.append(
+                            combine(
+                                leaf(pair_legs[0]),
+                                leaf(pair_legs[1]),
+                                result_leg=result_leg,
+                                label=f"f{index}",
+                                factor=factor,
+                                left_token=pair_legs[0] + 1,
+                                right_token=pair_legs[1] + 1,
+                                output_token=dummy,
+                            )
+                        )
+                    left_root, right_root = roots
+                    left_token = right_token = dummy
+                    final_factor = None
+                else:
+                    result_factor = next(
+                        factor for factor in factors if result_token in factor
+                    )
+                    outer_factor = next(
+                        factor for factor in factors if factor != result_factor
+                    )
+                    outer_legs = tuple(
+                        sorted(value - 1 for value in outer_factor if value > 0)
+                    )
+                    left_root = combine(
+                        leaf(outer_legs[0]),
+                        leaf(outer_legs[1]),
+                        result_leg=result_leg,
+                        label="outer-f",
+                        factor=outer_factor,
+                        left_token=outer_legs[0] + 1,
+                        right_token=outer_legs[1] + 1,
+                        output_token=dummy,
+                    )
+                    remaining_token = next(
+                        value
+                        for value in result_factor
+                        if value > 0 and value != result_token
+                    )
+                    remaining_leg = remaining_token - 1
+                    right_root = combine(
+                        leaf(remaining_leg),
+                        leaf(singlet_leg),
+                        result_leg=result_leg,
+                        label="identity",
+                        factor=None,
+                        left_token=remaining_token,
+                        right_token=None,
+                        output_token=remaining_token,
+                    )
+                    left_token = dummy
+                    right_token = remaining_token
+                    final_factor = result_factor
+
+            assignment_multiplicity = _contact_tree_assignment_multiplicity(
+                input_legs,
+                source_particles,
+                left_root,
+                right_root,
+            )
+            _append_heft_contact_final_kernels(
+                kernels,
+                term=term,
+                source_particles=source_particles,
+                left_node=left_root,
+                right_node=right_root,
+                result_leg=result_leg,
+                result_name=particle_by_name[source_result.antiname].name,
+                factor=final_factor,
+                left_token=left_token,
+                right_token=right_token,
+                output_token=result_token,
+                source_coefficient=source_coefficient,
+                assignment_multiplicity=assignment_multiplicity,
+                start_kind=start_kind,
+                model_symbols=model_symbols,
+            )
+
+    return tuple(auxiliary_particles), tuple(kernels)
+
+
+def _record_heft_contact_orbit_certificates(
+    terms: Sequence[CompiledVertexTerm],
+    particles: Sequence[CompiledParticleRecord],
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[CompiledVertexTerm, ...]:
+    """Certify the exact physical-assignment orbit of supported HEFT trees."""
+
+    particle_by_name = {particle.name: particle for particle in particles}
+    certified: list[CompiledVertexTerm] = []
+    for term in terms:
+        source_particles = tuple(particle_by_name[name] for name in term.particles)
+        if (
+            _heft_contact_color_topology(
+                term,
+                source_particles,
+                model_symbols=model_symbols,
+            )
+            is None
+        ):
+            certified.append(term)
+            continue
+        if term.contact_orbit_certificate is not None:
+            raise ValueError(
+                f"scalar-HEFT term {term.id} already has a contact-orbit certificate"
+            )
+        equivalence_classes: dict[str, int] = {}
+        leg_classes = tuple(
+            equivalence_classes.setdefault(particle.name, len(equivalence_classes))
+            for particle in source_particles
+        )
+        certified.append(
+            replace(
+                term,
+                contact_orbit_certificate=CompiledContactOrbitCertificate(
+                    algorithm=CONTACT_ORBIT_ALGORITHM,
+                    algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+                    term_id=term.id,
+                    vertex=term.vertex,
+                    particles=term.particles,
+                    color_expression=term.color_expression,
+                    lorentz_expression=term.lorentz_expression,
+                    coupling_expression=term.coupling_expression,
+                    evaluator_class=HEFT_CONTACT_ORBIT_EVALUATOR_CLASS,
+                    physical_leg_equivalence_classes=leg_classes,
+                    reconstruction_factor="1",
+                ),
+            )
+        )
+    return tuple(certified)
+
+
+def _heft_contact_orbit_step(
+    term: CompiledVertexTerm,
+    *,
+    stage: str,
+    result_leg: int,
+    left_covered_legs: tuple[int, ...],
+    right_covered_legs: tuple[int, ...],
+    source_particle_legs: tuple[int, int, int],
+) -> CompiledContactOrbitStep:
+    return CompiledContactOrbitStep(
+        algorithm=CONTACT_ORBIT_ALGORITHM,
+        algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+        term_id=term.id,
+        stage=stage,
+        result_leg=result_leg,
+        left_covered_legs=left_covered_legs,
+        right_covered_legs=right_covered_legs,
+        source_particle_legs=source_particle_legs,
+        reconstruction_factor="1",
+    )
+
+
+def _heft_contact_color_topology(
+    term: CompiledVertexTerm,
+    source_particles: Sequence[CompiledParticleRecord],
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[tuple[tuple[int, int, int], ...], str] | None:
+    colors = tuple(particle.color for particle in source_particles)
+    if term.valence == 4 and colors.count(8) == 3 and colors.count(1) == 1:
+        expected_count = 1
+    elif term.valence == 5 and colors.count(8) == 4 and colors.count(1) == 1:
+        expected_count = 2
+    else:
+        return None
+    factors = _normalized_structure_constant_factors(
+        term.color_expression,
+        expected_count=expected_count,
+    )
+    if len(factors) != expected_count:
+        return None
+    colored_tokens = {
+        index + 1
+        for index, particle in enumerate(source_particles)
+        if particle.color == 8
+    }
+    if expected_count == 1:
+        if set(factors[0]) != colored_tokens or any(value < 1 for value in factors[0]):
+            return None
+    else:
+        dummy_sets = tuple(
+            {value for value in factor if value < 0} for factor in factors
+        )
+        if any(len(values) != 1 for values in dummy_sets):
+            return None
+        shared = dummy_sets[0] & dummy_sets[1]
+        positives = tuple(value for factor in factors for value in factor if value > 0)
+        if (
+            len(shared) != 1
+            or set(positives) != colored_tokens
+            or len(positives) != len(set(positives))
+            or any(len(factor) != 3 for factor in factors)
+        ):
+            return None
+    source_factors = _function_arguments(term.color_source, "f")
+    if len(source_factors) != expected_count:
+        return None
+    compact_source = re.sub(r"\s+", "", term.color_source)
+    tensor = r"(?:UFO::(?:\{\}::)?)?f\(-?\d+,-?\d+,-?\d+\)"
+    if (
+        re.fullmatch(rf"{tensor}(?:\*{tensor}){{{expected_count - 1}}}", compact_source)
+        is None
+    ):
+        return None
+    coefficient = _source_structure_constant_product_coefficient(
+        term.color_source,
+        model_symbols=model_symbols,
+    )
+    if coefficient is None:
+        return None
+    oriented_factors = _source_structure_constant_factor_orientations(
+        source_factors, factors
+    )
+    if oriented_factors is None:
+        return None
+    return oriented_factors, coefficient
+
+
+def _heft_trilinear_color(
+    particles: tuple[
+        CompiledParticleRecord, CompiledParticleRecord, CompiledParticleRecord
+    ],
+) -> tuple[str, str, int]:
+    representations = tuple(particle.color for particle in particles)
+    colored_slots = tuple(
+        index + 1
+        for index, representation in enumerate(representations)
+        if representation == 8
+    )
+    if len(colored_slots) == 3:
+        source = "UFO::f(1,2,3)"
+        expected = "adjoint-structure-constant"
+        normalization_power = 1
+    elif len(colored_slots) == 2 and set(representations) <= {1, 8}:
+        source = f"UFO::Identity({colored_slots[0]},{colored_slots[1]})"
+        expected = "color-identity"
+        normalization_power = 0
+    else:
+        raise ValueError(
+            f"scalar-HEFT contact node has unsupported colors {representations!r}"
+        )
+    expression = normalize_color_expression(source, representations).expression
+    structure, coefficient = project_trilinear_color_expression(
+        expression,
+        representations,
+    )
+    if structure != expected or coefficient != 1.0 + 0.0j:
+        raise ValueError(
+            "scalar-HEFT contact node failed exact trilinear color projection"
+        )
+    return source, expression, normalization_power
+
+
+def _heft_node_base_dimension(
+    legs: Sequence[int],
+    source_particles: Sequence[CompiledParticleRecord],
+) -> int:
+    return math.prod(_spin_dimension(source_particles[leg].spin) for leg in legs)
+
+
+def _heft_node_component_dimension(
+    legs: Sequence[int],
+    source_particles: Sequence[CompiledParticleRecord],
+    *,
+    include_momenta: bool,
+) -> int:
+    base_dimension = _heft_node_base_dimension(legs, source_particles)
+    return base_dimension * (1 + (4 * len(legs) if include_momenta else 0))
+
+
+def _heft_node_base_index(
+    node: _ContactTreeNode,
+    source_particles: Sequence[CompiledParticleRecord],
+    component_by_leg: Mapping[int, int],
+) -> int:
+    index = 0
+    for leg in node.legs:
+        dimension = _spin_dimension(source_particles[leg].spin)
+        component = component_by_leg[leg]
+        if not 0 <= component < dimension:
+            raise ValueError("scalar-HEFT contact component is outside its basis")
+        index = index * dimension + component
+    return index
+
+
+def _heft_node_base_expression(
+    kind: int,
+    side: str,
+    node: _ContactTreeNode,
+    source_particles: Sequence[CompiledParticleRecord],
+    component_by_leg: Mapping[int, int],
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> _sym.Expression:
+    if node.is_leaf:
+        if node.physical_leg is None:
+            raise ValueError("scalar-HEFT contact leaf has no source leg")
+        index = component_by_leg[node.physical_leg]
+    else:
+        index = _heft_node_base_index(node, source_particles, component_by_leg)
+    return model_symbols.kernel_component(kind, side, index)
+
+
+def _heft_node_momentum_weighted_expression(
+    kind: int,
+    side: str,
+    node: _ContactTreeNode,
+    source_particles: Sequence[CompiledParticleRecord],
+    component_by_leg: Mapping[int, int],
+    *,
+    leg: int,
+    momentum_component: int,
+    model_symbols: ModelSymbolRegistry,
+) -> _sym.Expression:
+    base = _heft_node_base_expression(
+        kind,
+        side,
+        node,
+        source_particles,
+        component_by_leg,
+        model_symbols=model_symbols,
+    )
+    if node.is_leaf:
+        if node.physical_leg != leg:
+            raise ValueError("scalar-HEFT leaf momentum belongs to another source leg")
+        return base * model_symbols.kernel_momentum(
+            kind,
+            side,
+            momentum_component,
+        )
+    try:
+        leg_position = node.legs.index(leg)
+    except ValueError as error:
+        raise ValueError(
+            "scalar-HEFT auxiliary momentum belongs to another source node"
+        ) from error
+    base_dimension = _heft_node_base_dimension(node.legs, source_particles)
+    base_index = _heft_node_base_index(node, source_particles, component_by_leg)
+    jet_index = (
+        base_dimension
+        + (leg_position * 4 + momentum_component) * base_dimension
+        + base_index
+    )
+    if jet_index >= compiled_particle_component_dimension(node.particle):
+        raise ValueError("scalar-HEFT momentum jet is absent from an auxiliary")
+    return model_symbols.kernel_component(kind, side, jet_index)
+
+
+def _heft_contact_final_component_expressions(
+    term: CompiledVertexTerm,
+    source_particles: Sequence[CompiledParticleRecord],
+    *,
+    left_node: _ContactTreeNode,
+    right_node: _ContactTreeNode,
+    result_leg: int,
+    kind: int,
+    canonical_left_side: str,
+    canonical_right_side: str,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[_sym.Expression, ...]:
+    """Rebuild one HEFT Lorentz tensor linearly from authenticated node jets."""
+
+    input_legs = tuple(leg for leg in range(term.valence) if leg != result_leg)
+    if set((*left_node.legs, *right_node.legs)) != set(input_legs):
+        raise ValueError("scalar-HEFT final nodes do not cover every input leg")
+    component_placeholders = {
+        leg: tuple(
+            model_symbols.symbol(
+                f"compiler::heft_term_{term.id}_result_{result_leg}_"
+                f"leg_{leg}_component_{component}"
+            )
+            for component in range(_spin_dimension(source_particles[leg].spin))
+        )
+        for leg in input_legs
+    }
+    momentum_placeholders = {
+        leg: tuple(
+            model_symbols.symbol(
+                f"compiler::heft_term_{term.id}_result_{result_leg}_"
+                f"leg_{leg}_momentum_{component}"
+            )
+            for component in range(4)
+        )
+        for leg in input_legs
+    }
+    oracle_term = replace(term, color_source="1", color_expression="1")
+    oracle_components = eager_color_singlet_vertex_term_components(
+        oracle_term,
+        source_particles,
+        result_leg=result_leg,
+        input_components=component_placeholders,
+        input_momenta=momentum_placeholders,
+        model_symbols=model_symbols,
+    )
+    zero = _sym.E("0")
+    momentum_zeroes = {
+        momentum: zero
+        for values in momentum_placeholders.values()
+        for momentum in values
+    }
+    component_ranges = tuple(
+        range(_spin_dimension(source_particles[leg].spin)) for leg in input_legs
+    )
+    results: list[_sym.Expression] = []
+    for source_component in oracle_components:
+        expanded = source_component.expand()
+        translated = zero
+        recovered = zero
+        for indices in product(*component_ranges):
+            component_by_leg = dict(zip(input_legs, indices, strict=True))
+            monomial = math.prod(
+                component_placeholders[leg][component_by_leg[leg]] for leg in input_legs
+            )
+            coefficient = expanded.coefficient(monomial)
+            if coefficient == zero:
+                continue
+            constant = _replace_expression_symbols(coefficient, momentum_zeroes)
+            reconstructed_coefficient = constant
+            left_base = _heft_node_base_expression(
+                kind,
+                canonical_left_side,
+                left_node,
+                source_particles,
+                component_by_leg,
+                model_symbols=model_symbols,
+            )
+            right_base = _heft_node_base_expression(
+                kind,
+                canonical_right_side,
+                right_node,
+                source_particles,
+                component_by_leg,
+                model_symbols=model_symbols,
+            )
+            translated += constant * left_base * right_base
+            for leg in input_legs:
+                node, side, other_base = (
+                    (left_node, canonical_left_side, right_base)
+                    if leg in left_node.legs
+                    else (right_node, canonical_right_side, left_base)
+                )
+                for momentum_component, momentum in enumerate(
+                    momentum_placeholders[leg]
+                ):
+                    momentum_coefficient = _replace_expression_symbols(
+                        coefficient.coefficient(momentum),
+                        momentum_zeroes,
+                    )
+                    if momentum_coefficient == zero:
+                        continue
+                    reconstructed_coefficient += momentum_coefficient * momentum
+                    translated += (
+                        momentum_coefficient
+                        * _heft_node_momentum_weighted_expression(
+                            kind,
+                            side,
+                            node,
+                            source_particles,
+                            component_by_leg,
+                            leg=leg,
+                            momentum_component=momentum_component,
+                            model_symbols=model_symbols,
+                        )
+                        * other_base
+                    )
+            if (
+                coefficient - reconstructed_coefficient
+            ).expand().to_canonical_string() != "0":
+                raise ValueError(
+                    "scalar-HEFT contact Lorentz momentum degree exceeds one"
+                )
+            recovered += reconstructed_coefficient * monomial
+        if (expanded - recovered).expand().to_canonical_string() != "0":
+            raise ValueError(
+                "scalar-HEFT contact Lorentz tensor is not multilinear in its inputs"
+            )
+        results.append(_replace_evaluator_constants(translated))
+    return tuple(results)
+
+
+def _append_heft_contact_partial_kernels(
+    kernels: list[CompiledOrientedKernel],
+    *,
+    term: CompiledVertexTerm,
+    node: _ContactTreeNode,
+    result_leg: int,
+    source_particles: Sequence[CompiledParticleRecord],
+    factor: tuple[int, int, int] | None,
+    left_token: int | None,
+    right_token: int | None,
+    output_token: int,
+    include_momenta: bool,
+    start_kind: int,
+    model_symbols: ModelSymbolRegistry,
+) -> None:
+    if node.left is None or node.right is None:
+        raise ValueError("scalar-HEFT contact partial is missing a child")
+    if not node.left.is_leaf or not node.right.is_leaf:
+        raise ValueError("scalar-HEFT contact partial must join two physical legs")
+    orientations = (
+        ((node.left, node.right),)
+        if node.left.particle.name == node.right.particle.name
+        else ((node.left, node.right), (node.right, node.left))
+    )
+    for actual_left, actual_right in orientations:
+        kind = start_kind + len(kernels)
+        swapped = actual_left is node.right
+        canonical_left_side = "right" if swapped else "left"
+        canonical_right_side = "left" if swapped else "right"
+        left_dimension = _spin_dimension(node.left.particle.spin)
+        right_dimension = _spin_dimension(node.right.particle.spin)
+        left_components = tuple(
+            model_symbols.kernel_component(kind, canonical_left_side, index)
+            for index in range(left_dimension)
+        )
+        right_components = tuple(
+            model_symbols.kernel_component(kind, canonical_right_side, index)
+            for index in range(right_dimension)
+        )
+        base_components = tuple(
+            left * right for left in left_components for right in right_components
+        )
+        encoded_components = list(base_components)
+        if include_momenta:
+            for side in (canonical_left_side, canonical_right_side):
+                for momentum_component in range(4):
+                    momentum = model_symbols.kernel_momentum(
+                        kind,
+                        side,
+                        momentum_component,
+                    )
+                    encoded_components.extend(
+                        base * momentum for base in base_components
+                    )
+        actual_left_token, actual_right_token = (
+            (right_token, left_token) if swapped else (left_token, right_token)
+        )
+        sign = (
+            1
+            if factor is None
+            else _permutation_sign(
+                factor,
+                (actual_left_token, actual_right_token, output_token),  # type: ignore[arg-type]
+            )
+        )
+        particles = (
+            actual_left.particle,
+            actual_right.particle,
+            node.particle,
+        )
+        source_particle_legs = (
+            _contact_tree_source_leg(actual_left),
+            _contact_tree_source_leg(actual_right),
+            -1,
+        )
+        color_source, color_expression, color_power = _heft_trilinear_color(particles)
+        kernels.append(
+            CompiledOrientedKernel(
+                kind=kind,
+                term_id=term.id,
+                vertex=f"{term.vertex}::contact-heft-tree-partial",
+                particles=tuple(particle.name for particle in particles),
+                source_particle_legs=source_particle_legs,
+                component_expressions=tuple(
+                    _canonicalize_oriented_kernel_component(
+                        sign * component
+                    ).to_canonical_string()
+                    for component in encoded_components
+                ),
+                coupling_expression="1",
+                coupling_orders=(),
+                runtime_parameters=(),
+                color_source=color_source,
+                color_expression=color_expression,
+                lc_color_normalization_power=color_power,
+                term_ids=(),
+                contact_orbit_steps=(
+                    _heft_contact_orbit_step(
+                        term,
+                        stage="partial",
+                        result_leg=result_leg,
+                        left_covered_legs=actual_left.legs,
+                        right_covered_legs=actual_right.legs,
+                        source_particle_legs=source_particle_legs,
+                    ),
+                ),
+            )
+        )
+
+
+def _append_heft_contact_final_kernels(
+    kernels: list[CompiledOrientedKernel],
+    *,
+    term: CompiledVertexTerm,
+    source_particles: Sequence[CompiledParticleRecord],
+    left_node: _ContactTreeNode,
+    right_node: _ContactTreeNode,
+    result_leg: int,
+    result_name: str,
+    factor: tuple[int, int, int] | None,
+    left_token: int,
+    right_token: int | None,
+    output_token: int | None,
+    source_coefficient: str,
+    assignment_multiplicity: int,
+    start_kind: int,
+    model_symbols: ModelSymbolRegistry,
+) -> None:
+    orientations = (
+        ((left_node, right_node),)
+        if left_node.particle.name == right_node.particle.name
+        else ((left_node, right_node), (right_node, left_node))
+    )
+    canonical_kind = start_kind + len(kernels)
+    components = _heft_contact_final_component_expressions(
+        term,
+        source_particles,
+        left_node=left_node,
+        right_node=right_node,
+        result_leg=result_leg,
+        kind=canonical_kind,
+        canonical_left_side="left",
+        canonical_right_side="right",
+        model_symbols=model_symbols,
+    )
+    prefactor = (
+        _sym.E(source_coefficient)
+        * symbols.derived_coupling(model_symbols.model_name, term.id)
+        / assignment_multiplicity
+    )
+    weighted = tuple(
+        _canonicalize_oriented_kernel_component(component * prefactor)
+        for component in components
+    )
+    result_particle = next(
+        particle for particle in source_particles if particle.name == result_name
+    )
+    for actual_left, actual_right in orientations:
+        kind = start_kind + len(kernels)
+        swapped = actual_left is right_node
+        actual_left_token, actual_right_token = (
+            (right_token, left_token) if swapped else (left_token, right_token)
+        )
+        sign = (
+            1
+            if factor is None
+            else _permutation_sign(
+                factor,
+                (actual_left_token, actual_right_token, output_token),  # type: ignore[arg-type]
+            )
+        )
+        oriented_components = tuple(
+            _canonicalize_oriented_kernel_component(
+                sign
+                * _remap_kernel_symbols(
+                    component,
+                    old_kind=canonical_kind,
+                    new_kind=kind,
+                    model_symbols=model_symbols,
+                    swap_sides=swapped,
+                )
+            )
+            for component in weighted
+        )
+        particles = (actual_left.particle, actual_right.particle, result_particle)
+        source_particle_legs = (
+            _contact_tree_source_leg(actual_left),
+            _contact_tree_source_leg(actual_right),
+            result_leg,
+        )
+        color_source, color_expression, color_power = _heft_trilinear_color(particles)
+        kernels.append(
+            CompiledOrientedKernel(
+                kind=kind,
+                term_id=term.id,
+                vertex=f"{term.vertex}::contact-heft-tree-final",
+                particles=tuple(particle.name for particle in particles),
+                source_particle_legs=source_particle_legs,
+                component_expressions=tuple(
+                    component.to_canonical_string() for component in oriented_components
+                ),
+                coupling_expression="1",
+                coupling_orders=term.coupling_orders,
+                runtime_parameters=(f"derived_coupling_{term.id}",),
+                color_source=color_source,
+                color_expression=color_expression,
+                lc_color_normalization_power=color_power,
+                term_ids=(term.id,),
+                contact_orbit_steps=(
+                    _heft_contact_orbit_step(
+                        term,
+                        stage="final",
+                        result_leg=result_leg,
+                        left_covered_legs=actual_left.legs,
+                        right_covered_legs=actual_right.legs,
+                        source_particle_legs=source_particle_legs,
+                    ),
+                ),
+            )
+        )
+
+
+def _append_contact_tree_partial_kernels(
+    kernels: list[CompiledOrientedKernel],
+    *,
+    term: CompiledVertexTerm,
+    node: _ContactTreeNode,
+    source_particles: Sequence[CompiledParticleRecord],
+    scalar_product_tree: bool,
+    start_kind: int,
+    model_symbols: ModelSymbolRegistry,
+) -> None:
+    if node.left is None or node.right is None:
+        raise ValueError("contact tree partial node is missing a child")
+    orientations = (
+        ((node.left, node.right),)
+        if node.left.particle.name == node.right.particle.name
+        else ((node.left, node.right), (node.right, node.left))
+    )
+    for actual_left, actual_right in orientations:
+        kind = start_kind + len(kernels)
+        canonical_left_side = "left" if actual_left is node.left else "right"
+        canonical_right_side = "right" if actual_right is node.right else "left"
+        left_payload = _contact_tree_node_payload(
+            kind,
+            canonical_left_side,
+            node.left,
+            source_particles,
+            scalar_product_tree=scalar_product_tree,
+            model_symbols=model_symbols,
+        )
+        right_payload = _contact_tree_node_payload(
+            kind,
+            canonical_right_side,
+            node.right,
+            source_particles,
+            scalar_product_tree=scalar_product_tree,
+            model_symbols=model_symbols,
+        )
+        components = (
+            (left_payload[0] * right_payload[0],)
+            if scalar_product_tree
+            else (*left_payload, *right_payload)
+        )
+        kernels.append(
+            CompiledOrientedKernel(
+                kind=kind,
+                term_id=term.id,
+                vertex=f"{term.vertex}::contact-tree-partial",
+                particles=(
+                    actual_left.particle.name,
+                    actual_right.particle.name,
+                    node.particle.name,
+                ),
+                source_particle_legs=(
+                    _contact_tree_source_leg(actual_left),
+                    _contact_tree_source_leg(actual_right),
+                    -1,
+                ),
+                component_expressions=tuple(
+                    component.to_canonical_string() for component in components
+                ),
+                coupling_expression="1",
+                coupling_orders=(),
+                runtime_parameters=(),
+                color_source="1",
+                color_expression="1",
+                lc_color_normalization_power=0,
+                term_ids=(),
+            )
+        )
+
+
+def _append_contact_tree_final_kernels(
+    kernels: list[CompiledOrientedKernel],
+    *,
+    term: CompiledVertexTerm,
+    source_particles: Sequence[CompiledParticleRecord],
+    left_node: _ContactTreeNode,
+    right_node: _ContactTreeNode,
+    result_leg: int,
+    result_name: str,
+    scalar_product_tree: bool,
+    assignment_multiplicity: int,
+    start_kind: int,
+    template_cache: dict[
+        tuple[object, ...],
+        tuple[int, tuple[_sym.Expression, ...]],
+    ],
+    model_symbols: ModelSymbolRegistry,
+) -> None:
+    orientations = (
+        ((left_node, right_node),)
+        if left_node.particle.name == right_node.particle.name
+        else ((left_node, right_node), (right_node, left_node))
+    )
+    canonical_kind = start_kind + len(kernels)
+    if scalar_product_tree:
+        left_payload = _contact_tree_node_payload(
+            canonical_kind,
+            "left",
+            left_node,
+            source_particles,
+            scalar_product_tree=True,
+            model_symbols=model_symbols,
+        )
+        right_payload = _contact_tree_node_payload(
+            canonical_kind,
+            "right",
+            right_node,
+            source_particles,
+            scalar_product_tree=True,
+            model_symbols=model_symbols,
+        )
+        canonical_components = (
+            left_payload[0] * right_payload[0] * _sym.E(term.lorentz_expression),
+        )
+    else:
+        template_key = (
+            term.lorentz_expression,
+            tuple(particle.spin for particle in source_particles),
+            result_leg,
+            left_node.legs,
+            right_node.legs,
+        )
+        cached = template_cache.get(template_key)
+        if cached is None:
+            canonical_components = _contact_tree_final_component_expressions(
+                term,
+                source_particles,
+                left_node=left_node,
+                right_node=right_node,
+                result_leg=result_leg,
+                kind=canonical_kind,
+                canonical_left_side="left",
+                canonical_right_side="right",
+                model_symbols=model_symbols,
+            )
+            template_cache[template_key] = canonical_kind, canonical_components
+        else:
+            template_kind, template_components = cached
+            canonical_components = tuple(
+                _remap_kernel_symbols(
+                    component,
+                    old_kind=template_kind,
+                    new_kind=canonical_kind,
+                    model_symbols=model_symbols,
+                )
+                for component in template_components
+            )
+    prefactor = (
+        symbols.derived_coupling(model_symbols.model_name, term.id)
+        / assignment_multiplicity
+    )
+    canonical_weighted_components = tuple(
+        _canonicalize_oriented_kernel_component(component * prefactor)
+        for component in canonical_components
+    )
+    for actual_left, actual_right in orientations:
+        kind = start_kind + len(kernels)
+        components = tuple(
+            _remap_kernel_symbols(
+                component,
+                old_kind=canonical_kind,
+                new_kind=kind,
+                model_symbols=model_symbols,
+                swap_sides=actual_left is right_node,
+            )
+            for component in canonical_weighted_components
+        )
+        kernels.append(
+            CompiledOrientedKernel(
+                kind=kind,
+                term_id=term.id,
+                vertex=f"{term.vertex}::contact-tree-final",
+                particles=(
+                    actual_left.particle.name,
+                    actual_right.particle.name,
+                    result_name,
+                ),
+                source_particle_legs=(
+                    _contact_tree_source_leg(actual_left),
+                    _contact_tree_source_leg(actual_right),
+                    result_leg,
+                ),
+                component_expressions=tuple(
+                    component.to_canonical_string() for component in components
+                ),
+                coupling_expression="1",
+                coupling_orders=term.coupling_orders,
+                runtime_parameters=(f"derived_coupling_{term.id}",),
+                color_source=term.color_source,
+                color_expression=term.color_expression,
+                lc_color_normalization_power=term.lc_color_normalization_power,
+                term_ids=(term.id,),
+            )
+        )
+
+
+def _contact_tree_node_payload(
+    kind: int,
+    side: str,
+    node: _ContactTreeNode,
+    source_particles: Sequence[CompiledParticleRecord],
+    *,
+    scalar_product_tree: bool,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[_sym.Expression, ...]:
+    if node.is_leaf:
+        if node.physical_leg is None:
+            raise ValueError("contact tree leaf has no source leg")
+        dimension = _spin_dimension(source_particles[node.physical_leg].spin)
+        components = tuple(
+            model_symbols.kernel_component(kind, side, index)
+            for index in range(dimension)
+        )
+        if scalar_product_tree:
+            return components
+        momenta = tuple(
+            model_symbols.kernel_momentum(kind, side, index) for index in range(4)
+        )
+        return (*components, *momenta)
+    dimension = compiled_particle_component_dimension(node.particle)
+    return tuple(
+        model_symbols.kernel_component(kind, side, index) for index in range(dimension)
+    )
+
+
+def _contact_tree_final_component_expressions(
+    term: CompiledVertexTerm,
+    source_particles: Sequence[CompiledParticleRecord],
+    *,
+    left_node: _ContactTreeNode,
+    right_node: _ContactTreeNode,
+    result_leg: int,
+    kind: int,
+    canonical_left_side: str,
+    canonical_right_side: str,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[_sym.Expression, ...]:
+    payload_by_leg = {
+        **_contact_tree_payload_by_leg(
+            kind,
+            canonical_left_side,
+            left_node,
+            source_particles,
+            model_symbols=model_symbols,
+        ),
+        **_contact_tree_payload_by_leg(
+            kind,
+            canonical_right_side,
+            right_node,
+            source_particles,
+            model_symbols=model_symbols,
+        ),
+    }
+    momentum_by_leg = {
+        leg: momentum for leg, (_components, momentum) in payload_by_leg.items()
+    }
+    momentum_by_leg[result_leg] = tuple(
+        -sum(
+            (momentum[component] for momentum in momentum_by_leg.values()),
+            _sym.E("0"),
+        )
+        for component in range(4)
+    )
+    library = _sym.TensorLibrary.hep_lib_atom()
+    expression = _sym.E(term.lorentz_expression)
+    minkowski = _sym.Representation.mink(4)
+    for leg, momentum in momentum_by_leg.items():
+        library.register(
+            _sym.Tensor.dense(
+                _sym.TensorName(model_symbols.ufo_momentum_tensor_name(leg + 1))(
+                    minkowski
+                ),
+                momentum,
+            )
+        )
+    input_work = math.prod(
+        _spin_dimension(source_particles[leg].spin) for leg in payload_by_leg
+    )
+    if input_work > _DIRECT_DENSE_CONTACT_INPUT_WORK and sys.platform.startswith(
+        "linux"
+    ):
+        result = _execute_contact_tensor_staged(
+            expression,
+            library,
+            source_particles,
+            payload_by_leg=payload_by_leg,
+            result_leg=result_leg,
+            kind=kind,
+            model_symbols=model_symbols,
+        )
+    else:
+        for leg, (components, _momentum) in sorted(payload_by_leg.items()):
+            expression *= _contact_tree_physical_tensor_expression(
+                library,
+                kind=kind,
+                leg=leg,
+                spin=source_particles[leg].spin,
+                components=components,
+                model_symbols=model_symbols,
+            )
+        result = _execute_dense_tensor(
+            expression,
+            library,
+            axis_labels=_spin_axis_labels(
+                source_particles[result_leg].spin,
+                result_leg + 1,
+            ),
+        )
+    expected = _spin_dimension(source_particles[result_leg].spin)
+    if len(result) != expected:
+        raise ValueError(
+            f"contact tree final {term.vertex}/{term.id} produced {len(result)} "
+            f"components, expected {expected}"
+        )
+    return tuple(
+        _replace_evaluator_constants(_as_expression(result[index]))
+        for index in range(len(result))
+    )
+
+
+def _execute_contact_tensor_staged(
+    expression: _sym.Expression,
+    library: _sym.TensorLibrary,
+    source_particles: Sequence[CompiledParticleRecord],
+    *,
+    payload_by_leg: Mapping[
+        int,
+        tuple[tuple[_sym.Expression, ...], tuple[_sym.Expression, ...]],
+    ],
+    result_leg: int,
+    kind: int,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[_sym.Expression, ...]:
+    """Contract high-rank inputs in bounded, model-independent stages."""
+
+    dimensions = tuple(_spin_dimension(particle.spin) for particle in source_particles)
+    input_legs = tuple(sorted(payload_by_leg, key=lambda leg: (-dimensions[leg], leg)))
+    if set(input_legs) != set(range(len(source_particles))) - {result_leg}:
+        raise ValueError("staged contact payload does not cover every input leg")
+    for leg in input_legs:
+        if len(payload_by_leg[leg][0]) != dimensions[leg]:
+            raise ValueError(f"staged contact input leg {leg} has wrong dimension")
+    remaining_legs = list(range(len(source_particles)))
+    pending_legs = list(input_legs)
+    step = 0
+    while pending_legs:
+        stage_legs: list[int] = []
+        stage_work = 1
+        while pending_legs:
+            next_leg = pending_legs[0]
+            next_work = stage_work * dimensions[next_leg]
+            if stage_legs and next_work > _MAX_STAGED_CONTACT_INPUT_WORK:
+                break
+            stage_legs.append(pending_legs.pop(0))
+            stage_work = next_work
+        for leg in stage_legs:
+            expression *= _contact_tree_physical_tensor_expression(
+                library,
+                kind=kind,
+                leg=leg,
+                spin=source_particles[leg].spin,
+                components=payload_by_leg[leg][0],
+                model_symbols=model_symbols,
+            )
+            remaining_legs.remove(leg)
+        axis_labels = tuple(
+            label
+            for remaining_leg in remaining_legs
+            for label in _spin_axis_labels(
+                source_particles[remaining_leg].spin,
+                remaining_leg + 1,
+            )
+        )
+        dense = _execute_dense_tensor(
+            expression,
+            library,
+            axis_labels=axis_labels,
+        )
+        expected = math.prod(dimensions[index] for index in remaining_legs)
+        if len(dense) != expected:
+            raise ValueError(
+                f"staged contact contraction {step} produced {len(dense)} "
+                f"components, expected {expected}"
+            )
+        if not pending_legs:
+            return tuple(_as_expression(component) for component in dense)
+        representations = tuple(
+            representation
+            for remaining_leg in remaining_legs
+            for representation in _spin_representations(
+                source_particles[remaining_leg].spin
+            )
+        )
+        if not representations:
+            if len(dense) != 1:
+                raise ValueError("scalar staged contact must have one component")
+            expression = _as_expression(dense[0])
+            library = _sym.TensorLibrary.hep_lib_atom()
+            continue
+        slots = tuple(
+            slot
+            for remaining_leg in remaining_legs
+            for slot in _spin_slots(
+                source_particles[remaining_leg].spin,
+                remaining_leg + 1,
+            )
+        )
+        library = _sym.TensorLibrary.hep_lib_atom()
+        name = _sym.TensorName(
+            model_symbols.kernel_tensor_name(kind, f"contact_stage_{step}")
+        )
+        library.register(
+            _sym.Tensor.dense(
+                name(*representations),
+                tuple(_as_expression(component) for component in dense),
+            )
+        )
+        expression = name(*slots).to_expression()
+        step += 1
+    raise ValueError("staged contact contraction has no input legs")
+
+
+def eager_color_singlet_vertex_term_components(
+    term: CompiledVertexTerm,
+    particles: Sequence[CompiledParticleRecord],
+    *,
+    result_leg: int,
+    input_components: Mapping[int, Sequence[_sym.Expression]],
+    input_momenta: Mapping[int, Sequence[_sym.Expression]],
+    coupling: _sym.Expression | None = None,
+    model_symbols: ModelSymbolRegistry | None = None,
+) -> tuple[_sym.Expression, ...]:
+    """Contract one original color-singlet n-ary term without its lowered tree."""
+
+    _sym._ensure_symbolica()
+
+    if not _contact_term_is_color_singlet(term):
+        raise ValueError("the eager n-ary oracle currently requires a color singlet")
+    if not 0 <= result_leg < term.valence:
+        raise ValueError(f"result leg {result_leg} is outside valence {term.valence}")
+    particle_by_name = {particle.name: particle for particle in particles}
+    source_particles = tuple(particle_by_name[name] for name in term.particles)
+    tensor_symbols = model_symbols or symbols.model("eager-contact-oracle")
+    input_legs = set(range(term.valence)) - {result_leg}
+    if set(input_components) != input_legs or set(input_momenta) != input_legs:
+        raise ValueError(
+            "eager n-ary inputs must provide every non-result leg exactly once"
+        )
+
+    library = _sym.TensorLibrary.hep_lib_atom()
+    expression = _sym.E(term.lorentz_expression)
+    momentum_by_leg: dict[int, tuple[_sym.Expression, ...]] = {}
+    for leg in sorted(input_legs):
+        components = tuple(input_components[leg])
+        expected_dimension = _spin_dimension(source_particles[leg].spin)
+        if len(components) != expected_dimension:
+            raise ValueError(
+                f"input leg {leg} has {len(components)} components, "
+                f"expected {expected_dimension}"
+            )
+        momentum = tuple(input_momenta[leg])
+        if len(momentum) != 4:
+            raise ValueError(f"input leg {leg} momentum must have four components")
+        momentum_by_leg[leg] = momentum
+        expression *= _contact_tree_physical_tensor_expression(
+            library,
+            kind=term.id,
+            leg=leg,
+            spin=source_particles[leg].spin,
+            components=components,
+            model_symbols=tensor_symbols,
+        )
+
+    momentum_by_leg[result_leg] = tuple(
+        -sum(
+            (momentum[component] for momentum in momentum_by_leg.values()),
+            _sym.E("0"),
+        )
+        for component in range(4)
+    )
+    minkowski = _sym.Representation.mink(4)
+    for leg, momentum in momentum_by_leg.items():
+        library.register(
+            _sym.Tensor.dense(
+                _sym.TensorName(tensor_symbols.ufo_momentum_tensor_name(leg + 1))(
+                    minkowski
+                ),
+                momentum,
+            )
+        )
+    if coupling is not None:
+        expression *= coupling
+    result = _execute_dense_tensor(
+        expression,
+        library,
+        axis_labels=_spin_axis_labels(
+            source_particles[result_leg].spin,
+            result_leg + 1,
+        ),
+    )
+    expected_dimension = _spin_dimension(source_particles[result_leg].spin)
+    if len(result) != expected_dimension:
+        raise ValueError(
+            f"eager n-ary term {term.vertex}/{term.id} produced {len(result)} "
+            f"components, expected {expected_dimension}"
+        )
+    return tuple(
+        _replace_evaluator_constants(_as_expression(result[index]))
+        for index in range(len(result))
+    )
+
+
+def _contact_tree_payload_by_leg(
+    kind: int,
+    side: str,
+    node: _ContactTreeNode,
+    source_particles: Sequence[CompiledParticleRecord],
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> dict[int, tuple[tuple[_sym.Expression, ...], tuple[_sym.Expression, ...]]]:
+    payload = _contact_tree_node_payload(
+        kind,
+        side,
+        node,
+        source_particles,
+        scalar_product_tree=False,
+        model_symbols=model_symbols,
+    )
+    result: dict[
+        int, tuple[tuple[_sym.Expression, ...], tuple[_sym.Expression, ...]]
+    ] = {}
+    cursor = 0
+    for leg in node.legs:
+        dimension = _spin_dimension(source_particles[leg].spin)
+        components = tuple(payload[cursor : cursor + dimension])
+        cursor += dimension
+        momentum = tuple(payload[cursor : cursor + 4])
+        cursor += 4
+        result[leg] = components, momentum
+    if cursor != len(payload):
+        raise ValueError("contact tree payload layout mismatch")
+    return result
+
+
+def _contact_tree_physical_tensor_expression(
+    library: _sym.TensorLibrary,
+    *,
+    kind: int,
+    leg: int,
+    spin: int,
+    components: Sequence[_sym.Expression],
+    model_symbols: ModelSymbolRegistry,
+) -> _sym.Expression:
+    representations = _spin_representations(spin)
+    if not representations:
+        if len(components) != 1:
+            raise ValueError("scalar contact input must have one component")
+        return components[0]
+    name = _sym.TensorName(model_symbols.contact_leg_tensor_name(kind, leg))
+    library.register(_sym.Tensor.dense(name(*representations), components))
+    return name(*_spin_slots(spin, leg + 1)).to_expression()
+
+
+def _contact_tree_assignment_multiplicity(
+    input_legs: Sequence[int],
+    source_particles: Sequence[CompiledParticleRecord],
+    left_root: _ContactTreeNode,
+    right_root: _ContactTreeNode,
+) -> int:
+    species_counts: dict[str, int] = {}
+    for leg in input_legs:
+        name = source_particles[leg].name
+        species_counts[name] = species_counts.get(name, 0) + 1
+    permutations = math.prod(math.factorial(count) for count in species_counts.values())
+    symmetry_nodes = (
+        _contact_tree_same_input_node_count(left_root)
+        + _contact_tree_same_input_node_count(right_root)
+        + int(left_root.particle.name == right_root.particle.name)
+    )
+    symmetry_divisor = 2**symmetry_nodes
+    if permutations % symmetry_divisor:
+        raise ValueError("contact tree assignment symmetry is not integral")
+    return permutations // symmetry_divisor
+
+
+def _contact_tree_same_input_node_count(node: _ContactTreeNode) -> int:
+    if node.is_leaf:
+        return 0
+    if node.left is None or node.right is None:
+        raise ValueError("contact tree internal node is missing a child")
+    return (
+        int(node.left.particle.name == node.right.particle.name)
+        + _contact_tree_same_input_node_count(node.left)
+        + _contact_tree_same_input_node_count(node.right)
+    )
+
+
+def _contact_tree_source_leg(node: _ContactTreeNode) -> int:
+    return -1 if node.physical_leg is None else node.physical_leg
+
+
+def _contact_term_is_color_singlet(term: CompiledVertexTerm) -> bool:
+    return term.color_source in {"1", "UFO::{}::1"} or term.color_expression == "1"
+
+
+def _deduplicate_contact_partials(
+    auxiliary_particles: Sequence[CompiledParticleRecord],
+    kernels: Sequence[CompiledOrientedKernel],
+    terms: Sequence[CompiledVertexTerm],
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[tuple[CompiledParticleRecord, ...], tuple[CompiledOrientedKernel, ...]]:
+    term_by_id = {term.id: term for term in terms}
+    auxiliary_by_name = {particle.name: particle for particle in auxiliary_particles}
+    representative_by_signature: dict[tuple[object, ...], tuple[str, int]] = {}
+    replacement: dict[str, str] = {}
+    retained: list[CompiledOrientedKernel] = []
+
+    for kernel in kernels:
+        if not kernel.vertex.endswith("::contact-partial"):
+            retained.append(kernel)
+            continue
+        auxiliary = auxiliary_by_name[kernel.particles[2]]
+        term = term_by_id[kernel.term_id]
+        substitutions = {
+            symbols.derived_coupling(
+                model_symbols.model_name,
+                int(name.rsplit("_", 1)[1]),
+            ): _sym.E(term.coupling_expression)
+            for name in kernel.runtime_parameters
+            if name.startswith("derived_coupling_")
+        }
+        normalized_components = tuple(
+            _replace_expression_symbols(
+                _remap_kernel_symbols(
+                    _sym.E(component),
+                    old_kind=kernel.kind,
+                    new_kind=0,
+                    model_symbols=model_symbols,
+                ),
+                substitutions,
+            ).to_canonical_string()
+            for component in kernel.component_expressions
+        )
+        signature = (
+            kernel.particles[:2],
+            compiled_particle_component_dimension(auxiliary),
+            auxiliary.color,
+            kernel.coupling_orders,
+            kernel.color_source,
+            kernel.lc_color_normalization_power,
+            normalized_components,
+            auxiliary.auxiliary_kind if kernel.contact_orbit_steps else None,
+        )
+        representative = representative_by_signature.get(signature)
+        if representative is None:
+            representative_by_signature[signature] = (
+                auxiliary.name,
+                len(retained),
+            )
+            retained.append(kernel)
+        else:
+            representative_name, representative_index = representative
+            replacement[auxiliary.name] = representative_name
+            retained[representative_index] = replace(
+                retained[representative_index],
+                contact_orbit_steps=canonical_contact_orbit_steps(
+                    retained[representative_index].contact_orbit_steps,
+                    kernel.contact_orbit_steps,
+                ),
+            )
+
+    if not replacement:
+        return tuple(auxiliary_particles), tuple(kernels)
+
+    rewritten = tuple(
+        replace(
+            kernel,
+            particles=tuple(replacement.get(name, name) for name in kernel.particles),
+        )
+        for kernel in retained
+    )
+    particles = tuple(
+        particle for particle in auxiliary_particles if particle.name not in replacement
+    )
+    return particles, rewritten
diff --git a/pyamplicol/src/pyamplicol/models/compiler_contacts.py b/pyamplicol/src/pyamplicol/models/compiler_contacts.py
new file mode 100644
index 0000000000..f57063400f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_contacts.py
@@ -0,0 +1,1009 @@
+# SPDX-License-Identifier: 0BSD
+"""Four-point contact component compression and fusion."""
+
+from __future__ import annotations
+
+import math
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import replace
+
+from .._internal.physics.symbols import ModelSymbolRegistry, symbols
+from . import compiler_symbolica as _sym
+from .compiler_kernels import (
+    _as_expression,
+    _canonicalize_oriented_kernel_component,
+    _component_symbols,
+    _function_arguments,
+    _input_tensor_expression,
+    _ordered_dense_tensor_components,
+    _permutation_sign,
+    _remap_kernel_symbols,
+    _replace_expression_symbols,
+    _spin_axis_labels,
+    _spin_dimension,
+    _spin_representations,
+    _spin_slots,
+)
+from .compiler_records import _replace_evaluator_constants
+from .contact_decomposition import (
+    CONTACT_DECOMPOSITION_ALGORITHM,
+    CONTACT_DECOMPOSITION_ALGORITHM_VERSION,
+    CONTACT_ORBIT_ALGORITHM,
+    CONTACT_ORBIT_ALGORITHM_VERSION,
+    CONTACT_ORBIT_EVALUATOR_CLASS,
+    CompiledContactDecompositionProof,
+    CompiledContactDecompositionSplit,
+    CompiledContactDummyIndexMapping,
+    CompiledContactOrbitCertificate,
+    CompiledContactOrientationProof,
+    CompiledContactUnsupportedReason,
+    canonical_contact_orbit_steps,
+    contact_orbit_evaluator_class_is_certifiable,
+)
+from .contracts import (
+    CompiledOrientedKernel,
+    CompiledParticleRecord,
+    CompiledVertexTerm,
+    compiled_particle_component_dimension,
+)
+
+
+def _fuse_contact_finals(
+    kernels: Sequence[CompiledOrientedKernel],
+    terms: Sequence[CompiledVertexTerm],
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[CompiledOrientedKernel, ...]:
+    coupling_by_term = {term.id: term.coupling_expression for term in terms}
+    groups: dict[tuple[object, ...], list[CompiledOrientedKernel]] = {}
+    passthrough: list[CompiledOrientedKernel] = []
+    for kernel in kernels:
+        if not kernel.vertex.endswith("::contact-final"):
+            passthrough.append(kernel)
+            continue
+        key = (
+            kernel.particles,
+            kernel.coupling_orders,
+            kernel.color_source,
+            kernel.lc_color_normalization_power,
+        )
+        groups.setdefault(key, []).append(kernel)
+
+    fused: list[CompiledOrientedKernel] = []
+    for members in groups.values():
+        first = members[0]
+        runtime_aliases: dict[_sym.Expression, _sym.Expression] = {}
+        canonical_runtime_name: str | None = None
+        if all(
+            coupling_by_term.get(member.term_id) == coupling_by_term.get(first.term_id)
+            for member in members
+        ):
+            canonical_runtime_name = f"derived_coupling_{first.term_id}"
+            canonical_runtime = symbols.derived_coupling(
+                model_symbols.model_name,
+                first.term_id,
+            )
+            runtime_aliases = {
+                symbols.derived_coupling(
+                    model_symbols.model_name,
+                    member.term_id,
+                ): canonical_runtime
+                for member in members
+            }
+        components = tuple(
+            _canonicalize_oriented_kernel_component(
+                sum(
+                    (
+                        _replace_expression_symbols(
+                            _remap_kernel_symbols(
+                                _sym.E(member.component_expressions[index]),
+                                old_kind=member.kind,
+                                new_kind=first.kind,
+                                model_symbols=model_symbols,
+                            ),
+                            runtime_aliases,
+                        )
+                        for member in members
+                    ),
+                    _sym.E("0"),
+                )
+            ).to_canonical_string()
+            for index in range(len(first.component_expressions))
+        )
+        fused.append(
+            replace(
+                first,
+                vertex=first.vertex.replace(
+                    "::contact-final",
+                    "::contact-final-fused",
+                ),
+                component_expressions=components,
+                runtime_parameters=(
+                    (canonical_runtime_name,)
+                    if canonical_runtime_name is not None
+                    else tuple(
+                        sorted(
+                            {
+                                name
+                                for member in members
+                                for name in member.runtime_parameters
+                            }
+                        )
+                    )
+                ),
+                term_ids=tuple(
+                    term_id
+                    for member in members
+                    for term_id in (member.term_ids or (member.term_id,))
+                ),
+                contact_orbit_steps=canonical_contact_orbit_steps(
+                    *(member.contact_orbit_steps for member in members)
+                ),
+            )
+        )
+    return tuple(sorted((*passthrough, *fused), key=lambda kernel: kernel.kind))
+
+
+def _contact_partial_component_expressions(
+    term: CompiledVertexTerm,
+    particle_by_name: Mapping[str, CompiledParticleRecord],
+    *,
+    left_leg: int,
+    right_leg: int,
+    open_legs: tuple[int, ...],
+    kind: int,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[str, ...]:
+    library = _sym.TensorLibrary.hep_lib_atom()
+    expression = _sym.E(term.lorentz_expression)
+    particles = tuple(particle_by_name[name] for name in term.particles)
+    expression *= _input_tensor_expression(
+        library,
+        kind=kind,
+        side="left",
+        spin=particles[left_leg].spin,
+        leg=left_leg + 1,
+        components=_component_symbols(
+            kind,
+            "left",
+            particles[left_leg].spin,
+            model_symbols=model_symbols,
+        ),
+        model_symbols=model_symbols,
+    )
+    expression *= _input_tensor_expression(
+        library,
+        kind=kind,
+        side="right",
+        spin=particles[right_leg].spin,
+        leg=right_leg + 1,
+        components=_component_symbols(
+            kind,
+            "right",
+            particles[right_leg].spin,
+            model_symbols=model_symbols,
+        ),
+        model_symbols=model_symbols,
+    )
+    result = _execute_dense_tensor(
+        expression,
+        library,
+        axis_labels=tuple(
+            label
+            for leg in open_legs
+            for label in _spin_axis_labels(particles[leg].spin, leg + 1)
+        ),
+    )
+    expected = math.prod(_spin_dimension(particles[leg].spin) for leg in open_legs)
+    if len(result) != expected:
+        raise ValueError(
+            f"contact partial {term.vertex}/{term.id} produced {len(result)} "
+            f"components, expected {expected}"
+        )
+    return tuple(
+        _replace_evaluator_constants(
+            _as_expression(result[index])
+        ).to_canonical_string()
+        for index in range(len(result))
+    )
+
+
+def _contact_final_component_expressions(
+    particles: Sequence[CompiledParticleRecord],
+    auxiliary: CompiledParticleRecord,
+    *,
+    open_legs: tuple[int, ...],
+    remaining_leg: int,
+    result_leg: int,
+    kind: int,
+    auxiliary_on_left: bool,
+    component_expansion: tuple[tuple[int, int] | None, ...],
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[str, ...]:
+    library = _sym.TensorLibrary.hep_lib_atom()
+    auxiliary_side = "left" if auxiliary_on_left else "right"
+    physical_side = "right" if auxiliary_on_left else "left"
+    auxiliary_symbols = tuple(
+        model_symbols.kernel_component(kind, auxiliary_side, component)
+        for component in range(compiled_particle_component_dimension(auxiliary))
+    )
+    expanded_auxiliary = tuple(
+        _sym.E("0") if entry is None else entry[1] * auxiliary_symbols[entry[0]]
+        for entry in component_expansion
+    )
+    expression = _contact_auxiliary_tensor_expression(
+        library,
+        kind=kind,
+        side=auxiliary_side,
+        particles=particles,
+        open_legs=open_legs,
+        components=expanded_auxiliary,
+        model_symbols=model_symbols,
+    )
+    expression *= _input_tensor_expression(
+        library,
+        kind=kind,
+        side=physical_side,
+        spin=particles[remaining_leg].spin,
+        leg=remaining_leg + 1,
+        components=_component_symbols(
+            kind,
+            physical_side,
+            particles[remaining_leg].spin,
+            model_symbols=model_symbols,
+        ),
+        model_symbols=model_symbols,
+    )
+    result = _execute_dense_tensor(
+        expression,
+        library,
+        axis_labels=_spin_axis_labels(particles[result_leg].spin, result_leg + 1),
+    )
+    expected = _spin_dimension(particles[result_leg].spin)
+    if len(result) != expected:
+        raise ValueError(
+            f"contact final for source leg {result_leg} produced {len(result)} "
+            f"components, expected {expected}"
+        )
+    return tuple(
+        _replace_evaluator_constants(
+            _as_expression(result[index])
+        ).to_canonical_string()
+        for index in range(len(result))
+    )
+
+
+def _contact_auxiliary_tensor_expression(
+    library: _sym.TensorLibrary,
+    *,
+    kind: int,
+    side: str,
+    particles: Sequence[CompiledParticleRecord],
+    open_legs: tuple[int, ...],
+    components: Sequence[_sym.Expression],
+    model_symbols: ModelSymbolRegistry,
+) -> _sym.Expression:
+    representations = tuple(
+        representation
+        for leg in open_legs
+        for representation in _spin_representations(particles[leg].spin)
+    )
+    if not representations:
+        if len(components) != 1:
+            raise ValueError("scalar contact auxiliary must have one component")
+        return components[0]
+    slots = tuple(
+        slot for leg in open_legs for slot in _spin_slots(particles[leg].spin, leg + 1)
+    )
+    name = _sym.TensorName(model_symbols.kernel_tensor_name(kind, side))
+    library.register(_sym.Tensor.dense(name(*representations), components))
+    return name(*slots).to_expression()
+
+
+def _execute_dense_tensor(
+    expression: _sym.Expression,
+    library: _sym.TensorLibrary,
+    *,
+    axis_labels: Sequence[str],
+) -> tuple[object, ...]:
+    if not axis_labels and set(expression.get_all_symbols()) == set(
+        expression.get_all_symbols(include_function_symbols=False)
+    ):
+        # A rank-zero expression with no function indeterminates contains no
+        # tensor heads to contract. Spenso need not construct a tensor network.
+        return (expression,)
+    network = _sym.TensorNetwork(
+        _sym.as_tensor(expression) if axis_labels else expression, library
+    )
+    network.execute(library=library)
+    result = network.result_tensor(library)
+    return _ordered_dense_tensor_components(result, axis_labels).values
+
+
+def _contact_auxiliary_color(
+    term: CompiledVertexTerm,
+    particles: Sequence[CompiledParticleRecord],
+    *,
+    remaining_leg: int,
+    result_leg: int,
+) -> int:
+    colors = tuple(particle.color for particle in particles)
+    if all(color == 1 for color in colors):
+        return 1
+    if "f(" in term.color_source or "::f(" in term.color_source:
+        return 8
+    remaining = abs(colors[remaining_leg])
+    result = abs(colors[result_leg])
+    if remaining == 1:
+        return int(colors[result_leg])
+    if result == 1:
+        return int(colors[remaining_leg])
+    if remaining == result == 8:
+        return 1
+    return 1
+
+
+def _compress_contact_components(
+    components: Sequence[str],
+) -> tuple[tuple[int, ...], tuple[tuple[int, int] | None, ...]]:
+    representatives: list[_sym.Expression] = []
+    representative_indices: list[int] = []
+    expansion: list[tuple[int, int] | None] = []
+    zero = _sym.E("0")
+    for index, source in enumerate(components):
+        expression = _sym.E(source)
+        if str(expression) == "0":
+            expansion.append(None)
+            continue
+        match: tuple[int, int] | None = None
+        for basis_index, representative in enumerate(representatives):
+            if str((expression - representative).expand()) == "0":
+                match = (basis_index, 1)
+                break
+            if str((expression + representative).expand()) == "0":
+                match = (basis_index, -1)
+                break
+        if match is None:
+            match = (len(representatives), 1)
+            representatives.append(expression)
+            representative_indices.append(index)
+        expansion.append(match)
+    if not representatives:
+        representatives.append(zero)
+        representative_indices.append(0)
+        expansion[0] = (0, 1)
+    return tuple(representative_indices), tuple(expansion)
+
+
+def _record_contact_decomposition_proofs(
+    terms: Sequence[CompiledVertexTerm],
+    particles: Sequence[CompiledParticleRecord],
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[CompiledVertexTerm, ...]:
+    """Attach explicit proof records before four-point contact lowering."""
+
+    particle_by_name = {particle.name: particle for particle in particles}
+    result: list[CompiledVertexTerm] = []
+    for term in terms:
+        if term.valence != 4 or "ufo_momentum_" in term.lorentz_expression:
+            result.append(term)
+            continue
+        source_particles = tuple(particle_by_name[name] for name in term.particles)
+        proof = _build_contact_decomposition_proof(
+            term,
+            source_particles,
+            particle_by_name,
+            model_symbols=model_symbols,
+        )
+        result.append(
+            replace(
+                term,
+                contact_decomposition_proof=proof,
+                contact_orbit_certificate=_build_contact_orbit_certificate(
+                    term,
+                    source_particles,
+                    proof,
+                ),
+            )
+        )
+    return tuple(result)
+
+
+def _build_contact_orbit_certificate(
+    term: CompiledVertexTerm,
+    source_particles: Sequence[CompiledParticleRecord],
+    proof: CompiledContactDecompositionProof,
+) -> CompiledContactOrbitCertificate | None:
+    """Issue the deliberately narrow compiler-owned contact-orbit proof."""
+
+    if (
+        proof.status != "proven"
+        or not proof.matches(term)
+        or tuple(particle.name for particle in source_particles) != term.particles
+        or not contact_orbit_evaluator_class_is_certifiable(
+            color_source=term.color_source,
+            color_expression=term.color_expression,
+            lorentz_expression=term.lorentz_expression,
+            decomposition_kinds=tuple(
+                split.decomposition_kind for split in proof.splits
+            ),
+            particle_contracts=tuple(
+                (
+                    particle.spin,
+                    particle.color,
+                    particle.statistics,
+                    particle.wavefunction_family,
+                    particle.self_conjugate,
+                )
+                for particle in source_particles
+            ),
+        )
+    ):
+        return None
+    equivalence_classes: dict[str, int] = {}
+    leg_classes = tuple(
+        equivalence_classes.setdefault(particle.name, len(equivalence_classes))
+        for particle in source_particles
+    )
+    if len(leg_classes) != 4:
+        raise ValueError("contact-orbit certificate requires exactly four particles")
+    return CompiledContactOrbitCertificate(
+        algorithm=CONTACT_ORBIT_ALGORITHM,
+        algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+        term_id=term.id,
+        vertex=term.vertex,
+        particles=(
+            source_particles[0].name,
+            source_particles[1].name,
+            source_particles[2].name,
+            source_particles[3].name,
+        ),
+        color_expression=term.color_expression,
+        lorentz_expression=term.lorentz_expression,
+        coupling_expression=term.coupling_expression,
+        evaluator_class=CONTACT_ORBIT_EVALUATOR_CLASS,
+        physical_leg_equivalence_classes=(
+            leg_classes[0],
+            leg_classes[1],
+            leg_classes[2],
+            leg_classes[3],
+        ),
+        reconstruction_factor="1",
+    )
+
+
+def _build_contact_decomposition_proof(
+    term: CompiledVertexTerm,
+    source_particles: Sequence[CompiledParticleRecord],
+    particle_by_name: Mapping[str, CompiledParticleRecord],
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> CompiledContactDecompositionProof:
+    result_legs: list[int] = []
+    result_particle_names: set[str] = set()
+    for result_leg, source_result in enumerate(source_particles):
+        if source_result.name in result_particle_names:
+            continue
+        result_particle_names.add(source_result.name)
+        result_legs.append(result_leg)
+
+    literal_singlet = _contact_term_has_literal_color_singlet(term)
+    if literal_singlet and any(particle.color != 1 for particle in source_particles):
+        return _contact_proof(
+            term,
+            status="unsupported",
+            unsupported_reasons=(
+                _contact_unsupported_reason(
+                    "literal-singlet-with-colored-legs",
+                    "a literal color singlet cannot contract non-singlet external legs",
+                    color_representations=",".join(
+                        str(particle.color) for particle in source_particles
+                    ),
+                ),
+            ),
+        )
+
+    splits: list[CompiledContactDecompositionSplit] = []
+    unsupported: list[CompiledContactUnsupportedReason] = []
+    for result_leg in result_legs:
+        color_split = _four_point_contact_color_split(
+            term,
+            result_leg,
+            model_symbols=model_symbols,
+        )
+        if color_split is None:
+            unsupported.append(
+                _unsupported_contact_color_split_reason(
+                    term,
+                    result_leg,
+                    model_symbols=model_symbols,
+                )
+            )
+            continue
+        splits.append(
+            _contact_decomposition_split_proof(
+                term,
+                source_particles,
+                particle_by_name,
+                result_leg=result_leg,
+                color_split=color_split,
+                model_symbols=model_symbols,
+            )
+        )
+    if unsupported:
+        return _contact_proof(
+            term,
+            status="unsupported",
+            unsupported_reasons=tuple(unsupported),
+        )
+    return _contact_proof(term, status="proven", splits=tuple(splits))
+
+
+def _contact_decomposition_split_proof(
+    term: CompiledVertexTerm,
+    source_particles: Sequence[CompiledParticleRecord],
+    particle_by_name: Mapping[str, CompiledParticleRecord],
+    *,
+    result_leg: int,
+    color_split: tuple[
+        tuple[int, int],
+        int,
+        str,
+        str,
+        int,
+        int,
+        tuple[int, ...],
+        tuple[int, ...],
+        int,
+        str,
+    ],
+    model_symbols: ModelSymbolRegistry,
+) -> CompiledContactDecompositionSplit:
+    (
+        pair_legs,
+        remaining_leg,
+        outer_color_source,
+        final_color_source,
+        outer_color_power,
+        final_color_power,
+        outer_color_factor,
+        final_color_factor,
+        color_dummy,
+        color_coefficient,
+    ) = color_split
+    open_legs = (
+        min(remaining_leg, result_leg),
+        max(remaining_leg, result_leg),
+    )
+    canonical_components = _contact_partial_component_expressions(
+        term,
+        particle_by_name,
+        left_leg=pair_legs[0],
+        right_leg=pair_legs[1],
+        open_legs=open_legs,
+        kind=term.id,
+        model_symbols=model_symbols,
+    )
+    representative_indices, component_expansion = _compress_contact_components(
+        canonical_components
+    )
+    assignment_multiplicity = sum(
+        source_particles[leg].name == source_particles[remaining_leg].name
+        for leg in range(4)
+        if leg != result_leg
+    )
+    pair_orders = (
+        (pair_legs,)
+        if source_particles[pair_legs[0]].name == source_particles[pair_legs[1]].name
+        else (pair_legs, tuple(reversed(pair_legs)))
+    )
+    canonical_outer_parity = (
+        _permutation_sign(
+            outer_color_factor,
+            (color_dummy, pair_legs[0] + 1, pair_legs[1] + 1),
+        )
+        if outer_color_factor
+        else 1
+    )
+    orientations: list[CompiledContactOrientationProof] = []
+    for left_leg, right_leg in pair_orders:
+        outer_parity = (
+            _permutation_sign(
+                outer_color_factor,
+                (color_dummy, left_leg + 1, right_leg + 1),
+            )
+            if outer_color_factor
+            else 1
+        )
+        orientations.append(
+            CompiledContactOrientationProof(
+                stage="partial",
+                input_legs=(left_leg, right_leg),
+                permutation_parity=outer_parity,
+                scalar_prefactor=_canonical_scalar_prefactor(
+                    _sym.E(str(outer_parity)) / canonical_outer_parity
+                ),
+            )
+        )
+
+    for auxiliary_on_left in (True, False):
+        final_input_tokens = (
+            (color_dummy, remaining_leg + 1)
+            if auxiliary_on_left
+            else (remaining_leg + 1, color_dummy)
+        )
+        final_parity = (
+            _permutation_sign(
+                final_color_factor,
+                (result_leg + 1, *final_input_tokens),
+            )
+            if final_color_factor
+            else 1
+        )
+        orientations.append(
+            CompiledContactOrientationProof(
+                stage="final",
+                input_legs=(
+                    (-1, remaining_leg) if auxiliary_on_left else (remaining_leg, -1)
+                ),
+                permutation_parity=final_parity,
+                scalar_prefactor=_canonical_scalar_prefactor(
+                    _sym.E(color_coefficient)
+                    * canonical_outer_parity
+                    * final_parity
+                    / assignment_multiplicity
+                ),
+            )
+        )
+
+    dummy_mapping = (
+        CompiledContactDummyIndexMapping(
+            source_index=color_dummy,
+            normalized_symbol=f"ufo_c_dummy_{abs(color_dummy)}_adjoint",
+            outer_slot=outer_color_factor.index(color_dummy),
+            final_slot=final_color_factor.index(color_dummy),
+        )
+        if outer_color_factor
+        else None
+    )
+    return CompiledContactDecompositionSplit(
+        decomposition_kind=(
+            "two-structure-constants" if outer_color_factor else "literal-color-singlet"
+        ),
+        result_leg=result_leg,
+        pair_legs=pair_legs,
+        remaining_leg=remaining_leg,
+        outer_color_source=outer_color_source,
+        final_color_source=final_color_source,
+        outer_color_factor=outer_color_factor,
+        final_color_factor=final_color_factor,
+        dummy_index_mapping=dummy_mapping,
+        outer_color_normalization_power=outer_color_power,
+        final_color_normalization_power=final_color_power,
+        color_coefficient=color_coefficient,
+        auxiliary_color=_contact_auxiliary_color(
+            term,
+            source_particles,
+            remaining_leg=remaining_leg,
+            result_leg=result_leg,
+        ),
+        open_legs=open_legs,
+        component_axis_order=tuple(
+            label
+            for leg in open_legs
+            for label in _spin_axis_labels(source_particles[leg].spin, leg + 1)
+        ),
+        component_basis_order=representative_indices,
+        component_expansion=component_expansion,
+        assignment_multiplicity=assignment_multiplicity,
+        canonical_outer_parity=canonical_outer_parity,
+        orientations=tuple(orientations),
+    )
+
+
+def _contact_proof(
+    term: CompiledVertexTerm,
+    *,
+    status: str,
+    splits: tuple[CompiledContactDecompositionSplit, ...] = (),
+    unsupported_reasons: tuple[CompiledContactUnsupportedReason, ...] = (),
+) -> CompiledContactDecompositionProof:
+    return CompiledContactDecompositionProof(
+        status=status,
+        algorithm=CONTACT_DECOMPOSITION_ALGORITHM,
+        algorithm_version=CONTACT_DECOMPOSITION_ALGORITHM_VERSION,
+        term_id=term.id,
+        vertex=term.vertex,
+        particles=term.particles,
+        color_index=term.color_index,
+        lorentz_index=term.lorentz_index,
+        original_color_source=term.color_source,
+        normalized_color_expression=term.color_expression,
+        lorentz_name=term.lorentz_name,
+        original_lorentz_source=term.lorentz_source,
+        normalized_lorentz_expression=term.lorentz_expression,
+        splits=splits,
+        unsupported_reasons=unsupported_reasons,
+    )
+
+
+def _contact_unsupported_reason(
+    code: str,
+    message: str,
+    **context: str,
+) -> CompiledContactUnsupportedReason:
+    return CompiledContactUnsupportedReason(
+        code=code,
+        message=message,
+        context=tuple(sorted(context.items())),
+    )
+
+
+def _unsupported_contact_color_split_reason(
+    term: CompiledVertexTerm,
+    result_leg: int,
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> CompiledContactUnsupportedReason:
+    common = {
+        "normalized_color_expression": term.color_expression,
+        "result_leg": str(result_leg),
+    }
+    factor_arguments = _function_arguments(term.color_expression, "::f")
+    if len(factor_arguments) != 2:
+        return _contact_unsupported_reason(
+            "unsupported-color-factor-count",
+            "contact color expression is not exactly two structure constants",
+            factor_count=str(len(factor_arguments)),
+            **common,
+        )
+    factors = _normalized_structure_constant_factors(term.color_expression)
+    if len(factors) != 2:
+        return _contact_unsupported_reason(
+            "malformed-structure-constant-indices",
+            "contact structure-constant indices are not normalized adjoint indices",
+            **common,
+        )
+    if (
+        _source_structure_constant_product_coefficient(
+            term.color_source,
+            model_symbols=model_symbols,
+        )
+        is None
+    ):
+        return _contact_unsupported_reason(
+            "non-scalar-color-prefactor",
+            "contact structure constants retain a non-scalar color factor",
+            **common,
+        )
+    shared_dummies = set(value for value in factors[0] if value < 0) & set(
+        value for value in factors[1] if value < 0
+    )
+    if len(shared_dummies) != 1:
+        return _contact_unsupported_reason(
+            "non-unique-shared-dummy",
+            "contact structure constants must share exactly one adjoint dummy",
+            shared_dummy_count=str(len(shared_dummies)),
+            **common,
+        )
+    result_index = result_leg + 1
+    if not any(result_index in factor for factor in factors):
+        return _contact_unsupported_reason(
+            "result-leg-absent-from-color-factors",
+            "contact result leg is absent from both structure constants",
+            **common,
+        )
+    return _contact_unsupported_reason(
+        "unsupported-structure-constant-topology",
+        "contact structure constants do not form a trivalent auxiliary split",
+        **common,
+    )
+
+
+def _canonical_scalar_prefactor(expression: _sym.Expression) -> str:
+    return str(expression.to_canonical_string())
+
+
+def _contact_term_has_literal_color_singlet(term: CompiledVertexTerm) -> bool:
+    return term.color_source in {"1", "UFO::{}::1"} or term.color_expression == "1"
+
+
+def _validated_contact_decomposition_proof(
+    term: CompiledVertexTerm,
+) -> CompiledContactDecompositionProof | None:
+    proof = term.contact_decomposition_proof
+    if proof is None:
+        return None
+    if not proof.matches(term):
+        raise ValueError(
+            f"contact decomposition proof identity mismatch for term {term.id}"
+        )
+    if (
+        proof.algorithm != CONTACT_DECOMPOSITION_ALGORITHM
+        or proof.algorithm_version != CONTACT_DECOMPOSITION_ALGORITHM_VERSION
+    ):
+        raise ValueError(
+            f"unsupported contact decomposition proof algorithm for term {term.id}: "
+            f"{proof.algorithm}/v{proof.algorithm_version}"
+        )
+    return proof if proof.status == "proven" else None
+
+
+def _four_point_contact_color_split(
+    term: CompiledVertexTerm,
+    result_leg: int,
+    *,
+    model_symbols: ModelSymbolRegistry | None = None,
+) -> (
+    tuple[
+        tuple[int, int],
+        int,
+        str,
+        str,
+        int,
+        int,
+        tuple[int, ...],
+        tuple[int, ...],
+        int,
+        str,
+    ]
+    | None
+):
+    active_symbols = model_symbols or symbols.model("contact_color_parser")
+    factors = _normalized_structure_constant_factors(term.color_expression)
+    color_coefficient = _source_structure_constant_product_coefficient(
+        term.color_source,
+        model_symbols=active_symbols,
+    )
+    if len(factors) == 2 and color_coefficient is not None:
+        factors = (
+            _source_structure_constant_factor_orientations(
+                _function_arguments(term.color_source, "f"), factors
+            )
+            or ()
+        )
+    if len(factors) == 2 and color_coefficient is not None:
+        shared_dummies = set(value for value in factors[0] if value < 0) & set(
+            value for value in factors[1] if value < 0
+        )
+        if len(shared_dummies) == 1:
+            dummy = next(iter(shared_dummies))
+            result_index = result_leg + 1
+            final_factor = next(
+                (factor for factor in factors if result_index in factor),
+                None,
+            )
+            if final_factor is not None:
+                outer_factor = factors[1] if final_factor is factors[0] else factors[0]
+                pair = tuple(value - 1 for value in outer_factor if value > 0)
+                remaining = tuple(
+                    value - 1
+                    for value in final_factor
+                    if value > 0 and value != result_index
+                )
+                if len(pair) == 2 and len(remaining) == 1:
+                    canonical_f = "UFO::{}::f(1,2,3)"
+                    return (
+                        (pair[0], pair[1]),
+                        remaining[0],
+                        canonical_f,
+                        canonical_f,
+                        1,
+                        1,
+                        outer_factor,
+                        final_factor,
+                        dummy,
+                        color_coefficient,
+                    )
+
+    if term.color_source in {"1", "UFO::{}::1"} or term.color_expression == "1":
+        input_legs = tuple(leg for leg in range(4) if leg != result_leg)
+        return (
+            (input_legs[0], input_legs[1]),
+            input_legs[2],
+            term.color_source,
+            "1",
+            term.lc_color_normalization_power,
+            0,
+            (),
+            (),
+            -1,
+            "1",
+        )
+    return None
+
+
+def _source_structure_constant_product_coefficient(
+    expression: str,
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> str | None:
+    """Return the explicit scalar multiplying two source UFO f tensors.
+
+    The normalized Spenso expression may acquire a sign while canonicalizing
+    antisymmetric structure-constant arguments. The decomposition records
+    those permutations separately, so using the normalized scalar here would
+    apply that sign twice.
+    """
+
+    _sym._ensure_symbolica()
+    parsed = model_symbols.expression(expression)
+    wildcards = tuple(
+        _sym.E(f"ufo_contact_color_argument_{index}_") for index in range(3)
+    )
+    coefficient = parsed.replace(
+        model_symbols.symbol("f")(*wildcards),
+        _sym.E("1"),
+        bottom_up=True,
+        repeat=True,
+    )
+    if coefficient.get_all_symbols():
+        return None
+    return str(coefficient.to_canonical_string())
+
+
+def _source_structure_constant_factor_orientations(
+    source_factors: Sequence[Sequence[str]],
+    normalized_factors: Sequence[tuple[int, ...]],
+) -> tuple[tuple[int, int, int], ...] | None:
+    """Recover source permutations after normalized tensor authentication.
+
+    The source scalar coefficient must accompany source f-tensor orientations,
+    independently of antisymmetric permutations chosen by the CAS printer.
+    """
+
+    try:
+        source = tuple(
+            tuple(int(argument.strip()) for argument in factor)
+            for factor in source_factors
+        )
+    except ValueError:
+        return None
+    if any(len(factor) != 3 for factor in source):
+        return None
+    source_dummies = {value for factor in source for value in factor if value < 0}
+    normalized_dummies = {
+        value for factor in normalized_factors for value in factor if value < 0
+    }
+    if len(source_dummies) != len(normalized_dummies):
+        return None
+    dummy_map = dict(
+        zip(sorted(source_dummies), sorted(normalized_dummies), strict=True)
+    )
+    oriented = tuple(
+        tuple(dummy_map.get(value, value) for value in factor) for factor in source
+    )
+    if sorted(sorted(factor) for factor in oriented) != sorted(
+        sorted(factor) for factor in normalized_factors
+    ):
+        return None
+    return oriented  # type: ignore[return-value]
+
+
+def _normalized_structure_constant_factors(
+    expression: str,
+    *,
+    expected_count: int = 2,
+) -> tuple[tuple[int, ...], ...]:
+    """Return typed f-tensor index words from a normalized color monomial."""
+
+    if expression.count("::f(") != expected_count:
+        return ()
+    result: list[tuple[int, ...]] = []
+    for arguments in _function_arguments(expression, "::f"):
+        indices: list[int] = []
+        for argument in arguments:
+            dummy = re.search(r"ufo_c_dummy_([0-9]+)_adjoint", argument)
+            if dummy is not None:
+                indices.append(-int(dummy.group(1)))
+                continue
+            external = re.search(r"ufo_c_([0-9]+)", argument)
+            if external is None:
+                return ()
+            indices.append(int(external.group(1)))
+        if len(indices) != 3:
+            return ()
+        result.append(tuple(indices))
+    return tuple(result)
diff --git a/pyamplicol/src/pyamplicol/models/compiler_contractions.py b/pyamplicol/src/pyamplicol/models/compiler_contractions.py
new file mode 100644
index 0000000000..d8c7581339
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_contractions.py
@@ -0,0 +1,247 @@
+# SPDX-License-Identifier: 0BSD
+"""Compile model-owned current-contraction records for external models."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from ._physics_ir import ContractionIR
+from .contracts import (
+    CompiledClosureContractionRecord,
+    CompiledDirectContractionRecord,
+    CompiledParameterRecord,
+    CompiledParticleRecord,
+    CompiledPropagatorRecord,
+    compiled_current_dimension,
+    compiled_particle_component_dimension,
+    compiled_particle_is_chiral_eligible,
+)
+
+
+def compile_contraction_records(
+    particles: Sequence[CompiledParticleRecord],
+    parameters: Sequence[CompiledParameterRecord],
+    propagators: Sequence[CompiledPropagatorRecord],
+) -> tuple[
+    tuple[CompiledDirectContractionRecord, ...],
+    tuple[CompiledClosureContractionRecord, ...],
+]:
+    """Derive concrete contraction states from explicit compiled metadata.
+
+    This is deliberately a finite compiler step. Runtime generation consumes
+    the resulting records and does not infer a contraction from component
+    dimensions.
+    """
+
+    particles_by_name = {particle.name: particle for particle in particles}
+    parameters_by_name = {parameter.name: parameter for parameter in parameters}
+    propagators_by_name = {propagator.name: propagator for propagator in propagators}
+    direct: list[CompiledDirectContractionRecord] = []
+    closure: list[CompiledClosureContractionRecord] = []
+
+    for left in particles:
+        try:
+            right = particles_by_name[left.antiname]
+        except KeyError as exc:
+            raise ValueError(
+                f"particle {left.name!r} refers to absent antiparticle "
+                f"{left.antiname!r}"
+            ) from exc
+
+        left_is_weyl = compiled_particle_is_chiral_eligible(
+            left,
+            parameters=parameters_by_name,
+            propagators=propagators_by_name,
+        )
+        right_is_weyl = compiled_particle_is_chiral_eligible(
+            right,
+            parameters=parameters_by_name,
+            propagators=propagators_by_name,
+        )
+        if left_is_weyl != right_is_weyl:
+            states: tuple[tuple[int, int], ...] = ()
+        elif left_is_weyl:
+            states = ((-1, 1), (0, 0), (1, -1))
+        else:
+            states = ((0, 0),)
+        for left_chirality, right_chirality in states:
+            contraction = _compile_direct_contraction(
+                left,
+                right,
+                left_chirality=left_chirality,
+                right_chirality=right_chirality,
+                parameters=parameters_by_name,
+                propagators=propagators_by_name,
+            )
+            if contraction is not None:
+                direct.append(
+                    CompiledDirectContractionRecord(
+                        left_particle=left.name,
+                        left_chirality=left_chirality,
+                        right_particle=right.name,
+                        right_chirality=right_chirality,
+                        contraction_ir=contraction,
+                    )
+                )
+
+        scalar_projection = _compile_scalar_closure(left)
+        if scalar_projection is not None:
+            closure.append(
+                CompiledClosureContractionRecord(
+                    particle=left.name,
+                    chirality=0,
+                    contraction_ir=scalar_projection,
+                )
+            )
+
+    return tuple(direct), tuple(closure)
+
+
+def _compile_direct_contraction(
+    left: CompiledParticleRecord,
+    right: CompiledParticleRecord,
+    *,
+    left_chirality: int,
+    right_chirality: int,
+    parameters: dict[str, CompiledParameterRecord],
+    propagators: dict[str, CompiledPropagatorRecord],
+) -> ContractionIR | None:
+    try:
+        left_dimension = compiled_current_dimension(
+            left,
+            left_chirality,
+            parameters=parameters,
+            propagators=propagators,
+        )
+        right_dimension = compiled_current_dimension(
+            right,
+            right_chirality,
+            parameters=parameters,
+            propagators=propagators,
+        )
+    except ValueError:
+        return None
+    if left_dimension != right_dimension:
+        return None
+
+    if left_chirality != 0 or right_chirality != 0:
+        if (
+            left.statistics != "fermion"
+            or right.statistics != "fermion"
+            or left.wavefunction_family != "fermion"
+            or right.wavefunction_family != "fermion"
+            or left_dimension != 2
+            or left_chirality != -right_chirality
+        ):
+            return None
+        return ContractionIR(
+            name="weyl",
+            left_basis="weyl-chiral",
+            right_basis="weyl-chiral",
+            coefficients=((1.0, 0.0),) * 2,
+            chirality_relation="opposite",
+            metric_signature=None,
+        )
+
+    if (
+        left.statistics == right.statistics == "boson"
+        and left.wavefunction_family == right.wavefunction_family == "scalar"
+        and left_dimension == 1
+    ):
+        return ContractionIR(
+            name="scalar",
+            left_basis="scalar",
+            right_basis="scalar",
+            coefficients=((1.0, 0.0),),
+        )
+    if (
+        left.statistics == right.statistics == "fermion"
+        and left.wavefunction_family == right.wavefunction_family == "fermion"
+        and left_dimension == 4
+    ):
+        return ContractionIR(
+            name="dirac",
+            left_basis="dirac",
+            right_basis="dirac",
+            coefficients=((1.0, 0.0),) * 4,
+        )
+    if (
+        left.statistics == right.statistics == "boson"
+        and left.wavefunction_family == right.wavefunction_family == "vector"
+        and left_dimension == 4
+    ):
+        return ContractionIR(
+            name="lorentz",
+            left_basis="lorentz-vector",
+            right_basis="lorentz-vector",
+            coefficients=(
+                (1.0, 0.0),
+                (-1.0, 0.0),
+                (-1.0, 0.0),
+                (-1.0, 0.0),
+            ),
+            metric_signature="mostly-minus",
+        )
+    if (
+        left.auxiliary_kind
+        == right.auxiliary_kind
+        == "u1-subtraction-color-flow-vector"
+        and left_dimension == 4
+    ):
+        basis = "auxiliary:u1-subtraction-color-flow-vector"
+        return ContractionIR(
+            name="lorentz",
+            left_basis=basis,
+            right_basis=basis,
+            coefficients=(
+                (1.0, 0.0),
+                (-1.0, 0.0),
+                (-1.0, 0.0),
+                (-1.0, 0.0),
+            ),
+            metric_signature="mostly-minus",
+        )
+    if (
+        left.statistics == right.statistics == "boson"
+        and left.wavefunction_family == right.wavefunction_family == "spin2"
+        and left_dimension == 16
+    ):
+        metric = (1.0, -1.0, -1.0, -1.0)
+        return ContractionIR(
+            name="lorentz-rank-2",
+            left_basis="lorentz-rank-2",
+            right_basis="lorentz-rank-2",
+            coefficients=tuple(
+                (metric[mu] * metric[nu], 0.0)
+                for mu in range(4)
+                for nu in range(4)
+            ),
+            metric_signature="mostly-minus-tensor-product",
+        )
+    return None
+
+
+def _compile_scalar_closure(
+    particle: CompiledParticleRecord,
+) -> ContractionIR | None:
+    try:
+        dimension = compiled_particle_component_dimension(particle)
+    except ValueError:
+        return None
+    if (
+        particle.statistics != "boson"
+        or particle.wavefunction_family != "scalar"
+        or dimension != 1
+    ):
+        return None
+    return ContractionIR(
+        name="scalar",
+        left_basis="scalar",
+        right_basis="scalar",
+        coefficients=((1.0, 0.0),),
+        chirality_relation="any",
+        metric_signature=None,
+    )
+
+
+__all__ = ["compile_contraction_records"]
diff --git a/pyamplicol/src/pyamplicol/models/compiler_entry.py b/pyamplicol/src/pyamplicol/models/compiler_entry.py
new file mode 100644
index 0000000000..ac936ffe71
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_entry.py
@@ -0,0 +1,1025 @@
+# SPDX-License-Identifier: 0BSD
+"""Entry point for compiling external UFO model IR."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import replace
+
+from .._internal.physics.symbols import ModelSymbolRegistry, symbols
+from . import compiler_symbolica as _sym
+from .compiler_auxiliary_components import reduce_contact_auxiliary_components
+from .compiler_color_flow import (
+    compile_lc_color_transition_terms,
+    synthesize_fundamental_fierz_auxiliaries,
+)
+from .compiler_contact_trees import (
+    _compile_color_singlet_contact_trees,
+    _compile_heft_colored_contact_trees,
+    _deduplicate_contact_partials,
+    _record_heft_contact_orbit_certificates,
+)
+from .compiler_contacts import (
+    _build_contact_decomposition_proof,
+    _contact_final_component_expressions,
+    _contact_partial_component_expressions,
+    _contact_term_has_literal_color_singlet,
+    _fuse_contact_finals,
+    _record_contact_decomposition_proofs,
+    _validated_contact_decomposition_proof,
+)
+from .compiler_contractions import compile_contraction_records
+from .compiler_gauge import compile_goldstone_partner_records
+from .compiler_kernels import (
+    _canonicalize_oriented_kernel_component,
+    _fuse_oriented_kernels,
+    _is_compile_time_zero_parameter,
+    _is_single_structure_constant,
+    _lc_color_normalization_power,
+    _oriented_component_expressions,
+    _remap_kernel_symbols,
+    _replace_expression_symbols,
+    _spin_axis_labels,
+)
+from .compiler_records import (
+    _coupling,
+    _mappings,
+    _order,
+    _parameter,
+    _particle,
+    _propagator,
+    _resolve_coupling_records,
+    _resolve_parameter_records,
+    _sequence,
+)
+from .compiler_tensor_ordering import compile_tensor_ordering_metadata
+from .contact_decomposition import (
+    CompiledContactDecompositionSplit,
+    CompiledContactOrbitStep,
+    CompiledContactOrientationProof,
+    compiled_contact_orbit_step,
+)
+from .contracts import (
+    CompiledModelIR,
+    CompiledOrientedKernel,
+    CompiledParameterRecord,
+    CompiledParticleRecord,
+    CompiledPropagatorRecord,
+    CompiledVertexTerm,
+    compiled_particle_component_dimension,
+)
+from .tensors import (
+    classify_trilinear_color_expression,
+    normalize_color_expression,
+    normalize_lorentz_expression,
+    project_trilinear_color_expression,
+)
+
+_SUPPORTED_TRILINEAR_COLOR_PROJECTIONS = frozenset(
+    {
+        "singlet",
+        "color-identity",
+        "fundamental-generator",
+        "adjoint-structure-constant",
+    }
+)
+
+
+def compile_ufo_model_ir(model: Mapping[str, object]) -> CompiledModelIR:
+    _sym._ensure_symbolica()
+    model_name = str(model.get("name", "unnamed-model"))
+    model_symbols = symbols.model(model_name)
+    particles = tuple(_particle(item) for item in _mappings(model.get("particles")))
+    particle_by_name = {particle.name: particle for particle in particles}
+    lorentz_by_name = {
+        str(item["name"]): item for item in _mappings(model.get("lorentz_structures"))
+    }
+    parameter_records = tuple(
+        _parameter(item, model_symbols=model_symbols)
+        for item in _mappings(model.get("parameters"))
+    )
+    parameter_records = _resolve_parameter_records(parameter_records, model_symbols)
+    coupling_records = tuple(
+        _coupling(item, model_symbols=model_symbols)
+        for item in _mappings(model.get("couplings"))
+    )
+    coupling_records = _resolve_coupling_records(
+        coupling_records,
+        parameter_records,
+        model_symbols,
+    )
+    coupling_by_name = {coupling.name: coupling for coupling in coupling_records}
+    terms: list[CompiledVertexTerm] = []
+    for vertex in _mappings(model.get("vertex_rules")):
+        particle_names = tuple(str(value) for value in _sequence(vertex["particles"]))
+        try:
+            vertex_particles = tuple(particle_by_name[name] for name in particle_names)
+        except KeyError as exc:
+            raise ValueError(
+                f"vertex {vertex.get('name')} refers to unknown particle {exc.args[0]}"
+            ) from exc
+        colors = tuple(particle.color for particle in vertex_particles)
+        color_sources = tuple(
+            str(value) for value in _sequence(vertex["color_structures"])
+        )
+        lorentz_names = tuple(
+            str(value) for value in _sequence(vertex["lorentz_structures"])
+        )
+        coupling_matrix = _sequence(vertex["couplings"])
+        if len(coupling_matrix) != len(color_sources):
+            raise ValueError(
+                f"vertex {vertex.get('name')} coupling rows do not match "
+                "color structures"
+            )
+        normalized_colors = tuple(
+            normalize_color_expression(source, colors) for source in color_sources
+        )
+        normalized_lorentz = []
+        for name in lorentz_names:
+            try:
+                lorentz = lorentz_by_name[name]
+            except KeyError as exc:
+                raise ValueError(
+                    f"vertex {vertex.get('name')} refers to unknown Lorentz "
+                    f"structure {name}"
+                ) from exc
+            normalized_lorentz.append(
+                normalize_lorentz_expression(
+                    str(lorentz["structure"]),
+                    tuple(int(value) for value in _sequence(lorentz["spins"])),
+                    model_symbols=model_symbols,
+                )
+            )
+        for color_index, row_value in enumerate(coupling_matrix):
+            row = _sequence(row_value)
+            if len(row) != len(lorentz_names):
+                raise ValueError(
+                    f"vertex {vertex.get('name')} coupling columns do not match "
+                    "Lorentz structures"
+                )
+            for lorentz_index, coupling_value in enumerate(row):
+                if coupling_value is None:
+                    continue
+                coupling_name = str(coupling_value)
+                try:
+                    coupling = coupling_by_name[coupling_name]
+                except KeyError as exc:
+                    raise ValueError(
+                        f"vertex {vertex.get('name')} refers to unknown coupling "
+                        f"{coupling_name}"
+                    ) from exc
+                source_lorentz = lorentz_by_name[lorentz_names[lorentz_index]]
+                terms.append(
+                    CompiledVertexTerm(
+                        id=len(terms),
+                        vertex=str(vertex["name"]),
+                        particles=particle_names,
+                        color_index=color_index,
+                        lorentz_index=lorentz_index,
+                        color_source=color_sources[color_index],
+                        color_expression=normalized_colors[color_index].expression,
+                        lorentz_name=lorentz_names[lorentz_index],
+                        lorentz_source=str(source_lorentz["structure"]),
+                        lorentz_expression=normalized_lorentz[lorentz_index].expression,
+                        coupling=coupling.name,
+                        coupling_expression=coupling.resolved_expression,
+                        coupling_orders=coupling.orders,
+                        lc_color_normalization_power=(
+                            _lc_color_normalization_power(color_sources[color_index])
+                        ),
+                    )
+                )
+    propagators = tuple(
+        _propagator(item, particles) for item in _mappings(model.get("propagators"))
+    )
+    terms = list(
+        _record_contact_decomposition_proofs(
+            terms,
+            particles,
+            model_symbols=model_symbols,
+        )
+    )
+    terms = list(
+        _record_heft_contact_orbit_certificates(
+            terms,
+            particles,
+            model_symbols=model_symbols,
+        )
+    )
+    oriented_kernels = _compile_oriented_kernels(
+        terms,
+        particles,
+        parameter_records,
+        propagators,
+        model_symbols,
+    )
+    contact_particles, contact_kernels = _compile_four_point_contact_kernels(
+        terms,
+        particles,
+        start_kind=len(oriented_kernels),
+        model_symbols=model_symbols,
+    )
+    contact_particles, contact_kernels = _deduplicate_contact_partials(
+        contact_particles,
+        contact_kernels,
+        terms,
+        model_symbols=model_symbols,
+    )
+    contact_kernels = _fuse_contact_finals(
+        contact_kernels,
+        terms,
+        model_symbols=model_symbols,
+    )
+    particles = (*particles, *contact_particles)
+    oriented_kernels = (*oriented_kernels, *contact_kernels)
+    tree_start_kind = max((kernel.kind for kernel in oriented_kernels), default=-1) + 1
+    tree_particles, tree_kernels = _compile_color_singlet_contact_trees(
+        terms,
+        particles,
+        start_kind=tree_start_kind,
+        model_symbols=model_symbols,
+    )
+    particles = (*particles, *tree_particles)
+    oriented_kernels = (*oriented_kernels, *tree_kernels)
+    heft_start_kind = max((kernel.kind for kernel in oriented_kernels), default=-1) + 1
+    heft_particles, heft_kernels = _compile_heft_colored_contact_trees(
+        terms,
+        particles,
+        start_kind=heft_start_kind,
+        model_symbols=model_symbols,
+    )
+    particles = (*particles, *heft_particles)
+    oriented_kernels = (*oriented_kernels, *heft_kernels)
+    particles, oriented_kernels = reduce_contact_auxiliary_components(
+        particles,
+        oriented_kernels,
+        auxiliary_particles=(*tree_particles, *heft_particles),
+        model_symbols=model_symbols,
+    )
+    (
+        annotated_terms,
+        oriented_kernels,
+        tensor_orderings,
+        current_orderings,
+    ) = compile_tensor_ordering_metadata(
+        terms,
+        particles,
+        oriented_kernels,
+        parameter_records,
+        propagators,
+    )
+    terms = list(annotated_terms)
+    oriented_kernels = _annotate_oriented_kernel_color_projections(
+        oriented_kernels,
+        particles,
+        terms,
+    )
+    particles, oriented_kernels = synthesize_fundamental_fierz_auxiliaries(
+        particles,
+        oriented_kernels,
+        propagators,
+        model_symbols=model_symbols,
+    )
+    (
+        annotated_terms,
+        oriented_kernels,
+        tensor_orderings,
+        current_orderings,
+    ) = compile_tensor_ordering_metadata(
+        terms,
+        particles,
+        oriented_kernels,
+        parameter_records,
+        propagators,
+    )
+    terms = list(annotated_terms)
+    oriented_kernels = _annotate_oriented_kernel_evaluation_equivalence(
+        oriented_kernels,
+        particles,
+        terms,
+        model_symbols,
+    )
+    direct_contractions, closure_contractions = compile_contraction_records(
+        particles,
+        parameter_records,
+        propagators,
+    )
+    goldstone_partners = compile_goldstone_partner_records(
+        particles,
+        parameter_records,
+        propagators,
+    )
+    return CompiledModelIR(
+        name=model_name,
+        orders=tuple(_order(item) for item in _mappings(model.get("orders"))),
+        parameters=parameter_records,
+        particles=particles,
+        couplings=coupling_records,
+        propagators=propagators,
+        vertex_terms=tuple(terms),
+        oriented_kernels=oriented_kernels,
+        direct_contractions=direct_contractions,
+        closure_contractions=closure_contractions,
+        tensor_orderings=tensor_orderings,
+        current_orderings=current_orderings,
+        goldstone_partners=goldstone_partners,
+    )
+
+
+def _annotate_oriented_kernel_color_projections(
+    kernels: Sequence[CompiledOrientedKernel],
+    particles: Sequence[CompiledParticleRecord],
+    terms: Sequence[CompiledVertexTerm],
+) -> tuple[CompiledOrientedKernel, ...]:
+    particle_by_name = {particle.name: particle for particle in particles}
+    term_by_id = {term.id: term for term in terms}
+    annotated: list[CompiledOrientedKernel] = []
+    for kernel in kernels:
+        term = term_by_id.get(kernel.term_id)
+        oriented_representations = tuple(
+            particle_by_name[name].color for name in kernel.particles
+        )
+        if term is not None and term.valence == 3 and kernel.vertex == term.vertex:
+            representations = tuple(
+                particle_by_name[name].color for name in term.particles
+            )
+            certified_structure, coefficient = project_trilinear_color_expression(
+                term.color_expression,
+                representations,
+            )
+            if certified_structure not in _SUPPORTED_TRILINEAR_COLOR_PROJECTIONS:
+                raise ValueError(
+                    f"vertex {term.vertex!r} has unsupported trilinear color "
+                    f"tensor {term.color_source!r}; pyAmpliCol could not prove it "
+                    "as a singlet, identity, fundamental generator, or adjoint "
+                    "structure constant"
+                )
+            structure, _ = classify_trilinear_color_expression(
+                kernel.color_expression,
+                kernel.color_source,
+                oriented_representations,
+                allow_source_fallback=True,
+            )
+            if structure not in {certified_structure, "generic-tensor"}:
+                raise ValueError(
+                    f"vertex {term.vertex!r} changed color-tensor family while "
+                    "being oriented"
+                )
+            if structure == "generic-tensor":
+                # Numeric prefactors and the dual representation carried by an
+                # oriented result state can hide the family from the cheap
+                # oriented recognizer.  The original trilinear term and the
+                # compiler-owned source-leg permutation already certify it.
+                structure = certified_structure
+            recurrence_structure = certified_structure
+            recurrence_proof_source = "exact-trilinear-symbolica-projection-v1"
+            recurrence_provenance = (("vertex-term-id", str(term.id)),)
+            tensor_role_representations = tuple(
+                representations[source_leg]
+                for source_leg in kernel.source_particle_legs
+            )
+        else:
+            # Contact fragments are emitted only after compiler_contacts has
+            # serialized a complete decomposition proof. Their compact source
+            # is compiler-owned, so textual recognition is safe at this point.
+            structure, coefficient = classify_trilinear_color_expression(
+                kernel.color_expression,
+                kernel.color_source,
+                oriented_representations,
+                allow_source_fallback=True,
+            )
+            if structure == "generic-tensor":
+                raise ValueError(
+                    f"compiler-generated kernel {kernel.vertex!r} has no proven "
+                    "color-flow projection"
+                )
+            contact_contract = _contact_recurrence_color_contract(
+                kernel,
+                term_by_id,
+            )
+            if contact_contract is None:
+                recurrence_structure = structure
+                recurrence_proof_source = "compiler-generated-color-projection-v1"
+                recurrence_provenance = ()
+            else:
+                (
+                    recurrence_structure,
+                    recurrence_proof_source,
+                    recurrence_provenance,
+                ) = contact_contract
+            tensor_role_representations = (
+                oriented_representations[0],
+                oriented_representations[1],
+                _dual_color_representation(oriented_representations[2]),
+            )
+        annotated_kernel = replace(
+            kernel,
+            color_projection_structure=structure,
+            color_projection_coefficient=(
+                float(coefficient.real),
+                float(coefficient.imag),
+            ),
+            lc_recurrence_color_rule_kind=recurrence_structure,
+        )
+        recurrence_kernel = replace(
+            annotated_kernel,
+            color_projection_structure=recurrence_structure,
+        )
+        annotated_kernel = replace(
+            annotated_kernel,
+            lc_color_transition_terms=compile_lc_color_transition_terms(
+                recurrence_kernel,
+                oriented_representations,
+                proof_source=recurrence_proof_source,
+                provenance=recurrence_provenance,
+                tensor_role_representations=tensor_role_representations,
+            ),
+        )
+        annotated.append(annotated_kernel)
+    return tuple(annotated)
+
+
+def _dual_color_representation(representation: int) -> int:
+    return -representation if abs(representation) == 3 else representation
+
+
+def _contact_recurrence_color_contract(
+    kernel: CompiledOrientedKernel,
+    term_by_id: dict[int, CompiledVertexTerm],
+) -> tuple[str, str, tuple[tuple[str, str], ...]] | None:
+    is_partial = kernel.vertex.endswith("::contact-partial")
+    is_final = kernel.vertex.endswith(("::contact-final", "::contact-final-fused"))
+    if not is_partial and not is_final:
+        # Balanced contact-tree lowering has its own compiler-owned singlet
+        # auxiliaries and is not described by the four-point split proof.
+        # Its trilinear color projection is authenticated by the generic
+        # compiler-generated contract below.
+        return None
+
+    stage = "partial" if is_partial else "final"
+    owner_matches = []
+    orientation_matches = []
+    fused_term_ids = set(kernel.term_ids or (kernel.term_id,))
+    # Contact-partial deduplication and final fusion may retain an auxiliary
+    # owned by a term that is no longer the fused kernel's primary term ID.
+    # Match the authenticated auxiliary name and source-leg orientation against
+    # the complete proof catalog instead of trusting that incidental owner.
+    for term in term_by_id.values():
+        if term.contact_decomposition_proof is None:
+            continue
+        proof = term.contact_decomposition_proof
+        if proof.status != "proven":
+            continue
+        for split in proof.splits:
+            auxiliary_name = f"__pyamplicol_contact_{term.id}_r{split.result_leg}"
+            owns_auxiliary = (
+                kernel.particles[2] == auxiliary_name
+                if stage == "partial"
+                else auxiliary_name in kernel.particles[:2]
+            )
+            if owns_auxiliary:
+                owner_matches.append((term, proof, split))
+            orientation_is_relevant = (
+                owns_auxiliary if stage == "partial" else term.id in fused_term_ids
+            )
+            if not orientation_is_relevant:
+                continue
+            for orientation in split.orientations:
+                if orientation.stage != stage:
+                    continue
+                expected_source_legs = (
+                    orientation.input_legs[0],
+                    orientation.input_legs[1],
+                    -1 if stage == "partial" else split.result_leg,
+                )
+                if kernel.source_particle_legs == expected_source_legs:
+                    orientation_matches.append((term, proof, split, orientation))
+    if len(owner_matches) != 1 or not orientation_matches:
+        raise ValueError(
+            f"compiler-generated contact kernel {kernel.vertex!r} has "
+            f"{len(owner_matches)} recurrence auxiliary owners and "
+            f"{len(orientation_matches)} exact stage orientations"
+        )
+    term, proof, split = owner_matches[0]
+    if any(
+        candidate_split.decomposition_kind != split.decomposition_kind
+        for _term, _proof, candidate_split, _orientation in orientation_matches
+    ):
+        raise ValueError(
+            f"compiler-generated contact kernel {kernel.vertex!r} fuses "
+            "incompatible recurrence color decompositions"
+        )
+    recurrence_structure = {
+        "literal-color-singlet": "singlet",
+        "two-structure-constants": "adjoint-structure-constant",
+    }[split.decomposition_kind]
+    return (
+        recurrence_structure,
+        f"{proof.algorithm}-recurrence-{stage}-v{proof.algorithm_version}",
+        (
+            ("contact-decomposition-kind", split.decomposition_kind),
+            ("contact-result-leg", str(split.result_leg)),
+            ("contact-stage", stage),
+            ("vertex-term-id", str(term.id)),
+        ),
+    )
+
+
+def _annotate_oriented_kernel_evaluation_equivalence(
+    kernels: Sequence[CompiledOrientedKernel],
+    particles: Sequence[CompiledParticleRecord],
+    terms: Sequence[CompiledVertexTerm],
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[CompiledOrientedKernel, ...]:
+    """Prove exact signed/permuted kernel relations from lowered expressions.
+
+    The comparison uses the concrete component expressions after resolving
+    generated coupling aliases.  It is therefore independent of how a UFO
+    author spelled or ordered the source Lorentz/color structures.  Only exact
+    Symbolica canonical equality up to an overall sign and input exchange is
+    recorded; kernels that do not pass that test remain in distinct classes.
+    """
+
+    particle_by_name = {particle.name: particle for particle in particles}
+    term_by_id = {term.id: term for term in terms}
+    annotated: list[CompiledOrientedKernel] = []
+    for kernel in kernels:
+        derived_couplings = {
+            symbols.derived_coupling(model_symbols.model_name, term_id): _sym.E(
+                term_by_id[term_id].coupling_expression
+            )
+            for name in kernel.runtime_parameters
+            if name.startswith("derived_coupling_")
+            for term_id in (int(name.rsplit("_", 1)[1]),)
+            if term_id in term_by_id
+        }
+        coupling = _replace_expression_symbols(
+            _sym.E(kernel.coupling_expression),
+            derived_couplings,
+        )
+        # The algebraic colour-flow normalization is evaluated by the kernel,
+        # so it must also participate in proofs of shared kernel evaluations.
+        if kernel.lc_color_normalization_power:
+            coupling *= _sym.E(f"2^(-{kernel.lc_color_normalization_power}/2)")
+        dimensions = tuple(
+            compiled_particle_component_dimension(particle)
+            for particle in (
+                particle_by_name[kernel.particles[0]],
+                particle_by_name[kernel.particles[1]],
+                particle_by_name[kernel.particles[2]],
+            )
+        )
+        candidates: list[tuple[str, tuple[int, int], tuple[float, float], str]] = []
+        components_by_input_order: dict[
+            tuple[int, int], tuple[_sym.Expression, ...]
+        ] = {}
+        for input_order, swap_sides in (((0, 1), False), ((1, 0), True)):
+            oriented_components = tuple(
+                (
+                    _replace_expression_symbols(
+                        _remap_kernel_symbols(
+                            _sym.E(component),
+                            old_kind=kernel.kind,
+                            new_kind=0,
+                            model_symbols=model_symbols,
+                            swap_sides=swap_sides,
+                        ),
+                        derived_couplings,
+                    )
+                    * coupling
+                ).expand()
+                for component in kernel.component_expressions
+            )
+            components_by_input_order[input_order] = oriented_components
+            oriented_dimensions = (
+                dimensions[input_order[0]],
+                dimensions[input_order[1]],
+                dimensions[2],
+            )
+            for sign in (1, -1):
+                # Horner/factor collection optimizes evaluation, but is not a
+                # unique algebraic normal form: mirrored kernels can retain
+                # different factorizations of the same coupling polynomial.
+                # Proof identities must use expanded expressions, while the
+                # stored runtime components remain optimized and unchanged.
+                component_strings = tuple(
+                    (sign * component).expand().to_canonical_string()
+                    for component in oriented_components
+                )
+                signature = json.dumps(
+                    {
+                        "input_dimensions": list(oriented_dimensions[:2]),
+                        "output_dimension": oriented_dimensions[2],
+                        "components": list(component_strings),
+                    },
+                    sort_keys=True,
+                    separators=(",", ":"),
+                )
+                candidates.append(
+                    (
+                        signature,
+                        input_order,
+                        (float(sign), 0.0),
+                        hashlib.sha256(signature.encode("utf-8")).hexdigest(),
+                    )
+                )
+        _signature, input_order, factor, class_digest = min(
+            candidates,
+            key=lambda candidate: candidate[0],
+        )
+        input_exchange_factor: tuple[float, float] | None = None
+        if dimensions[0] == dimensions[1]:
+            direct_components = components_by_input_order[(0, 1)]
+            swapped_components = components_by_input_order[(1, 0)]
+            zero = _sym.E("0").to_canonical_string()
+            for exchange_sign in (1, -1):
+                if all(
+                    (swapped - exchange_sign * direct).expand().to_canonical_string()
+                    == zero
+                    for direct, swapped in zip(
+                        direct_components,
+                        swapped_components,
+                        strict=True,
+                    )
+                ):
+                    input_exchange_factor = (float(exchange_sign), 0.0)
+                    break
+        annotated.append(
+            replace(
+                kernel,
+                evaluation_class=f"symbolica-sha256:{class_digest}",
+                evaluation_factor=factor,
+                evaluation_input_order=input_order,
+                evaluation_input_exchange_factor=input_exchange_factor,
+                evaluation_equivalence_verified=True,
+            )
+        )
+    reference_factor_by_class: dict[str, complex] = {}
+    normalized: list[CompiledOrientedKernel] = []
+    for kernel in annotated:
+        class_factor_complex = complex(*kernel.evaluation_factor)
+        reference_factor = reference_factor_by_class.setdefault(
+            kernel.evaluation_class,
+            class_factor_complex,
+        )
+        relative_factor = class_factor_complex / reference_factor
+        normalized.append(
+            replace(
+                kernel,
+                evaluation_factor=(
+                    float(relative_factor.real),
+                    float(relative_factor.imag),
+                ),
+            )
+        )
+    return tuple(normalized)
+
+
+def _compile_oriented_kernels(
+    terms: Sequence[CompiledVertexTerm],
+    particles: Sequence[CompiledParticleRecord],
+    parameters: Sequence[CompiledParameterRecord],
+    propagators: Sequence[CompiledPropagatorRecord],
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[CompiledOrientedKernel, ...]:
+    particle_by_name = {particle.name: particle for particle in particles}
+    parameter_by_name = {parameter.name: parameter for parameter in parameters}
+    propagator_by_name = {propagator.name: propagator for propagator in propagators}
+    external_parameters = {
+        parameter.name for parameter in parameters if parameter.nature == "external"
+    }
+    kernels: list[CompiledOrientedKernel] = []
+    for term in terms:
+        if term.valence != 3:
+            continue
+        oriented_result_particles: set[str] = set()
+        for result_leg in range(3):
+            result_source_name = term.particles[result_leg]
+            if result_source_name in oriented_result_particles:
+                continue
+            oriented_result_particles.add(result_source_name)
+            input_legs = tuple(leg for leg in range(3) if leg != result_leg)
+            input_orders = (
+                (input_legs,)
+                if term.particles[input_legs[0]] == term.particles[input_legs[1]]
+                else (input_legs, tuple(reversed(input_legs)))
+            )
+            for left_leg, right_leg in input_orders:
+                result_source = particle_by_name[term.particles[result_leg]]
+                try:
+                    result_name = particle_by_name[result_source.antiname].name
+                except KeyError as exc:
+                    raise ValueError(
+                        f"vertex {term.vertex} particle {result_source.name} refers to "
+                        f"absent antiparticle {result_source.antiname}"
+                    ) from exc
+                ordered_components = _oriented_component_expressions(
+                    term,
+                    particle_by_name,
+                    left_leg=left_leg,
+                    right_leg=right_leg,
+                    result_leg=result_leg,
+                    kind=len(kernels),
+                    model_symbols=model_symbols,
+                    use_transverse_massless_yang_mills=(
+                        _term_supports_transverse_massless_yang_mills(
+                            term,
+                            particle_by_name,
+                            parameter_by_name,
+                            propagator_by_name,
+                        )
+                    ),
+                )
+                coupling_symbols = set(
+                    _sym.E(term.coupling_expression).get_all_symbols(False)
+                )
+                runtime_parameters = tuple(
+                    sorted(
+                        name
+                        for name in external_parameters
+                        if model_symbols.symbol(name) in coupling_symbols
+                    )
+                )
+                kernels.append(
+                    CompiledOrientedKernel(
+                        kind=len(kernels),
+                        term_id=term.id,
+                        vertex=term.vertex,
+                        particles=(
+                            term.particles[left_leg],
+                            term.particles[right_leg],
+                            result_name,
+                        ),
+                        source_particle_legs=(left_leg, right_leg, result_leg),
+                        component_expressions=tuple(
+                            str(component) for component in ordered_components.values
+                        ),
+                        coupling_expression=term.coupling_expression,
+                        coupling_orders=term.coupling_orders,
+                        runtime_parameters=runtime_parameters,
+                        color_source=term.color_source,
+                        color_expression=term.color_expression,
+                        lc_color_normalization_power=(
+                            term.lc_color_normalization_power
+                        ),
+                        term_ids=(term.id,),
+                        output_ordering_id=ordered_components.ordering_id,
+                    )
+                )
+    return _fuse_oriented_kernels(
+        kernels,
+        model_name=model_symbols.model_name,
+    )
+
+
+def _term_supports_transverse_massless_yang_mills(
+    term: CompiledVertexTerm,
+    particles: Mapping[str, CompiledParticleRecord],
+    parameters: Mapping[str, CompiledParameterRecord],
+    propagators: Mapping[str, CompiledPropagatorRecord],
+) -> bool:
+    """Prove the field/propagator contract needed by transverse YM lowering."""
+
+    if not _is_single_structure_constant(term.color_expression):
+        return False
+    for name in term.particles:
+        particle = particles[name]
+        propagator = (
+            None
+            if particle.propagator is None
+            else propagators.get(particle.propagator)
+        )
+        if not (
+            particle.spin == 3
+            and particle.color == 8
+            and particle.self_conjugate is True
+            and _is_compile_time_zero_parameter(particle.mass, parameters)
+            and particle.propagating
+            and particle.ghost_number == 0
+            and propagator is not None
+            and propagator.particle == particle.name
+            and not propagator.custom
+        ):
+            return False
+    return True
+
+
+def _compile_four_point_contact_kernels(
+    terms: Sequence[CompiledVertexTerm],
+    particles: Sequence[CompiledParticleRecord],
+    *,
+    start_kind: int,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[tuple[CompiledParticleRecord, ...], tuple[CompiledOrientedKernel, ...]]:
+    """Lower momentum-independent four-point tensors through dense auxiliaries."""
+
+    particle_by_name = {particle.name: particle for particle in particles}
+    used_pdgs = {abs(particle.pdg_code) for particle in particles}
+    next_pdg = max(9_000_000, max(used_pdgs, default=0) + 1)
+    auxiliary_particles: list[CompiledParticleRecord] = []
+    kernels: list[CompiledOrientedKernel] = []
+
+    def allocate_pdg() -> int:
+        nonlocal next_pdg
+        while next_pdg in used_pdgs:
+            next_pdg += 1
+        result = next_pdg
+        used_pdgs.add(result)
+        next_pdg += 1
+        return result
+
+    for term in terms:
+        if term.valence != 4:
+            continue
+        if "ufo_momentum_" in term.lorentz_expression:
+            continue
+        source_particles = tuple(particle_by_name[name] for name in term.particles)
+        proof = _validated_contact_decomposition_proof(term)
+        if (
+            proof is None
+            and term.contact_decomposition_proof is None
+            and _contact_term_has_literal_color_singlet(term)
+            and all(particle.color == 1 for particle in source_particles)
+        ):
+            # Preserve direct construction of uncolored test/compiler terms.
+            # UFO compilation always serializes this trivial proof beforehand.
+            proof = _build_contact_decomposition_proof(
+                term,
+                source_particles,
+                particle_by_name,
+                model_symbols=model_symbols,
+            )
+        if proof is None:
+            # Leave the complete term unlowered so model preflight reports a
+            # structured unsupported-contact-color-lowering error. Partial
+            # orientation output would incorrectly make the term appear valid.
+            continue
+        for split in proof.splits:
+            result_leg = split.result_leg
+            source_result = source_particles[result_leg]
+            remaining_leg = split.remaining_leg
+            open_legs = split.open_legs
+            component_axis_order = tuple(
+                label
+                for leg in open_legs
+                for label in _spin_axis_labels(source_particles[leg].spin, leg + 1)
+            )
+            if component_axis_order != split.component_axis_order:
+                raise ValueError(
+                    f"contact decomposition component order mismatch for term "
+                    f"{term.id} result leg {result_leg}"
+                )
+            auxiliary_name = f"__pyamplicol_contact_{term.id}_r{result_leg}"
+            representative_indices = split.component_basis_order
+            component_expansion = split.component_expansion
+            auxiliary_dimension = len(representative_indices)
+            auxiliary = CompiledParticleRecord(
+                name=auxiliary_name,
+                antiname=auxiliary_name,
+                pdg_code=allocate_pdg(),
+                spin=-1,
+                color=split.auxiliary_color,
+                mass="ZERO",
+                width="ZERO",
+                charge=0.0,
+                quantum_numbers=(("electric_charge", "0"),),
+                ghost_number=0,
+                propagating=False,
+                goldstoneboson=False,
+                propagator=None,
+                component_dimension=auxiliary_dimension,
+                auxiliary_kind=(
+                    f"ufo-contact:{term.id}:result-{result_leg}:"
+                    + ",".join(str(leg) for leg in open_legs)
+                ),
+            )
+            auxiliary_particles.append(auxiliary)
+
+            partial_orientations = tuple(
+                item for item in split.orientations if item.stage == "partial"
+            )
+            for orientation in partial_orientations:
+                left_leg, right_leg = orientation.input_legs
+                kind = start_kind + len(kernels)
+                components = _contact_partial_component_expressions(
+                    term,
+                    particle_by_name,
+                    left_leg=left_leg,
+                    right_leg=right_leg,
+                    open_legs=open_legs,
+                    kind=kind,
+                    model_symbols=model_symbols,
+                )
+                kernels.append(
+                    CompiledOrientedKernel(
+                        kind=kind,
+                        term_id=term.id,
+                        vertex=f"{term.vertex}::contact-partial",
+                        particles=(
+                            source_particles[left_leg].name,
+                            source_particles[right_leg].name,
+                            auxiliary.name,
+                        ),
+                        source_particle_legs=(left_leg, right_leg, -1),
+                        component_expressions=tuple(
+                            _canonicalize_oriented_kernel_component(
+                                _sym.E(components[index])
+                                * _sym.E(orientation.scalar_prefactor)
+                            ).to_canonical_string()
+                            for index in representative_indices
+                        ),
+                        coupling_expression="1",
+                        coupling_orders=(),
+                        runtime_parameters=(),
+                        color_source="1",
+                        color_expression="1",
+                        lc_color_normalization_power=0,
+                        term_ids=(),
+                        contact_orbit_steps=_compiled_contact_orbit_steps(
+                            term,
+                            split,
+                            orientation,
+                        ),
+                    )
+                )
+
+            result_name = particle_by_name[source_result.antiname].name
+            final_orientations = tuple(
+                item for item in split.orientations if item.stage == "final"
+            )
+            for orientation in final_orientations:
+                auxiliary_on_left = orientation.input_legs[0] == -1
+                left_name, right_name = (
+                    (auxiliary.name, source_particles[remaining_leg].name)
+                    if auxiliary_on_left
+                    else (source_particles[remaining_leg].name, auxiliary.name)
+                )
+                kind = start_kind + len(kernels)
+                derived_coupling = symbols.derived_coupling(
+                    model_symbols.model_name,
+                    term.id,
+                )
+                final_prefactor = (
+                    _sym.E(orientation.scalar_prefactor) * derived_coupling
+                )
+                combined_color_source = (
+                    f"{split.outer_color_source}*{split.final_color_source}"
+                    if split.decomposition_kind == "two-structure-constants"
+                    else term.color_source
+                )
+                kernels.append(
+                    CompiledOrientedKernel(
+                        kind=kind,
+                        term_id=term.id,
+                        vertex=f"{term.vertex}::contact-final",
+                        particles=(left_name, right_name, result_name),
+                        source_particle_legs=(
+                            -1 if auxiliary_on_left else remaining_leg,
+                            remaining_leg if auxiliary_on_left else -1,
+                            result_leg,
+                        ),
+                        component_expressions=tuple(
+                            (_sym.E(component) * final_prefactor).to_canonical_string()
+                            for component in _contact_final_component_expressions(
+                                source_particles,
+                                auxiliary,
+                                open_legs=open_legs,
+                                remaining_leg=remaining_leg,
+                                result_leg=result_leg,
+                                kind=kind,
+                                auxiliary_on_left=auxiliary_on_left,
+                                component_expansion=component_expansion,
+                                model_symbols=model_symbols,
+                            )
+                        ),
+                        coupling_expression="1",
+                        coupling_orders=term.coupling_orders,
+                        runtime_parameters=(f"derived_coupling_{term.id}",),
+                        color_source=combined_color_source,
+                        color_expression=combined_color_source,
+                        lc_color_normalization_power=(
+                            split.outer_color_normalization_power
+                            + split.final_color_normalization_power
+                        ),
+                        term_ids=(term.id,),
+                        contact_orbit_steps=_compiled_contact_orbit_steps(
+                            term,
+                            split,
+                            orientation,
+                        ),
+                    )
+                )
+    return tuple(auxiliary_particles), tuple(kernels)
+
+
+def _compiled_contact_orbit_steps(
+    term: CompiledVertexTerm,
+    split: CompiledContactDecompositionSplit,
+    orientation: CompiledContactOrientationProof,
+) -> tuple[CompiledContactOrbitStep, ...]:
+    certificate = term.contact_orbit_certificate
+    if certificate is None:
+        return ()
+    return (compiled_contact_orbit_step(certificate, split, orientation),)
diff --git a/pyamplicol/src/pyamplicol/models/compiler_gauge.py b/pyamplicol/src/pyamplicol/models/compiler_gauge.py
new file mode 100644
index 0000000000..4d9fb911d1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_gauge.py
@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: 0BSD
+"""Compile explicit gauge/Goldstone partner contracts from normalized UFO IR."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+
+from .contracts import (
+    CompiledGoldstonePartnerRecord,
+    CompiledParameterRecord,
+    CompiledParticleRecord,
+    CompiledPropagatorRecord,
+    _goldstone_vector_quantum_contract_matches,
+    _resolved_mass_expression,
+)
+
+
+def compile_goldstone_partner_records(
+    particles: Sequence[CompiledParticleRecord],
+    parameters: Sequence[CompiledParameterRecord],
+    propagators: Sequence[CompiledPropagatorRecord],
+) -> tuple[CompiledGoldstonePartnerRecord, ...]:
+    """Resolve every declared Goldstone once, before executable model loading."""
+
+    parameter_by_name: Mapping[str, CompiledParameterRecord] = {
+        parameter.name: parameter for parameter in parameters
+    }
+    propagator_by_particle = {
+        propagator.particle: propagator for propagator in propagators
+    }
+    vectors = tuple(
+        particle
+        for particle in particles
+        if particle.spin == 3
+        and particle.wavefunction_family == "vector"
+        and particle.propagating
+        and not particle.goldstoneboson
+    )
+    records: list[CompiledGoldstonePartnerRecord] = []
+    for goldstone in particles:
+        if not goldstone.goldstoneboson:
+            continue
+        if goldstone.spin != 1 or not goldstone.propagating:
+            raise ValueError(
+                f"Goldstone {goldstone.name!r} must be a propagating scalar"
+            )
+        candidates = tuple(
+            vector
+            for vector in vectors
+            if _goldstone_vector_quantum_contract_matches(
+                goldstone,
+                vector,
+                parameter_by_name,
+            )
+            and _resolved_mass_expression(vector, parameter_by_name) != "0"
+        )
+        if len(candidates) > 1:
+            raise ValueError(
+                f"Goldstone {goldstone.name!r} ambiguously matches vectors "
+                f"{[vector.name for vector in candidates]!r}"
+            )
+        mass_expression = _resolved_mass_expression(
+            goldstone,
+            parameter_by_name,
+        )
+        if not candidates:
+            records.append(
+                CompiledGoldstonePartnerRecord(
+                    goldstone=goldstone.name,
+                    vector=None,
+                    policy="explicit",
+                    mass_expression=mass_expression,
+                )
+            )
+            continue
+        vector = candidates[0]
+        propagator = propagator_by_particle.get(vector.name)
+        custom = propagator is not None and propagator.custom
+        records.append(
+            CompiledGoldstonePartnerRecord(
+                goldstone=goldstone.name,
+                vector=vector.name,
+                policy="model-supplied" if custom else "absorbed",
+                mass_expression=mass_expression,
+            )
+        )
+    return tuple(records)
+
+
+__all__ = ["compile_goldstone_partner_records"]
diff --git a/pyamplicol/src/pyamplicol/models/compiler_kernels.py b/pyamplicol/src/pyamplicol/models/compiler_kernels.py
new file mode 100644
index 0000000000..70f7d1114e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_kernels.py
@@ -0,0 +1,654 @@
+# SPDX-License-Identifier: 0BSD
+"""Oriented-kernel fusion and component expression lowering."""
+
+from __future__ import annotations
+
+import math
+import re
+from collections.abc import Mapping, Sequence
+from itertools import product
+
+from .._internal.physics.symbols import ModelSymbolRegistry, symbols
+from . import compiler_symbolica as _sym
+from .compiler_records import _replace_evaluator_constants, _sequence
+from .compiler_tensor_ordering import (
+    OrderedComponents,
+    identity_ordering_for_materialized_axes,
+)
+from .contracts import (
+    CompiledOrientedKernel,
+    CompiledParameterRecord,
+    CompiledParticleRecord,
+    CompiledVertexTerm,
+)
+
+
+def _function_arguments(source: str, head_suffix: str) -> tuple[tuple[str, ...], ...]:
+    """Extract balanced canonical arguments for one fully qualified function."""
+
+    marker = head_suffix + "("
+    result: list[tuple[str, ...]] = []
+    cursor = 0
+    while True:
+        marker_start = source.find(marker, cursor)
+        if marker_start < 0:
+            break
+        open_index = marker_start + len(head_suffix)
+        depth = 0
+        brace_depth = 0
+        argument_start = open_index + 1
+        arguments: list[str] = []
+        index = open_index
+        while index < len(source):
+            character = source[index]
+            if character == "(":
+                depth += 1
+            elif character == ")":
+                depth -= 1
+                if depth == 0:
+                    arguments.append(source[argument_start:index])
+                    result.append(tuple(arguments))
+                    cursor = index + 1
+                    break
+            elif character == "{":
+                brace_depth += 1
+            elif character == "}":
+                brace_depth -= 1
+            elif character == "," and depth == 1 and brace_depth == 0:
+                arguments.append(source[argument_start:index])
+                argument_start = index + 1
+            index += 1
+        else:
+            raise ValueError(f"unbalanced canonical function {head_suffix}")
+    return tuple(result)
+
+
+def _permutation_sign(
+    actual: tuple[int, ...],
+    canonical: tuple[int, ...],
+) -> int:
+    if sorted(actual) != sorted(canonical):
+        raise ValueError(
+            f"color-factor indices {actual} do not match local orientation {canonical}"
+        )
+    positions = {value: index for index, value in enumerate(canonical)}
+    permutation = tuple(positions[value] for value in actual)
+    inversions = sum(
+        permutation[left] > permutation[right]
+        for left in range(len(permutation))
+        for right in range(left + 1, len(permutation))
+    )
+    return -1 if inversions % 2 else 1
+
+
+def _fuse_oriented_kernels(
+    kernels: Sequence[CompiledOrientedKernel],
+    *,
+    model_name: str,
+) -> tuple[CompiledOrientedKernel, ...]:
+    model_symbols = symbols.model(model_name)
+    groups: dict[tuple[object, ...], list[CompiledOrientedKernel]] = {}
+    for kernel in kernels:
+        key = (
+            kernel.vertex,
+            kernel.particles,
+            kernel.source_particle_legs,
+            kernel.coupling_orders,
+            kernel.color_source,
+            kernel.color_expression,
+            kernel.lc_color_normalization_power,
+            kernel.input_ordering_ids,
+            kernel.output_ordering_id,
+        )
+        groups.setdefault(key, []).append(kernel)
+
+    fused: list[CompiledOrientedKernel] = []
+    for members in groups.values():
+        kind = len(fused)
+        first = members[0]
+        remapped_components = [
+            tuple(
+                _remap_kernel_symbols(
+                    _sym.E(component),
+                    old_kind=member.kind,
+                    new_kind=kind,
+                    model_symbols=model_symbols,
+                )
+                for component in member.component_expressions
+            )
+            for member in members
+        ]
+        components = tuple(
+            _canonicalize_oriented_kernel_component(
+                sum(
+                    (
+                        remapped[index]
+                        * symbols.derived_coupling(model_name, member.term_id)
+                        for member, remapped in zip(
+                            members,
+                            remapped_components,
+                            strict=True,
+                        )
+                    ),
+                    _sym.E("0"),
+                )
+            )
+            for index in range(len(remapped_components[0]))
+        )
+        coupling_expression = "1"
+        fused.append(
+            CompiledOrientedKernel(
+                kind=kind,
+                term_id=first.term_id,
+                vertex=first.vertex,
+                particles=first.particles,
+                source_particle_legs=first.source_particle_legs,
+                component_expressions=tuple(
+                    component.to_canonical_string() for component in components
+                ),
+                coupling_expression=coupling_expression,
+                coupling_orders=first.coupling_orders,
+                runtime_parameters=tuple(
+                    sorted({f"derived_coupling_{member.term_id}" for member in members})
+                ),
+                color_source=first.color_source,
+                color_expression=first.color_expression,
+                lc_color_normalization_power=first.lc_color_normalization_power,
+                term_ids=tuple(
+                    term_id
+                    for member in members
+                    for term_id in (member.term_ids or (member.term_id,))
+                ),
+                input_ordering_ids=first.input_ordering_ids,
+                output_ordering_id=first.output_ordering_id,
+            )
+        )
+    return tuple(fused)
+
+
+def _canonicalize_oriented_kernel_component(
+    expression: _sym.Expression,
+) -> _sym.Expression:
+    """Cancel numeric sums, factor couplings, and group primitive inputs."""
+
+    return expression.expand_num().collect_factors().collect_horner()
+
+
+def _remap_kernel_symbols(
+    expression: _sym.Expression,
+    *,
+    old_kind: int,
+    new_kind: int,
+    model_symbols: ModelSymbolRegistry,
+    swap_sides: bool = False,
+) -> _sym.Expression:
+    source = expression.to_canonical_string()
+    kernel_symbols = {
+        (side, momentum_marker == "momentum_", int(index))
+        for side, momentum_marker, index in re.findall(
+            rf"kernel_{old_kind}_(left|right)_(momentum_)?([0-9]+)",
+            source,
+        )
+    }
+    replacements: list[_sym.Replacement] = []
+    for side, is_momentum, index in kernel_symbols:
+        target_side = ("right" if side == "left" else "left") if swap_sides else side
+        if is_momentum:
+            replacements.append(
+                _sym.Replacement(
+                    model_symbols.kernel_momentum(old_kind, side, index),
+                    model_symbols.kernel_momentum(new_kind, target_side, index),
+                )
+            )
+        else:
+            replacements.append(
+                _sym.Replacement(
+                    model_symbols.kernel_component(old_kind, side, index),
+                    model_symbols.kernel_component(new_kind, target_side, index),
+                )
+            )
+    return expression.replace_multiple(replacements) if replacements else expression
+
+
+def _replace_expression_symbols(
+    expression: _sym.Expression,
+    substitutions: Mapping[_sym.Expression, _sym.Expression],
+) -> _sym.Expression:
+    result = expression
+    for source, target in substitutions.items():
+        result = result.replace(source, target)
+    return result
+
+
+def _oriented_component_expressions(
+    term: CompiledVertexTerm,
+    particle_by_name: Mapping[str, CompiledParticleRecord],
+    *,
+    left_leg: int,
+    right_leg: int,
+    result_leg: int,
+    kind: int,
+    model_symbols: ModelSymbolRegistry,
+    use_transverse_massless_yang_mills: bool = False,
+) -> OrderedComponents:
+    library = _sym.TensorLibrary.hep_lib_atom()
+    expression = _sym.E(term.lorentz_expression)
+    particles = tuple(particle_by_name[name] for name in term.particles)
+    left_symbols = _component_symbols(
+        kind,
+        "left",
+        particles[left_leg].spin,
+        model_symbols=model_symbols,
+    )
+    right_symbols = _component_symbols(
+        kind,
+        "right",
+        particles[right_leg].spin,
+        model_symbols=model_symbols,
+    )
+    expression *= _input_tensor_expression(
+        library,
+        kind=kind,
+        side="left",
+        spin=particles[left_leg].spin,
+        leg=left_leg + 1,
+        components=left_symbols,
+        model_symbols=model_symbols,
+    )
+    expression *= _input_tensor_expression(
+        library,
+        kind=kind,
+        side="right",
+        spin=particles[right_leg].spin,
+        leg=right_leg + 1,
+        components=right_symbols,
+        model_symbols=model_symbols,
+    )
+    left_momentum = tuple(
+        model_symbols.kernel_momentum(kind, "left", component) for component in range(4)
+    )
+    right_momentum = tuple(
+        model_symbols.kernel_momentum(kind, "right", component)
+        for component in range(4)
+    )
+    result_momentum = tuple(
+        -(left_momentum[component] + right_momentum[component])
+        for component in range(4)
+    )
+    momentum_by_leg = {
+        left_leg: left_momentum,
+        right_leg: right_momentum,
+        result_leg: result_momentum,
+    }
+    minkowski = _sym.Representation.mink(4)
+    for leg, momentum in momentum_by_leg.items():
+        library.register(
+            _sym.Tensor.dense(
+                _sym.TensorName(model_symbols.ufo_momentum_tensor_name(leg + 1))(
+                    minkowski
+                ),
+                momentum,
+            )
+        )
+    axis_labels = _spin_axis_labels(particles[result_leg].spin, result_leg + 1)
+    # Plain expressions already carry the correct empty scalar interface.
+    network = _sym.TensorNetwork(
+        _sym.as_tensor(expression) if axis_labels else expression, library
+    )
+    network.execute(library=library)
+    result = network.result_tensor(library)
+    ordered_result = _ordered_dense_tensor_components(
+        result,
+        axis_labels,
+    )
+    result_components = ordered_result.values
+    expected_dimension = _spin_dimension(particles[result_leg].spin)
+    if len(result_components) != expected_dimension:
+        raise ValueError(
+            f"oriented kernel {term.vertex}/{term.id} produced "
+            f"{len(result_components)} "
+            f"components for spin {particles[result_leg].spin}, expected "
+            f"{expected_dimension}"
+        )
+    components = tuple(
+        _replace_evaluator_constants(_as_expression(component))
+        for component in result_components
+    )
+    if all(particle.spin == 3 for particle in particles):
+        compact = _compact_yang_mills_three_vector_components(
+            left_leg=left_leg,
+            right_leg=right_leg,
+            result_leg=result_leg,
+            left_components=left_symbols,
+            right_components=right_symbols,
+            momentum_by_leg=momentum_by_leg,
+        )
+        scale = _equivalent_component_scale(components, compact)
+        if scale is not None:
+            if use_transverse_massless_yang_mills:
+                compact = _transverse_yang_mills_three_vector_components(
+                    left_components=left_symbols,
+                    right_components=right_symbols,
+                    left_momentum=left_momentum,
+                    right_momentum=right_momentum,
+                )
+            components = tuple(scale * component for component in compact)
+    return OrderedComponents(
+        ordering=ordered_result.ordering,
+        values=tuple(component.to_canonical_string() for component in components),
+    )
+
+
+def _compact_yang_mills_three_vector_components(
+    *,
+    left_leg: int,
+    right_leg: int,
+    result_leg: int,
+    left_components: Sequence[_sym.Expression],
+    right_components: Sequence[_sym.Expression],
+    momentum_by_leg: Mapping[int, Sequence[_sym.Expression]],
+) -> tuple[_sym.Expression, ...]:
+    """Return the compact canonical Yang-Mills three-vector contraction.
+
+    The caller retains this form only after proving algebraic equivalence to the
+    fully materialized spenso tensor. This makes the optimization independent
+    of UFO Lorentz names and source-expression layout.
+    """
+
+    components_by_leg = {
+        left_leg: tuple(left_components),
+        right_leg: tuple(right_components),
+    }
+    terms = (
+        ((0, 1), 0, 1, 2),
+        ((0, 2), 2, 0, 1),
+        ((1, 2), 1, 2, 0),
+    )
+    outputs: list[_sym.Expression] = []
+    for component in range(4):
+        output = _sym.E("0")
+        for (
+            metric_legs,
+            positive_momentum_leg,
+            negative_momentum_leg,
+            vector_leg,
+        ) in terms:
+            momentum = tuple(
+                momentum_by_leg[positive_momentum_leg][index]
+                - momentum_by_leg[negative_momentum_leg][index]
+                for index in range(4)
+            )
+            if result_leg == vector_leg:
+                output += momentum[component] * _minkowski_dot(
+                    components_by_leg[metric_legs[0]],
+                    components_by_leg[metric_legs[1]],
+                )
+                continue
+            other_metric_leg = (
+                metric_legs[1] if metric_legs[0] == result_leg else metric_legs[0]
+            )
+            output += components_by_leg[other_metric_leg][component] * _minkowski_dot(
+                momentum,
+                components_by_leg[vector_leg],
+            )
+        outputs.append(output)
+    return tuple(outputs)
+
+
+def _transverse_yang_mills_three_vector_components(
+    *,
+    left_components: Sequence[_sym.Expression],
+    right_components: Sequence[_sym.Expression],
+    left_momentum: Sequence[_sym.Expression],
+    right_momentum: Sequence[_sym.Expression],
+) -> tuple[_sym.Expression, ...]:
+    """Return the transverse Berends-Giele massless gauge current.
+
+    The full Yang-Mills contraction differs only by terms proportional to each
+    parent current's self-momentum contraction. AmpliCol removes those terms
+    for massless adjoint gauge currents. Applying the same tensor-derived
+    reduction preserves its fixed-width recursion convention without relying
+    on model-specific particle or Lorentz names.
+    """
+
+    left = tuple(left_components)
+    right = tuple(right_components)
+    left_p = tuple(left_momentum)
+    right_p = tuple(right_momentum)
+    dot = _minkowski_dot(left, right)
+    left_dot_right_p = _minkowski_dot(left, right_p)
+    right_dot_left_p = _minkowski_dot(right, left_p)
+    return tuple(
+        dot * (left_p[index] - right_p[index])
+        + 2 * (left_dot_right_p * right[index] - right_dot_left_p * left[index])
+        for index in range(4)
+    )
+
+
+def _equivalent_component_scale(
+    materialized: Sequence[_sym.Expression],
+    compact: Sequence[_sym.Expression],
+) -> _sym.Expression | None:
+    if len(materialized) != len(compact) or not materialized:
+        return None
+    if any(
+        frozenset(
+            symbol.to_canonical_string() for symbol in dense.get_all_symbols(False)
+        )
+        != frozenset(
+            symbol.to_canonical_string() for symbol in candidate.get_all_symbols(False)
+        )
+        for dense, candidate in zip(materialized, compact, strict=True)
+    ):
+        return None
+    for scale in (_sym.E("1"), _sym.E("-1")):
+        if all(
+            (dense - scale * candidate).expand().to_canonical_string() == "0"
+            for dense, candidate in zip(materialized, compact, strict=True)
+        ):
+            return scale
+    # The compact Yang-Mills convention is only certified for an exact sign.
+    # Retaining the fully materialized tensor is always correct for every other
+    # normalization.  In particular, do not derive a general ratio here:
+    # Symbolica's polynomial cancellation aborts the process for float atoms.
+    return None
+
+
+def _is_compile_time_zero_parameter(
+    name: str,
+    parameters: Mapping[str, CompiledParameterRecord],
+) -> bool:
+    if name.upper() == "ZERO":
+        return True
+    parameter = parameters.get(name)
+    if parameter is None or parameter.nature != "internal":
+        return False
+    expression = _sym.E(parameter.resolved_expression)
+    if expression.get_all_symbols(False):
+        return False
+    try:
+        return complex(expression.evaluate({})) == 0.0
+    except (TypeError, ValueError):
+        return False
+
+
+def _is_single_structure_constant(expression: str) -> bool:
+    return (
+        expression.count("::f(") == 1
+        and len(_function_arguments(expression, "::f")) == 1
+        and "::t(" not in expression.lower()
+        and "::d(" not in expression.lower()
+    )
+
+
+def _minkowski_dot(
+    left: Sequence[_sym.Expression],
+    right: Sequence[_sym.Expression],
+) -> _sym.Expression:
+    if len(left) != 4 or len(right) != 4:
+        raise ValueError("Minkowski dot products require four components")
+    return left[0] * right[0] - sum(
+        (left[index] * right[index] for index in range(1, 4)),
+        _sym.E("0"),
+    )
+
+
+def _input_tensor_expression(
+    library: _sym.TensorLibrary,
+    *,
+    kind: int,
+    side: str,
+    spin: int,
+    leg: int,
+    components: Sequence[_sym.Expression],
+    model_symbols: ModelSymbolRegistry,
+) -> _sym.Expression:
+    representations = _spin_representations(spin)
+    if not representations:
+        if len(components) != 1:
+            raise ValueError("scalar current must have exactly one component")
+        return components[0]
+    name = _sym.TensorName(model_symbols.kernel_tensor_name(kind, side))
+    library.register(_sym.Tensor.dense(name(*representations), components))
+    slots = _spin_slots(spin, leg)
+    return name(*slots).to_expression()
+
+
+def _spin_representations(spin: int) -> tuple[_sym.Representation, ...]:
+    minkowski = _sym.Representation.mink(4)
+    if spin in {-1, 1}:
+        return ()
+    if spin == 2:
+        return (_sym.Representation.bis(4),)
+    if spin == 3:
+        return (minkowski,)
+    if spin == 5:
+        return (minkowski, minkowski)
+    raise ValueError(f"unsupported UFO spin code {spin}")
+
+
+def _spin_slots(spin: int, leg: int):
+    representations = _spin_representations(spin)
+    if spin == 2:
+        return (representations[0](f"ufo_s_1_{leg}"),)
+    if spin == 3:
+        return (representations[0](f"ufo_l_1_{leg}"),)
+    if spin == 5:
+        return (
+            representations[0](f"ufo_l_1_{leg}"),
+            representations[1](f"ufo_l_2_{leg}"),
+        )
+    return ()
+
+
+def _spin_axis_labels(spin: int, leg: int) -> tuple[str, ...]:
+    if spin == 2:
+        return (f"ufo_s_1_{leg}",)
+    if spin == 3:
+        return (f"ufo_l_1_{leg}",)
+    if spin == 5:
+        return (f"ufo_l_1_{leg}", f"ufo_l_2_{leg}")
+    return ()
+
+
+def _ordered_dense_tensor_components(
+    tensor: object,
+    expected_axis_labels: Sequence[str],
+) -> OrderedComponents:
+    """Flatten a dense tensor in explicit physical-index order."""
+
+    tensor = tensor.to_dense()
+    expected = tuple(str(label) for label in expected_axis_labels)
+    if not expected:
+        if len(tensor) != 1:
+            raise ValueError("scalar tensor result unexpectedly has open indices")
+        return OrderedComponents(
+            ordering=identity_ordering_for_materialized_axes((), ()),
+            values=tuple(tensor[index] for index in range(len(tensor))),
+        )
+
+    # Component coordinates follow the tensor's logical axes, not its canonical
+    # structure signature, which can put the same axes in a different order.
+    arguments = tuple(slot.to_expression() for slot in tensor.axes)
+    actual: list[str] = []
+    for argument in arguments:
+        source = argument.to_canonical_string()
+        labels = re.findall(r"ufo_[sl]_[0-9]+_[0-9]+", source)
+        if len(labels) != 1:
+            raise ValueError(
+                "tensor result has an unrecognized physical index: " + source
+            )
+        actual.append(labels[0])
+    if len(set(actual)) != len(actual) or set(actual) != set(expected):
+        raise ValueError(
+            "tensor result index labels do not match the requested physical order: "
+            f"actual={actual}, expected={list(expected)}"
+        )
+
+    positions = tuple(actual.index(label) for label in expected)
+    shape = tuple(int(dimension) for dimension in tensor.shape)
+    if len(shape) != len(actual) or math.prod(shape) != len(tensor):
+        raise ValueError(
+            "tensor result does not cover the complete Cartesian component grid"
+        )
+    by_coordinates: dict[tuple[int, ...], object] = {}
+    for flat_index, coordinates in enumerate(product(*(range(size) for size in shape))):
+        key = tuple(int(coordinates[position]) for position in positions)
+        by_coordinates[key] = tensor[flat_index]
+    ordered_shape = tuple(shape[position] for position in positions)
+    canonical_coordinates = product(*(range(size) for size in ordered_shape))
+    ordering = identity_ordering_for_materialized_axes(
+        expected,
+        ordered_shape,
+    )
+    return OrderedComponents(
+        ordering=ordering,
+        values=tuple(by_coordinates[key] for key in canonical_coordinates),
+    )
+
+
+def _spin_dimension(spin: int) -> int:
+    return {-1: 1, 1: 1, 2: 4, 3: 4, 5: 16}[spin]
+
+
+def _component_symbols(
+    kind: int,
+    side: str,
+    spin: int,
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[_sym.Expression, ...]:
+    return tuple(
+        model_symbols.kernel_component(kind, side, component)
+        for component in range(_spin_dimension(spin))
+    )
+
+
+def _lc_color_normalization_power(source: str) -> int:
+    """Count normalized non-Abelian tensors in one UFO color monomial."""
+
+    expression = _sym.E(source)
+    return sum(
+        len(list(expression.match(_sym.E(pattern))))
+        for pattern in (
+            "UFO::T(a_,b_,c_)",
+            "UFO::f(a_,b_,c_)",
+            "UFO::d(a_,b_,c_)",
+        )
+    )
+
+
+def _as_expression(value: object) -> _sym.Expression:
+    _sym._ensure_symbolica()
+    if isinstance(value, _sym.Expression):
+        return value
+    raise TypeError(
+        f"spenso kernel component is not an Expression: {type(value).__name__}"
+    )
+
+
+def cast_tuple3(value: object) -> tuple[str, str, str]:
+    values = tuple(str(item) for item in _sequence(value))
+    if len(values) != 3:
+        raise ValueError("oriented kernel particles must have length three")
+    return values[0], values[1], values[2]
diff --git a/pyamplicol/src/pyamplicol/models/compiler_records.py b/pyamplicol/src/pyamplicol/models/compiler_records.py
new file mode 100644
index 0000000000..44ae646400
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_records.py
@@ -0,0 +1,294 @@
+# SPDX-License-Identifier: 0BSD
+"""Canonical UFO record parsing and expression resolution."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import replace
+from fractions import Fraction
+from typing import cast
+
+from .._internal.physics.symbols import ModelSymbolRegistry
+from . import compiler_symbolica as _sym
+from .contracts import (
+    DEFAULT_FEYNMAN_PROPAGATOR_SOURCE,
+    MODEL_SUPPLIED_PROPAGATOR_SOURCE,
+    PROPAGATOR_SOURCE_FIELD,
+    CompiledCouplingOrder,
+    CompiledCouplingRecord,
+    CompiledParameterRecord,
+    CompiledParticleRecord,
+    CompiledPropagatorRecord,
+    validate_quantum_number_flow,
+)
+
+_COMPILER_OWNED_PARTICLE_FIELDS = frozenset({"auxiliary_kind", "component_dimension"})
+
+
+def cast_int_tuple3(value: object) -> tuple[int, int, int]:
+    values = tuple(int(item) for item in _sequence(value))
+    if len(values) != 3:
+        raise ValueError("oriented kernel source legs must have length three")
+    return values[0], values[1], values[2]
+
+
+def _order(item: Mapping[str, object]) -> CompiledCouplingOrder:
+    return CompiledCouplingOrder(
+        name=str(item["name"]),
+        expansion_order=int(item["expansion_order"]),
+        hierarchy=int(item["hierarchy"]),
+    )
+
+
+def _parameter(
+    item: Mapping[str, object],
+    *,
+    model_symbols: ModelSymbolRegistry | None = None,
+) -> CompiledParameterRecord:
+    expression = _optional_string(item.get("expression"))
+    if expression is not None and model_symbols is not None:
+        expression = model_symbols.expression_string(expression)
+    value = _optional_pair(item.get("value"))
+    return CompiledParameterRecord(
+        name=str(item["name"]),
+        nature=str(item["nature"]),
+        parameter_type=str(item["parameter_type"]),
+        value=value,
+        expression=expression,
+        resolved_expression=(
+            expression
+            if expression is not None
+            else _numeric_expression(value or (0.0, 0.0)).to_canonical_string()
+        ),
+        lhablock=_optional_string(item.get("lhablock")),
+        lhacode=tuple(int(value) for value in _sequence(item.get("lhacode"))),
+    )
+
+
+def _particle(
+    item: Mapping[str, object],
+) -> CompiledParticleRecord:
+    name = str(item["name"])
+    supplied_metadata = sorted(_COMPILER_OWNED_PARTICLE_FIELDS.intersection(item))
+    if supplied_metadata:
+        fields = ", ".join(supplied_metadata)
+        raise ValueError(
+            f"particle {name!r} supplies compiler-owned metadata in "
+            f"untrusted input: {fields}"
+        )
+    return _particle_record(item)
+
+
+def _particle_record(item: Mapping[str, object]) -> CompiledParticleRecord:
+    name = str(item["name"])
+    raw_charge = item.get("charge", 0.0)
+    # Loader 1.0 exports exact rational strings; retain them in charge-flow
+    # proofs while keeping the public numerical charge a float.
+    exact_charge = Fraction(raw_charge) if isinstance(raw_charge, str) else None
+    charge = float(exact_charge if exact_charge is not None else raw_charge)
+    quantum_numbers = item.get("quantum_numbers")
+    if quantum_numbers is None:
+        charge_flow = (
+            str(exact_charge)
+            if exact_charge is not None
+            else _exact_float_expression(charge)
+        )
+        quantum_numbers = (("electric_charge", charge_flow),)
+    return CompiledParticleRecord(
+        name=name,
+        antiname=str(item["antiname"]),
+        pdg_code=int(item["pdg_code"]),
+        spin=int(item["spin"]),
+        color=int(item["color"]),
+        mass=str(item["mass"]),
+        width=str(item["width"]),
+        charge=charge,
+        quantum_numbers=validate_quantum_number_flow(
+            quantum_numbers,
+            context=f"particle {name!r}",
+        ),
+        ghost_number=int(item.get("ghost_number", 0)),
+        propagating=bool(item.get("propagating", True)),
+        goldstoneboson=bool(item.get("goldstoneboson", False)),
+        propagator=_optional_string(item.get("propagator")),
+        component_dimension=cast(int | None, item.get("component_dimension")),
+        auxiliary_kind=_optional_string(item.get("auxiliary_kind")),
+    )
+
+
+def _exact_float_expression(value: float) -> str:
+    if not math.isfinite(value):
+        raise ValueError("particle electric charge must be finite")
+    numerator, denominator = value.as_integer_ratio()
+    if denominator == 1:
+        return str(numerator)
+    return f"{numerator}/{denominator}"
+
+
+def _coupling(
+    item: Mapping[str, object],
+    *,
+    model_symbols: ModelSymbolRegistry | None = None,
+) -> CompiledCouplingRecord:
+    expression = str(item["expression"])
+    if model_symbols is not None:
+        expression = model_symbols.expression_string(expression)
+    return CompiledCouplingRecord(
+        name=str(item["name"]),
+        expression=expression,
+        resolved_expression=expression,
+        value=_optional_pair(item.get("value")),
+        orders=_orders(item.get("orders")),
+    )
+
+
+def _propagator(
+    item: Mapping[str, object],
+    particles: Sequence[CompiledParticleRecord],
+) -> CompiledPropagatorRecord:
+    particle_name = str(item["particle"])
+    particle = next(
+        (candidate for candidate in particles if candidate.name == particle_name),
+        None,
+    )
+    name = str(item["name"])
+    if particle is None:
+        raise ValueError(
+            f"propagator {name!r} refers to unknown particle {particle_name!r}"
+        )
+    if particle.propagator != name:
+        raise ValueError(
+            f"propagator {name!r} is not linked from particle {particle_name!r}"
+        )
+    source = str(item.get(PROPAGATOR_SOURCE_FIELD, ""))
+    if source not in {
+        DEFAULT_FEYNMAN_PROPAGATOR_SOURCE,
+        MODEL_SUPPLIED_PROPAGATOR_SOURCE,
+    }:
+        raise ValueError(
+            f"propagator {name!r} has no valid generation-time source metadata"
+        )
+    return CompiledPropagatorRecord(
+        name=name,
+        particle=particle_name,
+        numerator=str(item["numerator"]),
+        denominator=str(item["denominator"]),
+        custom=source == MODEL_SUPPLIED_PROPAGATOR_SOURCE,
+    )
+
+
+def _orders(value: object) -> tuple[tuple[str, int], ...]:
+    result = []
+    for pair in _sequence(value):
+        values = _sequence(pair)
+        if len(values) != 2:
+            raise ValueError("coupling order must be [name, value]")
+        result.append((str(values[0]), int(values[1])))
+    return tuple(result)
+
+
+def _pair(value: object) -> tuple[float, float]:
+    pair = _sequence(value)
+    if len(pair) != 2:
+        raise ValueError("complex value must be [real, imaginary]")
+    return float(pair[0]), float(pair[1])
+
+
+def _optional_pair(value: object) -> tuple[float, float] | None:
+    return None if value is None else _pair(value)
+
+
+def _optional_string(value: object) -> str | None:
+    return None if value is None else str(value)
+
+
+def _resolve_parameter_records(
+    records: Sequence[CompiledParameterRecord],
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[CompiledParameterRecord, ...]:
+    by_name = {record.name: record for record in records}
+    parameter_symbols = {name: model_symbols.symbol(name) for name in by_name}
+    resolved: dict[str, _sym.Expression] = {}
+    active: list[str] = []
+
+    def resolve(name: str) -> _sym.Expression:
+        if name in resolved:
+            return resolved[name]
+        if name in active:
+            cycle = " -> ".join((*active, name))
+            raise ValueError(f"cyclic UFO parameter definitions: {cycle}")
+        record = by_name[name]
+        if record.nature == "external":
+            resolved[name] = parameter_symbols[name]
+            return resolved[name]
+        active.append(name)
+        expression = (
+            model_symbols.expression(record.expression)
+            if record.expression is not None
+            else _numeric_expression(record.value or (0.0, 0.0))
+        )
+        expression_symbols = set(expression.get_all_symbols(False))
+        for dependency, symbol in parameter_symbols.items():
+            if dependency == name or symbol not in expression_symbols:
+                continue
+            expression = expression.replace(symbol, resolve(dependency))
+        active.pop()
+        resolved[name] = expression
+        return resolved[name]
+
+    return tuple(
+        replace(record, resolved_expression=resolve(record.name).to_canonical_string())
+        for record in records
+    )
+
+
+def _resolve_coupling_records(
+    records: Sequence[CompiledCouplingRecord],
+    parameters: Sequence[CompiledParameterRecord],
+    model_symbols: ModelSymbolRegistry,
+) -> tuple[CompiledCouplingRecord, ...]:
+    replacements = {
+        model_symbols.symbol(parameter.name): _sym.E(parameter.resolved_expression)
+        for parameter in parameters
+        if parameter.nature != "external"
+    }
+    result = []
+    for record in records:
+        expression = model_symbols.expression(record.expression)
+        expression_symbols = set(expression.get_all_symbols(False))
+        for symbol, replacement_expression in replacements.items():
+            if symbol in expression_symbols:
+                expression = expression.replace(symbol, replacement_expression)
+        result.append(
+            replace(
+                record,
+                resolved_expression=expression.to_canonical_string(),
+            )
+        )
+    return tuple(result)
+
+
+def _replace_evaluator_constants(expression: _sym.Expression) -> _sym.Expression:
+    # Only call at the f64 evaluator boundary. The model's symbolic records
+    # must retain Pi: rounding it before resolving G and G**2 independently
+    # breaks gauge identities that higher-precision evaluation cannot recover.
+    return expression.replace(_sym.E("pi"), _sym.E(repr(math.pi)))
+
+
+def _numeric_expression(value: tuple[float, float]) -> _sym.Expression:
+    real, imaginary = value
+    return _sym.E(repr(real)) + _sym.E(repr(imaginary)) * _sym.E("1𝑖")  # noqa: RUF001
+
+
+def _sequence(value: object) -> list[object]:
+    return list(value) if isinstance(value, (list, tuple)) else []
+
+
+def _mappings(value: object) -> list[dict[str, object]]:
+    result = []
+    for item in _sequence(value):
+        if not isinstance(item, dict):
+            raise ValueError("compiled model list entry must be an object")
+        result.append({str(key): element for key, element in item.items()})
+    return result
diff --git a/pyamplicol/src/pyamplicol/models/compiler_symbolica.py b/pyamplicol/src/pyamplicol/models/compiler_symbolica.py
new file mode 100644
index 0000000000..ed07d479c4
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_symbolica.py
@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: 0BSD
+"""Process-wide lazy Symbolica namespace for model compilation."""
+
+from __future__ import annotations
+
+import math
+from threading import RLock
+from typing import Any
+
+E: Any = None
+S: Any = None
+Expression: Any = None
+Replacement: Any = None
+Tensor: Any = None
+Representation: Any = None
+TensorLibrary: Any = None
+TensorName: Any = None
+TensorNetwork: Any = None
+as_tensor: Any = None
+_SYMBOLICA_READY = False
+_SYMBOLICA_LOCK = RLock()
+
+
+def _ensure_symbolica() -> None:
+    global E, S, Expression, Replacement, Tensor, Representation
+    global TensorLibrary, TensorName, TensorNetwork, as_tensor, _SYMBOLICA_READY
+
+    if _SYMBOLICA_READY:
+        return
+    with _SYMBOLICA_LOCK:
+        if _SYMBOLICA_READY:
+            return
+        from symbolica import E as expression_parser
+        from symbolica import Expression as expression_type
+        from symbolica import Replacement as replacement_type
+        from symbolica import S as symbol
+        from symbolica.community.tensor import Representation as representation_type
+        from symbolica.community.tensor import Tensor as tensor_type
+        from symbolica.community.tensor import TensorLibrary as tensor_library_type
+        from symbolica.community.tensor import TensorName as tensor_name_type
+        from symbolica.community.tensor import TensorNetwork as tensor_network_type
+        from symbolica.community.tensor import as_tensor as tensor_expression
+
+        E = expression_parser
+        S = symbol
+        Expression = expression_type
+        Replacement = replacement_type
+        Tensor = tensor_type
+        Representation = representation_type
+        TensorLibrary = tensor_library_type
+        TensorName = tensor_name_type
+        TensorNetwork = tensor_network_type
+        as_tensor = tensor_expression
+        _SYMBOLICA_READY = True
+
+
+def _exact_binary64_coefficients(expression: Any) -> Any:
+    """Replace binary64 atoms by rationals with exactly their stored value.
+
+    Literal matching preserves the numeric kind and precision: rational and
+    higher-precision atoms must never be rounded through Python's ``complex``.
+    """
+    from symbolica import AtomType
+
+    _ensure_symbolica()
+    pending = [expression]
+    replacements: dict[Any, Any] = {}
+    while pending:
+        atom = pending.pop()
+        kind = atom.get_type()
+        if kind == AtomType.Var:
+            continue
+        if kind != AtomType.Num:
+            pending.extend(atom)
+            continue
+        try:
+            value = complex(atom)
+        except (TypeError, ValueError, OverflowError):
+            continue
+        if not math.isfinite(value.real) or not math.isfinite(value.imag):
+            continue
+        if not bool(atom.matches(Expression.num(value))):
+            continue
+        real_n, real_d = value.real.as_integer_ratio()
+        imag_n, imag_d = value.imag.as_integer_ratio()
+        replacements[atom] = E(f"({real_n}/{real_d})+1i*({imag_n}/{imag_d})")
+    if not replacements:
+        return expression
+    return expression.replace_multiple(
+        [Replacement(source, target) for source, target in replacements.items()]
+    )
diff --git a/pyamplicol/src/pyamplicol/models/compiler_tensor_ordering.py b/pyamplicol/src/pyamplicol/models/compiler_tensor_ordering.py
new file mode 100644
index 0000000000..3986b6b06e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/compiler_tensor_ordering.py
@@ -0,0 +1,507 @@
+# SPDX-License-Identifier: 0BSD
+"""Compile explicit component-ordering contracts for external UFO models."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, replace
+
+from ._physics_ir import (
+    TENSOR_ORDERING_CONTRACT_VERSION,
+    CompiledCurrentOrderingRecord,
+    TensorAxisIR,
+    TensorIndexBindingIR,
+    TensorOrderingIR,
+)
+from .contracts import (
+    CompiledOrientedKernel,
+    CompiledParameterRecord,
+    CompiledParticleRecord,
+    CompiledPropagatorRecord,
+    CompiledVertexTerm,
+    compiled_particle_component_dimension,
+    compiled_particle_is_chiral_eligible,
+)
+
+_NORMALIZED_INDEX_PATTERN = re.compile(
+    r"\bufo_(?P<family>[lsc])_(?:"
+    r"dummy_(?P<dummy>[0-9]+)(?:_(?P<dummy_space>[a-z]+))?"
+    r"|(?P<component>[0-9]+)_(?P<leg>[0-9]+)"
+    r"|(?P<leg_only>[0-9]+))\b"
+)
+_NORMALIZED_INDEX_TOKEN_PATTERN = re.compile(r"\bufo_[lsc]_[A-Za-z0-9_]+\b")
+_COLOR_DUMMY_SPACES = frozenset(
+    {"adjoint", "fundamental", "antifundamental"}
+)
+
+
+@dataclass(frozen=True, slots=True)
+class OrderedComponents:
+    """Materialized values with their proven canonical storage contract."""
+
+    ordering: TensorOrderingIR
+    values: tuple[object, ...]
+
+    def __post_init__(self) -> None:
+        if len(self.values) != self.ordering.stored_size:
+            raise ValueError(
+                "materialized component count does not match its tensor ordering"
+            )
+
+    @property
+    def ordering_id(self) -> str:
+        return self.ordering.ordering_id
+
+
+def identity_ordering_for_materialized_axes(
+    expected_axis_labels: Sequence[str],
+    extents: Sequence[int],
+) -> TensorOrderingIR:
+    labels = tuple(str(label) for label in expected_axis_labels)
+    dimensions = tuple(int(extent) for extent in extents)
+    if len(labels) != len(dimensions):
+        raise ValueError("tensor axis labels and extents must have equal length")
+    spaces = tuple(_space_from_axis_label(label) for label in labels)
+    return TensorOrderingIR.identity(
+        basis=_basis_for_spaces(spaces),
+        axes=tuple(
+            TensorAxisIR(name=f"axis-{index}", space=space, extent=extent)
+            for index, (space, extent) in enumerate(
+                zip(spaces, dimensions, strict=True)
+            )
+        ),
+    )
+
+
+def compile_vertex_index_bindings(
+    term: CompiledVertexTerm,
+    particle_by_name: Mapping[str, CompiledParticleRecord],
+) -> tuple[TensorIndexBindingIR, ...]:
+    """Record physical-leg and dummy provenance without making it identity."""
+
+    descriptors: list[tuple[str, str, int | None, int | None, int | None]] = []
+    seen: set[tuple[str, str, int | None, int | None, int | None]] = set()
+    for origin, expression in (
+        ("color", term.color_expression),
+        ("lorentz", term.lorentz_expression),
+    ):
+        matches = tuple(_NORMALIZED_INDEX_PATTERN.finditer(expression))
+        matched_spans = {match.span() for match in matches}
+        for token in _NORMALIZED_INDEX_TOKEN_PATTERN.finditer(expression):
+            if token.span() not in matched_spans:
+                raise ValueError(
+                    f"vertex term {term.id} contains malformed normalized tensor "
+                    f"index {token.group(0)!r}"
+                )
+        for match in matches:
+            family = match.group("family")
+            component_text = match.group("component")
+            leg_text = match.group("leg") or match.group("leg_only")
+            dummy_text = match.group("dummy")
+            source_component = (
+                None if component_text is None else int(component_text)
+            )
+            source_leg = None if leg_text is None else int(leg_text)
+            source_dummy = None if dummy_text is None else -int(dummy_text)
+            _validate_index_source(
+                term,
+                origin=origin,
+                family=family,
+                source_component=source_component,
+                source_leg=source_leg,
+                source_dummy=source_dummy,
+                dummy_space=match.group("dummy_space"),
+                particle_by_name=particle_by_name,
+            )
+            space = _binding_space(
+                family,
+                source_leg=source_leg,
+                dummy_space=match.group("dummy_space"),
+                particles=term.particles,
+                particle_by_name=particle_by_name,
+            )
+            descriptor = (
+                origin,
+                space,
+                source_component,
+                source_leg,
+                source_dummy,
+            )
+            if descriptor not in seen:
+                seen.add(descriptor)
+                descriptors.append(descriptor)
+
+    dummy_ordinals: dict[tuple[str, str, int], int] = {}
+    next_dummy_by_space: dict[tuple[str, str], int] = {}
+    bindings: list[TensorIndexBindingIR] = []
+    for origin, space, component, leg, dummy in descriptors:
+        if dummy is None:
+            normalized_name = f"{origin}:{space}:leg-{leg}"
+            if component is not None:
+                normalized_name += f":component-{component}"
+        else:
+            key = (origin, space, dummy)
+            if key not in dummy_ordinals:
+                space_key = (origin, space)
+                ordinal = next_dummy_by_space.get(space_key, 0)
+                next_dummy_by_space[space_key] = ordinal + 1
+                dummy_ordinals[key] = ordinal
+            normalized_name = f"{origin}:{space}:dummy-{dummy_ordinals[key]}"
+        bindings.append(
+            TensorIndexBindingIR(
+                origin=origin,
+                space=space,
+                source_component=component,
+                source_leg=leg,
+                source_dummy=dummy,
+                normalized_name=normalized_name,
+            )
+        )
+    return tuple(bindings)
+
+
+def compile_tensor_ordering_metadata(
+    terms: Sequence[CompiledVertexTerm],
+    particles: Sequence[CompiledParticleRecord],
+    kernels: Sequence[CompiledOrientedKernel],
+    parameters: Sequence[CompiledParameterRecord],
+    propagators: Sequence[CompiledPropagatorRecord],
+) -> tuple[
+    tuple[CompiledVertexTerm, ...],
+    tuple[CompiledOrientedKernel, ...],
+    tuple[TensorOrderingIR, ...],
+    tuple[CompiledCurrentOrderingRecord, ...],
+]:
+    """Attach and cross-check every external model component-ordering reference."""
+
+    particle_by_name = {particle.name: particle for particle in particles}
+    parameters_by_name = {parameter.name: parameter for parameter in parameters}
+    propagators_by_name = {propagator.name: propagator for propagator in propagators}
+    contact_orderings = _contact_auxiliary_orderings(terms, particle_by_name)
+    ordering_registry: dict[str, TensorOrderingIR] = {}
+
+    def register(ordering: TensorOrderingIR) -> TensorOrderingIR:
+        previous = ordering_registry.setdefault(ordering.ordering_id, ordering)
+        if previous != ordering:
+            raise ValueError(
+                f"tensor ordering digest collision for {ordering.ordering_id!r}"
+            )
+        return previous
+
+    full_ordering_by_particle: dict[str, TensorOrderingIR] = {}
+    current_orderings: list[CompiledCurrentOrderingRecord] = []
+    for particle in particles:
+        full = register(
+            contact_orderings.get(
+                particle.name,
+                _full_particle_ordering(particle),
+            )
+        )
+        full_ordering_by_particle[particle.name] = full
+        identity = tuple(range(full.stored_size))
+        current_orderings.append(
+            CompiledCurrentOrderingRecord(
+                particle=particle.name,
+                chirality=0,
+                ordering_id=full.ordering_id,
+                kernel_ordering_id=full.ordering_id,
+                input_embedding=identity,
+                result_projection=identity,
+            )
+        )
+        if compiled_particle_is_chiral_eligible(
+            particle,
+            parameters=parameters_by_name,
+            propagators=propagators_by_name,
+        ):
+            for chirality in (-1, 1):
+                projected = register(
+                    TensorOrderingIR.identity(
+                        basis=f"weyl-chirality:{chirality:+d}",
+                        axes=(
+                            TensorAxisIR(
+                                name="axis-0",
+                                space="weyl-spinor",
+                                extent=2,
+                            ),
+                        ),
+                    )
+                )
+                input_embedding = (
+                    (None, None, 0, 1)
+                    if chirality == -1
+                    else (0, 1, None, None)
+                )
+                result_projection = (0, 1) if chirality == -1 else (2, 3)
+                current_orderings.append(
+                    CompiledCurrentOrderingRecord(
+                        particle=particle.name,
+                        chirality=chirality,
+                        ordering_id=projected.ordering_id,
+                        kernel_ordering_id=full.ordering_id,
+                        input_embedding=input_embedding,
+                        result_projection=result_projection,
+                    )
+                )
+
+    annotated_terms: list[CompiledVertexTerm] = []
+    for term in terms:
+        source_ordering_ids = tuple(
+            full_ordering_by_particle[name].ordering_id for name in term.particles
+        )
+        index_bindings = compile_vertex_index_bindings(term, particle_by_name)
+        if term.source_ordering_ids and term.source_ordering_ids != source_ordering_ids:
+            raise ValueError(f"vertex term {term.id} has stale source tensor orderings")
+        if term.index_bindings and term.index_bindings != index_bindings:
+            raise ValueError(f"vertex term {term.id} has stale tensor index bindings")
+        annotated_terms.append(
+            replace(
+                term,
+                source_ordering_ids=source_ordering_ids,
+                index_bindings=index_bindings,
+            )
+        )
+
+    annotated_kernels: list[CompiledOrientedKernel] = []
+    for kernel in kernels:
+        input_ordering_ids = (
+            full_ordering_by_particle[kernel.particles[0]].ordering_id,
+            full_ordering_by_particle[kernel.particles[1]].ordering_id,
+        )
+        output_ordering_id = full_ordering_by_particle[
+            kernel.particles[2]
+        ].ordering_id
+        if (
+            kernel.input_ordering_ids
+            and kernel.input_ordering_ids != input_ordering_ids
+        ):
+            raise ValueError(f"oriented kernel {kernel.kind} has stale input orderings")
+        if (
+            kernel.output_ordering_id
+            and kernel.output_ordering_id != output_ordering_id
+        ):
+            raise ValueError(f"oriented kernel {kernel.kind} has stale output ordering")
+        annotated_kernels.append(
+            replace(
+                kernel,
+                input_ordering_ids=input_ordering_ids,
+                output_ordering_id=output_ordering_id,
+                term_ids=kernel.term_ids or (kernel.term_id,),
+            )
+        )
+
+    return (
+        tuple(annotated_terms),
+        tuple(annotated_kernels),
+        tuple(sorted(ordering_registry.values(), key=lambda item: item.ordering_id)),
+        tuple(current_orderings),
+    )
+
+
+def _contact_auxiliary_orderings(
+    terms: Sequence[CompiledVertexTerm],
+    particle_by_name: Mapping[str, CompiledParticleRecord],
+) -> dict[str, TensorOrderingIR]:
+    result: dict[str, TensorOrderingIR] = {}
+    for term in terms:
+        proof = term.contact_decomposition_proof
+        if proof is None or proof.status != "proven":
+            continue
+        for split in proof.splits:
+            expected_axis_order = tuple(
+                label
+                for leg in split.open_legs
+                for label in _spin_axis_labels(
+                    particle_by_name[term.particles[leg]].spin,
+                    leg + 1,
+                )
+            )
+            if split.component_axis_order != expected_axis_order:
+                raise ValueError(
+                    f"contact term {term.id} result leg {split.result_leg} has "
+                    "non-canonical component axes"
+                )
+            name = f"__pyamplicol_contact_{term.id}_r{split.result_leg}"
+            spaces = tuple(
+                _space_from_axis_label(label) for label in split.component_axis_order
+            )
+            ordering = TensorOrderingIR.create(
+                basis=(
+                    "contact-scalar"
+                    if not spaces
+                    else "contact:" + "x".join(spaces)
+                ),
+                axes=tuple(
+                    TensorAxisIR(name=f"axis-{index}", space=space, extent=4)
+                    for index, space in enumerate(spaces)
+                ),
+                component_basis=split.component_basis_order,
+                component_expansion=split.component_expansion,
+            )
+            previous = result.setdefault(name, ordering)
+            if previous != ordering:
+                raise ValueError(
+                    f"contact auxiliary {name!r} has conflicting tensor orderings"
+                )
+    return result
+
+
+def _full_particle_ordering(particle: CompiledParticleRecord) -> TensorOrderingIR:
+    expected_dimension = {-1: 1, 1: 1, 2: 4, 3: 4, 5: 16}.get(particle.spin)
+    component_dimension = compiled_particle_component_dimension(particle)
+    if expected_dimension is None or component_dimension != expected_dimension:
+        basis = "opaque-auxiliary"
+        if particle.auxiliary_kind:
+            basis += f":{particle.auxiliary_kind.split(':', 1)[0]}"
+        return TensorOrderingIR.identity(
+            basis=basis,
+            axes=(
+                TensorAxisIR(
+                    name="axis-0",
+                    space="opaque-component",
+                    extent=component_dimension,
+                ),
+            ),
+        )
+    spaces = {
+        -1: (),
+        1: (),
+        2: ("bispinor",),
+        3: ("lorentz-vector",),
+        5: ("lorentz-vector", "lorentz-vector"),
+    }.get(particle.spin)
+    if spaces is None:
+        raise ValueError(
+            f"particle {particle.name!r} has unsupported tensor spin {particle.spin}"
+        )
+    return TensorOrderingIR.identity(
+        basis=_basis_for_spaces(spaces),
+        axes=tuple(
+            TensorAxisIR(name=f"axis-{index}", space=space, extent=4)
+            for index, space in enumerate(spaces)
+        ),
+    )
+
+
+def _basis_for_spaces(spaces: Sequence[str]) -> str:
+    values = tuple(spaces)
+    if not values:
+        return "scalar"
+    if values == ("bispinor",):
+        return "dirac"
+    if values == ("lorentz-vector",):
+        return "lorentz-vector"
+    if values == ("lorentz-vector", "lorentz-vector"):
+        return "lorentz-rank-2"
+    return "tensor-product:" + "x".join(values)
+
+
+def _space_from_axis_label(label: str) -> str:
+    if re.fullmatch(r"ufo_s_[0-9]+_[0-9]+", label):
+        return "bispinor"
+    if re.fullmatch(r"ufo_l_[0-9]+_[0-9]+", label):
+        return "lorentz-vector"
+    raise ValueError(f"unsupported physical tensor axis label {label!r}")
+
+
+def _spin_axis_labels(spin: int, leg: int) -> tuple[str, ...]:
+    if spin in {-1, 1}:
+        return ()
+    if spin == 2:
+        return (f"ufo_s_1_{leg}",)
+    if spin == 3:
+        return (f"ufo_l_1_{leg}",)
+    if spin == 5:
+        return (f"ufo_l_1_{leg}", f"ufo_l_2_{leg}")
+    raise ValueError(f"unsupported tensor spin {spin} on source leg {leg}")
+
+
+def _validate_index_source(
+    term: CompiledVertexTerm,
+    *,
+    origin: str,
+    family: str,
+    source_component: int | None,
+    source_leg: int | None,
+    source_dummy: int | None,
+    dummy_space: str | None,
+    particle_by_name: Mapping[str, CompiledParticleRecord],
+) -> None:
+    if origin == "color" and family != "c":
+        raise ValueError(
+            f"vertex term {term.id} color expression contains a non-color index"
+        )
+    if origin == "lorentz" and family == "c":
+        raise ValueError(
+            f"vertex term {term.id} Lorentz expression contains a color index"
+        )
+    if source_dummy is not None:
+        if family == "c":
+            if dummy_space not in _COLOR_DUMMY_SPACES:
+                raise ValueError(
+                    f"vertex term {term.id} has unknown color dummy space "
+                    f"{dummy_space!r}"
+                )
+        elif dummy_space is not None:
+            raise ValueError(
+                f"vertex term {term.id} has a typed non-color dummy index"
+            )
+        return
+    if source_leg is None or source_leg > len(term.particles):
+        raise ValueError(f"tensor index refers to absent source leg {source_leg}")
+    particle = particle_by_name[term.particles[source_leg - 1]]
+    if family == "c":
+        if source_component is not None:
+            raise ValueError(
+                f"vertex term {term.id} color index has an invalid component ordinal"
+            )
+        if particle.color not in {-3, 3, 8}:
+            raise ValueError(
+                f"vertex term {term.id} color index refers to singlet particle "
+                f"{particle.name!r}"
+            )
+        return
+    expected_family = "s" if particle.spin == 2 else "l"
+    label = f"ufo_{family}_{source_component}_{source_leg}"
+    if family != expected_family or label not in _spin_axis_labels(
+        particle.spin,
+        source_leg,
+    ):
+        raise ValueError(
+            f"vertex term {term.id} tensor index {label!r} is incompatible with "
+            f"particle {particle.name!r} spin {particle.spin}"
+        )
+
+
+def _binding_space(
+    family: str,
+    *,
+    source_leg: int | None,
+    dummy_space: str | None,
+    particles: Sequence[str],
+    particle_by_name: Mapping[str, CompiledParticleRecord],
+) -> str:
+    if family == "l":
+        return "lorentz-vector"
+    if family == "s":
+        return "bispinor"
+    if source_leg is None:
+        return "color-" + (dummy_space or "unknown")
+    if source_leg < 1 or source_leg > len(particles):
+        raise ValueError(f"tensor index refers to absent source leg {source_leg}")
+    particle = particle_by_name[particles[source_leg - 1]]
+    return {
+        -3: "color-antifundamental",
+        3: "color-fundamental",
+        8: "color-adjoint",
+    }[particle.color]
+
+
+__all__ = [
+    "TENSOR_ORDERING_CONTRACT_VERSION",
+    "OrderedComponents",
+    "compile_tensor_ordering_metadata",
+    "compile_vertex_index_bindings",
+    "identity_ordering_for_materialized_axes",
+]
diff --git a/pyamplicol/src/pyamplicol/models/contact_decomposition.py b/pyamplicol/src/pyamplicol/models/contact_decomposition.py
new file mode 100644
index 0000000000..1a76e4243f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/contact_decomposition.py
@@ -0,0 +1,1074 @@
+# SPDX-License-Identifier: 0BSD
+"""Serialized proof records for explicit UFO contact decomposition."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Protocol
+
+CONTACT_DECOMPOSITION_ALGORITHM = "ufo-four-point-contact-decomposition"
+CONTACT_DECOMPOSITION_ALGORITHM_VERSION = 2
+CONTACT_ORBIT_ALGORITHM = "compiler-certified-contact-orbit"
+CONTACT_ORBIT_ALGORITHM_VERSION = 2
+CONTACT_ORBIT_EVALUATOR_CLASS = "constant-scalar-literal-singlet-self-conjugate-boson"
+HEFT_CONTACT_ORBIT_EVALUATOR_CLASS = "scalar-heft-colored-contact-tree"
+CONTACT_ORBIT_EVALUATOR_CLASSES = frozenset(
+    {CONTACT_ORBIT_EVALUATOR_CLASS, HEFT_CONTACT_ORBIT_EVALUATOR_CLASS}
+)
+
+
+def contact_orbit_evaluator_class_is_certifiable(
+    *,
+    color_source: str,
+    color_expression: str,
+    lorentz_expression: str,
+    decomposition_kinds: tuple[str, ...],
+    particle_contracts: tuple[tuple[int, int, str, str, bool | None], ...],
+) -> bool:
+    """Recognize the one compiler-owned evaluator class admitted by the proof."""
+
+    return (
+        len(particle_contracts) == 4
+        and color_expression == "1"
+        and lorentz_expression == "1"
+        and (color_source in {"1", "UFO::{}::1"} or color_expression == "1")
+        and bool(decomposition_kinds)
+        and all(kind == "literal-color-singlet" for kind in decomposition_kinds)
+        and all(
+            spin == 1
+            and color == 1
+            and statistics == "boson"
+            and wavefunction_family == "scalar"
+            and self_conjugate is True
+            for spin, color, statistics, wavefunction_family, self_conjugate in (
+                particle_contracts
+            )
+        )
+    )
+
+
+class _ContactTerm(Protocol):
+    @property
+    def id(self) -> int: ...
+
+    @property
+    def vertex(self) -> str: ...
+
+    @property
+    def particles(self) -> tuple[str, ...]: ...
+
+    @property
+    def color_index(self) -> int: ...
+
+    @property
+    def lorentz_index(self) -> int: ...
+
+    @property
+    def color_source(self) -> str: ...
+
+    @property
+    def color_expression(self) -> str: ...
+
+    @property
+    def lorentz_name(self) -> str: ...
+
+    @property
+    def lorentz_source(self) -> str: ...
+
+    @property
+    def lorentz_expression(self) -> str: ...
+
+
+@dataclass(frozen=True)
+class CompiledContactUnsupportedReason:
+    code: str
+    message: str
+    context: tuple[tuple[str, str], ...] = ()
+
+    def __post_init__(self) -> None:
+        if not self.code or not self.message:
+            raise ValueError(
+                "contact decomposition reason must have a code and message"
+            )
+        if self.context != tuple(sorted(self.context)):
+            raise ValueError("contact decomposition reason context must be sorted")
+        names = tuple(name for name, _value in self.context)
+        if any(not name for name in names) or len(names) != len(set(names)):
+            raise ValueError(
+                "contact decomposition reason context names must be non-empty and "
+                "unique"
+            )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "code": self.code,
+            "message": self.message,
+            "context": dict(self.context),
+        }
+
+    @classmethod
+    def from_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> CompiledContactUnsupportedReason:
+        fields = _strict_record_fields(
+            payload,
+            required={"code", "message", "context"},
+            context="compiled contact unsupported reason",
+        )
+        context = _strict_mapping(fields["context"], "contact reason context")
+        return cls(
+            code=_strict_string(fields["code"], "contact reason code"),
+            message=_strict_string(fields["message"], "contact reason message"),
+            context=tuple(
+                sorted(
+                    (
+                        _strict_string(name, "contact reason context name"),
+                        _strict_string(value, "contact reason context value"),
+                    )
+                    for name, value in context.items()
+                )
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class CompiledContactDummyIndexMapping:
+    source_index: int
+    normalized_symbol: str
+    outer_slot: int
+    final_slot: int
+
+    def __post_init__(self) -> None:
+        if self.source_index >= 0:
+            raise ValueError("contact dummy source index must be negative")
+        if not self.normalized_symbol:
+            raise ValueError("contact dummy normalized symbol must not be empty")
+        if self.outer_slot not in range(3) or self.final_slot not in range(3):
+            raise ValueError("contact dummy slots must address a structure constant")
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "source_index": self.source_index,
+            "normalized_symbol": self.normalized_symbol,
+            "outer_slot": self.outer_slot,
+            "final_slot": self.final_slot,
+        }
+
+    @classmethod
+    def from_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> CompiledContactDummyIndexMapping:
+        fields = _strict_record_fields(
+            payload,
+            required={"source_index", "normalized_symbol", "outer_slot", "final_slot"},
+            context="compiled contact dummy-index mapping",
+        )
+        return cls(
+            source_index=_strict_integer(
+                fields["source_index"], "contact dummy source index"
+            ),
+            normalized_symbol=_strict_string(
+                fields["normalized_symbol"], "contact dummy normalized symbol"
+            ),
+            outer_slot=_strict_integer(
+                fields["outer_slot"], "contact dummy outer slot"
+            ),
+            final_slot=_strict_integer(
+                fields["final_slot"], "contact dummy final slot"
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class CompiledContactOrientationProof:
+    stage: str
+    input_legs: tuple[int, int]
+    permutation_parity: int
+    scalar_prefactor: str
+
+    def __post_init__(self) -> None:
+        if self.stage not in {"partial", "final"}:
+            raise ValueError(f"unknown contact proof orientation stage {self.stage!r}")
+        if self.permutation_parity not in {-1, 1}:
+            raise ValueError("contact orientation parity must be -1 or 1")
+        if not self.scalar_prefactor:
+            raise ValueError("contact orientation scalar prefactor must not be empty")
+        auxiliary_count = self.input_legs.count(-1)
+        if self.stage == "partial" and (
+            auxiliary_count or any(leg < 0 for leg in self.input_legs)
+        ):
+            raise ValueError("contact partial orientation requires two physical legs")
+        if self.stage == "final" and auxiliary_count != 1:
+            raise ValueError("contact final orientation requires one auxiliary leg")
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "stage": self.stage,
+            "input_legs": list(self.input_legs),
+            "permutation_parity": self.permutation_parity,
+            "scalar_prefactor": self.scalar_prefactor,
+        }
+
+    @classmethod
+    def from_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> CompiledContactOrientationProof:
+        fields = _strict_record_fields(
+            payload,
+            required={
+                "stage",
+                "input_legs",
+                "permutation_parity",
+                "scalar_prefactor",
+            },
+            context="compiled contact orientation proof",
+        )
+        return cls(
+            stage=_strict_string(fields["stage"], "contact orientation stage"),
+            input_legs=_strict_int_pair(
+                fields["input_legs"], "contact orientation input legs"
+            ),
+            permutation_parity=_strict_integer(
+                fields["permutation_parity"], "contact orientation parity"
+            ),
+            scalar_prefactor=_strict_string(
+                fields["scalar_prefactor"], "contact orientation scalar prefactor"
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class CompiledContactDecompositionSplit:
+    decomposition_kind: str
+    result_leg: int
+    pair_legs: tuple[int, int]
+    remaining_leg: int
+    outer_color_source: str
+    final_color_source: str
+    outer_color_factor: tuple[int, ...]
+    final_color_factor: tuple[int, ...]
+    dummy_index_mapping: CompiledContactDummyIndexMapping | None
+    outer_color_normalization_power: int
+    final_color_normalization_power: int
+    color_coefficient: str
+    auxiliary_color: int
+    open_legs: tuple[int, int]
+    component_axis_order: tuple[str, ...]
+    component_basis_order: tuple[int, ...]
+    component_expansion: tuple[tuple[int, int] | None, ...]
+    assignment_multiplicity: int
+    canonical_outer_parity: int
+    orientations: tuple[CompiledContactOrientationProof, ...]
+
+    def __post_init__(self) -> None:
+        if self.decomposition_kind not in {
+            "literal-color-singlet",
+            "two-structure-constants",
+        }:
+            raise ValueError(
+                f"unknown contact decomposition kind {self.decomposition_kind!r}"
+            )
+        physical_legs = (*self.pair_legs, self.remaining_leg, self.result_leg)
+        if any(leg < 0 for leg in physical_legs) or len(set(physical_legs)) != 4:
+            raise ValueError("contact decomposition must partition four physical legs")
+        if self.open_legs != tuple(sorted((self.remaining_leg, self.result_leg))):
+            raise ValueError("contact decomposition open-leg order is not canonical")
+        if self.assignment_multiplicity <= 0:
+            raise ValueError("contact assignment multiplicity must be positive")
+        if (
+            self.outer_color_normalization_power < 0
+            or self.final_color_normalization_power < 0
+        ):
+            raise ValueError("contact color normalization powers must be non-negative")
+        if self.canonical_outer_parity not in {-1, 1}:
+            raise ValueError("contact canonical outer parity must be -1 or 1")
+        if not self.color_coefficient:
+            raise ValueError("contact color coefficient must not be empty")
+        _validate_auxiliary_color(self.auxiliary_color)
+        if not self.component_basis_order or not self.component_expansion:
+            raise ValueError("contact component basis and expansion must not be empty")
+        if len(set(self.component_basis_order)) != len(self.component_basis_order):
+            raise ValueError(
+                "contact component basis order must not contain duplicates"
+            )
+        if any(
+            source < 0 or source >= len(self.component_expansion)
+            for source in self.component_basis_order
+        ):
+            raise ValueError("contact component basis source is outside the expansion")
+        for entry in self.component_expansion:
+            if entry is None:
+                continue
+            basis_index, coefficient = entry
+            if basis_index not in range(len(self.component_basis_order)):
+                raise ValueError(
+                    "contact component expansion has an absent basis index"
+                )
+            if coefficient not in {-1, 1}:
+                raise ValueError("contact component expansion coefficient must be +/-1")
+        for basis_index, source_component in enumerate(self.component_basis_order):
+            if self.component_expansion[source_component] != (basis_index, 1):
+                raise ValueError(
+                    "contact component basis order disagrees with its expansion"
+                )
+        partials = tuple(item for item in self.orientations if item.stage == "partial")
+        finals = tuple(item for item in self.orientations if item.stage == "final")
+        if not partials or not finals:
+            raise ValueError(
+                "contact decomposition requires partial and final orientations"
+            )
+        allowed_partial_orders = {self.pair_legs, tuple(reversed(self.pair_legs))}
+        if partials[0].input_legs != self.pair_legs or any(
+            item.input_legs not in allowed_partial_orders for item in partials
+        ):
+            raise ValueError(
+                "contact partial orientations disagree with the chosen pair"
+            )
+        if any(
+            tuple(leg for leg in item.input_legs if leg >= 0) != (self.remaining_leg,)
+            for item in finals
+        ):
+            raise ValueError(
+                "contact final orientations disagree with the remaining leg"
+            )
+        if self.decomposition_kind == "two-structure-constants":
+            if (
+                len(self.outer_color_factor) != 3
+                or len(self.final_color_factor) != 3
+                or self.dummy_index_mapping is None
+            ):
+                raise ValueError(
+                    "two-structure-constant contact proof requires two factors and a "
+                    "dummy mapping"
+                )
+            mapping = self.dummy_index_mapping
+            if (
+                self.outer_color_factor[mapping.outer_slot] != mapping.source_index
+                or self.final_color_factor[mapping.final_slot] != mapping.source_index
+            ):
+                raise ValueError(
+                    "contact dummy-index mapping disagrees with the chosen factors"
+                )
+        elif (
+            self.outer_color_factor
+            or self.final_color_factor
+            or self.dummy_index_mapping is not None
+        ):
+            raise ValueError(
+                "literal singlet contact proof must not contain color factors"
+            )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "decomposition_kind": self.decomposition_kind,
+            "result_leg": self.result_leg,
+            "pair_legs": list(self.pair_legs),
+            "remaining_leg": self.remaining_leg,
+            "outer_color_source": self.outer_color_source,
+            "final_color_source": self.final_color_source,
+            "outer_color_factor": list(self.outer_color_factor),
+            "final_color_factor": list(self.final_color_factor),
+            "dummy_index_mapping": (
+                None
+                if self.dummy_index_mapping is None
+                else self.dummy_index_mapping.to_dict()
+            ),
+            "outer_color_normalization_power": self.outer_color_normalization_power,
+            "final_color_normalization_power": self.final_color_normalization_power,
+            "color_coefficient": self.color_coefficient,
+            "auxiliary_color": self.auxiliary_color,
+            "open_legs": list(self.open_legs),
+            "component_axis_order": list(self.component_axis_order),
+            "component_basis_order": list(self.component_basis_order),
+            "component_expansion": [
+                None if entry is None else list(entry)
+                for entry in self.component_expansion
+            ],
+            "assignment_multiplicity": self.assignment_multiplicity,
+            "canonical_outer_parity": self.canonical_outer_parity,
+            "orientations": [item.to_dict() for item in self.orientations],
+        }
+
+    @classmethod
+    def from_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> CompiledContactDecompositionSplit:
+        fields = _strict_record_fields(
+            payload,
+            required={
+                "decomposition_kind",
+                "result_leg",
+                "pair_legs",
+                "remaining_leg",
+                "outer_color_source",
+                "final_color_source",
+                "outer_color_factor",
+                "final_color_factor",
+                "dummy_index_mapping",
+                "outer_color_normalization_power",
+                "final_color_normalization_power",
+                "color_coefficient",
+                "auxiliary_color",
+                "open_legs",
+                "component_axis_order",
+                "component_basis_order",
+                "component_expansion",
+                "assignment_multiplicity",
+                "canonical_outer_parity",
+                "orientations",
+            },
+            context="compiled contact decomposition split",
+        )
+        dummy_payload = fields["dummy_index_mapping"]
+        return cls(
+            decomposition_kind=_strict_string(
+                fields["decomposition_kind"], "contact decomposition kind"
+            ),
+            result_leg=_strict_integer(fields["result_leg"], "contact result leg"),
+            pair_legs=_strict_int_pair(fields["pair_legs"], "contact pair legs"),
+            remaining_leg=_strict_integer(
+                fields["remaining_leg"], "contact remaining leg"
+            ),
+            outer_color_source=_strict_string(
+                fields["outer_color_source"], "contact outer color source"
+            ),
+            final_color_source=_strict_string(
+                fields["final_color_source"], "contact final color source"
+            ),
+            outer_color_factor=_strict_int_tuple(
+                fields["outer_color_factor"], "contact outer color factor"
+            ),
+            final_color_factor=_strict_int_tuple(
+                fields["final_color_factor"], "contact final color factor"
+            ),
+            dummy_index_mapping=(
+                None
+                if dummy_payload is None
+                else CompiledContactDummyIndexMapping.from_dict(
+                    _strict_mapping(dummy_payload, "contact dummy-index mapping")
+                )
+            ),
+            outer_color_normalization_power=_strict_integer(
+                fields["outer_color_normalization_power"],
+                "contact outer color normalization power",
+            ),
+            final_color_normalization_power=_strict_integer(
+                fields["final_color_normalization_power"],
+                "contact final color normalization power",
+            ),
+            color_coefficient=_strict_string(
+                fields["color_coefficient"], "contact color coefficient"
+            ),
+            auxiliary_color=_strict_integer(
+                fields["auxiliary_color"], "contact auxiliary color"
+            ),
+            open_legs=_strict_int_pair(fields["open_legs"], "contact open legs"),
+            component_axis_order=_strict_string_tuple(
+                fields["component_axis_order"], "contact component axis order"
+            ),
+            component_basis_order=_strict_int_tuple(
+                fields["component_basis_order"], "contact component basis order"
+            ),
+            component_expansion=_strict_optional_int_pairs(
+                fields["component_expansion"], "contact component expansion"
+            ),
+            assignment_multiplicity=_strict_integer(
+                fields["assignment_multiplicity"], "contact assignment multiplicity"
+            ),
+            canonical_outer_parity=_strict_integer(
+                fields["canonical_outer_parity"], "contact canonical outer parity"
+            ),
+            orientations=tuple(
+                CompiledContactOrientationProof.from_dict(item)
+                for item in _strict_mappings(
+                    fields["orientations"], "contact decomposition orientations"
+                )
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class CompiledContactDecompositionProof:
+    status: str
+    algorithm: str
+    algorithm_version: int
+    term_id: int
+    vertex: str
+    particles: tuple[str, ...]
+    color_index: int
+    lorentz_index: int
+    original_color_source: str
+    normalized_color_expression: str
+    lorentz_name: str
+    original_lorentz_source: str
+    normalized_lorentz_expression: str
+    splits: tuple[CompiledContactDecompositionSplit, ...] = ()
+    unsupported_reasons: tuple[CompiledContactUnsupportedReason, ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.status not in {"proven", "unsupported"}:
+            raise ValueError(
+                f"unknown contact decomposition proof status {self.status!r}"
+            )
+        if (
+            self.algorithm != CONTACT_DECOMPOSITION_ALGORITHM
+            or self.algorithm_version != CONTACT_DECOMPOSITION_ALGORITHM_VERSION
+        ):
+            raise ValueError(
+                "unsupported contact decomposition proof algorithm: "
+                f"{self.algorithm}/v{self.algorithm_version}"
+            )
+        if not self.vertex or not self.particles:
+            raise ValueError("contact decomposition proof requires a term identity")
+        if len(self.particles) != 4:
+            raise ValueError("contact decomposition proof requires four particles")
+        result_legs = tuple(split.result_leg for split in self.splits)
+        if len(result_legs) != len(set(result_legs)):
+            raise ValueError("contact decomposition proof has duplicate result legs")
+        if self.status == "proven" and (not self.splits or self.unsupported_reasons):
+            raise ValueError("proven contact decomposition must contain only splits")
+        if self.status == "unsupported" and (
+            self.splits or not self.unsupported_reasons
+        ):
+            raise ValueError(
+                "unsupported contact decomposition must contain only reasons"
+            )
+
+    def matches(self, term: _ContactTerm) -> bool:
+        return (
+            self.term_id == term.id
+            and self.vertex == term.vertex
+            and self.particles == term.particles
+            and self.color_index == term.color_index
+            and self.lorentz_index == term.lorentz_index
+            and self.original_color_source == term.color_source
+            and self.normalized_color_expression == term.color_expression
+            and self.lorentz_name == term.lorentz_name
+            and self.original_lorentz_source == term.lorentz_source
+            and self.normalized_lorentz_expression == term.lorentz_expression
+        )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "status": self.status,
+            "algorithm": self.algorithm,
+            "algorithm_version": self.algorithm_version,
+            "term_identity": {
+                "term_id": self.term_id,
+                "vertex": self.vertex,
+                "particles": list(self.particles),
+                "color_index": self.color_index,
+                "lorentz_index": self.lorentz_index,
+                "original_color_source": self.original_color_source,
+                "normalized_color_expression": self.normalized_color_expression,
+                "lorentz_name": self.lorentz_name,
+                "original_lorentz_source": self.original_lorentz_source,
+                "normalized_lorentz_expression": self.normalized_lorentz_expression,
+            },
+            "splits": [split.to_dict() for split in self.splits],
+            "unsupported_reasons": [
+                reason.to_dict() for reason in self.unsupported_reasons
+            ],
+        }
+
+    @classmethod
+    def from_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> CompiledContactDecompositionProof:
+        fields = _strict_record_fields(
+            payload,
+            required={
+                "status",
+                "algorithm",
+                "algorithm_version",
+                "term_identity",
+                "splits",
+                "unsupported_reasons",
+            },
+            context="compiled contact decomposition proof",
+        )
+        identity = _strict_record_fields(
+            _strict_mapping(fields["term_identity"], "contact term identity"),
+            required={
+                "term_id",
+                "vertex",
+                "particles",
+                "color_index",
+                "lorentz_index",
+                "original_color_source",
+                "normalized_color_expression",
+                "lorentz_name",
+                "original_lorentz_source",
+                "normalized_lorentz_expression",
+            },
+            context="compiled contact term identity",
+        )
+        return cls(
+            status=_strict_string(fields["status"], "contact proof status"),
+            algorithm=_strict_string(fields["algorithm"], "contact proof algorithm"),
+            algorithm_version=_strict_integer(
+                fields["algorithm_version"], "contact proof algorithm version"
+            ),
+            term_id=_strict_integer(identity["term_id"], "contact proof term id"),
+            vertex=_strict_string(identity["vertex"], "contact proof vertex"),
+            particles=_strict_string_tuple(
+                identity["particles"], "contact proof particles"
+            ),
+            color_index=_strict_integer(
+                identity["color_index"], "contact proof color index"
+            ),
+            lorentz_index=_strict_integer(
+                identity["lorentz_index"], "contact proof Lorentz index"
+            ),
+            original_color_source=_strict_string(
+                identity["original_color_source"], "contact proof color source"
+            ),
+            normalized_color_expression=_strict_string(
+                identity["normalized_color_expression"],
+                "contact proof normalized color expression",
+            ),
+            lorentz_name=_strict_string(
+                identity["lorentz_name"], "contact proof Lorentz name"
+            ),
+            original_lorentz_source=_strict_string(
+                identity["original_lorentz_source"], "contact proof Lorentz source"
+            ),
+            normalized_lorentz_expression=_strict_string(
+                identity["normalized_lorentz_expression"],
+                "contact proof normalized Lorentz expression",
+            ),
+            splits=tuple(
+                CompiledContactDecompositionSplit.from_dict(item)
+                for item in _strict_mappings(fields["splits"], "contact proof splits")
+            ),
+            unsupported_reasons=tuple(
+                CompiledContactUnsupportedReason.from_dict(item)
+                for item in _strict_mappings(
+                    fields["unsupported_reasons"],
+                    "contact proof unsupported reasons",
+                )
+            ),
+        )
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class CompiledContactOrbitCertificate:
+    """Compiler proof that contact paths describe one physical assignment orbit."""
+
+    algorithm: str
+    algorithm_version: int
+    term_id: int
+    vertex: str
+    particles: tuple[str, ...]
+    color_expression: str
+    lorentz_expression: str
+    coupling_expression: str
+    evaluator_class: str
+    physical_leg_equivalence_classes: tuple[int, ...]
+    reconstruction_factor: str
+
+    def __post_init__(self) -> None:
+        if (
+            self.algorithm != CONTACT_ORBIT_ALGORITHM
+            or self.algorithm_version != CONTACT_ORBIT_ALGORITHM_VERSION
+        ):
+            raise ValueError(
+                "unsupported contact-orbit certificate algorithm: "
+                f"{self.algorithm}/v{self.algorithm_version}"
+            )
+        if self.term_id < 0 or not self.vertex:
+            raise ValueError("contact-orbit certificate requires a term identity")
+        if len(self.particles) not in {4, 5} or any(
+            not particle for particle in self.particles
+        ):
+            raise ValueError("contact-orbit certificate particles must be non-empty")
+        if self.evaluator_class not in CONTACT_ORBIT_EVALUATOR_CLASSES:
+            raise ValueError(
+                f"unsupported contact-orbit evaluator class {self.evaluator_class!r}"
+            )
+        if self.evaluator_class == CONTACT_ORBIT_EVALUATOR_CLASS and (
+            len(self.particles) != 4
+            or self.color_expression != "1"
+            or self.lorentz_expression != "1"
+        ):
+            raise ValueError(
+                "contact-orbit certificate requires literal scalar-singlet tensors"
+            )
+        if self.evaluator_class == HEFT_CONTACT_ORBIT_EVALUATOR_CLASS and (
+            not self.color_expression or not self.lorentz_expression
+        ):
+            raise ValueError("HEFT contact-orbit tensors must be non-empty")
+        if not self.coupling_expression:
+            raise ValueError(
+                "contact-orbit certificate coupling expression must not be empty"
+            )
+        classes = self.physical_leg_equivalence_classes
+        if len(classes) != len(self.particles) or any(value < 0 for value in classes):
+            raise ValueError("contact-orbit equivalence classes must be non-negative")
+        canonical: dict[str, int] = {}
+        expected = tuple(
+            canonical.setdefault(particle, len(canonical))
+            for particle in self.particles
+        )
+        if classes != expected:
+            raise ValueError(
+                "contact-orbit physical-leg equivalence classes are not canonical"
+            )
+        if self.reconstruction_factor != "1":
+            raise ValueError("contact-orbit reconstruction factor must be one")
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "algorithm": self.algorithm,
+            "algorithm_version": self.algorithm_version,
+            "term_id": self.term_id,
+            "vertex": self.vertex,
+            "particles": list(self.particles),
+            "color_expression": self.color_expression,
+            "lorentz_expression": self.lorentz_expression,
+            "coupling_expression": self.coupling_expression,
+            "evaluator_class": self.evaluator_class,
+            "physical_leg_equivalence_classes": list(
+                self.physical_leg_equivalence_classes
+            ),
+            "reconstruction_factor": self.reconstruction_factor,
+        }
+
+    @classmethod
+    def from_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> CompiledContactOrbitCertificate:
+        fields = _strict_record_fields(
+            payload,
+            required={
+                "algorithm",
+                "algorithm_version",
+                "term_id",
+                "vertex",
+                "particles",
+                "color_expression",
+                "lorentz_expression",
+                "coupling_expression",
+                "evaluator_class",
+                "physical_leg_equivalence_classes",
+                "reconstruction_factor",
+            },
+            context="compiled contact-orbit certificate",
+        )
+        particles = _strict_string_tuple(fields["particles"], "contact-orbit particles")
+        classes = _strict_int_tuple(
+            fields["physical_leg_equivalence_classes"],
+            "contact-orbit physical-leg equivalence classes",
+        )
+        if len(particles) not in {4, 5} or len(classes) != len(particles):
+            raise ValueError(
+                "contact-orbit certificate must describe four or five legs"
+            )
+        return cls(
+            algorithm=_strict_string(fields["algorithm"], "contact-orbit algorithm"),
+            algorithm_version=_strict_integer(
+                fields["algorithm_version"], "contact-orbit algorithm version"
+            ),
+            term_id=_strict_integer(fields["term_id"], "contact-orbit term ID"),
+            vertex=_strict_string(fields["vertex"], "contact-orbit vertex"),
+            particles=particles,
+            color_expression=_strict_string(
+                fields["color_expression"], "contact-orbit color expression"
+            ),
+            lorentz_expression=_strict_string(
+                fields["lorentz_expression"], "contact-orbit Lorentz expression"
+            ),
+            coupling_expression=_strict_string(
+                fields["coupling_expression"], "contact-orbit coupling expression"
+            ),
+            evaluator_class=_strict_string(
+                fields["evaluator_class"], "contact-orbit evaluator class"
+            ),
+            physical_leg_equivalence_classes=classes,
+            reconstruction_factor=_strict_string(
+                fields["reconstruction_factor"],
+                "contact-orbit reconstruction factor",
+            ),
+        )
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class CompiledContactOrbitStep:
+    """Exact physical-leg lineage for one compiler-lowered contact kernel."""
+
+    algorithm: str
+    algorithm_version: int
+    term_id: int
+    stage: str
+    result_leg: int
+    left_covered_legs: tuple[int, ...]
+    right_covered_legs: tuple[int, ...]
+    source_particle_legs: tuple[int, int, int]
+    reconstruction_factor: str
+
+    def __post_init__(self) -> None:
+        if (
+            self.algorithm != CONTACT_ORBIT_ALGORITHM
+            or self.algorithm_version != CONTACT_ORBIT_ALGORITHM_VERSION
+        ):
+            raise ValueError(
+                "unsupported contact-orbit step algorithm: "
+                f"{self.algorithm}/v{self.algorithm_version}"
+            )
+        if self.term_id < 0 or self.stage not in {"partial", "final"}:
+            raise ValueError("contact-orbit step has an invalid term or stage")
+        if self.result_leg not in range(5):
+            raise ValueError("contact-orbit result leg must address supported input")
+        if self.reconstruction_factor != "1":
+            raise ValueError("contact-orbit step reconstruction factor must be one")
+        covered = (*self.left_covered_legs, *self.right_covered_legs)
+        if (
+            not self.left_covered_legs
+            or not self.right_covered_legs
+            or any(leg not in range(5) for leg in covered)
+            or len(covered) != len(set(covered))
+        ):
+            raise ValueError("contact-orbit step has invalid covered physical legs")
+        left_source, right_source, output_source = self.source_particle_legs
+        if self.stage == "partial":
+            if (
+                len(self.left_covered_legs) != 1
+                or len(self.right_covered_legs) != 1
+                or (left_source, right_source)
+                != (self.left_covered_legs[0], self.right_covered_legs[0])
+                or output_source != -1
+                or self.result_leg in covered
+            ):
+                raise ValueError("contact-orbit partial step lineage is inconsistent")
+        else:
+            arity = len(covered) + 1
+            if (
+                arity not in {4, 5}
+                or set(covered) != (set(range(arity)) - {self.result_leg})
+                or output_source != self.result_leg
+                or any(
+                    len(side) not in {1, 2}
+                    for side in (self.left_covered_legs, self.right_covered_legs)
+                )
+            ):
+                raise ValueError("contact-orbit final step lineage is inconsistent")
+            expected_sources = tuple(
+                -1 if len(side) > 1 else side[0]
+                for side in (self.left_covered_legs, self.right_covered_legs)
+            )
+            if (left_source, right_source) != expected_sources:
+                raise ValueError("contact-orbit final source lineage is inconsistent")
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "algorithm": self.algorithm,
+            "algorithm_version": self.algorithm_version,
+            "term_id": self.term_id,
+            "stage": self.stage,
+            "result_leg": self.result_leg,
+            "left_covered_legs": list(self.left_covered_legs),
+            "right_covered_legs": list(self.right_covered_legs),
+            "source_particle_legs": list(self.source_particle_legs),
+            "reconstruction_factor": self.reconstruction_factor,
+        }
+
+    @classmethod
+    def from_dict(cls, payload: Mapping[str, object]) -> CompiledContactOrbitStep:
+        fields = _strict_record_fields(
+            payload,
+            required={
+                "algorithm",
+                "algorithm_version",
+                "term_id",
+                "stage",
+                "result_leg",
+                "left_covered_legs",
+                "right_covered_legs",
+                "source_particle_legs",
+                "reconstruction_factor",
+            },
+            context="compiled contact-orbit step",
+        )
+        source_legs = _strict_int_tuple(
+            fields["source_particle_legs"], "contact-orbit step source legs"
+        )
+        if len(source_legs) != 3:
+            raise ValueError("contact-orbit step must describe three kernel slots")
+        return cls(
+            algorithm=_strict_string(fields["algorithm"], "contact-orbit algorithm"),
+            algorithm_version=_strict_integer(
+                fields["algorithm_version"], "contact-orbit algorithm version"
+            ),
+            term_id=_strict_integer(fields["term_id"], "contact-orbit term ID"),
+            stage=_strict_string(fields["stage"], "contact-orbit stage"),
+            result_leg=_strict_integer(
+                fields["result_leg"], "contact-orbit result leg"
+            ),
+            left_covered_legs=_strict_int_tuple(
+                fields["left_covered_legs"], "contact-orbit left covered legs"
+            ),
+            right_covered_legs=_strict_int_tuple(
+                fields["right_covered_legs"], "contact-orbit right covered legs"
+            ),
+            source_particle_legs=(source_legs[0], source_legs[1], source_legs[2]),
+            reconstruction_factor=_strict_string(
+                fields["reconstruction_factor"],
+                "contact-orbit reconstruction factor",
+            ),
+        )
+
+
+def canonical_contact_orbit_steps(
+    *groups: tuple[CompiledContactOrbitStep, ...],
+) -> tuple[CompiledContactOrbitStep, ...]:
+    """Return the deterministic union carried by one retained compiler kernel."""
+
+    return tuple(sorted({step for group in groups for step in group}))
+
+
+def compiled_contact_orbit_step(
+    certificate: CompiledContactOrbitCertificate,
+    split: CompiledContactDecompositionSplit,
+    orientation: CompiledContactOrientationProof,
+) -> CompiledContactOrbitStep:
+    """Derive the exact compiler lineage named by one proven orientation."""
+
+    if orientation.stage == "partial":
+        left_covered = (orientation.input_legs[0],)
+        right_covered = (orientation.input_legs[1],)
+        source_particle_legs = (
+            orientation.input_legs[0],
+            orientation.input_legs[1],
+            -1,
+        )
+    else:
+        auxiliary_on_left = orientation.input_legs[0] == -1
+        pair_legs = tuple(sorted(split.pair_legs))
+        remaining = (split.remaining_leg,)
+        left_covered, right_covered = (
+            (pair_legs, remaining) if auxiliary_on_left else (remaining, pair_legs)
+        )
+        source_particle_legs = (
+            -1 if auxiliary_on_left else split.remaining_leg,
+            split.remaining_leg if auxiliary_on_left else -1,
+            split.result_leg,
+        )
+    return CompiledContactOrbitStep(
+        algorithm=CONTACT_ORBIT_ALGORITHM,
+        algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+        term_id=certificate.term_id,
+        stage=orientation.stage,
+        result_leg=split.result_leg,
+        left_covered_legs=left_covered,
+        right_covered_legs=right_covered,
+        source_particle_legs=source_particle_legs,
+        reconstruction_factor=certificate.reconstruction_factor,
+    )
+
+
+def _validate_auxiliary_color(value: int) -> None:
+    if value not in {-3, 1, 3, 8}:
+        raise ValueError(
+            f"contact auxiliary uses unsupported UFO color representation {value}"
+        )
+
+
+def _strict_record_fields(
+    payload: Mapping[str, object],
+    *,
+    required: set[str],
+    context: str,
+) -> Mapping[str, object]:
+    fields = set(payload)
+    missing = required - fields
+    if missing:
+        names = ", ".join(sorted(missing))
+        raise ValueError(f"{context} is missing required fields: {names}")
+    unknown = fields - required
+    if unknown:
+        names = ", ".join(sorted(str(name) for name in unknown))
+        raise ValueError(f"{context} has unknown fields: {names}")
+    return payload
+
+
+def _strict_mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise TypeError(f"{context} must be a mapping")
+    return value
+
+
+def _strict_string(value: object, context: str) -> str:
+    if not isinstance(value, str):
+        raise TypeError(f"{context} must be a string")
+    return value
+
+
+def _strict_integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{context} must be an integer")
+    return value
+
+
+def _strict_values(value: object, context: str) -> tuple[object, ...]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, list | tuple):
+        raise TypeError(f"{context} must be an array")
+    return tuple(value)
+
+
+def _strict_int_tuple(value: object, context: str) -> tuple[int, ...]:
+    return tuple(
+        _strict_integer(item, f"{context} entry")
+        for item in _strict_values(value, context)
+    )
+
+
+def _strict_int_pair(value: object, context: str) -> tuple[int, int]:
+    result = _strict_int_tuple(value, context)
+    if len(result) != 2:
+        raise ValueError(f"{context} must contain two entries")
+    return result[0], result[1]
+
+
+def _strict_string_tuple(value: object, context: str) -> tuple[str, ...]:
+    return tuple(
+        _strict_string(item, f"{context} entry")
+        for item in _strict_values(value, context)
+    )
+
+
+def _strict_optional_int_pairs(
+    value: object,
+    context: str,
+) -> tuple[tuple[int, int] | None, ...]:
+    return tuple(
+        None if item is None else _strict_int_pair(item, f"{context} entry")
+        for item in _strict_values(value, context)
+    )
+
+
+def _strict_mappings(
+    value: object,
+    context: str,
+) -> tuple[Mapping[str, object], ...]:
+    return tuple(
+        _strict_mapping(item, f"{context} entry")
+        for item in _strict_values(value, context)
+    )
+
+
+__all__ = [
+    "CONTACT_DECOMPOSITION_ALGORITHM",
+    "CONTACT_DECOMPOSITION_ALGORITHM_VERSION",
+    "CompiledContactDecompositionProof",
+    "CompiledContactDecompositionSplit",
+    "CompiledContactDummyIndexMapping",
+    "CompiledContactOrientationProof",
+    "CompiledContactUnsupportedReason",
+]
diff --git a/pyamplicol/src/pyamplicol/models/contracts.py b/pyamplicol/src/pyamplicol/models/contracts.py
new file mode 100644
index 0000000000..208623f691
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/contracts.py
@@ -0,0 +1,2355 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, cast
+
+from .._internal.physics.symbols import symbols
+from ._physics_ir import (
+    TENSOR_ORDERING_CONTRACT_VERSION,
+    CompiledCurrentOrderingRecord,
+    ContractionIR,
+    TensorAxisIR,
+    TensorIndexBindingIR,
+    TensorOrderingIR,
+)
+from .base import QuantumNumberFlow
+from .contact_decomposition import (
+    CONTACT_ORBIT_EVALUATOR_CLASS,
+    HEFT_CONTACT_ORBIT_EVALUATOR_CLASS,
+    CompiledContactDecompositionProof,
+    CompiledContactDecompositionSplit,
+    CompiledContactDummyIndexMapping,
+    CompiledContactOrbitCertificate,
+    CompiledContactOrbitStep,
+    CompiledContactOrientationProof,
+    CompiledContactUnsupportedReason,
+    compiled_contact_orbit_step,
+    contact_orbit_evaluator_class_is_certifiable,
+)
+
+PROPAGATOR_SOURCE_FIELD = "pyamplicol_source"
+DEFAULT_FEYNMAN_PROPAGATOR_SOURCE = "default-feynman"
+MODEL_SUPPLIED_PROPAGATOR_SOURCE = "model-supplied"
+
+SUPPORTED_COLOR_REPRESENTATIONS = frozenset({-3, 1, 3, 8})
+
+_CANONICAL_COMPONENT_DIMENSIONS = {-1: 1, 1: 1, 2: 4, 3: 4, 5: 16}
+
+
+def validate_color_representation(value: int, *, context: str = "particle") -> int:
+    representation = int(value)
+    if representation not in SUPPORTED_COLOR_REPRESENTATIONS:
+        raise ValueError(
+            f"{context} uses unsupported UFO color representation {representation}"
+        )
+    return representation
+
+
+def validate_quantum_number_flow(
+    value: object,
+    *,
+    context: str = "particle",
+) -> QuantumNumberFlow:
+    if not isinstance(value, list | tuple):
+        raise ValueError(f"{context} quantum numbers must be a sequence")
+    result: list[tuple[str, str]] = []
+    for item in value:
+        if not isinstance(item, list | tuple) or len(item) != 2:
+            raise ValueError(
+                f"{context} quantum-number entries must be [name, expression] pairs"
+            )
+        name, expression = item
+        if not isinstance(name, str) or not name:
+            raise ValueError(
+                f"{context} quantum-number names must be non-empty strings"
+            )
+        if not isinstance(expression, str) or not expression:
+            raise ValueError(
+                f"{context} quantum-number expressions must be non-empty strings"
+            )
+        _constant_quantum_number_expression(
+            expression,
+            context=f"{context} quantum number {name!r}",
+        )
+        result.append((name, expression))
+
+    names = tuple(name for name, _expression in result)
+    if names != tuple(sorted(set(names))):
+        raise ValueError(f"{context} quantum-number names must be sorted and unique")
+    return tuple(result)
+
+
+def _constant_quantum_number_expression(
+    expression: str,
+    *,
+    context: str,
+) -> Any:
+    from . import compiler_symbolica as _sym
+
+    _sym._ensure_symbolica()
+    try:
+        parsed = _sym.E(expression)
+    except Exception as exc:
+        raise ValueError(f"{context} is not a valid Symbolica expression") from exc
+    # Symbolica may expose built-in constants such as pi or the Euler constant
+    # through get_all_symbols(), so use its semantic constant predicate rather
+    # than treating every reported symbol as a free model variable.
+    if not parsed.is_constant():
+        raise ValueError(f"{context} must be symbol-free")
+    if not parsed.is_real():
+        raise ValueError(f"{context} must be real")
+    if not parsed.is_finite():
+        raise ValueError(f"{context} must be a finite real constant")
+    return parsed
+
+
+@dataclass(frozen=True)
+class CompiledCouplingOrder:
+    name: str
+    expansion_order: int
+    hierarchy: int
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "name": self.name,
+            "expansion_order": self.expansion_order,
+            "hierarchy": self.hierarchy,
+        }
+
+
+@dataclass(frozen=True)
+class CompiledParameterRecord:
+    name: str
+    nature: str
+    parameter_type: str
+    value: tuple[float, float] | None
+    expression: str | None
+    resolved_expression: str
+    lhablock: str | None
+    lhacode: tuple[int, ...]
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "name": self.name,
+            "nature": self.nature,
+            "parameter_type": self.parameter_type,
+            "value": None if self.value is None else list(self.value),
+            "expression": self.expression,
+            "resolved_expression": self.resolved_expression,
+            "lhablock": self.lhablock,
+            "lhacode": list(self.lhacode),
+        }
+
+
+@dataclass(frozen=True)
+class CompiledParticleRecord:
+    name: str
+    antiname: str
+    pdg_code: int
+    spin: int
+    color: int
+    mass: str
+    width: str
+    charge: float
+    quantum_numbers: QuantumNumberFlow
+    ghost_number: int
+    propagating: bool
+    goldstoneboson: bool
+    propagator: str | None
+    component_dimension: int | None = None
+    auxiliary_kind: str | None = None
+    statistics: str = ""
+    wavefunction_family: str = ""
+    color_role: str = ""
+    self_conjugate: bool | None = None
+    source_orientation: str = ""
+
+    def __post_init__(self) -> None:
+        if self.component_dimension is not None:
+            if isinstance(self.component_dimension, bool) or not isinstance(
+                self.component_dimension, int
+            ):
+                raise TypeError(
+                    f"particle {self.name!r} component dimension must be an integer"
+                )
+            if self.component_dimension <= 0:
+                raise ValueError(
+                    f"particle {self.name!r} component dimension must be positive"
+                )
+        if not math.isfinite(float(self.charge)):
+            raise ValueError(f"particle {self.name!r} charge must be finite")
+        quantum_numbers = validate_quantum_number_flow(
+            self.quantum_numbers,
+            context=f"particle {self.name!r}",
+        )
+        if not any(name == "electric_charge" for name, _ in quantum_numbers):
+            raise ValueError(
+                f"particle {self.name!r} must declare exact electric_charge metadata"
+            )
+        object.__setattr__(
+            self,
+            "quantum_numbers",
+            quantum_numbers,
+        )
+        derived = _particle_role_metadata(self)
+        for field_name, expected in derived.items():
+            supplied = getattr(self, field_name)
+            if supplied in {"", None}:
+                object.__setattr__(self, field_name, expected)
+            elif supplied != expected:
+                raise ValueError(
+                    f"particle {self.name!r} has inconsistent {field_name}: "
+                    f"{supplied!r}, expected {expected!r}"
+                )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "name": self.name,
+            "antiname": self.antiname,
+            "pdg_code": self.pdg_code,
+            "spin": self.spin,
+            "color": self.color,
+            "mass": self.mass,
+            "width": self.width,
+            "charge": self.charge,
+            "quantum_numbers": [list(item) for item in self.quantum_numbers],
+            "ghost_number": self.ghost_number,
+            "propagating": self.propagating,
+            "goldstoneboson": self.goldstoneboson,
+            "propagator": self.propagator,
+            "component_dimension": self.component_dimension,
+            "auxiliary_kind": self.auxiliary_kind,
+            "statistics": self.statistics,
+            "wavefunction_family": self.wavefunction_family,
+            "color_role": self.color_role,
+            "self_conjugate": self.self_conjugate,
+            "source_orientation": self.source_orientation,
+        }
+
+
+def compiled_particle_component_dimension(
+    particle: CompiledParticleRecord,
+) -> int:
+    if particle.component_dimension is not None:
+        return particle.component_dimension
+    try:
+        return _CANONICAL_COMPONENT_DIMENSIONS[particle.spin]
+    except KeyError as exc:
+        raise ValueError(
+            f"particle {particle.name!r} has unsupported UFO spin code {particle.spin}"
+        ) from exc
+
+
+def _particle_role_metadata(particle: CompiledParticleRecord) -> dict[str, object]:
+    representation = validate_color_representation(
+        particle.color,
+        context=f"particle {particle.name!r}",
+    )
+    if particle.ghost_number != 0:
+        statistics = "ghost"
+    elif particle.auxiliary_kind is not None or particle.spin < 0:
+        statistics = "auxiliary"
+    elif particle.spin % 2 == 0:
+        statistics = "fermion"
+    else:
+        statistics = "boson"
+
+    if statistics == "fermion":
+        wavefunction_family = "fermion"
+    elif particle.spin == 1:
+        wavefunction_family = "scalar"
+    elif particle.spin == 3:
+        wavefunction_family = "vector"
+    elif particle.spin == 5:
+        wavefunction_family = "spin2"
+    elif statistics == "ghost":
+        wavefunction_family = "ghost"
+    else:
+        wavefunction_family = "auxiliary"
+
+    color_role = {
+        -3: "antifundamental",
+        1: "singlet",
+        3: "fundamental",
+        8: "adjoint",
+    }[representation]
+    self_conjugate = particle.name == particle.antiname
+    if self_conjugate:
+        source_orientation = "self-conjugate"
+    elif particle.pdg_code > 0:
+        source_orientation = "particle"
+    elif particle.pdg_code < 0:
+        source_orientation = "antiparticle"
+    else:
+        raise ValueError(
+            f"non-self-conjugate particle {particle.name!r} cannot use PDG code zero"
+        )
+    return {
+        "statistics": statistics,
+        "wavefunction_family": wavefunction_family,
+        "color_role": color_role,
+        "self_conjugate": self_conjugate,
+        "source_orientation": source_orientation,
+    }
+
+
+def _resolved_mass_expression(
+    particle: CompiledParticleRecord,
+    parameters: Mapping[str, CompiledParameterRecord],
+) -> str:
+    if particle.mass.upper() == "ZERO":
+        return "0"
+    try:
+        return parameters[particle.mass].resolved_expression
+    except KeyError as exc:
+        raise ValueError(
+            f"particle {particle.name!r} refers to absent mass parameter "
+            f"{particle.mass!r}"
+        ) from exc
+
+
+def _goldstone_vector_quantum_contract_matches(
+    goldstone: CompiledParticleRecord,
+    vector: CompiledParticleRecord,
+    parameters: Mapping[str, CompiledParameterRecord],
+) -> bool:
+    return (
+        vector.spin == 3
+        and vector.wavefunction_family == "vector"
+        and vector.propagating
+        and not vector.goldstoneboson
+        and vector.color == goldstone.color
+        and vector.quantum_numbers == goldstone.quantum_numbers
+        and _resolved_mass_expression(vector, parameters)
+        == _resolved_mass_expression(goldstone, parameters)
+    )
+
+
+@dataclass(frozen=True)
+class CompiledCouplingRecord:
+    name: str
+    expression: str
+    resolved_expression: str
+    value: tuple[float, float] | None
+    orders: tuple[tuple[str, int], ...]
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "name": self.name,
+            "expression": self.expression,
+            "resolved_expression": self.resolved_expression,
+            "value": None if self.value is None else list(self.value),
+            "orders": [[name, value] for name, value in self.orders],
+        }
+
+
+@dataclass(frozen=True)
+class CompiledPropagatorRecord:
+    name: str
+    particle: str
+    numerator: str
+    denominator: str
+    custom: bool
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "name": self.name,
+            "particle": self.particle,
+            "numerator": self.numerator,
+            "denominator": self.denominator,
+            "custom": self.custom,
+        }
+
+
+@dataclass(frozen=True)
+class CompiledGoldstonePartnerRecord:
+    """Compiler-owned disposition of one UFO-declared Goldstone mode."""
+
+    goldstone: str
+    vector: str | None
+    policy: str
+    mass_expression: str
+    association_basis: str = (
+        "ufo-goldstone+spin+color+quantum-numbers+resolved-mass+propagator-v1"
+    )
+
+    def __post_init__(self) -> None:
+        if self.policy not in {"absorbed", "explicit", "model-supplied"}:
+            raise ValueError(f"invalid compiled Goldstone policy {self.policy!r}")
+        if not self.goldstone or not self.mass_expression or not self.association_basis:
+            raise ValueError("compiled Goldstone metadata must not be empty")
+        if self.policy == "explicit" and self.vector is not None:
+            raise ValueError("an explicit Goldstone mode cannot name a vector partner")
+        if self.policy != "explicit" and not self.vector:
+            raise ValueError(
+                f"a {self.policy} Goldstone mode must name its vector partner"
+            )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "goldstone": self.goldstone,
+            "vector": self.vector,
+            "policy": self.policy,
+            "mass_expression": self.mass_expression,
+            "association_basis": self.association_basis,
+        }
+
+    @classmethod
+    def from_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> CompiledGoldstonePartnerRecord:
+        fields = _strict_record_fields(
+            payload,
+            required={
+                "goldstone",
+                "vector",
+                "policy",
+                "mass_expression",
+                "association_basis",
+            },
+            context="compiled Goldstone partner",
+        )
+        vector_value = fields["vector"]
+        if vector_value is not None and not isinstance(vector_value, str):
+            raise TypeError("compiled Goldstone vector must be a string or null")
+        return cls(
+            goldstone=_strict_string(fields["goldstone"], "goldstone"),
+            vector=vector_value,
+            policy=_strict_string(fields["policy"], "policy"),
+            mass_expression=_strict_string(
+                fields["mass_expression"], "mass expression"
+            ),
+            association_basis=_strict_string(
+                fields["association_basis"], "association basis"
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class CompiledVertexTerm:
+    id: int
+    vertex: str
+    particles: tuple[str, ...]
+    color_index: int
+    lorentz_index: int
+    color_source: str
+    color_expression: str
+    lorentz_name: str
+    lorentz_source: str
+    lorentz_expression: str
+    coupling: str
+    coupling_expression: str
+    coupling_orders: tuple[tuple[str, int], ...]
+    backend: str = "ufo"
+    lc_color_normalization_power: int = 0
+    contact_decomposition_proof: CompiledContactDecompositionProof | None = None
+    contact_orbit_certificate: CompiledContactOrbitCertificate | None = None
+    source_ordering_ids: tuple[str, ...] = ()
+    index_bindings: tuple[TensorIndexBindingIR, ...] = ()
+
+    @property
+    def valence(self) -> int:
+        return len(self.particles)
+
+    def to_dict(self) -> dict[str, object]:
+        payload: dict[str, object] = {
+            "id": self.id,
+            "vertex": self.vertex,
+            "particles": list(self.particles),
+            "valence": self.valence,
+            "color_index": self.color_index,
+            "lorentz_index": self.lorentz_index,
+            "color_source": self.color_source,
+            "color_expression": self.color_expression,
+            "lorentz_name": self.lorentz_name,
+            "lorentz_source": self.lorentz_source,
+            "lorentz_expression": self.lorentz_expression,
+            "coupling": self.coupling,
+            "coupling_expression": self.coupling_expression,
+            "coupling_orders": [[name, value] for name, value in self.coupling_orders],
+            "backend": self.backend,
+            "lc_color_normalization_power": self.lc_color_normalization_power,
+            "source_ordering_ids": list(self.source_ordering_ids),
+            "index_bindings": [item.to_json_dict() for item in self.index_bindings],
+        }
+        if self.contact_decomposition_proof is not None:
+            payload["contact_decomposition_proof"] = (
+                self.contact_decomposition_proof.to_dict()
+            )
+        payload["contact_orbit_certificate"] = (
+            None
+            if self.contact_orbit_certificate is None
+            else self.contact_orbit_certificate.to_dict()
+        )
+        return payload
+
+
+@dataclass(frozen=True)
+class CompiledLCColorTransitionTerm:
+    """Compiler-certified executable term for an LC color-state transition."""
+
+    input_permutation: tuple[int, int]
+    reverse_parent_mask: int
+    component_operation: str
+    result_component_kind: str | None
+    result_component_role: str
+    input_shape_kinds: tuple[str, str]
+    result_shape_kind: str | None
+    exact_factor_expression: str
+    proof_digest: str
+    provenance: tuple[tuple[str, str], ...] = ()
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.input_permutation, tuple) or any(
+            isinstance(value, bool) or not isinstance(value, int)
+            for value in self.input_permutation
+        ):
+            raise TypeError("compiled LC color input permutation must be integer tuple")
+        if self.input_permutation not in {(0, 1), (1, 0)}:
+            raise ValueError(
+                "compiled LC color input permutation must be (0, 1) or (1, 0)"
+            )
+        if isinstance(self.reverse_parent_mask, bool) or not isinstance(
+            self.reverse_parent_mask, int
+        ):
+            raise TypeError("compiled LC color reverse-parent mask must be an integer")
+        if self.reverse_parent_mask not in range(4):
+            raise ValueError(
+                "compiled LC color reverse-parent mask must fit two inputs"
+            )
+
+        supported_operations = {
+            "concatenate-join",
+            "concatenate-keep",
+            "inherit-left",
+            "inherit-right",
+            "empty",
+            "close",
+        }
+        if not isinstance(self.component_operation, str):
+            raise TypeError("compiled LC color component operation must be a string")
+        if self.component_operation not in supported_operations:
+            raise ValueError(
+                "unsupported compiled LC color component operation "
+                f"{self.component_operation!r}"
+            )
+
+        supported_component_kinds = {"open-string", "adjoint-segment", "trace"}
+        if self.result_component_kind is not None and not isinstance(
+            self.result_component_kind, str
+        ):
+            raise TypeError(
+                "compiled LC color result component kind must be a string or null"
+            )
+        if self.result_component_kind is not None and (
+            self.result_component_kind not in supported_component_kinds
+        ):
+            raise ValueError("unsupported compiled LC color result component kind")
+        if self.result_component_role not in {"active", "passive", "none"}:
+            raise ValueError("unsupported compiled LC color result component role")
+        if self.component_operation == "concatenate-join":
+            if (
+                self.result_component_kind is None
+                or self.result_component_role == "none"
+            ):
+                raise ValueError(
+                    "compiled LC joins require a result kind and active/passive role"
+                )
+        elif self.component_operation == "close":
+            if self.result_component_role != "none":
+                raise ValueError(
+                    "compiled LC closures cannot declare a recurrence result component"
+                )
+        elif self.result_component_kind is not None or self.result_component_role != (
+            "active"
+            if self.component_operation in {"inherit-left", "inherit-right"}
+            else "none"
+        ):
+            raise ValueError(
+                "compiled LC non-join result role does not match its operation"
+            )
+
+        supported_shape_kinds = {
+            "singlet-forest",
+            "fundamental-open-string",
+            "antifundamental-open-string",
+            "adjoint-segment",
+        }
+        if (
+            not isinstance(self.input_shape_kinds, tuple)
+            or len(self.input_shape_kinds) != 2
+        ):
+            raise TypeError(
+                "compiled LC color input shapes must be a two-element tuple"
+            )
+        if any(not isinstance(value, str) for value in self.input_shape_kinds):
+            raise TypeError("compiled LC color input shapes must be strings")
+        if any(value not in supported_shape_kinds for value in self.input_shape_kinds):
+            raise ValueError(
+                "compiled LC color term requires two supported input shape kinds"
+            )
+        if self.result_shape_kind is not None and not isinstance(
+            self.result_shape_kind, str
+        ):
+            raise TypeError(
+                "compiled LC color result shape kind must be a string or null"
+            )
+        if self.component_operation == "close":
+            if self.result_shape_kind is not None:
+                raise ValueError(
+                    "compiled LC color closure term cannot declare a result shape"
+                )
+        elif self.result_shape_kind not in supported_shape_kinds:
+            raise ValueError(
+                "non-closure compiled LC color term requires a supported result shape"
+            )
+
+        if not isinstance(self.exact_factor_expression, str):
+            raise TypeError("compiled LC color exact factor must be a string")
+        if (
+            not self.exact_factor_expression
+            or self.exact_factor_expression != self.exact_factor_expression.strip()
+        ):
+            raise ValueError(
+                "compiled LC color exact factor must be a nonempty canonical string"
+            )
+        if not isinstance(self.proof_digest, str):
+            raise TypeError("compiled LC color proof digest must be a string")
+        if len(self.proof_digest) != 64 or any(
+            character not in "0123456789abcdef" for character in self.proof_digest
+        ):
+            raise ValueError("compiled LC color proof digest must be lowercase SHA256")
+
+        if not isinstance(self.provenance, tuple):
+            raise TypeError("compiled LC color provenance must be an immutable tuple")
+        for item in self.provenance:
+            if not isinstance(item, tuple) or len(item) != 2:
+                raise TypeError(
+                    "compiled LC color provenance entries must be key/value tuples"
+                )
+            key, value = item
+            if not isinstance(key, str) or not isinstance(value, str):
+                raise TypeError(
+                    "compiled LC color provenance keys and values must be strings"
+                )
+            if not key or not value or key != key.strip() or value != value.strip():
+                raise ValueError(
+                    "compiled LC color provenance keys and values must be nonempty "
+                    "canonical strings"
+                )
+        provenance_keys = tuple(key for key, _value in self.provenance)
+        if provenance_keys != tuple(sorted(set(provenance_keys))):
+            raise ValueError(
+                "compiled LC color provenance keys must be sorted and unique"
+            )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "component_operation": self.component_operation,
+            "exact_factor_expression": self.exact_factor_expression,
+            "input_permutation": list(self.input_permutation),
+            "input_shape_kinds": list(self.input_shape_kinds),
+            "proof_digest": self.proof_digest,
+            "provenance": [list(item) for item in self.provenance],
+            "result_component_kind": self.result_component_kind,
+            "result_component_role": self.result_component_role,
+            "result_shape_kind": self.result_shape_kind,
+            "reverse_parent_mask": self.reverse_parent_mask,
+        }
+
+    @classmethod
+    def from_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> CompiledLCColorTransitionTerm:
+        required = {
+            "component_operation",
+            "exact_factor_expression",
+            "input_permutation",
+            "input_shape_kinds",
+            "proof_digest",
+            "result_component_kind",
+            "result_shape_kind",
+            "reverse_parent_mask",
+        }
+        fields = set(payload)
+        missing = required - fields
+        if missing:
+            names = ", ".join(sorted(missing))
+            raise ValueError(
+                f"compiled LC color transition term is missing required fields: {names}"
+            )
+        unknown = fields - required - {"provenance", "result_component_role"}
+        if unknown:
+            names = ", ".join(sorted(str(name) for name in unknown))
+            raise ValueError(
+                f"compiled LC color transition term has unknown fields: {names}"
+            )
+
+        input_permutation = _required_sequence_field(
+            payload,
+            "input_permutation",
+            context="compiled LC color transition term",
+        )
+        input_shape_kinds = _required_sequence_field(
+            payload,
+            "input_shape_kinds",
+            context="compiled LC color transition term",
+        )
+        if len(input_permutation) != 2:
+            raise ValueError(
+                "compiled LC color input permutation must contain two entries"
+            )
+        if len(input_shape_kinds) != 2:
+            raise ValueError("compiled LC color input shapes must contain two entries")
+
+        provenance_value = payload.get("provenance", ())
+        if isinstance(provenance_value, (str, bytes)) or not isinstance(
+            provenance_value, list | tuple
+        ):
+            raise TypeError("compiled LC color provenance must be an array")
+        provenance: list[tuple[str, str]] = []
+        for index, item in enumerate(provenance_value):
+            if isinstance(item, (str, bytes)) or not isinstance(item, list | tuple):
+                raise TypeError(
+                    "compiled LC color provenance item "
+                    f"{index} must be a key/value array"
+                )
+            if len(item) != 2:
+                raise ValueError(
+                    "compiled LC color provenance item "
+                    f"{index} must contain two entries"
+                )
+            provenance.append(
+                (
+                    _strict_string(item[0], "compiled LC color provenance key"),
+                    _strict_string(item[1], "compiled LC color provenance value"),
+                )
+            )
+
+        result_component_kind = payload["result_component_kind"]
+        if result_component_kind is not None and not isinstance(
+            result_component_kind, str
+        ):
+            raise TypeError(
+                "compiled LC color result component kind must be a string or null"
+            )
+        result_shape_kind = payload["result_shape_kind"]
+        if result_shape_kind is not None and not isinstance(result_shape_kind, str):
+            raise TypeError(
+                "compiled LC color result shape kind must be a string or null"
+            )
+        result_component_role = payload.get("result_component_role")
+        if result_component_role is None:
+            operation = payload["component_operation"]
+            result_component_role = (
+                "passive"
+                if operation == "concatenate-join"
+                and result_shape_kind == "singlet-forest"
+                else "active"
+                if operation in {"concatenate-join", "inherit-left", "inherit-right"}
+                else "none"
+            )
+        return cls(
+            input_permutation=(
+                _strict_integer(
+                    input_permutation[0], "compiled LC color input permutation"
+                ),
+                _strict_integer(
+                    input_permutation[1], "compiled LC color input permutation"
+                ),
+            ),
+            reverse_parent_mask=_strict_integer(
+                payload["reverse_parent_mask"],
+                "compiled LC color reverse-parent mask",
+            ),
+            component_operation=_strict_string(
+                payload["component_operation"],
+                "compiled LC color component operation",
+            ),
+            result_component_kind=result_component_kind,
+            result_component_role=_strict_string(
+                result_component_role,
+                "compiled LC color result component role",
+            ),
+            input_shape_kinds=(
+                _strict_string(input_shape_kinds[0], "compiled LC color input shape"),
+                _strict_string(input_shape_kinds[1], "compiled LC color input shape"),
+            ),
+            result_shape_kind=result_shape_kind,
+            exact_factor_expression=_strict_string(
+                payload["exact_factor_expression"],
+                "compiled LC color exact factor",
+            ),
+            proof_digest=_strict_string(
+                payload["proof_digest"], "compiled LC color proof digest"
+            ),
+            provenance=tuple(provenance),
+        )
+
+
+@dataclass(frozen=True)
+class CompiledOrientedKernel:
+    kind: int
+    term_id: int
+    vertex: str
+    particles: tuple[str, str, str]
+    source_particle_legs: tuple[int, int, int]
+    component_expressions: tuple[str, ...]
+    coupling_expression: str
+    coupling_orders: tuple[tuple[str, int], ...]
+    runtime_parameters: tuple[str, ...]
+    color_source: str
+    color_expression: str
+    color_projection_structure: str | None = None
+    color_projection_coefficient: tuple[float, float] | None = None
+    lc_color_normalization_power: int = 0
+    term_ids: tuple[int, ...] = ()
+    evaluation_class: str = ""
+    evaluation_factor: tuple[float, float] = (1.0, 0.0)
+    evaluation_input_order: tuple[int, int] = (0, 1)
+    evaluation_input_exchange_factor: tuple[float, float] | None = None
+    evaluation_equivalence_verified: bool = False
+    input_ordering_ids: tuple[str, ...] = ()
+    output_ordering_id: str = ""
+    lc_recurrence_color_rule_kind: str | None = None
+    lc_color_transition_terms: tuple[CompiledLCColorTransitionTerm, ...] = ()
+    lc_color_closure_terms: tuple[CompiledLCColorTransitionTerm, ...] = ()
+    contact_orbit_steps: tuple[CompiledContactOrbitStep, ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.contact_orbit_steps != tuple(sorted(set(self.contact_orbit_steps))):
+            raise ValueError("compiled contact-orbit steps must be sorted and unique")
+        if self.lc_recurrence_color_rule_kind is not None and (
+            not isinstance(self.lc_recurrence_color_rule_kind, str)
+            or not self.lc_recurrence_color_rule_kind
+        ):
+            raise ValueError(
+                "compiled oriented-kernel recurrence color rule must be a "
+                "nonempty string"
+            )
+        compiler_closure_terms = getattr(
+            self.lc_color_transition_terms,
+            "compiler_closure_terms",
+            None,
+        )
+        if compiler_closure_terms is not None:
+            compiler_closure_terms = tuple(compiler_closure_terms)
+            if self.lc_color_closure_terms and (
+                self.lc_color_closure_terms != compiler_closure_terms
+            ):
+                raise ValueError(
+                    "compiled oriented-kernel LC closure terms conflict with "
+                    "compiler-owned closure companions"
+                )
+            object.__setattr__(
+                self,
+                "lc_color_transition_terms",
+                tuple(self.lc_color_transition_terms),
+            )
+            object.__setattr__(
+                self,
+                "lc_color_closure_terms",
+                compiler_closure_terms,
+            )
+        if not isinstance(self.lc_color_transition_terms, tuple):
+            raise TypeError(
+                "compiled oriented-kernel LC color transition terms must be a tuple"
+            )
+        if any(
+            not isinstance(item, CompiledLCColorTransitionTerm)
+            for item in self.lc_color_transition_terms
+        ):
+            raise TypeError(
+                "compiled oriented-kernel LC color transition terms must contain "
+                "typed records"
+            )
+        if not isinstance(self.lc_color_closure_terms, tuple):
+            raise TypeError(
+                "compiled oriented-kernel LC color closure terms must be a tuple"
+            )
+        if any(
+            not isinstance(item, CompiledLCColorTransitionTerm)
+            for item in self.lc_color_closure_terms
+        ):
+            raise TypeError(
+                "compiled oriented-kernel LC color closure terms must contain "
+                "typed records"
+            )
+        if any(
+            item.component_operation == "close"
+            for item in self.lc_color_transition_terms
+        ):
+            raise ValueError(
+                "compiled oriented-kernel LC transition terms cannot contain "
+                "closure operations"
+            )
+        if any(
+            item.component_operation != "close" for item in self.lc_color_closure_terms
+        ):
+            raise ValueError(
+                "compiled oriented-kernel LC closure terms must contain only "
+                "closure operations"
+            )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "kind": self.kind,
+            "term_id": self.term_id,
+            "vertex": self.vertex,
+            "particles": list(self.particles),
+            "source_particle_legs": list(self.source_particle_legs),
+            "component_expressions": list(self.component_expressions),
+            "coupling_expression": self.coupling_expression,
+            "coupling_orders": [[name, value] for name, value in self.coupling_orders],
+            "runtime_parameters": list(self.runtime_parameters),
+            "color_source": self.color_source,
+            "color_expression": self.color_expression,
+            "color_projection_structure": self.color_projection_structure,
+            "color_projection_coefficient": (
+                None
+                if self.color_projection_coefficient is None
+                else list(self.color_projection_coefficient)
+            ),
+            "lc_color_normalization_power": self.lc_color_normalization_power,
+            "term_ids": list(self.term_ids or (self.term_id,)),
+            "evaluation_class": self.evaluation_class,
+            "evaluation_factor": list(self.evaluation_factor),
+            "evaluation_input_order": list(self.evaluation_input_order),
+            "evaluation_input_exchange_factor": (
+                None
+                if self.evaluation_input_exchange_factor is None
+                else list(self.evaluation_input_exchange_factor)
+            ),
+            "evaluation_equivalence_verified": (self.evaluation_equivalence_verified),
+            "input_ordering_ids": list(self.input_ordering_ids),
+            "output_ordering_id": self.output_ordering_id,
+            "lc_recurrence_color_rule_kind": self.lc_recurrence_color_rule_kind,
+            "lc_color_transition_terms": [
+                item.to_dict() for item in self.lc_color_transition_terms
+            ],
+            "lc_color_closure_terms": [
+                item.to_dict() for item in self.lc_color_closure_terms
+            ],
+            "contact_orbit_steps": [
+                step.to_dict() for step in self.contact_orbit_steps
+            ],
+        }
+
+
+@dataclass(frozen=True)
+class _ContactTreeNode:
+    legs: tuple[int, ...]
+    particle: CompiledParticleRecord
+    physical_leg: int | None = None
+    left: _ContactTreeNode | None = None
+    right: _ContactTreeNode | None = None
+
+    @property
+    def is_leaf(self) -> bool:
+        return self.physical_leg is not None
+
+
+@dataclass(frozen=True)
+class CompiledDirectContractionRecord:
+    left_particle: str
+    left_chirality: int
+    right_particle: str
+    right_chirality: int
+    contraction_ir: ContractionIR
+
+    def __post_init__(self) -> None:
+        _validate_particle_selector_name(self.left_particle, "left particle")
+        _validate_particle_selector_name(self.right_particle, "right particle")
+        _validate_chirality(self.left_chirality, "left chirality")
+        _validate_chirality(self.right_chirality, "right chirality")
+        if not isinstance(self.contraction_ir, ContractionIR):
+            raise TypeError("direct contraction must contain a ContractionIR")
+
+    @property
+    def selector(self) -> tuple[str, int, str, int]:
+        return (
+            self.left_particle,
+            self.left_chirality,
+            self.right_particle,
+            self.right_chirality,
+        )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "left_particle": self.left_particle,
+            "left_chirality": self.left_chirality,
+            "right_particle": self.right_particle,
+            "right_chirality": self.right_chirality,
+            "contraction_ir": self.contraction_ir.to_json_dict(),
+        }
+
+    @classmethod
+    def from_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> CompiledDirectContractionRecord:
+        fields = _strict_record_fields(
+            payload,
+            required={
+                "left_particle",
+                "left_chirality",
+                "right_particle",
+                "right_chirality",
+                "contraction_ir",
+            },
+            context="compiled direct contraction",
+        )
+        return cls(
+            left_particle=_strict_string(fields["left_particle"], "left particle"),
+            left_chirality=_strict_integer(fields["left_chirality"], "left chirality"),
+            right_particle=_strict_string(fields["right_particle"], "right particle"),
+            right_chirality=_strict_integer(
+                fields["right_chirality"], "right chirality"
+            ),
+            contraction_ir=ContractionIR.from_json_dict(
+                _strict_mapping(fields["contraction_ir"], "contraction IR")
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class CompiledClosureContractionRecord:
+    particle: str
+    chirality: int
+    contraction_ir: ContractionIR
+
+    def __post_init__(self) -> None:
+        _validate_particle_selector_name(self.particle, "particle")
+        _validate_chirality(self.chirality, "chirality")
+        if not isinstance(self.contraction_ir, ContractionIR):
+            raise TypeError("closure contraction must contain a ContractionIR")
+
+    @property
+    def selector(self) -> tuple[str, int]:
+        return self.particle, self.chirality
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "particle": self.particle,
+            "chirality": self.chirality,
+            "contraction_ir": self.contraction_ir.to_json_dict(),
+        }
+
+    @classmethod
+    def from_dict(
+        cls,
+        payload: Mapping[str, object],
+    ) -> CompiledClosureContractionRecord:
+        fields = _strict_record_fields(
+            payload,
+            required={"particle", "chirality", "contraction_ir"},
+            context="compiled closure contraction",
+        )
+        return cls(
+            particle=_strict_string(fields["particle"], "particle"),
+            chirality=_strict_integer(fields["chirality"], "chirality"),
+            contraction_ir=ContractionIR.from_json_dict(
+                _strict_mapping(fields["contraction_ir"], "contraction IR")
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class CompiledModelIR:
+    name: str
+    orders: tuple[CompiledCouplingOrder, ...]
+    parameters: tuple[CompiledParameterRecord, ...]
+    particles: tuple[CompiledParticleRecord, ...]
+    couplings: tuple[CompiledCouplingRecord, ...]
+    propagators: tuple[CompiledPropagatorRecord, ...]
+    vertex_terms: tuple[CompiledVertexTerm, ...]
+    oriented_kernels: tuple[CompiledOrientedKernel, ...]
+    direct_contractions: tuple[CompiledDirectContractionRecord, ...]
+    closure_contractions: tuple[CompiledClosureContractionRecord, ...]
+    tensor_orderings: tuple[TensorOrderingIR, ...] = ()
+    current_orderings: tuple[CompiledCurrentOrderingRecord, ...] = ()
+    goldstone_partners: tuple[CompiledGoldstonePartnerRecord, ...] = ()
+
+    def __post_init__(self) -> None:
+        self._validate_particle_identities()
+        self._validate_goldstone_partners()
+        self._validate_contractions()
+        self._validate_contact_decomposition_proofs()
+        self._validate_contact_orbit_contracts()
+        self._validate_tensor_orderings()
+        for context, expression in self._executable_expressions():
+            if "UFO::" in expression:
+                raise ValueError(
+                    f"{context} retains a process-global UFO symbol; "
+                    "regenerate it through the model symbol registry"
+                )
+
+    def _validate_particle_identities(self) -> None:
+        by_name: dict[str, CompiledParticleRecord] = {}
+        by_pdg: dict[int, CompiledParticleRecord] = {}
+        for particle in self.particles:
+            if particle.name in by_name:
+                raise ValueError(
+                    f"compiled model contains duplicate particle name {particle.name!r}"
+                )
+            if particle.pdg_code in by_pdg:
+                raise ValueError(
+                    f"compiled model contains duplicate PDG code {particle.pdg_code}"
+                )
+            by_name[particle.name] = particle
+            by_pdg[particle.pdg_code] = particle
+        for particle in self.particles:
+            anti = by_name.get(particle.antiname)
+            if anti is None:
+                raise ValueError(
+                    f"particle {particle.name!r} refers to absent antiparticle "
+                    f"{particle.antiname!r}"
+                )
+            if anti.antiname != particle.name:
+                raise ValueError(
+                    f"particle/antiparticle relation is not involutive for "
+                    f"{particle.name!r} and {anti.name!r}"
+                )
+            if anti is not particle and anti.pdg_code != -particle.pdg_code:
+                raise ValueError(
+                    f"non-self-conjugate pair {particle.name!r}/{anti.name!r} must "
+                    "use opposite signed PDG codes"
+                )
+            if anti is particle:
+                for name, expression in particle.quantum_numbers:
+                    parsed = _constant_quantum_number_expression(
+                        expression,
+                        context=(
+                            f"self-conjugate particle {particle.name!r} quantum "
+                            f"number {name!r}"
+                        ),
+                    )
+                    if parsed.to_canonical_string() != "0":
+                        raise ValueError(
+                            f"self-conjugate particle {particle.name!r} must have "
+                            f"zero quantum number {name!r}"
+                        )
+                continue
+            particle_names = tuple(name for name, _ in particle.quantum_numbers)
+            anti_names = tuple(name for name, _ in anti.quantum_numbers)
+            if particle_names != anti_names:
+                raise ValueError(
+                    f"particle/antiparticle pair {particle.name!r}/{anti.name!r} "
+                    "must declare the same quantum numbers"
+                )
+            for (name, expression), (_anti_name, anti_expression) in zip(
+                particle.quantum_numbers,
+                anti.quantum_numbers,
+                strict=True,
+            ):
+                total = _constant_quantum_number_expression(
+                    expression,
+                    context=f"particle {particle.name!r} quantum number {name!r}",
+                ) + _constant_quantum_number_expression(
+                    anti_expression,
+                    context=f"particle {anti.name!r} quantum number {name!r}",
+                )
+                if total.to_canonical_string() != "0":
+                    raise ValueError(
+                        f"particle/antiparticle pair {particle.name!r}/{anti.name!r} "
+                        f"must have exactly negated quantum number {name!r}"
+                    )
+
+    def _validate_goldstone_partners(self) -> None:
+        from .compiler_gauge import compile_goldstone_partner_records
+
+        expected = compile_goldstone_partner_records(
+            self.particles,
+            self.parameters,
+            self.propagators,
+        )
+        if self.goldstone_partners != expected:
+            raise ValueError(
+                "compiled Goldstone partner contracts are stale or non-canonical"
+            )
+
+    def _validate_contact_decomposition_proofs(self) -> None:
+        for term in self.vertex_terms:
+            proof = term.contact_decomposition_proof
+            requires_proof = (
+                term.backend == "ufo"
+                and term.valence == 4
+                and "ufo_momentum_" not in term.lorentz_expression
+            )
+            if proof is None and requires_proof:
+                raise ValueError(
+                    f"UFO four-point term {term.id} has no contact decomposition proof"
+                )
+            if proof is None:
+                continue
+            if term.valence != 4:
+                raise ValueError(
+                    f"contact decomposition proof on non-four-point term {term.id}"
+                )
+            if not proof.matches(term):
+                raise ValueError(
+                    f"contact decomposition proof identity mismatch for term {term.id}"
+                )
+
+    def _validate_contact_orbit_contracts(self) -> None:
+        particles = {particle.name: particle for particle in self.particles}
+        certificates: dict[int, CompiledContactOrbitCertificate] = {}
+        expected_steps: set[CompiledContactOrbitStep] = set()
+        heft_terms: set[int] = set()
+        for term in self.vertex_terms:
+            certificate = term.contact_orbit_certificate
+            proof = term.contact_decomposition_proof
+            source_particles = tuple(particles[name] for name in term.particles)
+            scalar_certifiable = (
+                proof is not None
+                and proof.status == "proven"
+                and proof.matches(term)
+                and contact_orbit_evaluator_class_is_certifiable(
+                    color_source=term.color_source,
+                    color_expression=term.color_expression,
+                    lorentz_expression=term.lorentz_expression,
+                    decomposition_kinds=tuple(
+                        split.decomposition_kind for split in proof.splits
+                    ),
+                    particle_contracts=tuple(
+                        (
+                            particle.spin,
+                            particle.color,
+                            particle.statistics,
+                            particle.wavefunction_family,
+                            particle.self_conjugate,
+                        )
+                        for particle in source_particles
+                    ),
+                )
+            )
+            heft_certifiable = False
+            if certificate is not None and (
+                certificate.evaluator_class == HEFT_CONTACT_ORBIT_EVALUATOR_CLASS
+            ):
+                from .compiler_contact_trees import _heft_contact_color_topology
+
+                heft_certifiable = (
+                    _heft_contact_color_topology(
+                        term,
+                        source_particles,
+                        model_symbols=symbols.model(self.name),
+                    )
+                    is not None
+                )
+            certifiable = scalar_certifiable or heft_certifiable
+            if certificate is None:
+                if scalar_certifiable:
+                    raise ValueError(
+                        f"certifiable contact term {term.id} has no orbit certificate"
+                    )
+                continue
+            if not certifiable:
+                raise ValueError(
+                    f"contact-orbit certificate for term {term.id} names an "
+                    "excluded evaluator class"
+                )
+            if (
+                certificate.term_id != term.id
+                or certificate.vertex != term.vertex
+                or certificate.particles != term.particles
+                or certificate.color_expression != term.color_expression
+                or certificate.lorentz_expression != term.lorentz_expression
+                or certificate.coupling_expression != term.coupling_expression
+            ):
+                raise ValueError(
+                    f"contact-orbit certificate identity mismatch for term {term.id}"
+                )
+            certificates[term.id] = certificate
+            if certificate.evaluator_class == CONTACT_ORBIT_EVALUATOR_CLASS:
+                assert proof is not None
+                expected_steps.update(
+                    compiled_contact_orbit_step(certificate, split, orientation)
+                    for split in proof.splits
+                    for orientation in split.orientations
+                )
+            else:
+                heft_terms.add(term.id)
+
+        actual_steps: list[CompiledContactOrbitStep] = []
+        seen_heft_terms: set[int] = set()
+        for kernel in self.oriented_kernels:
+            is_heft_kernel = "::contact-heft-tree-" in kernel.vertex
+            if is_heft_kernel:
+                if kernel.term_id not in heft_terms:
+                    raise ValueError(
+                        f"HEFT contact kernel {kernel.kind} has no authenticated term"
+                    )
+                if len(kernel.contact_orbit_steps) != 1:
+                    raise ValueError(
+                        f"HEFT contact kernel {kernel.kind} must carry one orbit step"
+                    )
+                seen_heft_terms.add(kernel.term_id)
+            for step in kernel.contact_orbit_steps:
+                if step.term_id not in certificates:
+                    raise ValueError(
+                        f"contact-orbit step on kernel {kernel.kind} has no certificate"
+                    )
+                expected_suffixes = (
+                    ("::contact-partial", "::contact-heft-tree-partial")
+                    if step.stage == "partial"
+                    else (
+                        "::contact-final",
+                        "::contact-final-fused",
+                        "::contact-heft-tree-final",
+                    )
+                )
+                if not kernel.vertex.endswith(expected_suffixes):
+                    raise ValueError(
+                        f"contact-orbit step stage mismatch for kernel {kernel.kind}"
+                    )
+                certificate = certificates[step.term_id]
+                arity = len(certificate.particles)
+                referenced_legs = {
+                    step.result_leg,
+                    *step.left_covered_legs,
+                    *step.right_covered_legs,
+                }
+                if any(leg not in range(arity) for leg in referenced_legs):
+                    raise ValueError(
+                        f"contact-orbit step on kernel {kernel.kind} exceeds term arity"
+                    )
+                if is_heft_kernel:
+                    expected_source_legs = (
+                        -1
+                        if len(step.left_covered_legs) > 1
+                        else step.left_covered_legs[0],
+                        -1
+                        if len(step.right_covered_legs) > 1
+                        else step.right_covered_legs[0],
+                        -1 if step.stage == "partial" else step.result_leg,
+                    )
+                    if kernel.source_particle_legs != expected_source_legs:
+                        raise ValueError(
+                            "HEFT contact-orbit lineage mismatch for kernel "
+                            f"{kernel.kind}"
+                        )
+                    expected_steps.add(step)
+                actual_steps.append(step)
+        if seen_heft_terms != heft_terms:
+            missing = sorted(heft_terms - seen_heft_terms)
+            unexpected = sorted(seen_heft_terms - heft_terms)
+            raise ValueError(
+                "HEFT contact-orbit certificates and lowered terms disagree: "
+                f"missing={missing}, unexpected={unexpected}"
+            )
+        if len(actual_steps) != len(set(actual_steps)):
+            raise ValueError(
+                "compiled contact-orbit lineage contains duplicate retained steps"
+            )
+        if set(actual_steps) != expected_steps:
+            raise ValueError(
+                "compiled contact-orbit lineage is incomplete after contact fusion"
+            )
+
+    def _validate_contractions(self) -> None:
+        particles = {particle.name: particle for particle in self.particles}
+        parameters = {parameter.name: parameter for parameter in self.parameters}
+        propagators = {propagator.name: propagator for propagator in self.propagators}
+        direct_selectors: set[tuple[str, int, str, int]] = set()
+        for record in self.direct_contractions:
+            if not isinstance(record, CompiledDirectContractionRecord):
+                raise TypeError(
+                    "compiled model direct contractions must contain typed records"
+                )
+            if record.selector in direct_selectors:
+                raise ValueError(
+                    f"compiled model contains duplicate direct contraction selector "
+                    f"{record.selector!r}"
+                )
+            direct_selectors.add(record.selector)
+            try:
+                left = particles[record.left_particle]
+                right = particles[record.right_particle]
+            except KeyError as exc:
+                raise ValueError(
+                    f"direct contraction refers to absent particle {exc.args[0]!r}"
+                ) from exc
+            if left.antiname != right.name or right.antiname != left.name:
+                raise ValueError(
+                    f"direct contraction particles {left.name!r}/{right.name!r} "
+                    "are not an antiparticle pair"
+                )
+            left_dimension = compiled_current_dimension(
+                left,
+                record.left_chirality,
+                parameters=parameters,
+                propagators=propagators,
+            )
+            right_dimension = compiled_current_dimension(
+                right,
+                record.right_chirality,
+                parameters=parameters,
+                propagators=propagators,
+            )
+            coefficient_count = len(record.contraction_ir.coefficients)
+            if left_dimension != right_dimension or coefficient_count != left_dimension:
+                raise ValueError(
+                    f"direct contraction selector {record.selector!r} has "
+                    f"{coefficient_count} coefficients for current dimensions "
+                    f"{left_dimension} and {right_dimension}"
+                )
+            _validate_concrete_chirality_relation(
+                record.contraction_ir,
+                record.left_chirality,
+                record.right_chirality,
+                context=f"direct contraction selector {record.selector!r}",
+            )
+
+        closure_selectors: set[tuple[str, int]] = set()
+        for record in self.closure_contractions:
+            if not isinstance(record, CompiledClosureContractionRecord):
+                raise TypeError(
+                    "compiled model closure contractions must contain typed records"
+                )
+            if record.selector in closure_selectors:
+                raise ValueError(
+                    f"compiled model contains duplicate closure contraction selector "
+                    f"{record.selector!r}"
+                )
+            closure_selectors.add(record.selector)
+            try:
+                particle = particles[record.particle]
+            except KeyError as exc:
+                raise ValueError(
+                    f"closure contraction refers to absent particle {exc.args[0]!r}"
+                ) from exc
+            dimension = compiled_current_dimension(
+                particle,
+                record.chirality,
+                parameters=parameters,
+                propagators=propagators,
+            )
+            contraction = record.contraction_ir
+            if (
+                dimension != 1
+                or len(contraction.coefficients) != 1
+                or contraction.name != "scalar"
+                or contraction.left_basis != "scalar"
+                or contraction.right_basis != "scalar"
+                or contraction.metric_signature is not None
+            ):
+                raise ValueError(
+                    f"closure contraction selector {record.selector!r} must be a "
+                    "one-component scalar projection"
+                )
+            _validate_concrete_chirality_relation(
+                contraction,
+                record.chirality,
+                record.chirality,
+                context=f"closure contraction selector {record.selector!r}",
+            )
+
+    def _validate_tensor_orderings(self) -> None:
+        orderings: dict[str, TensorOrderingIR] = {}
+        for ordering in self.tensor_orderings:
+            if not isinstance(ordering, TensorOrderingIR):
+                raise TypeError(
+                    "compiled model tensor orderings must contain TensorOrderingIR"
+                )
+            if ordering.ordering_id in orderings:
+                raise ValueError(
+                    f"compiled model contains duplicate tensor ordering "
+                    f"{ordering.ordering_id!r}"
+                )
+            orderings[ordering.ordering_id] = ordering
+
+        particles = {particle.name: particle for particle in self.particles}
+        parameters = {parameter.name: parameter for parameter in self.parameters}
+        propagators = {propagator.name: propagator for propagator in self.propagators}
+        current_orderings: dict[tuple[str, int], CompiledCurrentOrderingRecord] = {}
+        for record in self.current_orderings:
+            if not isinstance(record, CompiledCurrentOrderingRecord):
+                raise TypeError(
+                    "compiled model current orderings must contain typed records"
+                )
+            if record.selector in current_orderings:
+                raise ValueError(
+                    f"compiled model contains duplicate current ordering selector "
+                    f"{record.selector!r}"
+                )
+            current_orderings[record.selector] = record
+            try:
+                particle = particles[record.particle]
+            except KeyError as exc:
+                raise ValueError(
+                    f"current ordering refers to absent particle {record.particle!r}"
+                ) from exc
+            try:
+                ordering = orderings[record.ordering_id]
+                kernel_ordering = orderings[record.kernel_ordering_id]
+            except KeyError as exc:
+                raise ValueError(
+                    f"current ordering {record.selector!r} refers to absent tensor "
+                    f"ordering {exc.args[0]!r}"
+                ) from exc
+            expected_dimension = compiled_current_dimension(
+                particle,
+                record.chirality,
+                parameters=parameters,
+                propagators=propagators,
+            )
+            if ordering.stored_size != expected_dimension:
+                raise ValueError(
+                    f"current ordering {record.selector!r} stores "
+                    f"{ordering.stored_size} components, expected {expected_dimension}"
+                )
+            if len(record.input_embedding) != kernel_ordering.stored_size:
+                raise ValueError(
+                    f"current ordering {record.selector!r} input embedding has "
+                    "the wrong kernel size"
+                )
+            embedded = tuple(
+                value for value in record.input_embedding if value is not None
+            )
+            if sorted(embedded) != list(range(ordering.stored_size)):
+                raise ValueError(
+                    f"current ordering {record.selector!r} input embedding does not "
+                    "map every stored component exactly once"
+                )
+            if (
+                len(record.result_projection) != ordering.stored_size
+                or len(set(record.result_projection)) != ordering.stored_size
+                or any(
+                    value < 0 or value >= kernel_ordering.stored_size
+                    for value in record.result_projection
+                )
+            ):
+                raise ValueError(
+                    f"current ordering {record.selector!r} result projection is invalid"
+                )
+
+        has_external_contract = any(term.backend == "ufo" for term in self.vertex_terms)
+        if has_external_contract and (not orderings or not current_orderings):
+            raise ValueError(
+                "compiled UFO model is missing explicit tensor ordering metadata"
+            )
+        if orderings or current_orderings:
+            for particle in self.particles:
+                if (particle.name, 0) not in current_orderings:
+                    raise ValueError(
+                        f"particle {particle.name!r} has no full current ordering"
+                    )
+
+        term_by_id = {term.id: term for term in self.vertex_terms}
+        for term in self.vertex_terms:
+            if term.backend == "ufo" and len(term.source_ordering_ids) != term.valence:
+                raise ValueError(
+                    f"UFO vertex term {term.id} does not declare one source ordering "
+                    "per particle leg"
+                )
+            if term.source_ordering_ids:
+                for leg, (particle_name, ordering_id) in enumerate(
+                    zip(term.particles, term.source_ordering_ids, strict=True),
+                    start=1,
+                ):
+                    if ordering_id not in orderings:
+                        raise ValueError(
+                            f"vertex term {term.id} source leg {leg} refers to absent "
+                            f"tensor ordering {ordering_id!r}"
+                        )
+                    current = current_orderings.get((particle_name, 0))
+                    if current is None or current.kernel_ordering_id != ordering_id:
+                        raise ValueError(
+                            f"vertex term {term.id} source leg {leg} ordering does not "
+                            f"match particle {particle_name!r}"
+                        )
+            normalized_names: set[str] = set()
+            for binding in term.index_bindings:
+                if not isinstance(binding, TensorIndexBindingIR):
+                    raise TypeError(
+                        f"vertex term {term.id} index bindings must be typed records"
+                    )
+                if binding.normalized_name in normalized_names:
+                    raise ValueError(
+                        f"vertex term {term.id} repeats normalized tensor index "
+                        f"{binding.normalized_name!r}"
+                    )
+                normalized_names.add(binding.normalized_name)
+                if binding.source_leg is not None and binding.source_leg > term.valence:
+                    raise ValueError(
+                        f"vertex term {term.id} tensor index refers to absent source "
+                        f"leg {binding.source_leg}"
+                    )
+
+        for kernel in self.oriented_kernels:
+            if kernel.evaluation_input_order not in {(0, 1), (1, 0)}:
+                raise ValueError(
+                    f"oriented kernel {kernel.kind} has invalid evaluation input order"
+                )
+            exchange_factor = kernel.evaluation_input_exchange_factor
+            if exchange_factor is not None:
+                if not kernel.evaluation_equivalence_verified:
+                    raise ValueError(
+                        f"oriented kernel {kernel.kind} has an unverified input-"
+                        "exchange relation"
+                    )
+                if exchange_factor not in {(1.0, 0.0), (-1.0, 0.0)}:
+                    raise ValueError(
+                        f"oriented kernel {kernel.kind} has invalid input-exchange "
+                        "phase"
+                    )
+            if len(kernel.input_ordering_ids) != 2 or not kernel.output_ordering_id:
+                if has_external_contract:
+                    raise ValueError(
+                        f"oriented kernel {kernel.kind} is missing tensor ordering "
+                        "references"
+                    )
+                continue
+            referenced_ids = (*kernel.input_ordering_ids, kernel.output_ordering_id)
+            try:
+                for ordering_id in kernel.input_ordering_ids:
+                    orderings[ordering_id]
+                output_ordering = orderings[kernel.output_ordering_id]
+            except KeyError as exc:
+                raise ValueError(
+                    f"oriented kernel {kernel.kind} refers to absent tensor ordering "
+                    f"{exc.args[0]!r}"
+                ) from exc
+            for particle_name, ordering_id in zip(
+                kernel.particles,
+                referenced_ids,
+                strict=True,
+            ):
+                current = current_orderings.get((particle_name, 0))
+                if current is None or current.kernel_ordering_id != ordering_id:
+                    raise ValueError(
+                        f"oriented kernel {kernel.kind} ordering does not match "
+                        f"particle {particle_name!r}"
+                    )
+            if len(kernel.component_expressions) != output_ordering.stored_size:
+                raise ValueError(
+                    f"oriented kernel {kernel.kind} has "
+                    f"{len(kernel.component_expressions)} components for output "
+                    f"ordering size {output_ordering.stored_size}"
+                )
+            term = term_by_id.get(kernel.term_id)
+            if term is None:
+                raise ValueError(
+                    f"oriented kernel {kernel.kind} refers to absent term "
+                    f"{kernel.term_id}"
+                )
+            for kernel_slot, source_leg in enumerate(kernel.source_particle_legs):
+                if source_leg < 0:
+                    continue
+                if source_leg >= term.valence:
+                    raise ValueError(
+                        f"oriented kernel {kernel.kind} refers to absent source leg "
+                        f"{source_leg}"
+                    )
+                if term.source_ordering_ids[source_leg] != referenced_ids[kernel_slot]:
+                    raise ValueError(
+                        f"oriented kernel {kernel.kind} source-leg ordering disagrees "
+                        f"with vertex term {term.id}"
+                    )
+        for record in self.direct_contractions:
+            if current_orderings:
+                for particle, chirality in (
+                    (record.left_particle, record.left_chirality),
+                    (record.right_particle, record.right_chirality),
+                ):
+                    if (particle, chirality) not in current_orderings:
+                        raise ValueError(
+                            f"direct contraction selector {record.selector!r} has no "
+                            f"current ordering metadata for {(particle, chirality)!r}"
+                        )
+        for record in self.closure_contractions:
+            if current_orderings and record.selector not in current_orderings:
+                raise ValueError(
+                    f"closure contraction selector {record.selector!r} has no current "
+                    "ordering metadata"
+                )
+
+        if has_external_contract:
+            # The content IDs make each ordering internally immutable, but they do
+            # not prove that it describes this model. Recompile the complete
+            # contract from the normalized model IR and require exact equality.
+            # This also validates source index bindings and the runtime's chiral
+            # embedding/projection conventions without maintaining a second set of
+            # validation rules.
+            from .compiler_tensor_ordering import compile_tensor_ordering_metadata
+
+            (
+                expected_terms,
+                expected_kernels,
+                expected_orderings,
+                expected_current_orderings,
+            ) = compile_tensor_ordering_metadata(
+                self.vertex_terms,
+                self.particles,
+                self.oriented_kernels,
+                self.parameters,
+                self.propagators,
+            )
+            if expected_terms != self.vertex_terms:
+                raise ValueError(
+                    "compiled UFO model tensor index bindings are not canonical"
+                )
+            if expected_kernels != self.oriented_kernels:
+                raise ValueError(
+                    "compiled UFO model kernel tensor orderings are not canonical"
+                )
+            if expected_orderings != self.tensor_orderings:
+                raise ValueError(
+                    "compiled UFO model tensor orderings do not match its particles "
+                    "and contact proofs"
+                )
+            if expected_current_orderings != self.current_orderings:
+                raise ValueError(
+                    "compiled UFO model current tensor mappings are not canonical"
+                )
+
+    def _executable_expressions(self) -> tuple[tuple[str, str], ...]:
+        """Return scalar/evaluator expressions, excluding raw tensor source."""
+
+        result: list[tuple[str, str]] = []
+        for parameter in self.parameters:
+            if parameter.expression is not None:
+                result.append(
+                    (f"parameter {parameter.name} expression", parameter.expression)
+                )
+            result.append(
+                (
+                    f"parameter {parameter.name} resolved expression",
+                    parameter.resolved_expression,
+                )
+            )
+        for coupling in self.couplings:
+            result.extend(
+                (
+                    (f"coupling {coupling.name} expression", coupling.expression),
+                    (
+                        f"coupling {coupling.name} resolved expression",
+                        coupling.resolved_expression,
+                    ),
+                )
+            )
+        for term in self.vertex_terms:
+            result.append((f"vertex term {term.id} coupling", term.coupling_expression))
+        for kernel in self.oriented_kernels:
+            result.append(
+                (f"oriented kernel {kernel.kind} coupling", kernel.coupling_expression)
+            )
+            result.extend(
+                (f"oriented kernel {kernel.kind} component {index}", expression)
+                for index, expression in enumerate(kernel.component_expressions)
+            )
+        return tuple(result)
+
+    @property
+    def max_vertex_valence(self) -> int:
+        return max((term.valence for term in self.vertex_terms), default=0)
+
+    @property
+    def symbol_namespace(self) -> str:
+        return symbols.model(self.name).namespace
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "name": self.name,
+            "symbol_namespace": self.symbol_namespace,
+            "orders": [item.to_dict() for item in self.orders],
+            "parameters": [item.to_dict() for item in self.parameters],
+            "particles": [item.to_dict() for item in self.particles],
+            "couplings": [item.to_dict() for item in self.couplings],
+            "propagators": [item.to_dict() for item in self.propagators],
+            "vertex_terms": [item.to_dict() for item in self.vertex_terms],
+            "oriented_kernels": [item.to_dict() for item in self.oriented_kernels],
+            "direct_contractions": [
+                item.to_dict() for item in self.direct_contractions
+            ],
+            "closure_contractions": [
+                item.to_dict() for item in self.closure_contractions
+            ],
+            "tensor_orderings": [item.to_json_dict() for item in self.tensor_orderings],
+            "current_orderings": [
+                item.to_json_dict() for item in self.current_orderings
+            ],
+            "goldstone_partners": [item.to_dict() for item in self.goldstone_partners],
+            "max_vertex_valence": self.max_vertex_valence,
+        }
+
+    @staticmethod
+    def from_dict(payload: Mapping[str, object]) -> CompiledModelIR:
+        name = str(payload["name"])
+        expected_namespace = symbols.model(name).namespace
+        if payload.get("symbol_namespace") != expected_namespace:
+            raise ValueError(
+                "compiled model symbol namespace mismatch; regenerate the model"
+            )
+        return CompiledModelIR(
+            name=name,
+            orders=tuple(
+                CompiledCouplingOrder(
+                    name=str(item["name"]),
+                    expansion_order=_integer(item["expansion_order"]),
+                    hierarchy=_integer(item["hierarchy"]),
+                )
+                for item in _mappings(payload.get("orders"))
+            ),
+            parameters=tuple(
+                CompiledParameterRecord(
+                    name=str(item["name"]),
+                    nature=str(item["nature"]),
+                    parameter_type=str(item["parameter_type"]),
+                    value=_optional_pair(item.get("value")),
+                    expression=_optional_string(item.get("expression")),
+                    resolved_expression=str(item["resolved_expression"]),
+                    lhablock=_optional_string(item.get("lhablock")),
+                    lhacode=tuple(
+                        _integer(value) for value in _sequence(item.get("lhacode"))
+                    ),
+                )
+                for item in _mappings(payload.get("parameters"))
+            ),
+            particles=tuple(
+                CompiledParticleRecord(
+                    name=str(item["name"]),
+                    antiname=str(item["antiname"]),
+                    pdg_code=_integer(item["pdg_code"]),
+                    spin=_integer(item["spin"]),
+                    color=_integer(item["color"]),
+                    mass=str(item["mass"]),
+                    width=str(item["width"]),
+                    charge=_floating(item["charge"]),
+                    quantum_numbers=validate_quantum_number_flow(
+                        item["quantum_numbers"],
+                        context=f"particle {str(item['name'])!r}",
+                    ),
+                    ghost_number=_integer(item["ghost_number"]),
+                    propagating=bool(item["propagating"]),
+                    goldstoneboson=bool(item["goldstoneboson"]),
+                    propagator=_optional_string(item.get("propagator")),
+                    component_dimension=cast(
+                        int | None, item.get("component_dimension")
+                    ),
+                    auxiliary_kind=_optional_string(item.get("auxiliary_kind")),
+                    statistics=str(item.get("statistics", "")),
+                    wavefunction_family=str(item.get("wavefunction_family", "")),
+                    color_role=str(item.get("color_role", "")),
+                    self_conjugate=(
+                        None
+                        if item.get("self_conjugate") is None
+                        else bool(item["self_conjugate"])
+                    ),
+                    source_orientation=str(item.get("source_orientation", "")),
+                )
+                for item in _mappings(payload.get("particles"))
+            ),
+            couplings=tuple(
+                CompiledCouplingRecord(
+                    name=str(item["name"]),
+                    expression=str(item["expression"]),
+                    resolved_expression=str(item["resolved_expression"]),
+                    value=_optional_pair(item.get("value")),
+                    orders=_orders(item.get("orders")),
+                )
+                for item in _mappings(payload.get("couplings"))
+            ),
+            propagators=tuple(
+                CompiledPropagatorRecord(
+                    name=str(item["name"]),
+                    particle=str(item["particle"]),
+                    numerator=str(item["numerator"]),
+                    denominator=str(item["denominator"]),
+                    custom=bool(item["custom"]),
+                )
+                for item in _mappings(payload.get("propagators"))
+            ),
+            vertex_terms=tuple(
+                CompiledVertexTerm(
+                    id=_integer(item["id"]),
+                    vertex=str(item["vertex"]),
+                    particles=tuple(
+                        str(value) for value in _sequence(item["particles"])
+                    ),
+                    color_index=_integer(item["color_index"]),
+                    lorentz_index=_integer(item["lorentz_index"]),
+                    color_source=str(item["color_source"]),
+                    color_expression=str(item["color_expression"]),
+                    lorentz_name=str(item["lorentz_name"]),
+                    lorentz_source=str(item["lorentz_source"]),
+                    lorentz_expression=str(item["lorentz_expression"]),
+                    coupling=str(item["coupling"]),
+                    coupling_expression=str(item["coupling_expression"]),
+                    coupling_orders=_orders(item.get("coupling_orders")),
+                    backend=str(item.get("backend", "ufo")),
+                    lc_color_normalization_power=_integer(
+                        item.get("lc_color_normalization_power", 0)
+                    ),
+                    contact_decomposition_proof=(
+                        None
+                        if item.get("contact_decomposition_proof") is None
+                        else CompiledContactDecompositionProof.from_dict(
+                            _strict_mapping(
+                                item["contact_decomposition_proof"],
+                                "contact decomposition proof",
+                            )
+                        )
+                    ),
+                    contact_orbit_certificate=(
+                        None
+                        if _required_field(
+                            item,
+                            "contact_orbit_certificate",
+                            context="compiled vertex term",
+                        )
+                        is None
+                        else CompiledContactOrbitCertificate.from_dict(
+                            _strict_mapping(
+                                item["contact_orbit_certificate"],
+                                "contact-orbit certificate",
+                            )
+                        )
+                    ),
+                    source_ordering_ids=tuple(
+                        _strict_string(value, "vertex source ordering ID")
+                        for value in _required_sequence_field(
+                            item,
+                            "source_ordering_ids",
+                            context="compiled vertex term",
+                        )
+                    ),
+                    index_bindings=tuple(
+                        TensorIndexBindingIR.from_json_dict(
+                            _strict_mapping(value, "tensor index binding")
+                        )
+                        for value in _required_sequence_field(
+                            item,
+                            "index_bindings",
+                            context="compiled vertex term",
+                        )
+                    ),
+                )
+                for item in _mappings(payload.get("vertex_terms"))
+            ),
+            oriented_kernels=tuple(
+                CompiledOrientedKernel(
+                    kind=_integer(item["kind"]),
+                    term_id=_integer(item["term_id"]),
+                    vertex=str(item["vertex"]),
+                    particles=cast_tuple3(item["particles"]),
+                    source_particle_legs=cast_int_tuple3(item["source_particle_legs"]),
+                    component_expressions=tuple(
+                        str(value) for value in _sequence(item["component_expressions"])
+                    ),
+                    coupling_expression=str(item["coupling_expression"]),
+                    coupling_orders=_orders(item.get("coupling_orders")),
+                    runtime_parameters=tuple(
+                        str(value) for value in _sequence(item["runtime_parameters"])
+                    ),
+                    color_source=str(
+                        item.get("color_source", item["color_expression"])
+                    ),
+                    color_expression=str(item["color_expression"]),
+                    color_projection_structure=_optional_string(
+                        item.get("color_projection_structure")
+                    ),
+                    color_projection_coefficient=(
+                        None
+                        if item.get("color_projection_coefficient") is None
+                        else _pair(item.get("color_projection_coefficient"))
+                    ),
+                    lc_color_normalization_power=_integer(
+                        item.get("lc_color_normalization_power", 0)
+                    ),
+                    term_ids=tuple(
+                        _integer(value)
+                        for value in _sequence(
+                            item.get("term_ids", [_integer(item["term_id"])])
+                        )
+                    ),
+                    evaluation_class=str(
+                        item.get(
+                            "evaluation_class",
+                            f"unverified-kernel-{_integer(item['kind'])}",
+                        )
+                    ),
+                    evaluation_factor=_pair(item.get("evaluation_factor", (1.0, 0.0))),
+                    evaluation_input_order=cast_int_tuple2(
+                        item.get("evaluation_input_order", (0, 1))
+                    ),
+                    evaluation_input_exchange_factor=(
+                        None
+                        if item.get("evaluation_input_exchange_factor") is None
+                        else _pair(item.get("evaluation_input_exchange_factor"))
+                    ),
+                    evaluation_equivalence_verified=bool(
+                        item.get("evaluation_equivalence_verified", False)
+                    ),
+                    input_ordering_ids=tuple(
+                        _strict_string(value, "kernel input ordering ID")
+                        for value in _required_sequence_field(
+                            item,
+                            "input_ordering_ids",
+                            context="compiled oriented kernel",
+                        )
+                    ),
+                    output_ordering_id=_strict_string(
+                        _required_field(
+                            item,
+                            "output_ordering_id",
+                            context="compiled oriented kernel",
+                        ),
+                        "kernel output ordering ID",
+                    ),
+                    lc_recurrence_color_rule_kind=_optional_string(
+                        item.get("lc_recurrence_color_rule_kind")
+                    ),
+                    lc_color_transition_terms=(
+                        _compiled_lc_color_transition_terms(
+                            item.get("lc_color_transition_terms", ())
+                        )
+                    ),
+                    lc_color_closure_terms=(
+                        _compiled_lc_color_closure_terms(
+                            item.get("lc_color_closure_terms", ())
+                        )
+                    ),
+                    contact_orbit_steps=tuple(
+                        CompiledContactOrbitStep.from_dict(step)
+                        for step in _mappings(
+                            _required_field(
+                                item,
+                                "contact_orbit_steps",
+                                context="compiled oriented kernel",
+                            )
+                        )
+                    ),
+                )
+                for item in _mappings(payload.get("oriented_kernels"))
+            ),
+            direct_contractions=tuple(
+                CompiledDirectContractionRecord.from_dict(item)
+                for item in _required_mappings(payload, "direct_contractions")
+            ),
+            closure_contractions=tuple(
+                CompiledClosureContractionRecord.from_dict(item)
+                for item in _required_mappings(payload, "closure_contractions")
+            ),
+            tensor_orderings=tuple(
+                TensorOrderingIR.from_json_dict(item)
+                for item in _required_mappings(payload, "tensor_orderings")
+            ),
+            current_orderings=tuple(
+                CompiledCurrentOrderingRecord.from_json_dict(item)
+                for item in _required_mappings(payload, "current_orderings")
+            ),
+            goldstone_partners=tuple(
+                CompiledGoldstonePartnerRecord.from_dict(item)
+                for item in _required_mappings(payload, "goldstone_partners")
+            ),
+        )
+
+
+def compiled_particle_is_chiral_eligible(
+    particle: CompiledParticleRecord,
+    *,
+    parameters: Mapping[str, CompiledParameterRecord],
+    propagators: Mapping[str, CompiledPropagatorRecord],
+) -> bool:
+    """Return whether compilation proved a two-component Weyl current valid."""
+
+    if (
+        particle.statistics != "fermion"
+        or particle.wavefunction_family != "fermion"
+        or particle.self_conjugate
+        or not particle.propagating
+    ):
+        return False
+    try:
+        component_dimension = compiled_particle_component_dimension(particle)
+    except ValueError:
+        return False
+    if component_dimension != 4:
+        return False
+    if particle.propagator is not None:
+        propagator = propagators.get(particle.propagator)
+        if propagator is None or propagator.custom:
+            return False
+    if particle.mass.upper() == "ZERO":
+        return True
+    parameter = parameters.get(particle.mass)
+    if parameter is None or parameter.nature.lower() == "external":
+        return False
+    from . import compiler_symbolica as _sym
+
+    _sym._ensure_symbolica()
+    return (
+        _sym.E(parameter.resolved_expression).expand().to_canonical_string()
+        == _sym.E("0").to_canonical_string()
+    )
+
+
+def compiled_current_dimension(
+    particle: CompiledParticleRecord,
+    chirality: int,
+    *,
+    parameters: Mapping[str, CompiledParameterRecord],
+    propagators: Mapping[str, CompiledPropagatorRecord],
+) -> int:
+    """Resolve one concrete compiled current state without model heuristics."""
+
+    value = _validate_chirality(chirality, "chirality")
+    if value != 0:
+        if value not in {-1, 1}:
+            raise ValueError(f"unsupported concrete chirality {value}")
+        if not compiled_particle_is_chiral_eligible(
+            particle,
+            parameters=parameters,
+            propagators=propagators,
+        ):
+            raise ValueError(
+                f"particle {particle.name!r} does not support projected Weyl currents"
+            )
+        return 2
+    return compiled_particle_component_dimension(particle)
+
+
+def _validate_concrete_chirality_relation(
+    contraction: ContractionIR,
+    left_chirality: int,
+    right_chirality: int,
+    *,
+    context: str,
+) -> None:
+    relation = contraction.chirality_relation
+    if relation == "equal" and left_chirality != right_chirality:
+        raise ValueError(f"{context} violates equal chirality relation")
+    if relation == "opposite" and (
+        left_chirality == 0
+        or right_chirality == 0
+        or left_chirality != -right_chirality
+    ):
+        raise ValueError(f"{context} violates opposite chirality relation")
+
+
+def _validate_particle_selector_name(value: object, context: str) -> str:
+    if not isinstance(value, str):
+        raise TypeError(f"compiled contraction {context} must be a string")
+    if not value:
+        raise ValueError(f"compiled contraction {context} must not be empty")
+    return value
+
+
+def _validate_chirality(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"compiled contraction {context} must be an integer")
+    return value
+
+
+def _strict_record_fields(
+    payload: Mapping[str, object],
+    *,
+    required: set[str],
+    context: str,
+) -> Mapping[str, object]:
+    if not isinstance(payload, Mapping):
+        raise TypeError(f"{context} must be a mapping")
+    fields = set(payload)
+    missing = required - fields
+    if missing:
+        names = ", ".join(sorted(missing))
+        raise ValueError(f"{context} is missing required fields: {names}")
+    unknown = fields - required
+    if unknown:
+        names = ", ".join(sorted(str(name) for name in unknown))
+        raise ValueError(f"{context} has unknown fields: {names}")
+    return payload
+
+
+def _strict_mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise TypeError(f"{context} must be a mapping")
+    return value
+
+
+def _strict_string(value: object, context: str) -> str:
+    if not isinstance(value, str):
+        raise TypeError(f"{context} must be a string")
+    return value
+
+
+def _strict_integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{context} must be an integer")
+    return value
+
+
+def _required_mappings(
+    payload: Mapping[str, object],
+    field: str,
+) -> tuple[Mapping[str, object], ...]:
+    if field not in payload:
+        raise ValueError(f"compiled model is missing required field {field!r}")
+    value = payload[field]
+    if isinstance(value, (str, bytes)) or not isinstance(value, list | tuple):
+        raise TypeError(f"compiled model field {field!r} must be an array")
+    result: list[Mapping[str, object]] = []
+    for index, item in enumerate(value):
+        if not isinstance(item, Mapping):
+            raise TypeError(
+                f"compiled model field {field!r} item {index} must be a mapping"
+            )
+        result.append(item)
+    return tuple(result)
+
+
+def _required_field(
+    payload: Mapping[str, object],
+    field: str,
+    *,
+    context: str,
+) -> object:
+    if field not in payload:
+        raise ValueError(f"{context} is missing required field {field!r}")
+    return payload[field]
+
+
+def _required_sequence_field(
+    payload: Mapping[str, object],
+    field: str,
+    *,
+    context: str,
+) -> tuple[object, ...]:
+    value = _required_field(payload, field, context=context)
+    if isinstance(value, (str, bytes)) or not isinstance(value, list | tuple):
+        raise TypeError(f"{context} field {field!r} must be an array")
+    return tuple(value)
+
+
+def cast_tuple3(value: object) -> tuple[str, str, str]:
+    values = tuple(str(item) for item in _sequence(value))
+    if len(values) != 3:
+        raise ValueError("oriented kernel particles must have length three")
+    return values[0], values[1], values[2]
+
+
+def cast_int_tuple3(value: object) -> tuple[int, int, int]:
+    values = tuple(_integer(item) for item in _sequence(value))
+    if len(values) != 3:
+        raise ValueError("oriented kernel source legs must have length three")
+    return values[0], values[1], values[2]
+
+
+def cast_int_tuple2(value: object) -> tuple[int, int]:
+    values = tuple(_integer(item) for item in _sequence(value))
+    if len(values) != 2:
+        raise ValueError("evaluation input order must have length two")
+    return values[0], values[1]
+
+
+def _orders(value: object) -> tuple[tuple[str, int], ...]:
+    result: list[tuple[str, int]] = []
+    for pair in _sequence(value):
+        values = _sequence(pair)
+        if len(values) != 2:
+            raise ValueError("coupling order must be [name, value]")
+        result.append((str(values[0]), _integer(values[1])))
+    return tuple(result)
+
+
+def _pair(value: object) -> tuple[float, float]:
+    pair = _sequence(value)
+    if len(pair) != 2:
+        raise ValueError("complex value must be [real, imaginary]")
+    return _floating(pair[0]), _floating(pair[1])
+
+
+def _optional_pair(value: object) -> tuple[float, float] | None:
+    return None if value is None else _pair(value)
+
+
+def _optional_string(value: object) -> str | None:
+    return None if value is None else str(value)
+
+
+def _integer(value: object) -> int:
+    if not isinstance(value, str | int | float):
+        raise ValueError(f"expected an integer-compatible value, got {value!r}")
+    return int(value)
+
+
+def _floating(value: object) -> float:
+    if not isinstance(value, str | int | float):
+        raise ValueError(f"expected a numeric value, got {value!r}")
+    return float(value)
+
+
+def _sequence(value: object) -> list[object]:
+    return list(value) if isinstance(value, list | tuple) else []
+
+
+def _mappings(value: object) -> list[dict[str, object]]:
+    return [dict(item) for item in _sequence(value) if isinstance(item, Mapping)]
+
+
+def _compiled_lc_color_transition_terms(
+    value: object,
+) -> tuple[CompiledLCColorTransitionTerm, ...]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, list | tuple):
+        raise TypeError(
+            "compiled oriented-kernel LC color transition terms must be an array"
+        )
+    return tuple(
+        CompiledLCColorTransitionTerm.from_dict(
+            _strict_mapping(item, "compiled LC color transition term")
+        )
+        for item in value
+    )
+
+
+def _compiled_lc_color_closure_terms(
+    value: object,
+) -> tuple[CompiledLCColorTransitionTerm, ...]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, list | tuple):
+        raise TypeError(
+            "compiled oriented-kernel LC color closure terms must be an array"
+        )
+    return tuple(
+        CompiledLCColorTransitionTerm.from_dict(
+            _strict_mapping(item, "compiled LC color closure term")
+        )
+        for item in value
+    )
+
+
+__all__ = [
+    "SUPPORTED_COLOR_REPRESENTATIONS",
+    "TENSOR_ORDERING_CONTRACT_VERSION",
+    "CompiledClosureContractionRecord",
+    "CompiledContactDecompositionProof",
+    "CompiledContactDecompositionSplit",
+    "CompiledContactDummyIndexMapping",
+    "CompiledContactOrientationProof",
+    "CompiledContactUnsupportedReason",
+    "CompiledCouplingOrder",
+    "CompiledCouplingRecord",
+    "CompiledCurrentOrderingRecord",
+    "CompiledDirectContractionRecord",
+    "CompiledLCColorTransitionTerm",
+    "CompiledModelIR",
+    "CompiledOrientedKernel",
+    "CompiledParameterRecord",
+    "CompiledParticleRecord",
+    "CompiledPropagatorRecord",
+    "CompiledVertexTerm",
+    "TensorAxisIR",
+    "TensorIndexBindingIR",
+    "TensorOrderingIR",
+    "compiled_current_dimension",
+    "compiled_particle_component_dimension",
+    "compiled_particle_is_chiral_eligible",
+    "validate_color_representation",
+    "validate_quantum_number_flow",
+]
diff --git a/pyamplicol/src/pyamplicol/models/expressions.py b/pyamplicol/src/pyamplicol/models/expressions.py
new file mode 100644
index 0000000000..0439276cde
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/expressions.py
@@ -0,0 +1,225 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Sequence
+from functools import lru_cache
+from numbers import Number
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .base import CouplingOrders, Model, Vertex
+
+
+def _number(value: complex | float) -> Any:
+    from symbolica import Expression
+
+    return Expression.num(value)
+
+
+@lru_cache(maxsize=128)
+def _exact_complex_expression(value: complex) -> Any:
+    """Represent a stored binary64 weight without rounding symbolic factors.
+
+    In particular, multiplying a rational coefficient by a Python complex
+    unit must not turn that coefficient into a floating-point approximation.
+    """
+    from symbolica import E
+
+    real_numerator, real_denominator = value.real.as_integer_ratio()
+    imag_numerator, imag_denominator = value.imag.as_integer_ratio()
+    return E(
+        f"({real_numerator}/{real_denominator})"
+        f"+1i*({imag_numerator}/{imag_denominator})"
+    )
+
+
+def _imaginary_unit_for(values: Sequence[Any]) -> Any:
+    """Keep symbolic propagator phases exact without changing numeric inputs."""
+    if all(isinstance(value, Number) for value in values):
+        return 1j
+    from symbolica import Expression
+
+    if any(isinstance(value, Expression) for value in values):
+        return _exact_complex_expression(1j)
+    return 1j
+
+
+def _as_expression(value: Any) -> Any:
+    if isinstance(value, int | float | complex):
+        return _number(value)
+    return value
+
+
+def _minkowski_square_expression(momentum: Sequence[Any]) -> Any:
+    if len(momentum) != 4:
+        raise ValueError("Minkowski momentum needs four components")
+    if all(isinstance(value, int | float | complex) for value in momentum):
+        p0, p1, p2, p3 = momentum
+        return p0 * p0 - p1 * p1 - p2 * p2 - p3 * p3
+    p0, p1, p2, p3 = (_as_expression(value) for value in momentum)
+    return p0 * p0 - p1 * p1 - p2 * p2 - p3 * p3
+
+
+def _model_vertex_result_chiralities(
+    model: Model,
+    vertex: Vertex,
+    left_index: Any,
+    right_index: Any,
+) -> tuple[int, ...]:
+    resolver = getattr(model, "_vertex_result_chiralities", None)
+    if resolver is None:
+        return (0,)
+    return tuple(resolver(vertex, left_index, right_index))
+
+
+def _index_particle_id(index: Any) -> int:
+    if hasattr(index, "particle_id"):
+        return int(index.particle_id)
+    return int(index.pdg)
+
+
+def _index_flavour_flow(index: Any) -> tuple[int, ...]:
+    flow = getattr(index, "flavour_flow", None)
+    if flow is None:
+        return (_index_particle_id(index),)
+    return tuple(int(value) for value in flow)
+
+
+def _index_coupling_orders(index: Any) -> CouplingOrders:
+    orders = getattr(index, "coupling_orders", None)
+    if orders is None:
+        return ()
+    return tuple(
+        sorted(
+            (str(name).upper(), int(value)) for name, value in orders if int(value) != 0
+        )
+    )
+
+
+def _append_flavour_transition(
+    flow: tuple[int, ...],
+    result_particle: int,
+) -> tuple[int, ...]:
+    if flow and flow[-1] == result_particle:
+        return flow
+    return (*flow, result_particle)
+
+
+def _expr_fermion_propagator_weyl(
+    fermion: tuple[Any, ...],
+    momentum: tuple[Any, ...],
+    chirality: int,
+) -> tuple[Any, ...]:
+    energy, px, py, pz = momentum
+    denominator = _minkowski_square_expression(momentum)
+    imaginary = _imaginary_unit_for((*fermion, *momentum))
+    prefactor = imaginary / denominator
+    tmp1 = energy + pz
+    tmp2 = energy - pz
+    tmp3 = px + imaginary * py
+    tmp4 = px - imaginary * py
+    f1, f2 = fermion
+    if chirality == 1:
+        return (
+            (tmp1 * f1 + tmp3 * f2) * prefactor,
+            (tmp2 * f2 + tmp4 * f1) * prefactor,
+        )
+    if chirality == -1:
+        return (
+            (tmp2 * f1 - tmp3 * f2) * prefactor,
+            (tmp1 * f2 - tmp4 * f1) * prefactor,
+        )
+    raise ValueError("Weyl fermion propagator expression needs nonzero chirality")
+
+
+def _expr_antifermion_propagator_weyl(
+    antifermion: tuple[Any, ...],
+    momentum: tuple[Any, ...],
+    chirality: int,
+) -> tuple[Any, ...]:
+    energy, px, py, pz = momentum
+    denominator = _minkowski_square_expression(momentum)
+    imaginary = _imaginary_unit_for((*antifermion, *momentum))
+    prefactor = imaginary / denominator
+    tmp1 = -(energy + pz)
+    tmp2 = -(energy - pz)
+    tmp3 = -(px + imaginary * py)
+    tmp4 = -(px - imaginary * py)
+    a1, a2 = antifermion
+    if chirality == 1:
+        return (
+            (tmp2 * a1 - tmp4 * a2) * prefactor,
+            (tmp1 * a2 - tmp3 * a1) * prefactor,
+        )
+    if chirality == -1:
+        return (
+            (tmp1 * a1 + tmp4 * a2) * prefactor,
+            (tmp2 * a2 + tmp3 * a1) * prefactor,
+        )
+    raise ValueError("Weyl antifermion propagator expression needs nonzero chirality")
+
+
+def _expr_fermion_propagator_dirac(
+    fermion: tuple[Any, ...],
+    momentum: tuple[Any, ...],
+    mass: float,
+    width: float,
+) -> tuple[Any, ...]:
+    if len(fermion) != 4 or len(momentum) != 4:
+        raise ValueError("Dirac fermion propagator expects four components")
+    energy, px, py, pz = momentum
+    imaginary = _imaginary_unit_for((*fermion, *momentum, mass, width))
+    denominator = (
+        _minkowski_square_expression(momentum) - mass * mass + imaginary * mass * width
+    )
+    prefactor = imaginary / denominator
+    tmp1 = energy + pz
+    tmp2 = energy - pz
+    tmp3 = px + imaginary * py
+    tmp4 = px - imaginary * py
+    f1, f2, f3, f4 = fermion
+    return (
+        (tmp1 * f3 + tmp3 * f4 + mass * f1) * prefactor,
+        (tmp2 * f4 + tmp4 * f3 + mass * f2) * prefactor,
+        (tmp2 * f1 - tmp3 * f2 + mass * f3) * prefactor,
+        (tmp1 * f2 - tmp4 * f1 + mass * f4) * prefactor,
+    )
+
+
+def _expr_antifermion_propagator_dirac(
+    antifermion: tuple[Any, ...],
+    momentum: tuple[Any, ...],
+    mass: float,
+    width: float,
+) -> tuple[Any, ...]:
+    if len(antifermion) != 4 or len(momentum) != 4:
+        raise ValueError("Dirac antifermion propagator expects four components")
+    energy, px, py, pz = momentum
+    imaginary = _imaginary_unit_for((*antifermion, *momentum, mass, width))
+    denominator = (
+        _minkowski_square_expression(momentum) - mass * mass + imaginary * mass * width
+    )
+    prefactor = imaginary / denominator
+    tmp1 = -(energy + pz)
+    tmp2 = -(energy - pz)
+    tmp3 = -(px + imaginary * py)
+    tmp4 = -(px - imaginary * py)
+    a1, a2, a3, a4 = antifermion
+    return (
+        (tmp2 * a3 - tmp4 * a4 + mass * a1) * prefactor,
+        (tmp1 * a4 - tmp3 * a3 + mass * a2) * prefactor,
+        (tmp1 * a1 + tmp4 * a2 + mass * a3) * prefactor,
+        (tmp2 * a2 + tmp3 * a1 + mass * a4) * prefactor,
+    )
+
+
+def _expr_minkowski_dot(
+    left: tuple[Any, ...],
+    right: tuple[Any, ...],
+) -> Any:
+    return (
+        left[0] * right[0]
+        - left[1] * right[1]
+        - left[2] * right[2]
+        - left[3] * right[3]
+    )
diff --git a/pyamplicol/src/pyamplicol/models/external.py b/pyamplicol/src/pyamplicol/models/external.py
new file mode 100644
index 0000000000..10b9d5f360
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/external.py
@@ -0,0 +1,199 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Mapping
+from copy import copy
+from typing import TYPE_CHECKING, Any
+
+from .._internal.physics.symbols import symbols
+from .base import (
+    Model,
+    Particle,
+    Vertex,
+)
+from .contracts import validate_color_representation
+
+if TYPE_CHECKING:
+    from .loading import CompiledModel
+
+from . import compiler_symbolica as _sym
+from .external_catalog import ExternalModelCatalogMixin
+from .external_evaluation import ExternalModelEvaluationMixin
+from .external_helpers import _spin_dimension
+from .external_kernels import ExternalModelKernelMixin
+from .external_symmetries import derive_external_symmetry_certificates
+
+
+class CompiledUFOModel(
+    ExternalModelCatalogMixin,
+    ExternalModelEvaluationMixin,
+    ExternalModelKernelMixin,
+    Model,
+):
+    """Compiled-UFO model boundary consumed by generic DAG generation."""
+
+    def __init__(
+        self,
+        compiled: CompiledModel,
+        runtime_parameters: Mapping[str, Any] | None = None,
+    ) -> None:
+        _sym._ensure_symbolica()
+        self.compiled = compiled
+        self.name = compiled.name
+        self._model_symbols = symbols.model(self.name)
+        self._particle_records_by_name = {
+            particle.name: particle for particle in compiled.ir.particles
+        }
+        self._particle_records_by_pdg = {
+            particle.pdg_code: particle for particle in compiled.ir.particles
+        }
+        self._direct_contraction_ir_by_state = {
+            (
+                self._particle_records_by_name[record.left_particle].pdg_code,
+                record.left_chirality,
+                self._particle_records_by_name[record.right_particle].pdg_code,
+                record.right_chirality,
+            ): record.contraction_ir
+            for record in compiled.ir.direct_contractions
+        }
+        self._closure_contraction_ir_by_state = {
+            (
+                self._particle_records_by_name[record.particle].pdg_code,
+                record.chirality,
+            ): record.contraction_ir
+            for record in compiled.ir.closure_contractions
+        }
+        for particle in compiled.ir.particles:
+            validate_color_representation(
+                particle.color,
+                context=f"particle {particle.name!r}",
+            )
+        self._parameter_records = {
+            parameter.name: parameter for parameter in compiled.ir.parameters
+        }
+        self._propagator_records_by_particle_name = {
+            propagator.particle: propagator for propagator in compiled.ir.propagators
+        }
+        self._vertex_terms = {term.id: term for term in compiled.ir.vertex_terms}
+        self._coupling_records_by_name = {
+            coupling.name: coupling for coupling in compiled.ir.couplings
+        }
+        defaults = {
+            name: complex(value[0], value[1])
+            for name, value in compiled.parameter_defaults.items()
+        }
+        self._runtime_parameters = {**defaults, **dict(runtime_parameters or {})}
+        self.particles = {
+            record.pdg_code: Particle(
+                pdg=record.pdg_code,
+                anti_pdg=self._particle_records_by_name[record.antiname].pdg_code,
+                spin=record.spin,
+                dimension=(
+                    record.component_dimension
+                    if record.component_dimension is not None
+                    else _spin_dimension(record.spin)
+                ),
+                color_rep=record.color,
+                mass=float(complex(self._parameter_default(record.mass)).real),
+                width=float(complex(self._parameter_default(record.width)).real),
+                charge=record.charge,
+            )
+            for record in compiled.ir.particles
+        }
+        self._kernels = {kernel.kind: kernel for kernel in compiled.ir.oriented_kernels}
+        self._symmetry_certificates = derive_external_symmetry_certificates(compiled.ir)
+        self._kernel_component_expression_cache: dict[
+            int, tuple[_sym.Expression, ...]
+        ] = {}
+        self._kernel_coupling_expression_cache: dict[int, _sym.Expression] = {}
+        self._kernel_function_specs: dict[
+            tuple[int, int, int, int],
+            tuple[tuple[_sym.Expression, tuple[int, ...]], ...],
+        ] = {}
+        self._symbolica_kernel_functions: dict[
+            tuple[_sym.Expression, tuple[_sym.Expression, ...]], _sym.Expression
+        ] = {}
+        self._runtime_derived_definitions = {
+            parameter.name: parameter.resolved_expression
+            for parameter in compiled.ir.parameters
+            if parameter.nature.lower() == "internal"
+            and parameter.expression is not None
+        }
+        self._runtime_derived_definitions.update(
+            {
+                name: self._vertex_terms[
+                    int(name.rsplit("_", 1)[1])
+                ].coupling_expression
+                for kernel in self._kernels.values()
+                for name in kernel.runtime_parameters
+                if name.startswith("derived_coupling_")
+            }
+        )
+        self._runtime_derived_expression_cache: dict[str, _sym.Expression] = {}
+        self._runtime_derived_default_cache: dict[str, complex] = {}
+        self._runtime_derived_domain_cache: dict[str, str] = {}
+        self._runtime_parameter_domain_cache: dict[str, str] = {}
+        self._weyl_projection_support: dict[tuple[int, int, int, int], bool] = {}
+        self._custom_propagator_expressions: dict[
+            int,
+            tuple[_sym.Expression, tuple[str, ...]],
+        ] = {}
+        self._custom_propagator_templates: dict[int, tuple[_sym.Expression, ...]] = {}
+        self._color_projection_cache: dict[int, tuple[str, complex]] = {}
+        self._goldstone_partner_records = {
+            record.goldstone: record for record in compiled.ir.goldstone_partners
+        }
+        for record in compiled.ir.goldstone_partners:
+            if record.vector is None:
+                continue
+            vector = self._particle_records_by_name[record.vector]
+            propagator = self._propagator_ir(vector.pdg_code)
+            if propagator.goldstone_policy != record.policy:
+                raise ValueError(
+                    f"compiled Goldstone {record.goldstone!r} policy does not "
+                    f"match vector {record.vector!r} lowering"
+                )
+        self.inactive_goldstone_names = frozenset(
+            record.goldstone
+            for record in compiled.ir.goldstone_partners
+            if record.policy == "absorbed"
+        )
+        self.vertices = tuple(
+            Vertex(
+                kind=kernel.kind,
+                particles=(
+                    self._particle_records_by_name[kernel.particles[0]].pdg_code,
+                    self._particle_records_by_name[kernel.particles[1]].pdg_code,
+                    self._particle_records_by_name[kernel.particles[2]].pdg_code,
+                ),
+                coupling=(1.0, 0.0),
+            )
+            for kernel in compiled.ir.oriented_kernels
+            if not any(
+                name in self.inactive_goldstone_names for name in kernel.particles
+            )
+        )
+        vertices_by_input: dict[tuple[int, int], list[Vertex]] = {}
+        for vertex in self.vertices:
+            vertices_by_input.setdefault(
+                (vertex.particles[0], vertex.particles[1]),
+                [],
+            ).append(vertex)
+        self._compiled_vertices_by_input = {
+            key: tuple(vertices) for key, vertices in vertices_by_input.items()
+        }
+
+    def with_runtime_parameters(
+        self,
+        parameters: Mapping[str, Any],
+    ) -> CompiledUFOModel:
+        model = copy(self)
+        model._runtime_parameters = {
+            **self._runtime_parameters,
+            **dict(parameters),
+        }
+        model._runtime_derived_default_cache = {}
+        return model
+
+
+__all__ = ["CompiledUFOModel"]
diff --git a/pyamplicol/src/pyamplicol/models/external_catalog.py b/pyamplicol/src/pyamplicol/models/external_catalog.py
new file mode 100644
index 0000000000..9da0fecc38
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/external_catalog.py
@@ -0,0 +1,599 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING, Any, cast
+
+from ._physics_ir import ParticleIdentityIR, ParticleOrientation
+from .base import (
+    Particle,
+    QuantumFlow,
+    QuantumNumberFlow,
+    RecurrenceCurrentEmbeddingContract,
+    RecurrenceLCColorComponentKind,
+    RecurrenceLCColorOperation,
+    RecurrenceLCColorShapeKind,
+    RecurrenceLCColorSourceSeedContract,
+    RecurrenceLCColorTransitionContract,
+    RecurrenceLCColorWitnessContract,
+    RecurrenceQuantumFlowContract,
+    SourceSpinState,
+    Vertex,
+    VertexEvaluationEquivalence,
+    VertexLoweringRule,
+)
+from .contact_decomposition import (
+    CompiledContactOrbitCertificate,
+    CompiledContactOrbitStep,
+)
+
+if TYPE_CHECKING:
+    pass
+
+from .external_helpers import _spin_dimension
+
+
+class ExternalModelCatalogMixin:
+    def particle(self, pdg: int) -> Particle:
+        try:
+            return self.particles[int(pdg)]
+        except KeyError as exc:
+            raise KeyError(f"particle not in model: {pdg}") from exc
+
+    def vertices_for_inputs(
+        self,
+        left_pdg: int,
+        right_pdg: int,
+        *,
+        color_accuracy: str = "lc",
+    ) -> tuple[Vertex, ...]:
+        if color_accuracy not in {"lc", "nlc", "full"}:
+            raise ValueError(f"unknown colour accuracy: {color_accuracy}")
+        return self._compiled_vertices_by_input.get(
+            (int(left_pdg), int(right_pdg)),
+            (),
+        )
+
+    def anti_particle(self, pdg: int) -> int:
+        return self.particle(pdg).anti_pdg
+
+    def mass(self, pdg: int) -> Any:
+        return self._real_parameter_value(
+            self._particle_records_by_pdg[int(pdg)].mass,
+            field="mass",
+        )
+
+    def width(self, pdg: int) -> Any:
+        return self._real_parameter_value(
+            self._particle_records_by_pdg[int(pdg)].width,
+            field="width",
+        )
+
+    def spin(self, pdg: int) -> int:
+        return self._particle_records_by_pdg[int(pdg)].spin
+
+    def dimension(self, pdg: int) -> int:
+        record = self._particle_records_by_pdg[int(pdg)]
+        if record.component_dimension is not None:
+            return record.component_dimension
+        return _spin_dimension(record.spin)
+
+    def current_dimension(self, particle_id: int, chirality: int = 0) -> int:
+        if chirality != 0 and self.is_chiral_eligible(particle_id):
+            return 2
+        return self.dimension(particle_id)
+
+    def color_rep(self, pdg: int) -> int:
+        return self._particle_records_by_pdg[int(pdg)].color
+
+    def color_dim(self, pdg: int) -> int:
+        return abs(self.color_rep(pdg))
+
+    def charge(self, pdg: int) -> float:
+        return self._particle_records_by_pdg[int(pdg)].charge
+
+    def quantum_number_flow(self, particle_id: int) -> QuantumNumberFlow:
+        return self._particle_records_by_pdg[int(particle_id)].quantum_numbers
+
+    def is_fermion(self, pdg: int) -> bool:
+        return self._particle_records_by_pdg[int(pdg)].statistics == "fermion"
+
+    def is_chiral_eligible(self, pdg: int) -> bool:
+        if not self.is_fermion(pdg):
+            return False
+        propagator = self._propagator_record(pdg)
+        if propagator is not None and propagator.custom:
+            return False
+        particle = self._particle_records_by_pdg[int(pdg)]
+        if particle.mass.upper() == "ZERO":
+            return True
+        record = self._parameter_records.get(particle.mass)
+        return (
+            record is not None
+            and record.nature != "external"
+            and self._parameter_default(particle.mass) == 0.0
+        )
+
+    def is_fundamental_colored_fermion(self, pdg: int) -> bool:
+        return self.is_fermion(pdg) and abs(self.color_rep(pdg)) == 3
+
+    def is_massless_adjoint_vector(self, pdg: int) -> bool:
+        return (
+            self.spin(pdg) == 3
+            and self.color_rep(pdg) == 8
+            and complex(
+                self._parameter_default(self._particle_records_by_pdg[int(pdg)].mass)
+            ).real
+            == 0.0
+        )
+
+    def is_singlet(self, pdg: int) -> bool:
+        return self.color_rep(pdg) == 1
+
+    def source_spin_states(self, particle_id: int) -> tuple[SourceSpinState, ...]:
+        if self.is_chiral_eligible(particle_id):
+            return super().source_spin_states(particle_id)
+        spin = self.spin(particle_id)
+        massive = (
+            complex(
+                self._parameter_default(
+                    self._particle_records_by_pdg[int(particle_id)].mass
+                )
+            ).real
+            != 0.0
+        )
+        if spin == 1:
+            helicities = (0,)
+        elif spin == 2:
+            helicities = (-1, 1)
+        elif spin == 3:
+            helicities = (-1, 0, 1) if massive else (-1, 1)
+        elif spin == 5:
+            helicities = (-2, -1, 0, 1, 2) if massive else (-2, 2)
+        else:
+            raise ValueError(
+                f"unsupported source spin {spin} for particle {particle_id}"
+            )
+        return tuple(
+            SourceSpinState(helicity=helicity, chirality=0, spin_state=helicity)
+            for helicity in helicities
+        )
+
+    def source_wavefunction_kind(self, particle_id: int) -> str:
+        return self._particle_records_by_pdg[int(particle_id)].wavefunction_family
+
+    def source_orientation(self, particle_id: int) -> str:
+        record = self._particle_records_by_pdg[int(particle_id)]
+        if record.statistics == "fermion" and record.self_conjugate:
+            raise ValueError(
+                f"unsupported self-conjugate fermion source {particle_id}: "
+                "Majorana/FNV source wavefunctions are not implemented"
+            )
+        return record.source_orientation
+
+    def _particle_identity_ir(self, particle_id: int) -> ParticleIdentityIR:
+        record = self._particle_records_by_pdg[int(particle_id)]
+        anti_record = self._particle_records_by_name[record.antiname]
+        species_record = (
+            record
+            if record.source_orientation in {"particle", "self-conjugate"}
+            else anti_record
+        )
+        return ParticleIdentityIR(
+            canonical_id=f"model:{self.name}:state:{record.name}",
+            species_id=f"model:{self.name}:species:{species_record.name}",
+            anti_canonical_id=f"model:{self.name}:state:{anti_record.name}",
+            display_name=record.name,
+            anti_display_name=anti_record.name,
+            pdg_label=int(record.pdg_code),
+            anti_pdg_label=int(anti_record.pdg_code),
+            orientation=cast(ParticleOrientation, record.source_orientation),
+            self_conjugate=bool(record.self_conjugate),
+        )
+
+    def allowed_quantum_flows(
+        self,
+        vertex: Vertex,
+        left_index: Any,
+        right_index: Any,
+    ) -> tuple[QuantumFlow, ...]:
+        result_particle = vertex.particles[2]
+        left_chirality = int(getattr(left_index, "chirality", 0))
+        right_chirality = int(getattr(right_index, "chirality", 0))
+        result_chiralities = (
+            (0,)
+            if (
+                self.is_chiral_eligible(result_particle)
+                and left_chirality == 0
+                and right_chirality == 0
+            )
+            else (
+                (-1, 1)
+                if self.is_chiral_eligible(result_particle)
+                else (0,)
+            )
+        )
+        return tuple(
+            QuantumFlow(
+                chirality=result_chirality,
+                spin_state=(
+                    result_chirality if self.is_chiral_eligible(result_particle) else 0
+                ),
+                flavour_flow=self.combine_flavour_flow(
+                    result_particle,
+                    left_index,
+                    right_index,
+                ),
+                quantum_number_flow=self.quantum_number_flow(result_particle),
+                coupling=(1.0, 0.0),
+            )
+            for result_chirality in result_chiralities
+            if self._weyl_projection_is_nonzero(
+                vertex.kind,
+                left_chirality,
+                right_chirality,
+                result_chirality,
+            )
+        )
+
+    def recurrence_quantum_flow_contract(
+        self,
+        vertex: Vertex,
+        left_particle_id: int,
+        right_particle_id: int,
+    ) -> RecurrenceQuantumFlowContract:
+        return self._standard_recurrence_quantum_flow_contract(
+            vertex,
+            left_particle_id,
+            right_particle_id,
+        )
+
+    def recurrence_current_embedding_contract(
+        self,
+        particle_id: int,
+        source_chirality: int,
+    ) -> RecurrenceCurrentEmbeddingContract:
+        particle = self._particle_records_by_pdg[int(particle_id)]
+        chirality = int(source_chirality)
+        ordering = next(
+            (
+                record
+                for record in self.compiled.ir.current_orderings
+                if record.particle == particle.name
+                and int(record.chirality) == chirality
+            ),
+            None,
+        )
+        if ordering is None:
+            raise NotImplementedError(
+                "compiled model has no current-ordering contract for "
+                f"particle={particle.name!r}, chirality={chirality:+d}; "
+                "re-run the original `pyamplicol model compile ...` command "
+                "with the current pyAmpliCol compiler"
+            )
+        return RecurrenceCurrentEmbeddingContract(
+            input_embedding=tuple(ordering.input_embedding),
+            source_dimension=int(self.current_dimension(particle_id, chirality)),
+            full_dimension=int(self.current_dimension(particle_id, 0)),
+            source_basis=self._current_basis(particle_id, chirality),
+            full_basis=self._current_basis(particle_id, 0),
+            proof_kind="compiled-current-ordering-embedding-v1",
+            provenance=tuple(
+                sorted(
+                    (
+                        ("chirality", f"{chirality:+d}"),
+                        ("kernel-ordering-id", ordering.kernel_ordering_id),
+                        ("ordering-id", ordering.ordering_id),
+                        ("particle", particle.name),
+                    )
+                )
+            ),
+        )
+
+    def recurrence_lc_color_shape_contract(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> RecurrenceLCColorShapeKind:
+        return self._standard_recurrence_lc_color_shape_contract(
+            particle_id,
+            chirality,
+        )
+
+    def recurrence_lc_source_color_contract(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> RecurrenceLCColorSourceSeedContract:
+        return self._standard_recurrence_lc_source_color_contract(
+            particle_id,
+            chirality,
+        )
+
+    def recurrence_lc_color_transition_contract(
+        self,
+        vertex: Vertex,
+        *,
+        closure: bool,
+    ) -> RecurrenceLCColorTransitionContract:
+        kernel = self._kernel(vertex.kind)
+        terms = (
+            kernel.lc_color_closure_terms
+            if closure
+            else kernel.lc_color_transition_terms
+        )
+        contract_kind = "closure" if closure else "transition"
+        if not terms:
+            raise NotImplementedError(
+                f"compiled kernel {kernel.kind} has no compiler-owned LC color "
+                f"{contract_kind} terms; re-run the original `pyamplicol model "
+                "compile ...` command with the current pyAmpliCol compiler"
+            )
+        input_shapes = tuple(
+            self.recurrence_lc_color_shape_contract(particle)
+            for particle in vertex.particles[:2]
+        )
+        result_shape = (
+            None
+            if closure
+            else self.recurrence_lc_color_shape_contract(vertex.particles[2])
+        )
+        witnesses = []
+        for term in terms:
+            if (
+                term.input_shape_kinds != input_shapes
+                or term.result_shape_kind != result_shape
+            ):
+                raise ValueError(
+                    f"compiled kernel {kernel.kind} LC color {contract_kind} term "
+                    "does not match its live oriented particle-state shapes"
+                )
+            if (term.component_operation == "close") != closure:
+                expectation = (
+                    "a closure operation"
+                    if closure
+                    else "a non-closure operation"
+                )
+                raise ValueError(
+                    f"compiled kernel {kernel.kind} LC color {contract_kind} term "
+                    f"must contain {expectation}"
+                )
+            factor = {
+                "1": (1.0, 0.0),
+                "-1": (-1.0, 0.0),
+            }.get(term.exact_factor_expression)
+            if factor is None:
+                raise NotImplementedError(
+                    f"compiled kernel {kernel.kind} LC witness factor "
+                    f"{term.exact_factor_expression!r} is not supported by "
+                    "recurrence v1"
+                )
+            witnesses.append(
+                RecurrenceLCColorWitnessContract(
+                    input_permutation=term.input_permutation,
+                    reverse_parent_mask=term.reverse_parent_mask,
+                    component_operation=cast(
+                        RecurrenceLCColorOperation,
+                        term.component_operation,
+                    ),
+                    result_component_kind=cast(
+                        RecurrenceLCColorComponentKind | None,
+                        term.result_component_kind,
+                    ),
+                    result_component_role=term.result_component_role,
+                    exact_factor=factor,
+                    proof_digest=term.proof_digest,
+                    provenance=term.provenance,
+                )
+            )
+        return RecurrenceLCColorTransitionContract(
+            str(
+                kernel.lc_recurrence_color_rule_kind
+                or kernel.color_projection_structure
+            ),
+            tuple(witnesses),
+        )
+
+    def vertex_lowering_rule(self, kind: int) -> VertexLoweringRule:
+        kernel = self._kernel(kind)
+        return VertexLoweringRule(
+            kind=kind,
+            backend="spenso-ufo",
+            tensor_names=(kernel.vertex,),
+            expression_head="compiled_ufo_kernel",
+            full_tensor_network_ready=True,
+            description="typed and oriented UFO tensor kernel",
+            kernel="compiled_ufo_kernel",
+            input_roles=(kernel.particles[0], kernel.particles[1]),
+            output_role=kernel.particles[2],
+            coupling_mode="external-model-parameters",
+        )
+
+    def vertex_evaluation_equivalence(
+        self,
+        kind: int,
+    ) -> VertexEvaluationEquivalence:
+        kernel = self._kernel(kind)
+        if not kernel.evaluation_equivalence_verified or not kernel.evaluation_class:
+            return super().vertex_evaluation_equivalence(kind)
+        input_order = tuple(int(value) for value in kernel.evaluation_input_order)
+        if input_order not in {(0, 1), (1, 0)}:
+            raise ValueError(
+                f"compiled UFO kernel {kind} has invalid evaluation input order "
+                f"{input_order}"
+            )
+        return VertexEvaluationEquivalence(
+            class_id=kernel.evaluation_class,
+            factor=kernel.evaluation_factor,
+            input_order=input_order,
+            input_exchange_factor=(kernel.evaluation_input_exchange_factor),
+            verified=True,
+        )
+
+    def vertex_contact_orbit_contracts(
+        self,
+        kind: int,
+    ) -> tuple[
+        tuple[CompiledContactOrbitCertificate, ...],
+        tuple[CompiledContactOrbitStep, ...],
+    ]:
+        kernel = self._kernel(kind)
+        steps = kernel.contact_orbit_steps
+        certificates = tuple(
+            self._vertex_terms[term_id].contact_orbit_certificate
+            for term_id in sorted({step.term_id for step in steps})
+        )
+        if any(certificate is None for certificate in certificates):
+            raise ValueError(
+                f"compiled kernel {kind} has an unpaired contact-orbit step"
+            )
+        return (
+            tuple(
+                certificate
+                for certificate in certificates
+                if certificate is not None
+            ),
+            steps,
+        )
+
+    def vertex_coupling_orders(
+        self,
+        vertex: Vertex,
+    ) -> tuple[tuple[str, int], ...]:
+        return self._kernel(vertex.kind).coupling_orders
+
+    def global_helicity_flip_equivalence_is_proven(
+        self,
+        vertices: Sequence[Vertex],
+    ) -> bool:
+        """Accept parity reduction only for algebraically certified kernels."""
+
+        kinds = self._symmetry_certificates.parity_kernel_kinds
+        return bool(vertices) and all(vertex.kind in kinds for vertex in vertices)
+
+    def pure_massless_adjoint_helicity_zero_rule_is_proven(
+        self,
+        process: Any,
+        vertices: Sequence[Vertex],
+    ) -> bool:
+        """Recognize the tree-level Yang--Mills helicity-zero theorem."""
+
+        names = self._symmetry_certificates.yang_mills_adjoint_names
+        kinds = self._symmetry_certificates.yang_mills_kernel_kinds
+        legs = tuple(getattr(process, "legs", ()))
+        return (
+            bool(legs)
+            and bool(vertices)
+            and all(self._particle_name_for_leg(leg) in names for leg in legs)
+            and all(vertex.kind in kinds for vertex in vertices)
+        )
+
+    def adjoint_current_reflection_phase(
+        self,
+        vertex: Vertex,
+    ) -> tuple[float, float] | None:
+        """Return an exact lowered-kernel reflection certificate, if present."""
+
+        return dict(self._symmetry_certificates.adjoint_current_reflection_phases).get(
+            vertex.kind
+        )
+
+    def lc_trace_reflection_equivalence_is_proven(self, process: Any) -> bool:
+        """Recognize reflection folding for a certified Yang--Mills sector."""
+
+        names = self._symmetry_certificates.yang_mills_adjoint_names
+        legs = tuple(getattr(process, "legs", ()))
+        return bool(legs) and all(
+            self._particle_name_for_leg(leg) in names for leg in legs
+        )
+
+    def shared_single_trace_color_basis_is_proven(self, process: Any) -> bool:
+        """Accept shared traces only for the certified Yang--Mills sector."""
+
+        names = self._symmetry_certificates.yang_mills_adjoint_names
+        legs = tuple(getattr(process, "legs", ()))
+        return bool(legs) and all(
+            self._particle_name_for_leg(leg) in names for leg in legs
+        )
+
+    def adjoint_tree_color_basis_is_proven(
+        self,
+        process: Any,
+        *,
+        max_coupling_orders: Mapping[str, int] | None = None,
+    ) -> bool:
+        """Certify actual colour tensors without assuming Yang--Mills helicities."""
+
+        from .adjoint_color_certificate import (
+            compiled_adjoint_tree_color_basis_is_proven,
+        )
+
+        return compiled_adjoint_tree_color_basis_is_proven(
+            self.compiled.ir, process, max_coupling_orders=max_coupling_orders
+        )
+
+    def _particle_name_for_leg(self, leg: Any) -> str | None:
+        outgoing_pdg = getattr(leg, "outgoing_pdg", None)
+        if outgoing_pdg is None:
+            return None
+        record = self._particle_records_by_pdg.get(int(outgoing_pdg))
+        return None if record is None else record.name
+
+    def coupling_order_hierarchies(self) -> dict[str, int]:
+        return {
+            str(order.name).upper(): max(1, int(order.hierarchy))
+            for order in self.compiled.ir.orders
+        }
+
+    def vertex_color_weight(
+        self,
+        vertex: Vertex,
+        *,
+        color_accuracy: str,
+    ) -> tuple[float, float]:
+        if color_accuracy not in {"lc", "nlc", "full"}:
+            raise ValueError(f"unknown colour accuracy: {color_accuracy}")
+        power = self._kernel(vertex.kind).lc_color_normalization_power
+        structure, coefficient = self._vertex_color_projection(vertex)
+        # The possibly irrational 2**(-power/2) belongs to the symbolic
+        # kernel. Recurrence colour weights are exact complex rationals.
+        if structure in {
+            "adjoint-structure-constant",
+            "adjoint-structure-constant-product",
+        }:
+            phase = (-1j) ** power
+            weight = coefficient * phase
+            return (weight.real, weight.imag)
+        return (coefficient.real, coefficient.imag)
+
+    def vertex_color_structure(self, vertex: Vertex) -> str:
+        return self._vertex_color_projection(vertex)[0]
+
+    def _vertex_color_projection(self, vertex: Vertex) -> tuple[str, complex]:
+        cached = self._color_projection_cache.get(vertex.kind)
+        if cached is not None:
+            return cached
+        kernel = self._kernel(vertex.kind)
+        if (
+            kernel.color_projection_structure is not None
+            and kernel.color_projection_coefficient is not None
+        ):
+            projected = (
+                kernel.color_projection_structure,
+                complex(*kernel.color_projection_coefficient),
+            )
+        else:
+            raise ValueError(
+                f"compiled external-model kernel {kernel.kind} has no certified "
+                "color-flow projection; recompile the UFO/JSON model with the "
+                "current pyAmpliCol version"
+            )
+        self._color_projection_cache[vertex.kind] = projected
+        return projected
+
+    def vertex_is_internal_contact_fragment(self, vertex: Vertex) -> bool:
+        return "::contact-" in self._kernel(vertex.kind).vertex
+
+    def vertex_closure_allowed(self, vertex: Vertex) -> bool:
+        del vertex
+        return False
diff --git a/pyamplicol/src/pyamplicol/models/external_evaluation.py b/pyamplicol/src/pyamplicol/models/external_evaluation.py
new file mode 100644
index 0000000000..92066eadc2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/external_evaluation.py
@@ -0,0 +1,673 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING, Any
+
+from .._internal.physics.symbols import symbols
+from ._physics_ir import PropagatorGauge, PropagatorIR, PropagatorKind
+from .base import (
+    PropagatorLoweringRule,
+)
+from .compiler_kernels import (
+    _as_expression,
+    _ordered_dense_tensor_components,
+    _spin_axis_labels,
+    _spin_representations,
+    _spin_slots,
+)
+from .compiler_records import _replace_evaluator_constants
+from .expressions import (
+    _expr_antifermion_propagator_dirac,
+    _expr_antifermion_propagator_weyl,
+    _expr_fermion_propagator_dirac,
+    _expr_fermion_propagator_weyl,
+    _expr_minkowski_dot,
+    _imaginary_unit_for,
+    _minkowski_square_expression,
+)
+from .tensors import (
+    normalize_lorentz_expression,
+)
+
+if TYPE_CHECKING:
+    pass
+
+from . import compiler_symbolica as _sym
+from .external_helpers import _expr_spin2_propagator, _is_numeric, _replace_symbols
+
+
+class ExternalModelEvaluationMixin:
+    def vertex_component_expression(
+        self,
+        kind: int,
+        left: Sequence[Any],
+        right: Sequence[Any],
+        *,
+        result_particle_id: int,
+        result_chirality: int,
+        left_chirality: int = 0,
+        right_chirality: int = 0,
+        coupling: tuple[Any, Any] = (1.0, 0.0),
+        left_momentum: Sequence[Any] | None = None,
+        right_momentum: Sequence[Any] | None = None,
+    ) -> tuple[Any, ...]:
+        del coupling
+        kernel = self._kernel(kind)
+        expected_result = self._particle_records_by_name[kernel.particles[2]].pdg_code
+        if int(result_particle_id) != expected_result:
+            raise ValueError(
+                f"kernel {kind} returns particle {expected_result}, "
+                f"not {result_particle_id}"
+            )
+        left_momentum = tuple(left_momentum or (0.0, 0.0, 0.0, 0.0))
+        right_momentum = tuple(right_momentum or (0.0, 0.0, 0.0, 0.0))
+        if len(left_momentum) != 4 or len(right_momentum) != 4:
+            raise ValueError("UFO kernels require four-component input momenta")
+        runtime_parameter_values = {
+            name: self._parameter_value(name) for name in kernel.runtime_parameters
+        }
+        if not all(
+            _is_numeric(value)
+            for value in (
+                *left,
+                *right,
+                *left_momentum,
+                *right_momentum,
+                *runtime_parameter_values.values(),
+            )
+        ):
+            return self._kernel_function_component_calls(
+                kernel,
+                left,
+                right,
+                left_chirality=left_chirality,
+                right_chirality=right_chirality,
+                result_chirality=result_chirality,
+                left_momentum=left_momentum,
+                right_momentum=right_momentum,
+                runtime_parameter_values=runtime_parameter_values,
+            )
+        components = self._projected_kernel_components(
+            kernel,
+            left,
+            right,
+            left_chirality=left_chirality,
+            right_chirality=right_chirality,
+            result_chirality=result_chirality,
+            left_momentum=left_momentum,
+            right_momentum=right_momentum,
+            runtime_parameter_values=runtime_parameter_values,
+        )
+        coupling_expression = self._resolved_kernel_coupling_expression(
+            kernel,
+            runtime_parameter_values,
+            numeric=True,
+        )
+        return tuple(component * coupling_expression for component in components)
+
+    def symbolica_function_definitions(
+        self,
+    ) -> Mapping[tuple[_sym.Expression, tuple[_sym.Expression, ...]], _sym.Expression]:
+        """Return lazily materialized kernel functions used by stage expressions."""
+
+        return self._symbolica_kernel_functions
+
+    def propagator_lowering_rule(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> PropagatorLoweringRule:
+        auxiliary_kind = self.auxiliary_kind(particle_id)
+        if (
+            auxiliary_kind is not None
+            and auxiliary_kind != "u1-subtraction-color-flow-vector"
+        ):
+            return PropagatorLoweringRule(
+                particle_id=particle_id,
+                chirality=0,
+                backend="identity",
+                full_tensor_network_ready=True,
+                applies_propagator=False,
+                kernel="ufo_contact_auxiliary_no_propagator",
+                kind="identity",
+                mass_class="not-applicable",
+                auxiliary_policy=auxiliary_kind,
+                description="synthetic UFO contact current with no propagator",
+            )
+        if chirality != 0 and self.is_chiral_eligible(particle_id):
+            return PropagatorLoweringRule(
+                particle_id=particle_id,
+                chirality=chirality,
+                backend="spenso-ufo-weyl",
+                full_tensor_network_ready=True,
+                applies_propagator=True,
+                kernel="ufo_weyl_fermion",
+                kind="weyl-fermion",
+                mass_class="massless",
+                description="UFO massless fermion projected to a Weyl current",
+            )
+        spin = self.spin(particle_id)
+        massive = (
+            complex(
+                self._parameter_default(
+                    self._particle_records_by_pdg[int(particle_id)].mass
+                )
+            ).real
+            != 0.0
+        )
+        custom = self._propagator_record(particle_id)
+        if custom is not None and custom.custom:
+            return PropagatorLoweringRule(
+                particle_id=particle_id,
+                chirality=0,
+                backend="spenso-ufo-custom",
+                full_tensor_network_ready=True,
+                applies_propagator=True,
+                kernel="ufo_custom_propagator",
+                kind="custom",
+                mass_class="massive" if massive else "massless",
+                gauge="model-supplied",
+                numerator=custom.numerator,
+                denominator=custom.denominator,
+                custom_source=custom.name,
+                goldstone_policy="model-supplied",
+                description=(
+                    "model-supplied UFO propagator lowered without gauge conversion"
+                ),
+            )
+        standard_contracts: dict[
+            int,
+            tuple[PropagatorKind, str, PropagatorGauge | None],
+        ] = {
+            1: ("scalar", "ufo_scalar_propagator", None),
+            2: ("dirac-fermion", "ufo_dirac_propagator", None),
+            3: (
+                "vector",
+                (
+                    "ufo_massive_vector_propagator"
+                    if massive
+                    else "ufo_massless_vector_propagator"
+                ),
+                "unitary" if massive else "feynman",
+            ),
+            5: (
+                "spin2",
+                (
+                    "ufo_massive_spin2_fierz_pauli"
+                    if massive
+                    else "ufo_massless_spin2_de_donder"
+                ),
+                "fierz-pauli" if massive else "de-donder",
+            ),
+        }
+        try:
+            kind, kernel, gauge = standard_contracts[spin]
+        except KeyError as exc:
+            raise ValueError(
+                f"UFO spin code {spin} has no supported propagator contract"
+            ) from exc
+        return PropagatorLoweringRule(
+            particle_id=particle_id,
+            chirality=0,
+            backend="symbolica-ufo",
+            full_tensor_network_ready=spin in {1, 2, 3, 5},
+            applies_propagator=True,
+            kernel=kernel,
+            kind=kind,
+            mass_class="massive" if massive else "massless",
+            gauge=gauge,
+            goldstone_policy=(
+                "absorbed" if spin == 3 and massive else "not-applicable"
+            ),
+            description="UFO propagator with runtime mass and width",
+        )
+
+    def propagator_component_expression(
+        self,
+        particle_id: int,
+        value: Sequence[Any],
+        momentum: Sequence[Any],
+        *,
+        chirality: int = 0,
+        propagator: PropagatorIR | None = None,
+    ) -> tuple[Any, ...]:
+        metadata = propagator or self._propagator_ir(particle_id, chirality)
+        if metadata.identity.canonical_id != self._particle_identity_ir(
+            particle_id
+        ).canonical_id or metadata.chirality != int(chirality):
+            raise ValueError("propagator metadata does not match the current")
+        if not metadata.applies_propagator:
+            return tuple(value)
+        if metadata.kind == "weyl-fermion":
+            components = tuple(value)
+            current_momentum = tuple(momentum)
+            return (
+                _expr_antifermion_propagator_weyl(
+                    components,
+                    current_momentum,
+                    chirality,
+                )
+                if metadata.identity.orientation == "antiparticle"
+                else _expr_fermion_propagator_weyl(
+                    components,
+                    current_momentum,
+                    chirality,
+                )
+            )
+        if metadata.kind == "custom":
+            custom = self._propagator_record(particle_id)
+            if (
+                custom is None
+                or not custom.custom
+                or custom.name != metadata.custom_source
+            ):
+                raise ValueError(
+                    "custom propagator contract does not match its compiled source"
+                )
+            return self._evaluate_custom_propagator(
+                particle_id,
+                value,
+                momentum,
+            )
+        if len(momentum) != 4:
+            raise ValueError("UFO propagators require four-momentum components")
+        if metadata.mass_class == "massless":
+            mass = 0.0
+            width = 0.0
+        else:
+            mass = self.mass(particle_id)
+            width = self.width(particle_id)
+        imaginary = _imaginary_unit_for((*value, *momentum, mass, width))
+        if metadata.kind == "scalar":
+            if len(value) != 1:
+                raise ValueError("scalar propagator expects one current component")
+            denominator = (
+                _minkowski_square_expression(momentum)
+                - mass * mass
+                + imaginary * mass * width
+            )
+            return (imaginary * value[0] / denominator,)
+        if metadata.kind == "dirac-fermion":
+            components = tuple(value)
+            current_momentum = tuple(momentum)
+            return (
+                _expr_antifermion_propagator_dirac(
+                    components,
+                    current_momentum,
+                    mass,
+                    width,
+                )
+                if metadata.identity.orientation == "antiparticle"
+                else _expr_fermion_propagator_dirac(
+                    components,
+                    current_momentum,
+                    mass,
+                    width,
+                )
+            )
+        if metadata.kind == "vector":
+            if len(value) != 4:
+                raise ValueError("vector propagator expects four current components")
+            current = tuple(value)
+            current_momentum = tuple(momentum)
+            if metadata.gauge == "feynman":
+                denominator = _minkowski_square_expression(current_momentum)
+                return tuple(
+                    -imaginary * component / denominator for component in current
+                )
+            if metadata.gauge != "unitary":
+                raise ValueError(
+                    f"unsupported vector propagator gauge {metadata.gauge!r}"
+                )
+            denominator = (
+                _minkowski_square_expression(current_momentum)
+                - mass * mass
+                + imaginary * mass * width
+            )
+            longitudinal = _expr_minkowski_dot(current, current_momentum) / (
+                mass * mass
+            )
+            return tuple(
+                -imaginary
+                * (current[index] - current_momentum[index] * longitudinal)
+                / denominator
+                for index in range(4)
+            )
+        if metadata.kind == "spin2":
+            dimension = self._runtime_parameters.get("dim", 4.0)
+            return _expr_spin2_propagator(
+                tuple(value),
+                tuple(momentum),
+                mass,
+                width,
+                dimension=dimension,
+                massive=metadata.mass_class == "massive",
+            )
+        raise NotImplementedError(
+            f"generic propagator kind {metadata.kind!r} is not implemented"
+        )
+
+    def runtime_parameter_names_for_vertex(self, kind: int) -> tuple[str, ...]:
+        return self._kernel(kind).runtime_parameters
+
+    def runtime_derived_parameter_definitions(self) -> dict[str, str]:
+        return dict(self._runtime_derived_definitions)
+
+    def runtime_derived_parameter_definitions_for(
+        self,
+        names: Sequence[str],
+    ) -> dict[str, str]:
+        return {
+            name: self._runtime_derived_definitions[name]
+            for name in names
+            if name in self._runtime_derived_definitions
+        }
+
+    def runtime_derived_parameter_domains(self) -> dict[str, str]:
+        """Return phases that follow exactly from UFO parameter declarations."""
+
+        return self.runtime_derived_parameter_domains_for(
+            tuple(self._runtime_derived_definitions)
+        )
+
+    def runtime_derived_parameter_domains_for(
+        self,
+        names: Sequence[str],
+    ) -> dict[str, str]:
+        """Return provable phases for only the requested derived couplings."""
+
+        parameter_symbols = {
+            self._model_symbols.symbol(parameter.name): self._runtime_domain_symbol(
+                parameter.name,
+                self._runtime_parameter_domain(parameter.name),
+            )
+            for parameter in self._parameter_records.values()
+        }
+        domains: dict[str, str] = {}
+        for name in names:
+            cached = self._runtime_derived_domain_cache.get(name)
+            if cached is not None:
+                domains[name] = cached
+                continue
+            if name not in self._runtime_derived_definitions:
+                continue
+            parameter = self._parameter_records.get(name)
+            if parameter is not None:
+                domain = self._runtime_parameter_domain(name)
+                self._runtime_derived_domain_cache[name] = domain
+                domains[name] = domain
+                continue
+            expression = self._model_symbols.expression(
+                self._runtime_derived_definitions[name]
+            )
+            for source, replacement in parameter_symbols.items():
+                expression = expression.replace(source, replacement)
+            if expression.is_real():
+                domain = "real"
+            elif (-1j * expression).is_real():
+                domain = "imaginary"
+            else:
+                domain = "complex"
+            self._runtime_derived_domain_cache[name] = domain
+            domains[name] = domain
+        return domains
+
+    def _runtime_parameter_domain(
+        self,
+        name: str,
+        visiting: frozenset[str] = frozenset(),
+    ) -> str:
+        cached = self._runtime_parameter_domain_cache.get(name)
+        if cached is not None:
+            return cached
+        parameter = self._parameter_records[name]
+        if parameter.parameter_type.lower() == "real":
+            domain = "real"
+        elif parameter.nature.lower() != "internal" or name in visiting:
+            domain = "complex"
+        else:
+            expression = self._model_symbols.expression(parameter.resolved_expression)
+            symbols = set(expression.get_all_symbols(False))
+            nested_visiting = visiting | {name}
+            for dependency in self._parameter_records.values():
+                source = self._model_symbols.symbol(dependency.name)
+                if source not in symbols:
+                    continue
+                replacement = self._runtime_domain_symbol(
+                    dependency.name,
+                    self._runtime_parameter_domain(
+                        dependency.name,
+                        nested_visiting,
+                    ),
+                )
+                expression = expression.replace(source, replacement)
+            if expression.is_real():
+                domain = "real"
+            elif (-1j * expression).is_real():
+                domain = "imaginary"
+            else:
+                domain = "complex"
+        self._runtime_parameter_domain_cache[name] = domain
+        return domain
+
+    def _runtime_domain_symbol(self, name: str, domain: str):
+        domain_symbol = symbols.runtime_domain(
+            self.name,
+            name,
+            domain,
+        )
+        return domain_symbol
+
+    def auxiliary_kind(self, particle_id: int) -> str | None:
+        return self._particle_records_by_pdg[int(particle_id)].auxiliary_kind
+
+    def runtime_derived_parameter_defaults(self) -> dict[str, complex]:
+        return self.runtime_derived_parameter_defaults_for(
+            tuple(self._runtime_derived_definitions)
+        )
+
+    def runtime_derived_parameter_defaults_for(
+        self,
+        names: Sequence[str],
+    ) -> dict[str, complex]:
+        substitutions: dict[_sym.Expression, Any] | None = None
+        defaults: dict[str, complex] = {}
+        for name in names:
+            cached = self._runtime_derived_default_cache.get(name)
+            if cached is not None:
+                defaults[name] = cached
+                continue
+            expression = self._runtime_derived_definitions.get(name)
+            if expression is None:
+                continue
+            template = self._runtime_derived_expression_cache.get(name)
+            if template is None:
+                template = self._model_symbols.expression(expression)
+                self._runtime_derived_expression_cache[name] = template
+            if substitutions is None:
+                substitutions = {
+                    self._model_symbols.symbol(parameter_name): value
+                    for parameter_name, value in self._runtime_parameters.items()
+                }
+            try:
+                value = complex(template.evaluate(substitutions))
+            except Exception:
+                value = complex(_replace_symbols(template, substitutions))
+            self._runtime_derived_default_cache[name] = value
+            defaults[name] = value
+        return defaults
+
+    def runtime_parameter_names_for_particle(self, pdg: int) -> tuple[str, ...]:
+        particle = self._particle_records_by_pdg[int(pdg)]
+        custom = self._propagator_record(pdg)
+        if custom is not None and custom.custom:
+            _expression, names = self._custom_propagator_expression(int(pdg))
+            return names
+        return tuple(
+            name
+            for name in (particle.mass, particle.width)
+            if name.upper() != "ZERO"
+            and (
+                name in self.compiled.parameter_defaults
+                or name in self._runtime_derived_definitions
+            )
+        )
+
+    def _custom_propagator_expression(
+        self,
+        particle_id: int,
+    ) -> tuple[_sym.Expression, tuple[str, ...]]:
+        cached = self._custom_propagator_expressions.get(int(particle_id))
+        if cached is not None:
+            return cached
+        record = self._propagator_record(particle_id)
+        if record is None or not record.custom:
+            raise ValueError(f"particle {particle_id} has no custom UFO propagator")
+        spin = self.spin(particle_id)
+        normalized = normalize_lorentz_expression(
+            f"({record.numerator})/({record.denominator})",
+            (spin, spin),
+            model_symbols=self._model_symbols,
+            vertex=False,
+        )
+        expression = self._model_symbols.expression(normalized.expression)
+        for parameter in self._parameter_records.values():
+            if parameter.nature == "external":
+                continue
+            expression = expression.replace(
+                self._model_symbols.symbol(parameter.name),
+                self._model_symbols.expression(parameter.resolved_expression),
+            )
+        expression = _replace_evaluator_constants(expression)
+        symbols = set(expression.get_all_symbols(False))
+        names = tuple(
+            sorted(
+                parameter.name
+                for parameter in self._parameter_records.values()
+                if parameter.nature == "external"
+                and self._model_symbols.symbol(parameter.name) in symbols
+            )
+        )
+        result = expression, names
+        self._custom_propagator_expressions[int(particle_id)] = result
+        return result
+
+    def _custom_propagator_template(
+        self,
+        particle_id: int,
+    ) -> tuple[_sym.Expression, ...]:
+        cached = self._custom_propagator_templates.get(int(particle_id))
+        if cached is not None:
+            return cached
+        expression, _names = self._custom_propagator_expression(particle_id)
+        spin = self.spin(particle_id)
+        components = tuple(
+            symbols.custom_propagator_component(self.name, "input", index)
+            for index in range(self.dimension(particle_id))
+        )
+        momenta = tuple(
+            symbols.custom_propagator_component(self.name, "momentum", index)
+            for index in range(4)
+        )
+        library = _sym.TensorLibrary.hep_lib_atom()
+        representations = _spin_representations(spin)
+        if representations:
+            name = _sym.TensorName(symbols.custom_propagator_tensor_name(self.name))
+            library.register(_sym.Tensor.dense(name(*representations), components))
+            expression *= name(*_spin_slots(spin, 1)).to_expression()
+        else:
+            expression *= components[0]
+        minkowski = _sym.Representation.mink(4)
+        for leg in (1, 2):
+            library.register(
+                _sym.Tensor.dense(
+                    _sym.TensorName(self._model_symbols.ufo_momentum_tensor_name(leg))(
+                        minkowski
+                    ),
+                    momenta,
+                )
+            )
+        axis_labels = _spin_axis_labels(spin, 2)
+        network = _sym.TensorNetwork(
+            _sym.as_tensor(expression) if axis_labels else expression, library
+        )
+        network.execute(library=library)
+        tensor = network.result_tensor(library)
+        tensor_components = _ordered_dense_tensor_components(
+            tensor,
+            axis_labels,
+        ).values
+        expected = self.dimension(particle_id)
+        if len(tensor_components) != expected:
+            raise ValueError(
+                f"custom propagator {particle_id} produced {len(tensor_components)} "
+                f"components, expected {expected}"
+            )
+        template = tuple(
+            _replace_evaluator_constants(_as_expression(component))
+            for component in tensor_components
+        )
+        self._custom_propagator_templates[int(particle_id)] = template
+        return template
+
+    def _evaluate_custom_propagator(
+        self,
+        particle_id: int,
+        value: Sequence[Any],
+        momentum: Sequence[Any],
+    ) -> tuple[Any, ...]:
+        if len(value) != self.dimension(particle_id):
+            raise ValueError(
+                f"custom propagator for {particle_id} expects "
+                f"{self.dimension(particle_id)} current components"
+            )
+        if len(momentum) != 4:
+            raise ValueError("UFO custom propagators require four-momentum components")
+        substitutions = {
+            **{
+                symbols.custom_propagator_component(
+                    self.name,
+                    "input",
+                    index,
+                ): component
+                for index, component in enumerate(value)
+            },
+            **{
+                symbols.custom_propagator_component(
+                    self.name,
+                    "momentum",
+                    index,
+                ): component
+                for index, component in enumerate(momentum)
+            },
+            **{
+                self._model_symbols.symbol(name): self._parameter_value(name)
+                for name in self._custom_propagator_expression(particle_id)[1]
+            },
+        }
+        return tuple(
+            _replace_symbols(component, substitutions)
+            for component in self._custom_propagator_template(particle_id)
+        )
+
+    def runtime_mass_parameter_name(self, pdg: int) -> str | None:
+        name = self._particle_records_by_pdg[int(pdg)].mass
+        return (
+            name
+            if name in self.compiled.parameter_defaults
+            or name in self._runtime_derived_definitions
+            else None
+        )
+
+    def runtime_width_parameter_name(self, pdg: int) -> str | None:
+        name = self._particle_records_by_pdg[int(pdg)].width
+        return (
+            name
+            if name in self.compiled.parameter_defaults
+            or name in self._runtime_derived_definitions
+            else None
+        )
+
+    def runtime_parameter_defaults(self) -> dict[str, tuple[float, float]]:
+        return dict(self.compiled.parameter_defaults)
diff --git a/pyamplicol/src/pyamplicol/models/external_helpers.py b/pyamplicol/src/pyamplicol/models/external_helpers.py
new file mode 100644
index 0000000000..7157fa71c5
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/external_helpers.py
@@ -0,0 +1,151 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from numbers import Number
+from typing import TYPE_CHECKING, Any
+
+from .contracts import (
+    CompiledParameterRecord,
+)
+from .expressions import (
+    _exact_complex_expression,
+    _imaginary_unit_for,
+    _minkowski_square_expression,
+)
+
+if TYPE_CHECKING:
+    pass
+
+from . import compiler_symbolica as _sym
+
+
+def _record_default(record: CompiledParameterRecord) -> complex:
+    if record.value is not None:
+        return complex(record.value[0], record.value[1])
+    return complex(_sym.E(record.resolved_expression).evaluate({}))
+
+
+def _spin_dimension(spin: int) -> int:
+    try:
+        return {-1: 1, 1: 1, 2: 4, 3: 4, 5: 16}[int(spin)]
+    except KeyError as exc:
+        raise ValueError(f"unsupported UFO spin code {spin}") from exc
+
+
+def _chirality_tag(chirality: int) -> str:
+    value = int(chirality)
+    if value < 0:
+        return f"m{abs(value)}"
+    if value > 0:
+        return f"p{value}"
+    return "z"
+
+
+def _replace_symbols(
+    expression: _sym.Expression, substitutions: Mapping[_sym.Expression, Any]
+) -> Any:
+    symbols = set(expression.get_all_symbols(False))
+    replacements = [
+        _sym.Replacement(symbol, value)
+        for symbol, value in substitutions.items()
+        if symbol in symbols
+    ]
+    if not replacements:
+        return expression
+    return expression.replace_multiple(replacements)
+
+
+def _is_numeric(value: Any) -> bool:
+    return isinstance(value, Number)
+
+
+def _is_zero(value: Any) -> bool:
+    if isinstance(value, int | float | complex):
+        return value == 0
+    return isinstance(value, _sym.Expression) and value.to_canonical_string() == "0"
+
+
+def _expr_spin2_propagator(
+    value: Sequence[Any],
+    momentum: Sequence[Any],
+    mass: Any,
+    width: Any,
+    *,
+    dimension: Any,
+    massive: bool,
+) -> tuple[Any, ...]:
+    if len(value) != 16:
+        raise ValueError("spin-2 propagator expects sixteen current components")
+    if len(momentum) != 4:
+        raise ValueError("spin-2 propagator expects four momentum components")
+    tensor = tuple(tuple(value[4 * mu + nu] for nu in range(4)) for mu in range(4))
+    metric = (1, -1, -1, -1)
+    imaginary = _imaginary_unit_for((*value, *momentum, mass, width, dimension))
+    one = 1 if isinstance(imaginary, complex) else _exact_complex_expression(1 + 0j)
+    if not isinstance(imaginary, complex) and isinstance(dimension, float | complex):
+        dimension = _exact_complex_expression(complex(dimension))
+    half = one / 2
+    denominator = (
+        _minkowski_square_expression(momentum) - mass * mass + imaginary * mass * width
+    )
+    if not massive:
+        trace = sum(
+            (metric[index] * tensor[index][index] for index in range(4)),
+            0,
+        )
+        trace_weight = one / (dimension - 2)
+        projected = tuple(
+            half * (tensor[mu][nu] + tensor[nu][mu])
+            - (metric[mu] * trace * trace_weight if mu == nu else 0)
+            for mu in range(4)
+            for nu in range(4)
+        )
+        return tuple(imaginary * component / denominator for component in projected)
+
+    mass_squared = mass * mass
+    first_projected = tuple(
+        tuple(
+            tensor[mu][nu]
+            - momentum[mu]
+            * sum(
+                (
+                    metric[alpha] * momentum[alpha] * tensor[alpha][nu]
+                    for alpha in range(4)
+                ),
+                0,
+            )
+            / mass_squared
+            for nu in range(4)
+        )
+        for mu in range(4)
+    )
+    transverse = tuple(
+        tuple(
+            first_projected[mu][nu]
+            - momentum[nu]
+            * sum(
+                (
+                    metric[beta] * momentum[beta] * first_projected[mu][beta]
+                    for beta in range(4)
+                ),
+                0,
+            )
+            / mass_squared
+            for nu in range(4)
+        )
+        for mu in range(4)
+    )
+    transverse_trace = sum(
+        (metric[index] * transverse[index][index] for index in range(4)),
+        0,
+    )
+    projected = tuple(
+        half * (transverse[mu][nu] + transverse[nu][mu])
+        - ((metric[mu] if mu == nu else 0) - momentum[mu] * momentum[nu] / mass_squared)
+        * transverse_trace
+        / 3
+        for mu in range(4)
+        for nu in range(4)
+    )
+    return tuple(imaginary * component / denominator for component in projected)
diff --git a/pyamplicol/src/pyamplicol/models/external_kernels.py b/pyamplicol/src/pyamplicol/models/external_kernels.py
new file mode 100644
index 0000000000..be93d6b58c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/external_kernels.py
@@ -0,0 +1,444 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+from collections import Counter
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING, Any
+
+from .._internal.physics.symbols import symbols
+from .contracts import (
+    CompiledOrientedKernel,
+)
+
+if TYPE_CHECKING:
+    pass
+
+from . import compiler_symbolica as _sym
+from .external_helpers import (
+    _chirality_tag,
+    _is_numeric,
+    _is_zero,
+    _record_default,
+    _replace_symbols,
+)
+
+
+class ExternalModelKernelMixin:
+    def runtime_parameter_type(self, name: str) -> str:
+        try:
+            return self._parameter_records[str(name)].parameter_type
+        except KeyError as exc:
+            raise KeyError(f"unknown runtime model parameter {name!r}") from exc
+
+    def runtime_normalization_payload(self, dag: Any) -> dict[str, object]:
+        initial_pdgs = tuple(int(pdg) for pdg in dag.process.initial_pdgs)
+        final_pdgs = tuple(int(pdg) for pdg in dag.process.final_pdgs)
+        average_factor = 1
+        for pdg in initial_pdgs:
+            average_factor *= len(self.source_spin_states(pdg))
+            average_factor *= max(1, abs(self.color_rep(pdg)))
+        identical_factor = math.prod(
+            math.factorial(count) for count in Counter(final_pdgs).values()
+        )
+        color_factor = self._external_color_normalization_factor(
+            (*initial_pdgs, *final_pdgs)
+        )
+        return {
+            "color_accuracy": dag.process.color_accuracy,
+            "color_factor": float(color_factor),
+            "average_factor": float(average_factor),
+            "identical_factor": float(identical_factor),
+            "global_coupling_factor": 1.0,
+            "couplings_in_stage_evaluators": True,
+            "coupling_policy": (
+                "UFO coupling expressions are fully included in generated stage "
+                "evaluators; no built-in-SM global coupling factor is applied"
+            ),
+        }
+
+    def _external_color_normalization_factor(self, process: Sequence[int]) -> int:
+        exponent_twice = 0
+        for pdg in process:
+            representation = abs(self.color_rep(int(pdg)))
+            if representation == 8:
+                exponent_twice += 2
+            elif representation == 3:
+                exponent_twice += 1
+            elif representation != 1:
+                raise ValueError(
+                    f"unsupported leading-color representation {representation}"
+                )
+        if exponent_twice % 2:
+            raise ValueError(f"non-integer leading-color exponent for {tuple(process)}")
+        return 3 ** (exponent_twice // 2)
+
+    def _kernel(self, kind: int) -> CompiledOrientedKernel:
+        try:
+            return self._kernels[int(kind)]
+        except KeyError as exc:
+            raise KeyError(f"unknown compiled UFO kernel kind {kind}") from exc
+
+    def _weyl_projection_is_nonzero(
+        self,
+        kind: int,
+        left_chirality: int,
+        right_chirality: int,
+        result_chirality: int,
+    ) -> bool:
+        key = (kind, left_chirality, right_chirality, result_chirality)
+        cached = self._weyl_projection_support.get(key)
+        if cached is not None:
+            return cached
+        kernel = self._kernel(kind)
+        left_pdg = self._particle_records_by_name[kernel.particles[0]].pdg_code
+        right_pdg = self._particle_records_by_name[kernel.particles[1]].pdg_code
+        left = tuple(
+            symbols.weyl_probe(self.name, kind, "left", "component", index)
+            for index in range(self.current_dimension(left_pdg, left_chirality))
+        )
+        right = tuple(
+            symbols.weyl_probe(self.name, kind, "right", "component", index)
+            for index in range(self.current_dimension(right_pdg, right_chirality))
+        )
+        components = self._projected_kernel_components(
+            kernel,
+            left,
+            right,
+            left_chirality=left_chirality,
+            right_chirality=right_chirality,
+            result_chirality=result_chirality,
+            left_momentum=tuple(
+                symbols.weyl_probe(
+                    self.name,
+                    kind,
+                    "left",
+                    "momentum",
+                    index,
+                )
+                for index in range(4)
+            ),
+            right_momentum=tuple(
+                symbols.weyl_probe(
+                    self.name,
+                    kind,
+                    "right",
+                    "momentum",
+                    index,
+                )
+                for index in range(4)
+            ),
+        )
+        supported = any(not _is_zero(component) for component in components)
+        self._weyl_projection_support[key] = supported
+        return supported
+
+    def _projected_kernel_components(
+        self,
+        kernel: CompiledOrientedKernel,
+        left: Sequence[Any],
+        right: Sequence[Any],
+        *,
+        left_chirality: int,
+        right_chirality: int,
+        result_chirality: int,
+        left_momentum: Sequence[Any],
+        right_momentum: Sequence[Any],
+        runtime_parameter_values: Mapping[str, Any] | None = None,
+    ) -> tuple[Any, ...]:
+        left_pdg = self._particle_records_by_name[kernel.particles[0]].pdg_code
+        right_pdg = self._particle_records_by_name[kernel.particles[1]].pdg_code
+        result_pdg = self._particle_records_by_name[kernel.particles[2]].pdg_code
+        full_left = self._embed_weyl_current(left_pdg, left_chirality, left)
+        full_right = self._embed_weyl_current(right_pdg, right_chirality, right)
+        parameter_values = (
+            {name: self._parameter_value(name) for name in kernel.runtime_parameters}
+            if runtime_parameter_values is None
+            else dict(runtime_parameter_values)
+        )
+        substitutions: dict[_sym.Expression, Any] = {}
+        for index, value in enumerate(full_left):
+            substitutions[
+                self._model_symbols.kernel_component(kernel.kind, "left", index)
+            ] = value
+        for index, value in enumerate(full_right):
+            substitutions[
+                self._model_symbols.kernel_component(kernel.kind, "right", index)
+            ] = value
+        for index, value in enumerate(left_momentum):
+            substitutions[
+                self._model_symbols.kernel_momentum(kernel.kind, "left", index)
+            ] = value
+        for index, value in enumerate(right_momentum):
+            substitutions[
+                self._model_symbols.kernel_momentum(kernel.kind, "right", index)
+            ] = value
+        for name, value in parameter_values.items():
+            substitutions[symbols.runtime_model_parameter(self.name, name)] = value
+        templates = self._kernel_component_expressions(kernel)
+        if all(_is_numeric(value) for value in substitutions.values()):
+            try:
+                components = tuple(
+                    complex(template.evaluate(substitutions)) for template in templates
+                )
+            except Exception:
+                components = tuple(
+                    _replace_symbols(template, substitutions) for template in templates
+                )
+        else:
+            components = tuple(
+                _replace_symbols(template, substitutions) for template in templates
+            )
+        if not self.is_chiral_eligible(result_pdg):
+            return components
+        if result_chirality == 0:
+            return components
+        if result_chirality == 1:
+            return components[2:4]
+        if result_chirality == -1:
+            return components[0:2]
+        raise ValueError("a projected Weyl result requires chirality -1, 0, or +1")
+
+    def _kernel_function_component_calls(
+        self,
+        kernel: CompiledOrientedKernel,
+        left: Sequence[Any],
+        right: Sequence[Any],
+        *,
+        left_chirality: int,
+        right_chirality: int,
+        result_chirality: int,
+        left_momentum: Sequence[Any],
+        right_momentum: Sequence[Any],
+        runtime_parameter_values: Mapping[str, Any],
+    ) -> tuple[Any, ...]:
+        key = (
+            int(kernel.kind),
+            int(left_chirality),
+            int(right_chirality),
+            int(result_chirality),
+        )
+        function_specs = self._kernel_function_specs.get(key)
+        if function_specs is None:
+            function_specs = self._define_kernel_component_functions(
+                kernel,
+                left_dimension=len(left),
+                right_dimension=len(right),
+                left_chirality=left_chirality,
+                right_chirality=right_chirality,
+                result_chirality=result_chirality,
+            )
+            self._kernel_function_specs[key] = function_specs
+        arguments = (
+            *left,
+            *right,
+            *left_momentum,
+            *right_momentum,
+            *(runtime_parameter_values[name] for name in kernel.runtime_parameters),
+        )
+        return tuple(
+            function(*(arguments[index] for index in argument_indices))
+            for function, argument_indices in function_specs
+        )
+
+    def _define_kernel_component_functions(
+        self,
+        kernel: CompiledOrientedKernel,
+        *,
+        left_dimension: int,
+        right_dimension: int,
+        left_chirality: int,
+        right_chirality: int,
+        result_chirality: int,
+    ) -> tuple[tuple[_sym.Expression, tuple[int, ...]], ...]:
+        key_tag = "_".join(
+            (
+                str(int(kernel.kind)),
+                _chirality_tag(left_chirality),
+                _chirality_tag(right_chirality),
+                _chirality_tag(result_chirality),
+            )
+        )
+        formal_left = tuple(
+            symbols.kernel_function_argument(
+                self.name,
+                key_tag,
+                "left",
+                index,
+            )
+            for index in range(left_dimension)
+        )
+        formal_right = tuple(
+            symbols.kernel_function_argument(
+                self.name,
+                key_tag,
+                "right",
+                index,
+            )
+            for index in range(right_dimension)
+        )
+        formal_left_momentum = tuple(
+            symbols.kernel_function_argument(
+                self.name,
+                key_tag,
+                "left_momentum",
+                index,
+            )
+            for index in range(4)
+        )
+        formal_right_momentum = tuple(
+            symbols.kernel_function_argument(
+                self.name,
+                key_tag,
+                "right_momentum",
+                index,
+            )
+            for index in range(4)
+        )
+        formal_parameters = {
+            name: symbols.kernel_function_argument(
+                self.name,
+                key_tag,
+                "parameter",
+                index,
+            )
+            for index, name in enumerate(kernel.runtime_parameters)
+        }
+        formal_arguments = (
+            *formal_left,
+            *formal_right,
+            *formal_left_momentum,
+            *formal_right_momentum,
+            *(formal_parameters[name] for name in kernel.runtime_parameters),
+        )
+        components = self._projected_kernel_components(
+            kernel,
+            formal_left,
+            formal_right,
+            left_chirality=left_chirality,
+            right_chirality=right_chirality,
+            result_chirality=result_chirality,
+            left_momentum=formal_left_momentum,
+            right_momentum=formal_right_momentum,
+            runtime_parameter_values=formal_parameters,
+        )
+        coupling_expression = self._resolved_kernel_coupling_expression(
+            kernel,
+            formal_parameters,
+        )
+        bodies = tuple(component * coupling_expression for component in components)
+        functions = tuple(
+            symbols.kernel_function_component(self.name, key_tag, index)
+            for index in range(len(bodies))
+        )
+        specs: list[tuple[_sym.Expression, tuple[int, ...]]] = []
+        for function, body in zip(functions, bodies, strict=True):
+            body_symbols = set(body.get_all_symbols(False))
+            argument_indices = tuple(
+                index
+                for index, argument in enumerate(formal_arguments)
+                if argument in body_symbols
+            )
+            used_arguments = tuple(
+                formal_arguments[index] for index in argument_indices
+            )
+            self._symbolica_kernel_functions[(function, used_arguments)] = body
+            specs.append((function, argument_indices))
+        return tuple(specs)
+
+    def _kernel_component_expressions(
+        self,
+        kernel: CompiledOrientedKernel,
+    ) -> tuple[_sym.Expression, ...]:
+        cached = self._kernel_component_expression_cache.get(kernel.kind)
+        if cached is None:
+            cached = tuple(
+                _sym.E(component) for component in kernel.component_expressions
+            )
+            self._kernel_component_expression_cache[kernel.kind] = cached
+        return cached
+
+    def _resolved_kernel_coupling_expression(
+        self,
+        kernel: CompiledOrientedKernel,
+        runtime_parameter_values: Mapping[str, Any],
+        *,
+        numeric: bool = False,
+    ) -> Any:
+        template = self._kernel_coupling_expression_cache.get(kernel.kind)
+        if template is None:
+            template = _sym.E(kernel.coupling_expression)
+            # Keep the colour-flow normalization algebraic until evaluation.
+            # Putting sqrt(2) in a binary64 recurrence weight would freeze its
+            # rounding error even when evaluating the process at high precision.
+            power = kernel.lc_color_normalization_power
+            if power:
+                template *= _sym.E(f"2^(-{power}/2)")
+            self._kernel_coupling_expression_cache[kernel.kind] = template
+        substitutions = {
+            symbols.runtime_model_parameter(self.name, name): value
+            for name, value in runtime_parameter_values.items()
+        }
+        if numeric and all(_is_numeric(value) for value in substitutions.values()):
+            try:
+                return complex(template.evaluate(substitutions))
+            except Exception:
+                pass
+        return _replace_symbols(template, substitutions)
+
+    def _embed_weyl_current(
+        self,
+        particle_id: int,
+        chirality: int,
+        values: Sequence[Any],
+    ) -> tuple[Any, ...]:
+        components = tuple(values)
+        if not self.is_chiral_eligible(particle_id):
+            return components
+        if chirality == 0:
+            if len(components) != 4:
+                raise ValueError("a full Dirac input must have four components")
+            return components
+        if len(components) != 2:
+            raise ValueError("a projected Weyl input must have two components")
+        if chirality == 1:
+            return (components[0], components[1], 0.0, 0.0)
+        if chirality == -1:
+            return (0.0, 0.0, components[0], components[1])
+        raise ValueError("a projected Weyl input requires chirality -1, 0, or +1")
+
+    def _propagator_record(self, particle_id: int):
+        name = self._particle_records_by_pdg[int(particle_id)].name
+        return self._propagator_records_by_particle_name.get(name)
+
+    def _parameter_default(self, name: str) -> complex:
+        if name.upper() == "ZERO":
+            return 0.0 + 0.0j
+        record = self._parameter_records.get(name)
+        if record is None:
+            raise ValueError(f"model parameter {name!r} is not defined")
+        return _record_default(record)
+
+    def _parameter_value(self, name: str) -> Any:
+        if name in self._runtime_parameters:
+            return self._runtime_parameters[name]
+        definition = self._runtime_derived_definitions.get(name)
+        if definition is not None:
+            return _replace_symbols(
+                _sym.E(definition),
+                {
+                    self._model_symbols.symbol(parameter_name): value
+                    for parameter_name, value in self._runtime_parameters.items()
+                    if not parameter_name.startswith("derived_coupling_")
+                },
+            )
+        return self._parameter_default(name)
+
+    def _real_parameter_value(self, name: str, *, field: str) -> Any:
+        value = self._parameter_value(name)
+        if isinstance(value, int | float | complex):
+            numeric = complex(value)
+            if numeric.imag != 0.0:
+                raise ValueError(f"particle {field} parameter {name!r} is not real")
+            return numeric.real
+        return value
diff --git a/pyamplicol/src/pyamplicol/models/external_symmetries.py b/pyamplicol/src/pyamplicol/models/external_symmetries.py
new file mode 100644
index 0000000000..1eaf90181a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/external_symmetries.py
@@ -0,0 +1,876 @@
+# SPDX-License-Identifier: 0BSD
+"""Algebraic symmetry certificates for compiled external models.
+
+The certificates in this module are deliberately derived from normalized
+Lorentz/color tensors and exact coupling relations. UFO particle names,
+vertex names, PDG assignments, and coupling-order labels are not proof input.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from collections import defaultdict
+from dataclasses import dataclass
+
+from .._internal.physics.symbols import ModelSymbolRegistry, symbols
+from . import compiler_symbolica as _sym
+from .contracts import (
+    CompiledCouplingRecord,
+    CompiledModelIR,
+    CompiledOrientedKernel,
+    CompiledParameterRecord,
+    CompiledParticleRecord,
+    CompiledPropagatorRecord,
+    CompiledVertexTerm,
+)
+from .tensors import (
+    _constant_expression_ratio,
+    classify_trilinear_color_expression,
+    normalize_color_expression,
+    normalize_lorentz_expression,
+)
+
+_YM_THREE_VECTOR = (
+    "-UFO::Metric(UFO::idx(1,1),UFO::idx(1,2))"
+    "*UFO::P(UFO::idx(1,3),UFO::idx(1,2))"
+    "-UFO::Metric(UFO::idx(1,1),UFO::idx(1,3))"
+    "*UFO::P(UFO::idx(1,2),UFO::idx(1,1))"
+    "-UFO::Metric(UFO::idx(1,2),UFO::idx(1,3))"
+    "*UFO::P(UFO::idx(1,1),UFO::idx(1,3))"
+    "+UFO::Metric(UFO::idx(1,1),UFO::idx(1,2))"
+    "*UFO::P(UFO::idx(1,3),UFO::idx(1,1))"
+    "+UFO::Metric(UFO::idx(1,1),UFO::idx(1,3))"
+    "*UFO::P(UFO::idx(1,2),UFO::idx(1,3))"
+    "+UFO::Metric(UFO::idx(1,2),UFO::idx(1,3))"
+    "*UFO::P(UFO::idx(1,1),UFO::idx(1,2))"
+)
+
+_YM_FOUR_VECTOR_BASIS = (
+    (
+        "UFO::f(-1,1,2)*UFO::f(3,4,-1)",
+        "-UFO::Metric(UFO::idx(1,1),UFO::idx(1,3))"
+        "*UFO::Metric(UFO::idx(1,2),UFO::idx(1,4))"
+        "+UFO::Metric(UFO::idx(1,1),UFO::idx(1,4))"
+        "*UFO::Metric(UFO::idx(1,2),UFO::idx(1,3))",
+    ),
+    (
+        "UFO::f(-1,1,3)*UFO::f(2,4,-1)",
+        "-UFO::Metric(UFO::idx(1,1),UFO::idx(1,2))"
+        "*UFO::Metric(UFO::idx(1,3),UFO::idx(1,4))"
+        "+UFO::Metric(UFO::idx(1,1),UFO::idx(1,4))"
+        "*UFO::Metric(UFO::idx(1,2),UFO::idx(1,3))",
+    ),
+    (
+        "UFO::f(-1,1,4)*UFO::f(2,3,-1)",
+        "-UFO::Metric(UFO::idx(1,1),UFO::idx(1,2))"
+        "*UFO::Metric(UFO::idx(1,3),UFO::idx(1,4))"
+        "+UFO::Metric(UFO::idx(1,1),UFO::idx(1,3))"
+        "*UFO::Metric(UFO::idx(1,2),UFO::idx(1,4))",
+    ),
+)
+
+_CONTACT_ORIGIN = re.compile(r"^ufo-contact:(?P<term>[0-9]+):")
+_CONTRACTED_INDEX = re.compile(
+    r"^ufo_(?P<family>[cls])_dummy_(?P<label>[0-9]+)"
+    r"(?:_(?P<representation>[A-Za-z0-9_]+))?$"
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ExternalSymmetryCertificates:
+    """Fail-closed model-level certificates consumed by DAG generation."""
+
+    parity_kernel_kinds: frozenset[int]
+    yang_mills_kernel_kinds: frozenset[int]
+    yang_mills_adjoint_names: frozenset[str]
+    adjoint_current_reflection_phases: tuple[
+        tuple[int, tuple[float, float]], ...
+    ]
+    parity_kernel_digests: tuple[tuple[int, str], ...]
+    yang_mills_kernel_digests: tuple[tuple[int, str], ...]
+    yang_mills_adjoint_digests: tuple[tuple[str, str], ...]
+    adjoint_current_reflection_digests: tuple[tuple[int, str], ...]
+
+    def __post_init__(self) -> None:
+        expected = (
+            (self.parity_kernel_kinds, self.parity_kernel_digests),
+            (self.yang_mills_kernel_kinds, self.yang_mills_kernel_digests),
+            (self.yang_mills_adjoint_names, self.yang_mills_adjoint_digests),
+            (
+                frozenset(
+                    kind for kind, _phase in self.adjoint_current_reflection_phases
+                ),
+                self.adjoint_current_reflection_digests,
+            ),
+        )
+        for selectors, digests in expected:
+            if len(digests) != len(selectors) or {
+                selector for selector, _digest in digests
+            } != set(selectors):
+                raise ValueError("symmetry certificate digest selectors are incomplete")
+            if any(
+                len(digest) != 64
+                or any(character not in "0123456789abcdef" for character in digest)
+                for _selector, digest in digests
+            ):
+                raise ValueError("symmetry certificate contains an invalid SHA-256")
+
+
+def derive_external_symmetry_certificates(
+    ir: CompiledModelIR,
+) -> ExternalSymmetryCertificates:
+    """Recognize exact vectorlike and Yang--Mills sectors in compiled IR."""
+
+    _sym._ensure_symbolica()
+    model_symbols = symbols.model(ir.name)
+    particles = {particle.name: particle for particle in ir.particles}
+    parameters = {parameter.name: parameter for parameter in ir.parameters}
+    propagators = {propagator.name: propagator for propagator in ir.propagators}
+    couplings = {coupling.name: coupling for coupling in ir.couplings}
+
+    ym_three_reference = normalize_lorentz_expression(
+        _YM_THREE_VECTOR,
+        (3, 3, 3),
+        model_symbols=model_symbols,
+    ).expression
+    ym_three_color_reference = normalize_color_expression(
+        "UFO::f(1,2,3)",
+        (8, 8, 8),
+    ).expression
+    ym_cubic_terms: dict[int, str] = {}
+    ym_coupling_by_adjoint: dict[str, _sym.Expression] = {}
+    vectorlike_terms: set[int] = set()
+
+    for term in ir.vertex_terms:
+        records = tuple(particles[name] for name in term.particles)
+        ym_coupling = _yang_mills_cubic_effective_coupling(
+            term,
+            records,
+            couplings=couplings,
+            ym_three_color_reference=ym_three_color_reference,
+            ym_three_reference=ym_three_reference,
+            parameters=parameters,
+            propagators=propagators,
+        )
+        if ym_coupling is not None:
+            adjoint_name = records[0].name
+            ym_cubic_terms[term.id] = adjoint_name
+            previous = ym_coupling_by_adjoint.get(adjoint_name, _sym.E("0"))
+            ym_coupling_by_adjoint[adjoint_name] = (
+                previous + ym_coupling
+            ).expand()
+            continue
+        if _is_vectorlike_gauge_term(
+            term,
+            records,
+            model_symbols=model_symbols,
+            parameters=parameters,
+            propagators=propagators,
+        ):
+            vectorlike_terms.add(term.id)
+
+    quartic_groups = _certified_yang_mills_quartic_groups(
+        ir,
+        particles,
+        couplings,
+        ym_coupling_by_adjoint,
+        model_symbols=model_symbols,
+        parameters=parameters,
+        propagators=propagators,
+    )
+    ym_quartic_terms = {
+        term_id
+        for term_ids in quartic_groups.values()
+        for term_id in term_ids
+    }
+    candidate_adjoint_names = frozenset(
+        name
+        for name in ym_coupling_by_adjoint
+        if name in quartic_groups
+    )
+
+    parity_kinds: set[int] = set()
+    yang_mills_kinds: set[int] = set()
+    for kernel in ir.oriented_kernels:
+        term_ids = frozenset(kernel.term_ids or (kernel.term_id,))
+        if term_ids and term_ids <= vectorlike_terms:
+            parity_kinds.add(kernel.kind)
+        if term_ids and term_ids <= set(ym_cubic_terms):
+            names = {ym_cubic_terms[term_id] for term_id in term_ids}
+            if names <= candidate_adjoint_names:
+                parity_kinds.add(kernel.kind)
+                yang_mills_kinds.add(kernel.kind)
+                continue
+        if term_ids and term_ids <= ym_quartic_terms:
+            group_names = {
+                name
+                for name, group_term_ids in quartic_groups.items()
+                if term_ids <= group_term_ids
+            }
+            if group_names:
+                parity_kinds.add(kernel.kind)
+                yang_mills_kinds.add(kernel.kind)
+                continue
+
+        origin_term_id = _contact_origin_term_id(kernel.particles, particles)
+        if origin_term_id is not None and origin_term_id in ym_quartic_terms:
+            parity_kinds.add(kernel.kind)
+            yang_mills_kinds.add(kernel.kind)
+
+    reflection_phases = _certified_two_source_adjoint_current_reflections(
+        ir,
+        particles,
+        parameters,
+        model_symbols=model_symbols,
+    )
+    complete_adjoint_names = frozenset(
+        name
+        for name in candidate_adjoint_names
+        if _yang_mills_sector_is_closed(
+            name,
+            ir.oriented_kernels,
+            yang_mills_kernel_kinds=frozenset(yang_mills_kinds),
+        )
+    )
+    kernels_by_kind = {kernel.kind: kernel for kernel in ir.oriented_kernels}
+    kernel_digests = {
+        kind: _kernel_contract_digest(kernels_by_kind[kind])
+        for kind in parity_kinds | yang_mills_kinds | set(reflection_phases)
+    }
+    yang_mills_term_ids_by_name = {
+        name: frozenset(
+            {
+                term_id
+                for term_id, term_name in ym_cubic_terms.items()
+                if term_name == name
+            }
+            | set(quartic_groups.get(name, ()))
+        )
+        for name in complete_adjoint_names
+    }
+    adjoint_digests = {
+        name: _adjoint_sector_contract_digest(
+            name,
+            ir,
+            particle=particles[name],
+            propagator=(
+                None
+                if particles[name].propagator is None
+                else propagators.get(particles[name].propagator)
+            ),
+            kernel_digests=kernel_digests,
+            kernel_kinds=frozenset(yang_mills_kinds),
+            term_ids=yang_mills_term_ids_by_name[name],
+        )
+        for name in complete_adjoint_names
+    }
+
+    return ExternalSymmetryCertificates(
+        parity_kernel_kinds=frozenset(parity_kinds),
+        yang_mills_kernel_kinds=frozenset(yang_mills_kinds),
+        yang_mills_adjoint_names=complete_adjoint_names,
+        adjoint_current_reflection_phases=tuple(sorted(reflection_phases.items())),
+        parity_kernel_digests=tuple(
+            (kind, kernel_digests[kind]) for kind in sorted(parity_kinds)
+        ),
+        yang_mills_kernel_digests=tuple(
+            (kind, kernel_digests[kind]) for kind in sorted(yang_mills_kinds)
+        ),
+        yang_mills_adjoint_digests=tuple(sorted(adjoint_digests.items())),
+        adjoint_current_reflection_digests=tuple(
+            (kind, kernel_digests[kind]) for kind in sorted(reflection_phases)
+        ),
+    )
+
+
+def _contract_digest(payload: object) -> str:
+    encoded = json.dumps(
+        payload,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _kernel_contract_digest(kernel: CompiledOrientedKernel) -> str:
+    """Bind a theorem to the exact oriented executable kernel contract."""
+
+    return _contract_digest(
+        {
+            "kind": kernel.kind,
+            "term_ids": list(kernel.term_ids or (kernel.term_id,)),
+            "particles": list(kernel.particles),
+            "source_particle_legs": list(kernel.source_particle_legs),
+            "component_expressions": list(kernel.component_expressions),
+            "coupling_expression": kernel.coupling_expression,
+            "coupling_orders": [list(item) for item in kernel.coupling_orders],
+            "runtime_parameters": list(kernel.runtime_parameters),
+            "color_expression": kernel.color_expression,
+            "color_projection_structure": kernel.color_projection_structure,
+            "color_projection_coefficient": kernel.color_projection_coefficient,
+            "lc_color_normalization_power": kernel.lc_color_normalization_power,
+            "input_ordering_ids": list(kernel.input_ordering_ids),
+            "output_ordering_id": kernel.output_ordering_id,
+        }
+    )
+
+
+def _adjoint_sector_contract_digest(
+    name: str,
+    ir: CompiledModelIR,
+    *,
+    particle: CompiledParticleRecord,
+    propagator: CompiledPropagatorRecord | None,
+    kernel_digests: dict[int, str],
+    kernel_kinds: frozenset[int],
+    term_ids: frozenset[int],
+) -> str:
+    """Bind global Yang--Mills theorems to source, kernel, and color data."""
+
+    current_orderings = tuple(
+        ordering.to_json_dict()
+        for ordering in ir.current_orderings
+        if ordering.particle == name
+    )
+    terms = tuple(
+        {
+            "id": term.id,
+            "particles": list(term.particles),
+            "tensor_product_signature": _tensor_product_signature(
+                term.color_expression,
+                term.lorentz_expression,
+            ),
+            "coupling_expression": term.coupling_expression,
+            "coupling_orders": [list(item) for item in term.coupling_orders],
+            "backend": term.backend,
+            "lc_color_normalization_power": term.lc_color_normalization_power,
+            "source_ordering_ids": list(term.source_ordering_ids),
+        }
+        for term in ir.vertex_terms
+        if term.id in term_ids
+    )
+    kernels = tuple(
+        (kernel.kind, kernel_digests[kernel.kind])
+        for kernel in ir.oriented_kernels
+        if kernel.kind in kernel_kinds and name in kernel.particles
+    )
+    return _contract_digest(
+        {
+            "particle": {
+                "name": particle.name,
+                "antiname": particle.antiname,
+                "spin": particle.spin,
+                "color": particle.color,
+                "mass": particle.mass,
+                "width": particle.width,
+                "quantum_numbers": [list(item) for item in particle.quantum_numbers],
+                "ghost_number": particle.ghost_number,
+                "propagating": particle.propagating,
+                "goldstoneboson": particle.goldstoneboson,
+                "component_dimension": particle.component_dimension,
+                "auxiliary_kind": particle.auxiliary_kind,
+                "statistics": particle.statistics,
+                "wavefunction_family": particle.wavefunction_family,
+                "color_role": particle.color_role,
+                "self_conjugate": particle.self_conjugate,
+                "source_orientation": particle.source_orientation,
+            },
+            "propagator": (
+                None
+                if propagator is None
+                else {
+                    "numerator": propagator.numerator,
+                    "denominator": propagator.denominator,
+                    "custom": propagator.custom,
+                }
+            ),
+            "current_orderings": current_orderings,
+            "vertex_terms": terms,
+            "oriented_kernels": kernels,
+        }
+    )
+
+
+def _yang_mills_sector_is_closed(
+    source_name: str,
+    kernels: tuple[CompiledOrientedKernel, ...],
+    *,
+    yang_mills_kernel_kinds: frozenset[int],
+) -> bool:
+    """Require every tree-reachable interaction to remain Yang--Mills.
+
+    A certified cubic and quartic tensor is insufficient for global helicity
+    and trace-reflection theorems when the same adjoint source can also produce
+    another state.  Follow the trivalent compiled theory from two reachable
+    currents, including synthetic contact auxiliaries, and fail closed as soon
+    as any reachable kernel lacks the exact Yang--Mills certificate.
+    """
+
+    reachable = {source_name}
+    changed = True
+    while changed:
+        changed = False
+        for kernel in kernels:
+            left_name, right_name, result_name = kernel.particles
+            if left_name not in reachable or right_name not in reachable:
+                continue
+            if kernel.kind not in yang_mills_kernel_kinds:
+                return False
+            if result_name not in reachable:
+                reachable.add(result_name)
+                changed = True
+    return True
+
+
+def _yang_mills_cubic_effective_coupling(
+    term: CompiledVertexTerm,
+    particles: tuple[CompiledParticleRecord, ...],
+    *,
+    couplings: dict[str, CompiledCouplingRecord],
+    ym_three_color_reference: str,
+    ym_three_reference: str,
+    parameters: dict[str, CompiledParameterRecord],
+    propagators: dict[str, CompiledPropagatorRecord],
+) -> _sym.Expression | None:
+    if len(particles) != 3 or len({particle.name for particle in particles}) != 1:
+        return None
+    particle = particles[0]
+    if not _is_compile_time_massless_adjoint_vector(
+        particle,
+        parameters,
+        propagators,
+    ):
+        return None
+    structure, _coefficient = classify_trilinear_color_expression(
+        term.color_expression,
+        term.color_source,
+        tuple(item.color for item in particles),
+    )
+    if structure != "adjoint-structure-constant":
+        return None
+    color_ratio = _constant_expression_ratio_exact(
+        _sym.E(term.color_expression),
+        _sym.E(ym_three_color_reference),
+    )
+    lorentz_ratio = _constant_expression_ratio_exact(
+        _sym.E(term.lorentz_expression),
+        _sym.E(ym_three_reference),
+    )
+    coupling = couplings.get(term.coupling)
+    if color_ratio is None or lorentz_ratio is None or coupling is None:
+        return None
+    effective = (
+        _sym.E(coupling.expression) * color_ratio * lorentz_ratio
+    ).expand()
+    return None if effective == _sym.E("0") else effective
+
+
+def _is_vectorlike_gauge_term(
+    term: CompiledVertexTerm,
+    particles: tuple[CompiledParticleRecord, ...],
+    *,
+    model_symbols: ModelSymbolRegistry,
+    parameters: dict[str, CompiledParameterRecord],
+    propagators: dict[str, CompiledPropagatorRecord],
+) -> bool:
+    if len(particles) != 3:
+        return False
+    vector_legs = tuple(
+        index for index, particle in enumerate(particles) if particle.spin == 3
+    )
+    fermion_legs = tuple(
+        index for index, particle in enumerate(particles) if particle.spin == 2
+    )
+    if len(vector_legs) != 1 or len(fermion_legs) != 2:
+        return False
+    vector = particles[vector_legs[0]]
+    left_fermion, right_fermion = (particles[index] for index in fermion_legs)
+    if not _is_compile_time_massless_adjoint_vector(
+        vector,
+        parameters,
+        propagators,
+    ):
+        return False
+    if sorted((left_fermion.color, right_fermion.color)) != [-3, 3]:
+        return False
+    if (
+        left_fermion.antiname != right_fermion.name
+        or right_fermion.antiname != left_fermion.name
+    ):
+        return False
+    structure, _coefficient = classify_trilinear_color_expression(
+        term.color_expression,
+        term.color_source,
+        tuple(item.color for item in particles),
+    )
+    if structure != "fundamental-generator":
+        return False
+
+    vector_leg = vector_legs[0] + 1
+    references = tuple(
+        normalize_lorentz_expression(
+            "UFO::Gamma("
+            f"UFO::idx(1,{vector_leg}),"
+            f"UFO::idx(1,{output_leg + 1}),"
+            f"UFO::idx(1,{input_leg + 1}))",
+            tuple(particle.spin for particle in particles),
+            model_symbols=model_symbols,
+        ).expression
+        for output_leg, input_leg in (
+            fermion_legs,
+            tuple(reversed(fermion_legs)),
+        )
+    )
+    return any(
+        _expressions_are_constant_multiples(term.lorentz_expression, reference)
+        for reference in references
+    )
+
+
+def _certified_yang_mills_quartic_groups(
+    ir: CompiledModelIR,
+    particles: dict[str, CompiledParticleRecord],
+    couplings: dict[str, CompiledCouplingRecord],
+    cubic_couplings: dict[str, _sym.Expression],
+    *,
+    model_symbols: ModelSymbolRegistry,
+    parameters: dict[str, CompiledParameterRecord],
+    propagators: dict[str, CompiledPropagatorRecord],
+) -> dict[str, frozenset[int]]:
+    references = tuple(
+        (
+            normalize_color_expression(color, (8, 8, 8, 8)).expression,
+            normalize_lorentz_expression(
+                lorentz,
+                (3, 3, 3, 3),
+                model_symbols=model_symbols,
+            ).expression,
+        )
+        for color, lorentz in _YM_FOUR_VECTOR_BASIS
+    )
+    terms_by_particles: dict[
+        tuple[str, ...], list[CompiledVertexTerm]
+    ] = defaultdict(list)
+    for term in ir.vertex_terms:
+        if len(term.particles) == 4:
+            terms_by_particles[term.particles].append(term)
+
+    certified: dict[str, frozenset[int]] = {}
+    for particle_names, terms in terms_by_particles.items():
+        if len(set(particle_names)) != 1:
+            continue
+        name = particle_names[0]
+        particle = particles[name]
+        cubic = cubic_couplings.get(name)
+        if cubic is None or not _is_compile_time_massless_adjoint_vector(
+            particle,
+            parameters,
+            propagators,
+        ):
+            continue
+        quartic_coefficients = [_sym.E("0") for _ in references]
+        valid = True
+        for term in terms:
+            matches = tuple(
+                (index, ratio)
+                for index, (color_reference, lorentz_reference) in enumerate(
+                    references
+                )
+                if (
+                    ratio := _tensor_product_ratio(
+                        term.color_expression,
+                        term.lorentz_expression,
+                        color_reference,
+                        lorentz_reference,
+                    )
+                )
+                is not None
+            )
+            coupling = couplings.get(term.coupling)
+            if len(matches) != 1 or coupling is None:
+                valid = False
+                break
+            index, ratio = matches[0]
+            quartic_coefficients[index] = (
+                quartic_coefficients[index]
+                + _sym.E(coupling.expression) * ratio
+            ).expand()
+        if not valid or not _has_yang_mills_coupling_relation(
+            cubic,
+            tuple(quartic_coefficients),
+        ):
+            continue
+        certified[name] = frozenset(term.id for term in terms)
+    return certified
+
+
+def _has_yang_mills_coupling_relation(
+    cubic: _sym.Expression,
+    quartic_coefficients: tuple[_sym.Expression, ...],
+) -> bool:
+    if cubic == _sym.E("0") or not quartic_coefficients:
+        return False
+    expected = (_sym.E("1i") * cubic**2).expand()
+    return all(
+        (coefficient - expected).cancel().expand() == _sym.E("0")
+        for coefficient in quartic_coefficients
+    )
+
+
+def _constant_expression_ratio_exact(
+    target: _sym.Expression,
+    reference: _sym.Expression,
+) -> _sym.Expression | None:
+    """Return an exact scalar tensor ratio without converting through float."""
+
+    if reference == _sym.E("0"):
+        return None
+    ratio = (target / reference).cancel()
+    if ratio.get_all_symbols(False):
+        return None
+    if (target - ratio * reference).expand() != _sym.E("0"):
+        return None
+    return ratio
+
+
+def _tensor_product_ratio(
+    color: str,
+    lorentz: str,
+    reference_color: str,
+    reference_lorentz: str,
+) -> _sym.Expression | None:
+    _sym._ensure_symbolica()
+    target_candidates = _canonical_tensor_product_expressions(
+        (_sym.E(color) * _sym.E(lorentz)).expand()
+    )
+    reference_candidates = _canonical_tensor_product_expressions(
+        (_sym.E(reference_color) * _sym.E(reference_lorentz)).expand()
+    )
+    for target in target_candidates:
+        for reference in reference_candidates:
+            ratio = _constant_expression_ratio_exact(target, reference)
+            if ratio is not None and ratio != _sym.E("0"):
+                return ratio
+    return None
+
+
+def _tensor_product_signature(color: str, lorentz: str) -> str:
+    _sym._ensure_symbolica()
+    expression = (_sym.E(color) * _sym.E(lorentz)).expand()
+    return min(
+        str(candidate.to_canonical_string())
+        for candidate in _canonical_tensor_product_expressions(expression)
+    )
+
+
+def _canonical_tensor_product_expressions(
+    expression: _sym.Expression,
+) -> tuple[_sym.Expression, ...]:
+    groups: dict[tuple[str, str], list[_sym.Expression]] = defaultdict(list)
+    for symbol in expression.get_all_symbols():
+        match = _CONTRACTED_INDEX.fullmatch(str(symbol))
+        if match is None:
+            continue
+        key = (match.group("family"), match.group("representation") or "index")
+        groups[key].append(symbol)
+    if not groups:
+        return (expression,)
+
+    contracted_indices: list[tuple[_sym.Expression, int]] = []
+    group_contracts: dict[int, tuple[str, str]] = {}
+    for group, ((family, representation), source_symbols) in enumerate(
+        sorted(groups.items())
+    ):
+        group_contracts[group] = (family, representation)
+        contracted_indices.extend(
+            (symbol, group)
+            for symbol in source_symbols
+        )
+
+    canonical, external, dummy = expression.canonize_tensors(contracted_indices)
+    if external:
+        raise ValueError(
+            "contracted UFO tensor indices unexpectedly became external during "
+            "canonization"
+        )
+    group_offsets: dict[int, int] = defaultdict(int)
+    for source, group_expression in dummy:
+        group = int(str(group_expression))
+        family, representation = group_contracts[group]
+        target = symbols.canonical_tensor_index(
+            family,
+            representation,
+            group_offsets[group],
+        )
+        group_offsets[group] += 1
+        canonical = canonical.replace(source, target)
+
+    if any(
+        _CONTRACTED_INDEX.fullmatch(str(symbol))
+        for symbol in canonical.get_all_symbols()
+    ):
+        raise ValueError(
+            "Symbolica tensor canonization left a source-owned contracted index"
+        )
+    return (canonical,)
+
+
+def _expressions_are_constant_multiples(target: str, reference: str) -> bool:
+    target_expression = _sym.E(target)
+    reference_expression = _sym.E(reference)
+    if target_expression == reference_expression:
+        return True
+    return (
+        _constant_expression_ratio(target_expression, reference_expression) is not None
+    )
+
+
+def _is_compile_time_massless_adjoint_vector(
+    particle: CompiledParticleRecord,
+    parameters: dict[str, CompiledParameterRecord],
+    propagators: dict[str, CompiledPropagatorRecord],
+) -> bool:
+    propagator = (
+        None
+        if particle.propagator is None
+        else propagators.get(particle.propagator)
+    )
+    return (
+        particle.spin == 3
+        and particle.color == 8
+        and particle.self_conjugate is True
+        and _parameter_is_compile_time_zero(particle.mass, parameters)
+        and particle.propagating
+        and particle.ghost_number == 0
+        and propagator is not None
+        and not propagator.custom
+    )
+
+
+def _parameter_is_compile_time_zero(
+    name: str,
+    parameters: dict[str, CompiledParameterRecord],
+) -> bool:
+    parameter = parameters.get(name)
+    if parameter is None or parameter.nature != "internal":
+        return False
+    return (
+        _sym.E(parameter.resolved_expression).expand().to_canonical_string()
+        == _sym.E("0").to_canonical_string()
+    )
+
+
+def _certified_two_source_adjoint_current_reflections(
+    ir: CompiledModelIR,
+    particles: dict[str, CompiledParticleRecord],
+    parameters: dict[str, CompiledParameterRecord],
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> dict[int, tuple[float, float]]:
+    """Prove local two-input current reflection from lowered expressions.
+
+    The proof is intentionally narrower than a Yang--Mills model
+    classification.  Every cubic kernel of a candidate gauge species must be
+    exactly antisymmetric under exchanging its formal input currents and
+    momenta, must carry an exact structure-constant color tensor, and must use
+    the compiler's standard linear propagator.  One failed kernel disables the
+    optimization for the complete species.
+    """
+
+    propagators = {propagator.name: propagator for propagator in ir.propagators}
+    kernels_by_name: dict[str, list[CompiledOrientedKernel]] = defaultdict(list)
+    for kernel in ir.oriented_kernels:
+        if len(set(kernel.particles)) == 1:
+            kernels_by_name[kernel.particles[0]].append(kernel)
+
+    certified: dict[int, tuple[float, float]] = {}
+    for name, kernels in kernels_by_name.items():
+        particle = particles.get(name)
+        if particle is None or not _is_compile_time_massless_adjoint_vector(
+            particle,
+            parameters,
+            propagators,
+        ):
+            continue
+        propagator = (
+            None
+            if particle.propagator is None
+            else propagators.get(particle.propagator)
+        )
+        if propagator is None or propagator.custom:
+            continue
+        if not kernels or any(
+            not _kernel_has_exact_adjoint_reflection(
+                kernel,
+                model_symbols=model_symbols,
+            )
+            for kernel in kernels
+        ):
+            continue
+        certified.update({kernel.kind: (-1.0, 0.0) for kernel in kernels})
+    return certified
+
+
+def _kernel_has_exact_adjoint_reflection(
+    kernel: CompiledOrientedKernel,
+    *,
+    model_symbols: ModelSymbolRegistry,
+) -> bool:
+    from .compiler_kernels import (
+        _remap_kernel_symbols,
+    )
+
+    color_reference = normalize_color_expression(
+        "UFO::f(1,2,3)",
+        (8, 8, 8),
+    ).expression
+    color_ratio = _constant_expression_ratio(
+        _sym.E(kernel.color_expression),
+        _sym.E(color_reference),
+    )
+    if color_ratio is None or color_ratio == 0j:
+        return False
+
+    coupling = _sym.E(kernel.coupling_expression)
+    zero = _sym.E("0").to_canonical_string()
+    for component_source in kernel.component_expressions:
+        component = _sym.E(component_source) * coupling
+        direct = _remap_kernel_symbols(
+            component,
+            old_kind=kernel.kind,
+            new_kind=0,
+            model_symbols=model_symbols,
+        )
+        swapped = _remap_kernel_symbols(
+            component,
+            old_kind=kernel.kind,
+            new_kind=0,
+            model_symbols=model_symbols,
+            swap_sides=True,
+        )
+        if (swapped + direct).expand().to_canonical_string() != zero:
+            return False
+    return True
+
+
+def _contact_origin_term_id(
+    particle_names: tuple[str, str, str],
+    particles: dict[str, CompiledParticleRecord],
+) -> int | None:
+    for name in particle_names:
+        auxiliary_kind = particles[name].auxiliary_kind
+        if auxiliary_kind is None:
+            continue
+        match = _CONTACT_ORIGIN.match(auxiliary_kind)
+        if match is not None:
+            return int(match.group("term"))
+    return None
+
+
+__all__ = [
+    "ExternalSymmetryCertificates",
+    "derive_external_symmetry_certificates",
+]
diff --git a/pyamplicol/src/pyamplicol/models/lc_color_port_wiring.py b/pyamplicol/src/pyamplicol/models/lc_color_port_wiring.py
new file mode 100644
index 0000000000..6c6c33c51b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/lc_color_port_wiring.py
@@ -0,0 +1,505 @@
+# SPDX-License-Identifier: 0BSD
+"""Model-generic leading-color port wiring for certified local tensors.
+
+The compiler in this module is deliberately bounded to trivalent recurrence
+transitions and direct two-current closures in the representations currently
+supported by the LC recurrence ABI.  It derives connectivity only from the
+certified tensor family and oriented/tensor-role representations.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Literal, TypeAlias
+
+LCColorTensorFamily: TypeAlias = Literal[
+    "singlet",
+    "color-identity",
+    "fundamental-generator",
+    "adjoint-structure-constant",
+    "direct-closure",
+]
+LCColorPortKind: TypeAlias = Literal["fundamental", "antifundamental"]
+
+_SUPPORTED_FAMILIES = frozenset(
+    {
+        "singlet",
+        "color-identity",
+        "fundamental-generator",
+        "adjoint-structure-constant",
+        "direct-closure",
+    }
+)
+_SUPPORTED_REPRESENTATIONS = frozenset({1, 3, -3, 8})
+
+
+@dataclass(frozen=True, slots=True, order=True)
+class ParentPortRef:
+    """Reference to one ordered color-flow port of a parent current."""
+
+    parent_index: int
+    local_port_index: int
+
+    def __post_init__(self) -> None:
+        if isinstance(self.parent_index, bool) or not isinstance(
+            self.parent_index, int
+        ):
+            raise TypeError("LC parent-port parent index must be an integer")
+        if self.parent_index not in (0, 1):
+            raise ValueError("LC parent-port parent index must be zero or one")
+        if isinstance(self.local_port_index, bool) or not isinstance(
+            self.local_port_index, int
+        ):
+            raise TypeError("LC parent-port local index must be an integer")
+        if self.local_port_index < 0:
+            raise ValueError("LC parent-port local index cannot be negative")
+
+
+@dataclass(frozen=True, slots=True)
+class ParentPortPairing:
+    """An input-input contraction, ordered fundamental to antifundamental."""
+
+    fundamental: ParentPortRef
+    antifundamental: ParentPortRef
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.fundamental, ParentPortRef) or not isinstance(
+            self.antifundamental, ParentPortRef
+        ):
+            raise TypeError("LC parent-port pairings require immutable port refs")
+        if self.fundamental.parent_index == self.antifundamental.parent_index:
+            raise ValueError("LC parent-port pairings must join different parents")
+
+
+@dataclass(frozen=True, slots=True)
+class LCColorPortWiring:
+    """One exact color-flow wiring term for a transition or closure.
+
+    ``result_port_bindings[i]`` identifies the parent port exposed as ordered
+    local port ``i`` of the result current.  Every parent port must occur once,
+    either in one input-input pairing or in this result-binding tuple.
+    """
+
+    tensor_family: LCColorTensorFamily
+    oriented_representations: tuple[int, ...]
+    tensor_role_representations: tuple[int, ...]
+    term_index: int
+    exact_factor: int
+    input_pairings: tuple[ParentPortPairing, ...]
+    result_port_bindings: tuple[ParentPortRef, ...]
+
+    def __post_init__(self) -> None:
+        _validate_contract_representations(
+            self.tensor_family,
+            self.oriented_representations,
+            self.tensor_role_representations,
+        )
+        if isinstance(self.term_index, bool) or not isinstance(self.term_index, int):
+            raise TypeError("LC port-wiring term index must be an integer")
+        if self.term_index < 0:
+            raise ValueError("LC port-wiring term index cannot be negative")
+        if self.exact_factor not in (-1, 1) or isinstance(self.exact_factor, bool):
+            raise ValueError("LC port-wiring exact factor must be +1 or -1")
+        if not isinstance(self.input_pairings, tuple) or any(
+            not isinstance(pairing, ParentPortPairing)
+            for pairing in self.input_pairings
+        ):
+            raise TypeError("LC input pairings must be an immutable pairing tuple")
+        if not isinstance(self.result_port_bindings, tuple) or any(
+            not isinstance(port, ParentPortRef) for port in self.result_port_bindings
+        ):
+            raise TypeError(
+                "LC result-port bindings must be an immutable parent-port tuple"
+            )
+
+        parent_representations = self.oriented_representations[:2]
+        expected_parent_ports = frozenset(
+            ParentPortRef(parent_index, local_port_index)
+            for parent_index, representation in enumerate(parent_representations)
+            for local_port_index in range(len(_port_kinds(representation)))
+        )
+        consumed_ports: list[ParentPortRef] = []
+        for pairing in self.input_pairings:
+            fundamental_kind = _parent_port_kind(
+                pairing.fundamental,
+                parent_representations,
+            )
+            antifundamental_kind = _parent_port_kind(
+                pairing.antifundamental,
+                parent_representations,
+            )
+            if fundamental_kind != "fundamental":
+                raise ValueError(
+                    "LC pairing fundamental endpoint is not a fundamental port"
+                )
+            if antifundamental_kind != "antifundamental":
+                raise ValueError(
+                    "LC pairing antifundamental endpoint is not an antifundamental port"
+                )
+            consumed_ports.extend((pairing.fundamental, pairing.antifundamental))
+
+        output_representation = self.output_representation
+        output_port_kinds = (
+            () if output_representation is None else _port_kinds(output_representation)
+        )
+        if len(self.result_port_bindings) != len(output_port_kinds):
+            raise ValueError(
+                "LC result-port binding count does not match the output representation"
+            )
+        for result_kind, parent_port in zip(
+            output_port_kinds,
+            self.result_port_bindings,
+            strict=True,
+        ):
+            if _parent_port_kind(parent_port, parent_representations) != result_kind:
+                raise ValueError(
+                    "LC result port is bound to a parent port with the wrong "
+                    "orientation"
+                )
+            consumed_ports.append(parent_port)
+
+        if len(consumed_ports) != len(set(consumed_ports)):
+            raise ValueError("LC port wiring consumes a parent port more than once")
+        consumed_set = frozenset(consumed_ports)
+        if consumed_set != expected_parent_ports:
+            missing = tuple(sorted(expected_parent_ports - consumed_set))
+            extra = tuple(sorted(consumed_set - expected_parent_ports))
+            raise ValueError(
+                "LC port wiring does not consume every parent port exactly once: "
+                f"missing={missing!r}, extra={extra!r}"
+            )
+
+    @property
+    def output_representation(self) -> int | None:
+        """Return the current-shape output representation, if this is not a closure."""
+
+        if self.tensor_family == "direct-closure":
+            return None
+        return self.oriented_representations[2]
+
+
+def compile_lc_color_port_wirings(
+    tensor_family: LCColorTensorFamily,
+    oriented_representations: Sequence[int],
+    tensor_role_representations: Sequence[int],
+) -> tuple[LCColorPortWiring, ...]:
+    """Compile exact LC parent/result port connectivity from a tensor contract.
+
+    Trivalent tensor families return one term except for the adjoint structure
+    constant, which returns its two ordered commutator terms with factors
+    ``+1`` and ``-1``.  Direct closures consume two parent currents and expose
+    no result ports.
+    """
+
+    oriented = _canonical_representations(
+        oriented_representations,
+        context="oriented",
+    )
+    tensor_roles = _canonical_representations(
+        tensor_role_representations,
+        context="tensor-role",
+    )
+    _validate_contract_representations(tensor_family, oriented, tensor_roles)
+
+    def port(parent_index: int, local_port_index: int) -> ParentPortRef:
+        return ParentPortRef(parent_index, local_port_index)
+
+    def pair(
+        fundamental: ParentPortRef,
+        antifundamental: ParentPortRef,
+    ) -> ParentPortPairing:
+        return ParentPortPairing(fundamental, antifundamental)
+
+    def wiring(
+        *,
+        term_index: int = 0,
+        exact_factor: int = 1,
+        input_pairings: tuple[ParentPortPairing, ...] = (),
+        result_port_bindings: tuple[ParentPortRef, ...] = (),
+    ) -> LCColorPortWiring:
+        return LCColorPortWiring(
+            tensor_family=tensor_family,
+            oriented_representations=oriented,
+            tensor_role_representations=tensor_roles,
+            term_index=term_index,
+            exact_factor=exact_factor,
+            input_pairings=input_pairings,
+            result_port_bindings=result_port_bindings,
+        )
+
+    if tensor_family == "singlet":
+        return (wiring(),)
+
+    if tensor_family == "color-identity":
+        output = oriented[2]
+        if output == 1:
+            return (
+                wiring(
+                    input_pairings=_closure_pairings(oriented[:2]),
+                ),
+            )
+        colored_parents = tuple(
+            index
+            for index, representation in enumerate(oriented[:2])
+            if representation != 1
+        )
+        if len(colored_parents) != 1:
+            raise ValueError(
+                "color-identity transition with a colored output requires exactly "
+                "one colored parent"
+            )
+        colored_parent = colored_parents[0]
+        if oriented[colored_parent] != output:
+            raise ValueError(
+                "color-identity transition cannot change the colored current shape"
+            )
+        return (
+            wiring(
+                result_port_bindings=tuple(
+                    port(colored_parent, local_port_index)
+                    for local_port_index in range(len(_port_kinds(output)))
+                )
+            ),
+        )
+
+    if tensor_family == "fundamental-generator":
+        output = oriented[2]
+        parent_by_representation = {
+            representation: index for index, representation in enumerate(oriented[:2])
+        }
+        if output == 8:
+            fundamental_parent = parent_by_representation[3]
+            antifundamental_parent = parent_by_representation[-3]
+            return (
+                wiring(
+                    result_port_bindings=(
+                        port(fundamental_parent, 0),
+                        port(antifundamental_parent, 0),
+                    )
+                ),
+            )
+        adjoint_parent = parent_by_representation[8]
+        if output == 3:
+            fundamental_parent = parent_by_representation[3]
+            return (
+                wiring(
+                    input_pairings=(
+                        pair(port(fundamental_parent, 0), port(adjoint_parent, 1)),
+                    ),
+                    result_port_bindings=(port(adjoint_parent, 0),),
+                ),
+            )
+        if output == -3:
+            antifundamental_parent = parent_by_representation[-3]
+            return (
+                wiring(
+                    input_pairings=(
+                        pair(port(adjoint_parent, 0), port(antifundamental_parent, 0)),
+                    ),
+                    result_port_bindings=(port(adjoint_parent, 1),),
+                ),
+            )
+        raise AssertionError("validated fundamental-generator output is unsupported")
+
+    if tensor_family == "adjoint-structure-constant":
+        return (
+            wiring(
+                term_index=0,
+                input_pairings=(pair(port(0, 0), port(1, 1)),),
+                result_port_bindings=(port(1, 0), port(0, 1)),
+            ),
+            wiring(
+                term_index=1,
+                exact_factor=-1,
+                input_pairings=(pair(port(1, 0), port(0, 1)),),
+                result_port_bindings=(port(0, 0), port(1, 1)),
+            ),
+        )
+
+    if tensor_family == "direct-closure":
+        return (wiring(input_pairings=_closure_pairings(oriented)),)
+
+    raise AssertionError("validated LC tensor family is unsupported")
+
+
+def _canonical_representations(
+    values: Sequence[int],
+    *,
+    context: str,
+) -> tuple[int, ...]:
+    if isinstance(values, str | bytes) or not isinstance(values, Sequence):
+        raise TypeError(f"LC {context} representations must be a sequence")
+    result: list[int] = []
+    for value in values:
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise TypeError(f"LC {context} representations must contain integers")
+        if value not in _SUPPORTED_REPRESENTATIONS:
+            raise ValueError(
+                f"LC {context} representation {value} is unsupported; expected "
+                "one of -3, 1, 3, or 8"
+            )
+        result.append(value)
+    return tuple(result)
+
+
+def _validate_contract_representations(
+    tensor_family: str,
+    oriented_representations: tuple[int, ...],
+    tensor_role_representations: tuple[int, ...],
+) -> None:
+    if not isinstance(tensor_family, str):
+        raise TypeError("LC tensor family must be a string")
+    if tensor_family not in _SUPPORTED_FAMILIES:
+        raise ValueError(f"unsupported certified LC tensor family {tensor_family!r}")
+    if not isinstance(oriented_representations, tuple) or not isinstance(
+        tensor_role_representations, tuple
+    ):
+        raise TypeError("LC port-wiring representations must be immutable tuples")
+    expected_arity = 2 if tensor_family == "direct-closure" else 3
+    if (
+        len(oriented_representations) != expected_arity
+        or len(tensor_role_representations) != expected_arity
+    ):
+        raise ValueError(
+            f"LC {tensor_family} contract requires {expected_arity} representations"
+        )
+    for context, representations in (
+        ("oriented", oriented_representations),
+        ("tensor-role", tensor_role_representations),
+    ):
+        for representation in representations:
+            if isinstance(representation, bool) or not isinstance(representation, int):
+                raise TypeError(f"LC {context} representations must contain integers")
+            if representation not in _SUPPORTED_REPRESENTATIONS:
+                raise ValueError(
+                    f"LC {context} representation {representation} is unsupported; "
+                    "expected one of -3, 1, 3, or 8"
+                )
+    if tuple(abs(value) for value in oriented_representations) != tuple(
+        abs(value) for value in tensor_role_representations
+    ):
+        raise ValueError(
+            "LC oriented and tensor-role representations describe different shapes"
+        )
+
+    if tensor_family == "direct-closure":
+        if oriented_representations != tensor_role_representations:
+            raise ValueError(
+                "direct LC closure tensor roles must equal the parent current shapes"
+            )
+        _validate_closure_representations(oriented_representations)
+        return
+
+    if oriented_representations[:2] != tensor_role_representations[:2]:
+        raise ValueError(
+            "LC parent tensor roles must equal the oriented parent current shapes"
+        )
+    if tensor_role_representations[2] != _dual(oriented_representations[2]):
+        raise ValueError(
+            "LC output tensor role must be dual to the oriented result current shape"
+        )
+
+    tensor_roles = tensor_role_representations
+    if tensor_family == "singlet":
+        if tensor_roles != (1, 1, 1):
+            raise ValueError("singlet LC tensor requires representations (1, 1, 1)")
+        return
+    if tensor_family == "color-identity":
+        role_counts = {
+            representation: tensor_roles.count(representation)
+            for representation in _SUPPORTED_REPRESENTATIONS
+        }
+        fundamental_identity = (
+            role_counts[3] == 1
+            and role_counts[-3] == 1
+            and role_counts[1] == 1
+            and role_counts[8] == 0
+        )
+        adjoint_identity = role_counts[8] == 2 and role_counts[1] == 1
+        singlet_identity = role_counts[1] == 3
+        if not (fundamental_identity or adjoint_identity or singlet_identity):
+            raise ValueError(
+                "color-identity LC tensor requires one singlet plus a dual "
+                "fundamental pair or two adjoints"
+            )
+        return
+    if tensor_family == "fundamental-generator":
+        if sorted(tensor_roles) != [-3, 3, 8]:
+            raise ValueError(
+                "fundamental-generator LC tensor requires roles (-3, 3, 8)"
+            )
+        return
+    if tensor_family == "adjoint-structure-constant" and tensor_roles != (8, 8, 8):
+        raise ValueError(
+            "adjoint-structure-constant LC tensor requires representations (8, 8, 8)"
+        )
+
+
+def _validate_closure_representations(representations: tuple[int, ...]) -> None:
+    if representations == (1, 1) or representations == (8, 8):
+        return
+    if set(representations) == {3, -3}:
+        return
+    raise ValueError(
+        "direct LC closure requires two singlets, a fundamental/antifundamental "
+        "pair, or two adjoints"
+    )
+
+
+def _closure_pairings(
+    representations: tuple[int, ...],
+) -> tuple[ParentPortPairing, ...]:
+    _validate_closure_representations(representations)
+    if representations == (1, 1):
+        return ()
+    if set(representations) == {3, -3}:
+        fundamental_parent = representations.index(3)
+        antifundamental_parent = representations.index(-3)
+        return (
+            ParentPortPairing(
+                ParentPortRef(fundamental_parent, 0),
+                ParentPortRef(antifundamental_parent, 0),
+            ),
+        )
+    return (
+        ParentPortPairing(ParentPortRef(0, 0), ParentPortRef(1, 1)),
+        ParentPortPairing(ParentPortRef(1, 0), ParentPortRef(0, 1)),
+    )
+
+
+def _parent_port_kind(
+    port: ParentPortRef,
+    parent_representations: tuple[int, ...],
+) -> LCColorPortKind:
+    if port.parent_index >= len(parent_representations):
+        raise ValueError("LC parent-port reference addresses a missing parent")
+    port_kinds = _port_kinds(parent_representations[port.parent_index])
+    if port.local_port_index >= len(port_kinds):
+        raise ValueError("LC parent-port reference addresses a missing local port")
+    return port_kinds[port.local_port_index]
+
+
+def _port_kinds(representation: int) -> tuple[LCColorPortKind, ...]:
+    if representation == 1:
+        return ()
+    if representation == 3:
+        return ("fundamental",)
+    if representation == -3:
+        return ("antifundamental",)
+    if representation == 8:
+        return ("fundamental", "antifundamental")
+    raise ValueError(f"unsupported LC color representation {representation}")
+
+
+def _dual(representation: int) -> int:
+    return -representation if abs(representation) == 3 else representation
+
+
+__all__ = [
+    "LCColorPortWiring",
+    "LCColorTensorFamily",
+    "ParentPortPairing",
+    "ParentPortRef",
+    "compile_lc_color_port_wirings",
+]
diff --git a/pyamplicol/src/pyamplicol/models/loading.py b/pyamplicol/src/pyamplicol/models/loading.py
new file mode 100644
index 0000000000..10bba3d6ac
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/loading.py
@@ -0,0 +1,1069 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import importlib.metadata
+import json
+import os
+import re
+import shutil
+import sys
+import threading
+import time
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
+from copy import copy
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .prepared import PreparedModelBundle
+
+from .._internal.versions import (
+    COMPILED_MODEL_SCHEMA_VERSION,
+    SYMBOLICA_SERIALIZATION_ABI,
+    package_version,
+)
+from .contact_decomposition import (
+    CONTACT_DECOMPOSITION_ALGORITHM,
+    CONTACT_DECOMPOSITION_ALGORITHM_VERSION,
+)
+from .contracts import (
+    DEFAULT_FEYNMAN_PROPAGATOR_SOURCE,
+    MODEL_SUPPLIED_PROPAGATOR_SOURCE,
+    PROPAGATOR_SOURCE_FIELD,
+    TENSOR_ORDERING_CONTRACT_VERSION,
+    CompiledModelIR,
+)
+
+COMPILED_MODEL_KIND = "pyamplicol-compiled-model"
+MODEL_COMPILER_VERSION = 16
+BUILTIN_SM_ALIASES = frozenset(("builtin_sm", "built-in-sm"))
+DEFAULT_MODEL_RESTRICTION = "default"
+NO_MODEL_RESTRICTION = "none"
+SANITIZED_MODEL_ENVIRONMENT_PREFIXES = (
+    "UFO_SCALARS_MODEL_",
+    "UFO_GRAVITY_MODEL_",
+)
+_MODEL_LOAD_LOCK = threading.RLock()
+
+SUPPORTED_FUNCTION_ARITIES = {
+    name: frozenset({1})
+    for name in (
+        "Theta",
+        "abs",
+        "acos",
+        "acosh",
+        "acsc",
+        "asec",
+        "asin",
+        "asinh",
+        "atan",
+        "atanh",
+        "complexconjugate",
+        "conj",
+        "cos",
+        "cosh",
+        "csc",
+        "exp",
+        "im",
+        "log",
+        "log10",
+        "re",
+        "reglog",
+        "reglogm",
+        "reglogp",
+        "sec",
+        "sin",
+        "sinh",
+        "sqrt",
+        "tan",
+        "tanh",
+    )
+}
+SUPPORTED_FUNCTION_ARITIES.update(
+    {
+        "complex": frozenset({2}),
+        "cond": frozenset({3}),
+        "if": frozenset({3}),
+        "pow": frozenset({2}),
+    }
+)
+SUPPORTED_FUNCTIONS = frozenset(SUPPORTED_FUNCTION_ARITIES)
+
+UFO_TENSOR_HEADS = frozenset(
+    {
+        "C",
+        "Epsilon",
+        "EpsilonBar",
+        "Gamma",
+        "Gamma5",
+        "Identity",
+        "IdentityL",
+        "K6",
+        "K6Bar",
+        "Metric",
+        "P",
+        "PSlash",
+        "ProjM",
+        "ProjP",
+        "Sigma",
+        "T",
+        "T6",
+        "d",
+        "dummy",
+        "f",
+        "idx",
+    }
+)
+
+
+def _require_ufo_model_loader() -> None:
+    """Reject loaders predating the supported model serialization API."""
+
+    installed = _distribution_version("ufo-model-loader", "not installed")
+    # The loader publishes three-component release versions. Development and
+    # prerelease builds are not substitutes for the required release interface.
+    release = re.fullmatch(
+        r"(\d+)\.(\d+)\.(\d+)(?:\.post\d+)?(?:\+[\w.-]+)?", installed
+    )
+    if release is None or tuple(map(int, release.groups())) < (1, 0, 0):
+        raise RuntimeError(
+            "UFO model import requires ufo-model-loader release 1.0.0 or newer "
+            f"for the supported model serialization API; found {installed}. "
+            "Install the updated loader before importing a UFO model."
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ModelCompileOptions:
+    restriction: str = DEFAULT_MODEL_RESTRICTION
+    simplify: bool = True
+
+    def __post_init__(self) -> None:
+        restriction_path = Path(self.restriction).expanduser()
+        if not self.restriction or (
+            any(character.isspace() for character in self.restriction)
+            and not restriction_path.is_file()
+        ):
+            raise ValueError(
+                "model restriction must be default, none, or a restriction name"
+            )
+        if not isinstance(self.simplify, bool):
+            raise TypeError("model simplification must be a boolean")
+
+    def canonical_payload(self) -> dict[str, object]:
+        restriction_path = Path(self.restriction).expanduser()
+        if restriction_path.is_file():
+            restriction: object = {
+                "kind": "file",
+                "sha256": hashlib.sha256(restriction_path.read_bytes()).hexdigest(),
+            }
+        else:
+            restriction = {"kind": "name", "value": self.restriction}
+        return {
+            "restriction": restriction,
+            "simplify": self.simplify,
+        }
+
+
+@dataclass(frozen=True)
+class ModelCompatibilityIssue:
+    severity: str
+    code: str
+    message: str
+    context: str = ""
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "severity": self.severity,
+            "code": self.code,
+            "message": self.message,
+            "context": self.context,
+        }
+
+    @staticmethod
+    def from_dict(payload: Mapping[str, object]) -> ModelCompatibilityIssue:
+        return ModelCompatibilityIssue(
+            severity=str(payload["severity"]),
+            code=str(payload["code"]),
+            message=str(payload["message"]),
+            context=str(payload.get("context", "")),
+        )
+
+
+@dataclass(frozen=True)
+class CompiledModel:
+    source: Mapping[str, object]
+    producer: Mapping[str, object]
+    model: Mapping[str, object]
+    ir: CompiledModelIR
+    parameter_defaults: Mapping[str, tuple[float, float]]
+    capabilities: Mapping[str, object]
+    issues: tuple[ModelCompatibilityIssue, ...]
+    phase_timings: Mapping[str, float]
+    conversion_seconds: float
+    _serialized_path: Path | None = field(default=None, compare=False, repr=False)
+    _prepared_bundle: PreparedModelBundle | None = field(
+        default=None,
+        compare=False,
+        repr=False,
+    )
+
+    @property
+    def name(self) -> str:
+        return str(self.model.get("name", "unnamed-model"))
+
+    @property
+    def schema_version(self) -> int:
+        return COMPILED_MODEL_SCHEMA_VERSION
+
+    @property
+    def model_compiler_version(self) -> int:
+        return MODEL_COMPILER_VERSION
+
+    @property
+    def supported(self) -> bool:
+        return not any(issue.severity == "error" for issue in self.issues)
+
+    @property
+    def prepared_bundle(self) -> PreparedModelBundle | None:
+        return self._prepared_bundle
+
+    @property
+    def prepared_backend(self) -> str | None:
+        return None if self._prepared_bundle is None else self._prepared_bundle.backend
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "kind": COMPILED_MODEL_KIND,
+            "schema_version": COMPILED_MODEL_SCHEMA_VERSION,
+            "model_compiler_version": MODEL_COMPILER_VERSION,
+            "source": dict(self.source),
+            "producer": dict(self.producer),
+            "model": dict(self.model),
+            "ir": self.ir.to_dict(),
+            "parameter_defaults": {
+                name: [value[0], value[1]]
+                for name, value in sorted(self.parameter_defaults.items())
+            },
+            "capabilities": dict(self.capabilities),
+            "issues": [issue.to_dict() for issue in self.issues],
+            "phase_timings": dict(self.phase_timings),
+            "conversion_seconds": self.conversion_seconds,
+        }
+
+    def write(self, path: Path) -> Path:
+        output = _compiled_model_output_path(path)
+        if self._serialized_path is None or not self._serialized_path.is_file():
+            _atomic_write_json(output, self.to_dict(), compact=True)
+        else:
+            _atomic_copy(self._serialized_path, output)
+        return output
+
+    def write_parameter_card(self, path: Path) -> Path:
+        _atomic_write_json(
+            path,
+            {
+                name: [value[0], value[1]]
+                for name, value in sorted(self.parameter_defaults.items())
+            },
+        )
+        return path
+
+    @staticmethod
+    def from_dict(
+        payload: Mapping[str, object],
+        *,
+        validate_fingerprint: bool = True,
+        serialized_path: Path | None = None,
+    ) -> CompiledModel:
+        if payload.get("kind") != COMPILED_MODEL_KIND:
+            raise ValueError("file is not a pyAmpliCol compiled model")
+        if int(payload.get("schema_version", -1)) != COMPILED_MODEL_SCHEMA_VERSION:
+            raise ValueError("compiled model schema mismatch; regenerate the model")
+        if int(payload.get("model_compiler_version", -1)) != MODEL_COMPILER_VERSION:
+            raise ValueError("compiled model compiler mismatch; regenerate the model")
+        producer = _mapping(payload.get("producer"), "producer")
+        if validate_fingerprint and producer != compiler_fingerprint():
+            raise ValueError(
+                "compiled model dependency fingerprint mismatch; regenerate the model"
+            )
+        parameter_payload = _mapping(
+            payload.get("parameter_defaults"),
+            "parameter_defaults",
+        )
+        parameters = {
+            str(name): _complex_pair(value, context=f"parameter {name}")
+            for name, value in parameter_payload.items()
+        }
+        raw_issues = payload.get("issues", ())
+        if not isinstance(raw_issues, list):
+            raise ValueError("compiled model issues must be a list")
+        return CompiledModel(
+            source=_mapping(payload.get("source"), "source"),
+            producer=producer,
+            model=_mapping(payload.get("model"), "model"),
+            ir=CompiledModelIR.from_dict(_mapping(payload.get("ir"), "ir")),
+            parameter_defaults=parameters,
+            capabilities=_mapping(payload.get("capabilities"), "capabilities"),
+            issues=tuple(
+                ModelCompatibilityIssue.from_dict(_mapping(issue, "issue"))
+                for issue in raw_issues
+            ),
+            phase_timings={
+                str(name): float(value)
+                for name, value in _mapping(
+                    payload.get("phase_timings"),
+                    "phase_timings",
+                ).items()
+            },
+            conversion_seconds=float(payload.get("conversion_seconds", 0.0)),
+            _serialized_path=(
+                None if serialized_path is None else Path(serialized_path).resolve()
+            ),
+        )
+
+
+def compiler_fingerprint() -> dict[str, object]:
+    return {
+        "pyamplicol": package_version(),
+        "ufo_model_loader": _distribution_version("ufo-model-loader", "missing"),
+        "symbolica": _distribution_version("symbolica", "missing"),
+        "compiled_model_schema_version": COMPILED_MODEL_SCHEMA_VERSION,
+        "model_compiler_version": MODEL_COMPILER_VERSION,
+        "model_compiler_sha256": _model_compiler_digest(),
+        "symbolica_serialization_abi": SYMBOLICA_SERIALIZATION_ABI,
+        "contact_decomposition_policy": (
+            f"{CONTACT_DECOMPOSITION_ALGORITHM}-v"
+            f"{CONTACT_DECOMPOSITION_ALGORITHM_VERSION}"
+        ),
+        "tensor_ordering_contract": (
+            f"explicit-canonical-component-order-v{TENSOR_ORDERING_CONTRACT_VERSION}"
+        ),
+        "model_environment_policy": "sanitize-historical-scalar-options-v1",
+        "symbol_namespace_policy": "model-name-and-pyamplicol-registry-v1",
+    }
+
+
+def detect_model_source(source: str | Path) -> tuple[str, str | Path]:
+    source_kind, resolved, _payload = _detect_model_source_payload(source)
+    return source_kind, resolved
+
+
+def _detect_model_source_payload(
+    source: str | Path,
+) -> tuple[str, str | Path, dict[str, object] | None]:
+    text = str(source)
+    if text.lower() in BUILTIN_SM_ALIASES:
+        return "built-in-sm", "built-in-sm", None
+    path = Path(text).expanduser().resolve()
+    if path.is_dir():
+        if not (path / "__init__.py").is_file():
+            raise ValueError(f"UFO model directory has no __init__.py: {path}")
+        return "ufo", path, None
+    if not path.is_file():
+        raise ValueError(f"model source does not exist: {path}")
+    from .prepared import PREPARED_MODEL_BUNDLE_SUFFIX
+
+    if path.name.lower().endswith(PREPARED_MODEL_BUNDLE_SUFFIX):
+        return "prepared", path, None
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ValueError(f"model JSON could not be read: {path}: {exc}") from exc
+    if isinstance(payload, dict) and payload.get("kind") == COMPILED_MODEL_KIND:
+        return "pyamplicol", path, payload
+    return "json", path, payload if isinstance(payload, dict) else None
+
+
+def compile_model_source(
+    source: str | Path = "BUILTIN_SM",
+    *,
+    restriction: str = "default",
+    simplify: bool = True,
+    cache_dir: Path | None = None,
+    use_cache: bool = True,
+    require_supported: bool = True,
+) -> CompiledModel:
+    options = ModelCompileOptions(restriction=restriction, simplify=simplify)
+    source_kind, resolved, detected_payload = _detect_model_source_payload(source)
+    if source_kind in {"pyamplicol", "prepared"}:
+        if restriction != DEFAULT_MODEL_RESTRICTION or not simplify:
+            raise ValueError(
+                "restriction and simplification options cannot be applied to an "
+                "already compiled pyAmpliCol model"
+            )
+        if source_kind == "prepared":
+            from .prepared import load_prepared_model_bundle
+
+            bundle = load_prepared_model_bundle(Path(resolved))
+            compiled = CompiledModel.from_dict(
+                bundle.compiled_model_payload(),
+                validate_fingerprint=False,
+            )
+            compiled = replace(compiled, _prepared_bundle=bundle)
+            _raise_for_unsupported(compiled, require_supported=require_supported)
+            return compiled
+        if detected_payload is None:
+            raise RuntimeError(
+                "compiled model detection did not retain its JSON payload"
+            )
+        return CompiledModel.from_dict(
+            detected_payload,
+            serialized_path=Path(resolved),
+        )
+    source_digest, fingerprint, cache_path = _compilation_cache_identity(
+        source_kind,
+        resolved,
+        options=options,
+        cache_dir=cache_dir,
+    )
+    if use_cache and cache_path.is_file():
+        compiled = load_compiled_model(cache_path)
+        _raise_for_unsupported(compiled, require_supported=require_supported)
+        return compiled
+
+    started = time.perf_counter()
+    phase_timings: dict[str, float] = {}
+    phase_started = time.perf_counter()
+    if source_kind == "built-in-sm":
+        from .builtin.adapters import build_model_payload
+
+        model_payload, parameter_defaults = build_model_payload()
+    else:
+        worker_payload = _load_external_model(
+            Path(resolved),
+            options=options,
+        )
+        model_payload = _mapping(worker_payload.get("model"), "worker model")
+        card = _mapping(worker_payload.get("parameter_card"), "parameter card")
+        parameter_defaults = {
+            str(name): _complex_pair(value, context=f"parameter {name}")
+            for name, value in card.items()
+        }
+    phase_timings["model_loading"] = time.perf_counter() - phase_started
+    phase_started = time.perf_counter()
+    issues, capabilities = preflight_model(model_payload)
+    phase_timings["preflight"] = time.perf_counter() - phase_started
+    phase_started = time.perf_counter()
+    from .compiler import compile_builtin_model_ir, compile_ufo_model_ir
+
+    model_ir = (
+        compile_builtin_model_ir(model_payload)
+        if source_kind == "built-in-sm"
+        else compile_ufo_model_ir(model_payload)
+    )
+    phase_timings["tensor_lowering"] = time.perf_counter() - phase_started
+    contact_term_ids = {term.id for term in model_ir.vertex_terms if term.valence > 3}
+    lowered_contact_term_ids = {
+        term_id
+        for kernel in model_ir.oriented_kernels
+        if "::contact-" in kernel.vertex and "final" in kernel.vertex
+        for term_id in (kernel.term_ids or (kernel.term_id,))
+    }
+    unlowered_contact_term_ids = contact_term_ids - lowered_contact_term_ids
+    if unlowered_contact_term_ids:
+        issues = (
+            *issues,
+            ModelCompatibilityIssue(
+                "error",
+                "unsupported-contact-color-lowering",
+                "one or more higher-point color tensors could not be lowered",
+                ", ".join(
+                    str(term_id) for term_id in sorted(unlowered_contact_term_ids)
+                ),
+            ),
+        )
+    evaluation_class_sizes: dict[str, int] = {}
+    for kernel in model_ir.oriented_kernels:
+        if not kernel.evaluation_equivalence_verified:
+            continue
+        evaluation_class_sizes[kernel.evaluation_class] = (
+            evaluation_class_sizes.get(kernel.evaluation_class, 0) + 1
+        )
+    capabilities = {
+        **capabilities,
+        "compiled_vertex_term_count": len(model_ir.vertex_terms),
+        "compiled_contact_term_count": len(lowered_contact_term_ids),
+        "unlowered_contact_term_count": len(unlowered_contact_term_ids),
+        "compiled_propagator_count": len(model_ir.propagators),
+        "verified_kernel_evaluation_class_count": len(evaluation_class_sizes),
+        "reusable_kernel_evaluation_class_count": sum(
+            size > 1 for size in evaluation_class_sizes.values()
+        ),
+        "signed_kernel_evaluation_relation_count": sum(
+            kernel.evaluation_factor != (1.0, 0.0)
+            for kernel in model_ir.oriented_kernels
+            if kernel.evaluation_equivalence_verified
+        ),
+        "swapped_kernel_evaluation_relation_count": sum(
+            kernel.evaluation_input_order == (1, 0)
+            for kernel in model_ir.oriented_kernels
+            if kernel.evaluation_equivalence_verified
+        ),
+        "exchange_symmetric_kernel_evaluation_relation_count": sum(
+            kernel.evaluation_input_exchange_factor is not None
+            for kernel in model_ir.oriented_kernels
+            if kernel.evaluation_equivalence_verified
+        ),
+    }
+    conversion_seconds = time.perf_counter() - started
+    phase_timings["total"] = conversion_seconds
+    compiled = CompiledModel(
+        source={
+            "kind": source_kind,
+            "source_name": (
+                None if source_kind == "built-in-sm" else Path(resolved).name
+            ),
+            "digest": source_digest,
+            "options": options.canonical_payload(),
+        },
+        producer=fingerprint,
+        model=model_payload,
+        ir=model_ir,
+        parameter_defaults=parameter_defaults,
+        capabilities=capabilities,
+        issues=issues,
+        phase_timings=phase_timings,
+        conversion_seconds=conversion_seconds,
+    )
+    if use_cache:
+        compiled.write(cache_path)
+        compiled = replace(compiled, _serialized_path=cache_path.resolve())
+    _raise_for_unsupported(compiled, require_supported=require_supported)
+    return compiled
+
+
+def load_cached_model_source(
+    source: str | Path,
+    *,
+    restriction: str = DEFAULT_MODEL_RESTRICTION,
+    simplify: bool = True,
+    cache_dir: Path | None = None,
+    require_supported: bool = True,
+) -> CompiledModel | None:
+    """Load an already compiled source without compiling or writing a cache."""
+
+    options = ModelCompileOptions(restriction=restriction, simplify=simplify)
+    source_kind, resolved, detected_payload = _detect_model_source_payload(source)
+    if source_kind in {"pyamplicol", "prepared"}:
+        if restriction != DEFAULT_MODEL_RESTRICTION or not simplify:
+            raise ValueError(
+                "restriction and simplification options cannot be applied to an "
+                "already compiled pyAmpliCol model"
+            )
+        if source_kind == "prepared":
+            from .prepared import load_prepared_model_bundle
+
+            bundle = load_prepared_model_bundle(Path(resolved))
+            compiled = CompiledModel.from_dict(
+                bundle.compiled_model_payload(),
+                validate_fingerprint=False,
+            )
+            compiled = replace(compiled, _prepared_bundle=bundle)
+            _raise_for_unsupported(compiled, require_supported=require_supported)
+            return compiled
+        if detected_payload is None:
+            raise RuntimeError(
+                "compiled model detection did not retain its JSON payload"
+            )
+        compiled = CompiledModel.from_dict(
+            detected_payload,
+            serialized_path=Path(resolved),
+        )
+        _raise_for_unsupported(compiled, require_supported=require_supported)
+        return compiled
+
+    _, _, cache_path = _compilation_cache_identity(
+        source_kind,
+        resolved,
+        options=options,
+        cache_dir=cache_dir,
+    )
+    if not cache_path.is_file():
+        return None
+    compiled = load_compiled_model(cache_path)
+    _raise_for_unsupported(compiled, require_supported=require_supported)
+    return compiled
+
+
+def load_compiled_model(path: Path) -> CompiledModel:
+    from .prepared import PREPARED_MODEL_BUNDLE_SUFFIX, load_prepared_model_bundle
+
+    if Path(path).name.lower().endswith(PREPARED_MODEL_BUNDLE_SUFFIX):
+        bundle = load_prepared_model_bundle(Path(path))
+        return replace(
+            CompiledModel.from_dict(
+                bundle.compiled_model_payload(),
+                validate_fingerprint=False,
+            ),
+            _prepared_bundle=bundle,
+        )
+    try:
+        payload = json.loads(Path(path).read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ValueError(f"could not load compiled model {path}: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise ValueError(f"compiled model root must be an object: {path}")
+    return CompiledModel.from_dict(payload, serialized_path=Path(path))
+
+
+def preflight_model(
+    model: Mapping[str, object],
+) -> tuple[tuple[ModelCompatibilityIssue, ...], dict[str, object]]:
+    particles = _list_of_mappings(model.get("particles"), "particles")
+    propagators = _list_of_mappings(model.get("propagators", []), "propagators")
+    vertices = _list_of_mappings(model.get("vertex_rules"), "vertex_rules")
+    functions = _list_of_mappings(model.get("functions", []), "functions")
+    form_factors = _list_of_mappings(model.get("form_factors", []), "form_factors")
+    issues: list[ModelCompatibilityIssue] = []
+    spins = sorted({int(particle.get("spin", 0)) for particle in particles})
+    colors = sorted({int(particle.get("color", 0)) for particle in particles})
+    unsupported_spins = sorted(set(spins) - {-1, 1, 2, 3, 5})
+    if unsupported_spins:
+        issues.append(
+            ModelCompatibilityIssue(
+                "error",
+                "unsupported-spin",
+                f"unsupported UFO spin codes: {unsupported_spins}",
+            )
+        )
+    unsupported_colors = sorted(set(colors) - {-3, 1, 3, 8})
+    if unsupported_colors:
+        issues.append(
+            ModelCompatibilityIssue(
+                "error",
+                "unsupported-color-representation",
+                f"unsupported UFO color representations: {unsupported_colors}",
+            )
+        )
+    majorana = sorted(
+        str(particle.get("name"))
+        for particle in particles
+        if int(particle.get("spin", 0)) == 2
+        and particle.get("name") == particle.get("antiname")
+    )
+    if majorana:
+        issues.append(
+            ModelCompatibilityIssue(
+                "error",
+                "majorana-fermion",
+                "Majorana/FNV fermion flow is not implemented",
+                ", ".join(majorana),
+            )
+        )
+    if form_factors:
+        issues.append(
+            ModelCompatibilityIssue(
+                "error",
+                "form-factors",
+                "UFO form factors are not supported in this milestone",
+                ", ".join(sorted(str(item.get("name")) for item in form_factors)),
+            )
+        )
+    declared_functions = {str(function.get("name")) for function in functions}
+    invalid_function_arities = []
+    for function in functions:
+        name = str(function.get("name"))
+        if name not in SUPPORTED_FUNCTION_ARITIES:
+            continue
+        arity = len(_sequence(function.get("arguments")))
+        if arity not in SUPPORTED_FUNCTION_ARITIES[name]:
+            invalid_function_arities.append(f"{name}/{arity}")
+    if invalid_function_arities:
+        issues.append(
+            ModelCompatibilityIssue(
+                "error",
+                "function-arity",
+                "model function declarations do not match pyAmpliCol's registry",
+                ", ".join(sorted(invalid_function_arities)),
+            )
+        )
+    expression_functions = _model_expression_functions(model)
+    unknown_functions = sorted(
+        (declared_functions | expression_functions)
+        - SUPPORTED_FUNCTIONS
+        - UFO_TENSOR_HEADS
+    )
+    if unknown_functions:
+        issues.append(
+            ModelCompatibilityIssue(
+                "error",
+                "unknown-functions",
+                "model uses functions that are not in pyAmpliCol's hard-coded registry",
+                ", ".join(unknown_functions),
+            )
+        )
+    massive_tensors = [
+        particle
+        for particle in particles
+        if int(particle.get("spin", 0)) == 5
+        and str(particle.get("mass", "ZERO")).upper() != "ZERO"
+    ]
+    if massive_tensors:
+        issues.append(
+            ModelCompatibilityIssue(
+                "warning",
+                "experimental-massive-spin-2",
+                "massive spin-2 support is experimental",
+                ", ".join(str(item.get("name")) for item in massive_tensors),
+            )
+        )
+    max_valence = max(
+        (len(_sequence(vertex.get("particles"))) for vertex in vertices), default=0
+    )
+    capabilities = {
+        "supported": not any(issue.severity == "error" for issue in issues),
+        "particle_count": len(particles),
+        "parameter_count": len(_sequence(model.get("parameters"))),
+        "vertex_count": len(vertices),
+        "max_vertex_valence": max_valence,
+        "spins": spins,
+        "color_representations": colors,
+        "declared_functions": sorted(declared_functions),
+        "expression_functions": sorted(expression_functions),
+        "form_factor_count": len(form_factors),
+        "has_custom_propagators": any(
+            propagator.get(PROPAGATOR_SOURCE_FIELD) == MODEL_SUPPLIED_PROPAGATOR_SOURCE
+            for propagator in propagators
+        ),
+        "color_accuracy_modes": ["lc", "nlc", "full"],
+    }
+    return tuple(issues), capabilities
+
+
+@contextmanager
+def _sanitized_model_environment() -> Iterator[None]:
+    """Hide historical untyped model switches while trusted UFO code executes."""
+
+    with _MODEL_LOAD_LOCK:
+        previous_dont_write_bytecode = sys.dont_write_bytecode
+        sys.dont_write_bytecode = True
+        removed = {
+            name: value
+            for name, value in os.environ.items()
+            if name.startswith(SANITIZED_MODEL_ENVIRONMENT_PREFIXES)
+        }
+        for name in removed:
+            os.environ.pop(name, None)
+        try:
+            yield
+        finally:
+            sys.dont_write_bytecode = previous_dont_write_bytecode
+            for name in tuple(os.environ):
+                if name.startswith(SANITIZED_MODEL_ENVIRONMENT_PREFIXES):
+                    os.environ.pop(name, None)
+            os.environ.update(removed)
+
+
+def _load_external_model(
+    source: Path,
+    *,
+    options: ModelCompileOptions,
+) -> dict[str, object]:
+    # These imports intentionally live inside the execution boundary so package
+    # import, metadata inspection, and built-in-SM planning stay dependency-light.
+    _require_ufo_model_loader()
+    with _sanitized_model_environment():
+        from ufo_model_loader.commands import load_model
+        from ufo_model_loader.common import JSONLook
+
+        restriction = _loader_restriction_name(source, options.restriction)
+        model, parameter_card = load_model(
+            str(source),
+            restriction,
+            options.simplify,
+            wrap_indices_in_lorentz_structures=False,
+        )
+        propagator_sources = _classify_external_propagators(model)
+        model.wrap_indices_in_lorentz_structures()
+        model_payload = json.loads(model.to_json(JSONLook.COMPACT))
+        raw_propagators = model_payload.get("propagators", [])
+        if not isinstance(raw_propagators, list):
+            raise ValueError("serialized model propagators must be a list")
+        for propagator in raw_propagators:
+            if not isinstance(propagator, dict):
+                raise ValueError("serialized model propagator must be an object")
+            particle = str(propagator["particle"])
+            propagator[PROPAGATOR_SOURCE_FIELD] = propagator_sources[particle]
+        return {
+            "loader_version": _distribution_version("ufo-model-loader", "missing"),
+            "model": model_payload,
+            "parameter_card": {
+                name: [value.real, value.imag]
+                for name, value in sorted(parameter_card.items())
+            },
+        }
+
+
+def _classify_external_propagators(model: Any) -> dict[str, str]:
+    """Classify propagators by expression, independently of UFO object names."""
+
+    from ufo_model_loader.model import Propagator
+
+    result: dict[str, str] = {}
+    for propagator in model.propagators:
+        actual = (
+            propagator.numerator.to_canonical_string(),
+            propagator.denominator.to_canonical_string(),
+        )
+        defaults = {
+            (
+                default.numerator.to_canonical_string(),
+                default.denominator.to_canonical_string(),
+            )
+            for default in _default_feynman_propagator_candidates(
+                Propagator,
+                propagator.particle,
+            )
+        }
+        result[str(propagator.particle.name)] = (
+            DEFAULT_FEYNMAN_PROPAGATOR_SOURCE
+            if actual in defaults
+            else MODEL_SUPPLIED_PROPAGATOR_SOURCE
+        )
+    return result
+
+
+def _default_feynman_propagator_candidates(
+    propagator_type: Any,
+    particle: Any,
+) -> tuple[Any, ...]:
+    """Cover loader defaults created before a restriction changes a mass value."""
+
+    current = propagator_type.from_particle(particle, "Feynman")
+    if particle.spin not in {1, 2, 3, -1}:
+        return (current,)
+    alternate_particle = copy(particle)
+    alternate_particle.mass = copy(particle.mass)
+    alternate_particle.mass.value = 0j if particle.is_massive() else 1.0 + 0j
+    alternate = propagator_type.from_particle(alternate_particle, "Feynman")
+    return current, alternate
+
+
+def _loader_restriction_name(source: Path, restriction: str) -> str | None:
+    """Translate the public restriction-file contract to the loader's name API."""
+
+    if restriction == DEFAULT_MODEL_RESTRICTION:
+        return None
+    if restriction == NO_MODEL_RESTRICTION:
+        return "full"
+
+    path = Path(restriction).expanduser()
+    if not path.is_absolute():
+        return restriction
+    path = path.resolve(strict=False)
+    if not path.is_file():
+        raise ValueError(f"model restriction file does not exist: {path}")
+
+    model_root = source if source.is_dir() else source.parent
+    if path.parent != model_root.resolve(strict=False):
+        raise ValueError(
+            "model restriction files must be stored next to the selected model"
+        )
+
+    suffix = ".dat" if source.is_dir() else ".json"
+    prefix = "restrict_"
+    if path.suffix.lower() != suffix or not path.name.startswith(prefix):
+        legacy_default = (
+            not source.is_dir() and path.name == f"{source.stem}_default.json"
+        )
+        if legacy_default:
+            return DEFAULT_MODEL_RESTRICTION
+        raise ValueError(
+            f"model restriction file must be named {prefix}<name>{suffix}: {path}"
+        )
+    name = path.name[len(prefix) : -len(suffix)]
+    if not name:
+        raise ValueError(f"model restriction filename has no restriction name: {path}")
+    return name
+
+
+def _model_expression_functions(model: Mapping[str, object]) -> set[str]:
+    expressions: list[str] = []
+    for key in ("parameters", "couplings", "propagators", "lorentz_structures"):
+        for item in _list_of_mappings(model.get(key, []), key):
+            for value in item.values():
+                if isinstance(value, str):
+                    expressions.append(value)
+    for vertex in _list_of_mappings(model.get("vertex_rules", []), "vertex_rules"):
+        expressions.extend(
+            str(value) for value in _sequence(vertex.get("color_structures"))
+        )
+    heads = set()
+    for expression in expressions:
+        for match in re.finditer(
+            r"(?:(?:UFO|spenso)::(?:\{\}::)?)?([A-Za-z][A-Za-z0-9_]*)\(",
+            expression,
+        ):
+            heads.add(match.group(1))
+    return heads
+
+
+def _source_digest(kind: str, source: str | Path) -> str:
+    digest = hashlib.sha256()
+    digest.update(kind.encode("utf-8") + b"\0")
+    if kind == "built-in-sm":
+        from .builtin.adapters import source_digest
+
+        digest.update(source_digest().encode("ascii"))
+        return digest.hexdigest()
+    path = Path(source)
+    root = path.parent if path.is_file() else path
+    files = (
+        [path]
+        if path.is_file()
+        else sorted(
+            item
+            for item in path.rglob("*")
+            if item.is_file()
+            and item.suffix != ".pyc"
+            and "__pycache__" not in item.parts
+        )
+    )
+    for item in files:
+        relative = item.name if path.is_file() else item.relative_to(root).as_posix()
+        digest.update(relative.encode("utf-8") + b"\0")
+        digest.update(item.read_bytes())
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def _compilation_cache_identity(
+    source_kind: str,
+    source: str | Path,
+    *,
+    options: ModelCompileOptions,
+    cache_dir: Path | None,
+) -> tuple[str, dict[str, object], Path]:
+    source_digest = _source_digest(source_kind, source)
+    fingerprint = compiler_fingerprint()
+    cache_key = hashlib.sha256(
+        json.dumps(
+            {
+                "source_digest": source_digest,
+                "options": options.canonical_payload(),
+                "producer": fingerprint,
+            },
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("utf-8")
+    ).hexdigest()
+    active_cache = cache_dir or _default_model_cache_dir()
+    return (
+        source_digest,
+        fingerprint,
+        active_cache / f"{cache_key}.pyAmplicol-model.json",
+    )
+
+
+def _model_compiler_digest() -> str:
+    digest = hashlib.sha256()
+    package_root = Path(__file__).resolve().parents[1]
+    for path in _model_compiler_source_paths():
+        relative = path.relative_to(package_root).as_posix()
+        digest.update(relative.encode("utf-8") + b"\0")
+        digest.update(path.read_bytes())
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def _model_compiler_source_paths() -> tuple[Path, ...]:
+    """Return every first-party source file that can change compiled model IR."""
+    package_root = Path(__file__).resolve().parents[1]
+    model_sources = Path(__file__).resolve().parent.glob("*.py")
+    physics_sources = (package_root / "_internal" / "physics").glob("*.py")
+    process_sources = (package_root / "processes" / "core_syntax.py",)
+    return tuple(sorted((*model_sources, *physics_sources, *process_sources)))
+
+
+def _default_model_cache_dir() -> Path:
+    configured = os.environ.get("PYAMPLICOL_CACHE_DIR")
+    if configured:
+        root = Path(configured).expanduser()
+    else:
+        from platformdirs import user_cache_path
+
+        root = user_cache_path("pyamplicol")
+    return root / "models"
+
+
+def _compiled_model_output_path(path: Path) -> Path:
+    text = str(path)
+    suffix = ".pyAmplicol-model.json"
+    return Path(text if text.endswith(suffix) else text + suffix)
+
+
+def _atomic_write_json(
+    path: Path,
+    payload: Mapping[str, object],
+    *,
+    compact: bool = False,
+) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    serialized = (
+        json.dumps(payload, separators=(",", ":"), sort_keys=True)
+        if compact
+        else json.dumps(payload, indent=2, sort_keys=True)
+    )
+    temporary.write_text(serialized + "\n", encoding="utf-8")
+    temporary.replace(path)
+
+
+def _atomic_copy(source: Path, path: Path) -> None:
+    source = source.resolve()
+    path = path.resolve()
+    if source == path:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    shutil.copyfile(source, temporary)
+    temporary.replace(path)
+
+
+def _distribution_version(name: str, default: str) -> str:
+    try:
+        return importlib.metadata.version(name)
+    except importlib.metadata.PackageNotFoundError:
+        return default
+
+
+def _raise_for_unsupported(
+    model: CompiledModel,
+    *,
+    require_supported: bool,
+) -> None:
+    if require_supported and not model.supported:
+        details = "; ".join(
+            f"{issue.code}: {issue.message}"
+            + (f" ({issue.context})" if issue.context else "")
+            for issue in model.issues
+            if issue.severity == "error"
+        )
+        raise ValueError(f"model {model.name!r} is not supported: {details}")
+
+
+def _mapping(value: object, context: str) -> dict[str, object]:
+    if not isinstance(value, dict):
+        raise ValueError(f"{context} must be an object")
+    return {str(key): item for key, item in value.items()}
+
+
+def _sequence(value: object) -> list[object]:
+    if isinstance(value, (list, tuple)):
+        return list(value)
+    return []
+
+
+def _list_of_mappings(value: object, context: str) -> list[dict[str, object]]:
+    return [_mapping(item, context) for item in _sequence(value)]
+
+
+def _complex_pair(value: object, *, context: str) -> tuple[float, float]:
+    pair = _sequence(value)
+    if len(pair) != 2:
+        raise ValueError(f"{context} must be [real, imaginary]")
+    return float(pair[0]), float(pair[1])
diff --git a/pyamplicol/src/pyamplicol/models/prepared.py b/pyamplicol/src/pyamplicol/models/prepared.py
new file mode 100644
index 0000000000..5e17fd9790
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/prepared.py
@@ -0,0 +1,2238 @@
+# SPDX-License-Identifier: 0BSD
+"""Deterministic prepared-model bundle container contract.
+
+This module owns the portable container format only. Kernel compilation and
+backend-specific manifest interpretation belong to the model compiler and
+runtime respectively.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import stat
+import tempfile
+import zipfile
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path, PurePosixPath
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Literal, TypeAlias, cast
+
+if TYPE_CHECKING:
+    from .recurrence_direct_template import RecurrenceDirectTemplateCatalogV1
+    from .recurrence_template import RecurrenceTemplateCatalog
+
+PREPARED_MODEL_BUNDLE_KIND = "pyamplicol-prepared-model"
+PREPARED_MODEL_BUNDLE_SCHEMA_VERSION = 1
+PREPARED_MODEL_BUNDLE_SUFFIX = ".pyamplicol-model"
+EAGER_KERNEL_ABI = "pyamplicol-eager-kernel-v1"
+EAGER_KERNEL_ABI_VERSION = 1
+PREPARED_KERNEL_VARIANT_ABI = "pyamplicol-prepared-kernel-variant-v2"
+PREPARED_KERNEL_PACK_IDENTITY_ABI = "pyamplicol-prepared-kernel-pack-identity-v2"
+PREPARED_INDEPENDENT_BLOCK_SIZE = 4
+PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL = 2
+PREPARED_JIT_PORTABLE_TARGET = "symjit-storage-v3-portable"
+PREPARED_SYMJIT_PLANE_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+
+PREPARED_MODEL_MANIFEST_PATH = "manifest.json"
+PREPARED_MODEL_COMPILED_MODEL_PATH = "model/model.pyAmplicol-model.json"
+
+PreparedBackend: TypeAlias = Literal["jit", "asm", "cpp"]
+KernelContractKind: TypeAlias = Literal[
+    "vertex",
+    "propagator",
+    "closure",
+    "model-parameter",
+]
+PayloadSource: TypeAlias = bytes | bytearray | memoryview | Path
+PreparedKernelVariantKind: TypeAlias = Literal["independent-block"]
+PreparedKernelLaneLayout: TypeAlias = Literal["lane-major"]
+
+_BACKENDS = frozenset(("jit", "asm", "cpp"))
+_CONTRACT_KINDS = frozenset(("vertex", "propagator", "closure", "model-parameter"))
+_PATH_FIELDS = frozenset(
+    (
+        "application_path",
+        "descriptor_path",
+        "evaluator_state_path",
+        "library_path",
+        "payload_path",
+        "source_path",
+    )
+)
+_PATH_LIST_FIELDS = frozenset(("payload_paths",))
+_SHA256_LENGTH = 64
+_ZIP_TIMESTAMP = (1980, 1, 1, 0, 0, 0)
+_ZIP_FILE_MODE = (stat.S_IFREG | 0o644) << 16
+
+
+class PreparedModelBundleError(ValueError):
+    """Raised when a prepared-model bundle violates its container contract."""
+
+
+def _freeze_json(value: object, context: str) -> object:
+    if value is None or isinstance(value, (str, bool, int)):
+        return value
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            raise PreparedModelBundleError(
+                f"{context} must not contain NaN or infinity"
+            )
+        return value
+    if isinstance(value, Mapping):
+        frozen: dict[str, object] = {}
+        for key, item in value.items():
+            if not isinstance(key, str):
+                raise PreparedModelBundleError(f"{context} keys must be strings")
+            frozen[key] = _freeze_json(item, f"{context}.{key}")
+        return MappingProxyType(frozen)
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return tuple(
+            _freeze_json(item, f"{context}[{index}]")
+            for index, item in enumerate(value)
+        )
+    raise PreparedModelBundleError(
+        f"{context} contains unsupported value {type(value).__name__}"
+    )
+
+
+def _freeze_mapping(value: Mapping[str, object], context: str) -> Mapping[str, object]:
+    frozen = _freeze_json(value, context)
+    if not isinstance(frozen, Mapping):  # pragma: no cover - guarded by annotation
+        raise PreparedModelBundleError(f"{context} must be an object")
+    return cast(Mapping[str, object], frozen)
+
+
+def _thaw_json(value: object) -> object:
+    if isinstance(value, Mapping):
+        return {str(key): _thaw_json(item) for key, item in value.items()}
+    if isinstance(value, tuple):
+        return [_thaw_json(item) for item in value]
+    return value
+
+
+def _mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):
+        raise PreparedModelBundleError(f"{context} must be an object with string keys")
+    return cast(Mapping[str, object], value)
+
+
+def _sequence(value: object, context: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise PreparedModelBundleError(f"{context} must be an array")
+    return value
+
+
+def _require_exact_keys(
+    value: Mapping[str, object],
+    context: str,
+    expected: frozenset[str],
+) -> None:
+    missing = expected - value.keys()
+    unknown = value.keys() - expected
+    if missing:
+        raise PreparedModelBundleError(
+            f"{context} is missing fields: {', '.join(sorted(missing))}"
+        )
+    if unknown:
+        raise PreparedModelBundleError(
+            f"{context} has unknown fields: {', '.join(sorted(unknown))}"
+        )
+
+
+def _nonempty_string(value: object, context: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise PreparedModelBundleError(f"{context} must be a non-empty string")
+    return value
+
+
+def _nonnegative_integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise PreparedModelBundleError(f"{context} must be an integer >= 0")
+    return value
+
+
+def _positive_integer(value: object, context: str) -> int:
+    result = _nonnegative_integer(value, context)
+    if result == 0:
+        raise PreparedModelBundleError(f"{context} must be an integer >= 1")
+    return result
+
+
+def _validate_portable_jit_manifest(
+    value: Mapping[str, object],
+    context: str,
+) -> None:
+    if value.get("kind") != "symjit-application-evaluator":
+        raise PreparedModelBundleError(
+            f"prepared JIT {context} must contain a SymJIT application evaluator"
+        )
+    level = value.get("optimization_level")
+    if level != PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL:
+        raise PreparedModelBundleError(
+            f"prepared JIT {context} must use portable SymJIT optimization "
+            f"level {PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL}, found {level!r}"
+        )
+    settings = _mapping(value.get("settings"), f"prepared JIT {context}.settings")
+    if (
+        settings.get("jit_optimization_level")
+        != PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL
+    ):
+        raise PreparedModelBundleError(
+            f"prepared JIT {context} settings do not attest portable SymJIT "
+            f"optimization level {PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL}"
+        )
+
+
+def _normalized_member_path(value: object, context: str) -> str:
+    path = _nonempty_string(value, context)
+    if "\\" in path or "\x00" in path:
+        raise PreparedModelBundleError(
+            f"{context} must be a normalized relative POSIX path"
+        )
+    pure = PurePosixPath(path)
+    if (
+        pure.is_absolute()
+        or path.endswith("/")
+        or pure.as_posix() != path
+        or any(part in {"", ".", ".."} for part in pure.parts)
+    ):
+        raise PreparedModelBundleError(
+            f"{context} must be a normalized relative POSIX path"
+        )
+    return path
+
+
+def _canonical_json(payload: Mapping[str, object]) -> bytes:
+    try:
+        serialized = json.dumps(
+            _thaw_json(payload),
+            ensure_ascii=True,
+            allow_nan=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+    except (TypeError, ValueError) as error:
+        raise PreparedModelBundleError(
+            f"payload is not canonical JSON: {error}"
+        ) from error
+    return (serialized + "\n").encode("ascii")
+
+
+def _sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def _valid_sha256(value: object, context: str) -> str:
+    digest = _nonempty_string(value, context)
+    if len(digest) != _SHA256_LENGTH or any(
+        character not in "0123456789abcdef" for character in digest
+    ):
+        raise PreparedModelBundleError(f"{context} must be a lowercase SHA-256")
+    return digest
+
+
+def _mapping_digest(value: Mapping[str, object]) -> str:
+    return _sha256(_canonical_json(value))
+
+
+def prepared_kernel_pack_manifest_identity_sha256(
+    manifest: Mapping[str, object],
+) -> str:
+    """Return the outer identity of one canonical prepared-bundle manifest.
+
+    This is deliberately distinct from :func:`prepared_kernel_pack_identity`,
+    which authenticates the callable kernel contract and referenced payloads.
+    Artifact manifests use this identity to name the exact prepared bundle from
+    which their copied evaluator pack was derived.
+    """
+
+    normalized = _freeze_mapping(manifest, "prepared bundle manifest identity")
+    canonical_manifest = json.dumps(
+        _thaw_json(normalized),
+        ensure_ascii=True,
+        allow_nan=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return _sha256(
+        PREPARED_KERNEL_PACK_IDENTITY_ABI.encode("ascii")
+        + b"\x00"
+        + canonical_manifest
+    )
+
+
+def prepared_expression_digest(expressions: Sequence[str]) -> str:
+    """Digest the ordered exact-expression contract of a scalar kernel."""
+
+    return _mapping_digest({"exact_expressions": list(expressions)})
+
+
+def prepared_input_contract_digest(
+    input_layout: Sequence[str],
+    input_contracts: Sequence[Mapping[str, object]],
+) -> str:
+    """Digest scalar input ordering, roles, symbols, and parameter metadata."""
+
+    return _mapping_digest(
+        {
+            "input_arity": len(input_layout),
+            "input_layout": list(input_layout),
+            "input_contracts": [
+                cast(dict[str, object], _thaw_json(contract))
+                for contract in input_contracts
+            ],
+        }
+    )
+
+
+def prepared_output_contract_digest(output_layout: Sequence[str]) -> str:
+    """Digest scalar output ordering and labels."""
+
+    return _mapping_digest(
+        {
+            "output_arity": len(output_layout),
+            "output_layout": list(output_layout),
+        }
+    )
+
+
+def prepared_optimization_settings_digest(
+    settings: Mapping[str, object],
+) -> str:
+    """Digest the backend optimization contract bound to a variant payload."""
+
+    return _mapping_digest(settings)
+
+
+def _recurrence_input_contract_layout(
+    contracts: Sequence[Mapping[str, object]],
+) -> tuple[str, ...]:
+    """Return the canonical input contract used by recurrence bindings."""
+
+    return tuple(
+        json.dumps(
+            cast(dict[str, object], _thaw_json(contract)),
+            ensure_ascii=True,
+            allow_nan=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        for contract in contracts
+    )
+
+
+def _validate_recurrence_kernel_bindings(
+    catalog: RecurrenceTemplateCatalog,
+    kernels: Sequence[PreparedKernelRecord],
+) -> None:
+    """Authenticate every recurrence callable against its prepared kernel."""
+
+    by_id = {kernel.kernel_id: kernel for kernel in kernels}
+    for binding in catalog.evaluator_bindings:
+        if binding.callable_kind != "prepared-kernel":
+            continue
+        kernel_id = binding.prepared_kernel_id
+        assert kernel_id is not None  # EvaluatorBindingV1 invariant.
+        kernel = by_id.get(kernel_id)
+        if kernel is None:
+            raise PreparedModelBundleError(
+                "recurrence evaluator binding references unknown prepared kernel "
+                f"ID {kernel_id}"
+            )
+        context = f"recurrence evaluator {binding.resolver_key!r}"
+        expected = {
+            "contract kind": kernel.contract_kind,
+            "callable signature": kernel.canonical_signature,
+            "input layout": _recurrence_input_contract_layout(kernel.input_contracts),
+            "output layout": kernel.output_layout,
+            "exact expression digests": tuple(
+                hashlib.sha256(expression.encode("utf-8")).hexdigest()
+                for expression in kernel.exact_expressions
+            ),
+        }
+        actual = {
+            "contract kind": binding.contract_kind,
+            "callable signature": binding.callable_signature,
+            "input layout": binding.input_layout,
+            "output layout": binding.output_layout,
+            "exact expression digests": binding.exact_expression_digests,
+        }
+        for name, expected_value in expected.items():
+            if actual[name] != expected_value:
+                raise PreparedModelBundleError(
+                    f"{context} {name} does not match prepared kernel {kernel_id}"
+                )
+
+
+def _validate_recurrence_direct_bindings(
+    direct_catalog: RecurrenceDirectTemplateCatalogV1,
+    semantic_catalog: RecurrenceTemplateCatalog,
+    kernels: Sequence[PreparedKernelRecord],
+    *,
+    backend: PreparedBackend,
+    target: Mapping[str, object],
+    optimization_settings: Mapping[str, object],
+) -> None:
+    """Authenticate stable semantic-binding to direct-executor mappings."""
+
+    if (
+        direct_catalog.compiled_model_digest
+        != semantic_catalog.header.compiled_model_digest
+        or direct_catalog.recurrence_template_catalog_digest
+        != semantic_catalog.catalog_digest
+        or direct_catalog.prepared_kernel_pack_digest
+        != semantic_catalog.header.prepared_kernel_pack_digest
+    ):
+        raise PreparedModelBundleError(
+            "direct recurrence companion does not match its semantic catalog"
+        )
+    if (
+        direct_catalog.backend != backend
+        or direct_catalog.target_triple != target.get("target_triple")
+        or direct_catalog.portable != target.get("portable")
+        or direct_catalog.optimization_settings_digest
+        != prepared_optimization_settings_digest(optimization_settings)
+    ):
+        raise PreparedModelBundleError(
+            "direct recurrence companion backend/target provenance does not "
+            "match its prepared pack"
+        )
+
+    role_for_contract = {
+        "source": "source",
+        "vertex": "contribution",
+        "propagator": "finalization",
+        "closure": "closure",
+    }
+    by_kernel_id = {kernel.kernel_id: kernel for kernel in kernels}
+    required: set[tuple[str, int]] = set()
+    for evaluator_binding_id, binding in enumerate(semantic_catalog.evaluator_bindings):
+        role = role_for_contract.get(binding.contract_kind)
+        if role is None:
+            continue
+        required.add((role, evaluator_binding_id))
+        try:
+            executor_id = direct_catalog.direct_executor_id_for(  # type: ignore[arg-type]
+                role,
+                evaluator_binding_id,
+            )
+        except ValueError as exc:
+            raise PreparedModelBundleError(str(exc)) from exc
+        template = direct_catalog.templates[executor_id]
+        if (
+            template.evaluator_resolver_key != binding.resolver_key
+            or template.semantic_template_ids != binding.semantic_template_ids
+        ):
+            raise PreparedModelBundleError(
+                "direct recurrence executor mapping does not match semantic "
+                f"evaluator binding {evaluator_binding_id}"
+            )
+        payload_kernel_id = template.payload_binding.prepared_kernel_id
+        if binding.callable_kind == "prepared-kernel":
+            prepared_payload_matches = (
+                template.payload_binding.kind == "prepared-direct-call"
+                and payload_kernel_id == binding.prepared_kernel_id
+                and payload_kernel_id in by_kernel_id
+            )
+            certified_intrinsic_matches = (
+                template.role == "contribution"
+                and template.payload_binding.kind == "rusticol-intrinsic"
+                and template.payload_binding.intrinsic_contract_digest is not None
+                and payload_kernel_id is None
+            )
+            finalization_intrinsic_matches = (
+                template.role == "finalization"
+                and template.payload_binding.kind == "rusticol-intrinsic"
+                and template.payload_binding.runtime_template is not None
+                and payload_kernel_id is None
+            )
+            if not (
+                prepared_payload_matches
+                or certified_intrinsic_matches
+                or finalization_intrinsic_matches
+            ):
+                raise PreparedModelBundleError(
+                    "direct recurrence prepared payload does not match semantic "
+                    f"evaluator binding {evaluator_binding_id}"
+                )
+        elif (
+            template.payload_binding.kind != "rusticol-intrinsic"
+            or template.payload_binding.runtime_template != binding.runtime_template
+        ):
+            raise PreparedModelBundleError(
+                "direct recurrence intrinsic does not match semantic evaluator "
+                f"binding {evaluator_binding_id}"
+            )
+
+    identity_propagators = {
+        propagator.template_id
+        for propagator in semantic_catalog.propagators
+        if not propagator.applies_propagator
+    }
+    mapped_identity: set[str] = set()
+    semantic_binding_count = len(semantic_catalog.evaluator_bindings)
+    for template in direct_catalog.templates:
+        key = (template.role, template.evaluator_binding_id)
+        if template.evaluator_binding_id < semantic_binding_count:
+            if key not in required:
+                raise PreparedModelBundleError(
+                    "direct recurrence companion exposes an unexpected semantic "
+                    f"evaluator mapping {key!r}"
+                )
+            continue
+        if (
+            template.role != "finalization"
+            or template.payload_binding.kind != "rusticol-intrinsic"
+            or not template.payload_binding.runtime_template
+            or template.payload_binding.runtime_template
+            != "rusticol.identity-finalize-in-place.v1"
+            or not set(template.semantic_template_ids) <= identity_propagators
+        ):
+            raise PreparedModelBundleError(
+                "direct recurrence synthetic evaluator is not an authenticated "
+                "identity finalizer"
+            )
+        mapped_identity.update(template.semantic_template_ids)
+    if mapped_identity != identity_propagators:
+        raise PreparedModelBundleError(
+            "direct recurrence companion does not cover every identity finalizer"
+        )
+
+
+def prepared_compiled_model_digest(compiled_model: Mapping[str, object]) -> str:
+    """Digest the exact canonical compiled-model member stored in a bundle."""
+
+    frozen = _freeze_mapping(compiled_model, "compiled_model")
+    return _sha256(_canonical_json(frozen))
+
+
+def _collect_manifest_paths(value: object, *, context: str) -> tuple[str, ...]:
+    paths: list[str] = []
+
+    def visit(item: object, item_context: str) -> None:
+        if isinstance(item, Mapping):
+            for key, child in item.items():
+                if key in _PATH_FIELDS:
+                    if child is not None:
+                        paths.append(
+                            _normalized_member_path(child, f"{item_context}.{key}")
+                        )
+                elif key in _PATH_LIST_FIELDS:
+                    for index, path in enumerate(
+                        _sequence(child, f"{item_context}.{key}")
+                    ):
+                        paths.append(
+                            _normalized_member_path(
+                                path,
+                                f"{item_context}.{key}[{index}]",
+                            )
+                        )
+                else:
+                    visit(child, f"{item_context}.{key}")
+        elif isinstance(item, Sequence) and not isinstance(
+            item, (str, bytes, bytearray)
+        ):
+            for index, child in enumerate(item):
+                visit(child, f"{item_context}[{index}]")
+
+    visit(value, context)
+    return tuple(sorted(set(paths)))
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedKernelVariantRecord:
+    """One backend evaluator that packs independent scalar kernel calls."""
+
+    variant_id: str
+    variant_abi: str
+    kind: PreparedKernelVariantKind
+    block_size: int
+    lane_layout: PreparedKernelLaneLayout
+    base_kernel_id: int
+    base_canonical_signature: str
+    base_expression_digest: str
+    base_input_contract_digest: str
+    base_output_contract_digest: str
+    backend: PreparedBackend
+    optimization_settings_digest: str
+    input_arity: int
+    output_arity: int
+    input_lane_stride: int
+    output_lane_stride: int
+    input_layout: tuple[str, ...]
+    output_layout: tuple[str, ...]
+    f64_evaluator_manifest: Mapping[str, object]
+    _referenced_payload_paths: tuple[str, ...] = field(
+        init=False,
+        repr=False,
+        compare=False,
+    )
+
+    def __post_init__(self) -> None:
+        _nonempty_string(self.variant_id, "kernel_variant.variant_id")
+        if self.variant_abi != PREPARED_KERNEL_VARIANT_ABI:
+            raise PreparedModelBundleError(
+                f"unsupported prepared kernel variant ABI {self.variant_abi!r}; "
+                "regenerate the prepared model with this pyAmpliCol version"
+            )
+        if self.kind != "independent-block":
+            raise PreparedModelBundleError(
+                f"unsupported prepared kernel variant kind {self.kind!r}"
+            )
+        block_size = _positive_integer(
+            self.block_size,
+            "kernel_variant.block_size",
+        )
+        if block_size != PREPARED_INDEPENDENT_BLOCK_SIZE:
+            raise PreparedModelBundleError(
+                "independent-block variants currently require block_size = 4"
+            )
+        if self.variant_id != f"independent-block-{block_size}":
+            raise PreparedModelBundleError(
+                "independent-block variant ID does not match its block size"
+            )
+        if self.lane_layout != "lane-major":
+            raise PreparedModelBundleError(
+                "independent-block variants require lane-major layout"
+            )
+        _nonnegative_integer(
+            self.base_kernel_id,
+            "kernel_variant.base_kernel_id",
+        )
+        _valid_sha256(
+            self.base_canonical_signature,
+            "kernel_variant.base_canonical_signature",
+        )
+        for name in (
+            "base_expression_digest",
+            "base_input_contract_digest",
+            "base_output_contract_digest",
+            "optimization_settings_digest",
+        ):
+            _valid_sha256(getattr(self, name), f"kernel_variant.{name}")
+        if self.backend not in _BACKENDS:
+            raise PreparedModelBundleError(
+                f"unsupported prepared variant backend {self.backend!r}"
+            )
+        input_arity = _positive_integer(
+            self.input_arity,
+            "kernel_variant.input_arity",
+        )
+        output_arity = _positive_integer(
+            self.output_arity,
+            "kernel_variant.output_arity",
+        )
+        input_lane_stride = _positive_integer(
+            self.input_lane_stride,
+            "kernel_variant.input_lane_stride",
+        )
+        output_lane_stride = _positive_integer(
+            self.output_lane_stride,
+            "kernel_variant.output_lane_stride",
+        )
+        if input_arity != block_size * input_lane_stride:
+            raise PreparedModelBundleError(
+                "kernel variant input arity must equal block_size * input_lane_stride"
+            )
+        if output_arity != block_size * output_lane_stride:
+            raise PreparedModelBundleError(
+                "kernel variant output arity must equal block_size * output_lane_stride"
+            )
+        input_layout = tuple(
+            _nonempty_string(item, f"kernel_variant.input_layout[{index}]")
+            for index, item in enumerate(self.input_layout)
+        )
+        output_layout = tuple(
+            _nonempty_string(item, f"kernel_variant.output_layout[{index}]")
+            for index, item in enumerate(self.output_layout)
+        )
+        if len(input_layout) != input_arity:
+            raise PreparedModelBundleError(
+                "kernel variant input layout length must equal input arity"
+            )
+        if len(output_layout) != output_arity:
+            raise PreparedModelBundleError(
+                "kernel variant output layout length must equal output arity"
+            )
+        object.__setattr__(self, "input_layout", input_layout)
+        object.__setattr__(self, "output_layout", output_layout)
+        if not self.f64_evaluator_manifest:
+            raise PreparedModelBundleError(
+                "kernel_variant.f64_evaluator_manifest must not be empty"
+            )
+        manifest = _freeze_mapping(
+            self.f64_evaluator_manifest,
+            "kernel_variant.f64_evaluator_manifest",
+        )
+        if manifest.get("input_len") != input_arity:
+            raise PreparedModelBundleError(
+                "kernel variant evaluator input_len does not match input arity"
+            )
+        if manifest.get("output_len") != output_arity:
+            raise PreparedModelBundleError(
+                "kernel variant evaluator output_len does not match output arity"
+            )
+        object.__setattr__(self, "f64_evaluator_manifest", manifest)
+        object.__setattr__(
+            self,
+            "_referenced_payload_paths",
+            _collect_manifest_paths(
+                manifest,
+                context="kernel_variant.f64_evaluator_manifest",
+            ),
+        )
+
+    @property
+    def referenced_payload_paths(self) -> tuple[str, ...]:
+        return self._referenced_payload_paths
+
+    def validate_base_kernel(self, kernel: PreparedKernelRecord) -> None:
+        """Validate every immutable binding back to the scalar kernel."""
+
+        if self.base_kernel_id != kernel.kernel_id:
+            raise PreparedModelBundleError(
+                "kernel variant base_kernel_id does not match its scalar kernel"
+            )
+        if self.base_canonical_signature != kernel.canonical_signature:
+            raise PreparedModelBundleError(
+                "kernel variant canonical signature does not match its scalar kernel"
+            )
+        expected = (
+            prepared_expression_digest(kernel.exact_expressions),
+            prepared_input_contract_digest(
+                kernel.input_layout,
+                kernel.input_contracts,
+            ),
+            prepared_output_contract_digest(kernel.output_layout),
+        )
+        actual = (
+            self.base_expression_digest,
+            self.base_input_contract_digest,
+            self.base_output_contract_digest,
+        )
+        if actual != expected:
+            raise PreparedModelBundleError(
+                "kernel variant scalar contract digest does not match its base kernel"
+            )
+        if self.input_lane_stride != kernel.input_arity:
+            raise PreparedModelBundleError(
+                "kernel variant input lane stride does not match its base kernel"
+            )
+        if self.output_lane_stride != kernel.output_arity:
+            raise PreparedModelBundleError(
+                "kernel variant output lane stride does not match its base kernel"
+            )
+        expected_inputs = tuple(
+            f"lane:{lane}:{item}"
+            for lane in range(self.block_size)
+            for item in kernel.input_layout
+        )
+        expected_outputs = tuple(
+            f"lane:{lane}:{item}"
+            for lane in range(self.block_size)
+            for item in kernel.output_layout
+        )
+        if (
+            self.input_layout != expected_inputs
+            or self.output_layout != expected_outputs
+        ):
+            raise PreparedModelBundleError(
+                "kernel variant lane-major layout does not match its base kernel"
+            )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "variant_id": self.variant_id,
+            "variant_abi": self.variant_abi,
+            "kind": self.kind,
+            "block_size": self.block_size,
+            "lane_layout": self.lane_layout,
+            "base_kernel_id": self.base_kernel_id,
+            "base_canonical_signature": self.base_canonical_signature,
+            "base_expression_digest": self.base_expression_digest,
+            "base_input_contract_digest": self.base_input_contract_digest,
+            "base_output_contract_digest": self.base_output_contract_digest,
+            "backend": self.backend,
+            "optimization_settings_digest": self.optimization_settings_digest,
+            "input_arity": self.input_arity,
+            "output_arity": self.output_arity,
+            "input_lane_stride": self.input_lane_stride,
+            "output_lane_stride": self.output_lane_stride,
+            "input_layout": list(self.input_layout),
+            "output_layout": list(self.output_layout),
+            "f64_evaluator_manifest": _thaw_json(self.f64_evaluator_manifest),
+        }
+
+    @classmethod
+    def from_dict(cls, value: Mapping[str, object]) -> PreparedKernelVariantRecord:
+        expected = frozenset(
+            (
+                "variant_id",
+                "variant_abi",
+                "kind",
+                "block_size",
+                "lane_layout",
+                "base_kernel_id",
+                "base_canonical_signature",
+                "base_expression_digest",
+                "base_input_contract_digest",
+                "base_output_contract_digest",
+                "backend",
+                "optimization_settings_digest",
+                "input_arity",
+                "output_arity",
+                "input_lane_stride",
+                "output_lane_stride",
+                "input_layout",
+                "output_layout",
+                "f64_evaluator_manifest",
+            )
+        )
+        _require_exact_keys(value, "kernel_variant", expected)
+        return cls(
+            variant_id=_nonempty_string(
+                value.get("variant_id"), "kernel_variant.variant_id"
+            ),
+            variant_abi=_nonempty_string(
+                value.get("variant_abi"), "kernel_variant.variant_abi"
+            ),
+            kind=cast(
+                PreparedKernelVariantKind,
+                _nonempty_string(value.get("kind"), "kernel_variant.kind"),
+            ),
+            block_size=_positive_integer(
+                value.get("block_size"), "kernel_variant.block_size"
+            ),
+            lane_layout=cast(
+                PreparedKernelLaneLayout,
+                _nonempty_string(
+                    value.get("lane_layout"), "kernel_variant.lane_layout"
+                ),
+            ),
+            base_kernel_id=_nonnegative_integer(
+                value.get("base_kernel_id"), "kernel_variant.base_kernel_id"
+            ),
+            base_canonical_signature=_nonempty_string(
+                value.get("base_canonical_signature"),
+                "kernel_variant.base_canonical_signature",
+            ),
+            base_expression_digest=_nonempty_string(
+                value.get("base_expression_digest"),
+                "kernel_variant.base_expression_digest",
+            ),
+            base_input_contract_digest=_nonempty_string(
+                value.get("base_input_contract_digest"),
+                "kernel_variant.base_input_contract_digest",
+            ),
+            base_output_contract_digest=_nonempty_string(
+                value.get("base_output_contract_digest"),
+                "kernel_variant.base_output_contract_digest",
+            ),
+            backend=cast(
+                PreparedBackend,
+                _nonempty_string(value.get("backend"), "kernel_variant.backend"),
+            ),
+            optimization_settings_digest=_nonempty_string(
+                value.get("optimization_settings_digest"),
+                "kernel_variant.optimization_settings_digest",
+            ),
+            input_arity=_positive_integer(
+                value.get("input_arity"), "kernel_variant.input_arity"
+            ),
+            output_arity=_positive_integer(
+                value.get("output_arity"), "kernel_variant.output_arity"
+            ),
+            input_lane_stride=_positive_integer(
+                value.get("input_lane_stride"),
+                "kernel_variant.input_lane_stride",
+            ),
+            output_lane_stride=_positive_integer(
+                value.get("output_lane_stride"),
+                "kernel_variant.output_lane_stride",
+            ),
+            input_layout=tuple(
+                _nonempty_string(item, f"kernel_variant.input_layout[{index}]")
+                for index, item in enumerate(
+                    _sequence(value.get("input_layout"), "kernel_variant.input_layout")
+                )
+            ),
+            output_layout=tuple(
+                _nonempty_string(item, f"kernel_variant.output_layout[{index}]")
+                for index, item in enumerate(
+                    _sequence(
+                        value.get("output_layout"), "kernel_variant.output_layout"
+                    )
+                )
+            ),
+            f64_evaluator_manifest=_mapping(
+                value.get("f64_evaluator_manifest"),
+                "kernel_variant.f64_evaluator_manifest",
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedKernelRecord:
+    """One canonical eager kernel and its exact/f64 evaluator contracts."""
+
+    kernel_id: int
+    contract_kind: KernelContractKind
+    canonical_signature: str
+    input_arity: int
+    output_arity: int
+    input_layout: tuple[str, ...]
+    input_contracts: tuple[Mapping[str, object], ...]
+    output_layout: tuple[str, ...]
+    exact_expressions: tuple[str, ...]
+    exact_evaluator_state_path: str
+    f64_evaluator_manifest: Mapping[str, object]
+    proof_classes: tuple[str, ...] = ()
+    _referenced_payload_paths: tuple[str, ...] = field(
+        init=False,
+        repr=False,
+        compare=False,
+    )
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "kernel_id",
+            _nonnegative_integer(self.kernel_id, "kernel.kernel_id"),
+        )
+        if self.contract_kind not in _CONTRACT_KINDS:
+            raise PreparedModelBundleError(
+                f"unsupported kernel contract kind {self.contract_kind!r}"
+            )
+        _nonempty_string(self.canonical_signature, "kernel.canonical_signature")
+        input_arity = _nonnegative_integer(self.input_arity, "kernel.input_arity")
+        output_arity = _nonnegative_integer(self.output_arity, "kernel.output_arity")
+        input_layout = tuple(
+            _nonempty_string(item, f"kernel.input_layout[{index}]")
+            for index, item in enumerate(self.input_layout)
+        )
+        output_layout = tuple(
+            _nonempty_string(item, f"kernel.output_layout[{index}]")
+            for index, item in enumerate(self.output_layout)
+        )
+        if len(input_layout) != input_arity:
+            raise PreparedModelBundleError(
+                "kernel input layout length must equal input arity"
+            )
+        if len(output_layout) != output_arity:
+            raise PreparedModelBundleError(
+                "kernel output layout length must equal output arity"
+            )
+        object.__setattr__(self, "input_layout", input_layout)
+        object.__setattr__(self, "output_layout", output_layout)
+        input_contracts = tuple(
+            _freeze_mapping(item, f"kernel.input_contracts[{index}]")
+            for index, item in enumerate(self.input_contracts)
+        )
+        if len(input_contracts) != input_arity:
+            raise PreparedModelBundleError(
+                "kernel input contract count must equal input arity"
+            )
+        for index, contract in enumerate(input_contracts):
+            _require_exact_keys(
+                contract,
+                f"kernel.input_contracts[{index}]",
+                frozenset(
+                    (
+                        "role",
+                        "component",
+                        "symbol",
+                        "model_parameter_name",
+                        "model_parameter_index",
+                    )
+                ),
+            )
+            _nonempty_string(
+                contract.get("role"), f"kernel.input_contracts[{index}].role"
+            )
+            _nonnegative_integer(
+                contract.get("component"),
+                f"kernel.input_contracts[{index}].component",
+            )
+            _nonempty_string(
+                contract.get("symbol"),
+                f"kernel.input_contracts[{index}].symbol",
+            )
+        object.__setattr__(self, "input_contracts", input_contracts)
+        exact_expressions = tuple(
+            _nonempty_string(item, f"kernel.exact_expressions[{index}]")
+            for index, item in enumerate(self.exact_expressions)
+        )
+        if len(exact_expressions) != output_arity:
+            raise PreparedModelBundleError(
+                "kernel exact expression count must equal output arity"
+            )
+        object.__setattr__(self, "exact_expressions", exact_expressions)
+        object.__setattr__(
+            self,
+            "exact_evaluator_state_path",
+            _normalized_member_path(
+                self.exact_evaluator_state_path,
+                "kernel.exact_evaluator_state_path",
+            ),
+        )
+        if not self.f64_evaluator_manifest:
+            raise PreparedModelBundleError(
+                "kernel.f64_evaluator_manifest must not be empty"
+            )
+        object.__setattr__(
+            self,
+            "f64_evaluator_manifest",
+            _freeze_mapping(
+                self.f64_evaluator_manifest,
+                "kernel.f64_evaluator_manifest",
+            ),
+        )
+        proof_classes = tuple(
+            _nonempty_string(item, f"kernel.proof_classes[{index}]")
+            for index, item in enumerate(self.proof_classes)
+        )
+        if proof_classes != tuple(sorted(set(proof_classes))):
+            raise PreparedModelBundleError(
+                "kernel proof classes must be sorted and unique"
+            )
+        object.__setattr__(self, "proof_classes", proof_classes)
+        object.__setattr__(
+            self,
+            "_referenced_payload_paths",
+            tuple(
+                sorted(
+                    {
+                        self.exact_evaluator_state_path,
+                        *_collect_manifest_paths(
+                            self.f64_evaluator_manifest,
+                            context="kernel.f64_evaluator_manifest",
+                        ),
+                    }
+                )
+            ),
+        )
+
+    @property
+    def referenced_payload_paths(self) -> tuple[str, ...]:
+        return self._referenced_payload_paths
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "kernel_id": self.kernel_id,
+            "contract_kind": self.contract_kind,
+            "canonical_signature": self.canonical_signature,
+            "input_arity": self.input_arity,
+            "output_arity": self.output_arity,
+            "input_layout": list(self.input_layout),
+            "input_contracts": [
+                _thaw_json(contract) for contract in self.input_contracts
+            ],
+            "output_layout": list(self.output_layout),
+            "exact_expressions": list(self.exact_expressions),
+            "proof_classes": list(self.proof_classes),
+            "exact_evaluator_state_path": self.exact_evaluator_state_path,
+            "f64_evaluator_manifest": _thaw_json(self.f64_evaluator_manifest),
+        }
+
+    @classmethod
+    def from_dict(cls, value: Mapping[str, object]) -> PreparedKernelRecord:
+        normalized = dict(value)
+        expected = frozenset(
+            (
+                "kernel_id",
+                "contract_kind",
+                "canonical_signature",
+                "input_arity",
+                "output_arity",
+                "input_layout",
+                "input_contracts",
+                "output_layout",
+                "exact_expressions",
+                "proof_classes",
+                "exact_evaluator_state_path",
+                "f64_evaluator_manifest",
+            )
+        )
+        _require_exact_keys(normalized, "kernel", expected)
+        contract_kind = _nonempty_string(
+            normalized.get("contract_kind"),
+            "kernel.contract_kind",
+        )
+        return cls(
+            kernel_id=_nonnegative_integer(
+                normalized.get("kernel_id"), "kernel.kernel_id"
+            ),
+            contract_kind=cast(KernelContractKind, contract_kind),
+            canonical_signature=_nonempty_string(
+                normalized.get("canonical_signature"),
+                "kernel.canonical_signature",
+            ),
+            input_arity=_nonnegative_integer(
+                normalized.get("input_arity"), "kernel.input_arity"
+            ),
+            output_arity=_nonnegative_integer(
+                normalized.get("output_arity"), "kernel.output_arity"
+            ),
+            input_layout=tuple(
+                _nonempty_string(item, f"kernel.input_layout[{index}]")
+                for index, item in enumerate(
+                    _sequence(normalized.get("input_layout"), "kernel.input_layout")
+                )
+            ),
+            input_contracts=tuple(
+                _mapping(item, f"kernel.input_contracts[{index}]")
+                for index, item in enumerate(
+                    _sequence(
+                        normalized.get("input_contracts"), "kernel.input_contracts"
+                    )
+                )
+            ),
+            output_layout=tuple(
+                _nonempty_string(item, f"kernel.output_layout[{index}]")
+                for index, item in enumerate(
+                    _sequence(normalized.get("output_layout"), "kernel.output_layout")
+                )
+            ),
+            exact_expressions=tuple(
+                _nonempty_string(item, f"kernel.exact_expressions[{index}]")
+                for index, item in enumerate(
+                    _sequence(
+                        normalized.get("exact_expressions"),
+                        "kernel.exact_expressions",
+                    )
+                )
+            ),
+            proof_classes=tuple(
+                _nonempty_string(item, f"kernel.proof_classes[{index}]")
+                for index, item in enumerate(
+                    _sequence(normalized.get("proof_classes"), "kernel.proof_classes")
+                )
+            ),
+            exact_evaluator_state_path=_normalized_member_path(
+                normalized.get("exact_evaluator_state_path"),
+                "kernel.exact_evaluator_state_path",
+            ),
+            f64_evaluator_manifest=_mapping(
+                normalized.get("f64_evaluator_manifest"),
+                "kernel.f64_evaluator_manifest",
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedKernelPack:
+    """The single prepared backend pack embedded in a model bundle."""
+
+    backend: PreparedBackend
+    optimization_settings: Mapping[str, object]
+    producer: Mapping[str, object]
+    dependency_abis: Mapping[str, object]
+    provenance: Mapping[str, object]
+    target: Mapping[str, object]
+    resolver_manifest: Mapping[str, object]
+    kernels: tuple[PreparedKernelRecord, ...]
+    kernel_variants: tuple[PreparedKernelVariantRecord, ...] = ()
+    recurrence_template: Mapping[str, object] | None = None
+    recurrence_direct_template: Mapping[str, object] | None = None
+    _referenced_payload_paths: tuple[str, ...] = field(
+        init=False,
+        repr=False,
+        compare=False,
+    )
+    _recurrence_direct_template_catalog: RecurrenceDirectTemplateCatalogV1 | None = (
+        field(
+            init=False,
+            repr=False,
+            compare=False,
+            default=None,
+        )
+    )
+
+    def __post_init__(self) -> None:
+        if self.backend not in _BACKENDS:
+            raise PreparedModelBundleError(
+                f"unsupported prepared backend {self.backend!r}"
+            )
+        for name in (
+            "optimization_settings",
+            "producer",
+            "dependency_abis",
+            "provenance",
+            "target",
+            "resolver_manifest",
+        ):
+            value = cast(Mapping[str, object], getattr(self, name))
+            if not value:
+                raise PreparedModelBundleError(f"kernel_pack.{name} must not be empty")
+            object.__setattr__(
+                self,
+                name,
+                _freeze_mapping(value, f"kernel_pack.{name}"),
+            )
+        target = self.target
+        target_fields = frozenset(
+            ("portable", "word_bits", "endianness", "target_triple", "cpu_features")
+        )
+        _require_exact_keys(target, "kernel_pack.target", target_fields)
+        if not isinstance(target.get("portable"), bool):
+            raise PreparedModelBundleError(
+                "kernel_pack.target.portable must be a boolean"
+            )
+        _positive_integer(target.get("word_bits"), "kernel_pack.target.word_bits")
+        if target.get("endianness") not in {"little", "big"}:
+            raise PreparedModelBundleError(
+                "kernel_pack.target.endianness must be 'little' or 'big'"
+            )
+        _nonempty_string(
+            target.get("target_triple"),
+            "kernel_pack.target.target_triple",
+        )
+        cpu_features = tuple(
+            _nonempty_string(item, f"kernel_pack.target.cpu_features[{index}]")
+            for index, item in enumerate(
+                _sequence(
+                    target.get("cpu_features"),
+                    "kernel_pack.target.cpu_features",
+                )
+            )
+        )
+        if cpu_features != tuple(sorted(set(cpu_features))):
+            raise PreparedModelBundleError(
+                "kernel_pack.target.cpu_features must be sorted and unique"
+            )
+        if self.backend == "jit":
+            if (
+                self.dependency_abis.get("symjit_plane_application")
+                != PREPARED_SYMJIT_PLANE_APPLICATION_ABI
+            ):
+                raise PreparedModelBundleError(
+                    "prepared JIT packs must authenticate SymJIT plane-application "
+                    f"ABI {PREPARED_SYMJIT_PLANE_APPLICATION_ABI!r}; regenerate "
+                    "the prepared model"
+                )
+            level = self.optimization_settings.get("jit_optimization_level")
+            if level != PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL:
+                raise PreparedModelBundleError(
+                    "prepared JIT packs must use portable SymJIT optimization "
+                    f"level {PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL}, found "
+                    f"{level!r}"
+                )
+            if (
+                target.get("portable") is not True
+                or target.get("target_triple") != PREPARED_JIT_PORTABLE_TARGET
+                or target.get("word_bits") != 64
+                or target.get("endianness") != "little"
+                or cpu_features
+            ):
+                raise PreparedModelBundleError(
+                    "prepared JIT packs must use the portable 64-bit "
+                    "little-endian SymJIT storage-v3 target"
+                )
+        kernels = tuple(sorted(self.kernels, key=lambda kernel: kernel.kernel_id))
+        if not kernels:
+            raise PreparedModelBundleError("kernel_pack.kernels must not be empty")
+        kernel_ids = tuple(kernel.kernel_id for kernel in kernels)
+        signatures = tuple(kernel.canonical_signature for kernel in kernels)
+        if len(set(kernel_ids)) != len(kernel_ids):
+            raise PreparedModelBundleError("kernel IDs must be unique")
+        if len(set(signatures)) != len(signatures):
+            raise PreparedModelBundleError("kernel canonical signatures must be unique")
+        object.__setattr__(self, "kernels", kernels)
+        if self.backend == "jit":
+            for kernel in kernels:
+                _validate_portable_jit_manifest(
+                    kernel.f64_evaluator_manifest,
+                    f"kernel {kernel.kernel_id}",
+                )
+        by_id = {kernel.kernel_id: kernel for kernel in kernels}
+        variants = tuple(
+            sorted(
+                self.kernel_variants,
+                key=lambda variant: (variant.base_kernel_id, variant.variant_id),
+            )
+        )
+        variant_keys = tuple(
+            (variant.base_kernel_id, variant.variant_id) for variant in variants
+        )
+        if len(set(variant_keys)) != len(variant_keys):
+            raise PreparedModelBundleError(
+                "prepared kernel variant identities must be unique"
+            )
+        optimization_digest = prepared_optimization_settings_digest(
+            self.optimization_settings
+        )
+        for variant in variants:
+            kernel = by_id.get(variant.base_kernel_id)
+            if kernel is None:
+                raise PreparedModelBundleError(
+                    "prepared kernel variant references an unknown base kernel"
+                )
+            variant.validate_base_kernel(kernel)
+            if variant.backend != self.backend:
+                raise PreparedModelBundleError(
+                    "prepared kernel variant backend does not match its pack"
+                )
+            if variant.optimization_settings_digest != optimization_digest:
+                raise PreparedModelBundleError(
+                    "prepared kernel variant optimization digest does not match "
+                    "its pack"
+                )
+            if variant.kind == "independent-block" and self.backend != "jit":
+                raise PreparedModelBundleError(
+                    "independent-block variants are currently supported only "
+                    "for JIT packs"
+                )
+        object.__setattr__(self, "kernel_variants", variants)
+        if self.backend == "jit":
+            for variant in variants:
+                _validate_portable_jit_manifest(
+                    variant.f64_evaluator_manifest,
+                    f"kernel {variant.base_kernel_id} variant {variant.variant_id!r}",
+                )
+        recurrence_template = self.recurrence_template
+        if recurrence_template is not None:
+            # Keep the prepared-bundle container independent from recurrence
+            # construction while still rejecting stale or incomplete semantic
+            # catalogs at the publication boundary.
+            from .recurrence_template import RecurrenceTemplateCatalog
+
+            try:
+                recurrence_payload = _thaw_json(recurrence_template)
+                catalog = RecurrenceTemplateCatalog.from_dict(
+                    _mapping(
+                        recurrence_payload,
+                        "kernel_pack.recurrence_template",
+                    )
+                )
+            except ValueError as exc:
+                raise PreparedModelBundleError(
+                    f"invalid kernel_pack.recurrence_template: {exc}"
+                ) from exc
+            _validate_recurrence_kernel_bindings(catalog, kernels)
+            object.__setattr__(
+                self,
+                "recurrence_template",
+                _freeze_mapping(
+                    catalog.to_dict(),
+                    "kernel_pack.recurrence_template",
+                ),
+            )
+        recurrence_direct_template = self.recurrence_direct_template
+        if recurrence_direct_template is not None:
+            if self.recurrence_template is None:
+                raise PreparedModelBundleError(
+                    "kernel_pack.recurrence_direct_template requires the "
+                    "authenticated semantic recurrence companion"
+                )
+            from .recurrence_direct_template import (
+                RecurrenceDirectTemplateCatalogV1,
+                RecurrenceDirectTemplateError,
+            )
+
+            try:
+                direct_catalog = RecurrenceDirectTemplateCatalogV1.from_dict(
+                    _mapping(
+                        _thaw_json(recurrence_direct_template),
+                        "kernel_pack.recurrence_direct_template",
+                    )
+                )
+            except RecurrenceDirectTemplateError as exc:
+                raise PreparedModelBundleError(
+                    f"invalid kernel_pack.recurrence_direct_template: {exc}"
+                ) from exc
+            semantic_catalog = self.recurrence_template_catalog
+            assert semantic_catalog is not None
+            _validate_recurrence_direct_bindings(
+                direct_catalog,
+                semantic_catalog,
+                kernels,
+                backend=self.backend,
+                target=self.target,
+                optimization_settings=self.optimization_settings,
+            )
+            expected_provenance = {
+                "direct_template_catalog_digest": direct_catalog.catalog_digest,
+                "prepared_kernel_contract_digest": (
+                    direct_catalog.prepared_kernel_contract_digest
+                ),
+                "prepared_kernel_payload_digest": (
+                    direct_catalog.prepared_kernel_payload_digest
+                ),
+                "prepared_kernel_pack_digest": (
+                    direct_catalog.prepared_kernel_pack_digest
+                ),
+                "recurrence_direct_template_abi": direct_catalog.abi,
+                "recurrence_direct_template_digest": direct_catalog.catalog_digest,
+            }
+            for name, expected in expected_provenance.items():
+                if self.provenance.get(name) != expected:
+                    raise PreparedModelBundleError(
+                        "direct recurrence companion provenance field "
+                        f"{name!r} does not match its authenticated catalog"
+                    )
+            object.__setattr__(
+                self,
+                "recurrence_direct_template",
+                _freeze_mapping(
+                    direct_catalog.to_dict(),
+                    "kernel_pack.recurrence_direct_template",
+                ),
+            )
+            object.__setattr__(
+                self,
+                "_recurrence_direct_template_catalog",
+                direct_catalog,
+            )
+        object.__setattr__(
+            self,
+            "_referenced_payload_paths",
+            tuple(
+                sorted(
+                    {
+                        path
+                        for record in (*kernels, *variants)
+                        for path in record.referenced_payload_paths
+                    }
+                )
+            ),
+        )
+
+    @property
+    def referenced_payload_paths(self) -> tuple[str, ...]:
+        return self._referenced_payload_paths
+
+    @property
+    def recurrence_template_catalog(self) -> RecurrenceTemplateCatalog | None:
+        """Return the validated semantic companion as its typed catalog."""
+
+        recurrence_template = self.recurrence_template
+        if recurrence_template is None:
+            return None
+        from .recurrence_template import RecurrenceTemplateCatalog
+
+        thawed = _thaw_json(recurrence_template)
+        return RecurrenceTemplateCatalog.from_dict(
+            _mapping(thawed, "kernel_pack.recurrence_template")
+        )
+
+    @property
+    def recurrence_direct_template_catalog(
+        self,
+    ) -> RecurrenceDirectTemplateCatalogV1 | None:
+        """Return the authenticated Direct-Arena executor companion."""
+
+        return self._recurrence_direct_template_catalog
+
+    @property
+    def direct_template_catalog_digest(self) -> str | None:
+        """Stable digest consumed by process plans and native handle binding."""
+
+        catalog = self.recurrence_direct_template_catalog
+        return None if catalog is None else catalog.catalog_digest
+
+    def to_dict(self) -> dict[str, object]:
+        payload: dict[str, object] = {
+            "backend": self.backend,
+            "optimization_settings": _thaw_json(self.optimization_settings),
+            "producer": _thaw_json(self.producer),
+            "dependency_abis": _thaw_json(self.dependency_abis),
+            "provenance": _thaw_json(self.provenance),
+            "target": _thaw_json(self.target),
+            "resolver_manifest": _thaw_json(self.resolver_manifest),
+            "kernels": [kernel.to_dict() for kernel in self.kernels],
+            "kernel_variants": [variant.to_dict() for variant in self.kernel_variants],
+        }
+        # Omitting this optional companion preserves the byte-for-byte manifest
+        # shape of prepared bundles produced before recurrence execution.
+        if self.recurrence_template is not None:
+            payload["recurrence_template"] = _thaw_json(self.recurrence_template)
+        if self.recurrence_direct_template is not None:
+            payload["recurrence_direct_template"] = _thaw_json(
+                self.recurrence_direct_template
+            )
+        return payload
+
+    @classmethod
+    def from_dict(cls, value: Mapping[str, object]) -> PreparedKernelPack:
+        normalized = dict(value)
+        normalized.setdefault("recurrence_template", None)
+        normalized.setdefault("recurrence_direct_template", None)
+        expected = frozenset(
+            (
+                "backend",
+                "optimization_settings",
+                "producer",
+                "dependency_abis",
+                "provenance",
+                "target",
+                "resolver_manifest",
+                "kernels",
+                "kernel_variants",
+                "recurrence_template",
+                "recurrence_direct_template",
+            )
+        )
+        _require_exact_keys(normalized, "kernel_pack", expected)
+        backend = _nonempty_string(normalized.get("backend"), "kernel_pack.backend")
+        kernels = tuple(
+            PreparedKernelRecord.from_dict(
+                _mapping(item, f"kernel_pack.kernels[{index}]")
+            )
+            for index, item in enumerate(
+                _sequence(normalized.get("kernels"), "kernel_pack.kernels")
+            )
+        )
+        kernel_variants = tuple(
+            PreparedKernelVariantRecord.from_dict(
+                _mapping(item, f"kernel_pack.kernel_variants[{index}]")
+            )
+            for index, item in enumerate(
+                _sequence(
+                    normalized.get("kernel_variants"),
+                    "kernel_pack.kernel_variants",
+                )
+            )
+        )
+        return cls(
+            backend=cast(PreparedBackend, backend),
+            optimization_settings=_mapping(
+                normalized.get("optimization_settings"),
+                "kernel_pack.optimization_settings",
+            ),
+            producer=_mapping(normalized.get("producer"), "kernel_pack.producer"),
+            dependency_abis=_mapping(
+                normalized.get("dependency_abis"),
+                "kernel_pack.dependency_abis",
+            ),
+            provenance=_mapping(normalized.get("provenance"), "kernel_pack.provenance"),
+            target=_mapping(normalized.get("target"), "kernel_pack.target"),
+            resolver_manifest=_mapping(
+                normalized.get("resolver_manifest"),
+                "kernel_pack.resolver_manifest",
+            ),
+            kernels=kernels,
+            kernel_variants=kernel_variants,
+            recurrence_template=(
+                None
+                if normalized.get("recurrence_template") is None
+                else _mapping(
+                    normalized.get("recurrence_template"),
+                    "kernel_pack.recurrence_template",
+                )
+            ),
+            recurrence_direct_template=(
+                None
+                if normalized.get("recurrence_direct_template") is None
+                else _mapping(
+                    normalized.get("recurrence_direct_template"),
+                    "kernel_pack.recurrence_direct_template",
+                )
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedKernelPackIdentity:
+    """Non-circular identity of callable contracts and payload contents."""
+
+    contract_digest: str
+    payload_digest: str
+    pack_digest: str
+    abi: str = PREPARED_KERNEL_PACK_IDENTITY_ABI
+
+    def __post_init__(self) -> None:
+        if self.abi != PREPARED_KERNEL_PACK_IDENTITY_ABI:
+            raise PreparedModelBundleError(
+                f"unsupported prepared pack identity ABI {self.abi!r}; "
+                "regenerate the prepared model with this pyAmpliCol version"
+            )
+        for name in ("contract_digest", "payload_digest", "pack_digest"):
+            _valid_sha256(getattr(self, name), f"prepared_pack_identity.{name}")
+
+
+def prepared_kernel_pack_identity(
+    kernel_pack: PreparedKernelPack,
+    payload_records: Mapping[str, tuple[int, str]],
+) -> PreparedKernelPackIdentity:
+    """Authenticate one backend pack without including its recurrence companion."""
+
+    normalized_records: dict[str, tuple[int, str]] = {}
+    for raw_path, raw_record in payload_records.items():
+        member_path = _normalized_member_path(
+            raw_path, "prepared payload identity path"
+        )
+        if (
+            not isinstance(raw_record, tuple)
+            or len(raw_record) != 2
+            or type(raw_record[0]) is not int
+            or raw_record[0] < 0
+        ):
+            raise PreparedModelBundleError(
+                f"prepared payload identity record for {member_path!r} is malformed"
+            )
+        normalized_records[member_path] = (
+            raw_record[0],
+            _valid_sha256(
+                raw_record[1],
+                f"prepared payload identity digest for {member_path!r}",
+            ),
+        )
+    referenced = set(kernel_pack.referenced_payload_paths)
+    supplied = set(normalized_records)
+    if supplied != referenced:
+        missing = sorted(referenced - supplied)
+        unexpected = sorted(supplied - referenced)
+        details: list[str] = []
+        if missing:
+            details.append("missing: " + ", ".join(missing))
+        if unexpected:
+            details.append("unreferenced: " + ", ".join(unexpected))
+        raise PreparedModelBundleError(
+            "prepared payload identity does not match kernel references ("
+            + "; ".join(details)
+            + ")"
+        )
+
+    contract_payload = {
+        "abi": PREPARED_KERNEL_PACK_IDENTITY_ABI,
+        "eager_kernel_abi": EAGER_KERNEL_ABI,
+        "backend": kernel_pack.backend,
+        "optimization_settings": _thaw_json(kernel_pack.optimization_settings),
+        "dependency_abis": _thaw_json(kernel_pack.dependency_abis),
+        "target": _thaw_json(kernel_pack.target),
+        "resolver_manifest": _thaw_json(kernel_pack.resolver_manifest),
+        "kernels": [kernel.to_dict() for kernel in kernel_pack.kernels],
+        "kernel_variants": [
+            variant.to_dict() for variant in kernel_pack.kernel_variants
+        ],
+    }
+    contract_digest = _mapping_digest(contract_payload)
+    payload_digest = _mapping_digest(
+        {
+            "abi": PREPARED_KERNEL_PACK_IDENTITY_ABI,
+            "payloads": [
+                {"path": path, "size": size, "sha256": digest}
+                for path, (size, digest) in sorted(normalized_records.items())
+            ],
+        }
+    )
+    pack_digest = _mapping_digest(
+        {
+            "abi": PREPARED_KERNEL_PACK_IDENTITY_ABI,
+            "contract_digest": contract_digest,
+            "payload_digest": payload_digest,
+        }
+    )
+    return PreparedKernelPackIdentity(
+        contract_digest=contract_digest,
+        payload_digest=payload_digest,
+        pack_digest=pack_digest,
+    )
+
+
+def _validate_recurrence_direct_pack_identity(
+    kernel_pack: PreparedKernelPack,
+    identity: PreparedKernelPackIdentity,
+) -> None:
+    direct_catalog = kernel_pack.recurrence_direct_template_catalog
+    if direct_catalog is None:
+        return
+    expected = {
+        "prepared kernel contract": (
+            direct_catalog.prepared_kernel_contract_digest,
+            identity.contract_digest,
+        ),
+        "prepared kernel payload": (
+            direct_catalog.prepared_kernel_payload_digest,
+            identity.payload_digest,
+        ),
+        "prepared kernel pack": (
+            direct_catalog.prepared_kernel_pack_digest,
+            identity.pack_digest,
+        ),
+    }
+    for name, (catalog_digest, actual_digest) in expected.items():
+        if catalog_digest != actual_digest:
+            raise PreparedModelBundleError(
+                f"direct recurrence {name} digest does not match the "
+                "published evaluator payloads"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedModelBundle:
+    """A validated prepared-model archive and its immutable metadata."""
+
+    path: Path
+    compiled_model: Mapping[str, object]
+    kernel_pack: PreparedKernelPack
+    manifest: Mapping[str, object]
+    _member_digests: Mapping[str, str] = field(repr=False)
+    _referenced_payload_paths: tuple[str, ...] = field(
+        init=False,
+        repr=False,
+        compare=False,
+    )
+    _referenced_payload_path_set: frozenset[str] = field(
+        init=False,
+        repr=False,
+        compare=False,
+    )
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "path", self.path.resolve())
+        object.__setattr__(
+            self,
+            "compiled_model",
+            _freeze_mapping(self.compiled_model, "compiled_model"),
+        )
+        object.__setattr__(
+            self,
+            "manifest",
+            _freeze_mapping(self.manifest, "manifest"),
+        )
+        object.__setattr__(
+            self,
+            "_member_digests",
+            MappingProxyType(dict(self._member_digests)),
+        )
+        recurrence_catalog = self.kernel_pack.recurrence_template_catalog
+        if (
+            recurrence_catalog is not None
+            and recurrence_catalog.header.compiled_model_digest
+            != self._member_digests[PREPARED_MODEL_COMPILED_MODEL_PATH]
+        ):
+            raise PreparedModelBundleError(
+                "recurrence template compiled-model digest does not match the "
+                "prepared bundle member"
+            )
+        direct_catalog = self.kernel_pack.recurrence_direct_template_catalog
+        if (
+            direct_catalog is not None
+            and direct_catalog.compiled_model_digest
+            != self._member_digests[PREPARED_MODEL_COMPILED_MODEL_PATH]
+        ):
+            raise PreparedModelBundleError(
+                "direct recurrence template compiled-model digest does not "
+                "match the prepared bundle member"
+            )
+        referenced_payload_paths = self.kernel_pack.referenced_payload_paths
+        object.__setattr__(
+            self,
+            "_referenced_payload_paths",
+            referenced_payload_paths,
+        )
+        object.__setattr__(
+            self,
+            "_referenced_payload_path_set",
+            frozenset(referenced_payload_paths),
+        )
+
+    @property
+    def backend(self) -> PreparedBackend:
+        return self.kernel_pack.backend
+
+    @property
+    def direct_template_catalog_digest(self) -> str | None:
+        """Expose the authenticated direct catalog identity without lowering."""
+
+        return self.kernel_pack.direct_template_catalog_digest
+
+    def compiled_model_payload(self) -> dict[str, object]:
+        """Return a detached plain-JSON payload for the model deserializer."""
+
+        payload = _thaw_json(self.compiled_model)
+        if not isinstance(payload, dict):  # pragma: no cover - constructor invariant
+            raise PreparedModelBundleError("compiled model root must be an object")
+        return payload
+
+    def read_payload(self, member_path: str) -> bytes:
+        """Read and revalidate one kernel payload from the archive."""
+        normalized = _normalized_member_path(member_path, "member_path")
+        if normalized not in self._referenced_payload_path_set:
+            raise PreparedModelBundleError(
+                f"{normalized!r} is not referenced by the prepared kernel pack"
+            )
+        try:
+            with zipfile.ZipFile(self.path, "r") as archive:
+                data = archive.read(normalized)
+        except (OSError, KeyError, zipfile.BadZipFile) as error:
+            raise PreparedModelBundleError(
+                f"could not read prepared payload {normalized!r}: {error}"
+            ) from error
+        expected = self._member_digests[normalized]
+        if _sha256(data) != expected:
+            raise PreparedModelBundleError(
+                f"prepared payload {normalized!r} has a SHA-256 mismatch"
+            )
+        return data
+
+    def copy_referenced_payloads(self, destination: Path) -> tuple[Path, ...]:
+        """Atomically copy all referenced backend payloads below *destination*."""
+        destination.mkdir(parents=True, exist_ok=True)
+        if destination.is_symlink():
+            raise PreparedModelBundleError("payload destination must not be a symlink")
+        root = destination.resolve()
+        outputs: list[Path] = []
+        for member_path in self._referenced_payload_paths:
+            output = root.joinpath(*PurePosixPath(member_path).parts)
+            output.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                output.parent.resolve().relative_to(root)
+            except ValueError as error:
+                raise PreparedModelBundleError(
+                    f"payload destination for {member_path!r} escapes its root"
+                ) from error
+            if output.is_symlink():
+                raise PreparedModelBundleError(
+                    f"payload destination {output} must not be a symlink"
+                )
+            data = self.read_payload(member_path)
+            temporary = output.with_name(f".{output.name}.{os.getpid()}.tmp")
+            try:
+                temporary.write_bytes(data)
+                temporary.replace(output)
+            finally:
+                temporary.unlink(missing_ok=True)
+            outputs.append(output)
+        return tuple(outputs)
+
+
+def _read_payload_source(source: PayloadSource, context: str) -> bytes:
+    if isinstance(source, bytes):
+        return source
+    if isinstance(source, (bytearray, memoryview)):
+        return bytes(source)
+    if isinstance(source, Path):
+        if source.is_symlink():
+            raise PreparedModelBundleError(f"{context} must not be a symlink")
+        if not source.is_file():
+            raise PreparedModelBundleError(f"{context} must be a regular file")
+        return source.read_bytes()
+    raise PreparedModelBundleError(f"{context} has an unsupported payload source")
+
+
+def prepared_payload_identity_records(
+    payloads: Mapping[str, PayloadSource],
+) -> dict[str, tuple[int, str]]:
+    """Read payload sources once into stable size/digest identity records."""
+
+    records: dict[str, tuple[int, str]] = {}
+    for raw_path, source in payloads.items():
+        member_path = _normalized_member_path(raw_path, "payload identity path")
+        if member_path in records:
+            raise PreparedModelBundleError(
+                f"duplicate payload identity path {member_path!r}"
+            )
+        data = _read_payload_source(source, f"payload {member_path!r}")
+        records[member_path] = (len(data), _sha256(data))
+    return records
+
+
+def _bundle_output_path(path: Path) -> Path:
+    text = str(path)
+    if not text.endswith(PREPARED_MODEL_BUNDLE_SUFFIX):
+        text += PREPARED_MODEL_BUNDLE_SUFFIX
+    return Path(text).expanduser().resolve()
+
+
+def _zip_info(path: str) -> zipfile.ZipInfo:
+    info = zipfile.ZipInfo(path, date_time=_ZIP_TIMESTAMP)
+    info.compress_type = zipfile.ZIP_STORED
+    info.create_system = 3
+    info.external_attr = _ZIP_FILE_MODE
+    info.extra = b""
+    info.comment = b""
+    return info
+
+
+def _write_zip(path: Path, members: Mapping[str, bytes]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+        dir=path.parent,
+    )
+    os.close(descriptor)
+    temporary = Path(temporary_name)
+    try:
+        with zipfile.ZipFile(temporary, "w", allowZip64=True) as archive:
+            archive.comment = b""
+            for member_path in (
+                PREPARED_MODEL_MANIFEST_PATH,
+                *sorted(
+                    path for path in members if path != PREPARED_MODEL_MANIFEST_PATH
+                ),
+            ):
+                archive.writestr(_zip_info(member_path), members[member_path])
+        temporary.replace(path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def write_prepared_model_bundle(
+    path: Path,
+    *,
+    compiled_model: Mapping[str, object],
+    kernel_pack: PreparedKernelPack,
+    payloads: Mapping[str, PayloadSource],
+) -> Path:
+    """Write one deterministic, self-contained prepared-model bundle."""
+    frozen_model = _freeze_mapping(compiled_model, "compiled_model")
+    recurrence_catalog = kernel_pack.recurrence_template_catalog
+    if (
+        recurrence_catalog is not None
+        and recurrence_catalog.header.compiled_model_digest
+        != _sha256(_canonical_json(frozen_model))
+    ):
+        raise PreparedModelBundleError(
+            "recurrence template compiled-model digest does not match the "
+            "prepared bundle member"
+        )
+    direct_catalog = kernel_pack.recurrence_direct_template_catalog
+    if direct_catalog is not None and direct_catalog.compiled_model_digest != _sha256(
+        _canonical_json(frozen_model)
+    ):
+        raise PreparedModelBundleError(
+            "direct recurrence template compiled-model digest does not match "
+            "the prepared bundle member"
+        )
+    payload_data: dict[str, bytes] = {}
+    for raw_path, source in payloads.items():
+        member_path = _normalized_member_path(raw_path, "payload path")
+        if member_path in {
+            PREPARED_MODEL_MANIFEST_PATH,
+            PREPARED_MODEL_COMPILED_MODEL_PATH,
+        }:
+            raise PreparedModelBundleError(
+                f"payload path {member_path!r} is reserved by the bundle"
+            )
+        if member_path in payload_data:
+            raise PreparedModelBundleError(f"duplicate payload path {member_path!r}")
+        payload_data[member_path] = _read_payload_source(
+            source,
+            f"payload {member_path!r}",
+        )
+    referenced = set(kernel_pack.referenced_payload_paths)
+    supplied = set(payload_data)
+    if referenced != supplied:
+        missing = sorted(referenced - supplied)
+        unexpected = sorted(supplied - referenced)
+        details: list[str] = []
+        if missing:
+            details.append("missing: " + ", ".join(missing))
+        if unexpected:
+            details.append("unreferenced: " + ", ".join(unexpected))
+        raise PreparedModelBundleError(
+            "prepared payload set does not match kernel references ("
+            + "; ".join(details)
+            + ")"
+        )
+    if recurrence_catalog is not None:
+        identity = prepared_kernel_pack_identity(
+            kernel_pack,
+            {
+                member_path: (len(data), _sha256(data))
+                for member_path, data in payload_data.items()
+            },
+        )
+        if (
+            identity.pack_digest
+            != recurrence_catalog.header.prepared_kernel_pack_digest
+        ):
+            raise PreparedModelBundleError(
+                "recurrence template prepared-pack digest does not match the "
+                "published evaluator payloads"
+            )
+        _validate_recurrence_direct_pack_identity(kernel_pack, identity)
+    hashed_members = {
+        PREPARED_MODEL_COMPILED_MODEL_PATH: _canonical_json(frozen_model),
+        **payload_data,
+    }
+    member_records = [
+        {
+            "path": member_path,
+            "size": len(data),
+            "sha256": _sha256(data),
+        }
+        for member_path, data in sorted(hashed_members.items())
+    ]
+    manifest: dict[str, object] = {
+        "kind": PREPARED_MODEL_BUNDLE_KIND,
+        "schema_version": PREPARED_MODEL_BUNDLE_SCHEMA_VERSION,
+        "eager_kernel_abi": EAGER_KERNEL_ABI,
+        "kernel_pack": kernel_pack.to_dict(),
+        "members": member_records,
+    }
+    if direct_catalog is not None:
+        manifest["direct_template_catalog_digest"] = direct_catalog.catalog_digest
+    members = {
+        PREPARED_MODEL_MANIFEST_PATH: _canonical_json(manifest),
+        **hashed_members,
+    }
+    output = _bundle_output_path(path)
+    _write_zip(output, members)
+    return output
+
+
+def _archive_members(archive: zipfile.ZipFile) -> dict[str, zipfile.ZipInfo]:
+    members: dict[str, zipfile.ZipInfo] = {}
+    for index, info in enumerate(archive.infolist()):
+        member_path = _normalized_member_path(info.filename, f"archive member {index}")
+        if member_path in members:
+            raise PreparedModelBundleError(
+                f"prepared-model archive contains duplicate member {member_path!r}"
+            )
+        mode = info.external_attr >> 16
+        if info.is_dir() or stat.S_IFMT(mode) == stat.S_IFLNK:
+            raise PreparedModelBundleError(
+                f"prepared-model member {member_path!r} must be a regular file"
+            )
+        members[member_path] = info
+    return members
+
+
+def _load_json_member(
+    archive: zipfile.ZipFile,
+    member_path: str,
+    context: str,
+) -> Mapping[str, object]:
+    try:
+        payload = json.loads(archive.read(member_path))
+    except KeyError as error:
+        raise PreparedModelBundleError(
+            f"prepared-model archive is missing {member_path!r}"
+        ) from error
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise PreparedModelBundleError(
+            f"{context} is not valid JSON: {error}"
+        ) from error
+    return _mapping(payload, context)
+
+
+def _load_member_records(value: object) -> dict[str, tuple[int, str]]:
+    records: dict[str, tuple[int, str]] = {}
+    for index, item in enumerate(_sequence(value, "manifest.members")):
+        record = _mapping(item, f"manifest.members[{index}]")
+        _require_exact_keys(
+            record,
+            f"manifest.members[{index}]",
+            frozenset(("path", "size", "sha256")),
+        )
+        path = _normalized_member_path(
+            record.get("path"),
+            f"manifest.members[{index}].path",
+        )
+        if path == PREPARED_MODEL_MANIFEST_PATH:
+            raise PreparedModelBundleError("manifest.json must not hash itself")
+        if path in records:
+            raise PreparedModelBundleError(
+                f"manifest contains duplicate member record {path!r}"
+            )
+        size = _nonnegative_integer(
+            record.get("size"),
+            f"manifest.members[{index}].size",
+        )
+        digest = _valid_sha256(
+            record.get("sha256"),
+            f"manifest.members[{index}].sha256",
+        )
+        records[path] = (size, digest)
+    return records
+
+
+def load_prepared_model_bundle(path: Path) -> PreparedModelBundle:
+    """Load and validate a prepared-model bundle without extracting it."""
+    requested_path = Path(path).expanduser()
+    if requested_path.is_symlink():
+        raise PreparedModelBundleError("prepared-model bundle must not be a symlink")
+    archive_path = requested_path.resolve()
+    try:
+        with zipfile.ZipFile(archive_path, "r") as archive:
+            archive_members = _archive_members(archive)
+            if PREPARED_MODEL_MANIFEST_PATH not in archive_members:
+                raise PreparedModelBundleError(
+                    "prepared-model archive is missing 'manifest.json'"
+                )
+            manifest = _load_json_member(
+                archive,
+                PREPARED_MODEL_MANIFEST_PATH,
+                "manifest",
+            )
+            base_manifest_fields = frozenset(
+                (
+                    "kind",
+                    "schema_version",
+                    "eager_kernel_abi",
+                    "kernel_pack",
+                    "members",
+                )
+            )
+            manifest_fields = frozenset(manifest)
+            expected_manifest_fields = (
+                base_manifest_fields | {"direct_template_catalog_digest"}
+                if "direct_template_catalog_digest" in manifest_fields
+                else base_manifest_fields
+            )
+            _require_exact_keys(
+                manifest,
+                "manifest",
+                expected_manifest_fields,
+            )
+            if manifest.get("kind") != PREPARED_MODEL_BUNDLE_KIND:
+                raise PreparedModelBundleError("invalid prepared-model bundle kind")
+            if manifest.get("schema_version") != PREPARED_MODEL_BUNDLE_SCHEMA_VERSION:
+                raise PreparedModelBundleError(
+                    "unsupported prepared-model bundle schema"
+                )
+            if manifest.get("eager_kernel_abi") != EAGER_KERNEL_ABI:
+                raise PreparedModelBundleError("unsupported eager kernel ABI")
+            kernel_pack = PreparedKernelPack.from_dict(
+                _mapping(manifest.get("kernel_pack"), "manifest.kernel_pack")
+            )
+            direct_catalog = kernel_pack.recurrence_direct_template_catalog
+            has_manifest_direct_digest = "direct_template_catalog_digest" in manifest
+            if direct_catalog is None:
+                if has_manifest_direct_digest:
+                    raise PreparedModelBundleError(
+                        "manifest advertises a direct template catalog that is absent"
+                    )
+            else:
+                manifest_direct_digest = (
+                    _valid_sha256(
+                        manifest.get("direct_template_catalog_digest"),
+                        "manifest.direct_template_catalog_digest",
+                    )
+                    if has_manifest_direct_digest
+                    else None
+                )
+                if manifest_direct_digest != direct_catalog.catalog_digest:
+                    raise PreparedModelBundleError(
+                        "manifest direct template catalog digest does not match the "
+                        "prepared companion"
+                    )
+            records = _load_member_records(manifest.get("members"))
+            expected_paths = {PREPARED_MODEL_MANIFEST_PATH, *records}
+            actual_paths = set(archive_members)
+            if expected_paths != actual_paths:
+                missing = sorted(expected_paths - actual_paths)
+                unexpected = sorted(actual_paths - expected_paths)
+                details: list[str] = []
+                if missing:
+                    details.append("missing: " + ", ".join(missing))
+                if unexpected:
+                    details.append("unexpected: " + ", ".join(unexpected))
+                raise PreparedModelBundleError(
+                    "prepared-model archive members do not match manifest ("
+                    + "; ".join(details)
+                    + ")"
+                )
+            if PREPARED_MODEL_COMPILED_MODEL_PATH not in records:
+                raise PreparedModelBundleError(
+                    "prepared-model archive is missing its compiled model"
+                )
+            for member_path, (expected_size, expected_digest) in records.items():
+                data = archive.read(member_path)
+                if len(data) != expected_size:
+                    raise PreparedModelBundleError(
+                        f"prepared-model member {member_path!r} has a size mismatch"
+                    )
+                if _sha256(data) != expected_digest:
+                    raise PreparedModelBundleError(
+                        f"prepared-model member {member_path!r} has a SHA-256 mismatch"
+                    )
+            payload_paths = set(records) - {PREPARED_MODEL_COMPILED_MODEL_PATH}
+            referenced_paths = set(kernel_pack.referenced_payload_paths)
+            if payload_paths != referenced_paths:
+                missing = sorted(referenced_paths - payload_paths)
+                unexpected = sorted(payload_paths - referenced_paths)
+                details = []
+                if missing:
+                    details.append("missing: " + ", ".join(missing))
+                if unexpected:
+                    details.append("unreferenced: " + ", ".join(unexpected))
+                raise PreparedModelBundleError(
+                    "prepared payload members do not match kernel references ("
+                    + "; ".join(details)
+                    + ")"
+                )
+            recurrence_catalog = kernel_pack.recurrence_template_catalog
+            if recurrence_catalog is not None:
+                identity = prepared_kernel_pack_identity(
+                    kernel_pack,
+                    {
+                        member_path: records[member_path]
+                        for member_path in referenced_paths
+                    },
+                )
+                if (
+                    identity.pack_digest
+                    != recurrence_catalog.header.prepared_kernel_pack_digest
+                ):
+                    raise PreparedModelBundleError(
+                        "recurrence template prepared-pack digest does not match "
+                        "the loaded evaluator payloads"
+                    )
+                _validate_recurrence_direct_pack_identity(kernel_pack, identity)
+            compiled_model = _load_json_member(
+                archive,
+                PREPARED_MODEL_COMPILED_MODEL_PATH,
+                "compiled_model",
+            )
+    except PreparedModelBundleError:
+        raise
+    except (OSError, zipfile.BadZipFile) as error:
+        raise PreparedModelBundleError(
+            f"could not open prepared-model bundle: {error}"
+        ) from error
+    return PreparedModelBundle(
+        path=archive_path,
+        compiled_model=compiled_model,
+        kernel_pack=kernel_pack,
+        manifest=manifest,
+        _member_digests={
+            member_path: digest for member_path, (_, digest) in records.items()
+        },
+    )
+
+
+def read_prepared_model_bundle(path: Path) -> PreparedModelBundle:
+    """Alias for :func:`load_prepared_model_bundle` for reader-style callers."""
+    return load_prepared_model_bundle(path)
+
+
+__all__ = [
+    "EAGER_KERNEL_ABI",
+    "EAGER_KERNEL_ABI_VERSION",
+    "PREPARED_INDEPENDENT_BLOCK_SIZE",
+    "PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL",
+    "PREPARED_JIT_PORTABLE_TARGET",
+    "PREPARED_KERNEL_PACK_IDENTITY_ABI",
+    "PREPARED_KERNEL_VARIANT_ABI",
+    "PREPARED_MODEL_BUNDLE_KIND",
+    "PREPARED_MODEL_BUNDLE_SCHEMA_VERSION",
+    "PREPARED_MODEL_BUNDLE_SUFFIX",
+    "PREPARED_MODEL_COMPILED_MODEL_PATH",
+    "PREPARED_MODEL_MANIFEST_PATH",
+    "PreparedKernelPack",
+    "PreparedKernelPackIdentity",
+    "PreparedKernelRecord",
+    "PreparedKernelVariantRecord",
+    "PreparedModelBundle",
+    "PreparedModelBundleError",
+    "load_prepared_model_bundle",
+    "prepared_compiled_model_digest",
+    "prepared_expression_digest",
+    "prepared_input_contract_digest",
+    "prepared_kernel_pack_identity",
+    "prepared_kernel_pack_manifest_identity_sha256",
+    "prepared_optimization_settings_digest",
+    "prepared_output_contract_digest",
+    "prepared_payload_identity_records",
+    "read_prepared_model_bundle",
+    "write_prepared_model_bundle",
+]
diff --git a/pyamplicol/src/pyamplicol/models/prepared_catalog.py b/pyamplicol/src/pyamplicol/models/prepared_catalog.py
new file mode 100644
index 0000000000..9926c5d1e4
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/prepared_catalog.py
@@ -0,0 +1,517 @@
+# SPDX-License-Identifier: 0BSD
+"""Process-independent exact kernel catalogs for prepared eager models.
+
+The catalog is deliberately upstream of generation.  It converts the local
+model contracts into content-addressed exact expressions and model-specific
+lookup bindings, but it never constructs a backend evaluator.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Literal, TypeAlias
+
+from .contact_decomposition import (
+    CompiledContactOrbitCertificate,
+    CompiledContactOrbitStep,
+)
+
+if TYPE_CHECKING:
+    from .base import Model
+
+PreparedContractKind: TypeAlias = Literal[
+    "vertex",
+    "propagator",
+    "closure",
+    "model-parameter",
+]
+PreparedInputRole: TypeAlias = Literal[
+    "left-current",
+    "right-current",
+    "left-momentum",
+    "right-momentum",
+    "current",
+    "momentum",
+    "coupling-real",
+    "coupling-imag",
+    "model-parameter",
+]
+PreparedOutputFactorSource: TypeAlias = Literal[
+    "none",
+    "coupling-real",
+    "coupling-imag",
+]
+
+_CATALOG_ABI = "pyamplicol-prepared-kernel-catalog-v1"
+PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF = (
+    "prepared-kernel-homogeneous-complex-linear-current-v1"
+)
+PREPARED_INDEPENDENT_BLOCK_PROOF = (
+    "prepared-kernel-independent-current-block-v1"
+)
+_CONTRACT_KINDS = frozenset(("vertex", "propagator", "closure", "model-parameter"))
+_INPUT_ROLES = frozenset(
+    (
+        "left-current",
+        "right-current",
+        "left-momentum",
+        "right-momentum",
+        "current",
+        "momentum",
+        "coupling-real",
+        "coupling-imag",
+        "model-parameter",
+    )
+)
+_OUTPUT_FACTOR_SOURCES = frozenset(("none", "coupling-real", "coupling-imag"))
+
+
+class PreparedKernelCatalogError(ValueError):
+    """Raised when a model cannot produce a complete exact eager catalog."""
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class PreparedKernelInput:
+    """One scalar input in a prepared evaluator's gather contract."""
+
+    role: PreparedInputRole
+    component: int
+    symbol: str
+    model_parameter_name: str | None = None
+    model_parameter_index: int | None = None
+
+    def __post_init__(self) -> None:
+        if self.role not in _INPUT_ROLES:
+            raise PreparedKernelCatalogError(
+                f"unsupported prepared input role {self.role!r}"
+            )
+        if self.component < 0:
+            raise PreparedKernelCatalogError(
+                "prepared input component must be nonnegative"
+            )
+        if not self.symbol:
+            raise PreparedKernelCatalogError("prepared input symbol must be nonempty")
+        parameter_fields = (
+            self.model_parameter_name,
+            self.model_parameter_index,
+        )
+        if self.role == "model-parameter":
+            if not self.model_parameter_name or self.model_parameter_index is None:
+                raise PreparedKernelCatalogError(
+                    "model-parameter inputs require a name and stable index"
+                )
+            if self.model_parameter_index < 0:
+                raise PreparedKernelCatalogError(
+                    "model-parameter input index must be nonnegative"
+                )
+        elif parameter_fields != (None, None):
+            raise PreparedKernelCatalogError(
+                "only model-parameter inputs may carry parameter metadata"
+            )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "role": self.role,
+            "component": self.component,
+            "symbol": self.symbol,
+            "model_parameter_name": self.model_parameter_name,
+            "model_parameter_index": self.model_parameter_index,
+        }
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class PreparedParticleState:
+    """Comparable model-owned orientation metadata for one current state."""
+
+    particle_id: int
+    identity: str
+    orientation: str
+    basis: str
+    chirality: int
+    dimension: int
+
+    def __post_init__(self) -> None:
+        if not self.identity or not self.orientation or not self.basis:
+            raise PreparedKernelCatalogError("prepared particle metadata is incomplete")
+        if self.dimension <= 0:
+            raise PreparedKernelCatalogError(
+                f"prepared current {self.identity!r} has invalid dimension "
+                f"{self.dimension}"
+            )
+
+    def contract_dict(self) -> dict[str, object]:
+        return {
+            "orientation": self.orientation,
+            "basis": self.basis,
+            "chirality": self.chirality,
+            "dimension": self.dimension,
+        }
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class VertexKernelKey:
+    kind: int
+    particles: tuple[int, int, int]
+    left_chirality: int
+    right_chirality: int
+    result_chirality: int
+    coupling: tuple[float, float]
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class PropagatorKernelKey:
+    particle_id: int
+    chirality: int
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class ClosureKernelKey:
+    kind: int
+    particles: tuple[int, int, int]
+    left_chirality: int
+    right_chirality: int
+    coupling: tuple[float, float]
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class PreparedVertexBinding:
+    key: VertexKernelKey
+    kernel_id: int
+    canonical_input_order: tuple[int, int]
+    equivalence_class: str
+    equivalence_factor: tuple[float, float]
+    input_exchange_factor: tuple[float, float] | None
+    left_state: PreparedParticleState
+    right_state: PreparedParticleState
+    result_state: PreparedParticleState
+    output_factor_source: PreparedOutputFactorSource = "none"
+    contact_orbit_certificates: tuple[CompiledContactOrbitCertificate, ...] = ()
+    contact_orbit_steps: tuple[CompiledContactOrbitStep, ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.output_factor_source not in _OUTPUT_FACTOR_SOURCES:
+            raise PreparedKernelCatalogError(
+                f"unsupported prepared output factor source "
+                f"{self.output_factor_source!r}"
+            )
+        if self.contact_orbit_certificates != tuple(
+            sorted(set(self.contact_orbit_certificates))
+        ) or self.contact_orbit_steps != tuple(sorted(set(self.contact_orbit_steps))):
+            raise PreparedKernelCatalogError(
+                "prepared contact-orbit contracts must be sorted and unique"
+            )
+        if any(
+            not isinstance(item, CompiledContactOrbitCertificate)
+            for item in self.contact_orbit_certificates
+        ) or any(
+            not isinstance(item, CompiledContactOrbitStep)
+            for item in self.contact_orbit_steps
+        ):
+            raise PreparedKernelCatalogError(
+                "prepared contact-orbit contract must contain typed records"
+            )
+        certificate_terms = {
+            certificate.term_id for certificate in self.contact_orbit_certificates
+        }
+        step_terms = {step.term_id for step in self.contact_orbit_steps}
+        if certificate_terms != step_terms:
+            raise PreparedKernelCatalogError(
+                "prepared contact-orbit certificates and steps disagree"
+            )
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class PreparedPropagatorBinding:
+    key: PropagatorKernelKey
+    kernel_id: int | None
+    state: PreparedParticleState
+    applies_propagator: bool
+    propagator_kind: str
+    mass_class: str
+    gauge: str | None
+    model_parameters: tuple[str, ...]
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class PreparedClosureBinding:
+    key: ClosureKernelKey
+    kernel_id: int
+    canonical_input_order: tuple[int, int]
+    equivalence_class: str
+    equivalence_factor: tuple[float, float]
+    input_exchange_factor: tuple[float, float] | None
+    left_state: PreparedParticleState
+    right_state: PreparedParticleState
+    result_state: PreparedParticleState
+    projection: str
+    output_factor_source: PreparedOutputFactorSource = "none"
+
+    def __post_init__(self) -> None:
+        if self.output_factor_source not in _OUTPUT_FACTOR_SOURCES:
+            raise PreparedKernelCatalogError(
+                f"unsupported prepared output factor source "
+                f"{self.output_factor_source!r}"
+            )
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class PreparedKernelGap:
+    """A model-admitted local variant lacking a constructive exact lowering."""
+
+    contract_kind: PreparedContractKind
+    context: str
+    reason: str
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedKernelSpec:
+    """One process-blind exact evaluator contract, before backend compilation."""
+
+    kernel_id: int
+    contract_kind: PreparedContractKind
+    canonical_signature: str
+    exact_expressions: tuple[str, ...]
+    inputs: tuple[PreparedKernelInput, ...]
+    output_layout: tuple[str, ...]
+    proof_classes: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.kernel_id < 0:
+            raise PreparedKernelCatalogError("prepared kernel id must be nonnegative")
+        if self.contract_kind not in _CONTRACT_KINDS:
+            raise PreparedKernelCatalogError(
+                f"unsupported prepared contract kind {self.contract_kind!r}"
+            )
+        if len(self.canonical_signature) != 64 or any(
+            character not in "0123456789abcdef"
+            for character in self.canonical_signature
+        ):
+            raise PreparedKernelCatalogError(
+                "prepared canonical signature must be a lowercase SHA-256"
+            )
+        if not self.exact_expressions or len(self.exact_expressions) != len(
+            self.output_layout
+        ):
+            raise PreparedKernelCatalogError(
+                "prepared exact outputs and output layout must be nonempty and aligned"
+            )
+        if any(not expression for expression in self.exact_expressions):
+            raise PreparedKernelCatalogError(
+                "prepared exact expressions must be nonempty"
+            )
+        if len(set(self.inputs)) != len(self.inputs):
+            raise PreparedKernelCatalogError("prepared kernel inputs must be unique")
+        if self.proof_classes != tuple(sorted(set(self.proof_classes))):
+            raise PreparedKernelCatalogError(
+                "prepared kernel proof classes must be sorted and unique"
+            )
+
+    @property
+    def input_arity(self) -> int:
+        return len(self.inputs)
+
+    @property
+    def output_dimension(self) -> int:
+        return len(self.exact_expressions)
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedKernelCatalog:
+    """Exact kernels plus deterministic model-local resolver bindings."""
+
+    model_name: str
+    kernels: tuple[PreparedKernelSpec, ...]
+    vertex_bindings: tuple[PreparedVertexBinding, ...]
+    propagator_bindings: tuple[PreparedPropagatorBinding, ...]
+    closure_bindings: tuple[PreparedClosureBinding, ...]
+    model_parameter_kernel_id: int | None
+    unsupported_variants: tuple[PreparedKernelGap, ...] = ()
+
+    def __post_init__(self) -> None:
+        if not self.model_name:
+            raise PreparedKernelCatalogError("prepared catalog model name is empty")
+        expected_ids = tuple(range(len(self.kernels)))
+        actual_ids = tuple(kernel.kernel_id for kernel in self.kernels)
+        if actual_ids != expected_ids:
+            raise PreparedKernelCatalogError(
+                "prepared kernel ids must be contiguous in signature order"
+            )
+        signatures = tuple(kernel.canonical_signature for kernel in self.kernels)
+        if signatures != tuple(sorted(signatures)) or len(set(signatures)) != len(
+            signatures
+        ):
+            raise PreparedKernelCatalogError(
+                "prepared kernels must have unique sorted canonical signatures"
+            )
+        referenced = (
+            {binding.kernel_id for binding in self.vertex_bindings}
+            | {
+                binding.kernel_id
+                for binding in self.propagator_bindings
+                if binding.kernel_id is not None
+            }
+            | {binding.kernel_id for binding in self.closure_bindings}
+        )
+        if self.model_parameter_kernel_id is not None:
+            referenced.add(self.model_parameter_kernel_id)
+        if any(kernel_id not in expected_ids for kernel_id in referenced):
+            raise PreparedKernelCatalogError(
+                "prepared resolver binding references an unknown kernel"
+            )
+        for context, keys in (
+            ("vertex", tuple(binding.key for binding in self.vertex_bindings)),
+            (
+                "propagator",
+                tuple(binding.key for binding in self.propagator_bindings),
+            ),
+            ("closure", tuple(binding.key for binding in self.closure_bindings)),
+        ):
+            if len(keys) != len(set(keys)):
+                raise PreparedKernelCatalogError(
+                    f"prepared {context} resolver keys must be unique"
+                )
+
+    @property
+    def by_id(self) -> Mapping[int, PreparedKernelSpec]:
+        return MappingProxyType({kernel.kernel_id: kernel for kernel in self.kernels})
+
+    def resolver_mappings(self) -> Mapping[str, Mapping[object, int | None]]:
+        """Return neutral maps for a generation-layer resolver adapter."""
+
+        return MappingProxyType(
+            {
+                "vertex": MappingProxyType(
+                    {binding.key: binding.kernel_id for binding in self.vertex_bindings}
+                ),
+                "propagator": MappingProxyType(
+                    {
+                        binding.key: binding.kernel_id
+                        for binding in self.propagator_bindings
+                    }
+                ),
+                "closure": MappingProxyType(
+                    {
+                        binding.key: binding.kernel_id
+                        for binding in self.closure_bindings
+                    }
+                ),
+            }
+        )
+
+    def resolver_manifest(self) -> dict[str, object]:
+        """Serialize the process-independent lookup and proof metadata.
+
+        Exact expressions live in :class:`PreparedKernelRecord` objects.  This
+        manifest contains only the model-owned keys and transformations needed
+        to select those records while lowering a process DAG.
+        """
+
+        return {
+            "abi": _CATALOG_ABI,
+            "model_name": self.model_name,
+            "vertex_bindings": [
+                {
+                    "key": {
+                        "kind": binding.key.kind,
+                        "particles": list(binding.key.particles),
+                        "left_chirality": binding.key.left_chirality,
+                        "right_chirality": binding.key.right_chirality,
+                        "result_chirality": binding.key.result_chirality,
+                        "coupling": list(binding.key.coupling),
+                    },
+                    "kernel_id": binding.kernel_id,
+                    "canonical_input_order": list(binding.canonical_input_order),
+                    "equivalence_class": binding.equivalence_class,
+                    "equivalence_factor": list(binding.equivalence_factor),
+                    "input_exchange_factor": (
+                        None
+                        if binding.input_exchange_factor is None
+                        else list(binding.input_exchange_factor)
+                    ),
+                    "output_factor_source": binding.output_factor_source,
+                    "contact_orbit_certificates": [
+                        item.to_dict()
+                        for item in binding.contact_orbit_certificates
+                    ],
+                    "contact_orbit_steps": [
+                        item.to_dict() for item in binding.contact_orbit_steps
+                    ],
+                }
+                for binding in self.vertex_bindings
+            ],
+            "propagator_bindings": [
+                {
+                    "key": {
+                        "particle_id": binding.key.particle_id,
+                        "chirality": binding.key.chirality,
+                    },
+                    "kernel_id": binding.kernel_id,
+                    "applies_propagator": binding.applies_propagator,
+                }
+                for binding in self.propagator_bindings
+            ],
+            "closure_bindings": [
+                {
+                    "key": {
+                        "kind": binding.key.kind,
+                        "particles": list(binding.key.particles),
+                        "left_chirality": binding.key.left_chirality,
+                        "right_chirality": binding.key.right_chirality,
+                        "coupling": list(binding.key.coupling),
+                    },
+                    "kernel_id": binding.kernel_id,
+                    "canonical_input_order": list(binding.canonical_input_order),
+                    "equivalence_class": binding.equivalence_class,
+                    "equivalence_factor": list(binding.equivalence_factor),
+                    "input_exchange_factor": (
+                        None
+                        if binding.input_exchange_factor is None
+                        else list(binding.input_exchange_factor)
+                    ),
+                    "projection": binding.projection,
+                    "output_factor_source": binding.output_factor_source,
+                }
+                for binding in self.closure_bindings
+            ],
+            "model_parameter_kernel_id": self.model_parameter_kernel_id,
+            "unsupported_variants": [
+                {
+                    "contract_kind": gap.contract_kind,
+                    "context": gap.context,
+                    "reason": gap.reason,
+                }
+                for gap in self.unsupported_variants
+            ],
+        }
+
+
+def build_prepared_kernel_catalog(model: Model) -> PreparedKernelCatalog:
+    """Build the complete process-independent exact catalog for ``model``."""
+
+    from .prepared_catalog_builder import build_prepared_kernel_catalog as build
+
+    return build(model)
+
+
+__all__ = [
+    "PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF",
+    "PREPARED_INDEPENDENT_BLOCK_PROOF",
+    "ClosureKernelKey",
+    "PreparedClosureBinding",
+    "PreparedContractKind",
+    "PreparedInputRole",
+    "PreparedKernelCatalog",
+    "PreparedKernelCatalogError",
+    "PreparedKernelGap",
+    "PreparedKernelInput",
+    "PreparedKernelSpec",
+    "PreparedOutputFactorSource",
+    "PreparedParticleState",
+    "PreparedPropagatorBinding",
+    "PreparedVertexBinding",
+    "PropagatorKernelKey",
+    "VertexKernelKey",
+    "build_prepared_kernel_catalog",
+]
diff --git a/pyamplicol/src/pyamplicol/models/prepared_catalog_builder.py b/pyamplicol/src/pyamplicol/models/prepared_catalog_builder.py
new file mode 100644
index 0000000000..1ec92ac170
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/prepared_catalog_builder.py
@@ -0,0 +1,1192 @@
+# SPDX-License-Identifier: 0BSD
+"""Model-specific construction of process-independent prepared kernel catalogs."""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from types import SimpleNamespace
+from typing import Any, Literal, cast
+
+from .._internal.physics.symbols import symbols
+from . import compiler_symbolica as _sym
+from ._physics_ir import ContractionIR, PropagatorIR
+from .base import Model, Vertex, VertexEvaluationEquivalence
+from .contact_decomposition import (
+    CompiledContactOrbitCertificate,
+    CompiledContactOrbitStep,
+)
+from .expressions import _as_expression, _exact_complex_expression
+from .external import CompiledUFOModel
+from .prepared_catalog import (
+    _CATALOG_ABI,
+    PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF,
+    PREPARED_INDEPENDENT_BLOCK_PROOF,
+    ClosureKernelKey,
+    PreparedClosureBinding,
+    PreparedContractKind,
+    PreparedKernelCatalog,
+    PreparedKernelCatalogError,
+    PreparedKernelInput,
+    PreparedKernelSpec,
+    PreparedOutputFactorSource,
+    PreparedParticleState,
+    PreparedPropagatorBinding,
+    PreparedVertexBinding,
+    PropagatorKernelKey,
+    VertexKernelKey,
+)
+from .prepared_catalog_helpers import (
+    canonical_expressions as _canonical_expressions,
+)
+from .prepared_catalog_helpers import (
+    canonical_json as _canonical_json,
+)
+from .prepared_catalog_helpers import (
+    component_descriptors as _component_descriptors,
+)
+from .prepared_catalog_helpers import (
+    coupling_descriptor as _coupling_descriptor,
+)
+from .prepared_catalog_helpers import (
+    formal_components as _formal_components,
+)
+from .prepared_catalog_helpers import (
+    formal_model_parameter as _formal_model_parameter,
+)
+from .prepared_catalog_helpers import (
+    model_parameter_descriptor as _model_parameter_descriptor,
+)
+from .prepared_catalog_helpers import (
+    proves_homogeneous_complex_linearity as _proves_homogeneous_complex_linearity,
+)
+from .prepared_catalog_helpers import (
+    proves_independent_current_block_eligibility as _proves_block_eligibility,
+)
+from .prepared_catalog_helpers import (
+    used_input_descriptors as _used_input_descriptors,
+)
+
+_MAX_DISCOVERED_CURRENT_STATES = 4096
+
+
+@dataclass(frozen=True, slots=True)
+class _Candidate:
+    contract_kind: PreparedContractKind
+    canonical_signature: str
+    exact_expressions: tuple[str, ...]
+    inputs: tuple[PreparedKernelInput, ...]
+    output_layout: tuple[str, ...]
+    proof_class: str | None
+
+    def spec(self, kernel_id: int, proof_classes: Sequence[str]) -> PreparedKernelSpec:
+        certified = set(proof_classes)
+        if _proves_block_eligibility(
+            self.contract_kind,
+            self.exact_expressions,
+            self.inputs,
+        ):
+            certified.add(PREPARED_INDEPENDENT_BLOCK_PROOF)
+        return PreparedKernelSpec(
+            kernel_id=kernel_id,
+            contract_kind=self.contract_kind,
+            canonical_signature=self.canonical_signature,
+            exact_expressions=self.exact_expressions,
+            inputs=self.inputs,
+            output_layout=self.output_layout,
+            proof_classes=tuple(sorted(certified)),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class _VertexCandidateResult:
+    candidate: _Candidate
+    key: VertexKernelKey
+    equivalence: VertexEvaluationEquivalence
+    left_state: PreparedParticleState
+    right_state: PreparedParticleState
+    result_state: PreparedParticleState
+    output_factor_source: PreparedOutputFactorSource = "none"
+    contact_orbit_certificates: tuple[CompiledContactOrbitCertificate, ...] = ()
+    contact_orbit_steps: tuple[CompiledContactOrbitStep, ...] = ()
+
+
+class _RuntimeParameterizedModel:
+    """Model-local copy of the compiled-stage parameter overlay."""
+
+    def __init__(self, base: Model, parameters: Mapping[str, Any]) -> None:
+        self._base_model = base
+        self._runtime_parameters = parameters
+        self.name = base.name
+        self.particles = base.particles
+        self.vertices = base.vertices
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._base_model, name)
+
+    def mass(self, pdg: int) -> Any:
+        particle = self._base_model.particle(pdg)
+        name = f"particle.{int(particle.pdg)}.mass"
+        return self._runtime_parameters.get(name, self._base_model.mass(pdg))
+
+    def width(self, pdg: int) -> Any:
+        particle = self._base_model.particle(pdg)
+        name = f"particle.{int(particle.pdg)}.width"
+        return self._runtime_parameters.get(name, self._base_model.width(pdg))
+
+    def propagator_lowering_rule(self, particle_id: int, chirality: int = 0) -> Any:
+        return self._base_model.propagator_lowering_rule(particle_id, chirality)
+
+    def propagator_component_expression(
+        self,
+        particle_id: int,
+        value: Sequence[Any],
+        momentum: Sequence[Any],
+        *,
+        chirality: int = 0,
+        propagator: PropagatorIR | None = None,
+    ) -> tuple[Any, ...]:
+        return cast(
+            tuple[Any, ...],
+            type(self._base_model).propagator_component_expression(
+                self,
+                particle_id,
+                value,
+                momentum,
+                chirality=chirality,
+                propagator=propagator,
+            ),
+        )
+
+
+def build_prepared_kernel_catalog(model: Model) -> PreparedKernelCatalog:
+    """Build the complete process-independent exact catalog for ``model``."""
+
+    _sym._ensure_symbolica()
+    parameter_names = _model_parameter_names(model)
+    parameter_indices = {name: index for index, name in enumerate(parameter_names)}
+    candidates: dict[str, _Candidate] = {}
+    proof_classes: dict[str, set[str]] = {}
+    vertex_pending: list[_VertexCandidateResult] = []
+    closure_pending: list[tuple[_VertexCandidateResult, str]] = []
+    propagator_pending: list[
+        tuple[
+            PropagatorKernelKey, PreparedParticleState, PropagatorIR, _Candidate | None
+        ]
+    ] = []
+
+    vertices = _unique_vertices(model)
+    chiralities_by_particle: dict[int, set[int]] = {}
+    for vertex in vertices:
+        for particle_id in vertex.particles:
+            chiralities_by_particle.setdefault(int(particle_id), set()).update(
+                _state_chiralities(model, int(particle_id))
+            )
+    visited_inputs: set[tuple[object, ...]] = set()
+    discovered = True
+    while discovered:
+        discovered = False
+        for vertex in vertices:
+            left_chiralities = tuple(
+                sorted(chiralities_by_particle[vertex.particles[0]])
+            )
+            right_chiralities = tuple(
+                sorted(chiralities_by_particle[vertex.particles[1]])
+            )
+            for left_chirality in left_chiralities:
+                for right_chirality in right_chiralities:
+                    input_key = (
+                        vertex.kind,
+                        vertex.particles,
+                        vertex.coupling,
+                        left_chirality,
+                        right_chirality,
+                    )
+                    if input_key in visited_inputs:
+                        continue
+                    visited_inputs.add(input_key)
+                    flows = _reachable_flows(
+                        model,
+                        vertex,
+                        left_chirality=left_chirality,
+                        right_chirality=right_chirality,
+                    )
+                    for result_chirality in flows:
+                        try:
+                            result = _vertex_candidate(
+                                model,
+                                vertex,
+                                left_chirality=left_chirality,
+                                right_chirality=right_chirality,
+                                result_chirality=result_chirality,
+                                parameter_indices=parameter_indices,
+                                contract_kind="vertex",
+                            )
+                        except PreparedKernelCatalogError as error:
+                            raise PreparedKernelCatalogError(
+                                "prepared catalog cannot lower admitted vertex "
+                                "orientation "
+                                f"kind={vertex.kind}, particles={vertex.particles}, "
+                                "chiralities="
+                                f"({left_chirality},{right_chirality},"
+                                f"{result_chirality}): {error}"
+                            ) from error
+                        _register_candidate(candidates, proof_classes, result.candidate)
+                        vertex_pending.append(result)
+                        result_states = chiralities_by_particle.setdefault(
+                            int(vertex.particles[2]), set()
+                        )
+                        if result_chirality not in result_states:
+                            result_states.add(result_chirality)
+                            discovered = True
+                            if (
+                                sum(map(len, chiralities_by_particle.values()))
+                                > _MAX_DISCOVERED_CURRENT_STATES
+                            ):
+                                raise PreparedKernelCatalogError(
+                                    "prepared current-state discovery did not "
+                                    "converge within the safety bound"
+                                )
+                        closure_ir = model.closure_contraction_ir(
+                            vertex.particles[2], result_chirality
+                        )
+                        if (
+                            model.vertex_closure_allowed(vertex)
+                            and closure_ir is not None
+                        ):
+                            closure = _closure_candidate(result, closure_ir)
+                            _register_candidate(
+                                candidates,
+                                proof_classes,
+                                closure.candidate,
+                            )
+                            closure_pending.append((closure, closure_ir.name))
+
+    propagator_states = _required_propagator_states(model, vertex_pending)
+    for state in propagator_states:
+        particle_id = state.particle_id
+        chirality = state.chirality
+        try:
+            metadata = model._propagator_ir(particle_id, chirality)
+        except (NotImplementedError, ValueError) as error:
+            raise PreparedKernelCatalogError(
+                "prepared catalog cannot lower admitted propagator "
+                f"particle={particle_id}, chirality={chirality}: {error}"
+            ) from error
+        candidate = (
+            _propagator_candidate(
+                model,
+                state,
+                metadata,
+                parameter_indices=parameter_indices,
+            )
+            if metadata.applies_propagator
+            else None
+        )
+        if candidate is not None:
+            _register_candidate(candidates, proof_classes, candidate)
+        propagator_pending.append(
+            (
+                PropagatorKernelKey(particle_id, chirality),
+                state,
+                metadata,
+                candidate,
+            )
+        )
+
+    model_parameter_candidate = _model_parameter_candidate(
+        model,
+        parameter_indices=parameter_indices,
+    )
+    if model_parameter_candidate is not None:
+        _register_candidate(candidates, proof_classes, model_parameter_candidate)
+
+    ordered_signatures = tuple(sorted(candidates))
+    kernel_ids = {
+        signature: kernel_id for kernel_id, signature in enumerate(ordered_signatures)
+    }
+    kernels = tuple(
+        candidates[signature].spec(
+            kernel_ids[signature],
+            proof_classes.get(signature, ()),
+        )
+        for signature in ordered_signatures
+    )
+    vertex_bindings = tuple(
+        sorted(
+            (
+                PreparedVertexBinding(
+                    key=result.key,
+                    kernel_id=kernel_ids[result.candidate.canonical_signature],
+                    canonical_input_order=result.equivalence.input_order,
+                    equivalence_class=result.equivalence.class_id,
+                    equivalence_factor=result.equivalence.factor,
+                    input_exchange_factor=(result.equivalence.input_exchange_factor),
+                    left_state=result.left_state,
+                    right_state=result.right_state,
+                    result_state=result.result_state,
+                    output_factor_source=result.output_factor_source,
+                    contact_orbit_certificates=result.contact_orbit_certificates,
+                    contact_orbit_steps=result.contact_orbit_steps,
+                )
+                for result in vertex_pending
+            ),
+            key=lambda binding: binding.key,
+        )
+    )
+    propagator_bindings = tuple(
+        PreparedPropagatorBinding(
+            key=key,
+            kernel_id=(
+                None if candidate is None else kernel_ids[candidate.canonical_signature]
+            ),
+            state=state,
+            applies_propagator=metadata.applies_propagator,
+            propagator_kind=metadata.kind,
+            mass_class=metadata.mass_class,
+            gauge=metadata.gauge,
+            model_parameters=tuple(
+                descriptor.model_parameter_name
+                for descriptor in (() if candidate is None else candidate.inputs)
+                if descriptor.model_parameter_name is not None
+            ),
+        )
+        for key, state, metadata, candidate in sorted(
+            propagator_pending,
+            key=lambda item: item[0],
+        )
+    )
+    closure_bindings = tuple(
+        sorted(
+            (
+                PreparedClosureBinding(
+                    key=ClosureKernelKey(
+                        result.key.kind,
+                        result.key.particles,
+                        result.key.left_chirality,
+                        result.key.right_chirality,
+                        result.key.coupling,
+                    ),
+                    kernel_id=kernel_ids[result.candidate.canonical_signature],
+                    canonical_input_order=result.equivalence.input_order,
+                    equivalence_class=result.equivalence.class_id,
+                    equivalence_factor=result.equivalence.factor,
+                    input_exchange_factor=(result.equivalence.input_exchange_factor),
+                    left_state=result.left_state,
+                    right_state=result.right_state,
+                    result_state=result.result_state,
+                    projection=projection,
+                    output_factor_source=result.output_factor_source,
+                )
+                for result, projection in closure_pending
+            ),
+            key=lambda binding: binding.key,
+        )
+    )
+    missing_vertex_kinds = sorted(
+        {vertex.kind for vertex in _unique_vertices(model)}
+        - {binding.key.kind for binding in vertex_bindings}
+    )
+    if missing_vertex_kinds:
+        raise PreparedKernelCatalogError(
+            "prepared catalog has no constructive orientation for model vertex "
+            f"kinds {missing_vertex_kinds}"
+        )
+    return PreparedKernelCatalog(
+        model_name=str(model.name),
+        kernels=kernels,
+        vertex_bindings=vertex_bindings,
+        propagator_bindings=propagator_bindings,
+        closure_bindings=closure_bindings,
+        model_parameter_kernel_id=(
+            None
+            if model_parameter_candidate is None
+            else kernel_ids[model_parameter_candidate.canonical_signature]
+        ),
+        unsupported_variants=(),
+    )
+
+
+def _unique_vertices(model: Model) -> tuple[Vertex, ...]:
+    by_key = {
+        (
+            int(vertex.kind),
+            tuple(int(particle) for particle in vertex.particles),
+            tuple(float(value) for value in vertex.coupling),
+        ): vertex
+        for vertex in model.iter_vertices(color_accuracy="full")
+    }
+    return tuple(by_key[key] for key in sorted(by_key))
+
+
+def _oriented_particle_ids(model: Model) -> tuple[int, ...]:
+    particle_ids = {
+        int(particle_id)
+        for particle_id in model.particles
+        if model.source_wavefunction_kind(int(particle_id)) != "ghost"
+    }
+    particle_ids.update(
+        model.anti_particle(particle_id) for particle_id in tuple(particle_ids)
+    )
+    return tuple(sorted(particle_ids))
+
+
+def _required_propagator_states(
+    model: Model,
+    vertex_candidates: Sequence[_VertexCandidateResult],
+) -> tuple[PreparedParticleState, ...]:
+    """Return every source or transition-reachable current state.
+
+    Source spin states do not necessarily span the internal current basis.  A
+    massless fermion, for example, has chiral external wavefunctions but may be
+    produced as a full Dirac current by a transition involving a massive
+    fermion.  Prepared propagators must therefore cover vertex states as well
+    as source states.
+    """
+
+    states: dict[tuple[int, int], PreparedParticleState] = {}
+
+    def add(state: PreparedParticleState) -> None:
+        if model.source_wavefunction_kind(int(state.particle_id)) == "ghost":
+            return
+        key = (int(state.particle_id), int(state.chirality))
+        previous = states.setdefault(key, state)
+        if previous != state:
+            raise PreparedKernelCatalogError(
+                "prepared vertex and source contracts disagree on current-state "
+                f"semantics for particle={key[0]}, chirality={key[1]}"
+            )
+
+    for particle_id in _oriented_particle_ids(model):
+        for chirality in _state_chiralities(model, particle_id):
+            add(_particle_state(model, particle_id, chirality))
+    for candidate in vertex_candidates:
+        add(candidate.left_state)
+        add(candidate.right_state)
+        add(candidate.result_state)
+    return tuple(states[key] for key in sorted(states))
+
+
+def _state_chiralities(model: Model, particle_id: int) -> tuple[int, ...]:
+    if model.auxiliary_kind(particle_id) is not None:
+        return (0,)
+    if model.particle(particle_id).spin < 0:
+        return (0,)
+    chiralities = {
+        int(state.chirality) for state in model.source_spin_states(particle_id)
+    }
+    source_chiralities = tuple(
+        sorted(chirality for chirality in chiralities if chirality)
+    )
+    if len(source_chiralities) < 2:
+        return tuple(sorted(chiralities))
+    try:
+        contracts = tuple(
+            model.recurrence_current_embedding_contract(particle_id, chirality)
+            for chirality in source_chiralities
+        )
+    except NotImplementedError:
+        return tuple(sorted(chiralities))
+    full_contracts = {
+        (contract.full_dimension, contract.full_basis) for contract in contracts
+    }
+    expected_full = (
+        int(model.current_dimension(particle_id, 0)),
+        model._current_basis(particle_id, 0),
+    )
+    if full_contracts != {expected_full}:
+        raise PreparedKernelCatalogError(
+            "recurrence current-embedding contracts disagree on the full state "
+            f"for particle={particle_id}: {sorted(full_contracts)!r}"
+        )
+    chiralities.add(0)
+    return tuple(sorted(chiralities))
+
+
+def _particle_state(
+    model: Model,
+    particle_id: int,
+    chirality: int,
+) -> PreparedParticleState:
+    metadata = model._particle_identity_ir(particle_id)
+    return PreparedParticleState(
+        particle_id=int(particle_id),
+        identity=metadata.canonical_id,
+        orientation=metadata.orientation,
+        basis=model._current_basis(particle_id, chirality),
+        chirality=int(chirality),
+        dimension=int(model.current_dimension(particle_id, chirality)),
+    )
+
+
+def _reachable_flows(
+    model: Model,
+    vertex: Vertex,
+    *,
+    left_chirality: int,
+    right_chirality: int,
+) -> tuple[int, ...]:
+    left = SimpleNamespace(
+        particle_id=vertex.particles[0],
+        pdg=vertex.particles[0],
+        chirality=left_chirality,
+        flavour_flow=(vertex.particles[0],),
+        coupling_orders=(),
+    )
+    right = SimpleNamespace(
+        particle_id=vertex.particles[1],
+        pdg=vertex.particles[1],
+        chirality=right_chirality,
+        flavour_flow=(vertex.particles[1],),
+        coupling_orders=(),
+    )
+    try:
+        return tuple(
+            sorted(
+                {
+                    int(flow.chirality)
+                    for flow in model.allowed_quantum_flows(vertex, left, right)
+                }
+            )
+        )
+    except Exception as error:
+        raise PreparedKernelCatalogError(
+            "cannot enumerate prepared vertex flows for "
+            f"model {model.name!r}, kind {vertex.kind}, particles "
+            f"{vertex.particles}, chiralities "
+            f"({left_chirality}, {right_chirality}): {error}"
+        ) from error
+
+
+def _vertex_candidate(
+    model: Model,
+    vertex: Vertex,
+    *,
+    left_chirality: int,
+    right_chirality: int,
+    result_chirality: int,
+    parameter_indices: Mapping[str, int],
+    contract_kind: Literal["vertex", "closure"],
+) -> _VertexCandidateResult:
+    equivalence = model.vertex_evaluation_equivalence(vertex.kind)
+    contact_orbit_certificates, contact_orbit_steps = (
+        model.vertex_contact_orbit_contracts(vertex.kind)
+    )
+    if not equivalence.verified:
+        raise PreparedKernelCatalogError(
+            f"prepared vertex kind {vertex.kind} has an unverified equivalence"
+        )
+    concrete_states = (
+        _particle_state(model, vertex.particles[0], left_chirality),
+        _particle_state(model, vertex.particles[1], right_chirality),
+    )
+    canonical_states = tuple(
+        concrete_states[index] for index in equivalence.input_order
+    )
+    canonical_left = _formal_components(
+        model,
+        "left-current",
+        canonical_states[0].dimension,
+    )
+    canonical_right = _formal_components(
+        model,
+        "right-current",
+        canonical_states[1].dimension,
+    )
+    canonical_left_momentum = _formal_components(model, "left-momentum", 4)
+    canonical_right_momentum = _formal_components(model, "right-momentum", 4)
+    canonical_values = (canonical_left, canonical_right)
+    canonical_momenta = (canonical_left_momentum, canonical_right_momentum)
+    inverse_order = tuple(equivalence.input_order.index(index) for index in (0, 1))
+    concrete_values = tuple(canonical_values[index] for index in inverse_order)
+    concrete_momenta = tuple(canonical_momenta[index] for index in inverse_order)
+    coupling_symbols = _formal_components(model, "coupling", 2)
+    parameter_symbols = {
+        name: _formal_model_parameter(model, name, parameter_indices[name])
+        for name in _vertex_runtime_parameter_names(model, vertex.kind)
+    }
+    try:
+        expressions, coupling_inputs = _vertex_expressions(
+            model,
+            vertex,
+            left=concrete_values[0],
+            right=concrete_values[1],
+            left_chirality=left_chirality,
+            right_chirality=right_chirality,
+            result_chirality=result_chirality,
+            left_momentum=concrete_momenta[0],
+            right_momentum=concrete_momenta[1],
+            coupling_symbols=coupling_symbols,
+            parameter_symbols=parameter_symbols,
+        )
+    except Exception as error:
+        raise PreparedKernelCatalogError(
+            "cannot construct prepared vertex expression for "
+            f"model {model.name!r}, kind {vertex.kind}, particles "
+            f"{vertex.particles}, chiralities "
+            f"({left_chirality}, {right_chirality}, {result_chirality}): {error}"
+        ) from error
+    factor = _exact_complex_expression(complex(*equivalence.factor))
+    normalized = tuple(
+        _as_expression(expression) / factor for expression in expressions
+    )
+    available_descriptors = (
+        *_component_descriptors(model, "left-current", canonical_left),
+        *_component_descriptors(model, "right-current", canonical_right),
+        *_component_descriptors(model, "left-momentum", canonical_left_momentum),
+        *_component_descriptors(model, "right-momentum", canonical_right_momentum),
+        *(
+            _coupling_descriptor(model, coupling_symbols[index], index)
+            for index in coupling_inputs
+        ),
+        *(
+            _model_parameter_descriptor(
+                model,
+                parameter_symbols[name],
+                name,
+                parameter_indices[name],
+            )
+            for name in sorted(parameter_symbols)
+        ),
+    )
+    descriptors = _used_input_descriptors(normalized, available_descriptors)
+    normalized, descriptors, output_factor_source = _factor_linear_coupling_output(
+        normalized,
+        descriptors,
+        available_descriptors=available_descriptors,
+        coupling_symbols=coupling_symbols,
+        context=f"vertex kind {vertex.kind}",
+    )
+    exact = _canonical_expressions(normalized, context=f"vertex kind {vertex.kind}")
+    if all(expression == "0" for expression in exact):
+        raise PreparedKernelCatalogError(
+            f"reachable prepared vertex kind {vertex.kind} lowered to zero"
+        )
+    output_state = _particle_state(
+        model,
+        vertex.particles[2],
+        result_chirality,
+    )
+    payload = {
+        "abi": _CATALOG_ABI,
+        "contract_kind": contract_kind,
+        "inputs": [descriptor.to_dict() for descriptor in descriptors],
+        "outputs": list(exact),
+        "output_layout": [
+            f"{output_state.basis}:c{index}" for index in range(len(exact))
+        ],
+        "canonical_input_states": [state.contract_dict() for state in canonical_states],
+        "result_state": output_state.contract_dict(),
+    }
+    candidate = _candidate_from_payload(
+        contract_kind,
+        payload,
+        exact,
+        descriptors,
+        tuple(payload["output_layout"]),
+        proof_class=equivalence.class_id,
+    )
+    return _VertexCandidateResult(
+        candidate=candidate,
+        key=VertexKernelKey(
+            kind=int(vertex.kind),
+            particles=tuple(int(value) for value in vertex.particles),
+            left_chirality=int(left_chirality),
+            right_chirality=int(right_chirality),
+            result_chirality=int(result_chirality),
+            coupling=tuple(float(value) for value in vertex.coupling),
+        ),
+        equivalence=equivalence,
+        left_state=concrete_states[0],
+        right_state=concrete_states[1],
+        result_state=output_state,
+        output_factor_source=output_factor_source,
+        contact_orbit_certificates=contact_orbit_certificates,
+        contact_orbit_steps=contact_orbit_steps,
+    )
+
+
+def _factor_linear_coupling_output(
+    expressions: tuple[Any, ...],
+    descriptors: tuple[PreparedKernelInput, ...],
+    *,
+    available_descriptors: tuple[PreparedKernelInput, ...],
+    coupling_symbols: tuple[Any, ...],
+    context: str,
+) -> tuple[
+    tuple[Any, ...],
+    tuple[PreparedKernelInput, ...],
+    PreparedOutputFactorSource,
+]:
+    """Factor one proof-certified real coupling component out of a callable."""
+
+    coupling_inputs = tuple(
+        descriptor
+        for descriptor in descriptors
+        if descriptor.role in ("coupling-real", "coupling-imag")
+    )
+    if len(coupling_inputs) != 1:
+        return expressions, descriptors, "none"
+    descriptor = coupling_inputs[0]
+    component = 0 if descriptor.role == "coupling-real" else 1
+    symbol = coupling_symbols[component]
+    symbol_name = symbol.to_canonical_string()
+    bases = tuple(
+        _as_expression(expression).replace(symbol, 1) for expression in expressions
+    )
+    if any(
+        symbol_name
+        in {
+            item.to_canonical_string()
+            for item in _as_expression(base).get_all_symbols(False)
+        }
+        for base in bases
+    ):
+        return expressions, descriptors, "none"
+    residuals = tuple(
+        (_as_expression(expression) - symbol * _as_expression(base)).expand()
+        for expression, base in zip(expressions, bases, strict=True)
+    )
+    if any(
+        residual != "0"
+        for residual in _canonical_expressions(
+            residuals,
+            context=f"{context} coupling-factor proof",
+        )
+    ):
+        return expressions, descriptors, "none"
+    factored_descriptors = _used_input_descriptors(bases, available_descriptors)
+    return (
+        bases,
+        factored_descriptors,
+        cast(PreparedOutputFactorSource, descriptor.role),
+    )
+
+
+def _vertex_expressions(
+    model: Model,
+    vertex: Vertex,
+    *,
+    left: Sequence[Any],
+    right: Sequence[Any],
+    left_chirality: int,
+    right_chirality: int,
+    result_chirality: int,
+    left_momentum: Sequence[Any],
+    right_momentum: Sequence[Any],
+    coupling_symbols: tuple[Any, ...],
+    parameter_symbols: Mapping[str, Any],
+) -> tuple[tuple[Any, ...], tuple[int, ...]]:
+    if isinstance(model, CompiledUFOModel):
+        kernel = model._kernel(vertex.kind)
+        components = model._projected_kernel_components(
+            kernel,
+            left,
+            right,
+            left_chirality=left_chirality,
+            right_chirality=right_chirality,
+            result_chirality=result_chirality,
+            left_momentum=left_momentum,
+            right_momentum=right_momentum,
+            runtime_parameter_values=parameter_symbols,
+        )
+        coupling = model._resolved_kernel_coupling_expression(
+            kernel,
+            parameter_symbols,
+        )
+        return tuple(component * coupling for component in components), ()
+
+    rule = model.vertex_lowering_rule(vertex.kind)
+    if not rule.full_tensor_network_ready or rule.backend == "unimplemented":
+        raise PreparedKernelCatalogError(
+            f"vertex kind {vertex.kind} has no complete local lowering contract"
+        )
+    coupling: tuple[Any, Any]
+    coupling_inputs: tuple[int, ...]
+    if rule.coupling_mode == "vertex":
+        coupling = (coupling_symbols[0], coupling_symbols[1])
+        coupling_inputs = (0, 1)
+    else:
+        coupling = vertex.coupling
+        coupling_inputs = ()
+    expressions = model.vertex_component_expression(
+        vertex.kind,
+        left,
+        right,
+        result_particle_id=vertex.particles[2],
+        result_chirality=result_chirality,
+        left_chirality=left_chirality,
+        right_chirality=right_chirality,
+        coupling=coupling,
+        left_momentum=left_momentum,
+        right_momentum=right_momentum,
+    )
+    if coupling_inputs:
+        actual = model.vertex_component_expression(
+            vertex.kind,
+            left,
+            right,
+            result_particle_id=vertex.particles[2],
+            result_chirality=result_chirality,
+            left_chirality=left_chirality,
+            right_chirality=right_chirality,
+            coupling=vertex.coupling,
+            left_momentum=left_momentum,
+            right_momentum=right_momentum,
+        )
+        substituted = tuple(
+            _as_expression(expression)
+            .replace(coupling_symbols[0], vertex.coupling[0])
+            .replace(coupling_symbols[1], vertex.coupling[1])
+            for expression in expressions
+        )
+        # Equal exact values may retain different float/integer atom spellings
+        # after substitution (for example 1.0*i versus i next to sqrt(2)).
+        # Prove equality by cancellation, not by comparing those spellings.
+        differences = tuple(
+            _as_expression(formal) - _as_expression(concrete)
+            for formal, concrete in zip(substituted, actual, strict=True)
+        )
+        if any(
+            value != "0"
+            for value in _canonical_expressions(
+                differences, context="formal coupling difference"
+            )
+        ):
+            coupling = (coupling_symbols[0], vertex.coupling[1])
+            coupling_inputs = (0,)
+            expressions = model.vertex_component_expression(
+                vertex.kind,
+                left,
+                right,
+                result_particle_id=vertex.particles[2],
+                result_chirality=result_chirality,
+                left_chirality=left_chirality,
+                right_chirality=right_chirality,
+                coupling=coupling,
+                left_momentum=left_momentum,
+                right_momentum=right_momentum,
+            )
+            branch_substituted = tuple(
+                _as_expression(expression).replace(
+                    coupling_symbols[0], vertex.coupling[0]
+                )
+                for expression in expressions
+            )
+            branch_differences = tuple(
+                _as_expression(formal) - _as_expression(concrete)
+                for formal, concrete in zip(branch_substituted, actual, strict=True)
+            )
+            if any(
+                value != "0"
+                for value in _canonical_expressions(
+                    branch_differences, context="branch coupling difference"
+                )
+            ):
+                raise PreparedKernelCatalogError(
+                    "vertex coupling control flow cannot be represented by the "
+                    "prepared scalar coupling inputs"
+                )
+    return tuple(expressions), coupling_inputs
+
+
+def _closure_candidate(
+    vertex: _VertexCandidateResult,
+    contraction: ContractionIR,
+) -> _VertexCandidateResult:
+    source = tuple(
+        _sym.E(expression) for expression in vertex.candidate.exact_expressions
+    )
+    if len(source) != len(contraction.coefficients):
+        raise PreparedKernelCatalogError(
+            f"closure projection {contraction.name!r} has dimension "
+            f"{len(contraction.coefficients)}, expected {len(source)}"
+        )
+    projected = sum(
+        (
+            _exact_complex_expression(complex(*coefficient)) * expression
+            for coefficient, expression in zip(
+                contraction.coefficients,
+                source,
+                strict=True,
+            )
+        ),
+        _sym.E("0"),
+    )
+    exact = _canonical_expressions((projected,), context="vertex closure")
+    payload = {
+        "abi": _CATALOG_ABI,
+        "contract_kind": "closure",
+        "inputs": [descriptor.to_dict() for descriptor in vertex.candidate.inputs],
+        "outputs": list(exact),
+        "output_layout": ["scalar:c0"],
+        "projection": contraction.to_json_dict(),
+    }
+    candidate = _candidate_from_payload(
+        "closure",
+        payload,
+        exact,
+        vertex.candidate.inputs,
+        ("scalar:c0",),
+        proof_class=vertex.equivalence.class_id,
+    )
+    return _VertexCandidateResult(
+        candidate=candidate,
+        key=vertex.key,
+        equivalence=vertex.equivalence,
+        left_state=vertex.left_state,
+        right_state=vertex.right_state,
+        result_state=vertex.result_state,
+        output_factor_source=vertex.output_factor_source,
+        contact_orbit_certificates=vertex.contact_orbit_certificates,
+        contact_orbit_steps=vertex.contact_orbit_steps,
+    )
+
+
+def _propagator_candidate(
+    model: Model,
+    state: PreparedParticleState,
+    metadata: PropagatorIR,
+    *,
+    parameter_indices: Mapping[str, int],
+) -> _Candidate:
+    current = _formal_components(model, "current", state.dimension)
+    momentum = _formal_components(model, "momentum", 4)
+    names = _particle_runtime_parameter_names(model, state.particle_id)
+    parameter_symbols = {
+        name: _formal_model_parameter(model, name, parameter_indices[name])
+        for name in names
+    }
+    parameterized: Any = (
+        model.with_runtime_parameters(parameter_symbols)
+        if hasattr(model, "with_runtime_parameters")
+        else _RuntimeParameterizedModel(model, parameter_symbols)
+    )
+    try:
+        expressions = parameterized.propagator_component_expression(
+            state.particle_id,
+            current,
+            momentum,
+            chirality=state.chirality,
+            propagator=metadata,
+        )
+    except Exception as error:
+        raise PreparedKernelCatalogError(
+            "cannot construct prepared propagator expression for "
+            f"model {model.name!r}, particle {state.particle_id}, chirality "
+            f"{state.chirality}: {error}"
+        ) from error
+    exact = _canonical_expressions(
+        expressions,
+        context=f"propagator {state.particle_id}/{state.chirality}",
+    )
+    descriptors = _used_input_descriptors(
+        tuple(_as_expression(value) for value in expressions),
+        (
+            *_component_descriptors(model, "current", current),
+            *_component_descriptors(model, "momentum", momentum),
+            *(
+                _model_parameter_descriptor(
+                    model,
+                    parameter_symbols[name],
+                    name,
+                    parameter_indices[name],
+                )
+                for name in sorted(parameter_symbols)
+            ),
+        ),
+    )
+    payload = {
+        "abi": _CATALOG_ABI,
+        "contract_kind": "propagator",
+        "inputs": [descriptor.to_dict() for descriptor in descriptors],
+        "outputs": list(exact),
+        "output_layout": [f"{state.basis}:c{index}" for index in range(len(exact))],
+        "state": state.contract_dict(),
+        "propagator": {
+            "kind": metadata.kind,
+            "mass_class": metadata.mass_class,
+            "gauge": metadata.gauge,
+            "kernel": metadata.kernel,
+            "custom_source": metadata.custom_source,
+            "goldstone_policy": metadata.goldstone_policy,
+        },
+    }
+    return _candidate_from_payload(
+        "propagator",
+        payload,
+        exact,
+        descriptors,
+        tuple(payload["output_layout"]),
+        proof_class=(
+            PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF
+            if _proves_homogeneous_complex_linearity(expressions, current)
+            else None
+        ),
+    )
+
+
+def _model_parameter_candidate(
+    model: Model,
+    *,
+    parameter_indices: Mapping[str, int],
+) -> _Candidate | None:
+    provider = getattr(model, "runtime_derived_parameter_definitions", None)
+    if not callable(provider):
+        return None
+    definitions = {
+        str(name): str(expression) for name, expression in provider().items()
+    }
+    if not definitions:
+        return None
+    defaults_provider = getattr(model, "runtime_parameter_defaults", None)
+    defaults = (
+        {str(name) for name in defaults_provider()}
+        if callable(defaults_provider)
+        else set()
+    )
+    formal = {
+        name: _formal_model_parameter(model, name, parameter_indices[name])
+        for name in sorted(defaults)
+    }
+    model_symbols = symbols.model(model.name)
+    outputs: list[Any] = []
+    for name in sorted(definitions):
+        expression = model_symbols.expression(definitions[name])
+        for parameter_name, replacement in formal.items():
+            expression = expression.replace(
+                model_symbols.symbol(parameter_name),
+                replacement,
+            )
+        outputs.append(expression)
+    exact = _canonical_expressions(outputs, context="model parameter derivation")
+    descriptors = _used_input_descriptors(
+        outputs,
+        tuple(
+            _model_parameter_descriptor(
+                model,
+                formal[name],
+                name,
+                parameter_indices[name],
+            )
+            for name in sorted(formal)
+        ),
+    )
+    output_layout = tuple(f"model-parameter:{name}" for name in sorted(definitions))
+    payload = {
+        "abi": _CATALOG_ABI,
+        "contract_kind": "model-parameter",
+        "inputs": [descriptor.to_dict() for descriptor in descriptors],
+        "outputs": list(exact),
+        "output_layout": list(output_layout),
+    }
+    return _candidate_from_payload(
+        "model-parameter",
+        payload,
+        exact,
+        descriptors,
+        output_layout,
+        proof_class=None,
+    )
+
+
+def _model_parameter_names(model: Model) -> tuple[str, ...]:
+    names: set[str] = set()
+    defaults_provider = getattr(model, "runtime_parameter_defaults", None)
+    if callable(defaults_provider):
+        names.update(str(name) for name in defaults_provider())
+    definitions_provider = getattr(model, "runtime_derived_parameter_definitions", None)
+    if callable(definitions_provider):
+        names.update(str(name) for name in definitions_provider())
+    for particle_id in _oriented_particle_ids(model):
+        names.update(_particle_runtime_parameter_names(model, particle_id))
+    return tuple(sorted(names))
+
+
+def _vertex_runtime_parameter_names(model: Model, kind: int) -> tuple[str, ...]:
+    provider = getattr(model, "runtime_parameter_names_for_vertex", None)
+    if not callable(provider):
+        return ()
+    return tuple(sorted(str(name) for name in provider(int(kind))))
+
+
+def _particle_runtime_parameter_names(
+    model: Model, particle_id: int
+) -> tuple[str, ...]:
+    provider = getattr(model, "runtime_parameter_names_for_particle", None)
+    if callable(provider):
+        return tuple(sorted(str(name) for name in provider(int(particle_id))))
+    particle = model.particle(particle_id)
+    names: list[str] = []
+    if float(particle.mass) != 0.0:
+        names.append(f"particle.{int(particle.pdg)}.mass")
+    if float(particle.width) != 0.0:
+        names.append(f"particle.{int(particle.pdg)}.width")
+    return tuple(names)
+
+
+def _candidate_from_payload(
+    contract_kind: PreparedContractKind,
+    payload: Mapping[str, object],
+    exact_expressions: tuple[str, ...],
+    inputs: tuple[PreparedKernelInput, ...],
+    output_layout: tuple[str, ...],
+    *,
+    proof_class: str | None,
+) -> _Candidate:
+    declared_symbols = {descriptor.symbol for descriptor in inputs}
+    used_symbols = {
+        symbol.to_canonical_string()
+        for expression in exact_expressions
+        for symbol in _sym.E(expression).get_all_symbols(False)
+        if not symbol.is_constant()
+    }
+    unbound_symbols = sorted(used_symbols - declared_symbols)
+    if unbound_symbols:
+        raise PreparedKernelCatalogError(
+            f"prepared {contract_kind} contract has undeclared inputs: "
+            f"{', '.join(unbound_symbols)}"
+        )
+    semantic_payload = {
+        "abi": payload.get("abi"),
+        "contract_kind": contract_kind,
+        "inputs": [descriptor.to_dict() for descriptor in inputs],
+        "outputs": list(exact_expressions),
+        "output_layout": list(output_layout),
+    }
+    canonical = _canonical_json(semantic_payload)
+    return _Candidate(
+        contract_kind=contract_kind,
+        canonical_signature=hashlib.sha256(canonical).hexdigest(),
+        exact_expressions=exact_expressions,
+        inputs=inputs,
+        output_layout=output_layout,
+        proof_class=proof_class,
+    )
+
+
+def _register_candidate(
+    candidates: dict[str, _Candidate],
+    proof_classes: dict[str, set[str]],
+    candidate: _Candidate,
+) -> None:
+    existing = candidates.setdefault(candidate.canonical_signature, candidate)
+    if (
+        existing.contract_kind,
+        existing.exact_expressions,
+        existing.inputs,
+        existing.output_layout,
+    ) != (
+        candidate.contract_kind,
+        candidate.exact_expressions,
+        candidate.inputs,
+        candidate.output_layout,
+    ):
+        raise PreparedKernelCatalogError(
+            f"prepared kernel SHA-256 collision for {candidate.canonical_signature}"
+        )
+    if candidate.proof_class:
+        proof_classes.setdefault(candidate.canonical_signature, set()).add(
+            candidate.proof_class
+        )
diff --git a/pyamplicol/src/pyamplicol/models/prepared_catalog_helpers.py b/pyamplicol/src/pyamplicol/models/prepared_catalog_helpers.py
new file mode 100644
index 0000000000..5ee34f3a18
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/prepared_catalog_helpers.py
@@ -0,0 +1,210 @@
+# SPDX-License-Identifier: 0BSD
+"""Expression and input-contract helpers for prepared kernel catalogs."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from .._internal.physics.symbols import symbols
+from . import compiler_symbolica as _sym
+from .base import Model
+from .expressions import _as_expression
+from .prepared_catalog import (
+    PreparedContractKind,
+    PreparedInputRole,
+    PreparedKernelCatalogError,
+    PreparedKernelInput,
+)
+
+
+def formal_components(model: Model, role: str, count: int) -> tuple[Any, ...]:
+    symbol_role = role.replace("-", "_")
+    return tuple(
+        symbols.model_owned(model.name, f"prepared::{symbol_role}::c{index}")
+        for index in range(count)
+    )
+
+
+def formal_model_parameter(model: Model, name: str, index: int) -> Any:
+    del name
+    return symbols.model_owned(
+        model.name,
+        f"prepared::model_parameter::p{index}",
+    )
+
+
+def component_descriptors(
+    model: Model,
+    role: PreparedInputRole,
+    values: Sequence[Any],
+) -> tuple[PreparedKernelInput, ...]:
+    del model
+    return tuple(
+        PreparedKernelInput(
+            role=role,
+            component=index,
+            symbol=value.to_canonical_string(),
+        )
+        for index, value in enumerate(values)
+    )
+
+
+def coupling_descriptor(model: Model, value: Any, index: int) -> PreparedKernelInput:
+    del model
+    return PreparedKernelInput(
+        role="coupling-real" if index == 0 else "coupling-imag",
+        component=0,
+        symbol=value.to_canonical_string(),
+    )
+
+
+def model_parameter_descriptor(
+    model: Model,
+    value: Any,
+    name: str,
+    index: int,
+) -> PreparedKernelInput:
+    del model
+    return PreparedKernelInput(
+        role="model-parameter",
+        component=0,
+        symbol=value.to_canonical_string(),
+        model_parameter_name=name,
+        model_parameter_index=index,
+    )
+
+
+def used_input_descriptors(
+    expressions: Sequence[Any],
+    descriptors: Sequence[PreparedKernelInput],
+) -> tuple[PreparedKernelInput, ...]:
+    used_symbols = {
+        symbol.to_canonical_string()
+        for expression in expressions
+        for symbol in _as_expression(expression).get_all_symbols(False)
+    }
+    return tuple(
+        descriptor for descriptor in descriptors if descriptor.symbol in used_symbols
+    )
+
+
+def canonical_expressions(
+    expressions: Sequence[Any],
+    *,
+    context: str,
+) -> tuple[str, ...]:
+    result: list[str] = []
+    for index, value in enumerate(expressions):
+        try:
+            expression = _as_expression(value).expand()
+            canonical = str(expression.to_canonical_string())
+        except Exception as error:
+            raise PreparedKernelCatalogError(
+                f"cannot canonicalize {context} output {index}: {error}"
+            ) from error
+        lowered = canonical.lower()
+        if not canonical or any(
+            marker in lowered
+            for marker in ("indeterminate", "nan", "infinity", "complexinf")
+        ):
+            raise PreparedKernelCatalogError(
+                f"{context} output {index} is not a finite exact expression"
+            )
+        result.append(canonical)
+    if not result:
+        raise PreparedKernelCatalogError(f"{context} produced no outputs")
+    return tuple(result)
+
+
+def canonical_json(value: Mapping[str, object]) -> bytes:
+    try:
+        return json.dumps(
+            value,
+            ensure_ascii=True,
+            allow_nan=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    except (TypeError, ValueError) as error:
+        raise PreparedKernelCatalogError(
+            f"prepared kernel contract is not canonical JSON: {error}"
+        ) from error
+
+
+def proves_homogeneous_complex_linearity(
+    expressions: Sequence[Any],
+    current_components: Sequence[Any],
+) -> bool:
+    """Certify exact complex linearity in one prepared current argument.
+
+    The reconstruction identity is checked symbolically, rather than inferred
+    from a propagator role. This rejects affine offsets, nonlinear terms, and
+    conjugate dependence while leaving unrelated momenta and parameters exact.
+    """
+
+    if not expressions or not current_components:
+        return False
+    _sym._ensure_symbolica()
+    currents = tuple(_as_expression(value) for value in current_components)
+    if len({value.to_canonical_string() for value in currents}) != len(currents):
+        return False
+    try:
+        basis_values: list[tuple[Any, ...]] = []
+        for basis_index in range(len(currents)):
+            replacements = [
+                _sym.Replacement(current, int(index == basis_index))
+                for index, current in enumerate(currents)
+            ]
+            basis_values.append(tuple(replacements))
+
+        for raw_expression in expressions:
+            expression = _as_expression(raw_expression)
+            residual = expression
+            for current, replacements in zip(currents, basis_values, strict=True):
+                basis_output = expression.replace_multiple(replacements)
+                residual -= current * basis_output
+            canonical = residual.expand().to_canonical_string()
+            if canonical != "0":
+                canonical = residual.together().cancel().expand().to_canonical_string()
+            if canonical != "0":
+                return False
+    except Exception:
+        return False
+    return True
+
+
+def proves_independent_current_block_eligibility(
+    contract_kind: PreparedContractKind,
+    expressions: Sequence[str],
+    inputs: Sequence[PreparedKernelInput],
+) -> bool:
+    """Certify that independent calls may be packed into block lanes.
+
+    The first block variant deliberately targets pure current-to-current vertex
+    maps. Momentum-, coupling-, and model-parameter-bearing contracts retain
+    their scalar evaluator until a separate layout is specified for them.
+    """
+
+    if contract_kind != "vertex" or not expressions or not inputs:
+        return False
+    if any(item.role not in {"left-current", "right-current"} for item in inputs):
+        return False
+    if not {item.role for item in inputs}.issuperset(
+        {"left-current", "right-current"}
+    ):
+        return False
+    declared = {item.symbol for item in inputs}
+    if len(declared) != len(inputs):
+        return False
+    try:
+        used = {
+            symbol.to_canonical_string()
+            for expression in expressions
+            for symbol in _sym.E(expression).get_all_symbols(False)
+            if not symbol.is_constant()
+        }
+    except Exception:
+        return False
+    return used.issubset(declared)
diff --git a/pyamplicol/src/pyamplicol/models/prepared_compile.py b/pyamplicol/src/pyamplicol/models/prepared_compile.py
new file mode 100644
index 0000000000..b1327d92ed
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/prepared_compile.py
@@ -0,0 +1,2076 @@
+# SPDX-License-Identifier: 0BSD
+"""Compile process-independent exact catalogs into prepared model bundles."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.metadata
+import json
+import os
+import re
+import sys
+import tempfile
+import time
+import warnings
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, replace
+from fractions import Fraction
+from pathlib import Path, PurePosixPath
+from typing import cast
+
+from .._internal.physics.symbols import symbols
+from .._internal.versions import (
+    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    EAGER_DIRECT_TABLE_BINDING_ABI,
+    EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+    NATIVE_EAGER_DIRECT_TABLE_APPLICATION_ABI,
+    SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+    SYMBOLICA_SERIALIZATION_ABI,
+    SYMJIT_APPLICATION_ABI,
+    SYMJIT_PLANE_APPLICATION_ABI,
+    package_version,
+    verify_native_module,
+)
+from ..config import EvaluatorConfig
+from ..evaluators.native_eager_direct_cpp import (
+    render_native_eager_direct_table_cpp,
+)
+from ..evaluators.symbolica_adapters import _compiled_compiler_flags
+from ..evaluators.symbolica_compile import (
+    _compile_symbolica_outputs,
+    _symbolica_evaluator_kwargs,
+)
+from ..evaluators.symbolica_helpers import _symbolica_evaluator_artifact_manifest
+from ..evaluators.symbolica_settings import SymbolicaEvaluatorSettings
+from .base import Model
+from .loading import CompiledModel
+from .prepared import (
+    PREPARED_INDEPENDENT_BLOCK_SIZE,
+    PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+    PREPARED_KERNEL_VARIANT_ABI,
+    PreparedBackend,
+    PreparedKernelPack,
+    PreparedKernelRecord,
+    PreparedKernelVariantRecord,
+    PreparedModelBundle,
+    PreparedModelBundleError,
+    load_prepared_model_bundle,
+    prepared_compiled_model_digest,
+    prepared_expression_digest,
+    prepared_input_contract_digest,
+    prepared_kernel_pack_identity,
+    prepared_optimization_settings_digest,
+    prepared_output_contract_digest,
+    prepared_payload_identity_records,
+    write_prepared_model_bundle,
+)
+from .prepared_catalog import (
+    PREPARED_INDEPENDENT_BLOCK_PROOF,
+    PreparedKernelSpec,
+    build_prepared_kernel_catalog,
+)
+from .prepared_target import (
+    PreparedTargetError,
+    canonical_architecture,
+    native_prepared_target,
+    symjit_storage_v3_target,
+)
+from .recurrence_catalog_builder import build_recurrence_template_catalog
+from .recurrence_direct_template import (
+    RECURRENCE_DIRECT_BACKEND_ABI,
+    PreparedJitDirectSourceV1,
+    PreparedNativeDirectCallableSpecV1,
+    PreparedNativeDirectSourceV1,
+    build_prepared_native_direct_callable_specs,
+    build_recurrence_direct_template_catalog,
+    prepared_kernel_payload_digest,
+)
+from .recurrence_template import RecurrenceTemplateCatalog
+
+PreparedModelProgress = Callable[[str, int, int], None]
+_PATH_FIELDS = frozenset(
+    (
+        "application_path",
+        "evaluator_state_path",
+        "library_path",
+        "payload_path",
+        "source_path",
+    )
+)
+_PATH_LIST_FIELDS = frozenset(("payload_paths",))
+_RECURRENCE_PREFLIGHT_PACK_DIGEST = "0" * 63 + "1"
+_ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedModelBuildResult:
+    output: Path
+    bundle: PreparedModelBundle
+    kernel_count: int
+    phase_timings_seconds: Mapping[str, float]
+
+
+@dataclass(frozen=True, slots=True)
+class _IndependentBlockContract:
+    parameters: tuple[object, ...]
+    outputs: tuple[object, ...]
+    input_layout: tuple[str, ...]
+    output_layout: tuple[str, ...]
+
+
+def _validate_native_recurrence_template_input_v1(
+    catalog: RecurrenceTemplateCatalog,
+    authenticated_kernel_ids: Sequence[int],
+) -> Mapping[str, object]:
+    """Validate the fixed-width model projection with the installed Rust core."""
+
+    from ..generation.recurrence_template_columnar import (
+        RECURRENCE_TEMPLATE_INPUT_ABI,
+        RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION,
+        build_recurrence_template_input_v1,
+    )
+
+    kernel_ids = tuple(authenticated_kernel_ids)
+    if kernel_ids != tuple(sorted(set(kernel_ids))) or any(
+        type(kernel_id) is not int or kernel_id < 0 for kernel_id in kernel_ids
+    ):
+        raise PreparedModelBundleError(
+            "authenticated prepared-kernel IDs must be sorted, unique, "
+            "nonnegative integers"
+        )
+    template_input = build_recurrence_template_input_v1(catalog)
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(module)
+    except (ImportError, RuntimeError) as exc:
+        raise PreparedModelBundleError(
+            "recurrence template preparation requires the matching installed "
+            "pyamplicol._rusticol extension"
+        ) from exc
+    candidate = getattr(module, "_validate_recurrence_template_input_v1", None)
+    if not callable(candidate):
+        raise PreparedModelBundleError(
+            "the installed pyamplicol._rusticol extension does not provide "
+            "_validate_recurrence_template_input_v1"
+        )
+    try:
+        raw = candidate(
+            template_input,
+            list(kernel_ids),
+        )
+    except Exception as exc:
+        raise PreparedModelBundleError(
+            f"native recurrence template validation failed: {exc}"
+        ) from exc
+    if not isinstance(raw, Mapping):
+        raise PreparedModelBundleError(
+            "native recurrence template validation returned a non-object result"
+        )
+    expected = {
+        "kind": "pyamplicol-recurrence-template-validation-result",
+        "schema_version": 1,
+        "validation_status": "validated",
+        "template_input_abi": RECURRENCE_TEMPLATE_INPUT_ABI,
+        "template_input_schema_version": RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION,
+        "template_input_sha256": template_input.canonical_digest,
+        "catalog_digest": catalog.catalog_digest,
+        "compiled_model_digest": catalog.header.compiled_model_digest,
+        "prepared_kernel_pack_digest": (catalog.header.prepared_kernel_pack_digest),
+        "prepared_kernel_inventory_verified": True,
+        "prepared_kernel_inventory_count": len(kernel_ids),
+    }
+    for name, expected_value in expected.items():
+        actual_value = raw.get(name)
+        if type(actual_value) is not type(expected_value) or (
+            actual_value != expected_value
+        ):
+            raise PreparedModelBundleError(
+                "native recurrence template validation returned inconsistent "
+                f"{name}: expected {expected_value!r}, found {actual_value!r}"
+            )
+    counts = raw.get("counts")
+    if not isinstance(counts, Mapping):
+        raise PreparedModelBundleError(
+            "native recurrence template validation omitted its count summary"
+        )
+    expected_counts = {
+        "parameters": len(catalog.parameters),
+        "current_states": len(catalog.current_states),
+        "sources": len(catalog.sources),
+        "quantum_flows": len(catalog.quantum_flows),
+        "transitions": len(catalog.transitions),
+        "propagators": len(catalog.propagators),
+        "closures": len(catalog.closures),
+        "color_contractions": len(catalog.color_contractions),
+        "symmetry_proofs": len(catalog.symmetry_proofs),
+        "runtime_helicity_contracts": len(catalog.runtime_helicity_contracts),
+        "evaluator_bindings": len(catalog.evaluator_bindings),
+        "prepared_kernels": len(
+            {
+                binding.prepared_kernel_id
+                for binding in catalog.evaluator_bindings
+                if binding.prepared_kernel_id is not None
+            }
+        ),
+        "referenced_prepared_kernels": len(
+            {
+                binding.prepared_kernel_id
+                for binding in catalog.evaluator_bindings
+                if binding.prepared_kernel_id is not None
+            }
+        ),
+    }
+    for name, expected_value in expected_counts.items():
+        actual_value = counts.get(name)
+        if type(actual_value) is not int or actual_value != expected_value:
+            raise PreparedModelBundleError(
+                "native recurrence template validation returned inconsistent "
+                f"{name} count: expected {expected_value}, found {actual_value!r}"
+            )
+    return raw
+
+
+def _native_build_inputs_sha256() -> str:
+    """Return the authenticated native compiler source identity."""
+
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(module)
+    except (ImportError, RuntimeError) as exc:
+        raise PreparedModelBundleError(
+            "prepared-model compilation requires the matching installed "
+            "pyamplicol._rusticol extension"
+        ) from exc
+    operation = getattr(module, "native_build_inputs_sha256", None)
+    if not callable(operation):
+        raise PreparedModelBundleError(
+            "the installed pyamplicol._rusticol extension does not expose "
+            "its native build identity"
+        )
+    digest = operation()
+    if not isinstance(digest, str) or re.fullmatch(r"[0-9a-f]{64}", digest) is None:
+        raise PreparedModelBundleError(
+            "the installed pyamplicol._rusticol extension has an invalid "
+            "native build identity"
+        )
+    return digest
+
+
+def _rebind_recurrence_template_pack_digest(
+    catalog: RecurrenceTemplateCatalog,
+    prepared_kernel_pack_digest: str,
+) -> RecurrenceTemplateCatalog:
+    """Rebind an already-proven semantic catalog to final evaluator payloads."""
+
+    return RecurrenceTemplateCatalog.create(
+        compiled_model_digest=catalog.header.compiled_model_digest,
+        prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+        parameters=catalog.parameters,
+        current_states=catalog.current_states,
+        sources=catalog.sources,
+        quantum_flows=catalog.quantum_flows,
+        contact_orbit_certificates=catalog.contact_orbit_certificates,
+        contact_orbit_steps=catalog.contact_orbit_steps,
+        transitions=catalog.transitions,
+        propagators=catalog.propagators,
+        closures=catalog.closures,
+        color_contractions=catalog.color_contractions,
+        symmetry_proofs=catalog.symmetry_proofs,
+        runtime_helicity_contracts=catalog.runtime_helicity_contracts,
+        evaluator_bindings=catalog.evaluator_bindings,
+    )
+
+
+def prepare_model_bundle(
+    compiled_model: CompiledModel,
+    output: Path,
+    *,
+    evaluator: EvaluatorConfig,
+    progress: PreparedModelProgress | None = None,
+) -> PreparedModelBuildResult:
+    """Build a prepared evaluator-kernel bundle.
+
+    The bundle is shared by eager, recurrence, and on-the-fly execution.
+    """
+
+    started = time.perf_counter()
+    model = _runtime_model(compiled_model)
+    catalog_started = time.perf_counter()
+    catalog = build_prepared_kernel_catalog(model)
+    catalog_seconds = time.perf_counter() - catalog_started
+    compiled_model_payload = compiled_model.to_dict()
+    compiled_model_digest = prepared_compiled_model_digest(compiled_model_payload)
+    recurrence_catalog_started = time.perf_counter()
+    provisional_recurrence_catalog = build_recurrence_template_catalog(
+        model,
+        catalog,
+        compiled_model_digest=compiled_model_digest,
+        prepared_kernel_pack_digest=_RECURRENCE_PREFLIGHT_PACK_DIGEST,
+    )
+    recurrence_catalog_seconds = time.perf_counter() - recurrence_catalog_started
+    recurrence_preflight_started = time.perf_counter()
+    _validate_native_recurrence_template_input_v1(
+        provisional_recurrence_catalog,
+        tuple(kernel.kernel_id for kernel in catalog.kernels),
+    )
+    native_build_inputs_sha256 = _native_build_inputs_sha256()
+    recurrence_preflight_seconds = time.perf_counter() - recurrence_preflight_started
+    settings = prepared_symbolica_settings(evaluator)
+    backend = cast(PreparedBackend, str(evaluator.backend))
+    optimization_metadata = _optimization_metadata(settings)
+    optimization_digest = prepared_optimization_settings_digest(optimization_metadata)
+    payloads: dict[str, bytes | Path] = {}
+    records: list[PreparedKernelRecord] = []
+    variants: list[PreparedKernelVariantRecord] = []
+    native_direct_specs = (
+        build_prepared_native_direct_callable_specs(
+            provisional_recurrence_catalog,
+            catalog.by_id,
+        )
+        if backend in {"cpp", "asm"}
+        else {}
+    )
+    real_model_parameter_names = frozenset(
+        parameter.name
+        for parameter in provisional_recurrence_catalog.parameters
+        if parameter.value_type == "real"
+    )
+    compile_started = time.perf_counter()
+    with tempfile.TemporaryDirectory(prefix="pyamplicol-prepared-model-") as raw:
+        staging = Path(raw)
+        for index, kernel in enumerate(catalog.kernels):
+            if progress is not None:
+                progress(
+                    f"prepare {kernel.contract_kind} kernel {kernel.kernel_id}",
+                    index,
+                    len(catalog.kernels),
+                )
+            record, kernel_variants, kernel_payloads = _compile_kernel(
+                kernel,
+                settings=settings,
+                staging=staging / f"kernel-{kernel.kernel_id:06d}",
+                backend=backend,
+                optimization_settings_digest=optimization_digest,
+                native_direct_spec=native_direct_specs.get(kernel.kernel_id),
+                real_model_parameter_names=real_model_parameter_names,
+            )
+            records.append(record)
+            variants.extend(kernel_variants)
+            overlap = payloads.keys() & kernel_payloads.keys()
+            if overlap:
+                raise PreparedModelBundleError(
+                    "prepared kernels produced duplicate payload paths: "
+                    + ", ".join(sorted(overlap))
+                )
+            payloads.update(kernel_payloads)
+
+        compile_seconds = time.perf_counter() - compile_started
+        base_pack = PreparedKernelPack(
+            backend=backend,
+            optimization_settings=optimization_metadata,
+            producer={
+                "distribution": "pyamplicol",
+                "version": package_version(),
+                "compiled_model_schema": compiled_model.schema_version,
+                "model_compiler_version": compiled_model.model_compiler_version,
+                "native_build_inputs_sha256": native_build_inputs_sha256,
+            },
+            dependency_abis={
+                "symbolica_serialization": SYMBOLICA_SERIALIZATION_ABI,
+                "symjit_application": SYMJIT_APPLICATION_ABI,
+                "symjit_plane_application": SYMJIT_PLANE_APPLICATION_ABI,
+                "symbolica_version": _distribution_version("symbolica"),
+            },
+            provenance={
+                "model_name": compiled_model.name,
+                "model_source": dict(compiled_model.source),
+                "compiled_model_digest": str(
+                    compiled_model.source.get("digest", "unavailable")
+                ),
+                "catalog_kernel_count": len(catalog.kernels),
+                "unsupported_variant_count": len(catalog.unsupported_variants),
+            },
+            target=_prepared_target(backend, evaluator),
+            resolver_manifest=catalog.resolver_manifest(),
+            kernels=tuple(records),
+            kernel_variants=tuple(variants),
+        )
+        pack_identity = prepared_kernel_pack_identity(
+            base_pack,
+            prepared_payload_identity_records(payloads),
+        )
+        payload_identity_records = prepared_payload_identity_records(payloads)
+        recurrence_binding_started = time.perf_counter()
+        records_by_id = {record.kernel_id: record for record in records}
+        recurrence_catalog = _rebind_recurrence_template_pack_digest(
+            provisional_recurrence_catalog,
+            prepared_kernel_pack_digest=pack_identity.pack_digest,
+        )
+        prepared_jit_sources = (
+            {
+                record.kernel_id: _prepared_jit_direct_source(
+                    record,
+                    payload_identity_records=payload_identity_records,
+                )
+                for record in records
+            }
+            if backend == "jit"
+            else None
+        )
+        prepared_native_sources = (
+            {
+                kernel_id: _prepared_native_direct_source(
+                    records_by_id[kernel_id],
+                    spec=spec,
+                    payload_identity_records=payload_identity_records,
+                )
+                for kernel_id, spec in native_direct_specs.items()
+            }
+            if backend in {"cpp", "asm"}
+            else None
+        )
+        direct_catalog = build_recurrence_direct_template_catalog(
+            recurrence_catalog,
+            backend=backend,
+            target_triple=str(base_pack.target["target_triple"]),
+            portable=bool(base_pack.target["portable"]),
+            optimization_level=(
+                PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL
+                if backend == "jit"
+                else int(settings.compiled_optimization_level)
+            ),
+            prepared_kernel_pack_digest=pack_identity.pack_digest,
+            prepared_kernel_contract_digest=pack_identity.contract_digest,
+            prepared_kernel_payload_digest=pack_identity.payload_digest,
+            optimization_settings_digest=optimization_digest,
+            prepared_kernel_payload_digests={
+                record.kernel_id: prepared_kernel_payload_digest(
+                    kernel_id=record.kernel_id,
+                    payload_records=payload_identity_records,
+                    referenced_paths=record.referenced_payload_paths,
+                )
+                for record in records
+            },
+            prepared_jit_sources=prepared_jit_sources,
+            prepared_native_sources=prepared_native_sources,
+        )
+        recurrence_binding_seconds = time.perf_counter() - recurrence_binding_started
+        authenticated_pack = replace(
+            base_pack,
+            provenance={
+                **dict(base_pack.provenance),
+                "prepared_kernel_contract_digest": pack_identity.contract_digest,
+                "prepared_kernel_payload_digest": pack_identity.payload_digest,
+                "prepared_kernel_pack_digest": pack_identity.pack_digest,
+                "recurrence_template_abi": recurrence_catalog.header.abi,
+                "recurrence_template_digest": recurrence_catalog.catalog_digest,
+                "recurrence_direct_backend_abi": RECURRENCE_DIRECT_BACKEND_ABI,
+                "recurrence_direct_template_abi": direct_catalog.abi,
+                "recurrence_direct_template_digest": direct_catalog.catalog_digest,
+                "direct_template_catalog_digest": direct_catalog.catalog_digest,
+                "recurrence_direct_payload_status": (
+                    "executable"
+                    if direct_catalog.executable
+                    else "pending-direct-call-abi"
+                ),
+            },
+            recurrence_template=recurrence_catalog.to_dict(),
+            recurrence_direct_template=direct_catalog.to_dict(),
+        )
+        recurrence_validation_started = time.perf_counter()
+        recurrence_validation = _validate_native_recurrence_template_input_v1(
+            authenticated_pack.recurrence_template_catalog
+            or recurrence_catalog,  # constructor invariant, kept explicit for typing
+            tuple(kernel.kernel_id for kernel in authenticated_pack.kernels),
+        )
+        recurrence_validation_seconds = (
+            time.perf_counter() - recurrence_validation_started
+        )
+        pack = replace(
+            authenticated_pack,
+            provenance={
+                **dict(authenticated_pack.provenance),
+                "recurrence_template_input_digest": recurrence_validation[
+                    "template_input_sha256"
+                ],
+                "recurrence_template_native_validation_kind": (
+                    recurrence_validation["kind"]
+                ),
+            },
+            recurrence_template=recurrence_catalog.to_dict(),
+            recurrence_direct_template=direct_catalog.to_dict(),
+        )
+        bundle_path = write_prepared_model_bundle(
+            output,
+            compiled_model=compiled_model_payload,
+            kernel_pack=pack,
+            payloads=payloads,
+        )
+
+    bundle = load_prepared_model_bundle(bundle_path)
+    timings = {
+        "catalog": catalog_seconds,
+        "recurrence_catalog": recurrence_catalog_seconds,
+        "recurrence_template_preflight": recurrence_preflight_seconds,
+        "recurrence_template_binding": recurrence_binding_seconds,
+        "recurrence_template_validation": recurrence_validation_seconds,
+        "kernel_compilation": compile_seconds,
+        "total": time.perf_counter() - started,
+    }
+    if progress is not None:
+        progress("prepared model complete", len(catalog.kernels), len(catalog.kernels))
+    return PreparedModelBuildResult(
+        output=bundle_path,
+        bundle=bundle,
+        kernel_count=len(catalog.kernels),
+        phase_timings_seconds=timings,
+    )
+
+
+def prepared_symbolica_settings(
+    evaluator: EvaluatorConfig,
+) -> SymbolicaEvaluatorSettings:
+    """Translate the public evaluator configuration into one-kernel settings."""
+
+    optimization = evaluator.optimization
+    backend = str(evaluator.backend)
+    cores = (
+        max(1, os.cpu_count() or 1)
+        if optimization.cores == "auto"
+        else int(optimization.cores)
+    )
+    collect_factors = (
+        False
+        if optimization.collect_factors == "auto"
+        else bool(optimization.collect_factors)
+    )
+    if (
+        backend == "jit"
+        and evaluator.jit.optimization_level != PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL
+    ):
+        warnings.warn(
+            "prepared JIT model bundles use SymJIT optimization level 2 for "
+            "cross-architecture portability; the requested process-evaluator "
+            f"level {evaluator.jit.optimization_level} is unchanged for compiled "
+            "DAG generation",
+            UserWarning,
+            stacklevel=2,
+        )
+    return SymbolicaEvaluatorSettings(
+        backend="jit" if backend == "jit" else "compiled-complex",
+        iterations=optimization.horner_iterations,
+        cpe_iterations=optimization.cpe_iterations,
+        n_cores=cores,
+        jit_direct_translation=False,
+        # Saved SymJIT applications are process-independent model assets.  O2
+        # is the only storage-v3 optimization level whose MIR is portable
+        # across the supported architecture classes.  Process-local compiled
+        # DAG evaluators continue to honor evaluator.jit.optimization_level.
+        jit_optimization_level=(
+            PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL
+            if backend == "jit"
+            else evaluator.jit.optimization_level
+        ),
+        jit_compress=evaluator.resolved_jit_compress,
+        max_horner_scheme_variables=optimization.max_horner_variables,
+        max_common_pair_cache_entries=optimization.max_common_pair_cache_entries,
+        max_common_pair_distance=optimization.max_common_pair_distance,
+        collect_factors=collect_factors,
+        compiled_inline_asm="default" if backend == "asm" else "none",
+        compiled_optimization_level=_cpp_optimization_level(evaluator.cpp.optimization),
+        compiled_native=evaluator.cpp.native_arch,
+        compiler_path=evaluator.cpp.compiler,
+        compiler_flags=evaluator.cpp.extra_flags,
+        compiled_output_chunk_size=None,
+        output_chunk_strategy="uniform",
+        output_chunk_autotune_batch_size=evaluator.batch_size,
+        compiled_chunk_compile_workers=1,
+        compiled_output_dir=None,
+    )
+
+
+def _runtime_model(compiled: CompiledModel) -> Model:
+    from . import BuiltinSMModel, CompiledUFOModel
+
+    if compiled.source.get("kind") == "built-in-sm":
+        return BuiltinSMModel()
+    return CompiledUFOModel(compiled)
+
+
+def _prepared_jit_direct_source(
+    record: PreparedKernelRecord,
+    *,
+    payload_identity_records: Mapping[str, tuple[int, str]],
+) -> PreparedJitDirectSourceV1:
+    manifest = record.f64_evaluator_manifest
+    plane_application = manifest.get("plane_application")
+    if not isinstance(plane_application, Mapping):
+        raise PreparedModelBundleError(
+            f"prepared JIT kernel {record.kernel_id} has no plane application"
+        )
+    application_path = plane_application.get("application_path")
+    if not isinstance(application_path, str) or not application_path:
+        raise PreparedModelBundleError(
+            f"prepared JIT kernel {record.kernel_id} has no plane application payload"
+        )
+    try:
+        _size, application_sha256 = payload_identity_records[application_path]
+    except KeyError as exc:
+        raise PreparedModelBundleError(
+            f"prepared JIT kernel {record.kernel_id} application payload "
+            f"{application_path!r} has no identity record"
+        ) from exc
+    application_abi = plane_application.get("application_abi")
+    if application_abi != SYMJIT_PLANE_APPLICATION_ABI:
+        raise PreparedModelBundleError(
+            f"prepared JIT kernel {record.kernel_id} has incompatible "
+            f"plane application ABI {application_abi!r}"
+        )
+    return PreparedJitDirectSourceV1(
+        prepared_kernel_id=record.kernel_id,
+        source_application_path=application_path,
+        source_application_sha256=application_sha256,
+        source_application_abi=application_abi,
+        input_contracts=tuple(
+            json.dumps(
+                dict(contract),
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            for contract in record.input_contracts
+        ),
+        exact_expressions=record.exact_expressions,
+        output_arity=record.output_arity,
+    )
+
+
+def _prepared_native_direct_source(
+    record: PreparedKernelRecord,
+    *,
+    spec: PreparedNativeDirectCallableSpecV1,
+    payload_identity_records: Mapping[str, tuple[int, str]],
+) -> PreparedNativeDirectSourceV1:
+    manifest = record.f64_evaluator_manifest
+    library_path = manifest.get("library_path")
+    if not isinstance(library_path, str) or not library_path:
+        raise PreparedModelBundleError(
+            f"prepared native kernel {record.kernel_id} has no library payload"
+        )
+    try:
+        _size, library_sha256 = payload_identity_records[library_path]
+    except KeyError as exc:
+        raise PreparedModelBundleError(
+            f"prepared native kernel {record.kernel_id} library payload "
+            f"{library_path!r} has no identity record"
+        ) from exc
+    source_application_abi = manifest.get("runtime_capability")
+    if source_application_abi not in {
+        SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+        SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    }:
+        raise PreparedModelBundleError(
+            f"prepared native kernel {record.kernel_id} has incompatible runtime "
+            f"capability {source_application_abi!r}"
+        )
+    if spec.prepared_kernel_id != record.kernel_id:
+        raise PreparedModelBundleError(
+            f"prepared native direct spec for kernel {record.kernel_id} identifies "
+            f"kernel {spec.prepared_kernel_id}"
+        )
+    return PreparedNativeDirectSourceV1(
+        prepared_kernel_id=record.kernel_id,
+        role=spec.role,
+        native_entry_point=spec.native_entry_point,
+        source_application_path=library_path,
+        source_application_sha256=library_sha256,
+        source_application_abi=source_application_abi,
+        input_contracts=spec.input_contracts,
+        exact_expressions=record.exact_expressions,
+        output_arity=record.output_arity,
+    )
+
+
+def _compile_kernel(
+    kernel: PreparedKernelSpec,
+    *,
+    settings: SymbolicaEvaluatorSettings,
+    staging: Path,
+    backend: PreparedBackend,
+    optimization_settings_digest: str,
+    native_direct_spec: PreparedNativeDirectCallableSpecV1 | None = None,
+    real_model_parameter_names: frozenset[str] = frozenset(),
+) -> tuple[
+    PreparedKernelRecord,
+    tuple[PreparedKernelVariantRecord, ...],
+    dict[str, Path],
+]:
+    from symbolica import Expression
+
+    staging.mkdir(parents=True, exist_ok=True)
+    scalar_staging = staging / "scalar"
+    scalar_staging.mkdir(parents=True, exist_ok=True)
+    from .compiler_records import _replace_evaluator_constants
+
+    outputs = tuple(
+        _replace_evaluator_constants(Expression.parse(value))
+        for value in kernel.exact_expressions
+    )
+    parameters = [Expression.parse(item.symbol) for item in kernel.inputs]
+    real_parameters = _real_kernel_parameter_indices(
+        kernel,
+        real_model_parameter_names=real_model_parameter_names,
+    )
+    if backend == "jit":
+        if native_direct_spec is not None:
+            raise PreparedModelBundleError(
+                f"prepared JIT kernel {kernel.kernel_id} cannot carry a native "
+                "Direct-Arena compile specification"
+            )
+        adapter = _compile_symbolica_outputs(
+            outputs,
+            parameters,
+            merge_evaluators_strategy=False,
+            verbose_evaluator_build=False,
+            real_params=real_parameters,
+            symbolica_settings=replace(settings, compiled_output_chunk_size=None),
+            jit_compile=True,
+            label=f"prepared_{kernel.contract_kind}_{kernel.kernel_id:06d}",
+        )
+        raw_manifest = _symbolica_evaluator_artifact_manifest(adapter, scalar_staging)
+    else:
+        raw_manifest = _compile_native_split_real_kernel(
+            kernel,
+            outputs=outputs,
+            parameters=parameters,
+            real_parameters=real_parameters,
+            settings=replace(settings, compiled_output_chunk_size=None),
+            staging=scalar_staging,
+            direct_spec=native_direct_spec,
+        )
+    manifest, payloads = _relocate_manifest_payloads(
+        raw_manifest,
+        staging=scalar_staging,
+        kernel_id=kernel.kernel_id,
+    )
+    _validate_backend_manifest(manifest, settings=settings)
+    exact_state = manifest.get("evaluator_state_path")
+    if not isinstance(exact_state, str) or not exact_state:
+        raise PreparedModelBundleError(
+            f"prepared kernel {kernel.kernel_id} lacks retained exact evaluator state"
+        )
+    record = PreparedKernelRecord(
+        kernel_id=kernel.kernel_id,
+        contract_kind=kernel.contract_kind,
+        canonical_signature=kernel.canonical_signature,
+        input_arity=kernel.input_arity,
+        output_arity=kernel.output_dimension,
+        input_layout=tuple(f"{item.role}:{item.component}" for item in kernel.inputs),
+        input_contracts=tuple(item.to_dict() for item in kernel.inputs),
+        output_layout=kernel.output_layout,
+        exact_expressions=kernel.exact_expressions,
+        proof_classes=kernel.proof_classes,
+        exact_evaluator_state_path=exact_state,
+        f64_evaluator_manifest=manifest,
+    )
+    variants: tuple[PreparedKernelVariantRecord, ...] = ()
+    if backend == "jit" and PREPARED_INDEPENDENT_BLOCK_PROOF in kernel.proof_classes:
+        variant, variant_payloads = _compile_independent_block_variant(
+            kernel,
+            settings=settings,
+            staging=staging,
+            backend=backend,
+            optimization_settings_digest=optimization_settings_digest,
+        )
+        overlap = payloads.keys() & variant_payloads.keys()
+        if overlap:
+            raise PreparedModelBundleError(
+                "prepared scalar and block evaluator payload paths overlap: "
+                + ", ".join(sorted(overlap))
+            )
+        payloads.update(variant_payloads)
+        variants = (variant,)
+    return record, variants, payloads
+
+
+def _real_kernel_parameter_indices(
+    kernel: PreparedKernelSpec,
+    *,
+    real_model_parameter_names: frozenset[str],
+) -> tuple[int, ...]:
+    """Return parameters certified real by their generic prepared contracts."""
+
+    always_real_roles = {
+        "left-momentum",
+        "right-momentum",
+        "momentum",
+        "coupling-real",
+        "coupling-imag",
+    }
+    return tuple(
+        index
+        for index, item in enumerate(kernel.inputs)
+        if item.role in always_real_roles
+        or (
+            item.role == "model-parameter"
+            and item.model_parameter_name in real_model_parameter_names
+        )
+    )
+
+
+def _native_eager_simd_lane_width(target: Mapping[str, object]) -> int:
+    target_triple = str(target["target_triple"])
+    raw_features = target.get("cpu_features", ())
+    cpu_features = frozenset(str(feature) for feature in raw_features)
+    return 4 if target_triple.startswith("x86_64") and "avx2" in cpu_features else 2
+
+
+def _compile_native_split_real_kernel(
+    kernel: PreparedKernelSpec,
+    *,
+    outputs: tuple[object, ...],
+    parameters: list[object],
+    real_parameters: tuple[int, ...],
+    settings: SymbolicaEvaluatorSettings,
+    staging: Path,
+    direct_spec: PreparedNativeDirectCallableSpecV1 | None,
+) -> dict[str, object]:
+    """Compile a native scalar/direct library without Symbolica's complex exporter."""
+
+    from symbolica import Expression
+
+    if settings.backend != "compiled-complex":
+        raise PreparedModelBundleError(
+            "split-real native preparation requires the compiled backend"
+        )
+    function_name = f"pyamplicol_prepared_native_k{kernel.kernel_id:08x}"
+    raw_function_name = f"{function_name}_split"
+    source_path = staging / f"{function_name}.cpp"
+    library_path = staging / f"lib{function_name}"
+    evaluator_state_path = staging / f"{function_name}.evaluator.bin"
+    evaluator_kwargs = _symbolica_evaluator_kwargs(
+        settings,
+        verbose=False,
+        jit_compile=False,
+    )
+
+    exact_evaluator = Expression.evaluator_multiple(
+        outputs,
+        parameters,
+        **evaluator_kwargs,
+    )
+    if real_parameters:
+        exact_evaluator.set_real_params(
+            list(real_parameters),
+            sqrt_real=settings.real_param_sqrt_real,
+            log_real=settings.real_param_log_real,
+            powf_real=settings.real_param_powf_real,
+            real_if_args_real=settings.real_param_real_if_args_real,
+            verbose=False,
+        )
+    save = getattr(exact_evaluator, "save", None)
+    if not callable(save):
+        raise PreparedModelBundleError(
+            f"prepared native kernel {kernel.kernel_id} cannot retain exact state"
+        )
+    evaluator_state_bytes = save()
+    if not isinstance(evaluator_state_bytes, bytes) or not evaluator_state_bytes:
+        raise PreparedModelBundleError(
+            f"prepared native kernel {kernel.kernel_id} returned invalid exact state"
+        )
+    evaluator_state_path.write_bytes(evaluator_state_bytes)
+    try:
+        native_target = native_prepared_target(
+            include_cpu_features=settings.compiled_native
+        )
+    except PreparedTargetError:
+        # Low-level compiler tests intentionally exercise the native producer
+        # without a built Rust extension. Full prepared-pack publication still
+        # calls `_prepared_target` and therefore fails closed without exact
+        # Rusticol target introspection.
+        native_target = {
+            "target_triple": (
+                f"{canonical_architecture()}-{sys.platform}-compile-only"
+            ),
+            "cpu_features": [],
+        }
+    target_triple = str(native_target["target_triple"])
+    simd_lane_width = _native_eager_simd_lane_width(native_target)
+    eager_direct = render_native_eager_direct_table_cpp(
+        exact_evaluator,
+        kernel_id=kernel.kernel_id,
+        input_complex_count=kernel.input_arity,
+        output_complex_count=kernel.output_dimension,
+        target_triple=target_triple,
+        simd_lane_width=simd_lane_width,
+        real_parameter_indices=real_parameters,
+        evaluator_state_bytes=evaluator_state_bytes,
+    )
+
+    split_parameters, split_outputs = _split_complex_kernel_contract(
+        kernel.kernel_id,
+        outputs=outputs,
+        parameters=parameters,
+        real_parameters=real_parameters,
+    )
+    split_evaluator = Expression.evaluator_multiple(
+        split_outputs,
+        list(split_parameters),
+        **evaluator_kwargs,
+    )
+    split_evaluator.set_real_params(
+        list(range(len(split_parameters))),
+        sqrt_real=settings.real_param_sqrt_real,
+        log_real=settings.real_param_log_real,
+        powf_real=settings.real_param_powf_real,
+        real_if_args_real=settings.real_param_real_if_args_real,
+        verbose=False,
+    )
+    custom_header = _native_split_real_custom_header(
+        kernel,
+        raw_function_name=raw_function_name,
+        direct_spec=direct_spec,
+        eager_direct_source=eager_direct.source,
+        raw_parameters_const=settings.compiled_inline_asm != "none",
+    )
+    compile_started = time.perf_counter()
+    split_evaluator.compile(
+        raw_function_name,
+        str(source_path),
+        str(library_path),
+        "real",
+        inline_asm=settings.compiled_inline_asm,
+        optimization_level=settings.compiled_optimization_level,
+        native=settings.compiled_native,
+        compiler_path=settings.compiler_path,
+        compiler_flags=_compiled_compiler_flags(settings),
+        custom_header=custom_header,
+    )
+    compile_seconds = time.perf_counter() - compile_started
+    runtime_capability = (
+        SYMBOLICA_CPP_RUNTIME_CAPABILITY
+        if settings.compiled_inline_asm == "none"
+        else SYMBOLICA_ASM_RUNTIME_CAPABILITY
+    )
+    return {
+        "kind": "compiled-complex-evaluator",
+        "runtime_capability": runtime_capability,
+        "backend": settings.backend,
+        "number_type": "complex",
+        # The sole eager f64 entry is the DirectTable callable. The split-real
+        # symbol remains private implementation support for the separate
+        # recurrence direct callable when that lane is present; no legacy
+        # dense complex entry is published.
+        "function_name": eager_direct.function_name,
+        "input_len": kernel.input_arity,
+        "output_len": kernel.output_dimension,
+        "settings": settings.to_json_dict(),
+        "source_path": str(source_path),
+        "library_path": str(library_path),
+        "evaluator_state_path": str(evaluator_state_path),
+        "build_timing": {
+            "cxx_compile_s": compile_seconds,
+        },
+        "direct_table": {
+            "capability": EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            "source_application_abi": (NATIVE_EAGER_DIRECT_TABLE_APPLICATION_ABI),
+            "descriptor_abi": EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+            "binding_abi": EAGER_DIRECT_TABLE_BINDING_ABI,
+            "library_path": str(library_path),
+            "function_name": eager_direct.function_name,
+            "evaluator_state_sha256": (eager_direct.evaluator_state_sha256),
+            "input_complex_count": eager_direct.input_complex_count,
+            "output_complex_count": eager_direct.output_complex_count,
+            "invocation_stride": eager_direct.invocation_stride,
+            "attachment_stride": eager_direct.attachment_stride,
+            "simd_lane_width": eager_direct.simd_lane_width,
+            "instruction_count": eager_direct.instruction_count,
+            "temporary_count": eager_direct.temporary_count,
+        },
+    }
+
+
+def _split_complex_kernel_contract(
+    kernel_id: int,
+    *,
+    outputs: tuple[object, ...],
+    parameters: list[object],
+    real_parameters: tuple[int, ...],
+) -> tuple[tuple[object, ...], tuple[object, ...]]:
+    """Lower the exact algebraic kernel into structurally real expressions."""
+
+    from symbolica import AtomType, Expression
+
+    split_parameters: list[object] = []
+    parameter_pairs: dict[str, tuple[object, object]] = {}
+    real_parameter_set = set(real_parameters)
+    if any(index < 0 or index >= len(parameters) for index in real_parameter_set):
+        raise PreparedModelBundleError(
+            f"prepared native kernel {kernel_id} has an invalid real parameter index"
+        )
+    zero = Expression.num(0)
+    for index, parameter in enumerate(parameters):
+        tree = parameter.to_atom_tree()
+        if tree.atom_type != AtomType.Var or not isinstance(tree.head, str):
+            raise PreparedModelBundleError(
+                f"prepared native kernel {kernel_id} parameter {index} is not "
+                "a scalar symbol"
+            )
+        real = symbols.real_symbol(
+            f"prepared_native::kernel_{kernel_id:08x}::input_{index}::re"
+        )
+        imag = symbols.real_symbol(
+            f"prepared_native::kernel_{kernel_id:08x}::input_{index}::im"
+        )
+        split_parameters.extend((real, imag))
+        parameter_pairs[tree.head] = (
+            real,
+            zero if index in real_parameter_set else imag,
+        )
+
+    split_outputs: list[object] = []
+    admitted_symbols = {
+        tree.head
+        for symbol in split_parameters
+        for tree in (symbol.to_atom_tree(),)
+        if tree.atom_type == AtomType.Var and isinstance(tree.head, str)
+    }
+    for output_index, output in enumerate(outputs):
+        real, imag = _split_complex_atom_tree(
+            output.to_atom_tree(),
+            kernel_id=kernel_id,
+            output_index=output_index,
+            parameter_pairs=parameter_pairs,
+        )
+        if not _is_structurally_real_expression(
+            real,
+            admitted_symbols=admitted_symbols,
+        ) or not _is_structurally_real_expression(
+            imag,
+            admitted_symbols=admitted_symbols,
+        ):
+            raise PreparedModelBundleError(
+                f"prepared native kernel {kernel_id} output {output_index} "
+                "cannot be certified as split-real"
+            )
+        used_symbols = {
+            tree.head
+            for expression in (real, imag)
+            for symbol in expression.get_all_symbols(False)
+            if not symbol.is_constant()
+            for tree in (symbol.to_atom_tree(),)
+            if tree.atom_type == AtomType.Var and isinstance(tree.head, str)
+        }
+        if not used_symbols.issubset(admitted_symbols):
+            raise PreparedModelBundleError(
+                f"prepared native kernel {kernel_id} output {output_index} "
+                "contains an unbound split-real symbol"
+            )
+        split_outputs.extend((real, imag))
+    return tuple(split_parameters), tuple(split_outputs)
+
+
+def _split_complex_atom_tree(
+    tree: object,
+    *,
+    kernel_id: int,
+    output_index: int,
+    parameter_pairs: Mapping[str, tuple[object, object]],
+) -> tuple[object, object]:
+    """Recursively evaluate one algebraic expression over real/imaginary pairs."""
+
+    from symbolica import AtomType, Expression
+
+    atom_type = tree.atom_type
+    if atom_type == AtomType.Var:
+        if not isinstance(tree.head, str) or tree.head not in parameter_pairs:
+            raise PreparedModelBundleError(
+                f"prepared native kernel {kernel_id} output {output_index} "
+                f"uses an unbound symbol {tree.head!r}"
+            )
+        return parameter_pairs[tree.head]
+    if atom_type == AtomType.Num:
+        if not isinstance(tree.head, str):
+            raise PreparedModelBundleError(
+                f"prepared native kernel {kernel_id} output {output_index} "
+                "has a malformed numeric coefficient"
+            )
+        number = Expression.parse(_ANSI_ESCAPE_RE.sub("", tree.head))
+        imaginary_unit = Expression.parse("sqrt(-1)")
+        return (
+            ((number + number.conj()) / 2).expand(),
+            ((number - number.conj()) / (2 * imaginary_unit)).expand(),
+        )
+    if atom_type == AtomType.Add:
+        result = (Expression.num(0), Expression.num(0))
+        for child in tree.tail:
+            value = _split_complex_atom_tree(
+                child,
+                kernel_id=kernel_id,
+                output_index=output_index,
+                parameter_pairs=parameter_pairs,
+            )
+            result = (result[0] + value[0], result[1] + value[1])
+        return result
+    if atom_type == AtomType.Mul:
+        result = (Expression.num(1), Expression.num(0))
+        for child in tree.tail:
+            value = _split_complex_atom_tree(
+                child,
+                kernel_id=kernel_id,
+                output_index=output_index,
+                parameter_pairs=parameter_pairs,
+            )
+            result = _multiply_complex_pairs(result, value)
+        return result
+    if atom_type == AtomType.Pow:
+        if (
+            len(tree.tail) != 2
+            or tree.tail[1].atom_type != AtomType.Num
+            or not isinstance(tree.tail[1].head, str)
+        ):
+            raise PreparedModelBundleError(
+                f"prepared native kernel {kernel_id} output {output_index} "
+                "uses a non-numeric exponent"
+            )
+        exponent = Expression.parse(_ANSI_ESCAPE_RE.sub("", tree.tail[1].head))
+        try:
+            exact_exponent = Fraction(exponent.to_canonical_string())
+        except ValueError as exc:
+            raise PreparedModelBundleError(
+                f"prepared native kernel {kernel_id} output {output_index} "
+                f"uses unsupported complex power {exponent}"
+            ) from exc
+        base = _split_complex_atom_tree(
+            tree.tail[0],
+            kernel_id=kernel_id,
+            output_index=output_index,
+            parameter_pairs=parameter_pairs,
+        )
+        if exact_exponent.denominator != 1:
+            if base[1].to_canonical_string() != "0":
+                raise PreparedModelBundleError(
+                    f"prepared native kernel {kernel_id} output {output_index} "
+                    f"uses non-integer power {exponent} of a complex expression"
+                )
+            if exact_exponent.denominator != 2:
+                raise PreparedModelBundleError(
+                    f"prepared native kernel {kernel_id} output {output_index} "
+                    f"uses unsupported real non-integer power {exponent}"
+                )
+            return base[0] ** exponent, Expression.num(0)
+        return _integer_power_complex_pair(base, exact_exponent.numerator)
+    raise PreparedModelBundleError(
+        f"prepared native kernel {kernel_id} output {output_index} uses "
+        f"unsupported expression atom {atom_type}"
+    )
+
+
+def _is_structurally_real_expression(
+    expression: object,
+    *,
+    admitted_symbols: set[str],
+) -> bool:
+    """Certify the real-branch grammar emitted by split-complex lowering."""
+
+    from symbolica import AtomType, Expression
+
+    def visit(tree: object) -> bool:
+        if tree.atom_type == AtomType.Var:
+            return isinstance(tree.head, str) and tree.head in admitted_symbols
+        if tree.atom_type == AtomType.Num:
+            return (
+                isinstance(tree.head, str)
+                and Expression.parse(_ANSI_ESCAPE_RE.sub("", tree.head)).is_real()
+            )
+        if tree.atom_type == AtomType.Add or tree.atom_type == AtomType.Mul:
+            return all(visit(child) for child in tree.tail)
+        if tree.atom_type == AtomType.Pow:
+            if len(tree.tail) != 2 or not visit(tree.tail[0]):
+                return False
+            exponent = tree.tail[1]
+            return (
+                exponent.atom_type == AtomType.Num
+                and isinstance(exponent.head, str)
+                and Expression.parse(_ANSI_ESCAPE_RE.sub("", exponent.head)).is_real()
+            )
+        return False
+
+    return visit(expression.to_atom_tree())
+
+
+def _multiply_complex_pairs(
+    left: tuple[object, object],
+    right: tuple[object, object],
+) -> tuple[object, object]:
+    return (
+        left[0] * right[0] - left[1] * right[1],
+        left[0] * right[1] + left[1] * right[0],
+    )
+
+
+def _integer_power_complex_pair(
+    base: tuple[object, object],
+    exponent: int,
+) -> tuple[object, object]:
+    from symbolica import Expression
+
+    if exponent == 0:
+        return Expression.num(1), Expression.num(0)
+    if exponent < 0:
+        positive = _integer_power_complex_pair(base, -exponent)
+        norm = positive[0] * positive[0] + positive[1] * positive[1]
+        return positive[0] / norm, -positive[1] / norm
+    result = (Expression.num(1), Expression.num(0))
+    factor = base
+    remaining = exponent
+    while remaining:
+        if remaining & 1:
+            result = _multiply_complex_pairs(result, factor)
+        remaining >>= 1
+        if remaining:
+            factor = _multiply_complex_pairs(factor, factor)
+    return result
+
+
+def _native_split_real_custom_header(
+    kernel: PreparedKernelSpec,
+    *,
+    raw_function_name: str,
+    direct_spec: PreparedNativeDirectCallableSpecV1 | None,
+    eager_direct_source: str = "",
+    raw_parameters_const: bool = False,
+) -> str:
+    lines = [
+        "#include <cstddef>",
+        "#include <cstdint>",
+    ]
+    if direct_spec is not None:
+        lines.extend(
+            (
+                "",
+                (
+                    'extern "C" unsigned long '
+                    f"{raw_function_name}_realf64_get_buffer_len();"
+                ),
+                (
+                    f'extern "C" void {raw_function_name}_realf64('
+                    f"{'const ' if raw_parameters_const else ''}"
+                    "double*, double*, double*);"
+                ),
+                "",
+                _native_direct_arena_declarations(),
+                "",
+                _native_direct_export(
+                    kernel,
+                    raw_function_name=raw_function_name,
+                    spec=direct_spec,
+                ),
+            )
+        )
+    if eager_direct_source:
+        lines.extend(("", eager_direct_source))
+    return "\n".join(lines)
+
+
+def _native_direct_arena_declarations() -> str:
+    return r"""
+extern "C" {
+struct DirectArenaView {
+  double* current_re;
+  double* current_im;
+  std::uint64_t current_scalar_len;
+  double* amplitude_re;
+  double* amplitude_im;
+  std::uint64_t amplitude_scalar_len;
+  std::uint32_t point_stride;
+};
+struct DirectMomentumView {
+  const double* values;
+  std::uint64_t scalar_len;
+  std::uint32_t form_count;
+  std::uint16_t lorentz_component_count;
+  std::uint32_t point_stride;
+};
+struct DirectParameterView {
+  const double* values_re;
+  const double* values_im;
+  std::uint32_t value_count;
+};
+struct DirectFactorView {
+  const double* values_re;
+  const double* values_im;
+  std::uint32_t value_count;
+};
+struct DirectNativeBindingContextV1 {
+  double coupling_re;
+  double coupling_im;
+};
+struct DirectContributionRow {
+  std::uint32_t parent0_component_base;
+  std::uint32_t parent1_component_base_or_sentinel;
+  std::uint32_t parent0_momentum_form_id;
+  std::uint32_t parent1_momentum_form_id_or_sentinel;
+  std::uint32_t destination_component_base;
+  std::uint32_t exact_factor_id;
+  std::uint32_t selector_domain_id;
+  std::uint32_t flags;
+};
+struct DirectFinalizationRow {
+  std::uint32_t component_base;
+  std::uint16_t component_count;
+  std::uint32_t momentum_form_id;
+  std::uint32_t exact_factor_id;
+  std::uint32_t selector_domain_id;
+  std::uint32_t flags;
+};
+struct DirectClosureRow {
+  std::uint32_t parent0_component_base;
+  std::uint32_t parent1_component_base_or_sentinel;
+  std::uint32_t parent0_momentum_form_id;
+  std::uint32_t parent1_momentum_form_id_or_sentinel;
+  std::uint32_t amplitude_destination_id;
+  std::uint32_t exact_factor_id;
+  std::uint32_t component_factor_start;
+  std::uint16_t component_count;
+  std::uint32_t selector_domain_id;
+  std::uint32_t flags;
+};
+}
+
+static_assert(sizeof(void*) == 8u, "Direct-Arena requires a 64-bit target");
+static_assert(sizeof(DirectArenaView) == 56u);
+static_assert(offsetof(DirectArenaView, current_scalar_len) == 16u);
+static_assert(offsetof(DirectArenaView, amplitude_re) == 24u);
+static_assert(offsetof(DirectArenaView, point_stride) == 48u);
+static_assert(sizeof(DirectMomentumView) == 32u);
+static_assert(offsetof(DirectMomentumView, form_count) == 16u);
+static_assert(offsetof(DirectMomentumView, point_stride) == 24u);
+static_assert(sizeof(DirectParameterView) == 24u);
+static_assert(offsetof(DirectParameterView, value_count) == 16u);
+static_assert(sizeof(DirectFactorView) == 24u);
+static_assert(sizeof(DirectNativeBindingContextV1) == 16u);
+static_assert(sizeof(DirectContributionRow) == 32u);
+static_assert(sizeof(DirectFinalizationRow) == 24u);
+static_assert(offsetof(DirectFinalizationRow, momentum_form_id) == 8u);
+static_assert(sizeof(DirectClosureRow) == 40u);
+static_assert(offsetof(DirectClosureRow, component_count) == 28u);
+static_assert(offsetof(DirectClosureRow, selector_domain_id) == 32u);
+
+static constexpr std::uint32_t PAC_DIRECT_NONE = 0xffffffffu;
+static constexpr std::uint32_t PAC_DIRECT_INITIALIZE = 1u;
+static constexpr unsigned long PAC_DIRECT_MAX_SCRATCH_DOUBLES = 65536ul;
+
+static inline bool pac_direct_plane_index(
+    std::uint32_t base,
+    std::uint32_t component,
+    std::uint32_t point,
+    std::uint32_t stride,
+    std::uint64_t scalar_len,
+    std::uint64_t* index) {
+  if (stride == 0u || point >= stride) return false;
+  const std::uint64_t plane =
+      static_cast<std::uint64_t>(base) + static_cast<std::uint64_t>(component);
+  if (plane > (UINT64_MAX - point) / stride) return false;
+  *index = plane * stride + point;
+  return *index < scalar_len;
+}
+
+static inline bool pac_direct_load_current(
+    DirectArenaView arena,
+    std::uint32_t base,
+    std::uint32_t component,
+    std::uint32_t point,
+    double* re,
+    double* im) {
+  std::uint64_t index = 0;
+  if (arena.current_re == nullptr || arena.current_im == nullptr ||
+      !pac_direct_plane_index(
+          base, component, point, arena.point_stride,
+          arena.current_scalar_len, &index)) return false;
+  *re = arena.current_re[index];
+  *im = arena.current_im[index];
+  return true;
+}
+
+static inline bool pac_direct_load_momentum(
+    DirectMomentumView momenta,
+    std::uint32_t form,
+    std::uint32_t component,
+    std::uint32_t point,
+    double* value) {
+  if (momenta.values == nullptr || momenta.point_stride == 0u ||
+      point >= momenta.point_stride || form >= momenta.form_count ||
+      component >= momenta.lorentz_component_count) return false;
+  const std::uint64_t plane =
+      static_cast<std::uint64_t>(form) * momenta.lorentz_component_count +
+      component;
+  if (plane > (UINT64_MAX - point) / momenta.point_stride) return false;
+  const std::uint64_t index = plane * momenta.point_stride + point;
+  if (index >= momenta.scalar_len) return false;
+  *value = momenta.values[index];
+  return true;
+}
+
+static inline bool pac_direct_load_parameter(
+    DirectParameterView parameters,
+    std::uint32_t index,
+    double* re,
+    double* im) {
+  if (index >= parameters.value_count || parameters.values_re == nullptr ||
+      parameters.values_im == nullptr) return false;
+  *re = parameters.values_re[index];
+  *im = parameters.values_im[index];
+  return true;
+}
+
+static inline bool pac_direct_load_factor(
+    DirectFactorView factors,
+    std::uint32_t index,
+    double* re,
+    double* im) {
+  if (index >= factors.value_count || factors.values_re == nullptr ||
+      factors.values_im == nullptr) return false;
+  *re = factors.values_re[index];
+  *im = factors.values_im[index];
+  return true;
+}
+
+static inline bool pac_direct_store_current(
+    DirectArenaView arena,
+    std::uint32_t base,
+    std::uint32_t component,
+    std::uint32_t point,
+    double re,
+    double im,
+    bool add) {
+  std::uint64_t index = 0;
+  if (arena.current_re == nullptr || arena.current_im == nullptr ||
+      !pac_direct_plane_index(
+          base, component, point, arena.point_stride,
+          arena.current_scalar_len, &index)) return false;
+  if (add) {
+    arena.current_re[index] += re;
+    arena.current_im[index] += im;
+  } else {
+    arena.current_re[index] = re;
+    arena.current_im[index] = im;
+  }
+  return true;
+}
+
+static inline bool pac_direct_store_amplitude(
+    DirectArenaView arena,
+    std::uint32_t base,
+    std::uint32_t component,
+    std::uint32_t point,
+    double re,
+    double im) {
+  std::uint64_t index = 0;
+  if (arena.amplitude_re == nullptr || arena.amplitude_im == nullptr ||
+      !pac_direct_plane_index(
+          base, component, point, arena.point_stride,
+          arena.amplitude_scalar_len, &index)) return false;
+  arena.amplitude_re[index] += re;
+  arena.amplitude_im[index] += im;
+  return true;
+}
+""".strip()
+
+
+def _native_direct_export(
+    kernel: PreparedKernelSpec,
+    *,
+    raw_function_name: str,
+    spec: PreparedNativeDirectCallableSpecV1,
+) -> str:
+    if spec.prepared_kernel_id != kernel.kernel_id:
+        raise PreparedModelBundleError(
+            "native direct export kernel ID does not match its prepared kernel"
+        )
+    if spec.exact_expressions != kernel.exact_expressions:
+        raise PreparedModelBundleError(
+            f"native direct kernel {kernel.kernel_id} expressions do not match "
+            "the recurrence callable specification"
+        )
+    if spec.output_arity > min(spec.destination_component_counts):
+        raise PreparedModelBundleError(
+            f"native direct kernel {kernel.kernel_id} output exceeds destination "
+            "component count"
+        )
+    if spec.role == "closure" and spec.output_arity != 1:
+        raise PreparedModelBundleError(
+            "native Direct-Arena closure callables must produce one amplitude"
+        )
+    contracts = tuple(json.loads(item) for item in spec.input_contracts)
+    if tuple(item.to_dict() for item in kernel.inputs) != contracts:
+        raise PreparedModelBundleError(
+            f"native direct kernel {kernel.kernel_id} input contracts do not match"
+        )
+    row_type = {
+        "contribution": "DirectContributionRow",
+        "finalization": "DirectFinalizationRow",
+        "closure": "DirectClosureRow",
+    }[spec.role]
+    uses_binding_coupling = any(
+        contract.get("role") in {"coupling-real", "coupling-imag"}
+        for contract in contracts
+    )
+    lines = [
+        f'extern "C" int {spec.native_entry_point}(',
+        "    const void* context,",
+        "    DirectArenaView arena,",
+        "    DirectMomentumView momenta,",
+        "    DirectParameterView parameters,",
+        "    DirectFactorView factors,",
+        f"    const {row_type}* rows,",
+        "    std::uint32_t row_count,",
+        "    std::uint32_t point_count) {",
+        (
+            "  if (context == nullptr) return 1;"
+            if uses_binding_coupling
+            else "  (void)context;"
+        ),
+        *(
+            (
+                "  const auto* binding_context = static_cast<const "
+                "DirectNativeBindingContextV1*>(context);",
+            )
+            if uses_binding_coupling
+            else ()
+        ),
+        "  if (rows == nullptr || row_count == 0u || point_count == 0u ||",
+        "      arena.point_stride == 0u || point_count > arena.point_stride ||",
+        "      arena.point_stride != momenta.point_stride) return 1;",
+        (
+            "  const unsigned long raw_buffer_len = "
+            f"{raw_function_name}_realf64_get_buffer_len();"
+        ),
+        ("  if (raw_buffer_len > PAC_DIRECT_MAX_SCRATCH_DOUBLES) return 3;"),
+        (
+            "  double* storage = static_cast<double*>("
+            "__builtin_alloca(sizeof(double) * "
+            f"({2 * kernel.input_arity}u + {2 * kernel.output_dimension}u + "
+            "raw_buffer_len)));"
+        ),
+        "  if (storage == nullptr) return 3;",
+        "  double* split_params = storage;",
+        f"  double* split_out = split_params + {2 * kernel.input_arity}u;",
+        f"  double* split_buffer = split_out + {2 * kernel.output_dimension}u;",
+        "  for (std::uint32_t row_index = 0; row_index < row_count; ++row_index) {",
+        "    const auto& row = rows[row_index];",
+    ]
+    if spec.role == "contribution":
+        lines.append("    if ((row.flags & ~PAC_DIRECT_INITIALIZE) != 0u) return 2;")
+    else:
+        lines.append("    if (row.flags != 0u) return 2;")
+    if spec.role == "finalization":
+        admitted_counts = " || ".join(
+            f"row.component_count == {count}u"
+            for count in spec.destination_component_counts
+        )
+        lines.append(f"    if (!({admitted_counts})) return 2;")
+    lines.extend(
+        (
+            "    double factor_re = 0.0;",
+            "    double factor_im = 0.0;",
+            "    if (!pac_direct_load_factor(",
+            "            factors, row.exact_factor_id, &factor_re, "
+            "&factor_im)) return 2;",
+            "    for (std::uint32_t point = 0; point < point_count; ++point) {",
+        )
+    )
+    lines.extend(_native_direct_input_loads(spec, contracts))
+    lines.append(
+        f"      {raw_function_name}_realf64(split_params, split_buffer, split_out);"
+    )
+    for component in range(kernel.output_dimension):
+        lines.extend(
+            (
+                f"      const double value_{component}_re = "
+                f"split_out[{2 * component}u] * factor_re - "
+                f"split_out[{2 * component + 1}u] * factor_im;",
+                f"      const double value_{component}_im = "
+                f"split_out[{2 * component}u] * factor_im + "
+                f"split_out[{2 * component + 1}u] * factor_re;",
+            )
+        )
+        if spec.role == "closure":
+            lines.extend(
+                (
+                    "      if (!pac_direct_store_amplitude(",
+                    "              arena, row.amplitude_destination_id, "
+                    f"{component}u, point,",
+                    f"              value_{component}_re, "
+                    f"value_{component}_im)) return 2;",
+                )
+            )
+        else:
+            base = (
+                "row.destination_component_base"
+                if spec.role == "contribution"
+                else "row.component_base"
+            )
+            add = (
+                "(row.flags & PAC_DIRECT_INITIALIZE) == 0u"
+                if spec.role == "contribution"
+                else "false"
+            )
+            lines.extend(
+                (
+                    "      if (!pac_direct_store_current(",
+                    f"              arena, {base}, {component}u, point,",
+                    f"              value_{component}_re, "
+                    f"value_{component}_im, {add})) return 2;",
+                )
+            )
+    lines.extend(("    }", "  }", "  return 0;", "}"))
+    return "\n".join(lines)
+
+
+def _native_direct_input_loads(
+    spec: PreparedNativeDirectCallableSpecV1,
+    contracts: Sequence[Mapping[str, object]],
+) -> list[str]:
+    lines: list[str] = []
+    for index, contract in enumerate(contracts):
+        role = contract.get("role")
+        component = contract.get("component")
+        if type(component) is not int or component < 0:
+            raise PreparedModelBundleError(
+                "native direct input component must be a nonnegative integer"
+            )
+        real_slot = 2 * index
+        imag_slot = real_slot + 1
+        if role in {"left-current", "right-current", "current"}:
+            parent = 1 if role == "right-current" else 0
+            if parent >= len(spec.parent_component_shapes[0]):
+                raise PreparedModelBundleError(
+                    f"native direct {role} input has no recurrence parent"
+                )
+            if any(
+                component >= shape[parent] for shape in spec.parent_component_shapes
+            ):
+                raise PreparedModelBundleError(
+                    f"native direct {role} component exceeds an admitted parent state"
+                )
+            if spec.role == "finalization":
+                base = "row.component_base"
+            elif parent == 0:
+                base = "row.parent0_component_base"
+            else:
+                base = "row.parent1_component_base_or_sentinel"
+                lines.append(
+                    "      if (row.parent1_component_base_or_sentinel == "
+                    "PAC_DIRECT_NONE) return 2;"
+                )
+            lines.extend(
+                (
+                    "      if (!pac_direct_load_current(",
+                    f"              arena, {base}, {component}u, point,",
+                    f"              &split_params[{real_slot}u], "
+                    f"&split_params[{imag_slot}u])) return 2;",
+                )
+            )
+        elif role in {"left-momentum", "right-momentum", "momentum"}:
+            operand = 1 if role == "right-momentum" else 0
+            if spec.role == "finalization":
+                form = "row.momentum_form_id"
+            elif operand == 0:
+                form = "row.parent0_momentum_form_id"
+            else:
+                form = "row.parent1_momentum_form_id_or_sentinel"
+                lines.append(
+                    "      if (row.parent1_momentum_form_id_or_sentinel == "
+                    "PAC_DIRECT_NONE) return 2;"
+                )
+            lines.extend(
+                (
+                    "      if (!pac_direct_load_momentum(",
+                    f"              momenta, {form}, {component}u, point,",
+                    f"              &split_params[{real_slot}u])) return 2;",
+                    f"      split_params[{imag_slot}u] = 0.0;",
+                )
+            )
+        elif role in {"coupling-real", "coupling-imag"}:
+            lines.extend(
+                (
+                    f"      split_params[{real_slot}u] = "
+                    "binding_context->"
+                    f"{'coupling_im' if role == 'coupling-imag' else 'coupling_re'};",
+                    f"      split_params[{imag_slot}u] = 0.0;",
+                )
+            )
+        elif role == "model-parameter":
+            parameter_index = contract.get("model_parameter_index")
+            if type(parameter_index) is not int or parameter_index < 0:
+                raise PreparedModelBundleError(
+                    "native direct model parameter has no stable index"
+                )
+            lines.extend(
+                (
+                    "      if (!pac_direct_load_parameter(",
+                    f"              parameters, {parameter_index}u,",
+                    f"              &split_params[{real_slot}u], "
+                    f"&split_params[{imag_slot}u])) return 2;",
+                )
+            )
+        else:
+            raise PreparedModelBundleError(
+                f"unsupported native direct input role {role!r}"
+            )
+    return lines
+
+
+def _cpp_float_literal(value: float) -> str:
+    if not value.is_integer():
+        return value.hex()
+    return f"{value:.1f}"
+
+
+def _independent_block_contract(
+    kernel: PreparedKernelSpec,
+    *,
+    block_size: int = PREPARED_INDEPENDENT_BLOCK_SIZE,
+) -> _IndependentBlockContract:
+    """Construct lane-major expressions for independent scalar calls."""
+
+    from symbolica import Expression, Replacement
+
+    if PREPARED_INDEPENDENT_BLOCK_PROOF not in kernel.proof_classes:
+        raise PreparedModelBundleError(
+            f"prepared kernel {kernel.kernel_id} lacks the independent-block proof"
+        )
+    if block_size != PREPARED_INDEPENDENT_BLOCK_SIZE:
+        raise PreparedModelBundleError(
+            f"unsupported prepared independent block size {block_size}"
+        )
+    scalar_inputs = tuple(Expression.parse(item.symbol) for item in kernel.inputs)
+    scalar_outputs = tuple(
+        Expression.parse(value) for value in kernel.exact_expressions
+    )
+    parameters: list[object] = []
+    outputs: list[object] = []
+    input_layout: list[str] = []
+    output_layout: list[str] = []
+    for lane in range(block_size):
+        lane_inputs = tuple(
+            symbols.symbol(
+                "prepared_block::"
+                f"kernel_{kernel.canonical_signature}::lane_{lane}::input_{index}"
+            )
+            for index in range(kernel.input_arity)
+        )
+        forward = tuple(
+            Replacement(source, target)
+            for source, target in zip(scalar_inputs, lane_inputs, strict=True)
+        )
+        reverse = tuple(
+            Replacement(target, source)
+            for source, target in zip(scalar_inputs, lane_inputs, strict=True)
+        )
+        lane_outputs = tuple(
+            expression.replace_multiple(forward) for expression in scalar_outputs
+        )
+        reconstructed = tuple(
+            expression.replace_multiple(reverse).to_canonical_string()
+            for expression in lane_outputs
+        )
+        expected = tuple(
+            expression.to_canonical_string() for expression in scalar_outputs
+        )
+        if reconstructed != expected:
+            raise PreparedModelBundleError(
+                f"prepared kernel {kernel.kernel_id} block lane {lane} "
+                "does not reconstruct its scalar expressions"
+            )
+        lane_symbols = {value.to_canonical_string() for value in lane_inputs}
+        used_symbols = {
+            symbol.to_canonical_string()
+            for expression in lane_outputs
+            for symbol in expression.get_all_symbols(False)
+            if not symbol.is_constant()
+        }
+        if not used_symbols.issubset(lane_symbols):
+            raise PreparedModelBundleError(
+                f"prepared kernel {kernel.kernel_id} block lane {lane} "
+                "contains inputs from another lane"
+            )
+        parameters.extend(lane_inputs)
+        outputs.extend(lane_outputs)
+        input_layout.extend(
+            f"lane:{lane}:{item}" for item in _kernel_input_layout(kernel)
+        )
+        output_layout.extend(f"lane:{lane}:{item}" for item in kernel.output_layout)
+    return _IndependentBlockContract(
+        parameters=tuple(parameters),
+        outputs=tuple(outputs),
+        input_layout=tuple(input_layout),
+        output_layout=tuple(output_layout),
+    )
+
+
+def _compile_independent_block_variant(
+    kernel: PreparedKernelSpec,
+    *,
+    settings: SymbolicaEvaluatorSettings,
+    staging: Path,
+    backend: PreparedBackend,
+    optimization_settings_digest: str,
+) -> tuple[PreparedKernelVariantRecord, dict[str, Path]]:
+    contract = _independent_block_contract(kernel)
+    variant_id = f"independent-block-{PREPARED_INDEPENDENT_BLOCK_SIZE}"
+    variant_staging = staging / "variants" / variant_id
+    variant_staging.mkdir(parents=True, exist_ok=True)
+    adapter = _compile_symbolica_outputs(
+        contract.outputs,
+        list(contract.parameters),
+        merge_evaluators_strategy=False,
+        verbose_evaluator_build=False,
+        real_params=(),
+        symbolica_settings=replace(settings, compiled_output_chunk_size=None),
+        jit_compile=True,
+        label=(
+            f"prepared_{kernel.contract_kind}_{kernel.kernel_id:06d}_"
+            f"independent_block_{PREPARED_INDEPENDENT_BLOCK_SIZE}"
+        ),
+    )
+    raw_manifest = _symbolica_evaluator_artifact_manifest(adapter, variant_staging)
+    manifest, payloads = _relocate_manifest_payloads(
+        raw_manifest,
+        staging=variant_staging,
+        kernel_id=kernel.kernel_id,
+        variant_id=variant_id,
+    )
+    _validate_backend_manifest(manifest, settings=settings)
+    return (
+        PreparedKernelVariantRecord(
+            variant_id=variant_id,
+            variant_abi=PREPARED_KERNEL_VARIANT_ABI,
+            kind="independent-block",
+            block_size=PREPARED_INDEPENDENT_BLOCK_SIZE,
+            lane_layout="lane-major",
+            base_kernel_id=kernel.kernel_id,
+            base_canonical_signature=kernel.canonical_signature,
+            base_expression_digest=prepared_expression_digest(kernel.exact_expressions),
+            base_input_contract_digest=prepared_input_contract_digest(
+                _kernel_input_layout(kernel),
+                tuple(item.to_dict() for item in kernel.inputs),
+            ),
+            base_output_contract_digest=prepared_output_contract_digest(
+                kernel.output_layout
+            ),
+            backend=backend,
+            optimization_settings_digest=optimization_settings_digest,
+            input_arity=len(contract.parameters),
+            output_arity=len(contract.outputs),
+            input_lane_stride=kernel.input_arity,
+            output_lane_stride=kernel.output_dimension,
+            input_layout=contract.input_layout,
+            output_layout=contract.output_layout,
+            f64_evaluator_manifest=manifest,
+        ),
+        payloads,
+    )
+
+
+def _kernel_input_layout(kernel: PreparedKernelSpec) -> tuple[str, ...]:
+    return tuple(f"{item.role}:{item.component}" for item in kernel.inputs)
+
+
+def _relocate_manifest_payloads(
+    manifest: Mapping[str, object],
+    *,
+    staging: Path,
+    kernel_id: int,
+    variant_id: str | None = None,
+) -> tuple[dict[str, object], dict[str, Path]]:
+    payloads: dict[str, Path] = {}
+    relocated: dict[Path, str] = {}
+    counters: dict[str, int] = {}
+
+    def relocate(path: object, field: str) -> str:
+        if not isinstance(path, str) or not path:
+            raise PreparedModelBundleError(
+                f"prepared evaluator {field} must be a nonempty path"
+            )
+        source = Path(path)
+        if not source.is_absolute():
+            source = staging / source
+        source = source.resolve()
+        if not source.is_file() or source.is_symlink():
+            raise PreparedModelBundleError(
+                f"prepared evaluator payload does not exist: {source}"
+            )
+        existing = relocated.get(source)
+        if existing is not None:
+            return existing
+        count = counters.get(field, 0)
+        counters[field] = count + 1
+        stem = field.removesuffix("_path").replace("_", "-")
+        suffix = "".join(source.suffixes)
+        root = PurePosixPath("kernels") / f"{kernel_id:06d}"
+        if variant_id is not None:
+            root = root / "variants" / variant_id
+        member = (root / f"{stem}-{count}{suffix}").as_posix()
+        relocated[source] = member
+        payloads[member] = source
+        return member
+
+    def visit(value: object) -> object:
+        if isinstance(value, Mapping):
+            result: dict[str, object] = {}
+            for key, child in value.items():
+                if key in _PATH_FIELDS:
+                    result[str(key)] = (
+                        None if child is None else relocate(child, str(key))
+                    )
+                elif key in _PATH_LIST_FIELDS:
+                    if not isinstance(child, Sequence) or isinstance(
+                        child, (str, bytes, bytearray)
+                    ):
+                        raise PreparedModelBundleError(
+                            f"prepared evaluator {key} must be a path array"
+                        )
+                    result[str(key)] = [relocate(item, str(key)) for item in child]
+                else:
+                    result[str(key)] = visit(child)
+            return result
+        if isinstance(value, Sequence) and not isinstance(
+            value, (str, bytes, bytearray)
+        ):
+            return [visit(item) for item in value]
+        return value
+
+    result = visit(manifest)
+    if not isinstance(result, dict):  # pragma: no cover - mapping root invariant
+        raise PreparedModelBundleError("prepared evaluator manifest must be an object")
+    return result, payloads
+
+
+def _validate_backend_manifest(
+    manifest: Mapping[str, object],
+    *,
+    settings: SymbolicaEvaluatorSettings,
+) -> None:
+    if settings.backend != "jit":
+        if manifest.get("kind") != "compiled-complex-evaluator":
+            raise PreparedModelBundleError(
+                "prepared native evaluator has an unexpected manifest kind"
+            )
+        return
+    expected = {
+        "kind": "symjit-application-evaluator",
+        "application_abi": SYMJIT_APPLICATION_ABI,
+        "compiler_type": "native",
+        "translation_mode": "indirect",
+        "word_bits": 64,
+        "endianness": "little",
+    }
+    for key, value in expected.items():
+        if manifest.get(key) != value:
+            raise PreparedModelBundleError(
+                f"prepared JIT evaluator has incompatible {key}: {manifest.get(key)!r}"
+            )
+    if manifest.get("required_defuns") != []:
+        raise PreparedModelBundleError(
+            "prepared JIT evaluators must not depend on external functions"
+        )
+    plane_application = manifest.get("plane_application")
+    if not isinstance(plane_application, Mapping):
+        raise PreparedModelBundleError(
+            "prepared JIT evaluator has no direct-arena plane application"
+        )
+    expected_plane = {
+        "application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+        "storage_abi": SYMJIT_APPLICATION_ABI,
+        "element_layout": "split-complex-plane-major",
+        "descriptor_order": "inputs-re-im-then-outputs-re-im",
+        "input_complex_count": manifest.get("input_len"),
+        "output_complex_count": manifest.get("output_len"),
+        "input_plane_count": 2 * int(manifest.get("input_len", -1)),
+        "output_plane_count": 2 * int(manifest.get("output_len", -1)),
+        "compiler_type": "native",
+        "translation_mode": "symbolica-structured-instructions",
+        "simd": True,
+        "complex": True,
+        "fast_math": True,
+        "fast_complex": False,
+        "threading": False,
+        "direct_arena": True,
+    }
+    for key, value in expected_plane.items():
+        if plane_application.get(key) != value:
+            raise PreparedModelBundleError(
+                "prepared JIT plane application has incompatible "
+                f"{key}: {plane_application.get(key)!r}"
+            )
+    expected_level = PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL
+    if manifest.get("optimization_level") != expected_level:
+        raise PreparedModelBundleError(
+            "prepared JIT evaluator is not portable: expected SymJIT "
+            f"optimization level {expected_level}, found "
+            f"{manifest.get('optimization_level')!r}"
+        )
+    if plane_application.get("optimization_level") != expected_level:
+        raise PreparedModelBundleError(
+            "prepared JIT plane application is not portable: expected SymJIT "
+            f"optimization level {expected_level}, found "
+            f"{plane_application.get('optimization_level')!r}"
+        )
+    manifest_settings = manifest.get("settings")
+    if not isinstance(manifest_settings, Mapping) or (
+        manifest_settings.get("jit_optimization_level") != expected_level
+    ):
+        raise PreparedModelBundleError(
+            "prepared JIT evaluator settings do not attest the portable "
+            f"SymJIT optimization level {expected_level}"
+        )
+
+
+def _optimization_metadata(settings: SymbolicaEvaluatorSettings) -> dict[str, object]:
+    result = settings.to_json_dict()
+    result["compiled_output_dir"] = None
+    result["compiled_output_chunk_size"] = None
+    return result
+
+
+def _prepared_target(
+    backend: PreparedBackend,
+    evaluator: EvaluatorConfig,
+) -> dict[str, object]:
+    try:
+        if backend == "jit":
+            return symjit_storage_v3_target()
+        return native_prepared_target(include_cpu_features=evaluator.cpp.native_arch)
+    except PreparedTargetError as error:
+        raise PreparedModelBundleError(str(error)) from error
+
+
+def _distribution_version(name: str) -> str:
+    try:
+        return importlib.metadata.version(name)
+    except importlib.metadata.PackageNotFoundError:
+        return "unknown"
+
+
+def _cpp_optimization_level(value: str) -> int:
+    normalized = value.strip().lower()
+    if normalized.startswith("-o"):
+        normalized = normalized[2:]
+    elif normalized.startswith("o"):
+        normalized = normalized[1:]
+    if normalized in {"0", "1", "2", "3"}:
+        return int(normalized)
+    raise PreparedModelBundleError(
+        f"unsupported prepared C++ optimization level {value!r}"
+    )
+
+
+__all__ = [
+    "PreparedModelBuildResult",
+    "prepare_model_bundle",
+    "prepared_symbolica_settings",
+]
diff --git a/pyamplicol/src/pyamplicol/models/prepared_target.py b/pyamplicol/src/pyamplicol/models/prepared_target.py
new file mode 100644
index 0000000000..b2e8604b0b
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/prepared_target.py
@@ -0,0 +1,182 @@
+# SPDX-License-Identifier: 0BSD
+"""Prepared-kernel target identities and host compatibility checks."""
+
+from __future__ import annotations
+
+import importlib
+import platform
+import struct
+import sys
+from collections.abc import Mapping, Sequence
+
+from pyamplicol._internal.versions import verify_native_module
+
+SYMJIT_STORAGE_V3_ABI = "symjit-application-storage-v3"
+SYMJIT_STORAGE_V3_TARGET_PREFIX = "symjit-storage-v3"
+SYMJIT_STORAGE_V3_PORTABLE_TARGET = f"{SYMJIT_STORAGE_V3_TARGET_PREFIX}-portable"
+
+
+class PreparedTargetError(ValueError):
+    """Raised when a prepared kernel pack cannot execute on this host."""
+
+
+def canonical_architecture(machine: str | None = None) -> str:
+    """Return the architecture identity used by prepared JIT storage v3."""
+
+    value = platform.machine() if machine is None else machine
+    normalized = value.strip().lower().replace("-", "_")
+    aliases = {
+        "amd64": "x86_64",
+        "x64": "x86_64",
+        "x86_64": "x86_64",
+        "aarch64": "aarch64",
+        "arm64": "aarch64",
+    }
+    try:
+        return aliases[normalized]
+    except KeyError as exc:
+        raise PreparedTargetError(
+            f"prepared JIT kernels do not support host architecture {value!r}"
+        ) from exc
+
+
+def symjit_storage_v3_target(
+    *,
+    machine: str | None = None,
+    word_bits: int | None = None,
+    endianness: str | None = None,
+) -> dict[str, object]:
+    """Describe a portable O2 SymJIT storage-v3 prepared-kernel pack."""
+
+    bits = struct.calcsize("P") * 8 if word_bits is None else word_bits
+    byte_order = sys.byteorder if endianness is None else endianness
+    if bits != 64 or byte_order != "little":
+        raise PreparedTargetError(
+            "prepared JIT kernels require a 64-bit little-endian host"
+        )
+    # Fail early on unsupported hosts while keeping the stored target
+    # architecture-neutral. SymJIT storage-v3 applications compiled at O2 are
+    # portable between the supported x86-64 and AArch64 hosts.
+    canonical_architecture(machine)
+    return {
+        "portable": True,
+        "word_bits": 64,
+        "endianness": "little",
+        "target_triple": SYMJIT_STORAGE_V3_PORTABLE_TARGET,
+        "cpu_features": [],
+    }
+
+
+def native_prepared_target(*, include_cpu_features: bool) -> dict[str, object]:
+    """Describe a target-native C++ or ASM prepared pack."""
+
+    try:
+        rusticol = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(rusticol)
+        info = rusticol.target_info()
+    except (AttributeError, ImportError, OSError) as exc:
+        raise PreparedTargetError(
+            "native prepared packs require Rusticol target introspection"
+        ) from exc
+    features = (
+        sorted(str(item) for item in info.cpu_features) if include_cpu_features else []
+    )
+    return {
+        "portable": False,
+        "word_bits": struct.calcsize("P") * 8,
+        "endianness": sys.byteorder,
+        "target_triple": str(info.triple),
+        "cpu_features": features,
+    }
+
+
+def validate_prepared_target(
+    target: Mapping[str, object],
+    *,
+    backend: str,
+    symjit_application_abi: str | None = None,
+    machine: str | None = None,
+    word_bits: int | None = None,
+    endianness: str | None = None,
+) -> None:
+    """Fail before DAG construction when a prepared pack cannot run here."""
+
+    if backend == "jit":
+        if symjit_application_abi != SYMJIT_STORAGE_V3_ABI:
+            raise PreparedTargetError(
+                "prepared JIT pack declares unsupported SymJIT application ABI "
+                f"{symjit_application_abi!r}"
+            )
+        expected = symjit_storage_v3_target(
+            machine=machine,
+            word_bits=word_bits,
+            endianness=endianness,
+        )
+        actual = _plain_target(target)
+        if actual != expected:
+            raise PreparedTargetError(
+                "prepared JIT pack target is incompatible with this host: "
+                f"pack={actual.get('target_triple')!r}, expected the portable "
+                f"target {expected['target_triple']!r}; recompile the prepared "
+                "model with SymJIT optimization level 2"
+            )
+        return
+
+    if backend not in {"asm", "cpp"}:
+        raise PreparedTargetError(f"unsupported prepared backend {backend!r}")
+    expected = native_prepared_target(include_cpu_features=False)
+    actual = _plain_target(target)
+    for field in ("portable", "word_bits", "endianness", "target_triple"):
+        if actual.get(field) != expected[field]:
+            raise PreparedTargetError(
+                "native prepared pack target is incompatible with this host: "
+                f"pack={actual.get('target_triple')!r}, "
+                f"host={expected['target_triple']!r}"
+            )
+    required_features = set(_strings(actual.get("cpu_features")))
+    try:
+        rusticol = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(rusticol)
+        available_features = {str(item) for item in rusticol.target_info().cpu_features}
+    except (AttributeError, ImportError, OSError) as exc:
+        raise PreparedTargetError(
+            "native prepared packs require Rusticol target introspection"
+        ) from exc
+    missing = sorted(required_features - available_features)
+    if missing:
+        raise PreparedTargetError(
+            "native prepared pack requires unavailable CPU features: "
+            + ", ".join(missing)
+        )
+
+
+def _plain_target(target: Mapping[str, object]) -> dict[str, object]:
+    return {
+        "portable": target.get("portable"),
+        "word_bits": target.get("word_bits"),
+        "endianness": target.get("endianness"),
+        "target_triple": target.get("target_triple"),
+        "cpu_features": list(_strings(target.get("cpu_features"))),
+    }
+
+
+def _strings(value: object) -> tuple[str, ...]:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes, bytearray)):
+        raise PreparedTargetError("prepared target cpu_features must be an array")
+    if not all(isinstance(item, str) for item in value):
+        raise PreparedTargetError(
+            "prepared target cpu_features must contain only strings"
+        )
+    return tuple(value)
+
+
+__all__ = [
+    "SYMJIT_STORAGE_V3_ABI",
+    "SYMJIT_STORAGE_V3_PORTABLE_TARGET",
+    "SYMJIT_STORAGE_V3_TARGET_PREFIX",
+    "PreparedTargetError",
+    "canonical_architecture",
+    "native_prepared_target",
+    "symjit_storage_v3_target",
+    "validate_prepared_target",
+]
diff --git a/pyamplicol/src/pyamplicol/models/recurrence_catalog_builder.py b/pyamplicol/src/pyamplicol/models/recurrence_catalog_builder.py
new file mode 100644
index 0000000000..340861f5af
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/recurrence_catalog_builder.py
@@ -0,0 +1,3752 @@
+# SPDX-License-Identifier: 0BSD
+"""Build the process-independent recurrence semantic catalog.
+
+The builder deliberately consumes only model contracts and prepared-kernel
+records.  It does not inspect a process and it does not classify a model by
+name or Python type.  Any semantic relation that is not represented by those
+contracts is rejected rather than inferred from a familiar particle inventory.
+
+Prepared source-fill kernels are not part of the pre-existing eager kernel
+catalog.  Recurrence companions therefore bind source semantics to generic
+Rusticol source-fill templates, while vertex, propagator, closure, and model
+parameter callables retain their prepared-kernel bindings.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections.abc import Mapping, Sequence
+from types import SimpleNamespace
+from typing import Any
+
+from .base import (
+    Model,
+    RecurrenceQuantumFlowContract,
+    Vertex,
+    _runtime_particle_parameter_name,
+)
+from .contact_decomposition import HEFT_CONTACT_ORBIT_EVALUATOR_CLASS
+from .lc_color_port_wiring import compile_lc_color_port_wirings
+from .prepared_catalog import (
+    PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF,
+    PreparedClosureBinding,
+    PreparedKernelCatalog,
+    PreparedKernelCatalogError,
+    PreparedKernelInput,
+    PreparedParticleState,
+    PreparedPropagatorBinding,
+    PreparedVertexBinding,
+)
+from .recurrence_template import (
+    ClosureTemplateV1,
+    ColorContractionTemplateV1,
+    ContactOrbitCertificateV1,
+    ContactOrbitStepV1,
+    CurrentStateTemplateV1,
+    EvaluatorBindingV1,
+    ExactComplexRationalV1,
+    FlavourFlowOperationV1,
+    LCColorSourceSeedV1,
+    LCColorTransitionWitnessV1,
+    ParameterTemplateV1,
+    PropagatorTemplateV1,
+    QuantumFlowTemplateV1,
+    RecurrenceRuntimeHelicityContractV1,
+    RecurrenceRuntimeHelicityVariantV1,
+    RecurrenceTemplateCatalog,
+    RecurrenceTemplateError,
+    SourceTemplateV1,
+    SymmetryProofV1,
+    TransitionTemplateV1,
+)
+
+_PREPARED_CATALOG_ABI = "pyamplicol-prepared-kernel-catalog-v1"
+_CURRENT_WORD_REFLECTION_PROOF = "canonical-current-word-reversal-v1"
+_SUPPORTED_COLOR_RULES = frozenset(
+    {
+        "singlet",
+        "color-identity",
+        "fundamental-generator",
+        "adjoint-structure-constant",
+        "adjoint-structure-constant-product",
+    }
+)
+
+
+def build_recurrence_template_catalog(
+    model: Model,
+    prepared_catalog: PreparedKernelCatalog,
+    *,
+    compiled_model_digest: str,
+    prepared_kernel_pack_digest: str,
+) -> RecurrenceTemplateCatalog:
+    """Project one model and its exact prepared kernels into recurrence v1.
+
+    The construction is deterministic and process independent.  Callback
+    results that affect recurrence semantics are sampled twice and compared in
+    canonical form; a stateful or nondeterministic model therefore fails
+    closed.  All prepared callables are independently signature-checked before
+    their IDs are admitted into the recurrence catalog.
+    """
+
+    _require_digest(compiled_model_digest, "compiled model digest")
+    _require_digest(prepared_kernel_pack_digest, "prepared kernel pack digest")
+    _validate_prepared_catalog_identity(model, prepared_catalog)
+    kernels = _validated_kernels(prepared_catalog)
+    recurrence_catalog = _recurrence_prepared_catalog(model, prepared_catalog)
+
+    prepared_states = _collect_prepared_states(recurrence_catalog)
+    parameters = _build_parameters(model, recurrence_catalog, prepared_states)
+    parameter_ids = {parameter.name: parameter.template_id for parameter in parameters}
+    current_states = _build_current_states(model, prepared_states, parameter_ids)
+    state_ids = {
+        (state.particle_id, state.chirality): state.template_id
+        for state in current_states
+    }
+    state_by_id = {state.template_id: state for state in current_states}
+
+    evaluator_builders: list[_EvaluatorRequest] = []
+    sources, source_evaluator_bindings = _build_sources(
+        model,
+        prepared_states,
+        state_ids,
+        parameter_ids,
+    )
+    recurrence_vertex_bindings = _canonical_recurrence_vertex_bindings(
+        recurrence_catalog.vertex_bindings
+    )
+    contact_orbit_certificates, contact_orbit_steps, contact_orbit_steps_by_binding = (
+        _build_contact_orbit_records(recurrence_vertex_bindings)
+    )
+    (
+        transition_quantum_flows,
+        transitions,
+        transition_colors,
+        transition_proofs,
+    ) = _build_transitions(
+        model,
+        recurrence_vertex_bindings,
+        state_ids,
+        parameter_ids,
+        kernels,
+        evaluator_builders,
+        contact_orbit_steps_by_binding,
+    )
+    propagators, propagator_proofs = _build_propagators(
+        model,
+        recurrence_catalog.propagator_bindings,
+        state_ids,
+        parameter_ids,
+        kernels,
+        evaluator_builders,
+    )
+    (
+        closure_quantum_flows,
+        prepared_closures,
+        prepared_closure_colors,
+    ) = _build_closures(
+        model,
+        recurrence_catalog.closure_bindings,
+        state_ids,
+        parameter_ids,
+        kernels,
+        evaluator_builders,
+    )
+    direct_closures, direct_closure_colors, direct_closure_bindings = (
+        _build_direct_closures(
+            model,
+            state_ids,
+            state_by_id,
+        )
+    )
+    closures = (*prepared_closures, *direct_closures)
+    quantum_flows_by_id = {
+        flow.template_id: flow
+        for flow in (*transition_quantum_flows, *closure_quantum_flows)
+    }
+    closure_colors = (*prepared_closure_colors, *direct_closure_colors)
+    _add_model_parameter_evaluator(
+        recurrence_catalog,
+        parameters,
+        kernels,
+        evaluator_builders,
+    )
+    evaluator_bindings = (
+        *source_evaluator_bindings,
+        *direct_closure_bindings,
+        *_coalesce_evaluator_requests(evaluator_builders),
+    )
+    runtime_helicity_contracts = _build_runtime_helicity_contracts(
+        model,
+        recurrence_catalog,
+        current_states,
+        sources,
+    )
+
+    colors_by_id = {
+        color.template_id: color for color in (*transition_colors, *closure_colors)
+    }
+    return RecurrenceTemplateCatalog.create(
+        compiled_model_digest=compiled_model_digest,
+        prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+        parameters=parameters,
+        current_states=current_states,
+        sources=sources,
+        quantum_flows=tuple(quantum_flows_by_id.values()),
+        contact_orbit_certificates=contact_orbit_certificates,
+        contact_orbit_steps=contact_orbit_steps,
+        transitions=transitions,
+        propagators=propagators,
+        closures=closures,
+        color_contractions=tuple(colors_by_id.values()),
+        symmetry_proofs=(*transition_proofs, *propagator_proofs),
+        runtime_helicity_contracts=runtime_helicity_contracts,
+        evaluator_bindings=evaluator_bindings,
+    )
+
+
+class _EvaluatorRequest:
+    __slots__ = (
+        "contract_kind",
+        "input_state_template_ids",
+        "kernel",
+        "output_state_template_id",
+        "semantic_template_id",
+    )
+
+    def __init__(
+        self,
+        *,
+        kernel: Any,
+        contract_kind: str,
+        input_state_template_ids: tuple[str, ...],
+        output_state_template_id: str | None,
+        semantic_template_id: str,
+    ) -> None:
+        self.kernel = kernel
+        self.contract_kind = contract_kind
+        self.input_state_template_ids = input_state_template_ids
+        self.output_state_template_id = output_state_template_id
+        self.semantic_template_id = semantic_template_id
+
+
+def _canonical_json(payload: object) -> str:
+    try:
+        return json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+    except (TypeError, ValueError) as exc:
+        raise RecurrenceTemplateError(
+            "recurrence model callback returned noncanonical metadata"
+        ) from exc
+
+
+def _digest(payload: object) -> str:
+    return hashlib.sha256(_canonical_json(payload).encode("ascii")).hexdigest()
+
+
+def _expression_digest(expression: str) -> str:
+    if not isinstance(expression, str) or not expression:
+        raise PreparedKernelCatalogError(
+            "prepared kernel exact expressions must be nonempty strings"
+        )
+    return hashlib.sha256(expression.encode("utf-8")).hexdigest()
+
+
+def _require_digest(value: object, context: str) -> str:
+    if (
+        not isinstance(value, str)
+        or len(value) != 64
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise RecurrenceTemplateError(f"{context} must be a lowercase SHA-256")
+    return value
+
+
+def _token(prefix: str, payload: object) -> str:
+    return f"{prefix}:{_digest(payload)[:24]}"
+
+
+def _exact_pair(value: object, context: str) -> ExactComplexRationalV1:
+    if isinstance(value, complex):
+        pair = (float(value.real), float(value.imag))
+    elif isinstance(value, (tuple, list)) and len(value) == 2:
+        if any(
+            isinstance(item, bool) or not isinstance(item, (int, float))
+            for item in value
+        ):
+            raise RecurrenceTemplateError(
+                f"{context} must contain two real binary64 components"
+            )
+        pair = (float(value[0]), float(value[1]))
+    elif isinstance(value, (int, float)) and not isinstance(value, bool):
+        pair = (float(value), 0.0)
+    else:
+        raise RecurrenceTemplateError(
+            f"{context} must be a real or complex binary64 value"
+        )
+    if not all(math.isfinite(component) for component in pair):
+        raise RecurrenceTemplateError(f"{context} must be finite")
+    return ExactComplexRationalV1.from_binary64(*pair)
+
+
+def _multiply_exact(
+    left: ExactComplexRationalV1,
+    right: ExactComplexRationalV1,
+) -> ExactComplexRationalV1:
+    real = left.real * right.real - left.imag * right.imag
+    imag = left.real * right.imag + left.imag * right.real
+    return ExactComplexRationalV1.from_fractions(real, imag)
+
+
+def _validate_prepared_catalog_identity(
+    model: Model,
+    prepared_catalog: PreparedKernelCatalog,
+) -> None:
+    model_name = getattr(model, "name", None)
+    if not isinstance(model_name, str) or not model_name:
+        raise RecurrenceTemplateError("recurrence model name must be nonempty")
+    if getattr(prepared_catalog, "model_name", None) != model_name:
+        raise PreparedKernelCatalogError(
+            "prepared kernel catalog model identity does not match the recurrence "
+            f"model: {getattr(prepared_catalog, 'model_name', None)!r} != "
+            f"{model_name!r}"
+        )
+    gaps = tuple(getattr(prepared_catalog, "unsupported_variants", ()))
+    if gaps:
+        details = "; ".join(
+            f"{gap.contract_kind}:{gap.context}:{gap.reason}" for gap in gaps
+        )
+        raise PreparedKernelCatalogError(
+            "prepared kernel catalog has unsupported recurrence semantics: " + details
+        )
+
+
+def _validated_kernels(
+    prepared_catalog: PreparedKernelCatalog,
+) -> Mapping[int, Any]:
+    kernels = tuple(getattr(prepared_catalog, "kernels", ()))
+    expected_ids = tuple(range(len(kernels)))
+    actual_ids = tuple(getattr(kernel, "kernel_id", None) for kernel in kernels)
+    if actual_ids != expected_ids:
+        raise PreparedKernelCatalogError(
+            "prepared kernel IDs must be contiguous before recurrence catalog build"
+        )
+    by_id: dict[int, Any] = {}
+    signatures: list[str] = []
+    for kernel in kernels:
+        payload = {
+            "abi": _PREPARED_CATALOG_ABI,
+            "contract_kind": kernel.contract_kind,
+            "inputs": [item.to_dict() for item in kernel.inputs],
+            "outputs": list(kernel.exact_expressions),
+            "output_layout": list(kernel.output_layout),
+        }
+        expected = _digest(payload)
+        if kernel.canonical_signature != expected:
+            raise PreparedKernelCatalogError(
+                f"prepared kernel {kernel.kernel_id} has a stale canonical signature"
+            )
+        if len(kernel.exact_expressions) != len(kernel.output_layout):
+            raise PreparedKernelCatalogError(
+                f"prepared kernel {kernel.kernel_id} has misaligned outputs"
+            )
+        by_id[int(kernel.kernel_id)] = kernel
+        signatures.append(str(kernel.canonical_signature))
+    if tuple(signatures) != tuple(sorted(signatures)) or len(set(signatures)) != len(
+        signatures
+    ):
+        raise PreparedKernelCatalogError(
+            "prepared kernel signatures must be sorted and unique"
+        )
+    return by_id
+
+
+def _collect_prepared_states(
+    prepared_catalog: PreparedKernelCatalog,
+) -> tuple[PreparedParticleState, ...]:
+    states: dict[tuple[int, int], PreparedParticleState] = {}
+    bindings: Sequence[Any] = (
+        *prepared_catalog.vertex_bindings,
+        *prepared_catalog.propagator_bindings,
+        *prepared_catalog.closure_bindings,
+    )
+    for binding in bindings:
+        candidates = tuple(
+            state
+            for name in ("left_state", "right_state", "result_state", "state")
+            for state in (getattr(binding, name, None),)
+            if state is not None
+        )
+        for state in candidates:
+            key = (int(state.particle_id), int(state.chirality))
+            previous = states.setdefault(key, state)
+            if previous != state:
+                raise PreparedKernelCatalogError(
+                    "prepared bindings disagree on current-state semantics for "
+                    f"particle={key[0]}, chirality={key[1]}"
+                )
+    return tuple(states[key] for key in sorted(states))
+
+
+def _recurrence_prepared_catalog(
+    model: Model,
+    prepared_catalog: PreparedKernelCatalog,
+) -> PreparedKernelCatalog:
+    """Return the process-independent subset admitted by recurrence semantics.
+
+    Prepared catalogs intentionally retain every exact model kernel useful to
+    eager execution, including UFO ghost-interaction kernels.  Tree-level
+    recurrence execution has no ghost source/current contract in v1.  Filter
+    such bindings from the recurrence companion using the typed model source
+    contract, without changing the prepared catalog or recognizing a model by
+    name, particle ID, or Python implementation type.
+
+    A future model that gives ghosts explicit recurrence semantics can extend
+    the public source/runtime template ABI.  Until then, a process whose only
+    construction needs an excluded binding will fail during process lowering
+    because the semantic transition is absent; no unsupported identity is
+    silently introduced.
+    """
+
+    states = _collect_prepared_states(prepared_catalog)
+    admitted = {
+        (state.particle_id, state.chirality)
+        for state in states
+        if _state_is_admitted_by_recurrence(model, state)
+    }
+
+    def state_key(state: PreparedParticleState) -> tuple[int, int]:
+        return int(state.particle_id), int(state.chirality)
+
+    vertex_bindings = tuple(
+        binding
+        for binding in prepared_catalog.vertex_bindings
+        if all(
+            state_key(state) in admitted
+            for state in (
+                binding.left_state,
+                binding.right_state,
+                binding.result_state,
+            )
+        )
+    )
+    propagator_bindings = tuple(
+        binding
+        for binding in prepared_catalog.propagator_bindings
+        if state_key(binding.state) in admitted
+    )
+    closure_bindings = tuple(
+        binding
+        for binding in prepared_catalog.closure_bindings
+        if all(
+            state_key(state) in admitted
+            for state in (
+                binding.left_state,
+                binding.right_state,
+                binding.result_state,
+            )
+        )
+    )
+    return PreparedKernelCatalog(
+        model_name=prepared_catalog.model_name,
+        kernels=prepared_catalog.kernels,
+        vertex_bindings=vertex_bindings,
+        propagator_bindings=propagator_bindings,
+        closure_bindings=closure_bindings,
+        model_parameter_kernel_id=prepared_catalog.model_parameter_kernel_id,
+        unsupported_variants=prepared_catalog.unsupported_variants,
+    )
+
+
+def _state_is_admitted_by_recurrence(
+    model: Model,
+    state: PreparedParticleState,
+) -> bool:
+    if model.auxiliary_kind(state.particle_id) is not None:
+        return True
+    wavefunction_family = _stable_callback(
+        f"wavefunction family for particle {state.particle_id}",
+        lambda: model.source_wavefunction_kind(state.particle_id),
+        serializer=str,
+    )
+    if wavefunction_family == "ghost":
+        return False
+    if (
+        _effective_auxiliary_kind(
+            model,
+            state.particle_id,
+            state.chirality,
+        )
+        is not None
+    ):
+        return True
+    source_ir = _stable_callback(
+        f"source contract for particle {state.particle_id}",
+        lambda: model._source_ir(state.particle_id),
+        serializer=_canonical_source_ir,
+    )
+    if source_ir.statistics == "ghost" or source_ir.wavefunction_family == "ghost":
+        return False
+    if source_ir.statistics not in {"boson", "fermion", "auxiliary"}:
+        raise RecurrenceTemplateError(
+            "recurrence-template-v1 cannot classify source statistics "
+            f"{source_ir.statistics!r} for particle={state.particle_id}"
+        )
+    # Require the corresponding finalization contract now.  This keeps missing
+    # physical-state semantics distinct from deliberately unsupported ghosts.
+    _stable_callback(
+        f"propagator contract for particle {state.particle_id}",
+        lambda: model._propagator_ir(state.particle_id, state.chirality),
+        serializer=lambda value: _canonical_json(value.to_json_dict()),
+    )
+    return True
+
+
+def _build_parameters(
+    model: Model,
+    prepared_catalog: PreparedKernelCatalog,
+    prepared_states: Sequence[PreparedParticleState],
+) -> tuple[ParameterTemplateV1, ...]:
+    defaults: dict[str, ExactComplexRationalV1] = {}
+    kinds: dict[str, str] = {}
+    value_types: dict[str, str] = {}
+    prepared_parameter_ids: dict[str, int] = {}
+
+    for kernel in prepared_catalog.kernels:
+        for item in kernel.inputs:
+            if item.model_parameter_name is None:
+                continue
+            if item.model_parameter_index is None:
+                raise RecurrenceTemplateError(
+                    "prepared model-parameter input lacks its stable index"
+                )
+            name = str(item.model_parameter_name)
+            index = int(item.model_parameter_index)
+            previous = prepared_parameter_ids.setdefault(name, index)
+            if previous != index:
+                raise RecurrenceTemplateError(
+                    f"prepared model parameter {name!r} has conflicting indices"
+                )
+    names_by_prepared_id: dict[int, str] = {}
+    for name, index in prepared_parameter_ids.items():
+        previous = names_by_prepared_id.setdefault(index, name)
+        if previous != name:
+            raise RecurrenceTemplateError(
+                f"prepared parameter index {index} names both {previous!r} and {name!r}"
+            )
+
+    def add_default(name: object, value: object, *, kind: str) -> None:
+        parameter_name = str(name)
+        exact = _exact_pair(value, f"model parameter {parameter_name!r} default")
+        previous = defaults.setdefault(parameter_name, exact)
+        if previous != exact:
+            raise RecurrenceTemplateError(
+                f"model parameter {parameter_name!r} has conflicting defaults"
+            )
+        kinds.setdefault(parameter_name, kind)
+        value_types.setdefault(
+            parameter_name,
+            "real" if exact.imag_numerator == 0 else "complex",
+        )
+
+    defaults_provider = getattr(model, "runtime_parameter_defaults", None)
+    if callable(defaults_provider):
+        first = dict(defaults_provider())
+        second = dict(defaults_provider())
+        if _canonical_binary64_mapping(first) != _canonical_binary64_mapping(second):
+            raise RecurrenceTemplateError(
+                "runtime_parameter_defaults is nondeterministic"
+            )
+        for name, value in first.items():
+            add_default(name, value, kind="external")
+            type_provider = getattr(model, "runtime_parameter_type", None)
+            if callable(type_provider):
+                declared = str(type_provider(str(name))).lower()
+                if declared not in {"real", "complex"}:
+                    raise RecurrenceTemplateError(
+                        f"unsupported parameter type {declared!r} for {name!r}"
+                    )
+                value_types[str(name)] = declared
+
+    normalization_provider = getattr(
+        model, "runtime_normalization_parameter_defaults", None
+    )
+    if callable(normalization_provider):
+        first = dict(normalization_provider())
+        second = dict(normalization_provider())
+        if _canonical_binary64_mapping(first) != _canonical_binary64_mapping(second):
+            raise RecurrenceTemplateError(
+                "runtime_normalization_parameter_defaults is nondeterministic"
+            )
+        for name, value in first.items():
+            add_default(name, value, kind="external")
+
+    definitions_provider = getattr(model, "runtime_derived_parameter_definitions", None)
+    definitions = (
+        {str(name): str(value) for name, value in definitions_provider().items()}
+        if callable(definitions_provider)
+        else {}
+    )
+    if callable(definitions_provider):
+        repeated = {
+            str(name): str(value) for name, value in definitions_provider().items()
+        }
+        if definitions != repeated:
+            raise RecurrenceTemplateError(
+                "runtime_derived_parameter_definitions is nondeterministic"
+            )
+
+    required_names = {
+        str(item.model_parameter_name)
+        for kernel in prepared_catalog.kernels
+        for item in kernel.inputs
+        if item.model_parameter_name is not None
+    }
+    required_names.update(
+        str(name)
+        for binding in prepared_catalog.propagator_bindings
+        for name in binding.model_parameters
+    )
+    for state in prepared_states:
+        if (
+            _effective_auxiliary_kind(model, state.particle_id, state.chirality)
+            is not None
+        ):
+            continue
+        source_ir = _stable_callback(
+            f"source contract for particle {state.particle_id}",
+            lambda state=state: model._source_ir(state.particle_id),
+            serializer=lambda value: _canonical_source_ir(value),
+        )
+        for name in (source_ir.mass_parameter, source_ir.width_parameter):
+            if name is not None:
+                required_names.add(str(name))
+        if (
+            source_ir.mass_parameter is not None
+            and source_ir.mass_parameter not in defaults
+            and source_ir.mass_parameter not in definitions
+        ):
+            add_default(
+                source_ir.mass_parameter,
+                model.mass(state.particle_id),
+                kind="external",
+            )
+        if (
+            source_ir.width_parameter is not None
+            and source_ir.width_parameter not in defaults
+            and source_ir.width_parameter not in definitions
+        ):
+            add_default(
+                source_ir.width_parameter,
+                model.width(state.particle_id),
+                kind="external",
+            )
+
+        # Match the model-generic fallback naming contract used by the
+        # prepared-kernel builder when a model does not expose named particle
+        # parameters itself.
+        particle = model.particle(state.particle_id)
+        fallback_values = {
+            f"particle.{int(particle.pdg)}.mass": model.mass(state.particle_id),
+            f"particle.{int(particle.pdg)}.width": model.width(state.particle_id),
+        }
+        for name, value in fallback_values.items():
+            if (
+                name in required_names
+                and name not in defaults
+                and name not in definitions
+            ):
+                add_default(name, value, kind="external")
+
+    derived_defaults_provider = getattr(
+        model, "runtime_derived_parameter_defaults", None
+    )
+    derived_defaults = (
+        dict(derived_defaults_provider()) if callable(derived_defaults_provider) else {}
+    )
+    for name, value in derived_defaults.items():
+        add_default(name, value, kind="derived")
+
+    missing = sorted(required_names - defaults.keys() - definitions.keys())
+    if missing:
+        raise RecurrenceTemplateError(
+            "recurrence catalog cannot resolve defaults or exact definitions for "
+            "prepared model parameters: " + ", ".join(missing)
+        )
+
+    all_names = tuple(sorted(defaults.keys() | definitions.keys()))
+    # Prepared kernels only retain model-parameter descriptors that survive
+    # exact expression simplification.  A restricted mass such as UFO ``Me``
+    # can therefore be absent from every kernel input while still being
+    # required by SourceIR at runtime.  Recurrence owns a parameter workspace
+    # with one slot per catalog parameter, so bind every otherwise-unbound
+    # required parameter to a deterministic free slot.  Existing kernel input
+    # indices remain authoritative.
+    occupied_prepared_ids = set(prepared_parameter_ids.values())
+    free_prepared_ids = iter(
+        index for index in range(len(all_names)) if index not in occupied_prepared_ids
+    )
+    for name in sorted(required_names):
+        if name in prepared_parameter_ids:
+            continue
+        try:
+            prepared_parameter_ids[name] = next(free_prepared_ids)
+        except StopIteration as exc:  # pragma: no cover - guarded by cardinality
+            raise RecurrenceTemplateError(
+                "recurrence catalog has no free prepared slot for required "
+                f"model parameter {name!r}"
+            ) from exc
+
+    ids = {name: _token("parameter", {"name": name}) for name in all_names}
+    external_ids = tuple(
+        sorted(ids[name] for name in all_names if name not in definitions)
+    )
+    records: list[ParameterTemplateV1] = []
+    for name in all_names:
+        derived = name in definitions
+        default = defaults.get(name)
+        declared = value_types.get(
+            name,
+            "complex"
+            if default is not None and default.imag_numerator != 0
+            else "real",
+        )
+        if declared == "real" and default is not None and default.imag_numerator != 0:
+            raise RecurrenceTemplateError(
+                f"real model parameter {name!r} has a complex default"
+            )
+        records.append(
+            ParameterTemplateV1(
+                template_id=ids[name],
+                name=name,
+                parameter_kind="derived" if derived else "external",
+                value_type=declared,  # type: ignore[arg-type]
+                mutable=not derived,
+                default_value=None if derived else default,
+                exact_expression_digest=(
+                    _expression_digest(definitions[name]) if derived else None
+                ),
+                # A superset is conservative and avoids parsing model syntax as
+                # proof. Rust may use the evaluator's actual input layout.
+                dependency_parameter_ids=external_ids if derived else (),
+                prepared_parameter_id=prepared_parameter_ids.get(name),
+            )
+        )
+    return tuple(records)
+
+
+def _canonical_binary64_mapping(values: Mapping[object, object]) -> str:
+    return _canonical_json(
+        {
+            str(name): _exact_pair(value, f"parameter {name!r}").to_dict()
+            for name, value in values.items()
+        }
+    )
+
+
+def _build_current_states(
+    model: Model,
+    prepared_states: Sequence[PreparedParticleState],
+    parameter_ids: Mapping[str, str],
+) -> tuple[CurrentStateTemplateV1, ...]:
+    records: list[CurrentStateTemplateV1] = []
+    for state in prepared_states:
+        auxiliary_kind = _effective_auxiliary_kind(
+            model, state.particle_id, state.chirality
+        )
+        if auxiliary_kind is None:
+            source_ir = _stable_callback(
+                f"source contract for particle {state.particle_id}",
+                lambda state=state: model._source_ir(state.particle_id),
+                serializer=lambda value: _canonical_source_ir(value),
+            )
+            identity = source_ir.identity
+            basis = model._current_basis(state.particle_id, state.chirality)
+            statistics = source_ir.statistics
+            mass_parameter = source_ir.mass_parameter
+            width_parameter = source_ir.width_parameter
+        else:
+            identity = _stable_callback(
+                f"auxiliary identity for particle {state.particle_id}",
+                lambda state=state: model._particle_identity_ir(state.particle_id),
+                serializer=lambda value: _canonical_json(value.to_json_dict()),
+            )
+            basis = model._current_basis(state.particle_id, state.chirality)
+            statistics = "fermion" if model.is_fermion(state.particle_id) else "boson"
+            propagator = model._propagator_ir(state.particle_id, state.chirality)
+            mass_parameter = propagator.mass_parameter
+            width_parameter = propagator.width_parameter
+        if (
+            identity.canonical_id != state.identity
+            or identity.orientation != state.orientation
+            or basis != state.basis
+            or int(model.current_dimension(state.particle_id, state.chirality))
+            != state.dimension
+        ):
+            raise PreparedKernelCatalogError(
+                "prepared current-state metadata does not match the live model "
+                f"contract for particle={state.particle_id}, "
+                f"chirality={state.chirality}"
+            )
+        if statistics == "ghost":
+            raise RecurrenceTemplateError(
+                f"recurrence-template-v1 cannot encode ghost current {state.identity!r}"
+            )
+        public_statistics = "fermion" if statistics == "fermion" else "boson"
+        mass_parameter = _runtime_particle_parameter_name(
+            mass_parameter,
+            particle_pdg=int(model.particle(state.particle_id).pdg),
+            kind="mass",
+            available_names=parameter_ids,
+        )
+        mass_id = _parameter_reference(
+            mass_parameter, parameter_ids, "current mass parameter"
+        )
+        width_id = _parameter_reference(
+            width_parameter, parameter_ids, "current width parameter"
+        )
+        records.append(
+            CurrentStateTemplateV1(
+                template_id=_state_template_id(state),
+                particle_id=state.particle_id,
+                anti_particle_id=identity.anti_pdg_label,
+                species_id=identity.species_id,
+                orientation=state.orientation,
+                statistics=public_statistics,
+                color_representation=int(model.color_rep(state.particle_id)),
+                basis=state.basis,
+                tensor_ordering=tuple(
+                    f"{state.basis}:c{component}"
+                    for component in range(state.dimension)
+                ),
+                dimension=state.dimension,
+                chirality=state.chirality,
+                lc_color_shape_kind=model.recurrence_lc_color_shape_contract(
+                    state.particle_id,
+                    state.chirality,
+                ),
+                auxiliary_kind=(
+                    None if auxiliary_kind is None else str(auxiliary_kind)
+                ),
+                mass_parameter_id=mass_id,
+                width_parameter_id=width_id,
+            )
+        )
+    return tuple(records)
+
+
+def _state_template_id(state: PreparedParticleState) -> str:
+    return _token(
+        "state",
+        {
+            "particle_id": state.particle_id,
+            "identity": state.identity,
+            "orientation": state.orientation,
+            "basis": state.basis,
+            "chirality": state.chirality,
+            "dimension": state.dimension,
+        },
+    )
+
+
+def _parameter_reference(
+    name: str | None,
+    parameter_ids: Mapping[str, str],
+    context: str,
+) -> str | None:
+    if name is None:
+        return None
+    try:
+        return parameter_ids[str(name)]
+    except KeyError as exc:
+        raise RecurrenceTemplateError(
+            f"{context} {name!r} is absent from the recurrence parameter catalog"
+        ) from exc
+
+
+def _build_sources(
+    model: Model,
+    prepared_states: Sequence[PreparedParticleState],
+    state_ids: Mapping[tuple[int, int], str],
+    parameter_ids: Mapping[str, str],
+) -> tuple[tuple[SourceTemplateV1, ...], tuple[EvaluatorBindingV1, ...]]:
+    records: list[SourceTemplateV1] = []
+    bindings: list[EvaluatorBindingV1] = []
+    for prepared_state in prepared_states:
+        if (
+            _effective_auxiliary_kind(
+                model,
+                prepared_state.particle_id,
+                prepared_state.chirality,
+            )
+            is not None
+        ):
+            continue
+        source_ir = model._source_ir(prepared_state.particle_id)
+        mass_parameter = _runtime_particle_parameter_name(
+            source_ir.mass_parameter,
+            particle_pdg=int(model.particle(prepared_state.particle_id).pdg),
+            kind="mass",
+            available_names=parameter_ids,
+        )
+        states = tuple(
+            state
+            for state in source_ir.states
+            if int(state.chirality) == prepared_state.chirality
+        )
+        if not states:
+            # Full internal fermion states may coexist with chiral external
+            # source states. They are recurrence currents, not source-fill
+            # entry points.
+            continue
+        for state in states:
+            if not isinstance(state.spin_state, int) or isinstance(
+                state.spin_state, bool
+            ):
+                raise RecurrenceTemplateError(
+                    "recurrence-template-v1 cannot encode structured source spin "
+                    f"state {state.spin_state!r}"
+                )
+            state_key = (
+                prepared_state.particle_id,
+                prepared_state.chirality,
+            )
+            flavour_flow = (int(prepared_state.particle_id),)
+            quantum_number_flow = _stable_callback(
+                f"source quantum-number flow for particle {prepared_state.particle_id}",
+                lambda prepared_state=prepared_state: model.quantum_number_flow(
+                    prepared_state.particle_id
+                ),
+                serializer=lambda value: _canonical_json(list(value)),
+            )
+            canonical_quantum_number_flow = tuple(
+                (str(name), str(expression)) for name, expression in quantum_number_flow
+            )
+            mass_parameter_id = _parameter_reference(
+                mass_parameter,
+                parameter_ids,
+                "source mass parameter",
+            )
+            width_parameter_id = _parameter_reference(
+                source_ir.width_parameter,
+                parameter_ids,
+                "source width parameter",
+            )
+            lc_color_seed = _source_color_seed(
+                model,
+                prepared_state.particle_id,
+                prepared_state.chirality,
+                state_template_id=state_ids[state_key],
+            )
+            source_semantics = {
+                "abi": "rusticol-source-fill-v1",
+                "state": state_ids[state_key],
+                "statistics": source_ir.statistics,
+                "wavefunction_family": source_ir.wavefunction_family,
+                "basis": source_ir.basis,
+                "dimension": prepared_state.dimension,
+                "crossing": _canonical_crossing(source_ir.crossing),
+                "helicity": int(state.helicity),
+                "chirality": int(state.chirality),
+                "spin_state": int(state.spin_state),
+                "flavour_flow": list(flavour_flow),
+                "quantum_number_flow": [
+                    list(item) for item in canonical_quantum_number_flow
+                ],
+                "lc_color_seed": lc_color_seed.to_dict(),
+                "mass_parameter_id": mass_parameter_id,
+                "width_parameter_id": width_parameter_id,
+            }
+            callable_signature = _digest(source_semantics)
+            runtime_template = (
+                f"rusticol.source-fill.{source_ir.wavefunction_family}.v1:"
+                f"{callable_signature[:24]}"
+            )
+            template_id = _token(
+                "source",
+                source_semantics,
+            )
+            resolver_key = _token("evaluator", source_semantics)
+            record = SourceTemplateV1(
+                template_id=template_id,
+                state_template_id=state_ids[state_key],
+                crossing=_canonical_crossing(source_ir.crossing),
+                wavefunction_family=source_ir.wavefunction_family,
+                helicity=int(state.helicity),
+                spin_state=int(state.spin_state),
+                flavour_flow=flavour_flow,
+                quantum_number_flow=canonical_quantum_number_flow,
+                lc_color_seed=lc_color_seed,
+                wavefunction_expression_digest=callable_signature,
+                evaluator_resolver_key=resolver_key,
+                mass_parameter_id=mass_parameter_id,
+                width_parameter_id=width_parameter_id,
+            )
+            records.append(record)
+            input_layout = (
+                "momentum:energy",
+                "momentum:px",
+                "momentum:py",
+                "momentum:pz",
+                *(() if mass_parameter_id is None else (mass_parameter_id,)),
+                *(() if width_parameter_id is None else (width_parameter_id,)),
+            )
+            output_layout = tuple(
+                f"source-component:{component}"
+                for component in range(prepared_state.dimension)
+            )
+            bindings.append(
+                EvaluatorBindingV1(
+                    resolver_key=resolver_key,
+                    prepared_kernel_id=None,
+                    callable_kind="rusticol-template",
+                    runtime_template=runtime_template,
+                    contract_kind="source",
+                    callable_signature=callable_signature,
+                    input_state_template_ids=(),
+                    output_state_template_id=record.state_template_id,
+                    input_layout=input_layout,
+                    output_layout=output_layout,
+                    exact_expression_digests=tuple(
+                        _digest({"source": source_semantics, "component": component})
+                        for component in range(prepared_state.dimension)
+                    ),
+                    semantic_template_ids=(record.template_id,),
+                )
+            )
+    return tuple(records), tuple(bindings)
+
+
+def _build_runtime_helicity_contracts(
+    model: Model,
+    prepared_catalog: PreparedKernelCatalog,
+    current_states: Sequence[CurrentStateTemplateV1],
+    sources: Sequence[SourceTemplateV1],
+) -> tuple[RecurrenceRuntimeHelicityContractV1, ...]:
+    """Certify source families that can execute through one full current state.
+
+    Incomplete families are deliberately absent.  Topology replay continues to
+    consume their concrete source states, while all-flow union calls the catalog
+    preflight and fails before lowering instead of guessing an embedding.
+    """
+
+    states_by_id = {state.template_id: state for state in current_states}
+    states_by_particle_chirality = {
+        (state.particle_id, state.chirality): state for state in current_states
+    }
+    source_families: dict[int, list[SourceTemplateV1]] = {}
+    for source in sources:
+        state = states_by_id[source.state_template_id]
+        source_families.setdefault(state.particle_id, []).append(source)
+
+    contracts: list[RecurrenceRuntimeHelicityContractV1] = []
+    for particle_id in sorted(source_families):
+        family = tuple(
+            sorted(source_families[particle_id], key=lambda item: item.template_id)
+        )
+        source_states = tuple(states_by_id[item.state_template_id] for item in family)
+        unique_state_ids = {state.template_id for state in source_states}
+        full_state = states_by_particle_chirality.get((particle_id, 0))
+        if full_state is None and len(unique_state_ids) == 1:
+            full_state = source_states[0]
+        if full_state is None:
+            continue
+
+        variants: list[RecurrenceRuntimeHelicityVariantV1] = []
+        proof_inputs: list[object] = []
+        complete = True
+        for source, source_state in zip(family, source_states, strict=True):
+            if source_state.template_id == full_state.template_id:
+                embedding = tuple(range(full_state.dimension))
+                projection = tuple(range(full_state.dimension))
+                ordering_proof: object = {
+                    "kind": "identity",
+                    "state_digest": full_state.semantic_digest,
+                }
+            else:
+                try:
+                    ordering = model.recurrence_current_embedding_contract(
+                        source_state.particle_id,
+                        source_state.chirality,
+                    )
+                except NotImplementedError:
+                    complete = False
+                    break
+                embedding = tuple(ordering.input_embedding)
+                projection = tuple(ordering.source_projection)
+                if (
+                    len(embedding) != full_state.dimension
+                    or len(projection) != source_state.dimension
+                    or ordering.source_dimension != source_state.dimension
+                    or ordering.full_dimension != full_state.dimension
+                    or ordering.source_basis != source_state.basis
+                    or ordering.full_basis != full_state.basis
+                ):
+                    complete = False
+                    break
+                ordering_proof = ordering.to_json_dict()
+            if not _prepared_full_state_family_is_complete(
+                prepared_catalog,
+                particle_id=particle_id,
+                source_state=source_state,
+                full_state_template=full_state,
+                states_by_particle_chirality=states_by_particle_chirality,
+            ):
+                complete = False
+                break
+            factors = tuple(
+                ExactComplexRationalV1.zero()
+                if component is None
+                else ExactComplexRationalV1.one()
+                for component in embedding
+            )
+            proof_payload = {
+                "abi": "pyamplicol-recurrence-runtime-helicity-variant-v1",
+                "full_state": full_state.semantic_digest,
+                "ordering": ordering_proof,
+                "source": source.semantic_digest,
+                "source_state": source_state.semantic_digest,
+            }
+            proof_digest = _digest(proof_payload)
+            proof_inputs.append(proof_payload)
+            variants.append(
+                RecurrenceRuntimeHelicityVariantV1(
+                    source_template_id=source.template_id,
+                    source_state_template_id=source_state.template_id,
+                    embedding_source_components=embedding,
+                    embedding_factors=factors,
+                    projection_full_components=projection,
+                    proof_digest=proof_digest,
+                )
+            )
+        if not complete or len(variants) != len(family):
+            continue
+        proof_payload = {
+            "abi": "pyamplicol-recurrence-runtime-helicity-contract-v1",
+            "full_state": full_state.semantic_digest,
+            "variants": proof_inputs,
+        }
+        contracts.append(
+            RecurrenceRuntimeHelicityContractV1(
+                template_id=_token("runtime-helicity", proof_payload),
+                full_state_template_id=full_state.template_id,
+                variants=tuple(variants),
+                proof_algorithm=(
+                    "prepared-current-ordering-runtime-helicity-embedding-v1"
+                ),
+                proof_digest=_digest(proof_payload),
+            )
+        )
+    return tuple(contracts)
+
+
+def _prepared_full_state_family_is_complete(
+    prepared_catalog: PreparedKernelCatalog,
+    *,
+    particle_id: int,
+    source_state: CurrentStateTemplateV1,
+    full_state_template: CurrentStateTemplateV1,
+    states_by_particle_chirality: Mapping[tuple[int, int], CurrentStateTemplateV1],
+) -> bool:
+    if source_state.template_id == full_state_template.template_id:
+        return True
+    full_prepared_state = next(
+        (
+            binding.state
+            for binding in prepared_catalog.propagator_bindings
+            if binding.state.particle_id == particle_id
+            and binding.state.chirality == full_state_template.chirality
+        ),
+        None,
+    )
+    if full_prepared_state is None:
+        return False
+
+    def full_state(state: PreparedParticleState) -> PreparedParticleState | None:
+        template = states_by_particle_chirality.get((state.particle_id, 0))
+        if template is None:
+            return state if state.chirality == 0 else None
+        return next(
+            (
+                candidate.state
+                for candidate in prepared_catalog.propagator_bindings
+                if candidate.state.particle_id == state.particle_id
+                and candidate.state.chirality == template.chirality
+            ),
+            None,
+        )
+
+    vertex_inventory = {
+        (
+            binding.key.kind,
+            binding.key.particles,
+            full_state(binding.left_state),
+            full_state(binding.right_state),
+            full_state(binding.result_state),
+        )
+        for binding in prepared_catalog.vertex_bindings
+        if all(
+            full_state(state) == state
+            for state in (binding.left_state, binding.right_state, binding.result_state)
+        )
+    }
+    closure_inventory = {
+        (
+            binding.key.kind,
+            binding.key.particles,
+            full_state(binding.left_state),
+            full_state(binding.right_state),
+            full_state(binding.result_state),
+        )
+        for binding in prepared_catalog.closure_bindings
+        if all(
+            full_state(state) == state
+            for state in (binding.left_state, binding.right_state, binding.result_state)
+        )
+    }
+    for bindings, inventory in (
+        (prepared_catalog.vertex_bindings, vertex_inventory),
+        (prepared_catalog.closure_bindings, closure_inventory),
+    ):
+        for binding in bindings:
+            states = (binding.left_state, binding.right_state, binding.result_state)
+            if not any(
+                state.particle_id == particle_id
+                and state.chirality == source_state.chirality
+                for state in states
+            ):
+                continue
+            mapped = tuple(full_state(state) for state in states)
+            if any(state is None for state in mapped):
+                return False
+            key = (binding.key.kind, binding.key.particles, *mapped)
+            if key not in inventory:
+                return False
+    return True
+
+
+def _source_color_seed(
+    model: Model,
+    particle_id: int,
+    chirality: int,
+    *,
+    state_template_id: str,
+) -> LCColorSourceSeedV1:
+    model_type = type(model)
+    mro = model_type.__mro__
+    shape_owner = next(
+        owner for owner in mro if "recurrence_lc_color_shape_contract" in owner.__dict__
+    )
+    seed_owner = next(
+        owner
+        for owner in mro
+        if "recurrence_lc_source_color_contract" in owner.__dict__
+    )
+    if mro.index(seed_owner) > mro.index(shape_owner):
+        raise RecurrenceTemplateError(
+            f"{model_type.__name__}.recurrence_lc_color_shape_contract overrides "
+            "the LC source shape without declaring a matching source-color seed "
+            "contract"
+        )
+
+    def evaluate() -> Any:
+        return model.recurrence_lc_source_color_contract(particle_id, chirality)
+
+    contract = _stable_callback(
+        f"LC source-color seed for particle {particle_id} chirality {chirality}",
+        evaluate,
+        serializer=lambda value: _canonical_json(
+            {
+                "operation": value.operation,
+                "output_shape_kind": value.output_shape_kind,
+                "component_kind": value.component_kind,
+                "component_role": value.component_role,
+                "proof_digest": value.proof_digest,
+                "provenance": list(value.provenance),
+            }
+        ),
+    )
+    expected_shape = model.recurrence_lc_color_shape_contract(particle_id, chirality)
+    if contract.output_shape_kind != expected_shape:
+        raise RecurrenceTemplateError(
+            "LC source-color seed output shape does not match its current-state "
+            f"contract: {contract.output_shape_kind!r} != {expected_shape!r}"
+        )
+    payload = {
+        "abi": "pyamplicol-recurrence-lc-source-seed-v1",
+        "state_template_id": state_template_id,
+        "particle_id": int(particle_id),
+        "chirality": int(chirality),
+        "operation": contract.operation,
+        "output_shape_kind": contract.output_shape_kind,
+        "component_kind": contract.component_kind,
+        "component_role": contract.component_role,
+        "provenance": [list(item) for item in contract.provenance],
+    }
+    return LCColorSourceSeedV1(
+        operation=contract.operation,
+        output_shape_kind=contract.output_shape_kind,
+        component_kind=contract.component_kind,
+        component_role=contract.component_role,
+        proof_digest=contract.proof_digest or _digest(payload),
+        provenance=contract.provenance,
+    )
+
+
+def _canonical_crossing(crossing: Any) -> str:
+    payload = {
+        "momentum_transform": crossing.momentum_transform,
+        "helicity_factor": int(crossing.helicity_factor),
+        "chirality_factor": int(crossing.chirality_factor),
+        "spin_state_factor": int(crossing.spin_state_factor),
+        "phase": _exact_pair(crossing.phase, "source crossing phase").to_dict(),
+    }
+    return _canonical_json(payload)
+
+
+def _effective_auxiliary_kind(
+    model: Model,
+    particle_id: int,
+    chirality: int,
+) -> str | None:
+    declared = model.auxiliary_kind(particle_id)
+    if declared is not None:
+        return str(declared)
+    particle = model.particle(particle_id)
+    if int(particle.spin) >= 0:
+        return None
+    try:
+        propagator = model._propagator_ir(particle_id, chirality)
+    except Exception as exc:
+        raise RecurrenceTemplateError(
+            "recurrence-template-v1 cannot encode a negative-spin state without "
+            f"an explicit auxiliary/propagator contract: particle={particle_id}, "
+            f"chirality={chirality}: {exc}"
+        ) from exc
+    if not propagator.applies_propagator and propagator.auxiliary_policy:
+        return str(propagator.auxiliary_policy)
+    raise RecurrenceTemplateError(
+        "recurrence-template-v1 cannot encode a negative-spin state without an "
+        f"explicit auxiliary contract: particle={particle_id}, "
+        f"chirality={chirality}"
+    )
+
+
+def _canonical_source_ir(source_ir: Any) -> str:
+    payload = source_ir.to_json_dict()
+    crossing = dict(payload["crossing"])
+    crossing["phase"] = _exact_pair(
+        crossing["phase"], "source crossing phase"
+    ).to_dict()
+    payload["crossing"] = crossing
+    return _canonical_json(payload)
+
+
+def _build_contact_orbit_records(
+    bindings: Sequence[PreparedVertexBinding],
+) -> tuple[
+    tuple[ContactOrbitCertificateV1, ...],
+    tuple[ContactOrbitStepV1, ...],
+    Mapping[object, tuple[ContactOrbitStepV1, ...]],
+]:
+    certificates: dict[str, ContactOrbitCertificateV1] = {}
+    certificate_id_by_term: dict[int, str] = {}
+    steps: dict[str, ContactOrbitStepV1] = {}
+    steps_by_binding: dict[object, tuple[ContactOrbitStepV1, ...]] = {}
+    for binding in bindings:
+        for certificate in binding.contact_orbit_certificates:
+            if certificate.reconstruction_factor != "1":
+                raise RecurrenceTemplateError(
+                    "recurrence v1 supports only exact unit contact-orbit "
+                    "reconstruction"
+                )
+            certificate_id = _token("contact-orbit-certificate", certificate.to_dict())
+            previous_id = certificate_id_by_term.setdefault(
+                certificate.term_id, certificate_id
+            )
+            if previous_id != certificate_id:
+                raise RecurrenceTemplateError(
+                    "contact-orbit term has conflicting certificates"
+                )
+            certificate_record = ContactOrbitCertificateV1(
+                template_id=certificate_id,
+                algorithm=certificate.algorithm,
+                algorithm_version=certificate.algorithm_version,
+                term_id=certificate.term_id,
+                vertex=certificate.vertex,
+                particles=certificate.particles,
+                evaluator_class=certificate.evaluator_class,
+                physical_leg_equivalence_classes=(
+                    certificate.physical_leg_equivalence_classes
+                ),
+                reconstruction_factor=ExactComplexRationalV1.one(),
+            )
+            previous_certificate = certificates.setdefault(
+                certificate_id, certificate_record
+            )
+            if previous_certificate != certificate_record:
+                raise RecurrenceTemplateError(
+                    "contact-orbit certificate identity collision"
+                )
+    for binding in bindings:
+        binding_steps: list[ContactOrbitStepV1] = []
+        for step in binding.contact_orbit_steps:
+            if step.reconstruction_factor != "1":
+                raise RecurrenceTemplateError(
+                    "recurrence v1 supports only exact unit contact-orbit "
+                    "reconstruction"
+                )
+            certificate_id = certificate_id_by_term.get(step.term_id)
+            if certificate_id is None:
+                raise PreparedKernelCatalogError(
+                    "prepared contact-orbit step has no certificate"
+                )
+            step_id = _token(
+                "contact-orbit-step",
+                {
+                    "certificate_template_id": certificate_id,
+                    "step": step.to_dict(),
+                },
+            )
+            step_record = ContactOrbitStepV1(
+                template_id=step_id,
+                certificate_template_id=certificate_id,
+                stage=step.stage,
+                result_leg=step.result_leg,
+                left_covered_legs=step.left_covered_legs,
+                right_covered_legs=step.right_covered_legs,
+                source_particle_legs=step.source_particle_legs,
+                reconstruction_factor=ExactComplexRationalV1.one(),
+            )
+            previous_step = steps.setdefault(step_id, step_record)
+            if previous_step != step_record:
+                raise RecurrenceTemplateError("contact-orbit step identity collision")
+            binding_steps.append(step_record)
+        if binding_steps:
+            steps_by_binding[binding.key] = tuple(
+                sorted(set(binding_steps), key=lambda item: item.template_id)
+            )
+    return (
+        tuple(sorted(certificates.values(), key=lambda item: item.template_id)),
+        tuple(sorted(steps.values(), key=lambda item: item.template_id)),
+        steps_by_binding,
+    )
+
+
+def _canonical_recurrence_vertex_bindings(
+    bindings: Sequence[PreparedVertexBinding],
+) -> tuple[PreparedVertexBinding, ...]:
+    """Drop only compiler-certified mirrored scalar-HEFT tree orientations.
+
+    Recurrence construction indexes an unordered pair of current states and
+    reorders the concrete parents into a transition's evaluator convention.
+    Consequently the two compiler-emitted input orientations of one HEFT tree
+    node are the same recurrence transition.  Keeping both is harmless for the
+    generic DAG backends, which consume the complete oriented kernel catalog,
+    but doubles the contact contribution in recurrence modes because colored
+    mirror currents do not share a dynamic-color identity.
+
+    The filtering is deliberately limited to the exact HEFT evaluator class
+    authenticated by the compiled-model contract.  Every discarded binding
+    must have a retained, state-exact mirror with the source-leg lineage
+    reversed; an unfamiliar or incomplete family fails closed.
+    """
+
+    heft_bindings: list[
+        tuple[
+            PreparedVertexBinding,
+            object,
+            object,
+        ]
+    ] = []
+    retained: list[PreparedVertexBinding] = []
+    for binding in bindings:
+        heft_certificates = tuple(
+            certificate
+            for certificate in binding.contact_orbit_certificates
+            if certificate.evaluator_class == HEFT_CONTACT_ORBIT_EVALUATOR_CLASS
+        )
+        if not heft_certificates:
+            retained.append(binding)
+            continue
+        if (
+            len(heft_certificates) != 1
+            or len(binding.contact_orbit_certificates) != 1
+            or len(binding.contact_orbit_steps) != 1
+        ):
+            raise PreparedKernelCatalogError(
+                "a scalar-HEFT recurrence binding must carry exactly one "
+                "certificate and one tree step"
+            )
+        certificate = heft_certificates[0]
+        step = binding.contact_orbit_steps[0]
+        if step.term_id != certificate.term_id:
+            raise PreparedKernelCatalogError(
+                "a scalar-HEFT recurrence step belongs to another certificate"
+            )
+        heft_bindings.append((binding, certificate, step))
+
+    for binding, certificate, step in heft_bindings:
+        left_key = (step.left_covered_legs, step.source_particle_legs[0])
+        right_key = (step.right_covered_legs, step.source_particle_legs[1])
+        if left_key <= right_key:
+            retained.append(binding)
+            continue
+
+        mirrors = tuple(
+            candidate
+            for candidate, candidate_certificate, candidate_step in heft_bindings
+            if candidate_certificate == certificate
+            and candidate_step.stage == step.stage
+            and candidate_step.result_leg == step.result_leg
+            and candidate_step.left_covered_legs == step.right_covered_legs
+            and candidate_step.right_covered_legs == step.left_covered_legs
+            and candidate_step.source_particle_legs
+            == (
+                step.source_particle_legs[1],
+                step.source_particle_legs[0],
+                step.source_particle_legs[2],
+            )
+            and candidate.left_state == binding.right_state
+            and candidate.right_state == binding.left_state
+            and candidate.result_state == binding.result_state
+            and candidate.key.coupling == binding.key.coupling
+            and candidate.output_factor_source == binding.output_factor_source
+        )
+        if len(mirrors) != 1:
+            raise PreparedKernelCatalogError(
+                "a mirrored scalar-HEFT recurrence binding has no unique "
+                "compiler-certified canonical orientation"
+            )
+        mirror_step = mirrors[0].contact_orbit_steps[0]
+        mirror_left_key = (
+            mirror_step.left_covered_legs,
+            mirror_step.source_particle_legs[0],
+        )
+        mirror_right_key = (
+            mirror_step.right_covered_legs,
+            mirror_step.source_particle_legs[1],
+        )
+        if mirror_left_key > mirror_right_key:
+            raise PreparedKernelCatalogError(
+                "a mirrored scalar-HEFT recurrence binding did not resolve to "
+                "the canonical orientation"
+            )
+
+    return tuple(sorted(retained, key=lambda item: item.key))
+
+
+def _singleton_contact_orbit_step_groups(
+    steps: Sequence[ContactOrbitStepV1],
+) -> tuple[tuple[ContactOrbitStepV1, ...], ...]:
+    """Split certified semantic lineage while preserving one numerical kernel.
+
+    A prepared vertex binding can reuse one exact evaluator for several proven
+    contact-orbit orientations.  Recurrence transitions, however, must name
+    one such orientation apiece so native owner selection never suppresses an
+    unrelated member of a numerically fused binding.  Uncertified bindings
+    retain their single ordinary transition.
+    """
+
+    if not steps:
+        return ((),)
+    return tuple((step,) for step in sorted(steps, key=lambda item: item.template_id))
+
+
+def _build_transitions(
+    model: Model,
+    bindings: Sequence[PreparedVertexBinding],
+    state_ids: Mapping[tuple[int, int], str],
+    parameter_ids: Mapping[str, str],
+    kernels: Mapping[int, Any],
+    evaluator_requests: list[_EvaluatorRequest],
+    contact_orbit_steps_by_binding: Mapping[object, tuple[ContactOrbitStepV1, ...]],
+) -> tuple[
+    tuple[QuantumFlowTemplateV1, ...],
+    tuple[TransitionTemplateV1, ...],
+    tuple[ColorContractionTemplateV1, ...],
+    tuple[SymmetryProofV1, ...],
+]:
+    candidates: list[
+        tuple[
+            str,
+            tuple[int, int, str],
+            TransitionTemplateV1,
+            QuantumFlowTemplateV1,
+            ColorContractionTemplateV1,
+            Any,
+            tuple[str, ...],
+            str,
+            tuple[ExactComplexRationalV1, str] | None,
+        ]
+    ] = []
+    for binding in sorted(bindings, key=lambda item: item.key):
+        contact_orbit_step_groups = _singleton_contact_orbit_step_groups(
+            contact_orbit_steps_by_binding.get(binding.key, ())
+        )
+        vertex = Vertex(
+            binding.key.kind,
+            binding.key.particles,
+            binding.key.coupling,
+        )
+        _validate_vertex_binding_against_model(model, binding, vertex)
+        kernel = _kernel(kernels, binding.kernel_id, "vertex")
+        if kernel.contract_kind != "vertex":
+            raise PreparedKernelCatalogError(
+                f"prepared vertex binding references a {kernel.contract_kind!r} kernel"
+            )
+        concrete_state_ids = (
+            state_ids[(binding.left_state.particle_id, binding.left_state.chirality)],
+            state_ids[(binding.right_state.particle_id, binding.right_state.chirality)],
+        )
+        result_state_id = state_ids[
+            (binding.result_state.particle_id, binding.result_state.chirality)
+        ]
+        _validate_binary_kernel_layout(
+            kernel,
+            binding,
+            output_dimension=binding.result_state.dimension,
+            context=f"vertex kind {binding.key.kind}",
+        )
+        color = _color_template(
+            model,
+            vertex,
+            closure=False,
+            proof_subject=kernel.canonical_signature,
+        )
+        reflection_claim = _current_word_reflection_claim(
+            model,
+            binding,
+            vertex,
+            color,
+        )
+        flow_variants = _probe_quantum_flows(model, vertex, binding)
+        if not flow_variants:
+            raise RecurrenceTemplateError(
+                "prepared vertex binding is not admitted by the live quantum-flow "
+                f"contract: kind={binding.key.kind}, key={binding.key!r}"
+            )
+        coupling_parameters = _kernel_parameter_ids(kernel, parameter_ids)
+        coupling_orders = _canonical_coupling_orders(
+            model.vertex_coupling_orders(vertex),
+            f"vertex kind {vertex.kind} coupling orders",
+        )
+        for variant in flow_variants:
+            flow = _quantum_flow_template(
+                binding,
+                variant,
+                state_ids,
+                coupling_orders,
+            )
+            for contact_orbit_steps in contact_orbit_step_groups:
+                transition_identity = {
+                    "binding": _vertex_binding_payload(binding),
+                    "flow": flow.semantic_digest,
+                    "color": color.semantic_digest,
+                    "kernel": kernel.canonical_signature,
+                }
+                if contact_orbit_steps:
+                    transition_identity["contact_orbit_steps"] = [
+                        step.semantic_digest for step in contact_orbit_steps
+                    ]
+                transition_id = _token("transition", transition_identity)
+                resolver_key = _resolver_key(
+                    kernel,
+                    "vertex",
+                    concrete_state_ids,
+                    result_state_id,
+                )
+                transition = TransitionTemplateV1(
+                    template_id=transition_id,
+                    input_state_template_ids=concrete_state_ids,
+                    result_state_template_id=result_state_id,
+                    quantum_flow_template_id=flow.template_id,
+                    evaluator_resolver_key=resolver_key,
+                    canonical_input_order=tuple(binding.canonical_input_order),
+                    momentum_convention=("incoming-left", "incoming-right"),
+                    coupling_parameter_ids=coupling_parameters,
+                    coupling_orders=coupling_orders,
+                    color_contraction_template_id=color.template_id,
+                    binding_coupling=_exact_pair(
+                        binding.key.coupling,
+                        f"vertex kind {vertex.kind} binding coupling",
+                    ),
+                    exact_factor=_exact_pair(
+                        binding.equivalence_factor,
+                        f"vertex kind {vertex.kind} equivalence factor",
+                    ),
+                    output_factor_source=binding.output_factor_source,
+                    equivalence_class=binding.equivalence_class,
+                    input_exchange_factor=(
+                        None
+                        if binding.input_exchange_factor is None
+                        else _exact_pair(
+                            binding.input_exchange_factor,
+                            f"vertex kind {vertex.kind} input-exchange factor",
+                        )
+                    ),
+                    output_projection=f"{binding.result_state.basis}:chirality={binding.result_state.chirality}",
+                    contact_orbit_step_template_ids=tuple(
+                        step.template_id for step in contact_orbit_steps
+                    ),
+                    contact_orbit_step_semantic_digests=tuple(
+                        step.semantic_digest for step in contact_orbit_steps
+                    ),
+                )
+                candidates.append(
+                    (
+                        _canonical_transition_alias_key(
+                            binding=binding,
+                            kernel=kernel,
+                            flow=flow,
+                            color=color,
+                            transition=transition,
+                        ),
+                        _transition_alias_preference(model, binding, transition),
+                        transition,
+                        flow,
+                        color,
+                        kernel,
+                        concrete_state_ids,
+                        result_state_id,
+                        reflection_claim,
+                    )
+                )
+
+    # Oriented model catalogs may contain exact mirrored aliases.  Collapse only
+    # rows whose complete prepared callable, quantum-flow, color, coupling, and
+    # sign contracts agree after the certified evaluator input permutation.  In
+    # particular, never aggregate alias coefficients: doing so would double a
+    # single physical recurrence contribution.
+    selected: dict[
+        str,
+        tuple[
+            tuple[int, int, str],
+            TransitionTemplateV1,
+            QuantumFlowTemplateV1,
+            ColorContractionTemplateV1,
+            Any,
+            tuple[str, ...],
+            str,
+            tuple[ExactComplexRationalV1, str] | None,
+        ],
+    ] = {}
+    for (
+        alias_key,
+        preference,
+        transition,
+        flow,
+        color,
+        kernel,
+        concrete_state_ids,
+        result_state_id,
+        reflection_claim,
+    ) in candidates:
+        candidate = (
+            preference,
+            transition,
+            flow,
+            color,
+            kernel,
+            concrete_state_ids,
+            result_state_id,
+            reflection_claim,
+        )
+        existing = selected.get(alias_key)
+        if existing is None or preference < existing[0]:
+            selected[alias_key] = candidate
+
+    flows_by_id: dict[str, QuantumFlowTemplateV1] = {}
+    colors: dict[str, ColorContractionTemplateV1] = {}
+    transitions: list[TransitionTemplateV1] = []
+    proofs: list[SymmetryProofV1] = []
+    for alias_key in sorted(selected):
+        (
+            _,
+            transition,
+            flow,
+            color,
+            kernel,
+            concrete_state_ids,
+            result_state_id,
+            reflection_claim,
+        ) = selected[alias_key]
+        flows_by_id.setdefault(flow.template_id, flow)
+        colors.setdefault(color.template_id, color)
+        transitions.append(transition)
+        if reflection_claim is not None:
+            proofs.append(
+                _current_word_reflection_proof(
+                    transition=transition,
+                    kernel=kernel,
+                    phase=reflection_claim[0],
+                    certificate_witness_digest=reflection_claim[1],
+                )
+            )
+        evaluator_requests.append(
+            _EvaluatorRequest(
+                kernel=kernel,
+                contract_kind="vertex",
+                input_state_template_ids=concrete_state_ids,
+                output_state_template_id=result_state_id,
+                semantic_template_id=transition.template_id,
+            )
+        )
+    return (
+        tuple(flows_by_id.values()),
+        tuple(transitions),
+        tuple(colors.values()),
+        tuple(proofs),
+    )
+
+
+def _current_word_reflection_claim(
+    model: Model,
+    binding: PreparedVertexBinding,
+    vertex: Vertex,
+    color: ColorContractionTemplateV1,
+) -> tuple[ExactComplexRationalV1, str] | None:
+    if color.input_representations != (8, 8) or color.output_representation != 8:
+        return None
+    context = f"adjoint-current reflection phase for vertex kind {vertex.kind}"
+
+    def phase_payload(value: object) -> dict[str, str] | None:
+        if value is None:
+            return None
+        return _exact_pair(value, context).to_dict()
+
+    callback_value = _stable_callback(
+        context,
+        lambda: model.adjoint_current_reflection_phase(vertex),
+        serializer=lambda candidate: _canonical_json(phase_payload(candidate)),
+    )
+    callback_phase = (
+        None if callback_value is None else _exact_pair(callback_value, context)
+    )
+    prepared_phase = (
+        None
+        if binding.input_exchange_factor is None
+        else _exact_pair(
+            binding.input_exchange_factor,
+            f"prepared input-exchange factor for vertex kind {vertex.kind}",
+        )
+    )
+    if prepared_phase is not None and binding.left_state != binding.right_state:
+        prepared_phase = None
+    color_claim = _adjoint_color_word_reflection_claim(color)
+    color_phase = None if color_claim is None else color_claim[0]
+    phases = tuple(
+        candidate
+        for candidate in (callback_phase, prepared_phase, color_phase)
+        if candidate is not None
+    )
+    if not phases:
+        return None
+    if any(candidate != phases[0] for candidate in phases[1:]):
+        raise RecurrenceTemplateError(
+            f"{context} has conflicting prepared, model, or color certificates"
+        )
+    phase = phases[0]
+    if phase == ExactComplexRationalV1.zero():
+        raise RecurrenceTemplateError(f"{context} must be nonzero")
+    certificate_payload = {
+        "vertex": {
+            "kind": int(vertex.kind),
+            "particles": [int(particle_id) for particle_id in vertex.particles],
+            "coupling": _exact_pair(
+                vertex.coupling,
+                f"vertex kind {vertex.kind} reflection coupling",
+            ).to_dict(),
+        },
+        "exact_phase": phase.to_dict(),
+        "prepared_input_exchange": (
+            None
+            if prepared_phase is None
+            else {
+                "equivalence_class": str(binding.equivalence_class),
+                "canonical_input_order": [
+                    int(index) for index in binding.canonical_input_order
+                ],
+                "factor": prepared_phase.to_dict(),
+                "left_state": {
+                    "particle_id": int(binding.left_state.particle_id),
+                    "identity": str(binding.left_state.identity),
+                    **binding.left_state.contract_dict(),
+                },
+                "right_state": {
+                    "particle_id": int(binding.right_state.particle_id),
+                    "identity": str(binding.right_state.identity),
+                    **binding.right_state.contract_dict(),
+                },
+            }
+        ),
+        "model_callback": (
+            None
+            if callback_phase is None
+            else {
+                "contract": "adjoint_current_reflection_phase",
+                "factor": callback_phase.to_dict(),
+            }
+        ),
+        "color_word_reversal": (
+            None
+            if color_claim is None
+            else {
+                "factor": color_phase.to_dict(),
+                "witness_digest": color_claim[1],
+            }
+        ),
+    }
+    return phase, _digest(certificate_payload)
+
+
+def _adjoint_color_word_reflection_claim(
+    color: ColorContractionTemplateV1,
+) -> tuple[ExactComplexRationalV1, str] | None:
+    """Prove reversal from paired exact ordered-word color witnesses."""
+
+    if (
+        color.input_representations != (8, 8)
+        or color.output_representation != 8
+        or len(color.transition_witnesses) != 2
+    ):
+        return None
+    by_permutation = {
+        witness.input_permutation: witness for witness in color.transition_witnesses
+    }
+    if set(by_permutation) != {(0, 1), (1, 0)}:
+        return None
+    forward = by_permutation[(0, 1)]
+    reverse = by_permutation[(1, 0)]
+
+    def swap_port(port: tuple[int, int]) -> tuple[int, int]:
+        return (1 - port[0], port[1])
+
+    swapped_pairings = tuple(
+        tuple(swap_port(port) for port in pairing)
+        for pairing in forward.input_port_pairings
+    )
+    swapped_bindings = tuple(swap_port(port) for port in forward.result_port_bindings)
+    swapped_reverse_mask = ((forward.reverse_parent_mask & 1) << 1) | (
+        (forward.reverse_parent_mask & 2) >> 1
+    )
+    if (
+        reverse.input_shape_kinds != forward.input_shape_kinds
+        or reverse.reverse_parent_mask != swapped_reverse_mask
+        or reverse.component_operation != "concatenate-join"
+        or forward.component_operation != "concatenate-join"
+        or reverse.result_component_kind != forward.result_component_kind
+        or reverse.result_component_role != forward.result_component_role
+        or reverse.result_shape_kind != forward.result_shape_kind
+        or reverse.input_port_pairings != swapped_pairings
+        or reverse.result_port_bindings != swapped_bindings
+    ):
+        return None
+
+    one = ExactComplexRationalV1.from_binary64(1.0)
+    minus_one = ExactComplexRationalV1.from_binary64(-1.0)
+    if reverse.exact_factor == forward.exact_factor:
+        phase = one
+    elif reverse.exact_factor == _multiply_exact(forward.exact_factor, minus_one):
+        phase = minus_one
+    else:
+        return None
+    witness = {
+        "proof_algorithm": "paired-adjoint-color-word-reversal-v1",
+        "color_semantic_digest": color.semantic_digest,
+        "forward": forward.to_dict(),
+        "reverse": reverse.to_dict(),
+        "exact_phase": phase.to_dict(),
+    }
+    return phase, _digest(witness)
+
+
+def _current_word_reflection_proof(
+    *,
+    transition: TransitionTemplateV1,
+    kernel: Any,
+    phase: ExactComplexRationalV1,
+    certificate_witness_digest: str,
+) -> SymmetryProofV1:
+    expression_digests = tuple(
+        _expression_digest(expression) for expression in kernel.exact_expressions
+    )
+    witness = {
+        "proof_algorithm": _CURRENT_WORD_REFLECTION_PROOF,
+        "subject_template_id": transition.template_id,
+        "input_permutation": [1, 0],
+        "exact_phase": phase.to_dict(),
+        "prepared_kernel": {
+            "contract_kind": kernel.contract_kind,
+            "canonical_signature": kernel.canonical_signature,
+            "expression_digests": list(expression_digests),
+        },
+        "certificate": {
+            "prepared_input_exchange_or_model_callback": True,
+            "witness_digest": certificate_witness_digest,
+        },
+    }
+    return SymmetryProofV1(
+        template_id=_token("proof", witness),
+        proof_algorithm=_CURRENT_WORD_REFLECTION_PROOF,
+        subject_template_ids=(transition.template_id,),
+        input_permutation=(1, 0),
+        exact_phase=phase,
+        expression_digests=expression_digests,
+        witness_digest=_digest(witness),
+    )
+
+
+def _canonical_transition_alias_key(
+    *,
+    binding: PreparedVertexBinding,
+    kernel: Any,
+    flow: QuantumFlowTemplateV1,
+    color: ColorContractionTemplateV1,
+    transition: TransitionTemplateV1,
+) -> str:
+    """Return an exact, orientation-independent transition proof key."""
+
+    order = tuple(int(value) for value in binding.canonical_input_order)
+    inverse_order = tuple(order.index(index) for index in (0, 1))
+    contribution_factor = _multiply_exact(
+        transition.exact_factor,
+        color.exact_coefficient,
+    )
+
+    def reordered(values: Sequence[Any]) -> list[Any]:
+        return [values[index] for index in order]
+
+    color_witnesses = []
+    for witness in color.transition_witnesses:
+        reverse_parent_mask = 0
+        for concrete_index in range(2):
+            if witness.reverse_parent_mask & (1 << concrete_index):
+                reverse_parent_mask |= 1 << inverse_order[concrete_index]
+        canonical_witness_order = tuple(
+            inverse_order[index] for index in witness.input_permutation
+        )
+        if witness.component_operation == "inherit-left":
+            operation = f"inherit-input-{canonical_witness_order[0]}"
+            operation_order: list[int] = []
+        elif witness.component_operation == "inherit-right":
+            operation = f"inherit-input-{canonical_witness_order[1]}"
+            operation_order = []
+        elif witness.component_operation == "empty":
+            operation = witness.component_operation
+            operation_order = []
+        elif witness.component_operation == "concatenate-keep":
+            operation = witness.component_operation
+            operation_order = list(canonical_witness_order)
+        else:
+            operation = witness.component_operation
+            operation_order = list(canonical_witness_order)
+        color_witnesses.append(
+            {
+                "input_shape_kinds": reordered(witness.input_shape_kinds),
+                "input_permutation": operation_order,
+                "reverse_parent_mask": reverse_parent_mask,
+                "component_operation": operation,
+                "result_component_kind": witness.result_component_kind,
+                "result_component_role": witness.result_component_role,
+                "result_shape_kind": witness.result_shape_kind,
+                # Transition orientation and LC witness signs are one exact
+                # contribution coefficient.  Keeping them as independent key
+                # fields prevents certified mirrored aliases such as
+                # (tensor, vector) and (vector, tensor) from comparing equal,
+                # even when their products are identical.
+                "exact_contribution_factor": _multiply_exact(
+                    contribution_factor,
+                    witness.exact_factor,
+                ).to_dict(),
+                "input_port_pairings": [
+                    [
+                        [inverse_order[left[0]], left[1]],
+                        [inverse_order[right[0]], right[1]],
+                    ]
+                    for left, right in witness.input_port_pairings
+                ],
+                "result_port_bindings": [
+                    [inverse_order[parent], port]
+                    for parent, port in witness.result_port_bindings
+                ],
+            }
+        )
+    color_witnesses.sort(key=_canonical_json)
+
+    payload = {
+        "prepared_kernel": {
+            # `_validate_vertex_binding_against_model` has already required a
+            # stable, verified model-owned permutation/sign certificate.
+            # Mirrored oriented kernels may have different callable digests
+            # even though that certificate proves the same canonical
+            # evaluation class.  Keying on the digest would retain both rows
+            # and double the recurrence contribution.
+            "verified_equivalence_class": transition.equivalence_class,
+            "contract_kind": str(kernel.contract_kind),
+        },
+        "input_state_template_ids": reordered(transition.input_state_template_ids),
+        "result_state_template_id": transition.result_state_template_id,
+        "quantum_flow": {
+            "input_state_template_ids": reordered(flow.input_state_template_ids),
+            "input_spin_states": reordered(flow.input_spin_states),
+            "input_flavour_flows": [
+                list(value) for value in reordered(flow.input_flavour_flows)
+            ],
+            "input_quantum_number_flows": [
+                [list(item) for item in value]
+                for value in reordered(flow.input_quantum_number_flows)
+            ],
+            **_canonical_flavour_flow_payload(flow, color, order),
+            "quantum_number_flow_operation": flow.quantum_number_flow_operation,
+            "coupling_orders": [list(item) for item in flow.coupling_orders],
+            "result_state_template_id": flow.result_state_template_id,
+            "result_spin_state": flow.result_spin_state,
+            "result_quantum_number_flow": [
+                list(item) for item in flow.result_quantum_number_flow
+            ],
+            "exact_coupling": flow.exact_coupling.to_dict(),
+        },
+        "color": {
+            "rule_kind": color.rule_kind,
+            "input_representations": reordered(color.input_representations),
+            "output_representation": color.output_representation,
+            "ordered_open_string_arity": color.ordered_open_string_arity,
+            "nc_polynomial": [
+                [power, coefficient.to_dict()]
+                for power, coefficient in color.nc_polynomial
+            ],
+            "transition_witnesses": color_witnesses,
+        },
+        "momentum_semantics": _canonical_momentum_semantics(
+            transition.momentum_convention,
+            order,
+        ),
+        "coupling_parameter_ids": list(transition.coupling_parameter_ids),
+        "contact_orbit_step_template_ids": list(
+            getattr(transition, "contact_orbit_step_template_ids", ())
+        ),
+        "contact_orbit_step_semantic_digests": list(
+            getattr(transition, "contact_orbit_step_semantic_digests", ())
+        ),
+        "coupling_orders": [list(item) for item in transition.coupling_orders],
+        "binding_coupling": transition.binding_coupling.to_dict(),
+        "output_factor_source": transition.output_factor_source,
+        "equivalence_class": transition.equivalence_class,
+        "input_exchange_factor": (
+            None
+            if transition.input_exchange_factor is None
+            else transition.input_exchange_factor.to_dict()
+        ),
+        "output_projection": transition.output_projection,
+    }
+    return _canonical_json(payload)
+
+
+def _canonical_flavour_flow_payload(
+    flow: QuantumFlowTemplateV1,
+    color: ColorContractionTemplateV1,
+    canonical_input_order: tuple[int, int],
+) -> dict[str, object]:
+    """Express flavour ancestry in certified canonical input coordinates."""
+
+    inverse_order = tuple(canonical_input_order.index(index) for index in (0, 1))
+    inputs = tuple(flow.input_flavour_flows[index] for index in canonical_input_order)
+    operation = flow.flavour_flow_operation
+    if operation == "constant-result":
+        return {
+            "flavour_flow_operation": operation,
+            "result_flavour_flow": list(flow.result_flavour_flow),
+        }
+
+    if not flow.result_flavour_flow:
+        raise RecurrenceTemplateError(
+            "recurrence quantum-flow result ancestry cannot be empty"
+        )
+    result_particle = flow.result_flavour_flow[-1]
+    if operation in {"append-left-result", "append-right-result"}:
+        concrete_parent = 0 if operation == "append-left-result" else 1
+        canonical_parent = inverse_order[concrete_parent]
+        ancestry = inputs[canonical_parent]
+        result = (
+            ancestry
+            if ancestry and ancestry[-1] == result_particle
+            else (*ancestry, result_particle)
+        )
+        return {
+            "flavour_flow_operation": f"append-input-{canonical_parent}-result",
+            "result_flavour_flow": list(result),
+        }
+
+    if operation != "concat-left-right-result":
+        raise RecurrenceTemplateError(
+            f"unsupported recurrence flavour operation {operation!r}"
+        )
+
+    parent_orders: set[tuple[int, int]] = set()
+    for witness in color.transition_witnesses:
+        concrete_order: list[int] = []
+        for left, right in witness.input_port_pairings:
+            concrete_order.extend((left[0], right[0]))
+        concrete_order.extend(parent for parent, _ in witness.result_port_bindings)
+        unique_order = tuple(dict.fromkeys(concrete_order))
+        if len(unique_order) == 2 and set(unique_order) == {0, 1}:
+            parent_orders.add(tuple(inverse_order[index] for index in unique_order))
+    canonical_parent_order = (
+        next(iter(parent_orders)) if len(parent_orders) == 1 else (0, 1)
+    )
+    result = (
+        *(value for parent in canonical_parent_order for value in inputs[parent]),
+        result_particle,
+    )
+    return {
+        "flavour_flow_operation": (
+            "concat-inputs-"
+            + "-".join(str(index) for index in canonical_parent_order)
+            + "-result"
+        ),
+        "result_flavour_flow": list(result),
+    }
+
+
+def _canonical_momentum_semantics(
+    conventions: Sequence[str],
+    canonical_input_order: tuple[int, int],
+) -> list[str]:
+    result: list[str] = []
+    for concrete_index in canonical_input_order:
+        value = str(conventions[concrete_index])
+        side = "left" if concrete_index == 0 else "right"
+        suffix = f"-{side}"
+        result.append(value[: -len(suffix)] if value.endswith(suffix) else value)
+    return result
+
+
+def _transition_alias_preference(
+    model: Model,
+    binding: PreparedVertexBinding,
+    transition: TransitionTemplateV1,
+) -> tuple[int, int, str]:
+    canonical_order_penalty = int(tuple(binding.canonical_input_order) != (0, 1))
+    left_colored = abs(int(model.color_rep(binding.left_state.particle_id))) != 1
+    right_singlet = abs(int(model.color_rep(binding.right_state.particle_id))) == 1
+    return (
+        0 if left_colored and right_singlet else 1,
+        canonical_order_penalty,
+        transition.template_id,
+    )
+
+
+def _quantum_flow_template(
+    binding: PreparedVertexBinding | PreparedClosureBinding,
+    variant: Mapping[str, Any],
+    state_ids: Mapping[tuple[int, int], str],
+    coupling_orders: tuple[tuple[str, int], ...],
+) -> QuantumFlowTemplateV1:
+    input_state_ids = (
+        state_ids[(binding.left_state.particle_id, binding.left_state.chirality)],
+        state_ids[(binding.right_state.particle_id, binding.right_state.chirality)],
+    )
+    result_state_id = state_ids[
+        (binding.result_state.particle_id, binding.result_state.chirality)
+    ]
+    predicate = {
+        "coupling_orders": [list(item) for item in coupling_orders],
+        "flow": variant,
+        "input_state_template_ids": list(input_state_ids),
+        "result_state_template_id": result_state_id,
+    }
+    return QuantumFlowTemplateV1(
+        template_id=_token("quantum-flow", predicate),
+        input_state_template_ids=input_state_ids,
+        input_spin_states=variant["input_spin_states"],
+        input_flavour_flows=variant["input_flavour_flows"],
+        input_quantum_number_flows=variant["input_quantum_number_flows"],
+        flavour_flow_operation=variant["flavour_flow_operation"],
+        quantum_number_flow_operation=variant["quantum_number_flow_operation"],
+        coupling_orders=coupling_orders,
+        result_state_template_id=result_state_id,
+        result_spin_state=variant["result_spin_state"],
+        result_flavour_flow=variant["result_flavour_flow"],
+        result_quantum_number_flow=variant["result_quantum_number_flow"],
+        exact_coupling=ExactComplexRationalV1.from_dict(variant["coupling"]),
+        predicate_digest=_digest(predicate),
+    )
+
+
+def _validate_vertex_binding_against_model(
+    model: Model,
+    binding: PreparedVertexBinding,
+    vertex: Vertex,
+) -> None:
+    equivalence = _stable_callback(
+        f"vertex equivalence for kind {vertex.kind}",
+        lambda: model.vertex_evaluation_equivalence(vertex.kind),
+        serializer=lambda value: _canonical_json(value.to_json_dict()),
+    )
+    expected = (
+        tuple(equivalence.input_order),
+        _exact_pair(equivalence.factor, "vertex equivalence factor"),
+        None
+        if equivalence.input_exchange_factor is None
+        else _exact_pair(
+            equivalence.input_exchange_factor,
+            "vertex input-exchange factor",
+        ),
+        str(equivalence.class_id),
+        bool(equivalence.verified),
+    )
+    actual = (
+        tuple(binding.canonical_input_order),
+        _exact_pair(binding.equivalence_factor, "prepared equivalence factor"),
+        None
+        if binding.input_exchange_factor is None
+        else _exact_pair(
+            binding.input_exchange_factor,
+            "prepared input-exchange factor",
+        ),
+        str(binding.equivalence_class),
+        True,
+    )
+    if expected != actual:
+        raise PreparedKernelCatalogError(
+            f"prepared vertex binding for kind {vertex.kind} has stale "
+            "permutation/sign proof metadata"
+        )
+    expected_contact = _stable_callback(
+        f"contact-orbit contract for kind {vertex.kind}",
+        lambda: model.vertex_contact_orbit_contracts(vertex.kind),
+        serializer=lambda value: _canonical_json(
+            [[item.to_dict() for item in group] for group in value]
+        ),
+    )
+    actual_contact = (
+        binding.contact_orbit_certificates,
+        binding.contact_orbit_steps,
+    )
+    if expected_contact != actual_contact:
+        raise PreparedKernelCatalogError(
+            f"prepared vertex binding for kind {vertex.kind} has stale "
+            "contact-orbit proof metadata"
+        )
+
+
+def _probe_quantum_flows(
+    model: Model,
+    vertex: Vertex,
+    binding: PreparedVertexBinding | PreparedClosureBinding,
+) -> tuple[dict[str, Any], ...]:
+    contract = _recurrence_quantum_flow_contract(model, vertex, binding)
+    static_result_quantum_flow = tuple(
+        (str(name), str(expression))
+        for name, expression in _stable_callback(
+            f"quantum-number flow for result particle "
+            f"{binding.result_state.particle_id}",
+            lambda: model.quantum_number_flow(binding.result_state.particle_id),
+            serializer=lambda value: _canonical_json(list(value)),
+        )
+    )
+    left_spins = _spin_states_for_chirality(
+        model, binding.left_state.particle_id, binding.left_state.chirality
+    )
+    right_spins = _spin_states_for_chirality(
+        model, binding.right_state.particle_id, binding.right_state.chirality
+    )
+    variants: dict[str, dict[str, Any]] = {}
+    for left_spin in left_spins:
+        for right_spin in right_spins:
+            baseline_left = _flow_probe_index(model, binding.left_state, left_spin)
+            baseline_right = _flow_probe_index(model, binding.right_state, right_spin)
+
+            def evaluate(
+                left: SimpleNamespace,
+                right: SimpleNamespace,
+            ) -> tuple[dict[str, Any], ...]:
+                try:
+                    flows = model.allowed_quantum_flows(vertex, left, right)
+                except Exception as exc:
+                    raise RecurrenceTemplateError(
+                        "cannot evaluate model quantum-flow callback for "
+                        f"vertex kind {vertex.kind}: {exc}"
+                    ) from exc
+                rows: list[dict[str, Any]] = []
+                for flow in flows:
+                    if int(flow.chirality) != binding.result_state.chirality:
+                        continue
+                    if not isinstance(flow.spin_state, int) or isinstance(
+                        flow.spin_state, bool
+                    ):
+                        raise RecurrenceTemplateError(
+                            "recurrence-template-v1 cannot encode structured "
+                            f"quantum-flow spin state {flow.spin_state!r}"
+                        )
+                    rows.append(
+                        {
+                            "input_spin_states": (
+                                int(left.spin_state),
+                                int(right.spin_state),
+                            ),
+                            "input_flavour_flows": (
+                                tuple(int(value) for value in left.flavour_flow),
+                                tuple(int(value) for value in right.flavour_flow),
+                            ),
+                            "input_quantum_number_flows": (
+                                tuple(
+                                    (str(name), str(expression))
+                                    for name, expression in left.quantum_number_flow
+                                ),
+                                tuple(
+                                    (str(name), str(expression))
+                                    for name, expression in right.quantum_number_flow
+                                ),
+                            ),
+                            "result_chirality": int(flow.chirality),
+                            "result_spin_state": int(flow.spin_state),
+                            "result_flavour_flow": tuple(
+                                int(value) for value in flow.flavour_flow
+                            ),
+                            "result_quantum_number_flow": tuple(
+                                (str(name), str(expression))
+                                for name, expression in flow.quantum_number_flow
+                            ),
+                            "coupling": _exact_pair(
+                                flow.coupling,
+                                f"vertex kind {vertex.kind} quantum-flow coupling",
+                            ).to_dict(),
+                        }
+                    )
+                return tuple(sorted(rows, key=_canonical_json))
+
+            baseline = _stable_quantum_flow_probe(
+                evaluate,
+                baseline_left,
+                baseline_right,
+                vertex_kind=vertex.kind,
+            )
+            probe_pairs = (
+                (
+                    _flow_probe_index(
+                        model,
+                        binding.left_state,
+                        left_spin,
+                        flavour_flow=(1_870_001, 1_870_002),
+                        quantum_number_flow=(("__RECURRENCE_LEFT__", "17"),),
+                        coupling_orders=(("QCD", 2),),
+                    ),
+                    _flow_probe_index(
+                        model,
+                        binding.right_state,
+                        right_spin,
+                        flavour_flow=(1_871_001, 1_871_002),
+                        quantum_number_flow=(("__RECURRENCE_RIGHT__", "19"),),
+                        coupling_orders=(("QED", 1),),
+                    ),
+                ),
+                (
+                    _flow_probe_index(
+                        model,
+                        binding.left_state,
+                        left_spin,
+                        flavour_flow=(1_872_001, 1_872_002, 1_872_003),
+                        quantum_number_flow=(("electric_charge", "23/7"),),
+                        coupling_orders=(("__RECURRENCE_LEFT__", 1),),
+                    ),
+                    _flow_probe_index(
+                        model,
+                        binding.right_state,
+                        right_spin,
+                        flavour_flow=(1_873_001, 1_873_002, 1_873_003),
+                        quantum_number_flow=(("color_charge", "29/11"),),
+                        coupling_orders=(("__RECURRENCE_RIGHT__", 2),),
+                    ),
+                ),
+            )
+            probes = tuple(
+                _stable_quantum_flow_probe(
+                    evaluate,
+                    left,
+                    right,
+                    vertex_kind=vertex.kind,
+                )
+                for left, right in probe_pairs
+            )
+            baseline_by_key = _quantum_flow_rows_by_invariant_key(
+                baseline, vertex_kind=vertex.kind
+            )
+            probe_maps = tuple(
+                _quantum_flow_rows_by_invariant_key(rows, vertex_kind=vertex.kind)
+                for rows in probes
+            )
+            if any(set(rows) != set(baseline_by_key) for rows in probe_maps):
+                raise RecurrenceTemplateError(
+                    "recurrence-template-v1 requires quantum-flow admission to be "
+                    "independent of accumulated flavour, quantum-number, and "
+                    "coupling-order flows; "
+                    f"vertex kind {vertex.kind} violates that contract"
+                )
+            for key, row in baseline_by_key.items():
+                for left, right, rows in (
+                    (baseline_left, baseline_right, baseline_by_key),
+                    *(
+                        (left, right, rows)
+                        for (left, right), rows in zip(
+                            probe_pairs, probe_maps, strict=True
+                        )
+                    ),
+                ):
+                    expected = _apply_flavour_flow_operation(
+                        contract.flavour_flow_operation,
+                        tuple(int(value) for value in left.flavour_flow),
+                        tuple(int(value) for value in right.flavour_flow),
+                        binding.result_state.particle_id,
+                    )
+                    candidate = rows[key]
+                    if tuple(candidate["result_flavour_flow"]) != expected:
+                        raise RecurrenceTemplateError(
+                            "quantum-flow callback contradicts its declared "
+                            f"flavour operation for vertex kind {vertex.kind}"
+                        )
+                    if (
+                        tuple(candidate["result_quantum_number_flow"])
+                        != static_result_quantum_flow
+                    ):
+                        raise RecurrenceTemplateError(
+                            "quantum-flow callback contradicts its declared "
+                            "particle-static quantum-number operation for vertex "
+                            f"kind {vertex.kind}"
+                        )
+                enriched = dict(row)
+                enriched["flavour_flow_operation"] = contract.flavour_flow_operation
+                enriched["quantum_number_flow_operation"] = (
+                    contract.quantum_number_flow_operation
+                )
+                variants.setdefault(_canonical_json(enriched), enriched)
+    return tuple(variants[key] for key in sorted(variants))
+
+
+def _stable_quantum_flow_probe(
+    evaluate: Any,
+    left: SimpleNamespace,
+    right: SimpleNamespace,
+    *,
+    vertex_kind: int,
+) -> tuple[dict[str, Any], ...]:
+    first = evaluate(left, right)
+    second = evaluate(left, right)
+    if _canonical_json(first) != _canonical_json(second):
+        raise RecurrenceTemplateError(
+            f"allowed_quantum_flows is nondeterministic for vertex kind {vertex_kind}"
+        )
+    return first
+
+
+def _quantum_flow_rows_by_invariant_key(
+    rows: Sequence[Mapping[str, Any]],
+    *,
+    vertex_kind: int,
+) -> dict[str, dict[str, Any]]:
+    result: dict[str, dict[str, Any]] = {}
+    for row in rows:
+        key_payload = {
+            name: value
+            for name, value in row.items()
+            if name
+            not in {
+                "input_flavour_flows",
+                "input_quantum_number_flows",
+                "result_flavour_flow",
+                "result_quantum_number_flow",
+            }
+        }
+        key = _canonical_json(key_payload)
+        if key in result:
+            raise RecurrenceTemplateError(
+                "recurrence-template-v1 cannot distinguish multiple quantum-flow "
+                f"branches for vertex kind {vertex_kind}"
+            )
+        result[key] = dict(row)
+    return result
+
+
+def _recurrence_quantum_flow_contract(
+    model: Model,
+    vertex: Vertex,
+    binding: PreparedVertexBinding | PreparedClosureBinding,
+) -> RecurrenceQuantumFlowContract:
+    model_type = type(model)
+    mro = model_type.__mro__
+    allowed_owner = next(
+        owner for owner in mro if "allowed_quantum_flows" in owner.__dict__
+    )
+    combine_owner = next(
+        owner for owner in mro if "combine_flavour_flow" in owner.__dict__
+    )
+    contract_owner = next(
+        owner for owner in mro if "recurrence_quantum_flow_contract" in owner.__dict__
+    )
+    if mro.index(contract_owner) > mro.index(allowed_owner):
+        raise RecurrenceTemplateError(
+            f"{model_type.__name__}.allowed_quantum_flows overrides the callback "
+            "without declaring a matching recurrence quantum-flow contract"
+        )
+    if mro.index(contract_owner) > mro.index(combine_owner):
+        raise RecurrenceTemplateError(
+            f"{model_type.__name__}.combine_flavour_flow overrides the callback "
+            "without declaring a matching recurrence quantum-flow contract"
+        )
+    try:
+        contract = _stable_callback(
+            f"recurrence quantum-flow contract for vertex kind {vertex.kind}",
+            lambda: model.recurrence_quantum_flow_contract(
+                vertex,
+                binding.left_state.particle_id,
+                binding.right_state.particle_id,
+            ),
+            serializer=lambda value: _canonical_json(value.to_json_dict()),
+        )
+    except Exception as exc:
+        raise RecurrenceTemplateError(
+            "model does not provide a recurrence quantum-flow contract for "
+            f"vertex kind {vertex.kind}: {exc}"
+        ) from exc
+    if not isinstance(contract, RecurrenceQuantumFlowContract):
+        raise RecurrenceTemplateError(
+            "model recurrence quantum-flow contract must be a "
+            f"RecurrenceQuantumFlowContract for vertex kind {vertex.kind}"
+        )
+    return contract
+
+
+def _apply_flavour_flow_operation(
+    operation: FlavourFlowOperationV1 | str,
+    left: tuple[int, ...],
+    right: tuple[int, ...],
+    result_particle: int,
+) -> tuple[int, ...]:
+    if operation == "constant-result":
+        return (int(result_particle),)
+    if operation == "append-left-result":
+        return (
+            left if left and left[-1] == result_particle else (*left, result_particle)
+        )
+    if operation == "append-right-result":
+        return (
+            right
+            if right and right[-1] == result_particle
+            else (*right, result_particle)
+        )
+    if operation == "concat-left-right-result":
+        return (*left, *right, result_particle)
+    raise AssertionError(f"unknown flavour-flow operation {operation!r}")
+
+
+def _spin_states_for_chirality(
+    model: Model,
+    particle_id: int,
+    chirality: int,
+) -> tuple[int, ...]:
+    if _effective_auxiliary_kind(model, particle_id, chirality) is not None:
+        result = model.result_spin_state(particle_id, chirality)
+        if not isinstance(result, int) or isinstance(result, bool):
+            raise RecurrenceTemplateError(
+                "recurrence-template-v1 cannot encode structured auxiliary "
+                "result spin state"
+            )
+        return (int(result),)
+    values: set[int] = set()
+    for state in model.source_spin_states(particle_id):
+        if int(state.chirality) != chirality:
+            continue
+        if not isinstance(state.spin_state, int) or isinstance(state.spin_state, bool):
+            raise RecurrenceTemplateError(
+                "recurrence-template-v1 cannot encode structured source spin state "
+                f"{state.spin_state!r}"
+            )
+        values.add(int(state.spin_state))
+    result = model.result_spin_state(particle_id, chirality)
+    if not isinstance(result, int) or isinstance(result, bool):
+        raise RecurrenceTemplateError(
+            "recurrence-template-v1 cannot encode structured result spin state"
+        )
+    values.add(int(result))
+    return tuple(sorted(values))
+
+
+def _flow_probe_index(
+    model: Model,
+    state: PreparedParticleState,
+    spin_state: int,
+    *,
+    flavour_flow: tuple[int, ...] | None = None,
+    quantum_number_flow: tuple[tuple[str, str], ...] | None = None,
+    coupling_orders: tuple[tuple[str, int], ...] = (),
+) -> SimpleNamespace:
+    quantum_flow = (
+        _stable_callback(
+            f"quantum-number flow for particle {state.particle_id}",
+            lambda: model.quantum_number_flow(state.particle_id),
+            serializer=lambda value: _canonical_json(list(value)),
+        )
+        if quantum_number_flow is None
+        else quantum_number_flow
+    )
+    return SimpleNamespace(
+        particle_id=state.particle_id,
+        pdg=state.particle_id,
+        chirality=state.chirality,
+        spin_state=spin_state,
+        flavour_flow=(state.particle_id,) if flavour_flow is None else flavour_flow,
+        quantum_number_flow=quantum_flow,
+        coupling_orders=coupling_orders,
+    )
+
+
+def _canonical_coupling_orders(
+    value: Sequence[tuple[str, int]],
+    context: str,
+) -> tuple[tuple[str, int], ...]:
+    result = tuple(sorted((str(name).upper(), int(power)) for name, power in value))
+    if len({name for name, _ in result}) != len(result) or any(
+        power < 0 for _, power in result
+    ):
+        raise RecurrenceTemplateError(f"{context} is not canonical")
+    return result
+
+
+def _color_template(
+    model: Model,
+    vertex: Vertex,
+    *,
+    closure: bool,
+    proof_subject: str,
+) -> ColorContractionTemplateV1:
+    model_type = type(model)
+    mro = model_type.__mro__
+    structure_owner = next(
+        owner for owner in mro if "vertex_color_structure" in owner.__dict__
+    )
+    contract_owner = next(
+        owner
+        for owner in mro
+        if "recurrence_lc_color_transition_contract" in owner.__dict__
+    )
+    if mro.index(contract_owner) > mro.index(structure_owner):
+        raise RecurrenceTemplateError(
+            f"{model_type.__name__}.vertex_color_structure overrides the color "
+            "tensor callback without declaring a matching recurrence LC color contract"
+        )
+
+    def evaluate() -> tuple[
+        str,
+        tuple[int, ...],
+        ExactComplexRationalV1,
+        tuple[Any, ...],
+    ]:
+        contract = model.recurrence_lc_color_transition_contract(
+            vertex,
+            closure=closure,
+        )
+        structure = str(contract.rule_kind)
+        representations = tuple(
+            int(model.color_rep(particle)) for particle in vertex.particles
+        )
+        if structure not in _SUPPORTED_COLOR_RULES:
+            raise RecurrenceTemplateError(
+                f"recurrence-template-v1 cannot encode color rule {structure!r} "
+                f"for vertex kind {vertex.kind}"
+            )
+        coefficient = _exact_pair(
+            model.vertex_color_weight(vertex, color_accuracy="lc"),
+            f"vertex kind {vertex.kind} LC color coefficient",
+        )
+        return structure, representations, coefficient, tuple(contract.witnesses)
+
+    first = evaluate()
+    second = evaluate()
+    if first != second:
+        raise RecurrenceTemplateError(
+            f"color callback is nondeterministic for vertex kind {vertex.kind}"
+        )
+    structure, representations, coefficient, witness_contracts = first
+    output_representation = None if closure else representations[2]
+    input_shapes = tuple(
+        model.recurrence_lc_color_shape_contract(particle)
+        for particle in vertex.particles[:2]
+    )
+    result_shape = (
+        None
+        if closure
+        else model.recurrence_lc_color_shape_contract(vertex.particles[2])
+    )
+    port_wirings = compile_lc_color_port_wirings(
+        "direct-closure" if closure else structure,  # type: ignore[arg-type]
+        representations[:2] if closure else representations,
+        (
+            representations[:2]
+            if closure
+            else (
+                *representations[:2],
+                -representations[2]
+                if abs(representations[2]) == 3
+                else representations[2],
+            )
+        ),
+    )
+    if len(port_wirings) != len(witness_contracts):
+        raise RecurrenceTemplateError(
+            f"vertex kind {vertex.kind} exposes {len(witness_contracts)} LC witness "
+            f"terms but its certified port compiler produced {len(port_wirings)}"
+        )
+    witnesses_list: list[LCColorTransitionWitnessV1] = []
+    for witness, wiring in zip(witness_contracts, port_wirings, strict=True):
+        exact_factor = _exact_pair(
+            witness.exact_factor,
+            f"vertex kind {vertex.kind} LC color witness factor",
+        )
+        expected_port_factor = (
+            ExactComplexRationalV1.one()
+            if wiring.exact_factor == 1
+            else ExactComplexRationalV1(
+                real_numerator=-1,
+                real_denominator=1,
+                imag_numerator=0,
+                imag_denominator=1,
+            )
+        )
+        if exact_factor != expected_port_factor:
+            raise RecurrenceTemplateError(
+                f"vertex kind {vertex.kind} LC witness factor does not match its "
+                "certified port-wiring term"
+            )
+        port_payload = {
+            "input_pairings": [
+                [
+                    [
+                        pairing.fundamental.parent_index,
+                        pairing.fundamental.local_port_index,
+                    ],
+                    [
+                        pairing.antifundamental.parent_index,
+                        pairing.antifundamental.local_port_index,
+                    ],
+                ]
+                for pairing in wiring.input_pairings
+            ],
+            "result_port_bindings": [
+                [port.parent_index, port.local_port_index]
+                for port in wiring.result_port_bindings
+            ],
+            "term_index": wiring.term_index,
+        }
+        model_proof_digest = witness.proof_digest or _digest(
+            {
+                "proof_subject": proof_subject,
+                "rule_kind": structure,
+                "representations": representations,
+                "closure": closure,
+                "input_shapes": input_shapes,
+                "result_shape": result_shape,
+                "input_permutation": witness.input_permutation,
+                "reverse_parent_mask": witness.reverse_parent_mask,
+                "operation": witness.component_operation,
+                "result_component_kind": witness.result_component_kind,
+                "result_component_role": witness.result_component_role,
+                "factor": exact_factor.to_dict(),
+            }
+        )
+        witnesses_list.append(
+            LCColorTransitionWitnessV1(
+                input_shape_kinds=input_shapes,  # type: ignore[arg-type]
+                input_permutation=witness.input_permutation,
+                reverse_parent_mask=witness.reverse_parent_mask,
+                component_operation=witness.component_operation,
+                result_component_kind=witness.result_component_kind,
+                result_component_role=witness.result_component_role,
+                result_shape_kind=result_shape,
+                exact_factor=exact_factor,
+                proof_digest=_digest(
+                    {
+                        "model_proof_digest": model_proof_digest,
+                        "port_wiring": port_payload,
+                    }
+                ),
+                provenance=witness.provenance,
+                input_port_pairings=tuple(
+                    (
+                        (
+                            pairing.fundamental.parent_index,
+                            pairing.fundamental.local_port_index,
+                        ),
+                        (
+                            pairing.antifundamental.parent_index,
+                            pairing.antifundamental.local_port_index,
+                        ),
+                    )
+                    for pairing in wiring.input_pairings
+                ),
+                result_port_bindings=tuple(
+                    (port.parent_index, port.local_port_index)
+                    for port in wiring.result_port_bindings
+                ),
+            )
+        )
+    witnesses = tuple(witnesses_list)
+    payload = {
+        "rule_kind": structure,
+        "input_representations": representations[:2],
+        "output_representation": output_representation,
+        "coefficient": coefficient.to_dict(),
+        "transition_witnesses": [witness.to_dict() for witness in witnesses],
+    }
+    return ColorContractionTemplateV1(
+        template_id=_token("color", payload),
+        rule_kind=structure,
+        input_representations=representations[:2],
+        output_representation=output_representation,
+        ordered_open_string_arity=(
+            1 if any(abs(value) == 3 for value in representations) else 0
+        ),
+        exact_coefficient=coefficient,
+        nc_polynomial=((0, ExactComplexRationalV1.one()),),
+        expression_digest=_digest(payload),
+        transition_witnesses=witnesses,
+    )
+
+
+def _infer_model_defined_color_rule(representations: tuple[int, ...]) -> str:
+    absolute = tuple(abs(value) for value in representations)
+    if all(value == 1 for value in absolute):
+        return "singlet"
+    if sorted(absolute) == [3, 3, 8]:
+        return "fundamental-generator"
+    if sorted(absolute) == [1, 3, 3]:
+        return "color-identity"
+    if absolute == (8, 8, 8):
+        return "adjoint-structure-constant"
+    raise RecurrenceTemplateError(
+        "model-defined color semantics are not reconstructible from generic "
+        f"representations {representations!r}; the prepared recurrence companion "
+        "must provide an explicit certified color rule"
+    )
+
+
+def _build_propagators(
+    model: Model,
+    bindings: Sequence[PreparedPropagatorBinding],
+    state_ids: Mapping[tuple[int, int], str],
+    parameter_ids: Mapping[str, str],
+    kernels: Mapping[int, Any],
+    evaluator_requests: list[_EvaluatorRequest],
+) -> tuple[tuple[PropagatorTemplateV1, ...], tuple[SymmetryProofV1, ...]]:
+    records: list[PropagatorTemplateV1] = []
+    proofs: list[SymmetryProofV1] = []
+    for binding in sorted(bindings, key=lambda item: item.key):
+        metadata = _stable_callback(
+            f"propagator contract for {binding.key!r}",
+            lambda binding=binding: model._propagator_ir(
+                binding.key.particle_id, binding.key.chirality
+            ),
+            serializer=lambda value: _canonical_json(value.to_json_dict()),
+        )
+        if (
+            bool(metadata.applies_propagator) != binding.applies_propagator
+            or str(metadata.kind) != binding.propagator_kind
+            or str(metadata.mass_class) != binding.mass_class
+            or metadata.gauge != binding.gauge
+            or metadata.identity.canonical_id != binding.state.identity
+            or metadata.basis != binding.state.basis
+        ):
+            raise PreparedKernelCatalogError(
+                f"prepared propagator binding {binding.key!r} is stale"
+            )
+        state_id = state_ids[(binding.state.particle_id, binding.state.chirality)]
+        template_id = _token(
+            "propagator",
+            {
+                "state": state_id,
+                "metadata": metadata.to_json_dict(),
+                "kernel_id": binding.kernel_id,
+            },
+        )
+        kernel = None
+        resolver_key = None
+        numerator_digest = None
+        denominator_digest = None
+        proof_id = None
+        if binding.applies_propagator:
+            if binding.kernel_id is None:
+                raise PreparedKernelCatalogError(
+                    f"active propagator {binding.key!r} has no prepared kernel"
+                )
+            kernel = _kernel(kernels, binding.kernel_id, "propagator")
+            if kernel.contract_kind != "propagator":
+                raise PreparedKernelCatalogError(
+                    f"prepared propagator binding references a "
+                    f"{kernel.contract_kind!r} kernel"
+                )
+            _validate_propagator_kernel_layout(kernel, binding)
+            if metadata.numerator is None or metadata.denominator is None:
+                raise RecurrenceTemplateError(
+                    f"active propagator {binding.key!r} lacks exact formula metadata"
+                )
+            numerator_digest = _expression_digest(str(metadata.numerator))
+            denominator_digest = _expression_digest(str(metadata.denominator))
+            resolver_key = _resolver_key(kernel, "propagator", (state_id,), state_id)
+            if PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF in kernel.proof_classes:
+                proof_id = _token(
+                    "proof",
+                    {
+                        "algorithm": PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF,
+                        "subject": template_id,
+                        "kernel": kernel.canonical_signature,
+                    },
+                )
+                expression_digests = tuple(
+                    _expression_digest(value) for value in kernel.exact_expressions
+                )
+                proofs.append(
+                    SymmetryProofV1(
+                        template_id=proof_id,
+                        proof_algorithm=PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF,
+                        subject_template_ids=(template_id,),
+                        input_permutation=(0,),
+                        exact_phase=ExactComplexRationalV1.one(),
+                        expression_digests=expression_digests,
+                        witness_digest=_digest(
+                            {
+                                "kernel": kernel.canonical_signature,
+                                "proof_class": (
+                                    PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF
+                                ),
+                            }
+                        ),
+                    )
+                )
+        record = PropagatorTemplateV1(
+            template_id=template_id,
+            state_template_id=state_id,
+            applies_propagator=binding.applies_propagator,
+            evaluator_resolver_key=resolver_key,
+            numerator_expression_digest=numerator_digest,
+            denominator_expression_digest=denominator_digest,
+            mass_parameter_id=_parameter_reference(
+                metadata.mass_parameter,
+                parameter_ids,
+                "propagator mass parameter",
+            ),
+            width_parameter_id=_parameter_reference(
+                metadata.width_parameter,
+                parameter_ids,
+                "propagator width parameter",
+            ),
+            gauge=metadata.gauge,
+            linearity_proof_template_id=proof_id,
+        )
+        records.append(record)
+        if kernel is not None:
+            evaluator_requests.append(
+                _EvaluatorRequest(
+                    kernel=kernel,
+                    contract_kind="propagator",
+                    input_state_template_ids=(state_id,),
+                    output_state_template_id=state_id,
+                    semantic_template_id=record.template_id,
+                )
+            )
+    return tuple(records), tuple(proofs)
+
+
+def _build_closures(
+    model: Model,
+    bindings: Sequence[PreparedClosureBinding],
+    state_ids: Mapping[tuple[int, int], str],
+    parameter_ids: Mapping[str, str],
+    kernels: Mapping[int, Any],
+    evaluator_requests: list[_EvaluatorRequest],
+) -> tuple[
+    tuple[QuantumFlowTemplateV1, ...],
+    tuple[ClosureTemplateV1, ...],
+    tuple[ColorContractionTemplateV1, ...],
+]:
+    flows_by_id: dict[str, QuantumFlowTemplateV1] = {}
+    records: list[ClosureTemplateV1] = []
+    colors: dict[str, ColorContractionTemplateV1] = {}
+    for binding in sorted(bindings, key=lambda item: item.key):
+        vertex = Vertex(
+            binding.key.kind,
+            binding.key.particles,
+            binding.key.coupling,
+        )
+        kernel = _kernel(kernels, binding.kernel_id, "closure")
+        if kernel.contract_kind != "closure":
+            raise PreparedKernelCatalogError(
+                f"prepared closure binding references a {kernel.contract_kind!r} kernel"
+            )
+        _validate_binary_kernel_layout(
+            kernel,
+            binding,
+            output_dimension=1,
+            context=f"closure kind {vertex.kind}",
+        )
+        contraction = model.closure_contraction_ir(
+            binding.result_state.particle_id,
+            binding.result_state.chirality,
+        )
+        if contraction is None or contraction.name != binding.projection:
+            raise PreparedKernelCatalogError(
+                f"prepared closure binding for kind {vertex.kind} does not match "
+                "the live contraction contract"
+            )
+        color = _color_template(
+            model,
+            vertex,
+            closure=True,
+            proof_subject=kernel.canonical_signature,
+        )
+        colors.setdefault(color.template_id, color)
+        coupling_orders = _canonical_coupling_orders(
+            model.vertex_coupling_orders(vertex),
+            f"closure kind {vertex.kind} coupling orders",
+        )
+        flow_variants = _probe_quantum_flows(model, vertex, binding)
+        if not flow_variants:
+            raise RecurrenceTemplateError(
+                "prepared closure binding is not admitted by the live quantum-flow "
+                f"contract: kind={binding.key.kind}, key={binding.key!r}"
+            )
+        eligible_flows = tuple(
+            _quantum_flow_template(
+                binding,
+                variant,
+                state_ids,
+                coupling_orders,
+            )
+            for variant in flow_variants
+        )
+        for flow in eligible_flows:
+            flows_by_id.setdefault(flow.template_id, flow)
+        input_state_ids = (
+            state_ids[(binding.left_state.particle_id, binding.left_state.chirality)],
+            state_ids[(binding.right_state.particle_id, binding.right_state.chirality)],
+        )
+        resolver_key = _resolver_key(kernel, "closure", input_state_ids, None)
+        template_id = _token(
+            "closure",
+            {
+                "binding": _closure_binding_payload(binding),
+                "kernel": kernel.canonical_signature,
+                "color": color.semantic_digest,
+                "projection": contraction.to_json_dict(),
+            },
+        )
+        record = ClosureTemplateV1(
+            template_id=template_id,
+            input_state_template_ids=input_state_ids,
+            result_state_template_id=state_ids[
+                (
+                    binding.result_state.particle_id,
+                    binding.result_state.chirality,
+                )
+            ],
+            evaluator_resolver_key=resolver_key,
+            canonical_input_order=tuple(binding.canonical_input_order),
+            coupling_parameter_ids=_kernel_parameter_ids(kernel, parameter_ids),
+            coupling_orders=coupling_orders,
+            eligible_quantum_flow_template_ids=tuple(
+                sorted(flow.template_id for flow in eligible_flows)
+            ),
+            color_contraction_template_id=color.template_id,
+            binding_coupling=_exact_pair(
+                binding.key.coupling,
+                f"closure kind {vertex.kind} binding coupling",
+            ),
+            exact_factor=_exact_pair(
+                binding.equivalence_factor,
+                f"closure kind {vertex.kind} equivalence factor",
+            ),
+            output_factor_source=binding.output_factor_source,
+            equivalence_class=binding.equivalence_class,
+            input_exchange_factor=(
+                None
+                if binding.input_exchange_factor is None
+                else _exact_pair(
+                    binding.input_exchange_factor,
+                    f"closure kind {vertex.kind} input-exchange factor",
+                )
+            ),
+            projection=binding.projection,
+        )
+        records.append(record)
+        evaluator_requests.append(
+            _EvaluatorRequest(
+                kernel=kernel,
+                contract_kind="closure",
+                input_state_template_ids=input_state_ids,
+                output_state_template_id=None,
+                semantic_template_id=record.template_id,
+            )
+        )
+    return (
+        tuple(flows_by_id.values()),
+        tuple(records),
+        tuple(colors.values()),
+    )
+
+
+def _build_direct_closures(
+    model: Model,
+    state_ids: Mapping[tuple[int, int], str],
+    state_by_id: Mapping[str, CurrentStateTemplateV1],
+) -> tuple[
+    tuple[ClosureTemplateV1, ...],
+    tuple[ColorContractionTemplateV1, ...],
+    tuple[EvaluatorBindingV1, ...],
+]:
+    """Bind exact model current-pair contractions to Rusticol templates."""
+
+    direct = getattr(model, "_direct_contraction_ir_by_state", {})
+    if not isinstance(direct, Mapping):
+        raise RecurrenceTemplateError(
+            "model direct-contraction inventory is not a mapping"
+        )
+    records: list[ClosureTemplateV1] = []
+    colors: dict[str, ColorContractionTemplateV1] = {}
+    evaluator_bindings: list[EvaluatorBindingV1] = []
+    for raw_key in sorted(direct):
+        if not isinstance(raw_key, tuple) or len(raw_key) != 4:
+            raise RecurrenceTemplateError(
+                f"direct-contraction key {raw_key!r} is not a four-state tuple"
+            )
+        key = tuple(int(value) for value in raw_key)
+        left_key = key[0], key[1]
+        right_key = key[2], key[3]
+        if left_key not in state_ids or right_key not in state_ids:
+            # Ghost-only and otherwise unadmitted states are intentionally not
+            # part of recurrence v1.
+            continue
+        contraction = _stable_callback(
+            f"direct contraction for states {key!r}",
+            lambda key=key: model.direct_contraction_ir(key[0], key[2], key[1], key[3]),
+            serializer=lambda value: (
+                "null" if value is None else _canonical_json(value.to_json_dict())
+            ),
+        )
+        if contraction is None:
+            continue
+        left_state_id = state_ids[left_key]
+        right_state_id = state_ids[right_key]
+        left_state = state_by_id[left_state_id]
+        right_state = state_by_id[right_state_id]
+        if (
+            contraction.left_basis != left_state.basis
+            or contraction.right_basis != right_state.basis
+        ):
+            raise RecurrenceTemplateError(
+                f"direct contraction {contraction.name!r} basis does not match "
+                f"states {key!r}"
+            )
+        if (
+            left_state.dimension != right_state.dimension
+            or len(contraction.coefficients) != left_state.dimension
+        ):
+            raise RecurrenceTemplateError(
+                f"direct contraction {contraction.name!r} component count does "
+                f"not match states {key!r}"
+            )
+        if contraction.chirality_relation == "equal" and key[1] != key[3]:
+            raise RecurrenceTemplateError(
+                f"direct contraction {contraction.name!r} violates equal chirality"
+            )
+        if contraction.chirality_relation == "opposite" and key[1] != -key[3]:
+            raise RecurrenceTemplateError(
+                f"direct contraction {contraction.name!r} violates opposite chirality"
+            )
+        exact_coefficients = tuple(
+            _exact_pair(value, f"direct contraction {contraction.name!r} coefficient")
+            for value in contraction.coefficients
+        )
+        callable_payload = {
+            "abi": "rusticol-closure-reduce-v1",
+            "left_basis": left_state.basis,
+            "right_basis": right_state.basis,
+            "dimension": left_state.dimension,
+            "coefficients": [value.to_dict() for value in exact_coefficients],
+            "chirality_relation": contraction.chirality_relation,
+            "metric_signature": contraction.metric_signature,
+        }
+        callable_signature = _digest(callable_payload)
+        runtime_template = f"rusticol.closure-reduce.v1:{callable_signature[:24]}"
+        input_state_ids = left_state_id, right_state_id
+        resolver_key = _token(
+            "evaluator",
+            {
+                "runtime_template": runtime_template,
+                "input_states": input_state_ids,
+            },
+        )
+        color = _direct_closure_color_template(model, key[0], key[2])
+        colors.setdefault(color.template_id, color)
+        closure_payload = {
+            "states": input_state_ids,
+            "projection": contraction.to_json_dict(),
+            "callable": callable_signature,
+            "color": color.semantic_digest,
+        }
+        record = ClosureTemplateV1(
+            template_id=_token("closure", closure_payload),
+            input_state_template_ids=input_state_ids,
+            result_state_template_id=None,
+            evaluator_resolver_key=resolver_key,
+            canonical_input_order=(0, 1),
+            coupling_parameter_ids=(),
+            coupling_orders=(),
+            eligible_quantum_flow_template_ids=(),
+            color_contraction_template_id=color.template_id,
+            binding_coupling=ExactComplexRationalV1.one(),
+            exact_factor=ExactComplexRationalV1.one(),
+            output_factor_source="none",
+            equivalence_class="direct-contraction",
+            input_exchange_factor=None,
+            projection=contraction.name,
+            component_coefficients=exact_coefficients,
+            chirality_relation=contraction.chirality_relation,
+            metric_signature=contraction.metric_signature,
+        )
+        records.append(record)
+        evaluator_bindings.append(
+            EvaluatorBindingV1(
+                resolver_key=resolver_key,
+                prepared_kernel_id=None,
+                callable_kind="rusticol-template",
+                runtime_template=runtime_template,
+                contract_kind="closure",
+                callable_signature=callable_signature,
+                input_state_template_ids=input_state_ids,
+                output_state_template_id=None,
+                input_layout=tuple(
+                    f"left-current:{component}"
+                    for component in range(left_state.dimension)
+                )
+                + tuple(
+                    f"right-current:{component}"
+                    for component in range(right_state.dimension)
+                ),
+                output_layout=("closure:amplitude",),
+                exact_expression_digests=(_digest(callable_payload),),
+                semantic_template_ids=(record.template_id,),
+            )
+        )
+    # Model contraction inventories expose both orientations of a direct
+    # bilinear. Once exact LC port wiring is attached, both orientations can
+    # close the same physical current pair. They are aliases, not two terms in
+    # the amplitude. Coalesce only when the complete process-independent
+    # callable and contraction contracts agree after forgetting parent order.
+    selected: dict[
+        str,
+        tuple[str, ClosureTemplateV1, EvaluatorBindingV1],
+    ] = {}
+    for record, binding in zip(records, evaluator_bindings, strict=True):
+        alias_key = _canonical_json(
+            {
+                "callable_signature": binding.callable_signature,
+                "chirality_relation": record.chirality_relation,
+                "component_coefficients": [
+                    value.to_dict() for value in record.component_coefficients
+                ],
+                "input_state_template_ids": sorted(record.input_state_template_ids),
+                "metric_signature": record.metric_signature,
+                "projection": record.projection,
+            }
+        )
+        preference = _canonical_json(
+            {
+                "input_state_template_ids": record.input_state_template_ids,
+                "template_id": record.template_id,
+            }
+        )
+        existing = selected.get(alias_key)
+        if existing is None or preference < existing[0]:
+            selected[alias_key] = (preference, record, binding)
+
+    selected_records = tuple(selected[key][1] for key in sorted(selected))
+    selected_bindings = tuple(selected[key][2] for key in sorted(selected))
+    selected_color_ids = {
+        record.color_contraction_template_id for record in selected_records
+    }
+    selected_colors = tuple(
+        color for color_id, color in colors.items() if color_id in selected_color_ids
+    )
+    return selected_records, selected_colors, selected_bindings
+
+
+def _direct_closure_color_template(
+    model: Model,
+    left_particle_id: int,
+    right_particle_id: int,
+) -> ColorContractionTemplateV1:
+    representations = (
+        int(model.color_rep(left_particle_id)),
+        int(model.color_rep(right_particle_id)),
+    )
+    if abs(representations[0]) != abs(representations[1]):
+        raise RecurrenceTemplateError(
+            "direct current contraction joins incompatible color "
+            f"representations {representations!r}"
+        )
+    payload = {
+        "rule_kind": "direct-pairing",
+        "input_representations": representations,
+    }
+    if all(abs(value) == 1 for value in representations):
+        closure_component_kind = None
+    elif set(representations) == {3, -3}:
+        closure_component_kind = "open-string"
+    elif representations == (8, 8):
+        closure_component_kind = "trace"
+    else:
+        raise RecurrenceTemplateError(
+            "direct current contraction has unsupported LC closure components "
+            f"{representations!r}"
+        )
+    (port_wiring,) = compile_lc_color_port_wirings(
+        "direct-closure",
+        representations,
+        representations,
+    )
+    port_payload = {
+        "input_pairings": [
+            [
+                [
+                    pairing.fundamental.parent_index,
+                    pairing.fundamental.local_port_index,
+                ],
+                [
+                    pairing.antifundamental.parent_index,
+                    pairing.antifundamental.local_port_index,
+                ],
+            ]
+            for pairing in port_wiring.input_pairings
+        ],
+        "result_port_bindings": [],
+    }
+    witness = LCColorTransitionWitnessV1(
+        input_shape_kinds=(
+            model.recurrence_lc_color_shape_contract(left_particle_id),
+            model.recurrence_lc_color_shape_contract(right_particle_id),
+        ),
+        input_permutation=(0, 1),
+        reverse_parent_mask=0,
+        component_operation="close",
+        result_component_kind=closure_component_kind,
+        result_component_role="none",
+        result_shape_kind=None,
+        exact_factor=ExactComplexRationalV1.one(),
+        proof_digest=_digest(
+            {**payload, "operation": "close", "port_wiring": port_payload}
+        ),
+        input_port_pairings=tuple(
+            (
+                (
+                    pairing.fundamental.parent_index,
+                    pairing.fundamental.local_port_index,
+                ),
+                (
+                    pairing.antifundamental.parent_index,
+                    pairing.antifundamental.local_port_index,
+                ),
+            )
+            for pairing in port_wiring.input_pairings
+        ),
+        result_port_bindings=(),
+    )
+    payload["transition_witnesses"] = [witness.to_dict()]
+    return ColorContractionTemplateV1(
+        template_id=_token("color", payload),
+        rule_kind="direct-pairing",
+        input_representations=representations,
+        output_representation=None,
+        ordered_open_string_arity=(1 if abs(representations[0]) == 3 else 0),
+        exact_coefficient=ExactComplexRationalV1.one(),
+        nc_polynomial=((0, ExactComplexRationalV1.one()),),
+        expression_digest=_digest(payload),
+        transition_witnesses=(witness,),
+    )
+
+
+def _add_model_parameter_evaluator(
+    prepared_catalog: PreparedKernelCatalog,
+    parameters: Sequence[ParameterTemplateV1],
+    kernels: Mapping[int, Any],
+    evaluator_requests: list[_EvaluatorRequest],
+) -> None:
+    kernel_id = prepared_catalog.model_parameter_kernel_id
+    derived = {
+        parameter.name: parameter
+        for parameter in parameters
+        if parameter.parameter_kind == "derived"
+    }
+    if kernel_id is None:
+        if derived:
+            raise PreparedKernelCatalogError(
+                "derived recurrence parameters have no prepared model-parameter kernel"
+            )
+        return
+    kernel = _kernel(kernels, kernel_id, "model-parameter")
+    if kernel.contract_kind != "model-parameter":
+        raise PreparedKernelCatalogError(
+            "prepared model-parameter binding references the wrong kernel kind"
+        )
+    output_names = tuple(
+        value.removeprefix("model-parameter:") for value in kernel.output_layout
+    )
+    if set(output_names) != set(derived):
+        raise PreparedKernelCatalogError(
+            "prepared model-parameter outputs do not match derived parameters"
+        )
+    for name in output_names:
+        evaluator_requests.append(
+            _EvaluatorRequest(
+                kernel=kernel,
+                contract_kind="model-parameter",
+                input_state_template_ids=(),
+                output_state_template_id=None,
+                semantic_template_id=derived[name].template_id,
+            )
+        )
+
+
+def _coalesce_evaluator_requests(
+    requests: Sequence[_EvaluatorRequest],
+) -> tuple[EvaluatorBindingV1, ...]:
+    groups: dict[
+        tuple[int, str, tuple[str, ...], str | None],
+        list[_EvaluatorRequest],
+    ] = {}
+    for request in requests:
+        key = (
+            int(request.kernel.kernel_id),
+            request.contract_kind,
+            request.input_state_template_ids,
+            request.output_state_template_id,
+        )
+        groups.setdefault(key, []).append(request)
+    result: list[EvaluatorBindingV1] = []
+    for key in sorted(groups, key=_canonical_json):
+        group = groups[key]
+        first = group[0]
+        kernel = first.kernel
+        input_layout = _kernel_input_layout(kernel.inputs)
+        result.append(
+            EvaluatorBindingV1(
+                resolver_key=_resolver_key(
+                    kernel,
+                    first.contract_kind,
+                    first.input_state_template_ids,
+                    first.output_state_template_id,
+                ),
+                prepared_kernel_id=int(kernel.kernel_id),
+                contract_kind=first.contract_kind,  # type: ignore[arg-type]
+                callable_signature=kernel.canonical_signature,
+                input_state_template_ids=first.input_state_template_ids,
+                output_state_template_id=first.output_state_template_id,
+                input_layout=input_layout,
+                output_layout=tuple(str(value) for value in kernel.output_layout),
+                exact_expression_digests=tuple(
+                    _expression_digest(value) for value in kernel.exact_expressions
+                ),
+                semantic_template_ids=tuple(
+                    sorted({item.semantic_template_id for item in group})
+                ),
+            )
+        )
+    return tuple(result)
+
+
+def _kernel_input_layout(inputs: Sequence[PreparedKernelInput]) -> tuple[str, ...]:
+    return tuple(
+        _canonical_json(
+            {
+                "role": item.role,
+                "component": item.component,
+                "symbol": item.symbol,
+                "model_parameter_name": item.model_parameter_name,
+                "model_parameter_index": item.model_parameter_index,
+            }
+        )
+        for item in inputs
+    )
+
+
+def _kernel_parameter_ids(
+    kernel: Any,
+    parameter_ids: Mapping[str, str],
+) -> tuple[str, ...]:
+    names = tuple(
+        sorted(
+            {
+                str(item.model_parameter_name)
+                for item in kernel.inputs
+                if item.model_parameter_name is not None
+            }
+        )
+    )
+    missing = tuple(name for name in names if name not in parameter_ids)
+    if missing:
+        raise RecurrenceTemplateError(
+            "prepared kernel references absent recurrence parameters: "
+            + ", ".join(missing)
+        )
+    return tuple(sorted(parameter_ids[name] for name in names))
+
+
+def _kernel(
+    kernels: Mapping[int, Any],
+    kernel_id: int,
+    context: str,
+) -> Any:
+    try:
+        return kernels[int(kernel_id)]
+    except KeyError as exc:
+        raise PreparedKernelCatalogError(
+            f"prepared {context} binding references unknown kernel {kernel_id}"
+        ) from exc
+
+
+def _validate_binary_kernel_layout(
+    kernel: Any,
+    binding: PreparedVertexBinding | PreparedClosureBinding,
+    *,
+    output_dimension: int,
+    context: str,
+) -> None:
+    canonical_states = tuple(
+        (binding.left_state, binding.right_state)[index]
+        for index in binding.canonical_input_order
+    )
+    expected = {
+        "left-current": canonical_states[0].dimension,
+        "right-current": canonical_states[1].dimension,
+    }
+    for role, dimension in expected.items():
+        components = tuple(
+            item.component for item in kernel.inputs if item.role == role
+        )
+        if len(set(components)) != len(components) or any(
+            component < 0 or component >= dimension for component in components
+        ):
+            raise PreparedKernelCatalogError(
+                f"prepared {context} {role} layout does not match its state dimension"
+            )
+    if len(kernel.output_layout) != output_dimension:
+        raise PreparedKernelCatalogError(
+            f"prepared {context} output layout has dimension "
+            f"{len(kernel.output_layout)}, expected {output_dimension}"
+        )
+
+
+def _validate_propagator_kernel_layout(
+    kernel: Any,
+    binding: PreparedPropagatorBinding,
+) -> None:
+    components = tuple(
+        item.component for item in kernel.inputs if item.role == "current"
+    )
+    if len(set(components)) != len(components) or any(
+        component < 0 or component >= binding.state.dimension
+        for component in components
+    ):
+        raise PreparedKernelCatalogError(
+            f"prepared propagator {binding.key!r} current layout does not match "
+            "its state dimension"
+        )
+    if len(kernel.output_layout) != binding.state.dimension:
+        raise PreparedKernelCatalogError(
+            f"prepared propagator {binding.key!r} output dimension is stale"
+        )
+
+
+def _resolver_key(
+    kernel: Any,
+    contract_kind: str,
+    input_states: tuple[str, ...],
+    output_state: str | None,
+) -> str:
+    return _token(
+        "evaluator",
+        {
+            "kernel_id": int(kernel.kernel_id),
+            "signature": kernel.canonical_signature,
+            "contract_kind": contract_kind,
+            "input_states": input_states,
+            "output_state": output_state,
+        },
+    )
+
+
+def _vertex_binding_payload(binding: PreparedVertexBinding) -> dict[str, object]:
+    return {
+        "kind": binding.key.kind,
+        "particles": list(binding.key.particles),
+        "chiralities": [
+            binding.key.left_chirality,
+            binding.key.right_chirality,
+            binding.key.result_chirality,
+        ],
+        "coupling": _exact_pair(binding.key.coupling, "vertex coupling").to_dict(),
+        "canonical_input_order": list(binding.canonical_input_order),
+        "equivalence_factor": _exact_pair(
+            binding.equivalence_factor, "vertex equivalence factor"
+        ).to_dict(),
+        "output_factor_source": binding.output_factor_source,
+        "contact_orbit_certificates": [
+            item.to_dict() for item in sorted(binding.contact_orbit_certificates)
+        ],
+        "contact_orbit_steps": [
+            item.to_dict() for item in sorted(binding.contact_orbit_steps)
+        ],
+    }
+
+
+def _closure_binding_payload(binding: PreparedClosureBinding) -> dict[str, object]:
+    return {
+        "kind": binding.key.kind,
+        "particles": list(binding.key.particles),
+        "chiralities": [binding.key.left_chirality, binding.key.right_chirality],
+        "coupling": _exact_pair(binding.key.coupling, "closure coupling").to_dict(),
+        "canonical_input_order": list(binding.canonical_input_order),
+        "equivalence_factor": _exact_pair(
+            binding.equivalence_factor, "closure equivalence factor"
+        ).to_dict(),
+        "projection": binding.projection,
+        "output_factor_source": binding.output_factor_source,
+    }
+
+
+def _stable_callback(
+    context: str,
+    callback: Any,
+    *,
+    serializer: Any,
+) -> Any:
+    try:
+        first = callback()
+        first_payload = serializer(first)
+        second = callback()
+        second_payload = serializer(second)
+    except (PreparedKernelCatalogError, RecurrenceTemplateError):
+        raise
+    except Exception as exc:
+        raise RecurrenceTemplateError(f"cannot project {context}: {exc}") from exc
+    if first_payload != second_payload:
+        raise RecurrenceTemplateError(f"{context} is nondeterministic")
+    return first
+
+
+__all__ = ["build_recurrence_template_catalog"]
diff --git a/pyamplicol/src/pyamplicol/models/recurrence_direct_intrinsics.py b/pyamplicol/src/pyamplicol/models/recurrence_direct_intrinsics.py
new file mode 100644
index 0000000000..92775a7ea9
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/recurrence_direct_intrinsics.py
@@ -0,0 +1,559 @@
+# SPDX-License-Identifier: 0BSD
+# ruff: noqa: RUF001
+"""Exact certification of model-generic Direct-Arena recurrence intrinsics."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import json
+import math
+import struct
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+
+from .recurrence_template import ExactComplexRationalV1
+
+
+class _LazyCompilerSymbolica:
+    """Keep planning metadata independent of compiler-module imports."""
+
+    def __getattr__(self, name: str) -> object:
+        module = importlib.import_module(
+            ".compiler_symbolica",
+            package=__package__,
+        )
+        return getattr(module, name)
+
+
+_sym = _LazyCompilerSymbolica()
+
+RECURRENCE_INTRINSIC_SCALE_KIND = "intrinsic-scale-v1"
+WEYL_PROPAGATOR_POSITIVE_TEMPLATE = "rusticol.recurrence-intrinsic.weyl-propagator-a.v1"
+WEYL_PROPAGATOR_NEGATIVE_TEMPLATE = "rusticol.recurrence-intrinsic.weyl-propagator-b.v1"
+FEYNMAN_VECTOR_PROPAGATOR_TEMPLATE = (
+    "rusticol.recurrence-intrinsic.vector-propagator-feynman.v1"
+)
+
+
+@dataclass(frozen=True, slots=True)
+class CertifiedRecurrenceIntrinsic:
+    """One exact algebra witness plus its model-owned scalar scale."""
+
+    runtime_template: str
+    contract_digest: str
+    constant_scale: complex
+    model_parameter_index: int | None
+    parent_permutation: tuple[int, int] = (0, 1)
+
+    def scale_projection(self) -> dict[str, object]:
+        real = 0.0 if self.constant_scale.real == 0.0 else self.constant_scale.real
+        imag = 0.0 if self.constant_scale.imag == 0.0 else self.constant_scale.imag
+        return {
+            "constant_imag_bits": _f64_bits(imag),
+            "constant_real_bits": _f64_bits(real),
+            "kind": RECURRENCE_INTRINSIC_SCALE_KIND,
+            "parameter_index": self.model_parameter_index,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class _IntrinsicWitness:
+    runtime_template: str
+    expressions: tuple[str, ...]
+    anchor_monomial: str
+    inverse_anchor_coefficient: str
+    parent_component_counts: tuple[int, int]
+    destination_component_count: int
+    contract_digest: str = ""
+
+    def __post_init__(self) -> None:
+        payload = {
+            "anchor_monomial": self.anchor_monomial,
+            "destination_component_count": self.destination_component_count,
+            "expressions": list(self.expressions),
+            "inverse_anchor_coefficient": self.inverse_anchor_coefficient,
+            "parent_component_counts": list(self.parent_component_counts),
+            "runtime_template": self.runtime_template,
+        }
+        digest = hashlib.sha256(
+            json.dumps(
+                payload,
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            ).encode("ascii")
+        ).hexdigest()
+        object.__setattr__(self, "contract_digest", digest)
+
+
+_WITNESSES = (
+    _IntrinsicWitness(
+        runtime_template=(
+            "rusticol.recurrence-intrinsic.color-ordered-three-vector.v1"
+        ),
+        expressions=(
+            "(l0*r0-l1*r1-l2*r2-l3*r3)*(p0-q0)"
+            "+2*((l0*q0-l1*q1-l2*q2-l3*q3)*r0"
+            "-(r0*p0-r1*p1-r2*p2-r3*p3)*l0)",
+            "(l0*r0-l1*r1-l2*r2-l3*r3)*(p1-q1)"
+            "+2*((l0*q0-l1*q1-l2*q2-l3*q3)*r1"
+            "-(r0*p0-r1*p1-r2*p2-r3*p3)*l1)",
+            "(l0*r0-l1*r1-l2*r2-l3*r3)*(p2-q2)"
+            "+2*((l0*q0-l1*q1-l2*q2-l3*q3)*r2"
+            "-(r0*p0-r1*p1-r2*p2-r3*p3)*l2)",
+            "(l0*r0-l1*r1-l2*r2-l3*r3)*(p3-q3)"
+            "+2*((l0*q0-l1*q1-l2*q2-l3*q3)*r3"
+            "-(r0*p0-r1*p1-r2*p2-r3*p3)*l3)",
+        ),
+        anchor_monomial="l0*p0*r0",
+        inverse_anchor_coefficient="-1",
+        parent_component_counts=(4, 4),
+        destination_component_count=4,
+    ),
+    _IntrinsicWitness(
+        runtime_template=("rusticol.recurrence-intrinsic.weyl-vector-to-weyl-a.v1"),
+        expressions=(
+            "-1𝑖*l0*r3-1𝑖*l1*r1+l1*r2+1𝑖*l0*r0",
+            "-l0*r2-1𝑖*l0*r1+1𝑖*l1*r0+1𝑖*l1*r3",
+        ),
+        anchor_monomial="l0*r3",
+        inverse_anchor_coefficient="1𝑖",
+        parent_component_counts=(2, 4),
+        destination_component_count=2,
+    ),
+    _IntrinsicWitness(
+        runtime_template=("rusticol.recurrence-intrinsic.weyl-vector-to-weyl-b.v1"),
+        expressions=(
+            "-l1*r2+1𝑖*l0*r0+1𝑖*l0*r3+1𝑖*l1*r1",
+            "-1𝑖*l1*r3+l0*r2+1𝑖*l0*r1+1𝑖*l1*r0",
+        ),
+        anchor_monomial="l1*r2",
+        inverse_anchor_coefficient="-1",
+        parent_component_counts=(2, 4),
+        destination_component_count=2,
+    ),
+    _IntrinsicWitness(
+        runtime_template=(
+            "rusticol.recurrence-intrinsic.antisymmetric-tensor-vector.v1"
+        ),
+        expressions=(
+            "l0*r1+l1*r2+l2*r3",
+            "l0*r0+l3*r2+l4*r3",
+            "-l3*r1+l1*r0+l5*r3",
+            "-l4*r1-l5*r2+l2*r0",
+        ),
+        anchor_monomial="l0*r1",
+        inverse_anchor_coefficient="1",
+        parent_component_counts=(6, 4),
+        destination_component_count=4,
+    ),
+    _IntrinsicWitness(
+        runtime_template=("rusticol.recurrence-intrinsic.vector-wedge-vector.v1"),
+        expressions=(
+            "-l1*r0+l0*r1",
+            "-l2*r0+l0*r2",
+            "-l3*r0+l0*r3",
+            "-l2*r1+l1*r2",
+            "-l3*r1+l1*r3",
+            "-l3*r2+l2*r3",
+        ),
+        anchor_monomial="l1*r0",
+        inverse_anchor_coefficient="-1",
+        parent_component_counts=(4, 4),
+        destination_component_count=6,
+    ),
+)
+
+RECURRENCE_INTRINSIC_RUNTIME_TEMPLATES = frozenset(
+    witness.runtime_template for witness in _WITNESSES
+)
+RECURRENCE_INTRINSIC_CONTRACT_DIGESTS = {
+    witness.runtime_template: witness.contract_digest for witness in _WITNESSES
+}
+
+
+@dataclass(frozen=True, slots=True)
+class _FinalizationWitness:
+    runtime_template: str
+    expressions: tuple[str, ...]
+    anchor_monomial: str
+    inverse_anchor_coefficient: str
+    component_count: int
+
+
+_FINALIZATION_WITNESSES = (
+    _FinalizationWitness(
+        runtime_template=WEYL_PROPAGATOR_POSITIVE_TEMPLATE,
+        expressions=(
+            "((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*(-1𝑖*l0*p3-1𝑖*l1*p1+l1*p2+1𝑖*l0*p0)",
+            "((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*(-l0*p2-1𝑖*l0*p1+1𝑖*l1*p0+1𝑖*l1*p3)",
+        ),
+        anchor_monomial="((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*l0*p3",
+        inverse_anchor_coefficient="1𝑖",
+        component_count=2,
+    ),
+    _FinalizationWitness(
+        runtime_template=WEYL_PROPAGATOR_NEGATIVE_TEMPLATE,
+        expressions=(
+            "((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*(-l1*p2+1𝑖*l0*p0+1𝑖*l0*p3+1𝑖*l1*p1)",
+            "((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*(-1𝑖*l1*p3+l0*p2+1𝑖*l0*p1+1𝑖*l1*p0)",
+        ),
+        anchor_monomial="((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*l1*p2",
+        inverse_anchor_coefficient="-1",
+        component_count=2,
+    ),
+    _FinalizationWitness(
+        runtime_template=FEYNMAN_VECTOR_PROPAGATOR_TEMPLATE,
+        expressions=(
+            "((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*l0",
+            "((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*l1",
+            "((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*l2",
+            "((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*l3",
+        ),
+        anchor_monomial="((-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1))*l0",
+        inverse_anchor_coefficient="1",
+        component_count=4,
+    ),
+)
+
+
+def certify_recurrence_contribution_intrinsic(
+    *,
+    exact_expressions: Sequence[str],
+    input_contracts: Sequence[str],
+    parent_component_counts: tuple[int, ...],
+    destination_component_count: int,
+    binding_coupling: ExactComplexRationalV1 | None,
+    allow_nontrivial_parent_permutation: bool = False,
+) -> CertifiedRecurrenceIntrinsic | None:
+    """Prove that one prepared kernel is exactly one known arena primitive.
+
+    Model-owned namespaces and parameter numbers do not participate in the
+    witness identity. Coupling inputs are first replaced by the exact
+    recurrence binding. A remaining scalar may be either a finite numerical
+    constant or that constant times one model parameter.
+
+    A prepared model may expose the same commutative vertex with its two
+    parents in the opposite order. Such a certificate records the exact
+    canonical-to-prepared permutation. Non-trivial permutations are rejected
+    by default because the current Direct-Arena payload has no permutation
+    field; a caller must opt in only when it will consume the permutation.
+    """
+
+    if (
+        len(parent_component_counts) != 2
+        or not exact_expressions
+        or len(exact_expressions) != destination_component_count
+    ):
+        return None
+    try:
+        candidates = _normalization_candidates(
+            exact_expressions,
+            input_contracts,
+            parent_component_counts=parent_component_counts,
+            binding_coupling=binding_coupling,
+            allow_nontrivial_parent_permutation=(allow_nontrivial_parent_permutation),
+        )
+    except (TypeError, ValueError):
+        return None
+
+    _sym._ensure_symbolica()
+    for (
+        normalized,
+        parameter_symbols,
+        parent_permutation,
+        normalized_shape,
+    ) in candidates:
+        for witness in _WITNESSES:
+            if (
+                witness.parent_component_counts != normalized_shape
+                or witness.destination_component_count != destination_component_count
+            ):
+                continue
+            references = tuple(_sym.E(value).expand() for value in witness.expressions)
+            coefficient = normalized[0].coefficient(_sym.E(witness.anchor_monomial))
+            scale = (coefficient * _sym.E(witness.inverse_anchor_coefficient)).expand()
+            if any(
+                not bool(candidate == (scale * reference).expand())
+                for candidate, reference in zip(normalized, references, strict=True)
+            ):
+                continue
+            scalar = _extract_scalar_scale(scale, parameter_symbols)
+            if scalar is None:
+                continue
+            constant, parameter_index = scalar
+            return CertifiedRecurrenceIntrinsic(
+                runtime_template=witness.runtime_template,
+                contract_digest=witness.contract_digest,
+                constant_scale=constant,
+                model_parameter_index=parameter_index,
+                parent_permutation=parent_permutation,
+            )
+    return None
+
+
+def certify_recurrence_finalization_intrinsic(
+    *,
+    exact_expressions: Sequence[str],
+    input_contracts: Sequence[str],
+    component_count: int,
+) -> str | None:
+    """Prove that one prepared propagator/finalizer is one known arena primitive."""
+
+    if not exact_expressions or len(exact_expressions) != component_count:
+        return None
+    try:
+        normalized, parameter_symbols = _normalized_expressions(
+            exact_expressions,
+            input_contracts,
+            binding_coupling=None,
+        )
+    except (TypeError, ValueError):
+        return None
+    if parameter_symbols:
+        return None
+
+    _sym._ensure_symbolica()
+    for witness in _FINALIZATION_WITNESSES:
+        if witness.component_count != component_count:
+            continue
+        references = tuple(_sym.E(value).expand() for value in witness.expressions)
+        coefficient = normalized[0].coefficient(_sym.E(witness.anchor_monomial))
+        scale = (coefficient * _sym.E(witness.inverse_anchor_coefficient)).expand()
+        if any(
+            not bool(candidate == (scale * reference).expand())
+            for candidate, reference in zip(normalized, references, strict=True)
+        ):
+            continue
+        return witness.runtime_template
+    return None
+
+
+def _normalized_expressions(
+    exact_expressions: Sequence[str],
+    input_contracts: Sequence[str],
+    *,
+    binding_coupling: ExactComplexRationalV1 | None,
+    parent_permutation: tuple[int, int] = (0, 1),
+) -> tuple[tuple[object, ...], dict[str, int]]:
+    _sym._ensure_symbolica()
+    if parent_permutation not in {(0, 1), (1, 0)}:
+        raise ValueError("intrinsic parent permutation is not binary")
+    raw_to_canonical = {
+        raw_parent: canonical_parent
+        for canonical_parent, raw_parent in enumerate(parent_permutation)
+    }
+    replacements: list[object] = []
+    parameter_symbols: dict[str, int] = {}
+    declared: set[str] = set()
+    for raw in input_contracts:
+        contract = json.loads(raw)
+        if not isinstance(contract, Mapping):
+            raise ValueError("prepared input contract is not an object")
+        role = contract.get("role")
+        component = contract.get("component")
+        symbol = contract.get("symbol")
+        if (
+            not isinstance(role, str)
+            or type(component) is not int
+            or component < 0
+            or not isinstance(symbol, str)
+            or not symbol
+        ):
+            raise ValueError("prepared input contract is malformed")
+        if symbol in declared:
+            continue
+        declared.add(symbol)
+        source = _sym.E(symbol)
+        if role in {"coupling-real", "coupling-imag"}:
+            if binding_coupling is None:
+                raise ValueError("intrinsic coupling input has no exact binding")
+            value = (
+                binding_coupling.real
+                if role == "coupling-real"
+                else binding_coupling.imag
+            )
+            target = _sym.E(f"({value.numerator})/({value.denominator})")
+        elif role == "model-parameter":
+            parameter_index = contract.get("model_parameter_index")
+            if type(parameter_index) is not int or parameter_index < 0:
+                raise ValueError("model-parameter input has no stable index")
+            target = _sym.Expression.symbol(
+                f"recurrence_intrinsic::parameter_{parameter_index}"
+            )
+            parameter_symbols[target.to_canonical_string()] = parameter_index
+        else:
+            if role in {"current", "momentum"}:
+                prefix = "l" if role == "current" else "p"
+            elif role in {
+                "left-current",
+                "left-momentum",
+                "right-current",
+                "right-momentum",
+            }:
+                raw_parent = 0 if role.startswith("left-") else 1
+                canonical_parent = raw_to_canonical[raw_parent]
+                prefix = (
+                    ("l", "r")[canonical_parent]
+                    if role.endswith("-current")
+                    else ("p", "q")[canonical_parent]
+                )
+            else:
+                prefix = None
+            if prefix is None:
+                raise ValueError(f"unsupported intrinsic input role {role!r}")
+            target = _sym.Expression.symbol(f"{prefix}{component}")
+        replacements.append(_sym.Replacement(source, target))
+
+    normalized = tuple(
+        _exact_binary64_coefficients(_sym.E(value))
+        .replace_multiple(replacements)
+        .expand()
+        for value in exact_expressions
+    )
+    allowed = set(parameter_symbols)
+    used = {
+        symbol.to_canonical_string()
+        for expression in normalized
+        for symbol in expression.get_all_symbols(False)
+    }
+    if not used.issubset(
+        allowed
+        | {
+            _sym.Expression.symbol(f"{side}{component}").to_canonical_string()
+            for side in ("l", "p", "q", "r")
+            for component in range(64)
+        }
+    ):
+        raise ValueError("normalized intrinsic retains an undeclared symbol")
+    return normalized, parameter_symbols
+
+
+def _exact_binary64_coefficients(expression: object) -> object:
+    """Compare coefficients exactly, including floating representations of units.
+
+    Only the temporary certification expression is changed. A binary64 number
+    is replaced by the rational with exactly the same value, not a nearby
+    rational approximation. This also prevents a floating unit from rounding
+    away a small rational difference during the algebraic comparison.
+    """
+    return _sym._exact_binary64_coefficients(expression)
+
+
+def _normalization_candidates(
+    exact_expressions: Sequence[str],
+    input_contracts: Sequence[str],
+    *,
+    parent_component_counts: tuple[int, ...],
+    binding_coupling: ExactComplexRationalV1 | None,
+    allow_nontrivial_parent_permutation: bool,
+) -> tuple[
+    tuple[
+        tuple[object, ...],
+        dict[str, int],
+        tuple[int, int],
+        tuple[int, int],
+    ],
+    ...,
+]:
+    if len(parent_component_counts) != 2:
+        raise ValueError("contribution intrinsic must have two parents")
+    raw_shape = _binary_parent_shape(input_contracts)
+    if raw_shape != parent_component_counts:
+        raise ValueError(
+            "prepared current-input shape disagrees with recurrence parent shape"
+        )
+    permutations = [(0, 1)]
+    if allow_nontrivial_parent_permutation:
+        permutations.append((1, 0))
+    return tuple(
+        (
+            *_normalized_expressions(
+                exact_expressions,
+                input_contracts,
+                binding_coupling=binding_coupling,
+                parent_permutation=parent_permutation,
+            ),
+            parent_permutation,
+            tuple(raw_shape[index] for index in parent_permutation),
+        )
+        for parent_permutation in permutations
+    )
+
+
+def _binary_parent_shape(
+    input_contracts: Sequence[str],
+) -> tuple[int, int]:
+    components: dict[str, set[int]] = {
+        "left-current": set(),
+        "right-current": set(),
+    }
+    for raw in input_contracts:
+        contract = json.loads(raw)
+        if not isinstance(contract, Mapping):
+            raise ValueError("prepared input contract is not an object")
+        role = contract.get("role")
+        if role not in components:
+            continue
+        component = contract.get("component")
+        if type(component) is not int or component < 0:
+            raise ValueError("prepared current-input component is malformed")
+        if component in components[role]:
+            raise ValueError("prepared current-input component is duplicated")
+        components[role].add(component)
+    shape: list[int] = []
+    for role in ("left-current", "right-current"):
+        values = components[role]
+        if not values or values != set(range(max(values) + 1)):
+            raise ValueError(f"prepared {role} components are not a contiguous basis")
+        shape.append(len(values))
+    return shape[0], shape[1]
+
+
+def _extract_scalar_scale(
+    scale: object,
+    parameter_symbols: Mapping[str, int],
+) -> tuple[complex, int | None] | None:
+    _sym._ensure_symbolica()
+    used = {symbol.to_canonical_string() for symbol in scale.get_all_symbols(False)}
+    if not used:
+        coefficient = scale
+        parameter_index = None
+    elif len(used) == 1 and next(iter(used)) in parameter_symbols:
+        canonical = next(iter(used))
+        parameter = next(
+            symbol
+            for symbol in scale.get_all_symbols(False)
+            if symbol.to_canonical_string() == canonical
+        )
+        coefficient = scale.coefficient(parameter)
+        if not bool(scale == (coefficient * parameter).expand()):
+            return None
+        parameter_index = parameter_symbols[canonical]
+    else:
+        return None
+    if coefficient.get_all_symbols(False):
+        return None
+    try:
+        value = complex(coefficient.evaluate({}))
+    except (TypeError, ValueError):
+        return None
+    if not math.isfinite(value.real) or not math.isfinite(value.imag) or value == 0.0:
+        return None
+    return value, parameter_index
+
+
+def _f64_bits(value: float) -> int:
+    return struct.unpack("<Q", struct.pack("<d", value))[0]
+
+
+__all__ = [
+    "RECURRENCE_INTRINSIC_CONTRACT_DIGESTS",
+    "RECURRENCE_INTRINSIC_RUNTIME_TEMPLATES",
+    "RECURRENCE_INTRINSIC_SCALE_KIND",
+    "CertifiedRecurrenceIntrinsic",
+    "certify_recurrence_contribution_intrinsic",
+    "certify_recurrence_finalization_intrinsic",
+]
diff --git a/pyamplicol/src/pyamplicol/models/recurrence_direct_template.py b/pyamplicol/src/pyamplicol/models/recurrence_direct_template.py
new file mode 100644
index 0000000000..d0c9239d5d
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/recurrence_direct_template.py
@@ -0,0 +1,2301 @@
+# SPDX-License-Identifier: 0BSD
+"""Prepared model metadata for Direct-Arena recurrence executors.
+
+This module deliberately describes executable ownership without adapting the
+existing packed eager-kernel ABI. Portable JIT bindings reference a standard
+SymJIT direct-arena P-kernel and authenticate Rusticol-owned plane, broadcast,
+scratch-output, and destination-policy metadata. Target-native C++/ASM bindings
+reference a split-real shared library that exports the same typed arena/row
+contract directly.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, replace
+from typing import Literal, TypeAlias, cast
+
+from .._internal.versions import (
+    RECURRENCE_DIRECT_BINDING_ABI,
+    SYMJIT_PLANE_APPLICATION_ABI,
+)
+from .recurrence_direct_intrinsics import (
+    RECURRENCE_INTRINSIC_SCALE_KIND,
+    CertifiedRecurrenceIntrinsic,
+    certify_recurrence_contribution_intrinsic,
+    certify_recurrence_finalization_intrinsic,
+)
+from .recurrence_template import (
+    ExactComplexRationalV1,
+    RecurrenceTemplateCatalog,
+)
+
+RECURRENCE_DIRECT_TEMPLATE_ABI = "pyamplicol-recurrence-direct-template-v1"
+RECURRENCE_DIRECT_BACKEND_ABI = "rusticol.recurrence-direct-backend.v1"
+RECURRENCE_DIRECT_CANONICALIZATION_ABI = "pyamplicol-canonical-json-v1"
+RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI = RECURRENCE_DIRECT_BINDING_ABI
+RECURRENCE_DIRECT_IDENTITY_FINALIZER = "rusticol.identity-finalize-in-place.v1"
+SYMJIT_DIRECT_APPLICATION_ABI = SYMJIT_PLANE_APPLICATION_ABI
+NATIVE_DIRECT_APPLICATION_ABI = "pyamplicol-recurrence-native-direct-library-v1"
+
+DirectRole: TypeAlias = Literal["source", "contribution", "finalization", "closure"]
+DirectDestinationOperation: TypeAlias = Literal[
+    "initialize", "add", "finalize-in-place", "closure-add"
+]
+DirectBackend: TypeAlias = Literal["jit", "cpp", "asm"]
+DirectPayloadBindingKind: TypeAlias = Literal[
+    "rusticol-intrinsic",
+    "prepared-direct-call",
+    "pending-direct-call-abi",
+]
+
+_ROLES = ("source", "contribution", "finalization", "closure")
+_ROLE_INDEX = {role: index for index, role in enumerate(_ROLES)}
+_DESTINATION_OPERATIONS = {
+    "source": "initialize",
+    "contribution": "add",
+    "finalization": "finalize-in-place",
+    "closure": "closure-add",
+}
+_CONTRACT_ROLES = {
+    "source": "source",
+    "vertex": "contribution",
+    "propagator": "finalization",
+    "closure": "closure",
+}
+_BACKENDS = frozenset({"jit", "cpp", "asm"})
+_PAYLOAD_BINDING_KINDS = frozenset(
+    {"rusticol-intrinsic", "prepared-direct-call", "pending-direct-call-abi"}
+)
+_NATIVE_SOURCE_APPLICATION_ABIS = frozenset(
+    {
+        "symbolica.compiled-cpp.complex-f64.v1",
+        "symbolica.compiled-asm.complex-f64.v1",
+    }
+)
+_HEX = frozenset("0123456789abcdef")
+
+
+class RecurrenceDirectTemplateError(ValueError):
+    """Raised when a prepared Direct-Arena companion is not canonical."""
+
+
+def _canonical_json(payload: object) -> str:
+    try:
+        return json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+    except (TypeError, ValueError) as exc:
+        raise RecurrenceDirectTemplateError(
+            "direct recurrence template payload is not canonical JSON"
+        ) from exc
+
+
+def _digest(payload: object) -> str:
+    return hashlib.sha256(_canonical_json(payload).encode("ascii")).hexdigest()
+
+
+def _require_nonempty(name: str, value: object) -> str:
+    if not isinstance(value, str) or not value:
+        raise RecurrenceDirectTemplateError(f"{name} must be a nonempty string")
+    return value
+
+
+def _require_sha256(name: str, value: object) -> str:
+    if (
+        not isinstance(value, str)
+        or len(value) != 64
+        or any(character not in _HEX for character in value)
+    ):
+        raise RecurrenceDirectTemplateError(f"{name} must be a lowercase SHA-256")
+    return value
+
+
+def _require_nonnegative_int(name: str, value: object) -> int:
+    if type(value) is not int or value < 0:
+        raise RecurrenceDirectTemplateError(f"{name} must be a nonnegative integer")
+    return value
+
+
+def _require_positive_int(name: str, value: object) -> int:
+    result = _require_nonnegative_int(name, value)
+    if result == 0:
+        raise RecurrenceDirectTemplateError(f"{name} must be positive")
+    return result
+
+
+def _require_string_tuple(
+    name: str,
+    value: object,
+    *,
+    nonempty: bool = False,
+    sorted_unique: bool = False,
+) -> tuple[str, ...]:
+    if not isinstance(value, tuple) or any(
+        not isinstance(item, str) or not item for item in value
+    ):
+        raise RecurrenceDirectTemplateError(
+            f"{name} must be an immutable nonempty-string tuple"
+        )
+    result = tuple(value)
+    if nonempty and not result:
+        raise RecurrenceDirectTemplateError(f"{name} must not be empty")
+    if sorted_unique and result != tuple(sorted(set(result))):
+        raise RecurrenceDirectTemplateError(f"{name} must be sorted and unique")
+    return result
+
+
+def _require_int_tuple(name: str, value: object) -> tuple[int, ...]:
+    if not isinstance(value, tuple) or any(type(item) is not int for item in value):
+        raise RecurrenceDirectTemplateError(
+            f"{name} must be an immutable integer tuple"
+        )
+    if any(item < 0 for item in value):
+        raise RecurrenceDirectTemplateError(f"{name} must be nonnegative")
+    return value
+
+
+def _encode_canonical_objects(value: Sequence[object]) -> tuple[str, ...]:
+    return tuple(_canonical_json(item) for item in value)
+
+
+def _decode_canonical_objects(value: Sequence[str]) -> list[object]:
+    return [json.loads(item) for item in value]
+
+
+def _require_canonical_object_tuple(name: str, value: object) -> tuple[str, ...]:
+    strings = _require_string_tuple(name, value)
+    for item in strings:
+        try:
+            decoded = json.loads(item)
+        except json.JSONDecodeError as exc:
+            raise RecurrenceDirectTemplateError(
+                f"{name} must contain canonical JSON objects"
+            ) from exc
+        if not isinstance(decoded, Mapping) or _canonical_json(decoded) != item:
+            raise RecurrenceDirectTemplateError(
+                f"{name} must contain canonical JSON objects"
+            )
+    return strings
+
+
+def _require_empty_prepared_call_metadata(
+    binding: RecurrenceDirectPayloadBindingV1,
+) -> None:
+    fields = {
+        "destination_operation": binding.destination_operation,
+        "direct_application_abi": binding.direct_application_abi,
+        "exact_factor_scalar_slots": binding.exact_factor_scalar_slots,
+        "input_plane_count": binding.input_plane_count,
+        "input_plane_projections": binding.input_plane_projections,
+        "native_entry_point": binding.native_entry_point,
+        "output_alias_inputs": binding.output_alias_inputs,
+        "parameter_bindings": binding.parameter_bindings,
+        "prepared_template_semantic_digest": (
+            binding.prepared_template_semantic_digest
+        ),
+        "role": binding.role,
+        "scalar_input_count": binding.scalar_input_count,
+        "scalar_projections": binding.scalar_projections,
+        "source_application_abi": binding.source_application_abi,
+        "source_application_path": binding.source_application_path,
+        "source_application_sha256": binding.source_application_sha256,
+        "state_plane_indices": binding.state_plane_indices,
+    }
+    if any(value not in (None, (), 0) for value in fields.values()):
+        raise RecurrenceDirectTemplateError(
+            "non-executable direct bindings cannot carry prepared-call metadata"
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceDirectPayloadBindingV1:
+    """Typed ownership of one executor's f64 implementation payload."""
+
+    kind: DirectPayloadBindingKind
+    payload_digest: str
+    prepared_kernel_id: int | None = None
+    runtime_template: str | None = None
+    payload_paths: tuple[str, ...] = ()
+    source_application_path: str | None = None
+    source_application_sha256: str | None = None
+    source_application_abi: str | None = None
+    direct_application_abi: str | None = None
+    native_entry_point: str | None = None
+    role: DirectRole | None = None
+    destination_operation: DirectDestinationOperation | None = None
+    exact_factor_scalar_slots: tuple[int, ...] = ()
+    state_plane_indices: tuple[int, ...] = ()
+    parameter_bindings: tuple[str, ...] = ()
+    input_plane_count: int = 0
+    scalar_input_count: int = 0
+    output_alias_inputs: tuple[int, ...] = ()
+    input_plane_projections: tuple[str, ...] = ()
+    scalar_projections: tuple[str, ...] = ()
+    intrinsic_contract_digest: str | None = None
+    prepared_template_semantic_digest: str | None = None
+    contribution_parent_permutation: tuple[int, int] = (0, 1)
+    abi: str = RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI
+
+    def __post_init__(self) -> None:
+        if self.abi != RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI:
+            raise RecurrenceDirectTemplateError(
+                f"unsupported direct payload-binding ABI {self.abi!r}; "
+                "regenerate the prepared model with this pyAmpliCol version"
+            )
+        if self.kind not in _PAYLOAD_BINDING_KINDS:
+            raise RecurrenceDirectTemplateError(
+                f"unsupported direct payload-binding kind {self.kind!r}"
+            )
+        _require_sha256("direct payload digest", self.payload_digest)
+        paths = _require_string_tuple(
+            "direct payload paths", self.payload_paths, sorted_unique=True
+        )
+        parameter_bindings = _require_canonical_object_tuple(
+            "direct parameter bindings", self.parameter_bindings
+        )
+        input_projections = _require_canonical_object_tuple(
+            "direct input-plane projections", self.input_plane_projections
+        )
+        scalar_projections = _require_canonical_object_tuple(
+            "direct scalar projections", self.scalar_projections
+        )
+        exact_factor_slots = _require_int_tuple(
+            "direct exact-factor scalar slots", self.exact_factor_scalar_slots
+        )
+        state_planes = _require_int_tuple(
+            "direct state-plane indices", self.state_plane_indices
+        )
+        output_aliases = _require_int_tuple(
+            "direct output-alias inputs", self.output_alias_inputs
+        )
+        parent_permutation = _require_int_tuple(
+            "direct contribution parent permutation",
+            self.contribution_parent_permutation,
+        )
+        if parent_permutation not in {(0, 1), (1, 0)}:
+            raise RecurrenceDirectTemplateError(
+                "direct contribution parent permutation must be (0, 1) or (1, 0)"
+            )
+        input_plane_count = _require_nonnegative_int(
+            "direct input-plane count", self.input_plane_count
+        )
+        scalar_input_count = _require_nonnegative_int(
+            "direct scalar-input count", self.scalar_input_count
+        )
+        if self.kind == "rusticol-intrinsic":
+            if self.prepared_kernel_id is not None or not self.runtime_template:
+                raise RecurrenceDirectTemplateError(
+                    "Rusticol direct intrinsics require a runtime template and "
+                    "cannot reference a prepared kernel"
+                )
+            if paths:
+                raise RecurrenceDirectTemplateError(
+                    "Rusticol direct intrinsics cannot reference bundle payloads"
+                )
+            if self.role == "contribution":
+                if (
+                    self.destination_operation != "add"
+                    or self.scalar_input_count != 1
+                    or len(scalar_projections) != 1
+                    or self.intrinsic_contract_digest is None
+                ):
+                    raise RecurrenceDirectTemplateError(
+                        "contribution intrinsics require one certified scale"
+                    )
+                projection = json.loads(scalar_projections[0])
+                if projection.get("kind") != RECURRENCE_INTRINSIC_SCALE_KIND:
+                    raise RecurrenceDirectTemplateError(
+                        "contribution intrinsic scale has an unsupported kind"
+                    )
+                _require_sha256(
+                    "intrinsic contract digest", self.intrinsic_contract_digest
+                )
+                expected_payload_digest = _digest(
+                    {
+                        "abi": self.abi,
+                        "destination_operation": self.destination_operation,
+                        "contribution_parent_permutation": list(parent_permutation),
+                        "intrinsic_contract_digest": (self.intrinsic_contract_digest),
+                        "kind": self.kind,
+                        "role": self.role,
+                        "runtime_template": self.runtime_template,
+                        "scalar_input_count": self.scalar_input_count,
+                        "scalar_projections": [json.loads(scalar_projections[0])],
+                    }
+                )
+                if self.payload_digest != expected_payload_digest:
+                    raise RecurrenceDirectTemplateError(
+                        "contribution intrinsic payload digest does not match "
+                        "its certified metadata"
+                    )
+                if any(
+                    value not in (None, (), 0)
+                    for value in (
+                        self.direct_application_abi,
+                        exact_factor_slots,
+                        input_plane_count,
+                        input_projections,
+                        output_aliases,
+                        parameter_bindings,
+                        self.prepared_template_semantic_digest,
+                        self.source_application_abi,
+                        self.source_application_path,
+                        self.source_application_sha256,
+                        state_planes,
+                    )
+                ):
+                    raise RecurrenceDirectTemplateError(
+                        "contribution intrinsics carry prepared-call metadata"
+                    )
+            else:
+                if parent_permutation != (0, 1):
+                    raise RecurrenceDirectTemplateError(
+                        "non-contribution intrinsics require the identity "
+                        "parent permutation"
+                    )
+                if self.intrinsic_contract_digest is not None:
+                    raise RecurrenceDirectTemplateError(
+                        "non-contribution intrinsics cannot carry a contract digest"
+                    )
+                _require_empty_prepared_call_metadata(self)
+        else:
+            if parent_permutation != (0, 1):
+                raise RecurrenceDirectTemplateError(
+                    "prepared direct payloads require the identity parent permutation"
+                )
+            _require_nonnegative_int(
+                "direct prepared kernel id", self.prepared_kernel_id
+            )
+            if self.intrinsic_contract_digest is not None:
+                raise RecurrenceDirectTemplateError(
+                    "prepared direct payloads cannot carry an intrinsic contract"
+                )
+            if self.runtime_template is not None:
+                raise RecurrenceDirectTemplateError(
+                    "prepared direct payloads cannot name a Rusticol template"
+                )
+            if self.kind == "pending-direct-call-abi" and paths:
+                raise RecurrenceDirectTemplateError(
+                    "pending direct-call bindings cannot claim executable payloads"
+                )
+            if self.kind == "prepared-direct-call" and not paths:
+                raise RecurrenceDirectTemplateError(
+                    "prepared direct-call bindings require executable payload paths"
+                )
+            if self.kind == "pending-direct-call-abi":
+                _require_empty_prepared_call_metadata(self)
+            else:
+                source_path = _require_nonempty(
+                    "direct source application path", self.source_application_path
+                )
+                if paths != (source_path,):
+                    raise RecurrenceDirectTemplateError(
+                        "prepared direct-call payload paths must contain exactly "
+                        "the source application"
+                    )
+                _require_sha256(
+                    "direct source application digest",
+                    self.source_application_sha256,
+                )
+                _require_nonempty(
+                    "direct source application ABI", self.source_application_abi
+                )
+                if self.direct_application_abi not in {
+                    SYMJIT_DIRECT_APPLICATION_ABI,
+                    NATIVE_DIRECT_APPLICATION_ABI,
+                }:
+                    raise RecurrenceDirectTemplateError(
+                        "prepared direct-call binding has an unsupported direct "
+                        "application ABI"
+                    )
+                if self.direct_application_abi == SYMJIT_DIRECT_APPLICATION_ABI:
+                    if self.native_entry_point is not None:
+                        raise RecurrenceDirectTemplateError(
+                            "prepared JIT direct-call bindings cannot name a native "
+                            "entry point"
+                        )
+                else:
+                    _require_nonempty(
+                        "native direct-call entry point", self.native_entry_point
+                    )
+                if self.role not in _ROLE_INDEX or self.role == "source":
+                    raise RecurrenceDirectTemplateError(
+                        "prepared direct-call role must be a non-source executor role"
+                    )
+                if self.destination_operation != _DESTINATION_OPERATIONS[self.role]:
+                    raise RecurrenceDirectTemplateError(
+                        "prepared direct-call destination operation does not match "
+                        "its role"
+                    )
+                if exact_factor_slots != (0, 1):
+                    raise RecurrenceDirectTemplateError(
+                        "prepared direct-call bindings must reserve exact-factor "
+                        "scalar slots 0 and 1"
+                    )
+                if len(input_projections) != input_plane_count:
+                    raise RecurrenceDirectTemplateError(
+                        "direct input-plane projection count does not match "
+                        "input_plane_count"
+                    )
+                if len(scalar_projections) != scalar_input_count:
+                    raise RecurrenceDirectTemplateError(
+                        "direct scalar projection count does not match "
+                        "scalar_input_count"
+                    )
+                for name, values, upper_bound in (
+                    ("state-plane", state_planes, input_plane_count),
+                    ("output-alias", output_aliases, input_plane_count),
+                ):
+                    if any(value >= upper_bound for value in values):
+                        raise RecurrenceDirectTemplateError(
+                            f"direct {name} index is out of bounds"
+                        )
+                _require_sha256(
+                    "prepared direct template semantic digest",
+                    self.prepared_template_semantic_digest,
+                )
+                expected_payload_digest = _digest(
+                    self._prepared_call_fields(include_payload_digest=False)
+                )
+                if self.payload_digest != expected_payload_digest:
+                    raise RecurrenceDirectTemplateError(
+                        "prepared direct-call payload digest does not match metadata"
+                    )
+                if len(parameter_bindings) == 0:
+                    raise RecurrenceDirectTemplateError(
+                        "prepared direct-call binding must map source parameters"
+                    )
+
+    @property
+    def executable(self) -> bool:
+        return self.kind != "pending-direct-call-abi"
+
+    def to_dict(self) -> dict[str, object]:
+        return self._prepared_call_fields(include_payload_digest=True)
+
+    def _prepared_call_fields(
+        self, *, include_payload_digest: bool
+    ) -> dict[str, object]:
+        payload = {
+            "abi": self.abi,
+            "contribution_parent_permutation": list(
+                self.contribution_parent_permutation
+            ),
+            "destination_operation": self.destination_operation,
+            "direct_application_abi": self.direct_application_abi,
+            "exact_factor_scalar_slots": list(self.exact_factor_scalar_slots),
+            "input_plane_count": self.input_plane_count,
+            "input_plane_projections": _decode_canonical_objects(
+                self.input_plane_projections
+            ),
+            "intrinsic_contract_digest": self.intrinsic_contract_digest,
+            "kind": self.kind,
+            "output_alias_inputs": list(self.output_alias_inputs),
+            "parameter_bindings": _decode_canonical_objects(self.parameter_bindings),
+            "payload_paths": list(self.payload_paths),
+            "prepared_kernel_id": self.prepared_kernel_id,
+            "prepared_template_semantic_digest": (
+                self.prepared_template_semantic_digest
+            ),
+            "role": self.role,
+            "runtime_template": self.runtime_template,
+            "scalar_input_count": self.scalar_input_count,
+            "scalar_projections": _decode_canonical_objects(self.scalar_projections),
+            "source_application_abi": self.source_application_abi,
+            "source_application_path": self.source_application_path,
+            "source_application_sha256": self.source_application_sha256,
+            "state_plane_indices": list(self.state_plane_indices),
+        }
+        if self.native_entry_point is not None:
+            payload["native_entry_point"] = self.native_entry_point
+        if include_payload_digest:
+            payload["payload_digest"] = self.payload_digest
+        return payload
+
+    @classmethod
+    def from_dict(cls, payload: object) -> RecurrenceDirectPayloadBindingV1:
+        if not isinstance(payload, Mapping):
+            raise RecurrenceDirectTemplateError(
+                "direct payload binding must be a JSON object"
+            )
+        expected = {
+            "abi",
+            "contribution_parent_permutation",
+            "destination_operation",
+            "direct_application_abi",
+            "exact_factor_scalar_slots",
+            "input_plane_count",
+            "input_plane_projections",
+            "intrinsic_contract_digest",
+            "kind",
+            "output_alias_inputs",
+            "parameter_bindings",
+            "payload_digest",
+            "payload_paths",
+            "prepared_kernel_id",
+            "prepared_template_semantic_digest",
+            "role",
+            "runtime_template",
+            "scalar_input_count",
+            "scalar_projections",
+            "source_application_abi",
+            "source_application_path",
+            "source_application_sha256",
+            "state_plane_indices",
+        }
+        optional = {"native_entry_point"}
+        if not expected.issubset(payload) or not set(payload).issubset(
+            expected | optional
+        ):
+            raise RecurrenceDirectTemplateError(
+                "direct payload-binding fields do not match v1"
+            )
+        array_fields = (
+            "contribution_parent_permutation",
+            "exact_factor_scalar_slots",
+            "input_plane_projections",
+            "output_alias_inputs",
+            "parameter_bindings",
+            "payload_paths",
+            "scalar_projections",
+            "state_plane_indices",
+        )
+        if any(not isinstance(payload[field], list) for field in array_fields):
+            raise RecurrenceDirectTemplateError(
+                "direct payload-binding arrays must be JSON arrays"
+            )
+        return cls(
+            abi=payload["abi"],  # type: ignore[arg-type]
+            kind=payload["kind"],  # type: ignore[arg-type]
+            native_entry_point=payload.get("native_entry_point"),  # type: ignore[arg-type]
+            payload_digest=payload["payload_digest"],  # type: ignore[arg-type]
+            contribution_parent_permutation=tuple(
+                payload["contribution_parent_permutation"]  # type: ignore[arg-type]
+            ),
+            payload_paths=tuple(payload["payload_paths"]),  # type: ignore[arg-type]
+            prepared_kernel_id=payload["prepared_kernel_id"],  # type: ignore[arg-type]
+            runtime_template=payload["runtime_template"],  # type: ignore[arg-type]
+            source_application_path=payload["source_application_path"],  # type: ignore[arg-type]
+            source_application_sha256=payload["source_application_sha256"],  # type: ignore[arg-type]
+            source_application_abi=payload["source_application_abi"],  # type: ignore[arg-type]
+            direct_application_abi=payload["direct_application_abi"],  # type: ignore[arg-type]
+            role=payload["role"],  # type: ignore[arg-type]
+            destination_operation=payload["destination_operation"],  # type: ignore[arg-type]
+            exact_factor_scalar_slots=tuple(
+                payload["exact_factor_scalar_slots"]  # type: ignore[arg-type]
+            ),
+            state_plane_indices=tuple(
+                payload["state_plane_indices"]  # type: ignore[arg-type]
+            ),
+            parameter_bindings=_encode_canonical_objects(
+                payload["parameter_bindings"]  # type: ignore[arg-type]
+            ),
+            input_plane_count=payload["input_plane_count"],  # type: ignore[arg-type]
+            scalar_input_count=payload["scalar_input_count"],  # type: ignore[arg-type]
+            output_alias_inputs=tuple(
+                payload["output_alias_inputs"]  # type: ignore[arg-type]
+            ),
+            input_plane_projections=_encode_canonical_objects(
+                payload["input_plane_projections"]  # type: ignore[arg-type]
+            ),
+            intrinsic_contract_digest=payload["intrinsic_contract_digest"],  # type: ignore[arg-type]
+            scalar_projections=_encode_canonical_objects(
+                payload["scalar_projections"]  # type: ignore[arg-type]
+            ),
+            prepared_template_semantic_digest=payload[
+                "prepared_template_semantic_digest"
+            ],  # type: ignore[arg-type]
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedJitDirectSourceV1:
+    """Authenticated source application and fixed prepared-kernel contract."""
+
+    prepared_kernel_id: int
+    source_application_path: str
+    source_application_sha256: str
+    source_application_abi: str
+    input_contracts: tuple[str, ...]
+    exact_expressions: tuple[str, ...]
+    output_arity: int
+
+    def __post_init__(self) -> None:
+        _require_nonnegative_int(
+            "prepared JIT direct source kernel ID", self.prepared_kernel_id
+        )
+        _require_nonempty(
+            "prepared JIT direct source path", self.source_application_path
+        )
+        _require_sha256(
+            "prepared JIT direct source digest", self.source_application_sha256
+        )
+        _require_nonempty("prepared JIT direct source ABI", self.source_application_abi)
+        _require_canonical_object_tuple(
+            "prepared JIT direct input contracts", self.input_contracts
+        )
+        output_arity = _require_positive_int(
+            "prepared JIT direct output arity", self.output_arity
+        )
+        expressions = _require_string_tuple(
+            "prepared JIT direct exact expressions",
+            self.exact_expressions,
+            nonempty=True,
+        )
+        if len(expressions) != output_arity:
+            raise RecurrenceDirectTemplateError(
+                "prepared JIT direct exact-expression count does not match output arity"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedNativeDirectCallableSpecV1:
+    """Compile-time contract for one target-native Direct-Arena export."""
+
+    prepared_kernel_id: int
+    role: DirectRole
+    native_entry_point: str
+    input_contracts: tuple[str, ...]
+    exact_expressions: tuple[str, ...]
+    output_arity: int
+    parent_component_shapes: tuple[tuple[int, ...], ...]
+    destination_component_counts: tuple[int, ...]
+
+    def __post_init__(self) -> None:
+        kernel_id = _require_nonnegative_int(
+            "prepared native direct kernel ID", self.prepared_kernel_id
+        )
+        if self.role not in _ROLE_INDEX or self.role == "source":
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct callables require a non-source role"
+            )
+        expected_entry_point = native_direct_entry_point(self.role, kernel_id)
+        if self.native_entry_point != expected_entry_point:
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct entry point does not authenticate its "
+                "role and kernel ID"
+            )
+        _require_canonical_object_tuple(
+            "prepared native direct input contracts", self.input_contracts
+        )
+        output_arity = _require_positive_int(
+            "prepared native direct output arity", self.output_arity
+        )
+        expressions = _require_string_tuple(
+            "prepared native direct exact expressions",
+            self.exact_expressions,
+            nonempty=True,
+        )
+        if len(expressions) != output_arity:
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct exact-expression count does not match "
+                "output arity"
+            )
+        if (
+            not isinstance(self.parent_component_shapes, tuple)
+            or not self.parent_component_shapes
+        ):
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct parent shapes must be nonempty"
+            )
+        shapes = tuple(
+            _require_int_tuple(
+                "prepared native direct parent component shape", shape
+            )
+            for shape in self.parent_component_shapes
+        )
+        if (
+            shapes != tuple(sorted(set(shapes)))
+            or len({len(shape) for shape in shapes}) != 1
+        ):
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct parent shapes must be sorted, unique, "
+                "and have one arity"
+            )
+        if any(count == 0 for shape in shapes for count in shape):
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct parent component counts must be positive"
+            )
+        destination_counts = _require_int_tuple(
+            "prepared native direct destination component counts",
+            self.destination_component_counts,
+        )
+        if (
+            not destination_counts
+            or destination_counts != tuple(sorted(set(destination_counts)))
+            or any(count == 0 for count in destination_counts)
+        ):
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct destination counts must be sorted, "
+                "unique, and positive"
+            )
+        if self.output_arity > min(destination_counts):
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct output exceeds a destination shape"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedNativeDirectSourceV1:
+    """Authenticated native library and one typed Direct-Arena export."""
+
+    prepared_kernel_id: int
+    role: DirectRole
+    native_entry_point: str
+    source_application_path: str
+    source_application_sha256: str
+    source_application_abi: str
+    input_contracts: tuple[str, ...]
+    exact_expressions: tuple[str, ...]
+    output_arity: int
+
+    def __post_init__(self) -> None:
+        kernel_id = _require_nonnegative_int(
+            "prepared native direct source kernel ID", self.prepared_kernel_id
+        )
+        if self.role not in _ROLE_INDEX or self.role == "source":
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct sources require a non-source role"
+            )
+        if self.native_entry_point != native_direct_entry_point(self.role, kernel_id):
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct source entry point is not canonical"
+            )
+        _require_canonical_object_tuple(
+            "prepared native direct source input contracts", self.input_contracts
+        )
+        output_arity = _require_positive_int(
+            "prepared native direct source output arity", self.output_arity
+        )
+        if len(
+            _require_string_tuple(
+                "prepared native direct source exact expressions",
+                self.exact_expressions,
+                nonempty=True,
+            )
+        ) != output_arity:
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct source expression count does not match "
+                "its output arity"
+            )
+        _require_nonempty(
+            "prepared native direct source path", self.source_application_path
+        )
+        _require_sha256(
+            "prepared native direct source digest", self.source_application_sha256
+        )
+        if self.source_application_abi not in _NATIVE_SOURCE_APPLICATION_ABIS:
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct source has an unsupported application ABI"
+            )
+
+
+def native_direct_entry_point(role: DirectRole, prepared_kernel_id: int) -> str:
+    """Return the role- and kernel-authenticated native C export."""
+
+    kernel_id = _require_nonnegative_int(
+        "prepared native direct kernel ID", prepared_kernel_id
+    )
+    if kernel_id == 0xFFFFFFFF:
+        raise RecurrenceDirectTemplateError(
+            "prepared native direct kernel ID cannot use the missing-ID sentinel"
+        )
+    if role not in _ROLE_INDEX or role == "source":
+        raise RecurrenceDirectTemplateError(
+            "prepared native Direct-Arena exports require a non-source role"
+        )
+    return f"pyamplicol_recurrence_direct_{role}_k{kernel_id:08x}_v1"
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceDirectTemplateV1:
+    """One model-prepared callable that operates directly on recurrence arenas."""
+
+    template_id: str
+    direct_executor_id: int
+    evaluator_binding_id: int
+    evaluator_resolver_key: str
+    role: DirectRole
+    parent_arity: int
+    parent_component_counts: tuple[int, ...]
+    destination_component_count: int
+    momentum_operand_count: int
+    destination_operation: DirectDestinationOperation
+    coupling_slot_count: int
+    parameter_slot_count: int
+    semantic_template_ids: tuple[str, ...]
+    exact_expression_digest: str
+    payload_binding: RecurrenceDirectPayloadBindingV1
+    backend: DirectBackend
+    target_triple: str
+    portable: bool
+    optimization_level: int
+    alignment_bytes: int
+    simd_axis: str
+    destination_aliasing: bool
+    semantic_digest: str = ""
+    abi: str = RECURRENCE_DIRECT_TEMPLATE_ABI
+
+    def __post_init__(self) -> None:
+        if self.abi != RECURRENCE_DIRECT_TEMPLATE_ABI:
+            raise RecurrenceDirectTemplateError(
+                f"unsupported direct template ABI {self.abi!r}"
+            )
+        _require_nonempty("direct template_id", self.template_id)
+        _require_nonnegative_int("direct executor id", self.direct_executor_id)
+        _require_nonnegative_int(
+            "direct evaluator binding id", self.evaluator_binding_id
+        )
+        _require_nonempty("direct evaluator resolver key", self.evaluator_resolver_key)
+        if self.role not in _ROLE_INDEX:
+            raise RecurrenceDirectTemplateError(
+                f"unsupported direct template role {self.role!r}"
+            )
+        _require_nonnegative_int("direct parent arity", self.parent_arity)
+        counts = _require_int_tuple(
+            "direct parent component counts", self.parent_component_counts
+        )
+        if len(counts) != self.parent_arity or any(count == 0 for count in counts):
+            raise RecurrenceDirectTemplateError(
+                "direct parent component counts must cover every nonempty parent"
+            )
+        _require_positive_int(
+            "direct destination component count", self.destination_component_count
+        )
+        _require_nonnegative_int(
+            "direct momentum operand count", self.momentum_operand_count
+        )
+        expected_operation = _DESTINATION_OPERATIONS[self.role]
+        if self.destination_operation != expected_operation:
+            raise RecurrenceDirectTemplateError(
+                f"direct {self.role} template must use {expected_operation!r}"
+            )
+        _require_nonnegative_int("direct coupling slot count", self.coupling_slot_count)
+        _require_nonnegative_int(
+            "direct parameter slot count", self.parameter_slot_count
+        )
+        _require_string_tuple(
+            "direct semantic template ids",
+            self.semantic_template_ids,
+            nonempty=True,
+            sorted_unique=True,
+        )
+        _require_sha256("direct exact expression digest", self.exact_expression_digest)
+        if not isinstance(self.payload_binding, RecurrenceDirectPayloadBindingV1):
+            raise RecurrenceDirectTemplateError(
+                "direct template requires a typed payload binding"
+            )
+        if self.backend not in _BACKENDS:
+            raise RecurrenceDirectTemplateError(
+                f"unsupported direct backend {self.backend!r}"
+            )
+        _require_nonempty("direct target triple", self.target_triple)
+        if type(self.portable) is not bool:
+            raise RecurrenceDirectTemplateError("direct portable flag must be boolean")
+        _require_nonnegative_int("direct optimization level", self.optimization_level)
+        if self.backend == "jit":
+            if self.optimization_level != 2 or not self.portable:
+                raise RecurrenceDirectTemplateError(
+                    "prepared direct JIT templates must use portable SymJIT O2"
+                )
+        elif self.portable:
+            raise RecurrenceDirectTemplateError(
+                "prepared direct C++/ASM templates must be target-native"
+            )
+        alignment = _require_positive_int(
+            "direct alignment bytes", self.alignment_bytes
+        )
+        if alignment & (alignment - 1):
+            raise RecurrenceDirectTemplateError(
+                "direct alignment bytes must be a power of two"
+            )
+        if self.simd_axis != "points-contiguous":
+            raise RecurrenceDirectTemplateError(
+                "direct template SIMD axis must be points-contiguous"
+            )
+        if type(self.destination_aliasing) is not bool:
+            raise RecurrenceDirectTemplateError(
+                "direct destination_aliasing must be boolean"
+            )
+        if self.destination_aliasing != (self.role == "finalization"):
+            raise RecurrenceDirectTemplateError(
+                "only direct finalization templates may alias their destination"
+            )
+        calculated = _digest(self._semantic_fields())
+        if self.semantic_digest:
+            _require_sha256("direct semantic digest", self.semantic_digest)
+            if self.semantic_digest != calculated:
+                raise RecurrenceDirectTemplateError(
+                    "direct semantic digest does not match template contents"
+                )
+        else:
+            object.__setattr__(self, "semantic_digest", calculated)
+
+    @property
+    def f64_payload_digest(self) -> str:
+        return self.payload_binding.payload_digest
+
+    @property
+    def executable(self) -> bool:
+        return self.payload_binding.executable
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "abi": self.abi,
+            "alignment_bytes": self.alignment_bytes,
+            "backend": self.backend,
+            "coupling_slot_count": self.coupling_slot_count,
+            "destination_aliasing": self.destination_aliasing,
+            "destination_component_count": self.destination_component_count,
+            "destination_operation": self.destination_operation,
+            "direct_executor_id": self.direct_executor_id,
+            "evaluator_binding_id": self.evaluator_binding_id,
+            "evaluator_resolver_key": self.evaluator_resolver_key,
+            "exact_expression_digest": self.exact_expression_digest,
+            "momentum_operand_count": self.momentum_operand_count,
+            "optimization_level": self.optimization_level,
+            "parameter_slot_count": self.parameter_slot_count,
+            "parent_arity": self.parent_arity,
+            "parent_component_counts": list(self.parent_component_counts),
+            "payload_binding": self.payload_binding.to_dict(),
+            "portable": self.portable,
+            "role": self.role,
+            "semantic_template_ids": list(self.semantic_template_ids),
+            "simd_axis": self.simd_axis,
+            "target_triple": self.target_triple,
+            "template_id": self.template_id,
+        }
+
+    def to_dict(self) -> dict[str, object]:
+        return {**self._semantic_fields(), "semantic_digest": self.semantic_digest}
+
+    @classmethod
+    def from_dict(cls, payload: object) -> RecurrenceDirectTemplateV1:
+        if not isinstance(payload, Mapping):
+            raise RecurrenceDirectTemplateError("direct template must be a JSON object")
+        expected = {
+            "abi",
+            "alignment_bytes",
+            "backend",
+            "coupling_slot_count",
+            "destination_aliasing",
+            "destination_component_count",
+            "destination_operation",
+            "direct_executor_id",
+            "evaluator_binding_id",
+            "evaluator_resolver_key",
+            "exact_expression_digest",
+            "momentum_operand_count",
+            "optimization_level",
+            "parameter_slot_count",
+            "parent_arity",
+            "parent_component_counts",
+            "payload_binding",
+            "portable",
+            "role",
+            "semantic_digest",
+            "semantic_template_ids",
+            "simd_axis",
+            "target_triple",
+            "template_id",
+        }
+        if set(payload) != expected:
+            raise RecurrenceDirectTemplateError(
+                "direct template fields do not match direct-template-v1"
+            )
+        parent_counts = payload["parent_component_counts"]
+        semantic_ids = payload["semantic_template_ids"]
+        if not isinstance(parent_counts, list) or not isinstance(semantic_ids, list):
+            raise RecurrenceDirectTemplateError(
+                "direct component counts and semantic IDs must be JSON arrays"
+            )
+        return cls(
+            abi=payload["abi"],  # type: ignore[arg-type]
+            template_id=payload["template_id"],  # type: ignore[arg-type]
+            direct_executor_id=payload["direct_executor_id"],  # type: ignore[arg-type]
+            evaluator_binding_id=payload["evaluator_binding_id"],  # type: ignore[arg-type]
+            evaluator_resolver_key=payload["evaluator_resolver_key"],  # type: ignore[arg-type]
+            role=payload["role"],  # type: ignore[arg-type]
+            parent_arity=payload["parent_arity"],  # type: ignore[arg-type]
+            parent_component_counts=tuple(parent_counts),  # type: ignore[arg-type]
+            destination_component_count=payload["destination_component_count"],  # type: ignore[arg-type]
+            momentum_operand_count=payload["momentum_operand_count"],  # type: ignore[arg-type]
+            destination_operation=payload["destination_operation"],  # type: ignore[arg-type]
+            coupling_slot_count=payload["coupling_slot_count"],  # type: ignore[arg-type]
+            parameter_slot_count=payload["parameter_slot_count"],  # type: ignore[arg-type]
+            semantic_template_ids=tuple(semantic_ids),  # type: ignore[arg-type]
+            exact_expression_digest=payload["exact_expression_digest"],  # type: ignore[arg-type]
+            payload_binding=RecurrenceDirectPayloadBindingV1.from_dict(
+                payload["payload_binding"]
+            ),
+            backend=payload["backend"],  # type: ignore[arg-type]
+            target_triple=payload["target_triple"],  # type: ignore[arg-type]
+            portable=payload["portable"],  # type: ignore[arg-type]
+            optimization_level=payload["optimization_level"],  # type: ignore[arg-type]
+            alignment_bytes=payload["alignment_bytes"],  # type: ignore[arg-type]
+            simd_axis=payload["simd_axis"],  # type: ignore[arg-type]
+            destination_aliasing=payload["destination_aliasing"],  # type: ignore[arg-type]
+            semantic_digest=payload["semantic_digest"],  # type: ignore[arg-type]
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceDirectTemplateCatalogV1:
+    """Deterministic model-wide direct-executor metadata."""
+
+    templates: tuple[RecurrenceDirectTemplateV1, ...]
+    backend: DirectBackend
+    target_triple: str
+    portable: bool
+    optimization_level: int
+    compiled_model_digest: str
+    recurrence_template_catalog_digest: str
+    prepared_kernel_pack_digest: str
+    prepared_kernel_contract_digest: str
+    prepared_kernel_payload_digest: str
+    optimization_settings_digest: str
+    catalog_digest: str = ""
+    abi: str = RECURRENCE_DIRECT_TEMPLATE_ABI
+    backend_abi: str = RECURRENCE_DIRECT_BACKEND_ABI
+    canonicalization_abi: str = RECURRENCE_DIRECT_CANONICALIZATION_ABI
+
+    def __post_init__(self) -> None:
+        if self.abi != RECURRENCE_DIRECT_TEMPLATE_ABI:
+            raise RecurrenceDirectTemplateError(
+                f"unsupported direct catalog ABI {self.abi!r}"
+            )
+        if self.backend_abi != RECURRENCE_DIRECT_BACKEND_ABI:
+            raise RecurrenceDirectTemplateError(
+                f"unsupported direct backend ABI {self.backend_abi!r}"
+            )
+        if self.canonicalization_abi != RECURRENCE_DIRECT_CANONICALIZATION_ABI:
+            raise RecurrenceDirectTemplateError(
+                "unsupported direct canonicalization ABI"
+            )
+        if not self.templates:
+            raise RecurrenceDirectTemplateError(
+                "direct template catalog must not be empty"
+            )
+        if self.backend not in _BACKENDS:
+            raise RecurrenceDirectTemplateError(
+                f"unsupported direct catalog backend {self.backend!r}"
+            )
+        _require_nonempty("direct catalog target triple", self.target_triple)
+        if type(self.portable) is not bool:
+            raise RecurrenceDirectTemplateError(
+                "direct catalog portable flag must be boolean"
+            )
+        _require_nonnegative_int(
+            "direct catalog optimization level", self.optimization_level
+        )
+        if self.backend == "jit":
+            if not self.portable or self.optimization_level != 2:
+                raise RecurrenceDirectTemplateError(
+                    "prepared direct JIT catalogs must use portable SymJIT O2"
+                )
+        elif self.portable:
+            raise RecurrenceDirectTemplateError(
+                "prepared direct C++/ASM catalogs must be target-native"
+            )
+        for name in (
+            "compiled_model_digest",
+            "recurrence_template_catalog_digest",
+            "prepared_kernel_pack_digest",
+            "prepared_kernel_contract_digest",
+            "prepared_kernel_payload_digest",
+            "optimization_settings_digest",
+        ):
+            _require_sha256(f"direct catalog {name}", getattr(self, name))
+        expected_order = tuple(
+            sorted(
+                self.templates,
+                key=lambda template: (
+                    template.direct_executor_id,
+                    _ROLE_INDEX[template.role],
+                    template.evaluator_binding_id,
+                    template.template_id,
+                ),
+            )
+        )
+        if expected_order != self.templates:
+            raise RecurrenceDirectTemplateError(
+                "direct templates must be sorted by dense executor identity"
+            )
+        ids = [template.direct_executor_id for template in self.templates]
+        names = [template.template_id for template in self.templates]
+        binding_keys = [
+            (template.role, template.evaluator_binding_id)
+            for template in self.templates
+        ]
+        if len(set(ids)) != len(ids) or len(set(names)) != len(names):
+            raise RecurrenceDirectTemplateError(
+                "direct template executor IDs and names must be unique"
+            )
+        if len(set(binding_keys)) != len(binding_keys):
+            raise RecurrenceDirectTemplateError(
+                "direct (role, evaluator_binding_id) mappings must be unique"
+            )
+        if ids != list(range(len(ids))):
+            raise RecurrenceDirectTemplateError(
+                "direct template executor IDs must form a dense zero-based catalog"
+            )
+        for template in self.templates:
+            if (
+                template.backend != self.backend
+                or template.target_triple != self.target_triple
+                or template.portable != self.portable
+                or template.optimization_level != self.optimization_level
+            ):
+                raise RecurrenceDirectTemplateError(
+                    "direct template backend/target policy does not match its catalog"
+                )
+        calculated = _digest(self._semantic_fields())
+        if self.catalog_digest:
+            _require_sha256("direct catalog digest", self.catalog_digest)
+            if self.catalog_digest != calculated:
+                raise RecurrenceDirectTemplateError(
+                    "direct catalog digest does not match its templates"
+                )
+        else:
+            object.__setattr__(self, "catalog_digest", calculated)
+
+    def direct_executor_id_for(
+        self,
+        role: DirectRole,
+        evaluator_binding_id: int,
+    ) -> int:
+        """Resolve an authenticated semantic evaluator binding deterministically."""
+
+        for template in self.templates:
+            if (
+                template.role == role
+                and template.evaluator_binding_id == evaluator_binding_id
+            ):
+                return template.direct_executor_id
+        raise RecurrenceDirectTemplateError(
+            "direct executor catalog has no mapping for "
+            f"({role!r}, evaluator_binding_id={evaluator_binding_id})"
+        )
+
+    @property
+    def executable(self) -> bool:
+        return all(template.executable for template in self.templates)
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "abi": self.abi,
+            "backend": self.backend,
+            "backend_abi": self.backend_abi,
+            "canonicalization_abi": self.canonicalization_abi,
+            "compiled_model_digest": self.compiled_model_digest,
+            "optimization_level": self.optimization_level,
+            "optimization_settings_digest": self.optimization_settings_digest,
+            "portable": self.portable,
+            "prepared_kernel_contract_digest": self.prepared_kernel_contract_digest,
+            "prepared_kernel_pack_digest": self.prepared_kernel_pack_digest,
+            "prepared_kernel_payload_digest": self.prepared_kernel_payload_digest,
+            "recurrence_template_catalog_digest": (
+                self.recurrence_template_catalog_digest
+            ),
+            "target_triple": self.target_triple,
+            "templates": [template.to_dict() for template in self.templates],
+        }
+
+    def to_dict(self) -> dict[str, object]:
+        return {**self._semantic_fields(), "catalog_digest": self.catalog_digest}
+
+    @property
+    def canonical_json(self) -> str:
+        return _canonical_json(self.to_dict())
+
+    @classmethod
+    def from_dict(cls, payload: object) -> RecurrenceDirectTemplateCatalogV1:
+        if not isinstance(payload, Mapping):
+            raise RecurrenceDirectTemplateError(
+                "direct template catalog must be a JSON object"
+            )
+        expected = {
+            "abi",
+            "backend",
+            "backend_abi",
+            "canonicalization_abi",
+            "catalog_digest",
+            "compiled_model_digest",
+            "optimization_level",
+            "optimization_settings_digest",
+            "portable",
+            "prepared_kernel_contract_digest",
+            "prepared_kernel_pack_digest",
+            "prepared_kernel_payload_digest",
+            "recurrence_template_catalog_digest",
+            "target_triple",
+            "templates",
+        }
+        if set(payload) != expected:
+            raise RecurrenceDirectTemplateError(
+                "direct template catalog fields do not match v1"
+            )
+        raw_templates = payload["templates"]
+        if not isinstance(raw_templates, list):
+            raise RecurrenceDirectTemplateError(
+                "direct template catalog templates must be a JSON array"
+            )
+        return cls(
+            abi=payload["abi"],  # type: ignore[arg-type]
+            backend_abi=payload["backend_abi"],  # type: ignore[arg-type]
+            canonicalization_abi=payload["canonicalization_abi"],  # type: ignore[arg-type]
+            templates=tuple(
+                RecurrenceDirectTemplateV1.from_dict(item) for item in raw_templates
+            ),
+            backend=payload["backend"],  # type: ignore[arg-type]
+            target_triple=payload["target_triple"],  # type: ignore[arg-type]
+            portable=payload["portable"],  # type: ignore[arg-type]
+            optimization_level=payload["optimization_level"],  # type: ignore[arg-type]
+            compiled_model_digest=payload["compiled_model_digest"],  # type: ignore[arg-type]
+            recurrence_template_catalog_digest=payload[
+                "recurrence_template_catalog_digest"
+            ],  # type: ignore[arg-type]
+            prepared_kernel_pack_digest=payload["prepared_kernel_pack_digest"],  # type: ignore[arg-type]
+            prepared_kernel_contract_digest=payload["prepared_kernel_contract_digest"],  # type: ignore[arg-type]
+            prepared_kernel_payload_digest=payload["prepared_kernel_payload_digest"],  # type: ignore[arg-type]
+            optimization_settings_digest=payload["optimization_settings_digest"],  # type: ignore[arg-type]
+            catalog_digest=payload["catalog_digest"],  # type: ignore[arg-type]
+        )
+
+
+def build_prepared_native_direct_callable_specs(
+    recurrence_catalog: RecurrenceTemplateCatalog,
+    prepared_kernels: Mapping[int, object],
+) -> dict[int, PreparedNativeDirectCallableSpecV1]:
+    """Project model-generic semantic bindings into one native export per kernel.
+
+    Inline couplings remain evaluator-binding-specific immutable contexts.
+    They are validated here but deliberately excluded from callable identity,
+    allowing one prepared Lorentz kernel to serve every compatible transition.
+    """
+
+    if not isinstance(recurrence_catalog, RecurrenceTemplateCatalog):
+        raise TypeError(
+            "native direct callable construction requires a validated recurrence "
+            "catalog"
+        )
+    states = {state.template_id: state for state in recurrence_catalog.current_states}
+    semantic_records = {
+        record.template_id: record
+        for records in (
+            recurrence_catalog.sources,
+            recurrence_catalog.transitions,
+            recurrence_catalog.propagators,
+            recurrence_catalog.closures,
+        )
+        for record in records
+    }
+    result: dict[int, PreparedNativeDirectCallableSpecV1] = {}
+    for binding in recurrence_catalog.evaluator_bindings:
+        if binding.callable_kind != "prepared-kernel":
+            continue
+        role = _CONTRACT_ROLES.get(binding.contract_kind)
+        if role is None:
+            continue
+        if role == "source":
+            raise RecurrenceDirectTemplateError(
+                "prepared native recurrence sources are unsupported; source "
+                "filling must remain Rusticol-owned"
+            )
+        assert binding.prepared_kernel_id is not None
+        kernel_id = binding.prepared_kernel_id
+        kernel = prepared_kernels.get(kernel_id)
+        if kernel is None:
+            raise RecurrenceDirectTemplateError(
+                f"native direct callable references absent prepared kernel {kernel_id}"
+            )
+        inputs = tuple(getattr(kernel, "inputs", ()))
+        exact_expressions = tuple(getattr(kernel, "exact_expressions", ()))
+        output_arity = len(exact_expressions)
+        if getattr(kernel, "kernel_id", None) != kernel_id:
+            raise RecurrenceDirectTemplateError(
+                f"native direct kernel inventory entry {kernel_id} identifies "
+                f"{getattr(kernel, 'kernel_id', None)!r}"
+            )
+        if getattr(kernel, "contract_kind", None) != binding.contract_kind:
+            raise RecurrenceDirectTemplateError(
+                f"native direct kernel {kernel_id} contract kind does not match "
+                "its recurrence evaluator binding"
+            )
+        input_contracts = tuple(
+            _canonical_json(item.to_dict()) for item in inputs
+        )
+        concrete_parent_component_counts = tuple(
+            states[state_id].dimension for state_id in binding.input_state_template_ids
+        )
+        parent_component_counts = _canonical_parent_component_counts(
+            binding.semantic_template_ids,
+            semantic_records,
+            concrete_parent_component_counts,
+        )
+        destination_component_count = (
+            states[binding.output_state_template_id].dimension
+            if binding.output_state_template_id is not None
+            else 1
+        )
+        _uniform_binding_coupling(
+            binding.semantic_template_ids,
+            semantic_records,
+            required=_input_contracts_use_inline_coupling(input_contracts),
+        )
+        spec = PreparedNativeDirectCallableSpecV1(
+            prepared_kernel_id=kernel_id,
+            role=cast(DirectRole, role),
+            native_entry_point=native_direct_entry_point(
+                cast(DirectRole, role), kernel_id
+            ),
+            input_contracts=input_contracts,
+            exact_expressions=exact_expressions,
+            output_arity=output_arity,
+            parent_component_shapes=(parent_component_counts,),
+            destination_component_counts=(destination_component_count,),
+        )
+        _validate_prepared_native_direct_projection_bounds(spec)
+        previous = result.get(kernel_id)
+        result[kernel_id] = (
+            spec
+            if previous is None
+            else _merge_prepared_native_direct_callable_specs(previous, spec)
+        )
+    return result
+
+
+def _merge_prepared_native_direct_callable_specs(
+    left: PreparedNativeDirectCallableSpecV1,
+    right: PreparedNativeDirectCallableSpecV1,
+) -> PreparedNativeDirectCallableSpecV1:
+    identity_fields = (
+        "prepared_kernel_id",
+        "role",
+        "native_entry_point",
+        "input_contracts",
+        "exact_expressions",
+        "output_arity",
+    )
+    conflicts = tuple(
+        name for name in identity_fields if getattr(left, name) != getattr(right, name)
+    )
+    left_parent_arity = len(left.parent_component_shapes[0])
+    right_parent_arity = len(right.parent_component_shapes[0])
+    if left_parent_arity != right_parent_arity:
+        conflicts += ("parent_arity",)
+    if conflicts:
+        raise RecurrenceDirectTemplateError(
+            f"prepared native kernel {left.prepared_kernel_id} has incompatible "
+            "recurrence bindings for "
+            + ", ".join(conflicts)
+        )
+    merged = replace(
+        left,
+        parent_component_shapes=tuple(
+            sorted(set(left.parent_component_shapes + right.parent_component_shapes))
+        ),
+        destination_component_counts=tuple(
+            sorted(
+                set(
+                    left.destination_component_counts
+                    + right.destination_component_counts
+                )
+            )
+        ),
+    )
+    _validate_prepared_native_direct_projection_bounds(merged)
+    return merged
+
+
+def _validate_prepared_native_direct_projection_bounds(
+    spec: PreparedNativeDirectCallableSpecV1,
+) -> None:
+    parent_arity = len(spec.parent_component_shapes[0])
+    for raw_contract in spec.input_contracts:
+        try:
+            contract = json.loads(raw_contract)
+        except (TypeError, ValueError) as exc:
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct input contract is not valid JSON"
+            ) from exc
+        if not isinstance(contract, Mapping):
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct input contract must be an object"
+            )
+        role = contract.get("role")
+        if role not in {"left-current", "right-current", "current"}:
+            continue
+        component = contract.get("component")
+        if type(component) is not int or component < 0:
+            raise RecurrenceDirectTemplateError(
+                "prepared native direct current projection must use a "
+                "nonnegative component"
+            )
+        parent = 1 if role == "right-current" else 0
+        if parent >= parent_arity:
+            raise RecurrenceDirectTemplateError(
+                f"prepared native direct {role} projection has no parent"
+            )
+        if any(
+            component >= shape[parent] for shape in spec.parent_component_shapes
+        ):
+            raise RecurrenceDirectTemplateError(
+                f"prepared native direct {role} component {component} is outside "
+                "an admitted parent shape"
+            )
+
+
+def build_recurrence_direct_template_catalog(
+    recurrence_catalog: RecurrenceTemplateCatalog,
+    *,
+    backend: DirectBackend,
+    target_triple: str,
+    portable: bool,
+    optimization_level: int,
+    prepared_kernel_pack_digest: str,
+    prepared_kernel_contract_digest: str,
+    prepared_kernel_payload_digest: str,
+    optimization_settings_digest: str,
+    prepared_kernel_payload_digests: Mapping[int, str],
+    prepared_direct_payload_bindings: (
+        Mapping[int, RecurrenceDirectPayloadBindingV1] | None
+    ) = None,
+    prepared_jit_sources: Mapping[int, PreparedJitDirectSourceV1] | None = None,
+    prepared_native_sources: Mapping[int, PreparedNativeDirectSourceV1] | None = None,
+    alignment_bytes: int = 64,
+) -> RecurrenceDirectTemplateCatalogV1:
+    """Derive stable direct executors from one authenticated semantic catalog.
+
+    ``prepared_jit_sources`` references each portable O2 plane application and
+    derives its authenticated P-kernel arena binding. ``prepared_native_sources``
+    references target-native split-real libraries and their typed exported
+    entry points. Omitting both records prepared kernels as pending and never
+    treats their packed eager evaluator as a direct call.
+    """
+
+    if not isinstance(recurrence_catalog, RecurrenceTemplateCatalog):
+        raise TypeError(
+            "direct template construction requires a validated recurrence catalog"
+        )
+    states = {state.template_id: state for state in recurrence_catalog.current_states}
+    semantic_records = {
+        record.template_id: record
+        for records in (
+            recurrence_catalog.sources,
+            recurrence_catalog.transitions,
+            recurrence_catalog.propagators,
+            recurrence_catalog.closures,
+        )
+        for record in records
+    }
+    supplied_direct = dict(prepared_direct_payload_bindings or {})
+    jit_sources = dict(prepared_jit_sources or {})
+    native_sources = dict(prepared_native_sources or {})
+    if backend == "jit" and native_sources:
+        raise RecurrenceDirectTemplateError(
+            "prepared JIT direct catalogs cannot reference native direct sources"
+        )
+    if backend == "jit":
+        for kernel_id, source in jit_sources.items():
+            if source.source_application_abi != SYMJIT_PLANE_APPLICATION_ABI:
+                raise RecurrenceDirectTemplateError(
+                    f"prepared JIT direct source for kernel {kernel_id} is not "
+                    "a SymJIT plane application; regenerate the prepared model"
+                )
+    if backend in {"cpp", "asm"} and jit_sources:
+        raise RecurrenceDirectTemplateError(
+            "prepared native direct catalogs cannot reference SymJIT sources"
+        )
+    expected_native_source_abi = {
+        "cpp": "symbolica.compiled-cpp.complex-f64.v1",
+        "asm": "symbolica.compiled-asm.complex-f64.v1",
+    }.get(backend)
+    if expected_native_source_abi is not None:
+        for kernel_id, source in native_sources.items():
+            if source.source_application_abi != expected_native_source_abi:
+                raise RecurrenceDirectTemplateError(
+                    f"prepared {backend} direct source for kernel {kernel_id} "
+                    "has the wrong target-native application ABI"
+                )
+    candidates: list[dict[str, object]] = []
+
+    for evaluator_binding_id, binding in enumerate(
+        recurrence_catalog.evaluator_bindings
+    ):
+        role = _CONTRACT_ROLES.get(binding.contract_kind)
+        if role is None:
+            continue
+        concrete_parent_component_counts = tuple(
+            states[state_id].dimension for state_id in binding.input_state_template_ids
+        )
+        parent_component_counts = _canonical_parent_component_counts(
+            binding.semantic_template_ids,
+            semantic_records,
+            concrete_parent_component_counts,
+        )
+        destination_component_count = (
+            states[binding.output_state_template_id].dimension
+            if binding.output_state_template_id is not None
+            else 1
+        )
+        if binding.callable_kind == "rusticol-template":
+            assert binding.runtime_template is not None
+            payload_binding = RecurrenceDirectPayloadBindingV1(
+                kind="rusticol-intrinsic",
+                runtime_template=binding.runtime_template,
+                payload_digest=_digest(
+                    {
+                        "abi": RECURRENCE_DIRECT_BACKEND_ABI,
+                        "callable_signature": binding.callable_signature,
+                        "contribution_parent_permutation": [0, 1],
+                        "runtime_template": binding.runtime_template,
+                    }
+                ),
+            )
+        else:
+            assert binding.prepared_kernel_id is not None
+            kernel_id = binding.prepared_kernel_id
+            kernel_payload_digest = _require_sha256(
+                f"prepared kernel {kernel_id} payload digest",
+                prepared_kernel_payload_digests.get(kernel_id),
+            )
+            payload_binding = supplied_direct.get(kernel_id)
+            if (
+                payload_binding is not None
+                and payload_binding.prepared_kernel_id != kernel_id
+            ):
+                raise RecurrenceDirectTemplateError(
+                    f"direct payload binding for kernel {kernel_id} identifies "
+                    f"kernel {payload_binding.prepared_kernel_id}"
+                )
+        coupling_slots, parameter_slots = _slot_counts(
+            binding.semantic_template_ids,
+            semantic_records,
+            binding.input_layout,
+        )
+        candidate: dict[str, object] = {
+            "evaluator_binding_id": evaluator_binding_id,
+            "evaluator_resolver_key": binding.resolver_key,
+            "role": role,
+            "parent_component_counts": parent_component_counts,
+            "destination_component_count": destination_component_count,
+            "momentum_operand_count": (
+                1
+                if role in {"source", "finalization"}
+                else len(parent_component_counts)
+            ),
+            "coupling_slot_count": coupling_slots,
+            "parameter_slot_count": parameter_slots,
+            "semantic_template_ids": binding.semantic_template_ids,
+            "exact_expression_digest": _digest(
+                {
+                    "callable_signature": binding.callable_signature,
+                    "exact_expression_digests": list(binding.exact_expression_digests),
+                }
+            ),
+            "template_id": f"direct:{role}:{binding.semantic_digest[:24]}",
+        }
+        if binding.callable_kind != "rusticol-template":
+            assert binding.prepared_kernel_id is not None
+            kernel_id = binding.prepared_kernel_id
+            if payload_binding is None:
+                source = (
+                    jit_sources.get(kernel_id)
+                    if backend == "jit"
+                    else native_sources.get(kernel_id)
+                )
+                if source is not None:
+                    if source.prepared_kernel_id != kernel_id:
+                        raise RecurrenceDirectTemplateError(
+                            f"prepared direct source for kernel {kernel_id} "
+                            f"identifies kernel {source.prepared_kernel_id}"
+                        )
+                    binding_coupling = _uniform_binding_coupling(
+                        binding.semantic_template_ids,
+                        semantic_records,
+                        required=_input_contracts_use_inline_coupling(
+                            source.input_contracts
+                        ),
+                    )
+                    certified_intrinsic = None
+                    finalization_intrinsic = None
+                    if role == "contribution":
+                        certified_intrinsic = certify_recurrence_contribution_intrinsic(
+                            exact_expressions=source.exact_expressions,
+                            input_contracts=source.input_contracts,
+                            parent_component_counts=parent_component_counts,
+                            destination_component_count=destination_component_count,
+                            binding_coupling=binding_coupling,
+                            allow_nontrivial_parent_permutation=True,
+                        )
+                    elif role == "finalization":
+                        finalization_intrinsic = (
+                            certify_recurrence_finalization_intrinsic(
+                                exact_expressions=source.exact_expressions,
+                                input_contracts=source.input_contracts,
+                                component_count=destination_component_count,
+                            )
+                        )
+                    if certified_intrinsic is not None:
+                        payload_binding = _build_certified_intrinsic_binding(
+                            certified_intrinsic
+                        )
+                    elif finalization_intrinsic is not None:
+                        payload_binding = _build_runtime_intrinsic_binding(
+                            runtime_template=finalization_intrinsic
+                        )
+                    elif isinstance(source, PreparedJitDirectSourceV1):
+                        payload_binding = _build_prepared_jit_direct_binding(
+                            source=source,
+                            role=cast(DirectRole, role),
+                            parent_component_counts=parent_component_counts,
+                            destination_component_count=destination_component_count,
+                            binding_coupling=binding_coupling,
+                            prepared_template_semantic_digest=(
+                                _prepared_template_contract_digest(
+                                    candidate,
+                                    backend=backend,
+                                    target_triple=target_triple,
+                                    portable=portable,
+                                    optimization_level=optimization_level,
+                                    alignment_bytes=alignment_bytes,
+                                )
+                            ),
+                        )
+                    else:
+                        payload_binding = _build_prepared_native_direct_binding(
+                            source=source,
+                            role=cast(DirectRole, role),
+                            parent_component_counts=parent_component_counts,
+                            destination_component_count=destination_component_count,
+                            binding_coupling=binding_coupling,
+                            prepared_template_semantic_digest=(
+                                _prepared_template_contract_digest(
+                                    candidate,
+                                    backend=backend,
+                                    target_triple=target_triple,
+                                    portable=portable,
+                                    optimization_level=optimization_level,
+                                    alignment_bytes=alignment_bytes,
+                                )
+                            ),
+                        )
+            if payload_binding is None:
+                payload_binding = RecurrenceDirectPayloadBindingV1(
+                    kind="pending-direct-call-abi",
+                    prepared_kernel_id=kernel_id,
+                    payload_digest=_digest(
+                        {
+                            "contribution_parent_permutation": [0, 1],
+                            "kind": "pending-direct-call-abi",
+                            "prepared_kernel_id": kernel_id,
+                            "prepared_kernel_payload_digest": kernel_payload_digest,
+                            "required_backend_abi": RECURRENCE_DIRECT_BACKEND_ABI,
+                        }
+                    ),
+                )
+        candidate["payload_binding"] = payload_binding
+        candidates.append(candidate)
+
+    synthetic_binding_id = len(recurrence_catalog.evaluator_bindings)
+    identity_propagators = tuple(
+        propagator
+        for propagator in recurrence_catalog.propagators
+        if not propagator.applies_propagator
+    )
+    if identity_propagators:
+        identity_states = tuple(
+            states[propagator.state_template_id] for propagator in identity_propagators
+        )
+        maximum_component_count = max(state.dimension for state in identity_states)
+        identity_semantics = {
+            "abi": RECURRENCE_DIRECT_BACKEND_ABI,
+            "component_count_mode": "row",
+            "maximum_component_count": maximum_component_count,
+            "operation": RECURRENCE_DIRECT_IDENTITY_FINALIZER,
+            "state_semantic_digests": sorted(
+                state.semantic_digest for state in identity_states
+            ),
+        }
+        runtime_template = RECURRENCE_DIRECT_IDENTITY_FINALIZER
+        candidates.append(
+            {
+                "evaluator_binding_id": synthetic_binding_id,
+                "evaluator_resolver_key": runtime_template,
+                "role": "finalization",
+                "parent_component_counts": (maximum_component_count,),
+                "destination_component_count": maximum_component_count,
+                "momentum_operand_count": 1,
+                "coupling_slot_count": 0,
+                "parameter_slot_count": 0,
+                "semantic_template_ids": tuple(
+                    sorted(
+                        propagator.template_id for propagator in identity_propagators
+                    )
+                ),
+                "exact_expression_digest": _digest(identity_semantics),
+                "payload_binding": RecurrenceDirectPayloadBindingV1(
+                    kind="rusticol-intrinsic",
+                    runtime_template=runtime_template,
+                    payload_digest=_digest(
+                        {
+                            **identity_semantics,
+                            "contribution_parent_permutation": [0, 1],
+                            "runtime_template": runtime_template,
+                        }
+                    ),
+                ),
+                "template_id": "direct:identity-finalization",
+            }
+        )
+
+    candidates.sort(
+        key=lambda item: (
+            _ROLE_INDEX[cast(str, item["role"])],
+            cast(int, item["evaluator_binding_id"]),
+            cast(str, item["template_id"]),
+        )
+    )
+    templates = tuple(
+        RecurrenceDirectTemplateV1(
+            template_id=cast(str, item["template_id"]),
+            direct_executor_id=direct_executor_id,
+            evaluator_binding_id=cast(int, item["evaluator_binding_id"]),
+            evaluator_resolver_key=cast(str, item["evaluator_resolver_key"]),
+            role=cast(DirectRole, item["role"]),
+            parent_arity=len(cast(tuple[int, ...], item["parent_component_counts"])),
+            parent_component_counts=cast(
+                tuple[int, ...], item["parent_component_counts"]
+            ),
+            destination_component_count=cast(int, item["destination_component_count"]),
+            momentum_operand_count=cast(int, item["momentum_operand_count"]),
+            destination_operation=cast(
+                DirectDestinationOperation,
+                _DESTINATION_OPERATIONS[cast(str, item["role"])],
+            ),
+            coupling_slot_count=cast(int, item["coupling_slot_count"]),
+            parameter_slot_count=cast(int, item["parameter_slot_count"]),
+            semantic_template_ids=cast(tuple[str, ...], item["semantic_template_ids"]),
+            exact_expression_digest=cast(str, item["exact_expression_digest"]),
+            payload_binding=cast(
+                RecurrenceDirectPayloadBindingV1, item["payload_binding"]
+            ),
+            backend=backend,
+            target_triple=target_triple,
+            portable=portable,
+            optimization_level=optimization_level,
+            alignment_bytes=alignment_bytes,
+            simd_axis="points-contiguous",
+            destination_aliasing=item["role"] == "finalization",
+        )
+        for direct_executor_id, item in enumerate(candidates)
+    )
+    return RecurrenceDirectTemplateCatalogV1(
+        templates=templates,
+        backend=backend,
+        target_triple=target_triple,
+        portable=portable,
+        optimization_level=optimization_level,
+        compiled_model_digest=recurrence_catalog.header.compiled_model_digest,
+        recurrence_template_catalog_digest=recurrence_catalog.catalog_digest,
+        prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+        prepared_kernel_contract_digest=prepared_kernel_contract_digest,
+        prepared_kernel_payload_digest=prepared_kernel_payload_digest,
+        optimization_settings_digest=optimization_settings_digest,
+    )
+
+
+def _prepared_template_contract_digest(
+    candidate: Mapping[str, object],
+    *,
+    backend: DirectBackend,
+    target_triple: str,
+    portable: bool,
+    optimization_level: int,
+    alignment_bytes: int,
+) -> str:
+    """Authenticate template semantics without creating a payload-digest cycle."""
+
+    return _digest(
+        {
+            "abi": RECURRENCE_DIRECT_TEMPLATE_ABI,
+            "alignment_bytes": alignment_bytes,
+            "backend": backend,
+            "coupling_slot_count": candidate["coupling_slot_count"],
+            "destination_aliasing": candidate["role"] == "finalization",
+            "destination_component_count": candidate["destination_component_count"],
+            "destination_operation": _DESTINATION_OPERATIONS[
+                cast(str, candidate["role"])
+            ],
+            "evaluator_binding_id": candidate["evaluator_binding_id"],
+            "evaluator_resolver_key": candidate["evaluator_resolver_key"],
+            "exact_expression_digest": candidate["exact_expression_digest"],
+            "momentum_operand_count": candidate["momentum_operand_count"],
+            "optimization_level": optimization_level,
+            "parameter_slot_count": candidate["parameter_slot_count"],
+            "parent_component_counts": list(
+                cast(tuple[int, ...], candidate["parent_component_counts"])
+            ),
+            "portable": portable,
+            "role": candidate["role"],
+            "semantic_template_ids": list(
+                cast(tuple[str, ...], candidate["semantic_template_ids"])
+            ),
+            "simd_axis": "points-contiguous",
+            "target_triple": target_triple,
+            "template_id": candidate["template_id"],
+        }
+    )
+
+
+def _build_prepared_jit_direct_binding(
+    *,
+    source: PreparedJitDirectSourceV1,
+    role: DirectRole,
+    parent_component_counts: tuple[int, ...],
+    destination_component_count: int,
+    binding_coupling: ExactComplexRationalV1 | None,
+    prepared_template_semantic_digest: str,
+) -> RecurrenceDirectPayloadBindingV1:
+    if role == "source":
+        raise RecurrenceDirectTemplateError(
+            "recurrence sources must remain Rusticol SourceIR intrinsics"
+        )
+    contracts = _decode_canonical_objects(source.input_contracts)
+    input_plane_projections: list[dict[str, object]] = []
+    scalar_projections: list[dict[str, object]] = [
+        {"imaginary": False, "kind": "exact-factor"},
+        {"imaginary": True, "kind": "exact-factor"},
+    ]
+    parameter_bindings: list[dict[str, object]] = []
+    zero_scalar_index: int | None = None
+
+    def append_zero_scalar_binding() -> None:
+        nonlocal zero_scalar_index
+        if zero_scalar_index is None:
+            zero_scalar_index = len(scalar_projections)
+            scalar_projections.append({"kind": "literal", "value": 0.0})
+        parameter_bindings.append({"index": zero_scalar_index, "kind": "scalar"})
+
+    for contract in contracts:
+        if not isinstance(contract, Mapping):
+            raise RecurrenceDirectTemplateError(
+                "prepared JIT direct input contract must be an object"
+            )
+        input_role = contract.get("role")
+        component = _require_nonnegative_int(
+            "prepared JIT direct input component", contract.get("component")
+        )
+        if input_role in {"left-current", "right-current", "current"}:
+            parent = 1 if input_role == "right-current" else 0
+            if parent >= len(parent_component_counts):
+                raise RecurrenceDirectTemplateError(
+                    f"prepared JIT direct {input_role} input has no parent"
+                )
+            for imaginary in (False, True):
+                parameter_bindings.append(
+                    {"index": len(input_plane_projections), "kind": "plane"}
+                )
+                input_plane_projections.append(
+                    {
+                        "component": component,
+                        "imaginary": imaginary,
+                        "kind": "parent-current",
+                        "parent": parent,
+                    }
+                )
+        elif input_role in {"left-momentum", "right-momentum", "momentum"}:
+            operand = 1 if input_role == "right-momentum" else 0
+            parameter_bindings.append(
+                {"index": len(input_plane_projections), "kind": "plane"}
+            )
+            input_plane_projections.append(
+                {
+                    "kind": "momentum",
+                    "lorentz_component": component,
+                    "operand": operand,
+                }
+            )
+            # Portable complex SymJIT applications expose every original input
+            # as adjacent real/imaginary parameters. Physical momenta are real.
+            append_zero_scalar_binding()
+        elif input_role in {"coupling-real", "coupling-imag"}:
+            if binding_coupling is None:
+                raise RecurrenceDirectTemplateError(
+                    "prepared JIT direct coupling input has no uniform exact "
+                    "semantic binding"
+                )
+            scalar_index = len(scalar_projections)
+            parameter_bindings.append({"index": scalar_index, "kind": "scalar"})
+            scalar_projections.append(
+                {
+                    "kind": "literal",
+                    "value": float(
+                        binding_coupling.imag
+                        if input_role == "coupling-imag"
+                        else binding_coupling.real
+                    ),
+                }
+            )
+            append_zero_scalar_binding()
+        elif input_role == "model-parameter":
+            parameter_index = _require_nonnegative_int(
+                "prepared JIT direct model-parameter index",
+                contract.get("model_parameter_index"),
+            )
+            for imaginary in (False, True):
+                scalar_index = len(scalar_projections)
+                parameter_bindings.append({"index": scalar_index, "kind": "scalar"})
+                scalar_projections.append(
+                    {
+                        "imaginary": imaginary,
+                        "index": parameter_index,
+                        "kind": "parameter",
+                    }
+                )
+        else:
+            raise RecurrenceDirectTemplateError(
+                f"unsupported prepared JIT direct input role {input_role!r}"
+            )
+
+    destination_kind = (
+        "destination-amplitude" if role == "closure" else "destination-current"
+    )
+    output_alias_inputs: list[int] = []
+    for component in range(source.output_arity):
+        if component >= destination_component_count:
+            raise RecurrenceDirectTemplateError(
+                "prepared JIT direct output exceeds destination component count"
+            )
+        for imaginary in (False, True):
+            output_alias_inputs.append(len(input_plane_projections))
+            input_plane_projections.append(
+                {
+                    "component": component,
+                    "imaginary": imaginary,
+                    "kind": destination_kind,
+                }
+            )
+
+    metadata: dict[str, object] = {
+        "abi": RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI,
+        "contribution_parent_permutation": [0, 1],
+        "destination_operation": _DESTINATION_OPERATIONS[role],
+        "direct_application_abi": SYMJIT_DIRECT_APPLICATION_ABI,
+        "exact_factor_scalar_slots": [0, 1],
+        "input_plane_count": len(input_plane_projections),
+        "input_plane_projections": input_plane_projections,
+        "intrinsic_contract_digest": None,
+        "kind": "prepared-direct-call",
+        "output_alias_inputs": output_alias_inputs,
+        "parameter_bindings": parameter_bindings,
+        "payload_paths": [source.source_application_path],
+        "prepared_kernel_id": source.prepared_kernel_id,
+        "prepared_template_semantic_digest": prepared_template_semantic_digest,
+        "role": role,
+        "runtime_template": None,
+        "scalar_input_count": len(scalar_projections),
+        "scalar_projections": scalar_projections,
+        "source_application_abi": source.source_application_abi,
+        "source_application_path": source.source_application_path,
+        "source_application_sha256": source.source_application_sha256,
+        "state_plane_indices": [],
+    }
+    return RecurrenceDirectPayloadBindingV1(
+        kind="prepared-direct-call",
+        payload_digest=_digest(metadata),
+        prepared_kernel_id=source.prepared_kernel_id,
+        payload_paths=(source.source_application_path,),
+        source_application_path=source.source_application_path,
+        source_application_sha256=source.source_application_sha256,
+        source_application_abi=source.source_application_abi,
+        direct_application_abi=SYMJIT_DIRECT_APPLICATION_ABI,
+        role=role,
+        destination_operation=cast(
+            DirectDestinationOperation, _DESTINATION_OPERATIONS[role]
+        ),
+        exact_factor_scalar_slots=(0, 1),
+        state_plane_indices=(),
+        parameter_bindings=_encode_canonical_objects(parameter_bindings),
+        input_plane_count=len(input_plane_projections),
+        scalar_input_count=len(scalar_projections),
+        output_alias_inputs=tuple(output_alias_inputs),
+        input_plane_projections=_encode_canonical_objects(input_plane_projections),
+        scalar_projections=_encode_canonical_objects(scalar_projections),
+        prepared_template_semantic_digest=prepared_template_semantic_digest,
+    )
+
+
+def _build_prepared_native_direct_binding(
+    *,
+    source: PreparedNativeDirectSourceV1,
+    role: DirectRole,
+    parent_component_counts: tuple[int, ...],
+    destination_component_count: int,
+    binding_coupling: ExactComplexRationalV1 | None,
+    prepared_template_semantic_digest: str,
+) -> RecurrenceDirectPayloadBindingV1:
+    """Bind one native export while authenticating JIT-equivalent projections."""
+
+    if source.role != role:
+        raise RecurrenceDirectTemplateError(
+            "prepared native direct source role does not match its template"
+        )
+    if source.native_entry_point != native_direct_entry_point(
+        role, source.prepared_kernel_id
+    ):
+        raise RecurrenceDirectTemplateError(
+            "prepared native direct source entry point is not canonical"
+        )
+    # The scalar and plane projection contract is backend-independent. Reuse the
+    # established JIT projection derivation only as authenticated metadata; the
+    # native executable consumes arena views and typed rows directly and never
+    # packs these projections at runtime.
+    projected = _build_prepared_jit_direct_binding(
+        source=PreparedJitDirectSourceV1(
+            prepared_kernel_id=source.prepared_kernel_id,
+            source_application_path=source.source_application_path,
+            source_application_sha256=source.source_application_sha256,
+            source_application_abi=source.source_application_abi,
+            input_contracts=source.input_contracts,
+            exact_expressions=source.exact_expressions,
+            output_arity=source.output_arity,
+        ),
+        role=role,
+        parent_component_counts=parent_component_counts,
+        destination_component_count=destination_component_count,
+        binding_coupling=binding_coupling,
+        prepared_template_semantic_digest=prepared_template_semantic_digest,
+    )
+    metadata = projected._prepared_call_fields(include_payload_digest=False)
+    metadata["direct_application_abi"] = NATIVE_DIRECT_APPLICATION_ABI
+    metadata["native_entry_point"] = source.native_entry_point
+    return replace(
+        projected,
+        direct_application_abi=NATIVE_DIRECT_APPLICATION_ABI,
+        native_entry_point=source.native_entry_point,
+        payload_digest=_digest(metadata),
+    )
+
+
+def _build_certified_intrinsic_binding(
+    certified: CertifiedRecurrenceIntrinsic,
+) -> RecurrenceDirectPayloadBindingV1:
+    runtime_template = _require_nonempty(
+        "certified intrinsic runtime template",
+        certified.runtime_template,
+    )
+    contract_digest = _require_sha256(
+        "certified intrinsic contract digest",
+        certified.contract_digest,
+    )
+    scale = certified.scale_projection()
+    metadata = {
+        "abi": RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI,
+        "contribution_parent_permutation": list(certified.parent_permutation),
+        "destination_operation": "add",
+        "intrinsic_contract_digest": contract_digest,
+        "kind": "rusticol-intrinsic",
+        "role": "contribution",
+        "runtime_template": runtime_template,
+        "scalar_input_count": 1,
+        "scalar_projections": [scale],
+    }
+    return RecurrenceDirectPayloadBindingV1(
+        kind="rusticol-intrinsic",
+        payload_digest=_digest(metadata),
+        runtime_template=runtime_template,
+        role="contribution",
+        destination_operation="add",
+        scalar_input_count=1,
+        scalar_projections=_encode_canonical_objects((scale,)),
+        intrinsic_contract_digest=contract_digest,
+        contribution_parent_permutation=certified.parent_permutation,
+    )
+
+
+def _build_runtime_intrinsic_binding(
+    *,
+    runtime_template: str,
+) -> RecurrenceDirectPayloadBindingV1:
+    runtime_template = _require_nonempty(
+        "direct intrinsic runtime template", runtime_template
+    )
+    metadata = {
+        "abi": RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI,
+        "contribution_parent_permutation": [0, 1],
+        "kind": "rusticol-intrinsic",
+        "runtime_template": runtime_template,
+    }
+    return RecurrenceDirectPayloadBindingV1(
+        kind="rusticol-intrinsic",
+        payload_digest=_digest(metadata),
+        runtime_template=runtime_template,
+    )
+
+
+def _source_uses_inline_coupling(source: PreparedJitDirectSourceV1) -> bool:
+    return _input_contracts_use_inline_coupling(source.input_contracts)
+
+
+def _input_contracts_use_inline_coupling(
+    input_contracts: Sequence[str],
+) -> bool:
+    for contract in _decode_canonical_objects(input_contracts):
+        if isinstance(contract, Mapping) and contract.get("role") in {
+            "coupling-real",
+            "coupling-imag",
+        }:
+            return True
+    return False
+
+
+def _uniform_binding_coupling(
+    semantic_template_ids: Sequence[str],
+    semantic_records: Mapping[str, object],
+    *,
+    required: bool,
+) -> ExactComplexRationalV1 | None:
+    if not required:
+        return None
+    couplings: set[ExactComplexRationalV1] = set()
+    missing: list[str] = []
+    for template_id in semantic_template_ids:
+        record = semantic_records.get(template_id)
+        coupling = getattr(record, "binding_coupling", None)
+        if not isinstance(coupling, ExactComplexRationalV1):
+            missing.append(template_id)
+        else:
+            couplings.add(coupling)
+    if missing:
+        raise RecurrenceDirectTemplateError(
+            "prepared JIT direct coupling input is not owned by every semantic "
+            "template: " + ", ".join(sorted(missing))
+        )
+    if len(couplings) != 1:
+        raise RecurrenceDirectTemplateError(
+            "one prepared JIT direct evaluator binding has conflicting exact "
+            "semantic couplings"
+        )
+    return next(iter(couplings))
+
+
+def _slot_counts(
+    semantic_template_ids: Sequence[str],
+    semantic_records: Mapping[str, object],
+    input_layout: Sequence[str],
+) -> tuple[int, int]:
+    coupling_ids: set[str] = set()
+    parameter_ids: set[str] = set()
+    for template_id in semantic_template_ids:
+        record = semantic_records.get(template_id)
+        if record is None:
+            continue
+        coupling_ids.update(getattr(record, "coupling_parameter_ids", ()))
+        for name in ("mass_parameter_id", "width_parameter_id"):
+            value = getattr(record, name, None)
+            if value is not None:
+                parameter_ids.add(str(value))
+    for raw in input_layout:
+        try:
+            contract = json.loads(raw)
+        except (TypeError, json.JSONDecodeError):
+            continue
+        if not isinstance(contract, Mapping):
+            continue
+        model_parameter = contract.get("model_parameter_name")
+        role = contract.get("role")
+        if isinstance(model_parameter, str) and model_parameter:
+            if isinstance(role, str) and "coupling" in role:
+                coupling_ids.add(model_parameter)
+            else:
+                parameter_ids.add(model_parameter)
+    return len(coupling_ids), len(parameter_ids)
+
+
+def _canonical_parent_component_counts(
+    semantic_template_ids: Sequence[str],
+    semantic_records: Mapping[str, object],
+    concrete_counts: tuple[int, ...],
+) -> tuple[int, ...]:
+    canonical_shapes: set[tuple[int, ...]] = set()
+    for template_id in semantic_template_ids:
+        record = semantic_records.get(template_id)
+        order = getattr(record, "canonical_input_order", None)
+        if order is None:
+            continue
+        if len(order) != len(concrete_counts) or set(order) != set(
+            range(len(concrete_counts))
+        ):
+            raise RecurrenceDirectTemplateError(
+                f"semantic template {template_id!r} has an invalid canonical "
+                "input order"
+            )
+        canonical_shapes.add(tuple(concrete_counts[index] for index in order))
+    if len(canonical_shapes) > 1:
+        raise RecurrenceDirectTemplateError(
+            "one evaluator binding has incompatible canonical parent shapes"
+        )
+    return next(iter(canonical_shapes), concrete_counts)
+
+
+def prepared_kernel_payload_digest(
+    *,
+    kernel_id: int,
+    payload_records: Mapping[str, tuple[int, str]],
+    referenced_paths: Sequence[str],
+) -> str:
+    """Digest exactly the payload bytes referenced by one prepared kernel."""
+
+    rows: list[dict[str, object]] = []
+    for path in sorted(set(referenced_paths)):
+        try:
+            size, digest = payload_records[path]
+        except KeyError as exc:
+            raise RecurrenceDirectTemplateError(
+                f"prepared kernel {kernel_id} payload {path!r} is absent"
+            ) from exc
+        _require_nonnegative_int(f"prepared payload {path!r} size", size)
+        _require_sha256(f"prepared payload {path!r} digest", digest)
+        rows.append({"path": path, "sha256": digest, "size": size})
+    if not rows:
+        raise RecurrenceDirectTemplateError(
+            f"prepared kernel {kernel_id} has no payload identity records"
+        )
+    return _digest(
+        {
+            "abi": RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI,
+            "kernel_id": kernel_id,
+            "payloads": rows,
+        }
+    )
+
+
+__all__ = [
+    "NATIVE_DIRECT_APPLICATION_ABI",
+    "RECURRENCE_DIRECT_BACKEND_ABI",
+    "RECURRENCE_DIRECT_CANONICALIZATION_ABI",
+    "RECURRENCE_DIRECT_IDENTITY_FINALIZER",
+    "RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI",
+    "RECURRENCE_DIRECT_TEMPLATE_ABI",
+    "SYMJIT_DIRECT_APPLICATION_ABI",
+    "PreparedJitDirectSourceV1",
+    "PreparedNativeDirectCallableSpecV1",
+    "PreparedNativeDirectSourceV1",
+    "RecurrenceDirectPayloadBindingV1",
+    "RecurrenceDirectTemplateCatalogV1",
+    "RecurrenceDirectTemplateError",
+    "RecurrenceDirectTemplateV1",
+    "build_prepared_native_direct_callable_specs",
+    "build_recurrence_direct_template_catalog",
+    "native_direct_entry_point",
+    "prepared_kernel_payload_digest",
+]
diff --git a/pyamplicol/src/pyamplicol/models/recurrence_template.py b/pyamplicol/src/pyamplicol/models/recurrence_template.py
new file mode 100644
index 0000000000..5efb62eab3
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/recurrence_template.py
@@ -0,0 +1,3949 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact, model-generic semantic templates for recurrence execution.
+
+This module defines the Python side of ``pyamplicol-recurrence-template-v1``.
+It intentionally contains no model implementation and no evaluator-building
+logic.  A catalog is a content-addressed statement of model semantics that a
+later recurrence builder may consume only after all references and digests
+have been checked.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from fractions import Fraction
+from typing import ClassVar, Literal, TypeAlias
+
+RECURRENCE_TEMPLATE_ABI = "pyamplicol-recurrence-template-v1"
+RECURRENCE_TEMPLATE_CANONICALIZATION_ABI = "pyamplicol-canonical-json-v1"
+RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI = "pyamplicol-exact-complex-rational-v1"
+_DYNAMIC_UNION_SOURCE_SPIN_STATE = -(1 << 31)
+
+ParameterKind: TypeAlias = Literal["external", "derived", "constant"]
+ParameterValueType: TypeAlias = Literal["real", "complex"]
+EvaluatorContractKind: TypeAlias = Literal[
+    "source",
+    "vertex",
+    "propagator",
+    "closure",
+    "model-parameter",
+]
+EvaluatorCallableKind: TypeAlias = Literal["prepared-kernel", "rusticol-template"]
+PreparedOutputFactorSource: TypeAlias = Literal[
+    "none",
+    "coupling-real",
+    "coupling-imag",
+]
+FlavourFlowV1: TypeAlias = tuple[int, ...]
+QuantumNumberFlowV1: TypeAlias = tuple[tuple[str, str], ...]
+FlavourFlowOperationV1: TypeAlias = Literal[
+    "constant-result",
+    "append-left-result",
+    "append-right-result",
+    "concat-left-right-result",
+]
+QuantumNumberFlowOperationV1: TypeAlias = Literal["particle-static-result"]
+LCColorShapeKindV1: TypeAlias = Literal[
+    "singlet-forest",
+    "fundamental-open-string",
+    "antifundamental-open-string",
+    "adjoint-segment",
+]
+LCColorComponentKindV1: TypeAlias = Literal["open-string", "adjoint-segment", "trace"]
+LCColorComponentRoleV1: TypeAlias = Literal["active", "passive", "none"]
+LCColorSourceSeedOperationV1: TypeAlias = Literal["empty", "singleton"]
+LCColorComponentOperationV1: TypeAlias = Literal[
+    "concatenate-join",
+    "concatenate-keep",
+    "inherit-left",
+    "inherit-right",
+    "empty",
+    "close",
+]
+
+SUPPORTED_SYMMETRY_PROOF_ALGORITHMS = frozenset(
+    {
+        "canonical-crossing-bijection-v1",
+        "canonical-current-word-reversal-v1",
+        "canonical-kernel-input-exchange-v1",
+        "canonical-model-contract-label-equivariance-v1",
+        "canonical-recurrence-replay-witness-v1",
+        "canonical-recurrence-union-witness-v1",
+        "canonical-source-transition-dependency-shape-v1",
+        "canonical-trace-amplitude-reversal-v1",
+        "exact-expression-identity-v1",
+        "prepared-kernel-homogeneous-complex-linear-current-v1",
+        "prepared-kernel-independent-current-block-v1",
+    }
+)
+
+_PARAMETER_KINDS = frozenset({"external", "derived", "constant"})
+_PARAMETER_VALUE_TYPES = frozenset({"real", "complex"})
+_ORIENTATIONS = frozenset({"particle", "antiparticle", "self-conjugate"})
+_STATISTICS = frozenset({"boson", "fermion"})
+_WAVEFUNCTION_FAMILIES = frozenset(
+    {"scalar", "fermion", "vector", "spin2", "ghost", "auxiliary"}
+)
+_EVALUATOR_CONTRACT_KINDS = frozenset(
+    {"source", "vertex", "propagator", "closure", "model-parameter"}
+)
+_EVALUATOR_CALLABLE_KINDS = frozenset({"prepared-kernel", "rusticol-template"})
+_OUTPUT_FACTOR_SOURCES = frozenset({"none", "coupling-real", "coupling-imag"})
+_FLAVOUR_FLOW_OPERATIONS = frozenset(
+    {
+        "constant-result",
+        "append-left-result",
+        "append-right-result",
+        "concat-left-right-result",
+    }
+)
+_QUANTUM_NUMBER_FLOW_OPERATIONS = frozenset({"particle-static-result"})
+_LC_COLOR_SHAPE_KINDS = frozenset(
+    {
+        "singlet-forest",
+        "fundamental-open-string",
+        "antifundamental-open-string",
+        "adjoint-segment",
+    }
+)
+_LC_COLOR_COMPONENT_KINDS = frozenset({"open-string", "adjoint-segment", "trace"})
+_LC_COLOR_COMPONENT_ROLES = frozenset({"active", "passive", "none"})
+_LC_COLOR_SOURCE_SEED_OPERATIONS = frozenset({"empty", "singleton"})
+_LC_COLOR_COMPONENT_OPERATIONS = frozenset(
+    {
+        "concatenate-join",
+        "concatenate-keep",
+        "inherit-left",
+        "inherit-right",
+        "empty",
+        "close",
+    }
+)
+_HEX = frozenset("0123456789abcdef")
+
+
+class RecurrenceTemplateError(ValueError):
+    """Raised when a recurrence semantic catalog is not canonical or complete."""
+
+
+def _validate_rusticol_runtime_template(
+    contract_kind: EvaluatorContractKind,
+    runtime_template: str,
+    callable_signature: str,
+) -> None:
+    suffix = f":{callable_signature[:24]}"
+    if contract_kind == "source":
+        prefix = "rusticol.source-fill."
+        version = ".v1"
+        if not runtime_template.startswith(prefix) or not runtime_template.endswith(
+            version + suffix
+        ):
+            raise RecurrenceTemplateError(
+                "source Rusticol template must use the authenticated "
+                "rusticol.source-fill.<family>.v1:<signature> contract"
+            )
+        family = runtime_template[len(prefix) : -len(version + suffix)]
+        if family not in _WAVEFUNCTION_FAMILIES:
+            raise RecurrenceTemplateError(
+                f"unsupported Rusticol source-fill family {family!r}"
+            )
+        return
+    if contract_kind == "closure":
+        expected = f"rusticol.closure-reduce.v1{suffix}"
+        if runtime_template != expected:
+            raise RecurrenceTemplateError(
+                "closure Rusticol template does not match its callable signature"
+            )
+        return
+    raise RecurrenceTemplateError(
+        f"Rusticol template callable is not registered for {contract_kind!r}"
+    )
+
+
+def _canonical_json(payload: object) -> str:
+    try:
+        return json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+    except (TypeError, ValueError) as exc:
+        raise RecurrenceTemplateError(
+            "recurrence template payload is not canonical JSON"
+        ) from exc
+
+
+def _digest(payload: object) -> str:
+    return hashlib.sha256(_canonical_json(payload).encode("ascii")).hexdigest()
+
+
+def _require_sha256(name: str, value: object) -> str:
+    if (
+        not isinstance(value, str)
+        or len(value) != 64
+        or any(character not in _HEX for character in value)
+    ):
+        raise RecurrenceTemplateError(f"{name} must be a lowercase SHA-256")
+    return value
+
+
+def _require_optional_sha256(name: str, value: object) -> str | None:
+    if value is None:
+        return None
+    return _require_sha256(name, value)
+
+
+def _require_nonempty(name: str, value: object) -> str:
+    if not isinstance(value, str) or not value:
+        raise RecurrenceTemplateError(f"{name} must be a nonempty string")
+    return value
+
+
+def _require_int(name: str, value: object, *, minimum: int | None = None) -> int:
+    if type(value) is not int:
+        raise RecurrenceTemplateError(f"{name} must be an integer")
+    if minimum is not None and value < minimum:
+        raise RecurrenceTemplateError(f"{name} must be at least {minimum}")
+    return value
+
+
+def _require_tuple(name: str, value: object) -> tuple[object, ...]:
+    if not isinstance(value, tuple):
+        raise RecurrenceTemplateError(f"{name} must be an immutable tuple")
+    return value
+
+
+def _require_string_tuple(
+    name: str,
+    value: object,
+    *,
+    nonempty: bool = False,
+    sorted_unique: bool = False,
+) -> tuple[str, ...]:
+    items = _require_tuple(name, value)
+    if any(not isinstance(item, str) or not item for item in items):
+        raise RecurrenceTemplateError(f"{name} must contain only nonempty strings")
+    result = tuple(items)
+    if nonempty and not result:
+        raise RecurrenceTemplateError(f"{name} must not be empty")
+    if sorted_unique and result != tuple(sorted(set(result))):
+        raise RecurrenceTemplateError(f"{name} must be sorted and unique")
+    return result
+
+
+def _require_int_tuple(
+    name: str,
+    value: object,
+    *,
+    nonempty: bool = False,
+) -> tuple[int, ...]:
+    items = _require_tuple(name, value)
+    if any(type(item) is not int for item in items):
+        raise RecurrenceTemplateError(f"{name} must contain only integers")
+    result = tuple(items)
+    if nonempty and not result:
+        raise RecurrenceTemplateError(f"{name} must not be empty")
+    return result
+
+
+def _require_concrete_spin_state(name: str, value: object) -> int:
+    result = _require_int(name, value)
+    if result == _DYNAMIC_UNION_SOURCE_SPIN_STATE:
+        raise RecurrenceTemplateError(
+            f"{name} uses the reserved dynamic-union sentinel"
+        )
+    return result
+
+
+def _require_concrete_spin_states(
+    name: str,
+    value: object,
+) -> tuple[int, ...]:
+    result = _require_int_tuple(name, value)
+    if _DYNAMIC_UNION_SOURCE_SPIN_STATE in result:
+        raise RecurrenceTemplateError(
+            f"{name} uses the reserved dynamic-union sentinel"
+        )
+    return result
+
+
+def _require_permutation(name: str, value: object, arity: int) -> tuple[int, ...]:
+    result = _require_int_tuple(name, value)
+    if result != tuple(sorted(result)) and set(result) != set(range(arity)):
+        raise RecurrenceTemplateError(f"{name} is not a permutation of its inputs")
+    if len(result) != arity or set(result) != set(range(arity)):
+        raise RecurrenceTemplateError(f"{name} is not a permutation of its inputs")
+    return result
+
+
+def _require_exact_keys(
+    name: str,
+    payload: Mapping[str, object],
+    expected: frozenset[str],
+) -> None:
+    actual = frozenset(payload)
+    if actual != expected:
+        unknown = sorted(actual - expected)
+        missing = sorted(expected - actual)
+        details: list[str] = []
+        if unknown:
+            details.append("unknown=" + ",".join(unknown))
+        if missing:
+            details.append("missing=" + ",".join(missing))
+        raise RecurrenceTemplateError(
+            f"{name} has noncanonical fields ({'; '.join(details)})"
+        )
+
+
+def _require_mapping(name: str, value: object) -> Mapping[str, object]:
+    if not isinstance(value, Mapping) or any(not isinstance(key, str) for key in value):
+        raise RecurrenceTemplateError(f"{name} must be a string-keyed object")
+    return value
+
+
+def _decode_string_tuple(name: str, value: object) -> tuple[str, ...]:
+    if not isinstance(value, list) or any(not isinstance(item, str) for item in value):
+        raise RecurrenceTemplateError(f"{name} must be a JSON string array")
+    return tuple(value)
+
+
+def _decode_int_tuple(name: str, value: object) -> tuple[int, ...]:
+    if not isinstance(value, list) or any(type(item) is not int for item in value):
+        raise RecurrenceTemplateError(f"{name} must be a JSON integer array")
+    return tuple(value)
+
+
+def _decode_string_pairs(
+    name: str,
+    value: object,
+) -> tuple[tuple[str, str], ...]:
+    if not isinstance(value, list):
+        raise RecurrenceTemplateError(f"{name} must be a JSON array")
+    result: list[tuple[str, str]] = []
+    for index, item in enumerate(value):
+        if (
+            not isinstance(item, list)
+            or len(item) != 2
+            or any(not isinstance(part, str) or not part for part in item)
+        ):
+            raise RecurrenceTemplateError(
+                f"{name} row {index} must contain two nonempty strings"
+            )
+        result.append((item[0], item[1]))
+    return tuple(result)
+
+
+def _require_flavour_flow(name: str, value: object) -> FlavourFlowV1:
+    result = _require_int_tuple(name, value, nonempty=True)
+    return tuple(result)
+
+
+def _require_quantum_number_flow(
+    name: str,
+    value: object,
+) -> QuantumNumberFlowV1:
+    items = _require_tuple(name, value)
+    result: list[tuple[str, str]] = []
+    for item in items:
+        if not isinstance(item, tuple) or len(item) != 2:
+            raise RecurrenceTemplateError(
+                f"{name} must contain immutable (name, expression) pairs"
+            )
+        quantum_name = _require_nonempty(f"{name} name", item[0])
+        expression = _require_nonempty(f"{name} expression", item[1])
+        result.append((quantum_name, expression))
+    normalized = tuple(result)
+    names = tuple(item[0] for item in normalized)
+    if names != tuple(sorted(set(names))):
+        raise RecurrenceTemplateError(f"{name} names must be sorted and unique")
+    return normalized
+
+
+def _decode_flavour_flow(name: str, value: object) -> FlavourFlowV1:
+    if not isinstance(value, list):
+        raise RecurrenceTemplateError(f"{name} must be a JSON integer array")
+    return _require_flavour_flow(name, tuple(value))
+
+
+def _decode_flavour_flows(
+    name: str,
+    value: object,
+) -> tuple[FlavourFlowV1, ...]:
+    if not isinstance(value, list):
+        raise RecurrenceTemplateError(f"{name} must be a JSON array")
+    return tuple(
+        _decode_flavour_flow(f"{name}[{index}]", item)
+        for index, item in enumerate(value)
+    )
+
+
+def _decode_quantum_number_flow(
+    name: str,
+    value: object,
+) -> QuantumNumberFlowV1:
+    if not isinstance(value, list):
+        raise RecurrenceTemplateError(f"{name} must be a JSON pair array")
+    pairs: list[tuple[object, object]] = []
+    for index, item in enumerate(value):
+        if not isinstance(item, list) or len(item) != 2:
+            raise RecurrenceTemplateError(
+                f"{name}[{index}] must be a JSON [name, expression] pair"
+            )
+        pairs.append((item[0], item[1]))
+    return _require_quantum_number_flow(name, tuple(pairs))
+
+
+def _decode_quantum_number_flows(
+    name: str,
+    value: object,
+) -> tuple[QuantumNumberFlowV1, ...]:
+    if not isinstance(value, list):
+        raise RecurrenceTemplateError(f"{name} must be a JSON array")
+    return tuple(
+        _decode_quantum_number_flow(f"{name}[{index}]", item)
+        for index, item in enumerate(value)
+    )
+
+
+def _decode_optional_string(name: str, value: object) -> str | None:
+    if value is None:
+        return None
+    return _require_nonempty(name, value)
+
+
+def _canonical_decimal_integer(name: str, value: object) -> int:
+    if not isinstance(value, str):
+        raise RecurrenceTemplateError(f"{name} must be a decimal integer string")
+    if value == "0":
+        return 0
+    negative = value.startswith("-")
+    digits = value[1:] if negative else value
+    if not digits or not digits.isascii() or not digits.isdigit():
+        raise RecurrenceTemplateError(f"{name} is not a decimal integer")
+    if digits.startswith("0"):
+        raise RecurrenceTemplateError(f"{name} is not canonically encoded")
+    parsed = int(value, 10)
+    if str(parsed) != value:
+        raise RecurrenceTemplateError(f"{name} is not canonically encoded")
+    return parsed
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class ExactComplexRationalV1:
+    """One exact complex number represented by two reduced fractions."""
+
+    real_numerator: int
+    real_denominator: int
+    imag_numerator: int
+    imag_denominator: int
+
+    def __post_init__(self) -> None:
+        for name in ("real_numerator", "imag_numerator"):
+            _require_int(name, getattr(self, name))
+        for name in ("real_denominator", "imag_denominator"):
+            _require_int(name, getattr(self, name), minimum=1)
+        for component in ("real", "imag"):
+            numerator = getattr(self, f"{component}_numerator")
+            denominator = getattr(self, f"{component}_denominator")
+            if numerator == 0 and denominator != 1:
+                raise RecurrenceTemplateError(
+                    f"{component} zero must be encoded as 0/1"
+                )
+            if math.gcd(abs(numerator), denominator) != 1:
+                raise RecurrenceTemplateError(f"{component} fraction must be reduced")
+
+    @classmethod
+    def zero(cls) -> ExactComplexRationalV1:
+        return cls(0, 1, 0, 1)
+
+    @classmethod
+    def one(cls) -> ExactComplexRationalV1:
+        return cls(1, 1, 0, 1)
+
+    @classmethod
+    def from_fractions(
+        cls,
+        real: Fraction | int,
+        imag: Fraction | int = 0,
+    ) -> ExactComplexRationalV1:
+        real_fraction = Fraction(real)
+        imag_fraction = Fraction(imag)
+        return cls(
+            real_fraction.numerator,
+            real_fraction.denominator,
+            imag_fraction.numerator,
+            imag_fraction.denominator,
+        )
+
+    @classmethod
+    def from_binary64(
+        cls,
+        real: float,
+        imag: float = 0.0,
+    ) -> ExactComplexRationalV1:
+        """Convert binary64 components without decimal or rounded arithmetic."""
+
+        if type(real) is not float or type(imag) is not float:
+            raise RecurrenceTemplateError(
+                "binary64 conversion requires float components"
+            )
+        if not math.isfinite(real) or not math.isfinite(imag):
+            raise RecurrenceTemplateError("binary64 proof coefficients must be finite")
+        real_numerator, real_denominator = real.as_integer_ratio()
+        imag_numerator, imag_denominator = imag.as_integer_ratio()
+        return cls(
+            real_numerator,
+            real_denominator,
+            imag_numerator,
+            imag_denominator,
+        )
+
+    @classmethod
+    def from_complex_binary64(cls, value: complex) -> ExactComplexRationalV1:
+        if type(value) is not complex:
+            raise RecurrenceTemplateError(
+                "complex binary64 conversion requires a complex value"
+            )
+        return cls.from_binary64(float(value.real), float(value.imag))
+
+    @property
+    def real(self) -> Fraction:
+        return Fraction(self.real_numerator, self.real_denominator)
+
+    @property
+    def imag(self) -> Fraction:
+        return Fraction(self.imag_numerator, self.imag_denominator)
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "imag_denominator": str(self.imag_denominator),
+            "imag_numerator": str(self.imag_numerator),
+            "real_denominator": str(self.real_denominator),
+            "real_numerator": str(self.real_numerator),
+        }
+
+    @classmethod
+    def from_dict(cls, payload: Mapping[str, object]) -> ExactComplexRationalV1:
+        value = _require_mapping("exact complex rational", payload)
+        _require_exact_keys(
+            "exact complex rational",
+            value,
+            frozenset(
+                {
+                    "real_numerator",
+                    "real_denominator",
+                    "imag_numerator",
+                    "imag_denominator",
+                }
+            ),
+        )
+        return cls(
+            _canonical_decimal_integer("real_numerator", value["real_numerator"]),
+            _canonical_decimal_integer("real_denominator", value["real_denominator"]),
+            _canonical_decimal_integer("imag_numerator", value["imag_numerator"]),
+            _canonical_decimal_integer("imag_denominator", value["imag_denominator"]),
+        )
+
+
+class _SemanticRecord:
+    _record_kind: ClassVar[str]
+    semantic_digest: str
+
+    def _semantic_fields(self) -> dict[str, object]:
+        raise NotImplementedError
+
+    def canonical_payload(self) -> dict[str, object]:
+        return {"record_kind": self._record_kind, **self._semantic_fields()}
+
+    @property
+    def expected_semantic_digest(self) -> str:
+        return _digest(self.canonical_payload())
+
+    def _finish_semantic_record(self) -> None:
+        expected = self.expected_semantic_digest
+        if self.semantic_digest:
+            _require_sha256("semantic_digest", self.semantic_digest)
+            if self.semantic_digest != expected:
+                raise RecurrenceTemplateError(
+                    f"stale semantic digest for {self._record_kind}"
+                )
+        else:
+            object.__setattr__(self, "semantic_digest", expected)
+
+    def to_dict(self) -> dict[str, object]:
+        return {**self.canonical_payload(), "semantic_digest": self.semantic_digest}
+
+
+@dataclass(frozen=True, slots=True)
+class ContactOrbitCertificateV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "contact-orbit-certificate"
+
+    template_id: str
+    algorithm: str
+    algorithm_version: int
+    term_id: int
+    vertex: str
+    particles: tuple[str, ...]
+    evaluator_class: str
+    physical_leg_equivalence_classes: tuple[int, ...]
+    reconstruction_factor: ExactComplexRationalV1
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("contact-orbit certificate template_id", self.template_id)
+        _require_nonempty("contact-orbit certificate algorithm", self.algorithm)
+        _require_int(
+            "contact-orbit certificate algorithm version",
+            self.algorithm_version,
+            minimum=1,
+        )
+        _require_int("contact-orbit certificate term ID", self.term_id, minimum=0)
+        _require_nonempty("contact-orbit certificate vertex", self.vertex)
+        _require_string_tuple(
+            "contact-orbit certificate particles", self.particles, nonempty=True
+        )
+        if len(self.particles) not in {4, 5}:
+            raise RecurrenceTemplateError(
+                "contact-orbit certificate must describe four or five physical legs"
+            )
+        _require_nonempty(
+            "contact-orbit certificate evaluator class", self.evaluator_class
+        )
+        classes = self.physical_leg_equivalence_classes
+        if (
+            len(classes) != len(self.particles)
+            or any(type(value) is not int or value < 0 for value in classes)
+        ):
+            raise RecurrenceTemplateError(
+                "contact-orbit certificate equivalence classes are invalid"
+            )
+        canonical: dict[str, int] = {}
+        expected = tuple(
+            canonical.setdefault(particle, len(canonical))
+            for particle in self.particles
+        )
+        if classes != expected:
+            raise RecurrenceTemplateError(
+                "contact-orbit certificate equivalence classes are not canonical"
+            )
+        if self.reconstruction_factor != ExactComplexRationalV1.one():
+            raise RecurrenceTemplateError(
+                "contact-orbit reconstruction factor must be exactly one"
+            )
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "algorithm": self.algorithm,
+            "algorithm_version": self.algorithm_version,
+            "evaluator_class": self.evaluator_class,
+            "particles": list(self.particles),
+            "physical_leg_equivalence_classes": list(
+                self.physical_leg_equivalence_classes
+            ),
+            "reconstruction_factor": self.reconstruction_factor.to_dict(),
+            "template_id": self.template_id,
+            "term_id": self.term_id,
+            "vertex": self.vertex,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ContactOrbitStepV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "contact-orbit-step"
+
+    template_id: str
+    certificate_template_id: str
+    stage: str
+    result_leg: int
+    left_covered_legs: tuple[int, ...]
+    right_covered_legs: tuple[int, ...]
+    source_particle_legs: tuple[int, int, int]
+    reconstruction_factor: ExactComplexRationalV1
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("contact-orbit step template_id", self.template_id)
+        _require_nonempty(
+            "contact-orbit step certificate", self.certificate_template_id
+        )
+        if self.stage not in {"partial", "final"}:
+            raise RecurrenceTemplateError(
+                f"unsupported contact-orbit step stage {self.stage!r}"
+            )
+        _require_int("contact-orbit step result leg", self.result_leg, minimum=0)
+        if self.result_leg >= 5:
+            raise RecurrenceTemplateError("contact-orbit result leg is outside arity")
+        for name, values in (
+            ("left", self.left_covered_legs),
+            ("right", self.right_covered_legs),
+        ):
+            if (
+                not isinstance(values, tuple)
+                or not values
+                or any(
+                    type(value) is not int or value not in range(5)
+                    for value in values
+                )
+            ):
+                raise RecurrenceTemplateError(
+                    f"contact-orbit {name} covered legs are invalid"
+                )
+        if set(self.left_covered_legs) & set(self.right_covered_legs):
+            raise RecurrenceTemplateError(
+                "contact-orbit left and right covered legs must be disjoint"
+            )
+        if len(self.source_particle_legs) != 3 or any(
+            type(value) is not int or value not in {-1, 0, 1, 2, 3, 4}
+            for value in self.source_particle_legs
+        ):
+            raise RecurrenceTemplateError(
+                "contact-orbit source-particle legs are invalid"
+            )
+        if self.reconstruction_factor != ExactComplexRationalV1.one():
+            raise RecurrenceTemplateError(
+                "contact-orbit step reconstruction factor must be exactly one"
+            )
+        covered = (*self.left_covered_legs, *self.right_covered_legs)
+        if len(covered) != len(set(covered)):
+            raise RecurrenceTemplateError(
+                "contact-orbit covered legs must be unique"
+            )
+        left_source, right_source, output_source = self.source_particle_legs
+        if self.stage == "partial":
+            if (
+                len(self.left_covered_legs) != 1
+                or len(self.right_covered_legs) != 1
+                or (left_source, right_source)
+                != (self.left_covered_legs[0], self.right_covered_legs[0])
+                or output_source != -1
+                or self.result_leg in covered
+            ):
+                raise RecurrenceTemplateError(
+                    "contact-orbit partial step lineage is inconsistent"
+                )
+        else:
+            arity = len(covered) + 1
+            if (
+                arity not in {4, 5}
+                or set(covered) != (set(range(arity)) - {self.result_leg})
+                or output_source != self.result_leg
+                or any(
+                    len(side) not in {1, 2}
+                    for side in (self.left_covered_legs, self.right_covered_legs)
+                )
+            ):
+                raise RecurrenceTemplateError(
+                    "contact-orbit final step lineage is inconsistent"
+                )
+            expected_sources = tuple(
+                -1 if len(side) > 1 else side[0]
+                for side in (self.left_covered_legs, self.right_covered_legs)
+            )
+            if (left_source, right_source) != expected_sources:
+                raise RecurrenceTemplateError(
+                    "contact-orbit final source lineage is inconsistent"
+                )
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "certificate_template_id": self.certificate_template_id,
+            "left_covered_legs": list(self.left_covered_legs),
+            "reconstruction_factor": self.reconstruction_factor.to_dict(),
+            "result_leg": self.result_leg,
+            "right_covered_legs": list(self.right_covered_legs),
+            "source_particle_legs": list(self.source_particle_legs),
+            "stage": self.stage,
+            "template_id": self.template_id,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ParameterTemplateV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "parameter"
+
+    template_id: str
+    name: str
+    parameter_kind: ParameterKind
+    value_type: ParameterValueType
+    mutable: bool
+    default_value: ExactComplexRationalV1 | None
+    exact_expression_digest: str | None
+    dependency_parameter_ids: tuple[str, ...]
+    prepared_parameter_id: int | None = None
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("parameter template_id", self.template_id)
+        _require_nonempty("parameter name", self.name)
+        if self.parameter_kind not in _PARAMETER_KINDS:
+            raise RecurrenceTemplateError(
+                f"unsupported parameter kind {self.parameter_kind!r}"
+            )
+        if self.value_type not in _PARAMETER_VALUE_TYPES:
+            raise RecurrenceTemplateError(
+                f"unsupported parameter value type {self.value_type!r}"
+            )
+        if type(self.mutable) is not bool:
+            raise RecurrenceTemplateError("parameter mutable flag must be boolean")
+        _require_optional_sha256(
+            "parameter exact_expression_digest", self.exact_expression_digest
+        )
+        _require_string_tuple(
+            "parameter dependencies",
+            self.dependency_parameter_ids,
+            sorted_unique=True,
+        )
+        if self.prepared_parameter_id is not None:
+            _require_int(
+                "prepared parameter ID",
+                self.prepared_parameter_id,
+                minimum=0,
+            )
+        if self.parameter_kind == "derived":
+            if self.exact_expression_digest is None:
+                raise RecurrenceTemplateError(
+                    "derived parameters require an exact expression digest"
+                )
+        elif self.default_value is None:
+            raise RecurrenceTemplateError(
+                "external and constant parameters require an exact default"
+            )
+        if (
+            self.value_type == "real"
+            and self.default_value is not None
+            and self.default_value.imag_numerator != 0
+        ):
+            raise RecurrenceTemplateError(
+                "real parameter defaults cannot have an imaginary component"
+            )
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "default_value": (
+                None if self.default_value is None else self.default_value.to_dict()
+            ),
+            "dependency_parameter_ids": list(self.dependency_parameter_ids),
+            "exact_expression_digest": self.exact_expression_digest,
+            "mutable": self.mutable,
+            "name": self.name,
+            "parameter_kind": self.parameter_kind,
+            "prepared_parameter_id": self.prepared_parameter_id,
+            "template_id": self.template_id,
+            "value_type": self.value_type,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class CurrentStateTemplateV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "current-state"
+
+    template_id: str
+    particle_id: int
+    anti_particle_id: int
+    species_id: str
+    orientation: str
+    statistics: str
+    color_representation: int
+    basis: str
+    tensor_ordering: tuple[str, ...]
+    dimension: int
+    chirality: int
+    lc_color_shape_kind: LCColorShapeKindV1
+    auxiliary_kind: str | None
+    mass_parameter_id: str | None
+    width_parameter_id: str | None
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("current-state template_id", self.template_id)
+        _require_int("particle_id", self.particle_id)
+        _require_int("anti_particle_id", self.anti_particle_id)
+        _require_nonempty("species_id", self.species_id)
+        if self.orientation not in _ORIENTATIONS:
+            raise RecurrenceTemplateError(
+                f"unsupported current orientation {self.orientation!r}"
+            )
+        if self.statistics not in _STATISTICS:
+            raise RecurrenceTemplateError(
+                f"unsupported current statistics {self.statistics!r}"
+            )
+        _require_int("color_representation", self.color_representation)
+        _require_nonempty("current basis", self.basis)
+        _require_string_tuple(
+            "current tensor_ordering", self.tensor_ordering, nonempty=True
+        )
+        _require_int("current dimension", self.dimension, minimum=1)
+        if len(self.tensor_ordering) != self.dimension:
+            raise RecurrenceTemplateError(
+                "current tensor ordering must name every output component"
+            )
+        _require_int("current chirality", self.chirality)
+        if self.lc_color_shape_kind not in _LC_COLOR_SHAPE_KINDS:
+            raise RecurrenceTemplateError(
+                f"unsupported current LC color shape {self.lc_color_shape_kind!r}"
+            )
+        if self.auxiliary_kind is not None:
+            _require_nonempty("current auxiliary_kind", self.auxiliary_kind)
+        if self.mass_parameter_id is not None:
+            _require_nonempty("current mass_parameter_id", self.mass_parameter_id)
+        if self.width_parameter_id is not None:
+            _require_nonempty("current width_parameter_id", self.width_parameter_id)
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "anti_particle_id": self.anti_particle_id,
+            "auxiliary_kind": self.auxiliary_kind,
+            "basis": self.basis,
+            "chirality": self.chirality,
+            "lc_color_shape_kind": self.lc_color_shape_kind,
+            "color_representation": self.color_representation,
+            "dimension": self.dimension,
+            "mass_parameter_id": self.mass_parameter_id,
+            "orientation": self.orientation,
+            "particle_id": self.particle_id,
+            "species_id": self.species_id,
+            "statistics": self.statistics,
+            "template_id": self.template_id,
+            "tensor_ordering": list(self.tensor_ordering),
+            "width_parameter_id": self.width_parameter_id,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class LCColorSourceSeedV1:
+    """Authenticated LC color forest seeded by one source template."""
+
+    operation: LCColorSourceSeedOperationV1
+    output_shape_kind: LCColorShapeKindV1
+    component_kind: LCColorComponentKindV1 | None
+    component_role: LCColorComponentRoleV1
+    proof_digest: str
+    provenance: tuple[tuple[str, str], ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.operation not in _LC_COLOR_SOURCE_SEED_OPERATIONS:
+            raise RecurrenceTemplateError(
+                f"unsupported LC source seed operation {self.operation!r}"
+            )
+        if self.output_shape_kind not in _LC_COLOR_SHAPE_KINDS:
+            raise RecurrenceTemplateError(
+                f"unsupported LC source seed shape {self.output_shape_kind!r}"
+            )
+        if self.component_role not in _LC_COLOR_COMPONENT_ROLES:
+            raise RecurrenceTemplateError(
+                f"unsupported LC source seed role {self.component_role!r}"
+            )
+        if self.operation == "empty":
+            if self.component_kind is not None or self.component_role != "none":
+                raise RecurrenceTemplateError(
+                    "an empty LC source seed cannot declare a component"
+                )
+        elif (
+            self.component_kind not in _LC_COLOR_COMPONENT_KINDS
+            or self.component_role == "none"
+        ):
+            raise RecurrenceTemplateError(
+                "a singleton LC source seed requires component kind and role"
+            )
+        expected = {
+            "singlet-forest": ("empty", None, "none"),
+            "fundamental-open-string": ("singleton", "open-string", "active"),
+            "antifundamental-open-string": (
+                "singleton",
+                "open-string",
+                "active",
+            ),
+            "adjoint-segment": ("singleton", "adjoint-segment", "active"),
+        }[self.output_shape_kind]
+        if (self.operation, self.component_kind, self.component_role) != expected:
+            raise RecurrenceTemplateError(
+                "LC source seed does not match its certified output shape"
+            )
+        _require_sha256("LC source seed proof digest", self.proof_digest)
+        if self.provenance != tuple(sorted(set(self.provenance))):
+            raise RecurrenceTemplateError(
+                "LC source seed provenance must be sorted and unique"
+            )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "component_kind": self.component_kind,
+            "component_role": self.component_role,
+            "operation": self.operation,
+            "output_shape_kind": self.output_shape_kind,
+            "proof_digest": self.proof_digest,
+            "provenance": [list(item) for item in self.provenance],
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class SourceTemplateV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "source"
+
+    template_id: str
+    state_template_id: str
+    crossing: str
+    wavefunction_family: str
+    helicity: int
+    spin_state: int
+    flavour_flow: FlavourFlowV1
+    quantum_number_flow: QuantumNumberFlowV1
+    lc_color_seed: LCColorSourceSeedV1
+    wavefunction_expression_digest: str
+    evaluator_resolver_key: str
+    mass_parameter_id: str | None = None
+    width_parameter_id: str | None = None
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("source template_id", self.template_id)
+        _require_nonempty("source state_template_id", self.state_template_id)
+        _require_nonempty("source crossing", self.crossing)
+        if self.wavefunction_family not in _WAVEFUNCTION_FAMILIES:
+            raise RecurrenceTemplateError(
+                f"unsupported source wavefunction family {self.wavefunction_family!r}"
+            )
+        _require_int("source helicity", self.helicity)
+        _require_concrete_spin_state("source spin_state", self.spin_state)
+        _require_flavour_flow("source flavour flow", self.flavour_flow)
+        _require_quantum_number_flow(
+            "source quantum-number flow", self.quantum_number_flow
+        )
+        if not isinstance(self.lc_color_seed, LCColorSourceSeedV1):
+            raise RecurrenceTemplateError(
+                "source template requires an authenticated LC color seed"
+            )
+        _require_sha256(
+            "source wavefunction_expression_digest",
+            self.wavefunction_expression_digest,
+        )
+        _require_nonempty("source evaluator_resolver_key", self.evaluator_resolver_key)
+        if self.mass_parameter_id is not None:
+            _require_nonempty("source mass_parameter_id", self.mass_parameter_id)
+        if self.width_parameter_id is not None:
+            _require_nonempty("source width_parameter_id", self.width_parameter_id)
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "crossing": self.crossing,
+            "evaluator_resolver_key": self.evaluator_resolver_key,
+            "helicity": self.helicity,
+            "flavour_flow": list(self.flavour_flow),
+            "mass_parameter_id": self.mass_parameter_id,
+            "quantum_number_flow": [list(item) for item in self.quantum_number_flow],
+            "lc_color_seed": self.lc_color_seed.to_dict(),
+            "spin_state": self.spin_state,
+            "state_template_id": self.state_template_id,
+            "template_id": self.template_id,
+            "wavefunction_family": self.wavefunction_family,
+            "wavefunction_expression_digest": self.wavefunction_expression_digest,
+            "width_parameter_id": self.width_parameter_id,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class QuantumFlowTemplateV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "quantum-flow"
+
+    template_id: str
+    input_state_template_ids: tuple[str, ...]
+    input_spin_states: tuple[int, ...]
+    input_flavour_flows: tuple[FlavourFlowV1, ...]
+    input_quantum_number_flows: tuple[QuantumNumberFlowV1, ...]
+    flavour_flow_operation: FlavourFlowOperationV1
+    quantum_number_flow_operation: QuantumNumberFlowOperationV1
+    coupling_orders: tuple[tuple[str, int], ...]
+    result_state_template_id: str
+    result_spin_state: int
+    result_flavour_flow: FlavourFlowV1
+    result_quantum_number_flow: QuantumNumberFlowV1
+    exact_coupling: ExactComplexRationalV1
+    predicate_digest: str
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("quantum-flow template_id", self.template_id)
+        _require_string_tuple(
+            "quantum-flow input states",
+            self.input_state_template_ids,
+            nonempty=True,
+        )
+        _require_concrete_spin_states(
+            "quantum-flow spin states",
+            self.input_spin_states,
+        )
+        flavour_flows = _require_tuple(
+            "quantum-flow flavour flows", self.input_flavour_flows
+        )
+        for index, flow in enumerate(flavour_flows):
+            _require_flavour_flow(f"quantum-flow flavour flow {index}", flow)
+        quantum_number_flows = _require_tuple(
+            "quantum-flow quantum-number flows",
+            self.input_quantum_number_flows,
+        )
+        for index, flow in enumerate(quantum_number_flows):
+            _require_quantum_number_flow(
+                f"quantum-flow quantum-number flow {index}", flow
+            )
+        if self.flavour_flow_operation not in _FLAVOUR_FLOW_OPERATIONS:
+            raise RecurrenceTemplateError(
+                "unsupported quantum-flow flavour operation "
+                f"{self.flavour_flow_operation!r}"
+            )
+        if self.quantum_number_flow_operation not in _QUANTUM_NUMBER_FLOW_OPERATIONS:
+            raise RecurrenceTemplateError(
+                "unsupported quantum-flow quantum-number operation "
+                f"{self.quantum_number_flow_operation!r}"
+            )
+        arity = len(self.input_state_template_ids)
+        if arity != 2:
+            raise RecurrenceTemplateError(
+                "recurrence quantum-flow templates must have binary input arity"
+            )
+        if not all(
+            len(values) == arity
+            for values in (
+                self.input_spin_states,
+                self.input_flavour_flows,
+                self.input_quantum_number_flows,
+            )
+        ):
+            raise RecurrenceTemplateError(
+                "quantum-flow input contracts must have equal arity"
+            )
+        _validate_coupling_orders(self.coupling_orders)
+        _require_nonempty("quantum-flow result state", self.result_state_template_id)
+        _require_concrete_spin_state(
+            "quantum-flow result spin state",
+            self.result_spin_state,
+        )
+        _require_flavour_flow(
+            "quantum-flow result flavour flow", self.result_flavour_flow
+        )
+        _require_quantum_number_flow(
+            "quantum-flow result quantum-number flow",
+            self.result_quantum_number_flow,
+        )
+        if not isinstance(self.exact_coupling, ExactComplexRationalV1):
+            raise RecurrenceTemplateError(
+                "quantum-flow coupling must be an exact complex rational"
+            )
+        _require_sha256("quantum-flow predicate_digest", self.predicate_digest)
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "coupling_orders": [list(item) for item in self.coupling_orders],
+            "exact_coupling": self.exact_coupling.to_dict(),
+            "flavour_flow_operation": self.flavour_flow_operation,
+            "input_flavour_flows": [list(flow) for flow in self.input_flavour_flows],
+            "input_quantum_number_flows": [
+                [list(item) for item in flow]
+                for flow in self.input_quantum_number_flows
+            ],
+            "input_spin_states": list(self.input_spin_states),
+            "input_state_template_ids": list(self.input_state_template_ids),
+            "predicate_digest": self.predicate_digest,
+            "quantum_number_flow_operation": self.quantum_number_flow_operation,
+            "result_flavour_flow": list(self.result_flavour_flow),
+            "result_quantum_number_flow": [
+                list(item) for item in self.result_quantum_number_flow
+            ],
+            "result_state_template_id": self.result_state_template_id,
+            "result_spin_state": self.result_spin_state,
+            "template_id": self.template_id,
+        }
+
+
+def _apply_flavour_flow_operation(
+    operation: FlavourFlowOperationV1,
+    left: FlavourFlowV1,
+    right: FlavourFlowV1,
+    result_particle: int,
+) -> FlavourFlowV1:
+    if operation == "constant-result":
+        return (result_particle,)
+    if operation == "append-left-result":
+        return (
+            left if left and left[-1] == result_particle else (*left, result_particle)
+        )
+    if operation == "append-right-result":
+        return (
+            right
+            if right and right[-1] == result_particle
+            else (*right, result_particle)
+        )
+    if operation == "concat-left-right-result":
+        return (*left, *right, result_particle)
+    raise AssertionError(f"unknown flavour-flow operation {operation!r}")
+
+
+def _validate_coupling_orders(value: object) -> tuple[tuple[str, int], ...]:
+    items = _require_tuple("coupling orders", value)
+    normalized: list[tuple[str, int]] = []
+    for item in items:
+        if not isinstance(item, tuple) or len(item) != 2:
+            raise RecurrenceTemplateError(
+                "coupling orders must contain (name, power) tuples"
+            )
+        name = _require_nonempty("coupling-order name", item[0])
+        power = _require_int("coupling-order power", item[1], minimum=0)
+        normalized.append((name, power))
+    result = tuple(normalized)
+    if result != tuple(sorted(result)) or len({name for name, _ in result}) != len(
+        result
+    ):
+        raise RecurrenceTemplateError("coupling orders must be sorted and unique")
+    return result
+
+
+@dataclass(frozen=True, slots=True)
+class TransitionTemplateV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "transition"
+
+    template_id: str
+    input_state_template_ids: tuple[str, ...]
+    result_state_template_id: str
+    quantum_flow_template_id: str
+    evaluator_resolver_key: str
+    canonical_input_order: tuple[int, ...]
+    momentum_convention: tuple[str, ...]
+    coupling_parameter_ids: tuple[str, ...]
+    coupling_orders: tuple[tuple[str, int], ...]
+    color_contraction_template_id: str
+    binding_coupling: ExactComplexRationalV1
+    exact_factor: ExactComplexRationalV1
+    output_factor_source: PreparedOutputFactorSource
+    equivalence_class: str
+    input_exchange_factor: ExactComplexRationalV1 | None
+    output_projection: str
+    contact_orbit_step_template_ids: tuple[str, ...] = ()
+    contact_orbit_step_semantic_digests: tuple[str, ...] = ()
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("transition template_id", self.template_id)
+        _require_string_tuple(
+            "transition input states", self.input_state_template_ids, nonempty=True
+        )
+        _require_nonempty("transition result state", self.result_state_template_id)
+        _require_nonempty(
+            "transition quantum-flow template", self.quantum_flow_template_id
+        )
+        _require_nonempty("transition evaluator resolver", self.evaluator_resolver_key)
+        _require_permutation(
+            "transition canonical input order",
+            self.canonical_input_order,
+            len(self.input_state_template_ids),
+        )
+        _require_string_tuple(
+            "transition momentum convention",
+            self.momentum_convention,
+            nonempty=True,
+        )
+        if len(self.momentum_convention) != len(self.input_state_template_ids):
+            raise RecurrenceTemplateError(
+                "transition momentum convention must cover every input"
+            )
+        _require_string_tuple(
+            "transition coupling parameters",
+            self.coupling_parameter_ids,
+            sorted_unique=True,
+        )
+        _validate_coupling_orders(self.coupling_orders)
+        _require_nonempty(
+            "transition color contraction", self.color_contraction_template_id
+        )
+        if not isinstance(self.binding_coupling, ExactComplexRationalV1):
+            raise RecurrenceTemplateError(
+                "transition binding coupling must be an exact complex rational"
+            )
+        if not isinstance(self.exact_factor, ExactComplexRationalV1):
+            raise RecurrenceTemplateError(
+                "transition exact factor must be an exact complex rational"
+            )
+        if self.output_factor_source not in _OUTPUT_FACTOR_SOURCES:
+            raise RecurrenceTemplateError(
+                f"unsupported transition output factor source "
+                f"{self.output_factor_source!r}"
+            )
+        _require_nonempty("transition equivalence class", self.equivalence_class)
+        if self.input_exchange_factor is not None:
+            if not isinstance(self.input_exchange_factor, ExactComplexRationalV1):
+                raise RecurrenceTemplateError(
+                    "transition input-exchange factor must be an exact complex rational"
+                )
+            if self.input_exchange_factor == ExactComplexRationalV1.zero():
+                raise RecurrenceTemplateError(
+                    "transition input-exchange factor must be nonzero"
+                )
+        _require_nonempty("transition output projection", self.output_projection)
+        if len(self.contact_orbit_step_template_ids) != len(
+            self.contact_orbit_step_semantic_digests
+        ):
+            raise RecurrenceTemplateError(
+                "transition contact-orbit step IDs and digests must be paired"
+            )
+        _require_string_tuple(
+            "transition contact-orbit steps", self.contact_orbit_step_template_ids
+        )
+        if self.contact_orbit_step_template_ids != tuple(
+            sorted(set(self.contact_orbit_step_template_ids))
+        ):
+            raise RecurrenceTemplateError(
+                "transition contact-orbit step IDs must be sorted and unique"
+            )
+        for digest in self.contact_orbit_step_semantic_digests:
+            _require_sha256(
+                "transition contact-orbit step semantic digest", digest
+            )
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "canonical_input_order": list(self.canonical_input_order),
+            "binding_coupling": self.binding_coupling.to_dict(),
+            "color_contraction_template_id": self.color_contraction_template_id,
+            "contact_orbit_step_semantic_digests": list(
+                self.contact_orbit_step_semantic_digests
+            ),
+            "contact_orbit_step_template_ids": list(
+                self.contact_orbit_step_template_ids
+            ),
+            "coupling_orders": [list(item) for item in self.coupling_orders],
+            "coupling_parameter_ids": list(self.coupling_parameter_ids),
+            "evaluator_resolver_key": self.evaluator_resolver_key,
+            "equivalence_class": self.equivalence_class,
+            "exact_factor": self.exact_factor.to_dict(),
+            "input_exchange_factor": (
+                None
+                if self.input_exchange_factor is None
+                else self.input_exchange_factor.to_dict()
+            ),
+            "input_state_template_ids": list(self.input_state_template_ids),
+            "momentum_convention": list(self.momentum_convention),
+            "output_projection": self.output_projection,
+            "output_factor_source": self.output_factor_source,
+            "quantum_flow_template_id": self.quantum_flow_template_id,
+            "result_state_template_id": self.result_state_template_id,
+            "template_id": self.template_id,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class PropagatorTemplateV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "propagator"
+
+    template_id: str
+    state_template_id: str
+    applies_propagator: bool
+    evaluator_resolver_key: str | None
+    numerator_expression_digest: str | None
+    denominator_expression_digest: str | None
+    mass_parameter_id: str | None
+    width_parameter_id: str | None
+    gauge: str | None
+    linearity_proof_template_id: str | None
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("propagator template_id", self.template_id)
+        _require_nonempty("propagator state", self.state_template_id)
+        if type(self.applies_propagator) is not bool:
+            raise RecurrenceTemplateError(
+                "propagator applies_propagator must be boolean"
+            )
+        _require_optional_sha256(
+            "propagator numerator expression", self.numerator_expression_digest
+        )
+        _require_optional_sha256(
+            "propagator denominator expression", self.denominator_expression_digest
+        )
+        for name, value in (
+            ("evaluator_resolver_key", self.evaluator_resolver_key),
+            ("mass_parameter_id", self.mass_parameter_id),
+            ("width_parameter_id", self.width_parameter_id),
+            ("gauge", self.gauge),
+            ("linearity_proof_template_id", self.linearity_proof_template_id),
+        ):
+            if value is not None:
+                _require_nonempty(f"propagator {name}", value)
+        required = (
+            self.evaluator_resolver_key,
+            self.numerator_expression_digest,
+            self.denominator_expression_digest,
+        )
+        if self.applies_propagator and any(value is None for value in required):
+            raise RecurrenceTemplateError(
+                "active propagators require evaluator, numerator, and denominator"
+            )
+        if not self.applies_propagator and any(value is not None for value in required):
+            raise RecurrenceTemplateError(
+                "identity propagators cannot carry evaluator or expressions"
+            )
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "applies_propagator": self.applies_propagator,
+            "denominator_expression_digest": self.denominator_expression_digest,
+            "evaluator_resolver_key": self.evaluator_resolver_key,
+            "gauge": self.gauge,
+            "linearity_proof_template_id": self.linearity_proof_template_id,
+            "mass_parameter_id": self.mass_parameter_id,
+            "numerator_expression_digest": self.numerator_expression_digest,
+            "state_template_id": self.state_template_id,
+            "template_id": self.template_id,
+            "width_parameter_id": self.width_parameter_id,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ClosureTemplateV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "closure"
+
+    template_id: str
+    input_state_template_ids: tuple[str, ...]
+    result_state_template_id: str | None
+    evaluator_resolver_key: str
+    canonical_input_order: tuple[int, ...]
+    coupling_parameter_ids: tuple[str, ...]
+    coupling_orders: tuple[tuple[str, int], ...]
+    eligible_quantum_flow_template_ids: tuple[str, ...]
+    color_contraction_template_id: str
+    binding_coupling: ExactComplexRationalV1
+    exact_factor: ExactComplexRationalV1
+    output_factor_source: PreparedOutputFactorSource
+    equivalence_class: str
+    input_exchange_factor: ExactComplexRationalV1 | None
+    projection: str
+    component_coefficients: tuple[ExactComplexRationalV1, ...] = ()
+    chirality_relation: str = "any"
+    metric_signature: str | None = None
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("closure template_id", self.template_id)
+        _require_string_tuple(
+            "closure input states", self.input_state_template_ids, nonempty=True
+        )
+        if self.result_state_template_id is not None:
+            _require_nonempty("closure result state", self.result_state_template_id)
+        _require_nonempty("closure evaluator resolver", self.evaluator_resolver_key)
+        _require_permutation(
+            "closure canonical input order",
+            self.canonical_input_order,
+            len(self.input_state_template_ids),
+        )
+        _require_string_tuple(
+            "closure coupling parameters",
+            self.coupling_parameter_ids,
+            sorted_unique=True,
+        )
+        _validate_coupling_orders(self.coupling_orders)
+        _require_string_tuple(
+            "closure eligible quantum flows",
+            self.eligible_quantum_flow_template_ids,
+            sorted_unique=True,
+        )
+        _require_nonempty(
+            "closure color contraction", self.color_contraction_template_id
+        )
+        if not isinstance(self.binding_coupling, ExactComplexRationalV1):
+            raise RecurrenceTemplateError(
+                "closure binding coupling must be an exact complex rational"
+            )
+        if not isinstance(self.exact_factor, ExactComplexRationalV1):
+            raise RecurrenceTemplateError(
+                "closure exact factor must be an exact complex rational"
+            )
+        if self.output_factor_source not in _OUTPUT_FACTOR_SOURCES:
+            raise RecurrenceTemplateError(
+                f"unsupported closure output factor source "
+                f"{self.output_factor_source!r}"
+            )
+        _require_nonempty("closure equivalence class", self.equivalence_class)
+        if self.input_exchange_factor is not None:
+            if not isinstance(self.input_exchange_factor, ExactComplexRationalV1):
+                raise RecurrenceTemplateError(
+                    "closure input-exchange factor must be an exact complex rational"
+                )
+            if self.input_exchange_factor == ExactComplexRationalV1.zero():
+                raise RecurrenceTemplateError(
+                    "closure input-exchange factor must be nonzero"
+                )
+        _require_nonempty("closure projection", self.projection)
+        coefficients = _require_tuple(
+            "closure component coefficients", self.component_coefficients
+        )
+        if not all(
+            isinstance(coefficient, ExactComplexRationalV1)
+            for coefficient in coefficients
+        ):
+            raise RecurrenceTemplateError(
+                "closure component coefficients must be exact complex rationals"
+            )
+        if self.chirality_relation not in {"any", "equal", "opposite"}:
+            raise RecurrenceTemplateError(
+                "closure chirality relation must be any, equal, or opposite"
+            )
+        if self.metric_signature is not None:
+            _require_nonempty("closure metric signature", self.metric_signature)
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "canonical_input_order": list(self.canonical_input_order),
+            "binding_coupling": self.binding_coupling.to_dict(),
+            "chirality_relation": self.chirality_relation,
+            "color_contraction_template_id": self.color_contraction_template_id,
+            "component_coefficients": [
+                value.to_dict() for value in self.component_coefficients
+            ],
+            "coupling_orders": [list(item) for item in self.coupling_orders],
+            "coupling_parameter_ids": list(self.coupling_parameter_ids),
+            "eligible_quantum_flow_template_ids": list(
+                self.eligible_quantum_flow_template_ids
+            ),
+            "evaluator_resolver_key": self.evaluator_resolver_key,
+            "equivalence_class": self.equivalence_class,
+            "exact_factor": self.exact_factor.to_dict(),
+            "input_exchange_factor": (
+                None
+                if self.input_exchange_factor is None
+                else self.input_exchange_factor.to_dict()
+            ),
+            "input_state_template_ids": list(self.input_state_template_ids),
+            "result_state_template_id": self.result_state_template_id,
+            "metric_signature": self.metric_signature,
+            "projection": self.projection,
+            "output_factor_source": self.output_factor_source,
+            "template_id": self.template_id,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class LCColorTransitionWitnessV1:
+    """One exact executable ordered-word term in an LC color contraction."""
+
+    input_shape_kinds: tuple[LCColorShapeKindV1, LCColorShapeKindV1]
+    input_permutation: tuple[int, int]
+    reverse_parent_mask: int
+    component_operation: LCColorComponentOperationV1
+    result_component_kind: LCColorComponentKindV1 | None
+    result_component_role: LCColorComponentRoleV1
+    result_shape_kind: LCColorShapeKindV1 | None
+    exact_factor: ExactComplexRationalV1
+    proof_digest: str
+    provenance: tuple[tuple[str, str], ...] = ()
+    input_port_pairings: tuple[tuple[tuple[int, int], tuple[int, int]], ...] = ()
+    result_port_bindings: tuple[tuple[int, int], ...] = ()
+
+    def __post_init__(self) -> None:
+        if len(self.input_shape_kinds) != 2 or any(
+            value not in _LC_COLOR_SHAPE_KINDS for value in self.input_shape_kinds
+        ):
+            raise RecurrenceTemplateError(
+                "LC color witness requires two supported input shape kinds"
+            )
+        if self.input_permutation not in {(0, 1), (1, 0)}:
+            raise RecurrenceTemplateError(
+                "LC color witness input permutation must be (0, 1) or (1, 0)"
+            )
+        _require_int("LC color witness reverse-parent mask", self.reverse_parent_mask)
+        if self.reverse_parent_mask not in range(4):
+            raise RecurrenceTemplateError(
+                "LC color witness reverse-parent mask must fit two inputs"
+            )
+        if self.component_operation not in _LC_COLOR_COMPONENT_OPERATIONS:
+            raise RecurrenceTemplateError(
+                f"unsupported LC color witness operation {self.component_operation!r}"
+            )
+        if self.result_component_kind is not None and (
+            self.result_component_kind not in _LC_COLOR_COMPONENT_KINDS
+        ):
+            raise RecurrenceTemplateError(
+                "unsupported LC color witness result component kind"
+            )
+        if self.result_component_role not in _LC_COLOR_COMPONENT_ROLES:
+            raise RecurrenceTemplateError(
+                "unsupported LC color witness result component role"
+            )
+        if self.component_operation == "concatenate-join":
+            if (
+                self.result_component_kind is None
+                or self.result_component_role == "none"
+            ):
+                raise RecurrenceTemplateError(
+                    "an LC join requires a result component kind and role"
+                )
+        elif self.component_operation == "close":
+            if self.result_component_role != "none":
+                raise RecurrenceTemplateError(
+                    "an LC closure cannot declare a recurrence result component"
+                )
+        elif self.result_component_kind is not None or self.result_component_role != (
+            "active"
+            if self.component_operation in {"inherit-left", "inherit-right"}
+            else "none"
+        ):
+            raise RecurrenceTemplateError(
+                "LC non-join result role does not match its component operation"
+            )
+        if self.component_operation == "close":
+            if self.result_shape_kind is not None:
+                raise RecurrenceTemplateError(
+                    "LC color closure witness cannot declare a result shape"
+                )
+        elif self.result_shape_kind not in _LC_COLOR_SHAPE_KINDS:
+            raise RecurrenceTemplateError(
+                "non-closure LC color witness requires a supported result shape"
+            )
+        if not isinstance(self.exact_factor, ExactComplexRationalV1):
+            raise RecurrenceTemplateError(
+                "LC color witness factor must be an exact complex rational"
+            )
+        if self.exact_factor == ExactComplexRationalV1.zero():
+            raise RecurrenceTemplateError("LC color witness factor must be nonzero")
+        _require_sha256("LC color witness proof digest", self.proof_digest)
+        if self.provenance != tuple(sorted(set(self.provenance))):
+            raise RecurrenceTemplateError(
+                "LC color witness provenance must be sorted and unique"
+            )
+        if any(
+            not isinstance(key, str)
+            or not key
+            or not isinstance(value, str)
+            or not value
+            for key, value in self.provenance
+        ):
+            raise RecurrenceTemplateError(
+                "LC color witness provenance requires nonempty string pairs"
+            )
+        consumed_ports: list[tuple[int, int]] = []
+        for pairing in self.input_port_pairings:
+            if not isinstance(pairing, tuple) or len(pairing) != 2:
+                raise RecurrenceTemplateError(
+                    "LC color witness port pairings must contain two port references"
+                )
+            for port in pairing:
+                _validate_lc_color_port_reference(port)
+                consumed_ports.append(port)
+        for port in self.result_port_bindings:
+            _validate_lc_color_port_reference(port)
+            consumed_ports.append(port)
+        if len(consumed_ports) != len(set(consumed_ports)):
+            raise RecurrenceTemplateError(
+                "LC color witness must consume each parent port at most once"
+            )
+
+    def to_dict(self) -> dict[str, object]:
+        payload: dict[str, object] = {
+            "component_operation": self.component_operation,
+            "exact_factor": self.exact_factor.to_dict(),
+            "input_permutation": list(self.input_permutation),
+            "input_shape_kinds": list(self.input_shape_kinds),
+            "proof_digest": self.proof_digest,
+            "provenance": [list(item) for item in self.provenance],
+            "result_component_kind": self.result_component_kind,
+            "result_component_role": self.result_component_role,
+            "result_shape_kind": self.result_shape_kind,
+            "reverse_parent_mask": self.reverse_parent_mask,
+        }
+        if self.input_port_pairings or self.result_port_bindings:
+            payload["input_port_pairings"] = [
+                [list(left), list(right)] for left, right in self.input_port_pairings
+            ]
+            payload["result_port_bindings"] = [
+                list(port) for port in self.result_port_bindings
+            ]
+        return payload
+
+
+@dataclass(frozen=True, slots=True)
+class ColorContractionTemplateV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "color-contraction"
+
+    template_id: str
+    rule_kind: str
+    input_representations: tuple[int, ...]
+    output_representation: int | None
+    ordered_open_string_arity: int
+    exact_coefficient: ExactComplexRationalV1
+    nc_polynomial: tuple[tuple[int, ExactComplexRationalV1], ...]
+    expression_digest: str
+    transition_witnesses: tuple[LCColorTransitionWitnessV1, ...]
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("color template_id", self.template_id)
+        _require_nonempty("color rule_kind", self.rule_kind)
+        _require_int_tuple("color input representations", self.input_representations)
+        if self.output_representation is not None:
+            _require_int("color output representation", self.output_representation)
+        _require_int(
+            "color ordered_open_string_arity",
+            self.ordered_open_string_arity,
+            minimum=0,
+        )
+        if not isinstance(self.exact_coefficient, ExactComplexRationalV1):
+            raise RecurrenceTemplateError(
+                "color coefficient must be an exact complex rational"
+            )
+        terms = _require_tuple("color Nc polynomial", self.nc_polynomial)
+        powers: list[int] = []
+        for term in terms:
+            if not isinstance(term, tuple) or len(term) != 2:
+                raise RecurrenceTemplateError(
+                    "color Nc polynomial terms must be (power, coefficient)"
+                )
+            power = _require_int("color Nc power", term[0], minimum=0)
+            if not isinstance(term[1], ExactComplexRationalV1):
+                raise RecurrenceTemplateError(
+                    "color Nc coefficients must be exact complex rationals"
+                )
+            if term[1] == ExactComplexRationalV1.zero():
+                raise RecurrenceTemplateError(
+                    "color Nc polynomial cannot retain exact zero terms"
+                )
+            powers.append(power)
+        if powers != sorted(set(powers)):
+            raise RecurrenceTemplateError(
+                "color Nc polynomial powers must be sorted and unique"
+            )
+        _require_sha256("color expression_digest", self.expression_digest)
+        if not self.transition_witnesses or any(
+            not isinstance(value, LCColorTransitionWitnessV1)
+            for value in self.transition_witnesses
+        ):
+            raise RecurrenceTemplateError(
+                "color contraction requires exact LC transition witnesses"
+            )
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "exact_coefficient": self.exact_coefficient.to_dict(),
+            "expression_digest": self.expression_digest,
+            "input_representations": list(self.input_representations),
+            "nc_polynomial": [
+                [power, coefficient.to_dict()]
+                for power, coefficient in self.nc_polynomial
+            ],
+            "ordered_open_string_arity": self.ordered_open_string_arity,
+            "output_representation": self.output_representation,
+            "rule_kind": self.rule_kind,
+            "template_id": self.template_id,
+            "transition_witnesses": [
+                witness.to_dict() for witness in self.transition_witnesses
+            ],
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class SymmetryProofV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "symmetry-proof"
+
+    template_id: str
+    proof_algorithm: str
+    subject_template_ids: tuple[str, ...]
+    input_permutation: tuple[int, ...]
+    exact_phase: ExactComplexRationalV1
+    expression_digests: tuple[str, ...]
+    witness_digest: str
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("symmetry proof template_id", self.template_id)
+        if self.proof_algorithm not in SUPPORTED_SYMMETRY_PROOF_ALGORITHMS:
+            raise RecurrenceTemplateError(
+                f"unsupported recurrence proof algorithm {self.proof_algorithm!r}"
+            )
+        _require_string_tuple(
+            "symmetry proof subjects", self.subject_template_ids, nonempty=True
+        )
+        _require_permutation(
+            "symmetry proof input permutation",
+            self.input_permutation,
+            len(self.input_permutation),
+        )
+        if not isinstance(self.exact_phase, ExactComplexRationalV1):
+            raise RecurrenceTemplateError(
+                "symmetry proof phase must be an exact complex rational"
+            )
+        if self.exact_phase == ExactComplexRationalV1.zero():
+            raise RecurrenceTemplateError("symmetry proof phase must be nonzero")
+        _require_string_tuple(
+            "symmetry proof expression digests",
+            self.expression_digests,
+            nonempty=True,
+        )
+        for digest in self.expression_digests:
+            _require_sha256("symmetry proof expression digest", digest)
+        _require_sha256("symmetry proof witness_digest", self.witness_digest)
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "exact_phase": self.exact_phase.to_dict(),
+            "expression_digests": list(self.expression_digests),
+            "input_permutation": list(self.input_permutation),
+            "proof_algorithm": self.proof_algorithm,
+            "subject_template_ids": list(self.subject_template_ids),
+            "template_id": self.template_id,
+            "witness_digest": self.witness_digest,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceRuntimeHelicityVariantV1:
+    """One exact source-wavefunction embedding into a full current state."""
+
+    source_template_id: str
+    source_state_template_id: str
+    embedding_source_components: tuple[int | None, ...]
+    embedding_factors: tuple[ExactComplexRationalV1, ...]
+    projection_full_components: tuple[int, ...]
+    proof_digest: str
+
+    def __post_init__(self) -> None:
+        _require_nonempty(
+            "runtime-helicity source template ID", self.source_template_id
+        )
+        _require_nonempty(
+            "runtime-helicity source-state template ID",
+            self.source_state_template_id,
+        )
+        embedding = _require_tuple(
+            "runtime-helicity component embedding",
+            self.embedding_source_components,
+        )
+        if any(
+            item is not None and (type(item) is not int or item < 0)
+            for item in embedding
+        ):
+            raise RecurrenceTemplateError(
+                "runtime-helicity embedding entries must be nonnegative integers "
+                "or null"
+            )
+        factors = _require_tuple(
+            "runtime-helicity embedding factors", self.embedding_factors
+        )
+        if len(factors) != len(embedding) or any(
+            not isinstance(item, ExactComplexRationalV1) for item in factors
+        ):
+            raise RecurrenceTemplateError(
+                "runtime-helicity embedding factors must align with full-state "
+                "components"
+            )
+        zero = ExactComplexRationalV1.zero()
+        if any(
+            (component is None) != (factor == zero)
+            for component, factor in zip(embedding, factors, strict=True)
+        ):
+            raise RecurrenceTemplateError(
+                "runtime-helicity zero embedding slots must have exactly zero factor"
+            )
+        projection = _require_tuple(
+            "runtime-helicity component projection",
+            self.projection_full_components,
+        )
+        if any(type(item) is not int or item < 0 for item in projection):
+            raise RecurrenceTemplateError(
+                "runtime-helicity projection entries must be nonnegative integers"
+            )
+        if len(set(projection)) != len(projection):
+            raise RecurrenceTemplateError(
+                "runtime-helicity projection entries must be unique"
+            )
+        if tuple(
+            sorted(component for component in embedding if component is not None)
+        ) != tuple(range(len(projection))):
+            raise RecurrenceTemplateError(
+                "runtime-helicity embedding must cover each source component once"
+            )
+        if any(
+            full_component >= len(embedding)
+            or embedding[full_component] != source_component
+            for source_component, full_component in enumerate(projection)
+        ):
+            raise RecurrenceTemplateError(
+                "runtime-helicity projection must invert the component embedding"
+            )
+        _require_sha256("runtime-helicity variant proof digest", self.proof_digest)
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "embedding_factors": [item.to_dict() for item in self.embedding_factors],
+            "embedding_source_components": list(self.embedding_source_components),
+            "projection_full_components": list(self.projection_full_components),
+            "proof_digest": self.proof_digest,
+            "source_state_template_id": self.source_state_template_id,
+            "source_template_id": self.source_template_id,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceRuntimeHelicityContractV1(_SemanticRecord):
+    """Compiler certificate for runtime source dispatch into one full state."""
+
+    _record_kind: ClassVar[str] = "runtime-helicity-contract"
+
+    template_id: str
+    full_state_template_id: str
+    variants: tuple[RecurrenceRuntimeHelicityVariantV1, ...]
+    proof_algorithm: str
+    proof_digest: str
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("runtime-helicity template ID", self.template_id)
+        _require_nonempty(
+            "runtime-helicity full-state template ID", self.full_state_template_id
+        )
+        _require_nonempty("runtime-helicity proof algorithm", self.proof_algorithm)
+        _require_sha256("runtime-helicity proof digest", self.proof_digest)
+        variants = _require_tuple("runtime-helicity variants", self.variants)
+        if not variants or any(
+            not isinstance(item, RecurrenceRuntimeHelicityVariantV1)
+            for item in variants
+        ):
+            raise RecurrenceTemplateError(
+                "runtime-helicity contract requires typed source variants"
+            )
+        source_ids = tuple(item.source_template_id for item in variants)
+        if source_ids != tuple(sorted(set(source_ids))):
+            raise RecurrenceTemplateError(
+                "runtime-helicity source variants must be sorted and unique"
+            )
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "full_state_template_id": self.full_state_template_id,
+            "proof_algorithm": self.proof_algorithm,
+            "proof_digest": self.proof_digest,
+            "template_id": self.template_id,
+            "variants": [item.to_dict() for item in self.variants],
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class EvaluatorBindingV1(_SemanticRecord):
+    _record_kind: ClassVar[str] = "evaluator-binding"
+
+    resolver_key: str
+    prepared_kernel_id: int | None
+    contract_kind: EvaluatorContractKind
+    callable_signature: str
+    input_state_template_ids: tuple[str, ...]
+    output_state_template_id: str | None
+    input_layout: tuple[str, ...]
+    output_layout: tuple[str, ...]
+    exact_expression_digests: tuple[str, ...]
+    semantic_template_ids: tuple[str, ...]
+    callable_kind: EvaluatorCallableKind = "prepared-kernel"
+    runtime_template: str | None = None
+    semantic_digest: str = ""
+
+    def __post_init__(self) -> None:
+        _require_nonempty("evaluator resolver_key", self.resolver_key)
+        if self.callable_kind not in _EVALUATOR_CALLABLE_KINDS:
+            raise RecurrenceTemplateError(
+                f"unsupported evaluator callable kind {self.callable_kind!r}"
+            )
+        if self.callable_kind == "prepared-kernel":
+            if self.prepared_kernel_id is None:
+                raise RecurrenceTemplateError(
+                    "prepared-kernel evaluator requires prepared_kernel_id"
+                )
+            _require_int(
+                "evaluator prepared_kernel_id",
+                self.prepared_kernel_id,
+                minimum=0,
+            )
+            if self.runtime_template is not None:
+                raise RecurrenceTemplateError(
+                    "prepared-kernel evaluator cannot name a Rusticol template"
+                )
+        else:
+            if self.prepared_kernel_id is not None:
+                raise RecurrenceTemplateError(
+                    "Rusticol-template evaluator cannot name a prepared kernel"
+                )
+            _require_nonempty("evaluator runtime_template", self.runtime_template)
+        if self.contract_kind not in _EVALUATOR_CONTRACT_KINDS:
+            raise RecurrenceTemplateError(
+                f"unsupported evaluator contract kind {self.contract_kind!r}"
+            )
+        _require_sha256("evaluator callable_signature", self.callable_signature)
+        if self.callable_kind == "rusticol-template":
+            assert self.runtime_template is not None
+            _validate_rusticol_runtime_template(
+                self.contract_kind,
+                self.runtime_template,
+                self.callable_signature,
+            )
+        _require_string_tuple("evaluator input states", self.input_state_template_ids)
+        if self.output_state_template_id is not None:
+            _require_nonempty("evaluator output state", self.output_state_template_id)
+        _require_string_tuple(
+            "evaluator input layout", self.input_layout, nonempty=True
+        )
+        _require_string_tuple(
+            "evaluator output layout", self.output_layout, nonempty=True
+        )
+        _require_string_tuple(
+            "evaluator exact expression digests",
+            self.exact_expression_digests,
+            nonempty=True,
+        )
+        if len(self.output_layout) != len(self.exact_expression_digests):
+            raise RecurrenceTemplateError(
+                "evaluator output layout and exact expressions must align"
+            )
+        for digest in self.exact_expression_digests:
+            _require_sha256("evaluator exact expression digest", digest)
+        _require_string_tuple(
+            "evaluator semantic templates",
+            self.semantic_template_ids,
+            nonempty=True,
+            sorted_unique=True,
+        )
+        if self.contract_kind in {"source", "vertex", "propagator"}:
+            if self.output_state_template_id is None:
+                raise RecurrenceTemplateError(
+                    f"{self.contract_kind} evaluators require an output state"
+                )
+        elif (
+            self.contract_kind in {"closure", "model-parameter"}
+            and self.output_state_template_id is not None
+        ):
+            raise RecurrenceTemplateError(
+                f"{self.contract_kind} evaluators cannot produce a current state"
+            )
+        self._finish_semantic_record()
+
+    def _semantic_fields(self) -> dict[str, object]:
+        return {
+            "callable_kind": self.callable_kind,
+            "callable_signature": self.callable_signature,
+            "contract_kind": self.contract_kind,
+            "exact_expression_digests": list(self.exact_expression_digests),
+            "input_layout": list(self.input_layout),
+            "input_state_template_ids": list(self.input_state_template_ids),
+            "output_layout": list(self.output_layout),
+            "output_state_template_id": self.output_state_template_id,
+            "prepared_kernel_id": self.prepared_kernel_id,
+            "resolver_key": self.resolver_key,
+            "runtime_template": self.runtime_template,
+            "semantic_template_ids": list(self.semantic_template_ids),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceTemplateCatalogHeaderV1:
+    compiled_model_digest: str
+    prepared_kernel_pack_digest: str
+    catalog_digest: str
+    abi: str = RECURRENCE_TEMPLATE_ABI
+    canonicalization_abi: str = RECURRENCE_TEMPLATE_CANONICALIZATION_ABI
+    exact_scalar_abi: str = RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI
+
+    def __post_init__(self) -> None:
+        if self.abi != RECURRENCE_TEMPLATE_ABI:
+            raise RecurrenceTemplateError(
+                f"unsupported recurrence template ABI {self.abi!r}"
+            )
+        if self.canonicalization_abi != RECURRENCE_TEMPLATE_CANONICALIZATION_ABI:
+            raise RecurrenceTemplateError(
+                "unsupported recurrence template canonicalization ABI"
+            )
+        if self.exact_scalar_abi != RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI:
+            raise RecurrenceTemplateError(
+                "unsupported recurrence template exact-scalar ABI"
+            )
+        _require_sha256("compiled_model_digest", self.compiled_model_digest)
+        _require_sha256("prepared_kernel_pack_digest", self.prepared_kernel_pack_digest)
+        _require_sha256("catalog_digest", self.catalog_digest)
+
+    def digest_payload(self) -> dict[str, object]:
+        return {
+            "abi": self.abi,
+            "canonicalization_abi": self.canonicalization_abi,
+            "compiled_model_digest": self.compiled_model_digest,
+            "exact_scalar_abi": self.exact_scalar_abi,
+            "prepared_kernel_pack_digest": self.prepared_kernel_pack_digest,
+        }
+
+    def to_dict(self) -> dict[str, object]:
+        return {**self.digest_payload(), "catalog_digest": self.catalog_digest}
+
+
+_Record = (
+    ParameterTemplateV1
+    | CurrentStateTemplateV1
+    | SourceTemplateV1
+    | QuantumFlowTemplateV1
+    | ContactOrbitCertificateV1
+    | ContactOrbitStepV1
+    | TransitionTemplateV1
+    | PropagatorTemplateV1
+    | ClosureTemplateV1
+    | ColorContractionTemplateV1
+    | SymmetryProofV1
+    | RecurrenceRuntimeHelicityContractV1
+    | EvaluatorBindingV1
+)
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceTemplateCatalog:
+    """Complete, content-addressed recurrence semantics for one compiled model."""
+
+    header: RecurrenceTemplateCatalogHeaderV1
+    parameters: tuple[ParameterTemplateV1, ...]
+    current_states: tuple[CurrentStateTemplateV1, ...]
+    sources: tuple[SourceTemplateV1, ...]
+    quantum_flows: tuple[QuantumFlowTemplateV1, ...]
+    contact_orbit_certificates: tuple[ContactOrbitCertificateV1, ...]
+    contact_orbit_steps: tuple[ContactOrbitStepV1, ...]
+    transitions: tuple[TransitionTemplateV1, ...]
+    propagators: tuple[PropagatorTemplateV1, ...]
+    closures: tuple[ClosureTemplateV1, ...]
+    color_contractions: tuple[ColorContractionTemplateV1, ...]
+    symmetry_proofs: tuple[SymmetryProofV1, ...]
+    runtime_helicity_contracts: tuple[RecurrenceRuntimeHelicityContractV1, ...]
+    evaluator_bindings: tuple[EvaluatorBindingV1, ...]
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.header, RecurrenceTemplateCatalogHeaderV1):
+            raise RecurrenceTemplateError(
+                "recurrence catalog header has the wrong type"
+            )
+        sections = self._sections()
+        for name, records in sections:
+            _require_tuple(f"recurrence catalog {name}", records)
+            keys = tuple(_record_identity(record) for record in records)
+            if keys != tuple(sorted(keys)):
+                raise RecurrenceTemplateError(
+                    f"recurrence catalog {name} must be sorted by semantic identity"
+                )
+            if len(keys) != len(set(keys)):
+                if name == "evaluator_bindings":
+                    raise RecurrenceTemplateError(
+                        "recurrence evaluator resolver keys must be unique"
+                    )
+                raise RecurrenceTemplateError(
+                    f"duplicate semantic identity in recurrence catalog {name}"
+                )
+
+        all_records = tuple(record for _, records in sections for record in records)
+        digests = tuple(record.semantic_digest for record in all_records)
+        if len(digests) != len(set(digests)):
+            raise RecurrenceTemplateError(
+                "duplicate semantic records in recurrence template catalog"
+            )
+        template_records = tuple(
+            record
+            for record in all_records
+            if not isinstance(record, EvaluatorBindingV1)
+        )
+        template_ids = tuple(record.template_id for record in template_records)
+        if len(template_ids) != len(set(template_ids)):
+            raise RecurrenceTemplateError(
+                "recurrence template semantic identities must be globally unique"
+            )
+        self._validate_references()
+        expected = _digest(self.digest_payload())
+        if self.header.catalog_digest != expected:
+            raise RecurrenceTemplateError("stale recurrence template catalog digest")
+
+    @classmethod
+    def create(
+        cls,
+        *,
+        compiled_model_digest: str,
+        prepared_kernel_pack_digest: str,
+        parameters: Sequence[ParameterTemplateV1] = (),
+        current_states: Sequence[CurrentStateTemplateV1] = (),
+        sources: Sequence[SourceTemplateV1] = (),
+        quantum_flows: Sequence[QuantumFlowTemplateV1] = (),
+        contact_orbit_certificates: Sequence[ContactOrbitCertificateV1] = (),
+        contact_orbit_steps: Sequence[ContactOrbitStepV1] = (),
+        transitions: Sequence[TransitionTemplateV1] = (),
+        propagators: Sequence[PropagatorTemplateV1] = (),
+        closures: Sequence[ClosureTemplateV1] = (),
+        color_contractions: Sequence[ColorContractionTemplateV1] = (),
+        symmetry_proofs: Sequence[SymmetryProofV1] = (),
+        runtime_helicity_contracts: Sequence[RecurrenceRuntimeHelicityContractV1] = (),
+        evaluator_bindings: Sequence[EvaluatorBindingV1] = (),
+    ) -> RecurrenceTemplateCatalog:
+        _require_sha256("compiled_model_digest", compiled_model_digest)
+        _require_sha256("prepared_kernel_pack_digest", prepared_kernel_pack_digest)
+        sorted_sections = {
+            "parameters": tuple(sorted(parameters, key=_record_identity)),
+            "current_states": tuple(sorted(current_states, key=_record_identity)),
+            "sources": tuple(sorted(sources, key=_record_identity)),
+            "quantum_flows": tuple(sorted(quantum_flows, key=_record_identity)),
+            "contact_orbit_certificates": tuple(
+                sorted(contact_orbit_certificates, key=_record_identity)
+            ),
+            "contact_orbit_steps": tuple(
+                sorted(contact_orbit_steps, key=_record_identity)
+            ),
+            "transitions": tuple(sorted(transitions, key=_record_identity)),
+            "propagators": tuple(sorted(propagators, key=_record_identity)),
+            "closures": tuple(sorted(closures, key=_record_identity)),
+            "color_contractions": tuple(
+                sorted(color_contractions, key=_record_identity)
+            ),
+            "symmetry_proofs": tuple(sorted(symmetry_proofs, key=_record_identity)),
+            "runtime_helicity_contracts": tuple(
+                sorted(runtime_helicity_contracts, key=_record_identity)
+            ),
+            "evaluator_bindings": tuple(
+                sorted(evaluator_bindings, key=_record_identity)
+            ),
+        }
+        provisional_header = {
+            "abi": RECURRENCE_TEMPLATE_ABI,
+            "canonicalization_abi": RECURRENCE_TEMPLATE_CANONICALIZATION_ABI,
+            "compiled_model_digest": compiled_model_digest,
+            "exact_scalar_abi": RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI,
+            "prepared_kernel_pack_digest": prepared_kernel_pack_digest,
+        }
+        digest_payload = {
+            "header": provisional_header,
+            **{
+                name: [record.to_dict() for record in records]
+                for name, records in sorted_sections.items()
+            },
+        }
+        header = RecurrenceTemplateCatalogHeaderV1(
+            compiled_model_digest=compiled_model_digest,
+            prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+            catalog_digest=_digest(digest_payload),
+        )
+        return cls(header=header, **sorted_sections)
+
+    def _sections(self) -> tuple[tuple[str, tuple[_Record, ...]], ...]:
+        return (
+            ("parameters", self.parameters),
+            ("current_states", self.current_states),
+            ("sources", self.sources),
+            ("quantum_flows", self.quantum_flows),
+            ("contact_orbit_certificates", self.contact_orbit_certificates),
+            ("contact_orbit_steps", self.contact_orbit_steps),
+            ("transitions", self.transitions),
+            ("propagators", self.propagators),
+            ("closures", self.closures),
+            ("color_contractions", self.color_contractions),
+            ("symmetry_proofs", self.symmetry_proofs),
+            ("runtime_helicity_contracts", self.runtime_helicity_contracts),
+            ("evaluator_bindings", self.evaluator_bindings),
+        )
+
+    def digest_payload(self) -> dict[str, object]:
+        return {
+            "header": self.header.digest_payload(),
+            **{
+                name: [record.to_dict() for record in records]
+                for name, records in self._sections()
+            },
+        }
+
+    @property
+    def canonical_json(self) -> str:
+        return _canonical_json(self.to_dict())
+
+    @property
+    def catalog_digest(self) -> str:
+        return self.header.catalog_digest
+
+    def require_complete_runtime_helicity_contracts(self) -> None:
+        """Fail all-flow-union preflight unless every source is certified."""
+
+        covered = {
+            variant.source_template_id
+            for contract in self.runtime_helicity_contracts
+            for variant in contract.variants
+        }
+        missing = tuple(
+            source.template_id
+            for source in self.sources
+            if source.template_id not in covered
+        )
+        if missing:
+            raise RecurrenceTemplateError(
+                "recurrence all-flow-union preflight requires complete certified "
+                "full-state runtime-helicity contracts; missing source templates: "
+                + ", ".join(missing)
+            )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "header": self.header.to_dict(),
+            **{
+                name: [record.to_dict() for record in records]
+                for name, records in self._sections()
+            },
+        }
+
+    def _validate_references(self) -> None:
+        parameters = {record.template_id: record for record in self.parameters}
+        states = {record.template_id: record for record in self.current_states}
+        sources = {record.template_id: record for record in self.sources}
+        quantum_flows = {record.template_id: record for record in self.quantum_flows}
+        contact_orbit_certificates = {
+            record.template_id: record for record in self.contact_orbit_certificates
+        }
+        contact_orbit_steps = {
+            record.template_id: record for record in self.contact_orbit_steps
+        }
+        colors = {record.template_id: record for record in self.color_contractions}
+        proofs = {record.template_id: record for record in self.symmetry_proofs}
+        templates = {
+            record.template_id: record
+            for _, records in self._sections()
+            for record in records
+            if not isinstance(record, EvaluatorBindingV1)
+        }
+        evaluators = {record.resolver_key: record for record in self.evaluator_bindings}
+        static_quantum_flows: dict[str, QuantumNumberFlowV1] = {}
+
+        for parameter in self.parameters:
+            _require_references(
+                "parameter dependencies",
+                parameter.dependency_parameter_ids,
+                parameters,
+            )
+            if parameter.template_id in parameter.dependency_parameter_ids:
+                raise RecurrenceTemplateError(
+                    "parameter cannot depend directly on itself"
+                )
+        _require_acyclic_parameter_dependencies(parameters)
+        for step in self.contact_orbit_steps:
+            certificate = _require_reference(
+                "contact-orbit step certificate",
+                step.certificate_template_id,
+                contact_orbit_certificates,
+            )
+            arity = len(certificate.particles)
+            referenced_legs = {
+                step.result_leg,
+                *step.left_covered_legs,
+                *step.right_covered_legs,
+            }
+            if any(leg not in range(arity) for leg in referenced_legs):
+                raise RecurrenceTemplateError(
+                    "contact-orbit step exceeds its certificate arity"
+                )
+            if step.stage == "final" and set(
+                (*step.left_covered_legs, *step.right_covered_legs)
+            ) != (set(range(arity)) - {step.result_leg}):
+                raise RecurrenceTemplateError(
+                    "contact-orbit final step does not cover its certificate"
+                )
+        for state in self.current_states:
+            _require_optional_reference(
+                "current mass parameter", state.mass_parameter_id, parameters
+            )
+            _require_optional_reference(
+                "current width parameter", state.width_parameter_id, parameters
+            )
+        for source in self.sources:
+            source_state = _require_reference(
+                "source state", source.state_template_id, states
+            )
+            if (
+                source.lc_color_seed.output_shape_kind
+                != source_state.lc_color_shape_kind
+            ):
+                raise RecurrenceTemplateError(
+                    "source LC color seed shape does not match its current state"
+                )
+            _require_optional_reference(
+                "source mass parameter", source.mass_parameter_id, parameters
+            )
+            _require_optional_reference(
+                "source width parameter", source.width_parameter_id, parameters
+            )
+            evaluator = _require_reference(
+                "source evaluator", source.evaluator_resolver_key, evaluators
+            )
+            _validate_evaluator_contract(
+                evaluator,
+                kind="source",
+                inputs=(),
+                output=source.state_template_id,
+                semantic_template_id=source.template_id,
+            )
+        for flow in self.quantum_flows:
+            _require_references(
+                "quantum-flow input states", flow.input_state_template_ids, states
+            )
+            result_state = _require_reference(
+                "quantum-flow result state", flow.result_state_template_id, states
+            )
+            expected_flavour = _apply_flavour_flow_operation(
+                flow.flavour_flow_operation,
+                flow.input_flavour_flows[0],
+                flow.input_flavour_flows[1],
+                result_state.particle_id,
+            )
+            if flow.result_flavour_flow != expected_flavour:
+                raise RecurrenceTemplateError(
+                    "quantum-flow flavour operation does not reproduce its stored "
+                    "result witness"
+                )
+            previous_quantum_flow = static_quantum_flows.setdefault(
+                flow.result_state_template_id,
+                flow.result_quantum_number_flow,
+            )
+            if flow.result_quantum_number_flow != previous_quantum_flow:
+                raise RecurrenceTemplateError(
+                    "particle-static quantum-number flow differs for one result state"
+                )
+        for transition in self.transitions:
+            _require_references(
+                "transition input states",
+                transition.input_state_template_ids,
+                states,
+            )
+            _require_reference(
+                "transition result state",
+                transition.result_state_template_id,
+                states,
+            )
+            flow = _require_reference(
+                "transition quantum flow",
+                transition.quantum_flow_template_id,
+                quantum_flows,
+            )
+            if (
+                flow.input_state_template_ids != transition.input_state_template_ids
+                or flow.result_state_template_id != transition.result_state_template_id
+                or flow.coupling_orders != transition.coupling_orders
+            ):
+                raise RecurrenceTemplateError(
+                    "transition and quantum-flow state/coupling contracts do not match"
+                )
+            _require_references(
+                "transition coupling parameters",
+                transition.coupling_parameter_ids,
+                parameters,
+            )
+            _require_reference(
+                "transition color contraction",
+                transition.color_contraction_template_id,
+                colors,
+            )
+            evaluator = _require_reference(
+                "transition evaluator",
+                transition.evaluator_resolver_key,
+                evaluators,
+            )
+            _validate_evaluator_contract(
+                evaluator,
+                kind="vertex",
+                inputs=transition.input_state_template_ids,
+                output=transition.result_state_template_id,
+                semantic_template_id=transition.template_id,
+            )
+            for step_id, step_digest in zip(
+                transition.contact_orbit_step_template_ids,
+                transition.contact_orbit_step_semantic_digests,
+                strict=True,
+            ):
+                step = _require_reference(
+                    "transition contact-orbit step", step_id, contact_orbit_steps
+                )
+                if step_digest != step.semantic_digest:
+                    raise RecurrenceTemplateError(
+                        "transition contact-orbit step digest is stale"
+                    )
+        for propagator in self.propagators:
+            _require_reference("propagator state", propagator.state_template_id, states)
+            _require_optional_reference(
+                "propagator mass parameter", propagator.mass_parameter_id, parameters
+            )
+            _require_optional_reference(
+                "propagator width parameter",
+                propagator.width_parameter_id,
+                parameters,
+            )
+            _require_optional_reference(
+                "propagator linearity proof",
+                propagator.linearity_proof_template_id,
+                proofs,
+            )
+            if propagator.evaluator_resolver_key is not None:
+                evaluator = _require_reference(
+                    "propagator evaluator",
+                    propagator.evaluator_resolver_key,
+                    evaluators,
+                )
+                _validate_evaluator_contract(
+                    evaluator,
+                    kind="propagator",
+                    inputs=(propagator.state_template_id,),
+                    output=propagator.state_template_id,
+                    semantic_template_id=propagator.template_id,
+                )
+        for closure in self.closures:
+            _require_references(
+                "closure input states", closure.input_state_template_ids, states
+            )
+            _require_optional_reference(
+                "closure result state", closure.result_state_template_id, states
+            )
+            eligible_flows = tuple(
+                _require_reference(
+                    "closure eligible quantum flow", flow_id, quantum_flows
+                )
+                for flow_id in closure.eligible_quantum_flow_template_ids
+            )
+            if any(
+                flow.input_state_template_ids != closure.input_state_template_ids
+                or flow.result_state_template_id != closure.result_state_template_id
+                or flow.coupling_orders != closure.coupling_orders
+                for flow in eligible_flows
+            ):
+                raise RecurrenceTemplateError(
+                    "closure and eligible quantum-flow input/result/coupling "
+                    "contracts do not match"
+                )
+            _require_references(
+                "closure coupling parameters",
+                closure.coupling_parameter_ids,
+                parameters,
+            )
+            _require_reference(
+                "closure color contraction",
+                closure.color_contraction_template_id,
+                colors,
+            )
+            evaluator = _require_reference(
+                "closure evaluator", closure.evaluator_resolver_key, evaluators
+            )
+            if evaluator.callable_kind == "prepared-kernel" and not eligible_flows:
+                raise RecurrenceTemplateError(
+                    "prepared closure must carry at least one eligible quantum-flow "
+                    "witness"
+                )
+            if evaluator.callable_kind == "rusticol-template" and eligible_flows:
+                raise RecurrenceTemplateError(
+                    "direct Rusticol closure cannot carry prepared quantum-flow "
+                    "witnesses"
+                )
+            if (
+                evaluator.callable_kind == "prepared-kernel"
+                and closure.result_state_template_id is None
+            ):
+                raise RecurrenceTemplateError(
+                    "prepared closure must carry a result-state contract"
+                )
+            if (
+                evaluator.callable_kind == "rusticol-template"
+                and closure.result_state_template_id is not None
+            ):
+                raise RecurrenceTemplateError(
+                    "direct Rusticol closure cannot carry a result-state contract"
+                )
+            _validate_evaluator_contract(
+                evaluator,
+                kind="closure",
+                inputs=closure.input_state_template_ids,
+                output=None,
+                semantic_template_id=closure.template_id,
+            )
+        for proof in self.symmetry_proofs:
+            _require_references(
+                "symmetry proof subjects", proof.subject_template_ids, templates
+            )
+        source_contract_owner: dict[str, str] = {}
+        particle_contract_owner: dict[int, str] = {}
+        for contract in self.runtime_helicity_contracts:
+            full_state = _require_reference(
+                "runtime-helicity full state",
+                contract.full_state_template_id,
+                states,
+            )
+            previous_particle_owner = particle_contract_owner.setdefault(
+                full_state.particle_id, contract.template_id
+            )
+            if previous_particle_owner != contract.template_id:
+                raise RecurrenceTemplateError(
+                    "one physical source family cannot span runtime-helicity contracts"
+                )
+            variant_source_ids = {item.source_template_id for item in contract.variants}
+            family_source_ids = {
+                item.template_id
+                for item in self.sources
+                if states[item.state_template_id].particle_id == full_state.particle_id
+            }
+            if variant_source_ids != family_source_ids:
+                raise RecurrenceTemplateError(
+                    "runtime-helicity contract must cover its complete physical "
+                    "source family"
+                )
+            for variant in contract.variants:
+                source = _require_reference(
+                    "runtime-helicity source", variant.source_template_id, sources
+                )
+                source_state = _require_reference(
+                    "runtime-helicity source state",
+                    variant.source_state_template_id,
+                    states,
+                )
+                if source.state_template_id != source_state.template_id:
+                    raise RecurrenceTemplateError(
+                        "runtime-helicity source variant names the wrong source state"
+                    )
+                if (
+                    source_state.particle_id != full_state.particle_id
+                    or source_state.species_id != full_state.species_id
+                    or source_state.orientation != full_state.orientation
+                ):
+                    raise RecurrenceTemplateError(
+                        "runtime-helicity variant and full state are not one physical "
+                        "source family"
+                    )
+                if len(variant.embedding_source_components) != full_state.dimension:
+                    raise RecurrenceTemplateError(
+                        "runtime-helicity embedding dimension does not match full state"
+                    )
+                if len(variant.projection_full_components) != source_state.dimension:
+                    raise RecurrenceTemplateError(
+                        "runtime-helicity projection dimension does not match source "
+                        "state"
+                    )
+                previous = source_contract_owner.setdefault(
+                    source.template_id, contract.template_id
+                )
+                if previous != contract.template_id:
+                    raise RecurrenceTemplateError(
+                        "source template belongs to multiple runtime-helicity contracts"
+                    )
+        for binding in self.evaluator_bindings:
+            _require_references(
+                "evaluator input states", binding.input_state_template_ids, states
+            )
+            _require_optional_reference(
+                "evaluator output state", binding.output_state_template_id, states
+            )
+            _require_references(
+                "evaluator semantic templates",
+                binding.semantic_template_ids,
+                templates,
+            )
+            if binding.output_state_template_id is not None:
+                dimension = states[binding.output_state_template_id].dimension
+                if len(binding.output_layout) != dimension:
+                    raise RecurrenceTemplateError(
+                        "evaluator output layout does not match state dimension"
+                    )
+
+        callable_by_kernel: dict[
+            int,
+            tuple[
+                str,
+                str,
+                tuple[str, ...],
+                tuple[str, ...],
+                tuple[str, ...],
+            ],
+        ] = {}
+        callable_by_runtime_template: dict[
+            str,
+            tuple[
+                str,
+                str,
+                tuple[str, ...],
+                tuple[str, ...],
+                tuple[str, ...],
+            ],
+        ] = {}
+        semantic_binding_owner: dict[str, str] = {}
+        expected_template_types = {
+            "source": SourceTemplateV1,
+            "vertex": TransitionTemplateV1,
+            "propagator": PropagatorTemplateV1,
+            "closure": ClosureTemplateV1,
+            "model-parameter": ParameterTemplateV1,
+        }
+        for binding in self.evaluator_bindings:
+            callable_contract = (
+                binding.contract_kind,
+                binding.callable_signature,
+                binding.input_layout,
+                binding.output_layout,
+                binding.exact_expression_digests,
+            )
+            if binding.prepared_kernel_id is not None:
+                previous = callable_by_kernel.setdefault(
+                    binding.prepared_kernel_id, callable_contract
+                )
+                owner = "prepared kernel ID"
+            else:
+                assert binding.runtime_template is not None
+                previous = callable_by_runtime_template.setdefault(
+                    binding.runtime_template, callable_contract
+                )
+                owner = "Rusticol runtime template"
+            if previous != callable_contract:
+                raise RecurrenceTemplateError(
+                    f"{owner} has inconsistent callable bindings"
+                )
+            expected_type = expected_template_types[binding.contract_kind]
+            for template_id in binding.semantic_template_ids:
+                template = templates[template_id]
+                if not isinstance(template, expected_type):
+                    raise RecurrenceTemplateError(
+                        "evaluator contract kind does not match semantic template"
+                    )
+                previous_owner = semantic_binding_owner.setdefault(
+                    template_id, binding.resolver_key
+                )
+                if previous_owner != binding.resolver_key:
+                    raise RecurrenceTemplateError(
+                        "semantic template has multiple evaluator resolver keys"
+                    )
+
+    @classmethod
+    def from_dict(cls, payload: Mapping[str, object]) -> RecurrenceTemplateCatalog:
+        root = _require_mapping("recurrence template catalog", payload)
+        section_names = frozenset(
+            {
+                "header",
+                "parameters",
+                "current_states",
+                "sources",
+                "quantum_flows",
+                "contact_orbit_certificates",
+                "contact_orbit_steps",
+                "transitions",
+                "propagators",
+                "closures",
+                "color_contractions",
+                "symmetry_proofs",
+                "runtime_helicity_contracts",
+                "evaluator_bindings",
+            }
+        )
+        _require_exact_keys("recurrence template catalog", root, section_names)
+        header_payload = _require_mapping("catalog header", root["header"])
+        _require_exact_keys(
+            "catalog header",
+            header_payload,
+            frozenset(
+                {
+                    "abi",
+                    "canonicalization_abi",
+                    "compiled_model_digest",
+                    "exact_scalar_abi",
+                    "prepared_kernel_pack_digest",
+                    "catalog_digest",
+                }
+            ),
+        )
+        header = RecurrenceTemplateCatalogHeaderV1(
+            compiled_model_digest=_require_sha256(
+                "compiled_model_digest", header_payload["compiled_model_digest"]
+            ),
+            prepared_kernel_pack_digest=_require_sha256(
+                "prepared_kernel_pack_digest",
+                header_payload["prepared_kernel_pack_digest"],
+            ),
+            catalog_digest=_require_sha256(
+                "catalog_digest", header_payload["catalog_digest"]
+            ),
+            abi=_require_nonempty("catalog abi", header_payload["abi"]),
+            canonicalization_abi=_require_nonempty(
+                "catalog canonicalization_abi",
+                header_payload["canonicalization_abi"],
+            ),
+            exact_scalar_abi=_require_nonempty(
+                "catalog exact_scalar_abi", header_payload["exact_scalar_abi"]
+            ),
+        )
+        decoders = {
+            "parameters": _parameter_from_dict,
+            "current_states": _current_state_from_dict,
+            "sources": _source_from_dict,
+            "quantum_flows": _quantum_flow_from_dict,
+            "contact_orbit_certificates": _contact_orbit_certificate_from_dict,
+            "contact_orbit_steps": _contact_orbit_step_from_dict,
+            "transitions": _transition_from_dict,
+            "propagators": _propagator_from_dict,
+            "closures": _closure_from_dict,
+            "color_contractions": _color_from_dict,
+            "symmetry_proofs": _symmetry_from_dict,
+            "runtime_helicity_contracts": _runtime_helicity_contract_from_dict,
+            "evaluator_bindings": _evaluator_from_dict,
+        }
+        decoded: dict[str, tuple[_Record, ...]] = {}
+        for name, decoder in decoders.items():
+            rows = root[name]
+            if not isinstance(rows, list):
+                raise RecurrenceTemplateError(f"catalog {name} must be an array")
+            decoded[name] = tuple(
+                decoder(_require_mapping(f"catalog {name} record", row)) for row in rows
+            )
+        return cls(header=header, **decoded)  # type: ignore[arg-type]
+
+
+def _record_identity(record: _Record) -> str:
+    if isinstance(record, EvaluatorBindingV1):
+        return record.resolver_key
+    return record.template_id
+
+
+def _require_reference(name: str, key: str, known: Mapping[str, _Record]):
+    try:
+        return known[key]
+    except KeyError as exc:
+        raise RecurrenceTemplateError(f"{name} references unknown {key!r}") from exc
+
+
+def _require_optional_reference(
+    name: str,
+    key: str | None,
+    known: Mapping[str, _Record],
+) -> None:
+    if key is not None:
+        _require_reference(name, key, known)
+
+
+def _require_references(
+    name: str,
+    keys: Sequence[str],
+    known: Mapping[str, _Record],
+) -> None:
+    for key in keys:
+        _require_reference(name, key, known)
+
+
+def _require_acyclic_parameter_dependencies(
+    parameters: Mapping[str, ParameterTemplateV1],
+) -> None:
+    indegree = {
+        template_id: len(parameter.dependency_parameter_ids)
+        for template_id, parameter in parameters.items()
+    }
+    dependents: dict[str, list[str]] = {template_id: [] for template_id in parameters}
+    for template_id, parameter in parameters.items():
+        for dependency_id in parameter.dependency_parameter_ids:
+            dependents[dependency_id].append(template_id)
+    ready = sorted(template_id for template_id, count in indegree.items() if count == 0)
+    visited = 0
+    while ready:
+        template_id = ready.pop()
+        visited += 1
+        for dependent_id in dependents[template_id]:
+            indegree[dependent_id] -= 1
+            if indegree[dependent_id] == 0:
+                ready.append(dependent_id)
+    if visited != len(parameters):
+        cyclic = sorted(
+            template_id for template_id, count in indegree.items() if count > 0
+        )
+        raise RecurrenceTemplateError(
+            "parameter dependency graph contains a cycle involving: "
+            + ", ".join(cyclic)
+        )
+
+
+def _validate_evaluator_contract(
+    binding: EvaluatorBindingV1,
+    *,
+    kind: EvaluatorContractKind,
+    inputs: tuple[str, ...],
+    output: str | None,
+    semantic_template_id: str,
+) -> None:
+    if binding.contract_kind != kind:
+        raise RecurrenceTemplateError(
+            f"{semantic_template_id!r} uses a {binding.contract_kind!r} evaluator "
+            f"where {kind!r} is required"
+        )
+    if binding.input_state_template_ids != inputs:
+        raise RecurrenceTemplateError(
+            f"{semantic_template_id!r} evaluator input states do not match"
+        )
+    if binding.output_state_template_id != output:
+        raise RecurrenceTemplateError(
+            f"{semantic_template_id!r} evaluator output state does not match"
+        )
+    if semantic_template_id not in binding.semantic_template_ids:
+        raise RecurrenceTemplateError(
+            f"{semantic_template_id!r} is missing from its evaluator binding"
+        )
+
+
+def _record_payload(
+    name: str,
+    payload: Mapping[str, object],
+    fields: frozenset[str],
+    record_kind: str,
+) -> Mapping[str, object]:
+    _require_exact_keys(name, payload, fields | {"record_kind", "semantic_digest"})
+    if payload["record_kind"] != record_kind:
+        raise RecurrenceTemplateError(
+            f"{name} has record kind {payload['record_kind']!r}, expected "
+            f"{record_kind!r}"
+        )
+    _require_sha256(f"{name} semantic_digest", payload["semantic_digest"])
+    return payload
+
+
+def _decode_ratio(name: str, value: object) -> ExactComplexRationalV1:
+    return ExactComplexRationalV1.from_dict(_require_mapping(name, value))
+
+
+def _decode_optional_ratio(
+    name: str,
+    value: object,
+) -> ExactComplexRationalV1 | None:
+    if value is None:
+        return None
+    return _decode_ratio(name, value)
+
+
+def _decode_ratio_array(
+    name: str,
+    value: object,
+) -> tuple[ExactComplexRationalV1, ...]:
+    if not isinstance(value, list):
+        raise RecurrenceTemplateError(f"{name} must be an array")
+    return tuple(
+        _decode_ratio(f"{name}[{index}]", item) for index, item in enumerate(value)
+    )
+
+
+def _decode_coupling_orders(name: str, value: object) -> tuple[tuple[str, int], ...]:
+    if not isinstance(value, list):
+        raise RecurrenceTemplateError(f"{name} must be an array")
+    result: list[tuple[str, int]] = []
+    for item in value:
+        if (
+            not isinstance(item, list)
+            or len(item) != 2
+            or not isinstance(item[0], str)
+            or type(item[1]) is not int
+        ):
+            raise RecurrenceTemplateError(f"{name} entries must be [name, power]")
+        result.append((item[0], item[1]))
+    return tuple(result)
+
+
+def _parameter_from_dict(payload: Mapping[str, object]) -> ParameterTemplateV1:
+    value = _record_payload(
+        "parameter template",
+        payload,
+        frozenset(
+            {
+                "template_id",
+                "name",
+                "parameter_kind",
+                "value_type",
+                "mutable",
+                "default_value",
+                "exact_expression_digest",
+                "dependency_parameter_ids",
+                "prepared_parameter_id",
+            }
+        ),
+        "parameter",
+    )
+    default = value["default_value"]
+    return ParameterTemplateV1(
+        template_id=_require_nonempty("parameter template_id", value["template_id"]),
+        name=_require_nonempty("parameter name", value["name"]),
+        parameter_kind=value["parameter_kind"],  # type: ignore[arg-type]
+        value_type=value["value_type"],  # type: ignore[arg-type]
+        mutable=value["mutable"],  # type: ignore[arg-type]
+        default_value=None if default is None else _decode_ratio("default", default),
+        exact_expression_digest=_require_optional_sha256(
+            "parameter exact expression", value["exact_expression_digest"]
+        ),
+        dependency_parameter_ids=_decode_string_tuple(
+            "parameter dependencies", value["dependency_parameter_ids"]
+        ),
+        prepared_parameter_id=(
+            None
+            if value["prepared_parameter_id"] is None
+            else _require_int(
+                "prepared parameter ID",
+                value["prepared_parameter_id"],
+                minimum=0,
+            )
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _current_state_from_dict(payload: Mapping[str, object]) -> CurrentStateTemplateV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "particle_id",
+            "anti_particle_id",
+            "species_id",
+            "orientation",
+            "statistics",
+            "color_representation",
+            "basis",
+            "tensor_ordering",
+            "dimension",
+            "chirality",
+            "lc_color_shape_kind",
+            "auxiliary_kind",
+            "mass_parameter_id",
+            "width_parameter_id",
+        }
+    )
+    value = _record_payload("current-state template", payload, fields, "current-state")
+    return CurrentStateTemplateV1(
+        template_id=_require_nonempty("state template_id", value["template_id"]),
+        particle_id=_require_int("particle_id", value["particle_id"]),
+        anti_particle_id=_require_int("anti_particle_id", value["anti_particle_id"]),
+        species_id=_require_nonempty("species_id", value["species_id"]),
+        orientation=_require_nonempty("orientation", value["orientation"]),
+        statistics=_require_nonempty("statistics", value["statistics"]),
+        color_representation=_require_int(
+            "color_representation", value["color_representation"]
+        ),
+        basis=_require_nonempty("basis", value["basis"]),
+        tensor_ordering=_decode_string_tuple(
+            "tensor_ordering", value["tensor_ordering"]
+        ),
+        dimension=_require_int("dimension", value["dimension"]),
+        chirality=_require_int("chirality", value["chirality"]),
+        lc_color_shape_kind=_require_nonempty(
+            "LC color shape kind", value["lc_color_shape_kind"]
+        ),  # type: ignore[arg-type]
+        auxiliary_kind=_decode_optional_string(
+            "auxiliary_kind", value["auxiliary_kind"]
+        ),
+        mass_parameter_id=_decode_optional_string(
+            "mass_parameter_id", value["mass_parameter_id"]
+        ),
+        width_parameter_id=_decode_optional_string(
+            "width_parameter_id", value["width_parameter_id"]
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _source_from_dict(payload: Mapping[str, object]) -> SourceTemplateV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "state_template_id",
+            "crossing",
+            "wavefunction_family",
+            "helicity",
+            "spin_state",
+            "flavour_flow",
+            "quantum_number_flow",
+            "lc_color_seed",
+            "wavefunction_expression_digest",
+            "evaluator_resolver_key",
+            "mass_parameter_id",
+            "width_parameter_id",
+        }
+    )
+    value = _record_payload("source template", payload, fields, "source")
+    return SourceTemplateV1(
+        template_id=_require_nonempty("source template_id", value["template_id"]),
+        state_template_id=_require_nonempty(
+            "source state_template_id", value["state_template_id"]
+        ),
+        crossing=_require_nonempty("source crossing", value["crossing"]),
+        wavefunction_family=_require_nonempty(
+            "source wavefunction family", value["wavefunction_family"]
+        ),
+        helicity=_require_int("source helicity", value["helicity"]),
+        spin_state=_require_int("source spin_state", value["spin_state"]),
+        flavour_flow=_decode_flavour_flow("source flavour flow", value["flavour_flow"]),
+        quantum_number_flow=_decode_quantum_number_flow(
+            "source quantum-number flow", value["quantum_number_flow"]
+        ),
+        lc_color_seed=_lc_color_source_seed_from_dict(value["lc_color_seed"]),
+        wavefunction_expression_digest=_require_sha256(
+            "source wavefunction expression", value["wavefunction_expression_digest"]
+        ),
+        evaluator_resolver_key=_require_nonempty(
+            "source evaluator", value["evaluator_resolver_key"]
+        ),
+        mass_parameter_id=_decode_optional_string(
+            "source mass parameter", value["mass_parameter_id"]
+        ),
+        width_parameter_id=_decode_optional_string(
+            "source width parameter", value["width_parameter_id"]
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _lc_color_source_seed_from_dict(payload: object) -> LCColorSourceSeedV1:
+    value = _require_mapping("LC color source seed", payload)
+    _require_exact_keys(
+        "LC color source seed",
+        value,
+        frozenset(
+            {
+                "component_kind",
+                "component_role",
+                "operation",
+                "output_shape_kind",
+                "proof_digest",
+                "provenance",
+            }
+        ),
+    )
+    return LCColorSourceSeedV1(
+        operation=_require_nonempty(
+            "LC color source seed operation", value["operation"]
+        ),  # type: ignore[arg-type]
+        output_shape_kind=_require_nonempty(
+            "LC color source seed output shape", value["output_shape_kind"]
+        ),  # type: ignore[arg-type]
+        component_kind=_decode_optional_string(
+            "LC color source seed component kind", value["component_kind"]
+        ),  # type: ignore[arg-type]
+        component_role=_require_nonempty(
+            "LC color source seed component role", value["component_role"]
+        ),  # type: ignore[arg-type]
+        proof_digest=_require_sha256(
+            "LC color source seed proof digest", value["proof_digest"]
+        ),
+        provenance=_decode_string_pairs(
+            "LC color source seed provenance",
+            value["provenance"],
+        ),
+    )
+
+
+def _quantum_flow_from_dict(payload: Mapping[str, object]) -> QuantumFlowTemplateV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "input_state_template_ids",
+            "input_spin_states",
+            "input_flavour_flows",
+            "input_quantum_number_flows",
+            "flavour_flow_operation",
+            "quantum_number_flow_operation",
+            "coupling_orders",
+            "result_state_template_id",
+            "result_spin_state",
+            "result_flavour_flow",
+            "result_quantum_number_flow",
+            "exact_coupling",
+            "predicate_digest",
+        }
+    )
+    value = _record_payload("quantum-flow template", payload, fields, "quantum-flow")
+    return QuantumFlowTemplateV1(
+        template_id=_require_nonempty("flow template_id", value["template_id"]),
+        input_state_template_ids=_decode_string_tuple(
+            "flow input states", value["input_state_template_ids"]
+        ),
+        input_spin_states=_decode_int_tuple(
+            "flow spin states", value["input_spin_states"]
+        ),
+        input_flavour_flows=_decode_flavour_flows(
+            "flow flavour inputs", value["input_flavour_flows"]
+        ),
+        input_quantum_number_flows=_decode_quantum_number_flows(
+            "flow quantum-number inputs", value["input_quantum_number_flows"]
+        ),
+        flavour_flow_operation=_require_nonempty(
+            "flow flavour operation", value["flavour_flow_operation"]
+        ),  # type: ignore[arg-type]
+        quantum_number_flow_operation=_require_nonempty(
+            "flow quantum-number operation",
+            value["quantum_number_flow_operation"],
+        ),  # type: ignore[arg-type]
+        coupling_orders=_decode_coupling_orders(
+            "flow coupling orders", value["coupling_orders"]
+        ),
+        result_state_template_id=_require_nonempty(
+            "flow result state", value["result_state_template_id"]
+        ),
+        result_spin_state=_require_int(
+            "flow result spin state", value["result_spin_state"]
+        ),
+        result_flavour_flow=_decode_flavour_flow(
+            "flow result flavour", value["result_flavour_flow"]
+        ),
+        result_quantum_number_flow=_decode_quantum_number_flow(
+            "flow result quantum number", value["result_quantum_number_flow"]
+        ),
+        exact_coupling=_decode_ratio("flow exact coupling", value["exact_coupling"]),
+        predicate_digest=_require_sha256(
+            "flow predicate digest", value["predicate_digest"]
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _contact_orbit_certificate_from_dict(
+    payload: Mapping[str, object],
+) -> ContactOrbitCertificateV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "algorithm",
+            "algorithm_version",
+            "term_id",
+            "vertex",
+            "particles",
+            "evaluator_class",
+            "physical_leg_equivalence_classes",
+            "reconstruction_factor",
+        }
+    )
+    value = _record_payload(
+        "contact-orbit certificate",
+        payload,
+        fields,
+        "contact-orbit-certificate",
+    )
+    particles = _decode_string_tuple(
+        "contact-orbit certificate particles", value["particles"]
+    )
+    classes = _decode_int_tuple(
+        "contact-orbit certificate equivalence classes",
+        value["physical_leg_equivalence_classes"],
+    )
+    if len(particles) not in {4, 5} or len(classes) != len(particles):
+        raise RecurrenceTemplateError(
+            "contact-orbit certificate must describe four or five legs"
+        )
+    return ContactOrbitCertificateV1(
+        template_id=_require_nonempty(
+            "contact-orbit certificate template_id", value["template_id"]
+        ),
+        algorithm=_require_nonempty(
+            "contact-orbit certificate algorithm", value["algorithm"]
+        ),
+        algorithm_version=_require_int(
+            "contact-orbit certificate algorithm version",
+            value["algorithm_version"],
+            minimum=1,
+        ),
+        term_id=_require_int(
+            "contact-orbit certificate term ID", value["term_id"], minimum=0
+        ),
+        vertex=_require_nonempty(
+            "contact-orbit certificate vertex", value["vertex"]
+        ),
+        particles=particles,
+        evaluator_class=_require_nonempty(
+            "contact-orbit certificate evaluator class", value["evaluator_class"]
+        ),
+        physical_leg_equivalence_classes=classes,
+        reconstruction_factor=_decode_ratio(
+            "contact-orbit certificate reconstruction factor",
+            value["reconstruction_factor"],
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _contact_orbit_step_from_dict(
+    payload: Mapping[str, object],
+) -> ContactOrbitStepV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "certificate_template_id",
+            "stage",
+            "result_leg",
+            "left_covered_legs",
+            "right_covered_legs",
+            "source_particle_legs",
+            "reconstruction_factor",
+        }
+    )
+    value = _record_payload(
+        "contact-orbit step", payload, fields, "contact-orbit-step"
+    )
+    source_legs = _decode_int_tuple(
+        "contact-orbit step source legs", value["source_particle_legs"]
+    )
+    if len(source_legs) != 3:
+        raise RecurrenceTemplateError(
+            "contact-orbit step must describe three kernel slots"
+        )
+    return ContactOrbitStepV1(
+        template_id=_require_nonempty(
+            "contact-orbit step template_id", value["template_id"]
+        ),
+        certificate_template_id=_require_nonempty(
+            "contact-orbit step certificate", value["certificate_template_id"]
+        ),
+        stage=_require_nonempty("contact-orbit step stage", value["stage"]),
+        result_leg=_require_int(
+            "contact-orbit step result leg", value["result_leg"], minimum=0
+        ),
+        left_covered_legs=_decode_int_tuple(
+            "contact-orbit left covered legs", value["left_covered_legs"]
+        ),
+        right_covered_legs=_decode_int_tuple(
+            "contact-orbit right covered legs", value["right_covered_legs"]
+        ),
+        source_particle_legs=(source_legs[0], source_legs[1], source_legs[2]),
+        reconstruction_factor=_decode_ratio(
+            "contact-orbit step reconstruction factor",
+            value["reconstruction_factor"],
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _transition_from_dict(payload: Mapping[str, object]) -> TransitionTemplateV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "input_state_template_ids",
+            "result_state_template_id",
+            "quantum_flow_template_id",
+            "evaluator_resolver_key",
+            "canonical_input_order",
+            "momentum_convention",
+            "coupling_parameter_ids",
+            "coupling_orders",
+            "color_contraction_template_id",
+            "binding_coupling",
+            "exact_factor",
+            "output_factor_source",
+            "equivalence_class",
+            "input_exchange_factor",
+            "output_projection",
+            "contact_orbit_step_template_ids",
+            "contact_orbit_step_semantic_digests",
+        }
+    )
+    value = _record_payload("transition template", payload, fields, "transition")
+    return TransitionTemplateV1(
+        template_id=_require_nonempty("transition template_id", value["template_id"]),
+        input_state_template_ids=_decode_string_tuple(
+            "transition input states", value["input_state_template_ids"]
+        ),
+        result_state_template_id=_require_nonempty(
+            "transition result state", value["result_state_template_id"]
+        ),
+        quantum_flow_template_id=_require_nonempty(
+            "transition quantum flow", value["quantum_flow_template_id"]
+        ),
+        evaluator_resolver_key=_require_nonempty(
+            "transition evaluator", value["evaluator_resolver_key"]
+        ),
+        canonical_input_order=_decode_int_tuple(
+            "transition input order", value["canonical_input_order"]
+        ),
+        momentum_convention=_decode_string_tuple(
+            "transition momenta", value["momentum_convention"]
+        ),
+        coupling_parameter_ids=_decode_string_tuple(
+            "transition coupling parameters", value["coupling_parameter_ids"]
+        ),
+        coupling_orders=_decode_coupling_orders(
+            "transition coupling orders", value["coupling_orders"]
+        ),
+        color_contraction_template_id=_require_nonempty(
+            "transition color", value["color_contraction_template_id"]
+        ),
+        binding_coupling=_decode_ratio(
+            "transition binding coupling", value["binding_coupling"]
+        ),
+        exact_factor=_decode_ratio("transition exact factor", value["exact_factor"]),
+        output_factor_source=_require_nonempty(
+            "transition output factor source", value["output_factor_source"]
+        ),  # type: ignore[arg-type]
+        equivalence_class=_require_nonempty(
+            "transition equivalence class", value["equivalence_class"]
+        ),
+        input_exchange_factor=_decode_optional_ratio(
+            "transition input-exchange factor", value["input_exchange_factor"]
+        ),
+        output_projection=_require_nonempty(
+            "transition projection", value["output_projection"]
+        ),
+        contact_orbit_step_template_ids=_decode_string_tuple(
+            "transition contact-orbit steps",
+            value["contact_orbit_step_template_ids"],
+        ),
+        contact_orbit_step_semantic_digests=_decode_string_tuple(
+            "transition contact-orbit step semantic digests",
+            value["contact_orbit_step_semantic_digests"],
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _propagator_from_dict(payload: Mapping[str, object]) -> PropagatorTemplateV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "state_template_id",
+            "applies_propagator",
+            "evaluator_resolver_key",
+            "numerator_expression_digest",
+            "denominator_expression_digest",
+            "mass_parameter_id",
+            "width_parameter_id",
+            "gauge",
+            "linearity_proof_template_id",
+        }
+    )
+    value = _record_payload("propagator template", payload, fields, "propagator")
+    return PropagatorTemplateV1(
+        template_id=_require_nonempty("propagator template_id", value["template_id"]),
+        state_template_id=_require_nonempty(
+            "propagator state", value["state_template_id"]
+        ),
+        applies_propagator=value["applies_propagator"],  # type: ignore[arg-type]
+        evaluator_resolver_key=_decode_optional_string(
+            "propagator evaluator", value["evaluator_resolver_key"]
+        ),
+        numerator_expression_digest=_require_optional_sha256(
+            "propagator numerator", value["numerator_expression_digest"]
+        ),
+        denominator_expression_digest=_require_optional_sha256(
+            "propagator denominator", value["denominator_expression_digest"]
+        ),
+        mass_parameter_id=_decode_optional_string(
+            "propagator mass", value["mass_parameter_id"]
+        ),
+        width_parameter_id=_decode_optional_string(
+            "propagator width", value["width_parameter_id"]
+        ),
+        gauge=_decode_optional_string("propagator gauge", value["gauge"]),
+        linearity_proof_template_id=_decode_optional_string(
+            "propagator linearity proof", value["linearity_proof_template_id"]
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _closure_from_dict(payload: Mapping[str, object]) -> ClosureTemplateV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "input_state_template_ids",
+            "result_state_template_id",
+            "evaluator_resolver_key",
+            "canonical_input_order",
+            "coupling_parameter_ids",
+            "coupling_orders",
+            "eligible_quantum_flow_template_ids",
+            "color_contraction_template_id",
+            "binding_coupling",
+            "component_coefficients",
+            "chirality_relation",
+            "equivalence_class",
+            "exact_factor",
+            "input_exchange_factor",
+            "metric_signature",
+            "output_factor_source",
+            "projection",
+        }
+    )
+    value = _record_payload("closure template", payload, fields, "closure")
+    return ClosureTemplateV1(
+        template_id=_require_nonempty("closure template_id", value["template_id"]),
+        input_state_template_ids=_decode_string_tuple(
+            "closure input states", value["input_state_template_ids"]
+        ),
+        result_state_template_id=_decode_optional_string(
+            "closure result state", value["result_state_template_id"]
+        ),
+        evaluator_resolver_key=_require_nonempty(
+            "closure evaluator", value["evaluator_resolver_key"]
+        ),
+        canonical_input_order=_decode_int_tuple(
+            "closure input order", value["canonical_input_order"]
+        ),
+        coupling_parameter_ids=_decode_string_tuple(
+            "closure coupling parameters", value["coupling_parameter_ids"]
+        ),
+        coupling_orders=_decode_coupling_orders(
+            "closure coupling orders", value["coupling_orders"]
+        ),
+        eligible_quantum_flow_template_ids=_decode_string_tuple(
+            "closure eligible quantum flows",
+            value["eligible_quantum_flow_template_ids"],
+        ),
+        color_contraction_template_id=_require_nonempty(
+            "closure color", value["color_contraction_template_id"]
+        ),
+        binding_coupling=_decode_ratio(
+            "closure binding coupling", value["binding_coupling"]
+        ),
+        exact_factor=_decode_ratio("closure exact factor", value["exact_factor"]),
+        output_factor_source=_require_nonempty(
+            "closure output factor source", value["output_factor_source"]
+        ),  # type: ignore[arg-type]
+        equivalence_class=_require_nonempty(
+            "closure equivalence class", value["equivalence_class"]
+        ),
+        input_exchange_factor=_decode_optional_ratio(
+            "closure input-exchange factor", value["input_exchange_factor"]
+        ),
+        component_coefficients=_decode_ratio_array(
+            "closure component coefficients", value["component_coefficients"]
+        ),
+        chirality_relation=_require_nonempty(
+            "closure chirality relation", value["chirality_relation"]
+        ),
+        metric_signature=_decode_optional_string(
+            "closure metric signature", value["metric_signature"]
+        ),
+        projection=_require_nonempty("closure projection", value["projection"]),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _color_from_dict(payload: Mapping[str, object]) -> ColorContractionTemplateV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "rule_kind",
+            "input_representations",
+            "output_representation",
+            "ordered_open_string_arity",
+            "exact_coefficient",
+            "nc_polynomial",
+            "expression_digest",
+            "transition_witnesses",
+        }
+    )
+    value = _record_payload(
+        "color-contraction template", payload, fields, "color-contraction"
+    )
+    raw_polynomial = value["nc_polynomial"]
+    if not isinstance(raw_polynomial, list):
+        raise RecurrenceTemplateError("color Nc polynomial must be an array")
+    polynomial: list[tuple[int, ExactComplexRationalV1]] = []
+    for term in raw_polynomial:
+        if not isinstance(term, list) or len(term) != 2:
+            raise RecurrenceTemplateError(
+                "color Nc polynomial entries must be [power, coefficient]"
+            )
+        polynomial.append(
+            (
+                _require_int("color Nc power", term[0]),
+                _decode_ratio("color Nc coefficient", term[1]),
+            )
+        )
+    output_representation = value["output_representation"]
+    raw_witnesses = value["transition_witnesses"]
+    if not isinstance(raw_witnesses, list):
+        raise RecurrenceTemplateError("LC color transition witnesses must be an array")
+    return ColorContractionTemplateV1(
+        template_id=_require_nonempty("color template_id", value["template_id"]),
+        rule_kind=_require_nonempty("color rule kind", value["rule_kind"]),
+        input_representations=_decode_int_tuple(
+            "color input representations", value["input_representations"]
+        ),
+        output_representation=(
+            None
+            if output_representation is None
+            else _require_int("color output representation", output_representation)
+        ),
+        ordered_open_string_arity=_require_int(
+            "color open string arity", value["ordered_open_string_arity"]
+        ),
+        exact_coefficient=_decode_ratio(
+            "color coefficient", value["exact_coefficient"]
+        ),
+        nc_polynomial=tuple(polynomial),
+        expression_digest=_require_sha256(
+            "color expression digest", value["expression_digest"]
+        ),
+        transition_witnesses=tuple(
+            _lc_color_witness_from_dict(witness) for witness in raw_witnesses
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _lc_color_witness_from_dict(payload: object) -> LCColorTransitionWitnessV1:
+    value = _require_mapping("LC color transition witness", payload)
+    legacy_fields = frozenset(
+        {
+            "component_operation",
+            "exact_factor",
+            "input_permutation",
+            "input_shape_kinds",
+            "proof_digest",
+            "provenance",
+            "result_component_kind",
+            "result_component_role",
+            "result_shape_kind",
+            "reverse_parent_mask",
+        }
+    )
+    optional_port_fields = frozenset({"input_port_pairings", "result_port_bindings"})
+    actual_fields = frozenset(value)
+    unknown = actual_fields - legacy_fields - optional_port_fields
+    missing = legacy_fields - actual_fields
+    if unknown or missing:
+        details: list[str] = []
+        if unknown:
+            details.append("unknown=" + ",".join(sorted(unknown)))
+        if missing:
+            details.append("missing=" + ",".join(sorted(missing)))
+        raise RecurrenceTemplateError(
+            "LC color transition witness has noncanonical fields "
+            f"({'; '.join(details)})"
+        )
+    input_shapes = _decode_string_tuple(
+        "LC color witness input shapes", value["input_shape_kinds"]
+    )
+    if len(input_shapes) != 2:
+        raise RecurrenceTemplateError("LC color witness requires two input shapes")
+    return LCColorTransitionWitnessV1(
+        input_shape_kinds=(input_shapes[0], input_shapes[1]),  # type: ignore[arg-type]
+        input_permutation=_decode_int_tuple(
+            "LC color witness input permutation", value["input_permutation"]
+        ),  # type: ignore[arg-type]
+        reverse_parent_mask=_require_int(
+            "LC color witness reverse-parent mask", value["reverse_parent_mask"]
+        ),
+        component_operation=_require_nonempty(
+            "LC color witness operation", value["component_operation"]
+        ),  # type: ignore[arg-type]
+        result_component_kind=_decode_optional_string(
+            "LC color witness result component", value["result_component_kind"]
+        ),  # type: ignore[arg-type]
+        result_component_role=_require_nonempty(
+            "LC color witness result component role",
+            value["result_component_role"],
+        ),  # type: ignore[arg-type]
+        result_shape_kind=_decode_optional_string(
+            "LC color witness result shape", value["result_shape_kind"]
+        ),  # type: ignore[arg-type]
+        exact_factor=_decode_ratio("LC color witness factor", value["exact_factor"]),
+        proof_digest=_require_sha256(
+            "LC color witness proof digest", value["proof_digest"]
+        ),
+        provenance=_decode_string_pairs(
+            "LC color witness provenance",
+            value["provenance"],
+        ),
+        input_port_pairings=_decode_lc_color_port_pairings(
+            value.get("input_port_pairings", [])
+        ),
+        result_port_bindings=_decode_lc_color_port_references(
+            value.get("result_port_bindings", [])
+        ),
+    )
+
+
+def _validate_lc_color_port_reference(value: object) -> None:
+    if (
+        not isinstance(value, tuple)
+        or len(value) != 2
+        or any(isinstance(item, bool) or not isinstance(item, int) for item in value)
+    ):
+        raise RecurrenceTemplateError(
+            "LC color port references must be two-element integer tuples"
+        )
+    parent_index, local_port_index = value
+    if parent_index not in (0, 1) or local_port_index < 0:
+        raise RecurrenceTemplateError(
+            "LC color port reference is outside the two-parent nonnegative domain"
+        )
+
+
+def _decode_lc_color_port_references(value: object) -> tuple[tuple[int, int], ...]:
+    if not isinstance(value, list):
+        raise RecurrenceTemplateError("LC color port references must be a JSON array")
+    sequence = value
+    result: list[tuple[int, int]] = []
+    for item in sequence:
+        port = _decode_int_tuple("LC color port reference", item)
+        if len(port) != 2:
+            raise RecurrenceTemplateError(
+                "LC color port reference must contain two integers"
+            )
+        result.append((port[0], port[1]))
+    return tuple(result)
+
+
+def _decode_lc_color_port_pairings(
+    value: object,
+) -> tuple[tuple[tuple[int, int], tuple[int, int]], ...]:
+    if not isinstance(value, list):
+        raise RecurrenceTemplateError("LC color port pairings must be a JSON array")
+    sequence = value
+    result: list[tuple[tuple[int, int], tuple[int, int]]] = []
+    for item in sequence:
+        if not isinstance(item, list):
+            raise RecurrenceTemplateError("LC color port pairing must be a JSON array")
+        pair = item
+        if len(pair) != 2:
+            raise RecurrenceTemplateError(
+                "LC color port pairing must contain two port references"
+            )
+        ports = _decode_lc_color_port_references(pair)
+        result.append((ports[0], ports[1]))
+    return tuple(result)
+
+
+def _symmetry_from_dict(payload: Mapping[str, object]) -> SymmetryProofV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "proof_algorithm",
+            "subject_template_ids",
+            "input_permutation",
+            "exact_phase",
+            "expression_digests",
+            "witness_digest",
+        }
+    )
+    value = _record_payload(
+        "symmetry-proof template", payload, fields, "symmetry-proof"
+    )
+    return SymmetryProofV1(
+        template_id=_require_nonempty("proof template_id", value["template_id"]),
+        proof_algorithm=_require_nonempty("proof algorithm", value["proof_algorithm"]),
+        subject_template_ids=_decode_string_tuple(
+            "proof subjects", value["subject_template_ids"]
+        ),
+        input_permutation=_decode_int_tuple(
+            "proof permutation", value["input_permutation"]
+        ),
+        exact_phase=_decode_ratio("proof phase", value["exact_phase"]),
+        expression_digests=_decode_string_tuple(
+            "proof expression digests", value["expression_digests"]
+        ),
+        witness_digest=_require_sha256("proof witness digest", value["witness_digest"]),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _runtime_helicity_contract_from_dict(
+    payload: Mapping[str, object],
+) -> RecurrenceRuntimeHelicityContractV1:
+    fields = frozenset(
+        {
+            "template_id",
+            "full_state_template_id",
+            "variants",
+            "proof_algorithm",
+            "proof_digest",
+        }
+    )
+    value = _record_payload(
+        "runtime-helicity contract", payload, fields, "runtime-helicity-contract"
+    )
+    raw_variants = value["variants"]
+    if not isinstance(raw_variants, list):
+        raise RecurrenceTemplateError("runtime-helicity variants must be an array")
+    variants: list[RecurrenceRuntimeHelicityVariantV1] = []
+    variant_fields = frozenset(
+        {
+            "source_template_id",
+            "source_state_template_id",
+            "embedding_source_components",
+            "embedding_factors",
+            "projection_full_components",
+            "proof_digest",
+        }
+    )
+    for index, raw_variant in enumerate(raw_variants):
+        variant = _require_mapping(f"runtime-helicity variant {index}", raw_variant)
+        _require_exact_keys(
+            f"runtime-helicity variant {index}", variant, variant_fields
+        )
+        raw_embedding = variant["embedding_source_components"]
+        if not isinstance(raw_embedding, list) or any(
+            item is not None and type(item) is not int for item in raw_embedding
+        ):
+            raise RecurrenceTemplateError(
+                "runtime-helicity component embedding must contain integers or null"
+            )
+        variants.append(
+            RecurrenceRuntimeHelicityVariantV1(
+                source_template_id=_require_nonempty(
+                    "runtime-helicity source template ID",
+                    variant["source_template_id"],
+                ),
+                source_state_template_id=_require_nonempty(
+                    "runtime-helicity source-state template ID",
+                    variant["source_state_template_id"],
+                ),
+                embedding_source_components=tuple(raw_embedding),
+                embedding_factors=_decode_ratio_array(
+                    "runtime-helicity embedding factors",
+                    variant["embedding_factors"],
+                ),
+                projection_full_components=_decode_int_tuple(
+                    "runtime-helicity projection",
+                    variant["projection_full_components"],
+                ),
+                proof_digest=_require_sha256(
+                    "runtime-helicity variant proof digest",
+                    variant["proof_digest"],
+                ),
+            )
+        )
+    return RecurrenceRuntimeHelicityContractV1(
+        template_id=_require_nonempty(
+            "runtime-helicity template ID", value["template_id"]
+        ),
+        full_state_template_id=_require_nonempty(
+            "runtime-helicity full-state template ID",
+            value["full_state_template_id"],
+        ),
+        variants=tuple(variants),
+        proof_algorithm=_require_nonempty(
+            "runtime-helicity proof algorithm", value["proof_algorithm"]
+        ),
+        proof_digest=_require_sha256(
+            "runtime-helicity proof digest", value["proof_digest"]
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+def _evaluator_from_dict(payload: Mapping[str, object]) -> EvaluatorBindingV1:
+    fields = frozenset(
+        {
+            "resolver_key",
+            "callable_kind",
+            "prepared_kernel_id",
+            "runtime_template",
+            "contract_kind",
+            "callable_signature",
+            "input_state_template_ids",
+            "output_state_template_id",
+            "input_layout",
+            "output_layout",
+            "exact_expression_digests",
+            "semantic_template_ids",
+        }
+    )
+    value = _record_payload(
+        "evaluator-binding template", payload, fields, "evaluator-binding"
+    )
+    return EvaluatorBindingV1(
+        resolver_key=_require_nonempty("evaluator resolver_key", value["resolver_key"]),
+        callable_kind=_require_nonempty(
+            "evaluator callable_kind", value["callable_kind"]
+        ),  # type: ignore[arg-type]
+        prepared_kernel_id=(
+            None
+            if value["prepared_kernel_id"] is None
+            else _require_int("prepared_kernel_id", value["prepared_kernel_id"])
+        ),
+        runtime_template=_decode_optional_string(
+            "evaluator runtime_template", value["runtime_template"]
+        ),
+        contract_kind=value["contract_kind"],  # type: ignore[arg-type]
+        callable_signature=_require_sha256(
+            "callable_signature", value["callable_signature"]
+        ),
+        input_state_template_ids=_decode_string_tuple(
+            "evaluator input states", value["input_state_template_ids"]
+        ),
+        output_state_template_id=_decode_optional_string(
+            "evaluator output state", value["output_state_template_id"]
+        ),
+        input_layout=_decode_string_tuple(
+            "evaluator input layout", value["input_layout"]
+        ),
+        output_layout=_decode_string_tuple(
+            "evaluator output layout", value["output_layout"]
+        ),
+        exact_expression_digests=_decode_string_tuple(
+            "evaluator expressions", value["exact_expression_digests"]
+        ),
+        semantic_template_ids=_decode_string_tuple(
+            "evaluator semantic templates", value["semantic_template_ids"]
+        ),
+        semantic_digest=value["semantic_digest"],  # type: ignore[arg-type]
+    )
+
+
+# Short aliases match the names used by the design document while retaining the
+# explicit version in persisted-contract code.
+CatalogHeader = RecurrenceTemplateCatalogHeaderV1
+ParameterTemplate = ParameterTemplateV1
+CurrentStateTemplate = CurrentStateTemplateV1
+SourceTemplate = SourceTemplateV1
+QuantumFlowTemplate = QuantumFlowTemplateV1
+TransitionTemplate = TransitionTemplateV1
+PropagatorTemplate = PropagatorTemplateV1
+ClosureTemplate = ClosureTemplateV1
+ColorContractionTemplate = ColorContractionTemplateV1
+SymmetryProof = SymmetryProofV1
+RecurrenceRuntimeHelicityContract = RecurrenceRuntimeHelicityContractV1
+EvaluatorBinding = EvaluatorBindingV1
+RecurrenceTemplateCatalogV1 = RecurrenceTemplateCatalog
+
+__all__ = [
+    "RECURRENCE_TEMPLATE_ABI",
+    "RECURRENCE_TEMPLATE_CANONICALIZATION_ABI",
+    "RECURRENCE_TEMPLATE_EXACT_SCALAR_ABI",
+    "SUPPORTED_SYMMETRY_PROOF_ALGORITHMS",
+    "CatalogHeader",
+    "ClosureTemplate",
+    "ClosureTemplateV1",
+    "ColorContractionTemplate",
+    "ColorContractionTemplateV1",
+    "CurrentStateTemplate",
+    "CurrentStateTemplateV1",
+    "EvaluatorBinding",
+    "EvaluatorBindingV1",
+    "EvaluatorCallableKind",
+    "ExactComplexRationalV1",
+    "FlavourFlowOperationV1",
+    "LCColorComponentKindV1",
+    "LCColorComponentOperationV1",
+    "LCColorComponentRoleV1",
+    "LCColorShapeKindV1",
+    "LCColorSourceSeedOperationV1",
+    "LCColorSourceSeedV1",
+    "LCColorTransitionWitnessV1",
+    "ParameterTemplate",
+    "ParameterTemplateV1",
+    "PropagatorTemplate",
+    "PropagatorTemplateV1",
+    "QuantumFlowTemplate",
+    "QuantumFlowTemplateV1",
+    "QuantumNumberFlowOperationV1",
+    "RecurrenceRuntimeHelicityContract",
+    "RecurrenceRuntimeHelicityContractV1",
+    "RecurrenceRuntimeHelicityVariantV1",
+    "RecurrenceTemplateCatalog",
+    "RecurrenceTemplateCatalogHeaderV1",
+    "RecurrenceTemplateCatalogV1",
+    "RecurrenceTemplateError",
+    "SourceTemplate",
+    "SourceTemplateV1",
+    "SymmetryProof",
+    "SymmetryProofV1",
+    "TransitionTemplate",
+    "TransitionTemplateV1",
+]
diff --git a/pyamplicol/src/pyamplicol/models/tensors.py b/pyamplicol/src/pyamplicol/models/tensors.py
new file mode 100644
index 0000000000..05bd1d7a97
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/models/tensors.py
@@ -0,0 +1,789 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from functools import cache
+from itertools import product
+from threading import RLock
+from typing import Any
+
+from .._internal.physics.symbols import ModelSymbolRegistry, symbols
+from .contracts import validate_color_representation
+
+E: Any = None
+Expression: Any = None
+Representation: Any = None
+TensorLibrary: Any = None
+TensorName: Any = None
+TensorNetwork: Any = None
+TensorExpression: Any = None
+as_tensor: Any = None
+_INDEX_PATTERN: Any = None
+_DUMMY_PATTERN: Any = None
+_WILDCARDS: dict[str, Any] = {}
+_SYMBOLICA_READY = False
+_SYMBOLICA_LOCK = RLock()
+
+
+def _ensure_symbolica() -> None:
+    global E, Expression, Representation, TensorLibrary, TensorName
+    global TensorNetwork, TensorExpression, as_tensor
+    global _INDEX_PATTERN, _DUMMY_PATTERN, _WILDCARDS, _SYMBOLICA_READY
+
+    if _SYMBOLICA_READY:
+        return
+    with _SYMBOLICA_LOCK:
+        if _SYMBOLICA_READY:
+            return
+        from symbolica import E as expression_parser
+        from symbolica import Expression as expression_type
+        from symbolica.community.tensor import Representation as representation_type
+        from symbolica.community.tensor import (
+            TensorExpression as tensor_expression_type,
+        )
+        from symbolica.community.tensor import TensorLibrary as tensor_library_type
+        from symbolica.community.tensor import TensorName as tensor_name_type
+        from symbolica.community.tensor import TensorNetwork as tensor_network_type
+        from symbolica.community.tensor import as_tensor as tensor_converter
+
+        E = expression_parser
+        Expression = expression_type
+        Representation = representation_type
+        TensorLibrary = tensor_library_type
+        TensorName = tensor_name_type
+        TensorNetwork = tensor_network_type
+        TensorExpression = tensor_expression_type
+        as_tensor = tensor_converter
+        _INDEX_PATTERN = E("UFO::idx(component_,leg_)")
+        _DUMMY_PATTERN = E("UFO::dummy(label_)")
+        _WILDCARDS = {name: E(name) for name in ("a_", "b_", "c_", "d_")}
+        _SYMBOLICA_READY = True
+
+
+@dataclass(frozen=True)
+class NormalizedTensorExpression:
+    source: str
+    expression: str
+    tensor_heads: tuple[str, ...]
+
+
+def normalize_lorentz_expression(
+    source: str,
+    spins: Sequence[int],
+    *,
+    model_symbols: ModelSymbolRegistry | None = None,
+    vertex: bool = True,
+) -> NormalizedTensorExpression:
+    """Convert one wrapped UFO Lorentz expression into typed spenso form.
+
+    ``vertex`` selects the vertex spinor order; propagators keep their own.
+    """
+
+    _ensure_symbolica()
+    context = _LorentzContext(
+        tuple(int(spin) for spin in spins),
+        model_symbols=model_symbols,
+        vertex=vertex,
+    )
+    expression = E(source)
+    expression = _replace(expression, "UFO::PSlash(a_,b_)", context.p_slash)
+    expression = _replace(expression, "UFO::Gamma(a_,b_,c_)", context.gamma)
+    expression = _replace(expression, "UFO::Gamma5(a_,b_)", context.gamma5)
+    expression = _replace(expression, "UFO::ProjM(a_,b_)", context.projector_minus)
+    expression = _replace(expression, "UFO::ProjP(a_,b_)", context.projector_plus)
+    expression = _replace(expression, "UFO::Sigma(a_,b_,c_,d_)", context.sigma)
+    expression = _replace(expression, "UFO::Identity(a_,b_)", context.identity)
+    expression = _replace(expression, "UFO::Metric(a_,b_)", context.metric)
+    expression = _replace(expression, "UFO::P(a_,b_)", context.momentum)
+    expression = _replace(expression, "UFO::P(a_)^2", context.momentum_square)
+    expression = _replace(expression, "UFO::P(a_)", context.propagator_momentum)
+    _reject_residual_ufo_tensors(expression, context="Lorentz expression")
+    _reject_indeterminate(expression, context="Lorentz expression")
+    expression = as_tensor(expression).simplify_algebra(color=False).to_expression()
+    return NormalizedTensorExpression(
+        source=source,
+        expression=expression.format_plain(),
+        tensor_heads=tuple(sorted(_tensor_heads(expression))),
+    )
+
+
+def normalize_color_expression(
+    source: str,
+    color_representations: Sequence[int],
+) -> NormalizedTensorExpression:
+    """Convert one UFO color expression into typed spenso SU(3) tensors."""
+
+    representations = tuple(int(color) for color in color_representations)
+    _validate_color_representations(representations)
+    _ensure_symbolica()
+    context = _ColorContext(representations)
+    expression = E(source)
+    expression = _replace(expression, "UFO::Identity(a_,b_)", context.identity)
+    expression = _replace(expression, "UFO::T(a_,b_,c_)", context.generator)
+    expression = _replace(expression, "UFO::f(a_,b_,c_)", context.structure_constant)
+    expression = _replace(expression, "UFO::d(a_,b_,c_)", context.symmetric_invariant)
+    _reject_residual_ufo_tensors(expression, context="color expression")
+    _reject_indeterminate(expression, context="color expression")
+    simplified = (
+        as_tensor(expression)
+        .simplify_algebra(
+            gamma=False,
+            contract="none",
+            color_substitute_cof_dimension_invariants=True,
+        )
+        .to_expression()
+    )
+    # Keep d^{abc} as its explicit generator trace for component projection,
+    # rather than introducing a separate symbolic invariant tensor.
+    expression = expression if context.expanded_symmetric_invariant else simplified
+    return NormalizedTensorExpression(
+        source=source,
+        expression=expression.format_plain(),
+        tensor_heads=tuple(sorted(_tensor_heads(expression))),
+    )
+
+
+def normalize_vertex_tensor_term(
+    *,
+    lorentz: str,
+    color: str,
+    spins: Sequence[int],
+    color_representations: Sequence[int],
+    model_symbols: ModelSymbolRegistry | None = None,
+) -> tuple[NormalizedTensorExpression, NormalizedTensorExpression]:
+    return (
+        normalize_lorentz_expression(
+            lorentz,
+            spins,
+            model_symbols=model_symbols,
+        ),
+        normalize_color_expression(color, color_representations),
+    )
+
+
+class _LorentzContext:
+    def __init__(
+        self,
+        spins: tuple[int, ...],
+        *,
+        model_symbols: ModelSymbolRegistry | None = None,
+        vertex: bool = True,
+    ) -> None:
+        _ensure_symbolica()
+        self.spins = spins
+        self.model_symbols = model_symbols
+        self.minkowski = Representation.mink(4)
+        self.bispinor = Representation.bis(4)
+        self.gamma_tensor = TensorExpression.dirac_gamma(4)
+        self.gamma5_tensor = TensorExpression.gamma5(4)
+        self.projm_tensor = TensorExpression.projm(4)
+        self.projp_tensor = TensorExpression.projp(4)
+        self._fresh_index = 0
+        # Standard UFO vertices index a fermion pair in the opposite order to
+        # the internal spinor slots, e.g. Gamma(3,2,1) for the SM FFV1.
+        dirac_legs = (
+            [leg for leg, spin in enumerate(spins, 1) if spin == 2] if vertex else []
+        )
+        self._spinor_partner = {
+            leg: partner
+            for first, second in zip(dirac_legs[::2], dirac_legs[1::2], strict=False)
+            for leg, partner in ((first, second), (second, first))
+        }
+
+    def metric(self, match: Mapping[Expression, Expression]) -> Expression:
+        left = self._minkowski_slot(match[_WILDCARDS["a_"]])
+        right = self._minkowski_slot(match[_WILDCARDS["b_"]])
+        return TensorExpression.g(self.minkowski)(left, right).to_expression()
+
+    def gamma(self, match: Mapping[Expression, Expression]) -> Expression:
+        lorentz = self._minkowski_label(match[_WILDCARDS["a_"]])
+        output = self._bispinor_label(match[_WILDCARDS["b_"]])
+        input_ = self._bispinor_label(match[_WILDCARDS["c_"]])
+        return _as_expression(self.gamma_tensor(input_, output, lorentz))
+
+    def gamma5(self, match: Mapping[Expression, Expression]) -> Expression:
+        output = self._bispinor_label(match[_WILDCARDS["a_"]])
+        input_ = self._bispinor_label(match[_WILDCARDS["b_"]])
+        return _as_expression(self.gamma5_tensor(input_, output))
+
+    def projector_minus(
+        self,
+        match: Mapping[Expression, Expression],
+    ) -> Expression:
+        output = self._bispinor_label(match[_WILDCARDS["a_"]])
+        input_ = self._bispinor_label(match[_WILDCARDS["b_"]])
+        return _as_expression(self.projp_tensor(input_, output))
+
+    def projector_plus(
+        self,
+        match: Mapping[Expression, Expression],
+    ) -> Expression:
+        output = self._bispinor_label(match[_WILDCARDS["a_"]])
+        input_ = self._bispinor_label(match[_WILDCARDS["b_"]])
+        return _as_expression(self.projm_tensor(input_, output))
+
+    def identity(self, match: Mapping[Expression, Expression]) -> Expression:
+        left = self.bispinor(self._bispinor_label(match[_WILDCARDS["a_"]]))
+        right = self.bispinor(self._bispinor_label(match[_WILDCARDS["b_"]]))
+        return TensorExpression.g(self.bispinor)(left, right).to_expression()
+
+    def sigma(self, match: Mapping[Expression, Expression]) -> Expression:
+        mu = self._minkowski_label(match[_WILDCARDS["a_"]])
+        nu = self._minkowski_label(match[_WILDCARDS["b_"]])
+        output = self._bispinor_label(match[_WILDCARDS["c_"]])
+        input_ = self._bispinor_label(match[_WILDCARDS["d_"]])
+        dummy = self._fresh_label("sigma")
+        first = _as_expression(self.gamma_tensor(input_, dummy, mu))
+        second = _as_expression(self.gamma_tensor(dummy, output, nu))
+        reverse_first = _as_expression(self.gamma_tensor(input_, dummy, nu))
+        reverse_second = _as_expression(self.gamma_tensor(dummy, output, mu))
+        return E("1𝑖/2") * (  # noqa: RUF001
+            first * second - reverse_first * reverse_second
+        )
+
+    def momentum(self, match: Mapping[Expression, Expression]) -> Expression:
+        lorentz_index = match[_WILDCARDS["a_"]]
+        momentum_index = match[_WILDCARDS["b_"]]
+        _component, leg = _ufo_index(momentum_index)
+        return self._momentum_tensor(leg, self._minkowski_slot(lorentz_index))
+
+    def momentum_square(
+        self,
+        match: Mapping[Expression, Expression],
+    ) -> Expression:
+        index = match[_WILDCARDS["a_"]]
+        _component, leg = _ufo_index(index)
+        left = self.minkowski(self._fresh_label("momentum_square"))
+        right = self.minkowski(self._fresh_label("momentum_square"))
+        return (
+            TensorExpression.g(self.minkowski)(left, right).to_expression()
+            * self._momentum_tensor(leg, left)
+            * self._momentum_tensor(leg, right)
+        )
+
+    def propagator_momentum(
+        self,
+        match: Mapping[Expression, Expression],
+    ) -> Expression:
+        index = match[_WILDCARDS["a_"]]
+        _component, leg = _ufo_index(index)
+        return self._momentum_tensor(leg, self._minkowski_slot(index))
+
+    def p_slash(self, match: Mapping[Expression, Expression]) -> Expression:
+        output = self._bispinor_label(match[_WILDCARDS["a_"]])
+        input_ = self._bispinor_label(match[_WILDCARDS["b_"]])
+        lorentz_label = self._fresh_label("pslash")
+        lorentz = self.minkowski(lorentz_label)
+        return _as_expression(
+            self.gamma_tensor(input_, output, lorentz_label)
+        ) * self._momentum_tensor(
+            1,
+            lorentz,
+        )
+
+    def _minkowski_slot(self, index: Expression):
+        return self.minkowski(self._minkowski_label(index))
+
+    def _minkowski_label(self, index: Expression) -> str:
+        return _ufo_lorentz_label(index)
+
+    def _bispinor_label(self, index: Expression) -> str:
+        dummy = _ufo_dummy(index)
+        if dummy is not None:
+            return f"ufo_s_dummy_{dummy}"
+        component, leg = _ufo_index(index)
+        if leg < 1 or leg > len(self.spins):
+            raise ValueError(f"UFO spin index refers to absent leg {leg}")
+        if self.spins[leg - 1] != 2:
+            raise ValueError(
+                f"UFO spin index ({component}, {leg}) refers to spin "
+                f"{self.spins[leg - 1]}, not a Dirac fermion"
+            )
+        if component != 1:
+            raise ValueError(f"Dirac particle leg {leg} has no spin index {component}")
+        return f"ufo_s_{component}_{self._spinor_partner.get(leg, leg)}"
+
+    def _momentum_tensor(self, leg: int, slot) -> Expression:
+        if leg < 1 or leg > len(self.spins):
+            raise ValueError(f"UFO momentum refers to absent leg {leg}")
+        name = (
+            symbols.ufo_momentum_tensor_name(leg)
+            if self.model_symbols is None
+            else self.model_symbols.ufo_momentum_tensor_name(leg)
+        )
+        return TensorName(name)(slot).to_expression()
+
+    def _fresh_label(self, prefix: str) -> str:
+        label = f"ufo_{prefix}_internal_{self._fresh_index}"
+        self._fresh_index += 1
+        return label
+
+
+class _ColorContext:
+    def __init__(self, color_representations: tuple[int, ...]) -> None:
+        _validate_color_representations(color_representations)
+        _ensure_symbolica()
+        self.color_representations = color_representations
+        self.fundamental = Representation.cof(3)
+        self.adjoint = Representation.coad(8)
+        self.generator_tensor = TensorExpression.color_t(8, 3)
+        self.f_tensor = TensorExpression.color_f(8)
+        self.expanded_symmetric_invariant = False
+        self._dummy_index = 0
+
+    def identity(self, match: Mapping[Expression, Expression]) -> Expression:
+        left = self._leg_slot(match[_WILDCARDS["a_"]])
+        right = self._leg_slot(match[_WILDCARDS["b_"]])
+        left_leg = int(match[_WILDCARDS["a_"]])
+        right_leg = int(match[_WILDCARDS["b_"]])
+        left_representation = self.color_representations[left_leg - 1]
+        right_representation = self.color_representations[right_leg - 1]
+        if left_representation == right_representation:
+            # Oriented current kernels can have equal input/output colour roles.
+            representation = {
+                8: self.adjoint,
+                3: self.fundamental,
+                -3: self.fundamental.dual(),
+            }[left_representation]
+            return TensorExpression.g(representation)(left, right).to_expression()
+        if left_representation != -right_representation:
+            raise ValueError("UFO color identity requires dual representations")
+        representation = (
+            self.fundamental if right_representation == 3 else self.fundamental.dual()
+        )
+        return representation.id(
+            f"ufo_c_{left_leg}", f"ufo_c_{right_leg}"
+        ).to_expression()
+
+    def generator(self, match: Mapping[Expression, Expression]) -> Expression:
+        adjoint = self._slot(match[_WILDCARDS["a_"]], expected="adjoint")
+        fundamental = self._slot(
+            match[_WILDCARDS["b_"]],
+            expected="fundamental",
+        )
+        antifundamental = self._slot(
+            match[_WILDCARDS["c_"]],
+            expected="antifundamental",
+        )
+        return self.generator_tensor(
+            adjoint,
+            fundamental,
+            antifundamental,
+        ).to_expression()
+
+    def structure_constant(
+        self,
+        match: Mapping[Expression, Expression],
+    ) -> Expression:
+        slots = [
+            self._slot(match[_WILDCARDS[name]], expected="adjoint")
+            for name in ("a_", "b_", "c_")
+        ]
+        return self.f_tensor(*slots).to_expression()
+
+    def symmetric_invariant(
+        self,
+        match: Mapping[Expression, Expression],
+    ) -> Expression:
+        self.expanded_symmetric_invariant = True
+        adjoint = [
+            self._slot(match[_WILDCARDS[name]], expected="adjoint")
+            for name in ("a_", "b_", "c_")
+        ]
+        suffix = self._dummy_index
+        self._dummy_index += 1
+        fundamental = [
+            self.fundamental(f"ufo_c_d_{suffix}_{name}") for name in ("i", "j", "k")
+        ]
+        antifundamental = [
+            self.fundamental.dual()(f"ufo_c_d_{suffix}_{name}")
+            for name in ("i", "j", "k")
+        ]
+
+        def generator(a: Any, row: int, column: int) -> Expression:
+            return self.generator_tensor(
+                a,
+                fundamental[row],
+                antifundamental[column],
+            ).to_expression()
+
+        first = (
+            generator(adjoint[0], 0, 1)
+            * generator(adjoint[1], 1, 2)
+            * generator(adjoint[2], 2, 0)
+        )
+        second = (
+            generator(adjoint[1], 0, 1)
+            * generator(adjoint[0], 1, 2)
+            * generator(adjoint[2], 2, 0)
+        )
+        return 2 * (first + second)
+
+    def _leg_slot(self, index: Expression):
+        label = int(index)
+        if label < 1 or label > len(self.color_representations):
+            raise ValueError(f"UFO color index refers to absent leg {label}")
+        representation = self.color_representations[label - 1]
+        if representation == 3:
+            return self.fundamental(f"ufo_c_{label}")
+        if representation == -3:
+            return self.fundamental.dual()(f"ufo_c_{label}")
+        if representation == 8:
+            return self.adjoint(f"ufo_c_{label}")
+        raise ValueError(
+            f"UFO color index {label} refers to color representation {representation}"
+        )
+
+    def _slot(self, index: Expression, *, expected: str):
+        label = int(index)
+        if label > 0:
+            slot = self._leg_slot(index)
+            actual = self._slot_kind(label)
+            if actual != expected:
+                raise ValueError(
+                    f"UFO color index {label} has type {actual}, expected {expected}"
+                )
+            return slot
+        name = f"ufo_c_dummy_{abs(label)}_{expected}"
+        if expected == "adjoint":
+            return self.adjoint(name)
+        if expected == "fundamental":
+            return self.fundamental(name)
+        if expected == "antifundamental":
+            return self.fundamental.dual()(name)
+        raise ValueError(f"unknown color index type {expected}")
+
+    def _slot_kind(self, leg: int) -> str:
+        representation = self.color_representations[leg - 1]
+        kind = {
+            3: "fundamental",
+            -3: "antifundamental",
+            8: "adjoint",
+            1: "singlet",
+        }.get(representation)
+        if kind is None:
+            raise ValueError(
+                f"unsupported UFO color representation {representation} on leg {leg}"
+            )
+        return kind
+
+
+def _replace(
+    expression: Expression,
+    pattern: str,
+    callback: Callable[[Mapping[Expression, Expression]], Expression],
+) -> Expression:
+    errors: list[Exception] = []
+
+    def guarded(match: Mapping[Expression, Expression]) -> Expression:
+        try:
+            return callback(match)
+        except Exception as exc:  # Symbolica otherwise converts this to indeterminate.
+            errors.append(exc)
+            return E("indeterminate")
+
+    result = expression.replace(E(pattern), guarded, bottom_up=True)
+    if errors:
+        raise errors[0]
+    return result
+
+
+def _ufo_index(expression: Expression) -> tuple[int, int]:
+    match = next(
+        iter(expression.match(_INDEX_PATTERN, min_level=0, max_level=0, partial=False)),
+        None,
+    )
+    if match is None:
+        raise ValueError(f"expected wrapped UFO index, got {expression}")
+    values = dict(match)
+    return int(values[E("component_")]), int(values[E("leg_")])
+
+
+def _ufo_lorentz_label(expression: Expression) -> str:
+    index_match = next(
+        iter(expression.match(_INDEX_PATTERN, min_level=0, max_level=0, partial=False)),
+        None,
+    )
+    if index_match is not None:
+        values = dict(index_match)
+        return f"ufo_l_{int(values[E('component_')])}_{int(values[E('leg_')])}"
+    dummy = _ufo_dummy(expression)
+    if dummy is not None:
+        return f"ufo_l_dummy_{dummy}"
+    raise ValueError(f"expected wrapped UFO Lorentz index, got {expression}")
+
+
+def _ufo_dummy(expression: Expression) -> int | None:
+    dummy_match = next(
+        iter(expression.match(_DUMMY_PATTERN, min_level=0, max_level=0, partial=False)),
+        None,
+    )
+    if dummy_match is None:
+        return None
+    return int(dict(dummy_match)[E("label_")])
+
+
+def _reject_residual_ufo_tensors(expression: Expression, *, context: str) -> None:
+    residual = sorted(
+        set(
+            re.findall(
+                r"UFO::(?:\{[^}]*\}::)?([A-Za-z][A-Za-z0-9_]*)\(",
+                expression.to_canonical_string(),
+            )
+        )
+        - {"idx", "dummy"}
+    )
+    if residual:
+        raise ValueError(
+            f"{context} contains unsupported UFO tensors: {', '.join(residual)}"
+        )
+
+
+def _reject_indeterminate(expression: Expression, *, context: str) -> None:
+    if (
+        "¿" in str(expression)
+        or "indeterminate" in expression.to_canonical_string().lower()
+    ):
+        raise ValueError(f"{context} became indeterminate during tensor normalization")
+
+
+def _tensor_heads(expression: Expression) -> set[str]:
+    return set(
+        re.findall(
+            r"(?:(?:[A-Za-z0-9_]+|\{[^}]*\})::)*([A-Za-z][A-Za-z0-9_]*)\(",
+            expression.to_canonical_string(),
+        )
+    )
+
+
+def project_trilinear_color_expression(
+    expression: str,
+    color_representations: Sequence[int],
+    *,
+    allow_numeric_fallback: bool = False,
+) -> tuple[str, complex]:
+    """Project a local color tensor onto the supported SU(3) basis.
+
+    The default path accepts only exact Symbolica identities. Dense numerical
+    projection is available for diagnostics, but must not certify executable
+    model contracts.
+    """
+
+    representations = tuple(int(value) for value in color_representations)
+    _validate_color_representations(representations)
+    if len(representations) != 3:
+        return "generic-tensor", 1.0 + 0.0j
+    colored_legs = tuple(
+        index + 1
+        for index, representation in enumerate(representations)
+        if abs(representation) != 1
+    )
+    candidates: list[tuple[str, str]] = []
+    if not colored_legs:
+        candidates.append(("singlet", "1"))
+    elif len(colored_legs) == 2:
+        left, right = colored_legs
+        left_representation = representations[left - 1]
+        right_representation = representations[right - 1]
+        if (
+            left_representation == right_representation == 8
+            or left_representation == -right_representation
+        ):
+            candidates.append(("color-identity", f"UFO::Identity({left},{right})"))
+    elif sorted(representations) == [-3, 3, 8]:
+        adjoint = representations.index(8) + 1
+        fundamental = representations.index(3) + 1
+        antifundamental = representations.index(-3) + 1
+        candidates.append(
+            (
+                "fundamental-generator",
+                f"UFO::T({adjoint},{fundamental},{antifundamental})",
+            )
+        )
+    elif all(representation == 8 for representation in representations):
+        candidates.extend(
+            (
+                ("adjoint-structure-constant", "UFO::f(1,2,3)"),
+                ("adjoint-symmetric-invariant", "UFO::d(1,2,3)"),
+            )
+        )
+    if not candidates:
+        return "generic-tensor", 1.0 + 0.0j
+
+    try:
+        normalized_candidates: list[tuple[str, NormalizedTensorExpression]] = []
+        for structure, source in candidates:
+            normalized = normalize_color_expression(source, representations)
+            coefficient = _constant_expression_ratio(
+                E(expression),
+                E(normalized.expression),
+            )
+            if coefficient is not None:
+                return structure, coefficient
+            normalized_candidates.append((structure, normalized))
+        if not allow_numeric_fallback:
+            return "generic-tensor", 1.0 + 0.0j
+        target = _materialized_color_components(expression, colored_legs)
+        for structure, normalized in normalized_candidates:
+            candidate = _materialized_color_components(
+                normalized.expression,
+                colored_legs,
+            )
+            norm = sum(abs(value) ** 2 for value in candidate.values())
+            if norm == 0.0:
+                continue
+            coefficient = (
+                sum(
+                    candidate.get(key, 0.0j).conjugate() * value
+                    for key, value in target.items()
+                )
+                / norm
+            )
+            scale = max(
+                1.0,
+                sum(abs(value) ** 2 for value in target.values()),
+                abs(coefficient) ** 2 * norm,
+            )
+            residual = sum(
+                abs(target.get(key, 0.0j) - coefficient * candidate.get(key, 0.0j)) ** 2
+                for key in set(target) | set(candidate)
+            )
+            if residual <= 1.0e-24 * scale:
+                return structure, coefficient
+    except (RuntimeError, TypeError, ValueError):
+        pass
+    return "generic-tensor", 1.0 + 0.0j
+
+
+def classify_trilinear_color_expression(
+    expression: str,
+    source: str,
+    color_representations: Sequence[int],
+    *,
+    allow_source_fallback: bool = False,
+) -> tuple[str, complex]:
+    """Resolve a trilinear color tensor through an exact tensor projection.
+
+    Source-text recognition is reserved for compiler-generated contact fragments
+    whose color decomposition has already been proven independently.  Arbitrary
+    UFO vertices must never acquire a color-flow contract from spelling alone.
+    """
+
+    representations = tuple(int(value) for value in color_representations)
+    _validate_color_representations(representations)
+    return _classify_trilinear_color_expression_cached(
+        expression,
+        source,
+        representations,
+        bool(allow_source_fallback),
+    )
+
+
+@cache
+def _classify_trilinear_color_expression_cached(
+    expression: str,
+    source: str,
+    color_representations: tuple[int, ...],
+    allow_source_fallback: bool,
+) -> tuple[str, complex]:
+    projected = project_trilinear_color_expression(
+        expression,
+        color_representations,
+    )
+    if projected[0] != "generic-tensor":
+        return projected
+    if not allow_source_fallback:
+        return projected
+
+    compact_source = re.sub(r"\s+", "", source)
+    tensor = r"(?:UFO::(?:\{\}::)?)?"
+    if re.fullmatch(tensor + r"T\([^()]+\)", compact_source):
+        return "fundamental-generator", 1.0 + 0.0j
+    if re.fullmatch(tensor + r"f\([^()]+\)", compact_source):
+        return "adjoint-structure-constant", 1.0 + 0.0j
+    factors = compact_source.split("*")
+    if len(factors) > 1 and all(
+        re.fullmatch(tensor + r"f\([^()]+\)", factor) for factor in factors
+    ):
+        return "adjoint-structure-constant-product", 1.0 + 0.0j
+    if compact_source in {"1", "UFO::{}::1"}:
+        return "singlet", 1.0 + 0.0j
+    return projected
+
+
+def _constant_expression_ratio(
+    target: Expression,
+    candidate: Expression,
+) -> complex | None:
+    """Return the constant scale between algebraically identical tensors."""
+
+    if candidate == E("0"):
+        return None
+    ratio = (target / candidate).cancel()
+    if ratio.get_all_symbols(False):
+        return None
+    if (target - ratio * candidate).expand() != E("0"):
+        return None
+    try:
+        return complex(ratio)
+    except (RuntimeError, TypeError, ValueError):
+        return None
+
+
+def _materialized_color_components(
+    expression: str,
+    colored_legs: Sequence[int],
+) -> dict[tuple[int, ...], complex]:
+    library = TensorLibrary.hep_lib_atom()
+    atom = E(expression)
+    network = TensorNetwork(as_tensor(atom) if colored_legs else atom, library)
+    network.execute(library=library)
+    tensor = network.result_tensor(library).to_dense()
+    axes = []
+    for slot in tensor.axes:
+        argument = slot.to_expression()
+        match = re.search(r"ufo_c_([0-9]+)", argument.to_canonical_string())
+        if match is None:
+            raise ValueError("materialized color tensor has an unknown open index")
+        axes.append(int(match.group(1)))
+    if set(axes) != set(colored_legs):
+        raise ValueError(
+            "materialized color tensor open indices do not match its particles"
+        )
+    result: dict[tuple[int, ...], complex] = {}
+    for coordinates in product(*(range(dimension) for dimension in tensor.shape)):
+        by_leg = {leg: int(coordinates[axis]) for axis, leg in enumerate(axes)}
+        key = tuple(by_leg[leg] for leg in colored_legs)
+        result[key] = complex(tensor[coordinates])
+    return result
+
+
+def _as_expression(value: object) -> Expression:
+    _ensure_symbolica()
+    if isinstance(value, Expression):
+        return value
+    converter = getattr(value, "to_expression", None)
+    if callable(converter):
+        converted = converter()
+        if isinstance(converted, Expression):
+            return converted
+    raise TypeError(
+        f"tensor value is not convertible to Expression: {type(value).__name__}"
+    )
+
+
+def _validate_color_representations(representations: Sequence[int]) -> None:
+    for index, value in enumerate(representations, start=1):
+        validate_color_representation(value, context=f"UFO color leg {index}")
+
+
+__all__ = [
+    "NormalizedTensorExpression",
+    "classify_trilinear_color_expression",
+    "normalize_color_expression",
+    "normalize_lorentz_expression",
+    "normalize_vertex_tensor_term",
+    "project_trilinear_color_expression",
+]
diff --git a/pyamplicol/src/pyamplicol/processes/__init__.py b/pyamplicol/src/pyamplicol/processes/__init__.py
new file mode 100644
index 0000000000..f22eb5ed6a
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/processes/__init__.py
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: 0BSD
+"""Model-neutral process syntax and canonical process IR.
+
+Built-in-SM catalogue enumeration and selection live under
+``pyamplicol.models.builtin`` and are intentionally not re-exported here.
+"""
+
+from .core_syntax import (
+    OrderTuple,
+    ParticleName,
+    ProcessTuple,
+    canonical_process_key,
+    expand_process_variants,
+    split_process_set,
+)
+
+__all__ = [
+    "OrderTuple",
+    "ParticleName",
+    "ProcessTuple",
+    "canonical_process_key",
+    "expand_process_variants",
+    "split_process_set",
+]
diff --git a/pyamplicol/src/pyamplicol/processes/conservation.py b/pyamplicol/src/pyamplicol/processes/conservation.py
new file mode 100644
index 0000000000..0f9a0fa032
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/processes/conservation.py
@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: 0BSD
+"""Additive quantum numbers conserved by every vertex of a compiled model.
+
+A charge assigns a rational value to every particle, the opposite value to its
+antiparticle and zero to self-conjugate particles. It is conserved when the
+values of the particles of every vertex term sum to zero, so the conserved
+charges span the rational nullspace of the vertex/flavour incidence matrix.
+They are derived from the vertex list alone, which makes them a model-generic
+prefilter: a process whose external states do not balance one of them has no
+tree-level amplitude, whatever the coupling orders.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from fractions import Fraction
+
+from ..models.contracts import CompiledModelIR, CompiledParticleRecord
+
+
+@dataclass(frozen=True, slots=True)
+class ConservedCharges:
+    """Integer values of a basis of conserved charges, by particle name."""
+
+    charges: Mapping[str, tuple[int, ...]]
+    count: int
+
+    def total(self, names: Iterable[str]) -> tuple[int, ...]:
+        totals = [0] * self.count
+        zero = (0,) * self.count
+        for name in names:
+            for index, value in enumerate(self.charges.get(name, zero)):
+                totals[index] += value
+        return tuple(totals)
+
+    def balanced(self, initial: Sequence[str], final: Sequence[str]) -> bool:
+        return self.total(initial) == self.total(final)
+
+
+def _self_conjugate(particle: CompiledParticleRecord) -> bool:
+    declared = particle.self_conjugate
+    return (
+        bool(declared) if declared is not None else particle.name == particle.antiname
+    )
+
+
+def _nullspace(rows: Sequence[Sequence[int]], width: int) -> list[list[Fraction]]:
+    """Rational basis of ``{x : row . x = 0 for every row}``."""
+
+    reduced: list[list[Fraction]] = []
+    pivots: list[int] = []
+    for row in rows:
+        vector = [Fraction(value) for value in row]
+        for pivot_row, pivot in zip(reduced, pivots, strict=True):
+            if vector[pivot]:
+                factor = vector[pivot]
+                vector = [
+                    a - factor * b for a, b in zip(vector, pivot_row, strict=True)
+                ]
+        lead = next((index for index, value in enumerate(vector) if value), None)
+        if lead is None:
+            continue
+        vector = [value / vector[lead] for value in vector]
+        for index, other in enumerate(reduced):
+            if other[lead]:
+                factor = other[lead]
+                reduced[index] = [
+                    a - factor * b for a, b in zip(other, vector, strict=True)
+                ]
+        reduced.append(vector)
+        pivots.append(lead)
+    basis = []
+    for free in (column for column in range(width) if column not in pivots):
+        vector = [Fraction(0)] * width
+        vector[free] = Fraction(1)
+        for pivot_row, pivot in zip(reduced, pivots, strict=True):
+            vector[pivot] = -pivot_row[free]
+        basis.append(vector)
+    return basis
+
+
+def _integer(vector: Sequence[Fraction]) -> tuple[int, ...]:
+    scale = math.lcm(*(value.denominator for value in vector))
+    values = [int(value * scale) for value in vector]
+    divisor = math.gcd(*values) or 1
+    return tuple(value // divisor for value in values)
+
+
+def conserved_charges(model: CompiledModelIR) -> ConservedCharges:
+    """Return the additive charges conserved by every vertex term of ``model``."""
+
+    by_name = {particle.name: particle for particle in model.particles}
+    # One column per particle/antiparticle pair: (column, +1 or -1).
+    columns: dict[str, tuple[int, int]] = {}
+    width = 0
+    for particle in model.particles:
+        if _self_conjugate(particle) or particle.name in columns:
+            continue
+        antiparticle = by_name.get(particle.antiname)
+        pair = [particle] if antiparticle is None else [particle, antiparticle]
+        canonical = max(pair, key=lambda record: (record.pdg_code, record.name))
+        for record in pair:
+            columns[record.name] = (width, 1 if record is canonical else -1)
+        width += 1
+    rows: set[tuple[int, ...]] = set()
+    for term in model.vertex_terms:
+        row = [0] * width
+        for name in term.particles:
+            if name not in by_name:
+                raise ValueError(
+                    f"vertex term {term.id} refers to unknown particle {name!r}"
+                )
+            if name in columns:
+                column, sign = columns[name]
+                row[column] += sign
+        if any(row):
+            rows.add(tuple(row))
+    basis = [_integer(vector) for vector in _nullspace(sorted(rows), width)]
+    charges = {
+        name: tuple(sign * vector[column] for vector in basis)
+        for name, (column, sign) in columns.items()
+    }
+    return ConservedCharges(charges=charges, count=len(basis))
+
+
+__all__ = ["ConservedCharges", "conserved_charges"]
diff --git a/pyamplicol/src/pyamplicol/processes/core_syntax.py b/pyamplicol/src/pyamplicol/processes/core_syntax.py
new file mode 100644
index 0000000000..12a0370875
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/processes/core_syntax.py
@@ -0,0 +1,159 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import itertools
+import re
+from collections.abc import Mapping, Sequence
+
+ParticleName = str
+ProcessTuple = tuple[ParticleName, ...]
+OrderTuple = tuple[int, ...]
+
+
+def split_process_set(process_string: str) -> tuple[str, ...]:
+    """Split process sets without treating bars inside brackets as separators."""
+
+    parts: list[str] = []
+    depth = 0
+    start = 0
+    for index, char in enumerate(process_string):
+        if char == "[":
+            depth += 1
+        elif char == "]":
+            depth -= 1
+            if depth < 0:
+                raise ValueError("unmatched ']' in process string")
+        elif char == "|" and depth == 0:
+            part = process_string[start:index].strip()
+            if not part:
+                raise ValueError("empty process in process set")
+            parts.append(part)
+            start = index + 1
+    if depth != 0:
+        raise ValueError("unmatched '[' in process string")
+    tail = process_string[start:].strip()
+    if not tail:
+        raise ValueError("empty process in process set")
+    parts.append(tail)
+    return tuple(parts)
+
+
+def expand_process_variants(
+    process_string: str,
+    *,
+    aliases: Mapping[str, Sequence[str]] | None = None,
+) -> tuple[str, ...]:
+    """Expand anonymous multiparticle slots and repetition syntax.
+
+    Built-in inclusive labels such as ``p`` and ``j`` are kept symbolic for the
+    enumerator. Anonymous slots like ``[d g]`` are expanded by cartesian product,
+    and each repeated slot in ``3*[d g]`` is treated independently.
+    Optional named aliases are expanded through the same token-aware path.
+    """
+
+    variants: list[str] = []
+    for process in split_process_set(process_string):
+        parts = process.lower().replace("bar", "~").split(">")
+        if len(parts) != 2:
+            raise ValueError("invalid collision format; expected 'initial > final'")
+        initial_options = _expand_side_tokens(
+            _tokenize_side(parts[0].strip()), aliases=aliases
+        )
+        final_options = _expand_side_tokens(
+            _tokenize_side(parts[1].strip()), aliases=aliases
+        )
+        for initial in itertools.product(*initial_options):
+            for final in itertools.product(*final_options):
+                variants.append(f"{' '.join(initial)} > {' '.join(final)}")
+    return tuple(dict.fromkeys(variants))
+
+
+def canonical_process_key(process: str) -> str:
+    tokens = process.lower().replace("bar", "~").replace(">", " > ").split()
+    safe = []
+    for token in tokens:
+        if token == ">":
+            safe.append("to")
+        else:
+            safe.append(
+                token.replace("~", "bar").replace("+", "plus").replace("-", "minus")
+            )
+    return "_".join(safe)
+
+
+def _tokenize_side(side: str) -> list[str]:
+    tokens: list[str] = []
+    index = 0
+    while index < len(side):
+        if side[index].isspace():
+            index += 1
+            continue
+        if side[index] == "[":
+            end = side.find("]", index + 1)
+            if end < 0:
+                raise ValueError("unmatched '[' in process string")
+            tokens.append(side[index : end + 1])
+            index = end + 1
+            continue
+        end = index
+        while end < len(side) and not side[end].isspace():
+            if side[end] == "[":
+                bracket = side.find("]", end + 1)
+                if bracket < 0:
+                    raise ValueError("unmatched '[' in process string")
+                end = bracket + 1
+            else:
+                end += 1
+        tokens.append(side[index:end])
+        index = end
+    return tokens
+
+
+def _expand_side_tokens(
+    tokens: Sequence[str],
+    *,
+    aliases: Mapping[str, Sequence[str]] | None = None,
+) -> tuple[tuple[str, ...], ...]:
+    expanded: list[tuple[str, ...]] = []
+    normalized_aliases = {
+        str(name).casefold(): tuple(str(value).casefold() for value in values)
+        for name, values in (aliases or {}).items()
+    }
+    for token in tokens:
+        repeat, item = _split_repeat_token(token)
+        options = tuple(
+            member
+            for option in _anonymous_options(item)
+            for member in normalized_aliases.get(option.casefold(), (option,))
+        )
+        expanded.extend(options for _ in range(repeat))
+    return tuple(expanded)
+
+
+def _split_repeat_token(token: str) -> tuple[int, str]:
+    match = re.fullmatch(r"(\d+)\*(.+)", token)
+    if match:
+        return int(match.group(1)), match.group(2)
+    compact = re.fullmatch(r"(\d+)([A-Za-z][A-Za-z0-9+~\-]*)", token)
+    if compact:
+        return int(compact.group(1)), compact.group(2)
+    return 1, token
+
+
+def _anonymous_options(token: str) -> tuple[str, ...]:
+    if token.startswith("[") and token.endswith("]"):
+        options = tuple(_tokenize_side(token[1:-1].strip()))
+        if not options:
+            raise ValueError("anonymous multiparticle label cannot be empty")
+        return options
+    return (token,)
+
+
+__all__ = [
+    "OrderTuple",
+    "ParticleName",
+    "ProcessTuple",
+    "canonical_process_key",
+    "expand_process_variants",
+    "split_process_set",
+]
diff --git a/pyamplicol/src/pyamplicol/processes/ir.py b/pyamplicol/src/pyamplicol/processes/ir.py
new file mode 100644
index 0000000000..ea2319538c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/processes/ir.py
@@ -0,0 +1,230 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+from .core_syntax import ProcessTuple
+
+LegSide = Literal["initial", "final"]
+# These values mirror canonical compiled-particle metadata. ``inclusive`` is
+# reserved for the built-in compatibility aliases that do not identify a
+# concrete model particle.
+ParticleStatistics = Literal["boson", "fermion", "ghost", "auxiliary", "inclusive"]
+WavefunctionFamily = Literal[
+    "scalar",
+    "fermion",
+    "vector",
+    "spin2",
+    "ghost",
+    "auxiliary",
+    "inclusive",
+]
+ColorRole = Literal[
+    "fundamental",
+    "antifundamental",
+    "adjoint",
+    "singlet",
+    "inclusive",
+]
+SourceOrientation = Literal[
+    "particle",
+    "antiparticle",
+    "self-conjugate",
+    "inclusive",
+]
+
+@dataclass(frozen=True)
+class ProcessLegIR:
+    """One external leg with both physical and all-outgoing conventions."""
+
+    label: int
+    side: LegSide
+    particle: str
+    outgoing_particle: str
+    pdg: int | None
+    outgoing_pdg: int | None
+    statistics: ParticleStatistics
+    wavefunction_family: WavefunctionFamily
+    color_role: ColorRole
+    source_orientation: SourceOrientation
+
+    @property
+    def is_initial(self) -> bool:
+        return self.side == "initial"
+
+    @property
+    def is_final(self) -> bool:
+        return self.side == "final"
+
+    @property
+    def is_colored(self) -> bool:
+        return self.color_role not in {"singlet", "inclusive"}
+
+    @property
+    def is_singlet(self) -> bool:
+        return self.color_role == "singlet"
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "label": self.label,
+            "side": self.side,
+            "particle": self.particle,
+            "outgoing_particle": self.outgoing_particle,
+            "pdg": self.pdg,
+            "outgoing_pdg": self.outgoing_pdg,
+            "statistics": self.statistics,
+            "wavefunction_family": self.wavefunction_family,
+            "color_role": self.color_role,
+            "source_orientation": self.source_orientation,
+        }
+
+
+@dataclass(frozen=True)
+class ColorEndpointSummary:
+    fundamental_count: int
+    antifundamental_count: int
+    pair_count: int
+
+    @property
+    def balanced(self) -> bool:
+        return self.fundamental_count == self.antifundamental_count
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "fundamental_count": self.fundamental_count,
+            "antifundamental_count": self.antifundamental_count,
+            "pair_count": self.pair_count,
+            "balanced": self.balanced,
+        }
+
+
+@dataclass(frozen=True)
+class CanonicalProcessIR:
+    """Canonical process data used before model-driven current generation."""
+
+    process: str
+    key: str
+    color_accuracy: str
+    legs: tuple[ProcessLegIR, ...]
+    color_endpoints: ColorEndpointSummary
+
+    @property
+    def initial_legs(self) -> tuple[ProcessLegIR, ...]:
+        return tuple(leg for leg in self.legs if leg.is_initial)
+
+    @property
+    def final_legs(self) -> tuple[ProcessLegIR, ...]:
+        return tuple(leg for leg in self.legs if leg.is_final)
+
+    @property
+    def outgoing_particles(self) -> ProcessTuple:
+        return tuple(leg.outgoing_particle for leg in self.legs)
+
+    @property
+    def outgoing_pdgs(self) -> tuple[int, ...]:
+        return tuple(
+            int(leg.outgoing_pdg) for leg in self.legs if leg.outgoing_pdg is not None
+        )
+
+    @property
+    def initial_pdgs(self) -> tuple[int, ...]:
+        return tuple(int(leg.pdg) for leg in self.initial_legs if leg.pdg is not None)
+
+    @property
+    def final_pdgs(self) -> tuple[int, ...]:
+        return tuple(int(leg.pdg) for leg in self.final_legs if leg.pdg is not None)
+
+    @property
+    def fundamental_labels(self) -> tuple[int, ...]:
+        return self._labels_with_color_role("fundamental")
+
+    @property
+    def antifundamental_labels(self) -> tuple[int, ...]:
+        return self._labels_with_color_role("antifundamental")
+
+    @property
+    def adjoint_labels(self) -> tuple[int, ...]:
+        return self._labels_with_color_role("adjoint")
+
+    @property
+    def singlet_labels(self) -> tuple[int, ...]:
+        return self._labels_with_color_role("singlet")
+
+    @property
+    def has_inclusive_initial_state(self) -> bool:
+        return any(leg.color_role == "inclusive" for leg in self.initial_legs)
+
+    def _labels_with_color_role(self, color_role: ColorRole) -> tuple[int, ...]:
+        return tuple(leg.label for leg in self.legs if leg.color_role == color_role)
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "process": self.process,
+            "key": self.key,
+            "color_accuracy": self.color_accuracy,
+            "legs": [leg.to_json_dict() for leg in self.legs],
+            "outgoing_particles": list(self.outgoing_particles),
+            "outgoing_pdgs": list(self.outgoing_pdgs),
+            "color_endpoints": self.color_endpoints.to_json_dict(),
+            "color_role_labels": {
+                "fundamental": list(self.fundamental_labels),
+                "antifundamental": list(self.antifundamental_labels),
+                "adjoint": list(self.adjoint_labels),
+                "singlet": list(self.singlet_labels),
+            },
+        }
+
+
+@dataclass(frozen=True)
+class ProcessSetEntryIR:
+    key: str
+    process: str
+    ir: CanonicalProcessIR
+    n_groups: int
+    n_records: int
+    n_unique_processes: int
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "key": self.key,
+            "process": self.process,
+            "n_groups": self.n_groups,
+            "n_records": self.n_records,
+            "n_unique_processes": self.n_unique_processes,
+            "ir": self.ir.to_json_dict(),
+        }
+
+
+@dataclass(frozen=True)
+class ProcessSetIR:
+    request: str
+    color_accuracy: str
+    entries: tuple[ProcessSetEntryIR, ...]
+
+    @property
+    def default_key(self) -> str:
+        if not self.entries:
+            raise ValueError("process set is empty")
+        return self.entries[0].key
+
+    def to_json_dict(self) -> dict[str, object]:
+        return {
+            "request": self.request,
+            "color_accuracy": self.color_accuracy,
+            "default_key": self.default_key,
+            "entries": [entry.to_json_dict() for entry in self.entries],
+        }
+
+
+__all__ = [
+    "CanonicalProcessIR",
+    "ColorEndpointSummary",
+    "ColorRole",
+    "ParticleStatistics",
+    "ProcessLegIR",
+    "ProcessSetEntryIR",
+    "ProcessSetIR",
+    "SourceOrientation",
+    "WavefunctionFamily",
+]
diff --git a/pyamplicol/src/pyamplicol/processes/model.py b/pyamplicol/src/pyamplicol/processes/model.py
new file mode 100644
index 0000000000..b4fb22af6c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/processes/model.py
@@ -0,0 +1,373 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import itertools
+import re
+from collections import Counter
+from collections.abc import Iterator, Mapping, Sequence
+from dataclasses import dataclass
+from typing import cast
+
+from ..models.contracts import (
+    CompiledModelIR,
+    CompiledParameterRecord,
+    CompiledParticleRecord,
+    validate_color_representation,
+)
+from .conservation import ConservedCharges
+from .core_syntax import (
+    canonical_process_key,
+    split_process_set,
+)
+from .ir import (
+    CanonicalProcessIR,
+    ColorEndpointSummary,
+    ColorRole,
+    LegSide,
+    ParticleStatistics,
+    ProcessLegIR,
+    SourceOrientation,
+    WavefunctionFamily,
+)
+
+
+@dataclass(frozen=True)
+class ModelParticleCatalog:
+    model_name: str
+    particles: tuple[CompiledParticleRecord, ...]
+    parameters: tuple[CompiledParameterRecord, ...] = ()
+
+    def __post_init__(self) -> None:
+        names = [particle.name for particle in self.particles]
+        if len(names) != len(set(names)):
+            raise ValueError("compiled model contains duplicate particle names")
+        for particle in self.particles:
+            validate_color_representation(
+                particle.color,
+                context=f"particle {particle.name!r}",
+            )
+
+    @property
+    def by_name(self) -> dict[str, CompiledParticleRecord]:
+        return {particle.name: particle for particle in self.particles}
+
+    @property
+    def external_particles(self) -> tuple[CompiledParticleRecord, ...]:
+        return tuple(
+            particle
+            for particle in self.particles
+            if particle.spin > 0
+            and particle.ghost_number == 0
+            and not particle.goldstoneboson
+            and particle.propagating
+            and particle.auxiliary_kind is None
+        )
+
+    def resolve(self, name: str, *, external: bool = True) -> CompiledParticleRecord:
+        candidates = self.external_particles if external else self.particles
+        exact = next(
+            (particle for particle in candidates if particle.name == name), None
+        )
+        if exact is not None:
+            return exact
+        folded = [
+            particle
+            for particle in candidates
+            if particle.name.casefold() == name.casefold()
+        ]
+        if len(folded) == 1:
+            return folded[0]
+        if len(folded) > 1:
+            names = ", ".join(sorted(particle.name for particle in folded))
+            raise ValueError(f"particle name {name!r} is case-ambiguous: {names}")
+        raise ValueError(
+            f"particle {name!r} is not an external state in {self.model_name}"
+        )
+
+    def antiparticle(self, particle: CompiledParticleRecord) -> CompiledParticleRecord:
+        try:
+            return self.by_name[particle.antiname]
+        except KeyError as exc:
+            raise ValueError(
+                f"particle {particle.name!r} refers to absent antiparticle "
+                f"{particle.antiname!r}"
+            ) from exc
+
+    def validate_process_role(self, particle: CompiledParticleRecord) -> None:
+        """Reject colored roles unsupported by the current color planner."""
+
+        representation = validate_color_representation(
+            particle.color,
+            context=f"particle {particle.name!r}",
+        )
+        supported_colored_role = (
+            particle.color_role in {"fundamental", "antifundamental"}
+            and particle.statistics == "fermion"
+        ) or (
+            particle.color_role == "adjoint"
+            and particle.wavefunction_family == "vector"
+        )
+        if representation != 1 and not supported_colored_role:
+            raise ValueError(
+                f"particle {particle.name!r} has unsupported colored external-state "
+                f"role (spin={particle.spin}, color={representation}); current color "
+                "planning supports fundamental fermions and adjoint vectors"
+            )
+
+    def default_multiparticles(self) -> dict[str, tuple[str, ...]]:
+        partons = tuple(
+            particle.name
+            for particle in self.external_particles
+            if self._mass_is_compile_time_zero(particle.mass)
+            and (
+                (
+                    particle.statistics == "fermion"
+                    and particle.color_role in {"fundamental", "antifundamental"}
+                )
+                or (
+                    particle.wavefunction_family == "vector"
+                    and particle.color_role == "adjoint"
+                )
+            )
+        )
+        result = {} if not partons else {"p": partons, "j": partons}
+        result["all"] = tuple(particle.name for particle in self.external_particles)
+        return result
+
+    def _mass_is_compile_time_zero(self, name: str) -> bool:
+        if name.casefold() == "zero":
+            return True
+        parameter = next(
+            (parameter for parameter in self.parameters if parameter.name == name),
+            None,
+        )
+        if parameter is None or parameter.nature.casefold() != "internal":
+            return False
+        from ..models import compiler_symbolica as _sym
+
+        _sym._ensure_symbolica()
+        return (
+            _sym.E(parameter.resolved_expression).expand().to_canonical_string()
+            == _sym.E("0").to_canonical_string()
+        )
+
+
+def parse_multiparticle_definitions(
+    definitions: Sequence[str],
+    catalog: ModelParticleCatalog,
+) -> dict[str, tuple[str, ...]]:
+    result = dict(catalog.default_multiparticles())
+    for definition in definitions:
+        name, separator, raw_items = definition.partition("=")
+        name = name.strip()
+        if (
+            not separator
+            or not name
+            or not re.fullmatch(r"[A-Za-z][A-Za-z0-9_]*", name)
+        ):
+            raise ValueError(
+                f"invalid multiparticle definition {definition!r}; "
+                "expected NAME=ITEM,ITEM"
+            )
+        items = tuple(item.strip() for item in raw_items.split(",") if item.strip())
+        if not items:
+            raise ValueError(f"multiparticle {name!r} has no members")
+        resolved = tuple(catalog.resolve(item).name for item in items)
+        result[name] = tuple(dict.fromkeys(resolved))
+    return result
+
+
+def expand_model_processes(
+    process_set: str,
+    catalog: ModelParticleCatalog,
+    *,
+    multiparticles: Mapping[str, Sequence[str]] | None = None,
+    charges: ConservedCharges | None = None,
+) -> tuple[str, ...]:
+    """Concrete processes of ``process_set``, one per multiset of each side.
+
+    Side permutations describe the same matrix element, so each side is
+    enumerated as a multiset. With ``charges``, processes violating a
+    conserved additive charge of the model are dropped.
+    """
+
+    aliases = {
+        name: tuple(values) for name, values in catalog.default_multiparticles().items()
+    }
+    if multiparticles is not None:
+        aliases.update({name: tuple(values) for name, values in multiparticles.items()})
+    expanded: dict[str, None] = {}
+    for process in split_process_set(process_set):
+        initial_text, separator, final_text = process.partition(">")
+        if not separator or ">" in final_text:
+            raise ValueError("invalid collision format; expected 'initial > final'")
+        initial_slots = _expanded_slots(initial_text, aliases, catalog)
+        final_slots = _expanded_slots(final_text, aliases, catalog)
+        if len(initial_slots) != 2:
+            raise ValueError(
+                "pyAmpliCol processes require exactly two initial particles"
+            )
+        if not final_slots:
+            raise ValueError("pyAmpliCol processes require at least one final particle")
+        finals: dict[tuple[int, ...], list[tuple[str, ...]]] = {}
+        for final in _side_multisets(final_slots):
+            key = () if charges is None else charges.total(final)
+            finals.setdefault(key, []).append(final)
+        for initial in _side_multisets(initial_slots):
+            key = () if charges is None else charges.total(initial)
+            for final in finals.get(key, ()):
+                concrete = f"{' '.join(initial)} > {' '.join(final)}"
+                expanded.setdefault(concrete, None)
+    return tuple(expanded)
+
+
+def _side_multisets(slots: Sequence[tuple[str, ...]]) -> Iterator[tuple[str, ...]]:
+    """Each particle multiset that fills ``slots`` once.
+
+    Slots with the same options are filled by non-decreasing option index:
+    the order in which a cartesian product meets a multiset first, unless
+    slots with different but overlapping options interleave.
+    """
+
+    groups: dict[tuple[str, ...], list[int]] = {}
+    for position, options in enumerate(slots):
+        groups.setdefault(options, []).append(position)
+    seen: set[tuple[str, ...]] = set()
+    for choice in itertools.product(
+        *(
+            itertools.combinations_with_replacement(options, len(positions))
+            for options, positions in groups.items()
+        )
+    ):
+        assignment = [""] * len(slots)
+        for positions, names in zip(groups.values(), choice, strict=True):
+            for position, name in zip(positions, names, strict=True):
+                assignment[position] = name
+        key = tuple(sorted(assignment))
+        if key not in seen:
+            seen.add(key)
+            yield tuple(assignment)
+
+
+def build_model_process_ir(
+    process: str,
+    model: CompiledModelIR,
+    *,
+    color_accuracy: str = "lc",
+) -> CanonicalProcessIR:
+    catalog = ModelParticleCatalog(model.name, model.particles, model.parameters)
+    initial_text, separator, final_text = process.partition(">")
+    if not separator or ">" in final_text:
+        raise ValueError("invalid collision format; expected 'initial > final'")
+    initial = tuple(catalog.resolve(token) for token in initial_text.split())
+    final = tuple(catalog.resolve(token) for token in final_text.split())
+    if len(initial) != 2 or not final:
+        raise ValueError(
+            "process must have exactly two initial and at least one final particle"
+        )
+    outgoing_initial = tuple(catalog.antiparticle(particle) for particle in initial)
+    canonical = f"{' '.join(particle.name for particle in initial)} > " + " ".join(
+        particle.name for particle in final
+    )
+    legs = tuple(
+        [
+            *(
+                _model_leg(
+                    label=index + 1,
+                    side="initial",
+                    particle=particle,
+                    outgoing_particle=outgoing_initial[index],
+                    catalog=catalog,
+                )
+                for index, particle in enumerate(initial)
+            ),
+            *(
+                _model_leg(
+                    label=index + 3,
+                    side="final",
+                    particle=particle,
+                    outgoing_particle=particle,
+                    catalog=catalog,
+                )
+                for index, particle in enumerate(final)
+            ),
+        ]
+    )
+    counts = Counter(leg.color_role for leg in legs)
+    return CanonicalProcessIR(
+        process=canonical,
+        key=canonical_process_key(canonical),
+        color_accuracy=color_accuracy,
+        legs=legs,
+        color_endpoints=ColorEndpointSummary(
+            fundamental_count=counts["fundamental"],
+            antifundamental_count=counts["antifundamental"],
+            pair_count=min(
+                counts["fundamental"],
+                counts["antifundamental"],
+            ),
+        ),
+    )
+
+
+def _expanded_slots(
+    text: str,
+    aliases: Mapping[str, Sequence[str]],
+    catalog: ModelParticleCatalog,
+) -> list[tuple[str, ...]]:
+    slots: list[tuple[str, ...]] = []
+    for token in text.split():
+        count, name = _repetition(token)
+        if name in aliases:
+            options = tuple(catalog.resolve(item).name for item in aliases[name])
+        else:
+            options = (catalog.resolve(name).name,)
+        slots.extend(options for _ in range(count))
+    return slots
+
+
+def _repetition(token: str) -> tuple[int, str]:
+    match = re.fullmatch(r"(?:(\d+)\*)?(.+)", token)
+    if match is None:
+        raise ValueError(f"invalid process token {token!r}")
+    count = int(match.group(1) or 1)
+    if count < 1:
+        raise ValueError(f"process repetition must be positive: {token!r}")
+    return count, match.group(2)
+
+
+def _model_leg(
+    *,
+    label: int,
+    side: str,
+    particle: CompiledParticleRecord,
+    outgoing_particle: CompiledParticleRecord,
+    catalog: ModelParticleCatalog,
+) -> ProcessLegIR:
+    catalog.validate_process_role(outgoing_particle)
+    return ProcessLegIR(
+        label=label,
+        side=cast(LegSide, side),
+        particle=particle.name,
+        outgoing_particle=outgoing_particle.name,
+        pdg=particle.pdg_code,
+        outgoing_pdg=outgoing_particle.pdg_code,
+        statistics=cast(ParticleStatistics, outgoing_particle.statistics),
+        wavefunction_family=cast(
+            WavefunctionFamily,
+            outgoing_particle.wavefunction_family,
+        ),
+        color_role=cast(ColorRole, outgoing_particle.color_role),
+        source_orientation=cast(
+            SourceOrientation,
+            outgoing_particle.source_orientation,
+        ),
+    )
+
+
+__all__ = [
+    "ModelParticleCatalog",
+    "build_model_process_ir",
+    "expand_model_processes",
+    "parse_multiparticle_definitions",
+]
diff --git a/pyamplicol/src/pyamplicol/py.typed b/pyamplicol/src/pyamplicol/py.typed
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/py.typed
@@ -0,0 +1 @@
+
diff --git a/pyamplicol/src/pyamplicol/reporting/__init__.py b/pyamplicol/src/pyamplicol/reporting/__init__.py
new file mode 100644
index 0000000000..c5045eb52e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/reporting/__init__.py
@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from .logging import (
+    DEFAULT_LOG_FORMAT,
+    LOGGER_NAME,
+    configure_cli_logging,
+    get_logger,
+    reset_cli_logging,
+)
+from .progress import (
+    CallbackProgressSink,
+    LoggingProgressSink,
+    NullProgressSink,
+    ProgressEnd,
+    ProgressEvent,
+    ProgressSink,
+    ProgressStart,
+    ProgressUpdate,
+    StreamProgressSink,
+    TtyProgressSink,
+    close_progress_sink,
+    progress_sink,
+)
+from .summary import render_summary
+
+__all__ = [
+    "DEFAULT_LOG_FORMAT",
+    "LOGGER_NAME",
+    "CallbackProgressSink",
+    "LoggingProgressSink",
+    "NullProgressSink",
+    "ProgressEnd",
+    "ProgressEvent",
+    "ProgressSink",
+    "ProgressStart",
+    "ProgressUpdate",
+    "StreamProgressSink",
+    "TtyProgressSink",
+    "close_progress_sink",
+    "configure_cli_logging",
+    "get_logger",
+    "progress_sink",
+    "render_summary",
+    "reset_cli_logging",
+]
diff --git a/pyamplicol/src/pyamplicol/reporting/logging.py b/pyamplicol/src/pyamplicol/reporting/logging.py
new file mode 100644
index 0000000000..e7df25e12e
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/reporting/logging.py
@@ -0,0 +1,143 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib
+import logging
+import sys
+from typing import Any, TextIO
+
+LOGGER_NAME = "pyamplicol"
+DEFAULT_LOG_FORMAT = "%(levelname)s %(name)s: %(message)s"
+_HANDLER_MARKER = "_pyamplicol_cli_handler"
+_NULL_MARKER = "_pyamplicol_null_handler"
+_PREVIOUS_STATE_MARKER = "_pyamplicol_cli_previous_state"
+
+
+class _CliFormatter(logging.Formatter):
+    """Color terminal diagnostics while leaving ordinary informational logs alone."""
+
+    def __init__(self, fmt: str, *, color: bool) -> None:
+        super().__init__(fmt)
+        self._color = color
+
+    def format(self, record: logging.LogRecord) -> str:
+        rendered = super().format(record)
+        if not self._color:
+            return rendered
+        try:
+            colorama: Any = importlib.import_module("colorama")
+        except ImportError:
+            return rendered
+        if record.levelno >= logging.ERROR:
+            foreground = colorama.Fore.RED
+        elif record.levelno >= logging.WARNING:
+            foreground = colorama.Fore.YELLOW
+        else:
+            return rendered
+        return f"{foreground}{rendered}{colorama.Style.RESET_ALL}"
+
+
+def get_logger(name: str | None = None) -> logging.Logger:
+    """Return the package logger or a named child without configuring logging."""
+
+    if not name:
+        return logging.getLogger(LOGGER_NAME)
+    if name == LOGGER_NAME or name.startswith(f"{LOGGER_NAME}."):
+        return logging.getLogger(name)
+    return logging.getLogger(f"{LOGGER_NAME}.{name}")
+
+
+def _ensure_null_handler() -> None:
+    logger = get_logger()
+    if any(getattr(handler, _NULL_MARKER, False) for handler in logger.handlers):
+        return
+    handler = logging.NullHandler()
+    setattr(handler, _NULL_MARKER, True)
+    logger.addHandler(handler)
+
+
+def _normalize_level(level: int | str) -> int:
+    if isinstance(level, bool):
+        raise ValueError(f"invalid logging level {level!r}")
+    if isinstance(level, int):
+        return level
+    if not isinstance(level, str):
+        raise ValueError(f"invalid logging level {level!r}")
+    normalized = logging.getLevelNamesMapping().get(level.upper())
+    if normalized is None:
+        raise ValueError(f"unknown logging level {level!r}")
+    return normalized
+
+
+def configure_cli_logging(
+    level: int | str = logging.INFO,
+    *,
+    stream: TextIO | None = None,
+    fmt: str = DEFAULT_LOG_FORMAT,
+    color: bool = False,
+) -> logging.Logger:
+    """Install one package-local CLI handler, leaving the root logger untouched."""
+
+    selected_level = _normalize_level(level)
+    logger = get_logger()
+    handler = next(
+        (
+            candidate
+            for candidate in logger.handlers
+            if getattr(candidate, _HANDLER_MARKER, False)
+        ),
+        None,
+    )
+    if handler is None:
+        handler = logging.StreamHandler(sys.stderr if stream is None else stream)
+        setattr(handler, _HANDLER_MARKER, True)
+        setattr(
+            handler,
+            _PREVIOUS_STATE_MARKER,
+            (logger.level, logger.propagate),
+        )
+        logger.addHandler(handler)
+    elif stream is not None and isinstance(handler, logging.StreamHandler):
+        handler.setStream(stream)
+    handler.setLevel(selected_level)
+    handler.setFormatter(_CliFormatter(fmt, color=color))
+    logger.setLevel(selected_level)
+    logger.propagate = False
+    return logger
+
+
+def reset_cli_logging() -> None:
+    """Remove CLI handlers and restore the embedding application's logger state."""
+
+    logger = get_logger()
+    previous_state: tuple[int, bool] | None = None
+    for handler in tuple(logger.handlers):
+        if not getattr(handler, _HANDLER_MARKER, False):
+            continue
+        candidate_state = getattr(handler, _PREVIOUS_STATE_MARKER, None)
+        if (
+            previous_state is None
+            and isinstance(candidate_state, tuple)
+            and len(candidate_state) == 2
+            and isinstance(candidate_state[0], int)
+            and isinstance(candidate_state[1], bool)
+        ):
+            previous_state = candidate_state
+        logger.removeHandler(handler)
+        handler.close()
+    if previous_state is not None:
+        logger.setLevel(previous_state[0])
+        logger.propagate = previous_state[1]
+    _ensure_null_handler()
+
+
+_ensure_null_handler()
+
+
+__all__ = [
+    "DEFAULT_LOG_FORMAT",
+    "LOGGER_NAME",
+    "configure_cli_logging",
+    "get_logger",
+    "reset_cli_logging",
+]
diff --git a/pyamplicol/src/pyamplicol/reporting/progress.py b/pyamplicol/src/pyamplicol/reporting/progress.py
new file mode 100644
index 0000000000..bf291af951
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/reporting/progress.py
@@ -0,0 +1,1047 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib
+import io
+import logging
+import math
+import os
+import re
+import shutil
+import time
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass, field
+from threading import Event, RLock, Thread
+from types import MappingProxyType
+from typing import Any, Literal, Protocol, TextIO, TypeAlias, runtime_checkable
+
+from .logging import get_logger
+from .resources import ResourceUsage, ResourceUsageMonitor
+
+ProgressDetailValue: TypeAlias = str | int | float | bool | None
+ProgressDetails: TypeAlias = Mapping[str, ProgressDetailValue]
+
+
+def _terminal_paint(text: str, color_name: str, *, enabled: bool) -> str:
+    if not enabled:
+        return text
+    try:
+        colorama: Any = importlib.import_module("colorama")
+    except ImportError:
+        return text
+    return f"{getattr(colorama.Fore, color_name)}{text}{colorama.Style.RESET_ALL}"
+
+
+def _task_id(value: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise ValueError("progress task_id must be a non-empty string")
+    return value
+
+
+def _total(value: int | None) -> int | None:
+    if value is not None and (
+        isinstance(value, bool) or not isinstance(value, int) or value < 0
+    ):
+        raise ValueError("progress total must be a non-negative integer or null")
+    return value
+
+
+def _details(value: ProgressDetails | None) -> ProgressDetails:
+    if value is None:
+        return MappingProxyType({})
+    if not isinstance(value, Mapping):
+        raise ValueError("progress details must be a mapping")
+    result: dict[str, ProgressDetailValue] = {}
+    for key, detail in value.items():
+        if not isinstance(key, str) or not key:
+            raise ValueError("progress detail names must be non-empty strings")
+        if not isinstance(detail, (str, int, float, bool, type(None))):
+            raise ValueError(
+                f"progress detail {key!r} has unsupported type "
+                f"{type(detail).__name__}"
+            )
+        if isinstance(detail, float) and not math.isfinite(detail):
+            raise ValueError(f"progress detail {key!r} must be finite")
+        result[key] = detail
+    return MappingProxyType(result)
+
+
+def _elapsed(value: float | None) -> float | None:
+    if value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValueError("progress elapsed_seconds must be a number or null")
+    elapsed = float(value)
+    if not math.isfinite(elapsed) or elapsed < 0.0:
+        raise ValueError("progress elapsed_seconds must be finite and non-negative")
+    return elapsed
+
+
+@dataclass(frozen=True, slots=True)
+class ProgressStart:
+    task_id: str
+    description: str
+    total: int | None = None
+    parent_task_id: str | None = None
+    unit: str = "items"
+    details: ProgressDetails = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        _task_id(self.task_id)
+        if not isinstance(self.description, str) or not self.description:
+            raise ValueError("progress description must be a non-empty string")
+        _total(self.total)
+        if self.parent_task_id is not None:
+            _task_id(self.parent_task_id)
+            if self.parent_task_id == self.task_id:
+                raise ValueError("progress task may not be its own parent")
+        if not isinstance(self.unit, str) or not self.unit:
+            raise ValueError("progress unit must be a non-empty string")
+        object.__setattr__(self, "details", _details(self.details))
+
+
+@dataclass(frozen=True, slots=True)
+class ProgressUpdate:
+    task_id: str
+    completed: int
+    total: int | None = None
+    message: str | None = None
+    details: ProgressDetails = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        _task_id(self.task_id)
+        if (
+            isinstance(self.completed, bool)
+            or not isinstance(self.completed, int)
+            or self.completed < 0
+        ):
+            raise ValueError("progress completed must be a non-negative integer")
+        total = _total(self.total)
+        if total is not None and self.completed > total:
+            raise ValueError("progress completed may not exceed total")
+        if self.message is not None and not isinstance(self.message, str):
+            raise ValueError("progress message must be a string or null")
+        object.__setattr__(self, "details", _details(self.details))
+
+
+@dataclass(frozen=True, slots=True)
+class ProgressEnd:
+    task_id: str
+    success: bool = True
+    message: str | None = None
+    elapsed_seconds: float | None = None
+    details: ProgressDetails = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        _task_id(self.task_id)
+        if not isinstance(self.success, bool):
+            raise ValueError("progress success must be a boolean")
+        if self.message is not None and not isinstance(self.message, str):
+            raise ValueError("progress message must be a string or null")
+        object.__setattr__(self, "elapsed_seconds", _elapsed(self.elapsed_seconds))
+        object.__setattr__(self, "details", _details(self.details))
+
+
+ProgressEvent: TypeAlias = ProgressStart | ProgressUpdate | ProgressEnd
+
+
+@runtime_checkable
+class ProgressSink(Protocol):
+    def emit(self, event: ProgressEvent) -> None:
+        """Consume one typed progress event."""
+
+
+@dataclass(frozen=True, slots=True)
+class CallbackProgressSink:
+    callback: Callable[[ProgressEvent], None]
+
+    def emit(self, event: ProgressEvent) -> None:
+        self.callback(event)
+
+
+@dataclass(frozen=True, slots=True)
+class NullProgressSink:
+    def emit(self, event: ProgressEvent) -> None:
+        del event
+
+
+@dataclass(slots=True)
+class LoggingProgressSink:
+    logger: logging.Logger = field(default_factory=lambda: get_logger("progress"))
+    level: int = logging.INFO
+    minimum_interval: float = 1.0
+    color: bool = False
+    _last_emit: dict[str, float] = field(default_factory=dict, init=False, repr=False)
+    _lock: RLock = field(default_factory=RLock, init=False, repr=False)
+
+    def emit(self, event: ProgressEvent) -> None:
+        now = time.monotonic()
+        with self._lock:
+            if isinstance(event, ProgressUpdate):
+                last = self._last_emit.get(event.task_id, float("-inf"))
+                complete = event.total is not None and event.completed == event.total
+                if not complete and now - last < self.minimum_interval:
+                    return
+            self.logger.log(self.level, _format_event(event, color=self.color))
+            self._last_emit[event.task_id] = now
+            if isinstance(event, ProgressEnd):
+                self._last_emit.pop(event.task_id, None)
+
+
+@dataclass(frozen=True, slots=True)
+class StreamProgressSink:
+    stream: TextIO
+
+    def emit(self, event: ProgressEvent) -> None:
+        self.stream.write(f"{_format_event(event)}\n")
+        self.stream.flush()
+
+
+@dataclass(slots=True)
+class TtyProgressSink:
+    """Render a thread-safe adaptive three-line progress dashboard."""
+
+    stream: TextIO
+    color: bool | None = None
+    _tasks: dict[str, _TaskState] = field(default_factory=dict, init=False, repr=False)
+    _dashboard: _Dashboard | None = field(default=None, init=False, repr=False)
+    _line_sink: _LineProgressSink | None = field(default=None, init=False, repr=False)
+    _lock: RLock = field(default_factory=RLock, init=False, repr=False)
+    _output_lock: RLock = field(default_factory=RLock, init=False, repr=False)
+    _message_stream: _TtyMessageStream = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        self._message_stream = _TtyMessageStream(self)
+
+    def emit(self, event: ProgressEvent) -> None:
+        dashboard: _Dashboard | None = None
+        start_dashboard = False
+        stop_dashboard = False
+        with self._lock:
+            if not self._interactive:
+                if self._line_sink is None:
+                    self._line_sink = _LineProgressSink(
+                        self.stream,
+                        color=False,
+                    )
+                self._line_sink.emit(event)
+                return
+            now = time.monotonic()
+            if isinstance(event, ProgressStart):
+                existing = self._tasks.get(event.task_id)
+                if existing is not None and existing.finished_at is None:
+                    raise ValueError(f"progress task already started: {event.task_id}")
+                self._tasks[event.task_id] = _TaskState(
+                    task_id=event.task_id,
+                    description=event.description,
+                    total=event.total,
+                    parent_task_id=event.parent_task_id,
+                    unit=event.unit,
+                    details=dict(event.details),
+                    started_at=now,
+                    updated_at=now,
+                )
+                if self._dashboard is None:
+                    self._dashboard = _Dashboard(
+                        stream=self.stream,
+                        color=self._color_enabled,
+                        snapshot=self._snapshot,
+                        render_lock=self._output_lock,
+                    )
+                    start_dashboard = True
+            else:
+                task = self._tasks.get(event.task_id)
+                if task is None:
+                    # Keep custom sinks forgiving when a backend emits a late pulse.
+                    return
+                if isinstance(event, ProgressUpdate):
+                    task.completed = max(task.completed, event.completed)
+                    task.total = event.total if event.total is not None else task.total
+                    task.message = event.message
+                    task.details.update(event.details)
+                    task.updated_at = now
+                else:
+                    task.success = event.success
+                    task.message = event.message
+                    task.details.update(event.details)
+                    task.finished_at = now
+                    task.updated_at = now
+                    if event.elapsed_seconds is not None:
+                        task.elapsed_seconds = event.elapsed_seconds
+            dashboard = self._dashboard
+            if (
+                isinstance(event, ProgressEnd)
+                and dashboard is not None
+                and all(task.finished_at is not None for task in self._tasks.values())
+            ):
+                self._dashboard = None
+                stop_dashboard = True
+
+        # Rendering snapshots task state and therefore acquires ``self._lock``.
+        # Keep it outside that lock so the heartbeat's render lock and event
+        # delivery can never form a lock-order cycle.
+        if dashboard is not None:
+            if stop_dashboard:
+                dashboard.close()
+            elif start_dashboard:
+                dashboard.start()
+            else:
+                dashboard.render_now()
+
+    def close(self) -> None:
+        with self._lock:
+            dashboard = self._dashboard
+            self._dashboard = None
+        if dashboard is not None:
+            dashboard.close()
+
+    @property
+    def message_stream(self) -> TextIO:
+        """A logging stream that preserves dashboard line ownership."""
+
+        return self._message_stream
+
+    def _write_message(self, text: str) -> int:
+        with self._lock:
+            dashboard = self._dashboard
+        if dashboard is not None:
+            dashboard.write_message(text)
+        else:
+            with self._output_lock:
+                self.stream.write(text)
+        return len(text)
+
+    def _flush_messages(self) -> None:
+        with self._output_lock:
+            self.stream.flush()
+
+    @property
+    def _interactive(self) -> bool:
+        return bool(getattr(self.stream, "isatty", lambda: False)())
+
+    @property
+    def _color_enabled(self) -> bool:
+        if self.color is not None:
+            return self.color
+        return bool(getattr(self.stream, "isatty", lambda: False)())
+
+    def _snapshot(self) -> tuple[_TaskState, ...]:
+        with self._lock:
+            return tuple(task.copy() for task in self._tasks.values())
+
+
+@dataclass(slots=True)
+class _TaskState:
+    task_id: str
+    description: str
+    total: int | None
+    parent_task_id: str | None
+    unit: str
+    details: dict[str, ProgressDetailValue]
+    started_at: float
+    updated_at: float
+    completed: int = 0
+    message: str | None = None
+    success: bool | None = None
+    finished_at: float | None = None
+    elapsed_seconds: float | None = None
+
+    def copy(self) -> _TaskState:
+        return _TaskState(
+            task_id=self.task_id,
+            description=self.description,
+            total=self.total,
+            parent_task_id=self.parent_task_id,
+            unit=self.unit,
+            details=dict(self.details),
+            started_at=self.started_at,
+            updated_at=self.updated_at,
+            completed=self.completed,
+            message=self.message,
+            success=self.success,
+            finished_at=self.finished_at,
+            elapsed_seconds=self.elapsed_seconds,
+        )
+
+
+@dataclass(slots=True)
+class _LineProgressSink:
+    stream: TextIO
+    color: bool = False
+    descriptions: dict[str, str] = field(default_factory=dict)
+
+    def emit(self, event: ProgressEvent) -> None:
+        if isinstance(event, ProgressStart):
+            self.descriptions[event.task_id] = event.description
+        description = self.descriptions.get(event.task_id)
+        rendered = _format_event(event, description=description)
+        color_name = (
+            "RED"
+            if isinstance(event, ProgressEnd) and not event.success
+            else "CYAN"
+        )
+        painted = _terminal_paint(rendered, color_name, enabled=self.color)
+        self.stream.write(f"{painted}\n")
+        self.stream.flush()
+        if isinstance(event, ProgressEnd):
+            self.descriptions.pop(event.task_id, None)
+
+
+class _TtyMessageStream(io.TextIOBase, TextIO):
+    def __init__(self, sink: TtyProgressSink) -> None:
+        self._sink = sink
+
+    def writable(self) -> bool:
+        return True
+
+    def isatty(self) -> bool:
+        return self._sink._interactive
+
+    def fileno(self) -> int:
+        return self._sink.stream.fileno()
+
+    def write(self, text: str) -> int:
+        if not isinstance(text, str):
+            raise TypeError("TTY progress messages must be strings")
+        return self._sink._write_message(text)
+
+    def flush(self) -> None:
+        self._sink._flush_messages()
+
+
+class _Dashboard:
+    def __init__(
+        self,
+        *,
+        stream: TextIO,
+        color: bool,
+        snapshot: Callable[[], tuple[_TaskState, ...]],
+        render_lock: RLock,
+    ) -> None:
+        self._stream = stream
+        self._color = color
+        self._snapshot = snapshot
+        self._resource_monitor = ResourceUsageMonitor(interval_seconds=1.0)
+        self._stop = Event()
+        self._thread: Thread | None = None
+        self._render_lock = render_lock
+        self._painted = False
+        self._closed = False
+
+    def start(self) -> None:
+        self._resource_monitor.start()
+        self.render_now()
+        self._thread = Thread(
+            target=self._run,
+            name="pyamplicol-progress-dashboard",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def close(self) -> None:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=1.0)
+            self._thread = None
+        self._resource_monitor.close()
+        with self._render_lock:
+            self._closed = True
+            self._clear_locked()
+            self._stream.flush()
+
+    def render_now(self) -> None:
+        with self._render_lock:
+            if not self._closed:
+                self._render_locked()
+
+    def write_message(self, text: str) -> None:
+        with self._render_lock:
+            if self._closed:
+                self._stream.write(text)
+                return
+            self._clear_locked()
+            self._stream.write(text)
+            if text and not text.endswith(("\n", "\r")):
+                self._stream.write("\n")
+            self._render_locked()
+
+    def _render_locked(self) -> None:
+        # Keeping the final column empty avoids delayed-wrap terminals turning
+        # one logical dashboard row into two physical rows.
+        width = max(_terminal_width(self._stream) - 1, 1)
+        lines = _dashboard_lines(
+            self._snapshot(),
+            now=time.monotonic(),
+            usage=self._resource_monitor.usage,
+            width=width,
+            color=self._color,
+        )
+        if self._painted:
+            self._stream.write(f"\x1b[{len(lines)}F")
+        for line in lines:
+            self._stream.write(f"\r\x1b[2K{line}\n")
+        self._painted = True
+        self._stream.flush()
+
+    def _clear_locked(self) -> None:
+        if not self._painted:
+            return
+        self._stream.write("\x1b[3F\r\x1b[J")
+        self._painted = False
+
+    def _run(self) -> None:
+        while not self._stop.wait(0.25):
+            self.render_now()
+
+
+def _terminal_width(stream: TextIO) -> int:
+    try:
+        return max(1, os.get_terminal_size(stream.fileno()).columns)
+    except (AttributeError, OSError, ValueError):
+        return max(1, shutil.get_terminal_size(fallback=(120, 24)).columns)
+
+
+def _dashboard_lines(
+    tasks: tuple[_TaskState, ...],
+    *,
+    now: float,
+    usage: ResourceUsage,
+    width: int,
+    color: bool,
+) -> tuple[str, str, str]:
+    if not tasks:
+        return ("", "", "")
+    active = tuple(task for task in tasks if task.finished_at is None)
+    roots = tuple(task for task in active if task.parent_task_id is None)
+    if not roots:
+        roots = tuple(task for task in tasks if task.parent_task_id is None)
+    root = max(roots or tasks, key=lambda task: task.updated_at)
+    children = tuple(
+        task for task in active if task.parent_task_id == root.task_id
+    )
+    phase = max(children, key=lambda task: task.updated_at) if children else root
+    parent_ids = {task.parent_task_id for task in active if task.parent_task_id}
+    leaves = tuple(task for task in active if task.task_id not in parent_ids)
+    if leaves:
+        ordered = tuple(sorted(leaves, key=lambda task: task.task_id))
+        rotation_anchor = min(task.started_at for task in ordered)
+        detail = ordered[int(max(now - rotation_anchor, 0.0) / 2.0) % len(ordered)]
+    else:
+        detail = max(tasks, key=lambda task: task.updated_at)
+    return (
+        _overall_line(root, now=now, usage=usage, width=width, color=color),
+        _phase_line(
+            phase,
+            now=now,
+            active_children=sum(
+                task.parent_task_id == phase.task_id for task in active
+            ),
+            width=width,
+            color=color,
+        ),
+        _detail_line(detail, now=now, width=width, color=color),
+    )
+
+
+def _overall_line(
+    root: _TaskState,
+    *,
+    now: float,
+    usage: ResourceUsage,
+    width: int,
+    color: bool,
+) -> str:
+    elapsed = root.elapsed_seconds or max(
+        (root.finished_at or now) - root.started_at,
+        0.0,
+    )
+    execution_mode = root.details.get("execution_mode")
+    backend = root.details.get("backend")
+    optimization = root.details.get("optimization")
+    identity = " | ".join(
+        str(value) for value in (execution_mode, backend, optimization) if value
+    )
+    title = root.description + (f" [{identity}]" if identity else "")
+    if width < 80:
+        title = root.description
+        rss = _rss_text(usage, compact=True)
+        fragments = [
+            (title, "CYAN"),
+            (f"  {_duration_text(elapsed)}", None),
+            (f"  RSS {rss}", "YELLOW" if usage.peak_rss_bytes is not None else None),
+        ]
+        return _paint_fragments(fragments, width=width, enabled=color)
+    rss = _rss_text(usage, compact=width < 120)
+    child_count = (
+        "N/A"
+        if usage.process_count is None
+        else str(max(usage.process_count - 1, 0))
+    )
+    fragments = [
+        (title, "CYAN"),
+        (f"  elapsed {_duration_text(elapsed)}", None),
+        (f"  RSS {rss}", "YELLOW" if usage.peak_rss_bytes is not None else None),
+        (f"  children {child_count}", None),
+    ]
+    return _paint_fragments(fragments, width=width, enabled=color)
+
+
+def _phase_line(
+    phase: _TaskState,
+    *,
+    now: float,
+    active_children: int,
+    width: int,
+    color: bool,
+) -> str:
+    elapsed = phase.elapsed_seconds or max(
+        (phase.finished_at or now) - phase.started_at,
+        0.0,
+    )
+    total = phase.total
+    completed = min(phase.completed, total) if total is not None else phase.completed
+    count = str(completed) if total is None else f"{completed}/{total}"
+    if total and total > 0:
+        fraction = completed / total
+        bar_width = 20 if width >= 110 else 10
+        filled = min(bar_width, max(0, round(fraction * bar_width)))
+        bar = "[" + "#" * filled + "-" * (bar_width - filled) + "]"
+        percent = f" {fraction:>5.1%}"
+        eta = (
+            elapsed * (total - completed) / completed if completed > 0 else None
+        )
+    else:
+        bar = "[...]"
+        percent = ""
+        eta = None
+    active_text = f"  active {active_children}" if active_children else ""
+    fragments = [
+        (phase.description, "CYAN"),
+        (f"  {count} ", None),
+        (bar, "GREEN"),
+        (percent, None),
+        (f"  phase {_duration_text(elapsed)}", None),
+        (f"  ETA {_duration_text(eta)}" if eta is not None else "", None),
+        (active_text, None),
+    ]
+    return _paint_fragments(fragments, width=width, enabled=color)
+
+
+def _detail_line(
+    task: _TaskState,
+    *,
+    now: float,
+    width: int,
+    color: bool,
+) -> str:
+    details = _display_details(task)
+    process = details.get("process") or details.get("process_id")
+    step = details.get("step") or task.message or task.description
+    fragments: list[tuple[str, str | None]] = []
+    if process:
+        fragments.append((str(process), "CYAN"))
+        fragments.append(("  ", None))
+    step_color = (
+        "RED"
+        if task.success is False
+        else "GREEN"
+        if task.success is True
+        else "MAGENTA"
+    )
+    fragments.append((str(step), step_color))
+    backend = details.get("backend")
+    if backend:
+        fragments.append((f"  {backend}", "MAGENTA"))
+    stage_index = _detail_int(details, "stage_index")
+    stage_total = _detail_int(details, "stage_total")
+    subset_size = _detail_int(details, "subset_size")
+    if stage_index is not None:
+        stage = str(stage_index) + (f"/{stage_total}" if stage_total else "")
+        fragments.append(("  stage ", "MAGENTA"))
+        fragments.append((stage, "GREEN"))
+        if subset_size is not None:
+            fragments.append(("  subset ", "MAGENTA"))
+            fragments.append((str(subset_size), "GREEN"))
+    for label, current_key, total_key in (
+        ("masks", "mask_index", "mask_total"),
+        ("chunks", "chunk_index", "chunk_total"),
+        ("kernels", "kernel_index", "kernel_total"),
+        (
+            "parent pairs",
+            "candidate_parent_pair_count",
+            "candidate_parent_pair_total",
+        ),
+    ):
+        current = _detail_int(details, current_key)
+        total = _detail_int(details, total_key)
+        if current is not None:
+            fragments.append(
+                (f"  {label} {current}" + (f"/{total}" if total else ""), None)
+            )
+    for label, key in (
+        ("currents", "current_count"),
+        ("colour states", "dynamic_color_state_count"),
+        ("colour-pruned", "color_target_prune_count"),
+        ("sources", "source_count"),
+        ("colour sectors", "color_sector_count"),
+        ("interactions", "interaction_count"),
+        ("contributions", "contribution_count"),
+        ("amplitudes", "amplitude_count"),
+        ("invocations", "invocation_count"),
+        ("attachments", "attachment_count"),
+        ("finalizations", "finalization_count"),
+        ("closures", "closure_count"),
+        ("kernels", "kernel_count"),
+        ("files", "file_count"),
+        ("inputs", "input_count"),
+        ("outputs", "output_count"),
+    ):
+        value = _detail_int(details, key)
+        if value is not None:
+            fragments.append((f"  {label} {value:,}", None))
+    sample_index = _detail_int(details, "sample_index")
+    sample_total = _detail_int(details, "sample_total")
+    if sample_index is not None:
+        sample = str(sample_index) + (f"/{sample_total}" if sample_total else "")
+        fragments.append((f"  samples {sample}", None))
+    waiting = details.get("waiting_seconds")
+    if isinstance(waiting, (float, int)) and not isinstance(waiting, bool):
+        fragments.append((f"  waiting {_duration_text(float(waiting))}", "YELLOW"))
+    elif task.finished_at is None and now - task.updated_at >= 5.0:
+        fragments.append(
+            (f"  active {_duration_text(now - task.updated_at)}", "YELLOW")
+        )
+    native_current_rss = _detail_int(details, "native_current_rss_bytes")
+    native_peak_rss = _detail_int(details, "native_peak_rss_bytes")
+    if native_current_rss is not None or native_peak_rss is not None:
+        fragments.append(
+            (
+                "  self RSS " + _native_rss_text(native_current_rss, native_peak_rss),
+                "YELLOW",
+            )
+        )
+    return _paint_fragments(fragments, width=width, enabled=color)
+
+
+_CHUNK_DETAIL = re.compile(
+    r"\bchunk\s+(?P<index>\d+)/(?P<total>\d+)"
+    r"(?:\s+p=(?P<inputs>\d+)/(?:\d+))?\b",
+    re.IGNORECASE,
+)
+_EVALUATOR_DETAIL = re.compile(r"\bevaluator\s+\d+/(?P<outputs>\d+)\b", re.IGNORECASE)
+_WAITING_DETAIL = re.compile(
+    r"\bwaiting\s+(?P<seconds>\d+(?:\.\d+)?)s\b",
+    re.IGNORECASE,
+)
+
+
+def _display_details(task: _TaskState) -> dict[str, ProgressDetailValue]:
+    """Enrich legacy evaluator callbacks without changing their stable ABI."""
+
+    details = dict(task.details)
+    message = task.message or ""
+    chunk = _CHUNK_DETAIL.search(message)
+    if chunk is not None:
+        details.setdefault("chunk_index", int(chunk.group("index")))
+        details.setdefault("chunk_total", int(chunk.group("total")))
+        if chunk.group("inputs") is not None:
+            details.setdefault("input_count", int(chunk.group("inputs")))
+        details.setdefault("step", "chunk compilation")
+    evaluator = _EVALUATOR_DETAIL.search(message)
+    if evaluator is not None:
+        details.setdefault("output_count", int(evaluator.group("outputs")))
+        details.setdefault("step", "evaluator construction")
+    waiting = _WAITING_DETAIL.search(message)
+    if waiting is not None:
+        details.setdefault("waiting_seconds", float(waiting.group("seconds")))
+
+    stage = str(details.get("stage", "")).strip().lower()
+    backend = str(details.get("backend", "")).strip().lower()
+    if "step" not in details:
+        if stage.startswith("jit "):
+            details["step"] = f"JIT {stage.removeprefix('jit ')}"
+        elif stage.startswith("c++"):
+            details["step"] = (
+                "ASM compilation" if backend == "asm" else "C++ compilation"
+            )
+    return details
+
+
+def _detail_int(details: ProgressDetails, key: str) -> int | None:
+    value = details.get(key)
+    if isinstance(value, bool) or not isinstance(value, int):
+        return None
+    return value
+
+
+def _detail_float(details: ProgressDetails, key: str) -> float | None:
+    value = details.get(key)
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    result = float(value)
+    return result if math.isfinite(result) else None
+
+
+def _paint_fragments(
+    fragments: list[tuple[str, str | None]],
+    *,
+    width: int,
+    enabled: bool,
+) -> str:
+    remaining = max(width, 1)
+    rendered: list[str] = []
+    for text, color_name in fragments:
+        if not text or remaining <= 0:
+            continue
+        clipped = text
+        if len(clipped) > remaining:
+            suffix = "..." if remaining >= 3 else ""
+            clipped = clipped[: max(remaining - 3, 0)] + suffix
+        remaining -= len(clipped)
+        rendered.append(
+            _terminal_paint(clipped, color_name, enabled=enabled)
+            if color_name is not None
+            else clipped
+        )
+    return "".join(rendered)
+
+
+def _duration_text(seconds: float | None) -> str:
+    if seconds is None:
+        return "N/A"
+    rounded = max(int(seconds), 0)
+    hours, remainder = divmod(rounded, 3600)
+    minutes, secs = divmod(remainder, 60)
+    if hours:
+        return f"{hours:d}h{minutes:02d}m{secs:02d}s"
+    if minutes:
+        return f"{minutes:d}m{secs:02d}s"
+    return f"{secs:d}s"
+
+
+def _rss_text(usage: ResourceUsage, *, compact: bool = False) -> str:
+    if usage.current_rss_bytes is None or usage.peak_rss_bytes is None:
+        return "N/A"
+    gib = 1024**3
+    if compact:
+        return (
+            f"{usage.current_rss_bytes / gib:.2f}/"
+            f"{usage.peak_rss_bytes / gib:.2f}G"
+        )
+    return (
+        f"{usage.current_rss_bytes / gib:.2f}/"
+        f"{usage.peak_rss_bytes / gib:.2f} GiB current/peak"
+    )
+
+
+def _native_rss_text(current: int | None, peak: int | None) -> str:
+    gib = 1024**3
+    current_text = "N/A" if current is None else f"{current / gib:.2f}"
+    peak_text = "N/A" if peak is None else f"{peak / gib:.2f}"
+    return f"{current_text}/{peak_text} GiB current/peak"
+
+
+def _format_event(
+    event: ProgressEvent,
+    *,
+    description: str | None = None,
+    color: bool = False,
+) -> str:
+    if isinstance(event, ProgressStart):
+        result = _terminal_paint(event.description, "CYAN", enabled=color)
+        if event.total is not None:
+            result += (
+                " ("
+                + _terminal_paint(f"0/{event.total}", "MAGENTA", enabled=color)
+                + ")"
+            )
+        return result
+    label = description or event.task_id
+    if isinstance(event, ProgressUpdate):
+        count = (
+            f"{event.completed}/{event.total}"
+            if event.total is not None
+            else str(event.completed)
+        )
+        message = _benchmark_statistics_message(event.details, color=color)
+        if message is None:
+            message = event.message
+        suffix = f": {message}" if message else ""
+        context = _log_detail_text(event.details)
+        return (
+            _terminal_paint(label, "CYAN", enabled=color)
+            + " "
+            + _terminal_paint(count, "MAGENTA", enabled=color)
+            + suffix
+            + context
+        )
+    state = "done" if event.success else "failed"
+    state_color = "GREEN" if event.success else "RED"
+    suffix = (
+        ": " + _terminal_paint(event.message, state_color, enabled=color)
+        if event.message
+        else ""
+    )
+    elapsed = (
+        " in "
+        + _terminal_paint(
+            _duration_text(event.elapsed_seconds), "MAGENTA", enabled=color
+        )
+        if event.elapsed_seconds is not None
+        else ""
+    )
+    return (
+        _terminal_paint(label, "CYAN", enabled=color)
+        + " "
+        + _terminal_paint(state, state_color, enabled=color)
+        + elapsed
+        + suffix
+    )
+
+
+def _benchmark_statistics_message(
+    details: ProgressDetails,
+    *,
+    color: bool,
+) -> str | None:
+    """Render typed benchmark statistics without putting ANSI in backend events."""
+
+    if details.get("progress_kind") != "benchmark-statistics":
+        return None
+    elapsed = _detail_float(details, "elapsed_seconds")
+    target = _detail_float(details, "target_seconds")
+    mean = _detail_float(details, "wall_seconds_per_point")
+    repetitions = _detail_int(details, "repetitions")
+    batch_size = _detail_int(details, "batch_size")
+    sample_count = _detail_int(details, "sample_count")
+    if (
+        elapsed is None
+        or target is None
+        or mean is None
+        or repetitions is None
+        or batch_size is None
+        or sample_count is None
+        or min(elapsed, target, mean, repetitions, batch_size, sample_count) < 0
+    ):
+        return None
+    if mean < 1.0e-6:
+        scale, unit = 1.0e9, "ns"
+    elif mean < 1.0e-3:
+        scale, unit = 1.0e6, "us"
+    elif mean < 1.0:
+        scale, unit = 1.0e3, "ms"
+    else:
+        scale, unit = 1.0, "s"
+
+    result = _terminal_paint(f"{elapsed:.3g}/{target:.3g}s", "MAGENTA", enabled=color)
+    result += "; " + _terminal_paint("wall", "CYAN", enabled=color) + " "
+    result += _terminal_paint(
+        f"{mean * scale:.5g} {unit}/point", "GREEN", enabled=color
+    )
+    if sample_count < 2:
+        result += " " + _terminal_paint("SE pending", "YELLOW", enabled=color)
+    else:
+        error = _detail_float(details, "wall_standard_error_seconds_per_point")
+        relative_error = _detail_float(details, "wall_relative_standard_error")
+        if error is None or relative_error is None or min(error, relative_error) < 0:
+            return None
+        relative_color = (
+            "GREEN"
+            if relative_error <= 0.01
+            else "YELLOW"
+            if relative_error <= 0.05
+            else "RED"
+        )
+        result += " +/- " + _terminal_paint(
+            f"{error * scale:.2g} {unit}", "YELLOW", enabled=color
+        )
+        result += " (" + _terminal_paint(
+            "relative standard error", "CYAN", enabled=color
+        )
+        result += (
+            " "
+            + _terminal_paint(f"{relative_error:.2%}", relative_color, enabled=color)
+            + ")"
+        )
+    result += "; " + _terminal_paint(f"{repetitions} calls", "CYAN", enabled=color)
+    result += " x " + _terminal_paint(f"{batch_size} points", "CYAN", enabled=color)
+    return result
+
+
+def _log_detail_text(details: ProgressDetails) -> str:
+    fragments: list[str] = []
+    process = details.get("process") or details.get("process_id")
+    if process:
+        fragments.append(f"process={process}")
+    stage_index = _detail_int(details, "stage_index")
+    stage_total = _detail_int(details, "stage_total")
+    if stage_index is not None:
+        stage = str(stage_index) + (f"/{stage_total}" if stage_total else "")
+        fragments.append(f"stage={stage}")
+    for name in (
+        "subset_size",
+        "candidate_parent_pair_count",
+        "candidate_parent_pair_total",
+        "current_count",
+        "dynamic_color_state_count",
+        "color_target_prune_count",
+        "contribution_count",
+    ):
+        value = _detail_int(details, name)
+        if value is not None:
+            fragments.append(f"{name}={value}")
+    native_current_rss = _detail_int(details, "native_current_rss_bytes")
+    native_peak_rss = _detail_int(details, "native_peak_rss_bytes")
+    if native_current_rss is not None or native_peak_rss is not None:
+        fragments.append(
+            "self_rss=" + _native_rss_text(native_current_rss, native_peak_rss)
+        )
+    return "" if not fragments else " [" + " ".join(fragments) + "]"
+
+
+def close_progress_sink(sink: ProgressSink | None) -> None:
+    """Close an interactive sink without requiring custom sinks to implement it."""
+
+    close = getattr(sink, "close", None)
+    if callable(close):
+        close()
+
+
+def progress_sink(
+    mode: Literal["auto", "tty", "log", "off"],
+    *,
+    stream: TextIO,
+    logger: logging.Logger | None = None,
+    color: bool | None = None,
+) -> ProgressSink:
+    """Create a sink for the configured CLI progress mode."""
+
+    selected = mode
+    if selected == "auto":
+        selected = "tty" if bool(getattr(stream, "isatty", lambda: False)()) else "log"
+    if selected == "off":
+        return NullProgressSink()
+    if selected == "log":
+        return LoggingProgressSink(
+            logger or get_logger("progress"),
+            color=bool(color),
+        )
+    if selected == "tty":
+        return TtyProgressSink(stream, color=color)
+    raise ValueError(f"unknown progress mode {mode!r}")
+
+
+__all__ = [
+    "CallbackProgressSink",
+    "LoggingProgressSink",
+    "NullProgressSink",
+    "ProgressEnd",
+    "ProgressEvent",
+    "ProgressSink",
+    "ProgressStart",
+    "ProgressUpdate",
+    "StreamProgressSink",
+    "TtyProgressSink",
+    "close_progress_sink",
+    "progress_sink",
+]
diff --git a/pyamplicol/src/pyamplicol/reporting/resources.py b/pyamplicol/src/pyamplicol/reporting/resources.py
new file mode 100644
index 0000000000..ca2359a708
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/reporting/resources.py
@@ -0,0 +1,241 @@
+# SPDX-License-Identifier: 0BSD
+"""Portable, read-only process-tree resource sampling for live progress."""
+
+from __future__ import annotations
+
+import os
+import platform
+import subprocess
+import threading
+from collections import defaultdict
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class ResourceProbeError(RuntimeError):
+    """Raised when resident-memory information cannot be collected."""
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessInfo:
+    pid: int
+    ppid: int
+    rss_bytes: int
+
+
+@dataclass(frozen=True, slots=True)
+class ResourceUsage:
+    current_rss_bytes: int | None = None
+    peak_rss_bytes: int | None = None
+    process_count: int | None = None
+
+
+ProcessSnapshot = Callable[[], dict[int, ProcessInfo]]
+
+
+def _parse_proc_stat_ppid(text: str) -> int:
+    closing_parenthesis = text.rfind(")")
+    if closing_parenthesis < 0:
+        raise ValueError("missing process-name terminator")
+    fields = text[closing_parenthesis + 1 :].split()
+    if len(fields) < 2:
+        raise ValueError("incomplete /proc stat record")
+    return int(fields[1])
+
+
+def _parse_proc_status_rss(text: str) -> int:
+    for line in text.splitlines():
+        if not line.startswith("VmRSS:"):
+            continue
+        fields = line.split()
+        if len(fields) != 3 or fields[2].lower() != "kb":
+            raise ValueError(f"invalid VmRSS record: {line!r}")
+        return int(fields[1]) * 1024
+    return 0
+
+
+def _parse_ps_output(text: str) -> dict[int, ProcessInfo]:
+    records: dict[int, ProcessInfo] = {}
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        if not line.strip():
+            continue
+        fields = line.split()
+        if len(fields) != 3:
+            raise ValueError(f"invalid ps row {line_number}: {line!r}")
+        pid, ppid, rss_kib = map(int, fields)
+        if min(pid, ppid, rss_kib) < 0:
+            raise ValueError(f"negative ps value on row {line_number}")
+        records[pid] = ProcessInfo(pid, ppid, rss_kib * 1024)
+    return records
+
+
+def _linux_proc_snapshot(proc_root: Path = Path("/proc")) -> dict[int, ProcessInfo]:
+    records: dict[int, ProcessInfo] = {}
+    try:
+        entries = tuple(proc_root.iterdir())
+    except OSError as exc:
+        raise ResourceProbeError(f"cannot enumerate {proc_root}: {exc}") from exc
+    for entry in entries:
+        if not entry.name.isdecimal():
+            continue
+        try:
+            stat = (entry / "stat").read_text(encoding="utf-8", errors="replace")
+            status = (entry / "status").read_text(
+                encoding="utf-8", errors="replace"
+            )
+            pid = int(entry.name)
+            records[pid] = ProcessInfo(
+                pid=pid,
+                ppid=_parse_proc_stat_ppid(stat),
+                rss_bytes=_parse_proc_status_rss(status),
+            )
+        except (OSError, ValueError):
+            # Processes may disappear between enumeration and reading.
+            continue
+    if not records:
+        raise ResourceProbeError(f"{proc_root} yielded no readable processes")
+    return records
+
+
+def _ps_snapshot() -> dict[int, ProcessInfo]:
+    environment = os.environ.copy()
+    environment["LC_ALL"] = "C"
+    try:
+        probe = subprocess.Popen(
+            ["ps", "-axo", "pid=,ppid=,rss="],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env=environment,
+        )
+        stdout, stderr = probe.communicate(timeout=10)
+    except subprocess.TimeoutExpired as exc:
+        probe.kill()
+        probe.communicate()
+        raise ResourceProbeError("ps process probe timed out") from exc
+    except (OSError, subprocess.SubprocessError) as exc:
+        raise ResourceProbeError(f"cannot execute ps: {exc}") from exc
+    if probe.returncode != 0:
+        detail = stderr.strip() or f"exit code {probe.returncode}"
+        raise ResourceProbeError(f"ps process probe failed: {detail}")
+    try:
+        records = _parse_ps_output(stdout)
+    except ValueError as exc:
+        raise ResourceProbeError(str(exc)) from exc
+    # The sampling command is itself a short-lived descendant of pyAmpliCol.
+    records.pop(probe.pid, None)
+    if not records:
+        raise ResourceProbeError("ps process probe yielded no records")
+    return records
+
+
+def process_snapshot(system: str | None = None) -> dict[int, ProcessInfo]:
+    host = system or platform.system()
+    if host == "Linux":
+        try:
+            return _linux_proc_snapshot()
+        except ResourceProbeError:
+            return _ps_snapshot()
+    if host == "Darwin":
+        return _ps_snapshot()
+    raise ResourceProbeError(f"unsupported host for RSS monitoring: {host!r}")
+
+
+class ProcessTreeSampler:
+    """Sample one root and its descendants, retaining live re-parented children."""
+
+    def __init__(self, root_pid: int) -> None:
+        if root_pid < 1:
+            raise ValueError("resource sampler root PID must be positive")
+        self.root_pid = root_pid
+        self._known_pids = {root_pid}
+
+    def sample(self, records: dict[int, ProcessInfo]) -> tuple[int, int]:
+        children: dict[int, list[int]] = defaultdict(list)
+        for record in records.values():
+            children[record.ppid].append(record.pid)
+
+        selected = {pid for pid in self._known_pids if pid in records}
+        if self.root_pid in records:
+            selected.add(self.root_pid)
+        pending = list(selected)
+        while pending:
+            parent = pending.pop()
+            for child in children.get(parent, ()):
+                if child not in selected:
+                    selected.add(child)
+                    pending.append(child)
+
+        self._known_pids = selected
+        return sum(records[pid].rss_bytes for pid in selected), len(selected)
+
+
+class ResourceUsageMonitor:
+    """Sample aggregate RSS in a daemon thread without affecting generation."""
+
+    def __init__(
+        self,
+        *,
+        root_pid: int | None = None,
+        interval_seconds: float = 1.0,
+        snapshotter: ProcessSnapshot = process_snapshot,
+    ) -> None:
+        if interval_seconds <= 0:
+            raise ValueError("resource monitor interval must be positive")
+        self._sampler = ProcessTreeSampler(root_pid or os.getpid())
+        self._interval_seconds = float(interval_seconds)
+        self._snapshotter = snapshotter
+        self._usage = ResourceUsage()
+        self._lock = threading.Lock()
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    @property
+    def usage(self) -> ResourceUsage:
+        with self._lock:
+            return self._usage
+
+    def start(self) -> None:
+        if self._thread is not None:
+            return
+        self._sample_once()
+        self._thread = threading.Thread(
+            target=self._run,
+            name="pyamplicol-resource-monitor",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def close(self) -> None:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=max(2.0 * self._interval_seconds, 1.0))
+            self._thread = None
+
+    def _run(self) -> None:
+        while not self._stop.wait(self._interval_seconds):
+            self._sample_once()
+
+    def _sample_once(self) -> None:
+        try:
+            rss_bytes, process_count = self._sampler.sample(self._snapshotter())
+        except (OSError, ResourceProbeError, subprocess.SubprocessError, ValueError):
+            return
+        with self._lock:
+            peak = max(self._usage.peak_rss_bytes or 0, rss_bytes)
+            self._usage = ResourceUsage(
+                current_rss_bytes=rss_bytes,
+                peak_rss_bytes=peak,
+                process_count=process_count,
+            )
+
+
+__all__ = [
+    "ProcessInfo",
+    "ProcessTreeSampler",
+    "ResourceProbeError",
+    "ResourceUsage",
+    "ResourceUsageMonitor",
+    "process_snapshot",
+]
diff --git a/pyamplicol/src/pyamplicol/reporting/summary.py b/pyamplicol/src/pyamplicol/reporting/summary.py
new file mode 100644
index 0000000000..7b2b12aee3
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/reporting/summary.py
@@ -0,0 +1,3230 @@
+# SPDX-License-Identifier: 0BSD
+"""Compact PrettyTable summaries for human-facing CLI results."""
+
+from __future__ import annotations
+
+import importlib
+import math
+import re
+import textwrap
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, fields, is_dataclass
+from decimal import Decimal
+from fractions import Fraction
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+if TYPE_CHECKING:
+    from pyamplicol.api.results import (
+        BenchmarkComponentTiming,
+        BenchmarkProfileCounters,
+        BenchmarkResult,
+        BenchmarkStatistics,
+        ResolvedEvaluation,
+    )
+
+
+def _plain(value: object) -> object:
+    if is_dataclass(value) and not isinstance(value, type):
+        return {item.name: _plain(getattr(value, item.name)) for item in fields(value)}
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, Mapping):
+        return {str(key): _plain(entry) for key, entry in value.items()}
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        return [_plain(entry) for entry in value]
+    if isinstance(value, complex):
+        return {"real": value.real, "imag": value.imag}
+    return value
+
+
+def _value_text(value: object) -> str:
+    if value is None:
+        return "N/A"
+    if isinstance(value, bool):
+        return "yes" if value else "no"
+    if isinstance(value, Mapping):
+        if not value:
+            return "none"
+        scalar_items = tuple(
+            (str(key), entry)
+            for key, entry in value.items()
+            if not isinstance(entry, (Mapping, list, tuple))
+        )
+        if len(scalar_items) == len(value) and len(value) <= 4:
+            return "; ".join(
+                f"{key}={_value_text(entry)}" for key, entry in scalar_items
+            )
+        labels = ", ".join(str(key).replace("_", " ") for key in value)
+        return f"{len(value)} fields ({labels})"
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        entries = tuple(value)
+        if not entries:
+            return "none"
+        if all(not isinstance(entry, (Mapping, list, tuple)) for entry in entries):
+            return ", ".join(_value_text(entry) for entry in entries)
+        return f"{len(entries)} entries"
+    return str(value)
+
+
+def _evaluation_scalar_text(value: Decimal | float | int) -> str:
+    if value == 0:
+        return "0"
+    scientific = f"{value:.15e}"
+    if "e" not in scientific:
+        return scientific
+    mantissa, raw_exponent = scientific.rsplit("e", maxsplit=1)
+    return f"{mantissa}e{int(raw_exponent):+03d}"
+
+
+def _evaluation_value_text(value: complex | Decimal | float | int) -> str:
+    if isinstance(value, complex):
+        real = _evaluation_scalar_text(value.real)
+        if value.imag == 0.0:
+            return real
+        imaginary = f"{_evaluation_scalar_text(abs(value.imag))}j"
+        if value.real == 0.0:
+            return imaginary if value.imag > 0.0 else f"-{imaginary}"
+        sign = "+" if value.imag > 0.0 else "-"
+        return f"{real}{sign}{imaginary}"
+    return _evaluation_scalar_text(value)
+
+
+def _is_evaluation_value(value: object) -> bool:
+    return not isinstance(value, bool) and isinstance(
+        value, (complex, Decimal, float, int)
+    )
+
+
+def _total_evaluation_summary(
+    values: tuple[object, ...],
+    *,
+    prettytable: Any,
+    color: bool,
+    title: str = "Summed Evaluation",
+) -> str:
+    table = prettytable.PrettyTable(("point", "matrix element"))
+    table.title = _paint(title, "CYAN", enabled=color)
+    table.align["point"] = "r"
+    table.align["matrix element"] = "r"
+    table.hrules = prettytable.HRuleStyle.FRAME
+    for point, raw in enumerate(values):
+        if not _is_evaluation_value(raw):
+            raise TypeError("evaluation values must be numeric")
+        value = cast(complex | Decimal | float | int, raw)
+        table.add_row(
+            (
+                point,
+                _paint(
+                    _evaluation_value_text(value),
+                    "GREEN",
+                    enabled=color,
+                ),
+            )
+        )
+    return cast(str, table.get_string())
+
+
+def _resolved_evaluation_summary(
+    evaluation: ResolvedEvaluation,
+    *,
+    prettytable: Any,
+    color: bool,
+) -> str:
+    component_table = prettytable.PrettyTable(
+        ("point", "helicity", "color", "matrix element")
+    )
+    component_table.title = _paint(
+        f"Resolved Evaluation ({evaluation.color_accuracy.upper()})",
+        "CYAN",
+        enabled=color,
+    )
+    component_table.align["point"] = "r"
+    component_table.align["helicity"] = "l"
+    component_table.align["color"] = "l"
+    component_table.align["matrix element"] = "r"
+    component_table.hrules = prettytable.HRuleStyle.FRAME
+    for point, helicities in enumerate(evaluation.values):
+        for helicity, colors in zip(
+            evaluation.helicity_ids,
+            helicities,
+            strict=True,
+        ):
+            for color_id, value in zip(
+                evaluation.color_ids,
+                colors,
+                strict=True,
+            ):
+                component_table.add_row(
+                    (
+                        point,
+                        _paint(helicity, "CYAN", enabled=color),
+                        _paint(color_id, "MAGENTA", enabled=color),
+                        _paint(
+                            _evaluation_value_text(value),
+                            "GREEN",
+                            enabled=color,
+                        ),
+                    )
+                )
+    total_table = _total_evaluation_summary(
+        cast(tuple[object, ...], evaluation.total()),
+        prettytable=prettytable,
+        color=color,
+        title="Resolved Sum",
+    )
+    return f"{component_table.get_string()}\n\n{total_table}"
+
+
+def _colored(text: str, *, key: str, enabled: bool) -> str:
+    if not enabled:
+        return text
+    normalized = text.casefold()
+    try:
+        colorama: Any = importlib.import_module("colorama")
+    except ImportError:
+        return text
+    if normalized in {
+        "yes",
+        "ok",
+        "pass",
+        "passed",
+        "accepted",
+        "complete",
+        "completed",
+        "valid",
+        "verified",
+    }:
+        color = colorama.Fore.GREEN
+    elif normalized in {"no", "fail", "failed", "error", "invalid"}:
+        color = colorama.Fore.RED
+    elif normalized == "warning" or key.casefold() in {
+        "warning",
+        "warnings",
+        "adjustments",
+    }:
+        color = colorama.Fore.YELLOW
+    else:
+        return text
+    return f"{color}{text}{colorama.Style.RESET_ALL}"
+
+
+def _paint(
+    text: str, color_name: str | None, *, enabled: bool, bold: bool = False
+) -> str:
+    """Colour ``text``; ``None`` keeps the terminal colour, for bold-only text."""
+
+    if not enabled or not text or (color_name is None and not bold):
+        return text
+    try:
+        colorama: Any = importlib.import_module("colorama")
+    except ImportError:
+        return text
+    style = colorama.Style.BRIGHT if bold else ""
+    fore = "" if color_name is None else getattr(colorama.Fore, color_name)
+    return f"{style}{fore}{text}{colorama.Style.RESET_ALL}"
+
+
+def _integer(value: object, name: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{name} must be an integer")
+    return value
+
+
+def _byte_size(value: object) -> str:
+    size = _integer(value, "payload size")
+    units = ("B", "KiB", "MiB", "GiB")
+    amount = float(size)
+    for unit in units:
+        if amount < 1024.0 or unit == units[-1]:
+            return f"{amount:.0f} {unit}" if unit == "B" else f"{amount:.2f} {unit}"
+        amount /= 1024.0
+    raise AssertionError("unreachable byte-size unit")
+
+
+def _component_count(process: Mapping[str, object], prefix: str) -> str:
+    physical = _integer(process[f"physical_{prefix}"], f"physical {prefix}")
+    computed = _integer(process[f"computed_{prefix}"], f"computed {prefix}")
+    if physical == computed:
+        return str(physical)
+    return f"{physical} ({computed} eval.)"
+
+
+def _duration_unit(seconds: float) -> tuple[float, str]:
+    magnitude = abs(seconds)
+    if magnitude < 1.0e-6:
+        return 1.0e9, "ns"
+    if magnitude < 1.0e-3:
+        return 1.0e6, "us"
+    if magnitude < 1.0:
+        return 1.0e3, "ms"
+    return 1.0, "s"
+
+
+def _timing_text(
+    seconds: float,
+    uncertainty: BenchmarkStatistics,
+) -> str:
+    scale, unit = _duration_unit(seconds)
+    return (
+        f"{seconds * scale:.6g} +/- "
+        f"{uncertainty.standard_error * scale:.3g} {unit}/point (standard error)"
+    )
+
+
+def _benchmark_timing_text(
+    seconds: float,
+    uncertainty: BenchmarkStatistics,
+    *,
+    sample_count: int,
+) -> str:
+    if sample_count > 1:
+        return _timing_text(seconds, uncertainty)
+    return f"{_seconds_text(seconds)}/point (uncertainty needs at least 2 blocks)"
+
+
+def _seconds_text(seconds: float) -> str:
+    scale, unit = _duration_unit(seconds)
+    return f"{seconds * scale:.6g} {unit}"
+
+
+def _component_timing_text(timing: BenchmarkComponentTiming | None) -> str:
+    if timing is None:
+        return "N/A"
+    scale, unit = _duration_unit(timing.mean_seconds_per_point)
+    if timing.sample_count < 2:
+        return f"{timing.mean_seconds_per_point * scale:.6g} {unit}/point (SE pending)"
+    return (
+        f"{timing.mean_seconds_per_point * scale:.6g} +/- "
+        f"{timing.uncertainty.standard_error * scale:.3g} {unit}/point"
+    )
+
+
+def _component_timing_is_exact_zero(
+    timing: BenchmarkComponentTiming | None,
+) -> bool:
+    return (
+        timing is not None
+        and timing.mean_seconds_per_point == 0.0
+        and timing.uncertainty.standard_deviation == 0.0
+        and timing.uncertainty.standard_error == 0.0
+        and timing.uncertainty.relative_standard_error == 0.0
+    )
+
+
+def _component_timings_are_exact_zero(
+    timings: tuple[BenchmarkComponentTiming | None, ...],
+) -> bool:
+    return all(_component_timing_is_exact_zero(timing) for timing in timings)
+
+
+def _counter_mean_text(value: float, unit: str) -> str:
+    rounded = round(value)
+    number = (
+        f"{rounded:,}"
+        if math.isclose(value, rounded, rel_tol=0.0, abs_tol=1.0e-12)
+        else f"{value:,.6g}"
+    )
+    return f"{number} {unit}"
+
+
+def _profile_counter_rows(
+    counters: BenchmarkProfileCounters,
+) -> tuple[tuple[str, str, float, str, str], ...]:
+    definitions = (
+        (
+            "native input",
+            "input components",
+            counters.native_input_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "native input",
+            "packed input",
+            counters.native_input_pack_bytes_per_point,
+            "bytes",
+            "per point",
+        ),
+        (
+            "native input",
+            "crossed input",
+            counters.native_input_crossing_bytes_per_point,
+            "bytes",
+            "per point",
+        ),
+        (
+            "native input",
+            "input containers",
+            counters.native_input_container_allocations_per_call,
+            "allocations",
+            "per runtime call",
+        ),
+        (
+            "state setup",
+            "state extent",
+            counters.state_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "state setup",
+            "state clear",
+            counters.state_clear_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "state setup",
+            "source fill",
+            counters.source_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "state setup",
+            "momentum fill",
+            counters.momentum_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "state setup",
+            "model parameter fill",
+            counters.model_parameter_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "compiled stages",
+            "stage input copy",
+            counters.stage_input_copy_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "compiled stages",
+            "stage leaf copy",
+            counters.stage_leaf_input_copy_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "compiled stages",
+            "stage output gather",
+            counters.stage_evaluator_output_gather_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "compiled stages",
+            "stage output assign",
+            counters.stage_output_assign_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "amplitude",
+            "amplitude input copy",
+            counters.amplitude_input_copy_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "amplitude",
+            "amplitude leaf copy",
+            counters.amplitude_leaf_input_copy_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "amplitude",
+            "amplitude output gather",
+            counters.amplitude_evaluator_output_gather_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "amplitude",
+            "amplitude output remap",
+            counters.amplitude_output_remap_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "backend",
+            "evaluator backend calls",
+            counters.evaluator_backend_calls_per_call,
+            "calls",
+            "per runtime call",
+        ),
+        (
+            "compiled Direct-Arena",
+            "Arena engines",
+            counters.compiled_direct_arena_engines_per_call,
+            "engines",
+            "per runtime call",
+        ),
+        (
+            "compiled Direct-Arena",
+            "Arena calls",
+            counters.compiled_direct_arena_calls_per_call,
+            "calls",
+            "per runtime call",
+        ),
+        (
+            "compiled Direct-Arena",
+            "boundary input",
+            counters.compiled_direct_arena_boundary_input_bytes_per_call,
+            "bytes",
+            "per runtime call",
+        ),
+        (
+            "compiled Direct-Arena",
+            "boundary current output",
+            counters.compiled_direct_arena_boundary_current_output_bytes_per_call,
+            "bytes",
+            "per runtime call",
+        ),
+        (
+            "compiled Direct-Arena",
+            "boundary amplitude output",
+            counters.compiled_direct_arena_boundary_amplitude_output_bytes_per_call,
+            "bytes",
+            "per runtime call",
+        ),
+        (
+            "recurrence",
+            "momentum scalar fill",
+            counters.recurrence_momentum_scalar_values_per_point,
+            "values",
+            "per point",
+        ),
+        (
+            "recurrence",
+            "schedule executions",
+            counters.recurrence_schedule_executions_per_call,
+            "executions",
+            "per runtime call",
+        ),
+        (
+            "recurrence",
+            "replay schedule executions",
+            counters.recurrence_replay_schedule_executions_per_call,
+            "executions",
+            "per runtime call",
+        ),
+        (
+            "recurrence",
+            "union schedule executions",
+            counters.recurrence_union_schedule_executions_per_call,
+            "executions",
+            "per runtime call",
+        ),
+        (
+            "recurrence",
+            "union source rows",
+            counters.recurrence_union_source_rows_per_call,
+            "rows",
+            "per runtime call",
+        ),
+        (
+            "recurrence",
+            "replay output mapping",
+            counters.recurrence_replay_output_values_per_point,
+            "values",
+            "per point",
+        ),
+        (
+            "recurrence kernels",
+            "source calls",
+            counters.recurrence_source_calls_per_call,
+            "calls",
+            "per runtime call",
+        ),
+        (
+            "recurrence kernels",
+            "source rows",
+            counters.recurrence_source_rows_per_call,
+            "rows",
+            "per runtime call",
+        ),
+        (
+            "recurrence kernels",
+            "contribution calls",
+            counters.recurrence_contribution_calls_per_call,
+            "calls",
+            "per runtime call",
+        ),
+        (
+            "recurrence kernels",
+            "contribution rows",
+            counters.recurrence_contribution_rows_per_call,
+            "rows",
+            "per runtime call",
+        ),
+        (
+            "recurrence kernels",
+            "finalization calls",
+            counters.recurrence_finalization_calls_per_call,
+            "calls",
+            "per runtime call",
+        ),
+        (
+            "recurrence kernels",
+            "finalization rows",
+            counters.recurrence_finalization_rows_per_call,
+            "rows",
+            "per runtime call",
+        ),
+        (
+            "recurrence kernels",
+            "closure calls",
+            counters.recurrence_closure_calls_per_call,
+            "calls",
+            "per runtime call",
+        ),
+        (
+            "recurrence kernels",
+            "closure rows",
+            counters.recurrence_closure_rows_per_call,
+            "rows",
+            "per runtime call",
+        ),
+        (
+            "reduction",
+            "reduction input",
+            counters.reduction_input_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "selectors",
+            "gathered rows",
+            counters.selector_gather_points_per_point,
+            "points",
+            "per point",
+        ),
+        (
+            "selectors",
+            "gathered input",
+            counters.selector_gather_bytes_per_point,
+            "bytes",
+            "per point",
+        ),
+        (
+            "selectors",
+            "scattered output",
+            counters.selector_scatter_values_per_point,
+            "values",
+            "per point",
+        ),
+        (
+            "materialization",
+            "resolved components",
+            counters.resolved_materialized_components_per_point,
+            "components",
+            "per point",
+        ),
+        (
+            "materialization",
+            "total values",
+            counters.total_materialized_values_per_point,
+            "values",
+            "per point",
+        ),
+        (
+            "materialization",
+            "final output copy",
+            counters.final_output_copy_values_per_point,
+            "values",
+            "per point",
+        ),
+        (
+            "allocations",
+            "observed scratch reallocations",
+            counters.observed_scratch_reallocations_per_call,
+            "reallocations",
+            "per runtime call",
+        ),
+        (
+            "allocations",
+            "native output vectors",
+            counters.native_output_allocations_per_call,
+            "allocations",
+            "per runtime call",
+        ),
+    )
+    return tuple(
+        (area, label, value, unit, basis)
+        for area, label, value, unit, basis in definitions
+        if value is not None
+    )
+
+
+def _benchmark_summary(
+    result: BenchmarkResult,
+    *,
+    prettytable: Any,
+    color: bool,
+) -> str:
+    environment = result.environment
+    process = result.process_id or "N/A"
+    if result.process_expression is not None:
+        process = f"{process} ({result.process_expression})"
+    elapsed_value = environment.get("elapsed_seconds")
+    elapsed = (
+        float(elapsed_value)
+        if isinstance(elapsed_value, (float, int))
+        and not isinstance(elapsed_value, bool)
+        else None
+    )
+    evaluator_source = str(environment.get("evaluator_time_source", "unavailable"))
+    evaluator_total_source = str(
+        environment.get("evaluator_total_time_source", "unavailable")
+    )
+    timing_sample_contract = str(
+        environment.get("timing_sample_contract", "unavailable")
+    )
+    shared_timing_samples = timing_sample_contract in {
+        "shared_native_repeated_profile_v1",
+        "shared_native_single_profile_v1",
+    }
+    paired_timing_samples = (
+        timing_sample_contract == "paired_unprofiled_headline_profiled_attribution_v1"
+    )
+    separate_timing_samples = paired_timing_samples or (
+        timing_sample_contract == "separate_native_profile_diagnostic_v1"
+    )
+    evaluator_sample_value = environment.get("evaluator_sample_count")
+    evaluator_sample_count = (
+        int(evaluator_sample_value)
+        if isinstance(evaluator_sample_value, int)
+        and not isinstance(evaluator_sample_value, bool)
+        and evaluator_sample_value > 0
+        else result.sample_count
+    )
+    evaluator_text = "N/A"
+    if result.evaluator_time_per_point is not None:
+        if result.evaluator_uncertainty is None:
+            evaluator_text = f"{_seconds_text(result.evaluator_time_per_point)}/point"
+        else:
+            evaluator_text = _benchmark_timing_text(
+                result.evaluator_time_per_point,
+                result.evaluator_uncertainty,
+                sample_count=evaluator_sample_count,
+            )
+    evaluator_total_text = "N/A"
+    if result.evaluator_total_time_per_point is not None:
+        evaluator_total_text = (
+            f"{_seconds_text(result.evaluator_total_time_per_point)}/point"
+        )
+
+    relative_error = result.uncertainty.relative_standard_error
+    if relative_error <= 0.01:
+        uncertainty_color = "GREEN"
+    elif relative_error <= 0.05:
+        uncertainty_color = "YELLOW"
+    else:
+        uncertainty_color = "RED"
+    status = (
+        f"interrupted - partial statistics from {result.sample_count} complete blocks"
+        if result.interrupted
+        else "complete"
+    )
+    breakdown = result.timing_breakdown
+    recurrence_timing = (
+        breakdown is not None and breakdown.execution_mode == "recurrence"
+    ) or environment.get("execution_mode") == "recurrence"
+    on_the_fly_timing = (
+        breakdown is not None and breakdown.execution_mode == "on-the-fly"
+    ) or environment.get("execution_mode") == "on-the-fly"
+    direct_arena_timing = environment.get("compiled_direct_arena_active") is True
+    if recurrence_timing:
+        profile_metric_label = "recurrence core"
+    elif on_the_fly_timing:
+        profile_metric_label = "OTF recurrence-schedule core"
+    elif direct_arena_timing:
+        profile_metric_label = "Direct-Arena runtime envelope"
+    else:
+        profile_metric_label = "evaluator core"
+    profile_repetitions_value = environment.get("native_profile_repetitions_per_sample")
+    profile_repetitions = (
+        int(profile_repetitions_value)
+        if isinstance(profile_repetitions_value, int)
+        and not isinstance(profile_repetitions_value, bool)
+        and profile_repetitions_value > 0
+        else (result.repetitions_per_sample if shared_timing_samples else 1)
+    )
+    profile_points_value = environment.get("native_profile_points_per_sample")
+    profile_points = (
+        int(profile_points_value)
+        if isinstance(profile_points_value, int)
+        and not isinstance(profile_points_value, bool)
+        and profile_points_value > 0
+        else profile_repetitions * result.effective_config.batch_size
+    )
+    warmup_elapsed_value = environment.get("warmup_elapsed_seconds")
+    warmup_elapsed = (
+        float(warmup_elapsed_value)
+        if isinstance(warmup_elapsed_value, (float, int))
+        and not isinstance(warmup_elapsed_value, bool)
+        and math.isfinite(float(warmup_elapsed_value))
+        and float(warmup_elapsed_value) >= 0.0
+        else None
+    )
+    first_warmup_value = environment.get("first_warmup_run_outer_wall_seconds")
+    first_warmup = (
+        float(first_warmup_value)
+        if isinstance(first_warmup_value, (float, int))
+        and not isinstance(first_warmup_value, bool)
+        and math.isfinite(float(first_warmup_value))
+        and float(first_warmup_value) >= 0.0
+        else None
+    )
+    cold_warmup_value = environment.get("cold_warmup_elapsed_seconds")
+    cold_warmup = (
+        float(cold_warmup_value)
+        if isinstance(cold_warmup_value, (float, int))
+        and not isinstance(cold_warmup_value, bool)
+        and math.isfinite(float(cold_warmup_value))
+        and float(cold_warmup_value) >= 0.0
+        else None
+    )
+    warmup_runs_value = environment.get("warmup_configured_run_count")
+    warmup_runs = (
+        int(warmup_runs_value)
+        if isinstance(warmup_runs_value, int)
+        and not isinstance(warmup_runs_value, bool)
+        and warmup_runs_value >= 0
+        else result.effective_config.warmup_runs
+    )
+    warmup_batch_value = environment.get("warmup_batch_size")
+    warmup_batch = (
+        int(warmup_batch_value)
+        if isinstance(warmup_batch_value, int)
+        and not isinstance(warmup_batch_value, bool)
+        and warmup_batch_value > 0
+        else result.effective_config.batch_size
+    )
+    warmup_point_value = environment.get("warmup_point_count")
+    warmup_points = (
+        int(warmup_point_value)
+        if isinstance(warmup_point_value, int)
+        and not isinstance(warmup_point_value, bool)
+        and warmup_point_value >= 0
+        else warmup_runs * warmup_batch
+    )
+    cold_warmup_batch_value = environment.get("cold_warmup_batch_size")
+    cold_warmup_batch = (
+        int(cold_warmup_batch_value)
+        if isinstance(cold_warmup_batch_value, int)
+        and not isinstance(cold_warmup_batch_value, bool)
+        and cold_warmup_batch_value > 0
+        else warmup_batch
+    )
+    warmup_rows: list[tuple[str, str, str | None]] = []
+    state_evidence = environment.get("cold_warmup_runtime_state_evidence")
+    runtime_was_cold = environment.get(
+        "cold_warmup_runtime_cold_before_first_evaluation"
+    )
+    runtime_was_retained = environment.get(
+        "cold_warmup_runtime_retained_before_first_evaluation"
+    )
+    runtime_is_retained = environment.get(
+        "cold_warmup_runtime_retained_after_first_evaluation"
+    )
+    if (
+        state_evidence == "authenticated-native-otf-census-v1"
+        and isinstance(runtime_was_cold, bool)
+        and isinstance(runtime_was_retained, bool)
+        and isinstance(runtime_is_retained, bool)
+    ):
+        before_state = (
+            "cold"
+            if runtime_was_cold
+            else "strictly retained"
+            if runtime_was_retained
+            else "partial"
+        )
+        after_state = "strictly retained" if runtime_is_retained else "partial"
+        warmup_rows.append(
+            (
+                "OTF runtime state",
+                f"authenticated native census: {before_state} -> {after_state}",
+                "GREEN" if runtime_is_retained else "RED",
+            )
+        )
+        state_before = environment.get("cold_warmup_runtime_state_before")
+        state_after = environment.get("cold_warmup_runtime_state_after")
+        if isinstance(state_before, Mapping) and isinstance(state_after, Mapping):
+            cache_policy = state_after.get("family_cache_policy")
+            cache_limit = state_after.get("family_cache_limit")
+            before_families = state_before.get("retained_family_count")
+            after_families = state_after.get("retained_family_count")
+            if (
+                isinstance(cache_policy, str)
+                and isinstance(cache_limit, int)
+                and not isinstance(cache_limit, bool)
+                and isinstance(before_families, int)
+                and not isinstance(before_families, bool)
+                and isinstance(after_families, int)
+                and not isinstance(after_families, bool)
+            ):
+                warmup_rows.append(
+                    (
+                        "OTF family cache",
+                        (
+                            f"{cache_policy}; limit {cache_limit}; retained families "
+                            f"{before_families} -> {after_families}"
+                        ),
+                        "GREEN",
+                    )
+                )
+    if cold_warmup is not None:
+        warmup_rows.append(
+            (
+                "OTF initial preparation",
+                (
+                    f"{_seconds_text(cold_warmup)} outer wall for 1 requested-selector "
+                    f"evaluation x {cold_warmup_batch} points; Runtime/artifact load "
+                    "excluded"
+                ),
+                "YELLOW",
+            )
+        )
+    if warmup_elapsed is not None:
+        warmup_rows.append(
+            (
+                "warm-up wall (total)",
+                (
+                    f"{_seconds_text(warmup_elapsed)} across {warmup_runs} configured "
+                    f"runs x {warmup_batch} points ({warmup_points} primary points)"
+                ),
+                "YELLOW",
+            )
+        )
+    if first_warmup is not None:
+        warmup_rows.append(
+            (
+                "first warm-up run",
+                f"{_seconds_text(first_warmup)} outer wall",
+                "YELLOW",
+            )
+        )
+    wall_pass = _value_text(environment.get("wall_time_sample_pass"))
+    evaluator_pass = _value_text(environment.get("evaluator_time_sample_pass"))
+    rows: list[tuple[str, str, str | None]] = [
+        ("process", process, None),
+        ("artifact", _value_text(environment.get("target")), None),
+        ("execution mode", _value_text(environment.get("execution_mode")), "CYAN"),
+        ("color workload", _value_text(environment.get("color_workload")), None),
+        (
+            "helicity workload",
+            _value_text(environment.get("helicity_workload")),
+            None,
+        ),
+        ("status", status, "YELLOW" if result.interrupted else "GREEN"),
+        *warmup_rows,
+        (
+            "outer wall",
+            _benchmark_timing_text(
+                result.wall_time_per_point,
+                result.uncertainty,
+                sample_count=result.sample_count,
+            ),
+            "GREEN",
+        ),
+        (
+            "evaluator total",
+            evaluator_total_text,
+            "CYAN",
+        ),
+        (
+            profile_metric_label,
+            evaluator_text,
+            "CYAN",
+        ),
+        (
+            "wall variability",
+            (
+                (
+                    f"SD {_seconds_text(result.uncertainty.standard_deviation)}/point; "
+                    f"relative standard error {relative_error:.3%}"
+                )
+                if result.sample_count > 1
+                else "not estimable from one complete block"
+            ),
+            uncertainty_color if result.sample_count > 1 else "YELLOW",
+        ),
+        (
+            "sampling",
+            (
+                f"{result.sample_count} blocks x "
+                f"{result.repetitions_per_sample} repetitions x "
+                f"{result.effective_config.batch_size} points"
+            ),
+            None,
+        ),
+        ("timed evaluations", str(result.evaluation_count), None),
+        ("timed points", str(result.evaluated_point_count), None),
+        (
+            "target / measured",
+            (
+                f"{result.effective_config.target_runtime:.6g} s / {elapsed:.6g} s"
+                if elapsed is not None
+                else f"{result.effective_config.target_runtime:.6g} s / N/A"
+            ),
+            None,
+        ),
+        ("precision", str(result.effective_config.precision), None),
+        (
+            "timing sources",
+            (
+                "outer wall="
+                f"{environment.get('wall_time_source', 'unavailable')} "
+                f"via {wall_pass}; evaluator total={evaluator_total_source}; "
+                f"{profile_metric_label}={evaluator_source} via {evaluator_pass}"
+            ),
+            None,
+        ),
+        (
+            "sample provenance",
+            (
+                (
+                    f"one shared native pass: {result.sample_count} blocks x "
+                    f"{profile_repetitions} repetitions x "
+                    f"{result.effective_config.batch_size} points; outer wall, "
+                    f"evaluator total, {profile_metric_label}, and breakdown "
+                    "use the same blocks"
+                )
+                if shared_timing_samples
+                else (
+                    f"paired passes: unprofiled headline {result.sample_count} "
+                    f"blocks x {result.repetitions_per_sample} repetitions x "
+                    f"{result.effective_config.batch_size} points provides outer "
+                    "wall and evaluator total; profiled "
+                    f"{profile_metric_label} attribution uses "
+                    f"{breakdown.sample_count} paired blocks with the identical "
+                    "batch and repetition count"
+                    if paired_timing_samples and breakdown is not None
+                    else (
+                        f"separate passes: headline outer wall and evaluator total "
+                        f"{result.sample_count} "
+                        f"blocks x {result.repetitions_per_sample} repetitions x "
+                        f"{result.effective_config.batch_size} points; "
+                        f"{profile_metric_label} and breakdown "
+                        f"{breakdown.sample_count} diagnostic blocks x "
+                        f"{profile_repetitions} repetitions "
+                        f"({profile_points} points/block)"
+                        if timing_sample_contract
+                        == "separate_native_profile_diagnostic_v1"
+                        and breakdown is not None
+                        else "no native timing breakdown available"
+                    )
+                )
+            ),
+            "YELLOW" if separate_timing_samples else None,
+        ),
+        ("platform", _value_text(environment.get("platform")), None),
+    ]
+
+    table = prettytable.PrettyTable(("metric", "value"))
+    table.title = _paint("Runtime Profile", "CYAN", enabled=color)
+    table.align["metric"] = "l"
+    table.align["value"] = "l"
+    table.max_width["metric"] = 24
+    table.max_width["value"] = 96
+    table.hrules = prettytable.HRuleStyle.FRAME
+    for metric, value, color_name in rows:
+        table.add_row(
+            (
+                metric,
+                _paint(value, color_name, enabled=color)
+                if color_name is not None
+                else value,
+            )
+        )
+    sections = [cast(str, table.get_string())]
+    if breakdown is None:
+        return sections[0]
+
+    component_table = prettytable.PrettyTable(
+        ("component", "mean +/- standard error", "relative standard error")
+    )
+    eager_profile = breakdown.execution_mode == "eager"
+    recurrence_profile = breakdown.execution_mode == "recurrence"
+    on_the_fly_profile = breakdown.execution_mode == "on-the-fly"
+    if eager_profile:
+        breakdown_title = "Rusticol Eager Timing Breakdown"
+    elif recurrence_profile:
+        breakdown_title = "Rusticol Recurrence Timing Breakdown"
+    elif on_the_fly_profile:
+        breakdown_title = "Rusticol OTF Recurrence-Schedule Timing Breakdown"
+    else:
+        breakdown_title = "Rusticol Timing Breakdown"
+    if separate_timing_samples:
+        breakdown_title += (
+            " (paired profiled attribution)"
+            if paired_timing_samples
+            else " (separate diagnostic samples)"
+        )
+    component_table.title = _paint(
+        breakdown_title,
+        "CYAN",
+        enabled=color,
+    )
+    component_table.align["component"] = "l"
+    component_table.align["mean +/- standard error"] = "r"
+    component_table.align["relative standard error"] = "r"
+    component_table.hrules = prettytable.HRuleStyle.FRAME
+    detailed_eager_profile = eager_profile and any(
+        timing is not None
+        for timing in (
+            breakdown.eager_gather_time,
+            breakdown.eager_kernel_call_time,
+            breakdown.eager_invocation_scatter_time,
+            breakdown.eager_finalization_time,
+            breakdown.eager_scatter_finalization_time,
+            breakdown.eager_closure_time,
+            breakdown.eager_initialize_time,
+            breakdown.eager_copy_out_time,
+        )
+    )
+    momentum_input_setup_time = (
+        breakdown.momentum_input_setup_time or breakdown.momentum_setup_time
+    )
+    orchestration_component_label = (
+        "Direct-Arena runtime envelope"
+        if direct_arena_timing
+        else "Runtime orchestration"
+    )
+    component_rows: tuple[tuple[str, BenchmarkComponentTiming | None], ...]
+    if detailed_eager_profile:
+        eager_phase_rows: tuple[tuple[str, BenchmarkComponentTiming | None], ...]
+        if (
+            breakdown.eager_invocation_scatter_time is not None
+            or breakdown.eager_finalization_time is not None
+        ):
+            eager_phase_rows = (
+                (
+                    "Invocation scatter (exclusive)",
+                    breakdown.eager_invocation_scatter_time,
+                ),
+                (
+                    "Current finalization (exclusive)",
+                    breakdown.eager_finalization_time,
+                ),
+            )
+        else:
+            eager_phase_rows = (
+                (
+                    "Scatter / finalization (exclusive)",
+                    breakdown.eager_scatter_finalization_time,
+                ),
+            )
+        component_rows = (
+            (
+                "Profile wall (headline)"
+                if shared_timing_samples
+                else (
+                    "Profile wall (paired profiled pass)"
+                    if paired_timing_samples
+                    else "Profile wall (diagnostic pass)"
+                ),
+                breakdown.wall_time,
+            ),
+            ("Native input pack (exclusive)", breakdown.native_input_pack_time),
+            (
+                "Native input crossing (exclusive)",
+                breakdown.native_input_crossing_time,
+            ),
+            ("Runtime orchestration (exclusive)", breakdown.orchestration_time),
+            ("State prepare (exclusive)", breakdown.state_prepare_time),
+            ("State clear (exclusive)", breakdown.state_clear_time),
+            ("Source fill (exclusive)", breakdown.source_fill_time),
+            (
+                "Momentum input setup (exclusive)",
+                momentum_input_setup_time,
+            ),
+            (
+                "Model parameter setup (exclusive)",
+                breakdown.model_parameter_setup_time,
+            ),
+            ("Eager execution (inclusive)", breakdown.eager_execution_time),
+            ("Initialize (exclusive)", breakdown.eager_initialize_time),
+            ("Gather (exclusive)", breakdown.eager_gather_time),
+            ("Kernel calls (exclusive)", breakdown.eager_kernel_call_time),
+            *eager_phase_rows,
+            ("Amplitude closure (exclusive)", breakdown.eager_closure_time),
+            ("Amplitude copy-out (exclusive)", breakdown.eager_copy_out_time),
+            ("Reduction (exclusive)", breakdown.reduction_time),
+            (
+                "Total materialization (exclusive)",
+                breakdown.total_materialization_time,
+            ),
+            ("Final output copy (exclusive)", breakdown.final_output_copy_time),
+            ("Selector planning (exclusive)", breakdown.selector_planner_time),
+            ("Selector gather (exclusive)", breakdown.selector_gather_time),
+            ("Selector scatter (exclusive)", breakdown.selector_scatter_time),
+            ("Other Rusticol core (exclusive)", breakdown.other_core_time),
+        )
+    elif eager_profile:
+        component_rows = (
+            (
+                "Profile wall (headline)"
+                if shared_timing_samples
+                else (
+                    "Profile wall (paired profiled pass)"
+                    if paired_timing_samples
+                    else "Profile wall (diagnostic pass)"
+                ),
+                breakdown.wall_time,
+            ),
+            ("Native input pack (exclusive)", breakdown.native_input_pack_time),
+            (
+                "Native input crossing (exclusive)",
+                breakdown.native_input_crossing_time,
+            ),
+            ("Runtime orchestration (exclusive)", breakdown.orchestration_time),
+            ("State prepare (exclusive)", breakdown.state_prepare_time),
+            ("State clear (exclusive)", breakdown.state_clear_time),
+            ("Source fill (exclusive)", breakdown.source_fill_time),
+            (
+                "Momentum input setup (exclusive)",
+                momentum_input_setup_time,
+            ),
+            (
+                "Model parameter setup (exclusive)",
+                breakdown.model_parameter_setup_time,
+            ),
+            ("Eager execution (inclusive)", breakdown.eager_execution_time),
+            (
+                "Total materialization (exclusive)",
+                breakdown.total_materialization_time,
+            ),
+            ("Final output copy (exclusive)", breakdown.final_output_copy_time),
+            ("Selector planning (exclusive)", breakdown.selector_planner_time),
+            ("Selector gather (exclusive)", breakdown.selector_gather_time),
+            ("Selector scatter (exclusive)", breakdown.selector_scatter_time),
+            ("Other Rusticol core (exclusive)", breakdown.other_core_time),
+        )
+    elif recurrence_profile or on_the_fly_profile:
+        recurrence_schedule_label = (
+            "OTF recurrence schedule (inclusive)"
+            if on_the_fly_profile
+            else "Recurrence schedule (inclusive)"
+        )
+        component_rows = (
+            (
+                "Profile wall (headline)"
+                if shared_timing_samples
+                else (
+                    "Profile wall (paired profiled pass)"
+                    if paired_timing_samples
+                    else "Profile wall (diagnostic pass)"
+                ),
+                breakdown.wall_time,
+            ),
+            ("Native input pack (exclusive)", breakdown.native_input_pack_time),
+            (
+                "Native input crossing (exclusive)",
+                breakdown.native_input_crossing_time,
+            ),
+            ("Runtime orchestration (exclusive)", breakdown.orchestration_time),
+            ("State prepare (exclusive)", breakdown.state_prepare_time),
+            ("State clear (exclusive)", breakdown.state_clear_time),
+            ("Source preparation (exclusive)", breakdown.source_fill_time),
+            (
+                "External momentum flatten (exclusive)",
+                momentum_input_setup_time,
+            ),
+            (
+                "Model parameter setup (exclusive)",
+                breakdown.model_parameter_setup_time,
+            ),
+            (
+                "Momentum-form fill (exclusive)",
+                breakdown.recurrence_momentum_fill_time,
+            ),
+            (
+                "Union source fill (exclusive)",
+                breakdown.recurrence_union_source_fill_time,
+            ),
+            (
+                recurrence_schedule_label,
+                breakdown.recurrence_schedule_time,
+            ),
+            (
+                "Source kernels (schedule attribution; do not add)",
+                breakdown.recurrence_source_kernel_time,
+            ),
+            (
+                "Contribution kernels (schedule attribution; do not add)",
+                breakdown.recurrence_contribution_kernel_time,
+            ),
+            (
+                "Current finalization (schedule attribution; do not add)",
+                breakdown.recurrence_finalization_time,
+            ),
+            (
+                "Amplitude closure (schedule attribution; do not add)",
+                breakdown.recurrence_closure_time,
+            ),
+            (
+                "Replay output mapping (exclusive)",
+                breakdown.recurrence_replay_output_mapping_time,
+            ),
+            ("Reduction (exclusive)", breakdown.reduction_time),
+            (
+                "Total materialization (exclusive)",
+                breakdown.total_materialization_time,
+            ),
+            ("Final output copy (exclusive)", breakdown.final_output_copy_time),
+            ("Selector planning (exclusive)", breakdown.selector_planner_time),
+            ("Selector gather (exclusive)", breakdown.selector_gather_time),
+            ("Selector scatter (exclusive)", breakdown.selector_scatter_time),
+            ("Other Rusticol core (exclusive)", breakdown.other_core_time),
+        )
+    else:
+        component_rows = (
+            (
+                "Profile wall (headline)"
+                if shared_timing_samples
+                else (
+                    "Profile wall (paired profiled pass)"
+                    if paired_timing_samples
+                    else "Profile wall (diagnostic pass)"
+                ),
+                breakdown.wall_time,
+            ),
+            ("Native input pack", breakdown.native_input_pack_time),
+            ("Native input crossing", breakdown.native_input_crossing_time),
+            (orchestration_component_label, breakdown.orchestration_time),
+            ("State prepare", breakdown.state_prepare_time),
+            ("State clear", breakdown.state_clear_time),
+            ("Source fill", breakdown.source_fill_time),
+            ("Momentum input setup", momentum_input_setup_time),
+            ("Model parameter setup", breakdown.model_parameter_setup_time),
+            ("Stage input pack (top-level)", breakdown.stage_input_pack_time),
+            (
+                "Stage evaluator envelope (top-level)",
+                breakdown.stage_evaluator_call_time,
+            ),
+            (
+                "Stage leaf input pack (attribution)",
+                breakdown.stage_leaf_input_pack_time,
+            ),
+            (
+                "Stage backend calls (attribution)",
+                breakdown.stage_backend_call_time,
+            ),
+            (
+                "Stage output gather (attribution)",
+                breakdown.stage_evaluator_output_gather_time,
+            ),
+            ("Output assign", breakdown.output_assign_time),
+            (
+                "Amplitude input pack (top-level)",
+                breakdown.amplitude_input_pack_time,
+            ),
+            (
+                "Amplitude evaluator envelope (top-level)",
+                breakdown.amplitude_evaluator_call_time,
+            ),
+            (
+                "Amplitude leaf input pack (attribution)",
+                breakdown.amplitude_leaf_input_pack_time,
+            ),
+            (
+                "Amplitude backend call (attribution)",
+                breakdown.amplitude_backend_call_time,
+            ),
+            (
+                "Amplitude output gather (attribution)",
+                breakdown.amplitude_evaluator_output_gather_time,
+            ),
+            (
+                "Amplitude output remap (attribution)",
+                breakdown.amplitude_output_remap_time,
+            ),
+            ("Reduction", breakdown.reduction_time),
+            ("Total materialization", breakdown.total_materialization_time),
+            ("Final output copy", breakdown.final_output_copy_time),
+            ("Selector planning", breakdown.selector_planner_time),
+            ("Selector gather", breakdown.selector_gather_time),
+            ("Selector scatter", breakdown.selector_scatter_time),
+            ("Other Rusticol core", breakdown.other_core_time),
+        )
+    for label, timing in component_rows:
+        if _component_timing_is_exact_zero(timing):
+            continue
+        relative = (
+            "N/A"
+            if timing is None
+            else f"{timing.uncertainty.relative_standard_error:.3%}"
+        )
+        value = _component_timing_text(timing)
+        if label in {
+            "Stage evaluator envelope (top-level)",
+            "Amplitude evaluator envelope (top-level)",
+            "Eager execution (inclusive)",
+            "Recurrence schedule (inclusive)",
+            "OTF recurrence schedule (inclusive)",
+            "Kernel calls (exclusive)",
+            "Source kernels (schedule attribution; do not add)",
+            "Contribution kernels (schedule attribution; do not add)",
+            "Current finalization (schedule attribution; do not add)",
+            "Amplitude closure (schedule attribution; do not add)",
+        }:
+            value = _paint(value, "CYAN", enabled=color)
+        component_table.add_row((label, value, relative))
+    sections.append(cast(str, component_table.get_string()))
+
+    visible_stages = tuple(
+        stage
+        for stage in breakdown.stages
+        if not _component_timings_are_exact_zero(
+            (
+                stage.input_pack_time,
+                stage.evaluator_call_time,
+                stage.output_assign_time,
+            )
+        )
+    )
+    if visible_stages:
+        stage_table = prettytable.PrettyTable(
+            ("stage", "input pack", "evaluator call", "output assign")
+        )
+        stage_table.title = _paint("Rusticol Stage Detail", "CYAN", enabled=color)
+        stage_table.align["stage"] = "r"
+        for column in ("input pack", "evaluator call", "output assign"):
+            stage_table.align[column] = "r"
+        stage_table.hrules = prettytable.HRuleStyle.FRAME
+        for stage in visible_stages:
+            stage_table.add_row(
+                (
+                    stage.stage_index,
+                    _component_timing_text(stage.input_pack_time),
+                    _paint(
+                        _component_timing_text(stage.evaluator_call_time),
+                        "CYAN",
+                        enabled=color,
+                    ),
+                    _component_timing_text(stage.output_assign_time),
+                )
+            )
+        sections.append(cast(str, stage_table.get_string()))
+
+        visible_nested_stages = tuple(
+            stage
+            for stage in breakdown.stages
+            if any(
+                timing is not None
+                for timing in (
+                    stage.leaf_input_pack_time,
+                    stage.backend_call_time,
+                    stage.evaluator_output_gather_time,
+                )
+            )
+            and not _component_timings_are_exact_zero(
+                (
+                    stage.leaf_input_pack_time,
+                    stage.backend_call_time,
+                    stage.evaluator_output_gather_time,
+                )
+            )
+        )
+        if visible_nested_stages:
+            nested_stage_table = prettytable.PrettyTable(
+                ("stage", "leaf input pack", "backend call", "output gather")
+            )
+            nested_stage_table.title = _paint(
+                "Rusticol Stage Internal Attribution (do not add to top-level)",
+                "CYAN",
+                enabled=color,
+            )
+            nested_stage_table.align["stage"] = "r"
+            for column in ("leaf input pack", "backend call", "output gather"):
+                nested_stage_table.align[column] = "r"
+            nested_stage_table.hrules = prettytable.HRuleStyle.FRAME
+            for stage in visible_nested_stages:
+                nested_stage_table.add_row(
+                    (
+                        stage.stage_index,
+                        _component_timing_text(stage.leaf_input_pack_time),
+                        _paint(
+                            _component_timing_text(stage.backend_call_time),
+                            "CYAN",
+                            enabled=color,
+                        ),
+                        _component_timing_text(stage.evaluator_output_gather_time),
+                    )
+                )
+            sections.append(cast(str, nested_stage_table.get_string()))
+
+    counters = breakdown.counters
+    if counters is not None:
+        counter_table = prettytable.PrettyTable(
+            ("area", "counter", "mean", "normalization")
+        )
+        counter_table.title = _paint(
+            (
+                "Native Work Counters "
+                f"(mean across {counters.sample_count} profiled blocks)"
+            ),
+            "CYAN",
+            enabled=color,
+        )
+        for column in ("area", "counter", "normalization"):
+            counter_table.align[column] = "l"
+        counter_table.align["mean"] = "r"
+        counter_table.hrules = prettytable.HRuleStyle.FRAME
+        previous_area: str | None = None
+        for area, label, counter_value, unit, basis in _profile_counter_rows(counters):
+            area_text = (
+                _paint(area, "CYAN", enabled=color) if area != previous_area else ""
+            )
+            value_text = _counter_mean_text(counter_value, unit)
+            if label == "observed scratch reallocations":
+                value_text = _paint(
+                    value_text,
+                    "GREEN" if counter_value == 0.0 else "YELLOW",
+                    enabled=color,
+                )
+            elif label == "evaluator backend calls":
+                value_text = _paint(value_text, "CYAN", enabled=color)
+            counter_table.add_row((area_text, label, value_text, basis))
+            previous_area = area
+        sections.append(cast(str, counter_table.get_string()))
+    return "\n\n".join(sections)
+
+
+# Width of the value column of the generation summary.
+_SUMMARY_VALUE_WIDTH = 88
+
+
+def _generated_process_groups(output: Path) -> Mapping[str, object] | None:
+    """The stored process-group map of a written artifact, when readable."""
+
+    from pyamplicol.api.errors import ArtifactError
+    from pyamplicol.artifacts.inspection import stored_process_groups
+
+    try:
+        groups = stored_process_groups(output)
+    except (OSError, ValueError, ArtifactError):
+        return None
+    return None if groups is None else cast(Mapping[str, object], _plain(groups))
+
+
+def _generated_group_texts(
+    record: Mapping[str, object],
+    *,
+    color: bool,
+) -> dict[str, str]:
+    """The group column of each generated process of a grouped artifact.
+
+    A representative shows its group size; a generated member, its
+    representative and any factor other than 1 or charge conjugation.
+    Processes alone in their group have no entry.
+    """
+
+    texts: dict[str, str] = {}
+    for group in cast(list[Mapping[str, object]], record["groups"]):
+        representative, *members = _group_members(group)
+        if not members:
+            continue
+        routed = sum(not bool(member["generated"]) for member in members)
+        size = _subprocess_count(len(members) + 1)
+        texts[str(representative["id"])] = (
+            f"{size} ({_paint(f'{routed} routed', _ROUTED_COLOR, enabled=color)})"
+            if routed
+            else size
+        )
+        for member in members:
+            if not bool(member["generated"]):
+                continue
+            relation = []
+            if str(member["factor"]) != "1":
+                relation.append(_factor_text(member["factor"], color=color, prefix="x"))
+            if bool(member["conjugated"]):
+                relation.append(_conjugation_mark(color=color))
+            texts[str(member["id"])] = (
+                "member of "
+                + _paint(str(representative["id"]), "CYAN", enabled=color)
+                + (f" ({', '.join(relation)})" if relation else "")
+            )
+    return texts
+
+
+def _generation_summary(
+    result: object,
+    *,
+    prettytable: Any,
+    color: bool,
+) -> str:
+    from pyamplicol.api.results import GenerationResult
+
+    if not isinstance(result, GenerationResult):
+        raise TypeError("generation summary requires a GenerationResult")
+    file_count = len(result.files)
+    total_size: int | None = None
+    container: Mapping[str, object] | None = None
+    try:
+        from pyamplicol.artifacts import load_manifest
+
+        manifest = load_manifest(result.output, verify_payloads=False)
+        manifest_path = result.output / "artifact.json"
+        file_count = len(manifest.payloads) + 1
+        total_size = sum(payload.size_bytes for payload in manifest.payloads)
+        total_size += manifest_path.stat().st_size
+        raw_container = getattr(manifest, "extensions", {}).get(
+            "evaluator_payload_container"
+        )
+        if isinstance(raw_container, Mapping):
+            container = raw_container
+    except (OSError, RuntimeError, ValueError):
+        existing = tuple(path for path in result.files if path.is_file())
+        if existing:
+            total_size = sum(path.stat().st_size for path in existing)
+    files = f"{file_count} files"
+    if total_size is not None:
+        files += f"; {_byte_size(total_size)} total"
+    if container is not None:
+        member_count = container.get("member_count")
+        unpacked = container.get("unpacked_size_bytes")
+        if isinstance(member_count, int) and isinstance(unpacked, int):
+            files += (
+                f"; {member_count} indexed evaluator payloads "
+                f"({_byte_size(unpacked)} unpacked)"
+            )
+    request_count = len(result.processes.requests)
+    alias_count = len(result.processes.aliases)
+    process_count = f"{request_count} request{'s' if request_count != 1 else ''}"
+    if alias_count:
+        process_count += f"; {alias_count} aliases"
+    grouping = _generated_process_groups(result.output)
+    grouping_text = (
+        ""
+        if grouping is None
+        else _process_grouping_text(grouping, color=color, width=_SUMMARY_VALUE_WIDTH)
+    )
+    rows = (
+        ("output", str(result.output)),
+        ("processes", process_count),
+        ("existing-output policy", result.mode),
+        ("schema version", str(result.schema_version)),
+        ("files", files),
+    )
+    table = prettytable.PrettyTable(("field", "value"))
+    table.align["field"] = "l"
+    table.align["value"] = "l"
+    table.max_width["field"] = 30
+    table.max_width["value"] = _SUMMARY_VALUE_WIDTH
+    table.hrules = prettytable.HRuleStyle.FRAME
+    value_colors = {
+        "output": "GREEN",
+        "processes": "CYAN",
+        "existing-output policy": "YELLOW",
+        "schema version": "MAGENTA",
+        "files": "GREEN",
+    }
+    for field, value in rows:
+        table.add_row(
+            (
+                _paint(field, "CYAN", enabled=color),
+                _paint(value, value_colors[field], enabled=color),
+            )
+        )
+        if field == "processes" and grouping_text:
+            # coloured like the `inspect` process-group overview
+            table.add_row(
+                (_paint("process grouping", "CYAN", enabled=color), grouping_text)
+            )
+    group_texts = (
+        {}
+        if grouping is None or not grouping_text
+        else _generated_group_texts(grouping, color=color)
+    )
+    process_table = prettytable.PrettyTable(
+        ("name", "process", "group") if group_texts else ("name", "process")
+    )
+    process_table.title = _paint("Generated Processes", "CYAN", enabled=color)
+    process_table.align = "l"
+    process_table.max_width["name"] = 34
+    process_table.max_width["process"] = 76
+    process_table.hrules = prettytable.HRuleStyle.FRAME
+    for request in result.processes.requests:
+        process_table.add_row(
+            (
+                _paint(request.name, "CYAN", enabled=color),
+                _paint(request.expression, "GREEN", enabled=color),
+            )
+            + ((group_texts.get(request.name, ""),) if group_texts else ())
+        )
+    for alias in result.processes.aliases:
+        process_table.add_row(
+            (
+                _paint(alias.name, "MAGENTA", enabled=color),
+                f"alias of {alias.process_name}",
+            )
+            + (("",) if group_texts else ())
+        )
+    return f"{table.get_string()}\n\n{process_table.get_string()}"
+
+
+# Maps with at most this many subprocesses list one row per member; larger ones
+# list each group's members as a wrapped grid of process strings.
+_PROCESS_GROUP_ROW_LIMIT = 80
+# Target width of the process-group tables and notes.
+_PROCESS_GROUP_WIDTH = 120
+# Colours of the process-group views, shared by `inspect` and `generate`.
+_GENERATED_COLOR = "GREEN"
+_ROUTED_COLOR = "CYAN"
+_CONJUGATED_COLOR = "MAGENTA"
+_ATTENTION_COLOR = "YELLOW"  # factors other than 1, warnings
+_BASIS_COLORS = {"flavor-blind": "LIGHTBLUE_EX", "numerical": "GREEN"}
+_Member = Mapping[str, object]
+# (routed, conjugated, factor, basis) of a member's relation
+_Relation = tuple[bool, bool, Fraction, str]
+
+
+@dataclass(frozen=True, slots=True)
+class _GroupCounts:
+    """Counts of a process-group map; ``bases`` counts the related members."""
+
+    groups: int
+    subprocesses: int
+    generated: int
+    conjugated: int
+    non_unit: int
+    warnings: int
+    bases: tuple[tuple[str, int], ...]
+
+    @property
+    def routed(self) -> int:
+        return self.subprocesses - self.generated
+
+    @property
+    def trivial(self) -> bool:
+        return self.subprocesses == self.groups
+
+
+def _count(count: int, singular: str, plural: str | None = None) -> str:
+    return f"{count} {singular if count == 1 else plural or f'{singular}s'}"
+
+
+def _subprocess_count(count: int) -> str:
+    return _count(count, "subprocess", "subprocesses")
+
+
+def _own_groups_text(count: int) -> str:
+    """The note of a trivial map: every process is its own group."""
+
+    if count == 1:
+        return "the process is its own group"
+    return f"each of the {count} processes is its own group"
+
+
+def _natural_key(text: str) -> tuple[tuple[int, int | str], ...]:
+    return tuple(
+        (0, int(part)) if part.isdigit() else (1, part)
+        for part in re.split(r"(\d+)", text)
+        if part
+    )
+
+
+def _group_members(group: Mapping[str, object]) -> list[Mapping[str, object]]:
+    return cast(list[Mapping[str, object]], group["members"])
+
+
+def _group_counts(groups: Sequence[Mapping[str, object]]) -> _GroupCounts:
+    members = [member for group in groups for member in _group_members(group)]
+    bases: dict[str, int] = {}
+    for group in groups:
+        for member in _group_members(group)[1:]:
+            basis = str(member["basis"])
+            bases[basis] = bases.get(basis, 0) + 1
+    return _GroupCounts(
+        groups=len(groups),
+        subprocesses=len(members),
+        generated=sum(bool(member["generated"]) for member in members),
+        conjugated=sum(bool(member["conjugated"]) for member in members),
+        non_unit=sum(str(member["factor"]) != "1" for member in members),
+        warnings=sum(bool(member.get("warning")) for member in members),
+        bases=tuple(sorted(bases.items())),
+    )
+
+
+def _ordered_group_members(
+    group: Mapping[str, object],
+) -> list[Mapping[str, object]]:
+    """Representative first, then generated, routed and conjugated members."""
+
+    representative, *members = _group_members(group)
+    return [
+        representative,
+        *sorted(
+            members,
+            key=lambda member: (
+                not bool(member["generated"]),
+                bool(member["conjugated"]),
+                _natural_key(str(member["id"])),
+            ),
+        ),
+    ]
+
+
+def _is_identity_permutation(permutation: object) -> bool:
+    values = cast(Sequence[int], permutation)
+    return list(values) == list(range(len(values)))
+
+
+def _permutation_text(permutation: object) -> str:
+    if _is_identity_permutation(permutation):
+        return ""
+    return (
+        "[" + " ".join(str(index) for index in cast(Sequence[int], permutation)) + "]"
+    )
+
+
+def _factor_text(factor: object, *, color: bool, prefix: str = "") -> str:
+    text = str(factor)
+    return _paint(
+        f"{prefix}{text}",
+        _GENERATED_COLOR if text == "1" else _ATTENTION_COLOR,
+        enabled=color,
+    )
+
+
+def _basis_text(basis: object, *, color: bool) -> str:
+    text = str(basis)
+    return _paint(text, _BASIS_COLORS.get(text), enabled=color)
+
+
+def _role_text(member: Mapping[str, object], *, color: bool) -> str:
+    if bool(member["generated"]):
+        return _paint("generated", _GENERATED_COLOR, enabled=color)
+    return _paint("routed", _ROUTED_COLOR, enabled=color)
+
+
+def _conjugation_mark(*, color: bool) -> str:
+    return _paint("C", _CONJUGATED_COLOR, enabled=color, bold=True)
+
+
+def _warning_count(count: int, *, color: bool) -> str:
+    return _paint(
+        _count(count, "warning"),
+        _ATTENTION_COLOR if count else _GENERATED_COLOR,
+        enabled=color,
+    )
+
+
+def _analysis_labels(analyses: Sequence[Mapping[str, object]]) -> list[str]:
+    labels: list[str] = []
+    for analysis in analyses:
+        flags = []
+        if analysis.get("only_unit_multiplier") is True:
+            flags.append("unit factor only")
+        if analysis.get("consider_charge_conjugation") is False:
+            flags.append("no C")
+        text = str(analysis.get("variant", "analysis"))
+        labels.append(f"{text} ({', '.join(flags)})" if flags else text)
+    return labels
+
+
+def _analysis_text(analysis: Mapping[str, object]) -> str:
+    """One recorded analysis, such as ``numerical analysis: 3 points, ...``."""
+
+    details: list[str] = []
+    points = analysis.get("points")
+    if isinstance(points, int) and not isinstance(points, bool):
+        details.append(_count(points, "point"))
+    tolerance = analysis.get("tolerance")
+    if isinstance(tolerance, (int, float)) and not isinstance(tolerance, bool):
+        details.append(f"tolerance {tolerance:g}")
+    if analysis.get("only_unit_multiplier") is True:
+        details.append("unit factors only")
+    if analysis.get("consider_charge_conjugation") is False:
+        details.append("without charge conjugation")
+    text = f"{analysis.get('variant', 'grouping')} analysis"
+    return f"{text}: {', '.join(details)}" if details else text
+
+
+def _group_size_text(size: int, generated: int, conjugated: int, *, color: bool) -> str:
+    """``N subprocesses: G generated, R routed, C conjugated``, coloured."""
+
+    parts = [
+        _paint(f"{generated} generated", _GENERATED_COLOR, enabled=color),
+        _paint(f"{size - generated} routed", _ROUTED_COLOR, enabled=color),
+    ]
+    if conjugated:
+        parts.append(
+            _paint(f"{conjugated} conjugated", _CONJUGATED_COLOR, enabled=color)
+        )
+    return f"{_subprocess_count(size)}: {', '.join(parts)}"
+
+
+def _process_grouping_text(
+    record: Mapping[str, object],
+    *,
+    color: bool,
+    width: int,
+) -> str:
+    """The grouping outcome of a process-group map, in lines of ``width``.
+
+    The first line gives the reduction, the next the relations and warnings,
+    and the last ones the recorded analyses. It is empty for a trivial map
+    without analyses.
+    """
+
+    groups = cast(list[Mapping[str, object]], record["groups"])
+    analyses = cast(list[Mapping[str, object]], record.get("analyses", []))
+    counts = _group_counts(groups)
+    lines: list[str] = []
+    if counts.trivial:
+        if not analyses:
+            return ""
+        lines.append(f"no relation found; {_own_groups_text(counts.groups)}")
+    else:
+        reduction = _paint(
+            _subprocess_count(counts.subprocesses), None, enabled=color, bold=True
+        )
+        lines.append(
+            f"{reduction} -> {_count(counts.groups, 'group')}: "
+            + _paint(f"{counts.generated} generated", _GENERATED_COLOR, enabled=color)
+            + ", "
+            + _paint(f"{counts.routed} routed", _ROUTED_COLOR, enabled=color)
+        )
+        related = counts.subprocesses - counts.groups
+        relations = " + ".join(
+            f"{count} {_basis_text(basis, color=color)}"
+            for basis, count in counts.bases
+        )
+        details: list[str] = []
+        if counts.conjugated:
+            details.append(
+                _paint(
+                    f"{counts.conjugated} charge-conjugated",
+                    _CONJUGATED_COLOR,
+                    enabled=color,
+                )
+            )
+        if counts.non_unit:
+            details.append(
+                _paint(
+                    f"{counts.non_unit} with factor != 1",
+                    _ATTENTION_COLOR,
+                    enabled=color,
+                )
+            )
+        relation_text = f"{relations} {'relation' if related == 1 else 'relations'}"
+        if details:
+            relation_text += f" ({', '.join(details)})"
+        lines.append(
+            _legend(
+                (relation_text, _warning_count(counts.warnings, color=color)),
+                width=width,
+            )
+        )
+    lines.extend(_analysis_text(analysis) for analysis in analyses)
+    return "\n".join(lines)
+
+
+def _wrapped_note(text: str, *, indent: str = "") -> str:
+    return textwrap.fill(
+        text,
+        width=_PROCESS_GROUP_WIDTH,
+        subsequent_indent=indent,
+        break_on_hyphens=False,
+    )
+
+
+_ANSI_STYLE = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _legend(items: Sequence[str], *, width: int = _PROCESS_GROUP_WIDTH) -> str:
+    """Join ``items`` with semicolons, breaking lines only between items."""
+
+    lines: list[tuple[int, str]] = []
+    for item in items:
+        size = len(_ANSI_STYLE.sub("", item))
+        if lines and lines[-1][0] + size + 2 <= width:
+            used, text = lines[-1]
+            lines[-1] = (used + size + 2, f"{text}; {item}")
+        else:
+            lines.append((size, item))
+    return "\n".join(text for _size, text in lines)
+
+
+def _padded(plain: str, painted: str, width: int) -> str:
+    return painted + " " * (width - len(plain))
+
+
+def _process_groups_overview(
+    groups: Sequence[Mapping[str, object]],
+    analyses: Sequence[Mapping[str, object]],
+    *,
+    prettytable: Any,
+    color: bool,
+) -> str:
+    counts = _group_counts(groups)
+    table = prettytable.PrettyTable(
+        (
+            "groups",
+            "subprocesses",
+            "generated",
+            "routed",
+            "conjugated",
+            "factor != 1",
+            "bases",
+            "analyses",
+            "warnings",
+        )
+    )
+    table.align = "r"
+    table.align["bases"] = "l"
+    table.align["analyses"] = "l"
+    # One basis per line; long analysis descriptions wrap to keep 120 columns.
+    table.max_width["analyses"] = 12
+    table.hrules = prettytable.HRuleStyle.FRAME
+    table.add_row(
+        (
+            _paint(str(counts.groups), None, enabled=color, bold=True),
+            _paint(str(counts.subprocesses), None, enabled=color, bold=True),
+            _paint(str(counts.generated), _GENERATED_COLOR, enabled=color),
+            _paint(str(counts.routed), _ROUTED_COLOR, enabled=color),
+            _paint(
+                str(counts.conjugated),
+                _CONJUGATED_COLOR,
+                enabled=color and counts.conjugated > 0,
+            ),
+            _paint(
+                str(counts.non_unit),
+                _ATTENTION_COLOR if counts.non_unit else _GENERATED_COLOR,
+                enabled=color,
+            ),
+            "\n".join(
+                f"{_basis_text(basis, color=color)} {count}"
+                for basis, count in counts.bases
+            )
+            or "none",
+            "\n".join(_analysis_labels(analyses)) or "none",
+            _paint(
+                str(counts.warnings),
+                _ATTENTION_COLOR if counts.warnings else _GENERATED_COLOR,
+                enabled=color,
+            ),
+        )
+    )
+    return cast(str, table.get_string())
+
+
+def _process_group_detail_table(
+    groups: Sequence[Mapping[str, object]],
+    footnotes: Mapping[str, int],
+    *,
+    prettytable: Any,
+    color: bool,
+) -> str:
+    members = [member for group in groups for member in _group_members(group)]
+    show_factor = any(str(member["factor"]) != "1" for member in members)
+    show_conjugated = any(bool(member["conjugated"]) for member in members)
+    show_permutation = not all(
+        _is_identity_permutation(member["permutation"]) for member in members
+    )
+    headers = ["process ID", "process", "role"]
+    if show_factor:
+        headers.append("factor")
+    if show_conjugated:
+        headers.append("C")
+    if show_permutation:
+        headers.append("permutation")
+    headers.append("basis")
+    if footnotes:
+        headers.append("note")
+    table = prettytable.PrettyTable(headers)
+    table.align = "l"
+    if show_factor:
+        table.align["factor"] = "r"
+    if show_conjugated:
+        table.align["C"] = "c"
+    table.hrules = prettytable.HRuleStyle.FRAME
+    for group_index, group in enumerate(groups):
+        ordered = _ordered_group_members(group)
+        representative = ordered[0]
+        rows: list[list[str]] = [
+            [
+                _paint(str(representative["id"]), "CYAN", enabled=color, bold=True),
+                _paint(
+                    str(representative["process"]), "GREEN", enabled=color, bold=True
+                ),
+                _paint("representative", None, enabled=color, bold=True),
+            ]
+            + [""] * (len(headers) - 3)
+        ]
+        for index, member in enumerate(ordered[1:], start=2):
+            branch = "`- " if index == len(ordered) else "|- "
+            row = [
+                branch + _paint(str(member["id"]), "CYAN", enabled=color),
+                str(member["process"]),
+                _role_text(member, color=color),
+            ]
+            if show_factor:
+                row.append(_factor_text(member["factor"], color=color))
+            if show_conjugated:
+                row.append(
+                    _conjugation_mark(color=color) if bool(member["conjugated"]) else ""
+                )
+            if show_permutation:
+                row.append(_permutation_text(member["permutation"]))
+            row.append(_basis_text(member["basis"], color=color))
+            if footnotes:
+                warning = member.get("warning")
+                row.append(
+                    _paint(
+                        f"[{footnotes[str(warning)]}]", _ATTENTION_COLOR, enabled=color
+                    )
+                    if warning
+                    else ""
+                )
+            rows.append(row)
+        for index, row in enumerate(rows):
+            table.add_row(
+                row,
+                divider=index == len(rows) - 1 and group_index < len(groups) - 1,
+            )
+    return cast(str, table.get_string())
+
+
+def _process_group_compact_table(
+    groups: Sequence[Mapping[str, object]],
+    footnotes: Mapping[str, int],
+    *,
+    prettytable: Any,
+    color: bool,
+) -> str:
+    """One row per group, its members as a grid of process strings.
+
+    Members are listed in one block per relation, labelled with their count,
+    role and conjugation. Factor and basis columns appear in the labels only
+    when they vary; the overview reports them otherwise.
+    """
+
+    grouped = [group for group in groups if len(_group_members(group)) > 1]
+    ungrouped = [
+        _group_members(group)[0] for group in groups if len(_group_members(group)) == 1
+    ]
+
+    def token(member: _Member) -> tuple[str, str]:
+        process = str(member["process"])
+        warning = member.get("warning")
+        if not warning:
+            return process, process
+        marker = f"[{footnotes[str(warning)]}]"
+        return (
+            f"{process} {marker}",
+            f"{process} {_paint(marker, _ATTENTION_COLOR, enabled=color)}",
+        )
+
+    classes: list[list[tuple[_Relation, list[_Member]]]] = []
+    for group in grouped:
+        by_relation: dict[_Relation, list[_Member]] = {}
+        for member in _ordered_group_members(group)[1:]:
+            key = (
+                not bool(member["generated"]),
+                bool(member["conjugated"]),
+                Fraction(str(member["factor"])),
+                str(member["basis"]),
+            )
+            by_relation.setdefault(key, []).append(member)
+        classes.append(sorted(by_relation.items(), key=lambda item: item[0]))
+    relations = [(key, len(members)) for items in classes for key, members in items]
+    count_width = max((len(str(count)) for _key, count in relations), default=1)
+    role_width = max(
+        (len("routed" if key[0] else "generated") for key, _count in relations),
+        default=0,
+    )
+    show_factor = any(key[2] != 1 for key, _count in relations)
+    show_basis = len({key[3] for key, _count in relations}) > 1
+    factor_width = max((len(f"x{key[2]}") for key, _count in relations), default=0)
+    basis_width = max((len(key[3]) for key, _count in relations), default=0)
+    label_width = (
+        count_width
+        + role_width
+        + 3
+        + (factor_width + 1 if show_factor else 0)
+        + (basis_width + 1 if show_basis else 0)
+    )
+
+    def label(key: _Relation, count: int) -> str:
+        routed, conjugated, factor, basis = key
+        role = "routed" if routed else "generated"
+        parts = [
+            f"{count:>{count_width}}",
+            _padded(
+                role,
+                _paint(
+                    role,
+                    _ROUTED_COLOR if routed else _GENERATED_COLOR,
+                    enabled=color,
+                ),
+                role_width,
+            ),
+            _conjugation_mark(color=color) if conjugated else " ",
+        ]
+        if show_factor:
+            parts.append(
+                _padded(
+                    f"x{factor}",
+                    _factor_text(factor, color=color, prefix="x"),
+                    factor_width,
+                )
+            )
+        if show_basis:
+            parts.append(_padded(basis, _basis_text(basis, color=color), basis_width))
+        return " ".join(parts)
+
+    tokens = [
+        token(member)
+        for items in classes
+        for _key, members in items
+        for member in members
+    ] + [token(member) for member in ungrouped]
+    cell_width = max(len(plain) for plain, _painted in tokens) + 2
+    group_width = max(
+        [len("ungrouped"), len(_subprocess_count(len(ungrouped)))]
+        + [
+            len(text)
+            for group in grouped
+            for text in (
+                str(group["representative"]),
+                str(group["representative_id"]),
+                _subprocess_count(len(_group_members(group))),
+            )
+        ]
+    )
+    members_width = _PROCESS_GROUP_WIDTH - group_width - 7
+    per_line = max(1, (members_width - label_width) // cell_width)
+
+    def grid(members: Sequence[tuple[str, str]], first: str) -> list[str]:
+        lines: list[str] = []
+        for start in range(0, len(members), per_line):
+            chunk = members[start : start + per_line]
+            cells = [_padded(plain, painted, cell_width) for plain, painted in chunk]
+            prefix = first if start == 0 else " " * label_width
+            lines.append(f"{prefix}  {''.join(cells).rstrip()}")
+        return lines
+
+    table = prettytable.PrettyTable(("representative", "members"))
+    table.align = "l"
+    table.hrules = prettytable.HRuleStyle.FRAME
+    rows: list[tuple[str, str]] = []
+    for group, items in zip(grouped, classes, strict=True):
+        rows.append(
+            (
+                "\n".join(
+                    (
+                        _paint(
+                            str(group["representative"]),
+                            "GREEN",
+                            enabled=color,
+                            bold=True,
+                        ),
+                        _paint(str(group["representative_id"]), "CYAN", enabled=color),
+                        _subprocess_count(len(_group_members(group))),
+                    )
+                ),
+                "\n".join(
+                    line
+                    for key, members in items
+                    for line in grid(
+                        [token(member) for member in members],
+                        label(key, len(members)),
+                    )
+                ),
+            )
+        )
+    if ungrouped:
+        rows.append(
+            (
+                _paint("ungrouped", None, enabled=color, bold=True)
+                + "\n"
+                + _subprocess_count(len(ungrouped)),
+                "\n".join(
+                    grid([token(member) for member in ungrouped], " " * label_width)
+                ),
+            )
+        )
+    for index, row in enumerate(rows):
+        table.add_row(row, divider=index < len(rows) - 1)
+    return cast(str, table.get_string())
+
+
+def _process_groups_summary(
+    record: Mapping[str, object],
+    *,
+    prettytable: Any,
+    color: bool,
+) -> str:
+    groups = cast(list[Mapping[str, object]], record["groups"])
+    analyses = cast(list[Mapping[str, object]], record.get("analyses", []))
+    heading = _paint("Process groups", "CYAN", enabled=color)
+    counts = _group_counts(groups)
+    if counts.trivial:
+        own = _own_groups_text(counts.groups)
+        if not bool(record.get("stored", True)):
+            return f"{heading}: no process-groups.json; {own}"
+        if analyses:
+            labels = "; ".join(_analysis_text(analysis) for analysis in analyses)
+            return f"{heading}: no relation found ({labels}); {own}"
+        return f"{heading}: none; {own}"
+    members = [member for group in groups for member in _group_members(group)]
+    footnotes: dict[str, int] = {}
+    for group in groups:
+        for member in _ordered_group_members(group):
+            warning = member.get("warning")
+            if warning and str(warning) not in footnotes:
+                footnotes[str(warning)] = len(footnotes) + 1
+    # One group, as selected by `--process REPRESENTATIVE`, is always detailed.
+    detailed = counts.groups == 1 or counts.subprocesses <= _PROCESS_GROUP_ROW_LIMIT
+    table = (_process_group_detail_table if detailed else _process_group_compact_table)(
+        groups, footnotes, prettytable=prettytable, color=color
+    )
+    legend: list[str] = []
+    if counts.routed:
+        routed = _paint("routed", _ROUTED_COLOR, enabled=color)
+        legend.append(f"{routed}: not generated, evaluated through its representative")
+    if counts.conjugated:
+        legend.append(f"{_conjugation_mark(color=color)}: charge-conjugated relation")
+    if counts.non_unit:
+        legend.append("factor F: ME = F x ME(representative)")
+    if not detailed:
+        legend.extend(
+            (
+                f"compact view of {_subprocess_count(counts.subprocesses)}",
+                "IDs and leg permutations: --json",
+                "one group row by row: --process REPRESENTATIVE",
+            )
+        )
+    elif not all(_is_identity_permutation(member["permutation"]) for member in members):
+        legend.append(
+            "permutation p: representative leg r takes the momentum of member leg p[r]"
+        )
+    notes = [_legend(legend)] if legend else []
+    notes.extend(map(_analysis_text, analyses))
+    for warning, number in footnotes.items():
+        marker = f"[{number}]"
+        text = _wrapped_note(f"{marker} {warning}", indent=" " * (len(marker) + 1))
+        notes.append(
+            _paint(marker, _ATTENTION_COLOR, enabled=color) + text.removeprefix(marker)
+        )
+    sections = [
+        heading,
+        _process_groups_overview(
+            groups, analyses, prettytable=prettytable, color=color
+        ),
+        table,
+    ]
+    if notes:
+        sections.append("\n".join(notes))
+    return "\n\n".join(sections)
+
+
+def _process_group_selection_summary(
+    record: Mapping[str, object],
+    *,
+    prettytable: Any,
+    color: bool,
+) -> str:
+    role = str(record["role"])
+    table = prettytable.PrettyTable(("field", "value"))
+    table.title = _paint("Process Group", "CYAN", enabled=color)
+    table.align = "l"
+    table.max_width["value"] = 88
+    table.hrules = prettytable.HRuleStyle.FRAME
+    size = _integer(record["group_size"], "group size")
+    routed = _integer(record["routed_count"], "routed count")
+    conjugated = _integer(record["conjugated_count"], "conjugated count")
+    group_text = _group_size_text(size, size - routed, conjugated, color=color)
+    permutation = _permutation_text(record["permutation"])
+    # `permutation` relates the representative to the requested leg order
+    permutation_text = (
+        f"p = {permutation}: representative leg r takes the momentum of leg p[r]"
+        if permutation
+        else "identity"
+    )
+    rows: list[tuple[str, str]]
+    if role == "representative":
+        rows = [
+            (
+                "role",
+                _paint(
+                    "representative: generated, evaluated by its own runtime",
+                    _GENERATED_COLOR,
+                    enabled=color,
+                    bold=True,
+                ),
+            ),
+            *((("permutation", permutation_text),) if permutation else ()),
+            ("group", group_text),
+        ]
+    else:
+        routed_member = role == "routed member"
+        rows = [
+            (
+                "role",
+                _paint(
+                    "routed member: not generated, evaluated through the representative"
+                    if routed_member
+                    else "generated member: evaluated by its own runtime",
+                    _ROUTED_COLOR if routed_member else _GENERATED_COLOR,
+                    enabled=color,
+                    bold=True,
+                ),
+            ),
+            (
+                "representative",
+                _paint(str(record["representative_id"]), "CYAN", enabled=color)
+                + "  "
+                + _paint(str(record["representative"]), "GREEN", enabled=color),
+            ),
+            ("factor", _factor_text(record["factor"], color=color)),
+            (
+                "conjugated",
+                _paint("yes (C)", _CONJUGATED_COLOR, enabled=color, bold=True)
+                if bool(record["conjugated"])
+                else "no",
+            ),
+            ("permutation", permutation_text),
+            ("basis", _basis_text(record["basis"], color=color)),
+            ("group", group_text),
+        ]
+        warning = record.get("warning")
+        if warning:
+            rows.append(
+                (
+                    "warning",
+                    "\n".join(
+                        _paint(line, _ATTENTION_COLOR, enabled=color)
+                        for line in textwrap.wrap(str(warning), 88)
+                    ),
+                )
+            )
+    for field, value in rows:
+        table.add_row((_paint(field, "CYAN", enabled=color), value))
+    return cast(str, table.get_string())
+
+
+def _artifact_inspection_summary(
+    plain: Mapping[str, object],
+    *,
+    prettytable: Any,
+    color: bool,
+) -> str:
+    processes = cast(list[Mapping[str, object]], plain["processes"])
+    dependencies = cast(list[Mapping[str, object]], plain["dependencies"])
+    aliases = [
+        cast(Mapping[str, object], alias)
+        for process in processes
+        for alias in cast(list[object], process["aliases"])
+    ]
+
+    model = str(plain["model_name"])
+    restriction = plain.get("model_restriction")
+    if restriction is not None:
+        model = f"{model} ({restriction})"
+    target = str(plain["target"])
+    features = cast(list[object], plain["cpu_features"])
+    if features:
+        target = f"{target} [{', '.join(str(feature) for feature in features)}]"
+    runtime_capabilities = cast(
+        Sequence[object],
+        plain["runtime_capabilities"],
+    )
+
+    summary = prettytable.PrettyTable(("field", "value"))
+    summary.align["field"] = "l"
+    summary.align["value"] = "l"
+    summary.max_width["field"] = 24
+    summary.max_width["value"] = 88
+    summary.hrules = prettytable.HRuleStyle.FRAME
+    physical_file_count = plain.get("physical_file_count")
+    if not isinstance(physical_file_count, int):
+        payload_count = plain["payload_count"]
+        if isinstance(payload_count, bool) or not isinstance(payload_count, int):
+            raise ValueError("artifact payload count must be an integer")
+        physical_file_count = payload_count + 1
+    payload_text = (
+        f"{physical_file_count} physical files; "
+        f"{_byte_size(plain['payload_size_bytes'])}"
+    )
+    container_members = plain.get("evaluator_container_member_count")
+    container_unpacked = plain.get("evaluator_container_unpacked_size_bytes")
+    if isinstance(container_members, int) and isinstance(container_unpacked, int):
+        payload_text += (
+            f"; {container_members} indexed evaluators "
+            f"({_byte_size(container_unpacked)} unpacked; "
+            f"{plain.get('evaluator_container_abi')})"
+        )
+    contents = (
+        f"{_count(len(processes), 'process', 'processes')}, "
+        f"{_count(len(aliases), 'alias', 'aliases')}"
+    )
+    process_groups = plain.get("process_groups")
+    if isinstance(process_groups, Mapping):
+        counts = _group_counts(
+            cast(list[Mapping[str, object]], process_groups["groups"])
+        )
+        if not counts.trivial:
+            contents += (
+                f"; {_subprocess_count(counts.subprocesses)} in "
+                f"{_count(counts.groups, 'group')}"
+            )
+    summary_rows = (
+        ("path", plain["path"]),
+        ("artifact type", str(plain["artifact_kind"]).removeprefix("pyamplicol-")),
+        ("artifact ID", plain["artifact_id"]),
+        ("created", plain["created_utc"]),
+        ("producer", f"pyamplicol {plain['producer_version']}"),
+        ("target", target),
+        ("model", f"{model}; {plain['model_source']}"),
+        ("default process", plain.get("default_process_id")),
+        ("contents", contents),
+        (
+            "runtime",
+            f"{plain['runtime_engine']} {plain['runtime_version']}",
+        ),
+        (
+            "capabilities",
+            ", ".join(str(value) for value in runtime_capabilities),
+        ),
+        ("payloads", payload_text),
+        ("integrity", plain["integrity"]),
+    )
+    for key, value in summary_rows:
+        text = _value_text(value)
+        summary.add_row(
+            (
+                _paint(key, "CYAN", enabled=color),
+                _colored(text, key=key, enabled=color),
+            )
+        )
+
+    process_table = prettytable.PrettyTable(
+        (
+            "default",
+            "stable ID",
+            "concrete process",
+            "color",
+            "helicities",
+            "color outputs",
+            "coverage (hel./color)",
+            "aliases",
+        )
+    )
+    process_table.align = "l"
+    process_table.align["default"] = "c"
+    process_table.align["color"] = "c"
+    process_table.align["helicities"] = "r"
+    process_table.align["color outputs"] = "r"
+    process_table.align["aliases"] = "r"
+    process_table.max_width["stable ID"] = 30
+    process_table.max_width["concrete process"] = 48
+    process_table.hrules = prettytable.HRuleStyle.FRAME
+    accuracy_colors = {"lc": "CYAN", "nlc": "YELLOW", "full": "MAGENTA"}
+    for process in processes:
+        accuracy = str(process["color_accuracy"])
+        marker = "*" if bool(process["default"]) else ""
+        coverage = f"{process['helicity_coverage']} / {process['color_coverage']}"
+        coverage_text = (
+            _paint(coverage, "GREEN", enabled=color)
+            if coverage == "complete / complete"
+            else coverage
+        )
+        process_table.add_row(
+            (
+                _paint(marker, "GREEN", enabled=color),
+                _paint(str(process["id"]), "CYAN", enabled=color),
+                _paint(str(process["expression"]), "GREEN", enabled=color),
+                _paint(
+                    accuracy,
+                    accuracy_colors.get(accuracy, "WHITE"),
+                    enabled=color,
+                ),
+                _paint(
+                    _component_count(process, "helicities"),
+                    "MAGENTA",
+                    enabled=color,
+                ),
+                _paint(
+                    _component_count(process, "color_components"),
+                    "MAGENTA",
+                    enabled=color,
+                ),
+                coverage_text,
+                _paint(
+                    str(len(cast(list[object], process["aliases"]))),
+                    "MAGENTA",
+                    enabled=color,
+                ),
+            )
+        )
+
+    sections = [
+        _paint("Artifact", "CYAN", enabled=color),
+        cast(str, summary.get_string()),
+        _paint("Processes", "CYAN", enabled=color),
+        cast(str, process_table.get_string()),
+    ]
+    if isinstance(process_groups, Mapping):
+        sections.append(
+            _process_groups_summary(
+                process_groups, prettytable=prettytable, color=color
+            )
+        )
+
+    execution_table = prettytable.PrettyTable(("process", "execution field", "value"))
+    execution_table.align = "l"
+    execution_table.max_width["process"] = 30
+    execution_table.max_width["execution field"] = 26
+    execution_table.max_width["value"] = 72
+    execution_table.hrules = prettytable.HRuleStyle.FRAME
+
+    def add_execution_row(row: tuple[object, object, object]) -> None:
+        process_id, field, value = row
+        execution_table.add_row(
+            (
+                _paint(str(process_id), "CYAN", enabled=color),
+                _paint(str(field), "MAGENTA", enabled=color),
+                _paint(_value_text(value), "CYAN", enabled=color),
+            )
+        )
+
+    for process in processes:
+        process_id = str(process["id"])
+        mode = str(process.get("execution_mode", "compiled"))
+        backend = process.get("prepared_backend")
+        mode_text = mode if backend is None else f"{mode} ({backend})"
+        add_execution_row((process_id, "mode / backend", mode_text))
+        lc_flow_layout = process.get("lc_flow_layout")
+        if lc_flow_layout is not None:
+            add_execution_row((process_id, "LC flow layout", str(lc_flow_layout)))
+        union_sector_count = process.get("lc_union_sector_count")
+        if union_sector_count is not None:
+            add_execution_row(
+                (
+                    process_id,
+                    "LC union sectors",
+                    f"{union_sector_count} physical / materialized; 0 residual",
+                )
+            )
+        phases = cast(Sequence[object], process.get("native_profile_phases", ()))
+        add_execution_row(
+            (
+                process_id,
+                "native profile phases",
+                ", ".join(str(phase) for phase in phases) or "unavailable",
+            )
+        )
+        selector_provenance = process.get("selector_provenance")
+        if selector_provenance is not None:
+            add_execution_row(
+                (
+                    process_id,
+                    "runtime selectors",
+                    (
+                        f"helicity {process.get('helicity_runtime_contract')}; "
+                        "color flow "
+                        f"{process.get('color_flow_runtime_contract')}"
+                    ),
+                )
+            )
+            specialized_axes = cast(
+                Sequence[object], process.get("generation_specialized_axes", ())
+            )
+            add_execution_row(
+                (
+                    process_id,
+                    "generation specialization",
+                    ", ".join(str(axis) for axis in specialized_axes) or "none",
+                )
+            )
+            source_helicities = cast(
+                Sequence[Sequence[object]],
+                process.get("selected_source_helicities", ()),
+            )
+            color_sectors = cast(
+                Sequence[object], process.get("selected_color_sector_ids", ())
+            )
+            selection_parts = []
+            if source_helicities:
+                selection_parts.append(
+                    "helicities "
+                    + ", ".join(f"{pair[0]}:{pair[1]}" for pair in source_helicities)
+                )
+            if color_sectors:
+                selection_parts.append(
+                    "color sectors " + ", ".join(str(value) for value in color_sectors)
+                )
+            add_execution_row(
+                (
+                    process_id,
+                    "generation selection",
+                    "; ".join(selection_parts) or "none",
+                )
+            )
+            add_execution_row((process_id, "selector provenance", selector_provenance))
+        if mode == "on-the-fly":
+            add_execution_row(
+                (
+                    process_id,
+                    "compact/query-local census",
+                    (
+                        f"{process.get('physical_helicities')} physical helicities; "
+                        f"{process.get('physical_color_components')} physical LC "
+                        "color flows"
+                    ),
+                )
+            )
+        elif process.get("lc_physical_sector_count") is not None:
+            add_execution_row(
+                (
+                    process_id,
+                    "LC replay sectors",
+                    (
+                        f"{process.get('lc_physical_sector_count')} physical; "
+                        f"{process.get('lc_materialized_sector_count')} materialized; "
+                        f"{process.get('lc_replayed_sector_count')} replayed; "
+                        f"{process.get('lc_residual_sector_count')} residual"
+                    ),
+                )
+            )
+        helicity_status = process.get("helicity_recurrence_status")
+        if helicity_status is not None:
+            recurrence = str(helicity_status)
+            optimized_currents = process.get("helicity_optimized_current_count")
+            if optimized_currents is not None:
+                recurrence += (
+                    f"; {optimized_currents} optimized currents in "
+                    f"{process.get('helicity_optimized_class_count')} classes; "
+                    f"{process.get('helicity_residual_current_count')} residual"
+                )
+            optimized_amplitude_classes = process.get(
+                "helicity_optimized_amplitude_class_count"
+            )
+            if optimized_amplitude_classes is not None:
+                recurrence += (
+                    f"; {optimized_amplitude_classes} optimized amplitude classes; "
+                    f"{process.get('helicity_residual_amplitude_count')} residual roots"
+                )
+            materialized_currents = process.get("helicity_materialized_current_count")
+            if materialized_currents is not None:
+                recurrence += (
+                    f"; materialized {materialized_currents} currents / "
+                    f"{process.get('helicity_materialized_amplitude_count')} roots"
+                )
+            add_execution_row((process_id, "helicity recurrence", recurrence))
+        if mode == "recurrence":
+            add_execution_row(
+                (
+                    process_id,
+                    "direct recurrence rows",
+                    (
+                        f"{process.get('direct_source_row_count')} sources; "
+                        f"{process.get('direct_contribution_row_count')} "
+                        "contributions; "
+                        f"{process.get('direct_finalization_row_count')} "
+                        "finalizations; "
+                        f"{process.get('direct_closure_row_count')} closures"
+                    ),
+                )
+            )
+            if process.get("recurrence_color_storage") is not None:
+                factorization = process.get("recurrence_color_factorization_kind")
+                factorization_text = (
+                    "none"
+                    if factorization is None
+                    else (
+                        f"{factorization}, rank "
+                        f"{process.get('recurrence_color_factorization_rank')}, "
+                        f"{process.get('recurrence_color_factorization_coset_count')} "
+                        "cosets"
+                    )
+                )
+                add_execution_row(
+                    (
+                        process_id,
+                        "contracted color",
+                        (
+                            f"{process.get('recurrence_color_accuracy')}; "
+                            f"{process.get('recurrence_color_storage')}; "
+                            f"{process.get('recurrence_color_active_sector_count')}/"
+                            f"{process.get('recurrence_color_sector_count')} "
+                            "active sectors; "
+                            f"{process.get('recurrence_color_component_count')} "
+                            "components; "
+                            f"{process.get('recurrence_color_group_count')} groups; "
+                            f"{process.get('recurrence_color_entry_count')}/"
+                            f"{process.get('recurrence_color_logical_entry_count')} "
+                            f"stored/logical entries; {factorization_text}"
+                        ),
+                    )
+                )
+            continue
+        if mode == "on-the-fly":
+            requested_tile = process.get("requested_point_tile_size")
+            add_execution_row(
+                (
+                    process_id,
+                    "point tile request",
+                    f"{requested_tile} requested; not applied by on-the-fly execution",
+                )
+            )
+            add_execution_row(
+                (
+                    process_id,
+                    "query construction threads",
+                    f"{process.get('requested_query_construction_threads')} requested",
+                )
+            )
+            add_execution_row((process_id, "numeric runtime", "f64 only"))
+            continue
+        if mode != "eager":
+            continue
+        pack_kernels = process.get("prepared_kernel_count")
+        referenced_kernels = process.get("referenced_kernel_count")
+        add_execution_row(
+            (
+                process_id,
+                "prepared kernels",
+                f"{pack_kernels} in pack; {referenced_kernels} referenced",
+            )
+        )
+        invocation_count = process.get("invocation_count")
+        attachment_count = process.get("attachment_count")
+        alias_count = process.get("evaluation_alias_count")
+        maximum_fanout = process.get("maximum_fanout")
+        add_execution_row(
+            (
+                process_id,
+                "invocations / reuse",
+                (
+                    f"{invocation_count} canonical; {attachment_count} attachments; "
+                    f"{alias_count} reused aliases; max fanout {maximum_fanout}"
+                ),
+            )
+        )
+        add_execution_row(
+            (
+                process_id,
+                "finalization / closure",
+                (
+                    f"{process.get('finalization_count')} currents; "
+                    f"{process.get('closure_count')} amplitudes"
+                ),
+            )
+        )
+        add_execution_row(
+            (
+                process_id,
+                "selector closures",
+                (
+                    (
+                        f"{process.get('selector_domain_count')} domains; "
+                        f"{process.get('selector_domain_membership_count')} "
+                        "memberships"
+                    )
+                    if bool(process.get("selector_closure_available"))
+                    else "not emitted"
+                ),
+            )
+        )
+        requested_tile = process.get("requested_point_tile_size")
+        effective_tile = process.get("effective_point_tile_size")
+        add_execution_row(
+            (
+                process_id,
+                "point tile requested / effective",
+                (
+                    f"{requested_tile} / "
+                    + (
+                        str(effective_tile)
+                        if effective_tile is not None
+                        else "available after runtime load"
+                    )
+                ),
+            )
+        )
+        workspace_target = process.get("workspace_limit_bytes")
+        workspace_used = process.get("workspace_bytes")
+        add_execution_row(
+            (
+                process_id,
+                "workspace target / allocated",
+                (
+                    f"{_byte_size(workspace_target)} / "
+                    + (
+                        _byte_size(workspace_used)
+                        if workspace_used is not None
+                        else "available after runtime load"
+                    )
+                ),
+            )
+        )
+    sections.extend(
+        (
+            _paint("Execution", "CYAN", enabled=color),
+            cast(str, execution_table.get_string()),
+        )
+    )
+
+    if aliases:
+        alias_table = prettytable.PrettyTable(
+            ("stable alias ID", "concrete process", "representative ID")
+        )
+        alias_table.align = "l"
+        alias_table.max_width["stable alias ID"] = 30
+        alias_table.max_width["concrete process"] = 52
+        alias_table.max_width["representative ID"] = 30
+        alias_table.hrules = prettytable.HRuleStyle.FRAME
+        for alias in aliases:
+            alias_table.add_row(
+                (
+                    _paint(str(alias["id"]), "CYAN", enabled=color),
+                    _paint(str(alias["expression"]), "GREEN", enabled=color),
+                    _paint(
+                        str(alias["representative_id"]),
+                        "MAGENTA",
+                        enabled=color,
+                    ),
+                )
+            )
+        sections.extend(
+            (
+                _paint("Aliases", "CYAN", enabled=color),
+                cast(str, alias_table.get_string()),
+            )
+        )
+
+    if dependencies:
+        dependency_table = prettytable.PrettyTable(("dependency", "version", "license"))
+        dependency_table.align = "l"
+        dependency_table.max_width["license"] = 48
+        dependency_table.hrules = prettytable.HRuleStyle.FRAME
+        for dependency in dependencies:
+            dependency_table.add_row(
+                (
+                    _paint(str(dependency["name"]), "CYAN", enabled=color),
+                    _paint(str(dependency["version"]), "GREEN", enabled=color),
+                    _paint(str(dependency["license"]), "YELLOW", enabled=color),
+                )
+            )
+        sections.extend(
+            (
+                _paint("Dependencies", "CYAN", enabled=color),
+                cast(str, dependency_table.get_string()),
+            )
+        )
+    return "\n\n".join(sections)
+
+
+def _human_result_title(value: object, plain: object) -> str:
+    class_name = type(value).__name__
+    if (
+        isinstance(value, Sequence)
+        and not isinstance(value, (str, bytes))
+        and value
+        and all(type(entry).__name__ == "ExampleEntry" for entry in value)
+    ):
+        return "Packaged Examples"
+    if class_name == "DiagnosticReport":
+        return "pyAmpliCol Diagnostics"
+    if class_name == "UtilityResult":
+        return "Operation Complete"
+    if class_name == "LicenseRequestResult":
+        return "Symbolica License Request"
+    if isinstance(plain, (str, int, float, bool)) or plain is None:
+        return "pyAmpliCol Result"
+    if isinstance(plain, Mapping):
+        keys = frozenset(plain)
+        if {"requested", "effective", "adjustments"} <= keys:
+            return "Resolved Configuration"
+        if {"available", "model", "entries"} <= keys:
+            return "Model Processes"
+        if {"name", "supported", "contents"} <= keys:
+            return "Model Inspection"
+        if {"model", "supported", "output"} <= keys:
+            return "Model Compilation"
+        if {"process_id", "external_particles", "helicities"} <= keys:
+            return "Process Physics"
+    name = class_name.removesuffix("Result")
+    words: list[str] = []
+    current = ""
+    for character in name:
+        if current and character.isupper() and not current[-1].isupper():
+            words.append(current)
+            current = character
+        else:
+            current += character
+    if current:
+        words.append(current)
+    if words and name not in {"dict", "tuple", "list"}:
+        return " ".join(words)
+    return "pyAmpliCol Result"
+
+
+def _record_color(key: str, text: str, *, color: bool) -> str:
+    normalized = key.casefold().replace("_", " ")
+    if normalized in {"name", "check", "field", "id", "key"}:
+        return _paint(text, "CYAN", enabled=color)
+    if normalized in {"action", "kind", "request", "mode"}:
+        return _paint(text, "MAGENTA", enabled=color)
+    if normalized in {"status", "supported", "available", "ok"}:
+        return _colored(text, key=key, enabled=color)
+    return text
+
+
+def _record_sequence_summary(
+    records: Sequence[object],
+    *,
+    prettytable: Any,
+    color: bool,
+    title: str,
+) -> str:
+    mappings = tuple(entry for entry in records if isinstance(entry, Mapping))
+    if len(mappings) != len(records):
+        table = prettytable.PrettyTable(("#", "value"))
+        table.align["#"] = "r"
+        table.align["value"] = "l"
+        table.max_width["value"] = 100
+        for index, entry in enumerate(records, start=1):
+            table.add_row((index, _value_text(entry)))
+    else:
+        ordered_keys: list[str] = []
+        for record in mappings:
+            for raw_key in record:
+                key = str(raw_key)
+                if key not in ordered_keys:
+                    ordered_keys.append(key)
+        visible_keys = ordered_keys[:6]
+        has_remainder = len(ordered_keys) > len(visible_keys)
+        headings = tuple(key.replace("_", " ") for key in visible_keys)
+        if has_remainder:
+            headings += ("other fields",)
+        table = prettytable.PrettyTable(headings or ("value",))
+        table.align = "l"
+        for heading in headings:
+            if heading == "name":
+                table.max_width[heading] = 68
+            elif heading in {"description", "detail"}:
+                table.max_width[heading] = 60
+            else:
+                table.max_width[heading] = 34
+        for record in mappings:
+            row = [
+                _record_color(
+                    key,
+                    _value_text(record.get(key)),
+                    color=color,
+                )
+                for key in visible_keys
+            ]
+            if has_remainder:
+                remainder = {
+                    key: record.get(key) for key in ordered_keys[len(visible_keys) :]
+                }
+                row.append(_value_text(remainder))
+            table.add_row(tuple(row) if row else ("N/A",))
+    table.title = _paint(title, "CYAN", enabled=color)
+    table.hrules = prettytable.HRuleStyle.FRAME
+    return cast(str, table.get_string())
+
+
+def _flatten_record(
+    value: Mapping[str, object],
+    *,
+    prefix: str = "",
+) -> tuple[tuple[str, object], ...]:
+    rows: list[tuple[str, object]] = []
+    for raw_key, entry in value.items():
+        key = str(raw_key).replace("_", " ")
+        path = f"{prefix}.{key}" if prefix else key
+        if isinstance(entry, Mapping):
+            if entry:
+                rows.extend(_flatten_record(entry, prefix=path))
+            else:
+                rows.append((path, entry))
+        else:
+            rows.append((path, entry))
+    return tuple(rows)
+
+
+def _mapping_summary(
+    value: object,
+    plain: Mapping[str, object],
+    *,
+    prettytable: Any,
+    color: bool,
+) -> str:
+    title = _human_result_title(value, plain)
+    if title == "Resolved Configuration" and all(
+        isinstance(plain.get(key), Mapping) for key in ("requested", "effective")
+    ):
+        sections: list[str] = []
+        for key in ("requested", "effective"):
+            configuration = cast(Mapping[str, object], plain[key])
+            section = prettytable.PrettyTable(("field", "value"))
+            section.title = _paint(
+                f"{key.title()} Configuration",
+                "CYAN",
+                enabled=color,
+            )
+            section.align = "l"
+            section.max_width["field"] = 42
+            section.max_width["value"] = 74
+            section.hrules = prettytable.HRuleStyle.FRAME
+            for field, entry in _flatten_record(configuration):
+                section.add_row(
+                    (
+                        _paint(field, "CYAN", enabled=color),
+                        _record_color(
+                            field.rsplit(".", maxsplit=1)[-1],
+                            _value_text(entry),
+                            color=color,
+                        ),
+                    )
+                )
+            sections.append(cast(str, section.get_string()))
+        adjustments = plain.get("adjustments")
+        if isinstance(adjustments, Sequence) and not isinstance(
+            adjustments, (str, bytes)
+        ):
+            sections.append(
+                _record_sequence_summary(
+                    adjustments,
+                    prettytable=prettytable,
+                    color=color,
+                    title="Adjustments",
+                )
+            )
+        return "\n\n".join(sections)
+    table = prettytable.PrettyTable(("field", "value"))
+    table.title = _paint(title, "CYAN", enabled=color)
+    table.align["field"] = "l"
+    table.align["value"] = "l"
+    table.max_width["field"] = 40
+    table.max_width["value"] = 88
+    table.hrules = prettytable.HRuleStyle.FRAME
+    for key, entry in _flatten_record(plain):
+        table.add_row(
+            (
+                _paint(key, "CYAN", enabled=color),
+                _record_color(
+                    key.rsplit(".", maxsplit=1)[-1],
+                    _value_text(entry),
+                    color=color,
+                ),
+            )
+        )
+    sections = [cast(str, table.get_string())]
+    for raw_key, entry in plain.items():
+        if (
+            isinstance(entry, Sequence)
+            and not isinstance(entry, (str, bytes))
+            and entry
+            and all(isinstance(item, Mapping) for item in entry)
+        ):
+            sections.append(
+                _record_sequence_summary(
+                    entry,
+                    prettytable=prettytable,
+                    color=color,
+                    title=str(raw_key).replace("_", " ").title(),
+                )
+            )
+    return "\n\n".join(sections)
+
+
+def render_summary(value: object, *, color: bool = False) -> str | None:
+    """Return colored human tables for every CLI result shape."""
+
+    try:
+        prettytable: Any = importlib.import_module("prettytable")
+    except ImportError:
+        return None
+    from pyamplicol.api.results import (
+        BenchmarkResult,
+        GenerationResult,
+        ResolvedEvaluation,
+    )
+
+    if isinstance(value, GenerationResult):
+        return _generation_summary(value, prettytable=prettytable, color=color)
+    if isinstance(value, ResolvedEvaluation):
+        return _resolved_evaluation_summary(
+            value,
+            prettytable=prettytable,
+            color=color,
+        )
+    if isinstance(value, tuple) and all(_is_evaluation_value(item) for item in value):
+        return _total_evaluation_summary(
+            cast(tuple[object, ...], value),
+            prettytable=prettytable,
+            color=color,
+        )
+    plain = _plain(value)
+    if isinstance(value, BenchmarkResult):
+        return _benchmark_summary(value, prettytable=prettytable, color=color)
+    if (
+        isinstance(plain, Mapping)
+        and plain.get("kind") == "pyamplicol-artifact-inspection"
+    ):
+        return _artifact_inspection_summary(
+            plain,
+            prettytable=prettytable,
+            color=color,
+        )
+    if isinstance(plain, Mapping) and isinstance(plain.get("process_group"), Mapping):
+        # `inspect --process MEMBER --full-physics` of a grouped process
+        physics = {key: entry for key, entry in plain.items() if key != "process_group"}
+        return "\n\n".join(
+            (
+                _process_group_selection_summary(
+                    cast(Mapping[str, object], plain["process_group"]),
+                    prettytable=prettytable,
+                    color=color,
+                ),
+                _mapping_summary(
+                    physics, physics, prettytable=prettytable, color=color
+                ),
+            )
+        )
+    if isinstance(plain, Mapping):
+        return _mapping_summary(
+            value,
+            plain,
+            prettytable=prettytable,
+            color=color,
+        )
+    if isinstance(plain, Sequence) and not isinstance(plain, (str, bytes)):
+        return _record_sequence_summary(
+            plain,
+            prettytable=prettytable,
+            color=color,
+            title=_human_result_title(value, plain),
+        )
+    table = prettytable.PrettyTable(("field", "value"))
+    table.title = _paint(_human_result_title(value, plain), "CYAN", enabled=color)
+    table.align = "l"
+    table.hrules = prettytable.HRuleStyle.FRAME
+    table.add_row(
+        (
+            _paint("result", "CYAN", enabled=color),
+            _paint(_value_text(plain), "GREEN", enabled=color),
+        )
+    )
+    return cast(str, table.get_string())
+
+
+__all__ = ["render_summary"]
diff --git a/pyamplicol/src/pyamplicol/runtime/__init__.py b/pyamplicol/src/pyamplicol/runtime/__init__.py
new file mode 100644
index 0000000000..fc4aaa6573
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/__init__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: 0BSD
+"""Lazy adapter for the native Rusticol runtime extension."""
+
+from .backend import RusticolRuntimeBackend, load_runtime_backend
+
+__all__ = ["RusticolRuntimeBackend", "load_runtime_backend"]
diff --git a/pyamplicol/src/pyamplicol/runtime/_color_topology_exact.py b/pyamplicol/src/pyamplicol/runtime/_color_topology_exact.py
new file mode 100644
index 0000000000..441d57bbf8
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/_color_topology_exact.py
@@ -0,0 +1,634 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact replay of authenticated NLC/full-colour topology quotients."""
+
+from __future__ import annotations
+
+import struct
+from collections.abc import Iterator, Mapping, Sequence
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation
+from typing import cast
+
+from pyamplicol.api.errors import ArtifactError, EvaluationError
+from pyamplicol.runtime._color_weight_exact import exact_color_weight
+
+_ZERO = Decimal(0)
+_ONE = Decimal(1)
+_TWO = Decimal(2)
+_ComplexDecimal = tuple[Decimal, Decimal]
+
+
+@dataclass(frozen=True, slots=True)
+class ExactColorReplayRoute:
+    source_output_indices: tuple[int, ...]
+    target_group_index: int
+    factor: _ComplexDecimal
+
+
+@dataclass(frozen=True, slots=True)
+class ExactColorReplayMapping:
+    input_mapping: tuple[tuple[int, int], ...]
+    routes: tuple[ExactColorReplayRoute, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactColorContractionEntry:
+    left_group_index: int
+    right_group_index: int
+    weight: _ComplexDecimal
+    symmetry_factor: Decimal
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactRepeatedColorContraction:
+    component_count: int
+    component_group_indices: tuple[int, ...]
+    entries: tuple[_ExactColorContractionEntry, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ExactColorReplayPlan:
+    mappings: tuple[ExactColorReplayMapping, ...]
+    physical_group_members: tuple[tuple[tuple[int, Decimal], ...], ...]
+    expanded_entries: tuple[_ExactColorContractionEntry, ...]
+    repeated_contraction: _ExactRepeatedColorContraction | None
+    helicity_ids: tuple[str, ...]
+    color_ids: tuple[str, ...]
+
+    @property
+    def physical_group_count(self) -> int:
+        return len(self.physical_group_members)
+
+
+def parse_exact_color_topology_replay(
+    execution: Mapping[str, object],
+    physics: Mapping[str, object],
+    public_permutation: tuple[int, ...] | None,
+) -> ExactColorReplayPlan | None:
+    """Validate and bind one exact colour-topology replay plan.
+
+    The amplitude replay and physical colour contraction live in the runtime
+    amplitude stage.  They are authenticated artifact data; this parser binds
+    their stable group IDs to materialized root outputs and public helicities.
+    """
+
+    runtime_schema = _mapping(execution.get("runtime_schema"), "runtime schema")
+    amplitude_stage = _mapping(
+        runtime_schema.get("amplitude_stage"), "runtime amplitude stage"
+    )
+    raw_replay = amplitude_stage.get("color_topology_replay")
+    proof = runtime_schema.get("color_topology_replay")
+    if proof is None:
+        compiled = execution.get("compiled")
+        if isinstance(compiled, Mapping):
+            proof = compiled.get("color_topology_replay")
+    if raw_replay is None:
+        if isinstance(proof, Mapping) and proof.get("enabled") is True:
+            raise ArtifactError(
+                "enabled color topology replay has no exact amplitude gather"
+            )
+        return None
+    replay = _mapping(raw_replay, "color topology replay amplitude gather")
+    if not isinstance(proof, Mapping) or proof.get("enabled") is not True:
+        raise ArtifactError(
+            "color topology replay amplitude gather has no enabled proof"
+        )
+
+    particles = _records(physics, "external_particles", "external particles")
+    external_count = len(particles)
+    if public_permutation is not None and (
+        len(public_permutation) != external_count
+        or set(public_permutation) != set(range(external_count))
+    ):
+        raise ArtifactError("color topology replay has an invalid public permutation")
+    if proof.get("contract_version") != 3:
+        raise ArtifactError("color topology replay proof has an unsupported contract")
+    if proof.get("mode") != "external-label-permutation":
+        raise ArtifactError("color topology replay proof has an unsupported mode")
+    accuracy = str(physics.get("color_accuracy"))
+    if accuracy not in {"nlc", "full"} or proof.get("color_accuracy") != accuracy:
+        raise ArtifactError("color topology replay has inconsistent colour accuracy")
+    if _integer(replay.get("contract_version"), "color replay contract") != 1:
+        raise ArtifactError("color topology replay amplitude contract is unsupported")
+
+    roots = _records(amplitude_stage, "roots", "amplitude roots")
+    output_count = _integer(amplitude_stage.get("output_count"), "amplitude count")
+    outputs_by_group: dict[int, list[int]] = {}
+    seen_outputs: set[int] = set()
+    for root_index, root in enumerate(roots):
+        output_index = _integer(root.get("output_index"), "amplitude output index")
+        group_id = _integer(root.get("coherent_group_id"), "coherent group ID")
+        if output_index >= output_count or output_index in seen_outputs:
+            raise ArtifactError("color replay amplitude outputs are not unique")
+        seen_outputs.add(output_index)
+        outputs_by_group.setdefault(group_id, []).append(output_index)
+        root_id = _integer(root.get("root_id"), "amplitude root ID")
+        if root_id != root_index:
+            raise ArtifactError("color replay amplitude roots are not contiguous")
+    if seen_outputs != set(range(output_count)):
+        raise ArtifactError("color replay amplitude outputs are incomplete")
+
+    physical_group_count = _integer(
+        replay.get("physical_group_count"), "physical color group count"
+    )
+    raw_groups = _records(replay, "physical_groups", "physical color groups")
+    if physical_group_count == 0 or len(raw_groups) != physical_group_count:
+        raise ArtifactError("color replay physical group count is inconsistent")
+
+    helicities = _records(physics, "helicities", "physical helicities")
+    colors = _records(physics, "color_components", "physical color components")
+    if len(colors) != 1:
+        raise ArtifactError("color topology replay requires contracted colour")
+    helicity_ids = tuple(str(item.get("id")) for item in helicities)
+    color_ids = tuple(str(item.get("id")) for item in colors)
+    if len(set(helicity_ids)) != len(helicity_ids) or not color_ids[0]:
+        raise ArtifactError("color replay public axes contain duplicate IDs")
+    physical_by_values: dict[tuple[int, ...], tuple[int, Decimal]] = {}
+    for index, helicity in enumerate(helicities):
+        values = _integer_sequence(
+            helicity.get("values"), external_count, "physical helicity values"
+        )
+        coefficient = _decimal(
+            helicity.get("coefficient", 1), "physical helicity coefficient"
+        )
+        if coefficient < _ZERO or values in physical_by_values:
+            raise ArtifactError("physical helicity metadata is inconsistent")
+        physical_by_values[values] = (index, coefficient)
+
+    physical_group_members = []
+    for index, group in enumerate(raw_groups):
+        if _integer(group.get("group_id"), "physical group ID") != index:
+            raise ArtifactError("color replay physical group IDs are not contiguous")
+        if _integer(group.get("color_sector_id"), "physical color sector") < 0:
+            raise ArtifactError("color replay physical color sector is invalid")
+        color_word = _nonempty_integer_sequence(
+            group.get("color_word"), "physical color word"
+        )
+        if any(label < 1 or label > external_count for label in color_word):
+            raise ArtifactError("color replay physical color word is out of range")
+        representative = _integer_sequence(
+            group.get("helicities"), external_count, "physical group helicity"
+        )
+        if public_permutation is not None:
+            representative = _permute_to_public(representative, public_permutation)
+        reuse_weight = _decimal(
+            group.get("helicity_weight"), "physical group helicity weight"
+        )
+        if reuse_weight <= _ZERO:
+            raise ArtifactError("color replay helicity weight must be positive")
+        members = [representative]
+        if reuse_weight > _ONE:
+            if reuse_weight != _TWO:
+                raise ArtifactError(
+                    "color replay has an unsupported helicity reuse weight"
+                )
+            flipped = tuple(-value for value in representative)
+            if flipped != representative:
+                members.append(flipped)
+        indexed = []
+        total_weight = _ZERO
+        for values in members:
+            try:
+                physical_index, weight = physical_by_values[values]
+            except KeyError as exc:
+                raise ArtifactError(
+                    "replayed physical helicity is absent from public metadata"
+                ) from exc
+            total_weight += weight
+            indexed.append((physical_index, weight))
+        if total_weight <= _ZERO:
+            raise ArtifactError("replayed physical helicity has no positive weight")
+        physical_group_members.append(
+            tuple((member, weight / total_weight) for member, weight in indexed)
+        )
+
+    raw_mappings = _records(replay, "mappings", "color replay mappings")
+    if not raw_mappings:
+        raise ArtifactError("color replay amplitude gather has no mappings")
+    mappings = []
+    covered_targets: set[int] = set()
+    input_mappings: list[tuple[tuple[int, int], ...]] = []
+    for raw_mapping in raw_mappings:
+        input_mapping = _label_permutation(
+            raw_mapping.get("label_permutation"), external_count
+        )
+        input_mappings.append(input_mapping)
+        raw_routes = _records(raw_mapping, "group_routes", "color replay routes")
+        if not raw_routes:
+            raise ArtifactError("color replay mapping has no group routes")
+        routes = []
+        mapping_sources: set[int] = set()
+        for raw_route in raw_routes:
+            source_id = _integer(
+                raw_route.get("source_group_id"), "color replay source group"
+            )
+            try:
+                source_outputs = tuple(outputs_by_group[source_id])
+            except KeyError as exc:
+                raise ArtifactError(
+                    "color replay route references an unknown materialized group"
+                ) from exc
+            target = _integer(
+                raw_route.get("target_group_id"), "color replay target group"
+            )
+            if target >= physical_group_count:
+                raise ArtifactError("color replay route target is out of range")
+            factor = _complex_pair(raw_route.get("factor"), "color replay factor")
+            if (
+                factor == (_ZERO, _ZERO)
+                or source_id in mapping_sources
+                or target in covered_targets
+            ):
+                raise ArtifactError("color replay routes are not a bijection")
+            mapping_sources.add(source_id)
+            covered_targets.add(target)
+            routes.append(ExactColorReplayRoute(source_outputs, target, factor))
+        routes.sort(key=lambda route: route.target_group_index)
+        mappings.append(ExactColorReplayMapping(input_mapping, tuple(routes)))
+    if covered_targets != set(range(physical_group_count)):
+        raise ArtifactError("color replay routes do not cover every physical group")
+    if input_mappings != sorted(input_mappings) or len(set(input_mappings)) != len(
+        input_mappings
+    ):
+        raise ArtifactError("color replay input mappings are not canonical")
+    _validate_proof_mapping_catalog(proof, tuple(input_mappings), external_count)
+
+    contraction = _mapping(
+        amplitude_stage.get("color_contraction"),
+        "color replay physical contraction",
+    )
+    if contraction.get("supported") is not True:
+        raise ArtifactError("color replay physical contraction is unsupported")
+    if contraction.get("includes_color_factor") is not True:
+        raise ArtifactError("color replay contraction omits the colour factor")
+    if (
+        _integer(contraction.get("group_count"), "color contraction group count")
+        != physical_group_count
+    ):
+        raise ArtifactError("color replay contraction group count is inconsistent")
+    expanded = tuple(
+        _parse_expanded_entry(entry, physical_group_count)
+        for entry in _records(contraction, "entries", "color contraction entries")
+    )
+    raw_repeated = contraction.get("repeated_block")
+    repeated = (
+        None
+        if raw_repeated is None
+        else _parse_repeated_contraction(raw_repeated, physical_group_count)
+    )
+    if (bool(expanded) == (repeated is not None)) or (
+        not expanded and repeated is None
+    ):
+        raise ArtifactError(
+            "color replay contraction must use exactly one storage layout"
+        )
+    plan = ExactColorReplayPlan(
+        mappings=tuple(mappings),
+        physical_group_members=tuple(physical_group_members),
+        expanded_entries=expanded,
+        repeated_contraction=repeated,
+        helicity_ids=helicity_ids,
+        color_ids=color_ids,
+    )
+    for entry in _contraction_entries(plan):
+        if (
+            plan.physical_group_members[entry.left_group_index]
+            != plan.physical_group_members[entry.right_group_index]
+        ):
+            raise ArtifactError(
+                "color contraction mixes distinct replayed physical helicities"
+            )
+    return plan
+
+
+def apply_exact_color_replay_input_mapping(
+    point: tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...],
+    mapping: Sequence[tuple[int, int]],
+) -> tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]:
+    mapped = list(point)
+    for representative, sector in mapping:
+        mapped[representative] = point[sector]
+    return tuple(mapped)
+
+
+def reduce_exact_color_topology_replay(
+    amplitudes: Sequence[Sequence[_ComplexDecimal]],
+    plan: ExactColorReplayPlan,
+    point_count: int,
+    normalization: Decimal,
+    selected_helicities: Sequence[str] | None,
+    selected_colors: Sequence[str] | None,
+) -> tuple[
+    tuple[tuple[tuple[Decimal, ...], ...], ...],
+    tuple[str, ...],
+    tuple[str, ...],
+]:
+    """Gather materialized amplitudes and apply the physical colour matrix."""
+
+    if selected_colors is not None:
+        raise EvaluationError(
+            "LC color-flow selection is unavailable for NLC/full artifacts"
+        )
+    selected_h = _selected_indices(plan.helicity_ids, selected_helicities, "helicity")
+    expected = point_count * len(plan.mappings)
+    if len(amplitudes) != expected:
+        raise ArtifactError("color replay amplitude point count is inconsistent")
+    full_points = []
+    for point_index in range(point_count):
+        physical = [(_ZERO, _ZERO) for _ in range(plan.physical_group_count)]
+        for mapping_index, mapping in enumerate(plan.mappings):
+            raw = amplitudes[mapping_index * point_count + point_index]
+            for route in mapping.routes:
+                value = (_ZERO, _ZERO)
+                for output_index in route.source_output_indices:
+                    if output_index >= len(raw):
+                        raise ArtifactError(
+                            "color replay materialized amplitude is too short"
+                        )
+                    value = _complex_add(value, raw[output_index])
+                physical[route.target_group_index] = _complex_mul(value, route.factor)
+        full = [_ZERO for _ in plan.helicity_ids]
+        for entry in _contraction_entries(plan):
+            left = physical[entry.left_group_index]
+            right = physical[entry.right_group_index]
+            product_real = left[0] * right[0] + left[1] * right[1]
+            product_imaginary = left[1] * right[0] - left[0] * right[1]
+            contribution = (
+                normalization
+                * entry.symmetry_factor
+                * (entry.weight[0] * product_real - entry.weight[1] * product_imaginary)
+            )
+            for helicity_index, weight in plan.physical_group_members[
+                entry.left_group_index
+            ]:
+                full[helicity_index] += contribution * weight
+        full_points.append(
+            tuple((full[helicity_index],) for helicity_index in selected_h)
+        )
+    return (
+        tuple(full_points),
+        tuple(plan.helicity_ids[index] for index in selected_h),
+        plan.color_ids,
+    )
+
+
+def _parse_expanded_entry(
+    raw: Mapping[str, object], group_count: int
+) -> _ExactColorContractionEntry:
+    left = _integer(raw.get("left_group_id"), "color contraction left group")
+    right = _integer(raw.get("right_group_id"), "color contraction right group")
+    if left >= group_count or right >= group_count:
+        raise ArtifactError("color contraction group ID is out of range")
+    return _ExactColorContractionEntry(
+        left,
+        right,
+        exact_color_weight(raw)
+        or _complex_pair(raw.get("weight"), "color contraction weight"),
+        _decimal(raw.get("symmetry_factor", 1), "color contraction symmetry"),
+    )
+
+
+def _parse_repeated_contraction(
+    raw: object, group_count: int
+) -> _ExactRepeatedColorContraction:
+    block = _mapping(raw, "repeated color contraction")
+    component_count = _integer(
+        block.get("component_count"), "repeated color component count"
+    )
+    group_ids = _integer_sequence(
+        block.get("component_group_ids"),
+        group_count,
+        "repeated color group map",
+    )
+    if (
+        component_count < 2
+        or len(group_ids) != group_count
+        or len(group_ids) % component_count
+        or set(group_ids) != set(range(group_count))
+    ):
+        raise ArtifactError("repeated color contraction group map is invalid")
+    groups_per_component = group_count // component_count
+    entries = []
+    for raw_entry in _records(block, "entries", "repeated color entries"):
+        left = _integer(raw_entry.get("left_group_index"), "repeated left group")
+        right = _integer(raw_entry.get("right_group_index"), "repeated right group")
+        if left >= groups_per_component or right >= groups_per_component:
+            raise ArtifactError("repeated color contraction index is out of range")
+        entries.append(
+            _ExactColorContractionEntry(
+                left,
+                right,
+                exact_color_weight(raw_entry)
+                or _complex_pair(raw_entry.get("weight"), "repeated color weight"),
+                _decimal(
+                    raw_entry.get("symmetry_factor", 1),
+                    "repeated color symmetry",
+                ),
+            )
+        )
+    if not entries:
+        raise ArtifactError("repeated color contraction is empty")
+    return _ExactRepeatedColorContraction(component_count, group_ids, tuple(entries))
+
+
+def _contraction_entries(
+    plan: ExactColorReplayPlan,
+) -> Iterator[_ExactColorContractionEntry]:
+    if plan.repeated_contraction is None:
+        yield from plan.expanded_entries
+        return
+    block = plan.repeated_contraction
+    for component in range(block.component_count):
+        for entry in block.entries:
+            yield _ExactColorContractionEntry(
+                block.component_group_indices[
+                    entry.left_group_index * block.component_count + component
+                ],
+                block.component_group_indices[
+                    entry.right_group_index * block.component_count + component
+                ],
+                entry.weight,
+                entry.symmetry_factor,
+            )
+
+
+def _validate_proof_mapping_catalog(
+    proof: Mapping[str, object],
+    actual: tuple[tuple[tuple[int, int], ...], ...],
+    external_count: int,
+) -> None:
+    groups = _records(proof, "groups", "color replay proof groups")
+    expected: set[tuple[tuple[int, int], ...]] = set()
+    for group in groups:
+        permutations = _records(
+            group, "sector_permutations", "color replay proof permutations"
+        )
+        for permutation in permutations:
+            expected.add(
+                _label_permutation(permutation.get("label_permutation"), external_count)
+            )
+    residual = _integer_members(
+        proof.get("residual_sector_ids"), "color replay residual sectors"
+    )
+    if residual:
+        expected.add(())
+    if tuple(sorted(expected)) != actual:
+        raise ArtifactError(
+            "color replay proof mappings do not match the amplitude gather"
+        )
+
+
+def _selected_indices(
+    available: Sequence[str], requested: Sequence[str] | None, kind: str
+) -> tuple[int, ...]:
+    if requested is None:
+        return tuple(range(len(available)))
+    if not requested:
+        raise EvaluationError(f"{kind} selection must not be empty")
+    unknown = sorted(set(requested) - set(available))
+    if unknown:
+        raise EvaluationError(f"unknown resolved {kind} ID {unknown[0]!r}")
+    selected = set(requested)
+    return tuple(
+        index for index, identifier in enumerate(available) if identifier in selected
+    )
+
+
+def _label_permutation(raw: object, external_count: int) -> tuple[tuple[int, int], ...]:
+    if isinstance(raw, (str, bytes)) or not isinstance(raw, Sequence):
+        raise ArtifactError("color replay label permutation is invalid")
+    representatives: set[int] = set()
+    sectors: set[int] = set()
+    result = []
+    for item in raw:
+        record = _mapping(item, "color replay label permutation entry")
+        representative = _integer(
+            record.get("representative_label"), "representative label"
+        )
+        sector = _integer(record.get("sector_label"), "sector label")
+        if (
+            not 1 <= representative <= external_count
+            or not 1 <= sector <= external_count
+        ):
+            raise ArtifactError("color replay label permutation is out of range")
+        representative -= 1
+        sector -= 1
+        if representative in representatives or sector in sectors:
+            raise ArtifactError("color replay label permutation is not one-to-one")
+        representatives.add(representative)
+        sectors.add(sector)
+        if representative != sector:
+            result.append((representative, sector))
+    if representatives != sectors:
+        raise ArtifactError("color replay label permutation support is inconsistent")
+    return tuple(sorted(result))
+
+
+def _permute_to_public(
+    representative: tuple[int, ...], permutation: tuple[int, ...]
+) -> tuple[int, ...]:
+    public = [0] * len(representative)
+    for representative_index, public_index in enumerate(permutation):
+        public[public_index] = representative[representative_index]
+    return tuple(public)
+
+
+def _complex_add(left: _ComplexDecimal, right: _ComplexDecimal) -> _ComplexDecimal:
+    return left[0] + right[0], left[1] + right[1]
+
+
+def _complex_mul(left: _ComplexDecimal, right: _ComplexDecimal) -> _ComplexDecimal:
+    return (
+        left[0] * right[0] - left[1] * right[1],
+        left[0] * right[1] + left[1] * right[0],
+    )
+
+
+def _complex_pair(value: object, context: str) -> _ComplexDecimal:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} is not complex data")
+    if len(value) != 2:
+        raise ArtifactError(f"{context} is not complex data")
+    return _decimal(value[0], context), _decimal(value[1], context)
+
+
+def _decimal(value: object, context: str) -> Decimal:
+    try:
+        if isinstance(value, str) and value.startswith("binary64:"):
+            bits = value.removeprefix("binary64:")
+            if len(bits) != 16:
+                raise ValueError("binary64 payload must contain 16 hexadecimal digits")
+            result = Decimal.from_float(struct.unpack(">d", bytes.fromhex(bits))[0])
+        else:
+            result = value if isinstance(value, Decimal) else Decimal(str(value))
+    except (InvalidOperation, TypeError, ValueError) as exc:
+        raise ArtifactError(f"{context} is not a decimal scalar") from exc
+    if not result.is_finite():
+        raise ArtifactError(f"{context} must be finite")
+    return result
+
+
+def _mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise ArtifactError(f"{context} is not an object")
+    return cast(Mapping[str, object], value)
+
+
+def _records(
+    mapping: Mapping[str, object], key: str, context: str
+) -> tuple[Mapping[str, object], ...]:
+    value = mapping.get(key)
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} are invalid")
+    return tuple(_mapping(item, f"{context} entry") for item in value)
+
+
+def _integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise ArtifactError(f"{context} is not a non-negative integer")
+    return value
+
+
+def _integer_sequence(
+    value: object, expected_length: int, context: str
+) -> tuple[int, ...]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} are invalid")
+    result = tuple(
+        int(cast(int | float | str, item))
+        for item in value
+        if not isinstance(item, bool)
+    )
+    if len(result) != expected_length or len(result) != len(value):
+        raise ArtifactError(f"{context} have an inconsistent length")
+    return result
+
+
+def _nonempty_integer_sequence(value: object, context: str) -> tuple[int, ...]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} is invalid")
+    try:
+        result = tuple(int(cast(int | float | str, item)) for item in value)
+    except (TypeError, ValueError) as exc:
+        raise ArtifactError(f"{context} is invalid") from exc
+    if not result:
+        raise ArtifactError(f"{context} is empty")
+    return result
+
+
+def _integer_members(value: object, context: str) -> tuple[int, ...]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} are invalid")
+    result = tuple(_integer(item, f"{context} entry") for item in value)
+    if len(set(result)) != len(result):
+        raise ArtifactError(f"{context} contain duplicates")
+    return result
+
+
+__all__ = [
+    "ExactColorReplayMapping",
+    "ExactColorReplayPlan",
+    "apply_exact_color_replay_input_mapping",
+    "parse_exact_color_topology_replay",
+    "reduce_exact_color_topology_replay",
+]
diff --git a/pyamplicol/src/pyamplicol/runtime/_color_weight_exact.py b/pyamplicol/src/pyamplicol/runtime/_color_weight_exact.py
new file mode 100644
index 0000000000..06e6279960
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/_color_weight_exact.py
@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: 0BSD
+"""Read retained rational colour weights at the active arithmetic precision."""
+
+from collections.abc import Mapping, Sequence
+from decimal import Decimal
+
+from pyamplicol.api.errors import ArtifactError
+
+
+def exact_color_weight(record: Mapping[str, object]) -> tuple[Decimal, Decimal] | None:
+    raw = record.get("exact_weight")
+    if raw is None:
+        return None
+    if (
+        not isinstance(raw, Sequence)
+        or isinstance(raw, (str, bytes))
+        or len(raw) != 4
+        or any(not isinstance(value, str) for value in raw)
+    ):
+        raise ArtifactError("exact colour weight must contain four integer strings")
+    try:
+        real_numerator, real_denominator, imag_numerator, imag_denominator = (
+            int(value) for value in raw
+        )
+    except ValueError as exc:
+        raise ArtifactError("exact colour weight contains an invalid integer") from exc
+    if real_denominator <= 0 or imag_denominator <= 0:
+        raise ArtifactError("exact colour weight denominators must be positive")
+    return (
+        Decimal(real_numerator) / Decimal(real_denominator),
+        Decimal(imag_numerator) / Decimal(imag_denominator),
+    )
diff --git a/pyamplicol/src/pyamplicol/runtime/_double_double.py b/pyamplicol/src/pyamplicol/runtime/_double_double.py
new file mode 100644
index 0000000000..bf930add15
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/_double_double.py
@@ -0,0 +1,134 @@
+# SPDX-License-Identifier: 0BSD
+"""Call-owned DoubleFloat arithmetic with lossless Decimal input transport.
+
+Decimal is the transport container, not the arithmetic backend. Every operation
+is evaluated by Symbolica's double-double backend; no Decimal context or module
+global is changed. The owner retains its small scalar evaluators locally.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from decimal import Decimal
+from typing import Any, ClassVar
+
+from pyamplicol.api.errors import EvaluationError
+from pyamplicol.runtime.symbolica_exact import _upcast_decimal
+
+
+class _DoubleDoubleScalar(Decimal):
+    _arithmetic: ClassVar[DoubleDoubleArithmetic]
+
+    def __new__(cls, value: Any = 0) -> _DoubleDoubleScalar:
+        if isinstance(value, cls):
+            return value
+        return cls._arithmetic.operation("identity", Decimal(value))
+
+    def __add__(self, other: Any) -> _DoubleDoubleScalar:
+        return self._arithmetic.operation("add", self, other)
+
+    __radd__ = __add__
+
+    def __sub__(self, other: Any) -> _DoubleDoubleScalar:
+        return self._arithmetic.operation("sub", self, other)
+
+    def __rsub__(self, other: Any) -> _DoubleDoubleScalar:
+        return self._arithmetic.operation("sub", other, self)
+
+    def __mul__(self, other: Any) -> _DoubleDoubleScalar:
+        return self._arithmetic.operation("mul", self, other)
+
+    __rmul__ = __mul__
+
+    def __truediv__(self, other: Any) -> _DoubleDoubleScalar:
+        return self._arithmetic.operation("div", self, other)
+
+    def __rtruediv__(self, other: Any) -> _DoubleDoubleScalar:
+        return self._arithmetic.operation("div", other, self)
+
+    def __neg__(self) -> _DoubleDoubleScalar:
+        return Decimal.__new__(type(self), self.copy_negate())
+
+    def __abs__(self) -> _DoubleDoubleScalar:
+        return Decimal.__new__(type(self), self.copy_abs())
+
+    def __pos__(self) -> _DoubleDoubleScalar:
+        return self
+
+    def __pow__(self, exponent: Any, modulo: Any = None) -> _DoubleDoubleScalar:
+        if modulo is not None or int(exponent) != exponent:
+            raise TypeError("double-double scalar powers require an integer")
+        exponent = int(exponent)
+        if exponent < 0:
+            return type(self)(1) / self.__pow__(-exponent)
+        result, factor = type(self)(1), self
+        while exponent:
+            if exponent & 1:
+                result *= factor
+            exponent >>= 1
+            if exponent:
+                factor *= factor
+        return result
+
+    def sqrt(self, context: Any = None) -> _DoubleDoubleScalar:
+        return self._arithmetic.operation("sqrt", self)
+
+
+class DoubleDoubleArithmetic:
+    """An independently owned arithmetic backend, never a process-wide mode."""
+
+    def __init__(self) -> None:
+        self.scalar = type(
+            "_OwnedDoubleDouble", (_DoubleDoubleScalar,), {"_arithmetic": self}
+        )
+        self._evaluators: dict[str, Any] = {}
+
+    def operation(self, operation: str, *values: Any) -> _DoubleDoubleScalar:
+        from symbolica import E
+
+        from pyamplicol._internal.physics.symbols import symbols
+
+        evaluator = self._evaluators.get(operation)
+        if evaluator is None:
+            parameters = [
+                symbols.symbol(f"runtime::double_double::{name}")
+                for name in (
+                    ("x",) if operation in {"identity", "sqrt"} else ("x", "y")
+                )
+            ]
+            expressions: dict[str, Callable[..., Any]] = {
+                "identity": lambda x: x,
+                "add": lambda x, y: x + y,
+                "sub": lambda x, y: x - y,
+                "mul": lambda x, y: x * y,
+                "div": lambda x, y: x / y,
+                "sqrt": lambda x: x ** E("1/2"),
+            }
+            expression = expressions[operation](*parameters)
+            evaluator = expression.evaluator(parameters, iterations=0, n_cores=1)
+            self._evaluators[operation] = evaluator
+        # 32 selects Symbolica DoubleFloat, transported through a 106-bit float
+        # (about 31 significant digits). Padding inputs adds no information.
+        result = evaluator.evaluate_with_prec(
+            [_upcast_decimal(Decimal(value), 80) for value in values], 32
+        )[0].to_decimal()
+        if not result.is_finite():
+            raise EvaluationError(f"non-finite double-double {operation}")
+        return Decimal.__new__(self.scalar, result)
+
+
+def correlated_precision(precision: int, arithmetic: str) -> int:
+    """Validate public arithmetic and return the amplitude transport precision."""
+    if type(precision) is not int or precision < 1:
+        raise EvaluationError("precision must be a positive number of decimal digits")
+    if arithmetic == "double-double":
+        if precision > 31:
+            raise EvaluationError(
+                "double-double results support at most 31 decimal digits"
+            )
+        return 31
+    if arithmetic != "arbitrary":
+        raise EvaluationError("arithmetic must be 'arbitrary' or 'double-double'")
+    from pyamplicol.runtime.symbolica_exact import _working_precision
+
+    return _working_precision(precision)
diff --git a/pyamplicol/src/pyamplicol/runtime/_evaluator_payloads.py b/pyamplicol/src/pyamplicol/runtime/_evaluator_payloads.py
new file mode 100644
index 0000000000..a0270b1fd4
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/_evaluator_payloads.py
@@ -0,0 +1,194 @@
+# SPDX-License-Identifier: 0BSD
+"""Artifact-scoped access to retained exact evaluator states."""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Mapping
+from pathlib import Path
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+from pyamplicol.artifacts.manifest import ArtifactManifest, PayloadRecord
+from pyamplicol.artifacts.security import confined_path, normalize_relative_path
+from pyamplicol.generation.evaluator_container import (
+    PacbinError,
+    PacbinMember,
+    PacbinMemberKind,
+    PacbinReader,
+)
+
+_EXTENSION_NAME = "evaluator_payload_container"
+_CONTAINER_KIND = "pyamplicol-evaluator-payload-container"
+_CONTAINER_SCHEMA_VERSION = 1
+_CONTAINER_STORAGE_ABI = "pacbin-v1"
+
+
+class ExactEvaluatorPayloadResolver:
+    """Resolve loose or packed Symbolica evaluator states by artifact path.
+
+    The pacbin index is parsed once. The parsing reader is closed before the
+    resolver is returned; each member read uses its own bounded file stream.
+    Consequently the resolver owns no persistent descriptor and can safely be
+    retained by a lazy exact executor.
+    """
+
+    def __init__(self, manifest: ArtifactManifest) -> None:
+        self._root = manifest.root
+        self._loose = {record.path: record for record in manifest.payloads}
+        self._container_path: Path | None = None
+        self._members: Mapping[str, PacbinMember] = {}
+
+        extension = manifest.extensions.get(_EXTENSION_NAME)
+        if extension is None:
+            return
+        if not isinstance(extension, Mapping):
+            raise ArtifactError(
+                f"extensions.{_EXTENSION_NAME} must be an object"
+            )
+        required = {
+            "kind",
+            "schema_version",
+            "storage_abi",
+            "path",
+            "member_count",
+            "unpacked_size_bytes",
+            "index_sha256",
+        }
+        if set(extension) != required:
+            raise ArtifactError(
+                f"extensions.{_EXTENSION_NAME} has invalid fields"
+            )
+        if (
+            extension.get("kind") != _CONTAINER_KIND
+            or extension.get("schema_version") != _CONTAINER_SCHEMA_VERSION
+            or extension.get("storage_abi") != _CONTAINER_STORAGE_ABI
+        ):
+            raise CompatibilityError(
+                "unsupported evaluator payload container contract"
+            )
+        relative = extension.get("path")
+        if not isinstance(relative, str):
+            raise ArtifactError("evaluator payload container path is not a string")
+        relative = normalize_relative_path(relative)
+        record = self._loose.get(relative)
+        if record is None:
+            raise ArtifactError("evaluator payload container is undeclared")
+        _validate_container_record(record)
+        container_path = confined_path(self._root, relative)
+        try:
+            with PacbinReader.open(container_path, verify_payloads=False) as reader:
+                index = reader.index
+        except (OSError, PacbinError) as exc:
+            raise ArtifactError(
+                f"could not open evaluator payload container {relative}: {exc}"
+            ) from exc
+
+        member_count = extension.get("member_count")
+        unpacked_size = extension.get("unpacked_size_bytes")
+        index_sha256 = extension.get("index_sha256")
+        if (
+            isinstance(member_count, bool)
+            or not isinstance(member_count, int)
+            or member_count != len(index.members)
+            or isinstance(unpacked_size, bool)
+            or not isinstance(unpacked_size, int)
+            or unpacked_size != sum(member.length for member in index.members)
+            or not isinstance(index_sha256, str)
+            or index_sha256 != index.index_sha256
+        ):
+            raise ArtifactError(
+                "evaluator payload container metadata does not match its index"
+            )
+        self._container_path = container_path
+        self._members = {member.logical_path: member for member in index.members}
+
+    def require_exact_state(
+        self,
+        logical_path: str,
+        *,
+        process_id: str | None,
+    ) -> None:
+        """Require one declared loose or packed exact evaluator state."""
+
+        normalized = normalize_relative_path(logical_path)
+        record = self._loose.get(normalized)
+        if record is not None:
+            if record.role != "evaluator-state" or record.process_id != process_id:
+                raise ArtifactError(
+                    f"exact evaluator payload {normalized} has role/process "
+                    f"{record.role!r}/{record.process_id!r}, expected "
+                    f"'evaluator-state'/{process_id!r}"
+                )
+            return
+        member = self._members.get(normalized)
+        if member is None:
+            raise ArtifactError(
+                f"exact evaluator payload is absent: {normalized}"
+            )
+        if process_id is not None:
+            process_prefix = normalize_relative_path(
+                f"processes/{process_id}"
+            ) + "/"
+            if not normalized.startswith(process_prefix):
+                raise ArtifactError(
+                    f"packed exact evaluator payload {normalized} does not belong "
+                    f"to process {process_id!r}"
+                )
+        if member.kind is not PacbinMemberKind.SYMBOLICA_EXACT_STATE:
+            raise ArtifactError(
+                f"packed evaluator payload {normalized} is not an exact state"
+            )
+
+    def read_exact_state(
+        self,
+        logical_path: str,
+        *,
+        process_id: str | None,
+    ) -> bytes:
+        """Read and authenticate one retained exact evaluator state."""
+
+        normalized = normalize_relative_path(logical_path)
+        self.require_exact_state(normalized, process_id=process_id)
+        record = self._loose.get(normalized)
+        if record is not None:
+            try:
+                return confined_path(self._root, normalized).read_bytes()
+            except OSError as exc:
+                raise CompatibilityError(
+                    f"could not read retained Symbolica evaluator state "
+                    f"{normalized}: {exc}"
+                ) from exc
+
+        member = self._members[normalized]
+        if self._container_path is None:
+            raise ArtifactError("packed evaluator payload has no container")
+        try:
+            with self._container_path.open("rb") as stream:
+                stream.seek(member.offset)
+                state = stream.read(member.length)
+        except OSError as exc:
+            raise CompatibilityError(
+                f"could not read packed Symbolica evaluator state "
+                f"{normalized}: {exc}"
+            ) from exc
+        if len(state) != member.length:
+            raise ArtifactError(
+                f"packed evaluator payload is truncated: {normalized}"
+            )
+        if hashlib.sha256(state).hexdigest() != member.sha256:
+            raise ArtifactError(
+                f"packed evaluator payload digest mismatch: {normalized}"
+            )
+        return state
+
+
+def _validate_container_record(record: PayloadRecord) -> None:
+    if (
+        record.role != "evaluator-state"
+        or record.media_type != "application/octet-stream"
+        or record.process_id is not None
+    ):
+        raise ArtifactError("evaluator payload container record is invalid")
+
+
+__all__ = ["ExactEvaluatorPayloadResolver"]
diff --git a/pyamplicol/src/pyamplicol/runtime/_native_selection.py b/pyamplicol/src/pyamplicol/runtime/_native_selection.py
new file mode 100644
index 0000000000..c734c7b4d7
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/_native_selection.py
@@ -0,0 +1,434 @@
+# SPDX-License-Identifier: 0BSD
+"""Validated process selection exported by the native runtime.
+
+Rusticol is the sole authority for resolving explicit aliases and inferred
+process permutations.  Python exact execution consumes that resolved state;
+it must not try to reproduce the selector rules from the artifact manifest.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from fractions import Fraction
+from typing import Any, cast
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+
+
+@dataclass(frozen=True, slots=True)
+class NativeProcessSelection:
+    """One representative process and its representative-to-public mapping."""
+
+    process: Mapping[str, object]
+    representative_process_id: str
+    representative_process_key: str
+    external_permutation: tuple[int, ...]
+    # Set when the selection is a non-generated process-group member.
+    process_group: NativeProcessGroupRelation | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class NativeProcessGroupRelation:
+    """How a non-generated process-group member relates to its representative."""
+
+    member_process_id: str
+    representative_process_key: str
+    factor: Fraction
+    conjugated: bool
+
+
+@dataclass(frozen=True, slots=True)
+class NativePhysicsAxes:
+    """Aligned representative/public selector identifiers from Rusticol."""
+
+    public_physics: dict[str, object]
+    helicity_ids: Mapping[str, str]
+    color_ids: Mapping[str, str]
+
+
+def exact_runtime_state_payload(native_runtime: Any) -> Mapping[str, object]:
+    """Return Rusticol's private exact-runtime state as a JSON object."""
+
+    try:
+        payload = json.loads(native_runtime._exact_runtime_state_json())
+    except AttributeError as exc:
+        raise CompatibilityError(
+            "the installed Rusticol extension is too old for high-precision evaluation"
+        ) from exc
+    except (TypeError, json.JSONDecodeError) as exc:
+        raise ArtifactError("Rusticol returned invalid exact-runtime state") from exc
+    if not isinstance(payload, Mapping):
+        raise ArtifactError("Rusticol exact-runtime state is not an object")
+    return cast(Mapping[str, object], payload)
+
+
+def native_process_selection(
+    native_runtime: Any,
+    processes: Sequence[Mapping[str, object]],
+) -> NativeProcessSelection:
+    """Authenticate Rusticol's resolved representative and public permutation."""
+
+    payload = exact_runtime_state_payload(native_runtime)
+    representative_id = payload.get("representative_process_id")
+    representative_key = payload.get("representative_process_key")
+    if not isinstance(representative_id, str) or not representative_id:
+        raise ArtifactError(
+            "Rusticol exact-runtime representative process ID is invalid"
+        )
+    if not isinstance(representative_key, str) or not representative_key:
+        raise ArtifactError(
+            "Rusticol exact-runtime representative process key is invalid"
+        )
+
+    matches = tuple(
+        process for process in processes if process.get("id") == representative_id
+    )
+    if len(matches) != 1:
+        raise ArtifactError(
+            "Rusticol exact-runtime representative process "
+            f"{representative_id!r} is absent or repeated in its artifact"
+        )
+    process = matches[0]
+    raw_pdgs = process.get("external_pdgs")
+    if isinstance(raw_pdgs, str | bytes) or not isinstance(raw_pdgs, Sequence):
+        raise ArtifactError(
+            f"representative process {representative_id!r} has invalid external PDGs"
+        )
+    external_count = len(raw_pdgs)
+    raw_permutation = payload.get("external_permutation")
+    if isinstance(raw_permutation, str | bytes) or not isinstance(
+        raw_permutation, Sequence
+    ):
+        raise ArtifactError("Rusticol exact-runtime external permutation is invalid")
+    permutation = tuple(raw_permutation)
+    if (
+        len(permutation) != external_count
+        or any(
+            isinstance(index, bool) or not isinstance(index, int)
+            for index in permutation
+        )
+        or set(permutation) != set(range(external_count))
+    ):
+        raise ArtifactError("Rusticol exact-runtime external permutation is invalid")
+
+    return NativeProcessSelection(
+        process=process,
+        representative_process_id=representative_id,
+        representative_process_key=representative_key,
+        external_permutation=cast(tuple[int, ...], permutation),
+        process_group=_process_group_relation(
+            payload, str(getattr(native_runtime, "process_id", ""))
+        ),
+    )
+
+
+def native_process_group_relation(
+    native_runtime: Any,
+) -> NativeProcessGroupRelation | None:
+    """Return the selected member's relation, or ``None`` for stored processes."""
+
+    return _process_group_relation(
+        exact_runtime_state_payload(native_runtime),
+        str(getattr(native_runtime, "process_id", "")),
+    )
+
+
+def _process_group_relation(
+    payload: Mapping[str, object],
+    member_process_id: str,
+) -> NativeProcessGroupRelation | None:
+    representative = payload.get("process_group_member_of")
+    if representative is None:
+        return None
+    factor = payload.get("process_group_factor")
+    conjugated = payload.get("charge_conjugated")
+    if (
+        not isinstance(representative, str)
+        or not representative
+        or not isinstance(factor, Mapping)
+        or not isinstance(conjugated, bool)
+    ):
+        raise ArtifactError("Rusticol exact-runtime process-group relation is invalid")
+    numerator = factor.get("numerator")
+    denominator = factor.get("denominator")
+    if (
+        isinstance(numerator, bool)
+        or not isinstance(numerator, int)
+        or isinstance(denominator, bool)
+        or not isinstance(denominator, int)
+        or numerator < 1
+        or denominator < 1
+    ):
+        raise ArtifactError("Rusticol exact-runtime process-group factor is invalid")
+    return NativeProcessGroupRelation(
+        member_process_id=member_process_id,
+        representative_process_key=representative,
+        factor=Fraction(numerator, denominator),
+        conjugated=conjugated,
+    )
+
+
+def charge_conjugate_color_id(identifier: str) -> str:
+    """Map an LC color-flow ID through charge conjugation (word reversal).
+
+    The map is an involution and leaves contracted-color IDs unchanged.
+    """
+
+    if not identifier.startswith("flow:") or identifier == "flow:singlet":
+        return identifier
+    return "flow:" + ",".join(reversed(identifier.removeprefix("flow:").split(",")))
+
+
+def _execution_physics(
+    public: dict[str, object],
+    representative: Mapping[str, object],
+    native_runtime: Any,
+) -> dict[str, object]:
+    """Undo a process-group member's relabelling of Rusticol's public physics.
+
+    The exact executors evaluate the representative: they need its flavours
+    in the public order and, for a charge-conjugated member, the unreversed LC
+    words that Rusticol's own execution lanes use. Ordinary selections are
+    returned unchanged.
+    """
+
+    payload = exact_runtime_state_payload(native_runtime)
+    relation = _process_group_relation(payload, str(public.get("process_id")))
+    if relation is None:
+        return public
+    permutation = payload.get("external_permutation")
+    representative_particles = representative.get("external_particles")
+    public_particles = public.get("external_particles")
+    if (
+        not isinstance(permutation, list)
+        or not isinstance(representative_particles, list)
+        or not isinstance(public_particles, list)
+        or sorted(permutation) != list(range(len(public_particles)))
+        or len(representative_particles) != len(public_particles)
+    ):
+        raise ArtifactError("Rusticol public physics has an inconsistent particle axis")
+    particles = [dict(item) for item in public_particles]
+    for representative_index, public_index in enumerate(permutation):
+        source = representative_particles[representative_index]
+        particles[public_index]["particle"] = source["particle"]
+        particles[public_index]["pdg"] = source["pdg"]
+    execution = {**public, "external_particles": particles}
+    if relation.conjugated:
+        colors = []
+        for item in cast(list[dict[str, object]], public["color_components"]):
+            color = dict(item)
+            if color.get("kind") == "lc-flow":
+                color["id"] = charge_conjugate_color_id(str(color["id"]))
+                color["representative_id"] = charge_conjugate_color_id(
+                    str(color["representative_id"])
+                )
+                color["word"] = list(reversed(cast(list[int], color["word"])))
+            colors.append(color)
+        reduction = dict(cast(dict[str, object], public["reduction"]))
+        reduction["groups"] = [
+            {
+                **group,
+                "representative_color_id": charge_conjugate_color_id(
+                    str(group["representative_color_id"])
+                ),
+                "physical_color_ids": [
+                    charge_conjugate_color_id(str(identifier))
+                    for identifier in cast(list[object], group["physical_color_ids"])
+                ],
+            }
+            for group in cast(list[dict[str, object]], reduction["groups"])
+        ]
+        execution["color_components"] = colors
+        execution["reduction"] = reduction
+    return execution
+
+
+def native_physics_axes(
+    native_runtime: Any,
+    representative_physics: Mapping[str, object],
+) -> NativePhysicsAxes:
+    """Load Rusticol's public physics and authenticate aligned selector axes.
+
+    Rusticol preserves axis order while rewriting process-order-dependent IDs,
+    vectors, and LC words.  Exact executors use these maps only to translate
+    representative execution overrides onto that already-validated public
+    payload. For a process-group member the payload is the representative's
+    execution view; callers relabel results with
+    :func:`native_process_group_relation`.
+    """
+
+    try:
+        public = json.loads(native_runtime.physics_json())
+    except AttributeError as exc:
+        raise CompatibilityError(
+            "the installed Rusticol extension does not expose public physics"
+        ) from exc
+    except (TypeError, json.JSONDecodeError) as exc:
+        raise ArtifactError("Rusticol returned invalid public physics") from exc
+    if not isinstance(public, dict):
+        raise ArtifactError("Rusticol public physics is not an object")
+    public = _execution_physics(public, representative_physics, native_runtime)
+    if public.get("color_accuracy") != representative_physics.get("color_accuracy"):
+        raise ArtifactError(
+            "Rusticol public physics changes the representative color accuracy"
+        )
+    return NativePhysicsAxes(
+        public_physics=public,
+        helicity_ids=_aligned_axis_ids(
+            representative_physics,
+            public,
+            "helicities",
+            "helicity",
+        ),
+        color_ids=_aligned_axis_ids(
+            representative_physics,
+            public,
+            "color_components",
+            "color component",
+        ),
+    )
+
+
+def remap_reduction(
+    reduction: Mapping[str, object],
+    axes: NativePhysicsAxes,
+) -> dict[str, object]:
+    """Translate representative reduction selectors to public IDs."""
+
+    groups = reduction.get("groups")
+    if isinstance(groups, str | bytes) or not isinstance(groups, Sequence):
+        raise ArtifactError("physics reduction groups are invalid")
+    remapped = dict(reduction)
+    remapped["groups"] = [
+        remap_reduction_group(group, axes, index=index)
+        for index, group in enumerate(groups)
+    ]
+    return remapped
+
+
+def remap_reduction_group(
+    value: object,
+    axes: NativePhysicsAxes,
+    *,
+    index: int,
+) -> dict[str, object]:
+    """Translate one representative reduction group to public IDs."""
+
+    if not isinstance(value, Mapping):
+        raise ArtifactError(f"physics reduction group {index} is not an object")
+    group = dict(value)
+    group["representative_helicity_id"] = _remapped_id(
+        value.get("representative_helicity_id"),
+        axes.helicity_ids,
+        f"reduction group {index} representative helicity",
+    )
+    group["representative_color_id"] = _remapped_id(
+        value.get("representative_color_id"),
+        axes.color_ids,
+        f"reduction group {index} representative color",
+    )
+    group["physical_helicity_ids"] = _remapped_ids(
+        value.get("physical_helicity_ids"),
+        axes.helicity_ids,
+        f"reduction group {index} physical helicities",
+    )
+    group["physical_color_ids"] = _remapped_ids(
+        value.get("physical_color_ids"),
+        axes.color_ids,
+        f"reduction group {index} physical colors",
+    )
+    return group
+
+
+def representative_vector_to_public(
+    values: Sequence[int], permutation: tuple[int, ...]
+) -> tuple[int, ...]:
+    """Apply a representative-index to public-index external permutation."""
+
+    vector = tuple(values)
+    if len(vector) != len(permutation) or set(permutation) != set(range(len(vector))):
+        raise ArtifactError("external vector permutation is invalid")
+    public = [0] * len(vector)
+    for representative_index, public_index in enumerate(permutation):
+        public[public_index] = vector[representative_index]
+    return tuple(public)
+
+
+def _aligned_axis_ids(
+    representative: Mapping[str, object],
+    public: Mapping[str, object],
+    key: str,
+    description: str,
+) -> Mapping[str, str]:
+    representative_axis = representative.get(key)
+    public_axis = public.get(key)
+    if (
+        isinstance(representative_axis, str | bytes)
+        or not isinstance(representative_axis, Sequence)
+        or isinstance(public_axis, str | bytes)
+        or not isinstance(public_axis, Sequence)
+        or len(representative_axis) != len(public_axis)
+    ):
+        raise ArtifactError(f"Rusticol public {description} axis is inconsistent")
+    result: dict[str, str] = {}
+    public_ids: set[str] = set()
+    for index, (representative_record, public_record) in enumerate(
+        zip(representative_axis, public_axis, strict=True)
+    ):
+        if not isinstance(representative_record, Mapping) or not isinstance(
+            public_record, Mapping
+        ):
+            raise ArtifactError(f"{description} axis entry {index} is not an object")
+        representative_id = representative_record.get("id")
+        public_id = public_record.get("id")
+        if (
+            not isinstance(representative_id, str)
+            or not representative_id
+            or not isinstance(public_id, str)
+            or not public_id
+            or representative_id in result
+            or public_id in public_ids
+        ):
+            raise ArtifactError(f"{description} axis IDs are invalid or repeated")
+        result[representative_id] = public_id
+        public_ids.add(public_id)
+    return result
+
+
+def _remapped_id(value: object, identifiers: Mapping[str, str], context: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise ArtifactError(f"{context} is invalid")
+    try:
+        return identifiers[value]
+    except KeyError as exc:
+        raise ArtifactError(f"{context} {value!r} is absent from its axis") from exc
+
+
+def _remapped_ids(
+    value: object,
+    identifiers: Mapping[str, str],
+    context: str,
+) -> list[str]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} are invalid")
+    return [
+        _remapped_id(identifier, identifiers, f"{context} entry {index}")
+        for index, identifier in enumerate(value)
+    ]
+
+
+__all__ = [
+    "NativePhysicsAxes",
+    "NativeProcessGroupRelation",
+    "NativeProcessSelection",
+    "charge_conjugate_color_id",
+    "exact_runtime_state_payload",
+    "native_physics_axes",
+    "native_process_group_relation",
+    "native_process_selection",
+    "remap_reduction",
+    "remap_reduction_group",
+    "representative_vector_to_public",
+]
diff --git a/pyamplicol/src/pyamplicol/runtime/_normalization_exact.py b/pyamplicol/src/pyamplicol/runtime/_normalization_exact.py
new file mode 100644
index 0000000000..02b85cfd66
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/_normalization_exact.py
@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: 0BSD
+"""Reconstruct ME normalization in the arithmetic requested by the caller."""
+
+from collections.abc import Mapping, Sequence
+from decimal import Decimal
+from functools import lru_cache
+from typing import Protocol, cast
+
+from pyamplicol.api.errors import ArtifactError
+
+
+class _DecimalComplexResult(Protocol):
+    # Symbolica returns ComplexFloat here; its current stubs still say tuple.
+    def to_decimal_tuple(self) -> tuple[Decimal, Decimal]: ...
+
+
+@lru_cache(maxsize=8)
+def _pi(precision: int) -> Decimal:
+    from symbolica import E
+
+    # Do not construct an optimized evaluator of the constant Pi: that
+    # construction requires a target precision in current Symbolica.
+    value = E("pi").evaluate({}, decimal_digit_precision=precision)
+    return cast(_DecimalComplexResult, value).to_decimal_tuple()[0]
+
+
+def exact_normalization(
+    physics: Mapping[str, object],
+    parameters: Sequence[Decimal],
+    precision: int,
+    parameter_schema: Sequence[Mapping[str, object]] | None = None,
+    *,
+    scalar: type[Decimal] | None = None,
+) -> Decimal:
+    """Use exact combinatorial factors and current, not default, couplings.
+
+    The native cached scalar is deliberately not upcast: independent rounding
+    of the Born and real-emission normalizations spoils local subtraction.
+    This function is called only by the non-f64 executors.
+    """
+    scalar = Decimal if scalar is None else scalar
+    extensions = physics.get("extensions", {})
+    if not isinstance(extensions, Mapping):
+        raise ArtifactError("exact normalization has invalid physics extensions")
+    normalization = extensions.get("normalization")
+    if not isinstance(normalization, Mapping):
+        raise ArtifactError("exact normalization metadata is absent")
+    # Full/NLC contractions already include their colour metric. Only LC
+    # needs the common colour factor, exactly as in the native executor.
+    color = (
+        scalar(str(normalization.get("color_factor", 1)))
+        if physics.get("color_accuracy") == "lc"
+        else scalar(1)
+    )
+    average = scalar(str(normalization.get("average_factor", 1)))
+    identical = scalar(str(normalization.get("identical_factor", 1)))
+    if average <= 0 or identical <= 0:
+        raise ArtifactError("exact normalization has a nonpositive averaging factor")
+    qcd_power = int(normalization.get("qcd_coupling_power", 0))
+    ew_power = int(normalization.get("electroweak_coupling_power", 0))
+    coupling = scalar(1)
+    if qcd_power or ew_power:
+        records = parameter_schema or physics.get("model_parameters", ())
+        if not isinstance(records, Sequence):
+            raise ArtifactError("exact normalization parameter schema is invalid")
+        by_name = {
+            str(record["name"]): parameters[int(record.get("parameter_index", index))]
+            for index, record in enumerate(records)
+            if isinstance(record, Mapping) and "name" in record
+        }
+        try:
+            pi = scalar(_pi(precision))
+            if qcd_power:
+                coupling *= (
+                    4 * pi * by_name["normalization.alpha_s_me_check"]
+                ) ** qcd_power
+            if ew_power:
+                coupling *= (8 * pi * by_name["normalization.alpha_ew"]) ** ew_power
+        except KeyError as exc:
+            raise ArtifactError(
+                "exact normalization lacks its current coupling parameter"
+            ) from exc
+    else:
+        coupling = scalar(str(normalization.get("global_coupling_factor", 1)))
+    return color * coupling / (average * identical)
diff --git a/pyamplicol/src/pyamplicol/runtime/backend.py b/pyamplicol/src/pyamplicol/runtime/backend.py
new file mode 100644
index 0000000000..f5bae308f3
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/backend.py
@@ -0,0 +1,1782 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib
+import inspect
+import json
+import math
+import os
+from collections.abc import Mapping, Sequence
+from contextlib import suppress
+from copy import deepcopy
+from decimal import ROUND_HALF_EVEN, Decimal, localcontext
+from fractions import Fraction
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal, cast
+
+from pyamplicol._internal.versions import (
+    COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+    EAGER_RUNTIME_LAYOUT_F64_CAPABILITY,
+    ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_RUNTIME_CAPABILITY,
+    RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+    SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+    verify_native_module,
+)
+from pyamplicol.api.errors import (
+    ArtifactError,
+    CompatibilityError,
+    DependencyError,
+    EvaluationError,
+)
+from pyamplicol.api.protocols import ModelParameters, Momenta
+from pyamplicol.api.results import (
+    ColorFlow,
+    ContractedColorComponent,
+    ExternalParticle,
+    HelicityConfiguration,
+    ModelParameter,
+    PhysicsReduction,
+    ProcessPhysics,
+    ReductionGroup,
+    ResolvedEvaluation,
+    WarmUpResult,
+)
+from pyamplicol.artifacts import MANIFEST_NAME, ArtifactManifest, load_manifest
+from pyamplicol.reporting import (
+    ProgressEnd,
+    ProgressSink,
+    ProgressStart,
+    ProgressUpdate,
+)
+from pyamplicol.runtime._native_selection import (
+    charge_conjugate_color_id,
+    native_process_selection,
+)
+
+if TYPE_CHECKING:
+    from .eager_exact import EagerExactExecutor
+    from .recurrence_exact import RecurrenceExactExecutor
+    from .symbolica_exact import SymbolicaExactExecutor
+
+    _ExactExecutor = (
+        EagerExactExecutor | RecurrenceExactExecutor | SymbolicaExactExecutor
+    )
+
+_Accuracy = Literal["lc", "nlc", "full"]
+_ParticleState = Literal["incoming", "outgoing"]
+_ExecutionMode = Literal["compiled", "eager", "recurrence", "on-the-fly"]
+
+_ON_THE_FLY_WARM_UP_TASK_ID = "runtime-warm-up"
+_ON_THE_FLY_WARM_UP_STAGES = (
+    "process_preparation",
+    "query_family",
+    "family_finalization",
+    "first_evaluation",
+)
+_ON_THE_FLY_WARM_UP_STAGE_LABELS = {
+    "process_preparation": "Preparing the OTF process",
+    "query_family": "Constructing the OTF query family",
+    "family_finalization": "Finalizing the OTF family",
+    "first_evaluation": "Evaluating the warm-up point",
+}
+
+
+def _manifest_integer(value: object, description: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ArtifactError(f"{description} must be an integer")
+    return value
+
+
+def _load_native_module() -> Any:
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(module)
+    except ImportError as exc:
+        raise DependencyError(
+            "the pyamplicol._rusticol native runtime extension is unavailable"
+        ) from exc
+    if not hasattr(module, "Runtime"):
+        raise DependencyError(
+            "the pyamplicol._rusticol extension does not provide Runtime"
+        )
+    return module
+
+
+def _translated_error(module: Any, error: Exception) -> Exception | None:
+    mappings = (
+        ("CompatibilityError", CompatibilityError),
+        ("ArtifactError", ArtifactError),
+        ("SelectorError", EvaluationError),
+        ("ModelParameterError", EvaluationError),
+        ("EvaluationError", EvaluationError),
+        ("RusticolError", EvaluationError),
+    )
+    for native_name, public_type in mappings:
+        native_type = getattr(module, native_name, None)
+        if isinstance(native_type, type) and isinstance(error, native_type):
+            return public_type(str(error))
+    return None
+
+
+def _invoke(module: Any, operation: Any, *args: Any, **kwargs: Any) -> Any:
+    try:
+        return operation(*args, **kwargs)
+    except Exception as exc:
+        translated = _translated_error(module, exc)
+        if translated is None:
+            raise
+        raise translated from exc
+
+
+def _accepts_keyword_arguments(operation: object, *names: str) -> bool:
+    if not callable(operation):
+        return False
+    try:
+        parameters = inspect.signature(operation).parameters.values()
+    except (TypeError, ValueError):
+        return False
+    declared = {parameter.name for parameter in parameters}
+    accepts_arbitrary = any(
+        parameter.kind is inspect.Parameter.VAR_KEYWORD for parameter in parameters
+    )
+    return accepts_arbitrary or all(name in declared for name in names)
+
+
+def _normalized_selectors(values: Sequence[str] | None) -> tuple[str, ...] | None:
+    if values is None:
+        return None
+    return tuple(values) or None
+
+
+def _warm_up_integer(
+    payload: Mapping[str, object],
+    name: str,
+    *,
+    optional: bool = False,
+) -> int | None:
+    value = payload.get(name)
+    if optional and value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        qualifier = "non-negative integer"
+        if optional:
+            qualifier += " or null"
+        raise ArtifactError(f"native OTF warm-up {name} must be a {qualifier}")
+    return value
+
+
+def _warm_up_seconds(payload: Mapping[str, object], name: str) -> float:
+    value = payload.get(name)
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(float(value))
+        or value < 0.0
+    ):
+        raise ArtifactError(
+            f"native OTF warm-up {name} must be finite and non-negative"
+        )
+    return float(value)
+
+
+def _warm_up_payload(raw: object, description: str) -> Mapping[str, object]:
+    try:
+        payload = json.loads(str(raw))
+    except (TypeError, ValueError) as exc:
+        raise ArtifactError(
+            f"native OTF warm-up {description} is invalid: {exc}"
+        ) from exc
+    if not isinstance(payload, Mapping):
+        raise ArtifactError(f"native OTF warm-up {description} must be an object")
+    if payload.get("schema_version") != 1:
+        raise ArtifactError(
+            f"native OTF warm-up {description} has an invalid schema version"
+        )
+    return payload
+
+
+def _warm_up_result(raw: object) -> WarmUpResult:
+    payload = _warm_up_payload(raw, "result")
+    if payload.get("first_evaluation_completed") is not True:
+        raise ArtifactError(
+            "native OTF warm-up first_evaluation_completed must be true"
+        )
+    already_warm = payload.get("already_warm")
+    if not isinstance(already_warm, bool):
+        raise ArtifactError("native OTF warm-up already_warm must be a boolean")
+    query_count = _warm_up_integer(payload, "query_count")
+    warmed_query_count = _warm_up_integer(payload, "warmed_query_count")
+    current_rss_bytes = _warm_up_integer(payload, "current_rss_bytes", optional=True)
+    peak_rss_bytes = _warm_up_integer(payload, "peak_rss_bytes", optional=True)
+    assert query_count is not None
+    assert warmed_query_count is not None
+    try:
+        return WarmUpResult(
+            elapsed_seconds=_warm_up_seconds(payload, "elapsed_seconds"),
+            query_count=query_count,
+            warmed_query_count=warmed_query_count,
+            current_rss_bytes=current_rss_bytes,
+            peak_rss_bytes=peak_rss_bytes,
+            already_warm=already_warm,
+        )
+    except (TypeError, ValueError) as exc:
+        raise ArtifactError(f"native OTF warm-up result is invalid: {exc}") from exc
+
+
+class _OnTheFlyWarmUpProgress:
+    """Translate throttled native snapshots into the shared progress protocol."""
+
+    def __init__(
+        self,
+        sink: ProgressSink,
+        *,
+        process: object,
+        color_accuracy: object,
+    ) -> None:
+        self._sink = sink
+        self._active_stage: str | None = None
+        self._process = process if isinstance(process, str) else None
+        self._color_accuracy = (
+            color_accuracy if isinstance(color_accuracy, str) else None
+        )
+        details: dict[str, str] = {"execution_mode": "on-the-fly"}
+        if self._process:
+            details["process"] = self._process
+        if self._color_accuracy:
+            details["color_accuracy"] = self._color_accuracy
+        self._sink.emit(
+            ProgressStart(
+                _ON_THE_FLY_WARM_UP_TASK_ID,
+                "Warming the on-the-fly runtime",
+                total=len(_ON_THE_FLY_WARM_UP_STAGES),
+                unit="phases",
+                details=details,
+            )
+        )
+
+    def __call__(self, raw: object) -> bool:
+        payload = _warm_up_payload(raw, "progress event")
+        kind = payload.get("kind")
+        if kind not in {"start", "update", "end"}:
+            raise ArtifactError("native OTF warm-up progress kind is invalid")
+        stage = payload.get("stage")
+        if stage not in _ON_THE_FLY_WARM_UP_STAGES:
+            raise ArtifactError("native OTF warm-up progress stage is invalid")
+        assert isinstance(stage, str)
+        completed = _warm_up_integer(payload, "completed")
+        total = _warm_up_integer(payload, "total")
+        workers = _warm_up_integer(payload, "workers")
+        current_rss_bytes = _warm_up_integer(
+            payload, "current_rss_bytes", optional=True
+        )
+        peak_rss_bytes = _warm_up_integer(payload, "peak_rss_bytes", optional=True)
+        assert completed is not None
+        assert total is not None
+        assert workers is not None
+        if completed > total:
+            raise ArtifactError(
+                "native OTF warm-up progress completed count exceeds its total"
+            )
+        if (
+            current_rss_bytes is not None
+            and peak_rss_bytes is not None
+            and current_rss_bytes > peak_rss_bytes
+        ):
+            raise ArtifactError("native OTF warm-up current RSS exceeds its peak RSS")
+        elapsed_seconds = _warm_up_seconds(payload, "elapsed_seconds")
+        message = payload.get("message")
+        if message is not None and not isinstance(message, str):
+            raise ArtifactError(
+                "native OTF warm-up progress message must be a string or null"
+            )
+        stage_index = _ON_THE_FLY_WARM_UP_STAGES.index(stage)
+        if stage != self._active_stage:
+            self._finish_active_stage(success=True)
+            self._active_stage = stage
+            self._sink.emit(
+                ProgressUpdate(
+                    _ON_THE_FLY_WARM_UP_TASK_ID,
+                    completed=stage_index,
+                    total=len(_ON_THE_FLY_WARM_UP_STAGES),
+                    message=_ON_THE_FLY_WARM_UP_STAGE_LABELS[stage],
+                )
+            )
+            self._sink.emit(
+                ProgressStart(
+                    self._stage_task_id(stage),
+                    _ON_THE_FLY_WARM_UP_STAGE_LABELS[stage],
+                    total=total,
+                    parent_task_id=_ON_THE_FLY_WARM_UP_TASK_ID,
+                    unit="queries" if stage == "query_family" else "steps",
+                    details={"stage": stage},
+                )
+            )
+        details: dict[str, str | int | float] = {
+            "stage": stage,
+            "workers": workers,
+            "elapsed_seconds": elapsed_seconds,
+        }
+        if current_rss_bytes is not None:
+            details["native_current_rss_bytes"] = current_rss_bytes
+        if peak_rss_bytes is not None:
+            details["native_peak_rss_bytes"] = peak_rss_bytes
+        self._sink.emit(
+            ProgressUpdate(
+                self._stage_task_id(stage),
+                completed=completed,
+                total=total,
+                message=message,
+                details=details,
+            )
+        )
+        return True
+
+    def finish(
+        self,
+        *,
+        success: bool,
+        elapsed_seconds: float | None = None,
+        message: str | None = None,
+    ) -> None:
+        self._finish_active_stage(success=success, message=message)
+        if success:
+            self._sink.emit(
+                ProgressUpdate(
+                    _ON_THE_FLY_WARM_UP_TASK_ID,
+                    completed=len(_ON_THE_FLY_WARM_UP_STAGES),
+                    total=len(_ON_THE_FLY_WARM_UP_STAGES),
+                    message="warm-up complete",
+                )
+            )
+        self._sink.emit(
+            ProgressEnd(
+                _ON_THE_FLY_WARM_UP_TASK_ID,
+                success=success,
+                message=message,
+                elapsed_seconds=elapsed_seconds,
+            )
+        )
+
+    @staticmethod
+    def _stage_task_id(stage: str) -> str:
+        return f"{_ON_THE_FLY_WARM_UP_TASK_ID}:{stage}"
+
+    def _finish_active_stage(
+        self,
+        *,
+        success: bool,
+        message: str | None = None,
+    ) -> None:
+        if self._active_stage is None:
+            return
+        self._sink.emit(
+            ProgressEnd(
+                self._stage_task_id(self._active_stage),
+                success=success,
+                message=message,
+            )
+        )
+        self._active_stage = None
+
+
+def _selected_manifest_process(
+    manifest: ArtifactManifest,
+    selected_id: str,
+) -> Mapping[str, object]:
+    for process in manifest.processes:
+        if process["id"] == selected_id:
+            return process
+        if any(
+            alias["id"] == selected_id
+            for alias in cast(Sequence[Mapping[str, object]], process["aliases"])
+        ):
+            return process
+    raise ArtifactError(
+        f"runtime selected process {selected_id!r} is absent from its artifact"
+    )
+
+
+def _has_reusable_runtime_selector_contract(
+    manifest: ArtifactManifest,
+    process: Mapping[str, object],
+) -> bool:
+    relative = str(process["physics_path"])
+    try:
+        payload = json.loads((manifest.root / relative).read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise ArtifactError(
+            f"could not read runtime selector metadata {relative}: {exc}"
+        ) from exc
+    except json.JSONDecodeError as exc:
+        raise ArtifactError(
+            f"invalid runtime selector metadata {relative}: {exc}"
+        ) from exc
+    if not isinstance(payload, Mapping):
+        raise ArtifactError(f"runtime physics metadata {relative} must be an object")
+    extensions = payload.get("extensions")
+    if extensions is None:
+        return False
+    if not isinstance(extensions, Mapping):
+        raise ArtifactError(
+            f"runtime physics metadata {relative}.extensions is invalid"
+        )
+    selectors = extensions.get("runtime_selectors")
+    if selectors is None:
+        return False
+    if not isinstance(selectors, Mapping):
+        raise ArtifactError(
+            f"runtime physics metadata {relative}.extensions.runtime_selectors "
+            "is invalid"
+        )
+    axes = selectors.get("axes")
+    if not isinstance(axes, Mapping):
+        raise ArtifactError(
+            f"runtime physics metadata {relative}.extensions.runtime_selectors.axes "
+            "is invalid"
+        )
+    return any(
+        isinstance(axis, Mapping)
+        and axis.get("runtime_contract") == "complete-reusable"
+        for axis in axes.values()
+    )
+
+
+def _physics_from_native(value: Any) -> ProcessPhysics:
+    return ProcessPhysics(
+        process_id=str(value.process_id),
+        process=str(value.process),
+        color_accuracy=cast(_Accuracy, str(value.color_accuracy)),
+        helicity_coverage=str(value.helicity_coverage),
+        color_coverage=str(value.color_coverage),
+        color_kind=str(value.color_kind),
+        structural_zero_helicity_count=int(value.structural_zero_helicity_count),
+        external_particles=tuple(
+            ExternalParticle(
+                index=int(particle.index),
+                label=int(particle.label),
+                name=str(particle.name),
+                pdg_id=int(particle.pdg_id),
+                state=cast(_ParticleState, str(particle.state)),
+                momentum_slot=int(particle.momentum_slot),
+            )
+            for particle in value.external_particles
+        ),
+        helicities=tuple(
+            HelicityConfiguration(
+                id=str(helicity.id),
+                index=int(helicity.index),
+                values=tuple(int(entry) for entry in helicity.values),
+                computed=bool(helicity.computed),
+                structural_zero=bool(helicity.structural_zero),
+                representative_id=str(helicity.representative_id),
+                coefficient=float(helicity.coefficient),
+            )
+            for helicity in value.helicities
+        ),
+        color_flows=tuple(
+            ColorFlow(
+                id=str(flow.id),
+                index=int(flow.index),
+                word=tuple(int(entry) for entry in flow.word),
+                computed=bool(flow.computed),
+                representative_id=str(flow.representative_id),
+                coefficient=float(flow.coefficient),
+            )
+            for flow in value.color_flows
+        ),
+        contracted_color_components=tuple(
+            ContractedColorComponent(
+                id=str(component.id),
+                index=int(component.index),
+                description=str(component.description),
+            )
+            for component in value.contracted_color_components
+        ),
+        reduction=PhysicsReduction(
+            kind=cast(
+                Literal["lc-diagonal", "contracted-color"],
+                str(value.reduction.kind),
+            ),
+            groups=tuple(
+                ReductionGroup(
+                    id=str(group.id),
+                    representative_helicity_id=str(group.representative_helicity_id),
+                    representative_color_id=str(group.representative_color_id),
+                    physical_helicity_ids=tuple(
+                        str(identifier) for identifier in group.physical_helicity_ids
+                    ),
+                    physical_color_ids=tuple(
+                        str(identifier) for identifier in group.physical_color_ids
+                    ),
+                )
+                for group in value.reduction.groups
+            ),
+        ),
+        model_parameters=tuple(
+            ModelParameter(
+                name=str(parameter.name),
+                kind=str(parameter.kind),
+                default_real=float(parameter.default_real),
+                default_imaginary=float(parameter.default_imaginary),
+                mutable=bool(parameter.mutable),
+            )
+            for parameter in value.model_parameters
+        ),
+        selector_capabilities=tuple(
+            str(capability) for capability in value.selector_capabilities
+        ),
+    )
+
+
+def _scalar_from_native(value: Any) -> complex | Decimal:
+    return value if isinstance(value, Decimal) else complex(value)
+
+
+def _native_runtime_metadata(runtime: Any) -> Mapping[str, object]:
+    metadata_json = getattr(runtime, "metadata_json", None)
+    if not callable(metadata_json):
+        return {"execution_mode": "compiled"}
+    try:
+        payload = json.loads(str(metadata_json()))
+    except (TypeError, ValueError) as exc:
+        raise ArtifactError(f"native runtime metadata is invalid: {exc}") from exc
+    if not isinstance(payload, Mapping):
+        raise ArtifactError("native runtime metadata must be an object")
+    return dict(payload)
+
+
+def _native_execution_mode(
+    metadata: Mapping[str, object],
+) -> _ExecutionMode:
+    payload = metadata
+    mode = payload.get("execution_mode", "compiled")
+    if mode not in {"compiled", "eager", "recurrence", "on-the-fly"}:
+        raise CompatibilityError(f"unsupported runtime execution mode {mode!r}")
+    return cast(_ExecutionMode, mode)
+
+
+class RusticolRuntimeBackend:
+    """Public-protocol adapter around ``pyamplicol._rusticol.Runtime``."""
+
+    def __init__(
+        self,
+        runtime: Any,
+        native_module: Any,
+        artifact_path: Path,
+        manifest: ArtifactManifest | None = None,
+    ) -> None:
+        self._runtime = runtime
+        self._native_module = native_module
+        self._artifact_path = artifact_path
+        self._native_metadata = _native_runtime_metadata(runtime)
+        self._execution_mode = _native_execution_mode(self._native_metadata)
+        self._physics: ProcessPhysics | None = None
+        self._exact_executor: _ExactExecutor | None = None
+        self._required_runtime_capabilities: tuple[str, ...] = ()
+        self._supports_per_point_selectors = _accepts_keyword_arguments(
+            runtime.evaluate,
+            "helicity_by_point",
+            "color_flow_by_point",
+        )
+        if manifest is not None:
+            self._validate_runtime_selector_capability(manifest)
+
+    @property
+    def physics(self) -> ProcessPhysics:
+        if self._physics is None:
+            self._physics = _physics_from_native(self._runtime.physics)
+        return self._physics
+
+    @property
+    def execution_mode(self) -> _ExecutionMode:
+        """Return the native execution lane selected by the artifact."""
+
+        return self._execution_mode
+
+    def _require_supported_precision(self, precision: int) -> None:
+        if self._execution_mode == "on-the-fly" and precision != 16:
+            raise CompatibilityError(
+                "on-the-fly execution supports only precision=16 (native f64); "
+                f"received precision={precision}"
+            )
+        if (
+            self._execution_mode == "compiled"
+            and precision != 16
+            and SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY
+            in self._required_runtime_capabilities
+        ):
+            raise CompatibilityError(
+                "compiled symmetric-group FFT diagnostic execution supports only "
+                "precision=16 native f64; exact/high-precision execution is unavailable"
+            )
+
+    def _on_the_fly_runtime_state_census(self) -> Mapping[str, object] | None:
+        owns_companion = (
+            self._execution_mode == "recurrence"
+            and RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY
+            in self._required_runtime_capabilities
+        )
+        if self._execution_mode != "on-the-fly" and not owns_companion:
+            return None
+        loader = getattr(
+            self._runtime,
+            "_on_the_fly_runtime_state_census_json",
+            None,
+        )
+        if not callable(loader):
+            raise CompatibilityError(
+                "installed native runtime has no compact on-the-fly state census"
+            )
+        raw = _invoke(self._native_module, loader)
+        if raw is None:
+            raise CompatibilityError(
+                "installed native runtime returned no on-the-fly state census"
+            )
+        try:
+            payload = json.loads(str(raw))
+        except (TypeError, ValueError) as exc:
+            raise ArtifactError(
+                f"native on-the-fly state census is invalid: {exc}"
+            ) from exc
+        if not isinstance(payload, Mapping):
+            raise ArtifactError("native on-the-fly state census must be an object")
+        if payload.get("kind") != "rusticol-on-the-fly-runtime-state-census-v1":
+            raise ArtifactError("native on-the-fly state census has an invalid kind")
+        if payload.get("family_cache_policy") != "last-family-only":
+            raise ArtifactError(
+                "native on-the-fly state census has an invalid family cache policy"
+            )
+        cache_limit = payload.get("family_cache_limit")
+        if (
+            isinstance(cache_limit, bool)
+            or not isinstance(cache_limit, int)
+            or cache_limit != 1
+        ):
+            raise ArtifactError(
+                "native on-the-fly state census has an invalid family cache limit"
+            )
+        return dict(payload)
+
+    def inspect(self) -> Mapping[str, object]:
+        """Return compact authenticated metadata without opening dense physics."""
+
+        result: dict[str, object] = {
+            "kind": "pyamplicol-runtime-inspection",
+            "schema_version": 1,
+            "artifact_id": self.artifact_id,
+            "runtime_metadata": deepcopy(dict(self._native_metadata)),
+            "on_the_fly_state": self._on_the_fly_runtime_state_census(),
+        }
+        if self._execution_mode == "on-the-fly":
+            result["supported_precisions"] = (16,)
+        return result
+
+    def save(self, path: os.PathLike[str] | str) -> None:
+        """Save the retained native on-the-fly structural cache."""
+
+        self._cache_operation("save", path)
+
+    def load_cache(self, path: os.PathLike[str] | str) -> None:
+        """Replace the retained native on-the-fly cache after validation."""
+
+        self._cache_operation("load_cache", path)
+
+    def _cache_operation(self, name: str, path: os.PathLike[str] | str) -> None:
+        if self._execution_mode != "on-the-fly":
+            raise CompatibilityError(
+                "saving and restoring caches is available only for on-the-fly runtimes"
+            )
+        operation = getattr(self._runtime, name, None)
+        if not callable(operation):
+            raise CompatibilityError(
+                f"installed native runtime has no on-the-fly {name} binding"
+            )
+        _invoke(self._native_module, operation, path)
+
+    def _on_the_fly_benchmark_context(
+        self,
+        color_flow_ids: Sequence[str],
+    ) -> Mapping[str, object] | None:
+        """Resolve the existing benchmark selectors through compact OTF state."""
+
+        if self._execution_mode != "on-the-fly":
+            return None
+        loader = getattr(self._runtime, "_on_the_fly_benchmark_context_json", None)
+        if not callable(loader):
+            raise CompatibilityError(
+                "installed native runtime has no compact on-the-fly benchmark context"
+            )
+        try:
+            payload = json.loads(str(loader(tuple(color_flow_ids) or None)))
+        except (TypeError, ValueError) as exc:
+            raise ArtifactError(
+                f"native on-the-fly benchmark context is invalid: {exc}"
+            ) from exc
+        if not isinstance(payload, Mapping):
+            raise ArtifactError("native on-the-fly benchmark context must be an object")
+        return dict(payload)
+
+    @property
+    def representative_process_key(self) -> str:
+        """Stable artifact process whose payload implements this selection."""
+
+        value = self._native_metadata.get("representative_process_key")
+        if not isinstance(value, str) or not value:
+            raise CompatibilityError(
+                "native runtime metadata has no representative process key"
+            )
+        return value
+
+    @property
+    def external_count(self) -> int:
+        """Authenticated number of public external legs."""
+
+        value = self._native_metadata.get("external_count")
+        if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+            raise CompatibilityError(
+                "native runtime metadata has no valid external process count"
+            )
+        return value
+
+    @property
+    def external_permutation(self) -> tuple[int, ...]:
+        """Representative-index to public-index external-leg permutation."""
+
+        raw = self._native_metadata.get("external_permutation")
+        if not isinstance(raw, list) or any(
+            isinstance(value, bool) or not isinstance(value, int) for value in raw
+        ):
+            raise CompatibilityError(
+                "native runtime metadata has no external process permutation"
+            )
+        permutation = tuple(raw)
+        count = self.external_count
+        if len(permutation) != count or sorted(permutation) != list(range(count)):
+            raise ArtifactError("native runtime external permutation is invalid")
+        return permutation
+
+    @property
+    def process_group_factor(self) -> Fraction:
+        """Exact factor relating the selected process to its representative."""
+
+        raw = self._native_metadata.get("process_group_factor")
+        if raw is None:
+            return Fraction(1)
+        if not isinstance(raw, Mapping):
+            raise ArtifactError("native runtime process-group factor is invalid")
+        numerator, denominator = raw.get("numerator"), raw.get("denominator")
+        if (
+            type(numerator) is not int
+            or type(denominator) is not int
+            or numerator < 1
+            or denominator < 1
+        ):
+            raise ArtifactError("native runtime process-group factor is invalid")
+        return Fraction(numerator, denominator)
+
+    @property
+    def charge_conjugated(self) -> bool:
+        """Whether the selected process is its representative's conjugate."""
+
+        return self._native_metadata.get("charge_conjugated") is True
+
+    @property
+    def artifact_id(self) -> str:
+        """Return the manifest identity authenticated by the native loader."""
+
+        value = getattr(self._runtime, "artifact_id", None)
+        if not isinstance(value, str) or len(value) != 64:
+            raise CompatibilityError(
+                "native runtime has no authenticated artifact identity; "
+                "reinstall pyAmpliCol from the current source revision"
+            )
+        try:
+            int(value, 16)
+        except ValueError as exc:
+            raise ArtifactError(
+                "native runtime carries an invalid artifact identity"
+            ) from exc
+        return value
+
+    @property
+    def supports_profiling(self) -> bool:
+        """Whether this installed native runtime exposes the optional profiler."""
+
+        return callable(getattr(self._runtime, "profile", None))
+
+    @property
+    def supports_per_point_selectors(self) -> bool:
+        """Whether this artifact/runtime pair supports per-point selectors."""
+
+        return self._supports_per_point_selectors
+
+    @property
+    def required_runtime_capabilities(self) -> tuple[str, ...]:
+        """Runtime capabilities declared by the selected artifact process."""
+
+        return self._required_runtime_capabilities
+
+    def _validate_runtime_selector_capability(
+        self,
+        manifest: ArtifactManifest,
+    ) -> None:
+        selected_id = self._native_metadata.get("process_group_member_of")
+        if selected_id is None:
+            selected_id = self._native_metadata.get("process_key")
+        if not isinstance(selected_id, str) or not selected_id:
+            selected_id = self.physics.process_id
+        process = _selected_manifest_process(manifest, selected_id)
+        capabilities = tuple(
+            str(value)
+            for value in cast(
+                Sequence[object], process["required_runtime_capabilities"]
+            )
+        )
+        self._required_runtime_capabilities = capabilities
+        if self._execution_mode == "compiled":
+            reusable_selectors = _has_reusable_runtime_selector_contract(
+                manifest,
+                process,
+            )
+            declares_selector_capability = (
+                COMPILED_RUNTIME_SELECTORS_CAPABILITY in capabilities
+            )
+            if reusable_selectors and not declares_selector_capability:
+                raise CompatibilityError(
+                    "compiled artifact declares reusable runtime selectors but does "
+                    f"not require {COMPILED_RUNTIME_SELECTORS_CAPABILITY!r}; "
+                    "regenerate the artifact with the current pyAmpliCol"
+                )
+            self._supports_per_point_selectors = declares_selector_capability
+        elif self._execution_mode == "eager":
+            self._supports_per_point_selectors = (
+                EAGER_RUNTIME_LAYOUT_F64_CAPABILITY in capabilities
+            )
+        elif self._execution_mode == "on-the-fly":
+            color_capabilities = {
+                ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+                ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            }
+            capability_values = set(capabilities)
+            selected_color_capabilities = capability_values.intersection(
+                color_capabilities
+            )
+            expected_capabilities: set[str] = set()
+            if len(selected_color_capabilities) == 1:
+                selected_color_capability = next(iter(selected_color_capabilities))
+                expected_capabilities = {
+                    ON_THE_FLY_RUNTIME_CAPABILITY,
+                    selected_color_capability,
+                }
+                if (
+                    selected_color_capability
+                    == ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY
+                    and SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY
+                    in capability_values
+                ):
+                    expected_capabilities.add(
+                        SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY
+                    )
+            # The native loader has already authenticated the OTF color payload.
+            # Keep this adapter check exact: only contracted color may add FFT.
+            if (
+                len(selected_color_capabilities) != 1
+                or capability_values != expected_capabilities
+                or len(capabilities) != len(expected_capabilities)
+            ):
+                raise CompatibilityError(
+                    "on-the-fly artifact has an invalid runtime capability contract"
+                )
+            self._supports_per_point_selectors = True
+        else:
+            self._supports_per_point_selectors = (
+                RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY in capabilities
+            )
+        if self._supports_per_point_selectors and not _accepts_keyword_arguments(
+            self._runtime.evaluate,
+            "helicity_by_point",
+            "color_flow_by_point",
+        ):
+            if self._execution_mode == "compiled":
+                required = COMPILED_RUNTIME_SELECTORS_CAPABILITY
+            elif self._execution_mode == "eager":
+                required = EAGER_RUNTIME_LAYOUT_F64_CAPABILITY
+            elif self._execution_mode == "on-the-fly":
+                required = ON_THE_FLY_RUNTIME_CAPABILITY
+            else:
+                required = RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY
+            raise CompatibilityError(
+                f"artifact requires runtime capability {required!r}, but the "
+                "installed native runtime does not accept per-point selectors"
+            )
+
+    def warm_up(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        precision: int = 16,
+        progress: ProgressSink | None = None,
+        n_cores: int | None = None,
+    ) -> WarmUpResult:
+        """Warm one compact OTF selector family from exactly one f64 point."""
+
+        if self._execution_mode != "on-the-fly":
+            raise CompatibilityError(
+                "explicit warm-up is available only for on-the-fly runtimes"
+            )
+        self._require_supported_precision(precision)
+        if len(momenta) != 1:
+            raise EvaluationError(
+                "on-the-fly warm-up requires exactly one phase-space point"
+            )
+        helicities = _normalized_selectors(helicities)
+        color_flows = _normalized_selectors(color_flows)
+        color_accuracy = self._native_metadata.get("color_accuracy")
+        if not isinstance(color_accuracy, str):
+            color_accuracy = getattr(self._runtime, "color_accuracy", None)
+        if color_accuracy not in {"lc", "nlc", "full"}:
+            raise ArtifactError(
+                "native on-the-fly runtime metadata has invalid color accuracy"
+            )
+        if color_accuracy != "lc" and color_flows is not None:
+            raise EvaluationError(
+                "NLC/full on-the-fly warm-up does not expose color-flow selectors"
+            )
+        color_flows = self._resolve_color_flows(color_flows)
+        operation = getattr(self._runtime, "_on_the_fly_warm_up_f64_json", None)
+        if not callable(operation):
+            raise CompatibilityError(
+                "installed native runtime has no explicit on-the-fly warm-up binding"
+            )
+        reporter = (
+            None
+            if progress is None
+            else _OnTheFlyWarmUpProgress(
+                progress,
+                process=self._native_metadata.get("process"),
+                color_accuracy=color_accuracy,
+            )
+        )
+        try:
+            raw = _invoke(
+                self._native_module,
+                operation,
+                momenta,
+                helicity_ids=helicities,
+                color_flow_ids=color_flows,
+                progress_callback=reporter,
+                n_cores=n_cores,
+            )
+            result = _warm_up_result(raw)
+        except Exception as exc:
+            if reporter is not None:
+                # Cleanup reporting must not replace the native/callback error.
+                with suppress(Exception):
+                    reporter.finish(success=False, message=str(exc))
+            raise
+        if reporter is not None:
+            # The native warm-up is committed; terminal reporting cannot undo it.
+            with suppress(Exception):
+                reporter.finish(success=True, elapsed_seconds=result.elapsed_seconds)
+        return result
+
+    def evaluate(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        helicity_by_point: Sequence[str] | None = None,
+        color_flow_by_point: Sequence[str] | None = None,
+        precision: int = 16,
+    ) -> tuple[complex | Decimal, ...]:
+        self._require_supported_precision(precision)
+        helicities = _normalized_selectors(helicities)
+        color_flows = _normalized_selectors(color_flows)
+        helicity_by_point = _normalized_selectors(helicity_by_point)
+        color_flow_by_point = _normalized_selectors(color_flow_by_point)
+        if helicities is not None and helicity_by_point is not None:
+            raise EvaluationError(
+                "helicities and helicity_by_point are mutually exclusive"
+            )
+        if color_flows is not None and color_flow_by_point is not None:
+            raise EvaluationError(
+                "color_flows and color_flow_by_point are mutually exclusive"
+            )
+        color_flows = self._resolve_color_flows(color_flows)
+        color_flow_by_point = self._resolve_color_flows(color_flow_by_point)
+        if (
+            helicity_by_point is not None or color_flow_by_point is not None
+        ) and not self._supports_per_point_selectors:
+            raise CompatibilityError(
+                "the selected artifact/runtime does not support per-point "
+                "helicity or color-flow selectors; regenerate a reusable-selector "
+                "artifact with the current pyAmpliCol"
+            )
+        helicity_indices = (
+            None
+            if helicity_by_point is None
+            else self._point_selector_indices(
+                helicity_by_point,
+                "helicity_by_point",
+            )
+        )
+        color_indices = (
+            None
+            if color_flow_by_point is None
+            else self._point_selector_indices(
+                color_flow_by_point,
+                "color_flow_by_point",
+            )
+        )
+        if precision != 16:
+            if helicity_by_point is not None or color_flow_by_point is not None:
+                return self._evaluate_exact_by_point(
+                    momenta,
+                    helicities=helicities,
+                    color_flows=color_flows,
+                    helicity_by_point=helicity_by_point,
+                    color_flow_by_point=color_flow_by_point,
+                    precision=precision,
+                )
+            return (
+                self._exact()
+                .evaluate_resolved(
+                    momenta,
+                    helicities=helicities,
+                    color_flows=color_flows,
+                    precision=precision,
+                )
+                .total()
+            )
+        selector_arguments: dict[str, object] = {}
+        if helicity_indices is not None:
+            selector_arguments["helicity_by_point"] = helicity_indices
+        if color_indices is not None:
+            selector_arguments["color_flow_by_point"] = color_indices
+        values = _invoke(
+            self._native_module,
+            self._runtime.evaluate,
+            momenta,
+            helicities=helicities,
+            color_flows=color_flows,
+            precision=precision,
+            **selector_arguments,
+        )
+        return tuple(_scalar_from_native(value) for value in values)
+
+    def _point_selector_indices(
+        self,
+        values: Sequence[str] | None,
+        name: str,
+    ) -> tuple[int, ...] | None:
+        if values is None:
+            return None
+        if self._execution_mode == "on-the-fly":
+            resolver = getattr(
+                self._runtime,
+                "_on_the_fly_selector_ordinals_json",
+                None,
+            )
+            if not callable(resolver):
+                raise CompatibilityError(
+                    "installed native runtime has no compact on-the-fly "
+                    "selector resolver"
+                )
+            helicities = values if name == "helicity_by_point" else None
+            colors = values if name == "color_flow_by_point" else None
+            try:
+                payload = json.loads(str(resolver(helicities, colors)))
+            except (TypeError, ValueError) as exc:
+                raise ArtifactError(
+                    f"native on-the-fly point-selector response is invalid: {exc}"
+                ) from exc
+            if not isinstance(payload, Mapping):
+                raise ArtifactError(
+                    "native on-the-fly point-selector response must be an object"
+                )
+            key = (
+                "helicity_ordinals" if name == "helicity_by_point" else "color_ordinals"
+            )
+            raw = payload.get(key)
+            if (
+                not isinstance(raw, list)
+                or len(raw) != len(values)
+                or any(
+                    isinstance(value, bool) or not isinstance(value, int) or value < 0
+                    for value in raw
+                )
+            ):
+                raise ArtifactError(f"native on-the-fly {name} ordinals are invalid")
+            return tuple(raw)
+        available = (
+            self.physics.helicity_ids
+            if name == "helicity_by_point"
+            else self.physics.color_ids
+        )
+        index_by_id = {identifier: index for index, identifier in enumerate(available)}
+        indices: list[int] = []
+        for point_index, identifier in enumerate(values):
+            try:
+                indices.append(index_by_id[identifier])
+            except KeyError as exc:
+                raise EvaluationError(
+                    f"{name}[{point_index}] references unknown selector {identifier!r}"
+                ) from exc
+        return tuple(indices)
+
+    def _evaluate_exact_by_point(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None,
+        color_flows: Sequence[str] | None,
+        helicity_by_point: Sequence[str] | None,
+        color_flow_by_point: Sequence[str] | None,
+        precision: int,
+    ) -> tuple[complex | Decimal, ...]:
+        point_count = len(momenta)
+        for name, selectors in (
+            ("helicity_by_point", helicity_by_point),
+            ("color_flow_by_point", color_flow_by_point),
+        ):
+            if selectors is not None and len(selectors) != point_count:
+                raise EvaluationError(
+                    f"{name} contains {len(selectors)} entries, expected one "
+                    f"selector for each of {point_count} points"
+                )
+        grouped: dict[tuple[str | None, str | None], list[int]] = {}
+        for point_index in range(point_count):
+            key = (
+                None if helicity_by_point is None else helicity_by_point[point_index],
+                None
+                if color_flow_by_point is None
+                else color_flow_by_point[point_index],
+            )
+            grouped.setdefault(key, []).append(point_index)
+        output: list[complex | Decimal | None] = [None] * point_count
+        exact = self._exact()
+        for (point_helicity, point_color), point_indices in grouped.items():
+            selected_momenta = tuple(momenta[index] for index in point_indices)
+            resolved = exact.evaluate_resolved(
+                selected_momenta,
+                helicities=(
+                    (point_helicity,) if point_helicity is not None else helicities
+                ),
+                color_flows=(point_color,) if point_color is not None else color_flows,
+                precision=precision,
+            )
+            for point_index, value in zip(point_indices, resolved.total(), strict=True):
+                output[point_index] = value
+        if any(value is None for value in output):
+            raise EvaluationError("per-point exact selector evaluation was incomplete")
+        return cast(tuple[complex | Decimal, ...], tuple(output))
+
+    def _benchmark_f64_wall_time(
+        self,
+        momenta: Momenta,
+        repetitions: int,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        helicity_by_point: Sequence[str] | None = None,
+        color_flow_by_point: Sequence[str] | None = None,
+        precision: int = 16,
+    ) -> float:
+        self._require_supported_precision(precision)
+        helicities = _normalized_selectors(helicities)
+        color_flows = _normalized_selectors(color_flows)
+        helicity_by_point = _normalized_selectors(helicity_by_point)
+        color_flow_by_point = _normalized_selectors(color_flow_by_point)
+        if helicities is not None and helicity_by_point is not None:
+            raise EvaluationError(
+                "helicities and helicity_by_point are mutually exclusive"
+            )
+        if color_flows is not None and color_flow_by_point is not None:
+            raise EvaluationError(
+                "color_flows and color_flow_by_point are mutually exclusive"
+            )
+        color_flows = self._resolve_color_flows(color_flows)
+        color_flow_by_point = self._resolve_color_flows(color_flow_by_point)
+        if (
+            helicity_by_point is not None or color_flow_by_point is not None
+        ) and not self._supports_per_point_selectors:
+            raise CompatibilityError(
+                "the selected artifact/runtime does not support per-point "
+                "helicity or color-flow selectors"
+            )
+        helicity_indices = (
+            None
+            if helicity_by_point is None
+            else self._point_selector_indices(
+                helicity_by_point,
+                "helicity_by_point",
+            )
+        )
+        color_indices = (
+            None
+            if color_flow_by_point is None
+            else self._point_selector_indices(
+                color_flow_by_point,
+                "color_flow_by_point",
+            )
+        )
+        timer = getattr(self._runtime, "_benchmark_f64_wall_time", None)
+        if not callable(timer):
+            raise EvaluationError("native Rusticol wall timer is unavailable")
+        selector_arguments: dict[str, object] = {}
+        if helicity_indices is not None:
+            selector_arguments["helicity_by_point"] = helicity_indices
+        if color_indices is not None:
+            selector_arguments["color_flow_by_point"] = color_indices
+        return float(
+            _invoke(
+                self._native_module,
+                timer,
+                momenta,
+                repetitions,
+                helicities=helicities,
+                color_flows=color_flows,
+                precision=precision,
+                **selector_arguments,
+            )
+        )
+
+    def _profile_arena_repeated(
+        self,
+        momenta: Momenta,
+        repetitions: int,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        precision: int = 16,
+        include_values: bool = False,
+    ) -> Mapping[str, object]:
+        """Use the private warmed-Arena profiler without a public fallback."""
+
+        self._require_supported_precision(precision)
+        helicities = _normalized_selectors(helicities)
+        color_flows = self._resolve_color_flows(_normalized_selectors(color_flows))
+        if precision != 16:
+            raise EvaluationError(
+                "Arena profiling is available only for native f64 precision"
+            )
+        profiler = getattr(self._runtime, "_profile_arena_repeated", None)
+        if not callable(profiler):
+            raise EvaluationError(
+                "native runtime does not expose warmed Arena profiling"
+            )
+        payload = _invoke(
+            self._native_module,
+            profiler,
+            momenta,
+            repetitions,
+            helicities=helicities,
+            color_flows=color_flows,
+            precision=precision,
+            include_values=include_values,
+        )
+        if not isinstance(payload, Mapping):
+            raise EvaluationError("native warmed Arena profile is not a mapping")
+        return cast(Mapping[str, object], dict(payload))
+
+    def evaluate_resolved(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        precision: int = 16,
+    ) -> ResolvedEvaluation:
+        self._require_supported_precision(precision)
+        helicities = _normalized_selectors(helicities)
+        color_flows = self._resolve_color_flows(_normalized_selectors(color_flows))
+        if precision != 16:
+            return self._exact().evaluate_resolved(
+                momenta,
+                helicities=helicities,
+                color_flows=color_flows,
+                precision=precision,
+            )
+        native = _invoke(
+            self._native_module,
+            self._runtime.evaluate_resolved,
+            momenta,
+            helicities=helicities,
+            color_flows=color_flows,
+            precision=precision,
+        )
+        values = tuple(
+            tuple(
+                tuple(_scalar_from_native(entry) for entry in colors)
+                for colors in helicities_at_point
+            )
+            for helicities_at_point in native.values
+        )
+        return ResolvedEvaluation(
+            values=values,
+            helicity_ids=tuple(str(value) for value in native.helicity_ids),
+            color_ids=tuple(str(value) for value in native.color_ids),
+            color_accuracy=cast(_Accuracy, str(native.color_accuracy)),
+        )
+
+    def profile(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        helicity_by_point: Sequence[str] | None = None,
+        color_flow_by_point: Sequence[str] | None = None,
+        precision: int = 16,
+        include_values: bool = False,
+    ) -> Mapping[str, object]:
+        self._require_supported_precision(precision)
+        helicities = _normalized_selectors(helicities)
+        color_flows = self._resolve_color_flows(_normalized_selectors(color_flows))
+        helicity_by_point = _normalized_selectors(helicity_by_point)
+        color_flow_by_point = self._resolve_color_flows(
+            _normalized_selectors(color_flow_by_point)
+        )
+        if helicities is not None and helicity_by_point is not None:
+            raise EvaluationError(
+                "helicities and helicity_by_point are mutually exclusive"
+            )
+        if color_flows is not None and color_flow_by_point is not None:
+            raise EvaluationError(
+                "color_flows and color_flow_by_point are mutually exclusive"
+            )
+        if precision != 16:
+            raise EvaluationError(
+                "runtime profiling is available only for native f64 precision"
+            )
+        profiler = getattr(self._runtime, "profile", None)
+        if not callable(profiler):
+            raise EvaluationError("native runtime does not expose profiling")
+        selector_arguments: dict[str, object] = {}
+        if helicity_by_point is not None or color_flow_by_point is not None:
+            if not self._supports_per_point_selectors or not _accepts_keyword_arguments(
+                profiler,
+                "helicity_by_point",
+                "color_flow_by_point",
+            ):
+                raise CompatibilityError(
+                    "the selected artifact/runtime does not support profiling "
+                    "with per-point helicity or color-flow selectors"
+                )
+            helicity_indices = self._point_selector_indices(
+                helicity_by_point,
+                "helicity_by_point",
+            )
+            color_indices = self._point_selector_indices(
+                color_flow_by_point,
+                "color_flow_by_point",
+            )
+            if helicity_indices is not None:
+                selector_arguments["helicity_by_point"] = helicity_indices
+            if color_indices is not None:
+                selector_arguments["color_flow_by_point"] = color_indices
+        payload = _invoke(
+            self._native_module,
+            profiler,
+            momenta,
+            helicities=helicities,
+            color_flows=color_flows,
+            precision=precision,
+            include_values=include_values,
+            **selector_arguments,
+        )
+        if not isinstance(payload, Mapping):
+            raise EvaluationError("native runtime profile is not a mapping")
+        return cast(Mapping[str, object], dict(payload))
+
+    def profile_repeated(
+        self,
+        momenta: Momenta,
+        repetitions: int,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        helicity_by_point: Sequence[str] | None = None,
+        color_flow_by_point: Sequence[str] | None = None,
+        precision: int = 16,
+        include_values: bool = False,
+    ) -> Mapping[str, object]:
+        self._require_supported_precision(precision)
+        helicities = _normalized_selectors(helicities)
+        color_flows = self._resolve_color_flows(_normalized_selectors(color_flows))
+        helicity_by_point = _normalized_selectors(helicity_by_point)
+        color_flow_by_point = self._resolve_color_flows(
+            _normalized_selectors(color_flow_by_point)
+        )
+        if helicities is not None and helicity_by_point is not None:
+            raise EvaluationError(
+                "helicities and helicity_by_point are mutually exclusive"
+            )
+        if color_flows is not None and color_flow_by_point is not None:
+            raise EvaluationError(
+                "color_flows and color_flow_by_point are mutually exclusive"
+            )
+        if precision != 16:
+            raise EvaluationError(
+                "runtime profiling is available only for native f64 precision"
+            )
+        profiler = getattr(self._runtime, "profile_repeated", None)
+        if not callable(profiler):
+            raise EvaluationError("native runtime does not expose repeated profiling")
+        selector_arguments: dict[str, object] = {}
+        if helicity_by_point is not None or color_flow_by_point is not None:
+            if not self._supports_per_point_selectors or not _accepts_keyword_arguments(
+                profiler,
+                "helicity_by_point",
+                "color_flow_by_point",
+            ):
+                raise CompatibilityError(
+                    "the selected artifact/runtime does not support profiling "
+                    "with per-point helicity or color-flow selectors"
+                )
+            helicity_indices = self._point_selector_indices(
+                helicity_by_point,
+                "helicity_by_point",
+            )
+            color_indices = self._point_selector_indices(
+                color_flow_by_point,
+                "color_flow_by_point",
+            )
+            if helicity_indices is not None:
+                selector_arguments["helicity_by_point"] = helicity_indices
+            if color_indices is not None:
+                selector_arguments["color_flow_by_point"] = color_indices
+        payload = _invoke(
+            self._native_module,
+            profiler,
+            momenta,
+            repetitions,
+            helicities=helicities,
+            color_flows=color_flows,
+            precision=precision,
+            include_values=include_values,
+            **selector_arguments,
+        )
+        if not isinstance(payload, Mapping):
+            raise EvaluationError("native repeated runtime profile is not a mapping")
+        return cast(Mapping[str, object], dict(payload))
+
+    def evaluate_profile(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        helicity_by_point: Sequence[str] | None = None,
+        color_flow_by_point: Sequence[str] | None = None,
+        precision: int = 16,
+        include_values: bool = False,
+    ) -> Mapping[str, object]:
+        return self.profile(
+            momenta,
+            helicities=helicities,
+            color_flows=color_flows,
+            helicity_by_point=helicity_by_point,
+            color_flow_by_point=color_flow_by_point,
+            precision=precision,
+            include_values=include_values,
+        )
+
+    def _resolve_color_flows(
+        self,
+        color_flows: Sequence[str] | None,
+    ) -> tuple[str, ...] | None:
+        if color_flows is None or not color_flows:
+            return None
+        if self._execution_mode == "on-the-fly":
+
+            def is_ordinal(value: str) -> bool:
+                try:
+                    ordinal = int(value, 10)
+                except ValueError:
+                    return False
+                return str(ordinal) == value.strip()
+
+            if not any(is_ordinal(value) for value in color_flows):
+                return tuple(color_flows)
+            context = self._on_the_fly_benchmark_context(color_flows)
+            assert context is not None
+            selected = context.get("selected_color_ids")
+            if not isinstance(selected, Sequence) or isinstance(
+                selected,
+                (str, bytes),
+            ):
+                raise ArtifactError("native on-the-fly selected color IDs are invalid")
+            return tuple(str(value) for value in selected)
+        available = self.physics.color_ids
+        resolved: list[str] = []
+        for requested in color_flows:
+            if requested in available:
+                resolved.append(requested)
+                continue
+            try:
+                ordinal = int(requested, 10)
+            except ValueError:
+                resolved.append(requested)
+                continue
+            if (
+                str(ordinal) != requested.strip()
+                or ordinal < 1
+                or ordinal > len(available)
+            ):
+                raise EvaluationError(
+                    f"color-flow ordinal {requested!r} is out of range; choose "
+                    f"1..{len(available)} or a stable color component ID"
+                )
+            resolved.append(available[ordinal - 1])
+        return tuple(resolved)
+
+    def _exact(self) -> _ExactExecutor:
+        if self._exact_executor is None:
+            if self._execution_mode == "eager":
+                from .eager_exact import EagerExactExecutor
+
+                self._exact_executor = EagerExactExecutor(
+                    self._artifact_path, self.physics.process_id, self._runtime
+                )
+            elif self._execution_mode == "recurrence":
+                from .recurrence_exact import RecurrenceExactExecutor
+
+                self._exact_executor = RecurrenceExactExecutor(
+                    self._artifact_path, self.physics.process_id, self._runtime
+                )
+            else:
+                from .symbolica_exact import SymbolicaExactExecutor
+
+                self._exact_executor = SymbolicaExactExecutor(
+                    self._artifact_path, self.physics.process_id, self._runtime
+                )
+            factor, conjugated = self.process_group_factor, self.charge_conjugated
+            if factor != 1 or conjugated:
+                self._exact_executor = cast(
+                    "_ExactExecutor",
+                    _ProcessGroupExactExecutor(
+                        self._exact_executor, factor, conjugated
+                    ),
+                )
+        return self._exact_executor
+
+    def _diagnostic_project_onshell(
+        self,
+        momenta: Momenta,
+        *,
+        precision: int,
+    ) -> tuple[
+        tuple[tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...], ...],
+        dict[str, object],
+    ]:
+        """Project kinematics only for the bounded validation diagnostic."""
+
+        self._require_supported_precision(precision)
+        return self._exact()._diagnostic_project_onshell(
+            momenta,
+            precision=precision,
+        )
+
+    def set_model_parameters(self, mapping: ModelParameters) -> None:
+        _invoke(
+            self._native_module,
+            self._runtime.set_model_parameters,
+            dict(mapping),
+        )
+
+    def clear(self) -> None:
+        _invoke(self._native_module, self._runtime.clear)
+
+    def mute_warnings(self) -> None:
+        _invoke(self._native_module, self._runtime.mute_warnings)
+
+    def unmute_warnings(self) -> None:
+        _invoke(self._native_module, self._runtime.unmute_warnings)
+
+    def take_warnings(self) -> tuple[str, ...]:
+        values = _invoke(self._native_module, self._runtime.take_warnings)
+        return tuple(str(value) for value in values)
+
+    def validation_momenta(self) -> Momenta | None:
+        """Return the selected process's verified deterministic artifact point."""
+
+        manifest = load_manifest(self._artifact_path)
+        selection = native_process_selection(self._runtime, manifest.processes)
+        representative = selection.process
+        permutation = selection.external_permutation
+        process_id = selection.representative_process_id
+        payloads = tuple(
+            payload
+            for payload in manifest.payloads
+            if payload.role == "validation-momenta" and payload.process_id == process_id
+        )
+        if len(payloads) != 1:
+            raise ArtifactError(
+                f"process {process_id!r} must declare exactly one validation point"
+            )
+        try:
+            raw = json.loads((manifest.root / payloads[0].path).read_text("utf-8"))
+        except (OSError, json.JSONDecodeError) as exc:
+            raise ArtifactError(
+                f"could not read validation point for process {process_id!r}: {exc}"
+            ) from exc
+        if not isinstance(raw, dict) or raw.get("available") is not True:
+            return None
+        points = raw.get("points")
+        if not isinstance(points, list) or len(points) != 1:
+            raise ArtifactError(
+                f"process {process_id!r} has invalid validation-point metadata"
+            )
+        particles = points[0]
+        expected_pdgs = tuple(
+            _manifest_integer(value, "representative external PDG")
+            for value in cast(Sequence[object], representative["external_pdgs"])
+        )
+        if not isinstance(particles, list) or len(particles) != len(expected_pdgs):
+            raise ArtifactError(
+                f"process {process_id!r} validation point has the wrong particle count"
+            )
+        vectors: list[tuple[float, float, float, float]] = []
+        pdgs: list[int] = []
+        for index, particle in enumerate(particles):
+            if not isinstance(particle, dict):
+                raise ArtifactError(
+                    f"process {process_id!r} validation particle {index} is invalid"
+                )
+            momentum = particle.get("momentum")
+            if not isinstance(momentum, list) or len(momentum) != 4:
+                raise ArtifactError(
+                    f"process {process_id!r} validation momentum {index} is invalid"
+                )
+            try:
+                pdgs.append(int(particle["pdg"]))
+                vectors.append(
+                    cast(
+                        tuple[float, float, float, float],
+                        tuple(float(component) for component in momentum),
+                    )
+                )
+            except (KeyError, TypeError, ValueError) as exc:
+                raise ArtifactError(
+                    f"process {process_id!r} validation particle {index} is invalid"
+                ) from exc
+        if tuple(pdgs) != expected_pdgs:
+            raise ArtifactError(
+                f"process {process_id!r} validation PDGs do not match its metadata"
+            )
+        reordered: list[tuple[float, float, float, float] | None] = [None] * len(
+            vectors
+        )
+        for representative_index, public_index in enumerate(permutation):
+            reordered[public_index] = vectors[representative_index]
+        if any(vector is None for vector in reordered):
+            raise ArtifactError(
+                f"selected process {process_id!r} has an incomplete permutation"
+            )
+        vectors = cast(list[tuple[float, float, float, float]], reordered)
+        return (tuple(vectors),)
+
+
+class _ProcessGroupExactExecutor:
+    """Present a representative's exact results as a process-group member.
+
+    Values are multiplied by the member's exact factor; a charge-conjugated
+    member's LC color-flow IDs are the reversed representative words, mapped
+    on input and output exactly as in the native lane.
+    """
+
+    def __init__(self, inner: Any, factor: Fraction, conjugated: bool) -> None:
+        self._inner = inner
+        self._factor = factor
+        self._conjugated = conjugated
+
+    def _color_ids(self, values: Sequence[str] | None) -> tuple[str, ...] | None:
+        if values is None or not self._conjugated:
+            return None if values is None else tuple(values)
+        return tuple(charge_conjugate_color_id(value) for value in values)
+
+    def _scaled(self, value: complex | Decimal, precision: int) -> complex | Decimal:
+        if self._factor == 1:
+            return value
+        if not isinstance(value, Decimal):
+            return value * self._factor.numerator / self._factor.denominator
+        digits = max(precision, len(value.as_tuple().digits))
+        with localcontext() as context:
+            context.rounding = ROUND_HALF_EVEN
+            # Exact product, then one correctly rounded division.
+            context.prec = digits + len(str(self._factor.numerator))
+            product = value * self._factor.numerator
+            context.prec = digits
+            return product / self._factor.denominator
+
+    def evaluate_resolved(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None,
+        color_flows: Sequence[str] | None,
+        precision: int,
+    ) -> ResolvedEvaluation:
+        resolved = self._inner.evaluate_resolved(
+            momenta,
+            helicities=helicities,
+            color_flows=self._color_ids(color_flows),
+            precision=precision,
+        )
+        return ResolvedEvaluation(
+            values=tuple(
+                tuple(
+                    tuple(self._scaled(value, precision) for value in colors)
+                    for colors in point
+                )
+                for point in resolved.values
+            ),
+            helicity_ids=resolved.helicity_ids,
+            color_ids=cast(tuple[str, ...], self._color_ids(resolved.color_ids)),
+            color_accuracy=resolved.color_accuracy,
+        )
+
+    def _diagnostic_project_onshell(self, momenta: Momenta, *, precision: int) -> Any:
+        return self._inner._diagnostic_project_onshell(momenta, precision=precision)
+
+
+def load_runtime_backend(
+    artifact: os.PathLike[str] | str,
+    *,
+    process: str | None = None,
+    model_parameters: ModelParameters | None = None,
+    mute_warnings: bool = False,
+) -> RusticolRuntimeBackend:
+    """Load a schema-v3 artifact without importing the extension during discovery."""
+
+    path = Path(os.fspath(artifact)).expanduser().resolve(strict=False)
+    parameters = dict(model_parameters) if model_parameters is not None else None
+    module = _load_native_module()
+    # Rusticol is the authoritative runtime loader and verifies every declared
+    # payload before returning.  Parse the manifest here only for the Python
+    # adapter's selector-contract checks; hashing it again would add a complete
+    # extra pass over large compact eager containers.
+    manifest = (
+        load_manifest(path, verify_payloads=False)
+        if (path / MANIFEST_NAME).is_file()
+        else None
+    )
+    runtime = _invoke(
+        module,
+        module.Runtime.load,
+        path,
+        process=process,
+        model_parameters=parameters,
+        mute_warnings=mute_warnings,
+    )
+    return RusticolRuntimeBackend(runtime, module, path, manifest)
+
+
+__all__ = ["RusticolRuntimeBackend", "load_runtime_backend"]
diff --git a/pyamplicol/src/pyamplicol/runtime/correlated_exact.py b/pyamplicol/src/pyamplicol/runtime/correlated_exact.py
new file mode 100644
index 0000000000..ae5de40d61
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/correlated_exact.py
@@ -0,0 +1,806 @@
+# SPDX-License-Identifier: 0BSD
+"""Isolated, unreduced reference amplitudes for declared Born correlations.
+
+The caller authenticates the correlation declaration and its generation policy.
+This executor intentionally does not change any ordinary execution path. It
+accepts only materialized, unreplayed compiled plans with complete source slots.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Mapping, Sequence
+from dataclasses import dataclass
+from decimal import ROUND_HALF_EVEN, Decimal, localcontext
+from pathlib import Path
+from typing import Any, cast
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError, EvaluationError
+from pyamplicol.api.protocols import Momenta
+from pyamplicol.runtime._normalization_exact import exact_normalization
+from pyamplicol.runtime.symbolica_exact import (
+    SymbolicaExactExecutor,
+    _assign_stage_outputs,
+    _canonical_amplitude_outputs,
+    _complex_mul,
+    _complex_zero,
+    _ComplexDecimal,
+    _crossing_phase,
+    _decimal,
+    _fill_momenta,
+    _json_integer,
+    _pack_stage_inputs,
+    _prepare_points,
+    _runtime_state,
+    _source_wavefunction,
+    _validated_source_ir,
+    _working_precision,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class CoherentAmplitudeGroup:
+    """One physical-helicity/color-basis coefficient, before any metric."""
+
+    group_id: int
+    helicity_id: str
+    helicities: tuple[int, ...]
+    color_word: tuple[int, ...]
+    color_sector_id: int
+
+
+@dataclass(frozen=True, slots=True)
+class CoherentAmplitudeBatch:
+    """Complex amplitudes in ``(point, physical group, real/imag)`` order.
+
+    Root colour/coupling coefficients are already included; folded helicity
+    and squared-colour weights are not. Distinct raw groups contributing to
+    the same physical helicity/colour sector have been summed coherently.
+    ``normalization_factor`` belongs to the final bilinear, not each amplitude.
+    ``spin_correlated_legs`` are one-based public legs replaced in this call;
+    their entries in each group's helicity vector are placeholder labels only.
+    """
+
+    values: tuple[tuple[_ComplexDecimal, ...], ...]
+    groups: tuple[CoherentAmplitudeGroup, ...]
+    normalization_factor: Decimal
+    precision: int
+    spin_correlated_legs: tuple[int, ...]
+
+
+_StageMemo = dict[int, tuple[tuple[_ComplexDecimal, ...], tuple[_ComplexDecimal, ...]]]
+
+
+def _identical_stage_inputs(
+    left: tuple[_ComplexDecimal, ...], right: tuple[_ComplexDecimal, ...]
+) -> bool:
+    """Conservative exact equality, including signed zero and decimal precision."""
+    return len(left) == len(right) and all(
+        a.as_tuple() == b.as_tuple()
+        for x, y in zip(left, right, strict=True)
+        for a, b in zip(x, y, strict=True)
+    )
+
+
+def _record(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise ArtifactError(f"correlated {context} must be an object")
+    return value
+
+
+def _records(value: object, context: str) -> tuple[Mapping[str, object], ...]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise ArtifactError(f"correlated {context} must be a sequence")
+    return tuple(_record(item, context) for item in value)
+
+
+def _complex_component(value: object) -> _ComplexDecimal:
+    if isinstance(value, bool):
+        raise EvaluationError("spin-vector components must be numeric scalars")
+    if isinstance(value, complex):
+        return (
+            _decimal(value.real, "spin-vector real component"),
+            _decimal(value.imag, "spin-vector imaginary component"),
+        )
+    if isinstance(value, Sequence) and not isinstance(value, str | bytes):
+        if len(value) != 2:
+            raise EvaluationError(
+                "a complex spin component must be a (real, imaginary) pair"
+            )
+        return (
+            _decimal(value[0], "spin-vector real component"),
+            _decimal(value[1], "spin-vector imaginary component"),
+        )
+    return (_decimal(value, "spin-vector component"), Decimal(0))
+
+
+def _is_spin_vector(value: Sequence[object]) -> bool:
+    """Distinguish four complex scalars from a per-point vector batch."""
+
+    def scalar(item: object) -> bool:
+        return not isinstance(item, Sequence) or isinstance(item, str | bytes)
+
+    return len(value) == 4 and all(
+        scalar(item)
+        or (
+            isinstance(item, Sequence)
+            and len(item) == 2
+            and all(scalar(part) for part in item)
+        )
+        for item in value
+    )
+
+
+def _vector(value: object) -> tuple[_ComplexDecimal, ...]:
+    if (
+        isinstance(value, str | bytes)
+        or not isinstance(value, Sequence)
+        or len(value) != 4
+    ):
+        raise EvaluationError("a spin vector must contain four complex components")
+    return tuple(_complex_component(component) for component in value)
+
+
+def _prepare_spin_vectors(
+    spin_vectors: Mapping[int, object] | None,
+    *,
+    allowed_legs: Sequence[int],
+    point_count: int,
+) -> tuple[dict[int, tuple[_ComplexDecimal, ...]], ...]:
+    """Copy caller data; no vectors or mutable input buffers survive the call."""
+
+    if spin_vectors is None:
+        spin_vectors = {}
+    if not isinstance(spin_vectors, Mapping):
+        raise EvaluationError("spin_vectors must map public leg labels to vectors")
+    result: tuple[dict[int, tuple[_ComplexDecimal, ...]], ...] = tuple(
+        {} for _ in range(point_count)
+    )
+    for leg, raw in spin_vectors.items():
+        if isinstance(leg, bool) or not isinstance(leg, int) or leg not in allowed_legs:
+            raise EvaluationError(
+                f"spin-vector leg {leg!r} was not declared at generation"
+            )
+        if isinstance(raw, str | bytes) or not isinstance(raw, Sequence):
+            raise EvaluationError(
+                "spin vectors must be complex four-vectors or a batch"
+            )
+        # A four-scalar vector broadcasts; a sequence of vectors is point-specific.
+        broadcast = _is_spin_vector(raw)
+        if broadcast:
+            prepared = (_vector(raw),) * point_count
+        else:
+            if len(raw) != point_count:
+                raise EvaluationError(
+                    f"spin-vector batch has {len(raw)} points, expected {point_count}"
+                )
+            prepared = tuple(_vector(item) for item in raw)
+        for point, wave in zip(result, prepared, strict=True):
+            point[leg] = wave
+    return result
+
+
+def _fill_correlated_sources(
+    state: list[_ComplexDecimal],
+    point: Sequence[tuple[Decimal, Decimal, Decimal, Decimal]],
+    schema: Mapping[str, object],
+    model_parameters: Sequence[Decimal],
+    spin_vectors: Mapping[int, tuple[_ComplexDecimal, ...]],
+    *,
+    scalar: type[Decimal] | None = None,
+) -> None:
+    scalar = Decimal if scalar is None else scalar
+    source_fill = _record(schema.get("source_fill"), "source fill")
+    seen: set[int] = set()
+    for source in _records(source_fill.get("sources"), "sources"):
+        leg = _json_integer(source["leg_label"])
+        slot = _record(source.get("value_slot"), "source value slot")
+        start = _json_integer(slot["component_start"])
+        stop = _json_integer(slot["component_stop"])
+        if not 0 <= start < stop <= len(state):
+            raise ArtifactError("correlated source value slot is out of range")
+        if leg in spin_vectors:
+            source_ir, _identity, crossing = _validated_source_ir(source)
+            if source_ir["wavefunction_family"] != "vector" or (
+                _json_integer(source_ir["component_dimension"]) != 4
+                or stop - start != 4
+            ):
+                raise CompatibilityError(
+                    "spin correlation requires a full four-component vector source"
+                )
+            # Literal input, including its temporal component. In particular,
+            # v=p remains a nonzero leaf, so a Ward test exercises the amplitude.
+            # The public vector is not negated, projected, normalized or conjugated;
+            # SourceIR's ordinary amplitude crossing phase is applied once.
+            phase = cast(
+                _ComplexDecimal,
+                tuple(scalar(value) for value in _crossing_phase(crossing)),
+            )
+            wave = tuple(
+                _complex_mul((scalar(component[0]), scalar(component[1])), phase)
+                for component in spin_vectors[leg]
+            )
+            seen.add(leg)
+        else:
+            wave = _source_wavefunction(
+                source, point, schema, model_parameters, scalar=scalar
+            )
+        if len(wave) != stop - start:
+            raise ArtifactError(
+                "correlated source wavefunction does not match its value slot"
+            )
+        state[start:stop] = wave
+    if seen != set(spin_vectors):
+        raise ArtifactError("a declared spin-vector leg has no retained source")
+
+
+class CorrelatedExactExecutor(SymbolicaExactExecutor):
+    """Reference executor for generation-declared, uncompressed correlations.
+
+    Each call owns its vector data. Passing ``None`` or ``{}`` restores ordinary
+    helicity sources; no global patching or cross-instance source state is used.
+    """
+
+    _scalar: type[Decimal] | None = None
+
+    def __init__(
+        self,
+        artifact: Path,
+        process_id: str,
+        native_runtime: Any,
+        *,
+        spin_correlated_legs: Sequence[int] = (),
+        coherent_groups: Sequence[Mapping[str, object]] | None = None,
+    ) -> None:
+        super().__init__(artifact, process_id, native_runtime)
+        self._initialize_correlated_plan(spin_correlated_legs, coherent_groups)
+
+    def _initialize_correlated_plan(
+        self,
+        spin_correlated_legs: Sequence[int],
+        coherent_groups: Sequence[Mapping[str, object]] | None = None,
+    ) -> None:
+        particles = _records(
+            self._physics.get("external_particles"), "external particles"
+        )
+        external_count = len(particles)
+        if self._permutation not in (None, tuple(range(external_count))):
+            raise CompatibilityError(
+                "correlated reference execution does not support process aliases"
+            )
+        if any(
+            getattr(self, name, None) is not None
+            for name in (
+                "_lc_replay",
+                "_color_replay",
+                "_helicity_plan",
+                "_helicity_sum_execution",
+            )
+        ):
+            raise CompatibilityError(
+                "correlated reference execution requires an unreplayed, "
+                "unquotiented plan"
+            )
+        legs = tuple(spin_correlated_legs)
+        if any(
+            isinstance(leg, bool)
+            or not isinstance(leg, int)
+            or not 1 <= leg <= external_count
+            for leg in legs
+        ) or len(set(legs)) != len(legs):
+            raise EvaluationError(
+                "declared spin-correlated legs must be unique public leg labels"
+            )
+        self._spin_correlated_legs = tuple(sorted(legs))
+        schema = _record(self._execution.get("runtime_schema"), "runtime schema")
+        amplitude = _record(schema.get("amplitude_stage"), "amplitude stage")
+        if (
+            amplitude.get("color_topology_replay") is not None
+            or self._execution.get("lc_topology_replay") is not None
+        ):
+            raise CompatibilityError(
+                "correlated reference execution cannot use color replay"
+            )
+        helicity_records = _records(self._physics.get("helicities"), "helicities")
+        helicity_by_values: dict[tuple[int, ...], str] = {}
+        computed_helicities: set[str] = set()
+        for record in helicity_records:
+            identifier = str(record["id"])
+            if record.get("representative_id", identifier) != identifier:
+                raise CompatibilityError(
+                    "correlated reference execution cannot use helicity aliases"
+                )
+            computed = record.get("computed")
+            structural_zero = record.get("structural_zero") is True
+            if (computed is True and structural_zero) or (
+                computed is not True and not (computed is False and structural_zero)
+            ):
+                raise CompatibilityError(
+                    "correlated reference execution cannot use zero-pruned "
+                    "or incomplete helicities"
+                )
+            expected_coefficient = 1 if computed is True else 0
+            if (
+                _decimal(record.get("coefficient", 1), "helicity coefficient")
+                != expected_coefficient
+            ):
+                raise CompatibilityError(
+                    "correlated reference execution requires unit computed-helicity "
+                    "weights and zero structural-zero weights"
+                )
+            values = tuple(
+                _json_integer(value)
+                for value in cast(Sequence[object], record["values"])
+            )
+            if (
+                len(values) != external_count
+                or values in helicity_by_values
+                or identifier in helicity_by_values.values()
+            ):
+                raise ArtifactError(
+                    "correlated helicity metadata is incomplete or repeated"
+                )
+            helicity_by_values[values] = identifier
+            if computed is True:
+                computed_helicities.add(identifier)
+            # The caller authenticates generation without source-dependent
+            # zero pruning. A remaining uncomputed structural zero is therefore
+            # intrinsic (e.g. massless-fermion chirality), even for literal
+            # vector replacements. Retain its public selector as a zero state.
+        roots = _records(amplitude.get("roots"), "amplitude roots")
+        root_indices: dict[int, list[int]] = {}
+        outputs: set[int] = set()
+        for root in roots:
+            group_id = _json_integer(root["coherent_group_id"])
+            index = _json_integer(root["output_index"])
+            if index in outputs:
+                raise ArtifactError("correlated amplitude output index is repeated")
+            outputs.add(index)
+            root_indices.setdefault(group_id, []).append(index)
+            if any(
+                _decimal(root.get(key, 1), key) != 1
+                for key in ("helicity_weight", "all_sector_weight")
+            ):
+                raise CompatibilityError(
+                    "correlated reference execution cannot use folded amplitude weights"
+                )
+        if outputs != set(range(len(roots))):
+            raise ArtifactError("correlated amplitude output mapping is incomplete")
+        groups: list[CoherentAmplitudeGroup] = []
+        seen_groups: set[int] = set()
+        physical_groups: dict[tuple[tuple[int, ...], int], CoherentAmplitudeGroup] = {}
+        physical_roots: dict[int, list[int]] = {}
+        descriptors = (
+            amplitude.get("coherent_groups")
+            if coherent_groups is None
+            else coherent_groups
+        )
+        for descriptor in _records(descriptors, "coherent groups"):
+            group_id = _json_integer(descriptor["group_id"])
+            values = tuple(
+                _json_integer(value)
+                for value in cast(Sequence[object], descriptor["helicities"])
+            )
+            if (
+                group_id in seen_groups
+                or group_id not in root_indices
+                or values not in helicity_by_values
+                or helicity_by_values[values] not in computed_helicities
+            ):
+                raise ArtifactError(
+                    "correlated coherent-group mapping is incomplete or repeated"
+                )
+            seen_groups.add(group_id)
+            word = tuple(
+                _json_integer(value)
+                for value in cast(Sequence[object], descriptor["color_word"])
+            )
+            sector = _json_integer(descriptor["color_sector_id"])
+            key = (values, sector)
+            physical = physical_groups.get(key)
+            if physical is None:
+                physical = CoherentAmplitudeGroup(
+                    group_id=group_id,
+                    helicity_id=helicity_by_values[values],
+                    helicities=values,
+                    color_word=word,
+                    color_sector_id=sector,
+                )
+                physical_groups[key] = physical
+                groups.append(physical)
+            elif physical.color_word != word:
+                raise ArtifactError(
+                    "correlated coherent groups disagree on a physical color sector"
+                )
+            # Generation may partition one physical coefficient by basis_key
+            # or root.color_weight. Compiled root outputs already contain those
+            # weights, so combine their complex values without another factor.
+            physical_roots.setdefault(physical.group_id, []).extend(
+                root_indices[group_id]
+            )
+        if (
+            seen_groups != set(root_indices)
+            or {group.helicity_id for group in groups} != computed_helicities
+        ):
+            raise ArtifactError(
+                "correlated coherent groups do not cover "
+                "the retained physical helicities"
+            )
+        color_basis: dict[str, set[tuple[int, tuple[int, ...]]]] = {}
+        for group in groups:
+            basis = color_basis.setdefault(group.helicity_id, set())
+            color = (group.color_sector_id, group.color_word)
+            basis.add(color)
+        if color_basis and any(
+            basis != next(iter(color_basis.values())) for basis in color_basis.values()
+        ):
+            raise ArtifactError(
+                "correlated coherent groups have incomplete helicity/color coverage"
+            )
+        self._coherent_groups = tuple(groups)
+        self._known_helicity_ids = frozenset(helicity_by_values.values())
+        self._coherent_root_indices = {
+            key: tuple(value) for key, value in physical_roots.items()
+        }
+        self._raw_amplitude_count = len(roots)
+        sources = _records(
+            _record(schema.get("source_fill"), "source fill").get("sources"), "sources"
+        )
+        for leg in self._spin_correlated_legs:
+            matching = [source for source in sources if source.get("leg_label") == leg]
+            if not matching:
+                raise ArtifactError(f"spin-correlated leg {leg} has no retained source")
+            for source in matching:
+                ir, _identity, _crossing = _validated_source_ir(source)
+                slot = _record(source.get("value_slot"), "source value slot")
+                if (
+                    ir["wavefunction_family"] != "vector"
+                    or _json_integer(ir["component_dimension"]) != 4
+                    or _json_integer(slot["component_stop"])
+                    - _json_integer(slot["component_start"])
+                    != 4
+                ):
+                    raise CompatibilityError(
+                        "spin correlation requires a full four-component vector source"
+                    )
+
+    def _selected_groups(
+        self, helicities: Sequence[str] | None, active_legs: tuple[int, ...]
+    ) -> tuple[CoherentAmplitudeGroup, ...]:
+        known_helicities = self._known_helicity_ids
+        selected = known_helicities if helicities is None else set(helicities)
+        if not selected <= known_helicities:
+            raise EvaluationError(
+                "unknown correlated helicity selector: "
+                f"{sorted(selected - known_helicities)!r}"
+            )
+        # Keep one placeholder helicity for each replaced leg, consistently
+        # across the color basis. Spectator helicities remain incoherently summed.
+        representatives: dict[tuple[int, ...], tuple[int, ...]] = {}
+        for group in self._coherent_groups:
+            if group.helicity_id in selected:
+                spectator = tuple(
+                    value
+                    for leg, value in enumerate(group.helicities, 1)
+                    if leg not in active_legs
+                )
+                representatives[spectator] = min(
+                    representatives.get(spectator, group.helicities), group.helicities
+                )
+        return tuple(
+            group
+            for group in self._coherent_groups
+            if group.helicity_id in selected
+            and group.helicities
+            == representatives[
+                tuple(
+                    value
+                    for leg, value in enumerate(group.helicities, 1)
+                    if leg not in active_legs
+                )
+            ]
+        )
+
+    def _coherent_values(
+        self,
+        raw: tuple[_ComplexDecimal, ...],
+        groups: tuple[CoherentAmplitudeGroup, ...],
+    ) -> tuple[_ComplexDecimal, ...]:
+        if len(raw) != self._raw_amplitude_count:
+            raise ArtifactError(
+                "correlated evaluator returned the wrong amplitude count"
+            )
+        return tuple(
+            (
+                sum(
+                    (
+                        raw[index][0]
+                        for index in self._coherent_root_indices[group.group_id]
+                    ),
+                    Decimal(0),
+                ),
+                sum(
+                    (
+                        raw[index][1]
+                        for index in self._coherent_root_indices[group.group_id]
+                    ),
+                    Decimal(0),
+                ),
+            )
+            for group in groups
+        )
+
+    def coherent_amplitudes(
+        self,
+        momenta: Momenta,
+        *,
+        spin_vectors: Mapping[int, object] | None = None,
+        precision: int = 40,
+        helicities: Sequence[str] | None = None,
+    ) -> CoherentAmplitudeBatch:
+        if (
+            isinstance(precision, bool)
+            or not isinstance(precision, int)
+            or precision < 1
+        ):
+            raise EvaluationError(
+                "precision must be a positive number of decimal digits"
+            )
+        points = _prepare_points(momenta, self._physics, None)
+        vectors = _prepare_spin_vectors(
+            spin_vectors,
+            allowed_legs=self._spin_correlated_legs,
+            point_count=len(points),
+        )
+        active_legs = tuple(sorted(vectors[0]))
+        groups = self._selected_groups(helicities, active_legs)
+        working_precision = _working_precision(precision)
+        payload = _runtime_state(self._native_runtime)
+        parameters = tuple(
+            _decimal(value, "runtime model parameter")
+            for value in payload["model_parameter_values"]
+        )
+        self._load_evaluators()
+        with localcontext() as context:
+            context.prec = working_precision
+            context.rounding = ROUND_HALF_EVEN
+            parameters = self._derive_model_parameters(parameters, working_precision)
+            schema = _record(self._execution.get("runtime_schema"), "runtime schema")
+            normalization = exact_normalization(
+                self._physics,
+                parameters,
+                working_precision,
+                cast(Any, schema.get("model_parameters", ())),
+                scalar=self._scalar,
+            )
+            result = []
+            for point, overrides in zip(points, vectors, strict=True):
+                raw = self._evaluate_correlated_point(
+                    point, parameters, working_precision, overrides
+                )
+                result.append(self._coherent_values(raw, groups))
+        with localcontext() as context:
+            context.prec = precision
+            context.rounding = ROUND_HALF_EVEN
+            values = tuple(
+                tuple((+real, +imag) for real, imag in point) for point in result
+            )
+            normalization = +normalization
+        return CoherentAmplitudeBatch(
+            values, groups, normalization, precision, active_legs
+        )
+
+    def iter_coherent_amplitudes_many(
+        self,
+        momenta: Momenta,
+        *,
+        spin_vector_sets: Sequence[Mapping[int, object]],
+        precision: int = 40,
+        helicities: Sequence[str] | None = None,
+    ) -> Iterator[tuple[int, int, CoherentAmplitudeBatch]]:
+        """Stream ``(point index, spin-set index, one-point amplitudes)``.
+
+        Common inputs and model parameters are prepared once. A stage retains
+        at most its previous exact input/output for the current point, not an
+        unbounded response tensor or a persistent numerical cache. Decimal
+        contexts never remain active while this iterator yields to its caller.
+        """
+        if type(precision) is not int or precision < 1:
+            raise EvaluationError(
+                "precision must be a positive number of decimal digits"
+            )
+        points = _prepare_points(momenta, self._physics, None)
+        vector_sets = tuple(
+            _prepare_spin_vectors(
+                vectors,
+                allowed_legs=self._spin_correlated_legs,
+                point_count=len(points),
+            )
+            for vectors in spin_vector_sets
+        )
+        active_sets = tuple(tuple(sorted(vectors[0])) for vectors in vector_sets)
+        selected = {
+            legs: self._selected_groups(helicities, legs) for legs in set(active_sets)
+        }
+        working_precision = _working_precision(precision)
+        payload = _runtime_state(self._native_runtime)
+        parameters = tuple(
+            _decimal(value, "runtime model parameter")
+            for value in payload["model_parameter_values"]
+        )
+        self._load_evaluators()
+        with localcontext() as context:
+            context.prec = working_precision
+            context.rounding = ROUND_HALF_EVEN
+            parameters = self._derive_model_parameters(parameters, working_precision)
+            schema = _record(self._execution.get("runtime_schema"), "runtime schema")
+            normalization = exact_normalization(
+                self._physics,
+                parameters,
+                working_precision,
+                cast(Any, schema.get("model_parameters", ())),
+                scalar=self._scalar,
+            )
+        with localcontext() as context:
+            context.prec = precision
+            context.rounding = ROUND_HALF_EVEN
+            normalization = +normalization
+        for point_index, point in enumerate(points):
+            memo: _StageMemo = {}
+            for spin_index, (vectors, legs) in enumerate(
+                zip(vector_sets, active_sets, strict=True)
+            ):
+                groups = selected[legs]
+                with localcontext() as context:
+                    context.prec = working_precision
+                    context.rounding = ROUND_HALF_EVEN
+                    raw = self._evaluate_correlated_point(
+                        point,
+                        parameters,
+                        working_precision,
+                        vectors[point_index],
+                        stage_memo=memo,
+                    )
+                    values = self._coherent_values(raw, groups)
+                with localcontext() as context:
+                    context.prec = precision
+                    context.rounding = ROUND_HALF_EVEN
+                    values = tuple((+real, +imag) for real, imag in values)
+                yield (
+                    point_index,
+                    spin_index,
+                    CoherentAmplitudeBatch(
+                        (values,), groups, normalization, precision, legs
+                    ),
+                )
+
+    def _evaluate_stage(
+        self, evaluator: Any, inputs: tuple[_ComplexDecimal, ...], precision: int
+    ) -> tuple[_ComplexDecimal, ...]:
+        """Evaluate one immutable stage; a narrow hook for diagnostic adapters."""
+        return cast(tuple[_ComplexDecimal, ...], evaluator.evaluate(inputs, precision))
+
+    def _evaluate_stage_cached(
+        self,
+        evaluator: Any,
+        inputs: tuple[_ComplexDecimal, ...],
+        precision: int,
+        memo: _StageMemo | None,
+        stage_index: int,
+    ) -> tuple[_ComplexDecimal, ...]:
+        previous = None if memo is None else memo.get(stage_index)
+        if previous is not None and _identical_stage_inputs(previous[0], inputs):
+            return previous[1]
+        outputs = self._evaluate_stage(evaluator, inputs, precision)
+        if memo is not None:
+            memo[stage_index] = (inputs, outputs)
+        return outputs
+
+    def clear(self) -> None:
+        """Release loaded evaluator states while retaining the source plan."""
+        self._stage_evaluators = None
+        self._amplitude_evaluator = None
+
+    def _evaluate_correlated_point(
+        self,
+        point: tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...],
+        model_parameters: tuple[Decimal, ...],
+        precision: int,
+        spin_vectors: Mapping[int, tuple[_ComplexDecimal, ...]],
+        *,
+        stage_memo: _StageMemo | None = None,
+    ) -> tuple[_ComplexDecimal, ...]:
+        scalar = Decimal if self._scalar is None else self._scalar
+        if scalar is not Decimal:
+            point = tuple(
+                cast(
+                    tuple[Decimal, Decimal, Decimal, Decimal],
+                    tuple(scalar(value) for value in vector),
+                )
+                for vector in point
+            )
+        schema = _record(self._execution.get("runtime_schema"), "runtime schema")
+        layout = _record(schema.get("parameter_layout"), "parameter layout")
+        model_start = _json_integer(layout["value_component_count"]) + _json_integer(
+            layout["momentum_parameter_count"]
+        )
+        state = [
+            _complex_zero()
+            for _ in range(
+                max(
+                    _json_integer(layout["parameter_count_if_flattened"]),
+                    model_start + len(model_parameters),
+                )
+            )
+        ]
+        _fill_correlated_sources(
+            state, point, schema, model_parameters, spin_vectors, scalar=self._scalar
+        )
+        _fill_momenta(state, point, schema)
+        for index, value in enumerate(model_parameters):
+            state[model_start + index] = (value, Decimal(0))
+        compiled = _record(self._execution.get("compiled"), "compiled evaluators")
+        stage_set = _record(compiled.get("stage_evaluators"), "stage evaluators")
+        stages = _records(stage_set.get("stages"), "stage evaluators")
+        assert self._stage_evaluators is not None
+        for stage_index, (stage, evaluator) in enumerate(
+            zip(stages, self._stage_evaluators, strict=True)
+        ):
+            outputs = self._evaluate_stage_cached(
+                evaluator,
+                _pack_stage_inputs(state, stage),
+                precision,
+                stage_memo,
+                stage_index,
+            )
+            _assign_stage_outputs(state, outputs, stage)
+        amplitude = _record(stage_set.get("amplitude_stage"), "amplitude evaluator")
+        assert self._amplitude_evaluator is not None
+        return _canonical_amplitude_outputs(
+            self._evaluate_stage_cached(
+                self._amplitude_evaluator,
+                _pack_stage_inputs(state, amplitude),
+                precision,
+                stage_memo,
+                len(stages),
+            ),
+            amplitude,
+        )
+
+
+class CorrelatedDoubleDoubleExecutor(CorrelatedExactExecutor):
+    """The same retained plan, with explicitly owned DoubleFloat arithmetic."""
+
+    _scalar: type[Decimal]
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        from pyamplicol.runtime._double_double import DoubleDoubleArithmetic
+
+        self._double_double = DoubleDoubleArithmetic()
+        self._scalar = self._double_double.scalar
+        super().__init__(*args, **kwargs)
+
+    def _derive_model_parameters(
+        self,
+        parameters: tuple[Decimal, ...],
+        precision: int,
+        *,
+        arithmetic: str = "arbitrary",
+    ) -> tuple[Decimal, ...]:
+        return tuple(
+            self._scalar(value)
+            for value in super()._derive_model_parameters(
+                tuple(self._scalar(value) for value in parameters),
+                precision,
+                arithmetic="double-double",
+            )
+        )
+
+    def _evaluate_stage(
+        self, evaluator: Any, inputs: tuple[_ComplexDecimal, ...], precision: int
+    ) -> tuple[_ComplexDecimal, ...]:
+        from pyamplicol.runtime.symbolica_exact import _upcast_complex_inputs
+
+        # Bypass the arbitrary-precision policy, not the evaluator itself.
+        # Each retained stage (including chunks) executes at DoubleFloat precision.
+        outputs = evaluator._evaluate_prepared(_upcast_complex_inputs(inputs, 80), 32)
+        return tuple((self._scalar(real), self._scalar(imag)) for real, imag in outputs)
diff --git a/pyamplicol/src/pyamplicol/runtime/correlations.py b/pyamplicol/src/pyamplicol/runtime/correlations.py
new file mode 100644
index 0000000000..01f0b8230f
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/correlations.py
@@ -0,0 +1,542 @@
+# SPDX-License-Identifier: 0BSD
+"""ID-selected direct Born correlations, isolated from ordinary runtime calls."""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from decimal import ROUND_HALF_EVEN, Decimal, localcontext
+from fractions import Fraction
+from pathlib import Path
+from typing import Any, cast
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError, EvaluationError
+from pyamplicol.api.protocols import Momenta
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.artifacts.security import confined_path
+from pyamplicol.color.connections import COLOR_CONNECTION_CONVENTION
+from pyamplicol.correlators import CorrelatedRequest, CorrelatedValue, CorrelatorConfig
+from pyamplicol.runtime._double_double import correlated_precision
+from pyamplicol.runtime._native_selection import native_process_selection
+from pyamplicol.runtime.correlated_exact import (
+    CoherentAmplitudeBatch,
+    CoherentAmplitudeGroup,
+    CorrelatedDoubleDoubleExecutor,
+    CorrelatedExactExecutor,
+    _is_spin_vector,
+    _prepare_spin_vectors,
+)
+from pyamplicol.runtime.symbolica_exact import _complex_mul, _working_precision
+
+
+@dataclass(frozen=True)
+class _MatrixEntry:
+    left: int
+    right: int
+    real: Fraction
+    imag: Fraction
+
+
+@dataclass(frozen=True)
+class _Matrix:
+    id: str
+    sectors: tuple[int, ...]
+    entries: tuple[_MatrixEntry, ...]
+
+
+@dataclass(frozen=True)
+class CorrelatorCatalogue:
+    """Validated selected-process metadata, without an amplitude executor."""
+
+    artifact: Path
+    process_id: str
+    native_runtime: Any
+    declarations: CorrelatorConfig
+    matrices: tuple[_Matrix, ...]
+    coherent_groups: Sequence[Mapping[str, object]]
+    # Exact factor of a process-group member evaluated by its representative.
+    factor: Fraction = Fraction(1)
+
+
+def _exact_integer(value: object) -> int:
+    """Read the writer's integer strings without accepting lossy coercions."""
+    if type(value) is int:
+        return value
+    if isinstance(value, str) and re.fullmatch(r"-?(?:0|[1-9][0-9]*)", value):
+        return int(value)
+    raise ValueError("invalid exact matrix integer")
+
+
+def _matrix(record: object) -> _Matrix:
+    try:
+        if not isinstance(record, Mapping):
+            raise ValueError("matrix is not an object")
+        if (
+            record["convention"] != COLOR_CONNECTION_CONVENTION
+            or record["color_accuracy"] not in {"lc", "nlc", "full"}
+            or record["storage"] != "sparse-directed"
+            or record["includes_color_factor"] is not True
+        ):
+            raise ValueError("unsupported matrix convention")
+        identifier = record["id"]
+        if not isinstance(identifier, str) or not identifier:
+            raise ValueError("missing correlation ID")
+        sectors = tuple(record["sector_ids"])
+        if (
+            not sectors
+            or any(type(item) is not int or item < 0 for item in sectors)
+            or len(set(sectors)) != len(sectors)
+        ):
+            raise ValueError("invalid colour sector IDs")
+        entries = []
+        pairs: set[tuple[int, int]] = set()
+        for item in record["entries"]:
+            left, right = item["left_sector_id"], item["right_sector_id"]
+            if (
+                type(left) is not int
+                or type(right) is not int
+                or left not in sectors
+                or right not in sectors
+                or (left, right) in pairs
+            ):
+                raise ValueError("invalid or repeated matrix entry")
+            pairs.add((left, right))
+            real, imag = item["weight"]["real"], item["weight"]["imag"]
+            if any(
+                isinstance(parts, (str, bytes))
+                or not isinstance(parts, Sequence)
+                or len(parts) != 2
+                for parts in (real, imag)
+            ):
+                raise ValueError("invalid exact matrix coefficient")
+            entries.append(
+                _MatrixEntry(
+                    left,
+                    right,
+                    Fraction(_exact_integer(real[0]), _exact_integer(real[1])),
+                    Fraction(_exact_integer(imag[0]), _exact_integer(imag[1])),
+                )
+            )
+        return _Matrix(identifier, sectors, tuple(entries))
+    except (KeyError, TypeError, ValueError, ZeroDivisionError) as exc:
+        raise ArtifactError(f"invalid correlated colour matrix: {exc}") from exc
+
+
+@dataclass(frozen=True)
+class _ContractionPlan:
+    group_count: int
+    terms: tuple[tuple[int, int, tuple[Decimal, Decimal]], ...]
+
+    def evaluate(
+        self, batch: CoherentAmplitudeBatch, *, precision: int
+    ) -> tuple[CorrelatedValue, ...]:
+        results = []
+        with localcontext() as context:
+            context.prec = _working_precision(precision)
+            context.rounding = ROUND_HALF_EVEN
+            for point in batch.values:
+                if len(point) != self.group_count:
+                    raise ArtifactError(
+                        "correlated amplitude point has an invalid group count"
+                    )
+                scalar = type(batch.normalization_factor)
+                real, imag = scalar(0), scalar(0)
+                for left, right, weight in self.terms:
+                    a, b = point[left], point[right]
+                    # Keep the single-ID multiplication/accumulation order.
+                    term = _complex_mul(_complex_mul((a[0], -a[1]), weight), b)
+                    real += term[0]
+                    imag += term[1]
+                results.append(
+                    (
+                        real * batch.normalization_factor,
+                        imag * batch.normalization_factor,
+                    )
+                )
+        with localcontext() as context:
+            context.prec = precision
+            context.rounding = ROUND_HALF_EVEN
+            return tuple(
+                CorrelatedValue(+Decimal(real), +Decimal(imag))
+                for real, imag in results
+            )
+
+
+def _prepare_contraction(
+    amplitude_groups: tuple[CoherentAmplitudeGroup, ...],
+    matrix: _Matrix,
+    *,
+    precision: int,
+    scalar: type[Decimal] = Decimal,
+) -> _ContractionPlan:
+    """Prepare exact weights and indices once, without numerical amplitude state."""
+    groups: dict[str, dict[int, int]] = {}
+    for index, group in enumerate(amplitude_groups):
+        sectors = groups.setdefault(group.helicity_id, {})
+        if group.color_sector_id in sectors:
+            raise ArtifactError("repeated coherent helicity/colour group")
+        sectors[group.color_sector_id] = index
+    expected = set(matrix.sectors)
+    if any(set(indices) != expected for indices in groups.values()):
+        raise ArtifactError("correlated amplitudes do not cover the colour matrix")
+    with localcontext() as context:
+        context.prec = _working_precision(precision)
+        context.rounding = ROUND_HALF_EVEN
+        entries = tuple(
+            (
+                entry.left,
+                entry.right,
+                (
+                    scalar(entry.real.numerator) / scalar(entry.real.denominator),
+                    scalar(entry.imag.numerator) / scalar(entry.imag.denominator),
+                ),
+            )
+            for entry in matrix.entries
+        )
+    return _ContractionPlan(
+        len(amplitude_groups),
+        tuple(
+            (indices[left], indices[right], weight)
+            for indices in groups.values()
+            for left, right, weight in entries
+        ),
+    )
+
+
+def _contract(
+    batch: CoherentAmplitudeBatch, matrix: _Matrix, *, precision: int
+) -> tuple[CorrelatedValue, ...]:
+    """Sum spectator helicities incoherently, but retain all colour phases."""
+    return _prepare_contraction(
+        batch.groups,
+        matrix,
+        precision=precision,
+        scalar=type(batch.normalization_factor),
+    ).evaluate(batch, precision=precision)
+
+
+def load_correlator_catalogue(backend: Any) -> CorrelatorCatalogue:
+    """Read and validate the correlation sidecar once for a runtime selection."""
+    artifact = getattr(backend, "_artifact_path", None)
+    native = getattr(backend, "_runtime", None)
+    if not isinstance(artifact, Path) or native is None:
+        raise CompatibilityError("this runtime does not support Born correlations")
+    manifest = load_manifest(artifact)
+    extension = manifest.extensions.get("correlators")
+    if not isinstance(extension, Mapping):
+        raise CompatibilityError(
+            "correlations must be declared at generation with CorrelatorConfig"
+        )
+    try:
+        if (
+            type(extension["schema_version"]) is not int
+            or extension["schema_version"] != 1
+        ):
+            raise ValueError("unsupported correlator schema version")
+        path = extension["path"]
+        if not isinstance(path, str):
+            raise ValueError("missing correlator catalogue path")
+        payload = json.loads(confined_path(artifact, path).read_text())
+        if (
+            type(payload["schema_version"]) is not int
+            or payload["schema_version"] != 1
+            or payload["complete_source_basis"] is not True
+        ):
+            raise ValueError("correlations require a complete source basis")
+        selection = native_process_selection(native, manifest.processes)
+        identity = selection.external_permutation == tuple(
+            range(len(selection.external_permutation))
+        )
+        relation = selection.process_group
+        if relation is not None and (relation.conjugated or not identity):
+            raise CompatibilityError(
+                "correlated evaluation of process-group member "
+                f"{relation.member_process_id!r} through its representative "
+                f"{relation.representative_process_key!r} is available only for "
+                "an identity leg order without charge conjugation; generate the "
+                "process explicitly"
+            )
+        if not identity:
+            raise CompatibilityError(
+                "correlated catalogues and evaluation do not support "
+                "non-identity process aliases"
+            )
+        process_id = selection.representative_process_id
+        process = payload["processes"][process_id]
+        declarations = CorrelatorConfig.from_json_dict(process["declarations"])
+        requests = declarations.color_requests
+        if (
+            any(type(leg) is not int for leg in process["spin_legs"])
+            or tuple(process["spin_legs"]) != declarations.spin_legs
+        ):
+            raise ValueError("inconsistent declared spin legs")
+        matrices = tuple(_matrix(item) for item in process["matrices"])
+        identifiers = {matrix.id for matrix in matrices}
+        if len(identifiers) != len(matrices) or identifiers != {
+            request.id for request in requests
+        }:
+            raise ValueError("inconsistent colour correlation IDs")
+        coherent_groups = cast(
+            Sequence[Mapping[str, object]], process["coherent_groups"]
+        )
+    except (KeyError, TypeError, ValueError, OSError) as exc:
+        raise ArtifactError(f"invalid correlator catalogue: {exc}") from exc
+    return CorrelatorCatalogue(
+        artifact,
+        process_id,
+        native,
+        declarations,
+        matrices,
+        coherent_groups,
+        Fraction(1) if relation is None else relation.factor,
+    )
+
+
+class CorrelatorEvaluator:
+    """Small stateful facade; source vectors belong only to this runtime."""
+
+    def __init__(
+        self, backend: Any, *, catalogue: CorrelatorCatalogue | None = None
+    ) -> None:
+        if catalogue is None:
+            catalogue = load_correlator_catalogue(backend)
+        self._matrices = {matrix.id: matrix for matrix in catalogue.matrices}
+        self._catalogue = catalogue
+        self._double_double_executor: CorrelatedDoubleDoubleExecutor | None = None
+        self._declarations = catalogue.declarations
+        self._vectors: dict[int, object] = {}
+        self._executor = CorrelatedExactExecutor(
+            catalogue.artifact,
+            catalogue.process_id,
+            catalogue.native_runtime,
+            spin_correlated_legs=catalogue.declarations.spin_legs,
+            coherent_groups=catalogue.coherent_groups,
+        )
+
+    def _select_executor(self, arithmetic: str) -> CorrelatedExactExecutor:
+        if arithmetic != "double-double":
+            return self._executor
+        if self._double_double_executor is None:
+            catalogue = self._catalogue
+            self._double_double_executor = CorrelatedDoubleDoubleExecutor(
+                catalogue.artifact,
+                catalogue.process_id,
+                catalogue.native_runtime,
+                spin_correlated_legs=catalogue.declarations.spin_legs,
+                coherent_groups=catalogue.coherent_groups,
+            )
+        return self._double_double_executor
+
+    def set_spin_correlation_vectors(
+        self, vectors: Mapping[int, object] | None
+    ) -> None:
+        self._vectors = self._copy_spin_vectors(vectors)
+
+    def _copy_spin_vectors(
+        self, vectors: Mapping[int, object] | None
+    ) -> dict[int, object]:
+        if vectors is None:
+            vectors = {}
+        if not isinstance(vectors, Mapping):
+            raise EvaluationError("spin vectors must map public leg labels to vectors")
+        legs = tuple(vectors)
+        if any(type(leg) is not int for leg in legs):
+            raise EvaluationError("spin-vector legs must be positive integer labels")
+        if legs and tuple(sorted(legs)) not in self._declarations.spin_correlations:
+            raise EvaluationError("this joint spin-correlation class was not declared")
+        frozen: dict[int, object] = {}
+
+        def freeze(value: object) -> object:
+            if isinstance(value, Sequence) and not isinstance(value, str | bytes):
+                return tuple(freeze(item) for item in value)
+            return value
+
+        for leg, value in vectors.items():
+            if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+                raise EvaluationError("spin vectors must be four-vectors or a batch")
+            vector = tuple(freeze(item) for item in value)
+            if not vector:
+                raise EvaluationError(
+                    "a spin-vector batch must contain at least one point"
+                )
+            broadcast = _is_spin_vector(vector)
+            # Validate before replacing the old state; a failed setter is atomic.
+            _prepare_spin_vectors(
+                {leg: vector},
+                allowed_legs=self._declarations.spin_legs,
+                point_count=1 if broadcast else len(vector),
+            )
+            frozen[leg] = vector
+        return frozen
+
+    def clear(self) -> None:
+        """Release warmed evaluators, preserving current numerical spin inputs."""
+        self._executor.clear()
+        if self._double_double_executor is not None:
+            self._double_double_executor.clear()
+
+    def evaluate(
+        self,
+        momenta: Momenta,
+        *,
+        color_correlation: str = "born",
+        helicities: Sequence[str] | None = None,
+        precision: int = 16,
+        arithmetic: str = "arbitrary",
+    ) -> tuple[CorrelatedValue, ...]:
+        if (
+            isinstance(precision, bool)
+            or not isinstance(precision, int)
+            or precision < 1
+        ):
+            raise EvaluationError(
+                "precision must be a positive number of decimal digits"
+            )
+        if (
+            not isinstance(color_correlation, str)
+            or color_correlation not in self._matrices
+        ):
+            raise EvaluationError(
+                f"unknown colour correlation ID {color_correlation!r}"
+            )
+        amplitude_precision = correlated_precision(precision, arithmetic)
+        batch = self._select_executor(arithmetic).coherent_amplitudes(
+            momenta,
+            spin_vectors=self._vectors,
+            helicities=helicities,
+            precision=amplitude_precision,
+        )
+        return self._scaled(
+            _contract(batch, self._matrices[color_correlation], precision=precision),
+            precision,
+        )
+
+    def _scaled(
+        self, values: tuple[CorrelatedValue, ...], precision: int
+    ) -> tuple[CorrelatedValue, ...]:
+        """Apply a process-group member's exact factor with one rounding."""
+
+        factor = self._catalogue.factor
+        if factor == 1:
+            return values
+        with localcontext() as context:
+            context.rounding = ROUND_HALF_EVEN
+            scaled = []
+            for value in values:
+                parts = []
+                for part in (value.real, value.imag):
+                    context.prec = max(precision, len(part.as_tuple().digits)) + len(
+                        str(factor.numerator)
+                    )
+                    product = part * factor.numerator
+                    context.prec = precision
+                    parts.append(product / factor.denominator)
+                scaled.append(CorrelatedValue(parts[0], parts[1]))
+        return tuple(scaled)
+
+    def evaluate_many(
+        self,
+        momenta: Momenta,
+        requests: Mapping[str, CorrelatedRequest],
+        *,
+        helicities: Sequence[str] | None = None,
+        precision: int = 16,
+        arithmetic: str = "arbitrary",
+    ) -> dict[str, tuple[CorrelatedValue, ...]]:
+        """Share amplitudes and exact unchanged stages within one labelled batch."""
+        if type(precision) is not int or precision < 1:
+            raise EvaluationError(
+                "precision must be a positive number of decimal digits"
+            )
+        amplitude_precision = correlated_precision(precision, arithmetic)
+        if not isinstance(requests, Mapping):
+            raise EvaluationError(
+                "correlated requests must map labels to CorrelatedRequest"
+            )
+        snapshot = dict(self._vectors)
+        assignments: list[dict[int, object]] = []
+        assignment_ids: dict[tuple[object, ...], int] = {}
+        routes: list[tuple[str, str, int]] = []
+        for label, request in requests.items():
+            if not isinstance(label, str) or not label:
+                raise EvaluationError(
+                    "correlated request labels must be nonempty strings"
+                )
+            if not isinstance(request, CorrelatedRequest):
+                raise EvaluationError(
+                    "correlated requests must contain CorrelatedRequest records"
+                )
+            identifier = request.color_correlation
+            if identifier not in self._matrices:
+                raise EvaluationError(f"unknown colour correlation ID {identifier!r}")
+            vectors = self._copy_spin_vectors(
+                snapshot if request.spin_vectors is None else request.spin_vectors
+            )
+            prepared = _prepare_spin_vectors(
+                vectors,
+                allowed_legs=self._declarations.spin_legs,
+                point_count=len(momenta),
+            )
+            # Normalize broadcast/per-point shapes, without a float conversion.
+            # Decimal tuples conservatively preserve signed zero and precision.
+            key: tuple[object, ...] = tuple(
+                tuple(
+                    (
+                        leg,
+                        tuple(
+                            (real.as_tuple(), imag.as_tuple()) for real, imag in wave
+                        ),
+                    )
+                    for leg, wave in sorted(point.items())
+                )
+                for point in prepared
+            )
+            if key not in assignment_ids:
+                assignment_ids[key] = len(assignments)
+                assignments.append(vectors)
+            routes.append((label, identifier, assignment_ids[key]))
+        if not routes:
+            return {}
+        by_assignment: dict[int, dict[str, list[str]]] = {}
+        for label, identifier, assignment in routes:
+            by_assignment.setdefault(assignment, {}).setdefault(identifier, []).append(
+                label
+            )
+        results: dict[str, list[CorrelatedValue]] = {
+            label: [] for label, _, _ in routes
+        }
+        plans: dict[tuple[int, str], _ContractionPlan] = {}
+        for (
+            point_index,
+            assignment,
+            batch,
+        ) in self._select_executor(arithmetic).iter_coherent_amplitudes_many(
+            momenta,
+            spin_vector_sets=assignments,
+            helicities=helicities,
+            precision=amplitude_precision,
+        ):
+            for identifier, labels in by_assignment[assignment].items():
+                plan_key = (assignment, identifier)
+                if plan_key not in plans:
+                    plans[plan_key] = _prepare_contraction(
+                        batch.groups,
+                        self._matrices[identifier],
+                        precision=precision,
+                        scalar=type(batch.normalization_factor),
+                    )
+                value = plans[plan_key].evaluate(batch, precision=precision)[0]
+                for label in labels:
+                    if len(results[label]) != point_index:
+                        raise ArtifactError(
+                            "correlated batch returned inconsistent point ordering"
+                        )
+                    results[label].append(value)
+        if any(len(values) != len(momenta) for values in results.values()):
+            raise ArtifactError("correlated batch did not cover all requested points")
+        return {
+            label: self._scaled(tuple(values), precision)
+            for label, values in results.items()
+        }
diff --git a/pyamplicol/src/pyamplicol/runtime/eager_exact/__init__.py b/pyamplicol/src/pyamplicol/runtime/eager_exact/__init__.py
new file mode 100644
index 0000000000..69a0f46f13
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/eager_exact/__init__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact Python replay of prepared-model eager DAG execution plans."""
+
+from pyamplicol.runtime.eager_exact._executor import EagerExactExecutor
+
+__all__ = ["EagerExactExecutor"]
diff --git a/pyamplicol/src/pyamplicol/runtime/eager_exact/_contracts.py b/pyamplicol/src/pyamplicol/runtime/eager_exact/_contracts.py
new file mode 100644
index 0000000000..b39c42f549
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/eager_exact/_contracts.py
@@ -0,0 +1,539 @@
+# SPDX-License-Identifier: 0BSD
+"""Private eager-plan contracts and exact-kernel loading utilities."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, field
+from decimal import Decimal
+from pathlib import Path, PurePosixPath
+from typing import Protocol, TypeVar, cast
+
+from pyamplicol._internal.versions import (
+    EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY,
+    PROCESS_ARTIFACT_SCHEMA_VERSION,
+)
+from pyamplicol.api.errors import ArtifactError, CompatibilityError, EvaluationError
+from pyamplicol.artifacts.manifest import ArtifactManifest, PayloadRecord
+from pyamplicol.artifacts.security import confined_path, normalize_relative_path
+from pyamplicol.generation.eager_tables import (
+    EAGER_PLAN_ABI,
+    EAGER_RUNTIME_CAPABILITY,
+    EagerAttachmentRow,
+    EagerClosureRow,
+    EagerCouplingRow,
+    EagerFinalizationRow,
+    EagerInvocationRow,
+    unpack_rows,
+)
+from pyamplicol.models.prepared import PreparedKernelRecord
+from pyamplicol.runtime._evaluator_payloads import ExactEvaluatorPayloadResolver
+from pyamplicol.runtime.symbolica_exact import (
+    _ComplexDecimal,
+    _decimal,
+    _ExactEvaluator,
+    _ExactExpressionEvaluator,
+)
+
+_ZERO = Decimal(0)
+_EAGER_RUNTIME_KIND = "pyamplicol-runtime-eager-execution"
+_SUPPORTED_PREPARED_BACKENDS = frozenset(("jit", "asm", "cpp"))
+_PREPARED_CATALOG_ABI = "pyamplicol-prepared-kernel-catalog-v1"
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactCouplingRow:
+    real_parameter_id: int
+    imag_parameter_id: int
+    constant: _ComplexDecimal
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactInvocationRow:
+    kernel_id: int
+    left_value_slot_id: int
+    right_value_slot_id: int
+    left_momentum_slot_id: int
+    right_momentum_slot_id: int
+    coupling_slot_id: int
+    output_factor_source: int
+    attachment_start: int
+    attachment_count: int
+    selector_domain_id: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactComplexProduct:
+    numerators: tuple[_ComplexDecimal, ...]
+    denominator: _ComplexDecimal | None = None
+
+
+_ExactFactor = _ComplexDecimal | _ExactComplexProduct
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactAttachmentRow:
+    result_current_id: int
+    factor: _ExactFactor
+    selector_domain_id: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactFinalizationRow:
+    kernel_id: int
+    current_id: int
+    unpropagated_value_slot_id: int
+    propagated_value_slot_id: int
+    momentum_slot_id: int
+    unpropagated_selector_domain_id: int | None = None
+    propagated_selector_domain_id: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactClosureRow:
+    kernel_id: int
+    left_value_slot_id: int
+    right_value_slot_id: int
+    amplitude_index: int
+    coupling_slot_id: int
+    output_factor_source: int
+    factor: _ExactFactor
+    direct_coefficients: tuple[_ComplexDecimal, ...] | None
+    coherent_group_id: int | None = None
+    selector_domain_id: int | None = None
+
+
+class _KernelEvaluator(Protocol):
+    input_len: int
+
+    def evaluate(
+        self,
+        values: Sequence[_ComplexDecimal],
+        precision: int,
+    ) -> Sequence[_ComplexDecimal]: ...
+
+
+_KernelCallable = Callable[[Sequence[_ComplexDecimal], int], Sequence[_ComplexDecimal]]
+_KernelLoader = Callable[
+    [PreparedKernelRecord, Path], _KernelEvaluator | _KernelCallable
+]
+
+
+def _complex_zero() -> _ComplexDecimal:
+    return (_ZERO, _ZERO)
+
+
+def _complex_add(left: _ComplexDecimal, right: _ComplexDecimal) -> _ComplexDecimal:
+    return left[0] + right[0], left[1] + right[1]
+
+
+def _complex_mul(left: _ComplexDecimal, right: _ComplexDecimal) -> _ComplexDecimal:
+    return (
+        left[0] * right[0] - left[1] * right[1],
+        left[0] * right[1] + left[1] * right[0],
+    )
+
+
+def _complex_div(left: _ComplexDecimal, right: _ComplexDecimal) -> _ComplexDecimal:
+    denominator = right[0] * right[0] + right[1] * right[1]
+    if denominator == _ZERO:
+        raise ArtifactError("exact eager factor has a zero denominator")
+    return (
+        (left[0] * right[0] + left[1] * right[1]) / denominator,
+        (left[1] * right[0] - left[0] * right[1]) / denominator,
+    )
+
+
+def _resolve_exact_factor(factor: _ExactFactor) -> _ComplexDecimal:
+    if not isinstance(factor, _ExactComplexProduct):
+        return factor
+    result = (Decimal(1), _ZERO)
+    for numerator in factor.numerators:
+        result = _complex_mul(result, numerator)
+    if factor.denominator is not None:
+        result = _complex_div(result, factor.denominator)
+    return result
+
+
+def _complex_pair(real: object, imaginary: object, context: str) -> _ComplexDecimal:
+    return _decimal(real, f"{context} real part"), _decimal(
+        imaginary, f"{context} imaginary part"
+    )
+
+
+def _mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise ArtifactError(f"{context} must be an object")
+    return value
+
+
+def _sequence(value: object, context: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} must be an array")
+    return value
+
+
+def _integer(value: object, context: str, *, minimum: int = 0) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < minimum:
+        raise ArtifactError(f"{context} must be an integer >= {minimum}")
+    return value
+
+
+def _read_json(path: Path, context: str) -> Mapping[str, object]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ArtifactError(f"could not load {context}: {exc}") from exc
+    return _mapping(value, context)
+
+
+def _joined_payload_path(prefix: str, member: str) -> str:
+    normalized_prefix = normalize_relative_path(prefix)
+    normalized_member = normalize_relative_path(member)
+    return normalize_relative_path(
+        (PurePosixPath(normalized_prefix) / normalized_member).as_posix()
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class _PayloadIndex:
+    records: Mapping[str, PayloadRecord]
+
+    @classmethod
+    def from_manifest(cls, manifest: ArtifactManifest) -> _PayloadIndex:
+        return cls({record.path: record for record in manifest.payloads})
+
+    def require(
+        self,
+        path: str,
+        *,
+        role: str,
+        process_id: str | None,
+    ) -> PayloadRecord:
+        normalized = normalize_relative_path(path)
+        record = self.records.get(normalized)
+        if record is None:
+            raise ArtifactError(
+                f"eager metadata references undeclared payload {normalized}"
+            )
+        if record.role != role or record.process_id != process_id:
+            raise ArtifactError(
+                f"eager payload {normalized} has role/process "
+                f"{record.role!r}/{record.process_id!r}, expected "
+                f"{role!r}/{process_id!r}"
+            )
+        return record
+
+
+@dataclass(frozen=True, slots=True)
+class _ComponentSlot:
+    slot_id: int
+    start: int
+    stop: int
+
+    @property
+    def width(self) -> int:
+        return self.stop - self.start
+
+    def read(self, values: Sequence[_ComplexDecimal]) -> tuple[_ComplexDecimal, ...]:
+        if self.stop > len(values):
+            raise ArtifactError(f"eager slot {self.slot_id} is outside its storage")
+        return tuple(values[self.start : self.stop])
+
+    def write(
+        self,
+        values: list[_ComplexDecimal],
+        entries: Sequence[_ComplexDecimal],
+        context: str,
+    ) -> None:
+        if len(entries) != self.width or self.stop > len(values):
+            raise EvaluationError(
+                f"{context} produced {len(entries)} components, expected {self.width}"
+            )
+        values[self.start : self.stop] = entries
+
+
+def _component_slots(
+    records: object,
+    *,
+    id_field: str,
+    start_field: str,
+    stop_field: str,
+    dimension_field: str | None,
+    component_count: int,
+    context: str,
+) -> tuple[_ComponentSlot, ...]:
+    parsed: list[_ComponentSlot] = []
+    for index, raw in enumerate(_sequence(records, context)):
+        record = _mapping(raw, f"{context}[{index}]")
+        slot_id = _integer(record.get(id_field), f"{context}[{index}].{id_field}")
+        start = _integer(record.get(start_field), f"{context}[{index}].{start_field}")
+        stop = _integer(record.get(stop_field), f"{context}[{index}].{stop_field}")
+        if stop <= start:
+            raise ArtifactError(f"{context}[{index}] has an empty/inverted range")
+        if dimension_field is not None:
+            dimension = _integer(
+                record.get(dimension_field),
+                f"{context}[{index}].{dimension_field}",
+                minimum=1,
+            )
+            if stop - start != dimension:
+                raise ArtifactError(f"{context}[{index}] has inconsistent dimension")
+        parsed.append(_ComponentSlot(slot_id, start, stop))
+    parsed.sort(key=lambda slot: slot.slot_id)
+    cursor = 0
+    for expected_id, slot in enumerate(parsed):
+        if slot.slot_id != expected_id:
+            raise ArtifactError(f"{context} IDs must be contiguous from zero")
+        if slot.start != cursor:
+            raise ArtifactError(f"{context} component ranges must be contiguous")
+        cursor = slot.stop
+    if cursor != component_count:
+        raise ArtifactError(
+            f"{context} spans {cursor} components, expected {component_count}"
+        )
+    return tuple(parsed)
+
+
+@dataclass(slots=True)
+class _CallableEvaluator:
+    input_len: int
+    function: _KernelCallable
+
+    def evaluate(
+        self,
+        values: Sequence[_ComplexDecimal],
+        precision: int,
+    ) -> Sequence[_ComplexDecimal]:
+        return self.function(values, precision)
+
+
+def _default_kernel_loader(
+    record: PreparedKernelRecord,
+    payload_root: Path,
+) -> _KernelEvaluator:
+    if record.contract_kind == "model-parameter":
+        return _ExactExpressionEvaluator(
+            record.exact_expressions,
+            tuple(str(item["symbol"]) for item in record.input_contracts),
+        )
+    return _ExactEvaluator.load(
+        {
+            "evaluator_state_path": record.exact_evaluator_state_path,
+            "input_len": record.input_arity,
+        },
+        payload_root,
+    )
+
+
+def _artifact_kernel_loader(
+    resolver: ExactEvaluatorPayloadResolver,
+    payload_root_name: str,
+) -> _KernelLoader:
+    def load(
+        record: PreparedKernelRecord,
+        payload_root: Path,
+    ) -> _KernelEvaluator:
+        if record.contract_kind == "model-parameter":
+            return _ExactExpressionEvaluator(
+                record.exact_expressions,
+                tuple(str(item["symbol"]) for item in record.input_contracts),
+            )
+        return _ExactEvaluator.load(
+            {
+                "evaluator_state_path": record.exact_evaluator_state_path,
+                "input_len": record.input_arity,
+            },
+            payload_root,
+            state_loader=lambda relative: resolver.read_exact_state(
+                _joined_payload_path(payload_root_name, relative),
+                process_id=None,
+            ),
+        )
+
+    return load
+
+
+@dataclass(slots=True)
+class _LazyExactKernel:
+    record: PreparedKernelRecord
+    payload_root: Path
+    loader: _KernelLoader
+    _evaluator: _KernelEvaluator | None = field(default=None, init=False, repr=False)
+
+    def evaluate(
+        self,
+        values: Sequence[_ComplexDecimal],
+        precision: int,
+    ) -> tuple[_ComplexDecimal, ...]:
+        if len(values) != self.record.input_arity:
+            raise EvaluationError(
+                f"eager kernel {self.record.kernel_id} received {len(values)} "
+                f"inputs, expected {self.record.input_arity}"
+            )
+        evaluator = self._load()
+        try:
+            raw_outputs = evaluator.evaluate(values, precision)
+        except (ArtifactError, CompatibilityError, EvaluationError):
+            raise
+        except Exception as exc:
+            raise EvaluationError(
+                f"exact eager kernel {self.record.kernel_id} failed: {exc}"
+            ) from exc
+        if isinstance(raw_outputs, (str, bytes, bytearray)) or not isinstance(
+            raw_outputs, Sequence
+        ):
+            raise EvaluationError(
+                f"eager kernel {self.record.kernel_id} returned a non-array result"
+            )
+        outputs_list = []
+        for output_index, value in enumerate(raw_outputs):
+            if (
+                isinstance(value, (str, bytes, bytearray))
+                or not isinstance(value, Sequence)
+                or len(value) != 2
+            ):
+                raise EvaluationError(
+                    f"eager kernel {self.record.kernel_id} output {output_index} "
+                    "is not a complex pair"
+                )
+            outputs_list.append(
+                _complex_pair(
+                    value[0],
+                    value[1],
+                    f"kernel {self.record.kernel_id} output {output_index}",
+                )
+            )
+        outputs = tuple(outputs_list)
+        if len(outputs) != self.record.output_arity:
+            raise EvaluationError(
+                f"eager kernel {self.record.kernel_id} produced {len(outputs)} "
+                f"outputs, expected {self.record.output_arity}"
+            )
+        return outputs
+
+    def _load(self) -> _KernelEvaluator:
+        if self._evaluator is not None:
+            return self._evaluator
+        loaded = self.loader(self.record, self.payload_root)
+        if callable(loaded) and not hasattr(loaded, "evaluate"):
+            loaded = _CallableEvaluator(self.record.input_arity, loaded)
+        if not hasattr(loaded, "evaluate") or not hasattr(loaded, "input_len"):
+            raise ArtifactError(
+                "exact eager kernel loader returned an invalid evaluator for "
+                f"kernel {self.record.kernel_id}"
+            )
+        evaluator = cast(_KernelEvaluator, loaded)
+        if (
+            isinstance(evaluator.input_len, bool)
+            or evaluator.input_len != self.record.input_arity
+        ):
+            raise ArtifactError(
+                f"exact evaluator for eager kernel {self.record.kernel_id} has input "
+                f"arity {evaluator.input_len}, expected {self.record.input_arity}"
+            )
+        self._evaluator = evaluator
+        return evaluator
+
+
+_RowT = TypeVar(
+    "_RowT",
+    EagerInvocationRow,
+    EagerAttachmentRow,
+    EagerCouplingRow,
+    EagerFinalizationRow,
+    EagerClosureRow,
+)
+
+
+def _load_table(
+    process_root: Path,
+    process_prefix: str,
+    record: Mapping[str, object],
+    row_type: type[_RowT],
+    payloads: _PayloadIndex,
+    process_id: str,
+    context: str,
+) -> tuple[_RowT, ...]:
+    raw_path = record.get("path")
+    if not isinstance(raw_path, str):
+        raise ArtifactError(f"{context} path must be a string")
+    path = normalize_relative_path(raw_path)
+    count = _integer(record.get("count"), f"{context} count")
+    row_size = _integer(record.get("row_size"), f"{context} row size", minimum=1)
+    expected_size = row_type._STRUCT.size
+    if row_size != expected_size:
+        raise ArtifactError(
+            f"{context} row size is {row_size}, expected {expected_size}"
+        )
+    global_path = _joined_payload_path(process_prefix, path)
+    payloads.require(global_path, role="evaluator-state", process_id=process_id)
+    table_path = confined_path(process_root, path)
+    try:
+        content = table_path.read_bytes()
+    except OSError as exc:
+        raise ArtifactError(f"could not read {context}: {exc}") from exc
+    if len(content) != count * expected_size:
+        raise ArtifactError(
+            f"{context} declares {count} rows but contains {len(content)} bytes"
+        )
+    try:
+        return unpack_rows(content, row_type)
+    except (TypeError, ValueError) as exc:
+        raise ArtifactError(f"could not decode {context}: {exc}") from exc
+
+
+def _direct_coefficients(
+    root: Mapping[str, object], index: int
+) -> tuple[_ComplexDecimal, ...]:
+    contraction = _mapping(
+        root.get("contraction_ir"), f"amplitude root {index} contraction_ir"
+    )
+    coefficients = []
+    for coefficient_index, raw in enumerate(
+        _sequence(
+            contraction.get("coefficients"),
+            f"amplitude root {index} contraction coefficients",
+        )
+    ):
+        pair = _sequence(raw, f"direct coefficient {coefficient_index}")
+        if len(pair) != 2:
+            raise ArtifactError("direct contraction coefficient must be complex pair")
+        coefficients.append(
+            _complex_pair(pair[0], pair[1], "direct contraction coefficient")
+        )
+    if not coefficients:
+        raise ArtifactError("direct eager closure has no contraction coefficients")
+    return tuple(coefficients)
+
+
+def _validate_execution_header(execution: Mapping[str, object]) -> None:
+    if execution.get("schema_version") != PROCESS_ARTIFACT_SCHEMA_VERSION:
+        raise CompatibilityError(
+            f"unsupported eager process schema {execution.get('schema_version')!r}"
+        )
+    if execution.get("kind") != _EAGER_RUNTIME_KIND:
+        raise CompatibilityError(
+            f"unsupported exact eager execution kind {execution.get('kind')!r}"
+        )
+    if execution.get("eager_plan_abi") != EAGER_PLAN_ABI:
+        raise CompatibilityError(
+            f"unsupported eager plan ABI {execution.get('eager_plan_abi')!r}"
+        )
+    plan = _mapping(execution.get("plan"), "plan")
+    if (
+        plan.get("kind") != _EAGER_RUNTIME_KIND
+        or plan.get("eager_plan_abi") != EAGER_PLAN_ABI
+    ):
+        raise CompatibilityError("outer and inner eager plan contracts do not match")
+    if plan.get("process_key") != execution.get("key"):
+        raise ArtifactError("eager plan process key does not match execution key")
+    expected_capabilities = [EAGER_RUNTIME_CAPABILITY]
+    if execution.get("lc_topology_replay") is not None:
+        expected_capabilities.append(EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY)
+    expected_capabilities.sort()
+    if execution.get("required_runtime_capabilities") != expected_capabilities:
+        raise CompatibilityError("unsupported eager runtime capability contract")
+    if plan.get("required_runtime_capabilities") != expected_capabilities:
+        raise CompatibilityError("unsupported eager plan capability contract")
diff --git a/pyamplicol/src/pyamplicol/runtime/eager_exact/_execution.py b/pyamplicol/src/pyamplicol/runtime/eager_exact/_execution.py
new file mode 100644
index 0000000000..0872d97166
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/eager_exact/_execution.py
@@ -0,0 +1,315 @@
+# SPDX-License-Identifier: 0BSD
+"""Correctness-oriented exact execution of a validated eager DAG plan."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from decimal import Decimal
+from typing import cast
+
+from pyamplicol.api.errors import ArtifactError
+from pyamplicol.generation.eager_tables import (
+    EAGER_OUTPUT_FACTOR_COUPLING_IMAG,
+    EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+    EAGER_OUTPUT_FACTOR_NONE,
+    MISSING_U32,
+)
+from pyamplicol.models.prepared import PreparedKernelRecord
+from pyamplicol.runtime.eager_exact._contracts import (
+    _ZERO,
+    _complex_add,
+    _complex_mul,
+    _complex_zero,
+    _resolve_exact_factor,
+)
+from pyamplicol.runtime.eager_exact._plan import _EagerExactPlan
+from pyamplicol.runtime.symbolica_exact import (
+    _ComplexDecimal,
+    _fill_momenta,
+    _fill_sources,
+)
+
+
+def _evaluate_point(
+    plan: _EagerExactPlan,
+    point: tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...],
+    model_parameters: tuple[Decimal, ...],
+    prepared_parameters: tuple[_ComplexDecimal, ...],
+    precision: int,
+) -> tuple[_ComplexDecimal, ...]:
+    if len(model_parameters) != plan.parameter_count:
+        raise ArtifactError(
+            f"eager runtime has {len(model_parameters)} model parameters, "
+            f"expected {plan.parameter_count}"
+        )
+    couplings = _resolve_couplings(plan, model_parameters)
+    amplitudes = [_complex_zero() for _ in range(plan.amplitude_count)]
+    selector_groups: tuple[int | None, ...] = (
+        (None,) if plan.selector_group_ids is None else tuple(plan.selector_group_ids)
+    )
+    for selector_group_id in selector_groups:
+        _evaluate_selector_group(
+            plan,
+            point,
+            model_parameters,
+            prepared_parameters,
+            couplings,
+            precision,
+            selector_group_id,
+            amplitudes,
+        )
+    return tuple(amplitudes)
+
+
+def _evaluate_selector_group(
+    plan: _EagerExactPlan,
+    point: tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...],
+    model_parameters: tuple[Decimal, ...],
+    prepared_parameters: tuple[_ComplexDecimal, ...],
+    couplings: tuple[_ComplexDecimal, ...],
+    precision: int,
+    selector_group_id: int | None,
+    amplitudes: list[_ComplexDecimal],
+) -> None:
+    flattened = [
+        _complex_zero()
+        for _ in range(plan.value_component_count + plan.momentum_component_count)
+    ]
+    _fill_sources(flattened, point, plan.runtime_schema, model_parameters)
+    _fill_momenta(flattened, point, plan.runtime_schema)
+    values = flattened[: plan.value_component_count]
+    momenta = flattened[plan.value_component_count :]
+    currents = [_complex_zero() for _ in range(plan.current_component_count)]
+    for stage in plan.stages:
+        for invocation in stage.invocations:
+            if not _selector_domain_active(
+                plan,
+                invocation.selector_domain_id,
+                selector_group_id,
+            ):
+                continue
+            start = invocation.attachment_start
+            stop = start + invocation.attachment_count
+            active_attachments = tuple(
+                attachment
+                for attachment in stage.attachments[start:stop]
+                if _selector_domain_active(
+                    plan,
+                    attachment.selector_domain_id,
+                    selector_group_id,
+                )
+            )
+            if not active_attachments:
+                continue
+            kernel = plan.kernels[invocation.kernel_id]
+            inputs = _gather_inputs(
+                kernel.record,
+                first_current=plan.value_slots[invocation.left_value_slot_id].read(
+                    values
+                ),
+                second_current=plan.value_slots[invocation.right_value_slot_id].read(
+                    values
+                ),
+                first_momentum=plan.momentum_slots[
+                    invocation.left_momentum_slot_id
+                ].read(momenta),
+                second_momentum=plan.momentum_slots[
+                    invocation.right_momentum_slot_id
+                ].read(momenta),
+                coupling=couplings[invocation.coupling_slot_id],
+                prepared_parameters=prepared_parameters,
+            )
+            outputs = kernel.evaluate(inputs, precision)
+            output_factor = _resolved_output_factor(
+                invocation.output_factor_source,
+                couplings[invocation.coupling_slot_id],
+            )
+            for attachment in active_attachments:
+                target = plan.current_slots[attachment.result_current_id]
+                factor = _complex_mul(
+                    _resolve_exact_factor(attachment.factor), output_factor
+                )
+                accumulated = target.read(currents)
+                target.write(
+                    currents,
+                    tuple(
+                        _complex_add(current, _complex_mul(factor, output))
+                        for current, output in zip(accumulated, outputs, strict=True)
+                    ),
+                    "eager attachment",
+                )
+
+        for finalization in stage.finalizations:
+            current_slot = plan.current_slots[finalization.current_id]
+            current = current_slot.read(currents)
+            if (
+                finalization.unpropagated_value_slot_id != MISSING_U32
+                and _selector_domain_active(
+                    plan,
+                    finalization.unpropagated_selector_domain_id,
+                    selector_group_id,
+                )
+            ):
+                plan.value_slots[finalization.unpropagated_value_slot_id].write(
+                    values, current, "unpropagated current finalization"
+                )
+            if finalization.kernel_id == MISSING_U32 or not _selector_domain_active(
+                plan,
+                finalization.propagated_selector_domain_id,
+                selector_group_id,
+            ):
+                continue
+            kernel = plan.kernels[finalization.kernel_id]
+            inputs = _gather_inputs(
+                kernel.record,
+                first_current=current,
+                second_current=(),
+                first_momentum=plan.momentum_slots[finalization.momentum_slot_id].read(
+                    momenta
+                ),
+                second_momentum=(),
+                coupling=None,
+                prepared_parameters=prepared_parameters,
+            )
+            outputs = kernel.evaluate(inputs, precision)
+            plan.value_slots[finalization.propagated_value_slot_id].write(
+                values, outputs, "propagated current finalization"
+            )
+
+    for closure in plan.closures:
+        if selector_group_id is not None and (
+            closure.coherent_group_id != selector_group_id
+            or not _selector_domain_active(
+                plan,
+                closure.selector_domain_id,
+                selector_group_id,
+            )
+        ):
+            continue
+        left = plan.value_slots[closure.left_value_slot_id].read(values)
+        right = plan.value_slots[closure.right_value_slot_id].read(values)
+        if closure.kernel_id == MISSING_U32:
+            coefficients = closure.direct_coefficients
+            if coefficients is None:
+                raise ArtifactError(
+                    "direct eager closure has no exact contraction coefficients"
+                )
+            output = _complex_zero()
+            for coefficient, left_value, right_value in zip(
+                coefficients, left, right, strict=True
+            ):
+                output = _complex_add(
+                    output,
+                    _complex_mul(coefficient, _complex_mul(left_value, right_value)),
+                )
+        else:
+            kernel = plan.kernels[closure.kernel_id]
+            inputs = _gather_inputs(
+                kernel.record,
+                first_current=left,
+                second_current=right,
+                first_momentum=(),
+                second_momentum=(),
+                coupling=couplings[closure.coupling_slot_id],
+                prepared_parameters=prepared_parameters,
+            )
+            output = kernel.evaluate(inputs, precision)[0]
+        factor = _resolve_exact_factor(closure.factor)
+        if closure.kernel_id != MISSING_U32:
+            factor = _complex_mul(
+                factor,
+                _resolved_output_factor(
+                    closure.output_factor_source,
+                    couplings[closure.coupling_slot_id],
+                ),
+            )
+        amplitude_id = closure.amplitude_index
+        amplitudes[amplitude_id] = _complex_add(
+            amplitudes[amplitude_id], _complex_mul(factor, output)
+        )
+
+
+def _selector_domain_active(
+    plan: _EagerExactPlan,
+    domain_id: int | None,
+    selector_group_id: int | None,
+) -> bool:
+    if plan.selector_domains is None:
+        return True
+    if domain_id is None or selector_group_id is None:
+        raise ArtifactError("compact eager exact execution lacks a selector domain")
+    return selector_group_id in plan.selector_domains[domain_id]
+
+
+def _resolved_output_factor(
+    source: int,
+    coupling: _ComplexDecimal,
+) -> _ComplexDecimal:
+    if source == EAGER_OUTPUT_FACTOR_NONE:
+        return Decimal(1), Decimal(0)
+    if source == EAGER_OUTPUT_FACTOR_COUPLING_REAL:
+        return coupling[0], Decimal(0)
+    if source == EAGER_OUTPUT_FACTOR_COUPLING_IMAG:
+        return coupling[1], Decimal(0)
+    raise ArtifactError(f"unsupported eager output factor source {source}")
+
+
+def _resolve_couplings(
+    plan: _EagerExactPlan,
+    parameters: Sequence[Decimal],
+) -> tuple[_ComplexDecimal, ...]:
+    result = []
+    for row in plan.couplings:
+        real = (
+            row.constant[0]
+            if row.real_parameter_id == MISSING_U32
+            else parameters[row.real_parameter_id]
+        )
+        imaginary = (
+            row.constant[1]
+            if row.imag_parameter_id == MISSING_U32
+            else parameters[row.imag_parameter_id]
+        )
+        result.append((real, imaginary))
+    return tuple(result)
+
+
+def _gather_inputs(
+    record: PreparedKernelRecord,
+    *,
+    first_current: Sequence[_ComplexDecimal],
+    second_current: Sequence[_ComplexDecimal],
+    first_momentum: Sequence[_ComplexDecimal],
+    second_momentum: Sequence[_ComplexDecimal],
+    coupling: _ComplexDecimal | None,
+    prepared_parameters: Sequence[_ComplexDecimal],
+) -> tuple[_ComplexDecimal, ...]:
+    inputs = []
+    for contract in record.input_contracts:
+        role = str(contract["role"])
+        component = int(cast(int, contract["component"]))
+        if role == "left-current":
+            value = first_current[component]
+        elif role == "right-current":
+            value = second_current[component]
+        elif role == "current":
+            value = first_current[component]
+        elif role == "left-momentum":
+            value = first_momentum[component]
+        elif role == "right-momentum":
+            value = second_momentum[component]
+        elif role == "momentum":
+            value = first_momentum[component]
+        elif role == "coupling-real":
+            if coupling is None:
+                raise ArtifactError("eager kernel requires an unavailable coupling")
+            value = (coupling[0], _ZERO)
+        elif role == "coupling-imag":
+            if coupling is None:
+                raise ArtifactError("eager kernel requires an unavailable coupling")
+            value = (coupling[1], _ZERO)
+        else:
+            parameter_id = cast(int, contract["model_parameter_index"])
+            value = prepared_parameters[parameter_id]
+        inputs.append(value)
+    return tuple(inputs)
diff --git a/pyamplicol/src/pyamplicol/runtime/eager_exact/_executor.py b/pyamplicol/src/pyamplicol/runtime/eager_exact/_executor.py
new file mode 100644
index 0000000000..b7a0b58119
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/eager_exact/_executor.py
@@ -0,0 +1,279 @@
+# SPDX-License-Identifier: 0BSD
+"""Public facade for exact replay of a prepared eager process artifact."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from decimal import ROUND_HALF_EVEN, Decimal, localcontext
+from pathlib import Path
+from typing import Any, cast
+
+from pyamplicol.api.errors import ArtifactError, EvaluationError
+from pyamplicol.api.protocols import Momenta
+from pyamplicol.api.results import ResolvedEvaluation
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.artifacts.security import confined_path
+from pyamplicol.runtime._color_topology_exact import (
+    apply_exact_color_replay_input_mapping,
+    parse_exact_color_topology_replay,
+    reduce_exact_color_topology_replay,
+)
+from pyamplicol.runtime._evaluator_payloads import ExactEvaluatorPayloadResolver
+from pyamplicol.runtime._native_selection import (
+    native_physics_axes,
+    native_process_selection,
+    remap_reduction_group,
+)
+from pyamplicol.runtime._normalization_exact import exact_normalization
+from pyamplicol.runtime.eager_exact._contracts import (
+    _KernelLoader,
+    _mapping,
+    _PayloadIndex,
+    _read_json,
+)
+from pyamplicol.runtime.eager_exact._execution import _evaluate_point
+from pyamplicol.runtime.eager_exact._plan import _EagerExactPlan
+from pyamplicol.runtime.eager_exact._plan_v3 import _NativeExactSectionsLoader
+from pyamplicol.runtime.symbolica_exact import (
+    _apply_lc_replay_input_mapping,
+    _apply_lc_replay_resolved,
+    _decimal,
+    _diagnostic_project_onshell_points,
+    _diagnostic_schema_mass_bindings,
+    _lc_replay_plan,
+    _prepare_points,
+    _reduce_resolved,
+    _runtime_state,
+    _working_precision,
+)
+
+
+class EagerExactExecutor:
+    """Replay one schema-v3 eager process through retained exact kernel states."""
+
+    def __init__(
+        self,
+        artifact: Path,
+        process_id: str,
+        native_runtime: Any,
+        *,
+        kernel_loader: _KernelLoader | None = None,
+        native_sections_loader: _NativeExactSectionsLoader | None = None,
+    ) -> None:
+        self._artifact = Path(artifact).expanduser().resolve(strict=True)
+        self._native_runtime = native_runtime
+        manifest = load_manifest(self._artifact)
+        exact_payloads = ExactEvaluatorPayloadResolver(manifest)
+        selection = native_process_selection(native_runtime, manifest.processes)
+        process = selection.process
+        permutation = selection.external_permutation
+        representative_id = selection.representative_process_id
+        execution_records = tuple(
+            record
+            for record in manifest.payloads
+            if record.role == "evaluator-manifest"
+            and record.process_id == representative_id
+        )
+        if len(execution_records) != 1:
+            raise ArtifactError(
+                f"process {representative_id!r} must declare one eager "
+                "execution manifest"
+            )
+        physics_path = process.get("physics_path")
+        if not isinstance(physics_path, str):
+            raise ArtifactError(f"process {representative_id!r} has no physics path")
+        payloads = _PayloadIndex.from_manifest(manifest)
+        payloads.require(
+            physics_path, role="runtime-physics", process_id=representative_id
+        )
+        execution = _read_json(
+            confined_path(self._artifact, execution_records[0].path),
+            "eager execution metadata",
+        )
+        representative_physics = _read_json(
+            confined_path(self._artifact, physics_path), "runtime physics metadata"
+        )
+        axes = native_physics_axes(native_runtime, representative_physics)
+        physics = axes.public_physics
+        if execution.get("key") != selection.representative_process_key:
+            raise ArtifactError(
+                "eager exact execution disagrees with Rusticol's representative "
+                "process key"
+            )
+        process_root = self._artifact / "processes" / representative_id
+        self._execution = execution
+        self._permutation = permutation
+        self._representative_physics = representative_physics
+        self._plan = _EagerExactPlan.load_for_execution(
+            artifact_root=self._artifact,
+            process_root=process_root,
+            process_id=representative_id,
+            execution=execution,
+            manifest=manifest,
+            kernel_loader=kernel_loader,
+            exact_payloads=exact_payloads,
+            native_sections_loader=native_sections_loader,
+        )
+        if self._plan.physics_reduction_groups is not None:
+            physics = dict(physics)
+            reduction = dict(_mapping(physics.get("reduction"), "physics reduction"))
+            reduction["groups"] = [
+                remap_reduction_group(group, axes, index=index)
+                for index, group in enumerate(self._plan.physics_reduction_groups)
+            ]
+            physics["reduction"] = reduction
+        self._physics = physics
+        if "runtime_schema" in execution:
+            exact_execution = execution
+        else:
+            exact_execution = {
+                "runtime_schema": self._plan.runtime_schema,
+                "lc_topology_replay": self._plan.runtime_schema.get(
+                    "lc_topology_replay"
+                ),
+            }
+        self._exact_execution = exact_execution
+        self._lc_replay = _lc_replay_plan(exact_execution, physics, permutation)
+        self._color_replay = parse_exact_color_topology_replay(
+            exact_execution, physics, permutation
+        )
+        if self._lc_replay is not None and self._color_replay is not None:
+            raise ArtifactError(
+                "eager exact execution cannot combine LC and full-colour replay"
+            )
+
+    def _diagnostic_project_onshell(
+        self,
+        momenta: Momenta,
+        *,
+        precision: int,
+    ) -> tuple[
+        tuple[tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...], ...],
+        dict[str, object],
+    ]:
+        """Build diagnostic-only on-shell kinematics from current parameters."""
+
+        state = _runtime_state(self._native_runtime)
+        parameters = tuple(
+            _decimal(value, "runtime model parameter")
+            for value in state["model_parameter_values"]
+        )
+        schema = self._exact_execution.get("runtime_schema")
+        if not isinstance(schema, Mapping):
+            raise ArtifactError("eager execution has no runtime schema")
+        bindings = _diagnostic_schema_mass_bindings(schema, self._physics, parameters)
+        return _diagnostic_project_onshell_points(
+            momenta,
+            physics=self._physics,
+            artifact_mass_bindings=bindings,
+            # Both public physics and its PDG-derived bindings already follow
+            # the caller's selected ordering.
+            permutation=None,
+            precision=precision,
+        )
+
+    def evaluate_resolved(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None,
+        color_flows: Sequence[str] | None,
+        precision: int,
+    ) -> ResolvedEvaluation:
+        if (
+            isinstance(precision, bool)
+            or not isinstance(precision, int)
+            or precision < 1
+        ):
+            raise EvaluationError(
+                "precision must be a positive integer number of decimal digits"
+            )
+        working_precision = _working_precision(precision)
+        points = _prepare_points(momenta, self._physics, self._permutation)
+        state = _runtime_state(self._native_runtime)
+        parameters = tuple(
+            _decimal(value, "runtime model parameter")
+            for value in state["model_parameter_values"]
+        )
+        with localcontext() as context:
+            context.prec = working_precision
+            context.rounding = ROUND_HALF_EVEN
+            if self._color_replay is not None:
+                self._color_replay = parse_exact_color_topology_replay(
+                    self._exact_execution, self._physics, self._permutation
+                )
+            normalization = exact_normalization(
+                self._physics,
+                parameters,
+                working_precision,
+                cast(Any, self._plan.runtime_schema["model_parameters"]),
+            )
+            exact_parameters = self._plan.resolve_model_parameters(
+                parameters,
+                working_precision,
+            )
+            if self._lc_replay is not None:
+                evaluation_points = tuple(
+                    _apply_lc_replay_input_mapping(point, entry.input_mapping)
+                    for entry in self._lc_replay.entries
+                    for point in points
+                )
+            elif self._color_replay is not None:
+                evaluation_points = tuple(
+                    apply_exact_color_replay_input_mapping(point, mapping.input_mapping)
+                    for mapping in self._color_replay.mappings
+                    for point in points
+                )
+            else:
+                evaluation_points = points
+            amplitudes = tuple(
+                _evaluate_point(
+                    self._plan,
+                    point,
+                    exact_parameters.runtime,
+                    exact_parameters.prepared,
+                    working_precision,
+                )
+                for point in evaluation_points
+            )
+            if self._color_replay is not None:
+                values, helicity_ids, color_ids = reduce_exact_color_topology_replay(
+                    amplitudes,
+                    self._color_replay,
+                    len(points),
+                    normalization,
+                    helicities,
+                    color_flows,
+                )
+            else:
+                values, helicity_ids, color_ids = _reduce_resolved(
+                    amplitudes,
+                    self._exact_execution,
+                    self._physics,
+                    normalization,
+                    helicities if self._lc_replay is None else None,
+                    color_flows if self._lc_replay is None else None,
+                )
+            if self._lc_replay is not None:
+                values, helicity_ids, color_ids = _apply_lc_replay_resolved(
+                    values,
+                    self._lc_replay,
+                    len(points),
+                    helicity_ids,
+                    color_ids,
+                    helicities,
+                    color_flows,
+                )
+        with localcontext() as context:
+            context.prec = precision
+            context.rounding = ROUND_HALF_EVEN
+            values = tuple(
+                tuple(tuple(+entry for entry in colors) for colors in helicity_values)
+                for helicity_values in values
+            )
+        return ResolvedEvaluation(
+            values=values,
+            helicity_ids=helicity_ids,
+            color_ids=color_ids,
+            color_accuracy=cast(Any, str(self._physics["color_accuracy"])),
+        )
diff --git a/pyamplicol/src/pyamplicol/runtime/eager_exact/_plan.py b/pyamplicol/src/pyamplicol/runtime/eager_exact/_plan.py
new file mode 100644
index 0000000000..853fe79a80
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/eager_exact/_plan.py
@@ -0,0 +1,1496 @@
+# SPDX-License-Identifier: 0BSD
+"""Validated in-memory representation of an eager exact-execution plan."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from decimal import Decimal
+from pathlib import Path
+from typing import cast
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError, EvaluationError
+from pyamplicol.artifacts.manifest import ArtifactManifest
+from pyamplicol.artifacts.security import confined_path, normalize_relative_path
+from pyamplicol.generation.eager_tables import (
+    EAGER_KERNEL_ABI,
+    EAGER_OUTPUT_FACTOR_NONE,
+    MISSING_U32,
+    EagerAttachmentRow,
+    EagerClosureRow,
+    EagerCouplingRow,
+    EagerFinalizationRow,
+    EagerInvocationRow,
+)
+from pyamplicol.models.prepared import (
+    PreparedKernelPack,
+    PreparedKernelRecord,
+    PreparedModelBundleError,
+)
+from pyamplicol.runtime._evaluator_payloads import ExactEvaluatorPayloadResolver
+from pyamplicol.runtime.eager_exact._contracts import (
+    _PREPARED_CATALOG_ABI,
+    _SUPPORTED_PREPARED_BACKENDS,
+    _artifact_kernel_loader,
+    _complex_pair,
+    _component_slots,
+    _ComponentSlot,
+    _direct_coefficients,
+    _ExactAttachmentRow,
+    _ExactClosureRow,
+    _ExactCouplingRow,
+    _ExactFinalizationRow,
+    _ExactInvocationRow,
+    _integer,
+    _joined_payload_path,
+    _KernelLoader,
+    _LazyExactKernel,
+    _load_table,
+    _mapping,
+    _PayloadIndex,
+    _read_json,
+    _sequence,
+    _validate_execution_header,
+)
+from pyamplicol.runtime.eager_exact._plan_v3 import (
+    EAGER_PLAN_V3_ABI,
+    _load_eager_exact_sections_v1,
+    _NativeExactSectionsLoader,
+    _validate_plan_v3_execution_header,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactStage:
+    stage_index: int
+    invocations: tuple[_ExactInvocationRow, ...]
+    attachments: tuple[_ExactAttachmentRow, ...]
+    finalizations: tuple[_ExactFinalizationRow, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _RuntimeParameterSlots:
+    real: int
+    imaginary: int | None
+    kind: str
+
+
+@dataclass(frozen=True, slots=True)
+class _PreparedParameterProjectionEntry:
+    name: str
+    prepared_index: int
+    runtime_real_index: int
+    runtime_imaginary_index: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class _PreparedParameterProjection:
+    parameter_count: int
+    runtime_parameter_count: int
+    entries: tuple[_PreparedParameterProjectionEntry, ...]
+
+    def project(
+        self, runtime_parameters: Sequence[Decimal]
+    ) -> tuple[tuple[Decimal, Decimal], ...]:
+        if len(runtime_parameters) != self.runtime_parameter_count:
+            raise ArtifactError(
+                f"eager runtime has {len(runtime_parameters)} model parameters, "
+                f"expected {self.runtime_parameter_count}"
+            )
+        zero = Decimal(0)
+        result = [(zero, zero) for _ in range(self.parameter_count)]
+        for entry in self.entries:
+            imaginary = (
+                runtime_parameters[entry.runtime_imaginary_index]
+                if entry.runtime_imaginary_index is not None
+                else zero
+            )
+            result[entry.prepared_index] = (
+                runtime_parameters[entry.runtime_real_index],
+                imaginary,
+            )
+        return tuple(result)
+
+    def entry(self, name: str) -> _PreparedParameterProjectionEntry | None:
+        return next((entry for entry in self.entries if entry.name == name), None)
+
+
+@dataclass(frozen=True, slots=True)
+class _DerivedParameterTarget:
+    name: str
+    prepared_index: int | None
+    runtime_real_index: int
+    runtime_imaginary_index: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactModelParameterState:
+    runtime: tuple[Decimal, ...]
+    prepared: tuple[tuple[Decimal, Decimal], ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactParameterDerivation:
+    kernel: _LazyExactKernel
+    input_parameter_indices: tuple[int, ...]
+    targets: tuple[_DerivedParameterTarget | None, ...]
+
+    def evaluate(
+        self,
+        runtime_parameters: Sequence[Decimal],
+        prepared_parameters: Sequence[tuple[Decimal, Decimal]],
+        precision: int,
+    ) -> _ExactModelParameterState:
+        inputs = tuple(
+            prepared_parameters[index] for index in self.input_parameter_indices
+        )
+        outputs = self.kernel.evaluate(inputs, precision)
+        if len(outputs) != len(self.targets):
+            raise ArtifactError(
+                "exact model-parameter output count does not match its layout"
+            )
+        runtime = list(runtime_parameters)
+        prepared = list(prepared_parameters)
+        zero = Decimal(0)
+        for output, target in zip(outputs, self.targets, strict=True):
+            if target is None:
+                continue
+            if target.prepared_index is not None:
+                prepared[target.prepared_index] = output
+            runtime[target.runtime_real_index] = output[0]
+            if target.runtime_imaginary_index is not None:
+                runtime[target.runtime_imaginary_index] = output[1]
+            elif output[1] != zero:
+                raise EvaluationError(
+                    f"exact derived scalar parameter {target.name!r} has a "
+                    "nonzero imaginary component"
+                )
+        return _ExactModelParameterState(tuple(runtime), tuple(prepared))
+
+
+@dataclass(slots=True)
+class _EagerExactPlan:
+    runtime_schema: Mapping[str, object]
+    physics_reduction_groups: tuple[Mapping[str, object], ...] | None
+    selector_group_ids: tuple[int, ...] | None
+    selector_domains: tuple[frozenset[int], ...] | None
+    kernels: Mapping[int, _LazyExactKernel]
+    value_slots: tuple[_ComponentSlot, ...]
+    momentum_slots: tuple[_ComponentSlot, ...]
+    current_slots: tuple[_ComponentSlot, ...]
+    value_component_count: int
+    momentum_component_count: int
+    current_component_count: int
+    parameter_count: int
+    parameter_projection: _PreparedParameterProjection
+    parameter_derivation: _ExactParameterDerivation | None
+    amplitude_count: int
+    couplings: tuple[_ExactCouplingRow, ...]
+    stages: tuple[_ExactStage, ...]
+    closures: tuple[_ExactClosureRow, ...]
+
+    @classmethod
+    def load_for_execution(
+        cls,
+        *,
+        artifact_root: Path,
+        process_root: Path,
+        process_id: str,
+        execution: Mapping[str, object],
+        manifest: ArtifactManifest,
+        kernel_loader: _KernelLoader | None,
+        exact_payloads: ExactEvaluatorPayloadResolver,
+        native_sections_loader: _NativeExactSectionsLoader | None = None,
+    ) -> _EagerExactPlan:
+        if execution.get("eager_plan_abi") == EAGER_PLAN_V3_ABI:
+            return cls.load_v3(
+                artifact_root=artifact_root,
+                process_id=process_id,
+                execution=execution,
+                manifest=manifest,
+                kernel_loader=kernel_loader,
+                exact_payloads=exact_payloads,
+                native_sections_loader=native_sections_loader,
+            )
+        del process_root
+        raise CompatibilityError(
+            "eager exact execution requires a compact plan-v3 artifact; "
+            f"found eager plan ABI {execution.get('eager_plan_abi')!r}. "
+            "Regenerate the artifact with the current `pyamplicol generate`."
+        )
+
+    @classmethod
+    def load_v3(
+        cls,
+        *,
+        artifact_root: Path,
+        process_id: str,
+        execution: Mapping[str, object],
+        manifest: ArtifactManifest,
+        kernel_loader: _KernelLoader | None,
+        exact_payloads: ExactEvaluatorPayloadResolver,
+        native_sections_loader: _NativeExactSectionsLoader | None,
+    ) -> _EagerExactPlan:
+        _validate_plan_v3_execution_header(execution)
+        sections = _load_eager_exact_sections_v1(
+            artifact_root,
+            process_id,
+            loader=native_sections_loader,
+        )
+        (
+            pack,
+            payload_root,
+            effective_kernel_loader,
+        ) = _load_exact_kernel_pack(
+            artifact_root=artifact_root,
+            execution=execution,
+            manifest=manifest,
+            kernel_loader=kernel_loader,
+            exact_payloads=exact_payloads,
+        )
+        return cls._from_exact_sections(
+            runtime_schema=sections.exact_schema,
+            physics_reduction_groups=sections.reduction_groups,
+            selector_group_ids=sections.selector_group_ids,
+            selector_domains=sections.selector_domains,
+            pack=pack,
+            payload_root=payload_root,
+            kernel_loader=effective_kernel_loader,
+            couplings=sections.couplings,
+            stages=tuple(
+                _ExactStage(
+                    stage.stage_index,
+                    stage.invocations,
+                    stage.attachments,
+                    stage.finalizations,
+                )
+                for stage in sections.stages
+            ),
+            closures=sections.closures,
+        )
+
+    @classmethod
+    def _from_exact_sections(
+        cls,
+        *,
+        runtime_schema: Mapping[str, object],
+        physics_reduction_groups: tuple[Mapping[str, object], ...] | None,
+        selector_group_ids: tuple[int, ...] | None,
+        selector_domains: tuple[frozenset[int], ...] | None,
+        pack: PreparedKernelPack,
+        payload_root: Path,
+        kernel_loader: _KernelLoader,
+        couplings: tuple[_ExactCouplingRow, ...],
+        stages: tuple[_ExactStage, ...],
+        closures: tuple[_ExactClosureRow, ...],
+    ) -> _EagerExactPlan:
+        layout = _mapping(runtime_schema.get("parameter_layout"), "parameter_layout")
+        value_count = _integer(
+            layout.get("value_component_count"), "value_component_count"
+        )
+        momentum_count = _integer(
+            layout.get("momentum_parameter_count"), "momentum_parameter_count"
+        )
+        parameter_count = _integer(
+            layout.get("model_parameter_count"), "model_parameter_count"
+        )
+        current_storage = _mapping(
+            runtime_schema.get("current_storage"), "current_storage"
+        )
+        value_storage = _mapping(runtime_schema.get("value_storage"), "value_storage")
+        current_count = _integer(
+            current_storage.get("component_count"), "current component count"
+        )
+        values = _component_slots(
+            value_storage.get("value_slots"),
+            id_field="value_slot_id",
+            start_field="component_start",
+            stop_field="component_stop",
+            dimension_field="dimension",
+            component_count=value_count,
+            context="value slots",
+        )
+        momenta = _component_slots(
+            runtime_schema.get("momentum_slots"),
+            id_field="momentum_slot_id",
+            start_field="component_start",
+            stop_field="component_stop",
+            dimension_field=None,
+            component_count=momentum_count,
+            context="momentum slots",
+        )
+        currents = _component_slots(
+            current_storage.get("current_slots"),
+            id_field="current_id",
+            start_field="component_start",
+            stop_field="component_stop",
+            dimension_field="dimension",
+            component_count=current_count,
+            context="current slots",
+        )
+        active_kernel_ids = _active_process_kernel_ids(stages, closures)
+        include_parameter_kernel = _runtime_has_derived_parameters(runtime_schema)
+        process_kernels = _process_prepared_kernels(
+            pack.kernels,
+            active_kernel_ids,
+            include_parameter_kernel=include_parameter_kernel,
+        )
+        kernels = {
+            kernel.kernel_id: _LazyExactKernel(kernel, payload_root, kernel_loader)
+            for kernel in process_kernels
+            if kernel.contract_kind != "model-parameter"
+        }
+        parameter_projection = _prepared_parameter_projection(
+            pack.kernels,
+            runtime_schema,
+            parameter_count,
+            active_kernel_ids=active_kernel_ids,
+            include_parameter_kernel=include_parameter_kernel,
+        )
+        parameter_derivation = _exact_parameter_derivation(
+            process_kernels,
+            runtime_schema,
+            parameter_projection,
+            payload_root,
+            kernel_loader,
+        )
+        amplitude_stage = _mapping(
+            runtime_schema.get("amplitude_stage"), "amplitude_stage"
+        )
+        amplitude_count = _integer(
+            amplitude_stage.get("output_count"),
+            "amplitude output count",
+            minimum=1,
+        )
+        result = cls(
+            runtime_schema=runtime_schema,
+            physics_reduction_groups=physics_reduction_groups,
+            selector_group_ids=selector_group_ids,
+            selector_domains=selector_domains,
+            kernels=kernels,
+            value_slots=values,
+            momentum_slots=momenta,
+            current_slots=currents,
+            value_component_count=value_count,
+            momentum_component_count=momentum_count,
+            current_component_count=current_count,
+            parameter_count=parameter_count,
+            parameter_projection=parameter_projection,
+            parameter_derivation=parameter_derivation,
+            amplitude_count=amplitude_count,
+            couplings=couplings,
+            stages=stages,
+            closures=closures,
+        )
+        result._validate()
+        return result
+
+    @classmethod
+    def load(
+        cls,
+        *,
+        artifact_root: Path,
+        process_root: Path,
+        process_id: str,
+        execution: Mapping[str, object],
+        manifest: ArtifactManifest,
+        kernel_loader: _KernelLoader | None,
+        exact_payloads: ExactEvaluatorPayloadResolver,
+    ) -> _EagerExactPlan:
+        _validate_execution_header(execution)
+        payloads = _PayloadIndex.from_manifest(manifest)
+        kernel_reference = _mapping(execution.get("kernel_pack"), "kernel_pack")
+        pack_path = cast(str, kernel_reference.get("manifest_path"))
+        if not isinstance(pack_path, str):
+            raise ArtifactError("kernel_pack.manifest_path must be a string")
+        payload_root_name = kernel_reference.get("payload_root")
+        if not isinstance(payload_root_name, str):
+            raise ArtifactError("kernel_pack.payload_root must be a string")
+        pack_path = normalize_relative_path(pack_path)
+        payload_root_name = normalize_relative_path(payload_root_name)
+        payloads.require(pack_path, role="evaluator-manifest", process_id=None)
+        pack_payload = _read_json(
+            confined_path(artifact_root, pack_path), "eager kernel pack"
+        )
+        raw_backend = pack_payload.get("backend")
+        if raw_backend not in _SUPPORTED_PREPARED_BACKENDS:
+            raise CompatibilityError(
+                f"unsupported prepared eager backend {raw_backend!r}"
+            )
+        mutable_pack = dict(pack_payload)
+        kernel_abi = mutable_pack.pop("eager_kernel_abi", None)
+        if kernel_abi != EAGER_KERNEL_ABI:
+            raise CompatibilityError(f"unsupported eager kernel ABI {kernel_abi!r}")
+        try:
+            pack = PreparedKernelPack.from_dict(mutable_pack)
+        except PreparedModelBundleError as exc:
+            raise ArtifactError(f"eager kernel pack is malformed: {exc}") from exc
+        if pack.resolver_manifest.get("abi") != _PREPARED_CATALOG_ABI:
+            raise CompatibilityError("unsupported prepared eager kernel catalog ABI")
+        payload_root = artifact_root / payload_root_name
+        if payload_root.exists() and (
+            not payload_root.is_dir() or payload_root.is_symlink()
+        ):
+            raise ArtifactError("eager kernel payload root is invalid")
+        for kernel in pack.kernels:
+            exact_path = _joined_payload_path(
+                payload_root_name, kernel.exact_evaluator_state_path
+            )
+            exact_payloads.require_exact_state(exact_path, process_id=None)
+
+        effective_kernel_loader = kernel_loader or _artifact_kernel_loader(
+            exact_payloads,
+            payload_root_name,
+        )
+
+        runtime_schema = _mapping(execution.get("runtime_schema"), "runtime_schema")
+        layout = _mapping(runtime_schema.get("parameter_layout"), "parameter_layout")
+        value_count = _integer(
+            layout.get("value_component_count"), "value_component_count"
+        )
+        momentum_count = _integer(
+            layout.get("momentum_parameter_count"), "momentum_parameter_count"
+        )
+        parameter_count = _integer(
+            layout.get("model_parameter_count"), "model_parameter_count"
+        )
+        current_storage = _mapping(
+            runtime_schema.get("current_storage"), "current_storage"
+        )
+        value_storage = _mapping(runtime_schema.get("value_storage"), "value_storage")
+        current_count = _integer(
+            current_storage.get("component_count"), "current component_count"
+        )
+        values = _component_slots(
+            value_storage.get("value_slots"),
+            id_field="value_slot_id",
+            start_field="component_start",
+            stop_field="component_stop",
+            dimension_field="dimension",
+            component_count=value_count,
+            context="value slots",
+        )
+        momenta = _component_slots(
+            runtime_schema.get("momentum_slots"),
+            id_field="momentum_slot_id",
+            start_field="component_start",
+            stop_field="component_stop",
+            dimension_field=None,
+            component_count=momentum_count,
+            context="momentum slots",
+        )
+        currents = _component_slots(
+            current_storage.get("current_slots"),
+            id_field="current_id",
+            start_field="component_start",
+            stop_field="component_stop",
+            dimension_field="dimension",
+            component_count=current_count,
+            context="current slots",
+        )
+        plan_record = _mapping(execution.get("plan"), "plan")
+        process_prefix = f"processes/{process_id}"
+        raw_couplings = _load_table(
+            process_root,
+            process_prefix,
+            _mapping(plan_record.get("couplings"), "plan.couplings"),
+            EagerCouplingRow,
+            payloads,
+            process_id,
+            "couplings",
+        )
+        couplings = tuple(
+            _ExactCouplingRow(
+                row.real_parameter_id,
+                row.imag_parameter_id,
+                _complex_pair(
+                    row.constant_real,
+                    row.constant_imag,
+                    f"eager coupling {index} constant",
+                ),
+            )
+            for index, row in enumerate(raw_couplings)
+        )
+        raw_runtime_stages = _sequence(runtime_schema.get("stages"), "runtime stages")
+        raw_stages = _sequence(plan_record.get("stages"), "plan.stages")
+        if len(raw_stages) != len(raw_runtime_stages):
+            raise ArtifactError("eager plan stage count does not match runtime schema")
+        stages: list[_ExactStage] = []
+        previous_stage = -1
+        for index, (raw_stage, raw_runtime_stage) in enumerate(
+            zip(raw_stages, raw_runtime_stages, strict=True)
+        ):
+            stage = _mapping(raw_stage, f"plan.stages[{index}]")
+            runtime_stage = _mapping(
+                raw_runtime_stage, f"runtime_schema.stages[{index}]"
+            )
+            stage_index = _integer(stage.get("stage_index"), "stage_index")
+            if stage_index <= previous_stage:
+                raise ArtifactError("eager stage indices must be strictly increasing")
+            previous_stage = stage_index
+            if stage_index != _integer(runtime_stage.get("stage_index"), "stage_index"):
+                raise ArtifactError("eager plan stage does not match runtime schema")
+            raw_invocations = _load_table(
+                process_root,
+                process_prefix,
+                _mapping(stage.get("invocations"), "stage.invocations"),
+                EagerInvocationRow,
+                payloads,
+                process_id,
+                f"stage {stage_index} invocations",
+            )
+            raw_attachments = _load_table(
+                process_root,
+                process_prefix,
+                _mapping(stage.get("attachments"), "stage.attachments"),
+                EagerAttachmentRow,
+                payloads,
+                process_id,
+                f"stage {stage_index} attachments",
+            )
+            raw_finalizations = _load_table(
+                process_root,
+                process_prefix,
+                _mapping(stage.get("finalizations"), "stage.finalizations"),
+                EagerFinalizationRow,
+                payloads,
+                process_id,
+                f"stage {stage_index} finalizations",
+            )
+            stages.append(
+                _ExactStage(
+                    stage_index,
+                    tuple(
+                        _ExactInvocationRow(
+                            row.kernel_id,
+                            row.left_value_slot_id,
+                            row.right_value_slot_id,
+                            row.left_momentum_slot_id,
+                            row.right_momentum_slot_id,
+                            row.coupling_slot_id,
+                            row.output_factor_source,
+                            row.attachment_start,
+                            row.attachment_count,
+                        )
+                        for row in raw_invocations
+                    ),
+                    tuple(
+                        _ExactAttachmentRow(
+                            row.result_current_id,
+                            _complex_pair(
+                                row.factor_real,
+                                row.factor_imag,
+                                f"stage {stage_index} attachment factor",
+                            ),
+                        )
+                        for row in raw_attachments
+                    ),
+                    tuple(
+                        _ExactFinalizationRow(
+                            row.kernel_id,
+                            row.current_id,
+                            row.unpropagated_value_slot_id,
+                            row.propagated_value_slot_id,
+                            row.momentum_slot_id,
+                        )
+                        for row in raw_finalizations
+                    ),
+                )
+            )
+        raw_closures = _load_table(
+            process_root,
+            process_prefix,
+            _mapping(plan_record.get("closures"), "plan.closures"),
+            EagerClosureRow,
+            payloads,
+            process_id,
+            "closures",
+        )
+        amplitude_stage = _mapping(
+            runtime_schema.get("amplitude_stage"), "amplitude_stage"
+        )
+        amplitude_count = _integer(
+            amplitude_stage.get("output_count"), "amplitude output count", minimum=1
+        )
+        roots = _sequence(amplitude_stage.get("roots"), "amplitude roots")
+        if len(roots) != len(raw_closures):
+            raise ArtifactError("eager closure rows do not match amplitude roots")
+        closures = tuple(
+            _ExactClosureRow(
+                kernel_id=row.kernel_id,
+                left_value_slot_id=row.left_value_slot_id,
+                right_value_slot_id=row.right_value_slot_id,
+                amplitude_index=row.amplitude_index,
+                coupling_slot_id=row.coupling_slot_id,
+                output_factor_source=row.output_factor_source,
+                factor=_complex_pair(
+                    row.factor_real,
+                    row.factor_imag,
+                    f"eager closure {index} factor",
+                ),
+                direct_coefficients=(
+                    _direct_coefficients(
+                        _mapping(root, f"amplitude root {index}"),
+                        index,
+                    )
+                    if row.kernel_id == MISSING_U32
+                    else None
+                ),
+            )
+            for index, (row, root) in enumerate(zip(raw_closures, roots, strict=True))
+        )
+        stage_records = tuple(stages)
+        active_kernel_ids = _active_process_kernel_ids(stage_records, closures)
+        include_parameter_kernel = _runtime_has_derived_parameters(runtime_schema)
+        process_kernels = _process_prepared_kernels(
+            pack.kernels,
+            active_kernel_ids,
+            include_parameter_kernel=include_parameter_kernel,
+        )
+        kernel_map = {
+            kernel.kernel_id: _LazyExactKernel(
+                kernel,
+                payload_root,
+                effective_kernel_loader,
+            )
+            for kernel in process_kernels
+            if kernel.contract_kind != "model-parameter"
+        }
+        parameter_projection = _prepared_parameter_projection(
+            pack.kernels,
+            runtime_schema,
+            parameter_count,
+            active_kernel_ids=active_kernel_ids,
+            include_parameter_kernel=include_parameter_kernel,
+        )
+        parameter_derivation = _exact_parameter_derivation(
+            process_kernels,
+            runtime_schema,
+            parameter_projection,
+            payload_root,
+            effective_kernel_loader,
+        )
+        result = cls(
+            runtime_schema=runtime_schema,
+            physics_reduction_groups=None,
+            selector_group_ids=None,
+            selector_domains=None,
+            kernels=kernel_map,
+            value_slots=values,
+            momentum_slots=momenta,
+            current_slots=currents,
+            value_component_count=value_count,
+            momentum_component_count=momentum_count,
+            current_component_count=current_count,
+            parameter_count=parameter_count,
+            parameter_projection=parameter_projection,
+            parameter_derivation=parameter_derivation,
+            amplitude_count=amplitude_count,
+            couplings=couplings,
+            stages=stage_records,
+            closures=closures,
+        )
+        result._validate()
+        return result
+
+    def project_model_parameters(
+        self, runtime_parameters: Sequence[Decimal]
+    ) -> tuple[tuple[Decimal, Decimal], ...]:
+        return self.parameter_projection.project(runtime_parameters)
+
+    def resolve_model_parameters(
+        self,
+        runtime_parameters: Sequence[Decimal],
+        precision: int,
+    ) -> _ExactModelParameterState:
+        runtime = tuple(runtime_parameters)
+        prepared = self.parameter_projection.project(runtime)
+        if self.parameter_derivation is None:
+            return _ExactModelParameterState(runtime, prepared)
+        return self.parameter_derivation.evaluate(runtime, prepared, precision)
+
+    def _validate(self) -> None:
+        if (self.selector_group_ids is None) != (self.selector_domains is None):
+            raise ArtifactError(
+                "eager exact selector groups and domains must be provided together"
+            )
+        selector_groups = (
+            set() if self.selector_group_ids is None else set(self.selector_group_ids)
+        )
+        if self.selector_group_ids is not None:
+            if not self.selector_group_ids:
+                raise ArtifactError("eager exact selector group catalog is empty")
+            if len(selector_groups) != len(self.selector_group_ids):
+                raise ArtifactError("eager exact selector group IDs must be unique")
+            assert self.selector_domains is not None
+            if not self.selector_domains:
+                raise ArtifactError("eager exact selector domain catalog is empty")
+            for index, members in enumerate(self.selector_domains):
+                unknown = members - selector_groups
+                if unknown:
+                    raise ArtifactError(
+                        f"eager exact selector domain {index} references unknown "
+                        f"group {min(unknown)}"
+                    )
+
+        def validate_domain(domain_id: int | None, context: str) -> None:
+            if self.selector_domains is None:
+                if domain_id is not None:
+                    raise ArtifactError(f"{context} unexpectedly has a selector domain")
+                return
+            if domain_id is None or domain_id >= len(self.selector_domains):
+                raise ArtifactError(f"{context} selector domain is out of range")
+
+        for index, coupling in enumerate(self.couplings):
+            for component, parameter_id in (
+                ("real", coupling.real_parameter_id),
+                ("imaginary", coupling.imag_parameter_id),
+            ):
+                if parameter_id != MISSING_U32 and parameter_id >= self.parameter_count:
+                    raise ArtifactError(
+                        f"eager coupling {index} {component} parameter is out of range"
+                    )
+        finalized: set[int] = set()
+        stored_values: set[int] = set()
+        for stage in self.stages:
+            cursor = 0
+            attached: set[int] = set()
+            for index, invocation in enumerate(stage.invocations):
+                validate_domain(
+                    invocation.selector_domain_id,
+                    f"eager invocation {index}",
+                )
+                kernel = self._require_kernel(
+                    invocation.kernel_id, "vertex", f"invocation {index}"
+                )
+                left = self._slot(
+                    self.value_slots,
+                    invocation.left_value_slot_id,
+                    "invocation left value",
+                )
+                right = self._slot(
+                    self.value_slots,
+                    invocation.right_value_slot_id,
+                    "invocation right value",
+                )
+                left_momentum = self._slot(
+                    self.momentum_slots,
+                    invocation.left_momentum_slot_id,
+                    "invocation left momentum",
+                )
+                right_momentum = self._slot(
+                    self.momentum_slots,
+                    invocation.right_momentum_slot_id,
+                    "invocation right momentum",
+                )
+                if invocation.coupling_slot_id >= len(self.couplings):
+                    raise ArtifactError("eager invocation coupling is out of range")
+                if (
+                    invocation.attachment_count == 0
+                    or invocation.attachment_start != cursor
+                ):
+                    raise ArtifactError(
+                        f"eager stage {stage.stage_index} has invalid attachment ranges"
+                    )
+                stop = cursor + invocation.attachment_count
+                if stop > len(stage.attachments):
+                    raise ArtifactError(
+                        "eager invocation attachment range is out of bounds"
+                    )
+                self._validate_kernel_inputs(
+                    kernel.record,
+                    first_current=left.width,
+                    second_current=right.width,
+                    first_momentum=left_momentum.width,
+                    second_momentum=right_momentum.width,
+                    has_coupling=True,
+                    context=f"invocation {index}",
+                )
+                for attachment in stage.attachments[cursor:stop]:
+                    validate_domain(
+                        attachment.selector_domain_id,
+                        "eager attachment",
+                    )
+                    current = self._slot(
+                        self.current_slots,
+                        attachment.result_current_id,
+                        "attachment result current",
+                    )
+                    if current.width != kernel.record.output_arity:
+                        raise ArtifactError(
+                            "eager invocation output width does not match "
+                            "attached current"
+                        )
+                    attached.add(attachment.result_current_id)
+                cursor = stop
+            if cursor != len(stage.attachments):
+                raise ArtifactError("eager attachment table is not fully referenced")
+            stage_finalized: set[int] = set()
+            for index, finalization in enumerate(stage.finalizations):
+                validate_domain(
+                    finalization.unpropagated_selector_domain_id,
+                    f"eager finalization {index} unpropagated",
+                )
+                validate_domain(
+                    finalization.propagated_selector_domain_id,
+                    f"eager finalization {index} propagated",
+                )
+                if (
+                    finalization.current_id in stage_finalized
+                    or finalization.current_id in finalized
+                ):
+                    raise ArtifactError(
+                        f"eager current {finalization.current_id} is finalized "
+                        "more than once"
+                    )
+                stage_finalized.add(finalization.current_id)
+                finalized.add(finalization.current_id)
+                current = self._slot(
+                    self.current_slots,
+                    finalization.current_id,
+                    "finalization current",
+                )
+                outputs = []
+                for name, slot_id in (
+                    ("unpropagated", finalization.unpropagated_value_slot_id),
+                    ("propagated", finalization.propagated_value_slot_id),
+                ):
+                    if slot_id == MISSING_U32:
+                        continue
+                    if slot_id in stored_values:
+                        raise ArtifactError(
+                            f"eager value slot {slot_id} is finalized more than once"
+                        )
+                    stored_values.add(slot_id)
+                    output = self._slot(self.value_slots, slot_id, f"{name} value")
+                    if output.width != current.width:
+                        raise ArtifactError("finalization output/current widths differ")
+                    outputs.append((name, output))
+                if not outputs:
+                    raise ArtifactError("eager finalization stores no value")
+                momentum = self._slot(
+                    self.momentum_slots,
+                    finalization.momentum_slot_id,
+                    "finalization momentum",
+                )
+                if finalization.kernel_id == MISSING_U32:
+                    if finalization.propagated_value_slot_id != MISSING_U32:
+                        raise ArtifactError(
+                            "eager propagated current has no finalization kernel"
+                        )
+                else:
+                    kernel = self._require_kernel(
+                        finalization.kernel_id,
+                        "propagator",
+                        f"finalization {index}",
+                    )
+                    if finalization.propagated_value_slot_id == MISSING_U32:
+                        raise ArtifactError(
+                            "eager finalization kernel has no propagated output"
+                        )
+                    if kernel.record.output_arity != current.width:
+                        raise ArtifactError(
+                            "eager finalization kernel/current widths differ"
+                        )
+                    self._validate_kernel_inputs(
+                        kernel.record,
+                        first_current=current.width,
+                        second_current=0,
+                        first_momentum=momentum.width,
+                        second_momentum=0,
+                        has_coupling=False,
+                        context=f"finalization {index}",
+                    )
+            if not attached.issubset(stage_finalized):
+                missing = min(attached - stage_finalized)
+                raise ArtifactError(
+                    f"eager stage {stage.stage_index} does not finalize "
+                    f"current {missing}"
+                )
+
+        amplitude_stage = _mapping(
+            self.runtime_schema.get("amplitude_stage"), "amplitude_stage"
+        )
+        roots = _sequence(amplitude_stage.get("roots"), "amplitude roots")
+        if len(roots) != len(self.closures):
+            raise ArtifactError("eager closure rows do not match amplitude roots")
+        for index, (closure, raw_root) in enumerate(
+            zip(self.closures, roots, strict=True)
+        ):
+            validate_domain(closure.selector_domain_id, f"eager closure {index}")
+            if self.selector_domains is not None:
+                if closure.coherent_group_id not in selector_groups:
+                    raise ArtifactError(
+                        f"eager closure {index} coherent group is unknown"
+                    )
+                assert closure.selector_domain_id is not None
+                if (
+                    closure.coherent_group_id
+                    not in self.selector_domains[closure.selector_domain_id]
+                ):
+                    raise ArtifactError(
+                        f"eager closure {index} domain excludes its coherent group"
+                    )
+            root = _mapping(raw_root, f"amplitude root {index}")
+            left = self._slot(
+                self.value_slots, closure.left_value_slot_id, "closure left value"
+            )
+            right = self._slot(
+                self.value_slots, closure.right_value_slot_id, "closure right value"
+            )
+            if closure.amplitude_index >= self.amplitude_count:
+                raise ArtifactError("eager closure amplitude index is out of range")
+            if closure.kernel_id == MISSING_U32:
+                if closure.coupling_slot_id != MISSING_U32:
+                    raise ArtifactError("direct eager closure references a coupling")
+                if closure.output_factor_source != EAGER_OUTPUT_FACTOR_NONE:
+                    raise ArtifactError(
+                        "direct eager closure has a dynamic output factor"
+                    )
+                if root.get("kind") != "direct-contraction":
+                    raise ArtifactError(
+                        "direct eager closure lacks contraction metadata"
+                    )
+                coefficients = closure.direct_coefficients
+                if not coefficients:
+                    raise ArtifactError(
+                        "direct eager closure has no exact contraction coefficients"
+                    )
+                if left.width != right.width or left.width != len(coefficients):
+                    raise ArtifactError("direct eager closure component widths differ")
+            else:
+                if closure.direct_coefficients is not None:
+                    raise ArtifactError(
+                        "kernel eager closure carries direct coefficients"
+                    )
+                if root.get("kind") == "direct-contraction":
+                    raise ArtifactError("kernel eager closure has direct metadata")
+                if closure.coupling_slot_id >= len(self.couplings):
+                    raise ArtifactError("eager closure coupling is out of range")
+                kernel = self._require_kernel(
+                    closure.kernel_id, "closure", f"closure {index}"
+                )
+                if kernel.record.output_arity != 1:
+                    raise ArtifactError(
+                        "eager closure kernels must return one component"
+                    )
+                self._validate_kernel_inputs(
+                    kernel.record,
+                    first_current=left.width,
+                    second_current=right.width,
+                    first_momentum=0,
+                    second_momentum=0,
+                    has_coupling=True,
+                    context=f"closure {index}",
+                )
+
+    def _require_kernel(
+        self, kernel_id: int, kind: str, context: str
+    ) -> _LazyExactKernel:
+        kernel = self.kernels.get(kernel_id)
+        if kernel is None:
+            raise ArtifactError(
+                f"{context} references missing eager kernel {kernel_id}"
+            )
+        if kernel.record.contract_kind != kind:
+            raise ArtifactError(
+                f"{context} requires a {kind} kernel, but {kernel_id} is "
+                f"{kernel.record.contract_kind}"
+            )
+        return kernel
+
+    @staticmethod
+    def _slot(
+        slots: Sequence[_ComponentSlot],
+        slot_id: int,
+        context: str,
+    ) -> _ComponentSlot:
+        if slot_id < 0 or slot_id >= len(slots):
+            raise ArtifactError(f"{context} references unknown slot {slot_id}")
+        return slots[slot_id]
+
+    def _validate_kernel_inputs(
+        self,
+        record: PreparedKernelRecord,
+        *,
+        first_current: int,
+        second_current: int,
+        first_momentum: int,
+        second_momentum: int,
+        has_coupling: bool,
+        context: str,
+    ) -> None:
+        seen: set[tuple[str, int]] = set()
+        for input_index, contract in enumerate(record.input_contracts):
+            role = str(contract["role"])
+            component = _integer(
+                contract["component"],
+                f"kernel {record.kernel_id} input component",
+            )
+            if role == "left-current":
+                allowed, bound, descriptor = True, first_current, (role, component)
+            elif role == "right-current":
+                allowed, bound, descriptor = (
+                    record.contract_kind != "propagator",
+                    second_current,
+                    (role, component),
+                )
+            elif role == "current":
+                allowed, bound, descriptor = (
+                    record.contract_kind == "propagator",
+                    first_current,
+                    ("left-current", component),
+                )
+            elif role == "left-momentum":
+                allowed, bound, descriptor = (
+                    record.contract_kind != "closure",
+                    first_momentum,
+                    (role, component),
+                )
+            elif role == "right-momentum":
+                allowed, bound, descriptor = (
+                    record.contract_kind == "vertex",
+                    second_momentum,
+                    (role, component),
+                )
+            elif role == "momentum":
+                allowed, bound, descriptor = (
+                    record.contract_kind == "propagator",
+                    first_momentum,
+                    ("left-momentum", component),
+                )
+            elif role in {"coupling-real", "coupling-imag"}:
+                allowed, bound, descriptor = has_coupling, 1, (role, 0)
+            elif role == "model-parameter":
+                parameter_id = contract.get("model_parameter_index")
+                if isinstance(parameter_id, bool) or not isinstance(parameter_id, int):
+                    raise ArtifactError(
+                        f"kernel {record.kernel_id} model-parameter input lacks "
+                        "an index"
+                    )
+                allowed, bound, component, descriptor = (
+                    parameter_id < self.parameter_projection.parameter_count,
+                    self.parameter_projection.parameter_count,
+                    parameter_id,
+                    (role, parameter_id),
+                )
+            else:
+                raise ArtifactError(
+                    f"kernel {record.kernel_id} has unsupported input role {role!r}"
+                )
+            if not allowed or component >= bound:
+                raise ArtifactError(
+                    f"{context} kernel {record.kernel_id} input {input_index} "
+                    "is out of range"
+                )
+            if descriptor in seen:
+                raise ArtifactError(
+                    f"kernel {record.kernel_id} repeats eager input {descriptor!r}"
+                )
+            seen.add(descriptor)
+
+
+def _load_exact_kernel_pack(
+    *,
+    artifact_root: Path,
+    execution: Mapping[str, object],
+    manifest: ArtifactManifest,
+    kernel_loader: _KernelLoader | None,
+    exact_payloads: ExactEvaluatorPayloadResolver,
+) -> tuple[PreparedKernelPack, Path, _KernelLoader]:
+    payloads = _PayloadIndex.from_manifest(manifest)
+    kernel_reference = _mapping(execution.get("kernel_pack"), "kernel_pack")
+    pack_path = kernel_reference.get("manifest_path")
+    if not isinstance(pack_path, str):
+        raise ArtifactError("kernel_pack.manifest_path must be a string")
+    payload_root_name = kernel_reference.get("payload_root")
+    if not isinstance(payload_root_name, str):
+        raise ArtifactError("kernel_pack.payload_root must be a string")
+    pack_path = normalize_relative_path(pack_path)
+    payload_root_name = normalize_relative_path(payload_root_name)
+    payloads.require(pack_path, role="evaluator-manifest", process_id=None)
+    pack_payload = _read_json(
+        confined_path(artifact_root, pack_path), "eager kernel pack"
+    )
+    raw_backend = pack_payload.get("backend")
+    if raw_backend not in _SUPPORTED_PREPARED_BACKENDS:
+        raise CompatibilityError(f"unsupported prepared eager backend {raw_backend!r}")
+    mutable_pack = dict(pack_payload)
+    kernel_abi = mutable_pack.pop("eager_kernel_abi", None)
+    if kernel_abi != EAGER_KERNEL_ABI:
+        raise CompatibilityError(f"unsupported eager kernel ABI {kernel_abi!r}")
+    try:
+        pack = PreparedKernelPack.from_dict(mutable_pack)
+    except PreparedModelBundleError as exc:
+        raise ArtifactError(f"eager kernel pack is malformed: {exc}") from exc
+    if pack.resolver_manifest.get("abi") != _PREPARED_CATALOG_ABI:
+        raise CompatibilityError("unsupported prepared eager kernel catalog ABI")
+    payload_root = artifact_root / payload_root_name
+    if payload_root.exists() and (
+        not payload_root.is_dir() or payload_root.is_symlink()
+    ):
+        raise ArtifactError("eager kernel payload root is invalid")
+    for kernel in pack.kernels:
+        exact_path = _joined_payload_path(
+            payload_root_name,
+            kernel.exact_evaluator_state_path,
+        )
+        exact_payloads.require_exact_state(exact_path, process_id=None)
+    effective_loader = kernel_loader or _artifact_kernel_loader(
+        exact_payloads,
+        payload_root_name,
+    )
+    return pack, payload_root, effective_loader
+
+
+def _prepared_parameter_projection(
+    kernels: Sequence[PreparedKernelRecord],
+    runtime_schema: Mapping[str, object],
+    runtime_parameter_count: int,
+    *,
+    active_kernel_ids: frozenset[int] | None = None,
+    include_parameter_kernel: bool = False,
+) -> _PreparedParameterProjection:
+    runtime_slots = _runtime_parameter_slots(
+        runtime_schema,
+        runtime_parameter_count,
+    )
+    by_name: dict[str, int] = {}
+    by_index: dict[int, str] = {}
+    active_names: set[str] = set()
+    for kernel in kernels:
+        active = (
+            active_kernel_ids is None
+            or kernel.kernel_id in active_kernel_ids
+            or (include_parameter_kernel and kernel.contract_kind == "model-parameter")
+        )
+        for contract in kernel.input_contracts:
+            if contract.get("role") != "model-parameter":
+                continue
+            name = contract.get("model_parameter_name")
+            if not isinstance(name, str) or not name:
+                raise ArtifactError(
+                    "prepared model-parameter input lacks its logical name"
+                )
+            index = contract.get("model_parameter_index")
+            if isinstance(index, bool) or not isinstance(index, int) or index < 0:
+                raise ArtifactError(
+                    "prepared model-parameter input lacks its stable index"
+                )
+            previous_index = by_name.setdefault(name, index)
+            if previous_index != index:
+                raise ArtifactError(
+                    f"prepared parameter {name!r} has conflicting stable indices"
+                )
+            previous_name = by_index.setdefault(index, name)
+            if previous_name != name:
+                raise ArtifactError(
+                    f"prepared parameter index {index} names multiple parameters"
+                )
+            if active:
+                active_names.add(name)
+
+    entries = []
+    active_parameters = sorted(
+        ((name, by_name[name]) for name in active_names),
+        key=lambda item: item[1],
+    )
+    for name, prepared_index in active_parameters:
+        slots = runtime_slots.get(name)
+        if slots is None:
+            raise ArtifactError(
+                f"prepared parameter {name!r} is absent from the process runtime schema"
+            )
+        entries.append(
+            _PreparedParameterProjectionEntry(
+                name=name,
+                prepared_index=prepared_index,
+                runtime_real_index=slots.real,
+                runtime_imaginary_index=slots.imaginary,
+            )
+        )
+    parameter_count = max((index for _, index in active_parameters), default=-1) + 1
+    return _PreparedParameterProjection(
+        parameter_count=parameter_count,
+        runtime_parameter_count=runtime_parameter_count,
+        entries=tuple(entries),
+    )
+
+
+def _active_process_kernel_ids(
+    stages: Sequence[_ExactStage],
+    closures: Sequence[_ExactClosureRow],
+) -> frozenset[int]:
+    kernel_ids = {
+        invocation.kernel_id for stage in stages for invocation in stage.invocations
+    }
+    kernel_ids.update(
+        finalization.kernel_id
+        for stage in stages
+        for finalization in stage.finalizations
+        if finalization.kernel_id != MISSING_U32
+    )
+    kernel_ids.update(
+        closure.kernel_id for closure in closures if closure.kernel_id != MISSING_U32
+    )
+    return frozenset(kernel_ids)
+
+
+def _process_prepared_kernels(
+    kernels: Sequence[PreparedKernelRecord],
+    active_kernel_ids: frozenset[int],
+    *,
+    include_parameter_kernel: bool,
+) -> tuple[PreparedKernelRecord, ...]:
+    if sum(kernel.contract_kind == "model-parameter" for kernel in kernels) > 1:
+        raise ArtifactError(
+            "eager kernel pack declares multiple model-parameter kernels"
+        )
+    process_kernels = tuple(
+        kernel
+        for kernel in kernels
+        if (include_parameter_kernel and kernel.contract_kind == "model-parameter")
+        or kernel.kernel_id in active_kernel_ids
+    )
+    available_ids = {
+        kernel.kernel_id
+        for kernel in process_kernels
+        if kernel.contract_kind != "model-parameter"
+    }
+    missing_ids = active_kernel_ids - available_ids
+    if missing_ids:
+        raise ArtifactError(
+            f"eager process references missing prepared kernel {min(missing_ids)}"
+        )
+    return process_kernels
+
+
+def _runtime_has_derived_parameters(
+    runtime_schema: Mapping[str, object],
+) -> bool:
+    return any(
+        _mapping(record, f"model parameters[{index}]").get("kind")
+        == "derived_parameter_component"
+        for index, record in enumerate(
+            _sequence(runtime_schema.get("model_parameters"), "model parameters")
+        )
+    )
+
+
+def _runtime_parameter_slots(
+    runtime_schema: Mapping[str, object],
+    parameter_count: int,
+) -> Mapping[str, _RuntimeParameterSlots]:
+    direct: dict[str, _RuntimeParameterSlots] = {}
+    complex_components: dict[str, list[int | None]] = {}
+    complex_kinds: dict[str, str] = {}
+    seen_indices: set[int] = set()
+    records = _sequence(runtime_schema.get("model_parameters"), "model parameters")
+    for record_index, raw_record in enumerate(records):
+        record = _mapping(raw_record, f"model parameters[{record_index}]")
+        parameter_index = _integer(
+            record.get("parameter_index"),
+            f"model parameters[{record_index}].parameter_index",
+        )
+        if parameter_index >= parameter_count or parameter_index in seen_indices:
+            raise ArtifactError("runtime model-parameter indices are invalid")
+        seen_indices.add(parameter_index)
+        name = record.get("name")
+        if not isinstance(name, str) or not name:
+            raise ArtifactError("runtime model parameter has no name")
+        runtime_name = record.get("runtime_name")
+        kind = record.get("kind")
+        if not isinstance(kind, str) or not kind:
+            raise ArtifactError("runtime model parameter has no kind")
+        if runtime_name is None:
+            if name in direct or name in complex_components:
+                raise ArtifactError(f"runtime model parameter {name!r} is duplicated")
+            direct[name] = _RuntimeParameterSlots(parameter_index, None, kind)
+            continue
+        if not isinstance(runtime_name, str) or not runtime_name:
+            raise ArtifactError("complex runtime model parameter has no logical name")
+        component = record.get("complex_component")
+        if component not in {"real", "imag"}:
+            raise ArtifactError(
+                f"runtime model parameter {runtime_name!r} has invalid component "
+                f"{component!r}"
+            )
+        slots = complex_components.setdefault(runtime_name, [None, None])
+        previous_kind = complex_kinds.setdefault(runtime_name, kind)
+        if previous_kind != kind:
+            raise ArtifactError(
+                f"runtime model parameter {runtime_name!r} has mixed component kinds"
+            )
+        component_index = 0 if component == "real" else 1
+        if slots[component_index] is not None:
+            raise ArtifactError(
+                f"runtime model parameter {runtime_name!r} repeats a complex component"
+            )
+        slots[component_index] = parameter_index
+
+    if seen_indices != set(range(parameter_count)):
+        raise ArtifactError(
+            "runtime model-parameter indices must be contiguous from zero"
+        )
+    for name, (real, imaginary) in complex_components.items():
+        if real is None:
+            raise ArtifactError(
+                f"complex runtime model parameter {name!r} lacks a real component"
+            )
+        if name in direct:
+            raise ArtifactError(
+                f"runtime model parameter {name!r} has scalar and complex records"
+            )
+        if imaginary is None:
+            raise ArtifactError(
+                f"complex runtime model parameter {name!r} lacks an imaginary component"
+            )
+        direct[name] = _RuntimeParameterSlots(real, imaginary, complex_kinds[name])
+    return direct
+
+
+def _exact_parameter_derivation(
+    kernels: Sequence[PreparedKernelRecord],
+    runtime_schema: Mapping[str, object],
+    projection: _PreparedParameterProjection,
+    payload_root: Path,
+    kernel_loader: _KernelLoader,
+) -> _ExactParameterDerivation | None:
+    records = tuple(
+        kernel for kernel in kernels if kernel.contract_kind == "model-parameter"
+    )
+    if not records:
+        return None
+    if len(records) != 1:
+        raise ArtifactError(
+            "eager kernel pack declares multiple model-parameter kernels"
+        )
+    record = records[0]
+    runtime_slots = _runtime_parameter_slots(
+        runtime_schema,
+        projection.runtime_parameter_count,
+    )
+    output_names: set[str] = set()
+    parsed_outputs: list[str] = []
+    prefix = "model-parameter:"
+    if not record.output_layout:
+        raise ArtifactError("model-parameter kernel declares no outputs")
+    for index, layout in enumerate(record.output_layout):
+        if not layout.startswith(prefix) or len(layout) == len(prefix):
+            raise ArtifactError(
+                f"model-parameter kernel output {index} has invalid layout {layout!r}"
+            )
+        output_name = layout[len(prefix) :]
+        if output_name != output_name.strip():
+            raise ArtifactError(
+                f"model-parameter kernel output {index} has invalid layout {layout!r}"
+            )
+        if output_name in output_names:
+            raise ArtifactError(
+                f"model-parameter kernel repeats output parameter {output_name!r}"
+            )
+        output_names.add(output_name)
+        parsed_outputs.append(output_name)
+
+    input_names: set[str] = set()
+    input_parameter_indices: list[int] = []
+    for index, contract in enumerate(record.input_contracts):
+        if contract.get("role") != "model-parameter":
+            raise ArtifactError(
+                f"model-parameter kernel input {index} is not a model parameter"
+            )
+        input_name = contract.get("model_parameter_name")
+        stable_index = contract.get("model_parameter_index")
+        component = contract.get("component")
+        if not isinstance(input_name, str) or not input_name:
+            raise ArtifactError(
+                f"model-parameter kernel input {index} lacks a logical name"
+            )
+        if (
+            isinstance(stable_index, bool)
+            or not isinstance(stable_index, int)
+            or stable_index < 0
+        ):
+            raise ArtifactError(
+                f"model-parameter kernel input {index} lacks a stable index"
+            )
+        if component != 0:
+            raise ArtifactError(
+                f"model-parameter kernel input {index} has invalid component "
+                f"{component!r}"
+            )
+        entry = projection.entry(input_name)
+        if entry is None or entry.prepared_index != stable_index:
+            raise ArtifactError(
+                f"model-parameter kernel input {input_name!r} has no matching "
+                "projection"
+            )
+        input_slots = runtime_slots[input_name]
+        if input_slots.kind not in {
+            "external_parameter",
+            "external_parameter_component",
+        }:
+            raise ArtifactError(
+                f"model-parameter kernel input {input_name!r} is not an "
+                "external/base "
+                "parameter"
+            )
+        if input_name in input_names:
+            raise ArtifactError(
+                f"model-parameter kernel repeats input parameter {input_name!r}"
+            )
+        input_names.add(input_name)
+        input_parameter_indices.append(stable_index)
+    overlap = input_names & output_names
+    if overlap:
+        raise ArtifactError(
+            "model-parameter kernel inputs overlap its derived outputs: "
+            + ", ".join(sorted(overlap))
+        )
+
+    derived_runtime_names = {
+        runtime_name
+        for runtime_name, runtime_slots_record in runtime_slots.items()
+        if runtime_slots_record.kind == "derived_parameter_component"
+    }
+    missing_outputs = derived_runtime_names - output_names
+    if missing_outputs:
+        raise ArtifactError(
+            "model-parameter kernel does not output runtime derived parameters: "
+            + ", ".join(repr(name) for name in sorted(missing_outputs))
+        )
+
+    targets: list[_DerivedParameterTarget | None] = []
+    for output_name in parsed_outputs:
+        output_slots = runtime_slots.get(output_name)
+        entry = projection.entry(output_name)
+        if output_slots is None:
+            if entry is not None:
+                raise ArtifactError(
+                    f"derived prepared parameter {output_name!r} has no runtime slots"
+                )
+            targets.append(None)
+            continue
+        if output_slots.kind != "derived_parameter_component":
+            raise ArtifactError(
+                f"model-parameter kernel output {output_name!r} does not target "
+                "derived runtime slots"
+            )
+        if output_slots.imaginary is None:
+            raise ArtifactError(
+                f"derived runtime parameter {output_name!r} lacks an imaginary "
+                "component"
+            )
+        targets.append(
+            _DerivedParameterTarget(
+                name=output_name,
+                prepared_index=(None if entry is None else entry.prepared_index),
+                runtime_real_index=output_slots.real,
+                runtime_imaginary_index=output_slots.imaginary,
+            )
+        )
+    return _ExactParameterDerivation(
+        _LazyExactKernel(record, payload_root, kernel_loader),
+        tuple(input_parameter_indices),
+        tuple(targets),
+    )
diff --git a/pyamplicol/src/pyamplicol/runtime/eager_exact/_plan_v3.py b/pyamplicol/src/pyamplicol/runtime/eager_exact/_plan_v3.py
new file mode 100644
index 0000000000..5a4f8c6e53
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/eager_exact/_plan_v3.py
@@ -0,0 +1,482 @@
+# SPDX-License-Identifier: 0BSD
+"""Typed adapter for exact-required sections of compact eager plan-v3."""
+
+from __future__ import annotations
+
+import importlib
+import os
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol, cast
+
+from pyamplicol._internal.versions import (
+    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    verify_native_module,
+)
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+from pyamplicol.runtime.eager_exact._contracts import (
+    _complex_pair,
+    _ExactAttachmentRow,
+    _ExactClosureRow,
+    _ExactComplexProduct,
+    _ExactCouplingRow,
+    _ExactFinalizationRow,
+    _ExactInvocationRow,
+    _integer,
+    _mapping,
+    _sequence,
+)
+
+EAGER_EXACT_SECTIONS_ABI = "pyamplicol-eager-exact-sections-v1"
+EAGER_REDUCTION_GROUPS_ABI = "pyamplicol-eager-reduction-groups-v1"
+EAGER_PLAN_V3_ABI = "pyamplicol-eager-plan-v3"
+EAGER_RUNTIME_LAYOUT_ABI = "pyamplicol-eager-runtime-layout-v1"
+EAGER_PLAN_V3_RUNTIME_CAPABILITY = "rusticol.eager-runtime-layout.complex-f64.v1"
+_EAGER_PLAN_V3_RUNTIME_CAPABILITIES = sorted(
+    (
+        EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+    )
+)
+_NATIVE_BINDING_NAME = "_load_eager_exact_sections_v1"
+_NATIVE_REDUCTION_BINDING_NAME = "_load_eager_reduction_groups_v1"
+
+
+class _NativeExactSectionsBinding(Protocol):
+    def __call__(self, artifact_root: str, process_id: str, /) -> object: ...
+
+
+class _NativeReductionGroupsBinding(Protocol):
+    def __call__(self, artifact_root: str, process_id: str, /) -> object: ...
+
+
+_NativeExactSectionsLoader = Callable[[Path, str], object]
+_NativeReductionGroupsLoader = Callable[[Path, str], object]
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactStageV3:
+    stage_index: int
+    invocations: tuple[_ExactInvocationRow, ...]
+    attachments: tuple[_ExactAttachmentRow, ...]
+    finalizations: tuple[_ExactFinalizationRow, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _EagerExactSectionsV1:
+    exact_schema: Mapping[str, object]
+    reduction_groups: tuple[Mapping[str, object], ...]
+    selector_group_ids: tuple[int, ...]
+    selector_domains: tuple[frozenset[int], ...]
+    couplings: tuple[_ExactCouplingRow, ...]
+    stages: tuple[_ExactStageV3, ...]
+    closures: tuple[_ExactClosureRow, ...]
+
+
+def _load_eager_exact_sections_v1(
+    artifact_root: Path,
+    process_id: str,
+    *,
+    loader: _NativeExactSectionsLoader | None = None,
+) -> _EagerExactSectionsV1:
+    raw = (loader or _native_exact_sections_loader)(artifact_root, process_id)
+    return _parse_exact_sections(raw, process_id)
+
+
+def _load_eager_reduction_groups_v1(
+    artifact_root: Path,
+    process_id: str,
+    *,
+    loader: _NativeReductionGroupsLoader | None = None,
+) -> tuple[Mapping[str, object], ...]:
+    raw = (loader or _native_reduction_groups_loader)(artifact_root, process_id)
+    root = _mapping(raw, "compact eager reduction groups")
+    if root.get("abi") != EAGER_REDUCTION_GROUPS_ABI:
+        raise CompatibilityError(
+            f"unsupported compact eager reduction-groups ABI {root.get('abi')!r}"
+        )
+    if root.get("runtime_layout_abi") != EAGER_RUNTIME_LAYOUT_ABI:
+        raise CompatibilityError(
+            "unsupported compact eager reduction runtime-layout ABI "
+            f"{root.get('runtime_layout_abi')!r}"
+        )
+    if root.get("process_id") != process_id:
+        raise ArtifactError("compact eager reduction groups select the wrong process")
+    return tuple(
+        _mapping(value, f"compact eager reduction group {index}")
+        for index, value in enumerate(
+            _sequence(
+                root.get("reduction_groups"),
+                "compact eager reduction groups",
+            )
+        )
+    )
+
+
+def _native_exact_sections_loader(artifact_root: Path, process_id: str) -> object:
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(module)
+    except ImportError as exc:
+        raise CompatibilityError(
+            "compact eager exact execution requires pyamplicol._rusticol"
+        ) from exc
+    candidate = getattr(module, _NATIVE_BINDING_NAME, None)
+    if not callable(candidate):
+        raise CompatibilityError(
+            "compact eager exact execution requires the private native binding "
+            f"{_NATIVE_BINDING_NAME}"
+        )
+    binding = cast(_NativeExactSectionsBinding, candidate)
+    try:
+        return binding(os.fspath(artifact_root), process_id)
+    except (ArtifactError, CompatibilityError):
+        raise
+    except Exception as exc:
+        raise ArtifactError(
+            f"could not load compact exact sections for process {process_id!r}: {exc}"
+        ) from exc
+
+
+def _native_reduction_groups_loader(artifact_root: Path, process_id: str) -> object:
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(module)
+    except ImportError as exc:
+        raise CompatibilityError(
+            "compact eager reduction loading requires pyamplicol._rusticol"
+        ) from exc
+    candidate = getattr(module, _NATIVE_REDUCTION_BINDING_NAME, None)
+    if not callable(candidate):
+        raise CompatibilityError(
+            "compact eager reduction loading requires the private native binding "
+            f"{_NATIVE_REDUCTION_BINDING_NAME}"
+        )
+    binding = cast(_NativeReductionGroupsBinding, candidate)
+    try:
+        return binding(os.fspath(artifact_root), process_id)
+    except (ArtifactError, CompatibilityError):
+        raise
+    except Exception as exc:
+        raise ArtifactError(
+            f"could not load compact eager reduction groups for process "
+            f"{process_id!r}: {exc}"
+        ) from exc
+
+
+def _parse_exact_sections(raw: object, process_id: str) -> _EagerExactSectionsV1:
+    root = _mapping(raw, "compact eager exact sections")
+    if root.get("abi") != EAGER_EXACT_SECTIONS_ABI:
+        raise CompatibilityError(
+            f"unsupported compact eager exact-sections ABI {root.get('abi')!r}"
+        )
+    if root.get("runtime_layout_abi") != EAGER_RUNTIME_LAYOUT_ABI:
+        raise CompatibilityError(
+            f"unsupported compact eager runtime-layout ABI "
+            f"{root.get('runtime_layout_abi')!r}"
+        )
+    if root.get("process_id") != process_id:
+        raise ArtifactError("compact eager exact sections select the wrong process")
+
+    couplings = tuple(
+        _parse_coupling(row, index)
+        for index, row in enumerate(
+            _sequence(root.get("couplings"), "compact eager couplings")
+        )
+    )
+    invocations = tuple(
+        _parse_invocation(row, index)
+        for index, row in enumerate(
+            _sequence(root.get("invocations"), "compact eager invocations")
+        )
+    )
+    attachments = tuple(
+        _parse_attachment(row, index)
+        for index, row in enumerate(
+            _sequence(root.get("attachments"), "compact eager attachments")
+        )
+    )
+    finalizations = tuple(
+        _parse_finalization(row, index)
+        for index, row in enumerate(
+            _sequence(root.get("finalizations"), "compact eager finalizations")
+        )
+    )
+    stages = _parse_stages(root.get("stages"), invocations, attachments, finalizations)
+    closures = tuple(
+        _parse_closure(row, index)
+        for index, row in enumerate(
+            _sequence(root.get("closures"), "compact eager closures")
+        )
+    )
+    selector_group_ids = tuple(
+        _integer(value, f"compact eager selector group {index}")
+        for index, value in enumerate(
+            _sequence(
+                root.get("selector_group_ids"),
+                "compact eager selector groups",
+            )
+        )
+    )
+    selector_domains = tuple(
+        frozenset(
+            _integer(member, f"compact eager selector domain {index} member")
+            for member in _sequence(
+                raw_domain,
+                f"compact eager selector domain {index}",
+            )
+        )
+        for index, raw_domain in enumerate(
+            _sequence(root.get("selector_domains"), "compact eager selector domains")
+        )
+    )
+    return _EagerExactSectionsV1(
+        exact_schema=_mapping(root.get("exact_schema"), "compact eager exact schema"),
+        reduction_groups=tuple(
+            _mapping(value, f"compact eager reduction group {index}")
+            for index, value in enumerate(
+                _sequence(
+                    root.get("reduction_groups"),
+                    "compact eager reduction groups",
+                )
+            )
+        ),
+        selector_group_ids=selector_group_ids,
+        selector_domains=selector_domains,
+        couplings=couplings,
+        stages=stages,
+        closures=closures,
+    )
+
+
+def _row(raw: object, width: int, context: str) -> Sequence[object]:
+    values = _sequence(raw, context)
+    if len(values) != width:
+        raise ArtifactError(f"{context} must contain {width} fields")
+    return values
+
+
+def _parse_coupling(raw: object, index: int) -> _ExactCouplingRow:
+    context = f"compact eager coupling {index}"
+    values = _row(raw, 4, context)
+    return _ExactCouplingRow(
+        _integer(values[0], f"{context} real parameter"),
+        _integer(values[1], f"{context} imaginary parameter"),
+        _complex_pair(values[2], values[3], f"{context} constant"),
+    )
+
+
+def _parse_invocation(raw: object, index: int) -> _ExactInvocationRow:
+    context = f"compact eager invocation {index}"
+    values = _row(raw, 10, context)
+    return _ExactInvocationRow(
+        *(
+            _integer(value, f"{context} field {field}")
+            for field, value in enumerate(values)
+        )
+    )
+
+
+def _parse_attachment(raw: object, index: int) -> _ExactAttachmentRow:
+    context = f"compact eager attachment {index}"
+    values = _row(raw, 4, context)
+    return _ExactAttachmentRow(
+        _integer(values[0], f"{context} current"),
+        _parse_factor_product(values[1], values[2], f"{context} factor"),
+        _integer(values[3], f"{context} selector domain"),
+    )
+
+
+def _parse_finalization(raw: object, index: int) -> _ExactFinalizationRow:
+    context = f"compact eager finalization {index}"
+    values = _row(raw, 7, context)
+    return _ExactFinalizationRow(
+        *(
+            _integer(value, f"{context} field {field}")
+            for field, value in enumerate(values)
+        )
+    )
+
+
+def _parse_closure(raw: object, index: int) -> _ExactClosureRow:
+    context = f"compact eager closure {index}"
+    values = _row(raw, 11, context)
+    raw_coefficients = values[8]
+    coefficients = (
+        None
+        if raw_coefficients is None
+        else tuple(
+            _complex_pair(
+                _row(value, 2, f"{context} direct coefficient {coefficient_index}")[0],
+                _row(value, 2, f"{context} direct coefficient {coefficient_index}")[1],
+                f"{context} direct coefficient {coefficient_index}",
+            )
+            for coefficient_index, value in enumerate(
+                _sequence(raw_coefficients, f"{context} direct coefficients")
+            )
+        )
+    )
+    return _ExactClosureRow(
+        kernel_id=_integer(values[0], f"{context} kernel"),
+        left_value_slot_id=_integer(values[1], f"{context} left value"),
+        right_value_slot_id=_integer(values[2], f"{context} right value"),
+        amplitude_index=_integer(values[3], f"{context} amplitude"),
+        coupling_slot_id=_integer(values[4], f"{context} coupling"),
+        output_factor_source=_integer(values[5], f"{context} output factor source"),
+        factor=_parse_factor_product(values[6], values[7], f"{context} factor"),
+        direct_coefficients=coefficients,
+        coherent_group_id=_integer(values[9], f"{context} coherent group"),
+        selector_domain_id=_integer(values[10], f"{context} selector domain"),
+    )
+
+
+def _parse_factor_product(
+    raw_numerators: object,
+    raw_denominator: object,
+    context: str,
+) -> _ExactComplexProduct:
+    numerators = []
+    for index, raw in enumerate(_sequence(raw_numerators, f"{context} numerators")):
+        values = _row(raw, 2, f"{context} numerator {index}")
+        numerators.append(
+            _complex_pair(values[0], values[1], f"{context} numerator {index}")
+        )
+    if not numerators:
+        raise ArtifactError(f"{context} must contain at least one numerator")
+    denominator = None
+    if raw_denominator is not None:
+        values = _row(raw_denominator, 2, f"{context} denominator")
+        denominator = _complex_pair(values[0], values[1], f"{context} denominator")
+    return _ExactComplexProduct(tuple(numerators), denominator)
+
+
+def _parse_stages(
+    raw_stages: object,
+    invocations: tuple[_ExactInvocationRow, ...],
+    attachments: tuple[_ExactAttachmentRow, ...],
+    finalizations: tuple[_ExactFinalizationRow, ...],
+) -> tuple[_ExactStageV3, ...]:
+    stages = []
+    invocation_cursor = 0
+    attachment_cursor = 0
+    finalization_cursor = 0
+    previous_stage = -1
+    for index, raw in enumerate(_sequence(raw_stages, "compact eager stages")):
+        context = f"compact eager stage {index}"
+        values = _row(raw, 7, context)
+        stage_index = _integer(values[0], f"{context} index")
+        if stage_index <= previous_stage:
+            raise ArtifactError("compact eager stage indices must increase")
+        previous_stage = stage_index
+
+        invocation_start = _integer(values[1], f"{context} start")
+        invocation_count = _integer(values[2], f"{context} count")
+        if (
+            invocation_start != invocation_cursor
+            or invocation_start + invocation_count > len(invocations)
+        ):
+            raise ArtifactError(f"{context} has a non-contiguous table range")
+        invocation_cursor = invocation_start + invocation_count
+        stage_invocation_rows = invocations[invocation_start:invocation_cursor]
+
+        attachment_start = _integer(values[3], f"{context} start")
+        attachment_count = _integer(values[4], f"{context} count")
+        if (
+            attachment_start != attachment_cursor
+            or attachment_start + attachment_count > len(attachments)
+        ):
+            raise ArtifactError(f"{context} has a non-contiguous table range")
+        attachment_cursor = attachment_start + attachment_count
+        stage_attachments = attachments[attachment_start:attachment_cursor]
+
+        finalization_start = _integer(values[5], f"{context} start")
+        finalization_count = _integer(values[6], f"{context} count")
+        if (
+            finalization_start != finalization_cursor
+            or finalization_start + finalization_count > len(finalizations)
+        ):
+            raise ArtifactError(f"{context} has a non-contiguous table range")
+        finalization_cursor = finalization_start + finalization_count
+        stage_finalizations = finalizations[
+            finalization_start:finalization_cursor
+        ]
+
+        if any(
+            invocation.attachment_start < attachment_start
+            for invocation in stage_invocation_rows
+        ):
+            raise ArtifactError(
+                f"{context} has an invocation before its attachment range"
+            )
+        stage_invocations = tuple(
+            _ExactInvocationRow(
+                invocation.kernel_id,
+                invocation.left_value_slot_id,
+                invocation.right_value_slot_id,
+                invocation.left_momentum_slot_id,
+                invocation.right_momentum_slot_id,
+                invocation.coupling_slot_id,
+                invocation.output_factor_source,
+                invocation.attachment_start - attachment_start,
+                invocation.attachment_count,
+                invocation.selector_domain_id,
+            )
+            for invocation in stage_invocation_rows
+        )
+        stages.append(
+            _ExactStageV3(
+                stage_index,
+                stage_invocations,
+                stage_attachments,
+                stage_finalizations,
+            )
+        )
+    if (
+        invocation_cursor != len(invocations)
+        or attachment_cursor != len(attachments)
+        or finalization_cursor != len(finalizations)
+    ):
+        raise ArtifactError("compact eager stages do not cover their exact tables")
+    return tuple(stages)
+
+
+def _validate_plan_v3_execution_header(execution: Mapping[str, object]) -> None:
+    from pyamplicol._internal.versions import PROCESS_ARTIFACT_SCHEMA_VERSION
+
+    if execution.get("schema_version") != PROCESS_ARTIFACT_SCHEMA_VERSION:
+        raise CompatibilityError(
+            f"unsupported eager process schema {execution.get('schema_version')!r}"
+        )
+    if execution.get("kind") != "pyamplicol-runtime-eager-execution":
+        raise CompatibilityError(
+            f"unsupported exact eager execution kind {execution.get('kind')!r}"
+        )
+    if execution.get("eager_plan_abi") != EAGER_PLAN_V3_ABI:
+        raise CompatibilityError(
+            f"unsupported eager plan ABI {execution.get('eager_plan_abi')!r}"
+        )
+    plan = _mapping(execution.get("plan"), "plan")
+    if (
+        plan.get("kind") != execution.get("kind")
+        or plan.get("eager_plan_abi") != EAGER_PLAN_V3_ABI
+        or plan.get("runtime_layout_abi") != EAGER_RUNTIME_LAYOUT_ABI
+    ):
+        raise CompatibilityError("outer and compact eager plan contracts do not match")
+    if execution.get("key") is None:
+        raise ArtifactError("compact eager execution has no process key")
+    expected = _EAGER_PLAN_V3_RUNTIME_CAPABILITIES
+    if execution.get("required_runtime_capabilities") != expected:
+        raise CompatibilityError(
+            "unsupported compact eager runtime capability contract"
+        )
+    if plan.get("required_runtime_capabilities") != expected:
+        raise CompatibilityError("unsupported compact eager plan capability contract")
+
+
+__all__ = [
+    "EAGER_EXACT_SECTIONS_ABI",
+    "EAGER_PLAN_V3_ABI",
+    "EAGER_PLAN_V3_RUNTIME_CAPABILITY",
+    "EAGER_RUNTIME_LAYOUT_ABI",
+]
diff --git a/pyamplicol/src/pyamplicol/runtime/recurrence_exact/__init__.py b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/__init__.py
new file mode 100644
index 0000000000..4f8f0fd085
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/__init__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact and high-precision execution of compact recurrence artifacts."""
+
+from ._executor import RecurrenceExactExecutor
+
+__all__ = ["RecurrenceExactExecutor"]
diff --git a/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_color.py b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_color.py
new file mode 100644
index 0000000000..588fed2cb1
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_color.py
@@ -0,0 +1,928 @@
+# SPDX-License-Identifier: 0BSD
+"""Authenticated compact color contraction for exact recurrence execution."""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import struct
+from collections.abc import Iterator, Mapping, Sequence
+from dataclasses import dataclass
+from decimal import Decimal
+from pathlib import Path, PurePosixPath
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+from pyamplicol.artifacts.manifest import ArtifactManifest, PayloadRecord
+from pyamplicol.artifacts.security import confined_path, normalize_relative_path
+from pyamplicol.color.symmetric_group import (
+    _inverse_permutation,
+    _lexicographic_permutation_rank,
+    _LexicographicPermutations,
+    _relative_permutation,
+)
+from pyamplicol.runtime.eager_exact._contracts import _mapping
+
+RECURRENCE_COLOR_CONTRACTION_CODEC_ABI = "pyamplicol-recurrence-color-contraction-v3"
+RECURRENCE_CONTRACTED_COLOR_CAPABILITY = "rusticol.recurrence-color.contracted.v1"
+
+_MAGIC = b"PACRCLR3"
+_VERSION = 3
+_STORAGE_EXPANDED = 1
+_STORAGE_REPEATED = 2
+_STORAGE_CONVOLUTION_KERNELS = 3
+_ACCURACY = {1: "nlc", 2: "full"}
+_FACTOR_NONE = 0
+_FACTOR_KLEIN_FOUR = 1
+_FACTOR_ELEMENTARY_ABELIAN = 2
+_FACTOR_SYMMETRIC_GROUP_FOURIER = 3
+_FLAG_INCLUDES_COLOR_FACTOR = 1 << 0
+_KNOWN_FLAGS = _FLAG_INCLUDES_COLOR_FACTOR
+_MAX_FACTOR_RANK = 31  # 2**rank must fit the u32 local-group count.
+_ZERO_SECTOR_OWNER = 0xFFFF_FFFF
+_HEADER = struct.Struct("<8s14I7Q")
+_ENTRY = struct.Struct("<IIdddI")
+_EXACT_FACTOR_BYTES = 64
+_U32 = struct.Struct("<I")
+
+
+@dataclass(frozen=True, slots=True)
+class _RawColorEntry:
+    left_group_id: int
+    right_group_id: int
+    weight_re: float
+    weight_im: float
+    symmetry_factor: float
+    exact_factor_id: int
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactColorFactor:
+    real_numerator: int
+    real_denominator: int
+    imag_numerator: int
+    imag_denominator: int
+
+    def decimal(self) -> tuple[Decimal, Decimal]:
+        return (
+            Decimal(self.real_numerator) / Decimal(self.real_denominator),
+            Decimal(self.imag_numerator) / Decimal(self.imag_denominator),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactColorEntry:
+    left_group_id: int
+    right_group_id: int
+    left_destination_id: int
+    right_destination_id: int
+    component_id: int
+    coefficient_re: Decimal
+    coefficient_im: Decimal
+
+
+@dataclass(frozen=True, slots=True)
+class _RecurrenceColorContraction:
+    color_accuracy: str
+    storage: str
+    includes_color_factor: bool
+    group_count: int
+    sector_count: int
+    component_count: int
+    local_group_count: int
+    destination_count: int
+    entries: tuple[_RawColorEntry, ...]
+    exact_factors: tuple[_ExactColorFactor, ...]
+    ordered_group_ids: tuple[int, ...]
+    destination_by_group: tuple[int, ...]
+    group_sector_ids: tuple[int, ...]
+    group_component_ids: tuple[int, ...]
+    owner_by_sector: tuple[int, ...]
+    logical_entry_count: int
+    factorization_kind: str | None
+    factorization_rank: int
+    factorization_coset_count: int
+
+    def runtime_entries(self) -> Iterator[_ExactColorEntry]:
+        """Yield the symmetry-folded rows represented by the compact payload."""
+
+        if self.storage == "expanded":
+            for entry in self.entries:
+                yield self._runtime_entry(
+                    entry,
+                    entry.left_group_id,
+                    entry.right_group_id,
+                )
+            return
+
+        group_by_local_component = [0] * self.group_count
+        for local_group_id in range(self.local_group_count):
+            start = local_group_id * self.component_count
+            for group_id in self.ordered_group_ids[
+                start : start + self.component_count
+            ]:
+                component_id = self.group_component_ids[group_id]
+                group_by_local_component[
+                    local_group_id * self.component_count + component_id
+                ] = group_id
+        if self.storage == "convolution-kernels":
+            # Exact coefficients are retained in the FFT payload. Expand only
+            # the iteration, not a dense matrix or a floating-point transform.
+            for entry, left, right in self._convolution_entries():
+                for component in range(self.component_count):
+                    yield self._runtime_entry(
+                        entry,
+                        group_by_local_component[
+                            left * self.component_count + component
+                        ],
+                        group_by_local_component[
+                            right * self.component_count + component
+                        ],
+                    )
+            return
+        for component in range(self.component_count):
+            for entry in self.entries:
+                left_index = entry.left_group_id * self.component_count + component
+                right_index = entry.right_group_id * self.component_count + component
+                yield self._runtime_entry(
+                    entry,
+                    group_by_local_component[left_index],
+                    group_by_local_component[right_index],
+                )
+
+    def _convolution_entries(self) -> Iterator[tuple[_RawColorEntry, int, int]]:
+        permutations = _LexicographicPermutations(self.factorization_rank)
+        order = len(permutations)
+        offset = 0
+        for left_channel in range(self.factorization_coset_count):
+            for right_channel in range(left_channel, self.factorization_coset_count):
+                for left_index, left in enumerate(permutations):
+                    for right_index, right in enumerate(permutations):
+                        relative = _lexicographic_permutation_rank(
+                            _relative_permutation(left, right)
+                        )
+                        # Same-channel kernels have weight one and use every
+                        # ordered pair. Cross-channel kernels already include
+                        # weight two for their implicit Hermitian partner.
+                        yield (
+                            self.entries[offset + relative],
+                            left_channel * order + left_index,
+                            right_channel * order + right_index,
+                        )
+                offset += order
+        for entry in self.entries[offset:]:
+            yield entry, entry.left_group_id, entry.right_group_id
+
+    def _runtime_entry(
+        self,
+        entry: _RawColorEntry,
+        left_group_id: int,
+        right_group_id: int,
+    ) -> _ExactColorEntry:
+        left_component = self.group_component_ids[left_group_id]
+        right_component = self.group_component_ids[right_group_id]
+        if left_component != right_component:
+            raise ArtifactError(
+                "recurrence color contraction mixes resolved components"
+            )
+        try:
+            coefficient_re, coefficient_im = self.exact_factors[
+                entry.exact_factor_id
+            ].decimal()
+        except IndexError as exc:
+            raise ArtifactError(
+                "recurrence color entry references an unknown exact coefficient"
+            ) from exc
+        return _ExactColorEntry(
+            left_group_id=left_group_id,
+            right_group_id=right_group_id,
+            left_destination_id=self.destination_by_group[left_group_id],
+            right_destination_id=self.destination_by_group[right_group_id],
+            component_id=left_component,
+            coefficient_re=coefficient_re,
+            coefficient_im=coefficient_im,
+        )
+
+
+def _load_recurrence_color_contraction(
+    *,
+    artifact_root: Path,
+    process_id: str,
+    execution_path: str,
+    execution: Mapping[str, object],
+    manifest: ArtifactManifest,
+) -> _RecurrenceColorContraction | None:
+    metadata = _mapping(execution.get("runtime_metadata"), "runtime metadata")
+    raw_reference = metadata.get("color_contraction")
+    if raw_reference is None:
+        return None
+    reference = _mapping(raw_reference, "recurrence color-contraction reference")
+    if reference.get("abi") != RECURRENCE_COLOR_CONTRACTION_CODEC_ABI:
+        raise CompatibilityError(
+            "unsupported recurrence color-contraction payload contract"
+        )
+    if reference.get("path") != "recurrence-color.bin":
+        raise CompatibilityError(
+            "unsupported recurrence color-contraction payload path"
+        )
+
+    logical_path = normalize_relative_path(
+        (
+            PurePosixPath(normalize_relative_path(execution_path)).parent
+            / "recurrence-color.bin"
+        ).as_posix()
+    )
+    record = _payload_record(manifest, logical_path, process_id)
+    declared_size = _nonnegative_integer(
+        reference.get("size_bytes"), "color-contraction payload size"
+    )
+    declared_sha = _digest(reference.get("sha256"), "color-contraction payload SHA-256")
+    semantic_digest = _digest(
+        reference.get("semantic_digest"),
+        "color-contraction semantic digest",
+    )
+    if (
+        record.role != "evaluator-state"
+        or record.media_type != "application/octet-stream"
+        or record.process_id != process_id
+        or record.size_bytes != declared_size
+        or record.sha256 != declared_sha
+        or semantic_digest != declared_sha
+    ):
+        raise ArtifactError(
+            "recurrence color-contraction payload disagrees with execution metadata"
+        )
+    try:
+        payload = confined_path(artifact_root, logical_path).read_bytes()
+    except OSError as exc:
+        raise ArtifactError(
+            f"could not read recurrence color-contraction payload: {exc}"
+        ) from exc
+    if (
+        len(payload) != declared_size
+        or hashlib.sha256(payload).hexdigest() != declared_sha
+    ):
+        raise ArtifactError(
+            "recurrence color-contraction payload authentication failed"
+        )
+
+    contraction = _decode_recurrence_color_contraction(payload)
+    expected = {
+        "color_accuracy": contraction.color_accuracy,
+        "storage": contraction.storage,
+        "includes_color_factor": contraction.includes_color_factor,
+        "group_count": contraction.group_count,
+        "sector_count": contraction.sector_count,
+        "active_sector_count": sum(
+            owner == sector for sector, owner in enumerate(contraction.owner_by_sector)
+        ),
+        "component_count": contraction.component_count,
+        "destination_count": contraction.destination_count,
+        "entry_count": len(contraction.entries),
+        "logical_entry_count": contraction.logical_entry_count,
+    }
+    for name, value in expected.items():
+        if reference.get(name) != value:
+            raise ArtifactError(
+                "recurrence color-contraction payload disagrees with its "
+                f"bounded summary field {name!r}"
+            )
+    factorization = reference.get("factorization")
+    expected_factorization: object
+    if contraction.factorization_kind is None:
+        expected_factorization = None
+    else:
+        expected_factorization = {
+            "kind": contraction.factorization_kind,
+            "rank": contraction.factorization_rank,
+            "coset_count": contraction.factorization_coset_count,
+        }
+    if factorization != expected_factorization:
+        raise ArtifactError(
+            "recurrence color-contraction factorization disagrees with its "
+            "bounded summary"
+        )
+    if not contraction.includes_color_factor:
+        raise ArtifactError(
+            "NLC/full recurrence color contraction must include the color factor"
+        )
+    return contraction
+
+
+def _decode_recurrence_color_contraction(
+    payload: bytes,
+) -> _RecurrenceColorContraction:
+    if len(payload) < _HEADER.size:
+        raise ArtifactError("recurrence color-contraction payload is truncated")
+    (
+        magic,
+        version,
+        header_size,
+        storage_id,
+        accuracy_id,
+        flags,
+        group_count,
+        sector_count,
+        component_count,
+        local_group_count,
+        destination_count,
+        factor_kind,
+        factor_rank,
+        entry_stride,
+        exact_factor_stride,
+        entry_count,
+        exact_factor_count,
+        coset_count,
+        coset_index_count,
+        logical_entry_count,
+        owner_map_count,
+        payload_size,
+    ) = _HEADER.unpack_from(payload)
+    if magic != _MAGIC or version != _VERSION or header_size != _HEADER.size:
+        raise CompatibilityError(
+            "unsupported recurrence color-contraction binary header"
+        )
+    if entry_stride != _ENTRY.size or exact_factor_stride != _EXACT_FACTOR_BYTES:
+        raise ArtifactError(
+            "recurrence color-contraction fixed-width header is inconsistent"
+        )
+    if flags & ~_KNOWN_FLAGS:
+        raise ArtifactError("recurrence color-contraction payload has unknown flags")
+    try:
+        accuracy = _ACCURACY[accuracy_id]
+    except KeyError as exc:
+        raise ArtifactError(
+            "recurrence color-contraction payload has invalid color accuracy"
+        ) from exc
+    if storage_id not in {
+        _STORAGE_EXPANDED,
+        _STORAGE_REPEATED,
+        _STORAGE_CONVOLUTION_KERNELS,
+    }:
+        raise ArtifactError("recurrence color-contraction payload has invalid storage")
+    storage = {
+        _STORAGE_EXPANDED: "expanded",
+        _STORAGE_REPEATED: "repeated",
+        _STORAGE_CONVOLUTION_KERNELS: "convolution-kernels",
+    }[storage_id]
+    if min(group_count, sector_count, component_count, destination_count) <= 0:
+        raise ArtifactError("recurrence color-contraction dimensions must be positive")
+    if owner_map_count != sector_count:
+        raise ArtifactError(
+            "recurrence color-contraction owner map count disagrees with sector_count"
+        )
+    expected_payload_size = (
+        entry_count * _ENTRY.size
+        + exact_factor_count * _EXACT_FACTOR_BYTES
+        + 4 * group_count * _U32.size
+        + owner_map_count * _U32.size
+        + coset_index_count * _U32.size
+    )
+    if (
+        payload_size != expected_payload_size
+        or len(payload) != _HEADER.size + payload_size
+    ):
+        raise ArtifactError("recurrence color-contraction payload size is inconsistent")
+
+    entry_domain = group_count if storage == "expanded" else local_group_count
+    entries = []
+    seen_pairs = set()
+    offset = _HEADER.size
+    for index in range(entry_count):
+        raw = _RawColorEntry(*_ENTRY.unpack_from(payload, offset))
+        offset += _ENTRY.size
+        pair = (raw.left_group_id, raw.right_group_id)
+        if (
+            raw.left_group_id >= entry_domain
+            or raw.right_group_id >= entry_domain
+            or raw.left_group_id > raw.right_group_id
+            or pair in seen_pairs
+        ):
+            raise ArtifactError(
+                f"recurrence color-contraction entry {index} is not canonical"
+            )
+        seen_pairs.add(pair)
+        if not all(
+            math.isfinite(value)
+            for value in (raw.weight_re, raw.weight_im, raw.symmetry_factor)
+        ) or not all(
+            math.isfinite(raw.symmetry_factor * value)
+            for value in (raw.weight_re, raw.weight_im)
+        ):
+            raise ArtifactError(
+                f"recurrence color-contraction entry {index} is not finite"
+            )
+        entries.append(raw)
+
+    exact_factors = []
+    for index in range(exact_factor_count):
+        values = []
+        for _ in range(4):
+            stop = offset + 16
+            if stop > len(payload):
+                raise ArtifactError(
+                    "recurrence color-contraction exact factor catalog is truncated"
+                )
+            values.append(
+                int.from_bytes(payload[offset:stop], byteorder="little", signed=True)
+            )
+            offset = stop
+        factor = _ExactColorFactor(*values)
+        _validate_exact_factor(factor, index)
+        exact_factors.append(factor)
+    if any(entry.exact_factor_id >= len(exact_factors) for entry in entries):
+        raise ArtifactError(
+            "recurrence color entry references an out-of-bounds exact coefficient"
+        )
+    for index, entry in enumerate(entries):
+        factor = exact_factors[entry.exact_factor_id]
+        expected_re = factor.real_numerator / factor.real_denominator
+        expected_im = factor.imag_numerator / factor.imag_denominator
+        for component, actual, expected in (
+            (
+                "real",
+                entry.weight_re * entry.symmetry_factor,
+                expected_re,
+            ),
+            (
+                "imaginary",
+                entry.weight_im * entry.symmetry_factor,
+                expected_im,
+            ),
+        ):
+            if not math.isclose(
+                actual,
+                expected,
+                rel_tol=0.0,
+                abs_tol=max(math.ulp(actual), math.ulp(expected)),
+            ):
+                raise ArtifactError(
+                    f"recurrence color entry {index} {component} f64 coefficient "
+                    "disagrees with its exact factor"
+                )
+
+    ordered_groups, offset = _read_u32_array(
+        payload, offset, group_count, "ordered group map"
+    )
+    destinations, offset = _read_u32_array(
+        payload, offset, group_count, "destination map"
+    )
+    group_sector_ids, offset = _read_u32_array(
+        payload, offset, group_count, "group sector map"
+    )
+    group_component_ids, offset = _read_u32_array(
+        payload, offset, group_count, "group component map"
+    )
+    owner_by_sector, offset = _read_u32_array(
+        payload, offset, owner_map_count, "physical sector owner map"
+    )
+    coset_indices, offset = _read_u32_array(
+        payload, offset, coset_index_count, "factorization cosets"
+    )
+    if offset != len(payload):
+        raise ArtifactError(
+            "recurrence color-contraction payload contains trailing bytes"
+        )
+    _validate_permutation(ordered_groups, group_count, "ordered group map")
+    if len(set(destinations)) != len(destinations) or any(
+        value >= destination_count for value in destinations
+    ):
+        raise ArtifactError(
+            "recurrence color-contraction destination map is not injective"
+        )
+    _validate_group_coordinates(
+        group_count=group_count,
+        sector_count=sector_count,
+        component_count=component_count,
+        group_sector_ids=group_sector_ids,
+        group_component_ids=group_component_ids,
+    )
+    _validate_sector_owners(
+        sector_count=sector_count,
+        owner_by_sector=owner_by_sector,
+        active_sector_ids=set(group_sector_ids),
+    )
+
+    factorization_kind = None
+    if storage == "expanded":
+        if (
+            local_group_count != 0
+            or factor_kind != _FACTOR_NONE
+            or factor_rank != 0
+            or coset_count != 0
+            or coset_indices
+            or logical_entry_count != entry_count
+        ):
+            raise ArtifactError(
+                "expanded recurrence color storage carries repeated metadata"
+            )
+        if any(
+            group_component_ids[entry.left_group_id]
+            != group_component_ids[entry.right_group_id]
+            for entry in entries
+        ):
+            raise ArtifactError(
+                "expanded recurrence color entry mixes helicity components"
+            )
+    else:
+        if (
+            (component_count < 2 and storage == "repeated")
+            or local_group_count * component_count != group_count
+            or logical_entry_count != entry_count * component_count
+        ):
+            raise ArtifactError("repeated recurrence color dimensions are inconsistent")
+        _validate_repeated_group_coordinates(
+            ordered_group_ids=ordered_groups,
+            group_sector_ids=group_sector_ids,
+            group_component_ids=group_component_ids,
+            sector_count=sector_count,
+            component_count=component_count,
+            local_group_count=local_group_count,
+        )
+        if storage == "convolution-kernels":
+            _validate_symmetric_group_convolution(
+                factor_kind,
+                factor_rank,
+                coset_count,
+                coset_indices,
+                local_group_count,
+                entries,
+                exact_factors,
+            )
+            factorization_kind = "symmetric-group-fourier"
+        else:
+            _validate_factorization(
+                factor_kind=factor_kind,
+                factor_rank=factor_rank,
+                coset_count=coset_count,
+                coset_indices=coset_indices,
+                local_group_count=local_group_count,
+                entries=entries,
+            )
+            factorization_kind = (
+                "klein-four-walsh"
+                if factor_kind == _FACTOR_KLEIN_FOUR
+                else "elementary-abelian-walsh"
+                if factor_kind == _FACTOR_ELEMENTARY_ABELIAN
+                else None
+            )
+
+    return _RecurrenceColorContraction(
+        color_accuracy=accuracy,
+        storage=storage,
+        includes_color_factor=bool(flags & _FLAG_INCLUDES_COLOR_FACTOR),
+        group_count=group_count,
+        sector_count=sector_count,
+        component_count=component_count,
+        local_group_count=local_group_count,
+        destination_count=destination_count,
+        entries=tuple(entries),
+        exact_factors=tuple(exact_factors),
+        ordered_group_ids=ordered_groups,
+        destination_by_group=destinations,
+        group_sector_ids=group_sector_ids,
+        group_component_ids=group_component_ids,
+        owner_by_sector=owner_by_sector,
+        logical_entry_count=logical_entry_count,
+        factorization_kind=factorization_kind,
+        factorization_rank=factor_rank,
+        factorization_coset_count=coset_count,
+    )
+
+
+def _contract_color_amplitudes(
+    contraction: _RecurrenceColorContraction,
+    amplitudes: Sequence[tuple[Decimal, Decimal]],
+    destination_physics_helicity: Sequence[int],
+    selected_helicities: set[int] | None = None,
+) -> dict[int, Decimal]:
+    if (
+        len(amplitudes) != contraction.destination_count
+        or len(destination_physics_helicity) != contraction.destination_count
+    ):
+        raise ArtifactError(
+            "recurrence color contraction does not match amplitude destinations"
+        )
+    result: dict[int, Decimal] = {}
+    physics_helicity_by_component: dict[int, int] = {}
+    for entry in contraction.runtime_entries():
+        left_helicity = destination_physics_helicity[entry.left_destination_id]
+        right_helicity = destination_physics_helicity[entry.right_destination_id]
+        if left_helicity != right_helicity:
+            raise ArtifactError("recurrence color contraction mixes public helicities")
+        known_helicity = physics_helicity_by_component.setdefault(
+            entry.component_id, left_helicity
+        )
+        if known_helicity != left_helicity:
+            raise ArtifactError(
+                "recurrence color component maps to inconsistent public helicities"
+            )
+        if selected_helicities is not None and left_helicity not in selected_helicities:
+            continue
+        left_re, left_im = amplitudes[entry.left_destination_id]
+        right_re, right_im = amplitudes[entry.right_destination_id]
+        product_re = left_re * right_re + left_im * right_im
+        product_im = left_im * right_re - left_re * right_im
+        value = entry.coefficient_re * product_re - entry.coefficient_im * product_im
+        result[left_helicity] = result.get(left_helicity, Decimal(0)) + value
+    return result
+
+
+def _payload_record(
+    manifest: ArtifactManifest,
+    path: str,
+    process_id: str,
+) -> PayloadRecord:
+    matches = tuple(record for record in manifest.payloads if record.path == path)
+    if len(matches) != 1:
+        raise ArtifactError(
+            "recurrence color-contraction payload is not uniquely declared"
+        )
+    record = matches[0]
+    if record.process_id != process_id:
+        raise ArtifactError(
+            "recurrence color-contraction payload selects the wrong process"
+        )
+    return record
+
+
+def _read_u32_array(
+    payload: bytes,
+    offset: int,
+    count: int,
+    label: str,
+) -> tuple[tuple[int, ...], int]:
+    stop = offset + count * _U32.size
+    if stop > len(payload):
+        raise ArtifactError(f"recurrence color-contraction {label} is truncated")
+    return (
+        tuple(
+            _U32.unpack_from(payload, offset + index * _U32.size)[0]
+            for index in range(count)
+        ),
+        stop,
+    )
+
+
+def _validate_permutation(values: Sequence[int], count: int, label: str) -> None:
+    if len(values) != count or sorted(values) != list(range(count)):
+        raise ArtifactError(
+            f"recurrence color-contraction {label} is not a complete permutation"
+        )
+
+
+def _validate_group_coordinates(
+    *,
+    group_count: int,
+    sector_count: int,
+    component_count: int,
+    group_sector_ids: Sequence[int],
+    group_component_ids: Sequence[int],
+) -> None:
+    if (
+        len(group_sector_ids) != group_count
+        or len(group_component_ids) != group_count
+        or any(value >= sector_count for value in group_sector_ids)
+        or any(value >= component_count for value in group_component_ids)
+    ):
+        raise ArtifactError(
+            "recurrence color-contraction group coordinates are out of bounds"
+        )
+    coordinates = tuple(zip(group_sector_ids, group_component_ids, strict=True))
+    if len(set(coordinates)) != group_count:
+        raise ArtifactError(
+            "recurrence color-contraction group coordinates are not unique"
+        )
+
+
+def _validate_exact_factor(factor: _ExactColorFactor, index: int) -> None:
+    for label, numerator, denominator in (
+        ("real", factor.real_numerator, factor.real_denominator),
+        ("imaginary", factor.imag_numerator, factor.imag_denominator),
+    ):
+        if denominator <= 0:
+            raise ArtifactError(
+                f"recurrence exact color factor {index} has a non-positive "
+                f"{label} denominator"
+            )
+        if numerator == 0 and denominator != 1:
+            raise ArtifactError(
+                f"recurrence exact color factor {index} has a non-canonical "
+                f"zero {label} component"
+            )
+        if math.gcd(abs(numerator), denominator) != 1:
+            raise ArtifactError(
+                f"recurrence exact color factor {index} has a reducible "
+                f"{label} component"
+            )
+
+
+def _validate_sector_owners(
+    *,
+    sector_count: int,
+    owner_by_sector: Sequence[int],
+    active_sector_ids: set[int],
+) -> None:
+    if len(owner_by_sector) != sector_count:
+        raise ArtifactError("recurrence physical-sector owner map has the wrong length")
+    fixed_points: set[int] = set()
+    for sector_id, owner_id in enumerate(owner_by_sector):
+        if owner_id == _ZERO_SECTOR_OWNER:
+            continue
+        if (
+            owner_id >= sector_count
+            or owner_id > sector_id
+            or owner_by_sector[owner_id] != owner_id
+        ):
+            raise ArtifactError(
+                f"recurrence physical sector {sector_id} has an invalid owner"
+            )
+        if owner_id == sector_id:
+            fixed_points.add(sector_id)
+    if fixed_points != active_sector_ids:
+        raise ArtifactError(
+            "recurrence active sectors do not match the authenticated owner map"
+        )
+
+
+def _validate_repeated_group_coordinates(
+    *,
+    ordered_group_ids: Sequence[int],
+    group_sector_ids: Sequence[int],
+    group_component_ids: Sequence[int],
+    sector_count: int,
+    component_count: int,
+    local_group_count: int,
+) -> None:
+    expected_components = set(range(component_count))
+    row_sectors: list[int] = []
+    for local_group_id in range(local_group_count):
+        start = local_group_id * component_count
+        row = ordered_group_ids[start : start + component_count]
+        sectors = {group_sector_ids[group_id] for group_id in row}
+        components = {group_component_ids[group_id] for group_id in row}
+        if len(sectors) != 1 or components != expected_components:
+            raise ArtifactError(
+                "repeated recurrence color row does not cover one physical "
+                "sector and every component exactly once"
+            )
+        row_sectors.append(next(iter(sectors)))
+    if len(set(row_sectors)) != len(row_sectors) or any(
+        sector_id >= sector_count for sector_id in row_sectors
+    ):
+        raise ArtifactError(
+            "repeated recurrence color rows do not identify unique physical sectors"
+        )
+
+
+def _validate_symmetric_group_convolution(
+    factor_kind: int,
+    degree: int,
+    channel_count: int,
+    channel_indices: Sequence[int],
+    local_group_count: int,
+    entries: Sequence[_RawColorEntry],
+    factors: Sequence[_ExactColorFactor],
+) -> None:
+    if factor_kind != _FACTOR_SYMMETRIC_GROUP_FOURIER or not 2 <= degree <= 10:
+        raise ArtifactError(
+            "convolution color storage requires symmetric-group metadata"
+        )
+    order = math.factorial(degree)
+    eligible = channel_count * order
+    if (
+        channel_count <= 0
+        or eligible > local_group_count
+        or tuple(channel_indices) != tuple(range(eligible))
+    ):
+        raise ArtifactError("symmetric-group channel coordinates are inconsistent")
+    kernel_count = channel_count * (channel_count + 1) // 2 * order
+    residual_count = (
+        local_group_count * (local_group_count + 1) - eligible * (eligible + 1)
+    ) // 2
+    if len(entries) != kernel_count + residual_count:
+        raise ArtifactError("symmetric-group kernel/residual row count is inconsistent")
+    offset = 0
+    for left in range(channel_count):
+        for right in range(left, channel_count):
+            for relative, permutation in enumerate(_LexicographicPermutations(degree)):
+                entry = entries[offset + relative]
+                if (entry.left_group_id, entry.right_group_id) != (
+                    left * order,
+                    right * order + relative,
+                ) or entry.symmetry_factor != (1.0 if left == right else 2.0):
+                    raise ArtifactError("symmetric-group kernel rows are not canonical")
+                if left == right:
+                    inverse = _lexicographic_permutation_rank(
+                        _inverse_permutation(permutation)
+                    )
+                    if (
+                        factors[entry.exact_factor_id]
+                        != factors[entries[offset + inverse].exact_factor_id]
+                    ):
+                        raise ArtifactError(
+                            "symmetric-group diagonal kernel is not Hermitian"
+                        )
+            offset += order
+    for left in range(local_group_count):
+        for right in range(max(left, eligible), local_group_count):
+            entry = entries[offset]
+            if (entry.left_group_id, entry.right_group_id) != (
+                left,
+                right,
+            ) or entry.symmetry_factor != (1.0 if left == right else 2.0):
+                raise ArtifactError("symmetric-group residual rows are not canonical")
+            offset += 1
+    if any(factors[entry.exact_factor_id].imag_numerator != 0 for entry in entries):
+        raise ArtifactError("symmetric-group color kernels require real coefficients")
+
+
+def _validate_factorization(
+    *,
+    factor_kind: int,
+    factor_rank: int,
+    coset_count: int,
+    coset_indices: Sequence[int],
+    local_group_count: int,
+    entries: Sequence[_RawColorEntry],
+) -> None:
+    if factor_kind == _FACTOR_NONE:
+        if factor_rank != 0 or coset_count != 0 or coset_indices:
+            raise ArtifactError("recurrence color factorization-none carries metadata")
+        return
+    if factor_kind == _FACTOR_KLEIN_FOUR:
+        if factor_rank != 2:
+            raise ArtifactError("Klein-four color factorization must have rank two")
+    elif factor_kind == _FACTOR_ELEMENTARY_ABELIAN:
+        if not 3 <= factor_rank <= _MAX_FACTOR_RANK:
+            raise ArtifactError(
+                "elementary-Abelian color factorization has invalid rank"
+            )
+    else:
+        raise ArtifactError("recurrence color factorization kind is unsupported")
+    subgroup_order = 1 << factor_rank
+    if (
+        coset_count <= 0
+        or coset_count * subgroup_order != len(coset_indices)
+        or len(coset_indices) != local_group_count
+    ):
+        raise ArtifactError(
+            "recurrence color factorization coset shape is inconsistent"
+        )
+    _validate_permutation(coset_indices, local_group_count, "factorization cosets")
+    matrix = {}
+    for entry in entries:
+        if entry.weight_im != 0.0:
+            raise ArtifactError(
+                "factorized recurrence color contraction requires real weights"
+            )
+        coefficient = entry.weight_re * entry.symmetry_factor
+        if entry.left_group_id != entry.right_group_id:
+            coefficient *= 0.5
+        matrix[(entry.left_group_id, entry.right_group_id)] = coefficient
+
+    def matrix_value(left: int, right: int) -> float:
+        return matrix.get((min(left, right), max(left, right)), 0.0)
+
+    for left_coset_index in range(coset_count):
+        left_start = left_coset_index * subgroup_order
+        left_coset = coset_indices[left_start : left_start + subgroup_order]
+        for right_coset_index in range(coset_count):
+            right_start = right_coset_index * subgroup_order
+            right_coset = coset_indices[right_start : right_start + subgroup_order]
+            for left_index in range(subgroup_order):
+                for right_index in range(subgroup_order):
+                    if matrix_value(
+                        left_coset[left_index],
+                        right_coset[right_index],
+                    ) != matrix_value(
+                        left_coset[0],
+                        right_coset[left_index ^ right_index],
+                    ):
+                        raise ArtifactError(
+                            "recurrence color factorization is not Walsh-invariant"
+                        )
+
+
+def _digest(value: object, context: str) -> str:
+    if (
+        not isinstance(value, str)
+        or len(value) != 64
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise ArtifactError(f"{context} must be a lowercase SHA-256 digest")
+    return value
+
+
+def _nonnegative_integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise ArtifactError(f"{context} must be a non-negative integer")
+    return value
+
+
+__all__ = [
+    "RECURRENCE_CONTRACTED_COLOR_CAPABILITY",
+    "_RecurrenceColorContraction",
+    "_contract_color_amplitudes",
+    "_decode_recurrence_color_contraction",
+    "_load_recurrence_color_contraction",
+]
diff --git a/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_execution.py b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_execution.py
new file mode 100644
index 0000000000..29afcfbed4
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_execution.py
@@ -0,0 +1,1176 @@
+# SPDX-License-Identifier: 0BSD
+"""Decimal/Symbolica execution of one authenticated Direct-Arena plan."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import Any
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError, EvaluationError
+from pyamplicol.runtime.eager_exact._contracts import (
+    _complex_add,
+    _complex_mul,
+    _complex_zero,
+)
+from pyamplicol.runtime.symbolica_exact import (
+    _antiquark_dirac,
+    _antiquark_weyl,
+    _ComplexDecimal,
+    _massive_vector,
+    _massless_vector,
+    _quark_dirac,
+    _quark_weyl,
+    _spin2,
+)
+
+from ._plan import _RecurrenceExactPlan, _SourceTemplate
+from ._plan_v2 import (
+    DIRECT_NONE_U32,
+    _Closure,
+    _Contribution,
+    _Current,
+    _Executor,
+    _Finalization,
+    _ReplayTarget,
+    _ResolvedHelicity,
+    _Source,
+    _SourceDispatchVariant,
+)
+
+_ZERO = Decimal(0)
+_ONE = Decimal(1)
+_ROLE_SOURCE = 0
+_ROLE_CONTRIBUTION = 1
+_ROLE_FINALIZATION = 2
+_ROLE_CLOSURE = 3
+_NODE_CURRENT = 1
+_CONTRIBUTION_FLAG_INITIALIZE_DESTINATION = 1 << 0
+_CONTRIBUTION_FLAG_CERTIFIED_REUSE = 1 << 1
+_CERTIFIED_REUSE_FLAGS = (
+    _CONTRIBUTION_FLAG_INITIALIZE_DESTINATION | _CONTRIBUTION_FLAG_CERTIFIED_REUSE
+)
+
+_Point = Sequence[tuple[Decimal, Decimal, Decimal, Decimal]]
+_CurrentObserver = Callable[[int, tuple[_ComplexDecimal, ...]], None]
+_FactorCache = list[_ComplexDecimal | None]
+
+_INPUT_CURRENT = 0
+_INPUT_MOMENTUM = 1
+_INPUT_PARAMETER = 2
+_INPUT_CONSTANT = 3
+
+
+@dataclass(frozen=True, slots=True)
+class _TrustedInputRecipe:
+    kind: int
+    index: int
+    component: int
+    constant: _ComplexDecimal | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class _TrustedExecutorRecipe:
+    kernel: Any
+    inputs: tuple[_TrustedInputRecipe, ...]
+
+
+def _evaluate_replay_point(
+    plan: _RecurrenceExactPlan,
+    point: _Point,
+    target: _ReplayTarget,
+    prepared_parameters: Sequence[_ComplexDecimal],
+    precision: int,
+    *,
+    current_observer: _CurrentObserver | None = None,
+) -> tuple[_ComplexDecimal, ...]:
+    sections = plan.sections
+    permutation = sections.source_permutations[
+        target.source_permutation_start : target.source_permutation_start
+        + target.source_permutation_count
+    ]
+    if len(permutation) != sections.external_source_count:
+        raise ArtifactError("recurrence replay permutation has invalid width")
+    momentum_signs = sections.replay_momentum_signs[
+        target.source_permutation_start : target.source_permutation_start
+        + target.source_permutation_count
+    ]
+    if len(momentum_signs) != sections.external_source_count:
+        raise ArtifactError("recurrence replay momentum-sign map has invalid width")
+    momenta = _momentum_forms(plan, point, permutation, momentum_signs)
+    amplitudes = list(
+        _execute_schedule(
+            plan,
+            momenta,
+            prepared_parameters,
+            precision,
+            selected_source_variants=None,
+            current_observer=current_observer,
+        )
+    )
+
+    replay_factor = _complex_mul(
+        _factor(plan, target.phase_factor_id),
+        (Decimal(target.multiplicity), _ZERO),
+    )
+    for destination in sections.amplitude_destinations:
+        if destination.target_sector_id == target.representative_id:
+            amplitudes[destination.destination_id] = _complex_mul(
+                amplitudes[destination.destination_id],
+                replay_factor,
+            )
+    return tuple(amplitudes)
+
+
+def _evaluate_union_point(
+    plan: _RecurrenceExactPlan,
+    point: _Point,
+    helicity: _ResolvedHelicity,
+    prepared_parameters: Sequence[_ComplexDecimal],
+    precision: int,
+    *,
+    current_observer: _CurrentObserver | None = None,
+) -> tuple[_ComplexDecimal, ...]:
+    """Execute one all-flow union once for one runtime-selected helicity."""
+
+    sections = plan.sections
+    if sections.strategy != "all-flow-union":
+        raise ArtifactError("union exact execution requires an all-flow-union plan")
+    selections = sections.resolved_source_selections[
+        helicity.source_selection_start : helicity.source_selection_start
+        + helicity.source_selection_count
+    ]
+    if len(selections) != sections.external_source_count:
+        raise ArtifactError(
+            "all-flow-union helicity does not select every external source"
+        )
+    selected_source_variants = {}
+    for source_slot, selection in enumerate(selections):
+        if selection.source_slot != source_slot:
+            raise ArtifactError(
+                "all-flow-union source selections are not in source-slot order"
+            )
+        try:
+            variant = sections.source_dispatch_variants[selection.dispatch_variant_id]
+        except IndexError as exc:
+            raise ArtifactError(
+                "all-flow-union source selection references an absent variant"
+            ) from exc
+        try:
+            source = sections.sources[variant.source_row_id]
+        except IndexError as exc:
+            raise ArtifactError(
+                "all-flow-union source variant references an absent source row"
+            ) from exc
+        if source.source_slot != source_slot:
+            raise ArtifactError(
+                "all-flow-union source variant selects the wrong external source"
+            )
+        if variant.source_row_id in selected_source_variants:
+            raise ArtifactError(
+                "all-flow-union helicity selects one source row more than once"
+            )
+        selected_source_variants[variant.source_row_id] = variant
+    momenta = _momentum_forms(
+        plan,
+        point,
+        tuple(range(sections.external_source_count)),
+    )
+    return _execute_schedule(
+        plan,
+        momenta,
+        prepared_parameters,
+        precision,
+        selected_source_variants=selected_source_variants,
+        current_observer=current_observer,
+    )
+
+
+def _evaluate_contracted_point(
+    plan: _RecurrenceExactPlan,
+    point: _Point,
+    prepared_parameters: Sequence[_ComplexDecimal],
+    precision: int,
+    *,
+    current_observer: _CurrentObserver | None = None,
+) -> tuple[_ComplexDecimal, ...]:
+    """Execute the fixed-source contracted-color schedule once."""
+
+    sections = plan.sections
+    if sections.strategy != "contracted-color-union":
+        raise ArtifactError(
+            "contracted exact execution requires a contracted-color plan"
+        )
+    momenta = _momentum_forms(
+        plan,
+        point,
+        tuple(range(sections.external_source_count)),
+    )
+    return _execute_schedule(
+        plan,
+        momenta,
+        prepared_parameters,
+        precision,
+        selected_source_variants=None,
+        current_observer=current_observer,
+    )
+
+
+def _execute_schedule(
+    plan: _RecurrenceExactPlan,
+    momenta: Sequence[Sequence[Decimal]],
+    prepared_parameters: Sequence[_ComplexDecimal],
+    precision: int,
+    *,
+    selected_source_variants: Mapping[int, _SourceDispatchVariant] | None,
+    current_observer: _CurrentObserver | None = None,
+) -> tuple[_ComplexDecimal, ...]:
+    sections = plan.sections
+    zero = _complex_zero()
+    arena = [zero] * sections.current_arena_components
+    amplitudes = [zero] * sections.amplitude_destination_count
+    factor_cache: _FactorCache = [None] * len(sections.exact_factors)
+    initialized_contribution_stage: int | None = None
+    active_stage: int | None = None
+
+    for group in sections.row_groups:
+        if active_stage is not None and group.stage != active_stage:
+            _observe_stage_currents(
+                current_observer,
+                plan,
+                active_stage,
+                arena,
+            )
+        active_stage = group.stage
+        start = group.row_start
+        stop = start + group.row_count
+        if group.role == _ROLE_SOURCE:
+            if selected_source_variants is not None:
+                if group.executor_id != DIRECT_NONE_U32:
+                    raise ArtifactError(
+                        "all-flow-union source row group must use runtime dispatch"
+                    )
+            else:
+                executor = plan.executors.get(group.executor_id)
+                if executor is None or _role_index(executor.role) != group.role:
+                    raise ArtifactError(
+                        "recurrence source row group references invalid executor "
+                        f"{group.executor_id}"
+                    )
+            for source_row_id in range(start, stop):
+                source_row = sections.sources[source_row_id]
+                if selected_source_variants is None:
+                    _execute_source(
+                        plan,
+                        source_row,
+                        momenta,
+                        prepared_parameters,
+                        arena,
+                        factor_cache=factor_cache,
+                    )
+                    continue
+                variant = selected_source_variants.get(source_row_id)
+                if variant is not None:
+                    _execute_union_source(
+                        plan,
+                        source_row,
+                        variant,
+                        momenta,
+                        prepared_parameters,
+                        arena,
+                        factor_cache=factor_cache,
+                    )
+            continue
+
+        if group.role == _ROLE_CONTRIBUTION:
+            if initialized_contribution_stage != group.stage:
+                _clear_stage(plan, arena, group.stage)
+                initialized_contribution_stage = group.stage
+            if group.executor_id == DIRECT_NONE_U32:
+                for contribution_row in sections.contributions[start:stop]:
+                    _execute_certified_reuse_row(
+                        plan,
+                        contribution_row,
+                        arena,
+                        factor_cache=factor_cache,
+                    )
+                continue
+        executor = plan.executors.get(group.executor_id)
+        if executor is None or _role_index(executor.role) != group.role:
+            raise ArtifactError(
+                f"recurrence row group references invalid executor {group.executor_id}"
+            )
+        if group.role == _ROLE_CONTRIBUTION:
+            for contribution_row in sections.contributions[start:stop]:
+                _execute_prepared_row(
+                    plan,
+                    executor,
+                    contribution_row,
+                    momenta,
+                    prepared_parameters,
+                    arena,
+                    amplitudes,
+                    precision,
+                    factor_cache=factor_cache,
+                )
+        elif group.role == _ROLE_FINALIZATION:
+            for finalization_row in sections.finalizations[start:stop]:
+                _execute_finalization(
+                    plan,
+                    executor,
+                    finalization_row,
+                    momenta,
+                    prepared_parameters,
+                    arena,
+                    amplitudes,
+                    precision,
+                    factor_cache=factor_cache,
+                )
+        elif group.role == _ROLE_CLOSURE:
+            for closure_row in sections.closures[start:stop]:
+                if executor.runtime_template is not None:
+                    _execute_intrinsic_closure(
+                        plan,
+                        closure_row,
+                        arena,
+                        amplitudes,
+                        factor_cache=factor_cache,
+                    )
+                else:
+                    _execute_prepared_row(
+                        plan,
+                        executor,
+                        closure_row,
+                        momenta,
+                        prepared_parameters,
+                        arena,
+                        amplitudes,
+                        precision,
+                        factor_cache=factor_cache,
+                    )
+        else:  # pragma: no cover - native plan validation rejects this
+            raise ArtifactError(f"unsupported recurrence row role {group.role}")
+    if active_stage is not None:
+        _observe_stage_currents(
+            current_observer,
+            plan,
+            active_stage,
+            arena,
+        )
+    return tuple(amplitudes)
+
+
+def _observe_stage_currents(
+    observer: _CurrentObserver | None,
+    plan: _RecurrenceExactPlan,
+    stage: int,
+    arena: Sequence[_ComplexDecimal],
+) -> None:
+    if observer is None:
+        return
+    for current in _currents_for_stage(plan, stage):
+        values = tuple(
+            _arena_value(arena, current.component_base, component)
+            for component in range(current.component_count)
+        )
+        observer(current.semantic_id, values)
+
+
+def _currents_for_stage(
+    plan: _RecurrenceExactPlan,
+    stage: int,
+) -> tuple[_Current, ...]:
+    cached = plan.trusted_currents_by_stage
+    if not cached:
+        grouped: dict[int, list[_Current]] = {}
+        for current in plan.sections.currents:
+            grouped.setdefault(current.stage, []).append(current)
+        cached.update(
+            (stage_id, tuple(currents)) for stage_id, currents in grouped.items()
+        )
+    return cached.get(stage, ())
+
+
+def _execute_certified_reuse_row(
+    plan: _RecurrenceExactPlan,
+    row: _Contribution,
+    arena: list[_ComplexDecimal],
+    *,
+    factor_cache: _FactorCache | None = None,
+) -> None:
+    if (
+        row.flags != _CERTIFIED_REUSE_FLAGS
+        or row.parent1_base != DIRECT_NONE_U32
+        or row.parent1_momentum != DIRECT_NONE_U32
+        or row.parent0_momentum <= 0
+    ):
+        raise ArtifactError("certified-reuse contribution has an invalid encoding")
+    factor = _factor(plan, row.exact_factor_id, cache=factor_cache)
+    component_count = row.parent0_momentum
+    values = tuple(
+        _complex_mul(
+            _arena_value(arena, row.parent0_base, component),
+            factor,
+        )
+        for component in range(component_count)
+    )
+    _write(
+        arena,
+        row.destination_base,
+        values,
+        replace=True,
+    )
+
+
+def _momentum_forms(
+    plan: _RecurrenceExactPlan,
+    point: _Point,
+    permutation: Sequence[int],
+    momentum_signs: Sequence[int] | None = None,
+) -> tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]:
+    result = []
+    terms = plan.sections.momentum_terms
+    for form in plan.sections.momentum_forms:
+        values = [_ZERO, _ZERO, _ZERO, _ZERO]
+        for term in terms[form.term_start : form.term_start + form.term_count]:
+            try:
+                external_slot = permutation[term.source_slot]
+                source = point[external_slot]
+            except IndexError as exc:
+                raise ArtifactError(
+                    "recurrence momentum form references an absent external source"
+                ) from exc
+            replay_sign = (
+                1 if momentum_signs is None else momentum_signs[term.source_slot]
+            )
+            coefficient = Decimal(term.coefficient * replay_sign)
+            for component in range(4):
+                values[component] += coefficient * source[component]
+        result.append((values[0], values[1], values[2], values[3]))
+    return tuple(result)
+
+
+def _clear_stage(
+    plan: _RecurrenceExactPlan,
+    arena: list[_ComplexDecimal],
+    stage: int,
+) -> None:
+    for current in _currents_for_stage(plan, stage):
+        if current.node_kind != _NODE_CURRENT:
+            continue
+        stop = current.component_base + current.component_count
+        arena[current.component_base : stop] = [
+            _complex_zero()
+        ] * current.component_count
+
+
+def _execute_source(
+    plan: _RecurrenceExactPlan,
+    row: _Source,
+    momenta: Sequence[Sequence[Decimal]],
+    prepared_parameters: Sequence[_ComplexDecimal],
+    arena: list[_ComplexDecimal],
+    *,
+    factor_cache: _FactorCache | None = None,
+) -> None:
+    source = row
+    template = plan.source_templates[source.source_template_or_dispatch_domain]
+    initial = source.source_slot in plan.initial_source_slots
+    helicity = template.helicity * (template.crossing_helicity_factor if initial else 1)
+    chirality = template.chirality * (
+        template.crossing_chirality_factor if initial else 1
+    )
+    spin_state = template.spin_state * (
+        template.crossing_spin_state_factor if initial else 1
+    )
+    if spin_state != source.spin_state_class:
+        raise ArtifactError("recurrence source spin-state contract is inconsistent")
+    try:
+        momentum = momenta[source.momentum_form_id]
+    except IndexError as exc:
+        raise ArtifactError("recurrence source momentum form is absent") from exc
+    mass = _ZERO
+    if template.mass_prepared_parameter_id is not None:
+        try:
+            mass_value = prepared_parameters[template.mass_prepared_parameter_id]
+        except IndexError as exc:
+            raise ArtifactError(
+                "recurrence source mass parameter is out of range"
+            ) from exc
+        if mass_value[1] != _ZERO:
+            raise EvaluationError("recurrence source mass must be real")
+        mass = mass_value[0]
+    wave = _source_wavefunction(template, momentum, helicity, chirality, mass)
+    if len(wave) != template.dimension:
+        raise ArtifactError("recurrence source wavefunction has the wrong dimension")
+    factor = _factor(plan, source.exact_factor_id, cache=factor_cache)
+    values = tuple(_complex_mul(value, factor) for value in wave)
+    _write(arena, source.destination_base, values, replace=True)
+
+
+def _execute_union_source(
+    plan: _RecurrenceExactPlan,
+    source: _Source,
+    variant: _SourceDispatchVariant,
+    momenta: Sequence[Sequence[Decimal]],
+    prepared_parameters: Sequence[_ComplexDecimal],
+    arena: list[_ComplexDecimal],
+    *,
+    factor_cache: _FactorCache | None = None,
+) -> None:
+    if (
+        source.source_template_or_dispatch_domain != variant.dispatch_domain_id
+        or variant.source_row_id >= len(plan.sections.sources)
+        or plan.sections.sources[variant.source_row_id] != source
+    ):
+        raise ArtifactError(
+            "all-flow-union source variant does not match its dispatch row"
+        )
+    try:
+        template = plan.source_templates[variant.source_template_id]
+    except KeyError as exc:
+        raise ArtifactError(
+            "all-flow-union source variant references an absent source template"
+        ) from exc
+    try:
+        momentum = momenta[source.momentum_form_id]
+    except IndexError as exc:
+        raise ArtifactError("recurrence source momentum form is absent") from exc
+
+    initial = source.source_slot in plan.initial_source_slots
+    helicity = template.helicity * (template.crossing_helicity_factor if initial else 1)
+    chirality = template.chirality * (
+        template.crossing_chirality_factor if initial else 1
+    )
+    spin_state = template.spin_state * (
+        template.crossing_spin_state_factor if initial else 1
+    )
+    if spin_state != variant.crossed_spin_state_class:
+        raise ArtifactError(
+            "all-flow-union source variant has inconsistent crossed spin state"
+        )
+
+    mass = _ZERO
+    if template.mass_prepared_parameter_id is not None:
+        try:
+            mass_value = prepared_parameters[template.mass_prepared_parameter_id]
+        except IndexError as exc:
+            raise ArtifactError(
+                "recurrence source mass parameter is out of range"
+            ) from exc
+        if mass_value[1] != _ZERO:
+            raise EvaluationError("recurrence source mass must be real")
+        mass = mass_value[0]
+    wave = _source_wavefunction(template, momentum, helicity, chirality, mass)
+    if len(wave) != variant.projection_count:
+        raise ArtifactError(
+            "all-flow-union source wavefunction has the wrong projected dimension"
+        )
+
+    embeddings = plan.sections.source_embeddings[
+        variant.embedding_start : variant.embedding_start + variant.embedding_count
+    ]
+    if len(embeddings) != variant.embedding_count:
+        raise ArtifactError("all-flow-union source embedding is out of bounds")
+    source_factor = _complex_mul(
+        _factor(plan, source.exact_factor_id, cache=factor_cache),
+        _factor(plan, variant.crossing_exact_factor_id, cache=factor_cache),
+    )
+    values = []
+    for full_component, embedding in enumerate(embeddings):
+        if embedding.full_component != full_component:
+            raise ArtifactError(
+                "all-flow-union source embedding is not in component order"
+            )
+        if embedding.source_component == DIRECT_NONE_U32:
+            values.append(_complex_zero())
+            continue
+        try:
+            value = wave[embedding.source_component]
+        except IndexError as exc:
+            raise ArtifactError(
+                "all-flow-union source embedding references an absent component"
+            ) from exc
+        values.append(
+            _complex_mul(
+                _complex_mul(value, source_factor),
+                _factor(plan, embedding.exact_factor_id, cache=factor_cache),
+            )
+        )
+    _write(arena, source.destination_base, values, replace=True)
+
+
+def _source_wavefunction(
+    template: _SourceTemplate,
+    momentum: Sequence[Decimal],
+    helicity: int,
+    chirality: int,
+    mass: Decimal,
+) -> tuple[_ComplexDecimal, ...]:
+    if template.dimension == 1 and template.family == "scalar":
+        return ((_ONE, _ZERO),)
+    if template.family == "fermion" and template.orientation == "self-conjugate":
+        raise CompatibilityError(
+            "self-conjugate fermion source wavefunctions are unsupported"
+        )
+    if template.dimension == 2 and template.family == "fermion":
+        return (
+            _antiquark_weyl(momentum, helicity, chirality)
+            if template.orientation == "antiparticle"
+            else _quark_weyl(momentum, helicity, chirality)
+        )
+    if template.dimension == 4 and template.family == "fermion":
+        return (
+            _antiquark_dirac(momentum, helicity, mass)
+            if template.orientation == "antiparticle"
+            else _quark_dirac(momentum, helicity, mass)
+        )
+    if template.dimension == 4 and template.family == "vector":
+        return (
+            _massless_vector(momentum, helicity)
+            if mass == _ZERO
+            else _massive_vector(momentum, helicity, mass)
+        )
+    if template.dimension == 16 and template.family == "spin2":
+        return _spin2(momentum, helicity, mass)
+    raise CompatibilityError(
+        f"exact recurrence source {template.family!r} with dimension "
+        f"{template.dimension} is unsupported"
+    )
+
+
+def _execute_finalization(
+    plan: _RecurrenceExactPlan,
+    executor: _Executor,
+    row: _Finalization,
+    momenta: Sequence[Sequence[Decimal]],
+    prepared_parameters: Sequence[_ComplexDecimal],
+    arena: list[_ComplexDecimal],
+    amplitudes: list[_ComplexDecimal],
+    precision: int,
+    *,
+    factor_cache: _FactorCache | None = None,
+) -> None:
+    if executor.runtime_template is not None:
+        if executor.runtime_template == "rusticol.identity-finalize-in-place.v1":
+            factor = _factor(plan, row.exact_factor_id, cache=factor_cache)
+            stop = row.component_base + row.component_count
+            arena[row.component_base : stop] = [
+                _complex_mul(value, factor)
+                for value in arena[row.component_base : stop]
+            ]
+            return
+        if executor.executor_id not in plan.executor_exact_kernel_ids:
+            raise CompatibilityError(
+                f"unsupported exact recurrence finalization intrinsic "
+                f"{executor.runtime_template!r}"
+            )
+    _execute_prepared_row(
+        plan,
+        executor,
+        row,
+        momenta,
+        prepared_parameters,
+        arena,
+        amplitudes,
+        precision,
+        factor_cache=factor_cache,
+    )
+
+
+def _execute_prepared_row(
+    plan: _RecurrenceExactPlan,
+    executor: _Executor,
+    row: _Contribution | _Finalization | _Closure,
+    momenta: Sequence[Sequence[Decimal]],
+    prepared_parameters: Sequence[_ComplexDecimal],
+    arena: list[_ComplexDecimal],
+    amplitudes: list[_ComplexDecimal],
+    precision: int,
+    *,
+    factor_cache: _FactorCache | None = None,
+) -> None:
+    recipe = _trusted_executor_recipe(plan, executor)
+    inputs = _trusted_kernel_inputs(
+        plan,
+        recipe.inputs,
+        executor,
+        row,
+        momenta,
+        prepared_parameters,
+        arena,
+    )
+    outputs = recipe.kernel.evaluate(inputs, precision)
+    factor = _factor(plan, row.exact_factor_id, cache=factor_cache)
+    scaled = tuple(_complex_mul(value, factor) for value in outputs)
+    if executor.role == "contribution" and isinstance(row, _Contribution):
+        _write(arena, row.destination_base, scaled, replace=False)
+    elif executor.role == "finalization" and isinstance(row, _Finalization):
+        _write(arena, row.component_base, scaled, replace=True)
+    elif executor.role == "closure" and isinstance(row, _Closure):
+        if len(scaled) != executor.destination_component_count:
+            raise ArtifactError("recurrence closure output width is inconsistent")
+        _write(
+            amplitudes,
+            row.amplitude_destination_id,
+            scaled,
+            replace=False,
+        )
+    else:
+        raise ArtifactError(
+            f"prepared direct executor has unsupported role {executor.role!r}"
+        )
+
+
+def _trusted_executor_recipe(
+    plan: _RecurrenceExactPlan,
+    executor: _Executor,
+) -> _TrustedExecutorRecipe:
+    cached = plan.trusted_executor_recipes.get(executor.executor_id)
+    if cached is not None:
+        if not isinstance(cached, _TrustedExecutorRecipe):
+            raise ArtifactError(
+                f"direct executor {executor.executor_id} has an invalid "
+                "trusted exact recipe"
+            )
+        return cached
+
+    kernel_id = plan.executor_exact_kernel_ids.get(
+        executor.executor_id,
+        executor.prepared_kernel_id,
+    )
+    if kernel_id is None:
+        raise ArtifactError(
+            f"direct executor {executor.executor_id} has no prepared exact kernel"
+        )
+    kernel = plan.kernels.get(kernel_id)
+    if kernel is None:
+        raise ArtifactError(f"prepared exact kernel {kernel_id} is absent")
+    recipe = _TrustedExecutorRecipe(
+        kernel=kernel,
+        inputs=_compile_trusted_inputs(
+            plan,
+            kernel.record.input_contracts,
+            executor,
+        ),
+    )
+    plan.trusted_executor_recipes[executor.executor_id] = recipe
+    return recipe
+
+
+def _compile_trusted_inputs(
+    plan: _RecurrenceExactPlan,
+    contracts: Sequence[Mapping[str, object]],
+    executor: _Executor,
+) -> tuple[_TrustedInputRecipe, ...]:
+    result = []
+    for index, contract in enumerate(contracts):
+        role = contract.get("role")
+        component = contract.get("component")
+        if (
+            isinstance(component, bool)
+            or not isinstance(component, int)
+            or component < 0
+        ):
+            raise ArtifactError(
+                f"prepared kernel input {index} has an invalid component"
+            )
+        if role in {"left-current", "current"}:
+            result.append(
+                _TrustedInputRecipe(
+                    _INPUT_CURRENT,
+                    _prepared_parent_operand(plan, executor, 0),
+                    component,
+                )
+            )
+        elif role == "right-current":
+            result.append(
+                _TrustedInputRecipe(
+                    _INPUT_CURRENT,
+                    _prepared_parent_operand(plan, executor, 1),
+                    component,
+                )
+            )
+        elif role in {"left-momentum", "momentum"}:
+            result.append(
+                _TrustedInputRecipe(
+                    _INPUT_MOMENTUM,
+                    _prepared_parent_operand(plan, executor, 0),
+                    component,
+                )
+            )
+        elif role == "right-momentum":
+            result.append(
+                _TrustedInputRecipe(
+                    _INPUT_MOMENTUM,
+                    _prepared_parent_operand(plan, executor, 1),
+                    component,
+                )
+            )
+        elif role in {"coupling-real", "coupling-imag"}:
+            coupling = plan.executor_couplings.get(executor.executor_id)
+            if coupling is None:
+                raise ArtifactError(
+                    f"direct executor {executor.executor_id} has no exact coupling"
+                )
+            result.append(
+                _TrustedInputRecipe(
+                    _INPUT_CONSTANT,
+                    0,
+                    component,
+                    (
+                        coupling[0 if role == "coupling-real" else 1],
+                        _ZERO,
+                    ),
+                )
+            )
+        elif role == "model-parameter":
+            parameter_id = contract.get("model_parameter_index")
+            if (
+                isinstance(parameter_id, bool)
+                or not isinstance(parameter_id, int)
+                or parameter_id < 0
+            ):
+                raise ArtifactError(
+                    f"prepared kernel input {index} has no model-parameter index"
+                )
+            result.append(
+                _TrustedInputRecipe(
+                    _INPUT_PARAMETER,
+                    parameter_id,
+                    component,
+                )
+            )
+        else:
+            raise CompatibilityError(
+                f"unsupported exact recurrence kernel input role {role!r}"
+            )
+    return tuple(result)
+
+
+def _trusted_kernel_inputs(
+    plan: _RecurrenceExactPlan,
+    recipes: Sequence[_TrustedInputRecipe],
+    executor: _Executor,
+    row: _Contribution | _Finalization | _Closure,
+    momenta: Sequence[Sequence[Decimal]],
+    prepared_parameters: Sequence[_ComplexDecimal],
+    arena: Sequence[_ComplexDecimal],
+) -> tuple[_ComplexDecimal, ...]:
+    result = []
+    current_bases: list[int | None] = [None, None]
+    momentum_form_ids: list[int | None] = [None, None]
+    for recipe in recipes:
+        if recipe.kind == _INPUT_CURRENT:
+            base = current_bases[recipe.index]
+            if base is None:
+                base = _parent_component_base(
+                    executor.role,
+                    row,
+                    recipe.index,
+                )
+                current_bases[recipe.index] = base
+            result.append(
+                _arena_value(
+                    arena,
+                    base,
+                    recipe.component,
+                )
+            )
+        elif recipe.kind == _INPUT_MOMENTUM:
+            form_id = momentum_form_ids[recipe.index]
+            if form_id is None:
+                form_id = _momentum_form_id(
+                    executor.role,
+                    row,
+                    recipe.index,
+                )
+                momentum_form_ids[recipe.index] = form_id
+            result.append(
+                _momentum_value(
+                    momenta,
+                    form_id,
+                    recipe.component,
+                )
+            )
+        elif recipe.kind == _INPUT_PARAMETER:
+            result.append(_parameter(prepared_parameters, recipe.index))
+        elif recipe.kind == _INPUT_CONSTANT and recipe.constant is not None:
+            result.append(recipe.constant)
+        else:  # pragma: no cover - recipes are constructed above
+            raise ArtifactError(
+                f"direct executor {executor.executor_id} has an invalid "
+                "trusted input recipe"
+            )
+    return tuple(result)
+
+
+def _kernel_inputs(
+    plan: _RecurrenceExactPlan,
+    contracts: Sequence[Mapping[str, object]],
+    executor: _Executor,
+    row: _Contribution | _Finalization | _Closure,
+    momenta: Sequence[Sequence[Decimal]],
+    prepared_parameters: Sequence[_ComplexDecimal],
+    arena: Sequence[_ComplexDecimal],
+) -> tuple[_ComplexDecimal, ...]:
+    result = []
+    for index, contract in enumerate(contracts):
+        role = contract.get("role")
+        component = contract.get("component")
+        if (
+            isinstance(component, bool)
+            or not isinstance(component, int)
+            or component < 0
+        ):
+            raise ArtifactError(
+                f"prepared kernel input {index} has an invalid component"
+            )
+        if role in {"left-current", "current"}:
+            parent = _prepared_parent_operand(plan, executor, 0)
+            result.append(
+                _arena_value(
+                    arena,
+                    _parent_component_base(executor.role, row, parent),
+                    component,
+                )
+            )
+        elif role == "right-current":
+            parent = _prepared_parent_operand(plan, executor, 1)
+            result.append(
+                _arena_value(
+                    arena,
+                    _parent_component_base(executor.role, row, parent),
+                    component,
+                )
+            )
+        elif role in {"left-momentum", "momentum"}:
+            operand = _prepared_parent_operand(plan, executor, 0)
+            result.append(
+                _momentum_value(
+                    momenta,
+                    _momentum_form_id(executor.role, row, operand),
+                    component,
+                )
+            )
+        elif role == "right-momentum":
+            operand = _prepared_parent_operand(plan, executor, 1)
+            result.append(
+                _momentum_value(
+                    momenta,
+                    _momentum_form_id(executor.role, row, operand),
+                    component,
+                )
+            )
+        elif role == "coupling-real":
+            coupling = plan.executor_couplings.get(executor.executor_id)
+            if coupling is None:
+                raise ArtifactError(
+                    f"direct executor {executor.executor_id} has no exact coupling"
+                )
+            result.append((coupling[0], _ZERO))
+        elif role == "coupling-imag":
+            coupling = plan.executor_couplings.get(executor.executor_id)
+            if coupling is None:
+                raise ArtifactError(
+                    f"direct executor {executor.executor_id} has no exact coupling"
+                )
+            result.append((coupling[1], _ZERO))
+        elif role == "model-parameter":
+            parameter_id = contract.get("model_parameter_index")
+            if (
+                isinstance(parameter_id, bool)
+                or not isinstance(parameter_id, int)
+                or parameter_id < 0
+            ):
+                raise ArtifactError(
+                    f"prepared kernel input {index} has no model-parameter index"
+                )
+            result.append(_parameter(prepared_parameters, parameter_id))
+        else:
+            raise CompatibilityError(
+                f"unsupported exact recurrence kernel input role {role!r}"
+            )
+    return tuple(result)
+
+
+def _prepared_parent_operand(
+    plan: _RecurrenceExactPlan,
+    executor: _Executor,
+    operand: int,
+) -> int:
+    if executor.role != "contribution":
+        return operand
+    permutation = plan.executor_parent_permutations.get(executor.executor_id)
+    if permutation not in {(0, 1), (1, 0)}:
+        raise ArtifactError(
+            f"direct contribution executor {executor.executor_id} has no "
+            "authenticated parent permutation"
+        )
+    try:
+        return permutation[operand]
+    except IndexError as exc:  # pragma: no cover - kernel roles are validated
+        raise ArtifactError(
+            f"direct contribution executor {executor.executor_id} references "
+            f"invalid parent operand {operand}"
+        ) from exc
+
+
+def _parent_component_base(
+    role: str,
+    row: _Contribution | _Finalization | _Closure,
+    parent: int,
+) -> int:
+    if role == "finalization":
+        if parent == 0 and isinstance(row, _Finalization):
+            return row.component_base
+    elif role in {"contribution", "closure"} and not isinstance(row, _Finalization):
+        if parent == 0:
+            return row.parent0_base
+        if parent == 1 and row.parent1_base != DIRECT_NONE_U32:
+            return row.parent1_base
+    raise ArtifactError(f"recurrence {role} row has no parent current {parent}")
+
+
+def _momentum_form_id(
+    role: str,
+    row: _Contribution | _Finalization | _Closure,
+    operand: int,
+) -> int:
+    if role == "finalization":
+        if operand == 0 and isinstance(row, _Finalization):
+            return row.momentum_form_id
+    elif role in {"contribution", "closure"} and not isinstance(row, _Finalization):
+        if operand == 0:
+            return row.parent0_momentum
+        if operand == 1 and row.parent1_momentum != DIRECT_NONE_U32:
+            return row.parent1_momentum
+    raise ArtifactError(f"recurrence {role} row has no momentum operand {operand}")
+
+
+def _execute_intrinsic_closure(
+    plan: _RecurrenceExactPlan,
+    row: _Closure,
+    arena: Sequence[_ComplexDecimal],
+    amplitudes: list[_ComplexDecimal],
+    *,
+    factor_cache: _FactorCache | None = None,
+) -> None:
+    if row.parent1_base == DIRECT_NONE_U32 or row.component_count == 0:
+        raise ArtifactError("recurrence intrinsic closure has invalid parents")
+    row_factor = _factor(plan, row.exact_factor_id, cache=factor_cache)
+    value = _complex_zero()
+    for component in range(row.component_count):
+        coefficient = _factor(
+            plan,
+            row.component_factor_start + component,
+            cache=factor_cache,
+        )
+        left = _arena_value(arena, row.parent0_base, component)
+        right = _arena_value(arena, row.parent1_base, component)
+        value = _complex_add(
+            value,
+            _complex_mul(_complex_mul(left, right), coefficient),
+        )
+    value = _complex_mul(value, row_factor)
+    amplitudes[row.amplitude_destination_id] = _complex_add(
+        amplitudes[row.amplitude_destination_id],
+        value,
+    )
+
+
+def _factor(
+    plan: _RecurrenceExactPlan,
+    factor_id: int,
+    *,
+    cache: _FactorCache | None = None,
+) -> _ComplexDecimal:
+    if cache is not None:
+        try:
+            cached = cache[factor_id]
+        except IndexError as exc:
+            raise ArtifactError("recurrence exact factor is out of range") from exc
+        if cached is not None:
+            return cached
+    try:
+        value = plan.sections.exact_factors[factor_id]
+    except IndexError as exc:
+        raise ArtifactError("recurrence exact factor is out of range") from exc
+    resolved = (
+        Decimal(value.real_numerator) / Decimal(value.real_denominator),
+        Decimal(value.imaginary_numerator) / Decimal(value.imaginary_denominator),
+    )
+    if cache is not None:
+        cache[factor_id] = resolved
+    return resolved
+
+
+def _parameter(
+    parameters: Sequence[_ComplexDecimal],
+    parameter_id: int,
+) -> _ComplexDecimal:
+    try:
+        return parameters[parameter_id]
+    except IndexError as exc:
+        raise ArtifactError("recurrence prepared parameter is out of range") from exc
+
+
+def _arena_value(
+    values: Sequence[_ComplexDecimal],
+    base: int,
+    component: int,
+) -> _ComplexDecimal:
+    try:
+        return values[base + component]
+    except IndexError as exc:
+        raise ArtifactError("recurrence component reference is out of range") from exc
+
+
+def _momentum_value(
+    momenta: Sequence[Sequence[Decimal]],
+    form_id: int,
+    component: int,
+) -> _ComplexDecimal:
+    try:
+        return momenta[form_id][component], _ZERO
+    except IndexError as exc:
+        raise ArtifactError("recurrence momentum reference is out of range") from exc
+
+
+def _write(
+    values: list[_ComplexDecimal],
+    start: int,
+    entries: Sequence[_ComplexDecimal],
+    *,
+    replace: bool,
+) -> None:
+    stop = start + len(entries)
+    if start < 0 or stop > len(values):
+        raise ArtifactError("recurrence destination range is out of bounds")
+    if replace:
+        values[start:stop] = entries
+    else:
+        values[start:stop] = [
+            _complex_add(previous, value)
+            for previous, value in zip(values[start:stop], entries, strict=True)
+        ]
+
+
+def _role_index(role: str) -> int:
+    try:
+        return {
+            "source": _ROLE_SOURCE,
+            "contribution": _ROLE_CONTRIBUTION,
+            "finalization": _ROLE_FINALIZATION,
+            "closure": _ROLE_CLOSURE,
+        }[role]
+    except KeyError as exc:
+        raise ArtifactError(f"unsupported direct executor role {role!r}") from exc
+
+
+__all__ = [
+    "_evaluate_contracted_point",
+    "_evaluate_replay_point",
+    "_evaluate_union_point",
+]
diff --git a/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_executor.py b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_executor.py
new file mode 100644
index 0000000000..8bde998036
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_executor.py
@@ -0,0 +1,957 @@
+# SPDX-License-Identifier: 0BSD
+"""Public exact executor for compact recurrence artifacts."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from decimal import ROUND_HALF_EVEN, Decimal, localcontext
+from pathlib import Path
+from typing import Any, cast
+
+from pyamplicol.api.errors import ArtifactError, EvaluationError
+from pyamplicol.api.protocols import Momenta
+from pyamplicol.api.results import ResolvedEvaluation
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.artifacts.security import confined_path
+from pyamplicol.runtime._evaluator_payloads import ExactEvaluatorPayloadResolver
+from pyamplicol.runtime._native_selection import (
+    native_physics_axes,
+    native_process_selection,
+    representative_vector_to_public,
+)
+from pyamplicol.runtime._normalization_exact import exact_normalization
+from pyamplicol.runtime.eager_exact._contracts import (
+    _KernelLoader,
+    _mapping,
+    _PayloadIndex,
+    _read_json,
+    _sequence,
+)
+from pyamplicol.runtime.symbolica_exact import (
+    _decimal,
+    _diagnostic_project_onshell_points,
+    _DiagnosticMassBinding,
+    _prepare_points,
+    _runtime_state,
+    _selected_indices,
+    _working_precision,
+)
+
+from ._color import _contract_color_amplitudes
+from ._execution import (
+    _evaluate_contracted_point,
+    _evaluate_replay_point,
+    _evaluate_union_point,
+)
+from ._plan import _RecurrenceExactPlan
+from ._plan_v2 import (
+    DIRECT_NONE_U32,
+    _AmplitudeDestination,
+    _NativeExactSectionsLoader,
+    _ReplayTarget,
+    _ResolvedHelicity,
+)
+
+_ZERO = Decimal(0)
+
+
+def _diagnostic_recurrence_mass_bindings(
+    plan: _RecurrenceExactPlan,
+    prepared_parameters: Sequence[tuple[Decimal, Decimal]],
+) -> tuple[_DiagnosticMassBinding, ...]:
+    """Resolve one unambiguous authenticated mass for every external source."""
+
+    template_ids_by_slot: dict[int, set[int]] = {
+        slot: set() for slot in range(plan.sections.external_source_count)
+    }
+    if plan.sections.source_dispatch_variants:
+        for variant in plan.sections.source_dispatch_variants:
+            try:
+                source = plan.sections.sources[variant.source_row_id]
+            except IndexError as exc:
+                raise ArtifactError(
+                    "recurrence diagnostic source variant is out of range"
+                ) from exc
+            template_ids_by_slot.setdefault(source.source_slot, set()).add(
+                variant.source_template_id
+            )
+    else:
+        for source in plan.sections.sources:
+            template_ids_by_slot.setdefault(source.source_slot, set()).add(
+                source.source_template_or_dispatch_domain
+            )
+
+    if len(plan.external_source_slots) != plan.sections.external_source_count or set(
+        plan.external_source_slots
+    ) != set(range(plan.sections.external_source_count)):
+        raise ArtifactError("recurrence diagnostic external source layout is invalid")
+    by_slot: dict[int, _DiagnosticMassBinding] = {}
+    for source_slot in range(plan.sections.external_source_count):
+        candidates = set()
+        for template_id in template_ids_by_slot.get(source_slot, set()):
+            try:
+                template = plan.source_templates[template_id]
+            except KeyError as exc:
+                raise ArtifactError(
+                    "recurrence diagnostic source template is absent"
+                ) from exc
+            parameter_id = template.mass_prepared_parameter_id
+            if parameter_id is None:
+                binding = _DiagnosticMassBinding(
+                    mass=_ZERO,
+                    authority="authenticated-recurrence-static-massless-source",
+                    parameter_name=None,
+                )
+            else:
+                try:
+                    real, imaginary = prepared_parameters[parameter_id]
+                except IndexError as exc:
+                    raise ArtifactError(
+                        "recurrence diagnostic mass parameter is out of range"
+                    ) from exc
+                if imaginary != _ZERO:
+                    raise EvaluationError(
+                        "recurrence diagnostic external mass must be real"
+                    )
+                if not real.is_finite():
+                    raise EvaluationError(
+                        "recurrence diagnostic external mass must be finite"
+                    )
+                if not template.mass_parameter_name:
+                    raise ArtifactError(
+                        "recurrence diagnostic mass parameter name is absent"
+                    )
+                binding = _DiagnosticMassBinding(
+                    mass=real,
+                    authority="authenticated-current-recurrence-prepared-parameter",
+                    parameter_name=template.mass_parameter_name,
+                )
+            candidates.add(binding)
+        if len(candidates) != 1:
+            raise ArtifactError(
+                f"recurrence diagnostic source slot {source_slot} does not have "
+                "one unambiguous mass binding"
+            )
+        by_slot[source_slot] = candidates.pop()
+    return tuple(by_slot[slot] for slot in plan.external_source_slots)
+
+
+class RecurrenceExactExecutor:
+    """Execute one authenticated compact recurrence through exact kernels."""
+
+    def __init__(
+        self,
+        artifact: Path,
+        process_id: str,
+        native_runtime: Any,
+        *,
+        kernel_loader: _KernelLoader | None = None,
+        native_sections_loader: _NativeExactSectionsLoader | None = None,
+    ) -> None:
+        self._artifact = Path(artifact).expanduser().resolve(strict=True)
+        self._native_runtime = native_runtime
+        manifest = load_manifest(self._artifact)
+        exact_payloads = ExactEvaluatorPayloadResolver(manifest)
+        selection = native_process_selection(native_runtime, manifest.processes)
+        process = selection.process
+        permutation = selection.external_permutation
+        representative_id = selection.representative_process_id
+        execution_records = tuple(
+            record
+            for record in manifest.payloads
+            if record.role == "evaluator-manifest"
+            and record.process_id == representative_id
+        )
+        if len(execution_records) != 1:
+            raise ArtifactError(
+                f"process {representative_id!r} must declare one recurrence "
+                "execution manifest"
+            )
+        physics_path = process.get("physics_path")
+        if not isinstance(physics_path, str):
+            raise ArtifactError(f"process {representative_id!r} has no physics path")
+        payloads = _PayloadIndex.from_manifest(manifest)
+        payloads.require(
+            physics_path,
+            role="runtime-physics",
+            process_id=representative_id,
+        )
+        execution = _read_json(
+            confined_path(self._artifact, execution_records[0].path),
+            "recurrence execution metadata",
+        )
+        representative_physics = _read_json(
+            confined_path(self._artifact, physics_path),
+            "runtime physics metadata",
+        )
+        axes = native_physics_axes(native_runtime, representative_physics)
+        if execution.get("key") != selection.representative_process_key:
+            raise ArtifactError(
+                "recurrence exact execution disagrees with Rusticol's representative "
+                "process key"
+            )
+        self._plan = _RecurrenceExactPlan.load(
+            artifact_root=self._artifact,
+            process_id=representative_id,
+            execution_path=execution_records[0].path,
+            execution=execution,
+            manifest=manifest,
+            kernel_loader=kernel_loader,
+            exact_payloads=exact_payloads,
+            native_sections_loader=native_sections_loader,
+        )
+        self._permutation = permutation
+        self._representative_physics = representative_physics
+        self._physics = axes.public_physics
+        (
+            self._helicity_representative,
+            self._helicity_orbit_members,
+        ) = self._helicity_reduction_indices()
+        self._replay_by_color: tuple[_ReplayTarget, ...] = ()
+        self._destination_helicities: tuple[tuple[int, ...], ...] = ()
+        self._union_destination_by_color: tuple[_AmplitudeDestination, ...] = ()
+        self._union_helicity_by_physics: tuple[_ResolvedHelicity | None, ...] = ()
+        self._contracted_destination_helicity: tuple[int, ...] = ()
+        if self._plan.sections.strategy == "topology-replay":
+            self._replay_by_color = self._replay_targets_by_color()
+            self._destination_helicities = self._destination_helicity_maps()
+        elif self._plan.sections.strategy == "all-flow-union":
+            self._union_destination_by_color = self._union_destinations_by_color()
+            self._union_helicity_by_physics = self._union_helicities_by_physics()
+        else:
+            self._contracted_destination_helicity = (
+                self._contracted_destination_helicity_map()
+            )
+
+    def _diagnostic_project_onshell(
+        self,
+        momenta: Momenta,
+        *,
+        precision: int,
+    ) -> tuple[
+        tuple[tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...], ...],
+        dict[str, object],
+    ]:
+        """Build diagnostic-only on-shell kinematics from current parameters."""
+
+        working_precision = _working_precision(precision)
+        state = _runtime_state(self._native_runtime)
+        runtime_parameters = tuple(
+            _decimal(value, "runtime model parameter")
+            for value in state["model_parameter_values"]
+        )
+        with localcontext() as context:
+            context.prec = working_precision
+            context.rounding = ROUND_HALF_EVEN
+            parameters = self._plan.resolve_model_parameters(
+                runtime_parameters,
+                working_precision,
+            )
+            bindings = _diagnostic_recurrence_mass_bindings(
+                self._plan,
+                parameters.prepared,
+            )
+        return _diagnostic_project_onshell_points(
+            momenta,
+            physics=self._representative_physics,
+            artifact_mass_bindings=bindings,
+            permutation=self._permutation,
+            precision=precision,
+        )
+
+    def evaluate_resolved(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None,
+        color_flows: Sequence[str] | None,
+        precision: int,
+    ) -> ResolvedEvaluation:
+        if (
+            isinstance(precision, bool)
+            or not isinstance(precision, int)
+            or precision < 1
+        ):
+            raise EvaluationError(
+                "precision must be a positive integer number of decimal digits"
+            )
+        working_precision = _working_precision(precision)
+        points = _prepare_points(momenta, self._physics, self._permutation)
+        state = _runtime_state(self._native_runtime)
+        runtime_parameters = tuple(
+            _decimal(value, "runtime model parameter")
+            for value in state["model_parameter_values"]
+        )
+        helicity_records = tuple(
+            _mapping(value, f"physics helicity {index}")
+            for index, value in enumerate(
+                _sequence(self._physics.get("helicities"), "physics helicities")
+            )
+        )
+        color_records = tuple(
+            _mapping(value, f"physics color {index}")
+            for index, value in enumerate(
+                _sequence(
+                    self._physics.get("color_components"),
+                    "physics color components",
+                )
+            )
+        )
+        helicity_ids = tuple(str(record["id"]) for record in helicity_records)
+        color_ids = tuple(str(record["id"]) for record in color_records)
+        selected_helicities = _selected_indices(
+            helicity_ids,
+            helicities,
+            "helicity",
+        )
+        if (
+            self._plan.sections.strategy == "contracted-color-union"
+            and color_flows is not None
+        ):
+            raise EvaluationError(
+                "contracted NLC/full recurrence does not expose a color-flow selector"
+            )
+        selected_colors = _selected_indices(color_ids, color_flows, "color component")
+        helicity_positions = {
+            index: position for position, index in enumerate(selected_helicities)
+        }
+
+        with localcontext() as context:
+            context.prec = working_precision
+            context.rounding = ROUND_HALF_EVEN
+            normalization = exact_normalization(
+                self._physics,
+                runtime_parameters,
+                working_precision,
+                tuple(
+                    {"name": row.runtime_name, "parameter_index": row.runtime_slot}
+                    for row in self._plan.runtime_parameter_schema
+                ),
+            )
+            parameters = self._plan.resolve_model_parameters(
+                runtime_parameters,
+                working_precision,
+            )
+            values = []
+            for point in points:
+                point_values = [
+                    [_ZERO for _ in selected_colors] for _ in selected_helicities
+                ]
+                if self._plan.sections.strategy == "topology-replay":
+                    self._evaluate_replay_resolved_point(
+                        point,
+                        selected_colors,
+                        helicity_positions,
+                        helicity_records,
+                        color_records,
+                        parameters.prepared,
+                        working_precision,
+                        normalization,
+                        point_values,
+                    )
+                elif self._plan.sections.strategy == "all-flow-union":
+                    self._evaluate_union_resolved_point(
+                        point,
+                        selected_helicities,
+                        selected_colors,
+                        helicity_records,
+                        color_records,
+                        parameters.prepared,
+                        working_precision,
+                        normalization,
+                        point_values,
+                    )
+                else:
+                    self._evaluate_contracted_resolved_point(
+                        point,
+                        selected_helicities,
+                        helicity_records,
+                        parameters.prepared,
+                        working_precision,
+                        normalization,
+                        point_values,
+                    )
+                values.append(tuple(tuple(colors) for colors in point_values))
+
+        with localcontext() as context:
+            context.prec = precision
+            context.rounding = ROUND_HALF_EVEN
+            rounded = tuple(
+                tuple(tuple(+entry for entry in colors) for colors in point)
+                for point in values
+            )
+        return ResolvedEvaluation(
+            values=rounded,
+            helicity_ids=tuple(helicity_ids[index] for index in selected_helicities),
+            color_ids=tuple(color_ids[index] for index in selected_colors),
+            color_accuracy=cast(Any, str(self._physics["color_accuracy"])),
+        )
+
+    def _evaluate_replay_resolved_point(
+        self,
+        point: object,
+        selected_colors: Sequence[int],
+        helicity_positions: dict[int, int],
+        helicity_records: Sequence[Mapping[str, object]],
+        color_records: Sequence[Mapping[str, object]],
+        prepared_parameters: Sequence[tuple[Decimal, Decimal]],
+        working_precision: int,
+        normalization: Decimal,
+        point_values: list[list[Decimal]],
+    ) -> None:
+        for color_position, color_index in enumerate(selected_colors):
+            target = self._replay_by_color[color_index]
+            amplitudes = _evaluate_replay_point(
+                self._plan,
+                cast(Any, point),
+                target,
+                prepared_parameters,
+                working_precision,
+            )
+            destination_helicities = self._destination_helicities[color_index]
+            color_weight = _decimal(
+                color_records[color_index].get("coefficient", 1),
+                "color coefficient",
+            )
+            for destination in self._plan.sections.amplitude_destinations:
+                if destination.target_sector_id != target.representative_id:
+                    continue
+                physics_helicity = destination_helicities[destination.destination_id]
+                helicity = helicity_records[physics_helicity]
+                if (
+                    helicity.get("computed") is not True
+                    or helicity.get("structural_zero") is True
+                ):
+                    continue
+                amplitude = amplitudes[destination.destination_id]
+                squared = amplitude[0] * amplitude[0] + amplitude[1] * amplitude[1]
+                for physical_helicity in self._helicity_orbit_members[physics_helicity]:
+                    helicity_position = helicity_positions.get(physical_helicity)
+                    if helicity_position is None:
+                        continue
+                    helicity_weight = _decimal(
+                        helicity_records[physical_helicity].get("coefficient", 1),
+                        "helicity coefficient",
+                    )
+                    point_values[helicity_position][color_position] += (
+                        normalization * color_weight * helicity_weight * squared
+                    )
+
+    def _evaluate_union_resolved_point(
+        self,
+        point: object,
+        selected_helicities: Sequence[int],
+        selected_colors: Sequence[int],
+        helicity_records: Sequence[Mapping[str, object]],
+        color_records: Sequence[Mapping[str, object]],
+        prepared_parameters: Sequence[tuple[Decimal, Decimal]],
+        working_precision: int,
+        normalization: Decimal,
+        point_values: list[list[Decimal]],
+    ) -> None:
+        for helicity_position, physics_helicity in enumerate(selected_helicities):
+            helicity_record = helicity_records[physics_helicity]
+            if (
+                helicity_record.get("computed") is not True
+                or helicity_record.get("structural_zero") is True
+            ):
+                continue
+            direct_helicity = self._union_helicity_by_physics[physics_helicity]
+            if direct_helicity is None:
+                raise ArtifactError(
+                    "all-flow-union plan is missing a retained physical helicity"
+                )
+            amplitudes = _evaluate_union_point(
+                self._plan,
+                cast(Any, point),
+                direct_helicity,
+                prepared_parameters,
+                working_precision,
+            )
+            helicity_weight = _decimal(
+                helicity_record.get("coefficient", 1),
+                "helicity coefficient",
+            )
+            for color_position, color_index in enumerate(selected_colors):
+                destination = self._union_destination_by_color[color_index]
+                color_weight = _decimal(
+                    color_records[color_index].get("coefficient", 1),
+                    "color coefficient",
+                )
+                amplitude = amplitudes[destination.destination_id]
+                point_values[helicity_position][color_position] += (
+                    normalization
+                    * color_weight
+                    * helicity_weight
+                    * (amplitude[0] * amplitude[0] + amplitude[1] * amplitude[1])
+                )
+
+    def _evaluate_contracted_resolved_point(
+        self,
+        point: object,
+        selected_helicities: Sequence[int],
+        helicity_records: Sequence[Mapping[str, object]],
+        prepared_parameters: Sequence[tuple[Decimal, Decimal]],
+        working_precision: int,
+        normalization: Decimal,
+        point_values: list[list[Decimal]],
+    ) -> None:
+        contraction = self._plan.color_contraction
+        if contraction is None:
+            raise ArtifactError(
+                "contracted exact execution has no color-contraction payload"
+            )
+        amplitudes = self._contracted_amplitudes(
+            point,
+            prepared_parameters,
+            working_precision,
+        )
+        selected = {
+            self._helicity_representative[physical] for physical in selected_helicities
+        }
+        contracted = _contract_color_amplitudes(
+            contraction,
+            amplitudes,
+            self._contracted_destination_helicity,
+            selected,
+        )
+        for helicity_position, physics_helicity in enumerate(selected_helicities):
+            helicity_record = helicity_records[physics_helicity]
+            if helicity_record.get("structural_zero") is True:
+                continue
+            representative = self._helicity_representative[physics_helicity]
+            helicity_weight = _decimal(
+                helicity_record.get("coefficient", 1),
+                "helicity coefficient",
+            )
+            point_values[helicity_position][0] = (
+                normalization * helicity_weight * contracted.get(representative, _ZERO)
+            )
+
+    def _contracted_amplitudes(
+        self,
+        point: object,
+        prepared_parameters: Sequence[tuple[Decimal, Decimal]],
+        working_precision: int,
+    ) -> tuple[tuple[Decimal, Decimal], ...]:
+        sections = self._plan.sections
+        contraction = self._plan.color_contraction
+        if contraction is None:
+            raise ArtifactError(
+                "contracted exact execution has no color-contraction payload"
+            )
+        if not sections.replay_targets:
+            return _evaluate_contracted_point(
+                self._plan,
+                cast(Any, point),
+                prepared_parameters,
+                working_precision,
+            )
+
+        destination_by_coordinate: dict[tuple[int, int], int] = {}
+        for group_id, destination_id in enumerate(contraction.destination_by_group):
+            coordinate = (
+                contraction.group_sector_ids[group_id],
+                contraction.group_component_ids[group_id],
+            )
+            if coordinate in destination_by_coordinate:
+                raise ArtifactError(
+                    "contracted replay color coordinates are not unique"
+                )
+            destination_by_coordinate[coordinate] = destination_id
+
+        amplitudes = [(_ZERO, _ZERO)] * contraction.destination_count
+        covered: set[int] = set()
+        for target in sections.replay_targets:
+            helicity_map = sections.replay_helicity_map[
+                target.helicity_map_start : target.helicity_map_start
+                + target.helicity_map_count
+            ]
+            if len(helicity_map) != len(sections.resolved_helicities):
+                raise ArtifactError(
+                    "contracted replay helicity mapping has incomplete coverage"
+                )
+            replayed = _evaluate_replay_point(
+                self._plan,
+                cast(Any, point),
+                target,
+                prepared_parameters,
+                working_precision,
+            )
+            for destination in sections.amplitude_destinations:
+                if destination.target_sector_id != target.representative_id:
+                    continue
+                direct_helicity = destination.target_helicity_id
+                if direct_helicity >= len(helicity_map):
+                    raise ArtifactError(
+                        "contracted replay destination helicity is not mapped"
+                    )
+                coordinate = (
+                    target.public_flow_id,
+                    helicity_map[direct_helicity],
+                )
+                try:
+                    physical_destination = destination_by_coordinate[coordinate]
+                    amplitude = replayed[destination.destination_id]
+                except (IndexError, KeyError) as exc:
+                    raise ArtifactError(
+                        "contracted replay route is outside the physical "
+                        "color/helicity domain"
+                    ) from exc
+                if physical_destination in covered:
+                    raise ArtifactError(
+                        "contracted replay routes repeat a physical destination"
+                    )
+                covered.add(physical_destination)
+                amplitudes[physical_destination] = amplitude
+        if len(covered) != contraction.destination_count:
+            raise ArtifactError(
+                "contracted replay routes do not cover every physical destination"
+            )
+        return tuple(amplitudes)
+
+    def _helicity_reduction_indices(
+        self,
+    ) -> tuple[tuple[int, ...], tuple[tuple[int, ...], ...]]:
+        records = tuple(
+            _mapping(value, f"physics helicity {index}")
+            for index, value in enumerate(
+                _sequence(self._physics.get("helicities"), "physics helicities")
+            )
+        )
+        index_by_id = {str(record["id"]): index for index, record in enumerate(records)}
+        if len(index_by_id) != len(records):
+            raise ArtifactError("physics helicities repeat a public ID")
+        representatives = []
+        members: list[list[int]] = [[] for _ in records]
+        for index, record in enumerate(records):
+            representative_id = str(record.get("representative_id", record["id"]))
+            try:
+                representative = index_by_id[representative_id]
+            except KeyError as exc:
+                raise ArtifactError(
+                    f"physics helicity {index} references absent representative "
+                    f"{representative_id!r}"
+                ) from exc
+            representative_record = records[representative]
+            if record.get("structural_zero") is not True and (
+                representative_record.get("computed") is not True
+                or representative_record.get("structural_zero") is True
+                or str(
+                    representative_record.get(
+                        "representative_id", representative_record["id"]
+                    )
+                )
+                != str(representative_record["id"])
+            ):
+                raise ArtifactError(
+                    f"physics helicity {index} has an invalid computed representative"
+                )
+            representatives.append(representative)
+            if record.get("structural_zero") is not True:
+                members[representative].append(index)
+        return tuple(representatives), tuple(tuple(group) for group in members)
+
+    def _replay_targets_by_color(self) -> tuple[_ReplayTarget, ...]:
+        by_public_id = {
+            target.public_flow_id: target
+            for target in self._plan.sections.replay_targets
+        }
+        if len(by_public_id) != len(self._plan.sections.replay_targets):
+            raise ArtifactError("recurrence replay targets repeat a public flow")
+        try:
+            return tuple(
+                by_public_id[public_id]
+                for public_id in self._plan.sections.public_flow_ids
+            )
+        except KeyError as exc:
+            raise ArtifactError(
+                "recurrence public color axis references an absent replay target"
+            ) from exc
+
+    def _destination_helicity_maps(self) -> tuple[tuple[int, ...], ...]:
+        sections = self._plan.sections
+        helicity_records = tuple(
+            _mapping(value, f"physics helicity {index}")
+            for index, value in enumerate(
+                _sequence(self._physics.get("helicities"), "physics helicities")
+            )
+        )
+        physics_by_values = {
+            tuple(
+                _signed_integer(component, "physics helicity component")
+                for component in _sequence(
+                    record.get("values"), "physics helicity values"
+                )
+            ): index
+            for index, record in enumerate(helicity_records)
+        }
+        direct_to_physics = {}
+        for descriptor in sections.resolved_helicities:
+            start = descriptor.public_helicity_start
+            stop = start + descriptor.public_helicity_count
+            vector = sections.public_helicities[start:stop]
+            if len(vector) != sections.external_source_count:
+                raise ArtifactError(
+                    "recurrence direct helicity has invalid source coverage"
+                )
+            try:
+                direct_to_physics[descriptor.helicity_id] = physics_by_values[
+                    representative_vector_to_public(vector, self._permutation)
+                ]
+            except KeyError as exc:
+                raise ArtifactError(
+                    "recurrence direct helicity is absent from public physics coverage"
+                ) from exc
+
+        result = []
+        for target in self._replay_by_color:
+            start = target.helicity_map_start
+            stop = start + target.helicity_map_count
+            helicity_map = sections.replay_helicity_map[start:stop]
+            if len(helicity_map) != len(sections.resolved_helicities):
+                raise ArtifactError(
+                    "recurrence replay helicity mapping has incomplete coverage"
+                )
+            destinations = [DIRECT_NONE_U32] * sections.amplitude_destination_count
+            for destination in sections.amplitude_destinations:
+                direct_id = destination.target_helicity_id
+                if direct_id == DIRECT_NONE_U32:
+                    raise ArtifactError(
+                        "topology-replay destination has no resolved helicity"
+                    )
+                if direct_id >= len(helicity_map):
+                    raise ArtifactError(
+                        "recurrence destination helicity is absent from replay mapping"
+                    )
+                mapped_id = helicity_map[direct_id]
+                try:
+                    destinations[destination.destination_id] = direct_to_physics[
+                        mapped_id
+                    ]
+                except KeyError as exc:
+                    raise ArtifactError(
+                        "recurrence replay maps to an absent direct helicity"
+                    ) from exc
+            if any(value == DIRECT_NONE_U32 for value in destinations):
+                raise ArtifactError(
+                    "recurrence amplitude destination helicity map is incomplete"
+                )
+            result.append(tuple(destinations))
+        return tuple(result)
+
+    def _union_destinations_by_color(
+        self,
+    ) -> tuple[_AmplitudeDestination, ...]:
+        sections = self._plan.sections
+        by_sector = {
+            destination.target_sector_id: destination
+            for destination in sections.amplitude_destinations
+        }
+        if len(by_sector) != len(sections.amplitude_destinations):
+            raise ArtifactError(
+                "all-flow-union repeats an amplitude destination sector"
+            )
+        try:
+            return tuple(by_sector[sector_id] for sector_id in sections.public_flow_ids)
+        except KeyError as exc:
+            raise ArtifactError(
+                "all-flow-union public color axis references an absent destination"
+            ) from exc
+
+    def _union_helicities_by_physics(
+        self,
+    ) -> tuple[_ResolvedHelicity | None, ...]:
+        sections = self._plan.sections
+        helicity_records = tuple(
+            _mapping(value, f"physics helicity {index}")
+            for index, value in enumerate(
+                _sequence(self._physics.get("helicities"), "physics helicities")
+            )
+        )
+        physics_by_values = {
+            tuple(
+                _signed_integer(component, "physics helicity component")
+                for component in _sequence(
+                    record.get("values"), "physics helicity values"
+                )
+            ): index
+            for index, record in enumerate(helicity_records)
+        }
+        result: list[_ResolvedHelicity | None] = [None] * len(helicity_records)
+        for descriptor in sections.resolved_helicities:
+            start = descriptor.public_helicity_start
+            stop = start + descriptor.public_helicity_count
+            vector = representative_vector_to_public(
+                sections.public_helicities[start:stop], self._permutation
+            )
+            if len(vector) != sections.external_source_count:
+                raise ArtifactError(
+                    "all-flow-union helicity has incomplete source coverage"
+                )
+            try:
+                physics_index = physics_by_values[vector]
+            except KeyError as exc:
+                raise ArtifactError(
+                    "all-flow-union helicity is outside public coverage"
+                ) from exc
+            if result[physics_index] is not None:
+                raise ArtifactError("all-flow-union repeats a public helicity")
+            result[physics_index] = descriptor
+        for index, (record, resolved_descriptor) in enumerate(
+            zip(helicity_records, result, strict=True)
+        ):
+            if (
+                record.get("computed") is True
+                and record.get("structural_zero") is not True
+                and resolved_descriptor is None
+            ):
+                raise ArtifactError(f"all-flow-union omits computed helicity {index}")
+        return tuple(result)
+
+    def _contracted_destination_helicity_map(self) -> tuple[int, ...]:
+        sections = self._plan.sections
+        contraction = self._plan.color_contraction
+        if contraction is None:
+            raise ArtifactError(
+                "contracted exact execution has no color-contraction payload"
+            )
+        replayed = bool(sections.replay_targets)
+        expected_destination_count = (
+            contraction.destination_count
+            if replayed
+            else sections.amplitude_destination_count
+        )
+        if (
+            contraction.component_count != len(sections.resolved_helicities)
+            or contraction.destination_count != expected_destination_count
+            or len(contraction.destination_by_group) != contraction.group_count
+            or len(contraction.group_sector_ids) != contraction.group_count
+            or len(contraction.group_component_ids) != contraction.group_count
+        ):
+            raise ArtifactError(
+                "contracted color dimensions disagree with the recurrence plan"
+            )
+        direct_to_physics = self._direct_helicity_to_physics()
+        result = [DIRECT_NONE_U32] * contraction.destination_count
+        if replayed:
+            expected_coordinates = {
+                (target.public_flow_id, direct_helicity)
+                for target in sections.replay_targets
+                for direct_helicity in range(len(sections.resolved_helicities))
+            }
+            actual_coordinates = set(
+                zip(
+                    contraction.group_sector_ids,
+                    contraction.group_component_ids,
+                    strict=True,
+                )
+            )
+            if actual_coordinates != expected_coordinates:
+                raise ArtifactError(
+                    "contracted replay color coordinates disagree with the "
+                    "recurrence plan"
+                )
+            for group_id, destination_id in enumerate(contraction.destination_by_group):
+                try:
+                    physics_helicity = direct_to_physics[
+                        contraction.group_component_ids[group_id]
+                    ]
+                    previous = result[destination_id]
+                except IndexError as exc:
+                    raise ArtifactError(
+                        "contracted replay color mapping references an absent "
+                        "destination"
+                    ) from exc
+                if previous != DIRECT_NONE_U32:
+                    raise ArtifactError(
+                        "contracted replay color mapping repeats a destination"
+                    )
+                result[destination_id] = physics_helicity
+            if any(value == DIRECT_NONE_U32 for value in result):
+                raise ArtifactError(
+                    "contracted replay color mapping does not cover every destination"
+                )
+            return tuple(result)
+
+        for group_id, destination_id in enumerate(contraction.destination_by_group):
+            expected_sector = contraction.group_sector_ids[group_id]
+            direct_helicity = contraction.group_component_ids[group_id]
+            try:
+                destination = sections.amplitude_destinations[destination_id]
+                physics_helicity = direct_to_physics[direct_helicity]
+            except IndexError as exc:
+                raise ArtifactError(
+                    "contracted color mapping references an absent destination"
+                ) from exc
+            if (
+                destination.destination_id != destination_id
+                or destination.target_sector_id != expected_sector
+                or destination.target_helicity_id != direct_helicity
+                or result[destination_id] != DIRECT_NONE_U32
+            ):
+                raise ArtifactError(
+                    "contracted color mapping disagrees with recurrence destinations"
+                )
+            result[destination_id] = physics_helicity
+        if any(value == DIRECT_NONE_U32 for value in result):
+            raise ArtifactError(
+                "contracted color mapping does not cover every destination"
+            )
+        return tuple(result)
+
+    def _direct_helicity_to_physics(self) -> tuple[int, ...]:
+        sections = self._plan.sections
+        helicity_records = tuple(
+            _mapping(value, f"physics helicity {index}")
+            for index, value in enumerate(
+                _sequence(self._physics.get("helicities"), "physics helicities")
+            )
+        )
+        physics_by_values = {
+            tuple(
+                _signed_integer(component, "physics helicity component")
+                for component in _sequence(
+                    record.get("values"), "physics helicity values"
+                )
+            ): index
+            for index, record in enumerate(helicity_records)
+        }
+        result = [DIRECT_NONE_U32] * len(sections.resolved_helicities)
+        for descriptor in sections.resolved_helicities:
+            start = descriptor.public_helicity_start
+            stop = start + descriptor.public_helicity_count
+            vector = representative_vector_to_public(
+                sections.public_helicities[start:stop], self._permutation
+            )
+            if len(
+                vector
+            ) != sections.external_source_count or descriptor.helicity_id >= len(
+                result
+            ):
+                raise ArtifactError(
+                    "contracted recurrence helicity has invalid source coverage"
+                )
+            try:
+                physics_helicity = physics_by_values[vector]
+            except KeyError as exc:
+                raise ArtifactError(
+                    "contracted recurrence helicity is outside public coverage"
+                ) from exc
+            if result[descriptor.helicity_id] != DIRECT_NONE_U32:
+                raise ArtifactError("contracted recurrence repeats a direct helicity")
+            result[descriptor.helicity_id] = physics_helicity
+        if any(value == DIRECT_NONE_U32 for value in result):
+            raise ArtifactError(
+                "contracted recurrence does not map every direct helicity"
+            )
+        return tuple(result)
+
+
+def _signed_integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ArtifactError(f"{context} must be an integer")
+    return value
+
+
+__all__ = ["RecurrenceExactExecutor"]
diff --git a/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_plan.py b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_plan.py
new file mode 100644
index 0000000000..7ac544a63d
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_plan.py
@@ -0,0 +1,1080 @@
+# SPDX-License-Identifier: 0BSD
+"""Validated exact-execution view of a topology-replay recurrence artifact."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from decimal import Decimal
+from pathlib import Path
+
+from pyamplicol._internal.versions import (
+    PROCESS_ARTIFACT_SCHEMA_VERSION,
+    RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+    SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+)
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+from pyamplicol.artifacts.manifest import ArtifactManifest
+from pyamplicol.models.prepared import (
+    PreparedKernelPack,
+    PreparedKernelRecord,
+    PreparedModelBundle,
+)
+from pyamplicol.models.recurrence_direct_template import (
+    RECURRENCE_DIRECT_IDENTITY_FINALIZER,
+)
+from pyamplicol.runtime._evaluator_payloads import ExactEvaluatorPayloadResolver
+from pyamplicol.runtime.eager_exact._contracts import (
+    _complex_pair,
+    _KernelLoader,
+    _LazyExactKernel,
+    _mapping,
+    _sequence,
+)
+from pyamplicol.runtime.eager_exact._plan import (
+    _ExactModelParameterState,
+    _load_exact_kernel_pack,
+)
+from pyamplicol.runtime.symbolica_exact import _ExactEvaluator
+
+from ._color import (
+    RECURRENCE_CONTRACTED_COLOR_CAPABILITY,
+    _load_recurrence_color_contraction,
+    _RecurrenceColorContraction,
+)
+from ._plan_v2 import (
+    RECURRENCE_DIRECT_RUNTIME_CAPABILITY,
+    RECURRENCE_PLAN_V2_ABI,
+    RECURRENCE_RUNTIME_KIND,
+    RECURRENCE_RUNTIME_LAYOUT_V2_ABI,
+    _Current,
+    _Executor,
+    _load_recurrence_exact_sections_v1,
+    _NativeExactSectionsLoader,
+    _parse_exact_sections,
+    _RecurrenceExactSectionsV1,
+)
+
+_RECURRENCE_COLOR_CAPABILITY = "rusticol.recurrence-color.lc.v1"
+
+
+@dataclass(frozen=True, slots=True)
+class _ParameterProjectionRow:
+    runtime_slot: int
+    prepared_slot: int
+    component: int
+
+
+@dataclass(frozen=True, slots=True)
+class _RuntimeParameterSchemaRow:
+    runtime_slot: int
+    runtime_name: str
+    parameter_template_id: int
+    prepared_parameter_id: int | None
+    component: int
+    probe_policy: str = "native-template-default-perturbed-v1"
+
+
+@dataclass(frozen=True, slots=True)
+class _SourceTemplate:
+    template_id: int
+    dimension: int
+    helicity: int
+    chirality: int
+    spin_state: int
+    family: str
+    orientation: str
+    mass_prepared_parameter_id: int | None
+    crossing_helicity_factor: int
+    crossing_chirality_factor: int
+    crossing_spin_state_factor: int
+    mass_parameter_name: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class _PreparedParameterDerivation:
+    kernel: _LazyExactKernel
+    input_indices: tuple[int, ...]
+    output_indices: tuple[int | None, ...]
+
+    def evaluate(
+        self,
+        prepared_parameters: Sequence[tuple[Decimal, Decimal]],
+        precision: int,
+    ) -> tuple[tuple[Decimal, Decimal], ...]:
+        try:
+            inputs = tuple(prepared_parameters[index] for index in self.input_indices)
+        except IndexError as exc:
+            raise ArtifactError(
+                "recurrence parameter derivation input is out of range"
+            ) from exc
+        outputs = self.kernel.evaluate(inputs, precision)
+        if len(outputs) != len(self.output_indices):
+            raise ArtifactError(
+                "recurrence parameter derivation output count is inconsistent"
+            )
+        prepared = list(prepared_parameters)
+        for output, target in zip(outputs, self.output_indices, strict=True):
+            if target is not None:
+                prepared[target] = output
+        return tuple(prepared)
+
+
+@dataclass(slots=True)
+class _RecurrenceExactPlan:
+    sections: _RecurrenceExactSectionsV1
+    kernels: Mapping[int, _LazyExactKernel]
+    executors: Mapping[int, _Executor]
+    executor_exact_kernel_ids: Mapping[int, int]
+    executor_parent_permutations: Mapping[int, tuple[int, int]]
+    source_templates: Mapping[int, _SourceTemplate]
+    initial_source_slots: frozenset[int]
+    executor_couplings: Mapping[int, tuple[Decimal, Decimal]]
+    prepared_defaults: tuple[tuple[Decimal, Decimal], ...]
+    parameter_projection: tuple[_ParameterProjectionRow, ...]
+    parameter_derivation: _PreparedParameterDerivation | None
+    runtime_defaults: tuple[Decimal, ...] = ()
+    runtime_parameter_schema: tuple[_RuntimeParameterSchemaRow, ...] = ()
+    color_contraction: _RecurrenceColorContraction | None = None
+    external_source_slots: tuple[int, ...] = ()
+    # Populated lazily only after the complete plan boundary has validated.
+    # The recipes are construction/runtime-session state, never serialized.
+    trusted_executor_recipes: dict[int, object] = field(
+        default_factory=dict,
+        repr=False,
+    )
+    trusted_currents_by_stage: dict[int, tuple[_Current, ...]] = field(
+        default_factory=dict,
+        repr=False,
+    )
+
+    @classmethod
+    def load(
+        cls,
+        *,
+        artifact_root: Path,
+        process_id: str,
+        execution_path: str,
+        execution: Mapping[str, object],
+        manifest: ArtifactManifest,
+        kernel_loader: _KernelLoader | None,
+        exact_payloads: ExactEvaluatorPayloadResolver,
+        native_sections_loader: _NativeExactSectionsLoader | None = None,
+    ) -> _RecurrenceExactPlan:
+        _validate_execution(execution, process_id)
+        sections = _load_recurrence_exact_sections_v1(
+            artifact_root,
+            process_id,
+            loader=native_sections_loader,
+        )
+        color_contraction = _load_recurrence_color_contraction(
+            artifact_root=artifact_root,
+            process_id=process_id,
+            execution_path=execution_path,
+            execution=execution,
+            manifest=manifest,
+        )
+        pack, payload_root, effective_kernel_loader = _load_exact_kernel_pack(
+            artifact_root=artifact_root,
+            execution=execution,
+            manifest=manifest,
+            kernel_loader=kernel_loader,
+            exact_payloads=exact_payloads,
+        )
+        kernels = {
+            record.kernel_id: _LazyExactKernel(
+                record,
+                payload_root,
+                effective_kernel_loader,
+            )
+            for record in pack.kernels
+            if record.contract_kind != "model-parameter"
+        }
+        metadata = _mapping(execution.get("runtime_metadata"), "runtime metadata")
+        runtime_parameters = tuple(
+            _mapping(value, f"runtime parameter {index}")
+            for index, value in enumerate(
+                _sequence(metadata.get("runtime_parameters"), "runtime parameters")
+            )
+        )
+        runtime_defaults = _parse_runtime_parameter_defaults(runtime_parameters)
+        runtime_parameter_schema = _runtime_parameter_schema(
+            metadata,
+            runtime_parameters,
+        )
+        defaults = tuple(
+            _parse_complex_default(value, index)
+            for index, value in enumerate(
+                _sequence(
+                    metadata.get("prepared_parameter_defaults"),
+                    "prepared parameter defaults",
+                )
+            )
+        )
+        if len(defaults) != sections.parameter_value_count:
+            raise ArtifactError(
+                "prepared parameter defaults do not match the recurrence plan"
+            )
+        projection_rows, external_prepared_by_name = _parameter_projection(
+            metadata,
+            len(runtime_parameters),
+            len(defaults),
+        )
+        prepared_by_name = dict(
+            _prepared_parameter_indices(
+                pack.kernels,
+                len(defaults),
+            )
+        )
+        for name, prepared_index in external_prepared_by_name.items():
+            previous = prepared_by_name.setdefault(name, prepared_index)
+            if previous != prepared_index:
+                raise ArtifactError(
+                    f"prepared parameter {name!r} has conflicting stable indices"
+                )
+        derivation = _prepared_parameter_derivation(
+            pack.kernels,
+            payload_root,
+            effective_kernel_loader,
+            prepared_by_name,
+        )
+        executor_exact_kernel_ids = _executor_exact_kernel_ids(pack)
+        external_source_slots, initial_source_slots = _external_source_layout(
+            metadata,
+            sections.external_source_count,
+        )
+        result = cls(
+            sections=sections,
+            kernels=kernels,
+            executors={row.executor_id: row for row in sections.executors},
+            executor_exact_kernel_ids=executor_exact_kernel_ids,
+            executor_parent_permutations=_executor_parent_permutations(pack),
+            source_templates=_source_templates(metadata, prepared_by_name),
+            initial_source_slots=initial_source_slots,
+            executor_couplings=_executor_couplings(
+                pack,
+                executor_exact_kernel_ids,
+            ),
+            prepared_defaults=defaults,
+            parameter_projection=projection_rows,
+            parameter_derivation=derivation,
+            runtime_defaults=runtime_defaults,
+            runtime_parameter_schema=runtime_parameter_schema,
+            color_contraction=color_contraction,
+            external_source_slots=external_source_slots,
+        )
+        result._validate(pack)
+        return result
+
+    @classmethod
+    def from_generation(
+        cls,
+        *,
+        raw_sections: object,
+        process_id: str,
+        bundle: PreparedModelBundle,
+        runtime_metadata: Mapping[str, object],
+    ) -> _RecurrenceExactPlan:
+        """Construct an unpublished exact plan for generation-time probes."""
+
+        sections = _parse_exact_sections(raw_sections, process_id)
+        pack = bundle.kernel_pack
+        payload_root = Path()
+
+        def kernel_loader(
+            record: PreparedKernelRecord,
+            root: Path,
+        ) -> _ExactEvaluator:
+            return _ExactEvaluator.load(
+                {
+                    "evaluator_state_path": record.exact_evaluator_state_path,
+                    "input_len": record.input_arity,
+                },
+                root,
+                state_loader=bundle.read_payload,
+            )
+
+        kernels = {
+            record.kernel_id: _LazyExactKernel(
+                record,
+                payload_root,
+                kernel_loader,
+            )
+            for record in pack.kernels
+            if record.contract_kind != "model-parameter"
+        }
+        runtime_parameters = tuple(
+            _mapping(value, f"runtime parameter {index}")
+            for index, value in enumerate(
+                _sequence(
+                    runtime_metadata.get("runtime_parameters"),
+                    "runtime parameters",
+                )
+            )
+        )
+        runtime_defaults = _parse_runtime_parameter_defaults(runtime_parameters)
+        runtime_parameter_schema = _runtime_parameter_schema(
+            runtime_metadata,
+            runtime_parameters,
+        )
+        defaults = tuple(
+            _parse_complex_default(value, index)
+            for index, value in enumerate(
+                _sequence(
+                    runtime_metadata.get("prepared_parameter_defaults"),
+                    "prepared parameter defaults",
+                )
+            )
+        )
+        if len(defaults) != sections.parameter_value_count:
+            raise ArtifactError(
+                "prepared parameter defaults do not match the recurrence plan"
+            )
+        projection_rows, external_prepared_by_name = _parameter_projection(
+            runtime_metadata,
+            len(runtime_parameters),
+            len(defaults),
+        )
+        prepared_by_name = dict(
+            _prepared_parameter_indices(pack.kernels, len(defaults))
+        )
+        for name, prepared_index in external_prepared_by_name.items():
+            previous = prepared_by_name.setdefault(name, prepared_index)
+            if previous != prepared_index:
+                raise ArtifactError(
+                    f"prepared parameter {name!r} has conflicting stable indices"
+                )
+        derivation = _prepared_parameter_derivation(
+            pack.kernels,
+            payload_root,
+            kernel_loader,
+            prepared_by_name,
+        )
+        executor_exact_kernel_ids = _executor_exact_kernel_ids(pack)
+        external_source_slots, initial_source_slots = _external_source_layout(
+            runtime_metadata,
+            sections.external_source_count,
+        )
+        result = cls(
+            sections=sections,
+            kernels=kernels,
+            executors={row.executor_id: row for row in sections.executors},
+            executor_exact_kernel_ids=executor_exact_kernel_ids,
+            executor_parent_permutations=_executor_parent_permutations(pack),
+            source_templates=_source_templates(
+                runtime_metadata,
+                prepared_by_name,
+            ),
+            initial_source_slots=initial_source_slots,
+            executor_couplings=_executor_couplings(
+                pack,
+                executor_exact_kernel_ids,
+            ),
+            prepared_defaults=defaults,
+            parameter_projection=projection_rows,
+            parameter_derivation=derivation,
+            runtime_defaults=runtime_defaults,
+            runtime_parameter_schema=runtime_parameter_schema,
+            color_contraction=None,
+            external_source_slots=external_source_slots,
+        )
+        result._validate(pack, allow_missing_color_contraction=True)
+        return result
+
+    def resolve_model_parameters(
+        self,
+        runtime_parameters: Sequence[Decimal],
+        precision: int,
+    ) -> _ExactModelParameterState:
+        prepared = list(self.prepared_defaults)
+        for row in self.parameter_projection:
+            try:
+                value = runtime_parameters[row.runtime_slot]
+            except IndexError as exc:
+                raise ArtifactError(
+                    "recurrence runtime parameter projection is out of range"
+                ) from exc
+            real, imaginary = prepared[row.prepared_slot]
+            prepared[row.prepared_slot] = (
+                value if row.component == 0 else real,
+                value if row.component == 1 else imaginary,
+            )
+        runtime = tuple(runtime_parameters)
+        if self.parameter_derivation is None:
+            return _ExactModelParameterState(runtime, tuple(prepared))
+        return _ExactModelParameterState(
+            runtime,
+            self.parameter_derivation.evaluate(
+                prepared,
+                precision,
+            ),
+        )
+
+    def _validate(
+        self,
+        pack: PreparedKernelPack,
+        *,
+        allow_missing_color_contraction: bool = False,
+    ) -> None:
+        if (
+            self.sections.strategy == "contracted-color-union"
+            and self.color_contraction is None
+            and not allow_missing_color_contraction
+        ) or (
+            self.sections.strategy != "contracted-color-union"
+            and self.color_contraction is not None
+        ):
+            raise ArtifactError(
+                "recurrence exact plan and contracted-color payload disagree"
+            )
+        if len(self.executors) != len(self.sections.executors):
+            raise ArtifactError("recurrence direct executor IDs are duplicated")
+        pack_by_id = {record.kernel_id: record for record in pack.kernels}
+        expected_kind = {
+            "contribution": "vertex",
+            "finalization": "propagator",
+            "closure": "closure",
+        }
+        for executor in self.sections.executors:
+            parent_permutation = self.executor_parent_permutations.get(
+                executor.executor_id
+            )
+            if parent_permutation not in {(0, 1), (1, 0)}:
+                raise ArtifactError(
+                    f"direct executor {executor.executor_id} has no authenticated "
+                    "parent permutation"
+                )
+            if executor.role != "contribution" and parent_permutation != (0, 1):
+                raise ArtifactError(
+                    f"non-contribution executor {executor.executor_id} has a "
+                    "non-identity parent permutation"
+                )
+            exact_kernel_id = self.executor_exact_kernel_ids.get(
+                executor.executor_id,
+                executor.prepared_kernel_id,
+            )
+            if exact_kernel_id is None:
+                if executor.runtime_template is None:
+                    raise ArtifactError(
+                        f"direct executor {executor.executor_id} has no exact binding"
+                    )
+                continue
+            if (
+                executor.runtime_template is not None
+                and executor.executor_id not in self.executor_exact_kernel_ids
+            ):
+                raise ArtifactError(
+                    f"direct executor {executor.executor_id} mixes exact bindings"
+                )
+            record = pack_by_id.get(exact_kernel_id)
+            if record is None:
+                raise ArtifactError(
+                    f"direct executor {executor.executor_id} references absent "
+                    f"prepared kernel {exact_kernel_id}"
+                )
+            if record.contract_kind != expected_kind.get(executor.role):
+                raise ArtifactError(
+                    f"direct executor {executor.executor_id} has the wrong "
+                    "prepared kernel role"
+                )
+            if record.output_arity != executor.destination_component_count:
+                raise ArtifactError(
+                    f"direct executor {executor.executor_id} output width disagrees "
+                    "with its prepared kernel"
+                )
+        if self.sections.strategy in {"topology-replay", "contracted-color-union"}:
+            for source in self.sections.sources:
+                if (
+                    source.source_template_or_dispatch_domain
+                    not in self.source_templates
+                ):
+                    raise ArtifactError(
+                        "recurrence source references absent template "
+                        f"{source.source_template_or_dispatch_domain}"
+                    )
+        else:
+            for variant in self.sections.source_dispatch_variants:
+                if variant.source_template_id not in self.source_templates:
+                    raise ArtifactError(
+                        "recurrence source-dispatch variant references absent "
+                        f"template {variant.source_template_id}"
+                    )
+
+
+def _executor_exact_kernel_ids(
+    pack: PreparedKernelPack,
+) -> Mapping[int, int]:
+    """Recover exact kernels hidden behind certified native intrinsics."""
+
+    semantic_catalog = pack.recurrence_template_catalog
+    direct_catalog = pack.recurrence_direct_template_catalog
+    if semantic_catalog is None or direct_catalog is None:
+        raise ArtifactError(
+            "exact recurrence execution requires semantic and direct template catalogs"
+        )
+    kernels = {record.kernel_id: record for record in pack.kernels}
+    expected_kind = {
+        "contribution": "vertex",
+        "finalization": "propagator",
+        "closure": "closure",
+    }
+    result: dict[int, int] = {}
+    for direct in direct_catalog.templates:
+        kernel_id = direct.payload_binding.prepared_kernel_id
+        binding_id = direct.evaluator_binding_id
+        if kernel_id is None:
+            if binding_id >= len(semantic_catalog.evaluator_bindings):
+                if (
+                    binding_id == len(semantic_catalog.evaluator_bindings)
+                    and direct.role == "finalization"
+                    and direct.payload_binding.runtime_template
+                    == RECURRENCE_DIRECT_IDENTITY_FINALIZER
+                ):
+                    continue
+                raise ArtifactError(
+                    f"direct executor {direct.direct_executor_id} references "
+                    f"absent evaluator binding {binding_id}"
+                )
+            binding = semantic_catalog.evaluator_bindings[binding_id]
+            if binding.callable_kind != "prepared-kernel":
+                continue
+            kernel_id = binding.prepared_kernel_id
+        else:
+            if binding_id >= len(semantic_catalog.evaluator_bindings):
+                raise ArtifactError(
+                    f"direct executor {direct.direct_executor_id} references "
+                    f"absent evaluator binding {binding_id}"
+                )
+            binding = semantic_catalog.evaluator_bindings[binding_id]
+        if kernel_id is None:
+            raise ArtifactError(
+                f"direct executor {direct.direct_executor_id} has an empty exact "
+                "kernel binding"
+            )
+        if binding.resolver_key != direct.evaluator_resolver_key:
+            raise ArtifactError(
+                f"direct executor {direct.direct_executor_id} resolver does not "
+                "match its semantic evaluator binding"
+            )
+        record = kernels.get(kernel_id)
+        if record is None:
+            raise ArtifactError(
+                f"direct executor {direct.direct_executor_id} references absent "
+                f"prepared kernel {kernel_id}"
+            )
+        if record.contract_kind != expected_kind.get(direct.role):
+            raise ArtifactError(
+                f"direct executor {direct.direct_executor_id} exact kernel has "
+                "the wrong role"
+            )
+        result[direct.direct_executor_id] = kernel_id
+    return result
+
+
+def _executor_parent_permutations(
+    pack: PreparedKernelPack,
+) -> Mapping[int, tuple[int, int]]:
+    """Recover authenticated prepared-kernel parent order for exact execution."""
+
+    direct_catalog = pack.recurrence_direct_template_catalog
+    if direct_catalog is None:
+        raise ArtifactError(
+            "exact recurrence execution requires a direct template catalog"
+        )
+    result: dict[int, tuple[int, int]] = {}
+    for direct in direct_catalog.templates:
+        permutation = direct.payload_binding.contribution_parent_permutation
+        if permutation not in {(0, 1), (1, 0)}:
+            raise ArtifactError(
+                f"direct executor {direct.direct_executor_id} has an invalid "
+                "parent permutation"
+            )
+        if direct.role != "contribution" and permutation != (0, 1):
+            raise ArtifactError(
+                f"non-contribution executor {direct.direct_executor_id} has a "
+                "non-identity parent permutation"
+            )
+        previous = result.setdefault(direct.direct_executor_id, permutation)
+        if previous != permutation:
+            raise ArtifactError(
+                f"direct executor {direct.direct_executor_id} has conflicting "
+                "parent permutations"
+            )
+    return result
+
+
+def _executor_couplings(
+    pack: PreparedKernelPack,
+    executor_exact_kernel_ids: Mapping[int, int],
+) -> Mapping[int, tuple[Decimal, Decimal]]:
+    semantic_catalog = pack.recurrence_template_catalog
+    direct_catalog = pack.recurrence_direct_template_catalog
+    if semantic_catalog is None or direct_catalog is None:
+        raise ArtifactError(
+            "exact recurrence execution requires semantic and direct template catalogs"
+        )
+    semantic_records = {
+        record.template_id: record
+        for records in (
+            semantic_catalog.transitions,
+            semantic_catalog.closures,
+        )
+        for record in records
+    }
+    kernels = {record.kernel_id: record for record in pack.kernels}
+    result: dict[int, tuple[Decimal, Decimal]] = {}
+    for direct in direct_catalog.templates:
+        kernel_id = executor_exact_kernel_ids.get(direct.direct_executor_id)
+        if kernel_id is None:
+            continue
+        kernel = kernels.get(kernel_id)
+        if kernel is None:
+            raise ArtifactError(
+                f"direct executor {direct.direct_executor_id} references absent "
+                f"prepared kernel {kernel_id}"
+            )
+        if not any(
+            contract.get("role") in {"coupling-real", "coupling-imag"}
+            for contract in kernel.input_contracts
+        ):
+            continue
+        records = tuple(
+            semantic_records.get(template_id)
+            for template_id in direct.semantic_template_ids
+        )
+        if any(record is None for record in records):
+            raise ArtifactError(
+                f"direct executor {direct.direct_executor_id} has no uniform exact "
+                "semantic coupling"
+            )
+        couplings = {
+            record.binding_coupling for record in records if record is not None
+        }
+        if len(couplings) != 1:
+            raise ArtifactError(
+                f"direct executor {direct.direct_executor_id} has no uniform exact "
+                "semantic coupling"
+            )
+        coupling = next(iter(couplings))
+        result[direct.direct_executor_id] = (
+            Decimal(coupling.real_numerator) / Decimal(coupling.real_denominator),
+            Decimal(coupling.imag_numerator) / Decimal(coupling.imag_denominator),
+        )
+    return result
+
+
+def _validate_execution(
+    execution: Mapping[str, object],
+    process_id: str,
+) -> None:
+    if execution.get("schema_version") != PROCESS_ARTIFACT_SCHEMA_VERSION:
+        raise CompatibilityError(
+            f"unsupported recurrence process schema {execution.get('schema_version')!r}"
+        )
+    if execution.get("kind") != RECURRENCE_RUNTIME_KIND:
+        raise CompatibilityError(
+            f"unsupported exact recurrence kind {execution.get('kind')!r}"
+        )
+    if execution.get("key") != process_id:
+        raise ArtifactError("recurrence execution metadata selects the wrong process")
+    if execution.get("recurrence_plan_abi") != RECURRENCE_PLAN_V2_ABI:
+        raise CompatibilityError(
+            f"unsupported recurrence plan ABI {execution.get('recurrence_plan_abi')!r}"
+        )
+    if execution.get("runtime_layout_abi") != RECURRENCE_RUNTIME_LAYOUT_V2_ABI:
+        raise CompatibilityError(
+            f"unsupported recurrence runtime-layout ABI "
+            f"{execution.get('runtime_layout_abi')!r}"
+        )
+    summary = _mapping(execution.get("recurrence_summary"), "recurrence summary")
+    layout = summary.get("lc_flow_layout")
+    if layout not in {
+        "topology-replay",
+        "all-flow-union",
+        "contracted-color-union",
+    }:
+        raise CompatibilityError(
+            "unsupported exact recurrence LC flow layout "
+            f"{summary.get('lc_flow_layout')!r}"
+        )
+    capabilities = execution.get("required_runtime_capabilities")
+    color_capability = (
+        RECURRENCE_CONTRACTED_COLOR_CAPABILITY
+        if layout == "contracted-color-union"
+        else _RECURRENCE_COLOR_CAPABILITY
+    )
+    required_capabilities = {
+        RECURRENCE_DIRECT_RUNTIME_CAPABILITY,
+        color_capability,
+    }
+    actual_capabilities = set(_sequence(capabilities, "recurrence capabilities"))
+    permitted_capabilities = required_capabilities | {
+        RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+    }
+    if layout == "contracted-color-union":
+        permitted_capabilities.add(SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY)
+    if not required_capabilities <= actual_capabilities or not (
+        actual_capabilities <= permitted_capabilities
+    ):
+        raise CompatibilityError("unsupported recurrence runtime capability contract")
+    color_accuracy = execution.get("color_accuracy")
+    if (layout == "contracted-color-union") != (color_accuracy in {"nlc", "full"}):
+        raise ArtifactError(
+            "recurrence layout and color-accuracy contracts are inconsistent"
+        )
+
+
+def _parse_complex_default(
+    raw: object,
+    index: int,
+) -> tuple[Decimal, Decimal]:
+    values = _sequence(raw, f"prepared parameter default {index}")
+    if len(values) != 2:
+        raise ArtifactError(
+            f"prepared parameter default {index} must be a complex pair"
+        )
+    return _complex_pair(
+        values[0],
+        values[1],
+        f"prepared parameter default {index}",
+    )
+
+
+def _parse_runtime_parameter_defaults(
+    runtime_parameters: Sequence[Mapping[str, object]],
+) -> tuple[Decimal, ...]:
+    defaults = []
+    for index, parameter in enumerate(runtime_parameters):
+        if parameter.get("parameter_index") != index:
+            raise ArtifactError(
+                f"runtime parameter {index} has a non-canonical parameter index"
+            )
+        defaults.append(
+            _complex_pair(
+                parameter.get("default"),
+                0,
+                f"runtime parameter {index} default",
+            )[0]
+        )
+    return tuple(defaults)
+
+
+def _parameter_projection(
+    metadata: Mapping[str, object],
+    runtime_count: int,
+    prepared_count: int,
+) -> tuple[tuple[_ParameterProjectionRow, ...], Mapping[str, int]]:
+    rows = []
+    by_name: dict[str, int] = {}
+    for index, raw in enumerate(
+        _sequence(metadata.get("parameter_projection"), "parameter projection")
+    ):
+        row = _mapping(raw, f"parameter projection {index}")
+        runtime_slot = _nonnegative_int(
+            row.get("runtime_slot"), f"parameter projection {index} runtime slot"
+        )
+        component = _nonnegative_int(
+            row.get("component"), f"parameter projection {index} component"
+        )
+        prepared_slot = row.get("prepared_parameter_id")
+        name = row.get("runtime_name")
+        if not isinstance(name, str) or not name:
+            raise ArtifactError(f"parameter projection {index} has no runtime name")
+        if prepared_slot is None:
+            continue
+        prepared_slot = _nonnegative_int(
+            prepared_slot, f"parameter projection {index} prepared slot"
+        )
+        if (
+            runtime_slot >= runtime_count
+            or prepared_slot >= prepared_count
+            or component not in {0, 1}
+        ):
+            raise ArtifactError(f"parameter projection {index} is out of range")
+        previous = by_name.setdefault(name, prepared_slot)
+        if previous != prepared_slot:
+            raise ArtifactError(
+                f"prepared parameter {name!r} has conflicting stable indices"
+            )
+        rows.append(_ParameterProjectionRow(runtime_slot, prepared_slot, component))
+    return tuple(rows), by_name
+
+
+def _runtime_parameter_schema(
+    metadata: Mapping[str, object],
+    runtime_parameters: Sequence[Mapping[str, object]],
+) -> tuple[_RuntimeParameterSchemaRow, ...]:
+    raw_projection = tuple(
+        _mapping(value, f"parameter projection {index}")
+        for index, value in enumerate(
+            _sequence(metadata.get("parameter_projection"), "parameter projection")
+        )
+    )
+    if len(raw_projection) != len(runtime_parameters):
+        raise ArtifactError(
+            "recurrence runtime parameter schema does not cover every flattened slot"
+        )
+    rows: list[_RuntimeParameterSchemaRow] = []
+    for index, (projection, parameter) in enumerate(
+        zip(raw_projection, runtime_parameters, strict=True)
+    ):
+        runtime_slot = _nonnegative_int(
+            projection.get("runtime_slot"),
+            f"parameter projection {index} runtime slot",
+        )
+        parameter_index = _nonnegative_int(
+            parameter.get("parameter_index"),
+            f"runtime parameter {index} parameter index",
+        )
+        runtime_name = projection.get("runtime_name")
+        if (
+            runtime_slot != index
+            or parameter_index != index
+            or not isinstance(runtime_name, str)
+            or not runtime_name
+        ):
+            raise ArtifactError(
+                f"recurrence runtime parameter schema row {index} is not canonical"
+            )
+        prepared_parameter_id = projection.get("prepared_parameter_id")
+        if prepared_parameter_id is not None:
+            prepared_parameter_id = _nonnegative_int(
+                prepared_parameter_id,
+                f"parameter projection {index} prepared parameter ID",
+            )
+        parameter_kind = parameter.get("kind")
+        if not isinstance(parameter_kind, str) or not parameter_kind:
+            raise ArtifactError(
+                f"runtime parameter {index} has no canonical parameter kind"
+            )
+        probe_policy = (
+            "derived-overwritten-fixed-zero-v1"
+            if parameter_kind in {"derived", "derived_parameter_component"}
+            else "native-template-default-perturbed-v1"
+        )
+        rows.append(
+            _RuntimeParameterSchemaRow(
+                runtime_slot=runtime_slot,
+                runtime_name=runtime_name,
+                parameter_template_id=_nonnegative_int(
+                    projection.get("parameter_template_id"),
+                    f"parameter projection {index} parameter template ID",
+                ),
+                prepared_parameter_id=prepared_parameter_id,
+                component=_nonnegative_int(
+                    projection.get("component"),
+                    f"parameter projection {index} component",
+                ),
+                probe_policy=probe_policy,
+            )
+        )
+    return tuple(rows)
+
+
+def _prepared_parameter_indices(
+    kernels: Sequence[PreparedKernelRecord],
+    prepared_count: int,
+) -> Mapping[str, int]:
+    by_name: dict[str, int] = {}
+    by_index: dict[int, str] = {}
+    for kernel in kernels:
+        for input_index, contract in enumerate(kernel.input_contracts):
+            if contract.get("role") != "model-parameter":
+                continue
+            name = contract.get("model_parameter_name")
+            prepared_index = contract.get("model_parameter_index")
+            if not isinstance(name, str) or not name:
+                raise ArtifactError(
+                    f"prepared kernel {kernel.kernel_id} input {input_index} "
+                    "has no model-parameter name"
+                )
+            if (
+                isinstance(prepared_index, bool)
+                or not isinstance(prepared_index, int)
+                or prepared_index < 0
+                or prepared_index >= prepared_count
+            ):
+                raise ArtifactError(
+                    f"prepared kernel {kernel.kernel_id} input {input_index} "
+                    "has an invalid model-parameter index"
+                )
+            previous_index = by_name.setdefault(name, prepared_index)
+            if previous_index != prepared_index:
+                raise ArtifactError(
+                    f"prepared parameter {name!r} has conflicting stable indices"
+                )
+            previous_name = by_index.setdefault(prepared_index, name)
+            if previous_name != name:
+                raise ArtifactError(
+                    f"prepared parameter index {prepared_index} has conflicting names"
+                )
+    return by_name
+
+
+def _prepared_parameter_derivation(
+    kernels: Sequence[PreparedKernelRecord],
+    payload_root: Path,
+    kernel_loader: _KernelLoader,
+    prepared_by_name: Mapping[str, int],
+) -> _PreparedParameterDerivation | None:
+    records = tuple(
+        kernel for kernel in kernels if kernel.contract_kind == "model-parameter"
+    )
+    if not records:
+        return None
+    if len(records) != 1:
+        raise ArtifactError(
+            "recurrence prepared pack declares multiple model-parameter kernels"
+        )
+    record = records[0]
+    input_indices = []
+    for input_index, contract in enumerate(record.input_contracts):
+        if contract.get("role") != "model-parameter":
+            raise ArtifactError(
+                f"model-parameter kernel input {input_index} has an invalid role"
+            )
+        name = contract.get("model_parameter_name")
+        prepared_index = contract.get("model_parameter_index")
+        if (
+            not isinstance(name, str)
+            or isinstance(prepared_index, bool)
+            or not isinstance(prepared_index, int)
+            or prepared_by_name.get(name) != prepared_index
+        ):
+            raise ArtifactError(
+                f"model-parameter kernel input {input_index} has no stable "
+                "prepared-parameter binding"
+            )
+        input_indices.append(prepared_index)
+
+    output_indices = []
+    seen_outputs: set[str] = set()
+    prefix = "model-parameter:"
+    for output_index, layout in enumerate(record.output_layout):
+        if not layout.startswith(prefix) or len(layout) == len(prefix):
+            raise ArtifactError(
+                f"model-parameter kernel output {output_index} has invalid layout"
+            )
+        name = layout[len(prefix) :]
+        if name != name.strip() or name in seen_outputs:
+            raise ArtifactError(
+                f"model-parameter kernel output {output_index} has invalid name"
+            )
+        seen_outputs.add(name)
+        output_indices.append(prepared_by_name.get(name))
+    return _PreparedParameterDerivation(
+        kernel=_LazyExactKernel(record, payload_root, kernel_loader),
+        input_indices=tuple(input_indices),
+        output_indices=tuple(output_indices),
+    )
+
+
+def _source_templates(
+    metadata: Mapping[str, object],
+    prepared_by_name: Mapping[str, int],
+) -> Mapping[int, _SourceTemplate]:
+    result = {}
+    for index, raw in enumerate(
+        _sequence(metadata.get("source_templates"), "source templates")
+    ):
+        source = _mapping(raw, f"source template {index}")
+        template_id = _nonnegative_int(
+            source.get("source_template_id"), f"source template {index} ID"
+        )
+        source_ir = _mapping(source.get("source_ir"), f"source template {index} IR")
+        identity = _mapping(
+            source_ir.get("identity"), f"source template {index} identity"
+        )
+        orientation = identity.get("orientation")
+        family = source_ir.get("wavefunction_family")
+        if orientation not in {"particle", "antiparticle", "self-conjugate"}:
+            raise ArtifactError(f"source template {index} has invalid orientation")
+        if family not in {"scalar", "fermion", "vector", "spin2"}:
+            raise CompatibilityError(
+                f"exact recurrence source family {family!r} is unsupported"
+            )
+        crossing = _mapping(source.get("crossing"), f"source template {index} crossing")
+        mass_name = source_ir.get("mass_parameter")
+        if mass_name is not None and not isinstance(mass_name, str):
+            raise ArtifactError(f"source template {index} has invalid mass parameter")
+        mass_prepared_parameter_id = (
+            None if mass_name is None else prepared_by_name.get(mass_name)
+        )
+        if mass_name is not None and mass_prepared_parameter_id is None:
+            raise ArtifactError(
+                f"source template {index} mass parameter {mass_name!r} "
+                "has no stable prepared binding"
+            )
+        if template_id in result:
+            raise ArtifactError(f"source template ID {template_id} is duplicated")
+        result[template_id] = _SourceTemplate(
+            template_id=template_id,
+            dimension=_nonnegative_int(
+                source.get("dimension"), f"source template {index} dimension"
+            ),
+            helicity=_signed_int(
+                source.get("helicity"), f"source template {index} helicity"
+            ),
+            chirality=_signed_int(
+                source.get("chirality"), f"source template {index} chirality"
+            ),
+            spin_state=_signed_int(
+                source.get("spin_state"), f"source template {index} spin state"
+            ),
+            family=str(family),
+            orientation=str(orientation),
+            mass_prepared_parameter_id=mass_prepared_parameter_id,
+            crossing_helicity_factor=_signed_int(
+                crossing.get("helicity_factor"),
+                f"source template {index} crossing helicity",
+            ),
+            crossing_chirality_factor=_signed_int(
+                crossing.get("chirality_factor"),
+                f"source template {index} crossing chirality",
+            ),
+            crossing_spin_state_factor=_signed_int(
+                crossing.get("spin_state_factor"),
+                f"source template {index} crossing spin",
+            ),
+            mass_parameter_name=mass_name,
+        )
+    return result
+
+
+def _external_source_layout(
+    metadata: Mapping[str, object],
+    expected_count: int,
+) -> tuple[tuple[int, ...], frozenset[int]]:
+    initial = set()
+    ordered_slots = []
+    seen = set()
+    for index, raw in enumerate(
+        _sequence(metadata.get("external_legs"), "external legs")
+    ):
+        leg = _mapping(raw, f"external leg {index}")
+        slot = _nonnegative_int(leg.get("source_slot"), f"external leg {index} slot")
+        is_initial = leg.get("is_initial")
+        if not isinstance(is_initial, bool) or slot in seen:
+            raise ArtifactError(f"external leg {index} has invalid source metadata")
+        ordered_slots.append(slot)
+        seen.add(slot)
+        if is_initial:
+            initial.add(slot)
+    if len(seen) != expected_count or seen != set(range(expected_count)):
+        raise ArtifactError("external source slots must be dense from zero")
+    return tuple(ordered_slots), frozenset(initial)
+
+
+def _nonnegative_int(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise ArtifactError(f"{context} must be a non-negative integer")
+    return value
+
+
+def _signed_int(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ArtifactError(f"{context} must be an integer")
+    return value
+
+
+__all__ = ["_RecurrenceExactPlan"]
diff --git a/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_plan_v2.py b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_plan_v2.py
new file mode 100644
index 0000000000..40c4d54a9c
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/recurrence_exact/_plan_v2.py
@@ -0,0 +1,848 @@
+# SPDX-License-Identifier: 0BSD
+"""Typed adapter for authenticated recurrence plan-v2 exact sections."""
+
+from __future__ import annotations
+
+import importlib
+import os
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol, TypeVar, cast
+
+from pyamplicol._internal.versions import verify_native_module
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+from pyamplicol.runtime.eager_exact._contracts import (
+    _integer,
+    _mapping,
+    _sequence,
+)
+
+RECURRENCE_EXACT_SECTIONS_ABI = "pyamplicol-recurrence-exact-sections-v1"
+RECURRENCE_PLAN_V2_ABI = "pyamplicol-recurrence-plan-v2"
+RECURRENCE_RUNTIME_LAYOUT_V2_ABI = "pyamplicol-recurrence-runtime-layout-v2"
+RECURRENCE_RUNTIME_KIND = "pyamplicol-runtime-recurrence-execution"
+RECURRENCE_DIRECT_RUNTIME_CAPABILITY = "rusticol.recurrence-direct-arena.complex-f64.v1"
+DIRECT_NONE_U32 = (1 << 32) - 1
+_NATIVE_BINDING_NAME = "_load_recurrence_exact_sections_v1"
+
+
+class _NativeExactSectionsBinding(Protocol):
+    def __call__(self, artifact_root: str, process_id: str, /) -> object: ...
+
+
+_NativeExactSectionsLoader = Callable[[Path, str], object]
+_RowT = TypeVar("_RowT")
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactFactor:
+    real_numerator: int
+    real_denominator: int
+    imaginary_numerator: int
+    imaginary_denominator: int
+
+
+@dataclass(frozen=True, slots=True)
+class _Current:
+    semantic_id: int
+    node_kind: int
+    state_template_id: int
+    component_base: int
+    component_count: int
+    momentum_form_id: int
+    stage: int
+    selector_domain_id: int
+    first_use: int
+    last_use: int
+    source_row: int
+    finalization_row: int
+
+
+@dataclass(frozen=True, slots=True)
+class _Source:
+    source_slot: int
+    destination_base: int
+    momentum_form_id: int
+    source_template_or_dispatch_domain: int
+    spin_state_class: int
+    exact_factor_id: int
+    selector_domain_id: int
+
+
+@dataclass(frozen=True, slots=True)
+class _Contribution:
+    parent0_base: int
+    parent1_base: int
+    parent0_momentum: int
+    parent1_momentum: int
+    destination_base: int
+    exact_factor_id: int
+    selector_domain_id: int
+    flags: int
+
+
+@dataclass(frozen=True, slots=True)
+class _Finalization:
+    component_base: int
+    component_count: int
+    momentum_form_id: int
+    exact_factor_id: int
+    selector_domain_id: int
+    flags: int
+
+
+@dataclass(frozen=True, slots=True)
+class _Closure:
+    parent0_base: int
+    parent1_base: int
+    parent0_momentum: int
+    parent1_momentum: int
+    amplitude_destination_id: int
+    exact_factor_id: int
+    component_factor_start: int
+    component_count: int
+    selector_domain_id: int
+    flags: int
+
+
+@dataclass(frozen=True, slots=True)
+class _RowGroup:
+    stage: int
+    role: int
+    destination_operation: int
+    executor_id: int
+    row_start: int
+    row_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class _MomentumForm:
+    term_start: int
+    term_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class _MomentumTerm:
+    source_slot: int
+    coefficient: int
+
+
+@dataclass(frozen=True, slots=True)
+class _ReplayTarget:
+    public_flow_id: int
+    representative_id: int
+    source_permutation_start: int
+    source_permutation_count: int
+    helicity_map_start: int
+    helicity_map_count: int
+    phase_factor_id: int
+    multiplicity: int
+    selector_domain_id: int
+
+
+@dataclass(frozen=True, slots=True)
+class _AmplitudeDestination:
+    closure_row_start: int
+    destination_id: int
+    target_sector_id: int
+    target_helicity_id: int
+    closure_row_count: int
+    selector_domain_id: int
+
+
+@dataclass(frozen=True, slots=True)
+class _ResolvedHelicity:
+    source_state_start: int
+    source_selection_start: int
+    public_helicity_start: int
+    helicity_id: int
+    source_state_count: int
+    source_selection_count: int
+    public_helicity_count: int
+    selector_domain_id: int
+
+
+@dataclass(frozen=True, slots=True)
+class _SourceStateAssignment:
+    source_slot: int
+    state_index: int
+
+
+@dataclass(frozen=True, slots=True)
+class _SourceDispatchVariant:
+    embedding_start: int
+    projection_start: int
+    source_row_id: int
+    dispatch_domain_id: int
+    runtime_variant_id: int
+    source_state_index: int
+    source_template_id: int
+    source_state_template_id: int
+    crossed_state_template_id: int
+    crossed_spin_state_class: int
+    executor_id: int
+    crossing_exact_factor_id: int
+    embedding_count: int
+    projection_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class _SourceEmbedding:
+    full_component: int
+    source_component: int
+    exact_factor_id: int
+
+
+@dataclass(frozen=True, slots=True)
+class _SourceProjection:
+    source_component: int
+    full_component: int
+
+
+@dataclass(frozen=True, slots=True)
+class _ResolvedSourceSelection:
+    source_slot: int
+    dispatch_variant_id: int
+
+
+@dataclass(frozen=True, slots=True)
+class _Executor:
+    executor_id: int
+    role: str
+    destination_operation: str
+    parent_component_counts: tuple[int, ...]
+    destination_component_count: int
+    momentum_operand_count: int
+    prepared_kernel_id: int | None
+    runtime_template: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class _RecurrenceExactSectionsV1:
+    process_id: str
+    strategy: str
+    semantic_digest: str
+    runtime_layout_digest: str
+    current_arena_components: int
+    amplitude_destination_count: int
+    parameter_value_count: int
+    external_source_count: int
+    currents: tuple[_Current, ...]
+    sources: tuple[_Source, ...]
+    contributions: tuple[_Contribution, ...]
+    finalizations: tuple[_Finalization, ...]
+    closures: tuple[_Closure, ...]
+    row_groups: tuple[_RowGroup, ...]
+    momentum_forms: tuple[_MomentumForm, ...]
+    momentum_terms: tuple[_MomentumTerm, ...]
+    replay_targets: tuple[_ReplayTarget, ...]
+    source_permutations: tuple[int, ...]
+    replay_momentum_signs: tuple[int, ...]
+    replay_helicity_map: tuple[int, ...]
+    amplitude_destinations: tuple[_AmplitudeDestination, ...]
+    resolved_helicities: tuple[_ResolvedHelicity, ...]
+    source_state_assignments: tuple[_SourceStateAssignment, ...]
+    source_dispatch_variants: tuple[_SourceDispatchVariant, ...]
+    source_embeddings: tuple[_SourceEmbedding, ...]
+    source_projections: tuple[_SourceProjection, ...]
+    resolved_source_selections: tuple[_ResolvedSourceSelection, ...]
+    public_helicities: tuple[int, ...]
+    exact_factors: tuple[_ExactFactor, ...]
+    public_flow_ids: tuple[int, ...]
+    executors: tuple[_Executor, ...]
+
+
+def _load_recurrence_exact_sections_v1(
+    artifact_root: Path,
+    process_id: str,
+    *,
+    loader: _NativeExactSectionsLoader | None = None,
+) -> _RecurrenceExactSectionsV1:
+    raw = (loader or _native_exact_sections_loader)(artifact_root, process_id)
+    return _parse_exact_sections(raw, process_id)
+
+
+def _native_exact_sections_loader(artifact_root: Path, process_id: str) -> object:
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        verify_native_module(module)
+    except ImportError as exc:
+        raise CompatibilityError(
+            "compact recurrence exact execution requires pyamplicol._rusticol"
+        ) from exc
+    candidate = getattr(module, _NATIVE_BINDING_NAME, None)
+    if not callable(candidate):
+        raise CompatibilityError(
+            "compact recurrence exact execution requires the private native binding "
+            f"{_NATIVE_BINDING_NAME}"
+        )
+    binding = cast(_NativeExactSectionsBinding, candidate)
+    try:
+        return binding(os.fspath(artifact_root), process_id)
+    except (ArtifactError, CompatibilityError):
+        raise
+    except Exception as exc:
+        raise ArtifactError(
+            "could not load recurrence exact sections for process "
+            f"{process_id!r}: {exc}"
+        ) from exc
+
+
+def _parse_exact_sections(
+    raw: object,
+    process_id: str,
+) -> _RecurrenceExactSectionsV1:
+    root = _mapping(raw, "recurrence exact sections")
+    if root.get("abi") != RECURRENCE_EXACT_SECTIONS_ABI:
+        raise CompatibilityError(
+            f"unsupported recurrence exact-sections ABI {root.get('abi')!r}"
+        )
+    if root.get("runtime_layout_abi") != RECURRENCE_RUNTIME_LAYOUT_V2_ABI:
+        raise CompatibilityError(
+            f"unsupported recurrence runtime-layout ABI "
+            f"{root.get('runtime_layout_abi')!r}"
+        )
+    if root.get("process_id") != process_id:
+        raise ArtifactError("recurrence exact sections select the wrong process")
+    strategy = root.get("strategy")
+    if strategy not in {
+        "topology-replay",
+        "all-flow-union",
+        "contracted-color-union",
+    }:
+        raise CompatibilityError(f"unsupported exact recurrence strategy {strategy!r}")
+    counts = _row(root.get("counts"), 4, "recurrence exact counts")
+    sections = _RecurrenceExactSectionsV1(
+        process_id=process_id,
+        strategy=strategy,
+        semantic_digest=_digest(root.get("semantic_digest"), "semantic digest"),
+        runtime_layout_digest=_digest(
+            root.get("runtime_layout_digest"), "runtime-layout digest"
+        ),
+        current_arena_components=_integer(counts[0], "current arena count", minimum=1),
+        amplitude_destination_count=_integer(
+            counts[1], "amplitude destination count", minimum=1
+        ),
+        parameter_value_count=_integer(counts[2], "parameter count"),
+        external_source_count=_integer(counts[3], "external source count", minimum=1),
+        currents=_rows(root, "currents", 12, _Current),
+        sources=_rows(root, "sources", 7, _Source, signed_fields={4}),
+        contributions=_rows(root, "contributions", 8, _Contribution),
+        finalizations=_rows(root, "finalizations", 6, _Finalization),
+        closures=_rows(root, "closures", 10, _Closure),
+        row_groups=_rows(root, "row_groups", 6, _RowGroup),
+        momentum_forms=_rows(root, "momentum_forms", 2, _MomentumForm),
+        momentum_terms=_rows(
+            root, "momentum_terms", 2, _MomentumTerm, signed_fields={1}
+        ),
+        replay_targets=_rows(root, "replay_targets", 9, _ReplayTarget),
+        source_permutations=tuple(
+            _integer(value, f"source permutation {index}")
+            for index, value in enumerate(
+                _sequence(root.get("source_permutations"), "source permutations")
+            )
+        ),
+        replay_momentum_signs=tuple(
+            _integer(value, f"replay momentum sign {index}", minimum=-1)
+            for index, value in enumerate(
+                _sequence(
+                    root.get("replay_momentum_signs"),
+                    "replay momentum signs",
+                )
+            )
+        ),
+        replay_helicity_map=tuple(
+            _integer(value, f"replay helicity map {index}")
+            for index, value in enumerate(
+                _sequence(root.get("replay_helicity_map"), "replay helicity map")
+            )
+        ),
+        amplitude_destinations=_rows(
+            root, "amplitude_destinations", 6, _AmplitudeDestination
+        ),
+        resolved_helicities=_rows(root, "resolved_helicities", 8, _ResolvedHelicity),
+        source_state_assignments=_rows(
+            root,
+            "source_state_assignments",
+            2,
+            _SourceStateAssignment,
+        ),
+        source_dispatch_variants=_rows(
+            root,
+            "source_dispatch_variants",
+            14,
+            _SourceDispatchVariant,
+            signed_fields={9},
+        ),
+        source_embeddings=_rows(root, "source_embeddings", 3, _SourceEmbedding),
+        source_projections=_rows(root, "source_projections", 2, _SourceProjection),
+        resolved_source_selections=_rows(
+            root,
+            "resolved_source_selections",
+            2,
+            _ResolvedSourceSelection,
+        ),
+        public_helicities=tuple(
+            _signed_integer(value, f"public helicity {index}")
+            for index, value in enumerate(
+                _sequence(root.get("public_helicities"), "public helicities")
+            )
+        ),
+        exact_factors=tuple(
+            _parse_factor(row, index)
+            for index, row in enumerate(
+                _sequence(root.get("exact_factors"), "exact factors")
+            )
+        ),
+        public_flow_ids=tuple(
+            _integer(value, f"public flow {index}")
+            for index, value in enumerate(
+                _sequence(root.get("public_flow_ids"), "public flow IDs")
+            )
+        ),
+        executors=tuple(
+            _parse_executor(row, index)
+            for index, row in enumerate(
+                _sequence(root.get("executors"), "direct executors")
+            )
+        ),
+    )
+    _validate_sections(sections)
+    return sections
+
+
+def _row(raw: object, width: int, context: str) -> Sequence[object]:
+    values = _sequence(raw, context)
+    if len(values) != width:
+        raise ArtifactError(f"{context} must contain {width} fields")
+    return values
+
+
+def _rows(
+    root: Mapping[str, object],
+    name: str,
+    width: int,
+    row_type: Callable[..., _RowT],
+    *,
+    signed_fields: set[int] | None = None,
+) -> tuple[_RowT, ...]:
+    signed = signed_fields or set()
+    parsed = []
+    for index, raw in enumerate(_sequence(root.get(name), f"recurrence {name}")):
+        values = _row(raw, width, f"recurrence {name}[{index}]")
+        parsed.append(
+            row_type(
+                *(
+                    _signed_integer(value, f"{name}[{index}][{field}]")
+                    if field in signed
+                    else _integer(value, f"{name}[{index}][{field}]")
+                    for field, value in enumerate(values)
+                )
+            )
+        )
+    return tuple(parsed)
+
+
+def _signed_integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ArtifactError(f"{context} must be an integer")
+    return value
+
+
+def _decimal_integer(value: object, context: str) -> int:
+    if not isinstance(value, str) or not value:
+        raise ArtifactError(f"{context} must be a decimal integer string")
+    try:
+        parsed = int(value, 10)
+    except ValueError as exc:
+        raise ArtifactError(f"{context} must be a decimal integer string") from exc
+    if str(parsed) != value:
+        raise ArtifactError(f"{context} must use canonical decimal syntax")
+    return parsed
+
+
+def _parse_factor(raw: object, index: int) -> _ExactFactor:
+    values = _row(raw, 4, f"exact factor {index}")
+    factor = _ExactFactor(
+        *(
+            _decimal_integer(value, f"exact factor {index} field {field}")
+            for field, value in enumerate(values)
+        )
+    )
+    if factor.real_denominator <= 0 or factor.imaginary_denominator <= 0:
+        raise ArtifactError(f"exact factor {index} has a non-positive denominator")
+    return factor
+
+
+def _parse_executor(raw: object, index: int) -> _Executor:
+    values = _row(raw, 8, f"direct executor {index}")
+    role = values[1]
+    operation = values[2]
+    if not isinstance(role, str) or role not in {
+        "source",
+        "contribution",
+        "finalization",
+        "closure",
+    }:
+        raise ArtifactError(f"direct executor {index} has an invalid role")
+    if not isinstance(operation, str) or operation not in {
+        "initialize",
+        "add",
+        "finalize-in-place",
+        "closure-add",
+    }:
+        raise ArtifactError(f"direct executor {index} has an invalid operation")
+    parent_counts = tuple(
+        _integer(value, f"direct executor {index} parent count")
+        for value in _sequence(values[3], f"direct executor {index} parent counts")
+    )
+    prepared_kernel_id = values[6]
+    if prepared_kernel_id is not None:
+        prepared_kernel_id = _integer(
+            prepared_kernel_id, f"direct executor {index} prepared kernel"
+        )
+    runtime_template = values[7]
+    if runtime_template is not None and (
+        not isinstance(runtime_template, str) or not runtime_template
+    ):
+        raise ArtifactError(f"direct executor {index} has an invalid runtime template")
+    return _Executor(
+        executor_id=_integer(values[0], f"direct executor {index} ID"),
+        role=role,
+        destination_operation=operation,
+        parent_component_counts=parent_counts,
+        destination_component_count=_integer(
+            values[4], f"direct executor {index} destination count", minimum=1
+        ),
+        momentum_operand_count=_integer(
+            values[5], f"direct executor {index} momentum count"
+        ),
+        prepared_kernel_id=prepared_kernel_id,
+        runtime_template=runtime_template,
+    )
+
+
+def _digest(value: object, context: str) -> str:
+    if (
+        not isinstance(value, str)
+        or len(value) != 64
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise ArtifactError(f"recurrence {context} must be a lowercase SHA-256")
+    return value
+
+
+def _validate_sections(sections: _RecurrenceExactSectionsV1) -> None:
+    if tuple(row.semantic_id for row in sections.currents) != tuple(
+        range(len(sections.currents))
+    ):
+        raise ArtifactError("recurrence current IDs are not dense")
+    if tuple(row.executor_id for row in sections.executors) != tuple(
+        range(len(sections.executors))
+    ):
+        raise ArtifactError("recurrence direct executor IDs are not dense")
+    if tuple(row.destination_id for row in sections.amplitude_destinations) != tuple(
+        range(sections.amplitude_destination_count)
+    ):
+        raise ArtifactError("recurrence amplitude destination IDs are not dense")
+    if sections.strategy == "topology-replay":
+        _validate_replay_sections(sections)
+    elif sections.strategy == "all-flow-union":
+        _validate_union_sections(sections)
+    else:
+        _validate_contracted_sections(sections)
+
+
+def _validate_replay_sections(sections: _RecurrenceExactSectionsV1) -> None:
+    if len(sections.public_flow_ids) != len(sections.replay_targets):
+        raise ArtifactError("recurrence public flow and replay axes differ in size")
+    _validate_replay_tables(sections)
+
+
+def _validate_replay_tables(sections: _RecurrenceExactSectionsV1) -> None:
+    if not sections.replay_targets and (
+        sections.source_permutations
+        or sections.replay_momentum_signs
+        or sections.replay_helicity_map
+    ):
+        raise ArtifactError("recurrence replay tables have no replay targets")
+    if any(
+        len(permutation) != sections.external_source_count
+        or sorted(permutation) != list(range(sections.external_source_count))
+        for target in sections.replay_targets
+        for permutation in (
+            sections.source_permutations[
+                target.source_permutation_start : target.source_permutation_start
+                + target.source_permutation_count
+            ],
+        )
+    ):
+        raise ArtifactError(
+            "recurrence replay permutation is not a complete source bijection"
+        )
+    if len(sections.replay_momentum_signs) != len(sections.source_permutations) or any(
+        sign not in (-1, 1) for sign in sections.replay_momentum_signs
+    ):
+        raise ArtifactError(
+            "recurrence replay momentum signs do not match source permutations"
+        )
+    helicity_count = len(sections.resolved_helicities)
+    for target in sections.replay_targets:
+        mapped = sections.replay_helicity_map[
+            target.helicity_map_start : target.helicity_map_start
+            + target.helicity_map_count
+        ]
+        if len(mapped) != helicity_count or sorted(mapped) != list(
+            range(helicity_count)
+        ):
+            raise ArtifactError(
+                "recurrence replay helicity mapping is not a complete bijection"
+            )
+    if (
+        sections.source_dispatch_variants
+        or sections.source_embeddings
+        or sections.source_projections
+        or sections.resolved_source_selections
+    ):
+        raise ArtifactError("topology-replay plan carries union source-dispatch tables")
+    if any(row.source_selection_count for row in sections.resolved_helicities):
+        raise ArtifactError(
+            "topology-replay resolved helicity carries source selections"
+        )
+
+
+def _validate_union_sections(sections: _RecurrenceExactSectionsV1) -> None:
+    if (
+        sections.replay_targets
+        or sections.source_permutations
+        or sections.replay_momentum_signs
+        or sections.replay_helicity_map
+    ):
+        raise ArtifactError("all-flow-union plan carries topology replay tables")
+    if not sections.source_dispatch_variants:
+        raise ArtifactError("all-flow-union plan has no source-dispatch variants")
+    if not sections.resolved_source_selections:
+        raise ArtifactError("all-flow-union plan has no resolved source selections")
+
+    factor_count = len(sections.exact_factors)
+    for index, variant in enumerate(sections.source_dispatch_variants):
+        if variant.source_row_id >= len(sections.sources):
+            raise ArtifactError(
+                f"source-dispatch variant {index} references an absent source row"
+            )
+        source = sections.sources[variant.source_row_id]
+        if source.source_template_or_dispatch_domain != variant.dispatch_domain_id:
+            raise ArtifactError(
+                f"source-dispatch variant {index} has the wrong dispatch domain"
+            )
+        if (
+            variant.source_template_id == DIRECT_NONE_U32
+            or variant.crossing_exact_factor_id >= factor_count
+        ):
+            raise ArtifactError(
+                f"source-dispatch variant {index} has an invalid exact binding"
+            )
+        embeddings = _table_slice(
+            sections.source_embeddings,
+            variant.embedding_start,
+            variant.embedding_count,
+            f"source-dispatch variant {index} embeddings",
+        )
+        projections = _table_slice(
+            sections.source_projections,
+            variant.projection_start,
+            variant.projection_count,
+            f"source-dispatch variant {index} projections",
+        )
+        if tuple(row.full_component for row in embeddings) != tuple(
+            range(variant.embedding_count)
+        ):
+            raise ArtifactError(
+                f"source-dispatch variant {index} embeddings are not ordered"
+            )
+        for full_component, embedding in enumerate(embeddings):
+            if embedding.exact_factor_id >= factor_count:
+                raise ArtifactError(
+                    f"source-dispatch variant {index} has an invalid embedding factor"
+                )
+            factor = sections.exact_factors[embedding.exact_factor_id]
+            is_zero = factor.real_numerator == 0 and factor.imaginary_numerator == 0
+            if (embedding.source_component == DIRECT_NONE_U32) != is_zero:
+                raise ArtifactError(
+                    f"source-dispatch variant {index} has an inconsistent "
+                    "zero embedding"
+                )
+            if (
+                embedding.source_component != DIRECT_NONE_U32
+                and embedding.source_component >= variant.projection_count
+            ):
+                raise ArtifactError(
+                    f"source-dispatch variant {index} embedding is out of range"
+                )
+            if full_component != embedding.full_component:
+                raise ArtifactError(
+                    f"source-dispatch variant {index} embedding order is invalid"
+                )
+        for source_component, projection in enumerate(projections):
+            if (
+                projection.source_component != source_component
+                or projection.full_component >= variant.embedding_count
+                or embeddings[projection.full_component].source_component
+                != source_component
+            ):
+                raise ArtifactError(
+                    f"source-dispatch variant {index} projection is not inverse"
+                )
+
+    for index, helicity in enumerate(sections.resolved_helicities):
+        if (
+            helicity.source_state_count != sections.external_source_count
+            or helicity.source_selection_count != sections.external_source_count
+            or helicity.source_state_start + helicity.source_state_count
+            > len(sections.source_state_assignments)
+            or helicity.source_selection_start + helicity.source_selection_count
+            > len(sections.resolved_source_selections)
+        ):
+            raise ArtifactError(
+                f"resolved helicity {index} does not cover every external source"
+            )
+        assignments = _table_slice(
+            sections.source_state_assignments,
+            helicity.source_state_start,
+            helicity.source_state_count,
+            f"resolved helicity {index} source states",
+        )
+        selections = _table_slice(
+            sections.resolved_source_selections,
+            helicity.source_selection_start,
+            helicity.source_selection_count,
+            f"resolved helicity {index} source selections",
+        )
+        if (
+            len(assignments) != sections.external_source_count
+            or len(selections) != sections.external_source_count
+        ):
+            raise ArtifactError(
+                f"resolved helicity {index} does not cover every external source"
+            )
+        for source_slot, (assignment, selection) in enumerate(
+            zip(assignments, selections, strict=True)
+        ):
+            if (
+                assignment.source_slot != source_slot
+                or selection.source_slot != source_slot
+            ):
+                raise ArtifactError(
+                    f"resolved helicity {index} source rows are not ordered"
+                )
+            if selection.dispatch_variant_id >= len(sections.source_dispatch_variants):
+                raise ArtifactError(
+                    f"resolved helicity {index} selects an absent source variant"
+                )
+            variant = sections.source_dispatch_variants[selection.dispatch_variant_id]
+            source = sections.sources[variant.source_row_id]
+            if (
+                source.source_slot != source_slot
+                or variant.source_state_index != assignment.state_index
+            ):
+                raise ArtifactError(
+                    f"resolved helicity {index} source selection is inconsistent"
+                )
+
+    sectors = [row.target_sector_id for row in sections.amplitude_destinations]
+    if any(
+        row.target_helicity_id != DIRECT_NONE_U32
+        for row in sections.amplitude_destinations
+    ):
+        raise ArtifactError(
+            "all-flow-union amplitude destination fixes a numerical helicity"
+        )
+    if len(sectors) != len(set(sectors)) or set(sectors) != set(
+        sections.public_flow_ids
+    ):
+        raise ArtifactError(
+            "all-flow-union destinations are not completely covered by public flows"
+        )
+
+
+def _validate_contracted_sections(sections: _RecurrenceExactSectionsV1) -> None:
+    if sections.public_flow_ids:
+        raise ArtifactError(
+            "contracted-color recurrence carries a public color-flow axis"
+        )
+    _validate_replay_tables(sections)
+    if (
+        sections.source_dispatch_variants
+        or sections.source_embeddings
+        or sections.source_projections
+        or sections.resolved_source_selections
+    ):
+        raise ArtifactError(
+            "contracted-color recurrence carries union source-dispatch tables"
+        )
+    helicity_count = len(sections.resolved_helicities)
+    if helicity_count == 0:
+        raise ArtifactError("contracted-color recurrence has no resolved helicities")
+    for index, helicity in enumerate(sections.resolved_helicities):
+        if (
+            helicity.source_state_count != sections.external_source_count
+            or helicity.source_selection_count != 0
+            or helicity.source_state_start + helicity.source_state_count
+            > len(sections.source_state_assignments)
+        ):
+            raise ArtifactError(
+                f"contracted resolved helicity {index} has invalid source coverage"
+            )
+        assignments = _table_slice(
+            sections.source_state_assignments,
+            helicity.source_state_start,
+            helicity.source_state_count,
+            f"contracted resolved helicity {index} source states",
+        )
+        if tuple(row.source_slot for row in assignments) != tuple(
+            range(sections.external_source_count)
+        ):
+            raise ArtifactError(
+                f"contracted resolved helicity {index} source rows are not ordered"
+            )
+
+    actual = [
+        (row.target_sector_id, row.target_helicity_id)
+        for row in sections.amplitude_destinations
+    ]
+    if (
+        len(set(actual)) != len(actual)
+        or any(
+            helicity_id == DIRECT_NONE_U32 or helicity_id >= helicity_count
+            for _, helicity_id in actual
+        )
+        or {helicity_id for _, helicity_id in actual} != set(range(helicity_count))
+    ):
+        raise ArtifactError(
+            "contracted-color destinations have invalid sparse sector/helicity coverage"
+        )
+
+
+def _table_slice(
+    rows: Sequence[_RowT],
+    start: int,
+    count: int,
+    context: str,
+) -> Sequence[_RowT]:
+    stop = start + count
+    if start < 0 or stop > len(rows):
+        raise ArtifactError(f"{context} is out of bounds")
+    return rows[start:stop]
+
+
+__all__ = [
+    "DIRECT_NONE_U32",
+    "RECURRENCE_DIRECT_RUNTIME_CAPABILITY",
+    "RECURRENCE_PLAN_V2_ABI",
+    "RECURRENCE_RUNTIME_KIND",
+    "RECURRENCE_RUNTIME_LAYOUT_V2_ABI",
+    "_NativeExactSectionsLoader",
+    "_RecurrenceExactSectionsV1",
+    "_load_recurrence_exact_sections_v1",
+]
diff --git a/pyamplicol/src/pyamplicol/runtime/symbolica_exact.py b/pyamplicol/src/pyamplicol/runtime/symbolica_exact.py
new file mode 100644
index 0000000000..30f357a2bc
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/runtime/symbolica_exact.py
@@ -0,0 +1,4232 @@
+# SPDX-License-Identifier: 0BSD
+"""Lazy Symbolica-backed execution for non-f64 precision requests.
+
+The process artifact is a trusted executable input. Evaluator states are loaded
+with Symbolica's own ``Evaluator.load`` implementation; this module does not
+decode or reinterpret Symbolica's serialization format.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import struct
+from collections.abc import Callable, Iterator, Mapping, Sequence
+from dataclasses import dataclass
+from decimal import ROUND_HALF_EVEN, Decimal, InvalidOperation, localcontext
+from itertools import pairwise
+from pathlib import Path
+from typing import Any, TypedDict, cast
+
+from pyamplicol.api.errors import (
+    ArtifactError,
+    CompatibilityError,
+    DependencyError,
+    EvaluationError,
+)
+from pyamplicol.api.protocols import Momenta
+from pyamplicol.api.results import ResolvedEvaluation
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.artifacts.security import confined_path, normalize_relative_path
+from pyamplicol.runtime._color_topology_exact import (
+    apply_exact_color_replay_input_mapping,
+    parse_exact_color_topology_replay,
+    reduce_exact_color_topology_replay,
+)
+from pyamplicol.runtime._color_weight_exact import exact_color_weight
+from pyamplicol.runtime._evaluator_payloads import ExactEvaluatorPayloadResolver
+from pyamplicol.runtime._native_selection import (
+    exact_runtime_state_payload,
+    native_physics_axes,
+    native_process_selection,
+    remap_reduction,
+)
+from pyamplicol.runtime._normalization_exact import (
+    _DecimalComplexResult,
+    exact_normalization,
+)
+
+_ComplexDecimal = tuple[Decimal, Decimal]
+_ZERO = Decimal(0)
+_ONE = Decimal(1)
+_TWO = Decimal(2)
+_MINIMUM_SYMBOLICA_ARBITRARY_PRECISION = 40
+_ARITHMETIC_GUARD_DIGITS = 8
+
+
+class _RuntimeState(TypedDict):
+    model_parameter_values: Sequence[object]
+    normalization_factor: object
+
+
+@dataclass(frozen=True, slots=True)
+class _DiagnosticMassBinding:
+    """One authenticated external-mass binding for diagnostic kinematics."""
+
+    mass: Decimal
+    authority: str
+    parameter_name: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class _LcReplayRoute:
+    source_index: int
+    target_index: int
+    weight: Decimal
+
+
+@dataclass(frozen=True, slots=True)
+class _LcReplayEntry:
+    input_mapping: tuple[tuple[int, int], ...]
+    routes: tuple[_LcReplayRoute, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _LcReplayPlan:
+    entries: tuple[_LcReplayEntry, ...]
+    helicity_count: int
+    color_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class _LcMaterializedSector:
+    color_index: int
+    reduction_weight: Decimal
+
+
+@dataclass(frozen=True, slots=True)
+class _LcReplaySectorRoute:
+    physical_sector_id: int
+    materialized_sector_id: int
+    reduction_weight: Decimal
+    residual: bool
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactRuntimeSourceState:
+    helicity: int
+    chirality: int
+    spin_state: int
+    factor: _ComplexDecimal
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactHelicitySchedule:
+    physical_helicity_index: int
+    execution_helicity_index: int
+    selector_domain_id: int
+    structural_zero: bool
+    source_states: tuple[_ExactRuntimeSourceState | None, ...]
+    root_factors: tuple[_ComplexDecimal | None, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactHelicityPlan:
+    schedules: tuple[_ExactHelicitySchedule, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _ExactColorContractionEntry:
+    left_group_id: int
+    right_group_id: int
+    weight: _ComplexDecimal
+    symmetry_factor: Decimal
+
+
+def _json_integer(value: object) -> int:
+    return int(cast(int | float | str, value))
+
+
+def _decimal(value: object, context: str) -> Decimal:
+    try:
+        if isinstance(value, str) and value.startswith("binary64:"):
+            bits = value.removeprefix("binary64:")
+            if len(bits) != 16:
+                raise ValueError("binary64 payload must contain 16 hexadecimal digits")
+            result = Decimal.from_float(struct.unpack(">d", bytes.fromhex(bits))[0])
+        else:
+            result = value if isinstance(value, Decimal) else Decimal(str(value))
+    except (InvalidOperation, TypeError, ValueError) as exc:
+        raise EvaluationError(f"{context} is not a decimal scalar") from exc
+    if not result.is_finite():
+        raise EvaluationError(f"{context} must be finite")
+    return result
+
+
+def _complex_zero() -> _ComplexDecimal:
+    return (_ZERO, _ZERO)
+
+
+def _complex_mul(left: _ComplexDecimal, right: _ComplexDecimal) -> _ComplexDecimal:
+    return (
+        left[0] * right[0] - left[1] * right[1],
+        left[0] * right[1] + left[1] * right[0],
+    )
+
+
+def _upcast_decimal(value: Decimal, precision: int) -> Decimal:
+    """Encode ``value`` with at least the precision requested from Symbolica.
+
+    Symbolica honors the precision carried by each input ``Decimal``.  Values
+    such as ``Decimal("500")`` otherwise enter an arbitrary-precision evaluator
+    with only three significant digits and can reduce the precision of an
+    entire instruction chain.  The extra zeroes intentionally do not invent
+    information; they implement pyAmpliCol's documented upcast of input
+    kinematics and intermediate stage values.
+    """
+
+    with localcontext() as context:
+        context.prec = max(precision, len(value.as_tuple().digits), 1) + 2
+        context.rounding = ROUND_HALF_EVEN
+        if value.is_zero():
+            return Decimal((value.as_tuple().sign, (0,), -precision))
+        return Decimal(format(value, f".{precision - 1}E"))
+
+
+def _upcast_complex_inputs(
+    values: Sequence[_ComplexDecimal], precision: int
+) -> tuple[_ComplexDecimal, ...]:
+    return tuple(
+        (
+            _upcast_decimal(real, precision),
+            _upcast_decimal(imaginary, precision),
+        )
+        for real, imaginary in values
+    )
+
+
+def _working_precision(requested_precision: int) -> int:
+    # Symbolica uses a double-double shortcut at 32 decimal digits. Stay above that
+    # threshold for every request routed through the arbitrary-precision path.
+    return max(
+        requested_precision + _ARITHMETIC_GUARD_DIGITS,
+        _MINIMUM_SYMBOLICA_ARBITRARY_PRECISION,
+    )
+
+
+def _sqrt(value: Decimal, context: str) -> Decimal:
+    if value < 0:
+        raise EvaluationError(f"{context} encountered a negative square root")
+    return value.sqrt()
+
+
+def _fortran_sign(value: Decimal, sign_source: Decimal) -> Decimal:
+    return abs(value) if sign_source >= 0 else -abs(value)
+
+
+@dataclass(slots=True)
+class _ExactEvaluator:
+    input_len: int
+    evaluator: Any | None = None
+    chunks: tuple[_ExactEvaluator, ...] = ()
+    chunk_input_indices: tuple[tuple[int, ...], ...] = ()
+
+    @classmethod
+    def load(
+        cls,
+        manifest: Mapping[str, object],
+        root: Path,
+        *,
+        state_loader: Callable[[str], bytes] | None = None,
+    ) -> _ExactEvaluator:
+        kind = str(manifest.get("kind", ""))
+        if kind == "chunked-symbolica-evaluator":
+            raw_chunks = manifest.get("chunks")
+            if isinstance(raw_chunks, str | bytes) or not isinstance(
+                raw_chunks, Sequence
+            ):
+                raise ArtifactError("chunked evaluator has no chunk list")
+            evaluators: list[_ExactEvaluator] = []
+            for raw_chunk in raw_chunks:
+                if not isinstance(raw_chunk, Mapping):
+                    raise ArtifactError("chunked evaluator entry is not an object")
+                evaluators.append(cls.load(raw_chunk, root, state_loader=state_loader))
+            if not evaluators:
+                raise ArtifactError("chunked evaluator has no evaluators")
+            raw_input_len = manifest.get("input_len")
+            raw_input_indices = manifest.get("chunk_input_indices")
+            if raw_input_len is None and raw_input_indices is None:
+                child_lengths = {evaluator.input_len for evaluator in evaluators}
+                if len(child_lengths) != 1:
+                    raise ArtifactError(
+                        "legacy chunked evaluator children have inconsistent inputs"
+                    )
+                input_len = child_lengths.pop()
+                input_indices = tuple(
+                    tuple(range(input_len)) for _evaluator in evaluators
+                )
+            elif (
+                isinstance(raw_input_len, int)
+                and not isinstance(raw_input_len, bool)
+                and isinstance(raw_input_indices, Sequence)
+                and not isinstance(raw_input_indices, str | bytes)
+            ):
+                input_len = raw_input_len
+                input_indices = tuple(
+                    _exact_chunk_input_indices(indices, input_len)
+                    for indices in raw_input_indices
+                )
+            else:
+                raise ArtifactError("chunked evaluator input metadata is incomplete")
+            if len(input_indices) != len(evaluators):
+                raise ArtifactError(
+                    "chunked evaluator input maps do not match evaluator chunks"
+                )
+            for evaluator, indices in zip(evaluators, input_indices, strict=True):
+                if len(indices) != evaluator.input_len:
+                    raise ArtifactError(
+                        "chunked evaluator input map has inconsistent length"
+                    )
+            return cls(
+                input_len=input_len,
+                chunks=tuple(evaluators),
+                chunk_input_indices=input_indices,
+            )
+
+        state_path = manifest.get("evaluator_state_path")
+        if not isinstance(state_path, str) or not state_path:
+            raise CompatibilityError(
+                "higher-precision evaluation requires retained Symbolica evaluator "
+                "state; regenerate this process artifact with the JIT backend"
+            )
+        if state_loader is None:
+            path = (root / state_path).resolve(strict=False)
+            try:
+                path.relative_to(root.resolve(strict=True))
+            except ValueError as exc:
+                raise ArtifactError(
+                    "Symbolica evaluator state escapes the process root"
+                ) from exc
+        else:
+            normalized_state_path = normalize_relative_path(state_path)
+            path = root / normalized_state_path
+        try:
+            from symbolica import Evaluator
+        except ImportError as exc:
+            raise DependencyError(
+                "precision above 16 requires the Symbolica Python package; "
+                "f64 SymJIT evaluation remains Symbolica-independent"
+            ) from exc
+        if state_loader is None:
+            try:
+                state = path.read_bytes()
+            except OSError as exc:
+                raise CompatibilityError(
+                    f"could not read retained Symbolica evaluator state {path}: {exc}"
+                ) from exc
+        else:
+            state = state_loader(state_path)
+        try:
+            raw_leaf_input_len = manifest.get("input_len")
+            if isinstance(raw_leaf_input_len, bool) or not isinstance(
+                raw_leaf_input_len, int
+            ):
+                raise ArtifactError("evaluator state has no valid input length")
+            return cls(
+                input_len=raw_leaf_input_len,
+                evaluator=Evaluator.load(state),
+            )
+        except Exception as exc:
+            if isinstance(exc, ArtifactError):
+                raise
+            raise CompatibilityError(
+                f"Symbolica could not load retained evaluator state {path}: {exc}"
+            ) from exc
+
+    def evaluate(
+        self,
+        values: Sequence[_ComplexDecimal],
+        precision: int,
+    ) -> tuple[_ComplexDecimal, ...]:
+        prepared_values = _upcast_complex_inputs(values, precision)
+        if len(prepared_values) != self.input_len:
+            raise EvaluationError(
+                "Symbolica high-precision evaluator input width is inconsistent"
+            )
+        return self._evaluate_prepared(prepared_values, precision)
+
+    def _evaluate_prepared(
+        self,
+        values: tuple[_ComplexDecimal, ...],
+        precision: int,
+    ) -> tuple[_ComplexDecimal, ...]:
+        if self.evaluator is not None:
+            try:
+                result = self.evaluator.evaluate_complex_with_prec(values, precision)
+            except Exception as exc:
+                raise EvaluationError(
+                    f"Symbolica high-precision evaluator failed: {exc}"
+                ) from exc
+            return tuple(
+                (
+                    _decimal(real, "evaluator real output"),
+                    _decimal(imaginary, "evaluator imaginary output"),
+                )
+                for value in result
+                for real, imaginary in (value.to_decimal_tuple(),)
+            )
+
+        outputs: list[_ComplexDecimal] = []
+        for evaluator, indices in zip(
+            self.chunks,
+            self.chunk_input_indices,
+            strict=True,
+        ):
+            outputs.extend(
+                evaluator._evaluate_prepared(
+                    tuple(values[index] for index in indices),
+                    precision,
+                )
+            )
+        return tuple(outputs)
+
+
+class _ExactExpressionEvaluator:
+    """Evaluate retained parameter definitions without pre-rounding constants.
+
+    The optimized f64 evaluator requires Pi to be lowered when it is built.
+    Parameter derivation is small and runs once per call, so
+    its original expressions can instead be evaluated at the requested
+    precision. Matrix-element kernels retain their optimized evaluators.
+    """
+
+    def __init__(self, expressions: Sequence[str], parameters: Sequence[str]) -> None:
+        from symbolica import E
+
+        self.input_len = len(parameters)
+        self._expressions = tuple(E(value) for value in expressions)
+        self._parameters = tuple(E(value) for value in parameters)
+
+    def evaluate(
+        self,
+        values: Sequence[_ComplexDecimal],
+        precision: int,
+    ) -> tuple[_ComplexDecimal, ...]:
+        if len(values) != self.input_len:
+            raise EvaluationError(
+                "exact parameter evaluator input width is inconsistent"
+            )
+        substitutions = dict(
+            zip(
+                self._parameters,
+                _upcast_complex_inputs(values, precision),
+                strict=True,
+            )
+        )
+        try:
+            outputs = tuple(
+                expression.evaluate(
+                    cast(Any, substitutions), decimal_digit_precision=precision
+                )
+                for expression in self._expressions
+            )
+        except Exception as exc:
+            raise EvaluationError(f"exact parameter derivation failed: {exc}") from exc
+        return tuple(
+            (
+                _decimal(real, "derived real parameter"),
+                _decimal(imaginary, "derived imaginary parameter"),
+            )
+            for value in outputs
+            for real, imaginary in (
+                cast(_DecimalComplexResult, value).to_decimal_tuple(),
+            )
+        )
+
+    def evaluate_double_double(
+        self, values: Sequence[_ComplexDecimal]
+    ) -> tuple[_ComplexDecimal, ...]:
+        """Evaluate UFO expressions, including constants, with DoubleFloat."""
+        if len(values) != self.input_len:
+            raise EvaluationError(
+                "exact parameter evaluator input width is inconsistent"
+            )
+        prepared = _upcast_complex_inputs(values, 80)
+        try:
+            return tuple(
+                cast(
+                    _DecimalComplexResult,
+                    expression.evaluator(
+                        self._parameters, iterations=0, n_cores=1
+                    ).evaluate_complex_with_prec(prepared, 32)[0],
+                ).to_decimal_tuple()
+                for expression in self._expressions
+            )
+        except Exception as exc:
+            raise EvaluationError(
+                f"double-double parameter derivation failed: {exc}"
+            ) from exc
+
+
+def _exact_chunk_input_indices(value: object, input_len: int) -> tuple[int, ...]:
+    if (
+        input_len < 0
+        or isinstance(value, str | bytes)
+        or not isinstance(value, Sequence)
+    ):
+        raise ArtifactError("chunked evaluator input map is invalid")
+    indices = tuple(value)
+    if any(
+        isinstance(index, bool)
+        or not isinstance(index, int)
+        or index < 0
+        or index >= input_len
+        for index in indices
+    ) or any(left >= right for left, right in pairwise(indices)):
+        raise ArtifactError("chunked evaluator input map is invalid")
+    return cast(tuple[int, ...], indices)
+
+
+class SymbolicaExactExecutor:
+    """Replay one verified schema-v3 execution plan through Symbolica states."""
+
+    def __init__(self, artifact: Path, process_id: str, native_runtime: Any) -> None:
+        self._artifact = artifact
+        self._native_runtime = native_runtime
+        manifest = load_manifest(artifact)
+        self._payloads = ExactEvaluatorPayloadResolver(manifest)
+        selection = native_process_selection(native_runtime, manifest.processes)
+        representative_id = selection.representative_process_id
+        permutation = selection.external_permutation
+        self._representative_id = representative_id
+        records = tuple(
+            record
+            for record in manifest.payloads
+            if record.role == "evaluator-manifest"
+            and record.process_id == representative_id
+        )
+        if len(records) != 1:
+            raise ArtifactError(
+                f"process {representative_id!r} must declare one evaluator manifest"
+            )
+        self._process_root = artifact / "processes" / representative_id
+        self._process_prefix = normalize_relative_path(f"processes/{representative_id}")
+        physics_path = selection.process.get("physics_path")
+        if not isinstance(physics_path, str) or not physics_path:
+            raise ArtifactError(
+                f"representative process {representative_id!r} has no physics path"
+            )
+        try:
+            self._execution = json.loads(
+                (artifact / records[0].path).read_text(encoding="utf-8")
+            )
+            representative_physics = json.loads(
+                confined_path(artifact, physics_path).read_text(encoding="utf-8")
+            )
+        except (OSError, json.JSONDecodeError) as exc:
+            raise ArtifactError(
+                f"could not load exact-runtime metadata: {exc}"
+            ) from exc
+        if not isinstance(self._execution, dict) or not isinstance(
+            representative_physics, dict
+        ):
+            raise ArtifactError("exact-runtime metadata is not an object")
+        axes = native_physics_axes(native_runtime, representative_physics)
+        self._representative_physics = representative_physics
+        self._physics = axes.public_physics
+        if self._execution.get("key") != selection.representative_process_key:
+            raise ArtifactError(
+                "compiled exact execution disagrees with Rusticol's "
+                "representative process key"
+            )
+        self._primary_execution = self._execution
+        self._primary_physics = self._physics
+        helicity_sum_execution = self._execution.get("helicity_sum_execution")
+        if helicity_sum_execution is not None:
+            if not isinstance(helicity_sum_execution, dict):
+                raise ArtifactError("compiled helicity-sum execution is not an object")
+            physics_reduction = helicity_sum_execution.get("physics_reduction")
+            if not isinstance(physics_reduction, dict):
+                raise ArtifactError(
+                    "compiled helicity-sum execution has no physics reduction"
+                )
+            self._helicity_sum_execution: dict[str, object] | None = (
+                helicity_sum_execution
+            )
+            self._helicity_sum_physics: dict[str, object] | None = {
+                **self._physics,
+                "reduction": remap_reduction(physics_reduction, axes),
+            }
+        else:
+            self._helicity_sum_execution = None
+            self._helicity_sum_physics = None
+        self._permutation = permutation
+        self._lc_replay = _lc_replay_plan(
+            self._execution,
+            self._physics,
+            permutation,
+        )
+        self._color_replay = parse_exact_color_topology_replay(
+            self._execution,
+            self._physics,
+            permutation,
+        )
+        if self._lc_replay is not None and self._color_replay is not None:
+            raise ArtifactError(
+                "compiled exact execution cannot combine LC and full-colour replay"
+            )
+        self._helicity_plan = _exact_helicity_plan(
+            self._execution,
+            self._physics,
+            permutation,
+        )
+        self._stage_evaluators: tuple[_ExactEvaluator, ...] | None = None
+        self._amplitude_evaluator: _ExactEvaluator | None = None
+
+    def _diagnostic_project_onshell(
+        self,
+        momenta: Momenta,
+        *,
+        precision: int,
+    ) -> tuple[
+        tuple[tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...], ...],
+        dict[str, object],
+    ]:
+        """Build diagnostic-only on-shell kinematics from current parameters."""
+
+        state = _runtime_state(self._native_runtime)
+        parameters = tuple(
+            _decimal(value, "runtime model parameter")
+            for value in state["model_parameter_values"]
+        )
+        execution = getattr(self, "_primary_execution", self._execution)
+        physics = getattr(self, "_primary_physics", self._physics)
+        schema = execution.get("runtime_schema")
+        if not isinstance(schema, Mapping):
+            raise ArtifactError("compiled execution has no runtime schema")
+        bindings = _diagnostic_schema_mass_bindings(schema, physics, parameters)
+        return _diagnostic_project_onshell_points(
+            momenta,
+            physics=physics,
+            artifact_mass_bindings=bindings,
+            # Native ``physics_json`` is already remapped to the selected alias.
+            # Exact evaluation applies ``self._permutation`` only after receiving
+            # these caller-order diagnostic momenta.
+            permutation=None,
+            precision=precision,
+        )
+
+    def evaluate_resolved(
+        self,
+        momenta: Momenta,
+        *,
+        helicities: Sequence[str] | None,
+        color_flows: Sequence[str] | None,
+        precision: int,
+    ) -> ResolvedEvaluation:
+        if isinstance(precision, bool) or not isinstance(precision, int):
+            raise EvaluationError(
+                "precision must be a positive integer number of decimal digits"
+            )
+        if precision < 1:
+            raise EvaluationError(
+                "precision must be a positive integer number of decimal digits"
+            )
+        working_precision = _working_precision(precision)
+        self._activate_execution(helicities)
+        points = _prepare_points(momenta, self._physics, self._permutation)
+        state_payload = _runtime_state(self._native_runtime)
+        parameters = tuple(
+            _decimal(value, "runtime model parameter")
+            for value in state_payload["model_parameter_values"]
+        )
+        self._load_evaluators()
+        with localcontext() as context:
+            context.prec = working_precision
+            context.rounding = ROUND_HALF_EVEN
+            if self._color_replay is not None:
+                # Rational metric coefficients must be rounded here, not in
+                # the default Decimal context used when the executor loads.
+                self._color_replay = parse_exact_color_topology_replay(
+                    self._execution, self._physics, self._permutation
+                )
+            parameters = self._derive_model_parameters(parameters, working_precision)
+            normalization = exact_normalization(
+                self._physics,
+                parameters,
+                working_precision,
+                cast(
+                    Any, self._execution["runtime_schema"].get("model_parameters", ())
+                ),
+            )
+            if self._lc_replay is not None:
+                evaluation_points = tuple(
+                    _apply_lc_replay_input_mapping(point, entry.input_mapping)
+                    for entry in self._lc_replay.entries
+                    for point in points
+                )
+            elif self._color_replay is not None:
+                evaluation_points = tuple(
+                    apply_exact_color_replay_input_mapping(point, mapping.input_mapping)
+                    for mapping in self._color_replay.mappings
+                    for point in points
+                )
+            else:
+                evaluation_points = points
+            if self._color_replay is not None:
+                if self._helicity_plan is not None:
+                    raise ArtifactError(
+                        "compiled exact color replay requires the helicity-sum "
+                        "execution"
+                    )
+                amplitudes = tuple(
+                    self._evaluate_point(point, parameters, working_precision)
+                    for point in evaluation_points
+                )
+                values, helicity_ids, color_ids = reduce_exact_color_topology_replay(
+                    amplitudes,
+                    self._color_replay,
+                    len(points),
+                    normalization,
+                    helicities,
+                    color_flows,
+                )
+            elif self._helicity_plan is None:
+                amplitudes = tuple(
+                    self._evaluate_point(point, parameters, working_precision)
+                    for point in evaluation_points
+                )
+                values, helicity_ids, color_ids = _reduce_resolved(
+                    amplitudes,
+                    self._execution,
+                    self._physics,
+                    normalization,
+                    helicities if self._lc_replay is None else None,
+                    color_flows if self._lc_replay is None else None,
+                )
+            else:
+                values, helicity_ids, color_ids = self._evaluate_helicity_quotient(
+                    evaluation_points,
+                    parameters,
+                    normalization,
+                    working_precision,
+                    helicities if self._lc_replay is None else None,
+                    color_flows if self._lc_replay is None else None,
+                )
+            if self._lc_replay is not None:
+                values, helicity_ids, color_ids = _apply_lc_replay_resolved(
+                    values,
+                    self._lc_replay,
+                    len(points),
+                    helicity_ids,
+                    color_ids,
+                    helicities,
+                    color_flows,
+                )
+        with localcontext() as context:
+            context.prec = precision
+            context.rounding = ROUND_HALF_EVEN
+            values = tuple(
+                tuple(tuple(+entry for entry in colors) for colors in helicities)
+                for helicities in values
+            )
+        return ResolvedEvaluation(
+            values=values,
+            helicity_ids=helicity_ids,
+            color_ids=color_ids,
+            color_accuracy=cast(Any, str(self._physics["color_accuracy"])),
+        )
+
+    def _activate_execution(self, helicities: Sequence[str] | None) -> None:
+        primary_execution = getattr(self, "_primary_execution", self._execution)
+        primary_physics = getattr(self, "_primary_physics", self._physics)
+        helicity_sum_execution = getattr(self, "_helicity_sum_execution", None)
+        helicity_sum_physics = getattr(self, "_helicity_sum_physics", None)
+        use_helicity_sum = helicity_sum_execution is not None and (
+            helicities is None or str(primary_physics.get("color_accuracy")) != "lc"
+        )
+        execution = helicity_sum_execution if use_helicity_sum else primary_execution
+        physics = helicity_sum_physics if use_helicity_sum else primary_physics
+        assert execution is not None and physics is not None
+        if self._execution is execution:
+            return
+        self._execution = execution
+        self._physics = physics
+        self._lc_replay = _lc_replay_plan(execution, physics, self._permutation)
+        self._color_replay = parse_exact_color_topology_replay(
+            execution,
+            physics,
+            self._permutation,
+        )
+        if self._lc_replay is not None and self._color_replay is not None:
+            raise ArtifactError(
+                "compiled exact execution cannot combine LC and full-colour replay"
+            )
+        self._helicity_plan = _exact_helicity_plan(
+            execution,
+            physics,
+            self._permutation,
+        )
+        self._stage_evaluators = None
+        self._amplitude_evaluator = None
+
+    def _load_evaluators(self) -> None:
+        if self._stage_evaluators is not None:
+            return
+        compiled = self._execution.get("compiled")
+        if not isinstance(compiled, Mapping):
+            raise ArtifactError("execution metadata has no compiled evaluator set")
+        stage_set = compiled.get("stage_evaluators")
+        if not isinstance(stage_set, Mapping):
+            raise CompatibilityError(
+                "process artifact has no materialized stage evaluators"
+            )
+        raw_stages = stage_set.get("stages")
+        amplitude = stage_set.get("amplitude_stage")
+        if isinstance(raw_stages, str | bytes) or not isinstance(raw_stages, Sequence):
+            raise ArtifactError("execution stage evaluator list is invalid")
+        if not isinstance(amplitude, Mapping):
+            raise ArtifactError("execution amplitude evaluator is invalid")
+        self._stage_evaluators = tuple(
+            _ExactEvaluator.load(
+                _evaluator_manifest(stage),
+                self._process_root,
+                state_loader=self._load_exact_state,
+            )
+            for stage in raw_stages
+        )
+        self._amplitude_evaluator = _ExactEvaluator.load(
+            _evaluator_manifest(amplitude),
+            self._process_root,
+            state_loader=self._load_exact_state,
+        )
+
+    def _load_exact_state(self, relative: str) -> bytes:
+        logical_path = normalize_relative_path(
+            f"{self._process_prefix}/{normalize_relative_path(relative)}"
+        )
+        return self._payloads.read_exact_state(
+            logical_path,
+            process_id=self._representative_id,
+        )
+
+    def _derive_model_parameters(
+        self,
+        parameters: tuple[Decimal, ...],
+        precision: int,
+        *,
+        arithmetic: str = "arbitrary",
+    ) -> tuple[Decimal, ...]:
+        """Recompute UFO couplings; native cached values are only binary64."""
+        compiled = cast(Mapping[str, Any], self._execution["compiled"])
+        derivation = compiled.get("model_parameter_evaluator")
+        if derivation is None:
+            return parameters
+        from pyamplicol._internal.physics.symbols import symbols
+
+        schema = cast(Mapping[str, Any], self._execution["runtime_schema"])
+        records = schema["model_parameters"]
+        inputs: dict[str, list[int | None]] = {}
+        for record in records:
+            if record.get("kind") not in {
+                "external_parameter",
+                "external_parameter_component",
+            }:
+                continue
+            name = str(record.get("runtime_name", record["name"]))
+            component = int(record.get("complex_component") == "imag")
+            inputs.setdefault(name, [None, None])[component] = int(
+                record["parameter_index"]
+            )
+        model = getattr(self, "_exact_compiled_model", None)
+        if model is None:
+            manifest = load_manifest(self._artifact)
+            model_records = tuple(
+                record
+                for record in manifest.payloads
+                if record.role == "compiled-model"
+            )
+            if len(model_records) != 1:
+                raise ArtifactError(
+                    "exact parameter derivation requires one compiled model"
+                )
+            model = json.loads(
+                confined_path(self._artifact, model_records[0].path).read_text()
+            )["ir"]
+            self._exact_compiled_model = model
+        definitions = {
+            record["name"]: record["resolved_expression"]
+            for record in model["parameters"]
+            if record["nature"] == "internal"
+        }
+        definitions.update(
+            {
+                f"derived_coupling_{record['id']}": record["coupling_expression"]
+                for record in model["vertex_terms"]
+            }
+        )
+        outputs = derivation["outputs"]
+        model_symbols = symbols.model(model["name"])
+        evaluator = _ExactExpressionEvaluator(
+            tuple(definitions[record["runtime_name"]] for record in outputs),
+            tuple(model_symbols.symbol(name).to_canonical_string() for name in inputs),
+        )
+        arguments = tuple(
+            (
+                parameters[indices[0]] if indices[0] is not None else _ZERO,
+                parameters[indices[1]] if indices[1] is not None else _ZERO,
+            )
+            for indices in inputs.values()
+        )
+        values = (
+            evaluator.evaluate_double_double(arguments)
+            if arithmetic == "double-double"
+            else evaluator.evaluate(arguments, precision)
+        )
+        result = list(parameters)
+        for value, record in zip(values, outputs, strict=True):
+            result[record["real_parameter_index"]] = value[0]
+            result[record["imag_parameter_index"]] = value[1]
+        return tuple(result)
+
+    def _evaluate_point(
+        self,
+        point: tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...],
+        model_parameters: tuple[Decimal, ...],
+        precision: int,
+        source_states: Sequence[_ExactRuntimeSourceState | None] | None = None,
+    ) -> tuple[_ComplexDecimal, ...]:
+        runtime_schema = cast(Mapping[str, object], self._execution["runtime_schema"])
+        layout = cast(Mapping[str, object], runtime_schema["parameter_layout"])
+        value_count = _json_integer(layout["value_component_count"])
+        momentum_count = _json_integer(layout["momentum_parameter_count"])
+        model_start = value_count + momentum_count
+        parameter_count = max(
+            _json_integer(layout["parameter_count_if_flattened"]),
+            model_start + len(model_parameters),
+        )
+        state = [_complex_zero() for _ in range(parameter_count)]
+        if source_states is None:
+            _fill_sources(state, point, runtime_schema, model_parameters)
+        else:
+            _fill_sources_with_states(
+                state,
+                point,
+                runtime_schema,
+                model_parameters,
+                source_states,
+            )
+        _fill_momenta(state, point, runtime_schema)
+        for index, value in enumerate(model_parameters):
+            state[model_start + index] = (value, _ZERO)
+
+        stage_set = cast(
+            Mapping[str, object],
+            cast(Mapping[str, object], self._execution["compiled"])["stage_evaluators"],
+        )
+        raw_stages = cast(Sequence[object], stage_set["stages"])
+        assert self._stage_evaluators is not None
+        for raw_stage, evaluator in zip(
+            raw_stages, self._stage_evaluators, strict=True
+        ):
+            stage = cast(Mapping[str, object], raw_stage)
+            inputs = _pack_stage_inputs(state, stage)
+            outputs = evaluator.evaluate(inputs, precision)
+            _assign_stage_outputs(state, outputs, stage)
+
+        amplitude = cast(Mapping[str, object], stage_set["amplitude_stage"])
+        assert self._amplitude_evaluator is not None
+        return _canonical_amplitude_outputs(
+            self._amplitude_evaluator.evaluate(
+                _pack_stage_inputs(state, amplitude), precision
+            ),
+            amplitude,
+        )
+
+    def _evaluate_helicity_quotient(
+        self,
+        points: Sequence[tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]],
+        model_parameters: tuple[Decimal, ...],
+        normalization: Decimal,
+        precision: int,
+        selected_helicities: Sequence[str] | None,
+        selected_colors: Sequence[str] | None,
+    ) -> tuple[
+        tuple[tuple[tuple[Decimal, ...], ...], ...],
+        tuple[str, ...],
+        tuple[str, ...],
+    ]:
+        assert self._helicity_plan is not None
+        helicities = cast(Sequence[Mapping[str, object]], self._physics["helicities"])
+        colors = cast(Sequence[Mapping[str, object]], self._physics["color_components"])
+        helicity_ids = tuple(str(item["id"]) for item in helicities)
+        color_ids = tuple(str(item["id"]) for item in colors)
+        selected_h = _selected_indices(helicity_ids, selected_helicities, "helicity")
+        selected_c = _selected_indices(color_ids, selected_colors, "color component")
+        if str(self._physics["color_accuracy"]) != "lc" and selected_colors is not None:
+            raise EvaluationError(
+                "LC color-flow selection is unavailable for NLC/full artifacts"
+            )
+
+        requested_helicities = set(selected_h)
+        full_points: list[tuple[tuple[Decimal, ...], ...]] = []
+        for point in points:
+            full = [[_ZERO for _color in color_ids] for _helicity in helicity_ids]
+            execution_amplitudes: dict[int, tuple[_ComplexDecimal, ...]] = {}
+            for schedule in self._helicity_plan.schedules:
+                helicity_index = schedule.physical_helicity_index
+                if (
+                    helicity_index not in requested_helicities
+                    or schedule.structural_zero
+                ):
+                    continue
+                execution_index = schedule.execution_helicity_index
+                execution_schedule = self._helicity_plan.schedules[execution_index]
+                amplitudes = execution_amplitudes.get(execution_index)
+                if amplitudes is None:
+                    amplitudes = self._evaluate_point(
+                        point,
+                        model_parameters,
+                        precision,
+                        execution_schedule.source_states,
+                    )
+                    execution_amplitudes[execution_index] = amplitudes
+                full[helicity_index] = list(
+                    _reduce_materialized_helicity(
+                        amplitudes,
+                        self._execution,
+                        self._physics,
+                        normalization,
+                        execution_index,
+                        execution_schedule.root_factors,
+                    )
+                )
+            full_points.append(
+                tuple(tuple(full[h][c] for c in selected_c) for h in selected_h)
+            )
+        return (
+            tuple(full_points),
+            tuple(helicity_ids[index] for index in selected_h),
+            tuple(color_ids[index] for index in selected_c),
+        )
+
+
+def _exact_helicity_plan(
+    execution: Mapping[str, object],
+    physics: Mapping[str, object],
+    public_permutation: tuple[int, ...] | None,
+) -> _ExactHelicityPlan | None:
+    try:
+        return _parse_exact_helicity_plan(execution, physics, public_permutation)
+    except (ArtifactError, CompatibilityError, EvaluationError):
+        raise
+    except (KeyError, TypeError, ValueError, OverflowError) as exc:
+        raise ArtifactError(
+            f"malformed helicity recurrence materialization: {exc}"
+        ) from exc
+
+
+def _parse_exact_helicity_plan(
+    execution: Mapping[str, object],
+    physics: Mapping[str, object],
+    public_permutation: tuple[int, ...] | None,
+) -> _ExactHelicityPlan | None:
+    runtime_schema = execution.get("runtime_schema")
+    if not isinstance(runtime_schema, Mapping):
+        raise ArtifactError("execution metadata has no runtime schema")
+    recurrence = runtime_schema.get("helicity_recurrence")
+    if recurrence is None:
+        return None
+    if not isinstance(recurrence, Mapping):
+        raise ArtifactError("helicity recurrence metadata is not an object")
+    materialization = recurrence.get("materialization")
+    if materialization is None:
+        # Pre-quotient artifacts may carry proof metadata while retaining the
+        # complete DAG. Their exact execution remains unchanged.
+        return None
+    if not isinstance(materialization, Mapping):
+        raise ArtifactError("helicity recurrence materialization is not an object")
+    if _json_integer(recurrence.get("contract_version", 0)) != 1:
+        raise CompatibilityError("unsupported helicity recurrence contract version")
+    if (
+        materialization.get("kind") != "pyamplicol-helicity-recurrence-materialization"
+        or _json_integer(materialization.get("contract_version", 0)) != 1
+    ):
+        raise CompatibilityError(
+            "unsupported helicity recurrence materialization contract"
+        )
+
+    helicities = physics.get("helicities")
+    particles = physics.get("external_particles")
+    if (
+        isinstance(helicities, str | bytes)
+        or not isinstance(helicities, Sequence)
+        or isinstance(particles, str | bytes)
+        or not isinstance(particles, Sequence)
+        or not helicities
+    ):
+        raise ArtifactError("helicity recurrence requires physical helicity metadata")
+    physical = cast(Sequence[Mapping[str, object]], helicities)
+    external_count = len(particles)
+    physical_by_values: dict[tuple[int, ...], int] = {}
+    physical_by_id: dict[str, int] = {}
+    for index, helicity in enumerate(physical):
+        values = _integer_vector(
+            helicity.get("values"),
+            external_count,
+            "physical helicity vector",
+        )
+        if values in physical_by_values:
+            raise ArtifactError("physical helicity metadata contains duplicate vectors")
+        if not isinstance(helicity.get("structural_zero"), bool):
+            raise ArtifactError("physical helicity structural-zero flag is not boolean")
+        physical_by_values[values] = index
+        raw_identifier = helicity.get("id")
+        if (
+            not isinstance(raw_identifier, str)
+            or not raw_identifier
+            or raw_identifier in physical_by_id
+        ):
+            raise ArtifactError(
+                "physical helicity metadata has invalid or duplicate IDs"
+            )
+        physical_by_id[raw_identifier] = index
+    for index, helicity in enumerate(physical):
+        identifier = str(helicity["id"])
+        computed = helicity.get("computed", True)
+        if not isinstance(computed, bool):
+            raise ArtifactError("physical helicity computed flag is not boolean")
+        representative_id = helicity.get("representative_id", identifier)
+        if not isinstance(representative_id, str) or not representative_id:
+            raise ArtifactError("physical helicity representative ID is invalid")
+        representative_index = physical_by_id.get(representative_id)
+        if representative_index is None:
+            raise ArtifactError(
+                f"physical helicity {identifier!r} references an unknown "
+                f"representative {representative_id!r}"
+            )
+        representative = physical[representative_index]
+        physical_structural_zero = bool(helicity["structural_zero"])
+        if not physical_structural_zero:
+            representative_computed = representative.get("computed", True)
+            representative_self_id = representative.get(
+                "representative_id", representative_id
+            )
+            if representative_computed is not True or (
+                representative_self_id != representative_id
+            ):
+                raise ArtifactError(
+                    f"physical helicity {identifier!r} does not reference a "
+                    "self-representing computed helicity"
+                )
+            if computed and representative_index != index:
+                raise ArtifactError(
+                    f"computed physical helicity {identifier!r} does not "
+                    "represent itself"
+                )
+            if bool(representative["structural_zero"]):
+                raise ArtifactError(
+                    f"nonzero physical helicity {identifier!r} references a "
+                    "structural-zero representative"
+                )
+            coefficient = _decimal(
+                helicity.get("coefficient", 1), "helicity coefficient"
+            )
+            representative_coefficient = _decimal(
+                representative.get("coefficient", 1),
+                "representative helicity coefficient",
+            )
+            if coefficient != representative_coefficient:
+                raise ArtifactError(
+                    f"physical helicity {identifier!r} and its representative "
+                    "have different reduction coefficients"
+                )
+    reduction = physics.get("reduction")
+    if isinstance(reduction, Mapping):
+        raw_groups = reduction.get("groups")
+        if isinstance(raw_groups, Sequence) and not isinstance(
+            raw_groups, (str, bytes)
+        ):
+            for raw_group in raw_groups:
+                if not isinstance(raw_group, Mapping):
+                    continue
+                group_representative = raw_group.get("representative_helicity_id")
+                if group_representative is None:
+                    # Legacy reduction records predate the explicit group
+                    # representative. Per-helicity metadata remains authoritative.
+                    continue
+                if (
+                    not isinstance(group_representative, str)
+                    or group_representative not in physical_by_id
+                ):
+                    raise ArtifactError(
+                        "resolved reduction group has an invalid helicity "
+                        "representative"
+                    )
+                raw_members = raw_group.get("physical_helicity_ids")
+                if isinstance(raw_members, (str, bytes)) or not isinstance(
+                    raw_members, Sequence
+                ):
+                    continue
+                member_ids = tuple(str(member) for member in raw_members)
+                if group_representative not in member_ids:
+                    raise ArtifactError(
+                        "resolved reduction group helicity representative is "
+                        "not a group member"
+                    )
+                for member_id in member_ids:
+                    member_index = physical_by_id.get(member_id)
+                    if member_index is None:
+                        continue
+                    member = physical[member_index]
+                    declared = member.get("representative_id", member_id)
+                    if declared != group_representative:
+                        raise ArtifactError(
+                            f"physical helicity {member_id!r} representative "
+                            "disagrees with its reduction group"
+                        )
+    if public_permutation is not None and (
+        len(public_permutation) != external_count
+        or set(public_permutation) != set(range(external_count))
+    ):
+        raise ArtifactError(
+            "process alias has an invalid public-label permutation for "
+            "helicity recurrence"
+        )
+
+    raw_domains = recurrence.get("selector_domains")
+    if isinstance(raw_domains, str | bytes) or not isinstance(raw_domains, Sequence):
+        raise ArtifactError("helicity recurrence selector domains are invalid")
+    domains: dict[int, tuple[bool, frozenset[tuple[int, int]]]] = {}
+    for raw_domain in raw_domains:
+        if not isinstance(raw_domain, Mapping):
+            raise ArtifactError("helicity recurrence selector domain is not an object")
+        domain_id = _strict_nonnegative_integer(
+            raw_domain.get("id"), "helicity selector domain ID"
+        )
+        complete = raw_domain.get("complete")
+        if not isinstance(complete, bool):
+            raise ArtifactError("helicity selector domain completeness is not boolean")
+        raw_states = raw_domain.get("source_states")
+        if isinstance(raw_states, str | bytes) or not isinstance(raw_states, Sequence):
+            raise ArtifactError("helicity selector domain source states are invalid")
+        domain_states: set[tuple[int, int]] = set()
+        for raw_state in raw_states:
+            if not isinstance(raw_state, Mapping):
+                raise ArtifactError("helicity selector source state is not an object")
+            label = _strict_nonnegative_integer(
+                raw_state.get("external_label"), "helicity source external label"
+            )
+            if not 1 <= label <= external_count:
+                raise ArtifactError("helicity source external label is out of range")
+            state = (label - 1, _json_integer(raw_state.get("helicity")))
+            if state in domain_states or any(
+                existing[0] == state[0] for existing in domain_states
+            ):
+                raise ArtifactError(
+                    "helicity selector domain repeats an external label"
+                )
+            domain_states.add(state)
+        if complete and len(domain_states) != external_count:
+            raise ArtifactError("complete helicity selector domain is incomplete")
+        if domain_id in domains:
+            raise ArtifactError("helicity recurrence repeats a selector domain ID")
+        domains[domain_id] = (complete, frozenset(domain_states))
+
+    source_fill = runtime_schema.get("source_fill")
+    amplitude_stage = runtime_schema.get("amplitude_stage")
+    if not isinstance(source_fill, Mapping) or not isinstance(amplitude_stage, Mapping):
+        raise ArtifactError("helicity materialization has incomplete runtime metadata")
+    raw_sources = source_fill.get("sources")
+    raw_roots = amplitude_stage.get("roots")
+    if (
+        isinstance(raw_sources, str | bytes)
+        or not isinstance(raw_sources, Sequence)
+        or isinstance(raw_roots, str | bytes)
+        or not isinstance(raw_roots, Sequence)
+    ):
+        raise ArtifactError("helicity materialization source/root metadata is invalid")
+    sources = cast(Sequence[Mapping[str, object]], raw_sources)
+    roots = cast(Sequence[Mapping[str, object]], raw_roots)
+    if _json_integer(materialization.get("materialized_root_count", -1)) != len(roots):
+        raise ArtifactError("helicity materialization root count is inconsistent")
+    for index, root in enumerate(roots):
+        if (
+            _strict_nonnegative_integer(root.get("root_id"), "amplitude root ID")
+            != index
+            or _strict_nonnegative_integer(
+                root.get("output_index"), "amplitude root output index"
+            )
+            != index
+        ):
+            raise ArtifactError(
+                "helicity materialization requires contiguous root/output identifiers"
+            )
+
+    source_routes = _exact_source_routes(materialization, domains, sources)
+    amplitude_routes = _exact_amplitude_routes(materialization, domains, len(roots))
+    execution_domain_by_domain = _exact_helicity_execution_domains(
+        domains, amplitude_routes
+    )
+    raw_schedules = materialization.get("selector_schedules")
+    if isinstance(raw_schedules, str | bytes) or not isinstance(
+        raw_schedules, Sequence
+    ):
+        raise ArtifactError("helicity materialization selector schedules are invalid")
+    schedules_by_physical: dict[int, _ExactHelicitySchedule] = {}
+    for raw_schedule in raw_schedules:
+        if not isinstance(raw_schedule, Mapping):
+            raise ArtifactError("helicity materialization schedule is not an object")
+        domain_id = _strict_nonnegative_integer(
+            raw_schedule.get("selector_domain_id"), "helicity schedule domain ID"
+        )
+        domain = domains.get(domain_id)
+        if domain is None or not domain[0]:
+            raise ArtifactError(
+                "helicity schedule does not reference a complete domain"
+            )
+        representative_values = _complete_domain_values(domain[1], external_count)
+        public_values = (
+            representative_values
+            if public_permutation is None
+            else _permute_helicity_to_public_alias(
+                representative_values, public_permutation
+            )
+        )
+        physical_index = physical_by_values.get(public_values)
+        if physical_index is None:
+            raise ArtifactError(
+                f"helicity selector domain {public_values!r} has no physical entry"
+            )
+        if physical_index in schedules_by_physical:
+            raise ArtifactError("physical helicity has multiple recurrence schedules")
+        structural_zero = raw_schedule.get("structural_zero")
+        if not isinstance(structural_zero, bool):
+            raise ArtifactError("helicity schedule structural-zero flag is not boolean")
+        if bool(physical[physical_index].get("structural_zero")) != structural_zero:
+            raise ArtifactError(
+                "helicity schedule structural-zero flag disagrees with physics metadata"
+            )
+        active_roots = frozenset(
+            _strict_integer_sequence(
+                raw_schedule.get("active_root_ids"),
+                len(roots),
+                "helicity schedule active roots",
+            )
+        )
+        active_currents = _strict_integer_sequence(
+            raw_schedule.get("active_current_ids"),
+            _json_integer(materialization.get("materialized_current_count", -1)),
+            "helicity schedule active currents",
+        )
+        if structural_zero and (active_currents or active_roots):
+            raise ArtifactError(
+                "structural-zero helicity schedule has an active closure"
+            )
+        schedule_source_states = (
+            ()
+            if structural_zero
+            else _source_states_for_active_closure(
+                sources,
+                source_routes,
+                active_currents,
+                domain[1],
+            )
+        )
+        factors: list[_ComplexDecimal | None] = [None] * len(roots)
+        for root_id, route_domain_ids, factor in amplitude_routes:
+            if domain_id not in route_domain_ids:
+                continue
+            if factors[root_id] is not None:
+                raise ArtifactError(
+                    "helicity schedule routes one materialized root more than once"
+                )
+            factors[root_id] = factor
+        routed = frozenset(
+            index for index, factor in enumerate(factors) if factor is not None
+        )
+        if routed != active_roots:
+            raise ArtifactError(
+                "helicity schedule amplitude routes do not match active roots"
+            )
+        schedules_by_physical[physical_index] = _ExactHelicitySchedule(
+            physical_helicity_index=physical_index,
+            execution_helicity_index=physical_index,
+            selector_domain_id=domain_id,
+            structural_zero=structural_zero,
+            source_states=schedule_source_states,
+            root_factors=tuple(factors),
+        )
+    if set(schedules_by_physical) != set(range(len(physical))):
+        raise ArtifactError(
+            "helicity materialization does not cover every physical helicity"
+        )
+    physical_by_domain = {
+        schedule.selector_domain_id: physical_index
+        for physical_index, schedule in schedules_by_physical.items()
+    }
+    resolved_schedules = []
+    for physical_index in range(len(physical)):
+        schedule = schedules_by_physical[physical_index]
+        execution_domain = execution_domain_by_domain[schedule.selector_domain_id]
+        execution_index = physical_by_domain.get(execution_domain)
+        if execution_index is None:
+            raise ArtifactError(
+                f"helicity selector domain {schedule.selector_domain_id} maps to "
+                f"absent execution domain {execution_domain}"
+            )
+        resolved_schedules.append(
+            _ExactHelicitySchedule(
+                physical_helicity_index=schedule.physical_helicity_index,
+                execution_helicity_index=execution_index,
+                selector_domain_id=schedule.selector_domain_id,
+                structural_zero=schedule.structural_zero,
+                source_states=schedule.source_states,
+                root_factors=schedule.root_factors,
+            )
+        )
+    return _ExactHelicityPlan(schedules=tuple(resolved_schedules))
+
+
+def _exact_source_routes(
+    materialization: Mapping[str, object],
+    domains: Mapping[int, tuple[bool, frozenset[tuple[int, int]]]],
+    sources: Sequence[Mapping[str, object]],
+) -> tuple[tuple[int, int, int, int, _ExactRuntimeSourceState], ...]:
+    raw_routes = materialization.get("source_routes")
+    if isinstance(raw_routes, str | bytes) or not isinstance(raw_routes, Sequence):
+        raise ArtifactError("helicity materialization source routes are invalid")
+    source_by_current = {
+        _strict_nonnegative_integer(
+            source.get("current_id"), "source current ID"
+        ): source
+        for source in sources
+    }
+    if len(source_by_current) != len(sources):
+        raise ArtifactError("runtime source currents are not unique")
+    parsed = []
+    for raw_route in raw_routes:
+        if not isinstance(raw_route, Mapping):
+            raise ArtifactError(
+                "helicity materialization source route is not an object"
+            )
+        current_id = _strict_nonnegative_integer(
+            raw_route.get("materialized_current_id"), "source-route current ID"
+        )
+        source = source_by_current.get(current_id)
+        if source is None:
+            raise ArtifactError(
+                "source route references an unknown materialized current"
+            )
+        external_label = _strict_nonnegative_integer(
+            raw_route.get("external_label"), "source-route external label"
+        )
+        if external_label != _json_integer(source.get("leg_label")):
+            raise ArtifactError("source route external label disagrees with its source")
+        domain_id = _strict_nonnegative_integer(
+            raw_route.get("selector_domain_id"), "source-route selector domain"
+        )
+        if domain_id not in domains:
+            raise ArtifactError("source route references an unknown selector domain")
+        declared_index = _strict_nonnegative_integer(
+            raw_route.get("declared_state_index"), "source-route declared state"
+        )
+        helicity, chirality, spin_state = _transformed_declared_source_state(
+            source, declared_index
+        )
+        if (
+            _json_integer(raw_route.get("helicity")) != helicity
+            or _json_integer(raw_route.get("chirality")) != chirality
+            or _json_integer(raw_route.get("spin_state")) != spin_state
+        ):
+            raise ArtifactError(
+                "source route disagrees with its declared transformed state"
+            )
+        factor = _complex_decimal_pair(raw_route.get("factor"), "source-route factor")
+        if (external_label - 1, helicity) not in domains[domain_id][1]:
+            raise ArtifactError(
+                "source route selector domain does not contain its source state"
+            )
+        parsed.append(
+            (
+                current_id,
+                external_label - 1,
+                helicity,
+                domain_id,
+                _ExactRuntimeSourceState(helicity, chirality, spin_state, factor),
+            )
+        )
+    return tuple(parsed)
+
+
+def _exact_amplitude_routes(
+    materialization: Mapping[str, object],
+    domains: Mapping[int, tuple[bool, frozenset[tuple[int, int]]]],
+    root_count: int,
+) -> tuple[tuple[int, tuple[int, ...], _ComplexDecimal], ...]:
+    raw_routes = materialization.get("amplitude_routes")
+    if isinstance(raw_routes, str | bytes) or not isinstance(raw_routes, Sequence):
+        raise ArtifactError("helicity materialization amplitude routes are invalid")
+    parsed = []
+    for raw_route in raw_routes:
+        if not isinstance(raw_route, Mapping):
+            raise ArtifactError(
+                "helicity materialization amplitude route is not an object"
+            )
+        root_id = _strict_nonnegative_integer(
+            raw_route.get("materialized_root_id"), "amplitude-route root ID"
+        )
+        if root_id >= root_count:
+            raise ArtifactError("amplitude route references an unknown root")
+        domain_ids = _strict_integer_sequence(
+            raw_route.get("selector_domain_ids"),
+            max(domains, default=-1) + 1,
+            "amplitude-route selector domains",
+        )
+        if (
+            not domain_ids
+            or any(domain_id not in domains for domain_id in domain_ids)
+            or any(not domains[domain_id][0] for domain_id in domain_ids)
+            or any(left >= right for left, right in pairwise(domain_ids))
+        ):
+            raise ArtifactError(
+                "amplitude route requires distinct ordered complete selector domains"
+            )
+        parsed.append(
+            (
+                root_id,
+                domain_ids,
+                _complex_decimal_pair(
+                    raw_route.get("factor"), "amplitude-route factor"
+                ),
+            )
+        )
+    return tuple(parsed)
+
+
+def _exact_helicity_execution_domains(
+    domains: Mapping[int, tuple[bool, frozenset[tuple[int, int]]]],
+    routes: Sequence[tuple[int, tuple[int, ...], _ComplexDecimal]],
+) -> dict[int, int]:
+    """Mirror the native retained-route mapping for global-flip aliases."""
+
+    execution_by_domain = {domain_id: domain_id for domain_id in domains}
+    primary_domains: set[int] = set()
+    for _root_id, route_domain_ids, _factor in routes:
+        primary_domain, *replay_domains = route_domain_ids
+        primary_domains.add(primary_domain)
+        for replay_domain in replay_domains:
+            previous = execution_by_domain[replay_domain]
+            if previous not in (replay_domain, primary_domain):
+                raise ArtifactError(
+                    f"helicity replay domain {replay_domain} maps to inconsistent "
+                    f"execution domains {previous} and {primary_domain}"
+                )
+            execution_by_domain[replay_domain] = primary_domain
+    for primary_domain in primary_domains:
+        execution_domain = execution_by_domain[primary_domain]
+        if execution_domain != primary_domain:
+            raise ArtifactError(
+                f"helicity selector domain {primary_domain} is both a primary "
+                "and replay-only domain"
+            )
+    return execution_by_domain
+
+
+def _source_states_for_active_closure(
+    sources: Sequence[Mapping[str, object]],
+    routes: Sequence[tuple[int, int, int, int, _ExactRuntimeSourceState]],
+    active_current_ids: Sequence[int],
+    complete_states: frozenset[tuple[int, int]],
+) -> tuple[_ExactRuntimeSourceState | None, ...]:
+    active = frozenset(active_current_ids)
+    active_labels = {
+        _json_integer(source.get("leg_label")) - 1
+        for source in sources
+        if _json_integer(source.get("current_id")) in active
+    }
+    expected_labels = {external for external, _helicity in complete_states}
+    if active_labels != expected_labels:
+        raise ArtifactError(
+            "helicity selector source-label coverage disagrees with its complete domain"
+        )
+    result: list[_ExactRuntimeSourceState | None] = []
+    state_by_external = dict(complete_states)
+    for source in sources:
+        current_id = _json_integer(source.get("current_id"))
+        if current_id not in active:
+            result.append(None)
+            continue
+        external = _json_integer(source.get("leg_label")) - 1
+        try:
+            selected_helicity = state_by_external[external]
+        except KeyError as exc:
+            raise ArtifactError(
+                "active materialized source has no state in its complete domain"
+            ) from exc
+        matching = [
+            state
+            for route_current, route_external, helicity, _domain_id, state in routes
+            if route_current == current_id
+            and route_external == external
+            and helicity == selected_helicity
+        ]
+        if len(matching) > 1:
+            raise ArtifactError(
+                "active materialized source has multiple routes for its "
+                "selected helicity"
+            )
+        result.append(
+            matching[0]
+            if matching
+            else _declared_source_state_for_helicity(source, selected_helicity)
+        )
+    return tuple(result)
+
+
+def _declared_source_state_for_helicity(
+    source: Mapping[str, object], helicity: int
+) -> _ExactRuntimeSourceState:
+    source_ir, _identity, _crossing = _validated_source_ir(source)
+    raw_states = source_ir.get("states")
+    if isinstance(raw_states, str | bytes) or not isinstance(raw_states, Sequence):
+        raise ArtifactError("source IR declared states are invalid")
+    matching = []
+    for declared_index in range(len(raw_states)):
+        runtime_helicity, chirality, spin_state = _transformed_declared_source_state(
+            source, declared_index
+        )
+        if runtime_helicity == helicity:
+            matching.append(
+                _ExactRuntimeSourceState(
+                    helicity=runtime_helicity,
+                    chirality=chirality,
+                    spin_state=spin_state,
+                    factor=(_ONE, _ZERO),
+                )
+            )
+    if len(matching) != 1:
+        raise ArtifactError(
+            "active materialized source does not declare exactly one state "
+            f"for helicity {helicity}"
+        )
+    return matching[0]
+
+
+def _transformed_declared_source_state(
+    source: Mapping[str, object], declared_index: int
+) -> tuple[int, int, int]:
+    source_ir, _identity, crossing = _validated_source_ir(source)
+    raw_states = source_ir.get("states")
+    if isinstance(raw_states, str | bytes) or not isinstance(raw_states, Sequence):
+        raise ArtifactError("source IR declared states are invalid")
+    try:
+        state = raw_states[declared_index]
+    except IndexError as exc:
+        raise ArtifactError("source route has a stale declared state index") from exc
+    if not isinstance(state, Mapping):
+        raise ArtifactError("source IR declared state is not an object")
+    return (
+        _json_integer(state.get("helicity"))
+        * _json_integer(crossing.get("helicity_factor")),
+        _json_integer(state.get("chirality"))
+        * _json_integer(crossing.get("chirality_factor")),
+        _json_integer(state.get("spin_state"))
+        * _json_integer(crossing.get("spin_state_factor")),
+    )
+
+
+def _complete_domain_values(
+    states: frozenset[tuple[int, int]], external_count: int
+) -> tuple[int, ...]:
+    values: list[int | None] = [None] * external_count
+    for external_index, helicity in states:
+        values[external_index] = helicity
+    if any(value is None for value in values):
+        raise ArtifactError("complete helicity selector domain is incomplete")
+    return tuple(cast(int, value) for value in values)
+
+
+def _permute_helicity_to_public_alias(
+    representative: tuple[int, ...], permutation: tuple[int, ...]
+) -> tuple[int, ...]:
+    public = [0] * len(representative)
+    for representative_index, public_index in enumerate(permutation):
+        public[public_index] = representative[representative_index]
+    return tuple(public)
+
+
+def _integer_vector(value: object, length: int, context: str) -> tuple[int, ...]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} is invalid")
+    result = tuple(_json_integer(item) for item in value)
+    if len(result) != length:
+        raise ArtifactError(f"{context} has an inconsistent length")
+    return result
+
+
+def _external_label_word(
+    value: object,
+    external_count: int,
+    context: str,
+    *,
+    expected_labels: frozenset[int] | None = None,
+) -> tuple[int, ...]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} is invalid")
+    result = tuple(_json_integer(item) for item in value)
+    labels = frozenset(result)
+    if (
+        not result
+        or len(labels) != len(result)
+        or any(label < 1 or label > external_count for label in result)
+        or (expected_labels is not None and labels != expected_labels)
+    ):
+        raise ArtifactError(f"{context} has inconsistent external labels")
+    return result
+
+
+def _strict_nonnegative_integer(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise ArtifactError(f"{context} is not a non-negative integer")
+    return value
+
+
+def _strict_integer_sequence(
+    value: object, upper_bound: int, context: str
+) -> tuple[int, ...]:
+    if (
+        upper_bound < 0
+        or isinstance(value, str | bytes)
+        or not isinstance(value, Sequence)
+    ):
+        raise ArtifactError(f"{context} are invalid")
+    result = tuple(
+        _strict_nonnegative_integer(item, f"{context} entry") for item in value
+    )
+    if len(set(result)) != len(result) or any(item >= upper_bound for item in result):
+        raise ArtifactError(f"{context} are invalid")
+    return result
+
+
+def _complex_decimal_pair(value: object, context: str) -> _ComplexDecimal:
+    if (
+        isinstance(value, str | bytes)
+        or not isinstance(value, Sequence)
+        or len(value) != 2
+    ):
+        raise ArtifactError(f"{context} is not a complex pair")
+    return (_decimal(value[0], context), _decimal(value[1], context))
+
+
+def _lc_replay_plan(
+    execution: Mapping[str, object],
+    physics: Mapping[str, object],
+    public_permutation: tuple[int, ...] | None,
+) -> _LcReplayPlan | None:
+    compiled = execution.get("compiled")
+    compiled_replay = (
+        compiled.get("lc_topology_replay") if isinstance(compiled, Mapping) else None
+    )
+    eager_replay = execution.get("lc_topology_replay")
+    if (
+        compiled_replay is not None
+        and eager_replay is not None
+        and compiled_replay != eager_replay
+    ):
+        raise ArtifactError(
+            "LC topology replay metadata disagrees between execution lanes"
+        )
+    raw_replay = compiled_replay if compiled_replay is not None else eager_replay
+    if raw_replay is None:
+        return None
+    if not isinstance(raw_replay, Mapping):
+        raise ArtifactError("LC topology replay metadata is not an object")
+    if not bool(raw_replay.get("enabled")):
+        return None
+    if raw_replay.get("mode") != "external-label-permutation":
+        raise CompatibilityError(
+            f"unsupported LC topology replay mode {raw_replay.get('mode')!r}"
+        )
+    particles = physics.get("external_particles")
+    if isinstance(particles, str | bytes) or not isinstance(particles, Sequence):
+        raise ArtifactError("physics metadata has no external particles")
+    external_count = len(particles)
+    if public_permutation is not None and (
+        len(public_permutation) != external_count
+        or set(public_permutation) != set(range(external_count))
+    ):
+        raise ArtifactError(
+            "process alias has an invalid public-label permutation for LC "
+            "topology replay"
+        )
+    contract_version = _json_integer(raw_replay.get("contract_version", 1))
+    if contract_version == 2:
+        return _lc_replay_plan_v2(
+            execution,
+            physics,
+            raw_replay,
+            public_permutation,
+            external_count,
+        )
+    if contract_version != 1:
+        raise CompatibilityError(
+            f"unsupported LC topology replay contract version {contract_version}"
+        )
+
+    raw_groups = raw_replay.get("groups")
+    if isinstance(raw_groups, str | bytes) or not isinstance(raw_groups, Sequence):
+        raise ArtifactError("LC topology replay group list is invalid")
+    parsed: list[
+        tuple[tuple[tuple[int, int], ...], tuple[tuple[int, int], ...], Decimal]
+    ] = []
+    for raw_group in raw_groups:
+        if not isinstance(raw_group, Mapping):
+            raise ArtifactError("LC topology replay group is not an object")
+        raw_permutations = raw_group.get("sector_permutations")
+        if isinstance(raw_permutations, str | bytes) or not isinstance(
+            raw_permutations, Sequence
+        ):
+            raise ArtifactError("LC topology replay sector permutations are invalid")
+        for raw_permutation in raw_permutations:
+            if not isinstance(raw_permutation, Mapping):
+                raise ArtifactError(
+                    "LC topology replay sector permutation is not an object"
+                )
+            raw_labels = raw_permutation.get("label_permutation", ())
+            if isinstance(raw_labels, str | bytes) or not isinstance(
+                raw_labels, Sequence
+            ):
+                raise ArtifactError("LC topology replay label permutation is invalid")
+            mapping: list[tuple[int, int]] = []
+            for raw_label in raw_labels:
+                if not isinstance(raw_label, Mapping):
+                    raise ArtifactError(
+                        "LC topology replay label permutation entry is not an object"
+                    )
+                representative = _json_integer(raw_label["representative_label"]) - 1
+                sector = _json_integer(raw_label["sector_label"]) - 1
+                mapping.append((representative, sector))
+            input_mapping = tuple(mapping)
+            _validate_lc_public_mapping(input_mapping, external_count)
+            public_mapping = (
+                input_mapping
+                if public_permutation is None
+                else tuple(
+                    (public_permutation[representative], public_permutation[sector])
+                    for representative, sector in input_mapping
+                )
+            )
+            replay_weight = _decimal(
+                raw_permutation.get("weight", 1), "LC topology replay weight"
+            )
+            if replay_weight <= 0:
+                raise ArtifactError(
+                    "LC topology replay weights must be positive finite numbers"
+                )
+            parsed.append((input_mapping, public_mapping, replay_weight))
+    declared_count = _json_integer(raw_replay.get("replayed_sector_count", 0))
+    if declared_count != len(parsed) or not parsed:
+        raise ArtifactError(
+            "LC topology replay sector count does not match its permutations"
+        )
+
+    helicities = cast(Sequence[Mapping[str, object]], physics["helicities"])
+    colors = cast(Sequence[Mapping[str, object]], physics["color_components"])
+    if str(physics.get("color_accuracy")) != "lc":
+        raise ArtifactError("LC topology replay requires LC resolved physics metadata")
+    helicity_ids = tuple(str(item["id"]) for item in helicities)
+    color_ids = tuple(str(item["id"]) for item in colors)
+    helicity_index = {
+        identifier: index for index, identifier in enumerate(helicity_ids)
+    }
+    color_index = {identifier: index for index, identifier in enumerate(color_ids)}
+    helicity_by_values: dict[tuple[int, ...], int] = {}
+    for index, record in enumerate(helicities):
+        values = tuple(
+            _json_integer(value) for value in cast(Sequence[object], record["values"])
+        )
+        if values in helicity_by_values:
+            raise ArtifactError("resolved physics contains duplicate helicity vectors")
+        helicity_by_values[values] = index
+    color_by_word: dict[tuple[int, ...], int] = {}
+    for index, record in enumerate(colors):
+        if record.get("kind") != "lc-flow":
+            raise ArtifactError(
+                "LC topology replay encountered a contracted color component"
+            )
+        word = tuple(
+            _json_integer(value) for value in cast(Sequence[object], record["word"])
+        )
+        if word in color_by_word:
+            raise ArtifactError("resolved physics contains duplicate LC flow words")
+        color_by_word[word] = index
+
+    reduction = physics.get("reduction")
+    if not isinstance(reduction, Mapping):
+        raise ArtifactError("resolved physics has no reduction metadata")
+    raw_reductions = reduction.get("groups")
+    if isinstance(raw_reductions, str | bytes) or not isinstance(
+        raw_reductions, Sequence
+    ):
+        raise ArtifactError("resolved physics reduction groups are invalid")
+    relevant_helicities: set[int] = set()
+    relevant_colors: set[int] = set()
+    for raw_reduction in raw_reductions:
+        if not isinstance(raw_reduction, Mapping):
+            raise ArtifactError("resolved physics reduction group is invalid")
+        for raw_id in cast(Sequence[object], raw_reduction["physical_helicity_ids"]):
+            identifier = str(raw_id)
+            if identifier not in helicity_index:
+                raise ArtifactError(
+                    f"reduction references unknown helicity {identifier!r}"
+                )
+            relevant_helicities.add(helicity_index[identifier])
+        for raw_id in cast(Sequence[object], raw_reduction["physical_color_ids"]):
+            identifier = str(raw_id)
+            if identifier not in color_index:
+                raise ArtifactError(
+                    f"reduction references unknown color component {identifier!r}"
+                )
+            relevant_colors.add(color_index[identifier])
+    if not relevant_helicities or not relevant_colors:
+        raise ArtifactError("LC topology replay has no materialized resolved members")
+
+    entries: list[_LcReplayEntry] = []
+    color_count = len(colors)
+    for input_mapping, public_mapping, replay_weight in parsed:
+        helicity_targets: dict[int, int] = {}
+        for source_index in sorted(relevant_helicities):
+            source = helicities[source_index]
+            source_values = tuple(
+                _json_integer(value)
+                for value in cast(Sequence[object], source["values"])
+            )
+            target_values = _permute_lc_helicity(source_values, public_mapping)
+            target_index = helicity_by_values.get(target_values)
+            if target_index is None:
+                raise CompatibilityError(
+                    "resolved physics is missing replayed helicity vector "
+                    f"{target_values!r}; regenerate the artifact with complete "
+                    "topology-replay reductions"
+                )
+            source_coefficient = _decimal(source["coefficient"], "helicity coefficient")
+            target_coefficient = _decimal(
+                helicities[target_index]["coefficient"], "helicity coefficient"
+            )
+            if source_coefficient != target_coefficient:
+                raise ArtifactError(
+                    "LC topology replay maps helicities with different reduction "
+                    "coefficients"
+                )
+            helicity_targets[source_index] = target_index
+
+        color_targets: dict[int, tuple[tuple[int, Decimal], ...]] = {}
+        for source_index in sorted(relevant_colors):
+            source_word = tuple(
+                _json_integer(value)
+                for value in cast(Sequence[object], colors[source_index]["word"])
+            )
+            target_word = _permute_lc_color_word(source_word, public_mapping)
+            target_words = _lc_replay_public_words(target_word, replay_weight)
+            coefficients: dict[int, Decimal] = {}
+            for word in target_words:
+                target_index = color_by_word.get(word)
+                if target_index is None:
+                    raise CompatibilityError(
+                        "resolved physics is missing replayed LC flow word "
+                        f"{word!r}; regenerate the artifact with "
+                        "replay-to-public-flow reductions"
+                    )
+                coefficient = _decimal(
+                    colors[target_index].get("coefficient", 1),
+                    "color coefficient",
+                )
+                if coefficient <= 0:
+                    raise ArtifactError(
+                        "replayed LC flow has no positive reduction coefficient"
+                    )
+                coefficients.setdefault(target_index, coefficient)
+            total = sum(coefficients.values(), _ZERO)
+            if total <= 0:
+                raise ArtifactError(
+                    "LC topology replay has no positive public-flow reduction weight"
+                )
+            color_targets[source_index] = tuple(
+                (target_index, replay_weight * coefficient / total)
+                for target_index, coefficient in sorted(coefficients.items())
+            )
+
+        routes = tuple(
+            _LcReplayRoute(
+                source_index=source_helicity * color_count + source_color,
+                target_index=target_helicity * color_count + target_color,
+                weight=weight,
+            )
+            for source_helicity, target_helicity in sorted(helicity_targets.items())
+            for source_color in sorted(relevant_colors)
+            for target_color, weight in color_targets[source_color]
+        )
+        entries.append(_LcReplayEntry(input_mapping=input_mapping, routes=routes))
+    return _LcReplayPlan(
+        entries=tuple(entries),
+        helicity_count=len(helicities),
+        color_count=color_count,
+    )
+
+
+def _lc_replay_plan_v2(
+    execution: Mapping[str, object],
+    physics: Mapping[str, object],
+    replay: Mapping[str, object],
+    public_permutation: tuple[int, ...] | None,
+    external_count: int,
+) -> _LcReplayPlan:
+    if str(physics.get("color_accuracy")) != "lc":
+        raise ArtifactError("LC topology replay requires LC resolved physics metadata")
+    helicities = _mapping_records(physics, "helicities", "resolved physics helicities")
+    colors = _mapping_records(
+        physics, "color_components", "resolved physics color components"
+    )
+    helicity_ids = tuple(str(record.get("id")) for record in helicities)
+    color_ids = tuple(str(record.get("id")) for record in colors)
+    if len(set(helicity_ids)) != len(helicity_ids):
+        raise ArtifactError("resolved physics contains duplicate helicity IDs")
+    if len(set(color_ids)) != len(color_ids):
+        raise ArtifactError("resolved physics contains duplicate color IDs")
+    helicity_index = {
+        identifier: index for index, identifier in enumerate(helicity_ids)
+    }
+    color_index = {identifier: index for index, identifier in enumerate(color_ids)}
+    helicity_by_values: dict[tuple[int, ...], int] = {}
+    for index, record in enumerate(helicities):
+        values = _integer_vector(
+            record.get("values"), external_count, "resolved helicity vector"
+        )
+        if values in helicity_by_values:
+            raise ArtifactError("resolved physics contains duplicate helicity vectors")
+        helicity_by_values[values] = index
+    color_by_word: dict[tuple[int, ...], int] = {}
+    color_labels: frozenset[int] | None = None
+    for index, record in enumerate(colors):
+        if record.get("kind") != "lc-flow":
+            raise ArtifactError(
+                "LC topology replay encountered a contracted color component"
+            )
+        word = _external_label_word(
+            record.get("word"),
+            external_count,
+            "LC flow word",
+            expected_labels=color_labels,
+        )
+        if color_labels is None:
+            color_labels = frozenset(word)
+        if word in color_by_word:
+            raise ArtifactError("resolved physics contains duplicate LC flow words")
+        color_by_word[word] = index
+
+    reductions = _lc_reductions(physics, helicity_index, color_index)
+    relevant_helicities = {
+        helicity_index[identifier]
+        for reduction in reductions.values()
+        for identifier in _string_members(
+            reduction, "physical_helicity_ids", "reduction physical helicities"
+        )
+    }
+    if not relevant_helicities:
+        raise ArtifactError("LC topology replay has no materialized helicities")
+    materialized = _lc_materialized_sectors(
+        execution,
+        colors,
+        color_index,
+        reductions,
+    )
+
+    raw_groups = _mapping_records(replay, "groups", "LC topology replay groups")
+    routes_by_mapping: dict[
+        tuple[tuple[int, int], ...],
+        tuple[tuple[tuple[int, int], ...], list[_LcReplaySectorRoute]],
+    ] = {}
+    replayed_sector_ids: set[int] = set()
+    group_materialized_sector_ids: set[int] = set()
+    for group in raw_groups:
+        _validate_lc_replay_proof(group.get("proof"))
+        representative_sector_id = _strict_nonnegative_integer(
+            group.get("representative_sector_id"), "LC representative sector ID"
+        )
+        materialized_sector_id = _strict_nonnegative_integer(
+            group.get("materialized_sector_id"), "LC materialized sector ID"
+        )
+        if materialized_sector_id != representative_sector_id:
+            raise ArtifactError(
+                "LC replay materialized sector is not its representative sector"
+            )
+        if materialized_sector_id in group_materialized_sector_ids:
+            raise ArtifactError(
+                "LC replay groups reuse a materialized representative sector"
+            )
+        group_materialized_sector_ids.add(materialized_sector_id)
+        active_sector_ids = set(
+            _nonnegative_integer_members(
+                group,
+                "active_sector_ids",
+                "LC replay active sector IDs",
+            )
+        )
+        if representative_sector_id not in active_sector_ids:
+            raise ArtifactError(
+                "LC replay active sectors omit the representative sector"
+            )
+        if replayed_sector_ids & active_sector_ids:
+            raise ArtifactError("LC replay groups overlap physical sector coverage")
+        replayed_sector_ids.update(active_sector_ids)
+        raw_permutations = _mapping_records(
+            group,
+            "sector_permutations",
+            "LC topology replay sector permutations",
+        )
+        seen_sector_ids: set[int] = set()
+        for permutation in raw_permutations:
+            sector_id = _strict_nonnegative_integer(
+                permutation.get("sector_id"), "LC replay physical sector ID"
+            )
+            if sector_id not in active_sector_ids or sector_id in seen_sector_ids:
+                raise ArtifactError(
+                    "LC replay permutations do not uniquely cover active sectors"
+                )
+            seen_sector_ids.add(sector_id)
+            mapping = _lc_v2_label_mapping(
+                permutation.get("label_permutation"), external_count
+            )
+            public_mapping = (
+                mapping
+                if public_permutation is None
+                else tuple(
+                    (public_permutation[representative], public_permutation[sector])
+                    for representative, sector in mapping
+                )
+            )
+            weight = _decimal(permutation.get("weight"), "LC replay sector weight")
+            sign = _json_integer(permutation.get("sign"))
+            if weight <= 0 or sign not in {-1, 1}:
+                raise ArtifactError(
+                    "LC replay sector weight/sign must be positive and +/-1"
+                )
+            factor = _complex_decimal_pair(
+                permutation.get("factor"), "LC replay signed factor"
+            )
+            if factor != (weight * sign, _ZERO):
+                raise ArtifactError(
+                    "LC replay signed factor does not match its weight and sign"
+                )
+            stored_public, mapping_routes = routes_by_mapping.setdefault(
+                mapping, (public_mapping, [])
+            )
+            if stored_public != public_mapping:
+                raise ArtifactError("LC replay has inconsistent public label mappings")
+            mapping_routes.append(
+                _LcReplaySectorRoute(
+                    physical_sector_id=sector_id,
+                    materialized_sector_id=materialized_sector_id,
+                    reduction_weight=weight,
+                    residual=False,
+                )
+            )
+        if seen_sector_ids != active_sector_ids:
+            raise ArtifactError(
+                "LC replay permutations do not exactly cover active sectors"
+            )
+
+    declared_replayed = _strict_nonnegative_integer(
+        replay.get("replayed_sector_count"), "LC replayed sector count"
+    )
+    if declared_replayed != len(replayed_sector_ids):
+        raise ArtifactError("LC replayed sector count is inconsistent")
+    residual_sector_ids = set(
+        _nonnegative_integer_members(
+            replay,
+            "residual_sector_ids",
+            "LC replay residual sector IDs",
+        )
+    )
+    if replayed_sector_ids & residual_sector_ids:
+        raise ArtifactError("LC replay residual and replayed sectors overlap")
+    identity_public: tuple[tuple[int, int], ...] = ()
+    stored_public, identity_routes = routes_by_mapping.setdefault(
+        (), (identity_public, [])
+    )
+    if stored_public != identity_public:
+        raise ArtifactError("LC replay identity mapping is inconsistent")
+    for sector_id in sorted(residual_sector_ids):
+        sector = materialized.get(sector_id)
+        if sector is None:
+            raise ArtifactError(
+                f"LC replay residual sector {sector_id} is not materialized"
+            )
+        identity_routes.append(
+            _LcReplaySectorRoute(
+                physical_sector_id=sector_id,
+                materialized_sector_id=sector_id,
+                reduction_weight=sector.reduction_weight,
+                residual=True,
+            )
+        )
+
+    declared_materialized = set(
+        _nonnegative_integer_members(
+            replay,
+            "materialized_sector_ids",
+            "LC replay materialized sector IDs",
+        )
+    )
+    expected_materialized = group_materialized_sector_ids | residual_sector_ids
+    if declared_materialized != expected_materialized:
+        raise ArtifactError("LC replay materialized sector coverage is inconsistent")
+    physical_sector_count = _strict_nonnegative_integer(
+        replay.get("physical_sector_count"), "LC physical sector count"
+    )
+    if replayed_sector_ids | residual_sector_ids != set(range(physical_sector_count)):
+        raise ArtifactError(
+            "LC replay does not cover every physical sector exactly once"
+        )
+    if not declared_materialized.issubset(materialized):
+        raise ArtifactError("LC replay declares an absent materialized sector")
+
+    entries: list[_LcReplayEntry] = []
+    target_sector_by_color: dict[int, int] = {}
+    color_count = len(colors)
+    for input_mapping in sorted(routes_by_mapping):
+        public_mapping, sector_routes = routes_by_mapping[input_mapping]
+        helicity_targets: dict[int, int] = {}
+        for source_index in sorted(relevant_helicities):
+            source = helicities[source_index]
+            source_values = _integer_vector(
+                source.get("values"), external_count, "resolved helicity vector"
+            )
+            target_values = _permute_lc_helicity(source_values, public_mapping)
+            target_index = helicity_by_values.get(target_values)
+            if target_index is None:
+                raise CompatibilityError(
+                    "resolved physics is missing replayed helicity vector "
+                    f"{target_values!r}; regenerate the artifact with complete "
+                    "topology-replay reductions"
+                )
+            if _decimal(source.get("coefficient"), "helicity coefficient") != _decimal(
+                helicities[target_index].get("coefficient"),
+                "helicity coefficient",
+            ):
+                raise ArtifactError(
+                    "LC topology replay maps helicities with different coefficients"
+                )
+            helicity_targets[source_index] = target_index
+
+        resolved_routes: list[_LcReplayRoute] = []
+        for sector_route in sorted(
+            sector_routes, key=lambda route: route.physical_sector_id
+        ):
+            source_sector = materialized.get(sector_route.materialized_sector_id)
+            if source_sector is None:
+                raise ArtifactError(
+                    "LC replay route references an absent materialized sector"
+                )
+            source_index = source_sector.color_index
+            source = colors[source_index]
+            source_id = str(source.get("id"))
+            if (
+                source.get("computed") is not True
+                or source.get("representative_id") != source_id
+            ):
+                raise ArtifactError(
+                    "LC replay materialized sector is not a computed representative"
+                )
+            source_word = _external_label_word(
+                source.get("word"),
+                external_count,
+                "materialized LC flow word",
+                expected_labels=color_labels,
+            )
+            target_word = _permute_lc_color_word(source_word, public_mapping)
+            target_words = _lc_replay_public_words(
+                target_word, sector_route.reduction_weight
+            )
+            target_coefficients: dict[int, Decimal] = {}
+            for word in target_words:
+                target_index = color_by_word.get(word)
+                if target_index is None:
+                    raise CompatibilityError(
+                        "resolved physics is missing replayed LC flow word "
+                        f"{word!r}; regenerate the artifact with "
+                        "replay-to-public-flow reductions"
+                    )
+                target = colors[target_index]
+                if target.get("representative_id") != source_id:
+                    raise ArtifactError(
+                        "LC replay target flow has the wrong representative"
+                    )
+                previous_sector = target_sector_by_color.setdefault(
+                    target_index, sector_route.physical_sector_id
+                )
+                if previous_sector != sector_route.physical_sector_id:
+                    raise ArtifactError(
+                        "LC replay physical sectors overlap a public color flow"
+                    )
+                coefficient = _decimal(
+                    target.get("coefficient", 1), "color coefficient"
+                )
+                if coefficient <= 0:
+                    raise ArtifactError(
+                        "replayed LC flow has no positive reduction coefficient"
+                    )
+                target_coefficients.setdefault(target_index, coefficient)
+            total = sum(target_coefficients.values(), _ZERO)
+            if total <= 0:
+                raise ArtifactError(
+                    "LC topology replay has no positive public-flow weight"
+                )
+            for source_helicity, target_helicity in sorted(helicity_targets.items()):
+                for target_color, coefficient in sorted(target_coefficients.items()):
+                    resolved_routes.append(
+                        _LcReplayRoute(
+                            source_index=source_helicity * color_count + source_index,
+                            target_index=target_helicity * color_count + target_color,
+                            weight=(
+                                sector_route.reduction_weight * coefficient / total
+                            ),
+                        )
+                    )
+        if not resolved_routes:
+            raise ArtifactError("LC topology replay mapping has no resolved routes")
+        entries.append(
+            _LcReplayEntry(
+                input_mapping=input_mapping,
+                routes=tuple(resolved_routes),
+            )
+        )
+    if set(target_sector_by_color) != set(range(color_count)):
+        raise ArtifactError(
+            f"LC topology replay covers {len(target_sector_by_color)} of "
+            f"{color_count} public color components"
+        )
+    return _LcReplayPlan(
+        entries=tuple(entries),
+        helicity_count=len(helicities),
+        color_count=color_count,
+    )
+
+
+def _lc_reductions(
+    physics: Mapping[str, object],
+    helicity_index: Mapping[str, int],
+    color_index: Mapping[str, int],
+) -> dict[int, Mapping[str, object]]:
+    reduction = physics.get("reduction")
+    if not isinstance(reduction, Mapping):
+        raise ArtifactError("resolved physics has no reduction metadata")
+    records = _mapping_records(reduction, "groups", "resolved physics reduction groups")
+    result: dict[int, Mapping[str, object]] = {}
+    for record in records:
+        identifier = str(record.get("id", ""))
+        if not identifier.startswith("reduction:"):
+            raise ArtifactError("resolved reduction group has an invalid ID")
+        try:
+            group_id = int(identifier.removeprefix("reduction:"))
+        except ValueError as exc:
+            raise ArtifactError("resolved reduction group has an invalid ID") from exc
+        if group_id < 0 or group_id in result:
+            raise ArtifactError("resolved reduction group IDs are invalid")
+        helicity_ids = _string_members(
+            record, "physical_helicity_ids", "reduction physical helicities"
+        )
+        color_ids = _string_members(
+            record, "physical_color_ids", "reduction physical colors"
+        )
+        if not helicity_ids or any(
+            value not in helicity_index for value in helicity_ids
+        ):
+            raise ArtifactError("reduction references an unknown physical helicity")
+        if not color_ids or any(value not in color_index for value in color_ids):
+            raise ArtifactError("reduction references an unknown physical color")
+        result[group_id] = record
+    return result
+
+
+def _lc_materialized_sectors(
+    execution: Mapping[str, object],
+    colors: Sequence[Mapping[str, object]],
+    color_index: Mapping[str, int],
+    reductions: Mapping[int, Mapping[str, object]],
+) -> dict[int, _LcMaterializedSector]:
+    runtime_schema = execution.get("runtime_schema")
+    if not isinstance(runtime_schema, Mapping):
+        raise ArtifactError("execution metadata has no runtime schema")
+    amplitude_stage = runtime_schema.get("amplitude_stage")
+    if not isinstance(amplitude_stage, Mapping):
+        raise ArtifactError("runtime schema has no amplitude stage")
+    roots = _mapping_records(amplitude_stage, "roots", "runtime amplitude roots")
+    result: dict[int, _LcMaterializedSector] = {}
+    for root in roots:
+        sector_id = _strict_nonnegative_integer(
+            root.get("color_sector_id"), "materialized root color sector ID"
+        )
+        group_id = _strict_nonnegative_integer(
+            root.get("coherent_group_id"), "materialized coherent group ID"
+        )
+        reduction = reductions.get(group_id)
+        if reduction is None:
+            raise ArtifactError(
+                "materialized LC sector is missing its physics reduction group"
+            )
+        computed = {
+            color_index[identifier]
+            for identifier in _string_members(
+                reduction, "physical_color_ids", "reduction physical colors"
+            )
+            if colors[color_index[identifier]].get("computed") is True
+        }
+        if len(computed) != 1:
+            raise ArtifactError(
+                "materialized LC sector does not have one computed representative"
+            )
+        color = next(iter(computed))
+        record = colors[color]
+        if record.get("representative_id") != record.get("id"):
+            raise ArtifactError(
+                "computed LC materialized color does not represent itself"
+            )
+        all_sector_weight = _decimal(
+            root.get("all_sector_weight"), "materialized LC sector weight"
+        )
+        helicity_weight = _decimal(
+            root.get("helicity_weight", 1), "materialized helicity weight"
+        )
+        if all_sector_weight <= 0 or helicity_weight <= 0:
+            raise ArtifactError("materialized LC sector weight must be positive")
+        weight = all_sector_weight / helicity_weight
+        sector = _LcMaterializedSector(color, weight)
+        previous = result.setdefault(sector_id, sector)
+        if previous != sector:
+            raise ArtifactError(
+                "materialized LC sector maps to inconsistent colors or weights"
+            )
+    return result
+
+
+def _validate_lc_replay_proof(value: object) -> None:
+    if not isinstance(value, Mapping):
+        raise ArtifactError("LC replay contract v2 group has no proof metadata")
+    algorithm = value.get("algorithm")
+    digest = value.get("digest")
+    if (
+        value.get("status") != "proven"
+        or not isinstance(algorithm, str)
+        or not algorithm
+        or not isinstance(digest, str)
+        or len(digest) != 64
+        or any(character not in "0123456789abcdef" for character in digest)
+    ):
+        raise ArtifactError("LC replay contract v2 proof metadata is invalid")
+
+
+def _lc_v2_label_mapping(
+    value: object, external_count: int
+) -> tuple[tuple[int, int], ...]:
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise ArtifactError("LC replay label permutation is invalid")
+    mapping = []
+    for raw_item in value:
+        if not isinstance(raw_item, Mapping):
+            raise ArtifactError("LC replay label permutation entry is not an object")
+        representative = _strict_nonnegative_integer(
+            raw_item.get("representative_label"), "LC representative label"
+        )
+        sector = _strict_nonnegative_integer(
+            raw_item.get("sector_label"), "LC sector label"
+        )
+        if (
+            not 1 <= representative <= external_count
+            or not 1 <= sector <= external_count
+        ):
+            raise ArtifactError("LC replay label permutation is out of range")
+        if representative != sector:
+            mapping.append((representative - 1, sector - 1))
+    result = tuple(sorted(mapping))
+    _validate_lc_public_mapping(result, external_count)
+    return result
+
+
+def _mapping_records(
+    mapping: Mapping[str, object], key: str, context: str
+) -> tuple[Mapping[str, object], ...]:
+    value = mapping.get(key)
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} are invalid")
+    if any(not isinstance(record, Mapping) for record in value):
+        raise ArtifactError(f"{context} contain a non-object entry")
+    return cast(tuple[Mapping[str, object], ...], tuple(value))
+
+
+def _string_members(
+    mapping: Mapping[str, object], key: str, context: str
+) -> tuple[str, ...]:
+    value = mapping.get(key)
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} are invalid")
+    result = tuple(str(item) for item in value)
+    if len(set(result)) != len(result):
+        raise ArtifactError(f"{context} contain duplicates")
+    return result
+
+
+def _nonnegative_integer_members(
+    mapping: Mapping[str, object], key: str, context: str
+) -> tuple[int, ...]:
+    value = mapping.get(key)
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} are invalid")
+    result = tuple(
+        _strict_nonnegative_integer(item, f"{context} entry") for item in value
+    )
+    if len(set(result)) != len(result):
+        raise ArtifactError(f"{context} contain duplicates")
+    return result
+
+
+def _validate_lc_public_mapping(
+    mapping: Sequence[tuple[int, int]], external_count: int
+) -> None:
+    representatives: set[int] = set()
+    sectors: set[int] = set()
+    for representative, sector in mapping:
+        if not 0 <= representative < external_count or not 0 <= sector < external_count:
+            raise ArtifactError(
+                "LC topology replay label permutation references an out-of-range leg"
+            )
+        if representative in representatives or sector in sectors:
+            raise ArtifactError(
+                "LC topology replay label permutation is not one-to-one"
+            )
+        representatives.add(representative)
+        sectors.add(sector)
+    if representatives != sectors:
+        raise ArtifactError(
+            "LC topology replay label permutation is not a permutation of its support"
+        )
+
+
+def _permute_lc_helicity(
+    values: tuple[int, ...], mapping: Sequence[tuple[int, int]]
+) -> tuple[int, ...]:
+    target = list(values)
+    for representative, sector in mapping:
+        target[sector] = values[representative]
+    return tuple(target)
+
+
+def _permute_lc_color_word(
+    word: tuple[int, ...], mapping: Sequence[tuple[int, int]]
+) -> tuple[int, ...]:
+    labels = {representative + 1: sector + 1 for representative, sector in mapping}
+    return tuple(labels.get(label, label) for label in word)
+
+
+def _lc_replay_public_words(
+    word: tuple[int, ...], replay_weight: Decimal
+) -> tuple[tuple[int, ...], ...]:
+    tolerance = Decimal("1e-12")
+    if abs(replay_weight - _ONE) <= tolerance:
+        return (word,)
+    if abs(replay_weight - _TWO) > tolerance:
+        raise CompatibilityError(
+            "resolved LC topology replay cannot expand sector weight "
+            f"{replay_weight}; schema-v3 replay metadata defines public-flow "
+            "expansion only for unit sectors and folded trace-reflection weight two"
+        )
+    if len(word) < 2:
+        return (word,)
+    reflected = (word[0], *reversed(word[1:]))
+    return (word,) if reflected == word else (word, reflected)
+
+
+def _apply_lc_replay_input_mapping(
+    point: tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...],
+    mapping: Sequence[tuple[int, int]],
+) -> tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]:
+    mapped = list(point)
+    for representative, sector in mapping:
+        mapped[representative] = point[sector]
+    return tuple(mapped)
+
+
+def _apply_lc_replay_resolved(
+    materialized: tuple[tuple[tuple[Decimal, ...], ...], ...],
+    plan: _LcReplayPlan,
+    point_count: int,
+    helicity_ids: tuple[str, ...],
+    color_ids: tuple[str, ...],
+    selected_helicities: Sequence[str] | None,
+    selected_colors: Sequence[str] | None,
+) -> tuple[
+    tuple[tuple[tuple[Decimal, ...], ...], ...],
+    tuple[str, ...],
+    tuple[str, ...],
+]:
+    if len(helicity_ids) != plan.helicity_count or len(color_ids) != plan.color_count:
+        raise ArtifactError(
+            "materialized LC topology replay axes do not match public physics"
+        )
+    expected_points = point_count * len(plan.entries)
+    if len(materialized) != expected_points:
+        raise ArtifactError(
+            "materialized LC topology replay result has an inconsistent point count"
+        )
+    full = [
+        [[_ZERO for _ in range(plan.color_count)] for _ in range(plan.helicity_count)]
+        for _ in range(point_count)
+    ]
+    for entry_index, entry in enumerate(plan.entries):
+        for point_index in range(point_count):
+            source = materialized[entry_index * point_count + point_index]
+            if len(source) != plan.helicity_count or any(
+                len(colors) != plan.color_count for colors in source
+            ):
+                raise ArtifactError(
+                    "materialized LC topology replay result has an inconsistent shape"
+                )
+            for route in entry.routes:
+                source_helicity, source_color = divmod(
+                    route.source_index, plan.color_count
+                )
+                target_helicity, target_color = divmod(
+                    route.target_index, plan.color_count
+                )
+                full[point_index][target_helicity][target_color] += (
+                    route.weight * source[source_helicity][source_color]
+                )
+    selected_h = _selected_indices(helicity_ids, selected_helicities, "helicity")
+    selected_c = _selected_indices(color_ids, selected_colors, "color component")
+    values = tuple(
+        tuple(tuple(full[p][h][c] for c in selected_c) for h in selected_h)
+        for p in range(point_count)
+    )
+    return (
+        values,
+        tuple(helicity_ids[index] for index in selected_h),
+        tuple(color_ids[index] for index in selected_c),
+    )
+
+
+def _evaluator_manifest(stage: object) -> Mapping[str, object]:
+    if not isinstance(stage, Mapping) or not isinstance(
+        stage.get("evaluator"), Mapping
+    ):
+        raise ArtifactError("serialized stage has no evaluator manifest")
+    return cast(Mapping[str, object], stage["evaluator"])
+
+
+def _runtime_state(native_runtime: Any) -> _RuntimeState:
+    payload = exact_runtime_state_payload(native_runtime)
+    values = payload.get("model_parameter_values")
+    if isinstance(values, str | bytes) or not isinstance(values, Sequence):
+        raise ArtifactError("Rusticol exact-runtime model parameters are invalid")
+    if "normalization_factor" not in payload:
+        raise ArtifactError("Rusticol exact-runtime normalization is absent")
+    return cast(_RuntimeState, payload)
+
+
+def _diagnostic_external_particles(
+    physics: Mapping[str, object],
+) -> tuple[Mapping[str, object], ...]:
+    raw_particles = physics.get("external_particles")
+    if isinstance(raw_particles, str | bytes) or not isinstance(
+        raw_particles, Sequence
+    ):
+        raise ArtifactError("physics metadata has no external particles")
+    particles = []
+    for index, raw_particle in enumerate(raw_particles):
+        if not isinstance(raw_particle, Mapping):
+            raise ArtifactError(f"external particle {index} is not an object")
+        role = raw_particle.get("role")
+        if role not in {"initial", "final", "incoming", "outgoing"}:
+            raise ArtifactError(f"external particle {index} has an invalid role")
+        label = raw_particle.get("label")
+        pdg = raw_particle.get("pdg")
+        if (
+            isinstance(label, bool)
+            or not isinstance(label, int)
+            or label < 1
+            or isinstance(pdg, bool)
+            or not isinstance(pdg, int)
+        ):
+            raise ArtifactError(f"external particle {index} has invalid identity")
+        particles.append(raw_particle)
+    return tuple(particles)
+
+
+def _diagnostic_schema_mass_bindings(
+    schema: Mapping[str, object],
+    physics: Mapping[str, object],
+    parameters: Sequence[Decimal],
+) -> tuple[_DiagnosticMassBinding, ...]:
+    """Resolve external masses through authenticated schema bindings."""
+
+    model = schema.get("model")
+    raw_parameters = schema.get("model_parameters")
+    if not isinstance(model, Mapping):
+        raise ArtifactError("runtime schema has no model metadata")
+    raw_particles = model.get("particles")
+    if isinstance(raw_particles, str | bytes) or not isinstance(
+        raw_particles, Sequence
+    ):
+        raise ArtifactError("runtime schema model has no particles")
+    if isinstance(raw_parameters, str | bytes) or not isinstance(
+        raw_parameters, Sequence
+    ):
+        raise ArtifactError("runtime schema has no model parameters")
+    model_particles = tuple(
+        particle for particle in raw_particles if isinstance(particle, Mapping)
+    )
+    if len(model_particles) != len(raw_particles):
+        raise ArtifactError("runtime schema model particle is not an object")
+    parameter_records = tuple(
+        parameter for parameter in raw_parameters if isinstance(parameter, Mapping)
+    )
+    if len(parameter_records) != len(raw_parameters):
+        raise ArtifactError("runtime schema model parameter is not an object")
+
+    bindings = []
+    for index, external in enumerate(_diagnostic_external_particles(physics)):
+        pdg = cast(int, external["pdg"])
+        record = next(
+            (
+                particle
+                for particle in model_particles
+                if _json_integer(particle.get("pdg")) == pdg
+            ),
+            None,
+        )
+        if record is None:
+            record = next(
+                (
+                    particle
+                    for particle in model_particles
+                    if _json_integer(particle.get("pdg")) == -pdg
+                ),
+                None,
+            )
+        if record is None:
+            raise ArtifactError(
+                f"external particle {index} has no authenticated mass binding"
+            )
+        parameter_name = record.get("mass_parameter")
+        if parameter_name is not None:
+            if not isinstance(parameter_name, str) or not parameter_name:
+                raise ArtifactError(
+                    f"external particle {index} has an invalid mass parameter"
+                )
+            matches = tuple(
+                parameter
+                for parameter in parameter_records
+                if parameter.get("name") == parameter_name
+            )
+            if len(matches) != 1:
+                raise ArtifactError(
+                    f"external particle {index} mass parameter {parameter_name!r} "
+                    "does not have one authenticated binding"
+                )
+            parameter_index = matches[0].get("parameter_index")
+            if (
+                isinstance(parameter_index, bool)
+                or not isinstance(parameter_index, int)
+                or parameter_index < 0
+            ):
+                raise ArtifactError(
+                    f"external particle {index} mass parameter index is invalid"
+                )
+            try:
+                mass = parameters[parameter_index]
+            except IndexError as exc:
+                raise ArtifactError(
+                    f"external particle {index} mass parameter index is invalid"
+                ) from exc
+            authority = "authenticated-current-runtime-model-parameter"
+        else:
+            mass = _decimal(
+                record.get("mass", 0),
+                f"external particle {index} static mass",
+            )
+            authority = "authenticated-runtime-schema-static-mass"
+        if not mass.is_finite():
+            raise EvaluationError(f"external particle {index} mass must be finite")
+        bindings.append(
+            _DiagnosticMassBinding(
+                mass=mass,
+                authority=authority,
+                parameter_name=parameter_name,
+            )
+        )
+    return tuple(bindings)
+
+
+def _diagnostic_input_order(
+    values: Sequence[Any], permutation: tuple[int, ...] | None
+) -> tuple[Any, ...]:
+    """Invert the artifact-order alias permutation back to caller order."""
+
+    ordered = tuple(values)
+    if permutation is None:
+        return ordered
+    if len(permutation) != len(ordered) or set(permutation) != set(range(len(ordered))):
+        raise ArtifactError("diagnostic external permutation is invalid")
+    result: list[Any | None] = [None] * len(ordered)
+    for artifact_index, input_index in enumerate(permutation):
+        result[input_index] = ordered[artifact_index]
+    if any(value is None for value in result):
+        raise ArtifactError("diagnostic external permutation is incomplete")
+    return tuple(result)
+
+
+def _diagnostic_decimal_point_digest(
+    points: Sequence[Sequence[Sequence[Decimal]]],
+) -> str:
+    payload = [
+        [[str(component) for component in leg] for leg in point] for point in points
+    ]
+    encoded = json.dumps(
+        payload,
+        ensure_ascii=True,
+        separators=(",", ":"),
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _diagnostic_global_residual(
+    point: Sequence[Sequence[Decimal]],
+    particles: Sequence[Mapping[str, object]],
+) -> tuple[Decimal, Decimal, Decimal, Decimal]:
+    residual = [_ZERO, _ZERO, _ZERO, _ZERO]
+    for leg, particle in zip(point, particles, strict=True):
+        sign = -_ONE if particle["role"] in {"initial", "incoming"} else _ONE
+        for component_index, component in enumerate(leg):
+            residual[component_index] += sign * component
+    return cast(tuple[Decimal, Decimal, Decimal, Decimal], tuple(residual))
+
+
+def _diagnostic_project_onshell_points(
+    momenta: Momenta,
+    *,
+    physics: Mapping[str, object],
+    artifact_mass_bindings: Sequence[_DiagnosticMassBinding],
+    permutation: tuple[int, ...] | None,
+    precision: int,
+) -> tuple[
+    tuple[tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...], ...],
+    dict[str, object],
+]:
+    """Project external energies for a non-promoting precision diagnostic."""
+
+    if isinstance(precision, bool) or not isinstance(precision, int) or precision < 1:
+        raise EvaluationError(
+            "diagnostic precision must be a positive integer number of decimal digits"
+        )
+    particles = _diagnostic_external_particles(physics)
+    if len(artifact_mass_bindings) != len(particles):
+        raise ArtifactError("diagnostic external mass binding count is inconsistent")
+    input_particles = cast(
+        tuple[Mapping[str, object], ...],
+        _diagnostic_input_order(particles, permutation),
+    )
+    input_bindings = cast(
+        tuple[_DiagnosticMassBinding, ...],
+        _diagnostic_input_order(artifact_mass_bindings, permutation),
+    )
+    points = _prepare_points(momenta, physics, None)
+    working_precision = _working_precision(precision)
+    projected_points = []
+    point_metadata = []
+    unchanged = True
+    with localcontext() as context:
+        context.prec = working_precision
+        context.rounding = ROUND_HALF_EVEN
+        for point_index, point in enumerate(points):
+            before_global = _diagnostic_global_residual(point, input_particles)
+            projected_legs = []
+            leg_metadata = []
+            for leg_index, (leg, particle, binding) in enumerate(
+                zip(point, input_particles, input_bindings, strict=True)
+            ):
+                energy, px, py, pz = leg
+                spatial_squared = px * px + py * py + pz * pz
+                mass_squared = binding.mass * binding.mass
+                magnitude = (spatial_squared + mass_squared).sqrt()
+                projected_energy = -magnitude if energy.is_signed() else magnitude
+                projected_leg = (projected_energy, px, py, pz)
+                projected_legs.append(projected_leg)
+                unchanged = unchanged and projected_energy == energy
+                leg_metadata.append(
+                    {
+                        "point_index": point_index,
+                        "leg_index": leg_index,
+                        "label": particle["label"],
+                        "pdg": particle["pdg"],
+                        "state": (
+                            "incoming"
+                            if particle["role"] in {"initial", "incoming"}
+                            else "outgoing"
+                        ),
+                        "mass": str(binding.mass),
+                        "mass_authority": binding.authority,
+                        "mass_parameter": binding.parameter_name,
+                        "original_energy": str(energy),
+                        "projected_energy": str(projected_energy),
+                        "energy_delta": str(projected_energy - energy),
+                        "shell_residual_before": str(
+                            energy * energy - spatial_squared - mass_squared
+                        ),
+                        "shell_residual_after": str(
+                            projected_energy * projected_energy
+                            - spatial_squared
+                            - mass_squared
+                        ),
+                    }
+                )
+            projected_point = tuple(projected_legs)
+            projected_points.append(projected_point)
+            after_global = _diagnostic_global_residual(projected_point, input_particles)
+            point_metadata.append(
+                {
+                    "point_index": point_index,
+                    "global_residual_before": [
+                        str(component) for component in before_global
+                    ],
+                    "global_residual_after": [
+                        str(component) for component in after_global
+                    ],
+                    "legs": leg_metadata,
+                }
+            )
+    projected = tuple(projected_points)
+    return projected, {
+        "abi": "pyamplicol-diagnostic-onshell-projection-v1",
+        "kind": "per-leg-onshell-energy-v1",
+        "precision_digits": precision,
+        "working_precision_digits": working_precision,
+        "mass_authority": "authenticated-current-runtime-and-artifact-bindings",
+        "energy_sign_preserved": True,
+        "spatial_components_unchanged": True,
+        "global_rebalance_applied": False,
+        "global_residual_convention": "final-minus-initial",
+        "unchanged": unchanged,
+        "projected_digest": _diagnostic_decimal_point_digest(projected),
+        "projected_digest_kind": "sha256-decimal-string-momenta-v1",
+        "points": point_metadata,
+    }
+
+
+def _prepare_points(
+    momenta: Momenta,
+    physics: Mapping[str, object],
+    permutation: tuple[int, ...] | None,
+) -> tuple[tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...], ...]:
+    particles = physics.get("external_particles")
+    if isinstance(particles, str | bytes) or not isinstance(particles, Sequence):
+        raise ArtifactError("physics metadata has no external particles")
+    external_count = len(particles)
+    if not momenta:
+        raise EvaluationError("momenta must contain at least one point")
+    prepared = []
+    for point_index, point in enumerate(momenta):
+        if len(point) != external_count:
+            raise EvaluationError(
+                f"point {point_index} has {len(point)} legs, expected {external_count}"
+            )
+        legs = []
+        for leg_index, leg in enumerate(point):
+            if len(leg) != 4:
+                raise EvaluationError(
+                    f"point {point_index} leg {leg_index} must have four components"
+                )
+            legs.append(
+                cast(
+                    tuple[Decimal, Decimal, Decimal, Decimal],
+                    tuple(
+                        _decimal(
+                            component,
+                            f"point {point_index} leg {leg_index} "
+                            f"component {component_index}",
+                        )
+                        for component_index, component in enumerate(leg)
+                    ),
+                )
+            )
+        if permutation is not None:
+            legs = [legs[alias_index] for alias_index in permutation]
+        prepared.append(tuple(legs))
+    return tuple(prepared)
+
+
+def _pack_stage_inputs(
+    state: Sequence[_ComplexDecimal], stage: Mapping[str, object]
+) -> tuple[_ComplexDecimal, ...]:
+    parameter_count = _json_integer(stage["parameter_count"])
+    raw_components = stage.get("input_components")
+    if isinstance(raw_components, Sequence) and not isinstance(
+        raw_components, str | bytes
+    ):
+        packed = [_complex_zero() for _ in range(parameter_count)]
+        seen: set[int] = set()
+        for raw_component in raw_components:
+            component = cast(Mapping[str, object], raw_component)
+            local = _json_integer(component["parameter_index"])
+            global_index = _json_integer(component["global_component"])
+            if local in seen or not 0 <= local < parameter_count:
+                raise ArtifactError("stage input parameter mapping is invalid")
+            try:
+                packed[local] = state[global_index]
+            except IndexError as exc:
+                raise ArtifactError(
+                    "stage input references an absent global value"
+                ) from exc
+            seen.add(local)
+        if len(seen) != parameter_count:
+            raise ArtifactError("stage input mapping is incomplete")
+        return tuple(packed)
+    if parameter_count != len(state):
+        raise ArtifactError(
+            "flat evaluator parameter count does not match runtime state"
+        )
+    return tuple(state)
+
+
+def _assign_stage_outputs(
+    state: list[_ComplexDecimal],
+    outputs: Sequence[_ComplexDecimal],
+    stage: Mapping[str, object],
+) -> None:
+    raw_slots = stage.get("output_slots")
+    if isinstance(raw_slots, str | bytes) or not isinstance(raw_slots, Sequence):
+        raise ArtifactError("stage output slots are invalid")
+    for raw_slot in raw_slots:
+        slot = cast(Mapping[str, object], raw_slot)
+        output_start = _json_integer(slot["output_start"])
+        output_stop = _json_integer(slot["output_stop"])
+        component_start = _json_integer(slot["component_start"])
+        component_stop = _json_integer(slot["component_stop"])
+        if output_stop - output_start != component_stop - component_start:
+            raise ArtifactError("stage output slot has inconsistent lengths")
+        if output_stop > len(outputs) or component_stop > len(state):
+            raise ArtifactError("stage output slot is out of range")
+        state[component_start:component_stop] = outputs[output_start:output_stop]
+
+
+def _canonical_amplitude_outputs(
+    outputs: Sequence[_ComplexDecimal],
+    stage: Mapping[str, object],
+) -> tuple[_ComplexDecimal, ...]:
+    """Scatter evaluator-ordered amplitudes into canonical root order."""
+
+    output_length = _strict_nonnegative_integer(
+        stage.get("output_length"), "amplitude evaluator output length"
+    )
+    if len(outputs) != output_length:
+        raise ArtifactError(
+            "amplitude evaluator output mapping has an inconsistent buffer length"
+        )
+    canonical: list[_ComplexDecimal | None] = [None] * output_length
+    seen_evaluator_outputs: set[int] = set()
+
+    def bind(evaluator_output: int, canonical_output: int) -> None:
+        if (
+            evaluator_output >= output_length
+            or canonical_output >= output_length
+            or evaluator_output in seen_evaluator_outputs
+            or canonical[canonical_output] is not None
+        ):
+            raise ArtifactError(
+                "amplitude evaluator output mapping is not a permutation"
+            )
+        seen_evaluator_outputs.add(evaluator_output)
+        canonical[canonical_output] = outputs[evaluator_output]
+
+    direct = stage.get("compiled_plane_arena")
+    if direct is not None:
+        if not isinstance(direct, Mapping):
+            raise ArtifactError(
+                "compiled plane-arena amplitude metadata is not an object"
+            )
+        for raw_binding in _mapping_sequence(
+            direct,
+            "output_bindings",
+            "compiled plane-arena amplitude output bindings",
+        ):
+            if not isinstance(raw_binding, Mapping):
+                raise ArtifactError(
+                    "compiled plane-arena amplitude output binding is invalid"
+                )
+            if raw_binding.get("arena") != "amplitude":
+                raise ArtifactError(
+                    "compiled plane-arena amplitude binding names the wrong arena"
+                )
+            bind(
+                _strict_nonnegative_integer(
+                    raw_binding.get("output_index"),
+                    "amplitude evaluator output index",
+                ),
+                _strict_nonnegative_integer(
+                    raw_binding.get("component"),
+                    "canonical amplitude output index",
+                ),
+            )
+    else:
+        for raw_slot in _mapping_sequence(
+            stage, "output_slots", "amplitude evaluator output slots"
+        ):
+            if not isinstance(raw_slot, Mapping):
+                raise ArtifactError("amplitude evaluator output slot is invalid")
+            output_start = _strict_nonnegative_integer(
+                raw_slot.get("output_start"), "amplitude evaluator output start"
+            )
+            output_stop = _strict_nonnegative_integer(
+                raw_slot.get("output_stop"), "amplitude evaluator output stop"
+            )
+            component_start = _strict_nonnegative_integer(
+                raw_slot.get("component_start"),
+                "amplitude evaluator component start",
+            )
+            component_stop = _strict_nonnegative_integer(
+                raw_slot.get("component_stop"),
+                "amplitude evaluator component stop",
+            )
+            if (
+                output_stop < output_start
+                or component_stop < component_start
+                or output_stop - output_start != component_stop - component_start
+                or output_stop > output_length
+                or component_stop > output_length
+            ):
+                raise ArtifactError(
+                    "amplitude evaluator output and component ranges disagree"
+                )
+            for offset in range(output_stop - output_start):
+                bind(output_start + offset, component_start + offset)
+
+    if len(seen_evaluator_outputs) != output_length or any(
+        value is None for value in canonical
+    ):
+        raise ArtifactError("amplitude evaluator output mapping is incomplete")
+    return cast(tuple[_ComplexDecimal, ...], tuple(canonical))
+
+
+def _fill_momenta(
+    state: list[_ComplexDecimal],
+    point: Sequence[tuple[Decimal, Decimal, Decimal, Decimal]],
+    schema: Mapping[str, object],
+) -> None:
+    layout = cast(Mapping[str, object], schema["parameter_layout"])
+    value_count = _json_integer(layout["value_component_count"])
+    external = cast(Sequence[Mapping[str, object]], schema["external_particles"])
+    incoming = {
+        _json_integer(particle["label"])
+        for particle in external
+        if str(particle["role"]) == "initial"
+    }
+    for raw_slot in cast(Sequence[Mapping[str, object]], schema["momentum_slots"]):
+        total = [_ZERO, _ZERO, _ZERO, _ZERO]
+        for raw_label in cast(Sequence[object], raw_slot["external_labels"]):
+            label = _json_integer(raw_label)
+            sign = -_ONE if label in incoming else _ONE
+            try:
+                momentum = point[label - 1]
+            except IndexError as exc:
+                raise ArtifactError(
+                    "momentum slot references an absent external leg"
+                ) from exc
+            for component in range(4):
+                total[component] += sign * momentum[component]
+        start = value_count + _json_integer(raw_slot["component_start"])
+        for component, value in enumerate(total):
+            state[start + component] = (value, _ZERO)
+
+
+def _fill_sources(
+    state: list[_ComplexDecimal],
+    point: Sequence[tuple[Decimal, Decimal, Decimal, Decimal]],
+    schema: Mapping[str, object],
+    model_parameters: Sequence[Decimal],
+) -> None:
+    source_fill = cast(Mapping[str, object], schema["source_fill"])
+    for raw_source in cast(Sequence[Mapping[str, object]], source_fill["sources"]):
+        wave = _source_wavefunction(raw_source, point, schema, model_parameters)
+        slot = cast(Mapping[str, object], raw_source["value_slot"])
+        start = _json_integer(slot["component_start"])
+        stop = _json_integer(slot["component_stop"])
+        if stop - start != len(wave):
+            raise ArtifactError("source wavefunction does not match its value slot")
+        state[start:stop] = wave
+
+
+def _fill_sources_with_states(
+    state: list[_ComplexDecimal],
+    point: Sequence[tuple[Decimal, Decimal, Decimal, Decimal]],
+    schema: Mapping[str, object],
+    model_parameters: Sequence[Decimal],
+    source_states: Sequence[_ExactRuntimeSourceState | None],
+) -> None:
+    source_fill = cast(Mapping[str, object], schema["source_fill"])
+    raw_sources = cast(Sequence[Mapping[str, object]], source_fill["sources"])
+    if len(source_states) != len(raw_sources):
+        raise ArtifactError(
+            "helicity recurrence source-state count does not match runtime sources"
+        )
+    for raw_source, runtime_state in zip(raw_sources, source_states, strict=True):
+        slot = cast(Mapping[str, object], raw_source["value_slot"])
+        start = _json_integer(slot["component_start"])
+        stop = _json_integer(slot["component_stop"])
+        if not 0 <= start <= stop <= len(state):
+            raise ArtifactError("source value slot is out of range")
+        if runtime_state is None:
+            state[start:stop] = [_complex_zero() for _ in range(stop - start)]
+            continue
+        source = dict(raw_source)
+        source["source_helicity"] = runtime_state.helicity
+        source["chirality"] = runtime_state.chirality
+        source["spin_state"] = runtime_state.spin_state
+        wave = tuple(
+            _complex_mul(component, runtime_state.factor)
+            for component in _source_wavefunction(
+                source, point, schema, model_parameters
+            )
+        )
+        if stop - start != len(wave):
+            raise ArtifactError("source wavefunction does not match its value slot")
+        state[start:stop] = wave
+
+
+def _source_wavefunction(
+    source: Mapping[str, object],
+    point: Sequence[tuple[Decimal, Decimal, Decimal, Decimal]],
+    schema: Mapping[str, object],
+    model_parameters: Sequence[Decimal],
+    *,
+    scalar: type[Decimal] | None = None,
+) -> tuple[_ComplexDecimal, ...]:
+    scalar = Decimal if scalar is None else scalar
+    leg_label = _json_integer(source["leg_label"])
+    try:
+        momentum = point[leg_label - 1]
+    except IndexError as exc:
+        raise ArtifactError("source references an absent external leg") from exc
+    source_ir, identity, crossing = _validated_source_ir(source)
+    if crossing["momentum_transform"] == "negate-four-momentum":
+        momentum = cast(
+            tuple[Decimal, Decimal, Decimal, Decimal],
+            tuple(-component for component in momentum),
+        )
+    dimension = _json_integer(source_ir["component_dimension"])
+    particle_id = _json_integer(identity["pdg_label"])
+    anti_particle_id = _json_integer(identity["anti_pdg_label"])
+    helicity = _json_integer(source["source_helicity"])
+    chirality = _json_integer(source["chirality"])
+    kind = str(source_ir["wavefunction_family"])
+    orientation = str(identity["orientation"])
+    wave: tuple[_ComplexDecimal, ...]
+    if dimension == 1 and kind == "scalar":
+        wave = ((scalar(1), scalar(0)),)
+    elif kind == "fermion" and orientation == "self-conjugate":
+        raise CompatibilityError(
+            "self-conjugate fermion source wavefunctions are unsupported"
+        )
+    elif dimension == 2 and kind == "fermion":
+        wave = (
+            _antiquark_weyl(momentum, helicity, chirality)
+            if orientation == "antiparticle"
+            else _quark_weyl(momentum, helicity, chirality)
+        )
+    elif dimension == 4 and kind == "fermion":
+        mass = _particle_mass(
+            schema,
+            particle_id,
+            anti_particle_id,
+            model_parameters,
+        )
+        wave = (
+            _antiquark_dirac(momentum, helicity, mass)
+            if orientation == "antiparticle"
+            else _quark_dirac(momentum, helicity, mass)
+        )
+    elif dimension == 4 and kind == "vector":
+        mass = _particle_mass(
+            schema,
+            particle_id,
+            anti_particle_id,
+            model_parameters,
+        )
+        wave = (
+            _massless_vector(momentum, helicity, scalar=scalar)
+            if mass == 0
+            else _massive_vector(momentum, helicity, mass, scalar=scalar)
+        )
+    elif dimension == 16 and kind == "spin2":
+        mass = _particle_mass(
+            schema,
+            particle_id,
+            anti_particle_id,
+            model_parameters,
+        )
+        wave = _spin2(momentum, helicity, mass, scalar=scalar)
+    else:
+        raise CompatibilityError(
+            f"high-precision source kind {kind!r} with dimension {dimension} "
+            "is unsupported"
+        )
+    phase = cast(
+        _ComplexDecimal, tuple(scalar(value) for value in _crossing_phase(crossing))
+    )
+    return tuple(_complex_mul(component, phase) for component in wave)
+
+
+def _validated_source_ir(
+    source: Mapping[str, object],
+) -> tuple[
+    Mapping[str, object],
+    Mapping[str, object],
+    Mapping[str, object],
+]:
+    try:
+        source_ir = cast(Mapping[str, object], source["source_ir"])
+        identity = cast(Mapping[str, object], source_ir["identity"])
+        declared_crossing = cast(Mapping[str, object], source_ir["crossing"])
+        applied_crossing = cast(Mapping[str, object], source["applied_crossing"])
+    except (KeyError, TypeError) as exc:
+        raise ArtifactError(
+            "source is missing typed SourceIR/CrossingIR metadata"
+        ) from exc
+
+    particle_id = _json_integer(identity["pdg_label"])
+    anti_particle_id = _json_integer(identity["anti_pdg_label"])
+    orientation = str(identity["orientation"])
+    if orientation not in {"particle", "antiparticle", "self-conjugate"}:
+        raise ArtifactError(f"source has invalid orientation {orientation!r}")
+    if anti_particle_id == 0 or (
+        (orientation == "self-conjugate") != (particle_id == anti_particle_id)
+    ):
+        raise ArtifactError(
+            "source orientation is inconsistent with its antiparticle relation"
+        )
+
+    side = str(source["side"])
+    expected_crossing = (
+        declared_crossing
+        if side == "initial"
+        else {
+            "momentum_transform": "identity",
+            "helicity_factor": 1,
+            "chirality_factor": 1,
+            "spin_state_factor": 1,
+            "phase": [1.0, 0.0],
+        }
+    )
+    if dict(applied_crossing) != dict(expected_crossing):
+        raise ArtifactError(
+            "source applied crossing is inconsistent with its side and SourceIR"
+        )
+    transform = str(applied_crossing["momentum_transform"])
+    if transform not in {"identity", "negate-four-momentum"}:
+        raise ArtifactError(f"source has unsupported momentum transform {transform!r}")
+    _crossing_phase(applied_crossing)
+
+    dimension = _json_integer(source_ir["component_dimension"])
+    family = str(source_ir["wavefunction_family"])
+    basis = str(source_ir["basis"])
+    flattened = {
+        "particle_id": particle_id,
+        "anti_particle_id": anti_particle_id,
+        "source_orientation": orientation,
+        "wavefunction_kind": family,
+        "dimension": dimension,
+        "source_basis": basis,
+        "crossing": (
+            "negate-incoming-momentum"
+            if transform == "negate-four-momentum"
+            else "identity"
+        ),
+    }
+    for key, expected in flattened.items():
+        actual = source.get(key)
+        if actual != expected:
+            raise ArtifactError(
+                f"source flattened field {key!r} disagrees with typed metadata"
+            )
+
+    state = (
+        _json_integer(source["source_helicity"]),
+        _json_integer(source["chirality"]),
+        _hashable_spin_state(source["spin_state"]),
+    )
+    transformed_states = {
+        _apply_source_crossing_state(
+            declared,
+            applied_crossing,
+        )
+        for declared in cast(Sequence[Mapping[str, object]], source_ir["states"])
+    }
+    if state not in transformed_states:
+        raise ArtifactError("source state is not declared by its typed SourceIR")
+    return source_ir, identity, applied_crossing
+
+
+def _apply_source_crossing_state(
+    state: Mapping[str, object],
+    crossing: Mapping[str, object],
+) -> tuple[int, int, object]:
+    spin_state = state["spin_state"]
+    spin_factor = _json_integer(crossing["spin_state_factor"])
+    if spin_factor != 1:
+        if isinstance(spin_state, bool) or not isinstance(spin_state, int):
+            raise ArtifactError(
+                "crossing cannot multiply a structured source spin state"
+            )
+        spin_state *= spin_factor
+    return (
+        _json_integer(state["helicity"]) * _json_integer(crossing["helicity_factor"]),
+        _json_integer(state["chirality"]) * _json_integer(crossing["chirality_factor"]),
+        _hashable_spin_state(spin_state),
+    )
+
+
+def _crossing_phase(crossing: Mapping[str, object]) -> _ComplexDecimal:
+    raw_phase = crossing.get("phase")
+    if not isinstance(raw_phase, Sequence) or isinstance(raw_phase, (str, bytes)):
+        raise ArtifactError("source crossing phase must be a complex pair")
+    if len(raw_phase) != 2:
+        raise ArtifactError("source crossing phase must be a complex pair")
+    try:
+        phase = (Decimal(str(raw_phase[0])), Decimal(str(raw_phase[1])))
+    except (InvalidOperation, TypeError, ValueError) as exc:
+        raise ArtifactError(
+            "source crossing phase must be a finite complex pair"
+        ) from exc
+    if not phase[0].is_finite() or not phase[1].is_finite():
+        raise ArtifactError("source crossing phase must be a finite complex pair")
+    if phase == (_ZERO, _ZERO):
+        raise ArtifactError("source crossing phase must be nonzero")
+    return phase
+
+
+def _hashable_spin_state(value: object) -> object:
+    if isinstance(value, list):
+        return tuple(_hashable_spin_state(item) for item in value)
+    return value
+
+
+def _particle_mass(
+    schema: Mapping[str, object],
+    particle_id: int,
+    anti_particle_id: int,
+    parameters: Sequence[Decimal],
+) -> Decimal:
+    model = cast(Mapping[str, object], schema["model"])
+    particles = cast(Sequence[Mapping[str, object]], model["particles"])
+    record = next(
+        (item for item in particles if _json_integer(item["pdg"]) == particle_id),
+        None,
+    )
+    if record is None:
+        record = next(
+            (
+                item
+                for item in particles
+                if _json_integer(item["pdg"]) == anti_particle_id
+            ),
+            None,
+        )
+    if record is None:
+        return _ZERO
+    parameter_name = record.get("mass_parameter")
+    if isinstance(parameter_name, str):
+        for raw_parameter in cast(
+            Sequence[Mapping[str, object]], schema["model_parameters"]
+        ):
+            if raw_parameter["name"] == parameter_name:
+                try:
+                    return parameters[_json_integer(raw_parameter["parameter_index"])]
+                except IndexError as exc:
+                    raise ArtifactError(
+                        "particle mass parameter index is invalid"
+                    ) from exc
+    return _decimal(record.get("mass", 0), "particle mass")
+
+
+def _quark_weyl(
+    momentum: Sequence[Decimal], helicity: int, chirality: int
+) -> tuple[_ComplexDecimal, _ComplexDecimal]:
+    energy, px, py, pz = momentum
+    if energy > 0:
+        sq = (
+            _ZERO
+            if px == 0 and py == 0 and pz < 0
+            else _sqrt(energy + pz, "Weyl source")
+        )
+        chi1 = (sq, _ZERO)
+        chi2 = (
+            (-Decimal(helicity) * _sqrt(_TWO * energy, "Weyl source"), _ZERO)
+            if sq == 0
+            else (Decimal(helicity) * px / sq, -py / sq)
+        )
+        if helicity == 1 and chirality == 1:
+            return chi1, chi2
+        if helicity == -1 and chirality == -1:
+            return chi2, chi1
+        return _complex_zero(), _complex_zero()
+    sq = (
+        _ZERO
+        if px == 0 and py == 0 and pz > 0
+        else -_sqrt(-(energy + pz), "Weyl source")
+    )
+    chi1 = (sq, _ZERO)
+    chi2 = (
+        (-Decimal(helicity) * _sqrt(_TWO * abs(energy), "Weyl source"), _ZERO)
+        if sq == 0
+        else (Decimal(helicity) * px / sq, py / sq)
+    )
+    if helicity == -1 and chirality == 1:
+        return chi1, chi2
+    if helicity == 1 and chirality == -1:
+        return chi2, chi1
+    return _complex_zero(), _complex_zero()
+
+
+def _antiquark_weyl(
+    momentum: Sequence[Decimal], helicity: int, chirality: int
+) -> tuple[_ComplexDecimal, _ComplexDecimal]:
+    energy, px, py, pz = momentum
+    if energy > 0:
+        sq = (
+            _ZERO
+            if px == 0 and py == 0 and pz < 0
+            else -_sqrt(energy + pz, "Weyl source")
+        )
+        chi1 = (sq, _ZERO)
+        chi2 = (
+            (-Decimal(helicity) * _sqrt(_TWO * energy, "Weyl source"), _ZERO)
+            if sq == 0
+            else (-Decimal(helicity) * px / sq, py / sq)
+        )
+        if helicity == 1 and chirality == 1:
+            return chi2, chi1
+        if helicity == -1 and chirality == -1:
+            return chi1, chi2
+        return _complex_zero(), _complex_zero()
+    sq = (
+        _ZERO
+        if px == 0 and py == 0 and pz > 0
+        else _sqrt(-(energy + pz), "Weyl source")
+    )
+    chi1 = (sq, _ZERO)
+    chi2 = (
+        (-Decimal(helicity) * _sqrt(_TWO * abs(energy), "Weyl source"), _ZERO)
+        if sq == 0
+        else (-Decimal(helicity) * px / sq, -py / sq)
+    )
+    if helicity == -1 and chirality == 1:
+        return chi2, chi1
+    if helicity == 1 and chirality == -1:
+        return chi1, chi2
+    return _complex_zero(), _complex_zero()
+
+
+def _massless_quark_dirac(
+    momentum: Sequence[Decimal], helicity: int
+) -> tuple[_ComplexDecimal, ...]:
+    left, right = _quark_weyl(momentum, helicity, helicity)
+    return (
+        (left, right, _complex_zero(), _complex_zero())
+        if helicity == 1
+        else (_complex_zero(), _complex_zero(), left, right)
+    )
+
+
+def _massless_antiquark_dirac(
+    momentum: Sequence[Decimal], helicity: int
+) -> tuple[_ComplexDecimal, ...]:
+    first, second = _antiquark_weyl(momentum, helicity, helicity)
+    return (
+        (_complex_zero(), _complex_zero(), first, second)
+        if -helicity == 1
+        else (first, second, _complex_zero(), _complex_zero())
+    )
+
+
+def _quark_dirac(
+    momentum: Sequence[Decimal], helicity: int, mass: Decimal
+) -> tuple[_ComplexDecimal, ...]:
+    if mass == 0:
+        return _massless_quark_dirac(momentum, helicity)
+    return _massive_dirac(momentum, helicity, mass, antiquark=False)
+
+
+def _antiquark_dirac(
+    momentum: Sequence[Decimal], helicity: int, mass: Decimal
+) -> tuple[_ComplexDecimal, ...]:
+    if mass == 0:
+        return _massless_antiquark_dirac(momentum, helicity)
+    return _massive_dirac(momentum, helicity, mass, antiquark=True)
+
+
+def _massive_dirac(
+    momentum: Sequence[Decimal], helicity: int, mass: Decimal, *, antiquark: bool
+) -> tuple[_ComplexDecimal, ...]:
+    energy, px, py, pz = momentum
+    nsf = (-1 if energy > 0 else 1) if antiquark else (1 if energy > 0 else -1)
+    nh = nsf * helicity
+    pp = _sqrt(px * px + py * py + pz * pz, "massive fermion source")
+    omega1 = _sqrt(abs(energy) + pp, "massive fermion source")
+    if omega1 == 0:
+        raise EvaluationError("massive fermion source has zero normalization")
+    omega = (omega1, mass / omega1)
+    half = _ONE / _TWO
+    sf1 = Decimal(1 + nsf + (1 - nsf) * nh) * half
+    sf2 = Decimal(1 + nsf - (1 - nsf) * nh) * half
+    ip = (3 + nh) // 2 - 1
+    im = (3 - nh) // 2 - 1
+    sfomeg = (sf1 * omega[ip], sf2 * omega[im])
+    signed_px, signed_py, signed_pz = (px, py, pz) if energy > 0 else (-px, -py, -pz)
+    pp3 = max(pp + signed_pz, _ZERO)
+    chi1 = _ONE if pp == 0 else _sqrt(pp3 / (_TWO * pp), "massive fermion source")
+    if pp3 == 0 or pp == 0:
+        chi2 = (-Decimal(nh), _ZERO)
+    else:
+        denominator = _sqrt(_TWO * pp * pp3, "massive fermion source")
+        chi2 = (
+            Decimal(nh) * signed_px / denominator,
+            (signed_py if antiquark else -signed_py) / denominator,
+        )
+    chi = ((chi1, _ZERO), chi2)
+    if antiquark:
+        return (
+            (chi[im][0] * sfomeg[0], chi[im][1] * sfomeg[0]),
+            (chi[ip][0] * sfomeg[0], chi[ip][1] * sfomeg[0]),
+            (chi[im][0] * sfomeg[1], chi[im][1] * sfomeg[1]),
+            (chi[ip][0] * sfomeg[1], chi[ip][1] * sfomeg[1]),
+        )
+    return (
+        (chi[im][0] * sfomeg[1], chi[im][1] * sfomeg[1]),
+        (chi[ip][0] * sfomeg[1], chi[ip][1] * sfomeg[1]),
+        (chi[im][0] * sfomeg[0], chi[im][1] * sfomeg[0]),
+        (chi[ip][0] * sfomeg[0], chi[ip][1] * sfomeg[0]),
+    )
+
+
+def _massless_vector(
+    momentum: Sequence[Decimal], helicity: int, *, scalar: type[Decimal] | None = None
+) -> tuple[_ComplexDecimal, ...]:
+    scalar = Decimal if scalar is None else scalar
+    energy, px, py, pz = momentum
+    if energy == 0:
+        raise EvaluationError("cannot build a massless vector with zero energy")
+    sqh = _sqrt(scalar(1) / scalar(2), "vector source")
+    if energy > 0:
+        hel = Decimal(helicity)
+        pp = energy
+        pt = _sqrt(px * px + py * py, "vector source")
+        wf3 = (hel * pt / pp * sqh, _ZERO)
+        if pt != 0:
+            pzpt = pz / (pp * pt) * sqh * hel
+            wf1 = (-px * pzpt, -py / pt * sqh)
+            wf2 = (-py * pzpt, px / pt * sqh)
+        else:
+            wf1 = (-hel * sqh, _ZERO)
+            wf2 = (_ZERO, _fortran_sign(sqh, pz))
+        return _complex_zero(), wf1, wf2, wf3
+    hel = Decimal(-helicity)
+    pp = -energy
+    pt = _sqrt(px * px + py * py, "vector source")
+    wf3 = (hel * pt / pp * sqh, _ZERO)
+    if pt != 0:
+        pzpt = -pz / (pp * pt) * sqh * hel
+        wf1 = (px * pzpt, py / pt * sqh)
+        wf2 = (py * pzpt, -px / pt * sqh)
+    else:
+        wf1 = (-hel * sqh, _ZERO)
+        wf2 = (_ZERO, -_fortran_sign(sqh, pz))
+    return _complex_zero(), wf1, wf2, wf3
+
+
+def _massive_vector(
+    momentum: Sequence[Decimal],
+    helicity: int,
+    mass: Decimal,
+    *,
+    scalar: type[Decimal] | None = None,
+) -> tuple[_ComplexDecimal, ...]:
+    scalar = Decimal if scalar is None else scalar
+    energy, px, py, pz = momentum
+    if mass == 0:
+        raise EvaluationError("massive-vector source has zero mass")
+    if energy < 0:
+        return _massive_vector(
+            tuple(-component for component in momentum),
+            -helicity,
+            mass,
+            scalar=scalar,
+        )
+    sqh = _sqrt(scalar(1) / scalar(2), "massive vector source")
+    hel = Decimal(helicity)
+    nsvahl = Decimal(abs(helicity))
+    pt2 = px * px + py * py
+    pp = min(energy, _sqrt(pt2 + pz * pz, "massive vector source"))
+    pt = min(pp, _sqrt(pt2, "massive vector source"))
+    hel0 = _ONE - abs(hel)
+    if pp == 0:
+        return (
+            _complex_zero(),
+            (-hel * sqh, _ZERO),
+            (_ZERO, nsvahl * sqh),
+            (hel0, _ZERO),
+        )
+    emp = energy / (mass * pp)
+    wf0 = (hel0 * pp / mass, _ZERO)
+    wf3 = (hel0 * pz * emp + hel * pt / pp * sqh, _ZERO)
+    if pt != 0:
+        pzpt = pz / (pp * pt) * sqh * hel
+        wf1 = (hel0 * px * emp - px * pzpt, -nsvahl * py / pt * sqh)
+        wf2 = (hel0 * py * emp - py * pzpt, nsvahl * px / pt * sqh)
+    else:
+        wf1 = (-hel * sqh, _ZERO)
+        wf2 = (_ZERO, nsvahl * _fortran_sign(sqh, pz))
+    return wf0, wf1, wf2, wf3
+
+
+def _spin2(
+    momentum: Sequence[Decimal],
+    helicity: int,
+    mass: Decimal,
+    *,
+    scalar: type[Decimal] | None = None,
+) -> tuple[_ComplexDecimal, ...]:
+    scalar = Decimal if scalar is None else scalar
+    if mass == 0:
+        if helicity not in {-2, 2}:
+            raise EvaluationError("massless spin-2 source supports helicity +/-2")
+        vector = _massless_vector(momentum, helicity // 2, scalar=scalar)
+        return _spin2_outer(vector, vector)
+    plus = _massive_vector(momentum, 1, mass, scalar=scalar)
+    minus = _massive_vector(momentum, -1, mass, scalar=scalar)
+    longitudinal = _massive_vector(momentum, 0, mass, scalar=scalar)
+    if helicity == 2:
+        return _spin2_outer(plus, plus)
+    if helicity == -2:
+        return _spin2_outer(minus, minus)
+    if helicity == 1:
+        return _spin2_sum(
+            (
+                _spin2_outer(plus, longitudinal),
+                scalar(1) / _sqrt(scalar(2), "spin-2 source"),
+            ),
+            (
+                _spin2_outer(longitudinal, plus),
+                scalar(1) / _sqrt(scalar(2), "spin-2 source"),
+            ),
+        )
+    if helicity == -1:
+        return _spin2_sum(
+            (
+                _spin2_outer(minus, longitudinal),
+                scalar(1) / _sqrt(scalar(2), "spin-2 source"),
+            ),
+            (
+                _spin2_outer(longitudinal, minus),
+                scalar(1) / _sqrt(scalar(2), "spin-2 source"),
+            ),
+        )
+    if helicity != 0:
+        raise EvaluationError(f"unsupported massive spin-2 helicity {helicity}")
+    sqrt6 = _sqrt(scalar(6), "spin-2 source")
+    return _spin2_sum(
+        (_spin2_outer(plus, minus), _ONE / sqrt6),
+        (_spin2_outer(minus, plus), _ONE / sqrt6),
+        (_spin2_outer(longitudinal, longitudinal), _TWO / sqrt6),
+    )
+
+
+def _spin2_outer(
+    left: Sequence[_ComplexDecimal], right: Sequence[_ComplexDecimal]
+) -> tuple[_ComplexDecimal, ...]:
+    return tuple(
+        _complex_mul(left[mu], right[nu]) for mu in range(4) for nu in range(4)
+    )
+
+
+def _spin2_sum(
+    *terms: tuple[Sequence[_ComplexDecimal], Decimal],
+) -> tuple[_ComplexDecimal, ...]:
+    values = []
+    for index in range(16):
+        real = sum((weight * tensor[index][0] for tensor, weight in terms), _ZERO)
+        imaginary = sum((weight * tensor[index][1] for tensor, weight in terms), _ZERO)
+        values.append((real, imaginary))
+    return tuple(values)
+
+
+def _validated_color_contraction_entries(
+    contraction: Mapping[str, object],
+    groups: Mapping[int, object],
+) -> Iterator[_ExactColorContractionEntry]:
+    raw_entries = _mapping_sequence(contraction, "entries", "color contraction entries")
+    repeated_raw = contraction.get("repeated_block")
+    if repeated_raw is None:
+        for raw_entry in raw_entries:
+            yield _validated_color_contraction_entry(raw_entry, groups)
+        return
+    if raw_entries:
+        raise ArtifactError("color contraction mixes expanded and repeated entries")
+    if not isinstance(repeated_raw, Mapping):
+        raise ArtifactError("repeated color contraction is not an object")
+    component_count = _strict_nonnegative_integer(
+        repeated_raw.get("component_count"),
+        "repeated color contraction component count",
+    )
+    if component_count < 2:
+        raise ArtifactError(
+            "repeated color contraction requires at least two components"
+        )
+    raw_group_ids = _mapping_sequence(
+        repeated_raw,
+        "component_group_ids",
+        "repeated color contraction group IDs",
+    )
+    component_group_ids = tuple(_json_integer(value) for value in raw_group_ids)
+    if (
+        not component_group_ids
+        or len(component_group_ids) % component_count != 0
+        or len(set(component_group_ids)) != len(component_group_ids)
+        or set(component_group_ids) != set(groups)
+    ):
+        raise ArtifactError("repeated color contraction group map is invalid")
+    declared_group_count = contraction.get("group_count")
+    if declared_group_count is not None and _strict_nonnegative_integer(
+        declared_group_count, "color contraction group count"
+    ) != len(component_group_ids):
+        raise ArtifactError(
+            "repeated color contraction group map does not match group count"
+        )
+    local_group_count = len(component_group_ids) // component_count
+    raw_templates = _mapping_sequence(
+        repeated_raw,
+        "entries",
+        "repeated color contraction entries",
+    )
+    templates: list[tuple[int, int, _ComplexDecimal, Decimal]] = []
+    for raw_template in raw_templates:
+        if not isinstance(raw_template, Mapping):
+            raise ArtifactError("repeated color contraction entry is not an object")
+        left_group_index = _strict_nonnegative_integer(
+            raw_template.get("left_group_index"),
+            "repeated color contraction left group index",
+        )
+        right_group_index = _strict_nonnegative_integer(
+            raw_template.get("right_group_index"),
+            "repeated color contraction right group index",
+        )
+        if (
+            left_group_index >= local_group_count
+            or right_group_index >= local_group_count
+        ):
+            raise ArtifactError(
+                "repeated color contraction entry references an unknown local group"
+            )
+        templates.append(
+            (
+                left_group_index,
+                right_group_index,
+                exact_color_weight(raw_template)
+                or _complex_decimal_pair(
+                    raw_template.get("weight"),
+                    "color contraction weight",
+                ),
+                _decimal(
+                    raw_template.get("symmetry_factor", 1),
+                    "color symmetry factor",
+                ),
+            )
+        )
+    logical_entry_count = contraction.get("logical_entry_count")
+    if logical_entry_count is not None and _strict_nonnegative_integer(
+        logical_entry_count, "color contraction logical entry count"
+    ) != component_count * len(templates):
+        raise ArtifactError("color contraction logical entry count is inconsistent")
+    for component_index in range(component_count):
+        for (
+            left_group_index,
+            right_group_index,
+            weight,
+            symmetry_factor,
+        ) in templates:
+            yield _ExactColorContractionEntry(
+                left_group_id=component_group_ids[
+                    left_group_index * component_count + component_index
+                ],
+                right_group_id=component_group_ids[
+                    right_group_index * component_count + component_index
+                ],
+                weight=weight,
+                symmetry_factor=symmetry_factor,
+            )
+
+
+def _validated_color_contraction_entry(
+    raw_entry: object,
+    groups: Mapping[int, object],
+) -> _ExactColorContractionEntry:
+    if not isinstance(raw_entry, Mapping):
+        raise ArtifactError("color contraction entry is not an object")
+    left_group_id = _json_integer(raw_entry.get("left_group_id"))
+    right_group_id = _json_integer(raw_entry.get("right_group_id"))
+    if left_group_id not in groups or right_group_id not in groups:
+        raise ArtifactError("color contraction references an unknown coherent group")
+    return _ExactColorContractionEntry(
+        left_group_id=left_group_id,
+        right_group_id=right_group_id,
+        weight=exact_color_weight(raw_entry)
+        or _complex_decimal_pair(raw_entry.get("weight"), "color contraction weight"),
+        symmetry_factor=_decimal(
+            raw_entry.get("symmetry_factor", 1), "color symmetry factor"
+        ),
+    )
+
+
+def _reduce_materialized_helicity(
+    amplitudes: Sequence[_ComplexDecimal],
+    execution: Mapping[str, object],
+    physics: Mapping[str, object],
+    normalization: Decimal,
+    helicity_index: int,
+    root_factors: Sequence[_ComplexDecimal | None],
+) -> tuple[Decimal, ...]:
+    helicities = cast(Sequence[Mapping[str, object]], physics["helicities"])
+    colors = cast(Sequence[Mapping[str, object]], physics["color_components"])
+    try:
+        helicity_id = str(helicities[helicity_index]["id"])
+    except IndexError as exc:
+        raise ArtifactError(
+            "helicity recurrence selected an absent physical helicity"
+        ) from exc
+    runtime_schema = execution.get("runtime_schema")
+    if not isinstance(runtime_schema, Mapping):
+        raise ArtifactError("execution metadata has no runtime schema")
+    amplitude_stage = runtime_schema.get("amplitude_stage")
+    if not isinstance(amplitude_stage, Mapping):
+        raise ArtifactError("runtime schema has no amplitude stage")
+    raw_roots = amplitude_stage.get("roots")
+    if isinstance(raw_roots, str | bytes) or not isinstance(raw_roots, Sequence):
+        raise ArtifactError("amplitude roots are invalid")
+    roots = cast(Sequence[Mapping[str, object]], raw_roots)
+    if len(amplitudes) != len(roots) or len(root_factors) != len(roots):
+        raise ArtifactError(
+            "helicity recurrence amplitude output width is inconsistent"
+        )
+
+    groups: dict[int, list[int]] = {}
+    all_sector_weights: dict[int, Decimal] = {}
+    for index, root in enumerate(roots):
+        output_index = _strict_nonnegative_integer(
+            root.get("output_index"), "amplitude root output index"
+        )
+        if output_index != index:
+            raise ArtifactError("amplitude root outputs are not contiguous")
+        group_id = _json_integer(root.get("coherent_group_id"))
+        groups.setdefault(group_id, []).append(output_index)
+        weight = _decimal(
+            root.get("all_sector_weight", root.get("helicity_weight")),
+            "all-sector weight",
+        )
+        previous = all_sector_weights.setdefault(group_id, weight)
+        if previous != weight:
+            raise ArtifactError("coherent amplitude group has inconsistent weights")
+
+    reduction_metadata = physics.get("reduction")
+    if not isinstance(reduction_metadata, Mapping):
+        raise ArtifactError("resolved physics has no reduction metadata")
+    raw_reductions = reduction_metadata.get("groups")
+    if isinstance(raw_reductions, str | bytes) or not isinstance(
+        raw_reductions, Sequence
+    ):
+        raise ArtifactError("resolved physics reduction groups are invalid")
+    reductions: dict[int, Mapping[str, object]] = {}
+    for raw_reduction in raw_reductions:
+        if not isinstance(raw_reduction, Mapping):
+            raise ArtifactError("resolved physics reduction group is invalid")
+        identifier = str(raw_reduction.get("id", ""))
+        if not identifier.startswith("reduction:"):
+            raise ArtifactError("resolved reduction group has an invalid ID")
+        try:
+            group_id = int(identifier.removeprefix("reduction:"))
+        except ValueError as exc:
+            raise ArtifactError("resolved reduction group has an invalid ID") from exc
+        if group_id in reductions:
+            raise ArtifactError("resolved physics repeats a reduction group")
+        reductions[group_id] = raw_reduction
+    if set(groups) - set(reductions):
+        raise ArtifactError("resolved physics is missing an amplitude reduction group")
+
+    coherent: dict[int, _ComplexDecimal] = {}
+    active_groups: set[int] = set()
+    for group_id, indices in groups.items():
+        reduction = reductions[group_id]
+        members = tuple(
+            str(value)
+            for value in _mapping_sequence(
+                reduction,
+                "physical_helicity_ids",
+                "reduction physical helicities",
+            )
+        )
+        if helicity_id not in members:
+            continue
+        values = [
+            _complex_mul(amplitudes[index], factor)
+            for index in indices
+            if (factor := root_factors[index]) is not None
+        ]
+        if not values:
+            continue
+        coherent[group_id] = (
+            sum((value[0] for value in values), _ZERO),
+            sum((value[1] for value in values), _ZERO),
+        )
+        active_groups.add(group_id)
+
+    contraction = amplitude_stage.get("color_contraction")
+    if isinstance(contraction, Mapping):
+        if (
+            len(colors) != 1
+            or str(physics.get("color_accuracy")) == "lc"
+            or colors[0].get("kind") == "lc-flow"
+        ):
+            raise ArtifactError("contracted color reduction requires one color axis")
+        total = _ZERO
+        for entry in _validated_color_contraction_entries(contraction, groups):
+            left_id = entry.left_group_id
+            right_id = entry.right_group_id
+            if left_id not in active_groups or right_id not in active_groups:
+                continue
+            left = coherent[left_id]
+            right = coherent[right_id]
+            product_re = left[0] * right[0] + left[1] * right[1]
+            product_im = left[1] * right[0] - left[0] * right[1]
+            total += (
+                normalization
+                * entry.symmetry_factor
+                * (entry.weight[0] * product_re - entry.weight[1] * product_im)
+            )
+        return (total,)
+    if contraction is not None:
+        raise ArtifactError("color contraction metadata is not an object")
+
+    color_index = {str(color["id"]): index for index, color in enumerate(colors)}
+    if len(color_index) != len(colors):
+        raise ArtifactError("resolved physics contains duplicate color IDs")
+    full = [_ZERO for _ in colors]
+    for group_id in active_groups:
+        value = coherent[group_id]
+        reduction = reductions[group_id]
+        member_ids = tuple(
+            str(value)
+            for value in _mapping_sequence(
+                reduction, "physical_color_ids", "reduction physical colors"
+            )
+        )
+        member_weights: list[tuple[int, Decimal]] = []
+        for identifier in member_ids:
+            color_slot = color_index.get(identifier)
+            if color_slot is None:
+                raise ArtifactError(
+                    f"reduction references unknown color component {identifier!r}"
+                )
+            weight = _decimal(
+                colors[color_slot].get("coefficient", 1), "color coefficient"
+            )
+            if weight <= 0:
+                raise ArtifactError("reduction color coefficient must be positive")
+            member_weights.append((color_slot, weight))
+        total_weight = sum((weight for _index, weight in member_weights), _ZERO)
+        if total_weight <= 0:
+            raise ArtifactError("reduction group has no positive color weight")
+        contribution = (
+            normalization
+            * all_sector_weights[group_id]
+            * (value[0] * value[0] + value[1] * value[1])
+        )
+        for index, weight in member_weights:
+            full[index] += contribution * weight / total_weight
+    return tuple(full)
+
+
+def _mapping_sequence(
+    mapping: Mapping[str, object], key: str, context: str
+) -> Sequence[object]:
+    value = mapping.get(key)
+    if isinstance(value, str | bytes) or not isinstance(value, Sequence):
+        raise ArtifactError(f"{context} are invalid")
+    return value
+
+
+def _reduce_resolved(
+    amplitudes: Sequence[Sequence[_ComplexDecimal]],
+    execution: Mapping[str, object],
+    physics: Mapping[str, object],
+    normalization: Decimal,
+    selected_helicities: Sequence[str] | None,
+    selected_colors: Sequence[str] | None,
+) -> tuple[
+    tuple[tuple[tuple[Decimal, ...], ...], ...],
+    tuple[str, ...],
+    tuple[str, ...],
+]:
+    helicities = cast(Sequence[Mapping[str, object]], physics["helicities"])
+    colors = cast(Sequence[Mapping[str, object]], physics["color_components"])
+    helicity_ids = tuple(str(item["id"]) for item in helicities)
+    color_ids = tuple(str(item["id"]) for item in colors)
+    selected_h = _selected_indices(helicity_ids, selected_helicities, "helicity")
+    selected_c = _selected_indices(color_ids, selected_colors, "color component")
+    accuracy = str(physics["color_accuracy"])
+    if accuracy != "lc" and selected_colors is not None:
+        raise EvaluationError(
+            "LC color-flow selection is unavailable for NLC/full artifacts"
+        )
+
+    amplitude_stage = cast(
+        Mapping[str, object],
+        cast(Mapping[str, object], execution["runtime_schema"])["amplitude_stage"],
+    )
+    roots = cast(Sequence[Mapping[str, object]], amplitude_stage["roots"])
+    groups: dict[int, list[int]] = {}
+    all_sector_weights: dict[int, Decimal] = {}
+    for root in roots:
+        group_id = _json_integer(root["coherent_group_id"])
+        groups.setdefault(group_id, []).append(_json_integer(root["output_index"]))
+        weight = root.get("all_sector_weight", root["helicity_weight"])
+        all_sector_weights[group_id] = _decimal(weight, "all-sector weight")
+
+    reductions = {
+        int(str(group["id"]).removeprefix("reduction:")): group
+        for group in cast(
+            Sequence[Mapping[str, object]],
+            cast(Mapping[str, object], physics["reduction"])["groups"],
+        )
+    }
+    helicity_index = {
+        identifier: index for index, identifier in enumerate(helicity_ids)
+    }
+    color_index = {identifier: index for index, identifier in enumerate(color_ids)}
+    full_points = []
+    contraction = amplitude_stage.get("color_contraction")
+    for raw_amplitudes in amplitudes:
+        coherent = {
+            group_id: (
+                sum((raw_amplitudes[index][0] for index in indices), _ZERO),
+                sum((raw_amplitudes[index][1] for index in indices), _ZERO),
+            )
+            for group_id, indices in groups.items()
+        }
+        full = [[_ZERO for _ in color_ids] for _ in helicity_ids]
+        if isinstance(contraction, Mapping):
+            if len(color_ids) != 1:
+                raise ArtifactError(
+                    "contracted color reduction requires one color axis"
+                )
+            for entry in _validated_color_contraction_entries(contraction, groups):
+                left_id = entry.left_group_id
+                right_id = entry.right_group_id
+                left = coherent[left_id]
+                right = coherent[right_id]
+                product_re = left[0] * right[0] + left[1] * right[1]
+                product_im = left[1] * right[0] - left[0] * right[1]
+                contribution = (
+                    normalization
+                    * entry.symmetry_factor
+                    * (entry.weight[0] * product_re - entry.weight[1] * product_im)
+                )
+                reduction = reductions[left_id]
+                if (
+                    reduction["physical_helicity_ids"]
+                    != reductions[right_id]["physical_helicity_ids"]
+                ):
+                    raise ArtifactError("color contraction mixes physical helicities")
+                contracted_members = tuple(
+                    str(value)
+                    for value in cast(
+                        Sequence[object], reduction["physical_helicity_ids"]
+                    )
+                )
+                member_weights = [
+                    _decimal(
+                        helicities[helicity_index[item]]["coefficient"],
+                        "helicity coefficient",
+                    )
+                    for item in contracted_members
+                ]
+                total_weight = sum(member_weights, _ZERO)
+                if total_weight <= 0:
+                    raise ArtifactError(
+                        "reduction group has no positive helicity weight"
+                    )
+                for identifier, member_weight in zip(
+                    contracted_members, member_weights, strict=True
+                ):
+                    full[helicity_index[identifier]][0] += (
+                        contribution * member_weight / total_weight
+                    )
+        else:
+            for group_id, value in coherent.items():
+                reduction = reductions[group_id]
+                contribution = (
+                    normalization
+                    * all_sector_weights[group_id]
+                    * (value[0] * value[0] + value[1] * value[1])
+                )
+                diagonal_members: list[tuple[int, int, Decimal]] = []
+                total_weight = _ZERO
+                for helicity_id in cast(
+                    Sequence[object], reduction["physical_helicity_ids"]
+                ):
+                    h_id = str(helicity_id)
+                    h_weight = _decimal(
+                        helicities[helicity_index[h_id]]["coefficient"],
+                        "helicity coefficient",
+                    )
+                    for color_id in cast(
+                        Sequence[object], reduction["physical_color_ids"]
+                    ):
+                        c_id = str(color_id)
+                        color_record = colors[color_index[c_id]]
+                        c_weight = _decimal(
+                            color_record.get("coefficient", 1), "color coefficient"
+                        )
+                        weight = h_weight * c_weight
+                        diagonal_members.append(
+                            (helicity_index[h_id], color_index[c_id], weight)
+                        )
+                        total_weight += weight
+                if total_weight <= 0:
+                    raise ArtifactError("reduction group has no positive member weight")
+                for h_index, c_index, weight in diagonal_members:
+                    full[h_index][c_index] += contribution * weight / total_weight
+        full_points.append(
+            tuple(tuple(full[h][c] for c in selected_c) for h in selected_h)
+        )
+    return (
+        tuple(full_points),
+        tuple(helicity_ids[index] for index in selected_h),
+        tuple(color_ids[index] for index in selected_c),
+    )
+
+
+def _selected_indices(
+    available: Sequence[str], requested: Sequence[str] | None, kind: str
+) -> tuple[int, ...]:
+    if requested is None:
+        return tuple(range(len(available)))
+    if not requested:
+        raise EvaluationError(f"{kind} selection must not be empty")
+    unknown = sorted(set(requested) - set(available))
+    if unknown:
+        raise EvaluationError(f"unknown resolved {kind} ID {unknown[0]!r}")
+    requested_set = set(requested)
+    return tuple(
+        index
+        for index, identifier in enumerate(available)
+        if identifier in requested_set
+    )
+
+
+__all__ = ["SymbolicaExactExecutor"]
diff --git a/pyamplicol/src/pyamplicol/selftest.py b/pyamplicol/src/pyamplicol/selftest.py
new file mode 100644
index 0000000000..19f621abc2
--- /dev/null
+++ b/pyamplicol/src/pyamplicol/selftest.py
@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: 0BSD
+"""Fast installed-distribution self-test entry point."""
+
+from __future__ import annotations
+
+import json
+
+from .diagnostics import run_self_test
+
+
+def main() -> int:
+    report = run_self_test()
+    print(
+        json.dumps(
+            {
+                "package_version": report.package_version,
+                "ok": report.ok,
+                "checks": [
+                    {
+                        "name": check.name,
+                        "status": check.status,
+                        "detail": check.detail,
+                    }
+                    for check in report.checks
+                ],
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+    return 0 if report.ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/src/rusticol_config/__init__.py b/pyamplicol/src/rusticol_config/__init__.py
new file mode 100644
index 0000000000..68237f76f0
--- /dev/null
+++ b/pyamplicol/src/rusticol_config/__init__.py
@@ -0,0 +1,206 @@
+# SPDX-License-Identifier: 0BSD
+"""Report native SDK metadata without initializing pyAmpliCol or Symbolica."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import runpy
+import shlex
+from collections.abc import Sequence
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+
+class SdkUnavailableError(RuntimeError):
+    """Raised when a source tree has no staged native SDK."""
+
+
+@dataclass(frozen=True)
+class SdkInfo:
+    abi_version: int
+    package_version: str
+    target: str
+    include_dir: Path
+    library: Path
+    fortran_source: Path
+    rust_source: Path
+    system_libraries: tuple[str, ...]
+    frameworks: tuple[str, ...]
+
+    @property
+    def cflags(self) -> tuple[str, ...]:
+        return (f"-I{self.include_dir}",)
+
+    @property
+    def link_flags(self) -> tuple[str, ...]:
+        libraries = tuple(f"-l{name}" for name in self.system_libraries)
+        frameworks = tuple(
+            token for name in self.frameworks for token in ("-framework", name)
+        )
+        return (str(self.library), *libraries, *frameworks)
+
+    @property
+    def rust_flags(self) -> tuple[str, ...]:
+        return tuple(
+            token
+            for link_flag in self.link_flags
+            for token in ("-C", f"link-arg={link_flag}")
+        )
+
+    @property
+    def cargo_encoded_rust_flags(self) -> str:
+        return "\x1f".join(self.rust_flags)
+
+    def to_json(self) -> dict[str, Any]:
+        payload = asdict(self)
+        payload["include_dir"] = str(self.include_dir)
+        payload["library"] = str(self.library)
+        payload["fortran_source"] = str(self.fortran_source)
+        payload["rust_source"] = str(self.rust_source)
+        payload["cflags"] = list(self.cflags)
+        payload["link_flags"] = list(self.link_flags)
+        payload["rust_flags"] = list(self.rust_flags)
+        return payload
+
+
+def _resource_root() -> Path:
+    # Finding the top-level package does not execute its __init__.py. SDK
+    # compiler/linker queries must not acquire a numerical-runtime licence.
+    spec = importlib.util.find_spec("pyamplicol")
+    if spec is None or spec.origin is None or not Path(spec.origin).is_file():
+        raise SdkUnavailableError(
+            "Rusticol's static SDK requires a normally installed, unpacked "
+            "pyamplicol wheel"
+        )
+    return Path(spec.origin).resolve().parent / "_sdk"
+
+
+def _package_version() -> str:
+    # Reuse the authoritative, stdlib-only version/source-runtime validation.
+    # Importing it through pyamplicol would first initialize Symbolica.
+    versions = runpy.run_path(
+        str(_resource_root().parent / "_internal" / "versions.py")
+    )
+    return str(versions["package_version"]())
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        raise SdkUnavailableError(
+            "Rusticol's native SDK is unavailable in this source tree; "
+            "install a pyamplicol binary wheel or build one with 'just wheel'"
+        )
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise SdkUnavailableError(f"invalid SDK metadata object: {path}")
+    return payload
+
+
+def _confined(root: Path, relative: str) -> Path:
+    path = (root / relative).resolve()
+    if path != root and root not in path.parents:
+        raise SdkUnavailableError(f"SDK metadata escapes its resource root: {relative}")
+    if not path.is_file():
+        raise SdkUnavailableError(f"missing SDK resource: {relative}")
+    return path
+
+
+def load_sdk_info() -> SdkInfo:
+    root = _resource_root()
+    metadata = _load_json(root / "metadata.json")
+    link = _load_json(root / "link.json")
+    if metadata.get("schema_version") != 1 or link.get("schema_version") != 1:
+        raise SdkUnavailableError("unsupported Rusticol SDK metadata schema")
+    if metadata.get("target") != link.get("target"):
+        raise SdkUnavailableError("Rusticol SDK target metadata is inconsistent")
+
+    package_version = _package_version()
+    metadata_version = str(metadata.get("version"))
+    if package_version != metadata_version:
+        raise SdkUnavailableError(
+            "Rusticol SDK metadata version does not match pyamplicol"
+        )
+    library = _confined(root, str(metadata["archive"]))
+    for required in (
+        "include/rusticol.h",
+        "include/rusticol.hpp",
+        "fortran/rusticol.f90",
+        "rust/rusticol.rs",
+    ):
+        _confined(root, required)
+
+    return SdkInfo(
+        abi_version=int(metadata["abi_version"]),
+        package_version=package_version,
+        target=str(metadata["target"]),
+        include_dir=(root / "include").resolve(),
+        library=library,
+        fortran_source=_confined(root, "fortran/rusticol.f90"),
+        rust_source=_confined(
+            root, str(metadata.get("rust_source", "rust/rusticol.rs"))
+        ),
+        system_libraries=tuple(map(str, link.get("system_libraries", []))),
+        frameworks=tuple(map(str, link.get("frameworks", []))),
+    )
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="rusticol-config",
+        description="Report paths and typed linker arguments for Rusticol's SDK.",
+    )
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--abi-version", action="store_true")
+    group.add_argument("--version", action="store_true")
+    group.add_argument("--target", action="store_true")
+    group.add_argument("--include-dir", action="store_true")
+    group.add_argument("--library", action="store_true")
+    group.add_argument("--fortran-source", action="store_true")
+    group.add_argument("--rust-source", action="store_true")
+    group.add_argument("--cflags", action="store_true")
+    group.add_argument("--libs", action="store_true")
+    group.add_argument("--rustflags", action="store_true")
+    group.add_argument("--cargo-rustflags", action="store_true")
+    group.add_argument("--json", action="store_true")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        info = load_sdk_info()
+    except SdkUnavailableError as error:
+        _parser().error(str(error))
+
+    if args.abi_version:
+        print(info.abi_version)
+    elif args.version:
+        print(info.package_version)
+    elif args.target:
+        print(info.target)
+    elif args.include_dir:
+        print(info.include_dir)
+    elif args.library:
+        print(info.library)
+    elif args.fortran_source:
+        print(info.fortran_source)
+    elif args.rust_source:
+        print(info.rust_source)
+    elif args.cflags:
+        print(shlex.join(info.cflags))
+    elif args.libs:
+        print(shlex.join(info.link_flags))
+    elif args.rustflags:
+        print(shlex.join(info.rust_flags))
+    elif args.cargo_rustflags:
+        print(info.cargo_encoded_rust_flags)
+    elif args.json:
+        print(json.dumps(info.to_json(), indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/src/rusticol_config/__main__.py b/pyamplicol/src/rusticol_config/__main__.py
new file mode 100644
index 0000000000..a97b70e446
--- /dev/null
+++ b/pyamplicol/src/rusticol_config/__main__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: 0BSD
+"""Support ``python -m rusticol_config`` without importing pyAmpliCol."""
+
+from . import main
+
+raise SystemExit(main())
diff --git a/pyamplicol/tests/fixtures/numerical_acceptance/ufo-sm-seed101-v1.json b/pyamplicol/tests/fixtures/numerical_acceptance/ufo-sm-seed101-v1.json
new file mode 100644
index 0000000000..654386450c
--- /dev/null
+++ b/pyamplicol/tests/fixtures/numerical_acceptance/ufo-sm-seed101-v1.json
@@ -0,0 +1,1625 @@
+{
+  "kind": "pyamplicol-ufo-sm-numerical-acceptance",
+  "schema_version": 1,
+  "model": {
+    "kind": "ufo-sm-json-default-restriction",
+    "source_sha256": "c1222e3b70b71804e5212e994a3b76e2f098f7fc3ba1693c9f9c65578d7e3e00",
+    "restriction_sha256": "8fdd48a3624620c1a15bab602f43a41519038cf69d8fef6aeaaaf13a3f1846c1",
+    "external_parameters_sha256": "d6b5072d4bfc1d6e9660a3c6349f069fb3c4a4aaafea9a8633b948ab7aafff01"
+  },
+  "point_policy": {
+    "generator": "generic_validation_point",
+    "seed": 101,
+    "stored_components": "canonical-binary64-decimal"
+  },
+  "comparison": {
+    "relative_tolerance": "0.0000000001",
+    "absolute_tolerance": null,
+    "full_candidate_precision_digits": 200,
+    "native_precision": "binary64"
+  },
+  "references": {
+    "full": {
+      "kind": "madgraph-standalone-ufo-sm",
+      "precision": "binary64",
+      "command_protocol": "generate-output-standalone-launch-force",
+      "madgraph_version": "version = 3.7.2\ndate = 2026-07-07",
+      "model_source_sha256": "f5a639915654d05a96bd3bea9bea0a21ab43f225684cf1988f8159345bd40dbf",
+      "driver_sha256": "9c243fd026ddfd624fa3a2e6dbd0a2ff34a7753a19896a879f47a134b5b12110",
+      "external_parameters_sha256": "d6b5072d4bfc1d6e9660a3c6349f069fb3c4a4aaafea9a8633b948ab7aafff01"
+    },
+    "lc": {
+      "kind": "pyamplicol-recurrence-regression",
+      "precision_digits": 200,
+      "captured_source_revision": "546f16657f5038d3a4757780d251a9caf2a0ecca"
+    },
+    "nlc": {
+      "kind": "pyamplicol-recurrence-regression",
+      "precision_digits": 200,
+      "captured_source_revision": "546f16657f5038d3a4757780d251a9caf2a0ecca"
+    }
+  },
+  "catalog_max_n_final": 4,
+  "catalog_cases": [
+    {
+      "id": "catalog:dd_z_jets:n1",
+      "family_id": 1,
+      "family_key": "dd_z_jets",
+      "n_final": 1,
+      "process": "d d~ > z",
+      "momenta": [
+        [
+          "45.594000000000001",
+          "0",
+          "0",
+          "45.594000000000001"
+        ],
+        [
+          "45.594000000000001",
+          "0",
+          "0",
+          "-45.594000000000001"
+        ],
+        [
+          "91.188000000000002",
+          "0",
+          "0",
+          "0"
+        ]
+      ],
+      "expected": {
+        "full": "142.10653372833232",
+        "lc": "142.1065337283316771630720519281830618215656701467945093745489031400198352158371309439349700067578697338864141170719902307518465149412502975033209900016614416142741044808017738627093943395178947669060418",
+        "nlc": "142.1065337283316737525152424482226734855640446719854922169078006245909239210193549663024730339556879741472550427958462279115447341677246458469334004706282352790667631995989217118372355521612360269942278"
+      }
+    },
+    {
+      "id": "catalog:ud_w_jets:n1",
+      "family_id": 2,
+      "family_key": "ud_w_jets",
+      "n_final": 1,
+      "process": "u d~ > w+",
+      "momenta": [
+        [
+          "40.209501222878082",
+          "0",
+          "0",
+          "40.209501222878082"
+        ],
+        [
+          "40.209501222878082",
+          "0",
+          "0",
+          "-40.209501222878082"
+        ],
+        [
+          "80.419002445756163",
+          "0",
+          "0",
+          "0"
+        ]
+      ],
+      "expected": {
+        "full": "229.97056761327616",
+        "lc": "229.97056761327635753098110523948539254482256522483025375679394580267863704974167984386500379266665540344181452454355935540433709017743888286755792393967055394090096118467927443150248243098196751834485",
+        "nlc": "229.97056761327635201168748252085259102953113073186877206939500068829327939072917600416340823836618556261790132852503603984426066039108173076041056822685128083361655811981505555850329140411062624231763"
+      }
+    },
+    {
+      "id": "catalog:dd_z_jets:n2",
+      "family_id": 1,
+      "family_key": "dd_z_jets",
+      "n_final": 2,
+      "process": "d d~ > z g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "504.15762567199999",
+          "-304.10842628649999",
+          "208.76026523528103",
+          "331.35611794513767"
+        ],
+        [
+          "495.84237432800001",
+          "304.10842628649999",
+          "-208.76026523528103",
+          "-331.35611794513767"
+        ]
+      ],
+      "expected": {
+        "full": "0.36154106787235846",
+        "lc": "0.406733701356400980477344819798281964547132485640488237589799387080592726894664150379425887837651519884288598614624522573841816532322005277139137654826698129107951277968093762360293553604493833678076069826524",
+        "nlc": "0.361541067872356403952344829323217079108501349822615561398506938746084907686669668641325659181463018312028246226601999981663560174535609378900337409971875904180570105830589777290143789907993815661589896399039"
+      }
+    },
+    {
+      "id": "catalog:ud_w_jets:n2",
+      "family_id": 2,
+      "family_key": "ud_w_jets",
+      "n_final": 2,
+      "process": "u d~ > w+ g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "503.23360797718527",
+          "-304.67514180251823",
+          "209.14929648601478",
+          "331.97361038249016"
+        ],
+        [
+          "496.76639202281473",
+          "304.67514180251823",
+          "-209.14929648601478",
+          "-331.97361038249016"
+        ]
+      ],
+      "expected": {
+        "full": "0.74840094538556268",
+        "lc": "0.8419510635587580185294296462853350134567455501314195817442538681159914477786403588061823936361260769040911250746729316880543740079632357044117157747537175158282410835270734567234320207181417160317133472737",
+        "nlc": "0.7484009453855626352396102920220638467317761669955366404555899197379006365745713772290930984916827673852603843223146754010865504256849845946060260134281177186474946660348021721920023777648359873173902451978"
+      }
+    },
+    {
+      "id": "catalog:dd_epem_jets:n2",
+      "family_id": 3,
+      "family_key": "dd_epem_jets",
+      "n_final": 2,
+      "process": "d d~ > e+ e-",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "499.99999999999994",
+          "-306.65836769058797",
+          "210.51071473894038",
+          "334.13453054936508"
+        ],
+        [
+          "499.99999999999994",
+          "306.65836769058797",
+          "-210.51071473894038",
+          "-334.13453054936508"
+        ]
+      ],
+      "expected": {
+        "full": "0.00029643287701939142",
+        "lc": "0.000296432877019388357696549282918537768933406423293542123764771988433219534529326956012307564740668975770611723619347473495181260687648913436184893085265198380502835228731564754571905708622664671181641158",
+        "nlc": "0.000296432877019388350582160234453216899640661694635800897653228683078559519713067019428638143386424568128453315673515749314163575990040582311127248677358030909759624866080104792775445713006712089597504326"
+      }
+    },
+    {
+      "id": "catalog:ud_epve_jets:n2",
+      "family_id": 4,
+      "family_key": "ud_epve_jets",
+      "n_final": 2,
+      "process": "u d~ > e+ ve",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "499.99999999999994",
+          "-306.65836769058797",
+          "210.51071473894038",
+          "334.13453054936508"
+        ],
+        [
+          "499.99999999999994",
+          "306.65836769058797",
+          "-210.51071473894038",
+          "-334.13453054936508"
+        ]
+      ],
+      "expected": {
+        "full": "0.00042290087317927035",
+        "lc": "0.00042290087317927101667680485117210900708566461543135076562362064944785883078365193194497691987108553413800835685965744053997011788171359700776878346158600283900787979490723528363853135464143412179878595",
+        "nlc": "0.00042290087317927100652718389486960420085750993520054234644148266986310368853123716180615929096684836190585712378411773194172023022834668011849044816578299908142366488472301684408081986949904973216557403"
+      }
+    },
+    {
+      "id": "catalog:dd_zz_jets:n2",
+      "family_id": 5,
+      "family_key": "dd_zz_jets",
+      "n_final": 2,
+      "process": "d d~ > z z",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500.00000000000006",
+          "-301.515357817672",
+          "206.98021044385018",
+          "328.53071415120502"
+        ],
+        [
+          "500.00000000000006",
+          "301.515357817672",
+          "-206.98021044385018",
+          "-328.53071415120502"
+        ]
+      ],
+      "expected": {
+        "full": "0.0090424170370014562",
+        "lc": "0.0090424170370013648845279919840604864829391659358048692463947855749456672962148595430803427854517900098592902941101001848666259886778203333078068868738995891075173352708083538172104162137425432736579449505317",
+        "nlc": "0.0090424170370013648845279919840604864829391659358048692463947855749456672962148595430803427854517900098592902941101001848666259886778203333078068868738995891075173352708083538172104162137425432736579449505317"
+      }
+    },
+    {
+      "id": "catalog:gg_tt_jets:n2",
+      "family_id": 6,
+      "family_key": "gg_tt_jets",
+      "n_final": 2,
+      "process": "g g > t t~",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500.00000000000006",
+          "-287.71746404131949",
+          "197.50841776906941",
+          "313.49654829996268"
+        ],
+        [
+          "500.00000000000006",
+          "287.71746404131949",
+          "-197.50841776906941",
+          "-313.49654829996268"
+        ]
+      ],
+      "expected": {
+        "full": "1.2610084500232903",
+        "lc": "1.6878740643879328250280033384515409661517475904750590138577663633669181966161042477988263203321837149785427042672253033492835720424525254871719536852878152133513739250681130658663008879735867482594106209936418",
+        "nlc": "1.26100845002328709396113227586451050337149832360108834320173270021687758321679415237080902723157117758909670503034917661514817267890778244486154273809695951448244927757661746744731218630968331082720920966212"
+      }
+    },
+    {
+      "id": "catalog:dd_tt_jets:n2",
+      "family_id": 7,
+      "family_key": "dd_tt_jets",
+      "n_final": 2,
+      "process": "d d~ > t t~",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500.00000000000006",
+          "-287.71746404131949",
+          "197.50841776906941",
+          "313.49654829996268"
+        ],
+        [
+          "500.00000000000006",
+          "287.71746404131949",
+          "-197.50841776906941",
+          "-313.49654829996268"
+        ]
+      ],
+      "expected": {
+        "full": "0.73920207615248823",
+        "lc": "0.924002595190608125103802206134566346136990859129272389616301871381931679869555297954080981962509123346720614981687643693018139715654310155871375684678354704978407418966766502445392626632623578986130943",
+        "nlc": "0.7392020761524864643802649432526023840665888019351189535728266553999803444316071007207571098670967720644692806134794243269686877006555114179154441267934558670200616003901330338951385202584503174225044276"
+      }
+    },
+    {
+      "id": "catalog:gg_gluons:n2",
+      "family_id": 8,
+      "family_key": "gg_gluons",
+      "n_final": 2,
+      "process": "g g > g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "499.99999999999994",
+          "-306.65836769058797",
+          "210.51071473894038",
+          "334.13453054936508"
+        ],
+        [
+          "499.99999999999994",
+          "306.65836769058797",
+          "-210.51071473894038",
+          "-334.13453054936508"
+        ]
+      ],
+      "expected": {
+        "full": "165.3364278744663",
+        "lc": "186.00348135877425216846523106011254900394998008176597202719652802042954685464434667511827369662439335588850389246630513367989312057055392948447348769645380752332242558464170604198515478397123250262088579304",
+        "nlc": "165.33642787446599699940513832406534195305107497723107694158970675653463381946014449050068848912474809470540644129286839214416641411534939123876870232330423464310169892634437331991273249990348265252061551"
+      }
+    },
+    {
+      "id": "catalog:dd_z_jets:n3",
+      "family_id": 1,
+      "family_key": "dd_z_jets",
+      "n_final": 3,
+      "process": "d d~ > z g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "312.48956564409934",
+          "-193.66118273046334",
+          "121.57983298112629",
+          "192.47900614913141"
+        ],
+        [
+          "487.79620348021274",
+          "250.47715399872871",
+          "-206.71282928308619",
+          "-363.97271554910253"
+        ],
+        [
+          "199.71423087568797",
+          "-56.81597126826545",
+          "85.132996301959906",
+          "171.49370939997104"
+        ]
+      ],
+      "expected": {
+        "full": "0.00017631238848843083",
+        "lc": "0.00022866903494322777184789097865160576625012684154671490824158388339590189548398253482192251668524571600856818684485074738589444776380122275411388018886878734376854000482302357886069556880559639010461955138435905",
+        "nlc": "0.000176312388488430309991648207894224321123263898940162375052410862306334784514692159689558997784847564392535584833873113167504696026177391654637809783418664241495889520626711846495166510779996545718826107815627"
+      }
+    },
+    {
+      "id": "catalog:ud_w_jets:n3",
+      "family_id": 2,
+      "family_key": "ud_w_jets",
+      "n_final": 3,
+      "process": "u d~ > w+ g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "310.39704012395219",
+          "-194.25061519123031",
+          "121.94987667869806",
+          "193.06484050499387"
+        ],
+        [
+          "489.28087331707053",
+          "251.23951310015411",
+          "-207.34198609147984",
+          "-365.0805128389535"
+        ],
+        [
+          "200.32208655897728",
+          "-56.988897908923896",
+          "85.392109412781764",
+          "172.01567233395957"
+        ]
+      ],
+      "expected": {
+        "full": "0.00036371847402838503",
+        "lc": "0.000471802455887629381751012889850229888032057171583165492366500234992781591587899976039282633880020820894197294586755868847973943089271659093712502754705677157184063491263792917257584986048424882556926450601877",
+        "nlc": "0.00036371847402838502469903577196089132768455237765431682839738136773674757167847031249069141480400207711127675112267240318340066086493292821067928823856229364459017572541706785313721388000256441899530004011129"
+      }
+    },
+    {
+      "id": "catalog:dd_epem_jets:n3",
+      "family_id": 3,
+      "family_key": "dd_epem_jets",
+      "n_final": 3,
+      "process": "d d~ > e+ e- g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "303.00992326176095",
+          "-196.331453120389",
+          "123.25621966556298",
+          "195.13297626103395"
+        ],
+        [
+          "494.52211385681227",
+          "253.93082353769123",
+          "-209.56306049343993",
+          "-368.99130291580417"
+        ],
+        [
+          "202.46796288142687",
+          "-57.59937041730231",
+          "86.306840827876954",
+          "173.85832665477017"
+        ]
+      ],
+      "expected": {
+        "full": "0.00000023666323813983404",
+        "lc": "0.000000266246142907310901325355677018696429262566038402124896647571207992471742911774178426532602105924836073319636326230387585553669388994611922772295906761290474934178482353991228883532360108864299509867621",
+        "nlc": "0.0000002366632381398318971427578052895988839464912970716030434163064446724252066375261039185253828910021482446516458195918923494195062313331612865221822320943354822286581774501340738632084350697116897455969543"
+      }
+    },
+    {
+      "id": "catalog:ud_epve_jets:n3",
+      "family_id": 4,
+      "family_key": "ud_epve_jets",
+      "n_final": 3,
+      "process": "u d~ > e+ ve g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "303.00992326176095",
+          "-196.331453120389",
+          "123.25621966556298",
+          "195.13297626103395"
+        ],
+        [
+          "494.52211385681227",
+          "253.93082353769123",
+          "-209.56306049343993",
+          "-368.99130291580417"
+        ],
+        [
+          "202.46796288142687",
+          "-57.59937041730231",
+          "86.306840827876954",
+          "173.85832665477017"
+        ]
+      ],
+      "expected": {
+        "full": "0.00000026222888441700588",
+        "lc": "0.00000029500749496913309995141368236988967401699007480994826335657432170761032857377380640398814595055344089461821197133139341979477350447304533882423604706380193187700297882778710336474192790983575707412822",
+        "nlc": "0.00000026222888441700718317416355941810780189023502501067477890596403010748575444712641521504632642580429425722388545414326770153707319045677019729665045403457799744524085932841196732137891816129879264946207"
+      }
+    },
+    {
+      "id": "catalog:dd_zz_jets:n3",
+      "family_id": 5,
+      "family_key": "dd_zz_jets",
+      "n_final": 3,
+      "process": "d d~ > z z g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "309.98693239254516",
+          "-191.96520759226249",
+          "120.51510554770157",
+          "190.79338384500207"
+        ],
+        [
+          "492.04782104310141",
+          "248.2836167091192",
+          "-204.90255520405609",
+          "-360.78524830423976"
+        ],
+        [
+          "197.96524656435344",
+          "-56.318409116856806",
+          "84.387449656354519",
+          "169.99186445923763"
+        ]
+      ],
+      "expected": {
+        "full": "0.000011028108806289972",
+        "lc": "0.00001240662240707612813324703832178871836279742434792171652467086755723448166029895112872581788260756289707390947803090730806359497520688232506770408844106084876428211533265727176290482021957131949080965007215953",
+        "nlc": "0.00001102810880628989096819840379459246029776619711417221449389840825799522140565637996952799255419972502988583554768611724029634522775894631910900060017830403949441818231534484519897727904844971259102324984327627"
+      }
+    },
+    {
+      "id": "catalog:gg_tt_jets:n3",
+      "family_id": 6,
+      "family_key": "gg_tt_jets",
+      "n_final": 3,
+      "process": "g g > t t~ g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "327.78016913065488",
+          "-180.39074377820512",
+          "113.24869646396822",
+          "179.28957466534038"
+        ],
+        [
+          "486.19081801910795",
+          "233.31345741167567",
+          "-192.5480392979517",
+          "-339.03184906320229"
+        ],
+        [
+          "186.02901285023736",
+          "-52.922713633470622",
+          "79.299342833983488",
+          "159.74227439786188"
+        ]
+      ],
+      "expected": {
+        "full": "0.0041234764122830402",
+        "lc": "0.005498647106423893281886883039692273222330614852654020152618248181068760112272295505879887872542713611472137213742699115336550927319641880063792317510519764567992737663647635861239848036129544386653854204580388",
+        "nlc": "0.004099225748770255672098790545878946580118185128069156274600967727592194049528969226888012825288930608379385616765966572671115456573788536907570925765360749829487479650246440574331402245208776105600804582681"
+      }
+    },
+    {
+      "id": "catalog:dd_tt_jets:n3",
+      "family_id": 7,
+      "family_key": "dd_tt_jets",
+      "n_final": 3,
+      "process": "d d~ > t t~ g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "327.78016913065488",
+          "-180.39074377820512",
+          "113.24869646396822",
+          "179.28957466534038"
+        ],
+        [
+          "486.19081801910795",
+          "233.31345741167567",
+          "-192.5480392979517",
+          "-339.03184906320229"
+        ],
+        [
+          "186.02901285023736",
+          "-52.922713633470622",
+          "79.299342833983488",
+          "159.74227439786188"
+        ]
+      ],
+      "expected": {
+        "full": "0.001055791108500876",
+        "lc": "0.0015530561536812689777429967533121489028956234696374552770061036600912134736319241268311463390973016613278224707334797345134084692937023716543246453183954922956587807720588433077307834853154662989113147736725",
+        "nlc": "0.001055791108500874142191908091927224326704140141033006344076728055738504904440144845187070652745087767144598827170004048179928827015155779166913689196724562680181397369201884355946448806444377881546896516"
+      }
+    },
+    {
+      "id": "catalog:gg_gluons:n3",
+      "family_id": 8,
+      "family_key": "gg_gluons",
+      "n_final": 3,
+      "process": "g g > g g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "303.00992326176095",
+          "-196.331453120389",
+          "123.25621966556298",
+          "195.13297626103395"
+        ],
+        [
+          "494.52211385681227",
+          "253.93082353769123",
+          "-209.56306049343993",
+          "-368.99130291580417"
+        ],
+        [
+          "202.46796288142687",
+          "-57.59937041730231",
+          "86.306840827876954",
+          "173.85832665477017"
+        ]
+      ],
+      "expected": {
+        "full": "0.54499571545662018",
+        "lc": "0.61312017988870141895096325191023036099439898686616580975870190773457471390422531338691835062271078019080994903818393502895975306455156810460532373714066429789120043177101961353963551830888929457599376923382768636",
+        "nlc": "0.5449957154566211248154238647597053100201890766933366783706880608633809734786336718337661801790197758782318923155091175027700354117565032127253120264264397403244966153999193220740606516995663454023019245418086"
+      }
+    },
+    {
+      "id": "catalog:dd_zzz_jets:n3",
+      "family_id": 9,
+      "family_key": "dd_zzz_jets",
+      "n_final": 3,
+      "process": "d d~ > z z z",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "303.95306247003941",
+          "-187.87079311487679",
+          "117.94464604054834",
+          "186.72396312651625"
+        ],
+        [
+          "481.91719597099183",
+          "242.9879902385625",
+          "-200.53220081013504",
+          "-353.0900812351025"
+        ],
+        [
+          "214.12974155896882",
+          "-55.117197123685791",
+          "82.587554769586717",
+          "166.36611810858622"
+        ]
+      ],
+      "expected": {
+        "full": "0.00000014647132653168889",
+        "lc": "0.0000001464713265316869800520794730160284038912011013474592914108157089879994148610025965262600019017665935142850477191789064192163726931671793693925359681393606315889711586608630709341781712646919340816652020040544",
+        "nlc": "0.0000001464713265316869695061439627345651652016063861797669351102746412386196300476432134299959038545791254626626357719862180868585722919538639149144763824502569487305679685242618935904505789400754768222709547204631"
+      }
+    },
+    {
+      "id": "catalog:dd_z_jets:n4",
+      "family_id": 1,
+      "family_key": "dd_z_jets",
+      "n_final": 4,
+      "process": "d d~ > z g g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "300.37140982458777",
+          "-210.34453868661902",
+          "87.704153573306712",
+          "173.12102410369954"
+        ],
+        [
+          "357.12242829640621",
+          "151.57318148300286",
+          "-187.59017005274106",
+          "-263.38551127012698"
+        ],
+        [
+          "183.94449464488207",
+          "-81.602974117292263",
+          "61.235780320717993",
+          "153.05786792545604"
+        ],
+        [
+          "158.56166723412403",
+          "140.37433132090848",
+          "38.650236158716361",
+          "-62.793380759028615"
+        ]
+      ],
+      "expected": {
+        "full": "0.000000035538847721871692",
+        "lc": "0.000000049469038090473216897119401175245771989229362094959206211600461468034063798042438035492000663386626460798687901683737336969157021524824204717047392232921150285466902836283518258784151085644291659508822676562877",
+        "nlc": "0.0000000352987950682156084272081702316323349546137541356434040376852518162253925256156621119958656138451168394069208619763546355501783263005970319279807616363248888375758173373192599426939178509051012552325106043889"
+      }
+    },
+    {
+      "id": "catalog:ud_w_jets:n4",
+      "family_id": 2,
+      "family_key": "ud_w_jets",
+      "n_final": 4,
+      "process": "u d~ > w+ g g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "298.15299166642154",
+          "-211.01150992056549",
+          "87.982250394342643",
+          "173.66996511157876"
+        ],
+        [
+          "358.25481037848004",
+          "152.05379748814443",
+          "-188.18499056948721",
+          "-264.22066753590093"
+        ],
+        [
+          "184.52775526736841",
+          "-81.861725006098553",
+          "61.429949868533221",
+          "153.54319165039263"
+        ],
+        [
+          "159.06444268773024",
+          "140.81943743851966",
+          "38.772790306611334",
+          "-62.992489226070475"
+        ]
+      ],
+      "expected": {
+        "full": "0.000000072771501409999417",
+        "lc": "0.0000001012865746931596959737069594481164851504853132405366604633596987513113640512925333512065965311658608749387891401852021396150083736264094237118726586295399437105564561613237941811054373292676792917342655823384",
+        "nlc": "0.00000007227651332284122746120624693324600837730958861140072390895612022021277734414569417527733145489021162371322115203343951429515837312734989248553011741549488185062564090212158329371329927644192459470193839715"
+      }
+    },
+    {
+      "id": "catalog:dd_epem_jets:n4",
+      "family_id": 3,
+      "family_key": "dd_epem_jets",
+      "n_final": 4,
+      "process": "d d~ > e+ e- g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "290.31075577423769",
+          "-213.36929162671257",
+          "88.965338665326172",
+          "175.61050317417747"
+        ],
+        [
+          "362.257846224096",
+          "153.7528027329422",
+          "-190.28771533698082",
+          "-267.17299301111615"
+        ],
+        [
+          "186.58961514320916",
+          "-82.776424293003245",
+          "62.11635039741472",
+          "155.25883895566528"
+        ],
+        [
+          "160.84178285845738",
+          "142.39291318677365",
+          "39.206026274239925",
+          "-63.696349118726602"
+        ]
+      ],
+      "expected": {
+        "full": "0.0000000000424909519514746",
+        "lc": "0.0000000000549885088289780349922545138477977432927959222290641543247394546139877459565655642153323014279909197140689352625730696639505052819892166629902021865997241109272876458274806001181288687572126976061436472881",
+        "nlc": "0.00000000004249095195147435805387504941647082381613178399812038666733776066691496014658832123105355569082911555090487099048064660566041552442424657371474351516261809903924053349115554357162718153345538292564774273"
+      }
+    },
+    {
+      "id": "catalog:ud_epve_jets:n4",
+      "family_id": 4,
+      "family_key": "ud_epve_jets",
+      "n_final": 4,
+      "process": "u d~ > e+ ve g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "290.31075577423769",
+          "-213.36929162671257",
+          "88.965338665326172",
+          "175.61050317417747"
+        ],
+        [
+          "362.257846224096",
+          "153.7528027329422",
+          "-190.28771533698082",
+          "-267.17299301111615"
+        ],
+        [
+          "186.58961514320916",
+          "-82.776424293003245",
+          "62.11635039741472",
+          "155.25883895566528"
+        ],
+        [
+          "160.84178285845738",
+          "142.39291318677365",
+          "39.206026274239925",
+          "-63.696349118726602"
+        ]
+      ],
+      "expected": {
+        "full": "0.000000000054487229301925616",
+        "lc": "0.00000000007017853150693386643654001957586773028803096037819722996102943421982911863918202893331036561208870428944241045324899471938430159163110108821248113763427344472397277261249364116133030588885929134350095455",
+        "nlc": "0.0000000000544872293019260846175862629691090291655941645115128444748867052082733465665899390106555853574283860728388266819286277664181624350717564898970317074202166338696898268940600142211231147593248278115444604"
+      }
+    },
+    {
+      "id": "catalog:dd_zz_jets:n4",
+      "family_id": 5,
+      "family_key": "dd_zz_jets",
+      "n_final": 4,
+      "process": "d d~ > z z g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "297.12168084047005",
+          "-207.836389371785",
+          "86.65836881432746",
+          "171.05672816000515"
+        ],
+        [
+          "364.45620244094101",
+          "149.76582212079853",
+          "-185.35334394151809",
+          "-260.24490113708436"
+        ],
+        [
+          "181.75113958517022",
+          "-80.6299398521829",
+          "60.505604574707498",
+          "151.23280515480278"
+        ],
+        [
+          "156.67097713341875",
+          "138.7005071031694",
+          "38.189370552483133",
+          "-62.044632177723578"
+        ]
+      ],
+      "expected": {
+        "full": "0.0000000019082866212806233",
+        "lc": "0.0000000025000011917449759563437217295467915519479084735477322001190128799067088278692472627765955019375097174945804832544211822019734974727372993141968157120071495837450570537587135395878106465727188218406854091083988",
+        "nlc": "0.000000001908286621280602063295305263807535577621112708881647296934790346905622034020400826223262743154586420687347018265070862631190187245853054381204054169616850130215886433551713335402914496871740914218663758068726"
+      }
+    },
+    {
+      "id": "catalog:gg_tt_jets:n4",
+      "family_id": 6,
+      "family_key": "gg_tt_jets",
+      "n_final": 4,
+      "process": "g g > t t~ g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "314.65690620656977",
+          "-193.17230180786569",
+          "80.544107917663595",
+          "158.98766341288447"
+        ],
+        [
+          "370.7986607092069",
+          "139.19895682690071",
+          "-172.2755683217658",
+          "-241.88308283436604"
+        ],
+        [
+          "168.92752080611501",
+          "-74.941020304264356",
+          "56.236576007221046",
+          "140.56243552400588"
+        ],
+        [
+          "145.61691227810837",
+          "128.91436528522939",
+          "35.494884396881169",
+          "-57.667016102524293"
+        ]
+      ],
+      "expected": {
+        "full": "0.0000013297504115314729",
+        "lc": "0.00000181314005319235749767037933567868945319675161558162928086809010060093169432965963992437853938552399976018847351715669551012699682956593917457750915770953667340503045479298179995272883209767825246667733361421801",
+        "nlc": "0.000001334994216442333805199546027503433542754776795537867615016444753042864780469996339784970768811052860055090830239907368865695958272876617426706472888276494781559661443454136988905904271189224290715804796378"
+      }
+    },
+    {
+      "id": "catalog:dd_tt_jets:n4",
+      "family_id": 7,
+      "family_key": "dd_tt_jets",
+      "n_final": 4,
+      "process": "d d~ > t t~ g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "314.65690620656977",
+          "-193.17230180786569",
+          "80.544107917663595",
+          "158.98766341288447"
+        ],
+        [
+          "370.7986607092069",
+          "139.19895682690071",
+          "-172.2755683217658",
+          "-241.88308283436604"
+        ],
+        [
+          "168.92752080611501",
+          "-74.941020304264356",
+          "56.236576007221046",
+          "140.56243552400588"
+        ],
+        [
+          "145.61691227810837",
+          "128.91436528522939",
+          "35.494884396881169",
+          "-57.667016102524293"
+        ]
+      ],
+      "expected": {
+        "full": "0.00000010521886363225839",
+        "lc": "0.00000019228625624912442915499464622016179123007555406846728804028872165990037494616304694310225413403320094528634900774236211375564218411731444412732629246610880693104945861113034797817808899117896958242354616424327",
+        "nlc": "0.00000010434231717649263869987084847320844023376768057959947054959384226612882985836410423843222776622915858660412871758739753336556553197701007970419742095222358116316635619457501344974341714306337233946800361"
+      }
+    },
+    {
+      "id": "catalog:gg_gluons:n4",
+      "family_id": 8,
+      "family_key": "gg_gluons",
+      "n_final": 4,
+      "process": "g g > g g g g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "290.31075577423769",
+          "-213.36929162671257",
+          "88.965338665326172",
+          "175.61050317417747"
+        ],
+        [
+          "362.257846224096",
+          "153.7528027329422",
+          "-190.28771533698082",
+          "-267.17299301111615"
+        ],
+        [
+          "186.58961514320916",
+          "-82.776424293003245",
+          "62.11635039741472",
+          "155.25883895566528"
+        ],
+        [
+          "160.84178285845738",
+          "142.39291318677365",
+          "39.206026274239925",
+          "-63.696349118726602"
+        ]
+      ],
+      "expected": {
+        "full": "0.0001887433739424267",
+        "lc": "0.0002119883742276068760685181223298585009934290154199226320684050844344779661540786287621514339243264245279803304297811418804253432454641678472946805675739226064420416160768293803958518966703805218536945408263739153316",
+        "nlc": "0.00018878203188216711218589720227208194236963802768492492668688663228704060626610087489080961066176703351380077689983669556237395452840315867517940414747595664053636712232809681527251400252116941751028160741435924"
+      }
+    },
+    {
+      "id": "catalog:dd_zzz_jets:n4",
+      "family_id": 9,
+      "family_key": "dd_zzz_jets",
+      "n_final": 4,
+      "process": "d d~ > z z z g",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "290.87287037663418",
+          "-203.00542771759544",
+          "84.644076427791873",
+          "167.08067518424895"
+        ],
+        [
+          "356.5209915182034",
+          "146.28465625778162",
+          "-181.04497956045921",
+          "-254.1957528532262"
+        ],
+        [
+          "199.57683067714848",
+          "-78.755772634483975",
+          "59.099208628129098",
+          "147.7175406490696"
+        ],
+        [
+          "153.02930742801391",
+          "135.47654409429785",
+          "37.30169450453824",
+          "-60.602462980092348"
+        ]
+      ],
+      "expected": {
+        "full": "0.000000000070486729249754583",
+        "lc": "0.0000000000792975704059726863009193253330169756829588739865624487291534027778342400965232808525390864110591632851058177142186077385020044795565601145983676791563999543773796882798976779102182971479024683712925189107533",
+        "nlc": "0.0000000000704867292497534938591060054248739525453893504774918569909153555420043700245032018590196222649986677237358834578457573983061371650848358723267860849532508235804208352387228270016718473509882815128685472167471"
+      }
+    },
+    {
+      "id": "catalog:dd_epemzh_jets:n4",
+      "family_id": 10,
+      "family_key": "dd_epemzh_jets",
+      "n_final": 4,
+      "process": "d d~ > e+ e- z h",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "270.65098032849863",
+          "-198.91997386302734",
+          "82.940627056037428",
+          "163.71820159854309"
+        ],
+        [
+          "337.72583089717784",
+          "143.34069944100176",
+          "-177.40147643883617",
+          "-249.08010136555396"
+        ],
+        [
+          "196.40565064490178",
+          "-77.170824495429102",
+          "57.909845898243887",
+          "144.74474724833556"
+        ],
+        [
+          "195.21753812942174",
+          "132.75009891745472",
+          "36.55100348455484",
+          "-59.382847481324681"
+        ]
+      ],
+      "expected": {
+        "full": "0.0000000000000043627308885228678",
+        "lc": "0.000000000000004362730888522779072181106118527979331096051610683739284691232996668770982424442693294285674542813097096973749513339824565679084099720079317258544372383540180400304894396455282998004642813545488467335710735",
+        "nlc": "0.000000000000004362730888522778967475564793981277410527851784144158515658001278675797388505582053524838339601762867256224162843816300608325628998623331446822321935231721748746342471118753687232190246190554865882648448146"
+      }
+    },
+    {
+      "id": "catalog:dd_ttzh_jets:n4",
+      "family_id": 11,
+      "family_key": "dd_ttzh_jets",
+      "n_final": 4,
+      "process": "d d~ > t t~ z h",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "294.88538952715049",
+          "-175.51504741897966",
+          "73.181831909570974",
+          "144.45511608957261"
+        ],
+        [
+          "344.56704357168957",
+          "126.47523107348077",
+          "-156.52841665261553",
+          "-219.77333373471285"
+        ],
+        [
+          "178.53102628594573",
+          "-68.090904385517319",
+          "51.096172754651874",
+          "127.71407859943305"
+        ],
+        [
+          "182.01654061521435",
+          "117.13072073101625",
+          "32.250411988392671",
+          "-52.395860954292807"
+        ]
+      ],
+      "expected": {
+        "full": "0.00000000066920840275964804",
+        "lc": "0.000000000836510503449559851231072110446059165679624184606167947324941649438676205388408515025078530230101842862573043985948169817605821133314054636541145505709018902564926992659009099785013224981663562131059233319",
+        "nlc": "0.0000000006692084027596478486627105763467572270169985285290438615541721825402623496199058885534520776862455924655100353867931630868468777689742879470828351881296528187778230391297169032684081325840854619654244388"
+      }
+    },
+    {
+      "id": "catalog:dd_4l_jets:n4",
+      "family_id": 12,
+      "family_key": "dd_4l_jets",
+      "n_final": 4,
+      "process": "d d~ > e+ e- e+ e-",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "290.31075577423769",
+          "-213.36929162671257",
+          "88.965338665326172",
+          "175.61050317417747"
+        ],
+        [
+          "362.257846224096",
+          "153.7528027329422",
+          "-190.28771533698082",
+          "-267.17299301111615"
+        ],
+        [
+          "186.58961514320916",
+          "-82.776424293003245",
+          "62.11635039741472",
+          "155.25883895566528"
+        ],
+        [
+          "160.84178285845738",
+          "142.39291318677365",
+          "39.206026274239925",
+          "-63.696349118726602"
+        ]
+      ],
+      "expected": {
+        "full": "0.00000000000000026694593189474546",
+        "lc": "0.00000000000000026694593189473874253916983328023425774528222221014053107751535791050521507933373350232615233072827840317446331944606579594368356248648123582511027011970744907852086694298147900451276132048726150008344053",
+        "nlc": "0.00000000000000026694593189473874253916983328023425774528222221014053107751535791050521507933373350232615233072827840317446331944606579594368356248648123582511027011970744907852086694298147900451276132048726150008344053"
+      }
+    },
+    {
+      "id": "catalog:dd_3q_lines:n4",
+      "family_id": 13,
+      "family_key": "dd_3q_lines",
+      "n_final": 4,
+      "process": "d d~ > u u~ s s~",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "290.31075577423769",
+          "-213.36929162671257",
+          "88.965338665326172",
+          "175.61050317417747"
+        ],
+        [
+          "362.257846224096",
+          "153.7528027329422",
+          "-190.28771533698082",
+          "-267.17299301111615"
+        ],
+        [
+          "186.58961514320916",
+          "-82.776424293003245",
+          "62.11635039741472",
+          "155.25883895566528"
+        ],
+        [
+          "160.84178285845738",
+          "142.39291318677365",
+          "39.206026274239925",
+          "-63.696349118726602"
+        ]
+      ],
+      "expected": {
+        "full": "0.00000000060125965786352068",
+        "lc": "0.00000000118174717425276052809465310358387087946882347197109385153479972473173004546288743505638610950692102578502600956002570114131165271095415507413627619033616360590755346679234681796423919330077105808874998647",
+        "nlc": "0.000000000601259657863520599963576540455578253157343523051020036267855165091993041637388361616115301427905380829814161343354563516388998585894742581019697713014219020282493573017608746400843850662614031646325418"
+      }
+    },
+    {
+      "id": "catalog:dd_3q_identical_lines:n4",
+      "family_id": 15,
+      "family_key": "dd_3q_identical_lines",
+      "n_final": 4,
+      "process": "d d~ > u u~ u u~",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "290.31075577423769",
+          "-213.36929162671257",
+          "88.965338665326172",
+          "175.61050317417747"
+        ],
+        [
+          "362.257846224096",
+          "153.7528027329422",
+          "-190.28771533698082",
+          "-267.17299301111615"
+        ],
+        [
+          "186.58961514320916",
+          "-82.776424293003245",
+          "62.11635039741472",
+          "155.25883895566528"
+        ],
+        [
+          "160.84178285845738",
+          "142.39291318677365",
+          "39.206026274239925",
+          "-63.696349118726602"
+        ]
+      ],
+      "expected": {
+        "full": "0.00000000037697272019965055",
+        "lc": "0.00000000087519841416157061042890812509782050284145301184555807810099927371832930855029765098227958923557633835345622285110757763154209767677161365114426989947253923992595442785129840537386733128249876128990748363",
+        "nlc": "0.000000000376972720199650165192493512405126655433720902066270040431048396855514706382122571138601419955898074209827531747111343906360180628989470751322287030514523880061331437479675271500889757029984635975516199"
+      }
+    }
+  ],
+  "extra_full_colour_cases": [
+    {
+      "id": "extra:identical-u-four-lines",
+      "process": "u u~ > u u~ u u~ u u~",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "87.426649869533108",
+          "-1.7683549991323071",
+          "-13.872238563808319",
+          "86.300944521110353"
+        ],
+        [
+          "271.51948426401049",
+          "188.89524479352281",
+          "-179.52309551815529",
+          "-76.242212749687639"
+        ],
+        [
+          "79.098818575548165",
+          "28.124777996640972",
+          "-16.760518635882654",
+          "72.004895512342586"
+        ],
+        [
+          "127.91723131205379",
+          "120.71852712172512",
+          "-40.699253856211726",
+          "-11.551017775521951"
+        ],
+        [
+          "114.48696971232674",
+          "-72.435438812038697",
+          "70.964759342285447",
+          "-53.144862117707397"
+        ],
+        [
+          "319.55084626652774",
+          "-263.53475610071791",
+          "179.89034723177252",
+          "-17.367747390535968"
+        ]
+      ],
+      "expected": {
+        "full": "0.000000000000016966596563230786"
+      }
+    },
+    {
+      "id": "extra:identical-electron-three-pair",
+      "process": "e+ e- > e+ e- e+ e- e+ e-",
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "87.426649869533108",
+          "-1.7683549991323071",
+          "-13.872238563808319",
+          "86.300944521110353"
+        ],
+        [
+          "271.51948426401049",
+          "188.89524479352281",
+          "-179.52309551815529",
+          "-76.242212749687639"
+        ],
+        [
+          "79.098818575548165",
+          "28.124777996640972",
+          "-16.760518635882654",
+          "72.004895512342586"
+        ],
+        [
+          "127.91723131205379",
+          "120.71852712172512",
+          "-40.699253856211726",
+          "-11.551017775521951"
+        ],
+        [
+          "114.48696971232674",
+          "-72.435438812038697",
+          "70.964759342285447",
+          "-53.144862117707397"
+        ],
+        [
+          "319.55084626652774",
+          "-263.53475610071791",
+          "179.89034723177252",
+          "-17.367747390535968"
+        ]
+      ],
+      "expected": {
+        "full": "0.000000000000000000003588368997450193"
+      }
+    }
+  ]
+}
diff --git a/pyamplicol/tests/fixtures/reference/CAPTURE.toml b/pyamplicol/tests/fixtures/reference/CAPTURE.toml
new file mode 100644
index 0000000000..6b59e73837
--- /dev/null
+++ b/pyamplicol/tests/fixtures/reference/CAPTURE.toml
@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: 0BSD
+schema_version = 2
+fixture_bundle = "reference-fixture-v2.manifest.json"
+captured_utc = "2026-07-16T08:30:24Z"
+memory_watchdog_gb = 30
+
+[source]
+repository = "https://github.com/mg5amcnlo/pyamplicol.git"
+revision = "54045e93070c87caab43063eae7c1807fb4ae70d"
+tree_sha256 = "b1df109c5ff447ffeb26b0fa8d6f09a0b1649e58de638100181498ba45e80e76"
+working_tree_clean = true
+installed_candidate = "0.1.0.dev0+candidate.38e8137f79f7"
+
+[capture]
+tool = "tools/developer/capture_reference_fixture_v2.py"
+artifact_root = ".artifacts/reference-fixture-v2/54045e93070c87caab43063eae7c1807fb4ae70d"
+artifact_mode = "generate"
+legacy_jobs = 5
+command = [
+  "python",
+  "tools/developer/capture_reference_fixture_v2.py",
+  "--generate",
+  "--external-watchdog-gb",
+  "30",
+  "--legacy-jobs",
+  "5",
+]
+
+[evidence.legacy_fortran]
+file = "legacy-fortran-v2.json"
+repository = "https://github.com/rikkert-frederix/AmpliCol.git"
+revision = "58c169b7df58ec8a38c0b748e08548cec20b4530"
+records = 90
+validation_profile = "binary64"
+
+[evidence.analytic]
+file = "analytic-oracles-v2.json"
+implementation = "tools/developer/analytic_oracles.py"
+records = 8
+validation_profile = "high-precision"
+
+[coverage]
+models = ["built-in-sm", "scalars-json", "scalar-gravity-json"]
+builtin_sm_processes = [
+  "d d~ > z",
+  "u d~ > w+",
+  "d d~ > z g",
+  "d d~ > e- e+",
+  "d d~ > u u~",
+  "d d~ > d d~",
+  "g g > g g",
+  "g g > t t~",
+  "d d~ > z g g",
+]
+color_accuracies = ["lc", "nlc", "full"]
+external_processes = [
+  "scalar_0 scalar_0 > scalar_0 scalar_0",
+  "scalar_0 scalar_0 > graviton graviton",
+]
+case_count = 29
+point_count = 38
diff --git a/pyamplicol/tests/fixtures/reference/README.md b/pyamplicol/tests/fixtures/reference/README.md
new file mode 100644
index 0000000000..c9f557de23
--- /dev/null
+++ b/pyamplicol/tests/fixtures/reference/README.md
@@ -0,0 +1,38 @@
+# Clean Reference Fixtures
+
+The release-facing reference bundle consists of:
+
+- `physics-v2.json`: exact model, process, phase-space, topology, resolved-axis,
+  reduction, and high-precision matrix-element records;
+- `legacy-fortran-v2.json`: independent built-in-SM evidence from the pinned
+  Fortran AmpliCol color probe;
+- `analytic-oracles-v2.json`: independent closed-form evidence for the scalar
+  and scalar-gravity cases;
+- `reference-fixture-v2.manifest.json`: the manifest-last atomic commit marker
+  and digest for the other three documents.
+
+Every nondegenerate process has three deterministic generic points and one
+quantified high-precision stress point. Values are recorded against complete
+physical helicity axes and either physical LC flows or one contracted NLC/full
+color component. Structural zeros, normalization, topology, reduction maps,
+input hashes, independent-oracle output hashes, and exact dependency provenance
+are part of the validated contract.
+
+The built-in-SM ladder covers neutral and charged currents, leptons, mixed- and
+same-flavour two-quark-line scattering, pure gluons, top-pair production, and
+the retained one-, two-, and three-body Z ladder in LC, NLC, and full color.
+The external-model slice covers scalar contact and scalar-gravity interactions.
+
+The bundle was captured from the clean installed candidate identified in
+`CAPTURE.toml`. Generated process artifacts are intentionally not committed,
+but remain in the ignored revision-scoped `.artifacts/reference-fixture-v2/`
+directory for retiming and diagnosis.
+
+Run the capture only behind the external 30 GB memory watchdog. The capture
+tool validates both independent evidence sets and all bundle digests before it
+publishes the manifest. CI independently rebuilds the pinned Fortran evidence
+and compares it semantically with the tracked v2 document.
+
+`physics-v1.json` and `legacy-fortran-v1.json` remain solely as focused inputs
+for legacy fixture-reader regression tests. They are not release evidence and
+are not consumed by current generation/runtime integration tests.
diff --git a/pyamplicol/tests/fixtures/reference/analytic-oracles-v2.json b/pyamplicol/tests/fixtures/reference/analytic-oracles-v2.json
new file mode 100644
index 0000000000..4068d73568
--- /dev/null
+++ b/pyamplicol/tests/fixtures/reference/analytic-oracles-v2.json
@@ -0,0 +1,568 @@
+{
+  "captured_at": "2026-07-16T08:30:24Z",
+  "dependency_ids": [
+    "dependency:analytic-oracles"
+  ],
+  "evidence_schema_version": 2,
+  "evidence_set_id": "evidence-set:analytic-oracles",
+  "kind": "pyamplicol-reference-oracle-evidence",
+  "oracle": {
+    "content_sha256": "089eb1fce800160a2144e21312658ddd22f343c75bdd9e1a1f636290123647ef",
+    "id": "oracle:analytic-scalars",
+    "implementation": "tools/developer/analytic_oracles.py Decimal formulas",
+    "independence_statement": "Closed-form scalar formulas consume only captured momenta and model defaults; they do not import generation or runtime evaluators.",
+    "name": "Independent closed-form scalar oracles",
+    "revision": "54045e93070c87caab43063eae7c1807fb4ae70d",
+    "tolerance_ceiling": {
+      "absolute": "0.000000000000001",
+      "relative": "0.000000000001"
+    },
+    "validation_profile": "high-precision"
+  },
+  "records": [
+    {
+      "arithmetic": "analytic",
+      "arithmetic_precision_bits": 333,
+      "case_id": "case:scalars_2to2:lc",
+      "certified_decimal_digits": 12,
+      "color_ids": [
+        "flow:singlet"
+      ],
+      "command": [
+        "tools/developer/analytic_oracles.py",
+        "scalar_contact_2to2",
+        "case=case:scalars_2to2:lc",
+        "point=point:scalars_2to2:generic-1"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "407b10ad06eec811330bb380f4dd8fd6b3c317eeb3532ddbccebb07126ac388c",
+      "helicity_ids": [
+        "h:+0,+0,+0,+0"
+      ],
+      "id": "evidence:analytic:case:scalars_2to2:lc:point:scalars_2to2:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "4a94d68460c1d85be8ca3f23e8a305a7cc88a2d6c46ffe5197e9eef20c765d9d",
+      "observed_helicity_totals": null,
+      "observed_total": "0.5",
+      "observed_values": [
+        [
+          "0.5"
+        ]
+      ],
+      "oracle_output_sha256": "dcd1e9621a78ddb55f07befcae557d301c4028c2ded7682de79af7c30e991bcd",
+      "physics_case_sha256": "6c7aab7fe96336599c451077935929599de9073a62146baea8c6a89c52661eca",
+      "point_id": "point:scalars_2to2:generic-1",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "scalar_0 scalar_0 > scalar_0 scalar_0",
+        "ordered_color_legs": [],
+        "ordered_external_leg_ids": [
+          "leg:incoming-scalar_0-1",
+          "leg:incoming-scalar_0-2",
+          "leg:outgoing-scalar_0-1",
+          "leg:outgoing-scalar_0-2"
+        ],
+        "ordered_external_pdgs": [
+          1000,
+          1000,
+          1000,
+          1000
+        ],
+        "row_id": null,
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 100,
+      "tolerances": {
+        "absolute": "0.000000000000001",
+        "relative": "0.000000000001"
+      }
+    },
+    {
+      "arithmetic": "analytic",
+      "arithmetic_precision_bits": 333,
+      "case_id": "case:scalars_2to2:lc",
+      "certified_decimal_digits": 12,
+      "color_ids": [
+        "flow:singlet"
+      ],
+      "command": [
+        "tools/developer/analytic_oracles.py",
+        "scalar_contact_2to2",
+        "case=case:scalars_2to2:lc",
+        "point=point:scalars_2to2:generic-2"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "3b82d21faf8b40ad57a791b5ea65c7aeada9236833801cb7583893e52efb7d1c",
+      "helicity_ids": [
+        "h:+0,+0,+0,+0"
+      ],
+      "id": "evidence:analytic:case:scalars_2to2:lc:point:scalars_2to2:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "d3e5490b2206e81186e35dbf1d29bd05f35fe481a90dee45476ff40c43426c50",
+      "observed_helicity_totals": null,
+      "observed_total": "0.5",
+      "observed_values": [
+        [
+          "0.5"
+        ]
+      ],
+      "oracle_output_sha256": "5e42e72679d7ac0cb61e45f4cf2088c569f938b85b18b176faf3577b8dc00f85",
+      "physics_case_sha256": "6c7aab7fe96336599c451077935929599de9073a62146baea8c6a89c52661eca",
+      "point_id": "point:scalars_2to2:generic-2",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "scalar_0 scalar_0 > scalar_0 scalar_0",
+        "ordered_color_legs": [],
+        "ordered_external_leg_ids": [
+          "leg:incoming-scalar_0-1",
+          "leg:incoming-scalar_0-2",
+          "leg:outgoing-scalar_0-1",
+          "leg:outgoing-scalar_0-2"
+        ],
+        "ordered_external_pdgs": [
+          1000,
+          1000,
+          1000,
+          1000
+        ],
+        "row_id": null,
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 100,
+      "tolerances": {
+        "absolute": "0.000000000000001",
+        "relative": "0.000000000001"
+      }
+    },
+    {
+      "arithmetic": "analytic",
+      "arithmetic_precision_bits": 333,
+      "case_id": "case:scalars_2to2:lc",
+      "certified_decimal_digits": 12,
+      "color_ids": [
+        "flow:singlet"
+      ],
+      "command": [
+        "tools/developer/analytic_oracles.py",
+        "scalar_contact_2to2",
+        "case=case:scalars_2to2:lc",
+        "point=point:scalars_2to2:generic-3"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "7755c0e119c47854195d85ae56879391ea102fd973b086160b7743abf09c38c7",
+      "helicity_ids": [
+        "h:+0,+0,+0,+0"
+      ],
+      "id": "evidence:analytic:case:scalars_2to2:lc:point:scalars_2to2:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "279100e04553b34e67f299af4c92f10ef737dccdd8586d68259214856cd630d0",
+      "observed_helicity_totals": null,
+      "observed_total": "0.5",
+      "observed_values": [
+        [
+          "0.5"
+        ]
+      ],
+      "oracle_output_sha256": "2e8f6dc5e31e28d606cd01f71fb81930adea4d2d180ddd7f98abd91549c60890",
+      "physics_case_sha256": "6c7aab7fe96336599c451077935929599de9073a62146baea8c6a89c52661eca",
+      "point_id": "point:scalars_2to2:generic-3",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "scalar_0 scalar_0 > scalar_0 scalar_0",
+        "ordered_color_legs": [],
+        "ordered_external_leg_ids": [
+          "leg:incoming-scalar_0-1",
+          "leg:incoming-scalar_0-2",
+          "leg:outgoing-scalar_0-1",
+          "leg:outgoing-scalar_0-2"
+        ],
+        "ordered_external_pdgs": [
+          1000,
+          1000,
+          1000,
+          1000
+        ],
+        "row_id": null,
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 100,
+      "tolerances": {
+        "absolute": "0.000000000000001",
+        "relative": "0.000000000001"
+      }
+    },
+    {
+      "arithmetic": "analytic",
+      "arithmetic_precision_bits": 333,
+      "case_id": "case:scalars_2to2:lc",
+      "certified_decimal_digits": 12,
+      "color_ids": [
+        "flow:singlet"
+      ],
+      "command": [
+        "tools/developer/analytic_oracles.py",
+        "scalar_contact_2to2",
+        "case=case:scalars_2to2:lc",
+        "point=point:scalars_2to2:stress-near-collinear"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "fdf3d29e1c6332dff190eb391e1d5f94437e33495834d186991f8780c6d64cbc",
+      "helicity_ids": [
+        "h:+0,+0,+0,+0"
+      ],
+      "id": "evidence:analytic:case:scalars_2to2:lc:point:scalars_2to2:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "c952531ebc6a62c8c1e70a0f39c19fce040468dbe56c7f9f406cb7bd67af0d0c",
+      "observed_helicity_totals": null,
+      "observed_total": "0.5",
+      "observed_values": [
+        [
+          "0.5"
+        ]
+      ],
+      "oracle_output_sha256": "2e1ccda21a5ea249a4fe6ec98c0b5b0440722530526fe0ea851ff8290b0f6999",
+      "physics_case_sha256": "6c7aab7fe96336599c451077935929599de9073a62146baea8c6a89c52661eca",
+      "point_id": "point:scalars_2to2:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "scalar_0 scalar_0 > scalar_0 scalar_0",
+        "ordered_color_legs": [],
+        "ordered_external_leg_ids": [
+          "leg:incoming-scalar_0-1",
+          "leg:incoming-scalar_0-2",
+          "leg:outgoing-scalar_0-1",
+          "leg:outgoing-scalar_0-2"
+        ],
+        "ordered_external_pdgs": [
+          1000,
+          1000,
+          1000,
+          1000
+        ],
+        "row_id": null,
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 100,
+      "tolerances": {
+        "absolute": "0.000000000000001",
+        "relative": "0.000000000001"
+      }
+    },
+    {
+      "arithmetic": "analytic",
+      "arithmetic_precision_bits": 333,
+      "case_id": "case:scalar_gravity_2to2:lc",
+      "certified_decimal_digits": 12,
+      "color_ids": [
+        "flow:singlet"
+      ],
+      "command": [
+        "tools/developer/analytic_oracles.py",
+        "scalar_gravity_2to2",
+        "case=case:scalar_gravity_2to2:lc",
+        "point=point:scalar_gravity_2to2:generic-1"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "f42628d6a7b442331bcf25a6bb00b7efb7a96f7e08d4d4d40ade9fcbeba006b4",
+      "helicity_ids": [
+        "h:+0,+0,-2,-2",
+        "h:+0,+0,-2,+2",
+        "h:+0,+0,+2,-2",
+        "h:+0,+0,+2,+2"
+      ],
+      "id": "evidence:analytic:case:scalar_gravity_2to2:lc:point:scalar_gravity_2to2:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "4f236f91d069ceca8d8f1bf83d8954fb32e9bed80e22024f3b2c1031756c3bd9",
+      "observed_helicity_totals": null,
+      "observed_total": "2743669908.184639318638142032821703315049439062061889915248831052018262890773100820174156360043279541",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "1371834954.09231965931907101641085165752471953103094495762441552600913144538655041008707818002163977"
+        ],
+        [
+          "1371834954.09231965931907101641085165752471953103094495762441552600913144538655041008707818002163977"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "94781f9c11685c8369617a1840ab4f763ea4da0e512795083afaf7d81d799a2d",
+      "physics_case_sha256": "f34ef0ce85a69fc7f40ac6c3bea4eba7dacbd383e3b4507505ec0028e700143e",
+      "point_id": "point:scalar_gravity_2to2:generic-1",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "scalar_0 scalar_0 > graviton graviton",
+        "ordered_color_legs": [],
+        "ordered_external_leg_ids": [
+          "leg:incoming-scalar_0-1",
+          "leg:incoming-scalar_0-2",
+          "leg:outgoing-graviton-1",
+          "leg:outgoing-graviton-2"
+        ],
+        "ordered_external_pdgs": [
+          2000,
+          2000,
+          1337,
+          1337
+        ],
+        "row_id": null,
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 100,
+      "tolerances": {
+        "absolute": "0.000000000000001",
+        "relative": "0.000000000001"
+      }
+    },
+    {
+      "arithmetic": "analytic",
+      "arithmetic_precision_bits": 333,
+      "case_id": "case:scalar_gravity_2to2:lc",
+      "certified_decimal_digits": 12,
+      "color_ids": [
+        "flow:singlet"
+      ],
+      "command": [
+        "tools/developer/analytic_oracles.py",
+        "scalar_gravity_2to2",
+        "case=case:scalar_gravity_2to2:lc",
+        "point=point:scalar_gravity_2to2:generic-2"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "b34edd33e9f66e14766f6fc57800b22b54f9bb2d48b0759a907a7d958d19f726",
+      "helicity_ids": [
+        "h:+0,+0,-2,-2",
+        "h:+0,+0,-2,+2",
+        "h:+0,+0,+2,-2",
+        "h:+0,+0,+2,+2"
+      ],
+      "id": "evidence:analytic:case:scalar_gravity_2to2:lc:point:scalar_gravity_2to2:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "9399cdbe88cbe7a5f89d58ce8f6fc7322cdca18c4f2f930cfe89412d36ed4ab2",
+      "observed_helicity_totals": null,
+      "observed_total": "2373424789.808567548632738845845699652078622579654373087863029936866673188711710756796479496175387764",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "1186712394.904283774316369422922849826039311289827186543931514968433336594355855378398239748087693882"
+        ],
+        [
+          "1186712394.904283774316369422922849826039311289827186543931514968433336594355855378398239748087693882"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "678ce97b2ad8d686c31183083b0ef3be072cf5afe0d5801a6517168bacbf8686",
+      "physics_case_sha256": "f34ef0ce85a69fc7f40ac6c3bea4eba7dacbd383e3b4507505ec0028e700143e",
+      "point_id": "point:scalar_gravity_2to2:generic-2",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "scalar_0 scalar_0 > graviton graviton",
+        "ordered_color_legs": [],
+        "ordered_external_leg_ids": [
+          "leg:incoming-scalar_0-1",
+          "leg:incoming-scalar_0-2",
+          "leg:outgoing-graviton-1",
+          "leg:outgoing-graviton-2"
+        ],
+        "ordered_external_pdgs": [
+          2000,
+          2000,
+          1337,
+          1337
+        ],
+        "row_id": null,
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 100,
+      "tolerances": {
+        "absolute": "0.000000000000001",
+        "relative": "0.000000000001"
+      }
+    },
+    {
+      "arithmetic": "analytic",
+      "arithmetic_precision_bits": 333,
+      "case_id": "case:scalar_gravity_2to2:lc",
+      "certified_decimal_digits": 12,
+      "color_ids": [
+        "flow:singlet"
+      ],
+      "command": [
+        "tools/developer/analytic_oracles.py",
+        "scalar_gravity_2to2",
+        "case=case:scalar_gravity_2to2:lc",
+        "point=point:scalar_gravity_2to2:generic-3"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "1134177a2c106806558a7423210aa048ec82978eaf904ae198388b6c77c4f1e6",
+      "helicity_ids": [
+        "h:+0,+0,-2,-2",
+        "h:+0,+0,-2,+2",
+        "h:+0,+0,+2,-2",
+        "h:+0,+0,+2,+2"
+      ],
+      "id": "evidence:analytic:case:scalar_gravity_2to2:lc:point:scalar_gravity_2to2:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "80712a181baf34040d3b2cc4560101a06ee601fa801be0f0c24d1619ea938d38",
+      "observed_helicity_totals": null,
+      "observed_total": "2887822815.354558927617123212371712726562866000574361481260754141281104310045653472058674492333223616",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "1443911407.677279463808561606185856363281433000287180740630377070640552155022826736029337246166611808"
+        ],
+        [
+          "1443911407.677279463808561606185856363281433000287180740630377070640552155022826736029337246166611808"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "3e9417e0f4fb6077512f4f183aea24d0e5f9288181808192268086097680b462",
+      "physics_case_sha256": "f34ef0ce85a69fc7f40ac6c3bea4eba7dacbd383e3b4507505ec0028e700143e",
+      "point_id": "point:scalar_gravity_2to2:generic-3",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "scalar_0 scalar_0 > graviton graviton",
+        "ordered_color_legs": [],
+        "ordered_external_leg_ids": [
+          "leg:incoming-scalar_0-1",
+          "leg:incoming-scalar_0-2",
+          "leg:outgoing-graviton-1",
+          "leg:outgoing-graviton-2"
+        ],
+        "ordered_external_pdgs": [
+          2000,
+          2000,
+          1337,
+          1337
+        ],
+        "row_id": null,
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 100,
+      "tolerances": {
+        "absolute": "0.000000000000001",
+        "relative": "0.000000000001"
+      }
+    },
+    {
+      "arithmetic": "analytic",
+      "arithmetic_precision_bits": 333,
+      "case_id": "case:scalar_gravity_2to2:lc",
+      "certified_decimal_digits": 12,
+      "color_ids": [
+        "flow:singlet"
+      ],
+      "command": [
+        "tools/developer/analytic_oracles.py",
+        "scalar_gravity_2to2",
+        "case=case:scalar_gravity_2to2:lc",
+        "point=point:scalar_gravity_2to2:stress-near-collinear"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "b7efb4934037768650f2d4f25024f0bb332183f555b63ce48ff4058a02653037",
+      "helicity_ids": [
+        "h:+0,+0,-2,-2",
+        "h:+0,+0,-2,+2",
+        "h:+0,+0,+2,-2",
+        "h:+0,+0,+2,+2"
+      ],
+      "id": "evidence:analytic:case:scalar_gravity_2to2:lc:point:scalar_gravity_2to2:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "22ce5ac27dba01f1e684c4e1eabf0e1082a38079e4cc5c315c3d150cee22d3e9",
+      "observed_helicity_totals": null,
+      "observed_total": "0.06249999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999997",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0.03124999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999998"
+        ],
+        [
+          "0.03124999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999998"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "6bedd892437584afbacd001c03af24ba446c5c62806c202584dc41efdebe30cf",
+      "physics_case_sha256": "f34ef0ce85a69fc7f40ac6c3bea4eba7dacbd383e3b4507505ec0028e700143e",
+      "point_id": "point:scalar_gravity_2to2:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "scalar_0 scalar_0 > graviton graviton",
+        "ordered_color_legs": [],
+        "ordered_external_leg_ids": [
+          "leg:incoming-scalar_0-1",
+          "leg:incoming-scalar_0-2",
+          "leg:outgoing-graviton-1",
+          "leg:outgoing-graviton-2"
+        ],
+        "ordered_external_pdgs": [
+          2000,
+          2000,
+          1337,
+          1337
+        ],
+        "row_id": null,
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 100,
+      "tolerances": {
+        "absolute": "0.000000000000001",
+        "relative": "0.000000000001"
+      }
+    }
+  ]
+}
diff --git a/pyamplicol/tests/fixtures/reference/legacy-fortran-v1.json b/pyamplicol/tests/fixtures/reference/legacy-fortran-v1.json
new file mode 100644
index 0000000000..3ce4a2c3e3
--- /dev/null
+++ b/pyamplicol/tests/fixtures/reference/legacy-fortran-v1.json
@@ -0,0 +1,221 @@
+{
+  "cases": {
+    "builtin_sm_ddbar_z_full": {
+      "color_accuracy": "full",
+      "fortran_process_entry": {
+        "color_order": [
+          2,
+          1,
+          3
+        ],
+        "exact_external_order": true,
+        "group": 1,
+        "integral": 1,
+        "matching_row_count": 1,
+        "process_pdgs": [
+          1,
+          -1,
+          23
+        ],
+        "source_to_row_permutation": [
+          0,
+          1,
+          2
+        ]
+      },
+      "fortran_topology": {
+        "amplitudes": 1,
+        "color_orders": 1,
+        "currents": 4,
+        "vertices": 1
+      },
+      "max_resolved_relative_difference": 0.0,
+      "process": "d d~ > z",
+      "total": 142.1065337287299
+    },
+    "builtin_sm_ddbar_z_lc": {
+      "color_accuracy": "lc",
+      "fortran_process_entry": {
+        "color_order": [
+          2,
+          1,
+          3
+        ],
+        "exact_external_order": true,
+        "group": 1,
+        "integral": 1,
+        "matching_row_count": 1,
+        "process_pdgs": [
+          1,
+          -1,
+          23
+        ],
+        "source_to_row_permutation": [
+          0,
+          1,
+          2
+        ]
+      },
+      "fortran_topology": {
+        "amplitudes": 1,
+        "color_orders": 1,
+        "currents": 4,
+        "vertices": 1
+      },
+      "max_resolved_relative_difference": 2.1284067746028536e-16,
+      "process": "d d~ > z",
+      "total": 142.1065337287299
+    },
+    "builtin_sm_ddbar_z_nlc": {
+      "color_accuracy": "nlc",
+      "fortran_process_entry": {
+        "color_order": [
+          2,
+          1,
+          3
+        ],
+        "exact_external_order": true,
+        "group": 1,
+        "integral": 1,
+        "matching_row_count": 1,
+        "process_pdgs": [
+          1,
+          -1,
+          23
+        ],
+        "source_to_row_permutation": [
+          0,
+          1,
+          2
+        ]
+      },
+      "fortran_topology": {
+        "amplitudes": 1,
+        "color_orders": 1,
+        "currents": 4,
+        "vertices": 1
+      },
+      "max_resolved_relative_difference": 0.0,
+      "process": "d d~ > z",
+      "total": 142.1065337287299
+    },
+    "builtin_sm_ddbar_zg_full": {
+      "color_accuracy": "full",
+      "fortran_process_entry": {
+        "color_order": [
+          2,
+          3,
+          1,
+          4
+        ],
+        "exact_external_order": false,
+        "group": 1,
+        "integral": 1,
+        "matching_row_count": 1,
+        "process_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "fortran_topology": {
+        "amplitudes": 1,
+        "color_orders": 1,
+        "currents": 7,
+        "vertices": 4
+      },
+      "max_resolved_relative_difference": 8.809602410999885e-14,
+      "process": "d d~ > z g",
+      "total": 0.36154106787336965
+    },
+    "builtin_sm_ddbar_zg_lc": {
+      "color_accuracy": "lc",
+      "fortran_process_entry": {
+        "color_order": [
+          2,
+          3,
+          1,
+          4
+        ],
+        "exact_external_order": false,
+        "group": 1,
+        "integral": 1,
+        "matching_row_count": 1,
+        "process_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "fortran_topology": {
+        "amplitudes": 1,
+        "color_orders": 1,
+        "currents": 7,
+        "vertices": 4
+      },
+      "max_resolved_relative_difference": 8.826279974905955e-14,
+      "process": "d d~ > z g",
+      "total": 0.4067337013575408
+    },
+    "builtin_sm_ddbar_zg_nlc": {
+      "color_accuracy": "nlc",
+      "fortran_process_entry": {
+        "color_order": [
+          2,
+          3,
+          1,
+          4
+        ],
+        "exact_external_order": false,
+        "group": 1,
+        "integral": 1,
+        "matching_row_count": 1,
+        "process_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "fortran_topology": {
+        "amplitudes": 1,
+        "color_orders": 1,
+        "currents": 7,
+        "vertices": 4
+      },
+      "max_resolved_relative_difference": 8.809602410999885e-14,
+      "process": "d d~ > z g",
+      "total": 0.36154106787336965
+    }
+  },
+  "fixture": "physics-v1.json",
+  "fixture_sha256": "43173e8e527676fe9b26467e9f0b6b0d26cd323ecebcac69f56ce64a8b1a85ac",
+  "oracle": "legacy-fortran-amplicol-color-probe",
+  "patches": [],
+  "revision": "f3fdca35631c9405d28337a79cdab84994d8e414",
+  "schema_version": 1,
+  "tolerances": {
+    "absolute": 1e-15,
+    "relative": 1e-08
+  }
+}
diff --git a/pyamplicol/tests/fixtures/reference/legacy-fortran-v2.json b/pyamplicol/tests/fixtures/reference/legacy-fortran-v2.json
new file mode 100644
index 0000000000..5e63276cca
--- /dev/null
+++ b/pyamplicol/tests/fixtures/reference/legacy-fortran-v2.json
@@ -0,0 +1,13612 @@
+{
+  "captured_at": "2026-07-16T08:30:24Z",
+  "dependency_ids": [
+    "dependency:legacy-amplicol"
+  ],
+  "evidence_schema_version": 2,
+  "evidence_set_id": "evidence-set:legacy-fortran-amplicol",
+  "kind": "pyamplicol-reference-oracle-evidence",
+  "oracle": {
+    "content_sha256": "ed18d0240cc7b1ea821708209afbfa40a8fcec63d62bd72cfa8c6f2f1cbf1990",
+    "id": "oracle:legacy-fortran-amplicol",
+    "implementation": "independent amplicol_color_probe executable",
+    "independence_statement": "The pinned Fortran implementation is built and executed outside the pyAmpliCol generation and Rusticol runtime code paths.",
+    "name": "Pinned legacy Fortran AmpliCol",
+    "revision": "58c169b7df58ec8a38c0b748e08548cec20b4530",
+    "tolerance_ceiling": {
+      "absolute": "0.000000000001",
+      "relative": "0.0000000001"
+    },
+    "validation_profile": "binary64"
+  },
+  "records": [
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=2419a02fba45bc751964d3f42ee9f24babc3219149ab385f266426f3702fdd11",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:full",
+        "point=point:sm_ddbar_ddbar:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "3b373bd58af8b58af7bbddf3d1904c039d64d992cc8fa1e6a40284684399dea0",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:full:point:sm_ddbar_ddbar:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "23303b063d14dfedddfd8a64601361414e2a30c0f3add940083aae609265d0ba",
+      "observed_helicity_totals": null,
+      "observed_total": "20.796297712640072",
+      "observed_values": [
+        [
+          "6.2545202620747435"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "4.1054562832025754"
+        ],
+        [
+          "0.03817231104271715"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.03817231104271715"
+        ],
+        [
+          "4.1054562832025754"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "6.2545202620747435"
+        ]
+      ],
+      "oracle_output_sha256": "ca6534864f708cc779b0179dd8bdedf44736499df864a496cdeb3c6637c24f6e",
+      "physics_case_sha256": "b9ecb96d6bdb1843b2d20ad95411d1931efc5c3b8a37e673e26edad85d421e15",
+      "point_id": "point:sm_ddbar_ddbar:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=0c88c540279d83837f75edc57dd3320917283ad5176936c634f9952bf367c055",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:full",
+        "point=point:sm_ddbar_ddbar:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "1aab6a91ca166f595f3df5b1552debb8667dc6721d3995173b272b4af47a611d",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:full:point:sm_ddbar_ddbar:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "a0d4a5d793f42434151b6f578a89d87af1f23b18b3d4058ee380e1733c15f0f5",
+      "observed_helicity_totals": null,
+      "observed_total": "11.398602456595007",
+      "observed_values": [
+        [
+          "3.6281562008441126"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "2.0053403929088955"
+        ],
+        [
+          "0.065804634544496046"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.065804634544496046"
+        ],
+        [
+          "2.0053403929088955"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "3.6281562008441126"
+        ]
+      ],
+      "oracle_output_sha256": "a8a8e51e7e13d5a05407a065ba3c921010810724ff930e90fa02be963d02e5b0",
+      "physics_case_sha256": "b9ecb96d6bdb1843b2d20ad95411d1931efc5c3b8a37e673e26edad85d421e15",
+      "point_id": "point:sm_ddbar_ddbar:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=25d252542c89572965dcb561d7b9257aa6a129f27eef0ce88d7f13b69afff984",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:full",
+        "point=point:sm_ddbar_ddbar:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "bdac20183563fcd212b17ba89d71fa9c0c24f071e39d3bc56ec77cbac335399e",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:full:point:sm_ddbar_ddbar:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "78ae4e2a9fe09d19d2243b8bbbc30b10be5ad26f04d3643241fc5f3e7b39460e",
+      "observed_helicity_totals": null,
+      "observed_total": "60.852321844547291",
+      "observed_values": [
+        [
+          "17.013547944460015"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "13.398580073351484"
+        ],
+        [
+          "0.014032904462154574"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.014032904462154574"
+        ],
+        [
+          "13.398580073351484"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "17.013547944460015"
+        ]
+      ],
+      "oracle_output_sha256": "2be33124a6b8a0b0f2af0712fb5ea580c300927c5bf144f79984f816b0a4c4e2",
+      "physics_case_sha256": "b9ecb96d6bdb1843b2d20ad95411d1931efc5c3b8a37e673e26edad85d421e15",
+      "point_id": "point:sm_ddbar_ddbar:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:full",
+        "point=point:sm_ddbar_ddbar:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "f26ad4796f0cf4ae92fa200396fb28338286197c51a392ddff0344191349a1df",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:full:point:sm_ddbar_ddbar:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "08d252c0bc0830beabb8e90d2b9b25a92a8761a1a067a92ba696f3d089fbd9e4",
+      "observed_helicity_totals": null,
+      "observed_total": "1954474740806.3025",
+      "observed_values": [
+        [
+          "488619010947.74573"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "488618359455.4054"
+        ],
+        [
+          "0.00000000000048862096542746837"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000000000048862096542746837"
+        ],
+        [
+          "488618359455.4054"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "488619010947.74573"
+        ]
+      ],
+      "oracle_output_sha256": "c95a6eb7814c80eb876eeb2a748638726522f830c925e93a4e7da0df1ae871f2",
+      "physics_case_sha256": "b9ecb96d6bdb1843b2d20ad95411d1931efc5c3b8a37e673e26edad85d421e15",
+      "point_id": "point:sm_ddbar_ddbar:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1,3,4",
+        "flow:2,4,3,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=2419a02fba45bc751964d3f42ee9f24babc3219149ab385f266426f3702fdd11",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:lc",
+        "point=point:sm_ddbar_ddbar:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "ba1381c21560bfb8c7ea4af5d686e1ef168692d66437afa797dd746eff5536a7",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:lc:point:sm_ddbar_ddbar:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "23303b063d14dfedddfd8a64601361414e2a30c0f3add940083aae609265d0ba",
+      "observed_helicity_totals": [
+        "7.8181503275934281",
+        "0",
+        "0",
+        "0",
+        "0",
+        "5.7368185107623741",
+        "0.047715388803396437",
+        "0",
+        "0",
+        "0.047715388803396437",
+        "5.7368185107623741",
+        "0",
+        "0",
+        "0",
+        "0",
+        "7.8181503275934281"
+      ],
+      "observed_total": "27.205368454318396",
+      "observed_values": null,
+      "oracle_output_sha256": "88bdb8894168edad81c37394255418fe179b545c0b4cbbc2687c1ac939cab93b",
+      "physics_case_sha256": "20eb3171d3d5c325bbe9796eb8904926179d2fdee0f721b539d47e2d7cdd222d",
+      "point_id": "point:sm_ddbar_ddbar:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1,3,4",
+        "flow:2,4,3,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=0c88c540279d83837f75edc57dd3320917283ad5176936c634f9952bf367c055",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:lc",
+        "point=point:sm_ddbar_ddbar:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "c4e19382a8ee99a924476f4e311f4ec05573dc3642d7043a32cfcbfedcc7c409",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:lc:point:sm_ddbar_ddbar:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "a0d4a5d793f42434151b6f578a89d87af1f23b18b3d4058ee380e1733c15f0f5",
+      "observed_helicity_totals": [
+        "4.5351952510551392",
+        "0",
+        "0",
+        "0",
+        "0",
+        "2.8623657241776885",
+        "0.082255793180620054",
+        "0",
+        "0",
+        "0.082255793180620054",
+        "2.8623657241776885",
+        "0",
+        "0",
+        "0",
+        "0",
+        "4.5351952510551392"
+      ],
+      "observed_total": "14.959633536826892",
+      "observed_values": null,
+      "oracle_output_sha256": "7cae582c98deb0367df5441e3518a0a04e91487f6b9a8fb1b41f8cec3607fd15",
+      "physics_case_sha256": "20eb3171d3d5c325bbe9796eb8904926179d2fdee0f721b539d47e2d7cdd222d",
+      "point_id": "point:sm_ddbar_ddbar:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1,3,4",
+        "flow:2,4,3,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=25d252542c89572965dcb561d7b9257aa6a129f27eef0ce88d7f13b69afff984",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:lc",
+        "point=point:sm_ddbar_ddbar:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "e3f933f48074f244055db3f48f93748220c3bba8372a08ce8bcd7a68f208aea5",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:lc:point:sm_ddbar_ddbar:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "78ae4e2a9fe09d19d2243b8bbbc30b10be5ad26f04d3643241fc5f3e7b39460e",
+      "observed_helicity_totals": [
+        "21.266934930575019",
+        "0",
+        "0",
+        "0",
+        "0",
+        "18.074105491276406",
+        "0.017541130577693218",
+        "0",
+        "0",
+        "0.017541130577693218",
+        "18.074105491276406",
+        "0",
+        "0",
+        "0",
+        "0",
+        "21.266934930575019"
+      ],
+      "observed_total": "78.717163104858258",
+      "observed_values": null,
+      "oracle_output_sha256": "da0e3a260b2e1374a0ff066328dad0f8eab57af455481bdb8833335f52e5869f",
+      "physics_case_sha256": "20eb3171d3d5c325bbe9796eb8904926179d2fdee0f721b539d47e2d7cdd222d",
+      "point_id": "point:sm_ddbar_ddbar:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1,3,4",
+        "flow:2,4,3,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:lc",
+        "point=point:sm_ddbar_ddbar:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "a3ad15a704429b817e0c8c1765d7a36ce96dd352821ca8d41d45810675020113",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:lc:point:sm_ddbar_ddbar:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "08d252c0bc0830beabb8e90d2b9b25a92a8761a1a067a92ba696f3d089fbd9e4",
+      "observed_helicity_totals": [
+        "610773763684.68225",
+        "0",
+        "0",
+        "0",
+        "0",
+        "610773275064.93835",
+        "0.00000000000061077620677731177",
+        "0",
+        "0",
+        "0.00000000000061077620677731177",
+        "610773275064.93835",
+        "0",
+        "0",
+        "0",
+        "0",
+        "610773763684.68225"
+      ],
+      "observed_total": "2443094077499.2412",
+      "observed_values": null,
+      "oracle_output_sha256": "2a86025f07c6ab00dc13e0b3d60a355c5ecb50cb56957d65aafa86ea5a610279",
+      "physics_case_sha256": "20eb3171d3d5c325bbe9796eb8904926179d2fdee0f721b539d47e2d7cdd222d",
+      "point_id": "point:sm_ddbar_ddbar:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=2419a02fba45bc751964d3f42ee9f24babc3219149ab385f266426f3702fdd11",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:nlc",
+        "point=point:sm_ddbar_ddbar:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "67c6817a25cb89a6a39540df27149369ca69bcf366a37ef73654e183339dc5b9",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:nlc:point:sm_ddbar_ddbar:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "23303b063d14dfedddfd8a64601361414e2a30c0f3add940083aae609265d0ba",
+      "observed_helicity_totals": null,
+      "observed_total": "20.796297712640072",
+      "observed_values": [
+        [
+          "6.2545202620747435"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "4.1054562832025754"
+        ],
+        [
+          "0.03817231104271715"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.03817231104271715"
+        ],
+        [
+          "4.1054562832025754"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "6.2545202620747435"
+        ]
+      ],
+      "oracle_output_sha256": "1f0d00b440b589fabfb900da124930a2da1b700c8036a2cb94b0d538c4bc8e9f",
+      "physics_case_sha256": "e63ec6fdb854a9e24a5a21f6110f376a6b6e00329a2bd741d29bc4ac60dec606",
+      "point_id": "point:sm_ddbar_ddbar:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=0c88c540279d83837f75edc57dd3320917283ad5176936c634f9952bf367c055",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:nlc",
+        "point=point:sm_ddbar_ddbar:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "ff3a3af95ddc51fedae005ed125ee5629796f2263b0dfd420e3213f43b8e4823",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:nlc:point:sm_ddbar_ddbar:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "a0d4a5d793f42434151b6f578a89d87af1f23b18b3d4058ee380e1733c15f0f5",
+      "observed_helicity_totals": null,
+      "observed_total": "11.398602456595007",
+      "observed_values": [
+        [
+          "3.6281562008441126"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "2.0053403929088955"
+        ],
+        [
+          "0.065804634544496046"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.065804634544496046"
+        ],
+        [
+          "2.0053403929088955"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "3.6281562008441126"
+        ]
+      ],
+      "oracle_output_sha256": "758505a57bfa50a84fe2a184b35acfe5a1049ef04a9619886ae83efca3d2e4e4",
+      "physics_case_sha256": "e63ec6fdb854a9e24a5a21f6110f376a6b6e00329a2bd741d29bc4ac60dec606",
+      "point_id": "point:sm_ddbar_ddbar:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=25d252542c89572965dcb561d7b9257aa6a129f27eef0ce88d7f13b69afff984",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:nlc",
+        "point=point:sm_ddbar_ddbar:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "ff160c8cbbd880f5cb09dad17046c1235f865d0b501a11896ec4ec2093c2270c",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:nlc:point:sm_ddbar_ddbar:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "78ae4e2a9fe09d19d2243b8bbbc30b10be5ad26f04d3643241fc5f3e7b39460e",
+      "observed_helicity_totals": null,
+      "observed_total": "60.852321844547291",
+      "observed_values": [
+        [
+          "17.013547944460015"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "13.398580073351484"
+        ],
+        [
+          "0.014032904462154574"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.014032904462154574"
+        ],
+        [
+          "13.398580073351484"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "17.013547944460015"
+        ]
+      ],
+      "oracle_output_sha256": "cc6f62cd5b22304fdc05a2912ee453382cdd9fdede0a5b3aa7bfc074cb669b45",
+      "physics_case_sha256": "e63ec6fdb854a9e24a5a21f6110f376a6b6e00329a2bd741d29bc4ac60dec606",
+      "point_id": "point:sm_ddbar_ddbar:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ddbar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > d d~",
+        "case=case:sm_ddbar_ddbar:nlc",
+        "point=point:sm_ddbar_ddbar:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "203c37e4784a42ebe9d3c2f701a0f82c107b1596ddaf11597b14a3b3d9c582f2",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ddbar:nlc:point:sm_ddbar_ddbar:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "08d252c0bc0830beabb8e90d2b9b25a92a8761a1a067a92ba696f3d089fbd9e4",
+      "observed_helicity_totals": null,
+      "observed_total": "1954474740806.3025",
+      "observed_values": [
+        [
+          "488619010947.74573"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "488618359455.4054"
+        ],
+        [
+          "0.00000000000048862096542746837"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000000000048862096542746837"
+        ],
+        [
+          "488618359455.4054"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "488619010947.74573"
+        ]
+      ],
+      "oracle_output_sha256": "559b1ae4a831cfbca6b2bbac3f233426d4ac3f512deb37b5f9a4ec179769a3ed",
+      "physics_case_sha256": "e63ec6fdb854a9e24a5a21f6110f376a6b6e00329a2bd741d29bc4ac60dec606",
+      "point_id": "point:sm_ddbar_ddbar:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > d d~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-d",
+          "leg:outgoing-dbar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          1,
+          -1
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=f825b4df6a74e42b804053b9c177c1ffe989c347de04b689134f38254b3a95ad",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:full",
+        "point=point:sm_ddbar_ee:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "a28f839983c6381f566b5b45351cc8b9f332a9f8e5739a44e0183535587ddabf",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:full:point:sm_ddbar_ee:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "99b07a562fe6881d561705d35b4f6f5afcb738a547f46f5f6d118b46d2655168",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0010319707037125029",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00082062602145063725"
+        ],
+        [
+          "0.000034317817325785194"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.000032587346469362543"
+        ],
+        [
+          "0.00014443951846671805"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "ef1da0c492b178fc9e00df585028dcc5514b8e7a93508c377158a80c5422b263",
+      "physics_case_sha256": "dd5047097a5d2663674b5785faa9c998258bcfdaa3a51f905dab106874e944ea",
+      "point_id": "point:sm_ddbar_ee:generic-1",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=068a8dce7ff6aa9bc83b5d85c64c54876aabd0b28405336704786f99b9ae107c",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:full",
+        "point=point:sm_ddbar_ee:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "ab482cd0745862228bfeec529cfe13462fc429a86183d742f79be5731da8775a",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:full:point:sm_ddbar_ee:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "f7933fed78760aca39b01ca4dff138155cab49e7726947549e97422c221a869a",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0026304340923297403",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0022308617343056824"
+        ],
+        [
+          "0.0000035470834122141319"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000033682222564516122"
+        ],
+        [
+          "0.00039265705235539235"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "6cf8e1ddc6c4b90df0b09617bc08c31c26694a80f8ad6324b9233066f1ec7074",
+      "physics_case_sha256": "dd5047097a5d2663674b5785faa9c998258bcfdaa3a51f905dab106874e944ea",
+      "point_id": "point:sm_ddbar_ee:generic-2",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=661c50875ebea8795170c443ca9c14f4864b26773f797758b7a20dbc8af42bef",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:full",
+        "point=point:sm_ddbar_ee:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "dc0dc25900767aa61eee9a7f2d4613f09a2842d82d170ba77610db6f835801a0",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:full:point:sm_ddbar_ee:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "e1019cc4d6faa63004183d71872a1e2b484a7dc995476b41d4461f567fa798eb",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0021223265191563298",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0017903979982851028"
+        ],
+        [
+          "0.0000086162867492653798"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000081818117659458211"
+        ],
+        [
+          "0.00031513042235601572"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "59422c4081d97599b04364dd18a60f2a34622c47928617a838bde11965692e71",
+      "physics_case_sha256": "dd5047097a5d2663674b5785faa9c998258bcfdaa3a51f905dab106874e944ea",
+      "point_id": "point:sm_ddbar_ee:generic-3",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:full",
+        "point=point:sm_ddbar_ee:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "514ff87aaccef17a4d409541e134fe17c43cab25a6bd4d9e1e5c95aeeede6a85",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:full:point:sm_ddbar_ee:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "3c2dd3d916954ad83254df54d6d46553766b81d72b617b8d892efca0c46a06c3",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0036930177240583704",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0031402908058451727"
+        ],
+        [
+          "0.00000000000000014363181961844104"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000000000000013638920640179538"
+        ],
+        [
+          "0.00055272691821291772"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "35d1350411b5cb8b8632376386aa761b7e37fb35df43cba372b627a795ae1043",
+      "physics_case_sha256": "dd5047097a5d2663674b5785faa9c998258bcfdaa3a51f905dab106874e944ea",
+      "point_id": "point:sm_ddbar_ee:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=f825b4df6a74e42b804053b9c177c1ffe989c347de04b689134f38254b3a95ad",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:lc",
+        "point=point:sm_ddbar_ee:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "583f4872c773327599f80b6a6eda3650ea305f379b661ace59d8bbd09de5511c",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:lc:point:sm_ddbar_ee:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "99b07a562fe6881d561705d35b4f6f5afcb738a547f46f5f6d118b46d2655168",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0010319707037125029",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00082062602145063725"
+        ],
+        [
+          "0.000034317817325785194"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.000032587346469362543"
+        ],
+        [
+          "0.00014443951846671805"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "65fbaa2186c510d0493f86782f49e062cd8adaeec443ca6429955f3ab193acc4",
+      "physics_case_sha256": "37f9baa3ba2ab4fe0dc56b6fa2bd743a1d3731d2714cd8da879bcbf2f59d25cb",
+      "point_id": "point:sm_ddbar_ee:generic-1",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=068a8dce7ff6aa9bc83b5d85c64c54876aabd0b28405336704786f99b9ae107c",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:lc",
+        "point=point:sm_ddbar_ee:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "0aa162e8fb88a99f2dc87e0d6511b511767b7c2f1ebb62cab8096c9f58b31c71",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:lc:point:sm_ddbar_ee:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "f7933fed78760aca39b01ca4dff138155cab49e7726947549e97422c221a869a",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0026304340923297403",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0022308617343056824"
+        ],
+        [
+          "0.0000035470834122141319"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000033682222564516122"
+        ],
+        [
+          "0.00039265705235539241"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "1e0703fd036a1f11efaaa72d3ffd4bb5cbfcbbf8712ba645f0d0535fc46abd83",
+      "physics_case_sha256": "37f9baa3ba2ab4fe0dc56b6fa2bd743a1d3731d2714cd8da879bcbf2f59d25cb",
+      "point_id": "point:sm_ddbar_ee:generic-2",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=661c50875ebea8795170c443ca9c14f4864b26773f797758b7a20dbc8af42bef",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:lc",
+        "point=point:sm_ddbar_ee:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "3b3b83950803239bb25db811c8cc4822d027176d62b50e27c5c6c84b1fec6037",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:lc:point:sm_ddbar_ee:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "e1019cc4d6faa63004183d71872a1e2b484a7dc995476b41d4461f567fa798eb",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0021223265191563298",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0017903979982851028"
+        ],
+        [
+          "0.0000086162867492653798"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000081818117659458211"
+        ],
+        [
+          "0.00031513042235601572"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "79382a2220f2a47332ffa89b8c483597232cbc04e2f65fbd0543e10cb7a73c31",
+      "physics_case_sha256": "37f9baa3ba2ab4fe0dc56b6fa2bd743a1d3731d2714cd8da879bcbf2f59d25cb",
+      "point_id": "point:sm_ddbar_ee:generic-3",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:lc",
+        "point=point:sm_ddbar_ee:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "60b2e4ccb7bc5b3fedadd12e729c3cc55ce893fdca2c335f6b4bdc5dd8220745",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:lc:point:sm_ddbar_ee:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "3c2dd3d916954ad83254df54d6d46553766b81d72b617b8d892efca0c46a06c3",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0036930177240583704",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0031402908058451727"
+        ],
+        [
+          "0.00000000000000014363181961844104"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000000000000001363892064017954"
+        ],
+        [
+          "0.00055272691821291772"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "5f1520b31c03c392951ca38a0e59108059c8206b4d35201610fb4594196c36bf",
+      "physics_case_sha256": "37f9baa3ba2ab4fe0dc56b6fa2bd743a1d3731d2714cd8da879bcbf2f59d25cb",
+      "point_id": "point:sm_ddbar_ee:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=f825b4df6a74e42b804053b9c177c1ffe989c347de04b689134f38254b3a95ad",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:nlc",
+        "point=point:sm_ddbar_ee:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "45c0c69ab4f9340419ecf056dac0d40c2076626c2dd04f668e00dc6a2f83251a",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:nlc:point:sm_ddbar_ee:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "99b07a562fe6881d561705d35b4f6f5afcb738a547f46f5f6d118b46d2655168",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0010319707037125029",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00082062602145063725"
+        ],
+        [
+          "0.000034317817325785194"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.000032587346469362543"
+        ],
+        [
+          "0.00014443951846671805"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "16eb8ef89ed1a41bb5ebeda412b59e96216ce3b6da114c5ff075cec34e8f0b6c",
+      "physics_case_sha256": "9851348d292228e28cebdf756cbe48997e9535a645a5e9da3b8d504885c35980",
+      "point_id": "point:sm_ddbar_ee:generic-1",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=068a8dce7ff6aa9bc83b5d85c64c54876aabd0b28405336704786f99b9ae107c",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:nlc",
+        "point=point:sm_ddbar_ee:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "458f9422e6b3d757d0a0b2d1de980bc9acb265be99298a6c405506afb517d1a1",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:nlc:point:sm_ddbar_ee:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "f7933fed78760aca39b01ca4dff138155cab49e7726947549e97422c221a869a",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0026304340923297403",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0022308617343056824"
+        ],
+        [
+          "0.0000035470834122141319"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000033682222564516122"
+        ],
+        [
+          "0.00039265705235539235"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "36cd97e6d4c49a775fdb9b9dc437633ea4b904b630a403d40bdb9f6030bb12d6",
+      "physics_case_sha256": "9851348d292228e28cebdf756cbe48997e9535a645a5e9da3b8d504885c35980",
+      "point_id": "point:sm_ddbar_ee:generic-2",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=661c50875ebea8795170c443ca9c14f4864b26773f797758b7a20dbc8af42bef",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:nlc",
+        "point=point:sm_ddbar_ee:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "ea0e5ffd8b37d4176e7f985fc3bd3d7186961f590a2943572b18ee74a2e747d2",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:nlc:point:sm_ddbar_ee:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "e1019cc4d6faa63004183d71872a1e2b484a7dc995476b41d4461f567fa798eb",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0021223265191563298",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0017903979982851028"
+        ],
+        [
+          "0.0000086162867492653798"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000081818117659458211"
+        ],
+        [
+          "0.00031513042235601572"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "37a506064a307482e06711c6d34ac9914e0aefbb592bf6b5ff10bc74256e39b0",
+      "physics_case_sha256": "9851348d292228e28cebdf756cbe48997e9535a645a5e9da3b8d504885c35980",
+      "point_id": "point:sm_ddbar_ee:generic-3",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_ee:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > e- e+",
+        "case=case:sm_ddbar_ee:nlc",
+        "point=point:sm_ddbar_ee:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "8306e665dca5d044c07e7ab743117782e60b1726dcd24f8ed390c776ce4f06f2",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_ee:nlc:point:sm_ddbar_ee:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "3c2dd3d916954ad83254df54d6d46553766b81d72b617b8d892efca0c46a06c3",
+      "observed_helicity_totals": null,
+      "observed_total": "0.0036930177240583704",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0031402908058451727"
+        ],
+        [
+          "0.00000000000000014363181961844104"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000000000000013638920640179538"
+        ],
+        [
+          "0.00055272691821291772"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "3ed8052f775a9b4a062e83dddaee91d0b7a8798663771828061e59f78a02905d",
+      "physics_case_sha256": "9851348d292228e28cebdf756cbe48997e9535a645a5e9da3b8d504885c35980",
+      "point_id": "point:sm_ddbar_ee:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > e- e+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-eminus",
+          "leg:outgoing-eplus"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          11,
+          -11
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=159688d12195a4d220c7fd689de17539cd91bf3a215ec0b03558b971190e7c25",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:full",
+        "point=point:sm_ddbar_uubar:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "42b49e6f947a2aa013352185e0ad58d6f94fde2ff0c2bc841d83906a693b2be0",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:full:point:sm_ddbar_uubar:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "6924172848714fe774b075723ca16855772adf6775725abb2da4d0baff8f5b16",
+      "observed_helicity_totals": null,
+      "observed_total": "0.68694275929045356",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.016088275717442591"
+        ],
+        [
+          "0.32738310392778419"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.32738310392778419"
+        ],
+        [
+          "0.016088275717442591"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "5c86de8be16a1f242fb1698a39681c349eb6894ed15619c6a10714fd153f5ba5",
+      "physics_case_sha256": "d6d2a9b49c3188523e310b83eda8d90ba5ccab3422b29469d8026ff1fd9302cc",
+      "point_id": "point:sm_ddbar_uubar:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=c30c7e9162e799c4524657c20fa30ab69778ac60d74ae48b7434c6116906767b",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:full",
+        "point=point:sm_ddbar_uubar:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "5d5886a89c09cb8e7ce6b5243ba5c485ff062760a820ca132a0bc731a9fdc588",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:full:point:sm_ddbar_uubar:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "66428f082fe49a6ac3c24f9ba6a89a07857fad57cd26da5b98cdfe97229b30aa",
+      "observed_helicity_totals": null,
+      "observed_total": "0.49632619985453857",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.093400085491858784"
+        ],
+        [
+          "0.15476301443541055"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.15476301443541055"
+        ],
+        [
+          "0.093400085491858784"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "d03a78968b19682fa87c51481a5dce132e3cac4bbad5fc90fa2a75f8dedff0ea",
+      "physics_case_sha256": "d6d2a9b49c3188523e310b83eda8d90ba5ccab3422b29469d8026ff1fd9302cc",
+      "point_id": "point:sm_ddbar_uubar:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=01eaaa371c390cbabbc33056696a40ff8cab98ddfc7e95fefa11c9f3f4710c33",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:full",
+        "point=point:sm_ddbar_uubar:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "34b5d378d5d3ed5121793e777005de8d3bf06c7d90eb7d71eafd55eb072864c4",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:full:point:sm_ddbar_uubar:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "355186049d66015fc0583c675ceca5de46d9dddee445c779e00e1af7322c5e6f",
+      "observed_helicity_totals": null,
+      "observed_total": "0.53016860746829364",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.20378379323180806"
+        ],
+        [
+          "0.061300510502338722"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.06130051050233868"
+        ],
+        [
+          "0.20378379323180806"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "a5c9f5168fb128e494bb449115c6974cfee1e1ed775e5a9580ed39fa833b22b0",
+      "physics_case_sha256": "d6d2a9b49c3188523e310b83eda8d90ba5ccab3422b29469d8026ff1fd9302cc",
+      "point_id": "point:sm_ddbar_uubar:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:full",
+        "point=point:sm_ddbar_uubar:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "cd5384183d01b434720407d58f5fce1f509d44f325d24fa1130f769029594592",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:full:point:sm_ddbar_uubar:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "5169f796ed9b26d0406255ce21c1d94e38838dfcd4b8f72db0c8eea4e3ca2dc7",
+      "observed_helicity_totals": null,
+      "observed_total": "0.97723802189646902",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.4886190109477459"
+        ],
+        [
+          "0.00000000000048862096542746837"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000000000048862096542746837"
+        ],
+        [
+          "0.4886190109477459"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "e8cefdca5c203c68f7549f6e992dde4c348f81f694009c20cefa2c3c7fe55816",
+      "physics_case_sha256": "d6d2a9b49c3188523e310b83eda8d90ba5ccab3422b29469d8026ff1fd9302cc",
+      "point_id": "point:sm_ddbar_uubar:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1,3,4",
+        "flow:2,4,3,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=159688d12195a4d220c7fd689de17539cd91bf3a215ec0b03558b971190e7c25",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:lc",
+        "point=point:sm_ddbar_uubar:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "26fe6a8175352bb1186d22c7f1b1e0908c98b1ed1361563300c727ec9afd9fec",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:lc:point:sm_ddbar_uubar:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "6924172848714fe774b075723ca16855772adf6775725abb2da4d0baff8f5b16",
+      "observed_helicity_totals": [
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0.020110344646803238",
+        "0.40922887990973017",
+        "0",
+        "0",
+        "0.40922887990973017",
+        "0.020110344646803238",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "observed_total": "0.85867844911306679",
+      "observed_values": null,
+      "oracle_output_sha256": "5a70b6cfa96c7ebd930b7d9762848edadbafc453fd568591e8683ba4d25412f3",
+      "physics_case_sha256": "196ac2eaf2a5c9c4e97da9930c2ac73dc59d4df940c2a44979d507ee673e125b",
+      "point_id": "point:sm_ddbar_uubar:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1,3,4",
+        "flow:2,4,3,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=c30c7e9162e799c4524657c20fa30ab69778ac60d74ae48b7434c6116906767b",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:lc",
+        "point=point:sm_ddbar_uubar:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "955dbb2a41fc359441b3ca5dbf1da25d35cc9828dce948102d3997b66d222851",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:lc:point:sm_ddbar_uubar:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "66428f082fe49a6ac3c24f9ba6a89a07857fad57cd26da5b98cdfe97229b30aa",
+      "observed_helicity_totals": [
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0.11675010686482348",
+        "0.19345376804426317",
+        "0",
+        "0",
+        "0.19345376804426317",
+        "0.11675010686482348",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "observed_total": "0.62040774981817326",
+      "observed_values": null,
+      "oracle_output_sha256": "b9d35aa80691affe2735252ba0770b4a9d47cc6b453fdd9b764bef6bf9435ea8",
+      "physics_case_sha256": "196ac2eaf2a5c9c4e97da9930c2ac73dc59d4df940c2a44979d507ee673e125b",
+      "point_id": "point:sm_ddbar_uubar:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1,3,4",
+        "flow:2,4,3,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=01eaaa371c390cbabbc33056696a40ff8cab98ddfc7e95fefa11c9f3f4710c33",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:lc",
+        "point=point:sm_ddbar_uubar:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "1c6ad5f752edc26783699c0d2e0bd46172629476d2507bb3a9a54408f6466ea7",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:lc:point:sm_ddbar_uubar:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "355186049d66015fc0583c675ceca5de46d9dddee445c779e00e1af7322c5e6f",
+      "observed_helicity_totals": [
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0.25472974153976008",
+        "0.07662563812792339",
+        "0",
+        "0",
+        "0.076625638127923348",
+        "0.25472974153976008",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "observed_total": "0.66271075933536694",
+      "observed_values": null,
+      "oracle_output_sha256": "bc81b67d8c91ed8d726f921ac5558a758460cab0154231ab1e381122cb423091",
+      "physics_case_sha256": "196ac2eaf2a5c9c4e97da9930c2ac73dc59d4df940c2a44979d507ee673e125b",
+      "point_id": "point:sm_ddbar_uubar:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1,3,4",
+        "flow:2,4,3,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:lc",
+        "point=point:sm_ddbar_uubar:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "9e3ebff35318e28a6fa65970ecd5ee73d232b637766da92dc5f9b6a037a23abf",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:lc:point:sm_ddbar_uubar:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "5169f796ed9b26d0406255ce21c1d94e38838dfcd4b8f72db0c8eea4e3ca2dc7",
+      "observed_helicity_totals": [
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0.61077376368468228",
+        "0.00000000000061077620677731177",
+        "0",
+        "0",
+        "0.00000000000061077620677731177",
+        "0.61077376368468228",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "observed_total": "1.2215475273705865",
+      "observed_values": null,
+      "oracle_output_sha256": "d0e7f13b49c489a05a243791e88cea1a3bba4a5d318fd11e8f253d0734ef602e",
+      "physics_case_sha256": "196ac2eaf2a5c9c4e97da9930c2ac73dc59d4df940c2a44979d507ee673e125b",
+      "point_id": "point:sm_ddbar_uubar:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=159688d12195a4d220c7fd689de17539cd91bf3a215ec0b03558b971190e7c25",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:nlc",
+        "point=point:sm_ddbar_uubar:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "8e7d0d6c23d0208b631389681c1b3d01afcca0a602dd4010024f3b86425297a4",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:nlc:point:sm_ddbar_uubar:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "6924172848714fe774b075723ca16855772adf6775725abb2da4d0baff8f5b16",
+      "observed_helicity_totals": null,
+      "observed_total": "0.68694275929045356",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.016088275717442591"
+        ],
+        [
+          "0.32738310392778419"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.32738310392778419"
+        ],
+        [
+          "0.016088275717442591"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "8bee5ba7e230c364f261b3a5ee9a17b0040c02c69b966f5f28eadecb926dc7ad",
+      "physics_case_sha256": "699634e12fe926987c1ca1e88982e17fb4925a014f9704fce2c38fcf19410b0c",
+      "point_id": "point:sm_ddbar_uubar:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=c30c7e9162e799c4524657c20fa30ab69778ac60d74ae48b7434c6116906767b",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:nlc",
+        "point=point:sm_ddbar_uubar:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "59f31a0855970d96afbdeb6f1ecf6606d1c2bb0f49105ba0650c4620fa182471",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:nlc:point:sm_ddbar_uubar:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "66428f082fe49a6ac3c24f9ba6a89a07857fad57cd26da5b98cdfe97229b30aa",
+      "observed_helicity_totals": null,
+      "observed_total": "0.49632619985453857",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.093400085491858784"
+        ],
+        [
+          "0.15476301443541055"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.15476301443541055"
+        ],
+        [
+          "0.093400085491858784"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "ac31992b064e01ea3b79f8dacf14d93891d2584492a7f065c27ad94c47a550c6",
+      "physics_case_sha256": "699634e12fe926987c1ca1e88982e17fb4925a014f9704fce2c38fcf19410b0c",
+      "point_id": "point:sm_ddbar_uubar:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=01eaaa371c390cbabbc33056696a40ff8cab98ddfc7e95fefa11c9f3f4710c33",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:nlc",
+        "point=point:sm_ddbar_uubar:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "da812227c66ba792d887f27a34320a5bbdfea35cf044f50a10b91c9ff14be34d",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:nlc:point:sm_ddbar_uubar:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "355186049d66015fc0583c675ceca5de46d9dddee445c779e00e1af7322c5e6f",
+      "observed_helicity_totals": null,
+      "observed_total": "0.53016860746829364",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.20378379323180806"
+        ],
+        [
+          "0.061300510502338722"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.06130051050233868"
+        ],
+        [
+          "0.20378379323180806"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "1b1d28c8b29249720c38a6de0839edf9bdafc61f90ee2ca9544a3085d58ef5ae",
+      "physics_case_sha256": "699634e12fe926987c1ca1e88982e17fb4925a014f9704fce2c38fcf19410b0c",
+      "point_id": "point:sm_ddbar_uubar:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_uubar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=2",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=d d~ > u u~",
+        "case=case:sm_ddbar_uubar:nlc",
+        "point=point:sm_ddbar_uubar:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "fda0abbc49bbeb671bb3d2c422fb28df7b90d3342149242a0d2a3eda50d2df19",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_uubar:nlc:point:sm_ddbar_uubar:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "5169f796ed9b26d0406255ce21c1d94e38838dfcd4b8f72db0c8eea4e3ca2dc7",
+      "observed_helicity_totals": null,
+      "observed_total": "0.97723802189646902",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.4886190109477459"
+        ],
+        [
+          "0.00000000000048862096542746837"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000000000048862096542746837"
+        ],
+        [
+          "0.4886190109477459"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "894d24a031af7baee2305e880cf6ff17d5f51985846f90a3278d4b998e435df0",
+      "physics_case_sha256": "699634e12fe926987c1ca1e88982e17fb4925a014f9704fce2c38fcf19410b0c",
+      "point_id": "point:sm_ddbar_uubar:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > u u~",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-u",
+          "leg:outgoing-ubar"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          2,
+          -2
+        ],
+        "row_id": "group:2:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_z:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=c93e1917cbca9f1bc317b871eb8295e74ee753c7d1cd2e9ae16117c006f055f1",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=full",
+        "process=d d~ > z",
+        "case=case:sm_ddbar_z:full",
+        "point=point:sm_ddbar_z:canonical",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "ec9637a9d96a9927a6ade8de8cb07709f88d0753464ad1680ba81c82097f4061",
+      "helicity_ids": [
+        "h:-1,-1,-1",
+        "h:-1,-1,+0",
+        "h:-1,-1,+1",
+        "h:-1,+1,-1",
+        "h:-1,+1,+0",
+        "h:-1,+1,+1",
+        "h:+1,-1,-1",
+        "h:+1,-1,+0",
+        "h:+1,-1,+1",
+        "h:+1,+1,-1",
+        "h:+1,+1,+0",
+        "h:+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_z:full:point:sm_ddbar_z:canonical",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "da8ce6c3708d2ed7d74a603d87abd4590d0311b64d4d7661b3317712732d44db",
+      "observed_helicity_totals": null,
+      "observed_total": "142.10653372872989",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "137.93356063778558"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "4.1729730909442964"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "6419398786073009a7e9adbedeaecb0b049e677f83ebb348c977ab4e51b3138b",
+      "physics_case_sha256": "c3a2cbe972134531fc4e0fbea590b92bcc75b2e8b5acd8b0e675679a9dc744af",
+      "point_id": "point:sm_ddbar_z:canonical",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_z:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=c93e1917cbca9f1bc317b871eb8295e74ee753c7d1cd2e9ae16117c006f055f1",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=lc",
+        "process=d d~ > z",
+        "case=case:sm_ddbar_z:lc",
+        "point=point:sm_ddbar_z:canonical",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "07dbfdde4fb8c447d7fa83e766ec3300505b965acc4ff00fd21c152f4b96137c",
+      "helicity_ids": [
+        "h:-1,-1,-1",
+        "h:-1,-1,+0",
+        "h:-1,-1,+1",
+        "h:-1,+1,-1",
+        "h:-1,+1,+0",
+        "h:-1,+1,+1",
+        "h:+1,-1,-1",
+        "h:+1,-1,+0",
+        "h:+1,-1,+1",
+        "h:+1,+1,-1",
+        "h:+1,+1,+0",
+        "h:+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_z:lc:point:sm_ddbar_z:canonical",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "da8ce6c3708d2ed7d74a603d87abd4590d0311b64d4d7661b3317712732d44db",
+      "observed_helicity_totals": null,
+      "observed_total": "142.10653372872989",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "137.93356063778558"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "4.1729730909442964"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "75e627c8b24559b5083458212d68ec9b51fd3eff76f6805099094c4bbd2b5002",
+      "physics_case_sha256": "7fac82a4f56a5e7542ea8d7f91b4c810d62539c447264fd8a7498fcf5721e04f",
+      "point_id": "point:sm_ddbar_z:canonical",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_z:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=c93e1917cbca9f1bc317b871eb8295e74ee753c7d1cd2e9ae16117c006f055f1",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=nlc",
+        "process=d d~ > z",
+        "case=case:sm_ddbar_z:nlc",
+        "point=point:sm_ddbar_z:canonical",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "4a9b4c45b7cc5d4ad41131556ea4eae6f4ee16553c8ae93925ee0768a3e6e33d",
+      "helicity_ids": [
+        "h:-1,-1,-1",
+        "h:-1,-1,+0",
+        "h:-1,-1,+1",
+        "h:-1,+1,-1",
+        "h:-1,+1,+0",
+        "h:-1,+1,+1",
+        "h:+1,-1,-1",
+        "h:+1,-1,+0",
+        "h:+1,-1,+1",
+        "h:+1,+1,-1",
+        "h:+1,+1,+0",
+        "h:+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_z:nlc:point:sm_ddbar_z:canonical",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "da8ce6c3708d2ed7d74a603d87abd4590d0311b64d4d7661b3317712732d44db",
+      "observed_helicity_totals": null,
+      "observed_total": "142.10653372872989",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "137.93356063778558"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "4.1729730909442964"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "6ccc424b058695d27e5d8ec3431ddf42cb8a0ea39227f24e817f7a4954d2109e",
+      "physics_case_sha256": "fb0ce6bde633c5f2236439d80241cc79244e967c385d3a5b4f1621694c610586",
+      "point_id": "point:sm_ddbar_z:canonical",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=fff1ea2d528950eeeb8abe60b76466f8aaa602a8b73de751dd1b59551905dc12",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=full",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:full",
+        "point=point:sm_ddbar_zg:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "e7114559c7f4d12dc17a3680035534cd9c4f7411ff2c76f5485653d207fca77d",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:full:point:sm_ddbar_zg:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "ecd661750c43b7017c1f061d5099dc06f1c3e0187c2e1ed30f23f37f31ef479c",
+      "observed_helicity_totals": null,
+      "observed_total": "0.21607176163324765",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000016788392960863336"
+        ],
+        [
+          "0.024280541263147042"
+        ],
+        [
+          "0.001109208727941525"
+        ],
+        [
+          "0.0011092087279415107"
+        ],
+        [
+          "0.18321348639648802"
+        ],
+        [
+          "0.000012668004275598482"
+        ],
+        [
+          "0.00000038325147783910022"
+        ],
+        [
+          "0.0055428493623704304"
+        ],
+        [
+          "0.000033557447169042847"
+        ],
+        [
+          "0.000033557447169044581"
+        ],
+        [
+          "0.00073457137520539762"
+        ],
+        [
+          "0.000000050790766033986098"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "79b81b873d12fc3e62ea5e5f646e95f185b307889c311910a0dcdb2df5ee46ab",
+      "physics_case_sha256": "748fe481f3c5b16ec661d65f56df93ab97d40f2d203573db11b647886d77bc09",
+      "point_id": "point:sm_ddbar_zg:generic-1",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=cf78f5a7fe21301d0fda83fc17b241f7d46f8aac621cc8675a0e86cb106f8585",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=full",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:full",
+        "point=point:sm_ddbar_zg:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "5c7ce2fa46aa59862600796cf08386e7af7ce27472673aefe8b6ee21b15fff75",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:full:point:sm_ddbar_zg:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "642d0d76adf727fd5d5c2f7e24ca53484b80dcf7f75e04d4dc94b1a764808a69",
+      "observed_helicity_totals": null,
+      "observed_total": "0.47302794814860799",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000068821346804150522"
+        ],
+        [
+          "0.009953421716771535"
+        ],
+        [
+          "0.0011092087279414315"
+        ],
+        [
+          "0.0011092087279414931"
+        ],
+        [
+          "0.44693400350144835"
+        ],
+        [
+          "0.000030902538773887961"
+        ],
+        [
+          "0.00000093490998237865648"
+        ],
+        [
+          "0.013521318244927819"
+        ],
+        [
+          "0.000033557447169042406"
+        ],
+        [
+          "0.000033557447169040888"
+        ],
+        [
+          "0.00030112585214834203"
+        ],
+        [
+          "0.000000020820866725135217"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "e91fcf793a2b023b007adef65f53c20fd0f169331cde89d2114cda7e1b8d155a",
+      "physics_case_sha256": "748fe481f3c5b16ec661d65f56df93ab97d40f2d203573db11b647886d77bc09",
+      "point_id": "point:sm_ddbar_zg:generic-2",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=672f81a3a4cc4a066e673c697bd6a0590376de09a71881c18e8f5a4686ece4dc",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=full",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:full",
+        "point=point:sm_ddbar_zg:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "dd72d9b2097f5d3739c2750ffc9ef2540916c5590326e92023289b6431150200",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:full:point:sm_ddbar_zg:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "756f28d660cf5c1e15ac26e6616137deb33ef801dd20d5ea3ce7ad53d49f115e",
+      "observed_helicity_totals": null,
+      "observed_total": "0.16872514943908373",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000087346391807811994"
+        ],
+        [
+          "0.12632642537142244"
+        ],
+        [
+          "0.0011092087279414892"
+        ],
+        [
+          "0.0011092087279414675"
+        ],
+        [
+          "0.035214505621729578"
+        ],
+        [
+          "0.000002434850821045794"
+        ],
+        [
+          "0.000000073662761330212085"
+        ],
+        [
+          "0.0010653620749795159"
+        ],
+        [
+          "0.000033557447169041647"
+        ],
+        [
+          "0.000033557447169042128"
+        ],
+        [
+          "0.0038218166145543484"
+        ],
+        [
+          "0.00000026425341368677949"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "9365b6bc10cc260e160e38af28553cb834776dc3dff1f4e5daaef879bd364cb2",
+      "physics_case_sha256": "748fe481f3c5b16ec661d65f56df93ab97d40f2d203573db11b647886d77bc09",
+      "point_id": "point:sm_ddbar_zg:generic-3",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=4f85d9e53e6bd65402c4cf1e910b46dd8179e2f6ae4ef67ea9f6ff9ddd481fd1",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=full",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:full",
+        "point=point:sm_ddbar_zg:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "c9d6955857ffef427d842b6324dbb0391df31856601e1b024512e71d22503301",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:full:point:sm_ddbar_zg:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "7786ade1b51cba7321f5fc5e6632f7a5ce491d1f51322d94469974bc8c443257",
+      "observed_helicity_totals": null,
+      "observed_total": "68719.687168469187",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "4.6116654595406494"
+        ],
+        [
+          "66697.112548676814"
+        ],
+        [
+          "0.0011092087279411678"
+        ],
+        [
+          "0.0011092087279037514"
+        ],
+        [
+          "0.000000066697379338132234"
+        ],
+        [
+          "0.0000000000046116839588053645"
+        ],
+        [
+          "0.0000000000001395195844655152"
+        ],
+        [
+          "0.0000000020178292210219726"
+        ],
+        [
+          "0.000033557447167901175"
+        ],
+        [
+          "0.000033557447169032594"
+        ],
+        [
+          "2017.8211497069631"
+        ],
+        [
+          "0.1395190247980054"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "c29924042b314aef7fd0317401e71da3de6f7ed572257098ac6447219d7e3858",
+      "physics_case_sha256": "748fe481f3c5b16ec661d65f56df93ab97d40f2d203573db11b647886d77bc09",
+      "point_id": "point:sm_ddbar_zg:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,4,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=fff1ea2d528950eeeb8abe60b76466f8aaa602a8b73de751dd1b59551905dc12",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=lc",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:lc",
+        "point=point:sm_ddbar_zg:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "f4dd8fa9c689da1b0131d8dbc6c612189f2e39b50b74d9f9e62f9c5865c8b50f",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:lc:point:sm_ddbar_zg:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "ecd661750c43b7017c1f061d5099dc06f1c3e0187c2e1ed30f23f37f31ef479c",
+      "observed_helicity_totals": null,
+      "observed_total": "0.2430807318374035",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000018886942080971254"
+        ],
+        [
+          "0.027315608921040423"
+        ],
+        [
+          "0.0012478598189342156"
+        ],
+        [
+          "0.0012478598189341996"
+        ],
+        [
+          "0.20611517219604902"
+        ],
+        [
+          "0.000014251504810048289"
+        ],
+        [
+          "0.00000043115791256898777"
+        ],
+        [
+          "0.0062357055326667347"
+        ],
+        [
+          "0.000037752128065173199"
+        ],
+        [
+          "0.000037752128065175157"
+        ],
+        [
+          "0.00082639279710607246"
+        ],
+        [
+          "0.000000057139611788234354"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "a89af4ec50bb6541ae2ca3e11db1e45471aba3d1618a5e8a0ccceef7deb0f07b",
+      "physics_case_sha256": "7dc9c595c3faa505ffa7a42df5398253a1eb7ace715a3e9ede8363fb034cecc5",
+      "point_id": "point:sm_ddbar_zg:generic-1",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,4,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=cf78f5a7fe21301d0fda83fc17b241f7d46f8aac621cc8675a0e86cb106f8585",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=lc",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:lc",
+        "point=point:sm_ddbar_zg:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "83bbea70b320905d925225facd9fd17141f2bfab20f6f42a38181a9fce00410a",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:lc:point:sm_ddbar_zg:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "642d0d76adf727fd5d5c2f7e24ca53484b80dcf7f75e04d4dc94b1a764808a69",
+      "observed_helicity_totals": null,
+      "observed_total": "0.5321564416671839",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000077424015154669338"
+        ],
+        [
+          "0.011197599431367979"
+        ],
+        [
+          "0.0012478598189341104"
+        ],
+        [
+          "0.0012478598189341796"
+        ],
+        [
+          "0.50280075393912937"
+        ],
+        [
+          "0.000034765356120623953"
+        ],
+        [
+          "0.0000010517737301759887"
+        ],
+        [
+          "0.015211483025543796"
+        ],
+        [
+          "0.000037752128065172711"
+        ],
+        [
+          "0.000037752128065170997"
+        ],
+        [
+          "0.00033876658366688479"
+        ],
+        [
+          "0.000000023423475065777118"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "db802961b329b489709c0982d616b25f019bfaea92ae8747b9d276c99aba10db",
+      "physics_case_sha256": "7dc9c595c3faa505ffa7a42df5398253a1eb7ace715a3e9ede8363fb034cecc5",
+      "point_id": "point:sm_ddbar_zg:generic-2",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,4,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=672f81a3a4cc4a066e673c697bd6a0590376de09a71881c18e8f5a4686ece4dc",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=lc",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:lc",
+        "point=point:sm_ddbar_zg:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "318aeca5141b849096fc445e6911c1bb62c5762ff606336c18448c4a9b700e5c",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:lc:point:sm_ddbar_zg:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "756f28d660cf5c1e15ac26e6616137deb33ef801dd20d5ea3ce7ad53d49f115e",
+      "observed_helicity_totals": null,
+      "observed_total": "0.18981579311896921",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000098264690783788487"
+        ],
+        [
+          "0.14211722854285025"
+        ],
+        [
+          "0.0012478598189341753"
+        ],
+        [
+          "0.001247859818934151"
+        ],
+        [
+          "0.039616318824445773"
+        ],
+        [
+          "0.0000027392071736765181"
+        ],
+        [
+          "0.000000082870606496488602"
+        ],
+        [
+          "0.0011985323343519552"
+        ],
+        [
+          "0.000037752128065171864"
+        ],
+        [
+          "0.000037752128065172393"
+        ],
+        [
+          "0.0042995436913736409"
+        ],
+        [
+          "0.00000029728509039762693"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "2afc76953fcd531bd4031ca41de03dfdb67dcac20d1dda5b2c3ba26df39b4a59",
+      "physics_case_sha256": "7dc9c595c3faa505ffa7a42df5398253a1eb7ace715a3e9ede8363fb034cecc5",
+      "point_id": "point:sm_ddbar_zg:generic-3",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,4,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=4f85d9e53e6bd65402c4cf1e910b46dd8179e2f6ae4ef67ea9f6ff9ddd481fd1",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=lc",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:lc",
+        "point=point:sm_ddbar_zg:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "122b155270316305a00e0594034b05646ccff9de0d9f2fe3f6f337e4631f5664",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:lc:point:sm_ddbar_zg:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "7786ade1b51cba7321f5fc5e6632f7a5ce491d1f51322d94469974bc8c443257",
+      "observed_helicity_totals": null,
+      "observed_total": "77309.648064527821",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "5.1881236419832302"
+        ],
+        [
+          "75034.251617261412"
+        ],
+        [
+          "0.001247859818933814"
+        ],
+        [
+          "0.0012478598188917201"
+        ],
+        [
+          "0.000000075034551755398775"
+        ],
+        [
+          "0.0000000000051881444536560352"
+        ],
+        [
+          "0.00000000000015695953252370459"
+        ],
+        [
+          "0.0000000022700578736497191"
+        ],
+        [
+          "0.000037752128063888826"
+        ],
+        [
+          "0.000037752128065161673"
+        ],
+        [
+          "2270.0487934203334"
+        ],
+        [
+          "0.15695890289775608"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "82756eedfd79ae425e4736499dda8bd5e3d85d4de303f24964c1513ddd202df2",
+      "physics_case_sha256": "7dc9c595c3faa505ffa7a42df5398253a1eb7ace715a3e9ede8363fb034cecc5",
+      "point_id": "point:sm_ddbar_zg:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=fff1ea2d528950eeeb8abe60b76466f8aaa602a8b73de751dd1b59551905dc12",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=nlc",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:nlc",
+        "point=point:sm_ddbar_zg:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "6b3b3f59fd6c4341ca5d1cecf1d92f85cebf8383acd0ba2659b3af43c31de487",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:nlc:point:sm_ddbar_zg:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "ecd661750c43b7017c1f061d5099dc06f1c3e0187c2e1ed30f23f37f31ef479c",
+      "observed_helicity_totals": null,
+      "observed_total": "0.21607176163324765",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000016788392960863336"
+        ],
+        [
+          "0.024280541263147042"
+        ],
+        [
+          "0.001109208727941525"
+        ],
+        [
+          "0.0011092087279415107"
+        ],
+        [
+          "0.18321348639648802"
+        ],
+        [
+          "0.000012668004275598482"
+        ],
+        [
+          "0.00000038325147783910022"
+        ],
+        [
+          "0.0055428493623704304"
+        ],
+        [
+          "0.000033557447169042847"
+        ],
+        [
+          "0.000033557447169044581"
+        ],
+        [
+          "0.00073457137520539762"
+        ],
+        [
+          "0.000000050790766033986098"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "949ed9a355e28b346bb4641f645b356624fc968287cdaa055216c3de708f7f08",
+      "physics_case_sha256": "c622e2c05ec7999ee2f113b5dd7d0545d190dd61b4c8b2610e6ddbdf29d10e87",
+      "point_id": "point:sm_ddbar_zg:generic-1",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=cf78f5a7fe21301d0fda83fc17b241f7d46f8aac621cc8675a0e86cb106f8585",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=nlc",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:nlc",
+        "point=point:sm_ddbar_zg:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "831ae7dc2fec84e941be63c40c990cf2e5995c6e48ab3e7d7b000fef4e9497ae",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:nlc:point:sm_ddbar_zg:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "642d0d76adf727fd5d5c2f7e24ca53484b80dcf7f75e04d4dc94b1a764808a69",
+      "observed_helicity_totals": null,
+      "observed_total": "0.47302794814860799",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000068821346804150522"
+        ],
+        [
+          "0.009953421716771535"
+        ],
+        [
+          "0.0011092087279414315"
+        ],
+        [
+          "0.0011092087279414931"
+        ],
+        [
+          "0.44693400350144835"
+        ],
+        [
+          "0.000030902538773887961"
+        ],
+        [
+          "0.00000093490998237865648"
+        ],
+        [
+          "0.013521318244927819"
+        ],
+        [
+          "0.000033557447169042406"
+        ],
+        [
+          "0.000033557447169040888"
+        ],
+        [
+          "0.00030112585214834203"
+        ],
+        [
+          "0.000000020820866725135217"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "92028e33620eb502353d14660e9dd1ba06f9d22c0e20f553bc697c6d66a00814",
+      "physics_case_sha256": "c622e2c05ec7999ee2f113b5dd7d0545d190dd61b4c8b2610e6ddbdf29d10e87",
+      "point_id": "point:sm_ddbar_zg:generic-2",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=672f81a3a4cc4a066e673c697bd6a0590376de09a71881c18e8f5a4686ece4dc",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=nlc",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:nlc",
+        "point=point:sm_ddbar_zg:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "ca151f5cb036034cbee1c2ca628432e7119c44c6f6a996f17b6224c599e81687",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:nlc:point:sm_ddbar_zg:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "756f28d660cf5c1e15ac26e6616137deb33ef801dd20d5ea3ce7ad53d49f115e",
+      "observed_helicity_totals": null,
+      "observed_total": "0.16872514943908373",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000087346391807811994"
+        ],
+        [
+          "0.12632642537142244"
+        ],
+        [
+          "0.0011092087279414892"
+        ],
+        [
+          "0.0011092087279414675"
+        ],
+        [
+          "0.035214505621729578"
+        ],
+        [
+          "0.000002434850821045794"
+        ],
+        [
+          "0.000000073662761330212085"
+        ],
+        [
+          "0.0010653620749795159"
+        ],
+        [
+          "0.000033557447169041647"
+        ],
+        [
+          "0.000033557447169042128"
+        ],
+        [
+          "0.0038218166145543484"
+        ],
+        [
+          "0.00000026425341368677949"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "28377f80d2374da3d6db39ad285b6d8b70107032a8a8ff60e87b62eaae71d855",
+      "physics_case_sha256": "c622e2c05ec7999ee2f113b5dd7d0545d190dd61b4c8b2610e6ddbdf29d10e87",
+      "point_id": "point:sm_ddbar_zg:generic-3",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=4f85d9e53e6bd65402c4cf1e910b46dd8179e2f6ae4ef67ea9f6ff9ddd481fd1",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=nlc",
+        "process=d d~ > z g",
+        "case=case:sm_ddbar_zg:nlc",
+        "point=point:sm_ddbar_zg:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "4691f259dd30c26f75c41ffa9793896c709940b45de99a842856629d63d0eb40",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+0,-1",
+        "h:-1,-1,+0,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+0,-1",
+        "h:-1,+1,+0,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+0,-1",
+        "h:+1,-1,+0,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+0,-1",
+        "h:+1,+1,+0,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zg:nlc:point:sm_ddbar_zg:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "7786ade1b51cba7321f5fc5e6632f7a5ce491d1f51322d94469974bc8c443257",
+      "observed_helicity_totals": null,
+      "observed_total": "68719.687168469187",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "4.6116654595406494"
+        ],
+        [
+          "66697.112548676814"
+        ],
+        [
+          "0.0011092087279411678"
+        ],
+        [
+          "0.0011092087279037514"
+        ],
+        [
+          "0.000000066697379338132234"
+        ],
+        [
+          "0.0000000000046116839588053645"
+        ],
+        [
+          "0.0000000000001395195844655152"
+        ],
+        [
+          "0.0000000020178292210219726"
+        ],
+        [
+          "0.000033557447167901175"
+        ],
+        [
+          "0.000033557447169032594"
+        ],
+        [
+          "2017.8211497069631"
+        ],
+        [
+          "0.1395190247980054"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "63787aeb10041aa895d2702704ca25a151222b931de99f9812adc54b2c65842a",
+      "physics_case_sha256": "c622e2c05ec7999ee2f113b5dd7d0545d190dd61b4c8b2610e6ddbdf29d10e87",
+      "point_id": "point:sm_ddbar_zg:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "d d~ > z g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=87931a6f865835e68a3e58c272db0b79db9934f18a2a6b16b0067cbc9897cafd",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=full",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:full",
+        "point=point:sm_ddbar_zgg:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "5dc5e46b790f12217384cee62f8cb8753ed2104da0a020c12adc6e5fe6f9f362",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:full:point:sm_ddbar_zgg:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "5220587ed8399d54d3d5c67ba4ecd9f76effcbfeb2289d22805691f122c49f56",
+      "observed_helicity_totals": null,
+      "observed_total": "0.014981403983888716",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.000000001290709116482262"
+        ],
+        [
+          "0.0002025161513731112"
+        ],
+        [
+          "0.00000000020844541839095915"
+        ],
+        [
+          "0.000013154844510478129"
+        ],
+        [
+          "0.0000082353564140620431"
+        ],
+        [
+          "0.00012633085090794249"
+        ],
+        [
+          "0.00000063575638130527721"
+        ],
+        [
+          "0.0000082353564140618567"
+        ],
+        [
+          "0.013136401998056725"
+        ],
+        [
+          "0.0001309476444219849"
+        ],
+        [
+          "0.00091372514598742115"
+        ],
+        [
+          "0.0000012888995991668629"
+        ],
+        [
+          "0.000000038993725090417147"
+        ],
+        [
+          "0.000027643384460562784"
+        ],
+        [
+          "0.0000039616246689262386"
+        ],
+        [
+          "0.00039742214872325114"
+        ],
+        [
+          "0.00000024914836209050517"
+        ],
+        [
+          "0.000000019233856208133593"
+        ],
+        [
+          "0.0000038219505025271249"
+        ],
+        [
+          "0.00000024914836209051073"
+        ],
+        [
+          "0.0000003979800992880594"
+        ],
+        [
+          "0.0000000000063062036378535325"
+        ],
+        [
+          "0.0000061268225532205186"
+        ],
+        [
+          "0.000000000039048469324016151"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "05e0ea7de8bdc682a55bea01a07b5b6fe907babf08e820f6c19df87eab8a1cf1",
+      "physics_case_sha256": "43f7a3c976a8c77fb1ad054ccdd724e2ab2cdac143ad62aff01e457060fb2209",
+      "point_id": "point:sm_ddbar_zgg:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=f454b121c00bf5b8a0fe19e9866bc3f3d9062a92cc7c25c6cdda21f3cf554bdf",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=full",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:full",
+        "point=point:sm_ddbar_zgg:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "57146d5e5b0eedcc6475974d20cc15c64b4faea913c078cae88028bfb53252fc",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:full:point:sm_ddbar_zgg:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "bcac1824bc417f87758f2874cf66bc923559e501d310d4eda0b09e2790dbf8d9",
+      "observed_helicity_totals": null,
+      "observed_total": "0.00090691933962912046",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000000050218400585297921"
+        ],
+        [
+          "0.0000015227442800382373"
+        ],
+        [
+          "0.00000044188962667335897"
+        ],
+        [
+          "0.0000052404119947770485"
+        ],
+        [
+          "0.0000010925857546280795"
+        ],
+        [
+          "0.0000015000033799806493"
+        ],
+        [
+          "0.00000025897375164813209"
+        ],
+        [
+          "0.0000010925857546280842"
+        ],
+        [
+          "0.00059427601103546413"
+        ],
+        [
+          "0.00027418169524926975"
+        ],
+        [
+          "0.00000062320727626135429"
+        ],
+        [
+          "0.000000056948939911880552"
+        ],
+        [
+          "0.0000000017229048007695681"
+        ],
+        [
+          "0.000000018854201848298417"
+        ],
+        [
+          "0.0000082949561442065942"
+        ],
+        [
+          "0.000017978929791836053"
+        ],
+        [
+          "0.000000033054544032143902"
+        ],
+        [
+          "0.00000000783486260987959"
+        ],
+        [
+          "0.000000045380353498030614"
+        ],
+        [
+          "0.000000033054544032143326"
+        ],
+        [
+          "0.00000015854080862229111"
+        ],
+        [
+          "0.000000013368708186383204"
+        ],
+        [
+          "0.000000046068345336748986"
+        ],
+        [
+          "0.000000000015192824236809683"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "bc69fd4ca5b9e52a9f2de22f29d7924f99ef159b13c0c318abfc4cde6edf4816",
+      "physics_case_sha256": "43f7a3c976a8c77fb1ad054ccdd724e2ab2cdac143ad62aff01e457060fb2209",
+      "point_id": "point:sm_ddbar_zgg:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=4a7db4918ff8305c3024a6a4501d5e1ca63c21a86d2f48fa5e6b8e14d3689a51",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=full",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:full",
+        "point=point:sm_ddbar_zgg:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "d25670b69ed8a1b828ec3f2c73d5e5f56622f59a054f0c884db0116675b1cdd3",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:full:point:sm_ddbar_zgg:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "37240f414da2242d63e055c00ee16715b0e26b2e67e067ed9dd6786e36b56d38",
+      "observed_helicity_totals": null,
+      "observed_total": "0.000018743756960353458",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000000043035086848322426"
+        ],
+        [
+          "0.000000059115768283467044"
+        ],
+        [
+          "0.000004442487116792543"
+        ],
+        [
+          "0.0000024046787380369732"
+        ],
+        [
+          "0.00000007809846998041092"
+        ],
+        [
+          "0.00000012497720003225663"
+        ],
+        [
+          "0.0000000992276637669188"
+        ],
+        [
+          "0.000000078098469980412164"
+        ],
+        [
+          "0.0000035432547369883152"
+        ],
+        [
+          "0.0000073304858579872696"
+        ],
+        [
+          "0.000000031856106925766326"
+        ],
+        [
+          "0.00000000063411495648065531"
+        ],
+        [
+          "0.000000000019184197360843423"
+        ],
+        [
+          "0.00000000096375875725092277"
+        ],
+        [
+          "0.00000022177285997320054"
+        ],
+        [
+          "0.00000010719586011877874"
+        ],
+        [
+          "0.0000000023627521262066652"
+        ],
+        [
+          "0.0000000030019842079186923"
+        ],
+        [
+          "0.0000000037809978246388916"
+        ],
+        [
+          "0.0000000023627521262066152"
+        ],
+        [
+          "0.000000072749950191927942"
+        ],
+        [
+          "0.00000013440078766562039"
+        ],
+        [
+          "0.0000000017884589447031801"
+        ],
+        [
+          "0.000000000013019620355925571"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "5954bf0930ec5b6f8de0c7e28be4b7577de28dd75752af26848aa1140fd2268d",
+      "physics_case_sha256": "43f7a3c976a8c77fb1ad054ccdd724e2ab2cdac143ad62aff01e457060fb2209",
+      "point_id": "point:sm_ddbar_zgg:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=bd03022f9c090a36ac752ea9ead5dca5620fca57e8ebd585f9765705fbdde802",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=full",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:full",
+        "point=point:sm_ddbar_zgg:stress-soft-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "4c9c204d93cbbe074ce622f3f3365cda1b4715a8681b1addccd76582e837c95f",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:full:point:sm_ddbar_zgg:stress-soft-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "b155388f382d87b4c72d2635f5276be720bceb164df4ea55f6c16da6e5a1d5d1",
+      "observed_helicity_totals": null,
+      "observed_total": "13.812900229656536",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00022840002683410422"
+        ],
+        [
+          "0.00022746435938143854"
+        ],
+        [
+          "3.303014543328604"
+        ],
+        [
+          "3.2900868008671114"
+        ],
+        [
+          "0.054934851647024593"
+        ],
+        [
+          "0.05471476340158242"
+        ],
+        [
+          "0.055145804941495589"
+        ],
+        [
+          "0.054934851647027001"
+        ],
+        [
+          "3.3032372711505"
+        ],
+        [
+          "3.2902987260666565"
+        ],
+        [
+          "0.00023019245852704611"
+        ],
+        [
+          "0.00022931294127905352"
+        ],
+        [
+          "0.0000069375192588239914"
+        ],
+        [
+          "0.0000069641277346142556"
+        ],
+        [
+          "0.099543055232949276"
+        ],
+        [
+          "0.099934491517354562"
+        ],
+        [
+          "0.0016619715797814725"
+        ],
+        [
+          "0.0016683536554503169"
+        ],
+        [
+          "0.0016553131398656979"
+        ],
+        [
+          "0.0016619715797813841"
+        ],
+        [
+          "0.099536643753749363"
+        ],
+        [
+          "0.099927753221010426"
+        ],
+        [
+          "0.0000068815931848538924"
+        ],
+        [
+          "0.000006909900400907713"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "93a26c2791f88e57332f73847d0eb6687a721ada19a2bec9eee0cdcd51d3fa25",
+      "physics_case_sha256": "43f7a3c976a8c77fb1ad054ccdd724e2ab2cdac143ad62aff01e457060fb2209",
+      "point_id": "point:sm_ddbar_zgg:stress-soft-collinear",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,4,5,1",
+        "flow:2,5,4,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=87931a6f865835e68a3e58c272db0b79db9934f18a2a6b16b0067cbc9897cafd",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=lc",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:lc",
+        "point=point:sm_ddbar_zgg:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "26f330e38d79d4819f84070fd4558c48fe0e17f71a6ad6ca128be72604c5bf23",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:lc:point:sm_ddbar_zgg:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "5220587ed8399d54d3d5c67ba4ecd9f76effcbfeb2289d22805691f122c49f56",
+      "observed_helicity_totals": [
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0.0000000016353995779250319",
+        "0.00025659981084343448",
+        "0.00000000026582715747665552",
+        "0.000016667912921184474",
+        "0.00001043465040390015",
+        "0.00016004075092069931",
+        "0.0000008078233276590714",
+        "0.000010434650403899909",
+        "0.01664454524163167",
+        "0.00016537941381028932",
+        "0.0011577517907596304",
+        "0.0000016331068197690167",
+        "0.000000049407198523858217",
+        "0.000035026044760197603",
+        "0.0000050033062326198339",
+        "0.00050355576324698128",
+        "0.00000031568470463276818",
+        "0.000000024439483712094669",
+        "0.0000048417929904699891",
+        "0.00000031568470463277532",
+        "0.00000050426271735967671",
+        "0.0000000000080422021287864251",
+        "0.0000077630425897793951",
+        "0.000000000049476562484628751",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "observed_total": "0.018981696539216539",
+      "observed_values": null,
+      "oracle_output_sha256": "70483c90854accd0ad81a2405e61f2065a7a5857408c8fbdc148873b25b32540",
+      "physics_case_sha256": "5196d56b489f28409632be42ea1528fdce6b19d5fe76ec4179e4db919d78b984",
+      "point_id": "point:sm_ddbar_zgg:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,4,5,1",
+        "flow:2,5,4,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=f454b121c00bf5b8a0fe19e9866bc3f3d9062a92cc7c25c6cdda21f3cf554bdf",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=lc",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:lc",
+        "point=point:sm_ddbar_zgg:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "1e438118a8315205acb186fd9aa83b05669dd9ce0d80cc397c8a5b024682d689",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:lc:point:sm_ddbar_zgg:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "bcac1824bc417f87758f2874cf66bc923559e501d310d4eda0b09e2790dbf8d9",
+      "observed_helicity_totals": [
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0.00000000061468078851170934",
+        "0.000001864872368327592",
+        "0.00000054133809066371427",
+        "0.0000064143432278462824",
+        "0.0000013373414233508393",
+        "0.0000019018595812895904",
+        "0.00000032101570317605064",
+        "0.0000013373414233508441",
+        "0.00072740279021115534",
+        "0.00033583127897811077",
+        "0.00000076626583146433151",
+        "0.000000069706360381754134",
+        "0.000000002108861431516189",
+        "0.000000023182223966563491",
+        "0.000010160071876584031",
+        "0.000022006480915837558",
+        "0.000000040459259858470246",
+        "0.0000000097118488417912401",
+        "0.000000057537910417009586",
+        "0.000000040459259858469598",
+        "0.00000019405633815379655",
+        "0.000000016377372374044374",
+        "0.000000056418917739043586",
+        "0.000000000018596245744106766",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "observed_total": "0.0011103956512612131",
+      "observed_values": null,
+      "oracle_output_sha256": "1253ff5611269130b46ed8c2720b7b08e8b8c9383e3a2b70f5083559084ae01d",
+      "physics_case_sha256": "5196d56b489f28409632be42ea1528fdce6b19d5fe76ec4179e4db919d78b984",
+      "point_id": "point:sm_ddbar_zgg:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,4,5,1",
+        "flow:2,5,4,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=4a7db4918ff8305c3024a6a4501d5e1ca63c21a86d2f48fa5e6b8e14d3689a51",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=lc",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:lc",
+        "point=point:sm_ddbar_zgg:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "47416c21a05bd2c510d7cfc138406f582c7d97608e929496ccad05bc3d9ac813",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:lc:point:sm_ddbar_zgg:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "37240f414da2242d63e055c00ee16715b0e26b2e67e067ed9dd6786e36b56d38",
+      "observed_helicity_totals": [
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0.00000000058979332315075162",
+        "0.000000080211102071744937",
+        "0.000006090619281164884",
+        "0.0000032955980059142595",
+        "0.00000010703349177633024",
+        "0.00000017208810169536695",
+        "0.00000014052911299364525",
+        "0.00000010703349177633207",
+        "0.0000048560096868479913",
+        "0.000010049370824709994",
+        "0.00000004340896142041221",
+        "0.00000000086905080210590853",
+        "0.000000000026291829160960048",
+        "0.0000000013132730502687854",
+        "0.00000030402864856479032",
+        "0.00000014691129308112981",
+        "0.0000000032381378320635524",
+        "0.0000000042514976362911127",
+        "0.0000000052062675271048033",
+        "0.0000000032381378320634792",
+        "0.000000099703377000205783",
+        "0.00000018426255546487422",
+        "0.0000000024266666429307309",
+        "0.000000000017843312790204931",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "observed_total": "0.000025697984894269887",
+      "observed_values": null,
+      "oracle_output_sha256": "f5cf9dab910a0cdbe94910f1642e5de0d447e6ac57009b84156ac7956c29a317",
+      "physics_case_sha256": "5196d56b489f28409632be42ea1528fdce6b19d5fe76ec4179e4db919d78b984",
+      "point_id": "point:sm_ddbar_zgg:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,4,5,1",
+        "flow:2,5,4,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=bd03022f9c090a36ac752ea9ead5dca5620fca57e8ebd585f9765705fbdde802",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=lc",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:lc",
+        "point=point:sm_ddbar_zgg:stress-soft-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "6e763c52e24507815ac6da98834e4db71e3d12d4e6e18659742a10647e487fc4",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:lc:point:sm_ddbar_zgg:stress-soft-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "b155388f382d87b4c72d2635f5276be720bceb164df4ea55f6c16da6e5a1d5d1",
+      "observed_helicity_totals": [
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0.00028907022937087586",
+        "0.00028789186004136026",
+        "4.1803993825971659",
+        "4.1640369283649123",
+        "0.069527269266017711",
+        "0.069249423624041892",
+        "0.069794961942441086",
+        "0.06952726926602075",
+        "4.1806805755388909",
+        "4.1643058459544937",
+        "0.00029134189192302109",
+        "0.00029022564249256134",
+        "0.0000087803417154138123",
+        "0.0000088141121684823227",
+        "0.12598483035802752",
+        "0.12648022325306491",
+        "0.0021034432982981193",
+        "0.0021115419389058118",
+        "0.0020950374949384762",
+        "0.0021034432982980074",
+        "0.12597669465950842",
+        "0.12647171618216962",
+        "0.0000087097366260940532",
+        "0.0000087453864235800699",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "observed_total": "17.48204216623796",
+      "observed_values": null,
+      "oracle_output_sha256": "bc70fdad61e832bfadbadbd2dce006d399e622d6fa5684d99457ce42dffd49f0",
+      "physics_case_sha256": "5196d56b489f28409632be42ea1528fdce6b19d5fe76ec4179e4db919d78b984",
+      "point_id": "point:sm_ddbar_zgg:stress-soft-collinear",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=87931a6f865835e68a3e58c272db0b79db9934f18a2a6b16b0067cbc9897cafd",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=nlc",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:nlc",
+        "point=point:sm_ddbar_zgg:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "d87424ebbf8c7e2ae8ecf8cb39ae1ce3f259c990920c5339e05095e00a9e0df1",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:nlc:point:sm_ddbar_zgg:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "5220587ed8399d54d3d5c67ba4ecd9f76effcbfeb2289d22805691f122c49f56",
+      "observed_helicity_totals": null,
+      "observed_total": "0.014981403983888716",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.000000001290709116482262"
+        ],
+        [
+          "0.0002025161513731112"
+        ],
+        [
+          "0.00000000020844541839095915"
+        ],
+        [
+          "0.000013154844510478129"
+        ],
+        [
+          "0.0000082353564140620431"
+        ],
+        [
+          "0.00012633085090794249"
+        ],
+        [
+          "0.00000063575638130527721"
+        ],
+        [
+          "0.0000082353564140618567"
+        ],
+        [
+          "0.013136401998056725"
+        ],
+        [
+          "0.0001309476444219849"
+        ],
+        [
+          "0.00091372514598742115"
+        ],
+        [
+          "0.0000012888995991668629"
+        ],
+        [
+          "0.000000038993725090417147"
+        ],
+        [
+          "0.000027643384460562784"
+        ],
+        [
+          "0.0000039616246689262386"
+        ],
+        [
+          "0.00039742214872325114"
+        ],
+        [
+          "0.00000024914836209050517"
+        ],
+        [
+          "0.000000019233856208133593"
+        ],
+        [
+          "0.0000038219505025271249"
+        ],
+        [
+          "0.00000024914836209051073"
+        ],
+        [
+          "0.0000003979800992880594"
+        ],
+        [
+          "0.0000000000063062036378535325"
+        ],
+        [
+          "0.0000061268225532205186"
+        ],
+        [
+          "0.000000000039048469324016151"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "57004e0be51f8e716d408da5f3627b81a75b7ac6d8904aa127551034a0c37cf4",
+      "physics_case_sha256": "08711d5d0eeedb60300c79db2d378b14e8e5ef94bf4f7b746347a4fafe05502f",
+      "point_id": "point:sm_ddbar_zgg:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=f454b121c00bf5b8a0fe19e9866bc3f3d9062a92cc7c25c6cdda21f3cf554bdf",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=nlc",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:nlc",
+        "point=point:sm_ddbar_zgg:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "a69a6c0db70710fd5b2641b0f298bbdcefcf102a9103ff21ce41462218f33b3a",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:nlc:point:sm_ddbar_zgg:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "bcac1824bc417f87758f2874cf66bc923559e501d310d4eda0b09e2790dbf8d9",
+      "observed_helicity_totals": null,
+      "observed_total": "0.00090691933962912046",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000000050218400585297921"
+        ],
+        [
+          "0.0000015227442800382373"
+        ],
+        [
+          "0.00000044188962667335897"
+        ],
+        [
+          "0.0000052404119947770485"
+        ],
+        [
+          "0.0000010925857546280795"
+        ],
+        [
+          "0.0000015000033799806493"
+        ],
+        [
+          "0.00000025897375164813209"
+        ],
+        [
+          "0.0000010925857546280842"
+        ],
+        [
+          "0.00059427601103546413"
+        ],
+        [
+          "0.00027418169524926975"
+        ],
+        [
+          "0.00000062320727626135429"
+        ],
+        [
+          "0.000000056948939911880552"
+        ],
+        [
+          "0.0000000017229048007695681"
+        ],
+        [
+          "0.000000018854201848298417"
+        ],
+        [
+          "0.0000082949561442065942"
+        ],
+        [
+          "0.000017978929791836053"
+        ],
+        [
+          "0.000000033054544032143902"
+        ],
+        [
+          "0.00000000783486260987959"
+        ],
+        [
+          "0.000000045380353498030614"
+        ],
+        [
+          "0.000000033054544032143326"
+        ],
+        [
+          "0.00000015854080862229111"
+        ],
+        [
+          "0.000000013368708186383204"
+        ],
+        [
+          "0.000000046068345336748986"
+        ],
+        [
+          "0.000000000015192824236809683"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "a85af6625094773af4779f98cee182c4335187d91b427d425a839be496d0e422",
+      "physics_case_sha256": "08711d5d0eeedb60300c79db2d378b14e8e5ef94bf4f7b746347a4fafe05502f",
+      "point_id": "point:sm_ddbar_zgg:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=4a7db4918ff8305c3024a6a4501d5e1ca63c21a86d2f48fa5e6b8e14d3689a51",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=nlc",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:nlc",
+        "point=point:sm_ddbar_zgg:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "66f407c7f4c15227ad0cf2c136e99a51647a532339ddd4cf6ea79f71508c70e2",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:nlc:point:sm_ddbar_zgg:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "37240f414da2242d63e055c00ee16715b0e26b2e67e067ed9dd6786e36b56d38",
+      "observed_helicity_totals": null,
+      "observed_total": "0.000018743756960353458",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00000000043035086848322426"
+        ],
+        [
+          "0.000000059115768283467044"
+        ],
+        [
+          "0.000004442487116792543"
+        ],
+        [
+          "0.0000024046787380369732"
+        ],
+        [
+          "0.00000007809846998041092"
+        ],
+        [
+          "0.00000012497720003225663"
+        ],
+        [
+          "0.0000000992276637669188"
+        ],
+        [
+          "0.000000078098469980412164"
+        ],
+        [
+          "0.0000035432547369883152"
+        ],
+        [
+          "0.0000073304858579872696"
+        ],
+        [
+          "0.000000031856106925766326"
+        ],
+        [
+          "0.00000000063411495648065531"
+        ],
+        [
+          "0.000000000019184197360843423"
+        ],
+        [
+          "0.00000000096375875725092277"
+        ],
+        [
+          "0.00000022177285997320054"
+        ],
+        [
+          "0.00000010719586011877874"
+        ],
+        [
+          "0.0000000023627521262066652"
+        ],
+        [
+          "0.0000000030019842079186923"
+        ],
+        [
+          "0.0000000037809978246388916"
+        ],
+        [
+          "0.0000000023627521262066152"
+        ],
+        [
+          "0.000000072749950191927942"
+        ],
+        [
+          "0.00000013440078766562039"
+        ],
+        [
+          "0.0000000017884589447031801"
+        ],
+        [
+          "0.000000000013019620355925571"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "3a6bb0df612098df087542b90ab263c9d9be9e54431e93b76ecda2ba6a14e109",
+      "physics_case_sha256": "08711d5d0eeedb60300c79db2d378b14e8e5ef94bf4f7b746347a4fafe05502f",
+      "point_id": "point:sm_ddbar_zgg:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_ddbar_zgg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=bd03022f9c090a36ac752ea9ead5dca5620fca57e8ebd585f9765705fbdde802",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=nlc",
+        "process=d d~ > z g g",
+        "case=case:sm_ddbar_zgg:nlc",
+        "point=point:sm_ddbar_zgg:stress-soft-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "3d6602c1d47f627ed4213a62f5de9104723d1328790a2d08d4d4007eec17f4ed",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1,-1",
+        "h:-1,-1,-1,-1,+1",
+        "h:-1,-1,-1,+1,-1",
+        "h:-1,-1,-1,+1,+1",
+        "h:-1,-1,+0,-1,-1",
+        "h:-1,-1,+0,-1,+1",
+        "h:-1,-1,+0,+1,-1",
+        "h:-1,-1,+0,+1,+1",
+        "h:-1,-1,+1,-1,-1",
+        "h:-1,-1,+1,-1,+1",
+        "h:-1,-1,+1,+1,-1",
+        "h:-1,-1,+1,+1,+1",
+        "h:-1,+1,-1,-1,-1",
+        "h:-1,+1,-1,-1,+1",
+        "h:-1,+1,-1,+1,-1",
+        "h:-1,+1,-1,+1,+1",
+        "h:-1,+1,+0,-1,-1",
+        "h:-1,+1,+0,-1,+1",
+        "h:-1,+1,+0,+1,-1",
+        "h:-1,+1,+0,+1,+1",
+        "h:-1,+1,+1,-1,-1",
+        "h:-1,+1,+1,-1,+1",
+        "h:-1,+1,+1,+1,-1",
+        "h:-1,+1,+1,+1,+1",
+        "h:+1,-1,-1,-1,-1",
+        "h:+1,-1,-1,-1,+1",
+        "h:+1,-1,-1,+1,-1",
+        "h:+1,-1,-1,+1,+1",
+        "h:+1,-1,+0,-1,-1",
+        "h:+1,-1,+0,-1,+1",
+        "h:+1,-1,+0,+1,-1",
+        "h:+1,-1,+0,+1,+1",
+        "h:+1,-1,+1,-1,-1",
+        "h:+1,-1,+1,-1,+1",
+        "h:+1,-1,+1,+1,-1",
+        "h:+1,-1,+1,+1,+1",
+        "h:+1,+1,-1,-1,-1",
+        "h:+1,+1,-1,-1,+1",
+        "h:+1,+1,-1,+1,-1",
+        "h:+1,+1,-1,+1,+1",
+        "h:+1,+1,+0,-1,-1",
+        "h:+1,+1,+0,-1,+1",
+        "h:+1,+1,+0,+1,-1",
+        "h:+1,+1,+0,+1,+1",
+        "h:+1,+1,+1,-1,-1",
+        "h:+1,+1,+1,-1,+1",
+        "h:+1,+1,+1,+1,-1",
+        "h:+1,+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_ddbar_zgg:nlc:point:sm_ddbar_zgg:stress-soft-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "b155388f382d87b4c72d2635f5276be720bceb164df4ea55f6c16da6e5a1d5d1",
+      "observed_helicity_totals": null,
+      "observed_total": "13.812900229656536",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.00022840002683410422"
+        ],
+        [
+          "0.00022746435938143854"
+        ],
+        [
+          "3.303014543328604"
+        ],
+        [
+          "3.2900868008671114"
+        ],
+        [
+          "0.054934851647024593"
+        ],
+        [
+          "0.05471476340158242"
+        ],
+        [
+          "0.055145804941495589"
+        ],
+        [
+          "0.054934851647027001"
+        ],
+        [
+          "3.3032372711505"
+        ],
+        [
+          "3.2902987260666565"
+        ],
+        [
+          "0.00023019245852704611"
+        ],
+        [
+          "0.00022931294127905352"
+        ],
+        [
+          "0.0000069375192588239914"
+        ],
+        [
+          "0.0000069641277346142556"
+        ],
+        [
+          "0.099543055232949276"
+        ],
+        [
+          "0.099934491517354562"
+        ],
+        [
+          "0.0016619715797814725"
+        ],
+        [
+          "0.0016683536554503169"
+        ],
+        [
+          "0.0016553131398656979"
+        ],
+        [
+          "0.0016619715797813841"
+        ],
+        [
+          "0.099536643753749363"
+        ],
+        [
+          "0.099927753221010426"
+        ],
+        [
+          "0.0000068815931848538924"
+        ],
+        [
+          "0.000006909900400907713"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "d2840c4cd915317987af56449a815de8043f26d73c70cc5d4ab3a84d1b6b6955",
+      "physics_case_sha256": "08711d5d0eeedb60300c79db2d378b14e8e5ef94bf4f7b746347a4fafe05502f",
+      "point_id": "point:sm_ddbar_zgg:stress-soft-collinear",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "d d~ > z g g",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:incoming-d",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-d",
+          "leg:incoming-dbar",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2",
+          "leg:outgoing-z"
+        ],
+        "ordered_external_pdgs": [
+          1,
+          -1,
+          21,
+          21,
+          23
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          3,
+          4,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=d6f1f9a391361e05558fe4554193b363715dd487f28e63a3447ba7e45aab6d09",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=full",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:full",
+        "point=point:sm_gg_gg:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "fb004cd258a7537bc04e7162851f8f56943e08ec59606616a14b1ec247372635",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:full:point:sm_gg_gg:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "2662782b2eebadbc95a2dbe12aeb7d2014d91ddd67bab5c3d922df5274b7c29f",
+      "observed_helicity_totals": null,
+      "observed_total": "57.166204002315951",
+      "observed_values": [
+        [
+          "22.757065758393647"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "5.6561917320490238"
+        ],
+        [
+          "0.16984451071530238"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.16984451071530238"
+        ],
+        [
+          "5.6561917320490238"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "22.757065758393647"
+        ]
+      ],
+      "oracle_output_sha256": "253a763c5cc2f84486996cf9ef05c111fe0a1462cf69829795edebf1287ed7eb",
+      "physics_case_sha256": "398f7e906137fea36df30cb527842922c69705b0d68067eed77dfa93cd5360d4",
+      "point_id": "point:sm_gg_gg:generic-1",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=d241720113a15c8624ce1fed3c97de753028081e11219c1098d47f0c4c494549",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=full",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:full",
+        "point=point:sm_gg_gg:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "053062cc5b42404e16fea5c51ee6db55ec63eecdfb8527ac0c2f1a22d2f5728e",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:full:point:sm_gg_gg:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "6599d1e32abe64f015925b5ca4cf0b16604f241380a5fb9c4b9889d8ae65f3a4",
+      "observed_helicity_totals": null,
+      "observed_total": "315.2754906174606",
+      "observed_values": [
+        [
+          "98.596680832320274"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.020719473664169416"
+        ],
+        [
+          "59.02034500274587"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "59.02034500274587"
+        ],
+        [
+          "0.020719473664169416"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "98.596680832320274"
+        ]
+      ],
+      "oracle_output_sha256": "a5504e0fa25f3beb890fe30dbfbda8bcf504de8198937937c0a0ba7ce366103c",
+      "physics_case_sha256": "398f7e906137fea36df30cb527842922c69705b0d68067eed77dfa93cd5360d4",
+      "point_id": "point:sm_gg_gg:generic-2",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=8225418329c35f988a04739ed1f756bde9403cec75c6c6f826fde7e8e5870a94",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=full",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:full",
+        "point=point:sm_gg_gg:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "e1c3b9ad33be0e45b4184984fb47e38b7f989afd61e5aa09786c16418a2a5114",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:full:point:sm_gg_gg:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "2a01fea7621eeec6e92bec51de1ccf4513b522277ac95d056e3b38483a2f8b20",
+      "observed_helicity_totals": null,
+      "observed_total": "44.319606432410595",
+      "observed_values": [
+        [
+          "18.545106868908974"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.27354100231415701"
+        ],
+        [
+          "3.3411553449821696"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "3.3411553449821696"
+        ],
+        [
+          "0.27354100231415701"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "18.545106868908974"
+        ]
+      ],
+      "oracle_output_sha256": "454ae0ce13528924a98c73e62cd2aa9fd2bb1fe8ab12ebc335fecc512e1cbb77",
+      "physics_case_sha256": "398f7e906137fea36df30cb527842922c69705b0d68067eed77dfa93cd5360d4",
+      "point_id": "point:sm_gg_gg:generic-3",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=full",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:full",
+        "point=point:sm_gg_gg:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "5b6f1eec482120da6fa89440bdda780a17e62757a3e11cf80cc9d42283a9e5e9",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:full:point:sm_gg_gg:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "9c1379dc0401f8ef6f7f37261396bb12f2111850e4db05e27803d0b7cbc75994",
+      "observed_helicity_totals": null,
+      "observed_total": "4947262538690.3555",
+      "observed_values": [
+        [
+          "1236818108307.5688"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "1236813161037.6094"
+        ],
+        [
+          "0.0000000000012368230555973183"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000000000012368230555973183"
+        ],
+        [
+          "1236813161037.6094"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "1236818108307.5688"
+        ]
+      ],
+      "oracle_output_sha256": "d4fc572bd1dc9af02a063af90e8c3ed717c43b832b73380cc0a26b713576f962",
+      "physics_case_sha256": "398f7e906137fea36df30cb527842922c69705b0d68067eed77dfa93cd5360d4",
+      "point_id": "point:sm_gg_gg:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:1,2,3,4",
+        "flow:1,2,4,3",
+        "flow:1,3,2,4",
+        "flow:1,3,4,2",
+        "flow:1,4,2,3",
+        "flow:1,4,3,2"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=d6f1f9a391361e05558fe4554193b363715dd487f28e63a3447ba7e45aab6d09",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=lc",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:lc",
+        "point=point:sm_gg_gg:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "37f32b3b40163c1ef3f1190958dfc474523080e6fa35aaba39463a272a2f19bc",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:lc:point:sm_gg_gg:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "2662782b2eebadbc95a2dbe12aeb7d2014d91ddd67bab5c3d922df5274b7c29f",
+      "observed_helicity_totals": [
+        "25.601698978192857",
+        "0",
+        "0",
+        "0",
+        "0",
+        "6.3632156985551518",
+        "0.19107507455471515",
+        "0",
+        "0",
+        "0.19107507455471515",
+        "6.3632156985551518",
+        "0",
+        "0",
+        "0",
+        "0",
+        "25.601698978192857"
+      ],
+      "observed_total": "64.311979502605453",
+      "observed_values": null,
+      "oracle_output_sha256": "eec526cfee5c09fddc4e120bb38faa6d27923c7fde5924241b254d1f77fc003d",
+      "physics_case_sha256": "effb6e8dab6aafe7629da6a40c01555b8f0a845770971cb9912ecc4db1e33959",
+      "point_id": "point:sm_gg_gg:generic-1",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:1,2,3,4",
+        "flow:1,2,4,3",
+        "flow:1,3,2,4",
+        "flow:1,3,4,2",
+        "flow:1,4,2,3",
+        "flow:1,4,3,2"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=d241720113a15c8624ce1fed3c97de753028081e11219c1098d47f0c4c494549",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=lc",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:lc",
+        "point=point:sm_gg_gg:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "a461e7368595ab19d74d4849ce12cbf80cd0a68bcac1fc06965e22b08d6e605a",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:lc:point:sm_gg_gg:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "6599d1e32abe64f015925b5ca4cf0b16604f241380a5fb9c4b9889d8ae65f3a4",
+      "observed_helicity_totals": [
+        "110.92126593636031",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0.023309407872190591",
+        "66.397888128089093",
+        "0",
+        "0",
+        "66.397888128089093",
+        "0.023309407872190591",
+        "0",
+        "0",
+        "0",
+        "0",
+        "110.92126593636031"
+      ],
+      "observed_total": "354.68492694464328",
+      "observed_values": null,
+      "oracle_output_sha256": "1933b480c711f6a1309c8396705ca9f3a4aab13ae744113b12d63e7dec80b3fc",
+      "physics_case_sha256": "effb6e8dab6aafe7629da6a40c01555b8f0a845770971cb9912ecc4db1e33959",
+      "point_id": "point:sm_gg_gg:generic-2",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:1,2,3,4",
+        "flow:1,2,4,3",
+        "flow:1,3,2,4",
+        "flow:1,3,4,2",
+        "flow:1,4,2,3",
+        "flow:1,4,3,2"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=8225418329c35f988a04739ed1f756bde9403cec75c6c6f826fde7e8e5870a94",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=lc",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:lc",
+        "point=point:sm_gg_gg:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "a3718a94a1fc58a94755326940c24145be2be8412bc58831255cd9c538f6c9d1",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:lc:point:sm_gg_gg:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "2a01fea7621eeec6e92bec51de1ccf4513b522277ac95d056e3b38483a2f8b20",
+      "observed_helicity_totals": [
+        "20.863245227522597",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0.30773362760342665",
+        "3.7587997631049412",
+        "0",
+        "0",
+        "3.7587997631049412",
+        "0.30773362760342665",
+        "0",
+        "0",
+        "0",
+        "0",
+        "20.863245227522597"
+      ],
+      "observed_total": "49.859557236461931",
+      "observed_values": null,
+      "oracle_output_sha256": "165acbcede9e9cd450b8a1bb34e5961b9446a18ed26f2dc52ab1668440d4c643",
+      "physics_case_sha256": "effb6e8dab6aafe7629da6a40c01555b8f0a845770971cb9912ecc4db1e33959",
+      "point_id": "point:sm_gg_gg:generic-3",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:1,2,3,4",
+        "flow:1,2,4,3",
+        "flow:1,3,2,4",
+        "flow:1,3,4,2",
+        "flow:1,4,2,3",
+        "flow:1,4,3,2"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=lc",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:lc",
+        "point=point:sm_gg_gg:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "03d9667e48ce2921213c875d5d37fe162cd2c86b8af118449c0369cc0435995c",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:lc:point:sm_gg_gg:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "9c1379dc0401f8ef6f7f37261396bb12f2111850e4db05e27803d0b7cbc75994",
+      "observed_helicity_totals": [
+        "1391420371846.0149",
+        "0",
+        "0",
+        "0",
+        "0",
+        "1391414806167.3108",
+        "0.0000000000013914259375469832",
+        "0",
+        "0",
+        "0.0000000000013914259375469832",
+        "1391414806167.3108",
+        "0",
+        "0",
+        "0",
+        "0",
+        "1391420371846.0149"
+      ],
+      "observed_total": "5565670356026.6504",
+      "observed_values": null,
+      "oracle_output_sha256": "01015d1123b3a83f5247f9be99960b236a0b4dcdf946d3be0525abdc8a44c5bc",
+      "physics_case_sha256": "effb6e8dab6aafe7629da6a40c01555b8f0a845770971cb9912ecc4db1e33959",
+      "point_id": "point:sm_gg_gg:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=d6f1f9a391361e05558fe4554193b363715dd487f28e63a3447ba7e45aab6d09",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=nlc",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:nlc",
+        "point=point:sm_gg_gg:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "59703f13ad2d284ea73296ff982ba01342c6c27532db3b24f523805c35b321f6",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:nlc:point:sm_gg_gg:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "2662782b2eebadbc95a2dbe12aeb7d2014d91ddd67bab5c3d922df5274b7c29f",
+      "observed_helicity_totals": null,
+      "observed_total": "57.166204002315972",
+      "observed_values": [
+        [
+          "22.757065758393647"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "5.6561917320490238"
+        ],
+        [
+          "0.1698445107153024"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.1698445107153024"
+        ],
+        [
+          "5.6561917320490238"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "22.757065758393647"
+        ]
+      ],
+      "oracle_output_sha256": "708723ed7417f28ea3ff47ecda120ff843d29a213a5414d10eb512c4c788c7d3",
+      "physics_case_sha256": "5f538cea8fbcd47d427d490c10e05a2241208e16455bbe228ca5db046e385862",
+      "point_id": "point:sm_gg_gg:generic-1",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=d241720113a15c8624ce1fed3c97de753028081e11219c1098d47f0c4c494549",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=nlc",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:nlc",
+        "point=point:sm_gg_gg:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "fef84ea8d2b6943c192e9583741fd6efeccede6e6d8a238014980ac66727ace0",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:nlc:point:sm_gg_gg:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "6599d1e32abe64f015925b5ca4cf0b16604f241380a5fb9c4b9889d8ae65f3a4",
+      "observed_helicity_totals": null,
+      "observed_total": "315.27549061746072",
+      "observed_values": [
+        [
+          "98.596680832320274"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.02071947366416942"
+        ],
+        [
+          "59.020345002745863"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "59.020345002745863"
+        ],
+        [
+          "0.02071947366416942"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "98.596680832320274"
+        ]
+      ],
+      "oracle_output_sha256": "3af3438c3d1100a7060be31c99bd6cc4329c2b0e3e477830cf4e525c2df6abf7",
+      "physics_case_sha256": "5f538cea8fbcd47d427d490c10e05a2241208e16455bbe228ca5db046e385862",
+      "point_id": "point:sm_gg_gg:generic-2",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=8225418329c35f988a04739ed1f756bde9403cec75c6c6f826fde7e8e5870a94",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=nlc",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:nlc",
+        "point=point:sm_gg_gg:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "c610365addb6be394bcd3544029d2c34b2921b967db52ef4425a974fe46dd04e",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:nlc:point:sm_gg_gg:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "2a01fea7621eeec6e92bec51de1ccf4513b522277ac95d056e3b38483a2f8b20",
+      "observed_helicity_totals": null,
+      "observed_total": "44.319606432410616",
+      "observed_values": [
+        [
+          "18.545106868908974"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.27354100231415701"
+        ],
+        [
+          "3.34115534498217"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "3.34115534498217"
+        ],
+        [
+          "0.27354100231415701"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "18.545106868908974"
+        ]
+      ],
+      "oracle_output_sha256": "9855fa7bed4c1732ed95172b0979e0d4f1455ee59577732d01df879a5086ecc0",
+      "physics_case_sha256": "5f538cea8fbcd47d427d490c10e05a2241208e16455bbe228ca5db046e385862",
+      "point_id": "point:sm_gg_gg:generic-3",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_gg:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=1796f0f4029b541d5503fda53148683b60929b7d28bbb2e3d5439a8d2abfe927",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=3",
+        "color_accuracy=nlc",
+        "process=g g > g g",
+        "case=case:sm_gg_gg:nlc",
+        "point=point:sm_gg_gg:stress-near-collinear",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "b2ac13847ea4faf74be0d3fb4dca342aad8a431f5838769167f0569b4dad0def",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_gg:nlc:point:sm_gg_gg:stress-near-collinear",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "9c1379dc0401f8ef6f7f37261396bb12f2111850e4db05e27803d0b7cbc75994",
+      "observed_helicity_totals": null,
+      "observed_total": "4947262538690.3555",
+      "observed_values": [
+        [
+          "1236818108307.5688"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "1236813161037.6096"
+        ],
+        [
+          "0.0000000000012368230555973183"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0.0000000000012368230555973183"
+        ],
+        [
+          "1236813161037.6096"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "1236818108307.5688"
+        ]
+      ],
+      "oracle_output_sha256": "f4a99aa898100e029e26f838966971f89f4c60680862f59d5d3e4069c440ec70",
+      "physics_case_sha256": "5f538cea8fbcd47d427d490c10e05a2241208e16455bbe228ca5db046e385862",
+      "point_id": "point:sm_gg_gg:stress-near-collinear",
+      "process_identity": {
+        "color_order_count": 6,
+        "expression": "g g > g g",
+        "ordered_color_legs": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-g-1",
+          "leg:outgoing-g-2"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          21,
+          21
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=07a57a487115a7cb05e33c7e5d0461c7ecce6ed83d922bb07a55dde45663387b",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:full",
+        "point=point:sm_gg_ttbar:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "be00d5e9e91cd0ac80c54a6ec2517a6103bdf191ea0fd361cd9bbdaaf3b81e2f",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:full:point:sm_gg_ttbar:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "e6ecfb02d53652298a9a4b66dc30a834021ad31960aff6265fe0af88cf611204",
+      "observed_helicity_totals": null,
+      "observed_total": "1.621078769243431",
+      "observed_values": [
+        [
+          "0.20852519192643637"
+        ],
+        [
+          "0.00000006252065770828103"
+        ],
+        [
+          "0.000000062520657708280686"
+        ],
+        [
+          "0.00021176543672018407"
+        ],
+        [
+          "0.010472261072627834"
+        ],
+        [
+          "0.5673709644825462"
+        ],
+        [
+          "0.013486815589441691"
+        ],
+        [
+          "0.010472261072627841"
+        ],
+        [
+          "0.010472261072627836"
+        ],
+        [
+          "0.013486815589441689"
+        ],
+        [
+          "0.5673709644825462"
+        ],
+        [
+          "0.010472261072627836"
+        ],
+        [
+          "0.0002117654367201842"
+        ],
+        [
+          "0.000000062520657708280911"
+        ],
+        [
+          "0.000000062520657708280779"
+        ],
+        [
+          "0.20852519192643634"
+        ]
+      ],
+      "oracle_output_sha256": "3b3ce0e7ce8b535eec126e71bac947aff74ec98923fbda14e22fefa22660c08e",
+      "physics_case_sha256": "b18ae14698a7879b2be9a6a7d2bf0496a490de8f6239e0236e93e87e458cbc61",
+      "point_id": "point:sm_gg_ttbar:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=28eb0b504cb6b3f8463d20d7ff98b4ca4811b230a4b6c341fd50f1eb68d07b71",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:full",
+        "point=point:sm_gg_ttbar:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "686d90b54a6c08da4b55abfe1b80dbfa4a0db0eb2ca05725544d1e06bc4d38ca",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:full:point:sm_gg_ttbar:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "9dcb98a7a2c876efcf71d30cc0142ec32b2e851bb8de6c958a5cdc3ac2998a3b",
+      "observed_helicity_totals": null,
+      "observed_total": "0.47906713204733004",
+      "observed_values": [
+        [
+          "0.045283474977377364"
+        ],
+        [
+          "0.000000030751591009523623"
+        ],
+        [
+          "0.000000030751591009518832"
+        ],
+        [
+          "0.000045985586626623174"
+        ],
+        [
+          "0.0090129081742816777"
+        ],
+        [
+          "0.042353474923449465"
+        ],
+        [
+          "0.1338247526844662"
+        ],
+        [
+          "0.0090129081742816777"
+        ],
+        [
+          "0.0090129081742816794"
+        ],
+        [
+          "0.1338247526844662"
+        ],
+        [
+          "0.042353474923449458"
+        ],
+        [
+          "0.0090129081742816759"
+        ],
+        [
+          "0.000045985586626623235"
+        ],
+        [
+          "0.000000030751591009529771"
+        ],
+        [
+          "0.000000030751591009521195"
+        ],
+        [
+          "0.045283474977377364"
+        ]
+      ],
+      "oracle_output_sha256": "8a520e5f471e2269d30da26982c0de5165d662b1ac00ad47581aaa8161200a10",
+      "physics_case_sha256": "b18ae14698a7879b2be9a6a7d2bf0496a490de8f6239e0236e93e87e458cbc61",
+      "point_id": "point:sm_gg_ttbar:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=40f292db725bc6a6bf49125b6c7d614301f05877ee61d356214bff639b43acb1",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:full",
+        "point=point:sm_gg_ttbar:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "b7485b296b4b61925fd6d39c2818a597e5d9f117d3cbaa087d9e7ffa54bee4ff",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:full:point:sm_gg_ttbar:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "955f65ab0578da4cf498025535587eae84ee70c297c4b1a0290e9796e9bb44aa",
+      "observed_helicity_totals": null,
+      "observed_total": "1.6327956461834441",
+      "observed_values": [
+        [
+          "0.21066837456303772"
+        ],
+        [
+          "0.000000062786527773916107"
+        ],
+        [
+          "0.000000062786527773921467"
+        ],
+        [
+          "0.0002139419581739677"
+        ],
+        [
+          "0.010464796306441902"
+        ],
+        [
+          "0.57120867623303295"
+        ],
+        [
+          "0.013377112151537857"
+        ],
+        [
+          "0.010464796306441903"
+        ],
+        [
+          "0.010464796306441903"
+        ],
+        [
+          "0.013377112151537857"
+        ],
+        [
+          "0.57120867623303284"
+        ],
+        [
+          "0.010464796306441905"
+        ],
+        [
+          "0.00021394195817396732"
+        ],
+        [
+          "0.000000062786527773920858"
+        ],
+        [
+          "0.000000062786527773929593"
+        ],
+        [
+          "0.21066837456303775"
+        ]
+      ],
+      "oracle_output_sha256": "944a5d647199468b14a4223a69d6bbe7d6647b76bc02a047054091a6040cf137",
+      "physics_case_sha256": "b18ae14698a7879b2be9a6a7d2bf0496a490de8f6239e0236e93e87e458cbc61",
+      "point_id": "point:sm_gg_ttbar:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=030ce6947652ddcd49e0c9be14e480084d64ca625038e898f47759d5d3bc9e94",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=full",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:full",
+        "point=point:sm_gg_ttbar:stress-near-threshold",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "6cdaf9ae42b18cca6e72b5a8fbc80d8039bc017e97289ff111f28bcd49ef6ff6",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:full:point:sm_gg_ttbar:stress-near-threshold",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "93d550c716a1e598846e431d9f9384eb08a0831a2115798f2787392e9eafc1e5",
+      "observed_helicity_totals": null,
+      "observed_total": "0.32066037990744473",
+      "observed_values": [
+        [
+          "0.08039102560761896"
+        ],
+        [
+          "0.00000068946715009596786"
+        ],
+        [
+          "0.00000068946715009596796"
+        ],
+        [
+          "0.0799375545426073"
+        ],
+        [
+          "0.000000020778193557676918"
+        ],
+        [
+          "0.00000018700411602676332"
+        ],
+        [
+          "0.0000000023086927904538691"
+        ],
+        [
+          "0.000000020778193557676938"
+        ],
+        [
+          "0.000000020778193557676938"
+        ],
+        [
+          "0.0000000023086927904538691"
+        ],
+        [
+          "0.00000018700411602676332"
+        ],
+        [
+          "0.000000020778193557676918"
+        ],
+        [
+          "0.0799375545426073"
+        ],
+        [
+          "0.00000068946715009596796"
+        ],
+        [
+          "0.00000068946715009596796"
+        ],
+        [
+          "0.08039102560761896"
+        ]
+      ],
+      "oracle_output_sha256": "cbf4b52fc3ca6861d3b142844ee8208ecd02b6fcc28b4d1eafdb672c2400ac94",
+      "physics_case_sha256": "b18ae14698a7879b2be9a6a7d2bf0496a490de8f6239e0236e93e87e458cbc61",
+      "point_id": "point:sm_gg_ttbar:stress-near-threshold",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:3,1,2,4",
+        "flow:3,2,1,4"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=07a57a487115a7cb05e33c7e5d0461c7ecce6ed83d922bb07a55dde45663387b",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:lc",
+        "point=point:sm_gg_ttbar:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "adf179b290b3d245f34b513905ef00172fc02212147773b9aab99bc7a454a133",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:lc:point:sm_gg_ttbar:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "e6ecfb02d53652298a9a4b66dc30a834021ad31960aff6265fe0af88cf611204",
+      "observed_helicity_totals": [
+        "0.27627811354141346",
+        "0.000000075738418826724572",
+        "0.000000075738418826724135",
+        "0.00028057040088419233",
+        "0.013874854104874549",
+        "0.75171821070365064",
+        "0.017868882120592004",
+        "0.013874854104874556",
+        "0.013874854104874551",
+        "0.017868882120591994",
+        "0.75171821070365052",
+        "0.013874854104874549",
+        "0.00028057040088419255",
+        "0.000000075738418826724373",
+        "0.000000075738418826724281",
+        "0.27627811354141341"
+      ],
+      "observed_total": "2.1477912729062543",
+      "observed_values": null,
+      "oracle_output_sha256": "dc72a308b17cde4464377443a3389291f7f96514c61cfb589e6d67d50bdbcae2",
+      "physics_case_sha256": "d776b97323c01627a112706c8dce489a9fa8671eaeb430a96a7ad44a698a0702",
+      "point_id": "point:sm_gg_ttbar:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:3,1,2,4",
+        "flow:3,2,1,4"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=28eb0b504cb6b3f8463d20d7ff98b4ca4811b230a4b6c341fd50f1eb68d07b71",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:lc",
+        "point=point:sm_gg_ttbar:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "623a86a97e7a398758e0687934ad67f10840c60b3c5c12cf336eca90737bdf12",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:lc:point:sm_gg_ttbar:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "9dcb98a7a2c876efcf71d30cc0142ec32b2e851bb8de6c958a5cdc3ac2998a3b",
+      "observed_helicity_totals": [
+        "0.064313478312075942",
+        "0.000000035098890440321045",
+        "0.000000035098890440315877",
+        "0.000065310570540114403",
+        "0.012800507879431022",
+        "0.060152170530918321",
+        "0.19006349205781684",
+        "0.012800507879431022",
+        "0.012800507879431029",
+        "0.19006349205781681",
+        "0.060152170530918314",
+        "0.012800507879431022",
+        "0.000065310570540114485",
+        "0.000000035098890440327775",
+        "0.000000035098890440318517",
+        "0.064313478312075942"
+      ],
+      "observed_total": "0.68039107485598815",
+      "observed_values": null,
+      "oracle_output_sha256": "b2cc3e9592db52935f8da9e51c3b7b4a5faa146f54c09c290eae1d621c1acd62",
+      "physics_case_sha256": "d776b97323c01627a112706c8dce489a9fa8671eaeb430a96a7ad44a698a0702",
+      "point_id": "point:sm_gg_ttbar:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:3,1,2,4",
+        "flow:3,2,1,4"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=40f292db725bc6a6bf49125b6c7d614301f05877ee61d356214bff639b43acb1",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:lc",
+        "point=point:sm_gg_ttbar:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "ea656fecdc0716bfe6e40f423f5ef58d2e0ab05edff99fdc26576f33b8719f0a",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:lc:point:sm_gg_ttbar:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "955f65ab0578da4cf498025535587eae84ee70c297c4b1a0290e9796e9bb44aa",
+      "observed_helicity_totals": [
+        "0.27904292148401866",
+        "0.000000076079125939158665",
+        "0.000000076079125939163721",
+        "0.00028337821308762825",
+        "0.013861251944465655",
+        "0.75660023781416896",
+        "0.017718789395613613",
+        "0.013861251944465658",
+        "0.013861251944465658",
+        "0.017718789395613617",
+        "0.75660023781416874",
+        "0.013861251944465657",
+        "0.00028337821308762766",
+        "0.000000076079125939164687",
+        "0.000000076079125939174507",
+        "0.27904292148401871"
+      ],
+      "observed_total": "2.1627359659081438",
+      "observed_values": null,
+      "oracle_output_sha256": "53ff7f00f53f34f759f3836609b1f5d58f6203fdbad447d60e91e8973373a791",
+      "physics_case_sha256": "d776b97323c01627a112706c8dce489a9fa8671eaeb430a96a7ad44a698a0702",
+      "point_id": "point:sm_gg_ttbar:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:3,1,2,4",
+        "flow:3,2,1,4"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=030ce6947652ddcd49e0c9be14e480084d64ca625038e898f47759d5d3bc9e94",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=lc",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:lc",
+        "point=point:sm_gg_ttbar:stress-near-threshold",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "helicity-aggregate",
+      "evidence_record_sha256": "168b99ea3baf8a9a2c4315467513884f30d7d0a870b30e5a5e3e985280584ccc",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:lc:point:sm_gg_ttbar:stress-near-threshold",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "93d550c716a1e598846e431d9f9384eb08a0831a2115798f2787392e9eafc1e5",
+      "observed_helicity_totals": [
+        "0.11627943870572015",
+        "0.00000077565076448280164",
+        "0.00000077565076448280174",
+        "0.11562352766948669",
+        "0.000000030054161833495436",
+        "0.00000027048799747664251",
+        "0.0000000033393579935387964",
+        "0.000000030054161833495462",
+        "0.000000030054161833495462",
+        "0.0000000033393579935387964",
+        "0.00000027048799747664251",
+        "0.000000030054161833495436",
+        "0.11562352766948669",
+        "0.00000077565076448280174",
+        "0.00000077565076448280174",
+        "0.11627943870572015"
+      ],
+      "observed_total": "0.46380970322482967",
+      "observed_values": null,
+      "oracle_output_sha256": "71e84889f4b937d2e06baddbd767ab6da2093d3c7b8a2891ed78bc07bb5a7a25",
+      "physics_case_sha256": "d776b97323c01627a112706c8dce489a9fa8671eaeb430a96a7ad44a698a0702",
+      "point_id": "point:sm_gg_ttbar:stress-near-threshold",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=07a57a487115a7cb05e33c7e5d0461c7ecce6ed83d922bb07a55dde45663387b",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:nlc",
+        "point=point:sm_gg_ttbar:generic-1",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "46956e3bf82aa54c5ff53767b79b3ec61ed9ff5468107ed49f10ba4451ac4427",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:nlc:point:sm_gg_ttbar:generic-1",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "e6ecfb02d53652298a9a4b66dc30a834021ad31960aff6265fe0af88cf611204",
+      "observed_helicity_totals": null,
+      "observed_total": "1.621078769243431",
+      "observed_values": [
+        [
+          "0.20852519192643637"
+        ],
+        [
+          "0.00000006252065770828103"
+        ],
+        [
+          "0.000000062520657708280686"
+        ],
+        [
+          "0.00021176543672018407"
+        ],
+        [
+          "0.010472261072627834"
+        ],
+        [
+          "0.5673709644825462"
+        ],
+        [
+          "0.013486815589441691"
+        ],
+        [
+          "0.010472261072627841"
+        ],
+        [
+          "0.010472261072627836"
+        ],
+        [
+          "0.013486815589441689"
+        ],
+        [
+          "0.5673709644825462"
+        ],
+        [
+          "0.010472261072627836"
+        ],
+        [
+          "0.0002117654367201842"
+        ],
+        [
+          "0.000000062520657708280911"
+        ],
+        [
+          "0.000000062520657708280779"
+        ],
+        [
+          "0.20852519192643634"
+        ]
+      ],
+      "oracle_output_sha256": "4af8032d70626013c629a698649f2f729dbca02328d8649f3a59f40e3aae1255",
+      "physics_case_sha256": "9b752367b61eaf756835ae5e33171100f2a7bfe9d103f7a71f18babb9352f3f4",
+      "point_id": "point:sm_gg_ttbar:generic-1",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=28eb0b504cb6b3f8463d20d7ff98b4ca4811b230a4b6c341fd50f1eb68d07b71",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:nlc",
+        "point=point:sm_gg_ttbar:generic-2",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "f707373e03f642f6376e8fa732cd7dc86b35ca2084f5f81b7d2336c6c3ccf175",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:nlc:point:sm_gg_ttbar:generic-2",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "9dcb98a7a2c876efcf71d30cc0142ec32b2e851bb8de6c958a5cdc3ac2998a3b",
+      "observed_helicity_totals": null,
+      "observed_total": "0.47906713204733004",
+      "observed_values": [
+        [
+          "0.045283474977377364"
+        ],
+        [
+          "0.000000030751591009523623"
+        ],
+        [
+          "0.000000030751591009518832"
+        ],
+        [
+          "0.000045985586626623174"
+        ],
+        [
+          "0.0090129081742816777"
+        ],
+        [
+          "0.042353474923449465"
+        ],
+        [
+          "0.1338247526844662"
+        ],
+        [
+          "0.0090129081742816777"
+        ],
+        [
+          "0.0090129081742816794"
+        ],
+        [
+          "0.1338247526844662"
+        ],
+        [
+          "0.042353474923449458"
+        ],
+        [
+          "0.0090129081742816759"
+        ],
+        [
+          "0.000045985586626623235"
+        ],
+        [
+          "0.000000030751591009529771"
+        ],
+        [
+          "0.000000030751591009521195"
+        ],
+        [
+          "0.045283474977377364"
+        ]
+      ],
+      "oracle_output_sha256": "af332fb827e235429ac5b5970df65572a7ca3b1053aa6af5c07866dc78ddd494",
+      "physics_case_sha256": "9b752367b61eaf756835ae5e33171100f2a7bfe9d103f7a71f18babb9352f3f4",
+      "point_id": "point:sm_gg_ttbar:generic-2",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=40f292db725bc6a6bf49125b6c7d614301f05877ee61d356214bff639b43acb1",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:nlc",
+        "point=point:sm_gg_ttbar:generic-3",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "84ed318b44834e9398679e506aa228ff576a7110139382ece04f69679df5a7a1",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:nlc:point:sm_gg_ttbar:generic-3",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "955f65ab0578da4cf498025535587eae84ee70c297c4b1a0290e9796e9bb44aa",
+      "observed_helicity_totals": null,
+      "observed_total": "1.6327956461834441",
+      "observed_values": [
+        [
+          "0.21066837456303772"
+        ],
+        [
+          "0.000000062786527773916107"
+        ],
+        [
+          "0.000000062786527773921467"
+        ],
+        [
+          "0.0002139419581739677"
+        ],
+        [
+          "0.010464796306441902"
+        ],
+        [
+          "0.57120867623303295"
+        ],
+        [
+          "0.013377112151537857"
+        ],
+        [
+          "0.010464796306441903"
+        ],
+        [
+          "0.010464796306441903"
+        ],
+        [
+          "0.013377112151537857"
+        ],
+        [
+          "0.57120867623303284"
+        ],
+        [
+          "0.010464796306441905"
+        ],
+        [
+          "0.00021394195817396732"
+        ],
+        [
+          "0.000000062786527773920858"
+        ],
+        [
+          "0.000000062786527773929593"
+        ],
+        [
+          "0.21066837456303775"
+        ]
+      ],
+      "oracle_output_sha256": "32cbe6e5821719fb8978d59d5c93b2294c6ae71e38d898fbc290f596fd51c24b",
+      "physics_case_sha256": "9b752367b61eaf756835ae5e33171100f2a7bfe9d103f7a71f18babb9352f3f4",
+      "point_id": "point:sm_gg_ttbar:generic-3",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_gg_ttbar:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=030ce6947652ddcd49e0c9be14e480084d64ca625038e898f47759d5d3bc9e94",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=2",
+        "color_accuracy=nlc",
+        "process=g g > t t~",
+        "case=case:sm_gg_ttbar:nlc",
+        "point=point:sm_gg_ttbar:stress-near-threshold",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "da84ace5cb85c20898d079ddd0fcdde89b250f87d245796f9531136993674a78",
+      "helicity_ids": [
+        "h:-1,-1,-1,-1",
+        "h:-1,-1,-1,+1",
+        "h:-1,-1,+1,-1",
+        "h:-1,-1,+1,+1",
+        "h:-1,+1,-1,-1",
+        "h:-1,+1,-1,+1",
+        "h:-1,+1,+1,-1",
+        "h:-1,+1,+1,+1",
+        "h:+1,-1,-1,-1",
+        "h:+1,-1,-1,+1",
+        "h:+1,-1,+1,-1",
+        "h:+1,-1,+1,+1",
+        "h:+1,+1,-1,-1",
+        "h:+1,+1,-1,+1",
+        "h:+1,+1,+1,-1",
+        "h:+1,+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_gg_ttbar:nlc:point:sm_gg_ttbar:stress-near-threshold",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "93d550c716a1e598846e431d9f9384eb08a0831a2115798f2787392e9eafc1e5",
+      "observed_helicity_totals": null,
+      "observed_total": "0.32066037990744473",
+      "observed_values": [
+        [
+          "0.08039102560761896"
+        ],
+        [
+          "0.00000068946715009596786"
+        ],
+        [
+          "0.00000068946715009596796"
+        ],
+        [
+          "0.0799375545426073"
+        ],
+        [
+          "0.000000020778193557676918"
+        ],
+        [
+          "0.00000018700411602676332"
+        ],
+        [
+          "0.0000000023086927904538691"
+        ],
+        [
+          "0.000000020778193557676938"
+        ],
+        [
+          "0.000000020778193557676938"
+        ],
+        [
+          "0.0000000023086927904538691"
+        ],
+        [
+          "0.00000018700411602676332"
+        ],
+        [
+          "0.000000020778193557676918"
+        ],
+        [
+          "0.0799375545426073"
+        ],
+        [
+          "0.00000068946715009596796"
+        ],
+        [
+          "0.00000068946715009596796"
+        ],
+        [
+          "0.08039102560761896"
+        ]
+      ],
+      "oracle_output_sha256": "3524e623e2314e044a7d4d23f339a394dbce3602f7a4a9d84e93f09bbc601d57",
+      "physics_case_sha256": "9b752367b61eaf756835ae5e33171100f2a7bfe9d103f7a71f18babb9352f3f4",
+      "point_id": "point:sm_gg_ttbar:stress-near-threshold",
+      "process_identity": {
+        "color_order_count": 2,
+        "expression": "g g > t t~",
+        "ordered_color_legs": [
+          "leg:outgoing-t",
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-g-1",
+          "leg:incoming-g-2",
+          "leg:outgoing-t",
+          "leg:outgoing-tbar"
+        ],
+        "ordered_external_pdgs": [
+          21,
+          21,
+          6,
+          -6
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2,
+          3
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_udbar_wplus:full",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=86282eb72766a35dbe2cebf8b4c6050e77fe62d24a40d915cb203d96f10d0406",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=full",
+        "process=u d~ > w+",
+        "case=case:sm_udbar_wplus:full",
+        "point=point:sm_udbar_wplus:canonical",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "55b17c47a98ca77c7dcaa488e6c897203fe554ed8f7c9faadf1426f3f2ae9962",
+      "helicity_ids": [
+        "h:-1,-1,-1",
+        "h:-1,-1,+0",
+        "h:-1,-1,+1",
+        "h:-1,+1,-1",
+        "h:-1,+1,+0",
+        "h:-1,+1,+1",
+        "h:+1,-1,-1",
+        "h:+1,-1,+0",
+        "h:+1,-1,+1",
+        "h:+1,+1,-1",
+        "h:+1,+1,+0",
+        "h:+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_udbar_wplus:full:point:sm_udbar_wplus:canonical",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "ed554de3f0ea6a73929dec1305172f832977416f4df004bbab2390ce7106a8d2",
+      "observed_helicity_totals": null,
+      "observed_total": "229.97056761391966",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "229.97056761391966"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "414ba04eff5e9807677bb5283ef3041759c607491b25ae47b204d6163750fc48",
+      "physics_case_sha256": "1b51f369a6313b99189b9dd1533f608511d332a449147f4a6f90d5a04860ce93",
+      "point_id": "point:sm_udbar_wplus:canonical",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "u d~ > w+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-u",
+          "leg:outgoing-wplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-u",
+          "leg:incoming-dbar",
+          "leg:outgoing-wplus"
+        ],
+        "ordered_external_pdgs": [
+          2,
+          -1,
+          24
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_udbar_wplus:lc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "flow:2,1"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=86282eb72766a35dbe2cebf8b4c6050e77fe62d24a40d915cb203d96f10d0406",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=lc",
+        "process=u d~ > w+",
+        "case=case:sm_udbar_wplus:lc",
+        "point=point:sm_udbar_wplus:canonical",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "1b89ef15543ac2bc0b2759cf75f4f4f6c4f08c9005edd43fcbd20fb604bae521",
+      "helicity_ids": [
+        "h:-1,-1,-1",
+        "h:-1,-1,+0",
+        "h:-1,-1,+1",
+        "h:-1,+1,-1",
+        "h:-1,+1,+0",
+        "h:-1,+1,+1",
+        "h:+1,-1,-1",
+        "h:+1,-1,+0",
+        "h:+1,-1,+1",
+        "h:+1,+1,-1",
+        "h:+1,+1,+0",
+        "h:+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_udbar_wplus:lc:point:sm_udbar_wplus:canonical",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "ed554de3f0ea6a73929dec1305172f832977416f4df004bbab2390ce7106a8d2",
+      "observed_helicity_totals": null,
+      "observed_total": "229.97056761391966",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "229.97056761391966"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "2e1cef1a645984db0f86015ba30e830d7b019c1ddb23618e6a25861dbfe23df5",
+      "physics_case_sha256": "377df53b4d1303b30d7e2c3bf774c81da2a49ff201d5bf413c7a855d6d1750ba",
+      "point_id": "point:sm_udbar_wplus:canonical",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "u d~ > w+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-u",
+          "leg:outgoing-wplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-u",
+          "leg:incoming-dbar",
+          "leg:outgoing-wplus"
+        ],
+        "ordered_external_pdgs": [
+          2,
+          -1,
+          24
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    },
+    {
+      "arithmetic": "binary64",
+      "arithmetic_precision_bits": 53,
+      "case_id": "case:sm_udbar_wplus:nlc",
+      "certified_decimal_digits": 10,
+      "color_ids": [
+        "color:contracted"
+      ],
+      "command": [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        "compiler_identity=gfortran",
+        "compiler_version=GNU Fortran (MacPorts gcc14 14.2.0_3+stdlib_flag) 14.2.0",
+        "compiler_flags=[\"-ffast-math\",\"-O3\"]",
+        "compiler_target=aarch64-apple-darwin24",
+        "oracle_executable_sha256=9643ba99b3c86b046dbdcf09905a850283aa8ba83a6c877c25ad23da6bc9694d",
+        "binary64_input_sha256=86282eb72766a35dbe2cebf8b4c6050e77fe62d24a40d915cb203d96f10d0406",
+        "mode=1",
+        "group=1",
+        "integral=1",
+        "pdg_match_count=1",
+        "color_accuracy=nlc",
+        "process=u d~ > w+",
+        "case=case:sm_udbar_wplus:nlc",
+        "point=point:sm_udbar_wplus:canonical",
+        "helicities=summed-then-each-physical"
+      ],
+      "coverage": "resolved",
+      "evidence_record_sha256": "6953dc5ac71edfa373f7ed939c3a533ba9460078ca81ca9a07590a6d6ebd7dfd",
+      "helicity_ids": [
+        "h:-1,-1,-1",
+        "h:-1,-1,+0",
+        "h:-1,-1,+1",
+        "h:-1,+1,-1",
+        "h:-1,+1,+0",
+        "h:-1,+1,+1",
+        "h:+1,-1,-1",
+        "h:+1,-1,+0",
+        "h:+1,-1,+1",
+        "h:+1,+1,-1",
+        "h:+1,+1,+0",
+        "h:+1,+1,+1"
+      ],
+      "id": "evidence:fortran:case:sm_udbar_wplus:nlc:point:sm_udbar_wplus:canonical",
+      "independent_of_pyamplicol": true,
+      "input_sha256": "ed554de3f0ea6a73929dec1305172f832977416f4df004bbab2390ce7106a8d2",
+      "observed_helicity_totals": null,
+      "observed_total": "229.97056761391966",
+      "observed_values": [
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "229.97056761391966"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ],
+        [
+          "0"
+        ]
+      ],
+      "oracle_output_sha256": "12e71cbd91d39758f2bc55105cabd2e1f2accf120f5093f7ffd9ca3a64e336b9",
+      "physics_case_sha256": "e93172ece779b67db1bb23861c86df4affb8eb4cddbd1f165e388149f47c2508",
+      "point_id": "point:sm_udbar_wplus:canonical",
+      "process_identity": {
+        "color_order_count": 1,
+        "expression": "u d~ > w+",
+        "ordered_color_legs": [
+          "leg:incoming-dbar",
+          "leg:incoming-u",
+          "leg:outgoing-wplus"
+        ],
+        "ordered_external_leg_ids": [
+          "leg:incoming-u",
+          "leg:incoming-dbar",
+          "leg:outgoing-wplus"
+        ],
+        "ordered_external_pdgs": [
+          2,
+          -1,
+          24
+        ],
+        "row_id": "group:1:integral:1",
+        "source_to_row_permutation": [
+          0,
+          1,
+          2
+        ]
+      },
+      "round_trip_decimal_digits": 17,
+      "tolerances": {
+        "absolute": "0.000000000001",
+        "relative": "0.0000000001"
+      }
+    }
+  ]
+}
diff --git a/pyamplicol/tests/fixtures/reference/physics-v1.json b/pyamplicol/tests/fixtures/reference/physics-v1.json
new file mode 100644
index 0000000000..e60bf76533
--- /dev/null
+++ b/pyamplicol/tests/fixtures/reference/physics-v1.json
@@ -0,0 +1,306 @@
+{
+  "fixture_schema_version": 1,
+  "source": {
+    "repository_commit": "643bc6f99d7b2249af0a85204768df243e612411",
+    "process_artifact_schema": 2,
+    "runtime_schema": 2,
+    "note": "Clean compact values captured before the standalone schema-v3 port."
+  },
+  "cases": {
+    "builtin_sm_ddbar_z_lc": {
+      "model": "built-in-sm",
+      "process": "d d~ > z",
+      "process_id": "d_dbar_to_z",
+      "color_accuracy": "lc",
+      "momenta": [
+        [
+          [45.594, 0.0, 0.0, 45.594],
+          [45.594, 0.0, 0.0, -45.594],
+          [91.188, 0.0, 0.0, 0.0]
+        ]
+      ],
+      "coverage": {
+        "helicities": "complete",
+        "color": "complete",
+        "color_kind": "physical-lc-flows"
+      },
+      "topology": {
+        "source_count": 7,
+        "current_count": 13,
+        "interaction_count": 6,
+        "interaction_evaluation_count": 6,
+        "amplitude_root_count": 6
+      },
+      "resolved": {
+        "h:-1,+1,-1": {
+          "flow:2,1": 137.93356063778558
+        },
+        "h:+1,-1,+1": {
+          "flow:2,1": 4.172973090944297
+        }
+      },
+      "total": 142.1065337287299
+    },
+    "builtin_sm_ddbar_z_nlc": {
+      "model": "built-in-sm",
+      "process": "d d~ > z",
+      "process_id": "d_dbar_to_z",
+      "color_accuracy": "nlc",
+      "momenta_from": "builtin_sm_ddbar_z_lc",
+      "coverage": {
+        "helicities": "complete",
+        "color": "contracted",
+        "color_kind": "contracted-color"
+      },
+      "topology": {
+        "source_count": 7,
+        "current_count": 13,
+        "interaction_count": 6,
+        "interaction_evaluation_count": 6,
+        "amplitude_root_count": 6
+      },
+      "resolved": {
+        "h:-1,+1,-1": {
+          "color:contracted": 137.93356063778558
+        },
+        "h:+1,-1,+1": {
+          "color:contracted": 4.172973090944296
+        }
+      },
+      "total": 142.1065337287299
+    },
+    "builtin_sm_ddbar_z_full": {
+      "model": "built-in-sm",
+      "process": "d d~ > z",
+      "process_id": "d_dbar_to_z",
+      "color_accuracy": "full",
+      "momenta_from": "builtin_sm_ddbar_z_lc",
+      "coverage": {
+        "helicities": "complete",
+        "color": "contracted",
+        "color_kind": "contracted-color"
+      },
+      "topology_from": "builtin_sm_ddbar_z_nlc",
+      "resolved_from": "builtin_sm_ddbar_z_nlc",
+      "total": 142.1065337287299
+    },
+    "builtin_sm_ddbar_zg_lc": {
+      "model": "built-in-sm",
+      "process": "d d~ > z g",
+      "process_id": "d_dbar_to_z_g",
+      "color_accuracy": "lc",
+      "momenta": [
+        [
+          [500.0, 0.0, 0.0, 500.0],
+          [500.0, 0.0, 0.0, -500.0],
+          [
+            504.157625672,
+            -304.1084262865,
+            208.76026523528103,
+            331.35611794513767
+          ],
+          [
+            495.842374328,
+            304.1084262865,
+            -208.76026523528103,
+            -331.35611794513767
+          ]
+        ]
+      ],
+      "coverage": {
+        "helicities": "complete",
+        "color": "complete",
+        "color_kind": "physical-lc-flows"
+      },
+      "topology": {
+        "source_count": 9,
+        "current_count": 31,
+        "interaction_count": 34,
+        "interaction_evaluation_count": 34,
+        "amplitude_root_count": 12
+      },
+      "resolved": {
+        "h:-1,+1,-1,-1": {
+          "flow:2,4,1": 0.000026091034789099317
+        },
+        "h:-1,+1,-1,+1": {
+          "flow:2,4,1": 0.3773466872450282
+        },
+        "h:-1,+1,+0,-1": {
+          "flow:2,4,1": 0.0012478598189341644
+        },
+        "h:-1,+1,+0,+1": {
+          "flow:2,4,1": 0.0012478598189342007
+        },
+        "h:-1,+1,+1,-1": {
+          "flow:2,4,1": 0.014920394498506004
+        },
+        "h:-1,+1,+1,+1": {
+          "flow:2,4,1": 1.0316468782852936e-6
+        },
+        "h:+1,-1,-1,-1": {
+          "flow:2,4,1": 3.121092968625858e-8
+        },
+        "h:+1,-1,-1,+1": {
+          "flow:2,4,1": 0.00045139416731248123
+        },
+        "h:+1,-1,+0,-1": {
+          "flow:2,4,1": 0.00003775212806517328
+        },
+        "h:+1,-1,+0,+1": {
+          "flow:2,4,1": 0.00003775212806517224
+        },
+        "h:+1,-1,+1,-1": {
+          "flow:2,4,1": 0.011416058314955969
+        },
+        "h:+1,-1,+1,+1": {
+          "flow:2,4,1": 7.893451425916166e-7
+        }
+      },
+      "total": 0.40673370135754094
+    },
+    "builtin_sm_ddbar_zg_nlc": {
+      "model": "built-in-sm",
+      "process": "d d~ > z g",
+      "process_id": "d_dbar_to_z_g",
+      "color_accuracy": "nlc",
+      "momenta_from": "builtin_sm_ddbar_zg_lc",
+      "coverage": {
+        "helicities": "complete",
+        "color": "contracted",
+        "color_kind": "contracted-color"
+      },
+      "topology": {
+        "source_count": 9,
+        "current_count": 31,
+        "interaction_count": 34,
+        "interaction_evaluation_count": 34,
+        "amplitude_root_count": 12
+      },
+      "resolved": {
+        "h:-1,+1,-1,-1": {
+          "color:contracted": 0.000023192030923643838
+        },
+        "h:-1,+1,-1,+1": {
+          "color:contracted": 0.33541927755113615
+        },
+        "h:-1,+1,+0,-1": {
+          "color:contracted": 0.0011092087279414794
+        },
+        "h:-1,+1,+0,+1": {
+          "color:contracted": 0.0011092087279415115
+        },
+        "h:-1,+1,+1,-1": {
+          "color:contracted": 0.013262572887560891
+        },
+        "h:-1,+1,+1,+1": {
+          "color:contracted": 9.170194473647053e-7
+        },
+        "h:+1,-1,-1,-1": {
+          "color:contracted": 2.7743048610007626e-8
+        },
+        "h:+1,-1,-1,+1": {
+          "color:contracted": 0.00040123925983331666
+        },
+        "h:+1,-1,+0,-1": {
+          "color:contracted": 0.000033557447169042914
+        },
+        "h:+1,-1,+0,+1": {
+          "color:contracted": 0.000033557447169041986
+        },
+        "h:+1,-1,+1,-1": {
+          "color:contracted": 0.010147607391071971
+        },
+        "h:+1,-1,+1,+1": {
+          "color:contracted": 7.016401267481036e-7
+        }
+      },
+      "total": 0.3615410678733697
+    },
+    "builtin_sm_ddbar_zg_full": {
+      "model": "built-in-sm",
+      "process": "d d~ > z g",
+      "process_id": "d_dbar_to_z_g",
+      "color_accuracy": "full",
+      "momenta_from": "builtin_sm_ddbar_zg_lc",
+      "coverage": {
+        "helicities": "complete",
+        "color": "contracted",
+        "color_kind": "contracted-color"
+      },
+      "topology_from": "builtin_sm_ddbar_zg_nlc",
+      "resolved_from": "builtin_sm_ddbar_zg_nlc",
+      "total": 0.3615410678733697
+    },
+    "scalars_2to2_lc": {
+      "model": "scalars-json",
+      "process": "scalar_0 scalar_0 > scalar_0 scalar_0",
+      "process_id": "scalar_0_scalar_0_to_scalar_0_scalar_0",
+      "color_accuracy": "lc",
+      "momenta": [
+        [
+          [500.0, 0.0, 0.0, 500.0],
+          [500.0, 0.0, 0.0, -500.0],
+          [
+            499.99999999999994,
+            -306.65836769058797,
+            210.51071473894038,
+            334.1345305493651
+          ],
+          [
+            499.99999999999994,
+            306.65836769058797,
+            -210.51071473894038,
+            -334.1345305493651
+          ]
+        ]
+      ],
+      "coverage": {
+        "helicities": "complete",
+        "color": "complete",
+        "color_kind": "physical-lc-flows"
+      },
+      "topology": {
+        "source_count": 4,
+        "current_count": 8,
+        "interaction_count": 6,
+        "interaction_evaluation_count": 6,
+        "amplitude_root_count": 1
+      },
+      "resolved": {
+        "h:+0,+0,+0,+0": {
+          "flow:singlet": 0.5
+        }
+      },
+      "total": 0.5
+    },
+    "scalar_gravity_2to2_lc": {
+      "model": "scalar-gravity-json",
+      "process": "scalar_0 scalar_0 > graviton graviton",
+      "process_id": "scalar_0_scalar_0_to_graviton_graviton",
+      "color_accuracy": "lc",
+      "momenta_from": "scalars_2to2_lc",
+      "coverage": {
+        "helicities": "complete",
+        "color": "complete",
+        "color_kind": "physical-lc-flows"
+      },
+      "topology": {
+        "source_count": 6,
+        "current_count": 14,
+        "interaction_count": 12,
+        "interaction_evaluation_count": 12,
+        "amplitude_root_count": 2
+      },
+      "resolved": {
+        "h:+0,+0,-2,+2": {
+          "flow:singlet": 598183164.8212746
+        },
+        "h:+0,+0,+2,-2": {
+          "flow:singlet": 598183164.8212746
+        }
+      },
+      "total": 1196366329.6425493
+    }
+  }
+}
diff --git a/pyamplicol/tests/fixtures/reference/physics-v2.json b/pyamplicol/tests/fixtures/reference/physics-v2.json
new file mode 100644
index 0000000000..1a215afc29
--- /dev/null
+++ b/pyamplicol/tests/fixtures/reference/physics-v2.json
@@ -0,0 +1,24471 @@
+{
+  "cases": [
+    {
+      "artifact_execution_sha256": "3ab7d6fa415cf5816aa3ceb30cef63e70c0c3774a6516c18a332048291fd2dff",
+      "artifact_physics_sha256": "12e68df59fc6dba1ab16f08e2bedb3b6026a64711c9f5c2b5ff2958e0a2abe45",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:2,1",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:2,1",
+            "word": [
+              2,
+              1
+            ]
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0",
+            "index": 1,
+            "representative_id": "h:-1,-1,+0",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1",
+            "index": 3,
+            "representative_id": "h:-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0",
+            "index": 4,
+            "representative_id": "h:-1,+1,+0",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1",
+            "index": 6,
+            "representative_id": "h:+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0",
+            "index": 7,
+            "representative_id": "h:+1,-1,+0",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1",
+            "index": 8,
+            "representative_id": "h:+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1",
+            "index": 9,
+            "representative_id": "h:+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0",
+            "index": 10,
+            "representative_id": "h:+1,+1,+0",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 1,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 12,
+        "structural_zero_helicity_count": 6
+      },
+      "id": "case:sm_ddbar_z:lc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "3",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.1896710455205285",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_z:lc:point:sm_ddbar_z:canonical"
+          ],
+          "point_id": "point:sm_ddbar_z:canonical",
+          "round_trip_decimal_digits": 80,
+          "total": "142.1065337287298727339265066580453053148858490850532613596025043412428069409520387",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "137.93356063778557711130826661684067959236898740561550246151952652207085844429728"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "4.1729730909442956226182400412046257225168616794377588980829778191719484966547587"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "7fac82a4f56a5e7542ea8d7f91b4c810d62539c447264fd8a7498fcf5721e04f",
+      "point_ids": [
+        "point:sm_ddbar_z:canonical"
+      ],
+      "point_policy": "degenerate-2to1",
+      "process_id": "sm_ddbar_z",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:+1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:+1,-1,+0"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:-1,+1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:-1,+1,+0"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:-1,+1,+1"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "85e36a8e07aee3e7c29f4983e7280508d784c273d541ba68d2af31246ea63a07"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 13,
+        "interactions": 6,
+        "reduction_groups": 6,
+        "roots": 6
+      }
+    },
+    {
+      "artifact_execution_sha256": "84a105e7b51ca1cf273b53c54533549204dd09bd6b3b564c6f0ab37f2bb0093a",
+      "artifact_physics_sha256": "2d36e335a22cb48e2716ed0253624a096aac248e9b86febf4e5d3084aca7b789",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:2,1",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:2,1",
+            "word": [
+              2,
+              1
+            ]
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0",
+            "index": 1,
+            "representative_id": "h:-1,-1,+0",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1",
+            "index": 3,
+            "representative_id": "h:-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0",
+            "index": 4,
+            "representative_id": "h:-1,+1,+0",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1",
+            "index": 6,
+            "representative_id": "h:+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+0",
+            "index": 7,
+            "representative_id": "h:+1,-1,+0",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1",
+            "index": 8,
+            "representative_id": "h:+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1",
+            "index": 9,
+            "representative_id": "h:+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0",
+            "index": 10,
+            "representative_id": "h:+1,+1,+0",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 1,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 12,
+        "structural_zero_helicity_count": 9
+      },
+      "id": "case:sm_udbar_wplus:lc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "3",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.1896710455205285",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_udbar_wplus:lc:point:sm_udbar_wplus:canonical"
+          ],
+          "point_id": "point:sm_udbar_wplus:canonical",
+          "round_trip_decimal_digits": 80,
+          "total": "229.970567613919698564848796014301632487598997204214635866698377469141207513162",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "229.970567613919698564848796014301632487598997204214635866698377469141207513162"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "377df53b4d1303b30d7e2c3bf774c81da2a49ff201d5bf413c7a855d6d1750ba",
+      "point_ids": [
+        "point:sm_udbar_wplus:canonical"
+      ],
+      "point_policy": "degenerate-2to1",
+      "process_id": "sm_udbar_wplus",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:-1,+1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:-1,+1,+0"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:-1,+1,+1"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "69a4998b88aabdb220dcdb7683b35514872c5d72533eb4582bda48dd0d31480e"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 10,
+        "interactions": 3,
+        "reduction_groups": 3,
+        "roots": 3
+      }
+    },
+    {
+      "artifact_execution_sha256": "1492bda4318ebcf383e298351811f0dd9a198bee2f1957e2c36d922404f7c9cd",
+      "artifact_physics_sha256": "b65b096a4e35cff8ba8fa084347a3c8fd44c8bbc62d96bf88aee54935fc3dece",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0",
+            "index": 1,
+            "representative_id": "h:-1,-1,+0",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1",
+            "index": 3,
+            "representative_id": "h:-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0",
+            "index": 4,
+            "representative_id": "h:-1,+1,+0",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1",
+            "index": 6,
+            "representative_id": "h:+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0",
+            "index": 7,
+            "representative_id": "h:+1,-1,+0",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1",
+            "index": 8,
+            "representative_id": "h:+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1",
+            "index": 9,
+            "representative_id": "h:+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0",
+            "index": 10,
+            "representative_id": "h:+1,+1,+0",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "nlc",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 12,
+        "structural_zero_helicity_count": 6
+      },
+      "id": "case:sm_ddbar_z:nlc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "3",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.1896710455205285",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_z:nlc:point:sm_ddbar_z:canonical"
+          ],
+          "point_id": "point:sm_ddbar_z:canonical",
+          "round_trip_decimal_digits": 80,
+          "total": "142.1065337287298727339265066580453053148858490850532613596025043412428069409520387",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "137.93356063778557711130826661684067959236898740561550246151952652207085844429728"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "4.1729730909442956226182400412046257225168616794377588980829778191719484966547587"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "fb0ce6bde633c5f2236439d80241cc79244e967c385d3a5b4f1621694c610586",
+      "point_ids": [
+        "point:sm_ddbar_z:canonical"
+      ],
+      "point_policy": "degenerate-2to1",
+      "process_id": "sm_ddbar_z",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "c7a0e7cb91bfe6bf85aef53720778f7ac88c7be08abdec0c186989c64e5104d9"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 13,
+        "interactions": 6,
+        "reduction_groups": 6,
+        "roots": 6
+      }
+    },
+    {
+      "artifact_execution_sha256": "d7dd69ff390cbbe163a96d9b07666b597f75bacb7d27b906908ecfc671f1ecf6",
+      "artifact_physics_sha256": "213ac16d85dfa2b412d9911581a796f41f66bf2f9b9c47adac1dfad98044f3d2",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0",
+            "index": 1,
+            "representative_id": "h:-1,-1,+0",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1",
+            "index": 3,
+            "representative_id": "h:-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0",
+            "index": 4,
+            "representative_id": "h:-1,+1,+0",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1",
+            "index": 6,
+            "representative_id": "h:+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+0",
+            "index": 7,
+            "representative_id": "h:+1,-1,+0",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1",
+            "index": 8,
+            "representative_id": "h:+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1",
+            "index": 9,
+            "representative_id": "h:+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0",
+            "index": 10,
+            "representative_id": "h:+1,+1,+0",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "nlc",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 12,
+        "structural_zero_helicity_count": 9
+      },
+      "id": "case:sm_udbar_wplus:nlc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "3",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.1896710455205285",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_udbar_wplus:nlc:point:sm_udbar_wplus:canonical"
+          ],
+          "point_id": "point:sm_udbar_wplus:canonical",
+          "round_trip_decimal_digits": 80,
+          "total": "229.970567613919698564848796014301632487598997204214635866698377469141207513162",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "229.970567613919698564848796014301632487598997204214635866698377469141207513162"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "e93172ece779b67db1bb23861c86df4affb8eb4cddbd1f165e388149f47c2508",
+      "point_ids": [
+        "point:sm_udbar_wplus:canonical"
+      ],
+      "point_policy": "degenerate-2to1",
+      "process_id": "sm_udbar_wplus",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "2eee370c66cecbab1c47c91f5ab7adb29121d902fdbc510ca92cb3d91728a6ab"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 10,
+        "interactions": 3,
+        "reduction_groups": 3,
+        "roots": 3
+      }
+    },
+    {
+      "artifact_execution_sha256": "38247a15856e672ded3c1db96a04cb96979dd6ea11ca58891334db63212aa454",
+      "artifact_physics_sha256": "c2f2de04529fcb4c240997c9ca6fa8984f1944afcd5b082240abbaec4e420c39",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0",
+            "index": 1,
+            "representative_id": "h:-1,-1,+0",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1",
+            "index": 3,
+            "representative_id": "h:-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0",
+            "index": 4,
+            "representative_id": "h:-1,+1,+0",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1",
+            "index": 6,
+            "representative_id": "h:+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0",
+            "index": 7,
+            "representative_id": "h:+1,-1,+0",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1",
+            "index": 8,
+            "representative_id": "h:+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1",
+            "index": 9,
+            "representative_id": "h:+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0",
+            "index": 10,
+            "representative_id": "h:+1,+1,+0",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "full",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 12,
+        "structural_zero_helicity_count": 6
+      },
+      "id": "case:sm_ddbar_z:full",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "3",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.1896710455205285",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_z:full:point:sm_ddbar_z:canonical"
+          ],
+          "point_id": "point:sm_ddbar_z:canonical",
+          "round_trip_decimal_digits": 80,
+          "total": "142.1065337287298727339265066580453053148858490850532613596025043412428069409520387",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "137.93356063778557711130826661684067959236898740561550246151952652207085844429728"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "4.1729730909442956226182400412046257225168616794377588980829778191719484966547587"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "c3a2cbe972134531fc4e0fbea590b92bcc75b2e8b5acd8b0e675679a9dc744af",
+      "point_ids": [
+        "point:sm_ddbar_z:canonical"
+      ],
+      "point_policy": "degenerate-2to1",
+      "process_id": "sm_ddbar_z",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "c7a0e7cb91bfe6bf85aef53720778f7ac88c7be08abdec0c186989c64e5104d9"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 13,
+        "interactions": 6,
+        "reduction_groups": 6,
+        "roots": 6
+      }
+    },
+    {
+      "artifact_execution_sha256": "d146b2da1c4d5cb0c73e1c0ff724a10a3edfefc1ad9678e0f23e0842f49fc92c",
+      "artifact_physics_sha256": "14e0385d4863c5e9654ca48ec373da5293d5bdb072d3a853d8d30522ae3c082b",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0",
+            "index": 1,
+            "representative_id": "h:-1,-1,+0",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1",
+            "index": 3,
+            "representative_id": "h:-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0",
+            "index": 4,
+            "representative_id": "h:-1,+1,+0",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1",
+            "index": 6,
+            "representative_id": "h:+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+0",
+            "index": 7,
+            "representative_id": "h:+1,-1,+0",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1",
+            "index": 8,
+            "representative_id": "h:+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1",
+            "index": 9,
+            "representative_id": "h:+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0",
+            "index": 10,
+            "representative_id": "h:+1,+1,+0",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "full",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 12,
+        "structural_zero_helicity_count": 9
+      },
+      "id": "case:sm_udbar_wplus:full",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "3",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.1896710455205285",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_udbar_wplus:full:point:sm_udbar_wplus:canonical"
+          ],
+          "point_id": "point:sm_udbar_wplus:canonical",
+          "round_trip_decimal_digits": 80,
+          "total": "229.970567613919698564848796014301632487598997204214635866698377469141207513162",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "229.970567613919698564848796014301632487598997204214635866698377469141207513162"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "1b51f369a6313b99189b9dd1533f608511d332a449147f4a6f90d5a04860ce93",
+      "point_ids": [
+        "point:sm_udbar_wplus:canonical"
+      ],
+      "point_policy": "degenerate-2to1",
+      "process_id": "sm_udbar_wplus",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "2eee370c66cecbab1c47c91f5ab7adb29121d902fdbc510ca92cb3d91728a6ab"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 10,
+        "interactions": 3,
+        "reduction_groups": 3,
+        "roots": 3
+      }
+    },
+    {
+      "artifact_execution_sha256": "e22e941a006844926b76125d9b925a144d809a4e79915ab67153a9997ff17325",
+      "artifact_physics_sha256": "43a2cfdc9b6c8f58ff43f0ae4836479c01dc3faa79aab7df6c7097fa1685065f",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:2,4,1",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:2,4,1",
+            "word": [
+              2,
+              4,
+              1
+            ]
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+0,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+0,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 4,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 5,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,-1",
+            "index": 8,
+            "representative_id": "h:-1,+1,+0,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+0,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,-1",
+            "index": 14,
+            "representative_id": "h:+1,-1,+0,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,+1",
+            "index": 15,
+            "representative_id": "h:+1,-1,+0,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1",
+            "index": 16,
+            "representative_id": "h:+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1",
+            "index": 17,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 18,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 19,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,-1",
+            "index": 20,
+            "representative_id": "h:+1,+1,+0,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,+1",
+            "index": 21,
+            "representative_id": "h:+1,+1,+0,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 22,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 23,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 1,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 24,
+        "structural_zero_helicity_count": 12
+      },
+      "id": "case:sm_ddbar_zg:lc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "9",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.2812502450332261",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:lc:point:sm_ddbar_zg:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_zg:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.243080731837403482643098599563334623815112450260257094175149225997736629194967315006837",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000018886942080970052342808449325113055603970150198982590442976863156874005250274018"
+            ],
+            [
+              "0.027315608921040422764416995687615577907073624183103044572850745673318473546546215"
+            ],
+            [
+              "0.0012478598189341807576420159889773934100513711241908635398086658982184333438577249"
+            ],
+            [
+              "0.0012478598189341810107037531189202746196561320555397285240691148156324026782382919"
+            ],
+            [
+              "0.20611517219604904007817940241046435525739744833827214008153511501734783308552879"
+            ],
+            [
+              "0.000014251504810048243146767463835240716136982966230011916204018944037439119400284914"
+            ],
+            [
+              "0.00000043115791256898042628041154192016122608931210092753348470122960374462942609686393"
+            ],
+            [
+              "0.0062357055326667378959730661456177478722442015146023454058795548712142274838664755"
+            ],
+            [
+              "0.000037752128065172794918729364483310566010332191229263551987111117998373480785337985"
+            ],
+            [
+              "0.000037752128065172787262725890724045791933692650987358677345223715941452887997746475"
+            ],
+            [
+              "0.00082639279710607209665654448757208932812221008952860700193402867751990060005111326"
+            ],
+            [
+              "0.000000057139611788228538037748650156879699968819452905111006648350588660938744210807107"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:lc:point:sm_ddbar_zg:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_zg:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.532156441667184166789690187361921588525091157097833713527999930719671201599969041710869",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000077424015154664166473967028694430208802069059308029211961500057787106635799532961"
+            ],
+            [
+              "0.011197599431367964459131065620363393991753608840053298795074392185966048387592682"
+            ],
+            [
+              "0.0012478598189341720664340881539771927940565981045798910940808076828022003521022914"
+            ],
+            [
+              "0.0012478598189341722849669731566831319512752737359249950825006159413762687110424975"
+            ],
+            [
+              "0.50280075393912942054011539552516377929894368408785767064861815302781683623257924"
+            ],
+            [
+              "0.000034765356120624127725906610667764766695477413296325514174600065010247353764969038"
+            ],
+            [
+              "0.0000010517737301759915216977841367770997078920167235992164733990858476653784059291716"
+            ],
+            [
+              "0.015211483025543795438686179166871927020156420486491574094938583234949288712964679"
+            ],
+            [
+              "0.000037752128065172530934644468247036201422674459571004325334356639865782711618677943"
+            ],
+            [
+              "0.000037752128065172524323259650904032607820128921204417375088063043806961567171712001"
+            ],
+            [
+              "0.00033876658366688440893494980119342049137371578051015681634970995294590424498582896"
+            ],
+            [
+              "0.000000023423475065775251287753426187999797662561027700273247634858706126881382539367659"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:lc:point:sm_ddbar_zg:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_zg:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.189815793118969248780468151569734782202225669697713964485946264123814313234411109040506",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000098264690783786314560789422576782807882448484058827965828471892279622562147687821"
+            ],
+            [
+              "0.14211722854285025742682380421954888744820543709562413872422142420581705098671739"
+            ],
+            [
+              "0.0012478598189341689629796507830245289820088701586236379692596101363855541003683494"
+            ],
+            [
+              "0.0012478598189341689551922886314351688133495422242688038087964641170077583977293043"
+            ],
+            [
+              "0.039616318824445761847347911428647976227557874167002724200511872562323598248125175"
+            ],
+            [
+              "0.0000027392071736765507401887400035403014431389879376456692430119323867761239643218373"
+            ],
+            [
+              "0.000000082870606496491110332001340200645936054263750367305033529386834869963016404609976"
+            ],
+            [
+              "0.0011985323343519552330301558977633750222563511199095518192375779380650808053951474"
+            ],
+            [
+              "0.000037752128065172430197303293390333040934684974320805015378578777234671102321234885"
+            ],
+            [
+              "0.000037752128065172430432898260690251933202262632014734287646359025636889913751532256"
+            ],
+            [
+              "0.0042995436913736421972675454109467313105755857541205334102294220724185422583571205"
+            ],
+            [
+              "0.00000029728509039762388999396068611019596762347173513947980556678047555907845036007013"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:lc:point:sm_ddbar_zg:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_zg:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "77309.64806454978210714872474235938556912792308724219701817170688672390272703235074652844692181617",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "5.1881236419847702272257922124599354750131183685721807013586559365663342564421219"
+            ],
+            [
+              "75034.251617282718842337070477490559626248337762389045354144932421861741878103076"
+            ],
+            [
+              "0.0012478598189341743336267622038209000273633709786726124404522063755024271083155887"
+            ],
+            [
+              "0.0012478598189341743336267622038209000273633709786726124404522063755024271083155887"
+            ],
+            [
+              "0.000000075034551755339671097510856213572286800148176222360291068915113795307764132622001"
+            ],
+            [
+              "0.0000000000051881443945519721463252787574474619095304863360771179355969254738066374762309884"
+            ],
+            [
+              "0.00000000000015695953073561169247715701795427701152286951687355889735556470696721678535452777"
+            ],
+            [
+              "0.0000000022700578736479312144661349156878916064756056390423276522559722259225153337533353"
+            ],
+            [
+              "0.000037752128065172592913775092178786566554444779056962259423981318923860505152615205"
+            ],
+            [
+              "0.000037752128065172592913775092178786566554444779056962259423981318923860505152615205"
+            ],
+            [
+              "2270.0487934209767384885706435102072135338301346164095158153495722796300453138559"
+            ],
+            [
+              "0.1569589028978026690918581757510009325186560911096731434109148725715782723387349"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "7dc9c595c3faa505ffa7a42df5398253a1eb7ace715a3e9ede8363fb034cecc5",
+      "point_ids": [
+        "point:sm_ddbar_zg:generic-1",
+        "point:sm_ddbar_zg:generic-2",
+        "point:sm_ddbar_zg:generic-3",
+        "point:sm_ddbar_zg:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_zg",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:+1,-1,+0,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:+1,-1,+0,+1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:-1,+1,+0,-1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:-1,+1,+0,+1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "flow:2,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,4,1",
+            "representative_helicity_id": "h:-1,+1,+1,+1"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "020d86072f660814d6771b2c384536aeb8b288e2391b72bf0fdff716eef37e2e"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 31,
+        "interactions": 34,
+        "reduction_groups": 12,
+        "roots": 12
+      }
+    },
+    {
+      "artifact_execution_sha256": "ccac4a939baff3f014171f929ebddb59e72883b45c60ccca746a3ae9f1e1e214",
+      "artifact_physics_sha256": "a451fd3b4c67b06d0857cb398bc0f02b729e67c8340f5198f6317b5ad73c6881",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:2,1",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:2,1",
+            "word": [
+              2,
+              1
+            ]
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 1,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 12
+      },
+      "id": "case:sm_ddbar_ee:lc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "3",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.03597510550885039",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:lc:point:sm_ddbar_ee:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_ee:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.001031970703712502686312134631466313143340008621571928840302236470080212994892891364",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00082062602145063693256030030979546017480568537593612310021138462355119326198786432"
+            ],
+            [
+              "0.000034317817325785205531356253586993688950692295302899983477888086223587749120796993"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.000032587346469362564542138255429673164504552110774513836771348676501996425486446071"
+            ],
+            [
+              "0.00014443951846671798367833981265418611507907883955839191984161508380343555829778398"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:lc:point:sm_ddbar_ee:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_ee:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.0026304340923297408406298912901995888953536362482245966904664910074579303034219670518",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.002230861734305682641766515890376943624217330931703691561667376504846800479088321"
+            ],
+            [
+              "0.0000035470834122141295075943507534052519534106466699648275962968484033608616290589735"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000033682222564516166998941282520250805400832584486928479030073510711835044625785083"
+            ],
+            [
+              "0.00039265705235539245265588692081721493864281141140224745329981030313658545824200857"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:lc:point:sm_ddbar_ee:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_ee:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.0021223265191563302236938903335663971309271160368644809367900588518401037957084245679",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0017903979982851032436610001264771814772114665986040068993804715707385451493929557"
+            ],
+            [
+              "0.0000086162867492653806076934785570595736923973719237199532057722760671802441772622262"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000081818117659458182133995650021051045217396198791369184826335623166885070709666617"
+            ],
+            [
+              "0.00031513042235601578121179716353005097550151244645761716572118144271768989506723998"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:lc:point:sm_ddbar_ee:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_ee:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "0.00369301772413452389211927094899004168166681553272455547244418012164998162564600902134520319249",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0031402908059099281418368930853819616030433940202771631596122542683706675303112562"
+            ],
+            [
+              "0.00000000000000014363181962999636827113447336007389619797804671776612181972171684557602336779234"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000000000013638920639602738149094571871511658027358908138212471016287303499298532183540015"
+            ],
+            [
+              "0.00055272691822431572925635183985831799843134632197092074570382596244733150058291426"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "37f9baa3ba2ab4fe0dc56b6fa2bd743a1d3731d2714cd8da879bcbf2f59d25cb",
+      "point_ids": [
+        "point:sm_ddbar_ee:generic-1",
+        "point:sm_ddbar_ee:generic-2",
+        "point:sm_ddbar_ee:generic-3",
+        "point:sm_ddbar_ee:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_ee",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "flow:2,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,1",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "6ba49e303cb9d3168a6e21ed4913ca78d9506913d6df76b12ddc735d96ed948c"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 16,
+        "interactions": 12,
+        "reduction_groups": 4,
+        "roots": 4
+      }
+    },
+    {
+      "artifact_execution_sha256": "60e7d88ac9b2ee5e675ab3c7d33d9ca8d1840f63dec741a4ea61ec86392aa71f",
+      "artifact_physics_sha256": "d764350a83cf852838bcc9240c3c2d9d4a1fc287c49ea3f09829a546a707c0e4",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:2,1,3,4",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:2,1,3,4",
+            "word": [
+              2,
+              1,
+              3,
+              4
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:2,4,3,1",
+            "index": 1,
+            "kind": "lc-flow",
+            "representative_id": "flow:2,4,3,1",
+            "word": [
+              2,
+              4,
+              3,
+              1
+            ]
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 2,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 12
+      },
+      "id": "case:sm_ddbar_uubar:lc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "9",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:lc:point:sm_ddbar_uubar:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_uubar:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.8586784491130669577945850823635320392666580558096603287408041080243327511138013428",
+          "values": [
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.0020110344646803242053719340172564018656082173039604911528200329425273679930641124",
+              "0.018099310182122921468209442579891729439260650484775626133084594520577145947991068"
+            ],
+            [
+              "0.040922887990973015956251278083317811789640204742825141391937136489604611130334121",
+              "0.36830599191875721726745988650130007653881995537326890569256029005945725048551137"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.040922887990973015956251278083317811789640204742825141391937136489604611130334121",
+              "0.36830599191875721726745988650130007653881995537326890569256029005945725048551137"
+            ],
+            [
+              "0.0020110344646803242053719340172564018656082173039604911528200329425273679930641124",
+              "0.018099310182122921468209442579891729439260650484775626133084594520577145947991068"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:lc:point:sm_ddbar_uubar:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_uubar:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.6204077498181734749618004282799422575861860404637307203545067998447730993446319",
+          "values": [
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.011675010686482354364574240023324108267851995031363074027201387140848477206256186",
+              "0.10507509617834121029618739587815798289718534750176128380792320304006408458747127"
+            ],
+            [
+              "0.019345376804426313799846033027111897465345903379190317272562605960273860106309094",
+              "0.1741083912398368590202925452113771401627097743195506850695662037812001277722794"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.019345376804426313799846033027111897465345903379190317272562605960273860106309094",
+              "0.1741083912398368590202925452113771401627097743195506850695662037812001277722794"
+            ],
+            [
+              "0.011675010686482354364574240023324108267851995031363074027201387140848477206256186",
+              "0.10507509617834121029618739587815798289718534750176128380792320304006408458747127"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:lc:point:sm_ddbar_uubar:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_uubar:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.6627107593353671552128664760144888483024229557441824916265966483336749016823799716",
+          "values": [
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.025472974153976014883098480415489072629425539209429747148412650136040740394548948",
+              "0.22925676738578417979923980089623532094511617429013392096093974689794140457714701"
+            ],
+            [
+              "0.0076625638127923369131480093669311518018023449965211932199935337820366157753209118",
+              "0.068963074315131046010946947328588878774867419376006384483952393350818690094173116"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.0076625638127923369131480093669311518018023449965211932199935337820366157753209118",
+              "0.068963074315131046010946947328588878774867419376006384483952393350818690094173116"
+            ],
+            [
+              "0.025472974153976014883098480415489072629425539209429747148412650136040740394548948",
+              "0.22925676738578417979923980089623532094511617429013392096093974689794140457714701"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:lc:point:sm_ddbar_uubar:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_uubar:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "1.221547527395775884301298384285505814745392315868834749622307625705999988678793238658997015926",
+          "values": [
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.061077376369727705600457084381580482025779262420412519108979381793831123304293429",
+              "0.54969638732754946034339122494411090994638507511129122734558001729362611500389321"
+            ],
+            [
+              "0.000000000000061077620680088270712179817637291662983237298563412931282037337029721078126534943",
+              "0.00000000000054969858612079454634933558289452873973039105803100083426071869418025925137197302"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.000000000000061077620680088270712179817637291662983237298563412931282037337029721078126534943",
+              "0.00000000000054969858612079454634933558289452873973039105803100083426071869418025925137197302"
+            ],
+            [
+              "0.061077376369727705600457084381580482025779262420412519108979381793831123304293429",
+              "0.54969638732754946034339122494411090994638507511129122734558001729362611500389321"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "196ac2eaf2a5c9c4e97da9930c2ac73dc59d4df940c2a44979d507ee673e125b",
+      "point_ids": [
+        "point:sm_ddbar_uubar:generic-1",
+        "point:sm_ddbar_uubar:generic-2",
+        "point:sm_ddbar_uubar:generic-3",
+        "point:sm_ddbar_uubar:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_uubar",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:2,1,3,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,1,3,4",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "flow:2,1,3,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,1,3,4",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "flow:2,4,3,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,4,3,1",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "flow:2,4,3,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,4,3,1",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "d7b201425e80aa918732d8dd522b324774e26587c45002169bdc0cc900707930"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 13,
+        "interactions": 7,
+        "reduction_groups": 4,
+        "roots": 4
+      }
+    },
+    {
+      "artifact_execution_sha256": "515fc8b55c54e260ae14ecfa557ee5eed8a438f810eb38a87e57867a9f227696",
+      "artifact_physics_sha256": "cfabe8c46b0cb174ddf6922c75c8b11666dbe93b8ff528c8747e80546db566ba",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:2,1,3,4",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:2,1,3,4",
+            "word": [
+              2,
+              1,
+              3,
+              4
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:2,4,3,1",
+            "index": 1,
+            "kind": "lc-flow",
+            "representative_id": "flow:2,4,3,1",
+            "word": [
+              2,
+              4,
+              3,
+              1
+            ]
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 2,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 10
+      },
+      "id": "case:sm_ddbar_ddbar:lc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "9",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:lc:point:sm_ddbar_ddbar:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "27.2053684543184168651300805787992744320796523928899205066424245595451339881583559558",
+          "values": [
+            [
+              "7.0363352948340904444812270056396435189743028646432079779546074793816422125453704",
+              "0.78181503275934322635712978209129166512020556417988322170712121635280404051694677"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "4.3649888696889272149565309474288773419011639466759866803726884885442905962975305",
+              "1.3718296410734511360022141370705152840661247189743815114515882753365914781331558"
+            ],
+            [
+              "0.0047715388803396402179168432557955725412213549836439674689396557724194161410211509",
+              "0.042943849923056770550021573913513833436807746987856894366267164384819250445153357"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.0047715388803396402179168432557955725412213549836439674689396557724194161410211509",
+              "0.042943849923056770550021573913513833436807746987856894366267164384819250445153357"
+            ],
+            [
+              "4.3649888696889272149565309474288773419011639466759866803726884885442905962975305",
+              "1.3718296410734511360022141370705152840661247189743815114515882753365914781331558"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "7.0363352948340904444812270056396435189743028646432079779546074793816422125453704",
+              "0.78181503275934322635712978209129166512020556417988322170712121635280404051694677"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:lc:point:sm_ddbar_ddbar:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "14.9596335368268960410381683074306243331741256200944179316492038649056576468340828238",
+          "values": [
+            [
+              "4.0816757259496254279371533709840992387343387288328607867183498768763404675426931",
+              "0.45351952510551384573355646456211716311788044758525471237603488347739671858444512"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "2.0602110357463930239563468015657924967052272584098103089550926463491028698311778",
+              "0.80215468843129568794857064055197029149791101262216352088531568872689832515635254"
+            ],
+            [
+              "0.0082255793180620020137414103539727130890750848705396245518410265309722401011588019",
+              "0.07403021386255803292971546569736026344263027772658001233796781049211820220121405"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.0082255793180620020137414103539727130890750848705396245518410265309722401011588019",
+              "0.07403021386255803292971546569736026344263027772658001233796781049211820220121405"
+            ],
+            [
+              "2.0602110357463930239563468015657924967052272584098103089550926463491028698311778",
+              "0.80215468843129568794857064055197029149791101262216352088531568872689832515635254"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "4.0816757259496254279371533709840992387343387288328607867183498768763404675426931",
+              "0.45351952510551384573355646456211716311788044758525471237603488347739671858444512"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:lc:point:sm_ddbar_ddbar:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "78.7171631048582504452670620584424069427684355863119531905276330050072204740518373538",
+          "values": [
+            [
+              "19.140241437517517304107797347846942350521797322739891939611160531446429179109084",
+              "2.1266934930575014973399455382604081034863003253916069903583527169879496083166894"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "14.73636077176799466025751843197743895792223769379750746599200929636476193977117",
+              "3.3377447195084185313333398496251461334794009165087716279210189149760630730585949"
+            ],
+            [
+              "0.0017541130577693226437526357526486693609211582233416760441457329949593504948283379",
+              "0.015787017519923906951177225758619256613560376494856895337129309733447086275552039"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.0017541130577693226437526357526486693609211582233416760441457329949593504948283379",
+              "0.015787017519923906951177225758619256613560376494856895337129309733447086275552039"
+            ],
+            [
+              "14.73636077176799466025751843197743895792223769379750746599200929636476193977117",
+              "3.3377447195084185313333398496251461334794009165087716279210189149760630730585949"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "19.140241437517517304107797347846942350521797322739891939611160531446429179109084",
+              "2.1266934930575014973399455382604081034863003253916069903583527169879496083166894"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:lc:point:sm_ddbar_ddbar:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "2443094077549.620887189977087915550211166890941390864568564098569320914446651881405512062419960658997015926",
+          "values": [
+            [
+              "549696387327.54946034339122494411090994638507511129122734558001729362611500389321",
+              "61077376369.727705600457084381580482025779262420412519108979381793831123304293429"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "549695654398.17793887570408501155068101848726188099849414816803759208700617058143",
+              "61077620679.355338775435538844326231709976809767329511858919134352556384433407091"
+            ],
+            [
+              "0.000000000000061077620680088270712179817637291662983237298563412931282037337029721078126534943",
+              "0.00000000000054969858612079454634933558289452873973039105803100083426071869418025925137197302"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.000000000000061077620680088270712179817637291662983237298563412931282037337029721078126534943",
+              "0.00000000000054969858612079454634933558289452873973039105803100083426071869418025925137197302"
+            ],
+            [
+              "549695654398.17793887570408501155068101848726188099849414816803759208700617058143",
+              "61077620679.355338775435538844326231709976809767329511858919134352556384433407091"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "549696387327.54946034339122494411090994638507511129122734558001729362611500389321",
+              "61077376369.727705600457084381580482025779262420412519108979381793831123304293429"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "20eb3171d3d5c325bbe9796eb8904926179d2fdee0f721b539d47e2d7cdd222d",
+      "point_ids": [
+        "point:sm_ddbar_ddbar:generic-1",
+        "point:sm_ddbar_ddbar:generic-2",
+        "point:sm_ddbar_ddbar:generic-3",
+        "point:sm_ddbar_ddbar:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_ddbar",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:2,1,3,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,1,3,4",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "flow:2,1,3,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,1,3,4",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "flow:2,1,3,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,1,3,4",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "flow:2,4,3,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,4,3,1",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "flow:2,4,3,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,4,3,1",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "flow:2,4,3,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,4,3,1",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "9839d75b5c0ce74104a4f9b17909a884840b1c0bf8f3f71ba29e9bbe6493bdcb"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 19,
+        "interactions": 14,
+        "reduction_groups": 6,
+        "roots": 6
+      }
+    },
+    {
+      "artifact_execution_sha256": "e176d7e9832ac9f73653b16ad7bef3d78d2f33f325eb16d79ad66116fb7caf95",
+      "artifact_physics_sha256": "bd91f74db86cfc77da8cb891821f7458b3201e6435cf2d76405057503ae009fd",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:1,2,3,4",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:1,2,3,4",
+            "word": [
+              1,
+              2,
+              3,
+              4
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:1,2,4,3",
+            "index": 1,
+            "kind": "lc-flow",
+            "representative_id": "flow:1,2,4,3",
+            "word": [
+              1,
+              2,
+              4,
+              3
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:1,3,2,4",
+            "index": 2,
+            "kind": "lc-flow",
+            "representative_id": "flow:1,3,2,4",
+            "word": [
+              1,
+              3,
+              2,
+              4
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "flow:1,3,4,2",
+            "index": 3,
+            "kind": "lc-flow",
+            "representative_id": "flow:1,2,4,3",
+            "word": [
+              1,
+              3,
+              4,
+              2
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "flow:1,4,2,3",
+            "index": 4,
+            "kind": "lc-flow",
+            "representative_id": "flow:1,3,2,4",
+            "word": [
+              1,
+              4,
+              2,
+              3
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "flow:1,4,3,2",
+            "index": 5,
+            "kind": "lc-flow",
+            "representative_id": "flow:1,2,3,4",
+            "word": [
+              1,
+              4,
+              3,
+              2
+            ]
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 6,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 10
+      },
+      "id": "case:sm_gg_gg:lc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "256",
+        "color_factor": "81",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "2",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:lc:point:sm_gg_gg:generic-1"
+          ],
+          "point_id": "point:sm_gg_gg:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "64.311979502605365403788298803114455099849695569570356470262874484637884527493469646",
+          "values": [
+            [
+              "0.69774200915959484206371355787144641823335642890943495650614950567198797882789882",
+              "4.0265321876815446210754360753022294133343498188603585683622093303196457989665468",
+              "8.0765752922552729128058699973101868242694358508005325423833744054930672660979574",
+              "4.0265321876815446210754360753022294133343498188603585683622093303196457989665468",
+              "8.0765752922552729128058699973101868242694358508005325423833744054930672660979574",
+              "0.69774200915959484206371355787144641823335642890943495650614950567198797882789882"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0.17342141668049340619409550550123741428739477261780033948117183472675208653704278",
+              "1.0007809579050591151045726928788141497673190655196477187316437345503986979781094",
+              "2.0074054746920189715586626607282782235206071827447966596592847405290743284635456",
+              "1.0007809579050591151045726928788141497673190655196477187316437345503986979781094",
+              "2.0074054746920189715586626607282782235206071827447966596592847405290743284635456",
+              "0.17342141668049340619409550550123741428739477261780033948117183472675208653704278"
+            ],
+            [
+              "0.0052075101161718711538109727625215208411608277554114968177287323278468041645909995",
+              "0.030051518792309425631421158410322809811026967187883759883724284307344390965975904",
+              "0.060278508368876185359492080013577000897772977996723075740432053233353779871699708",
+              "0.030051518792309425631421158410322809811026967187883759883724284307344390965975904",
+              "0.060278508368876185359492080013577000897772977996723075740432053233353779871699708",
+              "0.0052075101161718711538109727625215208411608277554114968177287323278468041645909995"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0.0052075101161718711538109727625215208411608277554114968177287323278468041645909995",
+              "0.030051518792309425631421158410322809811026967187883759883724284307344390965975904",
+              "0.060278508368876185359492080013577000897772977996723075740432053233353779871699708",
+              "0.030051518792309425631421158410322809811026967187883759883724284307344390965975904",
+              "0.060278508368876185359492080013577000897772977996723075740432053233353779871699708",
+              "0.0052075101161718711538109727625215208411608277554114968177287323278468041645909995"
+            ],
+            [
+              "0.17342141668049340619409550550123741428739477261780033948117183472675208653704278",
+              "1.0007809579050591151045726928788141497673190655196477187316437345503986979781094",
+              "2.0074054746920189715586626607282782235206071827447966596592847405290743284635456",
+              "1.0007809579050591151045726928788141497673190655196477187316437345503986979781094",
+              "2.0074054746920189715586626607282782235206071827447966596592847405290743284635456",
+              "0.17342141668049340619409550550123741428739477261780033948117183472675208653704278"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0.69774200915959484206371355787144641823335642890943495650614950567198797882789882",
+              "4.0265321876815446210754360753022294133343498188603585683622093303196457989665468",
+              "8.0765752922552729128058699973101868242694358508005325423833744054930672660979574",
+              "4.0265321876815446210754360753022294133343498188603585683622093303196457989665468",
+              "8.0765752922552729128058699973101868242694358508005325423833744054930672660979574",
+              "0.69774200915959484206371355787144641823335642890943495650614950567198797882789882"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:lc:point:sm_gg_gg:generic-2"
+          ],
+          "point_id": "point:sm_gg_gg:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "354.68492694464307096365771899834666684554573180052480547766886986721940622814974335118",
+          "values": [
+            [
+              "23.996095885821581706156925935036093208094224614549129725728505884081187265567353",
+              "0.44960287136740093023700402741728497456417746067486689819847711935142230978452279",
+              "31.014934210991155277577706494235042932647531639919733458116162592487436132360422",
+              "0.44960287136740093023700402741728497456417746067486689819847711935142230978452279",
+              "31.014934210991155277577706494235042932647531639919733458116162592487436132360422",
+              "23.996095885821581706156925935036093208094224614549129725728505884081187265567353"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0.0050426289460464781428424798959185399007835033229805153110144896558603628111323073",
+              "0.000094481221619157701917055418977904368309560235878410031511102207738887784735334595",
+              "0.0065175937684296535084162420089496502752823965941774251453863547362739483814906859",
+              "0.000094481221619157701917055418977904368309560235878410031511102207738887784735334595",
+              "0.0065175937684296535084162420089496502752823965941774251453863547362739483814906859",
+              "0.0050426289460464781428424798959185399007835033229805153110144896558603628111323073"
+            ],
+            [
+              "14.364153498318442575065164557188544058682547873794387935621615065742936822641995",
+              "0.26913397447382108530891326517640302654575023105312590041304994999004124701593172",
+              "18.565656591252270877215539693209452416307825669986921100851494908551954580689853",
+              "0.26913397447382108530891326517640302654575023105312590041304994999004124701593172",
+              "18.565656591252270877215539693209452416307825669986921100851494908551954580689853",
+              "14.364153498318442575065164557188544058682547873794387935621615065742936822641995"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "14.364153498318442575065164557188544058682547873794387935621615065742936822641995",
+              "0.26913397447382108530891326517640302654575023105312590041304994999004124701593172",
+              "18.565656591252270877215539693209452416307825669986921100851494908551954580689853",
+              "0.26913397447382108530891326517640302654575023105312590041304994999004124701593172",
+              "18.565656591252270877215539693209452416307825669986921100851494908551954580689853",
+              "14.364153498318442575065164557188544058682547873794387935621615065742936822641995"
+            ],
+            [
+              "0.0050426289460464781428424798959185399007835033229805153110144896558603628111323073",
+              "0.000094481221619157701917055418977904368309560235878410031511102207738887784735334595",
+              "0.0065175937684296535084162420089496502752823965941774251453863547362739483814906859",
+              "0.000094481221619157701917055418977904368309560235878410031511102207738887784735334595",
+              "0.0065175937684296535084162420089496502752823965941774251453863547362739483814906859",
+              "0.0050426289460464781428424798959185399007835033229805153110144896558603628111323073"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "23.996095885821581706156925935036093208094224614549129725728505884081187265567353",
+              "0.44960287136740093023700402741728497456417746067486689819847711935142230978452279",
+              "31.014934210991155277577706494235042932647531639919733458116162592487436132360422",
+              "0.44960287136740093023700402741728497456417746067486689819847711935142230978452279",
+              "31.014934210991155277577706494235042932647531639919733458116162592487436132360422",
+              "23.996095885821581706156925935036093208094224614549129725728505884081187265567353"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:lc:point:sm_gg_gg:generic-3"
+          ],
+          "point_id": "point:sm_gg_gg:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "49.859557236461872432768240620121682058545154009911188164012546018683573238244021896",
+          "values": [
+            [
+              "2.8641928335808665256353031909657068972885400833523920134877104242715192949180218",
+              "0.81953052916972273828068234304059795476522953920146368491137152939381495085428192",
+              "6.7478992510106970627243217185316379717321820097204928969298969708987925886016998",
+              "0.81953052916972273828068234304059795476522953920146368491137152939381495085428192",
+              "6.7478992510106970627243217185316379717321820097204928969298969708987925886016998",
+              "2.8641928335808665256353031909657068972885400833523920134877104242715192949180218"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0.042246948699564351488858771764745026911112153283276298519009647926646075042055805",
+              "0.012088105178405257905614459805736142075682759940212135099142671294263111922454874",
+              "0.099531759923743569691555892565658438022288109010104506277608685281150677730289845",
+              "0.012088105178405257905614459805736142075682759940212135099142671294263111922454874",
+              "0.099531759923743569691555892565658438022288109010104506277608685281150677730289845",
+              "0.042246948699564351488858771764745026911112153283276298519009647926646075042055805"
+            ],
+            [
+              "0.51602362081946496231020195487805806950009485832961568758863119464457007087098463",
+              "0.147649664532376725764254907102109308851362135405318512579856629813758328840787",
+              "1.2157265962006269143912669163761707054897968542349213056099087511463782107804298",
+              "0.147649664532376725764254907102109308851362135405318512579856629813758328840787",
+              "1.2157265962006269143912669163761707054897968542349213056099087511463782107804298",
+              "0.51602362081946496231020195487805806950009485832961568758863119464457007087098463"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0.51602362081946496231020195487805806950009485832961568758863119464457007087098463",
+              "0.147649664532376725764254907102109308851362135405318512579856629813758328840787",
+              "1.2157265962006269143912669163761707054897968542349213056099087511463782107804298",
+              "0.147649664532376725764254907102109308851362135405318512579856629813758328840787",
+              "1.2157265962006269143912669163761707054897968542349213056099087511463782107804298",
+              "0.51602362081946496231020195487805806950009485832961568758863119464457007087098463"
+            ],
+            [
+              "0.042246948699564351488858771764745026911112153283276298519009647926646075042055805",
+              "0.012088105178405257905614459805736142075682759940212135099142671294263111922454874",
+              "0.099531759923743569691555892565658438022288109010104506277608685281150677730289845",
+              "0.012088105178405257905614459805736142075682759940212135099142671294263111922454874",
+              "0.099531759923743569691555892565658438022288109010104506277608685281150677730289845",
+              "0.042246948699564351488858771764745026911112153283276298519009647926646075042055805"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "2.8641928335808665256353031909657068972885400833523920134877104242715192949180218",
+              "0.81953052916972273828068234304059795476522953920146368491137152939381495085428192",
+              "6.7478992510106970627243217185316379717321820097204928969298969708987925886016998",
+              "0.81953052916972273828068234304059795476522953920146368491137152939381495085428192",
+              "6.7478992510106970627243217185316379717321820097204928969298969708987925886016998",
+              "2.8641928335808665256353031909657068972885400833523920134877104242715192949180218"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:lc:point:sm_gg_gg:stress-near-collinear"
+          ],
+          "point_id": "point:sm_gg_gg:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "5565670356026.64834864356909200652968871434992593994328892103006352081499328143721400722647105785216073663927609221488",
+          "values": [
+            [
+              "0.34785613652956538428712758536771656225230110068598288777219251801621534199960308",
+              "347854745105.71491662338140860551173469346350392226547721297905971770587540063819",
+              "347855440816.9444066487859468295036225174808403732795889440427046312633453510234",
+              "347854745105.71491662338140860551173469346350392226547721297905971770587540063819",
+              "347855440816.9444066487859468295036225174808403732795889440427046312633453510234",
+              "0.34785613652956538428712758536771656225230110068598288777219251801621534199960308"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0.34785474510571497829889592151809595876248196575304572849412441583822741251109358",
+              "347853353687.43020325411102273707031397085618753409509267526474518606746507977268",
+              "347854049395.87684975297791875399195399905370222390312633053265651439105528493798",
+              "347853353687.43020325411102273707031397085618753409509267526474518606746507977268",
+              "347854049395.87684975297791875399195399905370222390312633053265651439105528493798",
+              "0.34785474510571497829889592151809595876248196575304572849412441583822741251109358"
+            ],
+            [
+              "0.00000000000000000000000034785752795898150515747730286201747340165536036591725932725416220952981902305372",
+              "0.00000000000034785613652956532261179809943040189785555536131045383288420277530862065659500025",
+              "0.00000000000034785683224357766729515334681844162416279713090641464436617860335315655228297438",
+              "0.00000000000034785613652956532261179809943040189785555536131045383288420277530862065659500025",
+              "0.00000000000034785683224357766729515334681844162416279713090641464436617860335315655228297438",
+              "0.00000000000000000000000034785752795898150515747730286201747340165536036591725932725416220952981902305372"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0.00000000000000000000000034785752795898150515747730286201747340165536036591725932725416220952981902305372",
+              "0.00000000000034785613652956532261179809943040189785555536131045383288420277530862065659500025",
+              "0.00000000000034785683224357766729515334681844162416279713090641464436617860335315655228297438",
+              "0.00000000000034785613652956532261179809943040189785555536131045383288420277530862065659500025",
+              "0.00000000000034785683224357766729515334681844162416279713090641464436617860335315655228297438",
+              "0.00000000000000000000000034785752795898150515747730286201747340165536036591725932725416220952981902305372"
+            ],
+            [
+              "0.34785474510571497829889592151809595876248196575304572849412441583822741251109358",
+              "347853353687.43020325411102273707031397085618753409509267526474518606746507977268",
+              "347854049395.87684975297791875399195399905370222390312633053265651439105528493798",
+              "347853353687.43020325411102273707031397085618753409509267526474518606746507977268",
+              "347854049395.87684975297791875399195399905370222390312633053265651439105528493798",
+              "0.34785474510571497829889592151809595876248196575304572849412441583822741251109358"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0",
+              "0",
+              "0",
+              "0",
+              "0"
+            ],
+            [
+              "0.34785613652956538428712758536771656225230110068598288777219251801621534199960308",
+              "347854745105.71491662338140860551173469346350392226547721297905971770587540063819",
+              "347855440816.9444066487859468295036225174808403732795889440427046312633453510234",
+              "347854745105.71491662338140860551173469346350392226547721297905971770587540063819",
+              "347855440816.9444066487859468295036225174808403732795889440427046312633453510234",
+              "0.34785613652956538428712758536771656225230110068598288777219251801621534199960308"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "effb6e8dab6aafe7629da6a40c01555b8f0a845770971cb9912ecc4db1e33959",
+      "point_ids": [
+        "point:sm_gg_gg:generic-1",
+        "point:sm_gg_gg:generic-2",
+        "point:sm_gg_gg:generic-3",
+        "point:sm_gg_gg:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_gg_gg",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:1,2,3,4",
+              "flow:1,4,3,2"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:1,2,3,4",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "flow:1,2,3,4",
+              "flow:1,4,3,2"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:1,2,3,4",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "flow:1,2,3,4",
+              "flow:1,4,3,2"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:1,2,3,4",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "flow:1,2,4,3",
+              "flow:1,3,4,2"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:1,2,4,3",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "flow:1,2,4,3",
+              "flow:1,3,4,2"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:1,2,4,3",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "flow:1,2,4,3",
+              "flow:1,3,4,2"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:1,2,4,3",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "flow:1,3,2,4",
+              "flow:1,4,2,3"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:1,3,2,4",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "flow:1,3,2,4",
+              "flow:1,4,2,3"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:1,3,2,4",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "flow:1,3,2,4",
+              "flow:1,4,2,3"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:1,3,2,4",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "0fabd0dceabd4ebce133a10edcbc3a7bf1b37341436d8b4fef77648bc6b7df11"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 30,
+        "interactions": 50,
+        "reduction_groups": 9,
+        "roots": 9
+      }
+    },
+    {
+      "artifact_execution_sha256": "2831330fdb9d954827773cf98e1cd3654ee895b9754fa9484f47a4e95f5a1d1b",
+      "artifact_physics_sha256": "063639e623c7844af0b0305d665743e931e2c3b0952abfc27687263cfeeac7c8",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:3,1,2,4",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:3,1,2,4",
+            "word": [
+              3,
+              1,
+              2,
+              4
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:3,2,1,4",
+            "index": 1,
+            "kind": "lc-flow",
+            "representative_id": "flow:3,2,1,4",
+            "word": [
+              3,
+              2,
+              1,
+              4
+            ]
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 2,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 0
+      },
+      "id": "case:sm_gg_ttbar:lc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "256",
+        "color_factor": "27",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:lc:point:sm_gg_ttbar:generic-1"
+          ],
+          "point_id": "point:sm_gg_ttbar:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "2.1477912729062541415514762271821053056500853503387870303006698960599889643157923281580412",
+          "values": [
+            [
+              "0.26712249040860657868181800846824597021909835209197931764388516843619947262254602",
+              "0.0091556231328069321777814927730193772620109251786716805522932968369817235242550719"
+            ],
+            [
+              "0.000000073228511651800018897600312227239573388658154296982734704202531699838895824408011",
+              "0.0000000025099071749244243031730130307139161166484153407192849839889618438681054662590993"
+            ],
+            [
+              "0.000000073228511651800018897600312227239573388658154296982734704202531699838895824408011",
+              "0.0000000025099071749244243031730130307139161166484153407192849839889618438681054662590993"
+            ],
+            [
+              "0.00027127253497730293292469429089523720013641715542272569223885119252783596311731177",
+              "0.0000092978659068886671400046776697559492379160801915804687402002614575891252216199848"
+            ],
+            [
+              "0.01341505316885915766721668589678185568744182675990325809179845829836484270910871",
+              "0.00045980093601539946125934652456093244795490427443359449716923366481767468175421222"
+            ],
+            [
+              "0.72680690466116555050704992226899372892850541388278671846566060922235626665964079",
+              "0.02491130604248503252437274563938331511092710335223427731865488124860309171069349"
+            ],
+            [
+              "0.017276722472462057806418293027706981296101525781871578325603901509908521783687743",
+              "0.00059215964812995977239448605580219468125254896442265610128327901260785857300569165"
+            ],
+            [
+              "0.01341505316885915766721668589678185568744182675990325809179845829836484270910871",
+              "0.00045980093601539946125934652456093244795490427443359449716923366481767468175421222"
+            ],
+            [
+              "0.01341505316885915766721668589678185568744182675990325809179845829836484270910871",
+              "0.00045980093601539946125934652456093244795490427443359449716923366481767468175421222"
+            ],
+            [
+              "0.017276722472462057806418293027706981296101525781871578325603901509908521783687743",
+              "0.00059215964812995977239448605580219468125254896442265610128327901260785857300569165"
+            ],
+            [
+              "0.72680690466116555050704992226899372892850541388278671846566060922235626665964079",
+              "0.02491130604248503252437274563938331511092710335223427731865488124860309171069349"
+            ],
+            [
+              "0.01341505316885915766721668589678185568744182675990325809179845829836484270910871",
+              "0.00045980093601539946125934652456093244795490427443359449716923366481767468175421222"
+            ],
+            [
+              "0.00027127253497730293292469429089523720013641715542272569223885119252783596311731177",
+              "0.0000092978659068886671400046776697559492379160801915804687402002614575891252216199848"
+            ],
+            [
+              "0.000000073228511651800018897600312227239573388658154296982734704202531699838895824408011",
+              "0.0000000025099071749244243031730130307139161166484153407192849839889618438681054662590993"
+            ],
+            [
+              "0.000000073228511651800018897600312227239573388658154296982734704202531699838895824408011",
+              "0.0000000025099071749244243031730130307139161166484153407192849839889618438681054662590993"
+            ],
+            [
+              "0.26712249040860657868181800846824597021909835209197931764388516843619947262254602",
+              "0.0091556231328069321777814927730193772620109251786716805522932968369817235242550719"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:lc:point:sm_gg_ttbar:generic-2"
+          ],
+          "point_id": "point:sm_gg_ttbar:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.6803910748559878241560708160316293191577330980429027145443336467118302133584542104494144",
+          "values": [
+            [
+              "0.016354786892059283844625069069232483256779267575913504358449650657631373940004337",
+              "0.047958691420016607797884289007922708029143863386383501176112132349490065214861898"
+            ],
+            [
+              "0.0000000089255765411057214569640333541469552513057090342652964495476632652354511809450366",
+              "0.000000026173313899214628605650402405374144503112609657212577095731675112500627549976817"
+            ],
+            [
+              "0.0000000089255765411057214569640333541469552513057090342652964495476632652354511809450366",
+              "0.000000026173313899214628605650402405374144503112609657212577095731675112500627549976817"
+            ],
+            [
+              "0.000016608345420213788502506561512541128872538346413444157075415965073850255537196675",
+              "0.000048702225119901110828427555906878909063836474676609502493900921759473513147869506"
+            ],
+            [
+              "0.0032551431515236718051735058164553495332460234494589670179859601306851685142589958",
+              "0.0095453647279073486638288706848207096352759495473288997976460114624085779196696648"
+            ],
+            [
+              "0.015296574776352235668028390745555665579482682674143340309611360510639876175144401",
+              "0.044855595754566020914373132031282641758670330123545821319993113383553879854352746"
+            ],
+            [
+              "0.048332759946254277779311979198151846181925022095518901143195374828955598382858534",
+              "0.14173073211156244959577673561482625735568555351464311871822484099394674100330534"
+            ],
+            [
+              "0.0032551431515236718051735058164553495332460234494589670179859601306851685142589958",
+              "0.0095453647279073486638288706848207096352759495473288997976460114624085779196696648"
+            ],
+            [
+              "0.0032551431515236718051735058164553495332460234494589670179859601306851685142589958",
+              "0.0095453647279073486638288706848207096352759495473288997976460114624085779196696648"
+            ],
+            [
+              "0.048332759946254277779311979198151846181925022095518901143195374828955598382858534",
+              "0.14173073211156244959577673561482625735568555351464311871822484099394674100330534"
+            ],
+            [
+              "0.015296574776352235668028390745555665579482682674143340309611360510639876175144401",
+              "0.044855595754566020914373132031282641758670330123545821319993113383553879854352746"
+            ],
+            [
+              "0.0032551431515236718051735058164553495332460234494589670179859601306851685142589958",
+              "0.0095453647279073486638288706848207096352759495473288997976460114624085779196696648"
+            ],
+            [
+              "0.000016608345420213788502506561512541128872538346413444157075415965073850255537196675",
+              "0.000048702225119901110828427555906878909063836474676609502493900921759473513147869506"
+            ],
+            [
+              "0.0000000089255765411057214569640333541469552513057090342652964495476632652354511809450366",
+              "0.000000026173313899214628605650402405374144503112609657212577095731675112500627549976817"
+            ],
+            [
+              "0.0000000089255765411057214569640333541469552513057090342652964495476632652354511809450366",
+              "0.000000026173313899214628605650402405374144503112609657212577095731675112500627549976817"
+            ],
+            [
+              "0.016354786892059283844625069069232483256779267575913504358449650657631373940004337",
+              "0.047958691420016607797884289007922708029143863386383501176112132349490065214861898"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:lc:point:sm_gg_ttbar:generic-3"
+          ],
+          "point_id": "point:sm_gg_ttbar:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "2.1627359659081426617625100551960590175668647473634876452142069896949007734837390854332568",
+          "values": [
+            [
+              "0.26990479163752210439400300464076272144578917585099684106976705438599733932999379",
+              "0.0091381298464963892924320096040457515425689248481459900191215369453288240516601867"
+            ],
+            [
+              "0.000000073587677929152233852467989161798788200566808731784576317962079760464620948496747",
+              "0.0000000024914480100147480385200773419600201574358810029998827830534231432275890437790672"
+            ],
+            [
+              "0.000000073587677929152233852467989161798788200566808731784576317962079760464620948496747",
+              "0.0000000024914480100147480385200773419600201574358810029998827830534231432275890437790672"
+            ],
+            [
+              "0.00027409811061059318769920102987152422686771578507878709591569940145496249050388467",
+              "0.000009280102477034801950747395911755124606211061170621924640333037123787556936822365"
+            ],
+            [
+              "0.013407322063607583298099385290015388084986319346491047480872409035082069426509414",
+              "0.00045392988085806779468722429552561725830990854176230621249195036574658305965136121"
+            ],
+            [
+              "0.73182300577306862353203518006200673205814182951202533914161949954604539279363622",
+              "0.024777232041099799738243189032403811003900444040189313481607363263725899327891065"
+            ],
+            [
+              "0.017138532432424113468784055068116565116192008510411527550194648715227258018103399",
+              "0.00058025696318949194657063961769563006115689229183922536859043871988381081640264001"
+            ],
+            [
+              "0.013407322063607583298099385290015388084986319346491047480872409035082069426509414",
+              "0.00045392988085806779468722429552561725830990854176230621249195036574658305965136121"
+            ],
+            [
+              "0.013407322063607583298099385290015388084986319346491047480872409035082069426509414",
+              "0.00045392988085806779468722429552561725830990854176230621249195036574658305965136121"
+            ],
+            [
+              "0.017138532432424113468784055068116565116192008510411527550194648715227258018103399",
+              "0.00058025696318949194657063961769563006115689229183922536859043871988381081640264001"
+            ],
+            [
+              "0.73182300577306862353203518006200673205814182951202533914161949954604539279363622",
+              "0.024777232041099799738243189032403811003900444040189313481607363263725899327891065"
+            ],
+            [
+              "0.013407322063607583298099385290015388084986319346491047480872409035082069426509414",
+              "0.00045392988085806779468722429552561725830990854176230621249195036574658305965136121"
+            ],
+            [
+              "0.00027409811061059318769920102987152422686771578507878709591569940145496249050388467",
+              "0.000009280102477034801950747395911755124606211061170621924640333037123787556936822365"
+            ],
+            [
+              "0.000000073587677929152233852467989161798788200566808731784576317962079760464620948496747",
+              "0.0000000024914480100147480385200773419600201574358810029998827830534231432275890437790672"
+            ],
+            [
+              "0.000000073587677929152233852467989161798788200566808731784576317962079760464620948496747",
+              "0.0000000024914480100147480385200773419600201574358810029998827830534231432275890437790672"
+            ],
+            [
+              "0.26990479163752210439400300464076272144578917585099684106976705438599733932999379",
+              "0.0091381298464963892924320096040457515425689248481459900191215369453288240516601867"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:lc:point:sm_gg_ttbar:stress-near-threshold"
+          ],
+          "point_id": "point:sm_gg_ttbar:stress-near-threshold",
+          "round_trip_decimal_digits": 80,
+          "total": "0.463809703224829559655326138194715511808457161006059863586020420325848540262506505460337",
+          "values": [
+            [
+              "0.058271271808692643715181553884557161271691566954089982811895127943579520909455831",
+              "0.058008166897027445422496153925585161533221951189326661214780731460548390944513161"
+            ],
+            [
+              "0.00000038870291281836147870706069755490112005482275865549715608056202387508262086228592",
+              "0.00000038694785166443924444615918541633475510031029634091364307017672093209705247924447"
+            ],
+            [
+              "0.00000038870291281836147870706069755490112005482275865549715608056202387508262086228592",
+              "0.00000038694785166443924444615918541633475510031029634091364307017672093209705247924447"
+            ],
+            [
+              "0.057942574227244794677720255645330679624570126619670920418820570225066477993530684",
+              "0.057680953442241793238919705013704787089278859013697767502475039805897837813327489"
+            ],
+            [
+              "0.000000015061082618520563291118383347324268405048733321241049059847042047192637429855721",
+              "0.000000014993079214974856282167007482736910693118307632583399334007986801407086889360789"
+            ],
+            [
+              "0.00000013555001466630775273377137532643873293239580918401466247739762511302920971459996",
+              "0.00000013493798281033451379985092005730638856980187701902604527595314395043227921302377"
+            ],
+            [
+              "0.0000000016734569711889846016514984608202312707703186319014155861407114211485087619086414",
+              "0.0000000016659010223498088123438385192260047971580478644324203120488042463016330767039971"
+            ],
+            [
+              "0.000000015061082618520563291118383347324268405048733321241049059847042047192637429855721",
+              "0.000000014993079214974856282167007482736910693118307632583399334007986801407086889360789"
+            ],
+            [
+              "0.000000015061082618520563291118383347324268405048733321241049059847042047192637429855721",
+              "0.000000014993079214974856282167007482736910693118307632583399334007986801407086889360789"
+            ],
+            [
+              "0.0000000016734569711889846016514984608202312707703186319014155861407114211485087619086414",
+              "0.0000000016659010223498088123438385192260047971580478644324203120488042463016330767039971"
+            ],
+            [
+              "0.00000013555001466630775273377137532643873293239580918401466247739762511302920971459996",
+              "0.00000013493798281033451379985092005730638856980187701902604527595314395043227921302377"
+            ],
+            [
+              "0.000000015061082618520563291118383347324268405048733321241049059847042047192637429855721",
+              "0.000000014993079214974856282167007482736910693118307632583399334007986801407086889360789"
+            ],
+            [
+              "0.057942574227244794677720255645330679624570126619670920418820570225066477993530684",
+              "0.057680953442241793238919705013704787089278859013697767502475039805897837813327489"
+            ],
+            [
+              "0.00000038870291281836147870706069755490112005482275865549715608056202387508262086228592",
+              "0.00000038694785166443924444615918541633475510031029634091364307017672093209705247924447"
+            ],
+            [
+              "0.00000038870291281836147870706069755490112005482275865549715608056202387508262086228592",
+              "0.00000038694785166443924444615918541633475510031029634091364307017672093209705247924447"
+            ],
+            [
+              "0.058271271808692643715181553884557161271691566954089982811895127943579520909455831",
+              "0.058008166897027445422496153925585161533221951189326661214780731460548390944513161"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "d776b97323c01627a112706c8dce489a9fa8671eaeb430a96a7ad44a698a0702",
+      "point_ids": [
+        "point:sm_gg_ttbar:generic-1",
+        "point:sm_gg_ttbar:generic-2",
+        "point:sm_gg_ttbar:generic-3",
+        "point:sm_gg_ttbar:stress-near-threshold"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_gg_ttbar",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,-1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,+1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,-1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:+1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:12",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:13",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:14",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:15",
+            "physical_color_ids": [
+              "flow:3,2,1,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,+1"
+            ],
+            "representative_color_id": "flow:3,2,1,4",
+            "representative_helicity_id": "h:-1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:16",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,-1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:17",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,+1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:18",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:19",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:20",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:21",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:22",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:23",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:24",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,-1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:25",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:+1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:26",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:27",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:28",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:29",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:30",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:31",
+            "physical_color_ids": [
+              "flow:3,1,2,4"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,+1"
+            ],
+            "representative_color_id": "flow:3,1,2,4",
+            "representative_helicity_id": "h:-1,-1,+1,+1"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "4170eb69ef92016c3dc3f736488a87aa976a609429d353d3dfe549de6601e887"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 36,
+        "interactions": 44,
+        "reduction_groups": 32,
+        "roots": 32
+      }
+    },
+    {
+      "artifact_execution_sha256": "4495dd3aeb34c2293f6fe40a61858819069f24e326e764b376e332c6aad09f8f",
+      "artifact_physics_sha256": "898e0e17e34db1184e00ec506d3269bc88330b694701a4708f58d4ed03fd62a7",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+0,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+0,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 4,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 5,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,-1",
+            "index": 8,
+            "representative_id": "h:-1,+1,+0,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+0,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,-1",
+            "index": 14,
+            "representative_id": "h:+1,-1,+0,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,+1",
+            "index": 15,
+            "representative_id": "h:+1,-1,+0,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1",
+            "index": 16,
+            "representative_id": "h:+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1",
+            "index": 17,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 18,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 19,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,-1",
+            "index": 20,
+            "representative_id": "h:+1,+1,+0,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,+1",
+            "index": 21,
+            "representative_id": "h:+1,+1,+0,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 22,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 23,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "nlc",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 24,
+        "structural_zero_helicity_count": 12
+      },
+      "id": "case:sm_ddbar_zg:nlc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "9",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.2812502450332261",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:nlc:point:sm_ddbar_zg:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_zg:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.216071761633247533981162889983463055439311393887806110579759592818795088850716815718019",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000016788392960862268271626971223431121831714710989090337741738120145460217944508741"
+            ],
+            [
+              "0.024280541263147041766613646392610903825041084035683224220260707339590916506719079"
+            ],
+            [
+              "0.0011092087279414939752421045500670247474474645018821276096430965412036465376798108"
+            ],
+            [
+              "0.0011092087279414942001858708877940238687012506365056424160772620848879617012908715"
+            ],
+            [
+              "0.18321348639648803041364706274554134595987509407119849103109176417428479603706135"
+            ],
+            [
+              "0.000012668004275598437992348160170071062802775823451540184192611177329050079204362659"
+            ],
+            [
+              "0.000000383251477839093701347888831872493926948934520015166631102033085759327336321766"
+            ],
+            [
+              "0.0055428493623704335276462587383010709235116819145352802545558138730446733183265419"
+            ],
+            [
+              "0.000033557447169042483417681769451092503023711367985989969766234601654272200682567546"
+            ],
+            [
+              "0.000033557447169042476612345348331746230751654663525700967196302574679181008011782909"
+            ],
+            [
+              "0.00073457137520539739835580529808326641367030294554421906554180327427339185563987765"
+            ],
+            [
+              "0.000000050790766033980921255507158294298376253521874970661028721332746894256969799113919"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:nlc:point:sm_ddbar_zg:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_zg:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.473027948148608134802496919377821508759774001909995223888016699663518367870014611306914",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000068821346804145923797054088580921521272287130304287552171756516769463945439578155"
+            ],
+            [
+              "0.0099534217167715236805527539361961875012252559369807392369166259661388251343474818"
+            ],
+            [
+              "0.0011092087279414862497239464745115106144438229638739016873743086016390084273540992"
+            ],
+            [
+              "0.0011092087279414864439753998102501176732683425056664762325914092078354215252770245"
+            ],
+            [
+              "0.44693400350144836110065754994772357527263773287280116049161514954084506370935553"
+            ],
+            [
+              "0.000030902538773888112655134427950981837524826901743454457138140552857847826807674135"
+            ],
+            [
+              "0.0000009349099823786591038050584580504679260270794616798446709655868780328151159650177"
+            ],
+            [
+              "0.013521318244927817783114997594868527700096883581453781334766664315873644046024439"
+            ],
+            [
+              "0.000033557447169042248765161861685521964611655693414325102529386152029108067740372364"
+            ],
+            [
+              "0.000033557447169042242888375357380630048571174589972077473688381207114181203658813819"
+            ],
+            [
+              "0.00030112585214834168826571638011374743460421075179052015449312885967330652273730528"
+            ],
+            [
+              "0.000000020820866725133556107987796849029651346161534064996710822107466233952141510409664"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:nlc:point:sm_ddbar_zg:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_zg:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.168725149439083771894460509742292726036535131768365524843949280237454813090322257600966",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000087346391807810054902850951008124616624032201128939686522597767061986464477720792"
+            ],
+            [
+              "0.12632642537142244745278374598027888966402654048856807215505730904628059478718212"
+            ],
+            [
+              "0.001109208727941483491097779922553665693477327957703292207983364524420949832205472"
+            ],
+            [
+              "0.0011092087279414834841756802322520124071197005549686243467759806635519955430216163"
+            ],
+            [
+              "0.035214505621729565084875300701759018357159457958323227914181853896910901780439241"
+            ],
+            [
+              "0.0000024348508210458228109098503218123063724516463062954010026564132243664265429890796"
+            ],
+            [
+              "0.000000073662761330214318199817805600771769523500380454105513315909194023126796007150626"
+            ],
+            [
+              "0.0010653620749795157323898659555379424642051805610989717330468875106379807236507395"
+            ],
+            [
+              "0.000033557447169042159220858595146232813435850013831536643960901735434641742645117425"
+            ],
+            [
+              "0.000033557447169042159430276343857271822828041602598970740450505855028197771473249943"
+            ],
+            [
+              "0.0038218166145543485110840180398436125056404399762390729650579765099214231584671189"
+            ],
+            [
+              "0.00000026425341368677678358920783585476883821428823411266226626839614353955145081422354"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:nlc:point:sm_ddbar_zg:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_zg:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "68719.68716848869325166280107404142261095803431271264111779705143647075592477003993050994602183858",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "4.6116654595420178485801120685990747763977818016934255923780127542941222518938167"
+            ],
+            [
+              "66697.11254869574818491673634561230763639573144676433767292828173746976980903881"
+            ],
+            [
+              "0.0011092087279414882650063234077058597205121746948363363291478384447230105398662349"
+            ],
+            [
+              "0.0011092087279414882650063234077058597205121746948363363291478384447230105398662349"
+            ],
+            [
+              "0.000000066697379338079705745063623886263853974863679298465158932950272416560351748282651"
+            ],
+            [
+              "0.0000000000046116839062684195544457976243830337818925674777612642048171198975214053602920625"
+            ],
+            [
+              "0.00000000000013951958287609927823336378278136273360325474840256238084430523243849028645117608"
+            ],
+            [
+              "0.0000000020178292210203832443516943099780862395300707238764440794610418036576150211306276"
+            ],
+            [
+              "0.000033557447169042303857722416291520722097316595422829210998409060122308953506507543"
+            ],
+            [
+              "0.000033557447169042303857722416291520722097316595422829210998409060122308953506507543"
+            ],
+            [
+              "2017.8211497075348212607556518522573502880369409799745848161583842525247873790261"
+            ],
+            [
+              "0.13951902479804681300200290836255737933381957314567028458524266016053981597534166"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "c622e2c05ec7999ee2f113b5dd7d0545d190dd61b4c8b2610e6ddbdf29d10e87",
+      "point_ids": [
+        "point:sm_ddbar_zg:generic-1",
+        "point:sm_ddbar_zg:generic-2",
+        "point:sm_ddbar_zg:generic-3",
+        "point:sm_ddbar_zg:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_zg",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,+1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,-1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,+1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "57c00f8b54d7efec3373b0bec2213c3228d4e5d7e1f80b02daec2e7f6b1d7c87"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 31,
+        "interactions": 34,
+        "reduction_groups": 12,
+        "roots": 12
+      }
+    },
+    {
+      "artifact_execution_sha256": "193659fd42201a00407862c2c757b35527b9b39843fd4d6cbdb96d228d063e8d",
+      "artifact_physics_sha256": "31deef42ce3382e201a612006f20a76f2eda6b6497b50180f785c604d5d4e773",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "nlc",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 12
+      },
+      "id": "case:sm_ddbar_ee:nlc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "3",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.03597510550885039",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:nlc:point:sm_ddbar_ee:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_ee:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.00103197070371250265188930731966460881986525888862870134178753527540880098118876319",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00082062602145063690518717070219774536676114976229759419782467934943057552011003644"
+            ],
+            [
+              "0.000034317817325785204386637420703764583845540164521723284391291262892588585239773347"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.000032587346469362563455141700169682840532734148148936227733209181316740425540962003"
+            ],
+            [
+              "0.0001444395184667179788603574965934160287258348136604476318383554817688964502979914"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:nlc:point:sm_ddbar_ee:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_ee:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.002630434092329740752888080219787590075981619196473987378544214109057907418807915404",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.002230861734305682567353000118804560453771283983497187519065865292660868182639291"
+            ],
+            [
+              "0.0000035470834122141293892764185485978100830525247454462244562173299464752114662944757"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000033682222564516165875423602565821526181559752418848846511791501801216786934178083"
+            ],
+            [
+              "0.00039265705235539243955826132217784965950912671298946875037095233627044234600891212"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:nlc:point:sm_ddbar_ee:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_ee:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.0021223265191563301529007185842563374973855648389268548547005522106028512381998004432",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0017903979982851031839397688040682010652651474750486537273599306148827503763884011"
+            ],
+            [
+              "0.00000861628674926538032028517348413127983982839808193197553495552960371348156942396"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000081818117659458179404837811493080589093242830453263928040839372437871362657561232"
+            ],
+            [
+              "0.00031513042235601577070018082555469709337126468275094275900158212887260024397621926"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:nlc:point:sm_ddbar_ee:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_ee:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "0.00369301772413452376893349550015400507860667242558010659999119270444005498013163385088141740983",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0031402908059099280370880976672602310294919006642941383074341971659369322802566758"
+            ],
+            [
+              "0.00000000000000014363181962999636348009408256558251162102585854531185599443672340216915191401774"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000000000013638920639602737694149283010667549204890481135420619683631815187937172950339209"
+            ],
+            [
+              "0.00055272691822431571081937180915335246220209950328229836188709602045029194499967651"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "9851348d292228e28cebdf756cbe48997e9535a645a5e9da3b8d504885c35980",
+      "point_ids": [
+        "point:sm_ddbar_ee:generic-1",
+        "point:sm_ddbar_ee:generic-2",
+        "point:sm_ddbar_ee:generic-3",
+        "point:sm_ddbar_ee:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_ee",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "a97bc0980d6b36c4af3d287247a65a4a748a3943f985a42df33b44a46c898d51"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 16,
+        "interactions": 12,
+        "reduction_groups": 4,
+        "roots": 4
+      }
+    },
+    {
+      "artifact_execution_sha256": "eec92a6eee17ec945237e7a99d70a4afd84b62bad0fbfe76c4638e5d5f6d134d",
+      "artifact_physics_sha256": "d73e804fd9322f67617d315ed0d0e3e64027cee600f5c78752806c10ecca46c8",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "nlc",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 12
+      },
+      "id": "case:sm_ddbar_uubar:nlc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "9",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:nlc:point:sm_ddbar_uubar:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_uubar:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.686942759290453617464748832985246441954666785229015076816866702226931172635351206",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.016088275717442597738655862568306927209227044371767229413928625006117557645640233"
+            ],
+            [
+              "0.32738310392778421099371855392431629376810634824274030899450472610734802867203537"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.32738310392778421099371855392431629376810634824274030899450472610734802867203537"
+            ],
+            [
+              "0.016088275717442597738655862568306927209227044371767229413928625006117557645640233"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:nlc:point:sm_ddbar_uubar:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_uubar:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.496326199854538816983201147725380760677211994778215065043928867318933157215254792",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.093400085491858858693964803927517128365114803794582216369975351271864484393404786"
+            ],
+            [
+              "0.15476301443541054979763576993517325197349119359452531615198908238760209421422261"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.15476301443541054979763576993517325197349119359452531615198908238760209421422261"
+            ],
+            [
+              "0.093400085491858858693964803927517128365114803794582216369975351271864484393404786"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:nlc:point:sm_ddbar_uubar:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_uubar:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.53016860746829376370786751993839461152943231709725921797937010950716709180798442",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.20378379323180817094314326721295658098675859271924379880544442348110643910989305"
+            ],
+            [
+              "0.06130051050233871091079049275624072477795756582938581018424063127247710679409916"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.06130051050233871091079049275624072477795756582938581018424063127247710679409916"
+            ],
+            [
+              "0.20378379323180817094314326721295658098675859271924379880544442348110643910989305"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:nlc:point:sm_ddbar_uubar:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_uubar:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "0.97723802191662078031902581242746719027897783326807709145916051302820468629114292344768551876",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.48861901095782176919407219992364524351011601067075455251129436207109765960113002"
+            ],
+            [
+              "0.00000000000048862096544070629008835162937290596328399321828589444300468354444144172384275938"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000000048862096544070629008835162937290596328399321828589444300468354444144172384275938"
+            ],
+            [
+              "0.48861901095782176919407219992364524351011601067075455251129436207109765960113002"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "699634e12fe926987c1ca1e88982e17fb4925a014f9704fce2c38fcf19410b0c",
+      "point_ids": [
+        "point:sm_ddbar_uubar:generic-1",
+        "point:sm_ddbar_uubar:generic-2",
+        "point:sm_ddbar_uubar:generic-3",
+        "point:sm_ddbar_uubar:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_uubar",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "29b453fbf2de542e083d040d6a2c1c9eb94909947cc1cf470c9935bfac23b6f0"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 20,
+        "interactions": 8,
+        "reduction_groups": 4,
+        "roots": 4
+      }
+    },
+    {
+      "artifact_execution_sha256": "19d27384fe6d1e648e9cca38db1879eced0ff5e72323af35442e4aa45770a9d7",
+      "artifact_physics_sha256": "e60c981c00c1849d22a0b187d235782d151aa608183c64a71b1f358a620814d2",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "nlc",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 10
+      },
+      "id": "case:sm_ddbar_ddbar:nlc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "9",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:nlc:point:sm_ddbar_ddbar:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "20.796297712640084402795855582349976686410160357006275633116826747635827100778059752",
+          "values": [
+            [
+              "6.2545202620747474031044884390587570888098084833609326538754903160583828753413647"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "4.1054562832025776668323704908123605253035967054542538839612013724142712843557246"
+            ],
+            [
+              "0.038172311042717131461068861303870729091674989687951278721721685345259390691940576"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.038172311042717131461068861303870729091674989687951278721721685345259390691940576"
+            ],
+            [
+              "4.1054562832025776668323704908123605253035967054542538839612013724142712843557246"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "6.2545202620747474031044884390587570888098084833609326538754903160583828753413647"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:nlc:point:sm_ddbar_ddbar:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "11.39860245659500707563904167984955224807973656002388044995577300842218471109287718",
+          "values": [
+            [
+              "3.6281562008441116895080303883424849223503895430239169352165348367000435737489979"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "2.0053403929088958154493132452722639525087131543848134178873423576041481301817788"
+            ],
+            [
+              "0.06580463454449603286217720631002724918076558260320987187400930990690065161566189"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.06580463454449603286217720631002724918076558260320987187400930990690065161566189"
+            ],
+            [
+              "2.0053403929088958154493132452722639525087131543848134178873423576041481301817788"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "3.6281562008441116895080303883424849223503895430239169352165348367000435737489979"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:nlc:point:sm_ddbar_ddbar:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "60.85232184454731706267418755250380060079109459894625186266777006157840316685427914",
+          "values": [
+            [
+              "17.01354794446001630995156900264229746321996706495377745434304938845224136017171"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "13.39858007335148763666307040537438165715686708076239027940264220428868216863519"
+            ],
+            [
+              "0.01403290446215458472245436823522118001871315375695819758819343804827805462023957"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.01403290446215458472245436823522118001871315375695819758819343804827805462023957"
+            ],
+            [
+              "13.39858007335148763666307040537438165715686708076239027940264220428868216863519"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "17.01354794446001630995156900264229746321996706495377745434304938845224136017171"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:nlc:point:sm_ddbar_ddbar:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "1954474740846.60636129752361781296933289079134632154663976827032575668283270915080936708888288344768551876",
+          "values": [
+            [
+              "488619010957.82176919407219992364524351011601067075455251129436207109765960113002"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "488618359465.48141145468912036187398222898957413838939446687751681402547085900238"
+            ],
+            [
+              "0.00000000000048862096544070629008835162937290596328399321828589444300468354444144172384275938"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000000048862096544070629008835162937290596328399321828589444300468354444144172384275938"
+            ],
+            [
+              "488618359465.48141145468912036187398222898957413838939446687751681402547085900238"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "488619010957.82176919407219992364524351011601067075455251129436207109765960113002"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "e63ec6fdb854a9e24a5a21f6110f376a6b6e00329a2bd741d29bc4ac60dec606",
+      "point_ids": [
+        "point:sm_ddbar_ddbar:generic-1",
+        "point:sm_ddbar_ddbar:generic-2",
+        "point:sm_ddbar_ddbar:generic-3",
+        "point:sm_ddbar_ddbar:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_ddbar",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "fa528444e1575065fa58644d801351080bd3a2b73433ce3bf1abf58b0e71dd50"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 28,
+        "interactions": 16,
+        "reduction_groups": 6,
+        "roots": 6
+      }
+    },
+    {
+      "artifact_execution_sha256": "9afe33b304a318d453783733c7b680cc32e62d2f975c8f636478444fe76f954d",
+      "artifact_physics_sha256": "bf3954909cd7d8b3ced5c8a010d9c2cab69b87824af6ae71782fa47b32abddda",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "nlc",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 10
+      },
+      "id": "case:sm_gg_gg:nlc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "256",
+        "color_factor": "81",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "2",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:nlc:point:sm_gg_gg:generic-1"
+          ],
+          "point_id": "point:sm_gg_gg:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "57.16620400231588009908035541820118649927058386361411538228276097942868993232704574",
+          "values": [
+            [
+              "22.757065758393621872187986049445585027897042023545576030127564871527863565553157"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "5.6561917320490159868851954305074314966517423474721793563760810041155415565141748"
+            ],
+            [
+              "0.16984451071530219046699622914757672508650756078930230463773461407093984409619107"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.16984451071530219046699622914757672508650756078930230463773461407093984409619107"
+            ],
+            [
+              "5.6561917320490159868851954305074314966517423474721793563760810041155415565141748"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "22.757065758393621872187986049445585027897042023545576030127564871527863565553157"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:nlc:point:sm_gg_gg:generic-2"
+          ],
+          "point_id": "point:sm_gg_gg:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "315.275490617460505160609261826378323380920172646107679046917571678820679647568074268",
+          "values": [
+            [
+              "98.596680832320244414708624779755850034167936075338806049757820991325838258200993"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.020719473664169403148674346849771402016986418342724454126519902950086144714649134"
+            ],
+            [
+              "59.020345002745838762447331786583540254275163829372309019574444945134415420868395"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "59.020345002745838762447331786583540254275163829372309019574444945134415420868395"
+            ],
+            [
+              "0.020719473664169403148674346849771402016986418342724454126519902950086144714649134"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "98.596680832320244414708624779755850034167936075338806049757820991325838258200993"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:nlc:point:sm_gg_gg:generic-3"
+          ],
+          "point_id": "point:sm_gg_gg:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "44.31960643241055304341039598235444236459464752760283819349856460354702023133010364",
+          "values": [
+            [
+              "18.545106868908953352774941922358985854679375617140910161997671528009715223596713"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.27354100231415676295030808948598503606886306379289899268891063090571479808430892"
+            ],
+            [
+              "3.3411553449821664059799479793322502915490850828676099420627001428580800939840299"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "3.3411553449821664059799479793322502915490850828676099420627001428580800939840299"
+            ],
+            [
+              "0.27354100231415676295030808948598503606886306379289899268891063090571479808430892"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "18.545106868908953352774941922358985854679375617140910161997671528009715223596713"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:nlc:point:sm_gg_gg:stress-near-collinear"
+          ],
+          "point_id": "point:sm_gg_gg:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "4947262538690.3540379055440816342663133461846956984528436023188842260636992694544348650118580136480459384",
+          "values": [
+            [
+              "1236818108307.5683065043625259009866080500474135333082205424141135417288581649905"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "1236813161037.6087124484082780930909513059952722902689852529790024544736870579906"
+            ],
+            [
+              "0.0000000000012368230555973170496620256492160057663261168293044117461174325059290068240229692"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000000000012368230555973170496620256492160057663261168293044117461174325059290068240229692"
+            ],
+            [
+              "1236813161037.6087124484082780930909513059952722902689852529790024544736870579906"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "1236818108307.5683065043625259009866080500474135333082205424141135417288581649905"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "5f538cea8fbcd47d427d490c10e05a2241208e16455bbe228ca5db046e385862",
+      "point_ids": [
+        "point:sm_gg_gg:generic-1",
+        "point:sm_gg_gg:generic-2",
+        "point:sm_gg_gg:generic-3",
+        "point:sm_gg_gg:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_gg_gg",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:12",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:13",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:14",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:15",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:16",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:17",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "ed8dbc77663bb127ecfbdf623099c5e35640893344e50d5cac00a32b538d1401"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 73,
+        "interactions": 120,
+        "reduction_groups": 18,
+        "roots": 18
+      }
+    },
+    {
+      "artifact_execution_sha256": "93d9c3c748cf5b2447fa631a30b35933b47d2e70e0d38e6207bcf9e5e8aeb447",
+      "artifact_physics_sha256": "a4ce99986b9f24145a114d094fa7b4bb48318872431d7791bd3d0baa6816ef7d",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "nlc",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 0
+      },
+      "id": "case:sm_gg_ttbar:nlc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "256",
+        "color_factor": "27",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:nlc:point:sm_gg_ttbar:generic-1"
+          ],
+          "point_id": "point:sm_gg_ttbar:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "1.62107876924343138126755773360234358235853476055677429080192302994609423112675403609894",
+          "values": [
+            [
+              "0.20852519192643640048000417129190879756950402231930676345147806581329264225775962"
+            ],
+            [
+              "0.000000062520657708280947048315885910971600694326192854999736747363188230095259278039735"
+            ],
+            [
+              "0.000000062520657708280947048315885910971600694326192854999736747363188230095259278039735"
+            ],
+            [
+              "0.00021176543672018345827098888005032080287385516993991972468120144107993051347280297"
+            ],
+            [
+              "0.010472261072627842113812432477948916377338252266212202582245516522062283891083582"
+            ],
+            [
+              "0.56737096448254629934889426882818966236563334961710424760398195604318969088417607"
+            ],
+            [
+              "0.013486815589441706557090476213353355743378259987226099456855763904983823935282805"
+            ],
+            [
+              "0.010472261072627842113812432477948916377338252266212202582245516522062283891083582"
+            ],
+            [
+              "0.010472261072627842113812432477948916377338252266212202582245516522062283891083582"
+            ],
+            [
+              "0.013486815589441706557090476213353355743378259987226099456855763904983823935282805"
+            ],
+            [
+              "0.56737096448254629934889426882818966236563334961710424760398195604318969088417607"
+            ],
+            [
+              "0.010472261072627842113812432477948916377338252266212202582245516522062283891083582"
+            ],
+            [
+              "0.00021176543672018345827098888005032080287385516993991972468120144107993051347280297"
+            ],
+            [
+              "0.000000062520657708280947048315885910971600694326192854999736747363188230095259278039735"
+            ],
+            [
+              "0.000000062520657708280947048315885910971600694326192854999736747363188230095259278039735"
+            ],
+            [
+              "0.20852519192643640048000417129190879756950402231930676345147806581329264225775962"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:nlc:point:sm_gg_ttbar:generic-2"
+          ],
+          "point_id": "point:sm_gg_ttbar:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.479067132047329782957050729040509089606478289512939239637804731390443223320697189110232",
+          "values": [
+            [
+              "0.0452834749773773333014894322141907411066766148801036774997964309329513768679904"
+            ],
+            [
+              "0.000000030751591009522888963395026038896903055702677265617449767123071498963230107806058"
+            ],
+            [
+              "0.000000030751591009522888963395026038896903055702677265617449767123071498963230107806058"
+            ],
+            [
+              "0.000045985586626623550669401072385134437823497776164610008995743775348074030449757543"
+            ],
+            [
+              "0.0090129081742816746674701897529619818220638741959305570473155984656801930530017857"
+            ],
+            [
+              "0.04235347492344941843099169237247705319402198594630364630729365527348119968183325"
+            ],
+            [
+              "0.1338247526844661478146565325652255746267831863566820406732858045359375770476114"
+            ],
+            [
+              "0.0090129081742816746674701897529619818220638741959305570473155984656801930530017857"
+            ],
+            [
+              "0.0090129081742816746674701897529619818220638741959305570473155984656801930530017857"
+            ],
+            [
+              "0.1338247526844661478146565325652255746267831863566820406732858045359375770476114"
+            ],
+            [
+              "0.04235347492344941843099169237247705319402198594630364630729365527348119968183325"
+            ],
+            [
+              "0.0090129081742816746674701897529619818220638741959305570473155984656801930530017857"
+            ],
+            [
+              "0.000045985586626623550669401072385134437823497776164610008995743775348074030449757543"
+            ],
+            [
+              "0.000000030751591009522888963395026038896903055702677265617449767123071498963230107806058"
+            ],
+            [
+              "0.000000030751591009522888963395026038896903055702677265617449767123071498963230107806058"
+            ],
+            [
+              "0.0452834749773773333014894322141907411066766148801036774997964309329513768679904"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:nlc:point:sm_gg_ttbar:generic-3"
+          ],
+          "point_id": "point:sm_gg_ttbar:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "1.63279564618344258159496768919928494289210650311164609745444641470208133988666696383748",
+          "values": [
+            [
+              "0.21066837456303760443715313071681728132919515805882633303498857510049520680308567"
+            ],
+            [
+              "0.00000006278652777392338934713168420545859269911973054519029003103956669383652216030437"
+            ],
+            [
+              "0.00000006278652777392338934713168420545859269911973054519029003103956669383652216030437"
+            ],
+            [
+              "0.00021394195817396747074640315288555308556574709293745565383609426050681816169290031"
+            ],
+            [
+              "0.010464796306441899560411898416019733956864142778664539349860794109986101122961828"
+            ],
+            [
+              "0.57120867623303251881943919199906704700907347323073059823077069534956935106938897"
+            ],
+            [
+              "0.013377112151537853102542627635464711191305189376538492727326192341363703990197965"
+            ],
+            [
+              "0.010464796306441899560411898416019733956864142778664539349860794109986101122961828"
+            ],
+            [
+              "0.010464796306441899560411898416019733956864142778664539349860794109986101122961828"
+            ],
+            [
+              "0.013377112151537853102542627635464711191305189376538492727326192341363703990197965"
+            ],
+            [
+              "0.57120867623303251881943919199906704700907347323073059823077069534956935106938897"
+            ],
+            [
+              "0.010464796306441899560411898416019733956864142778664539349860794109986101122961828"
+            ],
+            [
+              "0.00021394195817396747074640315288555308556574709293745565383609426050681816169290031"
+            ],
+            [
+              "0.00000006278652777392338934713168420545859269911973054519029003103956669383652216030437"
+            ],
+            [
+              "0.00000006278652777392338934713168420545859269911973054519029003103956669383652216030437"
+            ],
+            [
+              "0.21066837456303760443715313071681728132919515805882633303498857510049520680308567"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:nlc:point:sm_gg_ttbar:stress-near-threshold"
+          ],
+          "point_id": "point:sm_gg_ttbar:stress-near-threshold",
+          "round_trip_decimal_digits": 80,
+          "total": "0.3206603799074445051397943147009515236608435136977555182702161107293248166081574434048234",
+          "values": [
+            [
+              "0.080391025607618905104171032687182411057634852278788948076338169041475140139237175"
+            ],
+            [
+              "0.00000068946715009596704037022162961730052403910145251379986900814815492747300320815284"
+            ],
+            [
+              "0.00000068946715009596704037022162961730052403910145251379986900814815492747300320815284"
+            ],
+            [
+              "0.079937554542607222960745225184880668468224428360338155631519209999398767286236418"
+            ],
+            [
+              "0.000000020778193557676908305466247780836473400823952847033131363732469389165875027181545"
+            ],
+            [
+              "0.00000018700411602676321667556482059473751189396431871505684444558006986921547245488689"
+            ],
+            [
+              "0.0000000023086927904538668725378372912930557023946212187044054869824699983853762031467517"
+            ],
+            [
+              "0.000000020778193557676908305466247780836473400823952847033131363732469389165875027181545"
+            ],
+            [
+              "0.000000020778193557676908305466247780836473400823952847033131363732469389165875027181545"
+            ],
+            [
+              "0.0000000023086927904538668725378372912930557023946212187044054869824699983853762031467517"
+            ],
+            [
+              "0.00000018700411602676321667556482059473751189396431871505684444558006986921547245488689"
+            ],
+            [
+              "0.000000020778193557676908305466247780836473400823952847033131363732469389165875027181545"
+            ],
+            [
+              "0.079937554542607222960745225184880668468224428360338155631519209999398767286236418"
+            ],
+            [
+              "0.00000068946715009596704037022162961730052403910145251379986900814815492747300320815284"
+            ],
+            [
+              "0.00000068946715009596704037022162961730052403910145251379986900814815492747300320815284"
+            ],
+            [
+              "0.080391025607618905104171032687182411057634852278788948076338169041475140139237175"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "9b752367b61eaf756835ae5e33171100f2a7bfe9d103f7a71f18babb9352f3f4",
+      "point_ids": [
+        "point:sm_gg_ttbar:generic-1",
+        "point:sm_gg_ttbar:generic-2",
+        "point:sm_gg_ttbar:generic-3",
+        "point:sm_gg_ttbar:stress-near-threshold"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_gg_ttbar",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:12",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:13",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:14",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:15",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:16",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:17",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:18",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:19",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:20",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:21",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:22",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:23",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:24",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:25",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:26",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:27",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:28",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:29",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:30",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:31",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,+1,+1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "ab2550441908d0db0dc42aa7a6551308ef03cc1f437c9c1ecc476108575aebab"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 48,
+        "interactions": 48,
+        "reduction_groups": 32,
+        "roots": 32
+      }
+    },
+    {
+      "artifact_execution_sha256": "4ca3a029b581cd07e1e8782ab6e1c6300d808fc7e6fd062aaf4b34189307b6ab",
+      "artifact_physics_sha256": "8a0169fd3e30f139db8ab29c2b9d0d7ae313f0f3646897c1916f50d20406f893",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+0,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+0,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 4,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 5,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,-1",
+            "index": 8,
+            "representative_id": "h:-1,+1,+0,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+0,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,-1",
+            "index": 14,
+            "representative_id": "h:+1,-1,+0,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,+1",
+            "index": 15,
+            "representative_id": "h:+1,-1,+0,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1",
+            "index": 16,
+            "representative_id": "h:+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1",
+            "index": 17,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 18,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 19,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,-1",
+            "index": 20,
+            "representative_id": "h:+1,+1,+0,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,+1",
+            "index": 21,
+            "representative_id": "h:+1,+1,+0,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 22,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 23,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "full",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 24,
+        "structural_zero_helicity_count": 12
+      },
+      "id": "case:sm_ddbar_zg:full",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "9",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.2812502450332261",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:full:point:sm_ddbar_zg:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_zg:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.216071761633247533981162889983463055439311393887806110579759592818795088850716815718019",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000016788392960862268271626971223431121831714710989090337741738120145460217944508741"
+            ],
+            [
+              "0.024280541263147041766613646392610903825041084035683224220260707339590916506719079"
+            ],
+            [
+              "0.0011092087279414939752421045500670247474474645018821276096430965412036465376798108"
+            ],
+            [
+              "0.0011092087279414942001858708877940238687012506365056424160772620848879617012908715"
+            ],
+            [
+              "0.18321348639648803041364706274554134595987509407119849103109176417428479603706135"
+            ],
+            [
+              "0.000012668004275598437992348160170071062802775823451540184192611177329050079204362659"
+            ],
+            [
+              "0.000000383251477839093701347888831872493926948934520015166631102033085759327336321766"
+            ],
+            [
+              "0.0055428493623704335276462587383010709235116819145352802545558138730446733183265419"
+            ],
+            [
+              "0.000033557447169042483417681769451092503023711367985989969766234601654272200682567546"
+            ],
+            [
+              "0.000033557447169042476612345348331746230751654663525700967196302574679181008011782909"
+            ],
+            [
+              "0.00073457137520539739835580529808326641367030294554421906554180327427339185563987765"
+            ],
+            [
+              "0.000000050790766033980921255507158294298376253521874970661028721332746894256969799113919"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:full:point:sm_ddbar_zg:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_zg:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.473027948148608134802496919377821508759774001909995223888016699663518367870014611306914",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000068821346804145923797054088580921521272287130304287552171756516769463945439578155"
+            ],
+            [
+              "0.0099534217167715236805527539361961875012252559369807392369166259661388251343474818"
+            ],
+            [
+              "0.0011092087279414862497239464745115106144438229638739016873743086016390084273540992"
+            ],
+            [
+              "0.0011092087279414864439753998102501176732683425056664762325914092078354215252770245"
+            ],
+            [
+              "0.44693400350144836110065754994772357527263773287280116049161514954084506370935553"
+            ],
+            [
+              "0.000030902538773888112655134427950981837524826901743454457138140552857847826807674135"
+            ],
+            [
+              "0.0000009349099823786591038050584580504679260270794616798446709655868780328151159650177"
+            ],
+            [
+              "0.013521318244927817783114997594868527700096883581453781334766664315873644046024439"
+            ],
+            [
+              "0.000033557447169042248765161861685521964611655693414325102529386152029108067740372364"
+            ],
+            [
+              "0.000033557447169042242888375357380630048571174589972077473688381207114181203658813819"
+            ],
+            [
+              "0.00030112585214834168826571638011374743460421075179052015449312885967330652273730528"
+            ],
+            [
+              "0.000000020820866725133556107987796849029651346161534064996710822107466233952141510409664"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:full:point:sm_ddbar_zg:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_zg:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.168725149439083771894460509742292726036535131768365524843949280237454813090322257600966",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000087346391807810054902850951008124616624032201128939686522597767061986464477720792"
+            ],
+            [
+              "0.12632642537142244745278374598027888966402654048856807215505730904628059478718212"
+            ],
+            [
+              "0.001109208727941483491097779922553665693477327957703292207983364524420949832205472"
+            ],
+            [
+              "0.0011092087279414834841756802322520124071197005549686243467759806635519955430216163"
+            ],
+            [
+              "0.035214505621729565084875300701759018357159457958323227914181853896910901780439241"
+            ],
+            [
+              "0.0000024348508210458228109098503218123063724516463062954010026564132243664265429890796"
+            ],
+            [
+              "0.000000073662761330214318199817805600771769523500380454105513315909194023126796007150626"
+            ],
+            [
+              "0.0010653620749795157323898659555379424642051805610989717330468875106379807236507395"
+            ],
+            [
+              "0.000033557447169042159220858595146232813435850013831536643960901735434641742645117425"
+            ],
+            [
+              "0.000033557447169042159430276343857271822828041602598970740450505855028197771473249943"
+            ],
+            [
+              "0.0038218166145543485110840180398436125056404399762390729650579765099214231584671189"
+            ],
+            [
+              "0.00000026425341368677678358920783585476883821428823411266226626839614353955145081422354"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zg:full:point:sm_ddbar_zg:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_zg:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "68719.68716848869325166280107404142261095803431271264111779705143647075592477003993050994602183858",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "4.6116654595420178485801120685990747763977818016934255923780127542941222518938167"
+            ],
+            [
+              "66697.11254869574818491673634561230763639573144676433767292828173746976980903881"
+            ],
+            [
+              "0.0011092087279414882650063234077058597205121746948363363291478384447230105398662349"
+            ],
+            [
+              "0.0011092087279414882650063234077058597205121746948363363291478384447230105398662349"
+            ],
+            [
+              "0.000000066697379338079705745063623886263853974863679298465158932950272416560351748282651"
+            ],
+            [
+              "0.0000000000046116839062684195544457976243830337818925674777612642048171198975214053602920625"
+            ],
+            [
+              "0.00000000000013951958287609927823336378278136273360325474840256238084430523243849028645117608"
+            ],
+            [
+              "0.0000000020178292210203832443516943099780862395300707238764440794610418036576150211306276"
+            ],
+            [
+              "0.000033557447169042303857722416291520722097316595422829210998409060122308953506507543"
+            ],
+            [
+              "0.000033557447169042303857722416291520722097316595422829210998409060122308953506507543"
+            ],
+            [
+              "2017.8211497075348212607556518522573502880369409799745848161583842525247873790261"
+            ],
+            [
+              "0.13951902479804681300200290836255737933381957314567028458524266016053981597534166"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "748fe481f3c5b16ec661d65f56df93ab97d40f2d203573db11b647886d77bc09",
+      "point_ids": [
+        "point:sm_ddbar_zg:generic-1",
+        "point:sm_ddbar_zg:generic-2",
+        "point:sm_ddbar_zg:generic-3",
+        "point:sm_ddbar_zg:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_zg",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,+1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,-1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,+1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "57c00f8b54d7efec3373b0bec2213c3228d4e5d7e1f80b02daec2e7f6b1d7c87"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 31,
+        "interactions": 34,
+        "reduction_groups": 12,
+        "roots": 12
+      }
+    },
+    {
+      "artifact_execution_sha256": "0d15a2e7455d936f625f6a242d2d3725e744f875e0813821ff13f1bbaf685c88",
+      "artifact_physics_sha256": "8b36c811363cc9c453455f12ccaca1e9f8a505ef99bb358e74e6267c7205e529",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "full",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 12
+      },
+      "id": "case:sm_ddbar_ee:full",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "3",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.03597510550885039",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:full:point:sm_ddbar_ee:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_ee:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.00103197070371250265188930731966460881986525888862870134178753527540880098118876319",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00082062602145063690518717070219774536676114976229759419782467934943057552011003644"
+            ],
+            [
+              "0.000034317817325785204386637420703764583845540164521723284391291262892588585239773347"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.000032587346469362563455141700169682840532734148148936227733209181316740425540962003"
+            ],
+            [
+              "0.0001444395184667179788603574965934160287258348136604476318383554817688964502979914"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:full:point:sm_ddbar_ee:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_ee:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.002630434092329740752888080219787590075981619196473987378544214109057907418807915404",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.002230861734305682567353000118804560453771283983497187519065865292660868182639291"
+            ],
+            [
+              "0.0000035470834122141293892764185485978100830525247454462244562173299464752114662944757"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000033682222564516165875423602565821526181559752418848846511791501801216786934178083"
+            ],
+            [
+              "0.00039265705235539243955826132217784965950912671298946875037095233627044234600891212"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:full:point:sm_ddbar_ee:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_ee:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.0021223265191563301529007185842563374973855648389268548547005522106028512381998004432",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0017903979982851031839397688040682010652651474750486537273599306148827503763884011"
+            ],
+            [
+              "0.00000861628674926538032028517348413127983982839808193197553495552960371348156942396"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000081818117659458179404837811493080589093242830453263928040839372437871362657561232"
+            ],
+            [
+              "0.00031513042235601577070018082555469709337126468275094275900158212887260024397621926"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ee:full:point:sm_ddbar_ee:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_ee:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "0.00369301772413452376893349550015400507860667242558010659999119270444005498013163385088141740983",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0031402908059099280370880976672602310294919006642941383074341971659369322802566758"
+            ],
+            [
+              "0.00000000000000014363181962999636348009408256558251162102585854531185599443672340216915191401774"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000000000013638920639602737694149283010667549204890481135420619683631815187937172950339209"
+            ],
+            [
+              "0.00055272691822431571081937180915335246220209950328229836188709602045029194499967651"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "dd5047097a5d2663674b5785faa9c998258bcfdaa3a51f905dab106874e944ea",
+      "point_ids": [
+        "point:sm_ddbar_ee:generic-1",
+        "point:sm_ddbar_ee:generic-2",
+        "point:sm_ddbar_ee:generic-3",
+        "point:sm_ddbar_ee:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_ee",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "a97bc0980d6b36c4af3d287247a65a4a748a3943f985a42df33b44a46c898d51"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 16,
+        "interactions": 12,
+        "reduction_groups": 4,
+        "roots": 4
+      }
+    },
+    {
+      "artifact_execution_sha256": "f5571877b5909edb637afa0ea63e6e508c29dcfc3b140517bcbd8055f81a7834",
+      "artifact_physics_sha256": "aabe6e3523dfa2706d9386ba0d9b975a97bb68110c6126d2d0a4e967657b6fc0",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "full",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 12
+      },
+      "id": "case:sm_ddbar_uubar:full",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "9",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:full:point:sm_ddbar_uubar:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_uubar:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.686942759290453617464748832985246441954666785229015076816866702226931172635351206",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.016088275717442597738655862568306927209227044371767229413928625006117557645640233"
+            ],
+            [
+              "0.32738310392778421099371855392431629376810634824274030899450472610734802867203537"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.32738310392778421099371855392431629376810634824274030899450472610734802867203537"
+            ],
+            [
+              "0.016088275717442597738655862568306927209227044371767229413928625006117557645640233"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:full:point:sm_ddbar_uubar:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_uubar:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.496326199854538816983201147725380760677211994778215065043928867318933157215254792",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.093400085491858858693964803927517128365114803794582216369975351271864484393404786"
+            ],
+            [
+              "0.15476301443541054979763576993517325197349119359452531615198908238760209421422261"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.15476301443541054979763576993517325197349119359452531615198908238760209421422261"
+            ],
+            [
+              "0.093400085491858858693964803927517128365114803794582216369975351271864484393404786"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:full:point:sm_ddbar_uubar:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_uubar:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.53016860746829376370786751993839461152943231709725921797937010950716709180798442",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.20378379323180817094314326721295658098675859271924379880544442348110643910989305"
+            ],
+            [
+              "0.06130051050233871091079049275624072477795756582938581018424063127247710679409916"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.06130051050233871091079049275624072477795756582938581018424063127247710679409916"
+            ],
+            [
+              "0.20378379323180817094314326721295658098675859271924379880544442348110643910989305"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_uubar:full:point:sm_ddbar_uubar:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_uubar:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "0.97723802191662078031902581242746719027897783326807709145916051302820468629114292344768551876",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.48861901095782176919407219992364524351011601067075455251129436207109765960113002"
+            ],
+            [
+              "0.00000000000048862096544070629008835162937290596328399321828589444300468354444144172384275938"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000000048862096544070629008835162937290596328399321828589444300468354444144172384275938"
+            ],
+            [
+              "0.48861901095782176919407219992364524351011601067075455251129436207109765960113002"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "d6d2a9b49c3188523e310b83eda8d90ba5ccab3422b29469d8026ff1fd9302cc",
+      "point_ids": [
+        "point:sm_ddbar_uubar:generic-1",
+        "point:sm_ddbar_uubar:generic-2",
+        "point:sm_ddbar_uubar:generic-3",
+        "point:sm_ddbar_uubar:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_uubar",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "29b453fbf2de542e083d040d6a2c1c9eb94909947cc1cf470c9935bfac23b6f0"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 20,
+        "interactions": 8,
+        "reduction_groups": 4,
+        "roots": 4
+      }
+    },
+    {
+      "artifact_execution_sha256": "49b944567c9f1282333d5d807c94a5e086972e2b3beb9aa654b1388de8a003ed",
+      "artifact_physics_sha256": "3651c6e5a3120574b05d165b470e08c86e06bb37d360d27adcf72ef90723cda9",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "full",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 10
+      },
+      "id": "case:sm_ddbar_ddbar:full",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "9",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:full:point:sm_ddbar_ddbar:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "20.796297712640084402795855582349976686410160357006275633116826747635827100778059752",
+          "values": [
+            [
+              "6.2545202620747474031044884390587570888098084833609326538754903160583828753413647"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "4.1054562832025776668323704908123605253035967054542538839612013724142712843557246"
+            ],
+            [
+              "0.038172311042717131461068861303870729091674989687951278721721685345259390691940576"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.038172311042717131461068861303870729091674989687951278721721685345259390691940576"
+            ],
+            [
+              "4.1054562832025776668323704908123605253035967054542538839612013724142712843557246"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "6.2545202620747474031044884390587570888098084833609326538754903160583828753413647"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:full:point:sm_ddbar_ddbar:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "11.39860245659500707563904167984955224807973656002388044995577300842218471109287718",
+          "values": [
+            [
+              "3.6281562008441116895080303883424849223503895430239169352165348367000435737489979"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "2.0053403929088958154493132452722639525087131543848134178873423576041481301817788"
+            ],
+            [
+              "0.06580463454449603286217720631002724918076558260320987187400930990690065161566189"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.06580463454449603286217720631002724918076558260320987187400930990690065161566189"
+            ],
+            [
+              "2.0053403929088958154493132452722639525087131543848134178873423576041481301817788"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "3.6281562008441116895080303883424849223503895430239169352165348367000435737489979"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:full:point:sm_ddbar_ddbar:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "60.85232184454731706267418755250380060079109459894625186266777006157840316685427914",
+          "values": [
+            [
+              "17.01354794446001630995156900264229746321996706495377745434304938845224136017171"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "13.39858007335148763666307040537438165715686708076239027940264220428868216863519"
+            ],
+            [
+              "0.01403290446215458472245436823522118001871315375695819758819343804827805462023957"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.01403290446215458472245436823522118001871315375695819758819343804827805462023957"
+            ],
+            [
+              "13.39858007335148763666307040537438165715686708076239027940264220428868216863519"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "17.01354794446001630995156900264229746321996706495377745434304938845224136017171"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_ddbar:full:point:sm_ddbar_ddbar:stress-near-collinear"
+          ],
+          "point_id": "point:sm_ddbar_ddbar:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "1954474740846.60636129752361781296933289079134632154663976827032575668283270915080936708888288344768551876",
+          "values": [
+            [
+              "488619010957.82176919407219992364524351011601067075455251129436207109765960113002"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "488618359465.48141145468912036187398222898957413838939446687751681402547085900238"
+            ],
+            [
+              "0.00000000000048862096544070629008835162937290596328399321828589444300468354444144172384275938"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000000048862096544070629008835162937290596328399321828589444300468354444144172384275938"
+            ],
+            [
+              "488618359465.48141145468912036187398222898957413838939446687751681402547085900238"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "488619010957.82176919407219992364524351011601067075455251129436207109765960113002"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "b9ecb96d6bdb1843b2d20ad95411d1931efc5c3b8a37e673e26edad85d421e15",
+      "point_ids": [
+        "point:sm_ddbar_ddbar:generic-1",
+        "point:sm_ddbar_ddbar:generic-2",
+        "point:sm_ddbar_ddbar:generic-3",
+        "point:sm_ddbar_ddbar:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_ddbar",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "fa528444e1575065fa58644d801351080bd3a2b73433ce3bf1abf58b0e71dd50"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 28,
+        "interactions": 16,
+        "reduction_groups": 6,
+        "roots": 6
+      }
+    },
+    {
+      "artifact_execution_sha256": "fd6f268e8d97d9629ceca70f5180805b52f3409a3346a5bb8ebbc436141066be",
+      "artifact_physics_sha256": "df41e0ffce4a495ed44a6b5f0b38ef6dcb88de77a32b946b65ac28f6f222aacd",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "full",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 10
+      },
+      "id": "case:sm_gg_gg:full",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "256",
+        "color_factor": "81",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "2",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:full:point:sm_gg_gg:generic-1"
+          ],
+          "point_id": "point:sm_gg_gg:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "57.16620400231587771715518865503951599777556606192673415825855083579965448411279098",
+          "values": [
+            [
+              "22.757065758393620923976912783044673743064304236827667989689694006688302349201137"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "5.6561917320490157512105399284650987975589721534696436307829646966910123592953364"
+            ],
+            [
+              "0.16984451071530218339014161600998545826450664066605545865661671452051253355992209"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.16984451071530218339014161600998545826450664066605545865661671452051253355992209"
+            ],
+            [
+              "5.6561917320490157512105399284650987975589721534696436307829646966910123592953364"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "22.757065758393620923976912783044673743064304236827667989689694006688302349201137"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:full:point:sm_gg_gg:generic-2"
+          ],
+          "point_id": "point:sm_gg_gg:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "315.275490617460492024130486098857275229988560798112028656533560622217197647848246356",
+          "values": [
+            [
+              "98.59668083232024030651359009974566613536487955955661019228639708995032270581541"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.020719473664169402285362944176046270842051160254562570559779002482780347908337178"
+            ],
+            [
+              "59.020345002745836303266290005506925208787349679244841565420604218675495770200376"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "59.020345002745836303266290005506925208787349679244841565420604218675495770200376"
+            ],
+            [
+              "0.020719473664169402285362944176046270842051160254562570559779002482780347908337178"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "98.59668083232024030651359009974566613536487955955661019228639708995032270581541"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:full:point:sm_gg_gg:generic-3"
+          ],
+          "point_id": "point:sm_gg_gg:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "44.31960643241055119676012796524806577204261721896510409524201793919185118835767408",
+          "values": [
+            [
+              "18.545106868908952580062155717819262861670044391137380929048042714909611632666317"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.27354100231415675155276632639611991834784491748673732940618274848128678186787134"
+            ],
+            [
+              "3.3411553449821662667651419384086501060034193008584337891667835062050271796446487"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "3.3411553449821662667651419384086501060034193008584337891667835062050271796446487"
+            ],
+            [
+              "0.27354100231415675155276632639611991834784491748673732940618274848128678186787134"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "18.545106868908952580062155717819262861670044391137380929048042714909611632666317"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_gg:full:point:sm_gg_gg:stress-near-collinear"
+          ],
+          "point_id": "point:sm_gg_gg:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "4947262538690.3538317696049695361814006151812942706897875112898967905285491728342584625698237014715932296",
+          "values": [
+            [
+              "1236818108307.5682549702746797523071703682755009921995517904385496538863355644024"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "1236813161037.6086609145265681927279326223170184114793475031759903599326348505322"
+            ],
+            [
+              "0.0000000000012368230555973169981277316659944620304083814453041714825292312849118507357966148"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000000000012368230555973169981277316659944620304083814453041714825292312849118507357966148"
+            ],
+            [
+              "1236813161037.6086609145265681927279326223170184114793475031759903599326348505322"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "1236818108307.5682549702746797523071703682755009921995517904385496538863355644024"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "398f7e906137fea36df30cb527842922c69705b0d68067eed77dfa93cd5360d4",
+      "point_ids": [
+        "point:sm_gg_gg:generic-1",
+        "point:sm_gg_gg:generic-2",
+        "point:sm_gg_gg:generic-3",
+        "point:sm_gg_gg:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_gg_gg",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:12",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:13",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:14",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:15",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1",
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:16",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1",
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:17",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1",
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "ed8dbc77663bb127ecfbdf623099c5e35640893344e50d5cac00a32b538d1401"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 73,
+        "interactions": 120,
+        "reduction_groups": 18,
+        "roots": 18
+      }
+    },
+    {
+      "artifact_execution_sha256": "1df6e0a2b9059ca507e224ad99b857ebdceb9f8a362c49016dc5f257fc3a3bcb",
+      "artifact_physics_sha256": "99ecdfa6df27c91ecab7ef9839e1925bfbba88947bfed808fb019718971de543",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1",
+            "index": 8,
+            "representative_id": "h:+1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1",
+            "index": 9,
+            "representative_id": "h:+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1",
+            "index": 10,
+            "representative_id": "h:+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1",
+            "index": 11,
+            "representative_id": "h:+1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,-1,-1",
+            "index": 12,
+            "representative_id": "h:+1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,-1,+1",
+            "index": 13,
+            "representative_id": "h:+1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,+1,-1",
+            "index": 14,
+            "representative_id": "h:+1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,+1,+1,+1",
+            "index": 15,
+            "representative_id": "h:+1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "full",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 16,
+        "structural_zero_helicity_count": 0
+      },
+      "id": "case:sm_gg_ttbar:full",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "256",
+        "color_factor": "27",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "2.1987899468922913",
+        "identical_factor": "1",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:full:point:sm_gg_ttbar:generic-1"
+          ],
+          "point_id": "point:sm_gg_ttbar:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "1.62107876924343138126755773360234358235853476055677429080192302994609423112675403609894",
+          "values": [
+            [
+              "0.20852519192643640048000417129190879756950402231930676345147806581329264225775962"
+            ],
+            [
+              "0.000000062520657708280947048315885910971600694326192854999736747363188230095259278039735"
+            ],
+            [
+              "0.000000062520657708280947048315885910971600694326192854999736747363188230095259278039735"
+            ],
+            [
+              "0.00021176543672018345827098888005032080287385516993991972468120144107993051347280297"
+            ],
+            [
+              "0.010472261072627842113812432477948916377338252266212202582245516522062283891083582"
+            ],
+            [
+              "0.56737096448254629934889426882818966236563334961710424760398195604318969088417607"
+            ],
+            [
+              "0.013486815589441706557090476213353355743378259987226099456855763904983823935282805"
+            ],
+            [
+              "0.010472261072627842113812432477948916377338252266212202582245516522062283891083582"
+            ],
+            [
+              "0.010472261072627842113812432477948916377338252266212202582245516522062283891083582"
+            ],
+            [
+              "0.013486815589441706557090476213353355743378259987226099456855763904983823935282805"
+            ],
+            [
+              "0.56737096448254629934889426882818966236563334961710424760398195604318969088417607"
+            ],
+            [
+              "0.010472261072627842113812432477948916377338252266212202582245516522062283891083582"
+            ],
+            [
+              "0.00021176543672018345827098888005032080287385516993991972468120144107993051347280297"
+            ],
+            [
+              "0.000000062520657708280947048315885910971600694326192854999736747363188230095259278039735"
+            ],
+            [
+              "0.000000062520657708280947048315885910971600694326192854999736747363188230095259278039735"
+            ],
+            [
+              "0.20852519192643640048000417129190879756950402231930676345147806581329264225775962"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:full:point:sm_gg_ttbar:generic-2"
+          ],
+          "point_id": "point:sm_gg_ttbar:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.479067132047329782957050729040509089606478289512939239637804731390443223320697189110232",
+          "values": [
+            [
+              "0.0452834749773773333014894322141907411066766148801036774997964309329513768679904"
+            ],
+            [
+              "0.000000030751591009522888963395026038896903055702677265617449767123071498963230107806058"
+            ],
+            [
+              "0.000000030751591009522888963395026038896903055702677265617449767123071498963230107806058"
+            ],
+            [
+              "0.000045985586626623550669401072385134437823497776164610008995743775348074030449757543"
+            ],
+            [
+              "0.0090129081742816746674701897529619818220638741959305570473155984656801930530017857"
+            ],
+            [
+              "0.04235347492344941843099169237247705319402198594630364630729365527348119968183325"
+            ],
+            [
+              "0.1338247526844661478146565325652255746267831863566820406732858045359375770476114"
+            ],
+            [
+              "0.0090129081742816746674701897529619818220638741959305570473155984656801930530017857"
+            ],
+            [
+              "0.0090129081742816746674701897529619818220638741959305570473155984656801930530017857"
+            ],
+            [
+              "0.1338247526844661478146565325652255746267831863566820406732858045359375770476114"
+            ],
+            [
+              "0.04235347492344941843099169237247705319402198594630364630729365527348119968183325"
+            ],
+            [
+              "0.0090129081742816746674701897529619818220638741959305570473155984656801930530017857"
+            ],
+            [
+              "0.000045985586626623550669401072385134437823497776164610008995743775348074030449757543"
+            ],
+            [
+              "0.000000030751591009522888963395026038896903055702677265617449767123071498963230107806058"
+            ],
+            [
+              "0.000000030751591009522888963395026038896903055702677265617449767123071498963230107806058"
+            ],
+            [
+              "0.0452834749773773333014894322141907411066766148801036774997964309329513768679904"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:full:point:sm_gg_ttbar:generic-3"
+          ],
+          "point_id": "point:sm_gg_ttbar:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "1.63279564618344258159496768919928494289210650311164609745444641470208133988666696383748",
+          "values": [
+            [
+              "0.21066837456303760443715313071681728132919515805882633303498857510049520680308567"
+            ],
+            [
+              "0.00000006278652777392338934713168420545859269911973054519029003103956669383652216030437"
+            ],
+            [
+              "0.00000006278652777392338934713168420545859269911973054519029003103956669383652216030437"
+            ],
+            [
+              "0.00021394195817396747074640315288555308556574709293745565383609426050681816169290031"
+            ],
+            [
+              "0.010464796306441899560411898416019733956864142778664539349860794109986101122961828"
+            ],
+            [
+              "0.57120867623303251881943919199906704700907347323073059823077069534956935106938897"
+            ],
+            [
+              "0.013377112151537853102542627635464711191305189376538492727326192341363703990197965"
+            ],
+            [
+              "0.010464796306441899560411898416019733956864142778664539349860794109986101122961828"
+            ],
+            [
+              "0.010464796306441899560411898416019733956864142778664539349860794109986101122961828"
+            ],
+            [
+              "0.013377112151537853102542627635464711191305189376538492727326192341363703990197965"
+            ],
+            [
+              "0.57120867623303251881943919199906704700907347323073059823077069534956935106938897"
+            ],
+            [
+              "0.010464796306441899560411898416019733956864142778664539349860794109986101122961828"
+            ],
+            [
+              "0.00021394195817396747074640315288555308556574709293745565383609426050681816169290031"
+            ],
+            [
+              "0.00000006278652777392338934713168420545859269911973054519029003103956669383652216030437"
+            ],
+            [
+              "0.00000006278652777392338934713168420545859269911973054519029003103956669383652216030437"
+            ],
+            [
+              "0.21066837456303760443715313071681728132919515805882633303498857510049520680308567"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_gg_ttbar:full:point:sm_gg_ttbar:stress-near-threshold"
+          ],
+          "point_id": "point:sm_gg_ttbar:stress-near-threshold",
+          "round_trip_decimal_digits": 80,
+          "total": "0.3206603799074445051397943147009515236608435136977555182702161107293248166081574434048234",
+          "values": [
+            [
+              "0.080391025607618905104171032687182411057634852278788948076338169041475140139237175"
+            ],
+            [
+              "0.00000068946715009596704037022162961730052403910145251379986900814815492747300320815284"
+            ],
+            [
+              "0.00000068946715009596704037022162961730052403910145251379986900814815492747300320815284"
+            ],
+            [
+              "0.079937554542607222960745225184880668468224428360338155631519209999398767286236418"
+            ],
+            [
+              "0.000000020778193557676908305466247780836473400823952847033131363732469389165875027181545"
+            ],
+            [
+              "0.00000018700411602676321667556482059473751189396431871505684444558006986921547245488689"
+            ],
+            [
+              "0.0000000023086927904538668725378372912930557023946212187044054869824699983853762031467517"
+            ],
+            [
+              "0.000000020778193557676908305466247780836473400823952847033131363732469389165875027181545"
+            ],
+            [
+              "0.000000020778193557676908305466247780836473400823952847033131363732469389165875027181545"
+            ],
+            [
+              "0.0000000023086927904538668725378372912930557023946212187044054869824699983853762031467517"
+            ],
+            [
+              "0.00000018700411602676321667556482059473751189396431871505684444558006986921547245488689"
+            ],
+            [
+              "0.000000020778193557676908305466247780836473400823952847033131363732469389165875027181545"
+            ],
+            [
+              "0.079937554542607222960745225184880668468224428360338155631519209999398767286236418"
+            ],
+            [
+              "0.00000068946715009596704037022162961730052403910145251379986900814815492747300320815284"
+            ],
+            [
+              "0.00000068946715009596704037022162961730052403910145251379986900814815492747300320815284"
+            ],
+            [
+              "0.080391025607618905104171032687182411057634852278788948076338169041475140139237175"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "b18ae14698a7879b2be9a6a7d2bf0496a490de8f6239e0236e93e87e458cbc61",
+      "point_ids": [
+        "point:sm_gg_ttbar:generic-1",
+        "point:sm_gg_ttbar:generic-2",
+        "point:sm_gg_ttbar:generic-3",
+        "point:sm_gg_ttbar:stress-near-threshold"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_gg_ttbar",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:12",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:13",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:14",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:15",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:16",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:17",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:18",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:19",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:20",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:21",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:22",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:23",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:24",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:25",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:26",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:27",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:28",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:29",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:30",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:31",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,-1,+1,+1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "ab2550441908d0db0dc42aa7a6551308ef03cc1f437c9c1ecc476108575aebab"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 48,
+        "interactions": 48,
+        "reduction_groups": 32,
+        "roots": 32
+      }
+    },
+    {
+      "artifact_execution_sha256": "609f5deecd89a6a54f1393b83e82d4f94e7dcd9ec9c03d0e04c22138490f3d5d",
+      "artifact_physics_sha256": "57852007da9362bdcee13971dd4a1833c3bcd50a423d9bea6326f658a638ff1d",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:singlet",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:singlet",
+            "word": []
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+0,+0,+0,+0",
+            "index": 0,
+            "representative_id": "h:+0,+0,+0,+0",
+            "structural_zero": false,
+            "values": [
+              0,
+              0,
+              0,
+              0
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 1,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 1,
+        "structural_zero_helicity_count": 0
+      },
+      "id": "case:scalars_2to2:lc",
+      "model_id": "model:scalars-json",
+      "normalization": {
+        "average_factor": "1",
+        "color_factor": "1",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "1",
+        "identical_factor": "2",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 12,
+          "evidence_refs": [
+            "evidence:analytic:case:scalars_2to2:lc:point:scalars_2to2:generic-1"
+          ],
+          "point_id": "point:scalars_2to2:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.49999999999999994448884876874217451956237210524766681978235406794185483048131857",
+          "values": [
+            [
+              "0.49999999999999994448884876874217451956237210524766681978235406794185483048131857"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 12,
+          "evidence_refs": [
+            "evidence:analytic:case:scalars_2to2:lc:point:scalars_2to2:generic-2"
+          ],
+          "point_id": "point:scalars_2to2:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.49999999999999994448884876874217451956237210524766681978235406794185483048131857",
+          "values": [
+            [
+              "0.49999999999999994448884876874217451956237210524766681978235406794185483048131857"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 12,
+          "evidence_refs": [
+            "evidence:analytic:case:scalars_2to2:lc:point:scalars_2to2:generic-3"
+          ],
+          "point_id": "point:scalars_2to2:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.49999999999999994448884876874217451956237210524766681978235406794185483048131857",
+          "values": [
+            [
+              "0.49999999999999994448884876874217451956237210524766681978235406794185483048131857"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 12,
+          "evidence_refs": [
+            "evidence:analytic:case:scalars_2to2:lc:point:scalars_2to2:stress-near-collinear"
+          ],
+          "point_id": "point:scalars_2to2:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "0.49999999999999994448884876874217451956237210524766681978235406794185483048131857",
+          "values": [
+            [
+              "0.49999999999999994448884876874217451956237210524766681978235406794185483048131857"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "6c7aab7fe96336599c451077935929599de9073a62146baea8c6a89c52661eca",
+      "point_ids": [
+        "point:scalars_2to2:generic-1",
+        "point:scalars_2to2:generic-2",
+        "point:scalars_2to2:generic-3",
+        "point:scalars_2to2:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "scalars_2to2",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:singlet"
+            ],
+            "physical_helicity_ids": [
+              "h:+0,+0,+0,+0"
+            ],
+            "representative_color_id": "flow:singlet",
+            "representative_helicity_id": "h:+0,+0,+0,+0"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "d74d667a1741a9a7ae7e99d09062f317d055c0020392c222b97eccbb482f6dcf"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 154,
+        "interactions": 426,
+        "reduction_groups": 1,
+        "roots": 1
+      }
+    },
+    {
+      "artifact_execution_sha256": "b779952302d7758f5d56564114bf8126fc87c84b0ff21e7eb19bb89208341dc6",
+      "artifact_physics_sha256": "bb832605608de8c6379063650b437ac44b721cf25987ad894a2e1f13b42c9382",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:singlet",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:singlet",
+            "word": []
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+0,+0,-2,-2",
+            "index": 0,
+            "representative_id": "h:+0,+0,-2,-2",
+            "structural_zero": false,
+            "values": [
+              0,
+              0,
+              -2,
+              -2
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+0,+0,-2,+2",
+            "index": 1,
+            "representative_id": "h:+0,+0,-2,+2",
+            "structural_zero": false,
+            "values": [
+              0,
+              0,
+              -2,
+              2
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+0,+0,+2,-2",
+            "index": 2,
+            "representative_id": "h:+0,+0,+2,-2",
+            "structural_zero": false,
+            "values": [
+              0,
+              0,
+              2,
+              -2
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+0,+0,+2,+2",
+            "index": 3,
+            "representative_id": "h:+0,+0,+2,+2",
+            "structural_zero": false,
+            "values": [
+              0,
+              0,
+              2,
+              2
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 1,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 4,
+        "structural_zero_helicity_count": 0
+      },
+      "id": "case:scalar_gravity_2to2:lc",
+      "model_id": "model:scalar-gravity-json",
+      "normalization": {
+        "average_factor": "1",
+        "color_factor": "1",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "1",
+        "identical_factor": "2",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 12,
+          "evidence_refs": [
+            "evidence:analytic:case:scalar_gravity_2to2:lc:point:scalar_gravity_2to2:generic-1"
+          ],
+          "point_id": "point:scalar_gravity_2to2:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "2743669908.184639720452755159156760009444980925860179505934517773920884352729040804705351941938349258604047819482",
+          "values": [
+            [
+              "0.000000000000000000000023098971466642087576646056672955837435407008072702352675970969174629302023909741"
+            ],
+            [
+              "1371834954.0923198602263775795783569057510238208425131069105859311230067693564477"
+            ],
+            [
+              "1371834954.0923198602263775795783569057510238208425131069105859311230067693564477"
+            ],
+            [
+              "0.000000000000000000000023098971466642087576646056672955837435407008072702352675970969174629302023909741"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 12,
+          "evidence_refs": [
+            "evidence:analytic:case:scalar_gravity_2to2:lc:point:scalar_gravity_2to2:generic-2"
+          ],
+          "point_id": "point:scalar_gravity_2to2:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "2373424789.80856700578385723223391660045551355021931046450856499955439347937524492124835163609658829017176162788",
+          "values": [
+            [
+              "0.00000000000000000000025016772400796584901205572668775896764244793494786062417581804829414508588081394"
+            ],
+            [
+              "1186712394.9042835028919286161167081325037488092606431765275947408095542917526746"
+            ],
+            [
+              "1186712394.9042835028919286161167081325037488092606431765275947408095542917526746"
+            ],
+            [
+              "0.00000000000000000000025016772400796584901205572668775896764244793494786062417581804829414508588081394"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 12,
+          "evidence_refs": [
+            "evidence:analytic:case:scalar_gravity_2to2:lc:point:scalar_gravity_2to2:generic-3"
+          ],
+          "point_id": "point:scalar_gravity_2to2:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "2887822815.354558701739211193535286646121404166108318435089572942323216507398896628825155533098575123536156522536",
+          "values": [
+            [
+              "0.000000000000000000000008339746942829966486353652410015262900801363674614412577766549287561768078261268"
+            ],
+            [
+              "1443911407.6772793508696055967676349833137592530876728638923764558987074523357737"
+            ],
+            [
+              "1443911407.6772793508696055967676349833137592530876728638923764558987074523357737"
+            ],
+            [
+              "0.000000000000000000000008339746942829966486353652410015262900801363674614412577766549287561768078261268"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 12,
+          "evidence_refs": [
+            "evidence:analytic:case:scalar_gravity_2to2:lc:point:scalar_gravity_2to2:stress-near-collinear"
+          ],
+          "point_id": "point:scalar_gravity_2to2:stress-near-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "0.062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000625",
+          "values": [
+            [
+              "0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003125"
+            ],
+            [
+              "0.03125"
+            ],
+            [
+              "0.03125"
+            ],
+            [
+              "0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003125"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "f34ef0ce85a69fc7f40ac6c3bea4eba7dacbd383e3b4507505ec0028e700143e",
+      "point_ids": [
+        "point:scalar_gravity_2to2:generic-1",
+        "point:scalar_gravity_2to2:generic-2",
+        "point:scalar_gravity_2to2:generic-3",
+        "point:scalar_gravity_2to2:stress-near-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "scalar_gravity_2to2",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:singlet"
+            ],
+            "physical_helicity_ids": [
+              "h:+0,+0,-2,-2"
+            ],
+            "representative_color_id": "flow:singlet",
+            "representative_helicity_id": "h:+0,+0,-2,-2"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "flow:singlet"
+            ],
+            "physical_helicity_ids": [
+              "h:+0,+0,-2,+2"
+            ],
+            "representative_color_id": "flow:singlet",
+            "representative_helicity_id": "h:+0,+0,-2,+2"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "flow:singlet"
+            ],
+            "physical_helicity_ids": [
+              "h:+0,+0,+2,-2"
+            ],
+            "representative_color_id": "flow:singlet",
+            "representative_helicity_id": "h:+0,+0,+2,-2"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "flow:singlet"
+            ],
+            "physical_helicity_ids": [
+              "h:+0,+0,+2,+2"
+            ],
+            "representative_color_id": "flow:singlet",
+            "representative_helicity_id": "h:+0,+0,+2,+2"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "892f217cb1b819e3bfda5aa1c63a2b85c4effccdc67663a82094e728071b4aa9"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 22,
+        "interactions": 28,
+        "reduction_groups": 4,
+        "roots": 4
+      }
+    },
+    {
+      "artifact_execution_sha256": "48066508801b2398916ec23a3b548a0b7375853e5e94959d2dc39c3389249818",
+      "artifact_physics_sha256": "95fba39fded4bad53a1c3b881533d3dc90695f8a879d9fff207f04aab0cefed5",
+      "axes": {
+        "colors": [
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:2,4,5,1",
+            "index": 0,
+            "kind": "lc-flow",
+            "representative_id": "flow:2,4,5,1",
+            "word": [
+              2,
+              4,
+              5,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "flow:2,5,4,1",
+            "index": 1,
+            "kind": "lc-flow",
+            "representative_id": "flow:2,5,4,1",
+            "word": [
+              2,
+              5,
+              4,
+              1
+            ]
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,-1,+0,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,-1,+0,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,-1,+0,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,-1,+0,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1,-1",
+            "index": 8,
+            "representative_id": "h:-1,-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,-1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,-1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:-1,-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1,-1",
+            "index": 12,
+            "representative_id": "h:-1,+1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1,+1",
+            "index": 13,
+            "representative_id": "h:-1,+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1,-1",
+            "index": 14,
+            "representative_id": "h:-1,+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1,+1",
+            "index": 15,
+            "representative_id": "h:-1,+1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,-1,-1",
+            "index": 16,
+            "representative_id": "h:-1,+1,+0,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,-1,+1",
+            "index": 17,
+            "representative_id": "h:-1,+1,+0,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,+1,-1",
+            "index": 18,
+            "representative_id": "h:-1,+1,+0,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,+1,+1",
+            "index": 19,
+            "representative_id": "h:-1,+1,+0,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1,-1",
+            "index": 20,
+            "representative_id": "h:-1,+1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1,+1",
+            "index": 21,
+            "representative_id": "h:-1,+1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1,-1",
+            "index": 22,
+            "representative_id": "h:-1,+1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1,+1",
+            "index": 23,
+            "representative_id": "h:-1,+1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1,-1",
+            "index": 24,
+            "representative_id": "h:+1,-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1,+1",
+            "index": 25,
+            "representative_id": "h:+1,-1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1,-1",
+            "index": 26,
+            "representative_id": "h:+1,-1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1,+1",
+            "index": 27,
+            "representative_id": "h:+1,-1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,-1,-1",
+            "index": 28,
+            "representative_id": "h:+1,-1,+0,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,-1,+1",
+            "index": 29,
+            "representative_id": "h:+1,-1,+0,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,+1,-1",
+            "index": 30,
+            "representative_id": "h:+1,-1,+0,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,+1,+1",
+            "index": 31,
+            "representative_id": "h:+1,-1,+0,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1,-1",
+            "index": 32,
+            "representative_id": "h:+1,-1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1,+1",
+            "index": 33,
+            "representative_id": "h:+1,-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1,-1",
+            "index": 34,
+            "representative_id": "h:+1,-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1,+1",
+            "index": 35,
+            "representative_id": "h:+1,-1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1,-1",
+            "index": 36,
+            "representative_id": "h:+1,+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1,+1",
+            "index": 37,
+            "representative_id": "h:+1,+1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1,-1",
+            "index": 38,
+            "representative_id": "h:+1,+1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1,+1",
+            "index": 39,
+            "representative_id": "h:+1,+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,-1,-1",
+            "index": 40,
+            "representative_id": "h:+1,+1,+0,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,-1,+1",
+            "index": 41,
+            "representative_id": "h:+1,+1,+0,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,+1,-1",
+            "index": 42,
+            "representative_id": "h:+1,+1,+0,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,+1,+1",
+            "index": 43,
+            "representative_id": "h:+1,+1,+0,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1,-1",
+            "index": 44,
+            "representative_id": "h:+1,+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1,+1",
+            "index": 45,
+            "representative_id": "h:+1,+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1,-1",
+            "index": 46,
+            "representative_id": "h:+1,+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1,+1",
+            "index": 47,
+            "representative_id": "h:+1,+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "lc",
+      "coverage": {
+        "color": "complete",
+        "color_component_count": 2,
+        "color_kind": "physical-lc-flows",
+        "helicities": "complete",
+        "helicity_count": 48,
+        "structural_zero_helicity_count": 24
+      },
+      "id": "case:sm_ddbar_zgg:lc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "27",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.41704678810708823",
+        "identical_factor": "2",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:lc:point:sm_ddbar_zgg:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_zgg:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.0189816965392188905577571620949728766153309291309335911819060376212400058367735348020015402015",
+          "values": [
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.0000000000018645463440274346437861597839868069981972841237633319878841807342780192619633278",
+              "0.0000000016335350315800027254709255992850661544554072074279262461215788749749822223163896"
+            ],
+            [
+              "0.00000029982599137755640094297586152196337660690271708595451423543091153399822493603456",
+              "0.00025629998485208803842677790831714855553361716613711720373740837806274367816507894"
+            ],
+            [
+              "0.00000000000024651104415267076530118711060943362769774022721777433307848584070630584718918469",
+              "0.00000000026558064643246025763283518970173179315902963622177991325297240097932914687718404"
+            ],
+            [
+              "0.000000019003365611229936321521956711724769774764811736355242009473919500039006670579797",
+              "0.000016648909555575313658944063253409912244077703166978334124668796855534789159920746"
+            ],
+            [
+              "0.000000011896719018651412639837701319121447217510919321971996657519826415963431503495121",
+              "0.000010422753684882687020112379194031002256961840374167092610447740419669458266023775"
+            ],
+            [
+              "0.000000012051472684094480924929976122027362653139518569840270630861296372152273686850846",
+              "0.0001600286994480367134876950796080456833850498487941755534049178834692753618245531"
+            ],
+            [
+              "0.00000000078870087102701832431011526427385845772001661628875266052282736014744207680254287",
+              "0.00000080703462678813611810677132736388443325617764066632269018223314442394556870216384"
+            ],
+            [
+              "0.000000011896719018651461470439027981714393377332581056545670987198569715025593585036532",
+              "0.000010422753684882685722636184685272642843904126586913579610044349176303436500827747"
+            ],
+            [
+              "0.000018976723729902194559444033962620179006744173930633977279952986403114179729079862",
+              "0.016625568517903838602188895513542985172968153298384532571558425000815865447244878"
+            ],
+            [
+              "0.00000015205657194753118559997738649390265909622406399119445038108659263026984501393773",
+              "0.00016522735723834702661324031344464507267398680421077964861295761853372984262462151"
+            ],
+            [
+              "0.0000012508346658831780275503018824804595269583168573963487505232825048120656196667518",
+              "0.0011565009560938899394346905849927895764750390195788387797921027499377499763453608"
+            ],
+            [
+              "0.0000000018619323322010022623749824348536265850736794752855083542620606357784010209267302",
+              "0.0000016312448874370313728350577934315368425798652840493957748374051887650122066745316"
+            ],
+            [
+              "0.000000000056329971353653847362274393583767598706130027021542561093835122403128527307435403",
+              "0.000000049350868552511196073268593893233548234066080788306114051477705754420400505821016"
+            ],
+            [
+              "0.000000037842127599807019422224987364377752441426570468690077791016763324796308153121509",
+              "0.000034988202632602116649163750631652189321319136295808039658765606996512830455528918"
+            ],
+            [
+              "0.000000004600243625295496246984311132789967401932124350678228204159853555069068930115335",
+              "0.0000049987059889946996533314986889230316641054472125183376265104018181955039012360769"
+            ],
+            [
+              "0.00000057411232707258017214653901789665629758306019022767606091181121466811788589146302",
+              "0.00050298165091997125834525858767301964983551519334188629430772649536403455507929482"
+            ],
+            [
+              "0.000000000359917398679535645051988598542429614272130200646969469425688765712938209117238",
+              "0.00000031532478723413175592748887503821179890988603443465714776298202861416772923950189"
+            ],
+            [
+              "0.000000000023860962454546211964985141231019693047021393182054410035482012259414554710201311",
+              "0.000000024415622749642888732669725146762076536147149511697797779637486452543775217317755"
+            ],
+            [
+              "0.0000000003645992388251296991864471144891664592165829396097101131279879912704357652043184",
+              "0.0000048414283912318094200817432261859680983335427941869914446526484435022828920241831"
+            ],
+            [
+              "0.00000000035991739867953416775535093767632609746360418305289035521541713753716325419013821",
+              "0.00000031532478723413179518068599973166937683847432776159691271786453998185909787370784"
+            ],
+            [
+              "0.00000000057491833725138463415339262711913193848509718481070062498838067480313194063122897",
+              "0.00000050368779902248823417808878741749144157106084563791099356176177531323195219596742"
+            ],
+            [
+              "0.0000000000000074578220783483359446325344121372967036106212415085719907916749792279832985241745",
+              "0.0000000000080347443067068214934768195590212049157571249002161096605990540858951397340922656"
+            ],
+            [
+              "0.0000000090707858783534830538594678042472115435586126050692563811258540331081796524040775",
+              "0.0000077539718039019843073892897307458130765332427123974214324326616834034294777231581"
+            ],
+            [
+              "0.000000000000056409054362608843345504079229035773488566494140051020046517625981616003689526937",
+              "0.000000000049420153430236488196190946568281998530539807230341934354254499450732257450573207"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:lc:point:sm_ddbar_zgg:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_zgg:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.00111039565126121327652278194778670170935873620089214847834593841793223894744186572425402986",
+          "values": [
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.000000000012127601078528733705176136598787308670419781502641452722480777530321341757938533",
+              "0.00000000060255318743308777263602501675317499356325976200902676932232352710080244427920377"
+            ],
+            [
+              "0.000000035549662597664941704427313453720596781397194931370420179077744486721046764960859",
+              "0.0000018293227057299232599689683510325916885160241693578036915547879884773880751111985"
+            ],
+            [
+              "0.000000010129997053926453889119702546229831539091137446125532422906202499413412508456786",
+              "0.00000053120809360978752548199067764355975715003534724142909784431449750614760931621102"
+            ],
+            [
+              "0.00000012655446095264943612790213410788323907944575756344809509558707764596690789366621",
+              "0.0000062877887668936267099609146745198336803763716541873284327300569230603426728101686"
+            ],
+            [
+              "0.000000026385635587299425840350297446171072782202986902113729652888452494547637808807577",
+              "0.0000013109557877635465245077485248107737849504500031999228331043081156534428101786938"
+            ],
+            [
+              "0.00000000011261635177672049190132816696134510234124307975072575954195932212788907815589557",
+              "0.0000019017469649378002304419979724327241453882010481151086927328784218435651205875005"
+            ],
+            [
+              "0.0000000024177525455088852798062535075591046553413670186659432089883472288782593151332528",
+              "0.00000031859795063054355983247566259888339692139968958423898353535862404218637064580851"
+            ],
+            [
+              "0.000000026385635587299837385535519109535179516054928382134461038125469305063964180344122",
+              "0.0000013109557877635548136068924732810652450540614857458271605864683703083779017570038"
+            ],
+            [
+              "0.000014351596841744827607896579859737756881193314808655860199490976635725448499571507",
+              "0.00071305119336941011301702250910731399707580983586865820738865195208415492559376332"
+            ],
+            [
+              "0.000006347750975573054880701308503361333653776941403982450065286695472496970832377315",
+              "0.00032948352800253775795192366125123446323275519777207492027205219496395751340499738"
+            ],
+            [
+              "0.000000011058296690097488748760350466890447026714613427938290883815858117130212964818734",
+              "0.0000007552075347742335791252539339546819048895594904268841833602215782827828827719152"
+            ],
+            [
+              "0.0000000013753007205456622810817213423408743789541373946307277537441010909928496149012499",
+              "0.000000068331059661209120635101663790613060273710946531979781844539058355463689717209619"
+            ],
+            [
+              "0.000000000041607661487578388256417670976592307281451143885003963916596292237711926428862571",
+              "0.0000000020672537700286301538693766940471826468596699198164236455822693605422949025199416"
+            ],
+            [
+              "0.0000000003345521880685355387194071282097509887873333651575571678400813668934152386726763",
+              "0.000000022847671778494947780819550126380485683203544657069717101015354723147355126050005"
+            ],
+            [
+              "0.00000019204168939451964486416285710180389865382544979340115867131121097488229113151127",
+              "0.0000099680301871895098137126163145621628755438465396349942734317442220772312955597433"
+            ],
+            [
+              "0.00000043418604693277477803795943740235025079923938193896486474857691241273861115365341",
+              "0.000021572294868904764140181698609413570385087160165368912018027955409438837085110813"
+            ],
+            [
+              "0.00000000079825784808386780586611625061295506653823238245939234951856404285345754080988688",
+              "0.000000039661002010386596820567282096400553809410359775534463811223974869318810741533519"
+            ],
+            [
+              "0.000000000073145478637102678044265386199554825397771369652460132332029819967975309678406438",
+              "0.0000000096387033631541988065506443222771724418532808711609595573401034334030181000566492"
+            ],
+            [
+              "0.0000000000034070388917070737780256685765221881246016332835069191247839727502238462548782661",
+              "0.000000057534503378117325318968577210238900363198980198742324960513696760585166032333535"
+            ],
+            [
+              "0.00000000079825784808385535518351444709659726557261528104565123315133361697469655140507556",
+              "0.000000039661002010386346046299468475467491321889915318495417084518262419797520352141394"
+            ],
+            [
+              "0.0000000038287154891997797112720123723169272864908528018336636704736332085365500527305664",
+              "0.00000019022762266459652355848748285350803321119797242008553693611278076904449873708903"
+            ],
+            [
+              "0.00000000030646787425713722421444543196468008658576608334177890468002953256395133899705911",
+              "0.000000016070904499787221332151690787888509826200079879831876107369622304327668011669469"
+            ],
+            [
+              "0.0000000010755017468284381774843532743473996707186690150571174654063752523125622223423128",
+              "0.000000055343415992215001824693340823698610847305120470869665086678858622510217188936437"
+            ],
+            [
+              "0.00000000000036690238926916967176976861453222122579658436131996734929157508553990911434660276",
+              "0.000000000018229343354833859984350420078336375406608788871818003209785032376758260725845729"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:lc:point:sm_ddbar_zgg:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_zgg:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.000025697984894269886096292235900077970852958814449567157855069277210716365324314684052846",
+          "values": [
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.00000000021640304784080547497902132833212169695809699555953755644751665848915624817045096",
+              "0.00000000037339027530997180801687838911974101723172763896134110764714655275263607493200682"
+            ],
+            [
+              "0.000000026929466415996824788739441076966318186375808048490620733049477737357065110441666",
+              "0.000000053281635655747976688886003894547393912315381175944380699632618382105495514547222"
+            ],
+            [
+              "0.0000022323336292020266887464475356022293026340412612341829269635828562734476688554589",
+              "0.0000038582856519628578193197349444192222644986338519183764247781664761832935744546103"
+            ],
+            [
+              "0.0000012091989260373431555136368222092500207591102133332877026362013796008616162594473",
+              "0.0000020863990798769154858925391603129418661437381257469834160989544831891210167935326"
+            ],
+            [
+              "0.000000039272017725979169241804921184949386569509271825617888703649510931299928510139777",
+              "0.000000067761474050352682374555400415469902817881885373977885134070406595425286762434069"
+            ],
+            [
+              "0.000000027925990251256216529197112441696533670035811762998877214741303307102979708911361",
+              "0.00000014416211144411275682169966653701737259638460416711363702107835665855216553996683"
+            ],
+            [
+              "0.000000076092635626412212773768235790778461026277940842193420258613115538207724589082248",
+              "0.000000064436477367232332236623358537289146970762293387647453441690384125131818138157443"
+            ],
+            [
+              "0.000000039272017725979056513690575237686196056327200846321398690073605261477244588601679",
+              "0.000000067761474050351672176730093342493610136940726228078338318890287211279899734745465"
+            ],
+            [
+              "0.000001781734813416527935682523230703255886409736041650081662565316470353113428738872",
+              "0.0000030742748734314619644402417536577296392714668480854839014594768136549907965316728"
+            ],
+            [
+              "0.0000036766211864965681711362325825480723925594069102037191226866493739251114052094462",
+              "0.0000063727496382134217144408599524615133693173239059743624666831862591497094307520343"
+            ],
+            [
+              "0.00000001921911578305437240752840754315447614846247199250772909703203714720122715021739",
+              "0.000000024189845637357794351659690305855709467189515795698090806164522046479217169183348"
+            ],
+            [
+              "0.00000000031886634677303520936381017975948617449768046767825620529213418367705256929435604",
+              "0.00000000055018445533288914747262009804032658204000414987528227040664807347004001410552425"
+            ],
+            [
+              "0.0000000000096468232860732631344880785241251653131917941973883732040806596011917918639803504",
+              "0.000000000016645005874886760692785452546504544852258726935616049008712030280147521928761717"
+            ],
+            [
+              "0.00000000058144553525328516647925214838578902579824318687017307642786781057165721966353632",
+              "0.000000000731827515015499533748732319150180162479745991649711008340087113410909124223948"
+            ],
+            [
+              "0.00000011123066210938480542392500512889232984040511289854869309183318352145706019165799",
+              "0.00000019279798645540526193358194026797149160510740846499426128371109021264388559411932"
+            ],
+            [
+              "0.000000053903715652715800460750571900015306821680590449040678605529437628699434869170036",
+              "0.000000093007577428413937817370678130332726897290484635603295567518905624516224591994265"
+            ],
+            [
+              "0.0000000011881160207844612230267906596818607988885318127153138842676341147021640657608682",
+              "0.0000000020500218112790197857616655107042188751443211376468846988576043702101078094425105"
+            ],
+            [
+              "0.0000000023020686149173648514030471184477658473781295856957484771647630113357324579900993",
+              "0.0000000019494290213736522154714044903111149952056284663511511141890142584894607104149372"
+            ],
+            [
+              "0.00000000084485896918506312302628271945497104922552049428751288831152404204492611813352574",
+              "0.0000000043614085579198546734792601663464089404077595686938254237155086535760289693132108"
+            ],
+            [
+              "0.0000000011881160207844646334468913473810158626397171426853761665744021516113797004416014",
+              "0.000000002050021811279050347782409736009961059921539785294519079014419220003803128118238"
+            ],
+            [
+              "0.000000036582500709912680049288430776758672892609917058315353446991614060717840035273955",
+              "0.000000063120876290293108076237942617637711671180567031317122249285912690102568026319295"
+            ],
+            [
+              "0.000000067535907299113071593157226273516571718415664742901893850361793722327645486961522",
+              "0.00000011672664816576111677831006950658941977213532012182570876732832846485965945813742"
+            ],
+            [
+              "0.00000000081471063451006542871222282086951176082024469544585100505153402264983320490589702",
+              "0.0000000016119560084206637800961376883478701744090113214940959687592652849050515978123313"
+            ],
+            [
+              "0.0000000000065469497870022506023005233588596810536887532227464224085626527407853033605744306",
+              "0.000000000011296363003203405819146479365539173804272856283173441408782655249952319670993498"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:lc:point:sm_ddbar_zgg:stress-soft-collinear"
+          ],
+          "point_id": "point:sm_ddbar_zgg:stress-soft-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "17.482042166265736342612438414137064308934195921850282731389467288330310985808107800889182",
+          "values": [
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0.00028615569186657420692504066942459037093193340374172151049830830622304215731883341",
+              "0.0000029145375047671957741607245213037864168417344722139590662725558067893375843052026"
+            ],
+            [
+              "0.00028498892503814537280514178262229421967354896495378369966365133101674883320777937",
+              "0.000002902935003677895041418792903922575367254668933549668365743805281247727922451626"
+            ],
+            [
+              "4.138253437592820569244005439339681400570740360370264740987807906580845440116694",
+              "0.042145945010985833635337209064098536532507571792454230567365865956426487653084672"
+            ],
+            [
+              "4.1220532144990614507283891480662871652319478528974551904836960338069192256046177",
+              "0.041983713872465634189250193160925171430851632990860931587369566757088045622712884"
+            ],
+            [
+              "0.068826263720451051321824770387701825029643162085097073435241202113524430552217304",
+              "0.00070100554567960367684573071568100945235169376616485795582569955351705685851615527"
+            ],
+            [
+              "0.068551209266109958156183912239096993205799780310475403509926704946704947897506453",
+              "0.00069821435804444096557408946873782969858772238531320506792162481589199766171336676"
+            ],
+            [
+              "0.069096804200140114281139190889282938257252640102439168608944660194507194598880462",
+              "0.00069815774241131771982085390761304802580217486520836132728488585601303544959177881"
+            ],
+            [
+              "0.068826263720451051321824770387701825029643162085097073435241202113524430552217304",
+              "0.00070100554567960367684573071568100945235169376616485795582569955351705685851615527"
+            ],
+            [
+              "4.1385290528537019953962664844708486769118817149560811091292511686569148324276277",
+              "0.042151522691831952222315475361322168836240898260840433500718827846852495700613025"
+            ],
+            [
+              "4.122322157893241754654347707597314186797049871259160527013109061129905287455387",
+              "0.041983688067869831933542738271791382178575839838279873244288393721903108244457153"
+            ],
+            [
+              "0.00028845082625556406374381232187611873943618352269058422639631535202208596007271242",
+              "0.0000028910656679113845825222943378856815133099201179344728898954727394916989713152089"
+            ],
+            [
+              "0.00028729945558773882076199238440586152646867159286684775976335378357487594610557358",
+              "0.0000029261869052742480217200365017458896991561089420903798366229098721746981300576458"
+            ],
+            [
+              "0.0000086918143174660759910119010066169459187678488933144547640324598160435881815784574",
+              "0.000000088527397961174234547464524740747494248608979057328765961530168364649207341966451"
+            ],
+            [
+              "0.0000087266473109182954598347615125789393917783950107184676774562569257657354880546455",
+              "0.000000087464857577541537790848752774136051378525855363704887979265334685653469825967685"
+            ],
+            [
+              "0.1247146768165100471276865670444172496510867687044284452907321574141330044352048",
+              "0.0012701535417177248634845959251991358170032109484456016658406178682523570380910413"
+            ],
+            [
+              "0.12520499212661329731261352328822405558407670482955282261038012470582824908627728",
+              "0.0012752311266527056774868912799157120347297806674161820005903028637388115657243257"
+            ],
+            [
+              "0.0020822354264448632823210392384804932094465033942517564097901600950886676509907348",
+              "0.000021207871856549150056206614761973562610896067366690645506403214568802427634781038"
+            ],
+            [
+              "0.0020904202230711047586335490714517550572947030694211160257806654159879710077031914",
+              "0.000021121715838014491404263694653218751295444182317234023914658232599396610183912107"
+            ],
+            [
+              "0.0020739140662827496916526515714956739912328469694489558928555069059861766836675155",
+              "0.000021123428659118055079994343752518110186134800215191948474233185950758381824669294"
+            ],
+            [
+              "0.0020822354264448632823210392384804932094465033942517564097901600950886676509907348",
+              "0.000021207871856549150056206614761973562610896067366690645506403214568802427634781038"
+            ],
+            [
+              "0.12470654033731156704872937778494705766127967320753294870663579636527034926128352",
+              "0.0012701543223970853295028652569071239737528359783825261312353797171042858066261151"
+            ],
+            [
+              "0.12519665380009005149118461335397808292606128264497108339897948285407413949572374",
+              "0.0012750623822806101153388888096762846327632035896836507741575791199625044495629105"
+            ],
+            [
+              "0.0000086219126795711653095045974384026764151131760745012198433991451453287061597934769",
+              "0.000000087823946536979756240055299979664013547689729283910239774237572098548633429272973"
+            ],
+            [
+              "0.0000086572114607809513182605827803738052222759810050664245243892792676765065722549665",
+              "0.000000088174962813290109697744287150854076751461607009812295997767286548827605327985473"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ],
+            [
+              "0",
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "5196d56b489f28409632be42ea1528fdce6b19d5fe76ec4179e4db919d78b984",
+      "point_ids": [
+        "point:sm_ddbar_zgg:generic-1",
+        "point:sm_ddbar_zgg:generic-2",
+        "point:sm_ddbar_zgg:generic-3",
+        "point:sm_ddbar_zgg:stress-soft-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_zgg",
+      "reduction": {
+        "cell_semantics": "sum-all-contributing-groups",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:+1,-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:12",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:13",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:14",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:15",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:16",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:17",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:18",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:19",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:20",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:21",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:22",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:23",
+            "physical_color_ids": [
+              "flow:2,5,4,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,5,4,1",
+            "representative_helicity_id": "h:-1,+1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:24",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:25",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:26",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:27",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:28",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:29",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:30",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:31",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:32",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:33",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:34",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:35",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:+1,-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:36",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:37",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:38",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:39",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:40",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:41",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:42",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:43",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:44",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,-1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:45",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:46",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:47",
+            "physical_color_ids": [
+              "flow:2,4,5,1"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,+1"
+            ],
+            "representative_color_id": "flow:2,4,5,1",
+            "representative_helicity_id": "h:-1,+1,+1,+1,+1"
+          }
+        ],
+        "kind": "lc-diagonal",
+        "plan_sha256": "0a39189d0f168a2c6601f944166e5f3c0dbaeaa69496e7298163a958e359f712"
+      },
+      "selectors": {
+        "color_flow": true,
+        "helicity": true,
+        "omitted_color": "all-components",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 117,
+        "interactions": 242,
+        "reduction_groups": 48,
+        "roots": 48
+      }
+    },
+    {
+      "artifact_execution_sha256": "c7ff52a6c487d9bd6dc908b96327d4a384ef20ca3b66cbb020f9557d03ba60a5",
+      "artifact_physics_sha256": "461100166a41b597fa7968c92d1a888bdc1fd45aa12054af1d410e800062ce1b",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,-1,+0,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,-1,+0,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,-1,+0,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,-1,+0,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1,-1",
+            "index": 8,
+            "representative_id": "h:-1,-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,-1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,-1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:-1,-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1,-1",
+            "index": 12,
+            "representative_id": "h:-1,+1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1,+1",
+            "index": 13,
+            "representative_id": "h:-1,+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1,-1",
+            "index": 14,
+            "representative_id": "h:-1,+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1,+1",
+            "index": 15,
+            "representative_id": "h:-1,+1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,-1,-1",
+            "index": 16,
+            "representative_id": "h:-1,+1,+0,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,-1,+1",
+            "index": 17,
+            "representative_id": "h:-1,+1,+0,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,+1,-1",
+            "index": 18,
+            "representative_id": "h:-1,+1,+0,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,+1,+1",
+            "index": 19,
+            "representative_id": "h:-1,+1,+0,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1,-1",
+            "index": 20,
+            "representative_id": "h:-1,+1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1,+1",
+            "index": 21,
+            "representative_id": "h:-1,+1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1,-1",
+            "index": 22,
+            "representative_id": "h:-1,+1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1,+1",
+            "index": 23,
+            "representative_id": "h:-1,+1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1,-1",
+            "index": 24,
+            "representative_id": "h:+1,-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1,+1",
+            "index": 25,
+            "representative_id": "h:+1,-1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1,-1",
+            "index": 26,
+            "representative_id": "h:+1,-1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1,+1",
+            "index": 27,
+            "representative_id": "h:+1,-1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,-1,-1",
+            "index": 28,
+            "representative_id": "h:+1,-1,+0,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,-1,+1",
+            "index": 29,
+            "representative_id": "h:+1,-1,+0,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,+1,-1",
+            "index": 30,
+            "representative_id": "h:+1,-1,+0,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,+1,+1",
+            "index": 31,
+            "representative_id": "h:+1,-1,+0,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1,-1",
+            "index": 32,
+            "representative_id": "h:+1,-1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1,+1",
+            "index": 33,
+            "representative_id": "h:+1,-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1,-1",
+            "index": 34,
+            "representative_id": "h:+1,-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1,+1",
+            "index": 35,
+            "representative_id": "h:+1,-1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1,-1",
+            "index": 36,
+            "representative_id": "h:+1,+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1,+1",
+            "index": 37,
+            "representative_id": "h:+1,+1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1,-1",
+            "index": 38,
+            "representative_id": "h:+1,+1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1,+1",
+            "index": 39,
+            "representative_id": "h:+1,+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,-1,-1",
+            "index": 40,
+            "representative_id": "h:+1,+1,+0,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,-1,+1",
+            "index": 41,
+            "representative_id": "h:+1,+1,+0,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,+1,-1",
+            "index": 42,
+            "representative_id": "h:+1,+1,+0,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,+1,+1",
+            "index": 43,
+            "representative_id": "h:+1,+1,+0,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1,-1",
+            "index": 44,
+            "representative_id": "h:+1,+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1,+1",
+            "index": 45,
+            "representative_id": "h:+1,+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1,-1",
+            "index": 46,
+            "representative_id": "h:+1,+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1,+1",
+            "index": 47,
+            "representative_id": "h:+1,+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "nlc",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 48,
+        "structural_zero_helicity_count": 24
+      },
+      "id": "case:sm_ddbar_zgg:nlc",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "27",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.41704678810708823",
+        "identical_factor": "2",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:nlc:point:sm_ddbar_zgg:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_zgg:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.0149814039838905688575901155768813055959304775170997611466876457639852054711103332381183419",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000000012907091164814750270893192259920027852048334684094313805447669353376494675178861"
+            ],
+            [
+              "0.00020251615137313575956342938405925817343520912972622515200814318331447209567275359"
+            ],
+            [
+              "0.00000000020844541839092562454721819375141018996199804690305186134073794534823280519337795"
+            ],
+            [
+              "0.000013154844510479757498279786821649563997656863219653034836260936361076047015671459"
+            ],
+            [
+              "0.0000082353564140629854612713978360323458799310909117182489884929794881555586337858032"
+            ],
+            [
+              "0.00012633085090795942688410839570703238650843577879200642651086424645016257995815282"
+            ],
+            [
+              "0.00000063575638130534943392631472632933168857529792077670066684455022708336883319702847"
+            ],
+            [
+              "0.000008235356414062983948072728019694906300760742152855229617936573333860757609423032"
+            ],
+            [
+              "0.013136401998058355186365427042083217963125714407398974913718211973109712951985596"
+            ],
+            [
+              "0.0001309476444219890290624498092777554258847986707877921569666678874380401629374238"
+            ],
+            [
+              "0.00091372514598753389559404630197505687694364367340477971027835931223796833286547175"
+            ],
+            [
+              "0.000001288899599167032694157799845294747033285965218277735047032036311709975257828246"
+            ],
+            [
+              "0.000000038993725090422378983358321403293623531081189185980278039528785912780089326729103"
+            ],
+            [
+              "0.000027643384460566196985832037391146470851705538632202866243751494253140498991333888"
+            ],
+            [
+              "0.0000039616246689263659562117237064724999098144731958523949002827045046595311514650197"
+            ],
+            [
+              "0.00039742214872330041264633879858551783557260239335798538655159632450737744555304412"
+            ],
+            [
+              "0.0000002491483620905391602352499028213659924860674480808690578141367972331179435586432"
+            ],
+            [
+              "0.000000019233856208135773099437912190498785967869470046977565559744448510981605593010476"
+            ],
+            [
+              "0.0000038219505025276337228430047644660563448453052440616732661374058289629610870252821"
+            ],
+            [
+              "0.00000024914836209053920601480711281969375770689538753299707301207291975157071727468614"
+            ],
+            [
+              "0.00000039798009928810904187664337760264622170509854336468170611725028601621817879354714"
+            ],
+            [
+              "0.0000000000063062036378525436523145449349253009153825498710999699599611138740763295621757329"
+            ],
+            [
+              "0.0000061268225532212619674373965037460070047537818133210511266761063474647356003739201"
+            ],
+            [
+              "0.000000000039048469323992878870099832828729071311071001776696633471567939239464638590049559"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:nlc:point:sm_ddbar_zgg:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_zgg:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.000906919339629119596415968211193739984560325956621265461775004411077393646190161896833304",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000050218400585290822569969553123138554971385699155944890490082872718315396594314326"
+            ],
+            [
+              "0.0000015227442800382345760231780412850861924452466042552642294677561986797542641117234"
+            ],
+            [
+              "0.00000044188962667335858420932731567214636064754714331027067048156598001992599346512604"
+            ],
+            [
+              "0.0000052404119947770424052943751782499640557488607729555739111551528397169900870198598"
+            ],
+            [
+              "0.0000010925857546280857099708372078120451858691293864105160123010760072142380468022252"
+            ],
+            [
+              "0.0000015000033799806375195986123370439834545273843585864309169378328418877394086875305"
+            ],
+            [
+              "0.00000025897375164813349217703575401817993473428117107543301478467233612634944990670925"
+            ],
+            [
+              "0.0000010925857546280929935274529320030041216098737951559469122326695236571088344211906"
+            ],
+            [
+              "0.0005942760110354636314164372670984653351144968891564030840030744806253663561879277"
+            ],
+            [
+              "0.00027418169524926974154431800836559883585257006722588026085056316318872108552894237"
+            ],
+            [
+              "0.00000062320727626135386934770012874420531461552403115869720221775233724815064555761949"
+            ],
+            [
+              "0.000000056948939911881099689062869943446166297394436215997582853248182900878089703436334"
+            ],
+            [
+              "0.0000000017229048007695850254784394046376930239192586296393077523374753553050121112434002"
+            ],
+            [
+              "0.000000018854201848298408305583252066252789965033116149158371502119712358942169611914796"
+            ],
+            [
+              "0.0000082949561442065923383390809149865662033380435421185175774141678495917417003425092"
+            ],
+            [
+              "0.000017978929791836032451366086408346876439370841699750145920330162413001584880262863"
+            ],
+            [
+              "0.00000003305454403214408098903411711184714629521359975907662279225473410400691312410211"
+            ],
+            [
+              "0.000000007834862609879637851781362689208580517590795044579984047235101652804033061045248"
+            ],
+            [
+              "0.000000045380353498030187654848300925516937106457542046996291008958911926819727345569181"
+            ],
+            [
+              "0.000000033054544032143860635948013568009271204416638855100767604360029296734019838512306"
+            ],
+            [
+              "0.00000015854080862229087316824940560501609300880637541910795667556652559876590830556175"
+            ],
+            [
+              "0.000000013368708186383188877956961414240147248091410855367953969530796422547984487195841"
+            ],
+            [
+              "0.000000046068345336748878211349865197970662746248648161296901974206801713496384236714566"
+            ],
+            [
+              "0.000000000015192824236806724257228056379457389382056077439364959239836105137766923231677844"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:nlc:point:sm_ddbar_zgg:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_zgg:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.000018743756960353460554040308778827972147990420986918056228045552601265521986569714043552",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000043035086848324205715605948051221703032118398677195281171143167476459605002108386"
+            ],
+            [
+              "0.000000059115768283466967051294476913952549469107552467951799140161992335426653556081893"
+            ],
+            [
+              "0.0000044424871167925434385957753759471445158033817406714376129904082676405568625385328"
+            ],
+            [
+              "0.0000024046787380369725570748254905313314283141386693405302703695238677356986877612658"
+            ],
+            [
+              "0.000000078098469980412050924656531391044269326837485173189642080466854100607062135242638"
+            ],
+            [
+              "0.00000012497720003225801819550588478003830775915243319993090725267133768637316167042823"
+            ],
+            [
+              "0.000000099227663766918296629402669862067025269856180141017994951108923943285940897836763"
+            ],
+            [
+              "0.000000078098469980411170097897815689912614712087092885326431262566954403157917080074687"
+            ],
+            [
+              "0.0000035432547369883141550208237457659459532129639651742593570606987273669594141663031"
+            ],
+            [
+              "0.0000073304858579872645877438759350008924473877459767747057108167490277128029751039632"
+            ],
+            [
+              "0.000000031856106925766296043654122291630768794401491182869408448086203217580423815911404"
+            ],
+            [
+              "0.00000000063411495648066696664141439869579089197634342769297281256384396220278591955121196"
+            ],
+            [
+              "0.000000000019184197360843379591487871061260862045755854906902837718448816252477420117878854"
+            ],
+            [
+              "0.00000000096375875725092231472489430282764072024650988684922879563113703839463061723419211"
+            ],
+            [
+              "0.00000022177285997320036479225558905313533617653516319487102749780852226835022245670336"
+            ],
+            [
+              "0.000000107195860118778700713075532953209204888531674418523927797150599217978423701364"
+            ],
+            [
+              "0.0000000023627521262066132049804926202022141015806165844268300707217399053835465734130953"
+            ],
+            [
+              "0.0000000030019842079186247500206390754386002709723434286908295521875277632819044527450569"
+            ],
+            [
+              "0.0000000037809978246389739026539496960930628906024408932990000241278408716576066034084859"
+            ],
+            [
+              "0.0000000023627521262066398530735666228975356668185228441591978301514458412649190877778005"
+            ],
+            [
+              "0.000000072749950191927943742592502039990632197559589023875605023870037223963020732881693"
+            ],
+            [
+              "0.00000013440078766562037617465444604237301704950154606773618575164947719900648288584079"
+            ],
+            [
+              "0.0000000017884589447031787364827119635211854293059873809895113128204203856468549762191061"
+            ],
+            [
+              "0.000000000013019620355926074693444534054569764750722914043921554997972954925416366795774068"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:nlc:point:sm_ddbar_zgg:stress-soft-collinear"
+          ],
+          "point_id": "point:sm_ddbar_zgg:stress-soft-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "13.812900229678465057418735344642091681470625294269926762328165918151128010457435803107",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00022840002683447161884100485378518003323529565599493011578031117184760405411058484"
+            ],
+            [
+              "0.00022746435938180378164873496196898537729322435616142360449948708885566643098840883"
+            ],
+            [
+              "3.3030145433338438125319234013205813616967031587877662526117696798869334196065562"
+            ],
+            [
+              "3.2900868008723309682255350171544003963758552403035320504768380073947166114011642"
+            ],
+            [
+              "0.054934851647113721252436964948199940540776821044005053290521453261083882334549822"
+            ],
+            [
+              "0.054714763401671186091434572108229929214061405807538083829640708612355431375181405"
+            ],
+            [
+              "0.055145804941582662401765871561820206187079917676817922757960114160114223116422416"
+            ],
+            [
+              "0.054934851647113721252436964948199940540776821044005053290521453261083882334549822"
+            ],
+            [
+              "3.3032372711557420319244872802170297129020838404367056351748987682264914585875939"
+            ],
+            [
+              "3.29029872607187829067944275965084810711589430283144041571300066649685058174777"
+            ],
+            [
+              "0.00023019245852740474619954660233631000560950438345580268085172152962928853421215808"
+            ],
+            [
+              "0.00022931294127940986332798521417858598349139241310561147070473036805183621173320647"
+            ],
+            [
+              "0.0000069375192588345940842205712572594026183900962407074811617512917884274596859744113"
+            ],
+            [
+              "0.0000069641277346249204187256826487924776005637727965267969585838617683016617063936336"
+            ],
+            [
+              "0.099543055233107296495692471572901242505829951243700715415702188744053807430560794"
+            ],
+            [
+              "0.099934491517513213231082331436736427018390894201149875291635748612048536246229867"
+            ],
+            [
+              "0.0016619715797840711987753806388999358419181531685061858647396949920533577594555904"
+            ],
+            [
+              "0.001668353655452926143981307511489382878521858239603327058914953427187325667936639"
+            ],
+            [
+              "0.001655313139868374208204636712446242369321463410355569152574480498040346157098723"
+            ],
+            [
+              "0.0016619715797840711987753806388999358419181531685061858647396949920533577594555904"
+            ],
+            [
+              "0.099536643753907348144774184533817649127878325179892426247232265902017231492063762"
+            ],
+            [
+              "0.099927753221169029009862227757185939097670217665482910651729087912741701264287591"
+            ],
+            [
+              "0.0000068815931848650098967352842061052579069296645814192478795346126468681058935783723"
+            ],
+            [
+              "0.0000069099004009188937076387600241136781894697185826782379108318467148637182291766698"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "08711d5d0eeedb60300c79db2d378b14e8e5ef94bf4f7b746347a4fafe05502f",
+      "point_ids": [
+        "point:sm_ddbar_zgg:generic-1",
+        "point:sm_ddbar_zgg:generic-2",
+        "point:sm_ddbar_zgg:generic-3",
+        "point:sm_ddbar_zgg:stress-soft-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_zgg",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:12",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:13",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:14",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:15",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:16",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:17",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:18",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:19",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:20",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:21",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:22",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:23",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:24",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:25",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:26",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:27",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:28",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:29",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:30",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:31",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:32",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:33",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:34",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:35",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:36",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:37",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:38",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:39",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:40",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:41",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:42",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:43",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:44",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:45",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:46",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:47",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1,+1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "9ff2345b0798a05c249c17cf596f08bf8b0cc272a7ade6329a391711d447031e"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 138,
+        "interactions": 252,
+        "reduction_groups": 48,
+        "roots": 48
+      }
+    },
+    {
+      "artifact_execution_sha256": "7c2b76a178301589fb1b391483262e6bb63cee54f3c6a850cf0aa7daa13b4c07",
+      "artifact_physics_sha256": "e13ea389752e1b21e566dfab8a9b4a4dbee74dc5dc0add287906d25476e8b4bb",
+      "axes": {
+        "colors": [
+          {
+            "description": "coherent sparse contraction of the full color basis",
+            "id": "color:contracted",
+            "index": 0,
+            "kind": "contracted-color"
+          }
+        ],
+        "helicities": [
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1,-1",
+            "index": 0,
+            "representative_id": "h:-1,-1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,-1,+1",
+            "index": 1,
+            "representative_id": "h:-1,-1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1,-1",
+            "index": 2,
+            "representative_id": "h:-1,-1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,-1,+1,+1",
+            "index": 3,
+            "representative_id": "h:-1,-1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,-1,-1",
+            "index": 4,
+            "representative_id": "h:-1,-1,+0,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,-1,+1",
+            "index": 5,
+            "representative_id": "h:-1,-1,+0,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,+1,-1",
+            "index": 6,
+            "representative_id": "h:-1,-1,+0,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+0,+1,+1",
+            "index": 7,
+            "representative_id": "h:-1,-1,+0,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1,-1",
+            "index": 8,
+            "representative_id": "h:-1,-1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,-1,+1",
+            "index": 9,
+            "representative_id": "h:-1,-1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1,-1",
+            "index": 10,
+            "representative_id": "h:-1,-1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:-1,-1,+1,+1,+1",
+            "index": 11,
+            "representative_id": "h:-1,-1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              -1,
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1,-1",
+            "index": 12,
+            "representative_id": "h:-1,+1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,-1,+1",
+            "index": 13,
+            "representative_id": "h:-1,+1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1,-1",
+            "index": 14,
+            "representative_id": "h:-1,+1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,-1,+1,+1",
+            "index": 15,
+            "representative_id": "h:-1,+1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,-1,-1",
+            "index": 16,
+            "representative_id": "h:-1,+1,+0,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,-1,+1",
+            "index": 17,
+            "representative_id": "h:-1,+1,+0,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,+1,-1",
+            "index": 18,
+            "representative_id": "h:-1,+1,+0,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+0,+1,+1",
+            "index": 19,
+            "representative_id": "h:-1,+1,+0,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1,-1",
+            "index": 20,
+            "representative_id": "h:-1,+1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,-1,+1",
+            "index": 21,
+            "representative_id": "h:-1,+1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1,-1",
+            "index": 22,
+            "representative_id": "h:-1,+1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:-1,+1,+1,+1,+1",
+            "index": 23,
+            "representative_id": "h:-1,+1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              -1,
+              1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1,-1",
+            "index": 24,
+            "representative_id": "h:+1,-1,-1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,-1,+1",
+            "index": 25,
+            "representative_id": "h:+1,-1,-1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1,-1",
+            "index": 26,
+            "representative_id": "h:+1,-1,-1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,-1,+1,+1",
+            "index": 27,
+            "representative_id": "h:+1,-1,-1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,-1,-1",
+            "index": 28,
+            "representative_id": "h:+1,-1,+0,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,-1,+1",
+            "index": 29,
+            "representative_id": "h:+1,-1,+0,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,+1,-1",
+            "index": 30,
+            "representative_id": "h:+1,-1,+0,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+0,+1,+1",
+            "index": 31,
+            "representative_id": "h:+1,-1,+0,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1,-1",
+            "index": 32,
+            "representative_id": "h:+1,-1,+1,-1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,-1,+1",
+            "index": 33,
+            "representative_id": "h:+1,-1,+1,-1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1,-1",
+            "index": 34,
+            "representative_id": "h:+1,-1,+1,+1,-1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "1",
+            "computed": true,
+            "id": "h:+1,-1,+1,+1,+1",
+            "index": 35,
+            "representative_id": "h:+1,-1,+1,+1,+1",
+            "structural_zero": false,
+            "values": [
+              1,
+              -1,
+              1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1,-1",
+            "index": 36,
+            "representative_id": "h:+1,+1,-1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,-1,+1",
+            "index": 37,
+            "representative_id": "h:+1,+1,-1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1,-1",
+            "index": 38,
+            "representative_id": "h:+1,+1,-1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,-1,+1,+1",
+            "index": 39,
+            "representative_id": "h:+1,+1,-1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              -1,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,-1,-1",
+            "index": 40,
+            "representative_id": "h:+1,+1,+0,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,-1,+1",
+            "index": 41,
+            "representative_id": "h:+1,+1,+0,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,+1,-1",
+            "index": 42,
+            "representative_id": "h:+1,+1,+0,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+0,+1,+1",
+            "index": 43,
+            "representative_id": "h:+1,+1,+0,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              0,
+              1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1,-1",
+            "index": 44,
+            "representative_id": "h:+1,+1,+1,-1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,-1,+1",
+            "index": 45,
+            "representative_id": "h:+1,+1,+1,-1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              -1,
+              1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1,-1",
+            "index": 46,
+            "representative_id": "h:+1,+1,+1,+1,-1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1,
+              -1
+            ]
+          },
+          {
+            "coefficient": "0",
+            "computed": false,
+            "id": "h:+1,+1,+1,+1,+1",
+            "index": 47,
+            "representative_id": "h:+1,+1,+1,+1,+1",
+            "structural_zero": true,
+            "values": [
+              1,
+              1,
+              1,
+              1,
+              1
+            ]
+          }
+        ]
+      },
+      "case_kind": "substantive",
+      "color_accuracy": "full",
+      "coverage": {
+        "color": "contracted",
+        "color_component_count": 1,
+        "color_kind": "contracted-color",
+        "helicities": "complete",
+        "helicity_count": 48,
+        "structural_zero_helicity_count": 24
+      },
+      "id": "case:sm_ddbar_zgg:full",
+      "model_id": "model:builtin-sm",
+      "normalization": {
+        "average_factor": "36",
+        "color_factor": "27",
+        "couplings_in_stage_evaluators": true,
+        "global_coupling_factor": "0.41704678810708823",
+        "identical_factor": "2",
+        "quark_line_partner_factor": "1"
+      },
+      "observations": [
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:full:point:sm_ddbar_zgg:generic-1"
+          ],
+          "point_id": "point:sm_ddbar_zgg:generic-1",
+          "round_trip_decimal_digits": 80,
+          "total": "0.0149814039838905688575901155768813055959304775170997611466876457639852054711103332381183419",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.0000000012907091164814750270893192259920027852048334684094313805447669353376494675178861"
+            ],
+            [
+              "0.00020251615137313575956342938405925817343520912972622515200814318331447209567275359"
+            ],
+            [
+              "0.00000000020844541839092562454721819375141018996199804690305186134073794534823280519337795"
+            ],
+            [
+              "0.000013154844510479757498279786821649563997656863219653034836260936361076047015671459"
+            ],
+            [
+              "0.0000082353564140629854612713978360323458799310909117182489884929794881555586337858032"
+            ],
+            [
+              "0.00012633085090795942688410839570703238650843577879200642651086424645016257995815282"
+            ],
+            [
+              "0.00000063575638130534943392631472632933168857529792077670066684455022708336883319702847"
+            ],
+            [
+              "0.000008235356414062983948072728019694906300760742152855229617936573333860757609423032"
+            ],
+            [
+              "0.013136401998058355186365427042083217963125714407398974913718211973109712951985596"
+            ],
+            [
+              "0.0001309476444219890290624498092777554258847986707877921569666678874380401629374238"
+            ],
+            [
+              "0.00091372514598753389559404630197505687694364367340477971027835931223796833286547175"
+            ],
+            [
+              "0.000001288899599167032694157799845294747033285965218277735047032036311709975257828246"
+            ],
+            [
+              "0.000000038993725090422378983358321403293623531081189185980278039528785912780089326729103"
+            ],
+            [
+              "0.000027643384460566196985832037391146470851705538632202866243751494253140498991333888"
+            ],
+            [
+              "0.0000039616246689263659562117237064724999098144731958523949002827045046595311514650197"
+            ],
+            [
+              "0.00039742214872330041264633879858551783557260239335798538655159632450737744555304412"
+            ],
+            [
+              "0.0000002491483620905391602352499028213659924860674480808690578141367972331179435586432"
+            ],
+            [
+              "0.000000019233856208135773099437912190498785967869470046977565559744448510981605593010476"
+            ],
+            [
+              "0.0000038219505025276337228430047644660563448453052440616732661374058289629610870252821"
+            ],
+            [
+              "0.00000024914836209053920601480711281969375770689538753299707301207291975157071727468614"
+            ],
+            [
+              "0.00000039798009928810904187664337760264622170509854336468170611725028601621817879354714"
+            ],
+            [
+              "0.0000000000063062036378525436523145449349253009153825498710999699599611138740763295621757329"
+            ],
+            [
+              "0.0000061268225532212619674373965037460070047537818133210511266761063474647356003739201"
+            ],
+            [
+              "0.000000000039048469323992878870099832828729071311071001776696633471567939239464638590049559"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:full:point:sm_ddbar_zgg:generic-2"
+          ],
+          "point_id": "point:sm_ddbar_zgg:generic-2",
+          "round_trip_decimal_digits": 80,
+          "total": "0.000906919339629119596415968211193739984560325956621265461775004411077393646190161896833304",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000050218400585290822569969553123138554971385699155944890490082872718315396594314326"
+            ],
+            [
+              "0.0000015227442800382345760231780412850861924452466042552642294677561986797542641117234"
+            ],
+            [
+              "0.00000044188962667335858420932731567214636064754714331027067048156598001992599346512604"
+            ],
+            [
+              "0.0000052404119947770424052943751782499640557488607729555739111551528397169900870198598"
+            ],
+            [
+              "0.0000010925857546280857099708372078120451858691293864105160123010760072142380468022252"
+            ],
+            [
+              "0.0000015000033799806375195986123370439834545273843585864309169378328418877394086875305"
+            ],
+            [
+              "0.00000025897375164813349217703575401817993473428117107543301478467233612634944990670925"
+            ],
+            [
+              "0.0000010925857546280929935274529320030041216098737951559469122326695236571088344211906"
+            ],
+            [
+              "0.0005942760110354636314164372670984653351144968891564030840030744806253663561879277"
+            ],
+            [
+              "0.00027418169524926974154431800836559883585257006722588026085056316318872108552894237"
+            ],
+            [
+              "0.00000062320727626135386934770012874420531461552403115869720221775233724815064555761949"
+            ],
+            [
+              "0.000000056948939911881099689062869943446166297394436215997582853248182900878089703436334"
+            ],
+            [
+              "0.0000000017229048007695850254784394046376930239192586296393077523374753553050121112434002"
+            ],
+            [
+              "0.000000018854201848298408305583252066252789965033116149158371502119712358942169611914796"
+            ],
+            [
+              "0.0000082949561442065923383390809149865662033380435421185175774141678495917417003425092"
+            ],
+            [
+              "0.000017978929791836032451366086408346876439370841699750145920330162413001584880262863"
+            ],
+            [
+              "0.00000003305454403214408098903411711184714629521359975907662279225473410400691312410211"
+            ],
+            [
+              "0.000000007834862609879637851781362689208580517590795044579984047235101652804033061045248"
+            ],
+            [
+              "0.000000045380353498030187654848300925516937106457542046996291008958911926819727345569181"
+            ],
+            [
+              "0.000000033054544032143860635948013568009271204416638855100767604360029296734019838512306"
+            ],
+            [
+              "0.00000015854080862229087316824940560501609300880637541910795667556652559876590830556175"
+            ],
+            [
+              "0.000000013368708186383188877956961414240147248091410855367953969530796422547984487195841"
+            ],
+            [
+              "0.000000046068345336748878211349865197970662746248648161296901974206801713496384236714566"
+            ],
+            [
+              "0.000000000015192824236806724257228056379457389382056077439364959239836105137766923231677844"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:full:point:sm_ddbar_zgg:generic-3"
+          ],
+          "point_id": "point:sm_ddbar_zgg:generic-3",
+          "round_trip_decimal_digits": 80,
+          "total": "0.000018743756960353460554040308778827972147990420986918056228045552601265521986569714043552",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00000000043035086848324205715605948051221703032118398677195281171143167476459605002108386"
+            ],
+            [
+              "0.000000059115768283466967051294476913952549469107552467951799140161992335426653556081893"
+            ],
+            [
+              "0.0000044424871167925434385957753759471445158033817406714376129904082676405568625385328"
+            ],
+            [
+              "0.0000024046787380369725570748254905313314283141386693405302703695238677356986877612658"
+            ],
+            [
+              "0.000000078098469980412050924656531391044269326837485173189642080466854100607062135242638"
+            ],
+            [
+              "0.00000012497720003225801819550588478003830775915243319993090725267133768637316167042823"
+            ],
+            [
+              "0.000000099227663766918296629402669862067025269856180141017994951108923943285940897836763"
+            ],
+            [
+              "0.000000078098469980411170097897815689912614712087092885326431262566954403157917080074687"
+            ],
+            [
+              "0.0000035432547369883141550208237457659459532129639651742593570606987273669594141663031"
+            ],
+            [
+              "0.0000073304858579872645877438759350008924473877459767747057108167490277128029751039632"
+            ],
+            [
+              "0.000000031856106925766296043654122291630768794401491182869408448086203217580423815911404"
+            ],
+            [
+              "0.00000000063411495648066696664141439869579089197634342769297281256384396220278591955121196"
+            ],
+            [
+              "0.000000000019184197360843379591487871061260862045755854906902837718448816252477420117878854"
+            ],
+            [
+              "0.00000000096375875725092231472489430282764072024650988684922879563113703839463061723419211"
+            ],
+            [
+              "0.00000022177285997320036479225558905313533617653516319487102749780852226835022245670336"
+            ],
+            [
+              "0.000000107195860118778700713075532953209204888531674418523927797150599217978423701364"
+            ],
+            [
+              "0.0000000023627521262066132049804926202022141015806165844268300707217399053835465734130953"
+            ],
+            [
+              "0.0000000030019842079186247500206390754386002709723434286908295521875277632819044527450569"
+            ],
+            [
+              "0.0000000037809978246389739026539496960930628906024408932990000241278408716576066034084859"
+            ],
+            [
+              "0.0000000023627521262066398530735666228975356668185228441591978301514458412649190877778005"
+            ],
+            [
+              "0.000000072749950191927943742592502039990632197559589023875605023870037223963020732881693"
+            ],
+            [
+              "0.00000013440078766562037617465444604237301704950154606773618575164947719900648288584079"
+            ],
+            [
+              "0.0000000017884589447031787364827119635211854293059873809895113128204203856468549762191061"
+            ],
+            [
+              "0.000000000013019620355926074693444534054569764750722914043921554997972954925416366795774068"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        },
+        {
+          "arithmetic_precision_bits": 266,
+          "certified_decimal_digits": 10,
+          "evidence_refs": [
+            "evidence:fortran:case:sm_ddbar_zgg:full:point:sm_ddbar_zgg:stress-soft-collinear"
+          ],
+          "point_id": "point:sm_ddbar_zgg:stress-soft-collinear",
+          "round_trip_decimal_digits": 80,
+          "total": "13.812900229678465057418735344642091681470625294269926762328165918151128010457435803107",
+          "values": [
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0.00022840002683447161884100485378518003323529565599493011578031117184760405411058484"
+            ],
+            [
+              "0.00022746435938180378164873496196898537729322435616142360449948708885566643098840883"
+            ],
+            [
+              "3.3030145433338438125319234013205813616967031587877662526117696798869334196065562"
+            ],
+            [
+              "3.2900868008723309682255350171544003963758552403035320504768380073947166114011642"
+            ],
+            [
+              "0.054934851647113721252436964948199940540776821044005053290521453261083882334549822"
+            ],
+            [
+              "0.054714763401671186091434572108229929214061405807538083829640708612355431375181405"
+            ],
+            [
+              "0.055145804941582662401765871561820206187079917676817922757960114160114223116422416"
+            ],
+            [
+              "0.054934851647113721252436964948199940540776821044005053290521453261083882334549822"
+            ],
+            [
+              "3.3032372711557420319244872802170297129020838404367056351748987682264914585875939"
+            ],
+            [
+              "3.29029872607187829067944275965084810711589430283144041571300066649685058174777"
+            ],
+            [
+              "0.00023019245852740474619954660233631000560950438345580268085172152962928853421215808"
+            ],
+            [
+              "0.00022931294127940986332798521417858598349139241310561147070473036805183621173320647"
+            ],
+            [
+              "0.0000069375192588345940842205712572594026183900962407074811617512917884274596859744113"
+            ],
+            [
+              "0.0000069641277346249204187256826487924776005637727965267969585838617683016617063936336"
+            ],
+            [
+              "0.099543055233107296495692471572901242505829951243700715415702188744053807430560794"
+            ],
+            [
+              "0.099934491517513213231082331436736427018390894201149875291635748612048536246229867"
+            ],
+            [
+              "0.0016619715797840711987753806388999358419181531685061858647396949920533577594555904"
+            ],
+            [
+              "0.001668353655452926143981307511489382878521858239603327058914953427187325667936639"
+            ],
+            [
+              "0.001655313139868374208204636712446242369321463410355569152574480498040346157098723"
+            ],
+            [
+              "0.0016619715797840711987753806388999358419181531685061858647396949920533577594555904"
+            ],
+            [
+              "0.099536643753907348144774184533817649127878325179892426247232265902017231492063762"
+            ],
+            [
+              "0.099927753221169029009862227757185939097670217665482910651729087912741701264287591"
+            ],
+            [
+              "0.0000068815931848650098967352842061052579069296645814192478795346126468681058935783723"
+            ],
+            [
+              "0.0000069099004009188937076387600241136781894697185826782379108318467148637182291766698"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ],
+            [
+              "0"
+            ]
+          ]
+        }
+      ],
+      "physics_case_sha256": "43f7a3c976a8c77fb1ad054ccdd724e2ab2cdac143ad62aff01e457060fb2209",
+      "point_ids": [
+        "point:sm_ddbar_zgg:generic-1",
+        "point:sm_ddbar_zgg:generic-2",
+        "point:sm_ddbar_zgg:generic-3",
+        "point:sm_ddbar_zgg:stress-soft-collinear"
+      ],
+      "point_policy": "standard",
+      "process_id": "sm_ddbar_zgg",
+      "reduction": {
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+          {
+            "id": "reduction:0",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:1",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:2",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:3",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:4",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:5",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:6",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:7",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:8",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:9",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:10",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:11",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:12",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:13",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:14",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:15",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:16",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:17",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:18",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:19",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:20",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:21",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:22",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:23",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:24",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:25",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:26",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:27",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:28",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:29",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:30",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:31",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:32",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:33",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:34",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+0,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:35",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:+1,-1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:+1,-1,+1,+1,+1"
+          },
+          {
+            "id": "reduction:36",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1,-1"
+          },
+          {
+            "id": "reduction:37",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,-1,-1"
+          },
+          {
+            "id": "reduction:38",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1,-1"
+          },
+          {
+            "id": "reduction:39",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,-1,+1"
+          },
+          {
+            "id": "reduction:40",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,-1,+1"
+          },
+          {
+            "id": "reduction:41",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,-1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,-1,+1"
+          },
+          {
+            "id": "reduction:42",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1,-1"
+          },
+          {
+            "id": "reduction:43",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,+1,-1"
+          },
+          {
+            "id": "reduction:44",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,-1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1,-1"
+          },
+          {
+            "id": "reduction:45",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,-1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,-1,+1,+1"
+          },
+          {
+            "id": "reduction:46",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+0,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+0,+1,+1"
+          },
+          {
+            "id": "reduction:47",
+            "physical_color_ids": [
+              "color:contracted"
+            ],
+            "physical_helicity_ids": [
+              "h:-1,+1,+1,+1,+1"
+            ],
+            "representative_color_id": "color:contracted",
+            "representative_helicity_id": "h:-1,+1,+1,+1,+1"
+          }
+        ],
+        "kind": "contracted-color",
+        "plan_sha256": "9ff2345b0798a05c249c17cf596f08bf8b0cc272a7ade6329a391711d447031e"
+      },
+      "selectors": {
+        "color_flow": false,
+        "helicity": true,
+        "omitted_color": "contracted-component",
+        "omitted_helicity": "all-components"
+      },
+      "topology": {
+        "currents": 138,
+        "interactions": 252,
+        "reduction_groups": 48,
+        "roots": 48
+      }
+    }
+  ],
+  "dependencies": [
+    {
+      "content_sha256": "c9b17f9d74700f741e6fa850f6f205966b4c30d5b2d953f8cc59a095d817e81d",
+      "id": "dependency:pyamplicol-candidate",
+      "license": "0BSD",
+      "name": "Installed pyAmpliCol capture candidate",
+      "revision": "54045e93070c87caab43063eae7c1807fb4ae70d",
+      "serialization_abi": "candidate-e4167e7-bincode2",
+      "version": "0.1.0.dev0+candidate.38e8137f79f7"
+    },
+    {
+      "content_sha256": "cda1f2dfb24972ffd830d3526ed3f0f4d03e16e5462c922fe6181dff2bfd69db",
+      "id": "dependency:release-lock",
+      "license": "0BSD",
+      "name": "pyAmpliCol dependency release lock",
+      "revision": null,
+      "serialization_abi": "candidate-e4167e7-bincode2",
+      "version": "schema-1"
+    },
+    {
+      "content_sha256": "220fc6e9bc020758637018ade8d4add9bbaa017d7a932a3e5464e57bee7ee35e",
+      "id": "dependency:install-state",
+      "license": "0BSD",
+      "name": "pyAmpliCol installed dependency state",
+      "revision": null,
+      "serialization_abi": "candidate-e4167e7-bincode2",
+      "version": "schema-1"
+    },
+    {
+      "content_sha256": "92cf5016728a1d90c5c8d5dde0b232429f9fc008a844db31c1747b534ae84712",
+      "id": "dependency:symbolica",
+      "license": "Symbolica proprietary",
+      "name": "Symbolica",
+      "revision": "e4167e767147ab8f3b4f039057c396c8fa961f6a",
+      "serialization_abi": "candidate-e4167e7-bincode2",
+      "version": "2.1.0"
+    },
+    {
+      "content_sha256": "a48e316a25e3446f2faae618ce48245de0b52d47aa9acbe875a07f647b0571b6",
+      "id": "dependency:symjit",
+      "license": "MIT",
+      "name": "Symjit",
+      "revision": "7fb09d1cb2a943c25a6fd71a208af44fcc6d813d",
+      "serialization_abi": "candidate-e4167e7-bincode2",
+      "version": "2.19.3"
+    },
+    {
+      "content_sha256": "a7a17bc88f891559717680860b89595e7d7b611ee42060c972447e18d883ea8d",
+      "id": "dependency:ufo-model-loader",
+      "license": "MIT",
+      "name": "ufo-model-loader",
+      "revision": "9cb4deeae40ddd64184049af07ac1d03ce5f6162",
+      "serialization_abi": null,
+      "version": "0.1.7"
+    },
+    {
+      "content_sha256": "ed18d0240cc7b1ea821708209afbfa40a8fcec63d62bd72cfa8c6f2f1cbf1990",
+      "id": "dependency:legacy-amplicol",
+      "license": "NOASSERTION",
+      "name": "Pinned legacy Fortran AmpliCol",
+      "revision": "58c169b7df58ec8a38c0b748e08548cec20b4530",
+      "serialization_abi": null,
+      "version": "developer-only"
+    },
+    {
+      "content_sha256": "089eb1fce800160a2144e21312658ddd22f343c75bdd9e1a1f636290123647ef",
+      "id": "dependency:analytic-oracles",
+      "license": "0BSD",
+      "name": "pyAmpliCol independent analytic oracles",
+      "revision": null,
+      "serialization_abi": null,
+      "version": "1"
+    }
+  ],
+  "evidence_sets": [
+    "evidence-set:legacy-fortran-amplicol",
+    "evidence-set:analytic-oracles"
+  ],
+  "fixture_id": "fixture:compact-reference-ladder-v2",
+  "fixture_schema_version": 2,
+  "kind": "pyamplicol-reference-physics",
+  "models": [
+    {
+      "compiled_model_sha256": "552c1c413f90e97120c116c8fbcf6ade45edab2373b9955aa4eecab60fafe807",
+      "compiled_schema_version": 6,
+      "content_sha256": "c5d7d37155a72253457eed0deb490975117920b5a4ff3e7d5a33276e9a266c36",
+      "dependency_ids": [
+        "dependency:pyamplicol-candidate",
+        "dependency:release-lock",
+        "dependency:install-state",
+        "dependency:symbolica",
+        "dependency:symjit",
+        "dependency:ufo-model-loader"
+      ],
+      "id": "model:builtin-sm",
+      "name": "built-in-sm",
+      "parameter_defaults": {
+        "alpha_ew": {
+          "imag": "0",
+          "real": "0.0075467711139788835"
+        },
+        "alpha_s": {
+          "imag": "0",
+          "real": "0.118"
+        },
+        "mass_23": {
+          "imag": "0",
+          "real": "91.188"
+        },
+        "mass_24": {
+          "imag": "0",
+          "real": "80.41900244575616"
+        },
+        "mass_25": {
+          "imag": "0",
+          "real": "125"
+        },
+        "mass_6": {
+          "imag": "0",
+          "real": "173"
+        },
+        "width_23": {
+          "imag": "0",
+          "real": "2.441404"
+        },
+        "width_24": {
+          "imag": "0",
+          "real": "2.0476"
+        },
+        "width_25": {
+          "imag": "0",
+          "real": "0.006382339"
+        },
+        "width_6": {
+          "imag": "0",
+          "real": "1.4915"
+        }
+      },
+      "restriction": null,
+      "source_kind": "built-in-sm"
+    },
+    {
+      "compiled_model_sha256": "4be41969146b351f6ae2dc8fe6fed218bc85be7b454e6be13237f44ae500ee55",
+      "compiled_schema_version": 6,
+      "content_sha256": "1b9f5de8b0be52cd883f421f4cc9b9160537eb4161a408577fbb6aef95d95b93",
+      "dependency_ids": [
+        "dependency:pyamplicol-candidate",
+        "dependency:release-lock",
+        "dependency:install-state",
+        "dependency:symbolica",
+        "dependency:symjit",
+        "dependency:ufo-model-loader"
+      ],
+      "id": "model:scalars-json",
+      "name": "scalars",
+      "parameter_defaults": {
+        "Gf": {
+          "imag": "0",
+          "real": "0.0000116639"
+        },
+        "aEWM1": {
+          "imag": "0",
+          "real": "132.507"
+        },
+        "aS": {
+          "imag": "0",
+          "real": "0.118"
+        },
+        "lam": {
+          "imag": "0",
+          "real": "1"
+        },
+        "mass_scalar_1": {
+          "imag": "0",
+          "real": "1"
+        },
+        "mass_scalar_2": {
+          "imag": "0",
+          "real": "2"
+        }
+      },
+      "restriction": "default",
+      "source_kind": "ufo-json"
+    },
+    {
+      "compiled_model_sha256": "06774faf776f6b6f5c06e61ca552ed6b71b5712854eb5935c60221c740881e66",
+      "compiled_schema_version": 6,
+      "content_sha256": "452336768f0d61af0c0f3def703bd9d0ddae5be96353cad4835718c6f0d1a705",
+      "dependency_ids": [
+        "dependency:pyamplicol-candidate",
+        "dependency:release-lock",
+        "dependency:install-state",
+        "dependency:symbolica",
+        "dependency:symjit",
+        "dependency:ufo-model-loader"
+      ],
+      "id": "model:scalar-gravity-json",
+      "name": "scalar_gravity",
+      "parameter_defaults": {
+        "Gf": {
+          "imag": "0",
+          "real": "0.0000116639"
+        },
+        "aEWM1": {
+          "imag": "0",
+          "real": "132.507"
+        },
+        "aS": {
+          "imag": "0",
+          "real": "0.118"
+        },
+        "dim": {
+          "imag": "0",
+          "real": "4"
+        },
+        "kappa": {
+          "imag": "0",
+          "real": "1"
+        },
+        "mass_scalar_1": {
+          "imag": "0",
+          "real": "1"
+        },
+        "mass_scalar_2": {
+          "imag": "0",
+          "real": "2"
+        }
+      },
+      "restriction": "default",
+      "source_kind": "ufo-json"
+    }
+  ],
+  "points": [
+    {
+      "algorithm": {
+        "name": "exact-two-to-one",
+        "rng": null,
+        "seed": null,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 15,
+      "class": "canonical",
+      "id": "point:sm_ddbar_z:canonical",
+      "masses": [
+        "0",
+        "0",
+        "91.188"
+      ],
+      "momenta": [
+        [
+          "45.594",
+          "0",
+          "0",
+          "45.594"
+        ],
+        [
+          "45.594",
+          "0",
+          "0",
+          "-45.594"
+        ],
+        [
+          "91.188",
+          "0",
+          "0",
+          "0"
+        ]
+      ],
+      "process_id": "sm_ddbar_z",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "91.188",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "exact-two-to-one",
+        "rng": null,
+        "seed": null,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 15,
+      "class": "canonical",
+      "id": "point:sm_udbar_wplus:canonical",
+      "masses": [
+        "0",
+        "0",
+        "80.41900244575616"
+      ],
+      "momenta": [
+        [
+          "40.20950122287808",
+          "0",
+          "0",
+          "40.20950122287808"
+        ],
+        [
+          "40.20950122287808",
+          "0",
+          "0",
+          "-40.20950122287808"
+        ],
+        [
+          "80.41900244575616",
+          "0",
+          "0",
+          "0"
+        ]
+      ],
+      "process_id": "sm_udbar_wplus",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "80.41900244575616",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 104729,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_zg:generic-1",
+      "masses": [
+        "0",
+        "0",
+        "91.188",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "504.15762567199999",
+          "-438.65194577979531",
+          "1.0884904775248876",
+          "-231.17730388450397"
+        ],
+        [
+          "495.84237432800001",
+          "438.65194577979531",
+          "-1.0884904775248876",
+          "231.17730388450397"
+        ]
+      ],
+      "process_id": "sm_ddbar_zg",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 104759,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_zg:generic-2",
+      "masses": [
+        "0",
+        "0",
+        "91.188",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "504.15762567199999",
+          "-263.950482310908",
+          "-203.59525449712802",
+          "-367.06780765046284"
+        ],
+        [
+          "495.84237432800001",
+          "263.950482310908",
+          "203.59525449712802",
+          "367.06780765046284"
+        ]
+      ],
+      "process_id": "sm_ddbar_zg",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 104761,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_zg:generic-3",
+      "masses": [
+        "0",
+        "0",
+        "91.188",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "504.15762567199999",
+          "470.51906297424415",
+          "31.756220874196046",
+          "153.17641461026898"
+        ],
+        [
+          "495.84237432800001",
+          "-470.51906297424415",
+          "-31.756220874196046",
+          "-153.17641461026898"
+        ]
+      ],
+      "process_id": "sm_ddbar_zg",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "decimal-near-collinear-two-body",
+        "rng": null,
+        "seed": null,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 366,
+      "certified_decimal_digits": 80,
+      "class": "stress",
+      "id": "point:sm_ddbar_zg:stress-near-collinear",
+      "masses": [
+        "0",
+        "0",
+        "91.188",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "504.157625672",
+          "0.991684748656",
+          "0",
+          "495.84138264225965726796954425037309186792565363574323271256383401563919218790644372131614048413945648546743355"
+        ],
+        [
+          "495.842374328",
+          "-0.991684748656",
+          "0",
+          "-495.84138264225965726796954425037309186792565363574323271256383401563919218790644372131614048413945648546743355"
+        ]
+      ],
+      "process_id": "sm_ddbar_zg",
+      "round_trip_decimal_digits": 110,
+      "sqrt_s": "1000",
+      "stress_metric": {
+        "kind": "minimum-final-transverse-momentum-squared-fraction",
+        "value": "0.000000983438640716913893806336"
+      }
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 196613,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_ee:generic-1",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "-415.88835107696661",
+          "277.32928727957812",
+          "11.195796330898123"
+        ],
+        [
+          "500",
+          "415.88835107696661",
+          "-277.32928727957812",
+          "-11.195796330898123"
+        ]
+      ],
+      "process_id": "sm_ddbar_ee",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 196643,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_ee:generic-2",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "267.26786716249347",
+          "247.02403933198039",
+          "342.85129600823143"
+        ],
+        [
+          "500",
+          "-267.26786716249347",
+          "-247.02403933198039",
+          "-342.85129600823143"
+        ]
+      ],
+      "process_id": "sm_ddbar_ee",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 196657,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_ee:generic-3",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "269.8651711031668",
+          "-334.82850232368418",
+          "255.07383922530573"
+        ],
+        [
+          "500",
+          "-269.8651711031668",
+          "334.82850232368418",
+          "-255.07383922530573"
+        ]
+      ],
+      "process_id": "sm_ddbar_ee",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "decimal-near-collinear-two-body",
+        "rng": null,
+        "seed": null,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 366,
+      "certified_decimal_digits": 80,
+      "class": "stress",
+      "id": "point:sm_ddbar_ee:stress-near-collinear",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "1",
+          "0",
+          "499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ],
+        [
+          "500",
+          "-1",
+          "0",
+          "-499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ]
+      ],
+      "process_id": "sm_ddbar_ee",
+      "round_trip_decimal_digits": 110,
+      "sqrt_s": "1000",
+      "stress_metric": {
+        "kind": "minimum-final-transverse-momentum-squared-fraction",
+        "value": "0.000001"
+      }
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 221603,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_uubar:generic-1",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "349.55548503752317",
+          "162.29632791789103",
+          "-318.54491806423516"
+        ],
+        [
+          "500",
+          "-349.55548503752317",
+          "-162.29632791789103",
+          "318.54491806423516"
+        ]
+      ],
+      "process_id": "sm_ddbar_uubar",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 221621,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_uubar:generic-2",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "16.076939847710339",
+          "-495.78088600714847",
+          "-62.792078123756589"
+        ],
+        [
+          "500",
+          "-16.076939847710339",
+          "495.78088600714847",
+          "62.792078123756589"
+        ]
+      ],
+      "process_id": "sm_ddbar_uubar",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 221623,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_uubar:generic-3",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "463.87152485452202",
+          "-116.46914999317087",
+          "145.80173362826937"
+        ],
+        [
+          "500",
+          "-463.87152485452202",
+          "116.46914999317087",
+          "-145.80173362826937"
+        ]
+      ],
+      "process_id": "sm_ddbar_uubar",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "decimal-near-collinear-two-body",
+        "rng": null,
+        "seed": null,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 366,
+      "certified_decimal_digits": 80,
+      "class": "stress",
+      "id": "point:sm_ddbar_uubar:stress-near-collinear",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "1",
+          "0",
+          "499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ],
+        [
+          "500",
+          "-1",
+          "0",
+          "-499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ]
+      ],
+      "process_id": "sm_ddbar_uubar",
+      "round_trip_decimal_digits": 110,
+      "sqrt_s": "1000",
+      "stress_metric": {
+        "kind": "minimum-final-transverse-momentum-squared-fraction",
+        "value": "0.000001"
+      }
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 234803,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_ddbar:generic-1",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "-92.37565236398261",
+          "-439.14510003273597",
+          "220.49562346578892"
+        ],
+        [
+          "500",
+          "92.37565236398261",
+          "439.14510003273597",
+          "-220.49562346578892"
+        ]
+      ],
+      "process_id": "sm_ddbar_ddbar",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 234811,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_ddbar:generic-2",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "360.91008772304991",
+          "-319.452093255215",
+          "133.01980564788778"
+        ],
+        [
+          "500",
+          "-360.91008772304991",
+          "319.452093255215",
+          "-133.01980564788778"
+        ]
+      ],
+      "process_id": "sm_ddbar_ddbar",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 234817,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_ddbar:generic-3",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "-134.44541763580887",
+          "350.24726520552468",
+          "330.53181827591698"
+        ],
+        [
+          "500",
+          "134.44541763580887",
+          "-350.24726520552468",
+          "-330.53181827591698"
+        ]
+      ],
+      "process_id": "sm_ddbar_ddbar",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "decimal-near-collinear-two-body",
+        "rng": null,
+        "seed": null,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 366,
+      "certified_decimal_digits": 80,
+      "class": "stress",
+      "id": "point:sm_ddbar_ddbar:stress-near-collinear",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "1",
+          "0",
+          "499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ],
+        [
+          "500",
+          "-1",
+          "0",
+          "-499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ]
+      ],
+      "process_id": "sm_ddbar_ddbar",
+      "round_trip_decimal_digits": 110,
+      "sqrt_s": "1000",
+      "stress_metric": {
+        "kind": "minimum-final-transverse-momentum-squared-fraction",
+        "value": "0.000001"
+      }
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 246613,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_gg_gg:generic-1",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "-454.42735730865138",
+          "-32.064220250936174",
+          "206.07683690598216"
+        ],
+        [
+          "500",
+          "454.42735730865138",
+          "32.064220250936174",
+          "-206.07683690598216"
+        ]
+      ],
+      "process_id": "sm_gg_gg",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 246631,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_gg_gg:generic-2",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "218.70628263162223",
+          "-240.98122992349255",
+          "-379.5992739218791"
+        ],
+        [
+          "500",
+          "-218.70628263162223",
+          "240.98122992349255",
+          "379.5992739218791"
+        ]
+      ],
+      "process_id": "sm_gg_gg",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 246637,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_gg_gg:generic-3",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "476.17302515713095",
+          "-17.490104796112075",
+          "-151.50361826348367"
+        ],
+        [
+          "500",
+          "-476.17302515713095",
+          "17.490104796112075",
+          "151.50361826348367"
+        ]
+      ],
+      "process_id": "sm_gg_gg",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "decimal-near-collinear-two-body",
+        "rng": null,
+        "seed": null,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 366,
+      "certified_decimal_digits": 80,
+      "class": "stress",
+      "id": "point:sm_gg_gg:stress-near-collinear",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "1",
+          "0",
+          "499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ],
+        [
+          "500",
+          "-1",
+          "0",
+          "-499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ]
+      ],
+      "process_id": "sm_gg_gg",
+      "round_trip_decimal_digits": 110,
+      "sqrt_s": "1000",
+      "stress_metric": {
+        "kind": "minimum-final-transverse-momentum-squared-fraction",
+        "value": "0.000001"
+      }
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 271603,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_gg_ttbar:generic-1",
+      "masses": [
+        "0",
+        "0",
+        "173",
+        "173"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "319.12027591281498",
+          "6.6740914282666104",
+          "343.78584322938013"
+        ],
+        [
+          "500",
+          "-319.12027591281498",
+          "-6.6740914282666104",
+          "-343.78584322938013"
+        ]
+      ],
+      "process_id": "sm_gg_ttbar",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 271619,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_gg_ttbar:generic-2",
+      "masses": [
+        "0",
+        "0",
+        "173",
+        "173"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "-413.22510427682994",
+          "-179.07952861163048",
+          "-131.32606606321244"
+        ],
+        [
+          "500",
+          "413.22510427682994",
+          "179.07952861163048",
+          "131.32606606321244"
+        ]
+      ],
+      "process_id": "sm_gg_ttbar",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 271637,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_gg_ttbar:generic-3",
+      "masses": [
+        "0",
+        "0",
+        "173",
+        "173"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "212.31242292963711",
+          "-237.17089689689013",
+          "344.59309443874758"
+        ],
+        [
+          "500",
+          "-212.31242292963711",
+          "237.17089689689013",
+          "-344.59309443874758"
+        ]
+      ],
+      "process_id": "sm_gg_ttbar",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "decimal-near-threshold-two-body",
+        "rng": null,
+        "seed": null,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 366,
+      "certified_decimal_digits": 80,
+      "class": "stress",
+      "id": "point:sm_gg_ttbar:stress-near-threshold",
+      "masses": [
+        "0",
+        "0",
+        "173",
+        "173"
+      ],
+      "momenta": [
+        [
+          "173.000173",
+          "0",
+          "0",
+          "173.000173"
+        ],
+        [
+          "173.000173",
+          "0",
+          "0",
+          "-173.000173"
+        ],
+        [
+          "173.000173",
+          "0.14679540447316462229333569670207443216569225293054735776473484636188416541522083523901030505274939926150688605",
+          "0",
+          "0.19572720596421949639111426226943257622092300390739647701964646181584555388696111365201374007033253234867584807"
+        ],
+        [
+          "173.000173",
+          "-0.14679540447316462229333569670207443216569225293054735776473484636188416541522083523901030505274939926150688605",
+          "0",
+          "-0.19572720596421949639111426226943257622092300390739647701964646181584555388696111365201374007033253234867584807"
+        ]
+      ],
+      "process_id": "sm_gg_ttbar",
+      "round_trip_decimal_digits": 110,
+      "sqrt_s": "346.000346",
+      "stress_metric": {
+        "kind": "relative-excess-energy",
+        "value": "0.000001"
+      }
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 155921,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:scalars_2to2:generic-1",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "-302.64911500207177",
+          "251.44162274862589",
+          "308.51357107589354"
+        ],
+        [
+          "500",
+          "302.64911500207177",
+          "-251.44162274862589",
+          "-308.51357107589354"
+        ]
+      ],
+      "process_id": "scalars_2to2",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 155933,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:scalars_2to2:generic-2",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "50.523455049548076",
+          "-305.56310448943384",
+          "-392.52843166404597"
+        ],
+        [
+          "500",
+          "-50.523455049548076",
+          "305.56310448943384",
+          "392.52843166404597"
+        ]
+      ],
+      "process_id": "scalars_2to2",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 155947,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:scalars_2to2:generic-3",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "316.70473945431388",
+          "344.06379054288607",
+          "176.96953422675949"
+        ],
+        [
+          "500",
+          "-316.70473945431388",
+          "-344.06379054288607",
+          "-176.96953422675949"
+        ]
+      ],
+      "process_id": "scalars_2to2",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "decimal-near-collinear-two-body",
+        "rng": null,
+        "seed": null,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 366,
+      "certified_decimal_digits": 80,
+      "class": "stress",
+      "id": "point:scalars_2to2:stress-near-collinear",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "1",
+          "0",
+          "499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ],
+        [
+          "500",
+          "-1",
+          "0",
+          "-499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ]
+      ],
+      "process_id": "scalars_2to2",
+      "round_trip_decimal_digits": 110,
+      "sqrt_s": "1000",
+      "stress_metric": {
+        "kind": "minimum-final-transverse-momentum-squared-fraction",
+        "value": "0.000001"
+      }
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 181081,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:scalar_gravity_2to2:generic-1",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "424.18535124203169",
+          "-172.00871520913418",
+          "-201.19589877474442"
+        ],
+        [
+          "500",
+          "-424.18535124203169",
+          "172.00871520913418",
+          "201.19589877474442"
+        ]
+      ],
+      "process_id": "scalar_gravity_2to2",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 181087,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:scalar_gravity_2to2:generic-2",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "438.07353294828403",
+          "54.431706216522898",
+          "234.7951641081369"
+        ],
+        [
+          "500",
+          "-438.07353294828403",
+          "-54.431706216522898",
+          "-234.7951641081369"
+        ]
+      ],
+      "process_id": "scalar_gravity_2to2",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-two-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 181123,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:scalar_gravity_2to2:generic-3",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "-333.2335340914189",
+          "-322.34962231528823",
+          "-187.20612369827589"
+        ],
+        [
+          "500",
+          "333.2335340914189",
+          "322.34962231528823",
+          "187.20612369827589"
+        ]
+      ],
+      "process_id": "scalar_gravity_2to2",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "decimal-near-collinear-two-body",
+        "rng": null,
+        "seed": null,
+        "version": "1"
+      },
+      "arithmetic_precision_bits": 366,
+      "certified_decimal_digits": 80,
+      "class": "stress",
+      "id": "point:scalar_gravity_2to2:stress-near-collinear",
+      "masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "500",
+          "1",
+          "0",
+          "499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ],
+        [
+          "500",
+          "-1",
+          "0",
+          "-499.99899999899999799999499998599995799986799957099856999513798320394121379198725709732555030511964220035473236"
+        ]
+      ],
+      "process_id": "scalar_gravity_2to2",
+      "round_trip_decimal_digits": 110,
+      "sqrt_s": "1000",
+      "stress_metric": {
+        "kind": "minimum-final-transverse-momentum-squared-fraction",
+        "value": "0.000001"
+      }
+    },
+    {
+      "algorithm": {
+        "name": "seeded-sequential-three-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 130363,
+        "version": "2"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_zgg:generic-1",
+      "masses": [
+        "0",
+        "0",
+        "91.188",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "462.65016130616368",
+          "14.340107538562991",
+          "155.76435943335707",
+          "-425.74845397102462"
+        ],
+        [
+          "369.77384162614078",
+          "-17.479290785282917",
+          "2.0064955613504103",
+          "369.35503559605093"
+        ],
+        [
+          "167.57599706769557",
+          "3.1391832467199254",
+          "-157.77085499470743",
+          "56.393418374973699"
+        ]
+      ],
+      "process_id": "sm_ddbar_zgg",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-sequential-three-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 130367,
+        "version": "2"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_zgg:generic-2",
+      "masses": [
+        "0",
+        "0",
+        "91.188",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "465.33323302351317",
+          "-253.8161370082984",
+          "-30.614808132621327",
+          "-377.9680787173736"
+        ],
+        [
+          "441.9989576748219",
+          "169.17017190903826",
+          "8.1505251171731743",
+          "408.26229370615368"
+        ],
+        [
+          "92.667809301664988",
+          "84.645965099260138",
+          "22.464283015448164",
+          "-30.294214988780109"
+        ]
+      ],
+      "process_id": "sm_ddbar_zgg",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "seeded-sequential-three-body-binary64",
+        "rng": "python-random-mt19937",
+        "seed": 130369,
+        "version": "2"
+      },
+      "arithmetic_precision_bits": 53,
+      "certified_decimal_digits": 12,
+      "class": "generic",
+      "id": "point:sm_ddbar_zgg:generic-3",
+      "masses": [
+        "0",
+        "0",
+        "91.188",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "399.47320216104026",
+          "-150.692909586963",
+          "356.57195573898196",
+          "-37.572267452048351"
+        ],
+        [
+          "462.70516677703887",
+          "56.924884042471291",
+          "-455.5467232827699",
+          "57.730510523032876"
+        ],
+        [
+          "137.82163106192075",
+          "93.768025544491692",
+          "98.97476754378792",
+          "-20.158243070984529"
+        ]
+      ],
+      "process_id": "sm_ddbar_zgg",
+      "round_trip_decimal_digits": 17,
+      "sqrt_s": "1000",
+      "stress_metric": null
+    },
+    {
+      "algorithm": {
+        "name": "decimal-soft-near-collinear-sequential-three-body",
+        "rng": null,
+        "seed": null,
+        "version": "2"
+      },
+      "arithmetic_precision_bits": 366,
+      "certified_decimal_digits": 80,
+      "class": "stress",
+      "id": "point:sm_ddbar_zgg:stress-soft-collinear",
+      "masses": [
+        "0",
+        "0",
+        "91.188",
+        "0",
+        "0"
+      ],
+      "momenta": [
+        [
+          "500",
+          "0",
+          "0",
+          "500"
+        ],
+        [
+          "500",
+          "0",
+          "0",
+          "-500"
+        ],
+        [
+          "503.66179162958717434869739478957915831663326653306613226452905811623246492985971943887775551102204408817635271",
+          "-0.10083319151743486973947895791583166332665330661322645290581162324649298597194388777555110220440881763527054108",
+          "-495.33796020516426724896249802949650859988931293504757954585622785251389360657807656710274615766474763741882",
+          "-0.49397973670809694949549415569856263907490550326375161893062961555106829967261384420117167856896300443971326782"
+        ],
+        [
+          "495.33820837041282565130260521042084168336673346693386773547094188376753507014028056112224448897795591182364729",
+          "-0.099166808482565130260521042084168336673346693386773547094188376753507014028056112224448897795591182364729458917",
+          "495.33796020516426724896249802949650859988931293504757954585622785251389360657807656710274615766474763741882",
+          "-0.48581616040517428978341947418379391771147348899891643244244741134931585131031216641477209467289308948772457268"
+        ],
+        [
+          "1",
+          "0.2",
+          "0",
+          "0.97979589711327123927891362988235655678637899226266805137307702690038415098292601061594377324185609392743784049"
+        ]
+      ],
+      "process_id": "sm_ddbar_zgg",
+      "round_trip_decimal_digits": 110,
+      "sqrt_s": "1000",
+      "stress_metric": {
+        "kind": "minimum-final-transverse-momentum-squared-fraction",
+        "value": "0.00000004"
+      }
+    }
+  ],
+  "processes": [
+    {
+      "alias_of": null,
+      "expression": "d d~ > z",
+      "external_colors": [
+        3,
+        -3,
+        1
+      ],
+      "external_helicity_domains": [
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          0,
+          1
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3
+      ],
+      "external_leg_ids": [
+        "leg:incoming-d",
+        "leg:incoming-dbar",
+        "leg:outgoing-z"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "91.188"
+      ],
+      "external_pdgs": [
+        1,
+        -1,
+        23
+      ],
+      "external_spins": [
+        2,
+        2,
+        3
+      ],
+      "final_state_permutation": null,
+      "id": "sm_ddbar_z",
+      "initial_state_count": 2
+    },
+    {
+      "alias_of": null,
+      "expression": "u d~ > w+",
+      "external_colors": [
+        3,
+        -3,
+        1
+      ],
+      "external_helicity_domains": [
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          0,
+          1
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3
+      ],
+      "external_leg_ids": [
+        "leg:incoming-u",
+        "leg:incoming-dbar",
+        "leg:outgoing-wplus"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "80.41900244575616"
+      ],
+      "external_pdgs": [
+        2,
+        -1,
+        24
+      ],
+      "external_spins": [
+        2,
+        2,
+        3
+      ],
+      "final_state_permutation": null,
+      "id": "sm_udbar_wplus",
+      "initial_state_count": 2
+    },
+    {
+      "alias_of": null,
+      "expression": "d d~ > z g",
+      "external_colors": [
+        3,
+        -3,
+        1,
+        8
+      ],
+      "external_helicity_domains": [
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          0,
+          1
+        ],
+        [
+          -1,
+          1
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "external_leg_ids": [
+        "leg:incoming-d",
+        "leg:incoming-dbar",
+        "leg:outgoing-z",
+        "leg:outgoing-g"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "91.188",
+        "0"
+      ],
+      "external_pdgs": [
+        1,
+        -1,
+        23,
+        21
+      ],
+      "external_spins": [
+        2,
+        2,
+        3,
+        3
+      ],
+      "final_state_permutation": null,
+      "id": "sm_ddbar_zg",
+      "initial_state_count": 2
+    },
+    {
+      "alias_of": null,
+      "expression": "d d~ > e- e+",
+      "external_colors": [
+        3,
+        -3,
+        1,
+        1
+      ],
+      "external_helicity_domains": [
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "external_leg_ids": [
+        "leg:incoming-d",
+        "leg:incoming-dbar",
+        "leg:outgoing-eminus",
+        "leg:outgoing-eplus"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "external_pdgs": [
+        1,
+        -1,
+        11,
+        -11
+      ],
+      "external_spins": [
+        2,
+        2,
+        2,
+        2
+      ],
+      "final_state_permutation": null,
+      "id": "sm_ddbar_ee",
+      "initial_state_count": 2
+    },
+    {
+      "alias_of": null,
+      "expression": "d d~ > u u~",
+      "external_colors": [
+        3,
+        -3,
+        3,
+        -3
+      ],
+      "external_helicity_domains": [
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "external_leg_ids": [
+        "leg:incoming-d",
+        "leg:incoming-dbar",
+        "leg:outgoing-u",
+        "leg:outgoing-ubar"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "external_pdgs": [
+        1,
+        -1,
+        2,
+        -2
+      ],
+      "external_spins": [
+        2,
+        2,
+        2,
+        2
+      ],
+      "final_state_permutation": null,
+      "id": "sm_ddbar_uubar",
+      "initial_state_count": 2
+    },
+    {
+      "alias_of": null,
+      "expression": "d d~ > d d~",
+      "external_colors": [
+        3,
+        -3,
+        3,
+        -3
+      ],
+      "external_helicity_domains": [
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "external_leg_ids": [
+        "leg:incoming-d",
+        "leg:incoming-dbar",
+        "leg:outgoing-d",
+        "leg:outgoing-dbar"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "external_pdgs": [
+        1,
+        -1,
+        1,
+        -1
+      ],
+      "external_spins": [
+        2,
+        2,
+        2,
+        2
+      ],
+      "final_state_permutation": null,
+      "id": "sm_ddbar_ddbar",
+      "initial_state_count": 2
+    },
+    {
+      "alias_of": null,
+      "expression": "g g > g g",
+      "external_colors": [
+        8,
+        8,
+        8,
+        8
+      ],
+      "external_helicity_domains": [
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "external_leg_ids": [
+        "leg:incoming-g-1",
+        "leg:incoming-g-2",
+        "leg:outgoing-g-1",
+        "leg:outgoing-g-2"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "external_pdgs": [
+        21,
+        21,
+        21,
+        21
+      ],
+      "external_spins": [
+        3,
+        3,
+        3,
+        3
+      ],
+      "final_state_permutation": null,
+      "id": "sm_gg_gg",
+      "initial_state_count": 2
+    },
+    {
+      "alias_of": null,
+      "expression": "g g > t t~",
+      "external_colors": [
+        8,
+        8,
+        3,
+        -3
+      ],
+      "external_helicity_domains": [
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "external_leg_ids": [
+        "leg:incoming-g-1",
+        "leg:incoming-g-2",
+        "leg:outgoing-t",
+        "leg:outgoing-tbar"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "173",
+        "173"
+      ],
+      "external_pdgs": [
+        21,
+        21,
+        6,
+        -6
+      ],
+      "external_spins": [
+        3,
+        3,
+        2,
+        2
+      ],
+      "final_state_permutation": null,
+      "id": "sm_gg_ttbar",
+      "initial_state_count": 2
+    },
+    {
+      "alias_of": null,
+      "expression": "scalar_0 scalar_0 > scalar_0 scalar_0",
+      "external_colors": [
+        1,
+        1,
+        1,
+        1
+      ],
+      "external_helicity_domains": [
+        [
+          0
+        ],
+        [
+          0
+        ],
+        [
+          0
+        ],
+        [
+          0
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "external_leg_ids": [
+        "leg:incoming-scalar_0-1",
+        "leg:incoming-scalar_0-2",
+        "leg:outgoing-scalar_0-1",
+        "leg:outgoing-scalar_0-2"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "external_pdgs": [
+        1000,
+        1000,
+        1000,
+        1000
+      ],
+      "external_spins": [
+        1,
+        1,
+        1,
+        1
+      ],
+      "final_state_permutation": null,
+      "id": "scalars_2to2",
+      "initial_state_count": 2
+    },
+    {
+      "alias_of": null,
+      "expression": "scalar_0 scalar_0 > graviton graviton",
+      "external_colors": [
+        1,
+        1,
+        1,
+        1
+      ],
+      "external_helicity_domains": [
+        [
+          0
+        ],
+        [
+          0
+        ],
+        [
+          -2,
+          2
+        ],
+        [
+          -2,
+          2
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "external_leg_ids": [
+        "leg:incoming-scalar_0-1",
+        "leg:incoming-scalar_0-2",
+        "leg:outgoing-graviton-1",
+        "leg:outgoing-graviton-2"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "external_pdgs": [
+        2000,
+        2000,
+        1337,
+        1337
+      ],
+      "external_spins": [
+        1,
+        1,
+        5,
+        5
+      ],
+      "final_state_permutation": null,
+      "id": "scalar_gravity_2to2",
+      "initial_state_count": 2
+    },
+    {
+      "alias_of": null,
+      "expression": "d d~ > z g g",
+      "external_colors": [
+        3,
+        -3,
+        1,
+        8,
+        8
+      ],
+      "external_helicity_domains": [
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          0,
+          1
+        ],
+        [
+          -1,
+          1
+        ],
+        [
+          -1,
+          1
+        ]
+      ],
+      "external_labels": [
+        1,
+        2,
+        3,
+        4,
+        5
+      ],
+      "external_leg_ids": [
+        "leg:incoming-d",
+        "leg:incoming-dbar",
+        "leg:outgoing-z",
+        "leg:outgoing-g-1",
+        "leg:outgoing-g-2"
+      ],
+      "external_masses": [
+        "0",
+        "0",
+        "91.188",
+        "0",
+        "0"
+      ],
+      "external_pdgs": [
+        1,
+        -1,
+        23,
+        21,
+        21
+      ],
+      "external_spins": [
+        2,
+        2,
+        3,
+        3,
+        3
+      ],
+      "final_state_permutation": null,
+      "id": "sm_ddbar_zgg",
+      "initial_state_count": 2
+    }
+  ],
+  "provenance": {
+    "capture_command": [
+      "python",
+      "tools/developer/capture_reference_fixture_v2.py",
+      "--generate",
+      "--output-directory",
+      ".artifacts/reference-fixture-v2/54045e93070c87caab43063eae7c1807fb4ae70d/bundle",
+      "--artifact-root",
+      ".artifacts/reference-fixture-v2/54045e93070c87caab43063eae7c1807fb4ae70d",
+      "--legacy-repository",
+      "dependencies/checkouts/legacy-amplicol",
+      "--legacy-jobs",
+      "5",
+      "--external-watchdog-gb",
+      "30"
+    ],
+    "captured_at": "2026-07-16T08:30:24Z",
+    "memory_watchdog_gb": 30,
+    "source_repository": "https://github.com/mg5amcnlo/pyamplicol.git",
+    "source_revision": "54045e93070c87caab43063eae7c1807fb4ae70d",
+    "source_tree_sha256": "b1df109c5ff447ffeb26b0fa8d6f09a0b1649e58de638100181498ba45e80e76",
+    "working_tree_clean": true
+  }
+}
diff --git a/pyamplicol/tests/fixtures/reference/reference-fixture-v2.manifest.json b/pyamplicol/tests/fixtures/reference/reference-fixture-v2.manifest.json
new file mode 100644
index 0000000000..4a54a95fc1
--- /dev/null
+++ b/pyamplicol/tests/fixtures/reference/reference-fixture-v2.manifest.json
@@ -0,0 +1,19 @@
+{
+  "bundle_sha256": "6692f512038cfaf9e9aeaf480a7cf07deb5d685473d476a1b63f8cf2953cb5af",
+  "files": [
+    {
+      "path": "analytic-oracles-v2.json",
+      "sha256": "5a2102a5ad80ac50bad35710dd0a83b76299841aaa56e8add146c5ba827d5a1a"
+    },
+    {
+      "path": "legacy-fortran-v2.json",
+      "sha256": "8b7d3f852c152be175354f020dbc01bb3bc6a931d642678f1f5df5070197e7bc"
+    },
+    {
+      "path": "physics-v2.json",
+      "sha256": "8fd62ddd0d81abbb8a596fc3acc87ddd7b4d36ed4cd53ce495688aa6893ce194"
+    }
+  ],
+  "kind": "pyamplicol-reference-fixture-bundle",
+  "schema_version": 1
+}
diff --git a/pyamplicol/tests/integration/test_adjoint_fft_runtime.py b/pyamplicol/tests/integration/test_adjoint_fft_runtime.py
new file mode 100644
index 0000000000..3a62905e08
--- /dev/null
+++ b/pyamplicol/tests/integration/test_adjoint_fft_runtime.py
@@ -0,0 +1,400 @@
+# SPDX-License-Identifier: 0BSD
+"""Small physics and public-SDK parity checks for both FFT colour bases."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from collections.abc import Iterator
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from pyamplicol.models.builtin.validation import generic_validation_point
+from tests.integration.test_on_the_fly_runtime_capabilities import (
+    _require_native_on_the_fly,
+)
+from tests.integration.test_runtime_selector_api_parity import (
+    _compile_probe,
+    _NativeSdk,
+    _source_environment,
+)
+from tests.integration.test_runtime_selector_api_parity import (
+    native_sdk as _native_sdk_fixture,
+)
+
+native_sdk = _native_sdk_fixture
+
+_LANES = ("recurrence", "on-the-fly")
+_BASES = ("trace", "adjoint")
+_FOUR_GLUON_POINTS = (
+    ((500, 0, 0, 500), (500, 0, 0, -500), (500, 300, 0, 400), (500, -300, 0, -400)),
+    ((500, 0, 0, 500), (500, 0, 0, -500), (500, 400, 300, 0), (500, -400, -300, 0)),
+)
+
+
+@pytest.fixture(scope="module")
+def prepared_sm() -> Iterator[ModelSource]:
+    _require_native_on_the_fly()
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as path:
+        yield ModelSource.from_path(path)
+
+
+def _config(
+    lane: str,
+    basis: str,
+    *,
+    accuracy: str = "full",
+    selected_helicities: tuple[int, ...] = (),
+    reference_color_order: tuple[int, ...] | None = None,
+) -> RunConfig:
+    return RunConfig(
+        action="generate",
+        process=ProcessConfig(
+            reference_color_order=reference_color_order or (),
+            selected_source_helicities={
+                str(index): value
+                for index, value in enumerate(selected_helicities, start=1)
+            },
+        ),
+        color=ColorConfig(
+            accuracy=accuracy,
+            contraction="symmetric-group-fft",
+            fft_basis=basis,
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=lane,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+def _assert_fft_degree(artifact: Path, expected: int) -> None:
+    execution_paths = tuple((artifact / "processes").glob("*/execution.json"))
+    assert len(execution_paths) == 1
+    execution = json.loads(execution_paths[0].read_text(encoding="utf-8"))
+    color = execution["runtime_metadata"]["color_contraction"]
+    assert color["storage"] == "convolution-kernels"
+    assert color["factorization"]["kind"] == "symmetric-group-fourier"
+    assert color["factorization"]["rank"] == expected
+    assert color["fft_provenance"]["degree"] == expected
+
+
+@pytest.mark.parametrize("lane", _LANES)
+def test_automatic_fft_default_matches_forced_fft_and_direct(
+    tmp_path: Path, prepared_sm: ModelSource, lane: str
+) -> None:
+    config = _config(
+        lane,
+        "adjoint",
+        selected_helicities=(-1, 1, -1, 1) if lane == "recurrence" else (),
+    )
+    values = {}
+    for method in ("auto", "symmetric-group-fft", "direct"):
+        artifact = tmp_path / method
+        Generator(
+            replace(config, color=ColorConfig(accuracy="full", contraction=method))
+        ).generate("g g > g g", artifact, model=prepared_sm)
+        if method != "direct":
+            _assert_fft_degree(artifact, 2)
+        runtime = Runtime.load(artifact)
+        values[method] = tuple(
+            complex(value) for value in runtime.evaluate(_FOUR_GLUON_POINTS)
+        )
+        del runtime
+    assert any(abs(value) > 0 for value in values["auto"])
+    assert values["auto"] == pytest.approx(values["symmetric-group-fft"], rel=2e-12)
+    assert values["auto"] == pytest.approx(values["direct"], rel=2e-11)
+
+
+@pytest.fixture(scope="module", params=_LANES)
+def four_gluon_artifacts(
+    request: pytest.FixtureRequest,
+    tmp_path_factory: pytest.TempPathFactory,
+    prepared_sm: ModelSource,
+) -> dict[str, Path]:
+    root = tmp_path_factory.mktemp(f"adjoint-fft-{request.param}")
+    artifacts = {}
+    for basis in _BASES:
+        artifact = root / basis
+        Generator(
+            _config(
+                request.param,
+                basis,
+                reference_color_order=(3, 2, 4, 1) if basis == "adjoint" else None,
+            )
+        ).generate("g g > g g", artifact, model=prepared_sm)
+        _assert_fft_degree(artifact, 3 if basis == "trace" else 2)
+        artifacts[basis] = artifact
+    return artifacts
+
+
+def test_adjoint_fft_matches_trace_for_each_helicity_and_the_total(
+    four_gluon_artifacts: dict[str, Path],
+    request: pytest.FixtureRequest,
+) -> None:
+    runtimes = {
+        basis: Runtime.load(path) for basis, path in four_gluon_artifacts.items()
+    }
+    try:
+        resolved = {
+            basis: runtime.evaluate_resolved(_FOUR_GLUON_POINTS)
+            for basis, runtime in runtimes.items()
+        }
+        assert resolved["adjoint"].helicity_ids == resolved["trace"].helicity_ids
+        assert len(resolved["trace"].helicity_ids) == 16
+        flattened = {
+            basis: tuple(
+                complex(value)
+                for point in result.values
+                for helicity in point
+                for value in helicity
+            )
+            for basis, result in resolved.items()
+        }
+        assert flattened["adjoint"] == pytest.approx(
+            flattened["trace"], rel=2e-11, abs=1e-18
+        )
+        assert any(abs(value) > 0 for value in flattened["trace"])
+        totals = {
+            basis: tuple(
+                complex(value) for value in runtime.evaluate(_FOUR_GLUON_POINTS)
+            )
+            for basis, runtime in runtimes.items()
+        }
+        assert totals["adjoint"] == pytest.approx(totals["trace"], rel=2e-11)
+        for basis, result in resolved.items():
+            assert tuple(complex(value) for value in result.total()) == pytest.approx(
+                totals[basis], rel=2e-12
+            )
+        if request.node.callspec.params["four_gluon_artifacts"] == "recurrence":
+            exact = {
+                basis: tuple(
+                    complex(value)
+                    for value in runtime.evaluate(_FOUR_GLUON_POINTS, precision=32)
+                )
+                for basis, runtime in runtimes.items()
+            }
+            assert exact["adjoint"] == pytest.approx(exact["trace"], rel=2e-12)
+
+        # Coupling normalization is shared by the two bases and remains mutable.
+        for runtime in runtimes.values():
+            runtime.set_model_parameters({"normalization.alpha_s_me_check": 0.13})
+        assert runtimes["adjoint"].evaluate(_FOUR_GLUON_POINTS) == pytest.approx(
+            runtimes["trace"].evaluate(_FOUR_GLUON_POINTS), rel=2e-11
+        )
+    finally:
+        runtimes.clear()
+
+
+@pytest.mark.parametrize("lane", _LANES)
+@pytest.mark.parametrize(
+    "process,accuracy,helicities",
+    (
+        ("g g > g g g", "full", (-1, 1, -1, 1, -1)),
+        ("g g > g g g g", "nlc", (-1, 1, -1, 1, -1, 1)),
+    ),
+)
+def test_adjoint_fft_matches_trace_for_selected_helicity_and_nlc(
+    tmp_path: Path,
+    prepared_sm: ModelSource,
+    lane: str,
+    process: str,
+    accuracy: str,
+    helicities: tuple[int, ...],
+) -> None:
+    points = tuple(
+        tuple(
+            tuple(float(component) for component in leg.momentum)
+            for leg in generic_validation_point(process, seed=seed)
+        )
+        for seed in (101, 203)
+    )
+    helicity_id = "h:" + ",".join(f"{value:+d}" for value in helicities)
+    values = {}
+    for basis in _BASES:
+        artifact = tmp_path / basis
+        # Recurrence specializes source states at generation; OTF keeps its
+        # complete source domain and selects exactly the same states at runtime.
+        Generator(
+            _config(
+                lane,
+                basis,
+                accuracy=accuracy,
+                selected_helicities=helicities if lane == "recurrence" else (),
+            )
+        ).generate(process, artifact, model=prepared_sm)
+        _assert_fft_degree(artifact, len(helicities) - (1 if basis == "trace" else 2))
+        runtime = Runtime.load(artifact)
+        try:
+            values[basis] = tuple(
+                complex(value)
+                for value in runtime.evaluate(points, helicities=(helicity_id,))
+            )
+        finally:
+            del runtime
+    assert any(abs(value) > 0 for value in values["trace"])
+    assert values["adjoint"] == pytest.approx(values["trace"], rel=2e-10, abs=1e-18)
+
+
+_SDK_PROBES = {
+    "c": r"""
+        #include <rusticol.h>
+        #include <stdio.h>
+        #include <stdlib.h>
+        static void check(int status) {
+            if (status) {
+                char error[2048]; size_t needed;
+                rusticol_last_error_message(error, sizeof error, &needed);
+                fprintf(stderr, "%s\n", error); exit(1);
+            }
+        }
+        int main(int argc, char **argv) {
+            if (argc != 34) return 2;
+            double momenta[32], values[2];
+            for (size_t i=0; i<32; ++i) momenta[i]=strtod(argv[i+2], NULL);
+            RusticolRuntimeHandle *runtime=NULL;
+            check(rusticol_runtime_load(argv[1], NULL, NULL, &runtime));
+            check(rusticol_runtime_evaluate_f64(runtime, momenta, 32, 2, values, 2));
+            for (size_t i=0; i<2; ++i) printf("VALUE %zu %.17g\n", i, values[i]);
+            check(rusticol_runtime_free(runtime)); return 0;
+        }
+    """,
+    "cpp": r"""
+        #include <rusticol.hpp>
+        #include <cstdlib>
+        #include <iomanip>
+        #include <iostream>
+        int main(int argc, char **argv) {
+            if (argc != 34) return 2;
+            std::vector<double> momenta;
+            for (int i=2; i<argc; ++i) momenta.push_back(std::strtod(argv[i], nullptr));
+            rusticol::Runtime runtime(argv[1]);
+            auto values=runtime.evaluate(momenta, 2);
+            for (std::size_t i=0; i<values.size(); ++i)
+                std::cout << "VALUE " << i << " "
+                          << std::setprecision(17) << values[i] << "\n";
+        }
+    """,
+    "fortran": r"""
+        program adjoint_fft_parity
+          use, intrinsic :: iso_c_binding
+          use rusticol
+          implicit none
+          type(rusticol_runtime) :: runtime
+          character(len=4096) :: artifact, arg
+          real(c_double) :: momenta(32)
+          real(c_double), allocatable :: values(:)
+          integer :: i
+          if (command_argument_count() /= 33) stop 2
+          call get_command_argument(1, artifact)
+          do i=1,32
+            call get_command_argument(i+1, arg)
+            read(arg, *) momenta(i)
+          end do
+          call runtime%load(trim(artifact))
+          call runtime%evaluate(momenta, 2_c_size_t, values)
+          do i=1,2
+            write(*,'(A,I0,1X,ES25.17E3)') 'VALUE ', i-1, values(i)
+          end do
+          call runtime%close()
+        end program adjoint_fft_parity
+    """,
+    "rust": r"""
+        #[allow(dead_code)]
+        mod rusticol { include!(env!("RUSTICOL_RUST_SOURCE")); }
+        use rusticol::Runtime;
+        fn main() -> Result<(), Box<dyn std::error::Error>> {
+            let args: Vec<_> = std::env::args().collect();
+            if args.len() != 34 { return Err("wrong argument count".into()); }
+            let momenta: Vec<f64> = args[2..].iter()
+                .map(|s| s.parse()).collect::<Result<_,_>>()?;
+            let mut runtime = Runtime::load(&args[1], None, None)?;
+            for (i, value) in runtime.evaluate_f64(&momenta, 2)?.iter().enumerate() {
+                println!("VALUE {i} {value:.17e}");
+            }
+            Ok(())
+        }
+    """,
+}
+
+
+@pytest.fixture(scope="module", params=tuple(_SDK_PROBES))
+def sdk_driver(
+    request: pytest.FixtureRequest,
+    native_sdk: _NativeSdk,
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Path:
+    return _compile_probe(
+        request.param,
+        _SDK_PROBES[request.param],
+        native_sdk,
+        tmp_path_factory.mktemp(f"adjoint-fft-sdk-{request.param}"),
+    )
+
+
+def test_adjoint_fft_artifacts_use_the_same_native_sdk_evaluation_api(
+    sdk_driver: Path,
+    four_gluon_artifacts: dict[str, Path],
+) -> None:
+    runtime = Runtime.load(four_gluon_artifacts["trace"])
+    try:
+        expected = tuple(
+            float(complex(value).real) for value in runtime.evaluate(_FOUR_GLUON_POINTS)
+        )
+    finally:
+        del runtime
+    for artifact in four_gluon_artifacts.values():
+        result = subprocess.run(
+            [
+                str(sdk_driver),
+                str(artifact),
+                *(
+                    str(value)
+                    for point in _FOUR_GLUON_POINTS
+                    for leg in point
+                    for value in leg
+                ),
+            ],
+            env=_source_environment(),
+            capture_output=True,
+            text=True,
+            timeout=120,
+            check=False,
+        )
+        assert result.returncode == 0, result.stdout + result.stderr
+        measured = {
+            int(parts[1]): float(parts[2])
+            for line in result.stdout.splitlines()
+            if (parts := line.split()) and parts[0] == "VALUE"
+        }
+        assert set(measured) == {0, 1}
+        assert tuple(measured[index] for index in range(2)) == pytest.approx(
+            expected, rel=2e-11
+        )
diff --git a/pyamplicol/tests/integration/test_cli_artifact_workflow.py b/pyamplicol/tests/integration/test_cli_artifact_workflow.py
new file mode 100644
index 0000000000..cd20cace7d
--- /dev/null
+++ b/pyamplicol/tests/integration/test_cli_artifact_workflow.py
@@ -0,0 +1,457 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib.util
+import json
+import math
+import os
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from pyamplicol import (
+    Generator,
+    ModelSource,
+    ProcessAlias,
+    ProcessRequest,
+    ProcessSet,
+    Runtime,
+)
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorExecutionMode,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+@dataclass(frozen=True)
+class _Selection:
+    selector: str
+    process_id: str
+    expression: str
+    momenta: tuple[tuple[float, float, float, float], ...]
+
+
+def _native_extension_available() -> bool:
+    return importlib.util.find_spec("pyamplicol._rusticol") is not None
+
+
+def _base_momenta() -> tuple[tuple[float, float, float, float], ...]:
+    sqrt_s = 500.0
+    z_mass = 91.188
+    outgoing_momentum = (sqrt_s * sqrt_s - z_mass * z_mass) / (2.0 * sqrt_s)
+    z_energy = (sqrt_s * sqrt_s + z_mass * z_mass) / (2.0 * sqrt_s)
+    return (
+        (250.0, 0.0, 0.0, 250.0),
+        (250.0, 0.0, 0.0, -250.0),
+        (z_energy, outgoing_momentum, 0.0, 0.0),
+        (outgoing_momentum, -outgoing_momentum, 0.0, 0.0),
+    )
+
+
+@pytest.fixture(scope="module")
+def lc_process_set_artifact(tmp_path_factory: pytest.TempPathFactory) -> Path:
+    if not _native_extension_available():
+        pytest.skip("the Rusticol extension has not been built")
+
+    artifact = tmp_path_factory.mktemp("cli-artifact-workflow") / "artifact"
+    request = ProcessRequest.parse("d d~ > z g", name="ddbar_zg")
+    processes = ProcessSet(
+        requests=(request,),
+        aliases=(
+            ProcessAlias(
+                name="ddbar_gz",
+                process_name=request.name,
+                particle_permutation=(0, 1, 3, 2),
+            ),
+        ),
+    )
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc"),
+        generation=GenerationConfig(
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(jit=JITConfig(optimization_level=1)),
+    )
+
+    Generator(config).generate(processes, artifact)
+    return artifact
+
+
+@pytest.fixture(scope="module")
+def otf_process_set_artifact(tmp_path_factory: pytest.TempPathFactory) -> Path:
+    if not _native_extension_available():
+        pytest.skip("the Rusticol extension has not been built")
+
+    artifact = tmp_path_factory.mktemp("cli-otf-workflow") / "artifact"
+    request = ProcessRequest.parse("d d~ > z g", name="ddbar_zg")
+    processes = ProcessSet(
+        requests=(request,),
+        aliases=(
+            ProcessAlias(
+                name="ddbar_gz",
+                process_name=request.name,
+                particle_permutation=(0, 1, 3, 2),
+            ),
+        ),
+    )
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=EvaluatorExecutionMode.ON_THE_FLY,
+        ),
+    )
+
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+        Generator(config).generate(
+            processes,
+            artifact,
+            model=ModelSource.from_path(prepared_model),
+        )
+    return artifact
+
+
+def _run_json_cli(*arguments: str, timeout: float = 30.0) -> Any:
+    environment = os.environ.copy()
+    environment["PYTHONPATH"] = str(ROOT / "src")
+    environment["PYTHONDONTWRITEBYTECODE"] = "1"
+    environment["SYMBOLICA_HIDE_BANNER"] = "1"
+    completed = subprocess.run(
+        [sys.executable, "-m", "pyamplicol", *arguments],
+        cwd=ROOT,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+    assert completed.returncode == 0, completed.stderr
+    assert completed.stderr == ""
+    try:
+        return json.loads(completed.stdout)
+    except json.JSONDecodeError as exc:
+        pytest.fail(
+            f"CLI JSON stdout contains non-JSON output: {completed.stdout!r} ({exc})"
+        )
+
+
+def _write_momenta(
+    path: Path,
+    momenta: tuple[tuple[float, float, float, float], ...],
+) -> None:
+    path.write_text(json.dumps([momenta]) + "\n", encoding="utf-8")
+
+
+def _complex_values(payload: Any) -> tuple[complex, ...]:
+    assert isinstance(payload, list)
+    return tuple(
+        complex(float(entry["real"]), float(entry["imag"])) for entry in payload
+    )
+
+
+def _flatten_complex_values(payload: Any) -> tuple[complex, ...]:
+    if isinstance(payload, list):
+        return tuple(
+            value for entry in payload for value in _flatten_complex_values(entry)
+        )
+    assert isinstance(payload, dict)
+    return (complex(float(payload["real"]), float(payload["imag"])),)
+
+
+def test_cli_inspect_evaluate_and_profile_select_processes_by_public_identity(
+    lc_process_set_artifact: Path,
+    tmp_path: Path,
+) -> None:
+    base = _base_momenta()
+    alias = (base[0], base[1], base[3], base[2])
+    selections = (
+        _Selection("ddbar_zg", "ddbar_zg", "d d~ > z g", base),
+        _Selection("d d~ > z g", "ddbar_zg", "d d~ > z g", base),
+        _Selection("d d~ > g z", "ddbar_gz", "d d~ > g z", alias),
+    )
+
+    for index, selection in enumerate(selections):
+        runtime = Runtime.load(
+            lc_process_set_artifact,
+            process=selection.selector,
+        )
+        points = (selection.momenta,)
+        expected = runtime.evaluate(points)
+
+        inspection = _run_json_cli(
+            "inspect",
+            str(lc_process_set_artifact),
+            "--process",
+            selection.selector,
+            "--full-physics",
+            "--json",
+            "--progress",
+            "off",
+            "--color",
+            "never",
+            "--log-level",
+            "error",
+        )
+        assert inspection["process_id"] == selection.process_id
+        assert inspection["process"] == selection.expression
+        assert inspection["color_accuracy"] == "lc"
+        assert [
+            particle["name"] for particle in inspection["external_particles"]
+        ] == selection.expression.replace(">", " ").split()
+
+        momenta_path = tmp_path / f"momenta-{index}.json"
+        _write_momenta(momenta_path, selection.momenta)
+        evaluated = _run_json_cli(
+            "evaluate",
+            str(lc_process_set_artifact),
+            "--process",
+            selection.selector,
+            "--momenta",
+            str(momenta_path),
+            "--json",
+            "--progress",
+            "off",
+            "--color",
+            "never",
+            "--log-level",
+            "error",
+        )
+        assert _complex_values(evaluated) == pytest.approx(expected, rel=1.0e-13)
+
+        profile = _run_json_cli(
+            "profile",
+            str(lc_process_set_artifact),
+            "--process",
+            selection.selector,
+            "--momenta",
+            str(momenta_path),
+            "--target-runtime",
+            "0.001",
+            "--batch-size",
+            "2",
+            "--warmup-runs",
+            "0",
+            "--minimum-samples",
+            "2",
+            "--json",
+            "--progress",
+            "off",
+            "--color",
+            "never",
+            "--log-level",
+            "error",
+        )
+        assert profile["process_id"] == runtime.physics.process_id
+        assert profile["process_expression"] == runtime.physics.process
+        assert (
+            profile["environment"]["wall_time_source"]
+            == "python_outer_perf_counter_wall_time"
+        )
+        assert profile["effective_config"]["target_runtime"] == pytest.approx(0.001)
+        assert profile["effective_config"]["batch_size"] == 2
+        assert profile["sample_count"] >= 2
+        assert profile["wall_time_per_point"] > 0.0
+
+
+def test_otf_alias_crosses_compact_and_full_public_cli_and_runtime_surfaces(
+    otf_process_set_artifact: Path,
+    tmp_path: Path,
+) -> None:
+    selector = "d d~ > g z"
+    base = _base_momenta()
+    alias_momenta = (base[0], base[1], base[3], base[2])
+    points = (alias_momenta,)
+    manifest = load_manifest(otf_process_set_artifact)
+
+    runtime = Runtime.load(otf_process_set_artifact, process=selector)
+    cold = runtime.inspect()
+    assert cold["kind"] == "pyamplicol-runtime-inspection"
+    assert cold["artifact_id"] == manifest.artifact_id
+    assert cold["supported_precisions"] == (16,)
+    metadata = cold["runtime_metadata"]
+    assert isinstance(metadata, dict)
+    assert metadata["execution_mode"] == "on-the-fly"
+    assert metadata["process_key"] == "ddbar_gz"
+    assert metadata["representative_process_key"] == "ddbar_zg"
+    assert metadata["external_permutation"] == [0, 1, 3, 2]
+    assert metadata["permutation_alias_of"] == "ddbar_zg"
+    cold_state = cold["on_the_fly_state"]
+    assert isinstance(cold_state, dict)
+    assert cold_state["family_cache_policy"] == "last-family-only"
+    assert cold_state["family_cache_limit"] == 1
+    assert cold_state["retained_family_count"] == 0
+
+    expected_total = runtime.evaluate(points)
+    expected_resolved = runtime.evaluate_resolved(points)
+    assert expected_resolved.total() == pytest.approx(expected_total, rel=1.0e-13)
+    assert all(
+        math.isfinite(value.real) and math.isfinite(value.imag)
+        for value in expected_total
+    )
+    warm_state = runtime.inspect()["on_the_fly_state"]
+    assert isinstance(warm_state, dict)
+    assert warm_state["retained_family_count"] == 1
+    assert warm_state["retained_selection_count"] == 1
+
+    compact = _run_json_cli(
+        "inspect",
+        str(otf_process_set_artifact),
+        "--process",
+        selector,
+        "--json",
+        "--progress",
+        "off",
+        "--color",
+        "never",
+        "--log-level",
+        "error",
+    )
+    assert compact["kind"] == "pyamplicol-artifact-inspection"
+    assert len(compact["processes"]) == 1
+    compact_process = compact["processes"][0]
+    assert compact_process["id"] == "ddbar_zg"
+    assert compact_process["execution_mode"] == "on-the-fly"
+    assert compact_process["selector_provenance"] == "on-the-fly-compact-seed"
+    assert compact_process["lc_flow_layout"] == "compact/query-local"
+    assert [alias["id"] for alias in compact_process["aliases"]] == ["ddbar_gz"]
+
+    full = _run_json_cli(
+        "inspect",
+        str(otf_process_set_artifact),
+        "--process",
+        selector,
+        "--full-physics",
+        "--json",
+        "--progress",
+        "off",
+        "--color",
+        "never",
+        "--log-level",
+        "error",
+    )
+    assert full["process_id"] == "ddbar_gz"
+    assert full["process"] == selector
+    assert [particle["name"] for particle in full["external_particles"]] == [
+        "d",
+        "d~",
+        "g",
+        "z",
+    ]
+
+    momenta_path = tmp_path / "otf-alias-momenta.json"
+    _write_momenta(momenta_path, alias_momenta)
+    evaluated = _run_json_cli(
+        "evaluate",
+        str(otf_process_set_artifact),
+        "--process",
+        selector,
+        "--momenta",
+        str(momenta_path),
+        "--json",
+        "--progress",
+        "off",
+        "--color",
+        "never",
+        "--log-level",
+        "error",
+    )
+    assert _complex_values(evaluated) == pytest.approx(expected_total, rel=1.0e-13)
+
+    resolved = _run_json_cli(
+        "evaluate",
+        str(otf_process_set_artifact),
+        "--process",
+        selector,
+        "--momenta",
+        str(momenta_path),
+        "--resolved",
+        "--json",
+        "--progress",
+        "off",
+        "--color",
+        "never",
+        "--log-level",
+        "error",
+    )
+    assert resolved["helicity_ids"] == list(expected_resolved.helicity_ids)
+    assert resolved["color_ids"] == list(expected_resolved.color_ids)
+    assert resolved["color_accuracy"] == "lc"
+    assert _flatten_complex_values(resolved["values"]) == pytest.approx(
+        tuple(
+            value
+            for point in expected_resolved.values
+            for helicity in point
+            for value in helicity
+        ),
+        rel=1.0e-13,
+    )
+
+    profile = _run_json_cli(
+        "profile",
+        str(otf_process_set_artifact),
+        "--process",
+        selector,
+        "--momenta",
+        str(momenta_path),
+        "--target-runtime",
+        "0.001",
+        "--batch-size",
+        "2",
+        "--warmup-runs",
+        "0",
+        "--minimum-samples",
+        "2",
+        "--json",
+        "--progress",
+        "off",
+        "--color",
+        "never",
+        "--log-level",
+        "error",
+    )
+    assert profile["process_id"] == "ddbar_gz"
+    assert profile["process_expression"] == selector
+    assert profile["environment"]["execution_mode"] == "on-the-fly"
+    assert profile["environment"]["cold_warmup_runtime_freshness"] == (
+        "authenticated-cold"
+    )
+    assert profile["environment"]["cold_warmup_runtime_state_evidence"] == (
+        "authenticated-native-otf-census-v1"
+    )
+    before = profile["environment"]["cold_warmup_runtime_state_before"]
+    after = profile["environment"]["cold_warmup_runtime_state_after"]
+    assert before["family_cache_policy"] == "last-family-only"
+    assert before["family_cache_limit"] == 1
+    assert before["retained_family_count"] == 0
+    assert after["retained_family_count"] == 1
+    assert profile["sample_count"] >= 2
+    assert profile["wall_time_per_point"] > 0.0
diff --git a/pyamplicol/tests/integration/test_compiled_exact_color.py b/pyamplicol/tests/integration/test_compiled_exact_color.py
new file mode 100644
index 0000000000..fa63d23390
--- /dev/null
+++ b/pyamplicol/tests/integration/test_compiled_exact_color.py
@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: 0BSD
+"""Compare compiled/eager colour contractions with independent exact recurrence."""
+
+from decimal import Decimal, localcontext
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+
+
+@pytest.mark.parametrize(
+    "process,point",
+    (
+        (
+            "g g > g g",
+            (
+                (500, 0, 0, 500),
+                (500, 0, 0, -500),
+                (500, 300, 0, 400),
+                (500, -300, 0, -400),
+            ),
+        ),
+        (
+            "g g > g g g g",
+            (
+                (500, 0, 0, 500),
+                (500, 0, 0, -500),
+                (250, 150, 0, 200),
+                (250, -150, 0, -200),
+                (250, 0, 200, 150),
+                (250, 0, -200, -150),
+            ),
+        ),
+    ),
+)
+def test_compiled_full_colour_matches_recurrence_beyond_binary64(
+    tmp_path, process, point
+):
+    values = []
+    for mode in ("recurrence", "compiled", "eager"):
+        config = RunConfig(
+            action="generate",
+            color=ColorConfig(accuracy="full", contraction="direct"),
+            generation=GenerationConfig(
+                workers=1,
+                emit_api_bundle=False,
+                relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+                validation=GenerationValidationConfig(
+                    enabled=False, post_build_validation=False
+                ),
+            ),
+            evaluator=EvaluatorConfig(
+                execution_mode=mode,
+                optimization=EvaluatorOptimizationConfig(cores=1),
+                jit=JITConfig(optimization_level=2),
+            ),
+        )
+        output = tmp_path / mode
+        Generator(config).generate(process, output, model=ModelSource.built_in_sm())
+        runtime = Runtime.load(
+            output, model_parameters={"normalization.alpha_s_me_check": 0.125}
+        )
+        values.append(runtime.evaluate([[list(p) for p in point]], precision=80)[0])
+    with localcontext() as context:
+        context.prec = 90
+        assert values[0] > 0
+        for value in values[1:]:
+            assert abs(values[0] - value) / abs(values[0]) < Decimal("1e-70")
diff --git a/pyamplicol/tests/integration/test_correlated_native_sdk.py b/pyamplicol/tests/integration/test_correlated_native_sdk.py
new file mode 100644
index 0000000000..46a8653c67
--- /dev/null
+++ b/pyamplicol/tests/integration/test_correlated_native_sdk.py
@@ -0,0 +1,542 @@
+# SPDX-License-Identifier: 0BSD
+# ruff: noqa: E501 -- embedded native probe sources have their own formatting.
+"""One generated correlator example, evaluated independently through every SDK."""
+
+from __future__ import annotations
+
+import importlib.util
+import math
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import (
+    ColorCorrelator,
+    CorrelatedRequest,
+    CorrelatorConfig,
+    EmitGluon,
+    Generator,
+    ModelSource,
+    ProcessSet,
+    Runtime,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    JITConfig,
+    RunConfig,
+)
+from tests.integration.test_runtime_selector_api_parity import (
+    _compile_probe,
+    _NativeSdk,
+    _source_environment,
+    _unavailable,
+)
+from tests.integration.test_runtime_selector_api_parity import (
+    native_sdk as _native_sdk_fixture,
+)
+
+native_sdk = _native_sdk_fixture
+
+_ROOT = Path(__file__).resolve().parents[2]
+_POINTS = (
+    (
+        (400, 0, 0, 400),
+        (400, 0, 0, -400),
+        (300, 300, 0, 0),
+        (250, -150, 200, 0),
+        (250, -150, -200, 0),
+    ),
+    (
+        (400, 0, 0, 400),
+        (400, 0, 0, -400),
+        (300, 0, 300, 0),
+        (250, 200, -150, 0),
+        (250, -200, -150, 0),
+    ),
+)
+
+
+@pytest.fixture(scope="module", params=("lc", "nlc", "full"))
+def correlated_output(
+    request: pytest.FixtureRequest, tmp_path_factory: pytest.TempPathFactory
+):
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    artifact = tmp_path_factory.mktemp(f"correlated-sdk-{request.param}") / "process"
+    alpha = (EmitGluon(2, -3), EmitGluon(-3, -1), EmitGluon(-3, -2))
+    beta = (EmitGluon(1, -1), EmitGluon(3, -2), EmitGluon(4, -3))
+    # An ordered, non-Hermitian NNLO insertion, multiplied by C_F on the
+    # independent hard leg 4, gives a genuinely complex N3LO test below.
+    ordered_bra = (EmitGluon(2, -1), EmitGluon(1, -2), EmitGluon(4, -3))
+    ordered_ket = (EmitGluon(3, -2), EmitGluon(1, -1), EmitGluon(4, -3))
+    declarations = CorrelatorConfig(
+        color_correlations=(
+            ColorCorrelator("cascade-interference", alpha, beta),
+            ColorCorrelator("ordered", ordered_bra, ordered_ket),
+            ColorCorrelator("ordered-reverse", ordered_ket, ordered_bra),
+        ),
+        spin_correlations=((5,),),
+    )
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=request.param),
+        generation=GenerationConfig(workers=1),
+        evaluator=EvaluatorConfig(
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=1),
+        ),
+    )
+    Generator(config).generate(
+        ProcessSet.from_expressions(("d d~ > d d~ g",), names=("dd_ddg",)),
+        artifact,
+        model=ModelSource.built_in_sm(),
+        correlators=declarations,
+    )
+    runtime = Runtime.load(artifact, process="dd_ddg")
+    oracle = runtime.evaluate_correlated_many(
+        _POINTS,
+        {
+            "born": CorrelatedRequest("born", {}),
+            "interference": CorrelatedRequest("cascade-interference", {}),
+            "spin": CorrelatedRequest("cascade-interference", {5: (0, 0, 0, 1)}),
+        },
+        precision=50,
+    )
+    return (
+        artifact,
+        tuple(tuple(complex(value) for value in series) for series in oracle.values()),
+        request.param,
+    )
+
+
+@pytest.fixture(scope="module", params=("c", "cpp", "fortran", "rust"))
+def correlated_driver(
+    request: pytest.FixtureRequest,
+    native_sdk: _NativeSdk,
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Path:
+    extension = {"c": "c", "cpp": "cpp", "fortran": "f90", "rust": "rs"}[request.param]
+    source = (_ROOT / "examples" / "native" / f"correlated.{extension}").read_text()
+    return _compile_probe(
+        request.param,
+        source,
+        native_sdk,
+        tmp_path_factory.mktemp(f"correlated-sdk-{request.param}"),
+    )
+
+
+def test_correlated_sdk_matches_python_oracle(
+    correlated_driver: Path, correlated_output
+) -> None:
+    artifact, oracle, _ = correlated_output
+    result = subprocess.run(
+        [str(correlated_driver), str(artifact), "dd_ddg"],
+        capture_output=True,
+        text=True,
+        env=_source_environment(),
+        timeout=90,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    measured = {}
+    for line in result.stdout.splitlines():
+        if line.startswith("VALUE "):
+            _, request, point, real, imaginary = line.split()
+            key = (int(request), int(point))
+            assert key not in measured
+            measured[key] = complex(float(real), float(imaginary))
+    assert set(measured) == {
+        (request, point) for request in range(3) for point in range(2)
+    }
+    for request, series in enumerate(oracle):
+        for point, expected in enumerate(series):
+            assert measured[request, point] == pytest.approx(
+                expected, rel=2e-10, abs=1e-15
+            )
+
+
+# These small input-driven probes exercise the same physics requests through
+# each public wrapper. Numerical assertions stay in Python, avoiding four
+# independent copies of the physics conventions and tolerances.
+_PHYSICS_PROBES = {
+    "c": r"""
+        #include <rusticol.h>
+        #include <stdio.h>
+        #include <stdlib.h>
+        static void check(int status) {
+            if (status) {
+                char error[2048]; size_t needed;
+                rusticol_last_error_message(error, sizeof error, &needed);
+                fprintf(stderr, "%s\n", error); exit(1);
+            }
+        }
+        int main(int argc, char **argv) {
+            if (argc != 4) return 2;
+            FILE *input = fopen(argv[3], "r");
+            size_t points, legs, count;
+            if (!input || fscanf(input, "%zu %zu %zu", &points, &legs, &count) != 3) return 2;
+            size_t length = 4 * points * legs;
+            double *momenta = calloc(length, sizeof(double));
+            for (size_t i=0; i<length; ++i) if (fscanf(input, "%lf", momenta+i) != 1) return 2;
+            RusticolCorrelatedRequest *requests = calloc(count, sizeof(*requests));
+            for (size_t r=0; r<count; ++r) {
+                char *id = calloc(128, 1); size_t spins;
+                if (fscanf(input, "%127s %zu", id, &spins) != 2) return 2;
+                RusticolSpinCorrelationVector *vectors = calloc(spins, sizeof(*vectors));
+                for (size_t s=0; s<spins; ++s) {
+                    size_t leg; double *values = calloc(8 * points, sizeof(double));
+                    if (fscanf(input, "%zu", &leg) != 1) return 2;
+                    for (size_t i=0; i<8*points; ++i) if (fscanf(input, "%lf", values+i) != 1) return 2;
+                    vectors[s] = (RusticolSpinCorrelationVector){leg, points, values, 8*points};
+                }
+                requests[r] = (RusticolCorrelatedRequest){id, vectors, spins, 0};
+            }
+            fclose(input);
+            RusticolRuntimeHandle *runtime = NULL;
+            check(rusticol_runtime_load(argv[1], argv[2], NULL, &runtime));
+            double *before=calloc(points,sizeof(double)), *after=calloc(points,sizeof(double));
+            double *values=calloc(2*points*count,sizeof(double));
+            check(rusticol_runtime_evaluate_f64(runtime,momenta,length,points,before,points));
+            check(rusticol_runtime_evaluate_correlated_many_f64(runtime,momenta,length,points,requests,count,NULL,0,values,2*points*count));
+            check(rusticol_runtime_evaluate_f64(runtime,momenta,length,points,after,points));
+            for (size_t p=0; p<points; ++p) if(before[p]!=after[p]) return 1;
+            for(size_t r=0;r<count;++r) for(size_t p=0;p<points;++p)
+                printf("VALUE %zu %zu %.17g %.17g\n",r,p,values[2*(r*points+p)],values[2*(r*points+p)+1]);
+            for(size_t r=0;r<count;++r) {
+                for(size_t s=0;s<requests[r].spin_vector_count;++s) free((void*)requests[r].spin_vectors[s].components);
+                free((void*)requests[r].spin_vectors); free((void*)requests[r].color_correlation);
+            }
+            free(requests);free(values);free(before);free(after);free(momenta);
+            check(rusticol_runtime_free(runtime)); return 0;
+        }
+    """,
+    "cpp": r"""
+        #include <rusticol.hpp>
+        #include <fstream>
+        #include <iomanip>
+        #include <iostream>
+        int main(int argc,char **argv) {
+            if(argc!=4) return 2;
+            try {
+                std::ifstream input(argv[3]); size_t points,legs,count;
+                input>>points>>legs>>count;
+                std::vector<double> momenta(4*points*legs);
+                for(auto &value:momenta) input>>value;
+                std::vector<rusticol::CorrelatedRequest> requests;
+                for(size_t r=0;r<count;++r) {
+                    std::string id;size_t spins;input>>id>>spins;
+                    std::vector<rusticol::SpinCorrelationVector> vectors;
+                    for(size_t s=0;s<spins;++s) {
+                        rusticol::SpinCorrelationVector vector;input>>vector.leg;
+                        vector.components.resize(points);
+                        for(auto &point:vector.components) for(auto &value:point) {
+                            double re,im;input>>re>>im;value={re,im};
+                        }
+                        vectors.push_back(std::move(vector));
+                    }
+                    requests.push_back({id,vectors});
+                }
+                if(!input) return 2;
+                rusticol::Runtime runtime(argv[1],argv[2]);
+                const auto before=runtime.evaluate(momenta,points);
+                const auto values=runtime.evaluate_correlated_many(momenta,points,requests);
+                if(before!=runtime.evaluate(momenta,points)) return 1;
+                std::cout<<std::setprecision(17);
+                for(size_t r=0;r<count;++r) for(size_t p=0;p<points;++p)
+                    std::cout<<"VALUE "<<r<<' '<<p<<' '<<values(r,p).real()<<' '<<values(r,p).imag()<<'\n';
+            } catch(const std::exception &error) { std::cerr<<error.what()<<'\n';return 1; }
+        }
+    """,
+    "fortran": r"""
+        program physics_probe
+          use, intrinsic :: iso_c_binding
+          use rusticol
+          implicit none
+          type(rusticol_runtime) :: runtime
+          type(rusticol_correlated_request), allocatable :: requests(:)
+          character(len=4096) :: artifact, key, filename
+          character(len=128) :: identifier
+          integer :: unit, points, legs, count, spins, r, p, s, mu
+          real(c_double), allocatable :: momenta(:), before(:), after(:)
+          complex(c_double_complex), allocatable :: values(:,:)
+          real(c_double) :: re, im
+          call get_command_argument(1,artifact)
+          call get_command_argument(2,key)
+          call get_command_argument(3,filename)
+          open(newunit=unit,file=trim(filename),status="old",action="read")
+          read(unit,*) points,legs,count
+          allocate(momenta(4*points*legs),requests(count))
+          read(unit,*) momenta
+          do r=1,count
+            read(unit,*) identifier,spins
+            requests(r)%color_correlation=trim(identifier)
+            allocate(requests(r)%spin_vectors(spins))
+            do s=1,spins
+              read(unit,*) requests(r)%spin_vectors(s)%leg
+              allocate(requests(r)%spin_vectors(s)%components(4,points))
+              do p=1,points
+                do mu=1,4
+                  read(unit,*) re,im
+                  requests(r)%spin_vectors(s)%components(mu,p)=cmplx(re,im,kind=c_double)
+                end do
+              end do
+            end do
+          end do
+          close(unit)
+          call runtime%load(trim(artifact),process_key=trim(key))
+          call runtime%evaluate(momenta,int(points,c_size_t),before)
+          call runtime%evaluate_correlated_many(momenta,int(points,c_size_t),requests,values)
+          call runtime%evaluate(momenta,int(points,c_size_t),after)
+          if(any(before/=after)) error stop "ordinary result changed"
+          do r=1,count
+            do p=1,points
+              write(*,'(A,1X,I0,1X,I0,2(1X,ES25.17E3))') "VALUE",r-1,p-1,real(values(p,r),c_double),aimag(values(p,r))
+            end do
+          end do
+          call runtime%close()
+        end program physics_probe
+    """,
+    "rust": r"""
+        #[allow(dead_code)]
+        mod rusticol { include!(env!("RUSTICOL_RUST_SOURCE")); }
+        use rusticol::{Complex64,CorrelatedRequest,Runtime,SpinCorrelationVector};
+        fn main()->Result<(),Box<dyn std::error::Error>> {
+            let args=std::env::args().collect::<Vec<_>>();
+            let data=std::fs::read_to_string(&args[3])?;
+            let mut tokens=data.split_whitespace();
+            let points:usize=tokens.next().unwrap().parse()?;
+            let legs:usize=tokens.next().unwrap().parse()?;
+            let count:usize=tokens.next().unwrap().parse()?;
+            let mut momenta=Vec::new();
+            for _ in 0..4*points*legs { momenta.push(tokens.next().unwrap().parse::<f64>()?); }
+            let mut requests=Vec::new();
+            for _ in 0..count {
+                let id=tokens.next().unwrap().to_owned();
+                let spins:usize=tokens.next().unwrap().parse()?;
+                let mut vectors=Vec::new();
+                for _ in 0..spins {
+                    let leg=tokens.next().unwrap().parse()?;
+                    let mut components=vec![[Complex64::default();4];points];
+                    for point in &mut components { for value in point {
+                        *value=Complex64::new(tokens.next().unwrap().parse()?,tokens.next().unwrap().parse()?);
+                    } }
+                    vectors.push(SpinCorrelationVector{leg,components});
+                }
+                requests.push(CorrelatedRequest{color_correlation:id,spin_vectors:Some(vectors)});
+            }
+            let mut runtime=Runtime::load(&args[1],Some(&args[2]),None)?;
+            let before=runtime.evaluate_f64(&momenta,points)?;
+            let values=runtime.evaluate_correlated_many_f64(&momenta,points,&requests,&[])?;
+            assert_eq!(before,runtime.evaluate_f64(&momenta,points)?);
+            for r in 0..count {for p in 0..points {
+                let value=values.get(r,p).unwrap();
+                println!("VALUE {r} {p} {:.17e} {:.17e}",value.re,value.im);
+            }}
+            Ok(())
+        }
+    """,
+}
+
+
+@pytest.fixture(scope="module")
+def correlated_physics_output(tmp_path_factory):
+    from tests.integration.test_correlators import _configuration
+
+    output = tmp_path_factory.mktemp("correlated-sdk-physics") / "process"
+    cascade = (EmitGluon(1, -3), EmitGluon(-3, -1), EmitGluon(-3, -2))
+    independent = (EmitGluon(2, -1), EmitGluon(3, -2), EmitGluon(4, -3))
+    triple = tuple(EmitGluon(1, -i) for i in range(1, 4))
+    Generator(_configuration()).generate(
+        ProcessSet.from_expressions(("g g > g g",), names=("gg",)),
+        output,
+        model=ModelSource.built_in_sm(),
+        correlators=CorrelatorConfig(
+            color_correlations=(
+                *(ColorCorrelator.dipole(f"T1{leg}", 1, leg) for leg in range(1, 5)),
+                ColorCorrelator("triple-self", triple, triple),
+                ColorCorrelator("forward", cascade, independent),
+                ColorCorrelator("reverse", independent, cascade),
+            ),
+            spin_correlations=((3,), (4,), (3, 4)),
+        ),
+    )
+    points = (
+        ((500, 0, 0, 500), (500, 0, 0, -500), (500, 300, 0, 400), (500, -300, 0, -400)),
+        ((500, 0, 0, 500), (500, 0, 0, -500), (500, 400, 0, 300), (500, -400, 0, -300)),
+    )
+    transverse = (
+        ((0, 0.8, 0, -0.6), (0, 0.6, 0, -0.8)),
+        ((0, 0, 1, 0),) * 2,
+    )
+    requests = {"born": CorrelatedRequest("born", {})}
+    requests.update(
+        {f"T1{leg}": CorrelatedRequest(f"T1{leg}", {}) for leg in range(1, 5)}
+    )
+    requests["triple-self"] = CorrelatedRequest("triple-self", {})
+    for leg in (3, 4):
+        for pol, vectors in enumerate(transverse):
+            requests[f"pol{leg}-{pol}"] = CorrelatedRequest("born", {leg: vectors})
+        requests[f"ward{leg}"] = CorrelatedRequest(
+            "born", {leg: tuple(point[leg - 1] for point in points)}
+        )
+    for a in range(2):
+        for b in range(2):
+            requests[f"joint-{a}{b}"] = CorrelatedRequest(
+                "born", {3: transverse[a], 4: transverse[b]}
+            )
+    requests["joint-ward"] = CorrelatedRequest(
+        "born", {leg: tuple(point[leg - 1] for point in points) for leg in (3, 4)}
+    )
+    requests["mixed-ward"] = CorrelatedRequest(
+        "T13", {3: tuple(point[2] for point in points), 4: transverse[0]}
+    )
+    complex_vectors = {
+        leg: tuple(
+            tuple(complex(x, y) for x, y in zip(first, second, strict=True))
+            for first, second in zip(transverse[0], transverse[1], strict=True)
+        )
+        for leg in (3, 4)
+    }
+    requests["complex-forward"] = CorrelatedRequest("forward", complex_vectors)
+    requests["complex-reverse"] = CorrelatedRequest("reverse", complex_vectors)
+    runtime = Runtime.load(output, process="gg")
+    oracle = runtime.evaluate_correlated_many(points, requests, precision=45)
+    return output, points, requests, oracle
+
+
+def _write_physics_input(path, points, requests):
+    lines = [f"{len(points)} {len(points[0])} {len(requests)}"]
+    lines.append(
+        " ".join(str(value) for point in points for leg in point for value in leg)
+    )
+    for request in requests.values():
+        vectors = request.spin_vectors or {}
+        lines.append(f"{request.color_correlation} {len(vectors)}")
+        for leg, batch in vectors.items():
+            lines.append(str(leg))
+            for vector in batch:
+                for component in vector:
+                    number = complex(component)
+                    lines.append(f"{number.real:.17g} {number.imag:.17g}")
+    path.write_text("\n".join(lines) + "\n")
+
+
+@pytest.mark.parametrize("language", ("c", "cpp", "fortran", "rust"))
+def test_all_native_sdks_colour_coherence_and_joint_spin_physics(
+    language, native_sdk, correlated_physics_output, tmp_path
+):
+    output, points, requests, oracle = correlated_physics_output
+    binary = _compile_probe(language, _PHYSICS_PROBES[language], native_sdk, tmp_path)
+    input_path = tmp_path / "requests.txt"
+    _write_physics_input(input_path, points, requests)
+    run = subprocess.run(
+        [str(binary), str(output), "gg", str(input_path)],
+        capture_output=True,
+        text=True,
+        env=_source_environment(),
+        timeout=90,
+    )
+    assert run.returncode == 0, run.stdout + run.stderr
+    labels = tuple(requests)
+    measured = {}
+    for line in run.stdout.splitlines():
+        if line.startswith("VALUE "):
+            _, request, point, real, imag = line.split()
+            key = (labels[int(request)], int(point))
+            assert key not in measured
+            measured[key] = complex(float(real), float(imag))
+    assert set(measured) == {(label, point) for label in labels for point in range(2)}
+    for point in range(2):
+        born = measured["born", point]
+        assert born.real > 0
+        assert abs(born.imag) < born.real * 1e-12
+        assert measured["T11", point] == pytest.approx(3 * born, rel=2e-10)
+        assert (
+            abs(sum(measured[f"T1{leg}", point] for leg in range(1, 5)))
+            < abs(born) * 2e-10
+        )
+        assert measured["triple-self", point] == pytest.approx(27 * born, rel=2e-10)
+        for leg in (3, 4):
+            assert sum(
+                measured[f"pol{leg}-{pol}", point] for pol in range(2)
+            ) == pytest.approx(born, rel=2e-10)
+            assert abs(measured[f"ward{leg}", point]) < abs(born) * 1e-15 * 1e6
+        assert sum(
+            measured[f"joint-{a}{b}", point] for a in range(2) for b in range(2)
+        ) == pytest.approx(born, rel=2e-10)
+        assert abs(measured["joint-ward", point]) < abs(born) * 1e-15 * 1e12
+        assert abs(measured["mixed-ward", point]) < abs(born) * 1e-15 * 1e6
+        assert measured["complex-reverse", point] == pytest.approx(
+            measured["complex-forward", point].conjugate(),
+            rel=2e-10,
+            abs=abs(born) * 1e-12,
+        )
+        for label in labels:
+            value = measured[label, point]
+            assert math.isfinite(value.real) and math.isfinite(value.imag)
+            if "ward" not in label:
+                assert value == pytest.approx(
+                    complex(oracle[label][point]), rel=2e-10, abs=abs(born) * 1e-12
+                )
+
+
+@pytest.fixture(scope="module")
+def directed_complex_requests(correlated_output):
+    output, _, accuracy = correlated_output
+    runtime = Runtime.load(output, process="dd_ddg")
+    vectors = {
+        5: ((1 + 2j, 3 - 4j, 5 + 7j, -2 + 3j), (2 - 1j, -4 + 3j, 7 - 5j, 3 + 2j))
+    }
+    requests = {
+        "forward": CorrelatedRequest("ordered", vectors),
+        "reverse": CorrelatedRequest("ordered-reverse", vectors),
+    }
+    oracle = runtime.evaluate_correlated_many(_POINTS, requests, precision=45)
+    return output, requests, oracle, accuracy
+
+
+@pytest.mark.parametrize("language", ("c", "cpp", "fortran", "rust"))
+def test_native_directed_complex_insertion_and_reverse(
+    language, native_sdk, directed_complex_requests, tmp_path
+):
+    output, requests, oracle, accuracy = directed_complex_requests
+    # A genuinely nonzero imaginary part prevents a real-only reducer from
+    # passing the conjugacy check vacuously.
+    if accuracy == "lc":
+        # This ordering starts beyond leading colour; LC must not promote it.
+        assert all(complex(value) == 0 for value in oracle["forward"])
+    else:
+        assert any(
+            abs(complex(value).imag) > abs(complex(value)) * 1e-5
+            for value in oracle["forward"]
+        )
+    binary = _compile_probe(language, _PHYSICS_PROBES[language], native_sdk, tmp_path)
+    input_path = tmp_path / "directed-requests.txt"
+    _write_physics_input(input_path, _POINTS, requests)
+    run = subprocess.run(
+        [str(binary), str(output), "dd_ddg", str(input_path)],
+        capture_output=True,
+        text=True,
+        env=_source_environment(),
+        timeout=90,
+    )
+    assert run.returncode == 0, run.stdout + run.stderr
+    measured = {}
+    for line in run.stdout.splitlines():
+        if line.startswith("VALUE "):
+            _, request, point, real, imag = line.split()
+            measured[int(request), int(point)] = complex(float(real), float(imag))
+    assert set(measured) == {
+        (request, point) for request in range(2) for point in range(2)
+    }
+    for point in range(2):
+        for request, label in enumerate(requests):
+            assert measured[request, point] == pytest.approx(
+                complex(oracle[label][point]), rel=2e-10
+            )
+        assert measured[1, point] == pytest.approx(
+            measured[0, point].conjugate(), rel=2e-10
+        )
diff --git a/pyamplicol/tests/integration/test_correlator_colour_accuracy.py b/pyamplicol/tests/integration/test_correlator_colour_accuracy.py
new file mode 100644
index 0000000000..4e8cd1b456
--- /dev/null
+++ b/pyamplicol/tests/integration/test_correlator_colour_accuracy.py
@@ -0,0 +1,104 @@
+# SPDX-License-Identifier: 0BSD
+"""Inherited LC/NLC Born results from independently generated ordinary artifacts."""
+
+from decimal import Decimal, localcontext
+
+import pytest
+
+from pyamplicol import (
+    ColorCorrelator,
+    CorrelatorConfig,
+    Generator,
+    ModelSource,
+    Runtime,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+
+_POINT = (
+    (500, 0, 0, 500),
+    (500, 0, 0, -500),
+    (500, 300, 0, 400),
+    (500, -300, 0, -400),
+)
+_THREE_BODY_POINT = (
+    (900, 0, 0, 900),
+    (900, 0, 0, -900),
+    (500, 400, 300, 0),
+    (500, 400, -300, 0),
+    (800, -800, 0, 0),
+)
+
+
+def _configuration(accuracy):
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=accuracy, contraction="direct"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="compiled",
+            optimization=EvaluatorOptimizationConfig(cores=1, horner_iterations=1),
+            jit=JITConfig(optimization_level=0),
+        ),
+    )
+
+
+@pytest.mark.parametrize("accuracy", ("lc", "nlc"))
+@pytest.mark.parametrize(
+    ("expression", "point"),
+    (
+        ("g g > g g", _POINT),
+        ("d d~ > g g", _POINT),
+        ("d d~ > u u~", _POINT),
+        ("d d~ > d d~", _POINT),
+        ("d d~ > u u~ g", _THREE_BODY_POINT),
+        ("d d~ > d d~ g", _THREE_BODY_POINT),
+    ),
+    ids=(
+        "gluons",
+        "one-quark-pair",
+        "two-quark-pairs",
+        "identical-quarks",
+        "two-pairs-and-gluon",
+        "identical-pairs-and-gluon",
+    ),
+)
+def test_generated_correlated_born_matches_inherited_accuracy(
+    tmp_path, expression, point, accuracy
+):
+    pytest.importorskip("pyamplicol._rusticol")
+    config = _configuration(accuracy)
+    model = ModelSource.built_in_sm()
+    ordinary_path = tmp_path / "ordinary"
+    correlated_path = tmp_path / "correlated"
+    Generator(config).generate(expression, ordinary_path, model=model)
+    Generator(config).generate(
+        expression,
+        correlated_path,
+        model=model,
+        correlators=CorrelatorConfig(
+            color_correlations=(ColorCorrelator.dipole("T11", 1, 1),)
+        ),
+    )
+    ordinary = Runtime.load(ordinary_path).evaluate((point,), precision=36)[0]
+    correlated = Runtime.load(correlated_path).evaluate_correlated(
+        (point,), precision=32
+    )[0]
+    with localcontext() as context:
+        context.prec = 40
+        assert ordinary > 0
+        assert abs(correlated.real / ordinary - 1) < Decimal("1e-27")
+        assert abs(correlated.imag / ordinary) < Decimal("1e-27")
diff --git a/pyamplicol/tests/integration/test_correlators.py b/pyamplicol/tests/integration/test_correlators.py
new file mode 100644
index 0000000000..423f9452b0
--- /dev/null
+++ b/pyamplicol/tests/integration/test_correlators.py
@@ -0,0 +1,415 @@
+# SPDX-License-Identifier: 0BSD
+"""Generated tree amplitudes: Ward identities, Born recovery and colour coherence."""
+
+from decimal import Decimal, localcontext
+
+import pytest
+
+from pyamplicol import (
+    ColorCorrelator,
+    CorrelatedRequest,
+    CorrelatorConfig,
+    EmitGluon,
+    Generator,
+    ModelSource,
+    Runtime,
+    SplitGluon,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+
+POINT = (
+    (500, 0, 0, 500),
+    (500, 0, 0, -500),
+    (500, 300, 0, 400),
+    (500, -300, 0, -400),
+)
+THREE_BODY_POINT = (
+    (900, 0, 0, 900),
+    (900, 0, 0, -900),
+    (500, 400, 300, 0),
+    (500, 400, -300, 0),
+    (800, -800, 0, 0),
+)
+
+
+def _configuration():
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="full"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="compiled",
+            optimization=EvaluatorOptimizationConfig(cores=1, horner_iterations=1),
+            jit=JITConfig(optimization_level=0),
+        ),
+    )
+
+
+@pytest.fixture(scope="module")
+def correlated_gg(tmp_path_factory):
+    pytest.importorskip("pyamplicol._rusticol")
+    output = tmp_path_factory.mktemp("correlated-gg") / "process"
+    # Three successive physical colour charges on one adjoint line give C_A^3.
+    triple = tuple(EmitGluon(1, -i) for i in range(1, 4))
+    declarations = CorrelatorConfig(
+        color_correlations=(
+            *(ColorCorrelator.dipole(f"T1{leg}", 1, leg) for leg in range(1, 5)),
+            ColorCorrelator("triple-self", triple, triple),
+        ),
+        spin_correlations=((1,), (3,), (1, 3)),
+    )
+    Generator(_configuration()).generate(
+        "g g > g g", output, model=ModelSource.built_in_sm(), correlators=declarations
+    )
+    return output
+
+
+def _value(runtime, **kwargs):
+    return runtime.evaluate_correlated((POINT,), precision=32, **kwargs)[0]
+
+
+def test_generated_automatic_nnlo_catalogue_all_operators_in_one_point_batch(tmp_path):
+    pytest.importorskip("pyamplicol._rusticol")
+    output = tmp_path / "automatic-pair"
+    manual = ColorCorrelator.dipole("manual-T34", 3, 4)
+    Generator(_configuration()).generate(
+        "e+ e- > d d~",
+        output,
+        model=ModelSource.built_in_sm(),
+        correlators=CorrelatorConfig(
+            color_correlations=(manual,), all_color_through_order=2
+        ),
+    )
+    runtime = Runtime.load(output)
+    catalogue = runtime.available_color_correlations()
+    # Two coloured hard legs: 4 NLO + 108 NNLO, identity, and one manual alias.
+    assert len(catalogue) == 114
+    assert sum(item.order == 2 for item in catalogue) == 108
+    assert not hasattr(runtime, "_correlated_evaluator")
+    automatic = {
+        (item.bra, item.ket): item for item in catalogue if item.id.startswith("N")
+    }
+    alias = automatic[(manual.bra, manual.ket)]
+    points = (
+        POINT,
+        (POINT[0], POINT[1], (500, 400, 0, 300), (500, -400, 0, -300)),
+    )
+    requests = {item.id: CorrelatedRequest(item.id, {}) for item in catalogue}
+    values = runtime.evaluate_correlated_many(points, requests, precision=40)
+    assert tuple(values) == tuple(requests)
+    assert all(len(batch) == 2 for batch in values.values())
+    assert values[manual.id] == values[alias.id]
+    assert values["born"][0] != values["born"][1]
+    ordinary = runtime.evaluate(points, precision=40)
+    pair = next(
+        item
+        for item in catalogue
+        if item.order == 2
+        and item.bra == item.ket
+        and isinstance(item.bra[0], EmitGluon)
+        and item.bra[0].emitter_label == 3
+        and isinstance(item.bra[1], SplitGluon)
+    )
+    with localcontext() as context:
+        context.prec = 50
+        for point_index, born in enumerate(values["born"]):
+            tolerance = abs(born.real) * Decimal("1e-35")
+            assert born.real > 0
+            assert abs(born.real - ordinary[point_index]) < tolerance
+            # A quark emitter followed by g→q qbar gives C_F T_R = 2/3,
+            # with neither an additional flavour sum nor extra kinematics.
+            assert (
+                abs(values[pair.id][point_index].real - born.real * 2 / 3) < tolerance
+            )
+            assert (
+                abs(values[manual.id][point_index].real + born.real * 4 / 3) < tolerance
+            )
+            for (bra, ket), item in automatic.items():
+                partner = automatic[(ket, bra)]
+                left, right = (
+                    values[item.id][point_index],
+                    values[partner.id][point_index],
+                )
+                assert abs(left.real - right.real) < tolerance
+                assert abs(left.imag + right.imag) < tolerance
+
+
+def test_generated_many_colour_spin_and_point_axes_match_separate_calls(correlated_gg):
+    runtime = Runtime.load(correlated_gg)
+    runtime.set_spin_correlation_vectors({1: (0, 1, 0, 0)})
+    points = (
+        POINT,
+        (POINT[0], POINT[1], (500, 400, 0, 300), (500, -400, 0, -300)),
+    )
+    vectors = {3: ((0, 0, 1, 0), (0, 0, 2, 0))}
+    requests = {
+        "born": CorrelatedRequest("born", {}),
+        **{f"dipole1{leg}": CorrelatedRequest(f"T1{leg}", {}) for leg in range(1, 5)},
+        "spin-born": CorrelatedRequest("born", vectors),
+        "spin-dipole13": CorrelatedRequest("T13", vectors),
+        "inherited-spin": CorrelatedRequest("born"),
+    }
+    combined = runtime.evaluate_correlated_many(points, requests, precision=40)
+    reference = Runtime.load(correlated_gg)
+    for label, request in requests.items():
+        reference.set_spin_correlation_vectors(
+            {1: (0, 1, 0, 0)} if request.spin_vectors is None else request.spin_vectors
+        )
+        expected = reference.evaluate_correlated(
+            points, color_correlation=request.color_correlation, precision=40
+        )
+        assert combined[label] == expected
+        assert len(combined[label]) == 2
+    assert tuple(combined) == tuple(requests)
+    assert combined["spin-dipole13"][0] != combined["spin-dipole13"][1]
+    assert (
+        runtime.evaluate_correlated(points, precision=40) == combined["inherited-spin"]
+    )
+
+
+def test_generated_arb_preserves_decimal_spin_vectors_in_single_and_many_calls(
+    correlated_gg,
+):
+    runtime = Runtime.load(correlated_gg)
+    first = Decimal("1.00000000000000000000000000000000000000000000000001")
+    second = Decimal("1.00000000000000000000000000000000000000000000000002")
+    zero = Decimal(0)
+    vector = [zero, zero, first, zero]
+    points = (
+        POINT,
+        (POINT[0], POINT[1], (500, 400, 0, 300), (500, -400, 0, -300)),
+    )
+    runtime.set_spin_correlation_vectors({3: vector})
+    vector[2] = second  # The setter owns a copy, without rounding its Decimals.
+    single = runtime.evaluate_correlated(points, precision=100)
+    combined = runtime.evaluate_correlated_many(
+        points,
+        {
+            "inherited": CorrelatedRequest(),
+            "same-broadcast": CorrelatedRequest(
+                spin_vectors={3: (zero, zero, first, zero)}
+            ),
+            "per-point": CorrelatedRequest(
+                spin_vectors={
+                    3: ((zero, zero, first, zero), (zero, zero, second, zero))
+                }
+            ),
+            "unit": CorrelatedRequest(spin_vectors={3: (zero, zero, Decimal(1), zero)}),
+        },
+        precision=100,
+    )
+    assert single == combined["inherited"] == combined["same-broadcast"]
+    assert combined["per-point"][0] == single[0]
+    assert combined["per-point"][1] != single[1]
+    with localcontext() as context:
+        context.prec = 110
+        for index, scale in enumerate((first, second)):
+            unit = combined["unit"][index].real
+            assert unit > 0
+            assert abs(single[index].real / unit - first**2) < Decimal("1e-90")
+            assert abs(combined["per-point"][index].real / unit - scale**2) < Decimal(
+                "1e-90"
+            )
+            assert single[index].real != unit
+
+
+def test_generated_double_double_decimal_spin_and_ward_identities(correlated_gg):
+    runtime = Runtime.load(correlated_gg)
+    first = Decimal("1.0000000000000000000000001")
+    second = Decimal("1.0000000000000000000000002")
+    zero = Decimal(0)
+    points = (POINT, POINT)
+    runtime.set_spin_correlation_vectors({3: (zero, zero, first, zero)})
+    before = runtime.evaluate_correlated(points, precision=70)
+    single = runtime.evaluate_correlated(
+        points, arithmetic="double-double", precision=31
+    )
+    grouped = runtime.evaluate_correlated_many(
+        points,
+        {
+            "inherited": CorrelatedRequest(),
+            "unit": CorrelatedRequest(spin_vectors={3: (0, 0, 1, 0)}),
+            "pointwise": CorrelatedRequest(
+                spin_vectors={3: ((0, 0, first, 0), (0, 0, second, 0))}
+            ),
+            "complex": CorrelatedRequest(spin_vectors={3: (0, 0, (zero, first), 0)}),
+            "ward": CorrelatedRequest(
+                spin_vectors={3: tuple(Decimal(value) for value in POINT[2])}
+            ),
+        },
+        arithmetic="double-double",
+        precision=31,
+    )
+    assert single == grouped["inherited"] == grouped["complex"]
+    assert grouped["pointwise"][0] == single[0]
+    assert grouped["pointwise"][1] != single[1]
+    with localcontext() as context:
+        context.prec = 80
+        for index, scale in enumerate((first, second)):
+            unit = grouped["unit"][index].real
+            assert abs(single[index].real / unit - first**2) < Decimal("1e-28")
+            assert abs(grouped["pointwise"][index].real / unit - scale**2) < Decimal(
+                "1e-28"
+            )
+            assert abs(grouped["ward"][index].real / unit) < Decimal("1e-48")
+            assert abs(single[index].real / before[index].real - 1) < Decimal("1e-28")
+    assert runtime.evaluate_correlated(points, precision=70) == before
+
+
+def test_generated_born_recovery_and_n3lo_colour_coherence(correlated_gg):
+    runtime = Runtime.load(correlated_gg)
+    born = _value(runtime)
+    ordinary = runtime.evaluate((POINT,), precision=40)[0]
+    with localcontext() as context:
+        context.prec = 40
+        assert ordinary > 0
+        assert abs(born.real / ordinary - 1) < Decimal("1e-28")
+        assert abs(born.imag / ordinary) < Decimal("1e-28")
+        dipoles = [_value(runtime, color_correlation=f"T1{leg}") for leg in range(1, 5)]
+        assert abs(dipoles[0].real / born.real - 3) < Decimal("1e-28")
+        assert abs(sum(item.real for item in dipoles) / born.real) < Decimal("1e-28")
+        assert abs(sum(item.imag for item in dipoles) / born.real) < Decimal("1e-28")
+        triple = _value(runtime, color_correlation="triple-self")
+        assert abs(triple.real / born.real - 27) < Decimal("1e-28")
+
+
+@pytest.mark.parametrize("legs", ((1,), (3,), (1, 3)))
+def test_generated_single_and_joint_ward_identities(correlated_gg, legs):
+    runtime = Runtime.load(correlated_gg)
+    born = _value(runtime).real
+    runtime.set_spin_correlation_vectors({leg: POINT[leg - 1] for leg in legs})
+    for identifier in ("born", "T13"):
+        ward = _value(runtime, color_correlation=identifier)
+        # Compensate the dimensionful magnitude of each substituted momentum.
+        scale = born * Decimal(500) ** (2 * len(legs))
+        assert abs(ward.real / scale) < Decimal("1e-28")
+        assert abs(ward.imag / scale) < Decimal("1e-28")
+    runtime.set_spin_correlation_vectors(None)
+    assert _value(runtime).real == born
+
+
+def test_generated_polarization_completeness_and_vector_homogeneity(correlated_gg):
+    runtime = Runtime.load(correlated_gg)
+    born = _value(runtime).real
+    # For outgoing p=(500,300,0,400), these form a real transverse basis.
+    polarizations = ((0, Decimal("0.8"), 0, Decimal("-0.6")), (0, 0, 1, 0))
+    with localcontext() as context:
+        context.prec = 40
+        projections = []
+        for vector in polarizations:
+            runtime.set_spin_correlation_vectors({3: vector})
+            projections.append(_value(runtime).real)
+        assert abs(sum(projections) / born - 1) < Decimal("1e-28")
+        runtime.set_spin_correlation_vectors({3: (0, 0, 2j, 0)})
+        assert abs(_value(runtime).real / projections[1] - 4) < Decimal("1e-28")
+        runtime.set_spin_correlation_vectors({3: list(polarizations)})
+        batch = runtime.evaluate_correlated((POINT, POINT), precision=32)
+        assert tuple(item.real for item in batch) == tuple(projections)
+
+
+@pytest.fixture(
+    scope="module",
+    params=(
+        (
+            "d d~ > g g",
+            POINT,
+            (3, 4),
+            3,
+            ((0, Decimal("0.8"), 0, Decimal("-0.6")), (0, 0, 1, 0)),
+        ),
+        (
+            "d g > d g",
+            POINT,
+            (2, 4),
+            2,
+            ((0, 1, 0, 0), (0, 0, 1, 0)),
+        ),
+        (
+            "d d~ > u u~ g",
+            THREE_BODY_POINT,
+            (5,),
+            5,
+            ((0, 0, 1, 0), (0, 0, 0, 1)),
+        ),
+    ),
+    ids=("quark-annihilation", "crossed-quark-gluon", "two-quark-lines"),
+)
+def correlated_quarks(request, tmp_path_factory):
+    pytest.importorskip("pyamplicol._rusticol")
+    expression, point, gluons, projected_leg, polarizations = request.param
+    output = tmp_path_factory.mktemp("correlated-quarks") / "process"
+    declarations = CorrelatorConfig(
+        color_correlations=tuple(
+            ColorCorrelator.dipole(f"T1{leg}", 1, leg)
+            for leg in range(1, len(point) + 1)
+        ),
+        spin_correlations=tuple((leg,) for leg in gluons),
+    )
+    Generator(_configuration()).generate(
+        expression,
+        output,
+        model=ModelSource.built_in_sm(),
+        correlators=declarations,
+    )
+    return output, point, gluons, projected_leg, polarizations
+
+
+def test_generated_quark_born_and_colour_coherence(correlated_quarks):
+    output, point, _gluons, _projected_leg, _polarizations = correlated_quarks
+    runtime = Runtime.load(output)
+    born = runtime.evaluate_correlated((point,), precision=32)[0]
+    ordinary = runtime.evaluate((point,), precision=40)[0]
+    with localcontext() as context:
+        context.prec = 40
+        assert ordinary > 0
+        assert abs(born.real / ordinary - 1) < Decimal("1e-28")
+        assert abs(born.imag / ordinary) < Decimal("1e-28")
+        dipoles = [
+            runtime.evaluate_correlated(
+                (point,), color_correlation=f"T1{leg}", precision=32
+            )[0]
+            for leg in range(1, len(point) + 1)
+        ]
+        assert abs(dipoles[0].real / born.real - Decimal(4) / 3) < Decimal("1e-28")
+        assert abs(sum(item.real for item in dipoles) / born.real) < Decimal("1e-28")
+        assert abs(sum(item.imag for item in dipoles) / born.real) < Decimal("1e-28")
+
+
+def test_generated_quark_ward_and_polarization_completeness(correlated_quarks):
+    output, point, gluons, projected_leg, polarizations = correlated_quarks
+    runtime = Runtime.load(output)
+    born = runtime.evaluate_correlated((point,), precision=32)[0].real
+    with localcontext() as context:
+        context.prec = 40
+        for leg in gluons:
+            runtime.set_spin_correlation_vectors({leg: point[leg - 1]})
+            scale = born * Decimal(point[leg - 1][0]) ** 2
+            for identifier in ("born", f"T1{leg}"):
+                ward = runtime.evaluate_correlated(
+                    (point,), color_correlation=identifier, precision=32
+                )[0]
+                assert abs(ward.real / scale) < Decimal("1e-28")
+                assert abs(ward.imag / scale) < Decimal("1e-28")
+        projections = []
+        for vector in polarizations:
+            runtime.set_spin_correlation_vectors({projected_leg: vector})
+            projections.append(
+                runtime.evaluate_correlated((point,), precision=32)[0].real
+            )
+        assert abs(sum(projections) / born - 1) < Decimal("1e-28")
+    runtime.set_spin_correlation_vectors(None)
+    assert runtime.evaluate_correlated((point,), precision=32)[0].real == born
diff --git a/pyamplicol/tests/integration/test_eager_direct_append.py b/pyamplicol/tests/integration/test_eager_direct_append.py
new file mode 100644
index 0000000000..76bce84759
--- /dev/null
+++ b/pyamplicol/tests/integration/test_eager_direct_append.py
@@ -0,0 +1,129 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib.util
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+import pyamplicol.generation.service as generation_service
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.config import (
+    Action,
+    EvaluatorConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+
+
+def test_compiled_append_preserves_existing_direct_eager_process(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    # A stale developer environment must never revive the removed plan-v2
+    # writer. Eager generation is unconditionally plan-v3.
+    monkeypatch.setenv("PYAMPLICOL_EAGER_PLAN_VERSION", "v2")
+    eager_evaluator = EvaluatorConfig(
+        execution_mode="eager",
+        jit=JITConfig(optimization_level=0),
+    )
+    prepared = ModelSource.built_in_sm().compile(
+        use_cache=True,
+        cache_dir=tmp_path / "model-cache",
+        prepared_output=tmp_path / "built-in-sm-jit-o0.pyamplicol-model",
+        evaluator=eager_evaluator,
+    )
+    generation = GenerationConfig(
+        emit_api_bundle=False,
+        validation=GenerationValidationConfig(
+            enabled=False,
+            post_build_validation=False,
+        ),
+    )
+    artifact = tmp_path / "artifact"
+    initial_configuration: list[object] = []
+    write_artifact = generation_service.write_schema_v3_artifact
+
+    def write_with_initial_configuration(*args: Any, **kwargs: Any) -> Any:
+        if kwargs["mode"] == "error":
+            initial_configuration.append(kwargs["configuration"])
+        else:
+            # This is a writer-layer heterogeneous-append regression. Public
+            # generation normally partitions execution modes by requested
+            # configuration, so retain the exact initial provenance here to
+            # exercise the union pack rewrite itself.
+            kwargs["configuration"] = initial_configuration[0]
+        return write_artifact(*args, **kwargs)
+
+    monkeypatch.setattr(
+        generation_service,
+        "write_schema_v3_artifact",
+        write_with_initial_configuration,
+    )
+    Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            generation=generation,
+            evaluator=eager_evaluator,
+        )
+    ).generate("d d~ > z", artifact, model=prepared)
+
+    original_manifest = load_manifest(artifact)
+    original_process_id = str(original_manifest.processes[0]["id"])
+    original_execution = json.loads(
+        (artifact / f"processes/{original_process_id}/execution.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    assert original_execution["eager_plan_abi"] == "pyamplicol-eager-plan-v3"
+    assert original_execution["required_runtime_capabilities"] == [
+        "eager-direct-arena-v1",
+        "rusticol.eager-runtime-layout.complex-f64.v1",
+    ]
+    point = (
+        (45.594, 0.0, 0.0, 45.594),
+        (45.594, 0.0, 0.0, -45.594),
+        (91.188, 0.0, 0.0, 0.0),
+    )
+    before = Runtime.load(artifact, process=original_process_id).evaluate((point,))[0]
+
+    Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            generation=generation,
+            evaluator=EvaluatorConfig(
+                execution_mode="compiled",
+                # The existing eager artifact is portable-64le. Keep the
+                # appended compiled evaluator inside the same canonical
+                # portable O1/O2 target contract; this regression is about
+                # heterogeneous eager/compiled pack preservation, not a
+                # target transition.
+                jit=JITConfig(optimization_level=2),
+            ),
+        )
+    ).generate("u u~ > z", artifact, model=prepared, mode="append")
+
+    after = Runtime.load(artifact, process=original_process_id).evaluate((point,))[0]
+    assert after == pytest.approx(before, rel=1.0e-12, abs=1.0e-15)
+
+    appended_manifest = load_manifest(artifact)
+    assert {
+        "eager-direct-arena-v1",
+        "rusticol.eager-runtime-layout.complex-f64.v1",
+    }.issubset(appended_manifest.runtime["required_runtime_capabilities"])
+    kernel_pack = json.loads(
+        (artifact / "model/eager-kernel-pack.json").read_text(encoding="utf-8")
+    )
+    assert kernel_pack["kernels"]
+    assert all(
+        "direct_table" in kernel["f64_evaluator_manifest"]
+        for kernel in kernel_pack["kernels"]
+    )
diff --git a/pyamplicol/tests/integration/test_exact_precision_normalization.py b/pyamplicol/tests/integration/test_exact_precision_normalization.py
new file mode 100644
index 0000000000..0f9654f4cb
--- /dev/null
+++ b/pyamplicol/tests/integration/test_exact_precision_normalization.py
@@ -0,0 +1,112 @@
+# SPDX-License-Identifier: 0BSD
+"""Physical precision regression, including the full-colour normalization."""
+
+from __future__ import annotations
+
+import importlib.util
+from decimal import Decimal, localcontext
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+
+
+def _exact_frames():
+    with localcontext() as context:
+        context.prec = 120
+        point = [
+            [Decimal(x) for x in p]
+            for p in (
+                (500, 0, 0, 500),
+                (500, 0, 0, -500),
+                (500, 300, 0, 400),
+                (500, -300, 0, -400),
+            )
+        ]
+        axis = [Decimal(x) / 7 for x in (2, 3, 6)]
+        beta, gamma = Decimal(3) / 5, Decimal(5) / 4
+        boosted = []
+        for p in point:
+            longitudinal = sum(
+                (x * n for x, n in zip(p[1:], axis, strict=True)), Decimal(0)
+            )
+            shift = (gamma - 1) * longitudinal + gamma * beta * p[0]
+            boosted.append(
+                [gamma * (p[0] + beta * longitudinal)]
+                + [x + shift * n for x, n in zip(p[1:], axis, strict=True)]
+            )
+        return [point, boosted]
+
+
+@pytest.mark.parametrize("execution_mode", ("recurrence", "eager", "compiled"))
+@pytest.mark.parametrize("color_accuracy", ("lc", "full"))
+def test_gg_helicity_sum_has_consistent_normalization_and_precision(
+    tmp_path,
+    execution_mode,
+    color_accuracy,
+):
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=color_accuracy),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=execution_mode,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+    output = tmp_path / "gg"
+    Generator(config).generate("g g > g g", output, model=ModelSource.built_in_sm())
+    runtime = Runtime.load(
+        output,
+        model_parameters={"normalization.alpha_s_me_check": 0.125},
+    )
+    frames = _exact_frames()
+    native_frames = [[[float(x) for x in p] for p in frame] for frame in frames]
+    native = runtime.evaluate(native_frames)
+    separate = [runtime.evaluate([frame])[0] for frame in native_frames]
+    assert native == pytest.approx(separate, rel=3e-13, abs=0)
+    exact = runtime.evaluate(frames, precision=80)
+    with localcontext() as context:
+        context.prec = 90
+        assert exact[0] > 0
+        assert abs(exact[0] - exact[1]) / abs(exact[0]) < Decimal("1e-70")
+        # In particular, full colour must not acquire the extra LC factor81.
+        for value, reference in zip(exact, native, strict=True):
+            assert float(value) == pytest.approx(reference.real, rel=3e-13, abs=0)
+
+    if execution_mode == "eager" and color_accuracy == "full":
+        # Exercise both the ordinary and profiled topology-replay gathers.
+        # Repeated points exposed an amplitude/point stride mix-up even when
+        # each separate evaluation and the arbitrary-precision path agreed.
+        for point_count in (2, 3, 65):
+            batch = [native_frames[(index // 2) % 2] for index in range(point_count)]
+            expected = [separate[(index // 2) % 2] for index in range(point_count)]
+            assert runtime.evaluate(batch) == pytest.approx(expected, rel=3e-13, abs=0)
+            resolved = runtime.evaluate_resolved(batch)
+            totals = [
+                sum(value for helicity in point for value in helicity)
+                for point in resolved.values
+            ]
+            assert totals == pytest.approx(expected, rel=3e-13, abs=0)
+            profiled = runtime._backend.profile(batch, include_values=True)
+            assert profiled["values"] == pytest.approx(expected, rel=3e-13, abs=0)
diff --git a/pyamplicol/tests/integration/test_examples.py b/pyamplicol/tests/integration/test_examples.py
new file mode 100644
index 0000000000..50c56c46b9
--- /dev/null
+++ b/pyamplicol/tests/integration/test_examples.py
@@ -0,0 +1,184 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import io
+import json
+import runpy
+import shutil
+import subprocess
+import sys
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.cli import parse_cli, run_cli
+from pyamplicol.config import ProcessEntry, RunConfig
+from pyamplicol.reporting import ProgressSink
+
+ROOT = Path(__file__).resolve().parents[2]
+EXAMPLES = ROOT / "examples"
+RUN_CARDS = tuple(sorted(EXAMPLES.glob("*.toml")))
+
+
+def _run_example(
+    script: Path, arguments: tuple[str, ...], cwd: Path
+) -> subprocess.CompletedProcess[str]:
+    # This test module already owns a Symbolica session through the public API.
+    # Run the exact script in that session, still from an unrelated directory;
+    # the serialized installed-wheel smoke covers independent Python processes.
+    command = [str(script), *arguments]
+    stdout, stderr = io.StringIO(), io.StringIO()
+    returncode = 0
+    with (
+        pytest.MonkeyPatch.context() as context,
+        redirect_stdout(stdout),
+        redirect_stderr(stderr),
+    ):
+        context.chdir(cwd)
+        context.setattr(sys, "argv", command)
+        try:
+            runpy.run_path(str(script), run_name="__main__")
+        except SystemExit as error:
+            if error.code is None or isinstance(error.code, int):
+                returncode = error.code or 0
+            else:
+                print(error.code, file=sys.stderr)
+                returncode = 1
+    return subprocess.CompletedProcess(
+        command, returncode, stdout.getvalue(), stderr.getvalue()
+    )
+
+
+class _RecordingServices:
+    def __init__(self) -> None:
+        self.config: RunConfig | None = None
+
+    def _record(self, config: RunConfig, progress: ProgressSink) -> object:
+        del progress
+        self.config = config
+        return {"action": config.action, "schema_version": config.schema_version}
+
+    generate = _record
+    plan = _record
+    evaluate = _record
+    benchmark = _record
+    inspect = _record
+    model_inspect = _record
+    model_compile = _record
+    model_processes = _record
+    group_processes = _record
+
+
+@pytest.mark.parametrize("card", RUN_CARDS, ids=lambda path: path.stem)
+def test_cards_cross_cli_resolution_and_typed_dispatch_without_running_work(
+    card: Path,
+) -> None:
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    services = _RecordingServices()
+    status = run_cli(
+        (str(card), "--progress", "off", "--json"),
+        services=services,
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 0, stderr.getvalue()
+    assert services.config is not None
+    assert json.loads(stdout.getvalue()) == {
+        "action": services.config.action,
+        "schema_version": 1,
+    }
+    assert stderr.getvalue() == ""
+
+
+def test_copied_card_rebases_relative_paths_to_user_directory(tmp_path: Path) -> None:
+    source = EXAMPLES / "evaluate_total.toml"
+    copied = tmp_path / source.name
+    shutil.copy2(source, copied)
+
+    config = parse_cli((str(copied),)).resolve().effective
+    assert config.evaluation.artifact == (tmp_path / "artifacts/pp_zjj")
+    assert config.evaluation.process == "d d~ > g z g"
+    assert config.evaluation.momenta == (tmp_path / "data/pp_zjj_momenta.json")
+    assert config.evaluation.model_parameters == (
+        tmp_path / "data/model_parameters.json"
+    )
+
+
+def test_direct_cli_example_resolves_process_set_and_ordered_override(
+    tmp_path: Path,
+) -> None:
+    invocation = parse_cli(
+        (
+            "generate",
+            "p p > Z j j",
+            str(tmp_path / "pp_zjj"),
+            "--model",
+            str(tmp_path / "models/json/sm/sm.json"),
+            "--restriction",
+            "default",
+            "--multiparticle",
+            "p=d,d~,g",
+            "--multiparticle",
+            "j=d,d~,g",
+            "--flavor-scheme",
+            "2",
+            "--max-quark-lines",
+            "2",
+            "--workers",
+            "4",
+            "--set",
+            "generation.workers=2",
+        )
+    )
+    config = invocation.resolve().effective
+    assert config.process.entries == (ProcessEntry("p p > Z j j"),)
+    assert config.process.multiparticles == {
+        "p": ("d", "d~", "g"),
+        "j": ("d", "d~", "g"),
+    }
+    assert config.process.flavor_scheme == 2
+    assert config.process.max_quark_lines == 2
+    assert config.model.restriction == "default"
+    assert config.color.accuracy == "lc"
+    assert config.generation.workers == 2
+
+
+@pytest.mark.parametrize(
+    "script",
+    tuple(sorted((EXAMPLES / "python").glob("*.py"))),
+    ids=lambda path: path.stem,
+)
+def test_python_examples_offer_help_without_running_generation(
+    script: Path,
+    tmp_path: Path,
+) -> None:
+    completed = _run_example(script, ("--help",), tmp_path)
+    assert completed.returncode == 0, completed.stderr
+    assert "usage:" in completed.stdout
+    assert "schema-v3 artifact writing" not in completed.stderr
+    assert "no pyAmpliCol backend" not in completed.stderr
+
+
+def test_packaged_model_helper_materializes_external_card_inputs(
+    tmp_path: Path,
+) -> None:
+    script = EXAMPLES / "python/copy_packaged_models.py"
+    completed = _run_example(script, (), tmp_path)
+    assert completed.returncode == 0, completed.stderr
+    assert Path(completed.stdout.strip()) == tmp_path / "models"
+
+    expected = (
+        tmp_path / "models/json/sm/sm.json",
+        tmp_path / "models/json/scalars/scalars.json",
+        tmp_path / "models/json/scalar_gravity/scalar_gravity.json",
+        tmp_path / "models/ufo/sm/vertices.py",
+    )
+    assert all(path.is_file() for path in expected)
+
+    copied_card = tmp_path / "generate_pp_zjj_from_ufo_sm.toml"
+    shutil.copy2(EXAMPLES / copied_card.name, copied_card)
+    config = parse_cli((str(copied_card),)).resolve().effective
+    assert Path(config.model.source).is_file()
diff --git a/pyamplicol/tests/integration/test_generalized_adjoint_fft_runtime.py b/pyamplicol/tests/integration/test_generalized_adjoint_fft_runtime.py
new file mode 100644
index 0000000000..f8bfd5fb5b
--- /dev/null
+++ b/pyamplicol/tests/integration/test_generalized_adjoint_fft_runtime.py
@@ -0,0 +1,241 @@
+# SPDX-License-Identifier: 0BSD
+"""HEFT singlet attachments retain exact helicity-resolved DDM contractions."""
+
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_HEFT_JIT_O2,
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from pyamplicol.models.builtin.validation import generic_validation_point
+from tests.integration.test_on_the_fly_runtime_capabilities import (
+    _require_native_on_the_fly,
+)
+
+
+@pytest.fixture(scope="module")
+def prepared_heft() -> Iterator[ModelSource]:
+    _require_native_on_the_fly()
+    with packaged_prepared_model_path(BUILTIN_SM_HEFT_JIT_O2) as path:
+        yield ModelSource.from_path(path)
+
+
+@pytest.fixture(scope="module")
+def prepared_sm() -> Iterator[ModelSource]:
+    _require_native_on_the_fly()
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as path:
+        yield ModelSource.from_path(path)
+
+
+def _configuration(
+    lane: str, basis: str, *, coupling_orders: dict[str, int] | None = None
+) -> RunConfig:
+    return RunConfig(
+        action="generate",
+        process=ProcessConfig(
+            coupling_order_policy="explicit" if coupling_orders else "minimal",
+            max_coupling_orders=coupling_orders or {},
+        ),
+        color=ColorConfig(
+            accuracy="full", contraction="symmetric-group-fft", fft_basis=basis
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=lane,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+def _assert_color_domain(artifact: Path, *, basis: str, gluons: int) -> None:
+    execution_paths = tuple((artifact / "processes").glob("*/execution.json"))
+    assert len(execution_paths) == 1
+    execution = json.loads(execution_paths[0].read_text(encoding="utf-8"))
+    color = execution["runtime_metadata"]["color_contraction"]
+    degree = gluons - (2 if basis == "adjoint" else 1)
+    # The singlet is not a third colour endpoint. This also detects silently
+    # retaining all trace words after an adjoint request.
+    assert color["sector_count"] == math.factorial(degree)
+    if "selector_policy" in execution:
+        assert execution["selector_policy"].get("color_basis", "trace") == basis
+    if degree >= 2:
+        assert color["storage"] == "convolution-kernels"
+        assert color["factorization"]["kind"] == "symmetric-group-fourier"
+        assert color["factorization"]["rank"] == degree
+        assert color["fft_provenance"]["residual_group_count"] == 0
+    # S_0 and S_1 contain only one element and legitimately use the direct
+    # scalar contraction rather than a nontrivial Fourier transform.
+    if basis == "adjoint":
+        selection = _basis_selection(artifact)
+        assert selection["requested"] == "adjoint"
+        assert selection["actual_basis"] == "adjoint"
+        assert selection["name"] == "ddm"
+        assert selection["tensor_count"] == math.factorial(degree)
+
+
+def _basis_selection(artifact: Path) -> dict[str, object]:
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    concrete = manifest["extensions"]["generation"]["concrete_processes"]
+    assert len(concrete) == 1
+    return concrete[0]["filters"]["fft_basis_selection"]
+
+
+@pytest.mark.parametrize("lane", ("recurrence", "on-the-fly"))
+@pytest.mark.parametrize("gluons", (2, 3, 4, 5))
+def test_single_insertion_heft_adjoint_matches_trace_for_every_helicity(
+    tmp_path: Path, prepared_heft: ModelSource, lane: str, gluons: int
+) -> None:
+    process = "g g > H" + " g" * (gluons - 2)
+    # The two-gluon process is on-shell 2->1 at sqrt(s)=MH. For larger
+    # multiplicities use two independent nonexceptional massive RAMBO points.
+    seeds = (101,) if gluons == 2 else (101, 203)
+    points = tuple(
+        tuple(tuple(float(x) for x in leg.momentum) for leg in point)
+        for point in (generic_validation_point(process, seed=seed) for seed in seeds)
+    )
+    runtimes = {}
+    try:
+        for basis in ("trace", "adjoint"):
+            artifact = tmp_path / basis
+            Generator(_configuration(lane, basis, coupling_orders={"HIG": 1})).generate(
+                process, artifact, model=prepared_heft
+            )
+            _assert_color_domain(artifact, basis=basis, gluons=gluons)
+            runtimes[basis] = Runtime.load(artifact)
+
+        resolved = {
+            basis: runtime.evaluate_resolved(points)
+            for basis, runtime in runtimes.items()
+        }
+        assert resolved["adjoint"].helicity_ids == resolved["trace"].helicity_ids
+        assert len(resolved["trace"].helicity_ids) == 2**gluons
+        totals = {
+            basis: tuple(complex(value) for value in runtime.evaluate(points))
+            for basis, runtime in runtimes.items()
+        }
+        for values in totals.values():
+            assert all(math.isfinite(value.real) and value.real > 0 for value in values)
+            assert all(abs(value.imag) < value.real * 1e-12 for value in values)
+        assert totals["adjoint"] == pytest.approx(totals["trace"], rel=2e-11)
+        for basis, result in resolved.items():
+            assert tuple(complex(value) for value in result.total()) == pytest.approx(
+                totals[basis], rel=2e-12
+            )
+        for index, (trace_point, adjoint_point) in enumerate(
+            zip(resolved["trace"].values, resolved["adjoint"].values, strict=True)
+        ):
+            trace_values = tuple(
+                complex(v) for helicity in trace_point for v in helicity
+            )
+            adjoint_values = tuple(
+                complex(v) for helicity in adjoint_point for v in helicity
+            )
+            assert any(abs(value) > 0 for value in trace_values)
+            assert adjoint_values == pytest.approx(
+                trace_values, rel=2e-11, abs=totals["trace"][index].real * 2e-13
+            )
+
+        if gluons == 4:
+            # Exercise parameter invalidation once per runtime lane, including
+            # the lowest process that contains the effective Hgggg contact.
+            for runtime in runtimes.values():
+                runtime.set_model_parameters({"aS": 0.13})
+            changed = {
+                basis: tuple(complex(value) for value in runtime.evaluate(points))
+                for basis, runtime in runtimes.items()
+            }
+            assert changed["trace"] != pytest.approx(totals["trace"], rel=1e-6)
+            assert changed["adjoint"] == pytest.approx(changed["trace"], rel=2e-11)
+    finally:
+        runtimes.clear()
+
+
+@pytest.mark.parametrize("lane", ("recurrence", "on-the-fly"))
+@pytest.mark.parametrize(
+    "process,strategy,coupling_orders",
+    (
+        ("d d~ > z g g", "fundamental-chain", None),
+        ("d d~ > d d~ g g", "fundamental-chain-products", {"QED": 0}),
+        ("e- e+ > mu- mu+", "singlet", None),
+    ),
+)
+def test_adaptive_adjoint_preserves_fundamental_and_singlet_amplitudes(
+    tmp_path: Path,
+    prepared_sm: ModelSource,
+    lane: str,
+    process: str,
+    strategy: str,
+    coupling_orders: dict[str, int] | None,
+) -> None:
+    points = tuple(
+        tuple(tuple(float(x) for x in leg.momentum) for leg in point)
+        for point in (
+            generic_validation_point(process, seed=seed) for seed in (101, 203)
+        )
+    )
+    evaluations = {}
+    for basis in ("trace", "adjoint"):
+        artifact = tmp_path / basis
+        Generator(
+            _configuration(lane, basis, coupling_orders=coupling_orders)
+        ).generate(process, artifact, model=prepared_sm)
+        if basis == "adjoint":
+            selection = _basis_selection(artifact)
+            assert selection["requested"] == "adjoint"
+            assert selection["actual_basis"] == "trace"
+            assert selection["name"] == strategy
+        runtime = Runtime.load(artifact)
+        try:
+            resolved = runtime.evaluate_resolved(points)
+            total = tuple(complex(value) for value in runtime.evaluate(points))
+            assert all(value.real > 0 and math.isfinite(value.real) for value in total)
+            assert tuple(complex(value) for value in resolved.total()) == pytest.approx(
+                total, rel=2e-12
+            )
+            evaluations[basis] = (
+                resolved.helicity_ids,
+                tuple(
+                    complex(value)
+                    for point in resolved.values
+                    for helicity in point
+                    for value in helicity
+                ),
+                total,
+            )
+        finally:
+            del runtime
+    assert evaluations["adjoint"][0] == evaluations["trace"][0]
+    assert evaluations["adjoint"][1] == pytest.approx(
+        evaluations["trace"][1], rel=2e-11, abs=1e-300
+    )
+    assert evaluations["adjoint"][2] == pytest.approx(
+        evaluations["trace"][2], rel=2e-11
+    )
diff --git a/pyamplicol/tests/integration/test_heft_correlated_precision.py b/pyamplicol/tests/integration/test_heft_correlated_precision.py
new file mode 100644
index 0000000000..a7be315a8e
--- /dev/null
+++ b/pyamplicol/tests/integration/test_heft_correlated_precision.py
@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: 0BSD
+"""HEFT contact currents retain gauge invariance in all arithmetic modes."""
+
+from __future__ import annotations
+
+from decimal import Decimal, localcontext
+
+import pytest
+
+from pyamplicol import (
+    CorrelatedRequest,
+    CorrelatorConfig,
+    Generator,
+    ModelSource,
+    Runtime,
+)
+from pyamplicol.api.models import _compiled_model_payload
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    RunConfig,
+)
+
+
+def test_reduced_heft_contacts_preserve_grouped_spin_ward_and_precision(tmp_path):
+    pytest.importorskip("pyamplicol._rusticol")
+    # H at rest and two back-to-back gluons. All entries are exact dyadics,
+    # including the 3/5--4/5 gluon direction, with MH=125 and sqrt(s)=500.
+    point = tuple(
+        tuple(Decimal(component) for component in momentum)
+        for momentum in (
+            ("250", "0", "0", "250"),
+            ("250", "0", "0", "-250"),
+            ("125", "0", "0", "0"),
+            ("187.5", "112.5", "0", "150"),
+            ("187.5", "-112.5", "0", "-150"),
+        )
+    )
+    points = (point, point)
+    # Compile model IR afresh, rather than silently testing an older shipped
+    # bundle: this is the smallest process containing the Hgggg contact.
+    model = ModelSource.built_in_sm_heft().compile(use_cache=False)
+    assert any(
+        particle.component_dimension == 6
+        and (particle.auxiliary_kind or "").startswith("ufo-heft-contact-tree:")
+        for particle in _compiled_model_payload(model).ir.particles
+    )
+    output = tmp_path / "heft-correlated"
+    Generator(
+        RunConfig(
+            action="generate",
+            color=ColorConfig(accuracy="full", contraction="direct"),
+            process=ProcessConfig(
+                coupling_order_policy="explicit", max_coupling_orders={"HIG": 1}
+            ),
+            generation=GenerationConfig(
+                workers=1,
+                emit_api_bundle=False,
+                validation=GenerationValidationConfig(
+                    enabled=False, post_build_validation=False
+                ),
+            ),
+            evaluator=EvaluatorConfig(
+                execution_mode="compiled",
+                optimization=EvaluatorOptimizationConfig(cores=1, horner_iterations=1),
+                jit=JITConfig(optimization_level=0),
+            ),
+        )
+    ).generate(
+        "g g > H g g",
+        output,
+        model=model,
+        correlators=CorrelatorConfig(spin_correlations=((1,), (4,), (1, 4))),
+    )
+    runtime = Runtime.load(output)
+    requests = {
+        "born": CorrelatedRequest(spin_vectors={}),
+        "transverse": CorrelatedRequest(spin_vectors={4: (0, 0, 1, 0)}),
+        "scaled": CorrelatedRequest(spin_vectors={4: (0, 0, Decimal(2), 0)}),
+        "ward-incoming": CorrelatedRequest(spin_vectors={1: point[0]}),
+        "ward-outgoing": CorrelatedRequest(spin_vectors={4: point[3]}),
+        "ward-joint": CorrelatedRequest(spin_vectors={1: point[0], 4: point[3]}),
+    }
+    oracle = runtime.evaluate_correlated_many(points, requests, precision=60)
+    ordinary = runtime.evaluate(points, precision=60)
+    double = runtime.evaluate_correlated_many(points, requests, precision=16)
+    double_double = runtime.evaluate_correlated_many(
+        points, requests, arithmetic="double-double", precision=31
+    )
+    with localcontext() as context:
+        context.prec = 80
+        for index in range(len(points)):
+            born = oracle["born"][index].real
+            assert born > 0
+            assert abs(ordinary[index] / born - 1) < Decimal("1e-50")
+            for values, accuracy, ward_accuracy in (
+                (double, Decimal("1e-11"), Decimal("1e-20")),
+                (double_double, Decimal("1e-25"), Decimal("1e-45")),
+                (oracle, Decimal("1e-50"), Decimal("1e-90")),
+            ):
+                assert tuple(values) == tuple(requests)
+                for name in ("born", "transverse", "scaled"):
+                    value = Decimal(values[name][index].real)
+                    expected = oracle[name][index].real
+                    assert expected > 0
+                    assert abs(value / expected - 1) < accuracy
+                    assert abs(Decimal(values[name][index].imag) / expected) < accuracy
+                transverse = Decimal(values["transverse"][index].real)
+                assert (
+                    abs(Decimal(values["scaled"][index].real) / transverse - 4)
+                    < accuracy
+                )
+                for name, momentum_scale in (
+                    ("ward-incoming", point[0][0]),
+                    ("ward-outgoing", point[3][0]),
+                    ("ward-joint", point[0][0] * point[3][0]),
+                ):
+                    # Ward amplitudes vanish: normalize their squared values
+                    # to Born times the dimensions of the substituted momenta.
+                    scale = born * momentum_scale**2
+                    value = values[name][index]
+                    assert abs(Decimal(value.real) / scale) < ward_accuracy
+                    assert abs(Decimal(value.imag) / scale) < ward_accuracy
diff --git a/pyamplicol/tests/integration/test_heft_madgraph_acceptance.py b/pyamplicol/tests/integration/test_heft_madgraph_acceptance.py
new file mode 100644
index 0000000000..b718f8840d
--- /dev/null
+++ b/pyamplicol/tests/integration/test_heft_madgraph_acceptance.py
@@ -0,0 +1,55 @@
+# SPDX-License-Identifier: 0BSD
+"""Environment-gated scalar HEFT comparison with MadGraph standalone."""
+
+from __future__ import annotations
+
+import math
+import os
+from pathlib import Path
+
+import pytest
+
+from tools.developer.heft_madgraph_acceptance import (
+    ABSOLUTE_TOLERANCE,
+    PROCESSES,
+    RELATIVE_TOLERANCE,
+    run_acceptance,
+)
+
+_RUN_ENV = "PYAMPLICOL_RUN_HEFT_MADGRAPH"
+_INSTALLATION_ENV = "PYAMPLICOL_MADGRAPH"
+
+pytestmark = pytest.mark.skipif(
+    os.environ.get(_RUN_ENV) != "1",
+    reason=f"set {_RUN_ENV}=1 and {_INSTALLATION_ENV} to run the live HEFT gate",
+)
+
+
+def test_scalar_heft_full_color_matches_madgraph(
+    tmp_path: Path,
+) -> None:
+    configured = os.environ.get(_INSTALLATION_ENV)
+    if not configured:
+        pytest.fail(f"{_INSTALLATION_ENV} must name the MadGraph installation")
+
+    result = run_acceptance(
+        Path(configured),
+        model_root=tmp_path / "heft-ufo",
+        output_root=tmp_path / "acceptance",
+    )
+
+    processes = result["processes"]
+    assert isinstance(processes, dict)
+    assert set(processes) == {spec.process_id for spec in PROCESSES}
+    for record in processes.values():
+        assert isinstance(record, dict)
+        pyamplicol_value = float(record["pyamplicol"])
+        madgraph_value = float(record["madgraph"])
+        assert math.isfinite(pyamplicol_value) and pyamplicol_value != 0.0
+        assert math.isfinite(madgraph_value) and madgraph_value != 0.0
+        assert math.isclose(
+            pyamplicol_value,
+            madgraph_value,
+            rel_tol=RELATIVE_TOLERANCE,
+            abs_tol=ABSOLUTE_TOLERANCE,
+        )
diff --git a/pyamplicol/tests/integration/test_lc_selected_flow_consistency.py b/pyamplicol/tests/integration/test_lc_selected_flow_consistency.py
new file mode 100644
index 0000000000..8d654685a5
--- /dev/null
+++ b/pyamplicol/tests/integration/test_lc_selected_flow_consistency.py
@@ -0,0 +1,1081 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib.util
+import json
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import (
+    CompiledModel,
+    Generator,
+    ModelSource,
+    ResolvedEvaluation,
+    Runtime,
+)
+from pyamplicol.artifacts import inspect_artifact
+from pyamplicol.color.plan import build_color_plan
+from pyamplicol.config import (
+    ColorConfig,
+    EagerEvaluatorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from pyamplicol.generation.phase_space import massive_rambo_final_state
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.builtin.validation import generic_validation_point
+
+_RECURRENCE_KIND = "pyamplicol-runtime-recurrence-execution"
+_RECURRENCE_PLAN_ABI = "pyamplicol-recurrence-plan-v2"
+_SM_MODEL_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+
+
+@pytest.fixture(scope="module")
+def ufo_sm_recurrence_jit_o2_model(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> CompiledModel:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+    if importlib.util.find_spec("symbolica") is None:
+        pytest.skip("Symbolica is unavailable")
+    root = tmp_path_factory.mktemp("lc-selected-flow-ufo-sm")
+    model = ModelSource.from_path(
+        _SM_MODEL_ROOT / "sm.json",
+        restriction=_SM_MODEL_ROOT / "restrict_default.json",
+    ).compile(
+        cache_dir=root / "model-cache",
+        use_cache=True,
+        prepared_output=root / "ufo-sm-jit-o2.pyamplicol-model",
+        evaluator=EvaluatorConfig(
+            execution_mode="recurrence",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+    assert model.is_prepared
+    assert model.prepared_backend == "jit"
+    return model
+
+
+def _model_for_kind(
+    model_kind: str,
+    request: pytest.FixtureRequest,
+) -> CompiledModel | None:
+    if model_kind == "built-in":
+        return None
+    model = request.getfixturevalue("ufo_sm_recurrence_jit_o2_model")
+    assert isinstance(model, CompiledModel)
+    return model
+
+
+@pytest.mark.parametrize(
+    ("process", "flow_word", "final_masses"),
+    (
+        ("g g > g g", (1, 2, 3, 4), (0.0, 0.0)),
+        ("g g > t t~", (3, 1, 2, 4), (173.0, 173.0)),
+        ("d d~ > t t~", (2, 1, 3, 4), (173.0, 173.0)),
+        ("d d~ > u u~ s s~", (2, 1, 3, 4, 5, 6), (0.0, 0.0, 0.0, 0.0)),
+    ),
+)
+def test_selected_lc_artifact_matches_complete_artifact_physical_flow(
+    tmp_path: Path,
+    process: str,
+    flow_word: tuple[int, ...],
+    final_masses: tuple[float, ...],
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    generation = GenerationConfig(
+        emit_api_bundle=False,
+        validation=GenerationValidationConfig(
+            enabled=False,
+            post_build_validation=False,
+        ),
+    )
+    evaluator = EvaluatorConfig(jit=JITConfig(optimization_level=3))
+    complete_path = tmp_path / "complete"
+    selected_path = tmp_path / "selected"
+
+    Generator(
+        RunConfig(
+            action="generate",
+            generation=generation,
+            evaluator=evaluator,
+        )
+    ).generate(process, complete_path)
+    Generator(
+        RunConfig(
+            action="generate",
+            process=ProcessConfig(
+                reference_color_order=flow_word,
+                selected_color_sector_ids=(0,),
+            ),
+            generation=generation,
+            evaluator=evaluator,
+        )
+    ).generate(process, selected_path)
+
+    final_state = massive_rambo_final_state(
+        len(final_masses),
+        sqrt_s=1000.0,
+        masses=final_masses,
+        seed=731,
+    )
+    momenta = (
+        (
+            (500.0, 0.0, 0.0, 500.0),
+            (500.0, 0.0, 0.0, -500.0),
+            *final_state,
+        ),
+    )
+    flow_id = "flow:" + ",".join(str(label) for label in flow_word)
+    complete = Runtime.load(complete_path)
+    selected = Runtime.load(selected_path)
+    complete_inspection = inspect_artifact(complete_path).processes[0]
+    selected_inspection = inspect_artifact(selected_path).processes[0]
+
+    assert complete_inspection.selector_provenance == (_RECURRENCE_PLAN_ABI)
+    assert complete_inspection.helicity_runtime_contract == "complete-reusable"
+    assert complete_inspection.color_flow_runtime_contract == "complete-reusable"
+    assert complete_inspection.generation_specialized_axes == ()
+    assert complete_inspection.selected_source_helicities == ()
+    assert complete_inspection.selected_color_sector_ids == ()
+    assert complete_inspection.execution_mode == "recurrence"
+    assert complete_inspection.lc_flow_layout == "topology-replay"
+    if complete_inspection.lc_physical_sector_count is not None:
+        assert complete_inspection.lc_replayed_sector_count is not None
+        assert complete_inspection.lc_residual_sector_count is not None
+        assert (
+            complete_inspection.lc_replayed_sector_count
+            + complete_inspection.lc_residual_sector_count
+            == complete_inspection.lc_physical_sector_count
+        )
+        assert complete_inspection.lc_materialized_sector_count is not None
+        assert (
+            complete_inspection.lc_materialized_sector_count
+            <= complete_inspection.lc_physical_sector_count
+        )
+
+    assert selected_inspection.helicity_runtime_contract == "complete-reusable"
+    assert selected_inspection.color_flow_runtime_contract == ("generation-specialized")
+    assert selected_inspection.generation_specialized_axes == ("color_flow",)
+    assert selected_inspection.selected_source_helicities == ()
+    assert selected_inspection.selected_color_sector_ids == (0,)
+    assert selected_inspection.lc_physical_sector_count is None
+
+    assert flow_id in {flow.id for flow in complete.physics.color_flows}
+    selected_flow_by_id = {flow.id: flow for flow in selected.physics.color_flows}
+    assert flow_id in selected_flow_by_id
+    assert selected_flow_by_id[flow_id].word == flow_word
+
+    complete_component = complete.evaluate_resolved(
+        momenta,
+        color_flows=[flow_id],
+    ).total()[0]
+    complete_total = complete.evaluate(momenta, color_flows=[flow_id])[0]
+    selected_total = selected.evaluate(momenta, color_flows=[flow_id])[0]
+    assert complete_total == pytest.approx(
+        selected_total,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert selected_total.real == pytest.approx(
+        complete_component.real,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert selected_total.imag == pytest.approx(
+        complete_component.imag,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    profile = complete._backend.profile(momenta, color_flows=[flow_id])
+    assert profile["resolved_materialized_component_count"] == 0
+    assert profile["total_materialized_value_count"] == len(momenta)
+    homogeneous_profile = complete._backend.profile(
+        momenta,
+        color_flow_by_point=[flow_id] * len(momenta),
+    )
+    assert homogeneous_profile["selector_plan_kind"] == "homogeneous"
+    assert homogeneous_profile["resolved_materialized_component_count"] == 0
+    assert homogeneous_profile["total_materialized_value_count"] == len(momenta)
+
+
+def test_complete_pure_gluon_replay_matches_every_sector_specialization(
+    tmp_path: Path,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    process = "g g > g g"
+    generation = GenerationConfig(
+        emit_api_bundle=False,
+        validation=GenerationValidationConfig(
+            enabled=False,
+            post_build_validation=False,
+        ),
+    )
+    evaluator = EvaluatorConfig(
+        eager=EagerEvaluatorConfig(point_tile_size=2),
+        jit=JITConfig(optimization_level=3),
+    )
+    complete_path = tmp_path / "complete"
+    Generator(
+        RunConfig(
+            action="generate",
+            generation=generation,
+            evaluator=evaluator,
+        )
+    ).generate(process, complete_path)
+
+    final_state = massive_rambo_final_state(
+        2,
+        sqrt_s=1000.0,
+        masses=(0.0, 0.0),
+        seed=731,
+    )
+    momenta = (
+        (
+            (500.0, 0.0, 0.0, 500.0),
+            (500.0, 0.0, 0.0, -500.0),
+            *final_state,
+        ),
+    )
+    complete = Runtime.load(complete_path)
+    resolved = complete.evaluate_resolved(momenta)
+    exact = complete.evaluate_resolved(momenta, precision=32)
+    total = complete.evaluate(momenta)[0]
+    assert total == pytest.approx(
+        resolved.total()[0],
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    tiled_momenta = momenta * 3
+    tiled_total = complete.evaluate(tiled_momenta)
+    tiled_resolved = complete.evaluate_resolved(tiled_momenta)
+    assert tiled_total == pytest.approx(
+        tiled_resolved.total(),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert exact.helicity_ids == resolved.helicity_ids
+    assert exact.color_ids == resolved.color_ids
+    color_plan = build_color_plan(
+        build_process_ir(process),
+        color_accuracy="lc",
+        fold_trace_reflections=True,
+    )
+    sector_by_flow: dict[str, int] = {}
+    for sector in color_plan.sectors:
+        word = tuple(sector.word_labels or sector.color_words[0])
+        words = {word}
+        if sector.kind == "single-trace" and len(word) > 2:
+            words.add((word[0], *reversed(word[1:])))
+        for physical_word in words:
+            sector_by_flow[
+                "flow:" + ",".join(str(label) for label in physical_word)
+            ] = int(sector.id)
+
+    for helicity_index, helicity in enumerate(complete.physics.helicities):
+        if helicity.structural_zero:
+            continue
+        selected_helicities = {
+            str(label): value for label, value in enumerate(helicity.values, start=1)
+        }
+        specialized_by_sector: dict[int, Runtime] = {}
+        for sector in color_plan.sectors:
+            path = tmp_path / f"h{helicity_index}-sector{sector.id}"
+            Generator(
+                RunConfig(
+                    action="generate",
+                    process=ProcessConfig(
+                        selected_color_sector_ids=(int(sector.id),),
+                        selected_source_helicities=selected_helicities,
+                    ),
+                    generation=generation,
+                    evaluator=evaluator,
+                )
+            ).generate(process, path)
+            specialized_by_sector[int(sector.id)] = Runtime.load(path)
+
+        for color_index, color in enumerate(complete.physics.color_flows):
+            reusable = resolved.values[0][helicity_index][color_index]
+            exact_reusable = exact.values[0][helicity_index][color_index]
+            specialized = specialized_by_sector[sector_by_flow[color.id]].evaluate(
+                momenta,
+                color_flows=(color.id,),
+            )[0]
+            assert reusable.real == pytest.approx(
+                specialized.real,
+                rel=1.0e-12,
+                abs=1.0e-15,
+            )
+            assert reusable.imag == pytest.approx(
+                specialized.imag,
+                rel=1.0e-12,
+                abs=1.0e-15,
+            )
+            assert complex(exact_reusable).real == pytest.approx(
+                reusable.real,
+                rel=1.0e-12,
+                abs=1.0e-15,
+            )
+            assert complex(exact_reusable).imag == pytest.approx(
+                reusable.imag,
+                rel=1.0e-12,
+                abs=1.0e-15,
+            )
+
+    assert complex(exact.total()[0]).real == pytest.approx(
+        resolved.total()[0].real,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+
+@pytest.mark.parametrize("model_kind", ("built-in", "ufo-sm"))
+def test_complete_lc_fixed_helicity_selection_composes_with_flow_replay(
+    tmp_path: Path,
+    model_kind: str,
+    request: pytest.FixtureRequest,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    artifact = tmp_path / model_kind
+    model = _model_for_kind(model_kind, request)
+    Generator(
+        RunConfig(
+            action="generate",
+            generation=GenerationConfig(
+                emit_api_bundle=False,
+                validation=GenerationValidationConfig(
+                    enabled=False,
+                    post_build_validation=False,
+                ),
+            ),
+            evaluator=EvaluatorConfig(jit=JITConfig(optimization_level=3)),
+        )
+    ).generate("d d~ > z g g", artifact, model=model)
+
+    execution = json.loads(
+        (artifact / "processes/d_dbar_to_z_g_g/execution.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    assert execution["kind"] == _RECURRENCE_KIND
+    assert execution["recurrence_plan_abi"] == _RECURRENCE_PLAN_ABI
+    assert (
+        execution["plan"]["inspection_summary"]["direct_arena"]["selector_domain_count"]
+        == 2
+    )
+
+    point = (
+        (500.0, 0.0, 0.0, 500.0),
+        (500.0, 0.0, 0.0, -500.0),
+        (
+            312.48956564409934,
+            -193.66118273046334,
+            121.57983298112629,
+            192.4790061491314,
+        ),
+        (
+            487.79620348021274,
+            250.4771539987287,
+            -206.7128292830862,
+            -363.97271554910253,
+        ),
+        (
+            199.71423087568797,
+            -56.81597126826545,
+            85.1329963019599,
+            171.49370939997104,
+        ),
+    )
+    runtime = Runtime.load(artifact)
+    flow_id = "flow:2,4,5,1"
+    selected_flow = runtime.evaluate((point,), color_flows=(flow_id,))[0]
+    selected_flow_exact = runtime.evaluate(
+        (point,),
+        color_flows=(flow_id,),
+        precision=32,
+    )[0]
+    assert selected_flow == pytest.approx(
+        complex(selected_flow_exact),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert selected_flow.real == pytest.approx(
+        0.00022626601239021538,
+        rel=1.0e-11,
+        abs=1.0e-15,
+    )
+
+    helicity_id = "h:-1,+1,-1,+1,-1"
+    complete = runtime.evaluate_resolved((point,))
+    helicity_index = complete.helicity_ids.index(helicity_id)
+    selected = runtime.evaluate_resolved((point,), helicities=(helicity_id,))
+
+    assert selected.color_ids == complete.color_ids
+    assert selected.values[0][0] == pytest.approx(
+        complete.values[0][helicity_index],
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    total = runtime.evaluate((point,), helicities=(helicity_id,))[0]
+    assert total == pytest.approx(
+        sum(complete.values[0][helicity_index]),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert total.real == pytest.approx(
+        0.000180803517738144,
+        rel=1.0e-11,
+        abs=1.0e-15,
+    )
+
+
+@pytest.mark.parametrize(
+    (
+        "process",
+        "expected_total",
+        "expected_fixed_helicity",
+        "expected_all_flow_fixed_helicity",
+    ),
+    (
+        (
+            "d d~ > u u~ s s~ g",
+            8.495913119023438e-15,
+            2.6043061427778106e-15,
+            4.899181433766111e-14,
+        ),
+        (
+            "d d~ > u u~ u u~ g",
+            3.215288522484574e-15,
+            5.102730162523396e-16,
+            4.4151994948046454e-14,
+        ),
+    ),
+)
+def test_three_line_lc_publication_reload_and_union_components_match(
+    process: str,
+    expected_total: float,
+    expected_fixed_helicity: float,
+    expected_all_flow_fixed_helicity: float,
+    tmp_path: Path,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    generation = GenerationConfig(
+        emit_api_bundle=False,
+        validation=GenerationValidationConfig(
+            enabled=False,
+            post_build_validation=False,
+        ),
+    )
+    evaluator = EvaluatorConfig(jit=JITConfig(optimization_level=3))
+    complete_path = tmp_path / "complete"
+    union_path = tmp_path / "all-flow-union"
+    Generator(
+        RunConfig(
+            action="generate",
+            generation=generation,
+            evaluator=evaluator,
+        )
+    ).generate(process, complete_path)
+    Generator(
+        RunConfig(
+            action="generate",
+            color=ColorConfig(lc_flow_layout="all-flow-union"),
+            generation=generation,
+            evaluator=evaluator,
+        )
+    ).generate(process, union_path)
+
+    point = tuple(
+        tuple(float(component) for component in particle.momentum)
+        for particle in generic_validation_point(process)
+    )
+    points = (point,)
+    flow_id = "flow:2,7,1,3,4,5,6"
+    helicity_id = "h:-1,+1,-1,+1,-1,+1,-1"
+    complete = Runtime.load(complete_path)
+    union_immediate = Runtime.load(union_path)
+
+    def flattened_values(resolved: ResolvedEvaluation) -> tuple[complex, ...]:
+        return tuple(
+            complex(value)
+            for point_values in resolved.values
+            for helicity_values in point_values
+            for value in helicity_values
+        )
+
+    complete_selected = complete.evaluate_resolved(points, color_flows=(flow_id,))
+    union_selected = union_immediate.evaluate_resolved(
+        points,
+        color_flows=(flow_id,),
+    )
+    assert union_selected.helicity_ids == complete_selected.helicity_ids
+    assert union_selected.color_ids == complete_selected.color_ids
+    assert flattened_values(union_selected) == pytest.approx(
+        flattened_values(complete_selected),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert complete.evaluate(points, color_flows=(flow_id,))[0].real == pytest.approx(
+        expected_total,
+        rel=1.0e-11,
+        abs=1.0e-25,
+    )
+    assert complete.evaluate(
+        points,
+        color_flows=(flow_id,),
+        helicities=(helicity_id,),
+    )[0].real == pytest.approx(
+        expected_fixed_helicity,
+        rel=1.0e-11,
+        abs=1.0e-25,
+    )
+
+    complete_fixed = complete.evaluate_resolved(points, helicities=(helicity_id,))
+    union_fixed = union_immediate.evaluate_resolved(points, helicities=(helicity_id,))
+    assert union_fixed.color_ids == complete_fixed.color_ids
+    assert flattened_values(union_fixed) == pytest.approx(
+        flattened_values(complete_fixed),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert complete_fixed.total()[0].real == pytest.approx(
+        expected_all_flow_fixed_helicity,
+        rel=1.0e-11,
+        abs=1.0e-24,
+    )
+
+    union_reloaded = Runtime.load(union_path)
+    reloaded_selected = union_reloaded.evaluate_resolved(points, color_flows=(flow_id,))
+    assert flattened_values(reloaded_selected) == pytest.approx(
+        flattened_values(union_selected),
+        rel=0.0,
+        abs=0.0,
+    )
+
+
+@pytest.mark.parametrize("model_kind", ("built-in", "ufo-sm"))
+def test_complete_pure_gluon_fixed_helicity_preserves_every_physical_flow(
+    tmp_path: Path,
+    model_kind: str,
+    request: pytest.FixtureRequest,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    artifact = tmp_path / model_kind
+    model = _model_for_kind(model_kind, request)
+    Generator(
+        RunConfig(
+            action="generate",
+            generation=GenerationConfig(
+                emit_api_bundle=False,
+                validation=GenerationValidationConfig(
+                    enabled=False,
+                    post_build_validation=False,
+                ),
+            ),
+            evaluator=EvaluatorConfig(jit=JITConfig(optimization_level=3)),
+        )
+    ).generate("g g > g g", artifact, model=model)
+
+    execution = json.loads(
+        (artifact / "processes/g_g_to_g_g/execution.json").read_text(encoding="utf-8")
+    )
+    assert execution["kind"] == _RECURRENCE_KIND
+    assert execution["recurrence_plan_abi"] == _RECURRENCE_PLAN_ABI
+    assert (
+        execution["plan"]["inspection_summary"]["direct_arena"]["selector_domain_count"]
+        == 4
+    )
+
+    point = (
+        (500.0, 0.0, 0.0, 500.0),
+        (500.0, 0.0, 0.0, -500.0),
+        (
+            499.99999999999994,
+            -306.65836769058797,
+            210.51071473894038,
+            334.1345305493651,
+        ),
+        (
+            499.99999999999994,
+            306.65836769058797,
+            -210.51071473894038,
+            -334.1345305493651,
+        ),
+    )
+    runtime = Runtime.load(artifact)
+    helicity_id = "h:-1,+1,-1,+1"
+    complete = runtime.evaluate_resolved((point,))
+    helicity_index = complete.helicity_ids.index(helicity_id)
+    selected = runtime.evaluate_resolved((point,), helicities=(helicity_id,))
+    exact_selected = runtime.evaluate_resolved(
+        (point,),
+        helicities=(helicity_id,),
+        precision=32,
+    )
+
+    expected_by_flow = {
+        "flow:1,2,3,4": 0.2420310029906875,
+        "flow:1,2,4,3": 6.121124826711009,
+        "flow:1,3,2,4": 8.79749514971447,
+        "flow:1,3,4,2": 6.121124826711009,
+        "flow:1,4,2,3": 8.79749514971447,
+        "flow:1,4,3,2": 0.2420310029906875,
+    }
+    assert selected.color_ids == complete.color_ids
+    assert selected.values[0][0] == pytest.approx(
+        complete.values[0][helicity_index],
+        rel=1.0e-11,
+        abs=1.0e-14,
+    )
+    assert exact_selected.color_ids == selected.color_ids
+    for color_id, value in zip(
+        selected.color_ids,
+        selected.values[0][0],
+        strict=True,
+    ):
+        assert value.real == pytest.approx(
+            expected_by_flow[color_id],
+            rel=1.0e-10,
+            abs=1.0e-13,
+        )
+        assert value.imag == pytest.approx(0.0, abs=1.0e-15)
+    for exact_value, value in zip(
+        exact_selected.values[0][0],
+        selected.values[0][0],
+        strict=True,
+    ):
+        assert complex(exact_value) == pytest.approx(
+            value,
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+
+    total = runtime.evaluate((point,), helicities=(helicity_id,))[0]
+    assert total.real == pytest.approx(
+        30.321301958832333,
+        rel=1.0e-10,
+        abs=1.0e-12,
+    )
+    assert total.imag == pytest.approx(0.0, abs=1.0e-15)
+
+
+@pytest.mark.parametrize("model_kind", ("built-in", "ufo-sm"))
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+def test_all_flow_union_supports_complete_and_selected_runtime_axes(
+    tmp_path: Path,
+    execution_mode: str,
+    model_kind: str,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    artifact = tmp_path / f"{execution_mode}-{model_kind}"
+    model = None
+    if model_kind == "ufo-sm":
+        model_root = (
+            Path(__file__).resolve().parents[2]
+            / "src"
+            / "pyamplicol"
+            / "assets"
+            / "models"
+            / "json"
+            / "sm"
+        )
+        model = ModelSource.from_path(
+            model_root / "sm.json",
+            restriction=model_root / "restrict_default.json",
+        )
+        if execution_mode == "eager":
+            eager_evaluator = EvaluatorConfig(
+                execution_mode="eager",
+                jit=JITConfig(optimization_level=0),
+            )
+            model = model.compile(
+                use_cache=True,
+                prepared_output=tmp_path / "ufo-sm-jit-o0.pyamplicol-model",
+                evaluator=eager_evaluator,
+            )
+    Generator(
+        RunConfig(
+            action="generate",
+            color=ColorConfig(lc_flow_layout="all-flow-union"),
+            generation=GenerationConfig(
+                emit_api_bundle=False,
+                validation=GenerationValidationConfig(
+                    enabled=False,
+                    post_build_validation=False,
+                ),
+            ),
+            evaluator=EvaluatorConfig(
+                execution_mode=execution_mode,
+                jit=JITConfig(optimization_level=0 if execution_mode == "eager" else 3),
+            ),
+        )
+    ).generate("d d~ > z g g", artifact, model=model)
+
+    point = (
+        (500.0, 0.0, 0.0, 500.0),
+        (500.0, 0.0, 0.0, -500.0),
+        (
+            312.48956564409934,
+            -193.66118273046334,
+            121.57983298112629,
+            192.4790061491314,
+        ),
+        (
+            487.79620348021274,
+            250.4771539987287,
+            -206.7128292830862,
+            -363.97271554910253,
+        ),
+        (
+            199.71423087568797,
+            -56.81597126826545,
+            85.1329963019599,
+            171.49370939997104,
+        ),
+    )
+    inspection = inspect_artifact(artifact).processes[0]
+    runtime = Runtime.load(artifact)
+    resolved = runtime.evaluate_resolved((point,))
+    total = runtime.evaluate((point,))[0]
+
+    assert inspection.lc_flow_layout == "all-flow-union"
+    assert inspection.lc_union_sector_count == len(resolved.color_ids)
+    assert total == pytest.approx(
+        resolved.total()[0],
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+    helicity_id = "h:-1,+1,-1,+1,-1"
+    helicity_index = resolved.helicity_ids.index(helicity_id)
+    selected_helicity = runtime.evaluate_resolved((point,), helicities=(helicity_id,))
+    assert selected_helicity.values[0][0] == pytest.approx(
+        resolved.values[0][helicity_index],
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert selected_helicity.total()[0].real == pytest.approx(
+        0.000180803517738144,
+        rel=1.0e-10,
+        abs=1.0e-15,
+    )
+    assert selected_helicity.total()[0].imag == pytest.approx(0.0, abs=1.0e-15)
+
+    color_id = resolved.color_ids[-1]
+    color_index = resolved.color_ids.index(color_id)
+    selected_color = runtime.evaluate_resolved((point,), color_flows=(color_id,))
+    assert tuple(row[0] for row in selected_color.values[0]) == pytest.approx(
+        tuple(row[color_index] for row in resolved.values[0]),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+    exact = runtime.evaluate_resolved(
+        (point,),
+        helicities=(helicity_id,),
+        color_flows=(color_id,),
+        precision=32,
+    )
+    assert complex(exact.total()[0]) == pytest.approx(
+        selected_helicity.values[0][0][color_index],
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+    nonzero_helicity_indices = [
+        index
+        for index, helicity in enumerate(runtime.physics.helicities)
+        if not helicity.structural_zero
+    ][:2]
+    assert len(nonzero_helicity_indices) == 2
+    per_point = runtime.evaluate(
+        (point, point),
+        helicity_by_point=tuple(
+            resolved.helicity_ids[index] for index in nonzero_helicity_indices
+        ),
+        color_flow_by_point=(resolved.color_ids[0], resolved.color_ids[-1]),
+    )
+    assert per_point == pytest.approx(
+        (
+            resolved.values[0][nonzero_helicity_indices[0]][0],
+            resolved.values[0][nonzero_helicity_indices[1]][-1],
+        ),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+
+def test_eager_complete_replay_matches_specialized_flows_and_point_selectors(
+    tmp_path: Path,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    process = "d d~ > z g g"
+    generation = GenerationConfig(
+        emit_api_bundle=False,
+        validation=GenerationValidationConfig(
+            enabled=False,
+            post_build_validation=False,
+        ),
+    )
+    eager_path = tmp_path / "eager-complete"
+    Generator(
+        RunConfig(
+            action="generate",
+            generation=generation,
+            evaluator=EvaluatorConfig(
+                execution_mode="eager",
+                jit=JITConfig(optimization_level=0),
+            ),
+        )
+    ).generate(process, eager_path)
+
+    final_state = massive_rambo_final_state(
+        3,
+        sqrt_s=1000.0,
+        masses=(91.188, 0.0, 0.0),
+        seed=731,
+    )
+    point = (
+        (500.0, 0.0, 0.0, 500.0),
+        (500.0, 0.0, 0.0, -500.0),
+        *final_state,
+    )
+    eager = Runtime.load(eager_path)
+    resolved = eager.evaluate_resolved((point,))
+    exact = eager.evaluate_resolved((point,), precision=32)
+    inspection = inspect_artifact(eager_path).processes[0]
+
+    assert inspection.execution_mode == "eager"
+    assert inspection.lc_materialized_sector_count == 1
+    assert inspection.lc_physical_sector_count == 2
+    assert exact.helicity_ids == resolved.helicity_ids
+    assert exact.color_ids == resolved.color_ids
+
+    color_plan = build_color_plan(build_process_ir(process), color_accuracy="lc")
+    sector_by_flow = {
+        "flow:" + ",".join(str(label) for label in sector.word_labels): int(sector.id)
+        for sector in color_plan.sectors
+    }
+    specialized_by_sector = {}
+    for sector in color_plan.sectors:
+        selected_path = tmp_path / f"selected-{sector.id}"
+        Generator(
+            RunConfig(
+                action="generate",
+                process=ProcessConfig(
+                    selected_color_sector_ids=(int(sector.id),),
+                ),
+                generation=generation,
+                evaluator=EvaluatorConfig(jit=JITConfig(optimization_level=3)),
+            )
+        ).generate(process, selected_path)
+        selected_runtime = Runtime.load(selected_path)
+        specialized = selected_runtime.evaluate_resolved((point,))
+        specialized_by_sector[int(sector.id)] = specialized
+
+    for helicity_index, _helicity_id in enumerate(resolved.helicity_ids):
+        for color_index, color_id in enumerate(resolved.color_ids):
+            specialized = specialized_by_sector[sector_by_flow[color_id]]
+            actual = resolved.values[0][helicity_index][color_index]
+            expected = specialized.values[0][helicity_index][0]
+            exact_actual = complex(exact.values[0][helicity_index][color_index])
+            assert actual.real == pytest.approx(expected.real, rel=1.0e-12, abs=1.0e-15)
+            assert actual.imag == pytest.approx(expected.imag, rel=1.0e-12, abs=1.0e-15)
+            assert exact_actual.real == pytest.approx(
+                actual.real, rel=1.0e-12, abs=1.0e-15
+            )
+            assert exact_actual.imag == pytest.approx(
+                actual.imag, rel=1.0e-12, abs=1.0e-15
+            )
+
+    # Independent legacy generated-library oracle at this deterministic point,
+    # adjusted to the exact alpha_ew = 1 / 132.507 normalization.
+    helicity_sums = tuple(
+        sum(
+            resolved.values[0][helicity_index][color_index].real
+            for helicity_index in range(len(resolved.helicity_ids))
+        )
+        for color_index in range(len(resolved.color_ids))
+    )
+    assert dict(zip(resolved.color_ids, helicity_sums, strict=True)) == pytest.approx(
+        {
+            "flow:2,4,5,1": 2.20775902078958e-7,
+            "flow:2,5,4,1": 4.767041136002407e-2,
+        },
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+    point_batch = (point, point)
+    selected = eager.evaluate(
+        point_batch,
+        helicity_by_point=(resolved.helicity_ids[0], resolved.helicity_ids[1]),
+        color_flow_by_point=(resolved.color_ids[0], resolved.color_ids[1]),
+    )
+    assert selected[0].real == pytest.approx(
+        resolved.values[0][0][0].real, rel=1.0e-12, abs=1.0e-15
+    )
+    assert selected[1].real == pytest.approx(
+        resolved.values[0][1][1].real, rel=1.0e-12, abs=1.0e-15
+    )
+
+
+def test_external_sm_complete_three_line_flows_match_builtin(
+    tmp_path: Path,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    config = RunConfig(
+        action="generate",
+        generation=GenerationConfig(
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(jit=JITConfig(optimization_level=3)),
+    )
+    process = "d d~ > u u~ s s~"
+    builtin_path = tmp_path / "builtin"
+    external_path = tmp_path / "external"
+    Generator(config).generate(process, builtin_path)
+    Generator(config).generate(
+        process,
+        external_path,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+
+    final_state = massive_rambo_final_state(
+        4,
+        sqrt_s=1000.0,
+        masses=(0.0, 0.0, 0.0, 0.0),
+        seed=731,
+    )
+    momenta = (
+        (
+            (500.0, 0.0, 0.0, 500.0),
+            (500.0, 0.0, 0.0, -500.0),
+            *final_state,
+        ),
+    )
+    builtin = Runtime.load(builtin_path).evaluate_resolved(momenta)
+    external = Runtime.load(external_path).evaluate_resolved(momenta)
+
+    assert external.helicity_ids == builtin.helicity_ids
+    assert external.color_ids == builtin.color_ids
+    for builtin_helicities, external_helicities in zip(
+        builtin.values[0], external.values[0], strict=True
+    ):
+        for builtin_value, external_value in zip(
+            builtin_helicities, external_helicities, strict=True
+        ):
+            assert external_value.real == pytest.approx(
+                builtin_value.real,
+                rel=1.0e-11,
+                abs=1.0e-20,
+            )
+            assert external_value.imag == pytest.approx(
+                builtin_value.imag,
+                rel=1.0e-11,
+                abs=1.0e-20,
+            )
+
+
+def test_external_sm_fixed_width_multigluon_current_matches_builtin(
+    tmp_path: Path,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    """Keep the proven AmpliCol transverse Yang--Mills convention."""
+
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    config = RunConfig(
+        action="generate",
+        process=ProcessConfig(
+            selected_source_helicities={
+                "1": -1,
+                "2": 1,
+                "3": -1,
+                "4": 1,
+                "5": -1,
+                "6": 1,
+            }
+        ),
+        generation=GenerationConfig(
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(jit=JITConfig(optimization_level=3)),
+    )
+    process = "d d~ > t t~ g g"
+    builtin_path = tmp_path / "builtin-fixed-width"
+    external_path = tmp_path / "external-fixed-width"
+    Generator(config).generate(process, builtin_path)
+    Generator(config).generate(
+        process,
+        external_path,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+
+    final_state = massive_rambo_final_state(
+        4,
+        sqrt_s=1000.0,
+        masses=(173.0, 173.0, 0.0, 0.0),
+        seed=731,
+    )
+    momenta = (
+        (
+            (500.0, 0.0, 0.0, 500.0),
+            (500.0, 0.0, 0.0, -500.0),
+            *final_state,
+        ),
+    )
+    builtin = Runtime.load(builtin_path).evaluate(momenta)[0]
+    external = Runtime.load(external_path).evaluate(momenta)[0]
+
+    assert external.real == pytest.approx(
+        builtin.real,
+        rel=1.0e-11,
+        abs=1.0e-20,
+    )
+    assert external.imag == pytest.approx(
+        builtin.imag,
+        rel=1.0e-11,
+        abs=1.0e-20,
+    )
diff --git a/pyamplicol/tests/integration/test_model_spin2_contraction.py b/pyamplicol/tests/integration/test_model_spin2_contraction.py
new file mode 100644
index 0000000000..48aae5571a
--- /dev/null
+++ b/pyamplicol/tests/integration/test_model_spin2_contraction.py
@@ -0,0 +1,98 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.generation.dag_algorithms import (
+    infer_minimal_coupling_order_limits,
+)
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.runtime_schema import build_runtime_schema
+from pyamplicol.generation.stage_compiler import (
+    build_generic_stage_compiler_blueprint,
+)
+from pyamplicol.models import CompiledUFOModel, compile_model_source
+from pyamplicol.processes.model import build_model_process_ir
+
+MODEL_PATH = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "scalar_gravity"
+    / "scalar_gravity.json"
+)
+
+
+@pytest.fixture(scope="module")
+def scalar_gravity_model():
+    compiled = compile_model_source(MODEL_PATH, use_cache=True)
+    return compiled, CompiledUFOModel(compiled)
+
+
+def test_scalar_gravity_compiles_a_model_owned_spin2_contraction(
+    scalar_gravity_model,
+) -> None:
+    compiled, model = scalar_gravity_model
+    graviton = next(
+        particle.pdg_code
+        for particle in compiled.ir.particles
+        if particle.name == "graviton"
+    )
+
+    contraction = model.direct_contraction_ir(graviton, graviton)
+
+    assert contraction is not None
+    assert contraction.name == "lorentz-rank-2"
+    assert contraction.left_basis == contraction.right_basis == "lorentz-rank-2"
+    assert len(contraction.coefficients) == 16
+    assert model.closure_contraction_ir(graviton) is None
+
+
+@pytest.mark.parametrize(
+    ("process", "external_count", "coupling_order"),
+    (
+        ("graviton graviton > graviton", 3, 1),
+        ("graviton graviton > graviton graviton", 4, 2),
+        ("graviton graviton > graviton graviton graviton", 5, 3),
+    ),
+)
+def test_scalar_gravity_pure_graviton_ladder_has_complete_direct_roots(
+    scalar_gravity_model,
+    process: str,
+    external_count: int,
+    coupling_order: int,
+) -> None:
+    compiled, model = scalar_gravity_model
+    process_ir = build_model_process_ir(process, compiled.ir)
+    limits = infer_minimal_coupling_order_limits(process_ir, model=model)
+
+    dag = compile_generic_dag(
+        process_ir,
+        model=model,
+        max_coupling_orders=limits,
+    )
+
+    assert limits == {"GRAV": coupling_order, "QCD": 0, "QED": 0}
+    assert dag.interactions
+    assert len(dag.amplitude_roots) == 2**external_count
+    assert all(root.kind == "direct-contraction" for root in dag.amplitude_roots)
+    assert all(
+        root.contraction_ir.name == "lorentz-rank-2"
+        for root in dag.amplitude_roots
+    )
+    if external_count == 3:
+        runtime_schema = build_runtime_schema(dag, model)
+        blueprint = build_generic_stage_compiler_blueprint(
+            dag,
+            model=model,
+            runtime_schema=runtime_schema,
+        )
+        assert blueprint.expression_ready is True
+        assert blueprint.blockers == ()
+        assert blueprint.amplitude_stage.expression_ready is True
+        assert blueprint.amplitude_stage.blockers == ()
diff --git a/pyamplicol/tests/integration/test_multilanguage_api.py b/pyamplicol/tests/integration/test_multilanguage_api.py
new file mode 100644
index 0000000000..e1cad8c343
--- /dev/null
+++ b/pyamplicol/tests/integration/test_multilanguage_api.py
@@ -0,0 +1,971 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib.resources
+import importlib.util
+import io
+import json
+import os
+import runpy
+import shlex
+import shutil
+import subprocess
+import sys
+from contextlib import redirect_stdout
+from dataclasses import dataclass
+from decimal import Decimal
+from pathlib import Path
+from typing import Any, Literal
+from unittest.mock import patch
+
+import pytest
+
+from pyamplicol import CompiledModel, Generator, ModelSource, ProcessSet
+from pyamplicol.config import (
+    ColorConfig,
+    CppConfig,
+    EvaluatorBackend,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    JITConfig,
+    RunConfig,
+)
+
+_PARAMETER_ID = "aS"
+_EAGER_PARAMETER_ID = "normalization.alpha_ew"
+_EAGER_PROCESS = "d d~ > z"
+_EAGER_NAME = "ddbar_z_eager"
+_MIXED_PROCESSES = (
+    "d d~ > z g",
+    "d d~ > z g g",
+)
+_MIXED_NAMES = ("ddbar_zg", "ddbar_zgg")
+_METADATA_KEYS = (
+    "process",
+    "process_key",
+    "color_accuracy",
+    "external_particles",
+    "helicities",
+    "colors",
+    "shape",
+)
+_LANGUAGES = ("python", "c", "cpp", "fortran", "rust")
+_NATIVE_LANGUAGES = _LANGUAGES[1:]
+_PROJECT_ROOT = Path(__file__).resolve().parents[2]
+_EAGER_DIRECT_RUNTIME_CAPABILITIES = [
+    "eager-direct-arena-v1",
+    "rusticol.eager-runtime-layout.complex-f64.v1",
+]
+
+
+def _source_environment() -> dict[str, str]:
+    environment = os.environ.copy()
+    source_paths = [str((_PROJECT_ROOT / "src").resolve())]
+    source_paths.extend(
+        str(Path(entry).resolve())
+        for entry in sys.path
+        if entry and str(Path(entry).resolve()) not in source_paths
+    )
+    environment["PYTHONPATH"] = os.pathsep.join(source_paths)
+    return environment
+
+
+@dataclass(frozen=True, slots=True)
+class _NativeTools:
+    make: str
+    cc: str
+    cxx: str
+    fortran: str
+    rustc: str
+    rusticol_config: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _BuiltBundle:
+    artifact: Path
+    process_ids: tuple[str, ...]
+    python_driver: Path
+    c_driver: Path
+    cpp_driver: Path
+    fortran_driver: Path
+    rust_driver: Path
+
+
+def _required_native_tests() -> bool:
+    return os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1"
+
+
+def _unavailable(reason: str) -> None:
+    if _required_native_tests():
+        pytest.fail(reason)
+    pytest.skip(reason)
+
+
+def _tool_from_environment(variable: str, default: str) -> str | None:
+    configured = os.environ.get(variable)
+    if configured:
+        command = configured.split()[0]
+        located = shutil.which(command)
+        return located or (command if Path(command).is_file() else None)
+    return shutil.which(default)
+
+
+def _rusticol_config() -> tuple[str, ...] | None:
+    configured = os.environ.get("RUSTICOL_CONFIG")
+    if configured:
+        command = shlex.split(configured)
+        if command:
+            executable = shutil.which(command[0])
+            if executable or Path(command[0]).expanduser().is_file():
+                return (executable or str(Path(command[0]).expanduser()), *command[1:])
+    sibling = Path(sys.executable).parent / "rusticol-config"
+    if sibling.is_file():
+        return (str(sibling),)
+    discovered = shutil.which("rusticol-config")
+    if discovered:
+        return (discovered,)
+    if importlib.util.find_spec("rusticol_config") is not None:
+        return (sys.executable, "-m", "rusticol_config")
+    return None
+
+
+@pytest.fixture(scope="module")
+def native_tools() -> _NativeTools:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    discovered = {
+        "make": shutil.which("make"),
+        "cc": _tool_from_environment("CC", "cc"),
+        "cxx": _tool_from_environment("CXX", "c++"),
+        "fortran": _tool_from_environment("FC", "gfortran"),
+        "rustc": _tool_from_environment("RUSTC", "rustc"),
+        "rusticol_config": _rusticol_config(),
+    }
+    missing = tuple(name for name, value in discovered.items() if value is None)
+    if missing:
+        _unavailable("cross-language tests require " + ", ".join(missing))
+    tools = _NativeTools(**discovered)  # type: ignore[arg-type]
+    checked = subprocess.run(
+        [*tools.rusticol_config, "--json"],
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=20,
+    )
+    if checked.returncode != 0:
+        _unavailable(
+            "the installed Rusticol SDK is unavailable: " + checked.stderr.strip()
+        )
+    return tools
+
+
+def _generation_config(
+    accuracy: str,
+    execution_mode: Literal["compiled", "eager"] = "compiled",
+    *,
+    evaluator: EvaluatorConfig | None = None,
+) -> RunConfig:
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=accuracy),
+        generation=GenerationConfig(workers=1, emit_api_bundle=True),
+        evaluator=evaluator
+        or EvaluatorConfig(
+            execution_mode=execution_mode,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=0 if execution_mode == "eager" else 3),
+        ),
+    )
+
+
+def _manifest_process_ids(artifact: Path) -> tuple[str, ...]:
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    return tuple(str(process["id"]) for process in manifest["processes"])
+
+
+def _assert_complete_runtime_coverage(
+    artifact: Path, process_ids: tuple[str, ...], accuracy: str
+) -> None:
+    for process_id in process_ids:
+        physics = json.loads(
+            (artifact / "processes" / process_id / "physics.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        assert physics["color_accuracy"] == accuracy
+        assert physics["coverage"]["helicities"] == "complete"
+        expected_color_coverage = "complete" if accuracy == "lc" else "contracted"
+        assert physics["coverage"]["color"] == expected_color_coverage
+        assert physics["selectors"]["helicity"] is True
+        assert physics["selectors"]["color_flow"] is (accuracy == "lc")
+        assert physics["selectors"]["contracted_color"] is False
+
+
+def _assert_one_root_bundle(artifact: Path, process_ids: tuple[str, ...]) -> None:
+    api_directories = tuple(path for path in artifact.rglob("API") if path.is_dir())
+    assert api_directories == (artifact / "API",)
+    for process_id in process_ids:
+        assert not (artifact / "processes" / process_id / "API").exists()
+
+    rows = {
+        line.split("\t", 1)[0]
+        for line in (artifact / "API/validation_points.dat")
+        .read_text(encoding="ascii")
+        .splitlines()[1:]
+        if line and not line.startswith("#")
+    }
+    assert rows == set(process_ids)
+
+    c_source = (artifact / "API/c/check_standalone.c").read_text(encoding="utf-8")
+    assert "#include <rusticol.h>" in c_source
+    assert "rusticol_runtime_load" in c_source
+    assert "rusticol_runtime_evaluate_f64" in c_source
+    assert "rusticol_runtime_evaluate_resolved_f64" in c_source
+
+    rust_source = (artifact / "API/rust/check_standalone.rs").read_text(
+        encoding="utf-8"
+    )
+    assert "Runtime::load" in rust_source
+    assert "unsafe" not in rust_source
+    assert 'extern "C"' not in rust_source
+    assert "rusticol_runtime_" not in rust_source
+
+
+def _build_bundle(
+    artifact: Path,
+    expressions: tuple[str, ...],
+    names: tuple[str, ...],
+    accuracy: str,
+    model: CompiledModel | None,
+    tools: _NativeTools,
+    execution_mode: Literal["compiled", "eager"] = "compiled",
+    evaluator: EvaluatorConfig | None = None,
+) -> _BuiltBundle:
+    processes = ProcessSet.from_expressions(expressions, names=names)
+    Generator(
+        _generation_config(
+            accuracy,
+            execution_mode,
+            evaluator=evaluator,
+        )
+    ).generate(
+        processes,
+        artifact,
+        model=model,
+    )
+    process_ids = _manifest_process_ids(artifact)
+    assert process_ids == names
+    _assert_complete_runtime_coverage(artifact, process_ids, accuracy)
+    _assert_one_root_bundle(artifact, process_ids)
+
+    environment = _source_environment()
+    environment.update(
+        {
+            "CC": tools.cc,
+            "CXX": tools.cxx,
+            "FC": tools.fortran,
+            "RUSTC": tools.rustc,
+            "RUSTICOL_CONFIG": shlex.join(tools.rusticol_config),
+        }
+    )
+    for language in _NATIVE_LANGUAGES:
+        make_arguments = [
+            tools.make,
+            "-C",
+            str(artifact / "API" / language),
+        ]
+        if language == "rust":
+            make_arguments.append(f"RUSTC={tools.rustc}")
+        make_arguments.append("all")
+        completed = subprocess.run(
+            make_arguments,
+            env=environment,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=180,
+        )
+        assert completed.returncode == 0, (
+            f"{language} API driver failed to build\n"
+            f"stdout:\n{completed.stdout}\nstderr:\n{completed.stderr}"
+        )
+
+    return _BuiltBundle(
+        artifact=artifact,
+        process_ids=process_ids,
+        python_driver=artifact / "API/python/check_standalone.py",
+        c_driver=(
+            artifact.parent
+            / ".pyamplicol-api-build"
+            / artifact.name
+            / "c/check_standalone"
+        ),
+        cpp_driver=(
+            artifact.parent
+            / ".pyamplicol-api-build"
+            / artifact.name
+            / "cpp/check_standalone"
+        ),
+        fortran_driver=(
+            artifact.parent
+            / ".pyamplicol-api-build"
+            / artifact.name
+            / "fortran/check_standalone"
+        ),
+        rust_driver=(
+            artifact.parent
+            / ".pyamplicol-api-build"
+            / artifact.name
+            / "rust/check_standalone"
+        ),
+    )
+
+
+def test_safe_rust_demo_compiles_and_runs_with_installed_or_source_sdk(
+    native_tools: _NativeTools,
+    tmp_path: Path,
+) -> None:
+    completed = subprocess.run(
+        [*native_tools.rusticol_config, "--json"],
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=20,
+    )
+    assert completed.returncode == 0, completed.stderr
+    sdk = json.loads(completed.stdout)
+    package = importlib.resources.files("pyamplicol")
+    if not isinstance(package, os.PathLike):
+        _unavailable("the Rust SDK integration test requires an unpacked installation")
+    package_path = Path(os.fspath(package))
+    artifact = package_path / "assets" / "selftest" / sdk["target"] / "artifact"
+    source = package_path / "assets" / "api_templates" / "rust" / "check_standalone.rs"
+    if not artifact.is_dir() or not source.is_file():
+        _unavailable("the target-specific Rust SDK self-test fixture is unavailable")
+
+    binary = tmp_path / "check_standalone_rust"
+    environment = os.environ.copy()
+    environment["RUSTICOL_RUST_SOURCE"] = str(sdk["rust_source"])
+    compiled = subprocess.run(
+        [
+            native_tools.rustc,
+            "--edition=2021",
+            "-Dwarnings",
+            "-C",
+            "opt-level=2",
+            str(source),
+            "-o",
+            str(binary),
+            *map(str, sdk["rust_flags"]),
+        ],
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=180,
+    )
+    assert compiled.returncode == 0, (
+        f"safe Rust API driver failed to compile\n"
+        f"stdout:\n{compiled.stdout}\nstderr:\n{compiled.stderr}"
+    )
+
+    expected = json.loads(
+        (artifact.parent / "expected.json").read_text(encoding="utf-8")
+    )
+    process_id = str(expected["process_id"])
+
+    def run(*arguments: str) -> dict[str, Any]:
+        result = subprocess.run(
+            [str(binary), "--json", "--process", process_id, *arguments],
+            cwd=artifact,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+        assert result.returncode == 0, result.stderr
+        return json.loads(result.stdout)
+
+    baseline = run()
+    model_card = tmp_path / "model-parameters.json"
+    model_card.write_text(
+        json.dumps({"normalization.alpha_ew": [0.008, 0.0]}) + "\n",
+        encoding="utf-8",
+    )
+    card = run("--model-parameters", str(model_card))
+    direct = run("--set-parameter", "normalization.alpha_ew", "0.008", "0")
+
+    for payload in (baseline, card, direct):
+        assert payload["language"] == "rust"
+        assert payload["available"] is True
+        assert payload["process_key"] == process_id
+        assert payload["resolved_sum"] == pytest.approx(
+            payload["compatibility_total"], rel=1.0e-12, abs=1.0e-15
+        )
+        assert sum(payload["values"]) == pytest.approx(
+            payload["compatibility_total"][0], rel=1.0e-12, abs=1.0e-15
+        )
+    assert card["values"] == pytest.approx(direct["values"])
+    assert card["compatibility_total"] != pytest.approx(
+        baseline["compatibility_total"], rel=1.0e-10
+    )
+
+
+@pytest.fixture(scope="module")
+def external_sm_model(tmp_path_factory: pytest.TempPathFactory) -> CompiledModel:
+    resource = importlib.resources.files("pyamplicol").joinpath(
+        "assets/models/json/sm/sm.json"
+    )
+    cache = tmp_path_factory.mktemp("multilanguage-model-cache")
+    with importlib.resources.as_file(resource) as source:
+        return ModelSource.from_path(source, restriction="default").compile(
+            cache_dir=cache,
+            use_cache=True,
+        )
+
+
+@pytest.fixture(scope="module")
+def generated_bundles(
+    tmp_path_factory: pytest.TempPathFactory,
+    native_tools: _NativeTools,
+    external_sm_model: CompiledModel,
+) -> dict[str, _BuiltBundle]:
+    root = tmp_path_factory.mktemp("multilanguage-api")
+    return {
+        "mixed": _build_bundle(
+            root / "mixed-lc",
+            _MIXED_PROCESSES,
+            _MIXED_NAMES,
+            "lc",
+            external_sm_model,
+            native_tools,
+        ),
+        "single": _build_bundle(
+            root / "single-lc",
+            (_MIXED_PROCESSES[0],),
+            (_MIXED_NAMES[0],),
+            "lc",
+            external_sm_model,
+            native_tools,
+        ),
+        "nlc": _build_bundle(
+            root / "single-nlc",
+            (_MIXED_PROCESSES[0],),
+            (_MIXED_NAMES[0],),
+            "nlc",
+            external_sm_model,
+            native_tools,
+        ),
+        "full": _build_bundle(
+            root / "single-full",
+            (_MIXED_PROCESSES[0],),
+            (_MIXED_NAMES[0],),
+            "full",
+            external_sm_model,
+            native_tools,
+        ),
+    }
+
+
+@pytest.fixture(scope="module")
+def generated_eager_bundle(
+    tmp_path_factory: pytest.TempPathFactory,
+    native_tools: _NativeTools,
+) -> _BuiltBundle:
+    root = tmp_path_factory.mktemp("multilanguage-eager-api")
+    return _build_bundle(
+        root / "single-eager-lc",
+        (_EAGER_PROCESS,),
+        (_EAGER_NAME,),
+        "lc",
+        None,
+        native_tools,
+        execution_mode="eager",
+    )
+
+
+@pytest.fixture(scope="module")
+def generated_native_eager_bundles(
+    tmp_path_factory: pytest.TempPathFactory,
+    native_tools: _NativeTools,
+) -> dict[str, _BuiltBundle]:
+    root = tmp_path_factory.mktemp("multilanguage-native-eager-api")
+    bundles: dict[str, _BuiltBundle] = {}
+    for backend in (EvaluatorBackend.ASM, EvaluatorBackend.CPP):
+        evaluator = EvaluatorConfig(
+            backend=backend,
+            execution_mode="eager",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            cpp=CppConfig(compiler=native_tools.cxx),
+        )
+        prepared = ModelSource.built_in_sm().compile(
+            use_cache=True,
+            prepared_output=root / f"built-in-sm-{backend}.pyamplicol-model",
+            evaluator=evaluator,
+        )
+        bundles[str(backend)] = _build_bundle(
+            root / f"single-eager-{backend}",
+            (_EAGER_PROCESS,),
+            (f"ddbar_z_eager_{backend}",),
+            "lc",
+            prepared,
+            native_tools,
+            execution_mode="eager",
+            evaluator=evaluator,
+        )
+    return bundles
+
+
+def _driver_command(bundle: _BuiltBundle, language: str) -> list[str]:
+    if language == "python":
+        return [sys.executable, str(bundle.python_driver)]
+    if language == "c":
+        return [str(bundle.c_driver)]
+    if language == "cpp":
+        return [str(bundle.cpp_driver)]
+    if language == "fortran":
+        return [str(bundle.fortran_driver)]
+    if language == "rust":
+        return [str(bundle.rust_driver)]
+    raise AssertionError(language)
+
+
+def _run_python_driver_in_process(
+    command: list[str],
+) -> subprocess.CompletedProcess[str]:
+    driver = Path(command[1])
+    namespace = runpy.run_path(str(driver), run_name="_pyamplicol_api_driver")
+    main = namespace.get("main")
+    assert callable(main)
+    output = io.StringIO()
+    with (
+        patch.object(sys, "argv", [str(driver), *command[2:]]),
+        redirect_stdout(output),
+    ):
+        returncode = main()
+    assert isinstance(returncode, int)
+    return subprocess.CompletedProcess(command, returncode, output.getvalue(), "")
+
+
+def _run_driver(
+    bundle: _BuiltBundle,
+    language: str,
+    *,
+    process: str | None,
+    model_card: Path | None = None,
+    kinematics: Path | None = None,
+    override: float | None = None,
+    parameter_id: str = _PARAMETER_ID,
+    precision: int = 16,
+) -> dict[str, Any]:
+    command = [*_driver_command(bundle, language), "--json"]
+    if process is not None:
+        command.extend(("--process", process))
+    if model_card is not None:
+        command.extend(("--model-parameters", str(model_card)))
+    if kinematics is not None:
+        command.extend(("--kinematics", str(kinematics)))
+    if override is not None:
+        command.extend(("--set-parameter", parameter_id, f"{override:.17g}", "0"))
+    if precision != 16:
+        command.extend(("--precision", str(precision)))
+    if language == "python":
+        # Generation owns the restricted Symbolica session, and importing the
+        # public Python API initializes Symbolica even for binary64 evaluation.
+        # Exercise the same generated entry point in that session. Independent
+        # Python subprocess coverage lives in the serialized deployment smoke.
+        completed = _run_python_driver_in_process(command)
+    else:
+        completed = subprocess.run(
+            command,
+            cwd=bundle.artifact,
+            env=_source_environment(),
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+    assert completed.returncode == 0, (
+        f"{language} API driver failed\n"
+        f"stdout:\n{completed.stdout}\nstderr:\n{completed.stderr}"
+    )
+    try:
+        payload = json.loads(completed.stdout)
+    except json.JSONDecodeError as error:
+        pytest.fail(
+            f"{language} driver did not emit one JSON object: {error}\n"
+            f"stdout:\n{completed.stdout}\nstderr:\n{completed.stderr}"
+        )
+    assert payload["language"] == language
+    assert payload["available"] is True
+    assert payload["precision"] == precision
+    return payload
+
+
+@pytest.mark.parametrize("precision", (16, 32, 64))
+def test_python_driver_reuses_the_generation_session_at_every_precision(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, precision: int
+) -> None:
+    driver = tmp_path / "check_standalone.py"
+    bundle = _BuiltBundle(tmp_path, ("test",), driver, driver, driver, driver, driver)
+    commands: list[list[str]] = []
+
+    def in_process(command: list[str]) -> subprocess.CompletedProcess[str]:
+        commands.append(command)
+        payload = {"language": "python", "available": True, "precision": precision}
+        return subprocess.CompletedProcess(command, 0, json.dumps(payload), "")
+
+    def no_child(*_args: Any, **_kwargs: Any) -> None:
+        pytest.fail("Python API parity must reuse the generation session")
+
+    monkeypatch.setattr(
+        sys.modules[__name__], "_run_python_driver_in_process", in_process
+    )
+    monkeypatch.setattr(subprocess, "run", no_child)
+    assert _run_driver(bundle, "python", process="test", precision=precision)[
+        "precision"
+    ] == precision
+    assert len(commands) == 1
+    assert commands[0][:2] == [sys.executable, str(driver)]
+    assert ("--precision" in commands[0]) == (precision != 16)
+
+
+def _assert_numeric_sequence(actual: list[float], expected: list[float]) -> None:
+    assert len(actual) == len(expected)
+    assert actual == pytest.approx(expected, rel=1.0e-12, abs=1.0e-15)
+
+
+def _assert_language_payloads(payloads: dict[str, dict[str, Any]]) -> None:
+    reference = payloads["python"]
+    for language, payload in payloads.items():
+        for key in _METADATA_KEYS:
+            assert payload[key] == reference[key], (language, key)
+        _assert_numeric_sequence(payload["values"], reference["values"])
+        _assert_numeric_sequence(payload["resolved_sum"], reference["resolved_sum"])
+        _assert_numeric_sequence(
+            payload["compatibility_total"], reference["compatibility_total"]
+        )
+        _assert_numeric_sequence(
+            payload["resolved_sum"], payload["compatibility_total"]
+        )
+        assert len(payload["values"]) == (
+            payload["shape"][0] * payload["shape"][1] * payload["shape"][2]
+        )
+
+
+def _all_languages(
+    bundle: _BuiltBundle,
+    *,
+    process: str | None,
+    model_card: Path | None = None,
+    kinematics: Path | None = None,
+    override: float | None = None,
+    parameter_id: str = _PARAMETER_ID,
+) -> dict[str, dict[str, Any]]:
+    return {
+        language: _run_driver(
+            bundle,
+            language,
+            process=process,
+            model_card=model_card,
+            kinematics=kinematics,
+            override=override,
+            parameter_id=parameter_id,
+        )
+        for language in _LANGUAGES
+    }
+
+
+def _validation_point(bundle: _BuiltBundle, process_id: str) -> list[list[float]]:
+    lines = (bundle.artifact / "API/validation_points.dat").read_text(
+        encoding="ascii"
+    ).splitlines()
+    assert lines[0] == "RUSTICOL_VALIDATION_POINTS_V1"
+    for line in lines[1:]:
+        fields = line.split("\t")
+        if not fields or fields[0] != process_id:
+            continue
+        external_count = int(fields[1])
+        components = tuple(float(value) for value in fields[2:])
+        assert len(components) == external_count * 4
+        return [
+            list(components[offset : offset + 4])
+            for offset in range(0, len(components), 4)
+        ]
+    raise AssertionError(f"no validation point for {process_id!r}")
+
+
+def _reorder_point(
+    point: list[list[float]], permutation: tuple[int, ...]
+) -> list[list[float]]:
+    reordered: list[list[float] | None] = [None] * len(point)
+    for representative_index, public_index in enumerate(permutation):
+        reordered[public_index] = point[representative_index]
+    assert all(vector is not None for vector in reordered)
+    return [vector for vector in reordered if vector is not None]
+
+
+def _assert_public_metadata_permutation(
+    representative: dict[str, Any],
+    public: dict[str, Any],
+    permutation: tuple[int, ...],
+) -> None:
+    expected_particles: list[dict[str, Any] | None] = [None] * len(permutation)
+    for representative_index, public_index in enumerate(permutation):
+        expected_particles[public_index] = {
+            **representative["external_particles"][representative_index],
+            "index": public_index,
+        }
+    assert public["external_particles"] == expected_particles
+
+    for representative_helicity, public_helicity in zip(
+        representative["helicities"], public["helicities"], strict=True
+    ):
+        expected_values: list[int | None] = [None] * len(permutation)
+        for representative_index, public_index in enumerate(permutation):
+            expected_values[public_index] = representative_helicity["helicities"][
+                representative_index
+            ]
+        assert public_helicity["helicities"] == expected_values
+
+    def remap_word(word: list[int]) -> list[int]:
+        return [permutation[label - 1] + 1 for label in word]
+
+    assert [color["word"] for color in public["colors"]] == [
+        remap_word(color["word"]) for color in representative["colors"]
+    ]
+
+
+def test_all_generated_clients_load_and_evaluate_the_same_eager_artifact(
+    generated_eager_bundle: _BuiltBundle,
+    tmp_path: Path,
+) -> None:
+    bundle = generated_eager_bundle
+    manifest = json.loads(
+        (bundle.artifact / "artifact.json").read_text(encoding="utf-8")
+    )
+    assert manifest["default_process_id"] == bundle.process_ids[0]
+    assert (
+        manifest["runtime"]["required_runtime_capabilities"]
+        == _EAGER_DIRECT_RUNTIME_CAPABILITIES
+    )
+    for process_id in bundle.process_ids:
+        process = next(
+            item for item in manifest["processes"] if item["id"] == process_id
+        )
+        assert (
+            process["required_runtime_capabilities"]
+            == _EAGER_DIRECT_RUNTIME_CAPABILITIES
+        )
+        execution = json.loads(
+            (bundle.artifact / "processes" / process_id / "execution.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        assert execution["kind"] == "pyamplicol-runtime-eager-execution"
+
+    process_id = bundle.process_ids[0]
+    model_card = tmp_path / "eager-model-parameters.json"
+    updated_parameter = 0.008
+    model_card.write_text(
+        json.dumps({_EAGER_PARAMETER_ID: [updated_parameter, 0.0]}) + "\n",
+        encoding="utf-8",
+    )
+    baseline = _all_languages(bundle, process=process_id)
+    card = _all_languages(bundle, process=process_id, model_card=model_card)
+    direct = _all_languages(
+        bundle,
+        process=process_id,
+        override=updated_parameter,
+        parameter_id=_EAGER_PARAMETER_ID,
+    )
+    for payloads in (baseline, card, direct):
+        _assert_language_payloads(payloads)
+    _assert_numeric_sequence(card["python"]["values"], direct["python"]["values"])
+    assert card["python"]["compatibility_total"] != pytest.approx(
+        baseline["python"]["compatibility_total"], rel=1.0e-10
+    )
+
+
+def test_all_generated_clients_support_native_eager_kernel_backends(
+    generated_native_eager_bundles: dict[str, _BuiltBundle],
+) -> None:
+    for backend, bundle in generated_native_eager_bundles.items():
+        manifest = json.loads(
+            (bundle.artifact / "artifact.json").read_text(encoding="utf-8")
+        )
+        assert manifest["extensions"]["eager_prepared_pack"]["backend"] == backend
+        assert (
+            manifest["runtime"]["required_runtime_capabilities"]
+            == _EAGER_DIRECT_RUNTIME_CAPABILITIES
+        )
+        for process_id in bundle.process_ids:
+            process = next(
+                item for item in manifest["processes"] if item["id"] == process_id
+            )
+            assert (
+                process["required_runtime_capabilities"]
+                == _EAGER_DIRECT_RUNTIME_CAPABILITIES
+            )
+        _assert_language_payloads(_all_languages(bundle, process=bundle.process_ids[0]))
+
+
+def test_mixed_lc_bundle_agrees_for_all_processes_and_parameter_updates(
+    generated_bundles: dict[str, _BuiltBundle],
+    tmp_path: Path,
+) -> None:
+    bundle = generated_bundles["mixed"]
+    model_card = tmp_path / "model-parameters.json"
+    model_card.write_text(
+        json.dumps({_PARAMETER_ID: [0.109, 0.0]}) + "\n",
+        encoding="utf-8",
+    )
+    assert "alpha_s" not in model_card.read_text(encoding="utf-8").replace(
+        _PARAMETER_ID, ""
+    )
+
+    for process_id in bundle.process_ids:
+        baseline = _all_languages(bundle, process=process_id)
+        card = _all_languages(bundle, process=process_id, model_card=model_card)
+        direct = _all_languages(bundle, process=process_id, override=0.127)
+        for payloads in (baseline, card, direct):
+            _assert_language_payloads(payloads)
+
+        baseline_total = baseline["python"]["compatibility_total"][0]
+        card_total = card["python"]["compatibility_total"][0]
+        direct_total = direct["python"]["compatibility_total"][0]
+        assert card_total != pytest.approx(baseline_total, rel=1.0e-10)
+        assert direct_total != pytest.approx(baseline_total, rel=1.0e-10)
+
+
+@pytest.mark.parametrize(
+    ("expression", "stable_id"),
+    tuple(zip(_MIXED_PROCESSES, _MIXED_NAMES, strict=True)),
+)
+def test_all_languages_select_processes_by_concrete_expression(
+    generated_bundles: dict[str, _BuiltBundle],
+    expression: str,
+    stable_id: str,
+) -> None:
+    bundle = generated_bundles["mixed"]
+    selector = "  ".join(expression.split())
+    payloads = _all_languages(bundle, process=selector)
+
+    _assert_language_payloads(payloads)
+    assert payloads["python"]["process"].casefold() == expression.casefold()
+    assert payloads["python"]["process_key"] == stable_id
+
+
+def test_all_languages_infer_public_order_and_accept_custom_kinematics(
+    generated_bundles: dict[str, _BuiltBundle],
+    tmp_path: Path,
+) -> None:
+    bundle = generated_bundles["mixed"]
+    representative_id = _MIXED_NAMES[1]
+    requested_process = "d d~ > g z g"
+    permutation = (0, 1, 3, 2, 4)
+
+    representative = _all_languages(bundle, process=representative_id)
+    public_default = _all_languages(bundle, process=requested_process)
+    for payloads in (representative, public_default):
+        _assert_language_payloads(payloads)
+    for language in _LANGUAGES:
+        public = public_default[language]
+        source = representative[language]
+        assert public["process"].casefold() == requested_process.casefold()
+        assert public["process_key"] == representative_id
+        _assert_public_metadata_permutation(source, public, permutation)
+        _assert_numeric_sequence(public["values"], source["values"])
+        _assert_numeric_sequence(
+            public["compatibility_total"], source["compatibility_total"]
+        )
+
+    representative_point = _validation_point(bundle, representative_id)
+    public_point = _reorder_point(representative_point, permutation)
+    numeric_path = tmp_path / "public-numeric-kinematics.json"
+    numeric_path.write_text(json.dumps(public_point) + "\n", encoding="utf-8")
+    string_path = tmp_path / "public-string-kinematics.json"
+    string_point = [[format(value, ".17g") for value in leg] for leg in public_point]
+    string_path.write_text(json.dumps([string_point]) + "\n", encoding="utf-8")
+
+    numeric = _all_languages(
+        bundle,
+        process=requested_process,
+        kinematics=numeric_path,
+    )
+    strings = _all_languages(
+        bundle,
+        process=requested_process,
+        kinematics=string_path,
+    )
+    for payloads in (numeric, strings):
+        _assert_language_payloads(payloads)
+        _assert_numeric_sequence(
+            payloads["python"]["values"], public_default["python"]["values"]
+        )
+
+    model_card = tmp_path / "ufo-model-parameters.json"
+    model_card.write_text(
+        json.dumps({_PARAMETER_ID: [0.109, 0.0]}) + "\n",
+        encoding="utf-8",
+    )
+    overridden = _all_languages(
+        bundle,
+        process=requested_process,
+        model_card=model_card,
+        override=0.127,
+    )
+    direct = _all_languages(bundle, process=requested_process, override=0.127)
+    for payloads in (overridden, direct):
+        _assert_language_payloads(payloads)
+    _assert_numeric_sequence(
+        overridden["python"]["values"], direct["python"]["values"]
+    )
+
+    high_precision_a = tmp_path / "public-high-precision-a.json"
+    high_precision_b = tmp_path / "public-high-precision-b.json"
+    perturbed = [list(leg) for leg in string_point]
+    perturbed[0][0] = str(Decimal(perturbed[0][0]) + Decimal("1e-25"))
+    high_precision_a.write_text(json.dumps(string_point) + "\n", encoding="utf-8")
+    high_precision_b.write_text(json.dumps(perturbed) + "\n", encoding="utf-8")
+    exact_a = _run_driver(
+        bundle,
+        "python",
+        process=requested_process,
+        kinematics=high_precision_a,
+        precision=50,
+    )
+    exact_b = _run_driver(
+        bundle,
+        "python",
+        process=requested_process,
+        kinematics=high_precision_b,
+        precision=50,
+    )
+    assert exact_a["compatibility_total"] != exact_b["compatibility_total"]
+
+
+def test_single_process_bundle_uses_default_process_without_selector(
+    generated_bundles: dict[str, _BuiltBundle],
+) -> None:
+    bundle = generated_bundles["single"]
+    payloads = _all_languages(bundle, process=None)
+    _assert_language_payloads(payloads)
+    assert payloads["python"]["process_key"] == bundle.process_ids[0]
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_native_contracted_color_is_one_component_per_helicity(
+    generated_bundles: dict[str, _BuiltBundle],
+    accuracy: str,
+) -> None:
+    bundle = generated_bundles[accuracy]
+    payloads = _all_languages(bundle, process=bundle.process_ids[0])
+    _assert_language_payloads(payloads)
+    payload = payloads["python"]
+    assert payload["color_accuracy"] == accuracy
+    assert payload["shape"][2] == 1
+    assert len(payload["colors"]) == 1
+    assert payload["colors"][0]["kind"] == "contracted-color"
+    assert payload["colors"][0]["word"] == []
diff --git a/pyamplicol/tests/integration/test_numerical_acceptance.py b/pyamplicol/tests/integration/test_numerical_acceptance.py
new file mode 100644
index 0000000000..5d3062d65c
--- /dev/null
+++ b/pyamplicol/tests/integration/test_numerical_acceptance.py
@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: 0BSD
+"""Environment-gated real numerical acceptance across all fifteen UFO-SM lanes."""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+
+import pytest
+
+from tools.developer.numerical_acceptance import (
+    DEFAULT_FIXTURE,
+    EXTRA_FULL_COLOUR_CASES,
+    NumericalAcceptanceHarness,
+    catalog_cases,
+)
+
+pytestmark = pytest.mark.skipif(
+    os.environ.get("PYAMPLICOL_RUN_NUMERICAL_ACCEPTANCE") != "1",
+    reason=(
+        "set PYAMPLICOL_RUN_NUMERICAL_ACCEPTANCE=1 to run the full numerical "
+        "acceptance matrix"
+    ),
+)
+
+
+def _unavailable(reason: str) -> None:
+    if os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1":
+        pytest.fail(reason)
+    pytest.skip(reason)
+
+
+def _require_native_dependencies() -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    if importlib.util.find_spec("symbolica") is None:
+        _unavailable("Symbolica is unavailable")
+
+
+@pytest.fixture(scope="module")
+def acceptance(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> NumericalAcceptanceHarness:
+    _require_native_dependencies()
+    if not DEFAULT_FIXTURE.is_file():
+        pytest.fail(
+            f"the numerical acceptance fixture has not been captured: {DEFAULT_FIXTURE}"
+        )
+    return NumericalAcceptanceHarness.prepare(
+        DEFAULT_FIXTURE,
+        work_root=tmp_path_factory.mktemp("numerical-acceptance"),
+    )
+
+
+@pytest.mark.parametrize(
+    "case_id",
+    tuple(case.case_id for case in catalog_cases()),
+)
+def test_catalog_numerical_acceptance_case(
+    acceptance: NumericalAcceptanceHarness,
+    case_id: str,
+) -> None:
+    acceptance.assert_catalog_case(case_id)
+
+
+@pytest.mark.parametrize(
+    "case_id",
+    tuple(case.case_id for case in EXTRA_FULL_COLOUR_CASES),
+)
+def test_non_catalog_full_colour_madgraph_benchmark(
+    acceptance: NumericalAcceptanceHarness,
+    case_id: str,
+) -> None:
+    acceptance.assert_full_extra(case_id)
diff --git a/pyamplicol/tests/integration/test_numerical_current_warmup_real_a.py b/pyamplicol/tests/integration/test_numerical_current_warmup_real_a.py
new file mode 100644
index 0000000000..61fff8ccea
--- /dev/null
+++ b/pyamplicol/tests/integration/test_numerical_current_warmup_real_a.py
@@ -0,0 +1,114 @@
+# SPDX-License-Identifier: 0BSD
+"""Heavy real-A regression for generic-DAG current-output isolation."""
+
+from __future__ import annotations
+
+import os
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from pyamplicol import Generator
+from pyamplicol.api.errors import GenerationError
+from pyamplicol.config import (
+    Action,
+    ColorAccuracy,
+    ColorConfig,
+    EvaluatorConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    RunConfig,
+)
+from pyamplicol.generation import numerical_current_warmup
+
+_ACCEPTANCE_ENV = "PYAMPLICOL_RUN_GENERIC_DAG_REAL_A_REGRESSION"
+_PROCESS = "g g > t t~ g g g"
+
+pytestmark = pytest.mark.skipif(
+    os.environ.get(_ACCEPTANCE_ENV) != "1",
+    reason=f"set {_ACCEPTANCE_ENV}=1 to run the heavy real-A regression",
+)
+
+
+class _RealAValidated(RuntimeError):
+    pass
+
+
+def test_nlc_helicity_sum_application_is_decimal_identical(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    real_apply = (
+        numerical_current_warmup.apply_numerical_current_relation_certificates
+    )
+    real_validate = (
+        numerical_current_warmup._validate_applied_current_observations
+    )
+    applications: list[Any] = []
+    validations: list[tuple[Any, Any, dict[str, object]]] = []
+
+    def apply(*args: Any, **kwargs: Any) -> Any:
+        result = real_apply(*args, **kwargs)
+        if len(result.dag.currents) == 21_434:
+            applications.append(result)
+        return result
+
+    def validate(reference: Any, applied: Any, **kwargs: Any) -> Any:
+        result = real_validate(reference, applied, **kwargs)
+        if len(reference.observations) == 21_434:
+            validations.append((reference, applied, result))
+            raise _RealAValidated
+        return result
+
+    monkeypatch.setattr(
+        numerical_current_warmup,
+        "apply_numerical_current_relation_certificates",
+        apply,
+    )
+    monkeypatch.setattr(
+        numerical_current_warmup,
+        "_validate_applied_current_observations",
+        validate,
+    )
+
+    config = RunConfig(
+        action=Action.GENERATE,
+        color=ColorConfig(accuracy=ColorAccuracy.NLC),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(samples=1),
+        ),
+    )
+    with pytest.raises(GenerationError) as captured:
+        Generator(config).generate(_PROCESS, tmp_path / "real-a")
+
+    assert isinstance(captured.value.__cause__, _RealAValidated)
+    assert len(applications) == len(validations) == 1
+    application = applications[0]
+    reference, applied, validation = validations[0]
+    assert tuple(
+        certificate.current_id
+        for certificate in application.report.certificates
+    ) == (15, 16, 21, 23)
+    assert all(
+        certificate.relation_kind == "zero"
+        for certificate in application.report.certificates
+    )
+    assert application.report.applied_relation_count == 4
+    assert application.report.interaction_evaluation_count_before == 74_260
+    assert application.report.interaction_evaluation_count_projected == 73_996
+    assert validation["checked_current_count"] == 21_434
+    assert validation["checked_component_count"] == 362_784
+    assert validation["maximum_absolute_residual"] == "0"
+    assert validation["maximum_relative_residual"] == "0"
+    assert validation["maximum_tolerance_ratio"] == "0"
+    assert (
+        reference.observation_batch_sha256
+        == applied.observation_batch_sha256
+    )
+    assert reference.observations[202][1] == applied.observations[202][1]
+    assert Decimal(str(validation["maximum_tolerance_ratio"])) <= Decimal(1)
diff --git a/pyamplicol/tests/integration/test_on_the_fly_artifact_probe.py b/pyamplicol/tests/integration/test_on_the_fly_artifact_probe.py
new file mode 100644
index 0000000000..f25c8cdecf
--- /dev/null
+++ b/pyamplicol/tests/integration/test_on_the_fly_artifact_probe.py
@@ -0,0 +1,790 @@
+# SPDX-License-Identifier: 0BSD
+"""Genuine-artifact canary for the hidden on-the-fly execution probe."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import json
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+import pyamplicol.generation.service as generation_service
+from pyamplicol import Generator, ModelSource, ProcessRequest, Runtime
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from tools.developer import on_the_fly_lc_gate as lc_gate
+
+_MODEL = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "scalars"
+    / "scalars.json"
+)
+_HELICITIES = (0, 0, 0, 0)
+_SM_SEEDS = (101, 211)
+_IDENTICAL_SIX_FERMION_HELICITIES = (
+    "h:-1,+1,-1,+1,-1,+1",
+    "h:-1,+1,+1,-1,+1,-1",
+    "h:+1,-1,-1,+1,-1,+1",
+    "h:+1,-1,+1,-1,+1,-1",
+)
+_S = 1_000_000.0
+_FINAL_ONE_ENERGY = (_S + 1.0 - 4.0) / 2_000.0
+_FINAL_TWO_ENERGY = (_S + 4.0 - 1.0) / 2_000.0
+_FINAL_MOMENTUM = math.sqrt(_FINAL_ONE_ENERGY * _FINAL_ONE_ENERGY - 1.0)
+_POINT_0012 = (
+    (500.0, 0.0, 0.0, 500.0),
+    (500.0, 0.0, 0.0, -500.0),
+    (_FINAL_ONE_ENERGY, 0.0, 0.0, _FINAL_MOMENTUM),
+    (_FINAL_TWO_ENERGY, 0.0, 0.0, -_FINAL_MOMENTUM),
+)
+_POINT_0000 = (
+    (500.0, 0.0, 0.0, 500.0),
+    (500.0, 0.0, 0.0, -500.0),
+    (500.0, 0.0, 0.0, 500.0),
+    (500.0, 0.0, 0.0, -500.0),
+)
+
+
+def _hidden_artifact_probe() -> Any:
+    """Return the optional development probe or skip its private canaries.
+
+    ``PYAMPLICOL_REQUIRE_NATIVE_TESTS`` requires the production native runtime;
+    it does not make test-only Cargo features part of candidate or release
+    wheels.  Keep every canary in this file behind the same feature check.
+    """
+
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+    rusticol = importlib.import_module("pyamplicol._rusticol")
+    probe = getattr(rusticol, "_on_the_fly_artifact_probe_v1", None)
+    if not callable(probe):
+        pytest.skip("the native extension lacks on-the-fly test support")
+    return probe
+
+
+@dataclass(frozen=True)
+class _ScalarContactCase:
+    process: str
+    process_id: str
+    vertex: str
+    point: tuple[tuple[float, ...], ...]
+    normalization_factor: float
+
+
+_CASES = (
+    _ScalarContactCase(
+        process="scalar_0 scalar_0 > scalar_0 scalar_0",
+        process_id="scalars_0000",
+        vertex="V_4_SCALAR_0000",
+        point=_POINT_0000,
+        normalization_factor=0.5,
+    ),
+    _ScalarContactCase(
+        process="scalar_0 scalar_0 > scalar_1 scalar_2",
+        process_id="scalars_0012",
+        vertex="V_4_SCALAR_0012",
+        point=_POINT_0012,
+        normalization_factor=1.0,
+    ),
+)
+
+
+def _analytic_scalar_contact(case: _ScalarContactCase, coupling: float) -> float:
+    # Both selected V4 vertices have color 1, Lorentz structure 1, and raw
+    # amplitude i*lam.  The only normalization difference is the factor 1/2
+    # for the two identical scalar_0 particles in the 0000 final state.
+    return case.normalization_factor * coupling * coupling
+
+
+def _config() -> RunConfig:
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc", lc_flow_layout="topology-replay"),
+        process=ProcessConfig(
+            coupling_order_policy="explicit",
+            max_coupling_orders={"QCD": 1, "QED": 0},
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="recurrence",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+def _flatten(points: tuple[tuple[tuple[float, ...], ...], ...]) -> list[float]:
+    return [
+        component for point in points for momentum in point for component in momentum
+    ]
+
+
+def _transverse(point: tuple[tuple[float, ...], ...]) -> tuple[tuple[float, ...], ...]:
+    outgoing_one = point[2]
+    outgoing_two = point[3]
+    return (
+        point[0],
+        point[1],
+        (outgoing_one[0], outgoing_one[3], 0.0, 0.0),
+        (outgoing_two[0], outgoing_two[3], 0.0, 0.0),
+    )
+
+
+def _established_resolved_totals(
+    runtime: Runtime, points: tuple[Any, ...]
+) -> tuple[float, ...]:
+    resolved = runtime.evaluate_resolved(points)
+    assert resolved.helicity_ids == ("h:+0,+0,+0,+0",)
+    assert resolved.color_ids == ("flow:singlet",)
+    values = tuple(complex(value) for value in resolved.total())
+    assert all(value.imag == pytest.approx(0.0, abs=1.0e-15) for value in values)
+    return tuple(value.real for value in values)
+
+
+def _canonical_direct_catalog_json(retained: dict[str, object]) -> bytes:
+    direct_json = retained["direct_template_catalog_json"]
+    assert isinstance(direct_json, bytes)
+    assert direct_json == json.dumps(
+        retained["direct_template_catalog"].to_dict(),  # type: ignore[union-attr]
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return direct_json
+
+
+def _invoke_probe(
+    probe: Any,
+    artifact: Path,
+    case: _ScalarContactCase,
+    retained: dict[str, object],
+    direct_json: bytes,
+    points: tuple[tuple[tuple[float, ...], ...], ...],
+    *,
+    overrides: dict[str, list[float]] | None = None,
+    pack_digest: str | None = None,
+    tamper: bool = False,
+    benchmark: bool = False,
+    benchmark_warmup_repetitions: int = 0,
+    benchmark_repetitions: int = 0,
+    collect_current_diagnostics: bool = True,
+    enable_color_projection: bool = True,
+) -> dict[str, Any]:
+    return probe(
+        str(artifact),
+        case.process_id,
+        retained["builder_input"],
+        retained["prepared_template_input"],
+        direct_json,
+        pack_digest or retained["prepared_kernel_pack_digest"],
+        0,
+        list(_HELICITIES),
+        _flatten(points),
+        len(points),
+        parameter_overrides=overrides,
+        tamper_executor_key=tamper,
+        benchmark=benchmark,
+        benchmark_warmup_repetitions=benchmark_warmup_repetitions,
+        benchmark_repetitions=benchmark_repetitions,
+        collect_current_diagnostics=collect_current_diagnostics,
+        enable_color_projection=enable_color_projection,
+    )
+
+
+def _assert_zero_poison_counts(report: dict[str, Any]) -> None:
+    assert report["direct_plan_load_attempts"] == 0
+    assert report["direct_plan_decode_attempts"] == 0
+    assert report["direct_plan_materialization_attempts"] == 0
+    assert report["established_builder_attempts"] == 0
+
+
+def _assert_raw_i_lambda(report: dict[str, Any], coupling: float) -> None:
+    for raw in report["raw_amplitudes"]:
+        assert raw[0] == pytest.approx(0.0, abs=1.0e-14)
+        assert raw[1] == pytest.approx(coupling)
+
+
+_WORK_CENSUS_FIELDS = (
+    "work_census_basis",
+    "logical_current_count",
+    "resident_current_count",
+    "resident_current_component_count",
+    "source_operation_count",
+    "contribution_operation_count",
+    "finalization_operation_count",
+    "closure_operation_count",
+    "total_kernel_application_count",
+    "semantic_executor_binding_count",
+    "distinct_prepared_executor_count",
+)
+
+
+def _work_census(report: dict[str, Any]) -> tuple[object, ...]:
+    assert report["work_census_basis"] == "fully-resident-query-local-trace-v1"
+    assert report["logical_current_count"] == report["resident_current_count"]
+    resident_components = report["resident_current_component_count"]
+    assert resident_components >= report["resident_current_count"]
+    assert report["source_operation_count"] == 4
+    assert report["closure_operation_count"] >= 1
+    assert report["total_kernel_application_count"] == sum(
+        report[name]
+        for name in (
+            "source_operation_count",
+            "contribution_operation_count",
+            "finalization_operation_count",
+            "closure_operation_count",
+        )
+    )
+    assert (
+        0
+        < report["distinct_prepared_executor_count"]
+        <= report["semantic_executor_binding_count"]
+        <= report["total_kernel_application_count"]
+    )
+    return tuple(report[name] for name in _WORK_CENSUS_FIELDS)
+
+
+def _assert_hidden_probe_matches_sm_process(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    process: str,
+    process_id: str,
+    *,
+    selected_helicity_ids: tuple[str, ...] | None = None,
+    expected_flow_count: int | None = None,
+    expected_query_count: int | None = None,
+) -> None:
+    probe = _hidden_artifact_probe()
+    monkeypatch.setattr(lc_gate, "PROCESS", process)
+    monkeypatch.setattr(lc_gate, "PROCESS_ID", process_id)
+    monkeypatch.setattr(lc_gate, "SEEDS", _SM_SEEDS)
+    config = lc_gate._on_the_fly_config()
+    prepared = ModelSource.built_in_sm().compile(
+        cache_dir=tmp_path / "fresh-built-in-sm-cache",
+        use_cache=False,
+        prepared_output=(
+            tmp_path / f"fresh-{process_id}-built-in-sm-jit-o2.pyamplicol-model"
+        ),
+        evaluator=config.evaluator,
+    )
+    on_the_fly_artifact = tmp_path / f"fresh-{process_id}-on-the-fly-artifact"
+    lc_gate._generate_on_the_fly(on_the_fly_artifact, prepared)
+    recurrence_artifact = tmp_path / f"fresh-{process_id}-recurrence-probe"
+    retained = lc_gate._generate_probe_carrier(
+        recurrence_artifact,
+        prepared,
+    )
+    runtime = Runtime.load(recurrence_artifact, process=process_id)
+    on_the_fly_runtime = Runtime.load(on_the_fly_artifact, process=process_id)
+    points = lc_gate._points()
+    resolved = runtime.evaluate_resolved(points)
+    on_the_fly_resolved = on_the_fly_runtime.evaluate_resolved(points)
+    helicity_axis, color_axis = lc_gate._axes(resolved)
+    on_the_fly_helicity_axis, on_the_fly_color_axis = lc_gate._axes(on_the_fly_resolved)
+    assert on_the_fly_helicity_axis == helicity_axis
+    assert on_the_fly_color_axis == color_axis
+    flows = tuple(runtime.physics.color_flows)
+    helicities = tuple(
+        helicity
+        for helicity in runtime.physics.helicities
+        if not helicity.structural_zero
+    )
+    assert flows
+    assert helicities
+    if expected_flow_count is not None:
+        assert len(flows) == expected_flow_count
+    if selected_helicity_ids is not None:
+        selected = frozenset(selected_helicity_ids)
+        helicities = tuple(
+            helicity for helicity in helicities if helicity.id in selected
+        )
+        assert len(helicities) == len(selected_helicity_ids)
+        assert {helicity.id for helicity in helicities} == selected
+    census: list[tuple[str, dict[str, object], bool]] = []
+    for flow in flows:
+        for helicity in helicities:
+            selector = f"{flow.id}|{helicity.id}"
+            expected = tuple(
+                point[helicity_axis[helicity.id]][color_axis[flow.id]]
+                for point in resolved.values
+            )
+            public_on_the_fly = tuple(
+                point[on_the_fly_helicity_axis[helicity.id]][
+                    on_the_fly_color_axis[flow.id]
+                ]
+                for point in on_the_fly_resolved.values
+            )
+            lc_gate._series(public_on_the_fly, expected, f"{selector} public")
+            query = lc_gate._query(flow, helicity)
+            projected_report = lc_gate._invoke(
+                probe,
+                recurrence_artifact,
+                retained,
+                query,
+                points,
+                enable_color_projection=True,
+            )
+            bypass_report = lc_gate._invoke(
+                probe,
+                recurrence_artifact,
+                retained,
+                query,
+                points,
+                enable_color_projection=False,
+            )
+            projected = lc_gate._probe_values(projected_report, len(points))
+            bypass = lc_gate._probe_values(bypass_report, len(points))
+            try:
+                lc_gate._series(projected, expected, selector)
+            except lc_gate.GateError as error:
+                try:
+                    lc_gate._series(bypass, expected, f"{selector} bypass")
+                except lc_gate.GateError:
+                    localization = "pre-projection or shared execution"
+                else:
+                    localization = "late color projection"
+                pytest.fail(f"{error}; localized to {localization}")
+            try:
+                lc_gate._series(bypass, expected, f"{selector} bypass")
+            except lc_gate.GateError:
+                bypass_matches = False
+            else:
+                bypass_matches = True
+            census.append(
+                (
+                    selector,
+                    lc_gate._work_census(projected_report),
+                    bypass_matches,
+                )
+            )
+
+    if expected_query_count is not None:
+        assert len(census) == expected_query_count
+
+    print(
+        f"genuine on-the-fly {process} component census:",
+        f"flows={len(flows)} helicities={len(helicities)} "
+        f"components={len(census)} point-checks={len(census) * len(points)} ",
+        census,
+    )
+
+
+def test_hidden_on_the_fly_probe_matches_every_physical_sm_n3_component(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _assert_hidden_probe_matches_sm_process(
+        tmp_path,
+        monkeypatch,
+        "d d~ > t t~ g",
+        "otf_dd_tt_g",
+    )
+
+
+def test_hidden_on_the_fly_probe_matches_every_physical_sm_n2_component(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _assert_hidden_probe_matches_sm_process(
+        tmp_path,
+        monkeypatch,
+        "d d~ > t t~",
+        "otf_dd_tt",
+    )
+
+
+def test_hidden_on_the_fly_probe_matches_every_physical_sm_n3_z_component(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _assert_hidden_probe_matches_sm_process(
+        tmp_path,
+        monkeypatch,
+        "d d~ > t t~ z",
+        "otf_dd_tt_z",
+    )
+
+
+def test_hidden_on_the_fly_probe_matches_identical_six_fermion_wick_lineages(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _assert_hidden_probe_matches_sm_process(
+        tmp_path,
+        monkeypatch,
+        "d d~ > u u~ u u~",
+        "otf_dd_uu_uu",
+        selected_helicity_ids=_IDENTICAL_SIX_FERMION_HELICITIES,
+        expected_flow_count=6,
+        expected_query_count=24,
+    )
+
+
+def test_hidden_on_the_fly_probe_matches_identical_leptonic_wick_lineages(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _assert_hidden_probe_matches_sm_process(
+        tmp_path,
+        monkeypatch,
+        "d d~ > e+ e- e+ e-",
+        "otf_dd_epem_epem",
+        selected_helicity_ids=_IDENTICAL_SIX_FERMION_HELICITIES,
+        expected_flow_count=1,
+        expected_query_count=4,
+    )
+
+
+@pytest.mark.parametrize(
+    ("process", "process_id"),
+    (
+        ("g g > t t~", "otf_gg_tt"),
+        ("d d~ > e+ e- g", "otf_dd_epem_g"),
+        ("d d~ > u u~ g", "otf_dd_uu_g"),
+    ),
+    ids=("three-gluon-binding", "single-wick-line", "two-open-color-lines"),
+)
+def test_hidden_on_the_fly_probe_sm_low_multiplicity_discriminators(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    process: str,
+    process_id: str,
+) -> None:
+    _assert_hidden_probe_matches_sm_process(
+        tmp_path,
+        monkeypatch,
+        process,
+        process_id,
+    )
+
+
+def test_hidden_on_the_fly_probe_executes_genuine_scalar_artifact(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    probe = _hidden_artifact_probe()
+    rusticol = importlib.import_module("pyamplicol._rusticol")
+    if importlib.util.find_spec("symbolica") is None:
+        pytest.skip("Symbolica is unavailable")
+
+    config = _config()
+    prepared_output = tmp_path / "fresh-scalar-jit-o2.pyamplicol-model"
+    assert not prepared_output.exists()
+    prepared = ModelSource.from_path(_MODEL).compile(
+        cache_dir=tmp_path / "fresh-model-cache",
+        use_cache=False,
+        prepared_output=prepared_output,
+        evaluator=config.evaluator,
+    )
+    assert prepared_output.is_file()
+    captured: list[dict[str, object]] = []
+    original = generation_service._invoke_rust_recurrence_lowering_v2
+
+    def capture_lowering(*args: object, **kwargs: object) -> object:
+        captured.append(
+            {
+                "builder_input": args[0],
+                "prepared_template_input": args[1],
+                "direct_template_catalog": args[2],
+                "prepared_kernel_pack_digest": args[3],
+                "direct_template_catalog_json": kwargs.get(
+                    "direct_template_catalog_json"
+                ),
+            }
+        )
+        return original(*args, **kwargs)
+
+    monkeypatch.setattr(
+        generation_service,
+        "_invoke_rust_recurrence_lowering_v2",
+        capture_lowering,
+    )
+    generated: dict[str, tuple[_ScalarContactCase, Path, dict[str, object], bytes]] = {}
+    for case in _CASES:
+        artifact = tmp_path / f"fresh-{case.process_id}-artifact"
+        assert not artifact.exists()
+        Generator(config).generate(
+            ProcessRequest.parse(case.process, name=case.process_id),
+            artifact,
+            model=prepared,
+        )
+        assert artifact.exists()
+        assert len(captured) == len(generated) + 1
+        retained = captured[-1]
+        # These are the exact canonical bytes supplied to genuine lowering,
+        # not a reconstruction from the completed artifact.
+        direct_json = _canonical_direct_catalog_json(retained)
+        generated[case.process_id] = (case, artifact, retained, direct_json)
+
+    diagnostics: dict[str, object] = {}
+    for case, artifact, retained, direct_json in generated.values():
+        runtime = Runtime.load(artifact, process=case.process_id)
+        transverse = _transverse(case.point)
+        single_points = ((case.point,), (transverse,))
+        established_default = _established_resolved_totals(
+            runtime, (case.point, transverse)
+        )
+        expected_default = _analytic_scalar_contact(case, 1.0)
+        assert established_default == pytest.approx(
+            (expected_default, expected_default)
+        )
+
+        singles = tuple(
+            _invoke_probe(
+                probe,
+                artifact,
+                case,
+                retained,
+                direct_json,
+                points,
+            )
+            for points in single_points
+        )
+        bypass = _invoke_probe(
+            probe,
+            artifact,
+            case,
+            retained,
+            direct_json,
+            single_points[0],
+            enable_color_projection=False,
+        )
+        assert singles[0]["projection_enabled"] is True
+        assert bypass["projection_enabled"] is False
+        assert bypass["projection_applied"] is False
+        for name in ("current_count", "contribution_count", "closure_count"):
+            assert (
+                bypass[f"pre_projection_{name}"] == singles[0][f"pre_projection_{name}"]
+            )
+        assert bypass["raw_amplitudes"] == singles[0]["raw_amplitudes"]
+        batch_order = (0, 1, 1, 0, 1, 0, 0)
+        batch_points = tuple(single_points[index][0] for index in batch_order)
+        many = _invoke_probe(
+            probe,
+            artifact,
+            case,
+            retained,
+            direct_json,
+            batch_points,
+        )
+        one = singles[0]
+        assert one["process_id"] == case.process_id
+        assert one["point_count"] == 1
+        assert many["point_count"] == len(batch_order)
+        assert one["artifact_id"] == many["artifact_id"]
+        assert all(
+            report["seed_digest"] == one["seed_digest"]
+            and report["query_digest"] == one["query_digest"]
+            and report["trace_digest"] == one["trace_digest"]
+            for report in (*singles, many)
+        )
+        assert one["normalization_factor"] == pytest.approx(case.normalization_factor)
+        work_census = _work_census(one)
+        assert one["normalized_values"] == pytest.approx((expected_default,))
+        assert many["normalized_values"] == pytest.approx(
+            (expected_default,) * len(batch_order)
+        )
+        for report in (*singles, many):
+            assert _work_census(report) == work_census
+            _assert_zero_poison_counts(report)
+            assert report["trace_build_count"] == 1
+            assert report["trace_cache_hit_count"] == 0
+            assert report["momentum_fill_count"] == 1
+            assert report["benchmark_warmup_repetitions"] == 0
+            assert report["benchmark_repetitions"] == 0
+            assert report["benchmark_elapsed_seconds"] is None
+            assert report["benchmark_seconds_per_point"] is None
+            _assert_raw_i_lambda(report, 1.0)
+            for raw, normalized in zip(
+                report["raw_amplitudes"],
+                report["normalized_values"],
+                strict=True,
+            ):
+                assert normalized == pytest.approx(
+                    (raw[0] * raw[0] + raw[1] * raw[1]) * report["normalization_factor"]
+                )
+
+        assert one["currents"]
+        one_digests = [current["semantic_digest"] for current in one["currents"]]
+        assert all(
+            [current["semantic_digest"] for current in report["currents"]]
+            == one_digests
+            for report in (*singles, many)
+        )
+        for current_index, many_current in enumerate(many["currents"]):
+            width = many_current["component_count"]
+            assert len(many_current["values"]) == len(batch_order) * width
+            for point_index, single_index in enumerate(batch_order):
+                single_current = singles[single_index]["currents"][current_index]
+                assert single_current["component_count"] == width
+                assert len(single_current["values"]) == width
+                start = point_index * width
+                assert (
+                    many_current["values"][start : start + width]
+                    == single_current["values"]
+                )
+                assert (
+                    many["raw_amplitudes"][point_index]
+                    == singles[single_index]["raw_amplitudes"][0]
+                )
+
+        runtime.set_model_parameters({"lam": 3.0})
+        established_mutated = _established_resolved_totals(runtime, (case.point,))[0]
+        expected_mutated = _analytic_scalar_contact(case, 3.0)
+        assert established_mutated == pytest.approx(expected_mutated)
+        mutated = _invoke_probe(
+            probe,
+            artifact,
+            case,
+            retained,
+            direct_json,
+            (case.point,),
+            overrides={"lam": [3.0, 0.0]},
+        )
+        assert _work_census(mutated) == work_census
+        _assert_zero_poison_counts(mutated)
+        _assert_raw_i_lambda(mutated, 3.0)
+        assert mutated["trace_digest"] == one["trace_digest"]
+        assert mutated["normalized_values"] == pytest.approx((expected_mutated,))
+        assert mutated["normalized_values"] == pytest.approx((established_mutated,))
+        # `lam` is a runtime input while SCALAR_COUPLING is the prepared
+        # derived slot consumed by the executor. This exact factor-three raw
+        # scaling exercises the authenticated runtime-to-prepared projection.
+        assert mutated["raw_amplitudes"][0][0] == pytest.approx(
+            3.0 * one["raw_amplitudes"][0][0]
+        )
+        assert mutated["raw_amplitudes"][0][1] == pytest.approx(
+            3.0 * one["raw_amplitudes"][0][1]
+        )
+
+        benchmark = _invoke_probe(
+            probe,
+            artifact,
+            case,
+            retained,
+            direct_json,
+            (case.point,),
+            benchmark=True,
+            benchmark_warmup_repetitions=2,
+            benchmark_repetitions=5,
+            collect_current_diagnostics=False,
+        )
+        assert _work_census(benchmark) == work_census
+        _assert_zero_poison_counts(benchmark)
+        _assert_raw_i_lambda(benchmark, 1.0)
+        assert benchmark["normalized_values"] == pytest.approx((expected_default,))
+        assert benchmark["currents"] == []
+        assert benchmark["trace_build_count"] == 1
+        assert benchmark["trace_cache_hit_count"] == 7
+        assert benchmark["momentum_fill_count"] == 7
+        assert benchmark["benchmark_warmup_repetitions"] == 2
+        assert benchmark["benchmark_repetitions"] == 5
+        assert math.isfinite(benchmark["benchmark_elapsed_seconds"])
+        assert benchmark["benchmark_elapsed_seconds"] >= 0.0
+        assert benchmark["benchmark_seconds_per_point"] == pytest.approx(
+            benchmark["benchmark_elapsed_seconds"] / 5.0
+        )
+
+        with pytest.raises(ValueError, match="at least one timed repetition"):
+            _invoke_probe(
+                probe,
+                artifact,
+                case,
+                retained,
+                direct_json,
+                (case.point,),
+                benchmark=True,
+            )
+
+        with pytest.raises(ValueError, match="not used by the process"):
+            _invoke_probe(
+                probe,
+                artifact,
+                case,
+                retained,
+                direct_json,
+                (case.point,),
+                overrides={"unknown_parameter": [1.0, 0.0]},
+            )
+        with pytest.raises(rusticol.ArtifactError, match="prepared-kernel pack digest"):
+            _invoke_probe(
+                probe,
+                artifact,
+                case,
+                retained,
+                direct_json,
+                (case.point,),
+                pack_digest="1" * 64,
+            )
+        with pytest.raises(rusticol.ArtifactError, match=r"executor|semantic|mapping"):
+            _invoke_probe(
+                probe,
+                artifact,
+                case,
+                retained,
+                direct_json,
+                (case.point,),
+                tamper=True,
+            )
+
+        diagnostics[case.process_id] = {
+            "vertex": case.vertex,
+            "established_default": established_default,
+            "probe_default_raw": one["raw_amplitudes"],
+            "probe_default_normalized": one["normalized_values"],
+            "probe_batch_normalized": many["normalized_values"],
+            "normalization_factor": one["normalization_factor"],
+            "poison_counts": (
+                one["direct_plan_load_attempts"],
+                one["direct_plan_decode_attempts"],
+                one["direct_plan_materialization_attempts"],
+                one["established_builder_attempts"],
+            ),
+            "established_lam3": established_mutated,
+            "probe_lam3_raw": mutated["raw_amplitudes"],
+            "probe_lam3_normalized": mutated["normalized_values"],
+        }
+
+    case_0000, artifact_0000, _, _ = generated["scalars_0000"]
+    _, _, retained_0012, direct_json_0012 = generated["scalars_0012"]
+    with pytest.raises(
+        rusticol.ArtifactError, match=r"do not belong|selected artifact"
+    ):
+        _invoke_probe(
+            probe,
+            artifact_0000,
+            case_0000,
+            retained_0012,
+            direct_json_0012,
+            (case_0000.point,),
+        )
+
+    print("genuine on-the-fly scalar contact diagnostics:", diagnostics)
diff --git a/pyamplicol/tests/integration/test_on_the_fly_runtime_capabilities.py b/pyamplicol/tests/integration/test_on_the_fly_runtime_capabilities.py
new file mode 100644
index 0000000000..6267836697
--- /dev/null
+++ b/pyamplicol/tests/integration/test_on_the_fly_runtime_capabilities.py
@@ -0,0 +1,228 @@
+# SPDX-License-Identifier: 0BSD
+"""Small genuine-artifact regression for on-the-fly capability loading."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import json
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, ProcessRequest, Runtime
+from pyamplicol._internal.versions import (
+    ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_RUNTIME_CAPABILITY,
+)
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    Action,
+    ColorAccuracy,
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorExecutionMode,
+    GenerationConfig,
+    GenerationValidationConfig,
+    RunConfig,
+)
+
+_PROCESS = "d d~ > z"
+_PROCESS_ID = "d_dbar_to_z"
+_CAPABILITIES = (
+    ON_THE_FLY_RUNTIME_CAPABILITY,
+    ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+)
+
+
+def _unavailable(reason: str) -> None:
+    if os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1":
+        pytest.fail(reason)
+    pytest.skip(reason)
+
+
+def _require_native_on_the_fly() -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    rusticol = importlib.import_module("pyamplicol._rusticol")
+    if not hasattr(rusticol, "_build_on_the_fly_process_seeds_v1"):
+        _unavailable("the installed Rusticol extension lacks on-the-fly generation")
+
+
+def _configuration(*, emit_api_bundle: bool = False) -> RunConfig:
+    return RunConfig(
+        action=Action.GENERATE,
+        color=ColorConfig(accuracy=ColorAccuracy.LC),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=emit_api_bundle,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=EvaluatorExecutionMode.ON_THE_FLY,
+        ),
+    )
+
+
+def test_fresh_builtin_on_the_fly_artifact_loads_with_its_declared_capabilities(
+    tmp_path: Path,
+) -> None:
+    _require_native_on_the_fly()
+    artifact = tmp_path / "on-the-fly-d-dbar-to-z"
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+        Generator(_configuration()).generate(
+            ProcessRequest.parse(_PROCESS, name=_PROCESS_ID),
+            artifact,
+            model=ModelSource.from_path(prepared_model),
+        )
+
+    manifest = load_manifest(artifact)
+    assert manifest.runtime["required_runtime_capabilities"] == _CAPABILITIES
+    assert manifest.processes[0]["required_runtime_capabilities"] == _CAPABILITIES
+
+    runtime = Runtime.load(artifact, process=_PROCESS_ID)
+    assert runtime.execution_mode == "on-the-fly"
+    assert runtime.physics.process_id == _PROCESS_ID
+    assert runtime.physics.process == _PROCESS
+
+
+def _rusticol_config() -> tuple[str, ...]:
+    configured = os.environ.get("RUSTICOL_CONFIG")
+    if configured:
+        command = tuple(shlex.split(configured))
+        if command and (shutil.which(command[0]) or Path(command[0]).is_file()):
+            return command
+    sibling = Path(sys.executable).parent / "rusticol-config"
+    if sibling.is_file():
+        return (str(sibling),)
+    discovered = shutil.which("rusticol-config")
+    if discovered:
+        return (discovered,)
+    if importlib.util.find_spec("rusticol_config") is not None:
+        return (sys.executable, "-m", "rusticol_config")
+    _unavailable("the installed Rusticol C SDK is unavailable")
+    raise AssertionError("unreachable")
+
+
+def _validation_point(artifact: Path) -> tuple[tuple[float, ...], ...]:
+    lines = (
+        (artifact / "API/validation_points.dat")
+        .read_text(encoding="ascii")
+        .splitlines()
+    )
+    assert lines[0] == "RUSTICOL_VALIDATION_POINTS_V1"
+    fields = next(
+        line.split("\t")
+        for line in lines[1:]
+        if line and not line.startswith("#") and line.split("\t", 1)[0] == _PROCESS_ID
+    )
+    external_count = int(fields[1])
+    components = tuple(float(value) for value in fields[2:])
+    assert len(components) == 4 * external_count
+    return tuple(
+        components[offset : offset + 4] for offset in range(0, len(components), 4)
+    )
+
+
+def _real(value: complex | Decimal) -> float:
+    return float(complex(value).real)
+
+
+def test_generated_c_api_loads_and_evaluates_on_the_fly_artifact(
+    tmp_path: Path,
+) -> None:
+    _require_native_on_the_fly()
+    make = shutil.which("make")
+    cc = shutil.which(os.environ.get("CC", "cc"))
+    if make is None or cc is None:
+        _unavailable("the on-the-fly C API test requires make and a C compiler")
+    rusticol_config = _rusticol_config()
+    artifact = tmp_path / "on-the-fly-c-api"
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+        Generator(_configuration(emit_api_bundle=True)).generate(
+            ProcessRequest.parse(_PROCESS, name=_PROCESS_ID),
+            artifact,
+            model=ModelSource.from_path(prepared_model),
+        )
+
+    manifest = load_manifest(artifact)
+    assert manifest.runtime["api_bundle_path"] == "API"
+    c_source = artifact / "API/c/check_standalone.c"
+    assert "rusticol_runtime_evaluate_f64" in c_source.read_text(encoding="utf-8")
+    assert "rusticol_runtime_evaluate_resolved_f64" in c_source.read_text(
+        encoding="utf-8"
+    )
+
+    environment = os.environ.copy()
+    environment.update(
+        {
+            "CC": cc,
+            "RUSTICOL_CONFIG": shlex.join(rusticol_config),
+        }
+    )
+    compiled = subprocess.run(
+        [make, "-C", str(artifact / "API/c"), "all"],
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=180,
+    )
+    assert compiled.returncode == 0, (
+        f"on-the-fly C API driver failed to build\n"
+        f"stdout:\n{compiled.stdout}\nstderr:\n{compiled.stderr}"
+    )
+    driver = (
+        artifact.parent / ".pyamplicol-api-build" / artifact.name / "c/check_standalone"
+    )
+    executed = subprocess.run(
+        [str(driver), "--json", "--process", "  d   d~  >  z  "],
+        cwd=artifact,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    assert executed.returncode == 0, (
+        f"on-the-fly C API driver failed\n"
+        f"stdout:\n{executed.stdout}\nstderr:\n{executed.stderr}"
+    )
+    payload: dict[str, Any] = json.loads(executed.stdout)
+    assert payload["available"] is True
+    assert payload["process_key"] == _PROCESS_ID
+    assert payload["process"].casefold() == _PROCESS.casefold()
+
+    runtime = Runtime.load(artifact, process=_PROCESS_ID)
+    point = _validation_point(artifact)
+    expected_total = runtime.evaluate((point,))
+    expected_resolved = runtime.evaluate_resolved((point,))
+    expected_values = [
+        _real(value) for helicity in expected_resolved.values[0] for value in helicity
+    ]
+    assert payload["shape"] == [
+        1,
+        len(expected_resolved.helicity_ids),
+        len(expected_resolved.color_ids),
+    ]
+    assert payload["values"] == pytest.approx(expected_values, rel=1.0e-12, abs=1.0e-15)
+    assert payload["compatibility_total"] == pytest.approx(
+        [_real(expected_total[0])], rel=1.0e-12, abs=1.0e-15
+    )
+    assert payload["resolved_sum"] == pytest.approx(
+        [sum(expected_values)], rel=1.0e-12, abs=1.0e-15
+    )
diff --git a/pyamplicol/tests/integration/test_otf_cache.py b/pyamplicol/tests/integration/test_otf_cache.py
new file mode 100644
index 0000000000..76f43b8cf2
--- /dev/null
+++ b/pyamplicol/tests/integration/test_otf_cache.py
@@ -0,0 +1,259 @@
+# SPDX-License-Identifier: 0BSD
+"""Small-process cache round trips through the public Python runtime API."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import os
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+from pyamplicol.models.builtin.validation import generic_validation_point
+
+_PROCESS = "g g > g g"
+_HELICITY = "h:-1,+1,-1,+1"
+_OTHER_HELICITY = "h:+1,-1,+1,-1"
+_ALPHA_S = "normalization.alpha_s_me_check"
+
+
+def _require_native_cache() -> None:
+    reason = "the native Rusticol extension with OTF cache persistence is required"
+    if importlib.util.find_spec("pyamplicol._rusticol") is not None:
+        native = importlib.import_module("pyamplicol._rusticol")
+        if all(hasattr(native.Runtime, name) for name in ("save", "load_cache")):
+            return
+    if os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1":
+        pytest.fail(reason)
+    pytest.skip(reason)
+
+
+@pytest.fixture(scope="module")
+def cache_artifacts(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Iterator[dict[str, Path]]:
+    _require_native_cache()
+    output = tmp_path_factory.mktemp("otf-cache")
+    paths: dict[str, Path] = {}
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared:
+        for name, accuracy, contraction in (
+            ("lc", "lc", "direct"),
+            ("nlc", "nlc", "direct"),
+            ("full", "full", "direct"),
+            ("fft", "full", "symmetric-group-fft"),
+        ):
+            path = output / name
+            config = RunConfig(
+                action="generate",
+                color=ColorConfig(accuracy=accuracy, contraction=contraction),
+                generation=GenerationConfig(
+                    workers=1,
+                    emit_api_bundle=False,
+                    validation=GenerationValidationConfig(
+                        enabled=False, post_build_validation=False
+                    ),
+                ),
+                evaluator=EvaluatorConfig(
+                    execution_mode="on-the-fly",
+                    optimization=EvaluatorOptimizationConfig(cores=1),
+                    jit=JITConfig(optimization_level=2),
+                ),
+            )
+            Generator(config).generate(
+                _PROCESS, path, model=ModelSource.from_path(prepared)
+            )
+            paths[name] = path
+    yield paths
+
+
+def _point(seed: int) -> tuple[tuple[float, ...], ...]:
+    return tuple(
+        tuple(float(component) for component in particle.momentum)
+        for particle in generic_validation_point(_PROCESS, seed=seed)
+    )
+
+
+def _assert_warm(runtime: Runtime, selectors: dict[str, Any]) -> None:
+    warm = runtime.warm_up((_point(211),), **selectors)
+    assert warm.already_warm is True
+    assert warm.warmed_query_count == 0
+    assert warm.query_count > 0
+
+
+@pytest.mark.parametrize(
+    ("kind", "selection"),
+    (
+        ("lc", "selected"),
+        ("lc", "helicity-sum"),
+        ("lc", "all"),
+        ("nlc", "selected"),
+        ("full", "all"),
+        ("fft", "all"),
+    ),
+)
+def test_completed_evaluation_cache_restores_without_query_reconstruction(
+    cache_artifacts: dict[str, Path], tmp_path: Path, kind: str, selection: str
+) -> None:
+    artifact = cache_artifacts[kind]
+    runtime = Runtime.load(artifact)
+    selectors: dict[str, Any] = {}
+    if selection == "selected":
+        selectors["helicities"] = (_HELICITY,)
+    if kind == "lc" and selection != "all":
+        selectors["color_flows"] = (runtime.physics.color_flows[0].id,)
+
+    # An ordinary evaluate call, not only explicit warm_up(), must be saveable.
+    expected = runtime.evaluate((_point(101),), **selectors)
+    assert abs(complex(expected[0])) > 0
+    cache = tmp_path / "completed recursion.cache"
+    assert runtime.save(cache) is None
+    restored = Runtime.load(artifact)
+    assert restored.load_cache(cache) is None
+    _assert_warm(restored, selectors)
+    assert restored.evaluate((_point(101),), **selectors) == pytest.approx(expected)
+
+    # No momentum or SIMD-batch workspace from the saved call may leak in.
+    batch = (_point(311), _point(419), _point(521))
+    assert restored.evaluate(batch, **selectors) == pytest.approx(
+        runtime.evaluate(batch, **selectors), rel=2e-12
+    )
+
+    # Restoring structural state must not overwrite the receiving parameters.
+    changed = Runtime.load(artifact, model_parameters={_ALPHA_S: 0.13})
+    changed.load_cache(cache)
+    reference = Runtime.load(artifact, model_parameters={_ALPHA_S: 0.13})
+    _assert_warm(changed, selectors)
+    assert changed.evaluate(batch, **selectors) == pytest.approx(
+        reference.evaluate(batch, **selectors), rel=2e-12
+    )
+    assert changed.evaluate((_point(101),), **selectors) != pytest.approx(expected)
+
+    # An unretained selector family still takes the ordinary cold path, and
+    # its completed replacement can itself be saved and restored.
+    alternative = dict(selectors, helicities=(_OTHER_HELICITY,))
+    alternate_expected = runtime.evaluate(batch, **alternative)
+    assert restored.evaluate(batch, **alternative) == pytest.approx(
+        alternate_expected, rel=2e-12
+    )
+    restored.save(cache)
+    changed.load_cache(cache)
+    _assert_warm(changed, alternative)
+
+
+def test_empty_cache_round_trip_and_failed_restore_are_atomic(
+    cache_artifacts: dict[str, Path], tmp_path: Path
+) -> None:
+    artifact = cache_artifacts["lc"]
+    runtime = Runtime.load(artifact)
+    cache = tmp_path / "empty.cache"
+    runtime.save(cache)
+    restored = Runtime.load(artifact)
+    restored.load_cache(cache)
+    assert (
+        restored.inspect()["on_the_fly_state"] == runtime.inspect()["on_the_fly_state"]
+    )
+
+    selectors = {
+        "helicities": (_HELICITY,),
+        "color_flows": (runtime.physics.color_flows[0].id,),
+    }
+    expected = restored.evaluate((_point(101),), **selectors)
+    bad = tmp_path / "broken.cache"
+    bad.write_bytes(b"not a cache")
+    with pytest.raises(ArtifactError):
+        restored.load_cache(bad)
+    _assert_warm(restored, selectors)
+    assert restored.evaluate((_point(101),), **selectors) == pytest.approx(expected)
+
+    wrong = Runtime.load(cache_artifacts["full"])
+    wrong.save(cache)
+    with pytest.raises((ArtifactError, CompatibilityError)):
+        restored.load_cache(cache)
+    _assert_warm(restored, selectors)
+    assert restored.evaluate((_point(101),), **selectors) == pytest.approx(expected)
+
+
+@pytest.mark.parametrize("entry_point", ("resolved", "per-point", "zero"))
+def test_other_completed_evaluation_states_are_saveable(
+    cache_artifacts: dict[str, Path], tmp_path: Path, entry_point: str
+) -> None:
+    artifact = cache_artifacts["lc"]
+    runtime = Runtime.load(artifact)
+    flow = runtime.physics.color_flows[0].id
+    selectors: dict[str, Any] = {
+        "helicities": (_HELICITY,),
+        "color_flows": (flow,),
+    }
+    points = (_point(101), _point(211))
+    if entry_point == "resolved":
+        expected = runtime.evaluate_resolved(points, **selectors).total()
+    elif entry_point == "per-point":
+        # Per-point selectors may also produce a completed retained family.
+        expected = runtime.evaluate(
+            points,
+            helicity_by_point=(_HELICITY, _HELICITY),
+            color_flow_by_point=(flow, flow),
+        )
+    else:
+        # Include a completed zero-current cache, which need not own a JIT
+        # executor. Do not assume an incoming/outgoing helicity convention.
+        for helicity in runtime.physics.helicities:
+            selectors["helicities"] = (helicity.id,)
+            expected = runtime.evaluate(points, **selectors)
+            if all(abs(complex(value)) < 1e-20 for value in expected):
+                break
+        else:
+            pytest.fail("four-gluon tree amplitudes must include zero helicities")
+
+    cache = tmp_path / f"{entry_point}.cache"
+    runtime.save(cache)
+    restored = Runtime.load(artifact)
+    restored.load_cache(cache)
+    _assert_warm(restored, selectors)
+    assert restored.evaluate(points, **selectors) == pytest.approx(expected, abs=1e-25)
+
+
+def test_explicit_warm_up_cache_keeps_updated_parameters_of_a_warm_receiver(
+    cache_artifacts: dict[str, Path], tmp_path: Path
+) -> None:
+    artifact = cache_artifacts["lc"]
+    source = Runtime.load(artifact)
+    selectors = {"color_flows": (source.physics.color_flows[0].id,)}
+    points = (_point(101), _point(211))
+    # Explicit LC warm-up uses its streamed construction path, independently
+    # of the ordinary evaluate-created snapshots exercised above.
+    warm = source.warm_up(points[:1], **selectors)
+    assert warm.already_warm is False
+    assert warm.warmed_query_count > 0
+    cache = tmp_path / "explicit-warm-up.cache"
+    source.save(cache)
+
+    receiver = Runtime.load(artifact, model_parameters={_ALPHA_S: 0.13})
+    old = receiver.evaluate(points, **selectors)
+    # Leave the existing numerical workspace at 0.13, but update the public
+    # parameters to 0.15 immediately before replacing the retained family.
+    receiver.set_model_parameters({_ALPHA_S: 0.15})
+    receiver.load_cache(cache)
+    _assert_warm(receiver, selectors)
+    actual = receiver.evaluate(points, **selectors)
+    fresh = Runtime.load(artifact, model_parameters={_ALPHA_S: 0.15})
+    assert actual == pytest.approx(fresh.evaluate(points, **selectors), rel=2e-12)
+    assert actual != pytest.approx(old)
diff --git a/pyamplicol/tests/integration/test_otf_cache_native_sdk.py b/pyamplicol/tests/integration/test_otf_cache_native_sdk.py
new file mode 100644
index 0000000000..72d36f1b11
--- /dev/null
+++ b/pyamplicol/tests/integration/test_otf_cache_native_sdk.py
@@ -0,0 +1,281 @@
+# SPDX-License-Identifier: 0BSD
+# ruff: noqa: E501 -- native probes have their own source formatting.
+"""Completed OTF caches round-trip through every SDK without rebuilding queries."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, ProcessRequest, Runtime
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    RunConfig,
+)
+from tests.integration.test_on_the_fly_runtime_capabilities import (
+    _require_native_on_the_fly,
+)
+from tests.integration.test_runtime_selector_api_parity import (
+    _compile_probe,
+    _NativeSdk,
+    _source_environment,
+)
+from tests.integration.test_runtime_selector_api_parity import (
+    native_sdk as _native_sdk_fixture,
+)
+
+native_sdk = _native_sdk_fixture
+
+_POINTS = (
+    ((500, 0, 0, 500), (500, 0, 0, -500), (500, 300, 0, 400), (500, -300, 0, -400)),
+    ((500, 0, 0, 500), (500, 0, 0, -500), (500, 400, 300, 0), (500, -400, -300, 0)),
+)
+
+
+@pytest.fixture(scope="module", params=("lc", "full"))
+def otf_output(
+    request: pytest.FixtureRequest, tmp_path_factory: pytest.TempPathFactory
+):
+    _require_native_on_the_fly()
+    artifact = tmp_path_factory.mktemp(f"otf-cache-{request.param}") / "process"
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=request.param),
+        generation=GenerationConfig(
+            workers=1,
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="on-the-fly",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+        ),
+    )
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+        Generator(config).generate(
+            ProcessRequest.parse("g g > g g", name="gg_gg"),
+            artifact,
+            model=ModelSource.from_path(prepared_model),
+        )
+    expected = Runtime.load(artifact).evaluate(_POINTS)
+    return artifact, tuple(float(complex(value).real) for value in expected)
+
+
+_PROBES = {
+    "c": r"""
+        #include <rusticol.h>
+        #include <stdio.h>
+        #include <stdlib.h>
+        static void check(int status) {
+            if (status) {
+                char error[2048]; size_t needed;
+                rusticol_last_error_message(error, sizeof error, &needed);
+                fprintf(stderr, "%s\n", error); exit(1);
+            }
+        }
+        int main(int argc, char **argv) {
+            if (argc != 35) return 2;
+            double momenta[32], before, after[2];
+            for (size_t i=0; i<32; ++i) momenta[i]=strtod(argv[i+3], NULL);
+            RusticolRuntimeHandle *runtime=NULL;
+            check(rusticol_runtime_load(argv[1], NULL, NULL, &runtime));
+            const char invalid_utf8[]={(char)0xff, 0};
+            if (rusticol_runtime_save(runtime, NULL) != RUSTICOL_STATUS_INVALID_ARGUMENT ||
+                rusticol_runtime_load_cache(runtime, NULL) != RUSTICOL_STATUS_INVALID_ARGUMENT ||
+                rusticol_runtime_save(runtime, invalid_utf8) != RUSTICOL_STATUS_INVALID_ARGUMENT ||
+                rusticol_runtime_load_cache(runtime, invalid_utf8) != RUSTICOL_STATUS_INVALID_ARGUMENT) return 5;
+            RusticolWarmUpResult cold={0};
+            check(rusticol_runtime_warm_up_f64_with_cores(runtime, momenta, 16, NULL, 0, NULL, 0, 2, NULL, NULL, &cold));
+            if (!cold.first_evaluation_completed) return 6;
+            check(rusticol_runtime_evaluate_f64(runtime, momenta, 16, 1, &before, 1));
+            check(rusticol_runtime_save(runtime, argv[2]));
+            check(rusticol_runtime_free(runtime));
+            check(rusticol_runtime_load(argv[1], NULL, NULL, &runtime));
+            check(rusticol_runtime_load_cache(runtime, argv[2]));
+            RusticolWarmUpResult warm={0};
+            check(rusticol_runtime_warm_up_f64(runtime, momenta, 16, NULL, 0, NULL, 0, NULL, NULL, &warm));
+            if (!warm.already_warm || warm.warmed_query_count) return 3;
+            check(rusticol_runtime_evaluate_f64(runtime, momenta, 32, 2, after, 2));
+            printf("BEFORE %.17g\n", before);
+            for (size_t i=0; i<2; ++i) printf("VALUE %zu %.17g\n", i, after[i]);
+            check(rusticol_runtime_free(runtime)); return 0;
+        }
+    """,
+    "cpp": r"""
+        #include <rusticol.hpp>
+        #include <cstdlib>
+        #include <iomanip>
+        #include <iostream>
+        int main(int argc, char **argv) {
+            if (argc != 35) return 2;
+            std::vector<double> momenta;
+            for (int i=3; i<argc; ++i) momenta.push_back(std::strtod(argv[i], nullptr));
+            std::vector<double> point(momenta.begin(), momenta.begin()+16);
+            double before;
+            {
+                rusticol::Runtime runtime(argv[1]);
+                auto cold=runtime.warm_up(point, {}, {}, {}, 2);
+                if (!cold.first_evaluation_completed) return 6;
+                before=runtime.evaluate(point, 1).at(0);
+                runtime.save(argv[2]);
+                const std::string invalid_path=std::string(argv[2])+std::string("\0suffix", 7);
+                bool rejected_save=false, rejected_load=false;
+                try { runtime.save(invalid_path); } catch (const std::invalid_argument &) { rejected_save=true; }
+                try { runtime.load_cache(invalid_path); } catch (const std::invalid_argument &) { rejected_load=true; }
+                if (!rejected_save || !rejected_load) return 5;
+            }
+            rusticol::Runtime restored(argv[1]);
+            restored.load_cache(argv[2]);
+            auto warm=restored.warm_up(point);
+            if (!warm.already_warm || warm.warmed_query_count) return 3;
+            auto after=restored.evaluate(momenta, 2);
+            std::cout << "BEFORE " << std::setprecision(17) << before << "\n";
+            for (std::size_t i=0; i<after.size(); ++i)
+                std::cout << "VALUE " << i << " " << std::setprecision(17) << after[i] << "\n";
+        }
+    """,
+    "fortran": r"""
+        program cache_roundtrip
+          use, intrinsic :: iso_c_binding
+          use rusticol
+          implicit none
+          type(rusticol_runtime) :: runtime
+          type(rusticol_warm_up_result) :: warm
+          character(len=4096) :: artifact, cache, arg
+          real(c_double) :: momenta(32), before
+          real(c_double), allocatable :: values(:)
+          integer(c_int) :: status
+          integer :: i
+          if (command_argument_count() /= 34) stop 2
+          call get_command_argument(1, artifact)
+          call get_command_argument(2, cache)
+          do i=1,32
+            call get_command_argument(i+2, arg)
+            read(arg, *) momenta(i)
+          end do
+          call runtime%load(trim(artifact))
+          call runtime%warm_up(momenta(:16), warm, n_cores=0, ierr=status)
+          if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 6
+          call runtime%warm_up(momenta(:16), warm, n_cores=-1, ierr=status)
+          if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 6
+          call runtime%warm_up(momenta(:16), warm, n_cores=2)
+          if (warm%first_evaluation_completed == 0) stop 6
+          call runtime%evaluate(momenta(:16), 1_c_size_t, values)
+          before=values(1)
+          call runtime%save(trim(cache))
+          call runtime%save(trim(cache)//achar(0)//'suffix', ierr=status)
+          if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 5
+          call runtime%load_cache(trim(cache)//achar(0)//'suffix', ierr=status)
+          if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 5
+          call runtime%close()
+          call runtime%load(trim(artifact))
+          call runtime%load_cache(trim(cache))
+          call runtime%warm_up(momenta(:16), warm)
+          if (warm%already_warm == 0 .or. warm%warmed_query_count /= 0) stop 3
+          call runtime%evaluate(momenta, 2_c_size_t, values)
+          write(*,'(A,ES25.17E3)') 'BEFORE ', before
+          do i=1,2
+            write(*,'(A,I0,1X,ES25.17E3)') 'VALUE ', i-1, values(i)
+          end do
+          call runtime%close()
+        end program cache_roundtrip
+    """,
+    "rust": r"""
+        #[allow(dead_code)]
+        mod rusticol { include!(env!("RUSTICOL_RUST_SOURCE")); }
+        use rusticol::{Runtime, Selectors};
+        fn main() -> Result<(), Box<dyn std::error::Error>> {
+            let args: Vec<_> = std::env::args().collect();
+            if args.len() != 35 { return Err("wrong argument count".into()); }
+            let momenta: Vec<f64> = args[3..].iter().map(|s| s.parse()).collect::<Result<_,_>>()?;
+            let before = {
+                let mut runtime = Runtime::load(&args[1], None, None)?;
+                assert!(runtime.warm_up(&momenta[..16], &Selectors::default(), Some(0), None).is_err());
+                let cold = runtime.warm_up_f64(&momenta[..16], &Selectors::default(), Some(2), None)?;
+                assert!(cold.first_evaluation_completed);
+                let value = runtime.evaluate_f64(&momenta[..16], 1)?[0];
+                runtime.save(&args[2])?;
+                let invalid_path = format!("{}\0suffix", args[2]);
+                assert!(runtime.save(&invalid_path).is_err());
+                assert!(runtime.load_cache(&invalid_path).is_err());
+                value
+            };
+            let mut restored = Runtime::load(&args[1], None, None)?;
+            restored.load_cache(&args[2])?;
+            let warm = restored.warm_up(&momenta[..16], &Selectors::default(), None, None)?;
+            assert!(warm.already_warm);
+            assert_eq!(warm.warmed_query_count, 0);
+            let after = restored.evaluate_f64(&momenta, 2)?;
+            println!("BEFORE {before:.17e}");
+            for (i, value) in after.iter().enumerate() { println!("VALUE {i} {value:.17e}"); }
+            Ok(())
+        }
+    """,
+}
+
+
+@pytest.fixture(scope="module", params=tuple(_PROBES))
+def cache_driver(
+    request: pytest.FixtureRequest,
+    native_sdk: _NativeSdk,
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Path:
+    return _compile_probe(
+        request.param,
+        _PROBES[request.param],
+        native_sdk,
+        tmp_path_factory.mktemp(f"cache-sdk-{request.param}"),
+    )
+
+
+def test_completed_otf_cache_roundtrips_across_native_sdk_and_python(
+    cache_driver: Path,
+    otf_output,
+    tmp_path: Path,
+) -> None:
+    artifact, expected = otf_output
+    cache = tmp_path / "completed-cache.bin"
+    command = [
+        str(cache_driver),
+        str(artifact),
+        str(cache),
+        *(str(value) for point in _POINTS for leg in point for value in leg),
+    ]
+    result = subprocess.run(
+        command, env=_source_environment(), capture_output=True, text=True, timeout=120
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    measured = {
+        int(parts[1]): float(parts[2])
+        for line in result.stdout.splitlines()
+        if (parts := line.split()) and parts[0] == "VALUE"
+    }
+    assert set(measured) == {0, 1}
+    assert [measured[i] for i in range(2)] == pytest.approx(expected, rel=2e-12)
+    before = next(
+        float(line.split()[1])
+        for line in result.stdout.splitlines()
+        if line.startswith("BEFORE ")
+    )
+    assert before == pytest.approx(expected[0], rel=2e-12)
+    assert cache.stat().st_size > 0
+    restored = Runtime.load(artifact)
+    restored.load_cache(cache)
+    warm = restored.warm_up(_POINTS[:1])
+    assert warm.already_warm
+    assert warm.warmed_query_count == 0
+    values = restored.evaluate(_POINTS)
+    assert tuple(float(complex(value).real) for value in values) == pytest.approx(
+        expected, rel=2e-12
+    )
diff --git a/pyamplicol/tests/integration/test_otf_warmup_cores.py b/pyamplicol/tests/integration/test_otf_warmup_cores.py
new file mode 100644
index 0000000000..4e908e6f2c
--- /dev/null
+++ b/pyamplicol/tests/integration/test_otf_warmup_cores.py
@@ -0,0 +1,155 @@
+# SPDX-License-Identifier: 0BSD
+"""Small nonzero HEFT families exercise call-local parallel OTF preparation."""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_HEFT_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from pyamplicol.models.builtin.validation import generic_validation_point
+from pyamplicol.reporting import ProgressEvent, ProgressUpdate
+
+
+class _Progress:
+    def __init__(self) -> None:
+        self.events: list[ProgressEvent] = []
+
+    def emit(self, event: ProgressEvent) -> None:
+        self.events.append(event)
+
+    def workers(self) -> set[int]:
+        return {
+            int(event.details["workers"])
+            for event in self.events
+            if isinstance(event, ProgressUpdate) and "workers" in event.details
+        }
+
+
+@pytest.mark.parametrize("process", ("g g > H g", "g g > H g g"))
+@pytest.mark.parametrize(
+    ("accuracy", "contraction"),
+    (("lc", "direct"), ("full", "direct"), ("full", "symmetric-group-fft")),
+)
+def test_heft_warm_up_core_override_preserves_values_and_cache(
+    tmp_path: Path, process: str, accuracy: str, contraction: str
+) -> None:
+    native = pytest.importorskip("pyamplicol._rusticol")
+    output = tmp_path / "process"
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=accuracy, contraction=contraction),
+        process=ProcessConfig(
+            coupling_order_policy="explicit", max_coupling_orders={"HIG": 1}
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="on-the-fly",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+    with packaged_prepared_model_path(BUILTIN_SM_HEFT_JIT_O2) as prepared:
+        Generator(config).generate(
+            process, output, model=ModelSource.from_path(prepared)
+        )
+    points = tuple(
+        tuple(tuple(p.momentum) for p in generic_validation_point(process, seed=seed))
+        for seed in (211, 419)
+    )
+    # Callers of the native Python binding get the same validation, before
+    # constructing any currents, even if they bypass the public facade.
+    native_runtime = native.Runtime.load(output)
+    for invalid in (True, False, 0, -1, 1.5, "4", 2**100):
+        with pytest.raises((TypeError, ValueError), match="n_cores"):
+            native_runtime._on_the_fly_warm_up_f64_json(points[:1], n_cores=invalid)
+    del native_runtime
+    expected = None
+    expected_state = None
+    observations = []
+    for n_cores in (1, 2, 4):
+        runtime = Runtime.load(output)
+        progress = _Progress()
+        started = time.perf_counter()
+        warm = runtime.warm_up(points[:1], n_cores=n_cores, progress=progress)
+        elapsed = time.perf_counter() - started
+        assert not warm.already_warm
+        assert warm.warmed_query_count > 0
+        assert len(progress.workers()) == 1
+        workers = next(iter(progress.workers()))
+        assert 1 <= workers <= n_cores  # Hosts may restrict available cores.
+        values = runtime.evaluate(points)
+        assert all(abs(complex(value)) > 0 for value in values)
+        state = runtime.inspect()["on_the_fly_state"]
+        if expected is None:
+            expected, expected_state = values, state
+        else:
+            assert values == pytest.approx(expected, rel=2e-12)
+            assert state == expected_state
+
+        # Neither a different override nor omission rebuilds a warm family.
+        repeated = runtime.warm_up(points[:1], n_cores=3)
+        assert repeated.already_warm and repeated.warmed_query_count == 0
+        default_progress = _Progress()
+        default = runtime.warm_up(points[:1], progress=default_progress)
+        assert default.already_warm and default.warmed_query_count == 0
+        assert default_progress.workers() == {1}
+        observations.append(
+            {
+                "n_cores": n_cores,
+                "effective_workers": workers,
+                "warm_up_seconds": elapsed,
+                "queries": warm.query_count,
+                "cumulative_seconds_at_stage_end": {
+                    str(event.details["stage"]): event.details["elapsed_seconds"]
+                    for event in progress.events
+                    if isinstance(event, ProgressUpdate)
+                    and "elapsed_seconds" in event.details
+                },
+            }
+        )
+        if n_cores == 4:
+            cache = tmp_path / "parallel.cache"
+            runtime.save(cache)
+            restored = Runtime.load(output)
+            restored.load_cache(cache)
+            cached = restored.warm_up(points[:1], n_cores=2)
+            assert cached.already_warm and cached.warmed_query_count == 0
+            assert restored.evaluate(points) == pytest.approx(expected, rel=2e-12)
+
+    # Record the observation, but do not make noisy wall time a correctness gate.
+    (tmp_path / "warm-up-profile.json").write_text(
+        json.dumps(
+            {
+                "process": process,
+                "accuracy": accuracy,
+                "contraction": contraction,
+                "observations": observations,
+            },
+            indent=2,
+        )
+        + "\n"
+    )
diff --git a/pyamplicol/tests/integration/test_process_group_routing.py b/pyamplicol/tests/integration/test_process_group_routing.py
new file mode 100644
index 0000000000..e00df965fd
--- /dev/null
+++ b/pyamplicol/tests/integration/test_process_group_routing.py
@@ -0,0 +1,571 @@
+# SPDX-License-Identifier: 0BSD
+"""Process-group members that were not generated route to their representative."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import json
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from collections.abc import Iterator, Mapping, Sequence
+from fractions import Fraction
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, ProcessSet, Runtime
+from pyamplicol.artifacts.process_groups import (
+    initial_process_groups,
+    write_process_groups,
+)
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+from pyamplicol.generation.process_grouping import (
+    GroupingBasis,
+    GroupMember,
+)
+from pyamplicol.models.builtin.validation import generic_validation_point
+
+_MODES = ("compiled", "eager", "recurrence")
+_PROJECT_ROOT = Path(__file__).resolve().parents[2]
+
+# Representative, member, member relation (representative leg -> member leg),
+# exact factor, and charge conjugation. Each member is also generated in a
+# reference artifact under its own expression.
+_GROUPS = (
+    ("d d~ > g g", "u u~ > g g", (0, 1, 2, 3), Fraction(1), False),
+    ("d d~ > a g", "u~ u > a g", (1, 0, 2, 3), Fraction(4), False),
+    ("u g > u g", "u~ g > u~ g", (0, 1, 2, 3), Fraction(1), True),
+    ("d d~ > a a", "u u~ > a a", (0, 1, 2, 3), Fraction(16), False),
+)
+_REFERENCES = ("u u~ > g g", "u u~ > a g", "u~ g > u~ g", "u u~ > a a")
+
+
+def _require_native_runtime() -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+    if importlib.util.find_spec("symbolica") is None:
+        pytest.skip("Symbolica is unavailable")
+
+
+def _generation_config(execution_mode: str, *, api_bundle: bool = False) -> RunConfig:
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=api_bundle,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=execution_mode,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+def _member_id(expression: str) -> str:
+    initial, final = expression.split(">")
+
+    def name(token: str) -> str:
+        return token.replace("~", "bar")
+
+    return (
+        "_".join(name(token) for token in initial.split())
+        + "_to_"
+        + "_".join(name(token) for token in final.split())
+        + "_member"
+    )
+
+
+def _attach_process_groups(
+    artifact: Path,
+    members: Mapping[str, Sequence[GroupMember]],
+) -> None:
+    """Declare non-generated members on the stored representatives."""
+
+    raw = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    write_process_groups(
+        artifact,
+        initial_process_groups(
+            (
+                (
+                    str(process["id"]),
+                    str(process["expression"]),
+                    process["external_pdgs"],
+                )
+                for process in raw["processes"]
+            ),
+            members,
+        ),
+    )
+
+
+def _process_ids(artifact: Path) -> dict[str, str]:
+    raw = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    return {
+        str(process["expression"]): str(process["id"]) for process in raw["processes"]
+    }
+
+
+def _attach_members(artifact: Path) -> None:
+    ids = _process_ids(artifact)
+    members: dict[str, list[GroupMember]] = {}
+    for representative, member, permutation, factor, conjugated in _GROUPS:
+        if representative not in ids:
+            continue
+        pdgs = tuple(int(particle.pdg) for particle in generic_validation_point(member))
+        members.setdefault(ids[representative], []).append(
+            GroupMember(
+                process_id=_member_id(member),
+                expression=member,
+                pdgs=pdgs,
+                initial_count=len(member.split(">")[0].split()),
+                factor=factor,
+                permutation=permutation,
+                conjugated=conjugated,
+                basis=GroupingBasis.FLAVOR_BLIND,
+                generated=False,
+            )
+        )
+    _attach_process_groups(artifact, members)
+
+
+@pytest.fixture(scope="module")
+def group_artifacts(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Iterator[dict[str, Path]]:
+    _require_native_runtime()
+    root = tmp_path_factory.mktemp("process-group-routing")
+    representatives = tuple(group[0] for group in _GROUPS)
+    artifacts = {mode: root / mode for mode in _MODES}
+    artifacts["reference"] = root / "reference"
+    artifacts["single"] = root / "single"
+    try:
+        for mode in _MODES:
+            Generator(_generation_config(mode)).generate(
+                ProcessSet.from_expressions(representatives), artifacts[mode]
+            )
+            _attach_members(artifacts[mode])
+        Generator(_generation_config("recurrence")).generate(
+            ProcessSet.from_expressions(_REFERENCES), artifacts["reference"]
+        )
+        Generator(_generation_config("recurrence")).generate(
+            "u g > u g", artifacts["single"]
+        )
+        _attach_members(artifacts["single"])
+        yield artifacts
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+
+def _point(expression: str) -> tuple[tuple[float, float, float, float], ...]:
+    return tuple(
+        tuple(float(component) for component in particle.momentum)  # type: ignore[misc]
+        for particle in generic_validation_point(expression)
+    )
+
+
+def _reordered(
+    point: Sequence[Sequence[float]], permutation: Sequence[int]
+) -> tuple[tuple[float, ...], ...]:
+    """Momenta of ``point`` at ``target[i] = point[permutation[i]]``."""
+
+    return tuple(tuple(point[index]) for index in permutation)
+
+
+def _flatten(values: object) -> tuple[complex, ...]:
+    flattened: list[complex] = []
+
+    def visit(value: object) -> None:
+        if isinstance(value, tuple | list):
+            for item in value:
+                visit(item)
+        else:
+            flattened.append(complex(value))  # type: ignore[arg-type]
+
+    visit(values)
+    return tuple(flattened)
+
+
+def _assert_close(actual: object, expected: object) -> None:
+    assert _flatten(actual) == pytest.approx(
+        _flatten(expected), rel=1.0e-12, abs=1.0e-15
+    )
+
+
+def _flow_values(runtime: Runtime, point: object, **selectors: object) -> dict:
+    resolved = runtime.evaluate_resolved((point,), **selectors)  # type: ignore[arg-type]
+    return {
+        (helicity, color): resolved.values[0][h_index][c_index]
+        for h_index, helicity in enumerate(resolved.helicity_ids)
+        for c_index, color in enumerate(resolved.color_ids)
+    }
+
+
+@pytest.mark.parametrize("execution_mode", _MODES)
+def test_flavour_relabelled_member_matches_its_generated_process(
+    group_artifacts: dict[str, Path], execution_mode: str
+) -> None:
+    artifact = group_artifacts[execution_mode]
+    representative_id = _process_ids(artifact)["d d~ > g g"]
+    reference = Runtime.load(group_artifacts["reference"], process="u u~ > g g")
+    for selector in (_member_id("u u~ > g g"), "u   U~ > g g"):
+        member = Runtime.load(artifact, process=selector)
+        assert member.physics.process_id == _member_id("u u~ > g g")
+        assert member.physics.process == "u u~ > g g"
+        assert [p.pdg_id for p in member.physics.external_particles] == [2, -2, 21, 21]
+        assert [p.name for p in member.physics.external_particles] == [
+            "u",
+            "u~",
+            "g",
+            "g",
+        ]
+        assert member.representative_process_key == representative_id
+        assert member.external_permutation == (0, 1, 2, 3)
+        assert member.process_group_factor == 1
+        assert member.charge_conjugated is False
+        assert member.physics.color_ids == reference.physics.color_ids
+        point = _point("u u~ > g g")
+        _assert_close(member.evaluate((point,) * 3), reference.evaluate((point,) * 3))
+        assert (
+            _flow_values(member, point).keys() == _flow_values(reference, point).keys()
+        )
+        member_flows = _flow_values(member, point)
+        reference_flows = _flow_values(reference, point)
+        _assert_close(
+            [member_flows[key] for key in sorted(member_flows)],
+            [reference_flows[key] for key in sorted(member_flows)],
+        )
+
+    representative = Runtime.load(artifact, process=representative_id)
+    assert representative.process_group_factor == 1
+    assert representative.physics.process_id == representative_id
+    assert (
+        representative.inspect()["runtime_metadata"]["process_group_member_of"] is None
+    )
+
+
+@pytest.mark.parametrize("execution_mode", _MODES)
+def test_swapped_member_in_another_order_applies_permutation_and_factor(
+    group_artifacts: dict[str, Path], execution_mode: str
+) -> None:
+    artifact = group_artifacts[execution_mode]
+    requested = "u~ u > g a"
+    member = Runtime.load(artifact, process=requested)
+    reference = Runtime.load(group_artifacts["reference"], process="u u~ > a g")
+    # Representative d d~ a g -> member u~ u a g -> requested u~ u g a.
+    assert member.external_permutation == (1, 0, 3, 2)
+    assert member.process_group_factor == 4
+    assert member.physics.process_id == _member_id("u~ u > a g")
+    assert member.physics.process == requested
+    assert [p.pdg_id for p in member.physics.external_particles] == [-2, 2, 21, 22]
+    assert (
+        member.inspect()["runtime_metadata"]["process_group_member_of"]
+        == (_process_ids(artifact)["d d~ > a g"])
+    )
+
+    # Reference legs u u~ a g are requested legs (1, 0, 3, 2).
+    reference_point = _point("u u~ > a g")
+    requested_point = _reordered(reference_point, (1, 0, 3, 2))
+    _assert_close(
+        member.evaluate((requested_point,) * 2),
+        reference.evaluate((reference_point,) * 2),
+    )
+    member_by_helicity: dict[tuple[int, ...], complex] = {}
+    resolved = member.evaluate_resolved((requested_point,))
+    for helicity, values in zip(
+        member.physics.helicities, resolved.values[0], strict=True
+    ):
+        vector = helicity.values
+        member_by_helicity[(vector[1], vector[0], vector[3], vector[2])] = sum(
+            complex(value) for value in values
+        )
+    reference_resolved = reference.evaluate_resolved((reference_point,))
+    reference_by_helicity = {
+        helicity.values: sum(complex(value) for value in values)
+        for helicity, values in zip(
+            reference.physics.helicities, reference_resolved.values[0], strict=True
+        )
+    }
+    assert member_by_helicity.keys() == reference_by_helicity.keys()
+    _assert_close(
+        [member_by_helicity[key] for key in sorted(member_by_helicity)],
+        [reference_by_helicity[key] for key in sorted(member_by_helicity)],
+    )
+    selected = next(
+        helicity for helicity in member.physics.helicities if helicity.computed
+    )
+    vector = selected.values
+    reference_helicity = next(
+        helicity.id
+        for helicity in reference.physics.helicities
+        if helicity.values == (vector[1], vector[0], vector[3], vector[2])
+    )
+    _assert_close(
+        member.evaluate((requested_point,), helicities=(selected.id,)),
+        reference.evaluate((reference_point,), helicities=(reference_helicity,)),
+    )
+    _assert_close(
+        member.evaluate((requested_point,), precision=32),
+        reference.evaluate((reference_point,)),
+    )
+
+
+@pytest.mark.parametrize("execution_mode", _MODES)
+def test_charge_conjugated_member_reverses_lc_flows(
+    group_artifacts: dict[str, Path], execution_mode: str
+) -> None:
+    artifact = group_artifacts[execution_mode]
+    member = Runtime.load(artifact, process=_member_id("u~ g > u~ g"))
+    reference = Runtime.load(group_artifacts["reference"], process="u~ g > u~ g")
+    representative = Runtime.load(artifact, process="u g > u g")
+    assert member.charge_conjugated is True
+    assert member.process_group_factor == 1
+    assert member.physics.process == "u~ g > u~ g"
+    assert [p.pdg_id for p in member.physics.external_particles] == [-2, 21, -2, 21]
+    assert sorted(member.physics.color_ids) == sorted(reference.physics.color_ids)
+    for representative_flow, member_flow in zip(
+        representative.physics.color_flows, member.physics.color_flows, strict=True
+    ):
+        assert member_flow.word == tuple(reversed(representative_flow.word))
+
+    point = _point("u~ g > u~ g")
+    member_flows = _flow_values(member, point)
+    reference_flows = _flow_values(reference, point)
+    assert member_flows.keys() == reference_flows.keys()
+    _assert_close(
+        [member_flows[key] for key in sorted(member_flows)],
+        [reference_flows[key] for key in sorted(member_flows)],
+    )
+    for flow in member.physics.color_ids:
+        selected = member.evaluate_resolved((point,), color_flows=(flow,))
+        assert selected.color_ids == (flow,)
+        _assert_close(
+            member.evaluate((point,), color_flows=(flow,)),
+            reference.evaluate((point,), color_flows=(flow,)),
+        )
+    exact = member.evaluate_resolved((point,), precision=32)
+    assert sorted(exact.color_ids) == sorted(reference.physics.color_ids)
+    exact_flows = {
+        (helicity, color): exact.values[0][h_index][c_index]
+        for h_index, helicity in enumerate(exact.helicity_ids)
+        for c_index, color in enumerate(exact.color_ids)
+    }
+    _assert_close(
+        [exact_flows[key] for key in sorted(exact_flows)],
+        [reference_flows[key] for key in sorted(exact_flows)],
+    )
+
+
+@pytest.mark.parametrize("execution_mode", _MODES)
+def test_member_with_non_unit_factor_matches_its_generated_process(
+    group_artifacts: dict[str, Path], execution_mode: str
+) -> None:
+    member = Runtime.load(group_artifacts[execution_mode], process="u u~ > a a")
+    reference = Runtime.load(group_artifacts["reference"], process="u u~ > a a")
+    point = _point("u u~ > a a")
+    assert member.process_group_factor == 16
+    _assert_close(member.evaluate((point,) * 2), reference.evaluate((point,) * 2))
+    _assert_close(
+        member.evaluate_resolved((point,)).values,
+        reference.evaluate_resolved((point,)).values,
+    )
+
+
+def test_single_process_recurrence_artifact_routes_members(
+    group_artifacts: dict[str, Path],
+) -> None:
+    artifact = group_artifacts["single"]
+    default = Runtime.load(artifact)
+    assert default.physics.process == "u g > u g"
+    assert default.charge_conjugated is False
+    member = Runtime.load(artifact, process="u~ g > u~ g")
+    reference = Runtime.load(group_artifacts["reference"], process="u~ g > u~ g")
+    point = _point("u~ g > u~ g")
+    assert member.charge_conjugated is True
+    _assert_close(member.evaluate((point,)), reference.evaluate((point,)))
+    with pytest.raises(Exception, match="unknown process"):
+        Runtime.load(artifact, process="c~ g > c~ g")
+
+
+def test_on_the_fly_conjugated_member_translates_compact_selectors(
+    group_artifacts: dict[str, Path], tmp_path: Path
+) -> None:
+    rusticol = importlib.import_module("pyamplicol._rusticol")
+    if not hasattr(rusticol, "_build_on_the_fly_process_seeds_v1"):
+        pytest.skip("the installed Rusticol extension lacks on-the-fly generation")
+    artifact = tmp_path / "otf"
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared:
+        Generator(_generation_config("on-the-fly")).generate(
+            "u g > u g", artifact, model=ModelSource.from_path(prepared)
+        )
+    _attach_members(artifact)
+    member = Runtime.load(artifact, process="u~ g > u~ g")
+    reference = Runtime.load(group_artifacts["reference"], process="u~ g > u~ g")
+    assert member.execution_mode == "on-the-fly"
+    assert member.charge_conjugated is True
+    assert sorted(member.physics.color_ids) == sorted(reference.physics.color_ids)
+    point = _point("u~ g > u~ g")
+    member_flows = _flow_values(member, point)
+    reference_flows = _flow_values(reference, point)
+    assert member_flows.keys() == reference_flows.keys()
+    _assert_close(
+        [member_flows[key] for key in sorted(member_flows)],
+        [reference_flows[key] for key in sorted(member_flows)],
+    )
+    flows = reference.physics.color_ids
+    _assert_close(
+        member.evaluate((point,) * len(flows), color_flow_by_point=flows),
+        reference.evaluate((point,) * len(flows), color_flow_by_point=flows),
+    )
+    for flow in flows:
+        selected = member.evaluate_resolved((point,), color_flows=(flow,))
+        assert selected.color_ids == (flow,)
+        _assert_close(
+            member.evaluate((point,), color_flows=(flow,)),
+            reference.evaluate((point,), color_flows=(flow,)),
+        )
+
+
+def test_c_api_selects_a_process_group_member(tmp_path: Path) -> None:
+    _require_native_runtime()
+    tools = {
+        "make": shutil.which("make"),
+        "cc": shutil.which(os.environ.get("CC", "cc")),
+        "rusticol-config": shutil.which("rusticol-config")
+        or (
+            str(Path(sys.executable).parent / "rusticol-config")
+            if (Path(sys.executable).parent / "rusticol-config").is_file()
+            else None
+        ),
+    }
+    missing = [name for name, value in tools.items() if value is None]
+    if missing:
+        pytest.skip("C API check requires " + ", ".join(missing))
+    artifact = tmp_path / "artifact"
+    Generator(_generation_config("compiled", api_bundle=True)).generate(
+        "d d~ > a g", artifact
+    )
+    _attach_members(artifact)
+    environment = os.environ.copy()
+    environment["PYTHONPATH"] = os.pathsep.join(
+        [str(_PROJECT_ROOT / "src"), environment.get("PYTHONPATH", "")]
+    )
+    environment["CC"] = str(tools["cc"])
+    environment["RUSTICOL_CONFIG"] = shlex.join([str(tools["rusticol-config"])])
+    built = subprocess.run(
+        [str(tools["make"]), "-C", str(artifact / "API/c"), "all"],
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=180,
+    )
+    assert built.returncode == 0, built.stdout + built.stderr
+    driver = tmp_path / ".pyamplicol-api-build/artifact/c/check_standalone"
+
+    def run(process: str) -> dict:
+        completed = subprocess.run(
+            [str(driver), "--json", "--process", process],
+            cwd=artifact,
+            env=environment,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+        assert completed.returncode == 0, completed.stdout + completed.stderr
+        return json.loads(completed.stdout)
+
+    representative = run(_process_ids(artifact)["d d~ > a g"])
+    member = run("u~ u > g a")
+    assert member["process_key"] == _member_id("u~ u > a g")
+    assert [particle["pdg"] for particle in member["external_particles"]] == [
+        -2,
+        2,
+        21,
+        22,
+    ]
+    # Both drivers evaluate the bundled representative point in their order.
+    assert member["compatibility_total"] == pytest.approx(
+        [4 * value for value in representative["compatibility_total"]], rel=1.0e-12
+    )
+    python = Runtime.load(artifact, process="u~ u > g a")
+    assert python.process_group_factor == Fraction(4)
+
+    source = tmp_path / "relation.c"
+    source.write_text(
+        """#include <inttypes.h>
+#include <stdio.h>
+#include <rusticol.h>
+int main(int argc, char **argv) {
+    RusticolRuntimeHandle *runtime = NULL;
+    uint64_t numerator = 0, denominator = 0;
+    int32_t conjugated = -1;
+    if (argc != 3
+        || rusticol_runtime_load(argv[1], argv[2], NULL, &runtime) != 0
+        || rusticol_runtime_process_group_relation(
+               runtime, &numerator, &denominator, &conjugated) != 0) {
+        return 1;
+    }
+    printf("%" PRIu64 "/%" PRIu64 " %d\\n", numerator, denominator, conjugated);
+    return rusticol_runtime_free(runtime);
+}
+""",
+        encoding="utf-8",
+    )
+    flags = [
+        argument
+        for option in ("--cflags", "--libs")
+        for argument in shlex.split(
+            subprocess.run(
+                [str(tools["rusticol-config"]), option],
+                env=environment,
+                check=True,
+                capture_output=True,
+                text=True,
+            ).stdout
+        )
+    ]
+    program = tmp_path / "relation"
+    subprocess.run(
+        [str(tools["cc"]), "-std=c11", str(source), *flags, "-o", str(program)],
+        env=environment,
+        check=True,
+        timeout=120,
+    )
+    for process, expected in (
+        ("u~ u > g a", "4/1 0"),
+        (_process_ids(artifact)["d d~ > a g"], "1/1 0"),
+    ):
+        completed = subprocess.run(
+            [str(program), str(artifact), process],
+            env=environment,
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        assert completed.stdout.strip() == expected
diff --git a/pyamplicol/tests/integration/test_process_grouping.py b/pyamplicol/tests/integration/test_process_grouping.py
new file mode 100644
index 0000000000..e0510f2a57
--- /dev/null
+++ b/pyamplicol/tests/integration/test_process_grouping.py
@@ -0,0 +1,314 @@
+# SPDX-License-Identifier: 0BSD
+"""Numerical process grouping of generated built-in SM artifacts."""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import shutil
+from collections.abc import Callable, Iterator
+from fractions import Fraction
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.api.process_groups import group_processes
+from pyamplicol.artifacts.manifest import load_manifest
+from pyamplicol.artifacts.process_groups import grouping_process, read_process_groups
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from pyamplicol.generation.process_grouping import (
+    GroupingBasis,
+    flavor_class_key,
+    profile_key,
+)
+from pyamplicol.generation.process_grouping_numerical import (
+    _artifact_model,
+    member_point,
+    on_shell_point,
+)
+
+
+def _unavailable(reason: str) -> None:
+    if os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1":
+        pytest.fail(reason)
+    pytest.skip(reason)
+
+
+def _config(
+    flavor_scheme: int = 5, selected_source_helicities: dict[str, int] | None = None
+) -> RunConfig:
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc"),
+        process=ProcessConfig(
+            flavor_scheme=flavor_scheme,
+            selected_source_helicities=selected_source_helicities or {},
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="eager",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+@pytest.fixture(scope="module")
+def generated(tmp_path_factory: pytest.TempPathFactory) -> Iterator[dict[str, Path]]:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    if importlib.util.find_spec("symbolica") is None:
+        _unavailable("Symbolica is unavailable")
+    root = tmp_path_factory.mktemp("process-grouping")
+    artifacts = {
+        "jets": root / "jets",
+        "photons": root / "photons",
+        "selected": root / "selected",
+        "cycle": root / "cycle",
+    }
+    try:
+        Generator(_config(flavor_scheme=2)).generate(
+            "p p > j j", artifacts["jets"], model=ModelSource.built_in_sm()
+        )
+        Generator(_config()).generate(
+            ("u u~ > a a", "d d~ > a a"),
+            artifacts["photons"],
+            model=ModelSource.built_in_sm(),
+        )
+        Generator(_config(selected_source_helicities={"3": 1})).generate(
+            ("u u~ > a a", "d d~ > a a"),
+            artifacts["selected"],
+            model=ModelSource.built_in_sm(),
+        )
+        Generator(_config()).generate(
+            ("d g > d d d~", "d~ g > d d~ d~"),
+            artifacts["cycle"],
+            model=ModelSource.built_in_sm(),
+        )
+        yield artifacts
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+
+@pytest.fixture
+def artifact(generated: dict[str, Path], tmp_path: Path) -> Callable[[str], Path]:
+    def copy(name: str) -> Path:
+        destination = tmp_path / f"{name}-{len(list(tmp_path.iterdir()))}"
+        shutil.copytree(generated[name], destination)
+        return destination
+
+    return copy
+
+
+def _partition(path: Path) -> set[frozenset[str]]:
+    group_map = read_process_groups(path)
+    assert group_map is not None
+    return {
+        frozenset(member.process_id for member in group.members)
+        for group in group_map.groups.values()
+    }
+
+
+def _flavour_classes(
+    path: Path, *, consider_charge_conjugation: bool
+) -> set[frozenset[str]]:
+    table = _artifact_model(path).table
+    classes: dict[object, set[str]] = {}
+    for process in load_manifest(path).processes:
+        grouping = grouping_process(
+            str(process["id"]),
+            str(process["expression"]),
+            process["external_pdgs"],  # type: ignore[arg-type]
+        )
+        key = (
+            flavor_class_key(grouping, table, consider_charge_conjugation=True)
+            if consider_charge_conjugation
+            else profile_key(grouping, table)
+        )
+        classes.setdefault(key, set()).add(grouping.process_id)
+    return {frozenset(members) for members in classes.values()}
+
+
+@pytest.mark.parametrize("consider_charge_conjugation", (True, False))
+def test_jets_group_into_flavour_profile_classes(
+    artifact: Callable[[str], Path],
+    consider_charge_conjugation: bool,
+) -> None:
+    path = artifact("jets")
+    identity = load_manifest(path).artifact_id
+
+    summary = group_processes(
+        path, consider_charge_conjugation=consider_charge_conjugation
+    )
+
+    assert summary["skipped"] == []
+    expected = _flavour_classes(
+        path, consider_charge_conjugation=consider_charge_conjugation
+    )
+    assert len(expected) == (9 if consider_charge_conjugation else 12)
+    assert _partition(path) == expected
+    assert load_manifest(path).artifact_id == identity
+    group_map = read_process_groups(path)
+    assert group_map is not None
+    assert group_map.analyses[-1]["consider_charge_conjugation"] is (
+        consider_charge_conjugation
+    )
+    members = list(group_map.members())
+    assert {member.factor for member in members} == {Fraction(1)}
+    assert any(member.conjugated for member in members) is consider_charge_conjugation
+
+    # Each recorded relation holds for the summed matrix element at a point
+    # outside the analysed ones: ME_member(p) = factor * ME_rep(q).
+    point = on_shell_point((0.0, 0.0), (0.0, 0.0), seed=11)
+    assert point is not None
+    for group in group_map.groups.values():
+        representative = Runtime.load(path, process=group.representative.process_id)
+        (expected_value,) = representative.evaluate([point])
+        for member in group.members[1:]:
+            assert member.basis is GroupingBasis.NUMERICAL
+            runtime = Runtime.load(path, process=member.process_id)
+            (value,) = runtime.evaluate([member_point(point, member.permutation)])
+            assert value.real == pytest.approx(
+                float(member.factor) * expected_value.real, rel=1e-10
+            )
+
+
+def _helicity_totals(
+    path: Path, process: str, point: tuple[object, ...], legs: list[int]
+) -> dict[tuple[int, ...], float]:
+    """Colour-summed values keyed by the helicities of ``legs`` in order."""
+
+    runtime = Runtime.load(path, process=process)
+    values = {item.id: item.values for item in runtime.physics.helicities}
+    resolved = runtime.evaluate_resolved([point])
+    return {
+        tuple(values[identifier][leg] for leg in legs): sum(row).real
+        for identifier, row in zip(
+            resolved.helicity_ids, resolved.values[0], strict=True
+        )
+    }
+
+
+def test_conjugated_relation_with_cycled_legs_holds_per_helicity(
+    artifact: Callable[[str], Path],
+) -> None:
+    # d~ g > d d~ d~ is the charge conjugate of d g > d d d~ with the final
+    # legs cycled, a permutation that is not its own inverse.
+    path = artifact("cycle")
+    group_processes(path)
+    group_map = read_process_groups(path)
+    assert group_map is not None
+    (group,) = group_map.groups.values()
+    assert group.representative.process_id == "d_g_to_d_d_dbar"
+    (member,) = group.members[1:]
+    assert member.conjugated
+    assert member.factor == 1
+    assert member.permutation == (0, 1, 3, 4, 2)
+
+    # q[r] = p[perm[r]], and helicities map unchanged under conjugation.
+    point = on_shell_point((0.0, 0.0), (0.0, 0.0, 0.0), seed=11)
+    assert point is not None
+    member_momenta: list[object] = list(point)
+    for representative_index, member_index in enumerate(member.permutation):
+        member_momenta[member_index] = point[representative_index]
+    expected = _helicity_totals(path, "d_g_to_d_d_dbar", point, [0, 1, 2, 3, 4])
+    actual = _helicity_totals(
+        path, member.process_id, tuple(member_momenta), list(member.permutation)
+    )
+    assert actual.keys() == expected.keys()
+    scale = max(map(abs, expected.values()))
+    for helicities, value in expected.items():
+        assert actual[helicities] == pytest.approx(value, abs=1e-10 * scale)
+
+
+def test_rational_factor_is_found_and_unit_restriction_rejects_it(
+    artifact: Callable[[str], Path],
+) -> None:
+    path = artifact("photons")
+    summary = group_processes(path)
+    group_map = read_process_groups(path)
+    assert group_map is not None
+    (group,) = group_map.groups.values()
+    # Charges (2/3)^4 / (1/3)^4: the up-quark process is 16 times the down one.
+    assert group.representative.process_id == "d_dbar_to_a_a"
+    (member,) = group.members[1:]
+    assert member.process_id == "u_ubar_to_a_a"
+    assert member.factor == Fraction(16)
+    assert summary["new_relations"] == [
+        {
+            "process_id": "u_ubar_to_a_a",
+            "process": "u u~ > a a",
+            "representative": "d_dbar_to_a_a",
+            "factor": "16",
+            "permutation": [0, 1, 2, 3],
+            "conjugated": False,
+        }
+    ]
+
+    unit = artifact("photons")
+    group_processes(unit, only_unit_multiplier=True)
+    assert _partition(unit) == {
+        frozenset({"u_ubar_to_a_a"}),
+        frozenset({"d_dbar_to_a_a"}),
+    }
+
+
+def test_selected_helicity_coverage_is_never_grouped(
+    artifact: Callable[[str], Path],
+) -> None:
+    path = artifact("selected")
+    summary = group_processes(path)
+    assert summary["new_relations"] == []
+    assert summary["skipped"] == [
+        {"process_id": "d_dbar_to_a_a", "reason": "helicity coverage is selected"},
+        {"process_id": "u_ubar_to_a_a", "reason": "helicity coverage is selected"},
+    ]
+    assert _partition(path) == {
+        frozenset({"u_ubar_to_a_a"}),
+        frozenset({"d_dbar_to_a_a"}),
+    }
+
+
+def test_rerunning_the_analysis_merges_idempotently(
+    artifact: Callable[[str], Path],
+) -> None:
+    path = artifact("jets")
+    groups = path / "process-groups.json"
+    first = group_processes(path, consider_charge_conjugation=False)
+    stored = groups.read_bytes()
+
+    again = group_processes(path, consider_charge_conjugation=False)
+    assert again["new_relations"] == []
+    assert again["groups_before"] == again["groups_after"] == first["groups_after"]
+    assert groups.read_bytes() == stored
+    assert group_processes(path, analysis="none")["new_relations"] == []
+    assert groups.read_bytes() == stored
+
+    # Allowing charge conjugation only merges existing groups further.
+    conjugated = group_processes(path)
+    assert conjugated["groups_after"] == 9
+    assert all(relation["conjugated"] for relation in conjugated["new_relations"])
+    group_map = read_process_groups(path)
+    assert group_map is not None
+    assert [entry["consider_charge_conjugation"] for entry in group_map.analyses] == [
+        False,
+        True,
+    ]
diff --git a/pyamplicol/tests/integration/test_process_permutation_runtime.py b/pyamplicol/tests/integration/test_process_permutation_runtime.py
new file mode 100644
index 0000000000..190ed776f5
--- /dev/null
+++ b/pyamplicol/tests/integration/test_process_permutation_runtime.py
@@ -0,0 +1,283 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib.util
+import shutil
+from collections.abc import Iterator, Sequence
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, Runtime
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+from pyamplicol.models.builtin.validation import generic_validation_point
+
+_REPRESENTATIVE = "d d~ > z g"
+_PUBLIC = "d~ d > g z"
+_REPRESENTATIVE_TO_PUBLIC = (1, 0, 3, 2)
+_MODES = ("compiled", "eager", "recurrence")
+
+
+def _require_native_runtime() -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+    if importlib.util.find_spec("symbolica") is None:
+        pytest.skip("Symbolica is unavailable")
+
+
+def _generation_config(execution_mode: str) -> RunConfig:
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=execution_mode,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+@pytest.fixture(scope="module")
+def permutation_artifacts(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Iterator[dict[str, Path]]:
+    _require_native_runtime()
+    root = tmp_path_factory.mktemp("process-permutation-runtime")
+    artifacts = {mode: root / mode for mode in _MODES}
+    try:
+        for mode, artifact in artifacts.items():
+            Generator(_generation_config(mode)).generate(_REPRESENTATIVE, artifact)
+        yield artifacts
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+
+def _representative_point() -> tuple[tuple[float, float, float, float], ...]:
+    return tuple(
+        tuple(float(component) for component in particle.momentum)
+        for particle in generic_validation_point(_REPRESENTATIVE)
+    )
+
+
+def _public_point(
+    representative: Sequence[Sequence[float]],
+) -> tuple[tuple[float, ...], ...]:
+    public: list[tuple[float, ...] | None] = [None] * len(representative)
+    for representative_index, public_index in enumerate(
+        _REPRESENTATIVE_TO_PUBLIC
+    ):
+        public[public_index] = tuple(representative[representative_index])
+    assert all(momentum is not None for momentum in public)
+    return tuple(momentum for momentum in public if momentum is not None)
+
+
+def _flatten(values: object) -> tuple[complex, ...]:
+    flattened: list[complex] = []
+
+    def visit(value: object) -> None:
+        if isinstance(value, tuple | list):
+            for item in value:
+                visit(item)
+        else:
+            flattened.append(complex(value))
+
+    visit(values)
+    return tuple(flattened)
+
+
+def _assert_same_values(actual: object, expected: object) -> None:
+    assert _flatten(actual) == pytest.approx(
+        _flatten(expected),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+
+@pytest.mark.parametrize("execution_mode", _MODES)
+def test_inferred_both_side_permutation_preserves_every_execution_lane(
+    permutation_artifacts: dict[str, Path],
+    execution_mode: str,
+) -> None:
+    artifact = permutation_artifacts[execution_mode]
+    representative = Runtime.load(artifact, process=_REPRESENTATIVE)
+    public = Runtime.load(artifact, process=_PUBLIC)
+    representative_point = _representative_point()
+    public_point = _public_point(representative_point)
+
+    assert public.physics.process == _PUBLIC
+    assert public.physics.process_id == representative.physics.process_id
+    assert tuple(item.pdg_id for item in public.physics.external_particles) == (
+        -1,
+        1,
+        21,
+        23,
+    )
+    for representative_helicity, public_helicity in zip(
+        representative.physics.helicities,
+        public.physics.helicities,
+        strict=True,
+    ):
+        expected: list[int | None] = [None] * len(_REPRESENTATIVE_TO_PUBLIC)
+        for representative_index, public_index in enumerate(
+            _REPRESENTATIVE_TO_PUBLIC
+        ):
+            expected[public_index] = representative_helicity.values[
+                representative_index
+            ]
+        assert public_helicity.values == tuple(expected)
+    for representative_flow, public_flow in zip(
+        representative.physics.color_flows,
+        public.physics.color_flows,
+        strict=True,
+    ):
+        assert public_flow.word == tuple(
+            _REPRESENTATIVE_TO_PUBLIC[label - 1] + 1
+            for label in representative_flow.word
+        )
+
+    for count in (1, 5):
+        representative_batch = (representative_point,) * count
+        public_batch = (public_point,) * count
+        representative_resolved = representative.evaluate_resolved(
+            representative_batch
+        )
+        public_resolved = public.evaluate_resolved(public_batch)
+        _assert_same_values(public_resolved.values, representative_resolved.values)
+        _assert_same_values(public_resolved.total(), representative_resolved.total())
+        _assert_same_values(
+            public.evaluate(public_batch),
+            representative.evaluate(representative_batch),
+        )
+
+    representative_resolved = representative.evaluate_resolved(
+        (representative_point,)
+    )
+    public_resolved = public.evaluate_resolved((public_point,))
+    representative_helicity = next(
+        item for item in representative.physics.helicities if not item.structural_zero
+    )
+    helicity_index = representative.physics.helicities.index(
+        representative_helicity
+    )
+    public_helicity = public.physics.helicities[helicity_index]
+    representative_flow = representative.physics.color_flows[0]
+    public_flow = public.physics.color_flows[0]
+
+    representative_selected = representative.evaluate_resolved(
+        (representative_point,),
+        helicities=(representative_helicity.id,),
+        color_flows=(representative_flow.id,),
+    )
+    public_selected = public.evaluate_resolved(
+        (public_point,),
+        helicities=(public_helicity.id,),
+        color_flows=(public_flow.id,),
+    )
+    assert representative_selected.helicity_ids == (representative_helicity.id,)
+    assert representative_selected.color_ids == (representative_flow.id,)
+    assert public_selected.helicity_ids == (public_helicity.id,)
+    assert public_selected.color_ids == (public_flow.id,)
+    _assert_same_values(public_selected.values, representative_selected.values)
+    _assert_same_values(public_selected.total(), representative_selected.total())
+    _assert_same_values(
+        public.evaluate(
+            (public_point,),
+            helicities=(public_helicity.id,),
+            color_flows=(public_flow.id,),
+        ),
+        representative.evaluate(
+            (representative_point,),
+            helicities=(representative_helicity.id,),
+            color_flows=(representative_flow.id,),
+        ),
+    )
+    assert public_resolved.shape == representative_resolved.shape
+
+    representative_exact_full = representative.evaluate_resolved(
+        (representative_point,), precision=32
+    )
+    public_exact_full = public.evaluate_resolved((public_point,), precision=32)
+    assert public_exact_full.helicity_ids == tuple(
+        item.id for item in public.physics.helicities
+    )
+    assert public_exact_full.color_ids == tuple(
+        item.id for item in public.physics.color_flows
+    )
+    _assert_same_values(
+        public_exact_full.values,
+        representative_exact_full.values,
+    )
+    _assert_same_values(
+        public_exact_full.total(),
+        representative_exact_full.total(),
+    )
+
+    representative_exact = representative.evaluate_resolved(
+        (representative_point,),
+        helicities=(representative_helicity.id,),
+        color_flows=(representative_flow.id,),
+        precision=32,
+    )
+    public_exact = public.evaluate_resolved(
+        (public_point,),
+        helicities=(public_helicity.id,),
+        color_flows=(public_flow.id,),
+        precision=32,
+    )
+    _assert_same_values(public_exact.values, representative_exact.values)
+    _assert_same_values(public_exact.total(), representative_exact.total())
+    _assert_same_values(
+        public.evaluate(
+            (public_point,),
+            helicities=(public_helicity.id,),
+            color_flows=(public_flow.id,),
+            precision=32,
+        ),
+        representative.evaluate(
+            (representative_point,),
+            helicities=(representative_helicity.id,),
+            color_flows=(representative_flow.id,),
+            precision=32,
+        ),
+    )
+
+
+def test_runtime_load_accepts_ufo_style_parameter_pairs_directly(
+    permutation_artifacts: dict[str, Path],
+) -> None:
+    artifact = permutation_artifacts["compiled"]
+    point = _representative_point()
+    pair = Runtime.load(
+        artifact,
+        process=_REPRESENTATIVE,
+        model_parameters={"normalization.alpha_ew": [0.008, 0.0]},
+    )
+    scalar = Runtime.load(
+        artifact,
+        process=_REPRESENTATIVE,
+        model_parameters={"normalization.alpha_ew": complex(0.008, 0.0)},
+    )
+
+    _assert_same_values(pair.evaluate((point,)), scalar.evaluate((point,)))
+    _assert_same_values(
+        pair.evaluate_resolved((point,)).values,
+        scalar.evaluate_resolved((point,)).values,
+    )
diff --git a/pyamplicol/tests/integration/test_recurrence_generation_runtime.py b/pyamplicol/tests/integration/test_recurrence_generation_runtime.py
new file mode 100644
index 0000000000..6dd6154e78
--- /dev/null
+++ b/pyamplicol/tests/integration/test_recurrence_generation_runtime.py
@@ -0,0 +1,2454 @@
+# SPDX-License-Identifier: 0BSD
+"""Public generation/load canary for compact LC recurrence execution."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import json
+import math
+import os
+from collections.abc import Iterator
+from dataclasses import replace
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+import pyamplicol.generation.service as generation_service
+from pyamplicol import CompiledModel, Generator, ModelSource, Runtime
+from pyamplicol.api.errors import ArtifactError, EvaluationError
+from pyamplicol.artifacts import inspect_artifact, load_manifest
+from pyamplicol.artifacts.process_groups import (
+    read_process_groups,
+    write_process_groups,
+)
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+from pyamplicol.models.builtin.validation import generic_validation_point
+from pyamplicol.reporting import CallbackProgressSink, ProgressUpdate
+from pyamplicol.runtime.recurrence_exact._plan import _validate_execution
+
+_PROCESS = "d d~ > z g g"
+_THREE_LINE_PROCESS = "d d~ > u u~ s s~"
+_PURE_GLUON_PROCESS = "g g > g g"
+_N5_PURE_GLUON_PROCESS = "g g > g g g g g"
+_SAME_FLAVOUR_PROCESS = "d d~ > d d~"
+_NEUTRAL_CURRENT_PROCESS = "d d~ > e+ e-"
+_FOUR_LEPTON_PROCESS = "d d~ > e+ e- e+ e-"
+_FOUR_LEPTON_MADGRAPH_SEED_101 = Decimal("2.66945931894745456e-16")
+_DILEPTON_ZH_PROCESS = "d d~ > e+ e- z h"
+_CHARGED_CURRENT_PROCESS = "u d~ > e+ ve"
+_TWO_QUARK_LINE_PROCESS = "d d~ > t t~"
+_RELATION_REUSE_PROCESS = "d d~ > t t~ g g"
+# The immutable physics-v2 oracle was captured with the former rounded default.
+_HISTORICAL_REFERENCE_ALPHA_EW = 0.007546771114
+_CONTRACTED_COLOR_PROCESSES = (
+    _PROCESS,
+    _THREE_LINE_PROCESS,
+    _PURE_GLUON_PROCESS,
+    _SAME_FLAVOUR_PROCESS,
+    _TWO_QUARK_LINE_PROCESS,
+)
+_TOPOLOGY_REPLAY_PROCESSES = (
+    "d d~ > z g",
+    _PROCESS,
+)
+_TOPOLOGY_REPLAY_STRUCTURE = {
+    "d d~ > z g": (31, 34, 12),
+    _PROCESS: (69, 126, 24),
+}
+_RECURRENCE_KIND = "pyamplicol-runtime-recurrence-execution"
+_RECURRENCE_CAPABILITIES = {
+    "rusticol.recurrence-color.lc.v1",
+    "rusticol.recurrence-direct-arena.complex-f64.v1",
+}
+_CONTRACTED_RECURRENCE_CAPABILITIES = {
+    "rusticol.recurrence-color.contracted.v1",
+    "rusticol.recurrence-direct-arena.complex-f64.v1",
+    "rusticol.recurrence-helicity-selector-companion.v2",
+}
+_UFO_SM_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+_REFERENCE_PAYLOAD = json.loads(
+    (
+        Path(__file__).resolve().parents[1]
+        / "fixtures"
+        / "reference"
+        / "physics-v2.json"
+    ).read_text(encoding="utf-8")
+)
+
+_Point = tuple[tuple[float, ...], ...]
+_Points = tuple[_Point, ...]
+
+
+def _unavailable(reason: str) -> None:
+    if os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1":
+        pytest.fail(reason)
+    pytest.skip(reason)
+
+
+def _require_native_recurrence() -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    if importlib.util.find_spec("symbolica") is None:
+        _unavailable("Symbolica is unavailable")
+    rusticol = importlib.import_module("pyamplicol._rusticol")
+    if not hasattr(rusticol, "_lower_recurrence_direct_v2"):
+        _unavailable("the installed Rusticol extension lacks recurrence lowering")
+
+
+def _generation_config(
+    execution_mode: str,
+    *,
+    color_accuracy: str = "lc",
+    lc_flow_layout: str = "topology-replay",
+    relation_discovery_mode: str | None = "off",
+) -> RunConfig:
+    relation_discovery = GenerationRelationDiscoveryConfig(
+        precision_digits=80,
+        probe_count=2,
+        verification_probe_count=2,
+        seed=17,
+    )
+    if relation_discovery_mode is not None:
+        relation_discovery = replace(
+            relation_discovery,
+            mode=relation_discovery_mode,
+        )
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(
+            accuracy=color_accuracy,
+            # This suite asserts the direct-contraction artifact structure.
+            # Automatic FFT selection is covered by test_adjoint_fft_runtime.
+            contraction="direct",
+            lc_flow_layout=lc_flow_layout,
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=relation_discovery,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=execution_mode,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(
+                optimization_level=2 if execution_mode == "recurrence" else 1
+            ),
+        ),
+    )
+
+
+def _flatten(
+    values: tuple[
+        tuple[tuple[complex | Decimal, ...], ...],
+        ...,
+    ],
+) -> tuple[complex, ...]:
+    return tuple(
+        complex(value) for point in values for helicity in point for value in helicity
+    )
+
+
+def _validation_points(process_expression: str) -> _Points:
+    return (
+        tuple(
+            tuple(float(component) for component in particle.momentum)
+            for particle in generic_validation_point(process_expression)
+        ),
+    )
+
+
+def _seeded_validation_points(
+    process_expression: str,
+    *seeds: int,
+) -> _Points:
+    return tuple(
+        tuple(
+            tuple(float(component) for component in particle.momentum)
+            for particle in generic_validation_point(
+                process_expression,
+                seed=seed,
+            )
+        )
+        for seed in seeds
+    )
+
+
+def _reference_case(case_id: str) -> dict[str, Any]:
+    return next(case for case in _REFERENCE_PAYLOAD["cases"] if case["id"] == case_id)
+
+
+def _reference_point(point_id: str) -> _Point:
+    point = next(
+        item for item in _REFERENCE_PAYLOAD["points"] if item["id"] == point_id
+    )
+    return tuple(
+        tuple(float(component) for component in momentum)
+        for momentum in point["momenta"]
+    )
+
+
+def _assert_recurrence_per_point_selector_patterns(
+    artifact: Path,
+    point: _Point,
+    *,
+    expected_layout: str,
+) -> None:
+    """Exercise recurrence-native selector grouping without a compiled fallback."""
+
+    execution_files = tuple((artifact / "processes").glob("*/execution.json"))
+    assert len(execution_files) == 1
+    execution = json.loads(execution_files[0].read_text(encoding="utf-8"))
+    assert execution["kind"] == _RECURRENCE_KIND
+    assert execution["recurrence_plan_abi"] == "pyamplicol-recurrence-plan-v2"
+    assert execution["runtime_layout_abi"] == "pyamplicol-recurrence-runtime-layout-v2"
+    assert execution["recurrence_summary"]["lc_flow_layout"] == expected_layout
+    assert set(execution["required_runtime_capabilities"]) == _RECURRENCE_CAPABILITIES
+    assert inspect_artifact(artifact).processes[0].execution_mode == "recurrence"
+
+    runtime = Runtime.load(artifact)
+    resolved = runtime.evaluate_resolved((point,))
+    helicity_ids = tuple(
+        helicity.id
+        for helicity in runtime.physics.helicities
+        if not helicity.structural_zero
+    )
+    color_ids = resolved.color_ids
+    assert len(helicity_ids) >= 2
+    assert len(color_ids) >= 2
+    selector_pairs = (
+        (helicity_ids[0], color_ids[0]),
+        (helicity_ids[-1], color_ids[-1]),
+    )
+    patterns = {
+        "homogeneous": (selector_pairs[0],) * 8,
+        "alternating": selector_pairs * 4,
+        "random": tuple(selector_pairs[index] for index in (1, 0, 1, 1, 0, 0, 1, 0)),
+        "pre-grouped": (selector_pairs[0],) * 4 + (selector_pairs[1],) * 4,
+    }
+
+    for name, selectors in patterns.items():
+        points = (point,) * len(selectors)
+        actual = runtime.evaluate(
+            points,
+            helicity_by_point=tuple(selector[0] for selector in selectors),
+            color_flow_by_point=tuple(selector[1] for selector in selectors),
+        )
+        expected = tuple(
+            runtime.evaluate(
+                (point,),
+                helicities=(helicity_id,),
+                color_flows=(color_id,),
+            )[0]
+            for helicity_id, color_id in selectors
+        )
+        assert actual == pytest.approx(
+            expected,
+            rel=1.0e-12,
+            abs=1.0e-15,
+        ), name
+
+
+def _assert_topology_replay_structure(
+    artifact: Path,
+    process_expression: str,
+) -> None:
+    expected_currents, expected_contributions, expected_closures = (
+        _TOPOLOGY_REPLAY_STRUCTURE[process_expression]
+    )
+    manifest = load_manifest(artifact)
+    assert len(manifest.processes) == 1
+    process_id = str(manifest.processes[0]["id"])
+    execution = json.loads(
+        (artifact / "processes" / process_id / "execution.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    summary = execution["recurrence_summary"]
+    assert (
+        summary["current_count"],
+        summary["contribution_count"],
+        summary["closure_term_count"],
+    ) == (
+        expected_currents,
+        expected_contributions,
+        expected_closures,
+    )
+
+    inspection = inspect_artifact(artifact).processes[0]
+    assert inspection.invocation_count == expected_contributions
+    assert inspection.direct_contribution_row_count == expected_contributions
+    assert inspection.closure_count == expected_closures
+    assert inspection.direct_closure_row_count == expected_closures
+
+
+def _assert_topology_replay_artifacts_match(
+    recurrence_artifact: Path,
+    compiled_artifact: Path,
+    process_expression: str,
+) -> tuple[Runtime, Runtime, _Points]:
+    points = _validation_points(process_expression)
+    recurrence = Runtime.load(recurrence_artifact)
+    compiled = Runtime.load(compiled_artifact)
+
+    recurrence_total = recurrence.evaluate(points)
+    recurrence_resolved = recurrence.evaluate_resolved(points)
+    compiled_total = compiled.evaluate(points)
+    compiled_resolved = compiled.evaluate_resolved(points)
+
+    assert recurrence_resolved.total() == pytest.approx(
+        recurrence_total,
+        rel=1.0e-13,
+        abs=1.0e-15,
+    )
+    assert compiled_resolved.total() == pytest.approx(
+        compiled_total,
+        rel=1.0e-13,
+        abs=1.0e-15,
+    )
+    assert recurrence_resolved.helicity_ids == compiled_resolved.helicity_ids
+    assert recurrence_resolved.color_ids == compiled_resolved.color_ids
+    assert recurrence_resolved.shape == compiled_resolved.shape
+    assert _flatten(recurrence_resolved.values) == pytest.approx(
+        _flatten(compiled_resolved.values),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert recurrence_total == pytest.approx(
+        compiled_total,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+    # Public flow IDs are not recurrence construction-sector IDs. Exercise
+    # every public selector through both resolved and optimized runtime paths.
+    for color_id in recurrence_resolved.color_ids:
+        recurrence_selected = recurrence.evaluate(points, color_flows=(color_id,))
+        compiled_selected = compiled.evaluate(points, color_flows=(color_id,))
+        recurrence_selected_resolved = recurrence.evaluate_resolved(
+            points,
+            color_flows=(color_id,),
+        )
+        compiled_selected_resolved = compiled.evaluate_resolved(
+            points,
+            color_flows=(color_id,),
+        )
+        assert recurrence_selected_resolved.helicity_ids == (
+            compiled_selected_resolved.helicity_ids
+        )
+        assert recurrence_selected_resolved.color_ids == (
+            compiled_selected_resolved.color_ids
+        )
+        assert recurrence_selected_resolved.shape == compiled_selected_resolved.shape
+        assert _flatten(recurrence_selected_resolved.values) == pytest.approx(
+            _flatten(compiled_selected_resolved.values),
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+        assert recurrence_selected == pytest.approx(
+            compiled_selected,
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+
+    return recurrence, compiled, points
+
+
+def _assert_decimal_values_match(
+    actual: object,
+    expected: object,
+    precision: int,
+) -> None:
+    assert isinstance(actual, tuple)
+    assert isinstance(expected, tuple)
+    assert len(actual) == len(expected)
+    relative_tolerance = Decimal("1e-12")
+    absolute_tolerance = Decimal("1e-15")
+    for actual_value, expected_value in zip(actual, expected, strict=True):
+        if isinstance(actual_value, tuple):
+            _assert_decimal_values_match(actual_value, expected_value, precision)
+            continue
+        assert isinstance(actual_value, Decimal)
+        assert isinstance(expected_value, Decimal)
+        assert abs(actual_value - expected_value) <= (
+            absolute_tolerance + relative_tolerance * abs(expected_value)
+        )
+
+
+def _assert_scale_sensitive_values_match(
+    actual: object,
+    expected: object,
+    *,
+    relative_tolerance: Decimal = Decimal("1e-12"),
+) -> None:
+    """Compare tiny exact values without the report's absolute tolerance floor."""
+
+    assert isinstance(actual, tuple)
+    assert isinstance(expected, tuple)
+    assert len(actual) == len(expected)
+    for actual_value, expected_value in zip(actual, expected, strict=True):
+        if isinstance(actual_value, tuple):
+            _assert_scale_sensitive_values_match(
+                actual_value,
+                expected_value,
+                relative_tolerance=relative_tolerance,
+            )
+            continue
+        assert isinstance(actual_value, Decimal)
+        assert isinstance(expected_value, Decimal)
+        scale = max(abs(actual_value), abs(expected_value))
+        if scale == 0:
+            assert actual_value == expected_value
+        else:
+            assert abs(actual_value - expected_value) <= relative_tolerance * scale
+
+
+def _single_recurrence_execution(artifact: Path) -> dict[str, Any]:
+    execution_paths = tuple((artifact / "processes").glob("*/execution.json"))
+    assert len(execution_paths) == 1
+    execution = json.loads(execution_paths[0].read_text(encoding="utf-8"))
+    assert execution["kind"] == _RECURRENCE_KIND
+    return execution
+
+
+def _manifest_relation_discovery(artifact: Path) -> object:
+    manifest = load_manifest(artifact)
+    generation = manifest.extensions["generation"]
+    assert isinstance(generation, dict)
+    concrete_processes = generation["concrete_processes"]
+    assert isinstance(concrete_processes, list)
+    assert len(concrete_processes) == 1
+    process = concrete_processes[0]
+    assert isinstance(process, dict)
+    filters = process["filters"]
+    assert isinstance(filters, dict)
+    return filters.get("relation_discovery")
+
+
+def _assert_runtime_values_match(
+    actual: Runtime,
+    expected: Runtime,
+    points: _Points,
+) -> None:
+    actual_resolved = actual.evaluate_resolved(points)
+    expected_resolved = expected.evaluate_resolved(points)
+    assert actual_resolved.helicity_ids == expected_resolved.helicity_ids
+    assert actual_resolved.color_ids == expected_resolved.color_ids
+    assert actual_resolved.shape == expected_resolved.shape
+    assert _flatten(actual_resolved.values) == pytest.approx(
+        _flatten(expected_resolved.values),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert actual_resolved.total() == pytest.approx(
+        actual.evaluate(points),
+        rel=1.0e-13,
+        abs=1.0e-15,
+    )
+    assert actual.evaluate(points) == pytest.approx(
+        expected.evaluate(points),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+    actual_exact = actual.evaluate_resolved(points, precision=50)
+    expected_exact = expected.evaluate_resolved(points, precision=50)
+    assert actual_exact.helicity_ids == expected_exact.helicity_ids
+    assert actual_exact.color_ids == expected_exact.color_ids
+    assert actual_exact.shape == expected_exact.shape
+    _assert_decimal_values_match(
+        actual_exact.values,
+        expected_exact.values,
+        50,
+    )
+    _assert_decimal_values_match(
+        actual_exact.total(),
+        actual.evaluate(points, precision=50),
+        50,
+    )
+    _assert_decimal_values_match(
+        actual.evaluate(points, precision=50),
+        expected.evaluate(points, precision=50),
+        50,
+    )
+
+
+def _assert_topology_replay_exact_matches_compiled(
+    recurrence: Runtime,
+    compiled: Runtime,
+    points: _Points,
+) -> None:
+    for precision in (32, 50):
+        recurrence_resolved = recurrence.evaluate_resolved(
+            points,
+            precision=precision,
+        )
+        compiled_resolved = compiled.evaluate_resolved(
+            points,
+            precision=precision,
+        )
+        assert recurrence_resolved.helicity_ids == compiled_resolved.helicity_ids
+        assert recurrence_resolved.color_ids == compiled_resolved.color_ids
+        assert recurrence_resolved.shape == compiled_resolved.shape
+        _assert_decimal_values_match(
+            recurrence_resolved.values,
+            compiled_resolved.values,
+            precision,
+        )
+        _assert_decimal_values_match(
+            recurrence_resolved.total(),
+            recurrence.evaluate(points, precision=precision),
+            precision,
+        )
+
+        # Requesting every public ID explicitly must preserve the complete
+        # resolved result, and each physical flow remains independently usable.
+        explicit = recurrence.evaluate_resolved(
+            points,
+            helicities=recurrence_resolved.helicity_ids,
+            color_flows=recurrence_resolved.color_ids,
+            precision=precision,
+        )
+        _assert_decimal_values_match(
+            explicit.values,
+            recurrence_resolved.values,
+            precision,
+        )
+        for color_id in recurrence_resolved.color_ids:
+            actual = recurrence.evaluate_resolved(
+                points,
+                color_flows=(color_id,),
+                precision=precision,
+            )
+            expected = compiled.evaluate_resolved(
+                points,
+                color_flows=(color_id,),
+                precision=precision,
+            )
+            _assert_decimal_values_match(actual.values, expected.values, precision)
+
+        sampled_helicities = tuple(
+            recurrence_resolved.helicity_ids[index]
+            for index in sorted(
+                {
+                    0,
+                    len(recurrence_resolved.helicity_ids) // 2,
+                    len(recurrence_resolved.helicity_ids) - 1,
+                }
+            )
+        )
+        actual = recurrence.evaluate_resolved(
+            points,
+            helicities=sampled_helicities,
+            precision=precision,
+        )
+        expected = compiled.evaluate_resolved(
+            points,
+            helicities=sampled_helicities,
+            precision=precision,
+        )
+        _assert_decimal_values_match(actual.values, expected.values, precision)
+
+        doubled_points = points + points
+        helicity_by_point = (
+            recurrence_resolved.helicity_ids[0],
+            recurrence_resolved.helicity_ids[-1],
+        )
+        color_by_point = (
+            recurrence_resolved.color_ids[0],
+            recurrence_resolved.color_ids[-1],
+        )
+        _assert_decimal_values_match(
+            recurrence.evaluate(
+                doubled_points,
+                helicity_by_point=helicity_by_point,
+                color_flow_by_point=color_by_point,
+                precision=precision,
+            ),
+            compiled.evaluate(
+                doubled_points,
+                helicity_by_point=helicity_by_point,
+                color_flow_by_point=color_by_point,
+                precision=precision,
+            ),
+            precision,
+        )
+
+
+def _assert_contracted_color_artifacts_match(
+    recurrence_artifact: Path,
+    compiled_artifact: Path,
+    process_expression: str,
+    color_accuracy: str,
+    *,
+    parameter_update: tuple[str, float] | None = None,
+) -> None:
+    points = _validation_points(process_expression)
+    recurrence = Runtime.load(recurrence_artifact)
+    compiled = Runtime.load(compiled_artifact)
+    assert recurrence.physics.color_accuracy == color_accuracy
+    assert recurrence.physics.color_ids == ("color:contracted",)
+    assert compiled.physics.color_ids == recurrence.physics.color_ids
+    assert compiled.physics.helicity_ids == recurrence.physics.helicity_ids
+
+    recurrence_total = recurrence.evaluate(points)
+    compiled_total = compiled.evaluate(points)
+    recurrence_resolved = recurrence.evaluate_resolved(points)
+    compiled_resolved = compiled.evaluate_resolved(points)
+    assert recurrence_resolved.total() == pytest.approx(
+        recurrence_total,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert recurrence_total == pytest.approx(
+        compiled_total,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert recurrence_resolved.shape == compiled_resolved.shape
+    assert _flatten(recurrence_resolved.values) == pytest.approx(
+        _flatten(compiled_resolved.values),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+    nonzero_helicities = tuple(
+        helicity.id
+        for helicity in recurrence.physics.helicities
+        if not helicity.structural_zero
+    )
+    assert nonzero_helicities
+    sampled_helicities = tuple(
+        dict.fromkeys(
+            (
+                nonzero_helicities[0],
+                nonzero_helicities[len(nonzero_helicities) // 2],
+                nonzero_helicities[-1],
+            )
+        )
+    )
+    recurrence_selected = recurrence.evaluate_resolved(
+        points,
+        helicities=sampled_helicities,
+    )
+    compiled_selected = compiled.evaluate_resolved(
+        points,
+        helicities=sampled_helicities,
+    )
+    assert _flatten(recurrence_selected.values) == pytest.approx(
+        _flatten(compiled_selected.values),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+    repeated_points = points * len(sampled_helicities)
+    assert recurrence.evaluate(
+        repeated_points,
+        helicity_by_point=sampled_helicities,
+    ) == pytest.approx(
+        compiled.evaluate(
+            repeated_points,
+            helicity_by_point=sampled_helicities,
+        ),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    with pytest.raises(EvaluationError, match="color-flow selection"):
+        recurrence.evaluate(points, color_flows=("color:contracted",))
+
+    for precision in (32, 50):
+        recurrence_exact = recurrence.evaluate_resolved(
+            points,
+            helicities=sampled_helicities,
+            precision=precision,
+        )
+        recurrence_f64 = recurrence.evaluate_resolved(
+            points,
+            helicities=sampled_helicities,
+        )
+        assert _flatten(recurrence_exact.values) == pytest.approx(
+            _flatten(recurrence_f64.values),
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+        _assert_decimal_values_match(
+            recurrence_exact.total(),
+            recurrence.evaluate(
+                points,
+                helicities=sampled_helicities,
+                precision=precision,
+            ),
+            precision,
+        )
+
+    manifest = load_manifest(recurrence_artifact)
+    assert len(manifest.processes) == 1
+    process_id = str(manifest.processes[0]["id"])
+    execution = json.loads(
+        (recurrence_artifact / "processes" / process_id / "execution.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    assert execution["recurrence_summary"]["lc_flow_layout"] == "contracted-color-union"
+    assert (
+        set(execution["required_runtime_capabilities"])
+        == _CONTRACTED_RECURRENCE_CAPABILITIES
+    )
+    color_reference = execution["runtime_metadata"]["color_contraction"]
+    inspection = inspect_artifact(recurrence_artifact).processes[0]
+    assert inspection.execution_mode == "recurrence"
+    assert inspection.recurrence_color_accuracy == color_accuracy
+    assert inspection.recurrence_color_storage == color_reference["storage"]
+    assert inspection.recurrence_color_sector_count == color_reference["sector_count"]
+    assert (
+        inspection.recurrence_color_active_sector_count
+        == color_reference["active_sector_count"]
+    )
+    assert (
+        inspection.recurrence_color_component_count
+        == color_reference["component_count"]
+    )
+    assert inspection.recurrence_color_group_count == color_reference["group_count"]
+    assert inspection.recurrence_color_entry_count == color_reference["entry_count"]
+    assert (
+        inspection.recurrence_color_logical_entry_count
+        == color_reference["logical_entry_count"]
+    )
+    if process_expression == _THREE_LINE_PROCESS:
+        # Six endpoint pairings are physical. The six orderings of each
+        # disconnected open-string forest are coherent aliases and must have
+        # one deterministic owner, not six duplicated amplitude destinations.
+        assert color_reference["sector_count"] == 36
+        assert color_reference["active_sector_count"] == 6
+        assert color_reference["group_count"] == (
+            6 * color_reference["component_count"]
+        )
+        assert color_reference["storage"] == "repeated"
+    color_path = (
+        recurrence_artifact / "processes" / process_id / color_reference["path"]
+    )
+    assert color_path.is_file()
+    assert color_path.stat().st_size == color_reference["size_bytes"]
+    payloads = {
+        record.path: record
+        for record in manifest.payloads
+        if record.process_id == process_id
+    }
+    relative_color_path = color_path.relative_to(recurrence_artifact).as_posix()
+    assert payloads[relative_color_path].sha256 == color_reference["sha256"]
+
+    if parameter_update is not None:
+        parameter_name, parameter_value = parameter_update
+        exact_before_update = recurrence.evaluate(points, precision=50)
+        recurrence.set_model_parameters({parameter_name: parameter_value})
+        compiled.set_model_parameters({parameter_name: parameter_value})
+        assert recurrence.evaluate(points, precision=50) != exact_before_update
+        assert recurrence.evaluate(points) == pytest.approx(
+            compiled.evaluate(points),
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+        recurrence_exact = recurrence.evaluate_resolved(points, precision=50)
+        recurrence_f64 = recurrence.evaluate_resolved(points)
+        assert _flatten(recurrence_exact.values) == pytest.approx(
+            _flatten(recurrence_f64.values),
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+        _assert_decimal_values_match(
+            recurrence_exact.total(),
+            recurrence.evaluate(points, precision=50),
+            50,
+        )
+
+
+def _contracted_structure_signature(artifact: Path) -> dict[str, object]:
+    manifest = load_manifest(artifact)
+    assert len(manifest.processes) == 1
+    process_id = str(manifest.processes[0]["id"])
+    execution = json.loads(
+        (artifact / "processes" / process_id / "execution.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    summary = execution["recurrence_summary"]
+    inspection = execution["plan"]["inspection_summary"]
+    schedule = inspection["schedule"]
+    construction = inspection["construction"]
+    color = execution["runtime_metadata"]["color_contraction"]
+    return {
+        "layout": summary["lc_flow_layout"],
+        "currents": summary["current_count"],
+        "contributions": summary["contribution_count"],
+        "closures": summary["closure_term_count"],
+        "sources": schedule["source_row_count"],
+        "finalizations": schedule["finalization_count"],
+        "destinations": schedule["amplitude_destination_count"],
+        "resolved_helicities": schedule["resolved_helicity_count"],
+        "peak_contribution_count_semantics": construction[
+            "peak_contribution_count_semantics"
+        ],
+        "dynamic_color_states": construction["peak_dynamic_color_state_count"],
+        "color_storage": color["storage"],
+        "color_sectors": color["sector_count"],
+        "active_color_sectors": color["active_sector_count"],
+        "color_components": color["component_count"],
+        "color_groups": color["group_count"],
+        "color_entries": color["entry_count"],
+        "logical_color_entries": color["logical_entry_count"],
+        "factorization": color["factorization"],
+    }
+
+
+@pytest.fixture(scope="module")
+def builtin_sm_recurrence_jit_o2_model() -> Iterator[ModelSource]:
+    """Use a source-current prepared pack without weakening packaged checks."""
+
+    override = os.environ.get("PYAMPLICOL_RECURRENCE_TEST_PREPARED_MODEL")
+    if override:
+        yield ModelSource.from_path(Path(override))
+        return
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+        yield ModelSource.from_path(prepared_model)
+
+
+@pytest.fixture(scope="module")
+def builtin_sm_current_recurrence_jit_o2_model(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> CompiledModel:
+    """Prepare the live built-in lowering contract for alias regressions."""
+
+    _require_native_recurrence()
+    root = tmp_path_factory.mktemp("builtin-sm-current-recurrence-jit-o2")
+    return ModelSource.built_in_sm().compile(
+        cache_dir=root / "model-cache",
+        use_cache=True,
+        prepared_output=root / "built-in-sm-jit-o2.pyamplicol-model",
+        evaluator=_generation_config("recurrence").evaluator,
+    )
+
+
+@pytest.fixture(scope="module")
+def ufo_sm_recurrence_jit_o2_model(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> CompiledModel:
+    """Prepare one reusable UFO-SM recurrence pack for both public canaries."""
+
+    _require_native_recurrence()
+    root = tmp_path_factory.mktemp("ufo-sm-recurrence-jit-o2")
+    model = ModelSource.from_path(
+        _UFO_SM_ROOT / "sm.json",
+        restriction=_UFO_SM_ROOT / "restrict_default.json",
+    ).compile(
+        cache_dir=root / "model-cache",
+        use_cache=True,
+        prepared_output=root / "ufo-sm-jit-o2.pyamplicol-model",
+        evaluator=_generation_config("recurrence").evaluator,
+    )
+    assert model.is_prepared
+    assert model.prepared_backend == "jit"
+    return model
+
+
+@pytest.mark.parametrize("model_source", ("builtin", "ufo"))
+@pytest.mark.parametrize("color_accuracy", ("lc", "nlc", "full"))
+def test_relation_discovery_modes_preserve_recurrence_artifacts_and_values(
+    tmp_path: Path,
+    model_source: str,
+    color_accuracy: str,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    """Relation probes may optimize exact reuse but never alter amplitudes."""
+
+    _require_native_recurrence()
+    model = (
+        builtin_sm_recurrence_jit_o2_model
+        if model_source == "builtin"
+        else ufo_sm_recurrence_jit_o2_model
+    )
+    compiled_artifact = tmp_path / f"{model_source}-{color_accuracy}-compiled"
+    Generator(
+        _generation_config(
+            "compiled",
+            color_accuracy=color_accuracy,
+        )
+    ).generate(
+        _PROCESS,
+        compiled_artifact,
+        model=model,
+    )
+    compiled = Runtime.load(compiled_artifact)
+    points = _seeded_validation_points(_PROCESS, 101, 211)
+
+    executions: dict[str, dict[str, Any]] = {}
+    reports: dict[str, dict[str, Any]] = {}
+    lanes: dict[str, dict[str, Any]] = {}
+    runtimes: dict[str, Runtime] = {}
+    for mode in ("off", "diagnostic", "certified-reuse"):
+        artifact = tmp_path / f"{model_source}-{color_accuracy}-{mode}"
+        Generator(
+            _generation_config(
+                "recurrence",
+                color_accuracy=color_accuracy,
+                relation_discovery_mode=mode,
+            )
+        ).generate(
+            _PROCESS,
+            artifact,
+            model=model,
+        )
+        execution = _single_recurrence_execution(artifact)
+        executions[mode] = execution
+        runtime = Runtime.load(artifact)
+        runtimes[mode] = runtime
+        _assert_runtime_values_match(runtime, compiled, points)
+
+        report = execution["plan"]["inspection_summary"].get("relation_discovery")
+        manifest_report = _manifest_relation_discovery(artifact)
+        assert report is None
+        assert isinstance(manifest_report, dict)
+        reports[mode] = manifest_report
+        assert manifest_report["abi"] == (
+            "pyamplicol-artifact-numerical-current-reuse-v1"
+        )
+        assert manifest_report["requested_mode"] == mode
+        assert manifest_report["execution_mode"] == "recurrence"
+        assert manifest_report["lane_count"] == 1
+        lane = manifest_report["lanes"]["primary"]
+        assert isinstance(lane, dict)
+        lanes[mode] = lane
+        assert lane["requested_mode"] == mode
+        assert lane["scope"] == {
+            "execution_mode": "recurrence",
+            "color_accuracy": color_accuracy,
+            "representation": "recurrence-direct-plan-v2",
+        }
+        assert (
+            manifest_report["certified_relation_count"]
+            == lane["certified_relation_count"]
+        )
+        assert (
+            manifest_report["applied_relation_count"] == lane["applied_relation_count"]
+        )
+        if mode == "off":
+            assert lane["state"] == "disabled-by-user"
+            assert lane["candidate_capture"] is None
+            assert lane["verification_capture"] is None
+            assert lane["application_capture"] is None
+            assert lane["warning"]["required"] is False
+            assert manifest_report["warning"]["required"] is False
+            assert manifest_report["native_relation_application"] is None
+            continue
+
+        candidate = lane["candidate_capture"]
+        verification = lane["verification_capture"]
+        assert isinstance(candidate, dict)
+        assert candidate["precision_digits"] == 80
+        assert candidate["point_count"] == 2
+        discovery = lane["discovery"]
+        assert isinstance(discovery, dict)
+        probe_contract = discovery["probe_contract"]
+        assert isinstance(probe_contract, dict)
+        assert probe_contract["algorithm"] == (
+            "authenticated-independent-recursive-decimal-raw-probes-v2"
+        )
+        assert probe_contract["current_dimension_bound"] is True
+        assert (
+            probe_contract["runtime_parameter_schema_sha256"]
+            == candidate["runtime_parameter_schema_sha256"]
+        )
+        assert candidate["parameter_contexts"]
+        if discovery["numerical_candidate_count"] == 0:
+            assert verification is None
+            assert probe_contract["independent_verification"] is False
+            assert probe_contract["verification_status"] == (
+                "not-required-no-candidate-hypothesis"
+            )
+            assert probe_contract["verification_point_sha256s"] == []
+            assert probe_contract["verification_capture_sha256"] is None
+        else:
+            assert isinstance(verification, dict)
+            assert verification["point_count"] == 2
+            assert set(candidate["kinematic_sha256s"]).isdisjoint(
+                verification["kinematic_sha256s"]
+            )
+            assert probe_contract["independent_verification"] is True
+            assert verification["parameter_contexts"]
+            assert set(candidate["parameter_context_sha256s"]).isdisjoint(
+                verification["parameter_context_sha256s"]
+            )
+        persisted = lane["persisted_numerical_evidence"]
+        assert persisted["raw_evidence_retained"] is False
+        if verification is None:
+            assert persisted["verification_capture"] is None
+            assert persisted["generation_raw_evidence_bytes"] == 0
+            assert persisted["generation_evidence_transport_bytes"] == 0
+            assert persisted["generation_evidence_encoding"] is None
+        else:
+            assert persisted["generation_raw_evidence_bytes"] > 0
+        assert persisted["measured_payload_bytes"] < 64 << 20
+        assert (
+            persisted["full_census"]["decision_sha256"] == discovery["decision_sha256"]
+        )
+        assert (
+            discovery["certified_numerical_relation_count"]
+            == lane["certified_relation_count"]
+        )
+        application = lane["application"]
+        assert isinstance(application, dict)
+        assert (
+            application["certified_relation_count"] == lane["certified_relation_count"]
+        )
+        native = manifest_report["native_relation_application"]
+        certified = lane["certified_relation_count"]
+        applied = lane["applied_relation_count"]
+        if certified == 0:
+            assert applied == 0
+            assert native is None
+        else:
+            assert isinstance(native, dict)
+            assert native["requested_mode"] == lane["effective_mode"]
+            assert native["exact_certified_relation_count"] == certified
+        effective_mode = lane["effective_mode"]
+        if effective_mode == "diagnostic":
+            assert applied == 0
+            assert lane["warning"]["required"] is False
+            assert manifest_report["warning"]["required"] is False
+            if certified:
+                assert isinstance(native, dict)
+                assert native["applied_relation_count"] == 0
+                assert native["scale_copy_row_count"] == 0
+            if mode == "certified-reuse":
+                assert lane["effective_reuse_state"] == "disabled"
+                assert lane["effective_mode_reason"] in {
+                    "multi-helicity-all-flow-member-scope-unproven",
+                    "contracted-opposite-binary64-disabled",
+                }
+                assert (
+                    lane["application_scope"]["effective_mode_reason"]
+                    == (lane["effective_mode_reason"])
+                )
+        else:
+            assert effective_mode == mode == "certified-reuse"
+            # Discovery retains the complete verified census, while contracted
+            # colour applies only the supported equal/zero subset.
+            certificates = application["certificates"]
+            expected_applied = sum(
+                certificate["relation_kind"] != "opposite" or color_accuracy == "lc"
+                for certificate in certificates
+            )
+            assert applied == expected_applied
+            if applied:
+                assert isinstance(native, dict)
+                assert native["applied_relation_count"] == applied
+                assert native["scale_copy_row_count"] == applied
+            assert lane["warning"]["required"] is (applied > 0)
+            assert manifest_report["warning"]["required"] is (applied > 0)
+            assert lane["application_validation"]["status"] == (
+                "verified" if applied else "not-required-no-applied-relations"
+            )
+
+    _assert_runtime_values_match(runtimes["diagnostic"], runtimes["off"], points)
+    _assert_runtime_values_match(
+        runtimes["certified-reuse"],
+        runtimes["off"],
+        points,
+    )
+
+    off_inspection = executions["off"]["plan"]["inspection_summary"]
+    diagnostic_inspection = executions["diagnostic"]["plan"]["inspection_summary"]
+    assert (
+        executions["off"]["recurrence_summary"]
+        == executions["diagnostic"]["recurrence_summary"]
+    )
+    for key in (
+        "schedule",
+        "construction",
+        "selector_work_certificate",
+        "direct_arena",
+    ):
+        assert off_inspection.get(key) == diagnostic_inspection.get(key)
+    for capture_name in ("candidate_capture", "verification_capture"):
+        diagnostic_capture = lanes["diagnostic"][capture_name]
+        certified_capture = lanes["certified-reuse"][capture_name]
+        if diagnostic_capture is None or certified_capture is None:
+            assert diagnostic_capture is certified_capture is None
+            continue
+        assert isinstance(diagnostic_capture, dict)
+        assert isinstance(certified_capture, dict)
+        for key in (
+            "precision_digits",
+            "point_count",
+            "point_sha256s",
+            "kinematic_sha256s",
+            "context_sha256s",
+            "current_count",
+            "current_dimensions_sha256",
+            "context_policy",
+        ):
+            assert diagnostic_capture[key] == certified_capture[key]
+    diagnostic_discovery = lanes["diagnostic"]["discovery"]
+    certified_discovery = lanes["certified-reuse"]["discovery"]
+    assert isinstance(diagnostic_discovery, dict)
+    assert isinstance(certified_discovery, dict)
+    for key in (
+        "tested_hypothesis_count",
+        "numerical_candidate_count",
+        "verification_rejected_count",
+        "certified_numerical_relation_count",
+    ):
+        assert diagnostic_discovery[key] == certified_discovery[key]
+
+    def relation_identity(certificate: dict[str, Any]) -> tuple[object, ...]:
+        return (
+            certificate["current_id"],
+            certificate["representative_id"],
+            certificate["execution_representative_id"],
+            certificate["relation_kind"],
+            certificate["factor_integer"],
+            certificate["current_dimension"],
+        )
+
+    assert [
+        relation_identity(certificate)
+        for certificate in lanes["diagnostic"]["application"]["certificates"]
+    ] == [
+        relation_identity(certificate)
+        for certificate in lanes["certified-reuse"]["application"]["certificates"]
+    ]
+
+
+def test_charged_current_alias_uses_native_identity_for_numerical_probes(
+    tmp_path: Path,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Keep display ownership separate from the canonical native schedule ID."""
+
+    _require_native_recurrence()
+    observed_process_ids: list[str] = []
+    original = generation_service.build_recurrence_numerical_current_probe_points
+
+    def recording_probe_builder(*args: Any, **kwargs: Any) -> Any:
+        process_id = str(kwargs["process_id"])
+        result = original(*args, **kwargs)
+        observed_process_ids.append(process_id)
+        assert all(
+            point.process_id == process_id for capture in result for point in capture
+        )
+        assert all(
+            point.process == _CHARGED_CURRENT_PROCESS
+            for capture in result
+            for point in capture
+        )
+        return result
+
+    monkeypatch.setattr(
+        generation_service,
+        "build_recurrence_numerical_current_probe_points",
+        recording_probe_builder,
+    )
+    artifact = tmp_path / "charged-current-alias"
+    Generator(
+        _generation_config(
+            "recurrence",
+            relation_discovery_mode="certified-reuse",
+        )
+    ).generate(
+        _CHARGED_CURRENT_PROCESS,
+        artifact,
+        model=builtin_sm_recurrence_jit_o2_model,
+    )
+
+    assert len(observed_process_ids) == 1
+    canonical_process_id = observed_process_ids[0]
+    execution = _single_recurrence_execution(artifact)
+    display_process_id = str(load_manifest(artifact).processes[0]["id"])
+    assert canonical_process_id != display_process_id
+    assert execution["plan"]["process_binding"]["process_id"] == display_process_id
+    lane = _manifest_relation_discovery(artifact)["lanes"]["primary"]
+    assert lane["requested_mode"] == "certified-reuse"
+
+
+def test_no_relation_reuse_and_opt_out_emit_identical_recurrence_plan(
+    tmp_path: Path,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+) -> None:
+    """Certified-reuse discovery is byte-neutral when its certified set is empty."""
+
+    _require_native_recurrence()
+    artifacts: dict[str, Path] = {}
+    executions: dict[str, dict[str, Any]] = {}
+    for label, mode in (("certified", "certified-reuse"), ("off", "off")):
+        artifact = tmp_path / label
+        Generator(
+            _generation_config(
+                "recurrence",
+                relation_discovery_mode=mode,
+            )
+        ).generate(
+            _NEUTRAL_CURRENT_PROCESS,
+            artifact,
+            model=builtin_sm_recurrence_jit_o2_model,
+        )
+        artifacts[label] = artifact
+        executions[label] = _single_recurrence_execution(artifact)
+
+    certified_lane = _manifest_relation_discovery(artifacts["certified"])["lanes"][
+        "primary"
+    ]
+    assert certified_lane["requested_mode"] == "certified-reuse"
+    assert certified_lane["certified_relation_count"] == 0
+    assert certified_lane["applied_relation_count"] == 0
+    assert certified_lane["state"] == "no_certified_numerical_relation"
+    certified_schedule = next(artifacts["certified"].rglob("recurrence-runtime.pacbin"))
+    off_schedule = next(artifacts["off"].rglob("recurrence-runtime.pacbin"))
+    assert certified_schedule.read_bytes() == off_schedule.read_bytes()
+    assert (
+        executions["certified"]["plan"]["inspection_summary"]["schedule_digest"]
+        != executions["off"]["plan"]["inspection_summary"]["schedule_digest"]
+    )
+    assert (
+        executions["certified"]["plan"]["process_binding"][
+            "native_schedule_semantic_digest"
+        ]
+        == executions["off"]["plan"]["process_binding"][
+            "native_schedule_semantic_digest"
+        ]
+    )
+    assert (
+        executions["certified"]["recurrence_summary"]
+        == executions["off"]["recurrence_summary"]
+    )
+    for key in (
+        "schedule",
+        "construction",
+        "selector_work_certificate",
+        "direct_arena",
+    ):
+        assert executions["certified"]["plan"]["inspection_summary"].get(
+            key
+        ) == executions["off"]["plan"]["inspection_summary"].get(key)
+
+
+@pytest.mark.parametrize("model_source", ("builtin", "ufo"))
+def test_recurrence_audit_suppresses_unsafe_all_flow_selector_domain(
+    tmp_path: Path,
+    model_source: str,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Skip unsafe all-flow hypotheses and preserve both SM frontends."""
+
+    _require_native_recurrence()
+    model = (
+        builtin_sm_recurrence_jit_o2_model
+        if model_source == "builtin"
+        else ufo_sm_recurrence_jit_o2_model
+    )
+    compiled_artifact = tmp_path / f"{model_source}-compiled"
+    Generator(
+        _generation_config(
+            "compiled",
+            lc_flow_layout="all-flow-union",
+        )
+    ).generate(
+        _RELATION_REUSE_PROCESS,
+        compiled_artifact,
+        model=model,
+    )
+    compiled = Runtime.load(compiled_artifact)
+    points = _seeded_validation_points(_RELATION_REUSE_PROCESS, 101, 211, 307)
+
+    executions: dict[str, dict[str, Any]] = {}
+    reports: dict[str, dict[str, Any]] = {}
+    lanes: dict[str, dict[str, Any]] = {}
+    runtimes: dict[str, Runtime] = {}
+    active_artifact: Path | None = None
+    active_mode: str | None = None
+    warning_publications: list[tuple[str, bool, str]] = []
+    warning_counts = {"off": 0, "diagnostic": 0, "certified-reuse": 0}
+    original_warning = generation_service._LOGGER.warning
+
+    def record_warning(message: object, *args: object, **kwargs: object) -> None:
+        rendered = str(message) % args if args else str(message)
+        if "proofless-numerical-current-relations-applied-v1" in rendered:
+            assert active_mode is not None
+            warning_counts[active_mode] += 1
+            warning_publications.append(
+                (
+                    active_mode,
+                    active_artifact is not None
+                    and (active_artifact / "artifact.json").is_file(),
+                    rendered,
+                )
+            )
+        original_warning(message, *args, **kwargs)
+
+    monkeypatch.setattr(generation_service._LOGGER, "warning", record_warning)
+    for mode in ("off", "diagnostic", "certified-reuse"):
+        artifact = tmp_path / f"{model_source}-{mode}"
+        active_artifact = artifact
+        active_mode = mode
+        Generator(
+            _generation_config(
+                "recurrence",
+                lc_flow_layout="all-flow-union",
+                relation_discovery_mode=mode,
+            )
+        ).generate(
+            _RELATION_REUSE_PROCESS,
+            artifact,
+            model=model,
+        )
+        execution = _single_recurrence_execution(artifact)
+        executions[mode] = execution
+        assert execution["plan"]["inspection_summary"].get("relation_discovery") is None
+        report = _manifest_relation_discovery(artifact)
+        assert isinstance(report, dict)
+        reports[mode] = report
+        lane = report["lanes"]["primary"]
+        assert isinstance(lane, dict)
+        lanes[mode] = lane
+        native = report["native_relation_application"]
+        if mode == "off" or lane["certified_relation_count"] == 0:
+            assert lane["applied_relation_count"] == 0
+            assert native is None
+        else:
+            assert isinstance(native, dict)
+
+        runtime = Runtime.load(artifact)
+        runtimes[mode] = runtime
+        assert runtime.evaluate(points) == pytest.approx(
+            compiled.evaluate(points),
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+        _assert_decimal_values_match(
+            runtime.evaluate(points, precision=50),
+            compiled.evaluate(points, precision=50),
+            50,
+        )
+
+    diagnostic = lanes["diagnostic"]
+    certified = lanes["certified-reuse"]
+    assert diagnostic["state"] == "no_certified_numerical_relation"
+    assert diagnostic["certified_relation_count"] == 0
+    assert diagnostic["applied_relation_count"] == 0
+    assert diagnostic["warning"]["required"] is False
+    assert certified["requested_mode"] == "certified-reuse"
+    assert certified["effective_mode"] == "diagnostic"
+    assert certified["effective_reuse_state"] == "disabled"
+    assert certified["effective_mode_reason"] == (
+        "multi-helicity-all-flow-member-scope-unproven"
+    )
+    assert certified["application_scope"]["effective_mode_reason"] == (
+        "multi-helicity-all-flow-member-scope-unproven"
+    )
+    assert certified["state"] == "no_certified_numerical_relation"
+    assert certified["certified_relation_count"] == 0
+    assert certified["applied_relation_count"] == 0
+    assert certified["warning"]["required"] is False
+    assert warning_counts == {
+        "off": 0,
+        "diagnostic": 0,
+        "certified-reuse": 0,
+    }
+    assert warning_publications == []
+    assert certified["application_validation"]["status"] == (
+        "not-required-no-applied-relations"
+    )
+    for lane in (diagnostic, certified):
+        application_scope = lane["application_scope"]
+        assert application_scope["multi_helicity_all_flow_domain_ids"] == [0]
+        assert application_scope["suppressed_selector_domain_ids"] == [0]
+        assert application_scope["suppressed_current_count"] == 62
+        assert lane["discovery"]["tested_hypothesis_count"] == 0
+        assert lane["discovery"]["numerical_candidate_count"] == 0
+        assert lane["discovery"]["verification_rejected_count"] == 0
+        assert lane["discovery"]["rejected_hypothesis_count"] == 0
+        assert lane["discovery"]["certificates"] == []
+        assert lane["discovery"]["nearest_rejected_hypothesis"] is None
+        assert lane["application"]["certificates"] == []
+        assert lane["application"]["relation_kind_counts"] == {
+            "equal": 0,
+            "opposite": 0,
+            "zero": 0,
+        }
+        assert lane["application"]["certificate_replay"]["status"] == (
+            "no_certified_numerical_relation"
+        )
+    candidate_index = certified["discovery"]["candidate_index"]
+    assert candidate_index == {
+        "algorithm": "complete-contract-anchor-tolerance-window-v1",
+        "completeness": "complete-within-configured-tolerance",
+        "contract_count": 31,
+        "exhaustive_fallback_contract_count": 0,
+        "theoretical_pair_hypothesis_count": 0,
+        "screened_pair_hypothesis_count": 0,
+        "zero_hypothesis_count": 0,
+        "nearest_rejected_scope": ("zero-and-tolerance-window-screened-hypotheses"),
+    }
+    persisted = certified["persisted_numerical_evidence"]
+    assert persisted["raw_evidence_retained"] is False
+    assert persisted["generation_raw_evidence_bytes"] == 0
+    assert persisted["generation_evidence_transport_bytes"] == 0
+    assert persisted["generation_evidence_encoding"] is None
+    assert certified["verification_capture"] is None
+    assert persisted["verification_capture"] is None
+    assert persisted["full_census"] == {
+        "inspected_current_count": 68,
+        "tested_hypothesis_count": 0,
+        "numerical_candidate_count": 0,
+        "verification_rejected_count": 0,
+        "uncertified_candidate_count": 0,
+        "certified_relation_count": 0,
+        "rejected_hypothesis_count": 0,
+        "candidate_index": candidate_index,
+        "decision_sha256": certified["discovery"]["decision_sha256"],
+        "rejection_decision_sha256": certified["discovery"][
+            "rejection_decision_sha256"
+        ],
+        "certificate_set_sha256": certified["application"]["certificate_replay"][
+            "certificate_set_sha256"
+        ],
+    }
+    replay_capture = persisted["candidate_capture"]
+    assert replay_capture["certificate_current_ids"] == []
+    assert replay_capture["observations"] == []
+    assert replay_capture["full_batch_commitment"]["current_count"] == 68
+
+    _assert_runtime_values_match(
+        runtimes["certified-reuse"],
+        runtimes["diagnostic"],
+        points,
+    )
+    _assert_runtime_values_match(runtimes["diagnostic"], runtimes["off"], points)
+    # Binary64 is covered by the helper above.  Reuse must also preserve every
+    # resolved member and its total at the two higher precisions used by the
+    # focused numerical-current diagnosis; these are evaluations of the
+    # already-generated artifacts, not additional generation work.
+    for precision in (32, 200):
+        reference = runtimes["off"].evaluate_resolved(
+            points,
+            precision=precision,
+        )
+        candidate = runtimes["certified-reuse"].evaluate_resolved(
+            points,
+            precision=precision,
+        )
+        assert candidate.helicity_ids == reference.helicity_ids
+        assert candidate.color_ids == reference.color_ids
+        assert candidate.shape == reference.shape
+        _assert_decimal_values_match(candidate.values, reference.values, precision)
+        _assert_decimal_values_match(candidate.total(), reference.total(), precision)
+        _assert_decimal_values_match(
+            runtimes["certified-reuse"].evaluate(points, precision=precision),
+            runtimes["off"].evaluate(points, precision=precision),
+            precision,
+        )
+    off_inspection = executions["off"]["plan"]["inspection_summary"]
+    diagnostic_inspection = executions["diagnostic"]["plan"]["inspection_summary"]
+    assert (
+        executions["off"]["recurrence_summary"]
+        == executions["diagnostic"]["recurrence_summary"]
+    )
+    assert (
+        executions["certified-reuse"]["plan"]["inspection_summary"]["direct_arena"]
+        == off_inspection["direct_arena"]
+    )
+    for key in (
+        "schedule",
+        "construction",
+        "selector_work_certificate",
+        "direct_arena",
+    ):
+        assert off_inspection.get(key) == diagnostic_inspection.get(key)
+
+
+@pytest.mark.parametrize("process_expression", _TOPOLOGY_REPLAY_PROCESSES)
+def test_builtin_lc_recurrence_artifact_loads_and_matches_compiled(
+    tmp_path: Path,
+    process_expression: str,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+) -> None:
+    """Exercise the first public topology-replay artifact end to end."""
+
+    _require_native_recurrence()
+    recurrence_artifact = tmp_path / "recurrence"
+    compiled_artifact = tmp_path / "compiled"
+    progress_events: list[object] = []
+
+    Generator(
+        _generation_config("recurrence"),
+        progress=CallbackProgressSink(progress_events.append),
+    ).generate(
+        process_expression,
+        recurrence_artifact,
+        model=builtin_sm_recurrence_jit_o2_model,
+    )
+    Generator(_generation_config("compiled")).generate(
+        process_expression,
+        compiled_artifact,
+    )
+    _assert_topology_replay_structure(recurrence_artifact, process_expression)
+    native_progress = [
+        event
+        for event in progress_events
+        if isinstance(event, ProgressUpdate) and event.task_id.endswith(":rust-builder")
+    ]
+    assert native_progress
+    assert any(
+        event.details.get("step") == "recurrence stage" for event in native_progress
+    )
+    assert any(
+        int(event.details.get("current_count", 0)) > 0 for event in native_progress
+    )
+
+    manifest = load_manifest(recurrence_artifact)
+    assert len(manifest.processes) == 1
+    process = manifest.processes[0]
+    process_id = str(process["id"])
+    assert set(process["required_runtime_capabilities"]) == _RECURRENCE_CAPABILITIES
+    assert (
+        set(manifest.runtime["required_runtime_capabilities"])
+        == _RECURRENCE_CAPABILITIES
+    )
+    inspection = inspect_artifact(recurrence_artifact).processes[0]
+    assert inspection.execution_mode == "recurrence"
+    assert inspection.prepared_backend == "jit"
+    assert inspection.prepared_kernel_count
+    assert inspection.invocation_count
+    assert inspection.finalization_count
+    assert inspection.closure_count
+    assert inspection.native_profile_phases == (
+        "selector-plan",
+        "source-fill",
+        "momentum-form-fill",
+        "recurrence-direct-contribution",
+        "recurrence-direct-finalization",
+        "recurrence-direct-closure",
+        "reduction",
+    )
+
+    process_root = recurrence_artifact / "processes" / process_id
+    bootstrap_path = process_root / "recurrence-bootstrap.bin"
+    assert bootstrap_path.is_file()
+    bootstrap_relative_path = bootstrap_path.relative_to(recurrence_artifact).as_posix()
+    bootstrap_payload = next(
+        record for record in manifest.payloads if record.path == bootstrap_relative_path
+    )
+    assert bootstrap_payload.role == "evaluator-state"
+    assert bootstrap_payload.process_id == process_id
+    execution_path = process_root / "execution.json"
+    execution = json.loads(execution_path.read_text(encoding="utf-8"))
+    assert execution["kind"] == _RECURRENCE_KIND
+    assert execution["plan"]["kind"] == _RECURRENCE_KIND
+    assert execution["recurrence_summary"]["lc_flow_layout"] == "topology-replay"
+    runtime_schedule = execution["plan"]["runtime_schedule"]
+    assert runtime_schedule["storage_abi"] == "pacbin-v1"
+    assert runtime_schedule["member_count"] >= 1
+    assert execution["plan"]["process_binding"]["path"] == "recurrence-binding.bin"
+    z_masses = {
+        row["outgoing_pdg"]: row["mass"]
+        for row in execution["runtime_metadata"]["particle_masses"]
+    }
+    assert z_masses[23] == pytest.approx(91.188)
+    z_sources = [
+        row
+        for row in execution["runtime_metadata"]["source_templates"]
+        if row["source_ir"]["identity"]["pdg_label"] == 23
+    ]
+    assert z_sources
+    assert {row["source_ir"]["mass_parameter"] for row in z_sources} == {
+        "particle.23.mass"
+    }
+
+    runtime_path = recurrence_artifact / runtime_schedule["path"]
+    assert runtime_path.parent.parent.parent == recurrence_artifact / "recurrence"
+    assert runtime_path.is_file()
+    assert runtime_path.stat().st_size == runtime_schedule["size_bytes"]
+    payloads = {record.path: record for record in manifest.payloads}
+    runtime_payload = payloads[runtime_path.relative_to(recurrence_artifact).as_posix()]
+    assert runtime_payload.size_bytes == runtime_path.stat().st_size
+    assert runtime_payload.sha256 == runtime_schedule["sha256"]
+    binding_path = process_root / execution["plan"]["process_binding"]["path"]
+    assert binding_path.is_file()
+    assert (recurrence_artifact / "evaluators.pacbin").is_file()
+
+    recurrence, compiled, points = _assert_topology_replay_artifacts_match(
+        recurrence_artifact,
+        compiled_artifact,
+        process_expression,
+    )
+    _assert_topology_replay_exact_matches_compiled(
+        recurrence,
+        compiled,
+        points,
+    )
+
+    if process_expression == _PROCESS:
+        _assert_recurrence_per_point_selector_patterns(
+            recurrence_artifact,
+            points[0],
+            expected_layout="topology-replay",
+        )
+
+    # Prepared packs own the model-parameter derivation kernel. Recurrence must
+    # refresh derived parameters after an independent runtime update exactly as
+    # compiled mode does.
+    exact_before_update = recurrence.evaluate(points, precision=50)
+    recurrence.set_model_parameters({"particle.23.mass": 100.0})
+    compiled.set_model_parameters({"particle.23.mass": 100.0})
+    assert recurrence.evaluate(points, precision=50) != exact_before_update
+    assert recurrence.evaluate(points) == pytest.approx(
+        compiled.evaluate(points),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    _assert_topology_replay_exact_matches_compiled(
+        recurrence,
+        compiled,
+        points,
+    )
+
+    # The image's payload inventory excludes process-groups.json, which is
+    # rewritten in place without changing the artifact identity.
+    if process_expression == _PROCESS:
+        group_map = read_process_groups(recurrence_artifact)
+        assert group_map is not None
+        group_map.analyses.append({"variant": "in-place-update"})
+        write_process_groups(recurrence_artifact, group_map)
+        reloaded = Runtime.load(recurrence_artifact)
+        assert reloaded.artifact_id == manifest.artifact_id
+        assert reloaded.evaluate(points, precision=50) == exact_before_update
+
+    # The process-ready image is authenticated before decoding and must never
+    # fall back to the looser JSON path after corruption.
+    if process_expression == _PROCESS:
+        image = bytearray(bootstrap_path.read_bytes())
+        image[len(image) // 2] ^= 1
+        bootstrap_path.write_bytes(image)
+        with pytest.raises(ArtifactError):
+            Runtime.load(recurrence_artifact)
+
+
+@pytest.mark.parametrize(
+    "process_expression",
+    (
+        _FOUR_LEPTON_PROCESS,
+        _DILEPTON_ZH_PROCESS,
+        _NEUTRAL_CURRENT_PROCESS,
+        "d d~ > z g",
+    ),
+)
+def test_builtin_fermion_vector_aliases_match_compiled_at_small_scale(
+    tmp_path: Path,
+    process_expression: str,
+    builtin_sm_current_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    """Reject mirrored EW-current double counting even below 1e-15."""
+
+    _require_native_recurrence()
+    recurrence_artifact = tmp_path / "recurrence"
+    compiled_artifact = tmp_path / "compiled"
+    color_accuracy = "full" if process_expression == _FOUR_LEPTON_PROCESS else "lc"
+    Generator(_generation_config("recurrence", color_accuracy=color_accuracy)).generate(
+        process_expression,
+        recurrence_artifact,
+        model=builtin_sm_current_recurrence_jit_o2_model,
+    )
+    Generator(_generation_config("compiled", color_accuracy=color_accuracy)).generate(
+        process_expression,
+        compiled_artifact,
+    )
+
+    points = _validation_points(process_expression)
+    recurrence = Runtime.load(recurrence_artifact)
+    compiled = Runtime.load(compiled_artifact)
+    recurrence_resolved = recurrence.evaluate_resolved(points, precision=200)
+    compiled_resolved = compiled.evaluate_resolved(points, precision=200)
+
+    assert recurrence_resolved.helicity_ids == compiled_resolved.helicity_ids
+    assert recurrence_resolved.color_ids == compiled_resolved.color_ids
+    assert recurrence_resolved.shape == compiled_resolved.shape
+    _assert_scale_sensitive_values_match(
+        recurrence_resolved.values,
+        compiled_resolved.values,
+    )
+    _assert_scale_sensitive_values_match(
+        recurrence.evaluate(points, precision=200),
+        compiled.evaluate(points, precision=200),
+    )
+    if process_expression == _FOUR_LEPTON_PROCESS:
+        madgraph = (_FOUR_LEPTON_MADGRAPH_SEED_101,)
+        _assert_scale_sensitive_values_match(
+            recurrence.evaluate(points, precision=200),
+            madgraph,
+            relative_tolerance=Decimal("1e-10"),
+        )
+        _assert_scale_sensitive_values_match(
+            compiled.evaluate(points, precision=200),
+            madgraph,
+            relative_tolerance=Decimal("1e-10"),
+        )
+
+
+@pytest.mark.parametrize(
+    ("color_accuracy", "lc_flow_layout", "case_id"),
+    (
+        ("lc", "topology-replay", "case:sm_ddbar_ee:lc"),
+        ("lc", "all-flow-union", "case:sm_ddbar_ee:lc"),
+        ("nlc", "topology-replay", "case:sm_ddbar_ee:nlc"),
+        ("full", "topology-replay", "case:sm_ddbar_ee:full"),
+    ),
+)
+def test_builtin_neutral_current_recurrence_matches_legacy_oracle(
+    tmp_path: Path,
+    color_accuracy: str,
+    lc_flow_layout: str,
+    case_id: str,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+) -> None:
+    """Guard the incoming-spin average and mirrored fermion-pair orientation."""
+
+    _require_native_recurrence()
+    artifact = tmp_path / f"{color_accuracy}-{lc_flow_layout}"
+    Generator(
+        _generation_config(
+            "recurrence",
+            color_accuracy=color_accuracy,
+            lc_flow_layout=lc_flow_layout,
+        )
+    ).generate(
+        _NEUTRAL_CURRENT_PROCESS,
+        artifact,
+        model=builtin_sm_recurrence_jit_o2_model,
+    )
+
+    reference = _reference_case(case_id)
+    observation = reference["observations"][0]
+    reference_point = _reference_point(observation["point_id"])
+    point = (
+        reference_point[0],
+        reference_point[1],
+        reference_point[3],
+        reference_point[2],
+    )
+    runtime = Runtime.load(artifact)
+    runtime.set_model_parameters(
+        {"normalization.alpha_ew": _HISTORICAL_REFERENCE_ALPHA_EW}
+    )
+    resolved = runtime.evaluate_resolved((point,))
+    helicity_values = {
+        helicity.id: helicity.values for helicity in runtime.physics.helicities
+    }
+    actual = {
+        (helicity_values[helicity_id], color_id): complex(
+            resolved.values[0][helicity_index][color_index]
+        )
+        for helicity_index, helicity_id in enumerate(resolved.helicity_ids)
+        for color_index, color_id in enumerate(resolved.color_ids)
+    }
+    expected = {
+        (
+            (
+                helicity["values"][0],
+                helicity["values"][1],
+                helicity["values"][3],
+                helicity["values"][2],
+            ),
+            color["id"],
+        ): float(observation["values"][helicity_index][color_index])
+        for helicity_index, helicity in enumerate(reference["axes"]["helicities"])
+        for color_index, color in enumerate(reference["axes"]["colors"])
+    }
+
+    assert set(actual) == set(expected)
+    assert {key: value.real for key, value in actual.items()} == pytest.approx(
+        expected,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert {key: value.imag for key, value in actual.items()} == pytest.approx(
+        dict.fromkeys(actual, 0.0),
+        abs=1.0e-15,
+    )
+    expected_total = float(observation["total"])
+    assert runtime.evaluate((point,))[0] == pytest.approx(
+        complex(expected_total),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert resolved.total()[0] == pytest.approx(
+        complex(expected_total),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+
+@pytest.mark.parametrize("process_expression", _TOPOLOGY_REPLAY_PROCESSES)
+def test_ufo_sm_lc_recurrence_artifact_loads_and_matches_compiled(
+    tmp_path: Path,
+    process_expression: str,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    """Exercise public topology-replay artifacts with the prepared UFO-SM."""
+
+    recurrence_artifact = tmp_path / "recurrence-ufo-sm"
+    compiled_artifact = tmp_path / "compiled-ufo-sm"
+    Generator(_generation_config("recurrence")).generate(
+        process_expression,
+        recurrence_artifact,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+    Generator(_generation_config("compiled")).generate(
+        process_expression,
+        compiled_artifact,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+    _assert_topology_replay_structure(recurrence_artifact, process_expression)
+    recurrence, compiled, points = _assert_topology_replay_artifacts_match(
+        recurrence_artifact,
+        compiled_artifact,
+        process_expression,
+    )
+    _assert_topology_replay_exact_matches_compiled(
+        recurrence,
+        compiled,
+        points,
+    )
+    exact_before_update = recurrence.evaluate(points, precision=50)
+    recurrence.set_model_parameters({"MZ": 100.0})
+    compiled.set_model_parameters({"MZ": 100.0})
+    assert recurrence.evaluate(points, precision=50) != exact_before_update
+    _assert_topology_replay_exact_matches_compiled(
+        recurrence,
+        compiled,
+        points,
+    )
+
+
+def test_ufo_sm_recurrence_refreshes_real_and_complex_derived_couplings(
+    tmp_path: Path,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    """An aS update must refresh every -G alias as well as the complex i*G²."""
+
+    output = tmp_path / "recurrence-ufo-coupling-update"
+    Generator(_generation_config("recurrence", color_accuracy="full")).generate(
+        _PURE_GLUON_PROCESS,
+        output,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+    runtime = Runtime.load(output)
+    points = _validation_points(_PURE_GLUON_PROCESS)
+    original = runtime.evaluate(points)
+    alpha_s = next(
+        parameter.default_real
+        for parameter in runtime.physics.model_parameters
+        if parameter.name == "aS"
+    )
+    execution_path = next((output / "processes").glob("*/execution.json"))
+    execution = json.loads(execution_path.read_text(encoding="utf-8"))
+    negative_g_slots = [
+        parameter["parameter_index"]
+        for parameter in execution["runtime_metadata"]["runtime_parameters"]
+        if parameter["kind"] == "derived_parameter_component"
+        and parameter["runtime_name"] is None
+        and parameter["default"] == pytest.approx(-math.sqrt(4 * math.pi * alpha_s))
+    ]
+    # The SM contains distinct derived coupling names for the same real -G.
+    assert len(negative_g_slots) >= 2
+    changed_alpha_s = 0.125
+    expected = tuple(value * (changed_alpha_s / alpha_s) ** 2 for value in original)
+    loaded_override = Runtime.load(output, model_parameters={"aS": changed_alpha_s})
+    runtime.set_model_parameter("aS", changed_alpha_s)
+    for changed_runtime in (runtime, loaded_override):
+        state = json.loads(
+            changed_runtime._backend._runtime._exact_runtime_state_json()
+        )
+        for index in negative_g_slots:
+            assert state["model_parameter_values"][index] == pytest.approx(
+                -math.sqrt(4 * math.pi * changed_alpha_s), rel=2e-14
+            )
+        assert changed_runtime.evaluate(points) == pytest.approx(expected, rel=3e-13)
+        assert tuple(
+            float(value) for value in changed_runtime.evaluate(points, precision=50)
+        ) == pytest.approx(tuple(value.real for value in expected), rel=3e-13)
+    runtime.set_model_parameter("aS", alpha_s)
+    assert runtime.evaluate(points) == pytest.approx(original, rel=3e-13)
+
+
+@pytest.mark.parametrize("process_expression", _CONTRACTED_COLOR_PROCESSES)
+@pytest.mark.parametrize("color_accuracy", ("nlc", "full"))
+def test_builtin_contracted_color_recurrence_matches_compiled(
+    tmp_path: Path,
+    color_accuracy: str,
+    process_expression: str,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+) -> None:
+    """Exercise built-in NLC/full generation and Direct-Arena contraction."""
+
+    _require_native_recurrence()
+    recurrence_artifact = tmp_path / f"recurrence-{color_accuracy}"
+    compiled_artifact = tmp_path / f"compiled-{color_accuracy}"
+    Generator(
+        _generation_config(
+            "recurrence",
+            color_accuracy=color_accuracy,
+        )
+    ).generate(
+        process_expression,
+        recurrence_artifact,
+        model=builtin_sm_recurrence_jit_o2_model,
+    )
+    Generator(
+        _generation_config(
+            "compiled",
+            color_accuracy=color_accuracy,
+        )
+    ).generate(
+        process_expression,
+        compiled_artifact,
+        model=builtin_sm_recurrence_jit_o2_model,
+    )
+    _assert_contracted_color_artifacts_match(
+        recurrence_artifact,
+        compiled_artifact,
+        process_expression,
+        color_accuracy,
+        parameter_update=(
+            ("particle.23.mass", 100.0) if process_expression == _PROCESS else None
+        ),
+    )
+
+
+@pytest.mark.parametrize("process_expression", _CONTRACTED_COLOR_PROCESSES)
+@pytest.mark.parametrize("color_accuracy", ("nlc", "full"))
+def test_ufo_sm_contracted_color_recurrence_matches_compiled(
+    tmp_path: Path,
+    color_accuracy: str,
+    process_expression: str,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    """Exercise model-generic NLC/full recurrence with the UFO-SM pack."""
+
+    recurrence_artifact = tmp_path / f"recurrence-ufo-{color_accuracy}"
+    compiled_artifact = tmp_path / f"compiled-ufo-{color_accuracy}"
+    Generator(
+        _generation_config(
+            "recurrence",
+            color_accuracy=color_accuracy,
+        )
+    ).generate(
+        process_expression,
+        recurrence_artifact,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+    Generator(
+        _generation_config(
+            "compiled",
+            color_accuracy=color_accuracy,
+        )
+    ).generate(
+        process_expression,
+        compiled_artifact,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+    _assert_contracted_color_artifacts_match(
+        recurrence_artifact,
+        compiled_artifact,
+        process_expression,
+        color_accuracy,
+        parameter_update=(("MZ", 100.0) if process_expression == _PROCESS else None),
+    )
+
+
+def test_builtin_and_ufo_contracted_recurrence_have_matching_structure(
+    tmp_path: Path,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    """Equivalent SM models must construct the same generic color schedule."""
+
+    artifacts = []
+    for label, model in (
+        ("builtin", builtin_sm_recurrence_jit_o2_model),
+        ("ufo", ufo_sm_recurrence_jit_o2_model),
+    ):
+        artifact = tmp_path / label
+        Generator(
+            _generation_config(
+                "recurrence",
+                color_accuracy="full",
+            )
+        ).generate(
+            _THREE_LINE_PROCESS,
+            artifact,
+            model=model,
+        )
+        artifacts.append(artifact)
+
+    builtin_signature = _contracted_structure_signature(artifacts[0])
+    ufo_signature = _contracted_structure_signature(artifacts[1])
+    assert (
+        builtin_signature["peak_contribution_count_semantics"]
+        == "resident-pending-contributions-v1"
+    )
+    assert builtin_signature == ufo_signature
+
+
+def test_builtin_full_n5_pure_gluon_recurrence_fits_static_template_budget(
+    tmp_path: Path,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+) -> None:
+    """Keep generated N5 pure-gluon preprojection within AmpliCol's budget."""
+
+    _require_native_recurrence()
+    artifact = tmp_path / "builtin-full-n5-pure-gluon"
+    Generator(
+        _generation_config(
+            "recurrence",
+            color_accuracy="full",
+        )
+    ).generate(
+        _N5_PURE_GLUON_PROCESS,
+        artifact,
+        model=builtin_sm_recurrence_jit_o2_model,
+    )
+
+    manifest = load_manifest(artifact)
+    assert len(manifest.processes) == 1
+    process_id = str(manifest.processes[0]["id"])
+    execution = json.loads(
+        (artifact / "processes" / process_id / "execution.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    assert execution["kind"] == _RECURRENCE_KIND
+    summary = execution["recurrence_summary"]
+    inspection = execution["plan"]["inspection_summary"]
+    schedule = inspection["schedule"]
+    construction = inspection["construction"]
+    assert summary["lc_flow_layout"] == "contracted-color-union"
+    assert (
+        (
+            summary["current_count"],
+            summary["contribution_count"],
+        )
+        == (
+            schedule["current_count"],
+            schedule["contribution_count"],
+        )
+        == (1_795, 9_990)
+    )
+    assert (
+        construction["peak_current_count"],
+        construction["peak_contribution_count"],
+    ) == (2_430, 11_597)
+    assert (
+        construction["peak_contribution_count_semantics"]
+        == "resident-pending-contributions-v1"
+    )
+
+    # Integral ceilings for 1.05x the authenticated AmpliCol static modules.
+    assert construction["peak_current_count"] <= 2_557
+    assert construction["peak_contribution_count"] <= 15_372
+    certificate = inspection["selector_work_certificate"]
+    assert (
+        sum(
+            representative["public_flow_count"]
+            for representative in certificate["representatives"]
+        )
+        == schedule["replay_target_count"]
+        == 720
+    )
+    assert Runtime.load(artifact).physics.color_accuracy == "full"
+
+
+def test_builtin_and_ufo_full_neutral_current_defaults_agree(
+    tmp_path: Path,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    """Keep the two SM frontends on one exact electroweak normalization."""
+
+    process = "d d~ > z"
+    points = _validation_points(process)
+    runtimes = []
+    for label, model in (
+        ("builtin", builtin_sm_recurrence_jit_o2_model),
+        ("ufo", ufo_sm_recurrence_jit_o2_model),
+    ):
+        artifact = tmp_path / label
+        Generator(
+            _generation_config(
+                "recurrence",
+                color_accuracy="full",
+            )
+        ).generate(process, artifact, model=model)
+        runtimes.append(Runtime.load(artifact))
+
+    builtin_total = runtimes[0].evaluate(points)
+    ufo_total = runtimes[1].evaluate(points)
+    assert builtin_total == pytest.approx(ufo_total, rel=1.0e-12, abs=1.0e-15)
+    for runtime, total in zip(runtimes, (builtin_total, ufo_total), strict=True):
+        assert runtime.evaluate_resolved(points).total() == pytest.approx(
+            total,
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+
+
+@pytest.mark.parametrize(
+    ("process_expression", "required_color_id"),
+    (
+        (_PROCESS, None),
+        (_CHARGED_CURRENT_PROCESS, None),
+        (_TWO_QUARK_LINE_PROCESS, "flow:2,4,3,1"),
+    ),
+)
+def test_builtin_lc_all_flow_union_recurrence_matches_compiled(
+    tmp_path: Path,
+    process_expression: str,
+    required_color_id: str | None,
+    builtin_sm_recurrence_jit_o2_model: ModelSource,
+) -> None:
+    """Exercise all-flow union report canaries through numerical execution."""
+
+    _require_native_recurrence()
+    recurrence_artifact = tmp_path / "recurrence-union"
+    compiled_artifact = tmp_path / "compiled-union"
+    Generator(
+        _generation_config(
+            "recurrence",
+            lc_flow_layout="all-flow-union",
+        )
+    ).generate(
+        process_expression,
+        recurrence_artifact,
+        model=builtin_sm_recurrence_jit_o2_model,
+    )
+    Generator(
+        _generation_config(
+            "compiled",
+            lc_flow_layout="all-flow-union",
+        )
+    ).generate(
+        process_expression,
+        compiled_artifact,
+    )
+    _assert_all_flow_union_artifacts_match(
+        recurrence_artifact,
+        compiled_artifact,
+        process_expression,
+        parameter_update=(
+            ("particle.23.mass", 100.0) if process_expression == _PROCESS else None
+        ),
+        required_color_id=required_color_id,
+    )
+    if process_expression == _PROCESS:
+        _assert_recurrence_per_point_selector_patterns(
+            recurrence_artifact,
+            _validation_points(_PROCESS)[0],
+            expected_layout="all-flow-union",
+        )
+
+
+def test_ufo_sm_lc_all_flow_union_recurrence_matches_compiled(
+    tmp_path: Path,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    """Exercise the model-generic union lane with the prepared UFO-SM."""
+
+    recurrence_artifact = tmp_path / "recurrence-ufo-union"
+    compiled_artifact = tmp_path / "compiled-ufo-union"
+    Generator(
+        _generation_config(
+            "recurrence",
+            lc_flow_layout="all-flow-union",
+        )
+    ).generate(
+        _PROCESS,
+        recurrence_artifact,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+    Generator(
+        _generation_config(
+            "compiled",
+            lc_flow_layout="all-flow-union",
+        )
+    ).generate(
+        _PROCESS,
+        compiled_artifact,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+    _assert_all_flow_union_artifacts_match(
+        recurrence_artifact,
+        compiled_artifact,
+        _PROCESS,
+        parameter_update=("MZ", 100.0),
+    )
+
+
+def test_ufo_sm_full_neutral_current_recurrence_executes_prepared_mass_slot(
+    tmp_path: Path,
+    ufo_sm_recurrence_jit_o2_model: CompiledModel,
+) -> None:
+    """Exercise the report's UFO full-colour source-only ``Me`` slot."""
+
+    recurrence_artifact = tmp_path / "recurrence-ufo-full-neutral-current"
+    compiled_artifact = tmp_path / "compiled-ufo-full-neutral-current"
+    Generator(
+        _generation_config(
+            "recurrence",
+            color_accuracy="full",
+        )
+    ).generate(
+        _NEUTRAL_CURRENT_PROCESS,
+        recurrence_artifact,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+    Generator(
+        _generation_config(
+            "compiled",
+            color_accuracy="full",
+        )
+    ).generate(
+        _NEUTRAL_CURRENT_PROCESS,
+        compiled_artifact,
+        model=ufo_sm_recurrence_jit_o2_model,
+    )
+    runtimes = (
+        Runtime.load(recurrence_artifact),
+        Runtime.load(compiled_artifact),
+    )
+    for runtime in runtimes:
+        electron_mass = next(
+            parameter
+            for parameter in runtime.physics.model_parameters
+            if parameter.name == "Me"
+        )
+        assert electron_mass.kind == "derived"
+        assert electron_mass.mutable is False
+        assert electron_mass.default_real == 0.0
+        assert electron_mass.default_imaginary == 0.0
+
+    execution_path = next((recurrence_artifact / "processes").glob("*/execution.json"))
+    execution = json.loads(execution_path.read_text(encoding="utf-8"))
+    electron_mass_projection = next(
+        row
+        for row in execution["runtime_metadata"]["parameter_projection"]
+        if row["runtime_name"] == "Me"
+    )
+    prepared_parameter_id = electron_mass_projection["prepared_parameter_id"]
+    assert prepared_parameter_id is not None
+    assert execution["runtime_metadata"]["prepared_parameter_defaults"][
+        prepared_parameter_id
+    ] == [0.0, 0.0]
+
+    _assert_contracted_color_artifacts_match(
+        recurrence_artifact,
+        compiled_artifact,
+        _NEUTRAL_CURRENT_PROCESS,
+        "full",
+        parameter_update=("aEWM1", 128.0),
+    )
+
+
+def _assert_all_flow_union_artifacts_match(
+    recurrence_artifact: Path,
+    compiled_artifact: Path,
+    process_expression: str,
+    *,
+    parameter_update: tuple[str, float] | None = None,
+    required_color_id: str | None = None,
+) -> None:
+    point = tuple(
+        tuple(float(component) for component in particle.momentum)
+        for particle in generic_validation_point(process_expression)
+    )
+    points = (point,)
+    recurrence = Runtime.load(recurrence_artifact)
+    compiled = Runtime.load(compiled_artifact)
+    assert recurrence.physics.color_ids == compiled.physics.color_ids
+    assert recurrence.physics.helicity_ids == compiled.physics.helicity_ids
+
+    recurrence_resolved = recurrence.evaluate_resolved(points)
+    compiled_resolved = compiled.evaluate_resolved(points)
+    assert recurrence_resolved.total() == pytest.approx(
+        recurrence.evaluate(points),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert compiled_resolved.total() == pytest.approx(
+        compiled.evaluate(points),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert recurrence_resolved.shape == compiled_resolved.shape
+    assert _flatten(recurrence_resolved.values) == pytest.approx(
+        _flatten(compiled_resolved.values),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert recurrence.evaluate(points) == pytest.approx(
+        compiled.evaluate(points),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+    helicity_ids = tuple(
+        helicity.id
+        for helicity in recurrence.physics.helicities
+        if not helicity.structural_zero
+    )
+    assert helicity_ids
+    selected_ids = tuple(
+        dict.fromkeys(
+            (
+                helicity_ids[0],
+                helicity_ids[len(helicity_ids) // 2],
+                helicity_ids[-1],
+                *(("h:-1,+1,-1,+1,-1",) if process_expression == _PROCESS else ()),
+            )
+        )
+    )
+    assert set(selected_ids) <= set(helicity_ids)
+    for helicity_id in selected_ids:
+        recurrence_resolved = recurrence.evaluate_resolved(
+            points,
+            helicities=(helicity_id,),
+        )
+        compiled_resolved = compiled.evaluate_resolved(
+            points,
+            helicities=(helicity_id,),
+        )
+        assert recurrence_resolved.shape == compiled_resolved.shape
+        assert _flatten(recurrence_resolved.values) == pytest.approx(
+            _flatten(compiled_resolved.values),
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+        assert recurrence.evaluate(
+            points,
+            helicities=(helicity_id,),
+        ) == pytest.approx(
+            compiled.evaluate(points, helicities=(helicity_id,)),
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+        recurrence_exact = recurrence.evaluate_resolved(
+            points,
+            helicities=(helicity_id,),
+            precision=32,
+        )
+        compiled_exact = compiled.evaluate_resolved(
+            points,
+            helicities=(helicity_id,),
+            precision=32,
+        )
+        assert recurrence_exact.color_ids == compiled_exact.color_ids
+        assert recurrence_exact.helicity_ids == compiled_exact.helicity_ids
+        _assert_decimal_values_match(
+            recurrence_exact.values,
+            compiled_exact.values,
+            32,
+        )
+        _assert_decimal_values_match(
+            recurrence_exact.total(),
+            recurrence.evaluate(
+                points,
+                helicities=(helicity_id,),
+                precision=32,
+            ),
+            32,
+        )
+    if required_color_id is not None:
+        assert required_color_id in recurrence.physics.color_ids
+        assert recurrence.evaluate(
+            points,
+            color_flows=(required_color_id,),
+        ) == pytest.approx(
+            compiled.evaluate(
+                points,
+                color_flows=(required_color_id,),
+            ),
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+        recurrence_selected = recurrence.evaluate_resolved(
+            points,
+            color_flows=(required_color_id,),
+        )
+        compiled_selected = compiled.evaluate_resolved(
+            points,
+            color_flows=(required_color_id,),
+        )
+        assert _flatten(recurrence_selected.values) == pytest.approx(
+            _flatten(compiled_selected.values),
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
+    if parameter_update is not None:
+        parameter_name, parameter_value = parameter_update
+        before = recurrence.evaluate(points, precision=50)
+        recurrence.set_model_parameters({parameter_name: parameter_value})
+        compiled.set_model_parameters({parameter_name: parameter_value})
+        assert recurrence.evaluate(points, precision=50) != before
+        for helicity_id in selected_ids:
+            assert recurrence.evaluate(
+                points,
+                helicities=(helicity_id,),
+            ) == pytest.approx(
+                compiled.evaluate(points, helicities=(helicity_id,)),
+                rel=1.0e-12,
+                abs=1.0e-15,
+            )
+
+
+def test_recurrence_exact_accepts_all_flow_union_layout() -> None:
+    """Accept both complete LC recurrence strategies."""
+
+    _validate_execution(
+        {
+            "schema_version": 3,
+            "kind": _RECURRENCE_KIND,
+            "key": "d_dbar_to_z_g_g",
+            "recurrence_plan_abi": "pyamplicol-recurrence-plan-v2",
+            "runtime_layout_abi": "pyamplicol-recurrence-runtime-layout-v2",
+            "recurrence_summary": {"lc_flow_layout": "all-flow-union"},
+            "required_runtime_capabilities": sorted(_RECURRENCE_CAPABILITIES),
+        },
+        "d_dbar_to_z_g_g",
+    )
diff --git a/pyamplicol/tests/integration/test_recurrence_prepared_execution.py b/pyamplicol/tests/integration/test_recurrence_prepared_execution.py
new file mode 100644
index 0000000000..31f22db3f1
--- /dev/null
+++ b/pyamplicol/tests/integration/test_recurrence_prepared_execution.py
@@ -0,0 +1,588 @@
+# SPDX-License-Identifier: 0BSD
+"""Prepared-model oracles through public Direct-Arena recurrence artifacts."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from pyamplicol import CompiledModel, Generator, ModelSource, Runtime
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    Action,
+    ColorAccuracy,
+    ColorConfig,
+    ColorContraction,
+    EvaluatorConfig,
+    EvaluatorExecutionMode,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    LCFlowLayout,
+    RunConfig,
+)
+from pyamplicol.generation.phase_space import massive_rambo_final_state
+
+_ZG_EXPRESSION = "d d~ > z g"
+_ZGG_EXPRESSION = "d d~ > z g g"
+_GG_EXPRESSION = "g g > g g"
+_SAME_FLAVOUR_EXPRESSION = "d d~ > d d~"
+_THREE_LINE_EXPRESSION = "d d~ > u u~ s s~"
+_CROSSING_HELICITY_ID = "h:-1,+1,-1,-1"
+_CROSSING_FLOW_ID = "flow:2,4,1"
+_RECURRENCE_KIND = "pyamplicol-runtime-recurrence-execution"
+_RECURRENCE_PLAN_ABI = "pyamplicol-recurrence-plan-v2"
+_RECURRENCE_RUNTIME_LAYOUT_ABI = "pyamplicol-recurrence-runtime-layout-v2"
+_RECURRENCE_CAPABILITIES = {
+    "rusticol.recurrence-color.lc.v1",
+    "rusticol.recurrence-direct-arena.complex-f64.v1",
+}
+# The immutable physics-v2 oracle was captured with the former rounded default.
+_HISTORICAL_REFERENCE_ALPHA_EW = 0.007546771114
+_THREE_LINE_HELICITY_SUM_BY_FLOW = {
+    "flow:2,1,3,4,5,6": 1.7260373034739047e-11,
+    "flow:2,1,3,6,5,4": 1.6570372188601389e-11,
+    "flow:2,4,3,1,5,6": 1.0167883928661888e-10,
+    "flow:2,4,3,6,5,1": 1.6445040193096446e-10,
+    "flow:2,6,3,1,5,4": 6.5052811045824496e-10,
+    "flow:2,6,3,4,5,1": 1.2411150983558527e-10,
+}
+_THREE_LINE_HELICITY_SUM_TOTAL = 1.0745996067347547e-9
+_UFO_SM_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+_REFERENCE_PAYLOAD = json.loads(
+    (
+        Path(__file__).resolve().parents[1]
+        / "fixtures"
+        / "reference"
+        / "physics-v2.json"
+    ).read_text(encoding="utf-8")
+)
+
+_Point = tuple[tuple[float, ...], ...]
+
+
+def _unavailable(reason: str) -> None:
+    if os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1":
+        pytest.fail(reason)
+    pytest.skip(reason)
+
+
+def _require_native_direct_arena() -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    if importlib.util.find_spec("symbolica") is None:
+        _unavailable("Symbolica is unavailable")
+    rusticol = importlib.import_module("pyamplicol._rusticol")
+    if not hasattr(rusticol, "_lower_recurrence_direct_v2"):
+        _unavailable("the installed Rusticol extension lacks Direct-Arena v2")
+
+
+def _generation_config(
+    *,
+    lc_flow_layout: LCFlowLayout = LCFlowLayout.TOPOLOGY_REPLAY,
+    color_accuracy: ColorAccuracy = ColorAccuracy.LC,
+    color_contraction: ColorContraction = ColorContraction.DIRECT,
+) -> RunConfig:
+    return RunConfig(
+        action=Action.GENERATE,
+        color=ColorConfig(
+            accuracy=color_accuracy,
+            contraction=color_contraction,
+            # These structural oracles exercise trace-word reflection/replay.
+            fft_basis="trace",
+            lc_flow_layout=lc_flow_layout,
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=EvaluatorExecutionMode.RECURRENCE,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+@pytest.fixture(scope="module")
+def ufo_sm_recurrence_jit_o2_model(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> CompiledModel:
+    """Prepare one model-generic UFO-SM pack for all Direct-Arena oracles."""
+
+    _require_native_direct_arena()
+    root = tmp_path_factory.mktemp("prepared-execution-ufo-sm")
+    model = ModelSource.from_path(
+        _UFO_SM_ROOT / "sm.json",
+        restriction=_UFO_SM_ROOT / "restrict_default.json",
+    ).compile(
+        cache_dir=root / "model-cache",
+        use_cache=True,
+        prepared_output=root / "ufo-sm-jit-o2.pyamplicol-model",
+        evaluator=_generation_config().evaluator,
+    )
+    assert model.is_prepared
+    assert model.prepared_backend == "jit"
+    return model
+
+
+def _assert_direct_arena_v2_artifact(
+    artifact: Path,
+    *,
+    expected_layout: LCFlowLayout,
+) -> None:
+    execution_files = tuple((artifact / "processes").glob("*/execution.json"))
+    assert len(execution_files) == 1
+    execution = json.loads(execution_files[0].read_text(encoding="utf-8"))
+    assert execution["kind"] == _RECURRENCE_KIND
+    assert execution["recurrence_plan_abi"] == _RECURRENCE_PLAN_ABI
+    assert execution["runtime_layout_abi"] == _RECURRENCE_RUNTIME_LAYOUT_ABI
+    assert set(execution["required_runtime_capabilities"]) == (_RECURRENCE_CAPABILITIES)
+    assert execution["plan"]["recurrence_plan_abi"] == _RECURRENCE_PLAN_ABI
+    assert execution["plan"]["runtime_layout_abi"] == (_RECURRENCE_RUNTIME_LAYOUT_ABI)
+    schedule = execution["plan"]["runtime_schedule"]
+    assert schedule["path"].startswith("recurrence/schedules/")
+    assert schedule["path"].endswith("/recurrence-runtime.pacbin")
+    assert execution["plan"]["process_binding"]["path"] == "recurrence-binding.bin"
+    assert execution["recurrence_summary"]["lc_flow_layout"] == expected_layout.value
+
+
+def _generate_direct_arena_runtime(
+    *,
+    tmp_path: Path,
+    model_source: str,
+    expression: str,
+    ufo_model: CompiledModel | None,
+    lc_flow_layout: LCFlowLayout = LCFlowLayout.TOPOLOGY_REPLAY,
+) -> Runtime:
+    _require_native_direct_arena()
+    slug = expression.replace("~", "bar").replace(">", "to").replace(" ", "_")
+    artifact = tmp_path / f"{model_source}-{slug}-{lc_flow_layout.value}-direct-v2"
+    generator = Generator(_generation_config(lc_flow_layout=lc_flow_layout))
+    if model_source == "built-in":
+        with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+            generator.generate(
+                expression,
+                artifact,
+                model=ModelSource.from_path(prepared_model),
+            )
+    else:
+        assert ufo_model is not None
+        generator.generate(expression, artifact, model=ufo_model)
+    _assert_direct_arena_v2_artifact(
+        artifact,
+        expected_layout=lc_flow_layout,
+    )
+    runtime = Runtime.load(artifact)
+    if model_source == "built-in":
+        runtime.set_model_parameters(
+            {"normalization.alpha_ew": _HISTORICAL_REFERENCE_ALPHA_EW}
+        )
+    return runtime
+
+
+def _reference_case(case_id: str) -> dict[str, Any]:
+    return next(case for case in _REFERENCE_PAYLOAD["cases"] if case["id"] == case_id)
+
+
+def _ufo_model_for(
+    model_source: str,
+    request: pytest.FixtureRequest,
+) -> CompiledModel | None:
+    if model_source == "built-in":
+        return None
+    model = request.getfixturevalue("ufo_sm_recurrence_jit_o2_model")
+    assert isinstance(model, CompiledModel)
+    return model
+
+
+def _reference_point(point_id: str) -> _Point:
+    point = next(
+        item for item in _REFERENCE_PAYLOAD["points"] if item["id"] == point_id
+    )
+    return tuple(
+        tuple(float(component) for component in row) for row in point["momenta"]
+    )
+
+
+def _tracked_lc_reference(
+    case_id: str,
+) -> tuple[_Point, dict[str, float], float]:
+    case = _reference_case(case_id)
+    observation = case["observations"][0]
+    point = _reference_point(observation["point_id"])
+    color_ids = tuple(item["id"] for item in case["axes"]["colors"])
+    expected_by_flow = {
+        color_id: sum(float(row[color_index]) for row in observation["values"])
+        for color_index, color_id in enumerate(color_ids)
+    }
+    return point, expected_by_flow, float(observation["total"])
+
+
+def _helicity_sum_by_flow(
+    runtime: Runtime,
+    point: _Point,
+    *,
+    precision: int = 16,
+) -> dict[str, float]:
+    resolved = runtime.evaluate_resolved((point,), precision=precision)
+    return {
+        color_id: sum(
+            complex(resolved.values[0][helicity_index][color_index]).real
+            for helicity_index in range(len(resolved.helicity_ids))
+        )
+        for color_index, color_id in enumerate(resolved.color_ids)
+    }
+
+
+def _assert_flow_oracle(
+    runtime: Runtime,
+    point: _Point,
+    expected_by_flow: dict[str, float],
+    expected_total: float,
+    *,
+    relative_tolerance: float,
+    precision: int = 16,
+) -> None:
+    actual_by_flow = _helicity_sum_by_flow(runtime, point, precision=precision)
+    assert set(actual_by_flow) == set(expected_by_flow)
+    assert actual_by_flow == pytest.approx(
+        expected_by_flow,
+        rel=relative_tolerance,
+        abs=1.0e-15,
+    )
+    assert sum(actual_by_flow.values()) == pytest.approx(
+        expected_total,
+        rel=relative_tolerance,
+        abs=1.0e-15,
+    )
+    exact_total = complex(runtime.evaluate((point,), precision=precision)[0]).real
+    assert exact_total == pytest.approx(
+        expected_total,
+        rel=relative_tolerance,
+        abs=1.0e-15,
+    )
+
+    for flow_id, expected in expected_by_flow.items():
+        selected = runtime.evaluate_resolved(
+            (point,),
+            color_flows=(flow_id,),
+            precision=precision,
+        )
+        assert selected.color_ids == (flow_id,)
+        assert complex(selected.total()[0]).real == pytest.approx(
+            expected,
+            rel=relative_tolerance,
+            abs=1.0e-15,
+        )
+        assert complex(
+            runtime.evaluate(
+                (point,),
+                color_flows=(flow_id,),
+                precision=precision,
+            )[0]
+        ).real == pytest.approx(
+            expected,
+            rel=relative_tolerance,
+            abs=1.0e-15,
+        )
+
+
+def _assert_exact_components_match_native(
+    runtime: Runtime,
+    point: _Point,
+) -> None:
+    native = runtime.evaluate_resolved((point,))
+    exact = runtime.evaluate_resolved((point,), precision=32)
+    assert exact.helicity_ids == native.helicity_ids
+    assert exact.color_ids == native.color_ids
+    assert exact.shape == native.shape
+    for native_helicities, exact_helicities in zip(
+        native.values,
+        exact.values,
+        strict=True,
+    ):
+        for native_colors, exact_colors in zip(
+            native_helicities,
+            exact_helicities,
+            strict=True,
+        ):
+            assert tuple(complex(value) for value in exact_colors) == pytest.approx(
+                tuple(complex(value) for value in native_colors),
+                rel=1.0e-12,
+                abs=1.0e-15,
+            )
+    assert tuple(complex(value) for value in exact.total()) == pytest.approx(
+        tuple(complex(value) for value in native.total()),
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+
+@pytest.mark.parametrize("model_source", ["built-in", "ufo-sm"])
+def test_direct_arena_crossing_matches_tracked_component_oracle(
+    tmp_path: Path,
+    model_source: str,
+    request: pytest.FixtureRequest,
+) -> None:
+    """Lock initial-state crossing through a public resolved component."""
+
+    runtime = _generate_direct_arena_runtime(
+        tmp_path=tmp_path,
+        model_source=model_source,
+        expression=_ZG_EXPRESSION,
+        ufo_model=_ufo_model_for(model_source, request),
+    )
+    case = _reference_case("case:sm_ddbar_zg:lc")
+    observation = case["observations"][0]
+    point = _reference_point(observation["point_id"])
+    helicity_ids = tuple(item["id"] for item in case["axes"]["helicities"])
+    color_ids = tuple(item["id"] for item in case["axes"]["colors"])
+    helicity_index = helicity_ids.index(_CROSSING_HELICITY_ID)
+    color_index = color_ids.index(_CROSSING_FLOW_ID)
+    expected = float(observation["values"][helicity_index][color_index])
+    relative_tolerance = 5.0e-12 if model_source == "ufo-sm" else 1.0e-12
+
+    complete = runtime.evaluate_resolved((point,))
+    assert complete.helicity_ids == helicity_ids
+    assert complete.color_ids == color_ids
+    assert complex(
+        complete.values[0][helicity_index][color_index]
+    ).real == pytest.approx(
+        expected,
+        rel=relative_tolerance,
+        abs=1.0e-15,
+    )
+
+    selected = runtime.evaluate_resolved(
+        (point,),
+        helicities=(_CROSSING_HELICITY_ID,),
+        color_flows=(_CROSSING_FLOW_ID,),
+    )
+    assert selected.helicity_ids == (_CROSSING_HELICITY_ID,)
+    assert selected.color_ids == (_CROSSING_FLOW_ID,)
+    assert complex(selected.values[0][0][0]).real == pytest.approx(
+        expected,
+        rel=relative_tolerance,
+        abs=1.0e-15,
+    )
+    assert complex(
+        runtime.evaluate(
+            (point,),
+            helicities=(_CROSSING_HELICITY_ID,),
+            color_flows=(_CROSSING_FLOW_ID,),
+        )[0]
+    ).real == pytest.approx(
+        expected,
+        rel=relative_tolerance,
+        abs=1.0e-15,
+    )
+
+
+@pytest.mark.parametrize("model_source", ["built-in", "ufo-sm"])
+def test_direct_arena_two_flow_replay_matches_tracked_lc_oracle(
+    tmp_path: Path,
+    model_source: str,
+    request: pytest.FixtureRequest,
+) -> None:
+    """Replay and select both physical Zgg flows from one public artifact."""
+
+    runtime = _generate_direct_arena_runtime(
+        tmp_path=tmp_path,
+        model_source=model_source,
+        expression=_ZGG_EXPRESSION,
+        ufo_model=_ufo_model_for(model_source, request),
+    )
+    point, expected_by_flow, expected_total = _tracked_lc_reference(
+        "case:sm_ddbar_zgg:lc"
+    )
+    _assert_flow_oracle(
+        runtime,
+        point,
+        expected_by_flow,
+        expected_total,
+        relative_tolerance=5.0e-12 if model_source == "ufo-sm" else 1.0e-12,
+    )
+    _assert_flow_oracle(
+        runtime,
+        point,
+        expected_by_flow,
+        expected_total,
+        relative_tolerance=5.0e-12 if model_source == "ufo-sm" else 1.0e-12,
+        precision=32,
+    )
+
+
+@pytest.mark.parametrize("model_source", ["built-in", "ufo-sm"])
+def test_direct_arena_multiline_replay_matches_tracked_lc_oracles(
+    tmp_path: Path,
+    model_source: str,
+    request: pytest.FixtureRequest,
+) -> None:
+    """Cover distinct-flavour and same-flavour closure reconstruction."""
+
+    for expression, case_id in (
+        ("d d~ > u u~", "case:sm_ddbar_uubar:lc"),
+        ("d d~ > d d~", "case:sm_ddbar_ddbar:lc"),
+    ):
+        runtime = _generate_direct_arena_runtime(
+            tmp_path=tmp_path,
+            model_source=model_source,
+            expression=expression,
+            ufo_model=_ufo_model_for(model_source, request),
+        )
+        point, expected_by_flow, expected_total = _tracked_lc_reference(case_id)
+        _assert_flow_oracle(
+            runtime,
+            point,
+            expected_by_flow,
+            expected_total,
+            relative_tolerance=(5.0e-12 if model_source == "ufo-sm" else 1.0e-12),
+        )
+
+
+@pytest.mark.parametrize("model_source", ["built-in", "ufo-sm"])
+def test_direct_arena_pure_gluon_replay_matches_reflection_oracle(
+    tmp_path: Path,
+    model_source: str,
+    request: pytest.FixtureRequest,
+) -> None:
+    """Lock reciprocal pure-gluon flow handling against tracked LC components."""
+
+    runtime = _generate_direct_arena_runtime(
+        tmp_path=tmp_path,
+        model_source=model_source,
+        expression=_GG_EXPRESSION,
+        ufo_model=_ufo_model_for(model_source, request),
+    )
+    point, expected_by_flow, expected_total = _tracked_lc_reference("case:sm_gg_gg:lc")
+    _assert_flow_oracle(
+        runtime,
+        point,
+        expected_by_flow,
+        expected_total,
+        relative_tolerance=5.0e-12 if model_source == "ufo-sm" else 1.0e-12,
+    )
+
+
+def test_symmetric_group_complete_gluon_replay_lowers_all_materialized_sectors(
+    tmp_path: Path,
+) -> None:
+    """Lower the complete-helicity FullColour replay that exercises reflection."""
+
+    _require_native_direct_arena()
+    artifact = tmp_path / "symmetric-group-complete-gluon-replay"
+    config = _generation_config(
+        color_accuracy=ColorAccuracy.FULL,
+        color_contraction=ColorContraction.SYMMETRIC_GROUP_FFT,
+    )
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+        Generator(config).generate(
+            _GG_EXPRESSION,
+            artifact,
+            model=ModelSource.from_path(prepared_model),
+        )
+
+    execution_path = next((artifact / "processes").glob("*/execution.json"))
+    execution = json.loads(execution_path.read_text(encoding="utf-8"))
+    summary = execution["recurrence_summary"]
+    schedule = execution["plan"]["inspection_summary"]["schedule"]
+    assert summary["lc_flow_layout"] == "contracted-color-union"
+    assert schedule["replay_target_count"] == 6
+    assert schedule["resolved_helicity_count"] == 3
+    assert schedule["amplitude_destination_count"] == 9
+
+
+@pytest.mark.parametrize("model_source", ["built-in", "ufo-sm"])
+@pytest.mark.parametrize(
+    ("expression", "case_id"),
+    [
+        pytest.param(
+            _GG_EXPRESSION,
+            "case:sm_gg_gg:lc",
+            id="pure-gluon-folded-reflection",
+        ),
+        pytest.param(
+            _SAME_FLAVOUR_EXPRESSION,
+            "case:sm_ddbar_ddbar:lc",
+            id="same-flavour-reconstruction",
+        ),
+        pytest.param(
+            _THREE_LINE_EXPRESSION,
+            None,
+            id="multiple-open-line-closures",
+        ),
+    ],
+)
+def test_direct_arena_all_flow_union_difficult_semantics(
+    tmp_path: Path,
+    model_source: str,
+    expression: str,
+    case_id: str | None,
+    request: pytest.FixtureRequest,
+) -> None:
+    """Cover difficult closure semantics through the actual union runtime."""
+
+    runtime = _generate_direct_arena_runtime(
+        tmp_path=tmp_path,
+        model_source=model_source,
+        expression=expression,
+        ufo_model=_ufo_model_for(model_source, request),
+        lc_flow_layout=LCFlowLayout.ALL_FLOW_UNION,
+    )
+
+    if case_id is not None:
+        point, expected_by_flow, expected_total = _tracked_lc_reference(case_id)
+    else:
+        point = (
+            (500.0, 0.0, 0.0, 500.0),
+            (500.0, 0.0, 0.0, -500.0),
+            *massive_rambo_final_state(
+                4,
+                sqrt_s=1000.0,
+                masses=(0.0, 0.0, 0.0, 0.0),
+                seed=731,
+            ),
+        )
+        expected_by_flow = _THREE_LINE_HELICITY_SUM_BY_FLOW
+        expected_total = _THREE_LINE_HELICITY_SUM_TOTAL
+
+    relative_tolerance = 5.0e-12 if model_source == "ufo-sm" else 1.0e-12
+    _assert_flow_oracle(
+        runtime,
+        point,
+        expected_by_flow,
+        expected_total,
+        relative_tolerance=relative_tolerance,
+    )
+    _assert_flow_oracle(
+        runtime,
+        point,
+        expected_by_flow,
+        expected_total,
+        relative_tolerance=relative_tolerance,
+        precision=32,
+    )
+    _assert_exact_components_match_native(runtime, point)
diff --git a/pyamplicol/tests/integration/test_recurrence_process_set_sharing.py b/pyamplicol/tests/integration/test_recurrence_process_set_sharing.py
new file mode 100644
index 0000000000..cad74c82c8
--- /dev/null
+++ b/pyamplicol/tests/integration/test_recurrence_process_set_sharing.py
@@ -0,0 +1,416 @@
+# SPDX-License-Identifier: 0BSD
+"""Guarded acceptance test for real recurrence process-set schedule sharing.
+
+Run the full acceptance explicitly under the repository memory watchdog:
+
+.. code-block:: console
+
+   PYAMPLICOL_RUN_RECURRENCE_PROCESS_SET_ACCEPTANCE=1 \
+     .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 -- \
+     .venv/bin/python -m pytest -q \
+     tests/integration/test_recurrence_process_set_sharing.py
+
+The caller must provide the normal Symbolica license environment. The test is
+skipped by default because it generates the bounded one-flavour ``p p > 4j``
+process set and loads representative native schedules.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import importlib.util
+import json
+import os
+import struct
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, ProcessSet, Runtime
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    Action,
+    ColorAccuracy,
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorExecutionMode,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    LCFlowLayout,
+    ProcessConfig,
+    RelationDiscoveryMode,
+    RunConfig,
+)
+from pyamplicol.generation.recurrence_schedule_sharing import (
+    RECURRENCE_PROCESS_BINDING_MAGIC,
+    RECURRENCE_SCHEDULE_INDEX_PATH,
+    RECURRENCE_SCHEDULE_SHARING_KIND,
+    RECURRENCE_SCHEDULE_SHARING_SCHEMA_VERSION,
+)
+
+_ACCEPTANCE_ENV = "PYAMPLICOL_RUN_RECURRENCE_PROCESS_SET_ACCEPTANCE"
+_PROCESS_EXPRESSION = "p p > j j j j"
+_PROCESS_NAME = "pp_4j"
+_EXPECTED_PROCESS_COUNT = 11
+
+pytestmark = pytest.mark.skipif(
+    os.environ.get(_ACCEPTANCE_ENV) != "1",
+    reason=(
+        "set PYAMPLICOL_RUN_RECURRENCE_PROCESS_SET_ACCEPTANCE=1 and run "
+        "under the 30 GiB watchdog"
+    ),
+)
+
+
+def _generation_config() -> RunConfig:
+    partons = ("d", "d~", "g")
+    return RunConfig(
+        action=Action.GENERATE,
+        process=ProcessConfig(
+            multiparticles={"p": partons, "j": partons},
+            flavor_scheme=1,
+            max_quark_lines=2,
+        ),
+        color=ColorConfig(
+            accuracy=ColorAccuracy.LC,
+            lc_flow_layout=LCFlowLayout.TOPOLOGY_REPLAY,
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(
+                mode=RelationDiscoveryMode.OFF,
+            ),
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=EvaluatorExecutionMode.RECURRENCE,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+def _require_native_direct_arena() -> None:
+    assert importlib.util.find_spec("symbolica") is not None, (
+        "the process-set acceptance requires Symbolica"
+    )
+    assert importlib.util.find_spec("pyamplicol._rusticol") is not None, (
+        "the process-set acceptance requires the native Rusticol extension"
+    )
+    rusticol = importlib.import_module("pyamplicol._rusticol")
+    assert hasattr(rusticol, "_lower_recurrence_direct_v2"), (
+        "the installed Rusticol extension lacks recurrence Direct-Arena v2"
+    )
+
+
+def _mapping(value: object, context: str) -> Mapping[str, Any]:
+    assert isinstance(value, Mapping), f"{context} must be a mapping"
+    return value
+
+
+def _sequence(value: object, context: str) -> tuple[object, ...]:
+    assert isinstance(value, list), f"{context} must be a JSON array"
+    return tuple(value)
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while block := stream.read(1024 * 1024):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _inode(path: Path) -> tuple[int, int]:
+    stat = path.stat()
+    assert stat.st_nlink == 1, f"{path} must not be hard-linked"
+    return stat.st_dev, stat.st_ino
+
+
+def _assert_process_binding(
+    artifact: Path,
+    *,
+    process_id: str,
+    binding: Mapping[str, Any],
+) -> Path:
+    assert binding["process_id"] == process_id
+    assert binding["path"] == "recurrence-binding.bin"
+    schedule_digest = str(binding["schedule_digest"])
+    binding_path = artifact / "processes" / process_id / str(binding["path"])
+    payload = binding_path.read_bytes()
+
+    assert binding_path.stat().st_size == int(binding["size_bytes"])
+    assert _sha256(binding_path) == binding["sha256"]
+    assert payload[:8] == RECURRENCE_PROCESS_BINDING_MAGIC
+
+    (
+        version,
+        fixed_size,
+        process_id_size,
+        support_word_count,
+        target_size,
+        _cpu_feature_count,
+        descriptor_count,
+        catalog_executor_count,
+    ) = struct.unpack_from("<8I", payload, 8)
+    assert version == 4
+    assert fixed_size == 344
+    assert support_word_count >= 1
+    assert descriptor_count >= 1
+    assert catalog_executor_count == int(
+        _mapping(
+            _mapping(binding["remap"], "binding remap")["direct_executors"],
+            "binding direct-executor remap",
+        )["count"]
+    )
+    assert payload[88:120] == bytes.fromhex(schedule_digest)
+    assert payload[fixed_size : fixed_size + process_id_size].decode("utf-8") == (
+        process_id
+    )
+    assert len(payload) >= (
+        fixed_size
+        + process_id_size
+        + target_size
+        + 8 * support_word_count
+        + 16 * descriptor_count
+    )
+    return binding_path
+
+
+def _representative_process_ids(
+    schedules: tuple[Mapping[str, Any], ...],
+) -> tuple[str, ...]:
+    shared = next(
+        schedule
+        for schedule in schedules
+        if len(_sequence(schedule["process_ids"], "schedule process IDs")) > 1
+    )
+    shared_ids = tuple(
+        str(value)
+        for value in _sequence(shared["process_ids"], "shared schedule process IDs")
+    )
+    representatives = [shared_ids[0], shared_ids[-1]]
+    distinct = next(
+        (schedule for schedule in schedules if schedule["digest"] != shared["digest"]),
+        None,
+    )
+    if distinct is not None:
+        representatives.append(
+            str(
+                _sequence(
+                    distinct["process_ids"],
+                    "distinct schedule process IDs",
+                )[0]
+            )
+        )
+    return tuple(dict.fromkeys(representatives))
+
+
+def _flatten(values: object) -> list[complex]:
+    if isinstance(values, (tuple, list)):
+        result: list[complex] = []
+        for value in values:
+            result.extend(_flatten(value))
+        return result
+    return [complex(values)]
+
+
+def test_bounded_pp_four_jets_shares_root_recurrence_schedules(
+    tmp_path: Path,
+) -> None:
+    """Generate and load a real bounded multiprocess Direct-Arena artifact."""
+
+    _require_native_direct_arena()
+    artifact = tmp_path / "recurrence-pp-four-jets"
+    processes = ProcessSet.from_expressions(
+        (_PROCESS_EXPRESSION,),
+        names=(_PROCESS_NAME,),
+    )
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+        Generator(_generation_config()).generate(
+            processes,
+            artifact,
+            model=ModelSource.from_path(prepared_model),
+        )
+
+    manifest = load_manifest(artifact)
+    process_records = tuple(manifest.processes)
+    process_ids = tuple(str(record["id"]) for record in process_records)
+    assert manifest.kind == "pyamplicol-process-set"
+    assert len(process_ids) == _EXPECTED_PROCESS_COUNT
+    assert all(
+        set(str(record["expression"]).replace(">", " ").split()) <= {"d", "d~", "g"}
+        for record in process_records
+    )
+
+    index_path = artifact / RECURRENCE_SCHEDULE_INDEX_PATH
+    index = _mapping(
+        json.loads(index_path.read_text(encoding="utf-8")),
+        "recurrence schedule index",
+    )
+    assert index["kind"] == RECURRENCE_SCHEDULE_SHARING_KIND
+    assert index["schema_version"] == RECURRENCE_SCHEDULE_SHARING_SCHEMA_VERSION
+    assert index["runtime_ownership"] == "root-schedule-plus-process-binding"
+    assert index["interning_phase"] == "before-direct-lowering"
+
+    schedules = tuple(
+        _mapping(value, "recurrence schedule")
+        for value in _sequence(index["schedules"], "recurrence schedules")
+    )
+    bindings = tuple(
+        _mapping(value, "recurrence binding")
+        for value in _sequence(index["bindings"], "recurrence bindings")
+    )
+    assert int(index["binding_count"]) == len(bindings) == len(process_ids)
+    assert int(index["schedule_count"]) == len(schedules)
+    assert len(schedules) < len(bindings)
+    assert int(index["schedule_alias_count"]) == len(bindings) - len(schedules)
+
+    schedule_paths: list[Path] = []
+    schedule_payload_digests: set[str] = set()
+    schedule_inodes: set[tuple[int, int]] = set()
+    declared_owners: dict[str, set[str]] = {}
+    for schedule in schedules:
+        digest = str(schedule["digest"])
+        path = artifact / str(schedule["path"])
+        expected_path = (
+            artifact / "recurrence" / "schedules" / digest / "recurrence-runtime.pacbin"
+        )
+        assert path == expected_path
+        assert path.stat().st_size == int(schedule["size_bytes"])
+        assert _sha256(path) == schedule["sha256"]
+        assert str(schedule["sha256"]) not in schedule_payload_digests
+        schedule_payload_digests.add(str(schedule["sha256"]))
+        inode = _inode(path)
+        assert inode not in schedule_inodes
+        schedule_inodes.add(inode)
+        schedule_paths.append(path)
+        declared_owners[digest] = {
+            str(value)
+            for value in _sequence(
+                schedule["process_ids"],
+                f"schedule {digest} process IDs",
+            )
+        }
+
+    assert set(artifact.rglob("recurrence-runtime.pacbin")) == set(schedule_paths)
+
+    bindings_by_process = {str(binding["process_id"]): binding for binding in bindings}
+    assert set(bindings_by_process) == set(process_ids)
+    binding_paths: list[Path] = []
+    binding_inodes: set[tuple[int, int]] = set()
+    binding_payload_digests: set[str] = set()
+    bound_owners: dict[str, set[str]] = {}
+    for process_id in process_ids:
+        binding = bindings_by_process[process_id]
+        binding_path = _assert_process_binding(
+            artifact,
+            process_id=process_id,
+            binding=binding,
+        )
+        inode = _inode(binding_path)
+        assert inode not in binding_inodes
+        binding_inodes.add(inode)
+        assert str(binding["sha256"]) not in binding_payload_digests
+        binding_payload_digests.add(str(binding["sha256"]))
+        binding_paths.append(binding_path)
+        bound_owners.setdefault(str(binding["schedule_digest"]), set()).add(process_id)
+
+        execution = _mapping(
+            json.loads(
+                (artifact / "processes" / process_id / "execution.json").read_text(
+                    encoding="utf-8"
+                )
+            ),
+            f"process {process_id} execution",
+        )
+        plan = _mapping(execution["plan"], f"process {process_id} plan")
+        runtime_schedule = _mapping(
+            plan["runtime_schedule"],
+            f"process {process_id} runtime schedule",
+        )
+        process_binding = _mapping(
+            plan["process_binding"],
+            f"process {process_id} binding",
+        )
+        assert runtime_schedule["path"] == next(
+            schedule["path"]
+            for schedule in schedules
+            if schedule["digest"] == binding["schedule_digest"]
+        )
+        assert process_binding == binding
+
+    assert set(artifact.rglob("recurrence-binding.bin")) == set(binding_paths)
+    assert bound_owners == declared_owners
+    assert schedule_inodes.isdisjoint(binding_inodes)
+
+    for process_id in _representative_process_ids(schedules):
+        runtime = Runtime.load(artifact, process=process_id)
+        assert runtime.physics.process_id == process_id
+        assert runtime.physics.color_accuracy == "lc"
+
+    expressions = {
+        str(record["id"]): str(record["expression"]) for record in process_records
+    }
+    shared_groups = tuple(
+        tuple(
+            str(process_id)
+            for process_id in _sequence(
+                schedule["process_ids"],
+                "shared schedule process IDs",
+            )
+        )
+        for schedule in schedules
+        if len(_sequence(schedule["process_ids"], "schedule process IDs")) > 1
+    )
+    assert shared_groups
+    for group_index, shared_ids in enumerate(shared_groups):
+        process_id = shared_ids[-1]
+        shared_runtime = Runtime.load(artifact, process=process_id)
+        reference_artifact = tmp_path / f"reference-{group_index}"
+        with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+            Generator(_generation_config()).generate(
+                ProcessSet.from_expressions(
+                    (expressions[process_id],),
+                    names=(f"reference_{group_index}",),
+                ),
+                reference_artifact,
+                model=ModelSource.from_path(prepared_model),
+            )
+        reference_runtime = Runtime.load(reference_artifact)
+        assert shared_runtime.physics.helicity_ids == (
+            reference_runtime.physics.helicity_ids
+        )
+        assert shared_runtime.physics.color_ids == reference_runtime.physics.color_ids
+        momenta = shared_runtime._backend.validation_momenta()
+        assert momenta is not None
+        selected_flow = shared_runtime.physics.color_ids[0]
+        shared_resolved = shared_runtime.evaluate_resolved(
+            momenta,
+            color_flows=(selected_flow,),
+        )
+        reference_resolved = reference_runtime.evaluate_resolved(
+            momenta,
+            color_flows=(selected_flow,),
+        )
+        assert shared_resolved.helicity_ids == reference_resolved.helicity_ids
+        assert shared_resolved.color_ids == reference_resolved.color_ids
+        assert _flatten(shared_resolved.values) == pytest.approx(
+            _flatten(reference_resolved.values),
+            rel=1.0e-12,
+            abs=1.0e-15,
+        )
diff --git a/pyamplicol/tests/integration/test_recurrence_three_line_execution.py b/pyamplicol/tests/integration/test_recurrence_three_line_execution.py
new file mode 100644
index 0000000000..2dca7b8b5b
--- /dev/null
+++ b/pyamplicol/tests/integration/test_recurrence_three_line_execution.py
@@ -0,0 +1,233 @@
+# SPDX-License-Identifier: 0BSD
+"""Three-open-quark-line recurrence execution against an AmpliCol oracle."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+from pyamplicol.generation.phase_space import massive_rambo_final_state
+from pyamplicol.models.loading import compile_model_source
+from pyamplicol.models.prepared_compile import prepare_model_bundle
+
+_EXPRESSION = "d d~ > u u~ s s~"
+_LEGACY_HELICITY_SUM_BY_FLOW = {
+    "flow:2,1,3,4,5,6": 1.7260373034739047e-11,
+    "flow:2,1,3,6,5,4": 1.6570372188601389e-11,
+    "flow:2,4,3,1,5,6": 1.0167883928661888e-10,
+    "flow:2,4,3,6,5,1": 1.6445040193096446e-10,
+    "flow:2,6,3,1,5,4": 6.5052811045824496e-10,
+    "flow:2,6,3,4,5,1": 1.2411150983558527e-10,
+}
+_LEGACY_HELICITY_SUM_TOTAL = 1.0745996067347547e-9
+_UFO_SM_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+
+
+def _normalization_factor(payload: dict[str, object]) -> float:
+    return (
+        float(payload["global_coupling_factor"])
+        * float(payload["color_factor"])
+        / (float(payload["average_factor"]) * float(payload["identical_factor"]))
+    )
+
+
+def _model_context(model_source: str):
+    if model_source == "built-in":
+        compiled_model = compile_model_source("built-in-sm", use_cache=True)
+        return compiled_model, None
+
+    model_path = _UFO_SM_ROOT / "sm.json"
+    restriction_path = _UFO_SM_ROOT / "restrict_default.json"
+    compiled_model = compile_model_source(
+        model_path,
+        restriction=str(restriction_path.resolve()),
+        use_cache=True,
+    )
+    return (
+        compiled_model,
+        ModelSource.from_path(model_path, restriction=restriction_path),
+    )
+
+
+def _compiled_helicity_sum_by_flow(
+    artifact: Path,
+    point: tuple[tuple[float, ...], ...],
+) -> tuple[dict[str, float], dict[str, object]]:
+    resolved = Runtime.load(artifact).evaluate_resolved((point,))
+    values = {
+        flow_id: float(
+            sum(
+                resolved.values[0][helicity_index][color_index].real
+                for helicity_index in range(len(resolved.helicity_ids))
+            )
+        )
+        for color_index, flow_id in enumerate(resolved.color_ids)
+    }
+    physics_files = tuple((artifact / "processes").glob("*/physics.json"))
+    assert len(physics_files) == 1
+    physics = json.loads(physics_files[0].read_text(encoding="utf-8"))
+    normalization = physics["extensions"]["normalization"]
+    assert isinstance(normalization, dict)
+    return values, normalization
+
+
+def _recurrence_helicity_sum_by_flow(
+    *,
+    tmp_path: Path,
+    model_source: str,
+    compiled_model,
+    point: tuple[tuple[float, ...], ...],
+) -> tuple[dict[str, float], dict[str, object], tuple[str, ...]]:
+    evaluator = EvaluatorConfig(
+        execution_mode="recurrence",
+        optimization=EvaluatorOptimizationConfig(cores=1),
+        jit=JITConfig(optimization_level=2),
+    )
+    prepared = prepare_model_bundle(
+        compiled_model,
+        tmp_path / f"{model_source}-recurrence-jit-o2.pyamplicol-model",
+        evaluator=evaluator,
+    )
+    artifact = tmp_path / f"{model_source}-recurrence-direct-v2"
+    Generator(
+        RunConfig(
+            action="generate",
+            color=ColorConfig(accuracy="lc"),
+            generation=GenerationConfig(
+                workers=1,
+                emit_api_bundle=False,
+                validation=GenerationValidationConfig(
+                    enabled=False,
+                    post_build_validation=False,
+                ),
+            ),
+            evaluator=evaluator,
+        )
+    ).generate(
+        _EXPRESSION,
+        artifact,
+        model=ModelSource.from_path(prepared.output),
+    )
+
+    values, normalization = _compiled_helicity_sum_by_flow(artifact, point)
+    return values, normalization, tuple(values)
+
+
+def test_three_line_topology_replay_matches_amplicol_and_compiled_per_flow(
+    tmp_path: Path,
+) -> None:
+    """Compare both SM frontends to AmpliCol and fresh compiled artifacts."""
+
+    point = (
+        (500.0, 0.0, 0.0, 500.0),
+        (500.0, 0.0, 0.0, -500.0),
+        *massive_rambo_final_state(
+            4,
+            sqrt_s=1000.0,
+            masses=(0.0, 0.0, 0.0, 0.0),
+            seed=731,
+        ),
+    )
+    generation = GenerationConfig(
+        emit_api_bundle=False,
+        validation=GenerationValidationConfig(
+            enabled=False,
+            post_build_validation=False,
+        ),
+    )
+    evaluator = EvaluatorConfig(
+        execution_mode="compiled",
+        jit=JITConfig(optimization_level=1),
+    )
+    by_model: dict[str, dict[str, float]] = {}
+    mismatches: dict[str, dict[str, dict[str, float]]] = {}
+
+    for model_source in ("built-in", "ufo-sm"):
+        compiled_model, public_model = _model_context(model_source)
+        artifact = tmp_path / f"{model_source}-compiled-jit-o1"
+        Generator(
+            RunConfig(
+                action="generate",
+                color=ColorConfig(accuracy="lc"),
+                generation=generation,
+                evaluator=evaluator,
+            )
+        ).generate(_EXPRESSION, artifact, model=public_model)
+        compiled, artifact_normalization = _compiled_helicity_sum_by_flow(
+            artifact,
+            point,
+        )
+        recurrence, recurrence_normalization, recurrence_flow_ids = (
+            _recurrence_helicity_sum_by_flow(
+                tmp_path=tmp_path,
+                model_source=model_source,
+                compiled_model=compiled_model,
+                point=point,
+            )
+        )
+
+        assert tuple(compiled) == recurrence_flow_ids
+        for key in (
+            "global_coupling_factor",
+            "color_factor",
+            "average_factor",
+            "identical_factor",
+        ):
+            assert float(artifact_normalization[key]) == float(
+                recurrence_normalization[key]
+            )
+        assert _normalization_factor(artifact_normalization) == (
+            _normalization_factor(recurrence_normalization)
+        )
+        model_mismatches: dict[str, dict[str, float]] = {}
+        for flow_id, expected in compiled.items():
+            obtained = recurrence[flow_id]
+            absolute = abs(obtained - expected)
+            relative = absolute / abs(expected) if expected else float("inf")
+            if absolute > max(1e-15, 1e-12 * abs(expected)):
+                model_mismatches[flow_id] = {
+                    "recurrence": obtained,
+                    "compiled_jit_o1": expected,
+                    "absolute_difference": absolute,
+                    "relative_difference": relative,
+                }
+        if model_mismatches:
+            mismatches[model_source] = model_mismatches
+        assert recurrence == pytest.approx(
+            _LEGACY_HELICITY_SUM_BY_FLOW,
+            rel=5e-12,
+            abs=1e-15,
+        )
+        assert sum(recurrence.values()) == pytest.approx(
+            _LEGACY_HELICITY_SUM_TOTAL,
+            rel=5e-12,
+            abs=1e-15,
+        )
+        by_model[model_source] = recurrence
+
+    assert by_model["ufo-sm"] == pytest.approx(
+        by_model["built-in"],
+        rel=5e-12,
+        abs=1e-15,
+    )
+    assert not mismatches, json.dumps(mismatches, indent=2, sort_keys=True)
diff --git a/pyamplicol/tests/integration/test_runtime_selector_api_parity.py b/pyamplicol/tests/integration/test_runtime_selector_api_parity.py
new file mode 100644
index 0000000000..d0bc691aa1
--- /dev/null
+++ b/pyamplicol/tests/integration/test_runtime_selector_api_parity.py
@@ -0,0 +1,1255 @@
+# SPDX-License-Identifier: 0BSD
+# ruff: noqa: E501
+from __future__ import annotations
+
+import importlib.util
+import json
+import math
+import os
+import random
+import shlex
+import shutil
+import subprocess
+import sys
+import textwrap
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from pyamplicol import EvaluationError, Generator, ProcessSet, Runtime
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    JITConfig,
+    RunConfig,
+)
+from pyamplicol.generation.phase_space import massive_rambo_final_state
+
+_PROJECT_ROOT = Path(__file__).resolve().parents[2]
+_POINT_COUNT = 8
+_RANDOM_SELECTOR_SEED = 0xC0FFEE
+
+
+@dataclass(frozen=True, slots=True)
+class _NativeSdk:
+    cc: str
+    cxx: str
+    fortran: str
+    rustc: str
+    config: dict[str, Any]
+
+
+def _source_environment() -> dict[str, str]:
+    environment = os.environ.copy()
+    environment["PYTHONPATH"] = os.pathsep.join(
+        (str((_PROJECT_ROOT / "src").resolve()), environment.get("PYTHONPATH", ""))
+    ).rstrip(os.pathsep)
+    return environment
+
+
+def _unavailable(reason: str) -> None:
+    if os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1":
+        pytest.fail(reason)
+    pytest.skip(reason)
+
+
+def _configured_tool(variable: str, default: str) -> str | None:
+    command = os.environ.get(variable, default).split()[0]
+    return shutil.which(command) or (command if Path(command).is_file() else None)
+
+
+def _rusticol_config_command() -> tuple[str, ...] | None:
+    configured = os.environ.get("RUSTICOL_CONFIG")
+    if configured:
+        return tuple(shlex.split(configured))
+    if importlib.util.find_spec("rusticol_config") is not None:
+        return (sys.executable, "-m", "rusticol_config")
+    sibling = Path(sys.executable).parent / "rusticol-config"
+    if sibling.is_file():
+        return (str(sibling),)
+    return None
+
+
+@pytest.fixture(scope="module")
+def native_sdk() -> _NativeSdk:
+    tools = {
+        "cc": _configured_tool("CC", "cc"),
+        "cxx": _configured_tool("CXX", "c++"),
+        "fortran": _configured_tool("FC", "gfortran"),
+        "rustc": _configured_tool("RUSTC", "rustc"),
+    }
+    missing = tuple(name for name, path in tools.items() if path is None)
+    if missing:
+        _unavailable("runtime selector parity requires " + ", ".join(missing))
+    command = _rusticol_config_command()
+    if command is None:
+        _unavailable("runtime selector parity requires rusticol-config")
+    completed = subprocess.run(
+        [*command, "--json"],
+        env=_source_environment(),
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=20,
+    )
+    if completed.returncode != 0:
+        _unavailable("Rusticol SDK configuration failed: " + completed.stderr.strip())
+    return _NativeSdk(
+        cc=tools["cc"],  # type: ignore[arg-type]
+        cxx=tools["cxx"],  # type: ignore[arg-type]
+        fortran=tools["fortran"],  # type: ignore[arg-type]
+        rustc=tools["rustc"],  # type: ignore[arg-type]
+        config=json.loads(completed.stdout),
+    )
+
+
+@pytest.fixture(scope="module")
+def selector_artifact(tmp_path_factory: pytest.TempPathFactory) -> Path:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    artifact = tmp_path_factory.mktemp("runtime-selector-parity") / "dd-zgg-lc"
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc"),
+        generation=GenerationConfig(workers=1),
+        evaluator=EvaluatorConfig(
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=1),
+        ),
+    )
+    Generator(config).generate(
+        ProcessSet.from_expressions(("d d~ > z g g",), names=("dd_zgg",)), artifact
+    )
+    return artifact
+
+
+@pytest.fixture(scope="module")
+def contracted_selector_artifact(tmp_path_factory: pytest.TempPathFactory) -> Path:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    artifact = tmp_path_factory.mktemp("runtime-selector-contracted") / "dd-zgg-nlc"
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="nlc"),
+        generation=GenerationConfig(workers=1),
+        evaluator=EvaluatorConfig(
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=1),
+        ),
+    )
+    Generator(config).generate(
+        ProcessSet.from_expressions(("d d~ > z g g",), names=("dd_zgg",)),
+        artifact,
+    )
+    return artifact
+
+
+def _validation_point(artifact: Path) -> tuple[tuple[float, ...], ...]:
+    payload = json.loads(
+        (artifact / "processes/dd_zgg/validation-momenta.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    return tuple(
+        tuple(float(component) for component in leg["momentum"])
+        for leg in payload["points"][0]
+    )
+
+
+def _phase_space_points(
+    artifact: Path,
+) -> tuple[tuple[tuple[float, ...], ...], ...]:
+    validation = _validation_point(artifact)
+    sqrt_s = validation[0][0] + validation[1][0]
+    z_momentum = validation[2]
+    z_mass = math.sqrt(
+        max(
+            0.0,
+            z_momentum[0] ** 2 - sum(component**2 for component in z_momentum[1:]),
+        )
+    )
+    points = tuple(
+        (
+            validation[0],
+            validation[1],
+            *massive_rambo_final_state(
+                3,
+                sqrt_s=sqrt_s,
+                masses=(z_mass, 0.0, 0.0),
+                seed=7000 + index,
+            ),
+        )
+        for index in range(_POINT_COUNT)
+    )
+    assert len(set(points)) == _POINT_COUNT
+    return points
+
+
+def _selector_patterns() -> dict[str, tuple[tuple[int, ...], tuple[int, ...]]]:
+    random_generator = random.Random(_RANDOM_SELECTOR_SEED)
+    seeded_random = (
+        tuple(random_generator.randrange(2) for _ in range(_POINT_COUNT)),
+        tuple(random_generator.randrange(2) for _ in range(_POINT_COUNT)),
+    )
+    return {
+        "homogeneous": ((0,) * _POINT_COUNT, (0,) * _POINT_COUNT),
+        "pooled": ((0,) * 4 + (1,) * 4, (1,) * 4 + (0,) * 4),
+        "alternating": ((0, 1) * 4, (1, 0) * 4),
+        "seeded-random": seeded_random,
+    }
+
+
+def _assert_close(actual: complex, expected: complex) -> None:
+    assert actual.real == pytest.approx(expected.real, rel=1.0e-12, abs=1.0e-15)
+    assert actual.imag == pytest.approx(expected.imag, rel=1.0e-12, abs=1.0e-15)
+
+
+def test_python_global_and_per_point_selector_contract(selector_artifact: Path) -> None:
+    runtime = Runtime.load(selector_artifact)
+    momenta = _phase_space_points(selector_artifact)
+    resolved = runtime.evaluate_resolved(momenta)
+    assert len(resolved.helicity_ids) >= 2
+    assert len(resolved.color_ids) >= 2
+
+    patterns = _selector_patterns()
+    helicities, colors = patterns["alternating"]
+    default_values = runtime.evaluate(momenta)
+    global_values = runtime.evaluate(
+        momenta,
+        helicities=(resolved.helicity_ids[0],),
+        color_flows=(resolved.color_ids[0],),
+    )
+    global_helicity_only = runtime.evaluate(
+        momenta,
+        helicities=(resolved.helicity_ids[0],),
+    )
+    global_color_only = runtime.evaluate(
+        momenta,
+        color_flows=(resolved.color_ids[0],),
+    )
+    selected_by_pattern = {
+        name: runtime.evaluate(
+            momenta,
+            helicity_by_point=tuple(
+                resolved.helicity_ids[index] for index in pattern_helicities
+            ),
+            color_flow_by_point=tuple(
+                resolved.color_ids[index] for index in pattern_colors
+            ),
+        )
+        for name, (pattern_helicities, pattern_colors) in patterns.items()
+    }
+    helicity_only = runtime.evaluate(
+        momenta,
+        helicity_by_point=tuple(resolved.helicity_ids[index] for index in helicities),
+    )
+    color_only = runtime.evaluate(
+        momenta,
+        color_flow_by_point=tuple(resolved.color_ids[index] for index in colors),
+    )
+
+    for point in range(_POINT_COUNT):
+        _assert_close(
+            default_values[point],
+            sum(sum(row) for row in resolved.values[point]),
+        )
+        _assert_close(global_values[point], resolved.values[point][0][0])
+        _assert_close(global_helicity_only[point], sum(resolved.values[point][0]))
+        _assert_close(
+            global_color_only[point], sum(row[0] for row in resolved.values[point])
+        )
+        for name, (pattern_helicities, pattern_colors) in patterns.items():
+            _assert_close(
+                selected_by_pattern[name][point],
+                resolved.values[point][pattern_helicities[point]][
+                    pattern_colors[point]
+                ],
+            )
+        _assert_close(
+            helicity_only[point], sum(resolved.values[point][helicities[point]])
+        )
+        _assert_close(
+            color_only[point],
+            sum(row[colors[point]] for row in resolved.values[point]),
+        )
+
+    with pytest.raises(ValueError, match="helicities and helicity_by_point"):
+        runtime.evaluate(
+            momenta,
+            helicities=(resolved.helicity_ids[0],),
+            helicity_by_point=(resolved.helicity_ids[0],) * _POINT_COUNT,
+        )
+    with pytest.raises(ValueError, match="color_flows and color_flow_by_point"):
+        runtime.evaluate(
+            momenta,
+            color_flows=(resolved.color_ids[0],),
+            color_flow_by_point=(resolved.color_ids[0],) * _POINT_COUNT,
+        )
+    with pytest.raises(
+        EvaluationError, match="expected one selector for each of 8 points"
+    ):
+        runtime.evaluate(
+            momenta,
+            helicity_by_point=(resolved.helicity_ids[0],),
+        )
+    with pytest.raises(EvaluationError, match=r"color_flow_by_point\[1\]"):
+        runtime.evaluate(
+            momenta,
+            color_flow_by_point=(
+                resolved.color_ids[0],
+                "missing",
+                "missing",
+                "missing",
+                "missing",
+                "missing",
+                "missing",
+                "missing",
+            ),
+        )
+
+
+def test_native_profile_reports_stable_grouping_and_pooled_bypass(
+    selector_artifact: Path,
+) -> None:
+    runtime = Runtime.load(selector_artifact)
+    momenta = _phase_space_points(selector_artifact)
+    resolved = runtime.evaluate_resolved(momenta)
+    patterns = _selector_patterns()
+
+    pooled_helicities, pooled_colors = patterns["pooled"]
+    pooled = runtime._backend.profile_repeated(
+        momenta,
+        2,
+        helicity_by_point=tuple(
+            resolved.helicity_ids[index] for index in pooled_helicities
+        ),
+        color_flow_by_point=tuple(
+            resolved.color_ids[index] for index in pooled_colors
+        ),
+    )
+    assert pooled["selector_plan_kind"] == "contiguous"
+    assert pooled["selector_group_sizes"] == [4, 4]
+    assert pooled["selector_reordered_point_count"] == 0
+    assert pooled["selector_gather_time_s"] == 0.0
+
+    alternating_helicities, alternating_colors = patterns["alternating"]
+    alternating = runtime._backend.profile_repeated(
+        momenta,
+        2,
+        helicity_by_point=tuple(
+            resolved.helicity_ids[index] for index in alternating_helicities
+        ),
+        color_flow_by_point=tuple(
+            resolved.color_ids[index] for index in alternating_colors
+        ),
+    )
+    assert alternating["selector_plan_kind"] == "stable-grouped"
+    assert alternating["selector_group_sizes"] == [4, 4]
+    assert alternating["selector_reordered_point_count"] == 6
+    assert 0.0 < float(alternating["selector_simd_occupancy"]) <= 1.0
+    assert float(alternating["selector_planner_time_s"]) > 0.0
+    assert float(alternating["selector_gather_time_s"]) > 0.0
+
+
+def test_python_color_selectors_reject_contracted_axis(
+    contracted_selector_artifact: Path,
+) -> None:
+    runtime = Runtime.load(contracted_selector_artifact)
+    momenta = (_validation_point(contracted_selector_artifact),)
+
+    for selectors in (
+        {"color_flows": (runtime.physics.color_ids[0],)},
+        {"color_flow_by_point": (runtime.physics.color_ids[0],)},
+    ):
+        with pytest.raises(
+            EvaluationError,
+            match="LC color-flow selection is unavailable",
+        ):
+            runtime.evaluate(momenta, **selectors)
+
+
+_C_PROBE = r"""
+#include <rusticol.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define CHECK(call) do { \
+    int status_ = (call); \
+    if (status_ != RUSTICOL_STATUS_OK) { \
+        size_t required_ = 0; \
+        rusticol_last_error_message(NULL, 0, &required_); \
+        char *message_ = required_ > 0 ? malloc(required_) : NULL; \
+        if (message_ != NULL && rusticol_last_error_message( \
+                message_, required_, &required_) == RUSTICOL_STATUS_OK) \
+            fprintf(stderr, "Rusticol error: %s\\n", message_); \
+        free(message_); \
+        return 10; \
+    } \
+} while (0)
+
+typedef int (*id_getter)(const RusticolRuntimeHandle *, size_t, char *, size_t, size_t *);
+
+static char *get_id(RusticolRuntimeHandle *runtime, id_getter getter, size_t index) {
+    size_t required = 0;
+    if (getter(runtime, index, NULL, 0, &required) != RUSTICOL_STATUS_OK) return NULL;
+    char *value = malloc(required);
+    if (value == NULL || getter(runtime, index, value, required, &required) != RUSTICOL_STATUS_OK) {
+        free(value);
+        return NULL;
+    }
+    return value;
+}
+
+static int close_value(double actual, double expected) {
+    const double scale = fmax(fabs(actual), fabs(expected));
+    return fabs(actual - expected) <= 1.0e-15 + 1.0e-12 * scale;
+}
+
+static double component(const double *values, size_t point, size_t helicity, size_t color,
+                        size_t helicity_count, size_t color_count) {
+    return values[(point * helicity_count + helicity) * color_count + color];
+}
+
+static int check_pattern(RusticolRuntimeHandle *runtime, const double *momenta,
+                         size_t momenta_count, size_t point_count,
+                         const uint32_t *helicities, const uint32_t *colors,
+                         const double *resolved, size_t helicity_count,
+                         size_t color_count, int failure_code) {
+    double selected[8];
+    if (rusticol_runtime_evaluate_selected_f64(
+            runtime, momenta, momenta_count, point_count,
+            NULL, 0, NULL, 0, helicities, point_count, colors, point_count,
+            selected, point_count) != RUSTICOL_STATUS_OK) return 10;
+    for (size_t point = 0; point < point_count; ++point) {
+        const double expected = component(
+            resolved, point, helicities[point], colors[point], helicity_count, color_count);
+        if (!close_value(selected[point], expected)) return failure_code;
+    }
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 4) return 2;
+    const size_t point_count = 8;
+    const size_t momenta_count = (size_t)(argc - 3);
+    if (momenta_count % point_count != 0) return 2;
+    double *momenta = malloc(momenta_count * sizeof(double));
+    if (momenta == NULL) return 3;
+    for (size_t index = 0; index < momenta_count; ++index)
+        momenta[index] = strtod(argv[index + 3], NULL);
+
+    RusticolRuntimeHandle *runtime = NULL;
+    CHECK(rusticol_runtime_load(argv[1], argv[2], NULL, &runtime));
+    size_t helicity_count = 0, color_count = 0;
+    CHECK(rusticol_runtime_helicity_count(runtime, &helicity_count));
+    CHECK(rusticol_runtime_color_count(runtime, &color_count));
+    if (getenv("RUSTICOL_EXPECT_CONTRACTED_COLOR") != NULL) {
+        char *contracted_color_id = get_id(runtime, rusticol_runtime_color_id, 0);
+        const char *contracted_color_ids[] = {contracted_color_id};
+        const uint32_t contracted_colors[] = {0, 0, 0, 0, 0, 0, 0, 0};
+        double contracted_output[8];
+        if (contracted_color_id == NULL) return 40;
+        if (rusticol_runtime_evaluate_selected_f64(
+                runtime, momenta, momenta_count, point_count,
+                NULL, 0, contracted_color_ids, 1, NULL, 0, NULL, 0,
+                contracted_output, point_count) != RUSTICOL_STATUS_INVALID_ARGUMENT) return 41;
+        if (rusticol_runtime_evaluate_selected_f64(
+                runtime, momenta, momenta_count, point_count,
+                NULL, 0, NULL, 0, NULL, 0, contracted_colors, point_count,
+                contracted_output, point_count) != RUSTICOL_STATUS_INVALID_ARGUMENT) return 42;
+        free(contracted_color_id);
+        CHECK(rusticol_runtime_free(runtime));
+        free(momenta);
+        puts("ok");
+        return 0;
+    }
+    if (helicity_count < 2 || color_count < 2) return 4;
+    char *helicity_id = get_id(runtime, rusticol_runtime_helicity_id, 0);
+    char *color_id = get_id(runtime, rusticol_runtime_color_id, 0);
+    if (helicity_id == NULL || color_id == NULL) return 5;
+    const char *helicity_ids[] = {helicity_id};
+    const char *color_ids[] = {color_id};
+    const uint32_t homogeneous_helicities[] = {0, 0, 0, 0, 0, 0, 0, 0};
+    const uint32_t homogeneous_colors[] = {0, 0, 0, 0, 0, 0, 0, 0};
+    const uint32_t pooled_helicities[] = {0, 0, 0, 0, 1, 1, 1, 1};
+    const uint32_t pooled_colors[] = {1, 1, 1, 1, 0, 0, 0, 0};
+    const uint32_t helicities[] = {0, 1, 0, 1, 0, 1, 0, 1};
+    const uint32_t colors[] = {1, 0, 1, 0, 1, 0, 1, 0};
+    const uint32_t random_helicities[] = {0, 0, 0, 1, 0, 1, 1, 1};
+    const uint32_t random_colors[] = {1, 1, 0, 1, 1, 1, 0, 1};
+    const uint32_t short_selectors[] = {0};
+    const uint32_t invalid_selectors[] = {
+        UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX,
+        UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX
+    };
+
+    double *resolved = malloc(point_count * helicity_count * color_count * sizeof(double));
+    double selected[8];
+    size_t returned_helicities = 0, returned_colors = 0;
+    if (resolved == NULL) return 6;
+    CHECK(rusticol_runtime_evaluate_resolved_f64(
+        runtime, momenta, momenta_count, point_count,
+        NULL, 0, NULL, 0, resolved, point_count * helicity_count * color_count,
+        &returned_helicities, &returned_colors));
+    if (returned_helicities != helicity_count || returned_colors != color_count) return 7;
+
+    CHECK(rusticol_runtime_evaluate_selected_f64(
+        runtime, momenta, momenta_count, point_count,
+        NULL, 0, NULL, 0, NULL, 0, NULL, 0, selected, point_count));
+    for (size_t point = 0; point < point_count; ++point) {
+        double expected = 0.0;
+        for (size_t helicity = 0; helicity < helicity_count; ++helicity)
+            for (size_t color = 0; color < color_count; ++color)
+                expected += component(resolved, point, helicity, color, helicity_count, color_count);
+        if (!close_value(selected[point], expected)) return 19;
+    }
+
+    CHECK(rusticol_runtime_evaluate_selected_f64(
+        runtime, momenta, momenta_count, point_count,
+        helicity_ids, 1, color_ids, 1, NULL, 0, NULL, 0, selected, point_count));
+    for (size_t point = 0; point < point_count; ++point)
+        if (!close_value(selected[point], component(resolved, point, 0, 0, helicity_count, color_count))) return 20;
+
+    CHECK(rusticol_runtime_evaluate_selected_f64(
+        runtime, momenta, momenta_count, point_count,
+        helicity_ids, 1, NULL, 0, NULL, 0, NULL, 0, selected, point_count));
+    for (size_t point = 0; point < point_count; ++point) {
+        double expected = 0.0;
+        for (size_t color = 0; color < color_count; ++color)
+            expected += component(resolved, point, 0, color, helicity_count, color_count);
+        if (!close_value(selected[point], expected)) return 25;
+    }
+
+    CHECK(rusticol_runtime_evaluate_selected_f64(
+        runtime, momenta, momenta_count, point_count,
+        NULL, 0, color_ids, 1, NULL, 0, NULL, 0, selected, point_count));
+    for (size_t point = 0; point < point_count; ++point) {
+        double expected = 0.0;
+        for (size_t helicity = 0; helicity < helicity_count; ++helicity)
+            expected += component(resolved, point, helicity, 0, helicity_count, color_count);
+        if (!close_value(selected[point], expected)) return 26;
+    }
+
+    int pattern_status = check_pattern(
+        runtime, momenta, momenta_count, point_count,
+        homogeneous_helicities, homogeneous_colors, resolved,
+        helicity_count, color_count, 21);
+    if (pattern_status != 0) return pattern_status;
+    pattern_status = check_pattern(
+        runtime, momenta, momenta_count, point_count,
+        pooled_helicities, pooled_colors, resolved,
+        helicity_count, color_count, 22);
+    if (pattern_status != 0) return pattern_status;
+    pattern_status = check_pattern(
+        runtime, momenta, momenta_count, point_count,
+        helicities, colors, resolved, helicity_count, color_count, 23);
+    if (pattern_status != 0) return pattern_status;
+    pattern_status = check_pattern(
+        runtime, momenta, momenta_count, point_count,
+        random_helicities, random_colors, resolved,
+        helicity_count, color_count, 24);
+    if (pattern_status != 0) return pattern_status;
+
+    CHECK(rusticol_runtime_evaluate_selected_f64(
+        runtime, momenta, momenta_count, point_count,
+        NULL, 0, NULL, 0, helicities, point_count, NULL, 0, selected, point_count));
+    for (size_t point = 0; point < point_count; ++point) {
+        double expected = 0.0;
+        for (size_t color = 0; color < color_count; ++color)
+            expected += component(resolved, point, helicities[point], color, helicity_count, color_count);
+        if (!close_value(selected[point], expected)) return 25;
+    }
+
+    CHECK(rusticol_runtime_evaluate_selected_f64(
+        runtime, momenta, momenta_count, point_count,
+        NULL, 0, NULL, 0, NULL, 0, colors, point_count, selected, point_count));
+    for (size_t point = 0; point < point_count; ++point) {
+        double expected = 0.0;
+        for (size_t helicity = 0; helicity < helicity_count; ++helicity)
+            expected += component(resolved, point, helicity, colors[point], helicity_count, color_count);
+        if (!close_value(selected[point], expected)) return 26;
+    }
+
+    if (rusticol_runtime_evaluate_selected_f64(runtime, momenta, momenta_count,
+            point_count, helicity_ids, 1, NULL, 0, homogeneous_helicities, point_count, NULL, 0, selected, point_count)
+        != RUSTICOL_STATUS_INVALID_ARGUMENT) return 30;
+    if (rusticol_runtime_evaluate_selected_f64(runtime, momenta, momenta_count,
+            point_count, NULL, 0, color_ids, 1, NULL, 0, homogeneous_colors, point_count, selected, point_count)
+        != RUSTICOL_STATUS_INVALID_ARGUMENT) return 31;
+    if (rusticol_runtime_evaluate_selected_f64(runtime, momenta, momenta_count,
+            point_count, NULL, 0, NULL, 0, short_selectors, 1, NULL, 0, selected, point_count)
+        != RUSTICOL_STATUS_INVALID_ARGUMENT) return 32;
+    if (rusticol_runtime_evaluate_selected_f64(runtime, momenta, momenta_count,
+            point_count, NULL, 0, NULL, 0, NULL, 0, short_selectors, 1, selected, point_count)
+        != RUSTICOL_STATUS_INVALID_ARGUMENT) return 33;
+    if (rusticol_runtime_evaluate_selected_f64(runtime, momenta, momenta_count,
+            point_count, NULL, 0, NULL, 0, invalid_selectors, point_count, NULL, 0, selected, point_count)
+        != RUSTICOL_STATUS_INVALID_ARGUMENT) return 34;
+    if (rusticol_runtime_evaluate_selected_f64(runtime, momenta, momenta_count,
+            point_count, NULL, 0, NULL, 0, NULL, 0, invalid_selectors, point_count, selected, point_count)
+        != RUSTICOL_STATUS_INVALID_ARGUMENT) return 35;
+
+    CHECK(rusticol_runtime_free(runtime));
+    free(resolved);
+    free(color_id);
+    free(helicity_id);
+    free(momenta);
+    puts("ok");
+    return 0;
+}
+"""
+
+
+_CPP_PROBE = r"""
+#include <rusticol.hpp>
+#include <cmath>
+#include <cstdlib>
+#include <cstdint>
+#include <iostream>
+#include <limits>
+#include <string>
+#include <vector>
+
+static bool close_value(double actual, double expected) {
+    const double scale = std::max(std::abs(actual), std::abs(expected));
+    return std::abs(actual - expected) <= 1.0e-15 + 1.0e-12 * scale;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 4) return 2;
+    constexpr std::size_t point_count = 8;
+    std::vector<double> momenta;
+    for (int index = 3; index < argc; ++index) momenta.push_back(std::stod(argv[index]));
+    if (momenta.size() % point_count != 0) return 2;
+    rusticol::Runtime runtime(argv[1], argv[2]);
+    const auto helicities_metadata = runtime.helicities();
+    const auto colors_metadata = runtime.colors();
+    if (std::getenv("RUSTICOL_EXPECT_CONTRACTED_COLOR") != nullptr) {
+        const std::vector<std::uint32_t> point_colors(point_count, 0);
+        const auto rejects = [&](const std::vector<std::string> &global_colors,
+                                 const std::vector<std::uint32_t> &per_point_colors) {
+            try {
+                (void)runtime.evaluate_selected(
+                    momenta, point_count, {}, global_colors, {}, per_point_colors);
+            } catch (const rusticol::Error &) {
+                return true;
+            }
+            return false;
+        };
+        if (!rejects({colors_metadata[0].id}, {})) return 40;
+        if (!rejects({}, point_colors)) return 41;
+        std::cout << "ok\n";
+        return 0;
+    }
+    if (helicities_metadata.size() < 2 || colors_metadata.size() < 2) return 3;
+    const auto resolved = runtime.evaluate_resolved(momenta, point_count);
+    const std::vector<std::uint32_t> homogeneous(point_count, 0);
+    const std::vector<std::uint32_t> pooled_helicities{0, 0, 0, 0, 1, 1, 1, 1};
+    const std::vector<std::uint32_t> pooled_colors{1, 1, 1, 1, 0, 0, 0, 0};
+    const std::vector<std::uint32_t> helicities{0, 1, 0, 1, 0, 1, 0, 1};
+    const std::vector<std::uint32_t> colors{1, 0, 1, 0, 1, 0, 1, 0};
+    const std::vector<std::uint32_t> random_helicities{0, 0, 0, 1, 0, 1, 1, 1};
+    const std::vector<std::uint32_t> random_colors{1, 1, 0, 1, 1, 1, 0, 1};
+
+    const auto all = runtime.evaluate_selected(momenta, point_count);
+
+    const auto global = runtime.evaluate_selected(
+        momenta, point_count, {helicities_metadata[0].id}, {colors_metadata[0].id});
+    const auto global_helicity_only = runtime.evaluate_selected(
+        momenta, point_count, {helicities_metadata[0].id}, {});
+    const auto global_color_only = runtime.evaluate_selected(
+        momenta, point_count, {}, {colors_metadata[0].id});
+    const auto homogeneous_values = runtime.evaluate_selected(
+        momenta, point_count, {}, {}, homogeneous, homogeneous);
+    const auto pooled = runtime.evaluate_selected(
+        momenta, point_count, {}, {}, pooled_helicities, pooled_colors);
+    const auto alternating = runtime.evaluate_selected(
+        momenta, point_count, {}, {}, helicities, colors);
+    const auto seeded_random = runtime.evaluate_selected(
+        momenta, point_count, {}, {}, random_helicities, random_colors);
+    const auto helicity_only = runtime.evaluate_selected(
+        momenta, point_count, {}, {}, helicities, {});
+    const auto color_only = runtime.evaluate_selected(
+        momenta, point_count, {}, {}, {}, colors);
+    for (std::size_t point = 0; point < point_count; ++point) {
+        double expected_all = 0.0;
+        for (std::size_t helicity = 0; helicity < helicities_metadata.size(); ++helicity)
+            for (std::size_t color = 0; color < colors_metadata.size(); ++color)
+                expected_all += resolved(point, helicity, color);
+        if (!close_value(all[point], expected_all)) return 19;
+        if (!close_value(global[point], resolved(point, 0, 0))) return 20;
+        double expected_global_helicity = 0.0;
+        for (std::size_t color = 0; color < colors_metadata.size(); ++color)
+            expected_global_helicity += resolved(point, 0, color);
+        if (!close_value(global_helicity_only[point], expected_global_helicity)) return 25;
+        double expected_global_color = 0.0;
+        for (std::size_t helicity = 0; helicity < helicities_metadata.size(); ++helicity)
+            expected_global_color += resolved(point, helicity, 0);
+        if (!close_value(global_color_only[point], expected_global_color)) return 26;
+        if (!close_value(homogeneous_values[point], resolved(point, 0, 0))) return 21;
+        if (!close_value(
+                pooled[point],
+                resolved(point, pooled_helicities[point], pooled_colors[point]))) return 27;
+        if (!close_value(alternating[point], resolved(point, helicities[point], colors[point]))) return 22;
+        if (!close_value(
+                seeded_random[point],
+                resolved(point, random_helicities[point], random_colors[point]))) return 28;
+        double expected_helicity = 0.0;
+        for (std::size_t color = 0; color < colors_metadata.size(); ++color)
+            expected_helicity += resolved(point, helicities[point], color);
+        if (!close_value(helicity_only[point], expected_helicity)) return 23;
+        double expected_color = 0.0;
+        for (std::size_t helicity = 0; helicity < helicities_metadata.size(); ++helicity)
+            expected_color += resolved(point, helicity, colors[point]);
+        if (!close_value(color_only[point], expected_color)) return 24;
+    }
+
+    const auto rejects = [&](const std::vector<std::string> &global_helicities,
+                             const std::vector<std::string> &global_colors,
+                             const std::vector<std::uint32_t> &point_helicities,
+                             const std::vector<std::uint32_t> &point_colors) {
+        try {
+            (void)runtime.evaluate_selected(
+                momenta, point_count, global_helicities, global_colors, point_helicities, point_colors);
+        } catch (const rusticol::Error &) {
+            return true;
+        }
+        return false;
+    };
+    if (!rejects({helicities_metadata[0].id}, {}, homogeneous, {})) return 30;
+    if (!rejects({}, {colors_metadata[0].id}, {}, homogeneous)) return 31;
+    if (!rejects({}, {}, {0}, {})) return 32;
+    if (!rejects({}, {}, {}, {0})) return 33;
+    const std::vector<std::uint32_t> invalid(point_count, std::numeric_limits<std::uint32_t>::max());
+    if (!rejects({}, {}, invalid, {})) return 34;
+    if (!rejects({}, {}, {}, invalid)) return 35;
+    std::cout << "ok\n";
+    return 0;
+}
+"""
+
+
+_RUST_PROBE = r"""
+#[allow(dead_code)]
+mod rusticol {
+    include!(env!("RUSTICOL_RUST_SOURCE"));
+}
+
+use rusticol::{ErrorKind, Runtime, Selectors};
+
+fn close_value(actual: f64, expected: f64) -> bool {
+    (actual - expected).abs() <= 1.0e-15 + 1.0e-12 * actual.abs().max(expected.abs())
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let arguments = std::env::args().collect::<Vec<_>>();
+    if arguments.len() < 4 {
+        return Err("missing artifact, process, or momenta".into());
+    }
+    const POINT_COUNT: usize = 8;
+    let momenta = arguments[3..]
+        .iter()
+        .map(|value| value.parse::<f64>())
+        .collect::<Result<Vec<_>, _>>()?;
+    assert_eq!(momenta.len() % POINT_COUNT, 0);
+    let mut runtime = Runtime::load(&arguments[1], Some(&arguments[2]), None)?;
+    let metadata_helicities = runtime.helicities()?;
+    let metadata_colors = runtime.colors()?;
+    if std::env::var_os("RUSTICOL_EXPECT_CONTRACTED_COLOR").is_some() {
+        let point_colors = [0_u32; POINT_COUNT];
+        let global_color = Selectors::all().with_colors([metadata_colors[0].id.clone()]);
+        for result in [
+            runtime.evaluate_selected_f64(&momenta, POINT_COUNT, &global_color, None, None),
+            runtime.evaluate_selected_f64(
+                &momenta,
+                POINT_COUNT,
+                &Selectors::all(),
+                None,
+                Some(&point_colors),
+            ),
+        ] {
+            assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidArgument);
+        }
+        println!("ok");
+        return Ok(());
+    }
+    assert!(metadata_helicities.len() >= 2 && metadata_colors.len() >= 2);
+    let resolved = runtime.evaluate_resolved_f64(&momenta, POINT_COUNT, &Selectors::all())?;
+    let homogeneous = [0_u32; POINT_COUNT];
+    let pooled_helicities = [0_u32, 0, 0, 0, 1, 1, 1, 1];
+    let pooled_colors = [1_u32, 1, 1, 1, 0, 0, 0, 0];
+    let helicities = [0_u32, 1, 0, 1, 0, 1, 0, 1];
+    let colors = [1_u32, 0, 1, 0, 1, 0, 1, 0];
+    let random_helicities = [0_u32, 0, 0, 1, 0, 1, 1, 1];
+    let random_colors = [1_u32, 1, 0, 1, 1, 1, 0, 1];
+    let global_selectors = Selectors::all()
+        .with_helicities([metadata_helicities[0].id.clone()])
+        .with_colors([metadata_colors[0].id.clone()]);
+    let global_helicity = Selectors::all().with_helicities([metadata_helicities[0].id.clone()]);
+    let global_color = Selectors::all().with_colors([metadata_colors[0].id.clone()]);
+
+    let all = runtime.evaluate_selected_f64(
+        &momenta, POINT_COUNT, &Selectors::all(), None, None)?;
+    let global = runtime.evaluate_selected_f64(
+        &momenta, POINT_COUNT, &global_selectors, None, None)?;
+    let global_helicity_only =
+        runtime.evaluate_selected_f64(&momenta, POINT_COUNT, &global_helicity, None, None)?;
+    let global_color_only =
+        runtime.evaluate_selected_f64(&momenta, POINT_COUNT, &global_color, None, None)?;
+    let homogeneous_values = runtime.evaluate_selected_f64(
+        &momenta, POINT_COUNT, &Selectors::all(), Some(&homogeneous), Some(&homogeneous))?;
+    let pooled = runtime.evaluate_selected_f64(
+        &momenta,
+        POINT_COUNT,
+        &Selectors::all(),
+        Some(&pooled_helicities),
+        Some(&pooled_colors),
+    )?;
+    let alternating = runtime.evaluate_selected_f64(
+        &momenta, POINT_COUNT, &Selectors::all(), Some(&helicities), Some(&colors))?;
+    let seeded_random = runtime.evaluate_selected_f64(
+        &momenta,
+        POINT_COUNT,
+        &Selectors::all(),
+        Some(&random_helicities),
+        Some(&random_colors),
+    )?;
+    let helicity_only = runtime.evaluate_selected_f64(
+        &momenta, POINT_COUNT, &Selectors::all(), Some(&helicities), None)?;
+    let color_only = runtime.evaluate_selected_f64(
+        &momenta, POINT_COUNT, &Selectors::all(), None, Some(&colors))?;
+    for point in 0..POINT_COUNT {
+        let mut expected_all = 0.0;
+        for helicity in 0..metadata_helicities.len() {
+            for color in 0..metadata_colors.len() {
+                expected_all += resolved.get(point, helicity, color).unwrap();
+            }
+        }
+        assert!(close_value(all[point], expected_all));
+        assert!(close_value(global[point], resolved.get(point, 0, 0).unwrap()));
+        let expected_global_helicity = (0..metadata_colors.len())
+            .map(|color| resolved.get(point, 0, color).unwrap())
+            .sum();
+        assert!(close_value(global_helicity_only[point], expected_global_helicity));
+        let expected_global_color = (0..metadata_helicities.len())
+            .map(|helicity| resolved.get(point, helicity, 0).unwrap())
+            .sum();
+        assert!(close_value(global_color_only[point], expected_global_color));
+        assert!(close_value(homogeneous_values[point], resolved.get(point, 0, 0).unwrap()));
+        assert!(close_value(
+            pooled[point],
+            resolved
+                .get(
+                    point,
+                    pooled_helicities[point] as usize,
+                    pooled_colors[point] as usize,
+                )
+                .unwrap()
+        ));
+        assert!(close_value(
+            alternating[point],
+            resolved.get(point, helicities[point] as usize, colors[point] as usize).unwrap()
+        ));
+        assert!(close_value(
+            seeded_random[point],
+            resolved
+                .get(
+                    point,
+                    random_helicities[point] as usize,
+                    random_colors[point] as usize,
+                )
+                .unwrap()
+        ));
+        let expected_helicity = (0..metadata_colors.len())
+            .map(|color| resolved.get(point, helicities[point] as usize, color).unwrap())
+            .sum();
+        assert!(close_value(helicity_only[point], expected_helicity));
+        let expected_color = (0..metadata_helicities.len())
+            .map(|helicity| resolved.get(point, helicity, colors[point] as usize).unwrap())
+            .sum();
+        assert!(close_value(color_only[point], expected_color));
+    }
+
+    let invalid = [u32::MAX; POINT_COUNT];
+    for result in [
+        runtime.evaluate_selected_f64(
+            &momenta, POINT_COUNT, &global_helicity, Some(&homogeneous), None),
+        runtime.evaluate_selected_f64(
+            &momenta, POINT_COUNT, &global_color, None, Some(&homogeneous)),
+        runtime.evaluate_selected_f64(
+            &momenta, POINT_COUNT, &Selectors::all(), Some(&[0]), None),
+        runtime.evaluate_selected_f64(
+            &momenta, POINT_COUNT, &Selectors::all(), None, Some(&[0])),
+        runtime.evaluate_selected_f64(
+            &momenta, POINT_COUNT, &Selectors::all(), Some(&invalid), None),
+        runtime.evaluate_selected_f64(
+            &momenta, POINT_COUNT, &Selectors::all(), None, Some(&invalid)),
+    ] {
+        assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidArgument);
+    }
+    println!("ok");
+    Ok(())
+}
+"""
+
+
+_FORTRAN_PROBE = r"""
+program selector_probe
+  use, intrinsic :: iso_c_binding
+  use rusticol
+  implicit none
+  type(rusticol_runtime) :: runtime
+  type(rusticol_helicity_configuration), allocatable :: helicity_metadata(:)
+  type(rusticol_color_component), allocatable :: color_metadata(:)
+  character(len=4096) :: artifact, process, argument
+  character(len=1) :: contracted_mode
+  character(len=256) :: helicity_ids(1), color_ids(1)
+  real(c_double), allocatable, target :: momenta(:)
+  real(c_double), allocatable, target :: resolved(:, :, :), selected(:)
+  integer(c_int32_t), target :: homogeneous(8), pooled_helicities(8), pooled_colors(8)
+  integer(c_int32_t), target :: helicities(8), colors(8), random_helicities(8), random_colors(8)
+  integer(c_int32_t), target :: short_selector(1), invalid(8)
+  integer(c_int) :: status, environment_status
+  integer, parameter :: point_count = 8
+  integer :: argument_count, point, index, helicity, color
+  real(c_double) :: expected, scale
+
+  argument_count = command_argument_count()
+  if (argument_count < 3) stop 2
+  call get_command_argument(1, artifact)
+  call get_command_argument(2, process)
+  allocate(momenta(argument_count - 2))
+  if (mod(size(momenta), point_count) /= 0) stop 2
+  do index = 3, argument_count
+    call get_command_argument(index, argument)
+    read(argument, *) momenta(index - 2)
+  end do
+
+  call runtime%load(trim(artifact), trim(process), ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 10
+  helicity_metadata = runtime%helicities(ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 11
+  color_metadata = runtime%colors(ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 12
+  if (size(color_metadata) < 1) stop 13
+  color_ids(1) = color_metadata(1)%id
+  homogeneous = 0_c_int32_t
+  call get_environment_variable("RUSTICOL_EXPECT_CONTRACTED_COLOR", contracted_mode, &
+      status=environment_status)
+  if (environment_status == 0) then
+    call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+        color_ids=color_ids, ierr=status)
+    if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 40
+    call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+        color_flow_by_point=homogeneous, ierr=status)
+    if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 41
+    call runtime%close()
+    write(*, '(A)') 'ok'
+    stop
+  end if
+  if (size(helicity_metadata) < 2 .or. size(color_metadata) < 2) stop 13
+  helicity_ids(1) = helicity_metadata(1)%id
+  pooled_helicities = [0_c_int32_t, 0_c_int32_t, 0_c_int32_t, 0_c_int32_t, &
+      1_c_int32_t, 1_c_int32_t, 1_c_int32_t, 1_c_int32_t]
+  pooled_colors = [1_c_int32_t, 1_c_int32_t, 1_c_int32_t, 1_c_int32_t, &
+      0_c_int32_t, 0_c_int32_t, 0_c_int32_t, 0_c_int32_t]
+  helicities = [0_c_int32_t, 1_c_int32_t, 0_c_int32_t, 1_c_int32_t, &
+      0_c_int32_t, 1_c_int32_t, 0_c_int32_t, 1_c_int32_t]
+  colors = [1_c_int32_t, 0_c_int32_t, 1_c_int32_t, 0_c_int32_t, &
+      1_c_int32_t, 0_c_int32_t, 1_c_int32_t, 0_c_int32_t]
+  random_helicities = [0_c_int32_t, 0_c_int32_t, 0_c_int32_t, 1_c_int32_t, &
+      0_c_int32_t, 1_c_int32_t, 1_c_int32_t, 1_c_int32_t]
+  random_colors = [1_c_int32_t, 1_c_int32_t, 0_c_int32_t, 1_c_int32_t, &
+      1_c_int32_t, 1_c_int32_t, 0_c_int32_t, 1_c_int32_t]
+  short_selector = [0_c_int32_t]
+  invalid = huge(0_c_int32_t)
+
+  call runtime%evaluate_resolved(momenta, int(point_count, c_size_t), resolved, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 14
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 18
+  do point = 1, point_count
+    expected = sum(resolved(:, :, point))
+    if (.not. close_value(selected(point), expected)) stop 19
+  end do
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      helicity_ids=helicity_ids, color_ids=color_ids, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 20
+  do point = 1, point_count
+    if (.not. close_value(selected(point), resolved(1, 1, point))) stop 21
+  end do
+
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      helicity_ids=helicity_ids, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 40
+  do point = 1, point_count
+    expected = sum(resolved(:, 1, point))
+    if (.not. close_value(selected(point), expected)) stop 41
+  end do
+
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      color_ids=color_ids, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 42
+  do point = 1, point_count
+    expected = sum(resolved(1, :, point))
+    if (.not. close_value(selected(point), expected)) stop 43
+  end do
+
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      helicity_by_point=homogeneous, color_flow_by_point=homogeneous, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 22
+  do point = 1, point_count
+    if (.not. close_value(selected(point), resolved(1, 1, point))) stop 23
+  end do
+
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      helicity_by_point=pooled_helicities, color_flow_by_point=pooled_colors, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 24
+  do point = 1, point_count
+    if (.not. close_value(selected(point), &
+        resolved(pooled_colors(point) + 1, pooled_helicities(point) + 1, point))) stop 25
+  end do
+
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      helicity_by_point=helicities, color_flow_by_point=colors, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 26
+  do point = 1, point_count
+    if (.not. close_value(selected(point), &
+        resolved(colors(point) + 1, helicities(point) + 1, point))) stop 27
+  end do
+
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      helicity_by_point=random_helicities, color_flow_by_point=random_colors, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 28
+  do point = 1, point_count
+    if (.not. close_value(selected(point), &
+        resolved(random_colors(point) + 1, random_helicities(point) + 1, point))) stop 29
+  end do
+
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      helicity_by_point=helicities, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 50
+  do point = 1, point_count
+    expected = 0.0_c_double
+    do color = 1, size(color_metadata)
+      expected = expected + resolved(color, helicities(point) + 1, point)
+    end do
+    if (.not. close_value(selected(point), expected)) stop 51
+  end do
+
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      color_flow_by_point=colors, ierr=status)
+  if (status /= RUSTICOL_STATUS_OK) stop 52
+  do point = 1, point_count
+    expected = 0.0_c_double
+    do helicity = 1, size(helicity_metadata)
+      expected = expected + resolved(colors(point) + 1, helicity, point)
+    end do
+    if (.not. close_value(selected(point), expected)) stop 53
+  end do
+
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      helicity_ids=helicity_ids, helicity_by_point=homogeneous, ierr=status)
+  if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 30
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      color_ids=color_ids, color_flow_by_point=homogeneous, ierr=status)
+  if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 31
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      helicity_by_point=short_selector, ierr=status)
+  if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 32
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      color_flow_by_point=short_selector, ierr=status)
+  if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 33
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      helicity_by_point=invalid, ierr=status)
+  if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 34
+  call runtime%evaluate_selected(momenta, int(point_count, c_size_t), selected, &
+      color_flow_by_point=invalid, ierr=status)
+  if (status /= RUSTICOL_STATUS_INVALID_ARGUMENT) stop 35
+
+  call runtime%close()
+  write(*, '(A)') 'ok'
+
+contains
+  logical function close_value(actual, wanted)
+    real(c_double), intent(in) :: actual, wanted
+    scale = max(abs(actual), abs(wanted))
+    close_value = abs(actual - wanted) <= 1.0e-15_c_double + 1.0e-12_c_double * scale
+  end function close_value
+end program selector_probe
+"""
+
+
+def _compile_probe(
+    language: str,
+    source_text: str,
+    native_sdk: _NativeSdk,
+    directory: Path,
+) -> Path:
+    suffix = {"c": ".c", "cpp": ".cpp", "fortran": ".f90", "rust": ".rs"}[language]
+    source = directory / f"selector_probe{suffix}"
+    source.write_text(textwrap.dedent(source_text).lstrip(), encoding="utf-8")
+    binary = directory / f"selector_probe_{language}"
+    sdk = native_sdk.config
+    if language == "c":
+        command = [
+            native_sdk.cc,
+            "-std=c11",
+            "-Wall",
+            "-Wextra",
+            "-pedantic",
+            *sdk["cflags"],
+            str(source),
+            "-o",
+            str(binary),
+            *sdk["link_flags"],
+        ]
+    elif language == "cpp":
+        command = [
+            native_sdk.cxx,
+            "-std=c++17",
+            "-Wall",
+            "-Wextra",
+            "-pedantic",
+            *sdk["cflags"],
+            str(source),
+            "-o",
+            str(binary),
+            *sdk["link_flags"],
+        ]
+    elif language == "fortran":
+        command = [
+            native_sdk.fortran,
+            "-std=f2008",
+            "-ffree-line-length-none",
+            f"-J{directory}",
+            sdk["fortran_source"],
+            str(source),
+            "-o",
+            str(binary),
+            *sdk["link_flags"],
+        ]
+    else:
+        command = [
+            native_sdk.rustc,
+            "--edition=2021",
+            "-Dwarnings",
+            str(source),
+            "-o",
+            str(binary),
+            *sdk["rust_flags"],
+        ]
+    environment = _source_environment()
+    if language == "rust":
+        environment["RUSTICOL_RUST_SOURCE"] = sdk["rust_source"]
+    completed = subprocess.run(
+        command,
+        cwd=directory,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=180,
+    )
+    assert completed.returncode == 0, (
+        f"{language} selector probe failed to compile\n"
+        f"stdout:\n{completed.stdout}\nstderr:\n{completed.stderr}"
+    )
+    return binary
+
+
+@pytest.mark.parametrize(
+    ("language", "source"),
+    (
+        ("c", _C_PROBE),
+        ("cpp", _CPP_PROBE),
+        ("fortran", _FORTRAN_PROBE),
+        ("rust", _RUST_PROBE),
+    ),
+)
+def test_native_selector_api_parity(
+    language: str,
+    source: str,
+    selector_artifact: Path,
+    native_sdk: _NativeSdk,
+    tmp_path: Path,
+) -> None:
+    binary = _compile_probe(language, source, native_sdk, tmp_path)
+    points = _phase_space_points(selector_artifact)
+    command = [
+        str(binary),
+        str(selector_artifact),
+        "dd_zgg",
+        *(
+            format(component, ".17g")
+            for point in points
+            for leg in point
+            for component in leg
+        ),
+    ]
+    completed = subprocess.run(
+        command,
+        env=_source_environment(),
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    assert completed.returncode == 0, (
+        f"{language} selector probe failed\n"
+        f"stdout:\n{completed.stdout}\nstderr:\n{completed.stderr}"
+    )
+    assert completed.stdout.strip() == "ok"
+
+
+@pytest.mark.parametrize(
+    ("language", "source"),
+    (
+        ("c", _C_PROBE),
+        ("cpp", _CPP_PROBE),
+        ("fortran", _FORTRAN_PROBE),
+        ("rust", _RUST_PROBE),
+    ),
+)
+def test_native_color_selectors_reject_contracted_axis(
+    language: str,
+    source: str,
+    contracted_selector_artifact: Path,
+    native_sdk: _NativeSdk,
+    tmp_path: Path,
+) -> None:
+    binary = _compile_probe(language, source, native_sdk, tmp_path)
+    points = _phase_space_points(contracted_selector_artifact)
+    command = [
+        str(binary),
+        str(contracted_selector_artifact),
+        "dd_zgg",
+        *(
+            format(component, ".17g")
+            for point in points
+            for leg in point
+            for component in leg
+        ),
+    ]
+    environment = _source_environment()
+    environment["RUSTICOL_EXPECT_CONTRACTED_COLOR"] = "1"
+    completed = subprocess.run(
+        command,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    assert completed.returncode == 0, (
+        f"{language} contracted-color selector probe failed\n"
+        f"stdout:\n{completed.stdout}\nstderr:\n{completed.stderr}"
+    )
+    assert completed.stdout.strip() == "ok"
diff --git a/pyamplicol/tests/integration/test_schema_v3_generation_runtime.py b/pyamplicol/tests/integration/test_schema_v3_generation_runtime.py
new file mode 100644
index 0000000000..64e42244a5
--- /dev/null
+++ b/pyamplicol/tests/integration/test_schema_v3_generation_runtime.py
@@ -0,0 +1,1197 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import shutil
+import tomllib
+import warnings
+from collections.abc import Iterator
+from decimal import Decimal, localcontext
+from pathlib import Path
+from typing import Any, NoReturn
+
+import pytest
+
+from pyamplicol import (
+    BenchmarkConfig,
+    BenchmarkRunner,
+    CompiledModel,
+    Generator,
+    ModelSource,
+    ProcessSet,
+    Runtime,
+)
+from pyamplicol.api.errors import EvaluationError
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ModelConfig,
+    RunConfig,
+)
+from pyamplicol.generation.phase_space import massive_rambo_final_state
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.base import Model
+from pyamplicol.models.builtin.validation import generic_validation_point
+from tools.developer.analytic_oracles import (
+    scalar_contact_2to2,
+    scalar_gravity_2to2,
+)
+from tools.developer.reference_fixture import load_reference_fixture
+
+REFERENCE_ROOT = Path(__file__).resolve().parents[1] / "fixtures" / "reference"
+REFERENCE = REFERENCE_ROOT / "physics-v2.json"
+_VALIDATED_REFERENCE_FIXTURE = load_reference_fixture(
+    REFERENCE,
+    (
+        REFERENCE_ROOT / "legacy-fortran-v2.json",
+        REFERENCE_ROOT / "analytic-oracles-v2.json",
+    ),
+)
+REFERENCE_PAYLOAD = json.loads(REFERENCE.read_text(encoding="utf-8"))
+CASE_NAMES = {
+    "lc": "case:sm_ddbar_z:lc",
+    "nlc": "case:sm_ddbar_z:nlc",
+    "full": "case:sm_ddbar_z:full",
+}
+MODEL_ASSETS = Path(__file__).resolve().parents[2] / "src/pyamplicol/assets/models"
+EXTERNAL_CASES = {
+    "scalars_2to2_lc": MODEL_ASSETS / "json/scalars/scalars.json",
+    "scalar_gravity_2to2_lc": (
+        MODEL_ASSETS / "json/scalar_gravity/scalar_gravity.json"
+    ),
+}
+EXTERNAL_SM_SOURCES = {
+    "json": MODEL_ASSETS / "json/sm/sm.json",
+    "ufo": MODEL_ASSETS / "ufo/sm",
+}
+EXTERNAL_SM_PROCESS_IDS = (
+    "sm_ddbar_z",
+    "sm_udbar_wplus",
+    "sm_ddbar_zg",
+    "sm_ddbar_ee",
+    "sm_ddbar_uubar",
+    "sm_ddbar_ddbar",
+    "sm_gg_gg",
+    "sm_gg_ttbar",
+    "sm_ddbar_zgg",
+)
+NAMED_CASE_IDS = {
+    "builtin_sm_ddbar_zg_lc": "case:sm_ddbar_zg:lc",
+    "scalars_2to2_lc": "case:scalars_2to2:lc",
+    "scalar_gravity_2to2_lc": "case:scalar_gravity_2to2:lc",
+}
+# The immutable physics-v2 oracle was captured with the former rounded default.
+_HISTORICAL_REFERENCE_ALPHA_EW = 0.007546771114
+
+
+def _unavailable(reason: str) -> NoReturn:
+    if os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1":
+        pytest.fail(reason)
+    pytest.skip(reason)
+
+
+@pytest.fixture(scope="module")
+def builtin_sm_eager_compiled_jit_o2_model(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Iterator[CompiledModel]:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    if importlib.util.find_spec("symbolica") is None:
+        _unavailable("Symbolica is unavailable")
+    root = tmp_path_factory.mktemp("builtin-sm-eager-compiled-jit-o2")
+    try:
+        yield ModelSource.built_in_sm().compile(
+            cache_dir=root / "model-cache",
+            prepared_output=root / "built-in-sm-jit-o2.pyamplicol-model",
+            evaluator=EvaluatorConfig(
+                execution_mode="eager",
+                optimization=EvaluatorOptimizationConfig(cores=1),
+                jit=JITConfig(optimization_level=2),
+            ),
+        )
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+
+def _assert_reusable_helicity_topology(
+    execution: dict[str, Any],
+    *,
+    current_count: int | None = None,
+    interaction_count: int | None = None,
+    amplitude_root_count: int | None = None,
+) -> None:
+    """Check both the compact selector lane and the summed recurrence."""
+
+    primary = execution["dag_summary"]
+    summed = execution["helicity_sum_execution"]["dag_summary"]
+    materialization = execution["runtime_schema"]["helicity_recurrence"][
+        "materialization"
+    ]
+
+    assert materialization["strategy"] == "quotient"
+    assert primary["current_count"] == materialization["materialized_current_count"]
+    assert (
+        primary["amplitude_root_count"] == (materialization["materialized_root_count"])
+    )
+    assert summed["current_count"] == materialization["proof_current_count"]
+    assert summed["amplitude_root_count"] == materialization["proof_root_count"]
+    assert primary["current_count"] <= summed["current_count"]
+    assert primary["interaction_count"] <= summed["interaction_count"]
+    assert primary["amplitude_root_count"] <= summed["amplitude_root_count"]
+    if current_count is not None:
+        assert summed["current_count"] == current_count
+    if interaction_count is not None:
+        assert summed["interaction_count"] == interaction_count
+    if amplitude_root_count is not None:
+        assert summed["amplitude_root_count"] == amplitude_root_count
+
+
+def _assert_reusable_reduction_coverage(
+    execution: dict[str, Any],
+    physics: dict[str, Any],
+) -> None:
+    groups = physics["reduction"]["groups"]
+    assert len(groups) == execution["dag_summary"]["amplitude_root_count"]
+
+    nonzero_helicities = {
+        item["id"] for item in physics["helicities"] if not item["structural_zero"]
+    }
+    represented_helicities = {
+        helicity_id
+        for group in groups
+        for helicity_id in group["physical_helicity_ids"]
+    }
+    assert represented_helicities == nonzero_helicities
+
+    represented_colors = {
+        color_id for group in groups for color_id in group["physical_color_ids"]
+    }
+    available_colors = {component["id"] for component in physics["color_components"]}
+    computed_colors = {
+        component["id"]
+        for component in physics["color_components"]
+        if component.get("computed", True)
+    }
+    assert computed_colors <= represented_colors <= available_colors
+    for group in groups:
+        assert group["representative_helicity_id"] in group["physical_helicity_ids"]
+        assert group["representative_color_id"] in group["physical_color_ids"]
+
+
+@pytest.fixture(autouse=True)
+def _discard_generated_artifacts(tmp_path: Path) -> Iterator[None]:
+    """Keep parameterized generation tests from retaining every large artifact."""
+
+    yield
+    shutil.rmtree(tmp_path, ignore_errors=True)
+
+
+def _case_payload(
+    case_id: str,
+) -> tuple[dict[str, Any], list[Any], dict[str, dict[str, float]]]:
+    case = next(item for item in REFERENCE_PAYLOAD["cases"] if item["id"] == case_id)
+    process = next(
+        item
+        for item in REFERENCE_PAYLOAD["processes"]
+        if item["id"] == case["process_id"]
+    )
+    point_id = case["point_ids"][0]
+    point = next(item for item in REFERENCE_PAYLOAD["points"] if item["id"] == point_id)
+    observation = next(
+        item for item in case["observations"] if item["point_id"] == point_id
+    )
+    helicity_ids = [axis["id"] for axis in case["axes"]["helicities"]]
+    color_ids = [axis["id"] for axis in case["axes"]["colors"]]
+    resolved = {
+        helicity_id: {
+            color_id: float(value)
+            for color_id, value in zip(color_ids, row, strict=True)
+        }
+        for helicity_id, row in zip(helicity_ids, observation["values"], strict=True)
+    }
+    topology = case["topology"]
+    reference = {
+        "process": process["expression"],
+        "process_id": process["id"],
+        "color_accuracy": case["color_accuracy"],
+        "total": float(observation["total"]),
+        "resolved": resolved,
+        "topology": {
+            "current_count": topology["currents"],
+            "interaction_count": topology["interactions"],
+            "amplitude_root_count": topology["roots"],
+            "reduction_group_count": topology["reduction_groups"],
+        },
+    }
+    return reference, [point["momenta"]], resolved
+
+
+def _reference_case(
+    accuracy: str,
+) -> tuple[dict[str, Any], list[Any], dict[str, Any]]:
+    return _case_payload(CASE_NAMES[accuracy])
+
+
+def _named_reference_case(name: str) -> tuple[dict[str, Any], list[Any]]:
+    case, momenta, _resolved = _case_payload(NAMED_CASE_IDS[name])
+    return case, momenta
+
+
+def _write_color_dummy_relabelled_sm(root: Path) -> Path:
+    source = EXTERNAL_SM_SOURCES["json"]
+    raw = json.loads(source.read_text(encoding="utf-8"))
+    vertex = next(item for item in raw["vertex_rules"] if item["name"] == "V_37")
+    vertex["color_structures"] = [
+        "*".join(reversed(expression.replace("-1", "-97").split("*")))
+        for expression in vertex["color_structures"]
+    ]
+    model_root = root / "model"
+    model_root.mkdir()
+    model_path = model_root / "sm.json"
+    model_path.write_text(
+        json.dumps(raw, sort_keys=True, separators=(",", ":")) + "\n",
+        encoding="utf-8",
+    )
+    restriction = source.with_name("restrict_default.json")
+    (model_root / restriction.name).write_bytes(restriction.read_bytes())
+    return model_path
+
+
+@pytest.mark.parametrize("color_accuracy", ("nlc", "full"))
+def test_eager_and_compiled_exact_z3g_contracted_color_match(
+    tmp_path: Path,
+    color_accuracy: str,
+    builtin_sm_eager_compiled_jit_o2_model: CompiledModel,
+) -> None:
+    """Regress noncanonical compiled amplitude-chunk output ordering."""
+
+    process = "d d~ > z g g g"
+    generation = GenerationConfig(
+        workers=1,
+        emit_api_bundle=False,
+        validation=GenerationValidationConfig(
+            enabled=False,
+            post_build_validation=False,
+        ),
+    )
+    artifact_by_mode = {
+        execution_mode: tmp_path / execution_mode
+        for execution_mode in ("eager", "compiled")
+    }
+    for execution_mode, artifact in artifact_by_mode.items():
+        Generator(
+            RunConfig(
+                action="generate",
+                color=ColorConfig(accuracy=color_accuracy),
+                generation=generation,
+                evaluator=EvaluatorConfig(
+                    execution_mode=execution_mode,
+                    optimization=EvaluatorOptimizationConfig(cores=1),
+                    jit=JITConfig(
+                        optimization_level=2 if execution_mode == "eager" else 3
+                    ),
+                ),
+            )
+        ).generate(
+            process,
+            artifact,
+            model=builtin_sm_eager_compiled_jit_o2_model,
+        )
+
+    compiled_process = next(
+        path
+        for path in (artifact_by_mode["compiled"] / "processes").iterdir()
+        if path.is_dir()
+    )
+    execution = json.loads(
+        (compiled_process / "execution.json").read_text(encoding="utf-8")
+    )
+    amplitude_stage = execution["compiled"]["stage_evaluators"]["amplitude_stage"]
+    bindings = amplitude_stage["compiled_plane_arena"]["output_bindings"]
+    assert [binding["component"] for binding in bindings] != list(
+        range(amplitude_stage["output_length"])
+    )
+
+    point = tuple(
+        tuple(float(component) for component in particle.momentum)
+        for particle in generic_validation_point(process)
+    )
+    momenta = (point,)
+    eager = Runtime.load(artifact_by_mode["eager"])
+    compiled = Runtime.load(artifact_by_mode["compiled"])
+    eager_f64 = eager.evaluate_resolved(momenta)
+    compiled_f64 = compiled.evaluate_resolved(momenta)
+    eager_exact = eager.evaluate_resolved(momenta, precision=32)
+    compiled_exact = compiled.evaluate_resolved(momenta, precision=32)
+
+    assert eager_exact.helicity_ids == compiled_exact.helicity_ids
+    assert eager_exact.color_ids == compiled_exact.color_ids
+    eager_f64_values = tuple(
+        value
+        for point_values in eager_f64.values
+        for helicity_values in point_values
+        for value in helicity_values
+    )
+    compiled_f64_values = tuple(
+        value
+        for point_values in compiled_f64.values
+        for helicity_values in point_values
+        for value in helicity_values
+    )
+    eager_exact_values = tuple(
+        complex(value)
+        for point_values in eager_exact.values
+        for helicity_values in point_values
+        for value in helicity_values
+    )
+    compiled_exact_values = tuple(
+        complex(value)
+        for point_values in compiled_exact.values
+        for helicity_values in point_values
+        for value in helicity_values
+    )
+    assert compiled_f64_values == pytest.approx(
+        eager_f64_values, rel=1.0e-12, abs=1.0e-15
+    )
+    assert eager_exact_values == pytest.approx(
+        eager_f64_values, rel=1.0e-12, abs=1.0e-15
+    )
+    assert compiled_exact_values == pytest.approx(
+        eager_exact_values, rel=1.0e-12, abs=1.0e-15
+    )
+
+
+def _symjit_application_leaves(value: object) -> Iterator[dict[str, Any]]:
+    if isinstance(value, dict):
+        if value.get("kind") == "symjit-application-evaluator":
+            yield value
+        else:
+            for child in value.values():
+                yield from _symjit_application_leaves(child)
+    elif isinstance(value, list):
+        for child in value:
+            yield from _symjit_application_leaves(child)
+
+
+@pytest.mark.parametrize("accuracy", ("lc", "nlc", "full"))
+def test_current_source_generates_and_evaluates_schema_v3(
+    tmp_path: Path,
+    accuracy: str,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    reference, reference_momenta, expected_resolved = _reference_case(accuracy)
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=accuracy),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+    artifact = tmp_path / accuracy
+
+    result = Generator(config).generate(reference["process"], artifact)
+
+    assert result.schema_version == 3
+    outer = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    assert outer["schema_version"] == 3
+    assert outer["processes"][0]["color_accuracy"] == accuracy
+    process_root = artifact / "processes" / outer["processes"][0]["id"]
+    execution = json.loads(
+        (process_root / "execution.json").read_text(encoding="utf-8")
+    )
+    requested = tomllib.loads((artifact / "config/requested.toml").read_text())
+    effective = tomllib.loads((artifact / "config/effective.toml").read_text())
+    assert requested["evaluator"]["jit"]["compress"] == "auto"
+    assert effective["evaluator"]["jit"]["compress"] is True
+    leaves = tuple(_symjit_application_leaves(execution))
+    assert leaves
+    for leaf in leaves:
+        assert leaf["optimization_level"] == 2
+        assert leaf["plane_application"]["optimization_level"] == 2
+        assert leaf["plane_application"]["compression"] is True
+    # Runtime.load below checks each flag against the real stored application;
+    # the f64 oracle evaluations then execute those compressed O2 kernels.
+    physics = json.loads((process_root / "physics.json").read_text(encoding="utf-8"))
+    assert execution["schema_version"] == 3
+    assert execution["kind"] == "pyamplicol-runtime-execution"
+    assert execution["runtime_schema"]["kind"] == ("pyamplicol-runtime-execution-plan")
+    assert all(
+        parameter["name"] != "runtime.lc_sector_id"
+        for parameter in execution["runtime_schema"]["model_parameters"]
+    )
+    _assert_reusable_helicity_topology(
+        execution,
+        current_count=reference["topology"]["current_count"],
+        interaction_count=reference["topology"]["interaction_count"],
+        amplitude_root_count=reference["topology"]["amplitude_root_count"],
+    )
+    _assert_reusable_reduction_coverage(execution, physics)
+
+    runtime = Runtime.load(artifact)
+    runtime.set_model_parameters(
+        {"normalization.alpha_ew": _HISTORICAL_REFERENCE_ALPHA_EW}
+    )
+    momenta = tuple(
+        tuple(tuple(float(component) for component in vector) for vector in point)
+        for point in reference_momenta
+    )
+    with warnings.catch_warnings(record=True) as recorded:
+        warnings.simplefilter("always")
+        total = runtime.evaluate(momenta)
+        resolved = runtime.evaluate_resolved(momenta)
+
+    assert recorded == []
+    assert runtime.physics.color_accuracy == accuracy
+    expected_capabilities = (
+        ("helicity", "color_flow") if accuracy == "lc" else ("helicity",)
+    )
+    assert runtime.physics.selector_capabilities == expected_capabilities
+    assert total[0].real == pytest.approx(reference["total"], rel=1.0e-12)
+    assert total[0].imag == pytest.approx(0.0, abs=1.0e-15)
+    assert resolved.total()[0] == pytest.approx(total[0], rel=1.0e-12)
+
+    if accuracy == "lc":
+        benchmark = BenchmarkRunner(
+            BenchmarkConfig(
+                target_runtime=1.0e-3,
+                batch_size=2,
+                warmup_runs=0,
+                minimum_samples=2,
+            )
+        ).run(runtime, points=momenta)
+        assert benchmark.wall_time_per_point > 0.0
+        assert benchmark.evaluator_time_per_point >= 0.0
+        assert benchmark.environment["wall_time_source"] == (
+            "python_outer_perf_counter_wall_time"
+        )
+        assert benchmark.timing_breakdown is not None
+        breakdown = benchmark.timing_breakdown
+        assert breakdown.wall_time is not None
+        accounted_components = (
+            breakdown.native_input_pack_time,
+            breakdown.native_input_crossing_time,
+            breakdown.orchestration_time,
+            breakdown.state_prepare_time,
+            breakdown.state_clear_time,
+            breakdown.source_fill_time,
+            breakdown.momentum_input_setup_time,
+            breakdown.model_parameter_setup_time,
+            breakdown.stage_input_pack_time,
+            breakdown.stage_evaluator_call_time,
+            breakdown.output_assign_time,
+            breakdown.amplitude_input_pack_time,
+            breakdown.amplitude_evaluator_call_time,
+            breakdown.reduction_time,
+            breakdown.total_materialization_time,
+            breakdown.final_output_copy_time,
+            breakdown.selector_planner_time,
+            breakdown.selector_gather_time,
+            breakdown.selector_scatter_time,
+        )
+        accounted = sum(
+            component.mean_seconds_per_point
+            for component in accounted_components
+            if component is not None
+        )
+        wall = breakdown.wall_time.mean_seconds_per_point
+        assert accounted <= wall * (1.0 + 1.0e-12)
+        if breakdown.other_core_time is not None:
+            assert accounted + breakdown.other_core_time.mean_seconds_per_point == (
+                pytest.approx(wall, rel=1.0e-12, abs=1.0e-18)
+            )
+
+    exact = runtime.evaluate_resolved(momenta, precision=32)
+    assert exact.helicity_ids == resolved.helicity_ids
+    assert exact.color_ids == resolved.color_ids
+    for jit_helicity, exact_helicity in zip(
+        resolved.values[0], exact.values[0], strict=True
+    ):
+        for jit_value, exact_value in zip(jit_helicity, exact_helicity, strict=True):
+            assert complex(jit_value).real == pytest.approx(
+                complex(exact_value).real,
+                rel=1.0e-12,
+                abs=1.0e-15,
+            )
+            assert complex(jit_value).imag == pytest.approx(
+                complex(exact_value).imag,
+                rel=1.0e-12,
+                abs=1.0e-15,
+            )
+
+    if accuracy != "lc":
+        for precision in (16, 32):
+            with pytest.raises(
+                EvaluationError,
+                match="color-flow selection is unavailable",
+            ):
+                runtime.evaluate_resolved(
+                    momenta,
+                    color_flows=[resolved.color_ids[0]],
+                    precision=precision,
+                )
+
+    helicity_index = {value: index for index, value in enumerate(resolved.helicity_ids)}
+    color_index = {value: index for index, value in enumerate(resolved.color_ids)}
+    for helicity_id, expected_colors in expected_resolved.items():
+        for color_id, expected_value in expected_colors.items():
+            actual = resolved.values[0][helicity_index[helicity_id]][
+                color_index[color_id]
+            ]
+            assert actual.real == pytest.approx(expected_value, rel=1.0e-12)
+            assert actual.imag == pytest.approx(0.0, abs=1.0e-15)
+
+
+def test_nlc_one_line_shared_orderings_match_sector_local_reference(
+    tmp_path: Path,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    artifact = tmp_path / "nlc-shared-one-line"
+    Generator(
+        RunConfig(
+            action="generate",
+            color=ColorConfig(accuracy="nlc"),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+            generation=GenerationConfig(
+                relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            ),
+        )
+    ).generate("g g > t t~ g", artifact)
+
+    execution = json.loads(
+        (artifact / "processes" / "g_g_to_t_tbar_g" / "execution.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    # Runtime-selected helicities use the quotient lane; the summed workload
+    # retains the proof recurrence as a separate execution lane. Exact
+    # reflection/permutation equivalences remove duplicate current values from
+    # both forms without changing the sector-local NLC result checked below.
+    # Optional numerical relation discovery is disabled: only structural reuse
+    # contributes to these plan counts.
+    assert execution["dag_summary"] == {
+        "amplitude_root_count": 6,
+        "current_count": 35,
+        "interaction_count": 66,
+        "interaction_evaluation_count": 42,
+        "source_count": 5,
+        "truncated": False,
+    }
+    assert execution["helicity_sum_execution"]["dag_summary"] == {
+        "amplitude_root_count": 192,
+        "current_count": 250,
+        "interaction_count": 624,
+        "interaction_evaluation_count": 420,
+        "source_count": 10,
+        "truncated": False,
+    }
+    _assert_reusable_helicity_topology(
+        execution,
+        current_count=250,
+        interaction_count=624,
+        amplitude_root_count=192,
+    )
+
+    runtime = Runtime.load(artifact)
+    momenta = runtime._backend.validation_momenta()
+    assert momenta is not None
+    total = runtime.evaluate(momenta)
+
+    # Captured with the previous exact sector-local NLC construction at the
+    # same deterministic validation point.
+    assert total[0].real == pytest.approx(5.285188765700242e-4, rel=1.0e-12)
+    assert total[0].imag == pytest.approx(0.0, abs=1.0e-15)
+
+
+@pytest.mark.parametrize(
+    ("process", "color_accuracy"),
+    (
+        ("d d~ > t t~ g g", "full"),
+        ("g g > g g g", "nlc"),
+    ),
+)
+def test_recursive_current_reuse_matches_unshared_contracted_runtime(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    process: str,
+    color_accuracy: str,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    from pyamplicol.generation import dag_compiler as dag_compiler_module
+
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=color_accuracy),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(samples=1),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="compiled",
+            output_chunk_size=512,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=1),
+        ),
+    )
+    optimized_artifact = tmp_path / "recursive-current-reuse"
+    external_artifact = tmp_path / "external-recursive-current-reuse"
+    baseline_artifact = tmp_path / "attachment-local-reuse"
+    Generator(config).generate(process, optimized_artifact)
+    Generator(config).generate(
+        process,
+        external_artifact,
+        model=ModelSource.from_path(EXTERNAL_SM_SOURCES["json"]),
+    )
+
+    monkeypatch.setattr(
+        dag_compiler_module,
+        "assign_recursive_current_evaluation_reuse",
+        lambda dag, _model: dag,
+    )
+    monkeypatch.setattr(
+        BuiltinSMModel,
+        "vertex_evaluation_equivalence",
+        Model.vertex_evaluation_equivalence,
+    )
+    Generator(config).generate(process, baseline_artifact)
+
+    optimized = Runtime.load(optimized_artifact)
+    external = Runtime.load(external_artifact)
+    baseline = Runtime.load(baseline_artifact)
+    momenta = optimized._backend.validation_momenta()
+    assert momenta is not None
+    optimized_total = optimized.evaluate(momenta)
+    baseline_total = baseline.evaluate(momenta)
+    assert optimized_total == pytest.approx(
+        baseline_total,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+    assert external.evaluate(momenta) == pytest.approx(
+        optimized_total,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
+
+    optimized_resolved = optimized.evaluate_resolved(momenta)
+    external_resolved = external.evaluate_resolved(momenta)
+    baseline_resolved = baseline.evaluate_resolved(momenta)
+    assert optimized_resolved.helicity_ids == baseline_resolved.helicity_ids
+    assert optimized_resolved.color_ids == baseline_resolved.color_ids
+    assert external_resolved.helicity_ids == optimized_resolved.helicity_ids
+    assert external_resolved.color_ids == optimized_resolved.color_ids
+    for optimized_helicities, baseline_helicities in zip(
+        optimized_resolved.values,
+        baseline_resolved.values,
+        strict=True,
+    ):
+        for optimized_colors, baseline_colors in zip(
+            optimized_helicities,
+            baseline_helicities,
+            strict=True,
+        ):
+            assert optimized_colors == pytest.approx(
+                baseline_colors,
+                rel=1.0e-12,
+                abs=1.0e-15,
+            )
+    for external_helicities, optimized_helicities in zip(
+        external_resolved.values,
+        optimized_resolved.values,
+        strict=True,
+    ):
+        for external_colors, optimized_colors in zip(
+            external_helicities,
+            optimized_helicities,
+            strict=True,
+        ):
+            assert external_colors == pytest.approx(
+                optimized_colors,
+                rel=1.0e-12,
+                abs=1.0e-15,
+            )
+
+
+def test_chunked_stage_evaluators_prune_inputs_and_preserve_precision(
+    tmp_path: Path,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    def config(output_chunk_size: int | None) -> RunConfig:
+        return RunConfig(
+            action="generate",
+            color=ColorConfig(accuracy="lc"),
+            generation=GenerationConfig(workers=1, emit_api_bundle=False),
+            evaluator=EvaluatorConfig(
+                execution_mode="compiled",
+                output_chunk_size=output_chunk_size,
+                optimization=EvaluatorOptimizationConfig(cores=1),
+                jit=JITConfig(optimization_level=1),
+            ),
+        )
+
+    artifact = tmp_path / "mapped-chunks"
+    baseline_artifact = tmp_path / "unchunked"
+    Generator(config(2)).generate("d d~ > z g", artifact)
+    Generator(config(None)).generate("d d~ > z g", baseline_artifact)
+
+    execution = json.loads(
+        (artifact / "processes" / "d_dbar_to_z_g" / "execution.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    # The final Zg kernels need internal momenta but not every canonical slot.
+    # Exercise genuine pruning, including nonzero retained global slot offsets.
+    live_momenta = execution["compiled"]["momentum_slot_ids"]
+    assert 0 < len(live_momenta) < len(execution["runtime_schema"]["momentum_slots"])
+    assert live_momenta != list(range(len(live_momenta)))
+    stages = execution["compiled"]["stage_evaluators"]
+    evaluator_manifests = [
+        *(stage["evaluator"] for stage in stages["stages"]),
+        stages["amplitude_stage"]["evaluator"],
+    ]
+    chunked = [
+        manifest
+        for manifest in evaluator_manifests
+        if manifest["kind"] == "chunked-symbolica-evaluator"
+    ]
+    assert chunked
+    assert any(
+        len(indices) < manifest["input_len"]
+        for manifest in chunked
+        for indices in manifest["chunk_input_indices"]
+    )
+    for manifest in chunked:
+        assert len(manifest["chunks"]) == len(manifest["chunk_input_indices"])
+        for child, indices in zip(
+            manifest["chunks"], manifest["chunk_input_indices"], strict=True
+        ):
+            assert child["input_len"] == len(indices)
+            assert indices == sorted(set(indices))
+
+    runtime = Runtime.load(artifact)
+    baseline = Runtime.load(baseline_artifact)
+    momenta = runtime._backend.validation_momenta()
+    assert momenta is not None
+    resolved = runtime.evaluate_resolved(momenta)
+    exact = runtime.evaluate_resolved(momenta, precision=32)
+    assert resolved.total()[0] == pytest.approx(
+        baseline.evaluate_resolved(momenta).total()[0], rel=1.0e-12
+    )
+    assert (
+        exact.total()[0] == baseline.evaluate_resolved(momenta, precision=32).total()[0]
+    )
+
+    final_state = massive_rambo_final_state(
+        2,
+        sqrt_s=1000.0,
+        masses=(91.188, 0.0),
+        seed=54321,
+    )
+    alternate = (
+        (500.0, 0.0, 0.0, 500.0),
+        (500.0, 0.0, 0.0, -500.0),
+        *final_state,
+    )
+    mixed_batch = (momenta[0], alternate, momenta[0])
+    oracle = runtime.evaluate(mixed_batch, precision=80)
+    # Public uncorrelated precision requests use Arb; the Symbolica-free
+    # native Python runtime exposes only f64, not its optional Rust DoubleFloat
+    # lane. Check the retained exact chunk maps without mislabelling Arb as DD.
+    higher_precision = runtime.evaluate(mixed_batch, precision=31)
+    with localcontext() as context:
+        context.prec = 90
+        for value, reference in zip(higher_precision, oracle, strict=True):
+            assert reference > 0
+            assert abs(value - reference) / reference < Decimal("1e-27")
+    assert runtime.evaluate(mixed_batch) == pytest.approx(
+        Runtime.load(artifact).evaluate(mixed_batch),
+        rel=1.0e-13,
+        abs=1.0e-15,
+    )
+    assert runtime.evaluate((alternate,)) == pytest.approx(
+        Runtime.load(artifact).evaluate((alternate,)),
+        rel=1.0e-13,
+        abs=1.0e-15,
+    )
+
+
+@pytest.mark.parametrize("case_name", tuple(EXTERNAL_CASES))
+def test_current_source_external_models_match_reference(
+    tmp_path: Path,
+    case_name: str,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    reference, reference_momenta = _named_reference_case(case_name)
+    config = RunConfig(
+        action="generate",
+        model=ModelConfig(cache=False),
+        color=ColorConfig(accuracy=reference["color_accuracy"]),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+    artifact = tmp_path / case_name
+    result = Generator(config).generate(
+        reference["process"],
+        artifact,
+        model=ModelSource.from_path(EXTERNAL_CASES[case_name]),
+    )
+
+    assert result.schema_version == 3
+    runtime = Runtime.load(artifact)
+    momenta = tuple(
+        tuple(tuple(float(component) for component in vector) for vector in point)
+        for point in reference_momenta
+    )
+    total = runtime.evaluate(momenta)
+    resolved = runtime.evaluate_resolved(momenta)
+
+    assert runtime.physics.color_accuracy == "lc"
+    assert runtime.physics.selector_capabilities == ("helicity", "color_flow")
+    assert total[0].real == pytest.approx(reference["total"], rel=1.0e-12)
+    assert total[0].imag == pytest.approx(0.0, abs=1.0e-15)
+    assert resolved.total()[0] == pytest.approx(total[0], rel=1.0e-12)
+
+    helicity_index = {value: index for index, value in enumerate(resolved.helicity_ids)}
+    color_index = {value: index for index, value in enumerate(resolved.color_ids)}
+    for helicity_id, expected_colors in reference["resolved"].items():
+        for color_id, expected_value in expected_colors.items():
+            actual = resolved.values[0][helicity_index[helicity_id]][
+                color_index[color_id]
+            ]
+            assert actual.real == pytest.approx(expected_value, rel=1.0e-12)
+            assert actual.imag == pytest.approx(0.0, abs=1.0e-15)
+
+    precise_by_precision = {}
+    for precision in (32, 80):
+        precise = runtime.evaluate_resolved(momenta, precision=precision)
+        precise_by_precision[precision] = precise
+        assert precise.helicity_ids == resolved.helicity_ids
+        assert precise.color_ids == resolved.color_ids
+        for jit_helicity, precise_helicity in zip(
+            resolved.values[0], precise.values[0], strict=True
+        ):
+            for jit_value, precise_value in zip(
+                jit_helicity, precise_helicity, strict=True
+            ):
+                assert complex(precise_value).real == pytest.approx(
+                    jit_value.real,
+                    rel=1.0e-12,
+                    abs=1.0e-15,
+                )
+                assert complex(precise_value).imag == pytest.approx(
+                    jit_value.imag,
+                    rel=1.0e-12,
+                    abs=1.0e-15,
+                )
+
+    low_precision = precise_by_precision[32]
+    high_precision = precise_by_precision[80]
+    for low_helicity, high_helicity in zip(
+        low_precision.values[0], high_precision.values[0], strict=True
+    ):
+        for low_value, high_value in zip(low_helicity, high_helicity, strict=True):
+            assert isinstance(low_value, Decimal)
+            assert isinstance(high_value, Decimal)
+            assert abs(low_value - high_value) <= max(
+                abs(high_value), Decimal(1)
+            ) * Decimal("1e-28")
+
+    if case_name == "scalars_2to2_lc":
+        analytic = scalar_contact_2to2()
+    else:
+        analytic_momenta = tuple(
+            tuple(Decimal(str(component)) for component in vector)
+            for vector in reference_momenta[0]
+        )
+        analytic = scalar_gravity_2to2(analytic_momenta)
+    assert high_precision.helicity_ids == analytic.helicity_ids
+    precise_total = high_precision.total()[0]
+    assert isinstance(precise_total, Decimal)
+    assert abs(precise_total - analytic.total) <= max(
+        abs(analytic.total), Decimal(1)
+    ) * Decimal("1e-14")
+    for row, expected in zip(high_precision.values[0], analytic.resolved, strict=True):
+        assert isinstance(row[0], Decimal)
+        assert abs(row[0] - expected) <= max(abs(expected), Decimal(1)) * Decimal(
+            "1e-14"
+        )
+
+
+@pytest.mark.parametrize("source_kind", tuple(EXTERNAL_SM_SOURCES))
+@pytest.mark.parametrize("accuracy", ("lc", "nlc", "full"))
+def test_current_source_external_sm_matches_builtin_reference(
+    tmp_path: Path,
+    source_kind: str,
+    accuracy: str,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    processes = {process["id"]: process for process in REFERENCE_PAYLOAD["processes"]}
+    cases = {case["id"]: case for case in REFERENCE_PAYLOAD["cases"]}
+    points = {point["id"]: point for point in REFERENCE_PAYLOAD["points"]}
+    config = RunConfig(
+        action="generate",
+        model=ModelConfig(cache=False),
+        color=ColorConfig(accuracy=accuracy),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+    artifact = tmp_path / f"external-sm-{source_kind}-{accuracy}"
+    Generator(config).generate(
+        ProcessSet.from_expressions(
+            tuple(
+                processes[process_id]["expression"]
+                for process_id in EXTERNAL_SM_PROCESS_IDS
+            ),
+            names=EXTERNAL_SM_PROCESS_IDS,
+        ),
+        artifact,
+        model=ModelSource.from_path(EXTERNAL_SM_SOURCES[source_kind]),
+    )
+
+    for process_id in EXTERNAL_SM_PROCESS_IDS:
+        case = cases[f"case:{process_id}:{accuracy}"]
+        execution = json.loads(
+            (artifact / "processes" / process_id / "execution.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        physics = json.loads(
+            (artifact / "processes" / process_id / "physics.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        _assert_reusable_helicity_topology(execution)
+        _assert_reusable_reduction_coverage(execution, physics)
+
+        runtime = Runtime.load(artifact, process=process_id)
+        assert runtime.physics.helicity_coverage == "complete"
+        assert runtime.physics.color_coverage == (
+            "complete" if accuracy == "lc" else "contracted"
+        )
+        expected_helicities = tuple(item["id"] for item in case["axes"]["helicities"])
+        expected_colors = tuple(item["id"] for item in case["axes"]["colors"])
+        for observation in case["observations"]:
+            point = points[observation["point_id"]]
+            momenta = (
+                tuple(
+                    tuple(float(component) for component in vector)
+                    for vector in point["momenta"]
+                ),
+            )
+            total = runtime.evaluate(momenta)[0]
+            resolved = runtime.evaluate_resolved(momenta)
+            expected_total = float(observation["total"])
+
+            assert total.real == pytest.approx(
+                expected_total,
+                rel=1.0e-10,
+                abs=1.0e-12,
+            )
+            assert total.imag == pytest.approx(
+                0.0,
+                abs=max(1.0e-15, abs(expected_total) * 1.0e-12),
+            )
+            assert resolved.total()[0] == pytest.approx(
+                total,
+                rel=1.0e-12,
+                abs=1.0e-12,
+            )
+            assert resolved.helicity_ids == expected_helicities
+            assert resolved.color_ids == expected_colors
+            for helicity_index, expected_row in enumerate(observation["values"]):
+                for color_index, expected_text in enumerate(expected_row):
+                    expected = float(expected_text)
+                    actual = resolved.values[0][helicity_index][color_index]
+                    assert actual.real == pytest.approx(
+                        expected,
+                        rel=1.0e-10,
+                        abs=1.0e-12,
+                    )
+                    assert actual.imag == pytest.approx(
+                        0.0,
+                        abs=max(1.0e-15, abs(expected) * 1.0e-12),
+                    )
+
+
+def test_external_sm_color_dummy_relabeling_preserves_resolved_runtime(
+    tmp_path: Path,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    reference, momenta, expected_resolved = _case_payload("case:sm_gg_gg:lc")
+    artifact = tmp_path / "color-dummy-relabelled-sm"
+    config = RunConfig(
+        action="generate",
+        model=ModelConfig(cache=False),
+        color=ColorConfig(accuracy="lc"),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+    Generator(config).generate(
+        reference["process"],
+        artifact,
+        model=ModelSource.from_path(_write_color_dummy_relabelled_sm(tmp_path)),
+    )
+
+    outer = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process_id = outer["processes"][0]["id"]
+    execution = json.loads(
+        (artifact / "processes" / process_id / "execution.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    physics = json.loads(
+        (artifact / "processes" / process_id / "physics.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    _assert_reusable_helicity_topology(execution)
+    _assert_reusable_reduction_coverage(execution, physics)
+
+    runtime_momenta = tuple(
+        tuple(tuple(float(component) for component in vector) for vector in point)
+        for point in momenta
+    )
+    runtime = Runtime.load(artifact)
+    resolved = runtime.evaluate_resolved(runtime_momenta)
+    precise = runtime.evaluate_resolved(runtime_momenta, precision=80)
+    expected_helicity_ids = tuple(expected_resolved)
+    expected_color_ids = tuple(next(iter(expected_resolved.values())))
+    assert resolved.helicity_ids == expected_helicity_ids
+    assert resolved.color_ids == expected_color_ids
+    assert precise.helicity_ids == expected_helicity_ids
+    assert precise.color_ids == expected_color_ids
+    for helicity_index, helicity_id in enumerate(expected_helicity_ids):
+        for color_index, color_id in enumerate(expected_color_ids):
+            expected = expected_resolved[helicity_id][color_id]
+            actual = resolved.values[0][helicity_index][color_index]
+            high_precision = precise.values[0][helicity_index][color_index]
+            assert actual.real == pytest.approx(expected, rel=1.0e-10, abs=1.0e-12)
+            assert actual.imag == pytest.approx(0.0, abs=1.0e-12)
+            assert float(high_precision) == pytest.approx(
+                expected,
+                rel=1.0e-10,
+                abs=1.0e-12,
+            )
+    assert resolved.total()[0].real == pytest.approx(
+        reference["total"],
+        rel=1.0e-10,
+        abs=1.0e-12,
+    )
+
+
+def test_external_sm_mass_overrides_refresh_sources_and_derived_masses(
+    tmp_path: Path,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    config = RunConfig(
+        action="generate",
+        model=ModelConfig(cache=False),
+        color=ColorConfig(accuracy="lc"),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+    artifact = tmp_path / "external-sm-runtime-mass"
+    Generator(config).generate(
+        "u d~ > w+",
+        artifact,
+        model=ModelSource.from_path(EXTERNAL_SM_SOURCES["json"]),
+    )
+
+    outer = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process_id = outer["processes"][0]["id"]
+    process_root = artifact / "processes" / process_id
+    execution = json.loads(
+        (process_root / "execution.json").read_text(encoding="utf-8")
+    )
+    w_record = next(
+        particle
+        for particle in execution["runtime_schema"]["model"]["particles"]
+        if particle["pdg"] == 24
+    )
+    assert w_record["mass_parameter"] == "MW"
+    assert {
+        parameter.get("runtime_name")
+        for parameter in execution["runtime_schema"]["model_parameters"]
+        if parameter["kind"] == "derived_parameter_component"
+    } >= {"MW"}
+
+    validation = json.loads(
+        (process_root / "validation-momenta.json").read_text(encoding="utf-8")
+    )
+    momenta = (
+        tuple(
+            tuple(float(component) for component in particle["momentum"])
+            for particle in validation["points"][0]
+        ),
+    )
+    runtime = Runtime.load(artifact)
+    baseline = runtime.evaluate(momenta)[0]
+    runtime.set_model_parameters({"MZ": 100.0})
+    changed = runtime.evaluate(momenta)[0]
+    runtime.set_model_parameters({"MZ": 91.188})
+    restored = runtime.evaluate(momenta)[0]
+
+    assert abs(changed - baseline) > max(1.0e-14, abs(baseline) * 1.0e-8)
+    assert restored == pytest.approx(baseline, rel=1.0e-12, abs=1.0e-15)
+
+
+def test_runtime_rejects_external_mass_class_changes_atomically(
+    tmp_path: Path,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+
+    artifact = tmp_path / "external-sm-runtime-mass-class"
+    Generator(
+        RunConfig(
+            action="generate",
+            model=ModelConfig(cache=False),
+            color=ColorConfig(accuracy="lc"),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        )
+    ).generate(
+        "d d~ > z",
+        artifact,
+        model=ModelSource.from_path(EXTERNAL_SM_SOURCES["json"]),
+    )
+    outer = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process_id = outer["processes"][0]["id"]
+    validation = json.loads(
+        (artifact / "processes" / process_id / "validation-momenta.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    momenta = (
+        tuple(
+            tuple(float(component) for component in particle["momentum"])
+            for particle in validation["points"][0]
+        ),
+    )
+    runtime = Runtime.load(artifact)
+    baseline = runtime.evaluate(momenta)[0]
+
+    with pytest.raises(EvaluationError, match=r"mass class.*regenerate"):
+        runtime.set_model_parameters({"MZ": 0.0})
+
+    assert runtime.evaluate(momenta)[0] == pytest.approx(
+        baseline,
+        rel=1.0e-12,
+        abs=1.0e-15,
+    )
diff --git a/pyamplicol/tests/integration/test_sm_heft_backends.py b/pyamplicol/tests/integration/test_sm_heft_backends.py
new file mode 100644
index 0000000000..b4e7f8f3c7
--- /dev/null
+++ b/pyamplicol/tests/integration/test_sm_heft_backends.py
@@ -0,0 +1,138 @@
+# SPDX-License-Identifier: 0BSD
+"""Packaged scalar HEFT execution through every evaluator backend."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import math
+import shutil
+import tomllib
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.config import (
+    ColorConfig,
+    CppConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ModelConfig,
+    ProcessConfig,
+    RunConfig,
+)
+
+
+def test_packaged_sm_heft_runs_in_every_execution_mode_and_backend(
+    tmp_path: Path,
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        pytest.skip("the Rusticol extension has not been built")
+    cxx = shutil.which("c++")
+
+    cache_dir = tmp_path / "model-cache"
+    source = ModelSource.built_in_sm_heft()
+    source.compile(cache_dir=cache_dir, use_cache=True)
+    values: dict[str, complex] = {}
+    validation_points: dict[str, object] = {}
+    lanes = [
+        ("backend-jit", "compiled", "jit", "g g > H", "backend"),
+        ("backend-asm", "compiled", "asm", "g g > H", "backend"),
+        (
+            "contact-compiled-jit",
+            "compiled",
+            "jit",
+            "g g > H g g",
+            "contact",
+        ),
+        ("contact-eager-jit", "eager", "jit", "g g > H g g", "contact"),
+        (
+            "contact-recurrence-jit",
+            "recurrence",
+            "jit",
+            "g g > H g g",
+            "contact",
+        ),
+        (
+            "contact-on-the-fly-jit",
+            "on-the-fly",
+            "jit",
+            "g g > H g g",
+            "contact",
+        ),
+    ]
+    if cxx is not None:
+        lanes.insert(2, ("backend-cpp", "compiled", "cpp", "g g > H", "backend"))
+    for lane, execution_mode, backend, process, comparison_group in lanes:
+        artifact = tmp_path / lane
+        evaluator = EvaluatorConfig(
+            backend=backend,
+            execution_mode=execution_mode,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=0),
+            cpp=(CppConfig(compiler=cxx) if backend == "cpp" else CppConfig()),
+        )
+        config = RunConfig(
+            action="generate",
+            model=ModelConfig(
+                source="built-in-sm-heft",
+                cache=True,
+                cache_dir=cache_dir,
+            ),
+            color=ColorConfig(accuracy="full"),
+            process=ProcessConfig(
+                coupling_order_policy="explicit",
+                max_coupling_orders={"HIG": 1},
+            ),
+            generation=GenerationConfig(
+                workers=1,
+                emit_api_bundle=False,
+                relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+                validation=GenerationValidationConfig(
+                    enabled=False,
+                    samples=1,
+                    seed=101,
+                    post_build_validation=False,
+                ),
+            ),
+            evaluator=evaluator,
+        )
+        Generator(config).generate(process, artifact, model=source)
+        runtime = Runtime.load(artifact)
+        points = runtime._backend.validation_momenta()
+        assert points is not None
+        if comparison_group not in validation_points:
+            validation_points[comparison_group] = points
+        else:
+            assert points == validation_points[comparison_group]
+        value = complex(runtime.evaluate(points)[0])
+        assert math.isfinite(value.real) and math.isfinite(value.imag)
+        assert value.real != 0.0
+        assert abs(value.imag) <= abs(value.real) * 1.0e-13
+        values[lane] = value
+
+        manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+        assert manifest["model"]["name"] == "built-in-sm-heft"
+        assert manifest["model"]["source_kind"] == (
+            "built-in-sm-heft" if execution_mode == "compiled" else "compiled-model"
+        )
+        effective = tomllib.loads(
+            (artifact / "config/effective.toml").read_text(encoding="utf-8")
+        )
+        assert effective["evaluator"]["backend"] == backend
+        assert effective["evaluator"]["execution_mode"] == execution_mode
+
+    references = {
+        "backend": "backend-jit",
+        "contact": "contact-compiled-jit",
+    }
+    for lane, _execution_mode, _backend, _process, comparison_group in lanes:
+        reference = references[comparison_group]
+        assert values[lane] == pytest.approx(
+            values[reference], rel=1.0e-12, abs=1.0e-300
+        )
diff --git a/pyamplicol/tests/integration/test_spenso_restricted_mode.py b/pyamplicol/tests/integration/test_spenso_restricted_mode.py
new file mode 100644
index 0000000000..96e9bbfdd9
--- /dev/null
+++ b/pyamplicol/tests/integration/test_spenso_restricted_mode.py
@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+_RESTRICTED_MODE_MRE = r"""
+from symbolica import Expression, is_licensed
+from symbolica.community.tensor import (
+    Representation,
+    Tensor,
+    TensorExpression,
+    TensorLibrary,
+    TensorName,
+    TensorNetwork,
+)
+
+assert not is_licensed()
+library = TensorLibrary.hep_lib_atom()
+minkowski = Representation.mink(4)
+mu = minkowski("ufo_l_1_3")
+nu = minkowski("ufo_l_2_3")
+rho = minkowski("ufo_l_1_4")
+sigma = minkowski("ufo_l_2_4")
+a = TensorName("spenso_restricted_mode_test::A")
+b = TensorName("spenso_restricted_mode_test::B")
+library.register(
+    Tensor.dense(
+        a(minkowski, minkowski),
+        tuple(Expression.parse(f"a{i}") for i in range(16)),
+    )
+)
+library.register(
+    Tensor.dense(
+        b(minkowski, minkowski),
+        tuple(Expression.parse("1" if i == 5 else "0") for i in range(16)),
+    )
+)
+metric = TensorExpression.g(minkowski)
+expression = (
+    -2 * metric(nu, mu).to_expression() * metric(sigma, rho).to_expression()
+    + 2 * metric(mu, rho).to_expression() * metric(nu, sigma).to_expression()
+    + 2 * metric(nu, rho).to_expression() * metric(sigma, mu).to_expression()
+) * a(mu, nu).to_expression() * b(rho, sigma).to_expression()
+
+network = TensorNetwork(expression, library)
+network.execute(library=library)
+result = network.result_tensor(library).to_dense()
+expected = Expression.parse("2*a0+2*a5-2*a10-2*a15")
+assert (result[0] - expected).expand().to_canonical_string() == "0"
+print("restricted tensor contraction passed")
+"""
+
+
+def test_spenso_sequential_execution_respects_symbolica_restricted_mode() -> None:
+    environment = dict(os.environ)
+    environment.pop("SYMBOLICA_LICENSE", None)
+    environment.pop("SYMBOLICA_MASTER_LICENSE", None)
+    environment["SYMBOLICA_HIDE_BANNER"] = "1"
+    result = subprocess.run(
+        [sys.executable, "-c", _RESTRICTED_MODE_MRE],
+        check=False,
+        capture_output=True,
+        env=environment,
+        text=True,
+        timeout=60,
+    )
+
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert "restricted tensor contraction passed" in result.stdout
diff --git a/pyamplicol/tests/integration/test_symbolica_instruction_bridge.py b/pyamplicol/tests/integration/test_symbolica_instruction_bridge.py
new file mode 100644
index 0000000000..ea8a7cb8bb
--- /dev/null
+++ b/pyamplicol/tests/integration/test_symbolica_instruction_bridge.py
@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: 0BSD
+"""Numerically exercise released Symbolica instructions in native plane kernels."""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.config import (
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+
+
+def test_unit_imaginary_instructions_survive_native_runtime(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        if os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1":
+            pytest.fail("the Rusticol extension has not been built")
+        pytest.skip("the Rusticol extension has not been built")
+
+    from symbolica import E
+
+    import pyamplicol.evaluators.symbolica as evaluator_module
+    from pyamplicol.evaluators.symbolica_adapters import _JITSymbolicaEvaluatorAdapter
+
+    coefficients = (E("1i"), E("-1i"), E("1/3-1i/2"))
+    original_compile = evaluator_module._compile_symbolica_outputs
+    exported_constants: set[Any] = set()
+    original_export = _JITSymbolicaEvaluatorAdapter._export_symjit_plane_application
+
+    def export_plane(adapter: Any, **kwargs: Any) -> Any:
+        exported_constants.update(
+            adapter._source_evaluator.get_instructions().constants
+        )
+        return original_export(adapter, **kwargs)
+
+    def compile_amplitudes(outputs: tuple[Any, ...], *args: Any, **kwargs: Any) -> Any:
+        if "amplitude" in kwargs.get("label", ""):
+            # The surrounding process supplies a valid native runtime schema;
+            # only its final amplitudes are synthetic. In particular, -i must
+            # not be silently parsed as zero by the SymJIT instruction bridge.
+            outputs = tuple(
+                coefficients[i % len(coefficients)] * (output + output**2)
+                for i, output in enumerate(outputs)
+            )
+        return original_compile(outputs, *args, **kwargs)
+
+    monkeypatch.setattr(
+        evaluator_module, "_compile_symbolica_outputs", compile_amplitudes
+    )
+    monkeypatch.setattr(
+        _JITSymbolicaEvaluatorAdapter, "_export_symjit_plane_application", export_plane
+    )
+    artifact = tmp_path / "imaginary-constants"
+    Generator(
+        RunConfig(
+            action="generate",
+            generation=GenerationConfig(
+                workers=1,
+                emit_api_bundle=False,
+                relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+                validation=GenerationValidationConfig(
+                    enabled=False, post_build_validation=False
+                ),
+            ),
+            evaluator=EvaluatorConfig(
+                execution_mode="compiled",
+                optimization=EvaluatorOptimizationConfig(cores=1),
+                jit=JITConfig(optimization_level=2),
+            ),
+        )
+    ).generate("d d~ > z", artifact, model=ModelSource.built_in_sm())
+    assert set(coefficients) <= exported_constants
+
+    momenta = [
+        [
+            [45.594, 0.0, 0.0, 45.594],
+            [45.594, 0.0, 0.0, -45.594],
+            [91.188, 0.0, 0.0, 0.0],
+        ]
+    ]
+    runtime = Runtime.load(artifact)
+    native = np.asarray(runtime.evaluate_resolved(momenta).values, dtype=complex)
+    exact = np.asarray(
+        runtime.evaluate_resolved(momenta, precision=40).values, dtype=complex
+    )
+    assert np.any(np.abs(exact) > 0)
+    np.testing.assert_allclose(native, exact, rtol=1e-13, atol=1e-15)
diff --git a/pyamplicol/tests/integration/test_symjit_upstream_regressions.py b/pyamplicol/tests/integration/test_symjit_upstream_regressions.py
new file mode 100644
index 0000000000..c250abef8b
--- /dev/null
+++ b/pyamplicol/tests/integration/test_symjit_upstream_regressions.py
@@ -0,0 +1,202 @@
+# SPDX-License-Identifier: 0BSD
+"""Opt-in, tiny compiler regressions; no pyAmpliCol native build is required.
+
+PYAMPLICOL_RUN_SYMJIT_REGRESSIONS=1 tests the locked published SymJIT version.
+PYAMPLICOL_SYMJIT_SOURCE=/path/to/symjit selects a different source checkout.
+Only test modules are added to a temporary copy: corrective patches are never
+applied. A broken compiler is expected to fail, rather than produce an xfail.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shutil
+import signal
+import subprocess
+import tomllib
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+FOLLOWUP = ROOT / "SYMJIT_FOLLOW_UP_FIXES"
+ORIGINAL = ROOT / "DEPENDENCY_FIXES" / "SYMJIT"
+_ARM = platform.machine().lower() in {"arm64", "aarch64"}
+pytestmark = pytest.mark.skipif(
+    os.environ.get("PYAMPLICOL_RUN_SYMJIT_REGRESSIONS") != "1",
+    reason="set PYAMPLICOL_RUN_SYMJIT_REGRESSIONS=1 for SymJIT compiler tests",
+)
+
+_BINARIES = {
+    "output_reuse": ORIGINAL / "output-reuse/src/main.rs",
+    "unused_trailing_inputs": ORIGINAL / "unused-trailing-inputs/src/main.rs",
+    "argument_count": FOLLOWUP / "argument-count-overflow/mre.rs",
+    "arm_simd_arguments": FOLLOWUP / "arm-simd-real-ultra-arguments/mre.rs",
+    "real_input_locations": FOLLOWUP / "real-input-locations/mre.rs",
+}
+_RUST_TESTS = {
+    "compressed_success": ORIGINAL / "compressed-success-status/mre.rs",
+    "original_arm_registers": ORIGINAL / "arm-callee-saved-registers/mre.rs",
+    "arm_normal_return": FOLLOWUP / "arm-compressed-register-restore/mre.rs",
+    "arm_fast_complex": FOLLOWUP
+    / "arm-compressed-register-restore/fast_complex_mre.rs",
+}
+
+
+def _cargo(manifest: Path, *arguments: str) -> str:
+    """Keep compiler crashes isolated and terminate a timed-out process group."""
+    command = ["cargo", *arguments, "--manifest-path", str(manifest)]
+    # Cargo arguments must precede the test/program's own `--` arguments.
+    if "--" in arguments:
+        split = command.index("--")
+        command[split:split] = command[-2:]
+        del command[-2:]
+    environment = os.environ.copy()
+    environment.setdefault(
+        "CARGO_TARGET_DIR", str(ROOT / ".artifacts/symjit-regressions/target")
+    )
+    environment["CARGO_BUILD_JOBS"] = "2"
+    with subprocess.Popen(
+        command,
+        cwd=manifest.parent,
+        env=environment,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        start_new_session=os.name == "posix",
+    ) as process:
+        try:
+            output, errors = process.communicate(timeout=600)
+        except subprocess.TimeoutExpired:
+            if os.name == "posix":
+                os.killpg(process.pid, signal.SIGKILL)
+            else:
+                process.kill()
+            output, errors = process.communicate()
+            pytest.fail(f"Cargo timed out after 600 seconds:\n{output}{errors}")
+        assert process.returncode == 0, (
+            f"{' '.join(command)} exited {process.returncode}:\n{output}{errors}"
+        )
+    return output
+
+
+def _manifest(dependency: str) -> str:
+    text = (
+        '[package]\nname="pyamplicol-symjit-regressions"\n'
+        'version="0.0.0"\nedition="2021"\npublish=false\n'
+        '[workspace]\n[features]\ndefault=["symbolica"]\n'
+        'symbolica=["symjit/symbolica"]\n[dependencies]\nanyhow="1"\n'
+        f"symjit={{ {dependency}, default-features=false }}\n"
+    )
+    for kind, targets in (("bin", _BINARIES), ("test", _RUST_TESTS)):
+        for name, source in targets.items():
+            text += (
+                f"[[{kind}]]\nname={json.dumps(name)}\npath={json.dumps(str(source))}\n"
+            )
+    return text
+
+
+@pytest.fixture(scope="session")
+def symjit_manifests(tmp_path_factory: pytest.TempPathFactory) -> tuple[Path, Path]:
+    assert shutil.which("cargo"), "these opt-in tests require Rust/Cargo"
+    work = tmp_path_factory.mktemp("symjit-regressions")
+    # Keep the harness beside, not above, a checkout with its own workspace.
+    harness = work / "harness" / "Cargo.toml"
+    harness.parent.mkdir()
+    selected = os.environ.get("PYAMPLICOL_SYMJIT_SOURCE")
+    with (ROOT / "dependencies/release-lock.toml").open("rb") as stream:
+        version = tomllib.load(stream)["symjit"]["version"]
+    dependency = (
+        f"path={json.dumps(str(Path(selected).expanduser().resolve()))}"
+        if selected
+        else f'version="={version}"'
+    )
+    harness.write_text(_manifest(dependency))
+    metadata = json.loads(_cargo(harness, "metadata", "--format-version", "1"))
+    package = next(p for p in metadata["packages"] if p["name"] == "symjit")
+    source = Path(package["manifest_path"]).parent
+    print(f"\nSymJIT {package['version']}: {source}")
+
+    staged = work / "symjit"
+    shutil.copytree(source, staged, ignore=shutil.ignore_patterns(".git", "target"))
+    # Both tests need private lowering types. Append test modules, not fixes,
+    # to the staged source; the selected checkout/registry copy is untouched.
+    for relative, module, test_source in (
+        (
+            "src/symjit/mod.rs",
+            "pyamplicol_return_regression",
+            FOLLOWUP / "compressed-complex-return/mre.rs",
+        ),
+        (
+            "src/symjit/complexify.rs",
+            "pyamplicol_abs_regression",
+            FOLLOWUP / "real-input-locations/abs_mre.rs",
+        ),
+    ):
+        target = staged / relative
+        target.write_text(
+            target.read_text()
+            + f"\n#[cfg(test)]\n#[path={json.dumps(str(test_source))}]\nmod {module};\n"
+        )
+    harness.write_text(_manifest(f"path={json.dumps(str(staged))}"))
+    return harness, staged / "Cargo.toml"
+
+
+@pytest.mark.parametrize(
+    ("kind", "name", "arguments", "arm_only"),
+    [
+        pytest.param("bin", "output_reuse", ("all",), False, id="output-reuse"),
+        pytest.param("bin", "unused_trailing_inputs", (), False, id="trailing-inputs"),
+        pytest.param("test", "compressed_success", (), False, id="compressed-status"),
+        pytest.param("test", "original_arm_registers", (), True, id="original-arm-abi"),
+        pytest.param("bin", "argument_count", ("63",), False, id="arity-63-control"),
+        pytest.param("bin", "argument_count", ("64",), False, id="arity-64"),
+        pytest.param("bin", "argument_count", ("65",), False, id="arity-65"),
+        pytest.param(
+            "bin",
+            "argument_count",
+            ("64", "--no-compress"),
+            False,
+            id="arity-64-uncompressed-control",
+        ),
+        pytest.param("bin", "arm_simd_arguments", (), True, id="arm-real-simd"),
+        pytest.param(
+            "bin",
+            "arm_simd_arguments",
+            ("--no-compress",),
+            True,
+            id="arm-real-simd-uncompressed-control",
+        ),
+        pytest.param("bin", "real_input_locations", (), False, id="real-inputs"),
+        pytest.param("test", "arm_normal_return", (), True, id="arm-normal-return"),
+        pytest.param("test", "arm_fast_complex", (), True, id="arm-fast-complex"),
+    ],
+)
+def test_public_symjit_regression(
+    symjit_manifests: tuple[Path, Path],
+    kind: str,
+    name: str,
+    arguments: tuple[str, ...],
+    arm_only: bool,
+) -> None:
+    if arm_only and not _ARM:
+        pytest.skip("this regression exercises AArch64 machine code")
+    harness, _ = symjit_manifests
+    if kind == "bin":
+        _cargo(harness, "run", "--quiet", "--bin", name, "--", *arguments)
+    else:
+        output = _cargo(harness, "test", "--test", name, "--", "--nocapture")
+        assert "running 1 test" in output, f"Rust test was not exercised:\n{output}"
+
+
+@pytest.mark.parametrize("module", ["return", "abs"])
+def test_private_symjit_lowering_regression(
+    symjit_manifests: tuple[Path, Path], module: str
+) -> None:
+    _, source = symjit_manifests
+    output = _cargo(
+        source, "test", "--lib", f"pyamplicol_{module}_regression", "--", "--nocapture"
+    )
+    assert "running 1 test" in output, f"Lowering test was not exercised:\n{output}"
diff --git a/pyamplicol/tests/integration/test_symmetric_group_fft_hybrid_residual_runtime.py b/pyamplicol/tests/integration/test_symmetric_group_fft_hybrid_residual_runtime.py
new file mode 100644
index 0000000000..7a3151a2e1
--- /dev/null
+++ b/pyamplicol/tests/integration/test_symmetric_group_fft_hybrid_residual_runtime.py
@@ -0,0 +1,289 @@
+# SPDX-License-Identifier: 0BSD
+"""Generated-runtime acceptance for a real hybrid FFT/direct-residual plan.
+
+Run this deliberately bounded acceptance under the repository memory watchdog::
+
+    PYAMPLICOL_RUN_FFT_HYBRID_RESIDUAL_RUNTIME_ACCEPTANCE=1 \
+      .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 -- \
+      .venv/bin/python -m pytest -q \
+      tests/integration/test_symmetric_group_fft_hybrid_residual_runtime.py
+
+The tiny model gives a second adjoint vector a coupling to only one quark
+flavour.  For ``d d~ > u u~ g x`` this leaves both a complete S2 orbit and an
+incomplete fermion-line channel, so the generated recurrence artifact must use
+FFT kernels together with nonzero direct residual/cross rows.
+"""
+
+from __future__ import annotations
+
+import copy
+import importlib
+import importlib.util
+import json
+import os
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import CompiledModel, Generator, ModelSource, Runtime
+from pyamplicol.config import (
+    Action,
+    ColorAccuracy,
+    ColorConfig,
+    ColorContraction,
+    EvaluatorConfig,
+    EvaluatorExecutionMode,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    RelationDiscoveryMode,
+    RunConfig,
+)
+from pyamplicol.generation import recurrence_color as recurrence_color_codec
+from pyamplicol.generation.phase_space import massive_rambo_final_state
+
+_ACCEPTANCE_ENV = "PYAMPLICOL_RUN_FFT_HYBRID_RESIDUAL_RUNTIME_ACCEPTANCE"
+_PROCESS = "d d~ > u u~ g x"
+_HELICITIES = (-1, 1, -1, 1, -1, 1)
+_SM_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+
+pytestmark = pytest.mark.skipif(
+    os.environ.get(_ACCEPTANCE_ENV) != "1",
+    reason=f"set {_ACCEPTANCE_ENV}=1 and run under the 30 GiB watchdog",
+)
+
+
+def _require_native_fft_runtime() -> None:
+    assert importlib.util.find_spec("symbolica") is not None, (
+        "the hybrid FFT runtime acceptance requires Symbolica"
+    )
+    assert importlib.util.find_spec("pyamplicol._rusticol") is not None, (
+        "the hybrid FFT runtime acceptance requires the native Rusticol extension"
+    )
+    rusticol = importlib.import_module("pyamplicol._rusticol")
+    assert hasattr(rusticol, "_lower_recurrence_direct_v2"), (
+        "the installed Rusticol extension lacks recurrence Direct-Arena v2"
+    )
+
+
+def _write_flavour_selective_adjoint_model(root: Path) -> tuple[Path, Path]:
+    raw = json.loads((_SM_ROOT / "sm.json").read_text(encoding="utf-8"))
+
+    particles = {item["name"]: item for item in raw["particles"]}
+    propagators = {item["name"]: item for item in raw["propagators"]}
+    vertices = {item["name"]: item for item in raw["vertex_rules"]}
+    lorentz = {item["name"]: item for item in raw["lorentz_structures"]}
+    couplings = {item["name"]: item for item in raw["couplings"]}
+
+    adjoint = copy.deepcopy(particles["g"])
+    adjoint.update(
+        {
+            "name": "x",
+            "antiname": "x",
+            "pdg_code": 9_900_021,
+            "texname": "x",
+            "antitexname": "x",
+            "propagator": "x_propFeynman",
+        }
+    )
+    adjoint_propagator = copy.deepcopy(propagators["g_propFeynman"])
+    adjoint_propagator.update({"name": "x_propFeynman", "particle": "x"})
+    selective_vertex = copy.deepcopy(vertices["V_74"])
+    selective_vertex.update({"name": "V_fft_hybrid_ddx", "particles": ["d~", "d", "x"]})
+
+    raw["name"] = "fft-hybrid-residual"
+    raw["particles"] = [
+        copy.deepcopy(particles[name]) for name in ("d", "d~", "u", "u~", "g")
+    ] + [adjoint]
+    raw["propagators"] = [
+        copy.deepcopy(propagators[name])
+        for name in (
+            "d_propFeynman",
+            "d~_propFeynman",
+            "u_propFeynman",
+            "u~_propFeynman",
+            "g_propFeynman",
+        )
+    ] + [adjoint_propagator]
+    raw["vertex_rules"] = [
+        copy.deepcopy(vertices["V_74"]),
+        copy.deepcopy(vertices["V_135"]),
+        selective_vertex,
+    ]
+    raw["lorentz_structures"] = [copy.deepcopy(lorentz["FFV1"])]
+    raw["couplings"] = [copy.deepcopy(couplings["GC_11"])]
+    raw["form_factors"] = []
+
+    model_root = root / "model"
+    model_root.mkdir()
+    model_path = model_root / "fft_hybrid_residual.json"
+    model_path.write_text(
+        json.dumps(raw, sort_keys=True, separators=(",", ":")) + "\n",
+        encoding="utf-8",
+    )
+    restriction_path = model_root / "restrict_default.json"
+    restriction_path.write_bytes((_SM_ROOT / restriction_path.name).read_bytes())
+    return model_path, restriction_path
+
+
+def _generation_config(contraction: ColorContraction) -> RunConfig:
+    return RunConfig(
+        action=Action.GENERATE,
+        process=ProcessConfig(
+            selected_source_helicities={
+                str(label): helicity
+                for label, helicity in enumerate(_HELICITIES, start=1)
+            }
+        ),
+        color=ColorConfig(
+            accuracy=ColorAccuracy.FULL,
+            contraction=contraction,
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+            relation_discovery=GenerationRelationDiscoveryConfig(
+                mode=RelationDiscoveryMode.OFF
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=EvaluatorExecutionMode.RECURRENCE,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=1),
+        ),
+    )
+
+
+@pytest.fixture(scope="module")
+def prepared_hybrid_model(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Iterator[CompiledModel]:
+    _require_native_fft_runtime()
+    root = tmp_path_factory.mktemp("fft-hybrid-residual-model")
+    model_path, restriction_path = _write_flavour_selective_adjoint_model(root)
+    model = ModelSource.from_path(
+        model_path,
+        restriction=restriction_path,
+    ).compile(
+        cache_dir=root / "model-cache",
+        use_cache=True,
+        prepared_output=root / "fft-hybrid-residual-jit-o1.pyamplicol-model",
+        evaluator=_generation_config(ColorContraction.DIRECT).evaluator,
+    )
+    assert model.is_prepared
+    yield model
+
+
+def _assert_hybrid_payload(artifact: Path) -> None:
+    execution_paths = tuple((artifact / "processes").glob("*/execution.json"))
+    assert len(execution_paths) == 1
+    execution_path = execution_paths[0]
+    execution = json.loads(execution_path.read_text(encoding="utf-8"))
+    assert execution["kind"] == "pyamplicol-runtime-recurrence-execution"
+    color = execution["runtime_metadata"]["color_contraction"]
+    provenance = color["fft_provenance"]
+
+    assert color["storage"] == "convolution-kernels"
+    assert color["factorization"]["kind"] == "symmetric-group-fourier"
+    assert provenance["degree"] == 2
+    assert provenance["covered_local_group_count"] > 0
+    assert provenance["residual_group_count"] > 0
+    assert provenance["residual_entry_count"] > 0
+
+    residual_count = provenance["residual_group_count"]
+    residual_triangle_count = residual_count * (residual_count + 1) // 2
+    assert provenance["residual_entry_count"] > residual_triangle_count
+
+    degree = provenance["degree"]
+    group_order = 1
+    for value in range(2, degree + 1):
+        group_order *= value
+    channel_count = provenance["channel_count"]
+    kernel_entry_count = channel_count * (channel_count + 1) // 2 * group_order
+
+    payload = (execution_path.parent / color["path"]).read_bytes()
+    header = recurrence_color_codec._HEADER.unpack_from(payload)
+    assert header[0] == recurrence_color_codec.RECURRENCE_COLOR_CONTRACTION_MAGIC
+    assert header[15] == color["entry_count"]
+    residual_rows = tuple(
+        recurrence_color_codec._ENTRY.unpack_from(
+            payload,
+            recurrence_color_codec._HEADER.size
+            + row_index * recurrence_color_codec._ENTRY.size,
+        )
+        for row_index in range(kernel_entry_count, header[15])
+    )
+    assert len(residual_rows) == provenance["residual_entry_count"]
+    covered_count = provenance["covered_local_group_count"]
+    assert any(
+        left < covered_count <= right and (weight_re != 0.0 or weight_im != 0.0)
+        for left, right, weight_re, weight_im, _symmetry, _exact_id in residual_rows
+    )
+
+
+def _point() -> tuple[tuple[tuple[float, ...], ...], ...]:
+    return (
+        (
+            (500.0, 0.0, 0.0, 500.0),
+            (500.0, 0.0, 0.0, -500.0),
+            *tuple(
+                tuple(float(component) for component in momentum)
+                for momentum in massive_rambo_final_state(
+                    4,
+                    sqrt_s=1000.0,
+                    masses=(0.0, 0.0, 0.0, 0.0),
+                    seed=101,
+                )
+            ),
+        ),
+    )
+
+
+def test_generated_recurrence_hybrid_fft_residual_matches_direct(
+    tmp_path: Path,
+    prepared_hybrid_model: CompiledModel,
+) -> None:
+    artifacts = {
+        contraction: tmp_path / contraction.value
+        for contraction in (
+            ColorContraction.DIRECT,
+            ColorContraction.SYMMETRIC_GROUP_FFT,
+        )
+    }
+    for contraction, artifact in artifacts.items():
+        Generator(_generation_config(contraction)).generate(
+            _PROCESS,
+            artifact,
+            model=prepared_hybrid_model,
+        )
+
+    fft_artifact = artifacts[ColorContraction.SYMMETRIC_GROUP_FFT]
+    _assert_hybrid_payload(fft_artifact)
+
+    direct = Runtime.load(artifacts[ColorContraction.DIRECT])
+    fft = Runtime.load(fft_artifact)
+    try:
+        direct_value = tuple(complex(value) for value in direct.evaluate(_point()))
+        fft_value = tuple(complex(value) for value in fft.evaluate(_point()))
+        assert len(direct_value) == len(fft_value) == 1
+        assert abs(direct_value[0]) > 0.0
+        assert fft_value == pytest.approx(direct_value, rel=1.0e-10, abs=1.0e-18)
+    finally:
+        direct.clear()
+        fft.clear()
diff --git a/pyamplicol/tests/integration/test_symmetric_group_fft_s4_runtime.py b/pyamplicol/tests/integration/test_symmetric_group_fft_s4_runtime.py
new file mode 100644
index 0000000000..e869fc5446
--- /dev/null
+++ b/pyamplicol/tests/integration/test_symmetric_group_fft_s4_runtime.py
@@ -0,0 +1,281 @@
+# SPDX-License-Identifier: 0BSD
+"""Focused generated-runtime acceptance for the nontrivial S4 FFT channel.
+
+Run this deliberately bounded, but expensive, acceptance under the repository
+memory watchdog::
+
+    PYAMPLICOL_RUN_FFT_S4_RUNTIME_ACCEPTANCE=1 \
+      .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 20 -- \
+      .venv/bin/python -m pytest -q \
+      tests/integration/test_symmetric_group_fft_s4_runtime.py
+
+The test is skipped in ordinary suites because it generates direct and FFT
+artifacts for an eight-particle process in both native execution lanes.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import json
+import os
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, Runtime
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    Action,
+    ColorAccuracy,
+    ColorConfig,
+    ColorContraction,
+    EvaluatorConfig,
+    EvaluatorExecutionMode,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    RelationDiscoveryMode,
+    RunConfig,
+)
+from pyamplicol.models.builtin.validation import generic_validation_point
+
+_ACCEPTANCE_ENV = "PYAMPLICOL_RUN_FFT_S4_RUNTIME_ACCEPTANCE"
+_FFT_CAPABILITY = "rusticol.color-contraction.symmetric-group-fft.v1"
+_PROCESS = "d d~ > u u~ g g g g"
+_HELICITIES = (-1, 1, -1, 1, -1, 1, -1, 1)
+_HELICITY_ID = "h:-1,+1,-1,+1,-1,+1,-1,+1"
+_ALPHA_S_PARAMETER = "normalization.alpha_s_me_check"
+_UPDATED_ALPHA_S = 0.13
+
+pytestmark = pytest.mark.skipif(
+    os.environ.get(_ACCEPTANCE_ENV) != "1",
+    reason=f"set {_ACCEPTANCE_ENV}=1 and run under the 20 GiB watchdog",
+)
+
+
+def _require_native_fft_runtime() -> None:
+    assert importlib.util.find_spec("symbolica") is not None, (
+        "the S4 FFT runtime acceptance requires Symbolica"
+    )
+    assert importlib.util.find_spec("pyamplicol._rusticol") is not None, (
+        "the S4 FFT runtime acceptance requires the native Rusticol extension"
+    )
+    rusticol = importlib.import_module("pyamplicol._rusticol")
+    assert hasattr(rusticol, "_lower_recurrence_direct_v2"), (
+        "the installed Rusticol extension lacks recurrence Direct-Arena v2"
+    )
+    assert hasattr(rusticol, "_build_on_the_fly_process_seeds_v1"), (
+        "the installed Rusticol extension lacks on-the-fly generation"
+    )
+
+
+@pytest.fixture(scope="module")
+def prepared_builtin_sm() -> Iterator[ModelSource]:
+    _require_native_fft_runtime()
+    override = os.environ.get("PYAMPLICOL_RECURRENCE_TEST_PREPARED_MODEL")
+    if override:
+        yield ModelSource.from_path(Path(override))
+        return
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+        yield ModelSource.from_path(prepared_model)
+
+
+def _generation_config(
+    lane: EvaluatorExecutionMode,
+    contraction: ColorContraction,
+) -> RunConfig:
+    selected = (
+        {str(label): helicity for label, helicity in enumerate(_HELICITIES, start=1)}
+        if lane is EvaluatorExecutionMode.RECURRENCE
+        else {}
+    )
+    return RunConfig(
+        action=Action.GENERATE,
+        process=ProcessConfig(selected_source_helicities=selected),
+        color=ColorConfig(
+            accuracy=ColorAccuracy.FULL,
+            contraction=contraction,
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+            relation_discovery=GenerationRelationDiscoveryConfig(
+                mode=RelationDiscoveryMode.OFF
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=lane,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+def _point() -> tuple[tuple[tuple[float, ...], ...], ...]:
+    return (
+        tuple(
+            tuple(float(component) for component in particle.momentum)
+            for particle in generic_validation_point(_PROCESS, seed=101)
+        ),
+    )
+
+
+def _assert_s4_fft_payload(artifact: Path, lane: EvaluatorExecutionMode) -> None:
+    execution_paths = tuple((artifact / "processes").glob("*/execution.json"))
+    assert len(execution_paths) == 1
+    execution = json.loads(execution_paths[0].read_text(encoding="utf-8"))
+    expected_kind = (
+        "pyamplicol-runtime-recurrence-execution"
+        if lane is EvaluatorExecutionMode.RECURRENCE
+        else "pyamplicol-runtime-on-the-fly-execution"
+    )
+    assert execution["kind"] == expected_kind
+    assert _FFT_CAPABILITY in execution["required_runtime_capabilities"]
+
+    color = execution["runtime_metadata"]["color_contraction"]
+    assert color["storage"] == "convolution-kernels"
+    assert color["factorization"] == {
+        "kind": "symmetric-group-fourier",
+        "rank": 4,
+        "coset_count": 10,
+    }
+    assert color["sector_count"] == 480
+    assert color["group_count"] == 240
+    assert color["fft_provenance"] == {
+        "method": "symmetric-group-fourier",
+        "degree": 4,
+        "channel_count": 10,
+        "covered_local_group_count": 240,
+        "residual_group_count": 0,
+        "residual_entry_count": 0,
+        "raw_kernel_bytes": 21_120,
+        "transformed_kernel_bytes": 10_560,
+        "capability": _FFT_CAPABILITY,
+    }
+
+
+def _evaluate_selected(
+    runtime: Runtime,
+    point: tuple[tuple[tuple[float, ...], ...], ...],
+) -> tuple[complex, ...]:
+    return tuple(
+        complex(value)
+        for value in runtime.evaluate(
+            point,
+            helicities=(_HELICITY_ID,),
+        )
+    )
+
+
+def _assert_repeated_warm_up_is_local(
+    runtime: Runtime,
+    isolated_runtime: Runtime,
+    point: tuple[tuple[tuple[float, ...], ...], ...],
+) -> None:
+    first = runtime.warm_up(point, helicities=(_HELICITY_ID,))
+    repeated = runtime.warm_up(point, helicities=(_HELICITY_ID,))
+    isolated_first = isolated_runtime.warm_up(point, helicities=(_HELICITY_ID,))
+
+    assert first.query_count > 0
+    assert first.warmed_query_count > 0
+    assert first.already_warm is False
+    assert repeated.query_count == first.query_count
+    assert repeated.warmed_query_count == 0
+    assert repeated.already_warm is True
+    assert isolated_first.query_count == first.query_count
+    assert isolated_first.warmed_query_count > 0
+    assert isolated_first.already_warm is False
+
+
+@pytest.mark.parametrize(
+    "lane",
+    (
+        EvaluatorExecutionMode.RECURRENCE,
+        EvaluatorExecutionMode.ON_THE_FLY,
+    ),
+)
+def test_generated_s4_fft_runtime_matches_direct_and_keeps_instances_independent(
+    tmp_path: Path,
+    prepared_builtin_sm: ModelSource,
+    lane: EvaluatorExecutionMode,
+) -> None:
+    direct_artifact = tmp_path / f"{lane.value}-direct"
+    fft_artifact = tmp_path / f"{lane.value}-fft"
+    for artifact, contraction in (
+        (direct_artifact, ColorContraction.DIRECT),
+        (fft_artifact, ColorContraction.SYMMETRIC_GROUP_FFT),
+    ):
+        Generator(_generation_config(lane, contraction)).generate(
+            _PROCESS,
+            artifact,
+            model=prepared_builtin_sm,
+        )
+
+    _assert_s4_fft_payload(fft_artifact, lane)
+    point = _point()
+    direct = Runtime.load(direct_artifact)
+    fft = Runtime.load(fft_artifact)
+    isolated_fft = Runtime.load(fft_artifact)
+    runtimes = (direct, fft, isolated_fft)
+    try:
+        if lane is EvaluatorExecutionMode.ON_THE_FLY:
+            _assert_repeated_warm_up_is_local(fft, isolated_fft, point)
+            direct.warm_up(point, helicities=(_HELICITY_ID,))
+
+        direct_default = _evaluate_selected(direct, point)
+        fft_default = _evaluate_selected(fft, point)
+        isolated_default = _evaluate_selected(isolated_fft, point)
+        assert fft_default == pytest.approx(
+            direct_default,
+            rel=1.0e-10,
+            abs=1.0e-18,
+        )
+        assert isolated_default == pytest.approx(
+            fft_default,
+            rel=1.0e-13,
+            abs=1.0e-20,
+        )
+        assert any(abs(value) > 0.0 for value in fft_default)
+
+        direct.set_model_parameters({_ALPHA_S_PARAMETER: _UPDATED_ALPHA_S})
+        fft.set_model_parameters({_ALPHA_S_PARAMETER: _UPDATED_ALPHA_S})
+        direct_updated = _evaluate_selected(direct, point)
+        fft_updated = _evaluate_selected(fft, point)
+        assert fft_updated == pytest.approx(
+            direct_updated,
+            rel=1.0e-10,
+            abs=1.0e-18,
+        )
+        assert fft_updated == pytest.approx(
+            _evaluate_selected(fft, point),
+            rel=1.0e-13,
+            abs=1.0e-20,
+        )
+        assert fft_updated != pytest.approx(
+            fft_default,
+            rel=1.0e-8,
+            abs=1.0e-20,
+        )
+
+        # The second handle must retain both its default parameters and its own
+        # warmed-family state after the first handle is changed and evaluated.
+        assert _evaluate_selected(isolated_fft, point) == pytest.approx(
+            isolated_default,
+            rel=1.0e-13,
+            abs=1.0e-20,
+        )
+    finally:
+        for runtime in reversed(runtimes):
+            runtime.clear()
diff --git a/pyamplicol/tests/integration/test_umami_api.py b/pyamplicol/tests/integration/test_umami_api.py
new file mode 100644
index 0000000000..4961506b7d
--- /dev/null
+++ b/pyamplicol/tests/integration/test_umami_api.py
@@ -0,0 +1,1018 @@
+# SPDX-License-Identifier: 0BSD
+"""Bounded native-provider checks; reuse the already staged Rusticol SDK."""
+
+from __future__ import annotations
+
+import ctypes as ct
+import importlib.util
+import json
+import math
+import os
+import shutil
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, ProcessSet, Runtime
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    RunConfig,
+)
+
+
+def _unavailable(reason):
+    if os.environ.get("PYAMPLICOL_REQUIRE_NATIVE_TESTS") == "1":
+        pytest.fail(reason)
+    pytest.skip(reason)
+
+
+def _config_executable():
+    configured = os.environ.get("RUSTICOL_CONFIG")
+    candidates = (
+        configured,
+        str(Path(sys.executable).parent / "rusticol-config"),
+        shutil.which("rusticol-config"),
+    )
+    for candidate in candidates:
+        if candidate and (shutil.which(candidate) or Path(candidate).is_file()):
+            return candidate
+    _unavailable(
+        "UMAMI native integration requires the staged rusticol-config executable"
+    )
+
+
+def _library(path):
+    library = ct.CDLL(str(path))
+    library.umami_initialize.argtypes = (ct.POINTER(ct.c_void_p), ct.c_char_p)
+    library.umami_free.argtypes = (ct.c_void_p,)
+    library.umami_get_meta.argtypes = (ct.c_int, ct.c_void_p)
+    for name in ("supported_inputs", "required_inputs", "supported_outputs"):
+        getattr(library, "umami_" + name).argtypes = (
+            ct.POINTER(ct.POINTER(ct.c_bool)),
+            ct.POINTER(ct.c_int),
+        )
+    library.umami_get_parameter.argtypes = (
+        ct.c_void_p,
+        ct.c_char_p,
+        ct.POINTER(ct.c_double),
+        ct.POINTER(ct.c_double),
+    )
+    library.umami_set_parameter.argtypes = (
+        ct.c_void_p,
+        ct.c_char_p,
+        ct.c_double,
+        ct.c_double,
+    )
+    library.umami_matrix_element.argtypes = (
+        ct.c_void_p,
+        ct.c_size_t,
+        ct.c_size_t,
+        ct.c_size_t,
+        ct.c_size_t,
+        ct.POINTER(ct.c_int),
+        ct.POINTER(ct.c_void_p),
+        ct.c_size_t,
+        ct.POINTER(ct.c_int),
+        ct.POINTER(ct.c_void_p),
+    )
+    return library
+
+
+@dataclass
+class Provider:
+    artifact: Path
+    build: Path
+    data: dict
+    library: object
+    structural_keys: list[dict]
+
+    @contextmanager
+    def handle(self):
+        value = ct.c_void_p()
+        assert (
+            self.library.umami_initialize(ct.byref(value), os.fsencode(self.artifact))
+            == 0
+        )
+        assert value.value is not None
+        try:
+            yield value
+        finally:
+            assert self.library.umami_free(value) == 0
+
+
+@pytest.fixture(
+    scope="module",
+    params=(
+        pytest.param(("lc", False), id="lc"),
+        pytest.param(("lc5", False), id="lc-identical-ggg"),
+        pytest.param(("lcq", False), id="lc-identical-quarks"),
+        pytest.param(("full", False), id="full"),
+        pytest.param(("nlc", False), id="nlc"),
+        pytest.param(("lc", True), id="restricted-helicity"),
+        pytest.param(("ufo", False), id="ufo-flavours"),
+    ),
+)
+def providers(request, tmp_path_factory):
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    if shutil.which("make") is None or shutil.which(os.environ.get("CC", "cc")) is None:
+        _unavailable("UMAMI integration requires make and a C compiler")
+    config_executable = _config_executable()
+    accuracy, restricted = request.param
+    is_ufo = accuracy == "ufo"
+    is_ggg = accuracy == "lc5"
+    is_qqg = accuracy == "lcq"
+    if is_ufo:
+        accuracy = "full"
+    elif is_ggg or is_qqg:
+        accuracy = "lc"
+    root = tmp_path_factory.mktemp("umami-" + accuracy)
+    artifact, build = root / "artifact with spaces", root / "build with spaces"
+    config = RunConfig(
+        action="generate",
+        process=ProcessConfig(
+            selected_source_helicities={"1": -1, "2": 1, "3": -1, "4": 1}
+            if restricted
+            else {},
+        ),
+        color=ColorConfig(accuracy=accuracy),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=True,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="recurrence",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+    # The massive colour singlet forces a separate fixed-mass provider, while
+    # retaining quark colour flow and generic UFO parameter declarations.
+    include_quark = not (is_ggg or is_qqg) and (
+        accuracy == "full" or (accuracy == "lc" and not restricted)
+    )
+    expressions = (
+        ("g g > g g g",)
+        if is_ggg
+        else ("d d > d d g",)
+        if is_qqg
+        else ("g g > g g", "d d~ > z g")
+        if include_quark
+        else ("g g > g g",)
+    )
+    names = (
+        ("ggg",)
+        if is_ggg
+        else ("dd_ddg",)
+        if is_qqg
+        else ("gg", "dd_zg")
+        if include_quark
+        else ("gg",)
+    )
+    from pyamplicol.generation import umami_semantics
+
+    original_keys = umami_semantics.recurrence_structural_keys
+    observed_keys = []
+
+    def record_keys(**kwargs):
+        keys = original_keys(**kwargs)
+        observed_keys.append(keys)
+        return keys
+
+    with pytest.MonkeyPatch.context() as patch:
+        patch.setattr(umami_semantics, "recurrence_structural_keys", record_keys)
+        if is_ufo:
+            from tests.integration.umami_fixtures import equivalent_scalar_model
+
+            model, requests = equivalent_scalar_model(root / "ufo-source")
+            prepared = model.compile(
+                cache_dir=root / "model-cache",
+                prepared_output=root / "equivalent-scalars.pyamplicol-model",
+                evaluator=config.evaluator,
+            )
+            Generator(config).generate(
+                requests,
+                artifact,
+                model=prepared,
+            )
+        else:
+            with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+                Generator(config).generate(
+                    ProcessSet.from_expressions(expressions, names=names),
+                    artifact,
+                    model=ModelSource.from_path(prepared_model),
+                )
+    completed = subprocess.run(
+        [
+            "make",
+            "-C",
+            str(artifact / "API/umami"),
+            f"BUILD_DIR={build}",
+            f"RUSTICOL_CONFIG={config_executable}",
+        ],
+        env=dict(
+            os.environ, PYTHONPATH=str(Path(__file__).resolve().parents[2] / "src")
+        ),
+        capture_output=True,
+        text=True,
+        timeout=180,
+        check=False,
+    )
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+    root_metadata = json.loads((artifact / "API/umami/metadata.json").read_text())
+    paths = sorted((artifact / "API/umami/providers").glob("*/metadata.json"))
+    documents = (
+        [json.loads(path.read_text()) for path in paths] if paths else [root_metadata]
+    )
+    assert len(documents) == (1 if is_ufo else len(expressions))
+    if is_ufo:
+        assert documents[0]["provider"]["supports_alpha_s"]
+        assert all(
+            process["alpha_s_parameter"] == "aS"
+            for process in documents[0]["runtime_processes"]
+        )
+    if restricted:
+        assert (
+            documents[0]["runtime_processes"][0]["coverage"]["helicities"] == "selected"
+        )
+        assert len(documents[0]["runtime_processes"][0]["helicity_ids"]) == 1
+    if is_ggg:
+        data = documents[0]
+        assert len(data["channels"]) == 4
+        assert data["grouping"]["physical_contributions"] == 24
+        assert [channel["phasespace_order"] for channel in data["channels"]] == [
+            [0, 1, 2, 3, 4],
+            [0, 2, 1, 3, 4],
+            [0, 2, 3, 1, 4],
+            [0, 2, 3, 4, 1],
+        ]
+        for channel in data["channels"]:
+            (entry,) = channel["processes"]
+            assert len(entry["members"]) == 6
+            assert entry["matrix_elements"] == [{"pdg_ids": 0, "factor": 6.0}]
+    if is_qqg:
+        grouping_metadata = documents[0]["grouping"]
+        assert (
+            grouping_metadata["exported_contributions"]
+            < grouping_metadata["physical_contributions"]
+        )
+    return [
+        Provider(
+            artifact,
+            build,
+            data,
+            _library(build / data["provider"]["library"]),
+            observed_keys,
+        )
+        for data in documents
+    ]
+
+
+def _entry(provider, channel=0, flavour=0):
+    return provider.data["channels"][channel]["processes"][flavour]["runtime"]
+
+
+def _runtime_point(provider, process_id):
+    lines = (provider.artifact / "API/validation_points.dat").read_text().splitlines()
+    fields = next(line.split() for line in lines[1:] if line.split()[0] == process_id)
+    components = tuple(float(value) for value in fields[2:])
+    assert len(components) == 4 * int(fields[1])
+    return tuple(
+        components[index : index + 4] for index in range(0, len(components), 4)
+    )
+
+
+def _point(provider, entry):
+    point = _runtime_point(provider, entry["process_id"])
+    # The provider maps physical slots to representative runtime slots.
+    physical = [None] * len(point)
+    for runtime_slot, physical_slot in enumerate(entry["permutation"]):
+        physical[physical_slot] = point[runtime_slot]
+    return tuple(physical)
+
+
+def _member_input(representative, member, point):
+    # Compose the two physical-to-representative maps without changing the
+    # physical labelling on which a consumer applies cuts or flavour weights.
+    mapped = [None] * len(point)
+    for j, slot in enumerate(representative["permutation"]):
+        mapped[slot] = point[member["runtime"]["permutation"][j]]
+    return tuple(mapped)
+
+
+def _expected(provider, entry, point, parameters=None):
+    runtime = Runtime.load(provider.artifact, process=entry["process_id"])
+    if parameters:
+        runtime.set_model_parameters(parameters)
+    runtime_point = tuple(point[index] for index in entry["permutation"])
+    selected = None if entry["color_id"] is None else (entry["color_id"],)
+    return (
+        float(complex(runtime.evaluate((runtime_point,), color_flows=selected)[0]).real)
+        * entry["factor"]
+    )
+
+
+def _batch(
+    provider,
+    handle,
+    points,
+    *,
+    channel=0,
+    flavour=0,
+    alpha_s=None,
+    offset=0,
+    count=None,
+    helicity=None,
+):
+    stride, n = len(points), len(points[0])
+    momenta = (ct.c_double * (4 * n * stride))(
+        *(
+            float(points[event][leg][component])
+            for component in range(4)
+            for leg in range(n)
+            for event in range(stride)
+        )
+    )
+    inputs = {
+        0: momenta,
+        2: (ct.c_int * stride)(*[flavour] * stride),
+        4: (ct.c_double * stride)(*[0.5] * stride),
+        8: (ct.c_uint * stride)(*[channel] * stride),
+    }
+    if alpha_s is not None:
+        inputs[1] = (ct.c_double * stride)(*alpha_s)
+    if helicity is not None:
+        inputs[6] = (ct.c_int * stride)(*[helicity] * stride)
+    outputs = {
+        0: (ct.c_double * stride)(*[-123.0] * stride),
+        3: (ct.c_int * stride)(*[-123] * stride),
+    }
+    if provider.data["provider"]["color_accuracy"] == "lc":
+        outputs[2] = (ct.c_int * stride)(*[-123] * stride)
+    status = provider.library.umami_matrix_element(
+        handle,
+        stride - offset if count is None else count,
+        stride,
+        offset,
+        len(inputs),
+        (ct.c_int * len(inputs))(*inputs),
+        (ct.c_void_p * len(inputs))(
+            *(ct.cast(value, ct.c_void_p) for value in inputs.values())
+        ),
+        len(outputs),
+        (ct.c_int * len(outputs))(*outputs),
+        (ct.c_void_p * len(outputs))(
+            *(ct.cast(value, ct.c_void_p) for value in outputs.values())
+        ),
+    )
+    return status, {key: list(value) for key, value in outputs.items()}
+
+
+def _parameter(provider, handle, name):
+    real, imaginary = ct.c_double(), ct.c_double()
+    assert (
+        provider.library.umami_get_parameter(
+            handle, name.encode(), ct.byref(real), ct.byref(imaginary)
+        )
+        == 0
+    )
+    return complex(real.value, imaginary.value)
+
+
+def test_metadata_capabilities_and_hidden_native_symbols(providers):
+    for provider in providers:
+        with pytest.raises(AttributeError):
+            _ = provider.library.rusticol_runtime_load
+        count = ct.c_int()
+        assert provider.library.umami_get_meta(1, ct.byref(count)) == 0
+        assert count.value == provider.data["provider"]["particle_count"]
+        masses = (ct.c_double * count.value)()
+        assert provider.library.umami_get_meta(5, masses) == 0
+        assert list(masses) == provider.data["provider"]["masses"]
+        assert provider.library.umami_get_meta(2, ct.byref(count)) == 6
+        has_color = provider.data["provider"]["color_accuracy"] == "lc"
+        assert provider.library.umami_get_meta(4, ct.byref(count)) == (
+            0 if has_color else 6
+        )
+        if has_color and provider.data["runtime_processes"][0]["id"] == "dd_zg":
+            for channel in provider.data["channels"]:
+                for entry in channel["processes"]:
+                    quark, antiquark, boson, gluon = provider.data["color_flows"][
+                        entry["color_flows"]
+                    ]
+                    assert quark[1] == antiquark[0] == 0
+                    assert boson == [0, 0]
+                    assert quark[0] == gluon[0] > 0
+                    assert antiquark[1] == gluon[1] > 0
+                    assert gluon[0] != gluon[1]
+        for operation in ("supported_inputs", "required_inputs", "supported_outputs"):
+            values, length = ct.POINTER(ct.c_bool)(), ct.c_int()
+            assert (
+                getattr(provider.library, "umami_" + operation)(
+                    ct.byref(values), ct.byref(length)
+                )
+                == 0
+            )
+            flags = list(values[: length.value])
+            if operation == "required_inputs":
+                assert flags == [True] + [False] * (len(flags) - 1)
+            elif operation == "supported_inputs":
+                assert flags[1] == provider.data["provider"]["supports_alpha_s"]
+                assert flags[6] and not flags[3] and not flags[5] and not flags[7]
+                assert not any(flags[9:])
+            else:
+                assert flags == [True, False, has_color, True] + [False] * (
+                    len(flags) - 4
+                )
+
+
+def test_all_exported_flavours_match_native_and_preserve_stride(providers):
+    for provider in providers:
+        with provider.handle() as handle:
+            for channel, description in enumerate(provider.data["channels"]):
+                for flavour in range(len(description["processes"])):
+                    entry = _entry(provider, channel, flavour)
+                    point = _point(provider, entry)
+                    expected = _expected(provider, entry, point)
+                    status, outputs = _batch(
+                        provider,
+                        handle,
+                        (point,) * 3,
+                        channel=channel,
+                        flavour=flavour,
+                        offset=1,
+                        count=1,
+                    )
+                    assert status == 0
+                    assert outputs[0] == pytest.approx(
+                        [-123.0, expected, -123.0], rel=2e-11, abs=1e-15
+                    )
+                    if 2 in outputs:
+                        assert outputs[2] == [-123, entry["color_index"], -123]
+                    assert outputs[3][::2] == [-123, -123]
+                    assert 0 <= outputs[3][1] < len(provider.data["helicities"])
+
+
+def test_grouped_members_match_physical_flows_at_asymmetric_point(providers):
+    for provider in providers:
+        reconstructed, complete = {}, {}
+        cut_native, cut_umami = 0.0, 0.0
+        cut_decisions = set()
+        with provider.handle() as handle:
+            for channel, description in enumerate(provider.data["channels"]):
+                for flavour, exported in enumerate(description["processes"]):
+                    representative = exported["runtime"]
+                    for member in exported["members"]:
+                        runtime = Runtime.load(
+                            provider.artifact, process=member["process_id"]
+                        )
+                        point = (
+                            (
+                                (500, 0, 0, 500),
+                                (500, 0, 0, -500),
+                                (500, 300, 0, 400),
+                                (500, -300, 0, -400),
+                            )
+                            if member["process_id"] == "gg"
+                            else _runtime_point(provider, member["process_id"])
+                        )
+                        selection = (
+                            None
+                            if member["color_id"] is None
+                            else (member["color_id"],)
+                        )
+                        expected = float(
+                            complex(
+                                runtime.evaluate((point,), color_flows=selection)[0]
+                            ).real
+                        )
+                        process_id = member["process_id"]
+                        if process_id not in complete:
+                            complete[process_id] = float(
+                                complex(runtime.evaluate((point,))[0]).real
+                            )
+                        # Both maps name the same representative runtime slots.
+                        # Test each member at its own physical momenta; do not
+                        # confuse integrated multiplicity with pointwise sum.
+                        mapped = _member_input(representative, member, point)
+                        status, outputs = _batch(
+                            provider,
+                            handle,
+                            (mapped,),
+                            channel=channel,
+                            flavour=flavour,
+                        )
+                        assert status == 0
+                        assert outputs[0][0] == pytest.approx(
+                            expected, rel=2e-11, abs=1e-15
+                        )
+                        reconstructed[process_id] = (
+                            reconstructed.get(process_id, 0.0)
+                            + outputs[0][0] * member["factor"]
+                        )
+                        if process_id == "gg":
+                            # An explicitly labelled-leg cut is not invariant
+                            # under exchanging the two final-state gluons.
+                            samples = (point, (*point[:2], point[3], point[2]))
+                        elif process_id in ("flavour_one", "flavour_two"):
+                            samples = (point,)
+                        else:
+                            continue
+                        for sample in samples:
+                            accepted = (
+                                sample[2][3] > 0
+                                if process_id == "gg"
+                                else member["pdgs"][2] == 1001
+                            )
+                            cut_decisions.add(accepted)
+                            status, selected = _batch(
+                                provider,
+                                handle,
+                                (_member_input(representative, member, sample),),
+                                channel=channel,
+                                flavour=flavour,
+                            )
+                            assert status == 0
+                            physical = float(
+                                complex(
+                                    runtime.evaluate((sample,), color_flows=selection)[
+                                        0
+                                    ]
+                                ).real
+                            )
+                            weight = member["factor"] if accepted else 0.0
+                            cut_native += weight * physical
+                            cut_umami += weight * selected[0][0]
+        # The member loop restores each labelled physical flow, including
+        # cross-flavour compaction; an orbit factor is not a pointwise sum.
+        assert reconstructed == pytest.approx(complete, rel=2e-11, abs=1e-15)
+        if cut_decisions:
+            assert cut_decisions == {False, True}
+            assert cut_native > 0
+            assert cut_umami == pytest.approx(cut_native, rel=2e-11, abs=1e-15)
+
+
+def test_parameters_event_override_and_independent_concurrent_handles(providers):
+    for provider in providers:
+        entry = _entry(provider)
+        description = provider.data["runtime_processes"][entry["process_index"]]
+        supports_alpha_s = provider.data["provider"]["supports_alpha_s"]
+        name = (
+            description["alpha_s_parameter"]
+            if supports_alpha_s
+            else next(
+                parameter["name"]
+                for parameter in description["parameters"]
+                if parameter["mutable"]
+                and parameter["default_real"] > 0
+                and not parameter.get("is_complex", False)
+            )
+        )
+        point = _point(provider, entry)
+        with provider.handle() as first, provider.handle() as second:
+            original = _parameter(provider, first, name)
+            assert original.imag == 0 and original.real > 0
+            changed = original.real * 1.2
+            assert (
+                provider.library.umami_set_parameter(first, name.encode(), changed, 0.0)
+                == 0
+            )
+            assert _parameter(provider, first, name) == changed
+            assert _parameter(provider, second, name) == original
+            if entry["process_id"] == "flavour_one":
+                assert _parameter(provider, first, "G") == pytest.approx(
+                    math.sqrt(4 * math.pi * changed)
+                )
+                # Recheck both physical UFO flavours after mutation, including
+                # the one whose computation is provided by its representative.
+                checked = set()
+                for channel, description in enumerate(provider.data["channels"]):
+                    for flavour, exported in enumerate(description["processes"]):
+                        for member in exported["members"]:
+                            physical = _runtime_point(provider, member["process_id"])
+                            native = Runtime.load(
+                                provider.artifact, process=member["process_id"]
+                            )
+                            native.set_model_parameters({name: changed})
+                            status, result = _batch(
+                                provider,
+                                first,
+                                (_member_input(exported["runtime"], member, physical),),
+                                channel=channel,
+                                flavour=flavour,
+                            )
+                            assert status == 0
+                            assert result[0][0] == pytest.approx(
+                                float(complex(native.evaluate((physical,))[0]).real),
+                                rel=2e-11,
+                            )
+                            checked.add(member["process_id"])
+                assert checked == {"flavour_one", "flavour_two"}
+            event_values = (original.real * 0.8, original.real * 1.1)
+            status, outputs = _batch(
+                provider, first, (point,) * 2, alpha_s=event_values
+            )
+            if supports_alpha_s:
+                assert status == 0
+                expected = [
+                    _expected(provider, entry, point, {name: value})
+                    for value in event_values
+                ]
+                assert outputs[0] == pytest.approx(expected, rel=2e-11)
+                if entry["process_id"] == "flavour_one":
+                    assert outputs[0][0] / outputs[0][1] == pytest.approx(
+                        (event_values[0] / event_values[1]) ** 2, rel=2e-11
+                    )
+            else:
+                assert status == 3  # No generic alpha_s name may be invented.
+            assert _parameter(provider, first, name) == changed
+            with ThreadPoolExecutor(max_workers=2) as pool:
+                futures = [
+                    pool.submit(_batch, provider, handle, (point,))
+                    for handle in (first, second)
+                ]
+                values = [future.result() for future in futures]
+            for (status, outputs), value in zip(
+                values, (changed, original.real), strict=True
+            ):
+                assert status == 0
+                assert outputs[0][0] == pytest.approx(
+                    _expected(provider, entry, point, {name: value}), rel=2e-11
+                )
+            assert (
+                provider.library.umami_set_parameter(first, b"does-not-exist", 1.0, 0.0)
+                == 1
+            )
+
+
+def test_fixed_helicities_and_sampled_helicity(providers):
+    for provider in providers:
+        with provider.handle() as handle:
+            entry = _entry(provider)
+            exported = provider.data["channels"][0]["processes"][0]["runtime"]
+            point = _point(provider, entry)
+            status, outputs = _batch(provider, handle, (point,))
+            assert status == 0
+            total, label = outputs[0][0], outputs[3][0]
+            values = {}
+            for index in exported["helicity_export"]:
+                status, fixed = _batch(provider, handle, (point,), helicity=index)
+                assert status == 0 and fixed[3] == [index]
+                values[index] = fixed[0][0]
+            assert sum(values.values()) == pytest.approx(total, rel=1e-12)
+            # the label of the random number 0.5 in the runtime helicity order
+            cumulative, expected = 0.0, None
+            for index in exported["helicity_export"]:
+                if values[index] <= 0.0:
+                    continue
+                expected, cumulative = index, cumulative + values[index]
+                if cumulative > 0.5 * total:
+                    break
+            assert label == expected
+
+
+def test_error_contract_and_zero_count(providers):
+    for provider in providers:
+        invalid = ct.c_void_p(123)
+        assert (
+            provider.library.umami_initialize(ct.byref(invalid), b"relative/artifact")
+            == 1
+        )
+        assert invalid.value is None
+        with provider.handle() as handle:
+            evaluate = provider.library.umami_matrix_element
+            assert evaluate(handle, 0, 0, 0, 0, None, None, 0, None, None) == 0
+            assert evaluate(handle, 1, 1, 0, 0, None, None, 0, None, None) == 7
+            assert evaluate(handle, 1, 1, 1, 0, None, None, 0, None, None) == 1
+            selector = ct.c_int(0)
+            pointer = (ct.c_void_p * 1)(ct.cast(ct.byref(selector), ct.c_void_p))
+            assert (
+                evaluate(handle, 0, 0, 0, 1, (ct.c_int * 1)(7), pointer, 0, None, None)
+                == 3
+            )
+            assert (
+                evaluate(handle, 0, 0, 0, 0, None, None, 1, (ct.c_int * 1)(1), pointer)
+                == 4
+            )
+            point = _point(provider, _entry(provider))
+            assert _batch(provider, handle, (point,), channel=999)[0] == 1
+            assert _batch(provider, handle, (point,), flavour=-1)[0] == 1
+
+
+def test_rejects_other_valid_artifact_with_identical_external_labels(
+    providers, tmp_path
+):
+    provider = providers[0]
+    if not (
+        provider.data["provider"]["color_accuracy"] == "lc"
+        and provider.data["provider"]["helicity_count"] > 1
+        and provider.data["runtime_processes"][0]["id"] == "gg"
+    ):
+        return
+    # A genuinely generated artifact with a different native layout, not a
+    # damaged manifest or a change of SDK metadata alone. Particle/helicity
+    # labels and colour accuracy by themselves cannot protect compiled tables.
+    other = tmp_path / "different native artifact"
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc", lc_flow_layout="all-flow-union"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="recurrence",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as model:
+        Generator(config).generate(
+            ProcessSet.from_expressions(("g g > g g",), names=("gg",)),
+            other,
+            model=ModelSource.from_path(model),
+        )
+    manifest = json.loads((other / "artifact.json").read_text())
+    assert manifest["artifact_id"] != provider.data["provider"]["artifact_id"]
+    original = Runtime.load(provider.artifact, process="gg")
+    alternate = Runtime.load(other, process="gg")
+    assert alternate.physics.helicity_ids == original.physics.helicity_ids
+    point = _runtime_point(provider, "gg")
+    assert alternate.evaluate((point,)) == pytest.approx(original.evaluate((point,)))
+    invalid = ct.c_void_p(123)
+    assert provider.library.umami_initialize(ct.byref(invalid), os.fsencode(other)) == 1
+    assert invalid.value is None
+
+
+def _assert_relative_make_run(provider, *, makefile=None):
+    sdk = provider.artifact / "API/umami"
+    command = ["make", "-C", str(sdk)]
+    if makefile is not None:
+        command.extend(("-f", str(makefile)))
+    command.extend(
+        (
+            "run",
+            f"BUILD_DIR={os.path.relpath(provider.build, sdk)}",
+            f"RUSTICOL_CONFIG={_config_executable()}",
+        )
+    )
+    completed = subprocess.run(
+        command,
+        env=dict(
+            os.environ, PYTHONPATH=str(Path(__file__).resolve().parents[2] / "src")
+        ),
+        capture_output=True,
+        text=True,
+        timeout=60,
+        check=False,
+    )
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+    result = json.loads(
+        next(line for line in completed.stdout.splitlines() if line.startswith("{"))
+    )
+    entry = _entry(provider)
+    assert result["matrix_element"] == pytest.approx(
+        _expected(provider, entry, _point(provider, entry)), rel=2e-11
+    )
+
+
+def test_linked_driver_survives_relocation(providers, tmp_path):
+    provider = providers[0]
+    _assert_relative_make_run(provider)
+    relocated = tmp_path / "relocated files with spaces"
+    artifact, build = relocated / "artifact", relocated / "build"
+    shutil.copytree(provider.artifact, artifact)
+    build.mkdir(parents=True)
+    library_name = provider.data["provider"]["library"]
+    driver_name = (
+        "umami_driver"
+        if library_name == "libumami.so"
+        else "umami_driver_" + provider.data["provider"]["id"]
+    )
+    shutil.copy2(provider.build / library_name, build / library_name)
+    shutil.copy2(provider.build / driver_name, build / driver_name)
+    completed = subprocess.run(
+        [str(build / driver_name), str(artifact)],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        timeout=60,
+        check=False,
+    )
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+    result = json.loads(completed.stdout)
+    entry = _entry(provider)
+    assert result["matrix_element"] == pytest.approx(
+        _expected(provider, entry, _point(provider, entry)), rel=2e-11
+    )
+
+
+def test_real_generation_exercises_structural_proofs(providers):
+    for provider in providers:
+        if (
+            provider.data["provider"]["color_accuracy"] == "lc"
+            and provider.data["provider"]["helicity_count"] > 1
+        ):
+            assert provider.structural_keys and any(provider.structural_keys), (
+                "ordinary gg must exercise structural proofs"
+            )
+        if provider.data["runtime_processes"][0]["id"] == "flavour_one":
+            assert len(provider.structural_keys) == 2
+            assert provider.structural_keys[0]
+            assert provider.structural_keys[0] == provider.structural_keys[1]
+            entries = [
+                entry
+                for channel in provider.data["channels"]
+                for entry in channel["processes"]
+            ]
+            assert len(entries) == 1
+            assert all(
+                entry["runtime"]["process_id"] == "flavour_one" for entry in entries
+            )
+            members = [member for entry in entries for member in entry["members"]]
+            assert members[0]["pdgs"] != members[1]["pdgs"]
+
+
+@pytest.fixture(scope="module")
+def flavor_blind(tmp_path_factory):
+    """``p p > j j`` with --flavor-blind and, as reference, every flavour.
+
+    The built-in expansion has no ``g q > q g``: the explicit ones add members
+    whose relation exchanges the incoming legs.
+    """
+    if importlib.util.find_spec("pyamplicol._rusticol") is None:
+        _unavailable("the Rusticol extension has not been built")
+    if shutil.which("make") is None or shutil.which(os.environ.get("CC", "cc")) is None:
+        _unavailable("UMAMI integration requires make and a C compiler")
+    config_executable = _config_executable()
+    root = tmp_path_factory.mktemp("umami-flavor-blind")
+    artifacts = {}
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+        for blind in (True, False):
+            config = RunConfig(
+                action="generate",
+                process=ProcessConfig(flavor_scheme=2, flavor_blind=blind),
+                color=ColorConfig(accuracy="lc"),
+                generation=GenerationConfig(
+                    workers=1,
+                    emit_api_bundle=True,
+                    relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+                    validation=GenerationValidationConfig(
+                        enabled=False, post_build_validation=False
+                    ),
+                ),
+                evaluator=EvaluatorConfig(
+                    execution_mode="recurrence",
+                    optimization=EvaluatorOptimizationConfig(cores=1),
+                    jit=JITConfig(optimization_level=2),
+                ),
+            )
+            artifacts[blind] = root / ("blind" if blind else "reference")
+            Generator(config).generate(
+                ProcessSet.from_expressions(("p p > j j", "g u > u g", "g u~ > u~ g")),
+                artifacts[blind],
+                model=ModelSource.from_path(prepared_model),
+            )
+    build = root / "build"
+    completed = subprocess.run(
+        [
+            "make",
+            "-C",
+            str(artifacts[True] / "API/umami"),
+            f"BUILD_DIR={build}",
+            f"RUSTICOL_CONFIG={config_executable}",
+        ],
+        env=dict(
+            os.environ, PYTHONPATH=str(Path(__file__).resolve().parents[2] / "src")
+        ),
+        capture_output=True,
+        text=True,
+        timeout=300,
+        check=False,
+    )
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+    return artifacts[True], artifacts[False], build
+
+
+def _canonical_tags(flow):
+    names = {}
+    return tuple(
+        tuple(names.setdefault(tag, len(names) + 1) if tag else 0 for tag in pair)
+        for pair in flow
+    )
+
+
+def test_flavor_blind_members_match_separately_generated_processes(flavor_blind):
+    from pyamplicol.artifacts.umami import FLAVOR_BLIND_ASSUMPTION
+    from pyamplicol.artifacts.umami_reweight import load_umami_metadata
+
+    blind, reference, build = flavor_blind
+    groups = json.loads((blind / "process-groups.json").read_text())
+    assumed = {
+        member["process_id"]
+        for group in groups["groups"]
+        for member in group["members"]
+        if not member["generated"]
+    }
+    assert assumed
+    members = [member for group in groups["groups"] for member in group["members"]]
+    assert any(member["conjugated"] for member in members)
+    assert any(member["permutation"][:2] == [1, 0] for member in members)
+    # The same physical flow of a separately generated process, by its LHE tags.
+    reference_colors = {
+        (
+            member["process_id"],
+            _canonical_tags(data["color_flows"][member["color_flows"]]),
+        ): member["color_id"]
+        for data in load_umami_metadata(reference)
+        for channel in data["channels"]
+        for entry in channel["processes"]
+        for member in entry["members"]
+    }
+    # An asymmetric massless point in each member's physical leg order.
+    sine, cosine = math.sqrt(1 - 0.31**2), 0.31
+    direction = (sine * math.cos(0.7), sine * math.sin(0.7), cosine)
+    point = (
+        (500.0, 0.0, 0.0, 500.0),
+        (500.0, 0.0, 0.0, -500.0),
+        (500.0, *(500.0 * v for v in direction)),
+        (500.0, *(-500.0 * v for v in direction)),
+    )
+    natives, checked = {}, []
+    for data in load_umami_metadata(blind):
+        provider = Provider(
+            blind, build, data, _library(build / data["provider"]["library"]), []
+        )
+        generated = {process["id"] for process in data["runtime_processes"]}
+        with provider.handle() as handle:
+            for channel, description in enumerate(data["channels"]):
+                for flavour, exported in enumerate(description["processes"]):
+                    for member in exported["members"]:
+                        process_id = member["process_id"]
+                        if process_id in generated:
+                            continue
+                        assert member["runtime"]["process_id"] != process_id
+                        assert (
+                            FLAVOR_BLIND_ASSUMPTION in data["grouping"]["assumptions"]
+                        )
+                        color = reference_colors[
+                            (
+                                process_id,
+                                _canonical_tags(
+                                    data["color_flows"][member["color_flows"]]
+                                ),
+                            )
+                        ]
+                        if process_id not in natives:
+                            natives[process_id] = Runtime.load(
+                                reference, process=process_id
+                            )
+                        expected = float(
+                            complex(
+                                natives[process_id].evaluate(
+                                    (point,), color_flows=(color,)
+                                )[0]
+                            ).real
+                        )
+                        status, outputs = _batch(
+                            provider,
+                            handle,
+                            (_member_input(exported["runtime"], member, point),),
+                            channel=channel,
+                            flavour=flavour,
+                        )
+                        assert status == 0
+                        assert outputs[0][0] == pytest.approx(
+                            expected, rel=1e-12, abs=1e-15
+                        )
+                        checked.append((process_id, color))
+    # Every physical flow of every assumed member is exported exactly once.
+    assert sorted(checked) == sorted(
+        (process_id, color)
+        for (process_id, _), color in reference_colors.items()
+        if process_id in assumed
+    )
diff --git a/pyamplicol/tests/integration/test_umami_reweight.py b/pyamplicol/tests/integration/test_umami_reweight.py
new file mode 100644
index 0000000000..2fc0dade8a
--- /dev/null
+++ b/pyamplicol/tests/integration/test_umami_reweight.py
@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: 0BSD
+"""Native checks of the UMAMI colour-accuracy ratio providers."""
+
+from __future__ import annotations
+
+import ctypes as ct
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from pyamplicol import Generator, ModelSource, ProcessSet, Runtime
+from pyamplicol.artifacts.umami_reweight import write_reweight_provider
+from pyamplicol.assets.prepared_models import (
+    BUILTIN_SM_JIT_O2,
+    packaged_prepared_model_path,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+from tests.integration.test_umami_api import (
+    _config_executable,
+    _library,
+    _runtime_point,
+    _unavailable,
+)
+
+EXPRESSIONS = ("g g > g g", "d d~ > g g")
+NAMES = ("gg", "dd_gg")
+
+
+def _generate(artifact: Path, accuracy: str) -> None:
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=accuracy),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=True,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode="recurrence",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+    with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as prepared_model:
+        Generator(config).generate(
+            ProcessSet.from_expressions(EXPRESSIONS, names=NAMES),
+            artifact,
+            model=ModelSource.from_path(prepared_model),
+        )
+
+
+@pytest.fixture(scope="module")
+def reweight(tmp_path_factory):
+    config_executable = _config_executable()
+    if shutil.which("make") is None or shutil.which(os.environ.get("CC", "cc")) is None:
+        _unavailable("UMAMI integration requires make and a C compiler")
+    root = tmp_path_factory.mktemp("umami-reweight")
+    lc, full, output = root / "lc", root / "full", root / "reweight"
+    _generate(lc, "lc")
+    _generate(full, "full")
+    assert write_reweight_provider(lc, full, output) == ["p0"]
+    completed = subprocess.run(
+        ["make", "-C", str(output), f"RUSTICOL_CONFIG={config_executable}"],
+        capture_output=True,
+        text=True,
+        timeout=180,
+        check=False,
+    )
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+    data = json.loads((lc / "API/umami/metadata.json").read_text())
+    return lc, full, output, data, _library(output / "build/libreweight_p0.so")
+
+
+def _ratio(library, handle, point, channel, flavour, helicity):
+    n = len(point)
+    momenta = (ct.c_double * (4 * n))(
+        *(float(point[leg][component]) for component in range(4) for leg in range(n))
+    )
+    inputs = {
+        0: momenta,
+        2: (ct.c_int * 1)(flavour),
+        6: (ct.c_int * 1)(helicity),
+        8: (ct.c_uint * 1)(channel),
+    }
+    output = (ct.c_double * 1)(-1.0)
+    status = library.umami_matrix_element(
+        handle,
+        1,
+        1,
+        0,
+        len(inputs),
+        (ct.c_int * len(inputs))(*inputs),
+        (ct.c_void_p * len(inputs))(
+            *(ct.cast(value, ct.c_void_p) for value in inputs.values())
+        ),
+        1,
+        (ct.c_int * 1)(10),
+        (ct.c_void_p * 1)(ct.cast(output, ct.c_void_p)),
+    )
+    return status, output[0]
+
+
+def test_ratio_matches_native_runtimes(reweight):
+    lc, full, output, data, library = reweight
+    handle = ct.c_void_p()
+    assert library.umami_initialize(ct.byref(handle), os.fsencode(output)) == 0
+    try:
+        checked = 0
+        for channel, description in enumerate(data["channels"]):
+            for flavour, entry in enumerate(description["processes"]):
+                runtime = entry["runtime"]
+                process = data["runtime_processes"][runtime["process_index"]]
+                lc_runtime = Runtime.load(lc, process=process["id"])
+                full_runtime = Runtime.load(full, process=process["id"])
+                runtime_point = _runtime_point_of(lc, process["id"])
+                point = [None] * len(runtime_point)
+                for runtime_slot, input_slot in enumerate(runtime["permutation"]):
+                    point[input_slot] = runtime_point[runtime_slot]
+                for runtime_index, exported in enumerate(runtime["helicity_export"]):
+                    identifier = process["helicity_ids"][runtime_index]
+                    reference = complex(
+                        lc_runtime.evaluate((runtime_point,), helicities=[identifier])[0]
+                    ).real
+                    target = complex(
+                        full_runtime.evaluate(
+                            (runtime_point,), helicities=[identifier]
+                        )[0]
+                    ).real
+                    status, value = _ratio(
+                        library, handle, point, channel, flavour, exported
+                    )
+                    assert status == 0
+                    expected = target / reference if reference != 0.0 else 0.0
+                    assert value == pytest.approx(expected, rel=1e-10, abs=1e-15)
+                    checked += reference != 0.0
+        assert checked > 0
+        assert _ratio(library, handle, point, 0, 0, len(data["helicities"]))[0] == 1
+    finally:
+        assert library.umami_free(handle) == 0
+
+
+def _runtime_point_of(artifact, process_id):
+    class _Artifact:
+        pass
+
+    provider = _Artifact()
+    provider.artifact = artifact
+    return _runtime_point(provider, process_id)
+
+
+def test_reference_must_be_leading_colour(reweight, tmp_path):
+    lc, full, _, _, _ = reweight
+    with pytest.raises(ValueError, match="leading-colour"):
+        write_reweight_provider(full, lc, tmp_path / "wrong")
diff --git a/pyamplicol/tests/integration/umami_fixtures.py b/pyamplicol/tests/integration/umami_fixtures.py
new file mode 100644
index 0000000000..2daef7cc37
--- /dev/null
+++ b/pyamplicol/tests/integration/umami_fixtures.py
@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: 0BSD
+"""A small generic UFO model shared by UMAMI generation/parameter tests."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from pyamplicol import ModelSource, ProcessSet
+
+
+def equivalent_scalar_model(directory: Path) -> tuple[ModelSource, ProcessSet]:
+    """Two different final flavours with exactly the same symbolic coupling.
+
+    This is a restriction of the shipped scalar model, not an SM relabelling.
+    All fields retain the normal UFO schema. The standard LHA declaration of
+    ``aS`` exercises event alpha_s; ``G`` and the complex quartic coupling are
+    derived from it. Both channels depend on the *same* mutable parameter, not
+    two independent inputs that happen to have equal defaults.
+    """
+    source = (
+        Path(__file__).resolve().parents[2]
+        / "src/pyamplicol/assets/models/json/scalars/scalars.json"
+    )
+    data = json.loads(source.read_text(encoding="utf-8"))
+    data["name"] = "umami_equivalent_scalars"
+    data["particles"] = data["particles"][:3]
+    for particle in data["particles"]:
+        particle["mass"] = particle["width"] = "ZERO"
+    data["parameters"] = [
+        p for p in data["parameters"] if p["name"] in {"ZERO", "aS", "G"}
+    ]
+    data["propagators"] = data["propagators"][:3]
+    for propagator in data["propagators"]:
+        propagator["denominator"] = data["propagators"][0]["denominator"]
+    data["lorentz_structures"] = [
+        value
+        for value in data["lorentz_structures"]
+        if value["name"] == "SCALAR_4_LORENTZ_STRUCTURE"
+    ]
+    coupling = data["couplings"][0]
+    coupling["expression"] = "1\U0001d456*UFO::{}::G^2"
+    coupling["orders"] = [["QCD", 2]]
+    g_default = next(p for p in data["parameters"] if p["name"] == "G")["value"][0]
+    coupling["value"] = [0.0, g_default**2]
+    data["vertex_rules"] = [
+        {
+            "name": f"V_QUARTIC_{index}",
+            "particles": ["scalar_0", "scalar_0", f"scalar_{index}", f"scalar_{index}"],
+            "color_structures": ["1"],
+            "lorentz_structures": ["SCALAR_4_LORENTZ_STRUCTURE"],
+            "couplings": [[coupling["name"]]],
+        }
+        for index in (1, 2)
+    ]
+    directory.mkdir(parents=True, exist_ok=True)
+    path = directory / "equivalent-scalars.json"
+    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    return ModelSource.from_path(path), ProcessSet.from_expressions(
+        [f"scalar_0 scalar_0 > scalar_{index} scalar_{index}" for index in (1, 2)],
+        names=["flavour_one", "flavour_two"],
+    )
diff --git a/pyamplicol/tests/release/test_artifacts.py b/pyamplicol/tests/release/test_artifacts.py
new file mode 100644
index 0000000000..320aa717bc
--- /dev/null
+++ b/pyamplicol/tests/release/test_artifacts.py
@@ -0,0 +1,2190 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import base64
+import csv
+import hashlib
+import io
+import json
+import re
+import subprocess
+import sys
+import tarfile
+import tomllib
+import zipfile
+from pathlib import Path, PurePosixPath
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tools" / "release"))
+_LOCK = tomllib.loads(
+    (ROOT / "dependencies" / "release-lock.toml").read_text(encoding="utf-8")
+)
+_RELEASE_VERSION = str(_LOCK["project"]["version"])
+_CONTRIBUTOR_LOCK = tomllib.loads(
+    (ROOT / "dependencies" / "contributor-lock.toml").read_text(encoding="utf-8")
+)
+_DEFAULT_REQUIREMENTS = [
+    f"{entry['distribution']}=={entry['version']}"
+    for entry in _LOCK["python_dependencies"]
+]
+_CANDIDATE_REQUIREMENTS = [
+    (
+        f"{entry['distribution']}=="
+        f"{_CONTRIBUTOR_LOCK['symbolica']['candidate_version']}"
+        if entry["distribution"] == _LOCK["symbolica"]["python_distribution"]
+        else f"{entry['distribution']}=={entry['version']}"
+    )
+    for entry in _LOCK["python_dependencies"]
+]
+_LEGAL_FILES = (
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
+    "licenses/Symbolica.txt",
+    "licenses/SymJIT.txt",
+)
+_COMPILED_MODEL_KIND = "pyamplicol-compiled-model"
+_BUILTIN_MODEL_SOURCE_KIND = "built-in-sm"
+_MODEL_COMPILER_VERSION = 11
+_RUNTIME_ARTIFACT_ID_PAYLOAD_ROLES = frozenset(
+    {
+        "compiled-model",
+        "evaluator-manifest",
+        "evaluator-state",
+        "model-parameters",
+        "runtime-physics",
+    }
+)
+_MODEL_COMPILER_SOURCE_FILES = {
+    "pyamplicol/models/__init__.py": b'"""Synthetic model package."""\n',
+    "pyamplicol/models/compiler.py": b"def compile_model():\n    return 'compiled'\n",
+    "pyamplicol/models/loading.py": b"MODEL_COMPILER_VERSION = 11\n",
+    "pyamplicol/_internal/physics/__init__.py": b'"""Synthetic physics."""\n',
+    "pyamplicol/_internal/physics/rules.py": b"PROPAGATOR = 'feynman'\n",
+    "pyamplicol/processes/core_syntax.py": b"CORE_SYNTAX_VERSION = 1\n",
+}
+_BUILTIN_MODEL_SOURCE_FILES = {
+    "pyamplicol/models/builtin/__init__.py": b'"""Synthetic built-in model."""\n',
+    "pyamplicol/models/builtin/adapters.py": b"def source_digest():\n    pass\n",
+    "pyamplicol/models/builtin/model.py": b"MODEL_NAME = 'sm'\n",
+}
+_PREPARED_PACK_COMPILER_SOURCE_FILES = {
+    **{
+        f"pyamplicol/models/{name}.py": f"# synthetic {name}\n".encode()
+        for name in (
+            "prepared",
+            "prepared_catalog",
+            "prepared_catalog_builder",
+            "prepared_catalog_helpers",
+            "prepared_compile",
+            "prepared_target",
+        )
+    },
+    **{
+        f"pyamplicol/evaluators/{name}.py": f"# synthetic {name}\n".encode()
+        for name in (
+            "symbolica",
+            "symbolica_adapters",
+            "symbolica_compile",
+            "symbolica_helpers",
+            "symbolica_settings",
+        )
+    },
+    **{
+        f"pyamplicol/config/{name}.py": f"# synthetic config {name}\n".encode()
+        for name in ("__init__", "errors", "models", "registry", "resolver")
+    },
+    "pyamplicol/_internal/physics/symbols.py": b"# synthetic symbols\n",
+    "pyamplicol/_internal/versions.py": b"# synthetic versions\n",
+}
+
+
+def _model_compiler_digest() -> str:
+    digest = hashlib.sha256()
+    sources = dict(_MODEL_COMPILER_SOURCE_FILES)
+    sources.update(
+        {
+            name: data
+            for name, data in _PREPARED_PACK_COMPILER_SOURCE_FILES.items()
+            if PurePosixPath(name).parent
+            in {
+                PurePosixPath("pyamplicol/models"),
+                PurePosixPath("pyamplicol/_internal/physics"),
+            }
+        }
+    )
+    for name, data in sorted(sources.items()):
+        relative = PurePosixPath(name).relative_to("pyamplicol").as_posix()
+        digest.update(relative.encode("utf-8") + b"\0")
+        digest.update(data)
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def _builtin_model_source_digest() -> str:
+    inner = hashlib.sha256()
+    for name, data in sorted(_BUILTIN_MODEL_SOURCE_FILES.items()):
+        inner.update(PurePosixPath(name).name.encode("utf-8") + b"\0")
+        inner.update(data)
+        inner.update(b"\0")
+    outer = hashlib.sha256()
+    outer.update(b"built-in-sm\0")
+    outer.update(inner.hexdigest().encode("ascii"))
+    return outer.hexdigest()
+
+
+import _artifacts as artifacts  # noqa: E402
+from _artifacts import (  # noqa: E402
+    _REQUIRED_WHEEL_PACKAGE_MEMBERS,
+    MAX_WHEEL_BYTES,
+    ArtifactError,
+    _scan_capi_archive,
+    _scan_static_runtime_families,
+    audit_sdist,
+    audit_wheel,
+)
+from audit_sdist import (  # noqa: E402
+    PREPARED_MODEL_ARCHITECTURES,
+    PREPARED_MODEL_ASSET_BASENAME,
+    PREPARED_MODEL_ASSETS,
+    REQUIRED_SDIST_MEMBERS,
+    prepared_model_asset_members,
+)
+from prepare_selftest_fixture import ARTIFACT_IDENTITY_CONTRACT  # noqa: E402
+
+
+@pytest.fixture
+def candidate_dependency_provenance(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    contributor_path = tmp_path / "contributor-lock.toml"
+    state_path = tmp_path / "install-state.json"
+    contributor_data = (ROOT / "dependencies" / "contributor-lock.toml").read_bytes()
+    contributor_path.write_bytes(contributor_data)
+    symbolica = _CONTRIBUTOR_LOCK["symbolica"]
+    state_path.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "sources": {
+                    "symbolica": {
+                        "url": symbolica["source_url"],
+                        "revision": symbolica["candidate_revision"],
+                    }
+                },
+            },
+            sort_keys=True,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        artifacts,
+        "_CONTRIBUTOR_DEPENDENCY_LOCK",
+        contributor_path,
+    )
+    monkeypatch.setattr(artifacts, "_CANDIDATE_INSTALL_STATE", state_path)
+
+
+def _record_hash(data: bytes) -> str:
+    digest = hashlib.sha256(data).digest()
+    encoded = base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
+    return f"sha256={encoded}"
+
+
+def _prepared_model_files(
+    prefix: str,
+    *,
+    mode: str = "release",
+) -> dict[str, bytes]:
+    root = prefix.rstrip("/")
+    files = {f"{root}/__init__.py": b'"""Synthetic prepared models."""\n'}
+    for identifier, model_source in PREPARED_MODEL_ASSETS.items():
+        for architecture in PREPARED_MODEL_ARCHITECTURES:
+            stem = f"{identifier}-{architecture}"
+            bundle_name = f"{stem}.pyamplicol-model"
+            bundle = f"synthetic portable {stem} prepared model\n".encode()
+            metadata = {
+                "schema_version": 1,
+                "prepared_model_bundle_schema": 1,
+                "eager_kernel_abi": "pyamplicol-eager-kernel-v1",
+                "id": identifier,
+                "model": model_source,
+                "backend": "jit",
+                "jit_optimization_level": 2,
+                "bundle": bundle_name,
+                "bundle_size": len(bundle),
+                "bundle_sha256": hashlib.sha256(bundle).hexdigest(),
+                "dependencies": {
+                    "symbolica_serialization_abi": "symbolica-bincode2-v1",
+                    "symjit_application_abi": "symjit-application-storage-v3",
+                    "symjit_plane_application_abi": (
+                        "pyamplicol-symjit-plane-application-v2"
+                    ),
+                },
+                "build_contract": {"candidate_fingerprint": None, "mode": mode},
+                "producer": {},
+                "target": {
+                    "portable": True,
+                    "word_bits": 64,
+                    "endianness": "little",
+                    "target_triple": "symjit-storage-v3-portable",
+                    "cpu_features": [],
+                },
+            }
+            files[f"{root}/{bundle_name}"] = bundle
+            files[f"{root}/{stem}.metadata.json"] = (
+                json.dumps(metadata, sort_keys=True) + "\n"
+            ).encode()
+    return files
+
+
+def _modified_prepared_metadata(
+    prefix: str,
+    architecture: str,
+    *,
+    values: dict[str, object] | None = None,
+    target_values: dict[str, object] | None = None,
+) -> tuple[str, bytes]:
+    root = prefix.rstrip("/")
+    stem = f"{PREPARED_MODEL_ASSET_BASENAME}-{architecture}"
+    metadata_name = f"{root}/{stem}.metadata.json"
+    metadata = json.loads(_prepared_model_files(prefix)[metadata_name])
+    if values is not None:
+        metadata.update(values)
+    if target_values is not None:
+        metadata["target"].update(target_values)
+    return metadata_name, (json.dumps(metadata, sort_keys=True) + "\n").encode()
+
+
+def _selftest_arena_stage(
+    *,
+    amplitude: bool,
+    direct_codegen_optimization_level: int,
+) -> dict[str, object]:
+    application_path = "evaluator.symjit"
+    plane_application_path = "evaluator.plane.symjit"
+    arena = "amplitude" if amplitude else "current"
+    output_component = 0 if amplitude else 2
+    input_component = {
+        "parameter_index": 0,
+        "kind": "value",
+        "source_id": 0,
+        "component": 0,
+        "global_component": 0,
+        "real_valued": False,
+    }
+    evaluator = {
+        "kind": "symjit-application-evaluator",
+        "runtime_capability": "symjit.application.complex-f64.v1",
+        "application_abi": "symjit-application-storage-v3",
+        "application_path": application_path,
+        "plane_application": {
+            "application_path": plane_application_path,
+            "application_abi": "pyamplicol-symjit-plane-application-v2",
+            "storage_abi": "symjit-application-storage-v3",
+            "element_layout": "split-complex-plane-major",
+            "descriptor_order": "inputs-re-im-then-outputs-re-im",
+            "input_complex_count": 1,
+            "output_complex_count": 1,
+            "input_plane_count": 2,
+            "output_plane_count": 2,
+            "compiler_type": "native",
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": 2,
+            "simd": True,
+            "complex": True,
+            "fast_math": True,
+            "fast_complex": False,
+            "compression": False,
+            "threading": False,
+            "direct_arena": True,
+            "source_digest": hashlib.sha256(
+                b"synthetic structured instructions"
+            ).hexdigest(),
+            "target": {"word_bits": 64, "endianness": "little"},
+        },
+        "compiler_type": "native",
+        "translation_mode": "indirect",
+        "optimization_level": 2,
+        "element_layout": "complex-f64",
+        "batch_layout": "row-major",
+        "input_len": 1,
+        "output_len": 1,
+    }
+    return {
+        "stage_kind": "amplitude-roots" if amplitude else "current-combine",
+        "parameter_layout": "stage-local-value-momentum",
+        "parameter_count": 1,
+        "output_length": 1,
+        "input_components": [input_component],
+        "output_slots": [
+            {
+                "output_start": 0,
+                "output_stop": 1,
+                "component_start": output_component,
+                "component_stop": output_component + 1,
+            }
+        ],
+        "evaluator": evaluator,
+        "compiled_plane_arena": {
+            "schema_version": 1,
+            "kind": "compiled-plane-arena-stage",
+            "application_abi": "pyamplicol-compiled-plane-kernel-v2",
+            "source_application_abi": "pyamplicol-symjit-plane-application-v2",
+            "element_layout": "split-complex-component-major",
+            "output_operation": "overwrite",
+            "output_factor": "identity",
+            "input_output_aliasing": "forbidden",
+            "output_output_aliasing": "forbidden",
+            "input_bindings": [input_component],
+            "output_bindings": [
+                {
+                    "output_index": 0,
+                    "arena": arena,
+                    "component": output_component,
+                }
+            ],
+            "leaves": [
+                {
+                    "application_path": plane_application_path,
+                    "source_application_abi": (
+                        "pyamplicol-symjit-plane-application-v2"
+                    ),
+                    "optimization_level": 2,
+                    "direct_codegen_optimization_level": (
+                        direct_codegen_optimization_level
+                    ),
+                    "input_len": 1,
+                    "output_len": 1,
+                    "input_indices": [0],
+                    "output_start": 0,
+                    "output_stop": 1,
+                }
+            ],
+        },
+    }
+
+
+def _selftest_execution(
+    *,
+    missing_arena_capability: str | None = None,
+    missing_symjit_capability: str | None = None,
+    direct_codegen_optimization_level: int = 2,
+) -> dict[str, object]:
+    arena_capability = "compiled-plane-arena-v1"
+    symjit_capability = "symjit.application.complex-f64.v1"
+    execution_capabilities: list[str] = []
+    stage_capabilities: list[str] = []
+    if missing_arena_capability != "execution":
+        execution_capabilities.append(arena_capability)
+    if missing_symjit_capability != "execution":
+        execution_capabilities.append(symjit_capability)
+    if missing_arena_capability != "stage_evaluators":
+        stage_capabilities.append(arena_capability)
+    if missing_symjit_capability != "stage_evaluators":
+        stage_capabilities.append(symjit_capability)
+    return {
+        "required_runtime_capabilities": execution_capabilities,
+        "compiled": {
+            "kind": "generic-dag-stage-blueprint",
+            "stage_evaluators": {
+                "kind": "generic-dag-stage-evaluator-artifacts",
+                "required_runtime_capabilities": stage_capabilities,
+                "stage_count": 2,
+                "stages": [
+                    _selftest_arena_stage(
+                        amplitude=False,
+                        direct_codegen_optimization_level=(
+                            direct_codegen_optimization_level
+                        ),
+                    )
+                ],
+                "amplitude_stage": _selftest_arena_stage(
+                    amplitude=True,
+                    direct_codegen_optimization_level=(
+                        direct_codegen_optimization_level
+                    ),
+                ),
+            },
+        },
+    }
+
+
+def _selftest_files(
+    rust_target: str,
+    version: str,
+    compiled_model_schema: int = _LOCK["abis"]["compiled_model"],
+    *,
+    producer_compiled_model_schema: int | None = None,
+    model_compiled_model_schema: int | None = None,
+    compiled_model_kind: str = _COMPILED_MODEL_KIND,
+    model_compiler_version: int = _MODEL_COMPILER_VERSION,
+    compiled_model_producer_schema: int | None = None,
+    compiled_model_producer_version: str | None = None,
+    compiled_model_producer_compiler_version: int | None = None,
+    compiled_model_compiler_sha256: str | None = None,
+    compiled_model_source_kind: str = _BUILTIN_MODEL_SOURCE_KIND,
+    compiled_model_source_digest: str | None = None,
+    omitted_api_payload: str | None = None,
+    missing_arena_capability: str | None = None,
+    missing_symjit_capability: str | None = None,
+    direct_codegen_optimization_level: int = 2,
+) -> dict[str, bytes]:
+    payload_path = "processes/smoke/evaluator.symjit"
+    payload = b"synthetic trusted SymJIT application"
+    plane_payload_path = "processes/smoke/evaluator.plane.symjit"
+    plane_payload = b"synthetic trusted SymJIT plane application"
+    execution_path = "processes/smoke/execution.json"
+    execution = (
+        json.dumps(
+            _selftest_execution(
+                missing_arena_capability=missing_arena_capability,
+                missing_symjit_capability=missing_symjit_capability,
+                direct_codegen_optimization_level=(direct_codegen_optimization_level),
+            ),
+            sort_keys=True,
+            separators=(",", ":"),
+        )
+        + "\n"
+    ).encode()
+    compiled_model_path = "model/compiled-model.json"
+    compiled_model = (
+        json.dumps(
+            {
+                "kind": compiled_model_kind,
+                "schema_version": compiled_model_schema,
+                "model_compiler_version": model_compiler_version,
+                "source": {
+                    "kind": compiled_model_source_kind,
+                    "digest": (
+                        _builtin_model_source_digest()
+                        if compiled_model_source_digest is None
+                        else compiled_model_source_digest
+                    ),
+                },
+                "producer": {
+                    "pyamplicol": (
+                        version
+                        if compiled_model_producer_version is None
+                        else compiled_model_producer_version
+                    ),
+                    "compiled_model_schema_version": (
+                        _LOCK["abis"]["compiled_model"]
+                        if compiled_model_producer_schema is None
+                        else compiled_model_producer_schema
+                    ),
+                    "model_compiler_version": (
+                        model_compiler_version
+                        if compiled_model_producer_compiler_version is None
+                        else compiled_model_producer_compiler_version
+                    ),
+                    "model_compiler_sha256": (
+                        _model_compiler_digest()
+                        if compiled_model_compiler_sha256 is None
+                        else compiled_model_compiler_sha256
+                    ),
+                },
+            },
+            sort_keys=True,
+        )
+        + "\n"
+    ).encode()
+    api_payloads = {
+        "API/validation_points.dat": (
+            b"RUSTICOL_VALIDATION_POINTS_V1\n",
+            "validation-momenta",
+            "text/tab-separated-values",
+        ),
+        "API/python/check_standalone.py": (
+            b"# synthetic Python driver\n",
+            "api-source",
+            "text/x-python",
+        ),
+        "API/c/Makefile": (
+            b"# synthetic C Makefile\n",
+            "api-build-file",
+            "text/x-makefile",
+        ),
+        "API/c/check_standalone.c": (
+            b"/* synthetic C driver */\n",
+            "api-source",
+            "text/x-csrc",
+        ),
+        "API/cpp/Makefile": (
+            b"# synthetic C++ Makefile\n",
+            "api-build-file",
+            "text/x-makefile",
+        ),
+        "API/cpp/check_standalone.cpp": (
+            b"// synthetic C++ driver\n",
+            "api-source",
+            "text/x-c++src",
+        ),
+        "API/fortran/Makefile": (
+            b"# synthetic Fortran Makefile\n",
+            "api-build-file",
+            "text/x-makefile",
+        ),
+        "API/fortran/check_standalone.f90": (
+            b"! synthetic Fortran driver\n",
+            "api-source",
+            "text/x-fortran",
+        ),
+        "API/rust/Makefile": (
+            b"# synthetic Rust Makefile\n",
+            "api-build-file",
+            "text/x-makefile",
+        ),
+        "API/rust/check_standalone.rs": (
+            b"// synthetic Rust driver\n",
+            "api-source",
+            "text/x-rust",
+        ),
+    }
+    if omitted_api_payload is not None:
+        api_payloads.pop(omitted_api_payload)
+    producer_schema = (
+        _LOCK["abis"]["compiled_model"]
+        if producer_compiled_model_schema is None
+        else producer_compiled_model_schema
+    )
+    model_schema = (
+        _LOCK["abis"]["compiled_model"]
+        if model_compiled_model_schema is None
+        else model_compiled_model_schema
+    )
+    artifact_capabilities = []
+    process_capabilities = []
+    if missing_arena_capability != "artifact_runtime":
+        artifact_capabilities.append("compiled-plane-arena-v1")
+    if missing_symjit_capability != "artifact_runtime":
+        artifact_capabilities.append("symjit.application.complex-f64.v1")
+    if missing_arena_capability != "process":
+        process_capabilities.append("compiled-plane-arena-v1")
+    if missing_symjit_capability != "process":
+        process_capabilities.append("symjit.application.complex-f64.v1")
+    manifest = {
+        "schema_version": 3,
+        "artifact_id": "0" * 64,
+        "extensions": {
+            "artifact_identity": dict(ARTIFACT_IDENTITY_CONTRACT),
+        },
+        "producer": {
+            "distribution": "pyamplicol",
+            "version": version,
+            "target": {"triple": rust_target, "cpu_features": []},
+            "versions": {"compiled_model": producer_schema},
+        },
+        "model": {"compiled_schema_version": model_schema},
+        "runtime": {
+            "engine": "rusticol",
+            "engine_version": version,
+            "required_runtime_capabilities": artifact_capabilities,
+        },
+        "processes": [
+            {
+                "id": "smoke",
+                "required_runtime_capabilities": process_capabilities,
+            }
+        ],
+        "payloads": [
+            {
+                "path": compiled_model_path,
+                "role": "compiled-model",
+                "media_type": "application/json",
+                "size_bytes": len(compiled_model),
+                "sha256": hashlib.sha256(compiled_model).hexdigest(),
+            },
+            {
+                "path": payload_path,
+                "role": "evaluator-state",
+                "media_type": "application/vnd.symjit.application",
+                "size_bytes": len(payload),
+                "sha256": hashlib.sha256(payload).hexdigest(),
+                "target": {"triple": rust_target, "cpu_features": []},
+            },
+            {
+                "path": plane_payload_path,
+                "role": "evaluator-state",
+                "media_type": "application/vnd.symjit.application",
+                "size_bytes": len(plane_payload),
+                "sha256": hashlib.sha256(plane_payload).hexdigest(),
+                "target": {"triple": rust_target, "cpu_features": []},
+            },
+            {
+                "path": execution_path,
+                "role": "evaluator-manifest",
+                "media_type": "application/json",
+                "size_bytes": len(execution),
+                "sha256": hashlib.sha256(execution).hexdigest(),
+            },
+            *[
+                {
+                    "path": path,
+                    "role": role,
+                    "media_type": media_type,
+                    "size_bytes": len(data),
+                    "sha256": hashlib.sha256(data).hexdigest(),
+                }
+                for path, (data, role, media_type) in sorted(api_payloads.items())
+            ],
+        ],
+    }
+    runtime_payloads = [
+        dict(payload)
+        for payload in manifest["payloads"]
+        if payload.get("role") in _RUNTIME_ARTIFACT_ID_PAYLOAD_ROLES
+    ]
+    runtime_payloads.sort(key=lambda payload: str(payload.get("path", "")))
+    canonical = (
+        json.dumps(
+            {
+                "kind": "pyamplicol-runtime-payload-identity",
+                "schema_version": 1,
+                "payloads": runtime_payloads,
+            },
+            sort_keys=True,
+            separators=(",", ":"),
+        )
+        + "\n"
+    ).encode()
+    manifest["artifact_id"] = hashlib.sha256(canonical).hexdigest()
+    prefix = f"pyamplicol/assets/selftest/{rust_target}"
+    files = {
+        f"{prefix}/expected.json": json.dumps(
+            {
+                "schema_version": 1,
+                "target": rust_target,
+                "artifact_path": "artifact",
+            }
+        ).encode(),
+        f"{prefix}/artifact/artifact.json": (
+            json.dumps(manifest, sort_keys=True, separators=(",", ":")) + "\n"
+        ).encode(),
+        f"{prefix}/artifact/{compiled_model_path}": compiled_model,
+        f"{prefix}/artifact/{payload_path}": payload,
+        f"{prefix}/artifact/{plane_payload_path}": plane_payload,
+        f"{prefix}/artifact/{execution_path}": execution,
+    }
+    files.update(
+        {
+            f"{prefix}/artifact/{path}": data
+            for path, (data, _role, _media_type) in api_payloads.items()
+        }
+    )
+    return files
+
+
+def _wheel(
+    directory: Path,
+    *,
+    platform_tag: str = "manylinux_2_28_x86_64",
+    rust_target: str = "x86_64-unknown-linux-gnu",
+    version: str = _RELEASE_VERSION,
+    candidate: bool = False,
+    extension: bytes = b"synthetic abi3 extension",
+    bad_record: bool = False,
+    requirement: str | None = None,
+    requirements: list[str] | None = None,
+    system_libraries: list[str] | None = None,
+    sdk_version: str | None = None,
+    notice: bytes | None = b"third-party notices\n",
+    license_files: tuple[str, ...] | None = None,
+    omitted_member: str | None = None,
+    extra_files: dict[str, bytes] | None = None,
+    compiled_model_schema: int = _LOCK["abis"]["compiled_model"],
+    producer_compiled_model_schema: int | None = None,
+    model_compiled_model_schema: int | None = None,
+    compiled_model_kind: str = _COMPILED_MODEL_KIND,
+    model_compiler_version: int = _MODEL_COMPILER_VERSION,
+    compiled_model_producer_schema: int | None = None,
+    compiled_model_producer_version: str | None = None,
+    compiled_model_producer_compiler_version: int | None = None,
+    compiled_model_compiler_sha256: str | None = None,
+    compiled_model_source_kind: str = _BUILTIN_MODEL_SOURCE_KIND,
+    compiled_model_source_digest: str | None = None,
+    omitted_selftest_api_payload: str | None = None,
+    selftest_missing_arena_capability: str | None = None,
+    selftest_missing_symjit_capability: str | None = None,
+    selftest_direct_codegen_optimization_level: int = 2,
+    selftest_fixture_bootstrap: bool = False,
+    metadata_description: str = "",
+) -> Path:
+    if requirement is not None and requirements is not None:
+        raise ValueError("use requirement or requirements, not both")
+    runtime_requirements = (
+        [requirement]
+        if requirement is not None
+        else list(
+            (_CANDIDATE_REQUIREMENTS if candidate else _DEFAULT_REQUIREMENTS)
+            if requirements is None
+            else requirements
+        )
+    )
+    declared_legal_files = _LEGAL_FILES if license_files is None else license_files
+    dist_info = f"pyamplicol-{version}.dist-info"
+    sdk_archive = b"synthetic static archive"
+    files = {
+        name: b"synthetic required wheel member\n"
+        for name in _REQUIRED_WHEEL_PACKAGE_MEMBERS
+    }
+    files.update(
+        {
+            "pyamplicol/__init__.py": b"",
+            "pyamplicol/_examples/README.md": b"load ../models/example.json\n",
+            "pyamplicol/_rusticol.abi3.so": extension,
+            "pyamplicol/_sdk/config.py": b"",
+            "pyamplicol/_sdk/include/rusticol.h": b"void rusticol(void);\n",
+            "pyamplicol/_sdk/include/rusticol.hpp": b"#pragma once\n",
+            "pyamplicol/_sdk/fortran/rusticol.f90": b"module rusticol\nend module\n",
+            "pyamplicol/_sdk/rust/rusticol.rs": b"// safe Rust wrapper\n",
+            "pyamplicol/_sdk/lib/librusticol_capi.a": sdk_archive,
+            "pyamplicol/_sdk/metadata.json": json.dumps(
+                {
+                    "schema_version": 1,
+                    "abi_version": 1,
+                    "version": sdk_version or version,
+                    "target": rust_target,
+                    "archive": "lib/librusticol_capi.a",
+                    "rust_source": "rust/rusticol.rs",
+                }
+            ).encode(),
+            "pyamplicol/_sdk/link.json": json.dumps(
+                {
+                    "schema_version": 1,
+                    "target": rust_target,
+                    "system_libraries": system_libraries or ["c", "m"],
+                    "frameworks": [],
+                }
+            ).encode(),
+            f"{dist_info}/METADATA": (
+                "Metadata-Version: 2.4\n"
+                "Name: pyamplicol\n"
+                f"Version: {version}\n"
+                "Requires-Python: >=3.11\n"
+                "License-Expression: 0BSD\n"
+                + "".join(f"License-File: {item}\n" for item in declared_legal_files)
+                + "".join(f"Requires-Dist: {item}\n" for item in runtime_requirements)
+                + f"\n{metadata_description}"
+            ).encode(),
+            f"{dist_info}/WHEEL": (
+                "Wheel-Version: 1.0\n"
+                "Generator: synthetic\n"
+                "Root-Is-Purelib: false\n"
+                f"Tag: cp311-abi3-{platform_tag}\n\n"
+            ).encode(),
+            f"{dist_info}/entry_points.txt": (
+                b"[console_scripts]\n"
+                b"pyamplicol = pyamplicol.cli:main\n"
+                b"rusticol-config = rusticol_config:main\n"
+            ),
+        }
+    )
+    files.update(_MODEL_COMPILER_SOURCE_FILES)
+    files.update(_BUILTIN_MODEL_SOURCE_FILES)
+    files.update(_PREPARED_PACK_COMPILER_SOURCE_FILES)
+    files.update(
+        _prepared_model_files(
+            "pyamplicol/assets/prepared_models",
+            mode="candidate" if candidate else "release",
+        )
+    )
+    files.update(
+        _selftest_files(
+            rust_target,
+            version,
+            compiled_model_schema,
+            producer_compiled_model_schema=producer_compiled_model_schema,
+            model_compiled_model_schema=model_compiled_model_schema,
+            compiled_model_kind=compiled_model_kind,
+            model_compiler_version=model_compiler_version,
+            compiled_model_producer_schema=compiled_model_producer_schema,
+            compiled_model_producer_version=compiled_model_producer_version,
+            compiled_model_producer_compiler_version=(
+                compiled_model_producer_compiler_version
+            ),
+            compiled_model_compiler_sha256=compiled_model_compiler_sha256,
+            compiled_model_source_kind=compiled_model_source_kind,
+            compiled_model_source_digest=compiled_model_source_digest,
+            omitted_api_payload=omitted_selftest_api_payload,
+            missing_arena_capability=selftest_missing_arena_capability,
+            missing_symjit_capability=selftest_missing_symjit_capability,
+            direct_codegen_optimization_level=(
+                selftest_direct_codegen_optimization_level
+            ),
+        )
+    )
+    for relative in _LEGAL_FILES:
+        if relative == "THIRD_PARTY_NOTICES.md" and notice is None:
+            continue
+        data = (
+            notice
+            if relative == "THIRD_PARTY_NOTICES.md"
+            else (ROOT / relative).read_bytes()
+        )
+        assert data is not None
+        files[f"{dist_info}/licenses/{relative}"] = data
+    for name in (
+        "README.md",
+        "artifact-manifest-v3.schema.json",
+        "runtime-physics-v1.schema.json",
+    ):
+        files[f"pyamplicol/assets/schemas/{name}"] = (
+            ROOT / "schemas" / name
+        ).read_bytes()
+    if candidate:
+        files["pyamplicol/_build_info.json"] = json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "selftest_fixture_bootstrap": selftest_fixture_bootstrap,
+                "source_checkout": "/Users/developer/pyamplicol",
+                "version": version,
+            }
+        ).encode()
+    else:
+        files["pyamplicol/_build_info.json"] = json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": True,
+                "selftest_fixture_bootstrap": False,
+                "source_revision": "a" * 40,
+                "version": version,
+            }
+        ).encode()
+    if extra_files is not None:
+        files.update(extra_files)
+    if omitted_member is not None:
+        files.pop(omitted_member)
+    record_name = f"{dist_info}/RECORD"
+    rows = [
+        [name, _record_hash(data), str(len(data))]
+        for name, data in sorted(files.items())
+    ]
+    rows.append([record_name, "", ""])
+    if bad_record:
+        rows[0][1] = "sha256=wrong"
+    record = io.StringIO(newline="")
+    csv.writer(record, lineterminator="\n").writerows(rows)
+    files[record_name] = record.getvalue().encode()
+
+    filename = f"pyamplicol-{version}-cp311-abi3-{platform_tag}.whl"
+    path = directory / filename
+    with zipfile.ZipFile(path, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+        for name, data in files.items():
+            info = zipfile.ZipInfo(name, date_time=(2025, 1, 1, 0, 0, 0))
+            info.compress_type = zipfile.ZIP_DEFLATED
+            archive.writestr(info, data)
+    return path
+
+
+def _sdist(
+    directory: Path,
+    *,
+    version: str = _RELEASE_VERSION,
+    candidate: bool = False,
+    manifest_path: str | None = None,
+    project_requirement: str | None = None,
+    omitted_member: str | None = None,
+    extra_files: dict[str, bytes] | None = None,
+) -> Path:
+    python_version = version.replace("-dev.0", ".dev0")
+    root = f"pyamplicol-{python_version}"
+    release_cargo_lock = (ROOT / "Cargo.lock").read_bytes()
+    files = {
+        name: b"synthetic required sdist member\n"
+        for name in {*REQUIRED_SDIST_MEMBERS, "PKG-INFO"}
+    }
+    files.update(
+        {
+            "Cargo.lock": release_cargo_lock,
+            "Cargo.toml": f'[workspace.package]\nversion = "{version}"\n'.encode(),
+            "LICENSE": b"0BSD\n",
+            "README.md": b"pyamplicol\n",
+            "THIRD_PARTY_NOTICES.md": b"notices\n",
+            "build_backend/_pyamplicol_build.py": b"",
+            "dependencies/release-lock.toml": (
+                ROOT / "dependencies" / "release-lock.toml"
+            ).read_bytes(),
+            "pyproject.toml": (
+                '[project]\nname = "pyamplicol"\n'
+                + (
+                    f"dependencies = [{json.dumps(project_requirement)}]\n"
+                    if project_requirement is not None
+                    else ""
+                )
+            ).encode(),
+            "tools/release/_artifacts.py": b"",
+            "tools/release/_common.py": b"",
+            "tools/release/build_from_sdist.py": b"",
+            "tools/release/build_release_artifacts.py": b"",
+            "tools/release/check_dependencies.py": b"",
+            "tools/release/install_wheel.py": b"",
+            "tools/release/publish_dry_run.py": b"",
+            "tools/release/test_deployment.py": b"",
+        }
+    )
+    files.update(
+        {
+            f"src/{name}": data
+            for name, data in _PREPARED_PACK_COMPILER_SOURCE_FILES.items()
+        }
+    )
+    files.update(_prepared_model_files("src/pyamplicol/assets/prepared_models"))
+    if candidate:
+        files["src/pyamplicol/_build_info.json"] = json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "version": python_version,
+            }
+        ).encode()
+    else:
+        files["src/pyamplicol/_build_info.json"] = json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": True,
+                "selftest_fixture_bootstrap": False,
+                "source_revision": "a" * 40,
+                "version": python_version,
+            }
+        ).encode()
+    if manifest_path is not None:
+        files["docs/development/BUILD_MANIFEST.toml"] = (
+            f'repository = "{manifest_path}"\n'.encode()
+        )
+    if extra_files is not None:
+        files.update(extra_files)
+    if omitted_member is not None:
+        files.pop(omitted_member)
+    path = directory / f"pyamplicol-{python_version}.tar.gz"
+    with tarfile.open(path, "w:gz") as archive:
+        for name, data in files.items():
+            info = tarfile.TarInfo(f"{root}/{name}")
+            info.size = len(data)
+            archive.addfile(info, io.BytesIO(data))
+    return path
+
+
+def test_required_sdist_keeps_the_portable_source_selftest() -> None:
+    members = REQUIRED_SDIST_MEMBERS
+
+    assert (
+        "src/pyamplicol/assets/selftest/portable-64le/artifact/artifact.json" in members
+    )
+    assert {
+        "examples/data/pp_zjj_momenta.json",
+        "src/pyamplicol/assets/api_templates/rust/Makefile",
+        "src/pyamplicol/assets/api_templates/rust/check_standalone.rs",
+        "tools/release/prepare_selftest_fixture.py",
+        "tests/fixtures/reference/analytic-oracles-v2.json",
+        "tests/fixtures/reference/legacy-fortran-v2.json",
+        "tests/fixtures/reference/physics-v2.json",
+        "tests/fixtures/reference/reference-fixture-v2.manifest.json",
+    } <= members
+
+
+def test_generated_umami_templates_are_required_in_wheel_and_sdist() -> None:
+    resources = {
+        f"pyamplicol/assets/api_templates/umami/{name}"
+        for name in (
+            "Makefile",
+            "README.md",
+            "UMAMI_LICENSE",
+            "umami.h",
+            "umami.c",
+            "umami_provider.h",
+            "umami_driver.c",
+            "umami.exports",
+            "umami.exports.macos",
+        )
+    }
+    assert resources <= set(_REQUIRED_WHEEL_PACKAGE_MEMBERS)
+    assert {f"src/{name}" for name in resources} <= REQUIRED_SDIST_MEMBERS
+
+
+def test_standalone_sdk_query_package_is_required_in_wheel_and_sdist() -> None:
+    resources = {"rusticol_config/__init__.py", "rusticol_config/__main__.py"}
+    assert resources <= set(_REQUIRED_WHEEL_PACKAGE_MEMBERS)
+    assert {f"src/{name}" for name in resources} <= REQUIRED_SDIST_MEMBERS
+
+
+def test_required_sdist_keeps_both_prepared_model_architectures() -> None:
+    assert (
+        prepared_model_asset_members("src/pyamplicol/assets/prepared_models")
+        <= REQUIRED_SDIST_MEMBERS
+    )
+
+
+@pytest.mark.parametrize(
+    "missing_member",
+    sorted(
+        prepared_model_asset_members("pyamplicol/assets/prepared_models")
+        - {"pyamplicol/assets/prepared_models/__init__.py"}
+    ),
+)
+def test_wheel_requires_both_prepared_model_asset_pairs(
+    tmp_path: Path,
+    missing_member: str,
+) -> None:
+    wheel = _wheel(tmp_path, omitted_member=missing_member)
+
+    with pytest.raises(ArtifactError, match="prepared-model asset inventory"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_wheel_rejects_generic_or_extra_prepared_model_assets(tmp_path: Path) -> None:
+    prefix = "pyamplicol/assets/prepared_models"
+    wheel = _wheel(
+        tmp_path,
+        extra_files={
+            f"{prefix}/{PREPARED_MODEL_ASSET_BASENAME}.pyamplicol-model": (
+                b"legacy generic prepared model"
+            )
+        },
+    )
+
+    with pytest.raises(ArtifactError, match=r"prepared-model.*extra=.*built-in-sm"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_wheel_rejects_wrong_prepared_model_target_class(tmp_path: Path) -> None:
+    prefix = "pyamplicol/assets/prepared_models"
+    metadata_name, metadata = _modified_prepared_metadata(
+        prefix,
+        "x86_64",
+        target_values={
+            "target_triple": "symjit-storage-v3-x86_64",
+            "portable": False,
+        },
+    )
+    wheel = _wheel(tmp_path, extra_files={metadata_name: metadata})
+
+    with pytest.raises(ArtifactError, match="target class is invalid"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_wheel_rejects_prepared_model_o3_drift(tmp_path: Path) -> None:
+    prefix = "pyamplicol/assets/prepared_models"
+    metadata_name, metadata = _modified_prepared_metadata(
+        prefix,
+        "aarch64",
+        values={"jit_optimization_level": 3},
+    )
+    wheel = _wheel(tmp_path, extra_files={metadata_name: metadata})
+
+    with pytest.raises(ArtifactError, match="metadata identity is invalid"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+@pytest.mark.parametrize(
+    "values",
+    [
+        pytest.param({"bundle_size": 1}, id="size"),
+        pytest.param({"bundle_sha256": "0" * 64}, id="sha256"),
+    ],
+)
+def test_wheel_rejects_prepared_model_bundle_identity_drift(
+    tmp_path: Path,
+    values: dict[str, object],
+) -> None:
+    prefix = "pyamplicol/assets/prepared_models"
+    metadata_name, metadata = _modified_prepared_metadata(
+        prefix,
+        "aarch64",
+        values=values,
+    )
+    wheel = _wheel(tmp_path, extra_files={metadata_name: metadata})
+
+    with pytest.raises(ArtifactError, match="bundle hash/size is invalid"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_wheel_accepts_independently_serialized_portable_prepared_model_assets(
+    tmp_path: Path,
+) -> None:
+    wheel = _wheel(tmp_path)
+
+    report = audit_wheel(wheel, mode="release", native_scan=False)
+
+    assert report.target == "manylinux_2_28_x86_64"
+
+
+def test_release_and_candidate_wheels_are_distinct_and_audited(
+    tmp_path: Path,
+    candidate_dependency_provenance: None,
+) -> None:
+    release = _wheel(tmp_path)
+    report = audit_wheel(release, mode="release", native_scan=False)
+    assert report.target == "manylinux_2_28_x86_64"
+    assert report.abi_tag == "abi3"
+
+    candidate_version = f"{_RELEASE_VERSION}.dev0+candidate.0123456789ab"
+    candidate = _wheel(
+        tmp_path,
+        version=candidate_version,
+        candidate=True,
+    )
+    candidate_report = audit_wheel(candidate, mode="candidate", native_scan=False)
+    assert candidate_report.version == candidate_version
+    with pytest.raises(ArtifactError, match="release wheel has invalid version"):
+        audit_wheel(candidate, mode="release", native_scan=False)
+
+
+def test_release_metadata_may_document_candidate_workflows(tmp_path: Path) -> None:
+    wheel = _wheel(
+        tmp_path,
+        metadata_description="Contributor candidate setup is non-publishable.\n",
+    )
+
+    assert (
+        audit_wheel(wheel, mode="release", native_scan=False).version
+        == _RELEASE_VERSION
+    )
+
+
+def test_release_wheel_requires_the_minimal_build_marker(tmp_path: Path) -> None:
+    missing = _wheel(
+        tmp_path,
+        omitted_member="pyamplicol/_build_info.json",
+    )
+    with pytest.raises(ArtifactError, match="one _build_info"):
+        audit_wheel(missing, mode="release", native_scan=False)
+
+    missing.unlink()
+    invalid = _wheel(
+        tmp_path,
+        extra_files={
+            "pyamplicol/_build_info.json": json.dumps(
+                {
+                    "schema_version": 1,
+                    "publishable": True,
+                    "selftest_fixture_bootstrap": False,
+                    "source_revision": "a" * 40,
+                    "source_checkout": "/private/source",
+                    "version": _RELEASE_VERSION,
+                }
+            ).encode()
+        },
+    )
+    with pytest.raises(ArtifactError, match="release build marker"):
+        audit_wheel(invalid, mode="release", native_scan=False)
+
+
+def test_candidate_and_release_symbolica_wheel_pins_can_match(
+    tmp_path: Path,
+    candidate_dependency_provenance: None,
+) -> None:
+    candidate_version = f"{_RELEASE_VERSION}.dev0+candidate.0123456789ab"
+    release_pin = _wheel(
+        tmp_path,
+        version=candidate_version,
+        candidate=True,
+        requirements=_DEFAULT_REQUIREMENTS,
+    )
+    candidate_report = audit_wheel(
+        release_pin,
+        mode="candidate",
+        native_scan=False,
+    )
+    assert candidate_report.version == candidate_version
+
+    release_pin.unlink()
+    candidate_pin = _wheel(
+        tmp_path,
+        requirements=_CANDIDATE_REQUIREMENTS,
+    )
+    release_report = audit_wheel(
+        candidate_pin,
+        mode="release",
+        native_scan=False,
+    )
+    assert release_report.version == _LOCK["project"]["version"]
+
+
+def test_candidate_dependency_provenance_uses_compact_source_map(
+    candidate_dependency_provenance: None,
+) -> None:
+    assert artifacts._candidate_dependency_overrides() == {
+        "symbolica": _CONTRIBUTOR_LOCK["symbolica"]["candidate_version"],
+        "ufo-model-loader": _LOCK["ufo_model_loader"]["required_version"],
+    }
+
+
+def test_candidate_dependency_provenance_rejects_extra_attestations(
+    tmp_path: Path,
+    candidate_dependency_provenance: None,
+) -> None:
+    state_path = artifacts.ROOT / artifacts._CANDIDATE_INSTALL_STATE
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+    state["created_utc"] = "2026-07-31T00:00:00Z"
+    state_path.write_text(json.dumps(state) + "\n", encoding="utf-8")
+    candidate = _wheel(
+        tmp_path,
+        version=f"{_RELEASE_VERSION}.dev0+candidate.0123456789ab",
+        candidate=True,
+    )
+
+    with pytest.raises(ArtifactError, match="only its source revisions"):
+        audit_wheel(candidate, mode="candidate", native_scan=False)
+
+
+def test_candidate_dependency_provenance_rejects_heavy_source_attestations(
+    tmp_path: Path,
+    candidate_dependency_provenance: None,
+) -> None:
+    state_path = artifacts.ROOT / artifacts._CANDIDATE_INSTALL_STATE
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+    state["sources"]["symbolica"]["worktree_sha256"] = "0" * 64
+    state_path.write_text(json.dumps(state) + "\n", encoding="utf-8")
+    candidate = _wheel(
+        tmp_path,
+        version=f"{_RELEASE_VERSION}.dev0+candidate.0123456789ab",
+        candidate=True,
+    )
+
+    with pytest.raises(ArtifactError, match="invalid descriptor"):
+        audit_wheel(candidate, mode="candidate", native_scan=False)
+
+
+def test_candidate_wheel_rejects_selftest_fixture_bootstrap_marker(
+    tmp_path: Path,
+    candidate_dependency_provenance: None,
+) -> None:
+    candidate = _wheel(
+        tmp_path,
+        version=f"{_RELEASE_VERSION}.dev0+candidate.0123456789ab",
+        candidate=True,
+        selftest_fixture_bootstrap=True,
+    )
+
+    with pytest.raises(ArtifactError, match="bootstrap wheels are not deployable"):
+        audit_wheel(candidate, mode="candidate", native_scan=False)
+
+
+def test_host_native_linux_tag_is_candidate_only(
+    tmp_path: Path,
+    candidate_dependency_provenance: None,
+) -> None:
+    candidate = _wheel(
+        tmp_path,
+        version=f"{_RELEASE_VERSION}.dev0+candidate.0123456789ab",
+        candidate=True,
+        platform_tag="linux_x86_64",
+    )
+
+    report = audit_wheel(candidate, mode="candidate", native_scan=False)
+    assert report.target == "manylinux_2_28_x86_64"
+    assert report.rust_target == "x86_64-unknown-linux-gnu"
+
+    with pytest.raises(ArtifactError, match="wheel platform tag"):
+        audit_wheel(candidate, mode="release", native_scan=False)
+
+
+def test_candidate_allows_only_rustup_standard_library_source_paths(
+    tmp_path: Path,
+    candidate_dependency_provenance: None,
+) -> None:
+    candidate_version = f"{_RELEASE_VERSION}.dev0+candidate.0123456789ab"
+    rustup_location = (
+        b"/Users/developer/.rustup/toolchains/stable-aarch64-apple-darwin/"
+        b"lib/rustlib/src/rust/library/core/src/slice/index.rs"
+    )
+    candidate = _wheel(
+        tmp_path,
+        version=candidate_version,
+        candidate=True,
+        extension=rustup_location,
+    )
+    assert audit_wheel(candidate, mode="candidate", native_scan=False).version == (
+        candidate_version
+    )
+
+    release = _wheel(tmp_path, extension=rustup_location)
+    with pytest.raises(ArtifactError, match="non-relocatable path marker"):
+        audit_wheel(release, mode="release", native_scan=False)
+
+    other_local_path = _wheel(
+        tmp_path,
+        version=f"{_RELEASE_VERSION}.dev0+candidate.abcdef012345",
+        candidate=True,
+        extension=b"/Users/developer/project/private.rs",
+    )
+    with pytest.raises(ArtifactError, match="non-relocatable path marker"):
+        audit_wheel(other_local_path, mode="candidate", native_scan=False)
+
+
+def test_short_repository_root_is_matched_only_at_a_path_token_boundary(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    marker = b"/io"
+    monkeypatch.setattr(artifacts, "_REPOSITORY_PATH_MARKER", marker)
+
+    assert not artifacts._contains_forbidden_path(
+        b"/rustc/hash/library/std/src/io/error.rs",
+        marker,
+    )
+    assert not artifacts._contains_forbidden_path(
+        b"symbolic/path/to/io/helpers.rs",
+        marker,
+    )
+    assert not artifacts._contains_forbidden_path(
+        b"\0native-instruction-bytes:\x8f/ioX\x91",
+        marker,
+    )
+    assert artifacts._contains_forbidden_path(
+        b"compiled from /io/dependencies/checkouts/symjit/rust/lib.rs",
+        marker,
+    )
+    assert artifacts._contains_forbidden_path(
+        b"\0/io/source/rust/crates/rusticol-core/src/lib.rs",
+        marker,
+    )
+    assert artifacts._contains_forbidden_path(b"checkout root: /io\0", marker)
+
+
+def test_native_scan_requires_short_repository_directory_prefix(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    marker = b"/io"
+    monkeypatch.setattr(artifacts, "_REPOSITORY_PATH_MARKER", marker)
+    monkeypatch.setattr(artifacts, "_FORBIDDEN_PATH_MARKERS", (b"/tmp/", marker))
+
+    artifacts._scan_embedded_paths({"pyamplicol/_rusticol.abi3.so": b"\x8f/io\x91"})
+    with pytest.raises(ArtifactError, match="non-relocatable path marker '/io/'"):
+        artifacts._scan_embedded_paths(
+            {"pyamplicol/_rusticol.abi3.so": b"\0/io/source.rs\0"}
+        )
+
+
+def test_temporary_path_marker_is_matched_only_at_a_path_token_boundary() -> None:
+    marker = b"/tmp/"
+
+    assert not artifacts._contains_forbidden_path(
+        b"/pyamplicol/checkout/.artifacts/dev-install/tmp/build/source.rs",
+        marker,
+    )
+    assert artifacts._contains_forbidden_path(
+        b"compiled from /tmp/build/source.rs",
+        marker,
+    )
+    assert artifacts._contains_forbidden_path(b"\0/tmp/build/source.rs", marker)
+
+
+def test_release_allows_rust_standard_library_backtrace_source_paths(
+    tmp_path: Path,
+) -> None:
+    standard_library_location = (
+        b"/rustc/59807616e1fa2540724bfbac14d7976d7e4a3860/library/std/src/"
+        b"../../backtrace/src/symbolize/gimli.rs"
+    )
+    wheel = _wheel(tmp_path, extension=standard_library_location)
+    assert (
+        audit_wheel(wheel, mode="release", native_scan=False).version
+        == _RELEASE_VERSION
+    )
+
+
+def test_release_allows_remapped_rust_standard_library_backtrace_paths(
+    tmp_path: Path,
+) -> None:
+    remapped_standard_library_location = (
+        b"library/std/src/../../backtrace/src/symbolize/gimli.rs"
+    )
+    wheel = _wheel(tmp_path, extension=remapped_standard_library_location)
+    assert (
+        audit_wheel(wheel, mode="release", native_scan=False).version
+        == _RELEASE_VERSION
+    )
+
+
+@pytest.mark.parametrize("marker", [b"__gmpz_init", b"mpfr_set", b"malachite-q"])
+def test_native_scan_rejects_static_arithmetic_runtime_markers(
+    tmp_path: Path,
+    marker: bytes,
+) -> None:
+    binary = tmp_path / "native-artifact"
+    binary.write_bytes(b"prefix\x00" + marker + b"\x00suffix")
+    with pytest.raises(ArtifactError, match="forbidden static arithmetic runtime"):
+        _scan_static_runtime_families(binary, "test artifact")
+
+
+@pytest.mark.parametrize(
+    "symbol",
+    ["_PyErr_SetString", "PyLong_FromLong", "_Py_Dealloc"],
+)
+def test_capi_archive_scan_rejects_undefined_python_symbols(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    symbol: str,
+) -> None:
+    archive = tmp_path / "librusticol_capi.a"
+    archive.write_bytes(b"synthetic archive")
+    monkeypatch.delenv("LLVM_NM", raising=False)
+    monkeypatch.setattr(artifacts.shutil, "which", lambda _name: "/usr/bin/nm")
+    monkeypatch.setattr(
+        artifacts.subprocess,
+        "run",
+        lambda *_args, **_kwargs: subprocess.CompletedProcess(
+            ["nm"], 0, stdout=f"                 U {symbol}\n", stderr=""
+        ),
+    )
+
+    with pytest.raises(ArtifactError, match="undefined Python"):
+        _scan_capi_archive(archive, allow_local_rustup=False)
+
+
+def test_capi_archive_scan_ignores_raw_pyo3_marker_with_clean_symbols(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    archive = tmp_path / "librusticol_capi.a"
+    archive.write_bytes(b"synthetic compressed archive bytes containing pyo3")
+    monkeypatch.delenv("LLVM_NM", raising=False)
+    monkeypatch.setattr(artifacts.shutil, "which", lambda _name: "/usr/bin/nm")
+    monkeypatch.setattr(
+        artifacts.subprocess,
+        "run",
+        lambda *_args, **_kwargs: subprocess.CompletedProcess(
+            ["nm"], 0, stdout="", stderr=""
+        ),
+    )
+
+    assert _scan_capi_archive(archive, allow_local_rustup=False)
+
+
+def test_capi_archive_scan_defers_incompatible_llvm_reader(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    archive = tmp_path / "librusticol_capi.a"
+    archive.write_bytes(b"synthetic archive")
+    monkeypatch.delenv("LLVM_NM", raising=False)
+    monkeypatch.setattr(artifacts.shutil, "which", lambda _name: "/usr/bin/nm")
+    monkeypatch.setattr(
+        artifacts.subprocess,
+        "run",
+        lambda *_args, **_kwargs: subprocess.CompletedProcess(
+            ["nm"],
+            1,
+            stdout="",
+            stderr="Unknown attribute kind (91) from LLVM 20",
+        ),
+    )
+
+    assert not _scan_capi_archive(archive, allow_local_rustup=False)
+
+
+def test_record_direct_dependency_and_size_fail_closed(tmp_path: Path) -> None:
+    bad_record = _wheel(tmp_path, bad_record=True)
+    with pytest.raises(ArtifactError, match="RECORD hash"):
+        audit_wheel(bad_record, mode="release", native_scan=False)
+
+    bad_record.unlink()
+    direct = _wheel(tmp_path, requirement="numpy @ file:///tmp/numpy.whl")
+    with pytest.raises(ArtifactError, match="direct URL or path"):
+        audit_wheel(direct, mode="release", native_scan=False)
+
+    direct.unlink()
+    parent_reference = _wheel(tmp_path, extension=b"built from ../parent/source")
+    with pytest.raises(ArtifactError, match="non-relocatable"):
+        audit_wheel(parent_reference, mode="release", native_scan=False)
+
+    oversized = (
+        tmp_path / f"pyamplicol-{_RELEASE_VERSION}-cp311-abi3-manylinux_2_28_x86_64.whl"
+    )
+    with oversized.open("wb") as stream:
+        stream.truncate(MAX_WHEEL_BYTES + 1)
+    with pytest.raises(ArtifactError, match="limit"):
+        audit_wheel(oversized, mode="release", native_scan=False)
+
+
+def test_wheel_filename_version_must_match_metadata(tmp_path: Path) -> None:
+    wheel = _wheel(tmp_path)
+    renamed = wheel.with_name(wheel.name.replace(f"-{_RELEASE_VERSION}-", "-9.9.9-"))
+    wheel.rename(renamed)
+    with pytest.raises(ArtifactError, match="filename version"):
+        audit_wheel(renamed, mode="release", native_scan=False)
+
+
+def test_wheel_selftest_compiled_model_matches_release_schema(tmp_path: Path) -> None:
+    expected = _LOCK["abis"]["compiled_model"]
+    wheel = _wheel(tmp_path, compiled_model_schema=expected - 1)
+
+    with pytest.raises(ArtifactError, match=f"release schema {expected}"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+@pytest.mark.parametrize(
+    ("owner", "contract"),
+    (
+        ("artifact_runtime", "artifact"),
+        ("process", "artifact"),
+        ("execution", "execution"),
+        ("stage_evaluators", "execution"),
+    ),
+)
+def test_wheel_selftest_requires_complete_arena_capability(
+    tmp_path: Path,
+    owner: str,
+    contract: str,
+) -> None:
+    wheel = _wheel(
+        tmp_path,
+        selftest_missing_arena_capability=owner,
+    )
+
+    with pytest.raises(
+        ArtifactError,
+        match=rf"Arena {contract} contract.*must require compiled-plane-arena-v1",
+    ):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+@pytest.mark.parametrize(
+    ("owner", "contract"),
+    (
+        ("artifact_runtime", "artifact"),
+        ("process", "artifact"),
+        ("execution", "execution"),
+        ("stage_evaluators", "execution"),
+    ),
+)
+def test_wheel_selftest_requires_complete_symjit_capability(
+    tmp_path: Path,
+    owner: str,
+    contract: str,
+) -> None:
+    wheel = _wheel(
+        tmp_path,
+        selftest_missing_symjit_capability=owner,
+    )
+
+    with pytest.raises(
+        ArtifactError,
+        match=(
+            rf"Arena {contract} contract.*must require "
+            r"symjit\.application\.complex-f64\.v1"
+        ),
+    ):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_wheel_selftest_requires_plane_codegen_optimization_match(
+    tmp_path: Path,
+) -> None:
+    wheel = _wheel(
+        tmp_path,
+        selftest_direct_codegen_optimization_level=3,
+    )
+
+    with pytest.raises(
+        ArtifactError,
+        match=r"Arena execution contract.*direct codegen optimization.*plane",
+    ):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+@pytest.mark.parametrize(
+    ("override", "message"),
+    [
+        pytest.param(
+            {"compiled_model_kind": "other-compiled-model"},
+            "compiled model kind is invalid",
+            id="kind",
+        ),
+        pytest.param(
+            {
+                "model_compiler_version": _MODEL_COMPILER_VERSION + 1,
+                "compiled_model_producer_compiler_version": (_MODEL_COMPILER_VERSION),
+            },
+            "compiler version does not match producer",
+            id="compiler-version",
+        ),
+        pytest.param(
+            {"compiled_model_producer_schema": (_LOCK["abis"]["compiled_model"] - 1)},
+            "producer does not match release schema",
+            id="producer-schema",
+        ),
+        pytest.param(
+            {"compiled_model_producer_version": "9.9.9"},
+            "producer does not match wheel version",
+            id="producer-version",
+        ),
+        pytest.param(
+            {"compiled_model_source_kind": "ufo"},
+            "source is not built-in-sm",
+            id="source-kind",
+        ),
+    ],
+)
+def test_wheel_selftest_compiled_model_matches_packaged_producer(
+    tmp_path: Path,
+    override: dict[str, object],
+    message: str,
+) -> None:
+    wheel = _wheel(tmp_path, **override)
+
+    with pytest.raises(ArtifactError, match=message):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+@pytest.mark.parametrize(
+    ("source_name", "replacement"),
+    [
+        pytest.param(
+            "pyamplicol/models/compiler.py",
+            b"def compile_model():\n    return 'changed'\n",
+            id="models",
+        ),
+        pytest.param(
+            "pyamplicol/_internal/physics/rules.py",
+            b"PROPAGATOR = 'changed'\n",
+            id="physics",
+        ),
+        pytest.param(
+            "pyamplicol/processes/core_syntax.py",
+            b"CORE_SYNTAX_VERSION = 2\n",
+            id="core-syntax",
+        ),
+        pytest.param(
+            "pyamplicol/models/builtin/model.py",
+            b"MODEL_NAME = 'changed'\n",
+            id="built-in",
+        ),
+    ],
+)
+def test_wheel_selftest_accepts_source_edits_with_stable_runtime_contract(
+    tmp_path: Path,
+    source_name: str,
+    replacement: bytes,
+) -> None:
+    wheel = _wheel(tmp_path, extra_files={source_name: replacement})
+
+    assert (
+        audit_wheel(wheel, mode="release", native_scan=False).version
+        == _RELEASE_VERSION
+    )
+
+
+def test_wheel_selftest_digests_ignore_nested_model_sources(tmp_path: Path) -> None:
+    wheel = _wheel(
+        tmp_path,
+        extra_files={
+            "pyamplicol/models/nested/ignored.py": b"MODEL_COMPILER_VERSION = 99\n",
+            "pyamplicol/_internal/physics/nested/ignored.py": b"PHYSICS = 99\n",
+            "pyamplicol/models/builtin/nested/ignored.py": b"MODEL = 99\n",
+        },
+    )
+
+    assert (
+        audit_wheel(wheel, mode="release", native_scan=False).version
+        == _RELEASE_VERSION
+    )
+
+
+@pytest.mark.parametrize(
+    "schema_override",
+    [
+        {"producer_compiled_model_schema": _LOCK["abis"]["compiled_model"] - 1},
+        {"model_compiled_model_schema": _LOCK["abis"]["compiled_model"] - 1},
+    ],
+)
+def test_wheel_selftest_producer_and_model_metadata_match_release_schema(
+    tmp_path: Path,
+    schema_override: dict[str, int],
+) -> None:
+    expected = _LOCK["abis"]["compiled_model"]
+    wheel = _wheel(tmp_path, **schema_override)
+
+    with pytest.raises(
+        ArtifactError,
+        match=f"producer/model metadata.*schema {expected}",
+    ):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_wheel_selftest_requires_the_complete_five_language_api_bundle(
+    tmp_path: Path,
+) -> None:
+    wheel = _wheel(
+        tmp_path,
+        omitted_selftest_api_payload="API/rust/check_standalone.rs",
+    )
+
+    with pytest.raises(ArtifactError, match=r"five-language API.*API/rust"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_sdk_link_metadata_is_target_allowlisted(tmp_path: Path) -> None:
+    wheel = _wheel(tmp_path, system_libraries=["python3.11"])
+    with pytest.raises(ArtifactError, match="target-allowlisted"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_runtime_requirements_must_agree_with_release_contract(tmp_path: Path) -> None:
+    missing = _wheel(
+        tmp_path,
+        requirements=[
+            item for item in _DEFAULT_REQUIREMENTS if not item.startswith("colorama")
+        ],
+    )
+    with pytest.raises(ArtifactError, match="inventory disagrees"):
+        audit_wheel(missing, mode="release", native_scan=False)
+
+    missing.unlink()
+    incompatible = _wheel(
+        tmp_path,
+        requirements=[
+            "numpy<2" if item.startswith("numpy") else item
+            for item in _DEFAULT_REQUIREMENTS
+        ],
+    )
+    with pytest.raises(ArtifactError, match="excludes locked version"):
+        audit_wheel(incompatible, mode="release", native_scan=False)
+
+    incompatible.unlink()
+    ordinary_range = _wheel(
+        tmp_path,
+        requirements=[
+            "numpy>=1.26" if item.startswith("numpy") else item
+            for item in _DEFAULT_REQUIREMENTS
+        ],
+    )
+    with pytest.raises(ArtifactError, match=r"pin numpy==2\.4\.6 exactly"):
+        audit_wheel(ordinary_range, mode="release", native_scan=False)
+
+    ordinary_range.unlink()
+    symbolica_version = _LOCK["symbolica"]["python_version"]
+    non_exact = _wheel(
+        tmp_path,
+        requirements=[
+            f"symbolica>={symbolica_version}" if item.startswith("symbolica") else item
+            for item in _DEFAULT_REQUIREMENTS
+        ],
+    )
+    with pytest.raises(
+        ArtifactError,
+        match=rf"pin symbolica=={re.escape(symbolica_version)} exactly",
+    ):
+        audit_wheel(non_exact, mode="release", native_scan=False)
+
+    non_exact.unlink()
+    marker_string = _wheel(
+        tmp_path,
+        requirements=[
+            *_DEFAULT_REQUIREMENTS,
+            "unexpected==1; python_version == 'extra'",
+        ],
+    )
+    with pytest.raises(ArtifactError, match="may not use environment markers"):
+        audit_wheel(marker_string, mode="release", native_scan=False)
+
+    marker_string.unlink()
+    optional = _wheel(
+        tmp_path,
+        requirements=[*_DEFAULT_REQUIREMENTS, "build>=1; extra == 'test'"],
+    )
+    assert (
+        audit_wheel(optional, mode="release", native_scan=False).version
+        == _RELEASE_VERSION
+    )
+
+
+def test_wheel_uses_metadata_not_packaged_dependency_inventories(
+    tmp_path: Path,
+) -> None:
+    wheel = _wheel(tmp_path)
+    with zipfile.ZipFile(wheel) as archive:
+        assert not any(
+            name.startswith("pyamplicol/assets/release/") for name in archive.namelist()
+        )
+
+    wheel.unlink()
+    no_notice = _wheel(tmp_path, notice=None)
+    with pytest.raises(ArtifactError, match="missing nonempty legal member"):
+        audit_wheel(no_notice, mode="release", native_scan=False)
+
+    no_notice.unlink()
+    empty_notice = _wheel(tmp_path, notice=b"\n")
+    with pytest.raises(ArtifactError, match="missing nonempty legal member"):
+        audit_wheel(empty_notice, mode="release", native_scan=False)
+
+
+def test_wheel_rejects_resources_installed_at_site_packages_root(
+    tmp_path: Path,
+) -> None:
+    wheel = _wheel(tmp_path)
+    with zipfile.ZipFile(wheel) as archive:
+        files = {name: archive.read(name) for name in archive.namelist()}
+    files["schemas/artifact-manifest-v3.schema.json"] = b"{}\n"
+    record_name = next(name for name in files if name.endswith(".dist-info/RECORD"))
+    rows = [
+        [name, _record_hash(data), str(len(data))]
+        for name, data in sorted(files.items())
+        if name != record_name
+    ]
+    rows.append([record_name, "", ""])
+    record = io.StringIO(newline="")
+    csv.writer(record, lineterminator="\n").writerows(rows)
+    files[record_name] = record.getvalue().encode()
+    with zipfile.ZipFile(wheel, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+        for name, data in files.items():
+            archive.writestr(name, data)
+
+    with pytest.raises(ArtifactError, match="outside pyamplicol"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+@pytest.mark.parametrize(
+    "resource",
+    [
+        "pyamplicol/assets/schemas/README.md",
+        "pyamplicol/assets/schemas/artifact-manifest-v3.schema.json",
+        "pyamplicol/assets/schemas/runtime-physics-v1.schema.json",
+    ],
+)
+def test_wheel_requires_all_package_owned_schema_resources(
+    tmp_path: Path, resource: str
+) -> None:
+    wheel = _wheel(tmp_path, omitted_member=resource)
+    with pytest.raises(ArtifactError, match=re.escape(resource)):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+@pytest.mark.parametrize(
+    "resource",
+    [
+        "pyamplicol/_examples/data/pp_zjj_momenta.json",
+        "pyamplicol/assets/api_templates/rust/Makefile",
+        "pyamplicol/assets/api_templates/rust/check_standalone.rs",
+        "pyamplicol/assets/api_templates/umami/umami.c",
+        "pyamplicol/_sdk/rust/rusticol.rs",
+    ],
+)
+def test_wheel_requires_primary_example_data_and_rust_api_templates(
+    tmp_path: Path, resource: str
+) -> None:
+    wheel = _wheel(tmp_path, omitted_member=resource)
+    with pytest.raises(ArtifactError, match=re.escape(resource)):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_wheel_rejects_an_unknown_top_level_root(tmp_path: Path) -> None:
+    wheel = _wheel(tmp_path, extra_files={"docs/leak.txt": b"not wheel data\n"})
+    with pytest.raises(ArtifactError, match=r"outside pyamplicol.*docs/leak\.txt"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_wheel_rejects_generated_sboms(tmp_path: Path) -> None:
+    wheel = _wheel(
+        tmp_path,
+        extra_files={
+            f"pyamplicol-{_RELEASE_VERSION}.dist-info/"
+            "sboms/rusticol-python.cyclonedx.json": b"{}\n"
+        },
+    )
+    with pytest.raises(ArtifactError, match="must not contain generated SBOMs"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+
+def test_wheel_rejects_non_library_repair_root_files(tmp_path: Path) -> None:
+    repair_secret = _wheel(
+        tmp_path,
+        extra_files={"pyamplicol.libs/token.txt": b"not a repaired library\n"},
+    )
+    with pytest.raises(ArtifactError, match="non-library member"):
+        audit_wheel(repair_secret, mode="release", native_scan=False)
+
+
+def test_wheel_requires_standard_license_metadata_and_allows_extra_notices(
+    tmp_path: Path,
+) -> None:
+    supplementary = "licenses/SymJIT.txt"
+    dist_info = f"pyamplicol-{_RELEASE_VERSION}.dist-info"
+    wheel = _wheel(
+        tmp_path,
+        omitted_member=f"{dist_info}/licenses/{supplementary}",
+    )
+    with pytest.raises(ArtifactError, match=re.escape(supplementary)):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+    wheel.unlink()
+    wheel = _wheel(
+        tmp_path,
+        license_files=tuple(item for item in _LEGAL_FILES if item != supplementary),
+    )
+    with pytest.raises(ArtifactError, match=r"omits required.*SymJIT"):
+        audit_wheel(wheel, mode="release", native_scan=False)
+
+    wheel.unlink()
+    additional = "licenses/ADDITIONAL.txt"
+    wheel = _wheel(
+        tmp_path,
+        license_files=(*_LEGAL_FILES, additional),
+        extra_files={f"{dist_info}/licenses/{additional}": b"additional attribution\n"},
+    )
+    assert (
+        audit_wheel(wheel, mode="release", native_scan=False).version
+        == _RELEASE_VERSION
+    )
+
+
+def test_candidate_sdk_version_must_match_staged_package_exactly(
+    tmp_path: Path,
+    candidate_dependency_provenance: None,
+) -> None:
+    version = f"{_RELEASE_VERSION}.dev0+candidate.0123456789ab"
+    wheel = _wheel(
+        tmp_path,
+        version=version,
+        candidate=True,
+        sdk_version="0.1.0",
+    )
+    with pytest.raises(ArtifactError, match="SDK version"):
+        audit_wheel(wheel, mode="candidate", native_scan=False)
+
+
+def test_release_sdist_identity_and_path_scan(tmp_path: Path) -> None:
+    release = _sdist(tmp_path)
+    assert audit_sdist(release, mode="release").version == _RELEASE_VERSION
+
+    candidate = _sdist(
+        tmp_path,
+        version=f"{_RELEASE_VERSION}-dev.0+candidate.0123456789ab",
+        candidate=True,
+    )
+    with pytest.raises(ArtifactError, match="candidate source distributions"):
+        audit_sdist(candidate, mode="candidate")
+
+    release.unlink()
+    leaked = _sdist(tmp_path, manifest_path="/Users/build/parent-project")
+    with pytest.raises(ArtifactError, match="non-relocatable"):
+        audit_sdist(leaked, mode="release")
+
+    leaked.unlink()
+    direct = _sdist(
+        tmp_path,
+        project_requirement="numpy @ https://example.invalid/numpy.whl",
+    )
+    with pytest.raises(ArtifactError, match="direct URL or path"):
+        audit_sdist(direct, mode="release")
+
+    direct.unlink()
+    fixture_leak = _sdist(
+        tmp_path,
+        extra_files={
+            "tests/fixtures/reference/physics-v2.json": (
+                b'{"capture_root":"/Users/build/private-checkout"}\n'
+            )
+        },
+    )
+    with pytest.raises(ArtifactError, match="non-relocatable"):
+        audit_sdist(fixture_leak, mode="release")
+
+
+def test_release_sdist_requires_the_minimal_build_marker(tmp_path: Path) -> None:
+    missing = _sdist(
+        tmp_path,
+        omitted_member="src/pyamplicol/_build_info.json",
+    )
+    with pytest.raises(ArtifactError, match="missing required files"):
+        audit_sdist(missing, mode="release")
+
+    missing.unlink()
+    invalid = _sdist(
+        tmp_path,
+        extra_files={
+            "src/pyamplicol/_build_info.json": json.dumps(
+                {
+                    "schema_version": 1,
+                    "publishable": True,
+                    "selftest_fixture_bootstrap": False,
+                    "source_revision": "not-a-revision",
+                    "version": _RELEASE_VERSION,
+                }
+            ).encode()
+        },
+    )
+    with pytest.raises(ArtifactError, match="release sdist build marker"):
+        audit_sdist(invalid, mode="release")
+
+
+@pytest.mark.parametrize(
+    "missing_member",
+    sorted(
+        prepared_model_asset_members("src/pyamplicol/assets/prepared_models")
+        - {"src/pyamplicol/assets/prepared_models/__init__.py"}
+    ),
+)
+def test_sdist_requires_both_prepared_model_asset_pairs(
+    tmp_path: Path,
+    missing_member: str,
+) -> None:
+    sdist = _sdist(tmp_path, omitted_member=missing_member)
+
+    with pytest.raises(ArtifactError, match="sdist is missing required files"):
+        audit_sdist(sdist, mode="release")
+
+
+def test_sdist_rejects_generic_or_extra_prepared_model_assets(tmp_path: Path) -> None:
+    prefix = "src/pyamplicol/assets/prepared_models"
+    sdist = _sdist(
+        tmp_path,
+        extra_files={
+            f"{prefix}/{PREPARED_MODEL_ASSET_BASENAME}.metadata.json": b"{}\n"
+        },
+    )
+
+    with pytest.raises(ArtifactError, match=r"prepared-model.*extra=.*built-in-sm"):
+        audit_sdist(sdist, mode="release")
+
+
+def test_sdist_validates_prepared_model_target_and_bundle_identity(
+    tmp_path: Path,
+) -> None:
+    prefix = "src/pyamplicol/assets/prepared_models"
+    metadata_name, metadata = _modified_prepared_metadata(
+        prefix,
+        "aarch64",
+        target_values={"target_triple": "symjit-storage-v3-x86_64"},
+    )
+    wrong_target = _sdist(tmp_path, extra_files={metadata_name: metadata})
+    with pytest.raises(ArtifactError, match="target class is invalid"):
+        audit_sdist(wrong_target, mode="release")
+
+    wrong_target.unlink()
+    metadata_name, metadata = _modified_prepared_metadata(
+        prefix,
+        "x86_64",
+        values={"bundle_sha256": "f" * 64},
+    )
+    wrong_digest = _sdist(tmp_path, extra_files={metadata_name: metadata})
+    with pytest.raises(ArtifactError, match="bundle hash/size is invalid"):
+        audit_sdist(wrong_digest, mode="release")
+
+
+def test_sdist_rejects_candidate_prepared_model_assets(tmp_path: Path) -> None:
+    prefix = "src/pyamplicol/assets/prepared_models"
+    metadata_name, metadata_bytes = _modified_prepared_metadata(
+        prefix,
+        "aarch64",
+    )
+    metadata = json.loads(metadata_bytes)
+    metadata["build_contract"]["mode"] = "candidate"
+    sdist = _sdist(
+        tmp_path,
+        extra_files={
+            metadata_name: (json.dumps(metadata, sort_keys=True) + "\n").encode()
+        },
+    )
+
+    with pytest.raises(ArtifactError, match="build mode is invalid"):
+        audit_sdist(sdist, mode="release")
+
+
+def test_sdist_accepts_prepared_payload_compiler_edits(tmp_path: Path) -> None:
+    sdist = _sdist(
+        tmp_path,
+        extra_files={"src/pyamplicol/evaluators/symbolica_compile.py": b"# drift\n"},
+    )
+
+    assert audit_sdist(sdist, mode="release").version == _RELEASE_VERSION
+
+
+@pytest.mark.parametrize(
+    "forbidden",
+    [
+        ".cargo/config.toml",
+        "build_backend/python_lock.py",
+        "dependencies/contributor-lock.toml",
+        "dependencies/install_dependencies.py",
+        "dependencies/patches/symbolica/fix.patch",
+        "dependencies/python-runtime-lock.toml",
+        "release_assets/prepared_models/built-in-sm-jit-o2-aarch64.metadata.json",
+    ],
+)
+def test_sdist_rejects_contributor_dependency_material(
+    tmp_path: Path, forbidden: str
+) -> None:
+    sdist = _sdist(
+        tmp_path,
+        extra_files={forbidden: b"contributor-only\n"},
+    )
+    with pytest.raises(ArtifactError, match="contributor-only dependency inputs"):
+        audit_sdist(sdist, mode="release")
+
+
+def test_sdist_rejects_extra_symjit_source_ceremony(tmp_path: Path) -> None:
+    lock_member = "dependencies/release-lock.toml"
+    lock_text = (ROOT / lock_member).read_text(encoding="utf-8")
+    symjit = _LOCK["symjit"]
+    contract = f'[symjit]\nversion = "{symjit["version"]}"\n'
+    replacement = contract + 'source_url = "https://example.invalid/archive.tar.gz"\n'
+    assert lock_text.count(contract) == 1
+    sdist = _sdist(
+        tmp_path,
+        extra_files={lock_member: lock_text.replace(contract, replacement).encode()},
+    )
+
+    with pytest.raises(ArtifactError, match="published SymJIT version contract"):
+        audit_sdist(sdist, mode="release")
+
+
+def test_sdist_rejects_mismatched_symjit_cargo_source(tmp_path: Path) -> None:
+    symjit = _LOCK["symjit"]
+    cargo_lock = (ROOT / "Cargo.lock").read_text(encoding="utf-8")
+    expected = (
+        'name = "symjit"\n'
+        f'version = "{symjit["version"]}"\n'
+        'source = "registry+https://github.com/rust-lang/crates.io-index"'
+    )
+    assert cargo_lock.count(expected) == 1
+    mismatched = cargo_lock.replace(
+        expected,
+        expected.replace(
+            "registry+https://github.com/rust-lang/crates.io-index",
+            "git+https://example.invalid/symjit",
+        ),
+    )
+    sdist = _sdist(
+        tmp_path,
+        extra_files={"Cargo.lock": mismatched.encode("utf-8")},
+    )
+
+    with pytest.raises(ArtifactError, match="published SymJIT dependency"):
+        audit_sdist(sdist, mode="release")
+
+
+@pytest.mark.parametrize(
+    "missing_member",
+    [
+        "build_backend/_pyamplicol_build.py",
+        "build_backend/sdk.py",
+        "docs/user/installation.md",
+        "examples/data/pp_zjj_momenta.json",
+        "examples/python/typed_generation.py",
+        "rust/crates/rusticol-capi/Cargo.toml",
+        "rust/crates/rusticol-capi/include/rusticol.h",
+        "rust/crates/rusticol-python/stubs/pyamplicol/_rusticol.pyi",
+        "schemas/README.md",
+        "schemas/artifact-manifest-v3.schema.json",
+        "src/pyamplicol/assets/selftest/portable-64le/expected.json",
+        "src/pyamplicol/assets/selftest/portable-64le/artifact/artifact.json",
+        "tools/release/prepare_selftest_fixture.py",
+        "src/pyamplicol/assets/api_templates/rust/check_standalone.rs",
+        "tests/integration/test_examples.py",
+        "tools/release/test_deployment.py",
+    ],
+)
+def test_sdist_requires_nested_release_content(
+    tmp_path: Path, missing_member: str
+) -> None:
+    sdist = _sdist(tmp_path, omitted_member=missing_member)
+    with pytest.raises(ArtifactError, match=re.escape(missing_member)):
+        audit_sdist(sdist, mode="release")
diff --git a/pyamplicol/tests/release/test_eager_portability.py b/pyamplicol/tests/release/test_eager_portability.py
new file mode 100644
index 0000000000..23d149a35a
--- /dev/null
+++ b/pyamplicol/tests/release/test_eager_portability.py
@@ -0,0 +1,1164 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import io
+import json
+import os
+import subprocess
+import sys
+import zipfile
+from collections.abc import Callable
+from dataclasses import asdict
+from pathlib import Path
+
+import pytest
+
+from tools.ci import eager_portability as portability
+from tools.ci.eager_portability_contract import symjit_storage_v3_target
+
+ROOT = Path(__file__).resolve().parents[2]
+# The workflow lives in the MadGraph7 repository that contains pyamplicol/.
+WORKFLOW = ROOT.parent / ".github" / "workflows" / "pyamplicol-eager-portability.yml"
+requires_workflow = pytest.mark.skipif(
+    not WORKFLOW.is_file(), reason="outside the MadGraph7 repository"
+)
+
+
+@pytest.fixture
+def contracts() -> portability.RuntimeContracts:
+    return portability.RuntimeContracts(
+        bundle_kind="pyamplicol-prepared-model",
+        bundle_schema_version=1,
+        eager_kernel_abi="pyamplicol-eager-kernel-v1",
+        compiled_model_schema_version=9,
+        symbolica_serialization_abi="symbolica-bincode2-v1",
+        symjit_application_abi="symjit-application-storage-v3",
+        symjit_plane_application_abi="pyamplicol-symjit-plane-application-v2",
+        symjit_runtime_capability="symjit.application.complex-f64.v1",
+        eager_runtime_capability="rusticol.eager-runtime-layout.complex-f64.v1",
+        package_version="0.1.0.dev0+candidate.portability",
+    )
+
+
+def _sha256(payload: bytes) -> str:
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _write_bundle(
+    path: Path,
+    contracts: portability.RuntimeContracts,
+    *,
+    architecture: str = "x86_64",
+    model: str = "built-in-sm",
+    mutate: Callable[[dict[str, object], dict[str, bytes]], None] | None = None,
+) -> Path:
+    application_path = "kernels/000000/application-0.symjit"
+    plane_application_path = "kernels/000000/application-0.plane.symjit"
+    state_path = "kernels/000000/evaluator-state-0.evaluator.bin"
+    model_path = "model/model.pyAmplicol-model.json"
+    payloads = {
+        application_path: b"portable-symjit-storage-v3-fixture\x00\x01",
+        plane_application_path: b"portable-symjit-plane-storage-v3-fixture\x00\x03",
+        state_path: b"architecture-neutral-symbolica-state-fixture\x00\x02",
+        model_path: json.dumps(
+            {
+                "schema_version": contracts.compiled_model_schema_version,
+                "source": {"kind": model},
+            },
+            sort_keys=True,
+        ).encode("utf-8"),
+    }
+    f64_manifest: dict[str, object] = {
+        "application_abi": contracts.symjit_application_abi,
+        "application_path": application_path,
+        "backend": "jit",
+        "batch_layout": "row-major",
+        "compiler_type": "native",
+        "element_layout": "complex-f64",
+        "endianness": "little",
+        "evaluator_state_path": state_path,
+        "input_len": 1,
+        "kind": "symjit-application-evaluator",
+        "optimization_level": 2,
+        "output_len": 1,
+        "plane_application": {
+            "application_abi": contracts.symjit_plane_application_abi,
+            "application_path": plane_application_path,
+            "complex": True,
+            "compression": False,
+            "compiler_type": "native",
+            "descriptor_order": "inputs-re-im-then-outputs-re-im",
+            "direct_arena": True,
+            "element_layout": "split-complex-plane-major",
+            "fast_complex": False,
+            "fast_math": True,
+            "input_complex_count": 1,
+            "input_plane_count": 2,
+            "optimization_level": 2,
+            "output_complex_count": 1,
+            "output_plane_count": 2,
+            "simd": True,
+            "source_digest": _sha256(b"synthetic structured instructions"),
+            "storage_abi": contracts.symjit_application_abi,
+            "target": {
+                "endianness": "little",
+                "word_bits": 64,
+            },
+            "threading": False,
+            "translation_mode": "symbolica-structured-instructions",
+        },
+        "required_defuns": [],
+        "runtime_capability": contracts.symjit_runtime_capability,
+        "settings": {
+            "backend": "jit",
+            "compiled_inline_asm": "none",
+            "compiled_native": False,
+            "compiler_path": None,
+            "effective_compiler_flags": [],
+            "jit_optimization_level": 2,
+        },
+        "translation_mode": "indirect",
+        "word_bits": 64,
+    }
+    manifest: dict[str, object] = {
+        "eager_kernel_abi": contracts.eager_kernel_abi,
+        "kernel_pack": {
+            "backend": "jit",
+            "dependency_abis": {
+                "symbolica_serialization": contracts.symbolica_serialization_abi,
+                "symjit_application": contracts.symjit_application_abi,
+                "symjit_plane_application": contracts.symjit_plane_application_abi,
+            },
+            "kernels": [
+                {
+                    "f64_evaluator_manifest": f64_manifest,
+                    "kernel_id": 0,
+                }
+            ],
+            "kernel_variants": [],
+            "optimization_settings": {
+                "backend": "jit",
+                "compiled_inline_asm": "none",
+                "compiled_native": False,
+                "compiler_path": None,
+                "effective_compiler_flags": [],
+                "jit_optimization_level": 2,
+            },
+            "producer": {
+                "compiled_model_schema": contracts.compiled_model_schema_version,
+                "distribution": "pyamplicol",
+                "model_compiler_version": 13,
+                "version": contracts.package_version,
+            },
+            "provenance": {
+                "compiled_model_digest": "a" * 64,
+                "model_name": model,
+                "model_source": {"kind": model},
+            },
+            "target": symjit_storage_v3_target(architecture),
+        },
+        "kind": contracts.bundle_kind,
+        "schema_version": contracts.bundle_schema_version,
+    }
+    if mutate is not None:
+        mutate(manifest, payloads)
+    manifest["members"] = [
+        {
+            "path": member,
+            "sha256": _sha256(payload),
+            "size": len(payload),
+        }
+        for member, payload in sorted(payloads.items())
+    ]
+
+    with zipfile.ZipFile(path, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+        for member, payload in {
+            "manifest.json": json.dumps(manifest, sort_keys=True).encode("utf-8"),
+            **payloads,
+        }.items():
+            info = zipfile.ZipInfo(member, date_time=(1980, 1, 1, 0, 0, 0))
+            info.external_attr = 0o100644 << 16
+            archive.writestr(info, payload)
+    return path
+
+
+def _write_transfer_fixture(
+    directory: Path,
+    contracts: portability.RuntimeContracts,
+    *,
+    architecture: str,
+) -> Path:
+    directory.mkdir()
+    bundle = _write_bundle(
+        directory / portability.DEFAULT_BUNDLE_NAME,
+        contracts,
+        architecture=architecture,
+    )
+    fixture = {
+        "bundle": {
+            "architecture_class": "portable",
+            "bundle_sha256": portability._sha256_file(bundle),
+            "filename": bundle.name,
+            "preflight_evaluator_count": 1,
+        },
+        "expected": {
+            "atol": portability.DEFAULT_ATOL,
+            "imaginary": 0.0,
+            "real": 1.0,
+            "rtol": portability.DEFAULT_RTOL,
+        },
+        "kind": portability.TRANSFER_KIND,
+        "process": {
+            "expression": portability.DEFAULT_PROCESS,
+            "id": portability.DEFAULT_PROCESS_ID,
+            "momenta": [],
+        },
+        "producer": {
+            "architecture_class": architecture,
+            "git_commit": "fixture-commit",
+            "machine": "x86_64" if architecture == "x86_64" else "arm64",
+            "system": "Linux",
+        },
+        "schema_version": portability.TRANSFER_SCHEMA_VERSION,
+    }
+    (directory / portability.DEFAULT_FIXTURE_NAME).write_text(
+        json.dumps(fixture),
+        encoding="utf-8",
+    )
+    return directory
+
+
+def _write_packed_consumer_artifact(
+    artifact: Path,
+    bundle: Path,
+    contracts: portability.RuntimeContracts,
+    *,
+    include_plane_payload: bool = True,
+    plane_payload_override: bytes | None = None,
+) -> Path:
+    from pyamplicol.generation.evaluator_container import (
+        PacbinMemberKind,
+        PacbinMemberSource,
+        write_pacbin_atomic,
+    )
+
+    artifact.mkdir()
+    bundle_manifest, bundle_payloads = portability._archive_manifest(bundle)
+    kernel_pack = bundle_manifest["kernel_pack"]
+    assert isinstance(kernel_pack, dict)
+    kernels = kernel_pack["kernels"]
+    assert isinstance(kernels, list) and len(kernels) == 1
+    kernel = kernels[0]
+    assert isinstance(kernel, dict)
+    f64 = kernel["f64_evaluator_manifest"]
+    assert isinstance(f64, dict)
+
+    filtered_pack = dict(kernel_pack)
+    filtered_pack["kernels"] = [kernel]
+    filtered_pack["kernel_variants"] = []
+    pack_path = artifact / "model" / "eager-kernel-pack.json"
+    pack_path.parent.mkdir(parents=True)
+    pack_path.write_text(json.dumps(filtered_pack), encoding="utf-8")
+
+    execution_path = (
+        artifact / "processes" / portability.DEFAULT_PROCESS_ID / "execution.json"
+    )
+    execution_path.parent.mkdir(parents=True)
+    execution_path.write_text(
+        json.dumps({"kind": "pyamplicol-runtime-eager-execution"}),
+        encoding="utf-8",
+    )
+
+    plane = f64["plane_application"]
+    assert isinstance(plane, dict)
+    packed_payloads: list[tuple[str, PacbinMemberKind, bytes | None]] = [
+        (
+            str(f64["application_path"]),
+            PacbinMemberKind.SYMJIT_APPLICATION,
+            None,
+        ),
+        (
+            str(f64["evaluator_state_path"]),
+            PacbinMemberKind.SYMBOLICA_EXACT_STATE,
+            None,
+        ),
+    ]
+    if include_plane_payload:
+        packed_payloads.append(
+            (
+                str(plane["application_path"]),
+                PacbinMemberKind.SYMJIT_APPLICATION,
+                plane_payload_override,
+            )
+        )
+    packed_sources = []
+    for source_path, kind, override in packed_payloads:
+        packed_sources.append(
+            PacbinMemberSource(
+                f"model/eager-kernels/{source_path}",
+                kind,
+                io.BytesIO(
+                    bundle_payloads[source_path] if override is None else override
+                ),
+            )
+        )
+    container_path = artifact / "evaluators.pacbin"
+    container_index = write_pacbin_atomic(container_path, packed_sources)
+
+    payload_paths = (
+        "evaluators.pacbin",
+        "model/eager-kernel-pack.json",
+        f"processes/{portability.DEFAULT_PROCESS_ID}/execution.json",
+    )
+    payloads = []
+    for relative in payload_paths:
+        path = artifact / relative
+        payloads.append(
+            {
+                "executable": False,
+                "path": relative,
+                "sha256": portability._sha256_file(path),
+                "size_bytes": path.stat().st_size,
+            }
+        )
+    manifest = {
+        "artifact_id": "packed-portability-fixture",
+        "extensions": {
+            "eager_prepared_pack": {
+                "backend": "jit",
+                "eager_kernel_abi": contracts.eager_kernel_abi,
+                "kernel_count": 1,
+            },
+            "evaluator_payload_container": {
+                "index_sha256": container_index.index_sha256,
+                "member_count": len(container_index.members),
+                "path": "evaluators.pacbin",
+                "storage_abi": "pacbin-v1",
+            },
+        },
+        "kind": "pyamplicol-process",
+        "payloads": payloads,
+        "processes": [
+            {
+                "expression": portability.DEFAULT_PROCESS,
+                "id": portability.DEFAULT_PROCESS_ID,
+                "required_runtime_capabilities": [contracts.eager_runtime_capability],
+            }
+        ],
+        "producer": {"version": contracts.package_version},
+        "schema_version": 3,
+    }
+    (artifact / "artifact.json").write_text(
+        json.dumps(manifest),
+        encoding="utf-8",
+    )
+    return artifact
+
+
+@pytest.mark.parametrize("architecture", ("x86_64", "aarch64"))
+def test_architecture_jit_bundle_audit_accepts_portable_storage_v3_pack(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+    architecture: str,
+) -> None:
+    bundle = _write_bundle(
+        tmp_path / "model.pyamplicol-model",
+        contracts,
+        architecture=architecture,
+    )
+
+    result = portability.audit_architecture_jit_bundle(
+        bundle,
+        contracts=contracts,
+        expected_sha256=portability._sha256_file(bundle),
+        expected_architecture_class=architecture,
+    )
+
+    assert result["backend"] == "jit"
+    assert result["kernel_count"] == 1
+    assert result["symjit_application_count"] == 1
+    assert result["symjit_plane_application_count"] == 1
+    assert result["exact_state_count"] == 1
+    assert result["architecture_class"] == "portable"
+    assert result["target"] == symjit_storage_v3_target(architecture)
+
+
+def test_architecture_jit_bundle_audit_accepts_explicit_heft_model(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+) -> None:
+    bundle = _write_bundle(
+        tmp_path / "heft.pyamplicol-model",
+        contracts,
+        model="built-in-sm-heft",
+    )
+
+    result = portability.audit_architecture_jit_bundle(
+        bundle,
+        contracts=contracts,
+        expected_model_source="built-in-sm-heft",
+    )
+
+    assert result["kernel_count"] == 1
+
+
+def test_architecture_jit_bundle_audit_rejects_wrong_storage_abi(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+) -> None:
+    def mutate(manifest: dict[str, object], _payloads: dict[str, bytes]) -> None:
+        pack = manifest["kernel_pack"]
+        assert isinstance(pack, dict)
+        dependencies = pack["dependency_abis"]
+        assert isinstance(dependencies, dict)
+        dependencies["symjit_application"] = "symjit-application-storage-v999"
+
+    bundle = _write_bundle(
+        tmp_path / "wrong-abi.pyamplicol-model",
+        contracts,
+        mutate=mutate,
+    )
+
+    with pytest.raises(
+        portability.PortabilityError,
+        match="application storage ABI mismatch",
+    ):
+        portability.audit_architecture_jit_bundle(bundle, contracts=contracts)
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("application_abi", "pyamplicol-symjit-plane-application-v999"),
+        ("storage_abi", "symjit-application-storage-v999"),
+    ),
+)
+def test_architecture_jit_bundle_audit_rejects_wrong_plane_application_abi(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+    field: str,
+    value: str,
+) -> None:
+    def mutate(manifest: dict[str, object], _payloads: dict[str, bytes]) -> None:
+        pack = manifest["kernel_pack"]
+        assert isinstance(pack, dict)
+        kernels = pack["kernels"]
+        assert isinstance(kernels, list)
+        kernel = kernels[0]
+        assert isinstance(kernel, dict)
+        f64 = kernel["f64_evaluator_manifest"]
+        assert isinstance(f64, dict)
+        plane = f64["plane_application"]
+        assert isinstance(plane, dict)
+        plane[field] = value
+
+    bundle = _write_bundle(
+        tmp_path / "wrong-plane-abi.pyamplicol-model",
+        contracts,
+        mutate=mutate,
+    )
+
+    with pytest.raises(
+        portability.PortabilityError,
+        match=rf"incompatible plane-application {field!r}",
+    ):
+        portability.audit_architecture_jit_bundle(bundle, contracts=contracts)
+
+
+def test_architecture_jit_bundle_audit_rejects_missing_plane_payload(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+) -> None:
+    def mutate(_manifest: dict[str, object], payloads: dict[str, bytes]) -> None:
+        payloads.pop("kernels/000000/application-0.plane.symjit")
+
+    bundle = _write_bundle(
+        tmp_path / "missing-plane.pyamplicol-model",
+        contracts,
+        mutate=mutate,
+    )
+
+    with pytest.raises(
+        portability.PortabilityError,
+        match="omits referenced plane-application payload",
+    ):
+        portability.audit_architecture_jit_bundle(bundle, contracts=contracts)
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("input_plane_count", 1),
+        ("output_plane_count", 3),
+        ("descriptor_order", "outputs-then-inputs"),
+        ("direct_arena", False),
+        ("optimization_level", 3),
+    ),
+)
+def test_architecture_jit_bundle_audit_rejects_wrong_plane_descriptor_contract(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+    field: str,
+    value: object,
+) -> None:
+    def mutate(manifest: dict[str, object], _payloads: dict[str, bytes]) -> None:
+        pack = manifest["kernel_pack"]
+        assert isinstance(pack, dict)
+        kernels = pack["kernels"]
+        assert isinstance(kernels, list)
+        kernel = kernels[0]
+        assert isinstance(kernel, dict)
+        f64 = kernel["f64_evaluator_manifest"]
+        assert isinstance(f64, dict)
+        plane = f64["plane_application"]
+        assert isinstance(plane, dict)
+        plane[field] = value
+
+    bundle = _write_bundle(
+        tmp_path / "wrong-plane-descriptor.pyamplicol-model",
+        contracts,
+        mutate=mutate,
+    )
+
+    with pytest.raises(
+        portability.PortabilityError,
+        match=rf"incompatible plane-application {field!r}",
+    ):
+        portability.audit_architecture_jit_bundle(bundle, contracts=contracts)
+
+
+@pytest.mark.parametrize(
+    ("payload", "message"),
+    (
+        (b"\x7fELF" + b"\0" * 64, "contains ELF image"),
+        (b"!<arch>\n" + b"\0" * 64, "contains static archive"),
+        (b"\xcf\xfa\xed\xfe" + b"\0" * 64, "contains Mach-O image"),
+    ),
+)
+def test_architecture_jit_bundle_audit_rejects_native_machine_code(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+    payload: bytes,
+    message: str,
+) -> None:
+    def mutate(_manifest: dict[str, object], payloads: dict[str, bytes]) -> None:
+        payloads["kernels/000000/application-0.symjit"] = payload
+
+    bundle = _write_bundle(
+        tmp_path / "native.pyamplicol-model",
+        contracts,
+        mutate=mutate,
+    )
+
+    with pytest.raises(portability.PortabilityError, match=message):
+        portability.audit_architecture_jit_bundle(bundle, contracts=contracts)
+
+
+@pytest.mark.parametrize(
+    ("member", "payload"),
+    (
+        ("kernels/000000/generated.cpp", b"double kernel(double x);\n"),
+        ("kernels/000000/generated.asm", b"section .text\n"),
+        ("kernels/000000/kernel.o", b"opaque native object fixture"),
+    ),
+)
+def test_architecture_jit_bundle_audit_rejects_native_source_or_object_payload(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+    member: str,
+    payload: bytes,
+) -> None:
+    def mutate(_manifest: dict[str, object], payloads: dict[str, bytes]) -> None:
+        payloads[member] = payload
+
+    bundle = _write_bundle(
+        tmp_path / "native-source.pyamplicol-model",
+        contracts,
+        mutate=mutate,
+    )
+
+    with pytest.raises(
+        portability.PortabilityError,
+        match="native/source payload",
+    ):
+        portability.audit_architecture_jit_bundle(bundle, contracts=contracts)
+
+
+def test_architecture_jit_bundle_audit_rejects_legacy_target_spelling(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+) -> None:
+    def mutate(manifest: dict[str, object], _payloads: dict[str, bytes]) -> None:
+        pack = manifest["kernel_pack"]
+        assert isinstance(pack, dict)
+        target = pack["target"]
+        assert isinstance(target, dict)
+        target["portable"] = True
+        target["target_triple"] = "portable-symjit-mir"
+
+    bundle = _write_bundle(
+        tmp_path / "falsely-portable.pyamplicol-model",
+        contracts,
+        mutate=mutate,
+    )
+
+    with pytest.raises(
+        portability.PortabilityError,
+        match="must be portable 64-bit little-endian",
+    ):
+        portability.audit_architecture_jit_bundle(bundle, contracts=contracts)
+
+
+def test_architecture_jit_bundle_audit_accepts_cross_architecture_load(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+) -> None:
+    bundle = _write_bundle(
+        tmp_path / "x86-pack.pyamplicol-model",
+        contracts,
+        architecture="x86_64",
+    )
+
+    result = portability.audit_architecture_jit_bundle(
+        bundle,
+        contracts=contracts,
+        expected_architecture_class="aarch64",
+    )
+
+    assert result["architecture_class"] == "portable"
+    assert result["target"] == symjit_storage_v3_target("aarch64")
+
+
+@pytest.mark.parametrize(
+    ("machine", "expected"),
+    (("AMD64", "x86_64"), ("x86_64", "x86_64"), ("arm64", "aarch64")),
+)
+def test_machine_names_normalize_to_storage_v3_architecture_classes(
+    machine: str,
+    expected: str,
+) -> None:
+    assert portability.architecture_class(machine) == expected
+
+
+def test_consumer_generation_command_uses_eager_pack_without_model_compile(
+    tmp_path: Path,
+) -> None:
+    command = portability._generation_command(
+        Path("/python"),
+        model=tmp_path / "transferred.pyamplicol-model",
+        output=tmp_path / "artifact",
+        execution_mode="eager",
+    )
+
+    assert command[:4] == ["/python", "-m", "pyamplicol", "generate"]
+    assert "compile" not in command
+    assert command[command.index("--execution-mode") + 1] == "eager"
+    assert command[command.index("--model") + 1].endswith(
+        "transferred.pyamplicol-model"
+    )
+    assert "--no-post-build-validation" in command
+    assert "--no-emit-api-bundle" in command
+
+
+def test_consumer_verifier_accepts_byte_identical_packed_kernel_payloads(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+) -> None:
+    bundle = _write_bundle(tmp_path / "model.pyamplicol-model", contracts)
+    artifact = _write_packed_consumer_artifact(
+        tmp_path / "artifact",
+        bundle,
+        contracts,
+    )
+
+    result = portability.verify_consumer_artifact(
+        artifact,
+        bundle,
+        contracts=contracts,
+        bundle_audit={"kernel_count": 1},
+    )
+
+    assert result["copied_kernel_payload_count"] == 3
+    assert result["filtered_kernel_count"] == 1
+    assert result["filtered_kernel_variant_count"] == 0
+
+
+def test_consumer_verifier_rejects_missing_packed_plane_payload(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+) -> None:
+    bundle = _write_bundle(tmp_path / "model.pyamplicol-model", contracts)
+    artifact = _write_packed_consumer_artifact(
+        tmp_path / "artifact",
+        bundle,
+        contracts,
+        include_plane_payload=False,
+    )
+
+    with pytest.raises(
+        portability.PortabilityError,
+        match=r"omitted transferred kernel payload.*plane\.symjit",
+    ):
+        portability.verify_consumer_artifact(
+            artifact,
+            bundle,
+            contracts=contracts,
+            bundle_audit={"kernel_count": 1},
+        )
+
+
+def test_consumer_verifier_rejects_changed_packed_plane_payload(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+) -> None:
+    bundle = _write_bundle(tmp_path / "model.pyamplicol-model", contracts)
+    artifact = _write_packed_consumer_artifact(
+        tmp_path / "artifact",
+        bundle,
+        contracts,
+        plane_payload_override=b"changed-plane-application",
+    )
+
+    with pytest.raises(
+        portability.PortabilityError,
+        match=r"rebuilt or changed kernel payload.*plane\.symjit",
+    ):
+        portability.verify_consumer_artifact(
+            artifact,
+            bundle,
+            contracts=contracts,
+            bundle_audit={"kernel_count": 1},
+        )
+
+
+def test_python_executable_preserves_virtual_environment_symlink(
+    tmp_path: Path,
+) -> None:
+    launcher = tmp_path / "python"
+    launcher.symlink_to(Path(sys.executable))
+
+    result = portability._python_executable(launcher)
+
+    assert result == launcher.absolute()
+    assert result.is_symlink()
+
+
+def test_runtime_contracts_do_not_initialize_the_driver_runtime(
+    contracts: portability.RuntimeContracts,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def child(command, **kwargs):
+        assert command[:2] == [sys.executable, "-c"]
+        assert "_runtime_contracts_in_process()" in command[2]
+        assert kwargs["check"] and kwargs["capture_output"]
+        return subprocess.CompletedProcess(command, 0, json.dumps(asdict(contracts)))
+
+    monkeypatch.setattr(portability.subprocess, "run", child)
+    monkeypatch.setattr(
+        portability,
+        "_runtime_contracts_in_process",
+        lambda: pytest.fail("parent must not initialize Symbolica before CLI children"),
+    )
+
+    assert portability._runtime_contracts() == contracts
+
+
+def test_producer_finishes_all_cli_children_before_native_parent_work(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    children: list[list[str]] = []
+    native_work: list[str] = []
+    monkeypatch.setattr(portability.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(portability.platform, "machine", lambda: "x86_64")
+    monkeypatch.setattr(portability, "_runtime_contracts", lambda: contracts)
+    monkeypatch.setattr(portability, "_git_commit", lambda: "fixture-commit")
+    monkeypatch.setattr(portability, "_validation_momenta", lambda _artifact: [])
+
+    def child(command, **_kwargs):
+        assert not native_work, "CLI child overlaps a parent Symbolica runtime"
+        children.append(command)
+        if command[3:5] == ["model", "compile"]:
+            _write_bundle(Path(command[6]), contracts, model=command[5])
+
+    def preflight(_bundle):
+        assert len(children) == 4
+        native_work.append("preflight")
+        return 1
+
+    def write_asset(bundle, output, *, identifier="built-in-sm-jit-o2", **_kwargs):
+        assert len(children) == 4
+        native_work.append("write")
+        output.mkdir(parents=True, exist_ok=True)
+        retained = output / f"{identifier}.pyamplicol-model"
+        retained.write_bytes(bundle.read_bytes())
+        return output / f"{identifier}.metadata.json", retained
+
+    def evaluate(_artifact, _momenta):
+        assert len(children) == 4
+        native_work.append("evaluate")
+        return 1 + 0j
+
+    monkeypatch.setattr(portability, "_run", child)
+    monkeypatch.setattr(portability, "_preflight_all_prepared_applications", preflight)
+    monkeypatch.setattr(portability, "_write_source_ready_asset", write_asset)
+    monkeypatch.setattr(portability, "_evaluate_artifact", evaluate)
+
+    report = portability.produce_transfer(
+        tmp_path / "transfer",
+        python=Path(sys.executable),
+        expected_system="Linux",
+        expected_machine="x86_64",
+        asset_mode="release",
+    )
+
+    assert [command[3] for command in children] == [
+        "model", "model", "generate", "generate"
+    ]
+    assert native_work == [
+        "preflight", "write", "preflight", "write", "evaluate", "evaluate"
+    ]
+    assert report["expected"] == {"real": 1.0, "imaginary": 0.0}
+
+
+def test_producer_rejects_an_unexpected_architecture_before_building(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(portability.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(portability.platform, "machine", lambda: "aarch64")
+
+    with pytest.raises(
+        portability.PortabilityError,
+        match=r"producer architecture class.*expected 'x86_64'",
+    ):
+        portability.produce_transfer(
+            tmp_path / "transfer",
+            python=Path(sys.executable),
+            expected_system="Linux",
+            expected_machine="x86_64",
+        )
+
+    assert not (tmp_path / "transfer").exists()
+
+
+def test_producer_cli_accepts_explicit_release_asset_mode(tmp_path: Path) -> None:
+    arguments = portability._parser().parse_args(
+        [
+            "produce",
+            str(tmp_path / "transfer"),
+            "--asset-mode",
+            "release",
+        ]
+    )
+
+    assert arguments.asset_mode == "release"
+
+
+def test_release_asset_output_uses_source_only_store_layout(tmp_path: Path) -> None:
+    output = tmp_path / "transfer"
+
+    assert portability._source_ready_asset_directory(output, "candidate") == output
+    assert (
+        portability._source_ready_asset_directory(
+            output,
+            "release",
+        )
+        == output / "release_assets" / "prepared_models"
+    )
+    with pytest.raises(
+        portability.PortabilityError,
+        match="unsupported prepared-model asset mode",
+    ):
+        portability._source_ready_asset_directory(output, "mixed")
+
+
+def test_transfer_bundle_member_accepts_only_root_or_release_store() -> None:
+    assert portability._transfer_bundle_member("built-in-sm.pyamplicol-model") == Path(
+        "built-in-sm.pyamplicol-model"
+    )
+    assert portability._transfer_bundle_member(
+        "release_assets/prepared_models/built-in-sm.pyamplicol-model"
+    ) == Path("release_assets/prepared_models/built-in-sm.pyamplicol-model")
+    for value in (
+        "nested/built-in-sm.pyamplicol-model",
+        "release_assets/built-in-sm.pyamplicol-model",
+        "release_assets/prepared_models/nested/built-in-sm.pyamplicol-model",
+    ):
+        with pytest.raises(
+            portability.PortabilityError,
+            match="exact release prepared-model source store",
+        ):
+            portability._transfer_bundle_member(value)
+
+
+def test_release_asset_dispatch_reaches_real_writer(tmp_path: Path) -> None:
+    bundle = tmp_path / "invalid.pyamplicol-model"
+    bundle.write_bytes(b"not a prepared-model bundle")
+
+    with pytest.raises(RuntimeError, match="prepared-model bundle is invalid"):
+        portability._write_source_ready_asset(
+            bundle,
+            tmp_path / "output",
+            architecture="x86_64",
+            asset_mode="release",
+        )
+
+
+def test_consumer_accepts_portable_pack_across_architectures(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    transfer = _write_transfer_fixture(
+        tmp_path / "transfer",
+        contracts,
+        architecture="x86_64",
+    )
+    monkeypatch.setattr(portability.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(portability.platform, "machine", lambda: "arm64")
+    monkeypatch.setattr(portability, "_runtime_contracts", lambda: contracts)
+    monkeypatch.setattr(portability, "_git_commit", lambda: "fixture-commit")
+    monkeypatch.setattr(
+        portability,
+        "_preflight_all_prepared_applications",
+        lambda _bundle: 1,
+    )
+
+    class GenerationStarted(RuntimeError):
+        pass
+
+    def stop_at_generation(*_args: object, **_kwargs: object) -> None:
+        raise GenerationStarted
+
+    monkeypatch.setattr(portability, "_run", stop_at_generation)
+
+    with pytest.raises(GenerationStarted):
+        portability.consume_transfer(
+            transfer,
+            python=Path(sys.executable),
+            report_path=tmp_path / "report.json",
+            expected_system="Darwin",
+            expected_machine="arm64",
+        )
+
+
+def test_consumer_rejects_inconsistent_producer_host_provenance(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    transfer = _write_transfer_fixture(
+        tmp_path / "transfer",
+        contracts,
+        architecture="x86_64",
+    )
+    fixture_path = transfer / portability.DEFAULT_FIXTURE_NAME
+    fixture = json.loads(fixture_path.read_text(encoding="utf-8"))
+    fixture["producer"]["machine"] = "arm64"
+    fixture_path.write_text(json.dumps(fixture), encoding="utf-8")
+    monkeypatch.setattr(portability.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(portability.platform, "machine", lambda: "x86_64")
+    monkeypatch.setattr(portability, "_runtime_contracts", lambda: contracts)
+    monkeypatch.setattr(
+        portability,
+        "_preflight_all_prepared_applications",
+        lambda _bundle: 1,
+    )
+
+    with pytest.raises(
+        portability.PortabilityError,
+        match="machine and architecture-class provenance differ",
+    ):
+        portability.consume_transfer(
+            transfer,
+            python=Path(sys.executable),
+            report_path=tmp_path / "report.json",
+            expected_system="Linux",
+            expected_machine="x86_64",
+        )
+
+
+def test_consumer_accepts_same_architecture_pack_across_operating_systems(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    transfer = _write_transfer_fixture(
+        tmp_path / "transfer",
+        contracts,
+        architecture="x86_64",
+    )
+    monkeypatch.setattr(portability.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(portability.platform, "machine", lambda: "x86_64")
+    monkeypatch.setattr(portability, "_runtime_contracts", lambda: contracts)
+    monkeypatch.setattr(portability, "_git_commit", lambda: "fixture-commit")
+    monkeypatch.setattr(
+        portability,
+        "_preflight_all_prepared_applications",
+        lambda _bundle: 1,
+    )
+
+    class GenerationStarted(RuntimeError):
+        pass
+
+    def stop_at_generation(*_args: object, **_kwargs: object) -> None:
+        raise GenerationStarted
+
+    monkeypatch.setattr(portability, "_run", stop_at_generation)
+
+    with pytest.raises(GenerationStarted):
+        portability.consume_transfer(
+            transfer,
+            python=Path(sys.executable),
+            report_path=tmp_path / "report.json",
+            expected_system="Darwin",
+            expected_machine="AMD64",
+        )
+
+
+def test_consumer_finishes_generation_before_native_parent_work(
+    tmp_path: Path,
+    contracts: portability.RuntimeContracts,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    transfer = _write_transfer_fixture(
+        tmp_path / "transfer", contracts, architecture="x86_64"
+    )
+    events: list[str] = []
+    monkeypatch.setattr(portability.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(portability.platform, "machine", lambda: "x86_64")
+    monkeypatch.setattr(portability, "_runtime_contracts", lambda: contracts)
+    monkeypatch.setattr(portability, "_git_commit", lambda: "fixture-commit")
+
+    def child(*_args, **_kwargs):
+        assert not events, "CLI child overlaps a parent Symbolica runtime"
+        events.append("generation")
+
+    def preflight(_bundle):
+        assert events == ["generation"]
+        events.append("preflight")
+        return 1
+
+    def verify(*_args, **_kwargs):
+        events.append("verify")
+        return {}
+
+    def evaluate(*_args):
+        events.append("evaluate")
+        return 1 + 0j
+
+    monkeypatch.setattr(portability, "_run", child)
+    monkeypatch.setattr(portability, "_preflight_all_prepared_applications", preflight)
+    monkeypatch.setattr(portability, "verify_consumer_artifact", verify)
+    monkeypatch.setattr(portability, "_evaluate_artifact", evaluate)
+
+    portability.consume_transfer(
+        transfer,
+        python=Path(sys.executable),
+        report_path=tmp_path / "report.json",
+        expected_system="Linux",
+        expected_machine="x86_64",
+    )
+
+    assert events == ["generation", "preflight", "verify", "evaluate"]
+
+
+def test_compiler_guard_records_and_denies_external_tool_execution() -> None:
+    with portability.compiler_guard() as (environment, marker):
+        completed = subprocess.run(
+            ["c++", "--version"],
+            check=False,
+            capture_output=True,
+            env=environment,
+        )
+        assert completed.returncode == 97
+        assert marker.read_text(encoding="utf-8").strip().endswith("c++ --version")
+
+
+@requires_workflow
+def test_portability_workflow_transfers_portable_packs() -> None:
+    workflow = WORKFLOW.read_text(encoding="utf-8")
+    trigger = workflow.split("on:\n", maxsplit=1)[1].split(
+        "\npermissions:\n", maxsplit=1
+    )[0]
+
+    assert "pull_request:" in trigger
+    assert "push:" in trigger
+    assert "workflow_dispatch:" in trigger
+    assert "rust/crates/rusticol-core/src/eager_runtime/**" in trigger
+    assert "rust/crates/rusticol-core/src/engine/**" in trigger
+    assert "rust/crates/rusticol-core/src/evaluator/symjit.rs" in trigger
+    for adapter in (
+        "symjit_plane.rs",
+        "symjit_direct.rs",
+        "symjit_eager_direct.rs",
+        "symjit_compiled_direct.rs",
+    ):
+        assert workflow.count(f"rust/crates/rusticol-core/src/evaluator/{adapter}") == 2
+    assert "dependencies/release-lock.toml" in trigger
+    assert "src/pyamplicol/evaluators/symbolica*.py" in trigger
+    assert workflow.count("eager_portability.py produce") == 1
+    assert workflow.count("eager_portability.py consume") == 1
+    assert workflow.count("pyamplicol-eager-jit-transfer-${{") == 2
+    assert "needs: produce-architecture-packs" in workflow
+    assert "ubuntu-24.04" in workflow
+    assert "macos-15-intel" in workflow
+    assert "macos-15" in workflow
+    assert "target: linux-x86-64" in workflow
+    assert "target: macos-x86-64" in workflow
+    assert "target: macos-arm64" in workflow
+    assert workflow.count("pack_architecture: x86_64") == 3
+    assert workflow.count("pack_architecture: aarch64") == 2
+    assert (
+        "target: macos-x86-64\n"
+        "            system: Darwin\n"
+        "            machine: x86_64\n"
+        "            pack_architecture: x86_64"
+    ) in workflow
+    assert (
+        "target: macos-arm64\n"
+        "            system: Darwin\n"
+        "            machine: arm64\n"
+        "            pack_architecture: aarch64"
+    ) in workflow
+    assert "--expected-system ${{ matrix.system }}" in workflow
+    assert "--expected-machine ${{ matrix.machine }}" in workflow
+    assert workflow.count("tools/ci/memory_watchdog.py --limit-gib 30 --") == 4
+    assert "dependencies/install_dependencies.py" not in workflow
+    assert workflow.count("prepare_release_prepared_models.py") == 2
+    assert workflow.count("bootstrap-wheel .artifacts/release-prepared-bootstrap") == 2
+    assert workflow.count("python -m venv .venv") == 2
+    assert workflow.count("--asset-mode release") == 1
+    assert "--with-legacy-amplicol" not in workflow
+    assert "--with-reference-fft" not in workflow
+    assert "--without-legacy-amplicol" not in workflow
+    assert "--without-reference-fft" not in workflow
+    assert "contents: read" in workflow
+    assert "continue-on-error" not in workflow
+    assert "publish-pypi" not in workflow
+    assert "gh-action-pypi-publish" not in workflow
+    assert workflow.count("PYAMPLICOL_BUILD_MODE: release") == 2
+    assert "PYAMPLICOL_BUILD_MODE: candidate" not in workflow
+    assert "PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP" not in workflow
+    assert "dependencies/candidate-Cargo.lock" not in workflow
+    assert workflow.count("      - pyamplicol/dependencies/release-lock.toml\n") == 2
+    assert (
+        "actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0" in workflow
+    )
+    assert (
+        "actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02" in workflow
+    )
+
+
+@requires_workflow
+def test_portability_workflow_does_not_expose_credentials() -> None:
+    workflow = WORKFLOW.read_text(encoding="utf-8")
+
+    assert "persist-credentials: false" in workflow
+    assert "id-token: write" not in workflow
+    assert "PYPI" not in workflow
+    assert "secrets." not in workflow
+    assert os.fspath(ROOT) not in workflow
diff --git a/pyamplicol/tests/release/test_release_prepared_models.py b/pyamplicol/tests/release/test_release_prepared_models.py
new file mode 100644
index 0000000000..af8c49aa91
--- /dev/null
+++ b/pyamplicol/tests/release/test_release_prepared_models.py
@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from tools.release import prepare_release_prepared_models as producer
+
+RELEASE_VERSION = producer.EXPECTED_VERSION
+
+
+def _bootstrap_wheel(
+    path: Path,
+    *,
+    publishable: bool = False,
+    include_prepared_payload: bool = False,
+    include_release_store: bool = False,
+    include_selftest_fixture: bool = False,
+) -> Path:
+    marker = {
+        "candidate_fingerprint": None,
+        "native_build_inputs_sha256": "b" * 64,
+        "publishable": publishable,
+        "release_prepared_model_bootstrap": True,
+        "schema_version": 1,
+        "selftest_fixture_bootstrap": True,
+        "source_checkout": str(producer.ROOT.resolve()),
+        "version": RELEASE_VERSION,
+    }
+    metadata = (
+        f"Metadata-Version: 2.4\nName: pyamplicol\nVersion: {RELEASE_VERSION}\n\n"
+    ).encode()
+    members = {
+        "pyamplicol/_build_info.json": (
+            json.dumps(marker, sort_keys=True) + "\n"
+        ).encode(),
+        "pyamplicol/assets/prepared_models/__init__.py": b"",
+        f"pyamplicol-{RELEASE_VERSION}.dist-info/METADATA": metadata,
+    }
+    if include_prepared_payload:
+        members[
+            "pyamplicol/assets/prepared_models/built-in-sm-jit-o2-x86_64.metadata.json"
+        ] = b"{}\n"
+    if include_release_store:
+        members[
+            "release_assets/prepared_models/built-in-sm-jit-o2-x86_64.metadata.json"
+        ] = b"{}\n"
+    if include_selftest_fixture:
+        members["pyamplicol/assets/selftest/portable-64le/expected.json"] = b"{}\n"
+    with zipfile.ZipFile(path, "w") as archive:
+        for name, payload in members.items():
+            archive.writestr(name, payload)
+    return path
+
+
+def test_release_bootstrap_wheel_is_explicitly_non_publishable(tmp_path: Path) -> None:
+    wheel = _bootstrap_wheel(tmp_path / f"pyamplicol-{RELEASE_VERSION}.whl")
+
+    result = producer.audit_bootstrap_wheel(wheel)
+
+    assert result["version"] == RELEASE_VERSION
+    assert result["publishable"] is False
+    assert result["release_prepared_model_bootstrap"] is True
+    assert result["selftest_fixture_bootstrap"] is True
+    assert result["candidate_fingerprint"] is None
+
+
+def test_release_bootstrap_wheel_rejects_publishable_marker(tmp_path: Path) -> None:
+    wheel = _bootstrap_wheel(
+        tmp_path / f"pyamplicol-{RELEASE_VERSION}.whl",
+        publishable=True,
+    )
+
+    with pytest.raises(
+        producer.ReleasePreparedModelError,
+        match="marker publishable is invalid",
+    ):
+        producer.audit_bootstrap_wheel(wheel)
+
+
+def test_release_bootstrap_wheel_rejects_prepared_payloads(tmp_path: Path) -> None:
+    wheel = _bootstrap_wheel(
+        tmp_path / f"pyamplicol-{RELEASE_VERSION}.whl",
+        include_prepared_payload=True,
+    )
+
+    with pytest.raises(
+        producer.ReleasePreparedModelError,
+        match="stale prepared-model payloads",
+    ):
+        producer.audit_bootstrap_wheel(wheel)
+
+
+def test_release_bootstrap_wheel_rejects_auxiliary_source_store(
+    tmp_path: Path,
+) -> None:
+    wheel = _bootstrap_wheel(
+        tmp_path / f"pyamplicol-{RELEASE_VERSION}.whl",
+        include_release_store=True,
+    )
+
+    with pytest.raises(
+        producer.ReleasePreparedModelError,
+        match="release prepared-model source store",
+    ):
+        producer.audit_bootstrap_wheel(wheel)
+
+
+def test_release_bootstrap_wheel_rejects_stale_selftest_fixture(
+    tmp_path: Path,
+) -> None:
+    wheel = _bootstrap_wheel(
+        tmp_path / f"pyamplicol-{RELEASE_VERSION}.whl",
+        include_selftest_fixture=True,
+    )
+
+    with pytest.raises(
+        producer.ReleasePreparedModelError,
+        match="stale self-test fixture",
+    ):
+        producer.audit_bootstrap_wheel(wheel)
+
+
+def test_release_bootstrap_builder_rejects_candidate_environment(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP", "1")
+
+    with pytest.raises(
+        producer.ReleasePreparedModelError,
+        match="cannot be combined",
+    ):
+        producer.build_bootstrap_wheel(tmp_path / "wheel")
+
+
+def test_release_bootstrap_builder_rejects_candidate_mode(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "candidate")
+
+    with pytest.raises(
+        producer.ReleasePreparedModelError,
+        match="requires PYAMPLICOL_BUILD_MODE=release",
+    ):
+        producer.build_bootstrap_wheel(tmp_path / "wheel")
diff --git a/pyamplicol/tests/release/test_sdist_manifest.py b/pyamplicol/tests/release/test_sdist_manifest.py
new file mode 100644
index 0000000000..c799acdc70
--- /dev/null
+++ b/pyamplicol/tests/release/test_sdist_manifest.py
@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import sys
+import tomllib
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tools" / "release"))
+
+from audit_sdist import (  # noqa: E402
+    PREPARED_MODEL_SDIST_MEMBERS,
+    REQUIRED_SDIST_MEMBERS,
+)
+
+
+def test_maturin_includes_required_sdist_source_trees() -> None:
+    pyproject = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+    includes = {entry["path"] for entry in pyproject["tool"]["maturin"]["include"]}
+
+    assert {
+        "build_backend/**/*",
+        "docs/README.md",
+        "docs/user/**/*",
+        "examples/**/*",
+        "rust/**/*",
+        "schemas/**/*",
+        "tests/**/*",
+        "tools/developer/**/*",
+        "tools/fft_profiling/**/*",
+        "tools/performance_report/**/*",
+        "tools/release/**/*",
+        "tools/typing/**/*",
+    } <= includes
+    assert {"justfile", "rust-toolchain.toml"} <= includes
+    assert "docs/**/*" not in includes
+    assert not {path for path in includes if path.startswith("dependencies/patches/")}
+    assert not {path for path in includes if path.endswith("/**")}
+
+    excludes = set(pyproject["tool"]["maturin"]["exclude"])
+    assert {
+        "build_backend/python_lock.py",
+        "dependencies/contributor-lock.toml",
+        "dependencies/install_dependencies.py",
+        "dependencies/python-runtime-lock.toml",
+        "flake.nix",
+        "release_assets/**",
+    } <= excludes
+
+
+def test_sdist_excludes_development_histories_and_report_payloads() -> None:
+    pyproject = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+    includes = {entry["path"] for entry in pyproject["tool"]["maturin"]["include"]}
+
+    assert {path for path in includes if path.startswith("docs/")} == {
+        "docs/README.md",
+        "docs/correlators.md",
+        "docs/correlator-conventions.md",
+        "docs/user/**/*",
+    }
+    assert not any(
+        member.startswith(
+            (
+                "docs/arxiv/",
+                "docs/development/",
+                "docs/performance_reports/",
+            )
+        )
+        or member.endswith(".pdf")
+        for member in REQUIRED_SDIST_MEMBERS
+    )
+
+
+def test_root_resources_are_sdist_only_and_wheel_resources_are_namespaced() -> None:
+    pyproject = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+    includes = {
+        entry["path"]: set(entry["format"])
+        for entry in pyproject["tool"]["maturin"]["include"]
+        if "format" in entry
+    }
+
+    for path in (
+        "LICENSE",
+        "THIRD_PARTY_NOTICES.md",
+        "licenses/**/*",
+        "dependencies/release-lock.toml",
+        "docs/README.md",
+        "docs/user/**/*",
+        "schemas/**/*",
+    ):
+        assert includes[path] == {"sdist"}
+    assert includes["README.md"] == {"sdist"}
+
+
+def test_maturin_generated_sboms_are_disabled() -> None:
+    pyproject = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+
+    assert pyproject["tool"]["maturin"]["sbom"] == {
+        "rust": False,
+        "auditwheel": False,
+    }
+
+
+def test_sdist_inventory_requires_all_prepared_packs() -> None:
+    root = "src/pyamplicol/assets/prepared_models"
+    expected = {
+        f"{root}/__init__.py",
+        f"{root}/built-in-sm-heft-jit-o2-aarch64.metadata.json",
+        f"{root}/built-in-sm-heft-jit-o2-aarch64.pyamplicol-model",
+        f"{root}/built-in-sm-heft-jit-o2-x86_64.metadata.json",
+        f"{root}/built-in-sm-heft-jit-o2-x86_64.pyamplicol-model",
+        f"{root}/built-in-sm-jit-o2-aarch64.metadata.json",
+        f"{root}/built-in-sm-jit-o2-aarch64.pyamplicol-model",
+        f"{root}/built-in-sm-jit-o2-x86_64.metadata.json",
+        f"{root}/built-in-sm-jit-o2-x86_64.pyamplicol-model",
+    }
+    assert expected == PREPARED_MODEL_SDIST_MEMBERS
+    assert PREPARED_MODEL_SDIST_MEMBERS <= REQUIRED_SDIST_MEMBERS
diff --git a/pyamplicol/tests/typing/consumer_native_api.py b/pyamplicol/tests/typing/consumer_native_api.py
new file mode 100644
index 0000000000..d564fac455
--- /dev/null
+++ b/pyamplicol/tests/typing/consumer_native_api.py
@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: 0BSD
+"""Static consumer of the installed native-extension stub."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import assert_type
+
+import pyamplicol._rusticol as rusticol
+
+MOMENTA: rusticol.Momenta = (((10.0, 0.0, 0.0, 10.0),),)
+
+
+def exercise_native_runtime(artifact: Path) -> None:
+    runtime = rusticol.Runtime.load(
+        artifact,
+        process="ddbar_z",
+        model_parameters={"normalization.alpha_s_me_check": 0.118},
+        mute_warnings=True,
+    )
+    assert_type(runtime, rusticol.Runtime)
+    assert_type(runtime.physics, rusticol.ProcessPhysics)
+    assert_type(runtime.evaluate(MOMENTA), list[float])
+    assert_type(runtime.evaluate(MOMENTA, precision=16), list[float])
+    resolved = runtime.evaluate_resolved(MOMENTA, precision=16)
+    assert_type(resolved, rusticol.ResolvedEvaluation)
+    assert_type(resolved.values, list[list[list[float]]])
+    assert_type(resolved.total(), list[float])
+    assert_type(runtime.physics.external_particles, list[rusticol.ExternalParticle])
+    assert_type(
+        runtime.physics.helicities,
+        list[rusticol.HelicityConfiguration],
+    )
+    assert_type(runtime.physics.color_flows, list[rusticol.ColorFlow])
+    assert_type(
+        runtime.physics.contracted_color_components,
+        list[rusticol.ContractedColorComponent],
+    )
+    assert_type(runtime.physics.model_parameters, list[rusticol.ModelParameter])
+    runtime.set_model_parameters({"normalization.alpha_s_me_check": 0.119})
+    runtime.set_model_parameter("normalization.alpha_s_me_check", 0.120)
+    assert_type(runtime.clear(), None)
+    assert_type(runtime.take_warnings(), list[str])
+
+
+def exercise_native_otf_cache(artifact: Path, cache: Path) -> None:
+    runtime = rusticol.Runtime.load(artifact)
+    assert_type(runtime._on_the_fly_warm_up_f64_json(MOMENTA, n_cores=4), str)
+    assert_type(runtime.save(cache), None)
+    assert_type(runtime.load_cache(str(cache)), None)
+
+
+def exercise_native_metadata() -> None:
+    assert_type(rusticol.abi_version(), int)
+    assert_type(rusticol.package_version(), str)
+    target = rusticol.target_info()
+    assert_type(target, rusticol.TargetInfo)
+    assert_type(target.triple, str)
+    assert_type(target.cpu_features, list[str])
diff --git a/pyamplicol/tests/typing/consumer_public_api.py b/pyamplicol/tests/typing/consumer_public_api.py
new file mode 100644
index 0000000000..3122df22fd
--- /dev/null
+++ b/pyamplicol/tests/typing/consumer_public_api.py
@@ -0,0 +1,298 @@
+# SPDX-License-Identifier: 0BSD
+"""Static external consumer of the installed inline public API."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from decimal import Decimal
+from pathlib import Path
+from typing import Literal, assert_type
+
+from pyamplicol import (
+    BenchmarkComponentTiming,
+    BenchmarkConfig,
+    BenchmarkProfileCounters,
+    BenchmarkResult,
+    BenchmarkRunner,
+    BenchmarkStageTiming,
+    BenchmarkStatistics,
+    BenchmarkTimingBreakdown,
+    ColorCorrelator,
+    ColorFlow,
+    CompiledModel,
+    ContractedColorComponent,
+    CorrelatedRequest,
+    CorrelatedValue,
+    CorrelatorConfig,
+    EvaluationConfig,
+    GenerationConfig,
+    GenerationPlan,
+    GenerationResult,
+    Generator,
+    HelicityConfiguration,
+    ModelSource,
+    ProcessPhysics,
+    ProcessRequest,
+    ProcessSet,
+    ResolvedEvaluation,
+    RunConfig,
+    Runtime,
+    WarmUpResult,
+    benchmark,
+    generate,
+    load,
+)
+from pyamplicol.api import GeneratorBackend, ModelParameters, Momenta, RuntimeBackend
+from pyamplicol.config import (
+    CONFIG_SECTIONS,
+    FIELD_REGISTRY,
+    Action,
+    ClampRequest,
+    ConfigClamp,
+    ConfigField,
+    ConfigOverride,
+    ConfigResolution,
+    config_to_dict,
+    config_to_toml,
+    get_config_field,
+    load_config,
+    parse_override,
+    resolution_to_dict,
+    resolve_config,
+)
+from pyamplicol.reporting import NullProgressSink
+
+MOMENTA: Momenta = (((10.0, 0.0, 0.0, 10.0),),)
+PARAMETERS: ModelParameters = {"normalization.alpha_s_me_check": 0.118}
+
+
+def exercise_otf_cache(artifact: Path, cache: Path) -> None:
+    runtime = Runtime.load(artifact)
+    assert_type(runtime.warm_up(MOMENTA, n_cores=4), WarmUpResult)
+    assert_type(runtime.warm_up(MOMENTA, n_cores=None), WarmUpResult)
+    assert_type(runtime.save(cache), None)
+    assert_type(runtime.load_cache(str(cache)), None)
+
+
+def exercise_generator(artifact: Path) -> None:
+    processes = ProcessSet.from_expressions(("d d~ > z",), names=("ddbar_z",))
+    assert_type(processes, ProcessSet)
+    compiled = ModelSource.built_in_sm().compile(use_cache=False)
+    assert_type(compiled, CompiledModel)
+    generator = Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            generation=GenerationConfig(workers=1),
+        ),
+        progress=NullProgressSink(),
+    )
+    plan = generator.plan(processes, model=compiled)
+    assert_type(plan, GenerationPlan)
+    generated = generator.generate(processes, artifact, mode="replace")
+    assert_type(generated, GenerationResult)
+    assert_type(
+        generate(
+            ProcessRequest.parse("d d~ > z"),
+            artifact,
+            model=compiled,
+            mode="append",
+            config=GenerationConfig(workers=1),
+        ),
+        GenerationResult,
+    )
+
+
+def exercise_runtime(artifact: Path) -> None:
+    runtime = Runtime.load(artifact, model_parameters=PARAMETERS, mute_warnings=True)
+    assert_type(runtime, Runtime)
+    assert_type(load(artifact, process="ddbar_z"), Runtime)
+    assert_type(runtime.artifact_id, str)
+    assert_type(
+        runtime.execution_mode,
+        Literal["compiled", "eager", "recurrence", "on-the-fly"],
+    )
+    assert_type(runtime.inspect(), Mapping[str, object])
+    physics = runtime.physics
+    assert_type(physics, ProcessPhysics)
+    assert_type(
+        runtime.evaluate(
+            MOMENTA,
+            helicities=physics.helicities,
+            color_flows=physics.color_flows,
+        ),
+        tuple[complex | Decimal, ...],
+    )
+    resolved = runtime.evaluate_resolved(MOMENTA, precision=32)
+    assert_type(resolved, ResolvedEvaluation)
+    assert_type(resolved.total(), tuple[complex | Decimal, ...])
+    runtime.set_model_parameters(PARAMETERS)
+    runtime.set_model_parameter("normalization.alpha_s_me_check", 0.119)
+    runtime.mute_warnings()
+    runtime.unmute_warnings()
+    runtime.clear()
+    assert_type(BenchmarkRunner(BenchmarkConfig()).run(runtime), BenchmarkResult)
+    assert_type(benchmark(runtime, points=MOMENTA), BenchmarkResult)
+
+
+def exercise_correlations(artifact: Path, momenta: Momenta) -> None:
+    dipole = ColorCorrelator.dipole("T13", 1, 3)
+    assert_type(dipole, ColorCorrelator)
+    declarations = CorrelatorConfig(
+        color_correlations=(dipole,), spin_correlations=((3,),)
+    )
+    assert_type(declarations, CorrelatorConfig)
+    assert_type(
+        Generator().generate("g g > g g", artifact, correlators=declarations),
+        GenerationResult,
+    )
+    runtime = Runtime.load(artifact)
+    runtime.set_spin_correlation_vectors({3: (0, 1, 0, 0)})
+    requests = {
+        "born": CorrelatedRequest("born", spin_vectors={}),
+        "dipole13_spin": CorrelatedRequest("T13"),
+    }
+    assert_type(requests, dict[str, CorrelatedRequest])
+    results = runtime.evaluate_correlated_many(momenta, requests, precision=40)
+    assert_type(results, dict[str, tuple[CorrelatedValue, ...]])
+    assert_type(results["dipole13_spin"][0].real, Decimal)
+    assert_type(results["dipole13_spin"][0].imag, Decimal)
+    assert_type(runtime.evaluate_correlated(momenta), tuple[CorrelatedValue, ...])
+    runtime.set_spin_correlation_vectors(
+        {3: (Decimal(0), (Decimal("1.00000000000000000001"), Decimal("1e-25")), 0, 0)}
+    )
+    assert_type(
+        runtime.evaluate_correlated(momenta, arithmetic="double-double", precision=31),
+        tuple[CorrelatedValue, ...],
+    )
+    assert_type(
+        runtime.evaluate_correlated_many(
+            momenta, requests, arithmetic="double-double", precision=31
+        ),
+        dict[str, tuple[CorrelatedValue, ...]],
+    )
+    runtime.set_spin_correlation_vectors(None)
+
+
+def exercise_configuration(card: Path) -> None:
+    generation = GenerationConfig(workers=1)
+    evaluation = EvaluationConfig(artifact=card, precision=32, resolved=True)
+    benchmark_config = BenchmarkConfig(minimum_samples=3)
+    run = RunConfig(
+        action=Action.EVALUATE,
+        generation=generation,
+        evaluation=evaluation,
+        benchmark=benchmark_config,
+    )
+    assert_type(generation, GenerationConfig)
+    assert_type(evaluation, EvaluationConfig)
+    assert_type(benchmark_config, BenchmarkConfig)
+    assert_type(run, RunConfig)
+    override = parse_override("generation.workers=2", base_dir=card.parent)
+    assert_type(override, ConfigOverride)
+    dedicated: Mapping[str, object] = {"generation": {"workers": 2}}
+    resolution = resolve_config(
+        card,
+        action=Action.GENERATE,
+        dedicated=dedicated,
+        overrides=(override,),
+        clamps=(ClampRequest("generation.workers", 1, "resource limit"),),
+    )
+    assert_type(resolution, ConfigResolution)
+    assert_type(load_config(card, overrides=(override,)), RunConfig)
+    assert_type(config_to_dict(run), dict[str, object])
+    assert_type(config_to_toml(run), str)
+    assert_type(resolution_to_dict(resolution), dict[str, object])
+    assert_type(get_config_field("generation.workers"), ConfigField)
+    assert_type(FIELD_REGISTRY, Mapping[str, ConfigField])
+    assert_type(CONFIG_SECTIONS, tuple[str, ...])
+
+
+def exercise_results(
+    plan: GenerationPlan,
+    generated: GenerationResult,
+    physics: ProcessPhysics,
+    resolved: ResolvedEvaluation,
+    result: BenchmarkResult,
+) -> None:
+    assert_type(plan.concrete_processes, tuple[ProcessRequest, ...])
+    assert_type(plan.estimated_coverage, Mapping[str, object])
+    assert_type(plan.requested_settings, RunConfig | GenerationConfig)
+    assert_type(plan.effective_settings, RunConfig | GenerationConfig)
+    assert_type(plan.adjustments, tuple[ConfigClamp, ...])
+    assert_type(plan.unsupported_features, tuple[str, ...])
+    assert_type(generated.output, Path)
+    assert_type(generated.processes, ProcessSet)
+    assert_type(generated.mode, Literal["error", "append", "replace"])
+    assert_type(physics.helicities, tuple[HelicityConfiguration, ...])
+    assert_type(physics.color_flows, tuple[ColorFlow, ...])
+    assert_type(
+        physics.contracted_color_components,
+        tuple[ContractedColorComponent, ...],
+    )
+    assert_type(physics.helicity_ids, tuple[str, ...])
+    assert_type(resolved.shape, tuple[int, int, int])
+    assert_type(result.uncertainty, BenchmarkStatistics)
+    assert_type(result.evaluator_uncertainty, BenchmarkStatistics | None)
+    assert_type(result.repetitions_per_sample, int)
+    assert_type(result.evaluation_count, int)
+    assert_type(result.evaluated_point_count, int)
+    assert_type(result.process_id, str | None)
+    assert_type(result.process_expression, str | None)
+    assert_type(result.timing_breakdown, BenchmarkTimingBreakdown | None)
+    if result.timing_breakdown is not None:
+        assert_type(
+            result.timing_breakdown.stage_evaluator_call_time,
+            BenchmarkComponentTiming | None,
+        )
+        assert_type(result.timing_breakdown.stages, tuple[BenchmarkStageTiming, ...])
+        assert_type(
+            result.timing_breakdown.stage_backend_call_time,
+            BenchmarkComponentTiming | None,
+        )
+        if result.timing_breakdown.stages:
+            assert_type(
+                result.timing_breakdown.stages[0].leaf_input_pack_time,
+                BenchmarkComponentTiming | None,
+            )
+        assert_type(
+            result.timing_breakdown.counters,
+            BenchmarkProfileCounters | None,
+        )
+        if result.timing_breakdown.counters is not None:
+            assert_type(
+                result.timing_breakdown.counters.stage_input_copy_components_per_point,
+                float | None,
+            )
+            assert_type(
+                result.timing_breakdown.counters.compiled_direct_arena_engines_per_call,
+                float | None,
+            )
+            assert_type(
+                result.timing_breakdown.counters.compiled_direct_arena_calls_per_call,
+                float | None,
+            )
+            assert_type(
+                result.timing_breakdown.counters.compiled_direct_arena_boundary_input_bytes_per_call,
+                float | None,
+            )
+            assert_type(
+                result.timing_breakdown.counters.compiled_direct_arena_boundary_current_output_bytes_per_call,
+                float | None,
+            )
+            assert_type(
+                result.timing_breakdown.counters.compiled_direct_arena_boundary_amplitude_output_bytes_per_call,
+                float | None,
+            )
+    assert_type(result.environment, Mapping[str, object])
+
+
+def exercise_protocols(
+    generator: GeneratorBackend,
+    runtime: RuntimeBackend,
+    processes: ProcessSet,
+) -> None:
+    assert_type(generator.plan(processes), GenerationPlan)
+    assert_type(generator.generate(processes, "artifact"), GenerationResult)
+    assert_type(runtime.physics, ProcessPhysics)
+    assert_type(runtime.evaluate(MOMENTA), Sequence[complex | Decimal])
+    assert_type(runtime.evaluate_resolved(MOMENTA), ResolvedEvaluation)
diff --git a/pyamplicol/tests/typing/test_typing_gate.py b/pyamplicol/tests/typing/test_typing_gate.py
new file mode 100644
index 0000000000..c8ad5c88ae
--- /dev/null
+++ b/pyamplicol/tests/typing/test_typing_gate.py
@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import sys
+import tomllib
+
+import pytest
+
+from tools.typing import check_public_typing as typing_gate
+from tools.typing.check_public_typing import (
+    PUBLIC_FACADES,
+    ROOT,
+    MetadataCheck,
+    check_typing_metadata,
+    render_export_consumer,
+    static_all,
+)
+
+
+def test_main_propagates_source_mypy_failure(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def successful_metadata_check() -> MetadataCheck:
+        return MetadataCheck(errors=(), native_symbols=())
+
+    def failed_mypy(
+        command: list[str], *, environment: dict[str, str] | None = None
+    ) -> int:
+        assert command == [sys.executable, "-m", "mypy"]
+        assert environment is None
+        return 2
+
+    def unexpected_installed_check() -> int:
+        raise AssertionError("installed typing checks must not mask source failures")
+
+    monkeypatch.setattr(typing_gate, "check_typing_metadata", successful_metadata_check)
+    monkeypatch.setattr(typing_gate, "_run_mypy", failed_mypy)
+    monkeypatch.setattr(
+        typing_gate, "_check_installed_consumers", unexpected_installed_check
+    )
+
+    assert typing_gate.main() == 2
+
+
+def test_mypy_scope_is_explicit_and_has_no_blanket_public_ignores() -> None:
+    configuration = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+    mypy = configuration["tool"]["mypy"]
+
+    assert mypy["strict"] is True
+    assert mypy["follow_imports"] == "silent"
+    assert "packages" not in mypy
+    assert "src/pyamplicol" not in mypy["files"]
+    assert "src/pyamplicol/__init__.py" in mypy["files"]
+    assert "src/pyamplicol/api" in mypy["files"]
+    assert "src/pyamplicol/config/models.py" in mypy["files"]
+    assert "src/pyamplicol/assets/models/ufo/" in "\n".join(mypy["exclude"])
+    assert "src/pyamplicol/assets/api_templates/" in "\n".join(mypy["exclude"])
+    assert all(
+        not override.get("ignore_errors", False)
+        for override in configuration["tool"].get("mypy", {}).get("overrides", [])
+    )
+
+
+def test_public_facade_exports_are_static_and_in_the_generated_consumer() -> None:
+    consumer = render_export_consumer()
+    for module, path in PUBLIC_FACADES.items():
+        exports = static_all(path)
+        assert exports
+        alias = module.rsplit(".", 1)[-1] if "." in module else "package"
+        assert all(f"reveal_type({alias}.{name})" in consumer for name in exports)
+
+
+def test_typing_marker_and_native_stub_cover_the_packaged_contract() -> None:
+    result = check_typing_metadata()
+    assert result.errors == ()
+    assert (ROOT / "src" / "pyamplicol" / "py.typed").is_file()
+
+
+def test_consumers_are_outside_the_package_tree() -> None:
+    package = ROOT / "src" / "pyamplicol"
+    for name in ("consumer_public_api.py", "consumer_native_api.py"):
+        consumer = ROOT / "tests" / "typing" / name
+        assert consumer.is_file()
+        assert package not in consumer.parents
diff --git a/pyamplicol/tests/unit/test_adjoint_color_contraction.py b/pyamplicol/tests/unit/test_adjoint_color_contraction.py
new file mode 100644
index 0000000000..bcdd60609a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_adjoint_color_contraction.py
@@ -0,0 +1,187 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+from fractions import Fraction
+from itertools import product
+
+import numpy as np
+import pytest
+
+from pyamplicol.color import (
+    ColorGroupDescriptor,
+    LCColorSector,
+    build_color_plan,
+    build_symmetric_group_color_contraction_plan,
+    certify_symmetric_group_orbits,
+    color_contraction_factor,
+    exact_color_contraction_factor,
+    reconstruct_symmetric_group_dense_exact,
+)
+from pyamplicol.color.adjoint_kernel import adjoint_color_kernel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _plan(n: int, *, basis: str = "adjoint", accuracy: str = "full", **kwargs):
+    process = build_process_ir(
+        "g g > " + " ".join(["g"] * (n - 2)), color_accuracy=accuracy
+    )
+    return build_color_plan(process, color_accuracy=accuracy, basis=basis, **kwargs)
+
+
+def _expanded_chain(word):
+    """Independent literal expansion of Tr([...[T1,T2],...] Tn)."""
+
+    terms = [(1, word[:1])]
+    for label in word[1:-1]:
+        terms = [
+            term
+            for sign, current in terms
+            for term in ((sign, (*current, label)), (-sign, (label, *current)))
+        ]
+    result = []
+    for sign, current in terms:
+        trace = (*current, word[-1])
+        pivot = trace.index(word[0])
+        trace = trace[pivot:] + trace[:pivot]
+        result.append(
+            (sign, LCColorSector(id=0, kind="single-trace", trace_labels=trace))
+        )
+    return result
+
+
+def _trace_expanded_overlap(trace_plan, left, right, accuracy):
+    return sum(
+        (
+            left_sign
+            * right_sign
+            * exact_color_contraction_factor(
+                trace_plan, left_trace, right_trace, accuracy=accuracy
+            )
+            for (left_sign, left_trace), (right_sign, right_trace) in product(
+                _expanded_chain(left.trace_labels), _expanded_chain(right.trace_labels)
+            )
+        ),
+        Fraction(0),
+    )
+
+
+@pytest.mark.parametrize("n", (4, 5))
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_adjoint_kernel_matches_literal_su3_commutator_expansion(n, accuracy):
+    plan = _plan(n, accuracy=accuracy)
+    trace_plan = _plan(n, basis="trace", accuracy=accuracy)
+    for left, right in product(plan.sectors, repeat=2):
+        expected = _trace_expanded_overlap(trace_plan, left, right, accuracy)
+        assert (
+            exact_color_contraction_factor(plan, left, right, accuracy=accuracy)
+            == expected
+        )
+        assert color_contraction_factor(plan, left, right, accuracy=accuracy) == float(
+            expected
+        )
+
+
+def test_nlc_truncates_the_transformed_metric_at_fixed_primitive_amplitudes():
+    plan = _plan(6, accuracy="nlc")
+    trace_plan = _plan(6, basis="trace", accuracy="nlc")
+    full = adjoint_color_kernel(6)
+    nlc = adjoint_color_kernel(6, accuracy="nlc")
+    differing = np.flatnonzero(full != nlc)
+    assert len(differing) > 0
+    for index in (0, int(differing[0]), len(plan.sectors) - 1):
+        left, right = plan.sectors[0], plan.sectors[index]
+        assert exact_color_contraction_factor(plan, left, right, accuracy="nlc") == (
+            _trace_expanded_overlap(trace_plan, left, right, "nlc")
+        )
+
+
+@pytest.mark.parametrize("n", (4, 5, 6))
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_adjoint_orbit_is_two_anchor_and_reconstructs_exact_metric(n, accuracy):
+    plan = _plan(n, accuracy=accuracy)
+    descriptors = tuple(
+        ColorGroupDescriptor(i, (), sector.id, sector.trace_labels, 1.0)
+        for i, sector in enumerate(plan.sectors)
+    )
+    partition = certify_symmetric_group_orbits(plan, tuple(range(plan.sector_count)))
+    assert partition.fixed_adjoint_labels == (1, n)
+    assert partition.permuted_adjoint_labels == tuple(range(2, n))
+    assert partition.residual_sector_ids == ()
+    block = build_symmetric_group_color_contraction_plan(
+        plan, descriptors
+    ).symmetric_group_block
+    assert block is not None
+    assert block.degree == n - 2
+    assert block.channel_count == 1
+    assert len(block.kernel_entries) == math.factorial(n - 2)
+    dense = reconstruct_symmetric_group_dense_exact(block)
+    for left in range(plan.sector_count):
+        for right in range(left, plan.sector_count):
+            assert dense[(left, right)] == exact_color_contraction_factor(
+                plan, plan.sectors[left], plan.sectors[right], accuracy=accuracy
+            )
+
+
+@pytest.mark.parametrize("n", (3, 4, 5, 6))
+def test_adjoint_kernel_normalization_and_read_only_storage(n):
+    kernel = adjoint_color_kernel(n)
+    assert len(kernel) == math.factorial(n - 2)
+    assert kernel[0] == (3**2 - 1) * (2 * 3) ** (n - 2)
+    assert not kernel.flags.writeable
+
+
+@pytest.mark.parametrize("nc", (2, 4))
+def test_adjoint_finite_differences_preserve_general_nc_normalization(nc):
+    kernel = adjoint_color_kernel(6, nc=nc)
+    assert kernel[0] == (nc**2 - 1) * (2 * nc) ** 4
+
+
+def test_adjoint_full_colour_cutoff_preserves_scalar_factor_contract():
+    np.testing.assert_array_equal(
+        adjoint_color_kernel(6, full_col_acc=0),
+        adjoint_color_kernel(6, accuracy="lc"),
+    )
+    np.testing.assert_array_equal(
+        adjoint_color_kernel(6, full_col_acc=1),
+        adjoint_color_kernel(6, accuracy="nlc"),
+    )
+    plan = _plan(6)
+    left, right = plan.sectors[0], plan.sectors[7]
+    assert exact_color_contraction_factor(
+        plan, left, right, accuracy="full", full_col_acc=1
+    ) == exact_color_contraction_factor(plan, left, right, accuracy="nlc")
+
+
+def test_adjoint_plan_keeps_basis_separate_from_primitive_words():
+    trace = _plan(5, basis="trace")
+    adjoint = _plan(5)
+    assert "basis" not in trace.to_json_dict()
+    assert adjoint.to_json_dict()["basis"] == "adjoint"
+    assert len(trace.sectors) == 24
+    assert len(adjoint.sectors) == 6
+    assert all(sector.kind == "single-trace" for sector in adjoint.sectors)
+    assert all(sector.trace_labels[::4] == (1, 5) for sector in adjoint.sectors)
+    reordered = _plan(5, reference_color_order=(1, 3, 2, 4, 5))
+    assert reordered.sectors[0].trace_labels == (1, 3, 2, 4, 5)
+    assert len(reordered.sectors) == 6
+    cyclic = _plan(5, reference_color_order=(3, 2, 4, 5, 1))
+    assert cyclic.sectors == reordered.sectors
+    with pytest.raises(ValueError, match="both anchors"):
+        _plan(5, reference_color_order=(1, 3, 2, 5, 4))
+    truncated = _plan(5, max_sectors=2)
+    assert truncated.truncated and len(truncated.sectors) == 2
+    empty = _plan(5, max_sectors=0, reference_color_order=(1, 3, 2, 4, 5))
+    assert empty.truncated and empty.sectors == ()
+
+
+def test_ddm_plan_rejects_fundamental_domains_and_lc():
+    with pytest.raises(ValueError, match="adjoint"):
+        process = build_process_ir("d d~ > g g", color_accuracy="full")
+        build_color_plan(process, color_accuracy="full", basis="adjoint")
+    with pytest.raises(ValueError, match="NLC or full"):
+        _plan(4, accuracy="lc")
+    with pytest.raises(ValueError, match="at most 12"):
+        _plan(13)
+    with pytest.raises(ValueError, match="int64"):
+        adjoint_color_kernel(12, nc=100)
diff --git a/pyamplicol/tests/unit/test_adjoint_generation_scope.py b/pyamplicol/tests/unit/test_adjoint_generation_scope.py
new file mode 100644
index 0000000000..568bf661db
--- /dev/null
+++ b/pyamplicol/tests/unit/test_adjoint_generation_scope.py
@@ -0,0 +1,289 @@
+# SPDX-License-Identifier: 0BSD
+"""Non-native checks for the certified DDM generation scope and seed boundary."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from types import SimpleNamespace
+from typing import cast
+
+import pytest
+
+from pyamplicol.config import ColorConfig, EvaluatorConfig, ProcessConfig, RunConfig
+from pyamplicol.generation import service as generation_service
+from pyamplicol.generation.on_the_fly_seed import project_on_the_fly_process_seed_v1
+from pyamplicol.generation.service import GenerationBackend
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.adjoint_color_certificate import (
+    adjoint_tree_color_basis_is_proven,
+)
+from pyamplicol.models.base import Model
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.contracts import CompiledOrientedKernel
+from pyamplicol.models.external_symmetries import _yang_mills_sector_is_closed
+from tests.unit.test_on_the_fly_seed_projection import (
+    _catalog,
+    _gluon_process,
+    _NormalizationModel,
+)
+
+
+class _UncertifiedAdjointModel(BuiltinSMModel):
+    """An unknown extension must not inherit the pinned model's certificate."""
+
+
+def test_pinned_builtin_certificate_does_not_leak_into_unknown_subclasses():
+    process = build_process_ir("g g > g g", color_accuracy="full")
+    model = BuiltinSMModel()
+    unknown = _UncertifiedAdjointModel()
+    assert model.lc_trace_reflection_equivalence_is_proven(process)
+    assert unknown.lc_trace_reflection_equivalence_is_proven(process)
+    assert adjoint_tree_color_basis_is_proven(model, process)
+    assert not adjoint_tree_color_basis_is_proven(unknown, process)
+
+
+def test_adjoint_certificate_dispatch_preserves_external_model_hook_and_limits():
+    process = build_process_ir("g g > z g", color_accuracy="full")
+    limits = {"HIG": 1}
+    observed = []
+
+    class CertifiedModel(_UncertifiedAdjointModel):
+        def adjoint_tree_color_basis_is_proven(
+            self, selected_process, *, max_coupling_orders=None
+        ):
+            observed.append((selected_process, max_coupling_orders))
+            return True
+
+    assert adjoint_tree_color_basis_is_proven(
+        CertifiedModel(), process, max_coupling_orders=limits
+    )
+    assert observed == [(process, limits)]
+
+
+def _backend(lane: str, basis: str = "adjoint", accuracy: str = "full"):
+    return GenerationBackend(
+        RunConfig(
+            action="generate",
+            process=ProcessConfig(
+                coupling_order_policy="explicit",
+                selected_source_helicities={"1": -1},
+            ),
+            color=ColorConfig(
+                accuracy=accuracy,
+                contraction="symmetric-group-fft",
+                fft_basis=basis,
+            ),
+            evaluator=EvaluatorConfig(execution_mode=lane),
+        ),
+        None,
+    )
+
+
+@pytest.mark.parametrize("lane", ("recurrence", "on-the-fly"))
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_builtin_certified_gluons_use_ddm_in_planning_and_construction(lane, accuracy):
+    backend = _backend(lane, accuracy=accuracy)
+    model = BuiltinSMModel()
+    process = build_process_ir("g g > g g g", color_accuracy=accuracy)
+    assert backend._fft_color_basis(process, model) == "adjoint"
+    assert (
+        backend._plan_concrete_process(process, model=model)["color_sector_count"] == 6
+    )
+    prepared = backend._prepare_process_construction(process, model)
+    assert prepared.complete_color_plan.basis == "adjoint"
+    assert prepared.restricted_color_plan.basis == "adjoint"
+    assert prepared.complete_color_plan.sector_count == 6
+    assert not prepared.complete_color_plan.trace_reflections_folded
+
+
+@pytest.mark.parametrize("lane", ("recurrence", "on-the-fly"))
+def test_adjoint_scope_requires_model_proof_not_external_adjoint_roles(lane):
+    process = build_process_ir("g g > g g", color_accuracy="full")
+    backend = _backend(lane)
+    for model in (None, _UncertifiedAdjointModel()):
+        assert backend._fft_color_basis(process, model) == "trace"
+        planned = backend._plan_concrete_process(process, model=model)
+        selected = planned["fft_basis_selection"]
+        assert selected["requested"] == "adjoint"
+        assert selected["name"] == "trace"
+        assert "No DDM amplitude identity" in selected["reason"]
+
+
+@pytest.mark.parametrize("lane", ("recurrence", "on-the-fly"))
+@pytest.mark.parametrize(
+    "process,name",
+    (
+        ("d d~ > g g", "fundamental-chain"),
+        ("d d~ > d d~ g g", "fundamental-chain-products"),
+        ("g g > g g z", "trace"),
+        ("e- e+ > mu- mu+", "singlet"),
+    ),
+)
+def test_general_adjoint_selection_preserves_other_exact_bases(lane, process, name):
+    backend = _backend(lane)
+    model = BuiltinSMModel()
+    process_ir = build_process_ir(process, color_accuracy="full")
+    assert backend._fft_color_basis(process_ir, model) == "trace"
+    planned = backend._plan_concrete_process(process_ir, model=model)
+    assert planned["fft_basis_selection"]["name"] == name
+    prepared = backend._prepare_process_construction(process_ir, model)
+    assert prepared.complete_color_plan.basis == "trace"
+    assert backend._fft_basis_metadata(prepared.complete_color_plan) == {
+        "fft_basis_selection": planned["fft_basis_selection"]
+    }
+
+
+def test_trace_scope_does_not_require_the_new_adjoint_certificate():
+    assert (
+        _backend("recurrence", basis="trace")._fft_color_basis(
+            build_process_ir("d d~ > g g", color_accuracy="full"), None
+        )
+        == "trace"
+    )
+
+
+@pytest.mark.parametrize("lane", ("recurrence", "on-the-fly"))
+def test_automatic_default_selects_certified_ddm_and_direct_opt_out_does_not(lane):
+    process = build_process_ir("g g > g g", color_accuracy="full")
+    model = BuiltinSMModel()
+    for contraction, expected in (("auto", "adjoint"), ("direct", "trace")):
+        backend = GenerationBackend(
+            RunConfig(
+                action="generate",
+                color=ColorConfig(accuracy="full", contraction=contraction),
+                evaluator=EvaluatorConfig(execution_mode=lane),
+            ),
+            None,
+        )
+        assert backend._fft_color_basis(process, model) == expected
+        planned = backend._plan_concrete_process(process, model=model)
+        assert ("fft_basis_selection" in planned) is (contraction == "auto")
+
+
+def test_automatic_adjoint_selection_respects_representation_limits():
+    model = BuiltinSMModel()
+    large = build_process_ir("g g > " + " ".join(["g"] * 11), color_accuracy="full")
+    backend = GenerationBackend(
+        RunConfig(action="generate", color=ColorConfig(accuracy="full")), None
+    )
+    assert backend._fft_color_basis(large, model) == "trace"
+    # A valid trace ordering need not preserve the two DDM anchors.
+    process = build_process_ir("g g > g g", color_accuracy="full")
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="full"),
+        process=ProcessConfig(reference_color_order=(1, 2, 4, 3)),
+    )
+    automatic = GenerationBackend(config, None)
+    planned = automatic._plan_concrete_process(process, model=model)
+    assert planned["fft_basis_selection"]["actual_basis"] == "trace"
+    assert "ordering" in planned["fft_basis_selection"]["reason"]
+    forced = GenerationBackend(
+        replace(config, color=replace(config.color, contraction="symmetric-group-fft")),
+        None,
+    )
+    with pytest.raises(ValueError, match="preserve both anchors"):
+        forced._plan_concrete_process(process, model=model)
+
+
+def test_structural_preflight_never_materializes_the_full_trace_domain(monkeypatch):
+    original = generation_service.build_color_plan
+    probes = []
+
+    def bounded_probe(process, **kwargs):
+        # Twelve gluons would otherwise build 11! temporary trace sectors
+        # before even selecting the much smaller DDM construction domain.
+        assert kwargs["max_sectors"] == 1
+        result = original(process, **kwargs)
+        assert len(result.sectors) <= 1
+        probes.append(result)
+        return result
+
+    monkeypatch.setattr(generation_service, "build_color_plan", bounded_probe)
+    expressions = (
+        "g g > " + " ".join(["g"] * 10),
+        "d d~ > z g g",
+        "d d > z d d~",  # unbalanced all-outgoing colour endpoints
+    )
+    candidates = tuple(
+        build_process_ir(expression, color_accuracy="full")
+        for expression in expressions
+    )
+    selected, rejected = generation_service._select_color_ready_processes(
+        candidates, color_accuracy="full"
+    )
+    assert selected == candidates[:2]
+    assert len(rejected) == 1
+    assert rejected[0].startswith(expressions[-1] + ":")
+    assert probes[0].truncated  # truncation is not structural rejection
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_adjoint_otf_projection_changes_only_the_separate_colour_plan(accuracy):
+    process = replace(_gluon_process(5), color_accuracy=accuracy)
+    projections = {
+        basis: project_on_the_fly_process_seed_v1(
+            process,
+            _catalog(),
+            cast(Model, _NormalizationModel()),
+            coupling_order_policy="minimal",
+            coupling_order_limits={"QCD": 3},
+            color_basis=basis,
+        )
+        for basis in ("trace", "adjoint")
+    }
+    trace = projections["trace"]
+    adjoint = projections["adjoint"]
+    assert trace.color_plan is not None and adjoint.color_plan is not None
+    assert trace.color_plan.sector_count == 24
+    assert adjoint.color_plan.sector_count == 6
+    assert adjoint.color_plan.basis == "adjoint"
+    assert adjoint.seed.to_json_bytes() == trace.seed.to_json_bytes()
+    assert adjoint.runtime_normalization == trace.runtime_normalization
+    assert all(len(leg.source_states) == 2 for leg in adjoint.seed.external_sources)
+
+
+def test_adjoint_otf_projection_canonicalizes_a_valid_cyclic_reference():
+    projection = project_on_the_fly_process_seed_v1(
+        replace(_gluon_process(4), color_accuracy="full"),
+        _catalog(),
+        cast(Model, _NormalizationModel()),
+        coupling_order_policy="minimal",
+        coupling_order_limits={},
+        color_basis="adjoint",
+        reference_color_order=(3, 2, 4, 1),
+    )
+    assert projection.color_plan is not None
+    assert projection.color_plan.sectors[0].trace_labels == (1, 3, 2, 4)
+
+
+def test_existing_yang_mills_certificate_excludes_reachable_singlet_exchange():
+    # This closure check is part of the existing model certificate. Merely
+    # recognizing ggg and gggg is insufficient when gg can also produce H.
+    def kernels(*rows):
+        return cast(
+            tuple[CompiledOrientedKernel, ...],
+            tuple(
+                SimpleNamespace(kind=kind, particles=particles)
+                for kind, particles in rows
+            ),
+        )
+
+    standard = kernels(
+        (1, ("g", "g", "g")), (2, ("g", "g", "aux")), (3, ("aux", "g", "g"))
+    )
+    certified = frozenset({1, 2, 3})
+    assert _yang_mills_sector_is_closed(
+        "g", standard, yang_mills_kernel_kinds=certified
+    )
+    assert not _yang_mills_sector_is_closed(
+        "g",
+        (*standard, *kernels((4, ("g", "g", "H")))),
+        yang_mills_kernel_kinds=certified,
+    )
+    # A quark pair cannot be produced from purely gluonic tree currents.
+    assert _yang_mills_sector_is_closed(
+        "g",
+        (*standard, *kernels((4, ("q", "q~", "g")))),
+        yang_mills_kernel_kinds=certified,
+    )
diff --git a/pyamplicol/tests/unit/test_adjoint_singlet_color_certificate.py b/pyamplicol/tests/unit/test_adjoint_singlet_color_certificate.py
new file mode 100644
index 0000000000..53236dbb33
--- /dev/null
+++ b/pyamplicol/tests/unit/test_adjoint_singlet_color_certificate.py
@@ -0,0 +1,165 @@
+# SPDX-License-Identifier: 0BSD
+"""Small exact checks for DDM colour with a colourless operator insertion."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from fractions import Fraction
+from types import SimpleNamespace
+from typing import cast
+
+import pytest
+
+from pyamplicol.color import (
+    build_color_plan,
+    color_contraction_factor,
+    exact_color_contraction_factor,
+)
+from pyamplicol.color.adjoint_kernel import adjoint_color_kernel
+from pyamplicol.color.contraction_trace import _simplify_trace_terms_nc_power
+from pyamplicol.models.adjoint_color_certificate import (
+    _is_connected_adjoint_tree_tensor,
+    compiled_adjoint_tree_color_basis_is_proven,
+)
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.contracts import CompiledModelIR
+from pyamplicol.models.tensors import normalize_color_expression
+
+
+def _term(index, particles, source, orders=()):
+    representations = tuple(1 if name == "spectator" else 8 for name in particles)
+    return SimpleNamespace(
+        id=index,
+        particles=particles,
+        color_source=source,
+        color_expression=normalize_color_expression(source, representations).expression,
+        coupling_orders=orders,
+    )
+
+
+def _theory(*, source="UFO::Identity(1,2)", mixed_order="EFT"):
+    # Names, spin, Lorentz structures and physical meaning are immaterial:
+    # this proof is exclusively about colour and insertion budgets.
+    return cast(
+        CompiledModelIR,
+        SimpleNamespace(
+            particles=(
+                SimpleNamespace(name="adj", antiname="adj", pdg_code=21, color=8),
+                SimpleNamespace(
+                    name="spectator", antiname="spectator", pdg_code=23, color=1
+                ),
+            ),
+            vertex_terms=(
+                _term(0, ("adj",) * 3, "UFO::f(1,2,3)", (("STRONG", 1),)),
+                _term(1, ("adj",) * 2 + ("spectator",), source, ((mixed_order, 1),)),
+                _term(2, ("spectator",) * 3, "1", (("WEAK", 1),)),
+            ),
+        ),
+    )
+
+
+@pytest.mark.parametrize("process", ("g g > z", "g g > z g", "g g > z g g"))
+def test_single_mixed_insertion_is_certified_without_yang_mills_helicity_claim(process):
+    assert compiled_adjoint_tree_color_basis_is_proven(
+        _theory(), build_process_ir(process, color_accuracy="full"),
+        max_coupling_orders={"EFT": 1},
+    )
+
+
+@pytest.mark.parametrize("limits", ({}, {"EFT": 2}, {"STRONG": 0}))
+@pytest.mark.parametrize("process", ("g g > g g", "g g > z g"))
+def test_extra_singlet_exchange_is_not_mistaken_for_one_ddm_tree(limits, process):
+    assert not compiled_adjoint_tree_color_basis_is_proven(
+        _theory(), build_process_ir(process, color_accuracy="full"),
+        max_coupling_orders=limits,
+    )
+
+
+def test_zero_insertion_budget_excludes_singlet_exchange_even_in_extended_model():
+    assert compiled_adjoint_tree_color_basis_is_proven(
+        _theory(), build_process_ir("g g > g g", color_accuracy="full"),
+        max_coupling_orders={"EFT": 0},
+    )
+
+
+def test_quark_domain_is_not_certified_by_the_gluonic_tree_theorem():
+    assert not compiled_adjoint_tree_color_basis_is_proven(
+        _theory(), build_process_ir("d d~ > z g", color_accuracy="full"),
+        max_coupling_orders={"EFT": 1},
+    )
+
+
+@pytest.mark.parametrize(
+    ("source", "representations", "expected"),
+    (
+        ("UFO::Identity(1,2)", (8, 8, 1), True),
+        ("UFO::f(1,2,3)", (8, 8, 8, 1), True),
+        ("UFO::f(-1,1,2)*UFO::f(3,4,-1)", (8, 8, 8, 8, 1), True),
+        ("UFO::f(-1,1,2)*UFO::f(3,4,-1)", (8, 8, 8, 8), True),
+        ("UFO::Identity(1,2)*UFO::Identity(3,4)", (8, 8, 8, 8), False),
+        ("UFO::d(1,2,3)", (8, 8, 8), False),
+    ),
+)
+def test_tree_certificate_distinguishes_connected_and_symmetric_tensors(
+    source, representations, expected
+):
+    expression = normalize_color_expression(source, representations).expression
+    actual = _is_connected_adjoint_tree_tensor(source, expression, representations)
+    assert actual is expected
+
+
+def test_source_spelling_cannot_certify_a_different_actual_tensor():
+    source = "UFO::f(1,2,3)"
+    expression = normalize_color_expression("UFO::d(1,2,3)", (8, 8, 8)).expression
+    assert not _is_connected_adjoint_tree_tensor(source, expression, (8, 8, 8))
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_singlet_labels_and_two_adjoint_identity_survive_ddm_planning(accuracy):
+    process = build_process_ir("g g > z", color_accuracy=accuracy)
+    adjoint = build_color_plan(process, color_accuracy=accuracy, basis="adjoint")
+    trace = build_color_plan(process, color_accuracy=accuracy, basis="trace")
+    assert adjoint.sector_count == trace.sector_count == 1
+    assert adjoint.sectors[0].singlet_labels == (3,)
+    assert adjoint.sectors[0].trace_labels == (1, 2)
+    assert exact_color_contraction_factor(
+        adjoint, adjoint.sectors[0], adjoint.sectors[0], accuracy=accuracy
+    ) == exact_color_contraction_factor(
+        trace, trace.sectors[0], trace.sectors[0], accuracy=accuracy
+    ) == 8
+
+
+@pytest.mark.parametrize("nc", (2, 3, 4))
+def test_degenerate_adjoint_ladder_keeps_su_nc_identity(nc):
+    assert adjoint_color_kernel(2, nc=nc)[0] == nc * nc - 1
+    assert adjoint_color_kernel(2, nc=nc, accuracy="nlc")[0] == nc * nc - 1
+    assert adjoint_color_kernel(2, nc=nc, accuracy="lc")[0] == nc * nc
+    assert adjoint_color_kernel(2, nc=nc, full_col_acc=0)[0] == nc * nc
+
+
+def test_two_adjoint_trace_nlc_keeps_the_complete_fierz_polynomial():
+    # Independent Fierz reduction proves that there is no NNLC term to
+    # discard. Nc^2 - n*Nc^(n-2) is not valid for the degenerate n=2 trace.
+    polynomial = _simplify_trace_terms_nc_power(
+        ((Fraction(1), 0, ((1, 2), (2, 1))),)
+    )
+    assert polynomial == {2: Fraction(1), 0: Fraction(-1)}
+    process = build_process_ir("g g > z", color_accuracy="nlc")
+    plan = build_color_plan(process, color_accuracy="nlc", basis="trace")
+    sector = plan.sectors[0]
+    assert exact_color_contraction_factor(plan, sector, sector, accuracy="nlc") == 8
+    assert color_contraction_factor(plan, sector, sector, accuracy="nlc") == 8.0
+
+
+def test_singlet_labels_are_retained_for_all_primitive_orderings():
+    process = build_process_ir("g g > z g g", color_accuracy="full")
+    adjoint = build_color_plan(process, color_accuracy="full", basis="adjoint")
+    assert adjoint.sector_count == 2
+    assert {sector.singlet_labels for sector in adjoint.sectors} == {(3,)}
+    assert {sector.trace_labels for sector in adjoint.sectors} == {
+        (1, 2, 4, 5), (1, 4, 2, 5)
+    }
+    reversed_plan = build_color_plan(
+        replace(process, color_accuracy="nlc"), color_accuracy="nlc", basis="adjoint"
+    )
+    assert reversed_plan.sectors == adjoint.sectors
diff --git a/pyamplicol/tests/unit/test_amplicol_z6g_m0_capture.py b/pyamplicol/tests/unit/test_amplicol_z6g_m0_capture.py
new file mode 100644
index 0000000000..de63dc4c3a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_amplicol_z6g_m0_capture.py
@@ -0,0 +1,998 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import subprocess
+import sys
+from dataclasses import replace
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+from typing import Any
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+CAPTURE_SCRIPT = ROOT / "tools" / "developer" / "amplicol_z6g_m0_capture.py"
+M0_SCRIPT = ROOT / "tools" / "developer" / "eager_compiled_arena_m0.py"
+
+
+def _load(name: str, path: Path) -> ModuleType:
+    spec = importlib.util.spec_from_file_location(name, path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+capture = _load("_test_amplicol_z6g_m0_capture", CAPTURE_SCRIPT)
+m0 = _load("_test_amplicol_z6g_m0_capture_m0", M0_SCRIPT)
+
+REVISION = "b" * 40
+PYAMPLICOL_REVISION = "a" * 40
+POINTS_SHA256 = "1" * 64
+NORMALIZATION_SHA256 = "2" * 64
+FLOW_ID = "flow:2,4,5,6,7,8,9,1"
+FLOW_WORD = [2, 4, 5, 6, 7, 8, 9, 1]
+HELICITY_ID = "h:-1,+1,-1,+1,-1,+1,-1,+1,-1"
+HELICITY_VALUES = [-1, 1, -1, 1, -1, 1, -1, 1, -1]
+HOST = {
+    "platform": "Darwin-test",
+    "system": "Darwin",
+    "release": "24.0.0",
+    "version": "test",
+    "machine": "arm64",
+    "processor": "arm",
+    "cpu_model": "test-cpu",
+    "logical_cpu_count": 8,
+}
+
+
+def _write(path: Path, raw: bytes, *, executable: bool = False) -> dict[str, Any]:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(raw)
+    if executable:
+        path.chmod(0o755)
+    return capture._file_ref(path)
+
+
+def _git_repository(path: Path) -> tuple[Path, str]:
+    path.mkdir()
+    subprocess.run(("git", "init", "-q"), cwd=path, check=True)
+    tracked = path / "tracked.txt"
+    tracked.write_text("tracked\n", encoding="utf-8")
+    subprocess.run(("git", "add", "tracked.txt"), cwd=path, check=True)
+    subprocess.run(
+        (
+            "git",
+            "-c",
+            "user.name=Capture Test",
+            "-c",
+            "user.email=capture@example.invalid",
+            "commit",
+            "-qm",
+            "initial",
+        ),
+        cwd=path,
+        check=True,
+    )
+    revision = subprocess.run(
+        ("git", "rev-parse", "--verify", "HEAD"),
+        cwd=path,
+        capture_output=True,
+        text=True,
+        check=True,
+    ).stdout.strip()
+    return path, revision
+
+
+def _write_generated_library(repository: Path) -> tuple[Path, Path]:
+    amplitudes = repository / "Library" / "amplitudes.bin"
+    data = repository / "Library" / "nested" / "amp_1_lib.data"
+    amplitudes.parent.mkdir(parents=True)
+    data.parent.mkdir(parents=True)
+    amplitudes.write_bytes(b"amplitudes\n")
+    data.write_bytes(b"library-data\n")
+    return amplitudes, data
+
+
+def _contract(tmp_path: Path) -> capture.CaptureContract:
+    fixture = _write(tmp_path / "validation-momenta.json", b"fixture\n")
+    return capture.CaptureContract(
+        expected={
+            "pyamplicol_source_revision": PYAMPLICOL_REVISION,
+            "amplicol_source_revision": REVISION,
+            "momenta_points_sha256": POINTS_SHA256,
+            "normalization_sha256": NORMALIZATION_SHA256,
+            "host_sha256": capture._canonical_sha256(HOST),
+            "color_flow": {"id": FLOW_ID, "word": FLOW_WORD},
+            "helicity": {"id": HELICITY_ID, "values": HELICITY_VALUES},
+            "external_leg_permutation": list(capture.AMPLICOL_EXTERNAL_LEG_PERMUTATION),
+        },
+        input_files=(),
+        host=HOST,
+        fixture={
+            "path": Path(fixture["path"]),
+            "file": fixture,
+            "point_count": 2,
+            "points_sha256": POINTS_SHA256,
+        },
+        color_axis={
+            "count": 720,
+            "ordered_ids_sha256": "3" * 64,
+        },
+        helicity_axis={
+            "count": 768,
+            "ordered_ids_sha256": "4" * 64,
+        },
+        color_flow_request="1",
+        helicity_request="1",
+        selected_values=(complex(1.25, 0.0), complex(2.5, 0.0)),
+        union_values=(complex(3.75, 0.0), complex(5.0, 0.0)),
+    )
+
+
+def _context(tmp_path: Path) -> capture.ProbeContext:
+    runtime = tmp_path / "runtime"
+    runtime.mkdir()
+    process_file = runtime / "processes.txt"
+    process_file.write_text("process\n", encoding="utf-8")
+    selected = runtime / "amplicol_library_benchmark"
+    union = runtime / "amplicol_color_probe"
+    selected.write_bytes(b"selected")
+    union.write_bytes(b"union")
+    worker = runtime / "amplicol_z6g_m0_sample"
+    worker.write_bytes(b"worker")
+    selected.chmod(0o755)
+    union.chmod(0o755)
+    worker.chmod(0o755)
+    return capture.ProbeContext(
+        runtime=runtime,
+        worker_executable=worker,
+        process_file=process_file,
+        selected_binary=selected,
+        union_binary=union,
+        linked_files=(selected, union, process_file),
+        group=11,
+        integral=7,
+        source_pdgs=(2, -2, 23, 21, 21, 21, 21, 21, 21),
+        generated_pdgs=(2, -2, 21, 21, 21, 21, 21, 21, 23),
+        generated_color_order=(2, 3, 4, 5, 6, 7, 8, 1, 9),
+        permutation=capture.AMPLICOL_EXTERNAL_LEG_PERMUTATION,
+    )
+
+
+def _source(tmp_path: Path) -> capture.SourceEvidence:
+    identity = _write(tmp_path / "amplicol-source.f90", b"program probe\n")
+    return capture.SourceEvidence(
+        source={
+            "revision": REVISION,
+            "dirty": False,
+            "compiler": {
+                "id": "gfortran",
+                "version": "GNU Fortran 14.2",
+                "target": "arm64-apple-darwin",
+                "flags_sha256": capture._canonical_sha256(["-O3"]),
+            },
+            "source_tree_sha256": capture._source_tree_sha256([identity]),
+        },
+        source_files=(identity,),
+    )
+
+
+def _role_samples(
+    tmp_path: Path,
+    *,
+    role: str,
+    executable: dict[str, Any],
+    fixture: dict[str, Any],
+    values: list[list[float]],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    samples: list[dict[str, Any]] = []
+    projections: list[dict[str, Any]] = []
+    offset = 0 if role == capture.SELECTED_ROLE else 1
+    for index in range(capture.MIN_SAMPLES):
+        evaluated = 1000
+        seconds_per_point = 4.0e-5 * (1.0 + index * 0.01)
+        elapsed = evaluated * seconds_per_point
+        selector = (
+            f"--color-flow-id={FLOW_ID}"
+            if role == capture.SELECTED_ROLE
+            else f"--helicity-id={HELICITY_ID}"
+        )
+        command = [
+            executable["path"],
+            "_sample",
+            f"--workload={role}",
+            f"--round={index}",
+            f"--momenta={fixture['path']}",
+            f"--source-revision={REVISION}",
+            selector,
+        ]
+        command_sha256 = capture._canonical_sha256(command)
+        stdout_payload = {
+            "kind": "amplicol-m0-probe-result",
+            "schema_version": 1,
+            "role": role,
+            "sample_index": index,
+            "evaluated_point_count": evaluated,
+            "elapsed_seconds": elapsed,
+            "seconds_per_point": seconds_per_point,
+            "selected_totals": values,
+            "resolved_sums": values,
+        }
+        stdout = capture._canonical_bytes(stdout_payload).decode() + "\n"
+        raw = capture._raw_sample(
+            role=role,
+            sample_index=index,
+            command_sha256=command_sha256,
+            stdout=stdout,
+            parsed=stdout_payload,
+        )
+        raw_ref = capture._write_json(
+            tmp_path / "raw" / f"{2 * index + offset:02d}-{role}.json",
+            raw,
+        )
+        start = 4 * index + 2 * offset
+        started = f"2026-07-26T01:00:{start:02d}+00:00"
+        finished = f"2026-07-26T01:00:{start + 1:02d}+00:00"
+        sample = {
+            "sample_index": index,
+            "interleave_round": index,
+            "interleave_position": 2 * index + offset,
+            "started_at_utc": started,
+            "finished_at_utc": finished,
+            "subprocess": True,
+            "command": command,
+            "command_sha256": command_sha256,
+            "evaluated_point_count": evaluated,
+            "elapsed_seconds": elapsed,
+            "seconds_per_point": seconds_per_point,
+            "interrupted": False,
+            "raw_output_file": raw_ref,
+        }
+        samples.append(sample)
+        projections.append(
+            {
+                "role": role,
+                "round": index,
+                "position": 2 * index + offset,
+                "started_at_utc": started,
+                "finished_at_utc": finished,
+                "command_sha256": command_sha256,
+            }
+        )
+    return samples, projections
+
+
+def test_generated_manifests_pass_the_real_m0_amplicol_validator(
+    tmp_path: Path,
+) -> None:
+    contract = _contract(tmp_path)
+    repository = tmp_path / "repository"
+    repository.mkdir()
+    for name, raw in (
+        ("amplicol_library_benchmark", b"selected"),
+        ("amplicol_color_probe", b"union"),
+        ("libamp_1.so", b"library"),
+    ):
+        path = repository / name
+        path.write_bytes(raw)
+        path.chmod(0o755)
+    _write_generated_library(repository)
+    process_file = tmp_path / "processes.txt"
+    process_file.write_text("process\n", encoding="utf-8")
+    context = replace(
+        capture._copy_runtime(repository, tmp_path / "capture", process_file),
+        group=11,
+        integral=7,
+        source_pdgs=(2, -2, 23, 21, 21, 21, 21, 21, 21),
+        generated_pdgs=(2, -2, 21, 21, 21, 21, 21, 21, 23),
+        generated_color_order=(2, 3, 4, 5, 6, 7, 8, 1, 9),
+        permutation=capture.AMPLICOL_EXTERNAL_LEG_PERMUTATION,
+    )
+    source = _source(tmp_path)
+    executable = capture._file_ref(context.worker_executable)
+    linked = [capture._file_ref(path) for path in context.linked_files]
+    binary_evidence = {
+        "executable": executable,
+        "linked_libraries": linked,
+        "source_files": list(source.source_files),
+    }
+    selected_values = capture._complex_pairs(contract.selected_values)
+    union_values = capture._complex_pairs(contract.union_values)
+    selected_samples, selected_projection = _role_samples(
+        tmp_path,
+        role=capture.SELECTED_ROLE,
+        executable=executable,
+        fixture=contract.fixture["file"],
+        values=selected_values,
+    )
+    union_samples, union_projection = _role_samples(
+        tmp_path,
+        role=capture.UNION_ROLE,
+        executable=executable,
+        fixture=contract.fixture["file"],
+        values=union_values,
+    )
+    evidence_paths = [
+        executable["path"],
+        *(row["path"] for row in linked),
+        *(row["path"] for row in source.source_files),
+    ]
+    assert len(evidence_paths) == len(set(evidence_paths))
+    assert capture._file_ref(context.process_file) in linked
+    combined = sorted(
+        [*selected_projection, *union_projection],
+        key=lambda row: row["position"],
+    )
+    interleave_sha256 = capture._interleave_group_sha256(combined)
+    assert interleave_sha256 == m0._amplicol_interleave_group_sha256(combined)
+
+    validated = {}
+    for role, samples, values in (
+        (capture.SELECTED_ROLE, selected_samples, contract.selected_values),
+        (capture.UNION_ROLE, union_samples, contract.union_values),
+    ):
+        manifest = capture._manifest(
+            role=role,
+            contract=contract,
+            context=context,
+            source=source,
+            binary_evidence=binary_evidence,
+            samples=samples,
+            interleave_group_sha256=interleave_sha256,
+            selected=values,
+            resolved=values,
+        )
+        path = tmp_path / f"{role}.json"
+        ref = capture._write_json(path, manifest)
+        m0_ref = m0._file_ref(ref, base=tmp_path, label=role)
+        loaded = m0._load_json_ref(m0_ref, role)
+        validated[role] = m0._validate_amplicol(
+            loaded,
+            role=role,
+            expected=contract.expected,
+        )
+
+    assert validated[capture.SELECTED_ROLE].timing["timing_boundary"] == (
+        "amplitude-evaluation"
+    )
+    assert validated[capture.UNION_ROLE].timing["timing_boundary"] == (
+        "direct-library-total"
+    )
+    assert (
+        validated[capture.SELECTED_ROLE].interleave_group_sha256
+        == validated[capture.UNION_ROLE].interleave_group_sha256
+        == interleave_sha256
+    )
+
+
+def test_capture_orchestrates_exactly_seven_selected_union_pairs(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    request = _write(tmp_path / "request-template.json", b"request\n")
+    contract = replace(
+        _contract(tmp_path),
+        input_files=(request,),
+    )
+    context = _context(tmp_path)
+    source = _source(tmp_path)
+    calls: list[tuple[str, int]] = []
+
+    monkeypatch.setattr(capture, "_contract_from_request", lambda _path: contract)
+    monkeypatch.setattr(capture, "_host_identity", lambda: HOST)
+    monkeypatch.setattr(
+        capture,
+        "_require_clean_revision",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(capture, "_prepare_probes", lambda **_kwargs: context)
+    monkeypatch.setattr(capture, "_source_evidence", lambda _repository: source)
+    monkeypatch.setattr(
+        capture.legacy_amplicol,
+        "validate_checkout",
+        lambda _repository: None,
+    )
+
+    def fake_run_sample(
+        _command: list[str],
+        *,
+        role: str,
+        round_index: int,
+        points: int,
+    ) -> tuple[str, dict[str, Any], str, str]:
+        calls.append((role, round_index))
+        position = len(calls) - 1
+        values = (
+            contract.selected_values
+            if role == capture.SELECTED_ROLE
+            else contract.union_values
+        )
+        elapsed = points * 4.0e-5 * (1.0 + round_index * 0.01)
+        payload = {
+            "kind": "amplicol-m0-probe-result",
+            "schema_version": 1,
+            "role": role,
+            "sample_index": round_index,
+            "evaluated_point_count": points,
+            "elapsed_seconds": elapsed,
+            "seconds_per_point": elapsed / points,
+            "selected_totals": capture._complex_pairs(values),
+            "resolved_sums": capture._complex_pairs(values),
+        }
+        stdout = capture._canonical_bytes(payload).decode() + "\n"
+        started = f"2026-07-26T02:00:{2 * position:02d}+00:00"
+        finished = f"2026-07-26T02:00:{2 * position + 1:02d}+00:00"
+        return stdout, payload, started, finished
+
+    monkeypatch.setattr(capture, "_run_sample_command", fake_run_sample)
+    output = tmp_path / "output"
+    arguments = SimpleNamespace(
+        request_template=Path(request["path"]),
+        repository=tmp_path / "repository",
+        output_directory=output,
+        jobs=1,
+        selected_points=1000,
+        union_points=2000,
+        warmup_points=100,
+        target_seconds=5.0,
+        minimum_points=100,
+        maximum_points=100_000,
+    )
+
+    index = capture._capture(arguments)
+
+    assert calls == [
+        (role, round_index)
+        for round_index in range(capture.MIN_SAMPLES)
+        for role in capture.ROLES
+    ]
+    assert index["complete"] is True
+    assert index["paired_round_count"] == capture.MIN_SAMPLES
+    assert index["evaluated_points"] == {
+        capture.SELECTED_ROLE: 1000,
+        capture.UNION_ROLE: 2000,
+    }
+    for role in capture.ROLES:
+        ref = index["amplicol_evidence"][role]
+        m0_ref = m0._file_ref(ref, base=output, label=role)
+        loaded = m0._load_json_ref(m0_ref, role)
+        evidence = m0._validate_amplicol(
+            loaded,
+            role=role,
+            expected=contract.expected,
+        )
+        assert evidence.interleave_group_sha256 == (index["interleave_group_sha256"])
+
+
+def test_sample_command_binds_all_required_physical_inputs(tmp_path: Path) -> None:
+    contract = _contract(tmp_path)
+    context = _context(tmp_path)
+
+    selected = capture._sample_command(
+        role=capture.SELECTED_ROLE,
+        round_index=3,
+        points=1234,
+        contract=contract,
+        context=context,
+    )
+    union = capture._sample_command(
+        role=capture.UNION_ROLE,
+        round_index=3,
+        points=4321,
+        contract=contract,
+        context=context,
+    )
+
+    for command, role in (
+        (selected, capture.SELECTED_ROLE),
+        (union, capture.UNION_ROLE),
+    ):
+        assert command[0] == str(context.worker_executable)
+        assert f"--workload={role}" in command
+        assert "--round=3" in command
+        assert f"--momenta={contract.fixture['path']}" in command
+        assert f"--source-revision={REVISION}" in command
+        assert f"--color-flow-word={','.join(map(str, FLOW_WORD))}" in command
+        assert f"--helicity-values={','.join(map(str, HELICITY_VALUES))}" in command
+        assert "--source-to-generated-permutation=0,1,3,4,5,6,7,8,2" in command
+    assert f"--color-flow-id={FLOW_ID}" in selected
+    assert f"--helicity-id={HELICITY_ID}" in union
+    assert capture._canonical_sha256(selected) != capture._canonical_sha256(union)
+
+
+def test_runtime_launcher_pins_interpreter_producer_and_probe_inputs(
+    tmp_path: Path,
+) -> None:
+    repository = tmp_path / "repository"
+    repository.mkdir()
+    for name, raw in (
+        ("amplicol_library_benchmark", b"selected"),
+        ("amplicol_color_probe", b"union"),
+        ("libamp_1.so", b"library"),
+    ):
+        path = repository / name
+        path.write_bytes(raw)
+        path.chmod(0o755)
+    source_amplitudes, source_data = _write_generated_library(repository)
+    process_file = tmp_path / "processes.txt"
+    process_file.write_text("process\n", encoding="utf-8")
+
+    context = capture._copy_runtime(
+        repository,
+        tmp_path / "capture",
+        process_file,
+    )
+
+    launcher = context.worker_executable.read_text(encoding="utf-8")
+    bundled_producer = (
+        context.runtime
+        / "python-src"
+        / "tools"
+        / "developer"
+        / "amplicol_z6g_m0_capture.py"
+    ).resolve()
+    assert launcher.startswith("#!/bin/sh\nexec ")
+    assert str(Path(sys.executable).resolve()) in launcher
+    assert " -I -S -B " in launcher
+    assert str(bundled_producer) in launcher
+    assert str(CAPTURE_SCRIPT) not in launcher
+    assert context.worker_executable.stat().st_mode & 0o111
+    assert Path(sys.executable).resolve() in context.linked_files
+    assert CAPTURE_SCRIPT not in context.linked_files
+    for relative in capture._SAMPLE_RUNTIME_RELATIVE_FILES:
+        copied = (context.runtime / "python-src" / relative).resolve()
+        assert copied.is_file()
+        assert copied in context.linked_files
+    assert context.process_file in context.linked_files
+    assert context.selected_binary in context.linked_files
+    assert context.union_binary in context.linked_files
+    for source in (source_amplitudes, source_data):
+        copied = (context.runtime / source.relative_to(repository)).resolve()
+        assert copied.read_bytes() == source.read_bytes()
+        assert copied in context.linked_files
+    assert len(context.linked_files) == len(set(context.linked_files))
+
+    completed = subprocess.run(
+        (str(context.worker_executable), "_sample", "--help"),
+        cwd=tmp_path,
+        env={**os.environ, "PYTHONPATH": ""},
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert completed.returncode == 0, completed.stderr
+    assert "usage:" in completed.stdout
+
+
+def test_selected_launcher_uses_snapshotted_generated_library_tree(
+    tmp_path: Path,
+) -> None:
+    repository = tmp_path / "repository"
+    repository.mkdir()
+    selected = repository / "amplicol_library_benchmark"
+    selected.write_text(
+        """#!/bin/sh
+set -eu
+test "$(cat Library/amplitudes.bin)" = amplitudes
+test "$(cat Library/nested/amp_1_lib.data)" = library-data
+cat <<'EOF'
+AMPICOL_SELECTED_FLOW_PROBE_VALUE 3 1 1.2500000000000000E+00
+AMPICOL_SELECTED_FLOW_PROBE_PDGS 9 2 -2 21 21 21 21 21 21 23
+AMPICOL_SELECTED_FLOW_PROBE_COLOR_ORDER 9 2 3 4 5 6 7 8 9 1
+AMPICOL_SELECTED_FLOW_PROBE_AMPLITUDES 4
+AMPICOL_SELECTED_FLOW_PROBE_COLOR_FACTOR 27
+AMPICOL_SELECTED_FLOW_PROBE_IDENTICAL_FACTOR 36
+AMPICOL_SELECTED_FLOW_PROBE_SINGLET_VERTICES 0
+AMPICOL_SELECTED_FLOW_PROBE_NORMALIZATION 1.0000000000000000E+00
+Timing summary
+amplitude evaluation 0.25
+EOF
+""",
+        encoding="utf-8",
+    )
+    selected.chmod(0o755)
+    union = repository / "amplicol_color_probe"
+    union.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8")
+    union.chmod(0o755)
+    (repository / "libamp_1.so").write_bytes(b"library")
+    _write_generated_library(repository)
+    process_file = tmp_path / "processes.txt"
+    process_file.write_text("process\n", encoding="utf-8")
+
+    source_pdgs = (2, -2, 23, 21, 21, 21, 21, 21, 21)
+    generated_pdgs = (2, -2, 21, 21, 21, 21, 21, 21, 23)
+    generated_color_order = (2, 3, 4, 5, 6, 7, 8, 9, 1)
+    context = replace(
+        capture._copy_runtime(repository, tmp_path / "capture", process_file),
+        group=3,
+        integral=1,
+        source_pdgs=source_pdgs,
+        generated_pdgs=generated_pdgs,
+        generated_color_order=generated_color_order,
+        permutation=capture.AMPLICOL_EXTERNAL_LEG_PERMUTATION,
+    )
+    fixture_path = tmp_path / "momenta.json"
+    fixture_path.write_text(
+        json.dumps(
+            {
+                "kind": "pyamplicol-rusticol-validation-momenta",
+                "schema_version": 1,
+                "process": capture.NORMALIZED_PROCESS,
+                "points": [
+                    [
+                        {
+                            "pdg": pdg,
+                            "momentum": [float(index + 1), 0.0, 0.0, 0.0],
+                        }
+                        for index, pdg in enumerate(source_pdgs)
+                    ]
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+    parsed_pdgs, points = capture._fixture_points(fixture_path)
+    assert parsed_pdgs == source_pdgs
+    fixture_ref = capture._file_ref(fixture_path)
+    base_contract = _contract(tmp_path / "contract")
+    expected = dict(base_contract.expected)
+    expected["amplicol_source_revision"] = capture.legacy_amplicol.expected_revision()
+    expected["momenta_points_sha256"] = capture._canonical_sha256(points)
+    contract = replace(
+        base_contract,
+        expected=expected,
+        fixture={
+            "path": fixture_path,
+            "file": fixture_ref,
+            "point_count": 1,
+            "points_sha256": expected["momenta_points_sha256"],
+        },
+    )
+
+    completed = subprocess.run(
+        capture._sample_command(
+            role=capture.SELECTED_ROLE,
+            round_index=0,
+            points=5,
+            contract=contract,
+            context=context,
+        ),
+        cwd=tmp_path,
+        env={**os.environ, "PYTHONPATH": ""},
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert completed.returncode == 0, completed.stderr
+    payload = json.loads(completed.stdout)
+    assert payload["selected_totals"] == [[1.25, 0.0]]
+    assert payload["resolved_sums"] == [[1.25, 0.0]]
+
+
+def test_executable_row_authentication_accepts_serialized_color_reorder() -> None:
+    source_pdgs = (2, -2, 23, 21, 21, 21, 21, 21, 21)
+    generated_pdgs = (2, -2, 21, 21, 21, 21, 21, 21, 23)
+    requested = capture.legacy_amplicol.ProcessEntry(
+        group=3,
+        integral=1,
+        process_pdgs=generated_pdgs,
+        color_order=(2, 3, 4, 5, 6, 7, 8, 1, 9),
+    )
+    emitted = SimpleNamespace(
+        group=3,
+        integral=1,
+        process_pdgs=generated_pdgs,
+        color_order=(2, 3, 4, 5, 6, 7, 8, 9, 1),
+    )
+
+    executable, permutation = capture._validated_executable_row(
+        requested_entry=requested,
+        emitted_probe=emitted,
+        source_pdgs=source_pdgs,
+        expected_flow_word=FLOW_WORD,
+        expected_permutation=capture.AMPLICOL_EXTERNAL_LEG_PERMUTATION,
+    )
+
+    assert executable.color_order == emitted.color_order
+    assert executable.color_order != requested.color_order
+    assert permutation == capture.AMPLICOL_EXTERNAL_LEG_PERMUTATION
+
+
+def test_sample_runtime_inventory_covers_every_imported_legacy_oracle_module() -> None:
+    expected = {
+        path.relative_to(ROOT)
+        for path in (ROOT / "tools" / "developer" / "legacy_oracle").glob("*.py")
+    }
+    assert expected <= set(capture._SAMPLE_RUNTIME_RELATIVE_FILES)
+
+
+def test_copied_helper_tampering_is_detected(tmp_path: Path) -> None:
+    repository = tmp_path / "repository"
+    repository.mkdir()
+    for name in (
+        "amplicol_library_benchmark",
+        "amplicol_color_probe",
+        "libamp_1.so",
+    ):
+        path = repository / name
+        path.write_bytes(name.encode())
+        path.chmod(0o755)
+    _write_generated_library(repository)
+    process_file = tmp_path / "processes.txt"
+    process_file.write_text("process\n", encoding="utf-8")
+    context = capture._copy_runtime(repository, tmp_path / "capture", process_file)
+    identities = tuple(capture._file_ref(path) for path in context.linked_files)
+    helper = (
+        context.runtime / "python-src" / "tools" / "developer" / "legacy_amplicol.py"
+    )
+    helper.write_text(
+        helper.read_text(encoding="utf-8") + "\n# adversarial drift\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(capture.CaptureError, match="capture input drifted"):
+        capture._verify_immutable_files(identities)
+
+
+def test_clean_revision_gate_rejects_revision_and_untracked_drift(
+    tmp_path: Path,
+) -> None:
+    repository, revision = _git_repository(tmp_path / "repository")
+
+    capture._require_clean_revision(
+        repository,
+        expected_revision=revision,
+        label="test checkout",
+    )
+    with pytest.raises(capture.CaptureError, match="revision differs"):
+        capture._require_clean_revision(
+            repository,
+            expected_revision="0" * 40,
+            label="test checkout",
+        )
+
+    (repository / "untracked.txt").write_text("drift\n", encoding="utf-8")
+    with pytest.raises(capture.CaptureError, match="tracked or untracked"):
+        capture._require_clean_revision(
+            repository,
+            expected_revision=revision,
+            label="test checkout",
+        )
+
+
+def test_prepare_probes_rejects_untracked_checkout_before_build(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repository, revision = _git_repository(tmp_path / "amplicol")
+    (repository / "untracked-before-build.txt").write_text(
+        "drift\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        capture.legacy_amplicol,
+        "prepare_checkout",
+        lambda _repository: None,
+    )
+    monkeypatch.setattr(
+        capture.legacy_amplicol,
+        "expected_revision",
+        lambda: revision,
+    )
+
+    with pytest.raises(capture.CaptureError, match="tracked or untracked"):
+        capture._prepare_probes(
+            repository=repository,
+            output=tmp_path / "output",
+            fixture_path=tmp_path / "not-read-before-cleanliness.json",
+            expected_flow_word=FLOW_WORD,
+            expected_permutation=capture.AMPLICOL_EXTERNAL_LEG_PERMUTATION,
+            jobs=1,
+        )
+
+
+def test_capture_rejects_current_source_revision_and_cleanliness_drift(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repository, revision = _git_repository(tmp_path / "pyamplicol")
+    request = tmp_path / "request.json"
+    request.write_text("{}\n", encoding="utf-8")
+    base_contract = _contract(tmp_path)
+    monkeypatch.setattr(capture, "ROOT", repository)
+    prepared = False
+
+    def unexpected_prepare(**_kwargs: Any) -> None:
+        nonlocal prepared
+        prepared = True
+        raise AssertionError("probe preparation must not run")
+
+    monkeypatch.setattr(capture, "_prepare_probes", unexpected_prepare)
+
+    def arguments(output: str) -> SimpleNamespace:
+        return SimpleNamespace(
+            request_template=request,
+            repository=tmp_path / "amplicol",
+            output_directory=tmp_path / output,
+        )
+
+    wrong_expected = dict(base_contract.expected)
+    wrong_expected["pyamplicol_source_revision"] = "0" * 40
+    monkeypatch.setattr(
+        capture,
+        "_contract_from_request",
+        lambda _path: replace(base_contract, expected=wrong_expected),
+    )
+    with pytest.raises(capture.CaptureError, match="revision differs"):
+        capture._capture(arguments("wrong-revision"))
+    assert prepared is False
+
+    clean_expected = dict(base_contract.expected)
+    clean_expected["pyamplicol_source_revision"] = revision
+    monkeypatch.setattr(
+        capture,
+        "_contract_from_request",
+        lambda _path: replace(base_contract, expected=clean_expected),
+    )
+    (repository / "untracked-current-source.txt").write_text(
+        "drift\n",
+        encoding="utf-8",
+    )
+    with pytest.raises(capture.CaptureError, match="tracked or untracked"):
+        capture._capture(arguments("dirty-source"))
+    assert prepared is False
+
+
+def test_process_generation_subprocess_receives_lowercase_z(
+    tmp_path: Path,
+) -> None:
+    process_payload = (
+        "9 1\n"
+        "2 -2 21 21 21 21 21 21 23\n"
+        "\n"
+        "\n"
+        "1\n"
+        "\n"
+        "1 1 1 1 9 2 3 4 5 6 7 8\n"
+        "1 1 2 -2 21 21 21 21 21 21 23 "
+        "2 3 4 5 6 7 8 1 9 720.0\n"
+        "\n"
+        "\n"
+    )
+    repository = tmp_path / "case-sensitive-amplicol"
+    repository.mkdir()
+    process_list = repository / "process_list.py"
+    process_list.write_text(
+        "\n".join(
+            (
+                "import json",
+                "import sys",
+                "from pathlib import Path",
+                "arguments = sys.argv[1:]",
+                "Path('received.json').write_text(json.dumps(arguments))",
+                (f"if arguments != ['--serial', {capture.NORMALIZED_PROCESS!r}]:"),
+                "    raise SystemExit(19)",
+                f"Path('processes.txt').write_text({process_payload!r})",
+            )
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    setup = tmp_path / "setup"
+    setup.mkdir()
+
+    generated = capture._generate_process_file(
+        repository=repository,
+        setup=setup,
+        log_path=setup / "generation.log",
+    )
+
+    assert generated == setup / "processes.txt"
+    assert generated.read_text(encoding="utf-8") == process_payload
+    assert json.loads((setup / "received.json").read_text(encoding="utf-8")) == [
+        "--serial",
+        "u u~ > z g g g g g g",
+    ]
+    assert " Z " in f" {capture.PROCESS_EXPRESSION} "
+    source_pdgs = capture.legacy_amplicol.process_pdgs(capture.NORMALIZED_PROCESS)
+    entry, matches = capture.legacy_amplicol.select_generated_process_entry(
+        capture.legacy_amplicol.parse_process_file(generated),
+        generated_process=capture.NORMALIZED_PROCESS,
+        wanted_pdgs=source_pdgs,
+    )
+    assert len(matches) == 1
+    assert (
+        capture.legacy_amplicol._permutation(
+            source_pdgs,
+            entry.process_pdgs,
+        )
+        == capture.AMPLICOL_EXTERNAL_LEG_PERMUTATION
+    )
+    mapped = capture.legacy_amplicol.source_mapped_color_order(
+        entry,
+        source_pdgs=source_pdgs,
+    )
+    colored_labels = {
+        index
+        for index, pdg in enumerate(source_pdgs, start=1)
+        if abs(pdg) == 21 or 1 <= abs(pdg) <= 6
+    }
+    assert [label for label in mapped if label in colored_labels] == FLOW_WORD
+
+
+def test_probe_stdout_is_strict_and_identity_bound() -> None:
+    payload = {
+        "kind": "amplicol-m0-probe-result",
+        "schema_version": 1,
+        "role": capture.SELECTED_ROLE,
+        "sample_index": 2,
+        "evaluated_point_count": 100,
+        "elapsed_seconds": 0.5,
+        "seconds_per_point": 0.005,
+        "selected_totals": [[1.0, 0.0]],
+        "resolved_sums": [[1.0, 0.0]],
+    }
+    stdout = capture._canonical_bytes(payload).decode() + "\n"
+    assert (
+        capture._parse_probe_stdout(
+            stdout,
+            role=capture.SELECTED_ROLE,
+            sample_index=2,
+            evaluated_points=100,
+        )
+        == payload
+    )
+
+    payload["unexpected"] = True
+    with pytest.raises(capture.CaptureError, match="unknown or missing"):
+        capture._parse_probe_stdout(
+            json.dumps(payload),
+            role=capture.SELECTED_ROLE,
+            sample_index=2,
+            evaluated_points=100,
+        )
+    with pytest.raises(capture.CaptureError, match="duplicate JSON key"):
+        capture._parse_probe_stdout(
+            '{"kind":"x","kind":"y"}',
+            role=capture.SELECTED_ROLE,
+            sample_index=2,
+            evaluated_points=100,
+        )
+
+
+def test_timing_boundaries_and_adaptive_count_fail_closed() -> None:
+    output = """\
+Timing summary
+generation setup 1.25
+amplitude evaluation 0.5
+total 2.0
+"""
+    assert capture._timing_value(output, "amplitude evaluation") == 0.5
+    assert capture._timing_value(output, "total") == 2.0
+    assert (
+        capture._adaptive_points(
+            0.5,
+            warmup_points=100,
+            target_seconds=5.0,
+            minimum_points=100,
+            maximum_points=10_000,
+        )
+        == 1000
+    )
+    with pytest.raises(capture.CaptureError, match="positive finite"):
+        capture._adaptive_points(
+            0.0,
+            warmup_points=100,
+            target_seconds=5.0,
+            minimum_points=100,
+            maximum_points=10_000,
+        )
+    with pytest.raises(capture.CaptureError, match="no unique"):
+        capture._timing_value("Timing summary\nother 1.0\n", "total")
diff --git a/pyamplicol/tests/unit/test_analytic_oracles.py b/pyamplicol/tests/unit/test_analytic_oracles.py
new file mode 100644
index 0000000000..710b7fd2ec
--- /dev/null
+++ b/pyamplicol/tests/unit/test_analytic_oracles.py
@@ -0,0 +1,274 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from decimal import Decimal, localcontext
+
+import pytest
+
+from tools.developer.analytic_oracles import (
+    AnalyticOracleError,
+    chiral_current_2to1,
+    scalar_contact_2to2,
+    scalar_gravity_2to2,
+)
+
+
+def _point(px: str, pz: str) -> tuple[tuple[Decimal, ...], ...]:
+    """Construct an exact rational massless 2->2 point."""
+
+    energy = Decimal("500")
+    x = Decimal(px)
+    z = Decimal(pz)
+    zero = Decimal("0")
+    return (
+        (energy, zero, zero, energy),
+        (energy, zero, zero, -energy),
+        (energy, x, zero, z),
+        (energy, -x, zero, -z),
+    )
+
+
+def _chiral_point() -> tuple[tuple[Decimal, ...], ...]:
+    zero = Decimal("0")
+    five = Decimal("5")
+    ten = Decimal("10")
+    return (
+        (five, zero, zero, five),
+        (five, zero, zero, -five),
+        (ten, zero, zero, zero),
+    )
+
+
+def test_scalar_contact_oracle_includes_identical_particle_factor() -> None:
+    assert scalar_contact_2to2().total == Decimal("0.5")
+    assert scalar_contact_2to2(Decimal("3")).total == Decimal("4.5")
+    assert scalar_contact_2to2().helicity_ids == ("h:+0,+0,+0,+0",)
+
+
+def test_oracle_metadata_separates_precision_from_certified_accuracy() -> None:
+    contact = scalar_contact_2to2(
+        Decimal("0.1234567890123456789"),
+        precision=60,
+        certified_accuracy_digits=24,
+    )
+    gravity = scalar_gravity_2to2(
+        _point("300", "400"),
+        precision=80,
+        certified_accuracy_digits=30,
+    )
+
+    assert contact.metadata.arithmetic_precision_decimal_digits == 60
+    assert contact.metadata.certified_accuracy_decimal_digits == 24
+    assert contact.metadata.kinematic_validation_relative_tolerance is None
+    assert gravity.metadata.arithmetic_precision_decimal_digits == 80
+    assert gravity.metadata.certified_accuracy_decimal_digits == 30
+    assert gravity.metadata.kinematic_validation_relative_tolerance == Decimal("1e-33")
+
+
+@pytest.mark.parametrize(
+    ("point", "expected"),
+    (
+        (_point("500", "0"), Decimal("3906250000")),
+        (_point("300", "400"), Decimal("506250000")),
+        (_point("400", "300"), Decimal("1600000000")),
+    ),
+)
+def test_scalar_gravity_oracle_matches_exact_kinematic_values(
+    point: tuple[tuple[Decimal, ...], ...], expected: Decimal
+) -> None:
+    observation = scalar_gravity_2to2(point)
+
+    assert observation.total == expected
+    assert observation.helicity_ids == (
+        "h:+0,+0,-2,-2",
+        "h:+0,+0,-2,+2",
+        "h:+0,+0,+2,-2",
+        "h:+0,+0,+2,+2",
+    )
+    assert observation.resolved == (
+        Decimal("0"),
+        expected / 2,
+        expected / 2,
+        Decimal("0"),
+    )
+    assert sum(observation.resolved, Decimal("0")) == observation.total
+
+
+def test_scalar_gravity_oracle_has_quartic_coupling_scaling() -> None:
+    baseline = scalar_gravity_2to2(_point("300", "400"))
+    scaled = scalar_gravity_2to2(_point("300", "400"), Decimal("2"))
+
+    assert scaled.total == 16 * baseline.total
+
+
+def test_chiral_current_oracle_exposes_leg_and_helicity_swaps() -> None:
+    observation = chiral_current_2to1(
+        _chiral_point(),
+        vector_mass=Decimal("10"),
+        left_coupling=Decimal("2"),
+        right_coupling=Decimal("3"),
+        certified_accuracy_digits=30,
+    )
+
+    assert observation.total == Decimal("2600")
+    assert observation.resolved_by_helicity == (
+        ("h:-1,+1,-1", Decimal("800")),
+        ("h:+1,-1,+1", Decimal("1800")),
+    )
+    assert all(value != 0 for value in observation.resolved)
+    assert observation.resolved[0] != observation.resolved[1]
+
+    swapped_values = tuple(reversed(observation.resolved))
+    assert swapped_values != observation.resolved
+    assert dict(zip(observation.helicity_ids, swapped_values, strict=True)) != dict(
+        observation.resolved_by_helicity
+    )
+
+
+def test_scalar_gravity_oracle_constructs_exact_redundant_invariant() -> None:
+    exact_point = _point("300", "400")
+    below_default_tolerance = list(exact_point)
+    below_default_tolerance[3] = (
+        *below_default_tolerance[3][:-1],
+        below_default_tolerance[3][-1] + Decimal("1e-20"),
+    )
+
+    exact = scalar_gravity_2to2(exact_point)
+    projected = scalar_gravity_2to2(tuple(below_default_tolerance))
+
+    assert projected.total == exact.total
+    with pytest.raises(AnalyticOracleError, match="not massless"):
+        scalar_gravity_2to2(
+            tuple(below_default_tolerance),
+            precision=60,
+            certified_accuracy_digits=30,
+        )
+
+
+def test_mass_shell_tolerance_tracks_certified_accuracy() -> None:
+    point = list(_point("300", "400"))
+    defect = Decimal("1e-20")
+    point[2] = (*point[2][:-1], point[2][-1] + defect)
+    point[3] = (*point[3][:-1], point[3][-1] - defect)
+
+    scalar_gravity_2to2(tuple(point), certified_accuracy_digits=12)
+    with pytest.raises(AnalyticOracleError, match="not massless"):
+        scalar_gravity_2to2(tuple(point), precision=60, certified_accuracy_digits=30)
+
+
+def test_momentum_conservation_tolerance_tracks_certified_accuracy() -> None:
+    point = _point("300", "400")
+    with localcontext() as context:
+        context.prec = 80
+        factor = Decimal("1.00000000000000000001")
+        scaled_outgoing = tuple(
+            tuple(+(component * factor) for component in momentum)
+            for momentum in point[2:]
+        )
+    defect_point = (*point[:2], *scaled_outgoing)
+
+    scalar_gravity_2to2(defect_point, certified_accuracy_digits=12)
+    with pytest.raises(AnalyticOracleError, match="do not conserve"):
+        scalar_gravity_2to2(defect_point, precision=60, certified_accuracy_digits=30)
+
+
+def test_scalar_gravity_oracle_rejects_invalid_kinematics() -> None:
+    with pytest.raises(AnalyticOracleError, match="four external momenta"):
+        scalar_gravity_2to2(_point("300", "400")[:3])
+
+    off_shell = list(_point("300", "400"))
+    off_shell[2] = (*off_shell[2][:-1], Decimal("401"))
+    with pytest.raises(AnalyticOracleError, match="not massless"):
+        scalar_gravity_2to2(tuple(off_shell))
+
+    nonconserving = list(_point("300", "400"))
+    nonconserving[3] = (
+        Decimal("500"),
+        Decimal("-400"),
+        Decimal("0"),
+        Decimal("-300"),
+    )
+    with pytest.raises(AnalyticOracleError, match="do not conserve"):
+        scalar_gravity_2to2(tuple(nonconserving))
+
+
+@pytest.mark.parametrize("nonfinite", ("NaN", "Infinity", "-Infinity"))
+def test_scalar_gravity_oracle_rejects_nonfinite_inputs(nonfinite: str) -> None:
+    point = list(_point("300", "400"))
+    point[2] = (Decimal(nonfinite), *point[2][1:])
+
+    with pytest.raises(AnalyticOracleError, match="must be finite"):
+        scalar_gravity_2to2(tuple(point))
+    with pytest.raises(AnalyticOracleError, match="coupling must be finite"):
+        scalar_gravity_2to2(_point("300", "400"), Decimal(nonfinite))
+
+
+@pytest.mark.parametrize(
+    ("precision", "accuracy", "message"),
+    (
+        (True, 12, "precision must be an integer"),
+        (31, 12, "precision must be at least 32"),
+        (40, True, "certified accuracy must be an integer"),
+        (40, 0, "certified accuracy must be positive"),
+        (40, 33, "must leave at least 8 arithmetic guard digits"),
+    ),
+)
+def test_oracles_reject_invalid_precision_policy(
+    precision: int, accuracy: int, message: str
+) -> None:
+    with pytest.raises(AnalyticOracleError, match=message):
+        scalar_gravity_2to2(
+            _point("300", "400"),
+            precision=precision,
+            certified_accuracy_digits=accuracy,
+        )
+
+
+def test_oracles_do_not_inherit_ambient_decimal_precision() -> None:
+    coupling = Decimal("0.12345678901234567890123456789")
+    with localcontext() as context:
+        context.prec = 6
+        contact_under_low_context = scalar_contact_2to2(
+            coupling, precision=50, certified_accuracy_digits=20
+        )
+        gravity_under_low_context = scalar_gravity_2to2(
+            _point("300", "400"),
+            coupling,
+            precision=50,
+            certified_accuracy_digits=20,
+        )
+    with localcontext() as context:
+        context.prec = 28
+        contact_under_default_context = scalar_contact_2to2(
+            coupling, precision=50, certified_accuracy_digits=20
+        )
+        gravity_under_default_context = scalar_gravity_2to2(
+            _point("300", "400"),
+            coupling,
+            precision=50,
+            certified_accuracy_digits=20,
+        )
+
+    assert contact_under_low_context == contact_under_default_context
+    assert gravity_under_low_context == gravity_under_default_context
+
+
+def test_scalar_gravity_oracle_uses_requested_arithmetic_precision() -> None:
+    point = _point("300", "400")
+    coupling = Decimal("0.1234567890123456789")
+    low = scalar_gravity_2to2(point, coupling, precision=40)
+    high = scalar_gravity_2to2(point, coupling, precision=100)
+
+    assert len(str(high.total)) > len(str(low.total))
+    assert low.metadata.arithmetic_precision_decimal_digits == 40
+    assert high.metadata.arithmetic_precision_decimal_digits == 100
+
+
+def test_chiral_current_rejects_wrong_vector_mass() -> None:
+    with pytest.raises(AnalyticOracleError, match="off shell"):
+        chiral_current_2to1(
+            _chiral_point(),
+            vector_mass=Decimal("11"),
+            left_coupling=Decimal("2"),
+            right_coupling=Decimal("3"),
+        )
diff --git a/pyamplicol/tests/unit/test_api_bundle.py b/pyamplicol/tests/unit/test_api_bundle.py
new file mode 100644
index 0000000000..30bbed2664
--- /dev/null
+++ b/pyamplicol/tests/unit/test_api_bundle.py
@@ -0,0 +1,320 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import os
+import runpy
+import shutil
+import subprocess
+import sys
+from decimal import Decimal
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.artifacts.api_bundle import (
+    api_bundle_payloads,
+    format_validation_points,
+)
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def test_api_bundle_has_one_complete_root_layout() -> None:
+    payloads = api_bundle_payloads(
+        {
+            "ddbar_to_zg": (
+                (500.0, 0.0, 0.0, 500.0),
+                (500.0, 0.0, 0.0, -500.0),
+                (Decimal("500.0"), "1.25", 2, -3),
+                (500.0, -1.25, -2.0, 3.0),
+            )
+        }
+    )
+    assert {payload.path for payload in payloads} == {
+        "API/validation_points.dat",
+        "API/python/check_standalone.py",
+        "API/c/check_standalone.c",
+        "API/c/Makefile",
+        "API/cpp/check_standalone.cpp",
+        "API/cpp/Makefile",
+        "API/fortran/check_standalone.f90",
+        "API/fortran/Makefile",
+        "API/rust/check_standalone.rs",
+        "API/rust/Makefile",
+        "API/umami/Makefile",
+        "API/umami/umami.h",
+        "API/umami/umami_provider.h",
+        "API/umami/umami.c",
+        "API/umami/umami_driver.c",
+        "API/umami/umami.exports",
+        "API/umami/umami.exports.macos",
+        "API/umami/UMAMI_LICENSE",
+        "API/umami/README.md",
+    }
+    python = next(payload for payload in payloads if payload.path.endswith(".py"))
+    assert python.executable is True
+    point = next(payload for payload in payloads if payload.path.endswith(".dat"))
+    assert point.content.startswith(b"RUSTICOL_VALIDATION_POINTS_V1\n")
+    assert b"ddbar_to_zg\t4\t" in point.content
+    makefiles = {
+        payload.path: payload.content.decode("utf-8")
+        for payload in payloads
+        if payload.path.endswith("Makefile")
+    }
+    assert all("/.pyamplicol-api-build/" in text for text in makefiles.values())
+    assert all(
+        'cd "$(ARTIFACT_DIR)"' in text
+        for path, text in makefiles.items()
+        if path != "API/umami/Makefile"
+    )
+    assert all("API/cpp/check_standalone" not in text for text in makefiles.values())
+    assert "CC ?= cc" in makefiles["API/c/Makefile"]
+    assert "CXX ?= c++" in makefiles["API/cpp/Makefile"]
+    assert "ifeq ($(origin FC), default)" in makefiles["API/fortran/Makefile"]
+    assert "FC ?= gfortran" in makefiles["API/fortran/Makefile"]
+    rust_makefile = makefiles["API/rust/Makefile"]
+    assert "RUSTC ?= rustc" in rust_makefile
+    assert '"$(RUSTICOL_CONFIG_PATH)" --rust-source' in rust_makefile
+    assert '"$(RUSTICOL_CONFIG_PATH)" --rustflags' in rust_makefile
+    assert '"$(RUSTICOL_CONFIG_PATH)" --cargo-rustflags' in rust_makefile
+    assert ".venv/bin/rusticol-config" in rust_makefile
+    assert "rusticol-config is unavailable" in rust_makefile
+    assert "RUSTICOL_RUST_SOURCE" in rust_makefile
+    assert "CARGO_ENCODED_RUSTFLAGS" in rust_makefile
+    assert "run-script:" in rust_makefile
+    assert "TARGET := $(BUILD_DIR)/check_standalone" in rust_makefile
+    assert "$(RUSTC) --edition=2021" in rust_makefile
+    assert "\tcargo " not in rust_makefile.lower()
+    assert "Cargo.toml" not in rust_makefile
+
+    rust_source = next(
+        payload.content.decode("utf-8")
+        for payload in payloads
+        if payload.path == "API/rust/check_standalone.rs"
+    )
+    assert "#!/usr/bin/env rust-script" in rust_source
+    assert 'include!(env!("RUSTICOL_RUST_SOURCE"))' in rust_source
+    assert "Runtime::load" in rust_source
+    assert "Selectors::all()" in rust_source
+    assert ".set_model_parameters(&options.overrides)" in rust_source
+    assert "--kinematics" in rust_source
+    assert ".representative_process_key()" in rust_source
+    assert ".external_permutation()" in rust_source
+    assert ".load_kinematics_json(" in rust_source
+    assert ".evaluate_f64(&momenta, 1)" in rust_source
+    assert ".evaluate_resolved_f64(&momenta, 1" in rust_source
+    assert r"\"language\":\"rust\"" in rust_source
+    assert "unsafe" not in rust_source
+    assert 'extern "C"' not in rust_source
+    assert "rusticol_runtime_" not in rust_source
+    assert "extern crate" not in rust_source
+    assert "serde" not in rust_source
+
+    umami_makefile = makefiles["API/umami/Makefile"]
+    assert "include providers.mk" in umami_makefile
+    assert "libumami.so" in umami_makefile
+    assert '"$(RUSTICOL_CONFIG_PATH)" --cflags' in umami_makefile
+    assert '"$(RUSTICOL_CONFIG_PATH)" --libs' in umami_makefile
+    # UMAMI receives the absolute artifact path explicitly. Keep the caller's
+    # working directory so an overridden relative BUILD_DIR remains valid.
+    assert '\t"$(RUN_DRIVER)" "$(ARTIFACT_DIR)" $(ARGS)' in umami_makefile
+    assert 'cd "$(ARTIFACT_DIR)"' not in umami_makefile
+
+    c_source = next(
+        payload.content.decode("utf-8")
+        for payload in payloads
+        if payload.path == "API/c/check_standalone.c"
+    )
+    assert "#include <rusticol.h>" in c_source
+    assert "rusticol_runtime_load" in c_source
+    assert "rusticol_runtime_evaluate_f64" in c_source
+    assert "rusticol_runtime_evaluate_resolved_f64" in c_source
+    assert "rusticol_runtime_representative_process_key" in c_source
+    assert "rusticol_runtime_external_permutation" in c_source
+    assert "rusticol_runtime_load_kinematics_json" in c_source
+
+    # Emitted drivers import the installed SDK instead of duplicating its
+    # warm-up ABI; updating construction options must not change lazy defaults.
+    cpp_source = next(
+        payload.content.decode("utf-8")
+        for payload in payloads
+        if payload.path == "API/cpp/check_standalone.cpp"
+    )
+    fortran_source = next(
+        payload.content.decode("utf-8")
+        for payload in payloads
+        if payload.path == "API/fortran/check_standalone.f90"
+    )
+    assert "#include <rusticol.hpp>" in cpp_source
+    assert "use rusticol" in fortran_source
+    for source in (c_source, cpp_source, fortran_source, rust_source):
+        assert "warm_up(" not in source
+        assert "warm_up_f64(" not in source
+
+    for payload in payloads:
+        if "check_standalone" in payload.path:
+            assert b"--kinematics" in payload.content
+
+
+def _write_api_bundle(root: Path) -> Path:
+    api = root / "artifact/API"
+    for payload in api_bundle_payloads():
+        target = root / "artifact" / payload.path
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes(payload.content)
+        if payload.executable:
+            target.chmod(0o755)
+    (api / "umami/providers.mk").write_text(
+        "UMAMI_PROVIDERS := p0\nUMAMI_SINGLE_PROVIDER := 1\n", encoding="ascii"
+    )
+    (api / "umami/provider_p0.h").write_text(
+        "/* dry-run fixture; real providers are generated per artifact */\n",
+        encoding="ascii",
+    )
+    return api
+
+
+def _write_sdk_config(path: Path, marker: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    library = path.parent / "lib-fixture.a"
+    library.write_bytes(b"")
+    path.write_text(
+        "#!/bin/sh\n"
+        'case "$1" in\n'
+        f"  --cflags) printf '%s\\n' '-I/{marker}/include' ;;\n"
+        f"  --libs) printf '%s\\n' '/{marker}/lib.a' ;;\n"
+        f"  --library) printf '%s\\n' '{library}' ;;\n"
+        f"  --fortran-source) printf '%s\\n' '/{marker}/rusticol.f90' ;;\n"
+        f"  --rust-source) printf '%s\\n' '/{marker}/rusticol.rs' ;;\n"
+        f"  --rustflags) printf '%s\\n' '-L /{marker}' ;;\n"
+        f"  --cargo-rustflags) printf '%s\\n' '-L{marker}' ;;\n"
+        "  *) exit 2 ;;\n"
+        "esac\n",
+        encoding="ascii",
+    )
+    path.chmod(0o755)
+
+
+def test_api_makefiles_find_source_checkout_sdk_without_activated_path(
+    tmp_path: Path,
+) -> None:
+    make = shutil.which("make")
+    if make is None:
+        pytest.skip("make is unavailable")
+    checkout = tmp_path / "checkout"
+    api = _write_api_bundle(checkout / "examples")
+    _write_sdk_config(checkout / ".venv/bin/rusticol-config", "ancestor-sdk")
+    environment = os.environ.copy()
+    environment["PATH"] = "/usr/bin:/bin"
+    environment.pop("RUSTICOL_CONFIG", None)
+
+    outputs: dict[str, str] = {}
+    for language in ("c", "cpp", "fortran", "rust", "umami"):
+        completed = subprocess.run(
+            [make, "-n", "-C", str(api / language)],
+            check=False,
+            capture_output=True,
+            text=True,
+            env=environment,
+            timeout=20,
+        )
+        assert completed.returncode == 0, completed.stderr
+        outputs[language] = completed.stdout
+    assert "/ancestor-sdk/include" in outputs["c"]
+    assert "/ancestor-sdk/include" in outputs["cpp"]
+    assert "/ancestor-sdk/rusticol.f90" in outputs["fortran"]
+    assert "/ancestor-sdk/rusticol.rs" in outputs["rust"]
+    assert "/ancestor-sdk/include" in outputs["umami"]
+    assert "libumami.so" in outputs["umami"]
+
+    override = tmp_path / "override-rusticol-config"
+    _write_sdk_config(override, "explicit-sdk")
+    completed = subprocess.run(
+        [make, "-n", "-C", str(api / "c"), f"RUSTICOL_CONFIG={override}"],
+        check=False,
+        capture_output=True,
+        text=True,
+        env=environment,
+        timeout=20,
+    )
+    assert completed.returncode == 0, completed.stderr
+    assert "/explicit-sdk/include" in completed.stdout
+    assert "/ancestor-sdk/include" not in completed.stdout
+
+    isolated_api = _write_api_bundle(tmp_path / "isolated")
+    missing = subprocess.run(
+        [make, "-n", "-C", str(isolated_api / "c")],
+        check=False,
+        capture_output=True,
+        text=True,
+        env=environment,
+        timeout=20,
+    )
+    assert missing.returncode != 0
+    assert "rusticol-config is unavailable" in missing.stderr
+    assert "rusticol.h" not in missing.stderr
+
+
+def test_python_api_driver_reexecutes_nearest_source_checkout_python(
+    tmp_path: Path,
+) -> None:
+    checkout = tmp_path / "checkout"
+    api = _write_api_bundle(checkout / "examples")
+    record = checkout / "reexec-argv.txt"
+    python = checkout / ".venv/bin/python"
+    python.parent.mkdir(parents=True)
+    python.write_text(
+        "#!/bin/sh\nprintf '%s\\n' \"$@\" > " + repr(os.fspath(record)) + "\n",
+        encoding="ascii",
+    )
+    python.chmod(0o755)
+    _write_sdk_config(checkout / ".venv/bin/rusticol-config", "ancestor-sdk")
+    environment = os.environ.copy()
+    environment.pop("_PYAMPLICOL_API_BOOTSTRAP", None)
+    completed = subprocess.run(
+        [
+            sys.executable,
+            "-I",
+            "-S",
+            str(api / "python/check_standalone.py"),
+            "--help",
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+        env=environment,
+        timeout=20,
+    )
+    assert completed.returncode == 0, completed.stderr
+    assert record.read_text(encoding="utf-8").splitlines() == [
+        str((api / "python/check_standalone.py").resolve()),
+        "--help",
+    ]
+
+
+def test_validation_points_are_sorted_and_require_four_vectors() -> None:
+    output = format_validation_points(
+        {
+            "second": ((1, 2, 3, 4),),
+            "first": ((5, 6, 7, 8),),
+        }
+    ).decode("ascii")
+    assert output.splitlines()[1].startswith("first\t")
+    assert output.splitlines()[2].startswith("second\t")
+    with pytest.raises(ValueError, match="four-vectors"):
+        format_validation_points({"broken": ((1, 2, 3),)})
+    with pytest.raises(ValueError, match="non-empty tokens"):
+        format_validation_points({"not valid": ((1, 2, 3, 4),)})
+
+
+def test_python_api_driver_enforces_canonical_model_parameter_card_values() -> None:
+    namespace = runpy.run_path(
+        str(ROOT / "src/pyamplicol/assets/api_templates/python/check_standalone.py")
+    )
+    convert = namespace["_parameter_value"]
+
+    assert convert(0.117) == 0.117
+    assert convert([2.5, -0.25]) == complex(2.5, -0.25)
+    for invalid in (True, "0.117", [True, 0], [0, False], [1], {}, float("inf")):
+        with pytest.raises(SystemExit):
+            convert(invalid)
diff --git a/pyamplicol/tests/unit/test_api_requests.py b/pyamplicol/tests/unit/test_api_requests.py
new file mode 100644
index 0000000000..8cedc20f2a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_api_requests.py
@@ -0,0 +1,221 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import sys
+from dataclasses import FrozenInstanceError
+from decimal import Decimal
+from pathlib import Path
+
+import pytest
+
+import pyamplicol.api.models as api_models
+import pyamplicol.models.loading as model_loading
+from pyamplicol._internal.versions import COMPILED_MODEL_SCHEMA_VERSION
+from pyamplicol.api import (
+    ColorFlow,
+    CompiledModel,
+    HelicityConfiguration,
+    ModelError,
+    ModelSource,
+    PhysicsReduction,
+    ProcessAlias,
+    ProcessPhysics,
+    ProcessRequest,
+    ProcessSet,
+    ReductionGroup,
+    ResolvedEvaluation,
+)
+from pyamplicol.config import ModelConfig
+
+
+def test_model_source_kind_resolution_does_not_import_symbolica(tmp_path: Path) -> None:
+    sys.modules.pop("symbolica", None)
+    ufo = tmp_path / "ufo"
+    ufo.mkdir()
+    serialized = tmp_path / "model.json"
+    serialized.write_text("{}", encoding="utf-8")
+    compiled = tmp_path / "sm.pyamplicol-model.json"
+    compiled.write_text("{}", encoding="utf-8")
+
+    assert ModelSource.built_in_sm().kind == "built-in-sm"
+    assert ModelSource.built_in_sm_heft().kind == "built-in-sm-heft"
+    assert ModelSource.from_path(ufo).kind == "ufo"
+    assert ModelSource.from_path(serialized).kind == "json"
+    assert ModelSource.from_path(compiled).kind == "compiled"
+    assert "symbolica" not in sys.modules
+
+
+def test_model_source_validates_restriction_files(tmp_path: Path) -> None:
+    ufo = tmp_path / "ufo"
+    ufo.mkdir()
+    restriction = ufo / "restrict_default.dat"
+    restriction.write_text("BLOCK MASS\n", encoding="ascii")
+
+    source = ModelSource.from_path(ufo, restriction="restrict_default.dat")
+
+    assert source.restriction == restriction
+    with pytest.raises(ModelError, match="does not exist"):
+        ModelSource.from_path(ufo, restriction="restrict_missing.dat")
+
+
+def test_model_source_preserves_named_restrictions_from_typed_config(
+    tmp_path: Path,
+) -> None:
+    ufo = tmp_path / "ufo"
+    ufo.mkdir()
+
+    source = ModelSource.from_config(
+        ModelConfig(
+            source=str(ufo),
+            restriction="no_widths",
+            simplify=False,
+        )
+    )
+
+    assert source.kind == "ufo"
+    assert source.path == ufo
+    assert source.restriction == "no_widths"
+    assert source.simplify is False
+
+
+def test_model_source_compile_forwards_named_restriction(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    ufo = tmp_path / "ufo"
+    ufo.mkdir()
+    source = ModelSource.from_path(ufo, restriction="no_widths")
+    captured: dict[str, object] = {}
+    payload = object()
+    expected = object()
+
+    def compile_source(value: object, **kwargs: object) -> object:
+        captured["source"] = value
+        captured.update(kwargs)
+        return payload
+
+    def wrap_compiled_model(value: object) -> object:
+        captured["payload"] = value
+        return expected
+
+    monkeypatch.setattr(model_loading, "compile_model_source", compile_source)
+    monkeypatch.setattr(api_models, "_compiled_model_from_payload", wrap_compiled_model)
+
+    result = source.compile(use_cache=False)
+
+    assert result is expected
+    assert captured["payload"] is payload
+    assert captured["source"] == ufo
+    assert captured["restriction"] == "no_widths"
+    assert captured["simplify"] is True
+    assert captured["use_cache"] is False
+
+
+def test_model_source_rejects_external_options_for_builtin_model() -> None:
+    with pytest.raises(ModelError, match="external models"):
+        ModelSource.from_config(
+            ModelConfig(source="built-in-sm", restriction="no_widths")
+        )
+    with pytest.raises(ModelError, match="cannot be disabled"):
+        ModelSource.from_config(ModelConfig(source="built-in-sm", simplify=False))
+
+
+@pytest.mark.parametrize(
+    "selector",
+    ("built-in-sm-heft", "builtin_sm_heft", "sm-heft", "sm_heft"),
+)
+def test_model_source_selects_packaged_sm_heft(selector: str) -> None:
+    source = ModelSource.from_config(ModelConfig(source=selector))
+
+    assert source == ModelSource.built_in_sm_heft()
+    with pytest.raises(ModelError, match="restrictions cannot be applied"):
+        ModelSource.from_config(ModelConfig(source=selector, restriction="none"))
+    with pytest.raises(ModelError, match="cannot be disabled"):
+        ModelSource.from_config(ModelConfig(source=selector, simplify=False))
+
+
+def test_public_compiled_model_uses_the_canonical_schema() -> None:
+    compiled = ModelSource.built_in_sm().compile(use_cache=False)
+
+    assert isinstance(compiled, CompiledModel)
+    assert compiled.schema_version == COMPILED_MODEL_SCHEMA_VERSION == 9
+
+
+def test_process_requests_normalize_and_sets_require_unique_names() -> None:
+    request = ProcessRequest.parse("  d   d~   >  z g ", name="dd_zg")
+    assert request.expression == "d d~ > z g"
+    assert request.name == "dd_zg"
+    processes = ProcessSet(
+        (request,),
+        aliases=(
+            ProcessAlias(
+                name="physical_alias",
+                process_name="dd_zg",
+                particle_permutation=(0, 1, 3, 2),
+            ),
+        ),
+    )
+    assert processes.aliases[0].process_name == "dd_zg"
+    assert processes.aliases[0].particle_permutation == (0, 1, 3, 2)
+    assert not hasattr(processes.aliases[0], "helicity_ids")
+    assert not hasattr(processes.aliases[0], "color_flow_ids")
+    with pytest.raises(ValueError, match="unique"):
+        ProcessSet((request, request))
+    with pytest.raises(ValueError, match="exactly one arrow"):
+        ProcessRequest.parse("d > z > g")
+
+
+def test_resolved_total_reproduces_fully_summed_values() -> None:
+    resolved = ResolvedEvaluation(
+        values=(
+            ((1.0 + 0j, 2.0 + 0j), (3.0 + 0j, 4.0 + 0j)),
+            ((5.0 + 0j, 6.0 + 0j), (7.0 + 0j, 8.0 + 0j)),
+        ),
+        helicity_ids=("h0", "h1"),
+        color_ids=("c0", "c1"),
+        color_accuracy="lc",
+    )
+    assert resolved.total() == (10.0 + 0j, 26.0 + 0j)
+
+
+def test_resolved_decimal_total_does_not_use_ambient_context_precision() -> None:
+    large = Decimal("10000000000000000000000000000")
+    tiny = Decimal("0.0000000000000000000000000001")
+    resolved = ResolvedEvaluation(
+        values=(((large, tiny),),),
+        helicity_ids=("h0",),
+        color_ids=("c0", "c1"),
+        color_accuracy="lc",
+    )
+
+    assert resolved.total() == (
+        Decimal("10000000000000000000000000000.0000000000000000000000000001"),
+    )
+
+
+def test_process_physics_metadata_is_deeply_immutable() -> None:
+    helicity = HelicityConfiguration("h0", 0, (1, -1), True, False, "h0", 1.0)
+    flow = ColorFlow("c0", 0, (1, 2), True, "c0", 1.0)
+    physics = ProcessPhysics(
+        process_id="ddbar_z",
+        process="d d~ > z",
+        color_accuracy="lc",
+        helicity_coverage="all",
+        color_coverage="all",
+        color_kind="flow",
+        structural_zero_helicity_count=0,
+        external_particles=(),
+        helicities=(helicity,),
+        color_flows=(flow,),
+        contracted_color_components=(),
+        reduction=PhysicsReduction(
+            "lc-diagonal",
+            (ReductionGroup("g0", "h0", "c0", ("h0",), ("c0",)),),
+        ),
+        model_parameters=(),
+        selector_capabilities=("helicity", "color_flow"),
+    )
+    assert physics.helicity_ids == ("h0",)
+    assert physics.color_ids == ("c0",)
+    with pytest.raises(FrozenInstanceError):
+        flow.id = "changed"  # type: ignore[misc]
diff --git a/pyamplicol/tests/unit/test_api_services.py b/pyamplicol/tests/unit/test_api_services.py
new file mode 100644
index 0000000000..cefdae0f1d
--- /dev/null
+++ b/pyamplicol/tests/unit/test_api_services.py
@@ -0,0 +1,449 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from decimal import Decimal
+from pathlib import Path
+
+import pytest
+
+import pyamplicol.api.services as service_module
+from pyamplicol.api import (
+    BenchmarkResult,
+    BenchmarkStatistics,
+    ColorFlow,
+    CompatibilityError,
+    EvaluationError,
+    Generator,
+    HelicityConfiguration,
+    PhysicsReduction,
+    ProcessPhysics,
+    ProcessSet,
+    ReductionGroup,
+    ResolvedEvaluation,
+    Runtime,
+    WarmUpResult,
+)
+from pyamplicol.api.results import GenerationPlan
+from pyamplicol.config import BenchmarkConfig, GenerationConfig
+
+
+class _GeneratorBackend:
+    def __init__(self) -> None:
+        self.processes: ProcessSet | None = None
+
+    def plan(self, processes: ProcessSet, *, model: object = None) -> GenerationPlan:
+        del model
+        self.processes = processes
+        return GenerationPlan(
+            concrete_processes=processes.requests,
+            estimated_coverage={"fraction": 1.0},
+            requested_settings=GenerationConfig(),
+            effective_settings=GenerationConfig(),
+        )
+
+    def generate(self, *args: object, **kwargs: object) -> object:
+        raise AssertionError("not used")
+
+
+class _RuntimeBackend:
+    muted = False
+
+    def __init__(self) -> None:
+        self.selectors: dict[str, object] = {}
+        self.clear_count = 0
+
+    @property
+    def physics(self) -> ProcessPhysics:
+        return ProcessPhysics(
+            "test",
+            "d d~ > z",
+            "lc",
+            "all",
+            "all",
+            "flow",
+            0,
+            (),
+            (HelicityConfiguration("h0", 0, (1, -1), True, False, "h0", 1.0),),
+            (ColorFlow("c0", 0, (1,), True, "c0", 1.0),),
+            (),
+            PhysicsReduction(
+                "lc-diagonal",
+                (ReductionGroup("g0", "h0", "c0", ("h0",), ("c0",)),),
+            ),
+            (),
+            ("helicity",),
+        )
+
+    def evaluate(self, momenta: object, **selectors: object) -> tuple[complex, ...]:
+        del momenta
+        self.selectors = selectors
+        return (3.0 + 0j,)
+
+    def evaluate_resolved(
+        self, momenta: object, **selectors: object
+    ) -> ResolvedEvaluation:
+        del momenta, selectors
+        return ResolvedEvaluation((((3.0 + 0j,),),), ("h0",), ("c0",))
+
+    def set_model_parameters(self, mapping: object) -> None:
+        self.parameters = mapping
+
+    def clear(self) -> None:
+        self.clear_count += 1
+
+    def mute_warnings(self) -> None:
+        self.muted = True
+
+    def unmute_warnings(self) -> None:
+        self.muted = False
+
+
+class _PreSelectorRuntimeBackend(_RuntimeBackend):
+    def evaluate(
+        self,
+        momenta: object,
+        *,
+        helicities: tuple[str, ...] | None = None,
+        color_flows: tuple[str, ...] | None = None,
+        precision: int = 16,
+    ) -> tuple[complex, ...]:
+        del momenta
+        self.selectors = {
+            "helicities": helicities,
+            "color_flows": color_flows,
+            "precision": precision,
+        }
+        return (3.0 + 0j,)
+
+
+class _DiagnosticRuntimeBackend(_RuntimeBackend):
+    def _diagnostic_project_onshell(
+        self, momenta: object, *, precision: int
+    ) -> tuple[object, dict[str, object]]:
+        self.diagnostic_call = (momenta, precision)
+        return momenta, {"unchanged": True, "projected_digest": "a" * 64}
+
+
+class _WarmUpRuntimeBackend(_RuntimeBackend):
+    execution_mode = "on-the-fly"
+
+    def warm_up(self, momenta: object, **options: object) -> WarmUpResult:
+        self.warm_up_call = (momenta, options)
+        return WarmUpResult(0.5, 7, 7, None, None, False)
+
+
+class _BenchmarkBackend:
+    def run(self, target: object, *, points: object = None) -> BenchmarkResult:
+        del target, points
+        config = BenchmarkConfig(target_runtime=0.1)
+        return BenchmarkResult(
+            requested_config=config,
+            effective_config=config,
+            sample_count=5,
+            wall_time_per_point=1e-6,
+            evaluator_time_per_point=8e-7,
+            uncertainty=BenchmarkStatistics(1e-7, 5e-8, 0.05),
+            environment={"python": "test"},
+        )
+
+
+def test_generator_backend_is_created_only_on_first_operation(
+    monkeypatch: object,
+) -> None:
+    calls: list[object] = []
+    backend = _GeneratorBackend()
+
+    def factory(config: object, progress: object) -> _GeneratorBackend:
+        calls.append((config, progress))
+        return backend
+
+    monkeypatch.setattr(service_module, "_generator_factory", factory)  # type: ignore[attr-defined]
+    generator = Generator(GenerationConfig())
+    assert calls == []
+    plan = generator.plan("d d~ > z g")
+    assert len(calls) == 1
+    assert plan.concrete_processes[0].expression == "d d~ > z g"
+
+
+def test_generator_rejects_existing_output_before_backend_construction(
+    monkeypatch: object, tmp_path: Path
+) -> None:
+    destination = tmp_path / "artifact"
+    destination.mkdir()
+    calls: list[object] = []
+
+    def factory(config: object, progress: object) -> _GeneratorBackend:
+        calls.append((config, progress))
+        return _GeneratorBackend()
+
+    monkeypatch.setattr(service_module, "_generator_factory", factory)  # type: ignore[attr-defined]
+    generator = Generator(GenerationConfig())
+    with pytest.raises(FileExistsError, match="artifact already exists"):
+        generator.generate("d d~ > z g", destination)
+    assert calls == []
+
+
+def test_runtime_and_benchmark_facades_use_typed_backends(
+    monkeypatch: object, tmp_path: Path
+) -> None:
+    backend = _RuntimeBackend()
+    loaded: list[Path] = []
+
+    def loader(path: Path, **kwargs: object) -> _RuntimeBackend:
+        del kwargs
+        loaded.append(path)
+        return backend
+
+    monkeypatch.setattr(service_module, "_runtime_loader", loader)  # type: ignore[attr-defined]
+    monkeypatch.setattr(  # type: ignore[attr-defined]
+        service_module,
+        "_benchmark_factory",
+        lambda config, progress: _BenchmarkBackend(),
+    )
+    runtime = Runtime.load(tmp_path / "artifact")
+    assert loaded[0].is_absolute()
+    assert runtime.evaluate([[[[1.0, 0.0, 0.0, 1.0]]]]) == (3.0 + 0j,)
+    assert runtime.evaluate_resolved([]).total() == (3.0 + 0j,)
+    runtime.mute_warnings()
+    assert backend.muted
+    runtime.clear()
+    assert backend.clear_count == 1
+    result = service_module.BenchmarkRunner(BenchmarkConfig()).run(runtime)
+    assert result.sample_count == 5
+
+
+def test_runtime_forwards_ufo_style_complex_parameter_pairs(
+    monkeypatch: object, tmp_path: Path
+) -> None:
+    backend = _RuntimeBackend()
+    received: list[object] = []
+
+    def loader(path: Path, **kwargs: object) -> _RuntimeBackend:
+        del path
+        received.append(kwargs["model_parameters"])
+        return backend
+
+    monkeypatch.setattr(service_module, "_runtime_loader", loader)  # type: ignore[attr-defined]
+
+    Runtime.load(
+        tmp_path / "artifact",
+        model_parameters={"aS": [0.117, 0.0], "complex": [2.5, -0.25]},
+    )
+
+    assert received == [{"aS": [0.117, 0.0], "complex": [2.5, -0.25]}]
+
+
+def test_runtime_accepts_typed_physics_selectors(
+    monkeypatch: object, tmp_path: Path
+) -> None:
+    backend = _RuntimeBackend()
+    monkeypatch.setattr(  # type: ignore[attr-defined]
+        service_module,
+        "_runtime_loader",
+        lambda path, **kwargs: backend,
+    )
+    runtime = Runtime.load(tmp_path / "artifact")
+    physics = runtime.physics
+    runtime.evaluate(
+        [[[[1.0, 0.0, 0.0, 1.0]]]],
+        helicities=(physics.helicities[0],),
+        color_flows=(physics.color_flows[0],),
+    )
+    assert backend.selectors["helicities"] == ("h0",)
+    assert backend.selectors["color_flows"] == ("c0",)
+
+
+def test_runtime_accepts_typed_per_point_selectors() -> None:
+    backend = _RuntimeBackend()
+    runtime = Runtime(backend)
+    physics = runtime.physics
+
+    runtime.evaluate(
+        [[[[1.0, 0.0, 0.0, 1.0]]]],
+        helicity_by_point=(physics.helicities[0],),
+        color_flow_by_point=(physics.color_flows[0],),
+    )
+
+    assert backend.selectors["helicity_by_point"] == ("h0",)
+    assert backend.selectors["color_flow_by_point"] == ("c0",)
+
+
+def test_runtime_forwards_private_diagnostic_projection() -> None:
+    backend = _DiagnosticRuntimeBackend()
+    runtime = Runtime(backend)
+    points = ((((1.0, 0.0, 0.0, 1.0),),),)
+
+    projected, metadata = runtime._diagnostic_project_onshell(
+        points,
+        precision=200,
+    )
+
+    assert projected is points
+    assert metadata == {"unchanged": True, "projected_digest": "a" * 64}
+    assert backend.diagnostic_call == (points, 200)
+
+
+def test_runtime_preserves_pre_selector_backend_compatibility() -> None:
+    backend = _PreSelectorRuntimeBackend()
+    runtime = Runtime(backend)
+
+    assert runtime.evaluate([], helicities=("h0",)) == (3.0 + 0j,)
+    assert backend.selectors == {
+        "helicities": ("h0",),
+        "color_flows": None,
+        "precision": 16,
+    }
+    assert runtime.evaluate([], helicity_by_point=()) == (3.0 + 0j,)
+
+    with pytest.raises(EvaluationError, match="does not support per-point"):
+        runtime.evaluate([[]], helicity_by_point=("h0",))
+
+
+def test_runtime_warm_up_is_one_point_native_f64_only() -> None:
+    backend = _WarmUpRuntimeBackend()
+    runtime = Runtime(backend)
+    point = ((1.0, 0.0, 0.0, 1.0),)
+
+    result = runtime.warm_up((point,), helicities=("h0",), color_flows=("c0",))
+
+    assert result == WarmUpResult(0.5, 7, 7, None, None, False)
+    assert backend.warm_up_call == (
+        (point,),
+        {
+            "helicities": ("h0",),
+            "color_flows": ("c0",),
+            "precision": 16,
+            "progress": None,
+            "n_cores": None,
+        },
+    )
+    with pytest.raises(ValueError, match="exactly one"):
+        runtime.warm_up(())
+    with pytest.raises(ValueError, match="exactly one"):
+        runtime.warm_up((point, point))
+    with pytest.raises(CompatibilityError, match="only precision=16"):
+        runtime.warm_up((point,), precision=200)
+    backend.execution_mode = "compiled"
+    with pytest.raises(CompatibilityError, match="only for on-the-fly"):
+        runtime.warm_up((point,))
+
+
+def test_runtime_warm_up_forwards_per_call_core_override() -> None:
+    backend = _WarmUpRuntimeBackend()
+    runtime = Runtime(backend)
+    point = ((1.0, 0.0, 0.0, 1.0),)
+
+    runtime.warm_up((point,), n_cores=4)
+    assert backend.warm_up_call[1]["n_cores"] == 4
+    runtime.warm_up((point,))
+    assert backend.warm_up_call[1]["n_cores"] is None
+
+
+@pytest.mark.parametrize("n_cores", [True, False, 1.5, "4"])
+def test_runtime_warm_up_rejects_noninteger_core_count(n_cores: object) -> None:
+    backend = _WarmUpRuntimeBackend()
+    with pytest.raises(TypeError, match="n_cores must be a positive integer"):
+        Runtime(backend).warm_up(((),), n_cores=n_cores)  # type: ignore[arg-type]
+    assert not hasattr(backend, "warm_up_call")
+
+
+@pytest.mark.parametrize("n_cores", [0, -1])
+def test_runtime_warm_up_rejects_nonpositive_core_count(n_cores: int) -> None:
+    backend = _WarmUpRuntimeBackend()
+    with pytest.raises(ValueError, match="n_cores must be a positive integer"):
+        Runtime(backend).warm_up(((),), n_cores=n_cores)
+    assert not hasattr(backend, "warm_up_call")
+
+
+def test_runtime_normalizes_empty_selector_sequences_to_omitted_axes() -> None:
+    backend = _RuntimeBackend()
+    runtime = Runtime(backend)
+
+    runtime.evaluate(
+        [],
+        helicities=(),
+        color_flows=(),
+        helicity_by_point=(),
+        color_flow_by_point=(),
+    )
+
+    assert backend.selectors == {
+        "helicities": None,
+        "color_flows": None,
+        "precision": 16,
+    }
+
+    runtime.evaluate([], helicities=(), helicity_by_point=("h0",))
+    assert backend.selectors["helicity_by_point"] == ("h0",)
+
+
+def test_runtime_rejects_global_and_per_point_selector_on_same_axis() -> None:
+    runtime = Runtime(_RuntimeBackend())
+
+    with pytest.raises(ValueError, match="helicities and helicity_by_point"):
+        runtime.evaluate([], helicities=("h0",), helicity_by_point=("h0",))
+    with pytest.raises(ValueError, match="color_flows and color_flow_by_point"):
+        runtime.evaluate([], color_flows=("c0",), color_flow_by_point=("c0",))
+
+
+def test_runtime_identity_is_optional_for_backend_conformance_but_fails_closed() -> (
+    None
+):
+    runtime = Runtime(_RuntimeBackend())
+
+    assert runtime.external_permutation == ()
+    with pytest.raises(EvaluationError, match="authenticated artifact identity"):
+        _ = runtime.artifact_id
+    with pytest.raises(EvaluationError, match="valid execution mode"):
+        _ = runtime.execution_mode
+    with pytest.raises(CompatibilityError, match="compact runtime inspection"):
+        runtime.inspect()
+
+
+def test_runtime_validates_legacy_permutation_against_physics_count() -> None:
+    backend = _RuntimeBackend()
+    backend.external_permutation = ()
+    runtime = Runtime(backend)
+
+    assert runtime.external_permutation == ()
+    backend.external_permutation = (0,)
+    with pytest.raises(CompatibilityError, match="external permutation is invalid"):
+        _ = runtime.external_permutation
+
+
+def test_runtime_prefers_authenticated_compact_external_count() -> None:
+    backend = _RuntimeBackend()
+    backend.external_count = 1
+    backend.external_permutation = (0,)
+
+    assert Runtime(backend).external_permutation == (0,)
+
+
+@pytest.mark.parametrize("precision", (True, False, 1.5, "32"))
+def test_runtime_rejects_non_integer_precision(precision: object) -> None:
+    runtime = Runtime(_RuntimeBackend())
+
+    with pytest.raises(TypeError, match="positive integer"):
+        runtime.evaluate([], precision=precision)  # type: ignore[arg-type]
+    with pytest.raises(TypeError, match="positive integer"):
+        runtime.evaluate_resolved([], precision=precision)  # type: ignore[arg-type]
+
+
+@pytest.mark.parametrize("precision", (0, -1))
+def test_runtime_rejects_non_positive_precision(precision: int) -> None:
+    runtime = Runtime(_RuntimeBackend())
+
+    with pytest.raises(ValueError, match="positive integer"):
+        runtime.evaluate([], precision=precision)
+    with pytest.raises(ValueError, match="positive integer"):
+        runtime.evaluate_resolved([], precision=precision)
+
+
+def test_resolved_evaluation_preserves_decimal_precision() -> None:
+    resolved = ResolvedEvaluation(
+        (((Decimal("1.25"), Decimal("2.75")),),),
+        ("h0",),
+        ("c0", "c1"),
+    )
+    assert resolved.total() == (Decimal("4.00"),)
+    assert resolved.color_accuracy == resolved.accuracy == "lc"
diff --git a/pyamplicol/tests/unit/test_arena_native_x86_acceptance.py b/pyamplicol/tests/unit/test_arena_native_x86_acceptance.py
new file mode 100644
index 0000000000..e0bc6bf86f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_arena_native_x86_acceptance.py
@@ -0,0 +1,530 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import copy
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from tools.developer import arena_native_x86_acceptance as acceptance
+
+REVISION = "1" * 40
+WORKSPACE = acceptance.ROOT
+SHA256 = "2" * 64
+
+
+def _source() -> dict[str, object]:
+    return {
+        "checkout": str(WORKSPACE),
+        "revision": REVISION,
+        "dirty": False,
+        "untracked_files_checked": True,
+    }
+
+
+def _runtime() -> dict[str, object]:
+    build_info = {"source_revision": REVISION}
+    return {
+        "interpreter": {
+            "path": "/python",
+            "size_bytes": 10,
+            "sha256": "3" * 64,
+            "python_version": "3.11.9",
+            "implementation": "CPython",
+        },
+        "package": {"version": "0.1.0"},
+        "python_package_tree": {
+            "kind": "pyamplicol-python-package-tree-v2",
+            "sha256": "4" * 64,
+        },
+        "native_extension": {
+            "path": "/pyamplicol/_rusticol.so",
+            "size_bytes": 20,
+            "sha256": "5" * 64,
+            "build_inputs_sha256": "6" * 64,
+        },
+        "active_build_info": {
+            "payload": build_info,
+            "canonical_sha256": acceptance._canonical_sha256(build_info),
+        },
+        "loaded_module_origin_policy": {
+            "kind": "pyamplicol-loaded-module-origin-policy-v1",
+            "all_loaded_origins_authenticated": True,
+            "observed_module_count": 1,
+            "observations": [{"module": "pyamplicol"}],
+            "observations_sha256": SHA256,
+        },
+    }
+
+
+def _gate_common(kind: str) -> dict[str, Any]:
+    source = _source()
+    runtime = _runtime()
+    script = {"path": "/gate.py", "size_bytes": 1, "sha256": SHA256}
+    return {
+        "kind": kind,
+        "schema_version": 1,
+        "status": "ok",
+        "passes": True,
+        "source_identity": source,
+        "source_identity_postflight": copy.deepcopy(source),
+        "source_identity_match": True,
+        "runtime_identity": runtime,
+        "runtime_identity_postflight": copy.deepcopy(runtime),
+        "runtime_identity_match": True,
+        "gate_script_identity": script,
+        "gate_script_identity_postflight": copy.deepcopy(script),
+        "gate_script_identity_match": True,
+        "failures": [],
+    }
+
+
+def _comparison() -> dict[str, object]:
+    return {
+        "value_count": 2,
+        "failing_value_count": 0,
+        "passes": True,
+    }
+
+
+def _comparison_mapping(names: set[str]) -> dict[str, object]:
+    return {name: _comparison() for name in names}
+
+
+def _all_jit_payload() -> dict[str, Any]:
+    payload = _gate_common(acceptance.ALL_JIT_KIND)
+    payload["request"] = {
+        "process": "g g > g g",
+        "jit_optimization_levels": [0, 1, 2, 3],
+        "point_count": 3,
+        "point_seeds": list(acceptance._ALL_JIT_POINT_SEEDS),
+        "momenta_identity": {
+            "algorithm": "sha256-float-hex-momenta-v1",
+            "sha256": SHA256,
+            "point_count": 3,
+            "external_particle_count": 4,
+        },
+        "relative_tolerance": 1.0e-12,
+        "absolute_tolerance": 1.0e-15,
+        "mandatory_watchdog_command": "memory-watchdog -- gate",
+        "memory_limit_gib": 30,
+    }
+    levels = {}
+    for name, level in acceptance._ALL_JIT_LEVELS.items():
+        levels[name] = {
+            "configuration": {
+                "process": "g g > g g",
+                "color_accuracy": "lc",
+                "lc_flow_layout": "topology-replay",
+                "backend": "jit",
+                "execution_mode": "compiled",
+                "jit_optimization_level": level,
+            },
+            "generation": {
+                "worker_provenance": {
+                    "source_revision": REVISION,
+                    "postflight_identity_match": True,
+                }
+            },
+            "artifact_identity": {
+                "payload_count": 1,
+                "direct_arena_audit": {"passes": True},
+            },
+            "numerical_validation": {
+                "execution_mode": "compiled",
+                "point_count": 3,
+                "point_seeds": list(acceptance._ALL_JIT_POINT_SEEDS),
+                "comparisons": _comparison_mapping(acceptance._ALL_JIT_COMPARISONS),
+                "native_profile": {
+                    "passes": True,
+                    "execution_mode": "compiled",
+                    "direct_arena_engine_counter": {"value": 1},
+                    "direct_arena_call_counter": {"value": 2},
+                },
+                "passes": True,
+            },
+            "passes": True,
+        }
+    payload["levels"] = levels
+    payload["cross_level_numerical_parity"] = {
+        "baseline_optimization_level": 3,
+        "comparisons": {
+            name: _comparison_mapping(acceptance._CROSS_LEVEL_COMPARISONS)
+            for name in ("o0_vs_o3", "o1_vs_o3", "o2_vs_o3")
+        },
+        "passes": True,
+    }
+    return acceptance._attach_content_identity(payload)
+
+
+def _four_quark_payload() -> dict[str, Any]:
+    payload = _gate_common(acceptance.FOUR_QUARK_KIND)
+    payload["request"] = {
+        "process": "d d~ > u u~ s s~ c c~",
+        "independent_quark_line_count": 4,
+        "expected_external_pdgs": [-4, -3, -2, -1, 1, 2, 3, 4],
+        "max_quark_lines": 4,
+        "point_count": 3,
+        "point_seeds": list(acceptance._FOUR_QUARK_POINT_SEEDS),
+        "momenta_identity": {
+            "algorithm": "sha256-float-hex-momenta-v1",
+            "sha256": SHA256,
+            "point_count": 3,
+            "external_particle_count": 8,
+        },
+        "relative_tolerance": 1.0e-12,
+        "absolute_tolerance": 1.0e-300,
+        "mandatory_watchdog_command": "memory-watchdog -- gate",
+        "memory_limit_gib": 30,
+    }
+    payload["invalid_union_configurations"] = [
+        {
+            "color_accuracy": color,
+            "lc_flow_layout": "all-flow-union",
+            "rejected": True,
+            "error_type": "ConfigurationError",
+            "message": f"all-flow-union requires LC, not {color}",
+        }
+        for color in ("nlc", "full")
+    ]
+    lanes = {}
+    for name, (color, layout, contracted) in acceptance._FOUR_QUARK_LANES.items():
+        comparisons = set(acceptance._FOUR_QUARK_BASE_COMPARISONS)
+        profiles = {"complete", "helicity_selector"}
+        if not contracted:
+            comparisons.add("color_selector_evaluate_vs_resolved_total")
+            profiles.update({"color_selector", "combined_selector"})
+        lanes[name] = {
+            "configuration": {
+                "process": "d d~ > u u~ s s~ c c~",
+                "max_quark_lines": 4,
+                "color_accuracy": color,
+                "lc_flow_layout": layout,
+                "contracted_color": contracted,
+                "backend": "jit",
+                "execution_mode": "compiled",
+                "jit_optimization_level": 3,
+            },
+            "generation": {
+                "worker_provenance": {
+                    "source_revision": REVISION,
+                    "postflight_identity_match": True,
+                }
+            },
+            "artifact_identity": {
+                "payload_count": 1,
+                "direct_arena_audit": {"passes": True},
+            },
+            "numerical_validation": {
+                "point_count": 3,
+                "point_seeds": list(acceptance._FOUR_QUARK_POINT_SEEDS),
+                "comparisons": _comparison_mapping(comparisons),
+                "runtime_execution": {
+                    "execution_mode": "compiled",
+                    "direct_arena_profiles": {
+                        profile: {
+                            "compiled_direct_arena_engine_count": 1,
+                            "compiled_direct_arena_call_count": 2,
+                            "legacy_boundary_component_total": 0,
+                            "passes": True,
+                        }
+                        for profile in profiles
+                    },
+                },
+                "passes": True,
+            },
+            "passes": True,
+        }
+    payload["lanes"] = lanes
+    payload["lc_cross_layout_parity"] = {
+        "physical_axes_match": True,
+        "comparisons": _comparison_mapping(acceptance._CROSS_LC_COMPARISONS),
+        "passes": True,
+    }
+    return acceptance._attach_content_identity(payload)
+
+
+def _resolved() -> dict[str, object]:
+    return {
+        "helicity_ids_match": True,
+        "color_ids_match": True,
+        "shape_matches": True,
+        "point_count": 2,
+        "component_count": 4,
+        "passes": True,
+    }
+
+
+def _correctness(*, specialized: bool) -> dict[str, Any]:
+    result = {
+        "total": [{"passes": True}],
+        "resolved_f64": _resolved(),
+        "resolved_precision32": _resolved(),
+        "eager_resolved_sum": [{"passes": True}],
+        "compiled_resolved_sum": [{"passes": True}],
+        "passes": True,
+    }
+    if specialized:
+        result["specialized_compiled"] = _correctness(specialized=False)
+    return result
+
+
+def _color_matrix_payload() -> dict[str, Any]:
+    records = []
+    for case_key, (process, n_final) in acceptance._SMOKE_CASES.items():
+        for color in acceptance._COLORS:
+            lc = color == "lc"
+            workload_names = (
+                ("single-flow-helicity-sum", "all-flow-single-helicity")
+                if lc
+                else ("summed",)
+            )
+            workloads = []
+            for name in workload_names:
+                modes = {"compiled_complete", "eager_complete"}
+                if lc:
+                    modes.add("compiled_specialized")
+                workloads.append(
+                    {
+                        "name": name,
+                        "correctness": _correctness(specialized=lc),
+                        "profiles": [
+                            {
+                                "batch_size": batch_size,
+                                **{
+                                    mode: {
+                                        "result": {
+                                            "sample_count": 5,
+                                            "wall_time_per_point": 1.0e-6,
+                                            "interrupted": False,
+                                            "effective_config": {
+                                                "batch_size": batch_size
+                                            },
+                                        }
+                                    }
+                                    for mode in modes
+                                },
+                            }
+                            for batch_size in (128, 1024)
+                        ],
+                    }
+                )
+            records.append(
+                {
+                    "case": {
+                        "key": case_key,
+                        "process": process,
+                        "n_final": n_final,
+                        "smoke": True,
+                    },
+                    "model": "built-in",
+                    "color": color,
+                    "process_id": f"{case_key}-{color}",
+                    "compiled_generation_under_hard_limit": True,
+                    "generation": {
+                        mode: {"core_phase_seconds": 1.0}
+                        for mode in ("compiled", "eager")
+                    },
+                    "workloads": workloads,
+                    "selector_pattern_profiles": (
+                        {
+                            mode: {"result": {"passes": True}}
+                            for mode in ("compiled", "eager")
+                        }
+                        if lc
+                        else None
+                    ),
+                }
+            )
+    return {
+        "kind": acceptance.COLOR_MATRIX_KIND,
+        "schema_version": acceptance.COLOR_MATRIX_SCHEMA_VERSION,
+        "complete": True,
+        "source_revision": REVISION,
+        "suite": "smoke",
+        "configuration": {
+            "batch_sizes": [128, 1024],
+            "colors": ["lc", "nlc", "full"],
+            "generation_timeout": 300.0,
+            "memory_limit_gib": 30.0,
+            "minimum_samples": 5,
+            "target_runtime": 5.0,
+            "selector_target_runtime": 1.0,
+            "selector_seed": 0xC0FFEE,
+        },
+        "gates": {name: True for name in acceptance._COLOR_MATRIX_GATES},
+        "passes": True,
+        "records": records,
+    }
+
+
+def _reattach(payload: dict[str, Any]) -> dict[str, Any]:
+    body = copy.deepcopy(payload)
+    body.pop("content_identity", None)
+    return acceptance._attach_content_identity(body)
+
+
+def test_acceptance_validators_accept_complete_synthetic_evidence() -> None:
+    assert acceptance._validate_all_jit(
+        _all_jit_payload(),
+        expected_revision=REVISION,
+        expected_workspace=WORKSPACE,
+        point_count=3,
+    )["numerical_validation"]
+    assert acceptance._validate_four_quark(
+        _four_quark_payload(),
+        expected_revision=REVISION,
+        expected_workspace=WORKSPACE,
+        point_count=3,
+    )["numerical_validation"]
+    color = acceptance._validate_color_matrix(
+        _color_matrix_payload(),
+        expected_revision=REVISION,
+    )
+    assert color["cell_count"] == 6
+    assert color["workload_count"] == 8
+
+
+def test_all_jit_rejects_tampering_and_vacuous_numerical_comparisons() -> None:
+    tampered = _all_jit_payload()
+    tampered["status"] = "validation_failed"
+    with pytest.raises(acceptance.AcceptanceError, match="content identity"):
+        acceptance._validate_all_jit(
+            tampered,
+            expected_revision=REVISION,
+            expected_workspace=WORKSPACE,
+            point_count=3,
+        )
+
+    empty = _all_jit_payload()
+    comparison = empty["levels"]["jit-o2"]["numerical_validation"]["comparisons"][
+        "f64_vs_precision32_total"
+    ]
+    comparison["value_count"] = 0
+    with pytest.raises(acceptance.AcceptanceError, match="comparison is empty"):
+        acceptance._validate_all_jit(
+            _reattach(empty),
+            expected_revision=REVISION,
+            expected_workspace=WORKSPACE,
+            point_count=3,
+        )
+
+
+def test_gate_runtime_must_match_the_preflight_candidate_bytes() -> None:
+    expected_runtime = _runtime()
+    package_tree = expected_runtime.pop("python_package_tree")
+    expected_runtime["preimport_runtime_identity"] = {
+        "python_package_tree": package_tree
+    }
+    acceptance._validate_all_jit(
+        _all_jit_payload(),
+        expected_revision=REVISION,
+        expected_workspace=WORKSPACE,
+        point_count=3,
+        expected_runtime=expected_runtime,
+    )
+
+    expected_runtime["native_extension"]["sha256"] = "7" * 64
+    with pytest.raises(acceptance.AcceptanceError, match="preflight candidate runtime"):
+        acceptance._validate_all_jit(
+            _all_jit_payload(),
+            expected_revision=REVISION,
+            expected_workspace=WORKSPACE,
+            point_count=3,
+            expected_runtime=expected_runtime,
+        )
+
+
+def test_four_quark_rejects_missing_lane_and_invalid_union_coverage() -> None:
+    missing_lane = _four_quark_payload()
+    del missing_lane["lanes"]["lc-all-flow-union"]
+    with pytest.raises(acceptance.AcceptanceError, match="lane coverage"):
+        acceptance._validate_four_quark(
+            _reattach(missing_lane),
+            expected_revision=REVISION,
+            expected_workspace=WORKSPACE,
+            point_count=3,
+        )
+
+    missing_rejection = _four_quark_payload()
+    missing_rejection["invalid_union_configurations"].pop()
+    with pytest.raises(acceptance.AcceptanceError, match="reject both"):
+        acceptance._validate_four_quark(
+            _reattach(missing_rejection),
+            expected_revision=REVISION,
+            expected_workspace=WORKSPACE,
+            point_count=3,
+        )
+
+
+def test_color_matrix_rejects_partial_scope_and_precision32_failure() -> None:
+    partial = _color_matrix_payload()
+    partial["records"].pop()
+    with pytest.raises(acceptance.AcceptanceError, match="cell scope"):
+        acceptance._validate_color_matrix(partial, expected_revision=REVISION)
+
+    failed = _color_matrix_payload()
+    failed["records"][0]["workloads"][0]["correctness"]["resolved_precision32"][
+        "passes"
+    ] = False
+    with pytest.raises(acceptance.AcceptanceError, match="resolved_precision32"):
+        acceptance._validate_color_matrix(failed, expected_revision=REVISION)
+
+
+def test_color_matrix_rejects_vacuous_reduction_and_false_hard_gate() -> None:
+    vacuous = _color_matrix_payload()
+    vacuous["records"][0]["workloads"][0]["correctness"]["eager_resolved_sum"] = []
+    with pytest.raises(acceptance.AcceptanceError, match="must not be empty"):
+        acceptance._validate_color_matrix(vacuous, expected_revision=REVISION)
+
+    failed_gate = _color_matrix_payload()
+    failed_gate["gates"]["correctness"] = False
+    with pytest.raises(acceptance.AcceptanceError, match=r"gates\.correctness"):
+        acceptance._validate_color_matrix(failed_gate, expected_revision=REVISION)
+
+
+def test_checked_json_binds_exact_bytes_and_rejects_symlink(
+    tmp_path: Path,
+) -> None:
+    evidence = tmp_path / "evidence.json"
+    evidence.write_text('{"passes":true}\n', encoding="utf-8")
+    payload, identity = acceptance._checked_json(evidence, label="fixture")
+    assert payload == {"passes": True}
+    assert (
+        identity["sha256"]
+        == acceptance.hashlib.sha256(evidence.read_bytes()).hexdigest()
+    )
+
+    link = tmp_path / "link.json"
+    link.symlink_to(evidence)
+    with pytest.raises(acceptance.AcceptanceError, match="regular file"):
+        acceptance._checked_json(link, label="fixture link")
+
+
+def test_content_identity_covers_the_entire_manifest_body() -> None:
+    payload = acceptance._attach_content_identity(
+        {
+            "kind": acceptance.ACCEPTANCE_KIND,
+            "schema_version": 1,
+            "evidence": {
+                "all_jit": {"file_identity": {"sha256": SHA256}},
+                "four_quark": {"file_identity": {"sha256": "3" * 64}},
+                "color_matrix": {"file_identity": {"sha256": "4" * 64}},
+                "preflight": {"file_identity": {"sha256": "5" * 64}},
+            },
+            "passes": True,
+        }
+    )
+    acceptance._require_content_identity(payload, label="manifest")
+    payload["evidence"]["all_jit"]["file_identity"]["sha256"] = "6" * 64
+    with pytest.raises(acceptance.AcceptanceError, match="content identity"):
+        acceptance._require_content_identity(payload, label="manifest")
+
+
+def test_strict_json_rejects_duplicate_keys(tmp_path: Path) -> None:
+    path = tmp_path / "duplicates.json"
+    path.write_text('{"passes":true,"passes":true}\n', encoding="utf-8")
+    with pytest.raises(acceptance.AcceptanceError, match="duplicate key"):
+        acceptance._checked_json(path, label="duplicate fixture")
diff --git a/pyamplicol/tests/unit/test_artifact_inspection.py b/pyamplicol/tests/unit/test_artifact_inspection.py
new file mode 100644
index 0000000000..7df7f13a05
--- /dev/null
+++ b/pyamplicol/tests/unit/test_artifact_inspection.py
@@ -0,0 +1,237 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import shutil
+from fractions import Fraction
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.artifacts import inspect_artifact
+from pyamplicol.artifacts.inspection import (
+    ArtifactProcessGroupMemberInspection,
+    _computed,
+    process_group_selection,
+    stored_process_groups,
+)
+from pyamplicol.artifacts.process_groups import (
+    initial_process_groups,
+    write_process_groups,
+)
+from pyamplicol.generation.process_grouping import GroupingBasis, GroupMember
+
+ROOT = Path(__file__).resolve().parents[2]
+PORTABLE_ARTIFACT = ROOT / "src/pyamplicol/assets/selftest/portable-64le/artifact"
+
+
+def test_artifact_inspection_lists_processes_without_loading_evaluators() -> None:
+    inspection = inspect_artifact(PORTABLE_ARTIFACT)
+
+    assert inspection.kind == "pyamplicol-artifact-inspection"
+    assert inspection.integrity == "verified"
+    assert inspection.model_name == "built-in-sm"
+    assert inspection.target == "portable-64le"
+    assert inspection.default_process_id == "d_dbar_to_z"
+    assert inspection.payload_count > 0
+    assert inspection.payload_size_bytes > 0
+
+    assert len(inspection.processes) == 1
+    process = inspection.processes[0]
+    assert process.id == "d_dbar_to_z"
+    assert process.expression == "d d~ > z"
+    assert process.default
+    assert process.physical_helicities == 12
+    assert process.computed_helicities == 2
+    assert process.physical_color_components == 1
+    assert process.computed_color_components == 1
+    assert process.helicity_coverage == "complete"
+    assert process.color_coverage == "complete"
+    assert process.lc_flow_layout == "topology-replay"
+    assert process.execution_mode == "compiled"
+    assert process.prepared_backend is None
+    assert process.invocation_count is None
+    assert process.native_profile_phases == (
+        "source-fill",
+        "momentum-setup",
+        "stage-input-pack",
+        "stage-evaluator-call",
+        "output-assign",
+        "amplitude-input-pack",
+        "amplitude-evaluator-call",
+        "reduction",
+    )
+
+
+def test_contracted_color_is_definitionally_computed() -> None:
+    assert _computed(
+        {
+            "kind": "contracted-color",
+            "id": "color:contracted",
+            "index": 0,
+            "description": "fully contracted color",
+        },
+        "color component",
+    )
+
+
+def _grouped_artifact(tmp_path: Path) -> Path:
+    """The self-test artifact with two flavour-blind members of ``d d~ > z``."""
+
+    root = tmp_path / "artifact"
+    shutil.copytree(PORTABLE_ARTIFACT, root)
+    members = [
+        GroupMember(
+            process_id="u_ubar_to_z",
+            expression="u u~ > z",
+            pdgs=(2, -2, 23),
+            initial_count=2,
+            factor=Fraction(16, 9),
+            permutation=(0, 1, 2),
+            basis=GroupingBasis.FLAVOR_BLIND,
+            generated=False,
+            warning="Z couplings differ between d and u",
+        ),
+        GroupMember(
+            process_id="dbar_d_to_z",
+            expression="d~ d > z",
+            pdgs=(-1, 1, 23),
+            initial_count=2,
+            permutation=(1, 0, 2),
+            conjugated=True,
+            basis=GroupingBasis.FLAVOR_BLIND,
+            generated=False,
+        ),
+    ]
+    write_process_groups(
+        root,
+        initial_process_groups(
+            [("d_dbar_to_z", "d d~ > z", (1, -1, 23))], {"d_dbar_to_z": members}
+        ),
+    )
+    return root
+
+
+def test_artifact_without_group_map_inspects_as_identity_groups() -> None:
+    groups = inspect_artifact(PORTABLE_ARTIFACT).process_groups
+
+    assert groups is not None
+    assert not groups.stored
+    assert groups.analyses == ()
+    assert [group.representative_id for group in groups.groups] == ["d_dbar_to_z"]
+    assert groups.groups[0].members == (
+        ArtifactProcessGroupMemberInspection(
+            id="d_dbar_to_z",
+            process="d d~ > z",
+            pdgs=(1, -1, 23),
+            initial_count=2,
+            factor="1",
+            permutation=(0, 1, 2),
+            conjugated=False,
+            basis="identity",
+            generated=True,
+        ),
+    )
+    assert process_group_selection(PORTABLE_ARTIFACT, "d_dbar_to_z") is None
+    assert stored_process_groups(PORTABLE_ARTIFACT) is None
+
+
+def test_artifact_inspection_lists_stored_process_groups(tmp_path: Path) -> None:
+    root = _grouped_artifact(tmp_path)
+
+    groups = inspect_artifact(root).process_groups
+
+    assert groups is not None
+    assert groups.stored
+    (group,) = groups.groups
+    assert (group.representative_id, group.representative) == (
+        "d_dbar_to_z",
+        "d d~ > z",
+    )
+    representative, routed, conjugated = group.members
+    assert representative.generated and representative.basis == "identity"
+    assert routed == ArtifactProcessGroupMemberInspection(
+        id="u_ubar_to_z",
+        process="u u~ > z",
+        pdgs=(2, -2, 23),
+        initial_count=2,
+        factor="16/9",
+        permutation=(0, 1, 2),
+        conjugated=False,
+        basis="flavor-blind",
+        generated=False,
+        warning="Z couplings differ between d and u",
+    )
+    assert conjugated.conjugated
+    assert conjugated.permutation == (1, 0, 2)
+    assert conjugated.factor == "1"
+    assert conjugated.warning is None
+    assert (conjugated.pdgs, conjugated.initial_count) == ((-1, 1, 23), 2)
+    assert stored_process_groups(root) == groups
+
+
+def test_process_group_selection_describes_members_and_representatives(
+    tmp_path: Path,
+) -> None:
+    root = _grouped_artifact(tmp_path)
+
+    member = process_group_selection(root, "dbar_d_to_z", permutation=(0, 1, 2))
+    assert member is not None
+    assert member.role == "routed member"
+    assert member.representative_id == "d_dbar_to_z"
+    assert member.conjugated
+    # the runtime permutation of the requested leg order replaces the stored one
+    assert member.permutation == (0, 1, 2)
+    assert (member.group_size, member.routed_count, member.conjugated_count) == (
+        3,
+        2,
+        1,
+    )
+
+    routed = process_group_selection(root, "u_ubar_to_z")
+    assert routed is not None
+    assert (routed.factor, routed.basis) == ("16/9", "flavor-blind")
+    assert routed.warning == "Z couplings differ between d and u"
+
+    representative = process_group_selection(root, "d_dbar_to_z", permutation=(1, 0, 2))
+    assert representative is not None
+    assert representative.role == "representative"
+    assert representative.factor == "1"
+    # the representative requested as `d~ d > z` relates to itself by a swap
+    assert representative.permutation == (1, 0, 2)
+    stored = process_group_selection(root, "d_dbar_to_z")
+    assert stored is not None and stored.permutation == (0, 1, 2)
+
+
+def test_process_group_selection_composes_a_generated_member_permutation(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A generated member's runtime permutes its own legs, not the
+    representative's, so the stored relation is composed with it."""
+
+    import pyamplicol.artifacts.inspection as inspection_module
+
+    representative = ("d_g_to_d_g", "d g > d g", (1, 21, 1, 21))
+    member = GroupMember(
+        process_id="g_u_to_u_g",
+        expression="g u > u g",
+        pdgs=(21, 2, 2, 21),
+        initial_count=2,
+        permutation=(1, 0, 2, 3),
+        basis=GroupingBasis.NUMERICAL,
+        generated=True,
+    )
+    group_map = initial_process_groups([representative], {"d_g_to_d_g": [member]})
+    monkeypatch.setattr(
+        inspection_module, "read_process_groups", lambda _artifact: group_map
+    )
+
+    stored = process_group_selection("artifact", "g_u_to_u_g")
+    # `u g > u g` is `g u > u g` with its initial legs swapped
+    requested = process_group_selection(
+        "artifact", "g_u_to_u_g", permutation=(1, 0, 2, 3)
+    )
+
+    assert stored is not None and requested is not None
+    assert stored.role == requested.role == "generated member"
+    assert stored.permutation == (1, 0, 2, 3)
+    assert requested.permutation == (0, 1, 2, 3)
diff --git a/pyamplicol/tests/unit/test_artifacts.py b/pyamplicol/tests/unit/test_artifacts.py
new file mode 100644
index 0000000000..ef8a7d537d
--- /dev/null
+++ b/pyamplicol/tests/unit/test_artifacts.py
@@ -0,0 +1,1097 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import io
+import json
+import threading
+from pathlib import Path
+
+import pytest
+
+import pyamplicol.artifacts.manifest as manifest_module
+import pyamplicol.generation.artifact_writer as generation_artifact_writer
+from pyamplicol import ArtifactError, CompatibilityError
+from pyamplicol._internal.versions import (
+    SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+    SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+)
+from pyamplicol.artifacts import (
+    ArtifactBuilder,
+    ArtifactTransaction,
+    load_manifest,
+    normalize_relative_path,
+)
+from pyamplicol.artifacts.manifest import PORTABLE_64LE_TARGET
+from pyamplicol.artifacts.process_groups import (
+    initial_process_groups,
+    read_process_groups,
+    write_process_groups,
+)
+from pyamplicol.generation.evaluator_container import PacbinReader
+from pyamplicol.generation.process_grouping import (
+    GroupingBasis,
+    GroupMember,
+    ProcessGroupMap,
+)
+
+
+def _producer(
+    *,
+    triple: str = "test-target",
+    cpu_features: tuple[str, ...] = (),
+) -> dict[str, object]:
+    return {
+        "distribution": "pyamplicol",
+        "version": "0.1.0",
+        "versions": {
+            "python_api": 1,
+            "toml": 1,
+            "compiled_model": 1,
+            "process_artifact": 3,
+            "runtime_physics": 1,
+            "symbolica_serialization": "test",
+            "c_abi": 1,
+        },
+        "target": {"triple": triple, "cpu_features": list(cpu_features)},
+    }
+
+
+def _model() -> dict[str, object]:
+    return {
+        "name": "built-in-sm",
+        "source_kind": "built-in-sm",
+        "content_sha256": "1" * 64,
+        "compiled_schema_version": 1,
+    }
+
+
+def _configuration() -> dict[str, object]:
+    return {
+        "toml_schema_version": 1,
+        "requested_path": "config/requested.toml",
+        "effective_path": "config/effective.toml",
+        "adjustments": [],
+    }
+
+
+def _process(
+    identifier: str = "dd_to_z",
+    *,
+    runtime_capabilities: tuple[str, ...] = (
+        "symjit.application.complex-f64.v1",
+    ),
+) -> dict[str, object]:
+    return {
+        "id": identifier,
+        "expression": "d d~ > z",
+        "color_accuracy": "lc",
+        "external_pdgs": [1, -1, 23],
+        "physics_path": "physics/process.json",
+        "required_runtime_capabilities": list(runtime_capabilities),
+        "aliases": [],
+    }
+
+
+def _runtime(
+    *,
+    runtime_capabilities: tuple[str, ...] = (
+        "symjit.application.complex-f64.v1",
+    ),
+) -> dict[str, object]:
+    return {
+        "engine": "rusticol",
+        "engine_version": "0.1.0",
+        "evaluator_manifest_path": "physics/process.json",
+        "api_bundle_path": None,
+        "required_runtime_capabilities": list(runtime_capabilities),
+    }
+
+
+def _build(
+    path: Path,
+    *,
+    mode: str = "error",
+    triple: str = "test-target",
+    cpu_features: tuple[str, ...] = (),
+    runtime_capabilities: tuple[str, ...] = (
+        "symjit.application.complex-f64.v1",
+    ),
+    evaluator_state_target: dict[str, object] | None = None,
+) -> None:
+    with ArtifactBuilder(path, mode=mode) as builder:  # type: ignore[arg-type]
+        builder.add_json(
+            "physics/process.json",
+            {"schema_version": 1},
+            role="runtime-physics",
+            process_id="dd_to_z",
+        )
+        if evaluator_state_target is not None:
+            builder.add_bytes(
+                "evaluators/state.symjit",
+                b"portable-state",
+                role="evaluator-state",
+                media_type="application/vnd.symjit.application",
+                target=evaluator_state_target,
+                process_id="dd_to_z",
+            )
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=_producer(triple=triple, cpu_features=cpu_features),
+            model=_model(),
+            configuration=_configuration(),
+            processes=[
+                _process(runtime_capabilities=runtime_capabilities)
+            ],
+            default_process_id="dd_to_z",
+            runtime=_runtime(runtime_capabilities=runtime_capabilities),
+        )
+
+
+def test_builder_writes_compact_machine_json(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    with ArtifactBuilder(root) as builder:
+        builder.add_json(
+            "physics/process.json",
+            {"beta": [1, 2], "alpha": True},
+            role="runtime-physics",
+            process_id="dd_to_z",
+            compact=True,
+        )
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=_producer(),
+            model=_model(),
+            configuration=_configuration(),
+            processes=[_process()],
+            default_process_id="dd_to_z",
+            runtime=_runtime(),
+        )
+
+    assert (root / "physics/process.json").read_text(encoding="utf-8") == (
+        '{"alpha":true,"beta":[1,2]}\n'
+    )
+
+
+def test_builder_streams_files_and_registers_staged_payloads(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    root = tmp_path / "artifact"
+    source = tmp_path / "large.bin"
+    source.write_bytes(b"streamed" * 4096)
+    original_read_bytes = Path.read_bytes
+
+    def guarded_read_bytes(path: Path) -> bytes:
+        if path == source:
+            raise AssertionError("ArtifactBuilder.add_file must not call read_bytes")
+        return original_read_bytes(path)
+
+    monkeypatch.setattr(Path, "read_bytes", guarded_read_bytes)
+    with ArtifactBuilder(root) as builder:
+        builder.add_file(
+            "payloads/streamed.bin",
+            source,
+            role="runtime-physics",
+            media_type="application/octet-stream",
+        )
+        staged = builder.staged_path("payloads/registered.bin", create_parent=True)
+        staged.write_bytes(b"registered")
+        builder.register_staged_file(
+            "payloads/registered.bin",
+            role="runtime-physics",
+            media_type="application/octet-stream",
+        )
+        builder.add_stream(
+            "physics/process.json",
+            io.BytesIO(b'{}\n'),
+            role="runtime-physics",
+            media_type="application/json",
+            process_id="dd_to_z",
+            chunk_size=2,
+        )
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=_producer(),
+            model=_model(),
+            configuration=_configuration(),
+            processes=[_process()],
+            default_process_id="dd_to_z",
+            runtime=_runtime(),
+        )
+
+    assert (root / "payloads/streamed.bin").stat().st_size == source.stat().st_size
+    assert (root / "payloads/registered.bin").read_bytes() == b"registered"
+
+
+def test_builder_round_trip_and_explicit_tamper_detection(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    manifest = load_manifest(
+        root,
+        expected_target="test-target",
+        verify_payloads=True,
+    )
+    assert manifest.default_process_id == "dd_to_z"
+    assert manifest.payloads[0].path == "physics/process.json"
+    assert manifest.runtime["required_runtime_capabilities"] == (
+        "symjit.application.complex-f64.v1",
+    )
+
+    (root / "physics/process.json").write_text("modified\n", encoding="utf-8")
+    assert load_manifest(root).artifact_id == manifest.artifact_id
+    with pytest.raises(ArtifactError, match=r"(size|digest) mismatch"):
+        load_manifest(root, verify_payloads=True)
+
+
+def test_artifact_id_tracks_only_runtime_bearing_payload_records() -> None:
+    def record(path: str, role: str, digest: str) -> dict[str, object]:
+        return {
+            "path": path,
+            "role": role,
+            "media_type": "application/octet-stream",
+            "size_bytes": 1,
+            "sha256": digest * 64,
+            "executable": False,
+        }
+
+    manifest = {
+        "artifact_id": "0" * 64,
+        "created_utc": "2026-07-31T00:00:00Z",
+        "payloads": [
+            record("config/requested.toml", "configuration-requested", "1"),
+            record("config/effective.toml", "configuration-effective", "2"),
+            record(
+                "processes/p0/validation-momenta.json",
+                "validation-momenta",
+                "3",
+            ),
+            record("processes/p0/physics.json", "runtime-physics", "4"),
+        ],
+    }
+    identity = manifest_module.compute_artifact_id(manifest)
+
+    provenance_changed = json.loads(json.dumps(manifest))
+    for item in provenance_changed["payloads"][:3]:
+        item["sha256"] = "f" * 64
+        item["size_bytes"] = 999
+    provenance_changed["created_utc"] = "2030-01-01T00:00:00Z"
+    assert manifest_module.compute_artifact_id(provenance_changed) == identity
+
+    runtime_changed = json.loads(json.dumps(manifest))
+    runtime_changed["payloads"][3]["sha256"] = "f" * 64
+    assert manifest_module.compute_artifact_id(runtime_changed) != identity
+
+
+def test_artifact_without_current_identity_contract_fails_closed(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    path = root / "artifact.json"
+    manifest = json.loads(path.read_text(encoding="utf-8"))
+    del manifest["extensions"]["artifact_identity"]
+    path.write_text(json.dumps(manifest), encoding="utf-8")
+
+    with pytest.raises(CompatibilityError, match="regenerate"):
+        load_manifest(root)
+
+
+def test_python_loader_checks_cpu_features_before_payload_bytes(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root, cpu_features=("avx2",))
+    (root / "physics/process.json").write_text("tampered\n", encoding="utf-8")
+    monkeypatch.setattr(
+        manifest_module,
+        "_runtime_target_metadata",
+        lambda: ("test-target", ("sse2",)),
+    )
+    with pytest.raises(CompatibilityError, match="unavailable CPU features: avx2"):
+        load_manifest(root, verify_payloads=True)
+
+
+def test_python_loader_accepts_available_canonical_cpu_features(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root, cpu_features=("avx2", "fma"))
+    monkeypatch.setattr(
+        manifest_module,
+        "_runtime_target_metadata",
+        lambda: ("test-target", ("avx", "avx2", "fma", "sse2")),
+    )
+    assert load_manifest(root, verify_payloads=True).producer["target"] == {
+        "triple": "test-target",
+        "cpu_features": ("avx2", "fma"),
+    }
+
+
+@pytest.mark.parametrize(
+    "runtime_target",
+    (
+        "aarch64-apple-darwin",
+        "x86_64-apple-darwin",
+        "x86_64-unknown-linux-gnu",
+    ),
+)
+def test_python_loader_accepts_portable_o2_artifact_for_every_supported_target(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    runtime_target: str,
+) -> None:
+    root = tmp_path / "artifact"
+    target = {"triple": PORTABLE_64LE_TARGET, "cpu_features": []}
+    _build(
+        root,
+        triple=PORTABLE_64LE_TARGET,
+        evaluator_state_target=target,
+    )
+    monkeypatch.setattr(
+        manifest_module,
+        "_runtime_target_metadata",
+        lambda: (_ for _ in ()).throw(
+            AssertionError("portable artifact inspection must not import Rusticol")
+        ),
+    )
+
+    manifest = load_manifest(
+        root,
+        expected_target=runtime_target,
+        verify_payloads=True,
+    )
+
+    assert manifest.producer["target"] == {
+        "triple": PORTABLE_64LE_TARGET,
+        "cpu_features": (),
+    }
+
+
+def test_python_loader_inspects_portable_artifact_without_native_runtime(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root, triple=PORTABLE_64LE_TARGET)
+    monkeypatch.setattr(
+        manifest_module,
+        "_runtime_target_metadata",
+        lambda: (_ for _ in ()).throw(ImportError("native runtime unavailable")),
+    )
+
+    assert load_manifest(root).producer["target"]["triple"] == PORTABLE_64LE_TARGET
+
+
+def test_python_loader_rejects_portable_artifact_for_unsupported_target(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root, triple=PORTABLE_64LE_TARGET)
+
+    with pytest.raises(CompatibilityError, match="aarch64-unknown-linux-gnu"):
+        load_manifest(root, expected_target="aarch64-unknown-linux-gnu")
+
+
+def test_python_loader_rejects_portable_artifact_with_cpu_features(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(
+        root,
+        triple=PORTABLE_64LE_TARGET,
+        cpu_features=("avx2",),
+    )
+
+    with pytest.raises(CompatibilityError, match="may not require CPU features"):
+        load_manifest(root)
+
+
+@pytest.mark.parametrize(
+    "runtime_capability",
+    (SYMBOLICA_CPP_RUNTIME_CAPABILITY, SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY),
+)
+def test_python_loader_rejects_target_specific_capability_under_portable_target(
+    tmp_path: Path,
+    runtime_capability: str,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(
+        root,
+        triple=PORTABLE_64LE_TARGET,
+        runtime_capabilities=(runtime_capability,),
+    )
+
+    with pytest.raises(CompatibilityError, match="target-specific evaluator"):
+        load_manifest(root)
+
+
+def test_python_loader_rejects_mismatched_portable_payload_target(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(
+        root,
+        triple=PORTABLE_64LE_TARGET,
+        evaluator_state_target={
+            "triple": "aarch64-apple-darwin",
+            "cpu_features": [],
+        },
+    )
+
+    with pytest.raises(CompatibilityError, match="differs from producer target"):
+        load_manifest(root)
+
+
+def test_python_loader_rejects_portable_artifact_on_non_64_bit_runtime(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root, triple=PORTABLE_64LE_TARGET)
+    monkeypatch.setattr(manifest_module.struct, "calcsize", lambda _format: 4)
+
+    with pytest.raises(CompatibilityError, match="64-bit little-endian"):
+        load_manifest(root)
+
+
+@pytest.mark.parametrize(
+    "features",
+    (("fma", "avx2"), ("+avx2",), ("AVX2",), ("avx_2",)),
+)
+def test_manifest_rejects_noncanonical_cpu_feature_ids(
+    tmp_path: Path, features: tuple[str, ...]
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root, cpu_features=features)
+    with pytest.raises(ArtifactError, match=r"(sorted|non-canonical)"):
+        load_manifest(root, verify_payloads=False)
+
+
+@pytest.mark.parametrize(
+    "value",
+    ("../escape", "/absolute", "a/../b", r"a\b", "./payload"),
+)
+def test_relative_paths_reject_escape_and_nonportable_forms(value: str) -> None:
+    with pytest.raises(ArtifactError):
+        normalize_relative_path(value)
+
+
+def test_explicit_validation_rejects_payload_symlink(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    payload = root / "physics/process.json"
+    target = tmp_path / "outside.json"
+    target.write_text("{}\n", encoding="utf-8")
+    payload.unlink()
+    payload.symlink_to(target)
+    with pytest.raises(ArtifactError, match="symlink"):
+        load_manifest(root, verify_payloads=True)
+
+
+def test_explicit_validation_rejects_undeclared_symlink(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    target = tmp_path / "outside.txt"
+    target.write_text("outside\n", encoding="utf-8")
+    (root / "extra-link").symlink_to(target)
+    with pytest.raises(ArtifactError, match="undeclared symlink"):
+        load_manifest(root, verify_payloads=True)
+
+
+def test_explicit_validation_rejects_undeclared_executable(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    executable = root / "injected"
+    executable.write_text("#!/bin/sh\n", encoding="utf-8")
+    executable.chmod(0o755)
+    with pytest.raises(ArtifactError, match="undeclared executable"):
+        load_manifest(root, verify_payloads=True)
+
+
+def test_evaluator_state_requires_target_metadata(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    with ArtifactBuilder(root) as builder:
+        builder.add_bytes(
+            "evaluators/state.bin",
+            b"state",
+            role="evaluator-state",
+            media_type="application/octet-stream",
+        )
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=_producer(),
+            model=_model(),
+            configuration=_configuration(),
+            processes=[_process()],
+            runtime=_runtime(),
+        )
+    with pytest.raises(ArtifactError, match="no target metadata"):
+        load_manifest(root, verify_payloads=True)
+
+
+def test_artifact_root_must_be_a_directory(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact.json"
+    artifact.write_text("{}\n", encoding="utf-8")
+    with pytest.raises(ArtifactError, match="not a directory"):
+        load_manifest(artifact)
+
+
+def test_old_schema_has_actionable_regeneration_error(tmp_path: Path) -> None:
+    root = tmp_path / "old"
+    root.mkdir()
+    (root / "artifact.json").write_text(
+        json.dumps({"schema_version": 2}) + "\n", encoding="utf-8"
+    )
+    with pytest.raises(CompatibilityError, match="regenerate"):
+        load_manifest(root, verify_payloads=False)
+
+
+def test_transaction_rolls_back_failed_replace(tmp_path: Path) -> None:
+    destination = tmp_path / "artifact"
+    destination.mkdir()
+    (destination / "sentinel").write_text("old\n", encoding="utf-8")
+    with (
+        pytest.raises(RuntimeError, match="stop"),
+        ArtifactTransaction(destination, mode="replace") as staging,
+    ):
+        (staging / "sentinel").write_text("new\n", encoding="utf-8")
+        raise RuntimeError("stop")
+    assert (destination / "sentinel").read_text(encoding="utf-8") == "old\n"
+
+
+def test_transaction_atomically_replaces_existing_directory(tmp_path: Path) -> None:
+    destination = tmp_path / "artifact"
+    destination.mkdir()
+    (destination / "sentinel").write_text("old\n", encoding="utf-8")
+
+    with ArtifactTransaction(destination, mode="replace") as staging:
+        (staging / "sentinel").write_text("new\n", encoding="utf-8")
+
+    assert (destination / "sentinel").read_text(encoding="utf-8") == "new\n"
+    assert not tuple(tmp_path.glob(".artifact.staging-*"))
+
+
+def test_append_starts_from_existing_snapshot(tmp_path: Path) -> None:
+    destination = tmp_path / "artifact"
+    destination.mkdir()
+    (destination / "old").write_text("preserved\n", encoding="utf-8")
+    with ArtifactTransaction(destination, mode="append") as staging:
+        (staging / "new").write_text("added\n", encoding="utf-8")
+    assert (destination / "old").read_text(encoding="utf-8") == "preserved\n"
+    assert (destination / "new").read_text(encoding="utf-8") == "added\n"
+
+
+def test_builder_append_retains_declared_payloads_and_adds_new_ones(
+    tmp_path: Path,
+) -> None:
+    destination = tmp_path / "artifact"
+    _build(destination)
+
+    with ArtifactBuilder(destination, mode="append") as builder:
+        builder.add_json(
+            "physics/additional.json",
+            {"schema_version": 1},
+            role="runtime-physics",
+            process_id="dd_to_zg",
+        )
+        builder.finalize(
+            kind="pyamplicol-process-set",
+            producer=_producer(),
+            model=_model(),
+            configuration=_configuration(),
+            processes=[_process(), _process("dd_to_zg")],
+            default_process_id="dd_to_z",
+            runtime=_runtime(),
+        )
+
+    manifest = load_manifest(destination)
+    assert [record.path for record in manifest.payloads] == [
+        "physics/additional.json",
+        "physics/process.json",
+    ]
+    assert (destination / "physics/process.json").is_file()
+
+
+def test_evaluator_container_append_migrates_loose_and_reuses_old_members(
+    tmp_path: Path,
+) -> None:
+    destination = tmp_path / "artifact"
+    target = _producer()["target"]
+    with ArtifactBuilder(destination) as builder:
+        builder.add_json(
+            "physics/process.json",
+            {"schema_version": 1},
+            role="runtime-physics",
+            process_id="dd_to_z",
+        )
+        for relative, content in (
+            ("processes/old/application.symjit", b"old-application"),
+            ("processes/old/state.evaluator.bin", b"old-state"),
+            ("processes/old/library.dylib", b"native-library"),
+        ):
+            builder.add_bytes(
+                relative,
+                content,
+                role="evaluator-state",
+                media_type="application/octet-stream",
+                target=target,
+                process_id="dd_to_z",
+            )
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=_producer(),
+            model=_model(),
+            configuration=_configuration(),
+            processes=[_process()],
+            default_process_id="dd_to_z",
+            runtime=_runtime(),
+        )
+
+    replacement = tmp_path / "replacement.symjit"
+    replacement.write_bytes(b"replacement-application")
+    added = tmp_path / "added.evaluator.bin"
+    added.write_bytes(b"added-state")
+    existing = load_manifest(destination)
+    with ArtifactBuilder(
+        destination,
+        mode="append",
+        expected_artifact_id=existing.artifact_id,
+    ) as builder:
+        collector = generation_artifact_writer._EvaluatorPayloadCollector(
+            builder,
+            existing=existing,
+            target=target,
+        )
+        collector.add_file(
+            "processes/old/application.symjit",
+            replacement,
+            process_id="dd_to_z",
+        )
+        collector.add_file(
+            "processes/new/state.evaluator.bin",
+            added,
+            process_id="dd_to_z",
+        )
+        extension = collector.publish()
+        assert extension is not None
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=existing.producer,
+            model=existing.model,
+            configuration=existing.configuration,
+            processes=existing.processes,
+            default_process_id=existing.default_process_id,
+            runtime=existing.runtime,
+            dependencies=existing.dependencies,
+            extensions={"evaluator_payload_container": extension},
+        )
+
+    migrated = load_manifest(destination)
+    declared = {record.path for record in migrated.payloads}
+    assert "evaluators.pacbin" in declared
+    assert "processes/old/library.dylib" in declared
+    assert "processes/old/application.symjit" not in declared
+    assert "processes/old/state.evaluator.bin" not in declared
+    with PacbinReader.open(destination / "evaluators.pacbin") as container:
+        assert container.read_member(
+            "processes/old/application.symjit",
+            length=len(b"replacement-application"),
+        ) == b"replacement-application"
+        assert container.read_member(
+            "processes/old/state.evaluator.bin",
+            length=len(b"old-state"),
+        ) == b"old-state"
+        assert container.read_member(
+            "processes/new/state.evaluator.bin",
+            length=len(b"added-state"),
+        ) == b"added-state"
+
+    second = tmp_path / "second.symjit"
+    second.write_bytes(b"second-application")
+    existing = load_manifest(destination)
+    with ArtifactBuilder(
+        destination,
+        mode="append",
+        expected_artifact_id=existing.artifact_id,
+    ) as builder:
+        collector = generation_artifact_writer._EvaluatorPayloadCollector(
+            builder,
+            existing=existing,
+            target=target,
+        )
+        collector.add_file(
+            "processes/second/application.symjit",
+            second,
+            process_id="dd_to_z",
+        )
+        extension = collector.publish()
+        assert extension is not None
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=existing.producer,
+            model=existing.model,
+            configuration=existing.configuration,
+            processes=existing.processes,
+            default_process_id=existing.default_process_id,
+            runtime=existing.runtime,
+            dependencies=existing.dependencies,
+            extensions={"evaluator_payload_container": extension},
+        )
+    with PacbinReader.open(destination / "evaluators.pacbin") as container:
+        assert {member.logical_path for member in container.members} == {
+            "processes/new/state.evaluator.bin",
+            "processes/old/application.symjit",
+            "processes/old/state.evaluator.bin",
+            "processes/second/application.symjit",
+        }
+
+
+def test_evaluator_container_failed_repack_preserves_published_artifact(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    destination = tmp_path / "artifact"
+    _build(destination)
+    before = {
+        path.relative_to(destination).as_posix(): path.read_bytes()
+        for path in destination.rglob("*")
+        if path.is_file()
+    }
+    source = tmp_path / "application.symjit"
+    source.write_bytes(b"application")
+    existing = load_manifest(destination)
+
+    def fail_after_partial_write(path: Path, *_args: object, **_kwargs: object) -> None:
+        path.write_bytes(b"malformed-partial-container")
+        raise RuntimeError("injected container interruption")
+
+    monkeypatch.setattr(
+        generation_artifact_writer,
+        "write_pacbin_atomic",
+        fail_after_partial_write,
+    )
+    with (
+        pytest.raises(RuntimeError, match="injected container interruption"),
+        ArtifactBuilder(
+            destination,
+            mode="append",
+            expected_artifact_id=existing.artifact_id,
+        ) as builder,
+    ):
+        collector = generation_artifact_writer._EvaluatorPayloadCollector(
+            builder,
+            existing=existing,
+            target=existing.producer["target"],
+        )
+        collector.add_file(
+            "processes/new/application.symjit",
+            source,
+            process_id="dd_to_z",
+        )
+        collector.publish()
+
+    after = {
+        path.relative_to(destination).as_posix(): path.read_bytes()
+        for path in destination.rglob("*")
+        if path.is_file()
+    }
+    assert after == before
+
+
+def test_evaluator_container_snapshots_registered_files(tmp_path: Path) -> None:
+    destination = tmp_path / "artifact"
+    source = tmp_path / "reused.symjit"
+    source.write_bytes(b"first-application")
+    target = _producer()["target"]
+
+    with ArtifactBuilder(destination) as builder:
+        collector = generation_artifact_writer._EvaluatorPayloadCollector(
+            builder,
+            existing=None,
+            target=target,
+        )
+        collector.add_file(
+            "processes/first/application.symjit",
+            source,
+            process_id="dd_to_z",
+        )
+        source.write_bytes(b"second-application")
+        collector.add_file(
+            "processes/second/application.symjit",
+            source,
+            process_id="dd_to_z",
+        )
+        extension = collector.publish()
+        assert extension is not None
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=_producer(),
+            model=_model(),
+            configuration=_configuration(),
+            processes=[_process()],
+            default_process_id="dd_to_z",
+            runtime=_runtime(),
+            extensions={"evaluator_payload_container": extension},
+        )
+
+    with PacbinReader.open(destination / "evaluators.pacbin") as container:
+        assert container.read_member(
+            "processes/first/application.symjit",
+            length=len(b"first-application"),
+        ) == b"first-application"
+        assert container.read_member(
+            "processes/second/application.symjit",
+            length=len(b"second-application"),
+        ) == b"second-application"
+
+
+def test_manifest_rejects_unknown_nested_fields(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    path = root / "artifact.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["producer"]["unexpected"] = True
+    path.write_text(json.dumps(payload), encoding="utf-8")
+    with pytest.raises(ArtifactError, match="unknown fields"):
+        load_manifest(root, verify_payloads=False)
+
+
+def test_manifest_accepts_native_digest_without_git_revision(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    path = root / "artifact.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["producer"]["native_build_inputs_sha256"] = "a" * 64
+    path.write_text(json.dumps(payload), encoding="utf-8")
+
+    producer = load_manifest(root, verify_payloads=False).producer
+
+    assert producer["native_build_inputs_sha256"] == "a" * 64
+    assert "git_revision" not in producer
+
+
+def test_manifest_rejects_noncanonical_runtime_capabilities(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    path = root / "artifact.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["runtime"]["required_runtime_capabilities"] = [
+        "symjit.application.complex-f64.v1",
+        "symbolica.compiled-cpp.complex-f64.v1",
+    ]
+    path.write_text(json.dumps(payload), encoding="utf-8")
+    with pytest.raises(ArtifactError, match="must be sorted"):
+        load_manifest(root, verify_payloads=False)
+
+
+def test_manifest_rejects_unknown_runtime_capability(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    path = root / "artifact.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["runtime"]["required_runtime_capabilities"] = ["unknown.runtime.v1"]
+    path.write_text(json.dumps(payload), encoding="utf-8")
+    with pytest.raises(ArtifactError, match="unsupported capabilities"):
+        load_manifest(root, verify_payloads=False)
+
+
+def test_manifest_rejects_runtime_capabilities_not_owned_by_a_process(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    path = root / "artifact.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["runtime"]["required_runtime_capabilities"] = [
+        "symbolica.compiled-cpp.complex-f64.v1",
+        "symjit.application.complex-f64.v1",
+    ]
+    path.write_text(json.dumps(payload), encoding="utf-8")
+    with pytest.raises(ArtifactError, match="must equal the union"):
+        load_manifest(root, verify_payloads=False)
+
+
+@pytest.mark.parametrize(
+    ("permutation", "message"),
+    (
+        ([0, 1], "complete permutation"),
+        ([0, 0, 2], "complete permutation"),
+        ([0, 2, 1], "incoming and outgoing sides"),
+    ),
+)
+def test_manifest_rejects_invalid_alias_permutations(
+    tmp_path: Path,
+    permutation: list[int],
+    message: str,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    path = root / "artifact.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["processes"][0]["aliases"] = [
+        {
+            "id": "alias",
+            "expression": "d d~ > z",
+            "external_pdgs": [1, -1, 23],
+            "external_permutation": permutation,
+        }
+    ]
+    path.write_text(json.dumps(payload), encoding="utf-8")
+
+    with pytest.raises(ArtifactError, match=message):
+        load_manifest(root, verify_payloads=False)
+
+
+def test_manifest_accepts_alias_permutations_on_both_sides(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    path = root / "artifact.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["processes"][0]["aliases"] = [
+        {
+            "id": "incoming_swap",
+            "expression": "d~ d > z",
+            "external_pdgs": [-1, 1, 23],
+            "external_permutation": [1, 0, 2],
+        }
+    ]
+    payload["artifact_id"] = manifest_module.compute_artifact_id(payload)
+    path.write_text(json.dumps(payload), encoding="utf-8")
+
+    manifest = load_manifest(root, verify_payloads=False)
+
+    assert manifest.processes[0]["aliases"][0]["external_permutation"] == (1, 0, 2)
+
+
+def test_manifest_alias_records_permuted_public_particle_order(tmp_path: Path) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    path = root / "artifact.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["processes"][0].update(
+        {
+            "expression": "d d~ > z g a",
+            "external_pdgs": [1, -1, 23, 21, 22],
+            "aliases": [
+                {
+                    "id": "cycled",
+                    "expression": "d d~ > a z g",
+                    "external_pdgs": [1, -1, 22, 23, 21],
+                    "external_permutation": [0, 1, 3, 4, 2],
+                }
+            ],
+        }
+    )
+    payload["artifact_id"] = manifest_module.compute_artifact_id(payload)
+    path.write_text(json.dumps(payload), encoding="utf-8")
+
+    manifest = load_manifest(root, verify_payloads=False)
+
+    assert manifest.processes[0]["aliases"][0] == {
+        "id": "cycled",
+        "expression": "d d~ > a z g",
+        "external_pdgs": (1, -1, 22, 23, 21),
+        "external_permutation": (0, 1, 3, 4, 2),
+    }
+
+
+def test_manifest_rejects_alias_pdg_order_inconsistent_with_permutation(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    path = root / "artifact.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["processes"][0]["aliases"] = [
+        {
+            "id": "alias",
+            "expression": "d d~ > z",
+            "external_pdgs": [1, -1, 22],
+            "external_permutation": [0, 1, 2],
+        }
+    ]
+    path.write_text(json.dumps(payload), encoding="utf-8")
+
+    with pytest.raises(ArtifactError, match="does not match external_permutation"):
+        load_manifest(root, verify_payloads=False)
+
+
+def _flavor_blind_group_map() -> ProcessGroupMap:
+    return initial_process_groups(
+        [("dd_to_z", "d d~ > z", (1, -1, 23))],
+        {
+            "dd_to_z": [
+                GroupMember(
+                    process_id="uu_to_z",
+                    expression="u u~ > z",
+                    pdgs=(2, -2, 23),
+                    initial_count=2,
+                    permutation=(0, 1, 2),
+                    basis=GroupingBasis.FLAVOR_BLIND,
+                    generated=False,
+                    warning="Z couplings differ between d and u",
+                )
+            ]
+        },
+    )
+
+
+def test_process_groups_are_rewritten_in_place_without_changing_identity(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    assert read_process_groups(root) is None
+    before = load_manifest(root)
+
+    group_map = _flavor_blind_group_map()
+    write_process_groups(root, group_map)
+    first = load_manifest(root, verify_payloads=True)
+    stored = read_process_groups(root)
+    assert stored is not None
+    assert stored.as_document() == group_map.as_document()
+    assert first.artifact_id == before.artifact_id
+    assert [
+        (record.path, record.role, record.media_type) for record in first.payloads
+    ] == [
+        ("physics/process.json", "runtime-physics", "application/json"),
+        ("process-groups.json", "process-groups", "application/json"),
+    ]
+
+    stored.analyses.append({"analysis": "numerical", "merged": 0})
+    write_process_groups(root, stored)
+    second = load_manifest(root, verify_payloads=True)
+    assert second.artifact_id == before.artifact_id
+    assert second.payloads[1].sha256 != first.payloads[1].sha256
+    reread = read_process_groups(root)
+    assert reread is not None
+    assert reread.analyses == [{"analysis": "numerical", "merged": 0}]
+
+
+def test_process_groups_must_list_each_artifact_process_once(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    unrelated = initial_process_groups([("uu_to_z", "u u~ > z", (2, -2, 23))])
+    with pytest.raises(ArtifactError, match="missing: \\['dd_to_z'\\]"):
+        write_process_groups(root, unrelated)
+    assert read_process_groups(root) is None
+
+
+def test_process_group_update_waits_for_the_generation_lock(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "artifact"
+    _build(root)
+    writer = threading.Thread(
+        target=write_process_groups, args=(root, _flavor_blind_group_map())
+    )
+    with ArtifactTransaction(root, mode="append"):
+        writer.start()
+        writer.join(timeout=0.2)
+        assert writer.is_alive()
+        assert read_process_groups(root) is None
+    writer.join()
+    assert read_process_groups(root) is not None
+    load_manifest(root, verify_payloads=True)
diff --git a/pyamplicol/tests/unit/test_automatic_fft_contraction.py b/pyamplicol/tests/unit/test_automatic_fft_contraction.py
new file mode 100644
index 0000000000..0e813bc4c9
--- /dev/null
+++ b/pyamplicol/tests/unit/test_automatic_fft_contraction.py
@@ -0,0 +1,99 @@
+# SPDX-License-Identifier: 0BSD
+"""Automatic FFT uses the existing support verdict, never an exception catch."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.color import ColorContractionPlan, build_color_plan
+from pyamplicol.generation import recurrence_physics as physics
+from pyamplicol.generation import service
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _contract(lane: str, method: str):
+    process = build_process_ir("g g > g g", color_accuracy="full")
+    plan = build_color_plan(process, color_accuracy="full")
+    if lane == "on-the-fly":
+        return physics.build_on_the_fly_color_contraction(plan, contraction=method)[0]
+    labels = tuple(leg.label for leg in process.legs)
+    logical = SimpleNamespace(
+        layout="contracted-color-union",
+        replay_partitions=(),
+        external_legs=tuple(
+            SimpleNamespace(source_slot=slot, public_label=label)
+            for slot, label in enumerate(labels)
+        ),
+        physical_sectors=tuple(
+            SimpleNamespace(
+                sector_id=sector.id,
+                kind=sector.kind,
+                word_source_slots=tuple(
+                    labels.index(label) for label in sector.color_words[0]
+                ),
+            )
+            for sector in plan.sectors
+        ),
+    )
+    return physics.build_recurrence_color_contraction(
+        logical,
+        plan,
+        ((-1, -1, 1, 1),),
+        tuple((sector.id, 0) for sector in plan.sectors),
+        (),
+        contraction=method,
+    )
+
+
+@pytest.mark.parametrize("lane", ("recurrence", "on-the-fly"))
+def test_automatic_contraction_selects_a_supported_fft_plan(lane):
+    automatic = _contract(lane, "auto")
+    forced = _contract(lane, "symmetric-group-fft")
+    assert automatic == forced
+    assert automatic.symmetric_group_block is not None
+
+
+@pytest.mark.parametrize("lane", ("recurrence", "on-the-fly"))
+def test_only_automatic_contraction_falls_back_on_unsupported_fft(lane, monkeypatch):
+    calls = []
+
+    def unsupported(plan, groups, **_kwargs):
+        calls.append(True)
+        return ColorContractionPlan(
+            color_accuracy=plan.color_accuracy,
+            supported=False,
+            reason="test: no certified permutation orbit",
+            group_count=len(groups),
+            entries=(),
+        )
+
+    monkeypatch.setattr(
+        physics, "build_symmetric_group_color_contraction_plan", unsupported
+    )
+    direct = _contract(lane, "direct")
+    assert not calls  # The explicit opt-out does not even probe FFT support.
+    assert _contract(lane, "auto") == direct
+    with pytest.raises(ValueError, match="no certified permutation orbit"):
+        _contract(lane, "symmetric-group-fft")
+    assert len(calls) == 2
+    if lane == "on-the-fly":
+        process = build_process_ir("g g > g g", color_accuracy="full")
+        plan = build_color_plan(process, color_accuracy="full")
+        payload = service._build_on_the_fly_contracted_color_payload_v1(
+            plan, contraction="auto"
+        )
+        assert payload.summary["storage"] == "expanded"
+        assert payload.summary["factorization"] is None
+        assert "fft_provenance" not in payload.summary
+
+
+@pytest.mark.parametrize("lane", ("recurrence", "on-the-fly"))
+def test_automatic_contraction_does_not_hide_unrelated_failures(lane, monkeypatch):
+    def broken(*_args, **_kwargs):
+        raise RuntimeError("unexpected FFT construction failure")
+
+    monkeypatch.setattr(physics, "build_symmetric_group_color_contraction_plan", broken)
+    with pytest.raises(RuntimeError, match="unexpected FFT construction failure"):
+        _contract(lane, "auto")
diff --git a/pyamplicol/tests/unit/test_benchmarking.py b/pyamplicol/tests/unit/test_benchmarking.py
new file mode 100644
index 0000000000..06504e0273
--- /dev/null
+++ b/pyamplicol/tests/unit/test_benchmarking.py
@@ -0,0 +1,2466 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import warnings
+from collections.abc import Mapping
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+import pyamplicol.benchmarking as benchmark_module
+from pyamplicol.api import (
+    BenchmarkProfileCounters,
+    BenchmarkTimingBreakdown,
+    ColorFlow,
+    HelicityConfiguration,
+    PhysicsReduction,
+    ProcessPhysics,
+    ReductionGroup,
+    ResolvedEvaluation,
+)
+from pyamplicol.api.errors import EvaluationError
+from pyamplicol.benchmarking import BenchmarkBackend
+from pyamplicol.config import BenchmarkConfig
+from pyamplicol.reporting import (
+    CallbackProgressSink,
+    ProgressEnd,
+    ProgressStart,
+    ProgressUpdate,
+)
+
+
+class _Runtime:
+    calls = 0
+    last_options: dict[str, object] | None = None
+
+    @property
+    def physics(self) -> ProcessPhysics:
+        return ProcessPhysics(
+            "test",
+            "d d~ > z",
+            "lc",
+            "all",
+            "all",
+            "flow",
+            0,
+            (),
+            (HelicityConfiguration("h0", 0, (1, -1), True, False, "h0", 1.0),),
+            (ColorFlow("c0", 0, (1,), True, "c0", 1.0),),
+            (),
+            PhysicsReduction(
+                "lc-diagonal",
+                (ReductionGroup("g0", "h0", "c0", ("h0",), ("c0",)),),
+            ),
+            (),
+            (),
+        )
+
+    def evaluate(self, momenta: object, **selectors: object) -> tuple[complex, ...]:
+        self.calls += 1
+        self.last_options = selectors
+        return tuple(1.0 + 0.0j for _ in momenta)  # type: ignore[union-attr]
+
+    def evaluate_resolved(
+        self, momenta: object, **selectors: object
+    ) -> ResolvedEvaluation:
+        del momenta, selectors
+        return ResolvedEvaluation((((1.0 + 0.0j,),),), ("h0",), ("c0",))
+
+    def set_model_parameters(self, mapping: object) -> None:
+        del mapping
+
+    def clear(self) -> None:
+        pass
+
+    def mute_warnings(self) -> None:
+        pass
+
+    def unmute_warnings(self) -> None:
+        pass
+
+
+class _RuntimeTwoAxes(_Runtime):
+    @property
+    def physics(self) -> ProcessPhysics:
+        helicities = (
+            HelicityConfiguration("h0", 0, (1, -1), True, False, "h0", 1.0),
+            HelicityConfiguration("h1", 1, (-1, 1), True, False, "h1", 1.0),
+        )
+        flows = (
+            ColorFlow("c0", 0, (1,), True, "c0", 1.0),
+            ColorFlow("c1", 1, (2,), True, "c1", 1.0),
+        )
+        return ProcessPhysics(
+            "test",
+            "d d~ > z",
+            "lc",
+            "all",
+            "all",
+            "flow",
+            0,
+            (),
+            helicities,
+            flows,
+            (),
+            PhysicsReduction(
+                "lc-diagonal",
+                (
+                    ReductionGroup(
+                        "g0",
+                        "h0",
+                        "c0",
+                        tuple(item.id for item in helicities),
+                        tuple(item.id for item in flows),
+                    ),
+                ),
+            ),
+            (),
+            (),
+        )
+
+
+class _ImmutableRuntime:
+    __slots__ = ("_artifact_path", "_delegate")
+
+    def __init__(self, delegate: _RuntimeTwoAxes, artifact_path: Path) -> None:
+        self._delegate = delegate
+        self._artifact_path = artifact_path
+
+    def __getattr__(self, name: str) -> object:
+        return getattr(self._delegate, name)
+
+    @property
+    def physics(self) -> ProcessPhysics:
+        return self._delegate.physics
+
+    def evaluate(self, momenta: object, **selectors: object) -> tuple[complex, ...]:
+        return self._delegate.evaluate(momenta, **selectors)
+
+    def evaluate_resolved(
+        self, momenta: object, **selectors: object
+    ) -> ResolvedEvaluation:
+        return self._delegate.evaluate_resolved(momenta, **selectors)
+
+    def set_model_parameters(self, mapping: object) -> None:
+        self._delegate.set_model_parameters(mapping)
+
+    def clear(self) -> None:
+        self._delegate.clear()
+
+    def mute_warnings(self) -> None:
+        self._delegate.mute_warnings()
+
+    def unmute_warnings(self) -> None:
+        self._delegate.unmute_warnings()
+
+
+class _RuntimeWithValidation(_Runtime):
+    def validation_momenta(self) -> object:
+        return (((1.0, 0.0, 0.0, 1.0),),)
+
+
+class _RuntimeWithProfile(_Runtime):
+    profile_calls = 0
+
+    def profile(self, momenta: object, **kwargs: object) -> dict[str, object]:
+        self.profile_calls += 1
+        assert kwargs["helicities"] == ("h0",)
+        assert kwargs["color_flows"] is None
+        assert kwargs["precision"] == 16
+        assert kwargs["include_values"] is False
+        return {
+            "points": len(momenta),  # type: ignore[arg-type]
+            "wall_time_s": 12.0e-6,
+            "source_fill_time_s": 1.0e-6,
+            "momentum_setup_time_s": 0.5e-6,
+            "stage_input_pack_time_s": 1.0e-6,
+            "stage_leaf_input_pack_time_s": 0.3e-6,
+            "stage_evaluator_call_time_s": 2.0e-6,
+            "stage_backend_call_time_s": 1.4e-6,
+            "stage_evaluator_output_gather_time_s": 0.3e-6,
+            "output_assign_time_s": 0.5e-6,
+            "amplitude_input_pack_time_s": 0.5e-6,
+            "amplitude_evaluator_call_time_s": 6.0e-6,
+            "amplitude_leaf_input_pack_time_s": 0.5e-6,
+            "amplitude_backend_call_time_s": 4.5e-6,
+            "amplitude_evaluator_output_gather_time_s": 0.5e-6,
+            "amplitude_output_remap_time_s": 0.5e-6,
+            "reduction_time_s": 0.5e-6,
+            "stage_input_pack_by_stage_time_s": [0.5e-6, 0.5e-6],
+            "stage_leaf_input_pack_by_stage_time_s": [0.1e-6, 0.2e-6],
+            "stage_evaluator_call_by_stage_time_s": [0.5e-6, 1.5e-6],
+            "stage_backend_call_by_stage_time_s": [0.4e-6, 1.0e-6],
+            "stage_evaluator_output_gather_by_stage_time_s": [0.0, 0.3e-6],
+            "stage_output_assign_by_stage_time_s": [0.25e-6, 0.25e-6],
+        }
+
+
+class _RuntimeWithUnavailableProfile(_Runtime):
+    supports_profiling = False
+
+    def profile(self, _momenta: object, **_kwargs: object) -> dict[str, object]:
+        raise AssertionError("unavailable native profiler must not be called")
+
+    def profile_repeated(
+        self, _momenta: object, _repetitions: int, **_kwargs: object
+    ) -> dict[str, object]:
+        raise AssertionError("unavailable repeated native profiler must not be called")
+
+
+class _RuntimeWithPerStageProfile(_RuntimeWithProfile):
+    def profile(self, momenta: object, **kwargs: object) -> dict[str, object]:
+        profile = super().profile(momenta, **kwargs)
+        profile["stage_evaluator_call_time_s"] = -1.0
+        profile["stage_evaluator_call_by_stage_time_s"] = [0.5e-6, 1.5e-6]
+        return profile
+
+
+class _RuntimeWithEagerProfile(_RuntimeWithProfile):
+    def profile(self, momenta: object, **kwargs: object) -> dict[str, object]:
+        profile = super().profile(momenta, **kwargs)
+        profile["wall_time_s"] = 100.0e-6
+        profile["stage_input_pack_by_stage_time_s"] = []
+        profile["stage_evaluator_call_by_stage_time_s"] = []
+        profile["stage_output_assign_by_stage_time_s"] = []
+        profile["stage_evaluator_call_time_s"] = 80.0e-6
+        profile["amplitude_evaluator_call_time_s"] = 0.0
+        return profile
+
+
+class _RuntimeWithDetailedEagerProfile(_RuntimeWithEagerProfile):
+    def profile(self, momenta: object, **kwargs: object) -> dict[str, object]:
+        profile = super().profile(momenta, **kwargs)
+        profile.update(
+            {
+                "execution_mode": "eager",
+                "eager_initialize_time_s": 2.0e-6,
+                "eager_gather_time_s": 4.0e-6,
+                "eager_kernel_call_time_s": 24.0e-6,
+                "eager_invocation_scatter_time_s": 12.0e-6,
+                "eager_finalization_time_s": 20.0e-6,
+                "eager_scatter_finalization_time_s": 32.0e-6,
+                "eager_closure_time_s": 4.0e-6,
+                "eager_copy_out_time_s": 6.0e-6,
+            }
+        )
+        return profile
+
+
+class _RuntimeWithAmplitudeOnlyCompiledProfile(_RuntimeWithProfile):
+    def profile(self, momenta: object, **kwargs: object) -> dict[str, object]:
+        profile = super().profile(momenta, **kwargs)
+        profile["stage_input_pack_by_stage_time_s"] = []
+        profile["stage_evaluator_call_by_stage_time_s"] = []
+        profile["stage_output_assign_by_stage_time_s"] = []
+        profile["stage_evaluator_call_time_s"] = 0.0
+        return profile
+
+
+class _Clock:
+    def __init__(self) -> None:
+        self.value = 0.0
+
+    def perf_counter(self) -> float:
+        return self.value
+
+
+class _TimedRuntime(_Runtime):
+    def __init__(self, clock: _Clock, duration: float = 1.0e-3) -> None:
+        self.clock = clock
+        self.duration = duration
+
+    def evaluate(self, momenta: object, **selectors: object) -> tuple[complex, ...]:
+        self.calls += 1
+        self.last_options = selectors
+        self.clock.value += self.duration
+        return tuple(1.0 + 0.0j for _ in momenta)  # type: ignore[union-attr]
+
+
+class _TimedRuntimeWithProfile(_TimedRuntime):
+    def __init__(self, clock: _Clock) -> None:
+        super().__init__(clock)
+        self.profile_calls = 0
+
+    def profile(self, momenta: object, **kwargs: object) -> dict[str, object]:
+        del kwargs
+        self.profile_calls += 1
+        return {
+            "points": len(momenta),  # type: ignore[arg-type]
+            "stage_evaluator_call_time_s": 2.0e-6,
+            "amplitude_evaluator_call_time_s": 6.0e-6,
+        }
+
+
+class _TimedRuntimeWithNativeWall(_TimedRuntimeWithProfile):
+    native_wall_calls = 0
+    outer_seconds_per_repetition = 0.6e-3
+    evaluator_total_seconds_per_repetition = 0.5e-3
+
+    def _benchmark_f64_wall_time(
+        self,
+        momenta: object,
+        repetitions: int,
+        *,
+        helicities: object,
+        color_flows: object,
+        precision: int,
+    ) -> float:
+        assert len(momenta) == 2  # type: ignore[arg-type]
+        assert helicities is None
+        assert color_flows is None
+        assert precision == 16
+        self.native_wall_calls += 1
+        self.clock.value += repetitions * self.outer_seconds_per_repetition
+        return repetitions * self.evaluator_total_seconds_per_repetition
+
+
+class _TimedRuntimeWithCalibrationUndershoot(_TimedRuntimeWithNativeWall):
+    def __init__(self, clock: _Clock) -> None:
+        super().__init__(clock)
+        self.native_wall_calls = 0
+
+    def _benchmark_f64_wall_time(
+        self,
+        momenta: object,
+        repetitions: int,
+        *,
+        helicities: object,
+        color_flows: object,
+        precision: int,
+    ) -> float:
+        assert len(momenta) == 2  # type: ignore[arg-type]
+        assert helicities is None
+        assert color_flows is None
+        assert precision == 16
+        self.native_wall_calls += 1
+        duration = 1.0 if self.native_wall_calls == 1 else repetitions * 0.233
+        self.clock.value += duration
+        return duration
+
+
+class _TimedRuntimeWithRepeatedProfile(_TimedRuntimeWithNativeWall):
+    repeated_profile_calls = 0
+
+    def profile_repeated(
+        self,
+        momenta: object,
+        repetitions: int,
+        **kwargs: object,
+    ) -> dict[str, object]:
+        assert kwargs["helicities"] is None
+        assert kwargs["color_flows"] is None
+        assert kwargs["precision"] == 16
+        assert kwargs["include_values"] is False
+        self.repeated_profile_calls += 1
+        points = len(momenta) * repetitions  # type: ignore[arg-type]
+        return {
+            "points": points,
+            "wall_time_s": points * 4.0e-6,
+            "stage_evaluator_call_time_s": points * 2.0e-6,
+            "amplitude_evaluator_call_time_s": points * 0.5e-6,
+            "reduction_time_s": points * 0.5e-6,
+            "native_input_component_count": points * 4,
+            "stage_input_copy_component_count": points * 7,
+            "evaluator_backend_call_count": repetitions * 3,
+            "observed_scratch_reallocation_count": 0,
+            "native_output_allocation_count": repetitions,
+        }
+
+
+class _TimedRuntimeWithCompiledDirectArenaRepeatedProfile(
+    _TimedRuntimeWithRepeatedProfile
+):
+    def profile_repeated(
+        self,
+        momenta: object,
+        repetitions: int,
+        **kwargs: object,
+    ) -> dict[str, object]:
+        assert kwargs["helicities"] is None
+        assert kwargs["color_flows"] is None
+        assert kwargs["precision"] == 16
+        assert kwargs["include_values"] is False
+        self.repeated_profile_calls += 1
+        points = len(momenta) * repetitions  # type: ignore[arg-type]
+        return {
+            "execution_mode": "compiled",
+            "points": points,
+            "wall_time_s": points * 6.0e-6,
+            "orchestration_time_s": points * 3.5e-6,
+            "stage_evaluator_call_time_s": 0.0,
+            "amplitude_evaluator_call_time_s": 0.0,
+            "evaluator_backend_call_count": repetitions * 3,
+            "compiled_direct_arena_engine_count": repetitions * 2,
+            "compiled_direct_arena_call_count": repetitions * 3,
+            "compiled_direct_arena_boundary_input_bytes": 0,
+            "compiled_direct_arena_boundary_current_output_bytes": 0,
+            "compiled_direct_arena_boundary_amplitude_output_bytes": 0,
+        }
+
+
+class _TimedRuntimeWithBelowResolutionCompiledDirectArenaProfile(
+    _TimedRuntimeWithCompiledDirectArenaRepeatedProfile
+):
+    def profile_repeated(
+        self,
+        momenta: object,
+        repetitions: int,
+        **kwargs: object,
+    ) -> dict[str, object]:
+        profile = super().profile_repeated(momenta, repetitions, **kwargs)
+        profile["orchestration_time_s"] = 0.0
+        return profile
+
+
+class _TimedRuntimeWithRecurrenceRepeatedProfile(_TimedRuntimeWithRepeatedProfile):
+    def profile_repeated(
+        self,
+        momenta: object,
+        repetitions: int,
+        **kwargs: object,
+    ) -> dict[str, object]:
+        assert kwargs["helicities"] is None
+        assert kwargs["color_flows"] is None
+        assert kwargs["precision"] == 16
+        assert kwargs["include_values"] is False
+        self.repeated_profile_calls += 1
+        points = len(momenta) * repetitions  # type: ignore[arg-type]
+        per_point = {
+            "wall_time_s": 20.0e-6,
+            "native_input_pack_time_s": 1.0e-6,
+            "native_input_crossing_time_s": 0.5e-6,
+            "orchestration_time_s": 0.5e-6,
+            "state_prepare_time_s": 0.5e-6,
+            "state_clear_time_s": 0.5e-6,
+            "source_fill_time_s": 1.0e-6,
+            "momentum_input_setup_time_s": 0.5e-6,
+            "model_parameter_setup_time_s": 0.5e-6,
+            "recurrence_momentum_fill_time_s": 2.0e-6,
+            "recurrence_union_source_fill_time_s": 0.0,
+            "recurrence_schedule_time_s": 10.0e-6,
+            "recurrence_source_kernel_time_s": 1.0e-6,
+            "recurrence_contribution_kernel_time_s": 6.0e-6,
+            "recurrence_finalization_time_s": 2.0e-6,
+            "recurrence_closure_time_s": 1.0e-6,
+            "recurrence_replay_output_mapping_time_s": 1.0e-6,
+            "reduction_time_s": 1.0e-6,
+            "total_materialization_time_s": 0.5e-6,
+            "final_output_copy_time_s": 0.5e-6,
+        }
+        return {
+            "execution_mode": "recurrence",
+            "points": points,
+            **{key: value * points for key, value in per_point.items()},
+            "recurrence_momentum_scalar_value_count": points * 12,
+            "recurrence_schedule_execution_count": repetitions,
+            "recurrence_replay_schedule_execution_count": repetitions,
+            "recurrence_union_schedule_execution_count": 0,
+            "recurrence_union_source_row_count": 0,
+            "recurrence_replay_output_value_count": points * 2,
+            "recurrence_source_call_count": repetitions * 4,
+            "recurrence_source_row_count": repetitions * 31,
+            "recurrence_contribution_call_count": repetitions * 7,
+            "recurrence_contribution_row_count": repetitions * 126,
+            "recurrence_finalization_call_count": repetitions * 5,
+            "recurrence_finalization_row_count": repetitions * 34,
+            "recurrence_closure_call_count": repetitions * 2,
+            "recurrence_closure_row_count": repetitions * 12,
+        }
+
+
+class _TimedRuntimeWithOnTheFlyRepeatedProfile(
+    _TimedRuntimeWithRecurrenceRepeatedProfile
+):
+    def __init__(
+        self,
+        clock: _Clock,
+        *,
+        already_retained: bool = False,
+        retain_after_evaluation: bool = True,
+        structural_zero: bool = False,
+    ) -> None:
+        super().__init__(clock)
+        self.native_wall_calls = 0
+        self.repeated_profile_calls = 0
+        self.otf_events: list[str] = []
+        self.otf_context_access_count = 0
+        self.structural_zero = structural_zero
+        self.otf_census = _otf_runtime_state_census(
+            already_retained,
+            structural_zero=structural_zero,
+        )
+        self.retain_after_evaluation = retain_after_evaluation
+
+    @property
+    def execution_mode(self) -> str:
+        return "on-the-fly"
+
+    @property
+    def physics(self) -> ProcessPhysics:
+        raise AssertionError("on-the-fly benchmark opened dense physics metadata")
+
+    def _on_the_fly_benchmark_context(
+        self,
+        color_flow_ids: tuple[str, ...],
+    ) -> dict[str, object]:
+        self.otf_context_access_count += 1
+        assert color_flow_ids == ()
+        return {
+            "process_id": "otf-test",
+            "process_expression": "d d~ > t t~ g g",
+            "color_accuracy": "lc",
+            "helicity_count": 64,
+            "color_count": 24,
+            "selected_color_ids": (),
+        }
+
+    def _on_the_fly_runtime_state_census(self) -> dict[str, object]:
+        retained = self.otf_census["retained_family_count"] != 0
+        self.otf_events.append(f"census:{'retained' if retained else 'cold'}")
+        return self.otf_census
+
+    def _benchmark_f64_wall_time(
+        self,
+        momenta: object,
+        repetitions: int,
+        *,
+        helicities: object,
+        color_flows: object,
+        precision: int,
+    ) -> float:
+        self.otf_events.append("evaluate")
+        if self.retain_after_evaluation:
+            self.otf_census.clear()
+            self.otf_census.update(
+                _otf_runtime_state_census(
+                    True,
+                    structural_zero=self.structural_zero,
+                )
+            )
+        return super()._benchmark_f64_wall_time(
+            momenta,
+            repetitions,
+            helicities=helicities,
+            color_flows=color_flows,
+            precision=precision,
+        )
+
+    def profile_repeated(
+        self,
+        momenta: object,
+        repetitions: int,
+        **kwargs: object,
+    ) -> dict[str, object]:
+        profile = super().profile_repeated(momenta, repetitions, **kwargs)
+        profile["execution_mode"] = "on-the-fly"
+        return profile
+
+
+class _TimedRuntimeWithColdOnTheFlyConstruction(
+    _TimedRuntimeWithOnTheFlyRepeatedProfile
+):
+    def _benchmark_f64_wall_time(
+        self,
+        momenta: object,
+        repetitions: int,
+        *,
+        helicities: object,
+        color_flows: object,
+        precision: int,
+    ) -> float:
+        assert len(momenta) == 2  # type: ignore[arg-type]
+        assert helicities is None
+        assert color_flows is None
+        assert precision == 16
+        cold = self.otf_census["retained_family_count"] == 0
+        self.native_wall_calls += 1
+        self.otf_events.append("evaluate")
+        self.otf_census.clear()
+        self.otf_census.update(_otf_runtime_state_census(True))
+        outer_seconds = 120.0 if cold else repetitions * 0.6e-3
+        evaluator_seconds = 120.0 if cold else repetitions * 0.5e-3
+        self.clock.value += outer_seconds
+        return evaluator_seconds
+
+
+def _otf_runtime_state_census(
+    retained: bool,
+    *,
+    structural_zero: bool = False,
+) -> dict[str, object]:
+    count = int(retained)
+    executable_count = int(retained and not structural_zero)
+    active: dict[str, object] | None = None
+    if executable_count:
+        active = {
+            "basis": "shared-query-family-union-v1",
+            "scope": "active-family-union",
+            "query_count": 1,
+            "union_unique_current_count": 2,
+            "union_unique_current_component_count": 3,
+            "union_source_rows": 2,
+            "union_contribution_rows": 2,
+            "union_finalization_rows": 2,
+            "union_closure_rows": 2,
+            "union_amplitude_destination_count": 1,
+            "union_source_executor_call_groups": 1,
+            "union_contribution_executor_call_groups": 1,
+            "union_finalization_executor_call_groups": 1,
+            "union_closure_executor_call_groups": 1,
+        }
+    return {
+        "kind": "rusticol-on-the-fly-runtime-state-census-v1",
+        "process_id": "otf-test",
+        "family_cache_policy": "last-family-only",
+        "family_cache_limit": 1,
+        "process_preparation_count": count,
+        "retained_family_count": count,
+        "pending_family_count": 0,
+        "retained_selection_count": count,
+        "retained_request_count": count,
+        "retained_amplitude_destination_count": executable_count,
+        "retained_executor_handle_count": executable_count,
+        "retained_query_local_trace_count": 0,
+        "retained_embedded_lookup_key_count": 0,
+        "semantic_executor_binding_count": executable_count,
+        "active_family_union_census": active,
+    }
+
+
+def test_on_the_fly_benchmark_uses_compact_context_without_opening_physics(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithOnTheFlyRepeatedProfile(clock)
+    runtime.repeated_profile_calls = 0
+    runtime.native_wall_calls = 0
+    config = BenchmarkConfig(
+        target_runtime=0.1,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=4,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.process_id == "otf-test"
+    assert result.process_expression == "d d~ > t t~ g g"
+    assert result.environment["execution_mode"] == "on-the-fly"
+    assert result.environment["color_workload"] == "all 24 generated physical LC flows"
+    assert result.environment["helicity_workload"] == (
+        "all 64 generated helicity configurations"
+    )
+    assert result.evaluator_time_per_point == pytest.approx(10.0e-6)
+    assert result.timing_breakdown is not None
+    assert result.timing_breakdown.execution_mode == "on-the-fly"
+    assert result.timing_breakdown.recurrence_schedule_time is not None
+    assert runtime.otf_events[:4] == (
+        ["census:cold", "evaluate", "census:retained", "evaluate"]
+    )
+    environment = result.environment
+    assert environment["cold_warmup_runtime_state_evidence"] == (
+        "authenticated-native-otf-census-v1"
+    )
+    assert environment["cold_warmup_runtime_freshness"] == "authenticated-cold"
+    assert environment["cold_warmup_runtime_cold_before_first_evaluation"] is True
+    assert environment["cold_warmup_runtime_retained_before_first_evaluation"] is False
+    assert environment["cold_warmup_runtime_retained_after_first_evaluation"] is True
+    before = environment["cold_warmup_runtime_state_before"]
+    after = environment["cold_warmup_runtime_state_after"]
+    assert isinstance(before, Mapping)
+    assert isinstance(after, Mapping)
+    assert before["retained_family_count"] == 0
+    assert after["retained_family_count"] == 1
+
+
+def test_on_the_fly_benchmark_authenticates_already_retained_runtime_state(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithOnTheFlyRepeatedProfile(clock, already_retained=True)
+    config = BenchmarkConfig(
+        target_runtime=0.1,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=4,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert runtime.otf_events[:4] == (
+        ["census:retained", "evaluate", "census:retained", "evaluate"]
+    )
+    environment = result.environment
+    assert environment["cold_warmup_runtime_freshness"] == (
+        "authenticated-already-retained"
+    )
+    assert environment["cold_warmup_runtime_cold_before_first_evaluation"] is False
+    assert environment["cold_warmup_runtime_retained_before_first_evaluation"] is True
+    assert environment["cold_warmup_runtime_retained_after_first_evaluation"] is True
+
+
+def test_on_the_fly_benchmark_accepts_retained_structural_zero_state(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithOnTheFlyRepeatedProfile(
+        clock,
+        structural_zero=True,
+    )
+    result = BenchmarkBackend(
+        BenchmarkConfig(
+            target_runtime=0.1,
+            batch_size=2,
+            warmup_runs=1,
+            minimum_samples=4,
+        ),
+        None,
+    ).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    after = result.environment["cold_warmup_runtime_state_after"]
+    assert isinstance(after, Mapping)
+    assert after["retained_family_count"] == 1
+    assert after["retained_selection_count"] == 1
+    assert after["retained_request_count"] == 1
+    assert after["retained_amplitude_destination_count"] == 0
+    assert after["retained_executor_handle_count"] == 0
+    assert after["semantic_executor_binding_count"] == 0
+    assert after["active_family_union_census"] is None
+    assert (
+        result.environment["cold_warmup_runtime_retained_after_first_evaluation"]
+        is True
+    )
+    for field in (
+        "retained_amplitude_destination_count",
+        "retained_executor_handle_count",
+        "semantic_executor_binding_count",
+    ):
+        partial = dict(after)
+        partial[field] = 1
+        assert not benchmark_module._on_the_fly_runtime_state_is_retained(partial)
+
+
+def test_on_the_fly_cold_construction_does_not_seed_warm_chunk_estimate(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithColdOnTheFlyConstruction(clock)
+    guarded: list[tuple[float | None, str]] = []
+
+    def guard(estimated_seconds: float | None, description: str) -> None:
+        guarded.append((estimated_seconds, description))
+        if estimated_seconds is not None and estimated_seconds > 1.0:
+            raise AssertionError("cold construction estimate leaked into warm timing")
+
+    backend = BenchmarkBackend(
+        BenchmarkConfig(
+            target_runtime=0.01,
+            batch_size=2,
+            warmup_runs=1,
+            minimum_samples=4,
+        ),
+        None,
+    )
+    backend.set_chunk_guard(guard)
+    result = backend.run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    evaluator_guards = [
+        estimate
+        for estimate, description in guarded
+        if description == "runtime evaluator timing chunk"
+    ]
+    assert evaluator_guards[:2] == [None, None]
+    assert result.environment["cold_warmup_elapsed_seconds"] == pytest.approx(120.0)
+    assert result.environment["elapsed_seconds"] < 1.0
+
+
+@pytest.mark.parametrize(
+    ("field", "replacement", "message"),
+    (
+        ("kind", "wrong-kind", "invalid kind"),
+        ("process_id", "wrong-process", "does not match"),
+        ("family_cache_policy", "all-seen", "cache policy"),
+        ("family_cache_limit", True, "cache limit"),
+        ("retained_family_count", 2, "exceeds its cache limit"),
+        ("retained_family_count", -1, "retained_family_count"),
+        ("pending_family_count", True, "pending_family_count"),
+        ("active_family_union_census", "invalid", "active-family"),
+        ("process_preparation_count", 1, "neither cold nor fully retained"),
+    ),
+)
+def test_on_the_fly_benchmark_rejects_malformed_cold_state_before_evaluation(
+    field: str,
+    replacement: object,
+    message: str,
+) -> None:
+    runtime = _TimedRuntimeWithOnTheFlyRepeatedProfile(_Clock())
+    runtime.otf_census[field] = replacement
+
+    with pytest.raises(EvaluationError, match=message):
+        BenchmarkBackend(BenchmarkConfig(), None).run(
+            runtime,
+            points=(((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+    assert runtime.native_wall_calls == 0
+    assert "evaluate" not in runtime.otf_events
+
+
+def test_on_the_fly_benchmark_requires_first_evaluation_to_retain_family() -> None:
+    runtime = _TimedRuntimeWithOnTheFlyRepeatedProfile(
+        _Clock(),
+        retain_after_evaluation=False,
+    )
+
+    with pytest.raises(EvaluationError, match="did not leave a fully retained"):
+        BenchmarkBackend(BenchmarkConfig(batch_size=2), None).run(
+            runtime,
+            points=(((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+    assert runtime.native_wall_calls == 1
+    assert runtime.otf_events == ["census:cold", "evaluate", "census:cold"]
+
+
+def test_on_the_fly_benchmark_requires_runtime_state_census() -> None:
+    runtime = _TimedRuntimeWithOnTheFlyRepeatedProfile(_Clock())
+    runtime._on_the_fly_runtime_state_census = None  # type: ignore[method-assign]
+
+    with pytest.raises(EvaluationError, match=r"requires.*runtime state census"):
+        BenchmarkBackend(BenchmarkConfig(), None).run(
+            runtime,
+            points=(((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+    assert runtime.native_wall_calls == 0
+    assert runtime.otf_events == []
+
+
+def test_on_the_fly_benchmark_rejects_non_f64_before_compact_state_access() -> None:
+    runtime = _TimedRuntimeWithOnTheFlyRepeatedProfile(_Clock())
+
+    with pytest.raises(EvaluationError, match="supports only precision=16"):
+        BenchmarkBackend(BenchmarkConfig(precision=8), None).run(
+            runtime,
+            points=(((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+    assert runtime.otf_context_access_count == 0
+    assert runtime.native_wall_calls == 0
+    assert runtime.otf_events == []
+
+
+def test_benchmark_measures_minimum_samples_and_requested_batch() -> None:
+    runtime = _Runtime()
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=4,
+        warmup_runs=2,
+        minimum_samples=5,
+    )
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+    assert result.sample_count == 5
+    assert runtime.calls == 7
+    assert result.wall_time_per_point >= 0.0
+    assert result.evaluator_time_per_point is None
+    assert result.environment["batch_size"] == 4
+    assert result.environment["wall_time_source"] == (
+        "python_outer_perf_counter_wall_time"
+    )
+    assert result.environment["wall_time_sample_pass"] == (
+        "time.perf_counter[measure_repetitions]"
+    )
+    assert result.environment["evaluator_time_source"] == "unavailable"
+    assert result.environment["evaluator_time_status"] == "unavailable"
+    assert result.repetitions_per_sample == 1
+    assert result.evaluation_count == 5
+    assert result.evaluated_point_count == 20
+    assert result.evaluator_total_time_per_point == pytest.approx(
+        result.environment["evaluator_total_accumulated_seconds"]
+        / result.environment["measured_point_count"]
+    )
+    assert result.environment[
+        "evaluator_total_time_raw_seconds_per_point"
+    ] == pytest.approx(result.evaluator_total_time_per_point)
+    assert (
+        result.environment["evaluator_total_time_source"]
+        == "runtime.evaluate.accumulated"
+    )
+    assert (
+        result.environment["evaluator_total_time_sample_contract"]
+        == "accumulated-repeated-warmed-evaluator-total-v1"
+    )
+
+
+def _write_effective_color_config(
+    artifact: Path,
+    *,
+    accuracy: str = "lc",
+    layout: str | None = "topology-replay",
+) -> None:
+    config = artifact / "config"
+    config.mkdir(parents=True)
+    layout_line = "" if layout is None else f'lc_flow_layout = "{layout}"\n'
+    (config / "effective.toml").write_text(
+        f'[color]\naccuracy = "{accuracy}"\n{layout_line}',
+        encoding="utf-8",
+    )
+
+
+@pytest.mark.parametrize(
+    ("layout", "expected_helicities", "expected_color_flows"),
+    (
+        ("topology-replay", None, ("c0",)),
+        ("all-flow-union", ("h0",), None),
+    ),
+)
+def test_benchmark_defaults_to_generated_lc_hot_workload(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    layout: str,
+    expected_helicities: tuple[str, ...] | None,
+    expected_color_flows: tuple[str, ...] | None,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_effective_color_config(artifact, layout=layout)
+    runtime = _RuntimeTwoAxes()
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=1,
+        warmup_runs=0,
+        minimum_samples=1,
+    )
+    backend = BenchmarkBackend(config, None)
+    monkeypatch.setattr(backend, "_runtime", lambda _target: runtime)
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        result = backend.run(
+            artifact,
+            points=(((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+    assert caught == []
+    assert runtime.last_options == {
+        "helicities": expected_helicities,
+        "color_flows": expected_color_flows,
+        "precision": 16,
+    }
+    assert result.requested_config.helicity_ids == ()
+    assert result.requested_config.color_flow_ids == ()
+    assert result.effective_config.helicity_ids == tuple(expected_helicities or ())
+    assert result.effective_config.color_flow_ids == tuple(expected_color_flows or ())
+    assert result.environment["selected_helicity_ids"] == tuple(
+        expected_helicities or ()
+    )
+    assert result.environment["selected_color_ids"] == tuple(
+        expected_color_flows or ()
+    )
+
+
+def test_loaded_runtime_recovers_artifact_layout_for_profile_default(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_effective_color_config(artifact, layout="topology-replay")
+    runtime = _RuntimeTwoAxes()
+    runtime._artifact_path = artifact
+
+    result = BenchmarkBackend(
+        BenchmarkConfig(
+            target_runtime=1.0e-12,
+            batch_size=1,
+            warmup_runs=0,
+            minimum_samples=1,
+        ),
+        None,
+    ).run(runtime, points=(((1.0, 0.0, 0.0, 1.0),),))
+
+    assert result.effective_config.color_flow_ids == ("c0",)
+    assert runtime.last_options is not None
+    assert runtime.last_options["color_flows"] == ("c0",)
+
+
+def test_lc_profile_defaults_respect_complete_and_subset_axis_intent() -> None:
+    physics = SimpleNamespace(
+        color_accuracy="lc",
+        color_flows=(
+            ColorFlow("c0", 0, (1,), True, "c0", 1.0),
+            ColorFlow("c1", 1, (2,), True, "c1", 1.0),
+        ),
+        color_ids=("c0", "c1"),
+        helicities=(
+            HelicityConfiguration("h0", 0, (1, -1), True, False, "h0", 1.0),
+            HelicityConfiguration("h1", 1, (-1, 1), True, False, "h1", 1.0),
+        ),
+        helicity_ids=("h0", "h1"),
+    )
+
+    resolve = benchmark_module._default_lc_profile_selectors
+    assert resolve(
+        physics=physics,
+        lc_flow_layout="topology-replay",
+        selected_helicity_ids=("h1", "h0"),
+        selected_color_ids=(),
+    ) == (None, ("c0",))
+    assert resolve(
+        physics=physics,
+        lc_flow_layout="all-flow-union",
+        selected_helicity_ids=(),
+        selected_color_ids=("c1", "c0"),
+    ) == (("h0",), None)
+    assert resolve(
+        physics=physics,
+        lc_flow_layout="topology-replay",
+        selected_helicity_ids=("h0", "h1"),
+        selected_color_ids=("c1",),
+    ) == (None, ("c1",))
+    assert resolve(
+        physics=physics,
+        lc_flow_layout="all-flow-union",
+        selected_helicity_ids=("h1",),
+        selected_color_ids=("c0", "c1"),
+    ) == (("h1",), None)
+
+    assert resolve(
+        physics=physics,
+        lc_flow_layout="topology-replay",
+        selected_helicity_ids=(),
+        selected_color_ids=("c0", "c1"),
+    ) == (None, None)
+    assert resolve(
+        physics=physics,
+        lc_flow_layout="all-flow-union",
+        selected_helicity_ids=("h0", "h1"),
+        selected_color_ids=(),
+    ) == (None, None)
+
+    assert resolve(
+        physics=physics,
+        lc_flow_layout="topology-replay",
+        selected_helicity_ids=("h0",),
+        selected_color_ids=(),
+    ) == (("h0",), None)
+    assert resolve(
+        physics=physics,
+        lc_flow_layout="all-flow-union",
+        selected_helicity_ids=(),
+        selected_color_ids=("c0",),
+    ) == (None, ("c0",))
+
+
+def test_benchmark_recommends_union_for_topology_replay_all_flow_profile(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_effective_color_config(artifact, layout=None)
+    runtime = _RuntimeTwoAxes()
+    backend = BenchmarkBackend(
+        BenchmarkConfig(
+            target_runtime=1.0e-12,
+            batch_size=1,
+            warmup_runs=0,
+            minimum_samples=1,
+            helicity_ids=("h0",),
+        ),
+        None,
+    )
+    monkeypatch.setattr(backend, "_runtime", lambda _target: runtime)
+
+    with pytest.warns(
+        UserWarning, match="--lc-flow-layout all-flow-union"
+    ) as warning_records:
+        result = backend.run(
+            artifact,
+            points=(((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+    assert len(warning_records) == 1
+    assert result.environment["lc_flow_layout"] == "topology-replay"
+    recommendation = result.environment["lc_flow_layout_recommendation"]
+    assert isinstance(recommendation, str)
+    assert "--lc-flow-layout all-flow-union" in recommendation
+    assert "\x1b" not in recommendation
+
+
+def test_non_hot_profile_warning_is_once_per_loaded_process(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_effective_color_config(artifact, layout="topology-replay")
+    runtime = _RuntimeTwoAxes()
+    runtime._artifact_path = artifact
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=1,
+        warmup_runs=0,
+        minimum_samples=1,
+        helicity_ids=("h0",),
+    )
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        for _ in range(2):
+            BenchmarkBackend(config, None).run(
+                runtime,
+                points=(((1.0, 0.0, 0.0, 1.0),),),
+            )
+
+    assert len(caught) == 1
+    assert "single-flow/helicity-sum" in str(caught[0].message)
+
+
+def test_non_hot_profile_warning_is_once_for_immutable_runtime(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_effective_color_config(artifact, layout="topology-replay")
+    runtime = _ImmutableRuntime(_RuntimeTwoAxes(), artifact)
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=1,
+        warmup_runs=0,
+        minimum_samples=1,
+        helicity_ids=("h0",),
+    )
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        for _ in range(2):
+            BenchmarkBackend(config, None).run(
+                runtime,  # type: ignore[arg-type]
+                points=(((1.0, 0.0, 0.0, 1.0),),),
+            )
+
+    assert len(caught) == 1
+
+
+@pytest.mark.parametrize(
+    ("layout", "color_accuracy", "helicity_ids", "color_flow_ids"),
+    (
+        ("all-flow-union", "lc", ("h0",), ()),
+        ("topology-replay", "lc", (), ("c0",)),
+        ("topology-replay", "nlc", ("h0",), ()),
+        ("topology-replay", "full", ("h0",), ()),
+    ),
+)
+def test_lc_flow_layout_recommendation_exclusions(
+    layout: str,
+    color_accuracy: str,
+    helicity_ids: tuple[str, ...],
+    color_flow_ids: tuple[str, ...],
+) -> None:
+    assert (
+        benchmark_module._lc_flow_layout_recommendation(
+            color_accuracy=color_accuracy,
+            lc_flow_layout=layout,
+            selected_helicity_ids=helicity_ids,
+            selected_color_ids=color_flow_ids,
+        )
+        is None
+    )
+
+
+@pytest.mark.parametrize(
+    ("layout", "helicity_ids", "color_flow_ids", "message"),
+    (
+        ("topology-replay", ("h0",), ("c0",), "single-flow/helicity-sum"),
+        ("all-flow-union", (), ("c0",), "all-flows/single-helicity"),
+    ),
+)
+def test_non_hot_lc_profile_shapes_have_one_run_level_warning(
+    layout: str,
+    helicity_ids: tuple[str, ...],
+    color_flow_ids: tuple[str, ...],
+    message: str,
+) -> None:
+    recommendation = benchmark_module._lc_flow_layout_recommendation(
+        color_accuracy="lc",
+        lc_flow_layout=layout,
+        selected_helicity_ids=helicity_ids,
+        selected_color_ids=color_flow_ids,
+    )
+    assert recommendation is not None
+    assert message in recommendation
+
+
+def test_runtime_backend_has_no_artifact_layout_recommendation() -> None:
+    runtime = _Runtime()
+    result = BenchmarkBackend(
+        BenchmarkConfig(
+            target_runtime=1.0e-12,
+            batch_size=1,
+            warmup_runs=0,
+            minimum_samples=1,
+            helicity_ids=("h0",),
+        ),
+        None,
+    ).run(runtime, points=(((1.0, 0.0, 0.0, 1.0),),))
+
+    assert "lc_flow_layout" not in result.environment
+    assert "lc_flow_layout_recommendation" not in result.environment
+
+
+def test_benchmark_calibrates_blocks_and_repetitions_toward_target(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntime(clock)
+    events: list[object] = []
+    config = BenchmarkConfig(
+        target_runtime=0.1,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=4,
+    )
+
+    result = BenchmarkBackend(config, CallbackProgressSink(events.append)).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.sample_count == 4
+    assert result.repetitions_per_sample == 25
+    assert result.evaluation_count == 100
+    assert result.evaluated_point_count == 200
+    assert result.environment["elapsed_seconds"] == pytest.approx(0.1)
+    assert result.environment["calibration_evaluation_count"] == 25
+    assert runtime.calls == 126
+    assert result.uncertainty.standard_error == pytest.approx(0.0)
+    assert events[0] == ProgressStart(
+        "runtime-profile-calibration", "Calibrating runtime profile"
+    )
+    assert (
+        ProgressEnd(
+            "runtime-profile-calibration",
+            message="4 blocks x 25 repetitions",
+        )
+        in events
+    )
+    assert ProgressStart("runtime-benchmark", "Profiling runtime", 4) in events
+    updates = [
+        event
+        for event in events
+        if isinstance(event, ProgressUpdate) and event.task_id == "runtime-benchmark"
+    ]
+    assert updates
+    assert all(
+        event.details["progress_kind"] == "benchmark-statistics"
+        and event.details["repetitions"] == 25
+        and event.details["batch_size"] == 2
+        for event in updates
+    )
+    assert all("\x1b[" not in (event.message or "") for event in updates)
+
+
+def test_benchmark_single_sample_uses_probe_then_one_profile_block(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntime(clock)
+    config = BenchmarkConfig(
+        target_runtime=1.0,
+        batch_size=2,
+        warmup_runs=0,
+        minimum_samples=1,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.sample_count == 1
+    assert result.repetitions_per_sample == 1000
+    assert result.evaluation_count == 1000
+    assert runtime.calls == 1001
+    assert result.environment["elapsed_seconds"] == pytest.approx(1.0)
+    assert result.environment["initial_planned_sample_count"] == 1
+    assert result.environment["adaptive_extension_sample_count"] == 0
+    assert result.environment["calibration_evaluation_count"] == 1
+
+
+def test_benchmark_chunk_guard_runs_before_the_next_calibrated_call() -> None:
+    runtime = _RuntimeWithValidation()
+    runtime.calls = 0
+    calls: list[tuple[float | None, str]] = []
+
+    class StageBudgetReached(RuntimeError):
+        pass
+
+    def guard(estimated_seconds: float | None, description: str) -> None:
+        calls.append((estimated_seconds, description))
+        if estimated_seconds is not None:
+            raise StageBudgetReached
+
+    backend = BenchmarkBackend(
+        BenchmarkConfig(
+            target_runtime=0.005,
+            batch_size=1,
+            warmup_runs=0,
+            minimum_samples=5,
+        ),
+        None,
+    )
+    backend.set_chunk_guard(guard)
+
+    with pytest.raises(StageBudgetReached):
+        backend.run(runtime)
+
+    assert calls[0] == (None, "runtime evaluator timing chunk")
+    assert calls[1][0] is not None
+    assert calls[1][1] == "runtime evaluator timing chunk"
+    assert runtime.calls == 1
+
+
+def test_benchmark_extends_complete_blocks_when_calibration_undershoots(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithCalibrationUndershoot(clock)
+    config = BenchmarkConfig(
+        target_runtime=5.0,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=20,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.sample_count == 22
+    assert result.environment["elapsed_seconds"] == pytest.approx(5.126)
+    assert result.environment["elapsed_seconds"] >= config.target_runtime
+    assert result.environment["initial_planned_sample_count"] == 20
+    assert result.environment["adaptive_extension_sample_count"] == 2
+    assert result.environment["completed_sample_count"] == 22
+    assert result.environment["planned_sample_count"] == 22
+    assert result.environment["completion_fraction"] == pytest.approx(1.0)
+
+
+def test_benchmark_fails_closed_when_target_extension_cap_is_exhausted(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    monkeypatch.setattr(benchmark_module, "_MAX_TARGET_RUNTIME_SAMPLE_FACTOR", 1)
+    runtime = _TimedRuntimeWithCalibrationUndershoot(clock)
+
+    with pytest.raises(
+        EvaluationError,
+        match="could not reach its target duration of 5s within 20 complete blocks",
+    ):
+        BenchmarkBackend(
+            BenchmarkConfig(
+                target_runtime=5.0,
+                batch_size=2,
+                warmup_runs=1,
+                minimum_samples=20,
+            ),
+            None,
+        ).run(
+            runtime,
+            points=(((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+
+def test_native_profile_calls_are_bounded_independently_of_wall_repetitions(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithProfile(clock)
+    config = BenchmarkConfig(
+        target_runtime=0.1,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=4,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.repetitions_per_sample == 25
+    assert runtime.profile_calls == config.warmup_runs + result.sample_count
+    assert result.environment["native_profile_calls_per_block"] == 1
+
+
+def test_native_profile_calls_are_capped_for_long_target_runtime(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithNativeWall(clock)
+    config = BenchmarkConfig(
+        target_runtime=20.0,
+        batch_size=2,
+        warmup_runs=2,
+        minimum_samples=5,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.sample_count == 80
+    assert result.environment["native_profile_sample_count"] == 5
+    assert result.environment["native_profile_sample_limit"] == 5
+    assert result.environment["native_profile_calls_per_block"] == pytest.approx(5 / 80)
+    assert result.environment["native_profile_repetitions_per_sample"] == 1
+    assert result.environment["native_profile_points_per_sample"] == 2
+    assert result.environment["timing_sample_contract"] == (
+        "separate_native_profile_diagnostic_v1"
+    )
+    assert runtime.profile_calls == config.warmup_runs + 5
+
+
+def test_benchmark_uses_repeated_native_rusticol_wall_timer(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithNativeWall(clock)
+    config = BenchmarkConfig(
+        target_runtime=0.1,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=4,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.wall_time_per_point == pytest.approx(0.3e-3)
+    assert result.evaluator_total_time_per_point == pytest.approx(0.25e-3)
+    assert result.environment["wall_time_source"] == (
+        "python_outer_perf_counter_wall_time"
+    )
+    assert result.environment["elapsed_seconds"] == pytest.approx(0.12)
+    assert result.environment["evaluator_total_accumulated_seconds"] == pytest.approx(
+        0.1
+    )
+    assert runtime.native_wall_calls >= result.sample_count
+    assert result.environment["timing_sample_contract"] == (
+        "separate_native_profile_diagnostic_v1"
+    )
+    assert result.environment["wall_time_sample_pass"] == (
+        "time.perf_counter[measure_repetitions]"
+    )
+    assert result.environment["evaluator_total_time_source"] == (
+        "runtime._benchmark_f64_wall_time.accumulated"
+    )
+    assert result.environment["evaluator_time_sample_pass"] == "runtime.profile"
+    assert result.environment["native_profile_repetitions_per_sample"] == 1
+    assert result.repetitions_per_sample > 1
+
+
+def test_repeated_native_profile_is_paired_with_unprofiled_headline_samples(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithRepeatedProfile(clock)
+    runtime.repeated_profile_calls = 0
+    runtime.native_wall_calls = 0
+    config = BenchmarkConfig(
+        target_runtime=0.1,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=4,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert runtime.repeated_profile_calls == config.warmup_runs + result.sample_count
+    assert runtime.native_wall_calls >= config.warmup_runs + result.sample_count
+    assert result.wall_time_per_point == pytest.approx(0.3e-3)
+    assert result.evaluator_total_time_per_point == pytest.approx(0.25e-3)
+    assert result.evaluator_time_per_point == pytest.approx(2.5e-6)
+    assert result.timing_breakdown is not None
+    assert result.timing_breakdown.wall_time is not None
+    assert result.timing_breakdown.wall_time.mean_seconds_per_point == pytest.approx(
+        4.0e-6
+    )
+    assert result.timing_breakdown.sample_count == result.sample_count
+    counters = result.timing_breakdown.counters
+    assert isinstance(counters, BenchmarkProfileCounters)
+    assert counters.sample_count == result.sample_count
+    assert counters.native_input_components_per_point == pytest.approx(4.0)
+    assert counters.stage_input_copy_components_per_point == pytest.approx(7.0)
+    assert counters.evaluator_backend_calls_per_call == pytest.approx(3.0)
+    assert counters.observed_scratch_reallocations_per_call == pytest.approx(0.0)
+    assert counters.native_output_allocations_per_call == pytest.approx(1.0)
+    assert result.environment["native_profile_sample_count"] == result.sample_count
+    assert result.environment["native_profile_repetitions_per_sample"] == (
+        result.repetitions_per_sample
+    )
+    assert result.environment["native_profile_batch_size"] == config.batch_size
+    assert result.environment["native_profile_points_per_sample"] == (
+        result.repetitions_per_sample * config.batch_size
+    )
+    assert result.environment["wall_time_sample_pass"] == (
+        "time.perf_counter[measure_repetitions]"
+    )
+    assert result.environment["evaluator_time_sample_pass"] == (
+        "runtime.profile_repeated"
+    )
+    assert result.environment["timing_sample_contract"] == (
+        "paired_unprofiled_headline_profiled_attribution_v1"
+    )
+    assert result.environment["profile_attribution_paired_with_headline"] is True
+    assert result.environment["profile_attribution_identical_batch"] is True
+    assert result.environment["profile_attribution_identical_repetitions"] is True
+    assert result.environment["profile_attribution_evaluation_count"] == (
+        result.evaluation_count
+    )
+    assert result.environment["profile_attribution_point_count"] == (
+        result.evaluated_point_count
+    )
+
+
+def test_compiled_direct_arena_uses_fused_orchestration_attribution(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithCompiledDirectArenaRepeatedProfile(clock)
+    runtime.repeated_profile_calls = 0
+    runtime.native_wall_calls = 0
+    config = BenchmarkConfig(
+        target_runtime=0.1,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=4,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.evaluator_time_per_point == pytest.approx(3.5e-6)
+    assert result.environment["evaluator_time_source"] == (
+        "runtime_profile_core_compiled_direct_arena_orchestration_time"
+    )
+    assert result.environment["compiled_direct_arena_active"] is True
+    breakdown = result.timing_breakdown
+    assert breakdown is not None
+    assert breakdown.execution_mode == "compiled"
+    assert breakdown.orchestration_time is not None
+    assert breakdown.orchestration_time.mean_seconds_per_point == pytest.approx(3.5e-6)
+    assert breakdown.stage_evaluator_call_time is not None
+    assert breakdown.stage_evaluator_call_time.mean_seconds_per_point == 0.0
+    assert breakdown.amplitude_evaluator_call_time is not None
+    assert breakdown.amplitude_evaluator_call_time.mean_seconds_per_point == 0.0
+    counters = breakdown.counters
+    assert counters is not None
+    assert counters.evaluator_backend_calls_per_call == pytest.approx(3.0)
+    assert counters.compiled_direct_arena_engines_per_call == pytest.approx(2.0)
+    assert counters.compiled_direct_arena_calls_per_call == pytest.approx(3.0)
+    assert (
+        counters.compiled_direct_arena_boundary_input_bytes_per_call
+        == pytest.approx(0.0)
+    )
+    assert (
+        counters.compiled_direct_arena_boundary_current_output_bytes_per_call
+        == pytest.approx(0.0)
+    )
+    assert (
+        counters.compiled_direct_arena_boundary_amplitude_output_bytes_per_call
+        == pytest.approx(0.0)
+    )
+
+
+def test_compiled_direct_arena_zero_is_recorded_below_timer_resolution(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithBelowResolutionCompiledDirectArenaProfile(clock)
+    runtime.repeated_profile_calls = 0
+    runtime.native_wall_calls = 0
+    config = BenchmarkConfig(
+        target_runtime=0.1,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=4,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.evaluator_time_per_point is None
+    assert result.environment["evaluator_time_status"] == "below_timer_resolution"
+    assert result.environment["evaluator_time_ratio_eligible"] is False
+    assert result.environment["evaluator_time_raw_seconds_per_point"] == 0.0
+    assert result.environment["compiled_direct_arena_active"] is True
+    assert result.timing_breakdown is not None
+    assert result.timing_breakdown.orchestration_time is not None
+    assert result.timing_breakdown.orchestration_time.mean_seconds_per_point == 0.0
+
+
+def test_recurrence_profile_uses_paired_schedule_attribution(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithRecurrenceRepeatedProfile(clock)
+    runtime.repeated_profile_calls = 0
+    runtime.native_wall_calls = 0
+    config = BenchmarkConfig(
+        target_runtime=0.1,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=4,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.wall_time_per_point == pytest.approx(0.3e-3)
+    assert result.evaluator_total_time_per_point == pytest.approx(0.25e-3)
+    assert result.evaluator_time_per_point == pytest.approx(10.0e-6)
+    assert (
+        len(
+            {
+                result.wall_time_per_point,
+                result.evaluator_total_time_per_point,
+                result.evaluator_time_per_point,
+            }
+        )
+        == 3
+    )
+    assert result.environment["evaluator_time_source"] == (
+        "runtime_profile_core_recurrence_schedule_time"
+    )
+    assert result.environment["timing_sample_contract"] == (
+        "paired_unprofiled_headline_profiled_attribution_v1"
+    )
+    assert result.environment["native_profile_batch_size"] == config.batch_size
+    assert result.environment[
+        "evaluator_total_time_raw_seconds_per_point"
+    ] == pytest.approx(0.25e-3)
+    assert result.environment["evaluator_total_accumulated_seconds"] == pytest.approx(
+        0.1
+    )
+    breakdown = result.timing_breakdown
+    assert breakdown is not None
+    assert breakdown.execution_mode == "recurrence"
+    assert breakdown.stage_evaluator_call_time is None
+    assert breakdown.amplitude_evaluator_call_time is None
+    assert breakdown.stages == ()
+    assert breakdown.recurrence_schedule_time is not None
+    assert breakdown.recurrence_schedule_time.mean_seconds_per_point == pytest.approx(
+        10.0e-6
+    )
+    assert breakdown.recurrence_contribution_kernel_time is not None
+    contribution = breakdown.recurrence_contribution_kernel_time
+    assert contribution.mean_seconds_per_point == pytest.approx(6.0e-6)
+    assert breakdown.other_core_time is not None
+    assert breakdown.other_core_time.mean_seconds_per_point == pytest.approx(0.0)
+    assert breakdown.counters is not None
+    assert breakdown.counters.recurrence_momentum_scalar_values_per_point == 12
+    assert breakdown.counters.recurrence_schedule_executions_per_call == 1
+    assert breakdown.counters.recurrence_source_rows_per_call == 31
+    assert breakdown.counters.recurrence_contribution_rows_per_call == 126
+    assert breakdown.counters.recurrence_finalization_rows_per_call == 34
+    assert breakdown.counters.recurrence_closure_rows_per_call == 12
+
+
+def test_recurrence_profile_rejects_sub_attribution_larger_than_schedule() -> None:
+    profile = {
+        "execution_mode": "recurrence",
+        "points": 1,
+        "wall_time_s": 20.0e-6,
+        "recurrence_schedule_time_s": 10.0e-6,
+        "recurrence_source_kernel_time_s": 4.0e-6,
+        "recurrence_contribution_kernel_time_s": 7.0e-6,
+    }
+
+    with pytest.raises(EvaluationError, match="schedule sub-attribution"):
+        benchmark_module._native_profile_sample(profile, fallback_points=1)
+
+
+def test_keyboard_interrupt_returns_statistics_for_complete_samples(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntimeWithNativeWall(clock)
+    events: list[object] = []
+
+    def interrupt_after_two_samples(event: object) -> None:
+        events.append(event)
+        if (
+            isinstance(event, ProgressUpdate)
+            and event.task_id == "runtime-benchmark"
+            and event.completed == 2
+        ):
+            raise KeyboardInterrupt
+
+    result = BenchmarkBackend(
+        BenchmarkConfig(
+            target_runtime=0.1,
+            batch_size=2,
+            warmup_runs=1,
+            minimum_samples=4,
+        ),
+        CallbackProgressSink(interrupt_after_two_samples),
+    ).run(runtime, points=(((1.0, 0.0, 0.0, 1.0),),))
+
+    assert result.interrupted is True
+    assert result.sample_count == 2
+    assert result.environment["interrupted"] is True
+    assert result.environment["completed_sample_count"] == 2
+    assert result.environment["completion_fraction"] == pytest.approx(0.5)
+    assert result.uncertainty.standard_error >= 0.0
+    assert events[-1] == ProgressEnd(
+        "runtime-benchmark",
+        success=False,
+        message=("interrupted after 2/4 complete blocks; reporting partial statistics"),
+    )
+
+
+def test_benchmark_reduces_planned_blocks_for_slow_runtime(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = _Clock()
+    monkeypatch.setattr(benchmark_module.time, "perf_counter", clock.perf_counter)
+    runtime = _TimedRuntime(clock, duration=2.0)
+    config = BenchmarkConfig(
+        target_runtime=10.0,
+        batch_size=1,
+        warmup_runs=1,
+        minimum_samples=5,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.sample_count == 5
+    assert result.repetitions_per_sample == 1
+    assert result.environment["elapsed_seconds"] == pytest.approx(10.0)
+    assert runtime.calls == 6
+
+
+def test_benchmark_uses_native_profile_for_evaluator_time() -> None:
+    runtime = _RuntimeWithProfile()
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=4,
+        warmup_runs=1,
+        minimum_samples=3,
+        helicity_ids=("h0",),
+    )
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+    assert result.sample_count == 3
+    assert runtime.calls == 4
+    assert runtime.profile_calls == 4
+    assert result.wall_time_per_point >= 0.0
+    assert result.evaluator_time_per_point == pytest.approx(2.0e-6)
+    assert result.environment["wall_time_source"] == (
+        "python_outer_perf_counter_wall_time"
+    )
+    assert result.environment["wall_time_sample_pass"] == (
+        "time.perf_counter[measure_repetitions]"
+    )
+    assert (
+        result.environment["evaluator_time_source"]
+        == "runtime_profile_core_evaluator_call_time"
+    )
+    assert result.environment["evaluator_sample_count"] == 3
+    assert result.environment["timing_sample_contract"] == (
+        "separate_native_profile_diagnostic_v1"
+    )
+    assert result.environment["native_profile_repetitions_per_sample"] == 1
+    assert result.environment["precision"] == 16
+    assert result.environment["execution_mode"] == "compiled"
+    assert result.environment["color_workload"] == ("all 1 generated physical LC flows")
+    assert result.environment["helicity_workload"] == "selected 1/1 helicities: h0"
+    assert result.evaluator_uncertainty is not None
+    assert result.process_id == "test"
+    assert result.process_expression == "d d~ > z"
+    assert result.timing_breakdown is not None
+    assert result.timing_breakdown.sample_count == 3
+    assert result.timing_breakdown.wall_time is not None
+    assert result.timing_breakdown.wall_time.mean_seconds_per_point == pytest.approx(
+        3.0e-6
+    )
+    assert result.timing_breakdown.source_fill_time is not None
+    assert result.timing_breakdown.source_fill_time.mean_seconds_per_point == (
+        pytest.approx(0.25e-6)
+    )
+    assert result.timing_breakdown.stage_leaf_input_pack_time is not None
+    assert (
+        result.timing_breakdown.stage_leaf_input_pack_time.mean_seconds_per_point
+        == pytest.approx(0.075e-6)
+    )
+    assert result.timing_breakdown.stage_backend_call_time is not None
+    assert (
+        result.timing_breakdown.stage_backend_call_time.mean_seconds_per_point
+        == pytest.approx(0.35e-6)
+    )
+    assert result.timing_breakdown.amplitude_output_remap_time is not None
+    assert (
+        result.timing_breakdown.amplitude_output_remap_time.mean_seconds_per_point
+        == pytest.approx(0.125e-6)
+    )
+    assert result.timing_breakdown.other_core_time is not None
+    assert result.timing_breakdown.other_core_time.mean_seconds_per_point == (
+        pytest.approx(0.0)
+    )
+    assert len(result.timing_breakdown.stages) == 2
+    assert result.timing_breakdown.stages[1].leaf_input_pack_time is not None
+    assert result.timing_breakdown.stages[
+        1
+    ].leaf_input_pack_time.mean_seconds_per_point == pytest.approx(0.05e-6)
+    assert result.timing_breakdown.stages[1].backend_call_time is not None
+    assert result.timing_breakdown.stages[
+        1
+    ].backend_call_time.mean_seconds_per_point == pytest.approx(0.25e-6)
+
+
+def test_native_profile_reports_unaccounted_rusticol_core_time() -> None:
+    profile = {
+        "points": 2,
+        "wall_time_s": 20.0e-6,
+        "source_fill_time_s": 1.0e-6,
+        "momentum_setup_time_s": 1.0e-6,
+        "stage_input_pack_time_s": 2.0e-6,
+        "stage_evaluator_call_time_s": 4.0e-6,
+        "output_assign_time_s": 2.0e-6,
+        "amplitude_input_pack_time_s": 1.0e-6,
+        "amplitude_evaluator_call_time_s": 3.0e-6,
+        "reduction_time_s": 2.0e-6,
+    }
+
+    sample = benchmark_module._native_profile_sample(profile, fallback_points=2)
+
+    assert sample.other_core_time == pytest.approx(2.0e-6)
+
+
+def test_timing_breakdown_preserves_legacy_positional_field_order() -> None:
+    legacy_fields = (
+        "sample_count",
+        "execution_mode",
+        "wall_time",
+        "source_fill_time",
+        "momentum_setup_time",
+        "stage_input_pack_time",
+        "stage_evaluator_call_time",
+        "output_assign_time",
+        "amplitude_input_pack_time",
+        "amplitude_evaluator_call_time",
+        "reduction_time",
+        "other_core_time",
+        "eager_execution_time",
+        "eager_initialize_time",
+        "eager_gather_time",
+        "eager_kernel_call_time",
+        "eager_invocation_scatter_time",
+        "eager_finalization_time",
+        "eager_scatter_finalization_time",
+        "eager_closure_time",
+        "eager_copy_out_time",
+        "stages",
+    )
+
+    assert tuple(BenchmarkTimingBreakdown.__dataclass_fields__)[
+        : len(legacy_fields)
+    ] == (legacy_fields)
+    fields = tuple(BenchmarkTimingBreakdown.__dataclass_fields__)
+    assert fields.index("counters") == len(fields) - 8
+    assert fields[fields.index("counters") - 8 : fields.index("counters")] == (
+        "recurrence_momentum_fill_time",
+        "recurrence_union_source_fill_time",
+        "recurrence_schedule_time",
+        "recurrence_source_kernel_time",
+        "recurrence_contribution_kernel_time",
+        "recurrence_finalization_time",
+        "recurrence_closure_time",
+        "recurrence_replay_output_mapping_time",
+    )
+    assert fields[-7:] == (
+        "stage_leaf_input_pack_time",
+        "stage_backend_call_time",
+        "stage_evaluator_output_gather_time",
+        "amplitude_leaf_input_pack_time",
+        "amplitude_backend_call_time",
+        "amplitude_evaluator_output_gather_time",
+        "amplitude_output_remap_time",
+    )
+
+
+def test_repeated_profile_counters_normalize_per_point_and_per_call() -> None:
+    points = 24
+    repetitions = 3
+    per_point_counts = {
+        "native_input_component_count": 4,
+        "native_input_pack_bytes": 32,
+        "native_input_crossing_bytes": 32,
+        "state_component_count": 101,
+        "state_clear_component_count": 99,
+        "source_component_count": 8,
+        "momentum_component_count": 12,
+        "model_parameter_component_count": 5,
+        "stage_input_copy_component_count": 41,
+        "stage_leaf_input_copy_component_count": 43,
+        "stage_evaluator_output_gather_component_count": 47,
+        "stage_output_assign_component_count": 53,
+        "amplitude_input_copy_component_count": 59,
+        "amplitude_leaf_input_copy_component_count": 61,
+        "amplitude_evaluator_output_gather_component_count": 67,
+        "amplitude_output_remap_component_count": 71,
+        "reduction_input_component_count": 73,
+        "selector_gather_point_count": 1,
+        "selector_gather_bytes": 32,
+        "selector_scatter_value_count": 2,
+        "resolved_materialized_component_count": 79,
+        "total_materialized_value_count": 1,
+        "final_output_copy_value_count": 83,
+    }
+    per_call_counts = {
+        "native_input_container_allocation_count": 10,
+        "evaluator_backend_call_count": 11,
+        "observed_scratch_reallocation_count": 0,
+        "native_output_allocation_count": 1,
+    }
+    sample = benchmark_module._native_profile_sample(
+        {
+            "execution_mode": "compiled",
+            "points": points,
+            "wall_time_s": points * 4.0e-6,
+            "stage_evaluator_call_time_s": points * 2.0e-6,
+            "amplitude_evaluator_call_time_s": points * 0.5e-6,
+            **{key: value * points for key, value in per_point_counts.items()},
+            **{key: value * repetitions for key, value in per_call_counts.items()},
+        },
+        fallback_points=points,
+        repetitions=repetitions,
+    )
+
+    counters = sample.counters
+    assert counters is not None
+    for raw_name, expected in per_point_counts.items():
+        field_name = {
+            "native_input_component_count": "native_input_components_per_point",
+            "native_input_pack_bytes": "native_input_pack_bytes_per_point",
+            "native_input_crossing_bytes": "native_input_crossing_bytes_per_point",
+            "state_component_count": "state_components_per_point",
+            "state_clear_component_count": "state_clear_components_per_point",
+            "source_component_count": "source_components_per_point",
+            "momentum_component_count": "momentum_components_per_point",
+            "model_parameter_component_count": "model_parameter_components_per_point",
+            "stage_input_copy_component_count": (
+                "stage_input_copy_components_per_point"
+            ),
+            "stage_leaf_input_copy_component_count": (
+                "stage_leaf_input_copy_components_per_point"
+            ),
+            "stage_evaluator_output_gather_component_count": (
+                "stage_evaluator_output_gather_components_per_point"
+            ),
+            "stage_output_assign_component_count": (
+                "stage_output_assign_components_per_point"
+            ),
+            "amplitude_input_copy_component_count": (
+                "amplitude_input_copy_components_per_point"
+            ),
+            "amplitude_leaf_input_copy_component_count": (
+                "amplitude_leaf_input_copy_components_per_point"
+            ),
+            "amplitude_evaluator_output_gather_component_count": (
+                "amplitude_evaluator_output_gather_components_per_point"
+            ),
+            "amplitude_output_remap_component_count": (
+                "amplitude_output_remap_components_per_point"
+            ),
+            "reduction_input_component_count": ("reduction_input_components_per_point"),
+            "selector_gather_point_count": "selector_gather_points_per_point",
+            "selector_gather_bytes": "selector_gather_bytes_per_point",
+            "selector_scatter_value_count": "selector_scatter_values_per_point",
+            "resolved_materialized_component_count": (
+                "resolved_materialized_components_per_point"
+            ),
+            "total_materialized_value_count": ("total_materialized_values_per_point"),
+            "final_output_copy_value_count": ("final_output_copy_values_per_point"),
+        }[raw_name]
+        assert getattr(counters, field_name) == pytest.approx(expected)
+    assert counters.native_input_container_allocations_per_call == pytest.approx(10.0)
+    assert counters.evaluator_backend_calls_per_call == pytest.approx(11.0)
+    assert counters.observed_scratch_reallocations_per_call == pytest.approx(0.0)
+    assert counters.native_output_allocations_per_call == pytest.approx(1.0)
+
+    summary = benchmark_module._timing_breakdown((sample, sample)).counters
+    assert summary is not None
+    assert summary.sample_count == 2
+    assert summary.stage_leaf_input_copy_components_per_point == pytest.approx(43.0)
+    assert summary.evaluator_backend_calls_per_call == pytest.approx(11.0)
+
+
+def test_profile_counter_contract_rejects_ambiguous_repeated_totals() -> None:
+    with pytest.raises(EvaluationError, match="not divisible by repetitions"):
+        benchmark_module._native_profile_sample(
+            {
+                "points": 5,
+                "stage_evaluator_call_time_s": 1.0e-6,
+                "amplitude_evaluator_call_time_s": 0.0,
+            },
+            fallback_points=5,
+            repetitions=2,
+        )
+
+    with pytest.raises(EvaluationError, match="non-negative integer"):
+        benchmark_module._native_profile_sample(
+            {
+                "points": 2,
+                "stage_evaluator_call_time_s": 1.0e-6,
+                "amplitude_evaluator_call_time_s": 0.0,
+                "stage_input_copy_component_count": 1.5,
+            },
+            fallback_points=2,
+        )
+
+
+def test_compiled_direct_arena_counters_must_be_jointly_available() -> None:
+    with pytest.raises(EvaluationError, match="must be jointly available"):
+        benchmark_module._native_profile_sample(
+            {
+                "execution_mode": "compiled",
+                "points": 1,
+                "wall_time_s": 2.0e-6,
+                "orchestration_time_s": 1.0e-6,
+                "stage_evaluator_call_time_s": 0.0,
+                "amplitude_evaluator_call_time_s": 0.0,
+                "evaluator_backend_call_count": 1,
+                "compiled_direct_arena_engine_count": 1,
+            },
+            fallback_points=1,
+        )
+
+
+@pytest.mark.parametrize(
+    "boundary_counter",
+    (
+        "compiled_direct_arena_boundary_input_bytes",
+        "compiled_direct_arena_boundary_current_output_bytes",
+        "compiled_direct_arena_boundary_amplitude_output_bytes",
+    ),
+)
+def test_compiled_direct_arena_rejects_boundary_traffic(
+    boundary_counter: str,
+) -> None:
+    profile = {
+        "execution_mode": "compiled",
+        "points": 1,
+        "wall_time_s": 2.0e-6,
+        "orchestration_time_s": 1.0e-6,
+        "stage_evaluator_call_time_s": 0.0,
+        "amplitude_evaluator_call_time_s": 0.0,
+        "evaluator_backend_call_count": 1,
+        "compiled_direct_arena_engine_count": 1,
+        "compiled_direct_arena_call_count": 1,
+        "compiled_direct_arena_boundary_input_bytes": 0,
+        "compiled_direct_arena_boundary_current_output_bytes": 0,
+        "compiled_direct_arena_boundary_amplitude_output_bytes": 0,
+    }
+    profile[boundary_counter] = 16
+
+    with pytest.raises(EvaluationError, match="forbidden boundary traffic"):
+        benchmark_module._native_profile_sample(profile, fallback_points=1)
+
+
+def test_compiled_direct_arena_calls_must_cover_backend_calls() -> None:
+    with pytest.raises(EvaluationError, match="cover every evaluator backend call"):
+        benchmark_module._native_profile_sample(
+            {
+                "execution_mode": "compiled",
+                "points": 1,
+                "wall_time_s": 2.0e-6,
+                "orchestration_time_s": 1.0e-6,
+                "stage_evaluator_call_time_s": 0.0,
+                "amplitude_evaluator_call_time_s": 0.0,
+                "evaluator_backend_call_count": 2,
+                "compiled_direct_arena_engine_count": 1,
+                "compiled_direct_arena_call_count": 1,
+                "compiled_direct_arena_boundary_input_bytes": 0,
+                "compiled_direct_arena_boundary_current_output_bytes": 0,
+                "compiled_direct_arena_boundary_amplitude_output_bytes": 0,
+            },
+            fallback_points=1,
+        )
+
+
+def test_compiled_direct_arena_requires_fused_orchestration_timing() -> None:
+    with pytest.raises(EvaluationError, match="orchestration timing is unavailable"):
+        benchmark_module._native_profile_sample(
+            {
+                "execution_mode": "compiled",
+                "points": 1,
+                "wall_time_s": 2.0e-6,
+                "stage_evaluator_call_time_s": 0.0,
+                "amplitude_evaluator_call_time_s": 0.0,
+                "evaluator_backend_call_count": 1,
+                "compiled_direct_arena_engine_count": 1,
+                "compiled_direct_arena_call_count": 1,
+                "compiled_direct_arena_boundary_input_bytes": 0,
+                "compiled_direct_arena_boundary_current_output_bytes": 0,
+                "compiled_direct_arena_boundary_amplitude_output_bytes": 0,
+            },
+            fallback_points=1,
+        )
+
+
+def test_compiled_direct_arena_public_counters_reject_negative_values() -> None:
+    with pytest.raises(ValueError, match="finite and non-negative"):
+        BenchmarkProfileCounters(
+            sample_count=1,
+            compiled_direct_arena_calls_per_call=-1.0,
+        )
+
+
+def test_native_profile_preserves_legacy_momentum_setup_aggregate() -> None:
+    sample = benchmark_module._native_profile_sample(
+        {
+            "execution_mode": "compiled",
+            "points": 1,
+            "wall_time_s": 10.0e-6,
+            "momentum_input_setup_time_s": 1.0e-6,
+            "momentum_setup_time_s": 3.0e-6,
+            "model_parameter_setup_time_s": 2.0e-6,
+            "stage_evaluator_call_time_s": 1.0e-6,
+            "amplitude_evaluator_call_time_s": 1.0e-6,
+        },
+        fallback_points=1,
+    )
+
+    assert sample.momentum_input_setup_time == pytest.approx(1.0e-6)
+    assert sample.momentum_setup_time == pytest.approx(3.0e-6)
+    assert sample.model_parameter_setup_time == pytest.approx(2.0e-6)
+    assert sample.other_core_time == pytest.approx(5.0e-6)
+
+
+def test_native_profile_accounts_selector_phases_exclusively() -> None:
+    profile = {
+        "execution_mode": "compiled",
+        "points": 2,
+        "wall_time_s": 20.0e-6,
+        "stage_evaluator_call_time_s": 8.0e-6,
+        "amplitude_evaluator_call_time_s": 2.0e-6,
+        "selector_planner_time_s": 1.0e-6,
+        "selector_gather_time_s": 3.0e-6,
+        "selector_scatter_time_s": 2.0e-6,
+    }
+
+    sample = benchmark_module._native_profile_sample(profile, fallback_points=2)
+
+    assert sample.selector_planner_time == pytest.approx(0.5e-6)
+    assert sample.selector_gather_time == pytest.approx(1.5e-6)
+    assert sample.selector_scatter_time == pytest.approx(1.0e-6)
+    assert sample.other_core_time == pytest.approx(2.0e-6)
+
+
+def test_native_eager_profile_rejects_overlapping_top_level_phases() -> None:
+    profile = {
+        "execution_mode": "eager",
+        "points": 4,
+        "wall_time_s": 10.0e-6,
+        "source_fill_time_s": 8.0e-6,
+        "momentum_setup_time_s": 1.0e-6,
+        "stage_evaluator_call_time_s": 4.0e-6,
+        "amplitude_evaluator_call_time_s": 0.0,
+        "stage_input_pack_by_stage_time_s": [],
+        "stage_evaluator_call_by_stage_time_s": [],
+        "stage_output_assign_by_stage_time_s": [],
+    }
+
+    with pytest.raises(EvaluationError, match="exclusive top-level phases"):
+        benchmark_module._native_profile_sample(profile, fallback_points=4)
+
+
+def test_native_compiled_profile_rejects_overlapping_top_level_phases() -> None:
+    profile = {
+        "execution_mode": "compiled",
+        "points": 1,
+        "wall_time_s": 10.0e-6,
+        "stage_input_pack_time_s": 4.0e-6,
+        "stage_evaluator_call_time_s": 7.0e-6,
+        "output_assign_time_s": 0.0,
+        "amplitude_input_pack_time_s": 0.0,
+        "amplitude_evaluator_call_time_s": 0.0,
+        "reduction_time_s": 0.0,
+    }
+
+    with pytest.raises(EvaluationError, match="exclusive top-level phases"):
+        benchmark_module._native_profile_sample(profile, fallback_points=1)
+
+
+def test_native_eager_profile_rejects_children_exceeding_inclusive_execution() -> None:
+    profile = {
+        "execution_mode": "eager",
+        "points": 1,
+        "wall_time_s": 20.0e-6,
+        "source_fill_time_s": 1.0e-6,
+        "momentum_setup_time_s": 1.0e-6,
+        "stage_evaluator_call_time_s": 10.0e-6,
+        "amplitude_evaluator_call_time_s": 0.0,
+        "eager_kernel_call_time_s": 11.0e-6,
+        "stage_input_pack_by_stage_time_s": [],
+        "stage_evaluator_call_by_stage_time_s": [],
+        "stage_output_assign_by_stage_time_s": [],
+    }
+
+    with pytest.raises(EvaluationError, match="exclusive execution phases"):
+        benchmark_module._native_profile_sample(profile, fallback_points=1)
+
+
+def test_native_eager_shared_samples_partition_wall_time() -> None:
+    samples = []
+    for source_fill in (1.0e-6, 1.5e-6, 2.0e-6):
+        sample = benchmark_module._native_profile_sample(
+            {
+                "execution_mode": "eager",
+                "points": 1,
+                "wall_time_s": 12.0e-6,
+                "source_fill_time_s": source_fill,
+                "momentum_setup_time_s": 1.0e-6,
+                "stage_evaluator_call_time_s": 8.0e-6,
+                "amplitude_evaluator_call_time_s": 0.0,
+                "stage_input_pack_by_stage_time_s": [],
+                "stage_evaluator_call_by_stage_time_s": [],
+                "stage_output_assign_by_stage_time_s": [],
+            },
+            fallback_points=1,
+        )
+        assert sample.other_core_time is not None
+        assert sample.source_fill_time is not None
+        assert sample.momentum_setup_time is not None
+        assert (
+            sample.source_fill_time
+            + sample.momentum_setup_time
+            + sample.stage_evaluator_call_time
+            + sample.other_core_time
+        ) == pytest.approx(sample.wall_time)
+        samples.append(sample)
+
+    breakdown = benchmark_module._timing_breakdown(samples)
+    assert breakdown.source_fill_time is not None
+    assert breakdown.source_fill_time.uncertainty.standard_deviation > 0.0
+
+
+def test_benchmark_falls_back_to_valid_per_stage_native_timings() -> None:
+    runtime = _RuntimeWithPerStageProfile()
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=4,
+        warmup_runs=1,
+        minimum_samples=3,
+        helicity_ids=("h0",),
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.evaluator_time_per_point == pytest.approx(2.0e-6)
+
+
+def test_eager_profile_uses_nonzero_aggregate_when_stage_vectors_are_empty() -> None:
+    runtime = _RuntimeWithEagerProfile()
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=4,
+        warmup_runs=1,
+        minimum_samples=3,
+        helicity_ids=("h0",),
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.evaluator_time_per_point == pytest.approx(20.0e-6)
+    assert result.timing_breakdown is not None
+    assert result.timing_breakdown.execution_mode == "eager"
+    assert result.timing_breakdown.stage_evaluator_call_time is None
+    aggregate = result.timing_breakdown.eager_execution_time
+    assert aggregate is not None
+    assert aggregate.mean_seconds_per_point == pytest.approx(20.0e-6)
+    assert result.timing_breakdown.stage_input_pack_time is None
+    assert result.timing_breakdown.output_assign_time is None
+    assert result.timing_breakdown.amplitude_input_pack_time is None
+    assert result.timing_breakdown.amplitude_evaluator_call_time is None
+    assert result.timing_breakdown.reduction_time is None
+    assert result.timing_breakdown.stages == ()
+
+
+def test_eager_profile_preserves_detailed_native_phase_timings() -> None:
+    runtime = _RuntimeWithDetailedEagerProfile()
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=4,
+        warmup_runs=1,
+        minimum_samples=3,
+        helicity_ids=("h0",),
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    breakdown = result.timing_breakdown
+    assert breakdown is not None
+    assert breakdown.execution_mode == "eager"
+    assert breakdown.eager_initialize_time is not None
+    assert breakdown.eager_initialize_time.mean_seconds_per_point == pytest.approx(
+        0.5e-6
+    )
+    assert breakdown.eager_gather_time is not None
+    assert breakdown.eager_gather_time.mean_seconds_per_point == pytest.approx(1.0e-6)
+    assert breakdown.eager_kernel_call_time is not None
+    assert breakdown.eager_kernel_call_time.mean_seconds_per_point == pytest.approx(
+        6.0e-6
+    )
+    assert breakdown.eager_invocation_scatter_time is not None
+    invocation_scatter = breakdown.eager_invocation_scatter_time
+    assert invocation_scatter.mean_seconds_per_point == pytest.approx(3.0e-6)
+    assert breakdown.eager_finalization_time is not None
+    assert breakdown.eager_finalization_time.mean_seconds_per_point == pytest.approx(
+        5.0e-6
+    )
+    assert breakdown.eager_scatter_finalization_time is not None
+    assert breakdown.eager_closure_time is not None
+    assert breakdown.eager_copy_out_time is not None
+    assert breakdown.eager_copy_out_time.mean_seconds_per_point == pytest.approx(1.5e-6)
+
+
+def test_empty_stage_vectors_do_not_relabel_compiled_amplitude_only_profile() -> None:
+    runtime = _RuntimeWithAmplitudeOnlyCompiledProfile()
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=4,
+        warmup_runs=1,
+        minimum_samples=3,
+        helicity_ids=("h0",),
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert result.timing_breakdown is not None
+    assert result.timing_breakdown.execution_mode == "compiled"
+    assert result.evaluator_time_per_point == pytest.approx(1.5e-6)
+
+
+def test_non_f64_benchmark_forwards_precision_without_native_profile() -> None:
+    runtime = _RuntimeWithProfile()
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=2,
+        precision=80,
+        warmup_runs=1,
+        minimum_samples=2,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert runtime.profile_calls == 0
+    assert runtime.last_options is not None
+    assert runtime.last_options["precision"] == 80
+    assert result.environment["precision"] == 80
+    assert result.environment["native_profile_unavailable_reason"] == (
+        "non_f64_precision"
+    )
+    assert result.evaluator_time_per_point is None
+    assert result.environment["evaluator_time_status"] == "unavailable"
+
+
+def test_benchmark_falls_back_when_native_profile_is_unavailable() -> None:
+    runtime = _RuntimeWithUnavailableProfile()
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=2,
+    )
+
+    result = BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert runtime.calls == 3
+    assert result.environment["wall_time_source"] == (
+        "python_outer_perf_counter_wall_time"
+    )
+    assert result.evaluator_time_per_point is None
+    assert result.environment["evaluator_time_status"] == "unavailable"
+
+
+def test_benchmark_uses_runtime_validation_point_when_points_are_omitted() -> None:
+    runtime = _RuntimeWithValidation()
+    config = BenchmarkConfig(
+        target_runtime=1.0e-12,
+        batch_size=2,
+        warmup_runs=1,
+        minimum_samples=2,
+    )
+    result = BenchmarkBackend(config, None).run(runtime)
+    assert result.sample_count == 2
+    assert runtime.calls == 3
+
+
+def test_benchmark_without_points_or_artifact_fixture_is_explicit() -> None:
+    with pytest.raises(EvaluationError, match="deterministic validation point"):
+        BenchmarkBackend(BenchmarkConfig(), None).run(_Runtime())
diff --git a/pyamplicol/tests/unit/test_build_backend.py b/pyamplicol/tests/unit/test_build_backend.py
new file mode 100644
index 0000000000..42ce5cd548
--- /dev/null
+++ b/pyamplicol/tests/unit/test_build_backend.py
@@ -0,0 +1,2250 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "build_backend"))
+
+import _pyamplicol_build as backend  # noqa: E402
+import sdk  # noqa: E402
+
+
+def _git(repo: Path, *arguments: str) -> str:
+    completed = subprocess.run(
+        ["git", *arguments],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
+def _source_identity_checkout(tmp_path: Path) -> Path:
+    repo = tmp_path / "source-identity-checkout"
+    repo.mkdir()
+    _git(repo, "init", "-q")
+    _git(repo, "config", "user.email", "build@example.invalid")
+    _git(repo, "config", "user.name", "Build Test")
+    classifier = repo / "tools/performance_report/source_identity.py"
+    classifier.parent.mkdir(parents=True)
+    shutil.copy2(ROOT / "tools/performance_report/source_identity.py", classifier)
+    profile = repo / "docs/performance_reports/manual"
+    (profile / "results").mkdir(parents=True)
+    (profile / "results/cache.json").write_text("{}\n", encoding="utf-8")
+    (profile / "result_sample_table.tex").write_text("% table\n", encoding="utf-8")
+    (profile / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.4\n")
+    (profile / "pyAmpliCol.tex").write_text("% report source\n", encoding="utf-8")
+    source = repo / "src/runtime.py"
+    source.parent.mkdir()
+    source.write_text("VALUE = 1\n", encoding="utf-8")
+    (repo / "pyproject.toml").write_text("[project]\nname='test'\n", encoding="utf-8")
+    _git(repo, "add", ".")
+    _git(repo, "commit", "-qm", "fixture")
+    return repo
+
+
+def test_prepared_model_bootstrap_is_candidate_only(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP", "1")
+
+    assert backend._prepared_model_bootstrap("candidate") is True
+    with pytest.raises(RuntimeError, match="non-publishable candidate"):
+        backend._prepared_model_bootstrap("release")
+
+
+def test_prepared_model_bootstrap_rejects_ambiguous_values(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP", "true")
+
+    with pytest.raises(RuntimeError, match="must be either '0' or '1'"):
+        backend._prepared_model_bootstrap("candidate")
+
+
+def test_release_prepared_model_bootstrap_requires_explicit_release_context() -> None:
+    assert backend._release_prepared_model_bootstrap("release", None) is False
+    with pytest.raises(RuntimeError, match="explicit producer context"):
+        backend._release_prepared_model_bootstrap("release", "wrong")
+    with pytest.raises(RuntimeError, match="requires release dependency mode"):
+        backend._release_prepared_model_bootstrap(
+            "candidate",
+            backend._RELEASE_PREPARED_MODEL_BOOTSTRAP_CONTEXT,
+        )
+    assert (
+        backend._release_prepared_model_bootstrap(
+            "release",
+            backend._RELEASE_PREPARED_MODEL_BOOTSTRAP_CONTEXT,
+        )
+        is True
+    )
+
+
+def test_selftest_fixture_bootstrap_requires_explicit_candidate_context(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP", "1")
+
+    with pytest.raises(RuntimeError, match=r"explicit.*context"):
+        backend._selftest_fixture_bootstrap("candidate")
+
+    monkeypatch.setenv(
+        "PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP_CONTEXT",
+        backend._SELFTEST_FIXTURE_BOOTSTRAP_CONTEXT,
+    )
+    with pytest.raises(RuntimeError, match=r"explicit.*context"):
+        backend._selftest_fixture_bootstrap("candidate")
+    assert (
+        backend._selftest_fixture_bootstrap(
+            "candidate",
+            explicit_context=True,
+        )
+        is True
+    )
+    with pytest.raises(RuntimeError, match="non-publishable candidate"):
+        backend._selftest_fixture_bootstrap(
+            "release",
+            explicit_context=True,
+        )
+
+
+def test_selftest_fixture_bootstrap_rejects_raw_context_without_flag(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv(
+        "PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP_CONTEXT",
+        backend._SELFTEST_FIXTURE_BOOTSTRAP_CONTEXT,
+    )
+
+    with pytest.raises(RuntimeError, match="context requires the bootstrap flag"):
+        backend._selftest_fixture_bootstrap("candidate")
+
+
+def test_pep517_rejects_raw_selftest_fixture_bootstrap_escape(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "candidate")
+    monkeypatch.setenv("PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP", "1")
+    monkeypatch.setenv(
+        "PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP_CONTEXT",
+        backend._SELFTEST_FIXTURE_BOOTSTRAP_CONTEXT,
+    )
+
+    with pytest.raises(RuntimeError, match=r"explicit.*context"):
+        backend._from_overlay(lambda: None, with_sdk=False)
+
+
+def test_selftest_fixture_bootstrap_rejects_ambiguous_values(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_SELFTEST_FIXTURE_BOOTSTRAP", "true")
+
+    with pytest.raises(RuntimeError, match="must be either '0' or '1'"):
+        backend._selftest_fixture_bootstrap(
+            "candidate",
+            explicit_context=True,
+        )
+
+
+def test_selftest_fixture_bootstrap_marks_exact_candidate_and_strips_fixture(
+    tmp_path: Path,
+) -> None:
+    package = tmp_path / "src" / "pyamplicol"
+    package.mkdir(parents=True)
+    build_info_path = package / "_build_info.json"
+    build_info_path.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "selftest_fixture_bootstrap": False,
+                "source_revision": "a" * 40,
+            }
+        ),
+        encoding="utf-8",
+    )
+    fixture = package / "assets" / "selftest" / "portable-64le"
+    fixture.mkdir(parents=True)
+    (fixture / "expected.json").write_text("{}\n", encoding="utf-8")
+
+    backend._mark_selftest_fixture_bootstrap(tmp_path)
+
+    build_info = json.loads(build_info_path.read_text(encoding="utf-8"))
+    assert build_info["selftest_fixture_bootstrap"] is True
+    assert not fixture.exists()
+
+
+def test_selftest_fixture_bootstrap_rejects_dirty_candidate(
+    tmp_path: Path,
+) -> None:
+    package = tmp_path / "src" / "pyamplicol"
+    package.mkdir(parents=True)
+    (package / "_build_info.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "selftest_fixture_bootstrap": False,
+                "source_revision": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(RuntimeError, match="exact clean source revision"):
+        backend._mark_selftest_fixture_bootstrap(tmp_path)
+
+
+def test_prepared_model_bootstrap_strips_only_generated_payloads(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "src/pyamplicol/assets/prepared_models"
+    root.mkdir(parents=True)
+    package = root / "__init__.py"
+    package.write_text("# package\n", encoding="utf-8")
+    metadata = root / "built-in-sm-jit-o2-aarch64.metadata.json"
+    metadata.write_text("{}\n", encoding="utf-8")
+    bundle = root / "built-in-sm-jit-o2-aarch64.pyamplicol-model"
+    bundle.write_bytes(b"bundle")
+
+    backend._strip_prepared_model_payloads(tmp_path)
+
+    assert package.is_file()
+    assert not metadata.exists()
+    assert not bundle.exists()
+
+
+def test_linux_release_wheel_requests_manylinux_repair(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "release")
+    monkeypatch.setattr(backend.sys, "platform", "linux")
+    observed: dict[str, object] = {}
+
+    def delegated(operation, *args, **kwargs):
+        observed["operation"] = operation
+        observed["args"] = args
+        observed["kwargs"] = kwargs
+        return "pyamplicol.whl"
+
+    monkeypatch.setattr(backend, "_from_overlay", delegated)
+
+    assert backend.build_wheel("dist") == "pyamplicol.whl"
+    assert observed == {
+        "operation": backend.maturin.build_wheel,
+        "args": (
+            "dist",
+            {"maturin.build-args": ["--compatibility", "manylinux_2_28"]},
+            None,
+        ),
+        "kwargs": {
+            "with_sdk": True,
+            "retain_release_build_info": True,
+        },
+    }
+
+
+def test_candidate_and_non_linux_wheels_preserve_frontend_settings(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    supplied = {"frontend.setting": "preserved"}
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "candidate")
+    monkeypatch.setattr(backend.sys, "platform", "linux")
+    assert backend._release_wheel_config_settings(supplied) is supplied
+
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "release")
+    monkeypatch.setattr(backend.sys, "platform", "darwin")
+    assert backend._release_wheel_config_settings(supplied) is supplied
+
+
+@pytest.mark.parametrize("mode", ("candidate", "release"))
+@pytest.mark.parametrize("platform_name", ("darwin", "linux"))
+def test_host_wheel_setting_is_consumed_and_only_changes_linux_tags(
+    monkeypatch: pytest.MonkeyPatch, mode: str, platform_name: str
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", mode)
+    monkeypatch.setattr(backend.sys, "platform", platform_name)
+    supplied = {"pyamplicol.host-wheel": "true", "frontend.setting": "preserved"}
+    expected = {"frontend.setting": "preserved"}
+    if platform_name == "linux":
+        expected["maturin.build-args"] = ["--compatibility", "linux"]
+    assert backend._release_wheel_config_settings(supplied) == expected
+    assert supplied["pyamplicol.host-wheel"] == "true"
+
+
+def test_false_host_wheel_setting_preserves_release_manylinux(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "release")
+    monkeypatch.setattr(backend.sys, "platform", "linux")
+    assert backend._release_wheel_config_settings(
+        {"pyamplicol.host-wheel": "false"}
+    ) == {"maturin.build-args": ["--compatibility", "manylinux_2_28"]}
+
+
+@pytest.mark.parametrize("value", (None, True, "", "yes", "linux", ["true"]))
+def test_host_wheel_setting_rejects_invalid_values(value) -> None:
+    with pytest.raises(RuntimeError, match="host-wheel must be 'true' or 'false'"):
+        backend._release_wheel_config_settings({"pyamplicol.host-wheel": value})
+
+
+@pytest.mark.parametrize(
+    "hook_name", ("get_requires_for_build_wheel", "prepare_metadata_for_build_wheel")
+)
+def test_wheel_frontend_hooks_do_not_forward_backend_host_setting(
+    monkeypatch: pytest.MonkeyPatch, hook_name: str
+) -> None:
+    observed = []
+    monkeypatch.setattr(
+        backend,
+        "_from_overlay",
+        lambda _operation, *args, **_kwargs: observed.extend(args),
+    )
+    args = ("metadata",) if hook_name == "prepare_metadata_for_build_wheel" else ()
+    getattr(backend, hook_name)(
+        *args, config_settings={"pyamplicol.host-wheel": "true"}
+    )
+    assert observed[-1] == {}
+
+
+@pytest.mark.parametrize("mode", ("candidate", "release"))
+@pytest.mark.parametrize("platform_name", ("darwin", "linux"))
+@pytest.mark.parametrize("argument_key", ("maturin.build-args", "build-args"))
+@pytest.mark.parametrize("host_wheel", (False, True))
+def test_authenticated_wheel_rejects_frontend_maturin_overrides(
+    monkeypatch: pytest.MonkeyPatch,
+    mode: str,
+    platform_name: str,
+    argument_key: str,
+    host_wheel: bool,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", mode)
+    monkeypatch.setattr(backend.sys, "platform", platform_name)
+
+    with pytest.raises(RuntimeError, match="caller-supplied Maturin build arguments"):
+        supplied = {argument_key: ["--profile", "dev"]}
+        if host_wheel:
+            supplied["pyamplicol.host-wheel"] = "true"
+        backend._release_wheel_config_settings(supplied)
+
+
+@pytest.mark.parametrize("platform_name", ("linux", "darwin"))
+def test_release_bootstrap_wheel_uses_the_producer_platform(
+    monkeypatch: pytest.MonkeyPatch,
+    platform_name: str,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "release")
+    monkeypatch.setattr(backend.sys, "platform", platform_name)
+    observed: dict[str, object] = {}
+
+    def delegated(operation, *args, **kwargs):
+        observed["settings"] = args[1]
+        observed["context"] = kwargs["release_prepared_model_bootstrap_context"]
+        return "pyamplicol.whl"
+
+    monkeypatch.setattr(backend, "_from_overlay", delegated)
+    assert backend.build_release_prepared_model_bootstrap_wheel(
+        "dist",
+        bootstrap_context="test",
+        config_settings={"frontend.setting": "preserved"},
+    ) == "pyamplicol.whl"
+    expected: dict[str, object] = {"frontend.setting": "preserved"}
+    if platform_name == "linux":
+        expected["maturin.build-args"] = ["--compatibility", "linux"]
+    assert observed == {"settings": expected, "context": "test"}
+
+
+def test_release_bootstrap_wheel_rejects_frontend_maturin_overrides(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "release")
+    monkeypatch.setattr(backend.sys, "platform", "darwin")
+    with pytest.raises(RuntimeError, match="caller-supplied Maturin build arguments"):
+        backend.build_release_prepared_model_bootstrap_wheel(
+            "dist",
+            bootstrap_context="test",
+            config_settings={"build-args": "--features untracked"},
+        )
+
+
+def test_candidate_bootstrap_wheel_strips_stale_generated_assets(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "candidate")
+    monkeypatch.setenv("PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP", "1")
+    overlay = tmp_path / "overlay"
+    package = overlay / "src/pyamplicol"
+    build_info_path = package / "_build_info.json"
+    build_info_path.parent.mkdir(parents=True)
+    build_info_path.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "candidate_fingerprint": "b" * 12,
+                "native_build_inputs_sha256": "c" * 64,
+                "selftest_fixture_bootstrap": False,
+                "source_revision": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+    assets = package / "assets/prepared_models"
+    assets.mkdir(parents=True)
+    (assets / "__init__.py").write_text("# package\n", encoding="utf-8")
+    (assets / "built-in-sm-jit-o2-aarch64.metadata.json").write_text(
+        '{"producer": "stale"}\n',
+        encoding="utf-8",
+    )
+    (assets / "built-in-sm-jit-o2-aarch64.pyamplicol-model").write_bytes(b"stale")
+    fixture = package / "assets/selftest/portable-64le"
+    fixture.mkdir(parents=True)
+    (fixture / "expected.json").write_text('{"producer": "stale"}\n')
+    target = tmp_path / "target"
+    target.mkdir()
+
+    @contextlib.contextmanager
+    def fake_overlay(_mode: str):
+        yield overlay, target
+
+    def fake_sdk(_root: Path, _target: Path) -> Path:
+        staging = tmp_path / "sdk"
+        staging.mkdir()
+        (staging / "metadata.json").write_text(
+            json.dumps({"target": "aarch64-apple-darwin"}),
+            encoding="utf-8",
+        )
+        return staging
+
+    def delegated(*_args, **_kwargs) -> str:
+        assert {path.name for path in assets.iterdir()} == {"__init__.py"}
+        assert not fixture.exists()
+        build_info = json.loads(build_info_path.read_text(encoding="utf-8"))
+        assert build_info["source_revision"] is None
+        assert build_info["selftest_fixture_bootstrap"] is True
+        return "candidate-bootstrap.whl"
+
+    monkeypatch.setattr(backend, "_overlay", fake_overlay)
+    monkeypatch.setattr(backend, "_check_dependencies", lambda _mode: None)
+    monkeypatch.setattr(backend, "_rust_remap_flags", lambda *_args: "")
+    monkeypatch.setattr(backend, "_stage_packaged_examples", lambda _path: None)
+    monkeypatch.setattr(
+        backend, "_stage_packaged_profiling_campaign", lambda _path: None
+    )
+    monkeypatch.setattr(backend, "_stage_python_stub", lambda _path: None)
+    monkeypatch.setattr(backend, "_stage_runtime_resources", lambda _path: None)
+    monkeypatch.setattr(
+        backend,
+        "stage_packaged_prepared_models",
+        lambda *_args: pytest.fail("bootstrap wheel validated stale payloads"),
+    )
+    monkeypatch.setattr(backend, "build_sdk", fake_sdk)
+    monkeypatch.setattr(
+        backend,
+        "_stage_selftest_fixture",
+        lambda *_args: pytest.fail("bootstrap wheel staged a stale self-test fixture"),
+    )
+    monkeypatch.setattr(backend.maturin, "build_wheel", delegated)
+
+    assert backend.build_wheel(str(tmp_path / "dist")) == "candidate-bootstrap.whl"
+
+
+def test_release_prepared_model_recovery_strips_selftest_fixture(
+    tmp_path: Path,
+) -> None:
+    package = tmp_path / "src/pyamplicol"
+    package.mkdir(parents=True)
+    build_info_path = package / "_build_info.json"
+    build_info_path.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "candidate_fingerprint": None,
+                "release_prepared_model_bootstrap": True,
+                "selftest_fixture_bootstrap": False,
+            }
+        ),
+        encoding="utf-8",
+    )
+    fixture = package / "assets/selftest/portable-64le"
+    fixture.mkdir(parents=True)
+    (fixture / "expected.json").write_text("{}\n", encoding="utf-8")
+
+    backend._mark_selftest_fixture_bootstrap(
+        tmp_path,
+        prepared_model_recovery=True,
+    )
+
+    build_info = json.loads(build_info_path.read_text(encoding="utf-8"))
+    assert build_info["selftest_fixture_bootstrap"] is True
+    assert not fixture.exists()
+
+
+@pytest.mark.parametrize("mode", ["candidate", "release"])
+def test_ordinary_wheel_build_rejects_prepared_model_digest_drift(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    mode: str,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", mode)
+    monkeypatch.delenv("PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP", raising=False)
+    overlay = tmp_path / "overlay"
+    overlay.mkdir()
+    target = tmp_path / "target"
+    target.mkdir()
+
+    @contextlib.contextmanager
+    def fake_overlay(
+        actual_mode: str,
+        *,
+        project_release_prepared_models: bool = False,
+    ):
+        assert actual_mode == mode
+        assert project_release_prepared_models is (mode == "release")
+        yield overlay, target
+
+    monkeypatch.setattr(backend, "_overlay", fake_overlay)
+    monkeypatch.setattr(backend, "_check_dependencies", lambda _mode: None)
+    monkeypatch.setattr(backend, "_rust_remap_flags", lambda *_args: "")
+    monkeypatch.setattr(backend, "_stage_release_build_info", lambda *_args: None)
+    monkeypatch.setattr(
+        backend,
+        "_native_build_inputs_digest",
+        lambda *_args, **_kwargs: "d" * 64,
+    )
+    monkeypatch.setattr(
+        backend,
+        "canonical_package_version",
+        lambda _path: "0.1.0",
+    )
+    monkeypatch.setattr(backend, "_stage_packaged_examples", lambda _path: None)
+    monkeypatch.setattr(
+        backend, "_stage_packaged_profiling_campaign", lambda _path: None
+    )
+    monkeypatch.setattr(backend, "_stage_python_stub", lambda _path: None)
+    monkeypatch.setattr(backend, "_stage_runtime_resources", lambda _path: None)
+    monkeypatch.setattr(
+        backend,
+        "_strip_prepared_model_payloads",
+        lambda _path: pytest.fail("ordinary wheel stripped stale payloads"),
+    )
+
+    def reject_stale_pack(_path: Path, _mode: str) -> None:
+        raise RuntimeError("prepared model metadata is stale")
+
+    monkeypatch.setattr(
+        backend,
+        "stage_packaged_prepared_models",
+        reject_stale_pack,
+    )
+
+    with pytest.raises(
+        RuntimeError,
+        match="prepared model metadata is stale",
+    ):
+        backend.build_wheel(str(tmp_path / "dist"))
+
+
+def _candidate_inputs(tmp_path: Path) -> tuple[Path, Path, Path]:
+    candidate_lock = tmp_path / "Cargo.lock"
+    candidate_config = tmp_path / "config.toml"
+    installer_state = tmp_path / "install-state.json"
+    candidate_lock.write_bytes((ROOT / "Cargo.lock").read_bytes())
+    checkout = tmp_path / "dependencies" / "checkouts"
+    candidate_config.write_text(
+        "[patch.crates-io]\n"
+        f'graphica = {{ path = "{checkout / "symbolica/lib/graphica"}" }}\n'
+        f'numerica = {{ path = "{checkout / "symbolica/lib/numerica"}" }}\n'
+        f'symbolica = {{ path = "{checkout / "symbolica"}" }}\n'
+        f'symjit = {{ path = "{checkout / "symjit"}" }}\n',
+        encoding="utf-8",
+    )
+    with (ROOT / "dependencies" / "contributor-lock.toml").open("rb") as stream:
+        contributor = tomllib.load(stream)
+    sources = {
+        "gammaloop": {
+            "url": contributor["gammaloop_candidate"]["source_url"],
+            "revision": contributor["gammaloop_candidate"]["revision"],
+        },
+        "ratatui-ffi": {
+            "url": contributor["ratatui"]["ffi_repository"],
+            "revision": contributor["ratatui"]["ffi_revision"],
+        },
+        "symbolica": {
+            "url": contributor["symbolica"]["source_url"],
+            "revision": contributor["symbolica"]["candidate_revision"],
+        },
+        "symbolica-community": {
+            "url": contributor["symbolica"]["community_url"],
+            "revision": contributor["symbolica"]["community_revision"],
+        },
+        "symjit": {
+            "url": contributor["symjit"]["repository"],
+            "revision": contributor["symjit"]["revision"],
+        },
+    }
+    installer_state.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "sources": sources,
+            }
+        ),
+        encoding="utf-8",
+    )
+    return candidate_lock, candidate_config, installer_state
+
+
+def test_candidate_overlay_is_versioned_without_mutating_source(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    source_cargo = (ROOT / "Cargo.toml").read_bytes()
+    source_lock = (ROOT / "Cargo.lock").read_bytes()
+    source_pyproject = (ROOT / "pyproject.toml").read_bytes()
+    source_core = (
+        ROOT / "rust" / "crates" / "rusticol-core" / "Cargo.toml"
+    ).read_bytes()
+    candidate_inputs = _candidate_inputs(tmp_path)
+    monkeypatch.setattr(
+        backend,
+        "_candidate_inputs",
+        lambda: candidate_inputs,
+    )
+    monkeypatch.setattr(
+        backend,
+        "_clean_source_revision",
+        lambda **_kwargs: "a" * 40,
+    )
+    temporary_directory = tmp_path / "overlay-temporary"
+    temporary_directory.mkdir()
+    cargo_target_directory = tmp_path / "shared-cargo-target"
+    base_version = backend.canonical_package_version(ROOT)
+    native_digest = backend._native_build_inputs_digest(ROOT)
+    candidate_fingerprint = native_digest[:12]
+    candidate_version = f"{base_version}-dev.0+candidate.{candidate_fingerprint}"
+    with backend._overlay(
+        "candidate",
+        temporary_directory=temporary_directory,
+        cargo_target_directory=cargo_target_directory,
+    ) as (overlay, target):
+        assert overlay.parent.parent == temporary_directory
+        assert target == cargo_target_directory
+        cargo = (overlay / "Cargo.toml").read_text(encoding="utf-8")
+        lock = (overlay / "Cargo.lock").read_text(encoding="utf-8")
+        assert (overlay / ".cargo" / "config.toml").read_bytes() == (
+            candidate_inputs[1].read_bytes()
+        )
+        candidate_version_line = f'version = "{candidate_version}"'
+        assert candidate_version_line in cargo
+        assert lock.count(candidate_version_line) == 3
+        candidate_core = (
+            overlay / "rust" / "crates" / "rusticol-core" / "Cargo.toml"
+        ).read_text(encoding="utf-8")
+        with candidate_inputs[0].open("rb") as stream:
+            candidate_packages = tomllib.load(stream)["package"]
+        candidate_symbolica = next(
+            package["version"]
+            for package in candidate_packages
+            if package["name"] == "symbolica"
+        )
+        with (ROOT / "dependencies" / "release-lock.toml").open("rb") as stream:
+            release = tomllib.load(stream)
+        assert (
+            f'symjit = {{ version = "={release["symjit"]["version"]}"' in candidate_core
+        )
+        candidate_pyproject = (overlay / "pyproject.toml").read_text(encoding="utf-8")
+        assert f'"symbolica=={candidate_symbolica}"' in candidate_pyproject
+        build_info = json.loads(
+            (overlay / "src" / "pyamplicol" / "_build_info.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        assert build_info["publishable"] is False
+        assert build_info["selftest_fixture_bootstrap"] is False
+        assert build_info["candidate_fingerprint"] == candidate_fingerprint
+        assert build_info["native_build_inputs_sha256"] == native_digest
+        assert build_info["version"] == candidate_version.replace("-dev.", ".dev")
+        assert build_info["source_checkout"] == str(ROOT.resolve())
+        assert build_info["source_revision"] == "a" * 40
+        target = "aarch64-apple-darwin"
+        backend._stage_selftest_fixture(overlay, target)
+        selftest_manifest = json.loads(
+            (
+                overlay
+                / "src"
+                / "pyamplicol"
+                / "assets"
+                / "selftest"
+                / target
+                / "artifact"
+                / "artifact.json"
+            ).read_text(encoding="utf-8")
+        )
+        assert selftest_manifest["producer"]["version"] == build_info["version"]
+        assert selftest_manifest["runtime"]["engine_version"] == build_info["version"]
+        compiled_payloads = [
+            payload
+            for payload in selftest_manifest["payloads"]
+            if payload["role"] == "compiled-model"
+        ]
+        assert len(compiled_payloads) == 1
+        compiled_payload = compiled_payloads[0]
+        compiled_path = (
+            overlay
+            / "src"
+            / "pyamplicol"
+            / "assets"
+            / "selftest"
+            / target
+            / "artifact"
+            / compiled_payload["path"]
+        )
+        compiled_data = compiled_path.read_bytes()
+        compiled_model = json.loads(compiled_data)
+        assert compiled_model["producer"]["pyamplicol"] == build_info["version"]
+        assert compiled_payload["sha256"] == hashlib.sha256(compiled_data).hexdigest()
+        assert compiled_payload["size_bytes"] == len(compiled_data)
+        assert selftest_manifest["producer"]["target"] == {
+            "cpu_features": [],
+            "triple": target,
+        }
+        assert (
+            selftest_manifest["extensions"]["artifact_identity"]
+            == backend._ARTIFACT_IDENTITY_CONTRACT
+        )
+        target_payloads = [
+            payload["target"]
+            for payload in selftest_manifest["payloads"]
+            if "target" in payload
+        ]
+        assert target_payloads
+        assert target_payloads == [
+            {"cpu_features": [], "triple": target} for _payload in target_payloads
+        ]
+        expected = json.loads(
+            (
+                overlay
+                / "src"
+                / "pyamplicol"
+                / "assets"
+                / "selftest"
+                / target
+                / "expected.json"
+            ).read_text(encoding="utf-8")
+        )
+        assert expected["target"] == target
+        assert expected["compatible_targets"] == sorted(
+            backend._PORTABLE_SELFTEST_TARGETS
+        )
+        assert not (
+            overlay
+            / "src"
+            / "pyamplicol"
+            / "assets"
+            / "selftest"
+            / backend._PORTABLE_SELFTEST_TEMPLATE
+        ).exists()
+        assert selftest_manifest["artifact_id"] == backend._runtime_artifact_id(
+            selftest_manifest
+        )
+
+    assert (ROOT / "Cargo.toml").read_bytes() == source_cargo
+    assert (ROOT / "Cargo.lock").read_bytes() == source_lock
+    assert (ROOT / "pyproject.toml").read_bytes() == source_pyproject
+    assert (
+        ROOT / "rust" / "crates" / "rusticol-core" / "Cargo.toml"
+    ).read_bytes() == source_core
+
+
+def test_candidate_overlay_reuses_one_workspace_local_build_cache(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    checkout = tmp_path / "checkout"
+    checkout.mkdir()
+    cache = checkout / ".artifacts/dev-install"
+    cache.mkdir(parents=True)
+    monkeypatch.setattr(backend, "ROOT", checkout)
+    monkeypatch.setenv("PYAMPLICOL_CANDIDATE_CACHE_ROOT", str(cache))
+    digests = iter(("a" * 64, "b" * 64))
+    observed: list[tuple[Path, str | None]] = []
+    monkeypatch.setattr(
+        backend,
+        "_native_build_inputs_digest",
+        lambda *_args, **_kwargs: next(digests),
+    )
+
+    def populate(
+        source: Path,
+        _mode: str,
+        *,
+        native_build_inputs_sha256: str | None,
+        **_kwargs,
+    ) -> None:
+        source.mkdir(parents=True)
+        observed.append((source, native_build_inputs_sha256))
+
+    monkeypatch.setattr(backend, "_populate_overlay", populate)
+    paths: list[tuple[Path, Path]] = []
+    for _ in range(2):
+        with backend._overlay("candidate") as pair:
+            paths.append(pair)
+
+    expected = (cache / "project-build/source", cache / "cargo-target")
+    assert paths == [expected, expected]
+    assert observed == [
+        (expected[0], "a" * 64),
+        (expected[0], "b" * 64),
+    ]
+    assert backend._candidate_cache_root("release") is None
+
+
+def test_candidate_build_cache_rejects_non_workspace_paths(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    checkout = tmp_path / "checkout"
+    checkout.mkdir()
+    monkeypatch.setattr(backend, "ROOT", checkout)
+    monkeypatch.setenv(
+        "PYAMPLICOL_CANDIDATE_CACHE_ROOT",
+        str(tmp_path / "outside"),
+    )
+
+    with pytest.raises(RuntimeError, match="workspace-local developer cache"):
+        backend._candidate_cache_root("candidate")
+
+
+def test_release_overlay_uses_canonical_git_locked_resolution() -> None:
+    source_lock = (ROOT / "Cargo.lock").read_bytes()
+    with backend._overlay("release") as (overlay, _target):
+        assert (overlay / "Cargo.lock").read_bytes() == source_lock
+        assert not (overlay / ".cargo" / "config.toml").exists()
+        assert not (overlay / ".pyamplicol-build-dependencies").exists()
+        assert not (overlay / "dependencies" / "candidate-Cargo.lock").exists()
+
+
+def test_release_overlay_skips_contributor_native_digest(monkeypatch) -> None:
+    def unexpected_digest(_root: Path) -> str:
+        raise AssertionError("release builds must not hash contributor inputs")
+
+    monkeypatch.setattr(backend, "_native_build_inputs_digest", unexpected_digest)
+    with backend._overlay("release") as (overlay, _target):
+        assert not (overlay / "src/pyamplicol/_build_info.json").exists()
+
+
+def test_release_overlay_requires_source_store_in_git_checkout(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    source_checkout = tmp_path / "checkout"
+    source_checkout.mkdir()
+    (source_checkout / ".git").write_text("gitdir: elsewhere\n", encoding="utf-8")
+
+    def copy_without_store(destination: Path) -> None:
+        destination.mkdir(parents=True)
+
+    monkeypatch.setattr(backend, "ROOT", source_checkout)
+    monkeypatch.setattr(backend, "_copy_allowlisted_source", copy_without_store)
+    monkeypatch.setattr(backend, "_stage_cargo_inputs", lambda *_args, **_kwargs: None)
+
+    with (
+        pytest.raises(RuntimeError, match="source store is missing"),
+        backend._overlay("release", project_release_prepared_models=True),
+    ):
+        pass
+
+
+def test_release_overlay_reuses_canonical_assets_from_source_archive(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    source_archive = tmp_path / "archive"
+    source_archive.mkdir()
+
+    def copy_canonical_release_assets(destination: Path) -> None:
+        asset = destination / "src/pyamplicol/assets/prepared_models/release.bin"
+        asset.parent.mkdir(parents=True)
+        asset.write_bytes(b"canonical release payload")
+
+    monkeypatch.setattr(backend, "ROOT", source_archive)
+    monkeypatch.setattr(
+        backend,
+        "_copy_allowlisted_source",
+        copy_canonical_release_assets,
+    )
+    monkeypatch.setattr(backend, "_stage_cargo_inputs", lambda *_args, **_kwargs: None)
+
+    with backend._overlay(
+        "release",
+        project_release_prepared_models=True,
+    ) as (overlay, _target):
+        assert (
+            overlay / "src/pyamplicol/assets/prepared_models/release.bin"
+        ).read_bytes() == b"canonical release payload"
+        assert not (overlay / "release_assets").exists()
+
+
+def test_release_prepared_model_bootstrap_overlay_is_non_publishable(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        backend,
+        "_native_build_inputs_digest",
+        lambda _root, **_kwargs: "c" * 64,
+    )
+    source_lock = (ROOT / "Cargo.lock").read_bytes()
+
+    with backend._overlay(
+        "release",
+        release_prepared_model_bootstrap=True,
+    ) as (overlay, _target):
+        build_info = json.loads(
+            (overlay / "src/pyamplicol/_build_info.json").read_text(encoding="utf-8")
+        )
+
+        assert build_info == {
+            "candidate_fingerprint": None,
+            "native_build_inputs_sha256": "c" * 64,
+            "publishable": False,
+            "release_prepared_model_bootstrap": True,
+            "schema_version": 1,
+            "selftest_fixture_bootstrap": False,
+            "source_checkout": str(ROOT.resolve()),
+            "version": backend.canonical_package_version(ROOT),
+        }
+        assert (overlay / "Cargo.lock").read_bytes() == source_lock
+        assert not (overlay / ".cargo/config.toml").exists()
+
+
+def test_release_prepared_model_bootstrap_does_not_require_git_identity(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def unexpected_revision() -> None:
+        raise AssertionError("release bootstrap must not inspect Git identity")
+
+    monkeypatch.setattr(backend, "_clean_source_revision", unexpected_revision)
+    monkeypatch.setattr(
+        backend,
+        "_native_build_inputs_digest",
+        lambda _root, **_kwargs: "c" * 64,
+    )
+
+    with backend._overlay(
+        "release",
+        release_prepared_model_bootstrap=True,
+    ) as (overlay, _target):
+        build_info = json.loads(
+            (overlay / "src/pyamplicol/_build_info.json").read_text(encoding="utf-8")
+        )
+    assert "source_revision" not in build_info
+    assert build_info["native_build_inputs_sha256"] == "c" * 64
+
+
+def test_candidate_source_revision_ignores_only_generated_report_outputs(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    checkout = _source_identity_checkout(tmp_path)
+    profile = checkout / "docs/performance_reports/manual"
+    (profile / "results/cache.json").write_text('{"updated":true}\n', encoding="utf-8")
+    (profile / "result_sample_table.tex").write_text("% updated\n", encoding="utf-8")
+    (profile / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.7\n")
+    summary = profile / "campaign_summary_ids"
+    summary.mkdir()
+    (summary / "error.txt").write_text("cell-a\n", encoding="utf-8")
+    monkeypatch.setattr(backend, "ROOT", checkout)
+
+    assert backend._clean_source_revision() is None
+    assert backend._clean_source_revision(allow_generated_report_outputs=True) == _git(
+        checkout, "rev-parse", "HEAD"
+    )
+
+
+@pytest.mark.parametrize(
+    "destination",
+    (Path("x86_epyc_manual"), Path("scratch/campaigns/x86_epyc_manual")),
+)
+def test_candidate_source_revision_ignores_untracked_copied_campaign_anywhere(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    destination: Path,
+) -> None:
+    checkout = _source_identity_checkout(tmp_path)
+    copied = checkout / destination
+    (copied / "results").mkdir(parents=True)
+    (copied / "README.md").write_text("# copied campaign\n", encoding="utf-8")
+    (copied / "steer_performance_campaign.py").write_text(
+        "#!/usr/bin/env python3\n",
+        encoding="utf-8",
+    )
+    (copied / "report-workspace.json").write_text("{}\n", encoding="utf-8")
+    (copied / "pyAmpliCol.tex").write_text("% copied template\n", encoding="utf-8")
+    (copied / "results/cache.json").write_text("{}\n", encoding="utf-8")
+    monkeypatch.setattr(backend, "ROOT", checkout)
+
+    assert backend._clean_source_revision() is None
+    assert backend._clean_source_revision(allow_generated_report_outputs=True) == _git(
+        checkout, "rev-parse", "HEAD"
+    )
+    assert not any(
+        path == destination or destination in path.parents
+        for path in backend._git_inventory() or ()
+    )
+
+    tracked = checkout / "src/runtime.py"
+    tracked.write_text("VALUE = 2\n", encoding="utf-8")
+    assert (
+        backend._clean_source_revision(allow_generated_report_outputs=True) is None
+    )
+
+
+def test_candidate_source_revision_rejects_incomplete_untracked_campaign(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    checkout = _source_identity_checkout(tmp_path)
+    copied = checkout / "scratch/incomplete"
+    copied.mkdir(parents=True)
+    (copied / "report-workspace.json").write_text("{}\n", encoding="utf-8")
+    (copied / "README.md").write_text("# incomplete\n", encoding="utf-8")
+    monkeypatch.setattr(backend, "ROOT", checkout)
+
+    assert backend._clean_source_revision(allow_generated_report_outputs=True) is None
+
+
+def test_candidate_source_revision_rejects_campaign_markers_in_tracked_tree(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    checkout = _source_identity_checkout(tmp_path)
+    tracked_tree = checkout / "src"
+    (tracked_tree / "report-workspace.json").write_text("{}\n", encoding="utf-8")
+    (tracked_tree / "steer_performance_campaign.py").write_text(
+        "#!/usr/bin/env python3\n",
+        encoding="utf-8",
+    )
+    (tracked_tree / "rogue_runtime.py").write_text(
+        "VALUE = 'untracked'\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(backend, "ROOT", checkout)
+
+    assert backend._clean_source_revision(allow_generated_report_outputs=True) is None
+
+
+@pytest.mark.parametrize(
+    "relative",
+    (
+        "src/runtime.py",
+        "docs/performance_reports/manual/pyAmpliCol.tex",
+        "pyproject.toml",
+        "docs/performance_reports/manual/unexpected.json",
+    ),
+)
+def test_candidate_source_revision_rejects_non_generated_dirt(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    relative: str,
+) -> None:
+    checkout = _source_identity_checkout(tmp_path)
+    profile = checkout / "docs/performance_reports/manual"
+    (profile / "results/cache.json").write_text('{"updated":true}\n', encoding="utf-8")
+    changed = checkout / relative
+    changed.parent.mkdir(parents=True, exist_ok=True)
+    changed.write_text("changed\n", encoding="utf-8")
+    monkeypatch.setattr(backend, "ROOT", checkout)
+
+    assert backend._clean_source_revision(allow_generated_report_outputs=True) is None
+
+
+def test_release_build_info_is_minimal_and_retained_from_sdist(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    checkout = tmp_path / "checkout"
+    (checkout / ".git").mkdir(parents=True)
+    overlay = tmp_path / "checkout-overlay"
+    monkeypatch.setattr(backend, "ROOT", checkout)
+    monkeypatch.setattr(backend, "_clean_source_revision", lambda: "a" * 40)
+
+    backend._stage_release_build_info(overlay, "0.1.0")
+    marker = overlay / "src/pyamplicol/_build_info.json"
+    expected = {
+        "schema_version": 1,
+        "publishable": True,
+        "selftest_fixture_bootstrap": False,
+        "source_revision": "a" * 40,
+        "version": "0.1.0",
+    }
+    assert json.loads(marker.read_text(encoding="utf-8")) == expected
+    retained = marker.read_bytes()
+
+    source_archive = tmp_path / "source-archive"
+    source_archive.mkdir()
+    archive_overlay = tmp_path / "archive-overlay"
+    archive_marker = archive_overlay / "src/pyamplicol/_build_info.json"
+    archive_marker.parent.mkdir(parents=True)
+    archive_marker.write_bytes(retained)
+    monkeypatch.setattr(backend, "ROOT", source_archive)
+
+    backend._stage_release_build_info(archive_overlay, "0.1.0")
+    assert archive_marker.read_bytes() == retained
+
+
+def test_release_build_info_rejects_an_expanded_archive_marker(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    source_archive = tmp_path / "source-archive"
+    source_archive.mkdir()
+    overlay = tmp_path / "overlay"
+    marker = overlay / "src/pyamplicol/_build_info.json"
+    marker.parent.mkdir(parents=True)
+    marker.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": True,
+                "selftest_fixture_bootstrap": False,
+                "source_revision": "a" * 40,
+                "source_checkout": "/private/checkout",
+                "version": "0.1.0",
+            }
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(backend, "ROOT", source_archive)
+
+    with pytest.raises(RuntimeError, match="invalid build provenance"):
+        backend._stage_release_build_info(overlay, "0.1.0")
+
+
+def test_selftest_staging_rejects_an_unavailable_target() -> None:
+    with (
+        backend._overlay("release") as (overlay, _target),
+        pytest.raises(RuntimeError, match="unsupported self-test target"),
+    ):
+        backend._stage_selftest_fixture(overlay, "x86_64-unknown-test")
+
+
+def test_selftest_staging_applies_the_arena_execution_contract(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[Path] = []
+
+    def reject(
+        fixture: Path,
+        manifest: object,
+        *,
+        source_root: Path,
+    ) -> None:
+        assert isinstance(manifest, dict)
+        assert source_root.name == "source"
+        calls.append(fixture)
+        raise RuntimeError("Arena execution contract sentinel")
+
+    monkeypatch.setattr(
+        backend,
+        "_validate_portable_selftest_executions",
+        reject,
+    )
+    with (
+        backend._overlay("release") as (overlay, _target),
+        pytest.raises(RuntimeError, match="Arena execution contract sentinel"),
+    ):
+        backend._stage_selftest_fixture(overlay, "aarch64-apple-darwin")
+
+    assert len(calls) == 1
+    assert calls[0].name == "aarch64-apple-darwin"
+
+
+@pytest.mark.parametrize("target", sorted(backend._PORTABLE_SELFTEST_TARGETS))
+def test_portable_selftest_stages_for_every_release_target(target: str) -> None:
+    with backend._overlay("release") as (overlay, _target):
+        backend._stage_selftest_fixture(overlay, target)
+        fixture_root = overlay / "src" / "pyamplicol" / "assets" / "selftest"
+        assert tuple(path.name for path in fixture_root.iterdir()) == (target,)
+        manifest = json.loads(
+            (fixture_root / target / "artifact" / "artifact.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        assert manifest["producer"]["target"]["triple"] == target
+        assert {
+            payload["target"]["triple"]
+            for payload in manifest["payloads"]
+            if "target" in payload
+        } == {target}
+
+
+def test_cargo_overlay_rejects_unknown_resolution_mode(tmp_path: Path) -> None:
+    with pytest.raises(RuntimeError, match="unsupported Cargo input mode"):
+        backend._stage_cargo_inputs(
+            tmp_path,
+            "mixed",
+            native_build_inputs_sha256="0" * 64,
+        )
+
+
+def test_candidate_inputs_fail_closed_when_installer_has_not_run() -> None:
+    expected = (
+        ROOT / "dependencies" / "candidate-Cargo.lock",
+        ROOT / "dependencies" / "candidate-cargo-config.toml",
+        ROOT / "dependencies" / "install-state.json",
+    )
+    if all(path.is_file() for path in expected):
+        pytest.skip("candidate environment is installed")
+    with pytest.raises(RuntimeError, match="dev-install"):
+        backend._candidate_inputs()
+
+
+def test_candidate_source_distributions_are_rejected(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "candidate")
+    with pytest.raises(RuntimeError, match="wheel-only"):
+        backend.build_sdist(str(tmp_path))
+
+
+def test_overlay_excludes_managed_dependencies_and_includes_licenses() -> None:
+    with backend._overlay("release") as (overlay, _target):
+        assert (overlay / "licenses" / "MadGraph5_aMCatNLO.txt").is_file()
+        assert (overlay / "rust-toolchain.toml").is_file()
+        assert (overlay / "tools" / "typing" / "check_public_typing.py").is_file()
+        assert (overlay / "dependencies" / "release-lock.toml").is_file()
+        assert not (overlay / "dependencies" / "checkouts").exists()
+        assert not (overlay / "dependencies" / "contributor-lock.toml").exists()
+        assert not (overlay / "dependencies" / "install_dependencies.py").exists()
+        assert not (overlay / "dependencies" / "install-state.json").exists()
+        assert not (overlay / "dependencies" / "patches").exists()
+        assert not (overlay / "dependencies" / "python-runtime-lock.toml").exists()
+        assert not (overlay / "build_backend" / "python_lock.py").exists()
+
+
+def test_fft_profiling_tool_is_retained_by_source_release_manifests() -> None:
+    pyproject = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+    includes = {entry["path"] for entry in pyproject["tool"]["maturin"]["include"]}
+
+    assert "tools/fft_profiling" in backend.ALLOWLIST
+    assert "tools/fft_profiling/**/*" in includes
+    assert (ROOT / "tools/fft_profiling/fft_profiling.py").is_file()
+
+
+def test_wheel_examples_are_staged_from_the_single_canonical_tree() -> None:
+    with backend._overlay("release") as (overlay, _target):
+        packaged = overlay / "src" / "pyamplicol" / "_examples"
+        assert not packaged.exists()
+        backend._stage_packaged_examples(overlay)
+        assert (packaged / "all_options.toml").is_file()
+        assert (packaged / "builtin_sm_heft.toml").is_file()
+        assert (packaged / "qq_z6g_recurrence_jit_o2.toml").is_file()
+        assert (packaged / "qq_z6g_compiled_jit_o3.toml").is_file()
+        assert (packaged / "qq_z6g_eager_jit_o2.toml").is_file()
+        assert (packaged / "otf_pp_zjj.toml").is_file()
+        assert (packaged / "python/otf_pp_zjj_warm_up.py").is_file()
+        assert (packaged / "native" / "runtime.cpp").is_file()
+        assert (packaged / "all_options.toml").read_bytes() == (
+            overlay / "examples" / "all_options.toml"
+        ).read_bytes()
+        with pytest.raises(RuntimeError, match="already contains"):
+            backend._stage_packaged_examples(overlay)
+
+
+def test_wheel_profiling_campaign_is_a_bounded_reset_template() -> None:
+    with backend._overlay("release") as (overlay, _target):
+        source = overlay / backend._PROFILING_CAMPAIGN_SOURCE
+        packaged = overlay / "src/pyamplicol/_profiling_campaign"
+        assert packaged == source
+        before = {
+            path.relative_to(packaged): path.read_bytes()
+            for path in packaged.rglob("*")
+            if path.is_file()
+        }
+        backend._stage_packaged_profiling_campaign(overlay)
+        copied = {
+            path.relative_to(packaged) for path in packaged.rglob("*") if path.is_file()
+        }
+        assert copied == set(backend._profiling_campaign_inventory(source))
+        assert len(copied) == 69
+        assert {
+            Path("result_matrix_on_the_fly_builtin_sm_full_table.tex"),
+            Path("result_matrix_on_the_fly_builtin_sm_lc_table.tex"),
+            Path("result_matrix_on_the_fly_builtin_sm_nlc_table.tex"),
+            Path("results/matrix_on_the_fly_builtin_sm_full.json"),
+            Path("results/matrix_on_the_fly_builtin_sm_lc.json"),
+            Path("results/matrix_on_the_fly_builtin_sm_nlc.json"),
+        } <= copied
+        assert {
+            path.relative_to(packaged): path.read_bytes()
+            for path in packaged.rglob("*")
+            if path.is_file()
+        } == before
+        assert Path("steer_performance_campaign.py") in copied
+        assert Path("results/report-cache.schema.json") in copied
+        runtime = overlay / "src/pyamplicol/_performance_report"
+        assert {path.name for path in runtime.glob("*.py")} == {
+            path.name for path in (overlay / "tools/performance_report").glob("*.py")
+        } | {"_memory_watchdog.py"}
+        assert (runtime / "manual_campaign.py").read_bytes() == (
+            overlay / "tools/performance_report/manual_campaign.py"
+        ).read_bytes()
+        assert (runtime / "_memory_watchdog.py").read_bytes() == (
+            overlay / "tools/ci/memory_watchdog.py"
+        ).read_bytes()
+        assert (runtime / "_developer/__init__.py").is_file()
+        assert (runtime / "_developer/legacy_amplicol.py").read_bytes() == (
+            overlay / "tools/developer/legacy_amplicol.py"
+        ).read_bytes()
+        oracle = runtime / "_developer/legacy_oracle"
+        assert {path.name for path in oracle.glob("*.py")} == {
+            path.name
+            for path in (overlay / "tools/developer/legacy_oracle").glob("*.py")
+        }
+        assert (oracle / "__init__.py").is_file()
+        with pytest.raises(RuntimeError, match="already contains"):
+            backend._stage_packaged_profiling_campaign(overlay)
+
+
+def test_wheel_stages_the_single_maintained_rusticol_stub() -> None:
+    with backend._overlay("release") as (overlay, _target):
+        source = (
+            overlay
+            / "rust"
+            / "crates"
+            / "rusticol-python"
+            / "stubs"
+            / "pyamplicol"
+            / "_rusticol.pyi"
+        )
+        target = overlay / "src" / "pyamplicol" / "_rusticol.pyi"
+        assert source.is_file()
+        assert not target.exists()
+        backend._stage_python_stub(overlay)
+        assert target.read_bytes() == source.read_bytes()
+        with pytest.raises(RuntimeError, match="already contains"):
+            backend._stage_python_stub(overlay)
+
+
+def test_wheel_stages_runtime_resources_inside_package_namespace(
+    tmp_path: Path,
+) -> None:
+    overlay = tmp_path / "overlay"
+    for relative in (
+        Path("schemas/README.md"),
+        Path("schemas/artifact-manifest-v3.schema.json"),
+        Path("schemas/runtime-physics-v1.schema.json"),
+    ):
+        target = overlay / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes((ROOT / relative).read_bytes())
+
+    backend._stage_runtime_resources(overlay)
+    package_assets = overlay / "src" / "pyamplicol" / "assets"
+    assert not (package_assets / "release").exists()
+    assert (
+        package_assets / "schemas" / "artifact-manifest-v3.schema.json"
+    ).read_bytes() == (
+        overlay / "schemas" / "artifact-manifest-v3.schema.json"
+    ).read_bytes()
+    assert (package_assets / "schemas" / "runtime-physics-v1.schema.json").is_file()
+    with pytest.raises(RuntimeError, match="already contains"):
+        backend._stage_runtime_resources(overlay)
+
+
+def test_overlay_rejects_symlinked_inputs(tmp_path: Path) -> None:
+    target = tmp_path / "target"
+    target.write_text("content", encoding="utf-8")
+    link = tmp_path / "link"
+    link.symlink_to(target)
+    with pytest.raises(RuntimeError, match="symlinks"):
+        backend._reject_symlinks(link)
+
+
+def test_overlay_prunes_excluded_directories_before_symlink_walk(
+    tmp_path: Path,
+) -> None:
+    source = tmp_path / "source"
+    excluded = source / "checkouts"
+    excluded.mkdir(parents=True)
+    (excluded / "escape").symlink_to(tmp_path)
+    backend._reject_symlinks(source)
+
+
+def test_git_overlay_copies_only_tracked_files_and_prunes_ignored_symlinks(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    source = tmp_path / "source"
+    source.mkdir()
+    subprocess.run(["git", "init", "-q", source], check=True)
+    subprocess.run(
+        ["git", "-C", str(source), "config", "user.email", "test@example.invalid"],
+        check=True,
+    )
+    subprocess.run(
+        ["git", "-C", str(source), "config", "user.name", "Test"],
+        check=True,
+    )
+    tracked = source / "build_backend" / "tracked.py"
+    tracked.parent.mkdir()
+    tracked.write_text("tracked = True\n", encoding="utf-8")
+    subprocess.run(
+        ["git", "-C", str(source), "add", "build_backend/tracked.py"],
+        check=True,
+    )
+    subprocess.run(["git", "-C", str(source), "commit", "-qm", "tracked"], check=True)
+    (tracked.parent / "untracked.py").write_text("leak = True\n", encoding="utf-8")
+    excluded = source / "dependencies" / "checkouts"
+    excluded.mkdir(parents=True)
+    (excluded / "escape").symlink_to(tmp_path)
+
+    monkeypatch.setattr(backend, "ROOT", source)
+    destination = tmp_path / "destination"
+    backend._copy_allowlisted_source(destination)
+    assert (destination / "build_backend" / "tracked.py").is_file()
+    assert not (destination / "build_backend" / "untracked.py").exists()
+    assert not (destination / "dependencies" / "checkouts").exists()
+
+
+def test_archive_overlay_without_git_history_uses_pruned_allowlist(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    source = tmp_path / "archive"
+    retained = {
+        Path("build_backend/backend.py"): "archive = True\n",
+        Path("src/pyamplicol/_profiling_campaign/pyAmpliCol.tex"): (
+            "maintained TeX\n"
+        ),
+        Path("release_assets/prepared_models/README.md"): "release store\n",
+        Path("src/pyamplicol/_sdk/config.py"): "maintained SDK config\n",
+        Path("src/rusticol_config/__init__.py"): "standalone SDK config\n",
+        Path("tests/fixtures/candidate-Cargo.lock"): "fixture lock\n",
+    }
+    excluded = (
+        Path("dependencies/candidate-Cargo.lock"),
+        Path("dependencies/candidate-cargo-config.toml"),
+        Path("dependencies/contributor-lock.toml"),
+        Path("dependencies/install_dependencies.py"),
+        Path("dependencies/install-state.json"),
+        Path("dependencies/patches/dependency/fix.patch"),
+        Path("dependencies/python-runtime-lock.toml"),
+        Path("build_backend/python_lock.py"),
+        Path("docs/.result_outputs/cache.json"),
+        Path("docs/archive/retired.md"),
+        Path("src/pyamplicol/_profiling_campaign/pyAmpliCol.aux"),
+        Path("src/pyamplicol/_profiling_campaign/pyAmpliCol.synctex.gz"),
+        Path("docs/performance_reports/macbook_M3/pyAmpliCol.toc"),
+        Path(
+            "src/pyamplicol/_profiling_campaign/campaign_artifacts/"
+            "private-attempt.bin"
+        ),
+        Path("src/pyamplicol.egg-info/PKG-INFO"),
+        Path("src/pyamplicol/_rusticol.abi3.so"),
+        Path("src/pyamplicol/_rusticol.dylib"),
+        Path("src/pyamplicol/_rusticol.pyd"),
+        Path("src/pyamplicol/_sdk/fortran/rusticol.f90"),
+        Path("src/pyamplicol/_sdk/include/rusticol.h"),
+        Path("src/pyamplicol/_sdk/lib/librusticol_capi.a"),
+        Path("src/pyamplicol/_sdk/link.json"),
+        Path("src/pyamplicol/_sdk/metadata.json"),
+        Path("tests/.artifacts/build.json"),
+        Path("tests/build/output.txt"),
+        Path("tests/htmlcov/index.html"),
+    )
+    for relative, content in retained.items():
+        path = source / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+    for relative in excluded:
+        path = source / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("generated\n", encoding="utf-8")
+    ignored = source / "build_backend" / "__pycache__"
+    ignored.mkdir()
+    (ignored / "escape").symlink_to(tmp_path)
+    monkeypatch.setattr(backend, "ROOT", source)
+
+    destination = tmp_path / "destination"
+    backend._copy_allowlisted_source(destination)
+    for relative, content in retained.items():
+        assert (destination / relative).read_text(encoding="utf-8") == content
+    for relative in excluded:
+        assert not (destination / relative).exists()
+    assert not (destination / "build_backend" / "__pycache__").exists()
+
+    copy_ignore = backend._copy_ignore(source)
+    assert copy_ignore(
+        str(source / "docs" / "arxiv"),
+        ["pyAmpliCol.aux", "pyAmpliCol.tex"],
+    ) == {"pyAmpliCol.aux"}
+    assert copy_ignore(
+        str(source / "src" / "pyamplicol" / "_sdk"),
+        ["config.py", "lib", "metadata.json"],
+    ) == {"lib", "metadata.json"}
+
+
+def test_release_prepared_store_is_outside_native_build_identity(
+    tmp_path: Path,
+) -> None:
+    cargo = tmp_path / "Cargo.toml"
+    cargo.write_text("[workspace]\n", encoding="utf-8")
+    (tmp_path / "pyproject.toml").write_bytes(
+        (ROOT / "pyproject.toml").read_bytes()
+    )
+    before = backend._native_build_inputs_digest(tmp_path)
+    store = tmp_path / "release_assets" / "prepared_models"
+    store.mkdir(parents=True)
+    (store / "built-in-sm-jit-o2-aarch64.metadata.json").write_text(
+        "{}\n",
+        encoding="utf-8",
+    )
+
+    assert backend._native_build_inputs_digest(tmp_path) == before
+
+    native = tmp_path / "rust" / "native.rs"
+    native.parent.mkdir()
+    native.write_text("fn changed() {}\n", encoding="utf-8")
+    assert backend._native_build_inputs_digest(tmp_path) != before
+
+
+@pytest.mark.parametrize(
+    ("hook", "arguments", "expected", "with_sdk"),
+    [
+        ("build_wheel", ("wheel",), "delegated", True),
+        ("build_sdist", ("sdist",), "delegated", False),
+        ("get_requires_for_build_wheel", (), ["delegated"], False),
+        ("get_requires_for_build_sdist", (), ["delegated"], False),
+        ("prepare_metadata_for_build_wheel", ("metadata",), "delegated", False),
+    ],
+)
+def test_retained_pep517_hooks_use_gate_overlay_and_clean_environment(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    hook: str,
+    arguments: tuple[str, ...],
+    expected: str | list[str],
+    with_sdk: bool,
+) -> None:
+    # This test exercises the publishable hook contract independently of the
+    # candidate mode used by the enclosing contributor source gate.
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "release")
+    overlay = tmp_path / "overlay"
+    overlay.mkdir()
+    target = tmp_path / "cargo-target"
+    gates: list[str] = []
+    sdk_stages: list[Path] = []
+    selftest_stages: list[tuple[Path, str]] = []
+    prepared_model_stages: list[tuple[Path, str]] = []
+    injected_bins = (tmp_path / "injected-bin", tmp_path / "injected-tools")
+    for directory in injected_bins:
+        directory.mkdir()
+    injected = {
+        "CARGO": "/attacker/cargo",
+        "CARGO_BUILD_TARGET": "attacker-target",
+        "CC": "/attacker/cc",
+        "CPATH": "/opt/local/include",
+        "CXX": "/attacker/c++",
+        "DYLD_LIBRARY_PATH": "/opt/local/lib",
+        "GIT_INDEX_FILE": "/attacker/index",
+        "LIBRARY_PATH": "/opt/local/lib",
+        "MATURIN_PEP517_ARGS": "--target attacker-target",
+        "PYO3_PYTHON": "/attacker/python",
+        "PYTHONPATH": "/attacker/pythonpath",
+        "RUSTC_WRAPPER": "/attacker/wrapper",
+        "RUSTFLAGS": "-Clink-arg=/attacker/library",
+    }
+    for name, value in injected.items():
+        monkeypatch.setenv(name, value)
+    monkeypatch.setenv(
+        "PATH",
+        os.pathsep.join(str(path) for path in injected_bins)
+        + os.pathsep
+        + os.environ["PATH"],
+    )
+
+    @contextlib.contextmanager
+    def fake_overlay(
+        mode: str,
+        *,
+        project_release_prepared_models: bool = False,
+    ):
+        assert mode == "release"
+        assert project_release_prepared_models is True
+        yield overlay, target
+
+    def fake_sdk(root: Path, target_dir: Path) -> Path:
+        assert root == overlay and target_dir == target
+        assert not (set(injected) - {"CC", "CXX"}) & set(os.environ)
+        assert not {str(path) for path in injected_bins} & set(
+            os.environ["PATH"].split(os.pathsep)
+        )
+        assert "CARGO_ENCODED_RUSTFLAGS" in os.environ
+        assert os.environ["RUSTUP_TOOLCHAIN"] == "1.97.1"
+        if sys.platform == "darwin":
+            assert os.environ["CC"] == "/usr/bin/clang"
+            assert os.environ["CXX"] == "/usr/bin/clang++"
+        else:
+            assert not {"CC", "CXX"} & set(os.environ)
+        staging = tmp_path / "sdk"
+        staging.mkdir()
+        (staging / "metadata.json").write_text(
+            json.dumps({"target": "aarch64-apple-darwin"}), encoding="utf-8"
+        )
+        sdk_stages.append(staging)
+        return staging
+
+    def delegated(*_args, **_kwargs):
+        assert Path.cwd() == overlay
+        assert not (set(injected) - {"CC", "CXX"}) & set(os.environ)
+        assert not {str(path) for path in injected_bins} & set(
+            os.environ["PATH"].split(os.pathsep)
+        )
+        remaps = os.environ["CARGO_ENCODED_RUSTFLAGS"].split("\x1f")
+        assert len(remaps) == 5
+        assert all(flag.startswith("--remap-path-prefix=") for flag in remaps)
+        assert (
+            f"--remap-path-prefix={(ROOT / 'dependencies' / 'checkouts').resolve()}="
+            "/pyamplicol/dependencies"
+        ) in remaps
+        assert os.environ["CARGO_HOME"] == str(tmp_path / "cargo-home")
+        assert os.environ["CARGO_TARGET_DIR"] == str(target)
+        assert os.environ["PYAMPLICOL_BUILD_OVERLAY"] == str(overlay)
+        assert os.environ["PYAMPLICOL_NATIVE_BUILD_INPUTS_SHA256"] == (
+            backend._native_build_inputs_digest(
+                ROOT,
+                normalize_release_cargo_lock=True,
+            )
+        )
+        assert os.environ["RUSTUP_TOOLCHAIN"] == "1.97.1"
+        if sys.platform == "darwin":
+            assert os.environ["CC"] == "/usr/bin/clang"
+            assert os.environ["CXX"] == "/usr/bin/clang++"
+            assert os.environ["MACOSX_DEPLOYMENT_TARGET"] == "11.0"
+        else:
+            assert not {"CC", "CXX"} & set(os.environ)
+        if with_sdk:
+            assert os.environ["PYAMPLICOL_SDK_STAGING"] == str(tmp_path / "sdk")
+        return ["delegated"] if hook.startswith("get_requires") else "delegated"
+
+    monkeypatch.setattr(backend, "_overlay", fake_overlay)
+    monkeypatch.setattr(backend, "_check_dependencies", gates.append)
+    build_info_stages: list[tuple[Path, str]] = []
+    monkeypatch.setattr(
+        backend,
+        "_stage_release_build_info",
+        lambda path, version: build_info_stages.append((path, version)),
+    )
+    monkeypatch.setattr(
+        backend,
+        "canonical_package_version",
+        lambda _path: "0.1.0",
+    )
+    monkeypatch.setattr(backend, "_stage_packaged_examples", lambda path: None)
+    monkeypatch.setattr(
+        backend, "_stage_packaged_profiling_campaign", lambda path: None
+    )
+    monkeypatch.setattr(backend, "_stage_python_stub", lambda path: None)
+    monkeypatch.setattr(backend, "_stage_runtime_resources", lambda path: None)
+    monkeypatch.setattr(
+        backend,
+        "stage_packaged_prepared_models",
+        lambda path, mode: prepared_model_stages.append((path, mode)),
+    )
+    monkeypatch.setattr(
+        backend,
+        "_stage_selftest_fixture",
+        lambda path, target_name: selftest_stages.append((path, target_name)),
+    )
+    monkeypatch.setattr(backend, "build_sdk", fake_sdk)
+    monkeypatch.setattr(backend.maturin, hook, delegated)
+
+    result = getattr(backend, hook)(*arguments)
+    assert result == expected
+    output = capsys.readouterr().out
+    assert ("* Building native C SDK" in output) is with_sdk
+    assert ("* Native C SDK built." in output) is with_sdk
+    assert gates == ["release"]
+    assert bool(sdk_stages) is with_sdk
+    assert selftest_stages == ([(overlay, "aarch64-apple-darwin")] if with_sdk else [])
+    assert prepared_model_stages == (
+        [(overlay, "release")] if with_sdk or hook == "build_sdist" else []
+    )
+    assert build_info_stages == (
+        [(overlay, "0.1.0")] if hook in {"build_wheel", "build_sdist"} else []
+    )
+    for name, value in injected.items():
+        assert os.environ[name] == value
+
+
+def test_backend_does_not_advertise_pep660_hooks() -> None:
+    editable_hooks = (
+        "build_editable",
+        "get_requires_for_build_editable",
+        "prepare_metadata_for_build_editable",
+    )
+    assert not [name for name in editable_hooks if hasattr(backend, name)]
+
+
+def test_sdk_build_references_the_python_owned_safe_rust_wrapper(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    archive = tmp_path / "librusticol_capi.a"
+    archive.write_bytes(b"static archive")
+    link = {
+        "schema_version": 1,
+        "target": "aarch64-apple-darwin",
+        "system_libraries": ["System"],
+        "frameworks": [],
+    }
+    commands: list[list[str]] = []
+
+    def fake_run(command, **_kwargs):
+        commands.append(command)
+        return subprocess.CompletedProcess(
+            args=command,
+            returncode=0,
+            stdout="",
+            stderr="",
+        )
+
+    monkeypatch.setattr(sdk, "_host_target", lambda _root: link["target"])
+    monkeypatch.setattr(sdk, "_requested_target", lambda host: host)
+    monkeypatch.setattr(sdk, "_cargo_fetch", lambda *_args: None)
+    monkeypatch.setattr(sdk.subprocess, "run", fake_run)
+    monkeypatch.setattr(sdk, "_cargo_messages", lambda _stdout: ())
+    monkeypatch.setattr(sdk, "_static_library", lambda _messages: archive)
+    monkeypatch.setattr(sdk, "_native_tokens", lambda _stderr: ())
+    monkeypatch.setattr(sdk, "_typed_link_arguments", lambda _tokens, _target: link)
+    monkeypatch.setattr(sdk, "_scan_archive", lambda _archive: None)
+    monkeypatch.setattr(sdk, "_scan_archive_symbols", lambda _archive: None)
+    monkeypatch.setattr(
+        sdk, "_validate_archive_linkage", lambda *_args, **_kwargs: None
+    )
+    monkeypatch.setattr(sdk, "_package_version", lambda _root: "0.1.0")
+    stale = tmp_path / "wheel-data/_sdk/stale.txt"
+    stale.parent.mkdir(parents=True)
+    stale.write_text("stale\n", encoding="utf-8")
+
+    staging = sdk.build_sdk(ROOT, tmp_path / "target")
+
+    assert not stale.exists()
+    assert not (staging / "rust" / "rusticol.rs").exists()
+    assert (ROOT / sdk.RUST_SDK_SOURCE).is_file()
+    contract = backend.load_native_build_contract(ROOT)["sdk"]
+    assert commands == [
+        [
+            "cargo",
+            "rustc",
+            "--locked",
+            "--offline",
+            "--release",
+            "--package",
+            contract["package"],
+            "--target",
+            link["target"],
+            "--message-format=json-render-diagnostics",
+            "--",
+            "--print",
+            "native-static-libs",
+            *contract["rustc-codegen-arguments"],
+        ]
+    ]
+    metadata = json.loads((staging / "metadata.json").read_text(encoding="utf-8"))
+    assert metadata["rust_source"] == "rust/rusticol.rs"
+
+
+def test_python_extension_rebuilds_and_refreshes_embedded_sdk() -> None:
+    build_script = (
+        ROOT / "rust/crates/rusticol-python/build.rs"
+    ).read_text(encoding="utf-8")
+
+    assert "PYAMPLICOL_NATIVE_BUILD_INPUTS_SHA256" in build_script
+    assert "remove_dir_all(&sdk_output)" in build_script
+
+
+def test_sdk_build_restores_maturin_pruned_sdist_workspace_member(
+    tmp_path: Path,
+) -> None:
+    cargo = tmp_path / "Cargo.toml"
+    cargo.write_text(
+        """\
+[workspace]
+members = ["rust/crates/rusticol-core", "rust/crates/rusticol-python"]
+resolver = "2"
+
+[workspace.package]
+version = "0.1.0"
+""",
+        encoding="utf-8",
+    )
+    capi = tmp_path / sdk.RUST_SDK_WORKSPACE_MEMBER / "Cargo.toml"
+    capi.parent.mkdir(parents=True)
+    capi.write_text('[package]\nname = "rusticol-capi"\n', encoding="utf-8")
+
+    sdk._ensure_sdk_workspace_member(tmp_path)
+
+    with cargo.open("rb") as stream:
+        members = tomllib.load(stream)["workspace"]["members"]
+    assert members == [
+        "rust/crates/rusticol-core",
+        "rust/crates/rusticol-python",
+        "rust/crates/rusticol-capi",
+    ]
+    restored = cargo.read_bytes()
+    sdk._ensure_sdk_workspace_member(tmp_path)
+    assert cargo.read_bytes() == restored
+
+
+def test_dependency_gate_subprocess_ignores_inherited_build_injection(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CARGO", "/attacker/cargo")
+    monkeypatch.setenv("PYTHONPATH", "/attacker/pythonpath")
+    monkeypatch.setenv("RUSTFLAGS", "-Clink-arg=/attacker/library")
+    observed: dict[str, object] = {}
+
+    def fake_run(command, *, cwd, env, check):
+        observed.update(command=command, cwd=cwd, env=env, check=check)
+        return subprocess.CompletedProcess(command, 0)
+
+    monkeypatch.setattr(backend.subprocess, "run", fake_run)
+    backend._check_dependencies("candidate")
+    command = observed["command"]
+    environment = observed["env"]
+    assert isinstance(command, list) and command[1] == "-I"
+    assert command[-1] == "--candidate"
+    assert "--offline" not in command
+    assert isinstance(environment, dict)
+    assert not {"CARGO", "PYTHONPATH", "RUSTFLAGS"} & set(environment)
+
+
+def test_build_tool_path_retains_isolated_interpreter_bin(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    environment_bin = tmp_path / "build-env" / "bin"
+    environment_bin.mkdir(parents=True)
+    interpreter = environment_bin / "python"
+    interpreter.symlink_to(Path(sys.executable).resolve())
+    tool_bin = tmp_path / "rust" / "bin"
+    tool_bin.mkdir(parents=True)
+
+    monkeypatch.setattr(backend.sys, "executable", str(interpreter))
+    monkeypatch.setattr(
+        backend.shutil,
+        "which",
+        lambda executable, *, path: str(tool_bin / executable),
+    )
+
+    result = backend._build_tool_path("").split(os.pathsep)
+
+    assert str(environment_bin) in result
+
+
+def test_build_tool_path_retains_pip_isolated_maturin_bin(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    base_bin = tmp_path / "base-python" / "bin"
+    base_bin.mkdir(parents=True)
+    interpreter = base_bin / "python"
+    interpreter.touch()
+    isolated_bin = tmp_path / "pip-build-env" / "overlay" / "bin"
+    isolated_bin.mkdir(parents=True)
+    maturin_script = isolated_bin / "maturin"
+    maturin_script.touch()
+    rust_bin = tmp_path / "rust" / "bin"
+    rust_bin.mkdir(parents=True)
+
+    def locate(executable: str, *, path: str) -> str | None:
+        if executable in {"cargo", "rustc"}:
+            return str(rust_bin / executable)
+        assert path.startswith("/usr/bin" + os.pathsep)
+        return f"/usr/bin/{executable}"
+
+    monkeypatch.setattr(backend.sys, "executable", str(interpreter))
+    monkeypatch.setattr(
+        backend,
+        "_maturin_console_script",
+        lambda: maturin_script,
+    )
+    monkeypatch.setattr(backend.shutil, "which", locate)
+
+    result = backend._build_tool_path(
+        os.pathsep.join(("/opt/homebrew/bin", str(isolated_bin)))
+    ).split(os.pathsep)
+
+    assert str(base_bin) in result
+    assert str(isolated_bin) in result
+    assert str(rust_bin) in result
+    assert "/opt/homebrew/bin" not in result
+
+
+def test_build_tool_path_does_not_require_git_for_unpacked_sdist(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    tool_bin = tmp_path / "tools"
+    tool_bin.mkdir()
+
+    def locate(executable: str, *, path: str) -> str | None:
+        del path
+        if executable == "git":
+            return None
+        if executable in {"cargo", "rustc"}:
+            return str(tool_bin / executable)
+        return None
+
+    monkeypatch.setattr(backend.shutil, "which", locate)
+
+    result = backend._build_tool_path("").split(os.pathsep)
+
+    assert str(tool_bin) in result
+
+
+def test_macos_native_build_updates_select_apple_clang(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(backend.sys, "platform", "darwin")
+
+    assert backend._macos_native_build_updates() == {
+        "CC": "/usr/bin/clang",
+        "CXX": "/usr/bin/clang++",
+        "MACOSX_DEPLOYMENT_TARGET": "11.0",
+    }
+
+    monkeypatch.setattr(backend.sys, "platform", "linux")
+    assert backend._macos_native_build_updates() == {}
+
+
+def test_rust_remap_flags_uses_repository_toolchain_in_clean_environment(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    monkeypatch.setenv("RUSTUP_TOOLCHAIN", "nightly")
+    monkeypatch.setenv("RUSTFLAGS", "-Clink-arg=/attacker/library")
+    monkeypatch.setenv("RUSTC_WRAPPER", "/attacker/wrapper")
+    sysroot = tmp_path / "rustup" / "toolchains" / "1.97.1"
+    observed: dict[str, object] = {}
+
+    def fake_run(command, *, check, capture_output, text, env):
+        observed.update(
+            command=command,
+            check=check,
+            capture_output=capture_output,
+            text=text,
+            env=env,
+        )
+        return subprocess.CompletedProcess(
+            command,
+            0,
+            stdout=f"{sysroot}\n",
+            stderr="",
+        )
+
+    monkeypatch.setattr(backend.subprocess, "run", fake_run)
+
+    flags = backend._rust_remap_flags(
+        tmp_path / "overlay",
+        tmp_path / "build" / "cargo-target",
+    )
+
+    environment = observed["env"]
+    assert isinstance(environment, dict)
+    assert observed["command"] == ["rustc", "--print", "sysroot"]
+    assert environment["RUSTUP_TOOLCHAIN"] == "1.97.1"
+    assert "RUSTFLAGS" not in environment
+    assert "RUSTC_WRAPPER" not in environment
+    assert f"{sysroot.resolve()}=/rust/sysroot" in flags
+    assert (
+        f"{(backend.ROOT / 'dependencies' / 'checkouts').resolve()}="
+        "/pyamplicol/dependencies"
+    ) in flags
+
+
+def test_build_tool_path_does_not_expose_base_python_package_manager_tools(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    environment_bin = tmp_path / "build-env" / "bin"
+    environment_bin.mkdir(parents=True)
+    interpreter = environment_bin / "python"
+    interpreter.touch()
+    rust_bin = tmp_path / "rustup" / "bin"
+    rust_bin.mkdir(parents=True)
+
+    def locate(executable: str, *, path: str) -> str | None:
+        if executable in {"cargo", "rustc"}:
+            return str(rust_bin / executable)
+        assert path.startswith("/usr/bin" + os.pathsep)
+        return f"/usr/bin/{executable}"
+
+    monkeypatch.setattr(backend.sys, "executable", str(interpreter))
+    monkeypatch.setattr(backend.shutil, "which", locate)
+
+    result = backend._build_tool_path(
+        "/opt/local/bin:/opt/homebrew/bin:/usr/local/bin"
+    ).split(os.pathsep)
+
+    assert str(environment_bin) in result
+    assert str(rust_bin) in result
+    assert "/usr/bin" in result
+    assert "/opt/local/bin" not in result
+    assert "/opt/homebrew/bin" not in result
+    assert "/usr/local/bin" not in result
+
+
+def test_pep517_backend_rejects_recursive_delegation(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "release")
+    overlay = tmp_path / "overlay"
+    overlay.mkdir()
+
+    @contextlib.contextmanager
+    def fake_overlay(
+        _mode: str,
+        *,
+        project_release_prepared_models: bool = False,
+    ):
+        assert project_release_prepared_models is True
+        yield overlay, tmp_path / "target"
+
+    monkeypatch.setattr(backend, "_overlay", fake_overlay)
+    monkeypatch.setattr(backend, "_check_dependencies", lambda _mode: None)
+    monkeypatch.setattr(
+        backend,
+        "canonical_package_version",
+        lambda _path: "0.1.0",
+    )
+    monkeypatch.setattr(backend, "_stage_release_build_info", lambda *_args: None)
+    monkeypatch.setattr(
+        backend,
+        "stage_packaged_prepared_models",
+        lambda _path, _mode: None,
+    )
+    monkeypatch.setattr(
+        backend.maturin,
+        "build_sdist",
+        lambda *_args: backend.get_requires_for_build_sdist(),
+    )
+    with pytest.raises(RuntimeError, match="recursive PEP 517"):
+        backend.build_sdist(str(tmp_path / "dist"))
+
+
+def test_native_link_arguments_are_typed_and_allowlisted() -> None:
+    macos = sdk._typed_link_arguments(
+        [
+            "-lgcc_s",
+            "-lSystem",
+            "-lc",
+            "-framework",
+            "Security",
+            "-lSystem",
+            "-framework",
+            "Security",
+        ],
+        "aarch64-apple-darwin",
+    )
+    assert "gcc_s" in macos["system_libraries"]
+    assert macos["system_libraries"] == ["gcc_s", "System", "c"]
+    assert macos["frameworks"] == ["Security"]
+
+    linux = sdk._typed_link_arguments(
+        [
+            "-lgcc_s",
+            "-lutil",
+            "-lrt",
+            "-lpthread",
+            "-lm",
+            "-ldl",
+            "-lc",
+            "-lpthread",
+            "-ldl",
+            "-lc",
+        ],
+        "x86_64-unknown-linux-gnu",
+    )
+    assert linux["frameworks"] == []
+    assert linux["system_libraries"] == [
+        "gcc_s",
+        "util",
+        "rt",
+        "pthread",
+        "m",
+        "dl",
+        "c",
+    ]
+
+
+def test_static_archive_byte_scan_ignores_random_python_text(tmp_path: Path) -> None:
+    archive = tmp_path / "librusticol_capi.a"
+    archive.write_bytes(b"archive pYO3[/ rusticol_runtime_load native-static-libs")
+    sdk._scan_archive(archive)
+
+
+def test_static_archive_byte_scan_rejects_nonrelocatable_paths(
+    tmp_path: Path,
+) -> None:
+    archive = tmp_path / "librusticol_capi.a"
+    archive.write_bytes(b"archive /opt/local/lib/libexample.a")
+    with pytest.raises(RuntimeError, match="non-relocatable path marker"):
+        sdk._scan_archive(archive)
+
+
+@pytest.mark.parametrize(
+    "symbol",
+    ["_PyErr_SetString", "PyLong_FromLong", "_Py_Dealloc"],
+)
+def test_static_archive_symbol_scan_rejects_python_symbols(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    symbol: str,
+) -> None:
+    archive = tmp_path / "librusticol_capi.a"
+    archive.write_bytes(b"archive")
+    monkeypatch.setattr(sdk.shutil, "which", lambda _name: "/usr/bin/nm")
+    monkeypatch.setattr(
+        sdk.subprocess,
+        "run",
+        lambda *_args, **_kwargs: subprocess.CompletedProcess(
+            ["nm"], 0, stdout=f"                 U {symbol}\n", stderr=""
+        ),
+    )
+
+    with pytest.raises(RuntimeError, match="undefined Python"):
+        sdk._scan_archive_symbols(archive)
+
+
+def test_static_archive_symbol_scan_accepts_non_python_symbols(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    archive = tmp_path / "librusticol_capi.a"
+    archive.write_bytes(b"archive")
+    monkeypatch.setattr(sdk.shutil, "which", lambda _name: "/usr/bin/nm")
+    monkeypatch.setattr(
+        sdk.subprocess,
+        "run",
+        lambda *_args, **_kwargs: subprocess.CompletedProcess(
+            ["nm"], 0, stdout="                 U _malloc\n", stderr=""
+        ),
+    )
+
+    assert sdk._scan_archive_symbols(archive)
+
+
+def test_static_archive_symbol_scan_defers_incompatible_llvm_reader(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    archive = tmp_path / "librusticol_capi.a"
+    archive.write_bytes(b"archive")
+    monkeypatch.delenv("LLVM_NM", raising=False)
+    monkeypatch.setattr(sdk.shutil, "which", lambda _name: "/usr/bin/nm")
+    monkeypatch.setattr(
+        sdk.subprocess,
+        "run",
+        lambda *_args, **_kwargs: subprocess.CompletedProcess(
+            ["nm"],
+            1,
+            stdout="",
+            stderr=(
+                "Unknown attribute kind (91) "
+                "(Producer: 'LLVM20.1.7' Reader: 'LLVM APPLE_1_1600')"
+            ),
+        ),
+    )
+
+    assert not sdk._scan_archive_symbols(archive)
+
+
+@pytest.mark.skipif(os.name == "nt", reason="native SDK targets macOS and Linux")
+def test_static_archive_link_probe_rejects_missing_public_export(
+    tmp_path: Path,
+) -> None:
+    target = (
+        "aarch64-apple-darwin"
+        if sys.platform == "darwin"
+        else "x86_64-unknown-linux-gnu"
+    )
+    try:
+        compiler = sdk._native_c_compiler(target)
+    except RuntimeError as error:
+        pytest.skip(str(error))
+    archiver = shutil.which("ar")
+    if archiver is None:
+        pytest.skip("ar is unavailable")
+
+    header = tmp_path / "rusticol.h"
+    header.write_text(
+        """\
+#include <stdint.h>
+#define RUSTICOL_ABI_VERSION 1u
+uint32_t rusticol_abi_version(void);
+int rusticol_required_export(void);
+""",
+        encoding="utf-8",
+    )
+    implementation = tmp_path / "partial.c"
+    implementation.write_text(
+        "#include <stdint.h>\nuint32_t rusticol_abi_version(void) { return 1u; }\n",
+        encoding="utf-8",
+    )
+    object_file = tmp_path / "partial.o"
+    archive = tmp_path / "librusticol_capi.a"
+    subprocess.run(
+        [*compiler, "-c", str(implementation), "-o", str(object_file)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    subprocess.run(
+        [archiver, "rcs", str(archive), str(object_file)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    with pytest.raises(RuntimeError, match="complete C ABI link probe"):
+        sdk._validate_archive_linkage(
+            archive,
+            header=header,
+            link={"target": target, "system_libraries": [], "frameworks": []},
+            target=target,
+        )
+
+
+@pytest.mark.parametrize(
+    "token",
+    [
+        "-L/opt/local/lib",
+        "-Wl,-rpath,/opt/local/lib",
+        "/usr/local/lib/libfoo.a",
+        "-lnot_allowlisted",
+    ],
+)
+def test_native_link_arguments_reject_nonportable_tokens(token: str) -> None:
+    with pytest.raises(RuntimeError):
+        sdk._typed_link_arguments([token], "aarch64-apple-darwin")
diff --git a/pyamplicol/tests/unit/test_builtin_lowering_quarantine.py b/pyamplicol/tests/unit/test_builtin_lowering_quarantine.py
new file mode 100644
index 0000000000..a4edc9dabf
--- /dev/null
+++ b/pyamplicol/tests/unit/test_builtin_lowering_quarantine.py
@@ -0,0 +1,155 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+REPOSITORY_ROOT = Path(__file__).resolve().parents[2]
+SOURCE_ROOT = REPOSITORY_ROOT / "src"
+
+
+def _assert_isolated_import_does_not_load_builtin(statement: str) -> None:
+    script = "\n".join(
+        (
+            "import sys",
+            f"sys.path.insert(0, {str(SOURCE_ROOT)!r})",
+            statement,
+            "loaded = sorted(name for name in sys.modules ",
+            "    if name == 'pyamplicol.models.builtin' ",
+            "    or name.startswith('pyamplicol.models.builtin.'))",
+            "assert loaded == [], loaded",
+        )
+    )
+    environment = os.environ.copy()
+    environment.pop("PYTHONPATH", None)
+    completed = subprocess.run(
+        [sys.executable, "-I", "-c", script],
+        cwd=REPOSITORY_ROOT,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert completed.returncode == 0, completed.stderr
+
+
+@pytest.mark.parametrize(
+    "statement",
+    (
+        "import pyamplicol.generation",
+        "import pyamplicol.models.base",
+        "import pyamplicol.models.expressions",
+    ),
+)
+def test_generic_lowering_imports_do_not_load_builtin_physics(statement: str) -> None:
+    _assert_isolated_import_does_not_load_builtin(statement)
+
+
+def test_builtin_lowering_diagnostics_are_not_generic_model_contracts() -> None:
+    from pyamplicol.models import base, expressions
+    from pyamplicol.models.builtin import lowering_types
+
+    assert hasattr(lowering_types, "SymbolicLoweringReport")
+    assert not hasattr(base.Model, "build_tensor_library")
+    assert not hasattr(base.Model, "vertex_lowering_coverage")
+    assert not hasattr(base, "VertexLoweringCoverageEntry")
+    assert not hasattr(base, "VertexLoweringCoverageReport")
+    assert not hasattr(expressions, "_flat_index")
+    assert not hasattr(expressions, "_index_chirality")
+    assert not hasattr(expressions, "_expr_vector_slash_terms")
+
+
+def test_builtin_auxiliary_tensor_probe_executes() -> None:
+    from pyamplicol.models import BuiltinSMModel
+    from pyamplicol.models.builtin.lowering_tensor import (
+        _build_auxiliary_tensor_probe,
+    )
+
+    probe = _build_auxiliary_tensor_probe(BuiltinSMModel())
+
+    assert probe.engine == "spenso"
+    assert probe.output_rank == 2
+    assert probe.output_size == 16
+    assert probe.nonzero_entries == 4
+    assert probe.max_abs_entry == pytest.approx(1.5)
+    assert probe.weighted_checksum == pytest.approx((0.0, 48.0))
+
+
+@pytest.mark.parametrize(
+    ("vertex", "left_kind", "right_kind", "output_kind", "chirality"),
+    (
+        ("two_gluon_to_tensor", "vector", "vector", "tensor", 0),
+        ("tensor_gluon_to_gluon", "tensor", "vector", "vector", 0),
+        ("gluon_tensor_to_gluon", "vector", "tensor", "vector", 0),
+        ("quark_vector_weyl_plus", "weyl", "vector", "weyl", 1),
+        ("quark_vector_weyl_minus", "weyl", "vector", "weyl", -1),
+    ),
+)
+def test_builtin_tensor_interface_order_matches_numeric_vertices(
+    vertex: str,
+    left_kind: str,
+    right_kind: str,
+    output_kind: str,
+    chirality: int,
+) -> None:
+    from symbolica import Expression
+    from symbolica.community.spenso import (
+        Representation,
+        Tensor,
+        TensorName,
+        TensorNetwork,
+        as_tensor,
+    )
+
+    from pyamplicol.models import BuiltinSMModel
+    from pyamplicol.models.builtin import expressions
+    from pyamplicol.models.builtin.symbols import symbols
+
+    representations = {
+        "vector": Representation.mink(4),
+        "tensor": Representation(symbols.antisymmetric_lorentz_pair_name, 6),
+        "weyl": Representation(symbols.weyl_spinor_name, 2),
+    }
+    dimensions = {"vector": 4, "tensor": 6, "weyl": 2}
+    left = tuple(complex(index + 1, 0.25) for index in range(dimensions[left_kind]))
+    right = tuple(
+        complex(2 * index - 1, -0.5) for index in range(dimensions[right_kind])
+    )
+    library = BuiltinSMModel().build_tensor_library()
+    left_name = TensorName("pyamplicol::tensor_layout_probe_left")
+    right_name = TensorName("pyamplicol::tensor_layout_probe_right")
+    left_rep, right_rep = representations[left_kind], representations[right_kind]
+    output_rep = representations[output_kind]
+    library.register(Tensor.dense(left_name(left_rep), left))
+    library.register(Tensor.dense(right_name(right_rep), right))
+    expression = (
+        TensorName(symbols.qualified_name(vertex))(
+            left_rep("left"), right_rep("right"), output_rep("output")
+        ).to_expression()
+        * left_name(left_rep("left")).to_expression()
+        * right_name(right_rep("right")).to_expression()
+    )
+    network = TensorNetwork(as_tensor(expression), library)
+    network.execute(library=library)
+    result = network.result_tensor(library)
+    actual = tuple(
+        complex(value.evaluate({}) if isinstance(value, Expression) else value)
+        for value in (result[index] for index in range(len(result)))
+    )
+    if chirality:
+        expected = expressions._expr_fermion_vector_weyl(
+            left, right, chirality, antifermion=False, coupling=None
+        )
+    else:
+        numeric_vertex = {
+            "two_gluon_to_tensor": expressions._expr_two_vector_to_tensor,
+            "tensor_gluon_to_gluon": expressions._expr_tensor_vector_to_vector,
+            "gluon_tensor_to_gluon": expressions._expr_vector_tensor_to_vector,
+        }[vertex]
+        expected = numeric_vertex(left, right)
+    assert actual == pytest.approx(expected)
diff --git a/pyamplicol/tests/unit/test_capture_reference_fixture_v2.py b/pyamplicol/tests/unit/test_capture_reference_fixture_v2.py
new file mode 100644
index 0000000000..83ef728f85
--- /dev/null
+++ b/pyamplicol/tests/unit/test_capture_reference_fixture_v2.py
@@ -0,0 +1,814 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import subprocess
+import tomllib
+from decimal import Decimal
+from fractions import Fraction
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+from jsonschema import Draft202012Validator
+
+from tools.developer import reference_capture as capture
+from tools.developer.legacy_oracle import processes as legacy_processes
+from tools.developer.reference_capture import artifacts, evidence, pipeline, provenance
+from tools.developer.reference_fixture import model as reference_model
+from tools.developer.reference_fixture import numerics as reference_numerics
+
+ROOT = Path(__file__).resolve().parents[2]
+with (ROOT / "dependencies" / "release-lock.toml").open("rb") as stream:
+    RELEASE_VERSION = str(tomllib.load(stream)["project"]["version"])
+
+_REFERENCE_SCHEMA = json.loads(
+    (ROOT / "schemas/reference-physics-v2.schema.json").read_text(encoding="utf-8")
+)
+_POINT_VALIDATOR = Draft202012Validator(
+    {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "$defs": _REFERENCE_SCHEMA["$defs"],
+        "$ref": "#/$defs/point",
+    }
+)
+
+
+def _run_git(repository: Path, *arguments: str) -> None:
+    subprocess.run(
+        ["git", *arguments],
+        cwd=repository,
+        check=True,
+        capture_output=True,
+    )
+
+
+_PROCESS_SPECS = {
+    process.id: process
+    for artifact in artifacts.artifact_capture_specs(Path("unused"))
+    for process in artifact.processes
+}
+_PROCESS_MASSES = {
+    process_id: tuple(
+        Decimal(value) for value in process.expected_external_masses
+    )
+    for process_id, process in _PROCESS_SPECS.items()
+}
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    (
+        (Decimal("1.2300"), "1.23"),
+        (Decimal("-0.000"), "0"),
+        (1000, "1000"),
+        (0.1, "0.10000000000000001"),
+        ("1e-12", "0.000000000001"),
+    ),
+)
+def test_canonical_decimal_is_fixed_point_and_binary64_honest(
+    value: Decimal | float | int | str,
+    expected: str,
+) -> None:
+    assert capture.canonical_decimal(value) == expected
+
+
+def test_compiled_model_contract_hash_excludes_only_timing_diagnostics() -> None:
+    compiled = {
+        "schema_version": 6,
+        "kind": "pyamplicol-compiled-model",
+        "source": {"digest": "abc"},
+        "ir": {"particles": [{"pdg_code": 1}]},
+        "parameter_defaults": {"ZERO": [Decimal("0.0"), Decimal("0.0")]},
+        "conversion_seconds": Decimal("1.25"),
+        "phase_timings": {"lower": Decimal("0.5")},
+    }
+    baseline = artifacts._compiled_model_contract_sha256(compiled)
+
+    compiled["conversion_seconds"] = Decimal("99.0")
+    compiled["phase_timings"] = {"lower": Decimal("42.0")}
+    assert artifacts._compiled_model_contract_sha256(compiled) == baseline
+
+    compiled["ir"] = {"particles": [{"pdg_code": 2}]}
+    assert artifacts._compiled_model_contract_sha256(compiled) != baseline
+
+
+def test_canonical_decimal_rejects_non_finite_values() -> None:
+    with pytest.raises(capture.CaptureError, match="non-finite"):
+        capture.canonical_decimal(float("inf"))
+
+
+@pytest.mark.parametrize(
+    ("process_id", "expected_count"),
+    (
+        ("sm_ddbar_z", 1),
+        ("sm_ddbar_zg", 4),
+        ("sm_ddbar_zgg", 4),
+        ("sm_udbar_wplus", 1),
+        ("sm_ddbar_ee", 4),
+        ("sm_ddbar_uubar", 4),
+        ("sm_ddbar_ddbar", 4),
+        ("sm_gg_gg", 4),
+        ("sm_gg_ttbar", 4),
+        ("scalars_2to2", 4),
+        ("scalar_gravity_2to2", 4),
+    ),
+)
+def test_reference_points_are_deterministic_canonical_and_valid(
+    process_id: str,
+    expected_count: int,
+) -> None:
+    process = _PROCESS_SPECS[process_id]
+    masses = _PROCESS_MASSES[process_id]
+    first = capture.build_reference_points(process, masses)
+    second = capture.build_reference_points(process, masses)
+
+    assert first == second
+    assert len(first) == expected_count
+    for point in first:
+        capture.validate_point_kinematics(point, masses)
+        payload = point.as_payload()
+        _POINT_VALIDATOR.validate(payload)
+        numeric_strings = [
+            str(component) for momentum in payload["momenta"] for component in momentum
+        ]
+        assert all("e" not in value.lower() for value in numeric_strings)
+        assert capture.point_input_sha256(payload) == capture.point_input_sha256(
+            point.as_payload()
+        )
+
+    if process.point_policy == "exact-2to1":
+        assert [point.point_class for point in first] == ["canonical"]
+    else:
+        assert [point.point_class for point in first] == [
+            "generic",
+            "generic",
+            "generic",
+            "stress",
+        ]
+        assert all(point.arithmetic_precision_bits == 53 for point in first[:3])
+        assert all(point.round_trip_decimal_digits == 17 for point in first[:3])
+        assert all(point.certified_decimal_digits == 12 for point in first[:3])
+        assert all(point.stress_metric is None for point in first[:3])
+        assert first[-1].arithmetic_precision_bits >= 256
+        assert first[-1].round_trip_decimal_digits >= 80
+        assert first[-1].certified_decimal_digits >= 80
+        assert first[-1].stress_metric is not None
+        assert first[-1].stress_metric.value <= Decimal("0.001")
+
+    for point in first:
+        values = (
+            point.sqrt_s,
+            *point.masses,
+            *(component for momentum in point.momenta for component in momentum),
+        )
+        assert all(
+            len(value.as_tuple().digits) <= point.round_trip_decimal_digits
+            for value in values
+        )
+
+
+def test_builtin_capture_ladder_declares_exact_fortran_rows() -> None:
+    builtin = {
+        process.expression: process
+        for process in _PROCESS_SPECS.values()
+        if process.model_id == "model:builtin-sm"
+    }
+
+    expected_expressions = set(legacy_processes.EXPECTED_FORTRAN_PROCESS_ROWS)
+    assert set(builtin) == expected_expressions
+    assert set(legacy_processes.EXPECTED_FORTRAN_PDG_MATCH_COUNTS) == (
+        expected_expressions
+    )
+    assert set(legacy_processes.EXPECTED_FORTRAN_COLOR_ORDER_COUNTS) == (
+        expected_expressions
+    )
+    for expression, process in builtin.items():
+        row = legacy_processes.expected_process_entry(expression)
+        assert sorted(row.process_pdgs) == sorted(
+            legacy_processes.process_pdgs(expression)
+        )
+        assert (not process.point_seeds) == (process.point_policy == "exact-2to1")
+        assert legacy_processes.expected_process_match_count(expression) >= 1
+        assert legacy_processes.expected_color_order_count(expression) >= 1
+
+
+def test_capture_artifacts_are_ordered_by_final_state_multiplicity() -> None:
+    specs = artifacts.artifact_capture_specs(Path("unused"))
+    multiplicities = [
+        len(process.expression.partition(">")[2].split())
+        for artifact in specs
+        for process in artifact.processes
+    ]
+
+    assert multiplicities == sorted(multiplicities)
+    assert len({artifact.id for artifact in specs}) == len(specs)
+    assert len({artifact.directory_name for artifact in specs}) == len(specs)
+
+
+def test_capture_masses_are_independent_and_checked_against_artifacts() -> None:
+    process = _PROCESS_SPECS["sm_gg_ttbar"]
+    expected = _PROCESS_MASSES[process.id]
+
+    assert artifacts._validated_capture_masses(
+        process,
+        {"external_masses": ["0", "0", "173", "173"]},
+    ) == expected
+    with pytest.raises(capture.CaptureError, match="independent capture contract"):
+        artifacts._validated_capture_masses(
+            process,
+            {"external_masses": ["0", "0", "172.5", "172.5"]},
+        )
+
+
+def test_massive_two_body_stress_point_probes_threshold() -> None:
+    process = _PROCESS_SPECS["sm_gg_ttbar"]
+    point = capture.build_reference_points(
+        process, _PROCESS_MASSES[process.id]
+    )[-1]
+
+    assert point.id.endswith(":stress-near-threshold")
+    assert point.sqrt_s == Decimal("346.000346")
+    assert point.stress_metric == capture.StressMetric(
+        "relative-excess-energy",
+        Decimal("0.000001"),
+    )
+    assert point.momenta[2][1:] != (Decimal(0), Decimal(0), Decimal(0))
+    parsed_point = reference_model.ReferencePoint(
+        id=point.id,
+        process_id=point.process_id,
+        point_class=point.point_class,
+        algorithm=reference_model.PointAlgorithm(
+            point.algorithm_name,
+            point.algorithm_version,
+            point.rng,
+            point.seed,
+        ),
+        sqrt_s=point.sqrt_s,
+        momenta=point.momenta,
+        masses=point.masses,
+        arithmetic_precision_bits=point.arithmetic_precision_bits,
+        round_trip_decimal_digits=point.round_trip_decimal_digits,
+        certified_decimal_digits=point.certified_decimal_digits,
+        stress_metric=reference_model.StressMetric(
+            point.stress_metric.kind,
+            point.stress_metric.value,
+        ),
+    )
+    parsed_process = reference_model.Process(
+        id=process.id,
+        expression=process.expression,
+        external_pdgs=(21, 21, 6, -6),
+        external_labels=(1, 2, 3, 4),
+        external_leg_ids=("g-1", "g-2", "t", "tbar"),
+        external_spins=(3, 3, 2, 2),
+        external_colors=(8, 8, 3, -3),
+        external_masses=point.masses,
+        external_helicity_domains=((-1, 1),) * 4,
+        initial_state_count=2,
+        alias_of=None,
+        final_state_permutation=None,
+    )
+    assert reference_numerics._stress_metric_value(
+        parsed_point,
+        parsed_process,
+    ) == Fraction(1, 1_000_000)
+
+
+def test_three_body_stress_point_is_deliberately_soft() -> None:
+    process = _PROCESS_SPECS["sm_ddbar_zgg"]
+    point = capture.build_reference_points(
+        process, _PROCESS_MASSES[process.id]
+    )[-1]
+    incoming = point.momenta[0]
+    soft = point.momenta[-1]
+    incoming_dot_soft = incoming[0] * soft[0] - sum(
+        (left * right for left, right in zip(incoming[1:], soft[1:], strict=True)),
+        Decimal(0),
+    )
+
+    assert soft[0] == Decimal("1")
+    assert soft[1] != 0
+    assert soft[3] < soft[0]
+    assert incoming_dot_soft > 0
+    assert point.stress_metric == capture.StressMetric(
+        "minimum-final-transverse-momentum-squared-fraction",
+        Decimal("0.00000004"),
+    )
+
+
+def test_three_body_generic_points_avoid_exact_collinear_singularities() -> None:
+    process = _PROCESS_SPECS["sm_ddbar_zgg"]
+    points = capture.build_reference_points(
+        process, _PROCESS_MASSES[process.id]
+    )[:3]
+
+    def dot(left, right):
+        return left[0] * right[0] - sum(
+            (
+                left_component * right_component
+                for left_component, right_component in zip(
+                    left[1:], right[1:], strict=True
+                )
+            ),
+            Decimal(0),
+        )
+
+    for point in points:
+        incoming = point.momenta[:2]
+        gluons = point.momenta[-2:]
+        assert all(dot(initial, gluon) > 0 for initial in incoming for gluon in gluons)
+        assert dot(*gluons) > 0
+
+
+def test_stable_leg_ids_disambiguate_only_identical_role_particles() -> None:
+    particles = (
+        {"state": "incoming", "name": "d"},
+        {"state": "incoming", "name": "d~"},
+        {"state": "outgoing", "name": "z"},
+        {"state": "outgoing", "name": "g"},
+        {"state": "outgoing", "name": "g"},
+    )
+    assert capture.stable_external_leg_ids(particles) == (
+        "leg:incoming-d",
+        "leg:incoming-dbar",
+        "leg:outgoing-z",
+        "leg:outgoing-g-1",
+        "leg:outgoing-g-2",
+    )
+    assert capture.stable_external_leg_ids(
+        (
+            {"role": "initial", "particle": "scalar_0"},
+            {"role": "initial", "particle": "scalar_0"},
+            {"role": "final", "particle": "scalar_0"},
+            {"role": "final", "particle": "scalar_0"},
+        )
+    ) == (
+        "leg:incoming-scalar_0-1",
+        "leg:incoming-scalar_0-2",
+        "leg:outgoing-scalar_0-1",
+        "leg:outgoing-scalar_0-2",
+    )
+
+
+def test_external_model_metadata_is_derived_from_compiled_ir() -> None:
+    compiled = {
+        "ir": {
+            "particles": [
+                {
+                    "pdg_code": 1,
+                    "propagating": True,
+                    "spin": 2,
+                    "color": 3,
+                    "mass": "ZERO",
+                },
+                {
+                    "pdg_code": -1,
+                    "propagating": True,
+                    "spin": 2,
+                    "color": -3,
+                    "mass": "ZERO",
+                },
+                {
+                    "pdg_code": 23,
+                    "propagating": True,
+                    "spin": 3,
+                    "color": 1,
+                    "mass": "MZ",
+                },
+            ]
+        },
+        "parameter_defaults": {"MZ": ["91.188", "0"]},
+    }
+
+    spins, colors, masses = artifacts._external_model_metadata(
+        "process", (1, -1, 23), compiled
+    )
+
+    assert spins == (2, 2, 3)
+    assert colors == (3, -3, 1)
+    assert masses == (Decimal(0), Decimal(0), Decimal("91.188"))
+    assert tuple(
+        artifacts._physical_helicity_domain(spin, mass)
+        for spin, mass in zip(spins, masses, strict=True)
+    ) == ((-1, 1), (-1, 1), (-1, 0, 1))
+
+
+def test_clean_tree_rejects_untracked_but_ignores_ignored_files(tmp_path: Path) -> None:
+    repository = tmp_path / "repository"
+    repository.mkdir()
+    _run_git(repository, "init")
+    _run_git(repository, "config", "user.email", "fixture@example.invalid")
+    _run_git(repository, "config", "user.name", "Fixture Test")
+    tracked = repository / "tracked.txt"
+    (repository / ".gitignore").write_text("*.ignored\n", encoding="ascii")
+    tracked.write_text("first\n", encoding="ascii")
+    _run_git(repository, "add", ".gitignore", "tracked.txt")
+    _run_git(repository, "commit", "-m", "initial")
+
+    revision = capture.require_clean_tracked_tree(repository)
+    first_hash = capture.tracked_source_tree_sha256(repository, revision)
+    untracked = repository / "untracked.txt"
+    untracked.write_text("not ignored\n", encoding="ascii")
+
+    with pytest.raises(capture.CaptureError, match="clean source tree"):
+        capture.require_clean_tracked_tree(repository)
+    untracked.rename(repository / "untracked.ignored")
+    assert capture.require_clean_tracked_tree(repository) == revision
+    assert capture.tracked_source_tree_sha256(repository, revision) == first_hash
+
+    tracked.write_text("changed\n", encoding="ascii")
+    with pytest.raises(capture.CaptureError, match="clean source tree"):
+        capture.require_clean_tracked_tree(repository)
+    _run_git(repository, "add", "tracked.txt")
+    _run_git(repository, "commit", "-m", "change")
+    second_revision = capture.require_clean_tracked_tree(repository)
+    assert second_revision != revision
+    assert capture.tracked_source_tree_sha256(repository, second_revision) != first_hash
+
+
+def test_runtime_snapshot_requires_exact_clean_candidate(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    revision = "1" * 40
+    fingerprint = "2" * 12
+    version = f"{RELEASE_VERSION}.dev0+candidate.{fingerprint}"
+    site = tmp_path / "site-packages"
+    package = site / "pyamplicol"
+    package.mkdir(parents=True)
+    module_path = package / "__init__.py"
+    module_path.write_text("# installed candidate\n", encoding="ascii")
+    build_info = package / "_build_info.json"
+    build_info.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "candidate_fingerprint": fingerprint,
+                "source_revision": revision,
+                "version": version,
+            }
+        ),
+        encoding="ascii",
+    )
+    dist_info = site / f"pyamplicol-{version}.dist-info"
+    dist_info.mkdir()
+    metadata_path = dist_info / "METADATA"
+    metadata_path.write_text(
+        f"Name: pyamplicol\nVersion: {version}\n", encoding="ascii"
+    )
+
+    distribution = SimpleNamespace(
+        files=(
+            Path("pyamplicol/__init__.py"),
+            Path("pyamplicol/_build_info.json"),
+            Path(f"pyamplicol-{version}.dist-info/METADATA"),
+        ),
+        version=version,
+        locate_file=lambda path: site / str(path),
+    )
+
+    installed = SimpleNamespace(__file__=str(module_path), __version__=version)
+    monkeypatch.setattr(
+        provenance.importlib,
+        "import_module",
+        lambda name: installed if name == "pyamplicol" else None,
+    )
+    monkeypatch.setattr(provenance.metadata, "distribution", lambda name: distribution)
+    source = capture.SourceSnapshot(
+        "https://example.invalid/pyamplicol.git", revision, "3" * 64
+    )
+
+    snapshot = provenance.collect_runtime_snapshot(source)
+
+    assert snapshot.version == version
+    assert snapshot.candidate_fingerprint == fingerprint
+    assert snapshot.source_revision == revision
+    assert len(snapshot.distribution_sha256) == 64
+    assert len(snapshot.build_info_sha256) == 64
+
+
+def test_runtime_snapshot_rejects_candidate_from_another_revision(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fingerprint = "2" * 12
+    version = f"{RELEASE_VERSION}.dev0+candidate.{fingerprint}"
+    package = tmp_path / "site-packages" / "pyamplicol"
+    package.mkdir(parents=True)
+    module_path = package / "__init__.py"
+    module_path.write_text("# candidate\n", encoding="ascii")
+    (package / "_build_info.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "candidate_fingerprint": fingerprint,
+                "source_revision": "4" * 40,
+                "version": version,
+            }
+        ),
+        encoding="ascii",
+    )
+    installed = SimpleNamespace(__file__=str(module_path), __version__=version)
+    monkeypatch.setattr(provenance.importlib, "import_module", lambda name: installed)
+    monkeypatch.setattr(
+        provenance.metadata,
+        "distribution",
+        lambda name: SimpleNamespace(version=version, files=()),
+    )
+
+    with pytest.raises(capture.CaptureError, match="not built from the clean"):
+        provenance.collect_runtime_snapshot(
+            capture.SourceSnapshot(
+                "https://example.invalid/pyamplicol.git", "1" * 40, "3" * 64
+            )
+        )
+
+
+def _candidate_runtime_snapshot() -> capture.RuntimeSnapshot:
+    return capture.RuntimeSnapshot(
+        f"{RELEASE_VERSION}.dev0+candidate." + "2" * 12,
+        "2" * 12,
+        "1" * 40,
+        "3" * 64,
+        "4" * 64,
+    )
+
+
+def test_dependency_snapshot_uses_compact_source_descriptors(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    with provenance.CONTRIBUTOR_LOCK.open("rb") as stream:
+        contributor = tomllib.load(stream)
+    symbolica_descriptor = {
+        "url": contributor["symbolica"]["source_url"],
+        "revision": contributor["symbolica"]["candidate_revision"],
+    }
+    symjit_descriptor = {
+        "url": contributor["symjit"]["repository"],
+        "revision": contributor["symjit"]["revision"],
+    }
+    state_path = tmp_path / "install-state.json"
+    state_path.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "sources": {
+                    "symbolica": symbolica_descriptor,
+                    "symjit": symjit_descriptor,
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(provenance, "INSTALL_STATE", state_path)
+    snapshot = provenance.collect_dependency_snapshot(_candidate_runtime_snapshot())
+    payloads = {str(payload["id"]): payload for payload in snapshot.payloads}
+
+    assert payloads["dependency:symbolica"] == {
+        "id": "dependency:symbolica",
+        "name": "Symbolica",
+        "version": contributor["symbolica"]["candidate_version"],
+        "revision": symbolica_descriptor["revision"],
+        "content_sha256": provenance.canonical_sha256(symbolica_descriptor),
+        "serialization_abi": "symbolica-bincode2-v1",
+        "license": "Symbolica proprietary",
+    }
+    assert payloads["dependency:symjit"] == {
+        "id": "dependency:symjit",
+        "name": "Symjit",
+        "version": contributor["symjit"]["candidate_version"],
+        "revision": symjit_descriptor["revision"],
+        "content_sha256": provenance.canonical_sha256(symjit_descriptor),
+        "serialization_abi": "symjit-application-storage-v3",
+        "license": "MIT",
+    }
+    assert "patch_sha256" not in payloads["dependency:symjit"]
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "message"),
+    (
+        ("schema_version", 2, "schema versions must be 1"),
+        ("publishable", True, "non-publishable install state"),
+    ),
+)
+def test_dependency_snapshot_rejects_invalid_compact_install_state(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    field: str,
+    value: object,
+    message: str,
+) -> None:
+    state = json.loads(provenance.INSTALL_STATE.read_text(encoding="utf-8"))
+    state[field] = value
+    state_path = tmp_path / "install-state.json"
+    state_path.write_text(json.dumps(state), encoding="utf-8")
+    monkeypatch.setattr(provenance, "INSTALL_STATE", state_path)
+
+    with pytest.raises(capture.CaptureError, match=message):
+        provenance.collect_dependency_snapshot(_candidate_runtime_snapshot())
+
+
+@pytest.mark.parametrize("dependency", ("symbolica", "symjit"))
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (("url", "https://example.invalid/dependency.git"), ("revision", "f" * 40)),
+)
+def test_dependency_snapshot_rejects_mismatched_installed_source(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    dependency: str,
+    field: str,
+    value: str,
+) -> None:
+    state = json.loads(provenance.INSTALL_STATE.read_text(encoding="utf-8"))
+    state["sources"][dependency][field] = value
+    state_path = tmp_path / "install-state.json"
+    state_path.write_text(json.dumps(state), encoding="utf-8")
+    monkeypatch.setattr(provenance, "INSTALL_STATE", state_path)
+
+    with pytest.raises(capture.CaptureError, match=r"installed .* source"):
+        provenance.collect_dependency_snapshot(_candidate_runtime_snapshot())
+
+
+def test_github_ssh_origin_is_normalized_to_https() -> None:
+    assert capture.github_https_uri("git@github.com:owner/repository.git") == (
+        "https://github.com/owner/repository.git"
+    )
+    assert (
+        capture.github_https_uri("ssh://git@github.com/owner/repository.git")
+        == "https://github.com/owner/repository.git"
+    )
+
+
+def test_atomic_write_documents_never_overwrites_or_partially_adds(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "capture"
+    output.mkdir()
+    existing = output / capture.PHYSICS_FILENAME
+    existing.write_text('{"retained":true}\n', encoding="ascii")
+
+    with pytest.raises(capture.CaptureError, match="will not be overwritten"):
+        capture.atomic_write_documents(
+            output,
+            {
+                capture.PHYSICS_FILENAME: {"new": True},
+                capture.FORTRAN_EVIDENCE_FILENAME: {"new": True},
+            },
+        )
+
+    assert existing.read_text(encoding="ascii") == '{"retained":true}\n'
+    assert not (output / capture.FORTRAN_EVIDENCE_FILENAME).exists()
+    assert not tuple(output.glob("*.tmp"))
+
+
+def test_atomic_write_documents_publishes_canonical_json(tmp_path: Path) -> None:
+    output = tmp_path / "capture"
+    paths = capture.atomic_write_documents(
+        output,
+        {"one.json": {"z": 1, "a": 2}, "two.json": {"ok": True}},
+    )
+
+    assert paths == (output / "one.json", output / "two.json")
+    assert json.loads(paths[0].read_text(encoding="ascii")) == {"a": 2, "z": 1}
+    with pytest.raises(capture.CaptureError, match="will not be overwritten"):
+        capture.atomic_write_documents(output, {"one.json": {"z": 3}})
+
+
+def test_validation_failure_prevents_publication(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    published = False
+
+    def fail_validation(*args: object) -> None:
+        del args
+        raise capture.CaptureError("invalid fixture")
+
+    def publish(*args: object) -> tuple[Path, ...]:
+        nonlocal published
+        del args
+        published = True
+        return ()
+
+    monkeypatch.setattr(evidence, "validate_capture_documents", fail_validation)
+    monkeypatch.setattr(evidence, "atomic_write_documents", publish)
+
+    with pytest.raises(capture.CaptureError, match="invalid fixture"):
+        evidence.validate_and_publish(tmp_path, {}, {}, {})
+    assert not published
+
+
+def test_run_capture_uses_mocked_assembly_and_validation_paths(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[str] = []
+    source = capture.SourceSnapshot("https://example.invalid/repo", "1" * 40, "2" * 64)
+    runtime = capture.RuntimeSnapshot(
+        f"{RELEASE_VERSION}.dev0+candidate." + "3" * 12,
+        "3" * 12,
+        "1" * 40,
+        "4" * 64,
+        "5" * 64,
+    )
+    dependencies = capture.DependencySnapshot((), {}, {}, {})
+    process = capture.ProcessCaptureSpec(
+        "process",
+        "a b > c",
+        "model",
+        ("0", "0", "1"),
+        "exact-2to1",
+    )
+    spec = capture.ArtifactCaptureSpec(
+        "artifact",
+        "artifact",
+        "model",
+        None,
+        "lc",
+        (process,),
+    )
+    artifact_path = tmp_path / "artifacts" / "artifact"
+    fixture = {"fixture": True}
+    analytic = {"analytic": True}
+    fortran = {"fortran": True}
+    written = (
+        tmp_path / capture.PHYSICS_FILENAME,
+        tmp_path / capture.FORTRAN_EVIDENCE_FILENAME,
+        tmp_path / capture.ANALYTIC_EVIDENCE_FILENAME,
+    )
+
+    monkeypatch.setattr(pipeline, "collect_source_snapshot", lambda root: source)
+    monkeypatch.setattr(pipeline, "collect_runtime_snapshot", lambda value: runtime)
+    monkeypatch.setattr(
+        pipeline, "collect_dependency_snapshot", lambda value: dependencies
+    )
+    monkeypatch.setattr(pipeline, "artifact_capture_specs", lambda root: (spec,))
+
+    def materialize(*args: object) -> dict[str, Path]:
+        del args
+        calls.append("materialize")
+        return {spec.id: artifact_path}
+
+    def assemble(*args: object, **kwargs: object) -> dict[str, object]:
+        del args, kwargs
+        calls.append("assemble")
+        return fixture
+
+    def analytic_evidence(value: object) -> dict[str, object]:
+        assert value is fixture
+        calls.append("analytic")
+        return analytic
+
+    def fortran_evidence(*args: object) -> dict[str, object]:
+        del args
+        calls.append("fortran")
+        return fortran
+
+    def unchanged(value: object, root: object) -> None:
+        assert value is source
+        del root
+        calls.append("unchanged")
+
+    def publish(*args: object) -> tuple[Path, ...]:
+        del args
+        calls.append("validate-publish")
+        return written
+
+    monkeypatch.setattr(pipeline, "materialize_artifacts", materialize)
+    monkeypatch.setattr(pipeline, "assemble_fixture", assemble)
+    monkeypatch.setattr(pipeline, "build_analytic_evidence", analytic_evidence)
+    monkeypatch.setattr(pipeline, "build_fortran_evidence", fortran_evidence)
+    monkeypatch.setattr(pipeline, "assert_source_snapshot_unchanged", unchanged)
+    monkeypatch.setattr(
+        pipeline, "assert_runtime_snapshot_unchanged", lambda *args: None
+    )
+    monkeypatch.setattr(pipeline, "validate_and_publish", publish)
+    config = capture.CaptureConfig(
+        output_directory=tmp_path,
+        artifact_root=tmp_path / "artifacts",
+        legacy_repository=tmp_path / "legacy",
+        legacy_jobs=1,
+        artifact_mode="reuse",
+        capture_command=("capture",),
+    )
+
+    result = pipeline.run_capture(config)
+
+    assert calls == [
+        "materialize",
+        "assemble",
+        "analytic",
+        "fortran",
+        "unchanged",
+        "validate-publish",
+    ]
+    assert result.fixture_path == written[0]
+    assert result.evidence_paths == written[1:]
+    assert result.artifact_paths == (artifact_path,)
diff --git a/pyamplicol/tests/unit/test_catalog_final_source_structural_preflight.py b/pyamplicol/tests/unit/test_catalog_final_source_structural_preflight.py
new file mode 100644
index 0000000000..8dd53ef68f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_catalog_final_source_structural_preflight.py
@@ -0,0 +1,75 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tools.developer.catalog_final_source_structural_preflight import (
+    FinalSourceProducerError,
+    _counts,
+    _legacy_record,
+)
+from tools.developer.emit_candidate_structural_preflight import _numerical_proof
+from tools.performance_report.catalog import REPORT_CATALOG
+
+
+def test_structural_counts_do_not_accept_summary_placeholders() -> None:
+    with pytest.raises(FinalSourceProducerError, match="non-negative integer"):
+        _counts(
+            {
+                "source_current_count": 1,
+                "produced_current_count": 2,
+                "kernel_evaluation_count": None,
+                "attachment_count": 4,
+                "amplitude_destination_count": 1,
+            },
+            "candidate.active",
+        )
+
+
+def test_opaque_precision50_digest_is_not_accepted_as_truth(tmp_path: Path) -> None:
+    revision = "a" * 40
+    path = tmp_path / "precision50.json"
+    path.write_text(
+        json.dumps(
+            {
+                "status": "ok",
+                "source_revision": revision,
+                "precision_decimal_digits": 50,
+                "comparison_sha256": "b" * 64,
+            }
+        )
+    )
+    with pytest.raises(
+        FinalSourceProducerError,
+        match="recomputable independent precision>=50 witness",
+    ):
+        _numerical_proof(path, revision)
+
+
+def test_legacy_proof_is_bound_to_exact_reference_cell(tmp_path: Path) -> None:
+    reference = next(
+        cell
+        for cell in REPORT_CATALOG.reference_cells()
+        if REPORT_CATALOG.legacy_reference_available(cell)
+    )
+    (tmp_path / "legacy-structural-proof.json").write_text(
+        json.dumps(
+            {
+                "schema": "pyamplicol-legacy-final-structural-proof-v1",
+                "cell_id": f"{reference.cell_id}-wrong",
+                "accuracy": reference.measurement.accuracy.value,
+                "workload": reference.workload.value,
+                "source_revision": "a" * 40,
+            }
+        )
+    )
+    result = {
+        "status": "ok",
+        "artifact": {"path": str(tmp_path)},
+        "provenance": {"revision": "a" * 40},
+    }
+    with pytest.raises(FinalSourceProducerError, match="wrong identity"):
+        _legacy_record(reference, result)
diff --git a/pyamplicol/tests/unit/test_catalog_restart_parity_gate.py b/pyamplicol/tests/unit/test_catalog_restart_parity_gate.py
new file mode 100644
index 0000000000..e331414501
--- /dev/null
+++ b/pyamplicol/tests/unit/test_catalog_restart_parity_gate.py
@@ -0,0 +1,497 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+from copy import deepcopy
+from decimal import Decimal
+from pathlib import Path
+
+from pyamplicol.artifacts import ArtifactBuilder, load_manifest
+from pyamplicol.generation.structural_source_proof import (
+    ROLE as STRUCTURAL_SOURCE_PROOF_ROLE,
+)
+from pyamplicol.generation.structural_source_proof import (
+    SEMANTIC_MAP_DOMAINS,
+    build_generation_structural_proof,
+)
+from tools.developer.catalog_restart_parity_gate import (
+    SCHEMA,
+    validate_manifest,
+)
+from tools.developer.final_source_numerical_truth import (
+    REFERENCE_SCHEMA,
+    _agreement,
+    _value_record,
+    canonical_sha256,
+    comparison_sha256,
+)
+from tools.developer.final_source_numerical_truth import (
+    SCHEMA as TRUTH_SCHEMA,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import ExecutionMode
+
+REVISION = "1" * 40
+DIGEST = "2" * 64
+
+
+def _counts(value: int = 10) -> dict[str, int]:
+    return {
+        "source_current_count": 2,
+        "produced_current_count": value - 2,
+        "kernel_evaluation_count": value,
+        "attachment_count": value,
+        "amplitude_destination_count": 2,
+    }
+
+
+def _truth(
+    cell: object,
+    *,
+    candidate_id: str,
+    structural_path: str,
+    structural_sha256: str,
+) -> dict[str, object]:
+    reference_id = hashlib.sha256(f"reference:{cell.cell_id}".encode()).hexdigest()
+    contract: dict[str, object] = {
+        "schema": REFERENCE_SCHEMA,
+        "status": "materialized",
+        "semantics": "pre-optimization-reference",
+        "source_revision": REVISION,
+        "artifact_id": reference_id,
+        "process_id": "process",
+        "contract_sha256": hashlib.sha256(
+            f"contract:{cell.cell_id}".encode()
+        ).hexdigest(),
+        "semantic_payloads": [
+            {
+                "path": "reference.json",
+                "sha256": hashlib.sha256(
+                    f"reference-payload:{cell.cell_id}".encode()
+                ).hexdigest(),
+            }
+        ],
+    }
+    contract["semantic_identity_sha256"] = canonical_sha256(
+        "independent-reference-semantics-v1",
+        contract,
+    )
+    momenta: dict[str, object] = {
+        "candidate_payload_sha256": hashlib.sha256(b"candidate-points").hexdigest(),
+        "reference_payload_sha256": hashlib.sha256(b"reference-points").hexdigest(),
+        "points": [
+            [
+                {"pdg": 1, "momentum": ["5", "0", "0", "5"]},
+                {"pdg": -1, "momentum": ["5", "0", "0", "-5"]},
+            ]
+        ],
+    }
+    momenta["validation_momenta_sha256"] = canonical_sha256(
+        "final-source-validation-momenta-v1",
+        momenta,
+    )
+    selected = cell.workload.value == "selected-flow"
+    selectors: dict[str, object] = {
+        "workload": cell.workload.value,
+        "helicity_ids": ["h:0"] if selected else [],
+        "color_ids": ["c:0"] if selected else [],
+    }
+    selectors["selector_sha256"] = canonical_sha256(
+        "final-source-selectors-v1",
+        selectors,
+    )
+    axes: dict[str, object] = {
+        "color_accuracy": cell.measurement.accuracy.value,
+        "helicity_ids": ["h:0"],
+        "color_ids": ["c:0"],
+    }
+    axes["resolved_axes_sha256"] = canonical_sha256(
+        "final-source-resolved-axes-v1",
+        axes,
+    )
+    exact_values = [[["1"]]]
+    native_values = [[[["1", "0"]]]]
+    agreement = _agreement(
+        exact_values,
+        native_values,
+        exact_values,
+        precision=80,
+        exact_agreement_digits=50,
+        native_relative_tolerance=Decimal("1e-10"),
+        native_absolute_tolerance=Decimal("1e-14"),
+    )
+    truth: dict[str, object] = {
+        "schema": TRUTH_SCHEMA,
+        "status": "ok",
+        "cell_id": cell.cell_id,
+        "source_revision": REVISION,
+        "mode": cell.measurement.execution_mode.value,
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+        "precision_decimal_digits": 80,
+        "validation_momenta": momenta,
+        "selectors": selectors,
+        "resolved_axes": axes,
+        "candidate_artifact": {
+            "artifact_id": candidate_id,
+            "source_revision": REVISION,
+            "structural_proof_path": structural_path,
+            "structural_proof_sha256": structural_sha256,
+        },
+        "reference_artifact": {
+            "artifact_id": reference_id,
+            "source_revision": REVISION,
+            "semantics_contract": contract,
+        },
+        "candidate_native": _value_record(
+            precision=16,
+            executor="native",
+            values=native_values,
+            domain="final-source-candidate-native-values-v1",
+        ),
+        "candidate_exact": _value_record(
+            precision=80,
+            executor="exact",
+            values=exact_values,
+            domain="final-source-candidate-exact-values-v1",
+        ),
+        "reference_exact": _value_record(
+            precision=80,
+            executor="reference",
+            values=exact_values,
+            domain="final-source-reference-exact-values-v1",
+        ),
+        "agreement": agreement,
+    }
+    truth["comparison_sha256"] = comparison_sha256(truth)
+    return truth
+
+
+def _candidate(
+    cell: object,
+    evidence_root: Path,
+    *,
+    artifact_id: str,
+    structural_path: str,
+    structural_sha256: str,
+    generation_proof: dict[str, object],
+) -> dict[str, object]:
+    maps = generation_proof["semantic_maps"]
+    witnesses = {name: maps[name]["rows"] for name in SEMANTIC_MAP_DOMAINS}
+    return {
+        "source_revision": REVISION,
+        "evidence_root": str(evidence_root),
+        "artifact_identity": {
+            "artifact_id": artifact_id,
+            "process_id": "process",
+            "structural_proof_path": structural_path,
+            "structural_proof_sha256": structural_sha256,
+        },
+        "active": _counts(),
+        "final_materialized": _counts(),
+        "peak_materialized": _counts(),
+        "semantic_proof": {
+            "status": "proven",
+            "strength": "exact-symbolic",
+            "source_revision": REVISION,
+            "current_member_map_sha256": maps["current_member_map"]["sha256"],
+            "interaction_row_map_sha256": maps["interaction_row_map"]["sha256"],
+            "closure_map_sha256": maps["closure_map"]["sha256"],
+            "source_contract_sha256": maps["source_contract"]["sha256"],
+            "witnesses": witnesses,
+        },
+        "numerical_validation": _truth(
+            cell,
+            candidate_id=artifact_id,
+            structural_path=structural_path,
+            structural_sha256=structural_sha256,
+        ),
+        "generation_structural_proof": generation_proof,
+        "persisted_lane_inventory": generation_proof["physical_lane_inventory"],
+    }
+
+
+def _legacy(cell: object) -> dict[str, object]:
+    if not REPORT_CATALOG.legacy_reference_available(cell):
+        return {
+            "scope": "unavailable",
+            "reason": "original-amplicol-open-quark-line-limit",
+        }
+    return {
+        "scope": "available",
+        "active": _counts(),
+        "static": _counts(),
+        "object_mapping": {
+            "status": "exact",
+            "current_object_map_sha256": DIGEST,
+            "kernel_term_map_sha256": DIGEST,
+            "combine_route_map_sha256": DIGEST,
+        },
+        "row_multiplicity": {
+            "status": "exact",
+            "histogram_sha256": DIGEST,
+            "call_count": 1,
+        },
+    }
+
+
+def _artifact_fixture(
+    tmp_path: Path,
+) -> tuple[Path, str, str, str, dict[str, object]]:
+    artifact = tmp_path / "artifact"
+    execution_path = "processes/process/execution.json"
+    structural_path = "processes/process/structural-source-proof.json"
+    execution: dict[str, object] = {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-recurrence-execution",
+        "key": "process",
+        "process": "d d~ > z",
+        "color_accuracy": "lc",
+        "external_pdg_order": [1, -1, 23],
+        "source_count": 2,
+        "current_count": 10,
+        "interaction_count": 10,
+        "amplitude_root_count": 2,
+    }
+    producer = {
+        "distribution": "pyamplicol",
+        "version": "0.1.0",
+        "versions": {
+            "python_api": 1,
+            "toml": 1,
+            "compiled_model": 1,
+            "process_artifact": 3,
+            "runtime_physics": 1,
+            "symbolica_serialization": "test",
+            "c_abi": 1,
+        },
+        "target": {"triple": "test", "cpu_features": []},
+        "git_revision": REVISION,
+        "native_build_inputs_sha256": DIGEST,
+    }
+    with ArtifactBuilder(artifact) as builder:
+        execution_record = builder.add_json(
+            execution_path,
+            execution,
+            role="evaluator-manifest",
+            process_id="process",
+            compact=True,
+        )
+        generation_proof = build_generation_structural_proof(
+            artifact_root=builder.root,
+            process_id="process",
+            source_revision=REVISION,
+            native_build_inputs_sha256=DIGEST,
+            execution_path=execution_path,
+            execution_sha256=execution_record.sha256,
+            execution=execution,
+            evaluator_container_path=None,
+            evaluator_container_index_sha256=None,
+        )
+        structural_record = builder.add_json(
+            structural_path,
+            generation_proof,
+            role=STRUCTURAL_SOURCE_PROOF_ROLE,
+            process_id="process",
+            compact=True,
+        )
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=producer,
+            model={
+                "name": "built-in-sm",
+                "source_kind": "built-in-sm",
+                "content_sha256": DIGEST,
+                "compiled_schema_version": 1,
+            },
+            configuration={
+                "toml_schema_version": 1,
+                "requested_path": "processes/process/execution.json",
+                "effective_path": "processes/process/execution.json",
+                "adjustments": [],
+            },
+            processes=[
+                {
+                    "id": "process",
+                    "expression": "d d~ > z",
+                    "color_accuracy": "lc",
+                    "external_pdgs": [1, -1, 23],
+                    "physics_path": execution_path,
+                    "required_runtime_capabilities": [
+                        "rusticol.recurrence-direct-arena.complex-f64.v1"
+                    ],
+                    "aliases": [],
+                }
+            ],
+            default_process_id="process",
+            runtime={
+                "engine": "rusticol",
+                "engine_version": "0.1.0",
+                "evaluator_manifest_path": execution_path,
+                "api_bundle_path": None,
+                "required_runtime_capabilities": [
+                    "rusticol.recurrence-direct-arena.complex-f64.v1"
+                ],
+            },
+        )
+    manifest = load_manifest(artifact)
+    return (
+        artifact,
+        manifest.artifact_id,
+        structural_path,
+        structural_record.sha256,
+        generation_proof,
+    )
+
+
+def _manifest(tmp_path: Path) -> dict[str, object]:
+    (
+        artifact,
+        artifact_id,
+        structural_path,
+        structural_sha,
+        generation_proof,
+    ) = _artifact_fixture(tmp_path)
+    cells = []
+    for cell in REPORT_CATALOG.matrix_cells():
+        if cell.measurement.execution_mode not in {
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.COMPILED,
+            ExecutionMode.EAGER,
+        }:
+            continue
+        comparable = REPORT_CATALOG.legacy_reference_available(cell)
+        cells.append(
+            {
+                "cell_id": cell.cell_id,
+                "process_key": cell.process_key,
+                "n_final": cell.n_final,
+                "mode": cell.measurement.execution_mode.value,
+                "model": cell.measurement.model.value,
+                "accuracy": cell.measurement.accuracy.value,
+                "workload": cell.workload.value,
+                "classification": (
+                    "certified-parity" if comparable else "legacy-scope-unavailable"
+                ),
+                "candidate": _candidate(
+                    cell,
+                    artifact,
+                    artifact_id=artifact_id,
+                    structural_path=structural_path,
+                    structural_sha256=structural_sha,
+                    generation_proof=generation_proof,
+                ),
+                "legacy": _legacy(cell),
+            }
+        )
+    return {"schema": SCHEMA, "source_revision": REVISION, "cells": cells}
+
+
+def test_complete_exact_manifest_passes_every_catalog_row(tmp_path: Path) -> None:
+    result = validate_manifest(_manifest(tmp_path), expected_revision=REVISION)
+    assert result["summary"]["expected_cell_count"] == 1356
+    assert result["summary"]["failed_row_count"] == 0
+    assert result["summary"]["classification_counts"] == {
+        "certified-parity": 1314,
+        "legacy-scope-unavailable": 42,
+    }
+    assert result["summary"]["restart_ready"] is True
+    assert len(result["rows"]) == 1356
+
+
+def test_summary_boolean_cannot_replace_per_row_evidence() -> None:
+    result = validate_manifest(
+        {
+            "schema": SCHEMA,
+            "source_revision": REVISION,
+            "fully_certified_catalog_parity": True,
+            "cells": [],
+        },
+        expected_revision=REVISION,
+    )
+    assert result["summary"]["restart_ready"] is False
+    assert result["summary"]["failure_reason_counts"] == {"missing-record": 1356}
+
+
+def test_missing_and_unexpected_rows_are_listed_with_reasons(
+    tmp_path: Path,
+) -> None:
+    manifest = _manifest(tmp_path)
+    cells = manifest["cells"]
+    assert isinstance(cells, list)
+    cells.pop()
+    cells.append(
+        {
+            "cell_id": "not-in-the-report-catalog",
+            "classification": "certified-parity",
+        }
+    )
+    result = validate_manifest(manifest, expected_revision=REVISION)
+    assert result["summary"]["failure_reason_counts"] == {
+        "missing-record": 1,
+        "unexpected-record": 1,
+    }
+
+
+def test_numerical_only_generation_relation_fails_closed(tmp_path: Path) -> None:
+    manifest = _manifest(tmp_path)
+    cells = manifest["cells"]
+    assert isinstance(cells, list)
+    candidate = cells[0]["candidate"]
+    candidate["numerical_relation_discovery"] = {
+        "used_for_generation": True,
+        "reconstructed_exact": False,
+    }
+    result = validate_manifest(manifest, expected_revision=REVISION)
+    assert result["summary"]["failure_reason_counts"] == {
+        "numerical-only-relation-used-for-generation": 1
+    }
+
+
+def test_counts_only_certificate_and_stale_source_are_rejected(
+    tmp_path: Path,
+) -> None:
+    manifest = _manifest(tmp_path)
+    cells = manifest["cells"]
+    assert isinstance(cells, list)
+    candidate = cells[0]["candidate"]
+    candidate["source_revision"] = "3" * 40
+    candidate["semantic_proof"] = {"status": "proven"}
+    result = validate_manifest(manifest, expected_revision=REVISION)
+    assert result["summary"]["failure_reason_counts"] == {
+        "candidate-source-revision-mismatch": 1,
+        "semantic-proof-incomplete": 1,
+        "semantic-proof-not-exact": 1,
+        "semantic-proof-source-revision-mismatch": 1,
+    }
+
+
+def test_static_inventory_and_ratio_are_recomputed_not_trusted(
+    tmp_path: Path,
+) -> None:
+    manifest = _manifest(tmp_path)
+    cells = manifest["cells"]
+    assert isinstance(cells, list)
+    record = cells[0]
+    record["producer_ratio"] = 0.01
+    candidate = record["candidate"]
+    candidate["final_materialized"] = _counts(20)
+    result = validate_manifest(manifest, expected_revision=REVISION)
+    reasons = result["rows"][0]["reason_codes"]
+    assert "final_materialized-logical_current-exceeds-1.05" in reasons
+    assert "final_materialized-kernel_evaluation-exceeds-1.05" in reasons
+    assert "final_materialized-attachment-exceeds-1.05" in reasons
+
+
+def test_legacy_scope_unavailable_still_requires_candidate_self_proof(
+    tmp_path: Path,
+) -> None:
+    manifest = _manifest(tmp_path)
+    cells = manifest["cells"]
+    assert isinstance(cells, list)
+    target = next(cell for cell in cells if cell["process_key"] == "dd_4q_lines")
+    target["candidate"] = deepcopy(target["candidate"])
+    del target["candidate"]["numerical_validation"]
+    result = validate_manifest(manifest, expected_revision=REVISION)
+    row = next(row for row in result["rows"] if row["cell_id"] == target["cell_id"])
+    assert row["reason_codes"] == ["numerical-validation-incomplete"]
diff --git a/pyamplicol/tests/unit/test_catalog_structural_parity_audit.py b/pyamplicol/tests/unit/test_catalog_structural_parity_audit.py
new file mode 100644
index 0000000000..6f0614dd41
--- /dev/null
+++ b/pyamplicol/tests/unit/test_catalog_structural_parity_audit.py
@@ -0,0 +1,458 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tools.developer.catalog_structural_parity_audit import (
+    CatalogParityError,
+    WorkCounts,
+    _candidate_counts,
+    _legacy_counts,
+    _parity_exit_code,
+    audit_source_manifest,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import ExecutionMode, Workload
+
+
+def _module(path: Path, currents: int, interactions: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    source_calls = "\n".join(
+        f"call ext_scalar(p,val_c(1,{current}))"
+        for current in range(1, currents)
+    )
+    interaction_ids = ",".join(str(value) for value in range(1, interactions + 1))
+    path.write_text(
+        "subroutine evaluate(p,val_c,int_c)\n"
+        f"complex(kind=8),dimension(1:6,{currents}) :: val_c\n"
+        f"complex(kind=8),dimension(1:6,{interactions}) :: int_c\n"
+        "end subroutine evaluate\n"
+        "subroutine compute_external_currents(p,val_c)\n"
+        f"{source_calls}\n"
+        "end subroutine compute_external_currents\n"
+        "subroutine vertex_type_fixture(p,val_c,int_c)\n"
+        f"integer,parameter,dimension({interactions}) :: int1=[{interaction_ids}]\n"
+        "end subroutine vertex_type_fixture\n"
+        "subroutine combine_currents_fixture(p,val_c,int_c)\n"
+        f"integer,parameter,dimension(0:{interactions},1) :: int1="
+        f"reshape([{currents},{interaction_ids}],"
+        f"shape=[{interactions + 1},1])\n"
+        "end subroutine combine_currents_fixture\n"
+    )
+
+
+def test_selected_flow_uses_exact_process_row_module(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    _module(
+        artifact / "selected-flow-generated-library/Library/amp1_1_lib.f03",
+        31,
+        37,
+    )
+    _module(
+        artifact / "selected-flow-generated-library/Library/amp2_1_lib.f03",
+        41,
+        47,
+    )
+    counts = _legacy_counts(
+        {
+            "artifact": {
+                "path": str(artifact),
+                "process_row": "group:2:integral:1",
+            }
+        },
+        workload=Workload.SELECTED_FLOW,
+    )
+    assert counts.active is not None
+    assert counts.active.current_count == 41
+    assert counts.active.evaluation_count == 47
+    assert counts.active.attachment_count == 47
+    assert counts.static.current_count == 31 + 41
+    assert counts.static.evaluation_count == 37 + 47
+    assert counts.static.attachment_count == 37 + 47
+    assert counts.selected_module == "amp2_1_lib.f03"
+    assert counts.selected_module_object_mapping is not None
+    assert counts.selected_module_object_mapping.current_ids_complete is True
+    assert counts.selected_module_object_mapping.interaction_ids_complete is True
+
+
+def test_contracted_without_call_histogram_keeps_active_work_unresolved(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    for index in range(1, 7):
+        _module(
+            artifact / f"contracted-generated-library/Library/amp{index}_1_lib.f03",
+            406,
+            2440,
+        )
+    probe = (
+        artifact
+        / "contracted-generated-library"
+        / "amplicol_color_library_probe.output"
+    )
+    probe.write_text(
+        "Total number of currents, vertices and amplitudes after filter "
+        f"{720 * 406} {720 * 2440} 720\n"
+    )
+    counts = _legacy_counts(
+        {
+            "artifact": {
+                "path": str(artifact),
+                "process_row": "group:1:integral:1",
+            }
+        },
+        workload=Workload.CONTRACTED,
+    )
+    assert counts.static.current_count == 6 * 406
+    assert counts.static.evaluation_count == 6 * 2440
+    assert counts.static.attachment_count == 6 * 2440
+    assert counts.active is None
+    assert counts.limitation is not None
+
+
+def test_contracted_uses_exact_call_histogram_for_nonuniform_modules(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _module(
+        artifact / "contracted-generated-library/Library/amp1_1_lib.f03",
+        10,
+        20,
+    )
+    _module(
+        artifact / "contracted-generated-library/Library/amp2_1_lib.f03",
+        30,
+        40,
+    )
+    probe = (
+        artifact
+        / "contracted-generated-library"
+        / "amplicol_color_library_probe.output"
+    )
+    probe.write_text(
+        "Total number of currents, vertices and amplitudes after filter 123 456 7\n"
+        "AMPICOL_COLOR_PROBE_LIBRARY_CALLS 1 1 2\n"
+        "AMPICOL_COLOR_PROBE_LIBRARY_CALLS 2 1 5\n"
+    )
+    counts = _legacy_counts(
+        {
+            "artifact": {
+                "path": str(artifact),
+                "process_row": "group:2:integral:1",
+            }
+        },
+        workload=Workload.CONTRACTED,
+    )
+    assert counts.active == WorkCounts(
+        2 * 10 + 5 * 30,
+        2 * 20 + 5 * 40,
+        2 * 20 + 5 * 40,
+    )
+    assert counts.static == WorkCounts(40, 60, 60)
+    assert counts.limitation is None
+
+
+def test_recurrence_selector_certificate_separates_active_from_persisted(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    process = artifact / "processes/p/execution.json"
+    process.parent.mkdir(parents=True)
+    process.write_text(
+        json.dumps(
+            {
+                "kind": "pyamplicol-runtime-recurrence-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "schedule": {
+                            "current_count": 100,
+                            "contribution_count": 200,
+                        },
+                        "construction": {
+                            "peak_current_count": 120,
+                            "peak_contribution_count": 240,
+                            "peak_contribution_count_semantics": (
+                                "resident-pending-contributions-v1"
+                            ),
+                        },
+                        "selector_work_certificate": {
+                            "representatives": [
+                                {
+                                    "current_count": 30,
+                                    "contribution_count": 40,
+                                },
+                                {
+                                    "current_count": 35,
+                                    "contribution_count": 45,
+                                },
+                            ]
+                        },
+                    }
+                },
+            }
+        )
+    )
+    counts = _candidate_counts(
+        {
+            "artifact": {"path": str(artifact)},
+            "provenance": {"report_measured_source_revision": "abc"},
+        },
+        workload=Workload.SELECTED_FLOW,
+    )
+    assert counts.active.current_count == 35
+    assert counts.active.evaluation_count == 45
+    assert counts.active.attachment_count == 45
+    assert counts.final_materialized.current_count == 100
+    assert counts.peak_materialized.evaluation_count == 240
+    assert counts.peak_materialized.attachment_count == 240
+    assert counts.selector_certificate_available is True
+
+
+def test_recurrence_peak_requires_resident_semantics_marker(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    process = artifact / "processes/p/execution.json"
+    process.parent.mkdir(parents=True)
+    process.write_text(
+        json.dumps(
+            {
+                "kind": "pyamplicol-runtime-recurrence-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "schedule": {
+                            "current_count": 100,
+                            "contribution_count": 200,
+                        },
+                        "construction": {
+                            "peak_current_count": 120,
+                            "peak_contribution_count": 240,
+                        },
+                    }
+                },
+            }
+        )
+    )
+
+    with pytest.raises(
+        CatalogParityError,
+        match="authenticated resident peak-contribution semantics",
+    ):
+        _candidate_counts(
+            {
+                "artifact": {"path": str(artifact)},
+                "provenance": {"report_measured_source_revision": "abc"},
+            },
+            workload=Workload.CONTRACTED,
+        )
+
+
+def test_compiled_all_flow_uses_primary_fixed_helicity_dag(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    process = artifact / "processes/p/execution.json"
+    process.parent.mkdir(parents=True)
+    process.write_text(
+        json.dumps(
+            {
+                "kind": "pyamplicol-runtime-execution",
+                "dag_summary": {
+                    "current_count": 31,
+                    "interaction_count": 47,
+                    "interaction_evaluation_count": 29,
+                },
+                "helicity_selector_executions": [
+                    {
+                        "execution": {
+                            "dag_summary": {
+                                "current_count": 19,
+                                "interaction_count": 23,
+                                "interaction_evaluation_count": 17,
+                            }
+                        }
+                    }
+                ],
+            }
+        )
+    )
+    counts = _candidate_counts(
+        {"artifact": {"path": str(artifact)}},
+        workload=Workload.ALL_FLOW,
+    )
+    assert counts.active.current_count == 19
+    assert counts.active.evaluation_count == 17
+    assert counts.active.attachment_count == 23
+    assert counts.final_materialized == WorkCounts(50, 46, 70)
+    assert counts.active_evidence_kind == ("compiled-fixed-helicity-worst-class")
+    assert counts.selector_certificate_available is True
+
+
+def test_compiled_selected_flow_uses_worst_color_sector(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    process = artifact / "processes/p/execution.json"
+    process.parent.mkdir(parents=True)
+    process.write_text(
+        json.dumps(
+            {
+                "kind": "pyamplicol-runtime-execution",
+                "dag_summary": {
+                    "current_count": 11,
+                    "interaction_count": 13,
+                    "interaction_evaluation_count": 7,
+                },
+                "helicity_sum_execution": {
+                    "dag_summary": {
+                        "current_count": 101,
+                        "interaction_count": 211,
+                        "interaction_evaluation_count": 151,
+                    },
+                    "color_selector_executions": [
+                        {
+                            "execution": {
+                                "dag_summary": {
+                                    "current_count": 31,
+                                    "interaction_count": 41,
+                                    "interaction_evaluation_count": 29,
+                                }
+                            }
+                        },
+                        {
+                            "execution": {
+                                "dag_summary": {
+                                    "current_count": 37,
+                                    "interaction_count": 43,
+                                    "interaction_evaluation_count": 31,
+                                }
+                            }
+                        },
+                    ],
+                },
+            }
+        )
+    )
+    counts = _candidate_counts(
+        {"artifact": {"path": str(artifact)}},
+        workload=Workload.SELECTED_FLOW,
+    )
+    assert counts.active == WorkCounts(37, 31, 43)
+    assert counts.final_materialized == WorkCounts(180, 218, 308)
+    assert counts.active_evidence_kind == ("compiled-selected-color-worst-sector")
+    assert counts.selector_certificate_available is True
+
+
+def test_eager_selector_census_separates_active_from_materialized(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    process = artifact / "processes/p/execution.json"
+    process.parent.mkdir(parents=True)
+    process.write_text(
+        json.dumps(
+            {
+                "kind": "pyamplicol-runtime-eager-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "current_count": 101,
+                        "invocation_count": 151,
+                        "attachment_count": 211,
+                        "selector_work": {
+                            "abi": "pyamplicol-eager-selector-work-v1",
+                            "selected_flow_current_count": 37,
+                            "selected_flow_evaluation_count": 31,
+                            "selected_flow_attachment_count": 43,
+                            "all_flow_current_count": 41,
+                            "all_flow_evaluation_count": 35,
+                            "all_flow_attachment_count": 47,
+                            "contracted_current_count": 101,
+                            "contracted_evaluation_count": 151,
+                            "contracted_attachment_count": 211,
+                        },
+                    }
+                },
+            }
+        )
+    )
+    counts = _candidate_counts(
+        {"artifact": {"path": str(artifact)}},
+        workload=Workload.SELECTED_FLOW,
+    )
+    assert counts.active == WorkCounts(37, 31, 43)
+    assert counts.final_materialized == WorkCounts(101, 151, 211)
+    assert counts.active_evidence_kind == "eager-selected-flow-selector-census"
+    assert counts.selector_certificate_available is True
+
+
+def test_complete_parity_gate_fails_closed() -> None:
+    passing = {"summary": {"fully_certified_catalog_parity": True}}
+    failing = {"summary": {"fully_certified_catalog_parity": False}}
+    assert _parity_exit_code(passing, required=False) == 0
+    assert _parity_exit_code(failing, required=False) == 0
+    assert _parity_exit_code(passing, required=True) == 0
+    assert _parity_exit_code(failing, required=True) == 2
+    assert _parity_exit_code({}, required=True) == 2
+
+
+def test_source_preflight_requires_exact_all_catalog_coverage() -> None:
+    revision = "a" * 40
+    cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode
+        in {ExecutionMode.RECURRENCE, ExecutionMode.COMPILED, ExecutionMode.EAGER}
+    )
+    assert len(cells) == 1356
+    counts = {
+        "current_count": 100,
+        "evaluation_count": 200,
+        "attachment_count": 300,
+    }
+    rows = []
+    for cell in cells:
+        candidate = {
+            "active": counts,
+            "final_materialized": counts,
+            "peak_materialized": counts,
+            "active_closure_count": 4,
+            "final_closure_count": 4,
+            "peak_closure_count": 4,
+            "dynamic_color_projection_applied": False,
+            "dynamic_color_projection": None,
+        }
+        row = {
+            "cell_id": cell.cell_id,
+            "source_revision": revision,
+            "proof_strength": "exact-source-construction",
+            "candidate": candidate,
+        }
+        if REPORT_CATALOG.legacy_reference_available(cell):
+            row |= {
+                "status": "ok",
+                "legacy": {
+                    "active": counts,
+                    "static": counts,
+                },
+            }
+        else:
+            row |= {
+                "status": "legacy-scope-unavailable",
+                "scope_reason": "original AmpliCol supports at most three quark lines",
+                "legacy": None,
+            }
+        rows.append(row)
+    payload = audit_source_manifest(
+        {
+            "schema": "pyamplicol-catalog-source-structural-evidence-v1",
+            "source_revision": revision,
+            "cells": rows,
+        }
+    )
+
+    assert payload["summary"]["catalog_candidate_cell_count"] == 1356
+    assert payload["summary"]["complete_catalog_coverage"] is True
+    assert payload["summary"]["fully_certified_catalog_parity"] is True
diff --git a/pyamplicol/tests/unit/test_catalog_structural_scope_registry.py b/pyamplicol/tests/unit/test_catalog_structural_scope_registry.py
new file mode 100644
index 0000000000..d4c1c36b56
--- /dev/null
+++ b/pyamplicol/tests/unit/test_catalog_structural_scope_registry.py
@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+
+from tools.developer.catalog_structural_scope_registry import (
+    SCHEMA,
+    validate_reviewed_matrix_scope,
+)
+
+
+def test_reviewed_out_of_catalog_scope_is_exact_and_machine_readable() -> None:
+    scope = validate_reviewed_matrix_scope()
+    assert scope["schema"] == SCHEMA
+    assert scope["review"]["status"] == "reviewed"
+    assert {
+        item["scope_id"] for item in scope["intentionally_out_of_catalog"]
+    } == {"ufo-compiled-and-eager-lc-nlc"}
+    requirements = {
+        item["scope_id"]: item for item in scope["candidate_only_requirements"]
+    }
+    assert requirements[
+        "four-open-quark-lines-lc-candidate-proof"
+    ]["catalog_cell_count"] == 32
+    contracted = requirements[
+        "four-open-quark-lines-contracted-candidate-proof"
+    ]
+    assert contracted["catalog_cell_count"] == 10
+    assert contracted["mode_model_workload_plane_count_by_accuracy"] == {
+        "nlc": 4,
+        "full": 6,
+    }
+    assert contracted["legacy_comparison"] == {
+        "status": "unavailable",
+        "reason": "original-amplicol-open-quark-line-limit",
+    }
+    json.dumps(scope, sort_keys=True)
diff --git a/pyamplicol/tests/unit/test_ci_memory_watchdog.py b/pyamplicol/tests/unit/test_ci_memory_watchdog.py
new file mode 100644
index 0000000000..04f3384a72
--- /dev/null
+++ b/pyamplicol/tests/unit/test_ci_memory_watchdog.py
@@ -0,0 +1,981 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import ctypes
+import errno
+import hashlib
+import io
+import json
+import os
+import struct
+import subprocess
+import sys
+import time
+import tomllib
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+WATCHDOG = ROOT / "tools/ci/memory_watchdog.py"
+if WATCHDOG.is_file():
+    from tools.ci import memory_watchdog as watchdog
+else:  # CI-only tools are intentionally absent from unpacked source distributions.
+    watchdog = None  # type: ignore[assignment]
+
+pytestmark = pytest.mark.skipif(
+    watchdog is None,
+    reason="the CI-only memory watchdog is intentionally absent from the sdist",
+)
+
+
+def test_argument_validation_and_default_limit() -> None:
+    parser = watchdog._parser()
+    parsed = parser.parse_args(("--", sys.executable, "-c", "pass"))
+
+    assert parsed.limit_gib is None
+    assert parsed.limit_mib is None
+    assert parsed.report_json is None
+    assert parsed.bind_result_json is None
+    assert watchdog.DEFAULT_LIMIT_GIB == 30.0
+    with pytest.raises(SystemExit) as missing:
+        watchdog.main(())
+    assert missing.value.code == 2
+    with pytest.raises(SystemExit) as invalid:
+        watchdog.main(("--limit-gib", "0", "--", "true"))
+    assert invalid.value.code == 2
+    with pytest.raises(SystemExit) as unreported_binding:
+        watchdog.main(("--bind-result-json", "result.json", "--", "true"))
+    assert unreported_binding.value.code == 2
+    with pytest.raises(SystemExit) as aliased_outputs:
+        watchdog.main(
+            (
+                "--report-json",
+                "evidence.json",
+                "--bind-result-json",
+                "evidence.json",
+                "--",
+                "true",
+            )
+        )
+    assert aliased_outputs.value.code == 2
+
+
+def test_final_report_is_content_addressed_and_binds_result(tmp_path: Path) -> None:
+    result_path = tmp_path / "campaign.json"
+    result_path.write_text('{"complete":true}\n', encoding="ascii")
+    report_path = tmp_path / "watchdog.json"
+
+    returncode = watchdog._emit_final_report(
+        report_path=report_path,
+        bound_result_path=result_path,
+        command=("python", "paired.py", "--result-json", str(result_path)),
+        working_directory=str(tmp_path),
+        started_at_utc="2026-07-31T00:00:00+00:00",
+        started_monotonic=time.monotonic() - 1.0,
+        child_pid=123,
+        child_exit_code=0,
+        watchdog_exit_code=0,
+        outcome="command-finished",
+        reason=None,
+        limit_bytes=30 * watchdog.GIB,
+        poll_interval=0.25,
+        terminate_grace=5.0,
+        metric="process-tree-rss",
+        probe_sample_count=4,
+        probe_failure_count=2,
+        maximum_consecutive_probe_failures=1,
+        peak_rss_bytes=1024,
+        peak_physical_footprint_bytes=None,
+        peak_guard_bytes=1024,
+        peak_processes=2,
+        stderr=io.StringIO(),
+    )
+
+    payload = json.loads(report_path.read_text(encoding="ascii"))
+    unsigned = dict(payload)
+    digest = unsigned.pop("content_sha256")
+    assert returncode == 0
+    assert digest == watchdog._sha256(unsigned)
+    assert payload["passes"] is True
+    assert payload["enforcement"]["completed_under_retry_policy"] is True
+    assert payload["enforcement"]["probe_failure_count"] == 2
+    assert payload["enforcement"]["maximum_consecutive_probe_failures"] == 1
+    identity = payload["result_binding"]["identity"]
+    assert identity["resolved_path"] == str(result_path.resolve())
+    assert identity["sha256"] == hashlib.sha256(result_path.read_bytes()).hexdigest()
+
+
+def test_requested_report_is_emitted_when_command_cannot_start(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    report_path = tmp_path / "watchdog-failure.json"
+
+    def missing(*_args: object, **_kwargs: object) -> object:
+        raise FileNotFoundError
+
+    monkeypatch.setattr(watchdog.subprocess, "Popen", missing)
+    returncode = watchdog.run_guarded(
+        ("missing-command",),
+        limit_bytes=watchdog.MIB,
+        report_path=report_path,
+        stderr=io.StringIO(),
+    )
+
+    payload = json.loads(report_path.read_text(encoding="ascii"))
+    assert returncode == 127
+    assert payload["complete"] is True
+    assert payload["passes"] is False
+    assert payload["execution"]["outcome"] == "command-not-found"
+    assert payload["execution"]["watchdog_exit_code"] == 127
+
+
+def test_success_without_requested_bound_result_fails_closed(
+    tmp_path: Path,
+) -> None:
+    report_path = tmp_path / "watchdog.json"
+    missing_result = tmp_path / "missing-campaign.json"
+
+    returncode = watchdog._emit_final_report(
+        report_path=report_path,
+        bound_result_path=missing_result,
+        command=("python", "paired.py"),
+        working_directory=str(tmp_path),
+        started_at_utc="2026-07-31T00:00:00+00:00",
+        started_monotonic=time.monotonic() - 1.0,
+        child_pid=123,
+        child_exit_code=0,
+        watchdog_exit_code=0,
+        outcome="command-finished",
+        reason=None,
+        limit_bytes=30 * watchdog.GIB,
+        poll_interval=0.25,
+        terminate_grace=5.0,
+        metric="process-tree-rss",
+        probe_sample_count=4,
+        probe_failure_count=0,
+        maximum_consecutive_probe_failures=0,
+        peak_rss_bytes=1024,
+        peak_physical_footprint_bytes=None,
+        peak_guard_bytes=1024,
+        peak_processes=2,
+        stderr=io.StringIO(),
+    )
+
+    payload = json.loads(report_path.read_text(encoding="ascii"))
+    assert returncode == watchdog.WATCHDOG_ERROR_EXIT_CODE
+    assert payload["passes"] is False
+    assert payload["execution"]["outcome"] == "result-binding-failed"
+    assert payload["result_binding"]["identity"] is None
+    assert payload["result_binding"]["error"]
+
+
+def test_linux_proc_parsers_handle_parentheses_and_rss() -> None:
+    stat = "412 (worker (phase 2)) S 99 401 401 0 -1 0"
+    status = "Name:\tworker\nVmPeak:\t9000 kB\nVmRSS:\t1234 kB\n"
+
+    assert watchdog._parse_proc_stat(stat) == (99, 401)
+    assert watchdog._parse_proc_status_rss(status) == 1234 * 1024
+    assert watchdog._parse_proc_status_rss("Name:\tworker\n") == 0
+
+
+def test_ps_parser_and_tree_sampler_include_group_and_escaped_descendants() -> None:
+    records = watchdog._parse_ps_output(
+        """
+        100 1 100 1024
+        101 100 100 2048
+        102 101 102 4096
+        103 1 100 512
+        900 1 900 9999
+        """
+    )
+    sampler = watchdog.ProcessTreeSampler(root_pid=100, root_pgid=100)
+
+    footprints = {
+        100: 8 * watchdog.MIB,
+        101: 7 * watchdog.MIB,
+        103: 6 * watchdog.MIB,
+    }
+    sample = sampler.sample(
+        records,
+        physical_footprint_probe=lambda pids: {
+            pid: footprints[pid] for pid in pids if pid in footprints
+        },
+    )
+
+    assert tuple(member.pid for member in sample.members) == (100, 101, 102, 103)
+    assert sample.rss_bytes == (1024 + 2048 + 4096 + 512) * 1024
+    assert sample.physical_footprint_bytes == (
+        8 * watchdog.MIB
+        + 7 * watchdog.MIB
+        + 4096 * 1024  # Conservative RSS fallback for the raced-out PID.
+        + 6 * watchdog.MIB
+    )
+    assert watchdog._guard_observation(sample) == (
+        sample.physical_footprint_bytes,
+        watchdog.DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON,
+    )
+
+
+def test_raced_out_footprint_member_falls_back_to_its_last_rss() -> None:
+    records = {
+        100: watchdog.ProcessInfo(100, 1, 100, 3 * watchdog.MIB),
+        101: watchdog.ProcessInfo(101, 100, 100, 5 * watchdog.MIB),
+    }
+    sampler = watchdog.ProcessTreeSampler(root_pid=100, root_pgid=100)
+
+    sample = sampler.sample(
+        records,
+        physical_footprint_probe=lambda _pids: {100: 7 * watchdog.MIB},
+    )
+
+    assert sample.rss_bytes == 8 * watchdog.MIB
+    assert sample.physical_footprint_bytes == 12 * watchdog.MIB
+
+
+def test_guard_observation_falls_back_to_rss_without_darwin_metric() -> None:
+    sample = watchdog.MemorySample(
+        rss_bytes=11 * watchdog.MIB,
+        members=(),
+    )
+    lower_footprint = watchdog.MemorySample(
+        rss_bytes=11 * watchdog.MIB,
+        members=(),
+        physical_footprint_bytes=9 * watchdog.MIB,
+    )
+
+    assert watchdog._guard_observation(sample) == (
+        11 * watchdog.MIB,
+        watchdog.RSS_LIMIT_REASON,
+    )
+    assert watchdog._guard_observation(lower_footprint) == (
+        11 * watchdog.MIB,
+        watchdog.RSS_LIMIT_REASON,
+    )
+
+
+def test_footprint_over_rss_terminates_with_stable_reason(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class FakeProcess:
+        pid = 43210
+
+        def __init__(self) -> None:
+            self.returncode: int | None = None
+
+        def poll(self) -> int | None:
+            return self.returncode
+
+        def wait(self, timeout: float) -> int:
+            del timeout
+            self.returncode = self.returncode or -9
+            return self.returncode
+
+    process = FakeProcess()
+    monkeypatch.setattr(
+        watchdog.subprocess,
+        "Popen",
+        lambda *_args, **_kwargs: process,
+    )
+
+    def record_signal(_pgid: int, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    monkeypatch.setattr(watchdog.os, "killpg", record_signal)
+    monkeypatch.setattr(watchdog.os, "kill", lambda *_args: None)
+
+    def snapshotter() -> dict[int, watchdog.ProcessInfo]:
+        return {
+            process.pid: watchdog.ProcessInfo(
+                process.pid,
+                1,
+                process.pid,
+                8 * watchdog.MIB,
+            )
+        }
+
+    stderr = io.StringIO()
+
+    returncode = watchdog.run_guarded(
+        ("synthetic-child",),
+        limit_bytes=16 * watchdog.MIB,
+        poll_interval=0.001,
+        terminate_grace=0,
+        snapshotter=snapshotter,
+        physical_footprint_probe=lambda pids: {
+            pid: 20 * watchdog.MIB for pid in pids
+        },
+        stderr=stderr,
+    )
+
+    assert returncode == watchdog.MEMORY_LIMIT_EXIT_CODE
+    assert (
+        f"reason={watchdog.DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON}" in stderr.getvalue()
+    )
+    assert "rss=0.008 GiB" in stderr.getvalue()
+    assert "physical_footprint=0.020 GiB" in stderr.getvalue()
+
+
+def test_short_child_cannot_succeed_during_required_footprint_probe_failure(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class FinishedProcess:
+        pid = 43211
+        returncode = 0
+
+        def poll(self) -> int:
+            return self.returncode
+
+        def wait(self, timeout: float) -> int:
+            del timeout
+            return self.returncode
+
+    process = FinishedProcess()
+    monkeypatch.setattr(
+        watchdog.subprocess,
+        "Popen",
+        lambda *_args, **_kwargs: process,
+    )
+
+    def snapshotter() -> dict[int, watchdog.ProcessInfo]:
+        return {
+            process.pid: watchdog.ProcessInfo(
+                process.pid,
+                1,
+                process.pid,
+                8 * watchdog.MIB,
+            )
+        }
+
+    def unavailable_footprint(_pids: object) -> dict[int, int]:
+        raise watchdog.ProbeError("synthetic footprint probe failure")
+
+    stderr = io.StringIO()
+    returncode = watchdog.run_guarded(
+        ("short-child",),
+        limit_bytes=16 * watchdog.MIB,
+        poll_interval=0.001,
+        snapshotter=snapshotter,
+        physical_footprint_probe=unavailable_footprint,
+        stderr=stderr,
+    )
+
+    assert returncode == watchdog.WATCHDOG_ERROR_EXIT_CODE
+    assert (
+        "command exited while memory enforcement was unavailable"
+        in stderr.getvalue()
+    )
+    assert (
+        f"reason={watchdog.DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON}"
+        in stderr.getvalue()
+    )
+    assert "child_exit=0" in stderr.getvalue()
+
+
+def test_child_exit_before_retry_cannot_be_cleared_by_zombie_sample(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class ExitingProcess:
+        pid = 43213
+
+        def __init__(self) -> None:
+            self.returncode: int | None = None
+            self.poll_count = 0
+
+        def poll(self) -> int | None:
+            self.poll_count += 1
+            return self.returncode
+
+        def wait(self, timeout: float) -> int:
+            del timeout
+            assert self.returncode is not None
+            return self.returncode
+
+    process = ExitingProcess()
+    monkeypatch.setattr(
+        watchdog.subprocess,
+        "Popen",
+        lambda *_args, **_kwargs: process,
+    )
+    snapshot_count = 0
+
+    def snapshotter() -> dict[int, watchdog.ProcessInfo]:
+        nonlocal snapshot_count
+        snapshot_count += 1
+        return {
+            process.pid: watchdog.ProcessInfo(
+                process.pid,
+                1,
+                process.pid,
+                8 * watchdog.MIB,
+            )
+        }
+
+    footprint_count = 0
+
+    def footprint(_pids: object) -> dict[int, int]:
+        nonlocal footprint_count
+        footprint_count += 1
+        if footprint_count == 1:
+            raise watchdog.ProbeError("synthetic footprint probe failure")
+        return {process.pid: 0}
+
+    def exit_during_retry_sleep(_duration: float) -> None:
+        process.returncode = 0
+
+    monkeypatch.setattr(watchdog.time, "sleep", exit_during_retry_sleep)
+    stderr = io.StringIO()
+    returncode = watchdog.run_guarded(
+        ("zombie-child",),
+        limit_bytes=16 * watchdog.MIB,
+        poll_interval=0.001,
+        snapshotter=snapshotter,
+        physical_footprint_probe=footprint,
+        stderr=stderr,
+    )
+
+    assert returncode == watchdog.WATCHDOG_ERROR_EXIT_CODE
+    assert process.poll_count >= 3
+    assert snapshot_count == 1
+    assert footprint_count == 1
+    assert (
+        f"reason={watchdog.DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON}"
+        in stderr.getvalue()
+    )
+    assert "child_exit=0" in stderr.getvalue()
+
+
+def test_repeated_required_footprint_probe_failure_is_fail_closed(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class RunningProcess:
+        pid = 43212
+
+        def __init__(self) -> None:
+            self.returncode: int | None = None
+
+        def poll(self) -> int | None:
+            return self.returncode
+
+        def wait(self, timeout: float) -> int:
+            del timeout
+            self.returncode = self.returncode or -9
+            return self.returncode
+
+    process = RunningProcess()
+    monkeypatch.setattr(
+        watchdog.subprocess,
+        "Popen",
+        lambda *_args, **_kwargs: process,
+    )
+
+    def record_signal(_pgid: int, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    monkeypatch.setattr(watchdog.os, "killpg", record_signal)
+    monkeypatch.setattr(watchdog.os, "kill", lambda *_args: None)
+    probe_count = 0
+
+    def snapshotter() -> dict[int, watchdog.ProcessInfo]:
+        return {
+            process.pid: watchdog.ProcessInfo(
+                process.pid,
+                1,
+                process.pid,
+                8 * watchdog.MIB,
+            )
+        }
+
+    def unavailable_footprint(_pids: object) -> dict[int, int]:
+        nonlocal probe_count
+        probe_count += 1
+        raise watchdog.ProbeError("synthetic footprint probe failure")
+
+    stderr = io.StringIO()
+    returncode = watchdog.run_guarded(
+        ("long-child",),
+        limit_bytes=16 * watchdog.MIB,
+        poll_interval=0.001,
+        terminate_grace=0,
+        snapshotter=snapshotter,
+        physical_footprint_probe=unavailable_footprint,
+        stderr=stderr,
+    )
+
+    assert returncode == watchdog.WATCHDOG_ERROR_EXIT_CODE
+    assert probe_count >= 3
+    assert "terminating after repeated memory probe failures" in stderr.getvalue()
+    assert (
+        f"reason={watchdog.DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON}"
+        in stderr.getvalue()
+    )
+
+
+def test_main_injects_darwin_footprint_probe(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured: dict[str, object] = {}
+
+    def probe(_pids: object) -> dict[int, int]:
+        return {}
+
+    def fake_run_guarded(
+        command: tuple[str, ...] | list[str],
+        **kwargs: object,
+    ) -> int:
+        captured["command"] = tuple(command)
+        captured.update(kwargs)
+        return 0
+
+    monkeypatch.setattr(watchdog.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(
+        watchdog,
+        "DarwinPhysicalFootprintProbe",
+        lambda: probe,
+    )
+    monkeypatch.setattr(watchdog, "run_guarded", fake_run_guarded)
+
+    assert watchdog.main(("--limit-mib", "32", "--", "synthetic-child")) == 0
+    assert captured["physical_footprint_probe"] is probe
+
+
+def test_main_fails_closed_when_darwin_probe_construction_fails(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    def fail_probe() -> object:
+        raise watchdog.ProbeError("synthetic constructor failure")
+
+    monkeypatch.setattr(watchdog.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(watchdog, "DarwinPhysicalFootprintProbe", fail_probe)
+
+    returncode = watchdog.main(
+        ("--limit-mib", "32", "--", "synthetic-child")
+    )
+
+    assert returncode == watchdog.WATCHDOG_ERROR_EXIT_CODE
+    assert (
+        f"reason={watchdog.DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON}"
+        in capsys.readouterr().err
+    )
+
+
+def test_main_uses_rss_only_on_non_darwin(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured: dict[str, object] = {}
+
+    def fake_run_guarded(
+        command: tuple[str, ...] | list[str],
+        **kwargs: object,
+    ) -> int:
+        captured["command"] = tuple(command)
+        captured.update(kwargs)
+        return 0
+
+    monkeypatch.setattr(watchdog.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(watchdog, "run_guarded", fake_run_guarded)
+
+    assert watchdog.main(("--limit-mib", "32", "--", "synthetic-child")) == 0
+    assert captured["physical_footprint_probe"] is None
+    assert captured["limit_bytes"] == 32 * watchdog.MIB
+
+
+def test_darwin_libproc_parsers_extract_identity_rss_and_cpu() -> None:
+    bsd = bytearray(136)
+    struct.pack_into("=I", bsd, 12, 123)
+    struct.pack_into("=I", bsd, 16, 45)
+    struct.pack_into("=I", bsd, 100, 67)
+    task = bytearray(96)
+    struct.pack_into("=Q", task, 8, 987_654_321)
+    struct.pack_into("=Q", task, 16, 4_000_000_000)
+    struct.pack_into("=Q", task, 24, 2_000_000_000)
+    rusage = bytearray(96)
+    struct.pack_into("=Q", rusage, 72, 1_234_567_890)
+
+    assert watchdog._parse_darwin_bsdinfo(bytes(bsd)) == (123, 45, 67)
+    assert watchdog._parse_darwin_taskinfo_rss(bytes(task)) == 987_654_321
+    assert watchdog._parse_darwin_taskinfo_cpu_seconds(
+        bytes(task),
+        timebase_numer=1,
+        timebase_denom=2,
+    ) == 3.0
+    assert watchdog._parse_darwin_rusage_phys_footprint(bytes(rusage)) == 1_234_567_890
+    with pytest.raises(ValueError, match="incomplete Darwin proc_bsdinfo"):
+        watchdog._parse_darwin_bsdinfo(b"short")
+    with pytest.raises(ValueError, match="incomplete Darwin proc_taskinfo"):
+        watchdog._parse_darwin_taskinfo_rss(b"short")
+    with pytest.raises(ValueError, match="incomplete Darwin proc_taskinfo CPU"):
+        watchdog._parse_darwin_taskinfo_cpu_seconds(
+            b"short", timebase_numer=1, timebase_denom=1
+        )
+    with pytest.raises(ValueError, match="invalid Darwin Mach timebase"):
+        watchdog._parse_darwin_taskinfo_cpu_seconds(
+            bytes(task), timebase_numer=1, timebase_denom=0
+        )
+    with pytest.raises(ValueError, match="incomplete Darwin rusage_info_v0"):
+        watchdog._parse_darwin_rusage_phys_footprint(b"short")
+
+
+def test_darwin_mach_timebase_is_validated() -> None:
+    class FakeMachTimebaseInfo:
+        argtypes: object = None
+        restype: object = None
+
+        def __init__(self, *, result: int = 0, numer: int = 125, denom: int = 3):
+            self.result = result
+            self.numer = numer
+            self.denom = denom
+
+        def __call__(self, pointer: object) -> int:
+            info = ctypes.cast(
+                pointer,
+                ctypes.POINTER(watchdog._MachTimebaseInfo),
+            ).contents
+            info.numer = self.numer
+            info.denom = self.denom
+            return self.result
+
+    class FakeLibrary:
+        def __init__(self, function: FakeMachTimebaseInfo) -> None:
+            self.mach_timebase_info = function
+
+    assert watchdog._darwin_mach_timebase(
+        FakeLibrary(FakeMachTimebaseInfo())
+    ) == (125, 3)
+    with pytest.raises(watchdog.ProbeError, match="mach_timebase_info failed"):
+        watchdog._darwin_mach_timebase(
+            FakeLibrary(FakeMachTimebaseInfo(result=5))
+        )
+    with pytest.raises(watchdog.ProbeError, match="mach_timebase_info failed"):
+        watchdog._darwin_mach_timebase(
+            FakeLibrary(FakeMachTimebaseInfo(denom=0))
+        )
+
+
+def test_fake_darwin_libproc_handles_success_race_and_unexpected_error() -> None:
+    class FakeProcPidRusage:
+        argtypes: object = None
+        restype: object = None
+
+        def __call__(
+            self,
+            pid: int,
+            _flavor: int,
+            buffer: object,
+        ) -> int:
+            if pid == 1:
+                payload = struct.pack("=Q", 987_654_321)
+                ctypes.memmove(
+                    ctypes.addressof(buffer) + 72,
+                    payload,
+                    len(payload),
+                )
+                return 0
+            ctypes.set_errno(errno.ESRCH if pid == 2 else errno.EACCES)
+            return -1
+
+    class FakeLibrary:
+        proc_pid_rusage = FakeProcPidRusage()
+
+    probe = watchdog.DarwinPhysicalFootprintProbe(
+        FakeLibrary(),
+        pid_exists=lambda _pid: True,
+    )
+
+    assert probe((1, 2)) == {1: 987_654_321}
+    with pytest.raises(watchdog.ProbeError, match="Permission denied"):
+        probe((3,))
+
+
+def test_darwin_footprint_probe_retries_transient_permission_race() -> None:
+    class FakeProcPidRusage:
+        argtypes: object = None
+        restype: object = None
+
+        def __init__(self) -> None:
+            self.calls = 0
+
+        def __call__(
+            self,
+            _pid: int,
+            _flavor: int,
+            buffer: object,
+        ) -> int:
+            self.calls += 1
+            if self.calls == 1:
+                ctypes.set_errno(errno.EPERM)
+                return -1
+            payload = struct.pack("=Q", 123_456_789)
+            ctypes.memmove(
+                ctypes.addressof(buffer) + 72,
+                payload,
+                len(payload),
+            )
+            return 0
+
+    class FakeLibrary:
+        proc_pid_rusage = FakeProcPidRusage()
+
+    library = FakeLibrary()
+    probe = watchdog.DarwinPhysicalFootprintProbe(library)
+
+    assert probe((7,)) == {7: 123_456_789}
+    assert library.proc_pid_rusage.calls == 2
+
+
+def test_darwin_footprint_probe_accepts_exit_after_permission_race() -> None:
+    class FakeProcPidRusage:
+        argtypes: object = None
+        restype: object = None
+
+        def __init__(self) -> None:
+            self.calls = 0
+
+        def __call__(
+            self,
+            _pid: int,
+            _flavor: int,
+            _buffer: object,
+        ) -> int:
+            self.calls += 1
+            ctypes.set_errno(errno.EPERM if self.calls == 1 else errno.ESRCH)
+            return -1
+
+    class FakeLibrary:
+        proc_pid_rusage = FakeProcPidRusage()
+
+    library = FakeLibrary()
+    probe = watchdog.DarwinPhysicalFootprintProbe(library)
+
+    assert probe((7,)) == {}
+    assert library.proc_pid_rusage.calls == 2
+
+
+def test_darwin_footprint_probe_omits_exited_pid_after_permission_retries() -> None:
+    class FakeProcPidRusage:
+        argtypes: object = None
+        restype: object = None
+
+        def __init__(self) -> None:
+            self.calls = 0
+
+        def __call__(
+            self,
+            _pid: int,
+            _flavor: int,
+            _buffer: object,
+        ) -> int:
+            self.calls += 1
+            ctypes.set_errno(errno.EPERM)
+            return -1
+
+    class FakeLibrary:
+        proc_pid_rusage = FakeProcPidRusage()
+
+    library = FakeLibrary()
+    probe = watchdog.DarwinPhysicalFootprintProbe(
+        library,
+        pid_exists=lambda pid: pid != 7,
+    )
+
+    assert probe((7,)) == {}
+    assert library.proc_pid_rusage.calls == 3
+
+
+def test_darwin_probe_constructor_rejects_missing_symbol() -> None:
+    with pytest.raises(watchdog.ProbeError, match="proc_pid_rusage"):
+        watchdog.DarwinPhysicalFootprintProbe(object())
+
+
+def test_platform_probe_rejects_unsupported_hosts() -> None:
+    with pytest.raises(watchdog.ProbeError, match="unsupported host"):
+        watchdog.process_snapshot("Plan9")
+
+
+@pytest.mark.skipif(
+    sys.platform not in {"darwin", "linux"},
+    reason="the CI memory probe supports macOS and Linux",
+)
+def test_host_probe_observes_current_process() -> None:
+    records = watchdog.process_snapshot()
+
+    assert os.getpid() in records
+    assert records[os.getpid()].rss_bytes > 0
+
+
+@pytest.mark.skipif(
+    sys.platform != "darwin",
+    reason="physical-footprint probing uses Darwin libproc",
+)
+def test_darwin_physical_footprint_probe_observes_current_process() -> None:
+    footprints = watchdog.DarwinPhysicalFootprintProbe()((os.getpid(),))
+
+    assert footprints[os.getpid()] > 0
+
+
+@pytest.mark.skipif(os.name != "posix", reason="process groups require POSIX")
+def test_exit_code_is_propagated() -> None:
+    completed = subprocess.run(
+        [
+            sys.executable,
+            str(WATCHDOG),
+            "--limit-mib",
+            "256",
+            "--poll-interval",
+            "0.02",
+            "--",
+            sys.executable,
+            "-c",
+            "raise SystemExit(23)",
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=10,
+    )
+
+    assert completed.returncode == 23
+    assert "command finished exit=23" in completed.stderr
+
+
+def _pid_exists(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+@pytest.mark.skipif(os.name != "posix", reason="process groups require POSIX")
+def test_low_limit_terminates_child_process_tree(tmp_path: Path) -> None:
+    marker = tmp_path / "child-terminated"
+    pid_path = tmp_path / "child.pid"
+    child = tmp_path / "child.py"
+    child.write_text(
+        """
+import os
+import signal
+import sys
+import time
+from pathlib import Path
+
+marker = Path(sys.argv[1])
+
+def terminate(_signum, _frame):
+    marker.write_text("terminated", encoding="ascii")
+    raise SystemExit(0)
+
+signal.signal(signal.SIGTERM, terminate)
+payload = bytearray(96 * 1024 * 1024)
+marker.with_suffix(".ready").write_text(str(len(payload)), encoding="ascii")
+time.sleep(30)
+""".lstrip(),
+        encoding="utf-8",
+    )
+    parent = tmp_path / "parent.py"
+    parent.write_text(
+        """
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+child = subprocess.Popen([sys.executable, sys.argv[1], sys.argv[2]])
+Path(sys.argv[3]).write_text(str(child.pid), encoding="ascii")
+time.sleep(30)
+""".lstrip(),
+        encoding="utf-8",
+    )
+
+    completed = subprocess.run(
+        [
+            sys.executable,
+            str(WATCHDOG),
+            "--limit-mib",
+            "64",
+            "--poll-interval",
+            "0.02",
+            "--terminate-grace",
+            "1",
+            "--",
+            sys.executable,
+            str(parent),
+            str(child),
+            str(marker),
+            str(pid_path),
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=15,
+    )
+
+    assert completed.returncode == watchdog.MEMORY_LIMIT_EXIT_CODE
+    assert "memory limit exceeded" in completed.stderr
+    assert f"reason={watchdog.RSS_LIMIT_REASON}" in completed.stderr or (
+        f"reason={watchdog.DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON}" in completed.stderr
+    )
+    assert marker.read_text(encoding="ascii") == "terminated"
+    child_pid = int(pid_path.read_text(encoding="ascii"))
+    deadline = time.monotonic() + 3
+    while _pid_exists(child_pid) and time.monotonic() < deadline:
+        time.sleep(0.02)
+    assert not _pid_exists(child_pid)
+
+
+def test_ci_helper_is_sdist_only_for_packaged_profiling_runtime() -> None:
+    pyproject = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+    includes = pyproject["tool"]["maturin"]["include"]
+    ci_entries = {
+        entry["path"]: entry.get("format")
+        for entry in includes
+        if isinstance(entry, dict)
+        and (
+            entry.get("path") == "tools/ci"
+            or str(entry.get("path", "")).startswith("tools/ci/")
+        )
+    }
+
+    assert ci_entries == {
+        "tools/ci/__init__.py": ["sdist"],
+        "tools/ci/memory_watchdog.py": ["sdist"],
+    }
+    assert not any(
+        isinstance(entry, str)
+        and (entry == "tools/ci" or entry.startswith("tools/ci/"))
+        for entry in includes
+    )
+
+
+# The CI workflow lives in the MadGraph7 repository that contains pyamplicol/.
+_MADGRAPH_WORKFLOW = ROOT.parent / ".github/workflows/pyamplicol.yml"
+
+
+@pytest.mark.skipif(
+    not _MADGRAPH_WORKFLOW.is_file(), reason="outside the MadGraph7 repository"
+)
+def test_tests_workflow_guards_every_heavy_validation_phase() -> None:
+    text = _MADGRAPH_WORKFLOW.read_text(encoding="utf-8")
+    workflow = text.split("\n  release-runtime:\n", 1)[1].split("\n  # ----", 1)[0]
+
+    assert text.startswith("name: pyAmpliCol\n")
+    assert 'python-version: ["3.11", "3.12", "3.13", "3.14"]' in text
+    assert "ulimit -v" not in workflow
+    assert "psutil" not in workflow
+    guarded = "tools/ci/memory_watchdog.py --limit-gib 30 --"
+    # The installer stages the native runtime within its guarded invocation.
+    # Restricted-mode and ordinary integration checks use separate invocations.
+    assert workflow.count(guarded) == 8
+    for heavy_command in (
+        "dependencies/install_dependencies.py",
+        "tests/unit/test_generation_execution_schema.py",
+        "tests/integration/test_schema_v3_generation_runtime.py",
+        "tests/integration/test_multilanguage_api.py",
+        "just rust-check",
+        "just rust-test",
+    ):
+        assert heavy_command in workflow
diff --git a/pyamplicol/tests/unit/test_cli_handlers.py b/pyamplicol/tests/unit/test_cli_handlers.py
new file mode 100644
index 0000000000..5a26254fd2
--- /dev/null
+++ b/pyamplicol/tests/unit/test_cli_handlers.py
@@ -0,0 +1,945 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import errno
+import io
+import json
+import os
+import pty
+import sys
+import termios
+import threading
+import types
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.api import BenchmarkResult, BenchmarkStatistics
+from pyamplicol.cli import run_cli
+from pyamplicol.cli.handlers import _load_process_output, _process_set
+from pyamplicol.config import (
+    BenchmarkConfig,
+    ConfigurationError,
+    ProcessConfig,
+    ProcessEntry,
+    RunConfig,
+)
+from pyamplicol.reporting import (
+    CallbackProgressSink,
+    ProgressEnd,
+    ProgressSink,
+    ProgressStart,
+    ProgressUpdate,
+    get_logger,
+)
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+class _Services:
+    def __init__(self, *, fail: bool = False) -> None:
+        self.fail = fail
+        self.config: RunConfig | None = None
+
+    def generate(self, config: RunConfig, progress: ProgressSink) -> object:
+        del progress
+        if self.fail:
+            raise ConfigurationError("generation rejected")
+        self.config = config
+        return {
+            "action": config.action,
+            "workers": config.generation.workers,
+            "requests": tuple(entry.expression for entry in config.process.entries),
+        }
+
+    def evaluate(self, config: RunConfig, progress: ProgressSink) -> object:
+        raise AssertionError((config, progress))
+
+    benchmark = evaluate
+    inspect = evaluate
+    model_inspect = evaluate
+    model_compile = evaluate
+    model_processes = evaluate
+    group_processes = evaluate
+
+
+class _ProfileServices(_Services):
+    def benchmark(self, config: RunConfig, progress: ProgressSink) -> object:
+        self.config = config
+        progress.emit(ProgressStart("runtime-benchmark", "Profiling runtime", 2))
+        progress.emit(ProgressUpdate("runtime-benchmark", 1, 2, "sampled"))
+        progress.emit(ProgressUpdate("runtime-benchmark", 2, 2, "sampled"))
+        progress.emit(ProgressEnd("runtime-benchmark"))
+        benchmark = BenchmarkConfig(
+            target_runtime=config.benchmark.target_runtime,
+            batch_size=config.benchmark.batch_size,
+            minimum_samples=config.benchmark.minimum_samples,
+        )
+        uncertainty = BenchmarkStatistics(1.0e-7, 5.0e-8, 0.05)
+        return BenchmarkResult(
+            requested_config=benchmark,
+            effective_config=benchmark,
+            sample_count=2,
+            wall_time_per_point=1.0e-6,
+            evaluator_time_per_point=8.0e-7,
+            uncertainty=uncertainty,
+            environment={
+                "elapsed_seconds": benchmark.target_runtime,
+                "platform": "test",
+                "wall_time_source": "runtime_evaluate_wall_time",
+                "evaluator_time_source": "runtime_profile_core_evaluator_call_time",
+            },
+            repetitions_per_sample=3,
+            evaluator_uncertainty=uncertainty,
+            process_id="d_dbar_to_z_g",
+            process_expression="d d~ > z g",
+        )
+
+
+class _InterruptedProfileServices(_Services):
+    def benchmark(self, config: RunConfig, progress: ProgressSink) -> object:
+        del config, progress
+        raise KeyboardInterrupt
+
+
+class _PartialProfileServices(_ProfileServices):
+    def benchmark(self, config: RunConfig, progress: ProgressSink) -> object:
+        result = super().benchmark(config, progress)
+        assert isinstance(result, BenchmarkResult)
+        return replace(result, interrupted=True)
+
+
+class _TtyCliServices(_ProfileServices):
+    def generate(self, config: RunConfig, progress: ProgressSink) -> object:
+        self.config = config
+        logger = get_logger("tty")
+        logger.info("generate before")
+        progress.emit(ProgressStart("generation", "Generating processes", 1))
+        progress.emit(
+            ProgressStart(
+                "generation:phase",
+                "Constructing a deliberately width-sensitive DAG",
+                2,
+                parent_task_id="generation",
+            )
+        )
+        progress.emit(ProgressUpdate("generation:phase", 1, 2, "first pass"))
+        logger.warning("generate during")
+        progress.emit(ProgressUpdate("generation:phase", 2, 2, "second pass"))
+        progress.emit(ProgressEnd("generation:phase"))
+        progress.emit(ProgressUpdate("generation", 1, 1))
+        progress.emit(ProgressEnd("generation"))
+        logger.info("generate after")
+        return {"action": "generate"}
+
+    def benchmark(self, config: RunConfig, progress: ProgressSink) -> object:
+        logger = get_logger("tty")
+        logger.info("profile before")
+        progress.emit(ProgressStart("profile-load", "Loading profile artifact", 1))
+        logger.warning("profile during load")
+        progress.emit(ProgressUpdate("profile-load", 1, 1, "loaded"))
+        progress.emit(ProgressEnd("profile-load"))
+        logger.info("profile between dashboards")
+        result = super().benchmark(config, progress)
+        logger.info("profile after")
+        return result
+
+
+class _TerminalScreen:
+    """Small ANSI emulator for the cursor/erase operations used by the dashboard."""
+
+    def __init__(self, *, columns: int, rows: int = 40) -> None:
+        self.columns = columns
+        self.rows = [[" "] * columns for _ in range(rows)]
+        self.row = 0
+        self.column = 0
+        self.frames: list[tuple[str, ...]] = []
+
+    def feed(self, payload: bytes) -> None:
+        text = payload.decode("utf-8", errors="replace")
+        index = 0
+        while index < len(text):
+            character = text[index]
+            if character == "\x1b" and index + 1 < len(text):
+                index = self._escape(text, index)
+                continue
+            if character == "\r":
+                self.column = 0
+            elif character == "\n":
+                self._move_down()
+            elif character not in {"\x00", "\x08"} and character >= " ":
+                self._write(character)
+            index += 1
+
+    def visible_lines(self) -> tuple[str, ...]:
+        return tuple(line for row in self.rows if (line := "".join(row).rstrip()))
+
+    def _escape(self, text: str, index: int) -> int:
+        if text[index + 1] != "[":
+            return index + 2
+        final = index + 2
+        while final < len(text) and not "@" <= text[final] <= "~":
+            final += 1
+        if final == len(text):
+            return final
+        parameters = text[index + 2 : final]
+        values = [int(value) if value else 0 for value in parameters.split(";")]
+        count = values[0] if values and values[0] else 1
+        command = text[final]
+        if command in {"F", "A"}:
+            self.row = max(self.row - count, 0)
+            if command == "F":
+                self.column = 0
+        elif command in {"E", "B"}:
+            for _ in range(count):
+                self._move_down()
+            if command == "E":
+                self.column = 0
+        elif command == "K":
+            start = 0 if values and values[0] == 2 else self.column
+            self.rows[self.row][start:] = [" "] * (self.columns - start)
+        elif command == "J":
+            self.frames.append(self.visible_lines())
+            self.rows[self.row][self.column :] = [" "] * (self.columns - self.column)
+            for row in range(self.row + 1, len(self.rows)):
+                self.rows[row] = [" "] * self.columns
+        return final + 1
+
+    def _write(self, character: str) -> None:
+        if self.column >= self.columns:
+            self._move_down()
+            self.column = 0
+        self.rows[self.row][self.column] = character
+        self.column += 1
+
+    def _move_down(self) -> None:
+        self.row += 1
+        if self.row < len(self.rows):
+            return
+        self.rows.pop(0)
+        self.rows.append([" "] * self.columns)
+        self.row = len(self.rows) - 1
+
+
+def _run_cli_in_pty(
+    arguments: tuple[str, ...],
+    *,
+    services: _TtyCliServices,
+    columns: int = 52,
+) -> tuple[int, bytes]:
+    master, slave = pty.openpty()
+    termios.tcsetwinsize(slave, (40, columns))
+    chunks: list[bytes] = []
+
+    def read_master() -> None:
+        while True:
+            try:
+                chunk = os.read(master, 65536)
+            except OSError as exc:
+                if exc.errno == errno.EIO:
+                    return
+                raise
+            if not chunk:
+                return
+            chunks.append(chunk)
+
+    reader = threading.Thread(target=read_master, daemon=True)
+    reader.start()
+    stderr = os.fdopen(os.dup(slave), "w", encoding="utf-8", buffering=1)
+    os.close(slave)
+    try:
+        status = run_cli(
+            arguments,
+            services=services,
+            stdout=io.StringIO(),
+            stderr=stderr,
+        )
+    finally:
+        stderr.close()
+    reader.join(timeout=2.0)
+    os.close(master)
+    assert not reader.is_alive()
+    return status, b"".join(chunks)
+
+
+def _assert_stable_tty_output(
+    payload: bytes,
+    *,
+    expected_statuses: tuple[str, ...],
+    dashboard_text: str,
+    columns: int = 52,
+) -> None:
+    assert b"\x00" not in payload
+    assert b"\x1b[" in payload
+    assert dashboard_text.encode() in payload
+
+    terminal = _TerminalScreen(columns=columns)
+    terminal.feed(payload)
+    assert terminal.visible_lines() == expected_statuses
+    assert any(
+        any(dashboard_text in line for line in frame) for frame in terminal.frames
+    )
+    for frame in (*terminal.frames, terminal.visible_lines()):
+        assert all(len(line) < columns for line in frame)
+        for status in expected_statuses:
+            assert sum(status in line for line in frame) <= 1
+
+
+def test_generate_tty_dashboard_preserves_status_lines_and_terminal_width(
+    tmp_path: Path,
+) -> None:
+    status, payload = _run_cli_in_pty(
+        (
+            "generate",
+            "d d~ > z g",
+            str(tmp_path / "artifact"),
+            "--json",
+            "--progress",
+            "tty",
+            "--color",
+            "never",
+        ),
+        services=_TtyCliServices(),
+    )
+
+    assert status == 0
+    _assert_stable_tty_output(
+        payload,
+        expected_statuses=(
+            "INFO pyamplicol.tty: generate before",
+            "WARNING pyamplicol.tty: generate during",
+            "INFO pyamplicol.tty: generate after",
+        ),
+        dashboard_text="Generating processes",
+    )
+
+
+def test_profile_tty_dashboard_closes_between_lifecycle_roots(
+    tmp_path: Path,
+) -> None:
+    status, payload = _run_cli_in_pty(
+        (
+            "profile",
+            str(tmp_path / "artifact"),
+            "--json",
+            "--progress",
+            "tty",
+            "--color",
+            "never",
+        ),
+        services=_TtyCliServices(),
+    )
+
+    assert status == 0
+    _assert_stable_tty_output(
+        payload,
+        expected_statuses=(
+            "INFO pyamplicol.tty: profile before",
+            "WARNING pyamplicol.tty: profile during load",
+            "INFO pyamplicol.tty: profile between dashboards",
+            "INFO pyamplicol.tty: profile after",
+        ),
+        dashboard_text="Profiling runtime",
+    )
+
+
+def test_typed_config_entries_preserve_complete_process_set_behavior() -> None:
+    config = RunConfig(
+        action="generate",
+        process=ProcessConfig(
+            entries=(
+                ProcessEntry("d d~ > z g", "ddbar_zg"),
+                ProcessEntry("u u~ > z g"),
+            )
+        ),
+    )
+
+    processes = _process_set(config)
+
+    assert tuple(request.expression for request in processes.requests) == (
+        "d d~ > z g",
+        "u u~ > z g",
+    )
+    assert processes.requests[0].name == "ddbar_zg"
+    assert processes.requests[1].name == "u_ubar_to_z_g"
+
+
+def test_process_output_loading_emits_visible_timed_progress(tmp_path: Path) -> None:
+    events: list[object] = []
+    progress = CallbackProgressSink(events.append)
+
+    result = _load_process_output(tmp_path / "artifact", progress, lambda: "loaded")
+
+    assert result == "loaded"
+    assert isinstance(events[0], ProgressStart)
+    assert str((tmp_path / "artifact").resolve()) in events[0].description
+    assert isinstance(events[-1], ProgressEnd)
+    assert events[-1].success is True
+    assert events[-1].elapsed_seconds is not None
+
+
+def test_cli_dispatches_protocol_and_keeps_json_on_stdout(tmp_path: Path) -> None:
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    services = _Services()
+    sys.modules.pop("symbolica", None)
+    status = run_cli(
+        (
+            "generate",
+            "d d~ > z g",
+            str(tmp_path / "artifact"),
+            "--workers",
+            "3",
+            "--json",
+            "--progress",
+            "off",
+        ),
+        services=services,
+        stdout=stdout,
+        stderr=stderr,
+    )
+    assert status == 0
+    assert json.loads(stdout.getvalue()) == {
+        "action": "generate",
+        "requests": ["d d~ > z g"],
+        "workers": 3,
+    }
+    assert stderr.getvalue() == ""
+    assert services.config is not None
+    assert "symbolica" not in sys.modules
+
+
+def test_group_processes_command_calls_the_public_api(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[tuple[Path, dict[str, object]]] = []
+
+    def group_processes(artifact: Path, **options: object) -> dict[str, object]:
+        calls.append((artifact, options))
+        return {"artifact": str(artifact), "merged": 0}
+
+    module = types.ModuleType("pyamplicol.api.process_groups")
+    module.group_processes = group_processes  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, "pyamplicol.api.process_groups", module)
+    stdout = io.StringIO()
+    status = run_cli(
+        (
+            "group-processes",
+            str(tmp_path / "artifact"),
+            "--only-unit-multiplier",
+            "--json",
+            "--progress",
+            "off",
+        ),
+        stdout=stdout,
+        stderr=io.StringIO(),
+    )
+
+    assert status == 0
+    assert calls == [
+        (
+            (tmp_path / "artifact").resolve(),
+            {
+                "analysis": "numerical",
+                "only_unit_multiplier": True,
+                "consider_charge_conjugation": True,
+            },
+        )
+    ]
+    assert json.loads(stdout.getvalue())["merged"] == 0
+
+
+def test_cli_defaults_to_a_colored_table_for_structured_results(
+    tmp_path: Path,
+) -> None:
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    status = run_cli(
+        (
+            "generate",
+            "d d~ > z g",
+            str(tmp_path / "artifact"),
+            "--workers",
+            "3",
+            "--color",
+            "always",
+            "--progress",
+            "off",
+        ),
+        services=_Services(),
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 0
+    output = stdout.getvalue()
+    assert "pyAmpliCol Result" in output
+    assert "workers" in output
+    assert "\x1b[" in output
+    with pytest.raises(json.JSONDecodeError):
+        json.loads(output)
+    assert stderr.getvalue() == ""
+
+
+def test_cli_failures_write_only_diagnostics_to_stderr(tmp_path: Path) -> None:
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    status = run_cli(
+        (
+            "generate",
+            "d d~ > z g",
+            str(tmp_path / "artifact"),
+            "--json",
+        ),
+        services=_Services(fail=True),
+        stdout=stdout,
+        stderr=stderr,
+    )
+    assert status == 2
+    assert stdout.getvalue() == ""
+    assert "generation rejected" in stderr.getvalue()
+
+
+def test_profile_json_is_stdout_clean_and_uses_benchmark_service(
+    tmp_path: Path,
+) -> None:
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    services = _ProfileServices()
+
+    status = run_cli(
+        (
+            "profile",
+            str(tmp_path / "artifact"),
+            "--process",
+            "d d~ > z g",
+            "--target-runtime",
+            "0.1",
+            "--batch-size",
+            "4",
+            "--minimum-samples",
+            "2",
+            "--json",
+            "--progress",
+            "log",
+        ),
+        services=services,
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 0
+    payload = json.loads(stdout.getvalue())
+    assert payload["process_id"] == "d_dbar_to_z_g"
+    assert payload["repetitions_per_sample"] == 3
+    assert "Runtime Profile" not in stdout.getvalue()
+    assert "\x1b[" not in stdout.getvalue()
+    assert "Profiling runtime" in stderr.getvalue()
+    assert services.config is not None
+    assert services.config.action == "benchmark"
+    assert services.config.evaluation.process == "d d~ > z g"
+
+
+def test_profile_interrupted_before_sampling_exits_without_traceback(
+    tmp_path: Path,
+) -> None:
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+
+    status = run_cli(
+        ("profile", str(tmp_path / "artifact"), "--progress", "off"),
+        services=_InterruptedProfileServices(),
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 130
+    assert stdout.getvalue() == ""
+    assert "interrupted before a complete result was available" in stderr.getvalue()
+
+
+def test_partial_profile_prints_result_and_exits_as_interrupted(tmp_path: Path) -> None:
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+
+    status = run_cli(
+        (
+            "profile",
+            str(tmp_path / "artifact"),
+            "--json",
+            "--progress",
+            "off",
+        ),
+        services=_PartialProfileServices(),
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 130
+    assert json.loads(stdout.getvalue())["interrupted"] is True
+    assert stderr.getvalue() == ""
+
+
+def test_inspect_cli_lists_artifact_processes_as_json() -> None:
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    artifact = ROOT / "src/pyamplicol/assets/selftest/portable-64le/artifact"
+
+    status = run_cli(
+        ("inspect", str(artifact), "--json", "--progress", "off"),
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 0
+    payload = json.loads(stdout.getvalue())
+    assert payload["kind"] == "pyamplicol-artifact-inspection"
+    assert payload["default_process_id"] == "d_dbar_to_z"
+    assert payload["processes"][0]["expression"] == "d d~ > z"
+    assert stderr.getvalue() == ""
+
+
+def _inspection_with_alias() -> object:
+    from pyamplicol.artifacts import inspect_artifact
+    from pyamplicol.artifacts.inspection import ArtifactAliasInspection
+
+    artifact = ROOT / "src/pyamplicol/assets/selftest/portable-64le/artifact"
+    inspection = inspect_artifact(artifact)
+    representative = inspection.processes[0]
+    alias = ArtifactAliasInspection(
+        id="stable-alias",
+        expression="alias exact expression",
+        representative_id=representative.id,
+        external_pdgs=representative.external_pdgs,
+    )
+    return replace(
+        inspection,
+        processes=(replace(representative, aliases=(alias,)),),
+    )
+
+
+@pytest.mark.parametrize(
+    "selector",
+    ("d_dbar_to_z", "stable-alias", "d d~ > z"),
+)
+def test_inspect_process_defaults_to_compact_metadata_without_runtime(
+    selector: str,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol.api as api_module
+    import pyamplicol.artifacts as artifact_module
+
+    inspection = _inspection_with_alias()
+
+    class ForbiddenRuntime:
+        @classmethod
+        def load(cls, *_args: object, **_kwargs: object) -> object:
+            raise AssertionError("compact inspection loaded Runtime.physics")
+
+    monkeypatch.setattr(artifact_module, "inspect_artifact", lambda _path: inspection)
+    monkeypatch.setattr(api_module, "Runtime", ForbiddenRuntime)
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+
+    status = run_cli(
+        (
+            "inspect",
+            str(tmp_path / "artifact"),
+            "--process",
+            selector,
+            "--json",
+            "--progress",
+            "off",
+        ),
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 0
+    payload = json.loads(stdout.getvalue())
+    assert payload["kind"] == "pyamplicol-artifact-inspection"
+    assert [process["id"] for process in payload["processes"]] == ["d_dbar_to_z"]
+    assert stderr.getvalue() == ""
+
+
+# Rusticol resolves full-physics selectors, including side permutations and
+# non-generated process-group members absent from the compact inventory.
+@pytest.mark.parametrize("selector", ("stable-alias", "u u~ > a a"))
+def test_inspect_full_physics_is_the_only_runtime_materialization_path(
+    selector: str,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol.api as api_module
+    import pyamplicol.artifacts as artifact_module
+
+    inspection = _inspection_with_alias()
+    loads: list[tuple[Path, str | None]] = []
+    dense_physics = {"kind": "dense-legacy-physics"}
+
+    class DenseRuntime:
+        physics = dense_physics
+
+        @classmethod
+        def load(
+            cls,
+            artifact: Path,
+            *,
+            process: str | None = None,
+        ) -> DenseRuntime:
+            loads.append((artifact, process))
+            return cls()
+
+    monkeypatch.setattr(artifact_module, "inspect_artifact", lambda _path: inspection)
+    monkeypatch.setattr(api_module, "Runtime", DenseRuntime)
+    artifact = tmp_path / "artifact"
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+
+    status = run_cli(
+        (
+            "inspect",
+            str(artifact),
+            "--process",
+            selector,
+            "--full-physics",
+            "--json",
+            "--progress",
+            "off",
+        ),
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 0
+    assert json.loads(stdout.getvalue()) == dense_physics
+    assert loads == [(artifact.resolve(), selector)]
+    assert stderr.getvalue() == ""
+
+
+def test_inspect_process_keeps_only_the_selected_process_group(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol.artifacts as artifact_module
+    from pyamplicol.artifacts.inspection import (
+        ArtifactProcessGroupInspection,
+        ArtifactProcessGroupMemberInspection,
+        ArtifactProcessGroupsInspection,
+    )
+
+    def group(identifier: str, process: str) -> ArtifactProcessGroupInspection:
+        member = ArtifactProcessGroupMemberInspection(
+            id=identifier,
+            process=process,
+            pdgs=(1, -1, 23),
+            initial_count=2,
+            factor="1",
+            permutation=(0, 1, 2),
+            conjugated=False,
+            basis="identity",
+            generated=True,
+        )
+        return ArtifactProcessGroupInspection(identifier, process, (member,))
+
+    inspection = replace(
+        _inspection_with_alias(),
+        process_groups=ArtifactProcessGroupsInspection(
+            stored=True,
+            groups=(group("d_dbar_to_z", "d d~ > z"), group("u_ubar_to_z", "u u~ > z")),
+        ),
+    )
+    monkeypatch.setattr(artifact_module, "inspect_artifact", lambda _path: inspection)
+    stdout = io.StringIO()
+
+    status = run_cli(
+        (
+            "inspect",
+            str(tmp_path / "artifact"),
+            "--process",
+            "stable-alias",
+            "--json",
+            "--progress",
+            "off",
+        ),
+        stdout=stdout,
+        stderr=io.StringIO(),
+    )
+
+    assert status == 0
+    groups = json.loads(stdout.getvalue())["process_groups"]["groups"]
+    assert [group["representative_id"] for group in groups] == ["d_dbar_to_z"]
+
+
+def test_inspect_process_names_the_group_of_a_routed_member(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol.artifacts as artifact_module
+    from pyamplicol.artifacts.inspection import (
+        ArtifactProcessGroupInspection,
+        ArtifactProcessGroupMemberInspection,
+        ArtifactProcessGroupsInspection,
+    )
+
+    def member(
+        identifier: str, process: str, *, generated: bool
+    ) -> ArtifactProcessGroupMemberInspection:
+        return ArtifactProcessGroupMemberInspection(
+            id=identifier,
+            process=process,
+            pdgs=(1, -1, 23),
+            initial_count=2,
+            factor="1",
+            permutation=(0, 1, 2),
+            conjugated=False,
+            basis="flavor-blind" if not generated else "identity",
+            generated=generated,
+        )
+
+    inspection = replace(
+        _inspection_with_alias(),
+        process_groups=ArtifactProcessGroupsInspection(
+            stored=True,
+            groups=(
+                ArtifactProcessGroupInspection(
+                    "d_dbar_to_z",
+                    "d d~ > z",
+                    (
+                        member("d_dbar_to_z", "d d~ > z", generated=True),
+                        member("u_ubar_to_z", "u u~ > z", generated=False),
+                    ),
+                ),
+            ),
+        ),
+    )
+    monkeypatch.setattr(artifact_module, "inspect_artifact", lambda _path: inspection)
+
+    for selector in ("u_ubar_to_z", "u u~ > z", "s s~ > z"):
+        stderr = io.StringIO()
+        status = run_cli(
+            (
+                "inspect",
+                str(tmp_path / "artifact"),
+                "--process",
+                selector,
+                "--progress",
+                "off",
+            ),
+            stdout=io.StringIO(),
+            stderr=stderr,
+        )
+
+        assert status == 2
+        message = " ".join(stderr.getvalue().split())
+        if selector == "s s~ > z":
+            assert "did not match a stable representative ID" in message
+            continue
+        assert (
+            "inspect process u_ubar_to_z (u u~ > z) is a routed member of process "
+            "group d_dbar_to_z (d d~ > z) with no runtime of its own; --process "
+            "d_dbar_to_z lists the group, and --full-physics shows the member's "
+            "relation and physics"
+        ) in message
+
+
+def test_inspect_full_physics_adds_the_process_group_of_a_grouped_selection(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol.api as api_module
+    import pyamplicol.artifacts.inspection as inspection_module
+    from pyamplicol.api import (
+        ColorFlow,
+        HelicityConfiguration,
+        PhysicsReduction,
+        ProcessPhysics,
+        ReductionGroup,
+    )
+    from pyamplicol.artifacts.inspection import ArtifactProcessGroupSelection
+
+    physics = ProcessPhysics(
+        process_id="u_ubar_to_z",
+        process="u u~ > z",
+        color_accuracy="lc",
+        helicity_coverage="complete",
+        color_coverage="complete",
+        color_kind="flow",
+        structural_zero_helicity_count=0,
+        external_particles=(),
+        helicities=(
+            HelicityConfiguration("h0", 0, (1, -1, 0), True, False, "h0", 1.0),
+        ),
+        color_flows=(ColorFlow("c0", 0, (1, 2), True, "c0", 1.0),),
+        contracted_color_components=(),
+        reduction=PhysicsReduction(
+            "lc-diagonal", (ReductionGroup("g0", "h0", "c0", ("h0",), ("c0",)),)
+        ),
+        model_parameters=(),
+        selector_capabilities=("helicity", "color_flow"),
+    )
+    selection = ArtifactProcessGroupSelection(
+        process_id="u_ubar_to_z",
+        role="routed member",
+        representative_id="d_dbar_to_z",
+        representative="d d~ > z",
+        factor="1",
+        permutation=(1, 0, 2),
+        conjugated=False,
+        basis="flavor-blind",
+        warning=None,
+        group_size=2,
+        routed_count=1,
+        conjugated_count=0,
+    )
+    requests: list[tuple[Path, str, tuple[int, ...] | None]] = []
+
+    class MemberRuntime:
+        external_permutation = (1, 0, 2)
+
+        def __init__(self) -> None:
+            self.physics = physics
+
+        @classmethod
+        def load(cls, _artifact: Path, *, process: str | None = None) -> object:
+            return cls()
+
+    def select(
+        artifact: Path,
+        process_id: str,
+        *,
+        permutation: tuple[int, ...] | None = None,
+    ) -> ArtifactProcessGroupSelection:
+        requests.append((artifact, process_id, permutation))
+        return selection
+
+    monkeypatch.setattr(api_module, "Runtime", MemberRuntime)
+    monkeypatch.setattr(inspection_module, "process_group_selection", select)
+    artifact = tmp_path / "artifact"
+    stdout = io.StringIO()
+
+    status = run_cli(
+        (
+            "inspect",
+            str(artifact),
+            "--process",
+            "u~ u > z",
+            "--full-physics",
+            "--json",
+            "--progress",
+            "off",
+        ),
+        stdout=stdout,
+        stderr=io.StringIO(),
+    )
+
+    assert status == 0
+    payload = json.loads(stdout.getvalue())
+    assert payload["process_id"] == "u_ubar_to_z"
+    assert payload["helicities"][0]["id"] == "h0"
+    assert payload["process_group"]["representative_id"] == "d_dbar_to_z"
+    assert payload["process_group"]["permutation"] == [1, 0, 2]
+    assert requests == [(artifact.resolve(), "u_ubar_to_z", (1, 0, 2))]
diff --git a/pyamplicol/tests/unit/test_cli_licensing.py b/pyamplicol/tests/unit/test_cli_licensing.py
new file mode 100644
index 0000000000..116ef6c6df
--- /dev/null
+++ b/pyamplicol/tests/unit/test_cli_licensing.py
@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import io
+import json
+
+import pytest
+
+from pyamplicol.cli import LicenseRequestInvocation, parse_cli, run_cli
+
+
+class _TTYStringIO(io.StringIO):
+    def isatty(self) -> bool:
+        return True
+
+
+def test_trial_request_parses_without_entering_run_configuration() -> None:
+    invocation = parse_cli(
+        [
+            "request-symbolica-trial-license",
+            "--name",
+            "Ada",
+            "--email",
+            "ada@example.org",
+            "--organization",
+            "Institute",
+            "--yes",
+        ]
+    )
+    assert isinstance(invocation, LicenseRequestInvocation)
+    assert invocation.kind == "trial"
+    assert invocation.assume_yes
+
+
+def test_noninteractive_request_requires_all_fields_and_yes() -> None:
+    invocation = LicenseRequestInvocation(
+        kind="hobbyist",
+        name="Ada",
+        email=None,
+        assume_yes=True,
+    )
+    with pytest.raises(ValueError, match="missing email"):
+        invocation.run(stdin=io.StringIO(), stdout=io.StringIO())
+
+
+def test_license_request_uses_table_by_default_and_json_only_when_requested(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    requests: list[tuple[str, str]] = []
+    monkeypatch.setattr(
+        "pyamplicol.cli.licensing.request_hobbyist_license",
+        lambda name, email: requests.append((name, email)),
+    )
+    arguments = (
+        "request-symbolica-hobbyist-license",
+        "--name",
+        "Ada",
+        "--email",
+        "ada@example.org",
+        "--yes",
+    )
+
+    human = io.StringIO()
+    assert run_cli((*arguments, "--color", "always"), stdout=human) == 0
+    assert "Symbolica License Request" in human.getvalue()
+    assert "accepted" in human.getvalue()
+    assert "ada@example.org" not in human.getvalue()
+    assert "\x1b[" in human.getvalue()
+
+    machine = io.StringIO()
+    assert run_cli((*arguments, "--json"), stdout=machine) == 0
+    assert json.loads(machine.getvalue()) == {
+        "next_step": "The license key will be sent by email.",
+        "request": "hobbyist",
+        "status": "accepted",
+    }
+    assert "\x1b[" not in machine.getvalue()
+    assert requests == [
+        ("Ada", "ada@example.org"),
+        ("Ada", "ada@example.org"),
+    ]
+
+
+def test_json_license_request_never_prompts_on_stdout() -> None:
+    stdout = _TTYStringIO()
+    stderr = io.StringIO()
+    status = run_cli(
+        ("request-symbolica-hobbyist-license", "--json"),
+        stdin=_TTYStringIO("Ada\nada@example.org\nyes\n"),
+        stdout=stdout,
+        stderr=stderr,
+    )
+    assert status == 2
+    assert stdout.getvalue() == ""
+    assert "all fields and --yes" in stderr.getvalue()
diff --git a/pyamplicol/tests/unit/test_cli_model_commands.py b/pyamplicol/tests/unit/test_cli_model_commands.py
new file mode 100644
index 0000000000..d1b38fff61
--- /dev/null
+++ b/pyamplicol/tests/unit/test_cli_model_commands.py
@@ -0,0 +1,354 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.cli import DefaultCliServices, parse_cli
+from pyamplicol.config import ConfigurationError, EvaluatorBackend, EvaluatorConfig
+from pyamplicol.models.contracts import CompiledModelIR, CompiledParticleRecord
+from pyamplicol.reporting import NullProgressSink
+
+
+class _CompiledModel:
+    ir = CompiledModelIR(
+        name="toy",
+        orders=(),
+        parameters=(),
+        particles=(
+            CompiledParticleRecord(
+                "d",
+                "d~",
+                1,
+                2,
+                3,
+                "ZERO",
+                "ZERO",
+                -1.0 / 3.0,
+                (("electric_charge", "-1/3"),),
+                0,
+                True,
+                False,
+                None,
+            ),
+            CompiledParticleRecord(
+                "d~",
+                "d",
+                -1,
+                2,
+                -3,
+                "ZERO",
+                "ZERO",
+                1.0 / 3.0,
+                (("electric_charge", "1/3"),),
+                0,
+                True,
+                False,
+                None,
+            ),
+            CompiledParticleRecord(
+                "z",
+                "z",
+                23,
+                3,
+                1,
+                "MZ",
+                "WZ",
+                0.0,
+                (("electric_charge", "0"),),
+                0,
+                True,
+                False,
+                None,
+            ),
+        ),
+        couplings=(),
+        propagators=(),
+        vertex_terms=(),
+        oriented_kernels=(),
+        direct_contractions=(),
+        closure_contractions=(),
+    )
+
+    def __init__(self) -> None:
+        self.name = "toy"
+        self.supported = True
+        self.source = {"kind": "built-in-sm"}
+        self.producer = {"pyamplicol": "test"}
+        self.capabilities = {"particle_count": 3}
+        self.issues: tuple[object, ...] = ()
+        self.conversion_seconds = 0.25
+        self.phase_timings = {"total": 0.25}
+        self.parameter_defaults = {"mass": (1.0, 0.0)}
+
+    def write(self, path: Path) -> Path:
+        return path.with_name(path.name + ".pyAmplicol-model.json")
+
+
+def test_default_model_compile_calls_existing_compiler_service(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol.models import loading, prepared_compile
+
+    calls: list[dict[str, object]] = []
+
+    def compile_model_source(source: str, **options: object) -> _CompiledModel:
+        calls.append({"source": source, **options})
+        return _CompiledModel()
+
+    monkeypatch.setattr(loading, "compile_model_source", compile_model_source)
+    monkeypatch.setattr(
+        prepared_compile,
+        "prepare_model_bundle",
+        lambda *_args, **_kwargs: pytest.fail(
+            "IR-only model compilation must not prepare evaluator kernels"
+        ),
+    )
+    output = tmp_path / "toy"
+    invocation = parse_cli(("model", "compile", "built-in-sm", str(output)))
+    result = DefaultCliServices().model_compile(
+        invocation.resolve().effective,
+        NullProgressSink(),
+    )
+
+    assert calls == [
+        {
+            "source": "built-in-sm",
+            "restriction": "default",
+            "simplify": True,
+            "cache_dir": None,
+            "use_cache": True,
+            "require_supported": True,
+        }
+    ]
+    assert result == {
+        "model": "toy",
+        "supported": True,
+        "output": str(output) + ".pyAmplicol-model.json",
+        "conversion_seconds": 0.25,
+        "phase_timings": {"total": 0.25},
+        "source": {"kind": "built-in-sm"},
+        "capabilities": {"particle_count": 3},
+    }
+
+
+def test_model_inspect_routes_builtin_sm_heft_through_packaged_compiler(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol._internal import sm_heft
+
+    calls: list[dict[str, object]] = []
+
+    def compile_sm_heft_source(**options: object) -> _CompiledModel:
+        calls.append(options)
+        compiled = _CompiledModel()
+        compiled.name = "built-in-sm-heft"
+        compiled.source = {"kind": "built-in-sm-heft"}
+        return compiled
+
+    monkeypatch.setattr(sm_heft, "compile_sm_heft_source", compile_sm_heft_source)
+    invocation = parse_cli(("model", "inspect", "built-in-sm-heft"))
+    result = DefaultCliServices().model_inspect(
+        invocation.resolve().effective,
+        NullProgressSink(),
+    )
+
+    assert calls == [
+        {
+            "cache_dir": None,
+            "use_cache": True,
+            "require_supported": False,
+        }
+    ]
+    assert result["name"] == "built-in-sm-heft"
+    assert result["source"] == {"kind": "built-in-sm-heft"}
+
+
+def test_default_model_compile_prepares_one_requested_backend_pack(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol.models import loading, prepared_compile
+
+    compiled = _CompiledModel()
+    monkeypatch.setattr(
+        loading,
+        "compile_model_source",
+        lambda *args, **kwargs: compiled,
+    )
+    captured: dict[str, object] = {}
+
+    def prepare_model_bundle(
+        model: object,
+        output: Path,
+        *,
+        evaluator: object,
+        progress: object,
+    ) -> object:
+        captured.update(
+            model=model,
+            output=output,
+            evaluator=evaluator,
+            progress=progress,
+        )
+        assert callable(progress)
+        progress("prepare kernel 0", 0, 1)
+        progress("prepared model complete", 1, 1)
+        return SimpleNamespace(
+            output=output,
+            bundle=SimpleNamespace(backend="jit"),
+            kernel_count=1,
+            phase_timings_seconds={"catalog": 0.1, "total": 0.3},
+        )
+
+    monkeypatch.setattr(
+        prepared_compile,
+        "prepare_model_bundle",
+        prepare_model_bundle,
+    )
+    output = tmp_path / "toy.pyamplicol-model"
+    invocation = parse_cli(
+        (
+            "model",
+            "compile",
+            "built-in-sm",
+            str(output),
+            "--backend",
+            "jit",
+            "--horner-iterations",
+            "7",
+            "--cpe-iterations",
+            "3",
+            "--cores",
+            "2",
+            "--max-horner-variables",
+            "321",
+            "--max-common-pair-cache-entries",
+            "456",
+            "--max-common-pair-distance",
+            "78",
+            "--collect-factors",
+            "--no-jit-compress",
+        )
+    )
+    config = invocation.resolve().effective
+
+    assert config.evaluator.backend is EvaluatorBackend.JIT
+    assert config.evaluator.jit.optimization_level == 2
+    assert config.evaluator.jit.compress is False
+    assert config.evaluator.optimization.horner_iterations == 7
+    assert config.evaluator.optimization.cpe_iterations == 3
+    assert config.evaluator.optimization.cores == 2
+    assert config.evaluator.optimization.max_horner_variables == 321
+    assert config.evaluator.optimization.max_common_pair_cache_entries == 456
+    assert config.evaluator.optimization.max_common_pair_distance == 78
+    assert config.evaluator.optimization.collect_factors is True
+
+    result = DefaultCliServices().model_compile(config, NullProgressSink())
+
+    assert captured["model"] is compiled
+    assert captured["output"] == output.resolve()
+    assert captured["evaluator"] is config.evaluator
+    assert result["output"] == str(output.resolve())
+    assert result["prepared_backend"] == "jit"
+    assert result["kernel_count"] == 1
+    assert result["preparation_phase_timings"] == {
+        "catalog": 0.1,
+        "total": 0.3,
+    }
+
+
+@pytest.mark.parametrize(
+    ("flags", "expected"),
+    (((), False), (("--jit-compress",), True), (("--no-jit-compress",), False)),
+)
+def test_model_compile_jit_compression_selection(
+    tmp_path: Path, flags: tuple[str, ...], expected: bool
+) -> None:
+    config = (
+        parse_cli(
+            (
+                "model",
+                "compile",
+                "built-in-sm",
+                str(tmp_path / "model.pyamplicol-model"),
+                *flags,
+            )
+        )
+        .resolve()
+        .effective
+    )
+    assert config.evaluator.jit.compress is expected
+
+
+def test_model_compile_rejects_evaluator_options_for_ir_output(
+    tmp_path: Path,
+) -> None:
+    with pytest.raises(
+        ConfigurationError,
+        match=r"evaluator options require.*\.pyamplicol-model",
+    ):
+        parse_cli(
+            (
+                "model",
+                "compile",
+                "built-in-sm",
+                str(tmp_path / "toy.json"),
+                "--backend",
+                "jit",
+            )
+        )
+
+
+def test_model_compile_service_rejects_nondefault_card_evaluator_for_ir(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol.models import loading
+
+    monkeypatch.setattr(
+        loading,
+        "compile_model_source",
+        lambda *args, **kwargs: _CompiledModel(),
+    )
+    invocation = parse_cli(
+        ("model", "compile", "built-in-sm", str(tmp_path / "toy.json"))
+    )
+    config = replace(
+        invocation.resolve().effective,
+        evaluator=EvaluatorConfig(backend=EvaluatorBackend.ASM),
+    )
+
+    with pytest.raises(
+        ConfigurationError,
+        match=r"evaluator settings require.*\.pyamplicol-model",
+    ):
+        DefaultCliServices().model_compile(config, NullProgressSink())
+
+
+def test_default_model_processes_uses_compiled_model_catalog(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol.models import loading
+
+    monkeypatch.setattr(
+        loading,
+        "compile_model_source",
+        lambda *args, **kwargs: _CompiledModel(),
+    )
+    invocation = parse_cli(("model", "processes", "d d~ > z"))
+    result = DefaultCliServices().model_processes(
+        invocation.resolve().effective,
+        NullProgressSink(),
+    )
+
+    assert isinstance(result, dict)
+    assert result["model"] == "toy"
+    assert result["n_entries"] == 1
+    entry = result["entries"][0]
+    assert entry["process"] == "d d~ > z"
+    assert entry["ir"]["outgoing_pdgs"] == [-1, 1, 23]
diff --git a/pyamplicol/tests/unit/test_cli_parser.py b/pyamplicol/tests/unit/test_cli_parser.py
new file mode 100644
index 0000000000..a6857151b9
--- /dev/null
+++ b/pyamplicol/tests/unit/test_cli_parser.py
@@ -0,0 +1,726 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.cli import build_parser, parse_cli
+from pyamplicol.config import (
+    ColorContraction,
+    ColorFFTBasis,
+    ConfigurationError,
+    EvaluatorExecutionMode,
+    LCFlowLayout,
+    ProcessEntry,
+    ProcessGroupAnalysis,
+    RelationDiscoveryMode,
+)
+
+
+def test_direct_command_flags_then_ordered_set_overrides(tmp_path: Path) -> None:
+    invocation = parse_cli(
+        (
+            "generate",
+            "d d~ > z g",
+            str(tmp_path / "artifact"),
+            "--workers",
+            "4",
+            "--color-accuracy",
+            "nlc",
+            "--set",
+            "generation.workers=2",
+            "--set",
+            "generation.workers=1",
+        )
+    )
+    config = invocation.resolve().effective
+    assert config.action == "generate"
+    assert config.process.entries == (ProcessEntry("d d~ > z g"),)
+    assert config.generation.output == (tmp_path / "artifact").resolve()
+    assert config.generation.workers == 1
+    assert config.color.accuracy == "nlc"
+
+
+def test_generate_accepts_eager_execution_mode_override() -> None:
+    config = parse_cli(("generate", "--execution-mode", "eager")).resolve().effective
+    assert config.evaluator.execution_mode is EvaluatorExecutionMode.EAGER
+
+
+def test_generate_accepts_on_the_fly_execution_mode_override() -> None:
+    config = (
+        parse_cli(("generate", "--execution-mode", "on-the-fly")).resolve().effective
+    )
+    assert config.evaluator.execution_mode is EvaluatorExecutionMode.ON_THE_FLY
+
+
+def test_generate_defaults_to_recurrence_execution() -> None:
+    config = parse_cli(("generate",)).resolve().effective
+    assert config.evaluator.execution_mode is EvaluatorExecutionMode.RECURRENCE
+
+
+def test_umami_grouping_is_not_a_user_option() -> None:
+    config = parse_cli(("generate",)).resolve().effective
+    assert config.generation.emit_api_bundle
+    assert not hasattr(config.generation, "umami_grouping")
+    with pytest.raises(SystemExit):
+        parse_cli(("generate", "--umami-grouping", "flavour_blind_observables"))
+    with pytest.raises(ConfigurationError, match="umami_grouping"):
+        parse_cli(("generate", "--set", "generation.umami_grouping=exact")).resolve()
+
+
+def test_generate_accepts_symmetric_group_color_contraction() -> None:
+    config = (
+        parse_cli(
+            (
+                "generate",
+                "--color-accuracy",
+                "full",
+                "--color-contraction",
+                "symmetric-group-fft",
+            )
+        )
+        .resolve()
+        .effective
+    )
+    assert config.color.contraction is ColorContraction.SYMMETRIC_GROUP_FFT
+    assert config.color.fft_basis is ColorFFTBasis.ADJOINT
+
+
+@pytest.mark.parametrize("accuracy", ("lc", "nlc", "full"))
+@pytest.mark.parametrize("execution_mode", tuple(EvaluatorExecutionMode))
+def test_automatic_fft_default_is_limited_to_supported_lanes(
+    accuracy: str, execution_mode: EvaluatorExecutionMode
+) -> None:
+    resolution = parse_cli(
+        (
+            "generate",
+            "--color-accuracy",
+            accuracy,
+            "--execution-mode",
+            execution_mode.value,
+        )
+    ).resolve()
+    assert resolution.requested.color.contraction is ColorContraction.AUTO
+    assert resolution.requested.color.fft_basis is ColorFFTBasis.ADJOINT
+    supported = accuracy != "lc" and execution_mode in {
+        EvaluatorExecutionMode.RECURRENCE,
+        EvaluatorExecutionMode.ON_THE_FLY,
+    }
+    assert resolution.effective.color.contraction is (
+        ColorContraction.AUTO if supported else ColorContraction.DIRECT
+    )
+    assert resolution.effective.color.fft_basis is (
+        ColorFFTBasis.ADJOINT if supported else ColorFFTBasis.TRACE
+    )
+
+
+def test_direct_cli_opt_out_overrides_adaptive_fft_default() -> None:
+    config = (
+        parse_cli(
+            ("generate", "--color-accuracy", "full", "--color-contraction", "direct")
+        )
+        .resolve()
+        .effective
+    )
+    assert config.color.contraction is ColorContraction.DIRECT
+    assert config.color.fft_basis is ColorFFTBasis.TRACE
+
+
+@pytest.mark.parametrize("fft_basis", tuple(ColorFFTBasis))
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+@pytest.mark.parametrize("execution_mode", ("recurrence", "on-the-fly"))
+def test_fft_shorthand_selects_contraction_and_basis(
+    fft_basis: ColorFFTBasis, accuracy: str, execution_mode: str
+) -> None:
+    config = (
+        parse_cli(
+            (
+                "generate",
+                "--fft",
+                fft_basis.value,
+                "--color-accuracy",
+                accuracy,
+                "--execution-mode",
+                execution_mode,
+            )
+        )
+        .resolve()
+        .effective
+    )
+
+    assert config.color.contraction is ColorContraction.SYMMETRIC_GROUP_FFT
+    assert config.color.fft_basis is fft_basis
+    assert config.color.accuracy == accuracy
+    assert config.evaluator.execution_mode == execution_mode
+
+
+@pytest.mark.parametrize("fft_basis", tuple(ColorFFTBasis))
+def test_fft_shorthand_requires_explicit_contracted_accuracy(
+    fft_basis: ColorFFTBasis,
+) -> None:
+    with pytest.raises(ConfigurationError, match=r"requires color\.accuracy"):
+        parse_cli(("generate", "--fft", fft_basis.value)).resolve()
+
+
+def test_fft_shorthand_obeys_card_and_ordered_override_precedence(
+    tmp_path: Path,
+) -> None:
+    card = tmp_path / "fft.toml"
+    card.write_text(
+        'action = "generate"\n[color]\naccuracy = "full"\n'
+        'contraction = "direct"\nfft_basis = "trace"\n',
+        encoding="utf-8",
+    )
+    config = (
+        parse_cli(("generate", "--card", str(card), "--fft", "adjoint"))
+        .resolve()
+        .effective
+    )
+    assert config.color.contraction is ColorContraction.SYMMETRIC_GROUP_FFT
+    assert config.color.fft_basis is ColorFFTBasis.ADJOINT
+
+    overridden = (
+        parse_cli(
+            (
+                "generate",
+                "--card",
+                str(card),
+                "--fft",
+                "adjoint",
+                "--set",
+                "color.fft_basis=trace",
+            )
+        )
+        .resolve()
+        .effective
+    )
+    assert overridden.color.fft_basis is ColorFFTBasis.TRACE
+
+
+@pytest.mark.parametrize(
+    "arguments",
+    (
+        ("--fft", "invalid"),
+        ("--fft", "adjoint", "--color-contraction", "direct"),
+    ),
+)
+def test_fft_shorthand_rejects_invalid_or_conflicting_flags(
+    arguments: tuple[str, ...],
+) -> None:
+    with pytest.raises(SystemExit):
+        parse_cli(("generate", *arguments))
+
+
+def test_profile_help_explains_layout_aware_selector_default(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    with pytest.raises(SystemExit) as exit_info:
+        build_parser().parse_args(("profile", "--help"))
+
+    assert exit_info.value.code == 0
+    help_text = capsys.readouterr().out
+    assert help_text.count("omitting both selector options") == 2
+    assert "--helicity ID" in help_text
+    assert "--color-flow ID_OR_NUMBER" in help_text
+
+
+def test_generate_validation_samples_default_and_override() -> None:
+    default = parse_cli(("generate",)).resolve().effective
+    explicit = parse_cli(("generate", "--validation-samples", "10")).resolve().effective
+
+    assert default.generation.validation.samples == 2
+    assert explicit.generation.validation.samples == 10
+
+
+def test_generate_post_build_validation_is_opt_in() -> None:
+    default = parse_cli(("generate",)).resolve().effective
+    explicit = parse_cli(("generate", "--post-build-validation")).resolve().effective
+
+    assert not default.generation.validation.post_build_validation
+    assert explicit.generation.validation.post_build_validation
+
+
+def test_generate_defaults_to_no_numerical_current_reuse() -> None:
+    config = parse_cli(("generate",)).resolve().effective
+    assert config.generation.relation_discovery.mode is RelationDiscoveryMode.OFF
+
+
+@pytest.mark.parametrize(
+    ("flag", "expected"),
+    (
+        ("--numerical-current-reuse", RelationDiscoveryMode.CERTIFIED_REUSE),
+        ("--no-numerical-current-reuse", RelationDiscoveryMode.OFF),
+    ),
+)
+def test_generate_accepts_numerical_current_reuse_override(
+    flag: str,
+    expected: RelationDiscoveryMode,
+) -> None:
+    config = parse_cli(("generate", flag)).resolve().effective
+    assert config.generation.relation_discovery.mode is expected
+
+
+def test_direct_numerical_current_reuse_flag_overrides_card(
+    tmp_path: Path,
+) -> None:
+    card = tmp_path / "generate.toml"
+    card.write_text(
+        "\n".join(
+            (
+                'action = "generate"',
+                "[generation.relation_discovery]",
+                'mode = "off"',
+            )
+        ),
+        encoding="utf-8",
+    )
+    config = (
+        parse_cli(
+            (
+                "generate",
+                "--card",
+                str(card),
+                "--numerical-current-reuse",
+            )
+        )
+        .resolve()
+        .effective
+    )
+    assert (
+        config.generation.relation_discovery.mode
+        is RelationDiscoveryMode.CERTIFIED_REUSE
+    )
+
+
+@pytest.mark.parametrize(
+    ("flag", "expected"),
+    (("--jit-compress", True), ("--no-jit-compress", False)),
+)
+@pytest.mark.parametrize("mode", ("recurrence", "compiled", "eager", "on-the-fly"))
+def test_generate_accepts_jit_compression_override(
+    flag: str,
+    expected: bool,
+    mode: str,
+) -> None:
+    config = parse_cli(("generate", "--execution-mode", mode, flag)).resolve().effective
+    assert config.evaluator.jit.compress is expected
+
+
+@pytest.mark.parametrize("mode", ("recurrence", "compiled", "eager", "on-the-fly"))
+def test_generation_modes_select_jit_compression_default(mode: str) -> None:
+    config = parse_cli(("generate", "--execution-mode", mode)).resolve().effective
+    assert config.evaluator.jit.compress is (mode == "compiled")
+
+
+def test_generate_accepts_recurrence_execution_mode_override() -> None:
+    config = (
+        parse_cli(("generate", "--execution-mode", "recurrence")).resolve().effective
+    )
+    assert config.evaluator.execution_mode is EvaluatorExecutionMode.RECURRENCE
+
+
+def test_generate_accepts_recurrence_schema_overrides() -> None:
+    config = (
+        parse_cli(
+            (
+                "generate",
+                "--set",
+                "evaluator.execution_mode=recurrence",
+                "--set",
+                "evaluator.recurrence.point_tile_size=2048",
+                "--set",
+                "evaluator.recurrence.workspace_mib=384",
+            )
+        )
+        .resolve()
+        .effective
+    )
+    assert config.evaluator.execution_mode is EvaluatorExecutionMode.RECURRENCE
+    assert config.evaluator.recurrence.point_tile_size == 2048
+    assert config.evaluator.recurrence.workspace_mib == 384
+
+
+def test_generate_accepts_lc_flow_layout_override() -> None:
+    resolution = parse_cli(("generate", "--lc-flow-layout", "all-flow-union")).resolve()
+    assert resolution.requested.color.lc_flow_layout is LCFlowLayout.ALL_FLOW_UNION
+    assert resolution.effective.color.lc_flow_layout is LCFlowLayout.ALL_FLOW_UNION
+
+
+def test_generate_force_is_an_alias_for_atomic_replace(tmp_path: Path) -> None:
+    config = (
+        parse_cli(
+            (
+                "generate",
+                "d d~ > z g",
+                str(tmp_path / "artifact"),
+                "--force",
+            )
+        )
+        .resolve()
+        .effective
+    )
+    assert str(config.generation.mode) == "replace"
+
+
+def test_card_can_be_invoked_as_the_first_argument(tmp_path: Path) -> None:
+    card = tmp_path / "evaluate.toml"
+    card.write_text(
+        'action = "evaluate"\n[evaluation]\nartifact = "artifact"\n',
+        encoding="utf-8",
+    )
+    invocation = parse_cli((str(card), "--json"))
+    config = invocation.resolve().effective
+    assert invocation.action is None
+    assert config.action == "evaluate"
+    assert config.evaluation.artifact == (tmp_path / "artifact").resolve()
+    assert config.output.format == "json"
+
+
+def test_all_contract_actions_have_subcommands() -> None:
+    arguments = {
+        "generate": ("generate",),
+        "evaluate": ("evaluate",),
+        "benchmark": ("benchmark",),
+        "inspect": ("inspect",),
+        "model-inspect": ("model", "inspect"),
+        "model-compile": ("model", "compile"),
+        "model-processes": ("model", "processes"),
+        "group-processes": ("group-processes",),
+    }
+    for action, argv in arguments.items():
+        assert parse_cli(argv).action == action
+
+    assert parse_cli(("profile",)).action == "benchmark"
+
+
+def test_generate_process_grouping_flags_keep_flavor_scheme() -> None:
+    default = parse_cli(("generate",)).resolve().effective.process
+    assert not default.flavor_blind
+    assert default.consider_charge_conjugation
+    assert not default.only_unit_multiplier
+    assert default.analyze_process_groups is ProcessGroupAnalysis.NONE
+
+    process = (
+        parse_cli(
+            (
+                "generate",
+                "--flavor-scheme",
+                "4",
+                "--flavor-blind",
+                "--no-consider-charge-conjugation",
+                "--only-unit-multiplier",
+                "--analyze-process-groups",
+                "numerical",
+            )
+        )
+        .resolve()
+        .effective.process
+    )
+    assert process.flavor_scheme == 4
+    assert process.flavor_blind
+    assert not process.consider_charge_conjugation
+    assert process.only_unit_multiplier
+    assert process.analyze_process_groups is ProcessGroupAnalysis.NUMERICAL
+
+
+def test_group_processes_defaults_to_numerical_analysis(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    config = parse_cli(("group-processes", str(artifact))).resolve().effective
+    assert config.action == "group-processes"
+    assert config.evaluation.artifact == artifact.resolve()
+    assert config.process.analyze_process_groups is ProcessGroupAnalysis.NUMERICAL
+    assert config.process.consider_charge_conjugation
+
+    explicit = (
+        parse_cli(
+            (
+                "group-processes",
+                str(artifact),
+                "--analyze-process-groups",
+                "none",
+                "--only-unit-multiplier",
+                "--no-consider-charge-conjugation",
+            )
+        )
+        .resolve()
+        .effective.process
+    )
+    assert explicit.analyze_process_groups is ProcessGroupAnalysis.NONE
+    assert explicit.only_unit_multiplier
+    assert not explicit.consider_charge_conjugation
+    # The choice "none" is not the null literal of --set.
+    overridden = parse_cli(
+        (
+            "group-processes",
+            str(artifact),
+            "--set",
+            "process.analyze_process_groups=none",
+        )
+    ).resolve()
+    overridden_process = overridden.effective.process
+    assert overridden_process.analyze_process_groups is ProcessGroupAnalysis.NONE
+    with pytest.raises(SystemExit):
+        parse_cli(("group-processes", str(artifact), "--flavor-blind"))
+
+
+def test_inspect_full_physics_is_an_explicit_transient_opt_in(
+    tmp_path: Path,
+) -> None:
+    default = parse_cli(
+        ("inspect", str(tmp_path / "artifact"), "--process", "process-id")
+    )
+    full = parse_cli(
+        (
+            "inspect",
+            str(tmp_path / "artifact"),
+            "--process",
+            "process-id",
+            "--full-physics",
+        )
+    )
+
+    assert default.full_physics is False
+    assert full.full_physics is True
+    assert full.resolve().effective.evaluation.process == "process-id"
+
+
+@pytest.mark.parametrize(
+    "command",
+    ("model-inspect", "model-compile", "model-processes"),
+)
+def test_flat_model_commands_are_not_cli_compatibility_aliases(command: str) -> None:
+    with pytest.raises(SystemExit):
+        parse_cli((command,))
+
+
+def test_model_processes_accepts_process_requests() -> None:
+    invocation = parse_cli(
+        (
+            "model",
+            "processes",
+            "d d~ > z g",
+            "--process",
+            "u u~ > z g",
+        )
+    )
+    config = invocation.resolve().effective
+    assert config.action == "model-processes"
+    assert config.process.entries == (
+        ProcessEntry("d d~ > z g"),
+        ProcessEntry("u u~ > z g"),
+    )
+
+
+def test_direct_process_names_are_assembled_into_typed_entries() -> None:
+    config = (
+        parse_cli(
+            (
+                "model",
+                "processes",
+                "d d~ > z g",
+                "--process",
+                "u u~ > z g",
+                "--name",
+                "ddbar_zg",
+                "--name",
+                "uubar_zg",
+            )
+        )
+        .resolve()
+        .effective
+    )
+    assert config.process.entries == (
+        ProcessEntry("d d~ > z g", "ddbar_zg"),
+        ProcessEntry("u u~ > z g", "uubar_zg"),
+    )
+
+
+def test_direct_process_names_must_align_with_expressions() -> None:
+    with pytest.raises(ConfigurationError, match="aligned with process expressions"):
+        parse_cli(
+            (
+                "model",
+                "processes",
+                "d d~ > z g",
+                "--name",
+                "one",
+                "--name",
+                "two",
+            )
+        )
+
+
+def test_model_command_accepts_common_flags_before_the_command_group() -> None:
+    invocation = parse_cli(("--json", "model", "inspect"))
+    assert invocation.resolve().effective.output.format == "json"
+
+
+def test_top_level_help_lists_nested_model_and_utility_commands() -> None:
+    help_text = build_parser().format_help()
+    for command in (
+        "model",
+        "config",
+        "examples",
+        "doctor",
+        "self-test",
+        "request-symbolica-trial-license",
+        "request-symbolica-hobbyist-license",
+    ):
+        assert command in help_text
+    assert "model-inspect" not in help_text
+    assert "model-compile" not in help_text
+    assert "model-processes" not in help_text
+
+
+def test_model_help_does_not_import_symbolica(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    sys.modules.pop("symbolica", None)
+    with pytest.raises(SystemExit) as exit_info:
+        build_parser().parse_args(("model", "--help"))
+    assert exit_info.value.code == 0
+    assert "{inspect,compile,processes}" in capsys.readouterr().out
+    assert "symbolica" not in sys.modules
+
+
+def test_global_output_flags_are_accepted_before_subcommand(tmp_path: Path) -> None:
+    invocation = parse_cli(
+        (
+            "--json",
+            "generate",
+            "u u~ > g g",
+            str(tmp_path / "artifact"),
+        )
+    )
+    assert invocation.resolve().effective.output.format == "json"
+
+
+def test_json_output_is_selected_only_by_the_json_flag(tmp_path: Path) -> None:
+    card = tmp_path / "json-card.toml"
+    card.write_text(
+        'schema_version = 1\naction = "generate"\n'
+        '[output]\nformat = "json"\n'
+        '[process]\nentries = [{ expression = "d d~ > z" }]\n',
+        encoding="utf-8",
+    )
+
+    assert parse_cli((str(card),)).resolve().effective.output.format == "human"
+    assert parse_cli((str(card), "--json")).resolve().effective.output.format == "json"
+
+    with pytest.raises(ConfigurationError, match="selected only with --json"):
+        parse_cli((str(card), "--set", "output.format=json")).resolve()
+    assert (
+        parse_cli((str(card), "--set", "output.format=human"))
+        .resolve()
+        .effective.output.format
+        == "human"
+    )
+
+    with pytest.raises(SystemExit):
+        parse_cli(("generate", "d d~ > z", "--format", "json"))
+
+
+def test_set_order_is_preserved_across_subcommand_position(tmp_path: Path) -> None:
+    invocation = parse_cli(
+        (
+            "--set",
+            "generation.workers=5",
+            "generate",
+            "u u~ > g g",
+            str(tmp_path / "artifact"),
+            "--set",
+            "generation.workers=2",
+        )
+    )
+    assert invocation.overrides == (
+        "generation.workers=5",
+        "generation.workers=2",
+    )
+    assert invocation.resolve().effective.generation.workers == 2
+
+
+@pytest.mark.parametrize(
+    "arguments",
+    (
+        ("generate", "--color-coverage", "all"),
+        ("generate", "--color-flow", "flow:2,4,1"),
+        ("generate", "--zero-current-filter"),
+        ("generate", "--no-zero-current-filter"),
+        ("generate", "--current-merging"),
+        ("generate", "--no-current-merging"),
+    ),
+)
+def test_removed_generation_flags_are_rejected(arguments: tuple[str, ...]) -> None:
+    with pytest.raises(SystemExit):
+        parse_cli(arguments)
+
+
+def test_runtime_color_flow_flags_remain_available() -> None:
+    evaluation = parse_cli(("evaluate", "--color-flow", "flow:2,4,1"))
+    benchmark = parse_cli(
+        (
+            "benchmark",
+            "--process",
+            "d d~ > z g",
+            "--precision",
+            "80",
+            "--color-flow",
+            "flow:2,4,1",
+        )
+    )
+
+    assert evaluation.resolve().effective.evaluation.color_flow_ids == ("flow:2,4,1",)
+    assert benchmark.resolve().effective.evaluation.process == "d d~ > z g"
+    assert benchmark.resolve().effective.benchmark.precision == 80
+    assert benchmark.resolve().effective.benchmark.color_flow_ids == ("flow:2,4,1",)
+
+
+def test_profile_is_primary_cli_spelling_for_typed_benchmark_config(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    profile = (
+        parse_cli(
+            (
+                "profile",
+                str(artifact),
+                "--process",
+                "d d~ > z g",
+                "--target-runtime",
+                "0.25",
+                "--batch-size",
+                "64",
+                "--minimum-samples",
+                "8",
+            )
+        )
+        .resolve()
+        .effective
+    )
+    benchmark = (
+        parse_cli(
+            (
+                "benchmark",
+                str(artifact),
+                "--process",
+                "d d~ > z g",
+                "--target-runtime",
+                "0.25",
+                "--batch-size",
+                "64",
+                "--minimum-samples",
+                "8",
+            )
+        )
+        .resolve()
+        .effective
+    )
+
+    assert profile == benchmark
+    assert profile.action == "benchmark"
+    assert profile.evaluation.artifact == artifact.resolve()
+    assert profile.evaluation.process == "d d~ > z g"
+    assert profile.benchmark.batch_size == 64
+    assert profile.benchmark.minimum_samples == 8
diff --git a/pyamplicol/tests/unit/test_cli_utilities.py b/pyamplicol/tests/unit/test_cli_utilities.py
new file mode 100644
index 0000000000..1fc5795c9f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_cli_utilities.py
@@ -0,0 +1,601 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import io
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.cli import UtilityInvocation, parse_cli, run_cli
+from pyamplicol.cli.utilities import list_examples, profiling_campaign_root
+from tools.performance_report.catalog import REPORT_CATALOG
+
+
+class _TTYStringIO(io.StringIO):
+    def isatty(self) -> bool:
+        return True
+
+
+def test_examples_list_is_checkout_independent_and_descriptive() -> None:
+    invocation = parse_cli(("examples", "list", "--json"))
+    assert isinstance(invocation, UtilityInvocation)
+    assert invocation.output_format == "json"
+    assert invocation.output_color == "auto"
+    stdout = io.StringIO()
+    assert run_cli(("examples", "list", "--json"), stdout=stdout) == 0
+    entries = json.loads(stdout.getvalue())
+    assert any(entry["name"] == "builtin_sm_lc" for entry in entries)
+    heft = next(entry for entry in entries if entry["name"] == "builtin_sm_heft")
+    assert "scalar HEFT" in heft["description"]
+    assert "g g > H g g" in heft["description"]
+    assert all("SPDX" not in entry["description"] for entry in entries)
+    otf = next(entry for entry in entries if entry["name"] == "otf_pp_zjj")
+    assert "first explicit warm_up or evaluation" in otf["description"]
+    assert "complete helicity sum" in otf["description"]
+
+
+def test_examples_list_presentation_options_are_explicit(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    invocation = parse_cli(("examples", "list", "--color", "always"))
+    assert isinstance(invocation, UtilityInvocation)
+    assert invocation.output_format == "human"
+    assert invocation.output_color == "always"
+
+    machine = parse_cli(("examples", "list", "--json"))
+    assert isinstance(machine, UtilityInvocation)
+    assert machine.output_format == "json"
+
+    with pytest.raises(SystemExit) as exc_info:
+        parse_cli(("examples", "list", "--help"))
+    assert exc_info.value.code == 0
+    help_text = capsys.readouterr().out
+    assert "--json" in help_text
+    assert "--color {auto,always,never}" in help_text
+    assert "--format" not in help_text
+    with pytest.raises(SystemExit):
+        parse_cli(("examples", "list", "--format", "json"))
+
+
+def test_utility_output_auto_colors_a_terminal_and_json_is_uncolored(
+    tmp_path: Path,
+) -> None:
+    human = _TTYStringIO()
+    assert run_cli(("examples", "list"), stdout=human) == 0
+    assert "Packaged Examples" in human.getvalue()
+    assert "\x1b[" in human.getvalue()
+    with pytest.raises(json.JSONDecodeError):
+        json.loads(human.getvalue())
+
+    target = tmp_path / "template.toml"
+    machine = _TTYStringIO()
+    assert (
+        run_cli(
+            ("config", "template", str(target), "--json"),
+            stdout=machine,
+        )
+        == 0
+    )
+    assert json.loads(machine.getvalue()) == {
+        "destination": str(target.resolve()),
+        "operation": "configuration template",
+        "status": "complete",
+    }
+    assert "\x1b[" not in machine.getvalue()
+
+
+def test_examples_run_help_lists_every_runnable_card(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    with pytest.raises(SystemExit) as exc_info:
+        parse_cli(("examples", "run", "--help"))
+
+    assert exc_info.value.code == 0
+    help_text = capsys.readouterr().out
+    runnable_names = {
+        entry.name for entry in list_examples() if entry.action != "reference"
+    }
+    assert runnable_names
+    assert all(f"  {name}\n" in help_text for name in runnable_names)
+    assert "all_options" not in help_text
+
+
+def test_examples_copy_requires_force_for_nonempty_destination(
+    tmp_path: Path,
+) -> None:
+    destination = tmp_path / "examples"
+    assert run_cli(("examples", "copy", str(destination))) == 0
+    assert (destination / "builtin_sm_lc.toml").is_file()
+    assert (destination / "builtin_sm_heft.toml").is_file()
+    assert (destination / "benchmark_z6g_single_flow_helicity_sum.toml").is_file()
+    assert (destination / "benchmark_z6g_all_flows_single_helicity.toml").is_file()
+    assert (destination / "otf_pp_zjj.toml").is_file()
+    assert (destination / "python/otf_pp_zjj_warm_up.py").is_file()
+    selected_card = (
+        destination / "benchmark_z6g_single_flow_helicity_sum.toml"
+    ).read_text(encoding="utf-8")
+    union_card = (
+        destination / "benchmark_z6g_all_flows_single_helicity.toml"
+    ).read_text(encoding="utf-8")
+    assert 'lc_flow_layout = "all-flow-union"' not in selected_card
+    assert 'lc_flow_layout = "all-flow-union"' in union_card
+    assert (destination / "models/json/sm/sm.json").is_file()
+    assert (destination / "models/ufo/sm/vertices.py").is_file()
+    expected_progress = {
+        "evaluate_total.toml": "off",
+        "evaluate_resolved.toml": "off",
+        "benchmark.toml": "log",
+    }
+    for name, progress in expected_progress.items():
+        card = parse_cli((str(destination / name),))
+        assert not isinstance(card, UtilityInvocation)
+        output = card.resolve().effective.output
+        assert output.format == "human"
+        assert output.color == "auto"
+        assert output.progress == progress
+    stderr = io.StringIO()
+    assert run_cli(("examples", "copy", str(destination)), stderr=stderr) == 2
+    assert "not empty" in stderr.getvalue()
+    assert run_cli(("examples", "copy", str(destination), "--force")) == 0
+
+
+def test_profiling_campaign_copy_is_reset_and_requires_force(
+    tmp_path: Path,
+) -> None:
+    destination = tmp_path / "profiling-campaign"
+    invocation = parse_cli(("profiling-campaign", "copy", str(destination)))
+    assert isinstance(invocation, UtilityInvocation)
+    assert invocation.kind == "profiling-campaign-copy"
+    assert invocation.path == destination
+    assert invocation.force is False
+
+    assert run_cli(("profiling-campaign", "copy", str(destination))) == 0
+    copied = tuple(path for path in destination.rglob("*") if path.is_file())
+    assert len(copied) == 69
+    expected_cache_names = {
+        f"{cell.dataset_id}.json" for cell in REPORT_CATALOG.measurement_cells()
+    } | {"report-cache.schema.json"}
+    assert {
+        path.name for path in (destination / "results").glob("*.json")
+    } == expected_cache_names
+    assert (destination / "steer_performance_campaign.py").is_file()
+    assert os.access(destination / "steer_performance_campaign.py", os.X_OK)
+    launcher = destination / "steer_performance_campaign.py"
+    assert launcher.read_text(encoding="utf-8").splitlines()[0] == (
+        f"#!{sys.executable}"
+    )
+    environment = os.environ.copy()
+    environment.pop("PYTHONPATH", None)
+    environment["PATH"] = "/usr/bin:/bin"
+    direct = subprocess.run(
+        (str(launcher), "--help"),
+        check=False,
+        capture_output=True,
+        env=environment,
+        text=True,
+    )
+    assert direct.returncode == 0, direct.stderr
+    table_filling = (destination / "TABLE_FILLING.md").read_text(encoding="utf-8")
+    assert "compact retained evidence" in table_filling
+    assert "keep attempts and large artifacts" not in table_filling
+    assert (destination / "results/report-cache.schema.json").is_file()
+    assert not (destination / "pyAmpliCol.pdf").exists()
+    assert not (destination / ".artifacts").exists()
+    assert (destination / "campaign_artifacts").is_dir()
+    assert not tuple((destination / "campaign_artifacts").iterdir())
+    assert not (profiling_campaign_root() / "campaign_artifacts").exists()
+    copied_readme = (destination / "README.md").read_text(encoding="utf-8")
+    assert "moves its state" in copied_readme
+    assert "legacy `.artifacts`" in copied_readme
+    workspace = json.loads(
+        (destination / "report-workspace.json").read_text(encoding="utf-8")
+    )
+    assert workspace["measurement_state"] == "reset"
+    assert workspace["initialized_from"] == "src/pyamplicol/_profiling_campaign"
+    assert workspace["report_source_revision"] == "unknown"
+    assert workspace["report_source_tree"] == "unknown"
+    assert workspace["initialized_source_identity"] == {
+        "clean": False,
+        "dirty_paths": [],
+        "revision": "unknown",
+        "schema": "pyamplicol-report-source-v1",
+        "tree": "unknown",
+    }
+    for path in sorted((destination / "results").glob("*.json")):
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        for entry in payload.get("entries", ()):
+            assert entry["measurement"]["status"] == "not_available"
+
+    stderr = io.StringIO()
+    assert (
+        run_cli(
+            ("profiling-campaign", "copy", str(destination)),
+            stderr=stderr,
+        )
+        == 2
+    )
+    assert "not empty" in stderr.getvalue()
+    (destination / "campaign_artifacts/attempts/cell-a").mkdir(parents=True)
+    (destination / "campaign_artifacts/attempts/cell-a/payload.bin").write_bytes(
+        b"attempt"
+    )
+    (destination / "campaign_summary_ids").mkdir()
+    (destination / "campaign_summary_ids/error.txt").write_text(
+        "cell-a\n", encoding="utf-8"
+    )
+    (destination / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.4\n")
+    (destination / "measurement_lineage.json").write_text(
+        "stale lineage\n",
+        encoding="utf-8",
+    )
+    (destination / "pyAmpliCol.aux").write_text("stale aux\n", encoding="utf-8")
+    (destination / "pyAmpliCol.log").write_text("stale log\n", encoding="utf-8")
+    (destination / "notes.aux").write_text("unrelated\n", encoding="utf-8")
+    (destination / ".artifacts").mkdir()
+    (destination / ".artifacts/legacy.bin").write_bytes(b"legacy")
+    (destination / "unrelated.txt").write_text("keep\n", encoding="utf-8")
+    madgraph_cache = destination / "results/reference_madgraph_full.json"
+    madgraph_cache.write_text('{"stale":true}\n', encoding="ascii")
+    assert run_cli(("profiling-campaign", "copy", str(destination), "--force")) == 0
+    assert (destination / "campaign_artifacts").is_dir()
+    assert not tuple((destination / "campaign_artifacts").iterdir())
+    assert not (destination / "campaign_summary_ids").exists()
+    assert not (destination / "pyAmpliCol.pdf").exists()
+    assert not (destination / "measurement_lineage.json").exists()
+    assert not (destination / "pyAmpliCol.aux").exists()
+    assert not (destination / "pyAmpliCol.log").exists()
+    assert (destination / "notes.aux").read_text(encoding="utf-8") == "unrelated\n"
+    assert (destination / ".artifacts/legacy.bin").read_bytes() == b"legacy"
+    assert (destination / "unrelated.txt").read_text(encoding="utf-8") == "keep\n"
+    reset_madgraph_cache = json.loads(madgraph_cache.read_text(encoding="ascii"))
+    assert reset_madgraph_cache["dataset_id"] == "reference_madgraph_full"
+    assert {
+        entry["measurement"]["status"] for entry in reset_madgraph_cache["entries"]
+    } == {"not_available"}
+
+
+def test_profiling_campaign_force_refuses_an_active_directory_lock(
+    tmp_path: Path,
+) -> None:
+    import fcntl
+
+    destination = tmp_path / "active-campaign"
+    assert run_cli(("profiling-campaign", "copy", str(destination))) == 0
+    sentinel = destination / "campaign_artifacts/active-attempt.bin"
+    sentinel.write_bytes(b"active")
+    descriptor = os.open(
+        destination,
+        os.O_RDONLY | getattr(os, "O_DIRECTORY", 0),
+    )
+    try:
+        fcntl.flock(descriptor, fcntl.LOCK_SH)
+        stderr = io.StringIO()
+        assert (
+            run_cli(
+                ("profiling-campaign", "copy", str(destination), "--force"),
+                stderr=stderr,
+            )
+            == 2
+        )
+        assert "campaign is active" in stderr.getvalue()
+        assert sentinel.read_bytes() == b"active"
+    finally:
+        fcntl.flock(descriptor, fcntl.LOCK_UN)
+        os.close(descriptor)
+
+
+def test_profiling_campaign_copy_records_local_amplicol_default(
+    tmp_path: Path,
+) -> None:
+    checkout = tmp_path / "original-amplicol"
+    checkout.mkdir()
+    checkout = checkout.resolve()
+    destination = tmp_path / "profiling-campaign"
+    invocation = parse_cli(
+        (
+            "profiling-campaign",
+            "copy",
+            str(destination),
+            "--local-amplicol",
+            str(checkout),
+        )
+    )
+    assert isinstance(invocation, UtilityInvocation)
+    assert invocation.local_amplicol == checkout
+
+    assert (
+        run_cli(
+            (
+                "profiling-campaign",
+                "copy",
+                str(destination),
+                "--local-amplicol",
+                str(checkout),
+            )
+        )
+        == 0
+    )
+    configured = destination / ".pyamplicol-original-amplicol"
+    assert configured.read_text(encoding="utf-8") == f"{checkout}\n"
+
+    assert run_cli(("profiling-campaign", "copy", str(destination), "--force")) == 0
+    assert configured.read_text(encoding="utf-8") == f"{checkout}\n"
+
+    replacement = tmp_path / "replacement-amplicol"
+    replacement.mkdir()
+    assert (
+        run_cli(
+            (
+                "profiling-campaign",
+                "copy",
+                str(destination),
+                "--force",
+                "--local-amplicol",
+                str(replacement),
+            )
+        )
+        == 0
+    )
+    assert configured.read_text(encoding="utf-8") == f"{replacement.resolve()}\n"
+
+
+def test_profiling_campaign_copy_records_local_madgraph_default(
+    tmp_path: Path,
+) -> None:
+    installation = tmp_path / "madgraph"
+    (installation / "bin").mkdir(parents=True)
+    (installation / "bin/mg5_aMC").write_text("#!/bin/sh\n", encoding="utf-8")
+    (installation / "bin/mg5_aMC").chmod(0o755)
+    installation = installation.resolve()
+    destination = tmp_path / "profiling-campaign"
+    invocation = parse_cli(
+        (
+            "profiling-campaign",
+            "copy",
+            str(destination),
+            "--local-madgraph",
+            str(installation),
+        )
+    )
+    assert isinstance(invocation, UtilityInvocation)
+    assert invocation.local_madgraph == installation
+
+    assert (
+        run_cli(
+            (
+                "profiling-campaign",
+                "copy",
+                str(destination),
+                "--local-madgraph",
+                str(installation),
+            )
+        )
+        == 0
+    )
+    configured = destination / ".pyamplicol-madgraph"
+    assert configured.read_text(encoding="utf-8") == f"{installation}\n"
+
+    assert run_cli(("profiling-campaign", "copy", str(destination), "--force")) == 0
+    assert configured.read_text(encoding="utf-8") == f"{installation}\n"
+
+    replacement = tmp_path / "replacement-madgraph"
+    (replacement / "bin").mkdir(parents=True)
+    (replacement / "bin/mg5_aMC").write_text("#!/bin/sh\n", encoding="utf-8")
+    (replacement / "bin/mg5_aMC").chmod(0o755)
+    assert (
+        run_cli(
+            (
+                "profiling-campaign",
+                "copy",
+                str(destination),
+                "--force",
+                "--local-madgraph",
+                str(replacement),
+            )
+        )
+        == 0
+    )
+    assert configured.read_text(encoding="utf-8") == f"{replacement.resolve()}\n"
+
+
+def test_profiling_campaign_copy_rejects_unsafe_local_madgraph_replacement(
+    tmp_path: Path,
+) -> None:
+    destination = tmp_path / "profiling-campaign"
+    assert run_cli(("profiling-campaign", "copy", str(destination))) == 0
+    sentinel = tmp_path / "external-madgraph-config"
+    sentinel.write_text("keep\n", encoding="utf-8")
+    (destination / ".pyamplicol-madgraph").symlink_to(sentinel)
+    replacement = tmp_path / "replacement-madgraph"
+    (replacement / "bin").mkdir(parents=True)
+    (replacement / "bin/mg5_aMC").write_text("#!/bin/sh\n", encoding="utf-8")
+    (replacement / "bin/mg5_aMC").chmod(0o755)
+    stderr = io.StringIO()
+
+    assert (
+        run_cli(
+            (
+                "profiling-campaign",
+                "copy",
+                str(destination),
+                "--force",
+                "--local-madgraph",
+                str(replacement),
+            ),
+            stderr=stderr,
+        )
+        == 2
+    )
+    assert (
+        "unsafe profiling campaign output" in stderr.getvalue()
+        or "escapes its destination" in stderr.getvalue()
+    )
+    assert sentinel.read_text(encoding="utf-8") == "keep\n"
+
+
+def test_profiling_campaign_force_rejects_unsafe_exact_reset_targets(
+    tmp_path: Path,
+) -> None:
+    external = tmp_path / "external"
+    external.mkdir()
+    sentinel = external / "sentinel"
+    sentinel.write_text("keep\n", encoding="utf-8")
+
+    for name in ("campaign_artifacts", "campaign_summary_ids"):
+        destination = tmp_path / f"campaign-{name}"
+        destination.mkdir()
+        (destination / name).symlink_to(external, target_is_directory=True)
+        stderr = io.StringIO()
+        assert (
+            run_cli(
+                ("profiling-campaign", "copy", str(destination), "--force"),
+                stderr=stderr,
+            )
+            == 2
+        )
+        assert "unsafe" in stderr.getvalue() or "escapes" in stderr.getvalue()
+        assert sentinel.read_text(encoding="utf-8") == "keep\n"
+
+    destination = tmp_path / "campaign-pdf"
+    destination.mkdir()
+    (destination / "pyAmpliCol.pdf").symlink_to(sentinel)
+    stderr = io.StringIO()
+    assert (
+        run_cli(
+            ("profiling-campaign", "copy", str(destination), "--force"),
+            stderr=stderr,
+        )
+        == 2
+    )
+    assert "unsafe" in stderr.getvalue() or "escapes" in stderr.getvalue()
+    assert sentinel.read_text(encoding="utf-8") == "keep\n"
+
+
+def test_profiling_campaign_force_rejects_unsafe_managed_output(
+    tmp_path: Path,
+) -> None:
+    external = tmp_path / "external-readme"
+    external.write_text("keep\n", encoding="utf-8")
+    destination = tmp_path / "campaign"
+    destination.mkdir()
+    (destination / "README.md").symlink_to(external)
+
+    stderr = io.StringIO()
+    assert (
+        run_cli(
+            ("profiling-campaign", "copy", str(destination), "--force"),
+            stderr=stderr,
+        )
+        == 2
+    )
+    assert "unsafe" in stderr.getvalue() or "escapes" in stderr.getvalue()
+    assert external.read_text(encoding="utf-8") == "keep\n"
+
+
+def test_profiling_campaign_force_rejects_symlinked_destination(
+    tmp_path: Path,
+) -> None:
+    real = tmp_path / "real"
+    real.mkdir()
+    destination = tmp_path / "campaign"
+    destination.symlink_to(real, target_is_directory=True)
+
+    stderr = io.StringIO()
+    assert (
+        run_cli(
+            ("profiling-campaign", "copy", str(destination), "--force"),
+            stderr=stderr,
+        )
+        == 2
+    )
+    assert "must not traverse a symlink" in stderr.getvalue()
+    assert not tuple(real.iterdir())
+
+
+def test_profiling_campaign_force_rejects_special_state_members(
+    tmp_path: Path,
+) -> None:
+    destination = tmp_path / "campaign"
+    state = destination / "campaign_artifacts"
+    state.mkdir(parents=True)
+    os.mkfifo(state / "active.pipe")
+
+    stderr = io.StringIO()
+    assert (
+        run_cli(
+            ("profiling-campaign", "copy", str(destination), "--force"),
+            stderr=stderr,
+        )
+        == 2
+    )
+    assert "contains a special file" in stderr.getvalue()
+    assert (state / "active.pipe").exists()
+
+
+def test_profiling_campaign_copy_help_describes_local_reset(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    with pytest.raises(SystemExit) as stopped:
+        parse_cli(("profiling-campaign", "copy", "--help"))
+
+    assert stopped.value.code == 0
+    rendered = capsys.readouterr().out
+    assert "DEST/campaign_artifacts" in rendered
+    assert "moves with DEST" in rendered
+    assert "unrelated files" in rendered
+    assert "--local-madgraph" in rendered
+    assert "MadGraph installation" in rendered
+
+
+def test_config_template_and_resolve(tmp_path: Path) -> None:
+    target = tmp_path / "all.toml"
+    assert run_cli(("config", "template", str(target))) == 0
+    template = target.read_text(encoding="utf-8")
+    assert "schema_version" in template
+    for path in (
+        "color.coverage",
+        "color.flow_ids",
+        "generation.validation.zero_current_filter",
+        "generation.validation.current_merging",
+    ):
+        assert path not in template
+    stdout = io.StringIO()
+    assert (
+        run_cli(
+            (
+                "config",
+                "resolve",
+                str(target),
+                "--set",
+                "generation.workers=1",
+                "--json",
+            ),
+            stdout=stdout,
+        )
+        == 0
+    )
+    payload = json.loads(stdout.getvalue())
+    assert payload["effective"]["generation"]["workers"] == 1
+
+
+def test_generate_dry_run_does_not_require_output() -> None:
+    invocation = parse_cli(("generate", "d d~ > z", "--dry-run"))
+    assert invocation.dry_run is True
+    assert invocation.resolve().effective.generation.output is None
+
+
+def test_example_run_materializes_outside_package_resources(
+    tmp_path: Path, monkeypatch: object
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_EXAMPLE_CACHE", str(tmp_path / "cache"))  # type: ignore[attr-defined]
+    from pyamplicol.cli.utilities import example_card
+
+    card = example_card("builtin_sm_lc")
+    assert card == tmp_path / "cache/builtin_sm_lc.toml"
+    assert (tmp_path / "cache/data/pp_zjj_momenta.json").is_file()
+    assert (tmp_path / "cache/models/json/scalars/scalars.json").is_file()
+    assert (tmp_path / "cache/models/ufo/sm/vertices.py").is_file()
diff --git a/pyamplicol/tests/unit/test_color_connection_catalogue.py b/pyamplicol/tests/unit/test_color_connection_catalogue.py
new file mode 100644
index 0000000000..229e0a379e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_color_connection_catalogue.py
@@ -0,0 +1,236 @@
+# SPDX-License-Identifier: 0BSD
+"""Independent small structural counts and ordering checks for soft catalogues."""
+
+import json
+from collections import Counter
+from itertools import product
+
+import pytest
+
+from pyamplicol.color.connection_catalogue import (
+    _labelled_histories,
+    build_color_correlator_catalogue,
+)
+from pyamplicol.color.connections import (
+    ColorConnection,
+    ColorLeg,
+    EmitGluon,
+    SplitGluon,
+)
+
+
+def _histories(catalogue, order):
+    result = {}
+    for request in catalogue:
+        if request.order != order:
+            continue
+        _, left, right = request.id.split("/")
+        if left == right:
+            assert request.bra == request.ket
+            result[int(left[1:])] = request.bra
+    assert tuple(result) == tuple(range(len(result)))
+    return result
+
+
+@pytest.fixture(scope="module")
+def pair_catalogue():
+    legs = (ColorLeg(1, 3), ColorLeg(2, -3))
+    return legs, build_color_correlator_catalogue(legs, through_order=3)
+
+
+@pytest.mark.parametrize("count", (1, 2, 3))
+def test_nlo_and_nnlo_exhaustive_hand_counts(count):
+    # A: distinct Born emitters, B: same Born line, C: emitted gluon,
+    # D: emitted gluon splits. These count labelled maps, not multiplicities.
+    legs = tuple(ColorLeg(index, 8) for index in range(1, count + 1))
+    catalogue = build_color_correlator_catalogue(legs, through_order=2)
+    assert len(_histories(catalogue, 1)) == count
+    assert sum(request.order == 1 for request in catalogue) == count**2
+    histories = _histories(catalogue, 2)
+    categories = Counter()
+    for operations in histories.values():
+        first, second = operations
+        if isinstance(second, SplitGluon):
+            categories["D"] += 1
+            assert second.parent_label == first.emitted_label < -2
+        elif second.emitter_label < 0:
+            categories["C"] += 1
+            assert second.emitter_label == first.emitted_label
+        elif second.emitter_label == first.emitter_label:
+            categories["B"] += 1
+        else:
+            categories["A"] += 1
+    assert {category: categories[category] for category in "ABCD"} == {
+        "A": count * (count - 1),
+        "B": 2 * count,
+        "C": 2 * count,
+        "D": 2 * count,
+    }
+    assert len(histories) == count**2 + 5 * count
+    assert (
+        sum(request.order == 2 for request in catalogue)
+        == (count**2 + 3 * count) ** 2 + 2 * count**2
+    )
+
+
+def test_n3lo_exhaustive_small_forest_counts_and_all_directed_pairs(pair_catalogue):
+    legs, catalogue = pair_catalogue
+    histories = _histories(catalogue, 3)
+    # Labelled ordered forests give k(k+4)(k+5) gluonic histories; each
+    # of the six q/qbar/g assignments has k(k+5) pair histories.
+    count = 2
+    gluonic = count * (count + 4) * (count + 5)
+    pair_block = count * (count + 5)
+    outputs = {
+        index: ColorConnection(legs, operations).output_legs
+        for index, operations in histories.items()
+    }
+    assert sorted(Counter(outputs.values()).values()) == [pair_block] * 6 + [gluonic]
+    assert len(histories) == gluonic + 6 * pair_block
+    observed = {
+        tuple(int(index[1:]) for index in request.id.split("/")[1:])
+        for request in catalogue
+        if request.order == 3
+    }
+    expected = {
+        (left, right)
+        for left, right in product(histories, repeat=2)
+        if outputs[left] == outputs[right]
+    }
+    assert observed == expected
+    assert len(observed) == gluonic**2 + 6 * pair_block**2 == 8232
+
+
+def test_independent_interleavings_collapse_but_shared_line_order_survives(
+    pair_catalogue,
+):
+    _, catalogue = pair_catalogue
+    histories = tuple(_histories(catalogue, 2).values())
+    independent = {EmitGluon(1, -1), EmitGluon(2, -2)}
+    assert sum(set(history) == independent for history in histories) == 1
+    assert (EmitGluon(1, -1), EmitGluon(1, -2)) in histories
+    assert (EmitGluon(1, -2), EmitGluon(1, -1)) in histories
+    # No canonical sorting is permitted to move the consumer before creation.
+    assert (EmitGluon(1, -1), EmitGluon(-1, -2)) in histories
+    assert (EmitGluon(-1, -2), EmitGluon(1, -1)) not in histories
+
+
+def test_n3lo_pair_first_and_gluon_first_cross_order_overlap_is_present(
+    pair_catalogue,
+):
+    legs, catalogue = pair_catalogue
+    histories = _histories(catalogue, 3)
+    pair_first = (
+        EmitGluon(1, -4),
+        SplitGluon(-4, -1, -2),
+        EmitGluon(-1, -3),
+    )
+    # Its raw creation history can emit the final gluon before making the
+    # pair. Final-role relabelling must still match q=-1,qbar=-2,g=-3.
+    independent_steps = {
+        EmitGluon(2, -3),
+        EmitGluon(1, -4),
+        SplitGluon(-4, -1, -2),
+    }
+    pair_index = next(i for i, steps in histories.items() if steps == pair_first)
+    other_indices = [
+        i for i, steps in histories.items() if set(steps) == independent_steps
+    ]
+    assert len(other_indices) == 1
+    other_index = other_indices[0]
+    assert (
+        ColorConnection(legs, pair_first).output_legs
+        == ColorConnection(legs, histories[other_index]).output_legs
+    )
+    requests = {request.id: request for request in catalogue}
+    assert requests[f"N3LO/c{pair_index}/c{other_index}"].bra == pair_first
+    assert requests[f"N3LO/c{other_index}/c{pair_index}"].ket == pair_first
+
+
+def test_soft_scope_labels_and_deterministic_json(pair_catalogue):
+    legs, catalogue = pair_catalogue
+    again = build_color_correlator_catalogue(tuple(reversed(legs)), through_order=3)
+    assert json.dumps([request.to_json_dict() for request in catalogue]) == json.dumps(
+        [request.to_json_dict() for request in again]
+    )
+    assert len({request.id for request in catalogue}) == len(catalogue)
+    assert all(request.id != "born" for request in catalogue)
+    for order in range(1, 4):
+        for operations in _histories(catalogue, order).values():
+            connection = ColorConnection(legs, operations)
+            assert {leg.label for leg in connection.output_legs if leg.label < 0} == {
+                -index for index in range(1, order + 1)
+            }
+            for operation in operations:
+                if isinstance(operation, SplitGluon):
+                    assert operation.parent_label < -order
+    # A singlet neither emits nor changes catalogue IDs or operations.
+    assert build_color_correlator_catalogue(
+        (*legs, ColorLeg(9, 1)), through_order=2
+    ) == tuple(request for request in catalogue if request.order <= 2)
+
+
+def test_born_adjoint_does_not_split_and_singlets_have_empty_catalogues():
+    catalogue = build_color_correlator_catalogue((ColorLeg(1, 8),), through_order=2)
+    assert not any(
+        isinstance(step, SplitGluon) and step.parent_label > 0
+        for request in catalogue
+        for step in (*request.bra, *request.ket)
+    )
+    assert build_color_correlator_catalogue((ColorLeg(1, 1),), through_order=3) == ()
+    assert build_color_correlator_catalogue((ColorLeg(1, 1),), through_order=5) == ()
+
+
+def test_n4lo_two_pairs_canonicalize_retired_labels_and_commuting_splits():
+    legs = (ColorLeg(1, 3),)
+    first = ColorConnection(
+        legs,
+        (
+            EmitGluon(1, -10),
+            SplitGluon(-10, -11, -12),
+            EmitGluon(1, -20),
+            SplitGluon(-20, -21, -22),
+        ),
+    )
+    interleaved = ColorConnection(
+        legs,
+        (
+            EmitGluon(1, -80),
+            EmitGluon(1, -70),
+            SplitGluon(-70, -21, -22),
+            SplitGluon(-80, -11, -12),
+        ),
+    )
+    # The two Born charge applications retain their relative order. Splits
+    # commute across independent active legs; retired names are pure dummies.
+    expected = dict(_labelled_histories(first))
+    assert dict(_labelled_histories(interleaved)) == expected
+    assert len(expected) == 24
+    output_counts = Counter()
+    for operations in expected.values():
+        connection = ColorConnection(legs, operations)
+        output_counts[connection.output_legs] += 1
+        assert {
+            step.parent_label for step in operations if isinstance(step, SplitGluon)
+        } == {
+            -5,
+            -6,
+        }
+    # Six q/qbar label orientations, each retaining both quark-pair
+    # assignments and both noncommuting hard-line charge orders.
+    assert sorted(output_counts.values()) == [4] * 6
+
+
+@pytest.mark.parametrize("order", (0, -1, True, 1.0, "2"))
+def test_invalid_orders_are_rejected(order):
+    with pytest.raises(ValueError, match="through_order"):
+        build_color_correlator_catalogue((ColorLeg(1, 8),), through_order=order)
+
+
+@pytest.mark.parametrize(
+    "legs",
+    ((ColorLeg(0, 8),), (ColorLeg(-1, 8),), (ColorLeg(1, 8), ColorLeg(1, 3))),
+)
+def test_invalid_born_labels_are_rejected(legs):
+    with pytest.raises(ValueError):
+        build_color_correlator_catalogue(legs, through_order=1)
diff --git a/pyamplicol/tests/unit/test_color_connections.py b/pyamplicol/tests/unit/test_color_connections.py
new file mode 100644
index 0000000000..a97e9a1604
--- /dev/null
+++ b/pyamplicol/tests/unit/test_color_connections.py
@@ -0,0 +1,588 @@
+# SPDX-License-Identifier: 0BSD
+"""Small independent generator checks for ordered exact colour connections."""
+
+from fractions import Fraction
+from itertools import permutations, product
+from math import sqrt
+
+import pytest
+
+from pyamplicol.color.connections import (
+    ColorConnection,
+    ColorLeg,
+    ColorTensor,
+    ConnectedColorTensor,
+    EmitGluon,
+    ExactColorCoefficient,
+    OpenColorString,
+    SplitGluon,
+    TensorTerm,
+    all_outgoing_color_leg,
+    apply_color_connection,
+    color_connection_matrix_element,
+    contract_connected_tensor_nc_terms,
+    contract_connected_tensors,
+    evaluate_color_nc_terms,
+)
+
+_QQ_LEGS = (ColorLeg(1, 3), ColorLeg(2, -3))
+_QQ = ColorTensor((OpenColorString(1, (), 2),))
+
+# Literal Gell-Mann matrices, independently of the symbolic Fierz machinery.
+_LAMBDA = (
+    ((0, 1, 0), (1, 0, 0), (0, 0, 0)),
+    ((0, -1j, 0), (1j, 0, 0), (0, 0, 0)),
+    ((1, 0, 0), (0, -1, 0), (0, 0, 0)),
+    ((0, 0, 1), (0, 0, 0), (1, 0, 0)),
+    ((0, 0, -1j), (0, 0, 0), (1j, 0, 0)),
+    ((0, 0, 0), (0, 0, 1), (0, 1, 0)),
+    ((0, 0, 0), (0, 0, -1j), (0, 1j, 0)),
+    ((1 / sqrt(3), 0, 0), (0, 1 / sqrt(3), 0), (0, 0, -2 / sqrt(3))),
+)
+_T = tuple(
+    tuple(tuple(value / 2 for value in row) for row in matrix) for matrix in _LAMBDA
+)
+_TAU = tuple(
+    tuple(tuple(value / sqrt(2) for value in row) for row in matrix)
+    for matrix in _LAMBDA
+)
+_IDENTITY = ((1, 0, 0), (0, 1, 0), (0, 0, 1))
+_F = {}
+for _indices, _value in (
+    ((1, 2, 3), 1),
+    ((1, 4, 7), 0.5),
+    ((1, 5, 6), -0.5),
+    ((2, 4, 6), 0.5),
+    ((2, 5, 7), 0.5),
+    ((3, 4, 5), 0.5),
+    ((3, 6, 7), -0.5),
+    ((4, 5, 8), sqrt(3) / 2),
+    ((6, 7, 8), sqrt(3) / 2),
+):
+    for _permutation in permutations(range(3)):
+        _sign = (-1) ** sum(
+            _permutation[i] > _permutation[j] for i in range(3) for j in range(i + 1, 3)
+        )
+        _F[tuple(_indices[i] - 1 for i in _permutation)] = _sign * _value
+
+
+def _matrix_product(left, right):
+    return tuple(
+        tuple(sum(left[i][k] * right[k][j] for k in range(3)) for j in range(3))
+        for i in range(3)
+    )
+
+
+def _word_matrix(word, values):
+    result = _IDENTITY
+    for label in word:
+        result = _matrix_product(result, _TAU[values[label]])
+    return result
+
+
+def _tensor_component(tensor, values):
+    result = 1 + 0j
+    for string in tensor.open_strings:
+        result *= _word_matrix(string.adjoint_labels, values)[
+            values[string.fundamental_label]
+        ][values[string.antifundamental_label]]
+    for trace in tensor.traces:
+        matrix = _word_matrix(trace, values)
+        result *= sum(matrix[index][index] for index in range(3))
+    return result
+
+
+def _assignments(legs):
+    labels = tuple(leg.label for leg in legs)
+    sizes = tuple(
+        8 if leg.representation == 8 else 1 if leg.representation == 1 else 3
+        for leg in legs
+    )
+    for indices in product(*(range(size) for size in sizes)):
+        yield indices, dict(zip(labels, indices, strict=True))
+
+
+def _explicit_state(tensor, connection):
+    """Apply explicit physical 3x3 or 8x8 generators to colour components."""
+    legs = connection.initial_legs
+    state = {
+        key: _tensor_component(tensor, values) for key, values in _assignments(legs)
+    }
+    for step, emission in enumerate(connection.emissions):
+        out_legs = ColorConnection(
+            connection.initial_legs, connection.emissions[: step + 1]
+        ).output_legs
+        out_state = {}
+        if isinstance(emission, EmitGluon):
+            representation = next(
+                leg.representation
+                for leg in legs
+                if leg.label == emission.emitter_label
+            )
+            dimension = 8 if representation == 8 else 3
+            for key, values in _assignments(out_legs):
+                b, a = values[emission.emitted_label], values[emission.emitter_label]
+                result = 0j
+                for old in range(dimension):
+                    charge = (
+                        _T[b][a][old]
+                        if representation == 3
+                        else -_T[b][old][a]
+                        if representation == -3
+                        else -1j * _F.get((b, a, old), 0)
+                    )
+                    source = tuple(
+                        old
+                        if leg.label == emission.emitter_label
+                        else values[leg.label]
+                        for leg in legs
+                    )
+                    result += charge * state[source]
+                out_state[key] = result
+        else:
+            for key, values in _assignments(out_legs):
+                out_state[key] = sum(
+                    _T[a][values[emission.quark_label]][
+                        values[emission.antiquark_label]
+                    ]
+                    * state[
+                        tuple(
+                            a
+                            if leg.label == emission.parent_label
+                            else values[leg.label]
+                            for leg in legs
+                        )
+                    ]
+                    for a in range(8)
+                )
+        legs, state = out_legs, out_state
+    return state
+
+
+def _explicit_overlap(left_tensor, left_graph, right_tensor, right_graph):
+    left = _explicit_state(left_tensor, left_graph)
+    right = _explicit_state(right_tensor, right_graph)
+    return sum(value.conjugate() * right[key] for key, value in left.items())
+
+
+def test_physical_dipole_normalization_and_signed_offdiagonal():
+    identity = ColorConnection(_QQ_LEGS)
+    quark = ColorConnection(_QQ_LEGS, (EmitGluon(1, 3),))
+    anti = ColorConnection(_QQ_LEGS, (EmitGluon(2, 3),))
+    born = color_connection_matrix_element(_QQ, identity, _QQ, identity)
+    assert born == ExactColorCoefficient(3)
+    assert color_connection_matrix_element(_QQ, quark, _QQ, quark) == born.scaled(
+        Fraction(4, 3)
+    )
+    assert color_connection_matrix_element(
+        _QQ, anti, _QQ, anti
+    ) == ExactColorCoefficient(4)
+    assert color_connection_matrix_element(
+        _QQ, quark, _QQ, anti
+    ) == ExactColorCoefficient(-4)
+
+
+@pytest.mark.parametrize(
+    ("emissions", "expected"),
+    (
+        ((EmitGluon(1, 3),), {2: Fraction(1, 2), 0: Fraction(-1, 2)}),
+        (
+            (EmitGluon(1, 3), EmitGluon(1, 4)),
+            {3: Fraction(1, 4), 1: Fraction(-1, 2), -1: Fraction(1, 4)},
+        ),
+        (
+            (EmitGluon(1, 3), SplitGluon(3, 4, 5)),
+            {2: Fraction(1, 4), 0: Fraction(-1, 4)},
+        ),
+        (
+            (EmitGluon(1, 3), EmitGluon(1, 4), EmitGluon(1, 5)),
+            {
+                4: Fraction(1, 8),
+                2: Fraction(-3, 8),
+                0: Fraction(3, 8),
+                -2: Fraction(-1, 8),
+            },
+        ),
+        (
+            (EmitGluon(1, 3), SplitGluon(3, 4, 5), EmitGluon(4, 6)),
+            {3: Fraction(1, 8), 1: Fraction(-1, 4), -1: Fraction(1, 8)},
+        ),
+    ),
+)
+def test_laurent_coefficients_preserve_casimirs_and_splitting_through_n3lo(
+    emissions, expected
+):
+    image = apply_color_connection(_QQ, ColorConnection(_QQ_LEGS, emissions))
+    terms = contract_connected_tensor_nc_terms(image, image)
+    assert terms == {
+        power: ExactColorCoefficient(value) for power, value in expected.items()
+    }
+    assert evaluate_color_nc_terms(terms) == contract_connected_tensors(image, image)
+
+
+def test_laurent_terms_are_not_cancelled_only_because_nc_is_three():
+    # (Nc - 3) delta_ij is zero at Nc=3, but not the zero Laurent tensor.
+    image = ConnectedColorTensor(
+        _QQ_LEGS,
+        (
+            TensorTerm(ExactColorCoefficient(1), _QQ, 1),
+            TensorTerm(ExactColorCoefficient(-3), _QQ),
+        ),
+    )
+    assert len(image.terms) == 2
+    terms = contract_connected_tensor_nc_terms(image, image)
+    assert terms == {
+        3: ExactColorCoefficient(1),
+        2: ExactColorCoefficient(-6),
+        1: ExactColorCoefficient(9),
+    }
+    assert evaluate_color_nc_terms(terms) == ExactColorCoefficient()
+
+
+def test_empty_trace_retains_its_symbolic_nc_power():
+    tensor = ColorTensor(_QQ.open_strings, ((),))
+    image = apply_color_connection(tensor, ColorConnection(_QQ_LEGS))
+    assert image.terms == (TensorTerm(ExactColorCoefficient(1), _QQ, 1),)
+    assert contract_connected_tensor_nc_terms(image, image) == {
+        3: ExactColorCoefficient(1)
+    }
+
+
+def test_all_outgoing_crossing_is_separate_and_dualizes_only_fundamentals():
+    assert all_outgoing_color_leg(1, 3, incoming=True) == ColorLeg(1, -3)
+    assert all_outgoing_color_leg(1, -3, incoming=True) == ColorLeg(1, 3)
+    assert all_outgoing_color_leg(1, 8, incoming=True) == ColorLeg(1, 8)
+    assert all_outgoing_color_leg(1, 1, incoming=True) == ColorLeg(1, 1)
+    assert all_outgoing_color_leg(1, 3) == ColorLeg(1, 3)
+    legs = (all_outgoing_color_leg(1, 3, incoming=True), ColorLeg(2, 3))
+    tensor = ColorTensor((OpenColorString(2, (), 1),))
+    crossed = ColorConnection(legs, (EmitGluon(1, 3),))
+    outgoing = ColorConnection(legs, (EmitGluon(2, 3),))
+    assert color_connection_matrix_element(
+        tensor, crossed, tensor, outgoing
+    ) == ExactColorCoefficient(-4)
+
+
+def test_quark_antiquark_and_adjoint_charges_obey_exact_colour_conservation():
+    legs = (*_QQ_LEGS, ColorLeg(3, 8))
+    tensor = ColorTensor((OpenColorString(1, (3,), 2),))
+    graphs = tuple(ColorConnection(legs, (EmitGluon(label, 4),)) for label in (1, 2, 3))
+    images = tuple(apply_color_connection(tensor, graph) for graph in graphs)
+    summed = ConnectedColorTensor(
+        images[0].legs, tuple(term for image in images for term in image.terms), 1
+    )
+    assert summed.terms == ()
+    for i, graph in enumerate(graphs):
+        row = [
+            color_connection_matrix_element(tensor, graph, tensor, other)
+            for other in graphs
+        ]
+        assert sum(value.real for value in row) == 0
+        assert all(value.imag == 0 for value in row)
+        assert row[i] == ExactColorCoefficient(
+            Fraction(8) * (3 if i == 2 else Fraction(4, 3))
+        )
+        for j, other in enumerate(graphs):
+            assert complex(row[j]) == pytest.approx(
+                _explicit_overlap(tensor, graph, tensor, other), abs=1e-12
+            )
+
+
+def test_ordered_emissions_do_not_commute():
+    first = ColorConnection(_QQ_LEGS, (EmitGluon(1, 3), EmitGluon(1, 4)))
+    reversed_order = ColorConnection(_QQ_LEGS, (EmitGluon(1, 4), EmitGluon(1, 3)))
+    assert (
+        apply_color_connection(_QQ, first).terms
+        != apply_color_connection(_QQ, reversed_order).terms
+    )
+    assert color_connection_matrix_element(
+        _QQ, first, _QQ, first
+    ) == ExactColorCoefficient(Fraction(16, 3))
+    cross = color_connection_matrix_element(_QQ, first, _QQ, reversed_order)
+    assert cross == ExactColorCoefficient(Fraction(-2, 3))
+    assert complex(cross) == pytest.approx(
+        _explicit_overlap(_QQ, first, _QQ, reversed_order), abs=1e-12
+    )
+
+
+def test_shared_leg_dipole_products_and_documented_anticommutator():
+    legs = (ColorLeg(1, 3), ColorLeg(2, -3), ColorLeg(3, 3), ColorLeg(4, -3))
+    # Literal tensors: no generated-basis endpoint-pairing phase is attached.
+    basis = (
+        ColorTensor((OpenColorString(1, (), 2), OpenColorString(3, (), 4))),
+        ColorTensor((OpenColorString(1, (), 4), OpenColorString(3, (), 2))),
+    )
+    bra = ColorConnection(legs, (EmitGluon(3, -1), EmitGluon(1, -2)))
+    ket_ab = ColorConnection(legs, (EmitGluon(2, -2), EmitGluon(2, -1)))
+    ket_ba = ColorConnection(legs, (EmitGluon(2, -1), EmitGluon(2, -2)))
+    states = tuple(_explicit_state(tensor, ColorConnection(legs)) for tensor in basis)
+
+    def charge(state, label, adjoint):
+        position = label - 1
+        result = {}
+        for indices in state:
+            value = 0j
+            for old in range(3):
+                source = list(indices)
+                source[position] = old
+                generator = (
+                    _T[adjoint][indices[position]][old]
+                    if legs[position].representation == 3
+                    else -_T[adjoint][old][indices[position]]
+                )
+                value += generator * state[tuple(source)]
+            result[indices] = value
+        return result
+
+    def dipole(state, first, second):
+        result = dict.fromkeys(state, 0j)
+        for adjoint in range(8):
+            branch = charge(charge(state, second, adjoint), first, adjoint)
+            for indices, value in branch.items():
+                result[indices] += value
+        return result
+
+    # A = T2.T3 and B = T1.T2 share leg 2: their order cannot be exchanged.
+    expected_ab = ((Fraction(0), Fraction(-2, 3)), (Fraction(16, 3), Fraction(0)))
+    expected_ba = ((Fraction(0), Fraction(16, 3)), (Fraction(-2, 3), Fraction(0)))
+    expected_anticommutator = (
+        (Fraction(0), Fraction(14, 3)),
+        (Fraction(14, 3), Fraction(0)),
+    )
+    for i, (left, left_state) in enumerate(zip(basis, states, strict=True)):
+        for j, (right, right_state) in enumerate(zip(basis, states, strict=True)):
+            ab = color_connection_matrix_element(left, bra, right, ket_ab)
+            ba = color_connection_matrix_element(left, bra, right, ket_ba)
+            assert ab == ExactColorCoefficient(expected_ab[i][j])
+            assert ba == ExactColorCoefficient(expected_ba[i][j])
+            assert ab + ba == ExactColorCoefficient(expected_anticommutator[i][j])
+            assert ab == ExactColorCoefficient(expected_ba[j][i]).conjugate()
+            # Independent physical generators act directly on Born colour
+            # components; no connected-overlap matrix is multiplied here.
+            for actual, explicit in (
+                (ab, dipole(dipole(right_state, 1, 2), 2, 3)),
+                (ba, dipole(dipole(right_state, 2, 3), 1, 2)),
+            ):
+                expected = sum(
+                    value.conjugate() * explicit[indices]
+                    for indices, value in left_state.items()
+                )
+                assert complex(actual) == pytest.approx(expected, abs=1e-12)
+
+
+@pytest.mark.parametrize(
+    ("emissions", "expected"),
+    (
+        ((EmitGluon(1, 3), EmitGluon(1, 4), EmitGluon(1, 5)), Fraction(64, 9)),
+        ((EmitGluon(1, 3), EmitGluon(3, 4), EmitGluon(4, 5)), Fraction(36)),
+        ((EmitGluon(1, 3), SplitGluon(3, 4, 5), EmitGluon(4, 6)), Fraction(8, 3)),
+        ((EmitGluon(1, 3), EmitGluon(3, 4), SplitGluon(4, 5, 6)), Fraction(6)),
+    ),
+)
+def test_three_emissions_include_radiating_emitted_gluons_and_quark_pairs(
+    emissions, expected
+):
+    graph = ColorConnection(_QQ_LEGS, emissions)
+    image = apply_color_connection(_QQ, graph)
+    exact = contract_connected_tensors(image, image)
+    assert image.normalization_power == 3
+    assert exact == ExactColorCoefficient(expected)
+    assert complex(exact) == pytest.approx(
+        _explicit_overlap(_QQ, graph, _QQ, graph), abs=2e-11
+    )
+
+
+@pytest.mark.parametrize("order", (4, 5))
+def test_generic_order_same_line_casimir_powers(order):
+    emissions = tuple(EmitGluon(1, -index) for index in range(1, order + 1))
+    image = apply_color_connection(_QQ, ColorConnection(_QQ_LEGS, emissions))
+    assert contract_connected_tensors(image, image) == ExactColorCoefficient(
+        3 * Fraction(4, 3) ** order
+    )
+
+
+def test_four_operations_with_two_quark_pairs():
+    graph = ColorConnection(_QQ_LEGS, (
+        EmitGluon(1, -5), SplitGluon(-5, -1, -2),
+        EmitGluon(1, -6), SplitGluon(-6, -3, -4),
+    ))
+    image = apply_color_connection(_QQ, graph)
+    assert graph.order == 4
+    assert contract_connected_tensors(image, image) == ExactColorCoefficient(
+        3 * (Fraction(4, 3) * Fraction(1, 2)) ** 2
+    )
+
+
+def test_n3lo_quark_pair_cross_connections_match_explicit_generators():
+    left = ColorConnection(
+        _QQ_LEGS, (EmitGluon(1, 3), SplitGluon(3, 4, 5), EmitGluon(4, 6))
+    )
+    right = ColorConnection(
+        _QQ_LEGS, (EmitGluon(2, 6), EmitGluon(1, 3), SplitGluon(3, 4, 5))
+    )
+    actual = color_connection_matrix_element(_QQ, left, _QQ, right)
+    assert complex(actual) == pytest.approx(
+        _explicit_overlap(_QQ, left, _QQ, right), abs=1e-12
+    )
+    assert color_connection_matrix_element(_QQ, right, _QQ, left) == actual.conjugate()
+
+
+@pytest.mark.parametrize(
+    ("prefix", "next_gluon"),
+    (
+        ((EmitGluon(1, 3),), 4),
+        ((EmitGluon(1, 3), EmitGluon(3, 4)), 5),
+        ((EmitGluon(1, 3), SplitGluon(3, 4, 5)), 6),
+    ),
+)
+def test_nnlo_n3lo_colour_coherence_includes_every_active_emitted_parton(
+    prefix, next_gluon
+):
+    intermediate = ColorConnection(_QQ_LEGS, prefix)
+    images = tuple(
+        apply_color_connection(
+            _QQ,
+            ColorConnection(_QQ_LEGS, (*prefix, EmitGluon(leg.label, next_gluon))),
+        )
+        for leg in intermediate.output_legs
+    )
+    # Charge conservation acts on the intermediate state, including auxiliary
+    # gluons and both endpoints of an emitted quark pair. The new operation is
+    # applied last on every branch, with unit sum weights and physical signs
+    # supplied by the quark/antiquark/adjoint charge maps themselves.
+    total = ConnectedColorTensor(
+        images[0].legs,
+        tuple(term for image in images for term in image.terms),
+        len(prefix) + 1,
+    )
+    assert total.terms == ()
+    for bra in images:
+        row_sum = ExactColorCoefficient()
+        for ket in images:
+            row_sum = row_sum + contract_connected_tensors(bra, ket)
+        assert row_sum == ExactColorCoefficient()
+
+    # These examples would fail if a higher-order sum only included Born legs.
+    born_only = ConnectedColorTensor(
+        images[0].legs,
+        tuple(
+            term
+            for leg, image in zip(intermediate.output_legs, images, strict=True)
+            if leg.label in (1, 2)
+            for term in image.terms
+        ),
+        len(prefix) + 1,
+    )
+    assert contract_connected_tensors(born_only, born_only).real > 0
+
+
+def test_splitting_a_trace_keeps_open_plus_closed_trace_intermediates():
+    legs = tuple(ColorLeg(label, 8) for label in (1, 2, 3))
+    tensor = ColorTensor(traces=((1, 2, 3),))
+    graph = ColorConnection(legs, (SplitGluon(1, 4, 5),))
+    image = apply_color_connection(tensor, graph)
+    assert len(image.terms) == 2
+    assert any(term.tensor.open_strings and term.tensor.traces for term in image.terms)
+    actual = contract_connected_tensors(image, image)
+    assert complex(actual) == pytest.approx(
+        _explicit_overlap(tensor, graph, tensor, graph), abs=1e-12
+    )
+    assert actual == ExactColorCoefficient(Fraction(28, 3))
+
+
+def test_multiple_traces_and_conjugation_match_literal_generators():
+    legs = tuple(ColorLeg(label, 8) for label in (1, 2, 3, 4))
+    graph = ColorConnection(legs)
+    left = ColorTensor(traces=((1, 2), (3, 4)))
+    right = ColorTensor(traces=((1, 3, 2, 4),))
+    actual = color_connection_matrix_element(left, graph, right, graph)
+    assert complex(actual) == pytest.approx(
+        _explicit_overlap(left, graph, right, graph), abs=1e-12
+    )
+    assert ColorTensor(traces=((2, 3, 1),)) == ColorTensor(traces=((1, 2, 3),))
+    assert ColorTensor(traces=((1, 3, 2),)) != ColorTensor(traces=((1, 2, 3),))
+
+
+def test_complex_trace_components_are_conjugated_by_reversing_the_bra_word():
+    legs = tuple(ColorLeg(label, 8) for label in (1, 2, 3))
+    identity = ColorConnection(legs)
+    left = ColorTensor(traces=((1, 2, 3),))
+    right = ColorTensor(traces=((1, 3, 2),))
+    assert color_connection_matrix_element(
+        left, identity, left, identity
+    ) == ExactColorCoefficient(Fraction(56, 3))
+    actual = color_connection_matrix_element(left, identity, right, identity)
+    assert actual == ExactColorCoefficient(Fraction(-16, 3))
+    assert complex(actual) == pytest.approx(
+        _explicit_overlap(left, identity, right, identity), abs=1e-12
+    )
+    images = tuple(
+        apply_color_connection(left, ColorConnection(legs, (EmitGluon(label, 4),)))
+        for label in (1, 2, 3)
+    )
+    assert (
+        ConnectedColorTensor(
+            images[0].legs, tuple(term for image in images for term in image.terms), 1
+        ).terms
+        == ()
+    )
+
+
+def test_literal_endpoint_pairings_do_not_inject_a_fermion_permutation_sign():
+    legs = (*_QQ_LEGS, ColorLeg(3, 3), ColorLeg(4, -3))
+    graph = ColorConnection(legs)
+    direct = ColorTensor((OpenColorString(1, (), 2), OpenColorString(3, (), 4)))
+    crossed = ColorTensor((OpenColorString(1, (), 4), OpenColorString(3, (), 2)))
+    assert color_connection_matrix_element(
+        direct, graph, crossed, graph
+    ) == ExactColorCoefficient(3)
+
+
+def test_overlap_retains_complex_coefficients_and_bra_conjugation():
+    graph = ColorConnection(_QQ_LEGS)
+    actual = color_connection_matrix_element(
+        _QQ,
+        graph,
+        _QQ,
+        graph,
+        left_coefficient=ExactColorCoefficient(1, 2),
+        right_coefficient=ExactColorCoefficient(3, -1),
+    )
+    assert actual == ExactColorCoefficient(3, -21)
+
+
+@pytest.mark.parametrize(
+    "emissions",
+    (
+        (EmitGluon(9, 3),),
+        (EmitGluon(1, 1),),
+        (SplitGluon(1, 3, 4),),
+        (EmitGluon(1, 3), SplitGluon(3, 4, 4)),
+        (EmitGluon(1, 3), SplitGluon(3, 4, 5), EmitGluon(3, 6)),
+        (EmitGluon(1, 3), SplitGluon(3, 4, 5), EmitGluon(1, 3)),
+    ),
+)
+def test_invalid_ordered_graphs_are_rejected(emissions):
+    with pytest.raises(ValueError):
+        ColorConnection(_QQ_LEGS, emissions)
+
+
+def test_mismatched_tensor_domains_and_graph_outputs_are_rejected():
+    with pytest.raises(ValueError, match="exactly once"):
+        apply_color_connection(ColorTensor(), ColorConnection(_QQ_LEGS))
+    with pytest.raises(ValueError, match="typed output"):
+        color_connection_matrix_element(
+            _QQ,
+            ColorConnection(_QQ_LEGS, (EmitGluon(1, 3),)),
+            _QQ,
+            ColorConnection(_QQ_LEGS, (EmitGluon(1, 4),)),
+        )
+    with pytest.raises(ValueError, match="odd"):
+        contract_connected_tensors(
+            ConnectedColorTensor(
+                _QQ_LEGS, (TensorTerm(ExactColorCoefficient(1), _QQ),), 0
+            ),
+            ConnectedColorTensor(
+                _QQ_LEGS, (TensorTerm(ExactColorCoefficient(1), _QQ),), 1
+            ),
+        )
diff --git a/pyamplicol/tests/unit/test_color_contraction_safety.py b/pyamplicol/tests/unit/test_color_contraction_safety.py
new file mode 100644
index 0000000000..4d30aa43b4
--- /dev/null
+++ b/pyamplicol/tests/unit/test_color_contraction_safety.py
@@ -0,0 +1,930 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from fractions import Fraction
+from itertools import permutations
+from math import isclose, nextafter
+
+import pytest
+
+import pyamplicol.color as color
+import pyamplicol.color.contraction_factors as contraction_factors
+import pyamplicol.generation.artifact_writer as artifact_writer
+from pyamplicol.color import (
+    ColorContractionEntry,
+    ColorContractionTemplateEntry,
+    ColorGroupDescriptor,
+    FactorizedColorContractionBlock,
+    RepeatedColorContractionBlock,
+    build_color_contraction_plan,
+    build_color_plan,
+    color_contraction_factor,
+    color_contraction_factors,
+    exact_color_contraction_factor,
+    exact_color_contraction_factors,
+)
+from pyamplicol.color.contraction import _build_walsh_color_contraction_block
+from pyamplicol.color.contraction_factors import (
+    _pure_adjoint_full_factor_by_relative_permutation,
+    _pure_adjoint_full_factor_uncached,
+    _relative_adjoint_permutation,
+)
+from pyamplicol.generation.artifact_writer import _color_contraction
+from pyamplicol.generation.dag_color import ColorEngine
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_ordering import _sector_intermediate_order_words
+from pyamplicol.models.builtin.model import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def test_color_one_open_line_factors_match_reference_convention() -> None:
+    plan = build_color_plan(
+        build_process_ir("d d~ > z g", color_accuracy="full"),
+        color_accuracy="full",
+    )
+    sector = plan.sectors[0]
+    assert color_contraction_factors(plan, sector, sector) == (9.0, 8.0, 8.0)
+
+
+@pytest.mark.parametrize(
+    "process",
+    (
+        "g g > g g",
+        "d d~ > z g",
+        "d d~ > u u~",
+        "d d~ > u u~ s s~ g",
+    ),
+)
+def test_exact_color_factors_match_binary64_reference_for_every_sector_pair(
+    process: str,
+) -> None:
+    plan = build_color_plan(
+        build_process_ir(process, color_accuracy="full"),
+        color_accuracy="full",
+    )
+
+    for left in plan.sectors:
+        for right in plan.sectors:
+            exact = exact_color_contraction_factors(plan, left, right)
+            binary64 = color_contraction_factors(plan, left, right)
+            assert all(isinstance(value, Fraction) for value in exact)
+            assert tuple(float(value) for value in exact) == binary64
+            for accuracy, expected in zip(
+                ("lc", "nlc", "full"),
+                exact,
+                strict=True,
+            ):
+                assert (
+                    exact_color_contraction_factor(
+                        plan,
+                        left,
+                        right,
+                        accuracy=accuracy,
+                    )
+                    == expected
+                )
+
+
+def test_pure_adjoint_full_factors_cache_relative_permutations_exactly() -> None:
+    words = tuple(permutations((11, 13, 17, 19)))
+    _pure_adjoint_full_factor_by_relative_permutation.cache_clear()
+
+    for left in words:
+        for right in words:
+            relative = _relative_adjoint_permutation(left, right)
+            assert relative is not None
+            cached = _pure_adjoint_full_factor_by_relative_permutation(
+                relative,
+                len(left),
+                20,
+            )
+            direct = _pure_adjoint_full_factor_uncached(
+                left,
+                right,
+                len(left),
+                20,
+            )
+            assert cached == direct
+
+    info = _pure_adjoint_full_factor_by_relative_permutation.cache_info()
+    assert info.misses == len(words)
+    assert info.hits == len(words) * (len(words) - 1)
+
+
+def test_pure_adjoint_exact_nlc_does_not_compute_full_color(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    plan = build_color_plan(
+        build_process_ir("g g > g g", color_accuracy="nlc"),
+        color_accuracy="nlc",
+    )
+
+    def reject_full_color(*args: object, **kwargs: object) -> None:
+        raise AssertionError("NLC requested an unnecessary full-colour trace")
+
+    monkeypatch.setattr(
+        contraction_factors,
+        "_pure_adjoint_full_factor_exact_by_relative_permutation",
+        reject_full_color,
+    )
+    monkeypatch.setattr(
+        contraction_factors,
+        "_pure_adjoint_full_factor_exact_uncached",
+        reject_full_color,
+    )
+    for left in plan.sectors:
+        for right in plan.sectors:
+            assert exact_color_contraction_factor(
+                plan, left, right, accuracy="nlc"
+            ) == Fraction(color_contraction_factor(plan, left, right, accuracy="nlc"))
+
+
+def test_color_plan_json_exposes_structural_open_line_roles() -> None:
+    plan = build_color_plan(build_process_ir("d d~ > z g"))
+    sector_record = plan.sectors[0]
+
+    assert isinstance(sector_record.open_color_lines[0], color.LCOpenColorLine)
+    assert not hasattr(sector_record, "quark_lines")
+    assert not hasattr(color, "LCQuarkLine")
+
+    payload = plan.to_json_dict()
+    sector = payload["sectors"][0]
+    line = sector["open_color_lines"][0]
+
+    assert set(sector) == {
+        "id",
+        "kind",
+        "open_color_lines",
+        "trace_labels",
+        "singlet_labels",
+        "word_labels",
+        "coloured_label_groups",
+        "line_label_groups",
+        "color_words",
+        "admissible_traversal_words",
+    }
+    assert "idenso_required" not in payload
+
+    assert "quark_lines" not in sector
+    assert line == {
+        "fundamental_label": 2,
+        "antifundamental_label": 1,
+        "adjoint_labels": [4],
+        "singlet_labels": [],
+        "line_labels": [2, 4, 1],
+    }
+    assert not {"quark_label", "antiquark_label", "gluon_labels"} & line.keys()
+
+
+def test_three_open_lines_keep_distinct_fixed_sink_traversals() -> None:
+    process = build_process_ir("d d~ > u u~ s s~")
+    plan = build_color_plan(process)
+    sector = plan.sectors[0]
+
+    assert sector.color_words == ((2, 1, 3, 4, 5, 6),)
+    assert _sector_intermediate_order_words(sector, process=process) == (
+        (2, 1, 3, 4, 5, 6),
+        (3, 4, 2, 1, 5, 6),
+    )
+
+
+def test_three_open_line_nlc_keeps_exact_qualified_coefficients() -> None:
+    plan = build_color_plan(
+        build_process_ir(
+            "d d~ > u u~ s s~ g",
+            color_accuracy="full",
+        ),
+        color_accuracy="full",
+    )
+    sectors = {sector.word_labels: sector for sector in plan.sectors}
+    reference = sectors[(2, 1, 3, 4, 5, 7, 6)]
+
+    assert color_contraction_factors(plan, reference, reference) == (
+        81.0,
+        72.0,
+        72.0,
+    )
+    assert color_contraction_factors(
+        plan,
+        reference,
+        sectors[(2, 1, 3, 6, 5, 7, 4)],
+    ) == (0.0, -24.0, -24.0)
+    assert color_contraction_factors(
+        plan,
+        reference,
+        sectors[(2, 4, 3, 6, 5, 7, 1)],
+    ) == (0.0, 8.0, 8.0)
+
+
+def test_nlc_one_open_line_recycles_runtime_route_safe_orderings() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("g g > t t~ g", color_accuracy="nlc")
+    plan = build_color_plan(process, color_accuracy="nlc")
+    engine = ColorEngine(plan, model)
+    dag = compile_generic_dag(process, model=model)
+
+    assert plan.sector_count == 6
+    assert engine.shared_lc_orderings is True
+    assert len(dag.currents) == 250
+    assert len(dag.interactions) == 624
+    # Reversed ordered-label routes stay distinct even when their color
+    # ordering is shared; only route-safe kernel evaluations may be recycled.
+    assert dag.interaction_evaluation_count == 420
+    assert len(dag.amplitude_roots) == 192
+
+
+def test_nlc_multiple_open_lines_keep_pairing_identity_sector_local() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > u u~ s s~", color_accuracy="nlc")
+    plan = build_color_plan(process, color_accuracy="nlc")
+    engine = ColorEngine(plan, model)
+
+    assert plan.sector_count > 1
+    assert engine.shared_lc_orderings is False
+
+
+def test_color_contraction_rejects_inconsistent_helicity_weights() -> None:
+    plan = build_color_plan(
+        build_process_ir("d d~ > z g", color_accuracy="full"),
+        color_accuracy="full",
+    )
+    sector = plan.sectors[0]
+    common = {
+        "helicity_key": ("h:-1,+1,+0,+1",),
+        "sector_id": sector.id,
+        "word": tuple(sector.word_labels or sector.color_words[0]),
+    }
+    groups = (
+        ColorGroupDescriptor(group_id=0, helicity_weight=1.0, **common),
+        ColorGroupDescriptor(group_id=1, helicity_weight=0.5, **common),
+    )
+
+    with pytest.raises(ValueError, match="inconsistent helicity weights"):
+        build_color_contraction_plan(plan, groups)
+
+
+def test_color_contraction_compacts_identical_helicity_components() -> None:
+    plan = build_color_plan(
+        build_process_ir("g g > g g", color_accuracy="full"),
+        color_accuracy="full",
+    )
+    first, second = plan.sectors[:2]
+    first_word = tuple(first.word_labels or first.color_words[0])
+    second_word = tuple(second.word_labels or second.color_words[0])
+    groups = (
+        ColorGroupDescriptor(
+            group_id=10,
+            helicity_key=("helicity:a",),
+            sector_id=second.id,
+            word=second_word,
+            helicity_weight=1.0,
+        ),
+        ColorGroupDescriptor(
+            group_id=20,
+            helicity_key=("helicity:b",),
+            sector_id=first.id,
+            word=first_word,
+            helicity_weight=1.0,
+        ),
+        ColorGroupDescriptor(
+            group_id=30,
+            helicity_key=("helicity:a",),
+            sector_id=first.id,
+            word=first_word,
+            helicity_weight=1.0,
+        ),
+        ColorGroupDescriptor(
+            group_id=40,
+            helicity_key=("helicity:b",),
+            sector_id=second.id,
+            word=second_word,
+            helicity_weight=1.0,
+        ),
+    )
+
+    contraction = build_color_contraction_plan(plan, groups)
+
+    assert contraction is not None
+    assert contraction.entries == ()
+    block = contraction.repeated_block
+    assert block is not None
+    assert block.component_count == 2
+    assert block.component_group_ids == (30, 20, 10, 40)
+    logical = tuple(contraction.iter_logical_entries())
+    assert len(logical) == contraction.logical_entry_count
+    assert tuple(
+        (entry.left_group_id, entry.right_group_id) for entry in logical
+    ) == tuple(
+        (
+            block.component_group_ids[
+                entry.left_group_index * block.component_count + component
+            ],
+            block.component_group_ids[
+                entry.right_group_index * block.component_count + component
+            ],
+        )
+        for component in range(block.component_count)
+        for entry in block.entries
+    )
+    payload = contraction.to_json_dict()
+    assert payload["entry_count"] == 0
+    assert payload["logical_entry_count"] == len(logical)
+    assert payload["entries"] == []
+    assert payload["repeated_block"] == block.to_json_dict()
+    assert _color_contraction(payload)["repeated_block"] == block.to_json_dict()
+
+    expanded = tuple(
+        entry
+        for helicity_key in (("helicity:a",), ("helicity:b",))
+        for entry in (
+            build_color_contraction_plan(
+                plan,
+                tuple(
+                    descriptor
+                    for descriptor in groups
+                    if descriptor.helicity_key == helicity_key
+                ),
+            )
+            or pytest.fail("single-component contraction is absent")
+        ).entries
+    )
+    amplitudes = {
+        10: complex(0.5, -1.0),
+        20: complex(1.5, 0.25),
+        30: complex(-0.75, 2.0),
+        40: complex(0.125, -0.5),
+    }
+
+    def reduce(entries: tuple[ColorContractionEntry, ...]) -> float:
+        total = 0.0
+        for entry in entries:
+            left = amplitudes[entry.left_group_id]
+            right = amplitudes[entry.right_group_id]
+            product = left * right.conjugate()
+            total += entry.symmetry_factor * (
+                entry.weight_re * product.real - entry.weight_im * product.imag
+            )
+        return total
+
+    assert isclose(reduce(logical), reduce(expanded), rel_tol=1.0e-15, abs_tol=1.0e-15)
+
+
+def test_full_color_permutation_orbit_emits_klein_four_walsh_plan() -> None:
+    plan = build_color_plan(
+        build_process_ir("d d~ > z g g g g", color_accuracy="full"),
+        color_accuracy="full",
+    )
+    groups = tuple(
+        ColorGroupDescriptor(
+            group_id=component_index * len(plan.sectors) + sector_index,
+            helicity_key=(f"helicity:{component_index}",),
+            sector_id=sector.id,
+            word=tuple(sector.word_labels or sector.color_words[0]),
+            helicity_weight=1.0,
+        )
+        for component_index in range(2)
+        for sector_index, sector in enumerate(plan.sectors)
+    )
+
+    contraction = build_color_contraction_plan(plan, groups)
+
+    assert contraction is not None
+    block = contraction.repeated_block
+    assert block is not None
+    factorized = block.factorized_block
+    assert factorized is not None
+    assert factorized.kind == "klein-four-walsh"
+    assert factorized.rank is None
+    assert len(factorized.cosets) == len(plan.sectors) // 4
+    assert sorted(index for coset in factorized.cosets for index in coset) == list(
+        range(len(plan.sectors))
+    )
+    payload = contraction.to_json_dict()
+    assert "rank" not in payload["repeated_block"]["factorized_block"]
+    assert payload["repeated_block"] == block.to_json_dict()
+    assert _color_contraction(payload)["repeated_block"] == block.to_json_dict()
+    assert artifact_writer._runtime_schema_uses_walsh_color_contraction(
+        {"amplitude_stage": {"color_contraction": payload}}
+    )
+
+
+def _elementary_abelian_orbit_words(rank: int) -> tuple[tuple[int, ...], ...]:
+    labels = tuple(range(2 * rank))
+    return tuple(
+        tuple(label ^ 1 if mask & (1 << (label // 2)) else label for label in labels)
+        for mask in range(1 << rank)
+    )
+
+
+def _diagonal_color_entries(
+    count: int,
+    *,
+    exceptional_weight: float | None = None,
+) -> tuple[ColorContractionTemplateEntry, ...]:
+    return tuple(
+        ColorContractionTemplateEntry(
+            left_group_index=index,
+            right_group_index=index,
+            weight_re=(
+                exceptional_weight
+                if index == 0 and exceptional_weight is not None
+                else 1.0
+            ),
+        )
+        for index in range(count)
+    )
+
+
+def test_elementary_abelian_walsh_plan_emits_measured_rank_three() -> None:
+    rank = 3
+    words = _elementary_abelian_orbit_words(rank)
+
+    factorized = _build_walsh_color_contraction_block(
+        words,
+        _diagonal_color_entries(len(words)),
+    )
+
+    assert factorized is not None
+    assert factorized.kind == "elementary-abelian-walsh"
+    assert factorized.rank == rank
+    assert factorized.cosets == (tuple(range(1 << rank)),)
+    assert factorized.to_json_dict() == {
+        "kind": "elementary-abelian-walsh",
+        "rank": rank,
+        "cosets": [list(range(1 << rank))],
+    }
+    contraction_payload = {
+        "supported": True,
+        "reason": None,
+        "group_count": 2 * len(words),
+        "includes_color_factor": True,
+        "entries": [],
+        "repeated_block": {
+            "component_count": 2,
+            "component_group_ids": list(range(2 * len(words))),
+            "entries": [],
+            "factorized_block": factorized.to_json_dict(),
+        },
+    }
+    assert (
+        _color_contraction(contraction_payload)["repeated_block"]["factorized_block"]
+        == factorized.to_json_dict()
+    )
+    assert artifact_writer._runtime_schema_walsh_color_contraction_capabilities(
+        {"amplitude_stage": {"color_contraction": contraction_payload}}
+    ) == frozenset({artifact_writer.COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY})
+
+
+def test_elementary_abelian_walsh_plan_caps_wider_orbit_at_rank_three() -> None:
+    words = _elementary_abelian_orbit_words(4)
+
+    factorized = _build_walsh_color_contraction_block(
+        words,
+        _diagonal_color_entries(len(words)),
+    )
+
+    assert factorized is not None
+    assert factorized.kind == "elementary-abelian-walsh"
+    assert factorized.rank == 3
+    assert factorized.cosets == (
+        tuple(range(8)),
+        tuple(range(8, 16)),
+    )
+
+
+def test_rank_three_walsh_recognizes_multi_coset_xor_matrix_exactly() -> None:
+    rank = 3
+    subgroup_order = 1 << rank
+    seeds = (
+        tuple(range(2 * rank)),
+        (0, 2, 1, 3, 4, 5),
+    )
+    words = tuple(
+        tuple(label ^ 1 if mask & (1 << (label // 2)) else label for label in seed)
+        for seed in seeds
+        for mask in range(subgroup_order)
+    )
+
+    def matrix_weight(left: int, right: int) -> float:
+        left_coset, left_subgroup = divmod(left, subgroup_order)
+        right_coset, right_subgroup = divmod(right, subgroup_order)
+        coset_pair = tuple(sorted((left_coset, right_coset)))
+        pair_offset = {
+            (0, 0): 8,
+            (0, 1): 24,
+            (1, 1): 40,
+        }[coset_pair]
+        return (pair_offset + (left_subgroup ^ right_subgroup) + 1) / 8.0
+
+    entries = tuple(
+        ColorContractionTemplateEntry(
+            left_group_index=left,
+            right_group_index=right,
+            weight_re=matrix_weight(left, right),
+            symmetry_factor=1.0 if left == right else 2.0,
+        )
+        for left in range(len(words))
+        for right in range(left, len(words))
+    )
+
+    factorized = _build_walsh_color_contraction_block(words, entries)
+
+    assert factorized is not None
+    assert factorized.kind == "elementary-abelian-walsh"
+    assert factorized.rank == rank
+    assert factorized.cosets == (
+        tuple(range(subgroup_order)),
+        tuple(range(subgroup_order, 2 * subgroup_order)),
+    )
+    expected_wire = {
+        "kind": "elementary-abelian-walsh",
+        "rank": rank,
+        "cosets": [
+            list(range(subgroup_order)),
+            list(range(subgroup_order, 2 * subgroup_order)),
+        ],
+    }
+    assert factorized.to_json_dict() == expected_wire
+
+    component_count = 3
+    contraction_payload = {
+        "supported": True,
+        "reason": None,
+        "group_count": component_count * len(words),
+        "includes_color_factor": True,
+        "entries": [],
+        "repeated_block": {
+            "component_count": component_count,
+            "component_group_ids": list(range(component_count * len(words))),
+            "entries": [entry.to_json_dict() for entry in entries],
+            "factorized_block": factorized.to_json_dict(),
+        },
+    }
+    assert (
+        _color_contraction(contraction_payload)["repeated_block"]["factorized_block"]
+        == expected_wire
+    )
+
+    amplitudes = tuple(
+        tuple(
+            complex(
+                (local_group + 1) * (component + 2) / 13.0,
+                (local_group - 2 * component) / 17.0,
+            )
+            for component in range(component_count)
+        )
+        for local_group in range(len(words))
+    )
+    direct = sum(
+        matrix_weight(left, right)
+        * sum(
+            (
+                amplitudes[left][component] * amplitudes[right][component].conjugate()
+            ).real
+            for component in range(component_count)
+        )
+        for left in range(len(words))
+        for right in range(len(words))
+    )
+
+    def walsh(values: list[complex] | list[float]) -> None:
+        stride = 1
+        while stride < len(values):
+            for start in range(0, len(values), 2 * stride):
+                for offset in range(stride):
+                    left = values[start + offset]
+                    right = values[start + stride + offset]
+                    values[start + offset] = left + right
+                    values[start + stride + offset] = left - right
+            stride *= 2
+
+    transformed = [
+        [
+            [
+                amplitudes[coset * subgroup_order + subgroup][component]
+                for subgroup in range(subgroup_order)
+            ]
+            for component in range(component_count)
+        ]
+        for coset in range(len(seeds))
+    ]
+    for coset_components in transformed:
+        for component_values in coset_components:
+            walsh(component_values)
+
+    factorized_total = 0.0
+    for left_coset in range(len(seeds)):
+        for right_coset in range(left_coset, len(seeds)):
+            weights = [
+                matrix_weight(
+                    left_coset * subgroup_order,
+                    right_coset * subgroup_order + subgroup,
+                )
+                for subgroup in range(subgroup_order)
+            ]
+            walsh(weights)
+            symmetry_factor = 1.0 if left_coset == right_coset else 2.0
+            for character, weight in enumerate(weights):
+                product = sum(
+                    (
+                        transformed[left_coset][component][character]
+                        * transformed[right_coset][component][character].conjugate()
+                    ).real
+                    for component in range(component_count)
+                )
+                factorized_total += symmetry_factor * weight * product / subgroup_order
+
+    assert isclose(
+        factorized_total,
+        direct,
+        rel_tol=1.0e-12,
+        abs_tol=1.0e-15,
+    )
+
+
+@pytest.mark.parametrize(
+    ("kind", "rank", "cosets", "message"),
+    [
+        (
+            "klein-four-walsh",
+            2,
+            ((0, 1, 2, 3),),
+            "cannot declare rank",
+        ),
+        (
+            "elementary-abelian-walsh",
+            None,
+            (tuple(range(8)),),
+            "requires rank >= 3",
+        ),
+        (
+            "elementary-abelian-walsh",
+            2,
+            ((0, 1, 2, 3),),
+            "requires rank >= 3",
+        ),
+        (
+            "elementary-abelian-walsh",
+            3,
+            ((0, 1, 2, 3),),
+            "rank is inconsistent",
+        ),
+    ],
+)
+def test_factorized_walsh_contract_rejects_malformed_rank_metadata(
+    kind: str,
+    rank: int | None,
+    cosets: tuple[tuple[int, ...], ...],
+    message: str,
+) -> None:
+    with pytest.raises(ValueError, match=message):
+        FactorizedColorContractionBlock(kind=kind, rank=rank, cosets=cosets)
+
+
+def test_factorized_walsh_contract_rejects_partial_local_partition() -> None:
+    factorized = FactorizedColorContractionBlock(
+        kind="elementary-abelian-walsh",
+        rank=3,
+        cosets=(tuple(range(8)),),
+    )
+
+    with pytest.raises(ValueError, match="do not partition local groups"):
+        RepeatedColorContractionBlock(
+            component_count=2,
+            component_group_ids=tuple(range(18)),
+            entries=(),
+            factorized_block=factorized,
+        )
+
+
+def test_complete_six_label_orbit_emits_rank_three_walsh_plan() -> None:
+    words = tuple(permutations(range(6)))
+
+    factorized = _build_walsh_color_contraction_block(
+        words,
+        _diagonal_color_entries(len(words)),
+    )
+
+    assert factorized is not None
+    assert factorized.kind == "elementary-abelian-walsh"
+    assert factorized.rank == 3
+    assert len(factorized.cosets) == len(words) // 8
+    assert sorted(index for coset in factorized.cosets for index in coset) == list(
+        range(len(words))
+    )
+
+
+def test_partial_or_asymmetric_rank_three_orbit_falls_back_safely() -> None:
+    words = _elementary_abelian_orbit_words(3)
+
+    partial = _build_walsh_color_contraction_block(
+        words[:-1],
+        _diagonal_color_entries(len(words) - 1),
+    )
+    asymmetric = _build_walsh_color_contraction_block(
+        words,
+        _diagonal_color_entries(len(words), exceptional_weight=2.0),
+    )
+
+    assert partial is None
+    assert asymmetric is None
+
+
+def test_nlc_permutation_orbit_emits_klein_four_walsh_plan() -> None:
+    nlc_plan = build_color_plan(
+        build_process_ir("g g > t t~ g g", color_accuracy="nlc"),
+        color_accuracy="nlc",
+    )
+    nlc_groups = tuple(
+        ColorGroupDescriptor(
+            group_id=component_index * len(nlc_plan.sectors) + sector_index,
+            helicity_key=(f"helicity:{component_index}",),
+            sector_id=sector.id,
+            word=tuple(sector.word_labels or sector.color_words[0]),
+            helicity_weight=1.0,
+        )
+        for component_index in range(2)
+        for sector_index, sector in enumerate(nlc_plan.sectors)
+    )
+    nlc_contraction = build_color_contraction_plan(nlc_plan, nlc_groups)
+    assert nlc_contraction is not None
+    assert nlc_contraction.repeated_block is not None
+    factorized = nlc_contraction.repeated_block.factorized_block
+    assert factorized is not None
+    assert factorized.kind == "klein-four-walsh"
+    assert len(factorized.cosets) == len(nlc_plan.sectors) // 4
+    assert sorted(index for coset in factorized.cosets for index in coset) == list(
+        range(len(nlc_plan.sectors))
+    )
+    assert artifact_writer._runtime_schema_uses_walsh_color_contraction(
+        {"amplitude_stage": {"color_contraction": nlc_contraction.to_json_dict()}}
+    )
+
+
+def test_malformed_nlc_permutation_orbit_falls_back_safely() -> None:
+    nlc_plan = build_color_plan(
+        build_process_ir("g g > t t~ g g", color_accuracy="nlc"),
+        color_accuracy="nlc",
+    )
+    duplicate_word = tuple(
+        nlc_plan.sectors[0].word_labels or nlc_plan.sectors[0].color_words[0]
+    )
+    malformed_groups = tuple(
+        ColorGroupDescriptor(
+            group_id=component_index * len(nlc_plan.sectors) + sector_index,
+            helicity_key=(f"helicity:{component_index}",),
+            sector_id=sector.id,
+            word=(
+                duplicate_word
+                if sector_index == 1
+                else tuple(sector.word_labels or sector.color_words[0])
+            ),
+            helicity_weight=1.0,
+        )
+        for component_index in range(2)
+        for sector_index, sector in enumerate(nlc_plan.sectors)
+    )
+    malformed_contraction = build_color_contraction_plan(nlc_plan, malformed_groups)
+    assert malformed_contraction is not None
+    assert malformed_contraction.repeated_block is not None
+    assert malformed_contraction.repeated_block.factorized_block is None
+    assert not artifact_writer._runtime_schema_uses_walsh_color_contraction(
+        {"amplitude_stage": {"color_contraction": malformed_contraction.to_json_dict()}}
+    )
+
+
+def test_small_nlc_permutation_orbit_falls_back_safely() -> None:
+    plan = build_color_plan(
+        build_process_ir("g g > t t~ g", color_accuracy="nlc"),
+        color_accuracy="nlc",
+    )
+    groups = tuple(
+        ColorGroupDescriptor(
+            group_id=component_index * len(plan.sectors) + sector_index,
+            helicity_key=(f"helicity:{component_index}",),
+            sector_id=sector.id,
+            word=tuple(sector.word_labels or sector.color_words[0]),
+            helicity_weight=1.0,
+        )
+        for component_index in range(2)
+        for sector_index, sector in enumerate(plan.sectors)
+    )
+
+    contraction = build_color_contraction_plan(plan, groups)
+
+    assert contraction is not None
+    assert contraction.repeated_block is not None
+    assert contraction.repeated_block.factorized_block is None
+
+
+@pytest.mark.parametrize(("accuracy", "entry_count"), [("nlc", 384), ("full", 984)])
+def test_two_open_line_orbit_discovers_exact_klein_four_action(
+    accuracy: str,
+    entry_count: int,
+) -> None:
+    plan = build_color_plan(
+        build_process_ir("d d~ > t t~ g g g", color_accuracy=accuracy),
+        color_accuracy=accuracy,
+    )
+    sectors = tuple(
+        sector
+        for sector in plan.sectors
+        if (1 <= sector.id < 48 and sector.id % 2 == 1)
+        or (48 <= sector.id < 96 and sector.id % 2 == 0)
+    )
+    groups = tuple(
+        ColorGroupDescriptor(
+            group_id=component_index * len(sectors) + sector_index,
+            helicity_key=(f"helicity:{component_index}",),
+            sector_id=sector.id,
+            word=tuple(sector.word_labels or sector.color_words[0]),
+            helicity_weight=1.0,
+        )
+        for component_index in range(2)
+        for sector_index, sector in enumerate(sectors)
+    )
+
+    contraction = build_color_contraction_plan(plan, groups)
+
+    assert len(sectors) == 48
+    assert contraction is not None
+    block = contraction.repeated_block
+    assert block is not None
+    assert len(block.entries) == entry_count
+    factorized = block.factorized_block
+    assert factorized is not None
+    assert len(factorized.cosets) == len(sectors) // 4
+    assert sorted(index for coset in factorized.cosets for index in coset) == list(
+        range(len(sectors))
+    )
+
+
+def test_partial_two_open_line_orbit_falls_back_safely() -> None:
+    plan = build_color_plan(
+        build_process_ir("d d~ > t t~ g g g", color_accuracy="nlc"),
+        color_accuracy="nlc",
+    )
+    sectors = tuple(
+        sector
+        for sector in plan.sectors
+        if (1 <= sector.id < 48 and sector.id % 2 == 1)
+        or (48 <= sector.id < 96 and sector.id % 2 == 0)
+    )[:-1]
+    groups = tuple(
+        ColorGroupDescriptor(
+            group_id=component_index * len(sectors) + sector_index,
+            helicity_key=(f"helicity:{component_index}",),
+            sector_id=sector.id,
+            word=tuple(sector.word_labels or sector.color_words[0]),
+            helicity_weight=1.0,
+        )
+        for component_index in range(2)
+        for sector_index, sector in enumerate(sectors)
+    )
+
+    contraction = build_color_contraction_plan(plan, groups)
+
+    assert contraction is not None
+    assert contraction.repeated_block is not None
+    assert contraction.repeated_block.factorized_block is None
+
+
+def test_color_contraction_compaction_falls_back_for_nonidentical_components() -> None:
+    plan = build_color_plan(
+        build_process_ir("g g > g g", color_accuracy="full"),
+        color_accuracy="full",
+    )
+    sector = plan.sectors[0]
+    common = {
+        "sector_id": sector.id,
+        "word": tuple(sector.word_labels or sector.color_words[0]),
+    }
+    groups = (
+        ColorGroupDescriptor(
+            group_id=0,
+            helicity_key=("helicity:a",),
+            helicity_weight=1.0,
+            **common,
+        ),
+        ColorGroupDescriptor(
+            group_id=1,
+            helicity_key=("helicity:b",),
+            helicity_weight=nextafter(1.0, 2.0),
+            **common,
+        ),
+    )
+
+    contraction = build_color_contraction_plan(plan, groups)
+
+    assert contraction is not None
+    assert contraction.repeated_block is None
+    assert contraction.logical_entry_count == len(contraction.entries) == 2
+
+
+def test_color_contraction_public_names_have_no_legacy_aliases() -> None:
+    assert callable(color.color_contraction_factor)
+    assert callable(color.color_contraction_factors)
+    assert callable(color.exact_color_contraction_factor)
+    assert callable(color.exact_color_contraction_factors)
+    assert not hasattr(color, "amplicol_color_factor")
+    assert not hasattr(color, "amplicol_color_factors")
diff --git a/pyamplicol/tests/unit/test_color_correlator_matrices.py b/pyamplicol/tests/unit/test_color_correlator_matrices.py
new file mode 100644
index 0000000000..67d5011190
--- /dev/null
+++ b/pyamplicol/tests/unit/test_color_correlator_matrices.py
@@ -0,0 +1,480 @@
+# SPDX-License-Identifier: 0BSD
+"""Generated-basis compatibility and directed exact correlator matrix tests."""
+
+import json
+from dataclasses import replace
+from fractions import Fraction
+
+import pytest
+
+from pyamplicol.color import correlator_matrices
+from pyamplicol.color.connections import (
+    ColorConnection,
+    ColorLeg,
+    EmitGluon,
+    ExactColorCoefficient,
+    SplitGluon,
+    apply_color_connection,
+    contract_connected_tensor_nc_terms,
+    evaluate_color_nc_terms,
+)
+from pyamplicol.color.contraction_factors import exact_color_contraction_factor
+from pyamplicol.color.correlator_matrices import (
+    ColorCorrelator,
+    ColorCorrelatorMatrixEntry,
+    build_color_correlator_matrices,
+    build_color_correlator_matrix,
+    process_color_legs,
+    sector_color_tensor,
+)
+from pyamplicol.color.plan import build_color_plan
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _plan(expression, *, accuracy="full"):
+    return build_color_plan(
+        build_process_ir(expression, color_accuracy=accuracy), color_accuracy=accuracy
+    )
+
+
+def _entries(matrix):
+    return {
+        (entry.left_sector_id, entry.right_sector_id): entry.weight
+        for entry in matrix.entries
+    }
+
+
+@pytest.mark.parametrize("accuracy", ("lc", "nlc", "full"))
+@pytest.mark.parametrize(
+    "expression",
+    (
+        "e- e+ > a a",
+        "g g > g g",
+        "d d~ > z g g",
+        "d d~ > u u~",
+        "d d~ > u u~ g g",
+        "d d~ > d d~ g",
+        "d d~ > u u~ s s~ g",
+    ),
+)
+def test_identity_matches_every_existing_metric_entry(expression, accuracy):
+    plan = _plan(expression)
+    matrix = build_color_correlator_matrix(
+        plan, ColorCorrelator("born"), color_accuracy=accuracy
+    )
+    entries = _entries(matrix)
+    assert matrix.order == 0
+    assert matrix.sector_ids == tuple(sector.id for sector in plan.sectors)
+    assert matrix.to_json_dict()["color_accuracy"] == accuracy
+    for left in plan.sectors:
+        for right in plan.sectors:
+            expected = exact_color_contraction_factor(
+                plan, left, right, accuracy=accuracy
+            )
+            assert entries.get(
+                (left.id, right.id), ExactColorCoefficient()
+            ) == ExactColorCoefficient(expected)
+
+
+def test_sector_adapter_adds_pairing_phase_and_ignores_traversal_replicas():
+    plan = _plan("d d~ > u u~")
+    terms = tuple(sector_color_tensor(sector, plan.process) for sector in plan.sectors)
+    assert {term.coefficient.real for term in terms} == {Fraction(-1), Fraction(1)}
+    assert len(set(terms)) == 2
+    matrix = build_color_correlator_matrix(plan, ColorCorrelator("born"))
+    assert any(entry.weight.real == -3 for entry in matrix.entries)
+
+
+def test_literal_identity_matches_crossed_multiquark_metric():
+    plan = _plan("d d~ > u u~ g")
+    identity = ColorConnection(process_color_legs(plan.process))
+    images = []
+    for sector in plan.sectors:
+        term = sector_color_tensor(sector, plan.process)
+        images.append(
+            apply_color_connection(term.tensor, identity, coefficient=term.coefficient)
+        )
+    # The Born matrix bypasses the literal adapter and uses the inherited
+    # metric directly. Contract its tensor images independently to protect
+    # crossed endpoints, pairing phases and gluon placement in the adapter.
+    for left, bra in zip(plan.sectors, images, strict=True):
+        for right, ket in zip(plan.sectors, images, strict=True):
+            actual = evaluate_color_nc_terms(
+                contract_connected_tensor_nc_terms(bra, ket)
+            )
+            expected = exact_color_contraction_factor(
+                plan, left, right, accuracy="full"
+            )
+            assert actual == ExactColorCoefficient(expected)
+
+
+def test_process_roles_are_already_crossed_and_include_singlets():
+    process = _plan("d d~ > z").process
+    assert process_color_legs(process) == (
+        ColorLeg(1, -3),
+        ColorLeg(2, 3),
+        ColorLeg(3, 1),
+    )
+    invalid = replace(
+        process,
+        legs=(replace(process.legs[0], color_role="inclusive"), *process.legs[1:]),
+    )
+    with pytest.raises(ValueError, match="concrete"):
+        process_color_legs(invalid)
+
+
+def test_dipole_convenience_and_n3lo_emitted_pair_normalization():
+    plan = _plan("d d~ > z")
+    pair = ColorCorrelator(
+        "pair",
+        (
+            EmitGluon(2, -1),
+            SplitGluon(-1, -2, -3),
+            EmitGluon(-2, -4),
+        ),
+        (
+            EmitGluon(2, -1),
+            SplitGluon(-1, -2, -3),
+            EmitGluon(-2, -4),
+        ),
+    )
+    born, dipole, triple = build_color_correlator_matrices(
+        plan,
+        (
+            ColorCorrelator("born"),
+            ColorCorrelator.dipole("B12", 1, 2),
+            pair,
+        ),
+    )
+    assert born.entries[0].weight == ExactColorCoefficient(3)
+    assert dipole.entries[0].weight == ExactColorCoefficient(-4)
+    assert triple.order == 3
+    assert triple.entries[0].weight == ExactColorCoefficient(Fraction(8, 3))
+    assert ColorLeg(-2, 3) in triple.output_legs
+    assert ColorLeg(-3, -3) in triple.output_legs
+    assert all(leg.label != -1 for leg in triple.output_legs)
+    assert ColorCorrelator.dipole("B12", 1, 2).to_json_dict() == {
+        "id": "B12",
+        "bra": [{"kind": "emit-gluon", "emitter": 1, "emitted": -1}],
+        "ket": [{"kind": "emit-gluon", "emitter": 2, "emitted": -1}],
+    }
+    assert pair.to_json_dict()["bra"][1] == {
+        "kind": "split-gluon",
+        "parent": -1,
+        "quark": -2,
+        "antiquark": -3,
+    }
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_ordered_connections_store_both_triangles_without_hermiticity_assumptions(
+    accuracy,
+):
+    plan = _plan("d d~ > g g")
+    request = ColorCorrelator(
+        "ordered",
+        (EmitGluon(2, -1), EmitGluon(1, -2)),
+        (EmitGluon(3, -2), EmitGluon(1, -1)),
+    )
+    matrix, adjoint = build_color_correlator_matrices(
+        plan,
+        (
+            request,
+            ColorCorrelator("adjoint", request.ket, request.bra),
+        ),
+        color_accuracy=accuracy,
+    )
+    entries = _entries(matrix)
+    expected = {
+        (0, 0): ExactColorCoefficient(Fraction(-16, 3)),
+        (0, 1): ExactColorCoefficient(Fraction(-16, 3)),
+        (1, 0): ExactColorCoefficient(Fraction(20, 3)),
+    }
+    if accuracy == "full":
+        expected[1, 1] = ExactColorCoefficient(Fraction(2, 3))
+    assert entries == expected
+    assert _entries(adjoint) == {
+        (j, i): value.conjugate() for (i, j), value in entries.items()
+    }
+    amplitudes = (ExactColorCoefficient(1), ExactColorCoefficient(0, 1))
+    value = ExactColorCoefficient()
+    for entry in matrix.entries:
+        value = (
+            value
+            + amplitudes[entry.left_sector_id].conjugate()
+            * entry.weight
+            * amplitudes[entry.right_sector_id]
+        )
+    assert value == ExactColorCoefficient(
+        Fraction(-14 if accuracy == "full" else -16, 3), -12
+    )
+    assert not build_color_correlator_matrix(plan, request, color_accuracy="lc").entries
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_insertions_can_revive_zero_ordinary_metric_entries(accuracy):
+    plan = _plan("d d~ > u u~ g")
+    born, inserted = build_color_correlator_matrices(
+        plan,
+        (
+            ColorCorrelator("born"),
+            ColorCorrelator.dipole("B13", 1, 3),
+        ),
+        color_accuracy=accuracy,
+    )
+    assert (0, 2) not in _entries(born)
+    assert _entries(inserted)[0, 2] == ExactColorCoefficient(-4)
+
+
+def test_selected_owner_ids_preserve_requested_coordinates():
+    plan = _plan("g g > g g")
+    matrix = build_color_correlator_matrix(
+        plan, ColorCorrelator("born"), sector_ids=(5, 0)
+    )
+    assert matrix.sector_ids == (5, 0)
+    assert {
+        (entry.left_sector_id, entry.right_sector_id) for entry in matrix.entries
+    } <= {(5, 5), (5, 0), (0, 5), (0, 0)}
+
+
+def test_graph_images_are_reused_across_requested_matrices(monkeypatch):
+    plan = _plan("d d~ > g g")
+    original = correlator_matrices.apply_color_connection
+    calls = []
+
+    def counted(*args, **kwargs):
+        calls.append(args[1].emissions)
+        return original(*args, **kwargs)
+
+    monkeypatch.setattr(correlator_matrices, "apply_color_connection", counted)
+    build_color_correlator_matrices(
+        plan,
+        (
+            ColorCorrelator("born"),
+            ColorCorrelator.dipole("B13", 1, 3),
+            ColorCorrelator.dipole("B31", 3, 1),
+        ),
+    )
+    # The identity reuses the inherited metric without constructing images.
+    assert len(calls) == 2 * len(plan.sectors)
+
+
+@pytest.mark.parametrize(
+    ("operations", "lc", "full"),
+    (
+        ((EmitGluon(2, -1),), Fraction(9, 2), Fraction(4)),
+        ((EmitGluon(2, -1), EmitGluon(2, -2)), Fraction(27, 4), Fraction(16, 3)),
+        ((EmitGluon(2, -1), SplitGluon(-1, -2, -3)), Fraction(9, 4), Fraction(2)),
+        (
+            (EmitGluon(2, -1), EmitGluon(2, -2), EmitGluon(2, -3)),
+            Fraction(81, 8),
+            Fraction(64, 9),
+        ),
+        (
+            (EmitGluon(2, -1), SplitGluon(-1, -2, -3), EmitGluon(-2, -4)),
+            Fraction(27, 8),
+            Fraction(8, 3),
+        ),
+    ),
+)
+def test_connected_family_power_counting_includes_splitting(operations, lc, full):
+    plan = _plan("d d~ > z")
+    request = ColorCorrelator("self", operations, operations)
+    for accuracy, expected in (("lc", lc), ("nlc", full), ("full", full)):
+        matrix = build_color_correlator_matrix(plan, request, color_accuracy=accuracy)
+        assert _entries(matrix) == {(0, 0): ExactColorCoefficient(expected)}
+
+
+def test_pure_adjoint_nlc_truncates_but_split_output_keeps_admitted_exact_entry():
+    plan = _plan("g g > g")
+    emission = (EmitGluon(1, -1),)
+    pair = (*emission, SplitGluon(-1, -2, -3))
+    for operations, expected in ((emission, 54), (pair, 28)):
+        matrix = build_color_correlator_matrix(
+            plan, ColorCorrelator("self", operations, operations), color_accuracy="nlc"
+        )
+        assert _entries(matrix)[0, 0] == ExactColorCoefficient(expected)
+
+
+def test_nlc_selection_includes_odd_powers_and_does_not_promote_suppressed_entries():
+    polynomial = {
+        3: ExactColorCoefficient(-1),
+        1: ExactColorCoefficient(2),
+        -1: ExactColorCoefficient(-1),
+    }
+    select = correlator_matrices._select_color_nc_terms
+    assert (
+        select(
+            polynomial, color_accuracy="lc", leading_power=4, fundamental_output=True
+        )
+        == {}
+    )
+    assert (
+        select(
+            polynomial, color_accuracy="nlc", leading_power=4, fundamental_output=True
+        )
+        == polynomial
+    )
+    assert select(
+        polynomial, color_accuracy="nlc", leading_power=4, fundamental_output=False
+    ) == {3: ExactColorCoefficient(-1)}
+    assert (
+        select(
+            {1: ExactColorCoefficient(1)},
+            color_accuracy="nlc",
+            leading_power=4,
+            fundamental_output=True,
+        )
+        == {}
+    )
+
+
+@pytest.mark.parametrize("accuracy", ("lc", "nlc"))
+@pytest.mark.parametrize(
+    ("prefix", "emitted"),
+    (
+        ((EmitGluon(2, -1),), -2),
+        ((EmitGluon(2, -1), EmitGluon(-1, -2)), -3),
+        ((EmitGluon(2, -1), SplitGluon(-1, -2, -3)), -4),
+    ),
+)
+def test_connected_nnlo_n3lo_coherence_holds_through_retained_order(
+    accuracy, prefix, emitted
+):
+    plan = _plan("d d~ > z")
+    tensor = sector_color_tensor(plan.sectors[0], plan.process)
+    legs = process_color_legs(plan.process)
+    intermediate = ColorConnection(legs, prefix)
+    images = tuple(
+        apply_color_connection(
+            tensor.tensor,
+            ColorConnection(legs, (*prefix, EmitGluon(leg.label, emitted))),
+            coefficient=tensor.coefficient,
+        )
+        for leg in intermediate.output_legs
+        if leg.representation != 1
+    )
+    leading = 1 + len(prefix) + 1 - sum(isinstance(step, SplitGluon) for step in prefix)
+    threshold = leading - (2 if accuracy == "nlc" else 0)
+    for bra in images:
+        summed = {}
+        for ket in images:
+            selected = correlator_matrices._select_color_nc_terms(
+                contract_connected_tensor_nc_terms(bra, ket),
+                color_accuracy=accuracy,
+                leading_power=leading,
+                fundamental_output=True,
+            )
+            for power, coefficient in selected.items():
+                summed[power] = summed.get(power, ExactColorCoefficient()) + coefficient
+        assert not {
+            power: value
+            for power, value in summed.items()
+            if value and power >= threshold
+        }
+        if accuracy == "lc":
+            assert evaluate_color_nc_terms(summed) == ExactColorCoefficient()
+
+
+def test_invalid_output_accuracy_is_rejected():
+    with pytest.raises(ValueError, match="accuracy"):
+        build_color_correlator_matrix(
+            _plan("d d~ > z"), ColorCorrelator("born"), color_accuracy="unknown"
+        )
+
+
+def test_json_is_exact_primitive_data_and_preserves_imaginary_weights():
+    matrix = build_color_correlator_matrix(_plan("d d~ > z"), ColorCorrelator("born"))
+    complex_entry = ColorCorrelatorMatrixEntry(
+        0, 0, ExactColorCoefficient(Fraction(2**70, 3), Fraction(-2, 7))
+    )
+    matrix = replace(matrix, entries=(complex_entry,))
+    payload = matrix.to_json_dict()
+    assert json.loads(json.dumps(payload, allow_nan=False)) == payload
+    assert payload["storage"] == "sparse-directed"
+    assert payload["includes_color_factor"] is True
+    assert payload["entries"] == [
+        {
+            "left_sector_id": 0,
+            "right_sector_id": 0,
+            "weight": {"real": [str(2**70), "3"], "imag": ["-2", "7"]},
+        }
+    ]
+
+
+@pytest.mark.parametrize("id", ("", "  ", None, 3))
+def test_correlator_ids_must_be_nonempty_strings(id):
+    with pytest.raises(ValueError, match="ID"):
+        ColorCorrelator(id)
+
+
+def test_duplicate_request_ids_and_incompatible_outputs_are_rejected():
+    plan = _plan("d d~ > z")
+    with pytest.raises(ValueError, match="unique"):
+        build_color_correlator_matrices(
+            plan, (ColorCorrelator("x"), ColorCorrelator("x"))
+        )
+    with pytest.raises(ValueError, match="incompatible"):
+        build_color_correlator_matrix(
+            plan, ColorCorrelator("x", (EmitGluon(1, -1),), (EmitGluon(1, -2),))
+        )
+    with pytest.raises(ValueError, match="same number"):
+        ColorCorrelator("x", (EmitGluon(1, -1),))
+    with pytest.raises(ValueError, match="active coloured"):
+        build_color_correlator_matrix(plan, ColorCorrelator.dipole("singlet", 1, 3))
+
+
+@pytest.mark.parametrize("accuracy", ("lc", "nlc"))
+def test_non_full_plans_are_rejected(accuracy):
+    with pytest.raises(ValueError, match="full-colour"):
+        build_color_correlator_matrix(
+            _plan("g g > g g", accuracy=accuracy), ColorCorrelator("born")
+        )
+
+
+@pytest.mark.parametrize(
+    "correlator", (ColorCorrelator("born"), ColorCorrelator.dipole("T12", 1, 2))
+)
+@pytest.mark.parametrize("plural", (False, True))
+def test_adjoint_plans_are_rejected_before_literal_tensor_conversion(
+    correlator, plural, monkeypatch
+):
+    plan = build_color_plan(
+        build_process_ir("g g > g g", color_accuracy="full"),
+        color_accuracy="full",
+        basis="adjoint",
+    )
+
+    def unexpected_tensor_conversion(*_args):
+        pytest.fail("adjoint ordering records are not literal trace tensors")
+
+    monkeypatch.setattr(
+        correlator_matrices, "_sector_color_tensor", unexpected_tensor_conversion
+    )
+    with pytest.raises(ValueError, match="do not support the adjoint DDM basis"):
+        if plural:
+            build_color_correlator_matrices(plan, (correlator,))
+        else:
+            build_color_correlator_matrix(plan, correlator)
+
+
+@pytest.mark.parametrize(
+    "change", ({"truncated": True}, {"trace_reflections_folded": True}, {"sectors": ()})
+)
+def test_incomplete_or_folded_plans_are_rejected(change):
+    with pytest.raises(ValueError, match="complete unfolded"):
+        build_color_correlator_matrix(
+            replace(_plan("g g > g g"), **change), ColorCorrelator("born")
+        )
+
+
+@pytest.mark.parametrize("ids", ((), (0, 0), (999,), (True,)))
+def test_invalid_selected_sector_ids_are_rejected(ids):
+    with pytest.raises(ValueError, match="sector IDs"):
+        build_color_correlator_matrix(
+            _plan("g g > g g"), ColorCorrelator("born"), sector_ids=ids
+        )
+
+
+def test_empty_correlator_request_does_not_touch_the_ordinary_lc_path():
+    assert build_color_correlator_matrices(_plan("g g > g g", accuracy="lc"), ()) == ()
diff --git a/pyamplicol/tests/unit/test_color_topology_exact.py b/pyamplicol/tests/unit/test_color_topology_exact.py
new file mode 100644
index 0000000000..cbd81a25b2
--- /dev/null
+++ b/pyamplicol/tests/unit/test_color_topology_exact.py
@@ -0,0 +1,210 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+from copy import deepcopy
+from decimal import Decimal
+
+import pytest
+
+from pyamplicol.api.errors import ArtifactError
+from pyamplicol.runtime._color_topology_exact import (
+    apply_exact_color_replay_input_mapping,
+    parse_exact_color_topology_replay,
+    reduce_exact_color_topology_replay,
+)
+
+
+def _fixture(*, repeated: bool = False) -> tuple[dict[str, object], dict[str, object]]:
+    mappings = [
+        {
+            "label_permutation": [],
+            "group_routes": [
+                {"source_group_id": 10, "target_group_id": 0, "factor": [1, 0]}
+            ],
+        },
+        {
+            "label_permutation": [
+                {"representative_label": 1, "sector_label": 2},
+                {"representative_label": 2, "sector_label": 1},
+            ],
+            "group_routes": [
+                {"source_group_id": 11, "target_group_id": 1, "factor": [1, 0]}
+            ],
+        },
+    ]
+    contraction: dict[str, object] = {
+        "supported": True,
+        "reason": None,
+        "group_count": 2,
+        "includes_color_factor": True,
+        "entries": [],
+        "repeated_block": None,
+    }
+    if repeated:
+        contraction["repeated_block"] = {
+            "component_count": 2,
+            "component_group_ids": [0, 1],
+            "entries": [
+                {
+                    "left_group_index": 0,
+                    "right_group_index": 0,
+                    "weight": [1, 0],
+                    "symmetry_factor": 1,
+                }
+            ],
+        }
+    else:
+        contraction["entries"] = [
+            {
+                "left_group_id": 0,
+                "right_group_id": 0,
+                "weight": [1, 0],
+                "symmetry_factor": 1,
+            },
+            {
+                "left_group_id": 1,
+                "right_group_id": 1,
+                "weight": [1, 0],
+                "symmetry_factor": 1,
+            },
+            {
+                "left_group_id": 0,
+                "right_group_id": 1,
+                "weight": [1, 0],
+                "symmetry_factor": 2,
+            },
+        ]
+    proof_mappings = [
+        [],
+        [
+            {"representative_label": 1, "sector_label": 2},
+            {"representative_label": 2, "sector_label": 1},
+        ],
+    ]
+    execution: dict[str, object] = {
+        "runtime_schema": {
+            "color_topology_replay": {
+                "enabled": True,
+                "mode": "external-label-permutation",
+                "contract_version": 3,
+                "color_accuracy": "full",
+                "physical_sector_count": 2,
+                "replayed_sector_count": 2,
+                "materialized_sector_ids": [0, 1],
+                "residual_sector_ids": [],
+                "groups": [
+                    {
+                        "sector_permutations": [
+                            {"label_permutation": mapping} for mapping in proof_mappings
+                        ]
+                    }
+                ],
+            },
+            "amplitude_stage": {
+                "stage_kind": "amplitude-roots",
+                "output_count": 2,
+                "roots": [
+                    {"root_id": 0, "output_index": 0, "coherent_group_id": 10},
+                    {"root_id": 1, "output_index": 1, "coherent_group_id": 11},
+                ],
+                "color_topology_replay": {
+                    "contract_version": 1,
+                    "physical_group_count": 2,
+                    "physical_groups": [
+                        {
+                            "group_id": 0,
+                            "helicities": [1, -1],
+                            "color_sector_id": 0,
+                            "color_word": [1, 2],
+                            "helicity_weight": 2,
+                        },
+                        {
+                            "group_id": 1,
+                            "helicities": [1, -1],
+                            "color_sector_id": 1,
+                            "color_word": [2, 1],
+                            "helicity_weight": 2,
+                        },
+                    ],
+                    "mappings": mappings,
+                },
+                "color_contraction": contraction,
+            },
+        }
+    }
+    physics: dict[str, object] = {
+        "color_accuracy": "full",
+        "external_particles": [{"pdg": 1}, {"pdg": -1}],
+        "helicities": [
+            {"id": "h-plus", "values": [1, -1], "coefficient": 1},
+            {"id": "h-minus", "values": [-1, 1], "coefficient": 1},
+        ],
+        "color_components": [{"id": "contracted:full"}],
+    }
+    return execution, physics
+
+
+@pytest.mark.parametrize(
+    ("repeated", "expected"),
+    [(False, Decimal("4.5")), (True, Decimal("2.5"))],
+)
+def test_exact_color_replay_gathers_routes_and_contracts_physical_groups(
+    repeated: bool, expected: Decimal
+) -> None:
+    execution, physics = _fixture(repeated=repeated)
+    plan = parse_exact_color_topology_replay(execution, physics, None)
+    assert plan is not None
+
+    values, helicities, colors = reduce_exact_color_topology_replay(
+        (
+            ((Decimal(1), Decimal(0)), (Decimal(99), Decimal(0))),
+            ((Decimal(99), Decimal(0)), (Decimal(2), Decimal(0))),
+        ),
+        plan,
+        1,
+        Decimal(1),
+        None,
+        None,
+    )
+
+    assert values == (((expected,), (expected,)),)
+    assert helicities == ("h-plus", "h-minus")
+    assert colors == ("contracted:full",)
+
+
+def test_exact_color_replay_maps_representative_helicity_to_public_alias() -> None:
+    execution, physics = _fixture()
+    replay = execution["runtime_schema"]["amplitude_stage"]["color_topology_replay"]
+    for group in replay["physical_groups"]:
+        group["helicity_weight"] = 1
+
+    plan = parse_exact_color_topology_replay(execution, physics, (1, 0))
+
+    assert plan is not None
+    assert plan.physical_group_members == (((1, Decimal(1)),),) * 2
+
+
+def test_exact_color_replay_rejects_proof_and_route_mapping_disagreement() -> None:
+    execution, physics = _fixture()
+    malformed = deepcopy(execution)
+    proof = malformed["runtime_schema"]["color_topology_replay"]
+    proof["groups"][0]["sector_permutations"] = [{"label_permutation": []}]
+
+    with pytest.raises(
+        ArtifactError,
+        match="proof mappings do not match the amplitude gather",
+    ):
+        parse_exact_color_topology_replay(malformed, physics, None)
+
+
+def test_exact_color_replay_applies_mapping_in_representative_order() -> None:
+    point = (
+        (Decimal(10), Decimal(1), Decimal(2), Decimal(3)),
+        (Decimal(20), Decimal(4), Decimal(5), Decimal(6)),
+    )
+
+    assert apply_exact_color_replay_input_mapping(point, ((0, 1), (1, 0))) == (
+        point[1],
+        point[0],
+    )
diff --git a/pyamplicol/tests/unit/test_color_topology_replay_partitions.py b/pyamplicol/tests/unit/test_color_topology_replay_partitions.py
new file mode 100644
index 0000000000..0e97e23d00
--- /dev/null
+++ b/pyamplicol/tests/unit/test_color_topology_replay_partitions.py
@@ -0,0 +1,206 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.color import ColorGroupDescriptor
+from pyamplicol.color.plan import (
+    build_color_plan,
+    build_color_topology_replay_certificate,
+    color_topology_replay_partitions,
+)
+from pyamplicol.generation.runtime_amplitudes import (
+    _color_topology_replay_amplitudes,
+)
+from pyamplicol.models.builtin.model import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+@pytest.mark.parametrize(
+    ("n_final", "sector_count", "partition_count", "partition_size", "representatives"),
+    [
+        (4, 120, 5, 24, (0, 24, 30, 32, 33)),
+        (5, 720, 6, 120, (0, 120, 144, 150, 152, 153)),
+        (6, 5_040, 7, 720, (0, 720, 840, 864, 870, 872, 873)),
+    ],
+)
+def test_full_color_pure_gluon_partitions_match_crossing_templates(
+    n_final: int,
+    sector_count: int,
+    partition_count: int,
+    partition_size: int,
+    representatives: tuple[int, ...],
+) -> None:
+    process = build_process_ir(
+        f"g g > {' '.join(['g'] * n_final)}",
+        color_accuracy="full",
+    )
+    color_plan = build_color_plan(process, color_accuracy="full")
+    partitions = color_topology_replay_partitions(color_plan)
+
+    assert color_plan.sector_count == sector_count
+    assert len(partitions) == partition_count
+    assert (
+        tuple(partition.representative_sector_id for partition in partitions)
+        == representatives
+    )
+    assert {len(partition.active_sector_ids) for partition in partitions} == {
+        partition_size
+    }
+    assert {
+        sector_id
+        for partition in partitions
+        for sector_id in partition.active_sector_ids
+    } == set(range(sector_count))
+
+    initial_labels = {leg.label for leg in process.initial_legs}
+    for partition in partitions:
+        for permutation in partition.label_permutations:
+            mapping = dict(permutation)
+            assert {mapping[label] for label in initial_labels} == initial_labels
+
+
+def test_existing_lc_runtime_wrapper_remains_lc_only() -> None:
+    process = build_process_ir("g g > g g g g g", color_accuracy="full")
+    color_plan = build_color_plan(process, color_accuracy="full")
+
+    from pyamplicol.color.plan import lc_topology_replay_partitions
+
+    assert lc_topology_replay_partitions(color_plan) == ()
+
+
+def test_full_color_certificate_proves_six_n5_crossing_orbits() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("g g > g g g g g", color_accuracy="full")
+    color_plan = build_color_plan(process, color_accuracy="full")
+
+    certificate = build_color_topology_replay_certificate(color_plan, model)
+
+    assert certificate is not None
+    assert certificate.color_accuracy == "full"
+    assert certificate.physical_sector_ids == tuple(range(720))
+    assert certificate.materialized_sector_ids == (0, 120, 144, 150, 152, 153)
+    assert certificate.residual_sector_ids == ()
+    assert certificate.replayed_sector_count == 720
+    assert all(
+        partition.proof_algorithm
+        == "canonical-model-contract-color-label-equivariance-v2"
+        and partition.proof_digest is not None
+        and len(partition.proof_digest) == 64
+        and partition.signs == (1,) * 120
+        for partition in certificate.partitions
+    )
+
+
+def test_n5_full_color_amplitude_gather_is_a_720_group_bijection() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("g g > g g g g g", color_accuracy="full")
+    color_plan = build_color_plan(process, color_accuracy="full")
+    certificate = build_color_topology_replay_certificate(color_plan, model)
+    assert certificate is not None
+    helicity_key = tuple((leg.label, 21, 0, 1, 1) for leg in process.legs)
+    descriptors = tuple(
+        ColorGroupDescriptor(
+            group_id=group_id,
+            helicity_key=helicity_key,
+            sector_id=sector_id,
+            word=tuple(
+                color_plan.sector(sector_id).word_labels  # type: ignore[union-attr]
+            ),
+            helicity_weight=1.0,
+        )
+        for group_id, sector_id in enumerate(certificate.materialized_sector_ids)
+    )
+    dag = SimpleNamespace(
+        color_topology_replay=certificate,
+        color_plan=color_plan,
+        process=process,
+    )
+
+    replay = _color_topology_replay_amplitudes(dag, descriptors)
+
+    assert replay is not None
+    assert len(replay.physical_descriptors) == 720
+    assert len(replay.mappings) == 120
+    assert {len(mapping.group_routes) for mapping in replay.mappings} == {6}
+    assert sorted(
+        route.target_group_id
+        for mapping in replay.mappings
+        for route in mapping.group_routes
+    ) == list(range(720))
+
+
+@pytest.mark.parametrize("color_accuracy", ["nlc", "full"])
+def test_n3_amplitude_gather_order_matches_replay_proof(
+    color_accuracy: str,
+) -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir(
+        "g g > g g g",
+        color_accuracy=color_accuracy,
+    )
+    color_plan = build_color_plan(process, color_accuracy=color_accuracy)
+    certificate = build_color_topology_replay_certificate(color_plan, model)
+    assert certificate is not None
+    helicity_key = tuple((leg.label, 21, 0, 1, 1) for leg in process.legs)
+    descriptors = tuple(
+        ColorGroupDescriptor(
+            group_id=group_id,
+            helicity_key=helicity_key,
+            sector_id=sector_id,
+            word=tuple(
+                color_plan.sector(sector_id).word_labels  # type: ignore[union-attr]
+            ),
+            helicity_weight=1.0,
+        )
+        for group_id, sector_id in enumerate(certificate.materialized_sector_ids)
+    )
+    dag = SimpleNamespace(
+        color_topology_replay=certificate,
+        color_plan=color_plan,
+        process=process,
+    )
+
+    replay = _color_topology_replay_amplitudes(dag, descriptors)
+
+    assert replay is not None
+    proof_mappings = tuple(
+        sorted(
+            {
+                tuple(
+                    sorted(
+                        (int(left), int(right))
+                        for left, right in permutation
+                        if int(left) != int(right)
+                    )
+                )
+                for partition in certificate.partitions
+                for permutation in partition.label_permutations
+            }
+        )
+    )
+    assert tuple(
+        mapping.label_permutation for mapping in replay.mappings
+    ) == proof_mappings
+
+
+def test_color_accuracy_is_bound_into_generic_replay_proof() -> None:
+    model = BuiltinSMModel()
+    certificates = []
+    for color_accuracy in ("nlc", "full"):
+        process = build_process_ir(
+            "g g > g g g",
+            color_accuracy=color_accuracy,
+        )
+        certificate = build_color_topology_replay_certificate(
+            build_color_plan(process, color_accuracy=color_accuracy),
+            model,
+        )
+        assert certificate is not None
+        certificates.append(certificate)
+
+    assert [partition.proof_digest for partition in certificates[0].partitions] != [
+        partition.proof_digest for partition in certificates[1].partitions
+    ]
diff --git a/pyamplicol/tests/unit/test_compiled_all_jit_arena_gate.py b/pyamplicol/tests/unit/test_compiled_all_jit_arena_gate.py
new file mode 100644
index 0000000000..05b138652b
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiled_all_jit_arena_gate.py
@@ -0,0 +1,412 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import argparse
+import os
+from collections.abc import Callable
+from copy import deepcopy
+from pathlib import Path
+
+import pytest
+
+from tools.developer import compiled_all_jit_arena_gate as gate
+
+
+def test_checked_file_identity_rejects_a_symlink(tmp_path: Path) -> None:
+    if not hasattr(os, "O_NOFOLLOW"):
+        pytest.skip("O_NOFOLLOW is unavailable")
+    target = tmp_path / "target.bin"
+    target.write_bytes(b"authenticated")
+    link = tmp_path / "link.bin"
+    link.symlink_to(target)
+    with pytest.raises(gate.GateError, match="checked fd"):
+        gate._regular_file_identity(link)
+
+
+def _source_leaf(
+    optimization_level: int,
+    *,
+    include_plane: bool = True,
+) -> dict[str, object]:
+    leaf: dict[str, object] = {
+        "kind": "symjit-application-evaluator",
+        "backend": "jit",
+        "runtime_capability": gate.SYMJIT_RUNTIME_CAPABILITY,
+        "input_len": 1,
+        "output_len": 1,
+        "application_path": f"evaluators/stage-o{optimization_level}.symjit",
+        "application_abi": gate.SYMJIT_APPLICATION_ABI,
+        "optimization_level": optimization_level,
+    }
+    if include_plane:
+        leaf["plane_application"] = {
+            "application_path": (
+                f"evaluators/stage-o{optimization_level}.plane.symjit"
+            ),
+            "application_abi": gate.SYMJIT_PLANE_APPLICATION_ABI,
+            "storage_abi": gate.SYMJIT_APPLICATION_ABI,
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": optimization_level,
+            "direct_arena": True,
+            "source_digest": f"{optimization_level}" * 64,
+        }
+    return leaf
+
+
+def _stage(optimization_level: int) -> dict[str, object]:
+    path = f"evaluators/stage-o{optimization_level}.plane.symjit"
+    return {
+        "stage_kind": "amplitude-roots",
+        "output_length": 1,
+        "evaluator": _source_leaf(optimization_level),
+        "compiled_plane_arena": {
+            "kind": "compiled-plane-arena-stage",
+            "schema_version": 1,
+            "application_abi": gate.COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+            "source_application_abi": gate.SYMJIT_PLANE_APPLICATION_ABI,
+            "element_layout": "split-complex-component-major",
+            "input_output_aliasing": "forbidden",
+            "output_output_aliasing": "forbidden",
+            "output_operation": "overwrite",
+            "output_factor": "identity",
+            "input_bindings": [
+                {
+                    "kind": "value",
+                    "parameter_index": 0,
+                    "source_id": 0,
+                    "component": 0,
+                }
+            ],
+            "output_bindings": [
+                {"arena": "amplitude", "component": 0, "output_index": 0}
+            ],
+            "leaves": [
+                {
+                    "application_path": path,
+                    "source_application_abi": gate.SYMJIT_PLANE_APPLICATION_ABI,
+                    "optimization_level": optimization_level,
+                    "direct_codegen_optimization_level": optimization_level,
+                    "input_indices": [0],
+                    "input_len": 1,
+                    "output_len": 1,
+                    "output_start": 0,
+                    "output_stop": 1,
+                }
+            ],
+        },
+    }
+
+
+def _stage_set(optimization_level: int) -> dict[str, object]:
+    return {
+        "kind": "generic-dag-stage-evaluator-artifacts",
+        "runtime_available": True,
+        "required_runtime_capabilities": [
+            gate.COMPILED_PLANE_ARENA_CAPABILITY,
+            gate.SYMJIT_RUNTIME_CAPABILITY,
+        ],
+        "stage_count": 1,
+        "stages": [],
+        "amplitude_stage": _stage(optimization_level),
+    }
+
+
+def _execution_payload(optimization_level: int) -> dict[str, object]:
+    return {
+        "required_runtime_capabilities": [
+            gate.COMPILED_PLANE_ARENA_CAPABILITY,
+            gate.SYMJIT_RUNTIME_CAPABILITY,
+        ],
+        "compiled": {
+            "model_parameter_evaluator": {
+                "kind": "model-parameter-evaluator",
+                "evaluator": _source_leaf(
+                    optimization_level,
+                    include_plane=False,
+                ),
+            },
+            "stage_evaluators": _stage_set(optimization_level),
+        },
+        "helicity_sum_execution": {
+            "required_runtime_capabilities": [
+                gate.COMPILED_PLANE_ARENA_CAPABILITY,
+            ],
+            "runtime_schema": {
+                "model_parameter_evaluator": None,
+                "stage_evaluators": _stage_set(optimization_level),
+            },
+        },
+    }
+
+
+def _profile() -> dict[str, object]:
+    result: dict[str, object] = {
+        "execution_mode": "compiled",
+        "evaluator_backend_call_count": 7,
+        "compiled_direct_arena_engine_count": 2,
+        "compiled_direct_arena_call_count": 7,
+    }
+    result.update(dict.fromkeys(gate._ZERO_PROFILE_COUNTERS, 0))
+    result.update(dict.fromkeys(gate._ZERO_PROFILE_TIMES, 0.0))
+    return result
+
+
+def _capture(offset: float = 0.0) -> gate.EvaluationCapture:
+    values = (complex(1.0 + offset), complex(2.0 + offset))
+    components = (complex(0.25 + offset), complex(0.75))
+    return gate.EvaluationCapture(
+        physics_axes={
+            "process": gate.PROCESS,
+            "helicities": ["h:one"],
+            "color_flows": ["flow:one"],
+        },
+        f64_total=values,
+        precision32_total=values,
+        f64_components=components,
+        precision32_components=components,
+    )
+
+
+@pytest.mark.parametrize("optimization_level", gate.JIT_LEVELS)
+def test_recursive_audit_accepts_every_jit_level(
+    optimization_level: int,
+) -> None:
+    result = gate._audit_execution_payload(
+        _execution_payload(optimization_level),
+        optimization_level,
+    )
+
+    assert result["source_optimization_level"] == optimization_level
+    assert result["stage_set_count"] == 2
+    assert result["descriptor_count"] == 2
+    assert result["leaf_count"] == 2
+    assert result["model_parameter_direct_application_count"] == 0
+    assert result["passes"] is True
+
+
+@pytest.mark.parametrize(
+    "mutation, message",
+    [
+        (
+            lambda payload: payload["compiled"]["stage_evaluators"][
+                "amplitude_stage"
+            ].pop("compiled_plane_arena"),
+            "compiled_plane_arena",
+        ),
+        (
+            lambda payload: payload["compiled"]["stage_evaluators"]["amplitude_stage"][
+                "compiled_plane_arena"
+            ]["leaves"][0].update({"optimization_level": 3}),
+            "does not retain JIT O1",
+        ),
+        (
+            lambda payload: payload["compiled"]["stage_evaluators"]["amplitude_stage"][
+                "compiled_plane_arena"
+            ]["leaves"][0].update({"direct_codegen_optimization_level": 2}),
+            "does not match.*plane",
+        ),
+        (
+            lambda payload: payload["helicity_sum_execution"]["runtime_schema"][
+                "stage_evaluators"
+            ]["amplitude_stage"]["evaluator"].update({"optimization_level": 2}),
+            "does not retain JIT O1",
+        ),
+        (
+            lambda payload: payload["compiled"]["model_parameter_evaluator"].update(
+                {"compiled_plane_arena": {"kind": "compiled-plane-arena-stage"}}
+            ),
+            "model_parameter_evaluator illegally",
+        ),
+        (
+            lambda payload: payload["compiled"]["model_parameter_evaluator"].update(
+                {
+                    "nested": {
+                        "application_abi": (gate.NATIVE_COMPILED_DIRECT_APPLICATION_ABI)
+                    }
+                }
+            ),
+            "direct application ABI",
+        ),
+    ],
+)
+def test_recursive_audit_rejects_level_or_direct_application_drift(
+    mutation: Callable[[dict[str, object]], object],
+    message: str,
+) -> None:
+    payload = deepcopy(_execution_payload(1))
+    mutation(payload)
+
+    with pytest.raises(gate.GateError, match=message):
+        gate._audit_execution_payload(payload, 1)
+
+
+def test_profile_audit_requires_direct_calls_and_zero_legacy_traffic() -> None:
+    result = gate._audit_profile(_profile())
+
+    assert result["direct_arena_engine_counter"] == {
+        "name": "compiled_direct_arena_engine_count",
+        "value": 2,
+    }
+    assert result["direct_arena_call_counter"] == {
+        "name": "compiled_direct_arena_call_count",
+        "value": 7,
+    }
+    assert result["passes"] is True
+
+    traffic = _profile()
+    traffic["amplitude_output_remap_component_count"] = 1
+    with pytest.raises(gate.GateError, match=r"output_remap.*=1"):
+        gate._audit_profile(traffic)
+
+    no_calls = _profile()
+    no_calls["compiled_direct_arena_call_count"] = 0
+    with pytest.raises(gate.GateError, match="no compiled Direct-Arena calls"):
+        gate._audit_profile(no_calls)
+
+    incomplete_calls = _profile()
+    incomplete_calls["compiled_direct_arena_call_count"] = 6
+    with pytest.raises(gate.GateError, match="every evaluator backend call"):
+        gate._audit_profile(incomplete_calls)
+
+
+def test_profile_audit_requires_explicit_direct_engine_counter() -> None:
+    profile = _profile()
+
+    result = gate._audit_profile(profile)
+
+    assert result["direct_arena_engine_counter"] == {
+        "name": "compiled_direct_arena_engine_count",
+        "value": 2,
+    }
+
+    profile["compiled_direct_arena_engine_count"] = 0
+    with pytest.raises(gate.GateError, match="no compiled Direct-Arena engines"):
+        gate._audit_profile(profile)
+
+
+def test_runtime_profile_fails_closed_when_api_has_no_profiler() -> None:
+    class RuntimeWithoutProfile:
+        pass
+
+    with pytest.raises(gate.GateError, match="activity cannot be proven"):
+        gate._profile_runtime(RuntimeWithoutProfile(), (((),),))
+
+
+def test_cross_level_parity_covers_totals_and_resolved_components() -> None:
+    captures = {level: _capture() for level in gate.JIT_LEVELS}
+
+    result = gate._cross_level_parity(captures)
+
+    assert set(result["comparisons"]) == {"o0_vs_o3", "o1_vs_o3", "o2_vs_o3"}
+    assert all(
+        set(comparisons)
+        == {
+            "f64_totals",
+            "precision32_totals",
+            "f64_resolved_components",
+            "precision32_resolved_components",
+        }
+        for comparisons in result["comparisons"].values()
+    )
+
+    captures[1] = _capture(offset=1.0e-3)
+    with pytest.raises(gate.GateError, match="O1/O3 f64 totals"):
+        gate._cross_level_parity(captures)
+
+
+def test_orchestrator_generates_and_checks_exactly_o0_through_o3(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    generated: list[int] = []
+    source = {"revision": "a" * 40}
+    runtime = {"identity": "candidate"}
+    runtime_sha = gate._canonical_sha256(runtime)
+    monkeypatch.setattr(gate, "_source_identity", lambda: source)
+    monkeypatch.setattr(gate, "_runtime_identity", lambda observed: runtime)
+    monkeypatch.setattr(
+        gate,
+        "_file_identity",
+        lambda path: {"path": str(path), "sha256": "c" * 64},
+    )
+    monkeypatch.setattr(
+        gate,
+        "_prepare_output_root",
+        lambda output_root, replace: tmp_path,
+    )
+    monkeypatch.setattr(gate, "_deterministic_points", lambda count: (((),),) * count)
+    monkeypatch.setattr(
+        gate,
+        "_points_identity",
+        lambda points: {"sha256": "b" * 64, "point_count": len(points)},
+    )
+
+    def generate(
+        artifact: Path,
+        optimization_level: int,
+        expected_revision: str,
+        expected_script_sha256: str,
+        *,
+        timeout: float,
+    ) -> dict[str, object]:
+        generated.append(optimization_level)
+        return {
+            "optimization_level": optimization_level,
+            "artifact": str(artifact),
+            "timeout": timeout,
+            "worker_provenance": {
+                "source_revision": expected_revision,
+                "runtime_identity_sha256": runtime_sha,
+                "gate_script_sha256": expected_script_sha256,
+                "postflight_identity_match": True,
+            },
+        }
+
+    monkeypatch.setattr(gate, "_invoke_generation_worker", generate)
+    monkeypatch.setattr(
+        gate,
+        "_artifact_identity_and_audit",
+        lambda artifact, level: ({"artifact_id": f"o{level}"}, "process"),
+    )
+    monkeypatch.setattr(
+        gate,
+        "_evaluate_artifact",
+        lambda artifact, process_id, optimization_level, points: (
+            {"passes": True},
+            _capture(),
+        ),
+    )
+    monkeypatch.setattr(gate, "_peak_rss_gib", lambda: 1.0)
+    arguments = argparse.Namespace(
+        output_root=tmp_path,
+        replace=False,
+        points=2,
+        generation_timeout=123.0,
+    )
+
+    result = gate.run_gate(arguments)
+
+    assert generated == [0, 1, 2, 3]
+    assert set(result["levels"]) == {"jit-o0", "jit-o1", "jit-o2", "jit-o3"}
+    assert result["passes"] is True
+    assert result["status"] == "ok"
+    assert result["source_identity_match"] is True
+    assert result["runtime_identity_match"] is True
+    assert result["gate_script_identity_match"] is True
+    assert result["content_identity"]["sha256"] == gate._canonical_sha256(
+        {key: value for key, value in result.items() if key != "content_identity"}
+    )
+
+
+def test_parser_documents_mandatory_watchdog_and_defaults() -> None:
+    parsed = gate.parser().parse_args(["--output-root", "out"])
+
+    assert parsed.points == 2
+    assert parsed.generation_timeout == 3_600.0
+    assert "--limit-gib 30" in gate.WATCHDOG_INVOCATION
+    assert "compiled_all_jit_arena_gate.py" in gate.WATCHDOG_INVOCATION
+
+
+def test_output_root_must_not_dirty_the_authenticated_checkout() -> None:
+    with pytest.raises(gate.GateError, match="outside the source checkout"):
+        gate._prepare_output_root(gate.ROOT / "generated-gate", replace=False)
diff --git a/pyamplicol/tests/unit/test_compiled_helicity_sum_artifact.py b/pyamplicol/tests/unit/test_compiled_helicity_sum_artifact.py
new file mode 100644
index 0000000000..7144dcdce9
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiled_helicity_sum_artifact.py
@@ -0,0 +1,1164 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+import pyamplicol.generation.artifact_writer as artifact_writer
+import pyamplicol.generation.service as service_module
+import pyamplicol.models.loading as model_loading
+from pyamplicol._internal.versions import (
+    COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY,
+    COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY,
+    COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY,
+    COMPILED_HELICITY_DUAL_LANE_CAPABILITY,
+    COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY,
+    COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY,
+    COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+    COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+    EVALUATOR_RUNTIME_CAPABILITIES,
+    SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+    SYMJIT_APPLICATION_ABI,
+    SYMJIT_F64_RUNTIME_CAPABILITY,
+    SYMJIT_PLANE_APPLICATION_ABI,
+)
+from pyamplicol.api import ModelSource, ProcessRequest
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.artifacts.manifest import PORTABLE_64LE_TARGET
+from pyamplicol.config import (
+    ColorConfig,
+    ConfigurationError,
+    EvaluatorConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    RunConfig,
+)
+from pyamplicol.generation.artifact_writer import (
+    _GenerationConfigProvenance,
+    write_schema_v3_artifact,
+)
+from pyamplicol.generation.contracts import RuntimeExpressionSchema
+from pyamplicol.generation.evaluator_container import PacbinReader
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.generation.service import _ProcessSelection
+from pyamplicol.generation.stage_artifacts import _compiled_plane_arena_stage
+from pyamplicol.models import BuiltinSMModel, compile_model_source
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _evaluator_process(
+    expression: str = "d d~ > z g",
+    *,
+    selection: _ProcessSelection | None = None,
+    config: GenerationConfig | RunConfig | None = None,
+) -> tuple[
+    service_module.GenerationBackend,
+    BuiltinSMModel,
+    service_module._EvaluatorProcess,
+]:
+    model = BuiltinSMModel()
+    backend = service_module.GenerationBackend(
+        GenerationConfig() if config is None else config,
+        None,
+        process_selection=selection,
+    )
+    color_accuracy = (
+        config.color.accuracy.value if isinstance(config, RunConfig) else "lc"
+    )
+    process_ir = build_process_ir(expression, color_accuracy=color_accuracy)
+    dag, coverage = backend._compile_concrete_process(process_ir, model)
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(
+            expanded=service_module._ExpandedProcess(
+                request=ProcessRequest.parse(expression, name="dual_lane"),
+                process_ir=process_ir,
+            ),
+            dag=dag,
+            coverage=coverage,
+        ),
+        model,
+        index=0,
+        phase=PhaseHandle("test", None, 1),
+    )
+    evaluator = backend._construct_evaluator(
+        prepared,
+        model,
+        PhaseHandle("test", None, 1),
+    )
+    return backend, model, evaluator
+
+
+def _symjit_stage_manifest(
+    root: Path,
+    *,
+    label: str,
+    optimization_level: int = 3,
+    value_component_count: int = 0,
+) -> dict[str, object]:
+    evaluator_dir = root / "evaluators"
+    evaluator_dir.mkdir(parents=True, exist_ok=True)
+    application = evaluator_dir / f"{label}.symjit"
+    plane_application = evaluator_dir / f"{label}.plane.symjit"
+    state = evaluator_dir / f"{label}.evaluator.bin"
+    application.write_bytes(f"application:{label}".encode())
+    plane_application.write_bytes(f"plane-application:{label}".encode())
+    state.write_bytes(f"state:{label}".encode())
+    plane_source_digest = hashlib.sha256(f"instructions:{label}".encode()).hexdigest()
+    evaluator = {
+        "kind": "symjit-application-evaluator",
+        "runtime_capability": SYMJIT_F64_RUNTIME_CAPABILITY,
+        "input_len": 1,
+        "output_len": 1,
+        "application_path": application.relative_to(root).as_posix(),
+        "application_abi": SYMJIT_APPLICATION_ABI,
+        "plane_application": {
+            "application_path": plane_application.relative_to(root).as_posix(),
+            "application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+            "storage_abi": SYMJIT_APPLICATION_ABI,
+            "element_layout": "split-complex-plane-major",
+            "descriptor_order": "inputs-re-im-then-outputs-re-im",
+            "input_complex_count": 1,
+            "output_complex_count": 1,
+            "input_plane_count": 2,
+            "output_plane_count": 2,
+            "compiler_type": "native",
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": optimization_level,
+            "simd": True,
+            "complex": True,
+            "fast_math": True,
+            "fast_complex": False,
+            "compression": False,
+            "threading": False,
+            "direct_arena": True,
+            "source_digest": plane_source_digest,
+            "target": {"word_bits": 64, "endianness": "little"},
+        },
+        "element_layout": "complex-f64",
+        "batch_layout": "row-major",
+        "compiler_type": "native",
+        "translation_mode": "indirect",
+        "optimization_level": optimization_level,
+        "word_bits": 64,
+        "endianness": "little",
+        "required_defuns": [],
+        "evaluator_state_path": state.relative_to(root).as_posix(),
+        "evaluator_state_runtime_capability": (SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY),
+    }
+    input_component = {
+        "kind": "momentum",
+        "source_id": 0,
+        "component": 0,
+        "global_component": value_component_count,
+        "parameter_index": 0,
+        "real_valued": True,
+    }
+    amplitude_stage = {
+        "stage_index": 0,
+        "stage_kind": "amplitude",
+        "subset_size": None,
+        "evaluator_label": label,
+        "parameter_layout": "stage-local-value-momentum",
+        "output_length": 1,
+        "output_slots": [
+            {
+                "value_slot_id": -1,
+                "current_id": -1,
+                "variant": "amplitude-root",
+                "component_start": 0,
+                "component_stop": 1,
+                "output_start": 0,
+                "output_stop": 1,
+                "color_selector_domain_ids": [],
+            }
+        ],
+        "input_value_slot_ids": [],
+        "output_value_slot_ids": [],
+        "interaction_ids": [],
+        "input_components": [input_component],
+        "parameter_count": 1,
+        "value_parameter_count": 0,
+        "momentum_parameter_count": 1,
+        "model_parameter_count": 0,
+        "real_valued_inputs": [0],
+        "expression_ready": True,
+        "blockers": [],
+        "evaluator": evaluator,
+    }
+    direct = _compiled_plane_arena_stage(amplitude_stage)
+    assert direct is not None
+    amplitude_stage["compiled_plane_arena"] = direct
+    return {
+        "kind": "generic-dag-stage-evaluator-artifacts",
+        "runtime_available": True,
+        "runtime_unavailable_message": None,
+        "parameter_count": 0,
+        "value_parameter_count": 0,
+        "momentum_parameter_count": 0,
+        "model_parameter_count": 0,
+        "real_valued_inputs": [],
+        "parameter_layout": "stage-local-value-momentum",
+        "stage_count": 1,
+        "required_runtime_capabilities": [
+            COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+            SYMJIT_F64_RUNTIME_CAPABILITY,
+        ],
+        "stages": [],
+        "amplitude_stage": amplitude_stage,
+    }
+
+
+def _materialize_without_symbolica(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    *,
+    expression: str = "d d~ > z g",
+    selection: _ProcessSelection | None = None,
+    config: GenerationConfig | RunConfig | None = None,
+    jit_optimization_level: int = 3,
+) -> service_module.CompiledProcessArtifact:
+    backend, model, evaluator = _evaluator_process(
+        expression,
+        selection=selection,
+        config=config,
+    )
+    calls: list[tuple[Path, int]] = []
+
+    def compile_stages(
+        stage_input: object,
+        runtime_schema: dict[str, object],
+        root: Path,
+        **_kwargs: object,
+    ) -> tuple[object, dict[str, object]]:
+        lane = "-".join(root.relative_to(tmp_path / "build").parts).replace(
+            ".",
+            "",
+        )
+        calls.append((root, len(stage_input.dag.currents)))  # type: ignore[attr-defined]
+        layout = runtime_schema["parameter_layout"]
+        assert isinstance(layout, dict)
+        return object(), _symjit_stage_manifest(
+            root,
+            label=lane,
+            optimization_level=jit_optimization_level,
+            value_component_count=int(layout["value_component_count"]),
+        )
+
+    monkeypatch.setattr(
+        service_module,
+        "build_and_write_generic_stage_evaluator_artifacts",
+        compile_stages,
+    )
+    monkeypatch.setattr(
+        service_module,
+        "write_model_parameter_evaluator_artifact",
+        lambda *_args, **_kwargs: None,
+    )
+    artifact = backend._materialize_evaluator_unlocked(
+        evaluator,
+        model,
+        tmp_path / "build",
+        PhaseHandle("jit", None, None),
+        PhaseHandle("process", None, None),
+        backend="JIT",
+    )
+
+    expected_calls = [
+        (tmp_path / "build" / "dual_lane", len(evaluator.compiled.dag.currents))
+    ]
+    if evaluator.compiled.helicity_sum_dag is not None:
+        expected_calls.append(
+            (
+                tmp_path / "build" / ".helicity-sum" / "dual_lane",
+                len(evaluator.compiled.helicity_sum_dag.currents),
+            )
+        )
+
+    def add_selector_lane_call(
+        lane: service_module._HelicitySelectorLane,
+        root: Path,
+    ) -> None:
+        expected_calls.append((root, len(lane.dag.currents)))
+        for child_index, child in enumerate(lane.child_lanes):
+            add_selector_lane_call(
+                child,
+                root.parent / f"{root.name}-closure-{child_index}",
+            )
+
+    selector_root = tmp_path / "build" / ".helicity-selector-union" / "dual_lane"
+    for lane_index, lane in enumerate(evaluator.helicity_selector_lanes):
+        add_selector_lane_call(lane, selector_root / f"class-{lane_index}")
+    selector_root = (
+        ".helicity-sum-color-selector"
+        if evaluator.compiled.helicity_sum_dag is not None
+        else ".color-selector"
+    )
+    expected_calls.extend(
+        (
+            tmp_path
+            / "build"
+            / selector_root
+            / "dual_lane"
+            / f"sector-{lane.materialized_sector_id}",
+            len(lane.dag.currents),
+        )
+        for lane in evaluator.color_selector_lanes
+    )
+    assert calls == expected_calls
+    return artifact
+
+
+@pytest.mark.parametrize("value_component_count", [0, 12])
+def test_mock_symjit_manifest_preserves_the_compiled_arena_invariant(
+    tmp_path: Path,
+    value_component_count: int,
+) -> None:
+    manifest = _symjit_stage_manifest(
+        tmp_path,
+        label="authenticated",
+        value_component_count=value_component_count,
+    )
+    amplitude_stage = manifest["amplitude_stage"]
+    assert isinstance(amplitude_stage, dict)
+    evaluator = amplitude_stage["evaluator"]
+    assert isinstance(evaluator, dict)
+    direct = amplitude_stage["compiled_plane_arena"]
+    assert isinstance(direct, dict)
+    leaves = direct["leaves"]
+    assert isinstance(leaves, list)
+    plane_application = evaluator["plane_application"]
+    assert isinstance(plane_application, dict)
+    assert leaves == [
+        {
+            "application_path": plane_application["application_path"],
+            "source_application_abi": plane_application["application_abi"],
+            "optimization_level": plane_application["optimization_level"],
+            "direct_codegen_optimization_level": plane_application[
+                "optimization_level"
+            ],
+            "input_len": evaluator["input_len"],
+            "output_len": evaluator["output_len"],
+            "input_indices": [0],
+            "output_start": 0,
+            "output_stop": 1,
+        }
+    ]
+    assert (
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY
+        in manifest["required_runtime_capabilities"]
+    )
+    assert artifact_writer._compiled_momentum_slot_ids(
+        manifest,
+        value_component_count=value_component_count,
+        momentum_component_count=4,
+    ) == [0]
+
+    del amplitude_stage["compiled_plane_arena"]
+    with pytest.raises(ValueError, match="compiled f64 artifacts require"):
+        artifact_writer._stage_evaluator_set(manifest)
+
+
+def _payload_paths(value: object) -> set[str]:
+    result: set[str] = set()
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key in {
+                "application_path",
+                "evaluator_state_path",
+                "library_path",
+            } and isinstance(item, str):
+                result.add(item)
+            else:
+                result.update(_payload_paths(item))
+    elif isinstance(value, list):
+        for item in value:
+            result.update(_payload_paths(item))
+    return result
+
+
+def test_generation_retains_selector_and_fused_helicity_sum_dags() -> None:
+    _backend, _model, evaluator = _evaluator_process()
+    prepared = evaluator.compiled
+    assert prepared.helicity_sum_dag is not None
+    assert prepared.helicity_sum_dag.helicity_recurrence is None
+    assert prepared.helicity_sum_dag.helicity_materialization is None
+    assert prepared.dag.helicity_materialization is not None
+    assert prepared.dag.helicity_materialization.strategy == "quotient"
+    assert prepared.dag.helicity_materialization.materialized_current_count == len(
+        prepared.dag.currents
+    )
+    assert prepared.dag.helicity_materialization.materialized_root_count == len(
+        prepared.dag.amplitude_roots
+    )
+
+    primary = evaluator.runtime_schema.to_mapping()
+    assert evaluator.helicity_sum_runtime_schema is not None
+    assert evaluator.helicity_sum_stage_input is not None
+    assert "materialization" in primary["helicity_recurrence"]
+    assert primary["helicity_recurrence"]["materialization"]["strategy"] == "quotient"
+    assert "helicity_recurrence" not in (
+        evaluator.helicity_sum_runtime_schema.to_mapping()
+    )
+
+    assert evaluator.helicity_selector_lanes
+    materialization = prepared.dag.helicity_materialization
+    assert materialization is not None
+    nonzero_domains = {
+        schedule.selector_domain_id
+        for schedule in materialization.selector_schedules
+        if not schedule.structural_zero
+    }
+    assert {
+        domain_id
+        for lane in evaluator.helicity_selector_lanes
+        for domain_id in lane.selector_domain_ids
+    } == nonzero_domains
+    assert len(evaluator.helicity_selector_lanes) == len(
+        {
+            (schedule.active_current_ids, schedule.active_root_ids)
+            for schedule in materialization.selector_schedules
+            if not schedule.structural_zero
+        }
+    )
+    for lane in evaluator.helicity_selector_lanes:
+        selector_input = lane.stage_input
+        assert selector_input.dag.currents == prepared.dag.currents
+        assert selector_input.dag.interactions == prepared.dag.interactions
+        assert selector_input.dag.amplitude_roots == prepared.dag.amplitude_roots
+        assert selector_input.dag.helicity_recurrence is None
+        assert selector_input.dag.helicity_materialization is None
+        selector_schema = lane.runtime_schema.to_mapping()
+        assert "helicity_recurrence" not in selector_schema
+        assert all(
+            int(stage["interaction_count"]) < int(parent_stage["interaction_count"])
+            for stage, parent_stage in zip(
+                selector_schema["stages"],
+                primary["stages"],
+                strict=True,
+            )
+        )
+
+
+def test_all_flow_union_artifact_omits_duplicate_execution_lanes(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = _materialize_without_symbolica(
+        monkeypatch,
+        tmp_path,
+        expression="d d~ > z g g",
+        config=RunConfig(
+            action="generate",
+            color=ColorConfig(lc_flow_layout="all-flow-union"),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+            generation=GenerationConfig(
+                emit_api_bundle=False,
+            ),
+        ),
+    )
+
+    assert artifact.helicity_sum_execution is None
+    assert artifact.helicity_selector_executions
+    assert all(
+        record.schedule_mode == "parent-closure"
+        for record in artifact.helicity_selector_executions
+    )
+    assert artifact.color_selector_executions == ()
+    capabilities = artifact_writer._compiled_process_runtime_capabilities(artifact)
+    assert COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY in capabilities
+    execution = artifact_writer._execution_manifest(
+        artifact,
+        artifact.runtime_schema.to_mapping(),
+    )
+    assert (
+        COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY
+        in execution["required_runtime_capabilities"]
+    )
+    assert (
+        COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY
+        not in execution["compiled"]["stage_evaluators"][
+            "required_runtime_capabilities"
+        ]
+    )
+
+
+def test_color_topology_lane_capability_is_publicly_supported() -> None:
+    assert COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY in EVALUATOR_RUNTIME_CAPABILITIES
+
+
+def test_walsh_color_contraction_capability_is_publicly_supported() -> None:
+    assert COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY in EVALUATOR_RUNTIME_CAPABILITIES
+    assert (
+        COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY
+        in EVALUATOR_RUNTIME_CAPABILITIES
+    )
+
+
+def test_helicity_selector_union_capability_is_publicly_supported() -> None:
+    assert COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY in EVALUATOR_RUNTIME_CAPABILITIES
+
+
+def test_primary_helicity_recurrence_capability_is_publicly_supported() -> None:
+    assert (
+        COMPILED_HELICITY_PRIMARY_RECURRENCE_CAPABILITY
+        in EVALUATOR_RUNTIME_CAPABILITIES
+    )
+
+
+def test_complete_lc_union_owns_childless_materialized_selector_lane() -> None:
+    _backend, model, evaluator = _evaluator_process("d d~ > z g g g")
+
+    assert len(evaluator.helicity_selector_lanes) == 1
+    union = evaluator.helicity_selector_lanes[0]
+    assert union.schedule_mode == "nested-runtime"
+    assert union.child_lanes == ()
+    assert union.dag.helicity_materialization is not None
+    assert union.dag.lc_topology_replay is None
+    assert union.dag.color_topology_replay is None
+    assert (
+        service_module._compiled_helicity_selector_closure_lanes(
+            evaluator.compiled.dag,
+            evaluator.runtime_schema,
+            model,
+        )
+        == ()
+    )
+
+
+@pytest.mark.parametrize("accuracy", ["nlc", "full"])
+def test_replayed_contracted_color_uses_physical_childless_selector_companion(
+    accuracy: str,
+) -> None:
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=accuracy),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+        generation=GenerationConfig(
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+        ),
+    )
+    _backend, _model, evaluator = _evaluator_process(
+        "g g > g g",
+        config=config,
+    )
+
+    primary = evaluator.compiled.dag
+    assert primary.color_topology_replay is not None
+    assert len(evaluator.helicity_selector_lanes) == 1
+    companion = evaluator.helicity_selector_lanes[0]
+    assert companion.schedule_mode == "nested-runtime"
+    assert companion.child_lanes == ()
+    assert companion.dag.process.color_accuracy == accuracy
+    assert companion.dag.selected_source_helicities == ()
+    assert companion.dag.helicity_coverage == "complete"
+    assert companion.dag.color_coverage == "complete"
+    assert companion.dag.lc_topology_replay is None
+    assert companion.dag.color_topology_replay is None
+    assert companion.dag.helicity_materialization is not None
+    assert companion.dag.color_plan.sectors == primary.color_plan.sectors
+    service_module._validate_matching_helicity_selector_domains(
+        primary,
+        companion.dag,
+    )
+
+
+def test_childless_nested_helicity_selector_is_written_with_owned_payloads(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = _materialize_without_symbolica(
+        monkeypatch,
+        tmp_path,
+        expression="d d~ > z g g g",
+        jit_optimization_level=2,
+    )
+    monkeypatch.setattr(
+        artifact_writer,
+        "_target_metadata",
+        lambda _config: (
+            {"triple": "aarch64-apple-darwin", "cpu_features": []},
+            1,
+        ),
+    )
+    monkeypatch.setattr(model_loading, "package_version", lambda: "0.1.4")
+    monkeypatch.setattr(artifact_writer, "package_version", lambda: "0.1.4")
+    monkeypatch.setattr(
+        artifact_writer,
+        "active_native_build_inputs_sha256",
+        lambda: "0" * 64,
+    )
+    output = tmp_path / "artifact"
+    write_schema_v3_artifact(
+        output,
+        mode="error",
+        source=ModelSource.built_in_sm(),
+        compiled_model=compile_model_source("built-in-sm", use_cache=False),
+        configuration=_GenerationConfigProvenance.from_config(
+            GenerationConfig(emit_api_bundle=False)
+        ),
+        processes=(artifact,),
+        timings={"total": 0.1},
+        api_bundle_hook=None,
+    )
+
+    execution = json.loads(
+        (output / "processes/dual_lane/execution.json").read_text(encoding="utf-8")
+    )
+    outer = execution["helicity_selector_executions"][0]
+    assert outer["schedule_mode"] == "nested-runtime"
+    assert "helicity_selector_executions" not in outer["execution"]
+
+    referenced = _payload_paths(execution)
+    nested_prefix = "helicity-selector-union/class-0/"
+    assert any(path.startswith(nested_prefix) for path in referenced)
+    assert not any(
+        path.startswith(f"{nested_prefix}helicity-selector-union/")
+        for path in referenced
+    )
+    manifest = load_manifest(output)
+    portable_target = {
+        "triple": PORTABLE_64LE_TARGET,
+        "cpu_features": (),
+    }
+    assert manifest.producer["target"] == portable_target
+    targeted_payloads = [
+        record for record in manifest.payloads if record.target is not None
+    ]
+    assert targeted_payloads
+    assert all(record.target == portable_target for record in targeted_payloads)
+    declared = {record.path for record in manifest.payloads}
+    assert "evaluators.pacbin" in declared
+    with PacbinReader.open(output / "evaluators.pacbin") as container:
+        members = {member.logical_path for member in container.members}
+    for relative in referenced:
+        assert f"processes/dual_lane/{relative}" in members
+
+
+def test_compiled_symmetric_group_is_rejected_before_generation() -> None:
+    with pytest.raises(
+        ConfigurationError,
+        match=r"requires evaluator\.execution_mode='recurrence' or 'on-the-fly'",
+    ):
+        RunConfig(
+            action="generate",
+            color=ColorConfig(
+                accuracy="full",
+                contraction="symmetric-group-fft",
+            ),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        )
+
+
+def test_generation_specialized_color_artifact_has_no_topology_lanes(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = _materialize_without_symbolica(
+        monkeypatch,
+        tmp_path,
+        expression="d d~ > z g g",
+        selection=_ProcessSelection(selected_color_sector_ids=frozenset({0})),
+    )
+
+    assert artifact.color_selector_executions == ()
+    assert artifact.helicity_selector_executions
+    if artifact.helicity_sum_execution is not None:
+        assert artifact.helicity_sum_execution.color_selector_executions == ()
+    manifest = artifact_writer._execution_manifest(
+        artifact,
+        artifact.runtime_schema.to_mapping(),
+    )
+    assert "color_selector_executions" not in manifest
+    auxiliary = manifest.get("helicity_sum_execution")
+    if isinstance(auxiliary, dict):
+        assert "color_selector_executions" not in auxiliary
+    assert (
+        COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY
+        not in manifest["required_runtime_capabilities"]
+    )
+
+
+def test_complete_lc_artifact_serializes_every_materialized_sector_lane(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _backend, _model, evaluator = _evaluator_process("g g > g g")
+    target_dag = evaluator.compiled.helicity_sum_dag or evaluator.compiled.dag
+    expected_sector_ids = tuple(
+        sorted(
+            {
+                int(root.color_sector_id)
+                for root in target_dag.amplitude_roots
+                if root.color_sector_id is not None
+            }
+        )
+    )
+    assert expected_sector_ids
+    assert (
+        tuple(lane.materialized_sector_id for lane in evaluator.color_selector_lanes)
+        == expected_sector_ids
+    )
+
+    artifact = _materialize_without_symbolica(
+        monkeypatch,
+        tmp_path,
+        expression="g g > g g",
+    )
+    manifest = artifact_writer._execution_manifest(
+        artifact,
+        artifact.runtime_schema.to_mapping(),
+    )
+    parent = manifest.get("helicity_sum_execution", manifest)
+    records = parent["color_selector_executions"]
+    assert (
+        tuple(record["materialized_sector_id"] for record in records)
+        == expected_sector_ids
+    )
+    assert all(
+        "color_selector_executions" not in record["execution"]
+        and "helicity_sum_execution" not in record["execution"]
+        and "physics_reduction" in record["execution"]
+        for record in records
+    )
+
+
+def test_fixed_helicity_complete_lc_attaches_color_lanes_to_primary(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = _materialize_without_symbolica(
+        monkeypatch,
+        tmp_path,
+        expression="d d~ > z g g",
+        selection=_ProcessSelection(
+            selected_source_helicities={
+                1: -1,
+                2: 1,
+                3: -1,
+                4: 1,
+                5: -1,
+            }
+        ),
+    )
+
+    assert artifact.helicity_sum_execution is None
+    assert artifact.helicity_selector_executions == ()
+    assert artifact.color_selector_executions
+    manifest = artifact_writer._execution_manifest(
+        artifact,
+        artifact.runtime_schema.to_mapping(),
+    )
+    assert "helicity_sum_execution" not in manifest
+    assert manifest["color_selector_executions"]
+    assert (
+        COMPILED_RUNTIME_SELECTORS_CAPABILITY
+        in manifest["required_runtime_capabilities"]
+    )
+
+
+def test_eager_plan_v3_artifacts_have_no_compiled_selector_union_lane() -> None:
+    assert "helicity_selector_executions" not in (
+        service_module.EagerPlanV3ProcessArtifact.__dataclass_fields__
+    )
+
+
+def test_replayed_physical_flows_compile_only_materialized_sector_lanes() -> None:
+    _backend, _model, evaluator = _evaluator_process("d d~ > z g g")
+    target_dag = evaluator.compiled.helicity_sum_dag or evaluator.compiled.dag
+    replay = target_dag.lc_topology_replay
+
+    assert replay is not None
+    assert len(replay.physical_sector_ids) > len(replay.materialized_sector_ids)
+    assert (
+        tuple(lane.materialized_sector_id for lane in evaluator.color_selector_lanes)
+        == replay.materialized_sector_ids
+    )
+
+
+def test_color_selector_execution_lanes_cannot_nest(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = _materialize_without_symbolica(monkeypatch, tmp_path)
+    assert artifact.helicity_sum_execution is not None
+    record = artifact.helicity_sum_execution.color_selector_executions[0]
+    recursive_record = replace(
+        record,
+        execution=replace(
+            record.execution,
+            color_selector_executions=(record,),
+        ),
+    )
+    invalid = replace(
+        artifact,
+        helicity_sum_execution=replace(
+            artifact.helicity_sum_execution,
+            color_selector_executions=(recursive_record,),
+        ),
+    )
+
+    with pytest.raises(ValueError, match="cannot nest"):
+        artifact_writer._execution_manifest(
+            invalid,
+            invalid.runtime_schema.to_mapping(),
+        )
+
+
+def test_compiled_materialization_builds_primary_sum_and_selector_union_lanes(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = _materialize_without_symbolica(monkeypatch, tmp_path)
+    assert artifact.helicity_sum_execution is not None
+    assert artifact.helicity_selector_executions
+    assert (
+        artifact.dag_summary["current_count"]
+        == (
+            artifact.runtime_schema.to_mapping()["helicity_recurrence"][
+                "materialization"
+            ]["materialized_current_count"]
+        )
+    )
+    assert "helicity_recurrence" not in (
+        artifact.helicity_sum_execution.runtime_schema.to_mapping()
+    )
+    primary_schema = artifact.runtime_schema.to_mapping()
+    for record in artifact.helicity_selector_executions:
+        assert record.schedule_mode == "parent-closure"
+        selector = record.execution
+        selector_schema = selector.runtime_schema.to_mapping()
+        assert "helicity_recurrence" not in selector_schema
+        assert selector.helicity_selector_executions == ()
+        assert (
+            selector_schema["physics"]["reduction"]
+            == (primary_schema["physics"]["reduction"])
+        )
+        assert selector.dag_summary["current_count"] == len(
+            selector_schema["current_storage"]["current_slots"]
+        )
+        assert (
+            selector.dag_summary["amplitude_root_count"]
+            == (selector_schema["amplitude_stage"]["output_count"])
+        )
+        assert (
+            COMPILED_RUNTIME_SELECTORS_CAPABILITY
+            not in (selector.stage_manifest["required_runtime_capabilities"])
+        )
+    execution_manifest = artifact_writer._execution_manifest(
+        artifact,
+        primary_schema,
+    )
+    assert execution_manifest["materialization_census"]["final"] == {
+        name: value
+        for name, value in execution_manifest["dag_summary"].items()
+        if name.endswith("_count")
+    }
+    assert execution_manifest["helicity_sum_execution"]["materialization_census"][
+        "final"
+    ] == {
+        name: value
+        for name, value in execution_manifest["helicity_sum_execution"][
+            "dag_summary"
+        ].items()
+        if name.endswith("_count")
+    }
+    selector_records = execution_manifest["helicity_selector_executions"]
+    assert len(selector_records) == len(artifact.helicity_selector_executions)
+    for selector_record in selector_records:
+        assert selector_record["selector_domain_ids"]
+        assert selector_record["schedule_mode"] == "parent-closure"
+        selector_manifest = selector_record["execution"]
+        assert selector_manifest["kind"] == "pyamplicol-runtime-execution"
+        assert selector_manifest["materialization_census"]["final"] == {
+            name: value
+            for name, value in selector_manifest["dag_summary"].items()
+            if name.endswith("_count")
+        }
+        assert (
+            selector_manifest["physics_reduction"]
+            == (primary_schema["physics"]["reduction"])
+        )
+        assert "helicity_sum_execution" not in selector_manifest
+        assert "helicity_selector_executions" not in selector_manifest
+        assert "color_selector_executions" not in selector_manifest
+
+
+def test_helicity_selector_union_execution_cannot_nest(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = _materialize_without_symbolica(monkeypatch, tmp_path)
+    assert artifact.helicity_selector_executions
+    assert artifact.helicity_sum_execution is not None
+    nested_color_lane = artifact.helicity_sum_execution.color_selector_executions[0]
+    first = artifact.helicity_selector_executions[0]
+    invalid_first = replace(
+        first,
+        execution=replace(
+            first.execution,
+            color_selector_executions=(nested_color_lane,),
+        ),
+    )
+    invalid = replace(
+        artifact,
+        helicity_selector_executions=(
+            invalid_first,
+            *artifact.helicity_selector_executions[1:],
+        ),
+    )
+
+    with pytest.raises(ValueError, match="cannot nest"):
+        artifact_writer._execution_manifest(
+            invalid,
+            invalid.runtime_schema.to_mapping(),
+        )
+
+
+def test_compiled_process_capabilities_use_primary_execution_lane(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = _materialize_without_symbolica(monkeypatch, tmp_path)
+    assert artifact_writer._compiled_process_runtime_capabilities(artifact) == (
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+        COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY,
+        COMPILED_HELICITY_DUAL_LANE_CAPABILITY,
+        COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY,
+        COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+        SYMJIT_F64_RUNTIME_CAPABILITY,
+    )
+
+
+@pytest.mark.parametrize(
+    ("factorized_block", "walsh_capability"),
+    [
+        (
+            {
+                "kind": "klein-four-walsh",
+                "cosets": [[0, 1, 2, 3]],
+            },
+            COMPILED_COLOR_CONTRACTION_WALSH_CAPABILITY,
+        ),
+        (
+            {
+                "kind": "elementary-abelian-walsh",
+                "rank": 3,
+                "cosets": [list(range(8))],
+            },
+            COMPILED_COLOR_CONTRACTION_WALSH_C2K_CAPABILITY,
+        ),
+    ],
+)
+def test_walsh_color_contraction_capability_is_lane_local_and_parent_aggregated(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    factorized_block: dict[str, object],
+    walsh_capability: str,
+) -> None:
+    artifact = _materialize_without_symbolica(monkeypatch, tmp_path)
+
+    def with_walsh(
+        schema: RuntimeExpressionSchema,
+    ) -> RuntimeExpressionSchema:
+        payload = schema.to_mapping()
+        amplitude_stage = payload["amplitude_stage"]
+        assert isinstance(amplitude_stage, dict)
+        cosets = factorized_block["cosets"]
+        assert isinstance(cosets, list)
+        local_group_count = 1 + max(int(index) for coset in cosets for index in coset)
+        group_count = 2 * local_group_count
+        amplitude_stage["color_contraction"] = {
+            "color_accuracy": "full",
+            "supported": True,
+            "reason": None,
+            "group_count": group_count,
+            "includes_color_factor": True,
+            "entry_count": 0,
+            "logical_entry_count": 0,
+            "storage": "test",
+            "entries": [],
+            "repeated_block": {
+                "component_count": 2,
+                "component_group_ids": list(range(group_count)),
+                "entries": [],
+                "factorized_block": factorized_block,
+            },
+        }
+        return RuntimeExpressionSchema.from_mapping(payload)
+
+    old_manifest = artifact_writer._execution_manifest(
+        artifact,
+        artifact.runtime_schema.to_mapping(),
+    )
+    assert walsh_capability not in old_manifest["required_runtime_capabilities"]
+
+    primary = replace(artifact, runtime_schema=with_walsh(artifact.runtime_schema))
+    primary_manifest = artifact_writer._execution_manifest(
+        primary,
+        primary.runtime_schema.to_mapping(),
+    )
+    assert walsh_capability in primary_manifest["required_runtime_capabilities"]
+    assert (
+        walsh_capability
+        not in primary_manifest["compiled"]["stage_evaluators"][
+            "required_runtime_capabilities"
+        ]
+    )
+    assert walsh_capability in artifact_writer._compiled_process_runtime_capabilities(
+        primary
+    )
+
+    assert artifact.helicity_sum_execution is not None
+    auxiliary = replace(
+        artifact.helicity_sum_execution,
+        runtime_schema=with_walsh(artifact.helicity_sum_execution.runtime_schema),
+    )
+    parent = replace(artifact, helicity_sum_execution=auxiliary)
+    parent_manifest = artifact_writer._execution_manifest(
+        parent,
+        parent.runtime_schema.to_mapping(),
+    )
+    auxiliary_manifest = parent_manifest["helicity_sum_execution"]
+    assert walsh_capability in auxiliary_manifest["required_runtime_capabilities"]
+    assert walsh_capability in parent_manifest["required_runtime_capabilities"]
+    assert walsh_capability in artifact_writer._compiled_process_runtime_capabilities(
+        parent
+    )
+
+
+def test_writer_emits_selector_and_fused_sum_lanes_and_owns_all_payloads(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = _materialize_without_symbolica(monkeypatch, tmp_path)
+    primary_schema = artifact.runtime_schema.to_mapping()
+    execution_manifest = artifact_writer._execution_manifest(
+        artifact,
+        primary_schema,
+    )
+    assert "helicity_sum_execution" in execution_manifest
+    assert (
+        execution_manifest["runtime_schema"]["helicity_recurrence"]["materialization"][
+            "strategy"
+        ]
+        == "quotient"
+    )
+
+    monkeypatch.setattr(
+        artifact_writer,
+        "_target_metadata",
+        lambda _config: (
+            {"triple": "aarch64-apple-darwin", "cpu_features": []},
+            1,
+        ),
+    )
+    output = tmp_path / "artifact"
+    write_schema_v3_artifact(
+        output,
+        mode="error",
+        source=ModelSource.built_in_sm(),
+        compiled_model=compile_model_source("built-in-sm", use_cache=False),
+        configuration=_GenerationConfigProvenance.from_config(
+            GenerationConfig(emit_api_bundle=False)
+        ),
+        processes=(artifact,),
+        timings={"total": 0.1},
+        api_bundle_hook=None,
+    )
+
+    execution = json.loads(
+        (output / "processes/dual_lane/execution.json").read_text(encoding="utf-8")
+    )
+    assert "helicity_sum_execution" in execution
+    assert "helicity_selector_executions" in execution
+    assert execution["runtime_schema"]["process_key"] == "dual_lane"
+    assert (
+        execution["runtime_schema"]["helicity_recurrence"]["materialization"][
+            "strategy"
+        ]
+        == "quotient"
+    )
+    primary_evaluator = execution["compiled"]["stage_evaluators"]["amplitude_stage"][
+        "evaluator"
+    ]
+    assert primary_evaluator["optimization_level"] == 3
+    helicity_sum_evaluator = execution["helicity_sum_execution"]["compiled"][
+        "stage_evaluators"
+    ]["amplitude_stage"]["evaluator"]
+    assert helicity_sum_evaluator["optimization_level"] == 3
+    assert (
+        "helicity_recurrence"
+        not in execution["helicity_sum_execution"]["runtime_schema"]
+    )
+    selector_records = execution["helicity_selector_executions"]
+    assert selector_records
+    for record in selector_records:
+        selector_lane = record["execution"]
+        assert record["selector_domain_ids"]
+        assert record["schedule_mode"] == "parent-closure"
+        assert "helicity_recurrence" not in selector_lane["runtime_schema"]
+        assert "helicity_selector_executions" not in selector_lane
+        assert (
+            selector_lane["physics_reduction"] == primary_schema["physics"]["reduction"]
+        )
+        assert (
+            COMPILED_RUNTIME_SELECTORS_CAPABILITY
+            not in selector_lane["required_runtime_capabilities"]
+        )
+    color_selector_records = execution["helicity_sum_execution"][
+        "color_selector_executions"
+    ]
+    assert artifact.helicity_sum_execution is not None
+    assert [record["materialized_sector_id"] for record in color_selector_records] == [
+        0
+    ]
+    color_selector_execution = color_selector_records[0]["execution"]
+    assert "helicity_sum_execution" not in color_selector_execution
+    assert "color_selector_executions" not in color_selector_execution
+    assert (
+        color_selector_execution["physics_reduction"]
+        == (
+            artifact.helicity_sum_execution.color_selector_executions[
+                0
+            ].execution.runtime_schema.to_mapping()["physics"]["reduction"]
+        )
+    )
+
+    manifest = load_manifest(output)
+    declared = {record.path for record in manifest.payloads}
+    referenced = _payload_paths(execution)
+    assert referenced
+    assert any(path.startswith("helicity-sum/") for path in referenced)
+    assert any(path.startswith("helicity-selector-union/") for path in referenced)
+    assert any(
+        path.startswith("helicity-sum/color-selector/sector-0/") for path in referenced
+    )
+    assert "evaluators.pacbin" in declared
+    with PacbinReader.open(output / "evaluators.pacbin") as container:
+        members = {member.logical_path for member in container.members}
+    for relative in referenced:
+        assert f"processes/dual_lane/{relative}" in members
+    assert execution["required_runtime_capabilities"] == [
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+        COMPILED_COLOR_TOPOLOGY_LANES_CAPABILITY,
+        COMPILED_HELICITY_DUAL_LANE_CAPABILITY,
+        COMPILED_HELICITY_SELECTOR_UNION_CAPABILITY,
+        COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+        SYMJIT_F64_RUNTIME_CAPABILITY,
+    ]
+    generation = manifest.extensions["generation"]["concrete_processes"][0]
+    assert generation["runtime_schema_sha256"] == artifact.runtime_schema.sha256
+    assert artifact.helicity_sum_execution is not None
+    assert generation["helicity_sum_runtime_schema_sha256"] == (
+        artifact.helicity_sum_execution.runtime_schema.sha256
+    )
+    assert artifact.helicity_selector_executions
+    assert generation["helicity_selector_runtime_schema_sha256s"] == [
+        record.execution.runtime_schema.sha256
+        for record in artifact.helicity_selector_executions
+    ]
diff --git a/pyamplicol/tests/unit/test_compiled_lc_color_transition_terms.py b/pyamplicol/tests/unit/test_compiled_lc_color_transition_terms.py
new file mode 100644
index 0000000000..7791a33961
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiled_lc_color_transition_terms.py
@@ -0,0 +1,195 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import FrozenInstanceError, replace
+
+import pytest
+
+from pyamplicol.models.contracts import (
+    CompiledLCColorTransitionTerm,
+    CompiledModelIR,
+    CompiledOrientedKernel,
+)
+
+
+def _term() -> CompiledLCColorTransitionTerm:
+    return CompiledLCColorTransitionTerm(
+        input_permutation=(1, 0),
+        reverse_parent_mask=1,
+        component_operation="concatenate-join",
+        result_component_kind="open-string",
+        result_component_role="active",
+        input_shape_kinds=("adjoint-segment", "fundamental-open-string"),
+        result_shape_kind="fundamental-open-string",
+        exact_factor_expression="-1/2",
+        proof_digest="a" * 64,
+        provenance=(
+            ("contact-split", "s-channel"),
+            ("source", "exact-symbolica-projection-v1"),
+        ),
+    )
+
+
+def _closure_term() -> CompiledLCColorTransitionTerm:
+    return CompiledLCColorTransitionTerm(
+        input_permutation=(0, 1),
+        reverse_parent_mask=0,
+        component_operation="close",
+        result_component_kind="open-string",
+        result_component_role="none",
+        input_shape_kinds=(
+            "fundamental-open-string",
+            "antifundamental-open-string",
+        ),
+        result_shape_kind=None,
+        exact_factor_expression="1",
+        proof_digest="b" * 64,
+        provenance=(("source", "exact-symbolica-closure-v1"),),
+    )
+
+
+def _model(
+    term: CompiledLCColorTransitionTerm,
+    closure_term: CompiledLCColorTransitionTerm | None = None,
+) -> CompiledModelIR:
+    kernel = CompiledOrientedKernel(
+        kind=7,
+        term_id=3,
+        vertex="compiled-lc-color-test",
+        particles=("left", "right", "result"),
+        source_particle_legs=(0, 1, 2),
+        component_expressions=("1",),
+        coupling_expression="1",
+        coupling_orders=(),
+        runtime_parameters=(),
+        color_source="T(3,2,1)",
+        color_expression="T(3,2,1)",
+        term_ids=(3,),
+        lc_color_transition_terms=(term,),
+        lc_color_closure_terms=(() if closure_term is None else (closure_term,)),
+    )
+    return CompiledModelIR(
+        name="compiled-lc-color-transition-term-test",
+        orders=(),
+        parameters=(),
+        particles=(),
+        couplings=(),
+        propagators=(),
+        vertex_terms=(),
+        oriented_kernels=(kernel,),
+        direct_contractions=(),
+        closure_contractions=(),
+    )
+
+
+def test_compiled_lc_color_transition_term_round_trips_through_model_ir() -> None:
+    closure_term = _closure_term()
+    model = _model(_term(), closure_term)
+
+    payload = model.to_dict()
+    encoded_term = payload["oriented_kernels"][0]["lc_color_transition_terms"][0]
+    encoded_closure = payload["oriented_kernels"][0]["lc_color_closure_terms"][0]
+
+    assert encoded_term == {
+        "component_operation": "concatenate-join",
+        "exact_factor_expression": "-1/2",
+        "input_permutation": [1, 0],
+        "input_shape_kinds": ["adjoint-segment", "fundamental-open-string"],
+        "proof_digest": "a" * 64,
+        "provenance": [
+            ["contact-split", "s-channel"],
+            ["source", "exact-symbolica-projection-v1"],
+        ],
+        "result_component_kind": "open-string",
+        "result_component_role": "active",
+        "result_shape_kind": "fundamental-open-string",
+        "reverse_parent_mask": 1,
+    }
+    assert encoded_closure == closure_term.to_dict()
+    assert CompiledModelIR.from_dict(payload) == model
+
+
+def test_missing_kernel_transition_terms_preserve_compiled_ir_compatibility() -> None:
+    payload = _model(_term()).to_dict()
+    del payload["oriented_kernels"][0]["lc_color_transition_terms"]
+
+    restored = CompiledModelIR.from_dict(payload)
+
+    assert restored.oriented_kernels[0].lc_color_transition_terms == ()
+
+
+def test_missing_kernel_closure_terms_preserve_nonrecurrence_compatibility() -> None:
+    payload = _model(_term(), _closure_term()).to_dict()
+    del payload["oriented_kernels"][0]["lc_color_closure_terms"]
+
+    restored = CompiledModelIR.from_dict(payload)
+
+    assert restored.oriented_kernels[0].lc_color_transition_terms == (_term(),)
+    assert restored.oriented_kernels[0].lc_color_closure_terms == ()
+
+
+def test_compiled_lc_color_transition_term_is_frozen() -> None:
+    with pytest.raises(FrozenInstanceError):
+        _term().proof_digest = "b" * 64  # type: ignore[misc]
+
+
+def test_compiled_lc_color_transition_term_rejects_invalid_contracts() -> None:
+    term = _term()
+
+    with pytest.raises(ValueError, match="input permutation"):
+        replace(term, input_permutation=(0, 0))
+    with pytest.raises(ValueError, match="reverse-parent mask"):
+        replace(term, reverse_parent_mask=4)
+    with pytest.raises(ValueError, match="component operation"):
+        replace(term, component_operation="append")
+    with pytest.raises(ValueError, match="joins require a result kind"):
+        replace(term, result_component_kind=None)
+    with pytest.raises(ValueError, match="result component role"):
+        replace(term, result_component_role="unknown")
+    with pytest.raises(ValueError, match="supported input shape"):
+        replace(term, input_shape_kinds=("unknown", "adjoint-segment"))
+    with pytest.raises(ValueError, match="supported result shape"):
+        replace(term, result_shape_kind="unknown")
+    with pytest.raises(ValueError, match="nonempty canonical string"):
+        replace(term, exact_factor_expression=" 1")
+    with pytest.raises(ValueError, match="lowercase SHA256"):
+        replace(term, proof_digest="A" * 64)
+    with pytest.raises(ValueError, match="sorted and unique"):
+        replace(term, provenance=tuple(reversed(term.provenance)))
+    with pytest.raises(TypeError, match="immutable tuple"):
+        replace(term, provenance=[])
+
+
+def test_compiled_lc_color_transition_term_decoder_is_strict() -> None:
+    payload = _term().to_dict()
+    payload["unknown"] = "field"
+    with pytest.raises(ValueError, match="unknown fields"):
+        CompiledLCColorTransitionTerm.from_dict(payload)
+
+    payload = _term().to_dict()
+    payload["provenance"] = [["source"]]
+    with pytest.raises(ValueError, match="must contain two entries"):
+        CompiledLCColorTransitionTerm.from_dict(payload)
+
+    model_payload = _model(_term()).to_dict()
+    model_payload["oriented_kernels"][0]["lc_color_transition_terms"] = {}
+    with pytest.raises(TypeError, match="transition terms must be an array"):
+        CompiledModelIR.from_dict(model_payload)
+
+    model_payload = _model(_term(), _closure_term()).to_dict()
+    model_payload["oriented_kernels"][0]["lc_color_closure_terms"] = {}
+    with pytest.raises(TypeError, match="closure terms must be an array"):
+        CompiledModelIR.from_dict(model_payload)
+
+
+def test_oriented_kernel_keeps_transition_and_closure_catalogs_disjoint() -> None:
+    with pytest.raises(ValueError, match="transition terms cannot contain closure"):
+        replace(
+            _model(_term()).oriented_kernels[0],
+            lc_color_transition_terms=(_closure_term(),),
+        )
+    with pytest.raises(ValueError, match="must contain only closure operations"):
+        replace(
+            _model(_term()).oriented_kernels[0],
+            lc_color_closure_terms=(_term(),),
+        )
diff --git a/pyamplicol/tests/unit/test_compiled_microkernel_acceptance.py b/pyamplicol/tests/unit/test_compiled_microkernel_acceptance.py
new file mode 100644
index 0000000000..ec076fe4df
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiled_microkernel_acceptance.py
@@ -0,0 +1,1180 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+import json
+import tomllib
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+from tools.developer import compiled_microkernel_acceptance as acceptance
+
+
+def test_dependency_identity_is_read_from_the_release_lock() -> None:
+    root = Path(__file__).resolve().parents[2]
+    with (root / "dependencies" / "release-lock.toml").open("rb") as stream:
+        symjit = tomllib.load(stream)["symjit"]
+
+    assert acceptance.DEPENDENCY_SOURCE == "registry+https://github.com/rust-lang/crates.io-index"
+    assert symjit["version"] == acceptance.DEPENDENCY_VERSION
+
+
+def _digest(character: str) -> str:
+    return character * 64
+
+
+def _certificate(kind: str, rows: list[dict[str, object]]) -> dict[str, object]:
+    payload: dict[str, object] = {"kind": kind, "rows": rows}
+    return {**payload, "sha256": acceptance.canonical_sha256(payload)}
+
+
+def _diagnostics(
+    *,
+    islands: int = 1,
+    kernels: int = 1,
+    invocations: int = 2,
+    attachments: int = 2,
+    table_code: int = 100,
+    residual_code: int = 50,
+    semantic_bytes: int = 32,
+    arena_bytes: int = 64,
+    allocations: int = 0,
+) -> dict[str, int]:
+    return {
+        "island_count": islands,
+        "kernel_count": kernels,
+        "invocation_count": invocations,
+        "attachment_count": attachments,
+        "table_machine_code_bytes": table_code,
+        "residual_machine_code_bytes": residual_code,
+        "semantic_row_bytes": semantic_bytes,
+        "arena_bytes": arena_bytes,
+        "warmed_allocation_count": allocations,
+    }
+
+
+def _stage_plan() -> dict[str, object]:
+    return {
+        "kind": acceptance.STAGE_PLAN_KIND,
+        "schema_version": acceptance.STAGE_PLAN_SCHEMA_VERSION,
+        "stage_id": "stage-0",
+        "direct_application_abi": acceptance.DIRECT_APPLICATION_ABI,
+        "direct_table_binding_abi": acceptance.DIRECT_TABLE_BINDING_ABI,
+        "direct_table_descriptor_abi": acceptance.DIRECT_TABLE_DESCRIPTOR_ABI,
+        "output_current_ids": [10, 11],
+        "table_current_ids": [10],
+        "residual_current_ids": [11],
+        "residual_leaves": [
+            {
+                "leaf_id": 0,
+                "current_ids": [11],
+                "source_sha256": _digest("1"),
+                "source_abi": acceptance.DIRECT_APPLICATION_ABI,
+                "source_bytes": 120,
+                "machine_code_bytes": 50,
+                "optimization_level": 3,
+            }
+        ],
+        "kernels": [
+            {
+                "kernel_id": 0,
+                "kernel_family": acceptance.VECTOR_WEYL_KERNEL_FAMILY,
+                "motif_sha256": _digest("2"),
+                "source_sha256": _digest("3"),
+                "descriptor_sha256": _digest("4"),
+                "source_abi": acceptance.DIRECT_APPLICATION_ABI,
+                "binding_abi": acceptance.DIRECT_TABLE_BINDING_ABI,
+                "descriptor_abi": acceptance.DIRECT_TABLE_DESCRIPTOR_ABI,
+                "canonical_input_order": ["left-current", "momentum"],
+                "input_permutation": [0, 1],
+                "result_signature": "vector-weyl:2",
+                "mutable_parameter_sha256": _digest("5"),
+                "coupling_provenance_sha256": _digest("6"),
+                "selector_domain_sha256": _digest("7"),
+                "finalizer_sha256": _digest("8"),
+                "input_complex_count": 2,
+                "output_complex_count": 2,
+                "source_bytes": 4096,
+                "machine_code_bytes": 100,
+                "optimization_level": 3,
+            }
+        ],
+        "islands": [
+            {
+                "island_id": 0,
+                "kernel_id": 0,
+                "current_ids": [10],
+                "selector_partition_sha256": _digest("9"),
+                "invocations": [
+                    {
+                        "invocation_id": 0,
+                        "evaluation_group_id": 7,
+                        "attachment_start": 0,
+                        "attachment_count": 1,
+                    },
+                    {
+                        "invocation_id": 1,
+                        "evaluation_group_id": 8,
+                        "attachment_start": 1,
+                        "attachment_count": 1,
+                    },
+                ],
+                "attachments": [
+                    {
+                        "attachment_id": 0,
+                        "invocation_id": 0,
+                        "current_id": 10,
+                        "evaluation_group_id": 7,
+                        "operation": "overwrite",
+                        "destination_complex_count": 2,
+                        "factor_id": 0,
+                    },
+                    {
+                        "attachment_id": 1,
+                        "invocation_id": 1,
+                        "current_id": 10,
+                        "evaluation_group_id": 8,
+                        "operation": "accumulate",
+                        "destination_complex_count": 2,
+                        "factor_id": 0,
+                    },
+                ],
+                "factor_catalog": [{"factor_id": 0, "factor_sha256": _digest("a")}],
+                "plane_bindings": [
+                    {
+                        "plane_id": index,
+                        "role": role,
+                        "canonical_index": index,
+                        "permutation_index": index,
+                    }
+                    for index, role in enumerate(
+                        ("current", "momentum", "parameter", "factor")
+                    )
+                ],
+                "dependency_certificate": _certificate(
+                    "complete-current-independence-v1",
+                    [{"current_id": 10, "predecessor_current_ids": [1, 2]}],
+                ),
+                "order_certificate": _certificate(
+                    "evaluation-group-order-v1",
+                    [{"current_id": 10, "evaluation_group_ids": [7, 8]}],
+                ),
+                "semantic_row_bytes": 32,
+                "arena_bytes": 64,
+            }
+        ],
+        "finalizers": [
+            {
+                "current_id": 10,
+                "island_id": 0,
+                "identity_sha256": _digest("8"),
+            }
+        ],
+        "diagnostics": _diagnostics(),
+    }
+
+
+def _residual_only_stage() -> dict[str, object]:
+    stage = _stage_plan()
+    stage["table_current_ids"] = []
+    stage["residual_current_ids"] = [10, 11]
+    stage["residual_leaves"] = [
+        {
+            "leaf_id": 0,
+            "current_ids": [10, 11],
+            "source_sha256": _digest("1"),
+            "source_abi": acceptance.DIRECT_APPLICATION_ABI,
+            "source_bytes": 240,
+            "machine_code_bytes": 75,
+            "optimization_level": 3,
+        }
+    ]
+    stage["kernels"] = []
+    stage["islands"] = []
+    stage["finalizers"] = []
+    stage["diagnostics"] = _diagnostics(
+        islands=0,
+        kernels=0,
+        invocations=0,
+        attachments=0,
+        table_code=0,
+        residual_code=75,
+        semantic_bytes=0,
+        arena_bytes=0,
+    )
+    return stage
+
+
+def _table_only_stage() -> dict[str, object]:
+    stage = _stage_plan()
+    stage["output_current_ids"] = [10]
+    stage["residual_current_ids"] = []
+    stage["residual_leaves"] = []
+    diagnostics = stage["diagnostics"]
+    assert isinstance(diagnostics, dict)
+    diagnostics["residual_machine_code_bytes"] = 0
+    return stage
+
+
+def _authorized_extended_stage_plan() -> dict[str, object]:
+    vector_current_ids = list(range(26))
+    three_vector_current_ids = list(range(26, 31))
+    residual_current_ids = list(range(31, 55))
+    contribution_counts = [width for width in range(1, 7) for _ in range(4)]
+    contribution_counts.extend((7, 7))
+    assert len(contribution_counts) == 26
+    assert sum(contribution_counts) == 98
+
+    vector_invocations: list[dict[str, object]] = []
+    vector_attachments: list[dict[str, object]] = []
+    vector_order_rows: list[dict[str, object]] = []
+    group_id = 0
+    for current_id, contribution_count in zip(
+        vector_current_ids,
+        contribution_counts,
+        strict=True,
+    ):
+        current_groups: list[int] = []
+        for contribution_index in range(contribution_count):
+            invocation_id = len(vector_invocations)
+            vector_invocations.append(
+                {
+                    "invocation_id": invocation_id,
+                    "evaluation_group_id": group_id,
+                    "attachment_start": invocation_id,
+                    "attachment_count": 1,
+                }
+            )
+            vector_attachments.append(
+                {
+                    "attachment_id": invocation_id,
+                    "invocation_id": invocation_id,
+                    "current_id": current_id,
+                    "evaluation_group_id": group_id,
+                    "operation": (
+                        "overwrite" if contribution_index == 0 else "accumulate"
+                    ),
+                    "destination_complex_count": 2,
+                    "factor_id": 0,
+                }
+            )
+            current_groups.append(group_id)
+            group_id += 1
+        vector_order_rows.append(
+            {
+                "current_id": current_id,
+                "evaluation_group_ids": current_groups,
+            }
+        )
+    assert group_id == 98
+
+    three_vector_invocations = [
+        {
+            "invocation_id": index,
+            "evaluation_group_id": 98 + index,
+            "attachment_start": index,
+            "attachment_count": 1,
+        }
+        for index in range(5)
+    ]
+    three_vector_attachments = [
+        {
+            "attachment_id": index,
+            "invocation_id": index,
+            "current_id": current_id,
+            "evaluation_group_id": 98 + index,
+            "operation": "overwrite",
+            "destination_complex_count": 4,
+            "factor_id": 0,
+        }
+        for index, current_id in enumerate(three_vector_current_ids)
+    ]
+
+    def bindings() -> list[dict[str, object]]:
+        return [
+            {
+                "plane_id": index,
+                "role": role,
+                "canonical_index": index,
+                "permutation_index": index,
+            }
+            for index, role in enumerate(("current", "momentum", "parameter", "factor"))
+        ]
+
+    vector_finalizer = _digest("8")
+    three_vector_finalizer = _digest("d")
+    return {
+        "kind": acceptance.STAGE_PLAN_KIND,
+        "schema_version": acceptance.STAGE_PLAN_SCHEMA_VERSION,
+        "stage_id": "stage-0",
+        "direct_application_abi": acceptance.DIRECT_APPLICATION_ABI,
+        "direct_table_binding_abi": acceptance.DIRECT_TABLE_BINDING_ABI,
+        "direct_table_descriptor_abi": acceptance.DIRECT_TABLE_DESCRIPTOR_ABI,
+        "output_current_ids": list(range(55)),
+        "table_current_ids": vector_current_ids + three_vector_current_ids,
+        "residual_current_ids": residual_current_ids,
+        "residual_leaves": [
+            {
+                "leaf_id": 0,
+                "current_ids": residual_current_ids,
+                "source_sha256": _digest("1"),
+                "source_abi": acceptance.DIRECT_APPLICATION_ABI,
+                "source_bytes": 120,
+                "machine_code_bytes": 50,
+                "optimization_level": 3,
+            }
+        ],
+        "kernels": [
+            {
+                "kernel_id": 0,
+                "kernel_family": acceptance.VECTOR_WEYL_KERNEL_FAMILY,
+                "motif_sha256": _digest("2"),
+                "source_sha256": _digest("3"),
+                "descriptor_sha256": _digest("4"),
+                "source_abi": acceptance.DIRECT_APPLICATION_ABI,
+                "binding_abi": acceptance.DIRECT_TABLE_BINDING_ABI,
+                "descriptor_abi": acceptance.DIRECT_TABLE_DESCRIPTOR_ABI,
+                "canonical_input_order": [f"input-{index}" for index in range(6)],
+                "input_permutation": list(range(6)),
+                "result_signature": "vector-weyl:2",
+                "mutable_parameter_sha256": _digest("5"),
+                "coupling_provenance_sha256": _digest("6"),
+                "selector_domain_sha256": _digest("7"),
+                "finalizer_sha256": vector_finalizer,
+                "input_complex_count": 6,
+                "output_complex_count": 2,
+                "source_bytes": 4096,
+                "machine_code_bytes": 100,
+                "optimization_level": 3,
+            },
+            {
+                "kernel_id": 1,
+                "kernel_family": (acceptance.THREE_VECTOR_SINGLETON_KERNEL_FAMILY),
+                "motif_sha256": _digest("9"),
+                "source_sha256": _digest("a"),
+                "descriptor_sha256": _digest("b"),
+                "source_abi": acceptance.DIRECT_APPLICATION_ABI,
+                "binding_abi": acceptance.DIRECT_TABLE_BINDING_ABI,
+                "descriptor_abi": acceptance.DIRECT_TABLE_DESCRIPTOR_ABI,
+                "canonical_input_order": [f"input-{index}" for index in range(16)],
+                "input_permutation": list(range(16)),
+                "result_signature": "three-vector:4",
+                "mutable_parameter_sha256": _digest("c"),
+                "coupling_provenance_sha256": _digest("d"),
+                "selector_domain_sha256": _digest("e"),
+                "finalizer_sha256": three_vector_finalizer,
+                "input_complex_count": 16,
+                "output_complex_count": 4,
+                "source_bytes": 8192,
+                "machine_code_bytes": 120,
+                "optimization_level": 3,
+            },
+        ],
+        "islands": [
+            {
+                "island_id": 0,
+                "kernel_id": 0,
+                "current_ids": vector_current_ids,
+                "selector_partition_sha256": _digest("9"),
+                "invocations": vector_invocations,
+                "attachments": vector_attachments,
+                "factor_catalog": [{"factor_id": 0, "factor_sha256": _digest("a")}],
+                "plane_bindings": bindings(),
+                "dependency_certificate": _certificate(
+                    "complete-current-independence-v1",
+                    [
+                        {
+                            "current_id": current_id,
+                            "predecessor_current_ids": [100 + current_id],
+                        }
+                        for current_id in vector_current_ids
+                    ],
+                ),
+                "order_certificate": _certificate(
+                    "evaluation-group-order-v1",
+                    vector_order_rows,
+                ),
+                "semantic_row_bytes": 3136,
+                "arena_bytes": 1664,
+            },
+            {
+                "island_id": 1,
+                "kernel_id": 1,
+                "current_ids": three_vector_current_ids,
+                "selector_partition_sha256": _digest("e"),
+                "invocations": three_vector_invocations,
+                "attachments": three_vector_attachments,
+                "factor_catalog": [{"factor_id": 0, "factor_sha256": _digest("f")}],
+                "plane_bindings": bindings(),
+                "dependency_certificate": _certificate(
+                    "complete-current-independence-v1",
+                    [
+                        {
+                            "current_id": current_id,
+                            "predecessor_current_ids": [200 + current_id],
+                        }
+                        for current_id in three_vector_current_ids
+                    ],
+                ),
+                "order_certificate": _certificate(
+                    "evaluation-group-order-v1",
+                    [
+                        {
+                            "current_id": current_id,
+                            "evaluation_group_ids": [98 + index],
+                        }
+                        for index, current_id in enumerate(three_vector_current_ids)
+                    ],
+                ),
+                "semantic_row_bytes": 160,
+                "arena_bytes": 320,
+            },
+        ],
+        "finalizers": [
+            {
+                "current_id": current_id,
+                "island_id": 0 if current_id in vector_current_ids else 1,
+                "identity_sha256": (
+                    vector_finalizer
+                    if current_id in vector_current_ids
+                    else three_vector_finalizer
+                ),
+            }
+            for current_id in vector_current_ids + three_vector_current_ids
+        ],
+        "diagnostics": _diagnostics(
+            islands=2,
+            kernels=2,
+            invocations=103,
+            attachments=103,
+            table_code=220,
+            residual_code=50,
+            semantic_bytes=3296,
+            arena_bytes=1984,
+        ),
+    }
+
+
+def _active_prepared_kernel_occurrences() -> list[dict[str, object]]:
+    prepared_kernel_ids = (
+        [7] * 49 + [24] * 49 + [4] * 5 + [4] * 30 + [36] * 40 + [41] * 30
+    )
+    assert len(prepared_kernel_ids) == acceptance.TARGET_MATERIALIZED_INTERACTIONS
+    return [
+        {
+            "occurrence_id": f"stage-0:{index}",
+            "prepared_kernel_id": prepared_kernel_id,
+        }
+        for index, prepared_kernel_id in enumerate(prepared_kernel_ids)
+    ]
+
+
+def _complex_values(batch: int, value: float = 1.0) -> list[list[float]]:
+    return [[value, 0.0] for _ in range(batch)]
+
+
+def _resolved_values(batch: int, value: float = 1.0) -> list[list[list[float]]]:
+    return [[[value, 0.0]] for _ in range(batch)]
+
+
+def _correctness(batch: int) -> dict[str, object]:
+    return {
+        lane: {
+            "evaluate": _complex_values(batch),
+            "resolved_total": _complex_values(batch),
+            "resolved_contributions": _resolved_values(batch),
+        }
+        for lane in ("baseline", "candidate")
+    }
+
+
+def _measurements(
+    *,
+    candidate_ratio: float,
+    allocations: int = 0,
+) -> list[dict[str, object]]:
+    rows: list[dict[str, object]] = []
+    for pair_index in range(acceptance.MIN_SAMPLE_PAIRS):
+        order = (
+            ("baseline", "candidate")
+            if pair_index % 2 == 0
+            else ("candidate", "baseline")
+        )
+        baseline = 1.0 + 0.001 * (pair_index % 3)
+        for lane in order:
+            rows.append(
+                {
+                    "pair_index": pair_index,
+                    "sequence_index": len(rows),
+                    "lane": lane,
+                    "duration_seconds": 5.25,
+                    "seconds_per_point": (
+                        baseline if lane == "baseline" else baseline * candidate_ratio
+                    ),
+                    "warmed_allocation_count": (
+                        allocations if lane == "candidate" else 0
+                    ),
+                }
+            )
+    return rows
+
+
+def _artifact_metrics(
+    *,
+    generation_seconds: float,
+    artifact_bytes: int,
+    load_seconds: float,
+    peak_rss_bytes: int,
+    machine_code_bytes: int,
+    digest_character: str,
+    code_size_metric_available: bool = True,
+) -> dict[str, object]:
+    return {
+        "artifact_sha256": _digest(digest_character),
+        "build_identity_sha256": _digest(digest_character),
+        "generation_seconds": generation_seconds,
+        "artifact_bytes": artifact_bytes,
+        "load_seconds": load_seconds,
+        "peak_rss_bytes": peak_rss_bytes,
+        "code_size_metric_available": code_size_metric_available,
+        "code_size_metric_kind": (
+            acceptance.EXACT_CODE_SIZE_METRIC if code_size_metric_available else None
+        ),
+        "selected_machine_code_bytes": (
+            machine_code_bytes if code_size_metric_available else None
+        ),
+        "portable_source_applications": [
+            {
+                "source_application_sha256": _digest(digest_character),
+                "source_application_bytes": 4096,
+                "source_application_abi": acceptance.SOURCE_APPLICATION_ABI,
+            }
+        ],
+    }
+
+
+def _campaign() -> dict[str, object]:
+    point_digest = _digest("b")
+    stage = _authorized_extended_stage_plan()
+    stage_diagnostics = copy.deepcopy(stage["diagnostics"])
+    campaign: dict[str, object] = {
+        "kind": acceptance.CAMPAIGN_KIND,
+        "schema_version": acceptance.CAMPAIGN_SCHEMA_VERSION,
+        "dependency": {
+            "source": acceptance.DEPENDENCY_SOURCE,
+            "version": acceptance.DEPENDENCY_VERSION,
+            "local_patch_count": 0,
+            "direct_application_abi": acceptance.DIRECT_APPLICATION_ABI,
+            "direct_table_binding_abi": acceptance.DIRECT_TABLE_BINDING_ABI,
+            "direct_table_descriptor_abi": acceptance.DIRECT_TABLE_DESCRIPTOR_ABI,
+        },
+        "workload": {
+            "process": acceptance.TARGET_PROCESS,
+            "color_accuracy": acceptance.TARGET_COLOR_ACCURACY,
+            "lc_flow_layout": acceptance.TARGET_LAYOUT,
+            "selected_flow": acceptance.TARGET_FLOW,
+            "helicity_mode": acceptance.TARGET_HELICITY_MODE,
+            "source_sha256": _digest("c"),
+            "model_sha256": _digest("d"),
+            "point_set_sha256": point_digest,
+            "runtime_target_sha256": _digest("e"),
+            "host_sha256": _digest("f"),
+        },
+        "baseline": _artifact_metrics(
+            generation_seconds=100.0,
+            artifact_bytes=1000,
+            load_seconds=10.0,
+            peak_rss_bytes=10_000,
+            machine_code_bytes=1000,
+            digest_character="1",
+        ),
+        "candidate": {
+            "metrics": _artifact_metrics(
+                generation_seconds=105.0,
+                artifact_bytes=1050,
+                load_seconds=10.5,
+                peak_rss_bytes=10_500,
+                machine_code_bytes=700,
+                digest_character="2",
+            ),
+            "stage_plans": [stage],
+            "diagnostics": stage_diagnostics,
+            "census": {
+                "denominator_contract": acceptance.CENSUS_DENOMINATOR_CONTRACT,
+                "active_non_source_current_slots": (
+                    acceptance.TARGET_ACTIVE_NON_SOURCE_CURRENT_SLOTS
+                ),
+                "materialized_interaction_count": (
+                    acceptance.TARGET_MATERIALIZED_INTERACTIONS
+                ),
+                "two_component_current_slots": (
+                    acceptance.TARGET_TWO_COMPONENT_CURRENT_SLOTS
+                ),
+                "four_component_three_vector_singleton_slots": (
+                    acceptance.TARGET_THREE_VECTOR_SINGLETON_CURRENT_SLOTS
+                ),
+                "active_prepared_kernel_occurrences": (
+                    _active_prepared_kernel_occurrences()
+                ),
+                "eligible_prepared_kernel_occurrence_ids": [
+                    f"stage-0:{index}"
+                    for index in range(
+                        acceptance.TARGET_ELIGIBLE_PREPARED_KERNEL_OCCURRENCES
+                    )
+                ],
+                "proof_dag_non_source_current_slots": (
+                    acceptance.TARGET_PROOF_DAG_NON_SOURCE_CURRENT_SLOTS
+                ),
+                "proof_dag_interaction_count": (
+                    acceptance.TARGET_PROOF_DAG_INTERACTIONS
+                ),
+                "projected_generated_text_bytes": 12_000,
+                "projected_replaced_text_bytes": 100_000,
+            },
+        },
+        "batches": {
+            str(batch): {
+                "point_set_sha256": point_digest,
+                "correctness": _correctness(batch),
+                "measurements": _measurements(
+                    candidate_ratio=(
+                        0.85
+                        if batch in acceptance.PRIMARY_BATCHES
+                        else 1.04
+                        if batch == 1
+                        else 0.95
+                    )
+                ),
+            }
+            for batch in acceptance.REQUIRED_BATCHES
+        },
+        "regression_cases": [
+            {
+                "name": name,
+                "passed": True,
+                "evidence_sha256": _digest("a"),
+            }
+            for name in sorted(acceptance.REQUIRED_REGRESSION_CASES)
+        ],
+        "non_target_performance": [
+            {
+                "name": name,
+                "baseline_seconds_per_point": [1.0] * 7,
+                "candidate_seconds_per_point": [1.01] * 7,
+            }
+            for name in sorted(acceptance.REQUIRED_NON_TARGET_PERFORMANCE)
+        ],
+    }
+    return _seal(campaign)
+
+
+def _seal(campaign: dict[str, object]) -> dict[str, object]:
+    campaign.pop("content_sha256", None)
+    campaign["content_sha256"] = acceptance.canonical_sha256(campaign)
+    return campaign
+
+
+def _candidate(campaign: dict[str, object]) -> dict[str, object]:
+    value = campaign["candidate"]
+    assert isinstance(value, dict)
+    return value
+
+
+def _batches(campaign: dict[str, object]) -> dict[str, object]:
+    value = campaign["batches"]
+    assert isinstance(value, dict)
+    return value
+
+
+def test_valid_campaign_recomputes_every_landing_gate() -> None:
+    result = acceptance.audit_campaign(_campaign())
+
+    assert result["passes"] is True
+    assert set(result["batches"]) == {
+        str(batch) for batch in acceptance.REQUIRED_BATCHES
+    }
+    gates = result["gates"]
+    assert isinstance(gates, dict)
+    assert gates["primary_gain:batch_128"]["passes"] is True
+    assert gates["primary_gain:batch_1024"]["passes"] is True
+    assert gates["selected_machine_code_reduction"]["passes"] is True
+    assert gates["zero_warmed_allocations"]["passes"] is True
+
+
+def test_residual_only_and_table_only_v2_stages_are_valid() -> None:
+    residual = acceptance.audit_stage_plan_v2(_residual_only_stage())
+    table = acceptance.audit_stage_plan_v2(_table_only_stage())
+
+    assert residual["residual_only"] is True
+    assert residual["table_only"] is False
+    assert table["residual_only"] is False
+    assert table["table_only"] is True
+
+
+@pytest.mark.parametrize(
+    "field,value",
+    [
+        ("schema_version", 1),
+        ("direct_application_abi", "symjit-direct-application-storage-v0"),
+        ("direct_table_binding_abi", "symjit-direct-table-binding-v0"),
+        ("direct_table_descriptor_abi", "symjit-direct-table-descriptor-v0"),
+    ],
+)
+def test_v1_and_incompatible_abis_fail_closed(field: str, value: object) -> None:
+    stage = _stage_plan()
+    stage[field] = value
+
+    with pytest.raises(acceptance.AcceptanceError, match="regenerate"):
+        acceptance.audit_stage_plan_v2(stage)
+
+
+def test_unknown_fields_and_split_destinations_fail_closed() -> None:
+    stage = _stage_plan()
+    stage["silent_fallback"] = True
+    with pytest.raises(acceptance.AcceptanceError, match="field mismatch"):
+        acceptance.audit_stage_plan_v2(stage)
+
+    stage = _stage_plan()
+    stage["residual_current_ids"] = [10, 11]
+    with pytest.raises(acceptance.AcceptanceError, match="may not be split"):
+        acceptance.audit_stage_plan_v2(stage)
+
+
+def test_order_certificate_is_authenticated_and_matches_attachments() -> None:
+    stage = _stage_plan()
+    island = stage["islands"][0]  # type: ignore[index]
+    assert isinstance(island, dict)
+    island["order_certificate"] = _certificate(
+        "evaluation-group-order-v1",
+        [{"current_id": 10, "evaluation_group_ids": [8, 7]}],
+    )
+
+    with pytest.raises(acceptance.AcceptanceError, match="attachment order differs"):
+        acceptance.audit_stage_plan_v2(stage)
+
+    stage = _stage_plan()
+    island = stage["islands"][0]  # type: ignore[index]
+    assert isinstance(island, dict)
+    certificate = island["order_certificate"]
+    assert isinstance(certificate, dict)
+    certificate["sha256"] = _digest("0")
+    with pytest.raises(acceptance.AcceptanceError, match="SHA-256 mismatch"):
+        acceptance.audit_stage_plan_v2(stage)
+
+
+def test_noncontiguous_ranges_and_partial_destination_writes_fail_closed() -> None:
+    stage = _stage_plan()
+    island = stage["islands"][0]  # type: ignore[index]
+    assert isinstance(island, dict)
+    invocation = island["invocations"][1]  # type: ignore[index]
+    assert isinstance(invocation, dict)
+    invocation["attachment_start"] = 0
+    with pytest.raises(acceptance.AcceptanceError, match="outside its invocation"):
+        acceptance.audit_stage_plan_v2(stage)
+
+    stage = _stage_plan()
+    island = stage["islands"][0]  # type: ignore[index]
+    assert isinstance(island, dict)
+    attachment = island["attachments"][0]  # type: ignore[index]
+    assert isinstance(attachment, dict)
+    attachment["destination_complex_count"] = 1
+    with pytest.raises(acceptance.AcceptanceError, match="complete"):
+        acceptance.audit_stage_plan_v2(stage)
+
+
+def test_dependency_certificate_rejects_grouped_dependent_currents() -> None:
+    stage = _stage_plan()
+    stage["output_current_ids"] = [10, 11, 12]
+    stage["table_current_ids"] = [10, 12]
+    island = stage["islands"][0]  # type: ignore[index]
+    assert isinstance(island, dict)
+    island["current_ids"] = [10, 12]
+    island["invocations"] = [
+        {
+            "invocation_id": 0,
+            "evaluation_group_id": 7,
+            "attachment_start": 0,
+            "attachment_count": 2,
+        },
+        {
+            "invocation_id": 1,
+            "evaluation_group_id": 8,
+            "attachment_start": 2,
+            "attachment_count": 2,
+        },
+    ]
+    island["attachments"] = [
+        {
+            "attachment_id": index,
+            "invocation_id": index // 2,
+            "current_id": 10 if index % 2 == 0 else 12,
+            "evaluation_group_id": 7 if index < 2 else 8,
+            "operation": "overwrite" if index < 2 else "accumulate",
+            "destination_complex_count": 2,
+            "factor_id": 0,
+        }
+        for index in range(4)
+    ]
+    island["dependency_certificate"] = _certificate(
+        "complete-current-independence-v1",
+        [
+            {"current_id": 10, "predecessor_current_ids": [12]},
+            {"current_id": 12, "predecessor_current_ids": []},
+        ],
+    )
+    island["order_certificate"] = _certificate(
+        "evaluation-group-order-v1",
+        [
+            {"current_id": 10, "evaluation_group_ids": [7, 8]},
+            {"current_id": 12, "evaluation_group_ids": [7, 8]},
+        ],
+    )
+    stage["finalizers"] = [
+        {
+            "current_id": current_id,
+            "island_id": 0,
+            "identity_sha256": _digest("8"),
+        }
+        for current_id in (10, 12)
+    ]
+    diagnostics = stage["diagnostics"]
+    assert isinstance(diagnostics, dict)
+    diagnostics["attachment_count"] = 4
+
+    with pytest.raises(acceptance.AcceptanceError, match="dependent destinations"):
+        acceptance.audit_stage_plan_v2(stage)
+
+
+def test_declared_diagnostics_and_hard_bounds_are_recomputed() -> None:
+    stage = _stage_plan()
+    diagnostics = stage["diagnostics"]
+    assert isinstance(diagnostics, dict)
+    diagnostics["attachment_count"] = 3
+    with pytest.raises(acceptance.AcceptanceError, match="recomputed"):
+        acceptance.audit_stage_plan_v2(stage)
+
+    stage = _stage_plan()
+    kernel = stage["kernels"][0]  # type: ignore[index]
+    assert isinstance(kernel, dict)
+    kernel["source_bytes"] = acceptance.MAX_KERNEL_SOURCE_BYTES + 1
+    with pytest.raises(acceptance.AcceptanceError, match="64 KiB"):
+        acceptance.audit_stage_plan_v2(stage)
+
+
+def test_census_rejects_proof_dag_substitution_and_incomplete_occurrences() -> None:
+    campaign = _campaign()
+    census = _candidate(campaign)["census"]
+    assert isinstance(census, dict)
+    census["active_non_source_current_slots"] = (
+        acceptance.TARGET_PROOF_DAG_NON_SOURCE_CURRENT_SLOTS
+    )
+    _seal(campaign)
+    with pytest.raises(acceptance.AcceptanceError, match="frozen target census"):
+        acceptance.audit_campaign(campaign)
+
+    campaign = _campaign()
+    census = _candidate(campaign)["census"]
+    assert isinstance(census, dict)
+    active = census["active_prepared_kernel_occurrences"]
+    assert isinstance(active, list)
+    active.pop()
+    _seal(campaign)
+    with pytest.raises(acceptance.AcceptanceError, match="enumerate all 203"):
+        acceptance.audit_campaign(campaign)
+
+    campaign = _campaign()
+    census = _candidate(campaign)["census"]
+    assert isinstance(census, dict)
+    eligible = census["eligible_prepared_kernel_occurrence_ids"]
+    assert isinstance(eligible, list)
+    eligible.pop()
+    _seal(campaign)
+    with pytest.raises(acceptance.AcceptanceError, match="exactly match"):
+        acceptance.audit_campaign(campaign)
+
+
+def test_authorized_kernel_families_enforce_family_specific_output_caps() -> None:
+    summary = acceptance.audit_stage_plan_v2(_authorized_extended_stage_plan())
+    counts = summary["table_destination_family_counts"]
+    assert counts == {
+        acceptance.VECTOR_WEYL_KERNEL_FAMILY: 26,
+        acceptance.THREE_VECTOR_SINGLETON_KERNEL_FAMILY: 5,
+    }
+
+    stage = _stage_plan()
+    kernel = stage["kernels"][0]  # type: ignore[index]
+    assert isinstance(kernel, dict)
+    kernel["output_complex_count"] = 4
+    kernel["result_signature"] = "three-vector:4"
+    with pytest.raises(acceptance.AcceptanceError, match="vector-weyl"):
+        acceptance.audit_stage_plan_v2(stage)
+
+    stage = _authorized_extended_stage_plan()
+    kernel = stage["kernels"][1]  # type: ignore[index]
+    assert isinstance(kernel, dict)
+    kernel["input_complex_count"] = 15
+    kernel["canonical_input_order"] = [f"input-{index}" for index in range(15)]
+    kernel["input_permutation"] = list(range(15))
+    with pytest.raises(acceptance.AcceptanceError, match="exactly 16 inputs"):
+        acceptance.audit_stage_plan_v2(stage)
+
+
+def test_three_vector_family_rejects_non_singleton_currents() -> None:
+    stage = _authorized_extended_stage_plan()
+    island = stage["islands"][1]  # type: ignore[index]
+    assert isinstance(island, dict)
+    attachments = island["attachments"]
+    invocations = island["invocations"]
+    assert isinstance(attachments, list)
+    assert isinstance(invocations, list)
+    invocations.append(
+        {
+            "invocation_id": 5,
+            "evaluation_group_id": 103,
+            "attachment_start": 5,
+            "attachment_count": 1,
+        }
+    )
+    attachments.append(
+        {
+            "attachment_id": 5,
+            "invocation_id": 5,
+            "current_id": 26,
+            "evaluation_group_id": 103,
+            "operation": "accumulate",
+            "destination_complex_count": 4,
+            "factor_id": 0,
+        }
+    )
+    island["order_certificate"] = _certificate(
+        "evaluation-group-order-v1",
+        [
+            {
+                "current_id": current_id,
+                "evaluation_group_ids": (
+                    [98, 103] if current_id == 26 else [98 + index]
+                ),
+            }
+            for index, current_id in enumerate(range(26, 31))
+        ],
+    )
+    with pytest.raises(acceptance.AcceptanceError, match="singleton"):
+        acceptance.audit_stage_plan_v2(stage)
+
+
+def test_odd_tail_batch_or_numerical_mismatch_is_not_accepted() -> None:
+    campaign = _campaign()
+    _batches(campaign).pop("129")
+    _seal(campaign)
+    with pytest.raises(acceptance.AcceptanceError, match="exactly batches"):
+        acceptance.audit_campaign(campaign)
+
+    campaign = _campaign()
+    batch = _batches(campaign)["127"]
+    assert isinstance(batch, dict)
+    correctness = batch["correctness"]
+    assert isinstance(correctness, dict)
+    candidate = correctness["candidate"]
+    assert isinstance(candidate, dict)
+    for field in ("evaluate", "resolved_total", "resolved_contributions"):
+        values = candidate[field]
+        assert isinstance(values, list)
+        if field == "resolved_contributions":
+            values[0][0][0] += 1.0e-6
+        else:
+            values[0][0] += 1.0e-6
+    _seal(campaign)
+    with pytest.raises(acceptance.AcceptanceError, match="candidate_vs_baseline"):
+        acceptance.audit_campaign(campaign)
+
+
+def test_resolved_contributions_must_sum_to_the_declared_total() -> None:
+    campaign = _campaign()
+    batch = _batches(campaign)["1"]
+    assert isinstance(batch, dict)
+    correctness = batch["correctness"]
+    assert isinstance(correctness, dict)
+    candidate = correctness["candidate"]
+    assert isinstance(candidate, dict)
+    resolved = candidate["resolved_contributions"]
+    assert isinstance(resolved, list)
+    resolved[0][0][0] += 1.0e-6
+    _seal(campaign)
+
+    with pytest.raises(
+        acceptance.AcceptanceError,
+        match="resolved_contributions_vs_total",
+    ):
+        acceptance.audit_campaign(campaign)
+
+
+def test_alternating_samples_may_start_with_either_lane() -> None:
+    campaign = _campaign()
+    for batch in _batches(campaign).values():
+        assert isinstance(batch, dict)
+        rows = batch["measurements"]
+        assert isinstance(rows, list)
+        for pair_index in range(acceptance.MIN_SAMPLE_PAIRS):
+            start = 2 * pair_index
+            rows[start], rows[start + 1] = rows[start + 1], rows[start]
+            rows[start]["sequence_index"] = start
+            rows[start + 1]["sequence_index"] = start + 1
+    _seal(campaign)
+
+    assert acceptance.audit_campaign(campaign)["passes"] is True
+
+
+def _set_candidate_ratio(
+    campaign: dict[str, object],
+    batch: int,
+    ratio: float,
+) -> None:
+    batch_value = _batches(campaign)[str(batch)]
+    assert isinstance(batch_value, dict)
+    rows = batch_value["measurements"]
+    assert isinstance(rows, list)
+    for row in rows:
+        assert isinstance(row, dict)
+        if row["lane"] == "candidate":
+            pair_index = int(row["pair_index"])
+            row["seconds_per_point"] = (1.0 + 0.001 * (pair_index % 3)) * ratio
+
+
+def _miss_primary_gain(campaign: dict[str, object]) -> str:
+    _set_candidate_ratio(campaign, 128, 0.95)
+    return "primary_gain:batch_128"
+
+
+def _regress_batch_one(campaign: dict[str, object]) -> str:
+    _set_candidate_ratio(campaign, 1, 1.06)
+    return "batch_1_regression"
+
+
+def _miss_code_size(campaign: dict[str, object]) -> str:
+    metrics = _candidate(campaign)["metrics"]
+    assert isinstance(metrics, dict)
+    metrics["selected_machine_code_bytes"] = 800
+    return "selected_machine_code_reduction"
+
+
+def _regress_generation(campaign: dict[str, object]) -> str:
+    metrics = _candidate(campaign)["metrics"]
+    assert isinstance(metrics, dict)
+    metrics["generation_seconds"] = 111.0
+    return "resource:generation_seconds"
+
+
+def _allocate_when_warmed(campaign: dict[str, object]) -> str:
+    candidate = _candidate(campaign)
+    diagnostics = candidate["diagnostics"]
+    assert isinstance(diagnostics, dict)
+    diagnostics["warmed_allocation_count"] = 1
+    stage_plans = candidate["stage_plans"]
+    assert isinstance(stage_plans, list)
+    stage = stage_plans[0]
+    assert isinstance(stage, dict)
+    stage_diagnostics = stage["diagnostics"]
+    assert isinstance(stage_diagnostics, dict)
+    stage_diagnostics["warmed_allocation_count"] = 1
+    for batch in _batches(campaign).values():
+        assert isinstance(batch, dict)
+        rows = batch["measurements"]
+        assert isinstance(rows, list)
+        for row in rows:
+            assert isinstance(row, dict)
+            if row["lane"] == "candidate":
+                row["warmed_allocation_count"] = 1
+    return "zero_warmed_allocations"
+
+
+def _regress_eager(campaign: dict[str, object]) -> str:
+    rows = campaign["non_target_performance"]
+    assert isinstance(rows, list)
+    eager = next(row for row in rows if row["name"] == "eager")
+    eager["candidate_seconds_per_point"] = [1.03] * 7
+    return "non_target_performance:eager"
+
+
+@pytest.mark.parametrize(
+    "mutation",
+    [
+        _miss_primary_gain,
+        _regress_batch_one,
+        _miss_code_size,
+        _regress_generation,
+        _allocate_when_warmed,
+        _regress_eager,
+    ],
+)
+def test_well_formed_threshold_misses_return_failed_gates(
+    mutation: Callable[[dict[str, object]], str],
+) -> None:
+    campaign = _campaign()
+    expected_gate = mutation(campaign)
+    _seal(campaign)
+
+    result = acceptance.audit_campaign(campaign)
+
+    assert result["passes"] is False
+    gates = result["gates"]
+    assert isinstance(gates, dict)
+    assert gates[expected_gate]["passes"] is False
+
+
+def test_unavailable_exact_code_size_fails_closed_without_using_source_bytes() -> None:
+    campaign = _campaign()
+    baseline = campaign["baseline"]
+    assert isinstance(baseline, dict)
+    baseline["code_size_metric_available"] = False
+    baseline["code_size_metric_kind"] = None
+    baseline["selected_machine_code_bytes"] = None
+    metrics = _candidate(campaign)["metrics"]
+    assert isinstance(metrics, dict)
+    metrics["code_size_metric_available"] = False
+    metrics["code_size_metric_kind"] = None
+    metrics["selected_machine_code_bytes"] = None
+    _seal(campaign)
+
+    result = acceptance.audit_campaign(campaign)
+
+    assert result["passes"] is False
+    gate = result["gates"]["selected_machine_code_reduction"]
+    assert gate["passes"] is False
+    assert gate["metric_available"] is False
+    diagnostics = result["code_size_diagnostics"]
+    assert diagnostics["portable_source_metric_is_machine_code"] is False
+    assert diagnostics["baseline_portable_source_application_bytes"] == 4096
+
+
+def test_code_size_metric_must_be_exact_executed_machine_code() -> None:
+    campaign = _campaign()
+    metrics = _candidate(campaign)["metrics"]
+    assert isinstance(metrics, dict)
+    metrics["code_size_metric_kind"] = "portable-source-application-bytes-v1"
+    _seal(campaign)
+
+    with pytest.raises(acceptance.AcceptanceError, match="exact executed code"):
+        acceptance.audit_campaign(campaign)
+
+
+def test_content_digest_duplicate_keys_and_cli_exit_status(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    campaign = _campaign()
+    campaign["content_sha256"] = _digest("0")
+    with pytest.raises(acceptance.AcceptanceError, match="computed"):
+        acceptance.audit_campaign(campaign)
+
+    duplicate_path = tmp_path / "duplicate.json"
+    duplicate_path.write_text('{"kind": 1, "kind": 2}', encoding="utf-8")
+    with pytest.raises(acceptance.AcceptanceError, match="duplicate"):
+        acceptance.load_campaign(duplicate_path)
+
+    valid_path = tmp_path / "valid.json"
+    valid_path.write_text(json.dumps(_campaign()), encoding="utf-8")
+    assert acceptance.main([str(valid_path)]) == 0
+    captured = capsys.readouterr()
+    assert acceptance.RESULT_KIND in captured.out
diff --git a/pyamplicol/tests/unit/test_compiled_mode_matrix.py b/pyamplicol/tests/unit/test_compiled_mode_matrix.py
new file mode 100644
index 0000000000..dc6b029e43
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiled_mode_matrix.py
@@ -0,0 +1,1001 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+import json
+import platform
+import subprocess
+from collections import Counter
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tools.developer import (
+    compiled_mode_matrix as matrix,
+)
+from tools.developer import (
+    compiled_mode_regression as regression,
+)
+from tools.developer import compiled_mode_sample
+
+BASELINE = Path("/matrix/baseline/bin/python")
+CURRENT = Path("/matrix/current/bin/python")
+UFO_SM = Path("/matrix/models/sm")
+OUTPUT_ROOT = Path("/matrix/output")
+BASELINE_SOURCE_REVISION = "1" * 40
+CURRENT_SOURCE_REVISION = "2" * 40
+BASELINE_NATIVE_INPUTS = "c" * 64
+CURRENT_NATIVE_INPUTS = "d" * 64
+BASELINE_DISTRIBUTION = "e" * 64
+CURRENT_DISTRIBUTION = "f" * 64
+BASELINE_NATIVE_MODULE = "a" * 64
+CURRENT_NATIVE_MODULE = "b" * 64
+
+
+def _synthetic_installation(lane: str) -> dict[str, object]:
+    baseline = lane == "baseline"
+    return {
+        "kind": regression.INSTALLATION_IDENTITY_KIND,
+        "schema_version": regression.INSTALLATION_IDENTITY_SCHEMA_VERSION,
+        "distribution_content": {
+            "sha256": BASELINE_DISTRIBUTION if baseline else CURRENT_DISTRIBUTION,
+        },
+        "native_modules": [
+            {"sha256": (BASELINE_NATIVE_MODULE if baseline else CURRENT_NATIVE_MODULE)}
+        ],
+        "build_info_files": [
+            {
+                "payload": {
+                    "source_revision": (
+                        BASELINE_SOURCE_REVISION
+                        if baseline
+                        else CURRENT_SOURCE_REVISION
+                    ),
+                    "native_build_inputs_sha256": (
+                        BASELINE_NATIVE_INPUTS if baseline else CURRENT_NATIVE_INPUTS
+                    ),
+                    "publishable": False,
+                    "selftest_fixture_bootstrap": False,
+                }
+            }
+        ],
+    }
+
+
+def _synthetic_result(
+    cell: matrix.MatrixCell,
+    *,
+    generation_ratio: float = 1.04,
+    gain: bool = False,
+) -> dict[str, object]:
+    model = "built-in-sm" if cell.model_kind == "built-in" else str(UFO_SM)
+    model_label = "built-in" if cell.model_kind == "built-in" else "ufo-sm"
+    native_hashes = {
+        "baseline": BASELINE_NATIVE_MODULE,
+        "current": CURRENT_NATIVE_MODULE,
+    }
+    measurements = [
+        {
+            "lane": lane,
+            "runtime_identity": {
+                "lane": lane,
+                "native_module": {"sha256": native_hashes[lane]},
+                "native_build_inputs_sha256": (
+                    BASELINE_NATIVE_INPUTS
+                    if lane == "baseline"
+                    else CURRENT_NATIVE_INPUTS
+                ),
+                "build_info": {
+                    "payload": {
+                        "source_revision": (
+                            BASELINE_SOURCE_REVISION
+                            if lane == "baseline"
+                            else CURRENT_SOURCE_REVISION
+                        ),
+                        "native_build_inputs_sha256": (
+                            BASELINE_NATIVE_INPUTS
+                            if lane == "baseline"
+                            else CURRENT_NATIVE_INPUTS
+                        ),
+                        "publishable": False,
+                        "selftest_fixture_bootstrap": False,
+                    }
+                },
+            },
+            "warmed_numerical_result": {
+                "values_f64": [1.0] * regression.VALIDATION_SAMPLE_COUNT,
+            },
+            **(
+                {
+                    "profile_attribution_sample_pass": (
+                        regression.PROFILE_ATTRIBUTION_SAMPLE_PASS
+                    ),
+                    "profile_attribution_boundary": (regression.ARENA_PROFILE_BOUNDARY),
+                    "profile_attribution_borrowed_flat_input": True,
+                    "profile_attribution_preallocated_output": True,
+                    "profile_attribution_phase_timing_scope": (
+                        regression.ARENA_PHASE_TIMING_SCOPE
+                    ),
+                    "profile_attribution_evaluator_timing_available": False,
+                    "profile_protocol": regression.ARENA_PROFILE_PROTOCOL,
+                    "profile_timed_block_count": 7,
+                    "paired_profile_evaluator_seconds_per_point": None,
+                    "paired_profile_evaluator_uncertainty": None,
+                    "paired_profile_timing_breakdown": {
+                        "sample_count": 7,
+                        "evaluator_call_time": None,
+                        "raw_profile_samples": [
+                            {
+                                "execution_mode": cell.execution_mode,
+                                "wall_time_s": 1.0,
+                                "orchestration_time_s": 1.0,
+                                "profile_boundary": (regression.ARENA_PROFILE_BOUNDARY),
+                                "borrowed_flat_input": True,
+                                "preallocated_output": True,
+                                "phase_timing_scope": (
+                                    regression.ARENA_PHASE_TIMING_SCOPE
+                                ),
+                                "evaluator_timing_available": False,
+                                **{
+                                    key: 0
+                                    for key in (
+                                        *regression._ZERO_ARENA_PROFILE_COUNTERS,
+                                        *regression._ZERO_COMPILED_BOUNDARY_COUNTERS,
+                                    )
+                                },
+                                **{
+                                    key: 0.0
+                                    for key in regression._ZERO_ARENA_PROFILE_TIMES
+                                },
+                                **{
+                                    key: []
+                                    for key in (
+                                        regression._EMPTY_ARENA_PROFILE_PHASE_VECTORS
+                                    )
+                                },
+                                "compiled_direct_arena_engine_count": (
+                                    1 if cell.execution_mode == "compiled" else 0
+                                ),
+                                "compiled_direct_arena_call_count": (
+                                    1 if cell.execution_mode == "compiled" else 0
+                                ),
+                                "evaluator_backend_call_count": (
+                                    1 if cell.execution_mode == "compiled" else 0
+                                ),
+                            }
+                            for _ in range(7)
+                        ],
+                    },
+                }
+                if lane == "current"
+                else {}
+            ),
+        }
+        for _pair in range(7)
+        for lane in ("baseline", "current")
+    ]
+    return {
+        "kind": regression.RESULT_KIND,
+        "schema_version": regression.SCHEMA_VERSION,
+        "complete": True,
+        "performance_result_authoritative": True,
+        "passes": True,
+        "platform": platform.platform(),
+        "configuration": {
+            "baseline_python": str(BASELINE),
+            "current_python": str(CURRENT),
+            "output_root": str(
+                OUTPUT_ROOT / "artifact-groups" / cell.artifact_group_id
+            ),
+            "process": cell.process,
+            "model": model,
+            "model_label": model_label,
+            "execution_mode": cell.execution_mode,
+            "workload": cell.workload,
+            "jit_optimization_level": cell.jit_optimization_level,
+            "color_accuracy": cell.color_accuracy,
+            "lc_flow_layout": cell.lc_flow_layout,
+            "shared_artifact": None,
+            "batch_size": cell.batch_size,
+            "independent_samples_per_lane": 7,
+            "target_runtime_per_native_sample_seconds": 5.0,
+            "minimum_native_timed_blocks_per_profile": 7,
+            "warmup_runs_per_profile": 2,
+            "native_wall_time_source": regression.NATIVE_WALL_TIME_SOURCE,
+            "native_wall_time_sample_pass": regression.NATIVE_WALL_TIME_SAMPLE_PASS,
+            "required_current_profile_attribution_sample_pass": (
+                regression.PROFILE_ATTRIBUTION_SAMPLE_PASS
+            ),
+            "required_current_profile_attribution_boundary": (
+                regression.ARENA_PROFILE_BOUNDARY
+            ),
+            "required_current_profile_attribution_phase_timing_scope": (
+                regression.ARENA_PHASE_TIMING_SCOPE
+            ),
+            "required_current_profile_attribution_evaluator_timing_available": False,
+            "required_current_profile_protocol": regression.ARENA_PROFILE_PROTOCOL,
+            "timing_sample_contract": regression.PAIRED_TIMING_SAMPLE_CONTRACT,
+            "helicities": list(cell.helicities),
+            "color_flows": list(cell.color_flows),
+            "dependency_sites": {"baseline": None, "current": None},
+        },
+        "gate": {"passes": True},
+        "correctness_gate": {"passes": True},
+        "arena_profile_gate": {"passes": True},
+        "resource_gate": {
+            "passes": True,
+            "generation": {
+                "current_over_baseline": generation_ratio,
+                "passes": True,
+            },
+        },
+        "gain_gate": {
+            "relative_gain": 0.12 if gain else 0.0,
+            "at_least_ten_percent": gain,
+            "beyond_measurement_noise": gain,
+            "passes": gain,
+        },
+        "native_module_sha256_by_lane": native_hashes,
+        "artifacts": {
+            lane: {
+                "path": str(
+                    OUTPUT_ROOT
+                    / "artifact-groups"
+                    / cell.artifact_group_id
+                    / lane
+                    / "artifact"
+                ),
+                "artifact_id": f"{cell.artifact_group_id}-{lane}",
+                "manifest_sha256": ("7" if lane == "baseline" else "8") * 64,
+                "tree_identity": {"sha256": ("9" if lane == "baseline" else "0") * 64},
+                "payload_digests": {
+                    "evaluator-state": ("3" if lane == "baseline" else "4") * 64
+                },
+                "installation_identity": _synthetic_installation(lane),
+                "required_runtime_capabilities": [
+                    (
+                        regression.EAGER_DIRECT_ARENA_CAPABILITY
+                        if cell.execution_mode == "eager"
+                        else regression.COMPILED_DIRECT_ARENA_CAPABILITY
+                    )
+                ],
+            }
+            for lane in ("baseline", "current")
+        },
+        "measurements": measurements,
+        "pair_orders": [
+            ["baseline", "current"] if pair_index % 2 == 0 else ["current", "baseline"]
+            for pair_index in range(7)
+        ],
+        "provenance": {
+            "driver": {"sha256": matrix._sha256_file(matrix.CELL_DRIVER)},
+            "watchdog": {"sha256": matrix._sha256_file(regression.WATCHDOG)},
+            "native_sample_helper": {
+                "sha256": matrix._sha256_file(regression.NATIVE_SAMPLE_HELPER)
+            },
+            "dependency_entry": {
+                "sha256": matrix._sha256_file(regression.DEPENDENCY_ENTRY)
+            },
+            "interpreters": {"baseline": "baseline", "current": "current"},
+            "dependency_sites": {"baseline": None, "current": None},
+            "model": {"kind": cell.model_kind},
+        },
+    }
+
+
+def _passing_results() -> dict[str, dict[str, object]]:
+    results = {cell.cell_id: _synthetic_result(cell) for cell in matrix.CANONICAL_CELLS}
+    for mode in matrix.EXECUTION_MODES:
+        cell = next(
+            candidate
+            for candidate in matrix.CANONICAL_CELLS
+            if candidate.execution_mode == mode
+        )
+        results[cell.cell_id] = _synthetic_result(cell, gain=True)
+    return results
+
+
+def _audit(results: dict[str, dict[str, object]]) -> dict[str, object]:
+    return matrix.audit_results(
+        results,
+        baseline_python=BASELINE,
+        current_python=CURRENT,
+        ufo_sm_model=UFO_SM,
+        output_root=OUTPUT_ROOT,
+        expected_platform=platform.platform(),
+        expected_builds={
+            "baseline": {
+                "source_revision": BASELINE_SOURCE_REVISION,
+                "native_build_inputs_sha256": BASELINE_NATIVE_INPUTS,
+                "distribution_content_sha256": BASELINE_DISTRIBUTION,
+                "native_module_sha256": BASELINE_NATIVE_MODULE,
+            },
+            "current": {
+                "source_revision": CURRENT_SOURCE_REVISION,
+                "native_build_inputs_sha256": CURRENT_NATIVE_INPUTS,
+                "distribution_content_sha256": CURRENT_DISTRIBUTION,
+                "native_module_sha256": CURRENT_NATIVE_MODULE,
+            },
+        },
+    )
+
+
+def test_canonical_matrix_is_the_documented_168_cells() -> None:
+    cells = matrix.CANONICAL_CELLS
+
+    assert len(cells) == len({cell.cell_id for cell in cells}) == 168
+    assert Counter(cell.category for cell in cells) == {
+        "primary": 24,
+        "medium": 120,
+        "color-heavy": 24,
+    }
+    assert Counter(cell.execution_mode for cell in cells) == {
+        "eager": 84,
+        "compiled": 84,
+    }
+    assert Counter(cell.jit_optimization_level for cell in cells) == {2: 84, 3: 84}
+    assert {cell.batch_size for cell in cells} == {1, 128, 1024}
+    assert len({cell.artifact_group_id for cell in cells}) == 56
+
+
+def test_stable_file_identity_projection_only_removes_mtimes() -> None:
+    value = {
+        "path": "/fixed/tool.py",
+        "resolved_path": "/fixed/tool.py",
+        "size_bytes": 123,
+        "sha256": "a" * 64,
+        "mtime_ns": 100,
+        "nested": [
+            {
+                "path": "/fixed/model",
+                "mtime_ns": 200,
+                "digest": {"sha256": "b" * 64},
+            }
+        ],
+    }
+    projected = matrix._stable_file_identity_value(value)
+    assert projected == {
+        "path": "/fixed/tool.py",
+        "resolved_path": "/fixed/tool.py",
+        "size_bytes": 123,
+        "sha256": "a" * 64,
+        "nested": [
+            {
+                "path": "/fixed/model",
+                "digest": {"sha256": "b" * 64},
+            }
+        ],
+    }
+    assert matrix._stable_file_identity_value(projected) == projected
+
+
+def test_stable_runtime_projection_drops_only_host_observations() -> None:
+    runtime = {
+        "platform": "Linux-6.11.0-runner-a-x86_64",
+        "python": "3.11.9",
+        "executable": {
+            "path": "/tmp/runtime/current/bin/python",
+            "size_bytes": 123,
+            "sha256": "a" * 64,
+            "mtime_ns": 100,
+        },
+        "native_module": {
+            "path": "/tmp/runtime/current/pyamplicol/_rusticol.abi3.so",
+            "sha256": "b" * 64,
+        },
+        "build_info": {
+            "payload": {
+                "source_revision": CURRENT_SOURCE_REVISION,
+                "native_build_inputs_sha256": CURRENT_NATIVE_INPUTS,
+            }
+        },
+    }
+    equivalent = copy.deepcopy(runtime)
+    equivalent["platform"] = "Linux-6.12.0-runner-b-x86_64"
+    equivalent["executable"]["mtime_ns"] = 200
+    assert matrix._stable_runtime_identity_value(runtime) == (
+        matrix._stable_runtime_identity_value(equivalent)
+    )
+
+    changed_path = copy.deepcopy(equivalent)
+    changed_path["executable"]["path"] = "/tmp/another/bin/python"
+    assert matrix._stable_runtime_identity_value(runtime) != (
+        matrix._stable_runtime_identity_value(changed_path)
+    )
+    changed_sha = copy.deepcopy(equivalent)
+    changed_sha["native_module"]["sha256"] = "c" * 64
+    assert matrix._stable_runtime_identity_value(runtime) != (
+        matrix._stable_runtime_identity_value(changed_sha)
+    )
+    changed_build = copy.deepcopy(equivalent)
+    changed_build["build_info"]["payload"]["source_revision"] = "f" * 40
+    assert matrix._stable_runtime_identity_value(runtime) != (
+        matrix._stable_runtime_identity_value(changed_build)
+    )
+
+
+def test_cell_command_wires_physical_ordinal_selectors_and_ufo_model() -> None:
+    topology = next(
+        cell
+        for cell in matrix.CANONICAL_CELLS
+        if cell.model_kind == "ufo-sm"
+        and cell.execution_mode == "compiled"
+        and cell.workload_key == "lc-topology"
+    )
+    union = next(
+        cell
+        for cell in matrix.CANONICAL_CELLS
+        if cell.model_kind == "ufo-sm"
+        and cell.execution_mode == "eager"
+        and cell.workload_key == "lc-union"
+    )
+
+    topology_command = matrix.cell_command(
+        topology,
+        baseline_python=BASELINE,
+        current_python=CURRENT,
+        output_root=Path("/matrix/output"),
+        ufo_sm_model=UFO_SM,
+    )
+    union_command = matrix.cell_command(
+        union,
+        baseline_python=BASELINE,
+        current_python=CURRENT,
+        output_root=Path("/matrix/output"),
+        ufo_sm_model=UFO_SM,
+    )
+
+    assert regression.parser().parse_args(topology_command[2:]).process == (
+        topology.process
+    )
+    assert regression.parser().parse_args(union_command[2:]).process == union.process
+    topology_arguments = regression.parser().parse_args(topology_command[2:])
+    assert (
+        topology_arguments.output_root
+        == Path("/matrix/output/artifact-groups") / topology.artifact_group_id
+    )
+    assert (
+        topology_arguments.result_path
+        == Path("/matrix/output/cells") / topology.cell_id / "result.json"
+    )
+    assert topology_command[topology_command.index("--model") + 1] == str(UFO_SM)
+    assert topology_command[topology_command.index("--color-flow") + 1] == (
+        "flow:2,4,5,6,7,8,9,1"
+    )
+    assert "--helicity" not in topology_command
+    assert union_command[union_command.index("--helicity") + 1] == (
+        "h:-1,+1,-1,+1,-1,+1,-1,+1,-1"
+    )
+    assert "--color-flow" not in union_command
+    assert (
+        topology_command[topology_command.index("--jit-optimization-level") + 1] == "3"
+    )
+    assert union_command[union_command.index("--jit-optimization-level") + 1] == "2"
+
+
+def test_complete_matrix_passes_all_aggregate_gates() -> None:
+    audited = _audit(_passing_results())
+
+    assert audited["passes"] is True
+    assert audited["coverage"]["expected"] == 168
+    assert audited["identity_gate"]["passes"] is True
+    assert audited["gain_gate"]["passes"] is True
+    assert audited["generation_gate"][
+        "geometric_mean_current_over_baseline"
+    ] == pytest.approx(1.04)
+
+
+def test_in_progress_matrix_never_retains_a_passing_verdict() -> None:
+    audited = _audit(_passing_results())
+    assert audited["passes"] is True
+
+    partial = matrix._mark_in_progress(
+        audited,
+        preflight_state={"sealed": True},
+        output_root=OUTPUT_ROOT,
+    )
+
+    assert partial["complete"] is True
+    assert partial["run_complete"] is False
+    assert partial["passes"] is False
+    assert partial["outer_provenance_gate"]["passes"] is False
+    assert partial["provenance"]["postflight"] is None
+
+
+def test_matrix_writes_in_progress_sentinel_before_first_cell(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    baseline_python = tmp_path / "baseline-python"
+    current_python = tmp_path / "current-python"
+    for interpreter in (baseline_python, current_python):
+        interpreter.write_text("#!/bin/sh\n", encoding="utf-8")
+        interpreter.chmod(0o755)
+    ufo_sm = tmp_path / "sm"
+    ufo_sm.mkdir()
+    output_root = tmp_path / "matrix"
+    expected_builds = {
+        "baseline": {
+            "source_revision": BASELINE_SOURCE_REVISION,
+            "native_build_inputs_sha256": BASELINE_NATIVE_INPUTS,
+            "distribution_content_sha256": BASELINE_DISTRIBUTION,
+            "native_module_sha256": BASELINE_NATIVE_MODULE,
+        },
+        "current": {
+            "source_revision": CURRENT_SOURCE_REVISION,
+            "native_build_inputs_sha256": CURRENT_NATIVE_INPUTS,
+            "distribution_content_sha256": CURRENT_DISTRIBUTION,
+            "native_module_sha256": CURRENT_NATIVE_MODULE,
+        },
+    }
+    preflight_state = {
+        "platform": platform.platform(),
+        "system": platform.system(),
+        "machine": platform.machine(),
+    }
+    monkeypatch.setattr(
+        matrix,
+        "_preflight",
+        lambda *_args, **_kwargs: (expected_builds, preflight_state),
+    )
+    monkeypatch.setattr(matrix, "CANONICAL_CELLS", matrix.CANONICAL_CELLS[:1])
+    writes: list[dict[str, object]] = []
+    monkeypatch.setattr(
+        matrix,
+        "_write_json_atomic",
+        lambda _path, payload: writes.append(copy.deepcopy(dict(payload))),
+    )
+
+    def fail_first_cell(
+        command: tuple[str, ...],
+        **_kwargs: object,
+    ) -> subprocess.CompletedProcess[str]:
+        assert writes
+        assert writes[-1]["run_complete"] is False
+        assert writes[-1]["passes"] is False
+        assert writes[-1]["outer_provenance_gate"]["passes"] is False
+        return subprocess.CompletedProcess(command, 2, "", "deliberate stop")
+
+    monkeypatch.setattr(matrix.subprocess, "run", fail_first_cell)
+    arguments = SimpleNamespace(
+        output_root=output_root,
+        ufo_sm_model=ufo_sm,
+        baseline_python=baseline_python,
+        current_python=current_python,
+        baseline_dependency_site=tmp_path / "baseline-site",
+        current_dependency_site=tmp_path / "current-site",
+        audit_only=False,
+        rerun_results=True,
+        regenerate_artifacts=True,
+        samples=7,
+        target_runtime=5.0,
+        minimum_samples=7,
+        warmup_runs=2,
+        generation_timeout=2400.0,
+        profile_timeout=1200.0,
+    )
+
+    with pytest.raises(matrix.MatrixError, match="cell driver failed"):
+        matrix.run_matrix(arguments)
+
+
+def test_matrix_fails_closed_for_missing_or_unexpected_cells() -> None:
+    results = _passing_results()
+    missing_id = next(iter(results))
+    del results[missing_id]
+    results["stale-cell"] = {}
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    assert audited["coverage"]["passes"] is False
+    assert audited["coverage"]["missing"] == [missing_id]
+    assert audited["coverage"]["unexpected"] == ["stale-cell"]
+
+
+def test_matrix_requires_gain_in_each_execution_mode() -> None:
+    results = _passing_results()
+    for cell in matrix.CANONICAL_CELLS:
+        if cell.execution_mode == "eager":
+            result = results[cell.cell_id]
+            result["gain_gate"] = {
+                "relative_gain": 0.2,
+                "at_least_ten_percent": True,
+                "beyond_measurement_noise": False,
+                "passes": False,
+            }
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    assert audited["gain_gate"]["passing_cells_by_execution_mode"]["eager"] == []
+    assert audited["gain_gate"]["passes"] is False
+
+
+def test_matrix_requires_gain_from_a_primary_workload_in_each_mode() -> None:
+    results = {cell.cell_id: _synthetic_result(cell) for cell in matrix.CANONICAL_CELLS}
+    for mode in matrix.EXECUTION_MODES:
+        cell = next(
+            candidate
+            for candidate in matrix.CANONICAL_CELLS
+            if candidate.category == "medium" and candidate.execution_mode == mode
+        )
+        results[cell.cell_id] = _synthetic_result(cell, gain=True)
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    assert all(
+        audited["gain_gate"]["passing_cells_by_execution_mode"][mode]
+        for mode in matrix.EXECUTION_MODES
+    )
+    assert all(
+        audited["gain_gate"]["passing_primary_cells_by_execution_mode"][mode] == []
+        for mode in matrix.EXECUTION_MODES
+    )
+
+
+def test_matrix_rejects_diagnostic_timing_methodology() -> None:
+    results = _passing_results()
+    changed_cell = next(iter(results))
+    result = results[changed_cell]
+    result["configuration"]["independent_samples_per_lane"] = 5
+    result["configuration"]["target_runtime_per_native_sample_seconds"] = 0.1
+    result["configuration"]["minimum_native_timed_blocks_per_profile"] = 5
+    result["measurements"] = result["measurements"][:10]
+    result["pair_orders"] = result["pair_orders"][:5]
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    assert changed_cell in audited["cell_gate"]["failures"]
+
+
+def test_matrix_recomputes_arena_profile_evidence_instead_of_trusting_gate() -> None:
+    results = _passing_results()
+    changed_cell = next(iter(results))
+    result = results[changed_cell]
+    assert result["arena_profile_gate"]["passes"] is True
+    for measurement in result["measurements"]:
+        if measurement["lane"] != "current":
+            continue
+        measurement.pop("profile_attribution_phase_timing_scope")
+        breakdown = measurement["paired_profile_timing_breakdown"]
+        breakdown["raw_profile_samples"][0].pop("phase_timing_scope")
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    failures = audited["cell_gate"]["failures"][changed_cell]
+    assert "arena profile evidence fails independent matrix recomputation" in failures
+
+
+def test_matrix_rejects_synthetic_nested_evaluator_zero() -> None:
+    results = _passing_results()
+    changed_cell = next(iter(results))
+    result = results[changed_cell]
+    assert result["arena_profile_gate"]["passes"] is True
+    for measurement in result["measurements"]:
+        if measurement["lane"] == "current":
+            measurement["paired_profile_timing_breakdown"]["evaluator_call_time"] = {
+                "mean_seconds_per_point": 0.0
+            }
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    failures = audited["cell_gate"]["failures"][changed_cell]
+    assert "arena profile evidence fails independent matrix recomputation" in failures
+
+
+def test_matrix_rejects_truncated_raw_arena_profile_vector() -> None:
+    results = _passing_results()
+    changed_cell = next(iter(results))
+    result = results[changed_cell]
+    assert result["arena_profile_gate"]["passes"] is True
+    for measurement in result["measurements"]:
+        if measurement["lane"] == "current":
+            measurement["paired_profile_timing_breakdown"]["raw_profile_samples"] = [
+                measurement["paired_profile_timing_breakdown"]["raw_profile_samples"][0]
+            ]
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    failures = audited["cell_gate"]["failures"][changed_cell]
+    assert "arena profile evidence fails independent matrix recomputation" in failures
+
+
+def test_matrix_rejects_phase_clocks_under_coarse_arena_scope() -> None:
+    results = _passing_results()
+    changed_cell = next(iter(results))
+    result = results[changed_cell]
+    assert result["arena_profile_gate"]["passes"] is True
+    for measurement in result["measurements"]:
+        if measurement["lane"] != "current":
+            continue
+        for profile in measurement["paired_profile_timing_breakdown"][
+            "raw_profile_samples"
+        ]:
+            profile["stage_evaluator_call_time_s"] = 1.0e-9
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    failures = audited["cell_gate"]["failures"][changed_cell]
+    assert "arena profile evidence fails independent matrix recomputation" in failures
+
+
+def test_matrix_rejects_an_identically_zero_lc_selector() -> None:
+    results = _passing_results()
+    changed_cell = next(
+        cell for cell in matrix.CANONICAL_CELLS if cell.workload != "summed"
+    )
+    for measurement in results[changed_cell.cell_id]["measurements"]:
+        measurement["warmed_numerical_result"]["values_f64"] = [
+            0.0
+        ] * regression.VALIDATION_SAMPLE_COUNT
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    assert changed_cell.cell_id in audited["cell_gate"]["failures"]
+
+
+def test_matrix_rejects_generation_geometric_mean_above_five_percent() -> None:
+    results = _passing_results()
+    for result in results.values():
+        result["resource_gate"]["generation"]["current_over_baseline"] = 1.051
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    assert audited["generation_gate"][
+        "geometric_mean_current_over_baseline"
+    ] == pytest.approx(1.051)
+    assert audited["generation_gate"]["passes"] is False
+
+
+def test_matrix_rejects_runtime_identity_drift() -> None:
+    results = _passing_results()
+    changed = copy.deepcopy(next(iter(results.values())))
+    for measurement in changed["measurements"]:
+        if measurement["lane"] == "current":
+            measurement["runtime_identity"]["extra_build_marker"] = "changed"
+    changed_cell = next(iter(results))
+    results[changed_cell] = changed
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    assert "runtime:current" in audited["identity_gate"]["failures"]
+
+
+def test_matrix_rejects_a_stable_but_unpinned_runtime() -> None:
+    results = _passing_results()
+    for result in results.values():
+        for measurement in result["measurements"]:
+            if measurement["lane"] == "current":
+                measurement["runtime_identity"]["build_info"]["payload"][
+                    "source_revision"
+                ] = "3" * 40
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    assert all(
+        "current source revision does not match its pin" in failures
+        for failures in audited["cell_gate"]["failures"].values()
+    )
+
+
+def test_matrix_rejects_a_stable_but_unpinned_distribution() -> None:
+    results = _passing_results()
+    for result in results.values():
+        result["artifacts"]["current"]["installation_identity"]["distribution_content"][
+            "sha256"
+        ] = "6" * 64
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    assert all(
+        "current distribution content does not match its pin" in failures
+        for failures in audited["cell_gate"]["failures"].values()
+    )
+
+
+def test_matrix_binds_results_to_output_root_and_platform() -> None:
+    results = _passing_results()
+    changed_cell = next(iter(results))
+    results[changed_cell]["configuration"]["output_root"] = "/copied/result"
+    results[changed_cell]["platform"] = "different-host"
+
+    audited = _audit(results)
+
+    assert audited["passes"] is False
+    failures = audited["cell_gate"]["failures"][changed_cell]
+    assert "configuration.output_root does not match the matrix" in failures
+    assert "result platform does not match the acceptance host" in failures
+
+
+def test_preflight_rejects_a_dirty_or_wrong_current_checkout(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    arguments = SimpleNamespace(
+        baseline_python=BASELINE,
+        current_python=CURRENT,
+        baseline_dependency_site=Path("/baseline/site"),
+        current_dependency_site=Path("/current/site"),
+        expected_baseline_source_revision=matrix.FROZEN_BASELINE_SOURCE_REVISION,
+        expected_baseline_native_inputs_sha256=(
+            matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256
+        ),
+        expected_baseline_distribution_sha256=(
+            matrix.FROZEN_BASELINE_DISTRIBUTION_SHA256
+        ),
+        expected_baseline_native_module_sha256=(
+            matrix.FROZEN_BASELINE_NATIVE_MODULE_SHA256
+        ),
+        expected_current_source_revision=CURRENT_SOURCE_REVISION,
+        expected_current_native_inputs_sha256=CURRENT_NATIVE_INPUTS,
+        expected_current_distribution_sha256=CURRENT_DISTRIBUTION,
+        expected_current_native_module_sha256=CURRENT_NATIVE_MODULE,
+    )
+    state = {
+        "platform": platform.platform(),
+        "system": platform.system(),
+        "machine": platform.machine(),
+        "repository": {
+            "head_revision": CURRENT_SOURCE_REVISION,
+            "clean": False,
+            "dirty_entries": [" M harness.py"],
+        },
+    }
+    monkeypatch.setattr(matrix, "_acceptance_state", lambda **_kwargs: state)
+    with pytest.raises(matrix.MatrixError, match="not clean"):
+        matrix._preflight(arguments, ufo_sm_model=UFO_SM)
+
+    state["repository"] = {
+        "head_revision": "3" * 40,
+        "clean": True,
+        "dirty_entries": [],
+    }
+    with pytest.raises(matrix.MatrixError, match="does not match clean checkout HEAD"):
+        matrix._preflight(arguments, ufo_sm_model=UFO_SM)
+
+
+def test_preflight_accepts_exact_caller_pinned_x86_baseline_binary(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    x86_distribution = "5" * 64
+    x86_native_module = "6" * 64
+    arguments = SimpleNamespace(
+        baseline_python=BASELINE,
+        current_python=CURRENT,
+        baseline_dependency_site=Path("/baseline/site"),
+        current_dependency_site=Path("/current/site"),
+        expected_baseline_source_revision=matrix.FROZEN_BASELINE_SOURCE_REVISION,
+        expected_baseline_native_inputs_sha256=(
+            matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256
+        ),
+        expected_baseline_distribution_sha256=x86_distribution,
+        expected_baseline_native_module_sha256=x86_native_module,
+        expected_current_source_revision=CURRENT_SOURCE_REVISION,
+        expected_current_native_inputs_sha256=CURRENT_NATIVE_INPUTS,
+        expected_current_distribution_sha256=CURRENT_DISTRIBUTION,
+        expected_current_native_module_sha256=CURRENT_NATIVE_MODULE,
+    )
+    baseline_installation = _synthetic_installation("baseline")
+    baseline_installation["distribution_content"]["sha256"] = x86_distribution
+    baseline_installation["native_modules"][0]["sha256"] = x86_native_module
+    baseline_payload = baseline_installation["build_info_files"][0]["payload"]
+    baseline_payload["source_revision"] = matrix.FROZEN_BASELINE_SOURCE_REVISION
+    baseline_payload["native_build_inputs_sha256"] = (
+        matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256
+    )
+    state = {
+        "platform": "Linux-x86_64",
+        "system": "Linux",
+        "machine": "x86_64",
+        "repository": {
+            "head_revision": CURRENT_SOURCE_REVISION,
+            "clean": True,
+            "dirty_entries": [],
+        },
+        "installed_pyamplicol": {
+            "baseline": baseline_installation,
+            "current": _synthetic_installation("current"),
+        },
+    }
+    monkeypatch.setattr(matrix, "_acceptance_state", lambda **_kwargs: state)
+
+    expected, observed = matrix._preflight(arguments, ufo_sm_model=UFO_SM)
+
+    assert observed is state
+    assert expected["baseline"]["distribution_content_sha256"] == x86_distribution
+    assert expected["baseline"]["native_module_sha256"] == x86_native_module
+
+
+def test_matrix_cli_requires_dependency_sites_and_has_long_cell_timeouts() -> None:
+    arguments = matrix.parser().parse_args(
+        [
+            "--baseline-python",
+            str(BASELINE),
+            "--current-python",
+            str(CURRENT),
+            "--ufo-sm-model",
+            str(UFO_SM),
+            "--output-root",
+            str(OUTPUT_ROOT),
+            "--expected-baseline-source-revision",
+            matrix.FROZEN_BASELINE_SOURCE_REVISION,
+            "--expected-current-source-revision",
+            CURRENT_SOURCE_REVISION,
+            "--expected-baseline-native-inputs-sha256",
+            matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256,
+            "--expected-current-native-inputs-sha256",
+            CURRENT_NATIVE_INPUTS,
+            "--expected-baseline-distribution-sha256",
+            matrix.FROZEN_BASELINE_DISTRIBUTION_SHA256,
+            "--expected-current-distribution-sha256",
+            CURRENT_DISTRIBUTION,
+            "--expected-baseline-native-module-sha256",
+            matrix.FROZEN_BASELINE_NATIVE_MODULE_SHA256,
+            "--expected-current-native-module-sha256",
+            CURRENT_NATIVE_MODULE,
+            "--baseline-dependency-site",
+            "/baseline/site",
+            "--current-dependency-site",
+            "/current/site",
+        ]
+    )
+
+    assert arguments.baseline_dependency_site == Path("/baseline/site")
+    assert arguments.current_dependency_site == Path("/current/site")
+    assert arguments.generation_timeout >= 1800.0
+    assert arguments.profile_timeout >= 900.0
+
+
+def test_helicity_ordinal_resolves_against_runtime_inventory(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    artifact.mkdir()
+    (artifact / "artifact.json").write_text(
+        json.dumps(
+            {
+                "processes": [
+                    {
+                        "id": "process",
+                        "expression": "d d~ > z",
+                        "physics_path": "runtime-physics.json",
+                    }
+                ]
+            }
+        ),
+        encoding="utf-8",
+    )
+    (artifact / "runtime-physics.json").write_text(
+        json.dumps(
+            {
+                "helicities": [
+                    {"id": "h:-1,-1", "structural_zero": True},
+                    {"id": "h:-1,+1", "structural_zero": False},
+                    {"id": "h:+1,-1"},
+                ]
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    assert compiled_mode_sample._resolve_helicities(
+        artifact,
+        process="process",
+        requested=("1", "h:+1,-1"),
+    ) == ("h:-1,+1", "h:+1,-1")
+    with pytest.raises(compiled_mode_sample.SampleError, match="out of range"):
+        compiled_mode_sample._resolve_helicities(
+            artifact,
+            process="process",
+            requested=("4",),
+        )
diff --git a/pyamplicol/tests/unit/test_compiled_mode_matrix_x86.py b/pyamplicol/tests/unit/test_compiled_mode_matrix_x86.py
new file mode 100644
index 0000000000..19dad1ea9d
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiled_mode_matrix_x86.py
@@ -0,0 +1,276 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import argparse
+import json
+from collections import Counter
+from pathlib import Path
+
+import pytest
+
+from tools.developer import compiled_mode_matrix as matrix
+from tools.developer import compiled_mode_matrix_x86 as x86
+
+
+def test_frozen_partition_is_complete_disjoint_and_group_local() -> None:
+    observed_cells: list[str] = []
+    observed_groups: list[str] = []
+    for shard_index in range(x86.SHARD_COUNT):
+        groups = x86.shard_groups(shard_index)
+        cells = x86.shard_cells(shard_index)
+        assert len(groups) == 7
+        assert len(cells) == 21
+        assert Counter(cell.category for cell in cells) == {
+            "primary": 3,
+            "medium": 15,
+            "color-heavy": 3,
+        }
+        for group in groups:
+            assert tuple(cell.batch_size for cell in group) == matrix.BATCH_SIZES
+            assert len({cell.artifact_group_id for cell in group}) == 1
+            assert all(
+                x86.artifact_group_shard(group) == shard_index for _ in group
+            )
+            observed_groups.append(group[0].artifact_group_id)
+        observed_cells.extend(cell.cell_id for cell in cells)
+    assert len(observed_groups) == len(set(observed_groups)) == 56
+    assert len(observed_cells) == len(set(observed_cells)) == 168
+    assert set(observed_cells) == {cell.cell_id for cell in matrix.CANONICAL_CELLS}
+
+
+def test_frozen_partition_spreads_primary_and_union_work() -> None:
+    primary = []
+    union_counts = []
+    for shard_index in range(x86.SHARD_COUNT):
+        groups = x86.shard_groups(shard_index)
+        primary_groups = [group for group in groups if group[0].category == "primary"]
+        assert len(primary_groups) == 1
+        primary.append(primary_groups[0][0].artifact_group_id)
+        union_counts.append(
+            sum(group[0].lc_flow_layout == "all-flow-union" for group in groups)
+        )
+    assert len(set(primary)) == 8
+    assert max(union_counts) <= 3
+    assert min(union_counts) >= 1
+
+
+def test_partition_definition_is_content_stable() -> None:
+    definition = x86.PARTITION_DEFINITION
+    body = dict(definition)
+    digest = body.pop("sha256")
+    assert definition["contract"] == x86.PARTITION_CONTRACT
+    assert definition["shard_count"] == 8
+    assert digest == x86._canonical_sha256(body)
+    assert set(definition["assignments"]) == {str(index) for index in range(8)}
+
+
+def test_checked_json_rejects_duplicates_nonfinite_and_symlinks(
+    tmp_path: Path,
+) -> None:
+    duplicate = tmp_path / "duplicate.json"
+    duplicate.write_text('{"a":1,"a":2}\n', encoding="utf-8")
+    with pytest.raises(x86.ShardError, match="duplicate"):
+        x86._checked_json(duplicate, label="duplicate")
+    nonfinite = tmp_path / "nonfinite.json"
+    nonfinite.write_text('{"a":NaN}\n', encoding="utf-8")
+    with pytest.raises(x86.ShardError, match="non-finite"):
+        x86._checked_json(nonfinite, label="nonfinite")
+    target = tmp_path / "target.json"
+    target.write_text("{}\n", encoding="utf-8")
+    link = tmp_path / "link.json"
+    link.symlink_to(target)
+    with pytest.raises(x86.ShardError, match="non-symlink"):
+        x86._checked_json(link, label="link")
+
+
+def test_content_identity_rejects_semantic_tampering() -> None:
+    payload = x86._attach_content_identity({"passes": True, "value": 7})
+    x86._require_content_identity(payload, label="payload")
+    payload["value"] = 8
+    with pytest.raises(x86.ShardError, match="does not match"):
+        x86._require_content_identity(payload, label="payload")
+
+
+def _arguments(tmp_path: Path) -> argparse.Namespace:
+    sha = "a" * 64
+    git = "b" * 40
+    return argparse.Namespace(
+        shard_count=8,
+        shard_root=tmp_path / "shards",
+        output_root=tmp_path / "matrix",
+        aggregate_result=tmp_path / "aggregate.json",
+        workflow_run_id="12345",
+        runtime_bundle_sha256=sha,
+        expected_baseline_source_revision=(
+            matrix.FROZEN_BASELINE_SOURCE_REVISION
+        ),
+        expected_current_source_revision=git,
+        expected_baseline_native_inputs_sha256=(
+            matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256
+        ),
+        expected_current_native_inputs_sha256="c" * 64,
+        expected_baseline_distribution_sha256="d" * 64,
+        expected_current_distribution_sha256="e" * 64,
+        expected_baseline_native_module_sha256="f" * 64,
+        expected_current_native_module_sha256="1" * 64,
+        baseline_python=Path("/private/tmp/arena/baseline/bin/python"),
+        current_python=Path("/private/tmp/arena/current/bin/python"),
+        baseline_dependency_site=Path("/private/tmp/arena/dependencies"),
+        current_dependency_site=Path("/private/tmp/arena/dependencies"),
+        ufo_sm_model=Path(
+            "/workspace/src/pyamplicol/assets/models/json/sm/sm.json"
+        ),
+    )
+
+
+def _fake_evidence(
+    cell: matrix.MatrixCell,
+    *_args: object,
+    **_kwargs: object,
+) -> dict[str, object]:
+    return {
+        "cell_id": cell.cell_id,
+        "configuration": matrix.asdict(cell),
+        "result_content_sha256": x86._canonical_sha256({}),
+        "errors": [],
+        "passes": True,
+        "gain_gate_passes": cell.category == "primary",
+        "relative_gain": 0.2,
+        "generation_current_over_baseline": 1.0,
+        "runtime_identity_sha256_by_lane": {
+            "baseline": "2" * 64,
+            "current": "3" * 64,
+        },
+        "native_module_sha256_by_lane": {
+            "baseline": "f" * 64,
+            "current": "1" * 64,
+        },
+        "artifact_identity_sha256_by_lane": {
+            "baseline": "4" * 64,
+            "current": "5" * 64,
+        },
+        "provenance_sha256": {
+            "driver": "6" * 64,
+            "watchdog": "7" * 64,
+            "native_sample_helper": "8" * 64,
+            "dependency_entry": "9" * 64,
+            "interpreters": "a" * 64,
+            "dependency_sites": "b" * 64,
+            "model": ("c" if cell.model_kind == "built-in" else "d") * 64,
+        },
+    }
+
+
+def _write_aggregate_fixture(
+    arguments: argparse.Namespace,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(matrix, "_cell_evidence", _fake_evidence)
+    monkeypatch.setattr(
+        matrix,
+        "_repository_identity",
+        lambda: {
+            "root": "/workspace",
+            "head_revision": arguments.expected_current_source_revision,
+            "clean": True,
+            "dirty_entries": [],
+        },
+    )
+    arguments.shard_root.mkdir(parents=True, exist_ok=True)
+    for index in range(8):
+        cells = x86.shard_cells(index)
+        result_files = []
+        evidence = []
+        for cell in cells:
+            path = arguments.output_root / "cells" / cell.cell_id / "result.json"
+            x86._write_json_atomic(path, {})
+            _, identity = x86._checked_json(path, label=cell.cell_id)
+            result_files.append({"cell_id": cell.cell_id, **identity})
+            evidence.append(_fake_evidence(cell))
+        stable = {"same": True}
+        payload = x86._attach_content_identity(
+            {
+                "kind": x86.SHARD_KIND,
+                "schema_version": x86.SCHEMA_VERSION,
+                "matrix_contract": matrix.MATRIX_CONTRACT,
+                "partition": x86.PARTITION_DEFINITION,
+                "shard_count": 8,
+                "shard_index": index,
+                "workflow_run_id": arguments.workflow_run_id,
+                "runtime_bundle_sha256": arguments.runtime_bundle_sha256,
+                "output_root": str(arguments.output_root.resolve()),
+                "expected_builds": x86._expected_builds(arguments),
+                "platform": {
+                    "platform": f"Linux-shard-{index}",
+                    "system": "Linux",
+                    "machine": "x86_64",
+                },
+                "selected_artifact_group_ids": [
+                    group[0].artifact_group_id for group in x86.shard_groups(index)
+                ],
+                "selected_cell_ids": [cell.cell_id for cell in cells],
+                "result_files": result_files,
+                "cell_evidence": evidence,
+                "cell_gate": {"failures": {}, "passes": True},
+                "artifact_postflight_gate": {"errors": [], "passes": True},
+                "provenance": {
+                    "preflight": stable,
+                    "postflight": stable,
+                    "all_match": True,
+                    "shard_driver": {"sha256": "e" * 64},
+                },
+                "complete": True,
+                "passes": True,
+            }
+        )
+        x86._write_json_atomic(arguments.shard_root / f"shard-{index}.json", payload)
+
+
+def test_pure_json_aggregate_accepts_exact_eight_shard_partition(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    arguments = _arguments(tmp_path)
+    _write_aggregate_fixture(arguments, monkeypatch)
+    payload = x86._aggregate(arguments)
+    assert payload["complete"] is True
+    assert payload["passes"] is True
+    assert payload["matrix_audit"]["coverage"]["observed"] == 168
+    assert payload["shard_gate"]["passes"] is True
+    x86._require_content_identity(payload, label="aggregate")
+
+
+def test_aggregate_rejects_missing_or_tampered_shard(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    arguments = _arguments(tmp_path)
+    _write_aggregate_fixture(arguments, monkeypatch)
+    (arguments.shard_root / "shard-7.json").unlink()
+    with pytest.raises(x86.ShardError, match="manifest set"):
+        x86._aggregate(arguments)
+
+    _write_aggregate_fixture(arguments, monkeypatch)
+    path = arguments.shard_root / "shard-3.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["selected_cell_ids"] = payload["selected_cell_ids"][:-1]
+    x86._write_json_atomic(path, payload)
+    with pytest.raises(x86.ShardError, match="content identity"):
+        x86._aggregate(arguments)
+
+
+def test_aggregate_rejects_changed_result_bytes(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    arguments = _arguments(tmp_path)
+    _write_aggregate_fixture(arguments, monkeypatch)
+    cell = x86.shard_cells(0)[0]
+    path = arguments.output_root / "cells" / cell.cell_id / "result.json"
+    x86._write_json_atomic(path, {"tampered": True})
+    payload = x86._aggregate(arguments)
+    assert payload["passes"] is False
+    assert any(
+        "result file identity changed" in error
+        for error in payload["shard_gate"]["errors"]
+    )
diff --git a/pyamplicol/tests/unit/test_compiled_mode_regression.py b/pyamplicol/tests/unit/test_compiled_mode_regression.py
new file mode 100644
index 0000000000..803bd98490
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiled_mode_regression.py
@@ -0,0 +1,2199 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tools.developer import compiled_mode_regression as regression
+from tools.developer import compiled_mode_sample
+
+WATCHDOG_STDERR = (
+    "memory-watchdog: command finished exit=0 peak_rss=1.250 GiB peak_processes=2\n"
+)
+
+
+def test_native_sample_schema_and_profile_contract_are_cross_module_locked() -> None:
+    assert compiled_mode_sample.SCHEMA_VERSION == (
+        regression.NATIVE_SAMPLE_SCHEMA_VERSION
+    )
+    assert compiled_mode_sample.ARENA_PROFILE_ATTRIBUTION_SAMPLE_PASS == (
+        regression.PROFILE_ATTRIBUTION_SAMPLE_PASS
+    )
+    assert compiled_mode_sample.FROZEN_BASELINE_PROFILE_ATTRIBUTION_SAMPLE_PASS == (
+        regression.FROZEN_BASELINE_PROFILE_ATTRIBUTION_SAMPLE_PASS
+    )
+    assert compiled_mode_sample.ARENA_PROFILE_BOUNDARY == (
+        regression.ARENA_PROFILE_BOUNDARY
+    )
+    assert compiled_mode_sample.FROZEN_BASELINE_PROFILE_BOUNDARY == (
+        regression.FROZEN_BASELINE_PROFILE_BOUNDARY
+    )
+    assert compiled_mode_sample.ARENA_PHASE_TIMING_SCOPE == (
+        regression.ARENA_PHASE_TIMING_SCOPE
+    )
+    assert compiled_mode_sample.FROZEN_BASELINE_PHASE_TIMING_SCOPE == (
+        regression.FROZEN_BASELINE_PHASE_TIMING_SCOPE
+    )
+    assert compiled_mode_sample.ARENA_PROFILE_PROTOCOL == (
+        regression.ARENA_PROFILE_PROTOCOL
+    )
+    assert compiled_mode_sample.FROZEN_BASELINE_PROFILE_PROTOCOL == (
+        regression.FROZEN_BASELINE_PROFILE_PROTOCOL
+    )
+
+
+def _correctness_derivation(
+    point_sha256: list[str],
+    *,
+    batch_sha256: str = "d" * 64,
+) -> dict[str, object]:
+    value: dict[str, object] = {
+        "kind": regression.CORRECTNESS_POINT_DERIVATION_KIND,
+        "schema_version": regression.CORRECTNESS_POINT_DERIVATION_SCHEMA_VERSION,
+        "contract": regression.CORRECTNESS_POINT_DERIVATION_CONTRACT,
+        "source_validation": {
+            "file_sha256": "1" * 64,
+            "canonical_sha256": "2" * 64,
+            "size_bytes": 1024,
+            "process_id": "d_dbar_to_z",
+            "process_expression": "d d~ > z",
+            "external_pdgs": [1, -1, 21, 21],
+            "point_count": 1,
+            "selected_point_index": 0,
+            "selected_point_sha256": "3" * 64,
+        },
+        "numpy": {
+            "module": "numpy",
+            "version": "2.4.2",
+            "origin_file_name": "__init__.py",
+            "origin_size_bytes": 4096,
+            "origin_sha256": "4" * 64,
+            "random_generator": "default_rng",
+            "bit_generator": "PCG64",
+        },
+        "sqrt_s_f64_hex": (1000.0).hex(),
+        "external_mass_f64_hex": [(0.0).hex()] * 4,
+        "final_state_mass_f64_hex": [(0.0).hex()] * 2,
+        "seed_start": regression.CORRECTNESS_SEED_START,
+        "seed_attempt_limit": regression.MAX_CORRECTNESS_SEED_ATTEMPTS,
+        "attempt_count": regression.VALIDATION_SAMPLE_COUNT,
+        "selected_seeds": list(
+            range(
+                regression.CORRECTNESS_SEED_START,
+                regression.CORRECTNESS_SEED_START + regression.VALIDATION_SAMPLE_COUNT,
+            )
+        ),
+        "point_sha256": point_sha256,
+        "invariant_sha256": [
+            f"{index + 100:064x}" for index in range(regression.VALIDATION_SAMPLE_COUNT)
+        ],
+        "batch_sha256": batch_sha256,
+    }
+    value["sha256"] = regression._canonical_sha256(value)
+    return value
+
+
+def _write_artifact(
+    path: Path,
+    *,
+    artifact_id: str = "artifact-id",
+    process: str = "d d~ > z",
+    color: str = "lc",
+    eager: bool = False,
+) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+    payload_path = path / "payload.bin"
+    payload_path.write_bytes(b"compiled-payload")
+    capability = (
+        regression.EAGER_DIRECT_ARENA_CAPABILITY
+        if eager
+        else regression.COMPILED_DIRECT_ARENA_CAPABILITY
+    )
+    (path / "artifact.json").write_text(
+        json.dumps(
+            {
+                "artifact_id": artifact_id,
+                "producer": {"version": "test"},
+                "payloads": [
+                    {
+                        "path": "payload.bin",
+                        "role": "evaluator-state",
+                        "sha256": regression._sha256_file(payload_path),
+                        "size_bytes": payload_path.stat().st_size,
+                    }
+                ],
+                "extensions": {
+                    "generation": {
+                        "concrete_processes": [
+                            {
+                                "id": "d_dbar_to_z",
+                                "filters": {
+                                    "lc_flow_layout": "topology-replay",
+                                },
+                            }
+                        ]
+                    }
+                },
+                "processes": [
+                    {
+                        "id": "d_dbar_to_z",
+                        "expression": process,
+                        "color_accuracy": color,
+                        "required_runtime_capabilities": [capability],
+                    }
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+
+def _profile_payload(
+    wall: float,
+    *,
+    source: str | None = None,
+    sample_pass: str | None = None,
+    timing_contract: str | None = None,
+    batch_size: int = 1024,
+    numerical_values: tuple[float, ...] = (2.5,),
+    native_module_sha256: str = "a" * 64,
+    execution_mode: str = "compiled",
+    include_precision32: bool = True,
+) -> dict[str, object]:
+    sample_count = 5
+    repetitions = 11
+    evaluations = sample_count * repetitions
+    points = evaluations * batch_size
+    profiled_wall = wall * 1.1
+    expanded_values = tuple(
+        numerical_values[index % len(numerical_values)]
+        for index in range(regression.VALIDATION_SAMPLE_COUNT)
+    )
+
+    def numerical_result(precision: int) -> dict[str, object]:
+        point_sha256 = [f"{index:064x}" for index in range(1, len(expanded_values) + 1)]
+        return {
+            "precision": precision,
+            "point_count": len(expanded_values),
+            "distinct_point_count": len(expanded_values),
+            "point_sha256": point_sha256,
+            "batch_sha256": "d" * 64,
+            "values_f64": list(expanded_values),
+            "values_f64_hex": [value.hex() for value in expanded_values],
+            "helicities": [],
+            "color_flows": [],
+            "resolved": {
+                "shape": [len(expanded_values), 1, 1],
+                "helicity_ids": ["h:-1,+1"],
+                "color_ids": ["flow:1,2"],
+                "totals_complex": [[value, 0.0] for value in expanded_values],
+                "values_complex": [[[[value, 0.0]]] for value in expanded_values],
+            },
+        }
+
+    return {
+        "kind": regression.NATIVE_SAMPLE_RESULT_KIND,
+        "schema_version": regression.NATIVE_SAMPLE_SCHEMA_VERSION,
+        "wall_time_per_point": wall,
+        "wall_time_samples_seconds_per_point": [wall] * sample_count,
+        "sample_count": sample_count,
+        "repetitions_per_sample": repetitions,
+        "interrupted": False,
+        "uncertainty": {"standard_deviation": wall / 100.0},
+        "evaluator_time_per_point": None,
+        "evaluator_uncertainty": None,
+        "correctness_point_derivation": _correctness_derivation(
+            [f"{index:064x}" for index in range(1, len(expanded_values) + 1)]
+        ),
+        "warmed_numerical_result": numerical_result(16),
+        "precision32_numerical_result": (
+            numerical_result(32) if include_precision32 else None
+        ),
+        "cold_load_seconds": 0.01,
+        "timing_breakdown": {
+            "sample_count": sample_count,
+            "execution_mode": execution_mode,
+            "wall_time": {
+                "mean_seconds_per_point": profiled_wall,
+                "sample_count": sample_count,
+                "samples_seconds_per_point": [profiled_wall] * sample_count,
+            },
+            "evaluator_call_time": None,
+            "raw_profile_samples": [
+                {
+                    "wall_time_s": profiled_wall * batch_size * repetitions,
+                    "orchestration_time_s": (profiled_wall * batch_size * repetitions),
+                    "profile_boundary": regression.ARENA_PROFILE_BOUNDARY,
+                    "borrowed_flat_input": True,
+                    "preallocated_output": True,
+                    "phase_timing_scope": regression.ARENA_PHASE_TIMING_SCOPE,
+                    "evaluator_timing_available": False,
+                    **{
+                        key: 0
+                        for key in (
+                            *regression._ZERO_ARENA_PROFILE_COUNTERS,
+                            *regression._ZERO_COMPILED_BOUNDARY_COUNTERS,
+                        )
+                    },
+                    **{key: 0.0 for key in regression._ZERO_ARENA_PROFILE_TIMES},
+                    **{
+                        key: [] for key in regression._EMPTY_ARENA_PROFILE_PHASE_VECTORS
+                    },
+                    "execution_mode": execution_mode,
+                    "evaluator_backend_call_count": (
+                        1 if execution_mode == "compiled" else 0
+                    ),
+                    "compiled_direct_arena_engine_count": (
+                        1 if execution_mode == "compiled" else 0
+                    ),
+                    "compiled_direct_arena_call_count": (
+                        1 if execution_mode == "compiled" else 0
+                    ),
+                }
+                for _ in range(sample_count)
+            ],
+        },
+        "environment": {
+            "wall_time_source": source or regression.NATIVE_WALL_TIME_SOURCE,
+            "wall_time_sample_pass": (
+                sample_pass or regression.NATIVE_WALL_TIME_SAMPLE_PASS
+            ),
+            "evaluator_time_sample_pass": (regression.PROFILE_ATTRIBUTION_SAMPLE_PASS),
+            "timing_breakdown_sample_pass": (
+                regression.PROFILE_ATTRIBUTION_SAMPLE_PASS
+            ),
+            "profile_attribution_boundary": (regression.ARENA_PROFILE_BOUNDARY),
+            "profile_attribution_borrowed_flat_input": True,
+            "profile_attribution_preallocated_output": True,
+            "profile_attribution_phase_timing_scope": (
+                regression.ARENA_PHASE_TIMING_SCOPE
+            ),
+            "profile_attribution_evaluator_timing_available": False,
+            "profile_protocol": regression.ARENA_PROFILE_PROTOCOL,
+            "timing_sample_contract": (
+                timing_contract or regression.PAIRED_TIMING_SAMPLE_CONTRACT
+            ),
+            "profile_attribution_paired_with_headline": True,
+            "profile_attribution_identical_batch": True,
+            "profile_attribution_identical_repetitions": True,
+            "execution_mode": execution_mode,
+            "batch_size": batch_size,
+            "completed_sample_count": sample_count,
+            "planned_sample_count": sample_count,
+            "measured_point_count": points,
+            "native_profile_sample_count": sample_count,
+            "native_profile_sample_limit": sample_count,
+            "native_profile_repetitions_per_sample": repetitions,
+            "native_profile_points_per_sample": repetitions * batch_size,
+            "native_profile_calls_per_block": 1.0,
+            "profile_attribution_evaluation_count": evaluations,
+            "profile_attribution_point_count": points,
+            "elapsed_seconds": 5.0,
+            "measured_evaluation_count": evaluations,
+            "interrupted": False,
+            "batch_sha256": "c" * 64,
+            "helicities": [],
+            "color_flows": [],
+            "runtime_identity": {
+                "native_module": {
+                    "sha256": native_module_sha256,
+                }
+            },
+        },
+    }
+
+
+def _profile_payload_for_command(
+    command: tuple[str, ...],
+    wall: float,
+    **kwargs: object,
+) -> dict[str, object]:
+    return _profile_payload(
+        wall,
+        include_precision32="--include-precision32" in command,
+        **kwargs,
+    )
+
+
+def test_parser_exposes_required_lanes_and_plan_defaults(tmp_path: Path) -> None:
+    arguments = regression.parser().parse_args(
+        [
+            "--baseline-python",
+            str(tmp_path / "baseline-python"),
+            "--current-python",
+            str(tmp_path / "current-python"),
+            "--output-root",
+            str(tmp_path / "output"),
+            "--process",
+            "d d~ > z",
+        ]
+    )
+
+    assert arguments.model == "built-in-sm"
+    assert arguments.color == "lc"
+    assert arguments.lc_flow_layout == "topology-replay"
+    assert arguments.shared_artifact is None
+    assert arguments.result_path is None
+    assert arguments.batch_size == 1024
+    assert arguments.samples == 7
+    assert arguments.target_runtime == 5.0
+    assert arguments.minimum_samples == 7
+
+
+def test_parser_rejects_fewer_than_five_outer_samples(tmp_path: Path) -> None:
+    with pytest.raises(SystemExit):
+        regression.parser().parse_args(
+            [
+                "--baseline-python",
+                str(tmp_path / "baseline-python"),
+                "--current-python",
+                str(tmp_path / "current-python"),
+                "--output-root",
+                str(tmp_path / "output"),
+                "--process",
+                "d d~ > z",
+                "--samples",
+                "4",
+            ]
+        )
+
+
+def test_generation_command_is_cross_version_compiled_jit_o3() -> None:
+    command = regression._generation_command(
+        Path("baseline-python"),
+        process="d d~ > z",
+        artifact=Path("artifact"),
+        model="built-in-sm",
+        color="full",
+        lc_flow_layout="topology-replay",
+    )
+
+    assert command[:4] == (
+        "baseline-python",
+        "-m",
+        "pyamplicol",
+        "generate",
+    )
+    assert command[command.index("--backend") + 1] == "jit"
+    assert command[command.index("--jit-optimization-level") + 1] == "3"
+    assert command[command.index("--color-accuracy") + 1] == "full"
+    assert command[command.index("--lc-flow-layout") + 1] == "topology-replay"
+    assert command[command.index("--workers") + 1] == "1"
+    assert command[command.index("--execution-mode") + 1] == "compiled"
+    assert "--no-post-build-validation" in command
+
+
+def test_artifact_execution_mode_accepts_frozen_and_arena_eager_capabilities() -> None:
+    frozen = {
+        "required_runtime_capabilities": [
+            "rusticol.eager-runtime-layout.complex-f64.v1"
+        ]
+    }
+    arena = {"required_runtime_capabilities": ["eager-direct-arena-v1"]}
+
+    assert regression._artifact_execution_mode(frozen) == "eager"
+    assert regression._artifact_execution_mode(arena) == "eager"
+
+
+def test_arena_profile_gate_requires_current_capability_and_complete_calls() -> None:
+    eager_sample = regression._native_profile_sample(
+        _profile_payload(1.0, execution_mode="eager"),
+        minimum_samples=5,
+        expected_execution_mode="eager",
+    )
+    eager_measurements = ({"lane": "current", "pair_index": 1, **eager_sample},)
+    legacy = {
+        "current": {
+            "required_runtime_capabilities": [
+                "rusticol.eager-runtime-layout.complex-f64.v1"
+            ]
+        }
+    }
+    direct = {
+        "current": {
+            "required_runtime_capabilities": [regression.EAGER_DIRECT_ARENA_CAPABILITY]
+        }
+    }
+    assert (
+        regression._arena_profile_gate(
+            eager_measurements,
+            execution_mode="eager",
+            artifacts=legacy,
+        )["passes"]
+        is False
+    )
+    assert (
+        regression._arena_profile_gate(
+            eager_measurements,
+            execution_mode="eager",
+            artifacts=direct,
+        )["passes"]
+        is True
+    )
+    eager_profiles = eager_sample["paired_profile_timing_breakdown"][
+        "raw_profile_samples"
+    ]
+    assert isinstance(eager_profiles, list)
+    eager_profiles[0]["profile_boundary"] = "materialized-native-profile-v1"
+    assert (
+        regression._arena_profile_gate(
+            eager_measurements,
+            execution_mode="eager",
+            artifacts=direct,
+        )["passes"]
+        is False
+    )
+
+    compiled_sample = regression._native_profile_sample(
+        _profile_payload(1.0),
+        minimum_samples=5,
+    )
+    profiles = compiled_sample["paired_profile_timing_breakdown"]["raw_profile_samples"]
+    assert isinstance(profiles, list)
+    profiles[0]["evaluator_backend_call_count"] = 2
+    profiles[0]["stage_input_pack_time_s"] = 1.0e-9
+    compiled = {
+        "current": {
+            "required_runtime_capabilities": [
+                regression.COMPILED_DIRECT_ARENA_CAPABILITY
+            ]
+        }
+    }
+    assert (
+        regression._arena_profile_gate(
+            ({"lane": "current", "pair_index": 1, **compiled_sample},),
+            execution_mode="compiled",
+            artifacts=compiled,
+        )["passes"]
+        is False
+    )
+
+
+def test_profile_command_carries_sampling_and_selector_controls() -> None:
+    command = regression._profile_command(
+        Path("current-python"),
+        artifact=Path("artifact"),
+        process_id="process-id",
+        batch_size=128,
+        target_runtime=7.5,
+        minimum_samples=7,
+        warmup_runs=3,
+        helicities=("h:-1,+1",),
+        color_flows=("flow:1,2",),
+    )
+
+    assert command[:2] == (
+        "current-python",
+        str(regression.NATIVE_SAMPLE_HELPER),
+    )
+    assert command[2] == "artifact"
+    assert command[command.index("--batch-size") + 1] == "128"
+    assert command[command.index("--target-runtime") + 1] == "7.5"
+    assert command[command.index("--minimum-samples") + 1] == "7"
+    assert command[command.index("--warmup-runs") + 1] == "3"
+    assert command[command.index("--profile-protocol") + 1] == (
+        regression.ARENA_PROFILE_PROTOCOL
+    )
+    assert command[command.index("--helicity") + 1] == "h:-1,+1"
+    assert command[command.index("--color-flow") + 1] == "flow:1,2"
+    parsed = compiled_mode_sample.parser().parse_args(command[2:])
+    assert parsed.artifact == Path("artifact")
+    assert parsed.process == "process-id"
+
+
+def test_run_json_routes_the_child_through_fixed_watchdog(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured: dict[str, object] = {}
+
+    class FakeProcess:
+        pid = 123
+        returncode = 0
+
+        def communicate(self, *, timeout: float) -> tuple[str, str]:
+            captured["timeout"] = timeout
+            return '{"ok": true}', WATCHDOG_STDERR
+
+    def fake_popen(command: tuple[str, ...], **kwargs: object) -> FakeProcess:
+        captured["command"] = command
+        captured["kwargs"] = kwargs
+        return FakeProcess()
+
+    monkeypatch.setattr(
+        "tools.developer.compiled_mode_regression.subprocess.Popen",
+        fake_popen,
+    )
+
+    payload, _elapsed, stderr = regression._run_json(
+        ("lane-python", "-m", "pyamplicol", "profile"),
+        timeout=10.0,
+        environment={"PATH": "/bin"},
+    )
+
+    command = captured["command"]
+    assert isinstance(command, tuple)
+    assert command[:6] == (
+        sys.executable,
+        str(regression.WATCHDOG),
+        "--limit-gib",
+        "30",
+        "--",
+        "lane-python",
+    )
+    assert payload == {"ok": True}
+    assert stderr == WATCHDOG_STDERR
+    assert captured["timeout"] == 10.0
+
+
+def test_native_profile_sample_requires_rusticol_marker() -> None:
+    sample = regression._native_profile_sample(
+        _profile_payload(1.25e-6),
+        minimum_samples=5,
+    )
+
+    assert sample["wall_seconds_per_point"] == 1.25e-6
+    assert sample["native_wall_time_source"] == ("runtime_core_repeated_wall_time")
+    assert sample["native_wall_time_sample_pass"] == (
+        regression.NATIVE_WALL_TIME_SAMPLE_PASS
+    )
+    assert sample["timing_sample_contract"] == (
+        regression.PAIRED_TIMING_SAMPLE_CONTRACT
+    )
+    assert sample["profile_timed_block_count"] == 5
+    assert sample["measured_evaluation_count"] == 55
+    assert sample["measured_point_count"] == 55 * 1024
+
+    with pytest.raises(regression.RegressionError, match="native Rusticol"):
+        regression._native_profile_sample(
+            _profile_payload(1.25e-6, source="runtime_evaluate_wall_time"),
+            minimum_samples=5,
+        )
+
+
+def test_current_profile_requires_authenticated_arena_boundary() -> None:
+    arena_payload = _profile_payload(1.25e-6)
+    sample = regression._native_profile_sample(
+        arena_payload,
+        minimum_samples=5,
+        require_arena_profile=True,
+    )
+    assert sample["profile_attribution_sample_pass"] == (
+        regression.PROFILE_ATTRIBUTION_SAMPLE_PASS
+    )
+    assert sample["profile_attribution_boundary"] == (regression.ARENA_PROFILE_BOUNDARY)
+    assert sample["profile_attribution_borrowed_flat_input"] is True
+    assert sample["profile_attribution_preallocated_output"] is True
+    assert sample["profile_attribution_phase_timing_scope"] == (
+        regression.ARENA_PHASE_TIMING_SCOPE
+    )
+    assert sample["profile_attribution_evaluator_timing_available"] is False
+    assert sample["paired_profile_evaluator_seconds_per_point"] is None
+
+    fabricated_evaluator = _profile_payload(1.25e-6)
+    fabricated_evaluator["evaluator_time_per_point"] = 0.0
+    with pytest.raises(regression.RegressionError, match="must record evaluator"):
+        regression._native_profile_sample(
+            fabricated_evaluator,
+            minimum_samples=5,
+            require_arena_profile=True,
+        )
+
+    legacy_payload = _profile_payload(1.25e-6)
+    environment = legacy_payload["environment"]
+    assert isinstance(environment, dict)
+    environment["evaluator_time_sample_pass"] = (
+        regression.FROZEN_BASELINE_PROFILE_ATTRIBUTION_SAMPLE_PASS
+    )
+    environment["timing_breakdown_sample_pass"] = (
+        regression.FROZEN_BASELINE_PROFILE_ATTRIBUTION_SAMPLE_PASS
+    )
+    environment["profile_attribution_boundary"] = (
+        regression.FROZEN_BASELINE_PROFILE_BOUNDARY
+    )
+    environment["profile_attribution_borrowed_flat_input"] = False
+    environment["profile_attribution_preallocated_output"] = False
+    environment["profile_attribution_phase_timing_scope"] = (
+        regression.FROZEN_BASELINE_PHASE_TIMING_SCOPE
+    )
+    environment["profile_attribution_evaluator_timing_available"] = True
+    environment["profile_protocol"] = regression.FROZEN_BASELINE_PROFILE_PROTOCOL
+    legacy_payload["evaluator_time_per_point"] = 0.5e-6
+    legacy_payload["evaluator_uncertainty"] = {"standard_deviation": 0.01e-6}
+    timing_breakdown = legacy_payload["timing_breakdown"]
+    assert isinstance(timing_breakdown, dict)
+    timing_breakdown["evaluator_call_time"] = {
+        "mean_seconds_per_point": 0.5e-6,
+        "sample_count": 5,
+        "samples_seconds_per_point": [0.5e-6] * 5,
+    }
+    regression._native_profile_sample(legacy_payload, minimum_samples=5)
+    with pytest.raises(regression.RegressionError, match="warmed Arena boundary"):
+        regression._native_profile_sample(
+            legacy_payload,
+            minimum_samples=5,
+            require_arena_profile=True,
+        )
+
+
+def test_native_sample_helper_uses_only_explicit_frozen_baseline_protocol() -> None:
+    calls: list[tuple[object, int, dict[str, object]]] = []
+
+    class FrozenRuntime:
+        def profile_repeated(
+            self,
+            batch: object,
+            repetitions: int,
+            **kwargs: object,
+        ) -> dict[str, object]:
+            calls.append((batch, repetitions, dict(kwargs)))
+            return {
+                "execution_mode": "compiled",
+                "wall_time_s": 8.0,
+                "stage_evaluator_call_time_s": 2.0,
+                "amplitude_evaluator_call_time_s": 1.0,
+            }
+
+    runtime = FrozenRuntime()
+    selected = compiled_mode_sample._profile_operation(
+        runtime,
+        protocol=compiled_mode_sample.FROZEN_BASELINE_PROFILE_PROTOCOL,
+    )
+    assert selected.sample_pass == (
+        compiled_mode_sample.FROZEN_BASELINE_PROFILE_ATTRIBUTION_SAMPLE_PASS
+    )
+    assert selected.boundary == (compiled_mode_sample.FROZEN_BASELINE_PROFILE_BOUNDARY)
+    assert selected.phase_timing_scope == (
+        compiled_mode_sample.FROZEN_BASELINE_PHASE_TIMING_SCOPE
+    )
+    assert selected.evaluator_timing_available is True
+    raw = selected.operation(("point",), 4, include_values=False)
+    wall, evaluator = compiled_mode_sample._profile_components(
+        raw,
+        evaluated_points=4,
+        execution_mode="compiled",
+        evaluator_timing_available=selected.evaluator_timing_available,
+    )
+    assert wall == 2.0
+    assert evaluator == 0.75
+    assert calls == [(("point",), 4, {"include_values": False})]
+    with pytest.raises(
+        compiled_mode_sample.SampleError,
+        match="requires _profile_arena_repeated",
+    ):
+        compiled_mode_sample._profile_operation(
+            runtime,
+            protocol=compiled_mode_sample.ARENA_PROFILE_PROTOCOL,
+        )
+
+
+@pytest.mark.parametrize(
+    ("payload", "message"),
+    (
+        (
+            _profile_payload(
+                1.25e-6,
+                sample_pass="runtime.profile_repeated",
+            ),
+            "wall_time_sample_pass",
+        ),
+        (
+            _profile_payload(
+                1.25e-6,
+                timing_contract="shared_native_repeated_profile_v1",
+            ),
+            "timing_sample_contract",
+        ),
+    ),
+)
+def test_native_profile_sample_rejects_profiled_or_unpaired_headlines(
+    payload: dict[str, object],
+    message: str,
+) -> None:
+    with pytest.raises(regression.RegressionError, match=message):
+        regression._native_profile_sample(payload, minimum_samples=5)
+
+
+def test_distribution_reports_median_and_median_absolute_deviation() -> None:
+    summary = regression._distribution((1.0, 2.0, 3.0, 4.0, 100.0))
+
+    assert summary["samples_seconds_per_point"] == [1.0, 2.0, 3.0, 4.0, 100.0]
+    assert summary["median_seconds_per_point"] == 3.0
+    assert summary["mad_seconds_per_point"] == 1.0
+
+
+def test_gate_requires_both_three_percent_and_three_baseline_mad() -> None:
+    baseline = {
+        "median_seconds_per_point": 100.0,
+        "mad_seconds_per_point": 2.0,
+    }
+
+    passing = regression._regression_gate(
+        baseline,
+        {"median_seconds_per_point": 101.9},
+    )
+    relative_failure = regression._regression_gate(
+        baseline,
+        {"median_seconds_per_point": 103.1},
+    )
+    mad_failure = regression._regression_gate(
+        {"median_seconds_per_point": 100.0, "mad_seconds_per_point": 0.1},
+        {"median_seconds_per_point": 101.0},
+    )
+
+    assert passing["passes"] is True
+    assert relative_failure["within_three_percent"] is False
+    assert relative_failure["within_three_baseline_mad"] is True
+    assert relative_failure["passes"] is False
+    assert mad_failure["within_three_percent"] is True
+    assert mad_failure["within_three_baseline_mad"] is False
+    assert mad_failure["passes"] is False
+
+
+def test_performance_authority_requires_shared_or_matching_payloads() -> None:
+    matching_payloads = [
+        {
+            "path": "evaluators.pacbin",
+            "role": "evaluator-state",
+            "sha256": "a" * 64,
+            "size_bytes": 123,
+        }
+    ]
+    artifacts = {
+        lane: {
+            "process_id": "d_dbar_to_z",
+            "color_accuracy": "lc",
+            "lc_flow_layout": "topology-replay",
+            "required_runtime_capabilities": [
+                regression.COMPILED_DIRECT_ARENA_CAPABILITY
+            ],
+            "payload_digests": matching_payloads,
+        }
+        for lane in ("baseline", "current")
+    }
+
+    proven = regression._performance_authority(
+        artifacts,
+        shared_artifact=False,
+    )
+    shared = regression._performance_authority(
+        artifacts,
+        shared_artifact=True,
+    )
+    artifacts["current"] = {
+        **artifacts["current"],
+        "payload_digests": [
+            {
+                **matching_payloads[0],
+                "sha256": "b" * 64,
+            }
+        ],
+    }
+    different = regression._performance_authority(
+        artifacts,
+        shared_artifact=False,
+    )
+
+    assert proven["authoritative"] is True
+    assert proven["basis"] == "matching-performance-relevant-payload-identities"
+    assert shared["authoritative"] is True
+    assert shared["basis"] == "single-read-only-shared-artifact"
+    assert different["authoritative"] is False
+    assert "differ" in different["basis"]
+
+
+def test_correctness_gate_compares_warmed_values_at_contract_tolerances() -> None:
+    def measurement(
+        lane: str,
+        value: float,
+        pair_index: int,
+    ) -> dict[str, object]:
+        def numerical_result(precision: int) -> dict[str, object]:
+            values = [value] * regression.VALIDATION_SAMPLE_COUNT
+            point_sha256 = [
+                f"{index:064x}"
+                for index in range(1, regression.VALIDATION_SAMPLE_COUNT + 1)
+            ]
+            return {
+                "precision": precision,
+                "point_count": regression.VALIDATION_SAMPLE_COUNT,
+                "distinct_point_count": regression.VALIDATION_SAMPLE_COUNT,
+                "point_sha256": point_sha256,
+                "batch_sha256": "d" * 64,
+                "values_f64": values,
+                "values_f64_hex": [entry.hex() for entry in values],
+                "helicities": ["h:-1,+1"],
+                "color_flows": ["flow:1,2"],
+                "resolved": {
+                    "shape": [regression.VALIDATION_SAMPLE_COUNT, 1, 1],
+                    "helicity_ids": ["h:-1,+1"],
+                    "color_ids": ["flow:1,2"],
+                    "totals_complex": [[entry, 0.0] for entry in values],
+                    "values_complex": [[[[entry, 0.0]]] for entry in values],
+                },
+            }
+
+        return {
+            "lane": lane,
+            "pair_index": pair_index,
+            "correctness_point_derivation": _correctness_derivation(
+                [
+                    f"{index:064x}"
+                    for index in range(1, regression.VALIDATION_SAMPLE_COUNT + 1)
+                ]
+            ),
+            "warmed_numerical_result": numerical_result(16),
+            "precision32_numerical_result": (
+                numerical_result(32) if lane == "current" and pair_index == 1 else None
+            ),
+        }
+
+    passing = regression._correctness_gate(
+        (
+            measurement("baseline", 2.5, 1),
+            measurement("current", 2.5 + 2.0e-12, 1),
+        )
+    )
+    failing = regression._correctness_gate(
+        (
+            measurement("baseline", 2.5, 1),
+            measurement("current", 2.5 + 3.0e-11, 1),
+        )
+    )
+
+    assert passing["relative_tolerance"] == 1.0e-12
+    assert passing["absolute_tolerance"] == 1.0e-15
+    assert passing["passes"] is True
+    assert failing["passes"] is False
+    assert failing["comparisons"][1]["passes"] is False
+
+
+def test_native_sample_rejects_inconsistent_totals_and_resolved_shape() -> None:
+    inconsistent_total = _profile_payload(1.0)
+    inconsistent_total["warmed_numerical_result"]["resolved"]["totals_complex"][0] = [
+        999.0,
+        0.0,
+    ]
+    with pytest.raises(regression.RegressionError, match="resolved totals"):
+        regression._native_profile_sample(inconsistent_total, minimum_samples=5)
+
+    inconsistent_shape = _profile_payload(1.0)
+    inconsistent_shape["warmed_numerical_result"]["resolved"]["shape"] = [8, 2, 1]
+    with pytest.raises(regression.RegressionError, match="resolved shape differs"):
+        regression._native_profile_sample(inconsistent_shape, minimum_samples=5)
+
+
+def test_correctness_gate_uses_current_precision32_exact_oracle() -> None:
+    baseline = regression._native_profile_sample(
+        _profile_payload(1.0, include_precision32=False),
+        minimum_samples=5,
+    )
+    current_payload = _profile_payload(1.0)
+    precise = current_payload["precision32_numerical_result"]
+    precise["values_f64"] = [3.0] * regression.VALIDATION_SAMPLE_COUNT
+    precise["values_f64_hex"] = [(3.0).hex()] * regression.VALIDATION_SAMPLE_COUNT
+    precise["resolved"]["totals_complex"] = [
+        [3.0, 0.0]
+    ] * regression.VALIDATION_SAMPLE_COUNT
+    precise["resolved"]["values_complex"] = [
+        [[[3.0, 0.0]]]
+    ] * regression.VALIDATION_SAMPLE_COUNT
+    current = regression._native_profile_sample(
+        current_payload,
+        minimum_samples=5,
+        require_precision32=True,
+    )
+    result = regression._correctness_gate(
+        (
+            {"lane": "baseline", "pair_index": 1, **baseline},
+            {"lane": "current", "pair_index": 1, **current},
+        )
+    )
+    assert result["passes"] is False
+    assert result["precision32_policy"] == regression.PRECISION32_CORRECTNESS_POLICY
+    assert result["precision32_authority_basis"].startswith(
+        "final-candidate-current-exact-oracle"
+    )
+    assert result["precision32_direct_oracle_scope"] == "every-f64-measurement"
+    assert result["precision32_direct_oracle_comparison_count"] == 2
+    assert any(
+        comparison["kind"] == "precision16-vs-current-exact-precision32"
+        and comparison["lane"] == "current"
+        and comparison["passes"] is False
+        for comparison in result["comparisons"]
+    )
+
+
+def test_correctness_gate_does_not_treat_tolerance_as_transitive() -> None:
+    baseline_value = 1.0
+    current_value = 1.0 + 0.9e-12
+    oracle_value = 1.0 + 1.8e-12
+    baseline = regression._native_profile_sample(
+        _profile_payload(
+            1.0,
+            numerical_values=(baseline_value,),
+            include_precision32=False,
+        ),
+        minimum_samples=5,
+    )
+    current_payload = _profile_payload(
+        1.0,
+        numerical_values=(current_value,),
+    )
+    precise = current_payload["precision32_numerical_result"]
+    assert isinstance(precise, dict)
+    precise["values_f64"] = [oracle_value] * regression.VALIDATION_SAMPLE_COUNT
+    precise["values_f64_hex"] = [
+        oracle_value.hex()
+    ] * regression.VALIDATION_SAMPLE_COUNT
+    resolved = precise["resolved"]
+    assert isinstance(resolved, dict)
+    resolved["totals_complex"] = [
+        [oracle_value, 0.0]
+    ] * regression.VALIDATION_SAMPLE_COUNT
+    resolved["values_complex"] = [
+        [[[oracle_value, 0.0]]]
+    ] * regression.VALIDATION_SAMPLE_COUNT
+    current = regression._native_profile_sample(
+        current_payload,
+        minimum_samples=5,
+        require_precision32=True,
+    )
+    baseline_measurement = {"lane": "baseline", "pair_index": 1, **baseline}
+    current_measurement = {"lane": "current", "pair_index": 1, **current}
+    current_exact = current["precision32_numerical_result"]
+    assert isinstance(current_exact, dict)
+
+    assert regression._numerical_comparison(
+        baseline["warmed_numerical_result"],
+        current["warmed_numerical_result"],
+        kind="test-baseline-vs-current",
+        lane="current",
+        pair_index=1,
+    )["passes"]
+    assert regression._numerical_comparison(
+        current_exact,
+        current["warmed_numerical_result"],
+        kind="test-current-vs-oracle",
+        lane="current",
+        pair_index=1,
+    )["passes"]
+
+    result = regression._correctness_gate((baseline_measurement, current_measurement))
+
+    assert result["passes"] is False
+    assert any(
+        comparison["kind"] == "precision16-vs-current-exact-precision32"
+        and comparison["lane"] == "baseline"
+        and comparison["passes"] is False
+        for comparison in result["comparisons"]
+    )
+
+
+@pytest.mark.parametrize(
+    ("baseline_precision32", "current_precision32"),
+    ((True, True), (False, False)),
+)
+def test_correctness_gate_rejects_precision32_policy_drift(
+    baseline_precision32: bool,
+    current_precision32: bool,
+) -> None:
+    baseline = regression._native_profile_sample(
+        _profile_payload(1.0, include_precision32=baseline_precision32),
+        minimum_samples=5,
+    )
+    current = regression._native_profile_sample(
+        _profile_payload(1.0, include_precision32=current_precision32),
+        minimum_samples=5,
+    )
+    with pytest.raises(regression.RegressionError, match="exactly one precision-32"):
+        regression._correctness_gate(
+            (
+                {"lane": "baseline", "pair_index": 1, **baseline},
+                {"lane": "current", "pair_index": 1, **current},
+            )
+        )
+
+
+def _validation_source(
+    point: tuple[tuple[float, float, float, float], ...],
+) -> compiled_mode_sample.ValidationMomentaSource:
+    return compiled_mode_sample.ValidationMomentaSource(
+        points=(point,),
+        identity={
+            "file_sha256": "1" * 64,
+            "canonical_sha256": "2" * 64,
+            "size_bytes": 1024,
+            "process_id": "fixture",
+            "process_expression": "a b > c d",
+            "external_pdgs": [1, -1, 21, 21],
+            "point_count": 1,
+            "selected_point_index": 0,
+            "selected_point_sha256": "3" * 64,
+        },
+    )
+
+
+def _two_body_point(
+    first_mass: float,
+    second_mass: float,
+) -> tuple[tuple[float, float, float, float], ...]:
+    sqrt_s = 1000.0
+    first_energy = (
+        sqrt_s * sqrt_s + first_mass * first_mass - second_mass * second_mass
+    ) / (2.0 * sqrt_s)
+    second_energy = sqrt_s - first_energy
+    spatial = (first_energy * first_energy - first_mass * first_mass) ** 0.5
+    return (
+        (500.0, 0.0, 0.0, 500.0),
+        (500.0, 0.0, 0.0, -500.0),
+        (first_energy, spatial, 0.0, 0.0),
+        (second_energy, -spatial, 0.0, 0.0),
+    )
+
+
+@pytest.mark.parametrize(("first_mass", "second_mass"), ((0.0, 0.0), (100.0, 200.0)))
+def test_correctness_batch_derives_eight_deterministic_varied_invariant_points(
+    first_mass: float,
+    second_mass: float,
+) -> None:
+    source = _validation_source(_two_body_point(first_mass, second_mass))
+
+    first_batch, first_derivation = compiled_mode_sample._correctness_batch(source)
+    second_batch, second_derivation = compiled_mode_sample._correctness_batch(source)
+
+    assert first_batch == second_batch
+    assert first_derivation == second_derivation
+    assert len(first_batch) == regression.VALIDATION_SAMPLE_COUNT
+    assert len(set(first_derivation["point_sha256"])) == len(first_batch)
+    assert len(set(first_derivation["invariant_sha256"])) == len(first_batch)
+    assert first_derivation["batch_sha256"] == compiled_mode_sample._canonical_sha256(
+        first_batch
+    )
+    assert "/" not in json.dumps(first_derivation["numpy"])
+    for point in first_batch:
+        incoming = compiled_mode_sample._sum_momenta(point[:2])
+        outgoing = compiled_mode_sample._sum_momenta(point[2:])
+        assert outgoing == pytest.approx(incoming, rel=0.0, abs=1.0e-8)
+        observed_mass_squared = [
+            compiled_mode_sample._validated_mass_squared(
+                momentum,
+                label="test particle",
+            )
+            for momentum in point
+        ]
+        assert observed_mass_squared == pytest.approx(
+            [0.0, 0.0, first_mass * first_mass, second_mass * second_mass],
+            rel=1.0e-10,
+            abs=1.0e-7,
+        )
+
+
+def test_correctness_batch_snaps_massless_roundoff_before_rambo() -> None:
+    noisy_spatial = math.nextafter(64.0, 0.0)
+    point = (
+        (64.0, 0.0, 0.0, 64.0),
+        (64.0, 0.0, 0.0, -64.0),
+        (64.0, noisy_spatial, 0.0, 0.0),
+        (64.0, -noisy_spatial, 0.0, 0.0),
+    )
+    raw_mass_squared = compiled_mode_sample._minkowski_square(point[2])
+    assert raw_mass_squared > 0.0
+    assert math.sqrt(raw_mass_squared) == pytest.approx(9.5367431640625e-7)
+
+    batch, derivation = compiled_mode_sample._correctness_batch(
+        _validation_source(point)
+    )
+
+    zero_hex = (0.0).hex()
+    assert derivation["external_mass_f64_hex"] == [zero_hex] * 4
+    assert derivation["final_state_mass_f64_hex"] == [zero_hex] * 2
+    for candidate in batch:
+        assert [
+            compiled_mode_sample._validated_mass_squared(
+                momentum,
+                label="test particle",
+            )
+            for momentum in candidate
+        ] == [0.0] * 4
+
+
+@pytest.mark.parametrize(
+    ("point", "message"),
+    (
+        (
+            (
+                (500.0, 0.0, 0.0, 500.0),
+                (500.0, 0.0, 0.0, -400.0),
+                (500.0, 500.0, 0.0, 0.0),
+                (500.0, -500.0, 0.0, 0.0),
+            ),
+            "center-of-mass",
+        ),
+        (
+            (
+                (500.0, 0.0, 0.0, 500.0),
+                (500.0, 0.0, 0.0, -500.0),
+                (500.0, 0.0, 0.0, 0.0),
+                (500.0, 0.0, 0.0, 0.0),
+            ),
+            "strictly above",
+        ),
+    ),
+)
+def test_correctness_batch_rejects_invalid_source_kinematics(
+    point: tuple[tuple[float, float, float, float], ...],
+    message: str,
+) -> None:
+    with pytest.raises(compiled_mode_sample.SampleError, match=message):
+        compiled_mode_sample._correctness_batch(_validation_source(point))
+
+
+def test_correctness_batch_has_bounded_seed_search(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    attempts = 0
+
+    def reject_point(*_args: object, **_kwargs: object) -> object:
+        nonlocal attempts
+        attempts += 1
+        raise compiled_mode_sample.SampleError("rejected fixture")
+
+    monkeypatch.setattr(
+        compiled_mode_sample,
+        "_massive_rambo_final_state",
+        reject_point,
+    )
+    with pytest.raises(compiled_mode_sample.SampleError, match="256 deterministic"):
+        compiled_mode_sample._correctness_batch(
+            _validation_source(_two_body_point(0.0, 0.0))
+        )
+    assert attempts == compiled_mode_sample.MAX_CORRECTNESS_SEED_ATTEMPTS
+
+
+def _write_validation_momenta_artifact(
+    root: Path,
+    *,
+    external_pdgs: list[object] | None = None,
+) -> tuple[Path, tuple[tuple[float, float, float, float], ...]]:
+    process_root = root / "processes" / "fixture"
+    process_root.mkdir(parents=True)
+    point = _two_body_point(0.0, 0.0)
+    pdgs = [1, -1, 21, 21]
+    validation = {
+        "schema_version": 1,
+        "kind": "pyamplicol-rusticol-validation-momenta",
+        "process_id": "fixture",
+        "process": "d d~ > g g",
+        "seed": 12345,
+        "available": True,
+        "error": None,
+        "points": [
+            [
+                {
+                    "pdg": pdg,
+                    "momentum": [str(component) for component in momentum],
+                }
+                for pdg, momentum in zip(pdgs, point, strict=True)
+            ]
+        ],
+    }
+    validation_path = process_root / "validation-momenta.json"
+    validation_path.write_text(json.dumps(validation), encoding="utf-8")
+    manifest = {
+        "processes": [
+            {
+                "id": "fixture",
+                "expression": "d d~ > g g",
+                "external_pdgs": external_pdgs or pdgs,
+            }
+        ],
+        "payloads": [
+            {
+                "path": "processes/fixture/validation-momenta.json",
+                "role": "validation-momenta",
+                "process_id": "fixture",
+                "sha256": regression._sha256_file(validation_path),
+                "size_bytes": validation_path.stat().st_size,
+            }
+        ],
+    }
+    (root / "artifact.json").write_text(json.dumps(manifest), encoding="utf-8")
+    return validation_path, point
+
+
+def test_validation_momenta_authenticates_payload_and_keeps_timing_source(
+    tmp_path: Path,
+) -> None:
+    validation_path, point = _write_validation_momenta_artifact(tmp_path)
+
+    source = compiled_mode_sample._validation_momenta(
+        tmp_path,
+        process="fixture",
+    )
+    timing_batch = compiled_mode_sample._benchmark_batch(source.points, 3)
+    correctness_batch, derivation = compiled_mode_sample._correctness_batch(source)
+
+    assert source.points == (point,)
+    assert source.identity["file_sha256"] == regression._sha256_file(validation_path)
+    assert source.identity["selected_point_sha256"] == (
+        compiled_mode_sample._canonical_sha256(point)
+    )
+    assert timing_batch == (point, point, point)
+    assert all(candidate != point for candidate in correctness_batch)
+    assert derivation["source_validation"] == source.identity
+
+
+def test_validation_momenta_rejects_digest_and_pdg_tampering(
+    tmp_path: Path,
+) -> None:
+    digest_root = tmp_path / "digest"
+    validation_path, _point = _write_validation_momenta_artifact(digest_root)
+    validation_path.write_text("{}\n", encoding="utf-8")
+    with pytest.raises(
+        compiled_mode_sample.SampleError,
+        match="does not match its manifest digest",
+    ):
+        compiled_mode_sample._validation_momenta(
+            digest_root,
+            process="fixture",
+        )
+
+    pdg_root = tmp_path / "pdg"
+    _write_validation_momenta_artifact(
+        pdg_root,
+        external_pdgs=[1, -1, 21, "21"],
+    )
+    with pytest.raises(
+        compiled_mode_sample.SampleError,
+        match="integer PDGs",
+    ):
+        compiled_mode_sample._validation_momenta(
+            pdg_root,
+            process="fixture",
+        )
+
+
+def test_native_sample_rejects_correctness_derivation_tampering() -> None:
+    duplicate_invariant = _profile_payload(1.0)
+    derivation = duplicate_invariant["correctness_point_derivation"]
+    assert isinstance(derivation, dict)
+    invariants = derivation["invariant_sha256"]
+    assert isinstance(invariants, list)
+    invariants[0] = invariants[1]
+    derivation["sha256"] = regression._canonical_sha256(
+        {key: value for key, value in derivation.items() if key != "sha256"}
+    )
+    with pytest.raises(regression.RegressionError, match="not distinct"):
+        regression._native_profile_sample(
+            duplicate_invariant,
+            minimum_samples=5,
+        )
+
+    mismatched_batch = _profile_payload(1.0)
+    derivation = mismatched_batch["correctness_point_derivation"]
+    assert isinstance(derivation, dict)
+    derivation["batch_sha256"] = "e" * 64
+    derivation["sha256"] = regression._canonical_sha256(
+        {key: value for key, value in derivation.items() if key != "sha256"}
+    )
+    with pytest.raises(regression.RegressionError, match="batch digest differs"):
+        regression._native_profile_sample(mismatched_batch, minimum_samples=5)
+
+    pathful_numpy = _profile_payload(1.0)
+    derivation = pathful_numpy["correctness_point_derivation"]
+    assert isinstance(derivation, dict)
+    numpy_identity = derivation["numpy"]
+    assert isinstance(numpy_identity, dict)
+    numpy_identity["origin_file_name"] = "/tmp/numpy/__init__.py"
+    derivation["sha256"] = regression._canonical_sha256(
+        {key: value for key, value in derivation.items() if key != "sha256"}
+    )
+    with pytest.raises(regression.RegressionError, match="path-free"):
+        regression._native_profile_sample(pathful_numpy, minimum_samples=5)
+
+
+def test_correctness_gate_rejects_cross_lane_derivation_mismatch() -> None:
+    baseline = regression._native_profile_sample(
+        _profile_payload(1.0, include_precision32=False),
+        minimum_samples=5,
+    )
+    current_payload = _profile_payload(1.0)
+    derivation = current_payload["correctness_point_derivation"]
+    assert isinstance(derivation, dict)
+    source = derivation["source_validation"]
+    assert isinstance(source, dict)
+    source["file_sha256"] = "f" * 64
+    derivation["sha256"] = regression._canonical_sha256(
+        {key: value for key, value in derivation.items() if key != "sha256"}
+    )
+    current = regression._native_profile_sample(
+        current_payload,
+        minimum_samples=5,
+    )
+
+    with pytest.raises(regression.RegressionError, match="byte-identical"):
+        regression._correctness_gate(
+            (
+                {"lane": "baseline", "pair_index": 1, **baseline},
+                {"lane": "current", "pair_index": 1, **current},
+            )
+        )
+
+
+def test_dependency_site_identity_tracks_distribution_content(tmp_path: Path) -> None:
+    for distribution_name, import_name in regression.DEPENDENCY_DISTRIBUTIONS:
+        package_root = tmp_path / import_name
+        package_root.mkdir()
+        (package_root / "__init__.py").write_text(
+            f'VERSION = "{distribution_name}"\n',
+            encoding="utf-8",
+        )
+        metadata_stem = distribution_name.replace("-", "_")
+        metadata = tmp_path / f"{metadata_stem}-1.0.dist-info"
+        metadata.mkdir()
+        (metadata / "METADATA").write_text(
+            f"Metadata-Version: 2.1\nName: {distribution_name}\nVersion: 1.0\n",
+            encoding="utf-8",
+        )
+        (metadata / "RECORD").write_text(
+            f"{import_name}/__init__.py,,\n"
+            f"{metadata_stem}-1.0.dist-info/METADATA,,\n"
+            f"{metadata_stem}-1.0.dist-info/RECORD,,\n",
+            encoding="utf-8",
+        )
+    before = regression._dependency_site_identity(tmp_path)
+    (tmp_path / "numpy" / "__init__.py").write_text(
+        'VERSION = "changed"\n',
+        encoding="utf-8",
+    )
+    after = regression._dependency_site_identity(tmp_path)
+    assert before["sha256"] != after["sha256"]
+
+
+def test_exact_identities_cover_file_tree_model_and_command_bytes(
+    tmp_path: Path,
+) -> None:
+    first = tmp_path / "first"
+    second = tmp_path / "second"
+    for root in (first, second):
+        (root / "nested").mkdir(parents=True)
+        (root / "nested" / "payload.bin").write_bytes(b"same bytes")
+
+    first_tree = regression._tree_identity(first)
+    second_tree = regression._tree_identity(second)
+    assert first_tree == second_tree
+    assert first_tree["file_count"] == 1
+
+    model = tmp_path / "model.json"
+    model.write_text('{"model": 1}\n', encoding="utf-8")
+    model_identity = regression._model_identity(str(model))
+    assert model_identity["sha256"] == regression._sha256_file(model)
+
+    command = regression._command_identity(("python", "helper.py", "--value", "1"))
+    assert command == regression._command_identity(
+        ("python", "helper.py", "--value", "1")
+    )
+    assert command != regression._command_identity(
+        ("python", "helper.py", "--value", "2")
+    )
+
+    (second / "nested" / "payload.bin").write_bytes(b"changed bytes")
+    assert regression._tree_identity(second)["sha256"] != first_tree["sha256"]
+
+
+def test_artifact_metadata_records_exact_tree_and_requires_requested_layout(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_artifact(artifact)
+
+    metadata = regression._artifact_metadata(
+        artifact,
+        expected_process="d d~ > Z",
+        expected_color="lc",
+        expected_lc_flow_layout="topology-replay",
+    )
+
+    assert metadata["manifest_sha256"] == regression._sha256_file(
+        artifact / "artifact.json"
+    )
+    assert metadata["lc_flow_layout"] == "topology-replay"
+    assert metadata["size_bytes"] == metadata["tree_identity"]["size_bytes"]
+    assert metadata["payload_digests"] == [
+        {
+            "path": "payload.bin",
+            "role": "evaluator-state",
+            "sha256": regression._sha256_file(artifact / "payload.bin"),
+            "size_bytes": len(b"compiled-payload"),
+        }
+    ]
+    with pytest.raises(regression.RegressionError, match="LC flow layout"):
+        regression._artifact_metadata(
+            artifact,
+            expected_process="d d~ > z",
+            expected_color="lc",
+            expected_lc_flow_layout="all-flow-union",
+        )
+    (artifact / "payload.bin").write_bytes(b"tampered")
+    with pytest.raises(regression.RegressionError, match="declared digest"):
+        regression._artifact_metadata(
+            artifact,
+            expected_process="d d~ > z",
+            expected_color="lc",
+            expected_lc_flow_layout="topology-replay",
+        )
+
+
+def test_matching_artifact_cache_avoids_generation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    python = Path(sys.executable)
+    artifact = tmp_path / "baseline" / "artifact"
+    cache_path = tmp_path / "baseline" / "artifact-cache.json"
+    _write_artifact(artifact)
+    signature = regression._generation_signature(
+        python,
+        installation_identity={
+            "kind": regression.INSTALLATION_IDENTITY_KIND,
+            "schema_version": regression.INSTALLATION_IDENTITY_SCHEMA_VERSION,
+            "distribution_content": {"sha256": "e" * 64},
+            "native_modules": [{"sha256": "f" * 64}],
+        },
+        process="d d~ > z",
+        model="built-in-sm",
+        color="lc",
+        artifact=artifact,
+    )
+    metadata = regression._artifact_metadata(
+        artifact,
+        expected_process="d d~ > z",
+        expected_color="lc",
+        expected_lc_flow_layout="topology-replay",
+    )
+    tree_identity = metadata["tree_identity"]
+    assert isinstance(tree_identity, dict)
+    regression._write_json_atomic(
+        cache_path,
+        {
+            "kind": regression.CACHE_KIND,
+            "schema_version": regression.CACHE_SCHEMA_VERSION,
+            "signature": signature,
+            "artifact_id": "artifact-id",
+            "artifact_tree_sha256": tree_identity["sha256"],
+        },
+    )
+
+    def unexpected_run(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("generation must be skipped for a matching cache")
+
+    monkeypatch.setattr(regression, "_run_json", unexpected_run)
+    monkeypatch.setattr(
+        regression,
+        "_installed_pyamplicol_identity",
+        lambda *_args, **_kwargs: {
+            "kind": regression.INSTALLATION_IDENTITY_KIND,
+            "schema_version": regression.INSTALLATION_IDENTITY_SCHEMA_VERSION,
+            "distribution_content": {"sha256": "e" * 64},
+            "native_modules": [{"sha256": "f" * 64}],
+        },
+    )
+
+    result = regression._ensure_artifact(
+        "baseline",
+        python,
+        output_root=tmp_path,
+        process="d d~ > z",
+        model="built-in-sm",
+        color="lc",
+        generation_timeout=300.0,
+        regenerate=False,
+        environment={},
+    )
+
+    assert result["reused"] is True
+    assert result["generation"] is None
+    assert result["artifact_id"] == "artifact-id"
+
+
+def test_generation_signature_tracks_reinstalled_pyamplicol_content(
+    tmp_path: Path,
+) -> None:
+    python = Path(sys.executable)
+    common = {
+        "kind": regression.INSTALLATION_IDENTITY_KIND,
+        "schema_version": regression.INSTALLATION_IDENTITY_SCHEMA_VERSION,
+        "native_modules": [{"sha256": "a" * 64}],
+    }
+    first = regression._generation_signature(
+        python,
+        installation_identity={
+            **common,
+            "distribution_content": {"sha256": "b" * 64},
+            "build_info_files": [{"sha256": "c" * 64}],
+        },
+        process="d d~ > z",
+        model="built-in-sm",
+        color="lc",
+        artifact=tmp_path / "artifact",
+    )
+    reinstalled = regression._generation_signature(
+        python,
+        installation_identity={
+            **common,
+            "distribution_content": {"sha256": "d" * 64},
+            "build_info_files": [{"sha256": "e" * 64}],
+        },
+        process="d d~ > z",
+        model="built-in-sm",
+        color="lc",
+        artifact=tmp_path / "artifact",
+    )
+
+    assert first["python"] == reinstalled["python"]
+    assert first["installed_pyamplicol"] != reinstalled["installed_pyamplicol"]
+    assert first != reinstalled
+
+
+def test_generation_signature_tracks_dependency_entry_content(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    python = Path(sys.executable)
+    installation = {
+        "kind": regression.INSTALLATION_IDENTITY_KIND,
+        "schema_version": regression.INSTALLATION_IDENTITY_SCHEMA_VERSION,
+        "distribution_content": {"sha256": "b" * 64},
+        "native_modules": [{"sha256": "a" * 64}],
+    }
+    original_path_identity = regression._path_identity
+    dependency_digest = "c" * 64
+
+    def path_identity(path: Path) -> dict[str, object]:
+        identity = original_path_identity(path)
+        if path == regression.DEPENDENCY_ENTRY:
+            identity["sha256"] = dependency_digest
+        return identity
+
+    monkeypatch.setattr(regression, "_path_identity", path_identity)
+    first = regression._generation_signature(
+        python,
+        installation_identity=installation,
+        process="d d~ > z",
+        model="built-in-sm",
+        color="lc",
+        artifact=tmp_path / "artifact",
+    )
+    dependency_digest = "d" * 64
+    second = regression._generation_signature(
+        python,
+        installation_identity=installation,
+        process="d d~ > z",
+        model="built-in-sm",
+        color="lc",
+        artifact=tmp_path / "artifact",
+    )
+
+    assert first["dependency_entry"] != second["dependency_entry"]
+    assert first != second
+
+
+def test_regression_environment_disables_python_bytecode_writes(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYTHONDONTWRITEBYTECODE", "0")
+
+    environment = regression._environment()
+
+    assert environment["PYTHONDONTWRITEBYTECODE"] == "1"
+
+
+def test_eager_artifact_is_never_accepted_as_compiled(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    _write_artifact(artifact, eager=True)
+
+    with pytest.raises(regression.RegressionError, match="not compiled mode"):
+        regression._artifact_metadata(
+            artifact,
+            expected_process="d d~ > z",
+            expected_color="lc",
+        )
+
+
+def test_run_regression_reuses_one_read_only_shared_artifact(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    baseline_python = tmp_path / "baseline-python"
+    current_python = tmp_path / "current-python"
+    for python in (baseline_python, current_python):
+        python.write_text("", encoding="utf-8")
+        python.chmod(0o755)
+    artifact = tmp_path / "retained-artifact"
+    _write_artifact(artifact)
+    original_payload = (artifact / "payload.bin").read_bytes()
+    observed_commands: list[tuple[str, ...]] = []
+
+    def unexpected_generation(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("shared artifact mode must not generate an artifact")
+
+    def fake_run(
+        command: tuple[str, ...],
+        *,
+        timeout: float,
+        environment: dict[str, str],
+    ) -> tuple[dict[str, object], float, str]:
+        del timeout
+        assert "PYTHONPATH" not in environment
+        assert Path(command[2]) == artifact
+        observed_commands.append(command)
+        return (
+            _profile_payload_for_command(command, 1.0, batch_size=4),
+            0.25,
+            WATCHDOG_STDERR,
+        )
+
+    monkeypatch.setattr(regression, "_ensure_artifact", unexpected_generation)
+    monkeypatch.setattr(regression, "_run_json", fake_run)
+    arguments = argparse.Namespace(
+        baseline_python=baseline_python,
+        current_python=current_python,
+        output_root=tmp_path / "output",
+        shared_artifact=artifact,
+        process="d d~ > z",
+        model="built-in-sm",
+        color="lc",
+        lc_flow_layout="topology-replay",
+        batch_size=4,
+        samples=5,
+        target_runtime=5.0,
+        minimum_samples=5,
+        warmup_runs=2,
+        helicity=[],
+        color_flow=[],
+        generation_timeout=300.0,
+        profile_timeout=120.0,
+        regenerate_artifacts=False,
+    )
+
+    result = regression.run_regression(arguments)
+
+    assert len(observed_commands) == 10
+    assert (artifact / "payload.bin").read_bytes() == original_payload
+    assert result["configuration"]["shared_artifact"] == str(artifact)
+    assert result["resources"]["generation_subprocess_count"] == 0
+    assert {lane: value["path"] for lane, value in result["artifacts"].items()} == {
+        "baseline": str(artifact),
+        "current": str(artifact),
+    }
+    assert all(
+        value["shared"] is True
+        and value["payload_digest_count"] == 1
+        and value["comparison_role"] == "shared-read-only-artifact"
+        for value in result["artifacts"].values()
+    )
+    assert result["performance_authority"]["authoritative"] is True
+    assert result["performance_result_authoritative"] is True
+    assert result["gate"]["authoritative"] is True
+    assert result["correctness_gate"]["passes"] is True
+
+
+def test_run_regression_rejects_native_module_change_within_lane(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    baseline_python = tmp_path / "baseline-python"
+    current_python = tmp_path / "current-python"
+    for python in (baseline_python, current_python):
+        python.write_text("", encoding="utf-8")
+        python.chmod(0o755)
+    artifact = tmp_path / "retained-artifact"
+    _write_artifact(artifact)
+    lane_calls = {"baseline": 0, "current": 0}
+
+    def fake_run(
+        command: tuple[str, ...],
+        *,
+        timeout: float,
+        environment: dict[str, str],
+    ) -> tuple[dict[str, object], float, str]:
+        del timeout, environment
+        lane = "baseline" if Path(command[0]) == baseline_python else "current"
+        lane_calls[lane] += 1
+        native_sha256 = (
+            "b" * 64 if lane == "baseline" and lane_calls[lane] > 1 else "a" * 64
+        )
+        return (
+            _profile_payload_for_command(
+                command,
+                1.0,
+                native_module_sha256=native_sha256,
+            ),
+            0.25,
+            WATCHDOG_STDERR,
+        )
+
+    monkeypatch.setattr(regression, "_run_json", fake_run)
+    arguments = argparse.Namespace(
+        baseline_python=baseline_python,
+        current_python=current_python,
+        output_root=tmp_path / "output",
+        shared_artifact=artifact,
+        process="d d~ > z",
+        model="built-in-sm",
+        color="lc",
+        lc_flow_layout="topology-replay",
+        batch_size=1024,
+        samples=5,
+        target_runtime=5.0,
+        minimum_samples=5,
+        warmup_runs=2,
+        helicity=[],
+        color_flow=[],
+        generation_timeout=300.0,
+        profile_timeout=120.0,
+        regenerate_artifacts=False,
+    )
+
+    with pytest.raises(
+        regression.RegressionError,
+        match="baseline native module changed during sampling",
+    ):
+        regression.run_regression(arguments)
+
+
+def test_run_regression_reports_independent_alternating_samples(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    baseline_python = tmp_path / "baseline-python"
+    current_python = tmp_path / "current-python"
+    for python in (baseline_python, current_python):
+        python.write_text("", encoding="utf-8")
+        python.chmod(0o755)
+
+    output_root = tmp_path / "output"
+    artifacts: dict[str, dict[str, object]] = {
+        lane: {
+            "artifact_id": f"{lane}-artifact",
+            "path": str(output_root / lane / "artifact"),
+            "process_id": "d_dbar_to_z",
+            "process_expression": "d d~ > z",
+            "color_accuracy": "lc",
+            "lc_flow_layout": "topology-replay",
+            "required_runtime_capabilities": [
+                regression.COMPILED_DIRECT_ARENA_CAPABILITY
+            ],
+            "manifest_sha256": ("a" if lane == "baseline" else "b") * 64,
+            "tree_identity": {
+                "sha256": ("c" if lane == "baseline" else "d") * 64,
+            },
+            "payload_digests": [],
+            "size_bytes": 100,
+            "producer": {"version": lane},
+            "reused": True,
+            "generation": None,
+            "cache_path": str(output_root / lane / "artifact-cache.json"),
+        }
+        for lane in ("baseline", "current")
+    }
+
+    def fake_ensure(lane: str, *_args: object, **_kwargs: object) -> dict[str, object]:
+        return artifacts[lane]
+
+    baseline_values = iter((1.00, 1.01, 0.99, 1.005, 0.995))
+    current_values = iter((1.005, 1.006, 1.004, 1.005, 1.005))
+    observed_order: list[str] = []
+
+    def fake_run(
+        command: tuple[str, ...],
+        *,
+        timeout: float,
+        environment: dict[str, str],
+    ) -> tuple[dict[str, object], float, str]:
+        del timeout
+        assert "PYTHONPATH" not in environment
+        assert command[1] == str(regression.NATIVE_SAMPLE_HELPER)
+        artifact = Path(command[2])
+        lane = artifact.parent.name
+        observed_order.append(lane)
+        value = next(baseline_values if lane == "baseline" else current_values)
+        return (
+            _profile_payload_for_command(command, value),
+            0.25,
+            WATCHDOG_STDERR,
+        )
+
+    monkeypatch.setattr(regression, "_ensure_artifact", fake_ensure)
+    monkeypatch.setattr(regression, "_run_json", fake_run)
+    monkeypatch.setattr(
+        regression,
+        "_artifact_metadata",
+        lambda artifact, **_kwargs: artifacts[artifact.parent.name],
+    )
+    arguments = argparse.Namespace(
+        baseline_python=baseline_python,
+        current_python=current_python,
+        output_root=output_root,
+        process="d d~ > z",
+        model="built-in-sm",
+        color="lc",
+        batch_size=1024,
+        samples=5,
+        target_runtime=5.0,
+        minimum_samples=5,
+        warmup_runs=2,
+        helicity=[],
+        color_flow=[],
+        generation_timeout=300.0,
+        profile_timeout=120.0,
+        regenerate_artifacts=False,
+    )
+
+    result = regression.run_regression(arguments)
+
+    assert observed_order == [
+        "baseline",
+        "current",
+        "current",
+        "baseline",
+        "baseline",
+        "current",
+        "current",
+        "baseline",
+        "baseline",
+        "current",
+    ]
+    assert result["complete"] is True
+    assert result["passes"] is False
+    assert result["performance_result_authoritative"] is False
+    assert result["gate"]["measured_thresholds_pass"] is True
+    assert result["gate"]["authoritative"] is False
+    assert result["gate"]["passes"] is False
+    assert result["performance_authority"]["comparison_mode"] == (
+        "independently-generated-artifacts"
+    )
+    assert result["distributions"]["baseline"]["sample_count"] == 5
+    assert result["distributions"]["current"]["sample_count"] == 5
+    assert result["resources"]["profile_subprocess_count"] == 10
+    assert result["resources"]["generation_subprocess_count"] == 0
+    assert result["native_module_sha256_by_lane"] == {
+        "baseline": "a" * 64,
+        "current": "a" * 64,
+    }
+    assert result["configuration"]["lc_flow_layout"] == "topology-replay"
+    assert result["configuration"]["precision32_correctness_policy"] == (
+        regression.PRECISION32_CORRECTNESS_POLICY
+    )
+    precision32_commands = [
+        measurement
+        for measurement in result["measurements"]
+        if "--include-precision32" in measurement["command"]["argv"]
+    ]
+    assert [
+        (measurement["lane"], measurement["pair_index"])
+        for measurement in precision32_commands
+    ] == [("current", 1)]
+    assert result["correctness_gate"]["precision32_measurement_count"] == 1
+    assert result["configuration"]["native_wall_time_sample_pass"] == (
+        regression.NATIVE_WALL_TIME_SAMPLE_PASS
+    )
+    assert all(
+        measurement["native_wall_time_source"] == regression.NATIVE_WALL_TIME_SOURCE
+        for measurement in result["measurements"]
+    )
+    assert all(
+        measurement["command"]["argv"][1] == str(regression.NATIVE_SAMPLE_HELPER)
+        for measurement in result["measurements"]
+    )
+    assert result["provenance"]["native_sample_helper"]["sha256"] == (
+        regression._sha256_file(regression.NATIVE_SAMPLE_HELPER)
+    )
+    persisted = json.loads((output_root / "result.json").read_text(encoding="utf-8"))
+    assert persisted["complete"] is True
+    assert persisted["gate"] == result["gate"]
+
+
+def test_run_regression_rehashes_generated_artifacts_after_sampling(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    baseline_python = tmp_path / "baseline-python"
+    current_python = tmp_path / "current-python"
+    for python in (baseline_python, current_python):
+        python.write_text("", encoding="utf-8")
+        python.chmod(0o755)
+    output_root = tmp_path / "output"
+    artifacts: dict[str, dict[str, object]] = {}
+    for lane in ("baseline", "current"):
+        path = output_root / lane / "artifact"
+        _write_artifact(path, artifact_id=f"{lane}-artifact")
+        artifacts[lane] = {
+            **regression._artifact_metadata(
+                path,
+                expected_process="d d~ > z",
+                expected_color="lc",
+                expected_lc_flow_layout="topology-replay",
+            ),
+            "reused": True,
+            "generation": None,
+            "cache_path": str(output_root / lane / "artifact-cache.json"),
+        }
+
+    def fake_ensure(lane: str, *_args: object, **_kwargs: object) -> dict[str, object]:
+        return artifacts[lane]
+
+    sample_calls = 0
+
+    def fake_run(
+        command: tuple[str, ...],
+        *,
+        timeout: float,
+        environment: dict[str, str],
+    ) -> tuple[dict[str, object], float, str]:
+        nonlocal sample_calls
+        del timeout, environment
+        sample_calls += 1
+        if sample_calls == 10:
+            (output_root / "current" / "artifact" / "late-file.bin").write_bytes(
+                b"mutation"
+            )
+        return (
+            _profile_payload_for_command(command, 1.0),
+            0.25,
+            WATCHDOG_STDERR,
+        )
+
+    monkeypatch.setattr(regression, "_ensure_artifact", fake_ensure)
+    monkeypatch.setattr(regression, "_run_json", fake_run)
+    arguments = argparse.Namespace(
+        baseline_python=baseline_python,
+        current_python=current_python,
+        output_root=output_root,
+        process="d d~ > z",
+        model="built-in-sm",
+        color="lc",
+        batch_size=1024,
+        samples=5,
+        target_runtime=5.0,
+        minimum_samples=5,
+        warmup_runs=2,
+        helicity=[],
+        color_flow=[],
+        generation_timeout=300.0,
+        profile_timeout=120.0,
+        regenerate_artifacts=False,
+    )
+
+    with pytest.raises(
+        regression.RegressionError,
+        match="current artifact changed during sampling: tree_identity differs",
+    ):
+        regression.run_regression(arguments)
+
+
+def test_native_sample_helper_pairs_direct_wall_and_profile_calls(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    native_module = tmp_path / "native-module.so"
+    native_module.write_bytes(b"native-module")
+
+    class FakeResolved:
+        helicity_ids = ("h:-1,+1",)
+        color_ids = ("flow:1,2",)
+
+        def __init__(self, point_count: int) -> None:
+            self.shape = (point_count, 1, 1)
+            self.values = tuple(((2.5 + 0.0j,),) for _ in range(point_count))
+
+        def total(self) -> tuple[complex, ...]:
+            return tuple(2.5 + 0.0j for _ in range(self.shape[0]))
+
+    class FakeRuntime:
+        def __init__(self) -> None:
+            self._native_module = SimpleNamespace(__file__=str(native_module))
+            self.wall_calls: list[tuple[int, int, dict[str, object]]] = []
+            self.wall_batches: list[tuple[object, ...]] = []
+            self.profile_calls: list[tuple[int, int, dict[str, object]]] = []
+            self.evaluate_calls: list[tuple[int, dict[str, object]]] = []
+
+        def metadata_json(self) -> str:
+            return '{"execution_mode": "compiled"}'
+
+        def _benchmark_f64_wall_time(
+            self,
+            batch: tuple[object, ...],
+            repetitions: int,
+            **kwargs: object,
+        ) -> float:
+            self.wall_calls.append((id(batch), repetitions, dict(kwargs)))
+            self.wall_batches.append(batch)
+            return repetitions * 0.01
+
+        def profile_repeated(
+            self,
+            _batch: tuple[object, ...],
+            _repetitions: int,
+            **_kwargs: object,
+        ) -> dict[str, object]:
+            raise AssertionError("current sampling used the legacy profiler")
+
+        def _profile_arena_repeated(
+            self,
+            batch: tuple[object, ...],
+            repetitions: int,
+            **kwargs: object,
+        ) -> dict[str, object]:
+            self.profile_calls.append((id(batch), repetitions, dict(kwargs)))
+            points = repetitions * len(batch)
+            return {
+                "execution_mode": "compiled",
+                "profile_boundary": compiled_mode_sample.ARENA_PROFILE_BOUNDARY,
+                "borrowed_flat_input": True,
+                "preallocated_output": True,
+                "phase_timing_scope": compiled_mode_sample.ARENA_PHASE_TIMING_SCOPE,
+                "evaluator_timing_available": False,
+                "wall_time_s": points * 0.007,
+                "stage_evaluator_call_time_s": points * 0.003,
+                "amplitude_evaluator_call_time_s": points * 0.001,
+                "native_input_container_allocation_count": 0,
+                "native_output_allocation_count": 0,
+                "stage_input_copy_component_count": 0,
+            }
+
+        def evaluate(
+            self,
+            batch: tuple[object, ...],
+            **kwargs: object,
+        ) -> list[float]:
+            self.evaluate_calls.append((id(batch), dict(kwargs)))
+            return [2.5] * len(batch)
+
+        def evaluate_resolved(
+            self,
+            batch: tuple[object, ...],
+            **kwargs: object,
+        ) -> FakeResolved:
+            self.evaluate_calls.append((id(batch), dict(kwargs)))
+            return FakeResolved(len(batch))
+
+    runtime = FakeRuntime()
+    monkeypatch.setattr(
+        compiled_mode_sample,
+        "_load_runtime",
+        lambda *_args, **_kwargs: (
+            runtime,
+            {"native_module": {"sha256": "b" * 64}},
+        ),
+    )
+    monkeypatch.setattr(
+        compiled_mode_sample,
+        "_load_public_runtime",
+        lambda *_args, **_kwargs: runtime,
+    )
+    monkeypatch.setattr(
+        compiled_mode_sample,
+        "_validation_momenta",
+        lambda *_args, **_kwargs: _validation_source(_two_body_point(0.0, 0.0)),
+    )
+    monkeypatch.setattr(
+        compiled_mode_sample,
+        "_resolve_color_flows",
+        lambda _artifact, *, process, requested: tuple(requested),
+    )
+    monkeypatch.setattr(
+        compiled_mode_sample,
+        "_resolve_helicities",
+        lambda _artifact, *, process, requested: tuple(requested),
+    )
+    artifact = tmp_path / "artifact"
+    artifact.mkdir()
+    arguments = argparse.Namespace(
+        artifact=artifact,
+        process="d_dbar_to_z",
+        profile_protocol=compiled_mode_sample.ARENA_PROFILE_PROTOCOL,
+        target_runtime=0.05,
+        batch_size=2,
+        minimum_samples=5,
+        warmup_runs=1,
+        include_precision32=True,
+        helicity=["h:-1,+1"],
+        color_flow=["flow:1,2"],
+    )
+
+    result = compiled_mode_sample.sample(arguments)
+
+    assert result["wall_time_per_point"] == pytest.approx(0.005)
+    breakdown = result["timing_breakdown"]
+    assert isinstance(breakdown, dict)
+    profile_wall = breakdown["wall_time"]
+    assert isinstance(profile_wall, dict)
+    assert profile_wall["mean_seconds_per_point"] == pytest.approx(0.007)
+    measured = regression._native_profile_sample(
+        result,
+        minimum_samples=5,
+        batch_size=2,
+        require_arena_profile=True,
+    )
+    assert measured["wall_seconds_per_point"] == pytest.approx(0.005)
+    assert measured["paired_profile_wall_seconds_per_point"] == pytest.approx(0.007)
+    assert measured["paired_profile_evaluator_seconds_per_point"] is None
+    assert measured["paired_profile_evaluator_uncertainty"] is None
+    assert measured["profile_attribution_sample_pass"] == (
+        regression.PROFILE_ATTRIBUTION_SAMPLE_PASS
+    )
+    assert measured["profile_attribution_boundary"] == (
+        regression.ARENA_PROFILE_BOUNDARY
+    )
+    assert measured["profile_attribution_phase_timing_scope"] == (
+        regression.ARENA_PHASE_TIMING_SCOPE
+    )
+    assert measured["profile_attribution_evaluator_timing_available"] is False
+    assert measured["warmed_numerical_result"]["values_f64"] == [2.5] * 8
+    assert measured["precision32_numerical_result"]["values_f64"] == [2.5] * 8
+    derivation = measured["correctness_point_derivation"]
+    assert (
+        derivation["batch_sha256"]
+        == (measured["warmed_numerical_result"]["batch_sha256"])
+    )
+    assert (
+        derivation["point_sha256"]
+        == (measured["warmed_numerical_result"]["point_sha256"])
+    )
+    assert len(runtime.wall_calls) == 7
+    source_point = _two_body_point(0.0, 0.0)
+    assert all(batch == (source_point, source_point) for batch in runtime.wall_batches)
+    assert len(runtime.profile_calls) == 6
+    assert len(runtime.evaluate_calls) == 4
+    assert runtime.evaluate_calls[0][1] == {
+        "helicities": ("h:-1,+1",),
+        "color_flows": ("flow:1,2",),
+        "precision": 16,
+    }
+    assert runtime.evaluate_calls[2][1] == {
+        "helicities": ("h:-1,+1",),
+        "color_flows": ("flow:1,2",),
+        "precision": 32,
+    }
+    for wall_call, profile_call in zip(
+        runtime.wall_calls[-5:],
+        runtime.profile_calls[-5:],
+        strict=True,
+    ):
+        assert wall_call[:2] == profile_call[:2]
+        assert wall_call[2] == {
+            "helicities": ("h:-1,+1",),
+            "color_flows": ("flow:1,2",),
+            "precision": 16,
+        }
+        assert profile_call[2] == {
+            **wall_call[2],
+            "include_values": False,
+        }
diff --git a/pyamplicol/tests/unit/test_compiled_model_and_dry_run.py b/pyamplicol/tests/unit/test_compiled_model_and_dry_run.py
new file mode 100644
index 0000000000..014684c683
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiled_model_and_dry_run.py
@@ -0,0 +1,642 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import io
+import json
+import os
+import stat
+import subprocess
+import sys
+from pathlib import Path
+from typing import Literal, cast
+
+import pytest
+
+import pyamplicol.api.services as api_services
+import pyamplicol.generation.service as generation_service
+import pyamplicol.licensing as licensing
+import pyamplicol.models.loading as model_loading
+from pyamplicol import (
+    CompiledModel,
+    Generator,
+    ModelSource,
+    ProcessSet,
+    generate,
+)
+from pyamplicol.api.errors import GenerationError
+from pyamplicol.api.results import GenerationResult
+from pyamplicol.cli import run_cli
+from pyamplicol.config import (
+    Action,
+    ConfigResolution,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    ModelConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from pyamplicol.licensing import SymbolicaLicenseState
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.prepared_target import canonical_architecture
+
+
+def _snapshot(root: Path) -> tuple[tuple[str, int, int, int, bytes | None], ...]:
+    paths = (root, *sorted(root.rglob("*")))
+    result: list[tuple[str, int, int, int, bytes | None]] = []
+    for path in paths:
+        metadata = path.lstat()
+        relative = "." if path == root else path.relative_to(root).as_posix()
+        payload = path.read_bytes() if stat.S_ISREG(metadata.st_mode) else None
+        result.append(
+            (
+                relative,
+                metadata.st_mode,
+                metadata.st_size,
+                metadata.st_mtime_ns,
+                payload,
+            )
+        )
+    return tuple(result)
+
+
+def _forbidden(name: str):
+    def fail(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError(f"dry-run called forbidden operation: {name}")
+
+    return fail
+
+
+def _restricted_license(**_kwargs: object) -> SymbolicaLicenseState:
+    return SymbolicaLicenseState(licensed=False, restricted=True)
+
+
+def test_external_multiparticle_filter_keeps_only_color_ready_children() -> None:
+    candidates = tuple(
+        build_process_ir(process, color_accuracy="lc")
+        for process in (
+            "d d > z d d~",
+            "d d > z d d",
+            "d d~ > z g g",
+        )
+    )
+
+    selected, rejected = generation_service._select_color_ready_processes(
+        candidates,
+        color_accuracy="lc",
+    )
+
+    assert tuple(process.process for process in selected) == (
+        "d d > z d d",
+        "d d~ > z g g",
+    )
+    assert len(rejected) == 1
+    assert rejected[0].startswith("d d > z d d~:")
+
+
+def test_external_multiparticle_expansion_reuses_side_permuted_representatives(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    compiled = ModelSource.built_in_sm().compile(use_cache=False)
+    plan = Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            process=ProcessConfig(
+                multiparticles={"p": ("d", "d~", "g"), "j": ("d", "d~", "g")},
+                flavor_scheme=2,
+                max_quark_lines=2,
+            ),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        )
+    ).plan(
+        ProcessSet.from_expressions(
+            ("p p > z j j",),
+            names=("p_p_to_z_j_j",),
+        ),
+        model=compiled,
+    )
+
+    assert tuple(
+        (process.name, process.expression) for process in plan.concrete_processes
+    ) == (
+        ("p_p_to_z_j_j_1", "d d > z d d"),
+        ("p_p_to_z_j_j_2", "d d~ > z d d~"),
+        ("p_p_to_z_j_j_3", "d d~ > z g g"),
+        ("p_p_to_z_j_j_4", "d g > z d g"),
+        ("p_p_to_z_j_j_7", "d~ d~ > z d~ d~"),
+        ("p_p_to_z_j_j_8", "d~ g > z d~ g"),
+        ("p_p_to_z_j_j_11", "g g > z d d~"),
+    )
+
+
+def test_model_compilation_returns_the_canonical_public_model(tmp_path: Path) -> None:
+    from pyamplicol.api.models import _compiled_model_payload
+    from pyamplicol.models.loading import CompiledModel as LoadingCompiledModel
+
+    compiled = ModelSource.built_in_sm().compile(use_cache=False)
+
+    assert isinstance(compiled, CompiledModel)
+    assert isinstance(_compiled_model_payload(compiled), LoadingCompiledModel)
+    assert compiled.name == "built-in-sm"
+    assert compiled.schema_version == model_loading.COMPILED_MODEL_SCHEMA_VERSION
+    assert compiled.model_compiler_version == model_loading.MODEL_COMPILER_VERSION
+    assert compiled.source.kind == "built-in-sm"
+    assert not hasattr(compiled, "ir")
+    assert not hasattr(compiled, "producer")
+    with pytest.raises(TypeError, match=r"ModelSource\.compile"):
+        CompiledModel()
+    with pytest.raises(AttributeError, match="immutable"):
+        compiled._info = compiled.info  # type: ignore[misc]
+
+    serialized = compiled.write(tmp_path / "builtin")
+    parameter_card = compiled.write_parameter_card(tmp_path / "parameters.json")
+    assert serialized == (tmp_path / "builtin.pyAmplicol-model.json").resolve()
+    assert parameter_card == (tmp_path / "parameters.json").resolve()
+    assert serialized.is_file()
+    assert parameter_card.is_file()
+
+
+def test_injected_license_plan_avoids_model_compilers() -> None:
+    root = Path(__file__).resolve().parents[2]
+    environment = os.environ.copy()
+    environment["PYTHONPATH"] = os.pathsep.join(
+        (str(root / "src"), environment.get("PYTHONPATH", ""))
+    )
+    completed = subprocess.run(
+        (
+            sys.executable,
+            "-c",
+            "\n".join(
+                (
+                    "import sys",
+                    "import pyamplicol.licensing as licensing",
+                    "from pyamplicol import Generator",
+                    "from pyamplicol.config import EvaluatorConfig, RunConfig",
+                    "licensing.detect_symbolica_license = lambda **kwargs: "
+                    "licensing.SymbolicaLicenseState(False, True)",
+                    "assert 'symbolica' in sys.modules",
+                    "Generator(RunConfig(action='generate', evaluator="
+                    "EvaluatorConfig(execution_mode='compiled'))).plan("
+                    "'d d~ > z')",
+                    "assert 'symbolica' in sys.modules",
+                    "assert not any(name.startswith("
+                    "'pyamplicol.models.compiler') for name in sys.modules)",
+                )
+            ),
+        ),
+        cwd=root,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert completed.returncode == 0, completed.stderr
+
+
+class _CapturingGenerationBackend:
+    def __init__(
+        self,
+        resolution: ConfigResolution,
+        captured: list[CompiledModel],
+    ) -> None:
+        self._resolution = resolution
+        self._captured = captured
+
+    def generate(
+        self,
+        processes: ProcessSet,
+        output: Path,
+        *,
+        model: ModelSource | CompiledModel | None = None,
+        mode: str = "error",
+    ) -> GenerationResult:
+        assert isinstance(model, CompiledModel)
+        self._captured.append(model)
+        return GenerationResult(
+            output=output,
+            processes=processes,
+            mode=cast(Literal["error", "append", "replace"], mode),
+        )
+
+
+def test_generator_and_generate_accept_the_compiled_model(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    compiled = ModelSource.built_in_sm().compile(use_cache=False)
+    captured: list[CompiledModel] = []
+
+    def factory(config: object, _progress: object) -> _CapturingGenerationBackend:
+        assert isinstance(config, ConfigResolution)
+        return _CapturingGenerationBackend(config, captured)
+
+    monkeypatch.setattr(api_services, "_generator_factory", factory)
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+
+    first = Generator(GenerationConfig(workers=1)).generate(
+        "d d~ > z",
+        tmp_path / "first",
+        model=compiled,
+    )
+    second = generate(
+        "d d~ > z",
+        tmp_path / "second",
+        model=compiled,
+        config=GenerationConfig(workers=1),
+    )
+
+    assert captured == [compiled, compiled]
+    assert first.output == (tmp_path / "first").resolve()
+    assert second.output == (tmp_path / "second").resolve()
+    assert not first.output.exists()
+    assert not second.output.exists()
+
+
+def test_generator_plan_is_strictly_non_writing_and_does_not_compile(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    compiled = ModelSource.built_in_sm().compile(use_cache=False)
+    sandbox = tmp_path / "sandbox"
+    sandbox.mkdir()
+    marker = sandbox / "marker.txt"
+    marker.write_text("unchanged\n", encoding="utf-8")
+    output = sandbox / "output" / "artifact"
+    cache = sandbox / "cache" / "models"
+    config = RunConfig(
+        action=Action.GENERATE,
+        model=ModelConfig(cache_dir=cache),
+        generation=GenerationConfig(output=output, workers=4),
+        evaluator=EvaluatorConfig(
+            execution_mode="compiled",
+            optimization=EvaluatorOptimizationConfig(cores=8),
+        ),
+    )
+    before = _snapshot(sandbox)
+
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    monkeypatch.setattr(
+        model_loading,
+        "compile_model_source",
+        _forbidden("model compilation"),
+    )
+    monkeypatch.setattr(
+        generation_service.GenerationBackend,
+        "_resolve_model",
+        _forbidden("generation model resolution"),
+    )
+    monkeypatch.setattr(
+        generation_service.GenerationBackend,
+        "_compile_concrete_process",
+        _forbidden("process DAG compilation"),
+    )
+    monkeypatch.setattr(
+        generation_service,
+        "TemporaryDirectory",
+        _forbidden("temporary directory creation"),
+    )
+    monkeypatch.setattr(
+        generation_service,
+        "write_schema_v3_artifact",
+        _forbidden("artifact writing"),
+    )
+
+    plan = Generator(config).plan("p p > z", model=compiled)
+
+    assert _snapshot(sandbox) == before
+    assert not output.exists()
+    assert not cache.exists()
+    assert len(plan.concrete_processes) == 5
+    assert plan.requested_settings.generation.workers == 4
+    assert plan.effective_settings.generation.workers == 1
+    assert plan.requested_settings.evaluator.optimization.cores == 8
+    assert plan.effective_settings.evaluator.optimization.cores == 1
+    assert [adjustment.path for adjustment in plan.adjustments] == [
+        "generation.workers",
+        "evaluator.optimization.cores",
+    ]
+
+
+def test_cli_generate_dry_run_preserves_the_filesystem_snapshot(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    sandbox = tmp_path / "sandbox"
+    sandbox.mkdir()
+    (sandbox / "marker.txt").write_text("unchanged\n", encoding="utf-8")
+    output = sandbox / "output" / "artifact"
+    cache = sandbox / "cache" / "models"
+    before = _snapshot(sandbox)
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    monkeypatch.setattr(
+        model_loading,
+        "compile_model_source",
+        _forbidden("model compilation"),
+    )
+    monkeypatch.setattr(
+        generation_service.GenerationBackend,
+        "_compile_concrete_process",
+        _forbidden("process DAG compilation"),
+    )
+    monkeypatch.setattr(
+        generation_service,
+        "TemporaryDirectory",
+        _forbidden("temporary directory creation"),
+    )
+    monkeypatch.setattr(
+        generation_service,
+        "write_schema_v3_artifact",
+        _forbidden("artifact writing"),
+    )
+
+    status = run_cli(
+        (
+            "generate",
+            "d d~ > z",
+            str(output),
+            "--dry-run",
+            "--execution-mode",
+            "compiled",
+            "--workers",
+            "4",
+            "--cores",
+            "8",
+            "--json",
+            "--progress",
+            "off",
+            "--set",
+            f"model.cache_dir={cache}",
+        ),
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 0, stderr.getvalue()
+    assert stderr.getvalue() == ""
+    assert _snapshot(sandbox) == before
+    assert not output.exists()
+    assert not cache.exists()
+    payload = json.loads(stdout.getvalue())
+    assert payload["requested_settings"]["generation"]["workers"] == 4
+    assert payload["effective_settings"]["generation"]["workers"] == 1
+    assert payload["requested_settings"]["evaluator"]["optimization"]["cores"] == 8
+    assert payload["effective_settings"]["evaluator"]["optimization"]["cores"] == 1
+    assert [item["reason"] for item in payload["adjustments"]] == [
+        "Symbolica restricted mode permits one generation instance",
+        "Symbolica restricted mode permits one Symbolica core",
+    ]
+
+
+def test_plan_reads_an_existing_external_model_cache_without_modifying_it(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source_path = (
+        Path(__file__).resolve().parents[2]
+        / "src"
+        / "pyamplicol"
+        / "assets"
+        / "models"
+        / "json"
+        / "scalars"
+        / "scalars.json"
+    )
+    source = ModelSource.from_path(source_path)
+    sandbox = tmp_path / "sandbox"
+    cache = sandbox / "cache" / "models"
+    output = sandbox / "output" / "artifact"
+    source.compile(cache_dir=cache)
+    before = _snapshot(sandbox)
+    config = RunConfig(
+        action=Action.GENERATE,
+        model=ModelConfig(cache_dir=cache),
+        generation=GenerationConfig(output=output),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    monkeypatch.setattr(
+        model_loading,
+        "compile_model_source",
+        _forbidden("model compilation"),
+    )
+    monkeypatch.setattr(
+        generation_service.GenerationBackend,
+        "_compile_concrete_process",
+        _forbidden("process DAG compilation"),
+    )
+    monkeypatch.setattr(
+        generation_service,
+        "write_schema_v3_artifact",
+        _forbidden("artifact writing"),
+    )
+
+    plan = Generator(config).plan(
+        "scalar_0 scalar_0 > scalar_0 scalar_0",
+        model=source,
+    )
+
+    assert _snapshot(sandbox) == before
+    assert not output.exists()
+    assert plan.estimated_coverage["model_kind"] == "json"
+    assert len(plan.concrete_processes) == 1
+
+
+def test_on_the_fly_high_multiplicity_dry_run_stays_compact(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    for name in (
+        "build_color_plan",
+        "compile_generic_dag",
+        "_invoke_rust_on_the_fly_seed_batch_builder_v1",
+        "write_schema_v3_artifact",
+    ):
+        monkeypatch.setattr(generation_service, name, _forbidden(name))
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    process = "d d~ > " + " ".join(("g",) * 9)
+    prepared_model = (
+        Path(__file__).resolve().parents[2]
+        / "src"
+        / "pyamplicol"
+        / "assets"
+        / "prepared_models"
+        / f"built-in-sm-jit-o2-{canonical_architecture()}.pyamplicol-model"
+    )
+
+    status = run_cli(
+        (
+            "generate",
+            process,
+            "--dry-run",
+            "--execution-mode",
+            "on-the-fly",
+            "--model",
+            str(prepared_model),
+            "--no-collect-factors",
+            "--json",
+            "--progress",
+            "off",
+        ),
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 0, stderr.getvalue()
+    payload = json.loads(stdout.getvalue())
+    coverage = payload["estimated_coverage"]["processes"][0]
+    assert coverage == {
+        "color_coverage": "complete",
+        "color_diagnostics": [],
+        "color_plan_materialized": False,
+        "color_sector_count": 362880,
+        "coupling_order_limits": {},
+        "dag_compilation_deferred": True,
+        "execution_mode": "on-the-fly",
+        "external_particle_count": 11,
+        "helicity_coverage": "complete",
+        "key": coverage["key"],
+        "native_seed_construction_deferred": True,
+        "physical_color_flow_count": 362880,
+        "physical_helicity_count": 2048,
+        "process": coverage["process"],
+        "selector_representation": "compact-query-local",
+        "source_projection_validated": True,
+    }
+    assert stderr.getvalue() == ""
+
+
+@pytest.mark.parametrize(
+    ("process_config", "field"),
+    (
+        (ProcessConfig(max_color_sectors=1), "process.max_color_sectors"),
+        (
+            ProcessConfig(selected_color_sector_ids=(0,)),
+            "process.selected_color_sector_ids",
+        ),
+        (
+            ProcessConfig(selected_source_helicities={"1": -1}),
+            "process.selected_source_helicities",
+        ),
+    ),
+)
+def test_on_the_fly_plan_and_generation_reject_selector_specialization_identically(
+    process_config: ProcessConfig,
+    field: str,
+    tmp_path: Path,
+) -> None:
+    generator = Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            process=process_config,
+            evaluator=EvaluatorConfig(execution_mode="on-the-fly"),
+        )
+    )
+
+    with pytest.raises(GenerationError) as plan_error:
+        generator.plan("d d~ > z")
+    with pytest.raises(GenerationError) as generation_error:
+        generator.generate("d d~ > z", tmp_path / "artifact")
+
+    assert str(plan_error.value) == str(generation_error.value)
+    assert field in str(plan_error.value)
+
+
+def test_plan_uses_licensed_concrete_process_resource_partition(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        licensing,
+        "detect_symbolica_license",
+        lambda **_kwargs: SymbolicaLicenseState(licensed=True, restricted=False),
+    )
+    monkeypatch.setattr(licensing, "_cpu_budget", lambda: 12)
+    monkeypatch.setattr(
+        model_loading,
+        "compile_model_source",
+        _forbidden("model compilation"),
+    )
+
+    plan = Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        )
+    ).plan("p p > z")
+
+    assert len(plan.concrete_processes) == 5
+    assert plan.requested_settings.generation.workers == "auto"
+    assert plan.effective_settings.generation.workers == 5
+    assert plan.requested_settings.evaluator.optimization.cores == "auto"
+    assert plan.effective_settings.evaluator.optimization.cores == 2
+    assert [adjustment.path for adjustment in plan.adjustments] == [
+        "generation.workers",
+        "evaluator.optimization.cores",
+    ]
+    assert all(adjustment.reason for adjustment in plan.adjustments)
+
+
+def test_builtin_all_plan_can_be_bounded_to_one_concrete_process(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+
+    plan = Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            process=ProcessConfig(flavor_scheme=1, max_quark_lines=0),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        )
+    ).plan("p p > all all")
+
+    assert tuple(process.expression for process in plan.concrete_processes) == (
+        "g g > g g",
+    )
+
+
+@pytest.mark.parametrize("expression", ("p p > 2*all", "p p > [all g] all"))
+def test_builtin_all_expands_token_aware_before_the_prefilter(
+    monkeypatch: pytest.MonkeyPatch,
+    expression: str,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+
+    plan = Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            process=ProcessConfig(flavor_scheme=1, max_quark_lines=0),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        )
+    ).plan(expression)
+
+    assert tuple(process.expression for process in plan.concrete_processes) == (
+        "g g > g g",
+    )
+
+
+def test_builtin_explicit_multiparticles_extend_defaults_and_override_all(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+
+    plan = Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            process=ProcessConfig(
+                multiparticles={"beam": ("g",), "all": ("g",)},
+                flavor_scheme=1,
+                max_quark_lines=0,
+            ),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        )
+    ).plan("beam beam > all all")
+
+    assert tuple(process.expression for process in plan.concrete_processes) == (
+        "g g > g g",
+    )
diff --git a/pyamplicol/tests/unit/test_compiled_plane_arena_contract.py b/pyamplicol/tests/unit/test_compiled_plane_arena_contract.py
new file mode 100644
index 0000000000..ea29b17f97
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiled_plane_arena_contract.py
@@ -0,0 +1,382 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+from copy import deepcopy
+
+import pytest
+
+from pyamplicol._internal.versions import (
+    COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+    COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+    NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+    SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+    SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+    SYMJIT_APPLICATION_ABI,
+    SYMJIT_F64_RUNTIME_CAPABILITY,
+    SYMJIT_PLANE_APPLICATION_ABI,
+)
+from pyamplicol.generation.artifact_writer import (
+    _compiled_momentum_slot_ids,
+    _prefix_evaluator_payload_paths,
+    _stage_evaluator_set,
+)
+from pyamplicol.generation.stage_artifacts import (
+    _compiled_plane_arena_stage,
+)
+
+
+def _leaf(
+    path: str,
+    input_len: int,
+    output_len: int,
+    *,
+    optimization_level: int = 3,
+) -> dict[str, object]:
+    plane_path = path.removesuffix(".symjit") + ".plane.symjit"
+    return {
+        "kind": "symjit-application-evaluator",
+        "runtime_capability": SYMJIT_F64_RUNTIME_CAPABILITY,
+        "input_len": input_len,
+        "output_len": output_len,
+        "application_path": path,
+        "application_abi": SYMJIT_APPLICATION_ABI,
+        "plane_application": {
+            "application_path": plane_path,
+            "application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+            "storage_abi": SYMJIT_APPLICATION_ABI,
+            "element_layout": "split-complex-plane-major",
+            "descriptor_order": "inputs-re-im-then-outputs-re-im",
+            "input_complex_count": input_len,
+            "output_complex_count": output_len,
+            "input_plane_count": 2 * input_len,
+            "output_plane_count": 2 * output_len,
+            "compiler_type": "native",
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": optimization_level,
+            "simd": True,
+            "complex": True,
+            "fast_math": True,
+            "fast_complex": False,
+            "compression": False,
+            "threading": False,
+            "direct_arena": True,
+            "source_digest": hashlib.sha256(
+                f"instructions:{path}".encode()
+            ).hexdigest(),
+            "target": {"word_bits": 64, "endianness": "little"},
+        },
+        "element_layout": "complex-f64",
+        "batch_layout": "row-major",
+        "compiler_type": "native",
+        "translation_mode": "indirect",
+        "optimization_level": optimization_level,
+        "word_bits": 64,
+        "endianness": "little",
+        "required_defuns": [],
+        "evaluator_state_path": None,
+        "evaluator_state_runtime_capability": (SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY),
+    }
+
+
+def _stage(*, amplitude: bool = False) -> dict[str, object]:
+    evaluator = {
+        "kind": "chunked-symbolica-evaluator",
+        "input_len": 3,
+        "chunk_input_indices": [[0, 2], [1]],
+        "required_runtime_capabilities": [SYMJIT_F64_RUNTIME_CAPABILITY],
+        "chunks": [
+            _leaf("evaluators/left.symjit", 2, 1),
+            _leaf("evaluators/right.symjit", 1, 1),
+        ],
+    }
+    return {
+        "stage_index": 2,
+        "stage_kind": "amplitude-roots" if amplitude else "current-combine",
+        "subset_size": None if amplitude else 3,
+        "evaluator_label": "amplitude" if amplitude else "stage-2",
+        "parameter_layout": "stage-local-value-momentum",
+        "output_length": 2,
+        "output_slots": [
+            {
+                "value_slot_id": -1 if amplitude else 7,
+                "current_id": -1 if amplitude else 7,
+                "variant": "amplitude-root" if amplitude else "propagated",
+                "component_start": 0 if amplitude else 12,
+                "component_stop": 2 if amplitude else 14,
+                "output_start": 0,
+                "output_stop": 2,
+                "color_selector_domain_ids": [0],
+            }
+        ],
+        "input_value_slot_ids": [0],
+        "output_value_slot_ids": [] if amplitude else [7],
+        "interaction_ids": [4],
+        "input_components": [
+            {
+                "kind": "value",
+                "source_id": 0,
+                "component": 0,
+                "global_component": 0,
+                "parameter_index": 0,
+                "real_valued": False,
+            },
+            {
+                "kind": "momentum",
+                "source_id": 3,
+                "component": 2,
+                "global_component": 22,
+                "parameter_index": 1,
+                "real_valued": True,
+            },
+            {
+                "kind": "model_parameter",
+                "source_id": 1,
+                "component": 0,
+                "global_component": 31,
+                "parameter_index": 2,
+                "real_valued": False,
+            },
+        ],
+        "parameter_count": 3,
+        "value_parameter_count": 1,
+        "momentum_parameter_count": 1,
+        "model_parameter_count": 1,
+        "real_valued_inputs": [1],
+        "expression_ready": True,
+        "blockers": [],
+        "evaluator": evaluator,
+    }
+
+
+def test_compiled_momentum_slot_selection_uses_whole_lane_leaf_inputs() -> None:
+    stage = _stage()
+    # The parent binding still mentions a momentum, but neither final chunk
+    # consumes it. It must not keep a dead momentum sum alive.
+    stage["evaluator"]["chunk_input_indices"] = [[0, 2], [0]]
+    stage["compiled_plane_arena"] = _compiled_plane_arena_stage(stage)
+    amplitude = _stage(amplitude=True)
+    amplitude["compiled_plane_arena"] = _compiled_plane_arena_stage(amplitude)
+    evaluators = {"stages": [stage], "amplitude_stage": amplitude}
+    assert _compiled_momentum_slot_ids(
+        evaluators, value_component_count=8, momentum_component_count=16
+    ) == [3]
+
+    # Every leaf in the prepared lane contributes, regardless of any runtime
+    # helicity/colour selection. Repeated bindings are retained only once.
+    stage["evaluator"]["chunk_input_indices"] = [[1, 2], [1]]
+    stage["input_components"][1]["global_component"] = 10
+    stage["input_components"][1]["source_id"] = 0
+    stage["compiled_plane_arena"] = _compiled_plane_arena_stage(stage)
+    assert _compiled_momentum_slot_ids(
+        evaluators, value_component_count=8, momentum_component_count=16
+    ) == [0, 3]
+    assert _compiled_momentum_slot_ids(
+        {"stages": [], "amplitude_stage": stage},
+        value_component_count=8,
+        momentum_component_count=16,
+    ) == [0]
+
+
+def test_compiled_momentum_slot_selection_rejects_out_of_range_input() -> None:
+    stage = _stage(amplitude=True)
+    stage["compiled_plane_arena"] = _compiled_plane_arena_stage(stage)
+    with pytest.raises(ValueError, match="outside momentum slots"):
+        _compiled_momentum_slot_ids(
+            {"stages": [], "amplitude_stage": stage},
+            value_component_count=8,
+            momentum_component_count=12,
+        )
+
+
+def _native_leaf(
+    path: str,
+    input_len: int,
+    output_len: int,
+    runtime_capability: str,
+) -> dict[str, object]:
+    return {
+        "kind": "compiled-complex-evaluator",
+        "runtime_capability": runtime_capability,
+        "backend": "compiled-complex",
+        "number_type": "complex",
+        "function_name": path.replace("/", "_").replace(".", "_"),
+        "input_len": input_len,
+        "output_len": output_len,
+        "settings": {
+            "compiled_optimization_level": 3,
+            "compiled_inline_asm": (
+                "none"
+                if runtime_capability == SYMBOLICA_CPP_RUNTIME_CAPABILITY
+                else "default"
+            ),
+        },
+        "source_path": f"{path}.direct.cpp",
+        "library_path": f"{path}.direct",
+        "evaluator_state_path": f"{path}.evaluator.bin",
+        "native_direct_application": {
+            "application_abi": NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+            "function_name": path.replace("/", "_").replace(".", "_"),
+            "source_path": f"{path}.direct.cpp",
+            "library_path": f"{path}.direct",
+            "target": {
+                "triple": "aarch64-apple-darwin",
+                "cpu_features": [],
+            },
+            "evaluator_state_sha256": "a" * 64,
+            "instruction_count": 1,
+            "temporary_count": 0,
+            "input_plane_count": input_len,
+            "scalar_input_count": 0,
+            "output_plane_count": 2 * output_len,
+            "simd_lane_width": 2,
+            "logical_stack_bytes": 32 * output_len,
+            "output_semantics": "factor-free-overwrite",
+        },
+    }
+
+
+def _set() -> dict[str, object]:
+    stage = _stage()
+    amplitude = _stage(amplitude=True)
+    stage["compiled_plane_arena"] = _compiled_plane_arena_stage(stage)
+    amplitude["compiled_plane_arena"] = _compiled_plane_arena_stage(amplitude)
+    return {
+        "kind": "generic-dag-stage-evaluator-artifacts",
+        "required_runtime_capabilities": [
+            COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+            SYMJIT_F64_RUNTIME_CAPABILITY,
+        ],
+        "runtime_available": True,
+        "runtime_unavailable_message": None,
+        "parameter_count": 0,
+        "value_parameter_count": 0,
+        "momentum_parameter_count": 0,
+        "model_parameter_count": 0,
+        "real_valued_inputs": [],
+        "parameter_layout": "stage-local-value-momentum",
+        "stage_count": 2,
+        "stages": [stage],
+        "amplitude_stage": amplitude,
+    }
+
+
+def test_compiled_plane_contract_freezes_leaf_and_plane_bindings() -> None:
+    stage = _stage()
+    direct = _compiled_plane_arena_stage(stage)
+
+    assert direct is not None
+    assert direct["application_abi"] == COMPILED_PLANE_DIRECT_APPLICATION_ABI
+    assert [leaf["input_indices"] for leaf in direct["leaves"]] == [[0, 2], [1]]
+    assert [leaf["output_start"] for leaf in direct["leaves"]] == [0, 1]
+    assert [binding["component"] for binding in direct["output_bindings"]] == [
+        12,
+        13,
+    ]
+
+
+@pytest.mark.parametrize("optimization_level", [0, 1, 2, 3])
+def test_compiled_plane_contract_covers_every_jit_optimization_level(
+    optimization_level: int,
+) -> None:
+    stage = _stage()
+    leaf = stage["evaluator"]["chunks"][0]
+    leaf["optimization_level"] = optimization_level
+    leaf["plane_application"]["optimization_level"] = optimization_level
+
+    direct = _compiled_plane_arena_stage(stage)
+
+    assert direct is not None
+    assert [leaf["optimization_level"] for leaf in direct["leaves"]] == [
+        optimization_level,
+        3,
+    ]
+    assert [leaf["direct_codegen_optimization_level"] for leaf in direct["leaves"]] == [
+        optimization_level,
+        3,
+    ]
+
+
+def test_compiled_plane_contract_rejects_unknown_jit_optimization_level() -> None:
+    stage = _stage()
+    stage["evaluator"]["chunks"][0]["plane_application"]["optimization_level"] = 4
+
+    with pytest.raises(ValueError, match="optimization level must be 0, 1, 2, or 3"):
+        _compiled_plane_arena_stage(stage)
+
+
+@pytest.mark.parametrize(
+    "runtime_capability",
+    [SYMBOLICA_CPP_RUNTIME_CAPABILITY, SYMBOLICA_ASM_RUNTIME_CAPABILITY],
+)
+def test_native_compiled_contract_publishes_direct_library_leaves(
+    runtime_capability: str,
+) -> None:
+    stage = _stage()
+    stage["evaluator"] = {
+        "kind": "chunked-symbolica-evaluator",
+        "input_len": 3,
+        "chunk_input_indices": [[0, 2], [1]],
+        "required_runtime_capabilities": [runtime_capability],
+        "chunks": [
+            _native_leaf("compiled/left", 2, 1, runtime_capability),
+            _native_leaf("compiled/right", 1, 1, runtime_capability),
+        ],
+    }
+
+    direct = _compiled_plane_arena_stage(stage)
+
+    assert direct is not None
+    assert direct["application_abi"] == NATIVE_COMPILED_DIRECT_APPLICATION_ABI
+    assert direct["source_application_abi"] == (NATIVE_COMPILED_DIRECT_APPLICATION_ABI)
+    assert [leaf["application_path"] for leaf in direct["leaves"]] == [
+        "compiled/left.direct",
+        "compiled/right.direct",
+    ]
+
+
+def test_stage_set_requires_complete_capability_bound_metadata() -> None:
+    serialized = _stage_evaluator_set(_set())
+    assert (
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY
+        in serialized["required_runtime_capabilities"]
+    )
+    assert all(
+        "compiled_plane_arena" in stage
+        for stage in (*serialized["stages"], serialized["amplitude_stage"])
+    )
+
+    missing = deepcopy(_set())
+    del missing["stages"][0]["compiled_plane_arena"]
+    with pytest.raises(ValueError, match="compiled f64 artifacts require"):
+        _stage_evaluator_set(missing)
+
+    pre_arena = deepcopy(_set())
+    pre_arena["required_runtime_capabilities"].remove(
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY
+    )
+    del pre_arena["stages"][0]["compiled_plane_arena"]
+    del pre_arena["amplitude_stage"]["compiled_plane_arena"]
+    with pytest.raises(ValueError, match="compiled f64 artifacts require"):
+        _stage_evaluator_set(pre_arena)
+
+    drift = deepcopy(_set())
+    drift["amplitude_stage"]["compiled_plane_arena"]["leaves"][1]["output_start"] = 0
+    with pytest.raises(ValueError, match="leaf bindings"):
+        _stage_evaluator_set(drift)
+
+
+def test_direct_source_paths_follow_nested_lane_prefixes() -> None:
+    serialized = _stage_evaluator_set(_set())
+    prefixed = _prefix_evaluator_payload_paths(serialized, "lane-7")
+    stage = prefixed["stages"][0]
+    assert stage["evaluator"]["chunks"][0]["application_path"] == (
+        "lane-7/evaluators/left.symjit"
+    )
+    assert stage["evaluator"]["chunks"][0]["plane_application"][
+        "application_path"
+    ] == ("lane-7/evaluators/left.plane.symjit")
+    assert stage["compiled_plane_arena"]["leaves"][0]["application_path"] == (
+        "lane-7/evaluators/left.plane.symjit"
+    )
diff --git a/pyamplicol/tests/unit/test_compiler_auxiliary_components.py b/pyamplicol/tests/unit/test_compiler_auxiliary_components.py
new file mode 100644
index 0000000000..7edfe6b3b7
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiler_auxiliary_components.py
@@ -0,0 +1,391 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact auxiliary reduction without generating a native process output."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+import pytest
+
+from pyamplicol._internal.physics.symbols import symbols
+from pyamplicol.models import compiler_symbolica as _sym
+from pyamplicol.models.compiler_auxiliary_components import (
+    reduce_contact_auxiliary_components,
+)
+from pyamplicol.models.compiler_tensor_ordering import compile_tensor_ordering_metadata
+from pyamplicol.models.contracts import CompiledOrientedKernel, CompiledParticleRecord
+
+_SYMBOLS = symbols.model("auxiliary-component-test")
+
+
+def _particle(name: str, dimension: int | None = None) -> CompiledParticleRecord:
+    auxiliary = dimension is not None
+    return CompiledParticleRecord(
+        name=name,
+        antiname=name,
+        pdg_code={"p": 1, "q": 2, "aux": 3, "aux2": 4}[name],
+        spin=-1 if auxiliary else 3,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=not auxiliary,
+        goldstoneboson=False,
+        propagator=None,
+        component_dimension=dimension,
+        auxiliary_kind="test-contact-tree" if auxiliary else None,
+    )
+
+
+def _kernel(kind: int, names: tuple[str, str, str], *expressions: str):
+    _sym._ensure_symbolica()
+    replacements = [
+        _sym.Replacement(
+            _sym.E(f"{letter}{index}"),
+            _SYMBOLS.kernel_component(kind, side, index),
+        )
+        for letter, side in (("L", "left"), ("R", "right"))
+        for index in range(8)
+    ]
+    return CompiledOrientedKernel(
+        kind=kind,
+        term_id=42,
+        vertex="test-contact-tree",
+        particles=names,
+        source_particle_legs=tuple(
+            -1 if name.startswith("aux") else index for index, name in enumerate(names)
+        ),
+        component_expressions=tuple(
+            _sym.E(source).replace_multiple(replacements).to_canonical_string()
+            for source in expressions
+        ),
+        coupling_expression="1",
+        coupling_orders=(("HIG", 1),),
+        runtime_parameters=(),
+        color_source="1",
+        color_expression="1",
+    )
+
+
+def _reduce(auxiliaries, kernels):
+    return reduce_contact_auxiliary_components(
+        (_particle("p"), _particle("q"), *auxiliaries),
+        kernels,
+        auxiliary_particles=auxiliaries,
+        model_symbols=_SYMBOLS,
+    )
+
+
+def _compose(consumer, producers):
+    replacements = [
+        _sym.Replacement(
+            _SYMBOLS.kernel_component(consumer.kind, side, index),
+            _sym.E(expression),
+        )
+        for side, producer in producers.items()
+        for index, expression in enumerate(producer.component_expressions)
+    ]
+    return tuple(
+        _sym.E(expression).replace_multiple(replacements)
+        for expression in consumer.component_expressions
+    )
+
+
+def _assert_equal(before, after):
+    assert len(before) == len(after)
+    assert all(
+        (left - right).expand().to_canonical_string() == "0"
+        for left, right in zip(before, after, strict=True)
+    )
+
+
+def test_signed_columns_reduce_all_producers_and_both_input_orientations():
+    aux = _particle("aux", 5)
+    producer = _kernel(
+        0, ("p", "q", "aux"), "L0*R0", "L0*R1", "L1*R0", "L1*R1", "L2*R2"
+    )
+    other_producer = _kernel(
+        1, ("q", "p", "aux"), "-L1*R0", "L2*R0", "L3*R1", "L0*R2", "L1*R3"
+    )
+    left = _kernel(2, ("aux", "p", "p"), "(L1-L2)*R0+(L3+L4)*R1", "0", "0", "0")
+    right = _kernel(3, ("p", "aux", "p"), "L0*(R1-R2)+L1*(R3+R4)", "0", "0", "0")
+    original = (producer, other_producer, left, right)
+    particles, reduced = _reduce((aux,), original)
+
+    assert particles[-1].component_dimension == 2
+    for old, new in zip(original, reduced, strict=True):
+        assert replace(new, component_expressions=old.component_expressions) == old
+    assert _sym.E(producer.component_expressions[0]) != _sym.E("0")
+    _assert_equal(
+        (
+            _sym.E(producer.component_expressions[1])
+            - _sym.E(producer.component_expressions[2]),
+            _sym.E(producer.component_expressions[3])
+            + _sym.E(producer.component_expressions[4]),
+        ),
+        tuple(_sym.E(value) for value in reduced[0].component_expressions),
+    )
+    for index in (0, 1):
+        for consumer, side in ((2, "left"), (3, "right")):
+            _assert_equal(
+                _compose(original[consumer], {side: original[index]}),
+                _compose(reduced[consumer], {side: reduced[index]}),
+            )
+    _, ordered, orderings, current_orderings = compile_tensor_ordering_metadata(
+        (), particles, reduced, (), ()
+    )
+    current = next(record for record in current_orderings if record.particle == "aux")
+    ordering = next(
+        record for record in orderings if record.ordering_id == current.ordering_id
+    )
+    assert ordering.stored_size == 2
+    assert current.input_embedding == current.result_projection == (0, 1)
+    assert ordered[0].output_ordering_id == current.ordering_id
+
+
+def test_every_consumer_constrains_the_shared_basis():
+    aux = _particle("aux", 3)
+    producer = _kernel(0, ("p", "q", "aux"), "L0*R0", "L1*R1", "L2*R2")
+    left = _kernel(1, ("aux", "p", "p"), "(L0-L1)*R0", "0", "0", "0")
+    right = _kernel(2, ("p", "aux", "p"), "L0*R0+L1*R2", "0", "0", "0")
+    particles, reduced = _reduce((aux,), (producer, left, right))
+    assert particles[-1] == aux
+    assert reduced == (producer, left, right)
+
+
+@pytest.mark.parametrize(
+    ("expression", "dimension"),
+    (("(a+b)*L0+(-a-b)*L1", 1), ("a*L0+b*L1", 2)),
+)
+def test_relations_are_exact_for_all_parameters(expression, dimension):
+    aux = _particle("aux", 2)
+    producer = _kernel(0, ("p", "q", "aux"), "L0*R0", "L1*R1")
+    consumer = _kernel(1, ("aux", "p", "p"), expression, "0", "0", "0")
+    particles, reduced = _reduce((aux,), (producer, consumer))
+    assert particles[-1].component_dimension == dimension
+    _assert_equal(
+        _compose(consumer, {"left": producer}),
+        _compose(reduced[1], {"left": reduced[0]}),
+    )
+
+
+@pytest.mark.parametrize("coefficient", ("1.0", "0.1"))
+def test_binary64_producer_coefficients_keep_their_exact_value(coefficient):
+    aux = _particle("aux", 2)
+    producer = _kernel(0, ("p", "q", "aux"), "L0", "L1")
+    left = _SYMBOLS.kernel_component(0, "left", 0)
+    # Retain the original binary64 literal, before canonical string formatting
+    # assigns a different precision to a subsequently reparsed Float atom.
+    producer = replace(
+        producer,
+        component_expressions=(
+            f"({left.to_canonical_string()}+{coefficient})/3",
+            producer.component_expressions[1],
+        ),
+    )
+    consumer = _kernel(1, ("aux", "p", "p"), "L0+L1", "0", "0", "0")
+    particles, reduced = _reduce((aux,), (producer, consumer))
+    assert particles[-1].component_dimension == 1
+    numerator, denominator = float(coefficient).as_integer_ratio()
+    expected = (
+        left + _sym.E(f"{numerator}/{denominator}")
+    ) / 3 + _SYMBOLS.kernel_component(0, "left", 1)
+    _assert_equal((expected,), (_sym.E(reduced[0].component_expressions[0]),))
+
+
+@pytest.mark.parametrize("location", ("producer", "consumer"))
+def test_unsupported_float_coefficients_leave_the_whole_basis_unchanged(location):
+    aux = _particle("aux", 2)
+    producer = _kernel(0, ("p", "q", "aux"), "L0", "L1")
+    consumer = _kernel(1, ("aux", "p", "p"), "L0+L1", "0", "0", "0")
+    if location == "producer":
+        producer = _kernel(
+            0, ("p", "q", "aux"), "(L0+0.1000000000000000000000000000000000123)/3", "L1"
+        )
+    else:
+        consumer = _kernel(
+            1,
+            ("aux", "p", "p"),
+            "(0.1000000000000000000000000000000000123+R0/3)*(L0+L1)",
+            "0",
+            "0",
+            "0",
+        )
+    particles, reduced = _reduce((aux,), (producer, consumer))
+    assert particles[-1] == aux
+    assert reduced == (producer, consumer)
+
+
+@pytest.mark.parametrize("sign", (1, -1))
+@pytest.mark.parametrize("nearby", (False, True))
+def test_arbitrary_precision_units_are_exactified_but_nearby_values_are_not(
+    sign, nearby
+):
+    aux = _particle("aux", 2)
+    literal = ("-" if sign < 0 else "") + "1." + "0" * 45 + ("1" if nearby else "0")
+    producer = _kernel(0, ("p", "q", "aux"), f"(L0+{literal})/3", "L1")
+    consumer = _kernel(1, ("aux", "p", "p"), "L0+L1", "0", "0", "0")
+    particles, reduced = _reduce((aux,), (producer, consumer))
+    if nearby:
+        assert particles[-1] == aux
+        assert reduced == (producer, consumer)
+    else:
+        assert particles[-1].component_dimension == 1
+        expected = (
+            _SYMBOLS.kernel_component(0, "left", 0) + sign
+        ) / 3 + _SYMBOLS.kernel_component(0, "left", 1)
+        _assert_equal((expected,), (_sym.E(reduced[0].component_expressions[0]),))
+
+
+def test_near_equal_consumer_columns_are_not_grouped_by_float_rounding():
+    aux = _particle("aux", 2)
+    producer = _kernel(0, ("p", "q", "aux"), "L0", "L1")
+    left0 = _SYMBOLS.kernel_component(1, "left", 0).to_canonical_string()
+    left1 = _SYMBOLS.kernel_component(1, "left", 1).to_canonical_string()
+    right0 = _SYMBOLS.kernel_component(1, "right", 0).to_canonical_string()
+    consumer = _kernel(1, ("aux", "p", "p"), "L0+L1", "0", "0", "0")
+    consumer = replace(
+        consumer,
+        component_expressions=(
+            f"0.1*({right0}*{left0}+({right0}+1/10^60)*{left1})",
+            "0",
+            "0",
+            "0",
+        ),
+    )
+    particles, reduced = _reduce((aux,), (producer, consumer))
+    assert particles[-1] == aux
+    assert reduced == (producer, consumer)
+
+
+@pytest.mark.parametrize("sign", (1, -1))
+def test_distinct_complex_columns_do_not_depend_on_printed_parentheses(sign):
+    aux = _particle("aux", 2)
+    producer = _kernel(0, ("p", "q", "aux"), "L0", "L1")
+    consumer = _kernel(1, ("aux", "p", "p"), "L0+L1", "0", "0", "0")
+    left0 = _SYMBOLS.kernel_component(1, "left", 0).to_canonical_string()
+    left1 = _SYMBOLS.kernel_component(1, "left", 1).to_canonical_string()
+    # These coefficients are neither equal nor opposite. Some Symbolica
+    # canonical printers omit the parentheses around the mixed complex atom,
+    # making (1+2i)*a and 1+2i*a indistinguishable as printed strings.
+    consumer = replace(
+        consumer,
+        component_expressions=(
+            f"(1+2i)*a*{left0}+({sign})*(1+2i*a)*{left1}",
+            "0",
+            "0",
+            "0",
+        ),
+    )
+    particles, reduced = _reduce((aux,), (producer, consumer))
+    assert particles[-1] == aux
+    assert reduced == (producer, consumer)
+
+
+@pytest.mark.parametrize(
+    "expression", ("L0^2", "1+L0", "1/L0", "f(L0)", "L0/L1", "f(L0)*L1")
+)
+def test_uncertified_nonlinear_or_inhomogeneous_consumer_is_unchanged(expression):
+    aux = _particle("aux", 2)
+    producer = _kernel(0, ("p", "q", "aux"), "L0*R0", "L1*R1")
+    consumer = _kernel(1, ("aux", "p", "p"), expression, "0", "0", "0")
+    particles, reduced = _reduce((aux,), (producer, consumer))
+    assert particles[-1] == aux
+    assert reduced == (producer, consumer)
+
+
+@pytest.mark.parametrize(
+    "contract", ("propagating", "propagator", "external", "ordering")
+)
+def test_nonopaque_or_externally_used_auxiliaries_are_unchanged(contract):
+    aux = _particle("aux", 2)
+    producer = _kernel(0, ("p", "q", "aux"), "L0*R0", "L1*R1")
+    consumer = _kernel(1, ("aux", "p", "p"), "L0*R0", "0", "0", "0")
+    if contract == "propagating":
+        aux = replace(aux, propagating=True)
+    elif contract == "propagator":
+        aux = replace(aux, propagator="custom")
+    elif contract == "external":
+        consumer = replace(consumer, source_particle_legs=(0, 1, 2))
+    else:
+        producer = replace(producer, output_ordering_id="prescribed")
+    particles, reduced = _reduce((aux,), (producer, consumer))
+    assert particles[-1] == aux
+    assert reduced == (producer, consumer)
+
+
+def test_two_reduced_inputs_are_replaced_simultaneously():
+    auxiliaries = (_particle("aux", 3), _particle("aux2", 3))
+    first = _kernel(0, ("p", "q", "aux"), "L0*R0", "L0*R1", "L1*R0")
+    second = _kernel(1, ("q", "p", "aux2"), "L2*R2", "L2*R3", "L3*R2")
+    consumer = _kernel(2, ("aux", "aux2", "p"), "(L1-L2)*(R1-R2)", "0", "0", "0")
+    particles, reduced = _reduce(auxiliaries, (first, second, consumer))
+    assert [particle.component_dimension for particle in particles[-2:]] == [1, 1]
+    _assert_equal(
+        _compose(consumer, {"left": first, "right": second}),
+        _compose(reduced[2], {"left": reduced[0], "right": reduced[1]}),
+    )
+
+
+def test_same_auxiliary_on_both_sides_uses_one_shared_reduced_basis():
+    aux = _particle("aux", 3)
+    first = _kernel(0, ("p", "q", "aux"), "L0*R0", "L0*R1", "L1*R0")
+    second = _kernel(1, ("q", "p", "aux"), "L2*R2", "L2*R3", "L3*R2")
+    consumer = _kernel(2, ("aux", "aux", "p"), "(L1-L2)*(R1-R2)", "0", "0", "0")
+    particles, reduced = _reduce((aux,), (first, second, consumer))
+    assert particles[-1].component_dimension == 1
+    _assert_equal(
+        _compose(consumer, {"left": first, "right": second}),
+        _compose(reduced[2], {"left": reduced[0], "right": reduced[1]}),
+    )
+
+
+def test_downstream_reduction_exposes_additional_upstream_dead_components():
+    auxiliaries = (_particle("aux", 3), _particle("aux2", 2))
+    first = _kernel(0, ("p", "q", "aux"), "L0*R0", "L0*R1", "L1*R0")
+    second = _kernel(1, ("aux", "p", "aux2"), "L0*R0", "(L1+L2)*R1")
+    final = _kernel(2, ("aux2", "p", "p"), "L1*R2", "0", "0", "0")
+    particles, reduced = _reduce(auxiliaries, (first, second, final))
+    assert [particle.component_dimension for particle in particles[-2:]] == [1, 1]
+    old_middle = replace(
+        second,
+        component_expressions=tuple(
+            value.to_canonical_string() for value in _compose(second, {"left": first})
+        ),
+    )
+    new_middle = replace(
+        reduced[1],
+        component_expressions=tuple(
+            value.to_canonical_string()
+            for value in _compose(reduced[1], {"left": reduced[0]})
+        ),
+    )
+    _assert_equal(
+        _compose(final, {"left": old_middle}),
+        _compose(reduced[2], {"left": new_middle}),
+    )
+
+
+@pytest.mark.parametrize("with_consumer", (False, True))
+def test_unobserved_family_does_not_create_a_zero_width_current(with_consumer):
+    aux = _particle("aux", 2)
+    kernels = (_kernel(0, ("p", "q", "aux"), "L0*R0", "L1*R1"),)
+    if with_consumer:
+        kernels += (_kernel(1, ("aux", "p", "p"), "0", "0", "0", "0"),)
+    particles, reduced = _reduce((aux,), kernels)
+    assert particles[-1] == aux
+    assert reduced == kernels
+
+
+def test_no_contact_trees_does_not_start_additional_symbolic_work(monkeypatch):
+    particles = (_particle("p"),)
+
+    def unexpected():
+        raise AssertionError("no symbolic reduction is needed")
+
+    monkeypatch.setattr(_sym, "_ensure_symbolica", unexpected)
+    assert reduce_contact_auxiliary_components(
+        particles, (), auxiliary_particles=(), model_symbols=_SYMBOLS
+    ) == (particles, ())
diff --git a/pyamplicol/tests/unit/test_compiler_kernel_scale.py b/pyamplicol/tests/unit/test_compiler_kernel_scale.py
new file mode 100644
index 0000000000..1005e85c52
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiler_kernel_scale.py
@@ -0,0 +1,58 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pyamplicol.models import compiler_symbolica as _sym
+from pyamplicol.models.compiler_kernels import _equivalent_component_scale
+
+
+def test_compact_component_scale_accepts_only_an_exact_sign() -> None:
+    _sym._ensure_symbolica()
+    compact = (_sym.E("x+1"), _sym.E("2*x-3"))
+
+    positive = _equivalent_component_scale(compact, compact)
+    negative = _equivalent_component_scale(
+        tuple(-component for component in compact),
+        compact,
+    )
+    float_positive = _equivalent_component_scale(
+        (_sym.E("-1.00000000000000*(x+1)"),),
+        (_sym.E("-(x+1)"),),
+    )
+    rescaled = _equivalent_component_scale(
+        tuple(2 * component for component in compact),
+        compact,
+    )
+    disjoint = _equivalent_component_scale(
+        (_sym.E("1.1*(x+1)"),),
+        (_sym.E("y+1"),),
+    )
+
+    assert positive == _sym.E("1")
+    assert negative == _sym.E("-1")
+    assert float_positive == _sym.E("1")
+    assert rescaled is None
+    assert disjoint is None
+
+
+def test_disjoint_symbol_support_fails_closed_before_expansion() -> None:
+    class FakeSymbol:
+        def __init__(self, name: str) -> None:
+            self.name = name
+
+        def to_canonical_string(self) -> str:
+            return self.name
+
+    class NoExpandExpression:
+        def __init__(self, symbol: str) -> None:
+            self.symbol = FakeSymbol(symbol)
+
+        def get_all_symbols(self, _include_functions: bool) -> list[FakeSymbol]:
+            return [self.symbol]
+
+        def __sub__(self, _other: object) -> object:
+            raise AssertionError("disjoint support must return before subtraction")
+
+    assert _equivalent_component_scale(
+        (NoExpandExpression("x"),),  # type: ignore[arg-type]
+        (NoExpandExpression("y"),),  # type: ignore[arg-type]
+    ) is None
diff --git a/pyamplicol/tests/unit/test_compiler_particle_metadata.py b/pyamplicol/tests/unit/test_compiler_particle_metadata.py
new file mode 100644
index 0000000000..edcd23fedb
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiler_particle_metadata.py
@@ -0,0 +1,239 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from fractions import Fraction
+
+import pytest
+
+from pyamplicol._internal.physics.symbols import symbols
+from pyamplicol.models.builtin.adapters import build_model_payload
+from pyamplicol.models.builtin.compiler import compile_model_ir as compile_builtin_ir
+from pyamplicol.models.compiler_contractions import compile_contraction_records
+from pyamplicol.models.compiler_entry import (
+    _compile_four_point_contact_kernels,
+    compile_ufo_model_ir,
+)
+from pyamplicol.models.compiler_records import _particle
+from pyamplicol.models.contracts import (
+    CompiledModelIR,
+    CompiledParticleRecord,
+    CompiledVertexTerm,
+    compiled_particle_component_dimension,
+)
+
+
+def _particle_payload(name: str = "phi") -> dict[str, object]:
+    return {
+        "name": name,
+        "antiname": name,
+        "pdg_code": 9_500_001,
+        "spin": 1,
+        "color": 1,
+        "mass": "ZERO",
+        "width": "ZERO",
+        "charge": 0.0,
+        "quantum_numbers": [["electric_charge", "0"]],
+        "ghost_number": 0,
+        "propagating": True,
+        "goldstoneboson": False,
+        "propagator": None,
+    }
+
+
+def _compiled_particle(
+    *,
+    name: str = "phi",
+    pdg_code: int = 9_500_001,
+    component_dimension: object = None,
+) -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=name,
+        pdg_code=pdg_code,
+        spin=1,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+        component_dimension=component_dimension,  # type: ignore[arg-type]
+    )
+
+
+@pytest.mark.parametrize(
+    ("charge", "exact"),
+    [("2/3", "2/3"), ("-2/6", "-1/3"), ("0", "0"), (1, "1"), (0.5, "1/2")],
+)
+def test_loader_particle_charge_accepts_exact_rationals_and_numbers(
+    charge: object, exact: str,
+) -> None:
+    payload = _particle_payload()
+    payload.pop("quantum_numbers")
+    payload.update(charge=charge, y_charge="-1", y_charge_right="-2")
+
+    particle = _particle(payload)
+
+    assert particle.charge == pytest.approx(float(Fraction(exact)))
+    # Chiral hypercharges are not conserved charges of the whole Dirac particle.
+    assert particle.quantum_numbers == (("electric_charge", exact),)
+
+
+def test_loader_particle_charge_preserves_explicit_flow_metadata() -> None:
+    payload = _particle_payload()
+    payload.update(charge="2/3", quantum_numbers=[["electric_charge", "2/3"]])
+
+    particle = _particle(payload)
+
+    assert particle.charge == pytest.approx(2 / 3)
+    assert particle.quantum_numbers == (("electric_charge", "2/3"),)
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    [
+        ("component_dimension", 6),
+        ("component_dimension", None),
+        ("auxiliary_kind", "antisymmetric-tensor"),
+        ("auxiliary_kind", None),
+    ],
+)
+def test_untrusted_particle_rejects_compiler_owned_metadata(
+    field: str,
+    value: object,
+) -> None:
+    payload = _particle_payload()
+    payload[field] = value
+
+    with pytest.raises(ValueError, match=rf"compiler-owned metadata.*{field}"):
+        _particle(payload)
+
+
+def test_untrusted_particle_cannot_self_mark_metadata_as_builtin() -> None:
+    payload = _particle_payload()
+    payload.update(
+        {
+            "component_dimension": 6,
+            "auxiliary_kind": "antisymmetric-tensor",
+        }
+    )
+    model_payload = {
+        "name": "spoofed-builtin-marker",
+        "builtin_model": True,
+        "particles": [payload],
+    }
+
+    with pytest.raises(ValueError, match="compiler-owned metadata in untrusted input"):
+        compile_ufo_model_ir(model_payload)
+
+
+@pytest.mark.parametrize("dimension", [True, False, 1.0, "1", object()])
+def test_compiled_particle_rejects_non_integer_component_dimension(
+    dimension: object,
+) -> None:
+    with pytest.raises(TypeError, match="component dimension must be an integer"):
+        _compiled_particle(component_dimension=dimension)
+
+
+@pytest.mark.parametrize("dimension", [0, -1])
+def test_compiled_particle_rejects_non_positive_component_dimension(
+    dimension: int,
+) -> None:
+    with pytest.raises(ValueError, match="component dimension must be positive"):
+        _compiled_particle(component_dimension=dimension)
+
+
+def test_trusted_builtin_particle_metadata_is_preserved() -> None:
+    model_payload, _parameter_defaults = build_model_payload()
+    compiled = compile_builtin_ir(model_payload)
+    particle = next(item for item in compiled.particles if item.pdg_code == -21)
+
+    assert particle.component_dimension == 6
+    assert particle.auxiliary_kind == "antisymmetric-tensor"
+    assert compiled_particle_component_dimension(particle) == 6
+    assert particle.statistics == "auxiliary"
+    direct = tuple(
+        record
+        for record in compiled.direct_contractions
+        if record.left_particle == particle.name
+        or record.right_particle == particle.name
+    )
+    assert tuple(record.contraction_ir.name for record in direct) == (
+        "antisymmetric-tensor",
+    )
+
+    round_trip = CompiledModelIR.from_dict(compiled.to_dict())
+    restored = next(item for item in round_trip.particles if item.pdg_code == -21)
+    assert restored.component_dimension == 6
+    assert restored.auxiliary_kind == "antisymmetric-tensor"
+    assert round_trip.direct_contractions == compiled.direct_contractions
+
+
+def test_generic_contractions_ignore_builtin_auxiliary_tags() -> None:
+    particle = CompiledParticleRecord(
+        name="model_auxiliary",
+        antiname="model_auxiliary",
+        pdg_code=9_700_001,
+        spin=-1,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=False,
+        goldstoneboson=False,
+        propagator=None,
+        component_dimension=6,
+        auxiliary_kind="antisymmetric-tensor",
+    )
+
+    direct, closure = compile_contraction_records((particle,), (), ())
+
+    assert direct == ()
+    assert closure == ()
+
+
+def test_compiler_generated_contact_auxiliary_keeps_owned_metadata() -> None:
+    names = ("a", "b", "c", "d")
+    particles = tuple(
+        _compiled_particle(name=name, pdg_code=9_600_000 + index)
+        for index, name in enumerate(names)
+    )
+    term = CompiledVertexTerm(
+        id=902,
+        vertex="V_scalar_contact",
+        particles=names,
+        color_index=0,
+        lorentz_index=0,
+        color_source="1",
+        color_expression="1",
+        lorentz_name="L_scalar_contact",
+        lorentz_source="1",
+        lorentz_expression="1",
+        coupling="GC_scalar_contact",
+        coupling_expression="1",
+        coupling_orders=(),
+    )
+
+    auxiliaries, kernels = _compile_four_point_contact_kernels(
+        (term,),
+        particles,
+        start_kind=0,
+        model_symbols=symbols.model("trusted-contact-metadata"),
+    )
+
+    assert auxiliaries
+    assert kernels
+    assert all(particle.component_dimension == 1 for particle in auxiliaries)
+    assert all(
+        compiled_particle_component_dimension(particle) == 1 for particle in auxiliaries
+    )
+    assert all(
+        particle.auxiliary_kind is not None
+        and particle.auxiliary_kind.startswith("ufo-contact:")
+        for particle in auxiliaries
+    )
diff --git a/pyamplicol/tests/unit/test_compiler_recurrence_color.py b/pyamplicol/tests/unit/test_compiler_recurrence_color.py
new file mode 100644
index 0000000000..cccf11cb87
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiler_recurrence_color.py
@@ -0,0 +1,149 @@
+# SPDX-License-Identifier: 0BSD
+
+from dataclasses import replace
+
+import pytest
+
+from pyamplicol.models.compiler_color_flow import (
+    compile_lc_color_transition_terms,
+)
+from pyamplicol.models.contracts import CompiledOrientedKernel
+
+
+def _kernel(structure: str) -> CompiledOrientedKernel:
+    return CompiledOrientedKernel(
+        kind=7,
+        term_id=3,
+        vertex="V_1",
+        particles=("left", "right", "result"),
+        source_particle_legs=(0, 1, 2),
+        component_expressions=("1",),
+        coupling_expression="1",
+        coupling_orders=(),
+        runtime_parameters=(),
+        color_source="exact-color-source",
+        color_expression="exact-color-expression",
+        color_projection_structure=structure,
+        color_projection_coefficient=(1.0, 0.0),
+    )
+
+
+@pytest.mark.parametrize(
+    ("representations", "permutation", "component"),
+    (
+        ((3, 8, -3), (0, 1), "open-string"),
+        ((8, 3, -3), (1, 0), "open-string"),
+        ((8, -3, 3), (0, 1), "open-string"),
+        ((-3, 8, 3), (1, 0), "open-string"),
+        ((3, -3, 8), (0, 1), "adjoint-segment"),
+        ((-3, 3, 8), (1, 0), "adjoint-segment"),
+    ),
+)
+def test_fundamental_generator_terms_are_orientation_explicit(
+    representations: tuple[int, int, int],
+    permutation: tuple[int, int],
+    component: str,
+) -> None:
+    terms = compile_lc_color_transition_terms(
+        _kernel("fundamental-generator"),
+        representations,
+        proof_source="test-exact-projection",
+    )
+    assert len(terms) == 1
+    assert terms[0].input_permutation == permutation
+    assert terms[0].component_operation == "concatenate-join"
+    assert terms[0].result_component_kind == component
+
+
+@pytest.mark.parametrize(
+    ("current_representations", "tensor_representations", "permutation"),
+    (
+        ((3, 8, 3), (3, 8, -3), (0, 1)),
+        ((-3, 8, -3), (-3, 8, 3), (1, 0)),
+    ),
+)
+def test_fundamental_generator_separates_current_shape_from_tensor_role(
+    current_representations: tuple[int, int, int],
+    tensor_representations: tuple[int, int, int],
+    permutation: tuple[int, int],
+) -> None:
+    terms = compile_lc_color_transition_terms(
+        _kernel("fundamental-generator"),
+        current_representations,
+        proof_source="test-exact-projection",
+        tensor_role_representations=tensor_representations,
+    )
+
+    assert len(terms) == 1
+    assert terms[0].input_permutation == permutation
+    assert terms[0].component_operation == "concatenate-join"
+    assert terms[0].result_shape_kind == (
+        "fundamental-open-string"
+        if current_representations[2] == 3
+        else "antifundamental-open-string"
+    )
+
+
+def test_adjoint_structure_constant_is_an_exact_commutator() -> None:
+    terms = compile_lc_color_transition_terms(
+        _kernel("adjoint-structure-constant"),
+        (8, 8, 8),
+        proof_source="test-exact-projection",
+    )
+    assert tuple(term.input_permutation for term in terms) == ((0, 1), (1, 0))
+    assert tuple(term.exact_factor_expression for term in terms) == ("1", "-1")
+    assert len({term.proof_digest for term in terms}) == 2
+
+
+@pytest.mark.parametrize(
+    ("structure", "representations", "closure_kind"),
+    (
+        ("color-identity", (3, -3, 1), "open-string"),
+        ("adjoint-structure-constant", (8, 8, 8), "trace"),
+        ("singlet", (1, 1, 1), None),
+    ),
+)
+def test_compiler_attaches_exact_lc_closure_companions(
+    structure: str,
+    representations: tuple[int, int, int],
+    closure_kind: str | None,
+) -> None:
+    kernel = _kernel(structure)
+    transitions = compile_lc_color_transition_terms(
+        kernel,
+        representations,
+        proof_source="test-exact-projection",
+    )
+
+    compiled = replace(kernel, lc_color_transition_terms=transitions)
+
+    assert len(compiled.lc_color_closure_terms) == 1
+    closure = compiled.lc_color_closure_terms[0]
+    assert closure.component_operation == "close"
+    assert closure.result_component_kind == closure_kind
+    assert closure.result_component_role == "none"
+    assert closure.result_shape_kind is None
+    assert closure.exact_factor_expression == "1"
+    assert ("contract-kind", "closure") in closure.provenance
+
+
+def test_compiler_omits_closure_for_noncontractible_input_pair() -> None:
+    kernel = _kernel("fundamental-generator")
+    transitions = compile_lc_color_transition_terms(
+        kernel,
+        (3, 8, -3),
+        proof_source="test-exact-projection",
+    )
+
+    compiled = replace(kernel, lc_color_transition_terms=transitions)
+
+    assert compiled.lc_color_closure_terms == ()
+
+
+def test_colored_literal_singlet_fails_without_contact_provenance() -> None:
+    with pytest.raises(ValueError, match="requires explicit contact provenance"):
+        compile_lc_color_transition_terms(
+            replace(_kernel("singlet"), particles=("a", "b", "c")),
+            (3, -3, 1),
+            proof_source="test-exact-projection",
+        )
diff --git a/pyamplicol/tests/unit/test_compiler_tensor_order.py b/pyamplicol/tests/unit/test_compiler_tensor_order.py
new file mode 100644
index 0000000000..141c01a5ab
--- /dev/null
+++ b/pyamplicol/tests/unit/test_compiler_tensor_order.py
@@ -0,0 +1,313 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import re
+from copy import deepcopy
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.models import CompiledUFOModel, compile_model_source
+from pyamplicol.models.compiler_kernels import _ordered_dense_tensor_components
+from pyamplicol.models.compiler_tensor_ordering import (
+    identity_ordering_for_materialized_axes,
+)
+from pyamplicol.models.contracts import CompiledOrientedKernel
+from pyamplicol.models.loading import CompiledModel
+
+SCALAR_GRAVITY_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "scalar_gravity"
+)
+_SPIN2_AXIS_PATTERN = re.compile(r"(?<![-0-9])(?P<axis>[12])00(?P<leg>[0-9]+)\b")
+_DUMMY_INDEX_PATTERN = re.compile(r"(?P<prefix>[(,]\s*)-(?P<label>[0-9]+)(?=\s*[,)])")
+
+
+class _Argument:
+    def __init__(self, label: str) -> None:
+        self.label = label
+
+    def to_canonical_string(self) -> str:
+        return f"spenso::mink(4,{self.label})"
+
+    def to_expression(self) -> _Argument:
+        return self
+
+
+class _DenseTensor:
+    def __init__(
+        self,
+        values: tuple[int, ...],
+        axes: tuple[_Argument, ...],
+        shape: tuple[int, ...],
+    ) -> None:
+        self.values = values
+        self.axes = axes
+        self.shape = shape
+
+    def __len__(self) -> int:
+        return len(self.values)
+
+    def __getitem__(self, index: int) -> int:
+        return self.values[index]
+
+
+class _Tensor:
+    def __init__(self) -> None:
+        # Storage follows the actual (leg 4, leg 3) structure.
+        self.values = (0, 10, 1, 11)
+        self.coordinates = ((0, 0), (0, 1), (1, 0), (1, 1))
+        self._axes = (_Argument("ufo_l_1_4"), _Argument("ufo_l_1_3"))
+        self._shape = (2, 2)
+
+    def to_dense(self) -> _DenseTensor:
+        # Released Symbolica returns a new tensor in logical row-major order.
+        values = tuple(
+            value
+            for _, value in sorted(zip(self.coordinates, self.values, strict=True))
+        )
+        return _DenseTensor(values, self._axes, self._shape)
+
+
+def test_dense_tensor_components_follow_physical_ufo_axis_order() -> None:
+    ordered = _ordered_dense_tensor_components(
+        _Tensor(),
+        ("ufo_l_1_3", "ufo_l_1_4"),
+    )
+
+    assert ordered.values == (0, 1, 10, 11)
+    assert tuple(axis.extent for axis in ordered.ordering.axes) == (2, 2)
+    assert ordered.ordering.component_basis == (0, 1, 2, 3)
+
+
+def test_spenso_tensor_components_preserve_logical_axis_order() -> None:
+    from symbolica import E
+    from symbolica.community.tensor import Representation, Tensor, TensorName
+
+    left = Representation.euc(2)("ufo_l_1_3")
+    right = Representation.euc(3)("ufo_l_1_4")
+    tensor = Tensor.dense(
+        TensorName("tensor_order_actual")(right, left),
+        [
+            E(str(left_index * 10 + right_index))
+            for right_index in range(3)
+            for left_index in range(2)
+        ],
+    )
+    ordered = _ordered_dense_tensor_components(tensor, ("ufo_l_1_3", "ufo_l_1_4"))
+
+    assert ordered.values == tuple(E(str(value)) for value in (0, 1, 2, 10, 11, 12))
+    assert tuple(axis.extent for axis in ordered.ordering.axes) == (2, 3)
+
+
+class _RectangularTensor(_Tensor):
+    def __init__(self) -> None:
+        super().__init__()
+        self.values = (12, 0, 1, 2, 10, 11)
+        self.coordinates = ((2, 1), (0, 0), (1, 0), (2, 0), (0, 1), (1, 1))
+        self._shape = (3, 2)
+
+
+def test_dense_tensor_components_validate_non_square_cartesian_grid() -> None:
+    ordered = _ordered_dense_tensor_components(
+        _RectangularTensor(),
+        ("ufo_l_1_3", "ufo_l_1_4"),
+    )
+
+    assert ordered.values == (0, 1, 2, 10, 11, 12)
+    assert tuple(axis.extent for axis in ordered.ordering.axes) == (2, 3)
+    assert ordered.ordering.canonical_size == 6
+
+
+class _IncompleteTensor(_Tensor):
+    def __init__(self) -> None:
+        super().__init__()
+        self.values = (0, 1, 10)
+        self.coordinates = ((0, 0), (0, 1), (1, 0))
+
+
+def test_dense_tensor_components_reject_incomplete_cartesian_grid() -> None:
+    with pytest.raises(ValueError, match="complete Cartesian component grid"):
+        _ordered_dense_tensor_components(
+            _IncompleteTensor(),
+            ("ufo_l_1_3", "ufo_l_1_4"),
+        )
+
+
+class _Spin2Tensor(_Tensor):
+    def __init__(self) -> None:
+        super().__init__()
+        self.coordinates = tuple(
+            reversed(tuple((right, left) for right in range(4) for left in range(4)))
+        )
+        self.values = tuple(
+            left * 4 + right for right, left in self.coordinates
+        )
+        self._axes = (_Argument("ufo_l_2_3"), _Argument("ufo_l_1_3"))
+        self._shape = (4, 4)
+
+
+def test_spin2_axis_transpose_and_storage_permutation_canonicalize() -> None:
+    labels = ("ufo_l_1_3", "ufo_l_2_3")
+    ordered = _ordered_dense_tensor_components(_Spin2Tensor(), labels)
+
+    assert ordered.values == tuple(range(16))
+    assert ordered.ordering.basis == "lorentz-rank-2"
+    assert (
+        ordered.ordering.ordering_id
+        == identity_ordering_for_materialized_axes(
+            labels,
+            (4, 4),
+        ).ordering_id
+    )
+
+
+def _transpose_spin2_axes(source: str) -> str:
+    return _SPIN2_AXIS_PATTERN.sub(
+        lambda match: (
+            ("2" if match.group("axis") == "1" else "1") + "00" + match.group("leg")
+        ),
+        source,
+    )
+
+
+def _rename_lorentz_dummies(source: str) -> str:
+    return _DUMMY_INDEX_PATTERN.sub(
+        lambda match: match.group("prefix") + f"-{7_000 + int(match.group('label'))}",
+        source,
+    )
+
+
+def _kernel_numeric_values(
+    model: CompiledUFOModel,
+    kernel: CompiledOrientedKernel,
+) -> tuple[complex, ...]:
+    particles = {particle.name: particle for particle in model.compiled.ir.particles}
+
+    def current(name: str, phase: float) -> tuple[complex, ...]:
+        pdg = particles[name].pdg_code
+        return tuple(
+            complex(index + 1, phase * (index + 1))
+            for index in range(model.current_dimension(pdg, 0))
+        )
+
+    left = current(kernel.particles[0], 0.125)
+    right = current(kernel.particles[1], -0.25)
+    values = model._projected_kernel_components(
+        kernel,
+        left,
+        right,
+        left_chirality=0,
+        right_chirality=0,
+        result_chirality=0,
+        left_momentum=(3.0, 0.2, -0.4, 2.9),
+        right_momentum=(2.0, -0.1, 0.5, -1.9),
+        runtime_parameter_values={name: 1.0 for name in kernel.runtime_parameters},
+    )
+    return tuple(complex(value) for value in values)
+
+
+def _minimal_scalar_gravity_vertex_model() -> dict[str, object]:
+    source_path = SCALAR_GRAVITY_ROOT / "scalar_gravity.json"
+    source = json.loads(source_path.read_text(encoding="utf-8"))
+    source["vertex_rules"] = [
+        vertex for vertex in source["vertex_rules"] if vertex["name"] == "V_S0S0Gr"
+    ]
+    source["lorentz_structures"] = [
+        lorentz
+        for lorentz in source["lorentz_structures"]
+        if lorentz["name"] in {"SSTmpart", "SST"}
+    ]
+    used_couplings = {
+        name
+        for row in source["vertex_rules"][0]["couplings"]
+        for name in row
+        if name is not None
+    }
+    source["couplings"] = [
+        coupling
+        for coupling in source["couplings"]
+        if coupling["name"] in used_couplings
+    ]
+    return source
+
+
+def test_external_spin2_axis_and_dummy_relabeling_preserve_numeric_kernels(
+    tmp_path: Path,
+) -> None:
+    restriction_path = SCALAR_GRAVITY_ROOT / "restrict_default.json"
+    source = _minimal_scalar_gravity_vertex_model()
+    relabelled = deepcopy(source)
+    changed = 0
+    renamed_dummy = False
+    for lorentz in relabelled["lorentz_structures"]:
+        if lorentz["name"] not in {"SSTmpart", "SST"}:
+            continue
+        original = lorentz["structure"]
+        transformed = _rename_lorentz_dummies(_transpose_spin2_axes(original))
+        assert transformed != original
+        renamed_dummy |= transformed != _transpose_spin2_axes(original)
+        lorentz["structure"] = transformed
+        changed += 1
+    assert changed == 2
+    assert renamed_dummy
+
+    source_path = tmp_path / "scalar_gravity-original.json"
+    relabelled_path = tmp_path / "scalar_gravity-relabelled.json"
+    local_restriction_path = tmp_path / "restrict_default.json"
+    source_path.write_text(
+        json.dumps(source, sort_keys=True, separators=(",", ":")) + "\n",
+        encoding="utf-8",
+    )
+    relabelled_path.write_text(
+        json.dumps(relabelled, sort_keys=True, separators=(",", ":")) + "\n",
+        encoding="utf-8",
+    )
+    local_restriction_path.write_bytes(restriction_path.read_bytes())
+
+    compiled = compile_model_source(
+        source_path,
+        restriction=str(local_restriction_path.resolve()),
+        use_cache=False,
+    )
+    relabelled_compiled = compile_model_source(
+        relabelled_path,
+        restriction=str(local_restriction_path.resolve()),
+        use_cache=False,
+    )
+    assert relabelled_compiled.ir.tensor_orderings == compiled.ir.tensor_orderings
+    assert relabelled_compiled.ir.current_orderings == compiled.ir.current_orderings
+
+    def kernels_by_orientation(
+        model: CompiledModel,
+    ) -> dict[tuple[tuple[str, ...], tuple[int, int, int]], CompiledOrientedKernel]:
+        return {
+            (kernel.particles, kernel.source_particle_legs): kernel
+            for kernel in model.ir.oriented_kernels
+            if kernel.vertex == "V_S0S0Gr"
+        }
+
+    kernels = kernels_by_orientation(compiled)
+    relabelled_kernels = kernels_by_orientation(relabelled_compiled)
+    assert kernels.keys() == relabelled_kernels.keys()
+    assert len(kernels) == 3
+
+    model = CompiledUFOModel(compiled)
+    relabelled_model = CompiledUFOModel(relabelled_compiled)
+    saw_nonzero = False
+    for key, kernel in kernels.items():
+        relabelled_kernel = relabelled_kernels[key]
+        assert relabelled_kernel.input_ordering_ids == kernel.input_ordering_ids
+        assert relabelled_kernel.output_ordering_id == kernel.output_ordering_id
+        assert relabelled_kernel.component_expressions == kernel.component_expressions
+        expected = _kernel_numeric_values(model, kernel)
+        actual = _kernel_numeric_values(relabelled_model, relabelled_kernel)
+        assert actual == pytest.approx(expected, rel=1.0e-12, abs=1.0e-14)
+        saw_nonzero |= any(abs(value) > 1.0e-14 for value in expected)
+    assert saw_nonzero
diff --git a/pyamplicol/tests/unit/test_conditioned_report_validation.py b/pyamplicol/tests/unit/test_conditioned_report_validation.py
new file mode 100644
index 0000000000..246d6bee8a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_conditioned_report_validation.py
@@ -0,0 +1,438 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+from copy import deepcopy
+from types import SimpleNamespace
+
+import pytest
+
+from tools.performance_report.agreements import (
+    BUILTIN_UFO_RECURRENCE,
+    DIRECT_AGREEMENT_V2_ABI,
+    INDEPENDENT_AUTHORITY_ABI,
+    INDEPENDENT_AUTHORITY_FIELD,
+    independent_numerical_authorities,
+    validate_direct_agreement_records,
+)
+from tools.performance_report.cache import _validate_conditioned_measurement_bindings
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.final_audit import (
+    _stored_independent_pointwise_matches_baseline,
+)
+from tools.performance_report.measurement import (
+    conditioned_measurement_comparison,
+    reconcile_independent_authority,
+)
+from tools.performance_report.models import (
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    MeasurementSpec,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from tools.performance_report.runner import (
+    SelectorContract,
+    pointwise_validation,
+    resolved_sum_validation,
+    validate_conditioned_comparison_record,
+    validate_resolved_sum_validation_record,
+)
+
+
+def _source_binding(
+    *,
+    point_identity: str = "a" * 64,
+    selector_identity: dict[str, object] | None = None,
+) -> dict[str, object]:
+    identity = selector_identity or {"cell_id": "candidate", "value_kind": "total"}
+    digest = hashlib.sha256(
+        json.dumps(
+            identity,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+    return {
+        "point_digest": point_identity,
+        "selector_component_identity": identity,
+        "selector_component_sha256": digest,
+        "candidate_source_sha256": "b" * 64,
+        "baseline_source_sha256": "c" * 64,
+    }
+
+
+def _cell() -> CellSpec:
+    return CellSpec(
+        dataset_id="test",
+        process_key="test",
+        process="d d~ > z",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        measurement=MeasurementSpec(
+            execution_mode=ExecutionMode.RECURRENCE,
+            backend="jit",
+            model=ModelKey.BUILTIN_SM,
+            accuracy=Accuracy.FULL,
+            jit_optimization_level=2,
+        ),
+    )
+
+
+def test_conditioned_comparison_has_no_tiny_absolute_escape() -> None:
+    failed = pointwise_validation(
+        1.0e-16,
+        0.0,
+        comparison_binding=_source_binding(),
+    )
+    assert failed["status"] == "validation_failed"
+    assert failed["comparison_scale"] == 1.0e-16
+    assert failed["conditioned_residual"] == 1.0
+
+    cancelled = pointwise_validation(
+        1.0e-16,
+        0.0,
+        candidate_scale=1.0e-3,
+        baseline_scale=1.0e-3,
+        comparison_binding=_source_binding(),
+    )
+    assert cancelled["status"] == "ok"
+    validate_conditioned_comparison_record(cancelled, require_binding=True)
+
+
+def test_conditioned_zero_scale_and_scale_validation_are_fail_closed() -> None:
+    exact = pointwise_validation(
+        0.0,
+        0.0,
+        comparison_binding=_source_binding(),
+    )
+    assert exact["comparison_scale"] == 0.0
+    assert exact["conditioned_residual"] == 0.0
+    assert exact["error_bound"] == 0.0
+
+    with pytest.raises(ValueError, match="smaller"):
+        pointwise_validation(2.0, 2.0, candidate_scale=1.0)
+    with pytest.raises(ValueError, match="finite"):
+        pointwise_validation(1.0, 1.0, baseline_scale=float("inf"))
+
+
+def test_legacy_comparison_reuse_rejects_floor_only_acceptance() -> None:
+    floor_only = {
+        "status": "ok",
+        "candidate": 1.0e-16,
+        "baseline": 0.0,
+        "absolute_difference": 1.0e-16,
+        "relative_difference": 1.0e-16 / 1.0e-300,
+        "relative_tolerance": 1.0e-12,
+        "absolute_tolerance": 1.0e-15,
+    }
+    with pytest.raises(ValueError, match="safely reusable"):
+        validate_conditioned_comparison_record(floor_only, require_binding=False)
+
+    safely_relative = {
+        "status": "ok",
+        "candidate": 1.0 + 1.0e-13,
+        "baseline": 1.0,
+        "absolute_difference": abs((1.0 + 1.0e-13) - 1.0),
+        "relative_difference": abs((1.0 + 1.0e-13) - 1.0),
+        "relative_tolerance": 1.0e-12,
+        "absolute_tolerance": 1.0e-15,
+    }
+    validate_conditioned_comparison_record(safely_relative, require_binding=False)
+
+    unbound_resolved = {
+        "status": "ok",
+        "maximum_absolute_difference": 1.0e-16,
+        "maximum_relative_difference": 1.0,
+        "relative_tolerance": 1.0e-12,
+        "absolute_tolerance": 1.0e-15,
+    }
+    with pytest.raises(ValueError, match="floor-only or unbound"):
+        validate_resolved_sum_validation_record(unbound_resolved)
+
+
+def test_resolved_l1_scale_is_bound_and_tampering_is_rejected() -> None:
+    class Runtime:
+        def evaluate(self, _points, **_kwargs):
+            return (1.0e-16,)
+
+        def evaluate_resolved(self, _points, **_kwargs):
+            return SimpleNamespace(
+                values=(((1.0, -1.0 + 1.0e-16),),),
+                helicity_ids=("h0",),
+                color_ids=("c0", "c1"),
+                total=lambda: (1.0e-16,),
+            )
+
+    record = resolved_sum_validation(
+        Runtime(),
+        (((1.0, 0.0, 0.0, 1.0),),),
+        cell=_cell(),
+        selector_contract=None,
+    )
+    assert record["status"] == "ok"
+    point = record["points"][0]
+    assert point["candidate_scale"] >= 1.0
+    assert point["baseline_scale"] >= 1.0
+    validate_resolved_sum_validation_record(record)
+
+    point["comparison_binding"]["point_index"] = 1
+    with pytest.raises(ValueError, match="binding differs"):
+        validate_resolved_sum_validation_record(record)
+
+
+def test_direct_agreement_v2_authenticates_conditioned_fields() -> None:
+    comparison = pointwise_validation(
+        1.0,
+        1.0,
+        comparison_binding=_source_binding(),
+    )
+    comparison.pop("abi")
+    record = {
+        "abi": DIRECT_AGREEMENT_V2_ABI,
+        "edge_kind": BUILTIN_UFO_RECURRENCE,
+        "value_kind": "matrix_element",
+        "baseline_cell_id": "baseline",
+        "candidate_cell_id": "candidate",
+        **comparison,
+    }
+    validate_direct_agreement_records([record], expected_candidate_id="candidate")
+
+    record["candidate_scale"] = 0.5
+    with pytest.raises(ValueError, match="numerical record"):
+        validate_direct_agreement_records([record], expected_candidate_id="candidate")
+
+    legacy_floor = {
+        "abi": "pyamplicol-report-direct-agreement-v1",
+        "edge_kind": BUILTIN_UFO_RECURRENCE,
+        "value_kind": "matrix_element",
+        "baseline_cell_id": "baseline",
+        "candidate_cell_id": "candidate",
+        "status": "ok",
+        "candidate": 1.0e-16,
+        "baseline": 0.0,
+        "absolute_difference": 1.0e-16,
+        "relative_difference": 1.0e-16 / 1.0e-300,
+        "relative_tolerance": 1.0e-12,
+        "absolute_tolerance": 1.0e-15,
+    }
+    with pytest.raises(ValueError, match="numerical record"):
+        validate_direct_agreement_records([legacy_floor])
+
+
+def test_completed_unverified_candidate_can_be_compared_to_late_authority() -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n1-dd-z-jets-contracted"
+    )
+    candidate_value = 1.0 + 1.0e-13
+    resolved_point = pointwise_validation(
+        candidate_value,
+        candidate_value,
+        candidate_scale=candidate_value,
+        baseline_scale=candidate_value,
+        comparison_binding={
+            "abi": "pyamplicol-report-resolved-component-scale-v1",
+            "point_digest": "a" * 64,
+            "helicity_ids": [],
+            "color_flow_ids": [],
+            "resolved_ordering_sha256": "c" * 64,
+            "resolved_source_sha256": "b" * 64,
+            "point_index": 0,
+        },
+    )
+    resolved = {
+        "abi": "pyamplicol-report-resolved-sum-validation-v2",
+        "status": "ok",
+        "maximum_absolute_difference": 0.0,
+        "maximum_relative_difference": 0.0,
+        "maximum_conditioned_residual": 0.0,
+        "relative_tolerance": 1.0e-12,
+        "point_digest": "a" * 64,
+        "helicity_ids": [],
+        "color_flow_ids": [],
+        "resolved_ordering_sha256": "c" * 64,
+        "resolved_source_sha256": "b" * 64,
+        "scale_source": "resolved-component-l1",
+        "precision_digits": 16,
+        "points": [resolved_point],
+    }
+    candidate = {
+        "status": "unverified",
+        "matrix_element": candidate_value,
+        "selector_contract": None,
+        "validation": {"resolved_sum": resolved},
+        "provenance": {"report_momenta": [[[1.0, 0.0, 0.0, 1.0]]]},
+    }
+    authority = {
+        "status": "ok",
+        "matrix_element": 1.0,
+        "selector_contract": None,
+        "validation": {"point_digest": "a" * 64},
+        "provenance": {"report_momenta": [[[1.0, 0.0, 0.0, 1.0]]]},
+    }
+    comparison = conditioned_measurement_comparison(cell, candidate, authority)
+    assert comparison["status"] == "ok"
+    assert comparison["candidate_scale_source"] == "resolved-component-l1"
+    validate_conditioned_comparison_record(comparison, require_binding=True)
+    candidate["validation"]["pointwise"] = comparison  # type: ignore[index]
+    authority_cell = independent_numerical_authorities(cell)[0]
+    assert _stored_independent_pointwise_matches_baseline(
+        cell,
+        candidate,
+        authority_cell,
+        authority,
+    )
+    comparison["comparison_binding"]["baseline_source_sha256"] = "f" * 64
+    assert not _stored_independent_pointwise_matches_baseline(
+        cell,
+        candidate,
+        authority_cell,
+        authority,
+    )
+    candidate["validation"]["resolved_sum"]["point_digest"] = comparison[  # type: ignore[index]
+        "comparison_binding"
+    ]["point_digest"]
+    candidate["validation"]["pointwise"] = comparison  # type: ignore[index]
+    _validate_conditioned_measurement_bindings(
+        candidate["validation"],  # type: ignore[arg-type]
+        expected_cell=cell,
+        selector_contract=None,
+    )
+    comparison["comparison_binding"]["candidate_source_sha256"] = "d" * 64  # type: ignore[index]
+    with pytest.raises(ValueError, match="candidate scale source"):
+        _validate_conditioned_measurement_bindings(
+            candidate["validation"],  # type: ignore[arg-type]
+            expected_cell=cell,
+            selector_contract=None,
+        )
+
+    candidate["matrix_element"] = 0.5
+    with pytest.raises(RuntimeError, match="differs from resolved-sum"):
+        conditioned_measurement_comparison(cell, candidate, authority)
+
+
+@pytest.mark.parametrize("authority_value", (1.0, 2.0))
+def test_late_authority_reconciliation_promotes_or_fails(
+    authority_value: float,
+) -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n1-dd-z-jets-contracted"
+    )
+    candidate = deepcopy(
+        # Reuse the authenticated resolved-scale fixture built by the adjacent
+        # test without relying on any campaign artifact.
+        {
+            "status": ResultStatus.UNVERIFIED.value,
+            "matrix_element": 1.0,
+            "selector_contract": None,
+            "validation": {
+                "point_digest": "a" * 64,
+                INDEPENDENT_AUTHORITY_FIELD: {
+                    "abi": INDEPENDENT_AUTHORITY_ABI,
+                    "expected_cell_ids": [
+                        item.cell_id
+                        for item in independent_numerical_authorities(cell)
+                    ],
+                    "selected_cell_id": None,
+                    "status": "unavailable",
+                    "reason": "no-successful-independent-authority",
+                    "same_artifact_diagnostics_are_authority": False,
+                },
+            },
+            "failure": {
+                "kind": "IndependentAuthorityUnavailable",
+                "message": "no authority",
+            },
+        }
+    )
+    authority = {
+        "status": ResultStatus.OK.value,
+        "matrix_element": authority_value,
+        "selector_contract": None,
+        "validation": {"point_digest": "a" * 64},
+        "provenance": {},
+    }
+    authority_id = independent_numerical_authorities(cell)[0].cell_id
+
+    reconciled = reconcile_independent_authority(
+        cell,
+        candidate,
+        authority,
+        authority_cell_id=authority_id,
+    )
+
+    expected = (
+        ResultStatus.OK.value
+        if authority_value == 1.0
+        else ResultStatus.VALIDATION_FAILED.value
+    )
+    assert reconciled["status"] == expected
+    record = reconciled["validation"][INDEPENDENT_AUTHORITY_FIELD]
+    assert record["selected_cell_id"] == authority_id
+    assert record["status"] == (
+        "verified" if authority_value == 1.0 else "mismatch"
+    )
+
+
+def test_late_lc_all_flow_authority_compares_only_common_component() -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-lc-n4-dd-tt-jets-all-flow"
+    )
+    contract = SelectorContract(
+        selected_color_flow_ids=("flow:1,2,3",),
+        selected_color_words=((1, 2, 3),),
+        all_flow_helicity_ids=("h:-1,+1,-1",),
+        all_flow_source_helicities=((1, -1), (2, 1), (3, -1)),
+        point_digest="a" * 64,
+    ).as_dict()
+
+    def component(cell_id: str, value: float) -> dict[str, object]:
+        return {
+            "abi": "pyamplicol-report-lc-common-component-v1",
+            "cell_id": cell_id,
+            "value": value,
+            "point_digest": contract["point_digest"],
+            "helicity_ids": contract["all_flow_helicity_ids"],
+            "color_flow_ids": contract["selected_color_flow_ids"],
+        }
+
+    candidate = {
+        "status": "unverified",
+        "matrix_element": 99.0,
+        "selector_contract": contract,
+        "validation": {
+            "lc_common_component": component(cell.cell_id, 2.0),
+        },
+    }
+    authority_id = "reference-amplicol-lc-n4-dd-tt-jets-all-flow"
+    authority = {
+        "status": "ok",
+        "matrix_element": 1.0,
+        "selector_contract": contract,
+        "validation": {
+            "legacy_numerical_authority": {
+                "abi": "pyamplicol-report-legacy-numerical-authority-v1",
+                "source": "all-flow-selected-provider-replay",
+            },
+            "lc_common_component": component(authority_id, 2.0),
+        },
+    }
+    comparison = conditioned_measurement_comparison(cell, candidate, authority)
+    assert comparison["status"] == "ok"
+    assert comparison["candidate"] == 2.0
+    assert comparison["baseline"] == 2.0
+    assert (
+        comparison["comparison_binding"]["selector_component_identity"][  # type: ignore[index]
+            "value_kind"
+        ]
+        == "lc_common_component"
+    )
+
+    authority["validation"]["lc_common_component"]["value"] = 3.0  # type: ignore[index]
+    mismatch = conditioned_measurement_comparison(cell, candidate, authority)
+    assert mismatch["status"] == "validation_failed"
diff --git a/pyamplicol/tests/unit/test_config_models.py b/pyamplicol/tests/unit/test_config_models.py
new file mode 100644
index 0000000000..dd19a57651
--- /dev/null
+++ b/pyamplicol/tests/unit/test_config_models.py
@@ -0,0 +1,436 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import FrozenInstanceError, is_dataclass, replace
+
+import pytest
+
+from pyamplicol.config import (
+    CONFIG_SECTIONS,
+    FIELD_REGISTRY,
+    Action,
+    BenchmarkConfig,
+    ColorAccuracy,
+    ColorConfig,
+    ColorContraction,
+    ColorFFTBasis,
+    ConfigurationError,
+    CppConfig,
+    EagerEvaluatorConfig,
+    EvaluationConfig,
+    EvaluatorBackend,
+    EvaluatorConfig,
+    EvaluatorExecutionMode,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    LCFlowLayout,
+    ModelConfig,
+    OutputConfig,
+    ProcessConfig,
+    ProcessEntry,
+    ProcessGroupAnalysis,
+    RecurrenceEvaluatorConfig,
+    RelationDiscoveryMode,
+    RunConfig,
+    SymbolicaConfig,
+)
+
+
+def test_schema_v1_registry_contains_every_contract_leaf() -> None:
+    assert len(FIELD_REGISTRY) == 83
+    assert "generation.umami_grouping" not in FIELD_REGISTRY
+    assert "evaluator.jit.direct_translation" not in FIELD_REGISTRY
+    assert FIELD_REGISTRY["action"].required
+    assert FIELD_REGISTRY["generation.workers"].default == "auto"
+    assert FIELD_REGISTRY["generation.validation.samples"].default == 2
+    assert FIELD_REGISTRY["evaluator.jit.optimization_level"].choices == (
+        0,
+        1,
+        2,
+        3,
+    )
+    assert FIELD_REGISTRY["evaluator.jit.compress"].kind == "auto_bool"
+    assert FIELD_REGISTRY["evaluator.jit.compress"].default == "auto"
+    assert FIELD_REGISTRY["evaluator.execution_mode"].choices == (
+        EvaluatorExecutionMode.COMPILED,
+        EvaluatorExecutionMode.EAGER,
+        EvaluatorExecutionMode.RECURRENCE,
+        EvaluatorExecutionMode.ON_THE_FLY,
+    )
+    assert (
+        FIELD_REGISTRY["evaluator.execution_mode"].default
+        is EvaluatorExecutionMode.RECURRENCE
+    )
+    assert FIELD_REGISTRY["color.lc_flow_layout"].default == (
+        LCFlowLayout.TOPOLOGY_REPLAY
+    )
+    assert FIELD_REGISTRY["color.lc_flow_layout"].choices == (
+        LCFlowLayout.TOPOLOGY_REPLAY,
+        LCFlowLayout.ALL_FLOW_UNION,
+    )
+    assert FIELD_REGISTRY["color.contraction"].default is ColorContraction.AUTO
+    assert FIELD_REGISTRY["color.contraction"].choices == (
+        ColorContraction.AUTO,
+        ColorContraction.DIRECT,
+        ColorContraction.SYMMETRIC_GROUP_FFT,
+    )
+    assert FIELD_REGISTRY["color.fft_basis"].default is ColorFFTBasis.ADJOINT
+    assert FIELD_REGISTRY["color.fft_basis"].choices == tuple(ColorFFTBasis)
+    assert FIELD_REGISTRY["evaluator.eager.point_tile_size"].default == 1024
+    assert FIELD_REGISTRY["evaluator.eager.workspace_mib"].default == 256
+    assert "evaluator.eager" in CONFIG_SECTIONS
+    assert FIELD_REGISTRY["evaluator.recurrence.point_tile_size"].default == 1024
+    assert FIELD_REGISTRY["evaluator.recurrence.workspace_mib"].default == 256
+    assert "evaluator.recurrence" in CONFIG_SECTIONS
+    assert FIELD_REGISTRY["generation.relation_discovery.mode"].default is (
+        RelationDiscoveryMode.OFF
+    )
+    assert (
+        FIELD_REGISTRY["generation.relation_discovery.precision_digits"].default == 96
+    )
+    assert (
+        FIELD_REGISTRY["generation.relation_discovery.verification_probe_count"].default
+        == 4
+    )
+    assert (
+        FIELD_REGISTRY["generation.relation_discovery.relative_tolerance"].default
+        == 1.0e-70
+    )
+    assert (
+        FIELD_REGISTRY["generation.relation_discovery.absolute_tolerance"].default
+        == 1.0e-80
+    )
+    assert "generation.relation_discovery" in CONFIG_SECTIONS
+    assert FIELD_REGISTRY["process.multiparticles"].dynamic_kind == "list_str"
+    assert FIELD_REGISTRY["process.entries"].kind == "process_entries"
+    assert FIELD_REGISTRY["process.reference_color_order"].kind == "list_int"
+    assert FIELD_REGISTRY["process.selected_color_sector_ids"].kind == "list_int"
+    assert FIELD_REGISTRY["process.selected_source_helicities"].dynamic_kind == "int"
+    assert FIELD_REGISTRY["process.flavor_blind"].default is False
+    assert FIELD_REGISTRY["process.consider_charge_conjugation"].default is True
+    assert FIELD_REGISTRY["process.only_unit_multiplier"].default is False
+    assert FIELD_REGISTRY["process.analyze_process_groups"].choices == (
+        ProcessGroupAnalysis.NONE,
+        ProcessGroupAnalysis.NUMERICAL,
+    )
+    assert "process.requests" not in FIELD_REGISTRY
+    assert "process.names" not in FIELD_REGISTRY
+    assert "evaluator.stage_local_parameter_layout" not in FIELD_REGISTRY
+    assert {
+        "color.coverage",
+        "color.flow_ids",
+        "generation.validation.zero_current_filter",
+        "generation.validation.current_merging",
+    }.isdisjoint(FIELD_REGISTRY)
+
+
+def test_all_public_configuration_dataclasses_are_frozen() -> None:
+    classes = (
+        BenchmarkConfig,
+        ColorConfig,
+        CppConfig,
+        EagerEvaluatorConfig,
+        EvaluationConfig,
+        EvaluatorConfig,
+        EvaluatorOptimizationConfig,
+        GenerationConfig,
+        GenerationRelationDiscoveryConfig,
+        GenerationValidationConfig,
+        JITConfig,
+        ModelConfig,
+        OutputConfig,
+        ProcessConfig,
+        ProcessEntry,
+        RecurrenceEvaluatorConfig,
+        RunConfig,
+        SymbolicaConfig,
+    )
+    assert all(is_dataclass(cls) and cls.__dataclass_params__.frozen for cls in classes)
+    config = RunConfig(action="generate")
+    with pytest.raises(FrozenInstanceError):
+        config.action = "evaluate"  # type: ignore[misc]
+
+
+def test_configuration_collections_are_immutable() -> None:
+    entry = ProcessEntry(expression="d d~ > z g", name="ddbar_zg")
+    process = ProcessConfig(
+        entries=(entry,),
+        multiparticles={"j": ["u", "d", "g"]},
+        max_coupling_orders={"QCD": 2},
+    )
+    assert process.entries == (entry,)
+    assert process.multiparticles["j"] == ("u", "d", "g")
+    with pytest.raises(FrozenInstanceError):
+        entry.name = "renamed"  # type: ignore[misc]
+    with pytest.raises(TypeError):
+        process.max_coupling_orders["QED"] = 1  # type: ignore[index]
+
+
+def test_process_entries_validate_names_and_uniqueness() -> None:
+    with pytest.raises(ConfigurationError, match="must start with a letter"):
+        ProcessEntry(expression="d d~ > z", name="1-invalid")
+    with pytest.raises(ConfigurationError, match="duplicates: 'same'"):
+        ProcessConfig(
+            entries=(
+                ProcessEntry("d d~ > z", "same"),
+                ProcessEntry("u u~ > z", "same"),
+            )
+        )
+
+
+def test_process_grouping_settings_are_typed() -> None:
+    process = ProcessConfig()
+    assert not process.flavor_blind
+    assert process.consider_charge_conjugation
+    assert not process.only_unit_multiplier
+    assert process.analyze_process_groups is ProcessGroupAnalysis.NONE
+    assert (
+        ProcessConfig(analyze_process_groups="numerical").analyze_process_groups  # type: ignore[arg-type]
+        is ProcessGroupAnalysis.NUMERICAL
+    )
+    with pytest.raises(ConfigurationError, match=r"process\.flavor_blind"):
+        ProcessConfig(flavor_blind=1)  # type: ignore[arg-type]
+    with pytest.raises(ConfigurationError, match=r"process\.analyze_process_groups"):
+        ProcessConfig(analyze_process_groups="symbolic")  # type: ignore[arg-type]
+    assert RunConfig(action="group-processes").action is Action.GROUP_PROCESSES
+
+
+def test_schema_and_jit_settings_reject_wrong_boolean_integer_types() -> None:
+    with pytest.raises(ConfigurationError, match="schema_version"):
+        RunConfig(action="generate", schema_version=True)  # type: ignore[arg-type]
+    with pytest.raises(ConfigurationError, match="optimization_level"):
+        JITConfig(optimization_level=True)  # type: ignore[arg-type]
+    with pytest.raises(ConfigurationError, match="compress"):
+        JITConfig(compress=1)  # type: ignore[arg-type]
+
+
+def test_contract_defaults_are_typed() -> None:
+    config = RunConfig(action="evaluate")
+    assert config.action is Action.EVALUATE
+    assert config.color.accuracy is ColorAccuracy.LC
+    assert config.color.contraction is ColorContraction.AUTO
+    assert config.color.fft_basis is ColorFFTBasis.ADJOINT
+    assert config.resolved_color.contraction is ColorContraction.DIRECT
+    assert config.resolved_color.fft_basis is ColorFFTBasis.TRACE
+    assert config.color.lc_flow_layout is LCFlowLayout.TOPOLOGY_REPLAY
+    assert config.evaluator.backend is EvaluatorBackend.JIT
+    assert config.evaluator.execution_mode is EvaluatorExecutionMode.RECURRENCE
+    assert config.evaluator.jit.compress == "auto"
+    assert config.evaluator.resolved_jit_compress is False
+    assert config.evaluator.eager == EagerEvaluatorConfig()
+    assert config.evaluator.recurrence == RecurrenceEvaluatorConfig()
+    assert config.schema_version == 1
+    assert config.generation.validation.samples == 2
+    assert config.generation.relation_discovery.mode is RelationDiscoveryMode.OFF
+    assert config.generation.relation_discovery.precision_digits == 96
+    assert config.generation.relation_discovery.probe_count == 4
+    assert config.generation.relation_discovery.verification_probe_count == 4
+    assert config.generation.relation_discovery.relative_tolerance == 1.0e-70
+    assert config.generation.relation_discovery.absolute_tolerance == 1.0e-80
+    assert config.evaluator.output_chunk_size == 512
+    assert not config.evaluator.cpp.native_arch
+    assert config.evaluator.optimization.max_common_pair_cache_entries == 5_000_000
+    assert config.benchmark.target_runtime == 10.0
+    assert config.benchmark.precision == 16
+    assert config.output == OutputConfig()
+
+
+def test_jit_compression_auto_tracks_python_configuration_overrides() -> None:
+    recurrence = EvaluatorConfig()
+    compiled = replace(recurrence, execution_mode="compiled")
+
+    assert recurrence.jit.compress == compiled.jit.compress == "auto"
+    assert recurrence.resolved_jit_compress is False
+    assert compiled.resolved_jit_compress is True
+    assert (
+        replace(compiled, jit=JITConfig(optimization_level=3)).resolved_jit_compress
+        is False
+    )
+    assert (
+        replace(compiled, jit=JITConfig(compress=False)).resolved_jit_compress is False
+    )
+
+
+def test_relation_discovery_defaults_off_and_validates_certification_policy() -> None:
+    assert GenerationRelationDiscoveryConfig().mode is RelationDiscoveryMode.OFF
+    assert (
+        GenerationRelationDiscoveryConfig(mode="off").mode is RelationDiscoveryMode.OFF
+    )
+    assert (
+        GenerationRelationDiscoveryConfig(mode="diagnostic").mode
+        is RelationDiscoveryMode.DIAGNOSTIC
+    )
+    assert (
+        GenerationRelationDiscoveryConfig(mode="certified-reuse").mode
+        is RelationDiscoveryMode.CERTIFIED_REUSE
+    )
+    with pytest.raises(ConfigurationError, match="precision_digits"):
+        GenerationRelationDiscoveryConfig(precision_digits=79)
+    with pytest.raises(ConfigurationError, match="probe_count"):
+        GenerationRelationDiscoveryConfig(probe_count=1)
+    with pytest.raises(ConfigurationError, match="verification_probe_count"):
+        GenerationRelationDiscoveryConfig(verification_probe_count=1)
+    with pytest.raises(ConfigurationError, match="relative_tolerance"):
+        GenerationRelationDiscoveryConfig(relative_tolerance=-1.0)
+    with pytest.raises(ConfigurationError, match="absolute_tolerance"):
+        GenerationRelationDiscoveryConfig(absolute_tolerance=-1.0)
+    with pytest.raises(ConfigurationError, match="negative zero"):
+        GenerationRelationDiscoveryConfig(
+            relative_tolerance=-0.0,
+            absolute_tolerance=1.0e-80,
+        )
+    with pytest.raises(ConfigurationError, match="negative zero"):
+        GenerationRelationDiscoveryConfig(
+            relative_tolerance=1.0e-70,
+            absolute_tolerance=-0.0,
+        )
+    subnormal = GenerationRelationDiscoveryConfig(
+        relative_tolerance=float.fromhex("0x0.0000000000001p-1022"),
+        absolute_tolerance=0.0,
+    )
+    assert subnormal.relative_tolerance.hex() == "0x0.0000000000001p-1022"
+    with pytest.raises(ConfigurationError, match="cannot both be zero"):
+        GenerationRelationDiscoveryConfig(
+            relative_tolerance=0.0,
+            absolute_tolerance=0.0,
+        )
+
+
+def test_all_flow_union_layout_requires_lc_accuracy() -> None:
+    assert (
+        ColorConfig(lc_flow_layout="all-flow-union").lc_flow_layout
+        is LCFlowLayout.ALL_FLOW_UNION
+    )
+    with pytest.raises(ConfigurationError, match=r"requires color\.accuracy='lc'"):
+        ColorConfig(accuracy="nlc", lc_flow_layout="all-flow-union")
+    with pytest.raises(ConfigurationError, match=r"requires color\.accuracy='lc'"):
+        ColorConfig(accuracy="full", lc_flow_layout="all-flow-union")
+
+
+@pytest.mark.parametrize("fft_basis", tuple(ColorFFTBasis))
+def test_symmetric_group_fft_requires_contracted_color_and_supported_lane(
+    fft_basis: ColorFFTBasis,
+) -> None:
+    with pytest.raises(ConfigurationError, match=r"requires color\.accuracy"):
+        ColorConfig(contraction="symmetric-group-fft", fft_basis=fft_basis)
+
+    for accuracy in ("nlc", "full"):
+        for execution_mode in ("recurrence", "on-the-fly"):
+            config = RunConfig(
+                action="generate",
+                color=ColorConfig(
+                    accuracy=accuracy,
+                    contraction="symmetric-group-fft",
+                    fft_basis=fft_basis,
+                ),
+                evaluator=EvaluatorConfig(execution_mode=execution_mode),
+            )
+            assert config.color.contraction is ColorContraction.SYMMETRIC_GROUP_FFT
+            assert config.color.fft_basis is fft_basis
+
+    compiled_direct = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="full"),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+    assert compiled_direct.resolved_color.contraction is ColorContraction.DIRECT
+
+    for execution_mode in ("compiled", "eager"):
+        with pytest.raises(
+            ConfigurationError,
+            match=r"requires evaluator\.execution_mode='recurrence' or 'on-the-fly'",
+        ):
+            RunConfig(
+                action="generate",
+                process=ProcessConfig(selected_source_helicities={"1": 1}),
+                color=ColorConfig(
+                    accuracy="full",
+                    contraction="symmetric-group-fft",
+                    fft_basis=fft_basis,
+                ),
+                evaluator=EvaluatorConfig(execution_mode=execution_mode),
+            )
+
+
+def test_direct_contraction_ignores_the_default_adjoint_basis() -> None:
+    config = RunConfig(
+        action="generate", color=ColorConfig(accuracy="full", contraction="direct")
+    )
+    assert config.resolved_color.contraction is ColorContraction.DIRECT
+    assert config.resolved_color.fft_basis is ColorFFTBasis.TRACE
+
+
+def test_automatic_color_tracks_python_configuration_overrides() -> None:
+    config = RunConfig(action="generate")
+    full = replace(config, color=replace(config.color, accuracy="full"))
+    assert full.resolved_color.contraction is ColorContraction.AUTO
+    assert full.resolved_color.fft_basis is ColorFFTBasis.ADJOINT
+    compiled = replace(
+        full, evaluator=replace(full.evaluator, execution_mode="compiled")
+    )
+    assert compiled.resolved_color.contraction is ColorContraction.DIRECT
+    assert compiled.resolved_color.fft_basis is ColorFFTBasis.TRACE
+
+
+def test_fft_basis_rejects_unknown_values() -> None:
+    with pytest.raises(ConfigurationError, match=r"color\.fft_basis"):
+        ColorConfig(accuracy="full", fft_basis="other")
+
+
+def test_on_the_fly_execution_supports_every_color_accuracy() -> None:
+    selected_flow = RunConfig(
+        action="generate",
+        evaluator=EvaluatorConfig(execution_mode="on-the-fly"),
+    )
+    all_flow = RunConfig(
+        action="generate",
+        color=ColorConfig(lc_flow_layout="all-flow-union"),
+        evaluator=EvaluatorConfig(execution_mode="on-the-fly"),
+    )
+    assert selected_flow.evaluator.execution_mode is EvaluatorExecutionMode.ON_THE_FLY
+    assert all_flow.evaluator.execution_mode is EvaluatorExecutionMode.ON_THE_FLY
+    for accuracy in ("nlc", "full"):
+        contracted = RunConfig(
+            action="generate",
+            color=ColorConfig(accuracy=accuracy),
+            evaluator=EvaluatorConfig(execution_mode="on-the-fly"),
+        )
+        assert contracted.color.accuracy.value == accuracy
+        assert contracted.evaluator.execution_mode is EvaluatorExecutionMode.ON_THE_FLY
+
+
+@pytest.mark.parametrize(
+    ("field_name", "value"),
+    (("point_tile_size", 0), ("workspace_mib", -1), ("workspace_mib", True)),
+)
+def test_eager_evaluator_sizes_must_be_positive_integers(
+    field_name: str, value: object
+) -> None:
+    with pytest.raises(ConfigurationError, match=rf"evaluator\.eager\.{field_name}"):
+        EagerEvaluatorConfig(**{field_name: value})  # type: ignore[arg-type]
+
+
+@pytest.mark.parametrize(
+    ("field_name", "value"),
+    (("point_tile_size", 0), ("workspace_mib", -1), ("workspace_mib", True)),
+)
+def test_recurrence_evaluator_sizes_must_be_positive_integers(
+    field_name: str, value: object
+) -> None:
+    with pytest.raises(
+        ConfigurationError, match=rf"evaluator\.recurrence\.{field_name}"
+    ):
+        RecurrenceEvaluatorConfig(**{field_name: value})  # type: ignore[arg-type]
+
+
+def test_cpp_flags_cannot_hide_target_cpu_requirements() -> None:
+    assert CppConfig(extra_flags=("-fno-math-errno",)).extra_flags == (
+        "-fno-math-errno",
+    )
+    with pytest.raises(ConfigurationError, match="unrecorded target CPU"):
+        CppConfig(extra_flags=("-march=native",))
+    with pytest.raises(ConfigurationError, match="unsupported compiler arguments"):
+        CppConfig(extra_flags=("-mavx2",))
diff --git a/pyamplicol/tests/unit/test_config_resolution.py b/pyamplicol/tests/unit/test_config_resolution.py
new file mode 100644
index 0000000000..848ec97740
--- /dev/null
+++ b/pyamplicol/tests/unit/test_config_resolution.py
@@ -0,0 +1,466 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.config import (
+    ClampRequest,
+    ColorContraction,
+    ColorFFTBasis,
+    ConfigurationError,
+    EvaluatorExecutionMode,
+    LCFlowLayout,
+    ProcessEntry,
+    config_to_dict,
+    config_to_toml,
+    load_config,
+    parse_override,
+    resolution_to_dict,
+    resolve_config,
+)
+
+
+def test_resolution_precedence_paths_and_clamp_record(tmp_path: Path) -> None:
+    card = tmp_path / "run.toml"
+    card.write_text(
+        """
+schema_version = 1
+action = "generate"
+
+[model]
+source = "model.json"
+
+[process]
+entries = [{ expression = "d d~ > z g", name = "ddbar_zg" }]
+
+[generation]
+output = "card-output"
+workers = 6
+""".strip(),
+        encoding="utf-8",
+    )
+
+    resolution = resolve_config(
+        card,
+        dedicated={"generation.workers": 4, "generation.output": "cli-output"},
+        overrides=("generation.workers=3", "generation.workers=2"),
+        clamps=(
+            ClampRequest(
+                "generation.workers",
+                1,
+                "unlicensed Symbolica core limit",
+            ),
+        ),
+    )
+
+    assert resolution.requested.generation.workers == 2
+    assert resolution.effective.generation.workers == 1
+    assert resolution.requested.generation.output == (tmp_path / "cli-output").resolve()
+    assert resolution.requested.model.source == str((tmp_path / "model.json").resolve())
+    assert resolution.was_clamped
+    assert resolution.clamps[0].requested == 2
+    assert resolution.clamps[0].effective == 1
+
+
+@pytest.mark.parametrize(
+    "selector",
+    ("built-in-sm-heft", "builtin_sm_heft", "sm-heft", "sm_heft"),
+)
+def test_sm_heft_model_selectors_are_not_resolved_as_paths(
+    selector: str,
+    tmp_path: Path,
+) -> None:
+    resolution = resolve_config(
+        {"action": "generate", "model": {"source": selector}},
+        base_dir=tmp_path,
+    )
+
+    assert resolution.effective.model.source == selector
+
+
+def test_dynamic_map_override_is_schema_aware(tmp_path: Path) -> None:
+    resolution = resolve_config(
+        {
+            "action": "generate",
+            "process": {
+                "entries": [{"expression": "u u~ > g g"}],
+                "multiparticles": {"j": ["u", "d"]},
+            },
+        },
+        base_dir=tmp_path,
+        overrides=(
+            'process.multiparticles.j=["u", "d", "g"]',
+            "process.max_coupling_orders.QCD=2",
+        ),
+    )
+    assert resolution.effective.process.multiparticles["j"] == ("u", "d", "g")
+    assert resolution.effective.process.max_coupling_orders["QCD"] == 2
+
+
+def test_selected_source_helicity_overrides_accept_signed_values() -> None:
+    resolution = resolve_config(
+        {"action": "generate"},
+        overrides=(
+            "process.selected_source_helicities.1=-1",
+            "process.selected_source_helicities.2=1",
+        ),
+    )
+    assert resolution.effective.process.selected_source_helicities == {"1": -1, "2": 1}
+
+
+def test_nullable_and_bare_enum_overrides() -> None:
+    assert parse_override("model.cache_dir=null").value is None
+    assert parse_override("color.accuracy=nlc").value == "nlc"
+    with pytest.raises(ConfigurationError, match="must be true or false"):
+        parse_override("model.cache=1")
+
+
+def test_eager_evaluator_card_and_dotted_overrides_round_trip() -> None:
+    pytest.importorskip("tomli_w")
+    config = resolve_config(
+        {
+            "action": "generate",
+            "evaluator": {
+                "execution_mode": "eager",
+                "eager": {"point_tile_size": 2048, "workspace_mib": 384},
+            },
+        },
+        overrides=("evaluator.eager.workspace_mib=512",),
+    ).effective
+
+    assert config.evaluator.execution_mode is EvaluatorExecutionMode.EAGER
+    assert config.evaluator.eager.point_tile_size == 2048
+    assert config.evaluator.eager.workspace_mib == 512
+    plain = config_to_dict(config)
+    assert plain["evaluator"]["eager"] == {  # type: ignore[index]
+        "point_tile_size": 2048,
+        "workspace_mib": 512,
+    }
+    assert resolve_config(plain).effective == config
+    serialized = config_to_toml(config)
+    assert 'execution_mode = "eager"' in serialized
+    assert "[evaluator.eager]" in serialized
+    assert resolve_config(tomllib.loads(serialized)).effective == config
+
+
+def test_jit_compression_card_and_dotted_override_round_trip() -> None:
+    pytest.importorskip("tomli_w")
+    config = resolve_config(
+        {
+            "action": "generate",
+            "evaluator": {"jit": {"compress": False}},
+        },
+        overrides=("evaluator.jit.compress=true",),
+    ).effective
+
+    assert config.evaluator.jit.compress is True
+    plain = config_to_dict(config)
+    assert plain["evaluator"]["jit"]["compress"] is True  # type: ignore[index]
+    assert resolve_config(plain).effective == config
+    serialized = config_to_toml(config)
+    assert "compress = true" in serialized
+    assert resolve_config(tomllib.loads(serialized)).effective == config
+
+
+@pytest.mark.parametrize("mode", ("compiled", "recurrence", "on-the-fly", "eager"))
+@pytest.mark.parametrize("level", (0, 1, 2, 3))
+def test_jit_compression_auto_resolves_only_for_compiled_o2(
+    mode: str, level: int
+) -> None:
+    resolution = resolve_config(
+        {
+            "action": "generate",
+            "evaluator": {"execution_mode": mode, "jit": {"optimization_level": level}},
+        }
+    )
+
+    assert resolution.requested.evaluator.jit.compress == "auto"
+    assert resolution.effective.evaluator.jit.compress is (
+        mode == "compiled" and level == 2
+    )
+    assert config_to_dict(resolution.effective)["evaluator"]["jit"]["compress"] is (  # type: ignore[index]
+        mode == "compiled" and level == 2
+    )
+    # A mode override must resolve the original auto intent, not the old default.
+    compiled = resolve_config(
+        config_to_dict(resolution.requested),
+        overrides=('evaluator.execution_mode="compiled"',),
+    )
+    assert compiled.effective.evaluator.jit.compress is (level == 2)
+
+
+@pytest.mark.parametrize("compress", (True, False))
+def test_compiled_o2_compression_explicit_card_and_override_win(compress: bool) -> None:
+    card = {
+        "action": "generate",
+        "evaluator": {"execution_mode": "compiled", "jit": {"compress": compress}},
+    }
+    assert resolve_config(card).effective.evaluator.jit.compress is compress
+    override = f"evaluator.jit.compress={str(not compress).lower()}"
+    assert (
+        resolve_config(card, overrides=(override,)).effective.evaluator.jit.compress
+        is not compress
+    )
+
+
+@pytest.mark.parametrize("backend", ("cpp", "asm"))
+def test_non_jit_backends_do_not_enable_compression(backend: str) -> None:
+    config = resolve_config(
+        {
+            "action": "generate",
+            "evaluator": {"execution_mode": "compiled", "backend": backend},
+        }
+    ).effective
+    assert config.evaluator.jit.compress is False
+
+
+def test_recurrence_evaluator_card_and_dotted_overrides_round_trip() -> None:
+    pytest.importorskip("tomli_w")
+    config = resolve_config(
+        {
+            "action": "generate",
+            "evaluator": {
+                "execution_mode": "recurrence",
+                "recurrence": {"point_tile_size": 2048, "workspace_mib": 384},
+            },
+        },
+        overrides=("evaluator.recurrence.workspace_mib=512",),
+    ).effective
+
+    assert config.evaluator.execution_mode is EvaluatorExecutionMode.RECURRENCE
+    assert config.evaluator.recurrence.point_tile_size == 2048
+    assert config.evaluator.recurrence.workspace_mib == 512
+    plain = config_to_dict(config)
+    assert plain["evaluator"]["recurrence"] == {  # type: ignore[index]
+        "point_tile_size": 2048,
+        "workspace_mib": 512,
+    }
+    assert resolve_config(plain).effective == config
+    serialized = config_to_toml(config)
+    assert 'execution_mode = "recurrence"' in serialized
+    assert "[evaluator.recurrence]" in serialized
+    assert resolve_config(tomllib.loads(serialized)).effective == config
+
+
+def test_lc_flow_layout_card_and_dotted_overrides_round_trip() -> None:
+    pytest.importorskip("tomli_w")
+    config = resolve_config(
+        {
+            "action": "generate",
+            "color": {"accuracy": "lc", "lc_flow_layout": "topology-replay"},
+        },
+        overrides=("color.lc_flow_layout=all-flow-union",),
+    ).effective
+
+    assert config.color.lc_flow_layout is LCFlowLayout.ALL_FLOW_UNION
+    plain = config_to_dict(config)
+    assert plain["color"] == {  # type: ignore[index]
+        "accuracy": "lc",
+        "contraction": "direct",
+        "fft_basis": "trace",
+        "lc_flow_layout": "all-flow-union",
+    }
+    assert resolve_config(plain).effective == config
+    serialized = config_to_toml(config)
+    assert 'lc_flow_layout = "all-flow-union"' in serialized
+    assert resolve_config(tomllib.loads(serialized)).effective == config
+
+
+def test_automatic_fft_card_round_trip_and_direct_override() -> None:
+    card = {"action": "generate", "color": {"accuracy": "full"}}
+    automatic = resolve_config(card).effective
+    assert automatic.color.contraction is ColorContraction.AUTO
+    assert automatic.color.fft_basis is ColorFFTBasis.ADJOINT
+    assert resolve_config(config_to_dict(automatic)).effective == automatic
+    direct = resolve_config(card, overrides=("color.contraction=direct",)).effective
+    assert direct.color.contraction is ColorContraction.DIRECT
+    assert direct.color.fft_basis is ColorFFTBasis.TRACE
+
+
+@pytest.mark.parametrize("fft_basis", tuple(ColorFFTBasis))
+def test_symmetric_group_fft_card_and_dotted_override_round_trip(
+    fft_basis: ColorFFTBasis,
+) -> None:
+    pytest.importorskip("tomli_w")
+    config = resolve_config(
+        {
+            "action": "generate",
+            "color": {"accuracy": "full", "contraction": "direct"},
+            "evaluator": {"execution_mode": "recurrence"},
+        },
+        overrides=(
+            "color.contraction=symmetric-group-fft",
+            f"color.fft_basis={fft_basis}",
+        ),
+    ).effective
+
+    assert config.color.contraction is ColorContraction.SYMMETRIC_GROUP_FFT
+    assert config.color.fft_basis is fft_basis
+    plain = config_to_dict(config)
+    assert plain["color"] == {  # type: ignore[index]
+        "accuracy": "full",
+        "contraction": "symmetric-group-fft",
+        "fft_basis": fft_basis.value,
+        "lc_flow_layout": "topology-replay",
+    }
+    assert resolve_config(plain).effective == config
+    serialized = config_to_toml(config)
+    assert 'contraction = "symmetric-group-fft"' in serialized
+    assert f'fft_basis = "{fft_basis}"' in serialized
+    assert resolve_config(tomllib.loads(serialized)).effective == config
+
+
+def test_packaged_adjoint_fft_card_selects_certified_pure_gluon_example() -> None:
+    card = Path(__file__).resolve().parents[2] / "examples/builtin_sm_adjoint_fft.toml"
+    config = load_config(card)
+    assert config.color.contraction is ColorContraction.SYMMETRIC_GROUP_FFT
+    assert config.color.fft_basis is ColorFFTBasis.ADJOINT
+    assert config.color.accuracy == "full"
+    assert config.evaluator.execution_mode is EvaluatorExecutionMode.RECURRENCE
+    assert config.process.entries[0].expression == "g g > g g g"
+
+
+@pytest.mark.parametrize(
+    "override",
+    (
+        "evaluator.execution_mode=streaming",
+        "evaluator.eager.point_tile_size=0",
+        "evaluator.eager.workspace_mib=-1",
+    ),
+)
+def test_invalid_eager_evaluator_overrides_are_rejected(override: str) -> None:
+    with pytest.raises(ConfigurationError, match="evaluator"):
+        resolve_config({"action": "generate"}, overrides=(override,))
+
+
+@pytest.mark.parametrize(
+    "override",
+    (
+        "evaluator.recurrence.point_tile_size=0",
+        "evaluator.recurrence.workspace_mib=-1",
+    ),
+)
+def test_invalid_recurrence_evaluator_overrides_are_rejected(override: str) -> None:
+    with pytest.raises(ConfigurationError, match=r"evaluator\.recurrence"):
+        resolve_config({"action": "generate"}, overrides=(override,))
+
+
+def test_unknown_card_and_override_fields_are_errors(tmp_path: Path) -> None:
+    card = tmp_path / "bad.toml"
+    card.write_text('action = "generate"\n[generator]\nworkers = 2\n', encoding="utf-8")
+    with pytest.raises(ConfigurationError, match="unknown configuration field"):
+        load_config(card)
+    with pytest.raises(ConfigurationError, match="optimization_level"):
+        parse_override("evaluator.jit.optimisation_level=2")
+
+
+def test_removed_parallel_process_fields_suggest_typed_entries() -> None:
+    with pytest.raises(ConfigurationError, match=r"process\.entries"):
+        resolve_config(
+            {
+                "action": "generate",
+                "process": {"requests": ["d d~ > z"], "names": ["ddbar_z"]},
+            }
+        )
+
+
+def test_process_entry_override_and_optional_name() -> None:
+    config = resolve_config(
+        {"action": "generate"},
+        overrides=(
+            'process.entries=[{ expression = "d d~ > z", name = "ddbar_z" }, '
+            '{ expression = "u u~ > z" }]',
+        ),
+    ).effective
+    assert config.process.entries == (
+        ProcessEntry("d d~ > z", "ddbar_z"),
+        ProcessEntry("u u~ > z"),
+    )
+
+
+def test_card_validation_aggregates_entry_field_and_unknown_path_errors() -> None:
+    with pytest.raises(ConfigurationError) as exc_info:
+        resolve_config(
+            {
+                "action": "generate",
+                "process": {
+                    "entries": [
+                        {"expresion": "d d~ > z", "name": "1-invalid"},
+                        7,
+                    ]
+                },
+                "generation": {"workers": False},
+                "evaluator": {"batch_size": "many"},
+                "outpt": {"format": "json"},
+            }
+        )
+
+    message = str(exc_info.value)
+    assert "configuration errors" in message
+    assert "process.entries[0].expresion" in message
+    assert "process entry expression" in message
+    assert "process entry name" in message
+    assert "process.entries[1] must be a table" in message
+    assert "generation.workers" in message
+    assert "evaluator.batch_size" in message
+    assert "output" in message
+
+
+@pytest.mark.parametrize(
+    "path",
+    (
+        "color.coverage",
+        "color.flow_ids",
+        "generation.validation.zero_current_filter",
+        "generation.validation.current_merging",
+    ),
+)
+def test_removed_generation_dotted_paths_are_errors(path: str) -> None:
+    with pytest.raises(ConfigurationError, match="unknown configuration field"):
+        parse_override(f"{path}=true")
+
+
+def test_config_serialization_uses_plain_paths_and_lists(tmp_path: Path) -> None:
+    config = resolve_config(
+        {"action": "evaluate", "evaluation": {"artifact": "artifact"}},
+        base_dir=tmp_path,
+    ).effective
+    plain = config_to_dict(config)
+    assert plain["evaluation"]["artifact"] == str((tmp_path / "artifact").resolve())  # type: ignore[index]
+    assert plain["benchmark"]["helicity_ids"] == []  # type: ignore[index]
+
+
+def test_resolution_serialization_records_requested_effective_and_reason() -> None:
+    resolution = resolve_config(
+        {"action": "generate", "generation": {"workers": 4}},
+        clamps=(ClampRequest("generation.workers", 1, "restricted mode"),),
+    )
+    plain = resolution_to_dict(resolution)
+    assert plain["requested"]["generation"]["workers"] == 4  # type: ignore[index]
+    assert plain["effective"]["generation"]["workers"] == 1  # type: ignore[index]
+    assert plain["adjustments"] == [
+        {
+            "path": "generation.workers",
+            "requested": 4,
+            "effective": 1,
+            "reason": "restricted mode",
+        }
+    ]
+
+
+def test_config_toml_round_trip_omits_nulls_without_changing_defaults() -> None:
+    pytest.importorskip("tomli_w")
+    original = resolve_config(
+        {
+            "action": "generate",
+            "process": {"entries": [{"expression": "d d~ > z"}]},
+            "generation": {"workers": 2},
+        }
+    ).effective
+    serialized = config_to_toml(original)
+    assert "null" not in serialized
+    restored = resolve_config(tomllib.loads(serialized)).effective
+    assert restored == original
diff --git a/pyamplicol/tests/unit/test_contact_color_proofs.py b/pyamplicol/tests/unit/test_contact_color_proofs.py
new file mode 100644
index 0000000000..9152e9bc0c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_contact_color_proofs.py
@@ -0,0 +1,932 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from dataclasses import replace
+from itertools import product
+from pathlib import Path
+
+import pytest
+
+from pyamplicol._internal.physics.symbols import ModelSymbolRegistry, symbols
+from pyamplicol.models import compiler_contacts
+from pyamplicol.models import compiler_symbolica as _sym
+from pyamplicol.models.compiler_contact_trees import _deduplicate_contact_partials
+from pyamplicol.models.compiler_contacts import (
+    CONTACT_DECOMPOSITION_ALGORITHM,
+    CONTACT_DECOMPOSITION_ALGORITHM_VERSION,
+    _build_contact_orbit_certificate,
+    _four_point_contact_color_split,
+    _fuse_contact_finals,
+    _record_contact_decomposition_proofs,
+)
+from pyamplicol.models.compiler_entry import (
+    _compile_four_point_contact_kernels,
+    _contact_recurrence_color_contract,
+)
+from pyamplicol.models.compiler_tensor_ordering import (
+    compile_tensor_ordering_metadata,
+)
+from pyamplicol.models.contact_decomposition import (
+    CONTACT_ORBIT_ALGORITHM,
+    CONTACT_ORBIT_ALGORITHM_VERSION,
+    CONTACT_ORBIT_EVALUATOR_CLASS,
+    CompiledContactOrbitCertificate,
+    CompiledContactOrbitStep,
+)
+from pyamplicol.models.contracts import (
+    CompiledModelIR,
+    CompiledOrientedKernel,
+    CompiledParticleRecord,
+    CompiledVertexTerm,
+)
+from pyamplicol.models.loading import (
+    CompiledModel,
+    compiler_fingerprint,
+    load_compiled_model,
+)
+
+
+def _adjoint(name: str, pdg: int, *, spin: int = 3) -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=name,
+        pdg_code=pdg,
+        spin=spin,
+        color=8,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def _scalar(
+    name: str,
+    pdg: int,
+    *,
+    antiname: str | None = None,
+    spin: int = 1,
+    color: int = 1,
+) -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=name if antiname is None else antiname,
+        pdg_code=pdg,
+        spin=spin,
+        color=color,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def _term(*, color_source: str, color_expression: str) -> CompiledVertexTerm:
+    return CompiledVertexTerm(
+        id=901,
+        vertex="V_adversarial_contact",
+        particles=("a", "b", "c", "d"),
+        color_index=0,
+        lorentz_index=0,
+        color_source=color_source,
+        color_expression=color_expression,
+        lorentz_name="L_contact",
+        lorentz_source="1",
+        lorentz_expression="1",
+        coupling="GC_contact",
+        coupling_expression="1",
+        coupling_orders=(),
+    )
+
+
+def _proof_term(
+    term: CompiledVertexTerm,
+    particles: tuple[CompiledParticleRecord, ...],
+    *,
+    model_name: str,
+) -> CompiledVertexTerm:
+    return _record_contact_decomposition_proofs(
+        (term,),
+        particles,
+        model_symbols=symbols.model(model_name),
+    )[0]
+
+
+@pytest.mark.parametrize(
+    ("particle_names", "expected_classes"),
+    (
+        (("a", "a", "a", "a"), (0, 0, 0, 0)),
+        (("a", "a", "b", "c"), (0, 0, 1, 2)),
+    ),
+)
+def test_constant_scalar_contact_issues_deterministic_orbit_contract(
+    particle_names: tuple[str, str, str, str],
+    expected_classes: tuple[int, int, int, int],
+) -> None:
+    particle_by_name = {
+        name: _scalar(name, 9_510_000 + index)
+        for index, name in enumerate(dict.fromkeys(particle_names))
+    }
+    particles = tuple(particle_by_name.values())
+    term = replace(
+        _term(color_source="1", color_expression="1"),
+        particles=particle_names,
+    )
+
+    proved = _proof_term(term, particles, model_name="scalar-contact-orbit")
+    repeated = _proof_term(term, particles, model_name="scalar-contact-orbit")
+
+    certificate = proved.contact_orbit_certificate
+    assert certificate is not None
+    assert certificate == repeated.contact_orbit_certificate
+    assert certificate.algorithm == CONTACT_ORBIT_ALGORITHM
+    assert certificate.algorithm_version == CONTACT_ORBIT_ALGORITHM_VERSION
+    assert certificate.evaluator_class == CONTACT_ORBIT_EVALUATOR_CLASS
+    assert certificate.physical_leg_equivalence_classes == expected_classes
+    assert certificate.reconstruction_factor == "1"
+    assert CompiledContactOrbitCertificate.from_dict(
+        certificate.to_dict()
+    ) == certificate
+
+    _auxiliaries, kernels = _compile_four_point_contact_kernels(
+        (proved,),
+        particles,
+        start_kind=0,
+        model_symbols=symbols.model("scalar-contact-orbit"),
+    )
+    steps = tuple(
+        step
+        for kernel in kernels
+        for step in kernel.contact_orbit_steps
+    )
+    assert steps
+    assert {step.stage for step in steps} == {"partial", "final"}
+    assert all(step.term_id == term.id for step in steps)
+    assert all(step.reconstruction_factor == "1" for step in steps)
+    assert all(
+        CompiledContactOrbitStep.from_dict(step.to_dict()) == step for step in steps
+    )
+    for kernel in kernels:
+        if kernel.contact_orbit_steps:
+            assert len(kernel.contact_orbit_steps) == 1
+            assert (
+                kernel.contact_orbit_steps[0].source_particle_legs
+                == kernel.source_particle_legs
+            )
+
+
+def test_contact_orbit_contract_rejects_tampering_and_uncertified_classes() -> None:
+    scalar = _scalar("a", 9_520_000)
+    term = replace(
+        _term(color_source="1", color_expression="1"),
+        particles=("a", "a", "a", "a"),
+    )
+    proved = _proof_term(term, (scalar,), model_name="scalar-contact-tamper")
+    certificate = proved.contact_orbit_certificate
+    assert certificate is not None
+
+    payload = certificate.to_dict()
+    payload["physical_leg_equivalence_classes"] = [0, 1, 2, 3]
+    with pytest.raises(ValueError, match="not canonical"):
+        CompiledContactOrbitCertificate.from_dict(payload)
+    payload = certificate.to_dict()
+    payload["reconstruction_factor"] = "2"
+    with pytest.raises(ValueError, match="factor must be one"):
+        CompiledContactOrbitCertificate.from_dict(payload)
+    payload = certificate.to_dict()
+    payload["unexpected"] = True
+    with pytest.raises(ValueError, match="unknown fields"):
+        CompiledContactOrbitCertificate.from_dict(payload)
+
+    vector = _scalar("v", 9_520_001, spin=3)
+    colored = _scalar("g", 9_520_002, color=8)
+    charged = _scalar("s", 9_520_003, antiname="s~")
+    anti = _scalar("s~", -9_520_003, antiname="s")
+    proof = proved.contact_decomposition_proof
+    assert proof is not None
+    assert _build_contact_orbit_certificate(term, (vector,) * 4, proof) is None
+    assert _build_contact_orbit_certificate(term, (colored,) * 4, proof) is None
+    assert (
+        _build_contact_orbit_certificate(
+            replace(term, particles=("s", "s~", "s", "s~")),
+            (charged, anti, charged, anti),
+            proof,
+        )
+        is None
+    )
+    momentum = replace(term, lorentz_expression="ufo_momentum_1_0")
+    assert _record_contact_decomposition_proofs(
+        (momentum,),
+        (scalar,),
+        model_symbols=symbols.model("contact-orbit-excluded-momentum"),
+    )[0].contact_orbit_certificate is None
+
+
+def test_single_lineage_contact_orbit_metadata_preserves_numerical_fusion() -> None:
+    particle_names = ("a", "a", "a", "a")
+    particle_by_name = {
+        name: _scalar(name, 9_519_000 + index)
+        for index, name in enumerate(dict.fromkeys(particle_names))
+    }
+    particles = tuple(particle_by_name.values())
+    term = replace(
+        _term(color_source="1", color_expression="1"),
+        particles=particle_names,
+    )
+    certified = _proof_term(term, particles, model_name="orbit-fusion-certified")
+    plain = replace(certified, contact_orbit_certificate=None)
+
+    def finalized(
+        value: CompiledVertexTerm,
+        model_name: str,
+    ) -> tuple[
+        tuple[CompiledParticleRecord, ...],
+        tuple[CompiledOrientedKernel, ...],
+    ]:
+        registry = symbols.model(model_name)
+        auxiliaries, kernels = _compile_four_point_contact_kernels(
+            (value,), particles, start_kind=0, model_symbols=registry
+        )
+        auxiliaries, kernels = _deduplicate_contact_partials(
+            auxiliaries, kernels, (value,), model_symbols=registry
+        )
+        return auxiliaries, _fuse_contact_finals(
+            kernels, (value,), model_symbols=registry
+        )
+
+    certified_auxiliaries, certified_kernels = finalized(
+        certified, "orbit-fusion-invariant"
+    )
+    plain_auxiliaries, plain_kernels = finalized(
+        plain, "orbit-fusion-invariant"
+    )
+
+    assert certified_auxiliaries == plain_auxiliaries
+    assert tuple(
+        replace(kernel, contact_orbit_steps=()) for kernel in certified_kernels
+    ) == plain_kernels
+    assert len(certified_kernels) == len(plain_kernels)
+    actual_steps = tuple(
+        step for kernel in certified_kernels for step in kernel.contact_orbit_steps
+    )
+    proof = certified.contact_decomposition_proof
+    assert proof is not None
+    assert len(actual_steps) == sum(
+        len(split.orientations) for split in proof.splits
+    )
+    assert len(actual_steps) == len(set(actual_steps))
+
+
+def _mixed_scalar_contact_partials(
+    *,
+    certified: bool,
+    model_name: str,
+) -> tuple[
+    tuple[CompiledParticleRecord, ...],
+    tuple[CompiledOrientedKernel, ...],
+    CompiledVertexTerm,
+    ModelSymbolRegistry,
+]:
+    particles = tuple(
+        _scalar(name, 9_519_100 + index)
+        for index, name in enumerate(("a", "b", "c"))
+    )
+    term = replace(
+        _term(color_source="1", color_expression="1"),
+        particles=("a", "a", "b", "c"),
+    )
+    term = _proof_term(term, particles, model_name=model_name)
+    if not certified:
+        term = replace(term, contact_orbit_certificate=None)
+    registry = symbols.model(model_name)
+    auxiliaries, kernels = _compile_four_point_contact_kernels(
+        (term,), particles, start_kind=0, model_symbols=registry
+    )
+    return auxiliaries, kernels, term, registry
+
+
+def test_certified_contact_partials_keep_distinct_compiler_lineages() -> None:
+    auxiliaries, kernels, term, registry = _mixed_scalar_contact_partials(
+        certified=True,
+        model_name="orbit-lineage-distinct",
+    )
+
+    retained_auxiliaries, retained_kernels = _deduplicate_contact_partials(
+        auxiliaries,
+        kernels,
+        (term,),
+        model_symbols=registry,
+    )
+
+    lineages = {
+        particle.auxiliary_kind
+        for particle in retained_auxiliaries
+        if particle.auxiliary_kind in {
+            "ufo-contact:901:result-2:2,3",
+            "ufo-contact:901:result-3:2,3",
+        }
+    }
+    assert lineages == {
+        "ufo-contact:901:result-2:2,3",
+        "ufo-contact:901:result-3:2,3",
+    }
+    same_input_partials = tuple(
+        kernel
+        for kernel in retained_kernels
+        if kernel.vertex.endswith("::contact-partial")
+        and kernel.particles[:2] == ("a", "a")
+    )
+    assert len(same_input_partials) == 2
+    assert all(len(kernel.contact_orbit_steps) == 1 for kernel in same_input_partials)
+    assert {
+        kernel.contact_orbit_steps[0].result_leg for kernel in same_input_partials
+    } == {2, 3}
+
+
+def test_certified_contact_partial_aliases_with_same_lineage_still_deduplicate(
+) -> None:
+    auxiliaries, kernels, term, registry = _mixed_scalar_contact_partials(
+        certified=True,
+        model_name="orbit-lineage-alias",
+    )
+    auxiliary_by_name = {particle.name: particle for particle in auxiliaries}
+    original_kernel = next(
+        kernel
+        for kernel in kernels
+        if kernel.vertex.endswith("::contact-partial")
+        and kernel.particles[:2] == ("a", "a")
+    )
+    original_auxiliary = auxiliary_by_name[original_kernel.particles[2]]
+    alias_name = f"{original_auxiliary.name}_alias"
+    alias_auxiliary = replace(
+        original_auxiliary,
+        name=alias_name,
+        antiname=alias_name,
+        pdg_code=original_auxiliary.pdg_code + 100,
+    )
+    alias_kernel = replace(
+        original_kernel,
+        particles=(*original_kernel.particles[:2], alias_name),
+    )
+
+    retained_auxiliaries, retained_kernels = _deduplicate_contact_partials(
+        (original_auxiliary, alias_auxiliary),
+        (original_kernel, alias_kernel),
+        (term,),
+        model_symbols=registry,
+    )
+
+    assert retained_auxiliaries == (original_auxiliary,)
+    assert retained_kernels == (original_kernel,)
+
+
+def test_uncertified_contact_partial_numeric_deduplication_is_unchanged() -> None:
+    auxiliaries, kernels, term, registry = _mixed_scalar_contact_partials(
+        certified=False,
+        model_name="orbit-lineage-uncertified",
+    )
+
+    retained_auxiliaries, retained_kernels = _deduplicate_contact_partials(
+        auxiliaries,
+        kernels,
+        (term,),
+        model_symbols=registry,
+    )
+
+    assert len(retained_auxiliaries) == len(auxiliaries) - 1
+    same_input_partials = tuple(
+        kernel
+        for kernel in retained_kernels
+        if kernel.vertex.endswith("::contact-partial")
+        and kernel.particles[:2] == ("a", "a")
+    )
+    assert len(same_input_partials) == 1
+    assert same_input_partials[0].contact_orbit_steps == ()
+
+
+def test_compiled_ir_requires_orbit_certificate_exactly_for_certifiable_class() -> None:
+    scalar = _scalar("s", 9_520_010)
+    term = replace(
+        _term(color_source="1", color_expression="1"),
+        particles=("s", "s", "s", "s"),
+    )
+    proved = _proof_term(term, (scalar,), model_name="scalar-orbit-required")
+    auxiliaries, kernels = _compile_four_point_contact_kernels(
+        (proved,),
+        (scalar,),
+        start_kind=0,
+        model_symbols=symbols.model("scalar-orbit-required"),
+    )
+    particles = (scalar, *auxiliaries)
+    terms, kernels, orderings, current_orderings = compile_tensor_ordering_metadata(
+        (proved,),
+        particles,
+        kernels,
+        (),
+        (),
+    )
+    missing_term = replace(terms[0], contact_orbit_certificate=None)
+    missing_steps = tuple(replace(kernel, contact_orbit_steps=()) for kernel in kernels)
+    with pytest.raises(ValueError, match="has no orbit certificate"):
+        CompiledModelIR(
+            name="scalar-orbit-missing",
+            orders=(),
+            parameters=(),
+            particles=particles,
+            couplings=(),
+            propagators=(),
+            vertex_terms=(missing_term,),
+            oriented_kernels=missing_steps,
+            direct_contractions=(),
+            closure_contractions=(),
+            tensor_orderings=orderings,
+            current_orderings=current_orderings,
+        )
+
+    colored = _scalar("g", 9_520_011, color=8)
+    colored_term = replace(term, particles=("g", "g", "g", "g"))
+    colored_proved = _proof_term(
+        colored_term,
+        (colored,),
+        model_name="colored-orbit-excluded",
+    )
+    certificate = proved.contact_orbit_certificate
+    assert certificate is not None
+    forged = replace(
+        colored_proved,
+        contact_orbit_certificate=replace(
+            certificate,
+            term_id=colored_proved.id,
+            vertex=colored_proved.vertex,
+            particles=("g", "g", "g", "g"),
+        ),
+    )
+    forged_terms, _kernels, forged_orderings, forged_current_orderings = (
+        compile_tensor_ordering_metadata(
+            (forged,),
+            (colored,),
+            (),
+            (),
+            (),
+        )
+    )
+    with pytest.raises(ValueError, match="excluded evaluator class"):
+        CompiledModelIR(
+            name="vector-orbit-forged",
+            orders=(),
+            parameters=(),
+            particles=(colored,),
+            couplings=(),
+            propagators=(),
+            vertex_terms=forged_terms,
+            oriented_kernels=(),
+            direct_contractions=(),
+            closure_contractions=(),
+            tensor_orderings=forged_orderings,
+            current_orderings=forged_current_orderings,
+        )
+
+
+def test_contact_tree_uses_its_compiler_owned_singlet_contract() -> None:
+    kernel = CompiledOrientedKernel(
+        kind=1,
+        term_id=25,
+        vertex="V_5_SCALAR_00000::contact-tree-partial",
+        particles=("scalar_0", "scalar_0", "__pyamplicol_contact_tree_25_r0_1_2"),
+        source_particle_legs=(1, 2, -1),
+        component_expressions=("1",),
+        coupling_expression="1",
+        coupling_orders=(),
+        runtime_parameters=(),
+        color_source="1",
+        color_expression="1",
+    )
+
+    assert _contact_recurrence_color_contract(kernel, {}) is None
+
+
+def test_unproved_colored_four_point_contact_fails_closed() -> None:
+    term = _term(
+        color_source="UFO::{}::T(1,2,3)",
+        color_expression="model_adversarial::T(1,2,3)",
+    )
+    particles = tuple(
+        _adjoint(name, 9_300_000 + index) for index, name in enumerate(term.particles)
+    )
+
+    proved_term = _proof_term(term, particles, model_name="adversarial-contact")
+    proof = proved_term.contact_decomposition_proof
+
+    assert _four_point_contact_color_split(term, 0) is None
+    assert proof is not None
+    assert proof.status == "unsupported"
+    assert proof.splits == ()
+    assert {reason.code for reason in proof.unsupported_reasons} == {
+        "unsupported-color-factor-count"
+    }
+    assert (
+        dict(proof.unsupported_reasons[0].context)["normalized_color_expression"]
+        == term.color_expression
+    )
+    auxiliaries, kernels = _compile_four_point_contact_kernels(
+        (proved_term,),
+        particles,
+        start_kind=0,
+        model_symbols=symbols.model("adversarial-contact"),
+    )
+
+    assert auxiliaries == ()
+    assert kernels == ()
+
+
+def test_literal_color_singlet_keeps_generic_contact_split() -> None:
+    term = _term(color_source="1", color_expression="1")
+
+    split = _four_point_contact_color_split(term, 2)
+
+    assert split is not None
+    pair, remaining, *_metadata = split
+    assert pair == (0, 1)
+    assert remaining == 3
+
+
+def test_structure_constant_contact_preserves_exact_color_coefficient() -> None:
+    unit_expression = (
+        "spenso::f(ufo_c_2,ufo_c_dummy_7_adjoint,ufo_c_1)"
+        "*spenso::f(ufo_c_dummy_7_adjoint,ufo_c_3,ufo_c_4)"
+    )
+    scaled = _term(
+        color_source=("-3/2*UFO::{}::f(2,-7,1)*UFO::{}::f(-7,3,4)"),
+        color_expression=f"-3/2*{unit_expression}",
+    )
+    unit = _term(
+        color_source="UFO::{}::f(2,-7,1)*UFO::{}::f(-7,3,4)",
+        color_expression=unit_expression,
+    )
+    particles = tuple(
+        _adjoint(name, 9_400_000 + index, spin=1)
+        for index, name in enumerate(scaled.particles)
+    )
+    scaled = _proof_term(
+        scaled,
+        particles,
+        model_name="contact-color-coefficient-scaled",
+    )
+    unit = _proof_term(
+        unit,
+        particles,
+        model_name="contact-color-coefficient-unit",
+    )
+
+    split = _four_point_contact_color_split(scaled, 2)
+    assert split is not None
+    assert split[-1] == "-3/2"
+    proof = scaled.contact_decomposition_proof
+    assert proof is not None
+    assert proof.status == "proven"
+    assert proof.algorithm == CONTACT_DECOMPOSITION_ALGORITHM
+    assert proof.algorithm_version == CONTACT_DECOMPOSITION_ALGORITHM_VERSION
+    assert proof.original_color_source == scaled.color_source
+    assert proof.normalized_color_expression == scaled.color_expression
+    assert proof.original_lorentz_source == scaled.lorentz_source
+    assert proof.normalized_lorentz_expression == scaled.lorentz_expression
+    chosen = next(item for item in proof.splits if item.result_leg == 2)
+    assert chosen.decomposition_kind == "two-structure-constants"
+    assert chosen.pair_legs == (1, 0)
+    assert chosen.remaining_leg == 3
+    assert chosen.outer_color_factor == (2, -7, 1)
+    assert chosen.final_color_factor == (-7, 3, 4)
+    assert chosen.color_coefficient == "-3/2"
+    assert chosen.component_axis_order == ()
+    assert chosen.component_basis_order == (0,)
+    assert chosen.component_expansion == ((0, 1),)
+    assert chosen.dummy_index_mapping is not None
+    assert chosen.dummy_index_mapping.source_index == -7
+    assert chosen.dummy_index_mapping.normalized_symbol == "ufo_c_dummy_7_adjoint"
+    assert chosen.dummy_index_mapping.outer_slot == 1
+    assert chosen.dummy_index_mapping.final_slot == 0
+    partials = tuple(item for item in chosen.orientations if item.stage == "partial")
+    finals = tuple(item for item in chosen.orientations if item.stage == "final")
+    assert tuple(item.input_legs for item in partials) == ((1, 0), (0, 1))
+    assert tuple(item.permutation_parity for item in partials) == (-1, 1)
+    assert tuple(item.scalar_prefactor for item in partials) == ("1", "-1")
+    assert tuple(item.input_legs for item in finals) == ((-1, 3), (3, -1))
+    assert tuple(item.permutation_parity for item in finals) == (-1, 1)
+    assert tuple(item.scalar_prefactor for item in finals) == ("-3/2", "3/2")
+
+    model_symbols = symbols.model("contact-color-coefficient")
+    _scaled_auxiliaries, scaled_kernels = _compile_four_point_contact_kernels(
+        (scaled,),
+        particles,
+        start_kind=0,
+        model_symbols=model_symbols,
+    )
+    _unit_auxiliaries, unit_kernels = _compile_four_point_contact_kernels(
+        (unit,),
+        particles,
+        start_kind=0,
+        model_symbols=model_symbols,
+    )
+    scaled_finals = tuple(
+        kernel for kernel in scaled_kernels if kernel.vertex.endswith("::contact-final")
+    )
+    unit_finals = tuple(
+        kernel for kernel in unit_kernels if kernel.vertex.endswith("::contact-final")
+    )
+
+    _sym._ensure_symbolica()
+    assert len(scaled_finals) == len(unit_finals) > 0
+    for scaled_kernel, unit_kernel in zip(
+        scaled_finals,
+        unit_finals,
+        strict=True,
+    ):
+        assert scaled_kernel.particles == unit_kernel.particles
+        for scaled_component, unit_component in zip(
+            scaled_kernel.component_expressions,
+            unit_kernel.component_expressions,
+            strict=True,
+        ):
+            difference = (
+                _sym.E(scaled_component) + _sym.E("3/2") * _sym.E(unit_component)
+            ).expand()
+            assert difference == _sym.E("0")
+
+
+def test_structure_constant_contact_does_not_duplicate_normalization_sign() -> None:
+    source = "UFO::{}::f(-1,1,3)*UFO::{}::f(2,4,-1)"
+    normalized = (
+        "-spenso::f(ufo_c_1,ufo_c_3,ufo_c_dummy_1_adjoint)"
+        "*spenso::f(ufo_c_2,ufo_c_4,ufo_c_dummy_1_adjoint)"
+    )
+    term = _term(color_source=source, color_expression=normalized)
+
+    split = _four_point_contact_color_split(term, 0)
+
+    assert split is not None
+    assert split[-1] == "1"
+
+
+@pytest.mark.parametrize("spelling", ("plain", "canonical", "permuted"))
+def test_structure_constant_contact_preserves_source_orientations(
+    spelling: str,
+) -> None:
+    from pyamplicol.models.tensors import normalize_color_expression
+
+    source = "-3/2*UFO::{}::f(2,-7,1)*UFO::{}::f(-7,3,4)"
+    normalized = normalize_color_expression(source, (8, 8, 8, 8)).expression
+    _sym._ensure_symbolica()
+    if spelling == "canonical":
+        normalized = _sym.E(normalized).to_canonical_string()
+    elif spelling == "permuted":
+        # An odd permutation changes the normalized scalar, not the source
+        # coefficient or the source tensor orientations used for decomposition.
+        normalized = (
+            "3/2*spenso::f(ufo_c_dummy_7_adjoint,ufo_c_3,ufo_c_4)"
+            "*spenso::f(ufo_c_dummy_7_adjoint,ufo_c_2,ufo_c_1)"
+        )
+    term = _term(color_source=source, color_expression=normalized)
+    particles = tuple(
+        _adjoint(name, 9_450_000 + index, spin=1)
+        for index, name in enumerate(term.particles)
+    )
+    proved = _proof_term(term, particles, model_name="source-oriented-contact")
+    reference = _proof_term(
+        replace(
+            term,
+            color_expression=(
+                "-3/2*spenso::f(ufo_c_2,ufo_c_dummy_7_adjoint,ufo_c_1)"
+                "*spenso::f(ufo_c_dummy_7_adjoint,ufo_c_3,ufo_c_4)"
+            ),
+        ),
+        particles,
+        model_name="source-oriented-contact",
+    )
+    assert proved.contact_decomposition_proof is not None
+    assert reference.contact_decomposition_proof is not None
+    assert proved.contact_decomposition_proof.status == "proven"
+    assert proved.contact_decomposition_proof.splits == (
+        reference.contact_decomposition_proof.splits
+    )
+
+    def epsilon(a: int, b: int, c: int) -> int:
+        return (a - b) * (b - c) * (c - a) // 2
+
+    # Independently reconstruct the colour product in the SU(2) subalgebra,
+    # including every result orientation and all external colour assignments.
+    for split in proved.contact_decomposition_proof.splits:
+        final = next(
+            item
+            for item in split.orientations
+            if item.stage == "final" and item.input_legs[0] == -1
+        )
+        coefficient = _sym.E(final.scalar_prefactor)
+        for indices in product(range(3), repeat=4):
+            expected = _sym.E("-3/2") * sum(
+                epsilon(indices[1], dummy, indices[0])
+                * epsilon(dummy, indices[2], indices[3])
+                for dummy in range(3)
+            )
+            actual = coefficient * sum(
+                epsilon(dummy, indices[split.pair_legs[0]], indices[split.pair_legs[1]])
+                * epsilon(
+                    indices[split.result_leg], dummy, indices[split.remaining_leg]
+                )
+                for dummy in range(3)
+            )
+            assert actual == expected
+
+
+def test_structure_constant_contact_rejects_residual_color_tensor() -> None:
+    term = _term(
+        color_source=("UFO::{}::f(-1,1,2)*UFO::{}::f(3,4,-1)*UFO::{}::T(1,2,3)"),
+        color_expression=(
+            "spenso::f(ufo_c_dummy_1_adjoint,ufo_c_1,ufo_c_2)"
+            "*spenso::f(ufo_c_3,ufo_c_4,ufo_c_dummy_1_adjoint)"
+            "*spenso::t(ufo_c_1,ufo_c_2,ufo_c_3)"
+        ),
+    )
+
+    particles = tuple(
+        _adjoint(name, 9_500_000 + index) for index, name in enumerate(term.particles)
+    )
+    proved_term = _proof_term(
+        term,
+        particles,
+        model_name="residual-contact-color",
+    )
+    proof = proved_term.contact_decomposition_proof
+
+    assert _four_point_contact_color_split(term, 0) is None
+    assert proof is not None
+    assert proof.status == "unsupported"
+    assert {reason.code for reason in proof.unsupported_reasons} == {
+        "non-scalar-color-prefactor"
+    }
+
+
+def test_contact_proof_round_trips_and_lowering_does_not_rediscover(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    expression = (
+        "spenso::f(ufo_c_2,ufo_c_dummy_11_adjoint,ufo_c_1)"
+        "*spenso::f(ufo_c_dummy_11_adjoint,ufo_c_3,ufo_c_4)"
+    )
+    term = _term(
+        color_source="UFO::{}::f(2,-11,1)*UFO::{}::f(-11,3,4)",
+        color_expression=expression,
+    )
+    particles = tuple(
+        _adjoint(name, 9_600_000 + index, spin=1)
+        for index, name in enumerate(term.particles)
+    )
+    proved_term = _proof_term(term, particles, model_name="serialized-contact-proof")
+    proved_terms, _kernels, orderings, current_orderings = (
+        compile_tensor_ordering_metadata(
+            (proved_term,),
+            particles,
+            (),
+            (),
+            (),
+        )
+    )
+    proved_term = proved_terms[0]
+    model = CompiledModelIR(
+        name="serialized-contact-proof",
+        orders=(),
+        parameters=(),
+        particles=particles,
+        couplings=(),
+        propagators=(),
+        vertex_terms=(proved_term,),
+        oriented_kernels=(),
+        direct_contractions=(),
+        closure_contractions=(),
+        tensor_orderings=orderings,
+        current_orderings=current_orderings,
+    )
+    compiled = CompiledModel(
+        source={"kind": "json"},
+        producer=compiler_fingerprint(),
+        model={"name": model.name},
+        ir=model,
+        parameter_defaults={},
+        capabilities={},
+        issues=(),
+        phase_timings={},
+        conversion_seconds=0.0,
+    )
+    serialized_path = compiled.write(tmp_path / "serialized-contact-proof")
+    payload = json.loads(serialized_path.read_text(encoding="utf-8"))
+    term_payload = payload["ir"]["vertex_terms"]
+    assert isinstance(term_payload, list)
+    assert term_payload[0]["contact_decomposition_proof"]["status"] == "proven"
+    restored = load_compiled_model(serialized_path).ir.vertex_terms[0]
+
+    invalid_payload = json.loads(serialized_path.read_text(encoding="utf-8"))
+    invalid_payload["ir"]["vertex_terms"][0]["contact_decomposition_proof"][
+        "algorithm_version"
+    ] = CONTACT_DECOMPOSITION_ALGORITHM_VERSION + 1
+    invalid_path = tmp_path / "invalid-contact-proof.pyAmplicol-model.json"
+    invalid_path.write_text(json.dumps(invalid_payload), encoding="utf-8")
+    with pytest.raises(ValueError, match="unsupported contact decomposition proof"):
+        load_compiled_model(invalid_path)
+
+    def forbidden_discovery(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("contact split was rediscovered during lowering")
+
+    monkeypatch.setattr(
+        compiler_contacts,
+        "_four_point_contact_color_split",
+        forbidden_discovery,
+    )
+    auxiliaries, kernels = _compile_four_point_contact_kernels(
+        (restored,),
+        particles,
+        start_kind=0,
+        model_symbols=symbols.model("serialized-contact-proof"),
+    )
+
+    assert (
+        restored.contact_decomposition_proof == proved_term.contact_decomposition_proof
+    )
+    assert auxiliaries
+    assert any(kernel.vertex.endswith("::contact-final") for kernel in kernels)
+
+
+def test_contact_proof_identity_and_algorithm_fail_closed() -> None:
+    expression = (
+        "spenso::f(ufo_c_2,ufo_c_dummy_13_adjoint,ufo_c_1)"
+        "*spenso::f(ufo_c_dummy_13_adjoint,ufo_c_3,ufo_c_4)"
+    )
+    term = _term(
+        color_source="UFO::{}::f(2,-13,1)*UFO::{}::f(-13,3,4)",
+        color_expression=expression,
+    )
+    particles = tuple(
+        _adjoint(name, 9_700_000 + index, spin=1)
+        for index, name in enumerate(term.particles)
+    )
+    proved_term = _proof_term(term, particles, model_name="closed-contact-proof")
+    proof = proved_term.contact_decomposition_proof
+    assert proof is not None
+
+    forged_split = replace(
+        proof.splits[0],
+        component_axis_order=("ufo_l_1_1",),
+    )
+    forged_proof = replace(
+        proof,
+        splits=(forged_split, *proof.splits[1:]),
+    )
+    with pytest.raises(ValueError, match="non-canonical component axes"):
+        compile_tensor_ordering_metadata(
+            (replace(proved_term, contact_decomposition_proof=forged_proof),),
+            particles,
+            (),
+            (),
+            (),
+        )
+
+    stale = replace(proved_term, color_expression="1")
+    with pytest.raises(ValueError, match="proof identity mismatch"):
+        _compile_four_point_contact_kernels(
+            (stale,),
+            particles,
+            start_kind=0,
+            model_symbols=symbols.model("closed-contact-proof"),
+        )
+
+    with pytest.raises(ValueError, match="unsupported contact decomposition proof"):
+        replace(
+            proof,
+            algorithm_version=CONTACT_DECOMPOSITION_ALGORITHM_VERSION + 1,
+        )
+
+    with pytest.raises(ValueError, match="has no contact decomposition proof"):
+        CompiledModelIR(
+            name="missing-contact-proof",
+            orders=(),
+            parameters=(),
+            particles=particles,
+            couplings=(),
+            propagators=(),
+            vertex_terms=(term,),
+            oriented_kernels=(),
+            direct_contractions=(),
+            closure_contractions=(),
+        )
+
+    assert compiler_fingerprint()["contact_decomposition_policy"] == (
+        f"{CONTACT_DECOMPOSITION_ALGORITHM}-v{CONTACT_DECOMPOSITION_ALGORITHM_VERSION}"
+    )
diff --git a/pyamplicol/tests/unit/test_contact_tensor_execution.py b/pyamplicol/tests/unit/test_contact_tensor_execution.py
new file mode 100644
index 0000000000..b8277772a3
--- /dev/null
+++ b/pyamplicol/tests/unit/test_contact_tensor_execution.py
@@ -0,0 +1,198 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+
+import pytest
+
+from pyamplicol._internal.physics.symbols import symbols
+from pyamplicol.models import compiler_contact_trees as contact_trees
+from pyamplicol.models import compiler_symbolica as _sym
+from pyamplicol.models.compiler_contacts import _execute_dense_tensor
+from pyamplicol.models.compiler_kernels import (
+    _oriented_component_expressions,
+    _spin_axis_labels,
+    _spin_representations,
+    _spin_slots,
+)
+from pyamplicol.models.contracts import CompiledParticleRecord, CompiledVertexTerm
+
+
+def _vector(name: str, pdg: int) -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=name,
+        pdg_code=pdg,
+        spin=3,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def test_rank_zero_plain_expression_bypasses_tensor_network(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _sym._ensure_symbolica()
+    expression = _sym.E("contact_left*contact_right")
+    library = _sym.TensorLibrary.hep_lib_atom()
+
+    def unexpected_tensor_network(*_args: object, **_kwargs: object) -> None:
+        raise AssertionError("plain scalar expression must not create a tensor network")
+
+    monkeypatch.setattr(_sym, "TensorNetwork", unexpected_tensor_network)
+
+    assert _execute_dense_tensor(expression, library, axis_labels=()) == (expression,)
+
+
+def test_rank_zero_symbol_detection_is_order_independent(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class ReorderedSymbols:
+        def get_all_symbols(
+            self, *, include_function_symbols: bool = True
+        ) -> list[str]:
+            return ["left", "right"] if include_function_symbols else ["right", "left"]
+
+    expression = ReorderedSymbols()
+
+    def unexpected_tensor_network(*_args: object, **_kwargs: object) -> None:
+        raise AssertionError("symbol order must not create a tensor network")
+
+    monkeypatch.setattr(_sym, "TensorNetwork", unexpected_tensor_network)
+
+    assert _execute_dense_tensor(expression, object(), axis_labels=()) == (expression,)
+
+
+def test_rank_zero_tensor_contraction_keeps_scalar_dispatch() -> None:
+    _sym._ensure_symbolica()
+    library = _sym.TensorLibrary.hep_lib_atom()
+    representation = _sym.Representation.euc(3)
+    slot = representation("rank_zero_axis")
+    left = _sym.TensorName("rank_zero_left")
+    right = _sym.TensorName("rank_zero_right")
+    library.register(_sym.Tensor.dense(left(representation), [1, 2, 3]))
+    library.register(_sym.Tensor.dense(right(representation), [4, 5, 6]))
+    expression = left(slot).to_expression() * right(slot).to_expression()
+
+    assert _execute_dense_tensor(expression, library, axis_labels=()) == (_sym.E("32"),)
+
+
+def test_scalar_oriented_kernel_keeps_plain_expression_dispatch() -> None:
+    _sym._ensure_symbolica()
+    registry = symbols.model("scalar-oriented-dispatch")
+    particles = tuple(
+        replace(
+            _vector(f"s{index}", 9_200_000 + index),
+            spin=1,
+            wavefunction_family="scalar",
+        )
+        for index in range(3)
+    )
+    term = CompiledVertexTerm(
+        id=0,
+        vertex="V_scalar",
+        particles=tuple(particle.name for particle in particles),
+        color_index=0,
+        lorentz_index=0,
+        color_source="1",
+        color_expression="1",
+        lorentz_name="SSS",
+        lorentz_source="1",
+        lorentz_expression="1",
+        coupling="GC_scalar",
+        coupling_expression="1",
+        coupling_orders=(),
+    )
+    result = _oriented_component_expressions(
+        term,
+        {particle.name: particle for particle in particles},
+        left_leg=0,
+        right_leg=1,
+        result_leg=2,
+        kind=0,
+        model_symbols=registry,
+    )
+
+    assert result.values == (
+        (
+            registry.kernel_component(0, "left", 0)
+            * registry.kernel_component(0, "right", 0)
+        ).to_canonical_string(),
+    )
+    assert result.ordering.axes == ()
+
+
+def test_staged_contact_contraction_preserves_dense_axis_order(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _sym._ensure_symbolica()
+    registry = symbols.model("staged-contact-test")
+    particles = tuple(_vector(f"v{index}", 9_100_000 + index) for index in range(4))
+    payload = {
+        leg: (
+            tuple(registry.symbol(f"input_{leg}_{index}") for index in range(4)),
+            tuple(_sym.E("0") for _ in range(4)),
+        )
+        for leg in range(3)
+    }
+    representations = tuple(
+        representation
+        for particle in particles
+        for representation in _spin_representations(particle.spin)
+    )
+    slots = tuple(
+        slot
+        for leg, particle in enumerate(particles, start=1)
+        for slot in _spin_slots(particle.spin, leg)
+    )
+    source_name = _sym.TensorName(registry.qualified_name("test_contact"))
+    source_components = tuple(_sym.E(str(index + 1)) for index in range(4**4))
+
+    def source_tensor() -> tuple[object, object]:
+        library = _sym.TensorLibrary.hep_lib_atom()
+        library.register(
+            _sym.Tensor.dense(
+                source_name(*representations),
+                source_components,
+            )
+        )
+        return source_name(*slots).to_expression(), library
+
+    direct_expression, direct_library = source_tensor()
+    for leg, (components, _momentum) in sorted(payload.items()):
+        direct_expression *= contact_trees._contact_tree_physical_tensor_expression(
+            direct_library,
+            kind=17,
+            leg=leg,
+            spin=particles[leg].spin,
+            components=components,
+            model_symbols=registry,
+        )
+    direct = _execute_dense_tensor(
+        direct_expression,
+        direct_library,
+        axis_labels=_spin_axis_labels(particles[3].spin, 4),
+    )
+
+    monkeypatch.setattr(contact_trees, "_MAX_STAGED_CONTACT_INPUT_WORK", 4)
+    staged_expression, staged_library = source_tensor()
+    staged = contact_trees._execute_contact_tensor_staged(
+        staged_expression,
+        staged_library,
+        particles,
+        payload_by_leg=payload,
+        result_leg=3,
+        kind=17,
+        model_symbols=registry,
+    )
+
+    assert tuple(item.to_canonical_string() for item in staged) == tuple(
+        item.to_canonical_string() for item in direct
+    )
diff --git a/pyamplicol/tests/unit/test_contraction_ir.py b/pyamplicol/tests/unit/test_contraction_ir.py
new file mode 100644
index 0000000000..7a6bcd1692
--- /dev/null
+++ b/pyamplicol/tests/unit/test_contraction_ir.py
@@ -0,0 +1,508 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import FrozenInstanceError, replace
+from typing import Any
+
+import pytest
+from symbolica import S
+
+from pyamplicol.generation.artifact_writer import _execution_plan
+from pyamplicol.generation.dag_algorithms import prune_dag_to_amplitude_roots
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.runtime_schema import build_runtime_schema
+from pyamplicol.generation.stage_compiler import (
+    build_generic_stage_compiler_blueprint,
+)
+from pyamplicol.generation.stage_expressions import _amplitude_root_expression
+from pyamplicol.generation.stage_parameters import _contract_components
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models._physics_ir import ContractionIR
+from pyamplicol.models.base import Model, Particle
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.compiler_contractions import compile_contraction_records
+from pyamplicol.models.contracts import CompiledModelIR, CompiledParticleRecord
+from pyamplicol.models.external import CompiledUFOModel
+from pyamplicol.models.loading import CompiledModel
+
+
+def test_contraction_ir_json_round_trip_and_strict_decoder() -> None:
+    contraction_ir = ContractionIR(
+        name="weyl",
+        left_basis="weyl-chiral",
+        right_basis="weyl-chiral",
+        coefficients=((1.0, 0.0), (1.0, 0.0)),
+        chirality_relation="opposite",
+        metric_signature=None,
+    )
+    payload = contraction_ir.to_json_dict()
+
+    assert ContractionIR.from_json_dict(payload) == contraction_ir
+    with pytest.raises(FrozenInstanceError):
+        contraction_ir.name = "mutated"  # type: ignore[misc]
+
+    unknown = {**payload, "inferred_from_dimension": True}
+    with pytest.raises(ValueError, match="unknown fields"):
+        ContractionIR.from_json_dict(unknown)
+
+    missing_nullable = dict(payload)
+    del missing_nullable["metric_signature"]
+    with pytest.raises(ValueError, match="missing required fields"):
+        ContractionIR.from_json_dict(missing_nullable)
+
+    malformed_pair = {**payload, "coefficients": [[1.0], [1.0, 0.0]]}
+    with pytest.raises(ValueError, match="must have two components"):
+        ContractionIR.from_json_dict(malformed_pair)
+
+    all_zero = {**payload, "coefficients": [[0.0, 0.0], [0.0, 0.0]]}
+    with pytest.raises(ValueError, match="nonzero component"):
+        ContractionIR.from_json_dict(all_zero)
+
+    nonfinite = {**payload, "coefficients": [[float("nan"), 0.0]]}
+    with pytest.raises(ValueError, match="finite complex pairs"):
+        ContractionIR.from_json_dict(nonfinite)
+
+
+def test_builtin_model_owns_exact_contraction_coefficients_and_bases() -> None:
+    model = BuiltinSMModel()
+
+    scalar = model.direct_contraction_ir(25, 25)
+    assert scalar == ContractionIR(
+        "scalar",
+        "scalar",
+        "scalar",
+        ((1.0, 0.0),),
+        "any",
+        None,
+    )
+
+    weyl = model.direct_contraction_ir(
+        1,
+        -1,
+        left_chirality=1,
+        right_chirality=-1,
+    )
+    assert weyl == ContractionIR(
+        "weyl",
+        "weyl-chiral",
+        "weyl-chiral",
+        ((1.0, 0.0), (1.0, 0.0)),
+        "opposite",
+        None,
+    )
+    assert (
+        model.direct_contraction_ir(
+            1,
+            -1,
+            left_chirality=1,
+            right_chirality=-1,
+        )
+        is weyl
+    )
+    assert (
+        model.direct_contraction_ir(
+            1,
+            -1,
+            left_chirality=1,
+            right_chirality=1,
+        )
+        is None
+    )
+
+    dirac = model.direct_contraction_ir(6, -6)
+    assert dirac is not None
+    assert dirac.name == "dirac"
+    assert dirac.left_basis == dirac.right_basis == "dirac"
+    assert dirac.coefficients == ((1.0, 0.0),) * 4
+    assert dirac.chirality_relation == "any"
+
+    lorentz = model.direct_contraction_ir(22, 22)
+    assert lorentz is not None
+    assert lorentz.name == "lorentz"
+    assert lorentz.left_basis == lorentz.right_basis == "lorentz-vector"
+    assert lorentz.coefficients == (
+        (1.0, 0.0),
+        (-1.0, 0.0),
+        (-1.0, 0.0),
+        (-1.0, 0.0),
+    )
+    assert lorentz.metric_signature == "mostly-minus"
+
+    auxiliary_vector = model.direct_contraction_ir(99, 99)
+    assert auxiliary_vector is not None
+    assert auxiliary_vector.name == "lorentz"
+    assert auxiliary_vector.left_basis == ("auxiliary:u1-subtraction-color-flow-vector")
+    assert auxiliary_vector.coefficients == lorentz.coefficients
+
+    antisymmetric = model.direct_contraction_ir(-21, -21)
+    assert antisymmetric is not None
+    assert antisymmetric.name == "antisymmetric-tensor"
+    assert antisymmetric.left_basis == "auxiliary:antisymmetric-tensor"
+    assert antisymmetric.right_basis == "auxiliary:antisymmetric-tensor"
+    assert antisymmetric.coefficients == ((1.0, 0.0),) * 6
+
+    closure = model.closure_contraction_ir(125)
+    assert closure == ContractionIR(
+        "scalar",
+        "scalar",
+        "scalar",
+        ((1.0, 0.0),),
+        "any",
+        None,
+    )
+
+
+def test_external_massless_fermions_record_weyl_and_dirac_contractions() -> None:
+    particle = CompiledParticleRecord(
+        name="psi",
+        antiname="psi_bar",
+        pdg_code=900_001,
+        spin=2,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+        component_dimension=4,
+    )
+    antiparticle = replace(
+        particle,
+        name="psi_bar",
+        antiname="psi",
+        pdg_code=-900_001,
+        source_orientation="antiparticle",
+    )
+
+    direct, closure = compile_contraction_records(
+        (particle, antiparticle),
+        (),
+        (),
+    )
+
+    by_selector = {record.selector: record.contraction_ir for record in direct}
+    assert by_selector[("psi", -1, "psi_bar", 1)].name == "weyl"
+    assert by_selector[("psi", 0, "psi_bar", 0)].name == "dirac"
+    assert by_selector[("psi", 1, "psi_bar", -1)].name == "weyl"
+    assert closure == ()
+
+
+def test_reachability_remains_coarse_and_dimension_16_is_not_contractible() -> None:
+    model = BuiltinSMModel()
+
+    assert model.direct_contraction_possible(1, -1) is True
+    assert (
+        model.direct_contraction_ir(
+            1,
+            -1,
+            left_chirality=1,
+            right_chirality=1,
+        )
+        is None
+    )
+
+    spin_two = 990_016
+    spin_two_model = Model(
+        name="spin-two-probe",
+        particles={
+            spin_two: Particle(
+                spin_two,
+                spin_two,
+                spin=5,
+                dimension=16,
+                color_rep=1,
+            )
+        },
+    )
+    assert spin_two_model.direct_contraction_possible(spin_two, spin_two) is False
+    assert spin_two_model.direct_contraction_ir(spin_two, spin_two) is None
+    assert spin_two_model.closure_contraction_ir(spin_two) is None
+
+
+def test_generic_model_never_infers_contractions_from_component_dimension() -> None:
+    scalar = 990_001
+    model = Model(
+        name="scalar-probe",
+        particles={
+            scalar: Particle(
+                scalar,
+                scalar,
+                spin=1,
+                dimension=1,
+                color_rep=1,
+            )
+        },
+    )
+
+    assert model.direct_contraction_ir(scalar, scalar) is None
+    assert model.closure_contraction_ir(scalar) is None
+    assert model.direct_contraction_possible(scalar, scalar) is False
+
+
+def test_external_model_with_empty_records_has_no_dimension_fallback() -> None:
+    particle = CompiledParticleRecord(
+        name="external_scalar",
+        antiname="external_scalar",
+        pdg_code=990_002,
+        spin=1,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+        component_dimension=1,
+    )
+    ir = CompiledModelIR(
+        name="external-empty-contractions",
+        orders=(),
+        parameters=(),
+        particles=(particle,),
+        couplings=(),
+        propagators=(),
+        vertex_terms=(),
+        oriented_kernels=(),
+        direct_contractions=(),
+        closure_contractions=(),
+    )
+    model = CompiledUFOModel(
+        CompiledModel(
+            source={"kind": "json"},
+            producer={},
+            model={"name": ir.name},
+            ir=ir,
+            parameter_defaults={},
+            capabilities={},
+            issues=(),
+            phase_timings={},
+            conversion_seconds=0.0,
+        )
+    )
+
+    assert model.dimension(particle.pdg_code) == 1
+    assert model.direct_contraction_ir(particle.pdg_code, particle.pdg_code) is None
+    assert model.closure_contraction_ir(particle.pdg_code) is None
+    assert model.direct_contraction_possible(
+        particle.pdg_code,
+        particle.pdg_code,
+    ) is False
+
+
+def test_component_contraction_is_coefficient_driven_and_never_truncates() -> None:
+    contraction_ir = ContractionIR(
+        name="lorentz",
+        left_basis="model-left",
+        right_basis="model-right",
+        coefficients=((2.0, 0.0), (0.0, 1.0)),
+        chirality_relation="any",
+        metric_signature=None,
+    )
+
+    assert _contract_components(contraction_ir, (2.0, 3.0), (5.0, 7.0)) == (
+        20.0 + 21.0j
+    )
+    renamed = replace(contraction_ir, name="model-defined-opaque-contraction")
+    assert _contract_components(renamed, (2.0, 3.0), (5.0, 7.0)) == (20.0 + 21.0j)
+    with pytest.raises(ValueError, match="requires 2 components, got 3 and 2"):
+        _contract_components(contraction_ir, (2.0, 3.0, 11.0), (5.0, 7.0))
+
+    unit_ir = replace(
+        contraction_ir,
+        coefficients=((1.0, 0.0), (1.0, 0.0)),
+    )
+    assert _contract_components(
+        unit_ir,
+        (S("left_0"), S("left_1")),
+        (S("right_0"), S("right_1")),
+    ) == S("left_0") * S("right_0") + S("left_1") * S("right_1")
+
+
+class _ClosureChiralityProbe(Model):
+    observed_chiralities: tuple[int, int] | None = None
+
+    def vertex_component_expression(
+        self,
+        kind: int,
+        left: Sequence[Any],
+        right: Sequence[Any],
+        *,
+        result_particle_id: int,
+        result_chirality: int,
+        left_chirality: int = 0,
+        right_chirality: int = 0,
+        coupling: tuple[Any, Any] = (1.0, 0.0),
+        left_momentum: Sequence[Any] | None = None,
+        right_momentum: Sequence[Any] | None = None,
+    ) -> tuple[Any, ...]:
+        del (
+            kind,
+            result_particle_id,
+            result_chirality,
+            coupling,
+            left_momentum,
+            right_momentum,
+        )
+        self.observed_chiralities = (left_chirality, right_chirality)
+        return (left[0] + right[0],)
+
+
+def test_vertex_closure_forwards_current_chiralities_and_scalar_projection() -> None:
+    model = _ClosureChiralityProbe(name="closure-chirality-probe")
+    contraction_ir = ContractionIR(
+        "scalar",
+        "scalar",
+        "scalar",
+        ((1.0, 0.0),),
+        "any",
+        None,
+    )
+    root = {
+        "kind": "vertex-closure",
+        "left_value_slot": {
+            "value_slot_id": 0,
+            "component_start": 0,
+            "component_stop": 1,
+            "dimension": 1,
+        },
+        "right_value_slot": {
+            "value_slot_id": 1,
+            "component_start": 1,
+            "component_stop": 2,
+            "dimension": 1,
+        },
+        "vertex_kind": 41,
+        "vertex_particles": [101, 202, 303],
+        "coupling": [1.0, 0.0],
+        "color_weight": [1.0, 0.0],
+        "contraction": contraction_ir.name,
+        "contraction_ir": contraction_ir.to_json_dict(),
+    }
+    value_slots = {
+        0: {"value_slot_id": 0, "dimension": 1, "chirality": -1},
+        1: {"value_slot_id": 1, "dimension": 1, "chirality": 1},
+    }
+
+    result = _amplitude_root_expression(
+        model,
+        root,
+        value_symbols={0: (2.0,), 1: (3.0,)},
+        model_parameter_symbols={},
+        value_slots=value_slots,
+    )
+
+    assert result == 5.0
+    assert model.observed_chiralities == (-1, 1)
+
+    malformed_projection = replace(
+        contraction_ir,
+        right_basis="lorentz-vector",
+    )
+    root["contraction_ir"] = malformed_projection.to_json_dict()
+    with pytest.raises(ValueError, match="scalar projection IR"):
+        _amplitude_root_expression(
+            model,
+            root,
+            value_symbols={0: (2.0,), 1: (3.0,)},
+            model_parameter_symbols={},
+            value_slots=value_slots,
+        )
+
+
+def test_runtime_and_execution_dtos_emit_full_contraction_ir() -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir("d d~ > z"), model=model)
+    runtime_schema = build_runtime_schema(dag, model)
+    execution_plan = _execution_plan(runtime_schema)
+    value_slots = {
+        int(slot["value_slot_id"]): slot
+        for slot in execution_plan["value_storage"]["value_slots"]
+    }
+
+    assert execution_plan["amplitude_stage"]["roots"]
+    for root in execution_plan["amplitude_stage"]["roots"]:
+        contraction_ir = ContractionIR.from_json_dict(root["contraction_ir"])
+        assert root["contraction"] == contraction_ir.name
+        assert len(contraction_ir.coefficients) == root["left_value_slot"]["dimension"]
+        assert len(contraction_ir.coefficients) == root["right_value_slot"]["dimension"]
+        left_value = value_slots[root["left_value_slot"]["value_slot_id"]]
+        right_value = value_slots[root["right_value_slot"]["value_slot_id"]]
+        assert contraction_ir.left_basis == left_value["propagator"]["basis"]
+        assert contraction_ir.right_basis == right_value["propagator"]["basis"]
+
+    blueprint = build_generic_stage_compiler_blueprint(
+        dag,
+        model=model,
+        runtime_schema=runtime_schema,
+    )
+    assert blueprint.amplitude_stage.expression_ready is True
+    assert blueprint.amplitude_stage.blockers == ()
+
+
+class _OpaqueContractionModel(BuiltinSMModel):
+    def direct_contraction_ir(
+        self,
+        left_particle_id: int,
+        right_particle_id: int,
+        left_chirality: int = 0,
+        right_chirality: int = 0,
+    ) -> ContractionIR | None:
+        contraction_ir = super().direct_contraction_ir(
+            left_particle_id,
+            right_particle_id,
+            left_chirality=left_chirality,
+            right_chirality=right_chirality,
+        )
+        if contraction_ir is None:
+            return None
+        return replace(contraction_ir, name="model-owned-opaque")
+
+
+def test_model_owned_ir_preserves_topology_and_all_root_copy_paths() -> None:
+    process = build_process_ir("d d~ > z")
+    default = compile_generic_dag(process, model=BuiltinSMModel())
+    unpruned = compile_generic_dag(
+        process,
+        model=BuiltinSMModel(),
+        species_reachability_pruning=False,
+    )
+    opaque = compile_generic_dag(process, model=_OpaqueContractionModel())
+
+    assert (
+        len(default.currents),
+        len(default.interactions),
+        len(default.amplitude_roots),
+    ) == (13, 6, 6)
+    assert (
+        len(unpruned.currents),
+        len(unpruned.interactions),
+        len(unpruned.amplitude_roots),
+    ) == (13, 6, 6)
+    assert (
+        len(opaque.currents),
+        len(opaque.interactions),
+        len(opaque.amplitude_roots),
+    ) == (13, 6, 6)
+    assert all(
+        root.contraction == "model-owned-opaque" for root in opaque.amplitude_roots
+    )
+    assert [
+        (root.kind, root.left_id, root.right_id, root.color_sector_id)
+        for root in default.amplitude_roots
+    ] == [
+        (root.kind, root.left_id, root.right_id, root.color_sector_id)
+        for root in opaque.amplitude_roots
+    ]
+
+    selected = replace(default, amplitude_roots=(default.amplitude_roots[0],))
+    copied = prune_dag_to_amplitude_roots(selected)
+    assert copied is not selected
+    assert copied.amplitude_roots[0].contraction_ir is (
+        default.amplitude_roots[0].contraction_ir
+    )
diff --git a/pyamplicol/tests/unit/test_correlated_double_double.py b/pyamplicol/tests/unit/test_correlated_double_double.py
new file mode 100644
index 0000000000..8fbba63b36
--- /dev/null
+++ b/pyamplicol/tests/unit/test_correlated_double_double.py
@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: 0BSD
+"""Arithmetic identity tests distinguish DoubleFloat from f64 and Decimal."""
+
+from decimal import Decimal, getcontext, localcontext
+
+import pytest
+
+from pyamplicol.api.errors import EvaluationError
+from pyamplicol.runtime._double_double import (
+    DoubleDoubleArithmetic,
+    correlated_precision,
+)
+from pyamplicol.runtime.correlated_exact import CorrelatedDoubleDoubleExecutor
+from pyamplicol.runtime.correlations import _contract, _Matrix, _MatrixEntry
+from pyamplicol.runtime.symbolica_exact import (
+    _ExactEvaluator,
+    _ExactExpressionEvaluator,
+)
+
+
+def test_double_double_retains_half_ulp_without_decimal_context_leak():
+    pytest.importorskip("symbolica")
+    first, second = DoubleDoubleArithmetic(), DoubleDoubleArithmetic()
+    scalar = first.scalar
+    original = getcontext().copy()
+    with localcontext() as context:
+        context.prec = 80
+        half_ulp = Decimal(2) ** -53
+        observed = scalar(1) + scalar(half_ulp)
+        assert observed > 1  # Binary64 would round the midpoint to one.
+        assert abs(Decimal(observed - scalar(1)) / half_ulp - 1) < Decimal("1e-14")
+        perturbation = Decimal("1e-25")
+        recovered = Decimal((scalar(1) + scalar(perturbation)) - scalar(1))
+        # Symbolica transports DoubleFloat results at 106 binary bits. After
+        # cancellation, bound the absolute rounding error near the original
+        # value one; a relative 1e-14 bound here would demand 39 digits.
+        assert abs(recovered - perturbation) <= Decimal(2) ** -105
+        # Double-double cannot retain this difference; arbitrary Decimal can.
+        assert scalar(1) + scalar("1e-40") == 1
+        assert Decimal(1) + Decimal("1e-40") > 1
+        assert (scalar(3).sqrt() ** 2 - scalar(3)).copy_abs() < Decimal("1e-29")
+        assert abs(Decimal(scalar(2) ** -3) - Decimal("0.125")) < Decimal("1e-30")
+    assert getcontext().prec == original.prec
+    assert getcontext().rounding == original.rounding
+    assert first.scalar is not second.scalar
+    assert first._evaluators
+    assert second._evaluators == {}
+
+
+def test_derived_parameters_and_complex_stages_really_use_double_double():
+    symbolica = pytest.importorskip("symbolica")
+    with localcontext() as context:
+        context.prec = 80
+        half_ulp = Decimal(2) ** -53
+        parameters = _ExactExpressionEvaluator(("x+1", "sqrt(pi)*x"), ("x",))
+        values = parameters.evaluate_double_double(((half_ulp, Decimal(0)),))
+        assert values[0][0] > 1
+        expected = parameters.evaluate(((half_ulp, Decimal(0)),), 70)
+        assert abs(values[1][0] / expected[1][0] - 1) < Decimal("1e-28")
+        executor = object.__new__(CorrelatedDoubleDoubleExecutor)
+        executor._double_double = DoubleDoubleArithmetic()
+        executor._scalar = executor._double_double.scalar
+        stage = _ExactEvaluator(1, symbolica.E("x+1").evaluator([symbolica.S("x")]))
+        output = executor._evaluate_stage(stage, ((half_ulp, half_ulp),), 31)[0]
+        assert output[0] > 1 and output[1] > 0
+        assert type(output[0]) is executor._scalar
+        # Chunked stages use the same backend, not a hidden Decimal fallback.
+        chunked = _ExactEvaluator(1, chunks=(stage,), chunk_input_indices=((0,),))
+        assert (
+            executor._evaluate_stage(chunked, ((half_ulp, half_ulp),), 31)[0] == output
+        )
+
+
+@pytest.mark.parametrize(
+    "precision, arithmetic",
+    [
+        (32, "double-double"),
+        (100, "double-double"),
+        (31, "unknown"),
+        (True, "double-double"),
+    ],
+)
+def test_invalid_arithmetic_is_rejected(precision, arithmetic):
+    with pytest.raises(EvaluationError):
+        correlated_precision(precision, arithmetic)
+
+
+def test_colour_reduction_uses_double_double_weights_and_operations():
+    from fractions import Fraction
+
+    from pyamplicol.runtime.correlated_exact import (
+        CoherentAmplitudeBatch,
+        CoherentAmplitudeGroup,
+    )
+
+    pytest.importorskip("symbolica")
+    scalar = DoubleDoubleArithmetic().scalar
+    group = CoherentAmplitudeGroup(0, "h", (1,), (1,), 0)
+    batch = CoherentAmplitudeBatch(
+        (((scalar(1), scalar("1e-20")),),), (group,), scalar(1), 31, ()
+    )
+    matrix = _Matrix("test", (0,), (_MatrixEntry(0, 0, Fraction(1), Fraction(0)),))
+    result = _contract(batch, matrix, precision=31)[0]
+    assert result.real == 1  # DD drops the 1e-40 term; an Arb(40+) sum retains it.
+    assert result.imag == 0
+    assert type(result.real) is Decimal
diff --git a/pyamplicol/tests/unit/test_correlated_exact.py b/pyamplicol/tests/unit/test_correlated_exact.py
new file mode 100644
index 0000000000..751e9b6733
--- /dev/null
+++ b/pyamplicol/tests/unit/test_correlated_exact.py
@@ -0,0 +1,631 @@
+# SPDX-License-Identifier: 0BSD
+"""Source injection and reduction mechanics; no Symbolica session required."""
+
+from __future__ import annotations
+
+import copy
+import json
+from decimal import Decimal, getcontext, localcontext
+
+import pytest
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError, EvaluationError
+from pyamplicol.runtime.correlated_exact import (
+    CorrelatedExactExecutor,
+    _fill_correlated_sources,
+    _prepare_spin_vectors,
+)
+
+
+def _source(leg=1, *, start=0, helicity=1, initial=False, phase=(1, 0)):
+    crossing = {
+        "momentum_transform": "negate-four-momentum" if initial else "identity",
+        "helicity_factor": -1 if initial else 1,
+        "chirality_factor": 1,
+        "spin_state_factor": 1,
+        "phase": list(phase),
+    }
+    return {
+        "leg_label": leg,
+        "source_helicity": helicity,
+        "chirality": 0,
+        "spin_state": 0,
+        "side": "initial" if initial else "final",
+        "particle_id": 21,
+        "anti_particle_id": 21,
+        "source_orientation": "self-conjugate",
+        "wavefunction_kind": "vector",
+        "dimension": 4,
+        "source_basis": "lorentz",
+        "crossing": "negate-incoming-momentum" if initial else "identity",
+        "value_slot": {"component_start": start, "component_stop": start + 4},
+        "source_ir": {
+            "basis": "lorentz",
+            "component_dimension": 4,
+            "wavefunction_family": "vector",
+            "identity": {
+                "pdg_label": 21,
+                "anti_pdg_label": 21,
+                "orientation": "self-conjugate",
+            },
+            "crossing": crossing,
+            "states": [
+                {"helicity": -1, "chirality": 0, "spin_state": 0},
+                {"helicity": 1, "chirality": 0, "spin_state": 0},
+            ],
+        },
+        "applied_crossing": crossing,
+    }
+
+
+def test_clear_releases_evaluators_without_mutating_the_plan():
+    executor = object.__new__(CorrelatedExactExecutor)
+    executor._stage_evaluators = (object(),)
+    executor._amplitude_evaluator = object()
+    executor._execution = {"source_plan": "retained"}
+    executor.clear()
+    assert executor._stage_evaluators is None
+    assert executor._amplitude_evaluator is None
+    assert executor._execution == {"source_plan": "retained"}
+
+
+def test_literal_momentum_vector_preserves_nonzero_temporal_component():
+    momentum = (Decimal(5), Decimal(3), Decimal(0), Decimal(4))
+    overrides = _prepare_spin_vectors({1: momentum}, allowed_legs=(1,), point_count=1)
+    state = [(Decimal(0), Decimal(0))] * 4
+    _fill_correlated_sources(
+        state, (momentum,), {"source_fill": {"sources": [_source()]}}, (), overrides[0]
+    )
+    assert state == [(component, Decimal(0)) for component in momentum]
+    assert state[0][0] == 5  # v=p has NOT been projected onto transverse helicities.
+
+
+def test_initial_crossing_phase_applied_once_without_conjugating_vector():
+    overrides = _prepare_spin_vectors(
+        {1: (2 + 3j, 5 - 7j, 11, 13)}, allowed_legs=(1,), point_count=1
+    )
+    state = [(Decimal(0), Decimal(0))] * 4
+    _fill_correlated_sources(
+        state,
+        ((Decimal(5), Decimal(3), Decimal(0), Decimal(4)),),
+        {"source_fill": {"sources": [_source(initial=True, phase=(0, 1))]}},
+        (),
+        overrides[0],
+    )
+    assert state == [
+        (Decimal(-3), Decimal(2)),
+        (Decimal(7), Decimal(5)),
+        (Decimal(0), Decimal(11)),
+        (Decimal(0), Decimal(13)),
+    ]
+
+
+def test_multiple_legs_and_point_specific_vectors_are_copied():
+    batch = [[1, 2, 3, 4], [5, 6, 7, 8]]
+    first = _prepare_spin_vectors(
+        {1: batch, 2: (9, 10, 11, 12)}, allowed_legs=(1, 2), point_count=2
+    )
+    batch[0][0] = 100
+    assert first[0][1][0] == (Decimal(1), Decimal(0))
+    assert first[1][1][0] == (Decimal(5), Decimal(0))
+    assert first[0][2] == first[1][2]
+    assert _prepare_spin_vectors({}, allowed_legs=(1, 2), point_count=2) == ({}, {})
+    assert _prepare_spin_vectors(None, allowed_legs=(1, 2), point_count=1) == ({},)
+    assert first[0][1][0] == (Decimal(1), Decimal(0))
+
+
+def test_real_decimal_vectors_preserve_all_digits_before_source_arithmetic():
+    first = Decimal("1.000000000000000000000000000000000000000000000000000000000001")
+    second = Decimal("1.000000000000000000000000000000000000000000000000000000000002")
+    with localcontext() as context:
+        context.prec = 7
+        vectors = _prepare_spin_vectors(
+            {1: (first, 0, 0, 0), 2: ((second, 0, 0, 0), (first, 0, 0, 0))},
+            allowed_legs=(1, 2),
+            point_count=2,
+        )
+    assert vectors[0][1][0][0] is first
+    assert vectors[1][1][0][0] is first
+    assert vectors[0][2][0][0] is second
+    assert vectors[1][2][0][0] is first
+    assert vectors[0][1] != vectors[0][2]
+
+
+def test_complex_decimal_pairs_broadcast_and_batch_without_float_conversion():
+    tiny = Decimal("1.00000000000000000000000000000000000000001")
+    wave = ((tiny, tiny), 0, 0, 0)
+    prepared = _prepare_spin_vectors(
+        {1: wave, 2: (wave, wave)}, allowed_legs=(1, 2), point_count=2
+    )
+    assert prepared[0][1][0] == (tiny, tiny)
+    assert prepared[1][2][0] == (tiny, tiny)
+
+
+def test_multiple_vector_sources_write_independent_full_slots():
+    overrides = _prepare_spin_vectors(
+        {1: (1, 2, 3, 4), 2: (5j, 6, 7, 8)},
+        allowed_legs=(1, 2),
+        point_count=1,
+    )[0]
+    state = [(Decimal(0), Decimal(0))] * 8
+    _fill_correlated_sources(
+        state,
+        ((Decimal(5), Decimal(3), Decimal(0), Decimal(4)),) * 2,
+        {"source_fill": {"sources": [_source(), _source(2, start=4)]}},
+        (),
+        overrides,
+    )
+    assert state[:4] == list(overrides[1])
+    assert state[4:] == list(overrides[2])
+
+
+@pytest.mark.parametrize(
+    "vectors, match",
+    [
+        ({2: (1, 2, 3, 4)}, "not declared"),
+        ({True: (1, 2, 3, 4)}, "not declared"),
+        ({1: [[1, 2, 3, 4]]}, "batch"),
+        ({1: (float("nan"), 2, 3, 4)}, "finite"),
+        ({1: (True, 2, 3, 4)}, "numeric"),
+    ],
+)
+def test_invalid_vector_input(vectors, match):
+    with pytest.raises(EvaluationError, match=match):
+        _prepare_spin_vectors(vectors, allowed_legs=(1,), point_count=2)
+
+
+def test_compressed_source_is_rejected():
+    source = _source()
+    source["value_slot"]["component_stop"] = 3
+    with pytest.raises(CompatibilityError, match="four-component"):
+        _fill_correlated_sources(
+            [(Decimal(0), Decimal(0))] * 4,
+            ((Decimal(5), Decimal(0), Decimal(0), Decimal(5)),),
+            {"source_fill": {"sources": [source]}},
+            (),
+            _prepare_spin_vectors({1: (1, 2, 3, 4)}, allowed_legs=(1,), point_count=1)[
+                0
+            ],
+        )
+
+
+class _NativeState:
+    def _exact_runtime_state_json(self):
+        return json.dumps({"model_parameter_values": [], "normalization_factor": 99})
+
+
+class _AmplitudeEvaluator:
+    def __init__(self):
+        self.inputs = []
+
+    def evaluate(self, values, precision):
+        self.inputs.append(tuple(values))
+        # Two roots in the same coherent group; their sum must precede squaring.
+        return (values[0], values[1], values[4], values[5])
+
+
+class _StubExecutor(CorrelatedExactExecutor):
+    def _load_evaluators(self):
+        pass
+
+    def _derive_model_parameters(self, parameters, precision):
+        return parameters
+
+
+def _executor():
+    executor = object.__new__(_StubExecutor)
+    executor._permutation = (0,)
+    executor._native_runtime = _NativeState()
+    executor._stage_evaluators = ()
+    executor._amplitude_evaluator = _AmplitudeEvaluator()
+    executor._physics = {
+        "color_accuracy": "full",
+        "external_particles": [{"label": 1, "pdg": 21, "role": "final"}],
+        "extensions": {"normalization": {"average_factor": 2, "identical_factor": 1}},
+        "helicities": [
+            {
+                "id": f"h:{h}",
+                "values": [h],
+                "computed": True,
+                "structural_zero": False,
+                "representative_id": f"h:{h}",
+                "coefficient": 1,
+            }
+            for h in (-1, 1)
+        ],
+    }
+    schema = {
+        "parameter_layout": {
+            "value_component_count": 8,
+            "momentum_parameter_count": 0,
+            "parameter_count_if_flattened": 8,
+        },
+        "external_particles": executor._physics["external_particles"],
+        "momentum_slots": [],
+        "model": {"particles": [{"pdg": 21, "mass": 0, "mass_parameter": None}]},
+        "source_fill": {
+            "sources": [_source(start=0, helicity=-1), _source(start=4, helicity=1)]
+        },
+        "amplitude_stage": {
+            "roots": [
+                {
+                    "output_index": index,
+                    "coherent_group_id": index // 2,
+                    "helicity_weight": 1,
+                    "all_sector_weight": 1,
+                }
+                for index in range(4)
+            ],
+            "coherent_groups": [
+                {
+                    "group_id": index,
+                    "helicities": [h],
+                    "color_word": [1],
+                    "color_sector_id": 0,
+                }
+                for index, h in enumerate((-1, 1))
+            ],
+        },
+    }
+    executor._execution = {
+        "runtime_schema": schema,
+        "compiled": {
+            "stage_evaluators": {
+                "stages": [],
+                "amplitude_stage": {
+                    "parameter_count": 8,
+                    "output_length": 4,
+                    "output_slots": [
+                        {
+                            "output_start": 0,
+                            "output_stop": 4,
+                            "component_start": 0,
+                            "component_stop": 4,
+                        }
+                    ],
+                },
+            }
+        },
+    }
+    executor._initialize_correlated_plan((1,))
+    return executor
+
+
+def test_coherent_group_descriptors_can_come_from_the_correlated_sidecar():
+    executor = _executor()
+    amplitude = executor._execution["runtime_schema"]["amplitude_stage"]
+    descriptors = amplitude.pop("coherent_groups")
+    expected = executor._coherent_groups
+    executor._initialize_correlated_plan((1,), descriptors)
+    assert executor._coherent_groups == expected
+
+
+def test_coherent_amplitudes_preserve_phase_and_deduplicate_replaced_helicity():
+    executor = _executor()
+    batch = executor.coherent_amplitudes(
+        [[(5, 3, 0, 4)]], spin_vectors={1: (2 + 3j, 5 - 7j, 11, 13)}
+    )
+    assert batch.values == (((Decimal(7), Decimal(-4)),),)
+    assert len(batch.groups) == 1
+    assert batch.groups[0].helicities == (-1,)
+    assert batch.normalization_factor == Decimal("0.5")
+    assert batch.spin_correlated_legs == (1,)
+    assert executor._amplitude_evaluator.inputs[0][0] == (Decimal(2), Decimal(3))
+    assert executor._amplitude_evaluator.inputs[0][4] == (Decimal(2), Decimal(3))
+
+
+def test_no_overrides_reset_and_separate_instances_remain_independent():
+    first, second = _executor(), _executor()
+    momenta = [[(5, 3, 0, 4)]]
+    first.coherent_amplitudes(momenta, spin_vectors={1: (9, 2, 3, 4)})
+    ordinary = first.coherent_amplitudes(momenta, spin_vectors={})
+    independent = second.coherent_amplitudes(momenta)
+    assert ordinary == independent
+    assert len(ordinary.groups) == 2
+    assert ordinary.spin_correlated_legs == ()
+    assert first._amplitude_evaluator.inputs[-1][0] == (Decimal(0), Decimal(0))
+
+
+def test_point_vectors_and_helicity_selector():
+    executor = _executor()
+    result = executor.coherent_amplitudes(
+        [[(5, 3, 0, 4)], [(5, 0, 3, 4)]],
+        spin_vectors={1: [(1, 2, 3, 4), (5, 6, 7, 8)]},
+        helicities=["h:1"],
+        precision=32,
+    )
+    assert result.values == (((Decimal(3), Decimal(0)),), ((Decimal(11), Decimal(0)),))
+    assert result.groups[0].helicity_id == "h:1"
+    with pytest.raises(EvaluationError, match="unknown"):
+        executor.coherent_amplitudes([[(5, 3, 0, 4)]], helicities=["missing"])
+
+
+def _executor_with_intrinsic_zeros():
+    executor = _executor()
+    executor._permutation = (0, 1)
+    executor._physics["external_particles"].append(
+        {"label": 2, "pdg": 1, "role": "final"}
+    )
+    for record in executor._physics["helicities"]:
+        record["values"].append(-1)
+    amplitude = executor._execution["runtime_schema"]["amplitude_stage"]
+    for descriptor in amplitude["coherent_groups"]:
+        descriptor["helicities"].append(-1)
+    # A spectator chirality gives no roots, independently of the vector source.
+    executor._physics["helicities"].extend(
+        {
+            "id": f"zero:{h}",
+            "values": [h, 1],
+            "computed": False,
+            "structural_zero": True,
+            "representative_id": f"zero:{h}",
+            "coefficient": 0,
+        }
+        for h in (-1, 1)
+    )
+    executor._initialize_correlated_plan((1,))
+    return executor
+
+
+def test_intrinsic_zero_helicities_retain_explicit_zero_selectors():
+    executor = _executor_with_intrinsic_zeros()
+    point = ((5, 3, 0, 4), (5, -3, 0, -4))
+    batch = executor.coherent_amplitudes(
+        (point, point), helicities=("zero:-1", "zero:1")
+    )
+    assert batch.groups == ()
+    assert batch.values == ((), ())
+    assert batch.normalization_factor == Decimal("0.5")
+    assert executor._known_helicity_ids == {"h:-1", "h:1", "zero:-1", "zero:1"}
+
+
+def test_intrinsic_zero_spectators_do_not_duplicate_replaced_spin_states():
+    executor = _executor_with_intrinsic_zeros()
+    point = ((5, 3, 0, 4), (5, -3, 0, -4))
+    ordinary = executor.coherent_amplitudes((point,))
+    assert len(ordinary.groups) == 2
+    projected = executor.coherent_amplitudes(
+        (point,), spin_vectors={1: (2 + 3j, 5 - 7j, 11, 13)}
+    )
+    assert projected.values == (((Decimal(7), Decimal(-4)),),)
+    assert projected.groups[0].helicities == (-1, -1)
+    zero = executor.coherent_amplitudes(
+        (point,), spin_vectors={1: (2 + 3j, 5 - 7j, 11, 13)}, helicities=("zero:1",)
+    )
+    assert zero.groups == ()
+    assert zero.values == ((),)
+
+
+@pytest.mark.parametrize("defect", ("unmarked", "alias", "weight"))
+def test_intrinsic_zero_metadata_must_be_explicit_unaliased_and_zero_weight(defect):
+    executor = _executor_with_intrinsic_zeros()
+    zero = executor._physics["helicities"][-1]
+    if defect == "unmarked":
+        zero["structural_zero"] = False
+    elif defect == "alias":
+        zero["representative_id"] = "h:1"
+    else:
+        zero["coefficient"] = 2
+    with pytest.raises(CompatibilityError):
+        executor._initialize_correlated_plan((1,))
+
+
+def test_raw_groups_in_one_physical_coefficient_are_summed_with_weights_once():
+    executor = _executor()
+    amplitude = executor._execution["runtime_schema"]["amplitude_stage"]
+    # Production separates raw groups by internal basis keys and colour weight.
+    # The mock outputs stand for already-weighted complex root expressions.
+    amplitude["roots"][1]["coherent_group_id"] = 2
+    amplitude["roots"][1]["color_weight"] = [3, -2]
+    extra = {**amplitude["coherent_groups"][0], "group_id": 2}
+    amplitude["coherent_groups"].append(extra)
+    executor._initialize_correlated_plan((1,))
+    assert len(executor._coherent_groups) == 2
+    assert executor._coherent_root_indices[0] == (0, 1)
+    batch = executor.coherent_amplitudes(
+        [[(5, 3, 0, 4)]], spin_vectors={1: (2 + 3j, 5 - 7j, 11, 13)}
+    )
+    assert batch.values == (((Decimal(7), Decimal(-4)),),)
+    assert len(batch.groups) == 1
+
+
+def test_raw_groups_cannot_assign_different_words_to_one_physical_sector():
+    executor = _executor()
+    amplitude = executor._execution["runtime_schema"]["amplitude_stage"]
+    amplitude["roots"][1]["coherent_group_id"] = 2
+    amplitude["coherent_groups"].append(
+        {**amplitude["coherent_groups"][0], "group_id": 2, "color_word": [2]}
+    )
+    with pytest.raises(ArtifactError, match="disagree"):
+        executor._initialize_correlated_plan((1,))
+
+
+def test_partial_colour_coverage_is_still_rejected():
+    executor = _executor_with_intrinsic_zeros()
+    amplitude = executor._execution["runtime_schema"]["amplitude_stage"]
+    amplitude["coherent_groups"][1]["color_sector_id"] = 1
+    with pytest.raises(ArtifactError, match="incomplete helicity/color"):
+        executor._initialize_correlated_plan((1,))
+
+
+class _CountingEvaluator:
+    def __init__(self, factor=1):
+        self.factor = factor
+        self.inputs = []
+
+    def evaluate(self, inputs, precision):
+        self.inputs.append(inputs)
+        if self.factor == 1:
+            return inputs
+        return tuple((a * self.factor, b * self.factor) for a, b in inputs)
+
+
+def _executor_with_stages():
+    executor = _executor()
+    schema = executor._execution["runtime_schema"]
+    schema["parameter_layout"]["parameter_count_if_flattened"] = 10
+    schema["parameter_layout"]["value_component_count"] = 10
+    stages = []
+    for source, target in ((2, 8), (1, 9)):
+        stages.append(
+            {
+                "parameter_count": 1,
+                "input_components": [
+                    {"parameter_index": 0, "global_component": source}
+                ],
+                "output_slots": [
+                    {
+                        "output_start": 0,
+                        "output_stop": 1,
+                        "component_start": target,
+                        "component_stop": target + 1,
+                    }
+                ],
+            }
+        )
+    stage_set = executor._execution["compiled"]["stage_evaluators"]
+    stage_set["stages"] = stages
+    stage_set["amplitude_stage"]["parameter_count"] = 4
+    stage_set["amplitude_stage"]["input_components"] = [
+        {"parameter_index": index, "global_component": source}
+        for index, source in enumerate((8, 9, 8, 9))
+    ]
+    executor._stage_evaluators = (_CountingEvaluator(2), _CountingEvaluator(3))
+    executor._amplitude_evaluator = _CountingEvaluator()
+    return executor
+
+
+def test_many_reuses_exact_stages_and_restores_slots_with_point_outer_order():
+    executor = _executor_with_stages()
+    points = [[(5, 3, 0, 4)], [(5, 0, 3, 4)]]
+    vectors = ({1: (2, 5, 11, 13)}, {1: (2, 7, 11, 13)})
+    batches = list(
+        executor.iter_coherent_amplitudes_many(points, spin_vector_sets=vectors)
+    )
+    assert [(point, spin) for point, spin, _ in batches] == [
+        (0, 0),
+        (0, 1),
+        (1, 0),
+        (1, 1),
+    ]
+    assert [batch.values[0][0] for _, _, batch in batches] == [
+        (Decimal(37), Decimal(0)),
+        (Decimal(43), Decimal(0)),
+        (Decimal(37), Decimal(0)),
+        (Decimal(43), Decimal(0)),
+    ]
+    unchanged, changed = executor._stage_evaluators
+    assert len(unchanged.inputs) == 2  # One evaluation per point, despite two spins.
+    assert len(changed.inputs) == 4
+    assert len(executor._amplitude_evaluator.inputs) == 4
+    # No numerical cache survives a call or a change to runtime parameters.
+    list(executor.iter_coherent_amplitudes_many(points, spin_vector_sets=vectors))
+    assert len(unchanged.inputs) == 4
+    assert len(changed.inputs) == 8
+
+
+def test_many_stage_reuse_matches_separate_calls_and_reuses_amplitude_stage():
+    executor = _executor_with_stages()
+    points = [[(5, 3, 0, 4)], [(5, 0, 3, 4)]]
+    vectors = ({1: (2, 5, 11, 13)}, {1: (8, 5, 11, 13)})
+    batches = list(
+        executor.iter_coherent_amplitudes_many(
+            points, spin_vector_sets=vectors, precision=70
+        )
+    )
+    for point, spin, batch in batches:
+        separate = _executor_with_stages().coherent_amplitudes(
+            [points[point]], spin_vectors=vectors[spin], precision=70
+        )
+        assert batch == separate
+    assert len(executor._amplitude_evaluator.inputs) == 2
+    assert all(len(stage.inputs) == 2 for stage in executor._stage_evaluators)
+
+
+def test_stage_cache_preserves_signed_zero_and_never_reuses_failed_results():
+    executor = _executor()
+    evaluator = _CountingEvaluator()
+    memo = {}
+    plus = ((Decimal("0"), Decimal(0)),)
+    minus = ((Decimal("-0"), Decimal(0)),)
+    assert executor._evaluate_stage_cached(evaluator, plus, 40, memo, 0) == plus
+    executor._evaluate_stage_cached(evaluator, plus, 40, memo, 0)
+    returned = executor._evaluate_stage_cached(evaluator, minus, 40, memo, 0)
+    assert returned[0][0].is_signed()
+    assert len(evaluator.inputs) == 2
+
+    class FailingEvaluator:
+        def evaluate(self, inputs, precision):
+            raise EvaluationError("test failure")
+
+    with pytest.raises(EvaluationError, match="test failure"):
+        executor._evaluate_stage_cached(FailingEvaluator(), plus, 40, memo, 1)
+    assert 1 not in memo
+
+
+def test_many_prepares_parameters_once_and_does_not_leak_decimal_context(monkeypatch):
+    executor = _executor_with_stages()
+    derivations = []
+
+    def derive(parameters, precision):
+        derivations.append((parameters, precision))
+        return parameters
+
+    monkeypatch.setattr(executor, "_derive_model_parameters", derive)
+    with localcontext() as context:
+        context.prec = 7
+        iterator = executor.iter_coherent_amplitudes_many(
+            [[(5, 3, 0, 4)], [(5, 0, 3, 4)]],
+            spin_vector_sets=({1: (2, 5, 11, 13)}, {1: (8, 5, 11, 13)}),
+            precision=70,
+        )
+        next(iterator)
+        assert getcontext().prec == 7
+        list(iterator)
+        assert getcontext().prec == 7
+    assert len(derivations) == 1
+
+
+def test_many_retains_explicit_intrinsic_zero_selectors():
+    executor = _executor_with_intrinsic_zeros()
+    point = ((5, 3, 0, 4), (5, -3, 0, -4))
+    batches = list(
+        executor.iter_coherent_amplitudes_many(
+            (point, point),
+            spin_vector_sets=({}, {1: (1, 2, 3, 4)}),
+            helicities=("zero:1",),
+        )
+    )
+    assert len(batches) == 4
+    assert all(batch.groups == () and batch.values == ((),) for _, _, batch in batches)
+
+
+@pytest.mark.parametrize(
+    "defect, match",
+    [
+        ("replay", "unreplayed"),
+        ("alias", "aliases"),
+        ("pruned", "zero-pruned"),
+        ("missing_group", "cover"),
+        ("weight", "folded"),
+        ("output", "mapping"),
+    ],
+)
+def test_unsafe_or_incomplete_plans_fail_closed(defect, match):
+    executor = _executor()
+    executor._execution = copy.deepcopy(executor._execution)
+    amplitude = executor._execution["runtime_schema"]["amplitude_stage"]
+    if defect == "replay":
+        executor._helicity_plan = object()
+    elif defect == "alias":
+        executor._physics["helicities"][1]["representative_id"] = "h:-1"
+    elif defect == "pruned":
+        executor._physics["helicities"][1]["structural_zero"] = True
+    elif defect == "missing_group":
+        amplitude["coherent_groups"].pop()
+    elif defect == "weight":
+        amplitude["roots"][0]["helicity_weight"] = 2
+    elif defect == "output":
+        amplitude["roots"][0]["output_index"] = 5
+    with pytest.raises((ArtifactError, CompatibilityError), match=match):
+        executor._initialize_correlated_plan((1,))
diff --git a/pyamplicol/tests/unit/test_correlated_generation.py b/pyamplicol/tests/unit/test_correlated_generation.py
new file mode 100644
index 0000000000..d4249c2db6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_correlated_generation.py
@@ -0,0 +1,496 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from dataclasses import replace
+from itertools import product
+from types import SimpleNamespace
+
+import pytest
+
+import pyamplicol.generation.correlated as correlated
+import pyamplicol.generation.service as service
+from pyamplicol.api import ProcessAlias, ProcessRequest, ProcessSet
+from pyamplicol.api.errors import GenerationError
+from pyamplicol.artifacts import ArtifactBuilder, load_manifest
+from pyamplicol.color.plan import build_color_plan
+from pyamplicol.config import (
+    Action,
+    ColorConfig,
+    ConfigClamp,
+    ConfigResolution,
+    GenerationConfig,
+    GenerationValidationConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from pyamplicol.correlators import ColorCorrelator, CorrelatorConfig
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def test_correlated_settings_are_explicit_and_do_not_change_default_factory() -> None:
+    ordinary = service.create_generator_backend(None, None)
+    assert type(ordinary) is service.GenerationBackend
+    assert ordinary._color_accuracy == "lc"
+    settings = correlated.correlated_configuration(None)
+    assert settings.requested.color.accuracy == "lc"
+    assert settings.effective.color.accuracy == "lc"
+    assert settings.effective.color.contraction == "direct"
+    assert settings.effective.color.fft_basis == "trace"
+    assert settings.effective.evaluator.execution_mode == "compiled"
+    assert settings.effective.evaluator.jit.compress is True
+    assert settings.effective.generation.relation_discovery.mode == "off"
+    assert "color.accuracy" not in {change.path for change in settings.clamps}
+    assert "evaluator.execution_mode" in {change.path for change in settings.clamps}
+    assert not hasattr(ordinary, "declarations")
+
+
+@pytest.mark.parametrize("accuracy", ("lc", "nlc", "full"))
+def test_output_accuracy_is_retained_but_underlying_generation_stays_full(accuracy):
+    config = RunConfig(action=Action.GENERATE, color=ColorConfig(accuracy=accuracy))
+    settings = correlated.correlated_configuration(config)
+    assert (
+        settings.requested.color.accuracy
+        == settings.effective.color.accuracy
+        == accuracy
+    )
+    backend = correlated.CorrelatedGenerationBackend(
+        config, None, declarations=CorrelatorConfig()
+    )
+    assert backend._run_config.color.accuracy == accuracy
+    assert backend._run_config.color.contraction == "direct"
+    assert backend._run_config.color.fft_basis == "trace"
+    assert backend._color_accuracy == "full"
+    process = build_process_ir("d d~ > z", color_accuracy="full")
+    plan = build_color_plan(process, color_accuracy="full")
+    groups = [
+        {"helicities": (1, -1, 0), "color_sector_id": sector.id}
+        for sector in plan.sectors
+    ]
+    backend._correlated_processes["process"] = correlated.CorrelatedProcessMetadata(
+        process,
+        plan,
+        SimpleNamespace(
+            to_mapping=lambda: {"amplitude_stage": {"coherent_groups": groups}}
+        ),
+        (),
+    )
+    matrices = backend.correlator_payload()["processes"]["process"]["matrices"]
+    assert matrices[0]["color_accuracy"] == accuracy
+
+
+def test_correlated_configuration_preserves_resources_and_existing_clamps() -> None:
+    requested = RunConfig(
+        action=Action.GENERATE,
+        color=ColorConfig(
+            accuracy="full", contraction="symmetric-group-fft", fft_basis="trace"
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            validation=GenerationValidationConfig(seed=19, samples=3),
+        ),
+    )
+    effective = replace(requested, generation=replace(requested.generation, workers=2))
+    clamp = ConfigClamp("generation.workers", 1, 2, "resource selection")
+    resolution = correlated.correlated_configuration(
+        ConfigResolution(requested, effective, (clamp,))
+    )
+    assert resolution.requested is requested
+    assert resolution.clamps[0] is clamp
+    assert resolution.effective.generation.workers == 2
+    assert resolution.effective.generation.validation is effective.generation.validation
+    assert resolution.effective.evaluator.backend is effective.evaluator.backend
+    assert resolution.effective.color.contraction == "direct"
+    assert correlated.correlated_configuration(resolution).clamps == resolution.clamps
+
+
+def test_correlated_configuration_still_rejects_forced_adjoint_fft() -> None:
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="full", contraction="symmetric-group-fft"),
+    )
+    with pytest.raises(ValueError, match="adjoint FFT is not supported"):
+        correlated.correlated_configuration(config)
+
+
+@pytest.mark.parametrize(
+    "compress, expected", (("auto", True), (False, False), (True, True))
+)
+def test_correlated_configuration_reselects_compiled_compression_default(
+    compress, expected
+) -> None:
+    from pyamplicol.config import resolve_config
+
+    recurrence = resolve_config(
+        {"action": "generate", "evaluator": {"jit": {"compress": compress}}}
+    )
+    assert recurrence.effective.evaluator.jit.compress is (compress is True)
+    compiled = correlated.correlated_configuration(recurrence)
+    assert compiled.effective.evaluator.jit.compress is expected
+
+
+def test_correlated_configuration_preserves_compression_clamp() -> None:
+    from pyamplicol.config import ClampRequest, resolve_config
+
+    recurrence = resolve_config(
+        {"action": "generate"},
+        clamps=(ClampRequest("evaluator.jit.compress", False, "explicit pack policy"),),
+    )
+    compiled = correlated.correlated_configuration(recurrence)
+    assert compiled.effective.evaluator.jit.compress is False
+
+
+def test_automatic_catalogues_expand_for_each_generated_process() -> None:
+    declarations = CorrelatorConfig.all_color(through_order=2)
+    backend = correlated.CorrelatedGenerationBackend(
+        RunConfig(action="generate", color=ColorConfig(accuracy="full")),
+        None,
+        declarations=declarations,
+    )
+    cases = (("annihilation", "d d~ > z"), ("pair", "e+ e- > d d~"))
+    for process_id, specification in cases:
+        process = build_process_ir(specification, color_accuracy="full")
+        plan = build_color_plan(process, color_accuracy="full")
+        groups = [
+            {"helicities": (1,), "color_sector_id": sector.id}
+            for sector in plan.sectors
+        ]
+        metadata = correlated.CorrelatedProcessMetadata(
+            process,
+            plan,
+            SimpleNamespace(
+                to_mapping=lambda groups=groups: {
+                    "amplitude_stage": {"coherent_groups": groups}
+                }
+            ),
+            (),
+        )
+        backend._correlated_processes[process_id] = metadata
+    payload = backend.correlator_payload()
+    assert payload["declarations"]["all_color_through_order"] == 2
+    for process_id, expected_labels in (("annihilation", {1, 2}), ("pair", {3, 4})):
+        process_payload = payload["processes"][process_id]
+        resolved = CorrelatorConfig.from_json_dict(process_payload["declarations"])
+        assert resolved.all_color_through_order is None
+        assert len(resolved.color_requests) == 113
+        assert [matrix["id"] for matrix in process_payload["matrices"]] == [
+            request.id for request in resolved.color_requests
+        ]
+        nlo = [request for request in resolved.color_correlations if request.order == 1]
+        assert {request.bra[0].emitter_label for request in nlo} == expected_labels
+    assert backend.declarations is declarations
+
+
+@pytest.mark.parametrize(
+    "selection",
+    [
+        ProcessConfig(max_color_sectors=1),
+        ProcessConfig(reference_color_order=(1, 2, 3, 4)),
+        ProcessConfig(selected_color_sector_ids=(0,)),
+        ProcessConfig(selected_source_helicities={"1": -1}),
+    ],
+)
+def test_partial_source_or_colour_selection_is_rejected(
+    selection: ProcessConfig,
+) -> None:
+    with pytest.raises(GenerationError, match="complete colour and helicity"):
+        correlated.CorrelatedGenerationBackend(
+            RunConfig(action=Action.GENERATE, process=selection),
+            None,
+            declarations=CorrelatorConfig(),
+        )
+
+
+def test_append_rejected_before_entering_generation(monkeypatch, tmp_path) -> None:
+    def forbidden(*args, **kwargs):
+        raise AssertionError("ordinary pipeline must not run")
+
+    monkeypatch.setattr(service.GenerationBackend, "generate", forbidden)
+    with pytest.raises(GenerationError, match="append"):
+        correlated.generate_correlated(
+            ProcessSet((ProcessRequest.parse("g g > g g"),)),
+            tmp_path / "not-created",
+            declarations=CorrelatorConfig(),
+            mode="append",
+        )
+    assert not (tmp_path / "not-created").exists()
+
+
+def test_nonidentity_alias_is_rejected_before_entering_generation(
+    monkeypatch, tmp_path
+) -> None:
+    def forbidden(*args, **kwargs):
+        raise AssertionError("ordinary pipeline must not run")
+
+    monkeypatch.setattr(service.GenerationBackend, "generate", forbidden)
+    with pytest.raises(GenerationError, match="identity process aliases"):
+        correlated.generate_correlated(
+            ProcessSet(
+                (ProcessRequest.parse("g g > g g", name="gggg"),),
+                (ProcessAlias("swapped", "gggg", (1, 0, 2, 3)),),
+            ),
+            tmp_path / "not-created",
+            declarations=CorrelatorConfig(),
+        )
+    assert not (tmp_path / "not-created").exists()
+
+
+@pytest.fixture
+def complete_gggg():
+    backend = correlated.CorrelatedGenerationBackend(
+        RunConfig(action=Action.GENERATE, color=ColorConfig(accuracy="full")),
+        None,
+        declarations=CorrelatorConfig(
+            color_correlations=(ColorCorrelator.dipole("T1.T3", 1, 3),),
+            spin_correlations=((3,), (3, 4)),
+        ),
+    )
+    model = BuiltinSMModel()
+    process = build_process_ir("g g > g g", color_accuracy="full")
+    dag, coverage = backend._compile_concrete_process(process, model)
+    expanded = service._ExpandedProcess(
+        request=ProcessRequest.parse(process.process, name="gggg"),
+        process_ir=process,
+    )
+    return backend, model, service._DagProcess(expanded, dag, coverage)
+
+
+def test_generic_compiler_keeps_complete_complex_source_basis(
+    complete_gggg, monkeypatch
+) -> None:
+    backend, model, process = complete_gggg
+
+    def forbidden(*args, **kwargs):
+        raise AssertionError("physical-helicity reductions must not run")
+
+    for name in (
+        "prune_global_helicity_flip_equivalent_roots",
+        "prune_dag_to_amplitude_roots",
+        "project_rectangular_dynamic_color_classes",
+        "build_helicity_recurrence_plan",
+        "materialize_helicity_recurrence",
+        "run_generic_dag_numerical_current_warmup",
+    ):
+        monkeypatch.setattr(service, name, forbidden)
+    prepared = backend._prepare_warmup_process(
+        process, model, index=0, phase=PhaseHandle("prepare", None, 1)
+    )
+    assert prepared.dag is process.dag
+    assert prepared.helicity_sum_dag is None
+    assert prepared.helicity_selector_union_dag is None
+    assert prepared.filters["structural_helicity_reduction"]["applied"] is False
+    assert prepared.filters["relation_discovery"]["effective_mode"] == "off"
+    assert len(prepared.validation_points) == 1
+    dag = prepared.dag
+    assert dag.color_coverage == dag.helicity_coverage == "complete"
+    assert not dag.color_plan.trace_reflections_folded
+    assert dag.lc_topology_replay is dag.color_topology_replay is None
+    assert dag.helicity_recurrence is dag.helicity_materialization is None
+    assert all(root.helicity_weight == 1 for root in dag.amplitude_roots)
+
+    evaluator = backend._construct_evaluator(
+        prepared, model, PhaseHandle("schema", None, 1)
+    )
+    schema = evaluator.runtime_schema.to_mapping()
+    assert "runtime_selectors" not in schema["physics"]["extensions"]
+    assert evaluator.stage_input.runtime_schema is evaluator.runtime_schema
+    ordinary_schema = service.build_runtime_expression_schema(
+        dag, model, process_id="ordinary"
+    ).to_mapping()
+    assert (
+        ordinary_schema["physics"]["extensions"]["runtime_selectors"]["axes"][
+            "helicity"
+        ]["runtime_contract"]
+        == "complete-reusable"
+    )
+    groups = schema["amplitude_stage"]["coherent_groups"]
+    assert {tuple(group["helicities"]) for group in groups} == set(
+        product((-1, 1), repeat=4)
+    )
+    assert {group["color_sector_id"] for group in groups} == {
+        sector.id for sector in dag.color_plan.sectors
+    }
+    assert all(
+        group["helicity_weight"] == group["all_sector_weight"] == 1 for group in groups
+    )
+    for source in schema["source_fill"]["sources"]:
+        assert source["source_parameter_stop"] - source["source_parameter_start"] == 4
+        assert source["source_ir"]["component_dimension"] == 4
+        assert (
+            source["value_slot"]["component_stop"]
+            - source["value_slot"]["component_start"]
+            == 4
+        )
+    metadata = backend.process_metadata["gggg"]
+    assert metadata.color_plan is dag.color_plan
+    assert metadata.process is dag.process
+    assert metadata.runtime_schema is evaluator.runtime_schema
+
+    payload = backend.correlator_payload()
+    assert payload["complete_source_basis"] is True
+    assert payload["declarations"] == backend.declarations.to_json_dict()
+    catalog = payload["processes"]["gggg"]
+    assert catalog["declarations"] == backend.declarations.to_json_dict()
+    assert catalog["spin_legs"] == [3, 4]
+    assert catalog["coherent_groups"] == groups
+    assert [matrix["id"] for matrix in catalog["matrices"]] == ["born", "T1.T3"]
+    for matrix in catalog["matrices"]:
+        assert matrix["color_accuracy"] == "full"
+        assert matrix["storage"] == "sparse-directed"
+        assert matrix["sector_ids"] == [sector.id for sector in dag.color_plan.sectors]
+
+
+@pytest.mark.parametrize("spin_leg", [1, 4])
+def test_only_present_four_vector_legs_can_be_declared(spin_leg: int) -> None:
+    backend = correlated.CorrelatedGenerationBackend(
+        None, None, declarations=CorrelatorConfig(spin_correlations=((spin_leg,),))
+    )
+    with pytest.raises(GenerationError, match=r"(four-component vector|absent)"):
+        backend._prepare_process_construction(
+            build_process_ir("d d~ > z", color_accuracy="full"), BuiltinSMModel()
+        )
+
+
+def test_multi_quark_catalogue_uses_retained_canonical_colour_owners() -> None:
+    backend = correlated.CorrelatedGenerationBackend(
+        None, None, declarations=CorrelatorConfig(spin_correlations=((5,),))
+    )
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > u u~ g", color_accuracy="full")
+    dag, coverage = backend._compile_concrete_process(process, model)
+    expanded = service._ExpandedProcess(
+        request=ProcessRequest.parse(process.process, name="qqqqg"), process_ir=process
+    )
+    compiled = backend._prepare_warmup_process(
+        service._DagProcess(expanded, dag, coverage),
+        model,
+        index=0,
+        phase=PhaseHandle("prepare", None, 1),
+    )
+    backend._construct_evaluator(compiled, model, PhaseHandle("schema", None, 1))
+    catalog = backend.correlator_payload()["processes"]["qqqqg"]
+    owners = catalog["matrices"][0]["sector_ids"]
+    assert owners == [0, 2, 4, 6]
+    assert len(owners) < dag.color_plan.sector_count
+    basis_by_helicity = {}
+    for group in catalog["coherent_groups"]:
+        basis_by_helicity.setdefault(tuple(group["helicities"]), set()).add(
+            group["color_sector_id"]
+        )
+    assert all(basis == set(owners) for basis in basis_by_helicity.values())
+
+
+def test_opt_in_payload_is_added_through_the_existing_writer(monkeypatch) -> None:
+    backend = correlated.CorrelatedGenerationBackend(
+        None, None, declarations=CorrelatorConfig()
+    )
+    calls = []
+
+    class Builder:
+        def add_json(self, path, payload, *, role):
+            calls.append((path, payload, role))
+
+    sentinel = object()
+
+    def writer(self, destination, **kwargs):
+        assert destination == "destination"
+        extensions = kwargs["payload_hook"](Builder())
+        assert extensions == {
+            "correlators": {"schema_version": 1, "path": "correlators.json"}
+        }
+        return sentinel
+
+    monkeypatch.setattr(service.GenerationBackend, "_write_artifact", writer)
+    assert backend._write_artifact("destination") is sentinel
+    assert calls == [
+        ("correlators.json", backend.correlator_payload(), "runtime-physics")
+    ]
+
+
+def test_sidecar_and_extension_are_ordinary_manifest_payloads(tmp_path) -> None:
+    backend = correlated.CorrelatedGenerationBackend(
+        None, None, declarations=CorrelatorConfig(spin_correlations=((3,),))
+    )
+    output = tmp_path / "artifact"
+    with ArtifactBuilder(output) as builder:
+        builder.add_json(
+            "physics/process.json", {}, role="runtime-physics", process_id="gggg"
+        )
+        extension = backend._write_correlator_payload(builder)
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer={
+                "distribution": "pyamplicol",
+                "version": "0.1.0",
+                "versions": {
+                    "python_api": 1,
+                    "toml": 1,
+                    "compiled_model": 1,
+                    "process_artifact": 3,
+                    "runtime_physics": 1,
+                    "symbolica_serialization": "test",
+                    "c_abi": 1,
+                },
+                "target": {"triple": "test-target", "cpu_features": []},
+            },
+            model={
+                "name": "built-in-sm",
+                "source_kind": "built-in-sm",
+                "content_sha256": "1" * 64,
+                "compiled_schema_version": 1,
+            },
+            configuration={
+                "toml_schema_version": 1,
+                "requested_path": "config/requested.toml",
+                "effective_path": "config/effective.toml",
+                "adjustments": [],
+            },
+            processes=[
+                {
+                    "id": "gggg",
+                    "expression": "g g > g g",
+                    "color_accuracy": "full",
+                    "external_pdgs": [21, 21, 21, 21],
+                    "physics_path": "physics/process.json",
+                    "required_runtime_capabilities": [
+                        "symjit.application.complex-f64.v1"
+                    ],
+                    "aliases": [],
+                }
+            ],
+            runtime={
+                "engine": "rusticol",
+                "engine_version": "0.1.0",
+                "evaluator_manifest_path": "physics/process.json",
+                "api_bundle_path": None,
+                "required_runtime_capabilities": ["symjit.application.complex-f64.v1"],
+            },
+            extensions=extension,
+        )
+        assert not output.exists()
+    manifest = load_manifest(output)
+    assert manifest.extensions["correlators"] == extension["correlators"]
+    records = {record.path: record for record in manifest.payloads}
+    assert records["correlators.json"].role == "runtime-physics"
+    assert (
+        json.loads((output / "correlators.json").read_text())
+        == backend.correlator_payload()
+    )
+
+
+def test_default_writer_wrapper_passes_through_without_a_payload_hook(
+    monkeypatch,
+) -> None:
+    calls = []
+    sentinel = object()
+
+    def writer(*args, **kwargs):
+        calls.append((args, kwargs))
+        return sentinel
+
+    monkeypatch.setattr(service, "write_schema_v3_artifact", writer)
+    backend = service.create_generator_backend(None, None)
+    assert backend._write_artifact("output", mode="error") is sentinel
+    assert calls == [(("output",), {"mode": "error"})]
diff --git a/pyamplicol/tests/unit/test_correlator_config.py b/pyamplicol/tests/unit/test_correlator_config.py
new file mode 100644
index 0000000000..58a4e414dd
--- /dev/null
+++ b/pyamplicol/tests/unit/test_correlator_config.py
@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: 0BSD
+import json
+
+import pytest
+
+from pyamplicol import (
+    ColorCorrelator,
+    CorrelatedRequest,
+    CorrelatorConfig,
+    EmitGluon,
+    SplitGluon,
+)
+from pyamplicol.cli.parser import parse_cli
+
+
+def test_correlated_request_defaults_and_physical_override():
+    assert CorrelatedRequest().color_correlation == "born"
+    assert CorrelatedRequest().spin_vectors is None
+    assert CorrelatedRequest("T12", {}).spin_vectors == {}
+
+
+@pytest.mark.parametrize("identifier", ("", None, 3))
+def test_correlated_request_requires_colour_id(identifier):
+    with pytest.raises(ValueError, match="correlation ID"):
+        CorrelatedRequest(identifier)
+
+
+def test_correlated_request_requires_vector_mapping():
+    with pytest.raises(TypeError, match="must map"):
+        CorrelatedRequest(spin_vectors=[(0, 1, 0, 0)])
+
+
+def test_declarations_json_roundtrip_and_automatic_born():
+    chain = (EmitGluon(1, -1), SplitGluon(-1, -2, -3), EmitGluon(-2, -4))
+    declarations = CorrelatorConfig(
+        (ColorCorrelator.dipole("T12", 1, 2), ColorCorrelator("N3LO", chain, chain)),
+        ((3, 1), (1,)),
+    )
+    encoded = json.loads(json.dumps(declarations.to_json_dict()))
+    assert CorrelatorConfig.from_json_dict(encoded) == declarations
+    assert declarations.spin_legs == (1, 3)
+    assert declarations.spin_correlations == ((1,), (1, 3))
+    assert [item.id for item in declarations.color_requests] == ["born", "T12", "N3LO"]
+
+
+@pytest.mark.parametrize("order", (1, 2, 3, 4, 7))
+def test_automatic_catalogue_declaration_roundtrip(order):
+    config = CorrelatorConfig.all_color(
+        through_order=order, spin_correlations=((3,),)
+    )
+    assert config.all_color_through_order == order
+    assert config.spin_correlations == ((3,),)
+    assert CorrelatorConfig.from_json_dict(config.to_json_dict()) == config
+    with pytest.raises(ValueError, match="resolved for a process"):
+        _ = config.color_requests
+
+
+@pytest.mark.parametrize("order", (0, -1, True, 1.0, "NLO", None))
+def test_automatic_catalogue_rejects_unsupported_orders(order):
+    with pytest.raises(ValueError, match="all_color_through_order"):
+        CorrelatorConfig.all_color(through_order=order)
+
+
+def test_automatic_catalogue_is_resolved_per_process_without_mutating_config():
+    from pyamplicol.color.connections import ColorLeg
+
+    config = CorrelatorConfig.all_color(through_order=1)
+    first = config._resolve_color((ColorLeg(1, 1), ColorLeg(2, 3), ColorLeg(3, -3)))
+    second = config._resolve_color((ColorLeg(1, 8), ColorLeg(2, 8), ColorLeg(3, 8)))
+    assert len(first.color_requests) == 5  # born and four directed dipoles
+    assert len(second.color_requests) == 10
+    assert config.all_color_through_order == 1
+    assert first.all_color_through_order is second.all_color_through_order is None
+    assert {item.bra[0].emitter_label for item in first.color_correlations} == {2, 3}
+    assert first._resolve_color(()) is first
+    assert CorrelatorConfig.from_json_dict(first.to_json_dict()) == first
+
+
+def test_explicit_and_automatic_requests_can_be_combined_but_not_id_collisions():
+    from pyamplicol.color.connections import ColorLeg
+
+    legs = (ColorLeg(1, 8),)
+    config = CorrelatorConfig(
+        color_correlations=(ColorCorrelator.dipole("my-Casimir", 1, 1),),
+        all_color_through_order=1,
+    )
+    resolved = config._resolve_color(legs)
+    assert len(resolved.color_requests) == 3
+    with pytest.raises(ValueError, match="catalogue IDs are reserved"):
+        CorrelatorConfig(
+            color_correlations=(resolved.color_correlations[1],),
+            all_color_through_order=1,
+        )
+
+
+@pytest.mark.parametrize(
+    "groups", (((),), ((0,),), ((True,),), ((1, 1),), ((1, 2), (2, 1)))
+)
+def test_invalid_spin_classes(groups):
+    with pytest.raises(ValueError):
+        CorrelatorConfig(spin_correlations=groups)
+
+
+def test_duplicate_or_reserved_ids_rejected():
+    with pytest.raises(ValueError, match="reserved"):
+        CorrelatorConfig((ColorCorrelator("born"),))
+    with pytest.raises(ValueError, match="unique"):
+        CorrelatorConfig((ColorCorrelator("a"), ColorCorrelator("a")))
+
+
+def test_unknown_json_fields_and_step_kinds_rejected():
+    with pytest.raises(ValueError, match="unknown"):
+        CorrelatorConfig.from_json_dict({"colour_correlations": []})
+    with pytest.raises(ValueError, match="unknown"):
+        CorrelatorConfig.from_json_dict(
+            {"color_correlations": [{"id": "a", "bra": [{"kind": "unknown"}]}]}
+        )
+
+
+def test_cli_correlator_path_is_separate_from_default_generation_identity():
+    plain = parse_cli(["generate", "g g > g g", "output"])
+    selected = parse_cli(
+        ["generate", "g g > g g", "output", "--correlators", "correlators.json"]
+    )
+    assert plain.correlators is None
+    assert str(selected.correlators) == "correlators.json"
+    assert dict(plain.dedicated) == dict(selected.dedicated)
+    assert plain.resolve().effective == selected.resolve().effective
diff --git a/pyamplicol/tests/unit/test_correlator_runtime.py b/pyamplicol/tests/unit/test_correlator_runtime.py
new file mode 100644
index 0000000000..b3f41eca1d
--- /dev/null
+++ b/pyamplicol/tests/unit/test_correlator_runtime.py
@@ -0,0 +1,740 @@
+# SPDX-License-Identifier: 0BSD
+"""Controller and directed reducer checks with no numerical evaluator session."""
+
+from __future__ import annotations
+
+import copy
+import json
+from decimal import ROUND_UP, Decimal, localcontext
+from fractions import Fraction
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError, EvaluationError
+from pyamplicol.api.results import HelicityConfiguration
+from pyamplicol.api.services import Runtime
+from pyamplicol.color.connections import COLOR_CONNECTION_CONVENTION
+from pyamplicol.correlators import (
+    ColorCorrelator,
+    CorrelatedRequest,
+    CorrelatedValue,
+    CorrelatorConfig,
+)
+from pyamplicol.runtime import correlations
+from pyamplicol.runtime.correlated_exact import (
+    CoherentAmplitudeBatch,
+    CoherentAmplitudeGroup,
+    _prepare_spin_vectors,
+)
+from pyamplicol.runtime.correlations import CorrelatorEvaluator, _contract, _matrix
+
+
+def _matrix_record(identifier="born", weights=None):
+    weights = weights or ((-16, -16), (20, 2))
+    return {
+        "id": identifier,
+        "convention": COLOR_CONNECTION_CONVENTION,
+        "color_accuracy": "full",
+        "storage": "sparse-directed",
+        "includes_color_factor": True,
+        "sector_ids": [0, 1],
+        "entries": [
+            {
+                "left_sector_id": left,
+                "right_sector_id": right,
+                "weight": {"real": [value, 3], "imag": [0, 1]},
+            }
+            for left, row in enumerate(weights)
+            for right, value in enumerate(row)
+        ],
+    }
+
+
+def _group(helicity, sector, index):
+    return CoherentAmplitudeGroup(
+        index, f"h:{helicity}", (helicity,), (sector,), sector
+    )
+
+
+def _amplitude(value):
+    if isinstance(value, complex):
+        return Decimal(str(value.real)), Decimal(str(value.imag))
+    return Decimal(str(value)), Decimal(0)
+
+
+def _batch(points, *, helicities=(1,), normalization="1"):
+    return CoherentAmplitudeBatch(
+        tuple(tuple(_amplitude(value) for value in point) for point in points),
+        tuple(
+            _group(helicity, sector, index * 2 + sector)
+            for index, helicity in enumerate(helicities)
+            for sector in (0, 1)
+        ),
+        Decimal(normalization),
+        60,
+        (),
+    )
+
+
+def test_directed_two_by_two_matrix_preserves_complex_interference():
+    matrix = _matrix(_matrix_record())
+    result = _contract(_batch([(1, 1j)], normalization="1.5"), matrix, precision=40)
+    # conj((1,i)) K (1,i) = -14/3 - 12i, with one factor of 3/2.
+    assert result == (CorrelatedValue(Decimal(-7), Decimal(-18)),)
+
+
+def test_spectator_helicities_are_summed_incoherently():
+    matrix = _matrix(_matrix_record())
+    result = _contract(
+        _batch([(1, 1j, 2, -1j)], helicities=(-1, 1), normalization="1.5"),
+        matrix,
+        precision=40,
+    )
+    assert result == (CorrelatedValue(Decimal(-38), Decimal(18)),)
+    # Coherently adding helicities would give (-72, 0), a different observable.
+
+
+def test_batched_and_single_point_contractions_agree():
+    points = [(1, 1j), (2, 2j), (3 - 1j, 2 + 4j)]
+    matrix = _matrix(_matrix_record())
+    batched = _contract(_batch(points, normalization="1.5"), matrix, precision=50)
+    single = tuple(
+        _contract(_batch([point], normalization="1.5"), matrix, precision=50)[0]
+        for point in points
+    )
+    assert batched == single
+    assert batched[1] == CorrelatedValue(Decimal(-28), Decimal(-72))
+
+
+def test_exact_rationals_and_rounding_ignore_ambient_decimal_context():
+    record = _matrix_record()
+    record["entries"] = [
+        {
+            "left_sector_id": 0,
+            "right_sector_id": 1,
+            "weight": {"real": [1, 3], "imag": [2, 7]},
+        }
+    ]
+    with localcontext() as context:
+        context.prec = 4
+        context.rounding = ROUND_UP
+        result = _contract(_batch([(1, 1)]), _matrix(record), precision=40)[0]
+    assert result.real == Decimal("0." + "3" * 40)
+    assert result.imag == Decimal("0.2857142857142857142857142857142857142857")
+    assert _matrix(record).entries[0].real == Fraction(1, 3)
+
+
+@pytest.mark.parametrize(
+    "defect",
+    [
+        "float",
+        "bool",
+        "string",
+        "zero_denominator",
+        "bool_sector",
+        "duplicate",
+        "outside",
+        "empty",
+        "convention",
+    ],
+)
+def test_matrix_catalogue_rejects_malformed_exact_data(defect):
+    record = _matrix_record()
+    if defect in {"float", "bool", "string"}:
+        record["entries"][0]["weight"]["real"][0] = {
+            "float": 1.5,
+            "bool": True,
+            "string": "16.0",
+        }[defect]
+    elif defect == "zero_denominator":
+        record["entries"][0]["weight"]["imag"][1] = 0
+    elif defect == "bool_sector":
+        record["entries"][0]["left_sector_id"] = False
+    elif defect == "duplicate":
+        record["entries"].append(copy.deepcopy(record["entries"][0]))
+    elif defect == "outside":
+        record["entries"][0]["right_sector_id"] = 7
+    elif defect == "empty":
+        record["sector_ids"] = []
+    elif defect == "convention":
+        record["storage"] = "upper-triangle"
+    with pytest.raises(ArtifactError, match="matrix"):
+        _matrix(record)
+
+
+def test_matrix_reads_generation_integer_string_coefficients_exactly():
+    record = _matrix_record()
+    record["entries"][0]["weight"]["real"] = [10**60 + 7, 10**45 + 3]
+    expected = _matrix(record)
+    for entry in record["entries"]:
+        for component in ("real", "imag"):
+            entry["weight"][component] = [
+                str(value) for value in entry["weight"][component]
+            ]
+    assert _matrix(record) == expected
+
+
+@pytest.mark.parametrize("defect", ["missing_sector", "duplicate_group", "point_shape"])
+def test_reducer_checks_amplitude_matrix_shape(defect):
+    batch = _batch([(1, 1j)])
+    if defect == "missing_sector":
+        batch = CoherentAmplitudeBatch(
+            ((batch.values[0][0],),), batch.groups[:1], Decimal(1), 40, ()
+        )
+    elif defect == "duplicate_group":
+        batch = CoherentAmplitudeBatch(
+            batch.values, (batch.groups[0], batch.groups[0]), Decimal(1), 40, ()
+        )
+    else:
+        batch = CoherentAmplitudeBatch(
+            ((batch.values[0][0],),), batch.groups, Decimal(1), 40, ()
+        )
+    with pytest.raises(ArtifactError):
+        _contract(batch, _matrix(_matrix_record()), precision=40)
+
+
+class _Executor:
+    def __init__(
+        self, artifact, process_id, native, *, spin_correlated_legs, coherent_groups
+    ):
+        self.legs = spin_correlated_legs
+        self.groups = coherent_groups
+        self.calls = []
+        self.many_calls = []
+
+    def coherent_amplitudes(self, momenta, **kwargs):
+        self.calls.append((momenta, copy.deepcopy(kwargs)))
+        return _batch(
+            [(point[0][0], complex(0, point[0][0])) for point in momenta],
+            normalization="1.5",
+        )
+
+    def iter_coherent_amplitudes_many(self, momenta, **kwargs):
+        self.many_calls.append((momenta, copy.deepcopy(kwargs)))
+        assignments = tuple(
+            _prepare_spin_vectors(
+                vectors, allowed_legs=self.legs, point_count=len(momenta)
+            )
+            for vectors in kwargs["spin_vector_sets"]
+        )
+        for point_index, point in enumerate(momenta):
+            for assignment, vectors in enumerate(assignments):
+                vector = vectors[point_index].get(1, ((Decimal(0), Decimal(0)),) * 4)
+                energy = Decimal(str(point[0][0]))
+                x, y = energy + vector[0][0], energy + vector[1][0]
+                batch = _batch([(0, 0)], normalization="1.5")
+                yield (
+                    point_index,
+                    assignment,
+                    CoherentAmplitudeBatch(
+                        (((x, Decimal(0)), (Decimal(0), y)),),
+                        batch.groups,
+                        batch.normalization_factor,
+                        60,
+                        tuple(sorted(vectors[point_index])),
+                    ),
+                )
+
+
+@pytest.fixture
+def controller_factory(monkeypatch, tmp_path):
+    declarations = CorrelatorConfig(
+        color_correlations=(ColorCorrelator.dipole("ordered", 1, 2),),
+        spin_correlations=((1,), (1, 2)),
+    )
+    payload = {
+        "schema_version": 1,
+        "complete_source_basis": True,
+        "declarations": declarations.to_json_dict(),
+        "processes": {
+            "p": {
+                "declarations": declarations.to_json_dict(),
+                "spin_legs": [1, 2],
+                "matrices": [_matrix_record("born"), _matrix_record("ordered")],
+                "coherent_groups": [{"group_id": 0}],
+            }
+        },
+    }
+    extension = {"schema_version": 1, "path": "correlators.json"}
+    manifest = SimpleNamespace(extensions={"correlators": extension}, processes=[])
+    reads = []
+
+    def read_manifest(path):
+        reads.append("manifest")
+        return manifest
+
+    def read_sidecar():
+        reads.append("sidecar")
+        return json.dumps(payload)
+
+    monkeypatch.setattr(correlations, "load_manifest", read_manifest)
+    monkeypatch.setattr(
+        correlations,
+        "confined_path",
+        lambda artifact, path: SimpleNamespace(read_text=read_sidecar),
+    )
+    monkeypatch.setattr(
+        correlations,
+        "native_process_selection",
+        lambda runtime, processes: SimpleNamespace(
+            representative_process_id="p",
+            external_permutation=(0, 1),
+            process_group=None,
+        ),
+    )
+    monkeypatch.setattr(correlations, "CorrelatedExactExecutor", _Executor)
+    backend = SimpleNamespace(_artifact_path=tmp_path, _runtime=object())
+    return SimpleNamespace(
+        create=lambda: CorrelatorEvaluator(backend),
+        payload=payload,
+        manifest=manifest,
+        backend=backend,
+        reads=reads,
+    )
+
+
+def test_public_catalogue_is_typed_lazy_and_reused_for_evaluation(
+    controller_factory, monkeypatch
+):
+    factory = controller_factory
+    runtime = object.__new__(Runtime)
+    runtime._backend = factory.backend
+    constructed = []
+    validated = []
+    matrix_reader = correlations._matrix
+
+    def executor(*args, **kwargs):
+        constructed.append(True)
+        return _Executor(*args, **kwargs)
+
+    def matrix(record):
+        validated.append(record["id"])
+        return matrix_reader(record)
+
+    monkeypatch.setattr(correlations, "CorrelatedExactExecutor", executor)
+    monkeypatch.setattr(correlations, "_matrix", matrix)
+    expected = (ColorCorrelator("born"), ColorCorrelator.dipole("ordered", 1, 2))
+    available = runtime.available_color_correlations()
+    assert available == expected
+    assert runtime.available_color_correlations() == expected
+    assert all(isinstance(item, ColorCorrelator) for item in available)
+    assert constructed == []
+    assert not hasattr(runtime, "_correlated_evaluator")
+    assert factory.reads == ["manifest", "sidecar"]
+    assert validated == ["born", "ordered"]
+
+    # Evaluating after discovery consumes the same validated metadata.
+    runtime.evaluate_correlated([[(1, 0, 0, 1)]], color_correlation="ordered")
+    assert constructed == [True]
+    assert factory.reads == ["manifest", "sidecar"]
+    assert validated == ["born", "ordered"]
+    assert runtime.available_color_correlations() == expected
+
+
+def test_public_catalogue_uses_selected_process_not_global_declarations(
+    controller_factory, monkeypatch
+):
+    factory = controller_factory
+    factory.payload["declarations"] = {"all_color_through_order": 3}
+    process = copy.deepcopy(factory.payload["processes"]["p"])
+    declarations = CorrelatorConfig((ColorCorrelator.dipole("selected", 2, 1),))
+    process.update(
+        declarations=declarations.to_json_dict(),
+        spin_legs=[],
+        matrices=[_matrix_record("born"), _matrix_record("selected")],
+    )
+    factory.payload["processes"]["q"] = process
+    monkeypatch.setattr(
+        correlations,
+        "native_process_selection",
+        lambda native, processes: SimpleNamespace(
+            representative_process_id="q",
+            external_permutation=(0, 1),
+            process_group=None,
+        ),
+    )
+    runtime = object.__new__(Runtime)
+    runtime._backend = factory.backend
+    assert runtime.available_color_correlations() == declarations.color_requests
+    assert not hasattr(runtime, "_correlated_evaluator")
+
+
+@pytest.mark.parametrize("defect", ["missing", "unresolved", "matrix_ids"])
+def test_public_catalogue_requires_resolved_consistent_process_declarations(
+    controller_factory, defect
+):
+    process = controller_factory.payload["processes"]["p"]
+    if defect == "missing":
+        del process["declarations"]
+    elif defect == "unresolved":
+        process["declarations"]["all_color_through_order"] = 1
+    else:
+        process["declarations"]["color_correlations"] = []
+    runtime = object.__new__(Runtime)
+    runtime._backend = controller_factory.backend
+    with pytest.raises(ArtifactError):
+        runtime.available_color_correlations()
+    assert not hasattr(runtime, "_correlated_catalogue")
+    assert not hasattr(runtime, "_correlated_evaluator")
+
+
+def test_public_catalogue_requires_generation_opt_in(controller_factory):
+    controller_factory.manifest.extensions = {}
+    runtime = object.__new__(Runtime)
+    runtime._backend = controller_factory.backend
+    with pytest.raises(CompatibilityError, match="declared at generation"):
+        runtime.available_color_correlations()
+
+
+@pytest.mark.parametrize("operation", ["list", "evaluate"])
+def test_public_catalogue_rejects_permuted_alias_before_executor(
+    controller_factory, monkeypatch, operation
+):
+    monkeypatch.setattr(
+        correlations,
+        "native_process_selection",
+        lambda native, processes: SimpleNamespace(
+            representative_process_id="p",
+            external_permutation=(1, 0),
+            process_group=None,
+        ),
+    )
+
+    def unexpected_executor(*args, **kwargs):
+        raise AssertionError("alias rejection must precede amplitude loading")
+
+    monkeypatch.setattr(correlations, "CorrelatedExactExecutor", unexpected_executor)
+    runtime = object.__new__(Runtime)
+    runtime._backend = controller_factory.backend
+    with pytest.raises(CompatibilityError, match="non-identity process aliases"):
+        if operation == "list":
+            runtime.available_color_correlations()
+        else:
+            runtime.evaluate_correlated([[(1, 0, 0, 1)]])
+    assert not hasattr(runtime, "_correlated_catalogue")
+    assert not hasattr(runtime, "_correlated_evaluator")
+
+
+def test_vectors_instance_isolation_copy_failed_setter_atomic_and_reset(
+    controller_factory,
+):
+    first, second = controller_factory.create(), controller_factory.create()
+    assert (
+        first._executor.groups
+        == controller_factory.payload["processes"]["p"]["coherent_groups"]
+    )
+    vector = [1, 2, 3, 4]
+    first.set_spin_correlation_vectors({1: vector})
+    vector[0] = 999
+    assert first._vectors == {1: (1, 2, 3, 4)}
+    with pytest.raises(EvaluationError, match="at least one"):
+        first.set_spin_correlation_vectors({1: []})
+    assert first._vectors == {1: (1, 2, 3, 4)}
+    assert second._vectors == {}
+    with pytest.raises(EvaluationError, match="finite"):
+        first.set_spin_correlation_vectors(
+            {1: (5, 6, 7, 8), 2: (float("nan"), 1, 2, 3)}
+        )
+    assert first._vectors == {1: (1, 2, 3, 4)}
+    with pytest.raises(EvaluationError, match="class"):
+        first.set_spin_correlation_vectors({2: (1, 2, 3, 4)})
+    assert first._vectors == {1: (1, 2, 3, 4)}
+    first.set_spin_correlation_vectors(None)
+    assert first._vectors == {}
+    first.set_spin_correlation_vectors({1: (1, 2, 3, 4)})
+    first.set_spin_correlation_vectors({})
+    assert first._vectors == {}
+
+
+def test_point_vectors_copied_and_controller_forwards_requests(controller_factory):
+    evaluator = controller_factory.create()
+    vectors = [[1, 2, 3, 4], [5, 6, 7, 8]]
+    evaluator.set_spin_correlation_vectors({1: vectors})
+    vectors[1][0] = 99
+    momenta = [[(1, 0, 0, 1)], [(2, 0, 0, 2)]]
+    result = evaluator.evaluate(
+        momenta, color_correlation="ordered", helicities=["h:1"], precision=50
+    )
+    assert result == (
+        CorrelatedValue(Decimal(-7), Decimal(-18)),
+        CorrelatedValue(Decimal(-28), Decimal(-72)),
+    )
+    received = evaluator._executor.calls[0][1]
+    assert received["spin_vectors"] == {1: ((1, 2, 3, 4), (5, 6, 7, 8))}
+    assert received["helicities"] == ["h:1"]
+    assert received["precision"] > 50
+    with pytest.raises(EvaluationError, match="unknown"):
+        evaluator.evaluate(momenta, color_correlation="absent")
+    for precision in (True, 0, "40"):
+        with pytest.raises(EvaluationError, match="precision"):
+            evaluator.evaluate(momenta, precision=precision)
+
+
+def test_explicit_generation_opt_in_required(controller_factory):
+    controller_factory.manifest.extensions = {}
+    with pytest.raises(CompatibilityError, match="declared at generation"):
+        controller_factory.create()
+    with pytest.raises(CompatibilityError, match="does not support"):
+        CorrelatorEvaluator(object())
+
+
+def test_many_keeps_distinct_request_and_point_axes(controller_factory):
+    evaluator = controller_factory.create()
+    requests = {
+        "spin-a": CorrelatedRequest("ordered", {1: ((1, 0, 0, 0), (2, 1, 0, 0))}),
+        "spin-b": CorrelatedRequest("ordered", {1: (4, 2, 0, 0)}),
+    }
+    result = evaluator.evaluate_many(
+        [[(1, 0, 0, 1)], [(3, 0, 0, 3)]], requests, precision=40
+    )
+    assert tuple(result) == ("spin-a", "spin-b")
+    assert result == {
+        "spin-a": (
+            CorrelatedValue(Decimal(-31), Decimal(-36)),
+            CorrelatedValue(Decimal(-184), Decimal(-360)),
+        ),
+        "spin-b": (
+            CorrelatedValue(Decimal(-191), Decimal(-270)),
+            CorrelatedValue(Decimal(-367), Decimal(-630)),
+        ),
+    }
+    assert {label: values[1] for label, values in result.items()} == {
+        "spin-a": CorrelatedValue(Decimal(-184), Decimal(-360)),
+        "spin-b": CorrelatedValue(Decimal(-367), Decimal(-630)),
+    }
+    assert len(evaluator._executor.many_calls[0][1]["spin_vector_sets"]) == 2
+
+
+def test_many_groups_inherited_explicit_and_broadcast_vectors(
+    controller_factory, monkeypatch
+):
+    evaluator = controller_factory.create()
+    evaluator.set_spin_correlation_vectors({1: (1, 2, 3, 4)})
+    requests = {
+        "inherited": CorrelatedRequest("born"),
+        "another-colour": CorrelatedRequest("ordered", {1: ((1, 2, 3, 4),) * 2}),
+        "same-again": CorrelatedRequest("born", {1: (1, 2, 3, 4)}),
+        "physical": CorrelatedRequest("born", {}),
+    }
+    prepared = []
+    original = correlations._prepare_contraction
+
+    def count_plan(*args, **kwargs):
+        prepared.append(args)
+        return original(*args, **kwargs)
+
+    monkeypatch.setattr(correlations, "_prepare_contraction", count_plan)
+    result = evaluator.evaluate_many([[(1, 0, 0, 1)], [(2, 0, 0, 2)]], requests)
+    assert result["inherited"] == result["another-colour"] == result["same-again"]
+    assert result["physical"] != result["inherited"]
+    assert len(evaluator._executor.many_calls) == 1
+    assert len(evaluator._executor.many_calls[0][1]["spin_vector_sets"]) == 2
+    assert len(prepared) == 3  # Two colour IDs for one spin state; one for physical.
+    assert evaluator._vectors == {1: (1, 2, 3, 4)}
+
+
+def test_many_scalar_batch_equivalence_and_exact_vector_grouping(controller_factory):
+    evaluator = controller_factory.create()
+    tiny = Decimal("1e-60")
+    requests = {
+        "one": CorrelatedRequest("born", {1: (tiny, 2, 3, 4)}),
+        "two": CorrelatedRequest("born", {1: (2 * tiny, 2, 3, 4)}),
+    }
+    points = [[(1, 0, 0, 1)], [(2, 0, 0, 2)]]
+    with localcontext() as context:
+        context.prec = 90
+        batch = evaluator.evaluate_many(points, requests, precision=70)
+        scalar = [
+            evaluator.evaluate_many([point], requests, precision=70) for point in points
+        ]
+    assert batch == {
+        label: tuple(point[label][0] for point in scalar) for label in requests
+    }
+    assert batch["one"] != batch["two"]
+    assert len(evaluator._executor.many_calls[0][1]["spin_vector_sets"]) == 2
+
+
+def test_decimal_setter_and_grouped_broadcast_preserve_sub_binary64_differences(
+    controller_factory,
+):
+    runtime = object.__new__(Runtime)
+    runtime._backend = controller_factory.backend
+    first = Decimal("1.000000000000000000000000000000000000000000000000000000000001")
+    second = Decimal("1.000000000000000000000000000000000000000000000000000000000002")
+    vector = [first, Decimal(0), Decimal(0), Decimal(0)]
+    points = [[(1, 0, 0, 1)], [(2, 0, 0, 2)]]
+    runtime.set_spin_correlation_vectors({1: vector})
+    vector[0] = second
+    runtime.evaluate_correlated(points, precision=80)
+    evaluator = runtime._correlated_evaluator
+    assert evaluator._vectors[1][0] is first
+
+    assert evaluator._executor.calls[0][1]["spin_vectors"][1][0] == first
+    runtime.evaluate_correlated_many(
+        points,
+        {
+            "inherited": CorrelatedRequest(),
+            "same-broadcast": CorrelatedRequest(spin_vectors={1: (first, 0, 0, 0)}),
+            "same-batch": CorrelatedRequest(spin_vectors={1: ((first, 0, 0, 0),) * 2}),
+            "different-second-point": CorrelatedRequest(
+                spin_vectors={1: ((first, 0, 0, 0), (second, 0, 0, 0))}
+            ),
+        },
+        precision=80,
+    )
+    assignments = evaluator._executor.many_calls[0][1]["spin_vector_sets"]
+    assert len(assignments) == 2
+    assert assignments[0][1][0] == first
+    assert assignments[1][1][0][0] == first
+    assert assignments[1][1][1][0] == second
+    assert evaluator._vectors[1][0] is first
+
+
+@pytest.mark.parametrize("point_count", (2, 4))
+def test_complex_decimal_pairs_are_copied_and_not_confused_with_point_batches(
+    controller_factory, point_count
+):
+    runtime = object.__new__(Runtime)
+    runtime._backend = controller_factory.backend
+    real = Decimal("1.000000000000000000000000000000001")
+    imaginary = Decimal("0.000000000000000000000000000000001")
+    component = [real, imaginary]
+    runtime.set_spin_correlation_vectors({1: [component, 0, 0, 0]})
+    component[0] = Decimal(9)
+    points = [[(1, 0, 0, 1)]] * point_count
+    result = runtime.evaluate_correlated_many(
+        points,
+        {
+            "inherited": CorrelatedRequest(),
+            "batch": CorrelatedRequest(
+                spin_vectors={1: (((real, imaginary), 0, 0, 0),) * point_count}
+            ),
+        },
+        precision=60,
+    )
+    assert result["batch"] == result["inherited"]
+    evaluator = runtime._correlated_evaluator
+    assert evaluator._vectors[1][0] == (real, imaginary)
+    assert len(evaluator._executor.many_calls[0][1]["spin_vector_sets"]) == 1
+
+
+@pytest.mark.parametrize("defect", ("id", "class", "shape", "label", "type"))
+def test_many_validates_all_requests_before_evaluation_without_setter_mutation(
+    controller_factory, defect
+):
+    evaluator = controller_factory.create()
+    evaluator.set_spin_correlation_vectors({1: (1, 2, 3, 4)})
+    requests = {"good": CorrelatedRequest(), "bad": CorrelatedRequest()}
+    if defect == "id":
+        requests["bad"] = CorrelatedRequest("missing")
+    elif defect == "class":
+        requests["bad"] = CorrelatedRequest(spin_vectors={2: (1, 2, 3, 4)})
+    elif defect == "shape":
+        requests["bad"] = CorrelatedRequest(spin_vectors={1: ((1, 2, 3, 4),)})
+    elif defect == "label":
+        requests[None] = requests.pop("bad")
+    else:
+        requests["bad"] = {}
+    with pytest.raises(EvaluationError):
+        evaluator.evaluate_many([[(1, 0, 0, 1)], [(2, 0, 0, 2)]], requests)
+    assert evaluator._executor.many_calls == []
+    assert evaluator._vectors == {1: (1, 2, 3, 4)}
+
+
+def test_many_empty_requests_and_signed_zero_assignments(controller_factory):
+    evaluator = controller_factory.create()
+    assert evaluator.evaluate_many([[(1, 0, 0, 1)]], {}) == {}
+    assert evaluator._executor.many_calls == []
+    evaluator.evaluate_many(
+        [[(1, 0, 0, 1)]],
+        {
+            "positive": CorrelatedRequest(spin_vectors={1: (Decimal("0"), 0, 0, 0)}),
+            "negative": CorrelatedRequest(spin_vectors={1: (Decimal("-0"), 0, 0, 0)}),
+        },
+    )
+    assert len(evaluator._executor.many_calls[0][1]["spin_vector_sets"]) == 2
+
+
+def test_many_public_typed_selectors_and_result_shape(controller_factory):
+    runtime = object.__new__(Runtime)
+    runtime._backend = controller_factory.backend
+    result = runtime.evaluate_correlated_many(
+        [[(1, 0, 0, 1)], [(2, 0, 0, 2)]],
+        {"dipole": CorrelatedRequest("ordered")},
+        helicities=[HelicityConfiguration("h:1", 0, (1,), True, False, "h:1", 1)],
+        precision=50,
+    )
+    assert result["dipole"] == (
+        CorrelatedValue(Decimal(-7), Decimal(-18)),
+        CorrelatedValue(Decimal(-28), Decimal(-72)),
+    )
+    assert runtime._correlated_evaluator._executor.many_calls[0][1]["helicities"] == (
+        "h:1",
+    )
+
+
+@pytest.mark.parametrize("accuracy", ("lc", "nlc", "full"))
+def test_matrix_reader_accepts_declared_colour_accuracy(accuracy):
+    record = _matrix_record()
+    record["color_accuracy"] = accuracy
+    assert _matrix(record).id == "born"
+
+
+@pytest.mark.parametrize(
+    "defect",
+    [
+        "extension_version",
+        "payload_version",
+        "basis",
+        "legs",
+        "bool_leg",
+        "missing_id",
+        "duplicate_id",
+        "missing_process",
+    ],
+)
+def test_catalogue_validation(controller_factory, defect):
+    factory = controller_factory
+    process = factory.payload["processes"]["p"]
+    if defect == "extension_version":
+        factory.manifest.extensions["correlators"]["schema_version"] = True
+    elif defect == "payload_version":
+        factory.payload["schema_version"] = True
+    elif defect == "basis":
+        factory.payload["complete_source_basis"] = False
+    elif defect == "legs":
+        process["spin_legs"] = [1]
+    elif defect == "bool_leg":
+        process["spin_legs"] = [True, 2]
+    elif defect == "missing_id":
+        process["matrices"].pop()
+    elif defect == "duplicate_id":
+        process["matrices"][1]["id"] = "born"
+    elif defect == "missing_process":
+        factory.payload["processes"] = {}
+    with pytest.raises(ArtifactError, match="catalogue"):
+        factory.create()
+
+
+def test_public_runtime_forwards_typed_helicity_id_and_validates_precision():
+    calls = []
+    recorder = SimpleNamespace(
+        evaluate=lambda *args, **kwargs: calls.append((args, kwargs)) or (),
+        set_spin_correlation_vectors=lambda value: calls.append(value),
+    )
+    runtime = object.__new__(Runtime)
+    runtime._correlated_evaluator = recorder
+    helicity = HelicityConfiguration("h:1", 0, (1,), True, False, "h:1", 1)
+    assert (
+        runtime.evaluate_correlated(
+            [[(1, 0, 0, 1)]], helicities=[helicity, "h:-1"], precision=40
+        )
+        == ()
+    )
+    assert calls[-1][1]["helicities"] == ("h:1", "h:-1")
+    assert calls[-1][1]["precision"] == 40
+    runtime.set_spin_correlation_vectors(None)
+    assert calls[-1] is None
+    with pytest.raises((ValueError, TypeError)):
+        runtime.evaluate_correlated([[(1, 0, 0, 1)]], precision=True)
diff --git a/pyamplicol/tests/unit/test_dag_equivalence_projective.py b/pyamplicol/tests/unit/test_dag_equivalence_projective.py
new file mode 100644
index 0000000000..6ceae7d376
--- /dev/null
+++ b/pyamplicol/tests/unit/test_dag_equivalence_projective.py
@@ -0,0 +1,498 @@
+# SPDX-License-Identifier: 0BSD
+"""Algebraically exact projective-current proof contracts."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from math import inf
+
+import pytest
+
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_equivalence import (
+    _canonicalize_projective_term_vector,
+    _classify_current_term_vector,
+    _complex_weight_mul,
+    _exact_representable_complex_product,
+    _exact_representable_complex_ratio,
+    _term_vector_scaled_exactly,
+    _validate_numerical_current_application_baseline,
+    assign_recursive_current_evaluation_reuse,
+    project_rectangular_dynamic_color_classes,
+)
+from pyamplicol.generation.dag_types import ColorState, GenericDAG
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _vector(
+    *coefficients: tuple[float, float],
+) -> tuple[tuple[tuple[object, ...], tuple[float, float]], ...]:
+    return tuple(
+        ((index,), coefficient) for index, coefficient in enumerate(coefficients)
+    )
+
+
+def _classify_sequence(
+    vectors: tuple[
+        tuple[tuple[tuple[object, ...], tuple[float, float]], ...],
+        ...,
+    ],
+):
+    equivalence_by_expression = {}
+    projective_representatives_by_expression = {}
+    return tuple(
+        _classify_current_term_vector(
+            current_id=current_id,
+            contract=("same-current-contract",),
+            term_vector=term_vector,
+            equivalence_by_expression=equivalence_by_expression,
+            projective_representatives_by_expression=(
+                projective_representatives_by_expression
+            ),
+        )
+        for current_id, term_vector in enumerate(vectors)
+    )
+
+
+def test_projective_current_reuse_retains_an_exact_complex_factor() -> None:
+    representative = _vector((2.0, 0.0), (0.0, 4.0))
+    scaled = _vector((0.0, 1.0), (-2.0, 0.0))
+
+    equivalences = _classify_sequence((representative, scaled, scaled))
+
+    assert equivalences[0].representative_id == 0
+    assert equivalences[0].factor == (1.0, 0.0)
+    assert equivalences[1].representative_id == 0
+    assert equivalences[1].factor == (0.0, 0.5)
+    assert equivalences[2] == equivalences[1]
+    assert _term_vector_scaled_exactly(
+        representative,
+        equivalences[1].factor,
+        scaled,
+    )
+
+
+def test_identity_and_sign_reuse_remain_deterministic_fast_paths() -> None:
+    representative = _vector((2.0, 1.0), (-4.0, 3.0))
+    opposite = _vector((-2.0, -1.0), (4.0, -3.0))
+    vectors = (representative, representative, opposite)
+
+    first = _classify_sequence(vectors)
+    second = _classify_sequence(vectors)
+
+    assert first == second
+    assert tuple(item.representative_id for item in first) == (0, 0, 0)
+    assert tuple(item.factor for item in first) == (
+        (1.0, 0.0),
+        (1.0, 0.0),
+        (-1.0, 0.0),
+    )
+
+
+def test_exact_zero_vectors_reuse_without_projective_normalization() -> None:
+    equivalences = _classify_sequence(((), ()))
+
+    assert tuple(item.representative_id for item in equivalences) == (0, 0)
+    assert tuple(item.factor for item in equivalences) == (
+        (1.0, 0.0),
+        (1.0, 0.0),
+    )
+    assert _canonicalize_projective_term_vector(()) is None
+
+
+def test_projective_reuse_rejects_a_nonproportional_coefficient() -> None:
+    representative = _vector((2.0, 0.0), (0.0, 4.0))
+    deformed = _vector((0.0, 1.0), (-2.5, 0.0))
+
+    equivalences = _classify_sequence((representative, deformed))
+
+    assert equivalences[1].representative_id == 1
+    assert equivalences[1].factor == (1.0, 0.0)
+
+
+def test_projective_reuse_rejects_a_rounded_unrepresentable_factor() -> None:
+    representative = _vector((3.0, 0.0), (6.0, 0.0))
+    rounded_third = _vector((1.0, 0.0), (2.0, 0.0))
+
+    assert (
+        _exact_representable_complex_ratio(
+            rounded_third[0][1],
+            representative[0][1],
+        )
+        is None
+    )
+    equivalences = _classify_sequence((representative, rounded_third))
+    assert equivalences[1].representative_id == 1
+
+
+def test_recursive_projective_factor_composition_fails_closed() -> None:
+    assert _exact_representable_complex_product(
+        (2.0, 0.0),
+        (0.5, 0.0),
+    ) == (1.0, 0.0)
+    assert (
+        _exact_representable_complex_product(
+            (1.0e308, 0.0),
+            (1.0e308, 0.0),
+        )
+        is None
+    )
+    assert (
+        _exact_representable_complex_product(
+            (0.1, 0.0),
+            (0.2, 0.0),
+        )
+        is None
+    )
+
+
+def test_projective_reuse_rejects_an_ambiguous_exact_representative() -> None:
+    first = _vector((3.0, 0.0), (6.0, 0.0))
+    second = _vector((1.0, 0.0), (2.0, 0.0))
+    exact_multiple_of_both = _vector((6.0, 0.0), (12.0, 0.0))
+
+    equivalences = _classify_sequence((first, second, exact_multiple_of_both))
+
+    assert equivalences[0].representative_id == 0
+    assert equivalences[1].representative_id == 1
+    assert equivalences[2].representative_id == 2
+
+
+def test_projective_canonicalization_rejects_unsafe_vectors() -> None:
+    assert _canonicalize_projective_term_vector(()) is None
+    assert _canonicalize_projective_term_vector(_vector((0.0, 0.0))) is None
+    assert _canonicalize_projective_term_vector(_vector((inf, 0.0))) is None
+
+    duplicate_key = (
+        ((0,), (1.0, 0.0)),
+        ((0,), (2.0, 0.0)),
+    )
+    unordered = (
+        ((1,), (1.0, 0.0)),
+        ((0,), (2.0, 0.0)),
+    )
+    assert _canonicalize_projective_term_vector(duplicate_key) is None
+    assert _canonicalize_projective_term_vector(unordered) is None
+
+
+def test_projective_factor_propagates_to_a_child_evaluation_group() -> None:
+    """A proportional parent must share its child's kernel, not the root value."""
+
+    model = BuiltinSMModel()
+    seed = compile_generic_dag(
+        build_process_ir("d d~ > z g", color_accuracy="lc"),
+        model=model,
+    )
+    template = seed.interactions[0]
+    generated_template = seed.currents[template.result_id]
+    source_templates = tuple(seed.currents[source_id] for source_id in seed.sources[:2])
+    sources = tuple(
+        replace(source, id=current_id)
+        for current_id, source in enumerate(source_templates)
+    )
+    generated = tuple(
+        replace(generated_template, id=current_id) for current_id in range(2, 6)
+    )
+
+    def interaction(
+        interaction_id: int,
+        left_id: int,
+        right_id: int,
+        result_id: int,
+        color_weight: tuple[float, float],
+    ):
+        return replace(
+            template,
+            id=interaction_id,
+            left_id=left_id,
+            right_id=right_id,
+            result_id=result_id,
+            color_weight=color_weight,
+            evaluation_group_id=None,
+            evaluation_factor=(1.0, 0.0),
+        )
+
+    interactions = (
+        interaction(0, 0, 1, 2, (1.0, 0.0)),
+        interaction(1, 0, 1, 3, (2.0, 0.0)),
+        interaction(2, 2, 1, 4, (1.0, 0.0)),
+        interaction(3, 3, 1, 5, (1.0, 0.0)),
+    )
+    root = replace(
+        seed.amplitude_roots[0],
+        id=0,
+        left_id=5,
+        right_id=1,
+    )
+    dag = replace(
+        seed,
+        currents=(*sources, *generated),
+        sources=(0, 1),
+        interactions=interactions,
+        amplitude_roots=(root,),
+        selected_source_helicities=(),
+        selected_color_sector_ids=(),
+        lc_topology_replay=None,
+        helicity_recurrence=None,
+        helicity_materialization=None,
+    )
+
+    rewritten = assign_recursive_current_evaluation_reuse(dag, model)
+
+    parent, proportional_parent, child, proportional_child = rewritten.interactions
+    assert parent.evaluation_group_id == proportional_parent.evaluation_group_id
+    assert child.evaluation_group_id == proportional_child.evaluation_group_id
+    assert proportional_child.evaluation_factor == _complex_weight_mul(
+        (2.0, 0.0),
+        child.evaluation_factor,
+    )
+    # Roots consume separately materialized currents. Rewriting a shared child
+    # kernel must therefore leave the physical amplitude contraction untouched.
+    assert rewritten.amplitude_roots == dag.amplitude_roots
+
+
+def test_numerical_baseline_authentication_canonicalizes_signed_zero_only() -> None:
+    model = BuiltinSMModel()
+    dag = assign_recursive_current_evaluation_reuse(
+        compile_generic_dag(
+            build_process_ir("d d~ > z g", color_accuracy="lc"),
+            model=model,
+        ),
+        model,
+    )
+    interaction = dag.interactions[0]
+    factor = interaction.evaluation_factor
+    signed_zero = replace(
+        interaction,
+        evaluation_factor=(factor[0], -0.0),
+    )
+    signed_zero_dag = replace(
+        dag,
+        interactions=(signed_zero, *dag.interactions[1:]),
+    )
+
+    _validate_numerical_current_application_baseline(signed_zero_dag, model)
+
+    tampered = replace(signed_zero, evaluation_factor=(factor[0] + 1.0, -0.0))
+    with pytest.raises(ValueError, match="unauthenticated for interaction 0"):
+        _validate_numerical_current_application_baseline(
+            replace(dag, interactions=(tampered, *dag.interactions[1:])),
+            model,
+        )
+
+
+def _dynamic_color_projection_fixture() -> tuple[
+    GenericDAG,
+    BuiltinSMModel,
+    dict[int, complex],
+    int,
+]:
+    model = BuiltinSMModel()
+    seed = compile_generic_dag(
+        build_process_ir("d d~ > z g", color_accuracy="lc"),
+        model=model,
+    )
+    source0 = replace(seed.currents[seed.sources[0]], id=0)
+    source1 = replace(seed.currents[seed.sources[1]], id=1)
+    generated_template = seed.currents[seed.interactions[0].result_id]
+
+    def projected_current(
+        current_id: int,
+        *,
+        family: str,
+        color_id: int,
+    ):
+        index = replace(
+            generated_template.index,
+            color_state=ColorState("lc", sector_id=color_id),
+            auxiliary_kind=family,
+        )
+        return replace(generated_template, id=current_id, index=index)
+
+    currents = (
+        source0,
+        source1,
+        projected_current(2, family="a", color_id=11),
+        projected_current(3, family="a", color_id=12),
+        projected_current(4, family="b", color_id=21),
+        projected_current(5, family="b", color_id=22),
+        projected_current(6, family="c", color_id=132),
+        projected_current(7, family="c", color_id=32),
+    )
+    template = seed.interactions[0]
+
+    def interaction(
+        interaction_id: int,
+        left_id: int,
+        right_id: int,
+        result_id: int,
+        weight: tuple[float, float],
+    ):
+        return replace(
+            template,
+            id=interaction_id,
+            left_id=left_id,
+            right_id=right_id,
+            result_id=result_id,
+            color_weight=weight,
+            evaluation_group_id=None,
+            evaluation_factor=(1.0, 0.0),
+        )
+
+    interactions = (
+        interaction(0, 0, 1, 2, (1.0, 2.0)),
+        interaction(1, 0, 1, 3, (2.0, -1.0)),
+        interaction(2, 0, 1, 4, (-3.0, 1.0)),
+        interaction(3, 0, 1, 5, (4.0, 0.5)),
+        interaction(4, 2, 4, 6, (1.0, -0.5)),
+        interaction(5, 2, 5, 6, (1.0, -0.5)),
+        interaction(6, 3, 4, 6, (1.0, -0.5)),
+        interaction(7, 3, 5, 6, (1.0, -0.5)),
+        interaction(8, 2, 4, 7, (-0.25, 2.0)),
+        interaction(9, 2, 5, 7, (-0.25, 2.0)),
+        interaction(10, 3, 4, 7, (-0.25, 2.0)),
+        interaction(11, 3, 5, 7, (-0.25, 2.0)),
+    )
+    selected_sector_id = int(seed.color_plan.sectors[0].id)
+    currents = (
+        *currents[:6],
+        replace(
+            currents[6],
+            index=replace(
+                currents[6].index,
+                color_state=ColorState("lc", sector_id=selected_sector_id + 100),
+            ),
+        ),
+        replace(
+            currents[7],
+            index=replace(
+                currents[7].index,
+                color_state=ColorState("lc", sector_id=selected_sector_id),
+            ),
+        ),
+    )
+    roots = (
+        replace(
+            seed.amplitude_roots[0],
+            id=0,
+            left_id=6,
+            right_id=0,
+            color_weight=(0.75, -0.25),
+            color_sector_id=selected_sector_id,
+        ),
+        replace(
+            seed.amplitude_roots[0],
+            id=1,
+            left_id=7,
+            right_id=0,
+            color_weight=(0.75, -0.25),
+            color_sector_id=None,
+        ),
+    )
+    dag = GenericDAG(
+        process=seed.process,
+        color_plan=seed.color_plan,
+        currents=currents,
+        sources=(0, 1),
+        interactions=interactions,
+        amplitude_roots=roots,
+        truncated=False,
+        helicity_coverage="selected",
+        color_coverage="selected",
+        selected_source_helicities=(),
+        selected_color_sector_ids=(selected_sector_id,),
+    )
+    return dag, model, {0: 0.75 - 0.2j, 1: -1.25 + 0.5j}, selected_sector_id
+
+
+def _evaluate_scalar_bilinear_dag(
+    dag: GenericDAG,
+    source_values: dict[int, complex],
+) -> complex:
+    """Numerically exercise the exact multilinear algebra of the projection."""
+
+    values = [0j] * len(dag.currents)
+    for current_id, value in source_values.items():
+        values[current_id] = value
+    for row in dag.interactions:
+        values[row.result_id] += (
+            complex(*row.color_weight) * values[row.left_id] * values[row.right_id]
+        )
+    return sum(
+        complex(*root.color_weight) * values[root.left_id] * values[root.right_id]
+        for root in dag.amplitude_roots
+    )
+
+
+def test_dynamic_color_projection_preserves_complex_cartesian_sums() -> None:
+    dag, model, source_values, selected_sector_id = (
+        _dynamic_color_projection_fixture()
+    )
+
+    projected, certificate = project_rectangular_dynamic_color_classes(
+        dag,
+        model,
+        source_revision="a" * 40,
+    )
+    projected_source_values = {
+        certificate.old_to_new_current_ids[current_id]: value
+        for current_id, value in source_values.items()
+    }
+
+    assert certificate.applied is True
+    assert certificate.before_current_count == 8
+    assert certificate.after_current_count == 5
+    assert certificate.before_interaction_count == 12
+    assert certificate.after_interaction_count == 6
+    assert certificate.projected_current_class_count == 3
+    assert certificate.rectangular_interaction_group_count == 6
+    assert certificate.rectangular_closure_group_count == 1
+    assert certificate.source_revision == "a" * 40
+    assert certificate.equality_check_status == (
+        "passed-exact-cartesian-products-no-duplicates"
+    )
+    assert len(certificate.old_to_new_current_ids) == len(dag.currents)
+    assert all(
+        len(value) == 64
+        for key, value in certificate.to_json_dict().items()
+        if key.endswith("_sha256")
+    )
+    assert len(projected.amplitude_roots) == 1
+    # Root 1 originally resolved sector ``selected_sector_id`` implicitly,
+    # while the class representative (old current 6) carried another sector.
+    # The emitted closure must retain the pre-projection physical sector.
+    assert projected.amplitude_roots[0].color_sector_id == selected_sector_id
+    assert _evaluate_scalar_bilinear_dag(
+        projected,
+        projected_source_values,
+    ) == pytest.approx(_evaluate_scalar_bilinear_dag(dag, source_values))
+
+
+def test_dynamic_color_projection_retains_basis_and_line_group_metadata() -> None:
+    dag, model, _source_values, _selected_sector_id = (
+        _dynamic_color_projection_fixture()
+    )
+    currents = list(dag.currents)
+    current = currents[3]
+    currents[3] = replace(
+        current,
+        index=replace(
+            current.index,
+            color_state=replace(
+                current.index.color_state,
+                line_groups=(7, 8),
+                basis_key=("distinct-coherent-basis",),
+            ),
+        ),
+    )
+    separated = replace(dag, currents=tuple(currents))
+
+    _projected, certificate = project_rectangular_dynamic_color_classes(
+        separated,
+        model,
+    )
+
+    assert certificate.old_to_new_current_ids[2] != (
+        certificate.old_to_new_current_ids[3]
+    )
diff --git a/pyamplicol/tests/unit/test_dag_model_independence.py b/pyamplicol/tests/unit/test_dag_model_independence.py
new file mode 100644
index 0000000000..5ae498da75
--- /dev/null
+++ b/pyamplicol/tests/unit/test_dag_model_independence.py
@@ -0,0 +1,529 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from itertools import permutations
+
+import pytest
+
+import pyamplicol.generation.dag_compiler as dag_compiler_module
+from pyamplicol.color.plan import GenericColorPlan, LCColorSector, build_color_plan
+from pyamplicol.generation.dag_algorithms import (
+    prune_global_helicity_flip_equivalent_roots,
+)
+from pyamplicol.generation.dag_color import ColorEngine
+from pyamplicol.generation.dag_ordering import (
+    _canonical_sink_mask,
+    _lc_color_order_reachable_masks,
+    _ordered_combination_segment,
+    _shared_single_trace_closure_matches_word,
+)
+from pyamplicol.generation.dag_types import ColorState, CurrentIndex
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.base import Model, Particle, Vertex
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.processes.ir import (
+    CanonicalProcessIR,
+    ColorEndpointSummary,
+    ProcessLegIR,
+)
+
+
+class _StructuralModel(Model):
+    def __init__(
+        self,
+        *,
+        particles: Iterable[Particle],
+        representations: Mapping[int, int],
+        fermions: Iterable[int] = (),
+        massless_adjoint_vectors: Iterable[int] | None = (),
+        vertices: Iterable[Vertex] = (),
+        auxiliary_kinds: Mapping[int, str] | None = None,
+        trace_reflection_proven: bool = False,
+        single_trace_basis_proven: bool = False,
+    ) -> None:
+        particle_tuple = tuple(particles)
+        super().__init__(
+            name="relabeled-structural-model",
+            particles={particle.pdg: particle for particle in particle_tuple},
+            vertices=tuple(vertices),
+        )
+        self._representations = dict(representations)
+        self._fermions = frozenset(fermions)
+        self._massless_adjoint_vectors = (
+            None
+            if massless_adjoint_vectors is None
+            else frozenset(massless_adjoint_vectors)
+        )
+        self._auxiliary_kinds = dict(auxiliary_kinds or {})
+        self._trace_reflection_proven = bool(trace_reflection_proven)
+        self._single_trace_basis_proven = bool(single_trace_basis_proven)
+
+    def color_rep(self, pdg: int) -> int:
+        return self._representations[int(pdg)]
+
+    def is_fermion(self, pdg: int) -> bool:
+        return int(pdg) in self._fermions
+
+    def is_massless_adjoint_vector(self, pdg: int) -> bool:
+        if self._massless_adjoint_vectors is None:
+            raise NotImplementedError("adjoint-vector role is not proven")
+        return int(pdg) in self._massless_adjoint_vectors
+
+    def auxiliary_kind(self, particle_id: int) -> str | None:
+        return self._auxiliary_kinds.get(int(particle_id))
+
+    def lc_trace_reflection_equivalence_is_proven(self, process: object) -> bool:
+        del process
+        return self._trace_reflection_proven
+
+    def shared_single_trace_color_basis_is_proven(self, process: object) -> bool:
+        del process
+        return self._single_trace_basis_proven
+
+
+def _process(
+    pdgs: tuple[int, ...],
+    *,
+    statistics: tuple[str, ...] | None = None,
+    wavefunction_families: tuple[str, ...] | None = None,
+    color_roles: tuple[str, ...] | None = None,
+    source_orientations: tuple[str, ...] | None = None,
+    color_accuracy: str = "lc",
+) -> CanonicalProcessIR:
+    names = tuple(f"state_{index}" for index in range(1, len(pdgs) + 1))
+    statistics = statistics or ("boson",) * len(pdgs)
+    wavefunction_families = wavefunction_families or ("scalar",) * len(pdgs)
+    color_roles = color_roles or ("singlet",) * len(pdgs)
+    source_orientations = source_orientations or ("self-conjugate",) * len(pdgs)
+    legs = tuple(
+        ProcessLegIR(
+            label=index,
+            side="initial" if index <= 2 else "final",
+            particle=names[index - 1],
+            outgoing_particle=names[index - 1],
+            pdg=pdg,
+            outgoing_pdg=pdg,
+            statistics=statistics[index - 1],
+            wavefunction_family=wavefunction_families[index - 1],
+            color_role=color_roles[index - 1],
+            source_orientation=source_orientations[index - 1],
+        )
+        for index, pdg in enumerate(pdgs, start=1)
+    )
+    return CanonicalProcessIR(
+        process=f"{' '.join(names[:2])} > {' '.join(names[2:])}",
+        key="relabeled_process",
+        color_accuracy=color_accuracy,
+        legs=legs,
+        color_endpoints=ColorEndpointSummary(
+            fundamental_count=color_roles.count("fundamental"),
+            antifundamental_count=color_roles.count("antifundamental"),
+            pair_count=min(
+                color_roles.count("fundamental"),
+                color_roles.count("antifundamental"),
+            ),
+        ),
+    )
+
+
+def _single_trace_plan(process: CanonicalProcessIR) -> GenericColorPlan:
+    return GenericColorPlan(
+        process=process,
+        color_accuracy=process.color_accuracy,
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=tuple(leg.label for leg in process.legs),
+            ),
+        ),
+    )
+
+
+def _adjoint_index(
+    labels: tuple[int, ...],
+    *,
+    ordered: tuple[int, ...],
+    accuracy: str = "full",
+) -> CurrentIndex:
+    mask = sum(1 << (label - 1) for label in labels)
+    return CurrentIndex(
+        particle_id=21,
+        external_mask=mask,
+        external_labels=tuple(sorted(labels)),
+        ordered_external_labels=ordered,
+        helicity_ancestry=mask,
+        chirality=0,
+        spin_state=0,
+        flavour_flow=(),
+        quantum_number_flow=(),
+        color_state=ColorState(
+            accuracy=accuracy,
+            sector_id=0,
+            line_groups=(0,),
+        ),
+        momentum_mask=mask,
+    )
+
+
+def test_sink_selection_uses_model_fermion_statistics_not_process_metadata() -> None:
+    scalar = 710_001
+    fermion = 810_001
+    model = _StructuralModel(
+        particles=(
+            Particle(scalar, scalar, spin=1, dimension=1, color_rep=1),
+            Particle(fermion, -fermion, spin=2, dimension=4, color_rep=1),
+        ),
+        representations={scalar: 1, fermion: 1, -fermion: 1},
+        fermions=(fermion, -fermion),
+    )
+    process = _process(
+        (scalar, fermion, scalar),
+        statistics=("fermion", "boson", "boson"),
+    )
+
+    assert _canonical_sink_mask(process, model) == 1 << 1
+
+
+def test_relabelled_adjoint_symmetry_uses_model_role_and_fails_closed() -> None:
+    adjoint = 910_101
+    particle = Particle(adjoint, adjoint, spin=3, dimension=4, color_rep=8)
+    lc_process = _process(
+        (adjoint,) * 4,
+    )
+    full_process = _process(
+        (adjoint,) * 4,
+        color_accuracy="full",
+    )
+    proven_model = _StructuralModel(
+        particles=(particle,),
+        representations={adjoint: 8},
+        massless_adjoint_vectors=(adjoint,),
+        single_trace_basis_proven=True,
+    )
+
+    proven_engine = ColorEngine(
+        _single_trace_plan(lc_process),
+        proven_model,
+        shared_lc_all_ordering_symmetry=True,
+    )
+    proven_full_engine = ColorEngine(
+        _single_trace_plan(full_process),
+        proven_model,
+    )
+
+    assert proven_engine.shared_lc_orderings is True
+    assert proven_engine.shared_lc_fixed_sink_label == 4
+    assert proven_full_engine.shared_single_trace is True
+    assert (
+        _lc_color_order_reachable_masks(
+            lc_process,
+            _single_trace_plan(lc_process),
+            proven_model,
+        )
+        is not None
+    )
+
+    unproven_model = _StructuralModel(
+        particles=(particle,),
+        representations={adjoint: 8},
+        massless_adjoint_vectors=None,
+    )
+    unproven_engine = ColorEngine(
+        _single_trace_plan(lc_process),
+        unproven_model,
+        shared_lc_all_ordering_symmetry=True,
+    )
+    unproven_full_engine = ColorEngine(
+        _single_trace_plan(full_process),
+        unproven_model,
+    )
+
+    assert unproven_engine.shared_lc_orderings is True
+    assert unproven_engine.shared_lc_fixed_sink_label is None
+    assert unproven_full_engine.shared_single_trace is False
+    assert unproven_full_engine.shared_lc_orderings is False
+
+    role_only_model = _StructuralModel(
+        particles=(particle,),
+        representations={adjoint: 8},
+        massless_adjoint_vectors=(adjoint,),
+    )
+    role_only_full_engine = ColorEngine(
+        _single_trace_plan(full_process),
+        role_only_model,
+    )
+    assert role_only_full_engine.shared_single_trace is False
+    assert role_only_full_engine.shared_lc_orderings is False
+
+
+def test_shared_single_trace_indexes_match_word_scan_exactly() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("g g > g g", color_accuracy="full")
+    plan = build_color_plan(process, color_accuracy="full")
+    engine = ColorEngine(plan, model)
+    vertex = next(
+        vertex
+        for vertex in model.vertices
+        if vertex.particles == (21, 21, 21)
+    )
+    primary_words = tuple(
+        word for sector in plan.sectors for word in (sector.color_words or ())
+    )
+
+    for ordering in permutations((1, 2, 3, 4)):
+        for split in range(1, len(ordering)):
+            left_order = tuple(ordering[:split])
+            right_order = tuple(ordering[split:])
+            left = _adjoint_index(left_order, ordered=left_order)
+            right = _adjoint_index(right_order, ordered=right_order)
+            expected_segment = next(
+                (
+                    segment
+                    for word in primary_words
+                    for segment in (
+                        _ordered_combination_segment(
+                            left_order,
+                            right_order,
+                            word,
+                        ),
+                    )
+                    if segment is not None
+                ),
+                None,
+            )
+            assert (
+                engine.ordered_combination_labels(left, right, vertex)
+                == expected_segment
+            )
+
+            expected_allowed = any(
+                _shared_single_trace_closure_matches_word(
+                    left_order,
+                    right_order,
+                    word,
+                )
+                for word in primary_words
+            )
+            assert engine.ordered_closure_allowed(left, right) is expected_allowed
+            expected_sector_ids = tuple(
+                sector.id
+                for sector in plan.sectors
+                if any(
+                    _shared_single_trace_closure_matches_word(
+                        left_order,
+                        right_order,
+                        word,
+                    )
+                    for word in sector.admissible_traversal_words
+                )
+            )
+            actual_sector_ids = tuple(
+                flow.state.sector_id
+                for flow in engine.shared_single_trace_closure_flows(left, right)
+            )
+            assert actual_sector_ids == expected_sector_ids
+
+
+def test_color_order_mask_pruning_rejects_plan_roles_not_proven_by_model() -> None:
+    adjoint = 910_101
+    process = _process(
+        (adjoint,) * 4,
+    )
+    model = _StructuralModel(
+        particles=(Particle(adjoint, adjoint, spin=3, dimension=4, color_rep=8),),
+        representations={adjoint: 8},
+        massless_adjoint_vectors=(adjoint,),
+    )
+    mismatched_plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=(1, 2, 3),
+                singlet_labels=(4,),
+            ),
+        ),
+    )
+
+    assert _lc_color_order_reachable_masks(process, mismatched_plan, model) is None
+
+
+def test_relabelled_fundamental_line_auxiliary_requires_model_declaration() -> None:
+    fermion = 810_001
+    adjoint = 910_101
+    auxiliary = 770_001
+    auxiliary_vertex = Vertex(1, (fermion, -fermion, auxiliary))
+    model = _StructuralModel(
+        particles=(
+            Particle(fermion, -fermion, spin=2, dimension=4, color_rep=3),
+            Particle(adjoint, adjoint, spin=3, dimension=4, color_rep=8),
+            Particle(auxiliary, auxiliary, spin=-1, dimension=4, color_rep=1),
+        ),
+        representations={
+            fermion: 3,
+            -fermion: -3,
+            adjoint: 8,
+            auxiliary: 1,
+        },
+        fermions=(fermion, -fermion),
+        massless_adjoint_vectors=(adjoint,),
+        vertices=(auxiliary_vertex,),
+        auxiliary_kinds={auxiliary: "u1-subtraction-color-flow-vector"},
+    )
+    one_line_process = _process(
+        (-fermion, fermion, adjoint, adjoint),
+    )
+    two_line_process = _process(
+        (-fermion, fermion, fermion, -fermion),
+    )
+
+    one_line_engine = ColorEngine(
+        GenericColorPlan(one_line_process, "lc", ()),
+        model,
+    )
+    two_line_engine = ColorEngine(
+        GenericColorPlan(two_line_process, "lc", ()),
+        model,
+    )
+
+    assert one_line_engine._particle_has_colour(auxiliary) is True
+    assert one_line_engine.vertex_allowed(auxiliary_vertex) is False
+    assert two_line_engine.vertex_allowed(auxiliary_vertex) is True
+
+    unrelated_model = _StructuralModel(
+        particles=model.particles.values(),
+        representations=model._representations,
+        fermions=(fermion, -fermion),
+        massless_adjoint_vectors=(adjoint,),
+        vertices=(auxiliary_vertex,),
+        auxiliary_kinds={auxiliary: "ufo-contact:unrelated-vector"},
+    )
+    unrelated_engine = ColorEngine(
+        GenericColorPlan(one_line_process, "lc", ()),
+        unrelated_model,
+    )
+    assert unrelated_engine._particle_has_colour(auxiliary) is False
+
+
+def test_trace_reflection_folding_requires_model_proof() -> None:
+    adjoint = 910_101
+    process = _process(
+        (adjoint,) * 5,
+        wavefunction_families=("vector",) * 5,
+        color_roles=("adjoint",) * 5,
+    )
+    unfolded = build_color_plan(process)
+    folded = build_color_plan(process, fold_trace_reflections=True)
+
+    assert unfolded.trace_reflections_folded is False
+    assert folded.trace_reflections_folded is True
+    assert unfolded.sector_count == 24
+    assert folded.sector_count == 12
+
+
+def test_compiler_requires_trace_proof_for_all_adjoint_fixed_sink(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    observed: list[tuple[bool, int | None]] = []
+    color_engine_type = dag_compiler_module.ColorEngine
+
+    class RecordingColorEngine(color_engine_type):
+        def __init__(self, *args: object, **kwargs: object) -> None:
+            super().__init__(*args, **kwargs)
+            observed.append(
+                (
+                    self.shared_lc_all_ordering_symmetry,
+                    self.shared_lc_fixed_sink_label,
+                )
+            )
+
+    class UnprovenBuiltinModel(BuiltinSMModel):
+        def lc_trace_reflection_equivalence_is_proven(
+            self,
+            process: object,
+        ) -> bool:
+            del process
+            return False
+
+    monkeypatch.setattr(
+        dag_compiler_module,
+        "ColorEngine",
+        RecordingColorEngine,
+    )
+    process = build_process_ir("g g > g g")
+
+    dag_compiler_module.compile_generic_dag(
+        process,
+        model=UnprovenBuiltinModel(),
+    )
+    dag_compiler_module.compile_generic_dag(
+        process,
+        model=BuiltinSMModel(),
+    )
+
+    assert observed == [(False, None), (True, 4)]
+
+
+def test_pure_adjoint_helicity_zero_pruning_requires_its_own_model_proof() -> None:
+    class ParityOnlyBuiltinModel(BuiltinSMModel):
+        def pure_massless_adjoint_helicity_zero_rule_is_proven(
+            self,
+            process: object,
+            vertices: Iterable[Vertex],
+        ) -> bool:
+            del process, vertices
+            return False
+
+    process = build_process_ir("g g > g g")
+    dag = dag_compiler_module.compile_generic_dag(
+        process,
+        model=BuiltinSMModel(),
+    )
+
+    parity_only = prune_global_helicity_flip_equivalent_roots(
+        dag,
+        ParityOnlyBuiltinModel(),
+    )
+    proven = prune_global_helicity_flip_equivalent_roots(
+        dag,
+        BuiltinSMModel(),
+    )
+
+    assert len(parity_only.amplitude_roots) == 24
+    assert len(proven.amplitude_roots) == 9
+    assert sum(root.helicity_weight for root in parity_only.amplitude_roots) == 48.0
+    assert sum(root.helicity_weight for root in proven.amplitude_roots) == 18.0
+
+
+def test_builtin_sink_adjoint_and_color_auxiliary_behavior_is_preserved() -> None:
+    model = BuiltinSMModel()
+    leptonic_process = build_process_ir("e- e+ > mu- mu+")
+    gluon_process = build_process_ir("g g > g g")
+    gluon_engine = ColorEngine(
+        build_color_plan(gluon_process),
+        model,
+        shared_lc_all_ordering_symmetry=True,
+    )
+    full_gluon_process = build_process_ir("g g > g g", color_accuracy="full")
+    full_gluon_engine = ColorEngine(
+        build_color_plan(full_gluon_process, color_accuracy="full"),
+        model,
+    )
+    auxiliary_vertex = next(
+        vertex for vertex in model.vertices if vertex.particles == (1, -1, 99)
+    )
+    one_line_process = build_process_ir("d d~ > g g")
+    two_line_process = build_process_ir("d d~ > d d~")
+    one_line_engine = ColorEngine(build_color_plan(one_line_process), model)
+    two_line_engine = ColorEngine(build_color_plan(two_line_process), model)
+
+    assert _canonical_sink_mask(leptonic_process, model) == 1
+    assert gluon_engine.shared_lc_fixed_sink_label == 4
+    assert full_gluon_engine.shared_single_trace is True
+    assert one_line_engine._particle_has_colour(99) is True
+    assert one_line_engine.vertex_allowed(auxiliary_vertex) is False
+    assert two_line_engine.vertex_allowed(auxiliary_vertex) is True
diff --git a/pyamplicol/tests/unit/test_dependency_gate.py b/pyamplicol/tests/unit/test_dependency_gate.py
new file mode 100644
index 0000000000..1b00b0728f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_dependency_gate.py
@@ -0,0 +1,327 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import copy
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools" / "release" / "check_dependencies.py"
+
+
+def _module():
+    spec = importlib.util.spec_from_file_location("dependency_gate", SCRIPT)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_release_gate_accepts_canonical_published_cargo_inputs() -> None:
+    module = _module()
+    assert module.check(candidate=False) == []
+
+
+@pytest.fixture
+def published_cargo(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    module = _module()
+    release = module._load_lock()
+    symjit = release["symjit"]
+    symbolica = release["symbolica"]
+    (tmp_path / "Cargo.toml").write_text(
+        "[workspace.dependencies]\n"
+        f'symbolica = {{ version = "={symbolica["rust_version"]}" }}\n',
+        encoding="utf-8",
+    )
+    core = tmp_path / "rust/crates/rusticol-core/Cargo.toml"
+    core.parent.mkdir(parents=True)
+    core.write_text(
+        "[dependencies]\n"
+        f'symbolica = {{ version = "={symbolica["rust_version"]}" }}\n'
+        f'symjit = {{ version = "={symjit["version"]}" }}\n',
+        encoding="utf-8",
+    )
+    cargo_lock = tmp_path / "Cargo.lock"
+    cargo_lock.write_text(
+        'version = 4\n[[package]]\nname = "symbolica"\n'
+        f'version = "{symbolica["rust_version"]}"\n'
+        f'source = "{module._REGISTRY_SOURCE}"\nchecksum = "{"0" * 64}"\n'
+        '[[package]]\nname = "symjit"\n'
+        f'version = "{symjit["version"]}"\n'
+        f'source = "{module._REGISTRY_SOURCE}"\nchecksum = "{"1" * 64}"\n',
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(module, "ROOT", tmp_path)
+    monkeypatch.setattr(module, "CARGO_LOCK_PATH", cargo_lock)
+    return module
+
+
+def test_release_contract_is_lean_exact_and_schema_8() -> None:
+    module = _module()
+    lock = module._load_lock()
+    assert lock["abis"]["compiled_model"] == 9
+    assert "python_runtime_lock" not in lock
+    assert "legal_status" not in lock
+    assert module._locked_python_dependencies(lock) == (
+        module._project_python_dependencies()
+    )
+    assert set(lock["symbolica"]) == {
+        "python_distribution",
+        "python_version",
+        "rust_crate",
+        "rust_version",
+        "serialization_abi",
+    }
+    assert lock["symjit"] == {"version": "2.26.4"}
+    assert set(lock["ufo_model_loader"]) == {
+        "python_distribution",
+        "required_version",
+    }
+
+
+def test_release_cargo_lock_accepts_registry_crates_including_symjit(
+    published_cargo,
+) -> None:
+    assert (
+        published_cargo._release_cargo_lock_issues(published_cargo._load_lock()) == []
+    )
+
+
+def test_release_toolchain_and_manylinux_image_are_exactly_pinned() -> None:
+    module = _module()
+    assert module._toolchain_issues(module._load_lock()) == []
+
+
+def test_release_cargo_lock_rejects_candidate_path_resolution(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    published_cargo,
+) -> None:
+    module = published_cargo
+    contaminated = tmp_path / "Cargo.lock"
+    text = module.CARGO_LOCK_PATH.read_text(encoding="utf-8")
+    marker = (
+        'name = "symbolica"\n'
+        f'version = "{module._load_lock()["symbolica"]["rust_version"]}"\n'
+        'source = "registry+https://github.com/rust-lang/crates.io-index"\n'
+    )
+    assert marker in text
+    contaminated.write_text(text.replace(marker, marker.rsplit("source", 1)[0], 1))
+    monkeypatch.setattr(module, "CARGO_LOCK_PATH", contaminated)
+    codes = {
+        issue.code for issue in module._release_cargo_lock_issues(module._load_lock())
+    }
+    assert codes == {
+        "release-cargo-nonregistry",
+        "release-cargo-pin",
+    }
+
+
+def test_candidate_gate_fails_closed_before_contributor_install(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    monkeypatch.setattr(module, "STATE_PATH", tmp_path / "install-state.json")
+    monkeypatch.setattr(module, "CANDIDATE_LOCK_PATH", tmp_path / "Cargo.lock")
+    monkeypatch.setattr(module, "CARGO_CONFIG_PATH", tmp_path / "config.toml")
+    codes = {issue.code for issue in module.check(candidate=True)}
+    assert "candidate-input-missing" in codes
+    assert "symbolica-unverified" not in codes
+
+
+def test_candidate_gate_uses_candidate_not_publication_cargo_resolution(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    publication_issue = module.GateIssue("release-cargo-patch", "local override")
+    monkeypatch.setattr(module, "_release_contract_issues", lambda lock: [])
+    monkeypatch.setattr(module, "_toolchain_issues", lambda lock: [])
+    monkeypatch.setattr(module, "_candidate_issues", lambda lock: [])
+    monkeypatch.setattr(
+        module, "_release_cargo_lock_issues", lambda lock: [publication_issue]
+    )
+
+    assert module.check(candidate=True) == []
+    assert module.check(candidate=False) == [publication_issue]
+
+
+@pytest.mark.parametrize("local_overrides", (False, True))
+def test_candidate_gate_uses_compact_exact_git_sources_and_rlib_manifest(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    local_overrides: bool,
+) -> None:
+    module = _module()
+    release = module._load_lock()
+    contributor = module._load_contributor_lock()
+    expected = module._candidate_sources(contributor, release)
+    dependencies = tmp_path / "dependencies"
+    contributor_path = dependencies / "contributor-lock.toml"
+    state_path = dependencies / "install-state.json"
+    candidate_lock = dependencies / "candidate-Cargo.lock"
+    cargo_config = dependencies / "candidate-cargo-config.toml"
+    checkouts = dependencies / "checkouts"
+    contributor_path.parent.mkdir(parents=True)
+    contributor_path.write_bytes(module.CONTRIBUTOR_LOCK_PATH.read_bytes())
+    source_paths = {name: checkouts / name for name in expected}
+    if local_overrides:
+        source_paths.update(
+            {
+                "symjit": tmp_path / "local-symjit",
+                "gammaloop": tmp_path / "local-gammaloop",
+                "symbolica-integrate": tmp_path / "local-integrate",
+            }
+        )
+    for path in source_paths.values():
+        path.mkdir(parents=True)
+    for name in ("graphica", "numerica"):
+        (checkouts / "symbolica" / "lib" / name).mkdir(parents=True)
+    (source_paths["symjit"] / "Cargo.toml").write_text(
+        '[package]\nname = "symjit"\n'
+        f'version = "{contributor["symjit"]["candidate_version"]}"\n\n'
+        '[lib]\ncrate-type = ["rlib"]\n',
+        encoding="utf-8",
+    )
+    compact_state = {
+        "schema_version": 1,
+        "publishable": False,
+        "sources": {
+            name: {"url": url, "revision": revision}
+            for name, (url, revision) in expected.items()
+            if source_paths[name] == checkouts / name
+        },
+    }
+    state_path.write_text(json.dumps(compact_state), encoding="utf-8")
+    candidate_lock.write_text(
+        'version = 4\n\n[[package]]\nname = "rusticol-core"\nversion = "0.1.0"\n',
+        encoding="utf-8",
+    )
+    patches = {
+        "graphica": checkouts / "symbolica/lib/graphica",
+        "numerica": checkouts / "symbolica/lib/numerica",
+        "symbolica": checkouts / "symbolica",
+        "symjit": source_paths["symjit"],
+    }
+    overrides = {}
+    if local_overrides:
+        overrides = {
+            "symjit": source_paths["symjit"],
+            "spenso": source_paths["gammaloop"] / "crates/spenso",
+            "symbolica-integrate": source_paths["symbolica-integrate"],
+        }
+        overrides["spenso"].mkdir(parents=True)
+        patches.update(overrides)
+    (tmp_path / "Cargo.toml").write_text(
+        "[patch.crates-io]\n"
+        + "".join(
+            f'{name} = {{ path = "{path}" }}\n' for name, path in overrides.items()
+        ),
+        encoding="utf-8",
+    )
+    config_text = "[patch.crates-io]\n" + "".join(
+        f'{name} = {{ path = "{path}" }}\n' for name, path in patches.items()
+    )
+    cargo_config.write_text(config_text, encoding="utf-8")
+    monkeypatch.setattr(module, "ROOT", tmp_path)
+    monkeypatch.setattr(module, "CONTRIBUTOR_LOCK_PATH", contributor_path)
+    monkeypatch.setattr(module, "STATE_PATH", state_path)
+    monkeypatch.setattr(module, "CANDIDATE_LOCK_PATH", candidate_lock)
+    monkeypatch.setattr(module, "CARGO_CONFIG_PATH", cargo_config)
+    monkeypatch.setattr(module, "CHECKOUTS_PATH", checkouts)
+    revisions = {
+        source_paths[name]: revision for name, (_, revision) in expected.items()
+    }
+    monkeypatch.setattr(module, "_git_head", revisions.get)
+
+    assert module._candidate_issues(release) == []
+
+    monkeypatch.setattr(module, "_git_head", lambda path: "0" * 40)
+    assert "candidate-source-revision" in {
+        issue.code for issue in module._candidate_issues(release)
+    }
+    monkeypatch.setattr(module, "_git_head", revisions.get)
+
+    cargo_config.write_text(
+        config_text.replace(str(source_paths["symjit"]), str(tmp_path / "undeclared")),
+        encoding="utf-8",
+    )
+    assert "candidate-cargo-config" in {
+        issue.code for issue in module._candidate_issues(release)
+    }
+    cargo_config.write_text(config_text, encoding="utf-8")
+
+    heavy_state = copy.deepcopy(compact_state)
+    heavy_state["sources"]["symbolica"]["worktree_sha256"] = "0" * 64
+    state_path.write_text(json.dumps(heavy_state), encoding="utf-8")
+    assert "candidate-state-invalid" in {
+        issue.code for issue in module._candidate_issues(release)
+    }
+
+    state_path.write_text(json.dumps(compact_state), encoding="utf-8")
+    patch_root = dependencies / "patches" / "symjit"
+    patch_root.mkdir(parents=True)
+    (patch_root / "legacy.patch").write_text("obsolete\n", encoding="utf-8")
+    assert "candidate-symjit-patch" in {
+        issue.code for issue in module._candidate_issues(release)
+    }
+
+    (source_paths["symjit"] / "Cargo.toml").write_text(
+        '[package]\nname = "symjit"\n'
+        f'version = "{contributor["symjit"]["candidate_version"]}"\n\n'
+        '[lib]\ncrate-type = ["rlib", "cdylib"]\n',
+        encoding="utf-8",
+    )
+    assert "candidate-symjit-manifest" in {
+        issue.code for issue in module._candidate_issues(release)
+    }
+
+
+def test_release_contract_rejects_symjit_git_source_metadata() -> None:
+    module = _module()
+    release = copy.deepcopy(module._load_lock())
+    release["symjit"]["repository"] = (
+        "https://github.com/ValentinHirschi/symjit_crate_changes_for_pyamplicol.git"
+    )
+
+    assert "release-lock-scope" in {
+        issue.code for issue in module._release_contract_issues(release)
+    }
+
+
+def test_release_contract_pins_symjit_plane_application_abi() -> None:
+    module = _module()
+    release = module._load_lock()
+
+    assert not {
+        issue.code
+        for issue in module._release_contract_issues(release)
+        if issue.code == "release-abi-contract"
+    }
+
+    missing = copy.deepcopy(release)
+    del missing["abis"]["symjit_plane_application"]
+    assert "release-abi-contract" in {
+        issue.code for issue in module._release_contract_issues(missing)
+    }
+
+    wrong = copy.deepcopy(release)
+    wrong["abis"]["symjit_plane_application"] = "wrong"
+    assert "release-abi-contract" in {
+        issue.code for issue in module._release_contract_issues(wrong)
+    }
+
+
+def test_release_gate_has_no_live_package_or_repository_preflight() -> None:
+    module = _module()
+    source = SCRIPT.read_text(encoding="utf-8")
+    assert not hasattr(module, "_published_dependency_issues")
+    assert "urllib.request" not in source
+    assert "pypi.org/pypi/" not in source
+    assert "crates.io/api/" not in source
diff --git a/pyamplicol/tests/unit/test_dependency_installer.py b/pyamplicol/tests/unit/test_dependency_installer.py
new file mode 100644
index 0000000000..62af692c57
--- /dev/null
+++ b/pyamplicol/tests/unit/test_dependency_installer.py
@@ -0,0 +1,1385 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import io
+import os
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "dependencies" / "install_dependencies.py"
+
+
+def _module():
+    spec = importlib.util.spec_from_file_location("dependency_installer", SCRIPT)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_source_inventory_is_exact_and_profiling_references_are_optional(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    checkouts = tmp_path / "dependencies" / "checkouts"
+    checkouts.mkdir(parents=True)
+    monkeypatch.setattr(module, "CHECKOUTS", checkouts)
+    payload = module._lock()
+    without_references = module._sources(
+        payload,
+        with_legacy=False,
+        with_reference_fft=False,
+    )
+    with_references = module._sources(
+        payload,
+        with_legacy=True,
+        with_reference_fft=True,
+    )
+
+    assert {item.key for item in without_references} == {
+        "symjit",
+        "symbolica",
+        "symbolica-community",
+        "symbolica-integrate",
+        "gammaloop",
+        "ratatui-ffi",
+        "ufo-model-loader",
+    }
+    assert {item.key for item in with_references} == {
+        *(item.key for item in without_references),
+        "legacy-amplicol",
+        "reference-fft",
+    }
+    assert all(len(item.revision) == 40 for item in with_references)
+    assert module._root_path_patches() == {}
+    assert module._managed_symjit_checkout() == module.CHECKOUTS / "symjit"
+    legacy = next(item for item in with_references if item.key == "legacy-amplicol")
+    assert legacy.branch == payload["legacy_amplicol"]["branch"]
+    assert legacy.revision == payload["legacy_amplicol"]["revision"]
+    reference = next(item for item in with_references if item.key == "reference-fft")
+    assert reference.url == (
+        "https://github.com/rikkert-frederix/AllGluonsMultipletFFT.git"
+    )
+    assert reference.branch == "main"
+    assert reference.revision == "9c3cb4fb4658200884553bab796e85bd5e7fe7a9"
+
+
+def test_profiling_references_require_explicit_cli_opt_in() -> None:
+    module = _module()
+    parser = module._parser()
+
+    defaults = parser.parse_args([])
+    assert defaults.candidate is False
+    assert defaults.loader_wheel is None
+    assert defaults.with_legacy_amplicol is False
+    assert defaults.with_reference_fft is False
+
+    selected = parser.parse_args(["--with-legacy-amplicol", "--with-reference-fft"])
+    assert selected.with_legacy_amplicol is True
+    assert selected.with_reference_fft is True
+    help_text = parser.format_help()
+    assert "--with-legacy-amplicol" in help_text
+    assert "--with-reference-fft" in help_text
+    assert "--without-legacy-amplicol" not in help_text
+    assert "--without-reference-fft" not in help_text
+
+
+def test_published_sources_retain_dashboard_and_optional_references() -> None:
+    module = _module()
+    payload = module._lock()
+    sources = module._developer_sources(
+        payload, with_legacy=False, with_reference_fft=False
+    )
+    assert len(sources) == 1
+    assert sources[0].key == "ratatui-ffi"
+    assert sources[0].url == payload["ratatui"]["ffi_repository"]
+    assert sources[0].revision == payload["ratatui"]["ffi_revision"]
+    assert {
+        source.key
+        for source in module._developer_sources(
+            payload, with_legacy=True, with_reference_fft=True
+        )
+    } == {"ratatui-ffi", "legacy-amplicol", "reference-fft"}
+
+
+@pytest.mark.parametrize("candidate", [False, True])
+def test_installer_wires_only_explicit_reference_opt_ins(
+    monkeypatch: pytest.MonkeyPatch,
+    candidate: bool,
+) -> None:
+    module = _module()
+    selections: list[dict[str, bool]] = []
+    profiling_extras: list[bool] = []
+    monkeypatch.setattr(module, "_lock", lambda: {})
+
+    def sources(_payload, **selection):
+        selections.append(selection)
+        return ()
+
+    monkeypatch.setattr(module, "_sources", sources)
+    monkeypatch.setattr(module, "_developer_sources", sources)
+    for name in (
+        "_ensure_just",
+        "_configure_sources",
+        "_write_cargo_config",
+        "_write_candidate_lock",
+        "_write_state",
+    ):
+        monkeypatch.setattr(module, name, lambda *_args, **_kwargs: None)
+    monkeypatch.setattr(
+        module,
+        "_ensure_venv",
+        lambda *_args, **kwargs: profiling_extras.append(kwargs["with_fft_profiling"]),
+    )
+
+    arguments = ["--dry-run", "--no-build", *(["--candidate"] if candidate else [])]
+    assert module.main(arguments) == 0
+    assert module.main([*arguments, "--with-legacy-amplicol"]) == 0
+    assert module.main([*arguments, "--with-reference-fft"]) == 0
+    assert (
+        module.main(
+            [
+                *arguments,
+                "--with-legacy-amplicol",
+                "--with-reference-fft",
+            ]
+        )
+        == 0
+    )
+    assert selections == [
+        {"with_legacy": False, "with_reference_fft": False},
+        {"with_legacy": True, "with_reference_fft": False},
+        {"with_legacy": False, "with_reference_fft": True},
+        {"with_legacy": True, "with_reference_fft": True},
+    ]
+    assert profiling_extras == [False, True, True, True]
+
+
+def test_ratatui_distribution_and_ffi_source_are_exactly_pinned() -> None:
+    module = _module()
+    ratatui = module._lock()["ratatui"]
+
+    assert ratatui["distribution"] == "ratatui"
+    assert ratatui["version"] == "0.4.2"
+    assert ratatui["sdist_sha256"] == (
+        "2778b066378f8e1629b4b5e1076f1957c8c439b45cdeaf51970d1949730bb0d5"
+    )
+    assert ratatui["ffi_revision"] == ("7249c0bd1445c0c6ee76f3f24923eb35a1d931e0")
+    ffi_source = next(
+        source
+        for source in module._sources(
+            module._lock(),
+            with_legacy=False,
+            with_reference_fft=False,
+        )
+        if source.key == "ratatui-ffi"
+    )
+    assert ffi_source.url == ratatui["ffi_repository"]
+    assert ffi_source.revision == ratatui["ffi_revision"]
+
+
+def test_ufo_loader_distinguishes_required_and_latest_published_versions() -> None:
+    module = _module()
+    payload = module._lock()
+    loader = payload["ufo_model_loader"]
+    assert loader["required_version"] == "1.0.0"
+    assert loader["latest_verified_published_version"] == "0.1.8"
+    assert loader["published_revision"] == ("f5a9f8d2eaff76b99629fc3143952ca4f2425d55")
+    assert loader["wheel_sha256"] == (
+        "b253942f0a356eacd5fd68b104cacf11039c2391a9ee963107f674fad54f01ef"
+    )
+    assert loader["release_status"] == "verified"
+    assert loader["source_url"] == "https://github.com/alphal00p/ufo_model_loader.git"
+    assert loader["candidate_revision"] == "70ddee6b416f8c8b340e0d087646d77095c5d24b"
+    assert "patches" not in payload
+
+
+def test_legacy_oracle_uses_the_pinned_remote_branch_without_local_patches() -> None:
+    module = _module()
+    payload = module._lock()
+    assert "patches" not in payload
+    assert not tuple(
+        (module.DEPENDENCIES / "patches" / "legacy-amplicol").glob("*.patch")
+    )
+
+
+def test_venv_reset_bootstraps_with_the_unmoved_base_interpreter(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    base_python = tmp_path / "base-python"
+    active_venv_python = tmp_path / ".venv" / "bin" / "python"
+    monkeypatch.setattr(module.sys, "_base_executable", str(base_python))
+    monkeypatch.setattr(module.sys, "executable", str(active_venv_python))
+
+    assert module._venv_bootstrap_python() == base_python
+
+
+def test_local_source_overrides_replace_managed_dependency_clones(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    overrides = {
+        "symjit": ROOT / "TMP_FIXED_SYMJIT",
+        "spenso": ROOT / "TMP_FIXED_SPENSO/crates/spenso",
+        "symbolica-integrate": ROOT / "TMP_FIXED_SPENSO/symbolica-integrate",
+    }
+    monkeypatch.setattr(module, "_root_path_patches", lambda: overrides)
+    payload = module._lock()
+    symjit = payload["symjit"]
+
+    assert symjit == {
+        **module._release_lock()["symjit"],
+        **module._contributor_lock()["symjit"],
+    }
+    sources = {
+        item.key
+        for item in module._sources(
+            payload,
+            with_legacy=False,
+            with_reference_fft=False,
+        )
+    }
+    assert not {"symjit", "gammaloop", "symbolica-integrate"} & sources
+    overrides = module._root_path_patches()
+    assert module._managed_symjit_checkout() == ROOT / "TMP_FIXED_SYMJIT"
+    assert overrides["spenso"] == ROOT / "TMP_FIXED_SPENSO/crates/spenso"
+    assert (
+        overrides["symbolica-integrate"]
+        == ROOT / "TMP_FIXED_SPENSO/symbolica-integrate"
+    )
+    assert "patches" not in payload
+    assert not tuple((module.DEPENDENCIES / "patches" / "symjit").rglob("*.patch"))
+
+
+def test_managed_sources_remain_available_without_explicit_path_overrides(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    monkeypatch.setattr(module, "_root_path_patches", dict)
+    sources = {
+        source.key: source
+        for source in module._sources(
+            module._lock(), with_legacy=False, with_reference_fft=False
+        )
+    }
+    assert (
+        sources["symjit"].revision == module._contributor_lock()["symjit"]["revision"]
+    )
+    assert (
+        sources["ufo-model-loader"].revision
+        == (module._contributor_lock()["ufo_model_loader"]["candidate_revision"])
+    )
+    contributor = module._contributor_lock()
+    assert sources["gammaloop"].branch == contributor["gammaloop_candidate"]["branch"]
+    assert (
+        sources["gammaloop"].revision == contributor["gammaloop_candidate"]["revision"]
+    )
+    assert (
+        sources["symbolica-integrate"].revision
+        == contributor["symbolica_integrate"]["revision"]
+    )
+
+
+def test_community_wiring_preserves_dependency_sources(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    project = tmp_path / "project"
+    checkouts = project / "dependencies/checkouts"
+    community = checkouts / "symbolica-community"
+    (community / "example_extension").mkdir(parents=True)
+    (community / "Cargo.toml").write_text(
+        '[package]\nname = "symbolica_community"\nversion = "3.0.0"\n'
+        '[features]\ndefault = ["module", "native"]\n'
+        'module = ["pyo3/abi3", "symbolica/python_abi3"]\n'
+        'native = ["symbolica/default", "idenso/native", "spynso3/native"]\n'
+        '[dependencies]\nsymbolica = "3.0"\n'
+        "[target.'cfg(not(target_arch = \"wasm32\"))'.dependencies]\n"
+        'vakint = { git = "https://github.com/alphal00p/gammaloop", '
+        'branch = "main" }\n',
+        encoding="utf-8",
+    )
+    (community / "example_extension/Cargo.toml").write_text(
+        '[dependencies]\nsymbolica = { version = "3.0", default-features = false }\n',
+        encoding="utf-8",
+    )
+    symjit = project / "TMP_FIXED_SYMJIT"
+    symjit.mkdir()
+    (symjit / "Cargo.toml").write_text(
+        '[package]\nname = "symjit"\n'
+        f'version = "{module._contributor_lock()["symjit"]["candidate_version"]}"\n'
+        '[lib]\ncrate-type = ["rlib"]\n',
+        encoding="utf-8",
+    )
+    symbolica = checkouts / "symbolica"
+    symbolica.mkdir()
+    original = b"unchanged upstream dependency manifest and source\n"
+    (symbolica / "Cargo.toml").write_bytes(original)
+    (symbolica / "source.rs").write_bytes(original)
+    spenso = project / "TMP_FIXED_SPENSO/crates/spenso"
+    spenso.mkdir(parents=True)
+    (spenso / "Cargo.toml").write_bytes(original)
+    (spenso / "source.rs").write_bytes(original)
+    overrides = {"symjit": symjit, "spenso": spenso}
+    monkeypatch.setattr(module, "CHECKOUTS", checkouts)
+    monkeypatch.setattr(module, "_root_path_patches", lambda: overrides)
+
+    module._configure_source_manifests(module.Runner(dry_run=False))
+
+    manifest = tomllib.loads((community / "Cargo.toml").read_text())
+    assert manifest["patch"]["crates-io"]["symjit"]["path"] == str(symjit)
+    assert manifest["patch"]["crates-io"]["spenso"]["path"] == str(spenso)
+    git_patch = manifest["patch"]["https://github.com/symbolica-dev/symbolica"]
+    assert git_patch["symbolica"]["path"] == str(symbolica)
+    assert "build-dependencies" not in manifest
+    assert manifest["features"]["default"] == ["module", "native"]
+    dependencies = manifest["dependencies"]
+    for dependency in (
+        "symbolica",
+        "idenso",
+        "spynso3",
+        "symbolica-integrate",
+        "example_extension",
+    ):
+        assert dependencies[dependency]["default-features"] is False
+    assert dependencies["symbolica-integrate"]["features"] == [
+        "compressed-step-metadata"
+    ]
+    assert "vakint" not in dependencies
+    assert "mimalloc" not in dependencies
+    native = manifest["target"]['cfg(not(target_arch = "wasm32"))']["dependencies"]
+    assert native["vakint"]["path"] == str(checkouts / "gammaloop/crates/vakint")
+    assert native["vakint"]["features"] == ["symbolica_community_module"]
+    assert native["mimalloc"]["package"] == "rustfs-mimalloc"
+    assert native["mimalloc"]["version"] == "0.5.4"
+    assert native["mimalloc"]["features"] == ["local_dynamic_tls"]
+    example = tomllib.loads((community / "example_extension/Cargo.toml").read_text())
+    assert example["dependencies"]["symbolica"]["default-features"] is False
+    for source in (symbolica, spenso):
+        assert (source / "Cargo.toml").read_bytes() == original
+        assert (source / "source.rs").read_bytes() == original
+
+
+def test_symjit_checkout_uses_exact_git_revision_and_accepts_matching_head(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    checkouts = tmp_path / "workspace" / "dependencies" / "checkouts"
+    monkeypatch.setattr(module, "CHECKOUTS", checkouts)
+    source = module.Source(
+        "symjit",
+        "https://github.com/siravan/symjit-crate.git",
+        "d8abfeeb4db98c13cdcf9dd39cf3e795fd5001a7",
+    )
+    calls: list[tuple[list[str], Path | None, bool]] = []
+
+    class FakeRunner:
+        dry_run = False
+
+        def run(self, command, *, cwd=None, capture=False, **_kwargs):
+            rendered = [str(item) for item in command]
+            calls.append((rendered, cwd, capture))
+            return subprocess.CompletedProcess(
+                command,
+                0,
+                source.revision + "\n" if rendered[1:] == ["rev-parse", "HEAD"] else "",
+                "",
+            )
+
+    module._checkout(FakeRunner(), source, update=False)
+    destination = checkouts / "symjit"
+    assert calls == [
+        (
+            [
+                "git",
+                "clone",
+                "--filter=blob:none",
+                "--no-checkout",
+                source.url,
+                str(destination),
+            ],
+            None,
+            False,
+        ),
+        (["git", "checkout", "--detach", source.revision], destination, False),
+    ]
+
+    destination.mkdir(parents=True)
+    (destination / ".git").mkdir()
+    calls.clear()
+    module._checkout(FakeRunner(), source, update=False)
+    assert calls == [(["git", "rev-parse", "HEAD"], destination, True)]
+
+
+def test_compact_install_state_records_only_git_sources(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    checkouts = tmp_path / "workspace" / "dependencies" / "checkouts"
+    state_path = checkouts.parent / "install-state.json"
+    sources = (
+        module.Source("symjit", "https://example.invalid/symjit.git", "1" * 40),
+        module.Source(
+            "legacy-amplicol",
+            "https://example.invalid/legacy.git",
+            "2" * 40,
+            "stable",
+        ),
+    )
+    for source in sources:
+        (checkouts / source.key).mkdir(parents=True)
+    monkeypatch.setattr(module, "CHECKOUTS", checkouts)
+    monkeypatch.setattr(module, "STATE", state_path)
+    monkeypatch.setattr(module, "_root_path_patches", lambda: {})
+
+    class FakeRunner:
+        dry_run = False
+
+        def run(self, command, *, cwd=None, capture=False, **_kwargs):
+            assert command == ["git", "rev-parse", "HEAD"]
+            assert cwd is not None and capture is True
+            revision = next(item.revision for item in sources if item.key == cwd.name)
+            return subprocess.CompletedProcess(command, 0, revision + "\n", "")
+
+    module._write_state(FakeRunner(), sources)
+
+    assert module.json.loads(state_path.read_text(encoding="utf-8")) == {
+        "schema_version": 1,
+        "publishable": False,
+        "sources": {
+            "symjit": {
+                "url": "https://example.invalid/symjit.git",
+                "revision": "1" * 40,
+            },
+            "legacy-amplicol": {
+                "url": "https://example.invalid/legacy.git",
+                "revision": "2" * 40,
+                "branch": "stable",
+            },
+        },
+    }
+
+
+def test_install_state_includes_selected_local_git_sources(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    state_path = tmp_path / "install-state.json"
+    paths = {
+        "symjit": tmp_path / "TMP_FIXED_SYMJIT",
+        "spenso": tmp_path / "TMP_FIXED_SPENSO" / "crates" / "spenso",
+        "symbolica-integrate": tmp_path / "TMP_FIXED_SPENSO" / "symbolica-integrate",
+    }
+    observed: list[Path] = []
+
+    def git_head(_runner, path):
+        observed.append(path)
+        return "a" * 40
+
+    monkeypatch.setattr(module, "STATE", state_path)
+    monkeypatch.setattr(module, "_root_path_patches", lambda: paths)
+    monkeypatch.setattr(module, "_git_head", git_head)
+    module._write_state(module.Runner(dry_run=False), ())
+    state = module.json.loads(state_path.read_text(encoding="utf-8"))
+    assert set(state["sources"]) == {"symjit", "gammaloop", "symbolica-integrate"}
+    assert observed == list(paths.values())
+    assert all(item["revision"] == "a" * 40 for item in state["sources"].values())
+    assert (
+        state["sources"]["gammaloop"]["branch"]
+        == (module._contributor_lock()["gammaloop_candidate"]["branch"])
+    )
+    assert state["publishable"] is False
+
+
+@pytest.mark.parametrize(
+    "checkout_name",
+    ("symbolica", "symbolica-community", "gammaloop"),
+)
+def test_non_symjit_checkout_symlink_outside_workspace_is_rejected_before_write(
+    checkout_name: str,
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    checkouts = tmp_path / "workspace" / "dependencies" / "checkouts"
+    checkouts.mkdir(parents=True)
+    outside = tmp_path / f"outside-{checkout_name}"
+    outside.mkdir()
+    marker = outside / "Cargo.toml"
+    marker.write_text("outside checkout must remain unchanged\n", encoding="utf-8")
+    (checkouts / checkout_name).symlink_to(outside, target_is_directory=True)
+    monkeypatch.setattr(module, "CHECKOUTS", checkouts)
+    source = module.Source(
+        checkout_name,
+        "https://example.invalid/source.git",
+        "1" * 40,
+    )
+    calls: list[list[str]] = []
+
+    class FakeRunner:
+        dry_run = False
+
+        def run(self, command, **_kwargs):
+            calls.append([str(item) for item in command])
+            return subprocess.CompletedProcess(command, 0, "", "")
+
+    runner = FakeRunner()
+    before = marker.read_bytes()
+    operations = (
+        lambda: module._checkout(runner, source, update=False),
+        lambda: module._configure_source_manifests(runner),
+    )
+
+    for operation in operations:
+        with pytest.raises(module.SetupError, match="must not be a symbolic link"):
+            operation()
+
+    assert calls == []
+    assert marker.read_bytes() == before
+    assert tuple(outside.iterdir()) == (marker,)
+
+
+def test_legacy_checkout_clones_the_named_branch_then_pins_its_commit(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    monkeypatch.setattr(module, "CHECKOUTS", tmp_path / "checkouts")
+    source = module.Source(
+        "legacy-amplicol",
+        "https://github.com/rikkert-frederix/AmpliCol.git",
+        "60443f327c2203cf92625da2bf0969c27e68a4ac",
+        "amplicol_with_patches",
+    )
+    calls: list[tuple[list[str], Path | None]] = []
+
+    class FakeRunner:
+        dry_run = False
+
+        def run(self, command, *, cwd=None, **_kwargs):
+            calls.append(([str(item) for item in command], cwd))
+            return subprocess.CompletedProcess(command, 0, "", "")
+
+    module._checkout(FakeRunner(), source, update=False)
+
+    assert calls == [
+        (
+            [
+                "git",
+                "clone",
+                "--filter=blob:none",
+                "--branch",
+                "amplicol_with_patches",
+                "--single-branch",
+                "--no-checkout",
+                "https://github.com/rikkert-frederix/AmpliCol.git",
+                str(source.path),
+            ],
+            None,
+        ),
+        (
+            [
+                "git",
+                "checkout",
+                "--detach",
+                "60443f327c2203cf92625da2bf0969c27e68a4ac",
+            ],
+            source.path,
+        ),
+    ]
+
+
+def test_checkout_update_migrates_origin_before_fetching(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    checkouts = tmp_path / "checkouts"
+    monkeypatch.setattr(module, "CHECKOUTS", checkouts)
+    source = module.Source(
+        "reference-fft",
+        "https://github.com/rikkert-frederix/AllGluonsMultipletFFT.git",
+        "9c3cb4fb4658200884553bab796e85bd5e7fe7a9",
+        "main",
+    )
+    destination = checkouts / source.key
+    (destination / ".git").mkdir(parents=True)
+    calls: list[tuple[list[str], Path | None, bool]] = []
+
+    class FakeRunner:
+        dry_run = False
+
+        def run(self, command, *, cwd=None, capture=False, **_kwargs):
+            rendered = [str(item) for item in command]
+            calls.append((rendered, cwd, capture))
+            stdout = "0" * 40 + "\n" if rendered[1:] == ["rev-parse", "HEAD"] else ""
+            return subprocess.CompletedProcess(command, 0, stdout, "")
+
+    module._checkout(FakeRunner(), source, update=True)
+
+    assert calls == [
+        (["git", "rev-parse", "HEAD"], destination, True),
+        (["git", "remote", "set-url", "origin", source.url], destination, False),
+        (["git", "fetch", "origin", "main"], destination, False),
+        (["git", "checkout", "--detach", source.revision], destination, False),
+    ]
+
+
+def test_contributor_runtime_requirements_use_the_full_hash_locked_closure() -> None:
+    module = _module()
+    requirements = module._runtime_requirements_text()
+    assert "symbolica==" not in requirements
+    assert "ufo-model-loader==" not in requirements
+    for requirement in (
+        "colorama==0.4.6",
+        "numpy==2.4.6",
+        "prettytable==3.18.0",
+        "progressbar2==4.6.0",
+        "python-utils==4.1.0",
+        "typing-extensions==4.16.0",
+        "wcwidth==0.9.1",
+    ):
+        assert requirements.count(requirement) == 1
+    assert requirements.count("--hash=sha256:") > 20
+
+
+def test_unpublished_ufo_loader_uses_managed_source_without_ignored_checkout(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    payload = module._lock()
+    monkeypatch.setattr(module, "ROOT", tmp_path)
+    monkeypatch.setattr(module, "CHECKOUTS", tmp_path / "dependencies/checkouts")
+    monkeypatch.setattr(module, "_root_path_patches", dict)
+    source = next(
+        source
+        for source in module._sources(
+            payload, with_legacy=False, with_reference_fft=False
+        )
+        if source.key == "ufo-model-loader"
+    )
+    assert source.path == tmp_path / "dependencies/checkouts/ufo-model-loader"
+    assert source.revision == payload["ufo_model_loader"]["candidate_revision"]
+    requirements = module._runtime_requirements_text()
+    assert "ufo-model-loader==" not in requirements
+    assert "numpy==2.4.6" in requirements
+
+
+def test_contributor_tools_reuse_project_build_test_and_docs_requirements() -> None:
+    module = _module()
+    with module.PYPROJECT.open("rb") as stream:
+        project_file = module.tomllib.load(stream)
+    project = project_file["project"]
+    optional = project["optional-dependencies"]
+    expected = tuple(
+        dict.fromkeys(
+            (
+                *project_file["build-system"]["requires"],
+                *optional["test"],
+                *optional["docs"],
+            )
+        )
+    )
+
+    requirements = module._contributor_python_requirements()
+
+    assert requirements == expected
+    assert requirements.count("maturin==1.15.0") == 1
+    assert "pypdf>=5,<6" in requirements
+
+    profiling_requirements = module._contributor_python_requirements(
+        with_fft_profiling=True
+    )
+    assert profiling_requirements == tuple(
+        dict.fromkeys((*expected, *optional["fft-profiling"]))
+    )
+    assert "matplotlib==3.11.2" in profiling_requirements
+    assert "reportlab==4.5.1" in profiling_requirements
+
+
+def test_candidate_dependency_only_build_installs_symbolica_and_managed_ufo_loader(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    venv = tmp_path / ".venv"
+    checkouts = tmp_path / "checkouts"
+    wheelhouse = tmp_path / "wheelhouse"
+    symbolica_wheels = wheelhouse / "symbolica"
+    symbolica_wheels.mkdir(parents=True)
+    previous_symbolica = symbolica_wheels / "symbolica-2.2.0-test.whl"
+    previous_symbolica.write_text("previous Symbolica wheel", encoding="utf-8")
+    wheel = symbolica_wheels / "symbolica-3.0.0-test.whl"
+    loader_wheels = wheelhouse / "ufo-model-loader"
+    loader_wheels.mkdir()
+    previous_loader = loader_wheels / "ufo_model_loader-0.1.7-py3-none-any.whl"
+    previous_loader.write_text("previous UFO loader wheel", encoding="utf-8")
+    loader_wheel = loader_wheels / "ufo_model_loader-0.1.8-py3-none-any.whl"
+    calls: list[tuple[list[str], Path | None, dict[str, str] | None]] = []
+
+    class FakeRunner:
+        dry_run = False
+
+        def run(self, command, *, cwd=None, env=None, **_kwargs):
+            rendered = [str(item) for item in command]
+            calls.append((rendered, cwd, env))
+            if rendered[1:4] == ["-m", "maturin", "build"]:
+                assert not list(symbolica_wheels.glob("*.whl"))
+                wheel.touch()
+            elif rendered[1:4] == ["-m", "pip", "wheel"]:
+                assert not list(loader_wheels.glob("*.whl"))
+                loader_wheel.touch()
+            return subprocess.CompletedProcess(rendered, 0, "", "")
+
+    monkeypatch.setattr(module, "ROOT", tmp_path)
+    monkeypatch.setattr(module, "TRASH", tmp_path / ".trash")
+    monkeypatch.setattr(module, "VENV", venv)
+    monkeypatch.setattr(module, "CHECKOUTS", checkouts)
+    monkeypatch.setattr(module, "WHEELHOUSE", wheelhouse)
+    ratatui_payloads: list[dict[str, object]] = []
+    monkeypatch.setattr(
+        module,
+        "_build_ratatui_wheel",
+        lambda _runner, payload: ratatui_payloads.append(payload),
+    )
+
+    payload: dict[str, object] = {"symbolica": {"candidate_version": "3.0.0"}}
+    module._build_candidate_dependency_wheels(
+        FakeRunner(),
+        payload,
+    )
+
+    python = str(venv / "bin" / "python")
+    assert calls[0][0][:4] == [python, "-m", "maturin", "build"]
+    assert calls[0][1] == checkouts / "symbolica-community"
+    assert calls[1][0] == [
+        python,
+        "-m",
+        "pip",
+        "install",
+        "--force-reinstall",
+        "--no-deps",
+        str(wheel),
+    ]
+    assert calls[2][0] == [
+        python,
+        "-m",
+        "pip",
+        "wheel",
+        "--no-deps",
+        "--wheel-dir",
+        str(loader_wheels),
+        str(checkouts / "ufo-model-loader"),
+    ]
+    assert calls[3][0] == [
+        python,
+        "-m",
+        "pip",
+        "install",
+        "--force-reinstall",
+        "--no-deps",
+        str(loader_wheel),
+    ]
+    probe, _, environment = calls[4]
+    assert probe[:3] == [python, "-I", "-c"]
+    assert probe[-1] == "3.0.0"
+    assert "from symbolica import Expression" in probe[3]
+    assert (
+        "from symbolica.community.tensor import TensorExpression, TensorNetwork"
+        in probe[3]
+    )
+    assert "TensorExpression.simplify_algebra" in probe[3]
+    assert "update coherent upstream pins" in probe[3]
+    assert "community.idenso" not in probe[3]
+    assert environment["SYMBOLICA_HIDE_BANNER"] == "1"
+    assert ratatui_payloads == [payload]
+    archived = {
+        path.name: path.read_text(encoding="utf-8")
+        for path in (tmp_path / ".trash").rglob("*.whl")
+    }
+    assert archived == {
+        previous_symbolica.name: "previous Symbolica wheel",
+        previous_loader.name: "previous UFO loader wheel",
+    }
+
+
+def test_ratatui_build_uses_verified_sdist_and_pinned_local_ffi(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    venv = tmp_path / ".venv"
+    checkouts = tmp_path / "checkouts"
+    wheelhouse = tmp_path / "wheelhouse"
+    ffi_source = checkouts / "ratatui-ffi"
+    ffi_source.mkdir(parents=True)
+    (ffi_source / "Cargo.toml").write_text(
+        '[package]\nname = "ratatui-ffi"\nversion = "0.1.0"\n',
+        encoding="utf-8",
+    )
+    sdist = wheelhouse / "ratatui" / "ratatui-0.4.2.tar.gz"
+    sdist.parent.mkdir(parents=True)
+    sdist.touch()
+    calls: list[tuple[list[str], dict[str, str] | None]] = []
+
+    class FakeRunner:
+        dry_run = False
+
+        def run(self, command, *, env=None, **_kwargs):
+            rendered = [str(item) for item in command]
+            calls.append((rendered, env))
+            if rendered[1:4] == ["-m", "pip", "wheel"]:
+                (wheelhouse / "ratatui" / "ratatui-0.4.2-test.whl").touch()
+            return subprocess.CompletedProcess(rendered, 0, "", "")
+
+    payload = {
+        "ratatui": {
+            "version": "0.4.2",
+            "ffi_revision": "7249c0bd1445c0c6ee76f3f24923eb35a1d931e0",
+        }
+    }
+    monkeypatch.setattr(module, "VENV", venv)
+    monkeypatch.setattr(module, "CHECKOUTS", checkouts)
+    monkeypatch.setattr(module, "WHEELHOUSE", wheelhouse)
+    monkeypatch.setattr(
+        module,
+        "_materialize_ratatui_sdist",
+        lambda _runner, _payload: sdist,
+    )
+    monkeypatch.setattr(module, "_archive_candidate_wheels", lambda *_args: None)
+
+    module._build_ratatui_wheel(FakeRunner(), payload)
+
+    build, build_environment = calls[0]
+    assert build == [
+        str(venv / "bin" / "python"),
+        "-m",
+        "pip",
+        "wheel",
+        "--no-deps",
+        "--no-build-isolation",
+        "--wheel-dir",
+        str(wheelhouse / "ratatui"),
+        str(sdist),
+    ]
+    assert build_environment is not None
+    assert Path(build_environment["RATATUI_FFI_SRC"]).name == "ratatui-ffi"
+    assert Path(build_environment["RATATUI_FFI_SRC"]) != ffi_source.resolve()
+    assert build_environment["RATATUI_FFI_TAG"] == payload["ratatui"]["ffi_revision"]
+    assert calls[1][0][1:4] == ["-m", "pip", "install"]
+    assert calls[2][0][:3] == [str(venv / "bin" / "python"), "-I", "-c"]
+    assert "import ratatui" in calls[2][0][3]
+    assert "import ratatui_py" in calls[2][0][3]
+
+
+def test_ratatui_sdist_materialization_rejects_unpinned_bytes(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    wheelhouse = tmp_path / "wheelhouse"
+    archive = b"not the pinned distribution"
+    payload = {
+        "ratatui": {
+            "version": "0.4.2",
+            "source_url": "https://example.invalid/ratatui-0.4.2.tar.gz",
+            "sdist_sha256": hashlib.sha256(b"expected distribution").hexdigest(),
+        }
+    }
+    monkeypatch.setattr(module, "WHEELHOUSE", wheelhouse)
+    monkeypatch.setattr(
+        module.urllib.request,
+        "urlopen",
+        lambda _url: io.BytesIO(archive),
+    )
+
+    with pytest.raises(module.SetupError, match="sdist digest mismatch"):
+        module._materialize_ratatui_sdist(module.Runner(dry_run=False), payload)
+
+    assert not (wheelhouse / "ratatui" / "ratatui-0.4.2.tar.gz").exists()
+
+
+@pytest.mark.parametrize("explicit_bootstrap", [None, "1"])
+@pytest.mark.parametrize("mode", ["candidate", "release"])
+@pytest.mark.parametrize("platform_name", ["linux", "darwin"])
+def test_project_wheel_uses_selected_mode_without_forcing_asset_bootstrap(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    explicit_bootstrap: str | None,
+    mode: str,
+    platform_name: str,
+) -> None:
+    module = _module()
+    monkeypatch.setattr(module.sys, "platform", platform_name)
+    venv = tmp_path / ".venv"
+    artifacts = tmp_path / "artifacts"
+    calls: list[tuple[list[str], dict[str, str] | None]] = []
+
+    class FakeRunner:
+        dry_run = False
+
+        def run(self, command, *, env=None, **_kwargs):
+            rendered = [str(item) for item in command]
+            calls.append((rendered, env))
+            if rendered[1:4] == ["-m", "build", "--wheel"]:
+                artifacts.mkdir(parents=True, exist_ok=True)
+                (artifacts / "pyamplicol-test.whl").touch()
+            return subprocess.CompletedProcess(rendered, 0, "", "")
+
+    if explicit_bootstrap is None:
+        monkeypatch.delenv("PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP", raising=False)
+    else:
+        monkeypatch.setenv(
+            "PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP",
+            explicit_bootstrap,
+        )
+    monkeypatch.setattr(module, "VENV", venv)
+    monkeypatch.setattr(module, "ARTIFACTS", artifacts)
+    monkeypatch.setattr(module, "RELEASE_ARTIFACTS", artifacts)
+
+    module._build_project_wheel(FakeRunner(), mode=mode)
+
+    assert len(calls) == 2
+    build_command, build_environment = calls[0]
+    assert build_command[1:4] == ["-m", "build", "--wheel"]
+    assert "--no-isolation" in build_command
+    assert "--skip-dependency-check" in build_command
+    assert ("pyamplicol.host-wheel=true" in build_command) == (platform_name == "linux")
+    if platform_name == "linux":
+        assert (
+            build_command[build_command.index("--config-setting") + 1]
+            == "pyamplicol.host-wheel=true"
+        )
+    assert build_environment is not None
+    assert build_environment["PYAMPLICOL_BUILD_MODE"] == mode
+    install_command, install_environment = calls[1]
+    assert install_command[1:4] == ["-m", "pip", "install"]
+    assert install_environment is not None
+    if explicit_bootstrap is None:
+        assert "PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP" not in build_environment
+        assert "PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP" not in install_environment
+        assert "PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP" not in os.environ
+    else:
+        assert (
+            build_environment["PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP"]
+            == explicit_bootstrap
+        )
+        assert (
+            install_environment["PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP"]
+            == explicit_bootstrap
+        )
+        assert os.environ["PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP"] == explicit_bootstrap
+
+
+def test_dependency_only_and_no_build_are_mutually_exclusive() -> None:
+    module = _module()
+    with pytest.raises(SystemExit):
+        module._parser().parse_args(["--dependencies-only", "--no-build"])
+
+
+@pytest.mark.parametrize("candidate", [False, True])
+@pytest.mark.parametrize("option", ["--dependencies-only", "--no-build"])
+def test_dependency_options_skip_the_project_wheel(
+    monkeypatch: pytest.MonkeyPatch,
+    candidate: bool,
+    option: str,
+) -> None:
+    module = _module()
+    payload: dict[str, object] = {}
+    monkeypatch.setattr(module, "_lock", lambda: payload)
+    monkeypatch.setattr(module, "_sources", lambda *_args, **_kwargs: ())
+    monkeypatch.setattr(module, "_developer_sources", lambda *_args, **_kwargs: ())
+    for name in (
+        "_ensure_just",
+        "_ensure_venv",
+        "_configure_sources",
+        "_write_cargo_config",
+        "_write_candidate_lock",
+        "_write_state",
+    ):
+        monkeypatch.setattr(module, name, lambda *_args, **_kwargs: None)
+    calls: list[str] = []
+    monkeypatch.setattr(
+        module,
+        "_build_candidate_dependency_wheels",
+        lambda *_args: calls.append("dependencies"),
+    )
+    monkeypatch.setattr(
+        module,
+        "_install_published_dependencies",
+        lambda *_args, **_kwargs: calls.append("published-dependencies"),
+    )
+    monkeypatch.setattr(
+        module, "_build_ratatui_wheel", lambda *_args: calls.append("ratatui")
+    )
+    monkeypatch.setattr(
+        module, "_build_project_wheel", lambda *_args, **_kwargs: pytest.fail("build")
+    )
+    monkeypatch.setattr(
+        module, "_stage_project_runtime", lambda *_args, **_kwargs: pytest.fail("stage")
+    )
+
+    assert (
+        module.main(
+            [
+                "--dry-run",
+                option,
+                *(["--candidate"] if candidate else []),
+            ]
+        )
+        == 0
+    )
+    expected = ["dependencies"] if candidate else ["published-dependencies", "ratatui"]
+    assert calls == ([] if option == "--no-build" else expected)
+
+
+@pytest.mark.parametrize("with_loader_wheel", [False, True])
+def test_published_dependencies_resolve_then_replace_same_version_candidates(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    with_loader_wheel: bool,
+) -> None:
+    module = _module()
+    monkeypatch.setattr(module, "VENV", tmp_path / ".venv")
+    wheel = tmp_path / "ufo_model_loader-1.0.0-py3-none-any.whl"
+    calls: list[list[str]] = []
+
+    class FakeRunner:
+        def run(self, command, **_kwargs):
+            calls.append([str(item) for item in command])
+
+    module._install_published_dependencies(
+        FakeRunner(), loader_wheel=wheel if with_loader_wheel else None
+    )
+    requirements = tomllib.loads(module.PYPROJECT.read_text())["project"][
+        "dependencies"
+    ]
+    selected = [str(wheel)] if with_loader_wheel else []
+    assert calls[0] == [
+        str(module._venv_python()),
+        "-m",
+        "pip",
+        "install",
+        "--upgrade",
+        *requirements,
+        *selected,
+    ]
+    assert calls[1] == [
+        str(module._venv_python()),
+        "-m",
+        "pip",
+        "install",
+        "--force-reinstall",
+        "--no-deps",
+        "--only-binary=:all:",
+        "symbolica==3.0.0",
+        *(selected or ["ufo-model-loader==1.0.0"]),
+    ]
+
+
+@pytest.mark.parametrize("reuse", [False, True])
+@pytest.mark.parametrize("mode", ["release", "candidate"])
+def test_installer_routes_project_and_staging_together(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    reuse: bool,
+    mode: str,
+) -> None:
+    module = _module()
+    monkeypatch.delenv("PYAMPLICOL_BUILD_MODE", raising=False)
+    monkeypatch.setattr(module, "_lock", lambda: {})
+    monkeypatch.setattr(module, "ARTIFACTS", tmp_path / "candidate")
+    monkeypatch.setattr(module, "RELEASE_ARTIFACTS", tmp_path / "release")
+    calls: list[tuple[str, object]] = []
+    for name in ("_ensure_just", "_ensure_venv"):
+        monkeypatch.setattr(module, name, lambda *_args, **_kwargs: None)
+    for name in (
+        "_configure_sources",
+        "_write_cargo_config",
+        "_write_candidate_lock",
+        "_write_state",
+    ):
+        monkeypatch.setattr(
+            module,
+            name,
+            lambda *_args, _name=name, **_kwargs: calls.append((_name, None)),
+        )
+    monkeypatch.setattr(module, "_sources", lambda *_args, **_kwargs: ())
+    monkeypatch.setattr(module, "_developer_sources", lambda *_args, **_kwargs: ())
+    monkeypatch.setattr(
+        module,
+        "_build_candidate_dependency_wheels",
+        lambda *_args: calls.append(("candidate-deps", None)),
+    )
+    monkeypatch.setattr(
+        module,
+        "_install_published_dependencies",
+        lambda *_args, **_kwargs: calls.append(("published-deps", None)),
+    )
+    monkeypatch.setattr(
+        module, "_build_ratatui_wheel", lambda *_args: calls.append(("ratatui", None))
+    )
+    monkeypatch.setattr(
+        module,
+        "_build_project_wheel",
+        lambda _runner, **kwargs: calls.append(("build", kwargs["mode"])),
+    )
+    monkeypatch.setattr(
+        module,
+        "_install_project_wheel",
+        lambda _runner, directory: calls.append(("install", directory)),
+    )
+    monkeypatch.setattr(
+        module,
+        "_stage_project_runtime",
+        lambda _runner, **kwargs: calls.append(("stage", kwargs)),
+    )
+    arguments = ["--dry-run", *(["--candidate"] if mode == "candidate" else [])]
+    directory = tmp_path / mode
+    if reuse:
+        directory = tmp_path / "existing"
+        arguments.extend(("--wheel-directory", str(directory)))
+    assert module.main(arguments) == 0
+    if mode == "release":
+        assert calls[:2] == [("published-deps", None), ("ratatui", None)]
+        assert len(calls) == 4  # No candidate Cargo overlays or candidate state.
+    else:
+        assert ("candidate-deps", None) in calls
+    assert calls[-2] == (("install", directory) if reuse else ("build", mode))
+    assert calls[-1] == ("stage", {"directory": directory, "mode": mode})
+
+
+@pytest.mark.parametrize("mode", ["release", "candidate"])
+def test_source_runtime_stage_reuses_wheel_in_selected_mode(mode: str) -> None:
+    module = _module()
+    calls = []
+
+    class FakeRunner:
+        def run(self, command, **kwargs):
+            calls.append((command, kwargs))
+
+    directory = Path("existing-wheels")
+    module._stage_project_runtime(FakeRunner(), directory=directory, mode=mode)
+    command, options = calls[0]
+    assert command == [
+        module._venv_python(),
+        ROOT / "tools/developer/prepare_source_runtime.py",
+        "--wheel-directory",
+        directory,
+    ]
+    assert options["env"]["PYAMPLICOL_BUILD_MODE"] == mode
+
+
+def test_candidate_mode_rejects_published_loader_override() -> None:
+    module = _module()
+    with pytest.raises(SystemExit):
+        module.main(["--candidate", "--loader-wheel", "loader.whl"])
+
+
+def test_toml_section_replacement_is_idempotent() -> None:
+    module = _module()
+    original = '[package]\nname = "x"\n\n[dependencies]\na = "1"\n'
+    once = module._replace_section(original, "dependencies", 'b = "2"')
+    twice = module._replace_section(once, "dependencies", 'b = "2"')
+    assert once == twice
+    assert 'a = "1"' not in once
+    assert once.count('b = "2"') == 1
+
+
+def test_symjit_rlib_manifest_validation_does_not_rewrite_source(
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    manifest = tmp_path / "Cargo.toml"
+    pristine = (
+        b'[package]\nname = "symjit"\nversion = "2.22.0"\n\n'
+        b'[lib]\ncrate-type = ["rlib"]\n'
+    )
+    manifest.write_bytes(pristine)
+
+    module._require_symjit_rlib_manifest(manifest, expected_version="2.22.0")
+
+    assert manifest.read_bytes() == pristine
+
+    manifest.write_text(
+        '[package]\nname = "symjit"\nversion = "2.22.0"\n\n'
+        '[lib]\ncrate-type = ["rlib", "cdylib"]\n',
+        encoding="utf-8",
+    )
+    with pytest.raises(module.SetupError, match="rlib-only"):
+        module._require_symjit_rlib_manifest(manifest)
+
+    manifest.write_text(
+        '[package]\nname = "symjit"\nversion = "2.21.0"\n\n'
+        '[lib]\ncrate-type = ["rlib"]\n',
+        encoding="utf-8",
+    )
+    with pytest.raises(module.SetupError, match="wrong package version"):
+        module._require_symjit_rlib_manifest(
+            manifest,
+            expected_version="2.22.0",
+        )
+
+
+def test_candidate_community_lock_is_resolved_from_the_upstream_lock(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    community = tmp_path / "checkouts" / "symbolica-community"
+    community.mkdir(parents=True)
+    lock = community / "Cargo.lock"
+    lock.write_text("stale generated lock\n", encoding="utf-8")
+    calls: list[list[str]] = []
+
+    class FakeRunner:
+        dry_run = False
+
+        def run(self, command, *, cwd=None, capture=False, **_kwargs):
+            rendered = [str(item) for item in command]
+            calls.append(rendered)
+            assert cwd == community
+            assert capture is True
+            if rendered[:2] == ["git", "show"]:
+                return subprocess.CompletedProcess(command, 0, "upstream lock\n", "")
+            if "--locked" not in rendered:
+                assert lock.read_text(encoding="utf-8") == "upstream lock\n"
+                lock.write_text("path-resolved lock\n", encoding="utf-8")
+            else:
+                assert lock.read_text(encoding="utf-8") == "path-resolved lock\n"
+            return subprocess.CompletedProcess(command, 0, "{}", "")
+
+    monkeypatch.setattr(module, "CHECKOUTS", tmp_path / "checkouts")
+    monkeypatch.setattr(module, "_configure_source_manifests", lambda _runner: None)
+
+    module._configure_sources(FakeRunner())
+
+    assert calls == [
+        ["git", "show", "HEAD:Cargo.lock"],
+        ["cargo", "metadata", "--format-version", "1"],
+        ["cargo", "metadata", "--locked", "--format-version", "1"],
+    ]
+    assert lock.read_text(encoding="utf-8") == "path-resolved lock\n"
+
+
+def test_development_symbolica_lock_is_not_publication_resolved(tmp_path: Path) -> None:
+    module = _module()
+    lock = tmp_path / "Cargo.lock"
+    lock.write_text(
+        'version = 4\n\n[[package]]\nname = "symbolica"\nversion = "3.0.0"\n'
+        'source = "git+https://github.com/symbolica-dev/symbolica#' + "a" * 40 + '"\n',
+        encoding="utf-8",
+    )
+    with pytest.raises(module.SetupError, match="symbolica has an unexpected source"):
+        module._validate_release_cargo_lock(lock)
+
+
+def test_candidate_lock_is_seeded_without_mutating_canonical_lock(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    project = tmp_path / "project"
+    project.mkdir()
+    (project / "Cargo.toml").write_text("[workspace]\n", encoding="utf-8")
+    release_lock = project / "Cargo.lock"
+    release_lock.write_bytes(b"canonical release lock\n")
+    (project / "rust").mkdir()
+    cargo_config = project / ".cargo" / "config.toml"
+    cargo_config.parent.mkdir()
+    cargo_config.write_text("[patch.crates-io]\n", encoding="utf-8")
+    candidate_lock = project / "dependencies" / "candidate-Cargo.lock"
+    candidate_lock.parent.mkdir()
+    calls: list[list[str]] = []
+
+    class FakeRunner:
+        dry_run = False
+
+        def run(self, command, *, cwd=None, capture=False, **_kwargs):
+            assert cwd is not None and capture is True
+            calls.append(list(command))
+            staged_lock = Path(cwd) / "Cargo.lock"
+            if len(calls) == 1:
+                assert staged_lock.read_bytes() == b"canonical release lock\n"
+                staged_lock.write_bytes(b"candidate path lock\n")
+            else:
+                assert staged_lock.read_bytes() == b"candidate path lock\n"
+            return subprocess.CompletedProcess(command, 0, "{}", "")
+
+    monkeypatch.setattr(module, "ROOT", project)
+    monkeypatch.setattr(module, "CARGO_CONFIG", cargo_config)
+    monkeypatch.setattr(module, "CANDIDATE_LOCK", candidate_lock)
+    monkeypatch.setattr(module, "_root_path_patches", dict)
+    monkeypatch.setattr(
+        module,
+        "_validate_release_cargo_lock",
+        lambda _path: pytest.fail("candidate resolution is not release validation"),
+    )
+    monkeypatch.setattr(module, "_validate_candidate_cargo_lock", lambda _path: None)
+    projected: list[Path] = []
+    monkeypatch.setattr(
+        module,
+        "_rewrite_candidate_requirements",
+        lambda root: projected.append(root),
+    )
+
+    module._write_candidate_lock(FakeRunner())
+
+    assert calls == [
+        ["cargo", "metadata", "--format-version", "1"],
+        ["cargo", "metadata", "--locked", "--format-version", "1"],
+    ]
+    assert release_lock.read_bytes() == b"canonical release lock\n"
+    assert candidate_lock.read_bytes() == b"candidate path lock\n"
+    assert len(projected) == 1
+    assert projected[0].parent != project
+
+
+def test_candidate_dependency_projection_rewrites_only_the_isolated_manifest(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    manifest = tmp_path / "rust" / "crates" / "rusticol-core" / "Cargo.toml"
+    manifest.parent.mkdir(parents=True)
+    manifest.write_text(
+        'symbolica = { version = "=2.1.0", default-features = false }\n'
+        'symjit = { version = "=2.22.0", default-features = false }\n',
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        module,
+        "_lock",
+        lambda: {
+            "symbolica": {
+                "rust_version": "2.1.0",
+                "candidate_version": "2.2.0",
+            },
+            "symjit": {
+                "version": "2.22.0",
+                "candidate_version": "2.21.0",
+            },
+        },
+    )
+
+    module._rewrite_candidate_requirements(tmp_path)
+
+    projected = manifest.read_text(encoding="utf-8")
+    assert 'symbolica = { version = "=2.2.0"' in projected
+    assert 'symjit = { version = "=2.21.0"' in projected
diff --git a/pyamplicol/tests/unit/test_deployment_harness.py b/pyamplicol/tests/unit/test_deployment_harness.py
new file mode 100644
index 0000000000..4384787ded
--- /dev/null
+++ b/pyamplicol/tests/unit/test_deployment_harness.py
@@ -0,0 +1,551 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import ast
+import json
+import os
+import subprocess
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tools" / "release"))
+
+import test_deployment as deployment  # noqa: E402
+
+
+def test_installed_smoke_uses_the_v1_builtin_model_name() -> None:
+    assert "from pyamplicol.models import BuiltinSMModel" in deployment._INSTALLED_SMOKE
+    assert "AmplicolSMLeadingColorModel" not in deployment._INSTALLED_SMOKE
+    assert 'build_info["selftest_fixture_bootstrap"] is False' in (
+        deployment._INSTALLED_SMOKE
+    )
+    assert 'build_info["publishable"] is True' in deployment._INSTALLED_SMOKE
+    assert 'build_info["schema_version"] == 1' in deployment._INSTALLED_SMOKE
+    assert 'build_info["source_revision"]' in deployment._INSTALLED_SMOKE
+
+
+def test_installed_smoke_copies_and_dry_runs_the_profiling_campaign() -> None:
+    smoke = deployment._INSTALLED_SMOKE
+    assert 'campaign = Path(raw).resolve() / "campaign"' in smoke
+    assert 'campaign = Path(raw) / "campaign"' not in smoke
+    assert '"profiling-campaign"' in smoke
+    assert 'campaign / "steer_performance_campaign.py"' in smoke
+    assert 'campaign / "pyAmpliCol.pdf"' in smoke
+    assert '"scalar_contact"' in smoke
+    assert '"--generation-engine"' in smoke
+    assert '"compiled"' in smoke
+    assert '"compact retention (default)"' in smoke
+    assert '"--retain-workspaces"' in smoke
+    assert '"full debug workspaces (--retain-workspaces)"' in smoke
+
+
+def test_installed_smoke_finishes_cli_children_before_native_imports() -> None:
+    tree = ast.parse(deployment._INSTALLED_SMOKE)
+    native_imports = [
+        node.lineno
+        for node in ast.walk(tree)
+        if (
+            isinstance(node, ast.Import)
+            and any(
+                name.name.split(".")[0] in {"pyamplicol", "symbolica"}
+                for name in node.names
+            )
+        )
+        or (
+            isinstance(node, ast.ImportFrom)
+            and (node.module or "").split(".")[0] in {"pyamplicol", "symbolica"}
+        )
+    ]
+    child_calls = [
+        node.lineno
+        for node in ast.walk(tree)
+        if isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and isinstance(node.func.value, ast.Name)
+        and node.func.value.id == "subprocess"
+    ]
+    assert native_imports and child_calls
+    assert max(child_calls) < min(native_imports)
+
+
+def test_f64_deployment_smoke_hard_blocks_symbolica() -> None:
+    smoke = deployment._SYMBOLICA_FREE_F64_SMOKE
+    assert 'os.environ.pop("SYMBOLICA_LICENSE", None)' in smoke
+    assert "builtins.__import__ = reject_symbolica" in smoke
+    assert 'check.name == "physics-f64"' in smoke
+    assert 'name.startswith("symbolica.")' in smoke
+    assert "for name in sys.modules" in smoke
+
+
+@pytest.mark.parametrize("name", ["symbolica", "symbolica.core"])
+def test_f64_deployment_import_block_models_an_absent_package(name: str) -> None:
+    hook = next(
+        node
+        for node in ast.parse(deployment._SYMBOLICA_FREE_F64_SMOKE).body
+        if isinstance(node, ast.FunctionDef) and node.name == "reject_symbolica"
+    )
+    namespace = {"original_import": __import__}
+    exec(compile(ast.Module(body=[hook], type_ignores=[]), "<hook>", "exec"), namespace)
+    with pytest.raises(ModuleNotFoundError) as caught:
+        namespace["reject_symbolica"](name)
+    assert caught.value.name == "symbolica"
+
+
+def test_f64_minimal_deployment_requires_symbolica_to_be_absent() -> None:
+    smoke = deployment._SYMBOLICA_ABSENT_F64_SMOKE
+    assert "find_spec(unavailable) is None" in smoke
+    assert '("symbolica", "ufo_model_loader")' in smoke
+    assert 'runtime.evaluate(expected["momenta"])' in smoke
+    assert 'runtime.evaluate_resolved(expected["momenta"])' in smoke
+    assert "resolved.total()" in smoke
+    assert 'runtime.artifact_id == manifest["artifact_id"]' in smoke
+    assert 'runtime.execution_mode == "compiled"' in smoke
+
+
+def test_f64_minimal_deployment_installs_only_numpy_and_wheel(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    wheel = tmp_path / "pyamplicol-test.whl"
+    wheel.write_bytes(b"wheel")
+    commands: list[list[str]] = []
+
+    def fake_run(command, **_kwargs):
+        rendered = [os.fspath(item) for item in command]
+        commands.append(rendered)
+        return subprocess.CompletedProcess(rendered, 0, "", "")
+
+    monkeypatch.setattr(deployment, "run", fake_run)
+    deployment._symbolica_absent_f64_smoke(
+        wheel,
+        target_python=Path("/host/python"),
+        sandbox=tmp_path / "deployment",
+        numpy_version="2.4.2",
+    )
+
+    pip_installs = [
+        command
+        for command in commands
+        if command[1:5] == ["-I", "-m", "pip", "install"]
+    ]
+    assert len(pip_installs) == 2
+    assert pip_installs[0][-2:] == ["--only-binary=:all:", "numpy==2.4.2"]
+    assert "--no-deps" in pip_installs[1]
+    assert pip_installs[1][-1] == os.fspath(wheel.resolve())
+    assert all("symbolica" not in command for command in pip_installs)
+    assert all("ufo-model-loader" not in command for command in pip_installs)
+    assert commands[-1][-2:] == ["-c", deployment._SYMBOLICA_ABSENT_F64_SMOKE]
+
+
+def test_installed_backend_smoke_covers_precision_compiled_and_eager() -> None:
+    smoke = deployment._INSTALLED_BACKEND_AND_PRECISION_SMOKE
+    assert "EvaluatorBackend.JIT" in smoke
+    assert "EvaluatorBackend.ASM" in smoke
+    assert "EvaluatorBackend.CPP" in smoke
+    assert "precision=80" in smoke
+    assert 'Generator(config).generate("d d~ > z", artifact)' in smoke
+    assert "resolved.total()[0] == total" in smoke
+    assert 'runtime.artifact_id == manifest["artifact_id"]' in smoke
+    assert 'runtime.execution_mode == "compiled"' in smoke
+    assert "EvaluatorExecutionMode.EAGER" in smoke
+    assert 'Generator(eager_config).generate("d d~ > z", eager_artifact)' in smoke
+    assert '"pyamplicol-runtime-eager-execution"' in smoke
+    assert '"model/eager-kernel-pack.json"' in smoke
+    assert "eager_runtime.evaluate(momenta)" in smoke
+    assert 'eager_runtime.artifact_id == eager_manifest["artifact_id"]' in smoke
+    assert 'eager_runtime.execution_mode == "eager"' in smoke
+    assert "abs(eager_reduced - eager_total)" in smoke
+    assert "eager_runtime.evaluate(momenta, precision=80)" in smoke
+
+
+def test_abi3_smoke_skips_duplicate_generation_and_sdk_checks(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    wheel = tmp_path / "pyamplicol-0.1.0-cp311-abi3-test.whl"
+    wheel.write_bytes(b"wheel")
+    commands: list[list[str]] = []
+
+    def fake_run(command, **_kwargs):
+        rendered = [os.fspath(item) for item in command]
+        commands.append(rendered)
+        return subprocess.CompletedProcess(rendered, 0, "", "")
+
+    def unexpected(*_args, **_kwargs):
+        raise AssertionError("full deployment check ran during abi3 smoke")
+
+    monkeypatch.setattr(deployment, "DEPLOYMENT_ROOT", tmp_path / "deployments")
+    monkeypatch.setattr(
+        deployment,
+        "audit_wheel",
+        lambda *_args, **_kwargs: SimpleNamespace(version="0.1.0"),
+    )
+    monkeypatch.setattr(deployment, "run", fake_run)
+    monkeypatch.setattr(deployment, "runtime_environment", lambda _venv: {})
+    monkeypatch.setattr(deployment, "interpreter_tags", lambda _python: ["abi3"])
+    monkeypatch.setattr(
+        deployment,
+        "_install_dependencies",
+        lambda *_args, **_kwargs: deployment.DependencyInstallation(
+            {"numpy": "2.4.2"}, {}
+        ),
+    )
+    monkeypatch.setattr(deployment, "_symbolica_absent_f64_smoke", unexpected)
+    monkeypatch.setattr(deployment, "_native_sdk_smoke", unexpected)
+
+    sandbox = deployment.test_deployment(
+        wheel,
+        target_python=Path(sys.executable),
+        mode="release",
+        wheelhouses=(),
+        keep=True,
+        abi3_smoke_only=True,
+    )
+
+    assert sandbox is not None
+    assert any(
+        command[-2:] == ["-c", deployment._INSTALLED_SMOKE]
+        for command in commands
+    )
+    assert any(
+        command[-2:] == ["-c", deployment._SYMBOLICA_FREE_F64_SMOKE]
+        for command in commands
+    )
+    assert not any(
+        deployment._INSTALLED_BACKEND_AND_PRECISION_SMOKE in command
+        for command in commands
+    )
+    assert not any("pyamplicol.selftest" in command for command in commands)
+    assert not any(
+        "self-test" in command or "examples" in command for command in commands
+    )
+    result = json.loads(
+        (sandbox / "deployment-result.json").read_text(encoding="utf-8")
+    )
+    assert result["validation_scope"] == "abi3-smoke"
+    assert result["native_sdk_validated"] is False
+
+
+from _common import ReleaseError, clean_environment  # noqa: E402
+
+
+def test_release_environment_discards_native_toolchain_injection(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    injected = {
+        "CPATH": "/opt/local/include",
+        "DYLD_LIBRARY_PATH": "/opt/local/lib",
+        "LDFLAGS": "-L/opt/local/lib",
+        "LIBRARY_PATH": "/opt/local/lib",
+        "RUSTFLAGS": "-L/opt/local/lib/libgcc -l dylib=gcc_s",
+    }
+    for name, value in injected.items():
+        monkeypatch.setenv(name, value)
+
+    environment = clean_environment(mode="candidate")
+
+    assert not set(injected) & set(environment)
+    assert environment["PYAMPLICOL_BUILD_MODE"] == "candidate"
+
+
+def test_deployment_copies_the_complete_installed_examples_tree(tmp_path: Path) -> None:
+    python = tmp_path / "venv/bin/python"
+    destination = tmp_path / "examples"
+
+    command = [
+        os.fspath(item)
+        for item in deployment._examples_copy_command(python, destination)
+    ]
+
+    assert command == [
+        os.fspath(python),
+        "-I",
+        "-m",
+        "pyamplicol",
+        "examples",
+        "copy",
+        os.fspath(destination),
+    ]
+
+
+def test_deployment_runs_a_copied_external_ufo_example(tmp_path: Path) -> None:
+    python = tmp_path / "venv/bin/python"
+    card = tmp_path / "examples/external_ufo_sm.toml"
+
+    command = [
+        os.fspath(item)
+        for item in deployment._copied_example_command(python, card)
+    ]
+
+    assert command == [
+        os.fspath(python),
+        "-I",
+        "-m",
+        "pyamplicol",
+        os.fspath(card),
+        "--set",
+        "generation.mode=replace",
+        "--json",
+    ]
+
+
+def test_candidate_deployment_builds_fresh_instead_of_reusing_stale_wheel(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("PYAMPLICOL_BUILD_MODE", raising=False)
+    retained = tmp_path / "retained"
+    retained.mkdir()
+    stale = retained / "pyamplicol-0.1.0.dev0+candidate.stale-cp311-abi3-test.whl"
+    stale.write_bytes(b"stale")
+    scratch = tmp_path / "scratch"
+    selected: list[tuple[Path, bool]] = []
+
+    @contextmanager
+    def fake_temporary(_prefix: str):
+        scratch.mkdir()
+        yield scratch
+
+    def fake_run(command, **_kwargs):
+        outdir = Path(command[command.index("--outdir") + 1])
+        fresh = outdir / "pyamplicol-0.1.0.dev0+candidate.fresh-cp311-abi3-test.whl"
+        fresh.write_bytes(b"fresh")
+        return subprocess.CompletedProcess(command, 0, "", "")
+
+    def fake_select(wheels, _tags):
+        candidates = list(wheels)
+        assert len(candidates) == 1
+        assert candidates[0].parent == scratch
+        assert candidates[0] != stale
+        return candidates[0]
+
+    def fake_deployment(wheel, **_kwargs):
+        selected.append((wheel, bool(_kwargs["abi3_smoke_only"])))
+
+    monkeypatch.setattr(deployment, "check_dependency_gate", lambda *_a, **_k: None)
+    monkeypatch.setattr(deployment, "external_temporary_directory", fake_temporary)
+    monkeypatch.setattr(deployment, "run", fake_run)
+    monkeypatch.setattr(deployment, "interpreter_tags", lambda _python: ["test"])
+    monkeypatch.setattr(deployment, "select_compatible_wheel", fake_select)
+    monkeypatch.setattr(deployment, "wheelhouse_directories", lambda _path: [])
+    monkeypatch.setattr(deployment, "test_deployment", fake_deployment)
+
+    assert (
+        deployment.main(
+            [
+                "--candidate",
+                "--artifact-dir",
+                os.fspath(retained),
+                "--abi3-smoke-only",
+            ]
+        )
+        == 0
+    )
+    assert selected and selected[0][0].read_bytes() == b"fresh"
+    assert selected[0][1] is True
+    assert stale.read_bytes() == b"stale"
+
+
+def test_release_native_sdk_smoke_requires_all_compilers(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("PYAMPLICOL_REQUIRE_NATIVE_TESTS", raising=False)
+    monkeypatch.delenv("CXX", raising=False)
+    monkeypatch.delenv("FC", raising=False)
+    monkeypatch.setattr(deployment.shutil, "which", lambda _name: None)
+
+    with pytest.raises(
+        ReleaseError,
+        match=r"C\+\+17 and Fortran 2008 and Rust 2021",
+    ):
+        deployment._native_sdk_smoke(
+            Path(sys.executable),
+            sandbox=tmp_path,
+            mode="release",
+            environment={},
+        )
+
+
+def test_candidate_native_sdk_smoke_reports_explicit_nonvalidation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    monkeypatch.delenv("PYAMPLICOL_REQUIRE_NATIVE_TESTS", raising=False)
+    monkeypatch.delenv("CXX", raising=False)
+    monkeypatch.delenv("FC", raising=False)
+    monkeypatch.setattr(deployment.shutil, "which", lambda _name: None)
+
+    assert (
+        deployment._native_sdk_smoke(
+            Path(sys.executable),
+            sandbox=tmp_path,
+            mode="candidate",
+            environment={},
+        )
+        is False
+    )
+    assert "did not run native SDK smoke tests" in capsys.readouterr().out
+
+
+def test_candidate_native_sdk_smoke_can_require_all_compilers(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_REQUIRE_NATIVE_TESTS", "1")
+    monkeypatch.delenv("CXX", raising=False)
+    monkeypatch.delenv("FC", raising=False)
+    monkeypatch.setattr(deployment.shutil, "which", lambda _name: None)
+
+    with pytest.raises(ReleaseError, match="native SDK validation requires"):
+        deployment._native_sdk_smoke(
+            Path(sys.executable),
+            sandbox=tmp_path,
+            mode="candidate",
+            environment={},
+        )
+
+
+def test_native_sdk_smoke_compiles_and_runs_all_four_language_drivers(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    include = tmp_path / "sdk/include"
+    include.mkdir(parents=True)
+    library = tmp_path / "sdk/librusticol_capi.a"
+    library.write_bytes(b"archive")
+    fortran_module = tmp_path / "sdk/rusticol.f90"
+    fortran_module.write_text(
+        "module rusticol\nend module rusticol\n", encoding="utf-8"
+    )
+    rust_module = tmp_path / "sdk/rusticol.rs"
+    rust_module.write_text("pub struct Runtime;\n", encoding="utf-8")
+    sdk = {
+        "cflags": [f"-I{include}"],
+        "link_flags": [str(library)],
+        "rust_flags": ["-C", f"link-arg={library}"],
+        "fortran_source": str(fortran_module),
+        "rust_source": str(rust_module),
+    }
+    artifact = tmp_path / "installed/artifact"
+    python_driver = artifact / "API/python/check_standalone.py"
+    c_driver = artifact / "API/c/check_standalone.c"
+    cpp_driver = artifact / "API/cpp/check_standalone.cpp"
+    fortran_driver = artifact / "API/fortran/check_standalone.f90"
+    rust_driver = artifact / "API/rust/check_standalone.rs"
+    python_driver.parent.mkdir(parents=True)
+    c_driver.parent.mkdir(parents=True)
+    cpp_driver.parent.mkdir(parents=True)
+    fortran_driver.parent.mkdir(parents=True)
+    rust_driver.parent.mkdir(parents=True)
+    python_driver.write_text("raise SystemExit(0)\n", encoding="utf-8")
+    c_driver.write_text("int main(void) { return 0; }\n", encoding="utf-8")
+    cpp_driver.write_text("int main() { return 0; }\n", encoding="utf-8")
+    fortran_driver.write_text("program main\nend program main\n", encoding="utf-8")
+    rust_driver.write_text("fn main() {}\n", encoding="utf-8")
+    fixture = deployment.NativePhysicsFixture(
+        artifact=artifact,
+        process_id="smoke",
+        shape=(1, 1, 1),
+        totals=(2.5,),
+    )
+    commands: list[list[str]] = []
+    command_environments: list[dict[str, str]] = []
+
+    monkeypatch.setattr(
+        deployment,
+        "_native_toolchain",
+        lambda _mode: deployment.NativeToolchain(
+            cc=("/tool/cc",),
+            cxx=("/tool/c++",),
+            fortran=("/tool/gfortran",),
+            rustc=("/tool/rustc",),
+        ),
+    )
+    monkeypatch.setattr(
+        deployment,
+        "_installed_selftest_fixture",
+        lambda *_args, **_kwargs: fixture,
+    )
+
+    def fake_run(command, **_kwargs):
+        rendered = [os.fspath(item) for item in command]
+        commands.append(rendered)
+        command_environments.append(dict(_kwargs.get("env", {})))
+        if "rusticol_config" in rendered:
+            return subprocess.CompletedProcess(rendered, 0, json.dumps(sdk), "")
+        language = None
+        if any(item.endswith("check_standalone.py") for item in rendered):
+            language = "python"
+        else:
+            for candidate in ("c", "cpp", "fortran", "rust"):
+                if rendered[0].endswith(f"check_standalone_{candidate}"):
+                    language = candidate
+                    break
+        if language is not None:
+            payload = {
+                "language": language,
+                "available": True,
+                "precision": 16,
+                "process_key": "smoke",
+                "shape": [1, 1, 1],
+                "values": [2.5],
+                "resolved_sum": [2.5],
+                "compatibility_total": [2.5],
+            }
+            return subprocess.CompletedProcess(rendered, 0, json.dumps(payload), "")
+        return subprocess.CompletedProcess(rendered, 0, "", "")
+
+    monkeypatch.setattr(deployment, "run", fake_run)
+    assert (
+        deployment._native_sdk_smoke(
+            Path(sys.executable),
+            sandbox=tmp_path,
+            mode="release",
+            environment={"PATH": "/deployment/venv/bin:/usr/bin:/bin"},
+        )
+        is True
+    )
+
+    assert any(command[0] == "/tool/cc" for command in commands)
+    assert any(command[0] == "/tool/c++" for command in commands)
+    assert any(command[0] == "/tool/gfortran" for command in commands)
+    assert any(command[0] == "/tool/rustc" for command in commands)
+    assert any(command[0] == os.fspath(Path(sys.executable)) for command in commands)
+    assert any(command[0].endswith("check_standalone_c") for command in commands)
+    assert any(command[0].endswith("check_standalone_cpp") for command in commands)
+    assert any(command[0].endswith("check_standalone_fortran") for command in commands)
+    assert any(command[0].endswith("check_standalone_rust") for command in commands)
+    rust_compile_index = next(
+        index for index, command in enumerate(commands) if command[0] == "/tool/rustc"
+    )
+    assert "rustc" not in command_environments[rust_compile_index]["PATH"]
+    assert command_environments[rust_compile_index]["RUSTICOL_RUST_SOURCE"] == str(
+        rust_module
+    )
+
+
+def test_five_language_result_comparison_rejects_metadata_drift() -> None:
+    common = {
+        "available": True,
+        "precision": 16,
+        "process_key": "smoke",
+        "shape": [1, 1, 1],
+        "values": [2.5],
+        "resolved_sum": [2.5],
+        "compatibility_total": [2.5],
+    }
+    results = {
+        language: {"language": language, **common}
+        for language in ("python", "c", "cpp", "fortran", "rust")
+    }
+    results["rust"]["process_key"] = "different"
+
+    with pytest.raises(ReleaseError, match="rust API driver metadata"):
+        deployment._compare_driver_results(results)
diff --git a/pyamplicol/tests/unit/test_developer_generation_slice.py b/pyamplicol/tests/unit/test_developer_generation_slice.py
new file mode 100644
index 0000000000..f7c349da87
--- /dev/null
+++ b/pyamplicol/tests/unit/test_developer_generation_slice.py
@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from types import MappingProxyType
+
+import pytest
+
+from pyamplicol.config import ProcessConfig, RunConfig
+from pyamplicol.generation.service import GenerationBackend
+from tools.developer.generation_slice import GenerationSlice
+
+
+def test_generation_slice_normalizes_immutable_internal_selection() -> None:
+    generation_slice = GenerationSlice(
+        reference_color_order=(2, 4, 1, 3),
+        selected_color_sector_ids=(3, 1),
+        selected_source_helicities={1: -1, 2: 1},
+    )
+
+    selection = generation_slice._selection()
+
+    assert selection.reference_color_order == (2, 4, 1, 3)
+    assert selection.selected_color_sector_ids == frozenset({1, 3})
+    assert selection.selected_source_helicities == {1: -1, 2: 1}
+    assert isinstance(selection.selected_source_helicities, MappingProxyType)
+
+
+def test_generation_backend_private_slice_overrides_legacy_public_fields() -> None:
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            process=ProcessConfig(
+                reference_color_order=(1, 2, 3, 4),
+                selected_color_sector_ids=(0,),
+                selected_source_helicities={"1": 1},
+            ),
+        ),
+        None,
+        process_selection=GenerationSlice(
+            reference_color_order=(2, 4, 1, 3),
+            selected_color_sector_ids=(2,),
+            selected_source_helicities={1: -1},
+        )._selection(),
+    )
+
+    selection = backend._process_selection
+
+    assert selection.reference_color_order == (2, 4, 1, 3)
+    assert selection.selected_color_sector_ids == frozenset({2})
+    assert selection.selected_source_helicities == {1: -1}
+
+
+@pytest.mark.parametrize(
+    ("kwargs", "message"),
+    (
+        ({"reference_color_order": (1, 1)}, "unique labels"),
+        ({"selected_color_sector_ids": (-1,)}, "non-negative"),
+        ({"selected_source_helicities": {0: 1}}, "positive integer labels"),
+        ({"selected_source_helicities": {1: True}}, "integer helicities"),
+    ),
+)
+def test_generation_slice_rejects_invalid_private_selectors(
+    kwargs: dict[str, object],
+    message: str,
+) -> None:
+    with pytest.raises(ValueError, match=message):
+        GenerationSlice(**kwargs)  # type: ignore[arg-type]
diff --git a/pyamplicol/tests/unit/test_diagnostics.py b/pyamplicol/tests/unit/test_diagnostics.py
new file mode 100644
index 0000000000..75d1ef461e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_diagnostics.py
@@ -0,0 +1,86 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from types import SimpleNamespace
+
+import pytest
+
+import pyamplicol.diagnostics as diagnostics
+from pyamplicol.api.services import Runtime
+from pyamplicol.diagnostics import DiagnosticCheck, DiagnosticReport, run_doctor
+
+
+def test_diagnostic_report_fails_only_for_failed_checks() -> None:
+    warning = DiagnosticReport(
+        "0.1.0", (DiagnosticCheck("optional", "warning", "missing"),)
+    )
+    failure = DiagnosticReport(
+        "0.1.0", (DiagnosticCheck("required", "fail", "missing"),)
+    )
+    assert warning.ok
+    assert not failure.ok
+
+
+def test_source_doctor_verifies_packaged_model_assets() -> None:
+    report = run_doctor()
+    assets = next(check for check in report.checks if check.name == "model-assets")
+    assert assets.status == "pass"
+    assert "verified files" in assets.detail
+
+
+def test_physics_selftest_uses_target_fixture_without_symbolica(
+    monkeypatch: pytest.MonkeyPatch, tmp_path
+) -> None:
+    target = "aarch64-apple-darwin"
+    fixture = tmp_path / "assets" / "selftest" / target
+    (fixture / "artifact").mkdir(parents=True)
+    (fixture / "expected.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "artifact_path": "artifact",
+                "target": target,
+                "process_id": "d_dbar_to_z",
+                "momenta": [[[45.594, 0.0, 0.0, 45.594]]],
+                "resolved_shape": [1, 2, 1],
+                "total": [[3.5, 0.0]],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    class Resolved:
+        shape = (1, 2, 1)
+
+        @staticmethod
+        def total() -> tuple[complex, ...]:
+            return (3.5 + 0.0j,)
+
+    runtime = SimpleNamespace(
+        physics=SimpleNamespace(process_id="d_dbar_to_z"),
+        evaluate=lambda _momenta: (3.5 + 0.0j,),
+        evaluate_resolved=lambda _momenta: Resolved(),
+    )
+    imports: list[str] = []
+    original_import = diagnostics.importlib.import_module
+
+    def fake_import(name: str):
+        imports.append(name)
+        if name == "pyamplicol._rusticol":
+            return SimpleNamespace(target_info=lambda: SimpleNamespace(triple=target))
+        return original_import(name)
+
+    monkeypatch.setattr(diagnostics.importlib, "import_module", fake_import)
+    monkeypatch.setattr(diagnostics.resources, "files", lambda _package: tmp_path)
+    monkeypatch.setattr(
+        Runtime,
+        "load",
+        classmethod(lambda _cls, _artifact, **_kwargs: runtime),
+    )
+
+    check = diagnostics._physics_check()
+
+    assert check.status == "pass"
+    assert "direct SymJIT" in check.detail
+    assert imports == ["pyamplicol._rusticol"]
diff --git a/pyamplicol/tests/unit/test_eager_artifact_writer.py b/pyamplicol/tests/unit/test_eager_artifact_writer.py
new file mode 100644
index 0000000000..4cbb9acd50
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_artifact_writer.py
@@ -0,0 +1,681 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import get_args
+
+import pytest
+
+import pyamplicol.generation.artifact_writer as artifact_writer
+from pyamplicol._internal.versions import (
+    EAGER_DAG_F64_RUNTIME_CAPABILITY,
+    EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY,
+    EVALUATOR_RUNTIME_CAPABILITIES,
+    KNOWN_EVALUATOR_RUNTIME_CAPABILITIES,
+)
+from pyamplicol.api.requests import ModelSource
+from pyamplicol.artifacts import ArtifactBuilder, load_manifest
+from pyamplicol.artifacts.manifest import PORTABLE_64LE_TARGET
+from pyamplicol.config import (
+    Action,
+    EvaluatorConfig,
+    GenerationConfig,
+    JITConfig,
+    RunConfig,
+)
+from pyamplicol.generation.artifact_writer import (
+    EagerPlanV3ProcessArtifact,
+    _GenerationConfigProvenance,
+    write_schema_v3_artifact,
+)
+from pyamplicol.generation.evaluator_container import PacbinReader
+from pyamplicol.generation.structural_source_proof import (
+    ROLE as STRUCTURAL_SOURCE_PROOF_ROLE,
+)
+from pyamplicol.generation.structural_source_proof import (
+    validate_generation_structural_proof,
+)
+from pyamplicol.generation.validation import ValidationPointRecord
+from pyamplicol.models.loading import compile_model_source
+from pyamplicol.models.prepared import (
+    PREPARED_KERNEL_VARIANT_ABI,
+    PreparedKernelPack,
+    PreparedKernelRecord,
+    PreparedKernelVariantRecord,
+    prepared_expression_digest,
+    prepared_input_contract_digest,
+    prepared_kernel_pack_manifest_identity_sha256,
+    prepared_optimization_settings_digest,
+    prepared_output_contract_digest,
+    write_prepared_model_bundle,
+)
+
+
+def _plane_application(
+    root: str,
+    *,
+    input_arity: int,
+    output_arity: int,
+) -> dict[str, object]:
+    return {
+        "application_path": f"{root}/plane-application.symjit",
+        "application_abi": artifact_writer.SYMJIT_PLANE_APPLICATION_ABI,
+        "storage_abi": artifact_writer.SYMJIT_APPLICATION_ABI,
+        "element_layout": "split-complex-plane-major",
+        "descriptor_order": "inputs-re-im-then-outputs-re-im",
+        "input_complex_count": input_arity,
+        "output_complex_count": output_arity,
+        "input_plane_count": 2 * input_arity,
+        "output_plane_count": 2 * output_arity,
+        "compiler_type": "native",
+        "translation_mode": "symbolica-structured-instructions",
+        "optimization_level": 2,
+        "simd": True,
+        "complex": True,
+        "fast_math": True,
+        "fast_complex": False,
+        "compression": True,
+        "threading": False,
+        "direct_arena": True,
+        "source_digest": "0" * 64,
+        "target": {"triple": "test-native", "cpu_features": []},
+    }
+
+
+def _kernel(kernel_id: int, signature: str) -> PreparedKernelRecord:
+    root = f"kernels/{kernel_id}"
+    return PreparedKernelRecord(
+        kernel_id=kernel_id,
+        contract_kind="vertex",
+        canonical_signature=signature,
+        input_arity=1,
+        output_arity=1,
+        input_layout=("input",),
+        input_contracts=(
+            {
+                "role": "current",
+                "component": 0,
+                "symbol": "pyamplicol::input",
+                "model_parameter_name": None,
+                "model_parameter_index": None,
+            },
+        ),
+        output_layout=("output",),
+        exact_expressions=("pyamplicol::input",),
+        exact_evaluator_state_path=f"{root}/exact.evaluator.bin",
+        f64_evaluator_manifest={
+            "kind": "symjit-application-evaluator",
+            "application_abi": artifact_writer.SYMJIT_APPLICATION_ABI,
+            "optimization_level": 2,
+            "settings": {"jit_optimization_level": 2},
+            "input_len": 1,
+            "output_len": 1,
+            "application_path": f"{root}/application.symjit",
+            "plane_application": _plane_application(
+                root,
+                input_arity=1,
+                output_arity=1,
+            ),
+            "evaluator_state_path": f"{root}/exact.evaluator.bin",
+        },
+    )
+
+
+def _variant(kernel: PreparedKernelRecord) -> PreparedKernelVariantRecord:
+    settings = {"jit_optimization_level": 2}
+    root = f"kernels/{kernel.kernel_id}/variants/independent-block-4"
+    return PreparedKernelVariantRecord(
+        variant_id="independent-block-4",
+        variant_abi=PREPARED_KERNEL_VARIANT_ABI,
+        kind="independent-block",
+        block_size=4,
+        lane_layout="lane-major",
+        base_kernel_id=kernel.kernel_id,
+        base_canonical_signature=kernel.canonical_signature,
+        base_expression_digest=prepared_expression_digest(kernel.exact_expressions),
+        base_input_contract_digest=prepared_input_contract_digest(
+            kernel.input_layout,
+            kernel.input_contracts,
+        ),
+        base_output_contract_digest=prepared_output_contract_digest(
+            kernel.output_layout
+        ),
+        backend="jit",
+        optimization_settings_digest=prepared_optimization_settings_digest(settings),
+        input_arity=4,
+        output_arity=4,
+        input_lane_stride=1,
+        output_lane_stride=1,
+        input_layout=tuple(f"lane:{lane}:input" for lane in range(4)),
+        output_layout=tuple(f"lane:{lane}:output" for lane in range(4)),
+        f64_evaluator_manifest={
+            "kind": "symjit-application-evaluator",
+            "application_abi": artifact_writer.SYMJIT_APPLICATION_ABI,
+            "optimization_level": 2,
+            "settings": settings,
+            "input_len": 4,
+            "output_len": 4,
+            "application_path": f"{root}/application.symjit",
+            "plane_application": _plane_application(
+                root,
+                input_arity=4,
+                output_arity=4,
+            ),
+            "evaluator_state_path": f"{root}/exact.evaluator.bin",
+        },
+    )
+
+
+def _prepared_model(
+    tmp_path: Path,
+    *,
+    signatures: dict[int, str],
+    bundle_name: str,
+) -> tuple[Path, object]:
+    kernels = tuple(
+        _kernel(kernel_id, signature)
+        for kernel_id, signature in sorted(signatures.items())
+    )
+    settings = {"jit_optimization_level": 2}
+    pack = PreparedKernelPack(
+        backend="jit",
+        optimization_settings=settings,
+        producer={"distribution": "pyamplicol", "version": "test"},
+        dependency_abis={
+            "symjit_application": artifact_writer.SYMJIT_APPLICATION_ABI,
+            "symjit_plane_application": "pyamplicol-symjit-plane-application-v2",
+        },
+        provenance={"compiled_model": "test"},
+        target={
+            "portable": True,
+            "word_bits": 64,
+            "endianness": "little",
+            "target_triple": "symjit-storage-v3-portable",
+            "cpu_features": [],
+        },
+        resolver_manifest={
+            "abi": "pyamplicol-prepared-kernel-catalog-v1",
+            "model_name": "built-in-sm",
+        },
+        kernels=kernels,
+        kernel_variants=tuple(_variant(kernel) for kernel in kernels),
+    )
+    source_model = compile_model_source("built-in-sm", use_cache=False)
+    bundle = write_prepared_model_bundle(
+        tmp_path / bundle_name,
+        compiled_model=source_model.to_dict(),
+        kernel_pack=pack,
+        payloads={
+            path: f"payload:{path}".encode() for path in pack.referenced_payload_paths
+        },
+    )
+    return bundle, compile_model_source(bundle, use_cache=False)
+
+
+def _v3_process(
+    tmp_path: Path,
+    *,
+    process_id: str,
+    kernel_ids: frozenset[int],
+) -> EagerPlanV3ProcessArtifact:
+    runtime = tmp_path / f"{process_id}.pacbin"
+    runtime_bytes = f"native-eager-runtime:{process_id}".encode()
+    runtime.write_bytes(runtime_bytes)
+    return EagerPlanV3ProcessArtifact(
+        process_id=process_id,
+        expression="d d~ > z",
+        color_accuracy="full",
+        external_pdgs=(1, -1, 23),
+        aliases=(),
+        physics={
+            "schema_version": 1,
+            "kind": "pyamplicol-resolved-physics",
+            "process_id": process_id,
+        },
+        eager_runtime_path=runtime,
+        eager_runtime_size_bytes=len(runtime_bytes),
+        eager_runtime_sha256=hashlib.sha256(runtime_bytes).hexdigest(),
+        eager_runtime_member_count=3,
+        eager_runtime_unpacked_size_bytes=256,
+        eager_runtime_index_sha256="3" * 64,
+        lowering_input_sha256=hashlib.sha256(process_id.encode()).hexdigest(),
+        referenced_kernel_ids=kernel_ids,
+        inspection_summary={
+            "stage_count": 2,
+            "invocation_count": 3,
+            "attachment_count": 4,
+            "finalization_count": 2,
+            "closure_count": 1,
+            "selector_domain_count": 0,
+        },
+        point_tile_size=128,
+        workspace_mib=64,
+        dag_summary={
+            "current_count": 4,
+            "source_count": 3,
+            "interaction_count": 3,
+            "amplitude_root_count": 1,
+            "truncated": False,
+        },
+        validation_point=ValidationPointRecord(
+            process_id=process_id,
+            process="d d~ > z",
+            seed=7,
+            error="not sampled in writer test",
+        ),
+        generation_filters={},
+    )
+
+
+def _tree_snapshot(root: Path) -> dict[str, bytes]:
+    return {
+        path.relative_to(root).as_posix(): path.read_bytes()
+        for path in sorted(root.rglob("*"))
+        if path.is_file()
+    }
+
+
+def _inject_stale_eager_payload(output: Path) -> str:
+    stale_path = "model/eager-kernels/superseded/application.symjit"
+    manifest = load_manifest(output)
+    with ArtifactBuilder(output, mode="append") as builder:
+        builder.add_bytes(
+            stale_path,
+            b"superseded evaluator payload",
+            role="evaluator-state",
+            media_type="application/vnd.symjit.application",
+            target=manifest.producer["target"],
+        )
+        builder.finalize(
+            kind=manifest.kind,
+            producer=manifest.producer,
+            model=manifest.model,
+            configuration=manifest.configuration,
+            processes=manifest.processes,
+            default_process_id=manifest.default_process_id,
+            runtime=manifest.runtime,
+            dependencies=manifest.dependencies,
+            extensions=manifest.extensions,
+        )
+    return stale_path
+
+
+def test_schema_v3_writer_has_no_legacy_eager_process_variant() -> None:
+    assert not hasattr(artifact_writer, "EagerProcessArtifact")
+    assert "EagerProcessArtifact" not in artifact_writer.__all__
+    assert {
+        variant.__name__ for variant in get_args(artifact_writer.ProcessArtifact)
+    } == {
+        "CompiledProcessArtifact",
+        "EagerPlanV3ProcessArtifact",
+        "OnTheFlyProcessArtifact",
+        "RecurrenceProcessArtifact",
+    }
+
+
+def test_legacy_eager_capabilities_are_known_but_not_supported() -> None:
+    legacy = {
+        EAGER_DAG_F64_RUNTIME_CAPABILITY,
+        EAGER_LC_TOPOLOGY_REPLAY_RUNTIME_CAPABILITY,
+    }
+    assert legacy <= KNOWN_EVALUATOR_RUNTIME_CAPABILITIES
+    assert legacy.isdisjoint(EVALUATOR_RUNTIME_CAPABILITIES)
+
+
+def test_plan_v3_writer_filters_pack_and_appends_atomically(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        artifact_writer,
+        "_target_metadata",
+        lambda _config: ({"triple": "aarch64-apple-darwin", "cpu_features": []}, 1),
+    )
+    monkeypatch.setattr(
+        artifact_writer,
+        "_derive_eager_direct_descriptor",
+        lambda source, **_widths: b"direct-table:" + source,
+    )
+    source_revision = "a" * 40
+    native_inputs = "b" * 64
+    monkeypatch.setattr(
+        artifact_writer,
+        "active_source_revision",
+        lambda: source_revision,
+    )
+    monkeypatch.setattr(
+        artifact_writer,
+        "active_native_build_inputs_sha256",
+        lambda: native_inputs,
+    )
+    signatures = {
+        10: "a" * 64,
+        20: "b" * 64,
+        30: "c" * 64,
+    }
+    bundle, compiled_model = _prepared_model(
+        tmp_path,
+        signatures=signatures,
+        bundle_name="prepared",
+    )
+    configuration = _GenerationConfigProvenance.from_config(
+        RunConfig(
+            action=Action.GENERATE,
+            generation=GenerationConfig(emit_api_bundle=False),
+            evaluator=EvaluatorConfig(
+                execution_mode="eager",
+                jit=JITConfig(optimization_level=2),
+            ),
+        )
+    )
+    first = _v3_process(
+        tmp_path,
+        process_id="d_dbar_to_z",
+        kernel_ids=frozenset({10}),
+    )
+    output = tmp_path / "artifact"
+    progress: list[dict[str, object]] = []
+
+    write_schema_v3_artifact(
+        output,
+        mode="error",
+        source=ModelSource.from_path(bundle),
+        compiled_model=compiled_model,
+        configuration=configuration,
+        processes=(first,),
+        timings={"total": 0.1},
+        api_bundle_hook=None,
+        progress_callback=progress.append,
+    )
+
+    assert [event["step"] for event in progress] == [
+        "global payloads",
+        "prepared kernel pack",
+        "process payloads",
+        "publishing artifact",
+    ]
+    manifest = load_manifest(output)
+    portable_target = {
+        "triple": PORTABLE_64LE_TARGET,
+        "cpu_features": (),
+    }
+    assert manifest.producer["target"] == portable_target
+    targeted_payloads = [
+        record for record in manifest.payloads if record.target is not None
+    ]
+    assert targeted_payloads
+    assert all(record.target == portable_target for record in targeted_payloads)
+    structural_records = [
+        record
+        for record in manifest.payloads
+        if record.role == STRUCTURAL_SOURCE_PROOF_ROLE
+    ]
+    assert len(structural_records) == 1
+    structural = json.loads(
+        (output / structural_records[0].path).read_text(encoding="utf-8")
+    )
+    validate_generation_structural_proof(
+        structural,
+        artifact_root=output,
+        expected_process_id="d_dbar_to_z",
+        expected_source_revision=source_revision,
+        expected_native_build_inputs_sha256=native_inputs,
+    )
+    capabilities = {
+        artifact_writer.EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        artifact_writer.EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+    }
+    assert set(manifest.runtime["required_runtime_capabilities"]) == capabilities
+    execution = json.loads(
+        (output / "processes/d_dbar_to_z/execution.json").read_text(encoding="utf-8")
+    )
+    assert execution["eager_plan_abi"] == artifact_writer.EAGER_PLAN_V3_ABI
+    assert set(execution["required_runtime_capabilities"]) == capabilities
+    assert execution["plan"]["inspection_summary"] == first.inspection_summary
+
+    pack_identity = manifest.extensions["eager_prepared_pack"]
+    assert pack_identity["kind"] == "pyamplicol-prepared-kernel-pack-identity"
+    assert pack_identity["abi"] == "pyamplicol-prepared-kernel-pack-identity-v2"
+    assert pack_identity["kernel_count"] == 3
+    assert pack_identity["identity_sha256"] == (
+        prepared_kernel_pack_manifest_identity_sha256(
+            compiled_model.prepared_bundle.manifest  # type: ignore[union-attr]
+        )
+    )
+    pack = json.loads(
+        (output / "model/eager-kernel-pack.json").read_text(encoding="utf-8")
+    )
+    assert {kernel["kernel_id"] for kernel in pack["kernels"]} == {10}
+    assert {variant["base_kernel_id"] for variant in pack["kernel_variants"]} == {10}
+    assert pack["recurrence_template"] is None
+    assert pack["recurrence_direct_template"] is None
+    assert (
+        pack["kernels"][0]["f64_evaluator_manifest"]["direct_table"]["capability"]
+        == artifact_writer.EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY
+    )
+
+    declared = {record.path for record in manifest.payloads}
+    assert "model/eager-kernel-pack.json" in declared
+    assert "model/eager-kernels/kernels/10/eager-direct-table-descriptor-v1.bin" in (
+        declared
+    )
+    assert not any(path.endswith((".symjit", ".evaluator.bin")) for path in declared)
+    container_extension = manifest.extensions["evaluator_payload_container"]
+    with PacbinReader.open(output / "evaluators.pacbin") as container:
+        members = {member.logical_path for member in container.members}
+        assert container_extension == {
+            "kind": "pyamplicol-evaluator-payload-container",
+            "schema_version": 1,
+            "storage_abi": "pacbin-v1",
+            "path": "evaluators.pacbin",
+            "member_count": len(container.members),
+            "unpacked_size_bytes": sum(member.length for member in container.members),
+            "index_sha256": container.index.index_sha256,
+        }
+        assert any(
+            path.startswith("model/eager-kernels/kernels/10/") for path in members
+        )
+        assert not any(
+            path.startswith("model/eager-kernels/kernels/20/")
+            or path.startswith("model/eager-kernels/kernels/30/")
+            for path in members
+        )
+
+    stale_path = _inject_stale_eager_payload(output)
+    second = _v3_process(
+        tmp_path,
+        process_id="u_ubar_to_z",
+        kernel_ids=frozenset({20}),
+    )
+    write_schema_v3_artifact(
+        output,
+        mode="append",
+        source=ModelSource.from_path(bundle),
+        compiled_model=compiled_model,
+        configuration=configuration,
+        processes=(second,),
+        timings={"total": 0.2},
+        api_bundle_hook=None,
+    )
+
+    appended = load_manifest(output)
+    appended_structural_records = [
+        record
+        for record in appended.payloads
+        if record.role == STRUCTURAL_SOURCE_PROOF_ROLE
+    ]
+    assert {record.process_id for record in appended_structural_records} == {
+        "d_dbar_to_z",
+        "u_ubar_to_z",
+    }
+    for record in appended_structural_records:
+        structural = json.loads((output / record.path).read_text(encoding="utf-8"))
+        validate_generation_structural_proof(
+            structural,
+            artifact_root=output,
+            expected_process_id=str(record.process_id),
+            expected_source_revision=source_revision,
+            expected_native_build_inputs_sha256=native_inputs,
+        )
+    assert {str(record["id"]) for record in appended.processes} == {
+        "d_dbar_to_z",
+        "u_ubar_to_z",
+    }
+    assert appended.extensions["eager_prepared_pack"] == pack_identity
+    appended_pack = json.loads(
+        (output / "model/eager-kernel-pack.json").read_text(encoding="utf-8")
+    )
+    assert {kernel["kernel_id"] for kernel in appended_pack["kernels"]} == {10, 20}
+    assert {
+        variant["base_kernel_id"] for variant in appended_pack["kernel_variants"]
+    } == {10, 20}
+    assert stale_path not in {record.path for record in appended.payloads}
+    assert not (output / stale_path).exists()
+    with PacbinReader.open(output / "evaluators.pacbin") as container:
+        members = {member.logical_path for member in container.members}
+        assert stale_path not in members
+        assert any(
+            path.startswith("model/eager-kernels/kernels/10/") for path in members
+        )
+        assert any(
+            path.startswith("model/eager-kernels/kernels/20/") for path in members
+        )
+        assert not any(
+            path.startswith("model/eager-kernels/kernels/30/") for path in members
+        )
+
+    shifted_bundle, shifted_model = _prepared_model(
+        tmp_path,
+        signatures={
+            10: "d" * 64,
+            20: "e" * 64,
+            30: "f" * 64,
+        },
+        bundle_name="shifted",
+    )
+    rejected = _v3_process(
+        tmp_path,
+        process_id="rejected",
+        kernel_ids=frozenset({30}),
+    )
+    before = _tree_snapshot(output)
+    with pytest.raises(ValueError, match="prepared kernel pack identity differs"):
+        write_schema_v3_artifact(
+            output,
+            mode="append",
+            source=ModelSource.from_path(shifted_bundle),
+            compiled_model=shifted_model,
+            configuration=configuration,
+            processes=(rejected,),
+            timings={"total": 0.3},
+            api_bundle_hook=None,
+        )
+    assert _tree_snapshot(output) == before
+    assert not tuple(tmp_path.glob(".artifact.staging-*"))
+
+
+def test_append_rejects_legacy_eager_plan_v2_before_pack_rewrite(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    output = tmp_path / "legacy-eager"
+    legacy_capability = "rusticol.eager-dag.complex-f64.v1"
+    with ArtifactBuilder(output) as builder:
+        builder.add_bytes(
+            "config/requested.toml",
+            b"",
+            role="configuration-requested",
+            media_type="application/toml",
+        )
+        builder.add_bytes(
+            "config/effective.toml",
+            b"",
+            role="configuration-effective",
+            media_type="application/toml",
+        )
+        builder.add_json(
+            "processes/legacy/physics.json",
+            {"schema_version": 1},
+            role="runtime-physics",
+            process_id="legacy",
+        )
+        builder.add_json(
+            "runtime/evaluators.json",
+            {"schema_version": 3, "kind": "pyamplicol-runtime-execution-set"},
+            role="evaluator-manifest",
+        )
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer={
+                "distribution": "pyamplicol",
+                "version": "test",
+                "versions": {
+                    "python_api": 1,
+                    "toml": 1,
+                    "compiled_model": 9,
+                    "process_artifact": 3,
+                    "runtime_physics": 1,
+                    "symbolica_serialization": "test",
+                    "c_abi": 1,
+                },
+                "target": {"triple": "aarch64-apple-darwin", "cpu_features": []},
+            },
+            model={
+                "name": "built-in-sm",
+                "source_kind": "built-in-sm",
+                "content_sha256": "1" * 64,
+                "compiled_schema_version": 9,
+                "restriction": None,
+            },
+            configuration={
+                "toml_schema_version": 1,
+                "requested_path": "config/requested.toml",
+                "effective_path": "config/effective.toml",
+                "adjustments": [],
+            },
+            processes=(
+                {
+                    "id": "legacy",
+                    "expression": "d d~ > z",
+                    "color_accuracy": "full",
+                    "external_pdgs": [1, -1, 23],
+                    "physics_path": "processes/legacy/physics.json",
+                    "required_runtime_capabilities": [legacy_capability],
+                    "aliases": [],
+                },
+            ),
+            default_process_id="legacy",
+            runtime={
+                "engine": "rusticol",
+                "engine_version": "test",
+                "evaluator_manifest_path": "runtime/evaluators.json",
+                "api_bundle_path": None,
+                "required_runtime_capabilities": [legacy_capability],
+            },
+        )
+
+    assert load_manifest(output).runtime["required_runtime_capabilities"] == (
+        legacy_capability,
+    )
+    monkeypatch.setattr(
+        artifact_writer,
+        "_default_api_bundle_hook",
+        lambda: pytest.fail("legacy rejection must precede append preparation"),
+    )
+    opaque = object()
+
+    with pytest.raises(
+        ValueError,
+        match=r"legacy eager plan-v2 artifacts cannot be extended.*replace mode",
+    ):
+        artifact_writer.write_schema_v3_artifact(
+            output,
+            mode="append",
+            source=opaque,
+            compiled_model=opaque,
+            configuration=opaque,
+            processes=(opaque,),
+            timings={},
+        )
diff --git a/pyamplicol/tests/unit/test_eager_backward_live_planner.py b/pyamplicol/tests/unit/test_eager_backward_live_planner.py
new file mode 100644
index 0000000000..ef31de39bd
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_backward_live_planner.py
@@ -0,0 +1,447 @@
+# SPDX-License-Identifier: 0BSD
+"""Correctness contracts for eager backward/live-state DAG construction."""
+
+from __future__ import annotations
+
+import inspect
+import subprocess
+from collections import defaultdict
+from collections.abc import Mapping
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.config import EvaluatorConfig, RunConfig
+from pyamplicol.generation import service as service_module
+from pyamplicol.generation.dag_algorithms import prune_dag_to_amplitude_roots
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_types import (
+    AmplitudeRoot,
+    GenericDAG,
+    InteractionNode,
+)
+from pyamplicol.generation.runtime_schema import build_runtime_schema
+from pyamplicol.generation.service import GenerationBackend
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.base import Model
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.external import CompiledUFOModel
+from pyamplicol.models.loading import compile_model_source
+from pyamplicol.processes.ir import CanonicalProcessIR
+from pyamplicol.processes.model import build_model_process_ir
+
+_BACKWARD_PLANNER_PARAMETER = "backward_live_planning"
+_EXTERNAL_SM_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+_PARITY_CASES = (
+    ("d d~ > z g g g", "nlc", {"QCD": 3, "QED": 1}),
+    ("d d~ > z g g g", "full", {"QCD": 3, "QED": 1}),
+    ("d d~ > u u~ s s~ g", "nlc", {"QCD": 5, "QED": 0}),
+    ("d d~ > u u~ s s~ g", "full", {"QCD": 5, "QED": 0}),
+)
+
+
+def _compile_reference_and_eager(
+    process: str,
+    color_accuracy: str,
+    coupling_limits: Mapping[str, int],
+    *,
+    selected_source_helicities: Mapping[int, int] | None = None,
+) -> tuple[Model, GenericDAG, GenericDAG, GenericDAG]:
+    model = BuiltinSMModel()
+    process_ir = build_process_ir(process, color_accuracy=color_accuracy)
+    options = {
+        "model": model,
+        "max_coupling_orders": coupling_limits,
+        "selected_source_helicities": selected_source_helicities,
+        "online_evaluation_reuse": True,
+    }
+    forward = compile_generic_dag(process_ir, **options)
+    reference = prune_dag_to_amplitude_roots(forward)
+    eager = compile_generic_dag(
+        process_ir,
+        **options,
+        backward_live_planning=True,
+    )
+    return model, forward, reference, eager
+
+
+def _interaction_signature(
+    dag: GenericDAG,
+    interaction: InteractionNode,
+) -> tuple[object, ...]:
+    return (
+        interaction.vertex_kind,
+        interaction.vertex_particles,
+        dag.currents[interaction.left_id].index,
+        dag.currents[interaction.right_id].index,
+        dag.currents[interaction.result_id].index,
+        interaction.coupling,
+        interaction.color_weight,
+        interaction.lowering_backend,
+        interaction.full_tensor_network_ready,
+        interaction.evaluation_factor,
+    )
+
+
+def _root_signature(
+    dag: GenericDAG,
+    root: AmplitudeRoot,
+) -> tuple[object, ...]:
+    return (
+        root.kind,
+        dag.currents[root.left_id].index,
+        dag.currents[root.right_id].index,
+        root.color_weight,
+        root.contraction_ir,
+        root.color_sector_id,
+        root.vertex_kind,
+        root.vertex_particles,
+        root.coupling,
+        root.helicity_weight,
+    )
+
+
+def _evaluation_group_partition(
+    dag: GenericDAG,
+) -> set[frozenset[tuple[object, ...]]]:
+    by_group: dict[int | None, set[tuple[object, ...]]] = defaultdict(set)
+    for interaction in dag.interactions:
+        by_group[interaction.evaluation_group_id].add(
+            _interaction_signature(dag, interaction)
+        )
+    return {frozenset(group) for group in by_group.values()}
+
+
+def _assert_semantic_topology_parity(
+    reference: GenericDAG,
+    eager: GenericDAG,
+) -> None:
+    """Compare topology independently of traversal-assigned integer IDs."""
+
+    reference_currents = {
+        (
+            current.index,
+            current.dimension,
+            current.is_source,
+            current.source_leg_label,
+            current.source_helicity,
+        )
+        for current in reference.currents
+    }
+    eager_currents = {
+        (
+            current.index,
+            current.dimension,
+            current.is_source,
+            current.source_leg_label,
+            current.source_helicity,
+        )
+        for current in eager.currents
+    }
+    reference_interactions = {
+        _interaction_signature(reference, interaction)
+        for interaction in reference.interactions
+    }
+    eager_interactions = {
+        _interaction_signature(eager, interaction)
+        for interaction in eager.interactions
+    }
+    reference_roots = {
+        _root_signature(reference, root) for root in reference.amplitude_roots
+    }
+    eager_roots = {_root_signature(eager, root) for root in eager.amplitude_roots}
+
+    assert eager.process == reference.process
+    assert eager.color_plan == reference.color_plan
+    assert eager_currents == reference_currents
+    assert eager_interactions == reference_interactions
+    assert eager_roots == reference_roots
+    assert _evaluation_group_partition(eager) == _evaluation_group_partition(
+        reference
+    )
+    assert (
+        eager.truncated,
+        eager.helicity_coverage,
+        eager.color_coverage,
+        eager.selected_source_helicities,
+    ) == (
+        reference.truncated,
+        reference.helicity_coverage,
+        reference.color_coverage,
+        reference.selected_source_helicities,
+    )
+
+
+def _assert_runtime_physics_equivalent(
+    reference: Mapping[str, object],
+    eager: Mapping[str, object],
+) -> None:
+    reference_without_reduction = dict(reference)
+    eager_without_reduction = dict(eager)
+    reference_reduction = reference_without_reduction.pop("reduction")
+    eager_reduction = eager_without_reduction.pop("reduction")
+    assert eager_without_reduction == reference_without_reduction
+    assert isinstance(reference_reduction, Mapping)
+    assert isinstance(eager_reduction, Mapping)
+    assert eager_reduction.get("kind") == reference_reduction.get("kind")
+
+    def group_records(payload: Mapping[str, object]) -> list[Mapping[str, object]]:
+        groups = payload.get("groups")
+        assert isinstance(groups, list)
+        records = [group for group in groups if isinstance(group, Mapping)]
+        assert len(records) == len(groups)
+        return records
+
+    def semantic_groups(
+        groups: list[Mapping[str, object]],
+    ) -> set[tuple[object, ...]]:
+        return {
+            (
+                group["representative_helicity_id"],
+                group["representative_color_id"],
+                tuple(group["physical_helicity_ids"]),
+                tuple(group["physical_color_ids"]),
+            )
+            for group in groups
+        }
+
+    eager_groups = group_records(eager_reduction)
+    reference_groups = group_records(reference_reduction)
+    assert len(eager_groups) == len(reference_groups)
+    assert semantic_groups(eager_groups) == semantic_groups(reference_groups)
+
+
+def _forbidden_backend_call(*_args: object, **_kwargs: object) -> None:
+    raise AssertionError("backward DAG planning invoked a backend compiler")
+
+
+def test_backward_live_planning_is_keyword_only_and_opt_in() -> None:
+    parameter = inspect.signature(compile_generic_dag).parameters.get(
+        _BACKWARD_PLANNER_PARAMETER
+    )
+
+    assert parameter is not None
+    assert parameter.kind is inspect.Parameter.KEYWORD_ONLY
+    assert parameter.default is False
+
+
+@pytest.mark.parametrize("backward_live_planning", (False, True))
+def test_dag_progress_reports_stage_boundaries_for_both_planners(
+    backward_live_planning: bool,
+) -> None:
+    events: list[Mapping[str, str | int]] = []
+    compile_generic_dag(
+        build_process_ir("d d~ > z g", color_accuracy="nlc"),
+        model=BuiltinSMModel(),
+        online_evaluation_reuse=True,
+        backward_live_planning=backward_live_planning,
+        progress_callback=events.append,
+    )
+
+    steps = [event["step"] for event in events]
+    assert "colour-plan" in steps
+    assert "reachability" in steps
+    assert "source-currents" in steps
+    assert "recursion" in steps
+    assert "amplitude-closure" in steps
+    assert steps[-1] == "symmetry-reuse"
+    recursion = [event for event in events if event["step"] == "recursion"]
+    assert recursion
+    assert all("mask_index" in event and "mask_total" in event for event in recursion)
+    assert all("current_count" in event for event in recursion)
+    assert all("interaction_count" in event for event in recursion)
+
+
+@pytest.mark.parametrize(
+    ("process", "color_accuracy", "coupling_limits"),
+    _PARITY_CASES,
+)
+def test_backward_live_planner_matches_post_pruned_topology_and_physics(
+    process: str,
+    color_accuracy: str,
+    coupling_limits: Mapping[str, int],
+) -> None:
+    model, forward, reference, eager = _compile_reference_and_eager(
+        process,
+        color_accuracy,
+        coupling_limits,
+    )
+
+    _assert_semantic_topology_parity(reference, eager)
+    assert prune_dag_to_amplitude_roots(eager) == eager
+    assert build_runtime_schema(eager, model, process_id="parity")["physics"] == (
+        build_runtime_schema(reference, model, process_id="parity")["physics"]
+    )
+    if "u u~ s s~" in process:
+        assert len(forward.currents) > len(eager.currents)
+        assert len(forward.interactions) > len(eager.interactions)
+
+
+@pytest.mark.parametrize("color_accuracy", ("nlc", "full"))
+def test_backward_live_planner_preserves_selected_helicity_topology(
+    color_accuracy: str,
+) -> None:
+    model, forward, reference, eager = _compile_reference_and_eager(
+        "d d~ > u u~ s s~ g",
+        color_accuracy,
+        {"QCD": 5, "QED": 0},
+        selected_source_helicities={1: -1},
+    )
+
+    _assert_semantic_topology_parity(reference, eager)
+    assert eager.helicity_coverage == "selected"
+    reference_physics = build_runtime_schema(
+        reference,
+        model,
+        process_id="selected",
+    )["physics"]
+    _assert_runtime_physics_equivalent(
+        reference_physics,
+        build_runtime_schema(forward, model, process_id="selected")["physics"],
+    )
+    _assert_runtime_physics_equivalent(
+        reference_physics,
+        build_runtime_schema(eager, model, process_id="selected")["physics"],
+    )
+
+
+@pytest.mark.parametrize("color_accuracy", ("nlc", "full"))
+def test_backward_live_planner_matches_pruned_ufo_sm(color_accuracy: str) -> None:
+    compiled = compile_model_source(
+        _EXTERNAL_SM_ROOT / "sm.json",
+        restriction=str((_EXTERNAL_SM_ROOT / "restrict_default.json").resolve()),
+        use_cache=True,
+    )
+    model = CompiledUFOModel(compiled)
+    process = build_model_process_ir(
+        "d d~ > u u~ s s~ g",
+        compiled.ir,
+        color_accuracy=color_accuracy,
+    )
+    options = {
+        "model": model,
+        "max_coupling_orders": {"QCD": 5, "QED": 0},
+        "online_evaluation_reuse": True,
+    }
+    reference = prune_dag_to_amplitude_roots(compile_generic_dag(process, **options))
+    eager = compile_generic_dag(
+        process,
+        **options,
+        backward_live_planning=True,
+    )
+
+    _assert_semantic_topology_parity(reference, eager)
+    _assert_runtime_physics_equivalent(
+        build_runtime_schema(reference, model, process_id="ufo-sm")["physics"],
+        build_runtime_schema(eager, model, process_id="ufo-sm")["physics"],
+    )
+
+
+def test_backward_live_planner_is_deterministic() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir(
+        "d d~ > u u~ s s~ g",
+        color_accuracy="nlc",
+    )
+    options = {
+        "model": model,
+        "max_coupling_orders": {"QCD": 5, "QED": 0},
+        "online_evaluation_reuse": True,
+        "backward_live_planning": True,
+    }
+
+    assert compile_generic_dag(process, **options) == compile_generic_dag(
+        process,
+        **options,
+    )
+
+
+def test_backward_live_planner_never_compiles_backend_evaluators(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol.evaluators import symbolica_compile
+    from pyamplicol.generation import stage_artifacts
+
+    monkeypatch.setattr(
+        symbolica_compile,
+        "_compile_symbolica_outputs",
+        _forbidden_backend_call,
+    )
+    monkeypatch.setattr(
+        stage_artifacts,
+        "_compile_stage_evaluator_artifact",
+        _forbidden_backend_call,
+    )
+    monkeypatch.setattr(
+        stage_artifacts,
+        "build_and_write_generic_stage_evaluator_artifacts",
+        _forbidden_backend_call,
+    )
+    monkeypatch.setattr(subprocess, "run", _forbidden_backend_call)
+    monkeypatch.setattr(subprocess, "Popen", _forbidden_backend_call)
+    try:
+        from symbolica import Expression
+    except ImportError:  # pragma: no cover - minimal source-only environment
+        Expression = None
+    if Expression is not None:
+        for name in dir(Expression):
+            if name == "evaluator" or name.startswith("evaluator_"):
+                monkeypatch.setattr(Expression, name, _forbidden_backend_call)
+
+    _model, _forward, reference, eager = _compile_reference_and_eager(
+        "d d~ > u u~ s s~ g",
+        "nlc",
+        {"QCD": 5, "QED": 0},
+    )
+
+    _assert_semantic_topology_parity(reference, eager)
+
+
+@pytest.mark.parametrize(
+    ("execution_mode", "expected_backward_planning"),
+    (("compiled", False), ("eager", True)),
+)
+def test_generation_service_enables_backward_planner_only_for_eager_mode(
+    monkeypatch: pytest.MonkeyPatch,
+    execution_mode: str,
+    expected_backward_planning: bool,
+) -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > z g g g")
+    reference = compile_generic_dag(process, model=model)
+    observed: list[bool] = []
+
+    def capture_compile(
+        process_ir: CanonicalProcessIR,
+        *,
+        model: Model,
+        **options: object,
+    ) -> GenericDAG:
+        assert process_ir is process
+        observed.append(bool(options.get(_BACKWARD_PLANNER_PARAMETER, False)))
+        return reference
+
+    monkeypatch.setattr(service_module, "compile_generic_dag", capture_compile)
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            evaluator=EvaluatorConfig(execution_mode=execution_mode),
+        ),
+        None,
+    )
+
+    compiled, _coverage = backend._compile_concrete_process(process, model)
+
+    assert compiled.currents == reference.currents
+    assert compiled.interactions == reference.interactions
+    assert compiled.amplitude_roots == reference.amplitude_roots
+    assert compiled.lc_topology_replay is not None
+    assert observed == [expected_backward_planning]
diff --git a/pyamplicol/tests/unit/test_eager_benchmark_matrix.py b/pyamplicol/tests/unit/test_eager_benchmark_matrix.py
new file mode 100644
index 0000000000..c0a3d11b26
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_benchmark_matrix.py
@@ -0,0 +1,400 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import argparse
+import subprocess
+from types import SimpleNamespace
+
+import pytest
+
+from tools.developer import eager_artifact_compare as artifact_compare
+from tools.developer import eager_benchmark_matrix as matrix
+
+
+def test_failed_command_reports_stdout_and_stderr(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class FailedProcess:
+        returncode = 134
+        pid = 123
+
+        def communicate(self, *, timeout: float) -> tuple[str, str]:
+            assert timeout == 10.0
+            return "native stdout detail", "watchdog stderr detail"
+
+    monkeypatch.setattr(subprocess, "Popen", lambda *args, **kwargs: FailedProcess())
+
+    with pytest.raises(matrix.MatrixError) as failure:
+        matrix._run_json(
+            ("python", "command.py"),
+            timeout=10.0,
+            memory_limit_gib=30.0,
+            environment={},
+        )
+
+    message = str(failure.value)
+    assert "stdout (tail):\nnative stdout detail" in message
+    assert "stderr (tail):\nwatchdog stderr detail" in message
+
+
+def test_smoke_suite_selects_the_two_bounded_cases() -> None:
+    selected = matrix._selected_cases("smoke", ())
+
+    assert [case.key for case in selected] == ["dd_z_3g", "dd_3q_1g"]
+    assert all(case.smoke for case in selected)
+
+
+def test_suite_defaults_keep_scalar_batch_for_milestone_only() -> None:
+    smoke = matrix.parser().parse_args(
+        ["--builtin-pack", "pack", "--output-root", "output"]
+    )
+    milestone = matrix.parser().parse_args(
+        [
+            "--suite",
+            "milestone",
+            "--builtin-pack",
+            "pack",
+            "--output-root",
+            "output",
+        ]
+    )
+
+    assert smoke.batch_sizes is None
+    assert milestone.batch_sizes is None
+    assert matrix.SMOKE_BATCH_SIZES == (128, 1024)
+    assert matrix.DEFAULT_BATCH_SIZES == (1, 128, 1024)
+
+
+def test_explicit_case_selection_preserves_request_order() -> None:
+    selected = matrix._selected_cases("milestone", ("dd_tt_3g", "dd_z_3g"))
+
+    assert [case.key for case in selected] == ["dd_tt_3g", "dd_z_3g"]
+
+
+def test_unknown_case_fails_closed() -> None:
+    with pytest.raises(matrix.MatrixError, match="unknown process case"):
+        matrix._selected_cases("smoke", ("not-a-case",))
+
+
+def test_lc_workloads_choose_computed_nonzero_selectors() -> None:
+    physics = {
+        "color_components": [
+            {"id": "flow:zero", "computed": False},
+            {
+                "id": "flow:chosen",
+                "computed": True,
+                "word": [2, 1],
+            },
+        ],
+        "helicities": [
+            {"id": "h:zero", "computed": True, "structural_zero": True},
+            {
+                "id": "h:chosen",
+                "computed": True,
+                "structural_zero": False,
+                "values": [-1, 1],
+            },
+        ],
+        "external_particles": [{"label": 1}, {"label": 2}],
+    }
+
+    assert matrix._workloads("lc", physics) == (
+        {
+            "name": "single-flow-helicity-sum",
+            "selectors": {"color_flow": "flow:chosen"},
+            "compiled_specialization": {
+                "reference_color_order": (2, 1),
+                "selected_color_sector_ids": (0,),
+            },
+        },
+        {
+            "name": "all-flow-single-helicity",
+            "selectors": {"helicity": "h:chosen"},
+            "compiled_specialization": {
+                "selected_source_helicities": {1: -1, 2: 1},
+            },
+        },
+    )
+
+
+def test_contracted_color_has_one_summed_workload() -> None:
+    assert matrix._workloads("nlc", {}) == ({"name": "summed", "selectors": {}},)
+    assert matrix._workloads("full", {}) == ({"name": "summed", "selectors": {}},)
+
+
+def test_generation_command_keeps_compiled_and_eager_modes_explicit() -> None:
+    command = matrix._generation_command(
+        matrix.Path("python"),
+        process="d d~ > z g",
+        artifact=matrix.Path("artifact"),
+        model=matrix.Path("model.pyamplicol-model"),
+        color="full",
+        execution_mode="eager",
+    )
+
+    assert command[0] == "python"
+    assert command[command.index("--execution-mode") + 1] == "eager"
+    assert command[command.index("--color-accuracy") + 1] == "full"
+    assert command[command.index("--jit-optimization-level") + 1] == "3"
+    assert "--no-post-build-validation" in command
+
+
+def test_generation_command_encodes_private_compiled_specialization() -> None:
+    command = matrix._generation_command(
+        matrix.Path("python"),
+        process="d d~ > z g",
+        artifact=matrix.Path("artifact"),
+        model="built-in-sm",
+        color="lc",
+        execution_mode="compiled",
+        process_overrides={
+            "reference_color_order": (2, 1, 3, 4),
+            "selected_color_sector_ids": (0,),
+            "selected_source_helicities": {1: -1, 2: 1},
+        },
+    )
+
+    overrides = [
+        command[index + 1]
+        for index, value in enumerate(command)
+        if value == "--set"
+    ]
+    assert overrides == [
+        "process.reference_color_order=[2,1,3,4]",
+        "process.selected_color_sector_ids=[0]",
+        'process.selected_source_helicities={"1"=-1,"2"=1}',
+    ]
+
+
+def test_profile_command_encodes_both_lc_selector_axes() -> None:
+    command = matrix._profile_command(
+        matrix.Path("python"),
+        artifact=matrix.Path("artifact"),
+        process_id="process",
+        batch_size=1024,
+        target_runtime=5.0,
+        minimum_samples=5,
+        selectors={"color_flow": "flow:1,2", "helicity": "h:-1,+1"},
+    )
+
+    assert command[command.index("--batch-size") + 1] == "1024"
+    assert command[command.index("--color-flow") + 1] == "flow:1,2"
+    assert command[command.index("--helicity") + 1] == "h:-1,+1"
+
+
+def test_comparison_command_isolates_exact_evaluation() -> None:
+    command = matrix._comparison_command(
+        matrix.Path("python"),
+        eager_artifact=matrix.Path("eager"),
+        compiled_artifact=matrix.Path("compiled"),
+        process_id="process",
+        selectors={"color_flow": "flow:1,2", "helicity": "h:-1,+1"},
+        compiled_selectors="none",
+    )
+
+    assert command[:3] == (
+        "python",
+        "-m",
+        "tools.developer.eager_artifact_compare",
+    )
+    assert command[command.index("--compiled-selectors") + 1] == "none"
+    assert command[command.index("--color-flow") + 1] == "flow:1,2"
+    assert command[command.index("--helicity") + 1] == "h:-1,+1"
+
+
+def test_ufo_model_requires_source_and_pack(tmp_path: matrix.Path) -> None:
+    arguments = argparse.Namespace(
+        models=("ufo-sm",),
+        builtin_pack=tmp_path / "builtin.pyamplicol-model",
+        ufo_source=None,
+        ufo_pack=None,
+    )
+
+    with pytest.raises(matrix.MatrixError, match="requires both"):
+        matrix._model_specs(arguments)
+
+
+def test_relative_difference_handles_zero_values() -> None:
+    assert artifact_compare._relative_difference(0j, 0j) == 0.0
+    assert (
+        artifact_compare._relative_difference(1 + 0j, 1 + 1.0e-13j)
+        < 1.1e-13
+    )
+
+
+def test_resolved_comparison_checks_every_component_and_identifier() -> None:
+    baseline = SimpleNamespace(
+        helicity_ids=("h0", "h1"),
+        color_ids=("c0", "c1"),
+        values=((((1 + 0j), (2 + 0j)), ((3 + 0j), (4 + 0j))),),
+    )
+    matching = SimpleNamespace(
+        helicity_ids=("h0", "h1"),
+        color_ids=("c0", "c1"),
+        values=((((1 + 1.0e-14j), (2 + 0j)), ((3 + 0j), (4 + 0j))),),
+    )
+    different = SimpleNamespace(
+        helicity_ids=("h0", "h1"),
+        color_ids=("c0", "different"),
+        values=baseline.values,
+    )
+
+    comparison = artifact_compare._resolved_comparison(baseline, matching)
+    assert comparison["component_count"] == 4
+    assert comparison["passes"] is True
+    assert artifact_compare._resolved_comparison(baseline, different)["passes"] is False
+
+
+def test_generation_assessment_separates_hard_gates_and_soft_targets() -> None:
+    records = [
+        {
+            "case": {"key": "process"},
+            "model": "built-in",
+            "color": color,
+            "compiled_over_eager_core_generation": ratio,
+        }
+        for color, ratio in (("lc", 2.0), ("nlc", 20.0), ("full", 30.0))
+    ]
+
+    hard, soft = matrix._generation_assessment(records)
+
+    assert hard == {
+        "nlc_full_each_at_least_7x": True,
+        "lc_no_generation_regression": True,
+        "per_process_geometric_mean_at_least_7x": True,
+    }
+    assert soft == {
+        "nlc_full_each_at_least_10x": True,
+        "per_process_geometric_mean_at_least_10x": True,
+    }
+
+
+def test_generation_assessment_rejects_partial_matrix_and_reports_soft_miss() -> None:
+    records = [
+        {
+            "case": {"key": "process"},
+            "model": "built-in",
+            "color": "nlc",
+            "compiled_over_eager_core_generation": 9.99,
+        }
+    ]
+
+    hard, soft = matrix._generation_assessment(records)
+
+    assert hard == {
+        "nlc_full_each_at_least_7x": True,
+        "lc_no_generation_regression": False,
+        "per_process_geometric_mean_at_least_7x": False,
+    }
+    assert soft == {
+        "nlc_full_each_at_least_10x": False,
+        "per_process_geometric_mean_at_least_10x": False,
+    }
+
+
+def test_reusable_runtime_gate_is_hard_only_for_n4_and_n5() -> None:
+    def record(n_final: int, ratio: float) -> dict[str, object]:
+        return {
+            "case": {"n_final": n_final},
+            "workloads": [
+                {
+                    "profiles": [
+                        {
+                            "batch_size": batch_size,
+                            "compiled_reusable_over_specialized_wall": ratio,
+                        }
+                        for batch_size in (128, 1024)
+                    ]
+                }
+            ],
+        }
+
+    assert matrix._reusable_runtime_gate([record(4, 1.24), record(5, 1.25)])
+    assert not matrix._reusable_runtime_gate([record(4, 1.251)])
+    assert matrix._reusable_runtime_gate([record(5, 1.20), record(7, 4.0)])
+
+
+def test_core_generation_excludes_model_loading_and_process_expansion() -> None:
+    assert (
+        matrix._core_generation_seconds(
+            {
+                "model-loading": 100.0,
+                "process-expansion": 50.0,
+                "dag": 2.0,
+                "jit": 3.0,
+            }
+        )
+        == 5.0
+    )
+
+
+def test_watchdog_peak_parser_uses_last_guarded_command() -> None:
+    stderr = "\n".join(
+        (
+            "memory-watchdog: command finished exit=0 peak_rss=1.250 GiB",
+            "memory-watchdog: command finished exit=0 peak_rss=2.500 GiB",
+        )
+    )
+
+    assert matrix._watchdog_peak_gib(stderr) == 2.5
+    assert matrix._watchdog_peak_gib("no watchdog result") is None
+
+
+def test_eager_topology_accepts_unreported_plan_v3_maximum_fanout(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    process = SimpleNamespace(
+        execution_mode="eager",
+        maximum_fanout=None,
+        **{
+            field: index
+            for index, field in enumerate(matrix._TOPOLOGY_FIELDS, start=1)
+            if field != "maximum_fanout"
+        },
+    )
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.inspect_artifact",
+        lambda _artifact: SimpleNamespace(processes=(process,)),
+    )
+
+    topology = matrix._eager_topology(matrix.Path("artifact"))
+
+    assert topology == {
+        field: index
+        for index, field in enumerate(matrix._TOPOLOGY_FIELDS, start=1)
+        if field != "maximum_fanout"
+    }
+
+
+def test_topology_gate_compares_equivalent_models_per_process_and_color() -> None:
+    topology = {field: index for index, field in enumerate(matrix._TOPOLOGY_FIELDS)}
+    records = [
+        {
+            "case": {"key": "process"},
+            "color": "nlc",
+            "model": model,
+            "eager_topology": topology,
+        }
+        for model in ("built-in", "ufo-sm")
+    ]
+
+    assert matrix._topology_gate(records, require_ufo=True)
+    assert matrix._topology_gate(records[:1], require_ufo=False)
+
+
+def test_topology_gate_rejects_missing_or_different_ufo_plan() -> None:
+    topology = {field: index for index, field in enumerate(matrix._TOPOLOGY_FIELDS)}
+    built_in = {
+        "case": {"key": "process"},
+        "color": "full",
+        "model": "built-in",
+        "eager_topology": topology,
+    }
+    ufo = {
+        **built_in,
+        "model": "ufo-sm",
+        "eager_topology": {**topology, "invocation_count": 999},
+    }
+
+    assert not matrix._topology_gate((built_in,), require_ufo=True)
+    assert not matrix._topology_gate((built_in, ufo), require_ufo=True)
diff --git a/pyamplicol/tests/unit/test_eager_columnar.py b/pyamplicol/tests/unit/test_eager_columnar.py
new file mode 100644
index 0000000000..7ca1a12853
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_columnar.py
@@ -0,0 +1,659 @@
+# SPDX-License-Identifier: 0BSD
+"""Contracts for the Python-to-Rust eager lowering input."""
+
+from __future__ import annotations
+
+import json
+import struct
+from collections.abc import Mapping
+from dataclasses import dataclass, replace
+
+import numpy as np
+import pytest
+
+from pyamplicol.color import (
+    build_color_contraction_plan,
+    build_lc_topology_replay_plan,
+)
+from pyamplicol.color.plan import (
+    build_color_plan,
+    build_color_topology_replay_certificate,
+)
+from pyamplicol.generation.dag_algorithms import (
+    prune_global_helicity_flip_equivalent_roots,
+)
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_types import GenericDAG
+from pyamplicol.generation.eager_columnar import (
+    EAGER_LOWERING_INPUT_ABI,
+    EAGER_LOWERING_INPUT_SCHEMA_SHA256,
+    FACTOR_EXACT_SOURCE_BINARY64,
+    FACTOR_EXACT_SOURCE_CANONICAL_IR,
+    EagerColumn,
+    EagerColumnarInputError,
+    EagerColumnarTable,
+    EagerLoweringInputV1,
+    build_eager_lowering_input_v1,
+)
+from pyamplicol.generation.eager_lowering import MappingEagerKernelResolver
+from pyamplicol.generation.helicity_materialization import (
+    materialize_helicity_recurrence,
+)
+from pyamplicol.generation.helicity_replay import build_helicity_recurrence_plan
+from pyamplicol.generation.runtime_amplitudes import _amplitude_groups
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.base import Model
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+@dataclass(frozen=True, slots=True)
+class _Case:
+    model: Model
+    dag: GenericDAG
+    resolver: MappingEagerKernelResolver
+
+
+def _resolver_for(
+    dag: GenericDAG,
+    model: Model,
+    *,
+    reverse: bool = False,
+) -> MappingEagerKernelResolver:
+    vertex_items = [
+        (kind, 100 + index)
+        for index, kind in enumerate(sorted(dag.required_vertex_kinds))
+    ]
+    propagator_keys: set[tuple[int, int]] = set()
+    for current in dag.currents:
+        propagator = model._propagator_ir(
+            current.index.particle_id,
+            current.index.chirality,
+        )
+        if propagator.applies_propagator:
+            propagator_keys.add((current.index.particle_id, current.index.chirality))
+    propagator_items = [
+        (key, 1_000 + index) for index, key in enumerate(sorted(propagator_keys))
+    ]
+    closure_items = [
+        ((str(root.kind), root.vertex_kind), 2_000 + root.id)
+        for root in dag.amplitude_roots
+        if root.kind != "direct-contraction"
+    ]
+    if reverse:
+        vertex_items.reverse()
+        propagator_items.reverse()
+        closure_items.reverse()
+    return MappingEagerKernelResolver(
+        vertex_kernels=dict(vertex_items),
+        propagator_kernels=dict(propagator_items),
+        closure_kernels=dict(closure_items),
+    )
+
+
+def _case(
+    expression: str = "d d~ > z g",
+    *,
+    recurrence: bool = False,
+    prepared_closure: bool = True,
+) -> _Case:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir(expression), model=model)
+    if recurrence:
+        reduced = prune_global_helicity_flip_equivalent_roots(dag, model)
+        proof = build_helicity_recurrence_plan(reduced, model)
+        assert proof is not None
+        materialization = materialize_helicity_recurrence(reduced, proof)
+        dag = replace(
+            materialization.dag,
+            helicity_recurrence=proof,
+            helicity_materialization=materialization,
+        )
+    if prepared_closure:
+        first = replace(
+            dag.amplitude_roots[0],
+            kind="prepared-closure",
+            vertex_kind=3,
+            vertex_particles=(21, 21, 21),
+            coupling=(1.0, 0.0),
+        )
+        dag = replace(dag, amplitude_roots=(first, *dag.amplitude_roots[1:]))
+    return _Case(model, dag, _resolver_for(dag, model))
+
+
+@pytest.fixture(scope="module")
+def low_case() -> _Case:
+    return _case()
+
+
+@pytest.fixture(scope="module")
+def lowering_input(low_case: _Case) -> EagerLoweringInputV1:
+    return build_eager_lowering_input_v1(
+        dag=low_case.dag,
+        model=low_case.model,
+        resolver=low_case.resolver,
+        process_id="columnar_contract",
+    )
+
+
+def _table_bytes(value: EagerLoweringInputV1) -> tuple[object, ...]:
+    return tuple(
+        (
+            table.name,
+            table.row_count,
+            tuple(
+                (
+                    column.name,
+                    column.values.dtype.str,
+                    column.values.shape,
+                    column.values.tobytes(order="C"),
+                )
+                for column in table.columns
+            ),
+        )
+        for table in value.tables
+    )
+
+
+def _f64_bits(value: float) -> str:
+    return f"{int.from_bytes(struct.pack('<d', value), 'little'):016x}"
+
+
+def test_contract_is_flat_immutable_little_endian_and_complete(
+    lowering_input: EagerLoweringInputV1,
+) -> None:
+    assert lowering_input.abi == EAGER_LOWERING_INPUT_ABI
+    assert tuple(table.name for table in lowering_input.tables) == tuple(
+        sorted(table.name for table in lowering_input.tables)
+    )
+    expected = {
+        "currents",
+        "sources",
+        "interactions",
+        "roots",
+        "contraction_coefficients",
+        "couplings",
+        "model_parameters",
+        "helicity_selectors",
+        "color_selectors",
+        "coherent_groups",
+        "reduction_members",
+        "color_contraction_entries",
+        "exact_factors",
+        "momentum_masks",
+        "bitset_ranges",
+        "bitset_words",
+    }
+    assert expected <= {table.name for table in lowering_input.tables}
+    assert not isinstance(lowering_input.string_catalog, list)
+    assert not isinstance(lowering_input.canonical_ir_catalog, list)
+    assert not any(isinstance(value, Mapping) for value in lowering_input.tables)
+
+    for table in lowering_input.tables:
+        for column in table.columns:
+            values = column.values
+            assert values.dtype != np.dtype("O")
+            assert values.flags.c_contiguous
+            assert not values.flags.writeable
+            assert values.dtype.byteorder in {"<", "|", "="}
+
+    assert lowering_input.schema_sha256 == EAGER_LOWERING_INPUT_SCHEMA_SHA256
+
+
+def test_contract_bytes_and_digest_ignore_resolver_mapping_order(
+    low_case: _Case,
+    lowering_input: EagerLoweringInputV1,
+) -> None:
+    reordered = build_eager_lowering_input_v1(
+        dag=low_case.dag,
+        model=low_case.model,
+        resolver=_resolver_for(low_case.dag, low_case.model, reverse=True),
+        process_id="columnar_contract",
+    )
+
+    assert reordered.digest == lowering_input.digest
+    assert reordered.string_catalog == lowering_input.string_catalog
+    assert reordered.canonical_ir_catalog == lowering_input.canonical_ir_catalog
+    assert _table_bytes(reordered) == _table_bytes(lowering_input)
+
+
+def test_contract_rejects_an_out_of_range_exact_ir_reference(
+    lowering_input: EagerLoweringInputV1,
+) -> None:
+    factors = lowering_input.table("exact_factors")
+    bad_values = factors.column("exact_ir_id").copy()
+    bad_values[0] = len(lowering_input.canonical_ir_catalog)
+    bad_values.flags.writeable = False
+    bad_columns = tuple(
+        EagerColumn(column.name, bad_values) if column.name == "exact_ir_id" else column
+        for column in factors.columns
+    )
+    bad_table = EagerColumnarTable(factors.name, factors.row_count, bad_columns)
+    tables = tuple(
+        bad_table if table.name == factors.name else table
+        for table in lowering_input.tables
+    )
+
+    with pytest.raises(EagerColumnarInputError, match="absent row"):
+        EagerLoweringInputV1(
+            abi=lowering_input.abi,
+            process_key=lowering_input.process_key,
+            model_name=lowering_input.model_name,
+            string_catalog=lowering_input.string_catalog,
+            canonical_ir_catalog=lowering_input.canonical_ir_catalog,
+            tables=tables,
+        )
+
+
+def test_extraction_never_calls_runtime_schema_layout(
+    monkeypatch: pytest.MonkeyPatch,
+    low_case: _Case,
+) -> None:
+    from pyamplicol.generation import runtime_schema
+
+    def forbidden(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("column extraction called runtime-schema construction")
+
+    monkeypatch.setattr(runtime_schema, "build_runtime_schema_layout", forbidden)
+    result = build_eager_lowering_input_v1(
+        dag=low_case.dag,
+        model=low_case.model,
+        resolver=low_case.resolver,
+    )
+    assert result.table("interactions").row_count == len(low_case.dag.interactions)
+
+
+def test_checked_u32_rejects_an_overflowing_dag_id(low_case: _Case) -> None:
+    overflowing = replace(low_case.dag.currents[0], id=1 << 32)
+    dag = replace(low_case.dag, currents=(overflowing, *low_case.dag.currents[1:]))
+
+    with pytest.raises(EagerColumnarInputError, match="does not fit u32"):
+        build_eager_lowering_input_v1(
+            dag=dag,
+            model=low_case.model,
+            resolver=_resolver_for(dag, low_case.model),
+        )
+
+
+def test_arbitrary_width_masks_are_flat_u64_words(low_case: _Case) -> None:
+    high_mask = (1 << 130) | (1 << 65) | 1
+    index = replace(
+        low_case.dag.currents[0].index,
+        momentum_mask=high_mask,
+        helicity_ancestry=high_mask,
+    )
+    current = replace(low_case.dag.currents[0], index=index)
+    dag = replace(low_case.dag, currents=(current, *low_case.dag.currents[1:]))
+    result = build_eager_lowering_input_v1(
+        dag=dag,
+        model=low_case.model,
+        resolver=_resolver_for(dag, low_case.model),
+    )
+
+    current_table = result.table("currents")
+    bitset_id = int(current_table.column("momentum_mask_bitset_id")[0])
+    ranges = result.table("bitset_ranges")
+    words = result.table("bitset_words").column("value")
+    start = int(ranges.column("start")[bitset_id])
+    count = int(ranges.column("count")[bitset_id])
+    rebuilt = sum(int(words[start + index]) << (64 * index) for index in range(count))
+
+    assert count == 3
+    assert rebuilt == high_mask
+    assert words.dtype.str == "<u8"
+
+
+def test_all_f64_payloads_have_exact_factor_references(
+    lowering_input: EagerLoweringInputV1,
+) -> None:
+    factors = lowering_input.table("exact_factors")
+    factor_count = factors.row_count
+    exact_ir_ids = factors.column("exact_ir_id")
+    sources = factors.column("exact_source")
+
+    assert factor_count > 0
+    assert len(exact_ir_ids) == factor_count
+    assert set(int(value) for value in sources) <= {
+        FACTOR_EXACT_SOURCE_BINARY64,
+        FACTOR_EXACT_SOURCE_CANONICAL_IR,
+    }
+    for row in range(factor_count):
+        payload = json.loads(
+            lowering_input.canonical_ir_catalog[int(exact_ir_ids[row])]
+        )
+        real = float(factors.column("real")[row])
+        imaginary = float(factors.column("imaginary")[row])
+        if int(sources[row]) == FACTOR_EXACT_SOURCE_BINARY64:
+            assert payload == {
+                "abi": "pyamplicol-exact-factor-v1",
+                "imaginary_bits": _f64_bits(imaginary),
+                "kind": "complex-ieee754-binary64",
+                "real_bits": _f64_bits(real),
+            }
+        else:
+            assert payload["kind"] == "canonical-source-ir"
+            fallback = payload["f64_fallback"]
+            assert fallback["real_bits"] == _f64_bits(real)
+            assert fallback["imaginary_bits"] == _f64_bits(imaginary)
+
+    for table in lowering_input.tables:
+        for column in table.columns:
+            if column.name.endswith("factor_id"):
+                assert (
+                    column.values.size == 0 or int(column.values.max()) < factor_count
+                )
+
+    f64_columns = {
+        (table.name, column.name)
+        for table in lowering_input.tables
+        for column in table.columns
+        if column.values.dtype.str == "<f8"
+    }
+    assert f64_columns == {
+        ("exact_factors", "real"),
+        ("exact_factors", "imaginary"),
+        ("model_parameters", "default_value"),
+    }
+    parameter_table = lowering_input.table("model_parameters")
+    for row, factor_id in enumerate(parameter_table.column("default_factor_id")):
+        assert (
+            parameter_table.column("default_value")[row]
+            == factors.column("real")[int(factor_id)]
+        )
+        assert factors.column("imaginary")[int(factor_id)] == 0.0
+
+
+def test_runtime_couplings_use_canonical_parameter_ir(
+    lowering_input: EagerLoweringInputV1,
+) -> None:
+    couplings = lowering_input.table("couplings")
+    factors = lowering_input.table("exact_factors")
+    found = False
+    for factor_id in couplings.column("constant_factor_id"):
+        row = int(factor_id)
+        if int(factors.column("exact_source")[row]) != (
+            FACTOR_EXACT_SOURCE_CANONICAL_IR
+        ):
+            continue
+        payload = json.loads(
+            lowering_input.canonical_ir_catalog[int(factors.column("exact_ir_id")[row])]
+        )
+        source = payload["source"]
+        assert source["kind"] == "model-parameter-components"
+        assert any(
+            component["kind"] == "model-parameter" for component in source["components"]
+        )
+        found = True
+    assert found, "the electroweak fixture must exercise parameter-backed couplings"
+
+
+def test_contraction_and_crossing_factors_retain_source_ir_ownership(
+    lowering_input: EagerLoweringInputV1,
+) -> None:
+    factors = lowering_input.table("exact_factors")
+    coefficients = lowering_input.table("contraction_coefficients")
+    for row, factor_id in enumerate(coefficients.column("factor_id")):
+        assert (
+            factors.column("source_ir_id")[int(factor_id)]
+            == (coefficients.column("contraction_ir_id")[row])
+        )
+
+    sources = lowering_input.table("sources")
+    for row, factor_id in enumerate(sources.column("crossing_factor_id")):
+        assert (
+            factors.column("source_ir_id")[int(factor_id)]
+            == (sources.column("crossing_ir_id")[row])
+        )
+
+
+def test_binary64_catalog_distinguishes_signed_zero() -> None:
+    case = _case("g g > g g", prepared_closure=False)
+    interactions = list(case.dag.interactions)
+    interactions[0] = replace(interactions[0], color_weight=(0.0, 0.0))
+    interactions[1] = replace(interactions[1], color_weight=(-0.0, 0.0))
+    dag = replace(case.dag, interactions=tuple(interactions))
+    result = build_eager_lowering_input_v1(
+        dag=dag,
+        model=case.model,
+        resolver=_resolver_for(dag, case.model),
+    )
+    table = result.table("interactions")
+    positive = int(table.column("color_factor_id")[0])
+    negative = int(table.column("color_factor_id")[1])
+    factors = result.table("exact_factors")
+
+    assert positive != negative
+    assert _f64_bits(float(factors.column("real")[positive])) == "0000000000000000"
+    assert _f64_bits(float(factors.column("real")[negative])) == "8000000000000000"
+
+
+def test_recurrence_proofs_and_structural_zeros_are_retained() -> None:
+    case = _case("g g > g g", recurrence=True, prepared_closure=False)
+    result = build_eager_lowering_input_v1(
+        dag=case.dag,
+        model=case.model,
+        resolver=case.resolver,
+    )
+    proof = case.dag.helicity_recurrence
+    materialization = case.dag.helicity_materialization
+    assert proof is not None
+    assert materialization is not None
+
+    assert result.table("helicity_domains").row_count == len(proof.selector_domains)
+    assert result.table("helicity_recurrence_classes").row_count == len(
+        proof.recurrence_classes
+    )
+    assert result.table("helicity_materialized_source_routes").row_count == len(
+        materialization.source_routes
+    )
+    assert result.table("helicity_materialized_amplitude_routes").row_count == len(
+        materialization.amplitude_routes
+    )
+    assert result.table("helicity_structural_zero_domains").row_count == len(
+        proof.structural_zero_selector_domain_ids
+    )
+    assert result.table("interaction_groups").row_count > 0
+    assert result.table("interaction_group_members").row_count == len(
+        case.dag.interactions
+    )
+
+
+def test_mixed_zero_group_selects_a_live_eager_representative() -> None:
+    case = _case("g g > g g", prepared_closure=False)
+    grouped: dict[int, list[object]] = {}
+    for interaction in case.dag.interactions:
+        assert interaction.evaluation_group_id is not None
+        grouped.setdefault(
+            int(interaction.evaluation_group_id),
+            [],
+        ).append(interaction)
+    members = next(value for value in grouped.values() if len(value) > 1)
+    zero_member = members[0]
+    live_member = members[1]
+    dag = replace(
+        case.dag,
+        interactions=tuple(
+            replace(interaction, evaluation_factor=(0.0, 0.0))
+            if interaction.id == zero_member.id
+            else interaction
+            for interaction in case.dag.interactions
+        ),
+    )
+
+    result = build_eager_lowering_input_v1(
+        dag=dag,
+        model=case.model,
+        resolver=_resolver_for(dag, case.model),
+    )
+    interaction_table = result.table("interactions")
+    compact_group_id = int(
+        interaction_table.column("evaluation_group_id")[zero_member.id]
+    )
+    group_table = result.table("interaction_groups")
+    member_table = result.table("interaction_group_members")
+    start = int(group_table.column("member_start")[compact_group_id])
+    count = int(group_table.column("member_count")[compact_group_id])
+    ordered_members = tuple(
+        int(value)
+        for value in member_table.column("interaction_id")[
+            start : start + count
+        ]
+    )
+
+    assert int(
+        group_table.column("representative_interaction_id")[
+            compact_group_id
+        ]
+    ) == live_member.id
+    assert ordered_members[0] == live_member.id
+    assert ordered_members[-1] == zero_member.id
+
+
+@pytest.mark.parametrize("color_accuracy", ("nlc", "full"))
+def test_contracted_color_reductions_are_columnar(color_accuracy: str) -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("g g > g g", color_accuracy=color_accuracy),
+        model=model,
+    )
+    result = build_eager_lowering_input_v1(
+        dag=dag,
+        model=model,
+        resolver=_resolver_for(dag, model),
+    )
+    metadata = result.table("color_contraction_metadata")
+    entries = result.table("color_contraction_entries")
+    reductions = result.table("reduction_members")
+    _group_ids, descriptors = _amplitude_groups(dag, dag.amplitude_roots)
+    contraction = build_color_contraction_plan(dag.color_plan, descriptors)
+
+    assert contraction is not None
+    assert contraction.repeated_block is not None
+    logical_entries = tuple(contraction.iter_logical_entries())
+    assert bool(metadata.column("present")[0])
+    assert bool(metadata.column("supported")[0])
+    assert entries.row_count == contraction.logical_entry_count > 0
+    assert tuple(int(value) for value in entries.column("left_group_id")) == tuple(
+        entry.left_group_id for entry in logical_entries
+    )
+    assert tuple(int(value) for value in entries.column("right_group_id")) == tuple(
+        entry.right_group_id for entry in logical_entries
+    )
+    assert reductions.row_count > 0
+    assert set(int(value) for value in reductions.column("color_selector_id")) == {0}
+    assert result.table("color_selectors").row_count == 1
+    factors = result.table("exact_factors")
+    for factor_id, entry in zip(
+        entries.column("weight_factor_id"), logical_entries, strict=True
+    ):
+        assert (
+            int(factors.column("exact_source")[factor_id])
+            == FACTOR_EXACT_SOURCE_CANONICAL_IR
+        )
+        ir_id = int(factors.column("exact_ir_id")[factor_id])
+        source = json.loads(result.canonical_ir_catalog[ir_id])["source"]
+        assert source == {
+            "kind": "rational-complex", "value": entry.to_json_dict()["exact_weight"]
+        }
+
+
+def test_lc_replay_proof_ownership_is_retained() -> None:
+    case = _case("g g > g g", prepared_closure=False)
+    replay = build_lc_topology_replay_plan(case.dag.color_plan, case.model)
+    dag = replace(case.dag, lc_topology_replay=replay)
+    result = build_eager_lowering_input_v1(
+        dag=dag,
+        model=case.model,
+        resolver=_resolver_for(dag, case.model),
+    )
+    metadata = result.table("lc_replay_metadata")
+    members = result.table("lc_replay_members")
+
+    assert bool(metadata.column("present")[0])
+    assert result.table("lc_replay_partitions").row_count == len(replay.partitions)
+    assert members.row_count == replay.replayed_sector_count
+    assert result.table("lc_replay_residual_sectors").row_count == len(
+        replay.residual_sector_ids
+    )
+    assert result.table("lc_replay_permutations").row_count == sum(
+        len(permutation)
+        for partition in replay.partitions
+        for permutation in partition.label_permutations
+    )
+
+
+def test_generic_color_replay_retains_compact_physical_contraction() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("g g > g g g", color_accuracy="full")
+    color_plan = build_color_plan(process, color_accuracy="full")
+    replay = build_color_topology_replay_certificate(color_plan, model)
+    assert replay is not None
+    dag = compile_generic_dag(
+        process,
+        model=model,
+        color_plan=color_plan,
+        selected_color_sector_ids=replay.materialized_sector_ids,
+        online_evaluation_reuse=True,
+        backward_live_planning=True,
+    )
+    dag = replace(
+        dag,
+        color_plan=color_plan,
+        color_coverage="complete",
+        selected_color_sector_ids=(),
+        color_topology_replay=replay,
+    )
+    result = build_eager_lowering_input_v1(
+        dag=dag,
+        model=model,
+        resolver=_resolver_for(dag, model),
+    )
+
+    replay_metadata = result.table("lc_replay_metadata")
+    amplitude_metadata = result.table("color_replay_metadata")
+    contraction_metadata = result.table("color_replay_contraction_metadata")
+    component_groups = result.table("color_replay_contraction_component_groups")
+    entries = result.table("color_replay_contraction_entries")
+
+    assert bool(replay_metadata.column("present")[0])
+    assert int(replay_metadata.column("replay_kind")[0]) == 2
+    assert bool(amplitude_metadata.column("present")[0])
+    assert (
+        result.table("color_replay_physical_groups").row_count
+        == int(amplitude_metadata.column("physical_group_count")[0])
+    )
+    assert bool(contraction_metadata.column("present")[0])
+    assert bool(contraction_metadata.column("repeated")[0])
+    component_count = int(contraction_metadata.column("component_count")[0])
+    assert component_count > 1
+    assert component_groups.row_count == int(
+        contraction_metadata.column("group_count")[0]
+    )
+    assert entries.row_count > 0
+    assert entries.row_count * component_count > entries.row_count
+    assert set(int(value) for value in entries.column("left_group_id")) == {
+        (1 << 32) - 1
+    }
+    assert set(int(value) for value in entries.column("right_group_id")) == {
+        (1 << 32) - 1
+    }
+    assert not bool(result.table("color_contraction_metadata").column("present")[0])
+    factors = result.table("exact_factors")
+    for factor_id in entries.column("weight_factor_id"):
+        assert (
+            int(factors.column("exact_source")[factor_id])
+            == FACTOR_EXACT_SOURCE_CANONICAL_IR
+        )
+        ir_id = int(factors.column("exact_ir_id")[factor_id])
+        source = json.loads(result.canonical_ir_catalog[ir_id])["source"]
+        assert source["kind"] == "rational-complex"
+        assert len(source["value"]) == 4
+
+
+def test_exactness_audit_reports_the_remaining_resolver_blocker(
+    lowering_input: EagerLoweringInputV1,
+) -> None:
+    audit = " ".join(lowering_input.semantic_limitations)
+    assert "exact-IR reference" in audit
+    assert "intrinsically f64" in audit
+    assert "prepared-kernel exact expressions" in audit.lower()
+    assert "remaining provenance blocker" in audit
diff --git a/pyamplicol/tests/unit/test_eager_compiled_arena_m0.py b/pyamplicol/tests/unit/test_eager_compiled_arena_m0.py
new file mode 100644
index 0000000000..64bb4984ce
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_compiled_arena_m0.py
@@ -0,0 +1,1565 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import importlib.util
+import json
+import statistics
+import subprocess
+import sys
+from collections.abc import Callable
+from dataclasses import replace
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+M0_SCRIPT = ROOT / "tools" / "developer" / "eager_compiled_arena_m0.py"
+Z6G_TEST = ROOT / "tests" / "unit" / "test_recurrence_z6g_benchmark.py"
+
+
+def _load(name: str, path: Path) -> ModuleType:
+    spec = importlib.util.spec_from_file_location(name, path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+m0 = _load("_test_eager_compiled_arena_m0", M0_SCRIPT)
+z6g = _load("_test_eager_compiled_arena_m0_z6g", Z6G_TEST)
+benchmark = z6g.benchmark
+
+SOURCE_REVISION = "a" * 40
+AMPLICOL_REVISION = "b" * 40
+POINTS_SHA256 = "1" * 64
+FLOW_ID = "flow:2,4,5,6,7,8,9,1"
+FLOW_WORD = [2, 4, 5, 6, 7, 8, 9, 1]
+HELICITY_ID = "h:-1,+1,-1,+1,-1,+1,-1,+1,-1"
+HELICITY_VALUES = [-1, 1, -1, 1, -1, 1, -1, 1, -1]
+OPPOSITE_HELICITY_ID = "h:+1,-1,+1,-1,+1,-1,+1,-1,+1"
+SOURCE = {
+    "checkout": "/checkout",
+    "revision": SOURCE_REVISION,
+    "dirty": False,
+    "untracked_files_checked": True,
+}
+HOST = {
+    "platform": "Darwin-test",
+    "system": "Darwin",
+    "release": "24.0.0",
+    "version": "test",
+    "machine": "arm64",
+    "processor": "arm",
+    "cpu_model": "test-cpu",
+    "logical_cpu_count": 8,
+}
+RUNTIME = {
+    "interpreter": {
+        "path": "/opt/test/python",
+        "resolved_path": "/opt/test/python",
+        "size_bytes": 10,
+        "sha256": "2" * 64,
+        "python_version": "3.12.6",
+        "implementation": "CPython",
+    },
+    "installed_distribution": {
+        "package_version": "0.1.0",
+        "distribution_content": {
+            "algorithm": "sha256-relative-path-size-content-v1",
+            "sha256": "3" * 64,
+            "file_count": 10,
+            "size_bytes": 100,
+        },
+        "native_modules": [
+            {
+                "relative_path": "pyamplicol/_rusticol.so",
+                "path": "/opt/test/_rusticol.so",
+                "resolved_path": "/opt/test/_rusticol.so",
+                "size_bytes": 20,
+                "sha256": "4" * 64,
+            }
+        ],
+        "build_info_files": [
+            {
+                "relative_path": "pyamplicol/_build_info.json",
+                "path": "/opt/test/_build_info.json",
+                "resolved_path": "/opt/test/_build_info.json",
+                "size_bytes": 30,
+                "sha256": "a" * 64,
+            }
+        ],
+    },
+    "active_build_info": {
+        "path": "/opt/test/_build_info.json",
+        "resolved_path": "/opt/test/_build_info.json",
+        "size_bytes": 30,
+        "sha256": "a" * 64,
+        "payload": {
+            "source_revision": SOURCE_REVISION,
+            "source_checkout": "/checkout",
+            "native_build_inputs_sha256": "5" * 64,
+        },
+    },
+    "native_extension": {
+        "path": "/opt/test/_rusticol.so",
+        "resolved_path": "/opt/test/_rusticol.so",
+        "size_bytes": 20,
+        "sha256": "4" * 64,
+        "package_version": "0.1.0",
+        "build_inputs_sha256": "5" * 64,
+    },
+    "dependencies": {
+        name: {
+            "present": True,
+            "path": f"/checkout/{name}",
+            "resolved_path": f"/checkout/{name}",
+            "sha256": hashlib.sha256(name.encode()).hexdigest(),
+            "size_bytes": 42,
+        }
+        for name in m0._RUNTIME_DEPENDENCIES
+    },
+}
+
+
+def _write_bytes(path: Path, raw: bytes) -> dict[str, object]:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(raw)
+    return {
+        "path": str(path.resolve()),
+        "size_bytes": len(raw),
+        "sha256": hashlib.sha256(raw).hexdigest(),
+    }
+
+
+def _write_json(path: Path, payload: object) -> dict[str, object]:
+    raw = (
+        json.dumps(
+            payload,
+            indent=2,
+            sort_keys=True,
+            ensure_ascii=False,
+            allow_nan=False,
+        )
+        + "\n"
+    ).encode()
+    return _write_bytes(path, raw)
+
+
+def _fixture(path: Path) -> dict[str, object]:
+    identity = _write_bytes(path, b'{"points":"m0-test"}\n')
+    return {
+        "point_count": 2,
+        "points_sha256": POINTS_SHA256,
+        "file": {
+            **identity,
+            "resolved_path": identity["path"],
+        },
+    }
+
+
+def _selector(layout: str) -> dict[str, object]:
+    union = layout == "all-flow-union"
+    return {
+        "color_flow_request": "1",
+        "resolved_color_flow_id": None if union else FLOW_ID,
+        "helicity_request": "1",
+        "resolved_helicity_id": HELICITY_ID if union else None,
+        "color_flow_count": 1,
+        "helicity_count": 2,
+        "structural_zero_helicity_count": 0,
+        "workload": m0.UNION_WORKLOAD if union else m0.SELECTED_WORKLOAD,
+    }
+
+
+def _make_capture(
+    root: Path,
+    *,
+    model: str,
+    layout: str,
+    fixture: dict[str, object],
+) -> tuple[dict[str, object], dict[str, Any]]:
+    argument_tokens = [
+        "--jit-optimization-level",
+        "3",
+        "--lc-flow-layout",
+        layout,
+    ]
+    if model != "built-in-sm":
+        argument_tokens.extend(("--prepared-model", f"/prepared/{model}.pacbin"))
+    arguments = z6g._arguments(*argument_tokens)
+    schedule = z6g._passing_schedule(
+        jit_optimization_level=3,
+        lc_flow_layout=layout,
+    )
+    for entry in schedule["entries"]:
+        entry["pre_timing_verification"]["effective_contract"][
+            "jit_optimization_level"
+        ] = benchmark._expected_effective_jit_optimization_level(
+            arguments,
+            mode=entry["mode"],
+        )
+    root_bindings = {
+        "source_identity_sha256": m0._canonical_sha256(SOURCE),
+        "runtime_provenance_sha256": m0._canonical_sha256(RUNTIME),
+        "interpreter_sha256": RUNTIME["interpreter"]["sha256"],
+        "native_extension_sha256": RUNTIME["native_extension"]["sha256"],
+    }
+    for entry in schedule["entries"]:
+        verification = entry["pre_timing_verification"]
+        for side in ("expected", "observed"):
+            verification[side].update(root_bindings)
+    semantic = z6g._artifact_semantic_identity(
+        model_name="built-in-sm" if model == "built-in-sm" else "sm",
+        model_content_sha256="c" * 64 if model == "built-in-sm" else "d" * 64,
+        color_id=FLOW_ID,
+        color_word=tuple(FLOW_WORD),
+        helicity_id=HELICITY_ID,
+        helicity_values=tuple(HELICITY_VALUES),
+    )
+    profiles = z6g._passing_profiles(
+        schedule,
+        semantic_identity=semantic,
+        selector_contract=_selector(layout),
+        fixture=fixture,
+    )
+    validation_preflight = benchmark._validation_preflight_contract(
+        arguments,
+        {
+            mode: profiles[mode]
+            for mode in benchmark.AUTHORITATIVE_EXECUTION_MODES
+            if mode in profiles
+        },
+    )
+    validation_preflight["worker_evidence"] = {
+        mode: {"fixture": "synthetic"}
+        for mode in benchmark.AUTHORITATIVE_EXECUTION_MODES
+    }
+    validation = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        validation,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is True
+    assert capture["passes"] is True
+    per_layout = benchmark._milestone0_acceptance_manifest(arguments, capture)
+    if model == "built-in-sm":
+        model_identities = {
+            "compiled": {
+                "kind": "built-in-sm-source",
+                "resource_id": None,
+                "source_revision": SOURCE_REVISION,
+                "compile_excluded_from_generation": False,
+            },
+            "eager": {
+                "kind": "packaged-prepared-model",
+                "resource_id": m0.BUILTIN_PACKAGED_MODEL_RESOURCE_ID,
+                "size_bytes": 100,
+                "sha256": "7" * 64,
+                "compile_excluded_from_generation": True,
+            },
+            "recurrence": {
+                "kind": "packaged-prepared-model",
+                "resource_id": m0.BUILTIN_PACKAGED_MODEL_RESOURCE_ID,
+                "size_bytes": 100,
+                "sha256": "7" * 64,
+                "compile_excluded_from_generation": True,
+            },
+        }
+    else:
+        model_identities = {
+            mode: {
+                "kind": "explicit-prepared-model",
+                "resource_id": None,
+                "file": {
+                    "size_bytes": 100,
+                    "sha256": "8" * 64,
+                    "path": f"/prepared/{model}.pacbin",
+                    "resolved_path": f"/prepared/{model}.pacbin",
+                },
+                "compile_excluded_from_generation": True,
+            }
+            for mode in m0.MODES
+        }
+    generation: dict[str, dict[str, Any]] = {}
+    for mode in m0.MODES:
+        signature = {
+            "kind": "pyamplicol-benchmark-generation-signature",
+            "schema_version": 1,
+            "source_revision": SOURCE_REVISION,
+            "runtime_provenance_sha256": m0._canonical_sha256(RUNTIME),
+            "mode": mode,
+            "process": m0.PROCESS,
+            "model": model_identities[mode],
+            "color_accuracy": "lc",
+            "lc_flow_layout": layout,
+            "jit_optimization_level": 3,
+        }
+        generation[mode] = {
+            "model_source": model_identities[mode],
+            "effective_contract": {
+                "execution_mode": mode,
+                "backend": "jit",
+                "jit_optimization_level": (
+                    m0._expected_effective_jit_optimization_level(
+                        model_identities[mode],
+                        mode=mode,
+                    )
+                ),
+                "color_accuracy": "lc",
+                "lc_flow_layout": layout,
+            },
+            "semantic_generation_signature": signature,
+            "semantic_generation_signature_sha256": m0._canonical_sha256(signature),
+            "artifact_semantic_identity": profiles[mode]["artifact_semantic_identity"],
+            "artifact_semantic_identity_sha256": profiles[mode][
+                "artifact_semantic_identity_sha256"
+            ],
+        }
+    configuration = {
+        "batch_sizes": list(m0.BATCHES),
+        "target_runtime_seconds": arguments.target_runtime,
+        "minimum_samples": arguments.minimum_samples,
+        "subprocess_samples": arguments.subprocess_samples,
+        "warmup_runs": arguments.warmup_runs,
+        "generation_timeout_seconds": arguments.generation_timeout,
+        "profile_timeout_seconds": arguments.profile_timeout,
+        "color_flow_request": arguments.color_flow,
+        "helicity_request": arguments.helicity,
+        "lc_flow_layout": layout,
+        "gluon_count": 6,
+        "validation_samples": arguments.validation_samples,
+        "point_tile_size": arguments.point_tile_size,
+        "jit_optimization_level": 3,
+        "validation_point_artifact": fixture["file"]["path"],
+        "generation_only": False,
+        "allow_diagnostic_incomplete_success": False,
+        "modes": list(m0.MODES),
+        "prepared_model_path": (
+            None if model == "built-in-sm" else f"/prepared/{model}.pacbin"
+        ),
+        "model_identities": model_identities,
+        "validation_seed": benchmark.VALIDATION_SEED,
+        "specialize_flow_at_generation": False,
+        "external_watchdog_required_for_long_runs": True,
+    }
+    recurrence_runtime_acceptance = benchmark._recurrence_runtime_acceptance(
+        arguments,
+        source_identity=SOURCE,
+        runtime_provenance=RUNTIME,
+        generation=generation,
+        profiles=profiles,
+        validation_summary=validation,
+        profile_schedule=schedule,
+    )
+    payload = {
+        "kind": m0.CAPTURE_KIND,
+        "schema_version": m0.CAPTURE_SCHEMA,
+        "complete": True,
+        "passes": True,
+        "capture_acceptance": capture,
+        "milestone0_acceptance": per_layout,
+        "recurrence_runtime_acceptance": recurrence_runtime_acceptance,
+        "source": copy.deepcopy(SOURCE),
+        "runtime_provenance": copy.deepcopy(RUNTIME),
+        "provenance": {
+            "started_at_utc": "2026-07-24T00:00:00+00:00",
+            "finished_at_utc": "2026-07-24T00:10:00+00:00",
+            "wall_seconds": 600.0,
+            "host": copy.deepcopy(HOST),
+            "working_directory": "/checkout",
+            "driver_command": {"argv": ["python", "benchmark"]},
+            "post_worker_identity_rechecks": [],
+            "external_watchdog_required_for_long_runs": True,
+        },
+        "process": "u u~ > Z g g g g g g",
+        "process_name": "uubar_z6g",
+        "workload": (
+            m0.UNION_WORKLOAD if layout == "all-flow-union" else m0.SELECTED_WORKLOAD
+        ),
+        "configuration": configuration,
+        "generation": generation,
+        "profile_schedule": schedule,
+        "validation_preflight": validation_preflight,
+        "paired_profile_coordination": None,
+        "profiles": profiles,
+        "validation_summary": validation,
+        "selector_contracts_match": validation["selectors_match"],
+        "validation_fixtures_match": validation["fixtures_match"],
+        "lane_comparisons": validation["comparisons"],
+        "result_json": f"/results/{model}-{layout}.json",
+    }
+    ref = _write_json(root / f"{model}-{layout}.json", payload)
+    return ref, payload
+
+
+def _amplicol_evidence(
+    root: Path,
+    *,
+    role: str,
+    fixture_ref: dict[str, object],
+    values: list[list[float]],
+) -> tuple[dict[str, object], dict[str, Any]]:
+    stem = role.replace("-", "_")
+    executable = _write_bytes(root / f"{stem}.exe", b"executable")
+    Path(executable["path"]).chmod(0o755)
+    library = _write_bytes(root / f"{stem}.dylib", b"library")
+    source = _write_bytes(root / f"{stem}.cc", b"int main() {}\n")
+    samples: list[dict[str, object]] = []
+    timings: list[float] = []
+    position_offset = 1 if role == m0.AMPLICOL_UNION_ROLE else 0
+    for index in range(m0.MIN_SAMPLES):
+        seconds_per_point = 4.0e-5 * (1.0 + index * 0.01)
+        evaluated_point_count = 1000
+        elapsed = seconds_per_point * evaluated_point_count
+        selector_argument = (
+            f"--helicity-id={HELICITY_ID}"
+            if role == m0.AMPLICOL_UNION_ROLE
+            else f"--color-flow-id={FLOW_ID}"
+        )
+        command = [
+            executable["path"],
+            f"--workload={role}",
+            f"--round={index}",
+            f"--momenta={fixture_ref['path']}",
+            f"--source-revision={AMPLICOL_REVISION}",
+            selector_argument,
+        ]
+        command_sha256 = m0._canonical_sha256(command)
+        stdout_payload = {
+            "kind": "amplicol-m0-probe-result",
+            "schema_version": 1,
+            "role": role,
+            "sample_index": index,
+            "evaluated_point_count": evaluated_point_count,
+            "elapsed_seconds": elapsed,
+            "seconds_per_point": seconds_per_point,
+            "selected_totals": values,
+            "resolved_sums": values,
+        }
+        stdout = json.dumps(
+            stdout_payload,
+            sort_keys=True,
+            separators=(",", ":"),
+        )
+        raw_payload = {
+            "kind": "pyamplicol-amplicol-m0-raw-sample",
+            "schema_version": 1,
+            "role": role,
+            "sample_index": index,
+            "command_sha256": command_sha256,
+            "evaluated_point_count": evaluated_point_count,
+            "elapsed_seconds": elapsed,
+            "seconds_per_point": seconds_per_point,
+            "stdout": stdout,
+            "stdout_sha256": hashlib.sha256(stdout.encode()).hexdigest(),
+        }
+        raw_payload["content_sha256"] = m0._canonical_sha256(raw_payload)
+        raw_output = _write_json(
+            root / f"{stem}-sample-{index}.json",
+            raw_payload,
+        )
+        start_second = 4 * index + 2 * position_offset
+        sample = {
+            "sample_index": index,
+            "interleave_round": index,
+            "interleave_position": 2 * index + position_offset,
+            "started_at_utc": f"2026-07-24T01:00:{start_second:02d}+00:00",
+            "finished_at_utc": f"2026-07-24T01:00:{start_second + 1:02d}+00:00",
+            "subprocess": True,
+            "command": command,
+            "command_sha256": command_sha256,
+            "evaluated_point_count": evaluated_point_count,
+            "elapsed_seconds": elapsed,
+            "seconds_per_point": seconds_per_point,
+            "interrupted": False,
+            "raw_output_file": raw_output,
+        }
+        samples.append(sample)
+        timings.append(seconds_per_point)
+    median = statistics.median(timings)
+    mad = statistics.median(abs(value - median) for value in timings)
+    union = role == m0.AMPLICOL_UNION_ROLE
+    comparisons = [
+        {
+            "point_index": index,
+            "passes": True,
+        }
+        for index in range(len(values))
+    ]
+    payload = {
+        "kind": m0.AMPLICOL_KIND,
+        "schema_version": m0.AMPLICOL_SCHEMA,
+        "complete": True,
+        "evidence_scope": "authoritative-host-capture-v1",
+        "workload": m0.UNION_WORKLOAD if union else m0.SELECTED_WORKLOAD,
+        "source": {
+            "revision": AMPLICOL_REVISION,
+            "dirty": False,
+            "compiler": {
+                "id": "apple-clang",
+                "version": "16.0.0",
+                "target": "arm64-apple-darwin",
+                "flags_sha256": m0._canonical_sha256(["-O3"]),
+            },
+            "source_tree_sha256": m0._amplicol_source_tree_sha256([source]),
+        },
+        "host": copy.deepcopy(HOST),
+        "process": {
+            "expression": "u u~ > Z g g g g g g",
+            "normalized_expression": m0.PROCESS,
+        },
+        "physical_axes": {
+            "color_flow": {
+                "count": 1,
+                "ordered_ids_sha256": m0._canonical_sha256([FLOW_ID]),
+            },
+            "helicity": {
+                "count": 2,
+                "ordered_ids_sha256": m0._canonical_sha256(
+                    [HELICITY_ID, OPPOSITE_HELICITY_ID]
+                ),
+            },
+        },
+        "selector": {
+            "color_flow_request": "1",
+            "resolved_color_flow_id": None if union else FLOW_ID,
+            "color_flow_word": FLOW_WORD,
+            "helicity_request": "1",
+            "resolved_helicity_id": HELICITY_ID if union else None,
+            "helicity_values": HELICITY_VALUES,
+            "sum_axis": "color_flow" if union else "helicity",
+            "source_to_generated_permutation": list(range(m0.EXTERNAL_LEG_COUNT)),
+            "complete_physical_axes": True,
+            "generation_specialized_axes": [],
+        },
+        "momenta": {
+            "point_count": len(values),
+            "points_sha256": POINTS_SHA256,
+            "raw_file": {
+                "path": fixture_ref["path"],
+                "size_bytes": fixture_ref["size_bytes"],
+                "sha256": fixture_ref["sha256"],
+            },
+        },
+        "normalization_sha256": z6g._artifact_semantic_identity()[
+            "normalization_sha256"
+        ],
+        "timing": {
+            "boundary": "direct-library-total" if union else "amplitude-evaluation",
+            "batch_semantics": "scalar-normalized-per-point",
+            "statistics_contract": "subprocess-median-and-raw-mad-v1",
+            "interleave_group_sha256": m0._canonical_sha256(
+                {
+                    "kind": "amplicol-m0-paired-interleave",
+                    "roles": [
+                        m0.AMPLICOL_SELECTED_ROLE,
+                        m0.AMPLICOL_UNION_ROLE,
+                    ],
+                    "rounds": m0.MIN_SAMPLES,
+                }
+            ),
+            "sample_count": len(samples),
+            "median_seconds_per_point": median,
+            "mad_seconds_per_point": mad,
+            "samples": samples,
+            "samples_sha256": m0._canonical_sha256(samples),
+        },
+        "validation": {
+            "selected_totals": copy.deepcopy(values),
+            "resolved_sums": copy.deepcopy(values),
+            "point_comparisons": comparisons,
+            "maximum_absolute_difference": 0.0,
+            "maximum_relative_difference": 0.0,
+            "passes": True,
+        },
+        "binary_evidence": {
+            "executable": executable,
+            "linked_libraries": [library],
+            "source_files": [source],
+        },
+    }
+    payload["content_sha256"] = m0._canonical_sha256(payload)
+    ref = _write_json(root / f"amplicol-{role}.json", payload)
+    return ref, payload
+
+
+def _interleave_projection(
+    role: str,
+    payload: dict[str, Any],
+) -> list[dict[str, Any]]:
+    return [
+        {
+            "role": role,
+            "round": sample["interleave_round"],
+            "position": sample["interleave_position"],
+            "started_at_utc": sample["started_at_utc"],
+            "finished_at_utc": sample["finished_at_utc"],
+            "command_sha256": sample["command_sha256"],
+        }
+        for sample in payload["timing"]["samples"]
+    ]
+
+
+def _make_corpus(root: Path) -> dict[str, Any]:
+    fixture = _fixture(root / "momenta.json")
+    capture_refs: dict[str, dict[str, dict[str, object]]] = {}
+    captures: dict[tuple[str, str], dict[str, Any]] = {}
+    for model in m0.MODELS:
+        capture_refs[model] = {}
+        for layout in m0.LAYOUTS:
+            ref, payload = _make_capture(
+                root,
+                model=model,
+                layout=layout,
+                fixture=fixture,
+            )
+            capture_refs[model][layout] = ref
+            captures[(model, layout)] = payload
+    selected_values = captures[("built-in-sm", "topology-replay")]["profiles"][
+        "compiled"
+    ]["validation"]["selected_totals"]
+    union_values = captures[("built-in-sm", "all-flow-union")]["profiles"]["compiled"][
+        "validation"
+    ]["selected_totals"]
+    selected_ref, selected_payload = _amplicol_evidence(
+        root,
+        role=m0.AMPLICOL_SELECTED_ROLE,
+        fixture_ref=fixture["file"],
+        values=selected_values,
+    )
+    union_ref, union_payload = _amplicol_evidence(
+        root,
+        role=m0.AMPLICOL_UNION_ROLE,
+        fixture_ref=fixture["file"],
+        values=union_values,
+    )
+    combined_interleave = sorted(
+        [
+            *_interleave_projection(m0.AMPLICOL_SELECTED_ROLE, selected_payload),
+            *_interleave_projection(m0.AMPLICOL_UNION_ROLE, union_payload),
+        ],
+        key=lambda record: record["position"],
+    )
+    interleave_sha256 = m0._amplicol_interleave_group_sha256(combined_interleave)
+    refreshed: dict[str, dict[str, object]] = {}
+    for role, payload, ref in (
+        (m0.AMPLICOL_SELECTED_ROLE, selected_payload, selected_ref),
+        (m0.AMPLICOL_UNION_ROLE, union_payload, union_ref),
+    ):
+        payload["timing"]["interleave_group_sha256"] = interleave_sha256
+        without_digest = dict(payload)
+        without_digest.pop("content_sha256")
+        payload["content_sha256"] = m0._canonical_sha256(without_digest)
+        refreshed[role] = _write_json(Path(ref["path"]), payload)
+    selected_ref = refreshed[m0.AMPLICOL_SELECTED_ROLE]
+    union_ref = refreshed[m0.AMPLICOL_UNION_ROLE]
+    semantic_builtin = captures[("built-in-sm", "topology-replay")]["profiles"][
+        "compiled"
+    ]["artifact_semantic_identity"]
+    semantic_ufo = captures[("ufo-sm", "topology-replay")]["profiles"]["compiled"][
+        "artifact_semantic_identity"
+    ]
+    configuration_builtin = captures[("built-in-sm", "topology-replay")][
+        "configuration"
+    ]
+    configuration_ufo = captures[("ufo-sm", "topology-replay")]["configuration"]
+    request = {
+        "kind": m0.REQUEST_KIND,
+        "schema_version": m0.REQUEST_SCHEMA,
+        "captures": capture_refs,
+        "amplicol_evidence": {
+            m0.AMPLICOL_SELECTED_ROLE: selected_ref,
+            m0.AMPLICOL_UNION_ROLE: union_ref,
+        },
+        "expected": {
+            "pyamplicol_source_revision": SOURCE_REVISION,
+            "amplicol_source_revision": AMPLICOL_REVISION,
+            "process": m0.PROCESS,
+            "runtime_provenance_sha256": m0._canonical_sha256(
+                m0._path_stripped(RUNTIME)
+            ),
+            "host_sha256": m0._canonical_sha256(HOST),
+            "momenta_points_sha256": POINTS_SHA256,
+            "normalization_sha256": semantic_builtin["normalization_sha256"],
+            "model_common_physics_identity_sha256": {
+                "built-in-sm": semantic_builtin["manifest_model_identity"][
+                    "common_physics_identity_sha256"
+                ],
+                "ufo-sm": semantic_ufo["manifest_model_identity"][
+                    "common_physics_identity_sha256"
+                ],
+            },
+            "generation_model_identities_sha256": {
+                "built-in-sm": m0._canonical_sha256(
+                    m0._path_stripped(configuration_builtin["model_identities"])
+                ),
+                "ufo-sm": m0._canonical_sha256(
+                    m0._path_stripped(configuration_ufo["model_identities"])
+                ),
+            },
+            "color_flow": {"id": FLOW_ID, "word": FLOW_WORD},
+            "helicity": {"id": HELICITY_ID, "values": HELICITY_VALUES},
+            "external_leg_permutation": list(range(m0.EXTERNAL_LEG_COUNT)),
+        },
+    }
+    request_ref = _write_json(root / "request.json", request)
+    return {
+        "request": request,
+        "request_ref": request_ref,
+        "captures": captures,
+        "capture_refs": capture_refs,
+        "amplicol": {
+            m0.AMPLICOL_SELECTED_ROLE: selected_payload,
+            m0.AMPLICOL_UNION_ROLE: union_payload,
+        },
+    }
+
+
+def _run(root: Path, corpus: dict[str, Any]) -> tuple[dict[str, Any], int]:
+    request_path = Path(corpus["request_ref"]["path"])
+    return m0.combine(
+        request_path=request_path,
+        request_sha256=corpus["request_ref"]["sha256"],
+        output_path=root / "decision.json",
+    )
+
+
+def _rewrite_capture(
+    corpus: dict[str, Any],
+    *,
+    model: str,
+    layout: str,
+) -> None:
+    payload = corpus["captures"][(model, layout)]
+    path = Path(corpus["capture_refs"][model][layout]["path"])
+    ref = _write_json(path, payload)
+    corpus["capture_refs"][model][layout] = ref
+    corpus["request"]["captures"][model][layout] = ref
+
+
+def _rewrite_amplicol(corpus: dict[str, Any], role: str) -> None:
+    payload = corpus["amplicol"][role]
+    without_digest = dict(payload)
+    without_digest.pop("content_sha256", None)
+    payload["content_sha256"] = m0._canonical_sha256(without_digest)
+    path = Path(corpus["request"]["amplicol_evidence"][role]["path"])
+    ref = _write_json(path, payload)
+    corpus["request"]["amplicol_evidence"][role] = ref
+
+
+def _refresh_amplicol_timing(corpus: dict[str, Any], role: str) -> None:
+    timing = corpus["amplicol"][role]["timing"]
+    samples = timing["samples"]
+    values = [sample["seconds_per_point"] for sample in samples]
+    median = statistics.median(values)
+    timing["sample_count"] = len(samples)
+    timing["median_seconds_per_point"] = median
+    timing["mad_seconds_per_point"] = statistics.median(
+        abs(value - median) for value in values
+    )
+    timing["samples_sha256"] = m0._canonical_sha256(samples)
+    _rewrite_amplicol(corpus, role)
+    _rewrite_request(corpus)
+
+
+def _rewrite_request(corpus: dict[str, Any]) -> None:
+    path = Path(corpus["request_ref"]["path"])
+    corpus["request_ref"] = _write_json(path, corpus["request"])
+
+
+def _capture_with_compiled_recurrence_ratio(
+    capture: m0.Capture,
+    *,
+    batch: int,
+    ratio: float,
+) -> m0.Capture:
+    timings = copy.deepcopy(capture.timings)
+    recurrence = timings["recurrence"][str(batch)]
+    compiled = timings["compiled"][str(batch)]
+    compiled_values = [value * ratio for value in recurrence["raw_seconds_per_point"]]
+    compiled_median = statistics.median(compiled_values)
+    compiled["sample_count"] = len(compiled_values)
+    compiled["median_seconds_per_point"] = compiled_median
+    compiled["mad_seconds_per_point"] = statistics.median(
+        abs(value - compiled_median) for value in compiled_values
+    )
+    compiled["raw_seconds_per_point"] = compiled_values
+    return replace(capture, timings=timings)
+
+
+def test_positive_fixture_emits_content_addressed_acceptance(
+    tmp_path: Path,
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 0
+    assert decision["accepted"] is True
+    assert decision["status"] == "accepted"
+    assert decision["errors"] == []
+    digest = decision.pop("content_sha256")
+    assert digest == m0._canonical_sha256(decision)
+    assert set(decision["layout_captures"]) == set(m0.MODELS)
+    assert decision["validation"]["amplicol_selected_flow_parity"] is True
+    comparison = decision["comparisons"][m0.SELECTED_WORKLOAD]["built-in-sm"][
+        "compiled"
+    ]["1024"]
+    assert comparison["pyamplicol_over_amplicol"] > 0.0
+    assert comparison["amplicol_boundary"] == "amplitude-evaluation"
+    ceiling = decision["validation"]["compiled_recurrence_runtime_ceiling"]
+    assert ceiling["passes"] is True
+    assert ceiling["required_batches"] == list(m0.COMPILED_RECURRENCE_BATCHES)
+    assert ceiling["maximum_compiled_over_recurrence"] == (
+        m0.MAX_COMPILED_OVER_RECURRENCE
+    )
+    assert {
+        (model, layout, int(batch))
+        for model, model_cells in ceiling["cells"].items()
+        for layout, layout_cells in model_cells.items()
+        for batch in layout_cells
+    } == {
+        (model, layout, batch)
+        for model in m0.MODELS
+        for layout in m0.LAYOUTS
+        for batch in m0.COMPILED_RECURRENCE_BATCHES
+    }
+
+
+def test_compiled_recurrence_ceiling_is_inclusive(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    validate_capture = m0._validate_capture
+
+    def at_ceiling(
+        loaded: m0.LoadedJson,
+        *,
+        model: str,
+        layout: str,
+        expected: dict[str, Any],
+        benchmark: ModuleType,
+    ) -> m0.Capture:
+        capture = validate_capture(
+            loaded,
+            model=model,
+            layout=layout,
+            expected=expected,
+            benchmark=benchmark,
+        )
+        for batch in m0.COMPILED_RECURRENCE_BATCHES:
+            capture = _capture_with_compiled_recurrence_ratio(
+                capture,
+                batch=batch,
+                ratio=m0.MAX_COMPILED_OVER_RECURRENCE,
+            )
+        return capture
+
+    monkeypatch.setattr(m0, "_validate_capture", at_ceiling)
+    decision, code = _run(tmp_path, corpus)
+
+    assert code == 0
+    assert decision["accepted"] is True
+    ceiling = decision["validation"]["compiled_recurrence_runtime_ceiling"]
+    for model in m0.MODELS:
+        for layout in m0.LAYOUTS:
+            for batch in m0.COMPILED_RECURRENCE_BATCHES:
+                cell = ceiling["cells"][model][layout][str(batch)]
+                assert cell["passes"] is True
+                assert cell["compiled_over_recurrence"] == pytest.approx(
+                    m0.MAX_COMPILED_OVER_RECURRENCE
+                )
+
+
+@pytest.mark.parametrize(
+    ("target_model", "target_layout", "target_batch"),
+    [
+        pytest.param(model, layout, batch, id=f"{model}-{layout}-{batch}")
+        for model in m0.MODELS
+        for layout in m0.LAYOUTS
+        for batch in m0.COMPILED_RECURRENCE_BATCHES
+    ],
+)
+def test_rejects_every_required_compiled_recurrence_ceiling_cell(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    target_model: str,
+    target_layout: str,
+    target_batch: int,
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    validate_capture = m0._validate_capture
+
+    def over_ceiling(
+        loaded: m0.LoadedJson,
+        *,
+        model: str,
+        layout: str,
+        expected: dict[str, Any],
+        benchmark: ModuleType,
+    ) -> m0.Capture:
+        capture = validate_capture(
+            loaded,
+            model=model,
+            layout=layout,
+            expected=expected,
+            benchmark=benchmark,
+        )
+        if model == target_model and layout == target_layout:
+            capture = _capture_with_compiled_recurrence_ratio(
+                capture,
+                batch=target_batch,
+                ratio=m0.MAX_COMPILED_OVER_RECURRENCE + 1.0e-6,
+            )
+        return capture
+
+    monkeypatch.setattr(m0, "_validate_capture", over_ceiling)
+    decision, code = _run(tmp_path, corpus)
+
+    assert code == 2
+    assert decision["accepted"] is False
+    assert decision["status"] == "rejected"
+    assert decision["validation"] is None
+    assert decision["timings"] is None
+    assert decision["comparisons"] is None
+    assert len(decision["errors"]) == 1
+    error = decision["errors"][0]
+    assert f"{target_model}/{target_layout}" in error
+    assert f"batch {target_batch}" in error
+    assert "compiled qq_Z6g exceeds the recurrence ceiling" in error
+    assert decision["policy"]["maximum_compiled_over_recurrence"] == (
+        m0.MAX_COMPILED_OVER_RECURRENCE
+    )
+
+
+def test_producer_shaped_builtin_model_identity_split_is_accepted(
+    tmp_path: Path,
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    for layout in m0.LAYOUTS:
+        capture = corpus["captures"][("built-in-sm", layout)]
+        identities = capture["configuration"]["model_identities"]
+        assert identities["compiled"]["kind"] == "built-in-sm-source"
+        assert identities["compiled"]["compile_excluded_from_generation"] is False
+        assert identities["eager"]["kind"] == "packaged-prepared-model"
+        assert identities["recurrence"]["kind"] == "packaged-prepared-model"
+        for mode in m0.MODES:
+            generation = capture["generation"][mode]
+            assert generation["model_source"] == identities[mode]
+            assert (
+                generation["semantic_generation_signature"]["model"]
+                == (identities[mode])
+            )
+
+    decision, code = _run(tmp_path, corpus)
+    assert code == 0
+    assert decision["accepted"] is True
+
+
+@pytest.mark.parametrize(
+    ("model_kind", "mode", "expected_level"),
+    [
+        pytest.param("built-in-sm-source", "compiled", 3, id="builtin-compiled"),
+        pytest.param(
+            "packaged-prepared-model",
+            "eager",
+            m0.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+            id="builtin-eager",
+        ),
+        pytest.param(
+            "packaged-prepared-model",
+            "recurrence",
+            m0.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+            id="builtin-recurrence",
+        ),
+        pytest.param("explicit-prepared-model", "compiled", 3, id="ufo-compiled"),
+        pytest.param(
+            "explicit-prepared-model",
+            "eager",
+            m0.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+            id="ufo-eager",
+        ),
+        pytest.param(
+            "explicit-prepared-model",
+            "recurrence",
+            m0.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL,
+            id="ufo-recurrence",
+        ),
+    ],
+)
+def test_effective_jit_level_is_execution_mode_aware(
+    model_kind: str,
+    mode: str,
+    expected_level: int,
+) -> None:
+    assert (
+        m0._expected_effective_jit_optimization_level(
+            {"kind": model_kind},
+            mode=mode,
+        )
+        == expected_level
+    )
+
+
+def test_producer_shaped_ufo_compiled_remains_o3(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    for layout in m0.LAYOUTS:
+        generation = corpus["captures"][("ufo-sm", layout)]["generation"]
+        assert generation["compiled"]["model_source"]["kind"] == (
+            "explicit-prepared-model"
+        )
+        assert (
+            generation["compiled"]["effective_contract"]["jit_optimization_level"] == 3
+        )
+        for mode in ("eager", "recurrence"):
+            assert (
+                generation[mode]["effective_contract"]["jit_optimization_level"]
+                == m0.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL
+            )
+
+    decision, code = _run(tmp_path, corpus)
+    assert code == 0
+    assert decision["accepted"] is True
+
+
+@pytest.mark.parametrize(
+    ("model", "mode", "wrong_level"),
+    [
+        pytest.param("built-in-sm", "compiled", 2, id="builtin-compiled-o2"),
+        pytest.param("built-in-sm", "eager", 3, id="builtin-eager-o3"),
+        pytest.param("built-in-sm", "recurrence", 3, id="builtin-recurrence-o3"),
+        pytest.param("ufo-sm", "compiled", 2, id="ufo-compiled-o2"),
+        pytest.param("ufo-sm", "eager", 3, id="ufo-eager-o3"),
+        pytest.param("ufo-sm", "recurrence", 3, id="ufo-recurrence-o3"),
+    ],
+)
+def test_rejects_model_mode_effective_jit_level_drift(
+    tmp_path: Path,
+    model: str,
+    mode: str,
+    wrong_level: int,
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    capture = corpus["captures"][(model, "topology-replay")]
+    capture["generation"][mode]["effective_contract"]["jit_optimization_level"] = (
+        wrong_level
+    )
+    _rewrite_capture(corpus, model=model, layout="topology-replay")
+    _rewrite_request(corpus)
+
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert decision["accepted"] is False
+    assert "wrong effective JIT optimization level" in decision["errors"][0]
+
+
+def test_rejects_self_pinned_builtin_compiled_model_branch_mismatch(
+    tmp_path: Path,
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    drifted_compiled_identity = {
+        "kind": "packaged-prepared-model",
+        "resource_id": m0.BUILTIN_PACKAGED_MODEL_RESOURCE_ID,
+        "size_bytes": 100,
+        "sha256": "e" * 64,
+        "compile_excluded_from_generation": True,
+    }
+    for layout in m0.LAYOUTS:
+        capture = corpus["captures"][("built-in-sm", layout)]
+        identities = capture["configuration"]["model_identities"]
+        identities["compiled"] = copy.deepcopy(drifted_compiled_identity)
+        generation = capture["generation"]["compiled"]
+        generation["model_source"] = copy.deepcopy(drifted_compiled_identity)
+        signature = generation["semantic_generation_signature"]
+        signature["model"] = copy.deepcopy(drifted_compiled_identity)
+        generation["semantic_generation_signature_sha256"] = m0._canonical_sha256(
+            signature
+        )
+        _rewrite_capture(corpus, model="built-in-sm", layout=layout)
+    corpus["request"]["expected"]["generation_model_identities_sha256"][
+        "built-in-sm"
+    ] = m0._canonical_sha256(
+        m0._path_stripped(
+            corpus["captures"][("built-in-sm", "topology-replay")]["configuration"][
+                "model_identities"
+            ]
+        )
+    )
+    _rewrite_request(corpus)
+
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert decision["accepted"] is False
+    assert "must use built-in-sm-source" in decision["errors"][0]
+
+
+@pytest.mark.parametrize(
+    ("model", "mode", "wrong_identity", "expected_kind"),
+    [
+        pytest.param(
+            "built-in-sm",
+            "compiled",
+            {
+                "kind": "packaged-prepared-model",
+                "resource_id": m0.BUILTIN_PACKAGED_MODEL_RESOURCE_ID,
+                "size_bytes": 100,
+                "sha256": "e" * 64,
+                "compile_excluded_from_generation": True,
+            },
+            "built-in-sm-source",
+            id="builtin-compiled",
+        ),
+        *[
+            pytest.param(
+                "built-in-sm",
+                mode,
+                {
+                    "kind": "explicit-prepared-model",
+                    "resource_id": None,
+                    "file": {
+                        "path": "/wrong/model.pacbin",
+                        "resolved_path": "/wrong/model.pacbin",
+                        "size_bytes": 100,
+                        "sha256": "e" * 64,
+                    },
+                    "compile_excluded_from_generation": True,
+                },
+                "packaged-prepared-model",
+                id=f"builtin-{mode}",
+            )
+            for mode in ("eager", "recurrence")
+        ],
+        *[
+            pytest.param(
+                "ufo-sm",
+                mode,
+                {
+                    "kind": "packaged-prepared-model",
+                    "resource_id": m0.BUILTIN_PACKAGED_MODEL_RESOURCE_ID,
+                    "size_bytes": 100,
+                    "sha256": "e" * 64,
+                    "compile_excluded_from_generation": True,
+                },
+                "explicit-prepared-model",
+                id=f"ufo-{mode}",
+            )
+            for mode in m0.MODES
+        ],
+    ],
+)
+def test_model_family_mode_policy_matrix_rejects_supported_wrong_branches(
+    tmp_path: Path,
+    model: str,
+    mode: str,
+    wrong_identity: dict[str, object],
+    expected_kind: str,
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    identities = copy.deepcopy(
+        corpus["captures"][(model, "topology-replay")]["configuration"][
+            "model_identities"
+        ]
+    )
+    identities[mode] = wrong_identity
+    with pytest.raises(m0.EvidenceError, match=f"must use {expected_kind}"):
+        m0._validate_generation_model_identities(
+            identities,
+            model_family=model,
+            source_revision=SOURCE_REVISION,
+            label="test.model_identities",
+        )
+
+
+def test_cli_accepts_the_content_addressed_positive_fixture(
+    tmp_path: Path,
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    output = tmp_path / "cli-decision.json"
+    completed = subprocess.run(
+        [
+            sys.executable,
+            str(M0_SCRIPT),
+            "--request",
+            corpus["request_ref"]["path"],
+            "--request-sha256",
+            corpus["request_ref"]["sha256"],
+            "--output",
+            str(output),
+        ],
+        cwd=ROOT,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert completed.returncode == 0, completed.stderr
+    summary = json.loads(completed.stdout)
+    assert summary["accepted"] is True
+    assert summary["output"] == str(output)
+    decision = json.loads(output.read_text(encoding="utf-8"))
+    assert decision["content_sha256"] == m0._canonical_sha256(
+        {key: value for key, value in decision.items() if key != "content_sha256"}
+    )
+
+
+@pytest.mark.parametrize(
+    "mutate",
+    [
+        pytest.param(
+            lambda corpus: corpus["captures"][
+                ("built-in-sm", "topology-replay")
+            ].__setitem__("complete", False),
+            id="incomplete-capture",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][
+                ("built-in-sm", "topology-replay")
+            ].__setitem__("schema_version", 5),
+            id="obsolete-schema-5-capture",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "configuration"
+            ].__setitem__("jit_optimization_level", 2),
+            id="o2-capture",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "generation"
+            ]["compiled"]["effective_contract"].__setitem__(
+                "jit_optimization_level", 2
+            ),
+            id="compiled-generation-not-o3",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "generation"
+            ]["recurrence"]["effective_contract"].__setitem__(
+                "jit_optimization_level", 3
+            ),
+            id="recurrence-prepared-generation-contract-drift",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "configuration"
+            ].__setitem__("batch_sizes", [1, 128]),
+            id="missing-batch",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "configuration"
+            ].__setitem__("specialize_flow_at_generation", True),
+            id="generation-fixed-headline",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "provenance"
+            ].__setitem__("external_watchdog_required_for_long_runs", False),
+            id="watchdog-provenance-disabled",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "validation_preflight"
+            ].__setitem__("passes", False),
+            id="validation-preflight-drift",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][
+                ("built-in-sm", "topology-replay")
+            ].__setitem__(
+                "paired_profile_coordination",
+                {"kind": "unexpected-paired-campaign"},
+            ),
+            id="unexpected-paired-profile-coordination",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "source"
+            ].__setitem__("revision", "e" * 40),
+            id="source-identity-drift",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "provenance"
+            ]["host"].__setitem__("logical_cpu_count", 99),
+            id="host-identity-drift",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "runtime_provenance"
+            ]["native_extension"].__setitem__("build_inputs_sha256", "f" * 64),
+            id="runtime-identity-drift",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "profiles"
+            ]["compiled"]["selector_contract"].__setitem__(
+                "resolved_color_flow_id", "flow:forged"
+            ),
+            id="py-selector-drift",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "profiles"
+            ]["compiled"]["artifact_semantic_identity"]["coverage"].__setitem__(
+                "complete_physical_axes", False
+            ),
+            id="incomplete-physical-axes",
+        ),
+        pytest.param(
+            lambda corpus: corpus["captures"][("built-in-sm", "topology-replay")][
+                "profiles"
+            ]["compiled"]["profiles"][0]["subprocess_samples"].pop(),
+            id="too-few-py-subprocess-samples",
+        ),
+    ],
+)
+def test_capture_rejection_classes(
+    tmp_path: Path,
+    mutate: Callable[[dict[str, Any]], None],
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    mutate(corpus)
+    _rewrite_capture(corpus, model="built-in-sm", layout="topology-replay")
+    _rewrite_request(corpus)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert decision["accepted"] is False
+    assert decision["status"] == "rejected"
+    assert decision["errors"]
+    assert decision["comparisons"] is None
+
+
+@pytest.mark.parametrize(
+    ("role", "mutate"),
+    [
+        pytest.param(
+            m0.AMPLICOL_SELECTED_ROLE,
+            lambda payload: payload.__setitem__("complete", False),
+            id="incomplete",
+        ),
+        pytest.param(
+            m0.AMPLICOL_SELECTED_ROLE,
+            lambda payload: payload.__setitem__("evidence_scope", "fixture"),
+            id="fixture-evidence",
+        ),
+        pytest.param(
+            m0.AMPLICOL_SELECTED_ROLE,
+            lambda payload: payload["selector"].__setitem__(
+                "resolved_color_flow_id", "flow:forged"
+            ),
+            id="selector-drift",
+        ),
+        pytest.param(
+            m0.AMPLICOL_SELECTED_ROLE,
+            lambda payload: payload["selector"].__setitem__(
+                "source_to_generated_permutation", [0]
+            ),
+            id="truncated-source-permutation",
+        ),
+        pytest.param(
+            m0.AMPLICOL_UNION_ROLE,
+            lambda payload: payload["validation"]["resolved_sums"].__setitem__(
+                1, [99.0, 0.0]
+            ),
+            id="resolved-sum-closure",
+        ),
+        pytest.param(
+            m0.AMPLICOL_UNION_ROLE,
+            lambda payload: payload["timing"]["samples"].pop(),
+            id="too-few-samples",
+        ),
+        pytest.param(
+            m0.AMPLICOL_UNION_ROLE,
+            lambda payload: payload["source"]["compiler"].__setitem__(
+                "version", "different"
+            ),
+            id="source-compiler-drift",
+        ),
+    ],
+)
+def test_amplicol_rejection_classes(
+    tmp_path: Path,
+    role: str,
+    mutate: Callable[[dict[str, Any]], None],
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    mutate(corpus["amplicol"][role])
+    if (
+        role == m0.AMPLICOL_UNION_ROLE
+        and len(corpus["amplicol"][role]["timing"]["samples"]) == 6
+    ):
+        samples = corpus["amplicol"][role]["timing"]["samples"]
+        corpus["amplicol"][role]["timing"]["sample_count"] = len(samples)
+        corpus["amplicol"][role]["timing"]["samples_sha256"] = m0._canonical_sha256(
+            samples
+        )
+    _rewrite_amplicol(corpus, role)
+    _rewrite_request(corpus)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert decision["accepted"] is False
+    assert decision["errors"]
+
+
+def test_rejects_content_hash_drift_before_parsing_evidence(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    evidence = Path(corpus["request"]["captures"]["ufo-sm"]["all-flow-union"]["path"])
+    raw = evidence.read_bytes()
+    evidence.write_bytes(b" " + raw[1:])
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert "content hash drifted" in decision["errors"][0]
+
+
+def test_rejects_blocked_amplicol_workloads_mislabeled_as_interleaved(
+    tmp_path: Path,
+) -> None:
+    corpus = _make_corpus(tmp_path)
+    selected = corpus["amplicol"][m0.AMPLICOL_SELECTED_ROLE]["timing"]["samples"]
+    union = corpus["amplicol"][m0.AMPLICOL_UNION_ROLE]["timing"]["samples"]
+    for index, sample in enumerate(selected):
+        sample["interleave_position"] = index
+    for index, sample in enumerate(union):
+        sample["interleave_position"] = m0.MIN_SAMPLES + index
+    for role in (m0.AMPLICOL_SELECTED_ROLE, m0.AMPLICOL_UNION_ROLE):
+        samples = corpus["amplicol"][role]["timing"]["samples"]
+        corpus["amplicol"][role]["timing"]["samples_sha256"] = m0._canonical_sha256(
+            samples
+        )
+        _rewrite_amplicol(corpus, role)
+    _rewrite_request(corpus)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert decision["accepted"] is False
+    assert "interleav" in decision["errors"][0]
+
+
+def test_rejects_amplicol_raw_momenta_file_drift(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    role = m0.AMPLICOL_UNION_ROLE
+    replacement = _write_bytes(tmp_path / "different-momenta.json", b"different\n")
+    corpus["amplicol"][role]["momenta"]["raw_file"] = replacement
+    _rewrite_amplicol(corpus, role)
+    _rewrite_request(corpus)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert "not bound to its evidence" in decision["errors"][0]
+
+
+def test_rejects_timing_longer_than_subprocess_envelope(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    role = m0.AMPLICOL_SELECTED_ROLE
+    sample = corpus["amplicol"][role]["timing"]["samples"][0]
+    sample["elapsed_seconds"] = 1.0e6
+    sample["seconds_per_point"] = 1.0e3
+    raw_path = Path(sample["raw_output_file"]["path"])
+    raw_payload = json.loads(raw_path.read_text(encoding="utf-8"))
+    raw_payload["elapsed_seconds"] = sample["elapsed_seconds"]
+    raw_payload["seconds_per_point"] = sample["seconds_per_point"]
+    without_digest = dict(raw_payload)
+    without_digest.pop("content_sha256")
+    raw_payload["content_sha256"] = m0._canonical_sha256(without_digest)
+    sample["raw_output_file"] = _write_json(raw_path, raw_payload)
+    _refresh_amplicol_timing(corpus, role)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert "exceeds its subprocess envelope" in decision["errors"][0]
+
+
+def test_rejects_unstructured_amplicol_raw_output(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    role = m0.AMPLICOL_SELECTED_ROLE
+    sample = corpus["amplicol"][role]["timing"]["samples"][0]
+    raw_path = Path(sample["raw_output_file"]["path"])
+    sample["raw_output_file"] = _write_bytes(raw_path, b"garbage\n")
+    _refresh_amplicol_timing(corpus, role)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert "is not strict JSON" in decision["errors"][0]
+
+
+def test_rejects_self_pinned_empty_host_contract(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    for model in m0.MODELS:
+        for layout in m0.LAYOUTS:
+            corpus["captures"][(model, layout)]["provenance"]["host"] = {}
+            _rewrite_capture(corpus, model=model, layout=layout)
+    for role in (m0.AMPLICOL_SELECTED_ROLE, m0.AMPLICOL_UNION_ROLE):
+        corpus["amplicol"][role]["host"] = {}
+        _rewrite_amplicol(corpus, role)
+    corpus["request"]["expected"]["host_sha256"] = m0._canonical_sha256({})
+    _rewrite_request(corpus)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert "host keys differ" in decision["errors"][0]
+
+
+def test_rejects_self_pinned_empty_runtime_contract(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    for model in m0.MODELS:
+        for layout in m0.LAYOUTS:
+            corpus["captures"][(model, layout)]["runtime_provenance"] = {}
+            _rewrite_capture(corpus, model=model, layout=layout)
+    corpus["request"]["expected"]["runtime_provenance_sha256"] = m0._canonical_sha256(
+        {}
+    )
+    _rewrite_request(corpus)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert "runtime_provenance keys differ" in decision["errors"][0]
+
+
+def test_rejects_self_pinned_null_model_identity_inventory(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    model = "built-in-sm"
+    for layout in m0.LAYOUTS:
+        corpus["captures"][(model, layout)]["configuration"]["model_identities"] = None
+        _rewrite_capture(corpus, model=model, layout=layout)
+    corpus["request"]["expected"]["generation_model_identities_sha256"][model] = (
+        m0._canonical_sha256(None)
+    )
+    _rewrite_request(corpus)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert "model_identities must be a JSON object" in decision["errors"][0]
+
+
+def test_rejects_absent_evidence(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    evidence = Path(
+        corpus["request"]["amplicol_evidence"][m0.AMPLICOL_SELECTED_ROLE]["path"]
+    )
+    evidence.unlink()
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert "does not exist" in decision["errors"][0]
+
+
+def test_rejects_unknown_request_key(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    corpus["request"]["policy_override"] = {"minimum_samples": 1}
+    _rewrite_request(corpus)
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert "unknown=['policy_override']" in decision["errors"][0]
+
+
+def test_rejects_duplicate_json_keys(tmp_path: Path) -> None:
+    corpus = _make_corpus(tmp_path)
+    request_path = Path(corpus["request_ref"]["path"])
+    request_path.write_text('{"kind":"a","kind":"b"}\n', encoding="utf-8")
+    corpus["request_ref"] = {
+        **corpus["request_ref"],
+        "size_bytes": request_path.stat().st_size,
+        "sha256": hashlib.sha256(request_path.read_bytes()).hexdigest(),
+    }
+    decision, code = _run(tmp_path, corpus)
+    assert code == 2
+    assert "duplicate JSON key" in decision["errors"][0]
diff --git a/pyamplicol/tests/unit/test_eager_exact_runtime.py b/pyamplicol/tests/unit/test_eager_exact_runtime.py
new file mode 100644
index 0000000000..da2f97f9dc
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_exact_runtime.py
@@ -0,0 +1,1895 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Callable, Mapping, Sequence
+from decimal import Decimal, localcontext
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol._internal.versions import EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY
+from pyamplicol.api.errors import ArtifactError, CompatibilityError, EvaluationError
+from pyamplicol.artifacts import ArtifactBuilder, load_manifest
+from pyamplicol.generation.eager_lowering import EAGER_RUNTIME_KIND
+from pyamplicol.generation.eager_tables import (
+    EAGER_KERNEL_ABI,
+    EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+    EAGER_OUTPUT_FACTOR_NONE,
+    EAGER_PLAN_ABI,
+    EAGER_RUNTIME_CAPABILITY,
+    MISSING_U32,
+    EagerAttachmentRow,
+    EagerClosureRow,
+    EagerCouplingRow,
+    EagerFinalizationRow,
+    EagerInvocationRow,
+    pack_rows,
+)
+from pyamplicol.models.prepared import PreparedKernelPack, PreparedKernelRecord
+from pyamplicol.runtime._evaluator_payloads import ExactEvaluatorPayloadResolver
+from pyamplicol.runtime.eager_exact import (
+    EagerExactExecutor as _EagerExactExecutor,
+)
+from pyamplicol.runtime.eager_exact import _plan_v3
+from pyamplicol.runtime.eager_exact._contracts import (
+    _ExactComplexProduct,
+    _resolve_exact_factor,
+)
+from pyamplicol.runtime.eager_exact._execution import _gather_inputs
+from pyamplicol.runtime.eager_exact._plan import (
+    _EagerExactPlan,
+    _prepared_parameter_projection,
+)
+from pyamplicol.runtime.eager_exact._plan_v3 import (
+    EAGER_EXACT_SECTIONS_ABI,
+    EAGER_PLAN_V3_ABI,
+    EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+    EAGER_REDUCTION_GROUPS_ABI,
+    EAGER_RUNTIME_LAYOUT_ABI,
+)
+
+eager_plan_v3 = _plan_v3
+
+_ComplexDecimal = tuple[Decimal, Decimal]
+_ExactCallable = Callable[[Sequence[_ComplexDecimal], int], Sequence[_ComplexDecimal]]
+_COMPACT_SECTIONS_BY_ARTIFACT: dict[Path, dict[str, object]] = {}
+
+
+def test_exact_factor_product_is_combined_at_requested_precision() -> None:
+    factors = _ExactComplexProduct(
+        numerators=(
+            (Decimal.from_float(0.1), Decimal(0)),
+            (Decimal.from_float(0.2), Decimal(0)),
+        ),
+        denominator=(Decimal.from_float(0.3), Decimal(0)),
+    )
+
+    with localcontext() as context:
+        context.prec = 50
+        resolved = _resolve_exact_factor(factors)
+        expected = (
+            Decimal.from_float(0.1) * Decimal.from_float(0.2) / Decimal.from_float(0.3)
+        )
+
+    assert resolved == (expected, Decimal(0))
+    assert resolved[0] != Decimal.from_float((0.1 * 0.2) / 0.3)
+
+
+class _NativeRuntime:
+    def __init__(
+        self,
+        model_parameter_values: Sequence[float] = (),
+        normalization_factor: float = 1.0,
+        *,
+        representative_process_id: str = "synthetic",
+        representative_process_key: str = "synthetic",
+        external_permutation: Sequence[int] = (0, 1, 2),
+        physics: Mapping[str, object] | None = None,
+    ) -> None:
+        self._model_parameter_values = tuple(model_parameter_values)
+        self._normalization_factor = normalization_factor
+        self._representative_process_id = representative_process_id
+        self._representative_process_key = representative_process_key
+        self._external_permutation = tuple(external_permutation)
+        self._public_physics = physics
+
+    def _exact_runtime_state_json(self) -> str:
+        return json.dumps(
+            {
+                "model_parameter_values": self._model_parameter_values,
+                "normalization_factor": self._normalization_factor,
+                "representative_process_id": self._representative_process_id,
+                "representative_process_key": self._representative_process_key,
+                "external_permutation": self._external_permutation,
+            }
+        )
+
+    def physics_json(self) -> str:
+        return json.dumps(self._public_physics or _physics())
+
+
+def test_eager_diagnostic_projection_maps_alias_masses_to_caller_order() -> None:
+    executor = object.__new__(_EagerExactExecutor)
+    schema = {
+        "model": {
+            "particles": [
+                {"pdg": 25, "mass": 125.0, "mass_parameter": "ufo.MH"},
+                {"pdg": 21, "mass": 0.0, "mass_parameter": None},
+            ]
+        },
+        "model_parameters": [
+            {"name": "ufo.MH", "parameter_index": 0},
+        ],
+    }
+    executor._native_runtime = _NativeRuntime((3.0,))
+    executor._exact_execution = {"runtime_schema": schema}
+    executor._physics = {
+        "external_particles": [
+            {"label": 1, "pdg": 21, "role": "final"},
+            {"label": 2, "pdg": 25, "role": "final"},
+        ]
+    }
+    # Native public physics and its PDG-derived bindings are already (g, H).
+    # The retained representative permutation must not be applied a second time.
+    executor._permutation = (1, 0)
+
+    projected, metadata = executor._diagnostic_project_onshell(
+        (((-4.0, 0.0, 0.0, 4.0), (4.9, 4.0, 0.0, 0.0)),),
+        precision=200,
+    )
+
+    assert projected[0][0][0] == Decimal("-4.0")
+    assert projected[0][1][0] == Decimal("5.0")
+    gluon, higgs = metadata["points"][0]["legs"]
+    assert (gluon["pdg"], gluon["mass"], gluon["projected_energy"]) == (
+        21,
+        "0.0",
+        "-4.0",
+    )
+    assert higgs["pdg"] == 25
+    assert higgs["mass"] == "3.0"
+    assert higgs["mass_parameter"] == "ufo.MH"
+    assert Decimal(higgs["shell_residual_after"]) == 0
+
+
+def _contract(role: str, component: int) -> dict[str, object]:
+    return {
+        "role": role,
+        "component": component,
+        "symbol": f"test::{role}::{component}",
+        "model_parameter_name": None,
+        "model_parameter_index": None,
+    }
+
+
+def _parameter_contract(name: str, index: int) -> dict[str, object]:
+    return {
+        "role": "model-parameter",
+        "component": 0,
+        "symbol": f"test::model-parameter::{index}",
+        "model_parameter_name": name,
+        "model_parameter_index": index,
+    }
+
+
+def _kernel(
+    kernel_id: int,
+    kind: str,
+    contracts: tuple[dict[str, object], ...],
+    *,
+    output_layout: tuple[str, ...] = ("scalar:0",),
+) -> PreparedKernelRecord:
+    exact_path = f"kernels/{kernel_id:06d}/exact.bin"
+    return PreparedKernelRecord(
+        kernel_id=kernel_id,
+        contract_kind=kind,  # type: ignore[arg-type]
+        canonical_signature=f"test:{kind}:{kernel_id}",
+        input_arity=len(contracts),
+        output_arity=len(output_layout),
+        input_layout=tuple(
+            f"{contract['role']}:{contract['component']}" for contract in contracts
+        ),
+        input_contracts=contracts,
+        output_layout=output_layout,
+        exact_expressions=tuple(
+            f"test::output::{index}" for index in range(len(output_layout))
+        ),
+        exact_evaluator_state_path=exact_path,
+        f64_evaluator_manifest={
+            "kind": "symjit-application-evaluator",
+            "input_len": len(contracts),
+            "output_len": len(output_layout),
+            "optimization_level": 2,
+            "settings": {"jit_optimization_level": 2},
+            "application_path": f"kernels/{kernel_id:06d}/application.symjit",
+            "evaluator_state_path": exact_path,
+        },
+    )
+
+
+def _source_record() -> dict[str, object]:
+    crossing = {
+        "momentum_transform": "identity",
+        "helicity_factor": 1,
+        "chirality_factor": 1,
+        "spin_state_factor": 1,
+        "phase": [1.0, 0.0],
+    }
+    return {
+        "source_id": 0,
+        "current_id": 0,
+        "current_component_start": 0,
+        "current_component_stop": 1,
+        "value_slot": {
+            "value_slot_id": 0,
+            "current_id": 0,
+            "variant": "source",
+            "component_start": 0,
+            "component_stop": 1,
+            "dimension": 1,
+        },
+        "source_parameter_start": 0,
+        "source_parameter_stop": 1,
+        "leg_label": 1,
+        "input_momentum_slot": 0,
+        "side": "final",
+        "crossing": "identity",
+        "physical_pdg": 9000001,
+        "outgoing_pdg": 9000001,
+        "particle_id": 9000001,
+        "anti_particle_id": 9000001,
+        "source_kind": "external-wavefunction",
+        "wavefunction_kind": "scalar",
+        "source_orientation": "self-conjugate",
+        "source_basis": "scalar",
+        "source_ir": {
+            "basis": "scalar",
+            "component_dimension": 1,
+            "crossing": crossing,
+            "identity": {
+                "pdg_label": 9000001,
+                "anti_pdg_label": 9000001,
+                "orientation": "self-conjugate",
+            },
+            "states": [{"helicity": 0, "chirality": 0, "spin_state": 0}],
+            "wavefunction_family": "scalar",
+        },
+        "applied_crossing": crossing,
+        "source_helicity": 0,
+        "chirality": 0,
+        "spin_state": 0,
+        "dimension": 1,
+        "helicity_ancestry": "1",
+        "color_state": {},
+    }
+
+
+def _runtime_schema(*, direct_closure: bool) -> dict[str, object]:
+    root: dict[str, object] = {
+        "output_index": 0,
+        "root_id": 0,
+        "kind": "direct-contraction" if direct_closure else "prepared-closure",
+        "left_current_id": 1,
+        "right_current_id": 0,
+        "left_value_slot": {"value_slot_id": 2},
+        "right_value_slot": {"value_slot_id": 0},
+        "coherent_group_id": 0,
+        "color_sector_id": 0,
+        "helicity_weight": 1.0,
+        "all_sector_weight": 1.0,
+    }
+    if direct_closure:
+        root["contraction_ir"] = {"coefficients": [[2.0, 0.0]]}
+    return {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-execution-plan",
+        "process_key": "synthetic",
+        "process": "s > s",
+        "external_particles": [{"label": 1, "role": "final"}],
+        "model": {"particles": []},
+        "model_parameters": [],
+        "normalization": {},
+        "parameter_layout": {
+            "source_component_parameter_count": 1,
+            "momentum_parameter_count": 4,
+            "model_parameter_count": 0,
+            "parameter_count_if_flattened": 5,
+            "value_component_count": 3,
+            "source_components_complex": True,
+            "momentum_components_real": True,
+            "real_valued_inputs": [1, 2, 3, 4],
+        },
+        "current_storage": {
+            "component_count": 2,
+            "number_type": "complex",
+            "metadata_compacted": True,
+            "current_slots": [
+                {
+                    "current_id": 0,
+                    "component_start": 0,
+                    "component_stop": 1,
+                    "dimension": 1,
+                    "is_source": True,
+                },
+                {
+                    "current_id": 1,
+                    "component_start": 1,
+                    "component_stop": 2,
+                    "dimension": 1,
+                    "is_source": False,
+                },
+            ],
+        },
+        "value_storage": {
+            "component_count": 3,
+            "number_type": "complex",
+            "metadata_compacted": True,
+            "value_slots": [
+                {
+                    "value_slot_id": 0,
+                    "current_id": 0,
+                    "variant": "source",
+                    "component_start": 0,
+                    "component_stop": 1,
+                    "dimension": 1,
+                },
+                {
+                    "value_slot_id": 1,
+                    "current_id": 1,
+                    "variant": "unpropagated",
+                    "component_start": 1,
+                    "component_stop": 2,
+                    "dimension": 1,
+                },
+                {
+                    "value_slot_id": 2,
+                    "current_id": 1,
+                    "variant": "propagated",
+                    "component_start": 2,
+                    "component_stop": 3,
+                    "dimension": 1,
+                },
+            ],
+        },
+        "source_fill": {"source_count": 1, "sources": [_source_record()]},
+        "momentum_slots": [
+            {
+                "momentum_slot_id": 0,
+                "momentum_mask": 1,
+                "external_labels": [1],
+                "component_start": 0,
+                "component_stop": 4,
+                "real_valued": True,
+            }
+        ],
+        "stages": [
+            {
+                "stage_index": 1,
+                "stage_kind": "current-combine",
+                "subset_size": 1,
+                "input_current_ids": [0],
+                "output_current_ids": [1],
+                "input_value_slot_ids": [0],
+                "output_value_slot_ids": [1, 2],
+                "interaction_count": 2,
+                "interactions_compacted": True,
+                "interaction_ids": [0, 1],
+                "interactions": [],
+            }
+        ],
+        "amplitude_stage": {
+            "stage_kind": "amplitude",
+            "output_count": 1,
+            "color_contraction": None,
+            "roots": [root],
+        },
+    }
+
+
+def _physics() -> dict[str, object]:
+    return {
+        "extensions": {"normalization": {}},
+        "schema_version": 1,
+        "kind": "pyamplicol-runtime-physics",
+        "process_id": "synthetic",
+        "process": "s > s s",
+        "color_accuracy": "lc",
+        "external_particles": [{}, {}, {}],
+        "helicities": [{"id": "h:0", "values": [0, 0, 0], "coefficient": 1.0}],
+        "color_components": [
+            {
+                "id": "flow:1",
+                "kind": "lc-flow",
+                "word": [1],
+                "coefficient": 1.0,
+            }
+        ],
+        "reduction": {
+            "kind": "symmetry-reduction",
+            "groups": [
+                {
+                    "id": "reduction:0",
+                    "physical_helicity_ids": ["h:0"],
+                    "physical_color_ids": ["flow:1"],
+                    "representative_helicity_id": "h:0",
+                    "representative_color_id": "flow:1",
+                }
+            ],
+        },
+    }
+
+
+def _momenta(*energies: int) -> list[list[tuple[int, int, int, int]]]:
+    return [
+        [(energy, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0)]
+        for energy in energies
+    ]
+
+
+def _producer() -> dict[str, object]:
+    return {
+        "distribution": "pyamplicol",
+        "version": "0.1.0",
+        "versions": {
+            "python_api": 1,
+            "toml": 1,
+            "compiled_model": 9,
+            "process_artifact": 3,
+            "runtime_physics": 1,
+            "symbolica_serialization": "test",
+            "c_abi": 1,
+        },
+        "target": {"triple": "test-target", "cpu_features": []},
+    }
+
+
+def _build_artifact(
+    root: Path,
+    *,
+    direct_closure: bool = False,
+    invocation_kernel_id: int = 10,
+    invocation_row_size: int | None = None,
+    plan_abi: str = EAGER_PLAN_ABI,
+    kernel_abi: str | None = EAGER_KERNEL_ABI,
+    prepared_backend: str = "jit",
+    vertex_contracts: tuple[dict[str, object], ...] | None = None,
+    parameter_kernel: PreparedKernelRecord | None = None,
+    extra_kernels: Sequence[PreparedKernelRecord] = (),
+    model_parameters: Sequence[dict[str, object]] = (),
+    coupling_row: EagerCouplingRow | None = None,
+    invocation_output_factor_source: int = EAGER_OUTPUT_FACTOR_NONE,
+    closure_output_factor_source: int = EAGER_OUTPUT_FACTOR_NONE,
+    compact_v3: bool = True,
+) -> dict[str, object] | None:
+    payload_target = {"triple": "test-target", "cpu_features": []}
+    base_kernels = (
+        _kernel(
+            10,
+            "vertex",
+            vertex_contracts
+            or (
+                _contract("left-current", 0),
+                _contract("right-current", 0),
+                _contract("coupling-real", 0),
+            ),
+        ),
+        _kernel(
+            11,
+            "propagator",
+            (_contract("current", 0), _contract("momentum", 0)),
+        ),
+        _kernel(
+            12,
+            "closure",
+            (
+                _contract("left-current", 0),
+                _contract("right-current", 0),
+                _contract("coupling-real", 0),
+            ),
+        ),
+    )
+    kernels = base_kernels + tuple(extra_kernels)
+    if parameter_kernel is not None:
+        kernels += (parameter_kernel,)
+    pack = PreparedKernelPack(
+        backend="jit",
+        optimization_settings={"jit_optimization_level": 2},
+        producer={"distribution": "pyamplicol", "version": "test"},
+        dependency_abis={
+            "symbolica_serialization": "test",
+            "symjit_plane_application": "pyamplicol-symjit-plane-application-v2",
+        },
+        provenance={"compiled_model": "test"},
+        target={
+            "portable": True,
+            "word_bits": 64,
+            "endianness": "little",
+            "target_triple": "symjit-storage-v3-portable",
+            "cpu_features": [],
+        },
+        resolver_manifest={
+            "abi": "pyamplicol-prepared-kernel-catalog-v1",
+            "model_name": "synthetic",
+        },
+        kernels=kernels,
+    )
+    pack_payload = pack.to_dict()
+    if kernel_abi is not None:
+        pack_payload["eager_kernel_abi"] = kernel_abi
+    pack_payload["backend"] = prepared_backend
+    coupling_rows = (
+        coupling_row or EagerCouplingRow(MISSING_U32, MISSING_U32, 1.0, 0.0),
+    )
+    invocations = (
+        EagerInvocationRow(
+            invocation_kernel_id,
+            0,
+            0,
+            0,
+            0,
+            0,
+            invocation_output_factor_source,
+            0,
+            1,
+        ),
+        EagerInvocationRow(
+            invocation_kernel_id,
+            0,
+            0,
+            0,
+            0,
+            0,
+            invocation_output_factor_source,
+            1,
+            1,
+        ),
+    )
+    attachments = (
+        EagerAttachmentRow(1, 1.0, 0.0),
+        EagerAttachmentRow(1, 2.0, 0.0),
+    )
+    finalizations = (EagerFinalizationRow(11, 1, 1, 2, 0),)
+    closure = EagerClosureRow(
+        MISSING_U32 if direct_closure else 12,
+        2,
+        0,
+        0,
+        MISSING_U32 if direct_closure else 0,
+        closure_output_factor_source,
+        0.5 if direct_closure else 1.0,
+        0.0,
+    )
+    tables = {
+        "eager/couplings.bin": pack_rows(coupling_rows),
+        "eager/stage-1-invocations.bin": pack_rows(invocations),
+        "eager/stage-1-attachments.bin": pack_rows(attachments),
+        "eager/stage-1-finalizations.bin": pack_rows(finalizations),
+        "eager/closures.bin": pack_rows((closure,)),
+    }
+    plan = {
+        "kind": EAGER_RUNTIME_KIND,
+        "eager_plan_abi": plan_abi,
+        "required_runtime_capabilities": [EAGER_RUNTIME_CAPABILITY],
+        "process_key": "synthetic",
+        "couplings": {
+            "path": "eager/couplings.bin",
+            "count": 1,
+            "row_size": EagerCouplingRow._STRUCT.size,
+        },
+        "stages": [
+            {
+                "stage_index": 1,
+                "subset_size": 1,
+                "invocations": {
+                    "path": "eager/stage-1-invocations.bin",
+                    "count": 2,
+                    "row_size": (
+                        invocation_row_size
+                        if invocation_row_size is not None
+                        else EagerInvocationRow._STRUCT.size
+                    ),
+                },
+                "attachments": {
+                    "path": "eager/stage-1-attachments.bin",
+                    "count": 2,
+                    "row_size": EagerAttachmentRow._STRUCT.size,
+                },
+                "finalizations": {
+                    "path": "eager/stage-1-finalizations.bin",
+                    "count": 1,
+                    "row_size": EagerFinalizationRow._STRUCT.size,
+                },
+            }
+        ],
+        "closures": {
+            "path": "eager/closures.bin",
+            "count": 1,
+            "row_size": EagerClosureRow._STRUCT.size,
+        },
+    }
+    runtime_schema = _runtime_schema(direct_closure=direct_closure)
+    runtime_schema["model_parameters"] = list(model_parameters)
+    parameter_layout = runtime_schema["parameter_layout"]
+    assert isinstance(parameter_layout, dict)
+    parameter_layout["model_parameter_count"] = len(model_parameters)
+    parameter_layout["parameter_count_if_flattened"] = (
+        int(parameter_layout["source_component_parameter_count"])
+        + int(parameter_layout["momentum_parameter_count"])
+        + len(model_parameters)
+    )
+    execution = {
+        "schema_version": 3,
+        "kind": EAGER_RUNTIME_KIND,
+        "required_runtime_capabilities": [EAGER_RUNTIME_CAPABILITY],
+        "process": "s > s",
+        "key": "synthetic",
+        "color_accuracy": "lc",
+        "external_pdg_order": [9000001, 9000001, 9000001],
+        "eager_plan_abi": plan_abi,
+        "kernel_pack": {
+            "manifest_path": "model/eager-kernel-pack.json",
+            "payload_root": "model/eager-kernels",
+        },
+        "runtime_options": {"point_tile_size": 1024, "workspace_mib": 256},
+        "plan": plan,
+        "dag_summary": {},
+        "runtime_schema": runtime_schema,
+    }
+    capabilities = [EAGER_RUNTIME_CAPABILITY]
+    compact_sections: dict[str, object] | None = None
+    if compact_v3:
+        capabilities = sorted(
+            (
+                EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+                EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+            )
+        )
+        execution = {
+            "schema_version": 3,
+            "kind": EAGER_RUNTIME_KIND,
+            "required_runtime_capabilities": capabilities,
+            "process": "s > s",
+            "key": "synthetic",
+            "color_accuracy": "lc",
+            "external_pdg_order": [9000001, 9000001, 9000001],
+            "eager_plan_abi": EAGER_PLAN_V3_ABI,
+            "kernel_pack": {
+                "manifest_path": "model/eager-kernel-pack.json",
+                "payload_root": "model/eager-kernels",
+            },
+            "runtime_options": {"point_tile_size": 1024, "workspace_mib": 256},
+            "plan": {
+                "kind": EAGER_RUNTIME_KIND,
+                "eager_plan_abi": EAGER_PLAN_V3_ABI,
+                "lowering_input_abi": "pyamplicol-eager-lowering-input-v1",
+                "lowering_input_sha256": "1" * 64,
+                "runtime_layout_abi": EAGER_RUNTIME_LAYOUT_ABI,
+                "required_runtime_capabilities": capabilities,
+                "runtime_container": {
+                    "kind": "pyamplicol-eager-runtime-container",
+                    "schema_version": 1,
+                    "storage_abi": "pacbin-v1",
+                    "path": "eager-runtime.pacbin",
+                    "size_bytes": 1,
+                    "sha256": "2" * 64,
+                    "member_count": 1,
+                    "unpacked_size_bytes": 1,
+                    "index_sha256": "3" * 64,
+                },
+                "inspection_summary": {},
+            },
+            "dag_summary": {},
+        }
+        compact_sections = {
+            "abi": EAGER_EXACT_SECTIONS_ABI,
+            "runtime_layout_abi": EAGER_RUNTIME_LAYOUT_ABI,
+            "process_id": "synthetic",
+            "exact_schema": runtime_schema,
+            "reduction_groups": _physics()["reduction"]["groups"],
+            "selector_group_ids": [0],
+            "selector_domains": [[0]],
+            "couplings": [
+                [
+                    row.real_parameter_id,
+                    row.imag_parameter_id,
+                    str(row.constant_real),
+                    str(row.constant_imag),
+                ]
+                for row in coupling_rows
+            ],
+            "stages": [[1, 0, len(invocations), 0, len(attachments), 0, 1]],
+            "invocations": [[*row._values(), 0] for row in invocations],
+            "attachments": [
+                [
+                    row.result_current_id,
+                    [[str(row.factor_real), str(row.factor_imag)]],
+                    None,
+                    0,
+                ]
+                for row in attachments
+            ],
+            "finalizations": [[*row._values(), 0, 0] for row in finalizations],
+            "closures": [
+                [
+                    closure.kernel_id,
+                    closure.left_value_slot_id,
+                    closure.right_value_slot_id,
+                    closure.amplitude_index,
+                    closure.coupling_slot_id,
+                    closure.output_factor_source,
+                    [[str(closure.factor_real), str(closure.factor_imag)]],
+                    None,
+                    [["2.0", "0.0"]] if direct_closure else None,
+                    0,
+                    0,
+                ]
+            ],
+        }
+
+    with ArtifactBuilder(root) as builder:
+        builder.add_json(
+            "model/eager-kernel-pack.json",
+            pack_payload,
+            role="evaluator-manifest",
+        )
+        for kernel in kernels:
+            builder.add_bytes(
+                f"model/eager-kernels/{kernel.exact_evaluator_state_path}",
+                b"mock exact evaluator",
+                role="evaluator-state",
+                media_type="application/octet-stream",
+                target=payload_target,
+            )
+        builder.add_json(
+            "processes/synthetic/execution.json",
+            execution,
+            role="evaluator-manifest",
+            process_id="synthetic",
+        )
+        if compact_v3:
+            builder.add_bytes(
+                "processes/synthetic/eager-runtime.pacbin",
+                b"x",
+                role="evaluator-state",
+                media_type="application/octet-stream",
+                target=payload_target,
+                process_id="synthetic",
+            )
+        builder.add_json(
+            "processes/synthetic/physics.json",
+            _physics(),
+            role="runtime-physics",
+            process_id="synthetic",
+        )
+        if not compact_v3:
+            for path, content in tables.items():
+                builder.add_bytes(
+                    f"processes/synthetic/{path}",
+                    content,
+                    role="evaluator-state",
+                    media_type="application/octet-stream",
+                    target=payload_target,
+                    process_id="synthetic",
+                )
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=_producer(),
+            model={
+                "name": "synthetic",
+                "source_kind": "built-in-sm",
+                "content_sha256": "1" * 64,
+                "compiled_schema_version": 9,
+            },
+            configuration={
+                "toml_schema_version": 1,
+                "requested_path": "config/requested.toml",
+                "effective_path": "config/effective.toml",
+                "adjustments": [],
+            },
+            processes=[
+                {
+                    "id": "synthetic",
+                    "expression": "s > s s",
+                    "color_accuracy": "lc",
+                    "external_pdgs": [9000001, 9000001, 9000001],
+                    "physics_path": "processes/synthetic/physics.json",
+                    "required_runtime_capabilities": capabilities,
+                    "aliases": [],
+                }
+            ],
+            default_process_id="synthetic",
+            runtime={
+                "engine": "rusticol",
+                "engine_version": "0.1.0",
+                "evaluator_manifest_path": "processes/evaluators.json",
+                "api_bundle_path": None,
+                "required_runtime_capabilities": capabilities,
+            },
+        )
+    resolved_root = root.resolve()
+    if compact_sections is None:
+        _COMPACT_SECTIONS_BY_ARTIFACT.pop(resolved_root, None)
+    else:
+        _COMPACT_SECTIONS_BY_ARTIFACT[resolved_root] = compact_sections
+    return compact_sections
+
+
+class EagerExactExecutor(_EagerExactExecutor):
+    """Test adapter that supplies the synthetic compact native sections."""
+
+    def __init__(
+        self,
+        artifact: Path,
+        process_id: str,
+        native_runtime: object,
+        **options: object,
+    ) -> None:
+        if options.get("native_sections_loader") is None:
+            sections = _COMPACT_SECTIONS_BY_ARTIFACT.get(artifact.resolve())
+            if sections is not None:
+                options["native_sections_loader"] = (
+                    lambda _root, _process, payload=sections: payload
+                )
+        super().__init__(
+            artifact,
+            process_id,
+            native_runtime,
+            **options,  # type: ignore[arg-type]
+        )
+
+
+def _load_legacy_plan(
+    artifact: Path,
+    *,
+    kernel_loader: Callable[[PreparedKernelRecord, Path], _ExactCallable],
+) -> _EagerExactPlan:
+    manifest = load_manifest(artifact)
+    execution = json.loads(
+        (artifact / "processes/synthetic/execution.json").read_text(encoding="utf-8")
+    )
+    return _EagerExactPlan.load(
+        artifact_root=artifact,
+        process_root=artifact / "processes/synthetic",
+        process_id="synthetic",
+        execution=execution,
+        manifest=manifest,
+        kernel_loader=kernel_loader,
+        exact_payloads=ExactEvaluatorPayloadResolver(manifest),
+    )
+
+
+def _loader(
+    finalization_inputs: list[tuple[_ComplexDecimal, ...]],
+) -> Callable[[PreparedKernelRecord, Path], _ExactCallable]:
+    def load(record: PreparedKernelRecord, _root: Path) -> _ExactCallable:
+        if record.kernel_id == 10:
+            return lambda values, _precision: (
+                (
+                    values[0][0] + values[1][0] + values[2][0],
+                    Decimal(0),
+                ),
+            )
+        if record.kernel_id == 11:
+
+            def finalize(
+                values: Sequence[_ComplexDecimal], _precision: int
+            ) -> tuple[_ComplexDecimal, ...]:
+                finalization_inputs.append(tuple(values))
+                return ((values[0][0] * 10 + values[1][0], Decimal(0)),)
+
+            return finalize
+        if record.kernel_id == 12:
+            return lambda values, _precision: (
+                (
+                    values[0][0] + values[1][0] + values[2][0],
+                    Decimal(0),
+                ),
+            )
+        raise AssertionError(f"unexpected kernel {record.kernel_id}")
+
+    return load
+
+
+def test_eager_exact_accumulates_then_finalizes_once(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    _build_artifact(artifact)
+    finalization_inputs: list[tuple[_ComplexDecimal, ...]] = []
+    executor = EagerExactExecutor(
+        artifact,
+        "synthetic",
+        _NativeRuntime(),
+        kernel_loader=_loader(finalization_inputs),
+    )
+
+    result = executor.evaluate_resolved(
+        _momenta(5),
+        helicities=None,
+        color_flows=None,
+        precision=50,
+    )
+
+    assert finalization_inputs == [((Decimal(9), Decimal(0)), (Decimal(5), Decimal(0)))]
+    assert result.values == (((Decimal(9409),),),)
+    assert result.helicity_ids == ("h:0",)
+    assert result.color_ids == ("flow:1",)
+
+
+def test_eager_exact_uses_native_representative_for_inferred_expression(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _build_artifact(artifact)
+    executor = EagerExactExecutor(
+        artifact,
+        "s > x s",
+        _NativeRuntime(external_permutation=(0, 2, 1)),
+        kernel_loader=_loader([]),
+    )
+
+    assert executor._permutation == (0, 2, 1)
+
+
+def test_eager_exact_plan_v3_uses_native_compact_sections(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    artifact = tmp_path / "artifact"
+    sections = _build_artifact(artifact, compact_v3=True)
+    assert sections is not None
+    calls: list[tuple[str, str]] = []
+
+    def load_sections(artifact_root: str, process_id: str) -> object:
+        calls.append((artifact_root, process_id))
+        return sections
+
+    module = SimpleNamespace(_load_eager_exact_sections_v1=load_sections)
+    monkeypatch.setattr(
+        eager_plan_v3.importlib,
+        "import_module",
+        lambda name: (
+            module
+            if name == "pyamplicol._rusticol"
+            else pytest.fail(f"unexpected native import {name}")
+        ),
+    )
+    finalization_inputs: list[tuple[_ComplexDecimal, ...]] = []
+    executor = _EagerExactExecutor(
+        artifact,
+        "synthetic",
+        _NativeRuntime(),
+        kernel_loader=_loader(finalization_inputs),
+    )
+
+    result = executor.evaluate_resolved(
+        _momenta(5),
+        helicities=None,
+        color_flows=None,
+        precision=50,
+    )
+
+    assert calls == [(str(artifact.resolve()), "synthetic")]
+    assert finalization_inputs == [((Decimal(9), Decimal(0)), (Decimal(5), Decimal(0)))]
+    assert result.values == (((Decimal(9409),),),)
+
+
+def test_eager_exact_plan_v3_rejects_wrong_native_section_abi(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    sections = _build_artifact(artifact, compact_v3=True)
+    assert sections is not None
+    sections["abi"] = "pyamplicol-eager-exact-sections-v0"
+
+    with pytest.raises(CompatibilityError, match="exact-sections ABI"):
+        EagerExactExecutor(
+            artifact,
+            "synthetic",
+            _NativeRuntime(),
+            kernel_loader=_loader([]),
+            native_sections_loader=lambda _root, _process: sections,
+        )
+
+
+def test_eager_exact_plan_v3_preserves_attachment_start_diagnostic(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    sections = _build_artifact(artifact, compact_v3=True)
+    assert sections is not None
+    stages = sections["stages"]
+    assert isinstance(stages, list)
+    stage = stages[0]
+    assert isinstance(stage, list)
+    stage[3] = "invalid"
+
+    with pytest.raises(
+        ArtifactError,
+        match=r"compact eager stage 0 start must be an integer",
+    ):
+        eager_plan_v3._load_eager_exact_sections_v1(
+            artifact,
+            "synthetic",
+            loader=lambda _root, _process: sections,
+        )
+
+
+def test_eager_reduction_groups_use_bounded_native_bridge(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    groups = (
+        {
+            "id": "reduction:0",
+            "physical_color_ids": ["flow:1"],
+            "physical_helicity_ids": ["h:0"],
+        },
+    )
+    calls: list[tuple[Path, str]] = []
+
+    def load_groups(artifact_root: Path, process_id: str) -> object:
+        calls.append((artifact_root, process_id))
+        return {
+            "abi": EAGER_REDUCTION_GROUPS_ABI,
+            "runtime_layout_abi": EAGER_RUNTIME_LAYOUT_ABI,
+            "process_id": process_id,
+            "reduction_groups": groups,
+        }
+
+    loaded = eager_plan_v3._load_eager_reduction_groups_v1(
+        artifact,
+        "synthetic",
+        loader=load_groups,
+    )
+
+    assert calls == [(artifact, "synthetic")]
+    assert loaded == groups
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "match"),
+    (
+        ("abi", "pyamplicol-eager-reduction-groups-v0", "reduction-groups ABI"),
+        ("runtime_layout_abi", "wrong-layout", "runtime-layout ABI"),
+        ("process_id", "wrong-process", "wrong process"),
+        ("reduction_groups", None, "must be an array"),
+    ),
+)
+def test_eager_reduction_groups_reject_malformed_native_payload(
+    tmp_path: Path,
+    field: str,
+    value: object,
+    match: str,
+) -> None:
+    payload: dict[str, object] = {
+        "abi": EAGER_REDUCTION_GROUPS_ABI,
+        "runtime_layout_abi": EAGER_RUNTIME_LAYOUT_ABI,
+        "process_id": "synthetic",
+        "reduction_groups": (),
+    }
+    payload[field] = value
+
+    with pytest.raises((ArtifactError, CompatibilityError), match=match):
+        eager_plan_v3._load_eager_reduction_groups_v1(
+            tmp_path / "artifact",
+            "synthetic",
+            loader=lambda _root, _process: payload,
+        )
+
+
+def test_eager_exact_applies_dynamic_output_factor_after_kernel(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _build_artifact(
+        artifact,
+        direct_closure=True,
+        vertex_contracts=(
+            _contract("left-current", 0),
+            _contract("right-current", 0),
+        ),
+        coupling_row=EagerCouplingRow(MISSING_U32, MISSING_U32, 2.0, 7.0),
+        invocation_output_factor_source=EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+    )
+    finalization_inputs: list[tuple[_ComplexDecimal, ...]] = []
+
+    def load(record: PreparedKernelRecord, _root: Path) -> _ExactCallable:
+        if record.kernel_id == 10:
+            return lambda values, _precision: (
+                (values[0][0] + values[1][0], Decimal(0)),
+            )
+        if record.kernel_id == 11:
+
+            def finalize(
+                values: Sequence[_ComplexDecimal], _precision: int
+            ) -> tuple[_ComplexDecimal, ...]:
+                finalization_inputs.append(tuple(values))
+                return (values[0],)
+
+            return finalize
+        raise AssertionError(f"unexpected kernel {record.kernel_id}")
+
+    executor = EagerExactExecutor(
+        artifact,
+        "synthetic",
+        _NativeRuntime(),
+        kernel_loader=load,
+    )
+    executor.evaluate_resolved(
+        _momenta(5),
+        helicities=None,
+        color_flows=None,
+        precision=50,
+    )
+
+    assert finalization_inputs[0][0] == (Decimal(12), Decimal(0))
+
+
+def test_eager_exact_projects_sparse_complex_prepared_parameters() -> None:
+    kernel = _kernel(
+        20,
+        "vertex",
+        (
+            _parameter_contract("alpha", 7),
+            _parameter_contract("derived", 157),
+        ),
+    )
+    runtime_schema = {
+        "model_parameters": [
+            {
+                "name": "alpha",
+                "kind": "external_parameter",
+                "parameter_index": 0,
+                "default": 2.0,
+            },
+            {
+                "name": "derived.real",
+                "kind": "derived_parameter_component",
+                "parameter_index": 1,
+                "runtime_name": "derived",
+                "complex_component": "real",
+                "default": 3.0,
+            },
+            {
+                "name": "derived.imag",
+                "kind": "derived_parameter_component",
+                "parameter_index": 2,
+                "runtime_name": "derived",
+                "complex_component": "imag",
+                "default": 4.0,
+            },
+        ]
+    }
+
+    projection = _prepared_parameter_projection((kernel,), runtime_schema, 3)
+    projected = projection.project((Decimal(2), Decimal(3), Decimal(4)))
+
+    assert projection.parameter_count == 158
+    assert projected[7] == (Decimal(2), Decimal(0))
+    assert projected[157] == (Decimal(3), Decimal(4))
+    assert _gather_inputs(
+        kernel,
+        first_current=(),
+        second_current=(),
+        first_momentum=(),
+        second_momentum=(),
+        coupling=None,
+        prepared_parameters=projected,
+    ) == (projected[7], projected[157])
+
+
+def test_eager_exact_derives_complex_parameters_at_requested_precision(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    parameter_kernel = _kernel(
+        20,
+        "model-parameter",
+        (_parameter_contract("alpha", 7),),
+        output_layout=("model-parameter:derived",),
+    )
+    model_parameters = (
+        {
+            "name": "alpha.real",
+            "kind": "external_parameter_component",
+            "parameter_index": 0,
+            "runtime_name": "alpha",
+            "complex_component": "real",
+            "default": 2.0,
+        },
+        {
+            "name": "alpha.imag",
+            "kind": "external_parameter_component",
+            "parameter_index": 1,
+            "runtime_name": "alpha",
+            "complex_component": "imag",
+            "default": 0.25,
+        },
+        {
+            "name": "derived.real",
+            "kind": "derived_parameter_component",
+            "parameter_index": 2,
+            "runtime_name": "derived",
+            "complex_component": "real",
+            "default": 5.351713562373095,
+        },
+        {
+            "name": "derived.imag",
+            "kind": "derived_parameter_component",
+            "parameter_index": 3,
+            "runtime_name": "derived",
+            "complex_component": "imag",
+            "default": 1.3333333333333333,
+        },
+    )
+    _build_artifact(
+        artifact,
+        parameter_kernel=parameter_kernel,
+        model_parameters=model_parameters,
+        vertex_contracts=(
+            _contract("left-current", 0),
+            _contract("right-current", 0),
+            _contract("coupling-real", 0),
+            _contract("coupling-imag", 0),
+            _parameter_contract("derived", 157),
+        ),
+        coupling_row=EagerCouplingRow(2, 3, 0.0, 0.0),
+    )
+    loaded_kernel_ids: list[int] = []
+    parameter_calls: list[tuple[tuple[_ComplexDecimal, ...], int]] = []
+    vertex_inputs: list[tuple[_ComplexDecimal, ...]] = []
+    finalization_inputs: list[tuple[_ComplexDecimal, ...]] = []
+
+    def load(record: PreparedKernelRecord, root: Path) -> _ExactCallable:
+        loaded_kernel_ids.append(record.kernel_id)
+        if record.kernel_id == 20:
+
+            def derive(
+                values: Sequence[_ComplexDecimal], precision: int
+            ) -> tuple[_ComplexDecimal, ...]:
+                parameter_calls.append((tuple(values), precision))
+                real, imaginary = values[0]
+                return (
+                    (
+                        real * real - imaginary * imaginary + Decimal(2).sqrt(),
+                        Decimal(2) * real * imaginary + Decimal(1) / Decimal(3),
+                    ),
+                )
+
+            return derive
+        if record.kernel_id == 10:
+
+            def vertex(
+                values: Sequence[_ComplexDecimal], _precision: int
+            ) -> tuple[_ComplexDecimal, ...]:
+                vertex_inputs.append(tuple(values))
+                return (
+                    (
+                        values[0][0]
+                        + values[1][0]
+                        + values[2][0]
+                        + values[3][0]
+                        + values[4][0]
+                        + values[4][1],
+                        Decimal(0),
+                    ),
+                )
+
+            return vertex
+        return _loader(finalization_inputs)(record, root)
+
+    native_derived = (
+        2.0 * 2.0 - 0.25 * 0.25 + math.sqrt(2.0),
+        2.0 * 2.0 * 0.25 + 1.0 / 3.0,
+    )
+    executor = EagerExactExecutor(
+        artifact,
+        "synthetic",
+        _NativeRuntime((2.0, 0.25, *native_derived)),
+        kernel_loader=load,
+    )
+    assert loaded_kernel_ids == []
+
+    result = executor.evaluate_resolved(
+        _momenta(5, 7),
+        helicities=None,
+        color_flows=None,
+        precision=60,
+    )
+
+    assert result.values
+    assert len(parameter_calls) == 1
+    parameter_inputs, working_precision = parameter_calls[0]
+    assert loaded_kernel_ids[0] == 20
+    assert loaded_kernel_ids.count(20) == 1
+    assert parameter_inputs == ((Decimal(2), Decimal("0.25")),)
+    assert working_precision > 60
+    with localcontext() as context:
+        context.prec = working_precision
+        exact_derived = (
+            Decimal(2) ** 2 - Decimal("0.25") ** 2 + Decimal(2).sqrt(),
+            Decimal(2) * Decimal(2) * Decimal("0.25") + Decimal(1) / Decimal(3),
+        )
+    assert exact_derived[0] != Decimal(str(native_derived[0]))
+    assert exact_derived[1] != Decimal(str(native_derived[1]))
+    assert len(vertex_inputs) == 4
+    for values in vertex_inputs:
+        assert values[2] == (exact_derived[0], Decimal(0))
+        assert values[3] == (exact_derived[1], Decimal(0))
+        assert values[4] == exact_derived
+
+    def expected_values(derived: _ComplexDecimal) -> tuple[Decimal, ...]:
+        with localcontext() as context:
+            context.prec = working_precision
+            vertex = Decimal(2) + Decimal(2) * (derived[0] + derived[1])
+            raw = tuple(
+                (Decimal(30) * vertex + energy + Decimal(1) + derived[0]) ** 2
+                for energy in (Decimal(5), Decimal(7))
+            )
+        with localcontext() as context:
+            context.prec = 60
+            return tuple(+value for value in raw)
+
+    exact_values = expected_values(exact_derived)
+    native_decimal: _ComplexDecimal = (
+        Decimal(str(native_derived[0])),
+        Decimal(str(native_derived[1])),
+    )
+    native_values = expected_values(native_decimal)
+    assert result.values == tuple(((value,),) for value in exact_values)
+    assert result.values != tuple(((value,),) for value in native_values)
+
+
+def test_eager_exact_ignores_parameters_of_inactive_shared_pack_kernel(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    beta_kernel = _kernel(
+        99,
+        "vertex",
+        (
+            _contract("left-current", 0),
+            _contract("right-current", 0),
+            _parameter_contract("beta", 199),
+        ),
+    )
+    _build_artifact(artifact, extra_kernels=(beta_kernel,))
+    executor = EagerExactExecutor(
+        artifact,
+        "synthetic",
+        _NativeRuntime(),
+        kernel_loader=_loader([]),
+    )
+
+    result = executor.evaluate_resolved(
+        _momenta(5),
+        helicities=None,
+        color_flows=None,
+        precision=50,
+    )
+
+    assert result.values
+    assert set(executor._plan.kernels) == {10, 11, 12}
+
+
+def test_eager_exact_ignores_derivation_kernel_without_derived_schema(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    parameter_kernel = _kernel(
+        20,
+        "model-parameter",
+        (_parameter_contract("beta", 199),),
+        output_layout=("model-parameter:unused",),
+    )
+    _build_artifact(artifact, parameter_kernel=parameter_kernel)
+
+    executor = EagerExactExecutor(
+        artifact,
+        "synthetic",
+        _NativeRuntime(),
+        kernel_loader=_loader([]),
+    )
+
+    assert executor._plan.parameter_derivation is None
+    assert executor._plan.parameter_projection.parameter_count == 0
+
+
+def test_eager_exact_rejects_multiple_inactive_derivation_kernels(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    first = _kernel(
+        20,
+        "model-parameter",
+        (_parameter_contract("alpha", 7),),
+        output_layout=("model-parameter:first",),
+    )
+    second = _kernel(
+        21,
+        "model-parameter",
+        (_parameter_contract("beta", 9),),
+        output_layout=("model-parameter:second",),
+    )
+    _build_artifact(
+        artifact,
+        parameter_kernel=first,
+        extra_kernels=(second,),
+    )
+
+    with pytest.raises(
+        ArtifactError,
+        match=r"eager kernel pack declares multiple model-parameter kernels",
+    ):
+        EagerExactExecutor(
+            artifact,
+            "synthetic",
+            _NativeRuntime(),
+            kernel_loader=_loader([]),
+        )
+
+
+def test_eager_exact_requires_parameters_of_active_shared_pack_kernel(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    beta_kernel = _kernel(
+        99,
+        "vertex",
+        (
+            _contract("left-current", 0),
+            _contract("right-current", 0),
+            _parameter_contract("beta", 199),
+        ),
+    )
+    _build_artifact(
+        artifact,
+        invocation_kernel_id=beta_kernel.kernel_id,
+        extra_kernels=(beta_kernel,),
+    )
+
+    with pytest.raises(
+        ArtifactError,
+        match=r"prepared parameter 'beta' is absent from the process runtime schema",
+    ):
+        EagerExactExecutor(
+            artifact,
+            "synthetic",
+            _NativeRuntime(),
+            kernel_loader=_loader([]),
+        )
+
+
+def test_eager_exact_validates_inactive_pack_parameter_identity() -> None:
+    beta_kernel = _kernel(
+        98,
+        "vertex",
+        (_parameter_contract("beta", 199),),
+    )
+    gamma_kernel = _kernel(
+        99,
+        "vertex",
+        (_parameter_contract("gamma", 199),),
+    )
+
+    with pytest.raises(
+        ArtifactError,
+        match=r"prepared parameter index 199 names multiple parameters",
+    ):
+        _prepared_parameter_projection(
+            (beta_kernel, gamma_kernel),
+            {"model_parameters": []},
+            0,
+            active_kernel_ids=frozenset(),
+        )
+
+
+def test_eager_exact_preserves_native_derived_values_without_kernel(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    model_parameters = (
+        {
+            "name": "derived.real",
+            "kind": "derived_parameter_component",
+            "parameter_index": 0,
+            "runtime_name": "derived",
+            "complex_component": "real",
+            "default": 1.25,
+        },
+        {
+            "name": "derived.imag",
+            "kind": "derived_parameter_component",
+            "parameter_index": 1,
+            "runtime_name": "derived",
+            "complex_component": "imag",
+            "default": -0.5,
+        },
+    )
+    _build_artifact(
+        artifact,
+        model_parameters=model_parameters,
+        vertex_contracts=(
+            _contract("left-current", 0),
+            _contract("right-current", 0),
+            _contract("coupling-real", 0),
+            _contract("coupling-imag", 0),
+            _parameter_contract("derived", 3),
+        ),
+        coupling_row=EagerCouplingRow(0, 1, 0.0, 0.0),
+    )
+    vertex_inputs: list[tuple[_ComplexDecimal, ...]] = []
+    fallback = _loader([])
+
+    def load(record: PreparedKernelRecord, root: Path) -> _ExactCallable:
+        if record.kernel_id != 10:
+            return fallback(record, root)
+
+        def vertex(
+            values: Sequence[_ComplexDecimal], _precision: int
+        ) -> tuple[_ComplexDecimal, ...]:
+            vertex_inputs.append(tuple(values))
+            total = sum((value[0] for value in values), start=Decimal(0))
+            return ((total, Decimal(0)),)
+
+        return vertex
+
+    executor = EagerExactExecutor(
+        artifact,
+        "synthetic",
+        _NativeRuntime((1.25, -0.5)),
+        kernel_loader=load,
+    )
+    executor.evaluate_resolved(
+        _momenta(5),
+        helicities=None,
+        color_flows=None,
+        precision=50,
+    )
+
+    assert vertex_inputs
+    for values in vertex_inputs:
+        assert values[2] == (Decimal("1.25"), Decimal(0))
+        assert values[3] == (Decimal("-0.5"), Decimal(0))
+        assert values[4] == (Decimal("1.25"), Decimal("-0.5"))
+
+
+@pytest.mark.parametrize(
+    "output_layout, match",
+    [
+        ((), "declares no outputs"),
+        (("scalar:0",), "invalid layout"),
+        (("model-parameter: derived",), "invalid layout"),
+        (
+            ("model-parameter:derived", "model-parameter:derived"),
+            "repeats output parameter",
+        ),
+    ],
+)
+def test_eager_exact_rejects_malformed_parameter_output_layout(
+    tmp_path: Path,
+    output_layout: tuple[str, ...],
+    match: str,
+) -> None:
+    artifact = tmp_path / "artifact"
+    parameter_kernel = _kernel(
+        20,
+        "model-parameter",
+        (_parameter_contract("alpha", 7),),
+        output_layout=output_layout,
+    )
+    _build_artifact(
+        artifact,
+        parameter_kernel=parameter_kernel,
+        model_parameters=(
+            {
+                "name": "alpha",
+                "kind": "external_parameter",
+                "parameter_index": 0,
+                "default": 2.0,
+            },
+            {
+                "name": "derived.real",
+                "kind": "derived_parameter_component",
+                "parameter_index": 1,
+                "runtime_name": "derived",
+                "complex_component": "real",
+                "default": 0.0,
+            },
+            {
+                "name": "derived.imag",
+                "kind": "derived_parameter_component",
+                "parameter_index": 2,
+                "runtime_name": "derived",
+                "complex_component": "imag",
+                "default": 0.0,
+            },
+        ),
+    )
+    with pytest.raises(ArtifactError, match=match):
+        EagerExactExecutor(
+            artifact,
+            "synthetic",
+            _NativeRuntime((2.0, 0.0, 0.0)),
+            kernel_loader=_loader([]),
+        )
+
+
+def test_eager_exact_rejects_missing_runtime_derived_output(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    parameter_kernel = _kernel(
+        20,
+        "model-parameter",
+        (_parameter_contract("alpha", 7),),
+        output_layout=("model-parameter:unused",),
+    )
+    _build_artifact(
+        artifact,
+        parameter_kernel=parameter_kernel,
+        model_parameters=(
+            {
+                "name": "alpha",
+                "kind": "external_parameter",
+                "parameter_index": 0,
+                "default": 2.0,
+            },
+            {
+                "name": "derived.real",
+                "kind": "derived_parameter_component",
+                "parameter_index": 1,
+                "runtime_name": "derived",
+                "complex_component": "real",
+                "default": 0.0,
+            },
+            {
+                "name": "derived.imag",
+                "kind": "derived_parameter_component",
+                "parameter_index": 2,
+                "runtime_name": "derived",
+                "complex_component": "imag",
+                "default": 0.0,
+            },
+        ),
+    )
+
+    with pytest.raises(
+        ArtifactError,
+        match="does not output runtime derived parameters: 'derived'",
+    ):
+        EagerExactExecutor(
+            artifact,
+            "synthetic",
+            _NativeRuntime((2.0, 0.0, 0.0)),
+            kernel_loader=_loader([]),
+        )
+
+
+def test_eager_exact_rejects_malformed_parameter_input_contract(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    input_contract = _parameter_contract("alpha", 7)
+    input_contract["component"] = 1
+    parameter_kernel = _kernel(
+        20,
+        "model-parameter",
+        (input_contract,),
+        output_layout=("model-parameter:derived",),
+    )
+    _build_artifact(
+        artifact,
+        parameter_kernel=parameter_kernel,
+        model_parameters=(
+            {
+                "name": "alpha",
+                "kind": "external_parameter",
+                "parameter_index": 0,
+                "default": 2.0,
+            },
+            {
+                "name": "derived.real",
+                "kind": "derived_parameter_component",
+                "parameter_index": 1,
+                "runtime_name": "derived",
+                "complex_component": "real",
+                "default": 0.0,
+            },
+            {
+                "name": "derived.imag",
+                "kind": "derived_parameter_component",
+                "parameter_index": 2,
+                "runtime_name": "derived",
+                "complex_component": "imag",
+                "default": 0.0,
+            },
+        ),
+    )
+
+    with pytest.raises(ArtifactError, match="input 0 has invalid component 1"):
+        EagerExactExecutor(
+            artifact,
+            "synthetic",
+            _NativeRuntime((2.0, 0.0, 0.0)),
+            kernel_loader=_loader([]),
+        )
+
+
+def test_eager_exact_rejects_parameter_evaluator_output_arity(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    parameter_kernel = _kernel(
+        20,
+        "model-parameter",
+        (_parameter_contract("alpha", 7),),
+        output_layout=("model-parameter:derived",),
+    )
+    _build_artifact(
+        artifact,
+        parameter_kernel=parameter_kernel,
+        model_parameters=(
+            {
+                "name": "alpha",
+                "kind": "external_parameter",
+                "parameter_index": 0,
+                "default": 2.0,
+            },
+            {
+                "name": "derived.real",
+                "kind": "derived_parameter_component",
+                "parameter_index": 1,
+                "runtime_name": "derived",
+                "complex_component": "real",
+                "default": 0.0,
+            },
+            {
+                "name": "derived.imag",
+                "kind": "derived_parameter_component",
+                "parameter_index": 2,
+                "runtime_name": "derived",
+                "complex_component": "imag",
+                "default": 0.0,
+            },
+        ),
+    )
+    fallback = _loader([])
+
+    def load(record: PreparedKernelRecord, root: Path) -> _ExactCallable:
+        if record.kernel_id == 20:
+            return lambda _values, _precision: ()
+        return fallback(record, root)
+
+    executor = EagerExactExecutor(
+        artifact,
+        "synthetic",
+        _NativeRuntime((2.0, 0.0, 0.0)),
+        kernel_loader=load,
+    )
+    with pytest.raises(EvaluationError, match="produced 0 outputs, expected 1"):
+        executor.evaluate_resolved(
+            _momenta(5),
+            helicities=None,
+            color_flows=None,
+            precision=40,
+        )
+
+
+def test_eager_exact_executes_direct_contraction(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    _build_artifact(artifact, direct_closure=True)
+    finalization_inputs: list[tuple[_ComplexDecimal, ...]] = []
+    executor = EagerExactExecutor(
+        artifact,
+        "synthetic",
+        _NativeRuntime(),
+        kernel_loader=_loader(finalization_inputs),
+    )
+
+    result = executor.evaluate_resolved(
+        _momenta(5),
+        helicities=("h:0",),
+        color_flows=("flow:1",),
+        precision=40,
+    )
+
+    assert result.values == (((Decimal(9025),),),)
+    assert len(finalization_inputs) == 1
+
+
+def test_eager_exact_rejects_malformed_table_contract(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    _build_artifact(
+        artifact,
+        invocation_row_size=EagerInvocationRow._STRUCT.size + 1,
+        compact_v3=False,
+    )
+
+    with pytest.raises(ArtifactError, match="row size"):
+        _load_legacy_plan(artifact, kernel_loader=_loader([]))
+
+
+def test_eager_exact_rejects_missing_kernel_and_plan_abi(tmp_path: Path) -> None:
+    missing = tmp_path / "missing"
+    _build_artifact(missing, invocation_kernel_id=99)
+    with pytest.raises(ArtifactError, match="missing prepared kernel 99"):
+        EagerExactExecutor(
+            missing,
+            "synthetic",
+            _NativeRuntime(),
+            kernel_loader=_loader([]),
+        )
+
+    retired = tmp_path / "retired-v2"
+    _build_artifact(retired, compact_v3=False)
+    with pytest.raises(
+        CompatibilityError,
+        match=r"requires a compact plan-v3 artifact.*[Rr]egenerate",
+    ):
+        EagerExactExecutor(
+            retired,
+            "synthetic",
+            _NativeRuntime(),
+            kernel_loader=_loader([]),
+        )
+
+    incompatible = tmp_path / "incompatible"
+    _build_artifact(
+        incompatible,
+        plan_abi="future-eager-plan",
+        compact_v3=False,
+    )
+    with pytest.raises(CompatibilityError, match="requires a compact plan-v3 artifact"):
+        EagerExactExecutor(
+            incompatible,
+            "synthetic",
+            _NativeRuntime(),
+            kernel_loader=_loader([]),
+        )
+
+    backend = tmp_path / "backend"
+    _build_artifact(backend, prepared_backend="future-backend")
+    with pytest.raises(CompatibilityError, match="prepared eager backend"):
+        EagerExactExecutor(
+            backend,
+            "synthetic",
+            _NativeRuntime(),
+            kernel_loader=_loader([]),
+        )
+
+    missing_kernel_abi = tmp_path / "missing-kernel-abi"
+    _build_artifact(missing_kernel_abi, kernel_abi=None)
+    with pytest.raises(CompatibilityError, match="unsupported eager kernel ABI None"):
+        EagerExactExecutor(
+            missing_kernel_abi,
+            "synthetic",
+            _NativeRuntime(),
+            kernel_loader=_loader([]),
+        )
+
+
+class _WrongArityEvaluator:
+    input_len = 999
+
+    def evaluate(
+        self,
+        _values: Sequence[_ComplexDecimal],
+        _precision: int,
+    ) -> tuple[_ComplexDecimal, ...]:
+        return ((Decimal(0), Decimal(0)),)
+
+
+def test_eager_exact_rejects_loaded_evaluator_arity_mismatch(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    _build_artifact(artifact)
+    executor = EagerExactExecutor(
+        artifact,
+        "synthetic",
+        _NativeRuntime(),
+        kernel_loader=lambda _record, _root: _WrongArityEvaluator(),
+    )
+
+    with pytest.raises(ArtifactError, match="input arity 999"):
+        executor.evaluate_resolved(
+            _momenta(5),
+            helicities=None,
+            color_flows=None,
+            precision=40,
+        )
diff --git a/pyamplicol/tests/unit/test_eager_fused_lowering.py b/pyamplicol/tests/unit/test_eager_fused_lowering.py
new file mode 100644
index 0000000000..968456297c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_fused_lowering.py
@@ -0,0 +1,356 @@
+# SPDX-License-Identifier: 0BSD
+"""Regression contract for single-pass eager runtime lowering."""
+
+from __future__ import annotations
+
+import subprocess
+from collections import Counter
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass, replace
+
+import pytest
+
+from pyamplicol.generation import eager_lowering
+from pyamplicol.generation.contracts import RuntimeExpressionSchema
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_types import GenericDAG
+from pyamplicol.generation.eager_lowering import (
+    EagerExecutionTables,
+    MappingEagerKernelResolver,
+    lower_eager_execution_tables,
+)
+from pyamplicol.generation.eager_tables import MISSING_U32
+from pyamplicol.generation.runtime_schema import build_runtime_schema
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.base import Model
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+_FUSED_ENTRY_POINT = "lower_fused_eager_execution"
+
+
+@dataclass(frozen=True, slots=True)
+class _LoweringCase:
+    name: str
+    process_id: str
+    dag: GenericDAG
+    model: Model
+    resolver: MappingEagerKernelResolver
+    reference_schema: Mapping[str, object]
+    reference_tables: EagerExecutionTables
+
+
+def _build_case(
+    process: str,
+    *,
+    process_id: str,
+    prepared_closure: bool,
+    color_accuracy: str = "lc",
+) -> _LoweringCase:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir(process, color_accuracy=color_accuracy),
+        model=model,
+    )
+
+    # The current built-in compiler closes amplitudes directly.  Replace one
+    # root with a prepared closure to exercise both closure lanes without
+    # requiring an external UFO model or any backend compilation.
+    closure_kernels: dict[tuple[str, int | None], int] = {}
+    if prepared_closure:
+        first = replace(
+            dag.amplitude_roots[0],
+            kind="prepared-closure",
+            vertex_kind=3,
+            vertex_particles=(21, 21, 21),
+            coupling=(1.0, 0.0),
+        )
+        dag = replace(dag, amplitude_roots=(first, *dag.amplitude_roots[1:]))
+        closure_kernels[("prepared-closure", 3)] = 9_000
+
+    schema = build_runtime_schema(dag, model, process_id=process_id)
+    propagated = sorted(
+        {
+            (int(slot["particle_id"]), int(slot["chirality"]))
+            for slot in schema["value_storage"]["value_slots"]
+            if slot["variant"] == "propagated"
+        }
+    )
+    kernel_id_by_evaluation_class: dict[str, int] = {}
+    vertex_kernels: dict[int, int] = {}
+    for kind in sorted(dag.required_vertex_kinds):
+        class_id = model.vertex_evaluation_equivalence(kind).class_id
+        vertex_kernels[kind] = kernel_id_by_evaluation_class.setdefault(
+            class_id,
+            100 + len(kernel_id_by_evaluation_class),
+        )
+    resolver = MappingEagerKernelResolver(
+        vertex_kernels=vertex_kernels,
+        propagator_kernels={key: 1_000 + index for index, key in enumerate(propagated)},
+        closure_kernels=closure_kernels,
+    )
+    tables = lower_eager_execution_tables(dag, model, schema, resolver)
+    return _LoweringCase(
+        name=process_id,
+        process_id=process_id,
+        dag=dag,
+        model=model,
+        resolver=resolver,
+        reference_schema=schema,
+        reference_tables=tables,
+    )
+
+
+@pytest.fixture(scope="module")
+def lowering_cases() -> tuple[_LoweringCase, ...]:
+    return (
+        _build_case(
+            "g g > g g",
+            process_id="synthetic_shared_mixed",
+            prepared_closure=True,
+        ),
+        _build_case(
+            "d d~ > z",
+            process_id="synthetic_direct_no_propagator",
+            prepared_closure=False,
+        ),
+    )
+
+
+@pytest.fixture(scope="module")
+def three_line_nlc_case() -> _LoweringCase:
+    return _build_case(
+        "d d~ > u u~ s s~ g",
+        process_id="three_line_nlc_fused_contract",
+        prepared_closure=False,
+        color_accuracy="nlc",
+    )
+
+
+def _fused_entry_point() -> Callable[..., object] | None:
+    candidate = getattr(eager_lowering, _FUSED_ENTRY_POINT, None)
+    return candidate if callable(candidate) else None
+
+
+@pytest.fixture
+def fused_lowerer() -> Callable[..., object]:
+    candidate = _fused_entry_point()
+    if candidate is None:
+        pytest.skip(
+            f"{_FUSED_ENTRY_POINT} is not implemented; the dedicated API "
+            "contract test reports this missing feature"
+        )
+    return candidate
+
+
+def _schema_mapping(value: object) -> dict[str, object]:
+    if isinstance(value, RuntimeExpressionSchema):
+        return value.to_mapping()
+    if isinstance(value, Mapping):
+        return {str(key): item for key, item in value.items()}
+    raise AssertionError(
+        "fused eager lowering must return a runtime schema mapping or "
+        "RuntimeExpressionSchema"
+    )
+
+
+def _unpack_fused_result(
+    result: object,
+) -> tuple[dict[str, object], EagerExecutionTables]:
+    if isinstance(result, tuple) and len(result) == 2:
+        schema, tables = result
+    else:
+        schema = getattr(result, "runtime_schema", None)
+        tables = getattr(result, "eager_tables", None)
+    if not isinstance(tables, EagerExecutionTables):
+        raise AssertionError(
+            "fused eager lowering must return EagerExecutionTables as the "
+            "second tuple member or eager_tables attribute"
+        )
+    return _schema_mapping(schema), tables
+
+
+def _run_fused(
+    lowerer: Callable[..., object],
+    case: _LoweringCase,
+    *,
+    resolver: MappingEagerKernelResolver | None = None,
+) -> tuple[dict[str, object], EagerExecutionTables]:
+    return _unpack_fused_result(
+        lowerer(
+            dag=case.dag,
+            model=case.model,
+            resolver=resolver or case.resolver,
+            process_id=case.process_id,
+        )
+    )
+
+
+def _canonical_schema(schema: Mapping[str, object]) -> str:
+    return RuntimeExpressionSchema.from_mapping(schema).canonical_json
+
+
+def _forbidden_backend_call(*_args: object, **_kwargs: object) -> object:
+    raise AssertionError("fused eager lowering attempted backend compilation")
+
+
+def test_fused_eager_lowering_entry_point_exists() -> None:
+    assert _fused_entry_point() is not None, (
+        "implement pyamplicol.generation.eager_lowering."
+        f"{_FUSED_ENTRY_POINT}(dag=..., model=..., resolver=..., "
+        "process_id=...) returning (runtime_schema, eager_tables) or an "
+        "object exposing runtime_schema/eager_tables"
+    )
+
+
+def test_reference_fixtures_cover_the_fused_lowering_contract(
+    lowering_cases: tuple[_LoweringCase, ...],
+) -> None:
+    mixed, direct = lowering_cases
+    mixed_tables = mixed.reference_tables
+    finalizations = tuple(
+        row for stage in mixed_tables.stages for row in stage.finalizations
+    )
+    input_fanout = Counter(
+        current_id
+        for interaction in mixed.dag.interactions
+        for current_id in (interaction.left_id, interaction.right_id)
+    )
+
+    assert any(count > 1 for count in input_fanout.values())
+    assert any(
+        invocation.attachment_count > 1
+        for stage in mixed_tables.stages
+        for invocation in stage.invocations
+    )
+    assert any(row.applies_kernel for row in finalizations)
+    assert any(not row.applies_kernel for row in finalizations)
+    assert any(row.kernel_id != MISSING_U32 for row in mixed_tables.closures)
+    assert any(row.kernel_id == MISSING_U32 for row in mixed_tables.closures)
+    assert mixed_tables.selector_closures is not None
+    assert len(mixed_tables.selector_closures.domains) > 1
+
+    direct_finalizations = tuple(
+        row for stage in direct.reference_tables.stages for row in stage.finalizations
+    )
+    assert direct_finalizations
+    assert all(not row.applies_kernel for row in direct_finalizations)
+    assert all(row.kernel_id == MISSING_U32 for row in direct.reference_tables.closures)
+
+
+@pytest.mark.parametrize(
+    "case_index",
+    (0, 1),
+    ids=("shared-mixed", "direct-no-propagator"),
+)
+def test_fused_lowering_matches_reference_schema_and_tables(
+    case_index: int,
+    lowering_cases: tuple[_LoweringCase, ...],
+    fused_lowerer: Callable[..., object],
+) -> None:
+    case = lowering_cases[case_index]
+    schema, tables = _run_fused(fused_lowerer, case)
+
+    assert _canonical_schema(schema) == _canonical_schema(case.reference_schema)
+    assert tables == case.reference_tables
+    assert tables.to_metadata() == case.reference_tables.to_metadata()
+    assert tables.binary_payloads() == case.reference_tables.binary_payloads()
+
+
+def test_fused_lowering_is_deterministic_across_resolver_mapping_order(
+    lowering_cases: tuple[_LoweringCase, ...],
+    fused_lowerer: Callable[..., object],
+) -> None:
+    case = lowering_cases[0]
+    reverse_resolver = MappingEagerKernelResolver(
+        vertex_kernels=dict(reversed(tuple(case.resolver.vertex_kernels.items()))),
+        propagator_kernels=dict(
+            reversed(tuple(case.resolver.propagator_kernels.items()))
+        ),
+        closure_kernels=dict(reversed(tuple(case.resolver.closure_kernels.items()))),
+    )
+
+    first_schema, first_tables = _run_fused(fused_lowerer, case)
+    second_schema, second_tables = _run_fused(
+        fused_lowerer,
+        case,
+        resolver=reverse_resolver,
+    )
+
+    assert _canonical_schema(first_schema) == _canonical_schema(second_schema)
+    assert first_tables.to_metadata() == second_tables.to_metadata()
+    assert first_tables.binary_payloads() == second_tables.binary_payloads()
+
+
+def test_three_line_nlc_fused_lowering_is_byte_identical_and_deterministic(
+    three_line_nlc_case: _LoweringCase,
+    fused_lowerer: Callable[..., object],
+) -> None:
+    first_schema, first_tables = _run_fused(
+        fused_lowerer,
+        three_line_nlc_case,
+    )
+    second_schema, second_tables = _run_fused(
+        fused_lowerer,
+        three_line_nlc_case,
+    )
+
+    reference_schema_bytes = _canonical_schema(
+        three_line_nlc_case.reference_schema
+    ).encode("utf-8")
+    assert _canonical_schema(first_schema).encode("utf-8") == reference_schema_bytes
+    assert _canonical_schema(second_schema).encode("utf-8") == reference_schema_bytes
+    assert first_tables == three_line_nlc_case.reference_tables
+    assert second_tables == three_line_nlc_case.reference_tables
+    assert first_tables.to_metadata() == (
+        three_line_nlc_case.reference_tables.to_metadata()
+    )
+    assert second_tables.to_metadata() == first_tables.to_metadata()
+    assert first_tables.binary_payloads() == (
+        three_line_nlc_case.reference_tables.binary_payloads()
+    )
+    assert second_tables.binary_payloads() == first_tables.binary_payloads()
+
+
+def test_fused_lowering_never_constructs_or_compiles_backend_evaluators(
+    lowering_cases: tuple[_LoweringCase, ...],
+    fused_lowerer: Callable[..., object],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol.evaluators import symbolica_compile
+    from pyamplicol.generation import stage_artifacts
+
+    monkeypatch.setattr(
+        symbolica_compile,
+        "_compile_symbolica_outputs",
+        _forbidden_backend_call,
+    )
+    monkeypatch.setattr(
+        stage_artifacts,
+        "_compile_stage_evaluator_artifact",
+        _forbidden_backend_call,
+    )
+    monkeypatch.setattr(
+        stage_artifacts,
+        "build_and_write_generic_stage_evaluator_artifacts",
+        _forbidden_backend_call,
+    )
+    monkeypatch.setattr(subprocess, "run", _forbidden_backend_call)
+    monkeypatch.setattr(subprocess, "Popen", _forbidden_backend_call)
+
+    # Patch every current/future Expression.evaluator* spelling exposed by the
+    # installed Symbolica API.  Importing is license-free and does not build an
+    # evaluator; absent Symbolica is tolerated because the low-level lowering
+    # contract itself must remain dependency-light.
+    try:
+        from symbolica import Expression
+    except ImportError:  # pragma: no cover - minimal source-only test env
+        Expression = None
+    if Expression is not None:
+        for name in dir(Expression):
+            if name == "evaluator" or name.startswith("evaluator_"):
+                monkeypatch.setattr(Expression, name, _forbidden_backend_call)
+
+    for case in lowering_cases:
+        schema, tables = _run_fused(fused_lowerer, case)
+        assert _canonical_schema(schema) == _canonical_schema(case.reference_schema)
+        assert tables.binary_payloads() == case.reference_tables.binary_payloads()
diff --git a/pyamplicol/tests/unit/test_eager_helicity_filter_performance_contract.py b/pyamplicol/tests/unit/test_eager_helicity_filter_performance_contract.py
new file mode 100644
index 0000000000..336aa98db7
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_helicity_filter_performance_contract.py
@@ -0,0 +1,72 @@
+# SPDX-License-Identifier: 0BSD
+"""Performance and parity contracts for eager helicity filtering."""
+
+from __future__ import annotations
+
+import pytest
+
+from pyamplicol.generation import dag_algorithms
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_types import GenericDAG
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+@pytest.fixture(scope="module")
+def three_line_nlc_dag() -> tuple[BuiltinSMModel, GenericDAG]:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("d d~ > u u~ s s~ g", color_accuracy="nlc"),
+        model=model,
+        online_evaluation_reuse=True,
+    )
+    return model, dag
+
+
+def test_compact_helicity_filter_exactly_matches_generic_fallback(
+    three_line_nlc_dag: tuple[BuiltinSMModel, GenericDAG],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model, dag = three_line_nlc_dag
+    compact = dag_algorithms.prune_global_helicity_flip_equivalent_roots(dag, model)
+
+    monkeypatch.setattr(
+        dag_algorithms,
+        "_compact_helicity_flip_representatives",
+        lambda *args, **kwargs: None,
+    )
+    generic = dag_algorithms.prune_global_helicity_flip_equivalent_roots(dag, model)
+
+    assert compact == generic
+    assert compact.currents == generic.currents
+    assert compact.interactions == generic.interactions
+    assert compact.amplitude_roots == generic.amplitude_roots
+
+
+def test_compact_helicity_filter_does_not_scan_all_decorated_sources_per_root(
+    three_line_nlc_dag: tuple[BuiltinSMModel, GenericDAG],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model, dag = three_line_nlc_dag
+    assert len(dag.sources) > 1_000
+    assert {
+        int(
+            dag.currents[root.left_id].index.helicity_ancestry
+            | dag.currents[root.right_id].index.helicity_ancestry
+        ).bit_count()
+        for root in dag.amplitude_roots
+    } == {len(dag.process.legs)}
+
+    def reject_generic_scan(*args: object, **kwargs: object) -> object:
+        del args, kwargs
+        raise AssertionError("compact filtering fell back to all-source scanning")
+
+    monkeypatch.setattr(
+        dag_algorithms,
+        "_root_physical_helicity_signature",
+        reject_generic_scan,
+    )
+
+    reduced = dag_algorithms.prune_global_helicity_flip_equivalent_roots(dag, model)
+
+    assert len(reduced.amplitude_roots) == len(dag.amplitude_roots) // 2
diff --git a/pyamplicol/tests/unit/test_eager_lowering.py b/pyamplicol/tests/unit/test_eager_lowering.py
new file mode 100644
index 0000000000..71eb57cb35
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_lowering.py
@@ -0,0 +1,436 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import replace
+
+import pytest
+
+import pyamplicol.generation.eager_lowering as eager_lowering_module
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.eager_lowering import (
+    EAGER_RUNTIME_KIND,
+    MappingEagerKernelResolver,
+    PreparedCatalogEagerKernelIndex,
+    PreparedCatalogEagerKernelResolver,
+    lower_eager_execution_tables,
+)
+from pyamplicol.generation.eager_tables import (
+    EAGER_SELECTOR_DOMAINS_ABI,
+    MISSING_U32,
+)
+from pyamplicol.generation.runtime_schema import build_runtime_schema
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.prepared_catalog import build_prepared_kernel_catalog
+
+_SELECTOR_PAYLOAD_PATHS = (
+    "eager/closure-domains.bin",
+    "eager/selector-domain-group-ids.bin",
+    "eager/selector-domains.bin",
+    "eager/stage-1-attachment-domains.bin",
+    "eager/stage-1-invocation-domains.bin",
+    "eager/stage-1-propagated-finalization-domains.bin",
+    "eager/stage-1-unpropagated-finalization-domains.bin",
+    "eager/stage-2-attachment-domains.bin",
+    "eager/stage-2-invocation-domains.bin",
+    "eager/stage-2-propagated-finalization-domains.bin",
+    "eager/stage-2-unpropagated-finalization-domains.bin",
+)
+
+
+def _gluon_scattering_tables():
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir("g g > g g"), model=model)
+    schema = build_runtime_schema(dag, model, process_id="gg_gg")
+    propagated = {
+        (int(slot["particle_id"]), int(slot["chirality"]))
+        for slot in schema["value_storage"]["value_slots"]
+        if slot["variant"] == "propagated"
+    }
+    resolver = MappingEagerKernelResolver(
+        vertex_kernels={kind: 100 + kind for kind in dag.required_vertex_kinds},
+        propagator_kernels={key: 1000 + index for index, key in enumerate(propagated)},
+        closure_kernels={},
+    )
+    tables = lower_eager_execution_tables(dag, model, schema, resolver)
+    return model, dag, schema, tables
+
+
+def _selector_domain_members(tables):
+    selector = tables.selector_closures
+    assert selector is not None
+    members = tuple(
+        frozenset(
+            row.coherent_group_id
+            for row in selector.domain_group_ids[
+                domain.member_start : domain.member_start + domain.member_count
+            ]
+        )
+        for domain in selector.domains
+    )
+    return selector, members
+
+
+def test_eager_lowering_preserves_compiled_evaluation_groups_and_fanout() -> None:
+    _model, dag, _schema, tables = _gluon_scattering_tables()
+
+    assert tables.process_key == "gg_gg"
+    assert tables.invocation_count == dag.interaction_evaluation_count
+    assert tables.attachment_count == len(dag.interactions)
+    assert sum(len(stage.finalizations) for stage in tables.stages) == len(
+        {interaction.result_id for interaction in dag.interactions}
+    )
+
+    dag_fanout = Counter(
+        interaction.evaluation_group_id for interaction in dag.interactions
+    )
+    eager_fanout = Counter(
+        invocation.attachment_count
+        for stage in tables.stages
+        for invocation in stage.invocations
+    )
+    assert eager_fanout[2] == sum(size == 2 for size in dag_fanout.values())
+    assert eager_fanout[1] == sum(size == 1 for size in dag_fanout.values())
+
+
+def test_eager_lowering_elides_authenticated_zero_attachments() -> None:
+    model, dag, _schema, baseline = _gluon_scattering_tables()
+    group_counts = Counter(
+        (
+            ("group", int(interaction.evaluation_group_id))
+            if interaction.evaluation_group_id is not None
+            else ("interaction", interaction.id)
+        )
+        for interaction in dag.interactions
+    )
+    target = next(
+        interaction
+        for interaction in dag.interactions
+        if group_counts[
+            (
+                ("group", int(interaction.evaluation_group_id))
+                if interaction.evaluation_group_id is not None
+                else ("interaction", interaction.id)
+            )
+        ]
+        == 1
+    )
+    zero_dag = replace(
+        dag,
+        interactions=tuple(
+            replace(interaction, evaluation_factor=(0.0, 0.0))
+            if interaction.id == target.id
+            else interaction
+            for interaction in dag.interactions
+        ),
+    )
+    schema = build_runtime_schema(zero_dag, model, process_id="gg_gg_zero")
+    propagated = {
+        (int(slot["particle_id"]), int(slot["chirality"]))
+        for slot in schema["value_storage"]["value_slots"]
+        if slot["variant"] == "propagated"
+    }
+    resolver = MappingEagerKernelResolver(
+        vertex_kernels={
+            kind: 100 + kind for kind in zero_dag.required_vertex_kinds
+        },
+        propagator_kernels={
+            key: 1000 + index
+            for index, key in enumerate(propagated)
+        },
+        closure_kernels={},
+    )
+
+    tables = lower_eager_execution_tables(
+        zero_dag,
+        model,
+        schema,
+        resolver,
+    )
+
+    assert tables.invocation_count == zero_dag.interaction_evaluation_count
+    assert tables.invocation_count == baseline.invocation_count - 1
+    assert tables.attachment_count == baseline.attachment_count - 1
+
+
+def test_eager_lowering_reports_stage_and_selector_progress() -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir("g g > g g"), model=model)
+    schema = build_runtime_schema(dag, model, process_id="gg_gg")
+    propagated = {
+        (int(slot["particle_id"]), int(slot["chirality"]))
+        for slot in schema["value_storage"]["value_slots"]
+        if slot["variant"] == "propagated"
+    }
+    resolver = MappingEagerKernelResolver(
+        vertex_kernels={kind: 100 + kind for kind in dag.required_vertex_kinds},
+        propagator_kernels={
+            key: 1000 + index for index, key in enumerate(propagated)
+        },
+        closure_kernels={},
+    )
+    events: list[dict[str, str | int]] = []
+
+    lower_eager_execution_tables(
+        dag,
+        model,
+        schema,
+        resolver,
+        progress_callback=events.append,
+    )
+
+    assert any(event["step"] == "invocation lowering" for event in events)
+    assert any(event["step"] == "amplitude closures" for event in events)
+    assert events[-1]["step"] == "eager plan ready"
+    assert all(
+        "invocation_count" in event
+        for event in events
+        if event["step"] == "invocation lowering"
+    )
+
+
+def test_eager_attachment_factors_use_the_compiled_representative_ratio() -> None:
+    _model, dag, schema, tables = _gluon_scattering_tables()
+    interaction_by_stage = {
+        int(stage["stage_index"]): [
+            dag.interactions[int(interaction_id)]
+            for interaction_id in stage["interaction_ids"]
+        ]
+        for stage in schema["stages"]
+    }
+
+    for stage in tables.stages:
+        grouped: dict[tuple[str, int], list[object]] = {}
+        for interaction in interaction_by_stage[stage.stage_index]:
+            key = (
+                ("group", int(interaction.evaluation_group_id))
+                if interaction.evaluation_group_id is not None
+                else ("interaction", interaction.id)
+            )
+            grouped.setdefault(key, []).append(interaction)
+        for invocation, interactions in zip(
+            stage.invocations,
+            grouped.values(),
+            strict=True,
+        ):
+            representative_factor = complex(*interactions[0].evaluation_factor)
+            actual = stage.attachments[
+                invocation.attachment_start : invocation.attachment_start
+                + invocation.attachment_count
+            ]
+            expected = tuple(
+                complex(*interaction.color_weight)
+                * complex(*interaction.evaluation_factor)
+                / representative_factor
+                for interaction in interactions
+            )
+            assert (
+                tuple(complex(row.factor_real, row.factor_imag) for row in actual)
+                == expected
+            )
+
+
+def test_selector_domains_preserve_shared_invocation_partial_fanout() -> None:
+    _model, _dag, schema, tables = _gluon_scattering_tables()
+    selector, members = _selector_domain_members(tables)
+
+    found_partial_fanout = False
+    for stage, selector_stage in zip(tables.stages, selector.stages, strict=True):
+        finalization_domains = {
+            finalization.current_id: (
+                members[unpropagated.domain_id] | members[propagated.domain_id]
+            )
+            for finalization, unpropagated, propagated in zip(
+                stage.finalizations,
+                selector_stage.unpropagated_finalization_domains,
+                selector_stage.propagated_finalization_domains,
+                strict=True,
+            )
+        }
+        for attachment, domain in zip(
+            stage.attachments,
+            selector_stage.attachment_domains,
+            strict=True,
+        ):
+            assert members[domain.domain_id] == finalization_domains[
+                attachment.result_current_id
+            ]
+
+        for invocation, domain in zip(
+            stage.invocations,
+            selector_stage.invocation_domains,
+            strict=True,
+        ):
+            attachment_domains = selector_stage.attachment_domains[
+                invocation.attachment_start : invocation.attachment_start
+                + invocation.attachment_count
+            ]
+            attachment_members = tuple(
+                members[attachment.domain_id] for attachment in attachment_domains
+            )
+            expected = frozenset().union(*attachment_members)
+            assert members[domain.domain_id] == expected
+            if len(set(attachment_members)) > 1:
+                found_partial_fanout = True
+
+    roots = schema["amplitude_stage"]["roots"]
+    for root, closure_domain in zip(
+        roots,
+        selector.closure_domains,
+        strict=True,
+    ):
+        assert members[closure_domain.domain_id] == {int(root["coherent_group_id"])}
+    assert found_partial_fanout
+
+
+def test_selector_interning_paths_emit_identical_bytes(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        eager_lowering_module,
+        "_DENSE_SELECTOR_DOMAIN_GROUP_LIMIT",
+        0,
+    )
+    _model, _dag, _schema, sparse_tables = _gluon_scattering_tables()
+    sparse_payloads = sparse_tables.binary_payloads()
+    monkeypatch.setattr(
+        eager_lowering_module,
+        "_DENSE_SELECTOR_DOMAIN_GROUP_LIMIT",
+        4096,
+    )
+    _model, _dag, _schema, dense_tables = _gluon_scattering_tables()
+    dense_payloads = dense_tables.binary_payloads()
+
+    assert {
+        path: dense_payloads[path] for path in _SELECTOR_PAYLOAD_PATHS
+    } == {
+        path: sparse_payloads[path] for path in _SELECTOR_PAYLOAD_PATHS
+    }
+
+
+def test_eager_lowering_emits_standalone_binary_table_metadata() -> None:
+    _model, _dag, _schema, tables = _gluon_scattering_tables()
+
+    metadata = tables.to_metadata()
+    payloads = tables.binary_payloads()
+
+    assert metadata["kind"] == EAGER_RUNTIME_KIND
+    assert metadata["process_key"] == "gg_gg"
+    assert metadata["required_runtime_capabilities"] == [
+        "rusticol.eager-dag.complex-f64.v1"
+    ]
+    selector = metadata["selector_closures"]
+    assert selector["abi"] == EAGER_SELECTOR_DOMAINS_ABI
+    assert set(payloads) == {
+        "eager/couplings.bin",
+        "eager/closures.bin",
+        "eager/selector-domains.bin",
+        "eager/selector-domain-group-ids.bin",
+        "eager/closure-domains.bin",
+        *{
+            f"eager/stage-{stage.stage_index}-{kind}.bin"
+            for stage in tables.stages
+            for kind in (
+                "invocations",
+                "attachments",
+                "finalizations",
+                "invocation-domains",
+                "attachment-domains",
+                "unpropagated-finalization-domains",
+                "propagated-finalization-domains",
+            )
+        },
+    }
+    for stage, record in zip(tables.stages, metadata["stages"], strict=True):
+        assert len(payloads[record["invocations"]["path"]]) == (
+            len(stage.invocations) * record["invocations"]["row_size"]
+        )
+
+
+def test_selector_domains_remain_additive_to_eager_plan_v1() -> None:
+    _model, _dag, _schema, tables = _gluon_scattering_tables()
+    legacy_tables = replace(tables, selector_closures=None)
+
+    assert "selector_closures" not in legacy_tables.to_metadata()
+    assert not any(
+        "domain" in path for path in legacy_tables.binary_payloads()
+    )
+
+
+def test_direct_contractions_remain_native_and_fixed_couplings_are_constant() -> None:
+    _model, _dag, _schema, tables = _gluon_scattering_tables()
+
+    assert tables.closures
+    assert all(row.kernel_id == MISSING_U32 for row in tables.closures)
+    assert all(
+        row.applies_kernel is row.stores_propagated
+        for stage in tables.stages
+        for row in stage.finalizations
+    )
+    assert all(row.coupling_slot_id == MISSING_U32 for row in tables.closures)
+    assert tables.couplings
+    assert all(row.real_parameter_id == MISSING_U32 for row in tables.couplings)
+    assert all(row.imag_parameter_id == MISSING_U32 for row in tables.couplings)
+
+
+def test_prepared_catalog_resolves_every_real_dag_orientation() -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir("g g > g g"), model=model)
+    schema = build_runtime_schema(dag, model, process_id="gg_gg")
+    catalog = build_prepared_kernel_catalog(model)
+    manifest = catalog.resolver_manifest()
+    index = PreparedCatalogEagerKernelIndex.from_manifest(manifest)
+    resolver = PreparedCatalogEagerKernelResolver(dag, index)
+
+    tables = lower_eager_execution_tables(dag, model, schema, resolver)
+
+    known_kernel_ids = set(catalog.by_id)
+    assert tables.invocation_count == dag.interaction_evaluation_count
+    assert {
+        invocation.kernel_id
+        for stage in tables.stages
+        for invocation in stage.invocations
+    } <= known_kernel_ids
+
+    checked_reflected_gluon = False
+    for stage, stage_record in zip(tables.stages, schema["stages"], strict=True):
+        groups: dict[int, list[object]] = {}
+        for interaction_id in stage_record["interaction_ids"]:
+            interaction = dag.interactions[int(interaction_id)]
+            groups.setdefault(int(interaction.evaluation_group_id), []).append(
+                interaction
+            )
+        input_slots = {
+            int(slot["current_id"]): int(slot["value_slot_id"])
+            for slot in schema["value_storage"]["value_slots"]
+            if int(slot["value_slot_id"]) in stage_record["input_value_slot_ids"]
+        }
+        for invocation, interactions in zip(
+            stage.invocations, groups.values(), strict=True
+        ):
+            representative = interactions[0]
+            if representative.vertex_kind != 3:
+                continue
+            resolution = resolver.vertex_kernel(representative)
+            assert resolution.canonical_input_order == (1, 0)
+            assert resolution.normalization_factor == (-1.0, 0.0)
+            assert invocation.left_value_slot_id == input_slots[
+                representative.right_id
+            ]
+            assert invocation.right_value_slot_id == input_slots[
+                representative.left_id
+            ]
+            first_attachment = stage.attachments[invocation.attachment_start]
+            expected = (
+                complex(*representative.color_weight)
+                * complex(*resolution.normalization_factor)
+            )
+            assert complex(
+                first_attachment.factor_real, first_attachment.factor_imag
+            ) == expected
+            checked_reflected_gluon = True
+            break
+        if checked_reflected_gluon:
+            break
+    assert checked_reflected_gluon
diff --git a/pyamplicol/tests/unit/test_eager_native_sdk.py b/pyamplicol/tests/unit/test_eager_native_sdk.py
new file mode 100644
index 0000000000..a1e2aed4ea
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_native_sdk.py
@@ -0,0 +1,143 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def _read(relative: str) -> str:
+    return (ROOT / relative).read_text(encoding="utf-8")
+
+
+def test_native_sdk_wrappers_expose_the_runtime_execution_mode() -> None:
+    header = _read("rust/crates/rusticol-capi/include/rusticol.h")
+    cpp = _read("rust/crates/rusticol-capi/include/rusticol.hpp")
+    fortran = _read("rust/crates/rusticol-capi/fortran/rusticol.f90")
+    rust = _read("src/pyamplicol/_sdk/rust/rusticol.rs")
+
+    assert "rusticol_runtime_execution_mode" in header
+    assert "std::string execution_mode() const" in cpp
+    assert "procedure, public :: execution_mode" in fortran
+    assert 'bind(C, name="rusticol_runtime_execution_mode")' in fortran
+    assert "pub fn execution_mode(&self) -> Result<String>" in rust
+    assert "rusticol_runtime_execution_mode" in rust
+
+
+def test_native_sdk_wrappers_expose_process_permutations_and_kinematics() -> None:
+    header = _read("rust/crates/rusticol-capi/include/rusticol.h")
+    cpp = _read("rust/crates/rusticol-capi/include/rusticol.hpp")
+    fortran = _read("rust/crates/rusticol-capi/fortran/rusticol.f90")
+    rust = _read("src/pyamplicol/_sdk/rust/rusticol.rs")
+
+    for symbol in (
+        "rusticol_runtime_representative_process_key",
+        "rusticol_runtime_external_permutation",
+        "rusticol_runtime_load_kinematics_json",
+    ):
+        assert symbol in header
+        assert symbol in fortran
+        assert symbol in rust
+    assert "std::string representative_process_key() const" in cpp
+    assert "std::vector<std::size_t> external_permutation() const" in cpp
+    assert "std::vector<double> load_kinematics_json" in cpp
+    assert "procedure, public :: representative_process_key" in fortran
+    assert "procedure, public :: external_permutation" in fortran
+    assert "procedure, public :: load_kinematics_json" in fortran
+    assert "pub fn representative_process_key(&self) -> Result<String>" in rust
+    assert "pub fn external_permutation(&self) -> Result<Vec<usize>>" in rust
+    assert "pub fn load_kinematics_json" in rust
+
+
+def test_native_sdk_wrappers_expose_per_point_runtime_selectors() -> None:
+    header = _read("rust/crates/rusticol-capi/include/rusticol.h")
+    cpp = _read("rust/crates/rusticol-capi/include/rusticol.hpp")
+    fortran = _read("rust/crates/rusticol-capi/fortran/rusticol.f90")
+    rust = _read("src/pyamplicol/_sdk/rust/rusticol.rs")
+
+    assert "rusticol_runtime_evaluate_selected_f64" in header
+    assert "evaluate_selected" in cpp
+    assert "procedure, public :: evaluate_selected" in fortran
+    assert "pub fn evaluate_selected_f64" in rust
+    assert "helicity_by_point: Option<&[u32]>" in rust
+    assert "color_flow_by_point: Option<&[u32]>" in rust
+
+
+def test_native_sdk_wrappers_expose_structured_one_point_otf_warm_up() -> None:
+    header = _read("rust/crates/rusticol-capi/include/rusticol.h")
+    cpp = _read("rust/crates/rusticol-capi/include/rusticol.hpp")
+    fortran = _read("rust/crates/rusticol-capi/fortran/rusticol.f90")
+    rust = _read("src/pyamplicol/_sdk/rust/rusticol.rs")
+
+    assert "rusticol_runtime_warm_up_f64" in header
+    assert "RusticolWarmUpProgressCallback" in header
+    assert "RusticolWarmUpProgressEvent" in header
+    assert "RusticolWarmUpResult" in header
+    original_signature = header.split("int rusticol_runtime_warm_up_f64(", 1)[1].split(
+        ");", 1
+    )[0]
+    assert "n_cores" not in original_signature
+    assert "rusticol_runtime_warm_up_f64_with_cores" in header
+    assert "size_t n_cores,\n    RusticolWarmUpProgressCallback" in header
+    assert "WarmUpResult warm_up(" in cpp
+    assert "std::function<bool(const WarmUpProgress &)>" in cpp
+    assert "std::size_t n_cores = 0" in cpp
+    assert "rusticol_runtime_warm_up_f64_with_cores(" in cpp
+    assert "procedure, public :: warm_up => rusticol_warm_up" in fortran
+    assert 'bind(C, name="rusticol_runtime_warm_up_f64_with_cores")' in fortran
+    assert "type, bind(C), public :: rusticol_warm_up_progress_event" in fortran
+    assert "integer, intent(in), optional :: n_cores" in fortran
+    assert "argument_ok(n_cores > 0" in fortran
+    assert "pub fn warm_up(" in rust
+    assert "pub fn warm_up_f64(" in rust
+    assert "FnMut(&WarmUpProgress) -> bool" in rust
+    assert "n_cores: Option<usize>" in rust
+    assert "n_cores == Some(0)" in rust
+    assert "rusticol_runtime_warm_up_f64_with_cores" in rust
+
+
+def test_native_sdk_wrappers_expose_otf_cache_save_and_load() -> None:
+    header = _read("rust/crates/rusticol-capi/include/rusticol.h")
+    cpp = _read("rust/crates/rusticol-capi/include/rusticol.hpp")
+    fortran = _read("rust/crates/rusticol-capi/fortran/rusticol.f90")
+    rust = _read("src/pyamplicol/_sdk/rust/rusticol.rs")
+
+    for symbol in ("rusticol_runtime_save", "rusticol_runtime_load_cache"):
+        assert symbol in header
+        assert symbol in cpp
+        assert f'bind(C, name="{symbol}")' in fortran
+        assert symbol in rust
+    assert "void save(const std::string &path) const" in cpp
+    assert "void load_cache(const std::string &path)" in cpp
+    assert "procedure, public :: save => rusticol_save" in fortran
+    assert "procedure, public :: load_cache => rusticol_load_cache" in fortran
+    assert "pub fn save(&self, path: impl AsRef<Path>)" in rust
+    assert "pub fn load_cache(&mut self, path: impl AsRef<Path>)" in rust
+
+
+def test_generated_native_drivers_share_total_and_resolved_entrypoints() -> None:
+    templates = {
+        "cpp": _read("src/pyamplicol/assets/api_templates/cpp/check_standalone.cpp"),
+        "fortran": _read(
+            "src/pyamplicol/assets/api_templates/fortran/check_standalone.f90"
+        ),
+        "rust": _read("src/pyamplicol/assets/api_templates/rust/check_standalone.rs"),
+    }
+
+    for language, source in templates.items():
+        assert "evaluate" in source, language
+        assert "evaluate_resolved" in source, language
+        assert "compatibility_total" in source, language
+        assert '"eager"' not in source, language
+        assert "resolved_available" not in source, language
+
+
+def test_compiled_driver_paths_still_check_resolved_sums() -> None:
+    sources = (
+        _read("src/pyamplicol/assets/api_templates/cpp/check_standalone.cpp"),
+        _read("src/pyamplicol/assets/api_templates/fortran/check_standalone.f90"),
+        _read("src/pyamplicol/assets/api_templates/rust/check_standalone.rs"),
+    )
+
+    for source in sources:
+        assert "resolved components do not reproduce the compatibility total" in source
diff --git a/pyamplicol/tests/unit/test_eager_online_dag_reuse.py b/pyamplicol/tests/unit/test_eager_online_dag_reuse.py
new file mode 100644
index 0000000000..d4e6af5b0c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_online_dag_reuse.py
@@ -0,0 +1,317 @@
+# SPDX-License-Identifier: 0BSD
+"""Parity contract for eager-only online recursive-current reuse."""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable
+
+import pytest
+
+from pyamplicol.color import build_color_plan
+from pyamplicol.config import EvaluatorConfig, RunConfig
+from pyamplicol.generation import service as service_module
+from pyamplicol.generation.contracts import runtime_coupling_parameter_names
+from pyamplicol.generation.dag_algorithms import (
+    prune_dag_to_amplitude_roots,
+    prune_global_helicity_flip_equivalent_roots,
+)
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_types import GenericDAG, InteractionNode
+from pyamplicol.generation.runtime_schema import build_runtime_schema
+from pyamplicol.generation.service import GenerationBackend
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.base import Model
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.processes.ir import CanonicalProcessIR
+
+_ONLINE_REUSE_PARAMETER = "online_evaluation_reuse"
+_CASES = (
+    ("d d~ > z g g g", "lc"),
+    ("d d~ > z g g g", "nlc"),
+    ("d d~ > z g g g", "full"),
+    ("d d~ > u u~ s s~ g", "lc"),
+    ("d d~ > u u~ s s~ g", "nlc"),
+    ("d d~ > u u~ s s~ g", "full"),
+)
+
+
+class _RuntimeCouplingBuiltin(BuiltinSMModel):
+    def runtime_parameter_names_for_vertex(self, kind: int) -> tuple[str, str]:
+        return (
+            f"runtime.vertex.{kind}.component_0",
+            f"runtime.vertex.{kind}.component_1",
+        )
+
+
+def _online_reuse_parameter() -> inspect.Parameter | None:
+    return inspect.signature(compile_generic_dag).parameters.get(
+        _ONLINE_REUSE_PARAMETER
+    )
+
+
+@pytest.fixture
+def online_compiler() -> Callable[..., GenericDAG]:
+    if _online_reuse_parameter() is None:
+        pytest.skip(
+            "online-reuse parity depends on the missing "
+            "compile_generic_dag(..., online_evaluation_reuse=...) API"
+        )
+    return compile_generic_dag
+
+
+def _interaction_reuse_contract(
+    interactions: tuple[InteractionNode, ...],
+) -> tuple[tuple[int, int | None, tuple[float, float]], ...]:
+    return tuple(
+        (
+            interaction.id,
+            interaction.evaluation_group_id,
+            interaction.evaluation_factor,
+        )
+        for interaction in interactions
+    )
+
+
+def _assert_exact_dag_parity(reference: GenericDAG, actual: GenericDAG) -> None:
+    # Dataclass equality covers every GenericDAG field, including any fields added
+    # after this contract.  The focused assertions below identify ordering/reuse
+    # regressions without reducing the strength of that complete comparison.
+    assert actual == reference
+    assert actual.process == reference.process
+    assert actual.color_plan == reference.color_plan
+    assert actual.currents == reference.currents
+    assert actual.sources == reference.sources
+    assert actual.interactions == reference.interactions
+    assert _interaction_reuse_contract(actual.interactions) == (
+        _interaction_reuse_contract(reference.interactions)
+    )
+    assert actual.amplitude_roots == reference.amplitude_roots
+    assert (
+        actual.truncated,
+        actual.helicity_coverage,
+        actual.color_coverage,
+        actual.selected_source_helicities,
+    ) == (
+        reference.truncated,
+        reference.helicity_coverage,
+        reference.color_coverage,
+        reference.selected_source_helicities,
+    )
+
+
+def test_compile_generic_dag_declares_online_reuse_as_opt_in() -> None:
+    parameter = _online_reuse_parameter()
+
+    assert parameter is not None, (
+        "eager online recursive-current reuse requires "
+        "compile_generic_dag(..., online_evaluation_reuse=False)"
+    )
+    assert parameter.kind is inspect.Parameter.KEYWORD_ONLY
+    assert parameter.default is False
+
+
+@pytest.mark.parametrize(("process", "color_accuracy"), _CASES)
+def test_online_reuse_exactly_matches_current_two_pass_dag(
+    online_compiler: Callable[..., GenericDAG],
+    process: str,
+    color_accuracy: str,
+) -> None:
+    model = BuiltinSMModel()
+    process_ir = build_process_ir(process, color_accuracy=color_accuracy)
+    reference = online_compiler(process_ir, model=model)
+    online_first = online_compiler(
+        process_ir,
+        model=model,
+        online_evaluation_reuse=True,
+    )
+    online_second = online_compiler(
+        process_ir,
+        model=model,
+        online_evaluation_reuse=True,
+    )
+
+    _assert_exact_dag_parity(reference, online_first)
+    _assert_exact_dag_parity(reference, online_second)
+    _assert_exact_dag_parity(online_first, online_second)
+
+
+def test_default_compiler_path_equals_explicit_online_reuse_opt_out(
+    online_compiler: Callable[..., GenericDAG],
+) -> None:
+    model = BuiltinSMModel()
+    process_ir = build_process_ir("d d~ > z g g g")
+
+    implicit_default = online_compiler(process_ir, model=model)
+    explicit_compiled = online_compiler(
+        process_ir,
+        model=model,
+        online_evaluation_reuse=False,
+    )
+
+    _assert_exact_dag_parity(implicit_default, explicit_compiled)
+
+
+def test_prebuilt_color_plan_preserves_exact_online_dag() -> None:
+    model = BuiltinSMModel()
+    process_ir = build_process_ir(
+        "d d~ > u u~ s s~ g",
+        color_accuracy="nlc",
+    )
+    color_plan = build_color_plan(process_ir, color_accuracy="nlc")
+
+    rebuilt = compile_generic_dag(
+        process_ir,
+        model=model,
+        online_evaluation_reuse=True,
+    )
+    prebuilt = compile_generic_dag(
+        process_ir,
+        model=model,
+        color_plan=color_plan,
+        online_evaluation_reuse=True,
+    )
+
+    _assert_exact_dag_parity(rebuilt, prebuilt)
+
+
+def test_evaluation_groups_preserve_mutable_coupling_provenance(
+    online_compiler: Callable[..., GenericDAG],
+) -> None:
+    model = _RuntimeCouplingBuiltin()
+    process_ir = build_process_ir("d d~ > z g g g", color_accuracy="nlc")
+    dag = online_compiler(
+        process_ir,
+        model=model,
+        online_evaluation_reuse=True,
+    )
+    provenance_by_group: dict[int, set[tuple[str | None, ...]]] = {}
+
+    for interaction in dag.interactions:
+        assert interaction.evaluation_group_id is not None
+        provenance = tuple(
+            runtime_coupling_parameter_names(
+                interaction.vertex_kind,
+                interaction.vertex_particles,
+                interaction.coupling,
+                model=model,
+            )
+        )
+        provenance_by_group.setdefault(
+            interaction.evaluation_group_id,
+            set(),
+        ).add(provenance)
+
+    assert provenance_by_group
+    assert all(len(provenance) == 1 for provenance in provenance_by_group.values())
+
+
+def test_builtin_runtime_schema_exposes_only_runtime_dependent_couplings() -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("d d~ > z g g g", color_accuracy="nlc"),
+        model=model,
+        online_evaluation_reuse=True,
+    )
+    schema = build_runtime_schema(dag, model, process_id="ddbar-z3g")
+    coupling_names = {
+        str(record["name"])
+        for record in schema["model_parameters"]
+        if record["kind"] == "coupling_component"
+    }
+
+    assert coupling_names == {
+        "coupling.10.1_23_1.component_0",
+        "coupling.10.1_23_1.component_1",
+    }
+
+
+def test_eager_qcd_parity_preselection_matches_post_dag_physics() -> None:
+    model = BuiltinSMModel()
+    process_ir = build_process_ir(
+        "d d~ > u u~ s s~ g",
+        color_accuracy="nlc",
+    )
+    limits = {"QCD": 5, "QED": 0}
+    complete = compile_generic_dag(
+        process_ir,
+        model=model,
+        max_coupling_orders=limits,
+    )
+    post_pruned = prune_global_helicity_flip_equivalent_roots(complete, model)
+    eager_preselected = compile_generic_dag(
+        process_ir,
+        model=model,
+        max_coupling_orders=limits,
+        online_evaluation_reuse=True,
+    )
+    eager_pruned = prune_dag_to_amplitude_roots(eager_preselected)
+
+    assert len(eager_preselected.amplitude_roots) * 2 == len(complete.amplitude_roots)
+    assert all(
+        root.helicity_weight == 2.0 for root in eager_preselected.amplitude_roots
+    )
+    assert (
+        len(eager_pruned.currents),
+        len(eager_pruned.interactions),
+        len(eager_pruned.amplitude_roots),
+    ) == (
+        len(post_pruned.currents),
+        len(post_pruned.interactions),
+        len(post_pruned.amplitude_roots),
+    )
+
+    reference_schema = build_runtime_schema(
+        post_pruned,
+        model,
+        process_id="threeq-reference",
+    )
+    eager_schema = build_runtime_schema(
+        eager_pruned,
+        model,
+        process_id="threeq-reference",
+    )
+    assert eager_schema["physics"] == reference_schema["physics"]
+
+
+@pytest.mark.parametrize(
+    ("execution_mode", "expected_online_reuse"),
+    (("compiled", False), ("eager", True)),
+)
+def test_generation_service_enables_online_reuse_only_for_eager_mode(
+    online_compiler: Callable[..., GenericDAG],
+    monkeypatch: pytest.MonkeyPatch,
+    execution_mode: str,
+    expected_online_reuse: bool,
+) -> None:
+    model = BuiltinSMModel()
+    process_ir = build_process_ir("d d~ > z g g g")
+    reference = online_compiler(process_ir, model=model)
+    observed: list[bool] = []
+
+    def capture_compile(
+        process: CanonicalProcessIR,
+        *,
+        model: Model,
+        **options: object,
+    ) -> GenericDAG:
+        assert process is process_ir
+        observed.append(bool(options.get(_ONLINE_REUSE_PARAMETER, False)))
+        return reference
+
+    monkeypatch.setattr(service_module, "compile_generic_dag", capture_compile)
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            evaluator=EvaluatorConfig(execution_mode=execution_mode),
+        ),
+        None,
+    )
+
+    compiled, _coverage = backend._compile_concrete_process(process_ir, model)
+
+    assert compiled.currents == reference.currents
+    assert compiled.interactions == reference.interactions
+    assert compiled.amplitude_roots == reference.amplitude_roots
+    assert compiled.lc_topology_replay is not None
+    assert observed == [expected_online_reuse]
diff --git a/pyamplicol/tests/unit/test_eager_plan_v2_semantic_goldens.py b/pyamplicol/tests/unit/test_eager_plan_v2_semantic_goldens.py
new file mode 100644
index 0000000000..14785374e7
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_plan_v2_semantic_goldens.py
@@ -0,0 +1,762 @@
+# SPDX-License-Identifier: 0BSD
+# ruff: noqa: E501 - uninterrupted SHA-256 goldens are easier to audit.
+"""Semantic plan-v2 goldens for the Rust eager-lowering transition.
+
+The snapshots deliberately avoid hashing JSON text or packed table bytes.  They
+project the Python lowerer's execution semantics into stable records so that a
+future plan-v3 Rust lowerer can be compared without reproducing Python object
+layout, selector-domain numbering, or serialization details.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections import defaultdict
+from collections.abc import Mapping, Sequence
+from dataclasses import asdict, dataclass
+from fractions import Fraction
+from typing import TypeAlias, cast
+
+import pytest
+
+import pyamplicol.generation.service as service_module
+from pyamplicol.api import ProcessRequest
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    RunConfig,
+)
+from pyamplicol.generation.eager_lowering import (
+    EagerExecutionTables,
+    PreparedCatalogEagerKernelResolver,
+    lower_fused_eager_execution,
+)
+from pyamplicol.generation.eager_tables import (
+    EAGER_PLAN_ABI,
+    EAGER_RUNTIME_CAPABILITY,
+    EagerSelectorDomainIdRow,
+)
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.prepared_catalog import (
+    PreparedKernelCatalog,
+    build_prepared_kernel_catalog,
+)
+
+_ComplexFraction: TypeAlias = tuple[Fraction, Fraction]
+
+_LEGACY_PLAN_ABI = "pyamplicol-eager-plan-v2"
+_LEGACY_RUNTIME_CAPABILITY = "rusticol.eager-dag.complex-f64.v1"
+
+
+@dataclass(frozen=True, slots=True)
+class _GoldenCase:
+    name: str
+    schema: Mapping[str, object]
+    tables: EagerExecutionTables
+    catalog: PreparedKernelCatalog
+
+
+def _canonical(value: object) -> object:
+    """Make semantic values JSON-canonical while preserving exact f64 bits."""
+
+    if value is None or isinstance(value, (bool, int, str)):
+        return value
+    if isinstance(value, float):
+        return {"f64_hex": value.hex()}
+    if isinstance(value, Mapping):
+        return {
+            str(key): _canonical(item)
+            for key, item in sorted(value.items(), key=lambda pair: str(pair[0]))
+        }
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return [_canonical(item) for item in value]
+    raise TypeError(f"unsupported semantic-golden value {type(value).__name__}")
+
+
+def _digest(value: object) -> str:
+    payload = json.dumps(
+        _canonical(value),
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=True,
+    ).encode("ascii")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _mapping(value: object, field: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise AssertionError(f"{field} must be a mapping")
+    return cast(Mapping[str, object], value)
+
+
+def _records(value: object, field: str) -> tuple[Mapping[str, object], ...]:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes, bytearray)):
+        raise AssertionError(f"{field} must be a sequence")
+    return tuple(_mapping(item, f"{field}[]") for item in value)
+
+
+def _build_case(
+    *,
+    name: str,
+    expression: str,
+    accuracy: str,
+    lc_flow_layout: str,
+    catalog: PreparedKernelCatalog,
+) -> _GoldenCase:
+    model = BuiltinSMModel()
+    backend = service_module.GenerationBackend(
+        RunConfig(
+            action="generate",
+            # Fix the historical v2 optimization policy independently of
+            # changing production defaults for numerical current discovery.
+            generation=GenerationConfig(
+                relation_discovery=GenerationRelationDiscoveryConfig(
+                    mode="certified-reuse"
+                )
+            ),
+            color=ColorConfig(
+                accuracy=accuracy,
+                lc_flow_layout=lc_flow_layout,
+            ),
+            evaluator=EvaluatorConfig(execution_mode="eager"),
+        ),
+        None,
+    )
+    process_ir = build_process_ir(expression, color_accuracy=accuracy)
+    dag, coverage = backend._compile_concrete_process(process_ir, model)
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(
+            expanded=service_module._ExpandedProcess(
+                request=ProcessRequest.parse(expression, name=name),
+                process_ir=process_ir,
+            ),
+            dag=dag,
+            coverage=coverage,
+        ),
+        model,
+        index=0,
+        phase=PhaseHandle("semantic-golden", None, 1),
+    )
+    schema, tables = lower_fused_eager_execution(
+        dag=prepared.dag,
+        model=model,
+        resolver=PreparedCatalogEagerKernelResolver(
+            prepared.dag,
+            catalog.resolver_manifest(),
+        ),
+        process_id=name,
+    )
+    return _GoldenCase(name=name, schema=schema, tables=tables, catalog=catalog)
+
+
+@pytest.fixture(scope="module")
+def golden_cases() -> tuple[_GoldenCase, ...]:
+    catalog = build_prepared_kernel_catalog(BuiltinSMModel())
+    return (
+        _build_case(
+            name="lc-topology-replay",
+            expression="d d~ > z g g",
+            accuracy="lc",
+            lc_flow_layout="topology-replay",
+            catalog=catalog,
+        ),
+        _build_case(
+            name="lc-all-flow-union",
+            expression="d d~ > z g g",
+            accuracy="lc",
+            lc_flow_layout="all-flow-union",
+            catalog=catalog,
+        ),
+        _build_case(
+            name="nlc-contracted",
+            expression="g g > g g",
+            accuracy="nlc",
+            lc_flow_layout="topology-replay",
+            catalog=catalog,
+        ),
+        _build_case(
+            name="full-contracted",
+            expression="g g > g g",
+            accuracy="full",
+            lc_flow_layout="topology-replay",
+            catalog=catalog,
+        ),
+    )
+
+
+def _layout_semantics(schema: Mapping[str, object]) -> object:
+    current_storage = _mapping(schema["current_storage"], "current_storage")
+    value_storage = _mapping(schema["value_storage"], "value_storage")
+    stages = _records(schema["stages"], "stages")
+    return {
+        "parameter_layout": schema["parameter_layout"],
+        "model_parameters": schema["model_parameters"],
+        "current_component_count": current_storage["component_count"],
+        "current_slots": sorted(
+            _records(current_storage["current_slots"], "current_slots"),
+            key=lambda row: int(row["current_id"]),
+        ),
+        "value_component_count": value_storage["component_count"],
+        "value_slots": sorted(
+            _records(value_storage["value_slots"], "value_slots"),
+            key=lambda row: int(row["value_slot_id"]),
+        ),
+        "source_fill": schema["source_fill"],
+        "momentum_slots": sorted(
+            _records(schema["momentum_slots"], "momentum_slots"),
+            key=lambda row: int(row["momentum_slot_id"]),
+        ),
+        "stages": [
+            {
+                key: stage[key]
+                for key in (
+                    "stage_index",
+                    "stage_kind",
+                    "subset_size",
+                    "input_current_ids",
+                    "output_current_ids",
+                    "input_value_slot_ids",
+                    "output_value_slot_ids",
+                    "input_momentum_slot_ids",
+                )
+            }
+            for stage in stages
+        ],
+    }
+
+
+def _table_semantics(tables: EagerExecutionTables) -> object:
+    couplings = tuple(asdict(row) for row in tables.couplings)
+
+    def coupling(row_id: int) -> object:
+        if row_id >= len(couplings):
+            return {"missing": True}
+        return couplings[row_id]
+
+    return {
+        "process_key": tables.process_key,
+        "couplings": couplings,
+        "stages": [
+            {
+                "stage_index": stage.stage_index,
+                "subset_size": stage.subset_size,
+                "invocations": [
+                    {
+                        **asdict(row),
+                        "coupling": coupling(row.coupling_slot_id),
+                    }
+                    for row in stage.invocations
+                ],
+                "attachments": [asdict(row) for row in stage.attachments],
+                "finalizations": [asdict(row) for row in stage.finalizations],
+            }
+            for stage in tables.stages
+        ],
+        "closures": [
+            {
+                **asdict(row),
+                "coupling": coupling(row.coupling_slot_id),
+            }
+            for row in tables.closures
+        ],
+    }
+
+
+def _selector_semantics(
+    schema: Mapping[str, object], tables: EagerExecutionTables
+) -> object:
+    selector = tables.selector_closures
+    if selector is None:
+        return {"enabled": False}
+    memberships = tuple(
+        tuple(
+            row.coherent_group_id
+            for row in selector.domain_group_ids[
+                domain.member_start : domain.member_start + domain.member_count
+            ]
+        )
+        for domain in selector.domains
+    )
+
+    def resolve(rows: Sequence[EagerSelectorDomainIdRow]) -> list[tuple[int, ...]]:
+        return [memberships[row.domain_id] for row in rows]
+
+    physics = _mapping(schema["physics"], "physics")
+    amplitude = _mapping(schema["amplitude_stage"], "amplitude_stage")
+    extensions = _mapping(physics["extensions"], "physics.extensions")
+    return {
+        "enabled": True,
+        "domain_memberships": sorted(set(memberships)),
+        "stages": [
+            {
+                "stage_index": stage.stage_index,
+                "invocations": resolve(stage.invocation_domains),
+                "attachments": resolve(stage.attachment_domains),
+                "unpropagated_finalizations": resolve(
+                    stage.unpropagated_finalization_domains
+                ),
+                "propagated_finalizations": resolve(
+                    stage.propagated_finalization_domains
+                ),
+            }
+            for stage in selector.stages
+        ],
+        "closures": resolve(selector.closure_domains),
+        "public_selectors": physics["selectors"],
+        "runtime_selectors": extensions.get("runtime_selectors"),
+        "lc_topology_replay": schema.get("lc_topology_replay"),
+        "color_topology_replay": amplitude.get("color_topology_replay"),
+        "helicity_recurrence": schema.get("helicity_recurrence"),
+    }
+
+
+def _reduction_semantics(schema: Mapping[str, object]) -> object:
+    physics = _mapping(schema["physics"], "physics")
+    amplitude = _mapping(schema["amplitude_stage"], "amplitude_stage")
+    return {
+        "roots": amplitude["roots"],
+        "coherent_groups": amplitude["coherent_groups"],
+        "final_reduction": amplitude["final_reduction"],
+        "color_contraction": amplitude["color_contraction"],
+        "physics_reduction": physics["reduction"],
+        "color_components": physics["color_components"],
+        "helicities": physics["helicities"],
+        "normalization": schema["normalization"],
+    }
+
+
+def _logical_color_contraction_entries(
+    contraction: Mapping[str, object],
+) -> tuple[Mapping[str, object], ...]:
+    entries = _records(contraction["entries"], "color_contraction.entries")
+    repeated_raw = contraction.get("repeated_block")
+    if repeated_raw is None:
+        return entries
+    assert not entries
+    repeated = _mapping(repeated_raw, "color_contraction.repeated_block")
+    component_count = int(repeated["component_count"])
+    component_group_ids = tuple(
+        int(value) for value in cast(Sequence[object], repeated["component_group_ids"])
+    )
+    templates = _records(
+        repeated["entries"], "color_contraction.repeated_block.entries"
+    )
+    return tuple(
+        {
+            "left_group_id": component_group_ids[
+                int(entry["left_group_index"]) * component_count + component_index
+            ],
+            "right_group_id": component_group_ids[
+                int(entry["right_group_index"]) * component_count + component_index
+            ],
+            "weight": entry["weight"],
+            "symmetry_factor": entry["symmetry_factor"],
+        }
+        for component_index in range(component_count)
+        for entry in templates
+    )
+
+
+def _exact_semantics(case: _GoldenCase) -> object:
+    referenced = case.tables.referenced_kernel_ids
+    kernels = [case.catalog.by_id[kernel_id] for kernel_id in sorted(referenced)]
+    amplitude = _mapping(case.schema["amplitude_stage"], "amplitude_stage")
+    roots = _records(amplitude["roots"], "amplitude_stage.roots")
+    return {
+        "kernels": [
+            {
+                "kernel_id": kernel.kernel_id,
+                "contract_kind": kernel.contract_kind,
+                "canonical_signature": kernel.canonical_signature,
+                "exact_expressions": kernel.exact_expressions,
+                "inputs": [item.to_dict() for item in kernel.inputs],
+                "output_layout": kernel.output_layout,
+                "proof_classes": kernel.proof_classes,
+            }
+            for kernel in kernels
+        ],
+        "root_exact_factors": [
+            {
+                "output_index": root["output_index"],
+                "color_weight": root["color_weight"],
+                "coupling": root["coupling"],
+                "helicity_weight": root["helicity_weight"],
+                "all_sector_weight": root["all_sector_weight"],
+                "contraction_coefficients": _mapping(
+                    root["contraction_ir"], "root.contraction_ir"
+                )["coefficients"],
+            }
+            for root in roots
+        ],
+    }
+
+
+def _fraction(value: object) -> Fraction:
+    return Fraction.from_float(float(value))
+
+
+def _complex_mul(left: _ComplexFraction, right: _ComplexFraction) -> _ComplexFraction:
+    return (
+        left[0] * right[0] - left[1] * right[1],
+        left[0] * right[1] + left[1] * right[0],
+    )
+
+
+def _fraction_record(value: Fraction) -> tuple[str, str]:
+    return str(value.numerator), str(value.denominator)
+
+
+def _complex_record(value: _ComplexFraction) -> object:
+    return _fraction_record(value[0]), _fraction_record(value[1])
+
+
+def _resolved_probe(
+    schema: Mapping[str, object], tables: EagerExecutionTables
+) -> object:
+    """Evaluate reduction semantics with deterministic exact rational amplitudes.
+
+    The probe is deliberately backend-independent.  Its synthetic closure
+    values exercise closure factors, coherent grouping, diagonal LC weights,
+    and sparse NLC/full contractions exactly, without compiling an evaluator.
+    """
+
+    amplitude = _mapping(schema["amplitude_stage"], "amplitude_stage")
+    roots = _records(amplitude["roots"], "amplitude_stage.roots")
+    root_by_output = {int(root["output_index"]): root for root in roots}
+    group_amplitudes: dict[int, _ComplexFraction] = defaultdict(
+        lambda: (Fraction(0), Fraction(0))
+    )
+    for closure in tables.closures:
+        output = closure.amplitude_index
+        root = root_by_output[output]
+        seed = (
+            Fraction((output * 17) % 23 + 1, 23),
+            Fraction((output * 29) % 31 - 15, 31),
+        )
+        factor = (_fraction(closure.factor_real), _fraction(closure.factor_imag))
+        value = _complex_mul(seed, factor)
+        group_id = int(root["coherent_group_id"])
+        previous = group_amplitudes[group_id]
+        group_amplitudes[group_id] = (
+            previous[0] + value[0],
+            previous[1] + value[1],
+        )
+
+    physics = _mapping(schema["physics"], "physics")
+    physical_groups: tuple[Mapping[str, object], ...] | None = None
+    color_replay_raw = amplitude.get("color_topology_replay")
+    if color_replay_raw is not None:
+        color_replay = _mapping(
+            color_replay_raw,
+            "amplitude_stage.color_topology_replay",
+        )
+        physical_groups = _records(
+            color_replay["physical_groups"],
+            "amplitude_stage.color_topology_replay.physical_groups",
+        )
+        expanded_amplitudes: dict[int, _ComplexFraction] = {}
+        for mapping in _records(
+            color_replay["mappings"],
+            "amplitude_stage.color_topology_replay.mappings",
+        ):
+            for route in _records(
+                mapping["group_routes"],
+                "amplitude_stage.color_topology_replay.group_routes",
+            ):
+                source_id = int(route["source_group_id"])
+                target_id = int(route["target_group_id"])
+                assert target_id not in expanded_amplitudes
+                factor = cast(Sequence[object], route["factor"])
+                expanded_amplitudes[target_id] = _complex_mul(
+                    group_amplitudes[source_id],
+                    (_fraction(factor[0]), _fraction(factor[1])),
+                )
+        assert set(expanded_amplitudes) == {
+            int(group["group_id"]) for group in physical_groups
+        }
+        group_amplitudes = defaultdict(
+            lambda: (Fraction(0), Fraction(0)),
+            expanded_amplitudes,
+        )
+
+    reduction = _mapping(physics["reduction"], "physics.reduction")
+    reduction_groups = _records(reduction["groups"], "physics.reduction.groups")
+    if physical_groups is None:
+        component_by_group = {}
+        for record in reduction_groups:
+            group_id = int(str(record["id"]).rsplit(":", maxsplit=1)[-1])
+            component_by_group[group_id] = (
+                f"{record['representative_color_id']}|"
+                f"{record['representative_helicity_id']}"
+            )
+    else:
+        color_components = _records(
+            physics["color_components"],
+            "physics.color_components",
+        )
+        assert len(color_components) == 1
+        color_id = str(color_components[0]["id"])
+        helicity_ids = {
+            tuple(
+                int(value) for value in cast(Sequence[object], record["values"])
+            ): str(record["representative_id"])
+            for record in _records(physics["helicities"], "physics.helicities")
+        }
+        component_by_group = {
+            int(group["group_id"]): (
+                f"{color_id}|"
+                f"{helicity_ids[tuple(int(value) for value in cast(Sequence[object], group['helicities']))]}"
+            )
+            for group in physical_groups
+        }
+
+    resolved: dict[str, Fraction] = defaultdict(Fraction)
+    contraction = amplitude["color_contraction"]
+    if contraction is None:
+        groups = _records(amplitude["coherent_groups"], "coherent_groups")
+        for group in groups:
+            group_id = int(group["group_id"])
+            value = group_amplitudes[group_id]
+            resolved[component_by_group[group_id]] += _fraction(
+                group["all_sector_weight"]
+            ) * (value[0] * value[0] + value[1] * value[1])
+    else:
+        entries = _logical_color_contraction_entries(
+            _mapping(contraction, "color_contraction")
+        )
+        for entry in entries:
+            left_id = int(entry["left_group_id"])
+            right_id = int(entry["right_group_id"])
+            left = group_amplitudes[left_id]
+            right = group_amplitudes[right_id]
+            product = (
+                left[0] * right[0] + left[1] * right[1],
+                left[1] * right[0] - left[0] * right[1],
+            )
+            weight = cast(Sequence[object], entry["weight"])
+            contribution = _fraction(entry["symmetry_factor"]) * (
+                _fraction(weight[0]) * product[0] - _fraction(weight[1]) * product[1]
+            )
+            # Sparse colour contractions only connect coherent groups for the
+            # same physical helicity. Aggregate by the public resolved axis,
+            # not by upper-triangular entry orientation.
+            component = component_by_group[left_id]
+            assert component == component_by_group[right_id]
+            resolved[component] += contribution
+
+    return {
+        "coherent_amplitudes": [
+            (group_id, _complex_record(value))
+            for group_id, value in sorted(group_amplitudes.items())
+        ],
+        "resolved_group_totals": [
+            (component, _fraction_record(value))
+            for component, value in sorted(resolved.items())
+        ],
+        "total": _fraction_record(sum(resolved.values(), Fraction())),
+    }
+
+
+def _diagnostic_counts(case: _GoldenCase) -> dict[str, int]:
+    schema = case.schema
+    current_storage = _mapping(schema["current_storage"], "current_storage")
+    value_storage = _mapping(schema["value_storage"], "value_storage")
+    amplitude = _mapping(schema["amplitude_stage"], "amplitude_stage")
+    physics = _mapping(schema["physics"], "physics")
+    selector = case.tables.selector_closures
+    contraction = amplitude["color_contraction"]
+    contraction_entries = (
+        ()
+        if contraction is None
+        else _logical_color_contraction_entries(
+            _mapping(contraction, "color_contraction")
+        )
+    )
+    return {
+        "current_slots": len(_records(current_storage["current_slots"], "currents")),
+        "value_slots": len(_records(value_storage["value_slots"], "values")),
+        "momentum_slots": len(_records(schema["momentum_slots"], "momenta")),
+        "stages": len(case.tables.stages),
+        "invocations": case.tables.invocation_count,
+        "attachments": case.tables.attachment_count,
+        "finalizations": sum(len(stage.finalizations) for stage in case.tables.stages),
+        "closures": len(case.tables.closures),
+        "couplings": len(case.tables.couplings),
+        "selector_domains": 0 if selector is None else len(selector.domains),
+        "selector_memberships": (
+            0 if selector is None else len(selector.domain_group_ids)
+        ),
+        "reduction_groups": len(
+            _records(
+                _mapping(physics["reduction"], "physics.reduction")["groups"],
+                "physics.reduction.groups",
+            )
+        ),
+        "color_contraction_entries": len(contraction_entries),
+        "amplitude_roots": len(_records(amplitude["roots"], "roots")),
+        "referenced_exact_kernels": len(case.tables.referenced_kernel_ids),
+    }
+
+
+def _snapshot(case: _GoldenCase) -> dict[str, object]:
+    sections = {
+        "layout": _layout_semantics(case.schema),
+        "tables": _table_semantics(case.tables),
+        "selectors": _selector_semantics(case.schema, case.tables),
+        "reductions": _reduction_semantics(case.schema),
+        "exact": _exact_semantics(case),
+        "resolved": _resolved_probe(case.schema, case.tables),
+    }
+    return {
+        "counts": _diagnostic_counts(case),
+        "digests": {name: _digest(value) for name, value in sections.items()},
+        "semantic_sha256": _digest(sections),
+    }
+
+
+# Refreshed after 0c4fa415 retained exact i/sqrt(2) vertex normalization and
+# 961f1b67 added rational colour weights. Exact expressions change content-derived
+# kernel IDs and hence table digests; exact_weight changes NLC/full reductions.
+# Replaying only the former normalization and omitting exact_weight reproduces
+# every preceding golden. Counts, layout, selectors and resolved probes are
+# unchanged. Section digests identify semantic drift without hashing packed bytes.
+# Refreshed again for exact symbolic propagator phases in the Symbolica 3 port.
+# The Symbolica 2.2 baseline reproduces the preceding goldens; all eight referenced
+# kernels remain symbolically equivalent. Only two Weyl propagators replace float
+# unit phases with exact units, renumbering content-derived IDs across the catalog.
+# Remapping those IDs reproduces all four preceding table digests. Counts, layout,
+# selectors, reductions and exact-rational resolved probes are unchanged.
+# The published Symbolica 3.0 wheel changes canonical complex-number printing,
+# again renumbering content-derived IDs. All 53 kernels are symbolically identical
+# to the retained candidate pack. Restoring that pack's exact strings/signatures
+# and remapping IDs reproduces every preceding exact and table digest; all other
+# sections remain unchanged.
+_EXPECTED: dict[str, dict[str, object]] = {
+    "lc-topology-replay": {
+        "counts": {
+            "amplitude_roots": 24,
+            "attachments": 126,
+            "closures": 24,
+            "color_contraction_entries": 0,
+            "couplings": 2,
+            "current_slots": 69,
+            "finalizations": 58,
+            "invocations": 126,
+            "momentum_slots": 11,
+            "reduction_groups": 24,
+            "referenced_exact_kernels": 6,
+            "selector_domains": 59,
+            "selector_memberships": 144,
+            "stages": 3,
+            "value_slots": 69,
+        },
+        "digests": {
+            "exact": "b1c2417ad5ef0283b529f4d347f7e174df526a191df598899e1737aa76065824",
+            "layout": "b62b48a5e371e65041aff8f7f0f47ccc6b354a838360b1ba8480de104744d83b",
+            "reductions": "3864a2185e4b6613de4cd650431a1cb6a42c224556e73ffb57d471dc5424b6f1",
+            "resolved": "4347816ea9472a7c77bd4638259933ac67a562a9fa7478795233da6dc43cab7b",
+            "selectors": "e05447b4632d2b06aed2ecc2ecec8526d3aa65e62583ae58f52f4881207435cb",
+            "tables": "c636926e14178c9b2a833a1c976a1100db7a4796aac323d44abb6fcf2b68a1c3",
+        },
+        "semantic_sha256": "15068225c280e5bb16516b044556e60bdd1e175664da650a2d00da154c65a189",
+    },
+    "lc-all-flow-union": {
+        "counts": {
+            "amplitude_roots": 48,
+            "attachments": 242,
+            "closures": 48,
+            "color_contraction_entries": 0,
+            "couplings": 2,
+            "current_slots": 117,
+            "finalizations": 106,
+            "invocations": 210,
+            "momentum_slots": 13,
+            "reduction_groups": 48,
+            "referenced_exact_kernels": 6,
+            "selector_domains": 139,
+            "selector_memberships": 384,
+            "stages": 3,
+            "value_slots": 117,
+        },
+        "digests": {
+            "exact": "907d6b5d5681b55224a7582b600236d63aceb4bbed8e2ca5ab3409f394eceed0",
+            "layout": "24432cc2b2d22a0c83adaddfe58e0beb1ce8447c5df44417e4b6c7e00fffb690",
+            "reductions": "b7d5c3c614f70ad6c4bf7f8afb1b3a0a8a5c33dcae0a0c12d271992928ec3a2a",
+            "resolved": "f038d7b438a5b59baabc439fb712dbe3fd455f433f20e9da7490e574acc22927",
+            "selectors": "7eafd41c8048e0c0d992c5078af4d67e94a9295688d8166a4962ff129a99b419",
+            "tables": "ef1d7173787a43a39214419b103b7a96f6abba3efc54743b4e00ba938de6c9fb",
+        },
+        "semantic_sha256": "e19d09c7b176933d503d84a821fac830573a8ddb90ccc5fe40f0906bf37966ca",
+    },
+    "nlc-contracted": {
+        "counts": {
+            "amplitude_roots": 9,
+            "attachments": 60,
+            "closures": 9,
+            "color_contraction_entries": 63,
+            "couplings": 1,
+            "current_slots": 42,
+            "finalizations": 35,
+            "invocations": 54,
+            "momentum_slots": 10,
+            "reduction_groups": 9,
+            "referenced_exact_kernels": 4,
+            "selector_domains": 16,
+            "selector_memberships": 23,
+            "stages": 2,
+            "value_slots": 42,
+        },
+        "digests": {
+            "exact": "d488c9d3052b05076ec2c05c9ab16d258fff27125769ed0e777371d2fe4bf065",
+            "layout": "6c829c0734a995d06f4dcc63bc0967d77bd838c7c733c0ef204f68b4c80ac32a",
+            "reductions": "2aac0b41a34bf54335d14337c4cc130f078b11c8a13dce0e5ed7ff2eb7c0bb4d",
+            "resolved": "673928032c4063e5aacb8eab41076de0d6c49ea64e56b13c0fa43c149c2c2393",
+            "selectors": "72534cf8b4737ba7bbf91913532f6240828386a1cd1d3146b253f44680af0a00",
+            "tables": "0831eff6d1237197672f30cecbeb763edf2682803920f07e52e11b2bfa2002a3",
+        },
+        "semantic_sha256": "90ae984c8e55ef27182edd2e8b4bad27e3f39c8d054c1834b95e707d15e54da7",
+    },
+    "full-contracted": {
+        "counts": {
+            "amplitude_roots": 9,
+            "attachments": 60,
+            "closures": 9,
+            "color_contraction_entries": 63,
+            "couplings": 1,
+            "current_slots": 42,
+            "finalizations": 35,
+            "invocations": 54,
+            "momentum_slots": 10,
+            "reduction_groups": 9,
+            "referenced_exact_kernels": 4,
+            "selector_domains": 16,
+            "selector_memberships": 23,
+            "stages": 2,
+            "value_slots": 42,
+        },
+        "digests": {
+            "exact": "d488c9d3052b05076ec2c05c9ab16d258fff27125769ed0e777371d2fe4bf065",
+            "layout": "71ddc16d027bd79283f4861d26a53e3233faf17f2411db49c9607bd21fbb8318",
+            "reductions": "0c27a7a5da29bf9569e5477991283edf65c1acd5e424af9a8a15d828d985dd82",
+            "resolved": "19acacf5110579b2c157b48dc5c4aacac3da5b51d76f13658ce4a5cbd73754de",
+            "selectors": "6f33e6fbd9d47db7a6f0bb8434606ef5b24eb2c644fd3d03006a35201b89a6d3",
+            "tables": "387438ecdc15df79663950e05408d4cd675c1157946ff7a451d89cd48b2a222d",
+        },
+        "semantic_sha256": "d64112012b5cc7280936f2ec8b55ef14b213b226e93734c436954d94716ec545",
+    },
+}
+
+
+def test_plan_v2_abi_and_capability_are_the_explicit_legacy_contract() -> None:
+    assert EAGER_PLAN_ABI == _LEGACY_PLAN_ABI
+    assert EAGER_RUNTIME_CAPABILITY == _LEGACY_RUNTIME_CAPABILITY
+
+
+def test_plan_v2_semantic_goldens(golden_cases: tuple[_GoldenCase, ...]) -> None:
+    actual = {case.name: _snapshot(case) for case in golden_cases}
+    assert actual == _EXPECTED
diff --git a/pyamplicol/tests/unit/test_eager_rust_integration.py b/pyamplicol/tests/unit/test_eager_rust_integration.py
new file mode 100644
index 0000000000..58c63d6782
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_rust_integration.py
@@ -0,0 +1,730 @@
+# SPDX-License-Identifier: 0BSD
+"""Integration scaffold contracts for future Rust eager lowering."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from types import SimpleNamespace
+from typing import cast
+
+import pytest
+
+import pyamplicol.generation.artifact_writer as artifact_writer
+import pyamplicol.generation.runtime_schema as runtime_schema
+import pyamplicol.generation.service as generation_service
+from pyamplicol.api.errors import GenerationError
+from pyamplicol.api.requests import ModelSource, ProcessRequest
+from pyamplicol.artifacts import ArtifactBuilder
+from pyamplicol.config import Action, EvaluatorConfig, RunConfig
+from pyamplicol.generation.artifact_writer import (
+    EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    EAGER_PLAN_V3_ABI,
+    EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+    EAGER_RUNTIME_CONTAINER_KIND,
+    EAGER_RUNTIME_CONTAINER_SCHEMA_VERSION,
+    EAGER_RUNTIME_LAYOUT_ABI,
+    EAGER_RUNTIME_STORAGE_ABI,
+    EagerPlanV3ProcessArtifact,
+)
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.eager_columnar import (
+    EAGER_LOWERING_INPUT_ABI,
+    EagerLoweringInputV1,
+    runtime_model_parameter_records_from_eager_input,
+)
+from pyamplicol.generation.eager_lowering import (
+    MappingEagerKernelResolver,
+    PreparedCatalogEagerKernelIndex,
+)
+from pyamplicol.generation.physics_metadata import (
+    EAGER_PLAN_V3_REDUCTION_ENTRIES_MEMBER,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_CONTAINER_PATH,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_KIND,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_MEMBER,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_RUNTIME_LAYOUT_ABI,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_SCHEMA_VERSION,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_STORAGE_ABI,
+    NATIVE_REDUCTION_GROUPS_EXTENSION_KEY,
+)
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.generation.validation import ValidationPointRecord
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.base import Model
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+_PROCESS_ID = "eager_v3_test"
+_RUNTIME_BYTES = b"future-rust-eager-runtime-pacbin"
+_INDEX_SHA256 = "3" * 64
+
+
+def _resolver_for(dag: object, model: Model) -> MappingEagerKernelResolver:
+    concrete = cast(generation_service.GenericDAG, dag)
+    propagators: set[tuple[int, int]] = set()
+    for current in concrete.currents:
+        key = (current.index.particle_id, current.index.chirality)
+        if model._propagator_ir(*key).applies_propagator:
+            propagators.add(key)
+    return MappingEagerKernelResolver(
+        vertex_kernels={
+            kind: 100 + index
+            for index, kind in enumerate(sorted(concrete.required_vertex_kinds))
+        },
+        propagator_kernels={
+            key: 1_000 + index for index, key in enumerate(sorted(propagators))
+        },
+        closure_kernels={
+            (str(root.kind), root.vertex_kind): 2_000 + root.id
+            for root in concrete.amplitude_roots
+            if root.kind != "direct-contraction"
+        },
+    )
+
+
+def _service_case() -> tuple[
+    Model,
+    generation_service._CompiledProcess,
+    generation_service._ResolvedModel,
+    MappingEagerKernelResolver,
+]:
+    model = BuiltinSMModel()
+    process_ir = build_process_ir("d d~ > z g")
+    dag = compile_generic_dag(process_ir, model=model)
+    request = ProcessRequest.parse(process_ir.process, name=_PROCESS_ID)
+    compiled = generation_service._CompiledProcess(
+        expanded=generation_service._ExpandedProcess(request, process_ir),
+        dag=dag,
+        helicity_sum_dag=None,
+        helicity_selector_union_dag=None,
+        coverage={},
+        filters={},
+        validation_points=(
+            ValidationPointRecord(
+                process_id=_PROCESS_ID,
+                process=process_ir.process,
+                seed=1,
+                error="not sampled in scaffold test",
+            ),
+        ),
+    )
+    resolved = generation_service._ResolvedModel(
+        source=ModelSource.built_in_sm(),
+        model=model,
+        eager_kernel_index=cast(PreparedCatalogEagerKernelIndex, object()),
+    )
+    return model, compiled, resolved, _resolver_for(dag, model)
+
+
+def _binding_result(lowering_input: EagerLoweringInputV1) -> dict[str, object]:
+    return {
+        "kind": "pyamplicol-eager-runtime-lowering-result",
+        "schema_version": 1,
+        "lowering_input_abi": EAGER_LOWERING_INPUT_ABI,
+        "lowering_input_sha256": lowering_input.digest,
+        "eager_plan_abi": EAGER_PLAN_V3_ABI,
+        "runtime_layout_abi": EAGER_RUNTIME_LAYOUT_ABI,
+        "required_runtime_capabilities": sorted(
+            (
+                EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+                EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+            )
+        ),
+        "runtime_container": {
+            "kind": EAGER_RUNTIME_CONTAINER_KIND,
+            "schema_version": EAGER_RUNTIME_CONTAINER_SCHEMA_VERSION,
+            "storage_abi": EAGER_RUNTIME_STORAGE_ABI,
+            "member_count": 7,
+            "unpacked_size_bytes": 4096,
+            "index_sha256": _INDEX_SHA256,
+        },
+        "inspection_summary": {
+            "stage_count": 3,
+            "invocation_count": 17,
+            "attachment_count": 19,
+        },
+    }
+
+
+def _patch_binding(
+    monkeypatch: pytest.MonkeyPatch,
+    binding: object,
+) -> None:
+    native = SimpleNamespace(_lower_eager_runtime_v1=binding)
+    original = generation_service.importlib.import_module
+
+    def import_module(name: str) -> object:
+        if name == "pyamplicol._rusticol":
+            return native
+        return original(name)
+
+    monkeypatch.setattr(generation_service.importlib, "import_module", import_module)
+
+
+def _forbidden(message: str):
+    def fail(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError(message)
+
+    return fail
+
+
+def test_plan_v3_builds_columnar_input_without_schema_or_evaluator_compilation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model, compiled, resolved, resolver = _service_case()
+    captured: list[EagerLoweringInputV1] = []
+
+    def binding(lowering_input: EagerLoweringInputV1, destination: str) -> object:
+        captured.append(lowering_input)
+        Path(destination).write_bytes(_RUNTIME_BYTES)
+        return _binding_result(lowering_input)
+
+    _patch_binding(monkeypatch, binding)
+    monkeypatch.setattr(
+        generation_service,
+        "PreparedCatalogEagerKernelResolver",
+        lambda *_args: resolver,
+    )
+    assert not hasattr(generation_service, "lower_fused_eager_execution")
+    for name in (
+        "build_runtime_expression_schema",
+        "build_and_write_generic_stage_evaluator_artifacts",
+        "write_model_parameter_evaluator_artifact",
+    ):
+        monkeypatch.setattr(
+            generation_service,
+            name,
+            _forbidden(f"plan-v3 called {name}"),
+        )
+    monkeypatch.setattr(
+        runtime_schema,
+        "build_runtime_schema_layout",
+        _forbidden("plan-v3 called expanded runtime-schema construction"),
+    )
+
+    backend = generation_service.GenerationBackend(
+        RunConfig(
+            action=Action.GENERATE,
+            evaluator=EvaluatorConfig(execution_mode="eager"),
+        ),
+        None,
+    )
+    result = backend._construct_eager_artifact(
+        compiled,
+        model,
+        resolved,
+        tmp_path,
+        PhaseHandle("test", None, 1),
+    )
+
+    assert isinstance(result, EagerPlanV3ProcessArtifact)
+    assert len(captured) == 1
+    assert captured[0].abi == EAGER_LOWERING_INPUT_ABI
+    assert result.lowering_input_sha256 == captured[0].digest
+    assert result.eager_runtime_path.read_bytes() == _RUNTIME_BYTES
+    assert result.referenced_kernel_ids
+    assert result.physics["schema_version"] == 1
+    assert result.physics["kind"] == "pyamplicol-resolved-physics"
+    assert result.physics["process_id"] == _PROCESS_ID
+    assert result.physics["process"] == compiled.dag.process.process
+    coverage = cast(dict[str, object], result.physics["coverage"])
+    assert coverage["helicities"] == "complete"
+    assert coverage["color"] == "complete"
+    assert coverage["color_kind"] == "physical-lc-flows"
+    assert len(cast(list[object], result.physics["external_particles"])) == 4
+    helicities = cast(list[dict[str, object]], result.physics["helicities"])
+    assert len(helicities) == 24
+    assert coverage["structural_zero_helicity_count"] == sum(
+        bool(record["structural_zero"]) for record in helicities
+    )
+    assert cast(list[object], result.physics["color_components"])
+    assert cast(dict[str, object], result.physics["reduction"])["groups"] == []
+    descriptor = cast(dict[str, object], result.physics["extensions"])[
+        NATIVE_REDUCTION_GROUPS_EXTENSION_KEY
+    ]
+    assert descriptor == {
+        "kind": EAGER_PLAN_V3_REDUCTION_GROUPS_KIND,
+        "schema_version": EAGER_PLAN_V3_REDUCTION_GROUPS_SCHEMA_VERSION,
+        "storage_abi": EAGER_PLAN_V3_REDUCTION_GROUPS_STORAGE_ABI,
+        "runtime_layout_abi": EAGER_PLAN_V3_REDUCTION_GROUPS_RUNTIME_LAYOUT_ABI,
+        "container_path": EAGER_PLAN_V3_REDUCTION_GROUPS_CONTAINER_PATH,
+        "group_member": EAGER_PLAN_V3_REDUCTION_GROUPS_MEMBER,
+        "entry_member": EAGER_PLAN_V3_REDUCTION_ENTRIES_MEMBER,
+        "group_count": len(
+            cast(list[object], captured[0].table("coherent_groups").column("id"))
+        ),
+    }
+    assert cast(list[object], result.physics["model_parameters"])
+    eager_parameter_records = runtime_model_parameter_records_from_eager_input(
+        captured[0]
+    )
+    expected_parameters: dict[str, dict[str, object]] = {}
+    for record in eager_parameter_records:
+        runtime_name = str(record.get("runtime_name", record["name"]))
+        expected = expected_parameters.setdefault(
+            runtime_name,
+            {
+                "name": runtime_name,
+                "default_real": 0.0,
+                "default_imaginary": 0.0,
+            },
+        )
+        field = (
+            "default_imaginary"
+            if record.get("complex_component") == "imag"
+            else "default_real"
+        )
+        expected[field] = record["default"]
+    for parameter in cast(list[dict[str, object]], result.physics["model_parameters"]):
+        expected = expected_parameters[str(parameter["name"])]
+        assert parameter["default_real"] == expected["default_real"]
+        assert parameter["default_imaginary"] == expected["default_imaginary"]
+    assert result.physics["selectors"] == {
+        "helicity": True,
+        "color_flow": True,
+        "contracted_color": False,
+    }
+
+
+def test_plan_v3_binding_failure_is_closed_and_removes_partial_output(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model, compiled, _resolved, resolver = _service_case()
+    lowering_input = generation_service.build_eager_lowering_input_v1(
+        dag=compiled.dag,
+        model=model,
+        resolver=resolver,
+        process_id=_PROCESS_ID,
+    )
+    destination = tmp_path / "eager-runtime.pacbin"
+
+    def binding(_lowering_input: object, output: str) -> object:
+        Path(output).write_bytes(b"partial")
+        raise RuntimeError("native lowering stopped")
+
+    _patch_binding(monkeypatch, binding)
+    with pytest.raises(GenerationError, match="native lowering stopped"):
+        generation_service._invoke_rust_eager_lowering_v1(
+            lowering_input,
+            destination,
+        )
+
+    assert not destination.exists()
+
+
+def test_eager_generation_is_v3_only_and_compiled_mode_ignores_legacy_env(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model, compiled, resolved, resolver = _service_case()
+    monkeypatch.delenv("PYAMPLICOL_EAGER_PLAN_VERSION", raising=False)
+    monkeypatch.setattr(
+        generation_service,
+        "PreparedCatalogEagerKernelResolver",
+        lambda *_args: resolver,
+    )
+    captured: list[EagerLoweringInputV1] = []
+
+    def binding(lowering_input: EagerLoweringInputV1, destination: str) -> object:
+        captured.append(lowering_input)
+        Path(destination).write_bytes(_RUNTIME_BYTES)
+        return _binding_result(lowering_input)
+
+    _patch_binding(monkeypatch, binding)
+
+    eager_backend = generation_service.GenerationBackend(
+        RunConfig(
+            action=Action.GENERATE,
+            evaluator=EvaluatorConfig(execution_mode="eager"),
+        ),
+        None,
+    )
+    eager = eager_backend._construct_eager_artifact(
+        compiled,
+        model,
+        resolved,
+        tmp_path,
+        PhaseHandle("v3", None, 1),
+    )
+    assert isinstance(eager, EagerPlanV3ProcessArtifact)
+    assert len(captured) == 1
+
+    monkeypatch.setenv("PYAMPLICOL_EAGER_PLAN_VERSION", "v2")
+    with_legacy_environment = eager_backend._construct_eager_artifact(
+        compiled,
+        model,
+        resolved,
+        tmp_path / "legacy-environment",
+        PhaseHandle("legacy-environment", None, 1),
+    )
+    assert isinstance(with_legacy_environment, EagerPlanV3ProcessArtifact)
+    assert len(captured) == 2
+
+    compiled_backend = generation_service.GenerationBackend(
+        RunConfig(action=Action.GENERATE),
+        None,
+    )
+    evaluator = compiled_backend._construct_evaluator(
+        compiled,
+        model,
+        PhaseHandle("compiled", None, 1),
+    )
+    assert evaluator.compiled is compiled
+
+
+def test_eager_direct_descriptor_is_serialized_into_kernel_metadata(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = b"portable-symjit-application"
+    descriptor = b"explicit-direct-table-descriptor"
+
+    class Bundle:
+        @staticmethod
+        def read_payload(path: str) -> bytes:
+            assert path == "kernels/17/plane-application.symjit"
+            return source
+
+    monkeypatch.setattr(
+        artifact_writer,
+        "_derive_eager_direct_descriptor",
+        lambda *_args, **_kwargs: descriptor,
+    )
+    manifest, path, payload = artifact_writer._eager_direct_evaluator_manifest(
+        bundle=Bundle(),
+        kernel_id=17,
+        input_complex_count=3,
+        output_complex_count=2,
+        manifest={
+            "kind": "symjit-application-evaluator",
+            "application_path": "kernels/17/application.symjit",
+            "application_abi": artifact_writer.SYMJIT_APPLICATION_ABI,
+            "plane_application": {
+                "application_path": "kernels/17/plane-application.symjit",
+                "application_abi": artifact_writer.SYMJIT_PLANE_APPLICATION_ABI,
+                "storage_abi": artifact_writer.SYMJIT_APPLICATION_ABI,
+                "input_complex_count": 3,
+                "output_complex_count": 2,
+            },
+            "build_timing": {"jit_materialize_s": 0.5},
+        },
+    )
+
+    assert path == "kernels/17/eager-direct-table-descriptor-v1.bin"
+    assert payload == descriptor
+    assert manifest["build_timing"]["jit_materialize_s"] == 0.5
+    assert manifest["build_timing"]["eager_direct_descriptor_s"] >= 0.0
+    assert manifest["direct_table"] == {
+        "capability": EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        "source_application_abi": artifact_writer.SYMJIT_PLANE_APPLICATION_ABI,
+        "descriptor_abi": artifact_writer.EAGER_DIRECT_TABLE_DESCRIPTOR_ABI,
+        "binding_abi": artifact_writer.EAGER_DIRECT_TABLE_BINDING_ABI,
+        "descriptor_path": path,
+        "descriptor_size_bytes": len(descriptor),
+        "descriptor_sha256": hashlib.sha256(descriptor).hexdigest(),
+        "input_complex_count": 3,
+        "output_complex_count": 2,
+    }
+
+
+def test_model_parameter_kernel_stays_on_the_ordinary_evaluator_path() -> None:
+    assert not artifact_writer._requires_eager_direct_table("model-parameter")
+    assert artifact_writer._requires_eager_direct_table("vertex")
+
+
+def test_eager_direct_descriptor_rejects_non_symjit_source() -> None:
+    class Bundle:
+        @staticmethod
+        def read_payload(_path: str) -> bytes:
+            raise AssertionError(
+                "incompatible metadata must fail before payload access"
+            )
+
+    with pytest.raises(ValueError, match="plane-application ABI"):
+        artifact_writer._eager_direct_evaluator_manifest(
+            bundle=Bundle(),
+            kernel_id=17,
+            input_complex_count=3,
+            output_complex_count=2,
+            manifest={
+                "kind": "symjit-application-evaluator",
+                "application_path": "kernels/17/application.symjit",
+                "application_abi": "symjit-application-storage-v2",
+            },
+        )
+
+
+def test_eager_direct_descriptor_verifies_native_module_once(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls = {"import": 0, "verify": 0, "descriptor": 0}
+
+    class Native:
+        @staticmethod
+        def _eager_direct_descriptor_v1(
+            source: bytes,
+            input_count: int,
+            output_count: int,
+        ) -> bytes:
+            calls["descriptor"] += 1
+            return source + bytes((input_count, output_count))
+
+    def import_module(name: str) -> object:
+        assert name == "pyamplicol._rusticol"
+        calls["import"] += 1
+        return Native()
+
+    def verify_native_module(_module: object) -> None:
+        calls["verify"] += 1
+
+    artifact_writer._eager_direct_descriptor_operation.cache_clear()
+    monkeypatch.setattr(artifact_writer.importlib, "import_module", import_module)
+    monkeypatch.setattr(
+        artifact_writer,
+        "verify_native_module",
+        verify_native_module,
+    )
+    try:
+        assert (
+            artifact_writer._derive_eager_direct_descriptor(
+                b"first",
+                input_complex_count=3,
+                output_complex_count=2,
+            )
+            == b"first\x03\x02"
+        )
+        assert (
+            artifact_writer._derive_eager_direct_descriptor(
+                b"second",
+                input_complex_count=4,
+                output_complex_count=1,
+            )
+            == b"second\x04\x01"
+        )
+    finally:
+        artifact_writer._eager_direct_descriptor_operation.cache_clear()
+    assert calls == {"import": 1, "verify": 1, "descriptor": 2}
+
+
+def _writer_process(
+    tmp_path: Path,
+    *,
+    inspection_summary: dict[str, object] | None = None,
+) -> EagerPlanV3ProcessArtifact:
+    payload = tmp_path / "native-eager-runtime.pacbin"
+    payload.write_bytes(_RUNTIME_BYTES)
+    return EagerPlanV3ProcessArtifact(
+        process_id=_PROCESS_ID,
+        expression="d d~ > z g",
+        color_accuracy="full",
+        external_pdgs=(1, -1, 23, 21),
+        aliases=(),
+        physics={
+            "schema_version": 1,
+            "kind": "pyamplicol-resolved-physics",
+            "process_id": _PROCESS_ID,
+        },
+        eager_runtime_path=payload,
+        eager_runtime_size_bytes=len(_RUNTIME_BYTES),
+        eager_runtime_sha256=hashlib.sha256(_RUNTIME_BYTES).hexdigest(),
+        eager_runtime_member_count=7,
+        eager_runtime_unpacked_size_bytes=4096,
+        eager_runtime_index_sha256=_INDEX_SHA256,
+        lowering_input_sha256="4" * 64,
+        referenced_kernel_ids=frozenset(),
+        inspection_summary=inspection_summary
+        or {
+            "stage_count": 3,
+            "invocation_count": 17,
+            "attachment_count": 19,
+        },
+        point_tile_size=2048,
+        workspace_mib=384,
+        dag_summary={
+            "current_count": 11,
+            "source_count": 4,
+            "interaction_count": 23,
+            "interaction_evaluation_count": 17,
+            "amplitude_root_count": 5,
+            "truncated": False,
+        },
+        validation_point=ValidationPointRecord(
+            process_id=_PROCESS_ID,
+            process="d d~ > z g",
+            seed=1,
+            error="not sampled in scaffold test",
+        ),
+        generation_filters={},
+    )
+
+
+def _finalize_test_artifact(
+    builder: ArtifactBuilder,
+    process_record: dict[str, object],
+) -> None:
+    builder.finalize(
+        kind="pyamplicol-process",
+        producer={},
+        model={},
+        configuration={},
+        processes=(process_record,),
+        default_process_id=_PROCESS_ID,
+        runtime={},
+    )
+
+
+def test_plan_v3_runtime_and_exact_bounded_summary_publish_atomically(
+    tmp_path: Path,
+) -> None:
+    process = _writer_process(tmp_path)
+    output = tmp_path / "artifact"
+    with ArtifactBuilder(output) as builder:
+        collector = artifact_writer._EvaluatorPayloadCollector(
+            builder,
+            existing=None,
+            target={"triple": "test-target", "cpu_features": []},
+        )
+        process_record, _entry, _sha256 = artifact_writer._write_process_payloads(
+            builder,
+            process,
+            evaluator_payloads=collector,
+        )
+        assert not output.exists()
+        assert builder.staged_path(
+            f"processes/{_PROCESS_ID}/eager-runtime.pacbin"
+        ).is_file()
+        assert builder.staged_path(f"processes/{_PROCESS_ID}/execution.json").is_file()
+        _finalize_test_artifact(builder, process_record)
+
+    execution_path = output / f"processes/{_PROCESS_ID}/execution.json"
+    execution = json.loads(execution_path.read_text(encoding="utf-8"))
+    capabilities = sorted(
+        (
+            EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            EAGER_PLAN_V3_RUNTIME_CAPABILITY,
+        )
+    )
+    assert execution == {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-eager-execution",
+        "required_runtime_capabilities": capabilities,
+        "process": "d d~ > z g",
+        "key": _PROCESS_ID,
+        "color_accuracy": "full",
+        "external_pdg_order": [1, -1, 23, 21],
+        "eager_plan_abi": EAGER_PLAN_V3_ABI,
+        "kernel_pack": {
+            "manifest_path": "model/eager-kernel-pack.json",
+            "payload_root": "model/eager-kernels",
+        },
+        "runtime_options": {"point_tile_size": 2048, "workspace_mib": 384},
+        "plan": {
+            "kind": "pyamplicol-runtime-eager-execution",
+            "eager_plan_abi": EAGER_PLAN_V3_ABI,
+            "lowering_input_abi": EAGER_LOWERING_INPUT_ABI,
+            "lowering_input_sha256": "4" * 64,
+            "runtime_layout_abi": EAGER_RUNTIME_LAYOUT_ABI,
+            "required_runtime_capabilities": capabilities,
+            "runtime_container": {
+                "kind": EAGER_RUNTIME_CONTAINER_KIND,
+                "schema_version": EAGER_RUNTIME_CONTAINER_SCHEMA_VERSION,
+                "storage_abi": EAGER_RUNTIME_STORAGE_ABI,
+                "path": "eager-runtime.pacbin",
+                "size_bytes": len(_RUNTIME_BYTES),
+                "sha256": hashlib.sha256(_RUNTIME_BYTES).hexdigest(),
+                "member_count": 7,
+                "unpacked_size_bytes": 4096,
+                "index_sha256": _INDEX_SHA256,
+            },
+            "inspection_summary": {
+                "stage_count": 3,
+                "invocation_count": 17,
+                "attachment_count": 19,
+            },
+            "materialization_census": {
+                "abi": "pyamplicol-fully-resident-materialization-census-v1",
+                "basis": "immutable-fully-resident-eager-plan",
+                "final": {
+                    "source_count": 4,
+                    "current_count": 11,
+                    "interaction_count": 23,
+                    "amplitude_root_count": 5,
+                    "invocation_count": 17,
+                    "attachment_count": 19,
+                },
+                "peak": {
+                    "source_count": 4,
+                    "current_count": 11,
+                    "interaction_count": 23,
+                    "amplitude_root_count": 5,
+                    "invocation_count": 17,
+                    "attachment_count": 19,
+                },
+                "final_equals_peak": True,
+            },
+        },
+        "dag_summary": {
+            "current_count": 11,
+            "source_count": 4,
+            "interaction_count": 23,
+            "interaction_evaluation_count": 17,
+            "amplitude_root_count": 5,
+            "truncated": False,
+        },
+    }
+    assert execution_path.stat().st_size < 1 << 20
+    assert (
+        output / f"processes/{_PROCESS_ID}/eager-runtime.pacbin"
+    ).read_bytes() == _RUNTIME_BYTES
+    assert not tuple(tmp_path.glob(".artifact.staging-*"))
+
+
+def test_plan_v3_summary_failure_rolls_back_staged_runtime(
+    tmp_path: Path,
+) -> None:
+    process = _writer_process(
+        tmp_path,
+        inspection_summary={"nonfinite": float("nan")},
+    )
+    output = tmp_path / "artifact"
+    output.mkdir()
+    sentinel = output / "sentinel"
+    sentinel.write_bytes(b"existing artifact")
+    staged: list[str] = []
+
+    class TrackingCollector(artifact_writer._EvaluatorPayloadCollector):
+        def add_file(
+            self,
+            relative: str,
+            source: Path,
+            *,
+            process_id: str | None,
+        ):
+            record = super().add_file(
+                relative,
+                source,
+                process_id=process_id,
+            )
+            staged.append(record.path)
+            return record
+
+    with (
+        pytest.raises(ValueError, match="not canonical JSON"),
+        ArtifactBuilder(output, mode="replace") as builder,
+    ):
+        collector = TrackingCollector(
+            builder,
+            existing=None,
+            target={"triple": "test-target", "cpu_features": []},
+        )
+        artifact_writer._write_process_payloads(
+            builder,
+            process,
+            evaluator_payloads=collector,
+        )
+
+    assert staged == [f"processes/{_PROCESS_ID}/eager-runtime.pacbin"]
+    assert sentinel.read_bytes() == b"existing artifact"
+    assert not (output / f"processes/{_PROCESS_ID}").exists()
+    assert not tuple(tmp_path.glob(".artifact.staging-*"))
diff --git a/pyamplicol/tests/unit/test_eager_tables.py b/pyamplicol/tests/unit/test_eager_tables.py
new file mode 100644
index 0000000000..1a219f0156
--- /dev/null
+++ b/pyamplicol/tests/unit/test_eager_tables.py
@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import struct
+
+import pytest
+
+from pyamplicol.generation.eager_tables import (
+    EAGER_OUTPUT_FACTOR_COUPLING_IMAG,
+    EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+    EAGER_OUTPUT_FACTOR_NONE,
+    EAGER_SELECTOR_DOMAINS_ABI,
+    MISSING_U32,
+    EagerAttachmentRow,
+    EagerClosureRow,
+    EagerCouplingRow,
+    EagerFinalizationRow,
+    EagerInvocationRow,
+    EagerSelectorDomainIdRow,
+    EagerSelectorDomainRow,
+    EagerSelectorGroupRow,
+    pack_rows,
+    unpack_rows,
+)
+
+
+@pytest.mark.parametrize(
+    "rows",
+    (
+        (
+            EagerInvocationRow(2, 3, 5, 7, 11, 13, EAGER_OUTPUT_FACTOR_NONE, 17, 19),
+            EagerInvocationRow(
+                23,
+                29,
+                31,
+                37,
+                41,
+                43,
+                EAGER_OUTPUT_FACTOR_COUPLING_REAL,
+                47,
+                53,
+            ),
+        ),
+        (
+            EagerAttachmentRow(2, -0.5, 0.25),
+            EagerAttachmentRow(3, 1.0, 0.0),
+        ),
+        (
+            EagerCouplingRow(MISSING_U32, MISSING_U32, -0.5, 0.25),
+            EagerCouplingRow(3, 5, 0.0, 0.0),
+        ),
+        (
+            EagerFinalizationRow(MISSING_U32, 2, 3, MISSING_U32, 5),
+            EagerFinalizationRow(7, 11, MISSING_U32, 13, 17),
+        ),
+        (
+            EagerClosureRow(2, 3, 5, 7, 11, EAGER_OUTPUT_FACTOR_NONE, -1.0, 0.5),
+            EagerClosureRow(
+                13,
+                17,
+                19,
+                23,
+                29,
+                EAGER_OUTPUT_FACTOR_COUPLING_IMAG,
+                1.0,
+                0.0,
+            ),
+        ),
+        (
+            EagerSelectorDomainRow(0, 0),
+            EagerSelectorDomainRow(17, 19),
+        ),
+        (
+            EagerSelectorGroupRow(0x01020304),
+            EagerSelectorGroupRow(29),
+        ),
+        (
+            EagerSelectorDomainIdRow(0x05060708),
+            EagerSelectorDomainIdRow(31),
+        ),
+    ),
+)
+def test_eager_fixed_width_tables_round_trip(rows: tuple[object, ...]) -> None:
+    row_type = type(rows[0])
+    payload = pack_rows(rows)  # type: ignore[arg-type]
+    reference_payload = b"".join(row_type._STRUCT.pack(*row._values()) for row in rows)
+    assert payload == reference_payload
+    assert len(payload) == len(rows) * row_type._STRUCT.size
+    assert unpack_rows(payload, row_type) == rows
+
+
+def test_eager_table_rejects_mixed_rows() -> None:
+    with pytest.raises(TypeError, match="one row type"):
+        pack_rows(
+            (
+                EagerAttachmentRow(0, 1.0, 0.0),
+                EagerClosureRow(0, 0, 0, 0, 0, EAGER_OUTPUT_FACTOR_NONE, 1, 0),
+            )
+        )
+
+
+def test_eager_table_rejects_truncated_payload() -> None:
+    payload = pack_rows(
+        (EagerInvocationRow(0, 1, 2, 3, 4, 5, EAGER_OUTPUT_FACTOR_NONE, 6, 7),)
+    )
+    with pytest.raises(ValueError, match="not a multiple"):
+        unpack_rows(payload[:-1], EagerInvocationRow)
+
+
+def test_selector_domain_rows_have_exact_little_endian_bytes() -> None:
+    assert EAGER_SELECTOR_DOMAINS_ABI == "pyamplicol-eager-selector-domains-v1"
+    assert pack_rows((EagerSelectorDomainRow(0x0102030405060708, 2),)) == (
+        struct.pack("<QQ", 0x0102030405060708, 2)
+    )
+    assert pack_rows((EagerSelectorGroupRow(0x01020304),)) == b"\x04\x03\x02\x01"
+    assert pack_rows((EagerSelectorDomainIdRow(0x05060708),)) == (b"\x08\x07\x06\x05")
+
+
+def test_eager_table_identifiers_are_bounded() -> None:
+    with pytest.raises(ValueError, match="unsigned 32-bit"):
+        EagerAttachmentRow(1 << 32, 1.0, 0.0)
+    with pytest.raises(ValueError, match="unsigned 64-bit"):
+        EagerInvocationRow(0, 0, 0, 0, 0, 0, EAGER_OUTPUT_FACTOR_NONE, -1, 0)
+
+
+@pytest.mark.parametrize(
+    "row",
+    (
+        EagerAttachmentRow,
+        EagerCouplingRow,
+        EagerClosureRow,
+    ),
+)
+def test_eager_table_floating_values_must_be_finite(row: type[object]) -> None:
+    with pytest.raises(ValueError, match="finite"):
+        if row is EagerAttachmentRow:
+            EagerAttachmentRow(0, float("nan"), 0.0)
+        elif row is EagerCouplingRow:
+            EagerCouplingRow(MISSING_U32, MISSING_U32, 0.0, float("inf"))
+        else:
+            EagerClosureRow(
+                0,
+                0,
+                0,
+                0,
+                0,
+                EAGER_OUTPUT_FACTOR_NONE,
+                float("-inf"),
+                0.0,
+            )
diff --git a/pyamplicol/tests/unit/test_evaluator_artifacts.py b/pyamplicol/tests/unit/test_evaluator_artifacts.py
new file mode 100644
index 0000000000..84bf9917c6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_evaluator_artifacts.py
@@ -0,0 +1,537 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import shutil
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+import numpy as np
+import pytest
+
+import pyamplicol.evaluators.symbolica_adapters as symbolica_adapters
+from pyamplicol._internal.physics.types import NativeEvaluationError
+from pyamplicol._internal.versions import (
+    SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+    SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+    SYMJIT_APPLICATION_ABI,
+    SYMJIT_F64_RUNTIME_CAPABILITY,
+    SYMJIT_PLANE_APPLICATION_ABI,
+)
+from pyamplicol.evaluators.execution_schema import evaluator_runtime_capabilities
+from pyamplicol.evaluators.symbolica_adapters import (
+    _ChunkedSymbolicaEvaluator,
+    _compiled_complex_custom_header,
+    _compiled_runtime_capability,
+    _CompiledComplexEvaluatorAdapter,
+    _JITSymbolicaEvaluatorAdapter,
+)
+from pyamplicol.evaluators.symbolica_compile import _chunk_parameter_indices
+from pyamplicol.evaluators.symbolica_helpers import (
+    _symbolica_instruction_program,
+    _symbolica_instruction_program_repr,
+)
+from pyamplicol.evaluators.symbolica_settings import SymbolicaEvaluatorSettings
+from pyamplicol.generation.artifact_writer import _evaluator, _stage_evaluator_set
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+class _FakeJITEvaluator:
+    def __init__(self, *, export_error: Exception | None = None) -> None:
+        self.export_error = export_error
+        self.evaluation_count = 0
+
+    def evaluate_complex(self, rows: Any) -> np.ndarray:
+        self.evaluation_count += 1
+        return np.zeros((len(rows), 2), dtype=np.complex128)
+
+    def export_symjit(self, *, complex: bool = False) -> bytes:
+        assert complex is True
+        if self.export_error is not None:
+            raise self.export_error
+        return b"symjit-application-v3"
+
+    def save(self) -> bytes:
+        return b"symbolica-evaluator-state"
+
+    def get_instructions(self) -> tuple[list[object], int, list[object]]:
+        return ([("assign", ("out", 0), ("param", 0))], 1, [])
+
+
+class _FakeRusticol:
+    @staticmethod
+    def _compile_symjit_plane_application_v2(
+        program: str,
+        input_len: int,
+        output_len: int,
+        optimization_level: int,
+        compress: bool,
+    ) -> bytes:
+        assert program
+        assert input_len >= 1
+        assert output_len >= 1
+        assert optimization_level in {0, 1, 2, 3}
+        assert isinstance(compress, bool)
+        return b"symjit-plane-application-v2"
+
+
+@pytest.fixture(autouse=True)
+def _fake_plane_compiler(monkeypatch: pytest.MonkeyPatch) -> None:
+    fake = _FakeRusticol()
+    monkeypatch.setitem(sys.modules, "pyamplicol._rusticol", fake)
+    monkeypatch.setattr(
+        symbolica_adapters,
+        "verify_native_module",
+        lambda _module: None,
+    )
+
+
+class _MappedEvaluator:
+    def __init__(self, input_len: int) -> None:
+        self.input_len = input_len
+
+    def evaluate_complex(self, rows: Any) -> np.ndarray:
+        values = np.asarray(rows, dtype=np.complex128)
+        return values.sum(axis=1, keepdims=True)
+
+
+class _FakeCompiledEvaluator:
+    def __init__(self) -> None:
+        self.compile_kwargs: dict[str, object] | None = None
+
+    def save(self) -> bytes:
+        return b"symbolica-evaluator-state"
+
+    def compile(self, *_args: object, **kwargs: object) -> _MappedEvaluator:
+        self.compile_kwargs = kwargs
+        return _MappedEvaluator(1)
+
+
+def _jit_adapter(
+    evaluator: object | None = None,
+    *,
+    direct_translation: bool = False,
+) -> _JITSymbolicaEvaluatorAdapter:
+    return _JITSymbolicaEvaluatorAdapter(
+        _FakeJITEvaluator() if evaluator is None else evaluator,
+        SymbolicaEvaluatorSettings(
+            backend="jit",
+            jit_direct_translation=direct_translation,
+            jit_optimization_level=3,
+            n_cores=1,
+        ),
+        "test stage",
+        input_len=3,
+        output_len=2,
+    )
+
+
+@pytest.mark.parametrize("structured", [False, True])
+def test_symjit_plane_export_preserves_shared_outputs_and_matching_digest(
+    monkeypatch: pytest.MonkeyPatch,
+    structured: bool,
+) -> None:
+    program = (
+        [
+            ("assign", ("out", 0), ("param", 0)),
+            ("assign", ("out", 1), ("out", 0)),
+        ],
+        0,
+        [],
+    )
+    expected = repr(program)
+    exported = (
+        SimpleNamespace(
+            instructions=program[0],
+            temporary_count=program[1],
+            constants=program[2],
+            sub_evaluators=[],
+        )
+        if structured
+        else program
+    )
+    source = _FakeJITEvaluator()
+    monkeypatch.setattr(source, "get_instructions", lambda: exported)
+    received: list[tuple[object, ...]] = []
+
+    def compile_plane(*args: object) -> bytes:
+        received.append(args)
+        return b"unmodified-plane"
+
+    monkeypatch.setattr(
+        _FakeRusticol,
+        "_compile_symjit_plane_application_v2",
+        staticmethod(compile_plane),
+    )
+
+    application, digest, _target = _jit_adapter(
+        source
+    )._export_symjit_plane_application(optimization_level=2)
+
+    assert received == [(expected, 3, 2, 2, False)]  # JIT compression is opt-in.
+    assert application == b"unmodified-plane"
+    assert digest == hashlib.sha256(expected.encode()).hexdigest()
+    assert source.get_instructions() is exported
+
+
+def test_symbolica_instruction_export_rejects_uninlined_functions() -> None:
+    exported = SimpleNamespace(
+        instructions=[], temporary_count=0, constants=[], sub_evaluators=[object()]
+    )
+    with pytest.raises(
+        NativeEvaluationError, match="inlined Symbolica function bodies"
+    ):
+        _symbolica_instruction_program(exported)
+
+
+@pytest.mark.parametrize(
+    ("constant", "serialized"),
+    [
+        ("1i", "1\U0001d456"),
+        ("-1i", "-1\U0001d456"),
+        ("1+1i", "1+1\U0001d456"),
+        ("1/3-1i/2", "1/3-1\U0001d456/2"),
+        ("2i/3", "2\U0001d456/3"),
+    ],
+)
+def test_symbolica_instruction_constants_have_explicit_imaginary_coefficients(
+    constant: str, serialized: str
+) -> None:
+    from symbolica import E, Expression, S
+
+    x = S("instruction_constant_x")
+    evaluator = Expression.evaluator_multiple(
+        [E(constant) * x], [x], jit_compile=False, n_cores=1
+    )
+    exported = evaluator.get_instructions()
+    original = repr(exported.constants)
+
+    program = _symbolica_instruction_program_repr(exported)
+
+    assert program == (
+        f"({exported.instructions!r}, {exported.temporary_count}, [{serialized}])"
+    )
+    assert repr(exported.constants) == original
+
+
+def test_jit_artifact_persists_direct_application_and_precision_fallback(
+    tmp_path: Path,
+) -> None:
+    source = _FakeJITEvaluator()
+    manifest = _jit_adapter(source).artifact_manifest(tmp_path)
+
+    assert source.evaluation_count == 1
+    assert manifest["kind"] == "symjit-application-evaluator"
+    assert manifest["runtime_capability"] == SYMJIT_F64_RUNTIME_CAPABILITY
+    assert manifest["application_abi"] == SYMJIT_APPLICATION_ABI
+    assert manifest["batch_layout"] == "row-major"
+    assert manifest["compiler_type"] == "native"
+    assert manifest["translation_mode"] == "indirect"
+    assert manifest["optimization_level"] == 3
+    assert manifest["word_bits"] == 64
+    assert manifest["endianness"] == "little"
+    assert manifest["required_defuns"] == []
+    assert manifest["evaluator_state_runtime_capability"] == (
+        SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY
+    )
+    assert (tmp_path / str(manifest["application_path"])).read_bytes() == (
+        b"symjit-application-v3"
+    )
+    plane = manifest["plane_application"]
+    assert isinstance(plane, dict)
+    assert plane["application_abi"] == SYMJIT_PLANE_APPLICATION_ABI
+    assert (
+        tmp_path / str(plane["application_path"])
+    ).read_bytes() == b"symjit-plane-application-v2"
+    assert (tmp_path / str(manifest["evaluator_state_path"])).read_bytes() == (
+        b"symbolica-evaluator-state"
+    )
+    assert evaluator_runtime_capabilities(manifest) == (SYMJIT_F64_RUNTIME_CAPABILITY,)
+
+
+@pytest.mark.parametrize(
+    "compress, expected", (("auto", True), (False, False), (True, True))
+)
+def test_compiled_o2_compression_matches_symbolica_native_lowering_and_metadata(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    compress: bool | str,
+    expected: bool,
+) -> None:
+    from pyamplicol.config import resolve_config
+    from pyamplicol.evaluators.symbolica_compile import _symbolica_evaluator_kwargs
+    from pyamplicol.generation.service import GenerationBackend
+
+    resolution = resolve_config(
+        {
+            "action": "generate",
+            "evaluator": {"execution_mode": "compiled", "jit": {"compress": compress}},
+        }
+    )
+    settings = GenerationBackend(resolution, None)._symbolica_settings()
+    calls: list[tuple[object, ...]] = []
+
+    def compile_plane(*args: object) -> bytes:
+        calls.append(args)
+        return b"compressed-plane"
+
+    monkeypatch.setattr(
+        _FakeRusticol,
+        "_compile_symjit_plane_application_v2",
+        staticmethod(compile_plane),
+    )
+    manifest = _JITSymbolicaEvaluatorAdapter(
+        _FakeJITEvaluator(), settings, "compiled-o2", input_len=3, output_len=2
+    ).artifact_manifest(tmp_path)
+
+    assert resolution.effective.evaluator.jit.compress is expected
+    assert settings.jit_compress is expected
+    assert _symbolica_evaluator_kwargs(settings, verbose=False)["jit_options"] == {
+        "compress": str(expected).lower()
+    }
+    assert calls[0][3:] == (2, expected)
+    assert manifest["settings"]["jit_compress"] is expected
+    assert manifest["plane_application"]["compression"] is expected
+
+
+def test_jit_artifact_rejects_non_self_contained_export(tmp_path: Path) -> None:
+    adapter = _jit_adapter(
+        _FakeJITEvaluator(export_error=ValueError("external defuns present"))
+    )
+    with pytest.raises(NativeEvaluationError, match="external evaluator functions"):
+        adapter.artifact_manifest(tmp_path)
+
+
+def test_jit_artifact_rejects_direct_translation(tmp_path: Path) -> None:
+    adapter = _jit_adapter(direct_translation=True)
+    with pytest.raises(NativeEvaluationError, match="cannot be persisted"):
+        adapter.artifact_manifest(tmp_path)
+
+
+def test_chunked_evaluator_aggregates_primary_capabilities(tmp_path: Path) -> None:
+    manifest = _ChunkedSymbolicaEvaluator(
+        (_jit_adapter(), _jit_adapter())
+    ).artifact_manifest(tmp_path)
+
+    assert manifest["required_runtime_capabilities"] == [SYMJIT_F64_RUNTIME_CAPABILITY]
+    assert manifest["input_len"] == 3
+    assert manifest["chunk_input_indices"] == [[0, 1, 2], [0, 1, 2]]
+    assert evaluator_runtime_capabilities(manifest) == (SYMJIT_F64_RUNTIME_CAPABILITY,)
+    serialized = _evaluator(manifest)
+    assert serialized["input_len"] == 3
+    assert serialized["chunk_input_indices"] == [[0, 1, 2], [0, 1, 2]]
+
+
+def test_chunked_evaluator_selects_parent_inputs_per_chunk() -> None:
+    evaluator = _ChunkedSymbolicaEvaluator(
+        (_MappedEvaluator(2), _MappedEvaluator(1)),
+        input_len=3,
+        chunk_input_indices=((0, 2), (1,)),
+    )
+
+    values = evaluator.evaluate_complex(
+        np.asarray([[1.0, 10.0, 3.0], [2.0, 20.0, 5.0]], dtype=np.complex128)
+    )
+
+    assert values.tolist() == [[4.0 + 0.0j, 10.0 + 0.0j], [7.0 + 0.0j, 20.0 + 0.0j]]
+
+
+def test_symbolica_chunk_dependencies_preserve_parent_parameter_order() -> None:
+    from symbolica import S
+
+    x, y, z, closed, argument = S("chunk_x", "chunk_y", "chunk_z", "closed", "arg")
+    function = S("chunk_function")
+
+    assert _chunk_parameter_indices(
+        (z + function(x),),
+        (x, y, z, closed),
+        functions={(function, (argument,)): argument + closed},
+    ) == (0, 2, 3)
+
+
+def test_compiled_capability_distinguishes_cpp_and_asm() -> None:
+    assert _compiled_runtime_capability({"compiled_inline_asm": "none"}) == (
+        SYMBOLICA_CPP_RUNTIME_CAPABILITY
+    )
+    assert _compiled_runtime_capability({"compiled_inline_asm": "default"}) == (
+        SYMBOLICA_ASM_RUNTIME_CAPABILITY
+    )
+
+
+def test_cpp_adapter_supplies_nested_complex_literal_compatibility_header(
+    tmp_path: Path,
+) -> None:
+    evaluator = _FakeCompiledEvaluator()
+    settings = SymbolicaEvaluatorSettings(
+        backend="compiled-complex",
+        compiled_inline_asm="none",
+        compiled_output_dir=str(tmp_path),
+    )
+
+    _CompiledComplexEvaluatorAdapter(
+        evaluator,
+        settings,
+        "cpp literal",
+        input_len=1,
+        output_len=1,
+    )
+
+    assert evaluator.compile_kwargs is not None
+    assert evaluator.compile_kwargs["compiler_flags"] == ("-std=c++17",)
+    assert evaluator.compile_kwargs["custom_header"] == (
+        _compiled_complex_custom_header(settings)
+    )
+    assert "pyamplicol_complex_literal" in str(
+        evaluator.compile_kwargs["custom_header"]
+    )
+
+
+def test_asm_adapter_does_not_use_cpp_literal_compatibility_header(
+    tmp_path: Path,
+) -> None:
+    evaluator = _FakeCompiledEvaluator()
+    settings = SymbolicaEvaluatorSettings(
+        backend="compiled-complex",
+        compiled_inline_asm="default",
+        compiled_output_dir=str(tmp_path),
+    )
+
+    _CompiledComplexEvaluatorAdapter(
+        evaluator,
+        settings,
+        "asm literal",
+        input_len=1,
+        output_len=1,
+    )
+
+    assert evaluator.compile_kwargs is not None
+    assert evaluator.compile_kwargs["compiler_flags"] == ("-std=c++17",)
+    assert "custom_header" not in evaluator.compile_kwargs
+
+
+def test_cpp_literal_compatibility_header_executes_nested_constructors(
+    tmp_path: Path,
+) -> None:
+    compiler = shutil.which("c++") or shutil.which("g++")
+    if compiler is None:
+        pytest.skip("a C++ compiler is required for the compatibility smoke")
+    settings = SymbolicaEvaluatorSettings(
+        backend="compiled-complex",
+        compiled_inline_asm="none",
+    )
+    header = _compiled_complex_custom_header(settings)
+    assert header is not None
+    source = tmp_path / "nested-complex.cpp"
+    executable = tmp_path / "nested-complex"
+    source.write_text(
+        f"""
+#include <cmath>
+#include <complex>
+{header}
+
+template<typename T>
+T evaluate(T value) {{
+    return value * T(T(5e-1), T(1e0));
+}}
+
+int main() {{
+    const auto result = evaluate(std::complex<double>(2.0, 3.0));
+    return std::abs(result.real() + 2.0) < 1e-15
+        && std::abs(result.imag() - 3.5) < 1e-15 ? 0 : 1;
+}}
+""",
+        encoding="utf-8",
+    )
+
+    subprocess.run(
+        [compiler, "-std=c++17", str(source), "-o", str(executable)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    subprocess.run([str(executable)], check=True)
+
+
+def test_artifact_writer_preserves_direct_symjit_contract(tmp_path: Path) -> None:
+    generated = _jit_adapter().artifact_manifest(tmp_path)
+    serialized = _evaluator(generated)
+
+    assert set(serialized) == {
+        "application_abi",
+        "application_path",
+        "batch_layout",
+        "compiler_type",
+        "element_layout",
+        "endianness",
+        "evaluator_state_path",
+        "evaluator_state_runtime_capability",
+        "input_len",
+        "kind",
+        "optimization_level",
+        "output_len",
+        "plane_application",
+        "required_defuns",
+        "runtime_capability",
+        "translation_mode",
+        "word_bits",
+    }
+    assert serialized["application_path"] == generated["application_path"]
+    assert serialized["runtime_capability"] == SYMJIT_F64_RUNTIME_CAPABILITY
+
+
+def test_stage_manifest_rejects_jit_payload_without_direct_arena(
+    tmp_path: Path,
+) -> None:
+    generated = _jit_adapter().artifact_manifest(tmp_path)
+    amplitude_stage = {
+        "stage_index": 0,
+        "stage_kind": "amplitude",
+        "subset_size": None,
+        "evaluator_label": "amplitude",
+        "parameter_layout": "stage-local-value-momentum",
+        "output_length": 2,
+        "output_slots": [],
+        "input_value_slot_ids": [],
+        "output_value_slot_ids": [],
+        "interaction_ids": [],
+        "input_components": [],
+        "parameter_count": 3,
+        "value_parameter_count": 0,
+        "momentum_parameter_count": 3,
+        "model_parameter_count": 0,
+        "real_valued_inputs": [0, 1, 2],
+        "expression_ready": True,
+        "blockers": [],
+        "evaluator": generated,
+    }
+    stage_set = {
+        "kind": "generic-dag-stage-evaluator-artifacts",
+        "runtime_available": True,
+        "runtime_unavailable_message": None,
+        "parameter_count": 0,
+        "value_parameter_count": 0,
+        "momentum_parameter_count": 0,
+        "model_parameter_count": 0,
+        "real_valued_inputs": [],
+        "parameter_layout": "stage-local-value-momentum",
+        "stage_count": 1,
+        "required_runtime_capabilities": [SYMJIT_F64_RUNTIME_CAPABILITY],
+        "stages": [],
+        "amplitude_stage": amplitude_stage,
+    }
+
+    with pytest.raises(ValueError, match="compiled f64 artifacts require"):
+        _stage_evaluator_set(stage_set)
+
+
+def test_symjit_application_abi_matches_contributor_contract() -> None:
+    lock = tomllib.loads(
+        (ROOT / "dependencies" / "contributor-lock.toml").read_text(encoding="utf-8")
+    )
+    assert lock["abis"]["symjit_application"] == SYMJIT_APPLICATION_ABI
diff --git a/pyamplicol/tests/unit/test_evaluator_container.py b/pyamplicol/tests/unit/test_evaluator_container.py
new file mode 100644
index 0000000000..97c4cd8644
--- /dev/null
+++ b/pyamplicol/tests/unit/test_evaluator_container.py
@@ -0,0 +1,703 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import io
+import stat
+import struct
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.generation import evaluator_container as pacbin
+from pyamplicol.generation.evaluator_container import (
+    PACBIN_ALIGNMENT,
+    PACBIN_VERSION,
+    PacbinError,
+    PacbinMemberKind,
+    PacbinMemberSource,
+    PacbinReader,
+    normalize_logical_path,
+    write_pacbin,
+    write_pacbin_atomic,
+)
+
+
+class _BoundedSource(io.BytesIO):
+    def __init__(self, payload: bytes, maximum_read: int) -> None:
+        super().__init__(payload)
+        self.maximum_read = maximum_read
+        self.read_sizes: list[int] = []
+
+    def read(self, size: int = -1) -> bytes:
+        if size < 0 or size > self.maximum_read:
+            raise AssertionError(f"unbounded source read: {size}")
+        self.read_sizes.append(size)
+        return super().read(size)
+
+
+class _NonSeekable(io.BytesIO):
+    def seekable(self) -> bool:
+        return False
+
+
+class _ShortWrite(io.BytesIO):
+    def write(self, payload: bytes | bytearray | memoryview) -> int:
+        return super().write(payload[:3])
+
+
+class _StalledWrite(io.BytesIO):
+    def write(self, payload: bytes | bytearray | memoryview) -> int:
+        del payload
+        return 0
+
+
+class _OversizedRead(io.BytesIO):
+    def read(self, size: int = -1) -> bytes:
+        return super().read(size + 1 if size >= 0 else size)
+
+
+class _FailingSource(io.BytesIO):
+    def __init__(self) -> None:
+        super().__init__(b"partial")
+        self._failed = False
+
+    def read(self, size: int = -1) -> bytes:
+        if self._failed:
+            raise RuntimeError("injected source failure")
+        self._failed = True
+        return super().read(size)
+
+
+def _sources(payload: bytes) -> tuple[PacbinMemberSource, ...]:
+    return (
+        PacbinMemberSource(
+            "z/native/library.so",
+            PacbinMemberKind.NATIVE_LIBRARY,
+            io.BytesIO(b"native"),
+        ),
+        PacbinMemberSource(
+            "a//jit/./application.symjit",
+            PacbinMemberKind.SYMJIT_APPLICATION,
+            io.BytesIO(payload),
+        ),
+        PacbinMemberSource(
+            "m/exact/state.bin",
+            PacbinMemberKind.SYMBOLICA_EXACT_STATE,
+            io.BytesIO(b"exact-state"),
+        ),
+    )
+
+
+def _container_bytes(payload: bytes = b"symjit-payload") -> bytes:
+    destination = io.BytesIO()
+    write_pacbin(destination, _sources(payload), chunk_size=4)
+    return destination.getvalue()
+
+
+def _index_entry_offsets(data: bytes | bytearray) -> list[int]:
+    header = pacbin._HEADER_STRUCT.unpack_from(data, 0)
+    index_offset = header[6]
+    index_header = pacbin._INDEX_HEADER_STRUCT.unpack_from(data, index_offset)
+    count = index_header[4]
+    cursor = index_offset + pacbin._INDEX_HEADER_STRUCT.size
+    offsets: list[int] = []
+    for _ in range(count):
+        offsets.append(cursor)
+        path_length = pacbin._INDEX_ENTRY_STRUCT.unpack_from(data, cursor)[0]
+        record_length = pacbin._INDEX_ENTRY_STRUCT.size + path_length
+        cursor += record_length + (-record_length) % pacbin._INDEX_ALIGNMENT
+    return offsets
+
+
+def _rewrite_index_digest(data: bytearray) -> None:
+    index_offset = pacbin._HEADER_STRUCT.unpack_from(data, 0)[6]
+    footer_offset = len(data) - pacbin._FOOTER_STRUCT.size
+    digest = hashlib.sha256(data[index_offset:footer_offset]).digest()
+    footer = list(pacbin._FOOTER_STRUCT.unpack_from(data, footer_offset))
+    footer[-1] = digest
+    pacbin._FOOTER_STRUCT.pack_into(data, footer_offset, *footer)
+
+
+def _mutated_container(
+    mutation: Callable[[bytearray], None],
+    *,
+    rewrite_index_digest: bool = False,
+) -> io.BytesIO:
+    data = bytearray(_container_bytes())
+    mutation(data)
+    if rewrite_index_digest:
+        _rewrite_index_digest(data)
+    return io.BytesIO(data)
+
+
+def test_pacbin_round_trip_is_deterministic_and_aligned(tmp_path: Path) -> None:
+    payload = bytes(range(251)) * 17
+    source_path = tmp_path / "native.so"
+    source_path.write_bytes(b"native")
+    first_members = (
+        PacbinMemberSource(
+            "z/native/library.so", PacbinMemberKind.NATIVE_LIBRARY, source_path
+        ),
+        PacbinMemberSource(
+            "a//jit/./application.symjit",
+            PacbinMemberKind.SYMJIT_APPLICATION,
+            _BoundedSource(payload, 113),
+        ),
+        PacbinMemberSource(
+            "m/exact/state.bin",
+            PacbinMemberKind.SYMBOLICA_EXACT_STATE,
+            io.BytesIO(b"exact-state"),
+        ),
+    )
+    first = io.BytesIO()
+    written = write_pacbin(first, first_members, chunk_size=113)
+    assert first_members[1].source.read_sizes
+    assert max(first_members[1].source.read_sizes) <= 113
+
+    second = io.BytesIO()
+    write_pacbin(second, reversed(_sources(payload)), chunk_size=7)
+    assert first.getvalue() == second.getvalue()
+    assert written.version == PACBIN_VERSION
+    assert written.file_size == len(first.getvalue())
+    assert [member.logical_path for member in written.members] == [
+        "a/jit/application.symjit",
+        "m/exact/state.bin",
+        "z/native/library.so",
+    ]
+    assert all(member.offset % PACBIN_ALIGNMENT == 0 for member in written.members)
+
+    first.seek(0)
+    with PacbinReader.open(first) as reader:
+        assert reader.index == written
+        assert (
+            reader.read_member("a/./jit/application.symjit", offset=5, length=19)
+            == payload[5:24]
+        )
+        assert (
+            reader.member("m/exact/state.bin").sha256
+            == hashlib.sha256(b"exact-state").hexdigest()
+        )
+    assert not first.closed
+
+
+def test_runtime_plan_member_kinds_round_trip() -> None:
+    destination = io.BytesIO()
+    sources = tuple(
+        PacbinMemberSource(path, kind, io.BytesIO(kind.name.encode()))
+        for path, kind in (
+            ("eager/metadata.bin", PacbinMemberKind.EAGER_RUNTIME_METADATA),
+            ("eager/table.bin", PacbinMemberKind.EAGER_RUNTIME_TABLE),
+            ("recurrence/plan.bin", PacbinMemberKind.RECURRENCE_DIRECT_PLAN),
+            (
+                "recurrence/projection.bin",
+                PacbinMemberKind.RECURRENCE_COLOR_PROJECTION_CERTIFICATE,
+            ),
+            (
+                "compiled/color.pacrclr3",
+                PacbinMemberKind.COLOR_CONTRACTION,
+            ),
+        )
+    )
+    write_pacbin(destination, sources)
+    destination.seek(0)
+    with PacbinReader.open(destination) as reader:
+        assert {member.kind for member in reader.members} == {
+            PacbinMemberKind.EAGER_RUNTIME_METADATA,
+            PacbinMemberKind.EAGER_RUNTIME_TABLE,
+            PacbinMemberKind.RECURRENCE_DIRECT_PLAN,
+            PacbinMemberKind.RECURRENCE_COLOR_PROJECTION_CERTIFICATE,
+            PacbinMemberKind.COLOR_CONTRACTION,
+        }
+
+
+def test_empty_and_zero_length_members_round_trip() -> None:
+    empty = io.BytesIO()
+    index = write_pacbin(empty, ())
+    assert index.members == ()
+    empty.seek(0)
+    with PacbinReader.open(empty) as reader:
+        assert reader.members == ()
+
+    zero = io.BytesIO()
+    write_pacbin(
+        zero,
+        (
+            PacbinMemberSource(
+                "a.empty", PacbinMemberKind.SYMBOLICA_EXACT_STATE, io.BytesIO()
+            ),
+            PacbinMemberSource(
+                "b.empty", PacbinMemberKind.SYMJIT_APPLICATION, io.BytesIO()
+            ),
+        ),
+    )
+    zero.seek(0)
+    with PacbinReader.open(zero) as reader:
+        assert [member.length for member in reader.members] == [0, 0]
+        assert reader.read_member("b.empty", length=0) == b""
+
+
+def test_member_stream_repackages_with_bounded_reads() -> None:
+    payload = bytes(range(251)) * 101
+    source = _BoundedSource(_container_bytes(payload), 1 << 20)
+    with PacbinReader.open(source, verify_payloads=False) as reader:
+        source.read_sizes.clear()
+        member_stream = reader.open_member_stream("a/jit/application.symjit")
+        destination = io.BytesIO()
+        write_pacbin(
+            destination,
+            (
+                PacbinMemberSource(
+                    "repacked/application.symjit",
+                    PacbinMemberKind.SYMJIT_APPLICATION,
+                    member_stream,
+                ),
+            ),
+            chunk_size=17,
+        )
+        assert source.read_sizes
+        assert max(source.read_sizes) <= 17
+        with pytest.raises(PacbinError, match="bounded read size"):
+            reader.open_member_stream("a/jit/application.symjit").read()
+
+    destination.seek(0)
+    with PacbinReader.open(destination) as repacked:
+        assert (
+            repacked.read_member(
+                "repacked/application.symjit",
+                length=len(payload),
+            )
+            == payload
+        )
+
+
+@pytest.mark.parametrize(
+    ("value", "message"),
+    (
+        ("", "non-empty"),
+        (".", "name a member"),
+        ("/absolute", "relative"),
+        ("safe/../escape", "must not contain"),
+        ("windows\\path", "POSIX"),
+        ("bad\x00path", "NUL"),
+    ),
+)
+def test_logical_path_rejects_unsafe_values(value: str, message: str) -> None:
+    with pytest.raises(PacbinError, match=message):
+        normalize_logical_path(value)
+
+
+def test_logical_path_is_nfc_and_posix_normalized() -> None:
+    assert normalize_logical_path("a//./cafe\u0301/state") == "a/caf\u00e9/state"
+
+
+def test_writer_rejects_duplicate_case_collision_and_unknown_kind() -> None:
+    duplicate = PacbinMemberSource(
+        "same/path", PacbinMemberKind.SYMJIT_APPLICATION, io.BytesIO()
+    )
+    with pytest.raises(PacbinError, match="duplicate"):
+        write_pacbin(io.BytesIO(), (duplicate, duplicate))
+    with pytest.raises(PacbinError, match="case-colliding"):
+        write_pacbin(
+            io.BytesIO(),
+            (
+                PacbinMemberSource(
+                    "Case/path", PacbinMemberKind.SYMJIT_APPLICATION, io.BytesIO()
+                ),
+                PacbinMemberSource(
+                    "case/PATH", PacbinMemberKind.NATIVE_LIBRARY, io.BytesIO()
+                ),
+            ),
+        )
+    with pytest.raises(PacbinError, match="unknown pacbin member kind"):
+        PacbinMemberSource("member", 99, io.BytesIO())  # type: ignore[arg-type]
+
+
+def test_writer_requires_typed_members_and_seekable_destination() -> None:
+    with pytest.raises(TypeError, match="PacbinMemberSource"):
+        write_pacbin(io.BytesIO(), (("member", 1, io.BytesIO()),))  # type: ignore[arg-type]
+    with pytest.raises(PacbinError, match="seekable"):
+        write_pacbin(_NonSeekable(), ())
+
+
+def test_writer_handles_short_writes_and_rejects_stalled_writes() -> None:
+    destination = _ShortWrite()
+    written = write_pacbin(destination, _sources(b"payload"), chunk_size=3)
+    destination.seek(0)
+    with PacbinReader.open(destination) as reader:
+        assert reader.index == written
+
+    with pytest.raises(PacbinError, match="short write"):
+        write_pacbin(_StalledWrite(), ())
+
+
+def test_writer_rejects_source_that_exceeds_requested_chunk() -> None:
+    with pytest.raises(PacbinError, match="more bytes than requested"):
+        write_pacbin(
+            io.BytesIO(),
+            (
+                PacbinMemberSource(
+                    "payload.bin",
+                    PacbinMemberKind.SYMJIT_APPLICATION,
+                    _OversizedRead(b"abcdef"),
+                ),
+            ),
+            chunk_size=2,
+        )
+
+
+def test_writer_preflights_wire_bounds_before_truncation(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    destination = io.BytesIO(b"existing")
+    monkeypatch.setattr(pacbin, "_MAX_U32", 3)
+    with pytest.raises(PacbinError, match="path exceeds u32 byte length"):
+        write_pacbin(destination, _sources(b"payload"))
+    assert destination.getvalue() == b"existing"
+
+    monkeypatch.setattr(pacbin, "_MAX_U32", 2**32 - 1)
+    monkeypatch.setattr(pacbin, "_MAX_U64", 2)
+    with pytest.raises(PacbinError, match="member count exceeds u64"):
+        write_pacbin(destination, _sources(b"payload"))
+    assert destination.getvalue() == b"existing"
+
+    monkeypatch.setattr(
+        pacbin,
+        "_MAX_U64",
+        pacbin._INDEX_HEADER_STRUCT.size,
+    )
+    with pytest.raises(PacbinError, match="index size exceeds u64"):
+        write_pacbin(destination, _sources(b"payload"))
+    assert destination.getvalue() == b"existing"
+
+
+def test_atomic_publication_replaces_only_complete_container(tmp_path: Path) -> None:
+    destination = tmp_path / "evaluators.pacbin"
+    destination.write_bytes(b"previous-container")
+
+    with pytest.raises(RuntimeError, match="injected source failure"):
+        write_pacbin_atomic(
+            destination,
+            (
+                PacbinMemberSource(
+                    "payload.bin",
+                    PacbinMemberKind.SYMJIT_APPLICATION,
+                    _FailingSource(),
+                ),
+            ),
+            chunk_size=3,
+        )
+    assert destination.read_bytes() == b"previous-container"
+    assert list(tmp_path.glob(f".{destination.name}.*.tmp")) == []
+
+    index = write_pacbin_atomic(destination, _sources(b"published"), mode=0o640)
+    assert stat.S_IMODE(destination.stat().st_mode) == 0o640
+    with PacbinReader.open(destination) as reader:
+        assert reader.index == index
+        assert (
+            reader.read_member("a/jit/application.symjit", offset=0, length=9)
+            == b"published"
+        )
+    assert list(tmp_path.glob(f".{destination.name}.*.tmp")) == []
+
+
+@pytest.mark.parametrize("mode", (-1, 0o1000, True))
+def test_atomic_publication_rejects_invalid_mode(tmp_path: Path, mode: object) -> None:
+    with pytest.raises(PacbinError, match="publication mode"):
+        write_pacbin_atomic(
+            tmp_path / "evaluators.pacbin",
+            (),
+            mode=mode,  # type: ignore[arg-type]
+        )
+
+
+def test_reader_bounded_reads_and_close_contract() -> None:
+    stream = io.BytesIO(_container_bytes(b"abcdef"))
+    reader = PacbinReader.open(stream)
+    with pytest.raises(PacbinError, match="offset"):
+        reader.read_member("a/jit/application.symjit", offset=-1, length=1)
+    with pytest.raises(PacbinError, match="length"):
+        reader.read_member("a/jit/application.symjit", length=-1)
+    with pytest.raises(PacbinError, match="exceeds"):
+        reader.read_member("a/jit/application.symjit", offset=5, length=2)
+    reader.close()
+    with pytest.raises(ValueError, match="closed"):
+        reader.member("a/jit/application.symjit")
+
+
+@pytest.mark.parametrize(
+    ("field_index", "value", "message"),
+    (
+        (1, PACBIN_VERSION + 1, "header version"),
+        (2, 1, "header size"),
+        (3, 1, "header flags"),
+        (4, 32, "payload alignment"),
+    ),
+)
+def test_reader_rejects_unknown_header_contract(
+    field_index: int, value: int, message: str
+) -> None:
+    def mutate(data: bytearray) -> None:
+        header = list(pacbin._HEADER_STRUCT.unpack_from(data, 0))
+        header[field_index] = value
+        pacbin._HEADER_STRUCT.pack_into(data, 0, *header)
+
+    with pytest.raises(PacbinError, match=message):
+        PacbinReader.open(_mutated_container(mutate))
+
+
+@pytest.mark.parametrize(
+    ("location", "message"),
+    (
+        ("header", "header magic"),
+        ("index", "index magic"),
+        ("footer", "footer magic"),
+    ),
+)
+def test_reader_rejects_invalid_magic(location: str, message: str) -> None:
+    def mutate(data: bytearray) -> None:
+        if location == "header":
+            offset = 0
+        elif location == "index":
+            offset = pacbin._HEADER_STRUCT.unpack_from(data, 0)[6]
+        else:
+            offset = len(data) - pacbin._FOOTER_STRUCT.size
+        data[offset : offset + 8] = b"INVALID!"
+
+    with pytest.raises(PacbinError, match=message):
+        PacbinReader.open(
+            _mutated_container(
+                mutate,
+                rewrite_index_digest=location == "index",
+            )
+        )
+
+
+def test_reader_rejects_nonzero_header_reserved_fields() -> None:
+    def reserved_integer(data: bytearray) -> None:
+        header = list(pacbin._HEADER_STRUCT.unpack_from(data, 0))
+        header[5] = 1
+        pacbin._HEADER_STRUCT.pack_into(data, 0, *header)
+
+    with pytest.raises(PacbinError, match="reserved fields"):
+        PacbinReader.open(_mutated_container(reserved_integer))
+
+    def reserved_bytes(data: bytearray) -> None:
+        header = list(pacbin._HEADER_STRUCT.unpack_from(data, 0))
+        header[8] = b"\x00" * 23 + b"\x01"
+        pacbin._HEADER_STRUCT.pack_into(data, 0, *header)
+
+    with pytest.raises(PacbinError, match="reserved fields"):
+        PacbinReader.open(_mutated_container(reserved_bytes))
+
+
+@pytest.mark.parametrize(
+    ("field_index", "value", "message"),
+    (
+        (1, PACBIN_VERSION + 1, "footer version"),
+        (2, 1, "footer size"),
+        (3, 1, "footer flags"),
+        (4, 0, "offset disagrees"),
+        (5, 99, "count disagrees"),
+    ),
+)
+def test_reader_rejects_unknown_footer_contract(
+    field_index: int, value: int, message: str
+) -> None:
+    def mutate(data: bytearray) -> None:
+        offset = len(data) - pacbin._FOOTER_STRUCT.size
+        footer = list(pacbin._FOOTER_STRUCT.unpack_from(data, offset))
+        footer[field_index] = value
+        pacbin._FOOTER_STRUCT.pack_into(data, offset, *footer)
+
+    with pytest.raises(PacbinError, match=message):
+        PacbinReader.open(_mutated_container(mutate))
+
+
+@pytest.mark.parametrize(
+    ("field_index", "value", "message"),
+    (
+        (1, PACBIN_VERSION + 1, "index version"),
+        (2, 1, "index size"),
+        (3, 1, "index flags"),
+        (5, 1, "reserved"),
+    ),
+)
+def test_reader_rejects_unknown_index_contract(
+    field_index: int, value: int, message: str
+) -> None:
+    def mutate(data: bytearray) -> None:
+        offset = pacbin._HEADER_STRUCT.unpack_from(data, 0)[6]
+        header = list(pacbin._INDEX_HEADER_STRUCT.unpack_from(data, offset))
+        header[field_index] = value
+        pacbin._INDEX_HEADER_STRUCT.pack_into(data, offset, *header)
+
+    with pytest.raises(PacbinError, match=message):
+        PacbinReader.open(_mutated_container(mutate, rewrite_index_digest=True))
+
+
+@pytest.mark.parametrize(
+    ("field_offset", "format_string", "value", "message"),
+    (
+        (4, "<H", 99, "member kind"),
+        (6, "<H", 1, "member flags"),
+    ),
+)
+def test_reader_rejects_unknown_member_contract(
+    field_offset: int, format_string: str, value: int, message: str
+) -> None:
+    def mutate(data: bytearray) -> None:
+        entry = _index_entry_offsets(data)[0]
+        struct.pack_into(format_string, data, entry + field_offset, value)
+
+    with pytest.raises(PacbinError, match=message):
+        PacbinReader.open(_mutated_container(mutate, rewrite_index_digest=True))
+
+
+def test_reader_rejects_noncanonical_and_case_colliding_paths() -> None:
+    def traversal(data: bytearray) -> None:
+        entry = _index_entry_offsets(data)[0]
+        path_offset = entry + pacbin._INDEX_ENTRY_STRUCT.size
+        original_length = pacbin._INDEX_ENTRY_STRUCT.unpack_from(data, entry)[0]
+        replacement = b"../escape//member.symjit"
+        assert len(replacement) == original_length
+        data[path_offset : path_offset + original_length] = replacement
+
+    with pytest.raises(PacbinError, match="must not contain"):
+        PacbinReader.open(_mutated_container(traversal, rewrite_index_digest=True))
+
+    case_container = io.BytesIO()
+    write_pacbin(
+        case_container,
+        (
+            PacbinMemberSource(
+                "case/A.bin", PacbinMemberKind.SYMJIT_APPLICATION, io.BytesIO()
+            ),
+            PacbinMemberSource(
+                "case/B.bin", PacbinMemberKind.NATIVE_LIBRARY, io.BytesIO()
+            ),
+        ),
+    )
+    case_data = bytearray(case_container.getvalue())
+
+    def collision(data: bytearray) -> None:
+        first, second = _index_entry_offsets(data)
+        first_length = pacbin._INDEX_ENTRY_STRUCT.unpack_from(data, first)[0]
+        second_length = pacbin._INDEX_ENTRY_STRUCT.unpack_from(data, second)[0]
+        assert first_length == second_length
+        first_path = bytes(
+            data[
+                first + pacbin._INDEX_ENTRY_STRUCT.size : first
+                + pacbin._INDEX_ENTRY_STRUCT.size
+                + first_length
+            ]
+        )
+        replacement = first_path.replace(b"A", b"a", 1)
+        data[
+            second + pacbin._INDEX_ENTRY_STRUCT.size : second
+            + pacbin._INDEX_ENTRY_STRUCT.size
+            + second_length
+        ] = replacement
+
+    collision(case_data)
+    _rewrite_index_digest(case_data)
+    with pytest.raises(PacbinError, match="case-colliding"):
+        PacbinReader.open(io.BytesIO(case_data))
+
+
+def test_reader_rejects_duplicate_and_unsorted_keys() -> None:
+    container = io.BytesIO()
+    write_pacbin(
+        container,
+        (
+            PacbinMemberSource(
+                "case/A.bin", PacbinMemberKind.SYMJIT_APPLICATION, io.BytesIO()
+            ),
+            PacbinMemberSource(
+                "case/B.bin", PacbinMemberKind.NATIVE_LIBRARY, io.BytesIO()
+            ),
+        ),
+    )
+
+    duplicate = bytearray(container.getvalue())
+    first, second = _index_entry_offsets(duplicate)
+    path_length = pacbin._INDEX_ENTRY_STRUCT.unpack_from(duplicate, first)[0]
+    first_path_start = first + pacbin._INDEX_ENTRY_STRUCT.size
+    second_path_start = second + pacbin._INDEX_ENTRY_STRUCT.size
+    duplicate[second_path_start : second_path_start + path_length] = duplicate[
+        first_path_start : first_path_start + path_length
+    ]
+    _rewrite_index_digest(duplicate)
+    with pytest.raises(PacbinError, match="duplicate"):
+        PacbinReader.open(io.BytesIO(duplicate))
+
+    unsorted = bytearray(container.getvalue())
+    first, second = _index_entry_offsets(unsorted)
+    first_path_start = first + pacbin._INDEX_ENTRY_STRUCT.size
+    second_path_start = second + pacbin._INDEX_ENTRY_STRUCT.size
+    first_path = bytes(unsorted[first_path_start : first_path_start + path_length])
+    second_path = bytes(unsorted[second_path_start : second_path_start + path_length])
+    unsorted[first_path_start : first_path_start + path_length] = second_path
+    unsorted[second_path_start : second_path_start + path_length] = first_path
+    _rewrite_index_digest(unsorted)
+    with pytest.raises(PacbinError, match="strictly sorted"):
+        PacbinReader.open(io.BytesIO(unsorted))
+
+
+def test_reader_rejects_overlap_out_of_bounds_and_nonzero_padding() -> None:
+    def overlap(data: bytearray) -> None:
+        first, second, _third = _index_entry_offsets(data)
+        first_offset = pacbin._INDEX_ENTRY_STRUCT.unpack_from(data, first)[3]
+        struct.pack_into("<Q", data, second + 8, first_offset)
+
+    with pytest.raises(PacbinError, match="overlapping"):
+        PacbinReader.open(_mutated_container(overlap, rewrite_index_digest=True))
+
+    def out_of_bounds(data: bytearray) -> None:
+        first = _index_entry_offsets(data)[0]
+        index_offset = pacbin._HEADER_STRUCT.unpack_from(data, 0)[6]
+        struct.pack_into("<Q", data, first + 16, index_offset)
+
+    with pytest.raises(PacbinError, match="out of bounds"):
+        PacbinReader.open(_mutated_container(out_of_bounds, rewrite_index_digest=True))
+
+    def nonzero_payload_padding(data: bytearray) -> None:
+        first, second, _third = _index_entry_offsets(data)
+        first_record = pacbin._INDEX_ENTRY_STRUCT.unpack_from(data, first)
+        second_record = pacbin._INDEX_ENTRY_STRUCT.unpack_from(data, second)
+        padding_start = first_record[3] + first_record[4]
+        assert padding_start < second_record[3]
+        data[padding_start] = 1
+
+    with pytest.raises(PacbinError, match="payload padding"):
+        PacbinReader.open(_mutated_container(nonzero_payload_padding))
+
+
+def test_reader_rejects_u64_member_range_overflow() -> None:
+    def overflow(data: bytearray) -> None:
+        first = _index_entry_offsets(data)[0]
+        struct.pack_into("<Q", data, first + 16, pacbin._MAX_U64)
+
+    with pytest.raises(PacbinError, match="overflows u64"):
+        PacbinReader.open(_mutated_container(overflow, rewrite_index_digest=True))
+
+
+def test_reader_rejects_digest_corruption_and_truncation() -> None:
+    def corrupt_payload(data: bytearray) -> None:
+        first = _index_entry_offsets(data)[0]
+        payload_offset = pacbin._INDEX_ENTRY_STRUCT.unpack_from(data, first)[3]
+        data[payload_offset] ^= 1
+
+    with pytest.raises(PacbinError, match="member digest mismatch"):
+        PacbinReader.open(_mutated_container(corrupt_payload))
+
+    def corrupt_index_digest(data: bytearray) -> None:
+        data[-1] ^= 1
+
+    with pytest.raises(PacbinError, match="index digest mismatch"):
+        PacbinReader.open(_mutated_container(corrupt_index_digest))
+
+    truncated = _container_bytes()[:-17]
+    with pytest.raises(PacbinError, match=r"footer|truncated"):
+        PacbinReader.open(io.BytesIO(truncated))
diff --git a/pyamplicol/tests/unit/test_evaluator_defaults.py b/pyamplicol/tests/unit/test_evaluator_defaults.py
new file mode 100644
index 0000000000..60614c530a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_evaluator_defaults.py
@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import subprocess
+import sys
+
+import pytest
+
+from pyamplicol.evaluators import SymbolicaEvaluatorSettings
+from pyamplicol.evaluators.symbolica_compile import _symbolica_evaluator_kwargs
+
+
+def test_evaluator_defaults_preserve_production_optimization_policy() -> None:
+    settings = SymbolicaEvaluatorSettings()
+    assert settings.backend == "jit"
+    assert settings.iterations == 10
+    assert settings.cpe_iterations is None
+    assert settings.jit_optimization_level == 2
+    assert settings.jit_compress is False
+    assert settings.jit_direct_translation is False
+    assert settings.max_horner_scheme_variables == 1000
+    assert settings.max_common_pair_cache_entries == 5_000_000
+    assert settings.max_common_pair_distance == 1000
+
+
+@pytest.mark.parametrize(
+    ("compress", "jit_options"),
+    ((True, {"compress": "true"}), (False, {"compress": "false"})),
+)
+def test_jit_compression_is_forwarded_to_symbolica(
+    compress: bool,
+    jit_options: dict[str, str],
+) -> None:
+    settings = SymbolicaEvaluatorSettings(jit_compress=compress)
+
+    assert settings.to_json_dict()["jit_compress"] is compress
+    assert (
+        _symbolica_evaluator_kwargs(
+            settings,
+            verbose=False,
+        )["jit_options"]
+        == jit_options
+    )
+
+
+def test_jit_compression_setting_requires_a_boolean() -> None:
+    with pytest.raises(ValueError, match="jit_compress"):
+        SymbolicaEvaluatorSettings(jit_compress=1)  # type: ignore[arg-type]
+
+
+def test_evaluator_module_import_registers_symbolica_without_model_tooling() -> None:
+    code = """
+import sys
+assert 'symbolica' not in sys.modules
+from pyamplicol.evaluators import SymbolicaEvaluatorSettings
+SymbolicaEvaluatorSettings()
+assert 'symbolica' in sys.modules
+assert 'pyamplicol.models.compiler_symbolica' not in sys.modules
+    """
+    subprocess.run([sys.executable, "-c", code], check=True)
+
+
+def test_removed_simd_backend_is_rejected() -> None:
+    with pytest.raises(ValueError, match="compiled-complex"):
+        SymbolicaEvaluatorSettings(backend="compiled-complex-4x")
+
+
+def test_compiled_flags_do_not_probe_checkout_dependencies() -> None:
+    settings = SymbolicaEvaluatorSettings(
+        backend="compiled-complex",
+        compiler_flags=("-DPYAMPLICOL_TEST_FLAG=1",),
+    )
+
+    payload = settings.to_json_dict()
+    assert payload["compiler_flags"] == ["-DPYAMPLICOL_TEST_FLAG=1"]
+    assert payload["effective_compiler_flags"] == [
+        "-std=c++17",
+        "-DPYAMPLICOL_TEST_FLAG=1",
+    ]
+
+    jit_payload = SymbolicaEvaluatorSettings(
+        backend="jit",
+        compiler_flags=("-DPYAMPLICOL_TEST_FLAG=1",),
+    ).to_json_dict()
+    assert jit_payload["effective_compiler_flags"] == ["-DPYAMPLICOL_TEST_FLAG=1"]
diff --git a/pyamplicol/tests/unit/test_exact_color_weight.py b/pyamplicol/tests/unit/test_exact_color_weight.py
new file mode 100644
index 0000000000..7db1e38dfa
--- /dev/null
+++ b/pyamplicol/tests/unit/test_exact_color_weight.py
@@ -0,0 +1,105 @@
+# SPDX-License-Identifier: 0BSD
+"""Colour coefficients must not impose a binary64 floor on exact evaluation."""
+
+from decimal import Decimal, localcontext
+from fractions import Fraction
+
+import pytest
+
+from pyamplicol.api.errors import ArtifactError
+from pyamplicol.color import (
+    ColorGroupDescriptor,
+    build_color_contraction_plan,
+    build_color_plan,
+)
+from pyamplicol.color.contraction_factors import exact_color_contraction_factor
+from pyamplicol.generation.artifact_writer import _color_contraction
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.runtime._color_topology_exact import (
+    _parse_expanded_entry,
+    _parse_repeated_contraction,
+)
+from pyamplicol.runtime._color_weight_exact import exact_color_weight
+from pyamplicol.runtime.symbolica_exact import _validated_color_contraction_entries
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+@pytest.mark.parametrize("components", (1, 2))
+def test_generated_colour_weights_retain_their_rational_source(accuracy, components):
+    plan = build_color_plan(
+        build_process_ir("g g > g g", color_accuracy=accuracy),
+        color_accuracy=accuracy,
+    )
+    sectors = plan.sectors[:2]
+    groups = tuple(
+        ColorGroupDescriptor(
+            group_id=2 * component + index,
+            helicity_key=(component,),
+            sector_id=sector.id,
+            word=tuple(sector.word_labels or sector.color_words[0]),
+            helicity_weight=2.0,
+        )
+        for component in range(components)
+        for index, sector in enumerate(sectors)
+    )
+    contraction = build_color_contraction_plan(plan, groups)
+    assert contraction is not None
+    by_group = {
+        group.group_id: sectors[index % 2] for index, group in enumerate(groups)
+    }
+    for entry in contraction.iter_logical_entries():
+        expected = 2 * exact_color_contraction_factor(
+            plan,
+            by_group[entry.left_group_id],
+            by_group[entry.right_group_id],
+            accuracy=accuracy,
+        )
+        assert entry.exact_weight == (expected, Fraction(0))
+        assert entry.weight_re == float(expected)
+    compact = _color_contraction(contraction.to_json_dict())
+    entries = (
+        compact["entries"] if components == 1 else compact["repeated_block"]["entries"]
+    )
+    assert entries and all("exact_weight" in entry for entry in entries)
+
+
+def test_expanded_and_repeated_exact_readers_do_not_upcast_f64_colour_weights():
+    weight = {
+        "weight": [1 / 3, -2 / 7],
+        "exact_weight": ["1", "3", "-2", "7"],
+        "symmetry_factor": 1.0,
+    }
+    expanded = {
+        "group_count": 2,
+        "entries": [dict(weight, left_group_id=i, right_group_id=i) for i in range(2)],
+    }
+    repeated = {
+        "group_count": 2,
+        "entries": [],
+        "repeated_block": {
+            "component_count": 2,
+            "component_group_ids": [0, 1],
+            "entries": [dict(weight, left_group_index=0, right_group_index=0)],
+        },
+    }
+    with localcontext() as context:
+        context.prec = 80
+        expected = Decimal(1) / 3, -Decimal(2) / 7
+        for contraction in (expanded, repeated):
+            entries = tuple(
+                _validated_color_contraction_entries(contraction, {0: None, 1: None})
+            )
+            assert [entry.weight for entry in entries] == [expected, expected]
+        assert _parse_expanded_entry(expanded["entries"][0], 2).weight == expected
+        assert (
+            _parse_repeated_contraction(repeated["repeated_block"], 2).entries[0].weight
+            == expected
+        )
+
+
+@pytest.mark.parametrize(
+    "raw", (["1", "0", "0", "1"], ["1.5", "3", "0", "1"], [1, 3, 0, 1], ["1", "3"])
+)
+def test_exact_colour_weight_rejects_invalid_rational_payload(raw):
+    with pytest.raises(ArtifactError, match="exact colour weight"):
+        exact_color_weight({"exact_weight": raw})
diff --git a/pyamplicol/tests/unit/test_exact_evaluator_payloads.py b/pyamplicol/tests/unit/test_exact_evaluator_payloads.py
new file mode 100644
index 0000000000..d5a761bf8b
--- /dev/null
+++ b/pyamplicol/tests/unit/test_exact_evaluator_payloads.py
@@ -0,0 +1,247 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import io
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from typing import ClassVar
+
+import pytest
+
+from pyamplicol.api.errors import ArtifactError
+from pyamplicol.artifacts.manifest import ArtifactManifest, PayloadRecord
+from pyamplicol.artifacts.security import sha256_file
+from pyamplicol.generation.evaluator_container import (
+    PacbinMemberKind,
+    PacbinMemberSource,
+    write_pacbin_atomic,
+)
+from pyamplicol.models.prepared import PreparedKernelRecord
+from pyamplicol.runtime._evaluator_payloads import ExactEvaluatorPayloadResolver
+from pyamplicol.runtime.eager_exact._contracts import _artifact_kernel_loader
+from pyamplicol.runtime.symbolica_exact import _ExactEvaluator
+
+
+class _LoadedEvaluator:
+    def evaluate_complex_with_prec(
+        self, _values: object, _precision: int
+    ) -> tuple[tuple[int, int], ...]:
+        return ((0, 0),)
+
+
+class _EvaluatorFactory:
+    loaded: ClassVar[list[bytes]] = []
+
+    @classmethod
+    def load(cls, state: bytes) -> _LoadedEvaluator:
+        cls.loaded.append(state)
+        return _LoadedEvaluator()
+
+
+@pytest.fixture(autouse=True)
+def _fake_symbolica(monkeypatch: pytest.MonkeyPatch) -> None:
+    _EvaluatorFactory.loaded = []
+    monkeypatch.setitem(
+        sys.modules,
+        "symbolica",
+        SimpleNamespace(Evaluator=_EvaluatorFactory),
+    )
+
+
+def _payload_record(
+    root: Path,
+    relative: str,
+    *,
+    process_id: str | None,
+) -> PayloadRecord:
+    path = root / relative
+    return PayloadRecord(
+        path=relative,
+        role="evaluator-state",
+        media_type="application/octet-stream",
+        size_bytes=path.stat().st_size,
+        sha256=sha256_file(path),
+        executable=False,
+        target=None,
+        process_id=process_id,
+    )
+
+
+def _manifest(
+    root: Path,
+    payloads: tuple[PayloadRecord, ...],
+    *,
+    extension: dict[str, object] | None = None,
+) -> ArtifactManifest:
+    return ArtifactManifest(
+        root=root,
+        kind="pyamplicol-process",
+        artifact_id="0" * 64,
+        created_utc="2026-01-01T00:00:00Z",
+        producer={},
+        model={},
+        configuration={},
+        processes=(),
+        default_process_id=None,
+        runtime={},
+        payloads=payloads,
+        dependencies=(),
+        extensions=(
+            {}
+            if extension is None
+            else {"evaluator_payload_container": extension}
+        ),
+    )
+
+
+def _packed_manifest(
+    root: Path,
+    logical_path: str,
+    state: bytes,
+) -> ArtifactManifest:
+    root.mkdir()
+    container = root / "evaluators.pacbin"
+    index = write_pacbin_atomic(
+        container,
+        (
+            PacbinMemberSource(
+                logical_path,
+                PacbinMemberKind.SYMBOLICA_EXACT_STATE,
+                io.BytesIO(state),
+            ),
+        ),
+    )
+    extension = {
+        "kind": "pyamplicol-evaluator-payload-container",
+        "schema_version": 1,
+        "storage_abi": "pacbin-v1",
+        "path": "evaluators.pacbin",
+        "member_count": 1,
+        "unpacked_size_bytes": len(state),
+        "index_sha256": index.index_sha256,
+    }
+    return _manifest(
+        root,
+        (_payload_record(root, "evaluators.pacbin", process_id=None),),
+        extension=extension,
+    )
+
+
+def _loose_manifest(
+    root: Path,
+    logical_path: str,
+    state: bytes,
+    *,
+    process_id: str | None,
+) -> ArtifactManifest:
+    path = root / logical_path
+    path.parent.mkdir(parents=True)
+    path.write_bytes(state)
+    return _manifest(
+        root,
+        (_payload_record(root, logical_path, process_id=process_id),),
+    )
+
+
+@pytest.mark.parametrize("packed", [False, True])
+def test_compiled_exact_evaluator_loads_loose_and_packed_state(
+    tmp_path: Path,
+    packed: bool,
+) -> None:
+    state = b"compiled-exact-state"
+    logical = "processes/process/stage.evaluator.bin"
+    manifest = (
+        _packed_manifest(tmp_path / "artifact", logical, state)
+        if packed
+        else _loose_manifest(
+            tmp_path / "artifact",
+            logical,
+            state,
+            process_id="process",
+        )
+    )
+    resolver = ExactEvaluatorPayloadResolver(manifest)
+    evaluator = _ExactEvaluator.load(
+        {"evaluator_state_path": "stage.evaluator.bin", "input_len": 2},
+        manifest.root / "processes/process",
+        state_loader=lambda relative: resolver.read_exact_state(
+            f"processes/process/{relative}",
+            process_id="process",
+        ),
+    )
+
+    assert evaluator.input_len == 2
+    assert _EvaluatorFactory.loaded == [state]
+
+
+def test_packed_exact_state_enforces_process_path_ownership(tmp_path: Path) -> None:
+    manifest = _packed_manifest(
+        tmp_path / "artifact",
+        "processes/other/stage.evaluator.bin",
+        b"state",
+    )
+    resolver = ExactEvaluatorPayloadResolver(manifest)
+
+    with pytest.raises(ArtifactError, match="does not belong to process"):
+        resolver.require_exact_state(
+            "processes/other/stage.evaluator.bin",
+            process_id="requested",
+        )
+
+
+def _kernel() -> PreparedKernelRecord:
+    return PreparedKernelRecord(
+        kernel_id=7,
+        contract_kind="vertex",
+        canonical_signature="test:vertex",
+        input_arity=2,
+        output_arity=1,
+        input_layout=("left-current:0", "right-current:0"),
+        input_contracts=(
+            {
+                "role": "left-current",
+                "component": 0,
+                "symbol": "test::left-current::0",
+                "model_parameter_name": None,
+                "model_parameter_index": None,
+            },
+            {
+                "role": "right-current",
+                "component": 0,
+                "symbol": "test::right-current::0",
+                "model_parameter_name": None,
+                "model_parameter_index": None,
+            },
+        ),
+        output_layout=("scalar:0",),
+        exact_expressions=("out",),
+        exact_evaluator_state_path="kernels/000007/exact.evaluator.bin",
+        f64_evaluator_manifest={"kind": "test-evaluator"},
+    )
+
+
+@pytest.mark.parametrize("packed", [False, True])
+def test_eager_exact_kernel_loads_loose_and_packed_state(
+    tmp_path: Path,
+    packed: bool,
+) -> None:
+    state = b"eager-exact-state"
+    prefix = "model/eager-kernels"
+    logical = f"{prefix}/{_kernel().exact_evaluator_state_path}"
+    manifest = (
+        _packed_manifest(tmp_path / "artifact", logical, state)
+        if packed
+        else _loose_manifest(
+            tmp_path / "artifact",
+            logical,
+            state,
+            process_id=None,
+        )
+    )
+    resolver = ExactEvaluatorPayloadResolver(manifest)
+    loader = _artifact_kernel_loader(resolver, prefix)
+    evaluator = loader(_kernel(), manifest.root / prefix)
+
+    assert evaluator.input_len == 2
+    assert _EvaluatorFactory.loaded == [state]
diff --git a/pyamplicol/tests/unit/test_exact_parameter_precision.py b/pyamplicol/tests/unit/test_exact_parameter_precision.py
new file mode 100644
index 0000000000..74e0245b3a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_exact_parameter_precision.py
@@ -0,0 +1,181 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from decimal import Decimal, localcontext
+
+import pytest
+from symbolica import E
+
+from pyamplicol._internal.physics.symbols import symbols
+from pyamplicol.api.errors import ArtifactError
+from pyamplicol.models import compiler_symbolica
+from pyamplicol.models.compiler_records import (
+    _coupling,
+    _parameter,
+    _resolve_coupling_records,
+    _resolve_parameter_records,
+)
+from pyamplicol.models.prepared_catalog_builder import _candidate_from_payload
+from pyamplicol.runtime._normalization_exact import _pi, exact_normalization
+from pyamplicol.runtime.symbolica_exact import (
+    SymbolicaExactExecutor,
+    _ExactExpressionEvaluator,
+)
+
+
+def _resolved_qcd_definitions():
+    compiler_symbolica._ensure_symbolica()
+    registry = symbols.model("exact_parameter_test")
+    records = (
+        {
+            "name": "aS",
+            "nature": "external",
+            "parameter_type": "real",
+            "value": [0.125, 0],
+        },
+        {
+            "name": "G",
+            "nature": "internal",
+            "parameter_type": "real",
+            "expression": "sqrt(4*pi*UFO::aS)",
+        },
+    )
+    parameters = _resolve_parameter_records(
+        tuple(_parameter(record, model_symbols=registry) for record in records),
+        registry,
+    )
+    couplings = _resolve_coupling_records(
+        tuple(
+            _coupling({"name": name, "expression": expression}, model_symbols=registry)
+            for name, expression in (("cubic", "UFO::G"), ("quartic", "UFO::G^2"))
+        ),
+        parameters,
+        registry,
+    )
+    return registry, parameters, couplings
+
+
+@pytest.mark.parametrize("precision", (80, 1000))
+def test_parameter_derivation_keeps_pi_and_dependent_couplings_exact(precision):
+    registry, _, couplings = _resolved_qcd_definitions()
+    cubic, quartic = (E(record.resolved_expression) for record in couplings)
+    assert (cubic**2 - quartic).expand() == E("0")
+    assert E("pi") in quartic.get_all_symbols(False)
+    evaluator = _ExactExpressionEvaluator(
+        tuple(record.resolved_expression for record in couplings),
+        (registry.symbol("aS").to_canonical_string(),),
+    )
+    with localcontext() as context:
+        context.prec = precision
+        values = evaluator.evaluate(((Decimal("0.125"), Decimal(0)),), precision)
+        assert abs(values[0][0] ** 2 - values[1][0]) < Decimal(10) ** (-precision + 5)
+        assert abs(values[1][0] - _pi(precision) / 2) < Decimal(10) ** (-precision + 5)
+        assert abs(values[1][0] - Decimal("1.5707963267948966")) > Decimal("1e-18")
+
+
+def test_compiled_exact_executor_rederives_current_parameters_not_native_cache():
+    _registry, parameters, couplings = _resolved_qcd_definitions()
+    executor = object.__new__(SymbolicaExactExecutor)
+    executor._exact_compiled_model = {
+        "name": "exact_parameter_test",
+        "parameters": [
+            {
+                "name": record.name,
+                "nature": record.nature,
+                "resolved_expression": record.resolved_expression,
+            }
+            for record in parameters
+        ],
+        "vertex_terms": [
+            {"id": 7, "coupling_expression": couplings[1].resolved_expression}
+        ],
+    }
+    executor._execution = {
+        "runtime_schema": {
+            "model_parameters": [
+                {"name": "aS", "kind": "external_parameter", "parameter_index": 0},
+            ]
+        },
+        "compiled": {
+            "model_parameter_evaluator": {
+                "outputs": [
+                    {
+                        "runtime_name": "G",
+                        "real_parameter_index": 1,
+                        "imag_parameter_index": 2,
+                    },
+                    {
+                        "runtime_name": "derived_coupling_7",
+                        "real_parameter_index": 3,
+                        "imag_parameter_index": 4,
+                    },
+                ]
+            }
+        },
+    }
+    with localcontext() as context:
+        context.prec = 80
+        result = executor._derive_model_parameters(
+            (Decimal("0.25"), Decimal(999), Decimal(999), Decimal(999), Decimal(999)),
+            80,
+        )
+        assert result[0] == Decimal("0.25")
+        assert result[2] == result[4] == 0
+        assert abs(result[1] ** 2 - result[3]) < Decimal("1e-75")
+        assert abs(result[3] - _pi(80)) < Decimal("1e-75")
+
+
+@pytest.mark.parametrize("precision", (80, 1000))
+def test_real_born_normalization_uses_one_exact_current_coupling(precision):
+    schema = ({"name": "normalization.alpha_s_me_check", "parameter_index": 0},)
+    # Remove the public final-state symmetry factors exactly, as needed when
+    # comparing one local collinear limit with its lower-multiplicity Born ME.
+    real = {
+        "extensions": {
+            "normalization": {
+                "average_factor": 256,
+                "identical_factor": 24,
+                "color_factor": 729,
+                "qcd_coupling_power": 4,
+                "global_coupling_factor": 999,
+            }
+        }
+    }
+    born = {
+        "extensions": {
+            "normalization": {
+                "average_factor": 256,
+                "identical_factor": 6,
+                "color_factor": 243,
+                "qcd_coupling_power": 3,
+                "global_coupling_factor": 999,
+            }
+        }
+    }
+    with localcontext() as context:
+        context.prec = precision
+        n_real = exact_normalization(real, (Decimal("0.125"),), precision, schema)
+        n_born = exact_normalization(born, (Decimal("0.125"),), precision, schema)
+        ratio = n_real * 24 / (n_born * 6)
+        assert abs(ratio - _pi(precision) / 2) < Decimal(10) ** (-precision + 5)
+
+
+@pytest.mark.parametrize("accuracy,expected", (("lc", 81), ("nlc", 1), ("full", 1)))
+def test_exact_normalization_counts_color_metric_once(accuracy, expected):
+    physics = {
+        "color_accuracy": accuracy,
+        "extensions": {"normalization": {"color_factor": 81}},
+    }
+    assert exact_normalization(physics, (), 80) == expected
+
+
+def test_exact_normalization_does_not_silently_use_missing_metadata():
+    with pytest.raises(ArtifactError, match="metadata is absent"):
+        exact_normalization({}, (), 80)
+
+
+def test_prepared_contract_accepts_intrinsic_pi_without_a_runtime_input():
+    candidate = _candidate_from_payload(
+        "model-parameter", {}, ("pi",), (), ("constant",), proof_class=None
+    )
+    assert candidate.exact_expressions == ("pi",)
diff --git a/pyamplicol/tests/unit/test_exact_python_bootstrap.py b/pyamplicol/tests/unit/test_exact_python_bootstrap.py
new file mode 100644
index 0000000000..0a15e51e23
--- /dev/null
+++ b/pyamplicol/tests/unit/test_exact_python_bootstrap.py
@@ -0,0 +1,763 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import runpy
+import shutil
+import subprocess
+import sys
+import sysconfig
+from importlib.machinery import EXTENSION_SUFFIXES
+from pathlib import Path
+
+import pytest
+
+REPORT_ENTRYPOINT = Path("src/pyamplicol/_profiling_campaign/result_tables.py")
+
+
+def test_report_worker_bootstrap_recovers_repository_venv_under_no_site(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    script = Path(__file__).resolve().parents[2] / REPORT_ENTRYPOINT
+    repository = tmp_path / "repository"
+    venv = repository / ".venv"
+    executable = venv / "bin/python"
+    executable.parent.mkdir(parents=True)
+    # execve is intercepted below; only the measured venv's layout is needed.
+    executable.touch()
+    (venv / "pyvenv.cfg").write_text(
+        "include-system-site-packages = false\n", encoding="ascii"
+    )
+    variables = dict(sysconfig.get_config_vars())
+    for name in ("base", "platbase", "installed_base", "installed_platbase"):
+        variables[name] = str(venv)
+    for name in ("purelib", "platlib"):
+        (Path(sysconfig.get_path(name, vars=variables)) / "symbolica").mkdir(
+            parents=True, exist_ok=True
+        )
+    monkeypatch.setattr(sys, "executable", str(executable))
+    namespace = runpy.run_path(
+        str(script),
+        run_name="result_tables_worker_bootstrap_test",
+    )
+    bootstrap = namespace["_bootstrap_exact_python"]
+    globals_ = bootstrap.__globals__
+    globals_["COMMAND"] = "_prepare"
+    globals_["MEASUREMENT_SOURCE_ROOT"] = None
+    globals_["REPOSITORY_ROOT"] = repository
+    globals_["ENTRYPOINT"] = script
+    for name in (
+        "PYAMPLICOL_EXACT_PYTHON_REEXEC",
+        "PYAMPLICOL_EXACT_IMPORT_PATHS",
+        "PYTHONPYCACHEPREFIX",
+        "PYTHONDONTWRITEBYTECODE",
+    ):
+        monkeypatch.delenv(name, raising=False)
+
+    observed: dict[str, object] = {}
+
+    def capture_execve(
+        executable: str,
+        arguments: tuple[str, ...],
+        environment: dict[str, str],
+    ) -> None:
+        observed.update(
+            {
+                "executable": executable,
+                "arguments": arguments,
+                "environment": environment,
+            }
+        )
+        raise RuntimeError("captured exact worker re-exec")
+
+    monkeypatch.setattr(os, "execve", capture_execve)
+    with pytest.raises(RuntimeError, match="captured exact worker re-exec"):
+        bootstrap(["_prepare"])
+
+    environment = observed["environment"]
+    assert isinstance(environment, dict)
+    import_paths = json.loads(environment["PYAMPLICOL_EXACT_IMPORT_PATHS"])
+    assert import_paths
+    assert all(Path(path).is_relative_to(repository / ".venv") for path in import_paths)
+    assert any((Path(path) / "symbolica").is_dir() for path in import_paths)
+    assert observed["arguments"][:4] == (
+        sys.executable,
+        "-I",
+        "-S",
+        "-B",
+    )
+
+
+@pytest.mark.parametrize(
+    "script_relative",
+    (
+        REPORT_ENTRYPOINT,
+        Path("tools/developer/compiled_all_jit_arena_gate.py"),
+        Path("tools/developer/four_quark_compiled_gate.py"),
+    ),
+)
+def test_direct_entrypoint_imports_repo_code_only_after_isolated_reexec(
+    tmp_path: Path,
+    script_relative: Path,
+) -> None:
+    repository = Path(__file__).resolve().parents[2]
+    script = tmp_path / script_relative
+    script.parent.mkdir(parents=True)
+    shutil.copy2(repository / script_relative, script)
+
+    package = tmp_path / "tools" / "performance_report"
+    package.mkdir(parents=True, exist_ok=True)
+    if script_relative == REPORT_ENTRYPOINT:
+        (tmp_path / "src/pyamplicol").mkdir(parents=True, exist_ok=True)
+    sentinel = tmp_path / "repo-imports.txt"
+    (package / "runtime_evidence.py").write_text(
+        "\n".join(
+            (
+                "import os",
+                "import sys",
+                "from pathlib import Path",
+                "sentinel = Path(os.environ['PYAMPLICOL_BOOTSTRAP_SENTINEL'])",
+                "prefix = Path(sys.pycache_prefix or '.')",
+                "with sentinel.open('a', encoding='ascii') as stream:",
+                "    stream.write(",
+                "        f'{sys.flags.isolated},{sys.flags.no_site},'",
+                "        f'{sys.flags.ignore_environment},'",
+                "        f'{sys.flags.dont_write_bytecode},'",
+                "        f'{int(prefix.exists())}\\n'",
+                "    )",
+                "class RuntimeEvidenceError(RuntimeError):",
+                "    pass",
+                "def source_only_bytecode_policy():",
+                "    raise RuntimeEvidenceError('stop after authenticated import')",
+                "def established_preimport_runtime_identity():",
+                "    return {}",
+                "def loaded_pyamplicol_origin_policy(*args, **kwargs):",
+                "    return {}",
+                "def native_extension_in_package(*args, **kwargs):",
+                "    return Path('/missing-native')",
+                "def preimport_python_runtime_identity(*args, **kwargs):",
+                "    return {}",
+                "def python_package_tree_identity(*args, **kwargs):",
+                "    return {}",
+                "",
+            )
+        ),
+        encoding="ascii",
+    )
+
+    environment = os.environ.copy()
+    environment["PYAMPLICOL_BOOTSTRAP_SENTINEL"] = str(sentinel)
+    for name in (
+        "PYAMPLICOL_EXACT_PYTHON_REEXEC",
+        "PYAMPLICOL_EXACT_IMPORT_PATHS",
+        "PYTHONPYCACHEPREFIX",
+        "PYTHONDONTWRITEBYTECODE",
+    ):
+        environment.pop(name, None)
+    completed = subprocess.run(
+        (sys.executable, str(script), "--help"),
+        cwd=tmp_path,
+        check=False,
+        capture_output=True,
+        text=True,
+        env=environment,
+        timeout=30,
+    )
+
+    assert completed.returncode != 0
+    assert sentinel.read_text(encoding="ascii").splitlines() == ["1,1,1,1,0"]
+
+
+def test_result_tables_preauthenticates_staged_source_native(
+    tmp_path: Path,
+) -> None:
+    repository = Path(__file__).resolve().parents[2]
+    script = tmp_path / REPORT_ENTRYPOINT
+    script.parent.mkdir(parents=True)
+    shutil.copy2(repository / REPORT_ENTRYPOINT, script)
+
+    source_package = tmp_path / "src/pyamplicol"
+    source_package.mkdir(parents=True, exist_ok=True)
+    native_name = f"_rusticol{EXTENSION_SUFFIXES[0]}"
+    (source_package / native_name).write_bytes(b"source native")
+    installed_site = tmp_path / "installed"
+    installed_package = installed_site / "pyamplicol"
+    installed_package.mkdir(parents=True)
+    (installed_package / native_name).write_bytes(b"installed native")
+
+    package = tmp_path / "tools/performance_report"
+    package.mkdir(parents=True)
+    sentinel = tmp_path / "preimport.json"
+    (package / "runtime_evidence.py").write_text(
+        "\n".join(
+            (
+                "import json",
+                "import os",
+                "from pathlib import Path",
+                "class RuntimeEvidenceError(RuntimeError):",
+                "    pass",
+                "def source_only_bytecode_policy():",
+                "    return {}",
+                "def native_extension_in_package(package):",
+                f"    return Path(package) / {native_name!r}",
+                "def preimport_python_runtime_identity(roots, *, native_extension):",
+                "    payload = {",
+                "        'roots': [str(Path(root)) for root in roots],",
+                "        'native_extension': str(Path(native_extension)),",
+                "    }",
+                "    Path(os.environ['PYAMPLICOL_PREIMPORT_SENTINEL']).write_text(",
+                "        json.dumps(payload), encoding='ascii'",
+                "    )",
+                "    raise RuntimeError('stop after preimport capture')",
+                "",
+            )
+        ),
+        encoding="ascii",
+    )
+
+    environment = os.environ.copy()
+    environment["PYTHONPATH"] = str(installed_site)
+    environment["PYAMPLICOL_PREIMPORT_SENTINEL"] = str(sentinel)
+    for name in (
+        "PYAMPLICOL_EXACT_PYTHON_REEXEC",
+        "PYAMPLICOL_EXACT_IMPORT_PATHS",
+        "PYTHONPYCACHEPREFIX",
+        "PYTHONDONTWRITEBYTECODE",
+    ):
+        environment.pop(name, None)
+    completed = subprocess.run(
+        (sys.executable, str(script), "--help"),
+        cwd=tmp_path,
+        check=False,
+        capture_output=True,
+        text=True,
+        env=environment,
+        timeout=30,
+    )
+
+    assert completed.returncode != 0
+    assert json.loads(sentinel.read_text(encoding="ascii")) == {
+        "roots": [str(source_package)],
+        "native_extension": str(source_package / native_name),
+    }
+
+
+def test_class_c_prepare_uses_ancestor_package_with_descendant_tools(
+    tmp_path: Path,
+) -> None:
+    repository = Path(__file__).resolve().parents[2]
+    script_relative = REPORT_ENTRYPOINT
+    script = tmp_path / script_relative
+    script.parent.mkdir(parents=True)
+    shutil.copy2(repository / script_relative, script)
+
+    descendant_package = tmp_path / "src/pyamplicol"
+    descendant_package.mkdir(parents=True, exist_ok=True)
+    (descendant_package / "__init__.py").write_text(
+        "raise RuntimeError('descendant package was imported')\n",
+        encoding="ascii",
+    )
+    ancestor = tmp_path / "ancestor-runtime"
+    ancestor_package = ancestor / "src/pyamplicol"
+    ancestor_package.mkdir(parents=True)
+    package_sentinel = tmp_path / "ancestor-package.txt"
+    (ancestor_package / "__init__.py").write_text(
+        "\n".join(
+            (
+                "import os",
+                "from pathlib import Path",
+                "Path(os.environ['PYAMPLICOL_ANCESTOR_PACKAGE_SENTINEL']).write_text(",
+                "    __file__, encoding='ascii'",
+                ")",
+                "",
+            )
+        ),
+        encoding="ascii",
+    )
+    native_name = f"_rusticol{EXTENSION_SUFFIXES[0]}"
+    (ancestor_package / native_name).write_bytes(b"ancestor native")
+
+    tools_package = tmp_path / "tools/performance_report"
+    tools_package.mkdir(parents=True)
+    (tools_package / "__init__.py").write_text("", encoding="ascii")
+    preimport_sentinel = tmp_path / "preimport.json"
+    (tools_package / "runtime_evidence.py").write_text(
+        "\n".join(
+            (
+                "import json",
+                "import os",
+                "from pathlib import Path",
+                "class RuntimeEvidenceError(RuntimeError):",
+                "    pass",
+                "def source_only_bytecode_policy():",
+                "    return {}",
+                "def native_extension_in_package(package):",
+                f"    return Path(package) / {native_name!r}",
+                "def preimport_python_runtime_identity(roots, *, native_extension):",
+                "    payload = {",
+                "        'roots': [str(Path(root)) for root in roots],",
+                "        'native_extension': str(Path(native_extension)),",
+                "    }",
+                "    Path(os.environ['PYAMPLICOL_PREIMPORT_SENTINEL']).write_text(",
+                "        json.dumps(payload), encoding='ascii'",
+                "    )",
+                "    return payload",
+                "",
+            )
+        ),
+        encoding="ascii",
+    )
+    cli_sentinel = tmp_path / "descendant-cli.json"
+    (tools_package / "cli.py").write_text(
+        "\n".join(
+            (
+                "import json",
+                "import os",
+                "from pathlib import Path",
+                "def main(arguments):",
+                "    sentinel = os.environ['PYAMPLICOL_DESCENDANT_CLI_SENTINEL']",
+                "    Path(sentinel).write_text(",
+                "        json.dumps({'arguments': arguments, 'origin': __file__}),",
+                "        encoding='ascii',",
+                "    )",
+                "    return 0",
+                "",
+            )
+        ),
+        encoding="ascii",
+    )
+
+    environment = os.environ.copy()
+    environment.update(
+        {
+            "PYAMPLICOL_ANCESTOR_PACKAGE_SENTINEL": str(package_sentinel),
+            "PYAMPLICOL_DESCENDANT_CLI_SENTINEL": str(cli_sentinel),
+            "PYAMPLICOL_PREIMPORT_SENTINEL": str(preimport_sentinel),
+        }
+    )
+    for name in (
+        "PYAMPLICOL_EXACT_PYTHON_REEXEC",
+        "PYAMPLICOL_EXACT_IMPORT_PATHS",
+        "PYTHONPYCACHEPREFIX",
+        "PYTHONDONTWRITEBYTECODE",
+    ):
+        environment.pop(name, None)
+    completed = subprocess.run(
+        (
+            sys.executable,
+            str(script),
+            "--class-c-ancestor-runtime-root",
+            str(ancestor),
+            "prepare-class-c-bridge",
+            "--ancestor-revision",
+            "a" * 40,
+            "--descendant-revision",
+            "d" * 40,
+            "--impact",
+            "hzz-orientation-v1",
+        ),
+        cwd=tmp_path,
+        check=False,
+        capture_output=True,
+        text=True,
+        env=environment,
+        timeout=30,
+    )
+
+    assert completed.returncode == 0, completed.stderr
+    assert Path(package_sentinel.read_text(encoding="ascii")).parent == ancestor_package
+    assert json.loads(preimport_sentinel.read_text(encoding="ascii")) == {
+        "roots": [str(ancestor_package)],
+        "native_extension": str(ancestor_package / native_name),
+    }
+    cli = json.loads(cli_sentinel.read_text(encoding="ascii"))
+    assert Path(cli["origin"]).parent == tools_package
+    assert "--class-c-ancestor-runtime-root" in cli["arguments"]
+
+
+def test_class_c_ancestor_runtime_option_is_prepare_only(tmp_path: Path) -> None:
+    repository = Path(__file__).resolve().parents[2]
+    script = tmp_path / REPORT_ENTRYPOINT
+    script.parent.mkdir(parents=True)
+    shutil.copy2(repository / REPORT_ENTRYPOINT, script)
+    (tmp_path / "tools/performance_report").mkdir(parents=True)
+    (tmp_path / "src/pyamplicol").mkdir(parents=True, exist_ok=True)
+    ancestor = tmp_path / "ancestor-runtime"
+    (ancestor / "src/pyamplicol").mkdir(parents=True)
+
+    completed = subprocess.run(
+        (
+            sys.executable,
+            str(script),
+            "--class-c-ancestor-runtime-root",
+            str(ancestor),
+            "audit",
+        ),
+        cwd=tmp_path,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+
+    assert completed.returncode != 0
+    assert "restricted to prepare-class-c-bridge" in completed.stderr
+
+
+def test_split_worker_uses_wrapper_tools_and_measured_source_venv(
+    tmp_path: Path,
+) -> None:
+    repository = Path(__file__).resolve().parents[2]
+    wrapper = tmp_path / "wrapper"
+    measured = tmp_path / "measured"
+    output = tmp_path / "output"
+    output.mkdir()
+
+    def initialize_git(root: Path) -> None:
+        subprocess.run(("git", "init", "-q"), cwd=root, check=True)
+        subprocess.run(
+            ("git", "config", "user.email", "test@example.invalid"),
+            cwd=root,
+            check=True,
+        )
+        subprocess.run(
+            ("git", "config", "user.name", "Test"),
+            cwd=root,
+            check=True,
+        )
+
+    wrapper_entrypoint = wrapper / REPORT_ENTRYPOINT
+    wrapper_entrypoint.parent.mkdir(parents=True)
+    shutil.copy2(
+        repository / REPORT_ENTRYPOINT,
+        wrapper_entrypoint,
+    )
+    wrapper_source = wrapper / "src/pyamplicol"
+    wrapper_source.mkdir(parents=True, exist_ok=True)
+    (wrapper_source / "__init__.py").write_text(
+        "raise RuntimeError('wrapper pyamplicol escaped split routing')\n",
+        encoding="ascii",
+    )
+    wrapper_tools = wrapper / "tools/performance_report"
+    wrapper_tools.mkdir(parents=True)
+    (wrapper / "tools/__init__.py").write_text("", encoding="ascii")
+    (wrapper_tools / "__init__.py").write_text(
+        "ORIGIN = 'wrapper-tools'\n",
+        encoding="ascii",
+    )
+    native_name = f"_rusticol{EXTENSION_SUFFIXES[0]}"
+    preimport_sentinel = output / "preimport.json"
+    (wrapper_tools / "runtime_evidence.py").write_text(
+        "\n".join(
+            (
+                "import json",
+                "import os",
+                "from pathlib import Path",
+                "class RuntimeEvidenceError(RuntimeError):",
+                "    pass",
+                "def source_only_bytecode_policy():",
+                "    return {}",
+                "def native_extension_in_package(package):",
+                f"    return Path(package) / {native_name!r}",
+                "def preimport_python_runtime_identity(roots, *, native_extension):",
+                "    payload = {",
+                "        'roots': [str(Path(root)) for root in roots],",
+                "        'native_extension': str(Path(native_extension)),",
+                "    }",
+                "    Path(os.environ['SPLIT_PREIMPORT_SENTINEL']).write_text(",
+                "        json.dumps(payload), encoding='ascii'",
+                "    )",
+                "    return payload",
+                "",
+            )
+        ),
+        encoding="ascii",
+    )
+    wrapper_legacy = wrapper_tools / "legacy.py"
+    wrapper_legacy.write_text(
+        "ORIGIN = 'wrapper-legacy-bootstrap-exclusion'\n",
+        encoding="ascii",
+    )
+    (wrapper_tools / "cli.py").write_text(
+        "\n".join(
+            (
+                "import json",
+                "import os",
+                "import sys",
+                "from pathlib import Path",
+                "import pyamplicol",
+                "import tools.performance_report as report_package",
+                "from tools.performance_report import legacy",
+                "def main(arguments):",
+                "    command = next(",
+                "        value for value in arguments",
+                "        if value in {'_prepare', '_worker'}",
+                "    )",
+                "    result_path = Path(",
+                "        arguments[arguments.index('--result-json') + 1]",
+                "    )",
+                "    if command == '_prepare':",
+                "        prepared = result_path.parent / 'prepared-model'",
+                "        prepared.mkdir(exist_ok=True)",
+                "        result_path.write_text(",
+                "            json.dumps({'path': str(prepared), 'reused': False}),",
+                "            encoding='ascii',",
+                "        )",
+                "    else:",
+                "        result_path.write_text(",
+                "            json.dumps({'status': 'ok'}), encoding='ascii'",
+                "        )",
+                "    payload = {",
+                "        'arguments': arguments,",
+                "        'cli_origin': __file__,",
+                "        'tools_origin': report_package.__file__,",
+                "        'legacy_origin': legacy.__file__,",
+                "        'legacy_marker': legacy.ORIGIN,",
+                "        'pyamplicol_origin': pyamplicol.__file__,",
+                "        'pyamplicol_path': list(pyamplicol.__path__),",
+                "        'sys_path': list(sys.path),",
+                "    }",
+                "    sentinel = Path(os.environ['SPLIT_CLI_SENTINEL_ROOT'])",
+                "    (sentinel / f'{command}.json').write_text(",
+                "        json.dumps(payload), encoding='ascii'",
+                "    )",
+                "    return 0",
+                "",
+            )
+        ),
+        encoding="ascii",
+    )
+    initialize_git(wrapper)
+    subprocess.run(("git", "add", "."), cwd=wrapper, check=True)
+    subprocess.run(
+        ("git", "commit", "-qm", "authenticated wrapper"),
+        cwd=wrapper,
+        check=True,
+    )
+
+    measured_package = measured / "src/pyamplicol"
+    measured_package.mkdir(parents=True)
+    (measured / ".gitignore").write_text(".venv/\n", encoding="ascii")
+    (measured_package / "__init__.py").write_text(
+        "ORIGIN = 'measured-pyamplicol'\n",
+        encoding="ascii",
+    )
+    native_payload = b"authenticated measured native fixture"
+    (measured_package / native_name).write_bytes(native_payload)
+    measured_decoy = measured / "src/tools/performance_report"
+    measured_decoy.mkdir(parents=True)
+    (measured / "src/tools/__init__.py").write_text("", encoding="ascii")
+    (measured_decoy / "__init__.py").write_text(
+        "raise RuntimeError('measured tools escaped wrapper routing')\n",
+        encoding="ascii",
+    )
+    (measured_decoy / "legacy.py").write_text(
+        "ORIGIN = 'measured-legacy-without-bootstrap-fix'\n",
+        encoding="ascii",
+    )
+    initialize_git(measured)
+    subprocess.run(("git", "add", "."), cwd=measured, check=True)
+    subprocess.run(
+        ("git", "commit", "-qm", "measured source"),
+        cwd=measured,
+        check=True,
+    )
+    subprocess.run(
+        (sys.executable, "-m", "venv", "--without-pip", measured / ".venv"),
+        check=True,
+        timeout=30,
+    )
+    site_paths = tuple(
+        (measured / ".venv").glob("lib/python*/site-packages")
+    )
+    assert len(site_paths) == 1
+    installed_package = site_paths[0] / "pyamplicol"
+    installed_package.mkdir()
+    (installed_package / "__init__.py").write_text(
+        "ORIGIN = 'measured-venv-pyamplicol'\n",
+        encoding="ascii",
+    )
+    (installed_package / native_name).write_bytes(native_payload)
+
+    attacker = tmp_path / "attacker"
+    attacker_package = attacker / "tools/performance_report"
+    attacker_package.mkdir(parents=True)
+    (attacker / "tools/__init__.py").write_text("", encoding="ascii")
+    (attacker_package / "__init__.py").write_text(
+        "raise RuntimeError('attacker PYTHONPATH was imported')\n",
+        encoding="ascii",
+    )
+    (attacker / "pyamplicol").mkdir()
+    (attacker / "pyamplicol/__init__.py").write_text(
+        "raise RuntimeError('attacker pyamplicol was imported')\n",
+        encoding="ascii",
+    )
+
+    def git_value(root: Path, expression: str) -> str:
+        return subprocess.run(
+            ("git", "rev-parse", expression),
+            cwd=root,
+            check=True,
+            capture_output=True,
+            text=True,
+        ).stdout.strip()
+
+    def digest(path: Path) -> str:
+        return hashlib.sha256(path.read_bytes()).hexdigest()
+
+    common_arguments = (
+        "--repo-root",
+        str(measured),
+        "--measurement-source-root",
+        str(measured),
+        "--expected-measurement-source-revision",
+        git_value(measured, "HEAD^{commit}"),
+        "--expected-measurement-source-tree",
+        git_value(measured, "HEAD^{tree}"),
+        "--expected-policy-wrapper-revision",
+        git_value(wrapper, "HEAD^{commit}"),
+        "--expected-policy-wrapper-tree",
+        git_value(wrapper, "HEAD^{tree}"),
+        "--expected-policy-entrypoint-sha256",
+        digest(wrapper_entrypoint),
+        "--expected-legacy-adapter-sha256",
+        digest(wrapper_legacy),
+        "--study-contract-sha256",
+        "a" * 64,
+    )
+    environment = os.environ.copy()
+    environment.update(
+        {
+            "PYTHONPATH": str(attacker),
+            "PYTHONHOME": str(attacker),
+            "PYTHONSTARTUP": str(attacker / "startup.py"),
+            "PYTHONUSERBASE": str(attacker),
+            "SPLIT_CLI_SENTINEL_ROOT": str(output),
+            "SPLIT_PREIMPORT_SENTINEL": str(preimport_sentinel),
+        }
+    )
+    for command in ("_prepare", "_worker"):
+        result_path = output / f"{command}-result.json"
+        completed = subprocess.run(
+            (
+                measured / ".venv/bin/python",
+                "-I",
+                "-S",
+                "-B",
+                wrapper_entrypoint,
+                *common_arguments,
+                command,
+                "--result-json",
+                result_path,
+            ),
+            cwd=measured,
+            check=False,
+            capture_output=True,
+            text=True,
+            env=environment,
+            timeout=30,
+        )
+        assert completed.returncode == 0, completed.stderr
+        captured = json.loads(
+            (output / f"{command}.json").read_text(encoding="ascii")
+        )
+        assert Path(captured["cli_origin"]).is_relative_to(wrapper_tools)
+        assert Path(captured["tools_origin"]).is_relative_to(wrapper_tools)
+        assert Path(captured["legacy_origin"]) == wrapper_legacy
+        assert captured["legacy_marker"] == (
+            "wrapper-legacy-bootstrap-exclusion"
+        )
+        assert Path(captured["pyamplicol_origin"]).is_relative_to(
+            measured_package
+        )
+        assert {
+            Path(path).resolve()
+            for path in captured["pyamplicol_path"]
+        } == {measured_package.resolve()}
+        assert str(attacker) not in captured["sys_path"]
+        assert str(wrapper / "src") not in captured["sys_path"]
+        assert {
+            Path(path).resolve()
+            for path in captured["sys_path"]
+            if "site-packages" in path
+        } == {site_paths[0].resolve()}
+        assert result_path.is_file()
+
+    assert json.loads(preimport_sentinel.read_text(encoding="ascii")) == {
+        "roots": [str(measured_package)],
+        "native_extension": str(measured_package / native_name),
+    }
+
+    preimport_sentinel.unlink()
+    (output / "_worker.json").unlink()
+    (measured_package / "__init__.py").write_text(
+        "ORIGIN = 'dirty-measured-pyamplicol'\n",
+        encoding="ascii",
+    )
+    dirty_result = subprocess.run(
+        (
+            measured / ".venv/bin/python",
+            "-I",
+            "-S",
+            "-B",
+            wrapper_entrypoint,
+            *common_arguments,
+            "_worker",
+            "--result-json",
+            output / "dirty-result.json",
+        ),
+        cwd=measured,
+        check=False,
+        capture_output=True,
+        text=True,
+        env=environment,
+        timeout=30,
+    )
+
+    assert dirty_result.returncode != 0
+    assert (
+        "measured-source checkout has tracked changes"
+        in dirty_result.stderr
+    )
+    assert not preimport_sentinel.exists()
+    assert not (output / "_worker.json").exists()
+
+    (measured_package / "__init__.py").write_text(
+        "ORIGIN = 'measured-pyamplicol'\n",
+        encoding="ascii",
+    )
+    (measured_package / "injected.py").write_text(
+        "raise RuntimeError('untracked measured source was imported')\n",
+        encoding="ascii",
+    )
+    untracked_result = subprocess.run(
+        (
+            measured / ".venv/bin/python",
+            "-I",
+            "-S",
+            "-B",
+            wrapper_entrypoint,
+            *common_arguments,
+            "_worker",
+            "--result-json",
+            output / "untracked-result.json",
+        ),
+        cwd=measured,
+        check=False,
+        capture_output=True,
+        text=True,
+        env=environment,
+        timeout=30,
+    )
+
+    assert untracked_result.returncode != 0
+    assert (
+        "measured-source checkout has untracked files in imported "
+        "source roots"
+        in untracked_result.stderr
+    )
+    assert not preimport_sentinel.exists()
+    assert not (output / "_worker.json").exists()
diff --git a/pyamplicol/tests/unit/test_exact_symbolic_propagators.py b/pyamplicol/tests/unit/test_exact_symbolic_propagators.py
new file mode 100644
index 0000000000..64e6d899c4
--- /dev/null
+++ b/pyamplicol/tests/unit/test_exact_symbolic_propagators.py
@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: 0BSD
+"""Propagating a rational current must not freeze binary64 roundoff into it."""
+
+from decimal import Decimal
+from types import SimpleNamespace
+
+import pytest
+from symbolica import E
+
+from pyamplicol.models.expressions import (
+    _expr_antifermion_propagator_dirac,
+    _expr_antifermion_propagator_weyl,
+    _expr_fermion_propagator_dirac,
+    _expr_fermion_propagator_weyl,
+    _imaginary_unit_for,
+)
+from pyamplicol.models.external_evaluation import ExternalModelEvaluationMixin
+from pyamplicol.models.external_helpers import _expr_spin2_propagator
+
+
+class _PropagatorProbe(ExternalModelEvaluationMixin):
+    """Exercise the ordinary external-model formula without compiling a model."""
+
+    def __init__(self, *, kind, gauge, mass, width=0):
+        self._mass = mass
+        self._width = width
+        self.identity = SimpleNamespace(canonical_id="probe")
+        self.propagator = SimpleNamespace(
+            identity=self.identity,
+            chirality=0,
+            applies_propagator=True,
+            kind=kind,
+            mass_class="massless" if mass == 0 else "massive",
+            gauge=gauge,
+        )
+
+    def _propagator_ir(self, *_):
+        return self.propagator
+
+    def _particle_identity_ir(self, *_):
+        return self.identity
+
+    def mass(self, *_):
+        return self._mass
+
+    def width(self, *_):
+        return self._width
+
+
+@pytest.mark.parametrize(
+    "kind,gauge,mass,slot,sign",
+    (
+        ("scalar", None, 0, 0, 1),
+        ("scalar", None, E("m"), 0, 1),
+        ("vector", "feynman", 0, 1, -1),
+        ("vector", "unitary", E("m"), 1, -1),
+    ),
+)
+def test_external_propagator_preserves_rational_current(kind, gauge, mass, slot, sign):
+    model = _PropagatorProbe(kind=kind, gauge=gauge, mass=mass)
+    current = [E("0")] * (1 if kind == "scalar" else 4)
+    current[slot] = E("x/3")
+    actual = model.propagator_component_expression(1, current, (E("p"), 0, 0, 0))
+    expected = sign * E("1i*x/3") / (E("p^2") - mass * mass)
+    assert (actual[slot] - expected).expand() == E("0")
+    assert all(value == E("0") for index, value in enumerate(actual) if index != slot)
+
+
+@pytest.mark.parametrize("antiparticle", (False, True))
+@pytest.mark.parametrize("chirality", (-1, 1))
+def test_weyl_propagator_preserves_rational_current(antiparticle, chirality):
+    propagate = (
+        _expr_antifermion_propagator_weyl
+        if antiparticle
+        else _expr_fermion_propagator_weyl
+    )
+    actual = propagate((E("x/3"), E("0")), (E("p"), 0, 0, 0), chirality)
+    expected = (-1 if antiparticle else 1) * E("1i*x/(3*p)")
+    assert (actual[0] - expected).expand() == E("0")
+    assert actual[1] == E("0")
+
+
+@pytest.mark.parametrize("antiparticle", (False, True))
+def test_dirac_propagator_preserves_rational_current(antiparticle):
+    propagate = (
+        _expr_antifermion_propagator_dirac
+        if antiparticle
+        else _expr_fermion_propagator_dirac
+    )
+    actual = propagate((E("x/3"), E("0"), E("0"), E("0")), (E("p"), 0, 0, 0), 0, 0)
+    expected = (-1 if antiparticle else 1) * E("1i*x/(3*p)")
+    assert (actual[2] - expected).expand() == E("0")
+    assert all(value == E("0") for index, value in enumerate(actual) if index != 2)
+
+
+@pytest.mark.parametrize("massive", (False, True))
+def test_spin2_propagator_preserves_rational_projector(massive):
+    current = [E("0")] * 16
+    current[5] = E("x/3")
+    mass = E("m") if massive else 0
+    actual = _expr_spin2_propagator(
+        current, (E("p"), 0, 0, 0), mass, 0, dimension=4.0, massive=massive
+    )
+    # For a purely spatial diagonal source, the trace subtraction is 1/2
+    # in de Donder gauge and 1/3 in the massive Fierz--Pauli projector.
+    expected = E("1i*x") * (E("2/9") if massive else E("1/6"))
+    expected /= E("p^2") - mass * mass
+    assert (actual[5] - expected).expand() == E("0")
+
+
+def test_propagator_phase_does_not_promote_numeric_types_to_symbolica():
+    assert _imaginary_unit_for((Decimal("0.123"), 1.0, 2j)) == 1j
+    # A numeric wrapper need not inherit numbers.Number.
+    assert _imaginary_unit_for((SimpleNamespace(value=1),)) == 1j
+    model = _PropagatorProbe(kind="scalar", gauge=None, mass=0)
+    actual = model.propagator_component_expression(1, (2.0,), (2.0, 0.0, 0.0, 0.0))
+    assert actual == (0.5j,)
+    assert isinstance(actual[0], complex)
diff --git a/pyamplicol/tests/unit/test_exact_vertex_normalization.py b/pyamplicol/tests/unit/test_exact_vertex_normalization.py
new file mode 100644
index 0000000000..dab6bdb567
--- /dev/null
+++ b/pyamplicol/tests/unit/test_exact_vertex_normalization.py
@@ -0,0 +1,130 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+from types import SimpleNamespace
+
+import pytest
+from symbolica import E, Expression, S
+
+from pyamplicol.models import BuiltinSMModel, compiler_symbolica
+from pyamplicol.models.builtin.expressions import _quark_vector_weyl_data
+from pyamplicol.models.external_catalog import ExternalModelCatalogMixin
+from pyamplicol.models.external_kernels import ExternalModelKernelMixin
+from pyamplicol.models.prepared_catalog_builder import _vertex_expressions
+
+
+def test_builtin_cubic_normalization_matches_the_quartic_vertex_exactly() -> None:
+    model = BuiltinSMModel()
+    zero, one = E("0"), E("1")
+    cubic = model.vertex_component_expression(
+        0,
+        (one, zero, zero, zero),
+        (zero, one, zero, zero),
+        result_particle_id=21,
+        result_chirality=0,
+        left_momentum=(zero, zero, zero, zero),
+        right_momentum=(E("1/2"), zero, zero, zero),
+    )[1]
+    quartic = model.vertex_component_expression(
+        2,
+        (one, zero, zero, zero, zero, zero),
+        (zero, one, zero, zero),
+        result_particle_id=21,
+        result_chirality=0,
+    )[0]
+
+    assert (cubic**2 + E("1/2")).expand() == zero
+    assert (cubic**2 - E("1i") * quartic).expand().to_canonical_string() == "0"
+    assert complex(cubic.evaluate({})) == pytest.approx(1j / math.sqrt(2))
+
+
+@pytest.mark.parametrize("chirality", (-1, 1))
+def test_builtin_quark_tensor_has_exact_colour_normalization(chirality: int) -> None:
+    entries = _quark_vector_weyl_data(chirality=chirality)
+    nonzero = [value for value in entries if value != 0]
+    assert nonzero
+    for value in nonzero:
+        assert isinstance(value, Expression)
+        # Nonzero entries are +/-1/sqrt(2) or +/-i/sqrt(2).
+        assert (value**4 - E("1/4")).expand() == E("0")
+
+
+def test_exact_radical_preserves_prepared_symbolic_coupling_inputs() -> None:
+    compiler_symbolica._ensure_symbolica()
+    model = BuiltinSMModel()
+    vertex = next(
+        vertex
+        for vertex in model.vertices
+        if vertex.kind == 21 and vertex.particles == (11, -11, 22)
+    )
+    expressions, coupling_inputs = _vertex_expressions(
+        model,
+        vertex,
+        left=tuple(S(f"normalization_left_{index}") for index in range(4)),
+        right=tuple(S(f"normalization_right_{index}") for index in range(2)),
+        left_chirality=0,
+        right_chirality=-1,
+        result_chirality=0,
+        left_momentum=(0, 0, 0, 0),
+        right_momentum=(0, 0, 0, 0),
+        coupling_symbols=S(
+            "normalization_coupling_left", "normalization_coupling_right"
+        ),
+        parameter_symbols={},
+    )
+    assert len(expressions) == 4
+    assert coupling_inputs == (0, 1)
+
+
+class _ExternalNormalizationModel(ExternalModelKernelMixin, ExternalModelCatalogMixin):
+    def __init__(self, power: int, structure: str) -> None:
+        self.name = "normalization_test"
+        self._kernel_coupling_expression_cache = {}
+        self._color_projection_cache = {}
+        self.kernel = SimpleNamespace(
+            kind=0,
+            coupling_expression="1",
+            lc_color_normalization_power=power,
+            color_projection_structure=structure,
+            color_projection_coefficient=(0.5, 0.0),
+        )
+
+    def _kernel(self, kind: int):
+        assert kind == 0
+        return self.kernel
+
+
+@pytest.mark.parametrize("power", (0, 1, 2, 3, 4))
+@pytest.mark.parametrize(
+    "structure",
+    ("adjoint-structure-constant", "adjoint-structure-constant-product", "identity"),
+)
+def test_external_normalization_is_symbolic_and_counted_once(
+    power: int, structure: str
+) -> None:
+    compiler_symbolica._ensure_symbolica()
+    model = _ExternalNormalizationModel(power, structure)
+    vertex = SimpleNamespace(kind=0)
+    coupling = model._resolved_kernel_coupling_expression(model.kernel, {})
+    weight = complex(*model.vertex_color_weight(vertex, color_accuracy="full"))
+    phase = (-1j) ** power if structure.startswith("adjoint-") else 1
+
+    # Empty parameter lists must not cause a symbolic constant to be evaluated
+    # as binary64 before the high-precision kernel has been constructed.
+    assert isinstance(coupling, Expression)
+    assert (coupling**2 - E(f"1/{2**power}")).expand() == E("0")
+    assert weight == 0.5 * phase
+    for color_accuracy in ("lc", "nlc"):
+        assert (
+            complex(*model.vertex_color_weight(vertex, color_accuracy=color_accuracy))
+            == weight
+        )
+
+    numeric_coupling = model._resolved_kernel_coupling_expression(
+        model.kernel, {}, numeric=True
+    )
+    assert isinstance(numeric_coupling, complex)
+    assert numeric_coupling * weight == pytest.approx(
+        0.5 * phase * 2.0 ** (-0.5 * power), rel=2e-15, abs=0
+    )
diff --git a/pyamplicol/tests/unit/test_examples.py b/pyamplicol/tests/unit/test_examples.py
new file mode 100644
index 0000000000..8d2f95ee98
--- /dev/null
+++ b/pyamplicol/tests/unit/test_examples.py
@@ -0,0 +1,475 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import ast
+import json
+import math
+import tomllib
+from collections.abc import Mapping
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.config import FIELD_REGISTRY, ProcessEntry, resolve_config
+
+ROOT = Path(__file__).resolve().parents[2]
+EXAMPLES = ROOT / "examples"
+RUN_CARDS = tuple(sorted(EXAMPLES.glob("*.toml")))
+
+
+def _read_toml(path: Path) -> dict[str, object]:
+    with path.open("rb") as stream:
+        return tomllib.load(stream)
+
+
+def _schema_leaf_paths(
+    payload: Mapping[str, object],
+    *,
+    prefix: str = "",
+) -> set[str]:
+    paths: set[str] = set()
+    for key, value in payload.items():
+        path = f"{prefix}.{key}" if prefix else key
+        if path in FIELD_REGISTRY:
+            paths.add(path)
+        elif isinstance(value, Mapping):
+            paths.update(_schema_leaf_paths(value, prefix=path))
+        else:
+            paths.add(path)
+    return paths
+
+
+@pytest.mark.parametrize("card", RUN_CARDS, ids=lambda path: path.stem)
+def test_run_cards_parse_and_resolve_without_domain_backends(card: Path) -> None:
+    payload = _read_toml(card)
+    resolution = resolve_config(card)
+    config = resolution.effective
+
+    assert payload["schema_version"] == 1
+    assert config.schema_version == 1
+    assert config.action == payload["action"]
+    assert not resolution.was_clamped
+
+    if config.action == "generate":
+        assert config.process.entries
+        assert config.generation.output is not None
+    elif config.action == "evaluate":
+        assert config.evaluation.artifact is not None
+        assert config.evaluation.momenta is not None
+    elif config.action in {"benchmark", "inspect", "group-processes"}:
+        assert config.evaluation.artifact is not None
+
+
+def test_all_options_is_an_exhaustive_commented_registry_snapshot() -> None:
+    card = EXAMPLES / "all_options.toml"
+    payload = _read_toml(card)
+    text = card.read_text(encoding="utf-8")
+
+    assert _schema_leaf_paths(payload) == set(FIELD_REGISTRY)
+    for path in FIELD_REGISTRY:
+        assert f"# {path}:" in text, f"missing all-options comment for {path}"
+
+
+def test_example_parameter_card_uses_serialized_ufo_pair_shape() -> None:
+    payload = json.loads(
+        (EXAMPLES / "data/model_parameters.json").read_text(encoding="utf-8")
+    )
+
+    assert payload == {"aS": [0.117, 0.0], "MZ": [91.188, 0.0]}
+
+
+def test_example_matrix_covers_required_models_and_modes() -> None:
+    color_cards = {
+        "builtin_sm_lc.toml": "lc",
+        "builtin_sm_nlc.toml": "nlc",
+        "builtin_sm_full.toml": "full",
+    }
+    for name, accuracy in color_cards.items():
+        payload = _read_toml(EXAMPLES / name)
+        assert payload["model"] == {"source": "built-in-sm"}
+        assert payload["color"]["accuracy"] == accuracy  # type: ignore[index]
+        assert payload["process"]["entries"][0]["expression"] == "u u~ > g g"  # type: ignore[index]
+        mode = resolve_config(EXAMPLES / name).effective.evaluator.execution_mode
+        if name == "builtin_sm_full.toml":
+            assert mode.value == "compiled"
+        else:
+            assert mode.value == "recurrence"
+
+    eager = resolve_config(EXAMPLES / "builtin_sm_eager.toml").effective
+    assert eager.model.source == "built-in-sm"
+    assert eager.evaluator.execution_mode.value == "eager"
+    assert eager.evaluator.backend.value == "jit"
+    assert eager.evaluator.jit.optimization_level == 2
+
+    heft = resolve_config(EXAMPLES / "builtin_sm_heft.toml").effective
+    assert heft.model.source == "built-in-sm-heft"
+    assert heft.process.entries == (ProcessEntry("g g > H g g", "gg_hgg"),)
+    assert heft.process.coupling_order_policy.value == "explicit"
+    assert heft.process.max_coupling_orders == {"HIG": 1}
+    assert heft.color.accuracy.value == "full"
+    assert heft.evaluator.execution_mode.value == "recurrence"
+    assert heft.evaluator.backend.value == "jit"
+
+    on_the_fly = resolve_config(EXAMPLES / "builtin_sm_on_the_fly.toml").effective
+    assert on_the_fly.model.source == "built-in-sm"
+    assert on_the_fly.color.accuracy.value == "lc"
+    assert on_the_fly.evaluator.execution_mode.value == "on-the-fly"
+    assert on_the_fly.evaluator.backend.value == "jit"
+    assert on_the_fly.evaluator.optimization.cores == 4
+    assert on_the_fly.generation.emit_api_bundle is False
+
+    process_set = resolve_config(EXAMPLES / "process_set_mixed_multiplicity.toml")
+    assert process_set.effective.process.entries == (
+        ProcessEntry("u u~ > Z g", "uubar_Zg"),
+        ProcessEntry("u u~ > Z g g", "uubar_Zgg"),
+    )
+
+    primary = resolve_config(EXAMPLES / "generate_pp_zjj_from_ufo_sm.toml").effective
+    assert primary.process.entries == (ProcessEntry("p p > Z j j"),)
+    assert primary.process.multiparticles == {
+        "p": ("d", "d~", "g"),
+        "j": ("d", "d~", "g"),
+    }
+    assert primary.process.flavor_scheme == 2
+    assert primary.model.restriction == "default"
+    assert primary.generation.output == EXAMPLES / "artifacts/pp_zjj"
+    assert primary.evaluator.jit.optimization_level == 2
+    assert primary.color.lc_flow_layout.value == "topology-replay"
+
+    external_sources = {
+        "external_ufo_sm.toml": "models/ufo/sm",
+        "generate_pp_zjj_from_ufo_sm.toml": "models/json/sm/sm.json",
+        "external_json_scalars.toml": "models/json/scalars/scalars.json",
+        "external_json_scalar_gravity.toml": (
+            "models/json/scalar_gravity/scalar_gravity.json"
+        ),
+    }
+    for name, expected in external_sources.items():
+        payload = _read_toml(EXAMPLES / name)
+        source = payload["model"]["source"]  # type: ignore[index]
+        assert source == expected
+        assert not Path(str(source)).is_absolute()
+        assert ".." not in Path(str(source)).parts
+        assert (
+            resolve_config(EXAMPLES / name).effective.evaluator.execution_mode.value
+            == "compiled"
+        )
+
+    total = resolve_config(EXAMPLES / "evaluate_total.toml").effective
+    resolved = resolve_config(EXAMPLES / "evaluate_resolved.toml").effective
+    assert not total.evaluation.resolved
+    assert resolved.evaluation.resolved
+    assert total.evaluation.process == resolved.evaluation.process == "d d~ > g z g"
+    benchmark = resolve_config(EXAMPLES / "benchmark.toml").effective
+    assert benchmark.action == "benchmark"
+    assert benchmark.benchmark.helicity_ids == ()
+    assert benchmark.benchmark.color_flow_ids == ("1",)
+    examples_readme = (EXAMPLES / "README.md").read_text(encoding="utf-8")
+    assert "--momenta data/pp_zjj_momenta.json \\\n  --color-flow 1" in examples_readme
+
+
+def test_z6g_benchmark_examples_encode_reusable_runtime_selectors() -> None:
+    selected = resolve_config(
+        EXAMPLES / "benchmark_z6g_single_flow_helicity_sum.toml"
+    ).effective
+    all_flows = resolve_config(
+        EXAMPLES / "benchmark_z6g_all_flows_single_helicity.toml"
+    ).effective
+
+    expected_process = (ProcessEntry("u u~ > Z g g g g g g", "uubar_Z_6g"),)
+    for config in (selected, all_flows):
+        assert config.process.entries == expected_process
+        assert config.model.source == "built-in-sm"
+        assert config.color.accuracy.value == "lc"
+        assert config.evaluator.execution_mode.value == "compiled"
+        assert config.evaluator.backend.value == "jit"
+        assert config.evaluator.jit.optimization_level == 3
+        assert config.evaluator.batch_size == 64
+        assert config.evaluator.output_chunk_size == 512
+        assert config.benchmark.batch_size == 64
+        assert config.benchmark.target_runtime == 20.0
+        assert config.benchmark.warmup_runs == 2
+        assert config.benchmark.minimum_samples == 5
+        assert not config.generation.validation.post_build_validation
+
+    assert selected.process.reference_color_order == ()
+    assert selected.process.selected_color_sector_ids == ()
+    assert selected.process.selected_source_helicities == {}
+    assert selected.color.lc_flow_layout.value == "topology-replay"
+    assert selected.benchmark.color_flow_ids == ("1",)
+    assert selected.benchmark.helicity_ids == ()
+
+    assert all_flows.process.reference_color_order == ()
+    assert all_flows.process.selected_color_sector_ids == ()
+    assert all_flows.process.selected_source_helicities == {}
+    assert all_flows.color.lc_flow_layout.value == "all-flow-union"
+    assert all_flows.benchmark.color_flow_ids == ()
+    assert all_flows.benchmark.helicity_ids == ("h:-1,+1,-1,+1,-1,+1,-1,+1,-1",)
+
+
+def test_qq_z6g_examples_cover_the_three_public_execution_modes() -> None:
+    cards = {
+        "qq_z6g_recurrence_jit_o2.toml": ("recurrence", 2),
+        "qq_z6g_compiled_jit_o3.toml": ("compiled", 3),
+        "qq_z6g_eager_jit_o2.toml": ("eager", 2),
+    }
+    outputs: set[Path] = set()
+
+    for name, (mode, jit_level) in cards.items():
+        config = resolve_config(EXAMPLES / name).effective
+        assert config.process.entries[0].expression == "u u~ > Z g g g g g g"
+        assert config.model.source == "built-in-sm"
+        assert config.color.accuracy.value == "lc"
+        assert config.color.lc_flow_layout.value == "topology-replay"
+        assert config.evaluator.execution_mode.value == mode
+        assert config.evaluator.backend.value == "jit"
+        assert config.evaluator.jit.optimization_level == jit_level
+        assert config.benchmark.target_runtime == 5.0
+        assert config.benchmark.color_flow_ids == ("1",)
+        assert config.benchmark.helicity_ids == ()
+        assert not config.generation.validation.post_build_validation
+        assert config.generation.output is not None
+        outputs.add(config.generation.output)
+
+    assert len(outputs) == len(cards)
+
+
+def test_otf_pp_zjj_example_pins_one_flow_f64_warm_up_and_profile() -> None:
+    config = resolve_config(EXAMPLES / "otf_pp_zjj.toml").effective
+    script = (EXAMPLES / "python/otf_pp_zjj_warm_up.py").read_text(encoding="utf-8")
+    momenta = json.loads(
+        (EXAMPLES / "data/pp_zjj_momenta.json").read_text(encoding="utf-8")
+    )
+
+    assert config.process.entries == (ProcessEntry("p p > Z j j"),)
+    assert config.process.multiparticles == {
+        "p": ("d", "d~", "g"),
+        "j": ("d", "d~", "g"),
+    }
+    assert config.model.source == "built-in-sm"
+    assert config.color.accuracy.value == "lc"
+    assert config.evaluator.execution_mode.value == "on-the-fly"
+    assert config.evaluator.optimization.cores == 4
+    assert config.generation.emit_api_bundle
+    assert config.evaluation.process == "d d~ > g z g"
+    assert config.evaluation.precision == 16
+    assert config.benchmark.precision == 16
+    assert config.benchmark.color_flow_ids == ("1",)
+    assert config.benchmark.helicity_ids == ()
+    assert config.output.format.value == "human"
+    assert config.output.color.value == "auto"
+    assert len(momenta) == 1
+
+    assert "one_point = (point,)" in script
+    assert "runtime.warm_up(" in script
+    assert "precision=16" in script
+    assert "color_flows=(flow,)" in script
+    assert "progress=progress" in script
+    assert "n_cores=n_cores" in script
+    assert '"--n-cores"' in script
+    assert "PrettyTable" in script
+
+
+def test_pp_4j_grouping_examples_share_one_flavor_blind_artifact() -> None:
+    generate = resolve_config(EXAMPLES / "generate_pp_4j_flavor_blind.toml").effective
+    inspect = resolve_config(EXAMPLES / "inspect_pp_4j.toml").effective
+    member = resolve_config(EXAMPLES / "evaluate_pp_4j_member.toml").effective
+    grouping = resolve_config(EXAMPLES / "group_pp_4j.toml").effective
+
+    assert generate.model.source == "built-in-sm"
+    assert generate.process.entries == (ProcessEntry("p p > j j j j"),)
+    assert generate.process.multiparticles == {}
+    assert generate.process.flavor_scheme == 5
+    assert generate.process.max_coupling_orders == {"QED": 0}
+    assert generate.process.flavor_blind
+    assert generate.process.consider_charge_conjugation
+    assert generate.color.accuracy.value == "lc"
+    artifact = EXAMPLES / "artifacts/pp_4j_flavor_blind"
+    assert generate.generation.output == artifact
+    for config in (inspect, member, grouping):
+        assert config.evaluation.artifact == artifact
+
+    assert member.evaluation.process == "u~ g > u~ g g g"
+    assert member.evaluation.momenta == EXAMPLES / "data/pp_4j_momenta.json"
+    # Run cards default to "none"; only the subcommand defaults to numerical.
+    assert grouping.process.analyze_process_groups.value == "numerical"
+
+    momenta = json.loads(
+        (EXAMPLES / "data/pp_4j_momenta.json").read_text(encoding="utf-8")
+    )
+    assert len(momenta) == 1 and len(momenta[0]) == 6
+    point = momenta[0]
+    for index in range(4):
+        incoming = sum(particle[index] for particle in point[:2])
+        outgoing = sum(particle[index] for particle in point[2:])
+        assert incoming == pytest.approx(outgoing, rel=1e-13, abs=1e-12)
+    for particle in point:
+        mass_squared = particle[0] ** 2 - sum(c**2 for c in particle[1:])
+        assert mass_squared == pytest.approx(0.0, abs=1e-9)
+
+
+def test_example_data_has_finite_momenta_and_scalar_parameters() -> None:
+    momenta = json.loads(
+        (EXAMPLES / "data/pp_zjj_momenta.json").read_text(encoding="utf-8")
+    )
+    assert isinstance(momenta, list) and momenta
+    for point in momenta:
+        assert isinstance(point, list) and len(point) == 5
+        for particle in point:
+            assert isinstance(particle, list) and len(particle) == 4
+            assert all(
+                isinstance(component, (int, float))
+                and not isinstance(component, bool)
+                and math.isfinite(component)
+                for component in particle
+            )
+        incoming = [
+            sum(particle[index] for particle in point[:2]) for index in range(4)
+        ]
+        outgoing = [
+            sum(particle[index] for particle in point[2:]) for index in range(4)
+        ]
+        assert incoming == pytest.approx(outgoing, rel=1e-13, abs=1e-13)
+        invariant_masses_squared = [
+            particle[0] ** 2 - sum(component**2 for component in particle[1:])
+            for particle in point[2:]
+        ]
+        assert invariant_masses_squared[0] == pytest.approx(0.0, abs=1.0e-10)
+        assert invariant_masses_squared[1] == pytest.approx(91.188**2, rel=1.0e-12)
+        assert invariant_masses_squared[2] == pytest.approx(0.0, abs=1.0e-10)
+
+    parameters = json.loads(
+        (EXAMPLES / "data/model_parameters.json").read_text(encoding="utf-8")
+    )
+    assert set(parameters) == {"aS", "MZ"}
+    assert all(
+        isinstance(value, list)
+        and len(value) == 2
+        and all(
+            isinstance(component, (int, float))
+            and not isinstance(component, bool)
+            and math.isfinite(component)
+            for component in value
+        )
+        for value in parameters.values()
+    )
+
+
+def test_example_source_is_syntax_valid_public_and_spdx_marked() -> None:
+    source_files = [
+        *EXAMPLES.glob("*.toml"),
+        *EXAMPLES.glob("*.md"),
+        *EXAMPLES.glob("python/*.py"),
+        *EXAMPLES.glob("native/*.cpp"),
+        *EXAMPLES.glob("native/*.f90"),
+        EXAMPLES / "native/Makefile",
+    ]
+    for source in source_files:
+        first_line = source.read_text(encoding="utf-8").splitlines()[0]
+        assert "SPDX-License-Identifier: 0BSD" in first_line, source
+
+    for source in EXAMPLES.glob("python/*.py"):
+        text = source.read_text(encoding="utf-8")
+        tree = ast.parse(text, filename=str(source))
+        compile(tree, str(source), "exec")
+        imported = {
+            node.module
+            for node in ast.walk(tree)
+            if isinstance(node, ast.ImportFrom) and node.module is not None
+        }
+        assert not any(name.startswith("pyamplicol._") for name in imported)
+
+
+def test_native_examples_use_installed_sdk_discovery_and_public_wrappers() -> None:
+    makefile = (EXAMPLES / "native/Makefile").read_text(encoding="utf-8")
+    cpp = (EXAMPLES / "native/runtime.cpp").read_text(encoding="utf-8")
+    fortran = (EXAMPLES / "native/runtime.f90").read_text(encoding="utf-8")
+
+    for option in ("--cflags", "--libs", "--fortran-source"):
+        assert f'"$(RUSTICOL_CONFIG_PATH)" {option}' in makefile
+    assert ".venv/bin/rusticol-config" in makefile
+    assert "rusticol-config is unavailable" in makefile
+    assert "CXX ?= c++" in makefile
+    assert "ifeq ($(origin FC), default)\nFC := gfortran\nendif" in makefile
+    assert "FC ?= gfortran" in makefile
+    assert '"$(RUSTICOL_CONFIG_PATH)" --library' not in makefile
+    assert "rusticol::Runtime" in cpp
+    assert ".evaluate_resolved(" in cpp
+    assert "set_model_parameters_json" in cpp
+    assert 'set_model_parameter("aS"' in cpp
+    assert "p_p_to_z_j_j_3" in cpp
+    assert "use rusticol, only: rusticol_runtime" in fortran
+    assert "runtime%evaluate_resolved" in fortran
+    assert "model_parameters=trim(parameters)" in fortran
+    assert "runtime%set_model_parameter" in fortran
+    assert '"aS"' in fortran
+    assert "p_p_to_z_j_j_3" in fortran
+    assert "momenta(20)" in fortran
+
+    generated_rust = (
+        ROOT / "src/pyamplicol/assets/api_templates/rust/check_standalone.rs"
+    ).read_text(encoding="utf-8")
+    generated_makefile = (
+        ROOT / "src/pyamplicol/assets/api_templates/rust/Makefile"
+    ).read_text(encoding="utf-8")
+    assert 'include!(env!("RUSTICOL_RUST_SOURCE"))' in generated_rust
+    assert "Runtime::load" in generated_rust
+    assert "rusticol_runtime_" not in generated_rust
+    assert "unsafe" not in generated_rust
+    assert "the Rust Rusticol API supports only double precision" in generated_rust
+    assert '"$(RUSTICOL_CONFIG_PATH)" --rustflags' in generated_makefile
+
+    combined = "\n".join((makefile, cpp, fortran))
+    assert "src/pyamplicol" not in combined
+    assert str(ROOT) not in combined
+
+
+def test_typed_external_model_example_selects_process_local_compiled_jit() -> None:
+    source = (EXAMPLES / "python/typed_generation.py").read_text(encoding="utf-8")
+
+    assert '"execution_mode": "compiled"' in source
+    assert '"backend": "jit"' in source
+    assert '"optimization_level"' not in source
+
+
+def test_readme_states_current_release_boundary_and_public_surfaces() -> None:
+    readme = (ROOT / "README.md").read_text(encoding="utf-8")
+    status = (ROOT / "docs/user/release-and-support.md").read_text(encoding="utf-8")
+    assert "https://madgraph.org/pyamplicol/" in readme
+    assert "https://github.com/MadGraphTeam/pyamplicol/wiki" not in readme
+    assert "Generator(GenerationConfig(workers=4))" in readme
+    assert "p p > Z j j" in readme
+    assert "Runtime.load" in readme
+    assert "pyamplicol examples copy" in readme
+    assert "pyamplicol profiling-campaign copy" in readme
+    for interface in ("Python", "C11", "C++17", "Fortran 2008", "Rust 2021"):
+        assert interface in readme
+    assert "one source distribution and three `cp311-abi3` wheels" in status
+    assert "independent Fortran physics oracle" in status
+
+
+def test_user_docs_and_examples_exclude_retired_workflows() -> None:
+    sources = [
+        ROOT / "README.md",
+        *sorted((ROOT / "docs/user").glob("*.md")),
+        ROOT / "docs/development/PACKAGING_CONTRACT.md",
+        ROOT / "docs/development/ARCHITECTURE_DECISIONS.md",
+        *sorted(EXAMPLES.rglob("*.md")),
+        *sorted(EXAMPLES.rglob("*.toml")),
+        *sorted(EXAMPLES.rglob("*.py")),
+        *sorted(EXAMPLES.rglob("*.cpp")),
+        *sorted(EXAMPLES.rglob("*.f90")),
+    ]
+    combined = "\n".join(path.read_text(encoding="utf-8") for path in sources)
+    for retired in (
+        "ddbar_zg",
+        "normalization.alpha_s_me_check",
+        "CycloneDX",
+        "SBOM",
+        "RECORD signatures",
+        "signed source tag",
+        "parent repository",
+        "parent workspace",
+        "parent project",
+    ):
+        assert retired not in combined
diff --git a/pyamplicol/tests/unit/test_external_goldstone_contract.py b/pyamplicol/tests/unit/test_external_goldstone_contract.py
new file mode 100644
index 0000000000..482b987fa4
--- /dev/null
+++ b/pyamplicol/tests/unit/test_external_goldstone_contract.py
@@ -0,0 +1,241 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.models import CompiledUFOModel, compile_model_source
+from pyamplicol.models.compiler_gauge import compile_goldstone_partner_records
+from pyamplicol.models.contracts import CompiledModelIR
+from pyamplicol.models.loading import CompiledModel
+
+MODEL_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+
+
+@pytest.fixture(scope="module")
+def compiled_external_sm() -> CompiledModel:
+    return compile_model_source(
+        MODEL_ROOT / "sm.json",
+        restriction=str((MODEL_ROOT / "restrict_default.json").resolve()),
+        use_cache=False,
+    )
+
+
+def _replace_compiled_ir(
+    compiled: CompiledModel,
+    *,
+    particles=None,
+    propagators=None,
+) -> CompiledModel:
+    ir = compiled.ir
+    selected_particles = ir.particles if particles is None else tuple(particles)
+    selected_propagators = (
+        ir.propagators if propagators is None else tuple(propagators)
+    )
+    goldstone_partners = compile_goldstone_partner_records(
+        selected_particles,
+        ir.parameters,
+        selected_propagators,
+    )
+    return replace(
+        compiled,
+        ir=replace(
+            ir,
+            particles=selected_particles,
+            propagators=selected_propagators,
+            goldstone_partners=goldstone_partners,
+        ),
+    )
+
+
+def test_packaged_external_sm_uses_unique_absorbing_goldstone_contract(
+    compiled_external_sm: CompiledModel,
+) -> None:
+    model = CompiledUFOModel(compiled_external_sm)
+
+    assert model.inactive_goldstone_names == frozenset({"G0", "G+", "G-"})
+    assert {
+        (record.goldstone, record.vector, record.policy)
+        for record in compiled_external_sm.ir.goldstone_partners
+    } == {
+        ("G0", "Z", "absorbed"),
+        ("G+", "W+", "absorbed"),
+        ("G-", "W-", "absorbed"),
+    }
+    assert len(model.vertices) == 499
+    assert sum(
+        not model._kernel(vertex.kind).vertex.endswith("::u1-subtraction")
+        for vertex in model.vertices
+    ) == 469
+    for particle_id in (23, 24, -24):
+        propagator = model._propagator_ir(particle_id)
+        assert propagator.kind == "vector"
+        assert propagator.mass_class == "massive"
+        assert propagator.gauge == "unitary"
+        assert propagator.goldstone_policy == "absorbed"
+
+
+def test_goldstone_contract_round_trips_losslessly(
+    compiled_external_sm: CompiledModel,
+) -> None:
+    payload = compiled_external_sm.ir.to_dict()
+
+    assert CompiledModelIR.from_dict(payload) == compiled_external_sm.ir
+
+
+def test_equivalent_resolved_mass_alias_matches_vector(
+    compiled_external_sm: CompiledModel,
+) -> None:
+    mz = next(
+        parameter
+        for parameter in compiled_external_sm.ir.parameters
+        if parameter.name == "MZ"
+    )
+    alias = replace(
+        mz,
+        name="MZ_ALIAS",
+        nature="internal",
+        expression=mz.resolved_expression,
+        lhablock=None,
+        lhacode=(),
+    )
+    particles = tuple(
+        replace(
+            particle,
+            pdg_code=700_003,
+            mass=alias.name,
+            width="WZ",
+            goldstoneboson=True,
+        )
+        if particle.name == "H"
+        else particle
+        for particle in compiled_external_sm.ir.particles
+    )
+
+    records = compile_goldstone_partner_records(
+        particles,
+        (*compiled_external_sm.ir.parameters, alias),
+        compiled_external_sm.ir.propagators,
+    )
+
+    h_contract = next(record for record in records if record.goldstone == "H")
+    assert (h_contract.vector, h_contract.policy) == ("Z", "absorbed")
+
+
+def test_declared_unrelated_scalar_uses_supported_unique_match_contract(
+    compiled_external_sm: CompiledModel,
+) -> None:
+    # No compiled partner relation ties H to Z. Marking the arbitrary-PDG scalar
+    # as a Goldstone makes the unique absorbing-vector match the supported proof.
+    particles = tuple(
+        replace(
+            particle,
+            pdg_code=700_001,
+            mass="MZ",
+            width="WZ",
+            goldstoneboson=True,
+        )
+        if particle.name == "H"
+        else particle
+        for particle in compiled_external_sm.ir.particles
+    )
+    compiled = _replace_compiled_ir(compiled_external_sm, particles=particles)
+
+    model = CompiledUFOModel(compiled)
+    declared_goldstone = next(
+        particle for particle in particles if particle.name == "H"
+    )
+    vector = next(particle for particle in particles if particle.name == "Z")
+
+    assert declared_goldstone.pdg_code == 700_001
+    assert (
+        declared_goldstone.mass,
+        declared_goldstone.color,
+        declared_goldstone.charge,
+    ) == (vector.mass, vector.color, vector.charge)
+    contract = model._goldstone_partner_records[declared_goldstone.name]
+    assert (contract.vector, contract.policy) == ("Z", "absorbed")
+    assert "H" in model.inactive_goldstone_names
+    assert not any(700_001 in vertex.particles for vertex in model.vertices)
+
+
+def test_unflagged_unrelated_scalar_is_not_absorbed_by_degenerate_vector(
+    compiled_external_sm: CompiledModel,
+) -> None:
+    particles = tuple(
+        replace(
+            particle,
+            pdg_code=700_002,
+            mass="MZ",
+            width="WZ",
+        )
+        if particle.name == "H"
+        else particle
+        for particle in compiled_external_sm.ir.particles
+    )
+    compiled = _replace_compiled_ir(compiled_external_sm, particles=particles)
+
+    model = CompiledUFOModel(compiled)
+    unrelated_scalar = next(particle for particle in particles if particle.name == "H")
+    vector = next(particle for particle in particles if particle.name == "Z")
+
+    assert unrelated_scalar.goldstoneboson is False
+    assert (
+        unrelated_scalar.mass,
+        unrelated_scalar.color,
+        unrelated_scalar.charge,
+    ) == (vector.mass, vector.color, vector.charge)
+    assert "H" not in model.inactive_goldstone_names
+    assert any(700_002 in vertex.particles for vertex in model.vertices)
+
+
+def test_ambiguous_degenerate_absorbing_vectors_fail_closed(
+    compiled_external_sm: CompiledModel,
+) -> None:
+    particles = tuple(
+        replace(
+            particle,
+            pdg_code=900_001,
+            mass="MZ",
+            width="WZ",
+        )
+        if particle.name == "a"
+        else particle
+        for particle in compiled_external_sm.ir.particles
+    )
+    with pytest.raises(
+        ValueError,
+        match=r"Goldstone 'G0' ambiguously matches vectors \['a', 'Z'\]",
+    ):
+        _replace_compiled_ir(compiled_external_sm, particles=particles)
+
+
+def test_custom_vector_propagator_does_not_absorb_a_goldstone(
+    compiled_external_sm: CompiledModel,
+) -> None:
+    propagators = tuple(
+        replace(propagator, custom=True) if propagator.particle == "Z" else propagator
+        for propagator in compiled_external_sm.ir.propagators
+    )
+    compiled = _replace_compiled_ir(
+        compiled_external_sm,
+        propagators=propagators,
+    )
+
+    model = CompiledUFOModel(compiled)
+
+    assert model._propagator_ir(23).kind == "custom"
+    assert model._propagator_ir(23).goldstone_policy == "model-supplied"
+    assert model._goldstone_partner_records["G0"].policy == "model-supplied"
+    assert model.inactive_goldstone_names == frozenset({"G+", "G-"})
+    assert any(250 in vertex.particles for vertex in model.vertices)
diff --git a/pyamplicol/tests/unit/test_external_model_independence.py b/pyamplicol/tests/unit/test_external_model_independence.py
new file mode 100644
index 0000000000..584acd3973
--- /dev/null
+++ b/pyamplicol/tests/unit/test_external_model_independence.py
@@ -0,0 +1,493 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import pytest
+
+from pyamplicol.color.plan import build_color_plan
+from pyamplicol.generation.dag_color import ColorEngine
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.models.base import Model, Particle, QuantumNumberFlow, Vertex
+from pyamplicol.models.contracts import (
+    CompiledModelIR,
+    CompiledParameterRecord,
+    CompiledParticleRecord,
+)
+from pyamplicol.processes.model import (
+    ModelParticleCatalog,
+    build_model_process_ir,
+    expand_model_processes,
+)
+
+
+def _particle(
+    name: str,
+    antiname: str,
+    pdg: int,
+    *,
+    spin: int,
+    color: int,
+    mass: str = "ZERO",
+    charge: float = 0.0,
+    exact_charge: str = "0",
+    component_dimension: int | None = None,
+    auxiliary_kind: str | None = None,
+    ghost_number: int = 0,
+    propagating: bool = True,
+    goldstoneboson: bool = False,
+) -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=antiname,
+        pdg_code=pdg,
+        spin=spin,
+        color=color,
+        mass=mass,
+        width="ZERO",
+        charge=charge,
+        quantum_numbers=(("electric_charge", exact_charge),),
+        ghost_number=ghost_number,
+        propagating=propagating,
+        goldstoneboson=goldstoneboson,
+        propagator=None,
+        component_dimension=component_dimension,
+        auxiliary_kind=auxiliary_kind,
+    )
+
+
+def _model(*particles: CompiledParticleRecord) -> CompiledModelIR:
+    return CompiledModelIR(
+        name="renamed-gauge-model",
+        orders=(),
+        parameters=(),
+        particles=particles,
+        couplings=(),
+        propagators=(),
+        vertex_terms=(),
+        oriented_kernels=(),
+        direct_contractions=(),
+        closure_contractions=(),
+    )
+
+
+class _RecordBackedBoundaryModel(Model):
+    def __init__(
+        self,
+        records: tuple[CompiledParticleRecord, ...],
+        *,
+        vertices: tuple[Vertex, ...] = (),
+        trace_reflection_proven: bool = False,
+    ) -> None:
+        records_by_name = {record.name: record for record in records}
+        self._records = {record.pdg_code: record for record in records}
+        self._trace_reflection_proven = trace_reflection_proven
+        particles = {
+            record.pdg_code: Particle(
+                pdg=record.pdg_code,
+                anti_pdg=records_by_name[record.antiname].pdg_code,
+                spin=record.spin,
+                dimension=record.component_dimension
+                or {1: 1, 2: 4, 3: 4, 5: 16}.get(record.spin, 1),
+                color_rep=record.color,
+                charge=record.charge,
+            )
+            for record in records
+        }
+        super().__init__(
+            name="record-backed-external-model",
+            particles=particles,
+            vertices=vertices,
+        )
+
+    def color_rep(self, pdg: int) -> int:
+        return self._records[int(pdg)].color
+
+    def is_fermion(self, pdg: int) -> bool:
+        return self._records[int(pdg)].statistics == "fermion"
+
+    def is_chiral_eligible(self, pdg: int) -> bool:
+        del pdg
+        return False
+
+    def is_fundamental_colored_fermion(self, pdg: int) -> bool:
+        record = self._records[int(pdg)]
+        return record.statistics == "fermion" and abs(record.color) == 3
+
+    def is_massless_adjoint_vector(self, pdg: int) -> bool:
+        record = self._records[int(pdg)]
+        return (
+            record.wavefunction_family == "vector"
+            and record.color_role == "adjoint"
+            and record.mass.casefold() == "zero"
+        )
+
+    def auxiliary_kind(self, particle_id: int) -> str | None:
+        return self._records[int(particle_id)].auxiliary_kind
+
+    def quantum_number_flow(self, particle_id: int) -> QuantumNumberFlow:
+        return self._records[int(particle_id)].quantum_numbers
+
+    def lc_trace_reflection_equivalence_is_proven(self, process: object) -> bool:
+        del process
+        return self._trace_reflection_proven
+
+
+def test_external_process_roles_do_not_depend_on_sm_names_or_pdgs() -> None:
+    model = _model(
+        _particle("chi", "chi_bar", 810_001, spin=2, color=3),
+        _particle("chi_bar", "chi", -810_001, spin=2, color=-3),
+        _particle("octet_vector", "octet_vector", 910_101, spin=3, color=8),
+        _particle("neutral_scalar", "neutral_scalar", 710_001, spin=1, color=1),
+    )
+
+    process = build_model_process_ir(
+        "chi chi_bar > neutral_scalar octet_vector",
+        model,
+    )
+
+    assert process.outgoing_pdgs == (-810_001, 810_001, 710_001, 910_101)
+    assert process.fundamental_labels == (2,)
+    assert process.antifundamental_labels == (1,)
+    assert process.adjoint_labels == (4,)
+    assert process.singlet_labels == (3,)
+    assert process.color_endpoints.pair_count == 1
+    assert tuple(leg.statistics for leg in process.legs) == (
+        "fermion",
+        "fermion",
+        "boson",
+        "boson",
+    )
+    assert tuple(leg.wavefunction_family for leg in process.legs) == (
+        "fermion",
+        "fermion",
+        "scalar",
+        "vector",
+    )
+    assert tuple(leg.color_role for leg in process.legs) == (
+        "antifundamental",
+        "fundamental",
+        "singlet",
+        "adjoint",
+    )
+    assert tuple(leg.source_orientation for leg in process.legs) == (
+        "antiparticle",
+        "particle",
+        "self-conjugate",
+        "self-conjugate",
+    )
+    by_name = {particle.name: particle for particle in model.particles}
+    assert by_name["chi"].statistics == "fermion"
+    assert by_name["chi"].color_role == "fundamental"
+    assert by_name["chi"].source_orientation == "particle"
+    assert by_name["chi_bar"].source_orientation == "antiparticle"
+    assert by_name["octet_vector"].wavefunction_family == "vector"
+    assert by_name["octet_vector"].self_conjugate is True
+
+
+def test_default_parton_aliases_are_derived_from_particle_metadata() -> None:
+    particles = (
+        _particle("octet_vector", "octet_vector", 910_101, spin=3, color=8),
+        _particle("chi", "chi_bar", 810_001, spin=2, color=3),
+        _particle("chi_bar", "chi", -810_001, spin=2, color=-3),
+        _particle(
+            "heavy_colored",
+            "heavy_colored_bar",
+            810_002,
+            spin=2,
+            color=3,
+            mass="MHEAVY",
+        ),
+        _particle(
+            "restricted_massless",
+            "restricted_massless_bar",
+            810_003,
+            spin=2,
+            color=3,
+            mass="MRESTRICTED",
+        ),
+        _particle(
+            "mutable_zero",
+            "mutable_zero_bar",
+            810_004,
+            spin=2,
+            color=3,
+            mass="MMUTABLE",
+        ),
+        _particle("singlet", "singlet", 710_001, spin=1, color=1),
+    )
+    parameters = (
+        CompiledParameterRecord(
+            name="MRESTRICTED",
+            nature="internal",
+            parameter_type="real",
+            value=None,
+            expression="0",
+            resolved_expression="0",
+            lhablock=None,
+            lhacode=(),
+        ),
+        CompiledParameterRecord(
+            name="MMUTABLE",
+            nature="external",
+            parameter_type="real",
+            value=(0.0, 0.0),
+            expression=None,
+            resolved_expression="0",
+            lhablock="MASS",
+            lhacode=(810_004,),
+        ),
+    )
+
+    aliases = ModelParticleCatalog(
+        "arbitrary-model-name",
+        particles,
+        parameters,
+    ).default_multiparticles()
+
+    assert aliases == {
+        "p": ("octet_vector", "chi", "chi_bar", "restricted_massless"),
+        "j": ("octet_vector", "chi", "chi_bar", "restricted_massless"),
+        "all": (
+            "octet_vector",
+            "chi",
+            "chi_bar",
+            "heavy_colored",
+            "restricted_massless",
+            "mutable_zero",
+            "singlet",
+        ),
+    }
+
+
+def test_all_alias_keeps_only_physical_external_particles_in_order() -> None:
+    physical = _particle("physical", "physical", 710_101, spin=1, color=1)
+    ghost = _particle("ghost", "ghost", 710_102, spin=1, color=1, ghost_number=1)
+    goldstone = _particle(
+        "goldstone", "goldstone", 710_103, spin=1, color=1, goldstoneboson=True
+    )
+    nonpropagating = _particle(
+        "nonpropagating",
+        "nonpropagating",
+        710_104,
+        spin=1,
+        color=1,
+        propagating=False,
+    )
+    auxiliary = _particle(
+        "auxiliary",
+        "auxiliary",
+        710_105,
+        spin=1,
+        color=1,
+        auxiliary_kind="synthetic-contact-current",
+    )
+    second = _particle("second", "second", 710_106, spin=1, color=1)
+
+    catalog = ModelParticleCatalog(
+        "external-filter-model",
+        (physical, ghost, goldstone, nonpropagating, auxiliary, second),
+    )
+
+    assert tuple(particle.name for particle in catalog.external_particles) == (
+        "physical",
+        "second",
+    )
+    assert catalog.default_multiparticles() == {"all": ("physical", "second")}
+
+
+def test_explicit_multiparticles_extend_defaults_and_can_override_all() -> None:
+    particles = (
+        _particle("parton", "parton", 810_101, spin=3, color=8),
+        _particle("first", "first", 710_101, spin=1, color=1),
+        _particle("second", "second", 710_102, spin=1, color=1),
+    )
+    catalog = ModelParticleCatalog("override-model", particles)
+
+    assert expand_model_processes(
+        "beam beam > all",
+        catalog,
+        multiparticles={"beam": ("parton",)},
+    ) == (
+        "parton parton > parton",
+        "parton parton > first",
+        "parton parton > second",
+    )
+    assert expand_model_processes(
+        "p p > all",
+        catalog,
+        multiparticles={"all": ("second",)},
+    ) == ("parton parton > second",)
+
+
+@pytest.mark.parametrize(
+    ("particle", "process"),
+    (
+        (
+            _particle(
+                "fundamental_scalar",
+                "fundamental_scalar_bar",
+                710_011,
+                spin=1,
+                color=3,
+            ),
+            "fundamental_scalar fundamental_scalar_bar > neutral",
+        ),
+        (
+            _particle("adjoint_scalar", "adjoint_scalar", 710_012, spin=1, color=8),
+            "adjoint_scalar adjoint_scalar > neutral",
+        ),
+    ),
+)
+def test_colored_spin_does_not_imply_an_sm_particle_family(
+    particle: CompiledParticleRecord,
+    process: str,
+) -> None:
+    antiparticle = (
+        particle
+        if particle.name == particle.antiname
+        else _particle(
+            particle.antiname,
+            particle.name,
+            -particle.pdg_code,
+            spin=particle.spin,
+            color=-particle.color,
+        )
+    )
+    model = _model(
+        particle,
+        *(() if antiparticle is particle else (antiparticle,)),
+        _particle("neutral", "neutral", 710_013, spin=1, color=1),
+    )
+
+    with pytest.raises(ValueError, match="unsupported colored external-state role"):
+        build_model_process_ir(process, model)
+
+
+def test_sm_like_pdgs_and_fractional_charges_use_only_external_metadata() -> None:
+    fundamental = _particle(
+        "fundamental_21",
+        "antifundamental_21",
+        21,
+        spin=2,
+        color=3,
+        charge=0.2,
+        exact_charge="1/5",
+    )
+    antifundamental = _particle(
+        "antifundamental_21",
+        "fundamental_21",
+        -21,
+        spin=2,
+        color=-3,
+        charge=-0.2,
+        exact_charge="-1/5",
+    )
+    adjoint = _particle("adjoint_1", "adjoint_1", 1, spin=3, color=8)
+    scalar = _particle(
+        "scalar_24",
+        "antiscalar_24",
+        24,
+        spin=1,
+        color=1,
+        charge=0.2,
+        exact_charge="1/5",
+    )
+    antiscalar = _particle(
+        "antiscalar_24",
+        "scalar_24",
+        -24,
+        spin=1,
+        color=1,
+        charge=-0.2,
+        exact_charge="-1/5",
+    )
+    unrelated_auxiliary = _particle(
+        "unrelated_auxiliary_99",
+        "unrelated_auxiliary_99",
+        99,
+        spin=-1,
+        color=1,
+        charge=0.2,
+    )
+    model = _model(
+        fundamental,
+        antifundamental,
+        adjoint,
+        scalar,
+        antiscalar,
+        unrelated_auxiliary,
+    )
+    catalog = ModelParticleCatalog(model.name, model.particles)
+
+    process = build_model_process_ir(
+        "fundamental_21 antifundamental_21 > adjoint_1 scalar_24",
+        model,
+    )
+
+    assert process.outgoing_pdgs == (-21, 21, 1, 24)
+    assert process.antifundamental_labels == (1,)
+    assert process.fundamental_labels == (2,)
+    assert process.adjoint_labels == (3,)
+    assert process.singlet_labels == (4,)
+    assert fundamental.charge == pytest.approx(0.2)
+    assert scalar.charge == pytest.approx(0.2)
+    assert catalog.default_multiparticles() == {
+        "p": ("fundamental_21", "antifundamental_21", "adjoint_1"),
+        "j": ("fundamental_21", "antifundamental_21", "adjoint_1"),
+        "all": (
+            "fundamental_21",
+            "antifundamental_21",
+            "adjoint_1",
+            "scalar_24",
+            "antiscalar_24",
+        ),
+    }
+    assert unrelated_auxiliary.statistics == "auxiliary"
+    assert unrelated_auxiliary not in catalog.external_particles
+    with pytest.raises(ValueError, match="is not an external state"):
+        catalog.resolve(unrelated_auxiliary.name)
+
+    auxiliary_vertex = Vertex(701, (21, -21, 99))
+    boundary_model = _RecordBackedBoundaryModel(
+        model.particles,
+        vertices=(auxiliary_vertex,),
+    )
+    color_engine = ColorEngine(build_color_plan(process), boundary_model)
+
+    assert color_engine._particle_has_colour(99) is False
+    assert color_engine.vertex_allowed(auxiliary_vertex) is True
+
+
+def test_pure_adjoint_lc_reflection_folding_requires_explicit_model_proof() -> None:
+    adjoint = _particle(
+        "external_adjoint",
+        "external_adjoint",
+        910_101,
+        spin=3,
+        color=8,
+    )
+    model_ir = _model(adjoint)
+    process = build_model_process_ir(
+        "external_adjoint external_adjoint > "
+        "external_adjoint external_adjoint external_adjoint",
+        model_ir,
+    )
+    default_plan = build_color_plan(process)
+
+    unproven = compile_generic_dag(
+        process,
+        model=_RecordBackedBoundaryModel(model_ir.particles),
+    )
+    proven = compile_generic_dag(
+        process,
+        model=_RecordBackedBoundaryModel(
+            model_ir.particles,
+            trace_reflection_proven=True,
+        ),
+    )
+
+    assert default_plan.trace_reflections_folded is False
+    assert default_plan.sector_count == 24
+    assert unproven.color_plan.trace_reflections_folded is False
+    assert unproven.color_plan.sector_count == 24
+    assert proven.color_plan.trace_reflections_folded is True
+    assert proven.color_plan.sector_count == 12
diff --git a/pyamplicol/tests/unit/test_external_recurrence_closure_contract.py b/pyamplicol/tests/unit/test_external_recurrence_closure_contract.py
new file mode 100644
index 0000000000..4cc019f536
--- /dev/null
+++ b/pyamplicol/tests/unit/test_external_recurrence_closure_contract.py
@@ -0,0 +1,136 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+
+import pytest
+
+from pyamplicol.models.base import RecurrenceLCColorShapeKind, Vertex
+from pyamplicol.models.compiler_color_flow import (
+    compile_lc_color_transition_terms,
+)
+from pyamplicol.models.contracts import CompiledOrientedKernel
+from pyamplicol.models.external_catalog import ExternalModelCatalogMixin
+
+
+class _ExternalCatalog(ExternalModelCatalogMixin):
+    def __init__(
+        self,
+        kernel: CompiledOrientedKernel,
+        shapes: dict[int, RecurrenceLCColorShapeKind],
+    ) -> None:
+        self._kernels = {kernel.kind: kernel}
+        self._shapes = shapes
+
+    def _kernel(self, kind: int) -> CompiledOrientedKernel:
+        return self._kernels[kind]
+
+    def recurrence_lc_color_shape_contract(
+        self,
+        particle_id: int,
+        chirality: int = 0,
+    ) -> RecurrenceLCColorShapeKind:
+        del chirality
+        return self._shapes[particle_id]
+
+
+def _compiled_kernel(
+    structure: str,
+    representations: tuple[int, int, int],
+) -> CompiledOrientedKernel:
+    kernel = CompiledOrientedKernel(
+        kind=7,
+        term_id=3,
+        vertex="V_1",
+        particles=("left", "right", "result"),
+        source_particle_legs=(0, 1, 2),
+        component_expressions=("1",),
+        coupling_expression="1",
+        coupling_orders=(),
+        runtime_parameters=(),
+        color_source="exact-color-source",
+        color_expression="exact-color-expression",
+        color_projection_structure=structure,
+        color_projection_coefficient=(1.0, 0.0),
+    )
+    terms = compile_lc_color_transition_terms(
+        kernel,
+        representations,
+        proof_source="test-exact-projection",
+        provenance=(("model-compiler", "test"),),
+    )
+    return replace(kernel, lc_color_transition_terms=terms)
+
+
+@pytest.mark.parametrize(
+    ("structure", "representations", "shapes", "closure_kind"),
+    (
+        (
+            "color-identity",
+            (3, -3, 1),
+            {
+                1: "fundamental-open-string",
+                2: "antifundamental-open-string",
+                3: "singlet-forest",
+            },
+            "open-string",
+        ),
+        (
+            "adjoint-structure-constant",
+            (8, 8, 8),
+            {1: "adjoint-segment", 2: "adjoint-segment", 3: "adjoint-segment"},
+            "trace",
+        ),
+        (
+            "singlet",
+            (1, 1, 1),
+            {1: "singlet-forest", 2: "singlet-forest", 3: "singlet-forest"},
+            None,
+        ),
+    ),
+)
+def test_external_catalog_consumes_compiler_owned_lc_closure_terms(
+    structure: str,
+    representations: tuple[int, int, int],
+    shapes: dict[int, RecurrenceLCColorShapeKind],
+    closure_kind: str | None,
+) -> None:
+    kernel = _compiled_kernel(structure, representations)
+    catalog = _ExternalCatalog(kernel, shapes)
+
+    contract = catalog.recurrence_lc_color_transition_contract(
+        Vertex(7, (1, 2, 3)),
+        closure=True,
+    )
+
+    assert contract.rule_kind == structure
+    assert len(contract.witnesses) == 1
+    witness = contract.witnesses[0]
+    assert witness.component_operation == "close"
+    assert witness.result_component_kind == closure_kind
+    assert witness.result_component_role == "none"
+    assert witness.exact_factor == (1.0, 0.0)
+    assert ("contract-kind", "closure") in witness.provenance
+    assert ("model-compiler", "test") in witness.provenance
+
+
+def test_old_external_bundle_fails_recurrence_closure_preflight_clearly() -> None:
+    kernel = _compiled_kernel("color-identity", (3, -3, 1))
+    old_kernel = replace(kernel, lc_color_closure_terms=())
+    catalog = _ExternalCatalog(
+        old_kernel,
+        {
+            1: "fundamental-open-string",
+            2: "antifundamental-open-string",
+            3: "singlet-forest",
+        },
+    )
+
+    with pytest.raises(
+        NotImplementedError,
+        match=r"no compiler-owned LC color closure terms.*model compile",
+    ):
+        catalog.recurrence_lc_color_transition_contract(
+            Vertex(7, (1, 2, 3)),
+            closure=True,
+        )
diff --git a/pyamplicol/tests/unit/test_external_spin2_contraction.py b/pyamplicol/tests/unit/test_external_spin2_contraction.py
new file mode 100644
index 0000000000..689ccf0bab
--- /dev/null
+++ b/pyamplicol/tests/unit/test_external_spin2_contraction.py
@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pyamplicol.generation.stage_expressions import _amplitude_root_expression
+from pyamplicol.models.base import Model
+from pyamplicol.models.compiler_contractions import compile_contraction_records
+from pyamplicol.models.contracts import CompiledParticleRecord
+
+
+def _spin2_particle() -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name="tensor",
+        antiname="tensor",
+        pdg_code=910_005,
+        spin=5,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def test_external_spin2_direct_contraction_uses_rank_two_lorentz_metric() -> None:
+    direct, closure = compile_contraction_records((_spin2_particle(),), (), ())
+
+    assert closure == ()
+    assert len(direct) == 1
+    record = direct[0]
+    assert record.selector == ("tensor", 0, "tensor", 0)
+    assert record.contraction_ir.name == "lorentz-rank-2"
+    assert record.contraction_ir.left_basis == "lorentz-rank-2"
+    assert record.contraction_ir.right_basis == "lorentz-rank-2"
+    assert record.contraction_ir.metric_signature == (
+        "mostly-minus-tensor-product"
+    )
+
+    metric = (1.0, -1.0, -1.0, -1.0)
+    expected_coefficients = tuple(
+        (metric[mu] * metric[nu], 0.0)
+        for mu in range(4)
+        for nu in range(4)
+    )
+    assert record.contraction_ir.coefficients == expected_coefficients
+
+    left = tuple(float(index + 1) for index in range(16))
+    right = (1.0,) * 16
+    root = {
+        "kind": "direct-contraction",
+        "left_value_slot": {
+            "value_slot_id": 0,
+            "component_start": 0,
+            "component_stop": 16,
+            "dimension": 16,
+        },
+        "right_value_slot": {
+            "value_slot_id": 1,
+            "component_start": 16,
+            "component_stop": 32,
+            "dimension": 16,
+        },
+        "coupling": [1.0, 0.0],
+        "color_weight": [1.0, 0.0],
+        "contraction": record.contraction_ir.name,
+        "contraction_ir": record.contraction_ir.to_json_dict(),
+    }
+    value_slots = {
+        0: {
+            "value_slot_id": 0,
+            "dimension": 16,
+            "chirality": 0,
+            "propagator": {"basis": "lorentz-rank-2"},
+        },
+        1: {
+            "value_slot_id": 1,
+            "dimension": 16,
+            "chirality": 0,
+            "propagator": {"basis": "lorentz-rank-2"},
+        },
+    }
+
+    result = _amplitude_root_expression(
+        Model(name="external-spin2-contraction-probe"),
+        root,
+        value_symbols={0: left, 1: right},
+        model_parameter_symbols={},
+        value_slots=value_slots,
+    )
+
+    assert result == sum(
+        coefficient[0] * component
+        for coefficient, component in zip(
+            expected_coefficients,
+            left,
+            strict=True,
+        )
+    )
diff --git a/pyamplicol/tests/unit/test_external_symmetry_certificates.py b/pyamplicol/tests/unit/test_external_symmetry_certificates.py
new file mode 100644
index 0000000000..3e840ba903
--- /dev/null
+++ b/pyamplicol/tests/unit/test_external_symmetry_certificates.py
@@ -0,0 +1,1192 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from copy import deepcopy
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.generation.dag_algorithms import (
+    infer_minimal_coupling_order_limits,
+)
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_equivalence import (
+    _derive_current_value_equivalences,
+    assign_recursive_current_evaluation_reuse,
+)
+from pyamplicol.generation.dag_types import CurrentNode
+from pyamplicol.models import BuiltinSMModel, CompiledUFOModel, compile_model_source
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.compiler_contacts import _four_point_contact_color_split
+from pyamplicol.models.compiler_entry import (
+    _annotate_oriented_kernel_evaluation_equivalence,
+    _term_supports_transverse_massless_yang_mills,
+)
+from pyamplicol.models.compiler_tensor_ordering import (
+    compile_tensor_ordering_metadata,
+)
+from pyamplicol.models.contracts import (
+    CompiledModelIR,
+    CompiledOrientedKernel,
+    CompiledParticleRecord,
+)
+from pyamplicol.models.external_symmetries import (
+    _tensor_product_signature,
+    derive_external_symmetry_certificates,
+)
+from pyamplicol.processes.model import build_model_process_ir
+
+MODEL_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+
+_EXTERNAL_SM_TOPOLOGY_LADDER = (
+    "d d~ > z",
+    "u d~ > w+",
+    "d d~ > z g",
+    "d d~ > e- e+",
+    "u d~ > e+ ve",
+    "d d~ > z z",
+    "d d~ > u u~",
+    "d d~ > d d~",
+    "g g > g g",
+    "g g > t t~",
+    "d d~ > t t~",
+    "d d~ > z g g",
+    "g g > t t~ g",
+    "g g > g g g",
+    "d d~ > t t~ g g",
+    "g g > t t~ g g g",
+    "d d~ > t t~ g g g",
+    "d d~ > z z z",
+    "d d~ > e+ e- z h",
+    "d d~ > t t~ z h",
+    "d d~ > e+ e- e+ e-",
+    "d d~ > u u~ s s~",
+)
+
+
+def _replace_model_with_recompiled_tensor_metadata(
+    model: CompiledModelIR,
+    *,
+    vertex_terms,
+    oriented_kernels,
+) -> CompiledModelIR:
+    terms, kernels, orderings, current_orderings = compile_tensor_ordering_metadata(
+        vertex_terms,
+        model.particles,
+        oriented_kernels,
+        model.parameters,
+        model.propagators,
+    )
+    return replace(
+        model,
+        vertex_terms=terms,
+        oriented_kernels=kernels,
+        tensor_orderings=orderings,
+        current_orderings=current_orderings,
+    )
+
+
+@pytest.fixture(scope="module")
+def external_sm():
+    compiled = compile_model_source(
+        MODEL_ROOT / "sm.json",
+        restriction=str((MODEL_ROOT / "restrict_default.json").resolve()),
+        use_cache=False,
+    )
+    return compiled, CompiledUFOModel(compiled)
+
+
+@pytest.fixture(scope="module")
+def relabelled_external_sm(tmp_path_factory: pytest.TempPathFactory):
+    raw = json.loads((MODEL_ROOT / "sm.json").read_text(encoding="utf-8"))
+    relabelled = deepcopy(raw)
+    absolute_ids = sorted(
+        {abs(int(particle["pdg_code"])) for particle in relabelled["particles"]}
+    )
+    replacements = {
+        particle_id: 700_000 + index
+        for index, particle_id in enumerate(absolute_ids, start=1)
+    }
+    for particle in relabelled["particles"]:
+        pdg = int(particle["pdg_code"])
+        particle["pdg_code"] = (
+            replacements[abs(pdg)] if pdg >= 0 else -replacements[abs(pdg)]
+        )
+
+    model_root = tmp_path_factory.mktemp("relabelled-external-sm")
+    model_path = model_root / "sm.json"
+    restriction_path = model_root / "restrict_default.json"
+    model_path.write_text(
+        json.dumps(relabelled, sort_keys=True, separators=(",", ":")) + "\n",
+        encoding="utf-8",
+    )
+    restriction_path.write_bytes((MODEL_ROOT / "restrict_default.json").read_bytes())
+    compiled = compile_model_source(
+        model_path,
+        restriction=str(restriction_path.resolve()),
+        use_cache=False,
+    )
+    return compiled, CompiledUFOModel(compiled)
+
+
+@pytest.fixture(scope="module")
+def reordered_external_sm(tmp_path_factory: pytest.TempPathFactory):
+    raw = json.loads((MODEL_ROOT / "sm.json").read_text(encoding="utf-8"))
+    reordered = deepcopy(raw)
+    for field in (
+        "orders",
+        "particles",
+        "couplings",
+        "lorentz_structures",
+        "propagators",
+        "functions",
+        "form_factors",
+        "vertex_rules",
+    ):
+        reordered[field] = list(reversed(reordered[field]))
+    for vertex in reordered["vertex_rules"]:
+        colors = vertex["color_structures"]
+        lorentz = vertex["lorentz_structures"]
+        coupling_matrix = vertex["couplings"]
+        color_order = tuple(reversed(range(len(colors))))
+        lorentz_order = tuple(reversed(range(len(lorentz))))
+        vertex["color_structures"] = [colors[index] for index in color_order]
+        vertex["lorentz_structures"] = [lorentz[index] for index in lorentz_order]
+        vertex["couplings"] = [
+            [coupling_matrix[row][column] for column in lorentz_order]
+            for row in color_order
+        ]
+
+    model_root = tmp_path_factory.mktemp("reordered-external-sm")
+    model_path = model_root / "sm.json"
+    restriction_path = model_root / "restrict_default.json"
+    model_path.write_text(
+        json.dumps(reordered, sort_keys=True, separators=(",", ":")) + "\n",
+        encoding="utf-8",
+    )
+    restriction_path.write_bytes((MODEL_ROOT / "restrict_default.json").read_bytes())
+    compiled = compile_model_source(
+        model_path,
+        restriction=str(restriction_path.resolve()),
+        use_cache=False,
+    )
+    return compiled, CompiledUFOModel(compiled)
+
+
+@pytest.fixture(scope="module")
+def renamed_relabelled_reordered_external_sm(
+    tmp_path_factory: pytest.TempPathFactory,
+):
+    raw = json.loads((MODEL_ROOT / "sm.json").read_text(encoding="utf-8"))
+    transformed = deepcopy(raw)
+    original_names = sorted(str(particle["name"]) for particle in raw["particles"])
+    name_map = {
+        name: f"state_{index:03d}"
+        for index, name in enumerate(original_names, start=1)
+    }
+    absolute_ids = sorted(
+        {abs(int(particle["pdg_code"])) for particle in transformed["particles"]}
+    )
+    pdg_map = {
+        particle_id: 800_000 + index
+        for index, particle_id in enumerate(absolute_ids, start=1)
+    }
+    for particle in transformed["particles"]:
+        particle["name"] = name_map[str(particle["name"])]
+        particle["antiname"] = name_map[str(particle["antiname"])]
+        pdg = int(particle["pdg_code"])
+        particle["pdg_code"] = pdg_map[abs(pdg)] if pdg >= 0 else -pdg_map[abs(pdg)]
+    for propagator in transformed["propagators"]:
+        propagator["particle"] = name_map[str(propagator["particle"])]
+    for vertex in transformed["vertex_rules"]:
+        vertex["particles"] = [name_map[str(name)] for name in vertex["particles"]]
+        colors = vertex["color_structures"]
+        lorentz = vertex["lorentz_structures"]
+        coupling_matrix = vertex["couplings"]
+        color_order = tuple(reversed(range(len(colors))))
+        lorentz_order = tuple(reversed(range(len(lorentz))))
+        vertex["color_structures"] = [colors[index] for index in color_order]
+        vertex["lorentz_structures"] = [lorentz[index] for index in lorentz_order]
+        vertex["couplings"] = [
+            [coupling_matrix[row][column] for column in lorentz_order]
+            for row in color_order
+        ]
+    for field in (
+        "orders",
+        "particles",
+        "couplings",
+        "lorentz_structures",
+        "propagators",
+        "functions",
+        "form_factors",
+        "vertex_rules",
+    ):
+        transformed[field] = list(reversed(transformed[field]))
+
+    model_root = tmp_path_factory.mktemp("renamed-relabelled-reordered-external-sm")
+    model_path = model_root / "sm.json"
+    restriction_path = model_root / "restrict_default.json"
+    model_path.write_text(
+        json.dumps(transformed, sort_keys=True, separators=(",", ":")) + "\n",
+        encoding="utf-8",
+    )
+    restriction_path.write_bytes((MODEL_ROOT / "restrict_default.json").read_bytes())
+    compiled = compile_model_source(
+        model_path,
+        restriction=str(restriction_path.resolve()),
+        use_cache=False,
+    )
+    return compiled, CompiledUFOModel(compiled), name_map
+
+
+@pytest.fixture(scope="module")
+def color_dummy_relabelled_external_sm(tmp_path_factory: pytest.TempPathFactory):
+    raw = json.loads((MODEL_ROOT / "sm.json").read_text(encoding="utf-8"))
+    relabelled = deepcopy(raw)
+    vertex = next(
+        item for item in relabelled["vertex_rules"] if item["name"] == "V_37"
+    )
+    vertex["color_structures"] = [
+        "*".join(reversed(source.replace("-1", "-97").split("*")))
+        for source in vertex["color_structures"]
+    ]
+
+    model_root = tmp_path_factory.mktemp("color-dummy-relabelled-external-sm")
+    model_path = model_root / "sm.json"
+    restriction_path = model_root / "restrict_default.json"
+    model_path.write_text(
+        json.dumps(relabelled, sort_keys=True, separators=(",", ":")) + "\n",
+        encoding="utf-8",
+    )
+    restriction_path.write_bytes((MODEL_ROOT / "restrict_default.json").read_bytes())
+    compiled = compile_model_source(
+        model_path,
+        restriction=str(restriction_path.resolve()),
+        use_cache=False,
+    )
+    return compiled, CompiledUFOModel(compiled)
+
+
+def _production_dag_signature(compiled, model, process: str) -> tuple[object, ...]:
+    process_ir = build_model_process_ir(process, compiled.ir)
+    limits = infer_minimal_coupling_order_limits(process_ir, model=model)
+    dag = compile_generic_dag(
+        process_ir,
+        model=model,
+        max_coupling_orders=limits,
+    )
+    return (
+        limits,
+        len(dag.currents),
+        len(dag.interactions),
+        len(dag.amplitude_roots),
+        len(dag.color_plan.sectors),
+        dag.interaction_evaluation_count,
+    )
+
+
+def _rename_process(process: str, name_map: dict[str, str]) -> str:
+    folded_map = {
+        name.casefold(): replacement for name, replacement in name_map.items()
+    }
+    return " ".join(
+        name_map.get(token, folded_map.get(token.casefold(), token))
+        for token in process.split()
+    )
+
+
+def test_external_sm_symmetries_are_proven_from_compiled_tensors(external_sm) -> None:
+    compiled, model = external_sm
+    certificates = model._symmetry_certificates
+
+    assert certificates.yang_mills_adjoint_names == frozenset({"g"})
+    assert len(certificates.yang_mills_kernel_kinds) == 4
+    assert certificates.yang_mills_kernel_kinds <= certificates.parity_kernel_kinds
+    reflection_phases = dict(certificates.adjoint_current_reflection_phases)
+    assert reflection_phases
+    assert set(reflection_phases.values()) == {(-1.0, 0.0)}
+    parity_digests = dict(certificates.parity_kernel_digests)
+    yang_mills_digests = dict(certificates.yang_mills_kernel_digests)
+    adjoint_digests = dict(certificates.yang_mills_adjoint_digests)
+    reflection_digests = dict(
+        certificates.adjoint_current_reflection_digests
+    )
+    assert set(parity_digests) == certificates.parity_kernel_kinds
+    assert set(yang_mills_digests) == certificates.yang_mills_kernel_kinds
+    assert set(adjoint_digests) == certificates.yang_mills_adjoint_names
+    assert set(reflection_digests) == set(reflection_phases)
+    assert all(
+        len(digest) == 64
+        for digest in (
+            *parity_digests.values(),
+            *yang_mills_digests.values(),
+            *adjoint_digests.values(),
+            *reflection_digests.values(),
+        )
+    )
+    assert all(
+        reflection_digests[kind] == parity_digests[kind]
+        for kind in reflection_digests
+    )
+
+    pure_adjoint = build_model_process_ir("g g > g g", compiled.ir)
+    qcd_vertices = tuple(
+        vertex
+        for vertex in model.vertices
+        if vertex.kind in certificates.parity_kernel_kinds
+    )
+    yang_mills_vertices = tuple(
+        vertex
+        for vertex in model.vertices
+        if vertex.kind in certificates.yang_mills_kernel_kinds
+    )
+
+    assert model.global_helicity_flip_equivalence_is_proven(qcd_vertices)
+    assert model.pure_massless_adjoint_helicity_zero_rule_is_proven(
+        pure_adjoint,
+        yang_mills_vertices,
+    )
+    assert model.lc_trace_reflection_equivalence_is_proven(pure_adjoint)
+
+    cubic_kernel = next(
+        kernel
+        for kernel in compiled.ir.oriented_kernels
+        if kernel.particles == ("g", "g", "g")
+    )
+    assert cubic_kernel.evaluation_input_exchange_factor == (-1.0, 0.0)
+    auxiliary_input = next(
+        kernel
+        for kernel in compiled.ir.oriented_kernels
+        if kernel.particles[:2] == ("g", "g")
+        and kernel.kind in certificates.yang_mills_kernel_kinds
+        and kernel.kind != cubic_kernel.kind
+    )
+    assert auxiliary_input.evaluation_input_exchange_factor == (-1.0, 0.0)
+    auxiliary_outputs = tuple(
+        kernel
+        for kernel in compiled.ir.oriented_kernels
+        if kernel.kind in certificates.yang_mills_kernel_kinds
+        and kernel.kind not in {cubic_kernel.kind, auxiliary_input.kind}
+    )
+    assert len(auxiliary_outputs) == 2
+    assert len({kernel.evaluation_class for kernel in auxiliary_outputs}) == 1
+    assert {kernel.evaluation_input_order for kernel in auxiliary_outputs} == {
+        (0, 1),
+        (1, 0),
+    }
+    assert {kernel.evaluation_factor for kernel in auxiliary_outputs} == {
+        (1.0, 0.0),
+        (-1.0, 0.0),
+    }
+
+
+def test_external_kernel_reuse_includes_exact_colour_normalization(external_sm) -> None:
+    from pyamplicol._internal.physics.symbols import symbols
+
+    compiled, _model = external_sm
+    cubic = next(
+        kernel
+        for kernel in compiled.ir.oriented_kernels
+        if kernel.particles == ("g", "g", "g")
+    )
+    different_normalization = replace(
+        cubic, lc_color_normalization_power=cubic.lc_color_normalization_power + 1
+    )
+    annotated = _annotate_oriented_kernel_evaluation_equivalence(
+        (cubic, different_normalization),
+        compiled.ir.particles,
+        compiled.ir.vertex_terms,
+        symbols.model(compiled.ir.name),
+    )
+
+    assert annotated[0].evaluation_class != annotated[1].evaluation_class
+    assert all(kernel.evaluation_equivalence_verified for kernel in annotated)
+
+
+def test_kernel_equivalence_ignores_mirrored_component_factorization() -> None:
+    from pyamplicol._internal.physics.symbols import symbols
+    from pyamplicol.models import compiler_symbolica as sym
+
+    sym._ensure_symbolica()
+    registry = symbols.model("factorized-kernel-proof")
+    particles = tuple(
+        CompiledParticleRecord(
+            name=name,
+            antiname=name,
+            pdg_code=index + 1,
+            spin=3,
+            color=1,
+            mass="ZERO",
+            width="ZERO",
+            charge=0.0,
+            quantum_numbers=(("electric_charge", "0"),),
+            ghost_number=0,
+            propagating=True,
+            goldstoneboson=False,
+            propagator=None,
+        )
+        for index, name in enumerate(("a", "b", "out"))
+    )
+    g, h, imaginary = (sym.E(value) for value in ("g", "h", "\U0001d456"))
+    kernels = []
+    for kind, mirrored in enumerate((False, True)):
+        vector_side, spinor_side = ("right", "left") if mirrored else ("left", "right")
+        a, b, d, e = (
+            registry.kernel_component(kind, vector_side, index) for index in range(4)
+        )
+        x, y = (
+            registry.kernel_component(kind, spinor_side, index) for index in range(2)
+        )
+        common = (a - imaginary * b) * x + (d + e) * y
+        # Released Symbolica 3 can retain these different factorizations for
+        # mirrored Z-antifermion kernels.  Both must certify the same operation.
+        expression = (
+            common * g + (a * x - imaginary * b * x + d * y + e * y) * h
+            if mirrored
+            else common * (g + h)
+        )
+        kernels.append(
+            CompiledOrientedKernel(
+                kind=kind,
+                term_id=0,
+                vertex="factorized-mirror",
+                particles=("b", "a", "out") if mirrored else ("a", "b", "out"),
+                source_particle_legs=(1, 0, 2) if mirrored else (0, 1, 2),
+                component_expressions=(expression.to_canonical_string(), "0", "0", "0"),
+                coupling_expression="1",
+                coupling_orders=(),
+                runtime_parameters=(),
+                color_source="1",
+                color_expression="1",
+            )
+        )
+
+    direct, mirrored = _annotate_oriented_kernel_evaluation_equivalence(
+        kernels, particles, (), registry
+    )
+
+    assert direct.evaluation_class == mirrored.evaluation_class
+    assert direct.evaluation_input_order == mirrored.evaluation_input_order[::-1]
+    assert direct.evaluation_factor == mirrored.evaluation_factor == (1.0, 0.0)
+    assert direct.component_expressions == kernels[0].component_expressions
+    assert mirrored.component_expressions == kernels[1].component_expressions
+
+
+def test_tensor_product_signature_alpha_normalizes_contracted_indices() -> None:
+    left = (
+        "spenso::f(ufo_c_dummy_1_adjoint,ufo_c_1,ufo_c_2)"
+        "*spenso::f(ufo_c_3,ufo_c_4,ufo_c_dummy_1_adjoint)"
+    )
+    right = (
+        "spenso::f(ufo_c_3,ufo_c_4,ufo_c_dummy_97_adjoint)"
+        "*spenso::f(ufo_c_dummy_97_adjoint,ufo_c_1,ufo_c_2)"
+    )
+    assert _tensor_product_signature(left, "1") == _tensor_product_signature(
+        right,
+        "1",
+    )
+
+
+def test_tensor_product_signature_distinguishes_contraction_graphs() -> None:
+    chain = (
+        "spenso::f(ufo_c_1,ufo_c_dummy_2_adjoint,ufo_c_dummy_7_adjoint)"
+        "*spenso::f(ufo_c_dummy_2_adjoint,ufo_c_2,ufo_c_3)"
+        "*spenso::f(ufo_c_dummy_7_adjoint,ufo_c_4,ufo_c_5)"
+    )
+    relabelled_chain = (
+        "spenso::f(ufo_c_dummy_41_adjoint,ufo_c_4,ufo_c_5)"
+        "*spenso::f(ufo_c_1,ufo_c_dummy_99_adjoint,ufo_c_dummy_41_adjoint)"
+        "*spenso::f(ufo_c_dummy_99_adjoint,ufo_c_2,ufo_c_3)"
+    )
+    different = (
+        "spenso::f(ufo_c_1,ufo_c_dummy_2_adjoint,ufo_c_dummy_7_adjoint)"
+        "*spenso::f(ufo_c_dummy_2_adjoint,ufo_c_dummy_7_adjoint,ufo_c_3)"
+        "*spenso::f(ufo_c_2,ufo_c_4,ufo_c_5)"
+    )
+    signature = _tensor_product_signature(chain, "1")
+    assert signature == _tensor_product_signature(relabelled_chain, "1")
+    assert signature != _tensor_product_signature(different, "1")
+
+
+def test_external_sm_color_dummy_relabeling_preserves_yang_mills_reuse(
+    external_sm,
+    color_dummy_relabelled_external_sm,
+) -> None:
+    compiled, model = external_sm
+    relabelled, relabelled_model = color_dummy_relabelled_external_sm
+
+    assert relabelled_model._symmetry_certificates == model._symmetry_certificates
+    assert _production_dag_signature(
+        relabelled,
+        relabelled_model,
+        "g g > g g",
+    ) == _production_dag_signature(compiled, model, "g g > g g")
+
+
+def test_external_sm_four_gluon_contacts_keep_proven_lowering(external_sm) -> None:
+    compiled, _model = external_sm
+    contact_terms = tuple(
+        term
+        for term in compiled.ir.vertex_terms
+        if term.particles == ("g", "g", "g", "g")
+    )
+
+    assert len(contact_terms) == 3
+    assert all(
+        _four_point_contact_color_split(term, result_leg) is not None
+        for term in contact_terms
+        for result_leg in range(4)
+    )
+    contact_term_ids = {term.id for term in contact_terms}
+    assert any(
+        contact_term_ids <= set(kernel.term_ids)
+        for kernel in compiled.ir.oriented_kernels
+    )
+
+
+def test_external_sm_derives_fundamental_fierz_auxiliary(external_sm) -> None:
+    compiled, model = external_sm
+    auxiliaries = tuple(
+        particle
+        for particle in compiled.ir.particles
+        if particle.auxiliary_kind == "u1-subtraction-color-flow-vector"
+    )
+
+    assert len(auxiliaries) == 1
+    auxiliary = auxiliaries[0]
+    assert auxiliary.name == "__pyamplicol_u1_subtraction_g"
+    assert (auxiliary.spin, auxiliary.color, auxiliary.component_dimension) == (
+        3,
+        1,
+        4,
+    )
+    synthetic = tuple(
+        kernel
+        for kernel in compiled.ir.oriented_kernels
+        if kernel.vertex.endswith("::u1-subtraction")
+    )
+    assert len(synthetic) == 30
+    assert all(
+        kernel.color_projection_structure == "color-identity"
+        and auxiliary.name in kernel.particles
+        for kernel in synthetic
+    )
+    assert {
+        kernel.color_projection_coefficient
+        for kernel in synthetic
+        if kernel.particles[2] == auxiliary.name
+    } == {(1.0 / 3.0, 0.0)}
+    assert {
+        kernel.color_projection_coefficient
+        for kernel in synthetic
+        if kernel.particles[2] != auxiliary.name
+    } == {(1.0, 0.0)}
+
+    propagator = model._propagator_ir(auxiliary.pdg_code)
+    assert propagator.kind == "vector"
+    assert propagator.mass_class == "massless"
+    assert propagator.gauge == "feynman"
+    assert propagator.applies_propagator is True
+
+
+@pytest.mark.parametrize(
+    ("process", "topology", "forbidden_order"),
+    (
+        ("g g > t t~", (36, 44, 36, 32), (2, 1)),
+        ("d d~ > z g g", (117, 242, 210, 48), (5, 4)),
+    ),
+)
+def test_external_sm_recovers_builtin_lc_current_reuse(
+    external_sm,
+    process: str,
+    topology: tuple[int, int, int, int],
+    forbidden_order: tuple[int, int],
+) -> None:
+    compiled, external_model = external_sm
+    builtin_dag = compile_generic_dag(
+        build_process_ir(process),
+        model=BuiltinSMModel(),
+    )
+    external_dag = compile_generic_dag(
+        build_model_process_ir(process, compiled.ir),
+        model=external_model,
+    )
+
+    for dag in (builtin_dag, external_dag):
+        assert (
+            len(dag.currents),
+            len(dag.interactions),
+            dag.interaction_evaluation_count,
+            len(dag.amplitude_roots),
+        ) == topology
+        assert all(
+            current.index.ordered_external_labels != forbidden_order
+            for current in dag.currents
+        )
+
+
+@pytest.mark.parametrize("process", _EXTERNAL_SM_TOPOLOGY_LADDER)
+def test_external_sm_matches_builtin_production_dag_topology(
+    external_sm,
+    process: str,
+) -> None:
+    """External SM must recover every built-in production DAG reduction."""
+
+    compiled, external_model = external_sm
+    builtin_model = BuiltinSMModel()
+    builtin_process = build_process_ir(process)
+    external_process = build_model_process_ir(process, compiled.ir)
+    builtin_limits = infer_minimal_coupling_order_limits(
+        builtin_process,
+        model=builtin_model,
+    )
+    external_limits = infer_minimal_coupling_order_limits(
+        external_process,
+        model=external_model,
+    )
+
+    assert external_limits == builtin_limits
+
+    builtin_dag = compile_generic_dag(
+        builtin_process,
+        model=builtin_model,
+        max_coupling_orders=builtin_limits,
+    )
+    external_dag = compile_generic_dag(
+        external_process,
+        model=external_model,
+        max_coupling_orders=external_limits,
+    )
+
+    def topology(dag) -> tuple[int, int, int, int]:
+        return (
+            len(dag.currents),
+            len(dag.interactions),
+            len(dag.amplitude_roots),
+            len(dag.color_plan.sectors),
+        )
+
+    assert topology(external_dag) == topology(builtin_dag)
+    # The external compiler may prove additional exact kernel equivalences,
+    # but it may never lose a reuse relation available to the built-in model.
+    assert (
+        external_dag.interaction_evaluation_count
+        <= builtin_dag.interaction_evaluation_count
+    )
+
+
+def test_route_safe_mixed_line_dag_stays_below_legacy_kernel_count(
+    external_sm,
+) -> None:
+    """Contracted-color SM DAGs remain smaller than the legacy kernel set."""
+
+    compiled, external_model = external_sm
+    builtin_model = BuiltinSMModel()
+    builtin_process = build_process_ir(
+        "d d~ > t t~ g g g",
+        color_accuracy="full",
+    )
+    external_process = build_model_process_ir(
+        "d d~ > t t~ g g g",
+        compiled.ir,
+        color_accuracy="full",
+    )
+    coupling_limits = {"QCD": 5, "QED": 0}
+    builtin_dag = compile_generic_dag(
+        builtin_process,
+        model=builtin_model,
+        max_coupling_orders=coupling_limits,
+    )
+    external_dag = compile_generic_dag(
+        external_process,
+        model=external_model,
+        max_coupling_orders=coupling_limits,
+    )
+
+    assert (
+        len(builtin_dag.currents),
+        len(builtin_dag.interactions),
+        len(builtin_dag.amplitude_roots),
+    ) == (14_088, 36_024, 3_072)
+    assert (
+        len(external_dag.currents),
+        len(external_dag.interactions),
+        len(external_dag.amplitude_roots),
+    ) == (14_088, 36_024, 3_072)
+
+    # Original AmpliCol evaluates 652 post-filter kernels for each of the 64
+    # nonzero helicities. Ordered labels and helicity ancestry are physical
+    # runtime routes and therefore may not be merged merely by a reflection
+    # proof. Exact structural pruning still keeps both model implementations
+    # below the legacy kernel count.
+    legacy_kernel_evaluations = 652 * 64
+    assert builtin_dag.interaction_evaluation_count == 36_024
+    assert external_dag.interaction_evaluation_count == 36_024
+    assert builtin_dag.interaction_evaluation_count < legacy_kernel_evaluations
+    assert external_dag.interaction_evaluation_count < legacy_kernel_evaluations
+    assert assign_recursive_current_evaluation_reuse(
+        builtin_dag,
+        builtin_model,
+    ) == builtin_dag
+    assert assign_recursive_current_evaluation_reuse(
+        external_dag,
+        external_model,
+    ) == external_dag
+
+
+def test_recursive_reuse_keeps_reflected_runtime_routes_distinct(
+    external_sm,
+) -> None:
+    compiled, external_model = external_sm
+    cases = (
+        (
+            BuiltinSMModel(),
+            build_process_ir("g g > g g g", color_accuracy="nlc"),
+        ),
+        (
+            external_model,
+            build_model_process_ir(
+                "g g > g g g",
+                compiled.ir,
+                color_accuracy="nlc",
+            ),
+        ),
+    )
+
+    for model, process in cases:
+        dag = compile_generic_dag(
+            process,
+            model=model,
+            max_coupling_orders={"QCD": 3, "QED": 0},
+        )
+        equivalences = _derive_current_value_equivalences(dag, model)
+        currents_by_contract: dict[tuple[object, ...], list[CurrentNode]] = defaultdict(
+            list
+        )
+        for current in dag.currents:
+            index = current.index
+            if len(index.ordered_external_labels) < 2:
+                continue
+            contract = (
+                int(index.particle_id),
+                int(index.external_mask),
+                index.external_labels,
+                int(index.helicity_ancestry),
+                int(index.chirality),
+                index.spin_state,
+                index.flavour_flow,
+                index.quantum_number_flow,
+                int(index.momentum_mask),
+                index.coupling_orders,
+                index.auxiliary_kind,
+                int(current.dimension),
+            )
+            currents_by_contract[contract].append(current)
+
+        checked = 0
+        for currents in currents_by_contract.values():
+            representatives_by_order: dict[tuple[int, ...], set[int]] = defaultdict(set)
+            for current in currents:
+                representatives_by_order[current.index.ordered_external_labels].add(
+                    equivalences[current.id].representative_id
+                )
+            for ordering, representatives in representatives_by_order.items():
+                reversed_representatives = representatives_by_order.get(
+                    tuple(reversed(ordering))
+                )
+                if reversed_representatives is None:
+                    continue
+                checked += 1
+                assert representatives.isdisjoint(reversed_representatives)
+        assert checked > 0
+
+
+def test_recursive_current_reuse_keeps_mixed_line_routes_strict() -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("d d~ > t t~ g g", color_accuracy="full"),
+        model=model,
+    )
+    equivalences = _derive_current_value_equivalences(dag, model)
+
+    # This production-shaped DAG has no exact same-route current aliases.
+    # Coefficient-deformation rejection is covered independently by the
+    # synthetic projective-vector tests.
+    assert all(
+        equivalences[current.id].representative_id == current.id
+        for current in dag.currents
+        if not current.is_source
+    )
+
+
+def test_external_sm_tensor_ordering_ids_are_source_inventory_invariant(
+    external_sm,
+    relabelled_external_sm,
+    reordered_external_sm,
+) -> None:
+    compiled, _model = external_sm
+    relabelled, _relabelled_model = relabelled_external_sm
+    reordered, _reordered_model = reordered_external_sm
+
+    assert relabelled.ir.tensor_orderings == compiled.ir.tensor_orderings
+    assert reordered.ir.tensor_orderings == compiled.ir.tensor_orderings
+    assert {
+        (
+            kernel.input_ordering_ids,
+            kernel.output_ordering_id,
+        )
+        for kernel in relabelled.ir.oriented_kernels
+    } == {
+        (
+            kernel.input_ordering_ids,
+            kernel.output_ordering_id,
+        )
+        for kernel in compiled.ir.oriented_kernels
+    }
+    assert {
+        (
+            kernel.input_ordering_ids,
+            kernel.output_ordering_id,
+        )
+        for kernel in reordered.ir.oriented_kernels
+    } == {
+        (
+            kernel.input_ordering_ids,
+            kernel.output_ordering_id,
+        )
+        for kernel in compiled.ir.oriented_kernels
+    }
+
+
+@pytest.mark.parametrize("process", _EXTERNAL_SM_TOPOLOGY_LADDER)
+def test_external_sm_topology_is_pdg_relabel_invariant(
+    external_sm,
+    relabelled_external_sm,
+    process: str,
+) -> None:
+    compiled, model = external_sm
+    relabelled, relabelled_model = relabelled_external_sm
+
+    assert _production_dag_signature(
+        relabelled,
+        relabelled_model,
+        process,
+    ) == _production_dag_signature(compiled, model, process)
+
+
+@pytest.mark.parametrize("process", _EXTERNAL_SM_TOPOLOGY_LADDER)
+def test_external_sm_topology_is_ufo_inventory_order_invariant(
+    external_sm,
+    reordered_external_sm,
+    process: str,
+) -> None:
+    compiled, model = external_sm
+    reordered, reordered_model = reordered_external_sm
+
+    assert _production_dag_signature(
+        reordered,
+        reordered_model,
+        process,
+    ) == _production_dag_signature(compiled, model, process)
+
+
+@pytest.mark.parametrize("process", _EXTERNAL_SM_TOPOLOGY_LADDER)
+def test_external_sm_topology_survives_combined_identity_and_inventory_changes(
+    external_sm,
+    renamed_relabelled_reordered_external_sm,
+    process: str,
+) -> None:
+    compiled, model = external_sm
+    transformed, transformed_model, name_map = (
+        renamed_relabelled_reordered_external_sm
+    )
+
+    assert _production_dag_signature(
+        transformed,
+        transformed_model,
+        _rename_process(process, name_map),
+    ) == _production_dag_signature(compiled, model, process)
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_lc_current_reflection_reuse_does_not_prune_contracted_color_modes(
+    external_sm,
+    accuracy: str,
+) -> None:
+    compiled, external_model = external_sm
+    cases = (
+        (
+            build_process_ir("d d~ > z g", color_accuracy=accuracy),
+            BuiltinSMModel(),
+        ),
+        (
+            build_model_process_ir(
+                "d d~ > z g",
+                compiled.ir,
+                color_accuracy=accuracy,
+            ),
+            external_model,
+        ),
+    )
+
+    for process, model in cases:
+        limits = infer_minimal_coupling_order_limits(process, model=model)
+        dag = compile_generic_dag(
+            process,
+            model=model,
+            max_coupling_orders=limits,
+        )
+        assert (
+            len(dag.currents),
+            len(dag.interactions),
+            len(dag.amplitude_roots),
+        ) == (31, 34, 12)
+
+
+def test_deformed_adjoint_kernel_disables_local_current_reuse(external_sm) -> None:
+    compiled, model = external_sm
+    reflection_kinds = dict(
+        model._symmetry_certificates.adjoint_current_reflection_phases
+    )
+    target = next(
+        kernel
+        for kernel in compiled.ir.oriented_kernels
+        if kernel.kind in reflection_kinds
+    )
+    deformed_kernels = tuple(
+        replace(
+            kernel,
+            component_expressions=("1", *kernel.component_expressions[1:]),
+        )
+        if kernel.kind == target.kind
+        else kernel
+        for kernel in compiled.ir.oriented_kernels
+    )
+    certificates = derive_external_symmetry_certificates(
+        replace(compiled.ir, oriented_kernels=deformed_kernels)
+    )
+
+    assert certificates.adjoint_current_reflection_phases == ()
+
+
+def test_custom_adjoint_propagator_disables_global_symmetries(external_sm) -> None:
+    compiled, model = external_sm
+    original_yang_mills_kinds = model._symmetry_certificates.yang_mills_kernel_kinds
+    propagators = tuple(
+        replace(propagator, custom=True)
+        if propagator.particle == "g"
+        else propagator
+        for propagator in compiled.ir.propagators
+    )
+
+    certificates = derive_external_symmetry_certificates(
+        replace(compiled.ir, propagators=propagators)
+    )
+
+    assert original_yang_mills_kinds
+    assert not (original_yang_mills_kinds & certificates.parity_kernel_kinds)
+    assert certificates.yang_mills_kernel_kinds == frozenset()
+    assert certificates.yang_mills_adjoint_names == frozenset()
+    assert certificates.adjoint_current_reflection_phases == ()
+    assert certificates.yang_mills_kernel_digests == ()
+    assert certificates.yang_mills_adjoint_digests == ()
+    assert certificates.adjoint_current_reflection_digests == ()
+
+
+def test_transverse_yang_mills_lowering_requires_standard_adjoint_propagator(
+    external_sm,
+) -> None:
+    compiled, _model = external_sm
+    term = next(
+        term
+        for term in compiled.ir.vertex_terms
+        if term.valence == 3 and set(term.particles) == {"g"}
+    )
+    particles = {particle.name: particle for particle in compiled.ir.particles}
+    parameters = {parameter.name: parameter for parameter in compiled.ir.parameters}
+    propagators = {
+        propagator.name: propagator for propagator in compiled.ir.propagators
+    }
+
+    assert _term_supports_transverse_massless_yang_mills(
+        term,
+        particles,
+        parameters,
+        propagators,
+    )
+
+    custom = {
+        name: replace(propagator, custom=True)
+        if propagator.particle == "g"
+        else propagator
+        for name, propagator in propagators.items()
+    }
+    assert not _term_supports_transverse_massless_yang_mills(
+        term,
+        particles,
+        parameters,
+        custom,
+    )
+
+
+def test_chiral_gauge_current_does_not_receive_parity_certificate(external_sm) -> None:
+    compiled, _model = external_sm
+    vectorlike = next(term for term in compiled.ir.vertex_terms if term.id == 75)
+    chiral = next(
+        term
+        for term in compiled.ir.vertex_terms
+        if "projm" in term.lorentz_expression.casefold()
+    )
+    deformed_terms = tuple(
+        replace(vectorlike, lorentz_expression=chiral.lorentz_expression)
+        if term.id == vectorlike.id
+        else term
+        for term in compiled.ir.vertex_terms
+    )
+    deformed_terms = tuple(
+        replace(term, index_bindings=()) if term.id == vectorlike.id else term
+        for term in deformed_terms
+    )
+    certificates = derive_external_symmetry_certificates(
+        _replace_model_with_recompiled_tensor_metadata(
+            compiled.ir,
+            vertex_terms=deformed_terms,
+            oriented_kernels=compiled.ir.oriented_kernels,
+        )
+    )
+    affected_kinds = {
+        kernel.kind
+        for kernel in compiled.ir.oriented_kernels
+        if vectorlike.id in kernel.term_ids
+    }
+
+    assert affected_kinds
+    assert not (affected_kinds & certificates.parity_kernel_kinds)
+
+
+def test_deformed_quartic_coupling_disables_yang_mills_theorems(external_sm) -> None:
+    compiled, _model = external_sm
+    quartic_terms = {
+        term.coupling for term in compiled.ir.vertex_terms if term.id in {36, 37, 38}
+    }
+    assert len(quartic_terms) == 1
+    quartic_name = next(iter(quartic_terms))
+    deformed_couplings = tuple(
+        replace(coupling, expression=f"2*({coupling.expression})")
+        if coupling.name == quartic_name
+        else coupling
+        for coupling in compiled.ir.couplings
+    )
+    certificates = derive_external_symmetry_certificates(
+        replace(compiled.ir, couplings=deformed_couplings)
+    )
+
+    assert certificates.yang_mills_adjoint_names == frozenset()
+    assert certificates.yang_mills_kernel_kinds == frozenset()
+
+
+@pytest.mark.parametrize("field", ("color_expression", "lorentz_expression"))
+def test_rescaled_cubic_tensor_disables_yang_mills_theorems(
+    external_sm,
+    field: str,
+) -> None:
+    compiled, _model = external_sm
+    cubic = next(
+        term for term in compiled.ir.vertex_terms if term.particles == ("g", "g", "g")
+    )
+    deformed_terms = tuple(
+        replace(
+            term,
+            **{field: f"2*({getattr(term, field)})"},
+        )
+        if term.id == cubic.id
+        else term
+        for term in compiled.ir.vertex_terms
+    )
+
+    certificates = derive_external_symmetry_certificates(
+        replace(compiled.ir, vertex_terms=deformed_terms)
+    )
+
+    assert certificates.yang_mills_adjoint_names == frozenset()
+    assert certificates.yang_mills_kernel_kinds == frozenset()
+
+
+def test_duplicate_cubic_term_disables_yang_mills_theorems(external_sm) -> None:
+    compiled, _model = external_sm
+    cubic = next(
+        term for term in compiled.ir.vertex_terms if term.particles == ("g", "g", "g")
+    )
+    duplicate = replace(
+        cubic,
+        id=max(term.id for term in compiled.ir.vertex_terms) + 1,
+        vertex=f"{cubic.vertex}_duplicate",
+    )
+
+    certificates = derive_external_symmetry_certificates(
+        replace(compiled.ir, vertex_terms=(*compiled.ir.vertex_terms, duplicate))
+    )
+
+    assert certificates.yang_mills_adjoint_names == frozenset()
+    assert certificates.yang_mills_kernel_kinds == frozenset()
+
+
+def test_reachable_non_yang_mills_kernel_disables_global_adjoint_theorems(
+    external_sm,
+) -> None:
+    compiled, _model = external_sm
+    original_certificates = derive_external_symmetry_certificates(compiled.ir)
+    representative = next(
+        kernel
+        for kernel in compiled.ir.oriented_kernels
+        if kernel.kind in original_certificates.yang_mills_kernel_kinds
+        and kernel.particles == ("g", "g", "g")
+    )
+    source_term = next(
+        term
+        for term in compiled.ir.vertex_terms
+        if term.id in (representative.term_ids or (representative.term_id,))
+    )
+    extra_term_id = max(term.id for term in compiled.ir.vertex_terms) + 1
+    extra_kind = max(kernel.kind for kernel in compiled.ir.oriented_kernels) + 1
+    extra_term = replace(
+        source_term,
+        id=extra_term_id,
+        vertex="V_non_yang_mills_adjoint",
+        lorentz_name="L_non_yang_mills_adjoint",
+        lorentz_source="1",
+        lorentz_expression="1",
+        index_bindings=(),
+    )
+    extra_kernel = replace(
+        representative,
+        kind=extra_kind,
+        term_id=extra_term_id,
+        term_ids=(extra_term_id,),
+        vertex=extra_term.vertex,
+        evaluation_class="",
+        evaluation_equivalence_verified=False,
+        evaluation_input_exchange_factor=None,
+    )
+
+    certificates = derive_external_symmetry_certificates(
+        _replace_model_with_recompiled_tensor_metadata(
+            compiled.ir,
+            vertex_terms=(*compiled.ir.vertex_terms, extra_term),
+            oriented_kernels=(*compiled.ir.oriented_kernels, extra_kernel),
+        )
+    )
+
+    assert certificates.yang_mills_kernel_kinds
+    assert certificates.yang_mills_adjoint_names == frozenset()
diff --git a/pyamplicol/tests/unit/test_fermion_ordering.py b/pyamplicol/tests/unit/test_fermion_ordering.py
new file mode 100644
index 0000000000..93715da169
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fermion_ordering.py
@@ -0,0 +1,181 @@
+# SPDX-License-Identifier: 0BSD
+"""Generation-time exterior-algebra signs for external fermions."""
+
+from __future__ import annotations
+
+import pytest
+
+from pyamplicol.generation.fermion_ordering import (
+    _external_fermion_requires_exterior_sign,
+    _external_fermion_support_sign,
+    _fermion_input_orientation_sign,
+    _fermion_rep_requires_exterior_sign,
+)
+
+
+@pytest.mark.parametrize(
+    ("statistics", "color_role", "expected"),
+    (
+        ("fermion", "singlet", True),
+        ("fermion", "fundamental", False),
+        ("fermion", "antifundamental", False),
+        ("boson", "adjoint", False),
+    ),
+)
+def test_external_source_sign_ownership_uses_canonical_color_role(
+    statistics: str,
+    color_role: str,
+    expected: bool,
+) -> None:
+    assert _external_fermion_requires_exterior_sign(statistics, color_role) is expected
+
+
+@pytest.mark.parametrize("color_role", ("adjoint", "inclusive"))
+def test_unsupported_external_fermion_color_role_fails_closed(
+    color_role: str,
+) -> None:
+    with pytest.raises(ValueError, match="fermion color role"):
+        _external_fermion_requires_exterior_sign("fermion", color_role)
+
+
+@pytest.mark.parametrize(
+    ("color_representation", "expected"),
+    ((1, True), (3, False), (-3, False)),
+)
+def test_model_representation_sign_ownership_is_generic(
+    color_representation: int,
+    expected: bool,
+) -> None:
+    assert _fermion_rep_requires_exterior_sign(color_representation) is expected
+
+
+def test_unsupported_fermion_representation_fails_closed() -> None:
+    with pytest.raises(ValueError, match="fermion color representation"):
+        _fermion_rep_requires_exterior_sign(8)
+
+
+def test_support_parity_uses_canonical_source_rank_not_label_value() -> None:
+    source_ranks = {40: 0, 7: 1, 99: 2, 3: 3}
+
+    sign = _external_fermion_support_sign(
+        (3, 7),
+        (40, 99),
+        source_ranks,
+    )
+
+    assert sign == -1
+
+
+@pytest.mark.parametrize(
+    (
+        "left_is_fermion",
+        "left_orientation",
+        "right_is_fermion",
+        "right_orientation",
+        "expected",
+    ),
+    (
+        (True, "antiparticle", True, "particle", 1),
+        (True, "particle", True, "antiparticle", -1),
+        (True, "particle", False, "self-conjugate", 1),
+        (False, "self-conjugate", True, "antiparticle", 1),
+    ),
+)
+def test_two_fermion_kernel_orientation_is_a_cached_sign(
+    left_is_fermion: bool,
+    left_orientation: str,
+    right_is_fermion: bool,
+    right_orientation: str,
+    expected: int,
+) -> None:
+    assert (
+        _fermion_input_orientation_sign(
+            left_is_fermion,
+            left_orientation,
+            True,
+            right_is_fermion,
+            right_orientation,
+            True,
+        )
+        == expected
+    )
+
+
+def test_colored_kernel_keeps_authenticated_open_line_sign() -> None:
+    assert (
+        _fermion_input_orientation_sign(
+            True,
+            "particle",
+            False,
+            True,
+            "antiparticle",
+            False,
+        )
+        == 1
+    )
+
+
+def test_mixed_kernel_sign_ownership_fails_closed() -> None:
+    with pytest.raises(ValueError, match="mixed color-sign ownership"):
+        _fermion_input_orientation_sign(
+            True,
+            "particle",
+            True,
+            True,
+            "antiparticle",
+            False,
+        )
+
+
+def test_unsupported_self_conjugate_fermion_fails_during_generation() -> None:
+    with pytest.raises(ValueError, match="non-self-conjugate"):
+        _fermion_input_orientation_sign(
+            True,
+            "self-conjugate",
+            True,
+            True,
+            "particle",
+            True,
+        )
+
+
+@pytest.mark.parametrize("orientation", ("particle", "antiparticle"))
+def test_same_dirac_orientation_fails_during_generation(orientation: str) -> None:
+    with pytest.raises(ValueError, match="opposite Dirac orientations"):
+        _fermion_input_orientation_sign(
+            True,
+            orientation,
+            True,
+            True,
+            orientation,
+            True,
+        )
+
+
+def test_identical_dirac_pairings_have_opposite_tree_products() -> None:
+    source_ranks = {10: 0, 20: 1, 30: 2, 40: 3}
+
+    direct = _external_fermion_support_sign((10,), (20,), source_ranks)
+    direct *= _fermion_input_orientation_sign(
+        True,
+        "antiparticle",
+        True,
+        True,
+        "particle",
+        True,
+    )
+    direct *= _external_fermion_support_sign((10, 20), (30,), source_ranks)
+
+    exchange = _external_fermion_support_sign((20,), (30,), source_ranks)
+    exchange *= _fermion_input_orientation_sign(
+        True,
+        "particle",
+        True,
+        True,
+        "antiparticle",
+        True,
+    )
+    exchange *= _external_fermion_support_sign((10,), (20, 30), source_ranks)
+
+    assert direct == 1
+    assert exchange == -1
diff --git a/pyamplicol/tests/unit/test_fft_basis_strategy.py b/pyamplicol/tests/unit/test_fft_basis_strategy.py
new file mode 100644
index 0000000000..30b56b82d5
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fft_basis_strategy.py
@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact basis selection must not disguise fundamental chains as DDM."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import replace
+
+import pytest
+
+from pyamplicol.color.fft_basis_strategy import best_general_fft_basis
+from pyamplicol.color.plan import build_color_plan
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+@pytest.mark.parametrize(
+    ("process", "name", "degree", "count"),
+    (
+        ("d d~ > z", "fundamental-chain", 0, 1),
+        ("d d~ > z g g g", "fundamental-chain", 3, 6),
+        ("d d~ > d d~", "fundamental-chain-products", 0, 2),
+        ("d d~ > d d~ g", "fundamental-chain-products", 1, 4),
+        ("d d~ > d d~ g g", "fundamental-chain-products", 2, 12),
+        ("d d~ > d d~ g g g", "fundamental-chain-products", 3, 48),
+        ("d d~ > u u~ s s~ g", "fundamental-chain-products", 1, 18),
+        ("e- e+ > mu- mu+", "singlet", 0, 1),
+    ),
+)
+def test_fundamental_and_singlet_strategy_is_explicit(process, name, degree, count):
+    process_ir = build_process_ir(process, color_accuracy="full")
+    for certificate in (False, True):
+        strategy = best_general_fft_basis(process_ir, ddm_proven=certificate)
+        assert strategy.actual_basis == "trace"
+        assert strategy.name == name
+        assert strategy.permutation_degree == degree
+        assert strategy.tensor_count == count
+    plan = build_color_plan(process_ir, color_accuracy="full")
+    tensor_keys = {
+        (sector.open_color_lines, sector.trace_labels, sector.singlet_labels)
+        for sector in plan.sectors
+    }
+    assert len(tensor_keys) == count
+
+
+@pytest.mark.parametrize("gluons", (3, 4, 5, 6))
+def test_only_a_certificate_selects_ddm(gluons):
+    process = build_process_ir(
+        "g g > " + " ".join(["g"] * (gluons - 2)), color_accuracy="full"
+    )
+    ordinary = best_general_fft_basis(process, ddm_proven=False)
+    assert ordinary.actual_basis == "trace"
+    assert ordinary.name == "trace"
+    assert ordinary.permutation_degree == gluons - 1
+    assert ordinary.tensor_count == math.factorial(gluons - 1)
+    certified = best_general_fft_basis(process, ddm_proven=True)
+    assert certified.actual_basis == "adjoint"
+    assert certified.name == "ddm"
+    assert certified.permutation_degree == gluons - 2
+    assert certified.tensor_count == math.factorial(gluons - 2)
+
+
+def test_certified_singlet_spectators_do_not_change_the_ddm_group():
+    process = build_process_ir("g g > g g h", color_accuracy="full")
+    strategy = best_general_fft_basis(process, ddm_proven=True)
+    assert (strategy.name, strategy.permutation_degree, strategy.tensor_count) == (
+        "ddm",
+        2,
+        2,
+    )
+
+
+def test_two_certified_adjoint_legs_select_the_degree_zero_delta_metric():
+    process = build_process_ir("g g > h", color_accuracy="full")
+    strategy = best_general_fft_basis(process, ddm_proven=True)
+    assert (
+        strategy.actual_basis,
+        strategy.name,
+        strategy.permutation_degree,
+        strategy.tensor_count,
+    ) == (
+        "adjoint",
+        "ddm",
+        0,
+        1,
+    )
+
+
+def test_unbalanced_endpoints_are_not_certified_by_the_dispatcher():
+    process = build_process_ir("d d~ > g g", color_accuracy="full")
+    process = replace(
+        process,
+        legs=tuple(
+            replace(leg, color_role="singlet")
+            if leg.color_role == "antifundamental"
+            else leg
+            for leg in process.legs
+        ),
+    )
+    strategy = best_general_fft_basis(process, ddm_proven=True)
+    assert strategy.actual_basis == "trace"
+    assert strategy.tensor_count is None
diff --git a/pyamplicol/tests/unit/test_fft_gluon_performance_acceptance.py b/pyamplicol/tests/unit/test_fft_gluon_performance_acceptance.py
new file mode 100644
index 0000000000..5e52245c79
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fft_gluon_performance_acceptance.py
@@ -0,0 +1,1603 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import uuid
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+from tools.developer import fft_gluon_performance_acceptance as acceptance
+
+
+def _probe(
+    *,
+    lane: str,
+    warm: float,
+    rss_kib: int = 1024,
+    point_values: tuple[float, ...] = (1.0,) * 10,
+    load: float = 0.2,
+    first_warm: float = 0.3,
+) -> acceptance.CandidateProbeMetrics:
+    samples = tuple(warm * (1.0 + 0.001 * index) for index in range(10))
+    warm_cells = tuple((sample,) for sample in samples)
+    return acceptance.CandidateProbeMetrics(
+        process="gg_N4",
+        execution_mode=lane,
+        helicity_coverage_count=1 if lane == "recurrence" else 16,
+        selected_helicity_id="h:-1,-1,+1,+1",
+        point_count=10,
+        point_values=point_values,
+        load_seconds=load,
+        first_warm_seconds=first_warm,
+        warm_up_api_seconds=0.0 if lane == "recurrence" else 0.25,
+        calibration_calls=(100,),
+        calibration_seconds=(0.26,),
+        warm_cell_seconds=warm_cells,
+        warm_samples_seconds=samples,
+        warm_median_seconds=acceptance.statistics.median(samples),
+        minimum_absolute_value=1.0,
+        max_rss_kib=rss_kib,
+    )
+
+
+def _candidate(
+    lane: str,
+    total_gluons: int,
+    warm: float,
+    *,
+    generation: float = 1.0,
+    rss_kib: int = 1024,
+    numerical_passes: bool = True,
+    load: float = 0.2,
+    first_warm: float = 0.3,
+) -> acceptance.CandidateMetrics:
+    scale_factor = acceptance.candidate_reference_scale_factor(total_gluons)
+    point_values = [1.0 / scale_factor] * 10
+    if not numerical_passes:
+        point_values[4] *= 1.0 + 1.0e-8
+    numerical_parity = acceptance.compare_candidate_to_reference(
+        total_gluons=total_gluons,
+        candidate_values=point_values,
+        reference_values=(1.0,) * 10,
+    )
+    return acceptance.CandidateMetrics(
+        lane=lane,
+        total_gluons=total_gluons,
+        generator_seed=acceptance.generator_seed(total_gluons),
+        generation_seconds=generation,
+        load_seconds=load,
+        first_warm_seconds=first_warm,
+        max_rss_kib=rss_kib,
+        probe=_probe(
+            lane=lane,
+            warm=warm,
+            rss_kib=rss_kib,
+            point_values=tuple(point_values),
+            load=load,
+            first_warm=first_warm,
+        ),
+        numerical_parity=numerical_parity,
+    )
+
+
+def _reference(
+    total_gluons: int,
+    *,
+    warm: float = 1.0,
+    rss_kib: int = 1024,
+    build: float = 1.0,
+    setup: float | None = None,
+) -> acceptance.ReferenceMetrics:
+    return acceptance.ReferenceMetrics(
+        total_gluons=total_gluons,
+        generator_seed=acceptance.generator_seed(total_gluons),
+        backend=acceptance.REFERENCE_BACKEND,
+        clean_build_scope=acceptance.REFERENCE_CLEAN_BUILD_SCOPE,
+        clean_build_command_count=11,
+        clean_build_seconds=build,
+        setup_to_driver_seconds=build if setup is None else setup,
+        initialization_seconds=0.2,
+        first_pass_seconds=0.3,
+        warm_samples_seconds=(warm,) * 10,
+        warm_median_seconds=warm,
+        max_rss_kib=rss_kib,
+        selected_helicity=(-1, -1, 1, 1),
+        selected_path="mhv",
+        event_paths=tuple(f"point-{index}.event" for index in range(10)),
+        matrix_elements=(1.0,) * 10,
+    )
+
+
+def test_reference_formal_cold_and_scaling_setup_metrics_remain_distinct() -> None:
+    reference = _reference(4, build=1.0, setup=2.0)
+
+    assert reference.cold_to_ready_seconds == pytest.approx(1.5)
+    assert reference.setup_to_ready_seconds == pytest.approx(2.5)
+    payload = acceptance._plain_reference(reference)
+    assert payload["cold_to_ready_seconds"] == pytest.approx(1.5)
+    assert payload["setup_to_ready_seconds"] == pytest.approx(2.5)
+    assert payload["clean_build_scope"] == "ampligluon-trace-backend-only"
+
+
+def test_reference_clean_build_boundary_excludes_support_tools(tmp_path: Path) -> None:
+    build_dir = tmp_path / "reference" / "N4" / "build"
+    backend_dir = build_dir / acceptance.REFERENCE_BUILD_PROGRAM
+    backend_compile = (
+        "gfortran",
+        f"-J{backend_dir / 'modules'}",
+        "-c",
+        "trace_colour_matrix.f90",
+        "-o",
+        str(backend_dir / "05_trace_colour_matrix.o"),
+    )
+    rambo_compile = (
+        "gfortran",
+        "-c",
+        "find_zero.f90",
+        "-o",
+        str(build_dir / "generate_ampligluon_events" / "00_find_zero.o"),
+    )
+    proxy_link = (
+        "gfortran",
+        "benchmark_helicity_proxy.f90",
+        "-o",
+        str(build_dir / "benchmark_helicity_proxy" / "benchmark_helicity_proxy"),
+    )
+
+    assert acceptance._is_reference_backend_build_command(
+        backend_compile, build_dir=build_dir, build_phase_active=True
+    )
+    assert not acceptance._is_reference_backend_build_command(
+        rambo_compile, build_dir=build_dir, build_phase_active=True
+    )
+    assert not acceptance._is_reference_backend_build_command(
+        proxy_link, build_dir=build_dir, build_phase_active=True
+    )
+    assert not acceptance._is_reference_backend_build_command(
+        (str(backend_dir / acceptance.REFERENCE_BUILD_PROGRAM),),
+        build_dir=build_dir,
+        build_phase_active=False,
+    )
+
+
+def test_reference_cold_timeout_remains_live_for_the_driver(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(acceptance.time, "perf_counter", lambda: 105.0)
+
+    assert acceptance._bounded_reference_cold_timeout(30.0, 10.0, 100.0) == 5.0
+    with pytest.raises(
+        acceptance.ReferenceColdLimitError, match="aggregate cold deadline"
+    ):
+        acceptance._bounded_reference_cold_timeout(30.0, 5.0, 100.0)
+    source = Path(acceptance.__file__).read_text(encoding="utf-8")
+    assert "cold_setup_active" not in source
+
+
+def _probe_output(
+    *,
+    calibration: float = 0.26,
+    lane: str = "recurrence",
+) -> str:
+    rows = [
+        "FFT_CANDIDATE_PROBE_V4",
+        "PROCESS gg_N4",
+        f"EXECUTION_MODE {lane}",
+        "TIMER_SOURCE process-cpu-time",
+        "HELICITY_COVERAGE_COUNT 1",
+        "SELECTED_HELICITY_ID h:-1,-1,+1,+1",
+        "POINT_COUNT 10",
+        "LOAD_SECONDS 2.0e-1",
+        "FIRST_WARM_SECONDS 3.0e-1",
+        f"WARM_UP_API_SECONDS {0.0 if lane == 'recurrence' else 0.25}",
+        *(f"POINT_VALUE {point} {1.0 / 512.0}" for point in range(1, 11)),
+        f"CALIBRATION_CELL 1 101 {calibration}",
+        *(f"WARM_CELL_SECONDS {batch} 1 {batch * 1.0e-6}" for batch in range(1, 11)),
+        "MIN_ABSOLUTE_VALUE 1.0e-20",
+        "MAX_RSS_KIB 4096",
+    ]
+    return "\n".join(rows) + "\n"
+
+
+def _first_ready_output(*, lane: str = "recurrence", rss_kib: int = 4096) -> str:
+    return (
+        "\n".join(
+            (
+                "FFT_CANDIDATE_FIRST_READY_V1",
+                "PROCESS gg_N4",
+                f"EXECUTION_MODE {lane}",
+                "TIMER_SOURCE process-cpu-time",
+                "HELICITY_COVERAGE_COUNT 1",
+                "SELECTED_HELICITY_ID h:-1,-1,+1,+1",
+                "POINT_COUNT 10",
+                "LOAD_SECONDS 0.2",
+                "FIRST_WARM_SECONDS 0.3",
+                f"WARM_UP_API_SECONDS {0.0 if lane == 'recurrence' else 0.25}",
+                "MIN_ABSOLUTE_VALUE 1e-20",
+                f"MAX_RSS_KIB {rss_kib}",
+            )
+        )
+        + "\n"
+    )
+
+
+def _without_warm_cell(output: str, batch: int, point: int) -> str:
+    prefix = f"WARM_CELL_SECONDS {batch} {point} "
+    return (
+        "\n".join(line for line in output.splitlines() if not line.startswith(prefix))
+        + "\n"
+    )
+
+
+def _without_point_value(output: str, point: int) -> str:
+    prefix = f"POINT_VALUE {point} "
+    return (
+        "\n".join(line for line in output.splitlines() if not line.startswith(prefix))
+        + "\n"
+    )
+
+
+def _duplicate_warm_cell(
+    output: str,
+    source: tuple[int, int],
+    destination: tuple[int, int],
+) -> str:
+    prefix = f"WARM_CELL_SECONDS {source[0]} {source[1]} "
+    return (
+        "\n".join(
+            (
+                f"WARM_CELL_SECONDS {destination[0]} {destination[1]} {line.split()[3]}"
+                if line.startswith(prefix)
+                else line
+            )
+            for line in output.splitlines()
+        )
+        + "\n"
+    )
+
+
+def test_candidate_probe_parser_requires_canonical_ten_sample_evidence() -> None:
+    parsed = acceptance.parse_candidate_probe_output(_probe_output())
+
+    assert parsed.execution_mode == "recurrence"
+    assert parsed.point_count == 10
+    assert parsed.point_values == pytest.approx((1.0 / 512.0,) * 10)
+    assert parsed.warm_up_api_seconds == 0.0
+    assert parsed.calibration_calls == (101,)
+    assert parsed.calibration_seconds == pytest.approx((0.26,))
+    assert len(parsed.warm_cell_seconds) == 10
+    assert all(len(row) == 1 for row in parsed.warm_cell_seconds)
+    assert parsed.warm_samples_seconds == pytest.approx(
+        tuple(batch * 1.0e-6 for batch in range(1, 11))
+    )
+    assert parsed.warm_median_seconds == pytest.approx(5.5e-6)
+    assert parsed.max_rss_kib == 4096
+
+
+@pytest.mark.parametrize(
+    ("payload", "message"),
+    (
+        (_probe_output(calibration=0.249), "0.25 seconds"),
+        (_without_point_value(_probe_output(), 10), "all 10 point values"),
+        (_without_warm_cell(_probe_output(), 10, 1), "point-1 cell"),
+        (
+            _probe_output().replace(
+                "CALIBRATION_CELL 1 101 0.26",
+                "CALIBRATION_CELL 1 101 0.26\nCALIBRATION_CELL 2 102 0.26",
+            ),
+            "calibrate only representative point 1",
+        ),
+        (
+            _duplicate_warm_cell(_probe_output(), (10, 1), (9, 1)),
+            "duplicated",
+        ),
+    ),
+)
+def test_candidate_probe_parser_rejects_incomplete_policy_evidence(
+    payload: str,
+    message: str,
+) -> None:
+    with pytest.raises(acceptance.AcceptanceError, match=message):
+        acceptance.parse_candidate_probe_output(payload)
+
+
+def test_candidate_probe_parser_enforces_lane_specific_warm_up_contract() -> None:
+    otf = acceptance.parse_candidate_probe_output(_probe_output(lane="on-the-fly"))
+    assert otf.warm_up_api_seconds == pytest.approx(0.25)
+
+    bad_recurrence = _probe_output().replace(
+        "WARM_UP_API_SECONDS 0.0", "WARM_UP_API_SECONDS 0.25"
+    )
+    with pytest.raises(acceptance.AcceptanceError, match="OTF-only"):
+        acceptance.parse_candidate_probe_output(bad_recurrence)
+
+
+@pytest.mark.parametrize("lane", acceptance.LANES)
+def test_candidate_identity_requires_lane_coverage_and_the_paired_helicity(
+    lane: str,
+) -> None:
+    metrics = _probe(lane=lane, warm=1.0)
+    expected = (-1, -1, 1, 1)
+
+    acceptance._validate_candidate_probe_identity(
+        metrics,
+        lane=lane,
+        total_gluons=4,
+        expected_helicities=expected,
+    )
+    invalid_coverage = 2 if lane == "recurrence" else 1
+    with pytest.raises(acceptance.AcceptanceError, match=r"coverage|specialization"):
+        acceptance._validate_candidate_probe_identity(
+            replace(metrics, helicity_coverage_count=invalid_coverage),
+            lane=lane,
+            total_gluons=4,
+            expected_helicities=expected,
+        )
+    with pytest.raises(acceptance.AcceptanceError, match="known-nonzero helicity"):
+        acceptance._validate_candidate_probe_identity(
+            replace(metrics, selected_helicity_id="h:-1,+1,-1,+1"),
+            lane=lane,
+            total_gluons=4,
+            expected_helicities=expected,
+        )
+
+
+def test_observed_default_bg_n4_protocol_times_one_cell_but_retains_ten_mes() -> None:
+    rows = [
+        f"BACKEND {acceptance.REFERENCE_BACKEND}",
+        "DIMENSION 6",
+        "INITIALIZATION_SECONDS 1.0e-3",
+        "FIRST_HELICITY_SWEEP_SECONDS 2.0e-3",
+        "EVALUATIONS_PER_SWEEP 1",
+        *(f"MATRIX_ELEMENT {point} 1 {point * 1.0e-3}" for point in range(1, 11)),
+        *(
+            f"EVALUATION_CELL_SECONDS {batch} 1 1 {batch * 1.0e-6}"
+            for batch in range(1, 11)
+        ),
+    ]
+    reference = acceptance._load_reference_module()
+    run = reference.parse_driver_output(
+        "\n".join(rows) + "\n",
+        acceptance.REFERENCE_BACKEND,
+        False,
+    )
+
+    samples = acceptance._reference_representative_warm_samples(run.cell_timings)
+
+    assert set(run.matrix_elements) == {(point, 1) for point in range(1, 11)}
+    assert samples == pytest.approx(tuple(batch * 1.0e-6 for batch in range(1, 11)))
+    assert acceptance.statistics.median(samples) == pytest.approx(5.5e-6)
+
+    with pytest.raises(acceptance.AcceptanceError, match="one point-1 cell"):
+        acceptance._reference_representative_warm_samples(
+            run.cell_timings | {(1, 2, 1): 1.0e-6}
+        )
+
+
+@pytest.mark.parametrize("total_gluons", (4, 9, 11))
+def test_numerical_parity_aligns_unit_coupling_and_me_conventions(
+    total_gluons: int,
+) -> None:
+    reference_values = tuple(float(point * point + 1) for point in range(1, 11))
+    scale_factor = 256 * acceptance.math.factorial(total_gluons - 2)
+    candidate_values = tuple(value / scale_factor for value in reference_values)
+
+    evidence = acceptance.compare_candidate_to_reference(
+        total_gluons=total_gluons,
+        candidate_values=candidate_values,
+        reference_values=reference_values,
+    )
+
+    assert evidence.normalization_alpha_s_me_check == pytest.approx(
+        1.0 / (4.0 * acceptance.math.pi)
+    )
+    assert evidence.candidate_scale_factor == scale_factor
+    assert evidence.relative_tolerance == 1.0e-10
+    assert evidence.maximum_relative_error <= 1.0e-15
+    assert evidence.passes is True
+
+
+@pytest.mark.parametrize("mismatch_multiplier", (1.0 + 2.0e-10, 0.0, -1.0))
+def test_numerical_parity_rejects_a_strict_scale_relative_mismatch(
+    mismatch_multiplier: float,
+) -> None:
+    reference_values = (1.0,) * 10
+    scale_factor = acceptance.candidate_reference_scale_factor(4)
+    candidate_values = [1.0 / scale_factor] * 10
+    candidate_values[6] *= mismatch_multiplier
+
+    evidence = acceptance.compare_candidate_to_reference(
+        total_gluons=4,
+        candidate_values=candidate_values,
+        reference_values=reference_values,
+    )
+
+    assert evidence.maximum_relative_error_point == 7
+    assert evidence.maximum_relative_error > 1.0e-10
+    assert evidence.passes is False
+
+
+def test_candidate_first_ready_parser_uses_the_same_lane_contract() -> None:
+    parsed = acceptance.parse_candidate_first_ready_output(_first_ready_output())
+    assert parsed.execution_mode == "recurrence"
+    assert parsed.warm_up_api_seconds == 0.0
+    zero_candidate = acceptance.parse_candidate_first_ready_output(
+        _first_ready_output().replace(
+            "MIN_ABSOLUTE_VALUE 1e-20", "MIN_ABSOLUTE_VALUE 0"
+        )
+    )
+    assert zero_candidate.minimum_absolute_value == 0.0
+
+
+def test_darwin_reference_command_uses_getrusage_for_gnu_and_direct_wrappers() -> None:
+    wrapped = (
+        "/usr/bin/timeout",
+        "--signal=TERM",
+        "--kill-after=5s",
+        "600s",
+        "/usr/bin/time",
+        "--format=BENCHMARK_MAX_RSS_KIB %M",
+        "/usr/bin/prlimit",
+        "--as=32212254720",
+        "--",
+        "/workspace/reference-driver",
+        "default-bg",
+        "fft",
+    )
+
+    translated, measured = acceptance._translate_darwin_reference_command(
+        wrapped, python="/venv/python"
+    )
+
+    assert measured is True
+    assert translated == (
+        "/venv/python",
+        str(acceptance.SCALING_STUDY_DRIVER),
+        "_time-rss",
+        "/workspace/reference-driver",
+        "default-bg",
+        "fft",
+    )
+    direct, measured = acceptance._translate_darwin_reference_command(
+        ("/usr/bin/time", "-l", "/workspace/reference-driver"),
+        python="/venv/python",
+    )
+    assert measured is True
+    assert direct == (
+        "/venv/python",
+        str(acceptance.SCALING_STUDY_DRIVER),
+        "_time-rss",
+        "/workspace/reference-driver",
+    )
+    compiler = ("gfortran", "--version")
+    assert acceptance._translate_darwin_reference_command(compiler) == (
+        compiler,
+        False,
+    )
+
+
+def test_gnu_reference_command_uses_getrusage_and_resolves_wrappers_from_path(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    tools = {
+        "timeout": "/nix/bin/timeout",
+        "prlimit": "/nix/bin/prlimit",
+    }
+    monkeypatch.setattr(acceptance.shutil, "which", tools.__getitem__)
+    wrapped = (
+        "/usr/bin/timeout",
+        "--signal=TERM",
+        "--kill-after=5s",
+        "600s",
+        "/usr/bin/time",
+        "--format=BENCHMARK_MAX_RSS_KIB %M",
+        "/usr/bin/prlimit",
+        "--as=32212254720",
+        "--",
+        "/workspace/reference-driver",
+        "default-bg",
+        "fft",
+    )
+
+    translated, measured = acceptance._translate_gnu_reference_command(
+        wrapped,
+        python="/venv/python",
+    )
+
+    assert measured is True
+    assert translated == (
+        "/venv/python",
+        str(acceptance.SCALING_STUDY_DRIVER),
+        "_time-rss",
+        "/nix/bin/timeout",
+        "--signal=TERM",
+        "--kill-after=5s",
+        "600s",
+        "/nix/bin/prlimit",
+        "--as=32212254720",
+        "--",
+        "/workspace/reference-driver",
+        "default-bg",
+        "fft",
+    )
+
+
+def test_darwin_getrusage_rss_is_adapted_to_the_reference_protocol() -> None:
+    getrusage = subprocess.CompletedProcess(
+        args=("_time-rss", "reference-driver"),
+        returncode=0,
+        stdout="BACKEND AmpliGluonTraceDefaultBG\n",
+        stderr="FFT_MAX_RSS_KIB 125\n",
+    )
+    normalized = acceptance._synthesize_reference_rss_marker(getrusage)
+    assert normalized.stderr == ("FFT_MAX_RSS_KIB 125\nBENCHMARK_MAX_RSS_KIB 125\n")
+    assert (
+        acceptance._parse_translated_reference_child_rss_kib(normalized.stderr) == 125
+    )
+    with pytest.raises(acceptance.AcceptanceError, match="matching exact child"):
+        acceptance._parse_translated_reference_child_rss_kib(
+            "FFT_MAX_RSS_KIB 125\nBENCHMARK_MAX_RSS_KIB 999\n"
+        )
+    compiler_watchdog_rss_kib = 200
+    wrapper_watchdog_rss_kib = 4096
+    formal_evaluator_rss_kib = acceptance._formal_reference_evaluator_rss_kib(
+        125,
+        compiler_watchdog_rss_kib,
+        125,
+    )
+    assert formal_evaluator_rss_kib == 125
+    assert formal_evaluator_rss_kib != compiler_watchdog_rss_kib
+    assert formal_evaluator_rss_kib != wrapper_watchdog_rss_kib
+
+
+def test_global_lane_is_selected_once_from_both_valid_lane_workloads() -> None:
+    references = {
+        total: _reference(total) for total in acceptance.MANDATORY_MULTIPLICITIES
+    }
+    candidates = {
+        "on-the-fly": {
+            total: _candidate("on-the-fly", total, 0.1)
+            for total in acceptance.MANDATORY_MULTIPLICITIES
+        },
+        "recurrence": {
+            total: _candidate("recurrence", total, 1.0)
+            for total in acceptance.MANDATORY_MULTIPLICITIES
+        },
+    }
+
+    winner = acceptance.select_global_lane(references, candidates)
+    eligibility = acceptance.lane_eligibility(candidates)
+
+    assert winner == "on-the-fly"
+    assert eligibility["on-the-fly"]["eligible"] is True
+    assert eligibility["on-the-fly"]["generation_specialized"] is False
+    assert eligibility["on-the-fly"]["complete_helicity_coverage"] is True
+    assert eligibility["recurrence"]["eligible"] is True
+    assert eligibility["recurrence"]["generation_specialized"] is True
+    assert eligibility["recurrence"]["complete_helicity_coverage"] is False
+    assert all(
+        candidates["on-the-fly"][total].probe.warm_median_seconds
+        < candidates["recurrence"][total].probe.warm_median_seconds
+        for total in acceptance.MANDATORY_MULTIPLICITIES
+    )
+
+
+def test_otf_without_complete_selector_coverage_is_ineligible() -> None:
+    candidates = {
+        "on-the-fly": {
+            total: _candidate("on-the-fly", total, 0.1)
+            for total in acceptance.MANDATORY_MULTIPLICITIES
+        },
+        "recurrence": {
+            total: _candidate("recurrence", total, 1.0)
+            for total in acceptance.MANDATORY_MULTIPLICITIES
+        },
+    }
+
+    for total, candidate in tuple(candidates["on-the-fly"].items()):
+        candidates["on-the-fly"][total] = replace(
+            candidate,
+            probe=replace(candidate.probe, helicity_coverage_count=1),
+        )
+
+    assert acceptance.lane_eligibility(candidates)["on-the-fly"]["eligible"] is False
+    with pytest.raises(acceptance.AcceptanceError, match="workload contract"):
+        acceptance.evaluate_gates("on-the-fly", {}, candidates)
+
+
+def test_slower_passing_lane_wins_when_faster_lane_fails_rss() -> None:
+    references = {
+        total: _reference(total, rss_kib=1000)
+        for total in acceptance.MANDATORY_MULTIPLICITIES
+    }
+    candidates = {
+        "recurrence": {
+            total: _candidate("recurrence", total, 0.1, rss_kib=2001)
+            for total in acceptance.MANDATORY_MULTIPLICITIES
+        },
+        "on-the-fly": {
+            total: _candidate("on-the-fly", total, 1.0, rss_kib=1000)
+            for total in acceptance.MANDATORY_MULTIPLICITIES
+        },
+    }
+
+    assert acceptance.select_global_lane(references, candidates) == "on-the-fly"
+
+
+def test_incremental_viability_keeps_otf_when_recurrence_fails() -> None:
+    references = {4: _reference(4)}
+    candidates = {
+        "recurrence": {4: _candidate("recurrence", 4, 2.0)},
+        "on-the-fly": {4: _candidate("on-the-fly", 4, 0.1)},
+    }
+
+    viability = acceptance._observed_mandatory_gate_viability(
+        references, candidates, multiplicities=(4,)
+    )
+
+    assert viability["viable_lanes"] == ["on-the-fly"]
+    assert viability["lanes"]["recurrence"]["viable"] is False
+    assert viability["lanes"]["on-the-fly"]["eligible"] is True
+    assert viability["lanes"]["on-the-fly"]["viable"] is True
+
+
+def test_gate_ratios_use_only_the_global_winner_and_include_thresholds() -> None:
+    references = {
+        total: _reference(
+            total,
+            warm=1.0,
+            rss_kib=1000,
+            build=1.0,
+            setup=100.0,
+        )
+        for total in acceptance.MANDATORY_MULTIPLICITIES
+    }
+    candidates = {
+        "on-the-fly": {
+            total: _candidate("on-the-fly", total, 100.0, rss_kib=100_000)
+            for total in acceptance.MANDATORY_MULTIPLICITIES
+        },
+        "recurrence": {
+            total: _candidate(
+                "recurrence",
+                total,
+                1.25 / 1.0045,
+                generation=7.0,
+                rss_kib=2000,
+            )
+            for total in acceptance.MANDATORY_MULTIPLICITIES
+        },
+    }
+
+    gates = acceptance.evaluate_gates("recurrence", references, candidates)
+
+    assert {gate.lane for gate in gates} == {"recurrence"}
+    assert len(gates) == 6
+    assert all(gate.warm_ratio == pytest.approx(1.25) for gate in gates)
+    assert all(gate.rss_ratio == pytest.approx(2.0) for gate in gates)
+    assert all(gate.cold_ratio == pytest.approx(5.0) for gate in gates)
+    assert all(gate.passes for gate in gates)
+
+
+def test_numerical_mismatch_fails_an_otherwise_passing_gate() -> None:
+    references = {
+        total: _reference(total) for total in acceptance.MANDATORY_MULTIPLICITIES
+    }
+    candidates = {
+        lane: {
+            total: _candidate(
+                lane,
+                total,
+                1.0 / 1.0045,
+                numerical_passes=(lane != "recurrence" or total != 7),
+            )
+            for total in acceptance.MANDATORY_MULTIPLICITIES
+        }
+        for lane in acceptance.LANES
+    }
+
+    gates = acceptance.evaluate_gates("recurrence", references, candidates)
+
+    failed = next(gate for gate in gates if gate.total_gluons == 7)
+    assert failed.warm_passes is True
+    assert failed.rss_passes is True
+    assert failed.cold_passes is True
+    assert failed.numerical_passes is False
+    assert failed.passes is False
+    assert acceptance._gate_report(gates)["passes"] is False
+
+
+def _gate(total_gluons: int, *, passes: bool) -> acceptance.GateResult:
+    return acceptance.GateResult(
+        total_gluons=total_gluons,
+        lane="recurrence",
+        warm_ratio=1.0 if passes else 1.26,
+        rss_ratio=1.0,
+        cold_ratio=1.0,
+        warm_passes=passes,
+        rss_passes=True,
+        cold_passes=True,
+        numerical_passes=True,
+    )
+
+
+@pytest.mark.parametrize(
+    ("optional_gates", "expected"),
+    (
+        ((_gate(10, passes=False),), False),
+        ((_gate(10, passes=True), _gate(11, passes=True)), True),
+        ((), True),
+    ),
+    ids=("measured-fail", "measured-pass", "skipped"),
+)
+def test_gate_report_includes_every_measured_optional_row(
+    monkeypatch: pytest.MonkeyPatch,
+    optional_gates: tuple[acceptance.GateResult, ...],
+    expected: bool,
+) -> None:
+    mandatory = tuple(
+        _gate(total_gluons, passes=True)
+        for total_gluons in acceptance.MANDATORY_MULTIPLICITIES
+    )
+
+    report = acceptance._gate_report((*mandatory, *optional_gates))
+
+    assert report["passes"] is expected
+    serialized = report["gates"]
+    assert isinstance(serialized, list)
+    assert [gate["total_gluons"] for gate in serialized] == [
+        *acceptance.MANDATORY_MULTIPLICITIES,
+        *(gate.total_gluons for gate in optional_gates),
+    ]
+    assert all(gate["passes"] for gate in serialized[:6])
+    assert [gate["passes"] for gate in serialized[6:]] == [
+        gate.passes for gate in optional_gates
+    ]
+    monkeypatch.setattr(acceptance, "_campaign", lambda _arguments: report)
+    assert acceptance.main(("--run-id", "pytest-optional-gate-report")) == (
+        0 if expected else 1
+    )
+
+
+def test_optional_numerical_mismatch_is_fatal_and_persisted_not_skipped(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    performance_root = tmp_path / "performance"
+    monkeypatch.setattr(acceptance, "PERFORMANCE_ROOT", performance_root)
+    source_identity = acceptance.ReportSourceIdentity("a" * 40, "b" * 40, ())
+    monkeypatch.setattr(
+        acceptance,
+        "_require_campaign_source_identity",
+        lambda _expected=None: source_identity,
+    )
+    reference_source_identity = acceptance.ReferenceSourceIdentity(
+        acceptance.REFERENCE_REVISION, "c" * 64, 4
+    )
+    monkeypatch.setattr(
+        acceptance,
+        "_require_reference_source_identity",
+        lambda _expected=None: reference_source_identity,
+    )
+    monkeypatch.setattr(acceptance, "_workspace_environment", lambda _python: {})
+    monkeypatch.setattr(
+        acceptance,
+        "_enforce_one_core",
+        lambda _platform: {"requested_cpu_cores": 1},
+    )
+    monkeypatch.setattr(
+        acceptance,
+        "_build_probe",
+        lambda **_kwargs: (
+            tmp_path / "probe",
+            {"target": "test-target", "package_version": "test-version"},
+        ),
+    )
+    monkeypatch.setattr(acceptance, "_load_reference_module", object)
+
+    def fake_reference(**kwargs: object) -> acceptance._ReferenceRun:
+        total_gluons = int(kwargs["total_gluons"])
+        return acceptance._ReferenceRun(
+            metrics=_reference(total_gluons),
+            event_paths=tuple(
+                tmp_path / f"N{total_gluons}-point-{point}.event" for point in range(10)
+            ),
+        )
+
+    def fake_candidate(**kwargs: object) -> acceptance.CandidateMetrics:
+        total_gluons = int(kwargs["total_gluons"])
+        return _candidate(
+            str(kwargs["lane"]),
+            total_gluons,
+            0.5 if kwargs["lane"] == "recurrence" else 1.0,
+            numerical_passes=total_gluons != 10,
+        )
+
+    monkeypatch.setattr(acceptance, "_run_reference", fake_reference)
+    monkeypatch.setattr(acceptance, "_run_candidate", fake_candidate)
+    arguments = acceptance._parser().parse_args(
+        ("--include-optional", "--run-id", "optional-numerical-mismatch")
+    )
+
+    with pytest.raises(acceptance.NumericalParityError, match="N=10"):
+        acceptance._campaign(arguments)
+
+    report = json.loads(
+        (
+            performance_root / "runs" / "optional-numerical-mismatch" / "report.json"
+        ).read_text(encoding="utf-8")
+    )
+    assert report["status"] == "failed-numerical-parity"
+    assert report["optional"]["10"]["status"] == "failed-numerical-parity"
+    optional_lanes = [
+        lane for lane, records in report["candidates"].items() if "10" in records
+    ]
+    assert optional_lanes == ["recurrence"]
+    evidence = report["candidates"][optional_lanes[0]]["10"]
+    assert len(evidence["probe"]["point_values"]) == 10
+    assert evidence["numerical_parity"]["passes"] is False
+    assert evidence["numerical_parity"]["maximum_relative_error"] > 1.0e-10
+    assert len(report["reference"]["10"]["matrix_elements"]) == 10
+
+
+def test_optional_policy_enforces_independent_stage_and_memory_caps() -> None:
+    accepted = _candidate(
+        "recurrence",
+        10,
+        1.0,
+        generation=899.75,
+        first_warm=0.5,
+    )
+    slow_generation = _candidate("recurrence", 10, 1.0, generation=900.0)
+    slow_first_warm = _candidate("recurrence", 10, 1.0, first_warm=900.0)
+    large = _candidate(
+        "recurrence",
+        10,
+        1.0,
+        rss_kib=(30 * 1024**2) + 1,
+    )
+
+    assert accepted.cold_to_ready_seconds > 900.0
+    assert acceptance.optional_candidate_is_feasible(accepted)
+    assert not acceptance.optional_candidate_is_feasible(slow_generation)
+    assert not acceptance.optional_candidate_is_feasible(slow_first_warm)
+    assert not acceptance.optional_candidate_is_feasible(large)
+
+
+def test_candidate_generation_commands_lock_paired_helicity_semantics(
+    tmp_path: Path,
+) -> None:
+    on_the_fly = acceptance.candidate_generation_command(
+        python="python-test",
+        lane="on-the-fly",
+        total_gluons=4,
+        helicities=(1, 1, 1, 1),
+        artifact=tmp_path / "artifact",
+    )
+    recurrence = acceptance.candidate_generation_command(
+        python="python-test",
+        lane="recurrence",
+        total_gluons=4,
+        helicities=(1, 1, 1, 1),
+        artifact=tmp_path / "recurrence-artifact",
+    )
+
+    for command, lane in ((on_the_fly, "on-the-fly"), (recurrence, "recurrence")):
+        assert command[:4] == ("python-test", "-m", "pyamplicol", "generate")
+        assert command[command.index("--color-accuracy") + 1] == "full"
+        assert command[command.index("--color-contraction") + 1] == (
+            "symmetric-group-fft"
+        )
+        assert command[command.index("--execution-mode") + 1] == lane
+        assert "evaluator.batch_size=1" in command
+        assert "evaluator.optimization.cores=1" in command
+        assert "model.cache=false" in command
+    selection = "process.selected_source_helicities={1=1,2=1,3=1,4=1}"
+    assert selection not in on_the_fly
+    assert selection in recurrence
+
+
+def test_dry_run_is_nonwriting_and_covers_locked_seeds(
+    capsys: pytest.CaptureFixture[str],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    run_id = "pytest-dry-run-fft-policy"
+    run_root = acceptance.PERFORMANCE_ROOT / "runs" / run_id
+    assert not run_root.exists()
+
+    monkeypatch.setattr(acceptance.sys, "platform", "darwin")
+    result = acceptance.main(("--dry-run", "--include-optional", "--run-id", run_id))
+
+    assert result == 0
+    assert not run_root.exists()
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["dry_run"] is True
+    assert payload["host_platform"] == "darwin"
+    assert payload["reference"]["process_measurement"] == (
+        "darwin-getrusage-child-plus-watchdog"
+    )
+    assert payload["reference"]["rss_marker"] == "FFT_MAX_RSS_KIB"
+    assert [item["total_gluons"] for item in payload["multiplicities"]] == list(
+        range(4, 12)
+    )
+    assert [item["generator_seed"] for item in payload["multiplicities"]] == list(
+        range(1733, 1741)
+    )
+    assert all(
+        item["candidate_lanes"] == ["recurrence", "on-the-fly"]
+        for item in payload["multiplicities"][:6]
+    )
+    assert all(
+        item["candidate_lanes"] == ["global-winner"]
+        for item in payload["multiplicities"][6:]
+    )
+    assert payload["measurement"] | {"cpu_policy": None} == {
+        "batch_size": 1,
+        "calibration_scope": "representative-point-1-only",
+        "calibration_seconds_minimum": 0.25,
+        "candidate_timer_source": "process-cpu-time",
+        "cpu_cores": 1,
+        "cpu_policy": None,
+        "fresh_process_same_os_rss": True,
+        "mandatory_lane_order": ["recurrence", "on-the-fly"],
+        "memory_limit_gib": 30.0,
+        "model_cache": "disabled-per-lane-and-multiplicity",
+        "optional_cold_and_warm_processes_separate": True,
+        "timed_event_cells_per_batch": 1,
+        "warm_batch_reduction": "point-1-cell-direct",
+        "warm_excludes_first_call": True,
+        "warm_samples": 10,
+    }
+    cpu_policy = payload["measurement"]["cpu_policy"]
+    assert cpu_policy["method"] == "single-thread-environment"
+    assert cpu_policy["requested_cpu_cores"] == 1
+    assert cpu_policy["affinity_available"] is False
+    assert cpu_policy["affinity_enforced"] is False
+    assert cpu_policy["cpu"] is None
+    assert set(cpu_policy["thread_environment"]) == set(
+        acceptance.SINGLE_THREAD_ENVIRONMENT
+    )
+    assert set(cpu_policy["thread_environment"].values()) == {"1"}
+    assert "on-the-fly" in payload["global_lane_policy"]
+    assert (
+        "eligible under their respective helicity workloads"
+        in payload["global_lane_policy"]
+    )
+    assert "passing every mandatory gate" in payload["global_lane_policy"]
+    assert payload["helicity_policy"] == {
+        "on-the-fly": "complete-runtime-selector-fixed-helicity-query",
+        "recurrence": "generation-specialized-known-nonzero",
+    }
+    assert payload["thresholds"] | {
+        "warm_ratio_maximum": None,
+        "rss_ratio_maximum": None,
+        "cold_to_ready_ratio_maximum": None,
+    } == {
+        "warm_ratio_maximum": None,
+        "rss_ratio_maximum": None,
+        "cold_to_ready_ratio_maximum": None,
+        "optional_generation_seconds_maximum_exclusive": 900.0,
+        "optional_first_warm_seconds_maximum_exclusive": 900.0,
+        "optional_continuation_deadlines_are_independent": True,
+    }
+    assert payload["reference"]["formal_cold_to_ready_metric"] == (
+        "clean AmpliGluonTrace backend build plus initialization plus first "
+        "complete pass"
+    )
+    assert payload["reference"]["clean_build_scope"] == (
+        "ampligluon-trace-backend-only"
+    )
+    assert payload["reference"]["clean_build_program"] == ("benchmark_ampligluon_trace")
+    assert (
+        "RAMBO and helicity-proxy builds excluded"
+        in payload["reference"]["clean_build_timing"]
+    )
+    assert payload["reference"]["scaling_setup_to_ready_metric"] == (
+        "all setup through driver plus initialization plus first complete pass"
+    )
+    assert payload["schema_version"] == 8
+    assert payload["numerical_parity"] == {
+        "reference_values": "ordered-10-AmpliGluonTrace-matrix-elements",
+        "candidate_values": (
+            "recurrence-first-pass-all-10;"
+            "otf-first-pass-points-2-10-plus-point-1-calibration"
+        ),
+        "candidate_runtime_parameter": "normalization.alpha_s_me_check",
+        "candidate_runtime_parameter_value": pytest.approx(
+            1.0 / (4.0 * acceptance.math.pi)
+        ),
+        "candidate_to_reference_scale": "256*factorial(N-2)",
+        "relative_error_scale": "max(abs(candidate),abs(reference))",
+        "relative_tolerance": 1.0e-10,
+        "failure_is_fatal": True,
+        "extra_evaluations": 0,
+    }
+
+
+def test_dry_run_rejects_unsafe_run_id_without_writing() -> None:
+    assert acceptance.main(("--dry-run", "--run-id", "../outside")) == 1
+
+
+def test_probe_commands_separate_optional_cold_from_warmed_campaign(
+    tmp_path: Path,
+) -> None:
+    common = {
+        "probe": tmp_path / "probe",
+        "artifact": tmp_path / "artifact",
+        "total_gluons": 4,
+        "target_seconds": 0.25,
+        "event_paths": tuple(tmp_path / f"point-{index}.event" for index in range(10)),
+    }
+    first_ready = acceptance._candidate_probe_command(**common, first_ready_only=True)
+    warmed = acceptance._candidate_probe_command(**common, first_ready_only=False)
+
+    assert "--first-ready-only" in first_ready
+    assert "--first-ready-only" not in warmed
+    assert first_ready[-10:] == warmed[-10:]
+
+
+def test_optional_candidate_gives_generation_and_first_ready_independent_deadlines(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[tuple[tuple[str, ...], float]] = []
+    outputs = iter(("", _first_ready_output(), _probe_output()))
+
+    def fake_run_watched(
+        command: tuple[str, ...],
+        **kwargs: object,
+    ) -> acceptance.WatchedCompletedProcess:
+        calls.append((command, float(kwargs["timeout_seconds"])))
+        return acceptance.WatchedCompletedProcess(
+            command,
+            0,
+            next(outputs),
+            "",
+            elapsed_seconds=1.0,
+            log_write_seconds=0.1,
+            timed_out=False,
+            timeout_cleanup="not-required",
+        )
+
+    clock = iter((100.0, 105.0, 105.1))
+    monkeypatch.setattr(acceptance, "_run_watched", fake_run_watched)
+    monkeypatch.setattr(acceptance.time, "perf_counter", lambda: next(clock))
+    reference = acceptance._ReferenceRun(
+        metrics=_reference(4),
+        event_paths=tuple(tmp_path / f"point-{index}.event" for index in range(10)),
+    )
+
+    candidate = acceptance._run_candidate(
+        lane="recurrence",
+        total_gluons=4,
+        reference=reference,
+        probe=tmp_path / "probe",
+        run_root=tmp_path / "run",
+        python=sys.executable,
+        environment={},
+        target_seconds=0.25,
+        timeout_seconds=3600.0,
+        continuation_stage_limit_seconds=900.0,
+    )
+
+    assert candidate.generation_seconds == pytest.approx(4.9)
+    assert candidate.cold_to_ready_seconds == pytest.approx(5.4)
+    assert candidate.max_rss_kib == 4096
+    assert calls[0][1] == pytest.approx(900.0)
+    assert "--first-ready-only" in calls[1][0]
+    assert calls[1][1] == pytest.approx(3600.0)
+    assert "--first-ready-only" not in calls[2][0]
+    assert calls[2][1] == pytest.approx(3600.0)
+
+
+def test_native_probe_uses_public_allocation_free_call_and_lane_guard() -> None:
+    source = acceptance.PROBE_SOURCE.read_text(encoding="utf-8")
+
+    assert "#include <rusticol.h>" in source
+    assert "#include <rusticol.hpp>" not in source
+    assert "rusticol_runtime_evaluate_f64" in source
+    assert "rusticol_runtime_evaluate_selected_f64" in source
+    assert 'execution_mode == "recurrence" && runtime_helicity_count == 1' in source
+    assert "arguments.color_id.empty()" in source
+    assert "if (generation_specialized_total)" in source
+    assert "&selected_helicity_index" in source
+    assert 'execution_mode == "compiled" ? nullptr' not in source
+    assert 'if (execution_mode == "on-the-fly")' in source
+    assert source.count("rusticol_runtime_warm_up_f64") == 1
+    assert "first_evaluated_point" not in source
+    assert "for (std::size_t point = 0; point < events.size(); ++point)" in source
+    assert "CLOCK_PROCESS_CPUTIME_ID" in source
+    assert "rusticol_runtime_set_model_parameter" in source
+    assert '"normalization.alpha_s_me_check"' in source
+    assert "kUnitCouplingAlphaS" in source
+    assert source.count("evaluate_one(") == 4
+    assert source.count("evaluate_repeated_batch(") == 2
+    assert 'token == "--batch-size"' in source
+    assert '"BENCHMARK_BATCH_SIZE "' in source
+    assert "events[point % events.size()]" in source
+    assert "authenticate_batch_results(" in source
+    assert "expected[index % expected.size()]" in source
+    assert '"BATCH_INPUT_PATTERN cyclic-10-events' in source
+    assert '"BATCH_AUTHENTICATED_POINT_COUNT "' in source
+    assert '"BATCH_MAX_RELATIVE_ERROR "' in source
+    assert "CLOCK_MONOTONIC" in source
+    assert '"START_TO_FIRST_WARM_WALL_SECONDS "' in source
+    assert "FFT_CANDIDATE_PROBE_V4" in source
+    assert "point_values[point] = evaluate_one(" in source
+    assert "point_values[kRepresentativePoint] = last_value" in source
+    assert "std::array<double, kWarmSampleCount> warm_cells" in source
+    assert "calibration_calls[point]" not in source
+    assert "warm_cells[sample][point]" not in source
+    assert "POINT_VALUE" in source
+    assert "CALIBRATION_CELL" in source
+    assert "WARM_CELL_SECONDS" in source
+
+
+class _GracefulTimeoutPopen:
+    def __init__(self) -> None:
+        self.returncode: int | None = None
+        self.communicate_timeouts: list[float | None] = []
+        self.terminated = False
+        self.killed = False
+
+    def communicate(self, timeout: float | None = None) -> tuple[str, str]:
+        self.communicate_timeouts.append(timeout)
+        if len(self.communicate_timeouts) == 1:
+            raise subprocess.TimeoutExpired(("watchdog",), timeout)
+        self.returncode = -15
+        return "partial stdout", "watchdog cleaned child tree"
+
+    def terminate(self) -> None:
+        self.terminated = True
+
+    def kill(self) -> None:
+        self.killed = True
+
+
+class _FallbackTimeoutPopen(_GracefulTimeoutPopen):
+    def communicate(self, timeout: float | None = None) -> tuple[str, str]:
+        self.communicate_timeouts.append(timeout)
+        if len(self.communicate_timeouts) <= 2:
+            raise subprocess.TimeoutExpired(("watchdog",), timeout)
+        self.returncode = -9
+        return "partial stdout", "watchdog required fallback kill"
+
+
+def test_watched_timeout_signals_watchdog_and_waits_for_tree_cleanup(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fake = _GracefulTimeoutPopen()
+    monkeypatch.setattr(acceptance.subprocess, "Popen", lambda *args, **kwargs: fake)
+    log_path = tmp_path / "timeout.json"
+
+    with pytest.raises(acceptance.AcceptanceError, match="sigterm-complete"):
+        acceptance._run_watched(
+            ("payload",),
+            python=sys.executable,
+            environment={},
+            timeout_seconds=0.01,
+            log_path=log_path,
+        )
+
+    assert fake.terminated is True
+    assert fake.killed is False
+    assert fake.communicate_timeouts[1] > 5.0
+    evidence = json.loads(log_path.read_text(encoding="utf-8"))
+    assert evidence["timed_out"] is True
+    assert evidence["timeout_cleanup"] == "sigterm-complete"
+    assert evidence["elapsed_excludes_log_write"] is True
+
+
+def test_watched_timeout_records_fallback_kill(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fake = _FallbackTimeoutPopen()
+    monkeypatch.setattr(acceptance.subprocess, "Popen", lambda *args, **kwargs: fake)
+    log_path = tmp_path / "timeout-fallback.json"
+
+    with pytest.raises(acceptance.AcceptanceError, match="sigkill-fallback"):
+        acceptance._run_watched(
+            ("payload",),
+            python=sys.executable,
+            environment={},
+            timeout_seconds=0.01,
+            log_path=log_path,
+        )
+
+    assert fake.terminated is True
+    assert fake.killed is True
+    evidence = json.loads(log_path.read_text(encoding="utf-8"))
+    assert evidence["timeout_cleanup"] == "sigkill-fallback"
+
+
+def test_watchdog_report_preserves_exact_peak_guard_for_rss_aggregation(
+    tmp_path: Path,
+) -> None:
+    report_path = tmp_path / "watchdog.json"
+    report_path.write_text(
+        json.dumps(
+            {
+                "complete": True,
+                "passes": True,
+                "enforcement": {
+                    "peak_rss_bytes": 125_953,
+                    "peak_guard_bytes": 126_977,
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    assert acceptance._read_watchdog_usage_kib(report_path) == (124, 125)
+    command = acceptance._watchdog_command(
+        ("payload",),
+        python=sys.executable,
+        memory_limit_gib=20.0,
+        report_json=report_path,
+    )
+    assert command[-4:] == ("--report-json", str(report_path), "--", "payload")
+
+
+def test_candidate_probe_compiles_and_links_against_public_sdk() -> None:
+    compiler = acceptance.shlex.split(os.environ.get("CXX", "c++"))
+    if not compiler or shutil.which(compiler[0]) is None:
+        pytest.skip("no C++ compiler is available for the public-SDK smoke test")
+    run_root = (
+        acceptance.PERFORMANCE_ROOT
+        / "test-native-smoke"
+        / f"pytest-{os.getpid()}-{uuid.uuid4().hex}"
+    )
+    try:
+        acceptance._create_workspace_directories(run_root)
+        sdk_root = acceptance.ROOT / "src" / "pyamplicol" / "_sdk"
+        metadata = json.loads((sdk_root / "metadata.json").read_text(encoding="utf-8"))
+        link = json.loads((sdk_root / "link.json").read_text(encoding="utf-8"))
+        probe = run_root / "candidate-probe" / "fft-gluon-candidate-probe"
+        probe.parent.mkdir(parents=True, exist_ok=True)
+        acceptance._run_watched(
+            (
+                *compiler,
+                "-std=c++17",
+                "-O3",
+                "-DNDEBUG",
+                f"-I{sdk_root / 'include'}",
+                str(acceptance.PROBE_SOURCE),
+                "-o",
+                str(probe),
+                str(sdk_root / str(metadata["archive"])),
+                *(f"-l{name}" for name in link.get("system_libraries", [])),
+                *(
+                    token
+                    for name in link.get("frameworks", [])
+                    for token in ("-framework", str(name))
+                ),
+                *acceptance._candidate_probe_executable_link_flags(sys.platform),
+            ),
+            python=sys.executable,
+            environment=acceptance._workspace_environment(sys.executable),
+            timeout_seconds=600.0,
+            log_path=run_root / "logs" / "candidate-probe-build.json",
+        )
+        assert probe.is_file()
+        assert metadata["abi_version"] == 1
+    finally:
+        shutil.rmtree(run_root, ignore_errors=True)
+
+
+@pytest.mark.parametrize(
+    ("platform_name", "expected"),
+    (
+        (
+            "darwin",
+            ("-Wl,-dead_strip", "-Wl,-no_exported_symbols"),
+        ),
+        ("linux", ()),
+        ("win32", ()),
+    ),
+)
+def test_candidate_probe_executable_link_flags_are_darwin_scoped(
+    platform_name: str,
+    expected: tuple[str, ...],
+) -> None:
+    assert acceptance._candidate_probe_executable_link_flags(platform_name) == expected
+
+
+def _mock_performance_campaign_dependencies(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    recurrence_warm: float,
+    otf_warm: float = 0.1,
+) -> tuple[Path, list[tuple[str, int]]]:
+    performance_root = tmp_path / "performance"
+    source_identity = acceptance.ReportSourceIdentity("a" * 40, "b" * 40, ())
+    calls: list[tuple[str, int]] = []
+    monkeypatch.setattr(acceptance, "PERFORMANCE_ROOT", performance_root)
+    monkeypatch.setattr(
+        acceptance,
+        "_require_campaign_source_identity",
+        lambda _expected=None: source_identity,
+    )
+    reference_source_identity = acceptance.ReferenceSourceIdentity(
+        acceptance.REFERENCE_REVISION, "c" * 64, 4
+    )
+    monkeypatch.setattr(
+        acceptance,
+        "_require_reference_source_identity",
+        lambda _expected=None: reference_source_identity,
+    )
+    monkeypatch.setattr(acceptance, "_workspace_environment", lambda _python: {})
+    monkeypatch.setattr(
+        acceptance,
+        "_enforce_one_core",
+        lambda _platform: {"requested_cpu_cores": 1},
+    )
+    monkeypatch.setattr(
+        acceptance,
+        "_build_probe",
+        lambda **_kwargs: (
+            tmp_path / "probe",
+            {"target": "test-target", "package_version": "test-version"},
+        ),
+    )
+    monkeypatch.setattr(acceptance, "_load_reference_module", object)
+
+    def fake_reference(**kwargs: object) -> acceptance._ReferenceRun:
+        total_gluons = int(kwargs["total_gluons"])
+        calls.append(("reference", total_gluons))
+        return acceptance._ReferenceRun(
+            metrics=_reference(total_gluons),
+            event_paths=tuple(
+                tmp_path / f"N{total_gluons}-point-{point}.event" for point in range(10)
+            ),
+        )
+
+    def fake_candidate(**kwargs: object) -> acceptance.CandidateMetrics:
+        lane = str(kwargs["lane"])
+        total_gluons = int(kwargs["total_gluons"])
+        calls.append((lane, total_gluons))
+        return _candidate(
+            lane,
+            total_gluons,
+            recurrence_warm if lane == "recurrence" else otf_warm,
+        )
+
+    monkeypatch.setattr(acceptance, "_run_reference", fake_reference)
+    monkeypatch.setattr(acceptance, "_run_candidate", fake_candidate)
+    return performance_root, calls
+
+
+def test_campaign_stops_after_first_dispositive_mandatory_failure(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    performance_root, calls = _mock_performance_campaign_dependencies(
+        tmp_path,
+        monkeypatch,
+        recurrence_warm=2.0,
+        otf_warm=2.0,
+    )
+    arguments = acceptance._parser().parse_args(("--run-id", "early-mandatory-failure"))
+
+    result = acceptance._campaign(arguments)
+
+    assert calls == [("reference", 4), ("recurrence", 4), ("on-the-fly", 4)]
+    assert result["status"] == "failed-performance-gates"
+    assert result["terminal"] is True
+    assert result["passes"] is False
+    assert result["dry_run"] is False
+    assert result["policy"]["dry_run"] is False
+    assert (
+        result["source_identity"]
+        == acceptance.ReportSourceIdentity("a" * 40, "b" * 40, ()).provenance()
+    )
+    assert (
+        result["reference_source_identity"]
+        == acceptance.ReferenceSourceIdentity(
+            acceptance.REFERENCE_REVISION, "c" * 64, 4
+        ).provenance()
+    )
+    assert result["failure"]["kind"] == "no-global-lane-remains"
+    viability = result["observed_gate_viability"]
+    assert viability["completed_multiplicities"] == [4]
+    assert viability["viable_lanes"] == []
+    assert viability["lanes"]["recurrence"]["eligible"] is True
+    assert viability["lanes"]["recurrence"]["viable"] is False
+    recurrence_gate = viability["lanes"]["recurrence"]["gates"][0]
+    assert recurrence_gate["warm_passes"] is False
+    assert recurrence_gate["rss_passes"] is True
+    assert recurrence_gate["cold_passes"] is True
+    report = json.loads(
+        (
+            performance_root / "runs" / "early-mandatory-failure" / "report.json"
+        ).read_text(encoding="utf-8")
+    )
+    assert report == json.loads(json.dumps(result))
+
+
+def test_campaign_keeps_running_when_only_otf_remains_viable(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _performance_root, calls = _mock_performance_campaign_dependencies(
+        tmp_path,
+        monkeypatch,
+        recurrence_warm=2.0,
+        otf_warm=0.1,
+    )
+    arguments = acceptance._parser().parse_args(("--run-id", "otf-survives"))
+
+    result = acceptance._campaign(arguments)
+
+    expected_calls = [
+        call
+        for total in acceptance.MANDATORY_MULTIPLICITIES
+        for call in (
+            ("reference", total),
+            ("recurrence", total),
+            ("on-the-fly", total),
+        )
+    ]
+    assert calls == expected_calls
+    assert result["status"] == "complete"
+    assert result["passes"] is True
+    assert result["global_winning_lane"] == "on-the-fly"
+    assert {gate["lane"] for gate in result["gates"]} == {"on-the-fly"}
+
+
+def test_campaign_uses_one_stable_winner_for_every_mandatory_row(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _performance_root, calls = _mock_performance_campaign_dependencies(
+        tmp_path,
+        monkeypatch,
+        recurrence_warm=0.5,
+        otf_warm=1.0,
+    )
+    arguments = acceptance._parser().parse_args(("--run-id", "stable-winner"))
+
+    result = acceptance._campaign(arguments)
+
+    assert len(calls) == 3 * len(acceptance.MANDATORY_MULTIPLICITIES)
+    assert result["status"] == "complete"
+    assert result["passes"] is True
+    assert result["global_winning_lane"] == "recurrence"
+    assert [gate["total_gluons"] for gate in result["gates"]] == list(
+        acceptance.MANDATORY_MULTIPLICITIES
+    )
+    assert {gate["lane"] for gate in result["gates"]} == {"recurrence"}
+
+
+def test_campaign_source_preflight_rejects_dirty_tracked_inputs(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def reject_source(_root: Path) -> acceptance.ReportSourceIdentity:
+        raise acceptance.ReportSourceIdentityError(
+            "dirty source paths: tools/developer/fft_gluon_performance_acceptance.py"
+        )
+
+    monkeypatch.setattr(acceptance, "require_eligible_report_source", reject_source)
+    monkeypatch.setattr(acceptance, "PERFORMANCE_ROOT", tmp_path / "performance")
+    monkeypatch.setattr(
+        acceptance,
+        "_create_workspace_directories",
+        lambda _root: pytest.fail("dirty source must fail before workspace creation"),
+    )
+    arguments = acceptance._parser().parse_args(("--run-id", "dirty-source"))
+
+    with pytest.raises(acceptance.AcceptanceError, match="dirty source paths"):
+        acceptance._campaign(arguments)
+
+
+def test_campaign_source_postflight_rejects_head_change(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    started = acceptance.ReportSourceIdentity("a" * 40, "b" * 40, ())
+    changed = acceptance.ReportSourceIdentity("c" * 40, "d" * 40, ())
+    monkeypatch.setattr(
+        acceptance,
+        "require_eligible_report_source",
+        lambda _root: changed,
+    )
+
+    with pytest.raises(acceptance.AcceptanceError, match="identity changed"):
+        acceptance._require_campaign_source_identity(started)
+
+
+def _git(repository: Path, *arguments: str) -> str:
+    return subprocess.run(
+        ("git", "-C", str(repository), *arguments),
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+
+def test_reference_source_identity_allows_dirty_inputs_and_detects_changes(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repository = tmp_path / "reference"
+    repository.mkdir()
+    subprocess.run(
+        ("git", "init", "--quiet", str(repository)),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    (repository / ".gitignore").write_text("ignored.tmp\n", encoding="utf-8")
+    (repository / "tracked.txt").write_text("committed\n", encoding="utf-8")
+    _git(repository, "add", ".gitignore", "tracked.txt")
+    _git(
+        repository,
+        "-c",
+        "user.name=FFT acceptance",
+        "-c",
+        "user.email=fft-acceptance@example.invalid",
+        "commit",
+        "--quiet",
+        "-m",
+        "fixture",
+    )
+    revision = _git(repository, "rev-parse", "HEAD")
+    monkeypatch.setattr(acceptance, "REFERENCE_ROOT", repository)
+    monkeypatch.setattr(acceptance, "REFERENCE_REVISION", revision)
+
+    # Intentional tracked and nonignored-untracked patches are authenticated,
+    # not rejected for making the reference checkout dirty.
+    (repository / "tracked.txt").write_text("intentional patch\n", encoding="utf-8")
+    (repository / "extra.txt").write_text("campaign input\n", encoding="utf-8")
+    started = acceptance._require_reference_source_identity()
+    assert started.revision == revision
+    assert started.file_count == 3
+    assert acceptance._require_reference_source_identity(started) == started
+
+    # Ignored build products are deliberately outside the source identity.
+    (repository / "ignored.tmp").write_text("build output\n", encoding="utf-8")
+    assert acceptance._require_reference_source_identity(started) == started
+
+    (repository / "extra.txt").write_text("changed campaign input\n", encoding="utf-8")
+    with pytest.raises(acceptance.AcceptanceError, match="identity changed"):
+        acceptance._require_reference_source_identity(started)
+
+
+def test_reference_source_identity_requires_the_locked_revision(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    assert acceptance.REFERENCE_REVISION == "9c3cb4fb4658200884553bab796e85bd5e7fe7a9"
+    repository = tmp_path / "reference"
+    repository.mkdir()
+    subprocess.run(
+        ("git", "init", "--quiet", str(repository)),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    (repository / "input.txt").write_text("input\n", encoding="utf-8")
+    _git(repository, "add", "input.txt")
+    _git(
+        repository,
+        "-c",
+        "user.name=FFT acceptance",
+        "-c",
+        "user.email=fft-acceptance@example.invalid",
+        "commit",
+        "--quiet",
+        "-m",
+        "fixture",
+    )
+    monkeypatch.setattr(acceptance, "REFERENCE_ROOT", repository)
+
+    with pytest.raises(acceptance.AcceptanceError, match="wrong revision"):
+        acceptance._require_reference_source_identity()
diff --git a/pyamplicol/tests/unit/test_fft_madgraph_selected_runtime.py b/pyamplicol/tests/unit/test_fft_madgraph_selected_runtime.py
new file mode 100644
index 0000000000..e152e23a0b
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fft_madgraph_selected_runtime.py
@@ -0,0 +1,1728 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from tools.developer import fft_madgraph_selected_runtime as madgraph
+
+
+def _event_text(
+    family: str,
+    n: int,
+    point: int,
+    helicity: tuple[int, ...],
+) -> str:
+    header = (
+        f"AMPLIGLUON_EVENT_V1\nFINAL_GLUONS {n}\nSTRONG_COUPLING 1.0\n"
+        if family == "gg"
+        else "PYAMPLICOL_SCALING_EVENT_V1\n"
+    )
+    momenta = "\n".join(
+        f"{point + index}.0 {index + 1}.0 0.0 0.0"
+        for index in range(n + 2)
+    )
+    return (
+        f"{header}BEGIN_MOMENTA\n{momenta}\nEND_MOMENTA\n"
+        "NHELICITIES 1\nBEGIN_HELICITIES\n"
+        f"{' '.join(str(value) for value in helicity)}\n"
+        "END_HELICITIES\n"
+    )
+
+
+def _source_cell(
+    *,
+    family: str,
+    mode: str,
+    n: int,
+    helicity: tuple[int, ...],
+    event_paths: tuple[Path, ...],
+) -> dict[str, object]:
+    return {
+        "family": family,
+        "mode": mode,
+        "n": n,
+        "total_external": n + 2,
+        "process": madgraph.process_expression(family, n),
+        "status": "measured",
+        "label": f"test {family} {mode} n={n}",
+        "helicity_workload": "fixed",
+        "warm_fixed_helicity": True,
+        "warm_helicity_sum": False,
+        "helicity": list(helicity),
+        "event_paths": [str(path) for path in event_paths],
+        "point_values": [float(point) for point in range(1, 11)],
+    }
+
+
+def _make_source_report(root: Path) -> Path:
+    events_root = root / "events"
+    cells: dict[str, dict[str, dict[str, dict[str, object]]]] = {
+        "gg": {"reference-fft": {}, "recurrence-fft": {}},
+        "ddbar": {"recurrence-fft": {}},
+    }
+    for family in madgraph.FAMILIES:
+        modes = tuple(cells[family])
+        for n in madgraph.FINAL_MULTIPLICITIES:
+            helicity = tuple(
+                1 if family == "gg" or index % 2 else -1
+                for index in range(n + 2)
+            )
+            event_directory = events_root / family / f"n{n}"
+            event_directory.mkdir(parents=True)
+            event_paths: list[Path] = []
+            for point in range(1, madgraph.POINT_COUNT + 1):
+                event = event_directory / f"point-{point:02d}.event"
+                event.write_text(
+                    _event_text(family, n, point, helicity),
+                    encoding="utf-8",
+                )
+                event_paths.append(event)
+            for mode in modes:
+                cells[family][mode][str(n)] = _source_cell(
+                    family=family,
+                    mode=mode,
+                    n=n,
+                    helicity=helicity,
+                    event_paths=tuple(event_paths),
+                )
+    report = root / "source-report.json"
+    report.write_text(
+        json.dumps(
+            {
+                "kind": madgraph.SOURCE_KIND,
+                "schema_version": 1,
+                "policy": {
+                    "measurement": {
+                        "alpha_s": 0.118,
+                        "helicity_workload": "fixed",
+                        "warm_fixed_helicity": True,
+                        "warm_helicity_sum": False,
+                    }
+                },
+                "cells": cells,
+            }
+        ),
+        encoding="utf-8",
+    )
+    return report
+
+
+@pytest.fixture(scope="module")
+def source_report(tmp_path_factory: pytest.TempPathFactory) -> Path:
+    return _make_source_report(tmp_path_factory.mktemp("madgraph-source"))
+
+
+@pytest.fixture(scope="module")
+def matrix_source(tmp_path_factory: pytest.TempPathFactory) -> Path:
+    path = tmp_path_factory.mktemp("madgraph-matrix") / "matrix.f"
+    path.write_text(
+        """      REAL*8 FUNCTION MATRIX(P,NHEL,IC)
+      INTEGER NEXTERNAL
+      PARAMETER (NEXTERNAL=4)
+      INTEGER NHEL(NEXTERNAL)
+      INTEGER NGRAPHS
+      PARAMETER (NGRAPHS=3)
+      INTEGER NCOLOR
+      PARAMETER (NCOLOR=2)
+      MATRIX=1D0
+      END
+      SUBROUTINE SMATRIX(P,ANS)
+      INTEGER NCOMB
+      PARAMETER (NCOMB=16)
+      INTEGER NHEL(NEXTERNAL,NCOMB)
+      INTEGER IDEN
+      DATA IDEN/512/
+      ANS=1D0
+      ANS=ANS/DBLE(IDEN)
+      END
+""",
+        encoding="utf-8",
+    )
+    return path
+
+
+def test_publication_process_grid_is_final_state_n2_through_n9() -> None:
+    assert tuple(range(2, 10)) == madgraph.FINAL_MULTIPLICITIES
+    assert madgraph.process_expression("gg", 2) == "g g > g g"
+    assert madgraph.process_expression("gg", 9) == "g g > g g g g g g g g g"
+    assert madgraph.process_expression("ddbar", 2) == "d d~ > d d~"
+    assert madgraph.process_expression("ddbar", 9) == "d d~ > d d~ g g g g g g g"
+    with pytest.raises(madgraph.SelectedMadGraphError, match="unsupported"):
+        madgraph.process_expression("qq", 2)
+    with pytest.raises(madgraph.SelectedMadGraphError, match="unsupported"):
+        madgraph.process_expression("gg", 1)
+    assert madgraph.process_expression("gg", 10).endswith("g g g g g g g g")
+
+
+def test_cli_requires_explicit_source_report_and_madgraph_installation(
+    tmp_path: Path,
+) -> None:
+    common = (
+        "--cache-dir",
+        str(tmp_path / "cache"),
+        "--output",
+        str(tmp_path / "report.json"),
+    )
+    with pytest.raises(SystemExit):
+        madgraph._parser().parse_args(common)
+    with pytest.raises(SystemExit):
+        madgraph._parser().parse_args(
+            (*common, "--source-report", str(tmp_path / "source.json"))
+        )
+    with pytest.raises(SystemExit):
+        madgraph._parser().parse_args(
+            (*common, "--mg5-root", str(tmp_path / "mg5"))
+        )
+
+    arguments = madgraph._parser().parse_args(
+        (
+            *common,
+            "--source-report",
+            str(tmp_path / "source.json"),
+            "--mg5-root",
+            str(tmp_path / "mg5"),
+        )
+    )
+    assert arguments.source_report == tmp_path / "source.json"
+    assert arguments.mg5_root == tmp_path / "mg5"
+    assert arguments.target_seconds == madgraph.TARGET_SECONDS
+
+
+def test_source_selection_authenticates_both_families_and_all_points(
+    source_report: Path,
+) -> None:
+    source = madgraph.load_source_selection(source_report)
+    assert source.alpha_s == 0.118
+    assert set(source.cells) == {"gg", "ddbar"}
+    assert set(source.cells["gg"]) == set(range(2, 10))
+    assert set(source.cells["ddbar"]) == set(range(2, 10))
+    assert source.unavailable == {"gg": {}, "ddbar": {}}
+    assert source.cells["gg"][2].source_mode == "reference-fft"
+    assert source.cells["ddbar"][2].source_mode == "recurrence-fft"
+
+    for family in madgraph.FAMILIES:
+        for n in madgraph.FINAL_MULTIPLICITIES:
+            cell = source.cells[family][n]
+            assert cell.process == madgraph.process_expression(family, n)
+            assert len(cell.helicity) == n + 2
+            assert len(cell.events) == madgraph.POINT_COUNT
+            assert len(cell.reference_point_values) == madgraph.POINT_COUNT
+            assert len({event.sha256 for event in cell.events}) == 10
+            assert all(event.helicity == cell.helicity for event in cell.events)
+
+    assert source.cells["gg"][2].events[0].strong_coupling == 1.0
+    assert source.cells["ddbar"][2].events[0].strong_coupling == pytest.approx(
+        math.sqrt(4.0 * math.pi * source.alpha_s)
+    )
+
+
+def test_source_selection_can_authenticate_one_family(
+    source_report: Path,
+) -> None:
+    source = madgraph.load_source_selection(
+        source_report, multiplicities=(2,), families=("gg",)
+    )
+
+    assert set(source.cells) == {"gg"}
+    assert set(source.unavailable) == {"gg"}
+    assert set(source.cells["gg"]) == {2}
+    assert source.cells["gg"][2].process == "g g > g g"
+
+
+def test_source_selection_rejects_changed_event_helicity(
+    tmp_path: Path,
+    source_report: Path,
+) -> None:
+    payload = json.loads(source_report.read_text(encoding="utf-8"))
+    payload["cells"]["ddbar"]["recurrence-fft"]["2"]["helicity"][0] *= -1
+    report = tmp_path / "source.json"
+    report.write_text(json.dumps(payload), encoding="utf-8")
+    with pytest.raises(madgraph.SelectedMadGraphError, match="event helicities"):
+        madgraph.load_source_selection(report)
+
+
+def test_source_selection_rejects_duplicate_event_payloads(tmp_path: Path) -> None:
+    report = _make_source_report(tmp_path)
+    payload = json.loads(report.read_text(encoding="utf-8"))
+    paths = payload["cells"]["gg"]["reference-fft"]["2"]["event_paths"]
+    Path(paths[1]).write_bytes(Path(paths[0]).read_bytes())
+    with pytest.raises(madgraph.SelectedMadGraphError, match="unique event payloads"):
+        madgraph.load_source_selection(report, multiplicities=(2,))
+
+
+def _summed_source_report(tmp_path: Path, source_report: Path) -> Path:
+    payload = json.loads(source_report.read_text(encoding="utf-8"))
+    measurement = payload["policy"]["measurement"]
+    measurement.update(
+        {
+            "helicity_workload": "sum",
+            "warm_fixed_helicity": False,
+            "warm_helicity_sum": True,
+        }
+    )
+    for family in madgraph.FAMILIES:
+        mode = madgraph.SUM_SOURCE_MODE[family]
+        for cell in payload["cells"][family][mode].values():
+            cell.update(
+                {
+                    "helicity_workload": "sum",
+                    "warm_fixed_helicity": False,
+                    "warm_helicity_sum": True,
+                }
+            )
+    report = tmp_path / "summed-source.json"
+    report.write_text(json.dumps(payload), encoding="utf-8")
+    return report
+
+
+def test_summed_source_uses_candidate_convention_and_native_smatrix(
+    tmp_path: Path,
+    source_report: Path,
+) -> None:
+    source = madgraph.load_source_selection(
+        _summed_source_report(tmp_path, source_report),
+        multiplicities=(2,),
+        helicity_workload="sum",
+    )
+    assert source.helicity_workload == "sum"
+    assert source.cells["gg"][2].source_mode == "recurrence-fft"
+    assert source.cells["ddbar"][2].source_mode == "recurrence-fft"
+
+    body = madgraph.render_check_source(
+        source.cells["gg"][2], summed_helicity_coverage_count=16
+    )
+    compact = body.replace(" ", "")
+    assert body.count("CALL SMATRIX(") == 3
+    assert "USERHEL=-1" in compact
+    assert "MATRIX(P(0,1,E),HEL,IC)" not in body
+    assert f"ASVALUE={madgraph._fortran_double(source.alpha_s)}" in body
+    assert "HELICITY_COVERAGE_COUNT" in body
+
+    parsed = madgraph.parse_driver_output(
+        _driver_output(helicity_workload="sum"),
+        batches=madgraph.TIMING_DRIVER_BATCH_COUNT,
+        expected_total_external=4,
+        expected_events=10,
+        helicity_workload="sum",
+        expected_helicity_coverage_count=16,
+    )
+    assert parsed.evaluations_per_sweep == 1
+    assert parsed.helicity_coverage_count == 16
+
+
+def test_rendered_check_fixes_only_timing_helicity_and_calls_direct_matrix(
+    source_report: Path,
+) -> None:
+    source = madgraph.load_source_selection(source_report)
+    for family, n in (("gg", 2), ("ddbar", 9)):
+        cell = source.cells[family][n]
+        body = madgraph.render_check_source(cell)
+        assert "SMATRIX" not in body.upper()
+        assert "MATRIX(P(0,1,E),HEL,IC)" in body
+        assert "MATRIX(P(0,1,1),HEL,IC)" in body
+        assert "CALL SETPARA('../../Cards/param_card.dat')" in body
+        assert "CALL UPDATE_AS_PARAM2(1D0,ASVALUE)" in body
+        assert "CALL SYSTEM_CLOCK(CLOCK0,CLOCKRATE)" in body
+        assert "DBLE(CLOCK1-CLOCK0)/DBLE(CLOCKRATE)" in body
+        assert f"DATA HEL /{','.join(str(value) for value in cell.helicity)}/" in body
+        assert f"PARAMETER (NSAMPLES={madgraph.TIMING_DRIVER_BATCH_COUNT})" in body
+        assert max(map(len, body.splitlines())) <= 132
+
+
+def _driver_output(
+    *,
+    total_external: int = 4,
+    batches: int = madgraph.TIMING_DRIVER_BATCH_COUNT,
+    point_values: tuple[float, ...] | None = None,
+    initialization_seconds: float = 1.0e-3,
+    helicity_workload: str = "fixed",
+) -> str:
+    points = point_values or tuple(float(index) for index in range(1, 11))
+    lines = [
+        (
+            "BACKEND MadGraph5_aMCatNLOHelicitySum"
+            if helicity_workload == "sum"
+            else "BACKEND MadGraph5_aMCatNLOFixedHelicity"
+        ),
+        (
+            "HELICITY_EVALUATOR SMATRIX_GENERATED_COMPLETE_HELICITY_SUM"
+            if helicity_workload == "sum"
+            else "HELICITY_EVALUATOR MATRIX_DIRECT_VECTOR"
+        ),
+        f"TOTAL_EXTERNAL {total_external}",
+        f"INITIALIZATION_SECONDS {initialization_seconds:.17e}",
+        "FIRST_SAMPLE_PASS_SECONDS 2.0D-3",
+    ]
+    lines.extend(
+        f"MATRIX_ELEMENT {index} 1 {value:.17e}"
+        for index, value in enumerate(points, start=1)
+    )
+    lines.append("EVALUATIONS_PER_SWEEP 1")
+    lines.append(
+        "HELICITY_COVERAGE_COUNT "
+        + (str(2**total_external) if helicity_workload == "sum" else "1")
+    )
+    for batch in range(1, batches + 1):
+        lines.extend(
+            (
+                f"EVALUATION_SWEEP_SECONDS {batch} {batch}.0D-6",
+                f"EVALUATION_CELL_SECONDS {batch} 1 1 {batch}.0D-6",
+            )
+        )
+    lines.append("CHECKSUM 1.0D+0")
+    return "\n".join(lines) + "\n"
+
+
+def test_driver_output_requires_ten_points_and_configured_timing_batches() -> None:
+    parsed = madgraph.parse_driver_output(
+        _driver_output(),
+        batches=madgraph.TIMING_DRIVER_BATCH_COUNT,
+        expected_total_external=4,
+        expected_events=10,
+    )
+    assert parsed.point_values == tuple(float(index) for index in range(1, 11))
+    assert len(parsed.cell_seconds) == madgraph.TIMING_DRIVER_BATCH_COUNT
+    assert parsed.initialization_seconds == 1.0e-3
+
+    incomplete = _driver_output().replace(
+        "EVALUATION_CELL_SECONDS "
+        f"{madgraph.TIMING_DRIVER_BATCH_COUNT} 1 1 "
+        f"{madgraph.TIMING_DRIVER_BATCH_COUNT}.0D-6\n",
+        "",
+    )
+    with pytest.raises(madgraph.SelectedMadGraphError, match="incomplete timing"):
+        madgraph.parse_driver_output(
+            incomplete,
+            batches=madgraph.TIMING_DRIVER_BATCH_COUNT,
+            expected_total_external=4,
+            expected_events=10,
+        )
+
+
+def test_external_time_command_selects_darwin_and_linux_dialects(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(madgraph.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(
+        madgraph.Path,
+        "is_file",
+        lambda path: str(path) == "/usr/bin/time",
+    )
+    assert madgraph._external_time_command(("probe", "argument")) == [
+        "/usr/bin/time",
+        "-l",
+        "probe",
+        "argument",
+    ]
+
+    monkeypatch.setattr(madgraph.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(madgraph.shutil, "which", lambda name: f"/opt/bin/{name}")
+    assert madgraph._external_time_command(("probe",)) == [
+        "/opt/bin/time",
+        "-v",
+        "probe",
+    ]
+
+
+def test_external_time_command_falls_back_to_watchdog_only(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(madgraph.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(madgraph.shutil, "which", lambda _name: None)
+    assert madgraph._external_time_command(("probe", "argument")) == [
+        "probe",
+        "argument",
+    ]
+
+    monkeypatch.setattr(madgraph.platform, "system", lambda: "FreeBSD")
+    assert madgraph._external_time_command(("probe",)) == ["probe"]
+
+
+@pytest.mark.parametrize(
+    ("system", "stderr", "expected_kib"),
+    (
+        ("Darwin", "  1048577  maximum resident set size\n", 1025),
+        (
+            "Linux",
+            "\tMaximum resident set size (kbytes): 123456\n",
+            123456,
+        ),
+        ("FreeBSD", "123 maximum resident set size\n", None),
+    ),
+)
+def test_external_time_max_rss_parsers(
+    monkeypatch: pytest.MonkeyPatch,
+    system: str,
+    stderr: str,
+    expected_kib: int | None,
+) -> None:
+    monkeypatch.setattr(madgraph.platform, "system", lambda: system)
+    assert madgraph._parse_time_max_rss(stderr) == expected_kib
+
+
+def test_generated_matrix_audit_proves_general_helicity_and_direct_vector(
+    matrix_source: Path,
+) -> None:
+    metadata = madgraph._validate_matrix_source(
+        matrix_source, family="gg", final_multiplicity=2
+    )
+    assert metadata["generation_helicity_coverage"] == "all"
+    assert metadata["generated_helicity_coverage_count"] == 16
+    assert metadata["generated_matrix_graphs"] > 0
+    assert metadata["colour_flows"] > 0
+    assert metadata["smatrix_iden"] == 512
+    assert metadata["matrix_sha256"] == hashlib.sha256(
+        matrix_source.read_bytes()
+    ).hexdigest()
+
+
+def test_generated_matrix_audit_rejects_missing_duplicate_or_wrong_iden(
+    tmp_path: Path,
+    matrix_source: Path,
+) -> None:
+    fixture = matrix_source.read_text(encoding="utf-8")
+    variants = {
+        "missing": fixture.replace("      DATA IDEN/512/\n", ""),
+        "comment-only": fixture.replace(
+            "      DATA IDEN/512/",
+            "C     DATA IDEN/512/",
+        ),
+        "duplicate": fixture.replace(
+            "      DATA IDEN/512/\n",
+            "      DATA IDEN/512/\n      DATA IDEN/512/\n",
+        ),
+        "wrong": fixture.replace("      DATA IDEN/512/", "      DATA IDEN/513/"),
+    }
+    for name, source in variants.items():
+        path = tmp_path / f"{name}.f"
+        path.write_text(source, encoding="utf-8")
+        with pytest.raises(
+            madgraph.SelectedMadGraphError,
+            match="IDEN denominator",
+        ):
+            madgraph._validate_matrix_source(path, family="gg", final_multiplicity=2)
+
+
+@pytest.mark.parametrize(
+    ("replacement", "message"),
+    (
+        ("PARAMETER (NCOMB=8)", "complete-helicity coverage"),
+        ("INTEGER NHEL(NEXTERNAL,16)", "NHEL\\(NEXTERNAL,NCOMB\\)"),
+    ),
+)
+def test_generated_matrix_audit_requires_exact_ncomb_nhel_coverage(
+    tmp_path: Path,
+    matrix_source: Path,
+    replacement: str,
+    message: str,
+) -> None:
+    fixture = matrix_source.read_text(encoding="utf-8")
+    original = (
+        "PARAMETER (NCOMB=16)"
+        if replacement.startswith("PARAMETER")
+        else "INTEGER NHEL(NEXTERNAL,NCOMB)"
+    )
+    path = tmp_path / "bad-coverage.f"
+    path.write_text(fixture.replace(original, replacement), encoding="utf-8")
+    with pytest.raises(madgraph.SelectedMadGraphError, match=message):
+        madgraph._validate_matrix_source(path, family="gg", final_multiplicity=2)
+
+
+def test_generated_matrix_audit_requires_executable_smatrix_iden_use(
+    tmp_path: Path,
+    matrix_source: Path,
+) -> None:
+    fixture = matrix_source.read_text(encoding="utf-8")
+    statement = "      ANS=ANS/DBLE(IDEN)"
+    variants = {
+        "missing": fixture.replace(f"{statement}\n", ""),
+        "commented": fixture.replace(statement, "C     ANS=ANS/DBLE(IDEN)"),
+        "duplicate": fixture.replace(
+            f"{statement}\n",
+            f"{statement}\n{statement}\n",
+        ),
+    }
+    for name, source in variants.items():
+        path = tmp_path / f"{name}.f"
+        path.write_text(source, encoding="utf-8")
+        with pytest.raises(
+            madgraph.SelectedMadGraphError,
+            match="does not apply its IDEN denominator exactly once",
+        ):
+            madgraph._validate_matrix_source(path, family="gg", final_multiplicity=2)
+
+
+def test_numerical_convention_map_is_fixed_not_fitted() -> None:
+    assert madgraph._expected_smatrix_iden("gg", 2) == 512
+    assert madgraph._expected_smatrix_iden("ddbar", 2) == 36
+    assert madgraph._expected_smatrix_iden("ddbar", 4) == 72
+    assert madgraph._expected_smatrix_iden("ddbar", 5) == 216
+    assert madgraph._numerical_normalization_factor("gg", smatrix_iden=512) == 1.0
+    assert (
+        madgraph._numerical_normalization_factor("ddbar", smatrix_iden=36) == 1.0 / 36.0
+    )
+    assert (
+        madgraph._numerical_normalization_factor("ddbar", smatrix_iden=72) == 1.0 / 72.0
+    )
+    with pytest.raises(madgraph.SelectedMadGraphError, match="unsupported"):
+        madgraph._numerical_normalization_factor("bad", smatrix_iden=1)
+    with pytest.raises(madgraph.SelectedMadGraphError, match="positive"):
+        madgraph._numerical_normalization_factor("ddbar", smatrix_iden=0)
+
+
+def test_watchdog_resource_uses_conservative_peak_guard() -> None:
+    report = {
+        "passes": True,
+        "execution": {"elapsed_wall_seconds": 2.5, "outcome": "command-finished"},
+        "enforcement": {
+            "peak_guard_bytes": 2049,
+            "peak_rss_bytes": 1024,
+            "peak_physical_footprint_bytes": 2049,
+            "metric": "max(process-tree-rss,darwin-process-tree-physical-footprint)",
+            "limit_bytes": 30 * 1024**3,
+        },
+    }
+    resource = madgraph._watchdog_resource(report)
+    assert resource["elapsed_wall_seconds"] == 2.5
+    assert resource["peak_guard_kib"] == 3
+    assert resource["passes"] is True
+
+
+def test_disk_exhaustion_is_infrastructure_not_physics_frontier() -> None:
+    assert madgraph._is_disk_exhaustion(OSError(28, "No space left on device"))
+    assert madgraph._is_disk_exhaustion("No space left on device")
+    assert not madgraph._is_disk_exhaustion("generation reached memory limit")
+
+
+def test_time_and_memory_limits_are_strict_publication_caps() -> None:
+    assert madgraph.DEFAULT_GENERATION_TIMEOUT_SECONDS < 3600.0
+    assert madgraph.MAX_MEMORY_GIB == 30.0
+    assert madgraph.TARGET_SECONDS == 180.0
+    assert madgraph.WARM_SAMPLE_COUNT == 1
+
+
+def test_hidden_timeout_worker_propagates_exit_and_terminates_late_child() -> None:
+    assert (
+        madgraph.main(
+            [
+                "_run-with-timeout",
+                "--timeout-seconds",
+                "1",
+                "--",
+                sys.executable,
+                "-c",
+                "raise SystemExit(7)",
+            ]
+        )
+        == 7
+    )
+    assert (
+        madgraph.main(
+            [
+                "_run-with-timeout",
+                "--timeout-seconds",
+                "0.01",
+                "--",
+                sys.executable,
+                "-c",
+                "import time; time.sleep(10)",
+            ]
+        )
+        == 124
+    )
+
+
+def test_generation_worker_runs_madgraph_with_current_python(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    fake_bin = tmp_path / "fake-bin"
+    fake_bin.mkdir()
+    fake_python = fake_bin / "python3"
+    fake_python.write_text("#!/bin/sh\nexit 93\n", encoding="ascii")
+    fake_python.chmod(0o755)
+    monkeypatch.setenv("PATH", str(fake_bin))
+
+    mg5_root = tmp_path / "mg5"
+    (mg5_root / "bin").mkdir(parents=True)
+    (mg5_root / "VERSION").write_text("test-version\n", encoding="ascii")
+    mg5 = mg5_root / "bin" / "mg5_aMC"
+    mg5.write_text(
+        """#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+card = Path(sys.argv[1])
+output = None
+for line in card.read_text(encoding="utf-8").splitlines():
+    if line.startswith("output standalone "):
+        output = Path(line.removeprefix("output standalone ").rsplit(" -f", 1)[0])
+if output is None:
+    raise SystemExit(2)
+process = output / "SubProcesses" / "P0_test"
+process.mkdir(parents=True)
+(process / "matrix.f").write_text("      REAL*8 FUNCTION MATRIX()\\n      END\\n")
+""",
+        encoding="ascii",
+    )
+    mg5.chmod(0o755)
+
+    cell_dir = tmp_path / "gg" / "n2"
+    result = cell_dir / "generation-attempts" / "attempt-001" / "result.json"
+    result.parent.mkdir(parents=True)
+    arguments = madgraph._worker_parser().parse_args(
+        [
+            "--mg5-root",
+            str(mg5_root),
+            "--generated-output",
+            str(cell_dir / "generated"),
+            "--worker-result",
+            str(result),
+            "--process",
+            "g g > g g",
+            "--generation-timeout-seconds",
+            "10",
+        ]
+    )
+
+    assert madgraph._generation_worker(arguments) == 0
+    payload = json.loads(result.read_text(encoding="utf-8"))
+
+    assert payload["status"] == "measured"
+    assert payload["returncode"] == 0
+    assert payload["process_dirs"] == [
+        str(cell_dir / "generated" / "SubProcesses" / "P0_test")
+    ]
+
+
+def test_bounded_command_uses_current_python_for_timeout_wrapper(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    calls: list[list[str]] = []
+
+    def watchdog(
+        command: list[str], *, cwd: Path, report: Path, limit_gib: float
+    ) -> subprocess.CompletedProcess[str]:
+        del cwd, limit_gib
+        calls.append(command)
+        report.write_text(json.dumps(_watchdog_report(elapsed=1.0)), encoding="utf-8")
+        return subprocess.CompletedProcess(command, 0, "stdout", "stderr")
+
+    monkeypatch.setattr(madgraph, "_run_watchdog", watchdog)
+
+    madgraph._run_bounded_command(
+        ["probe"],
+        cwd=tmp_path,
+        report=tmp_path / "watchdog.json",
+        limit_gib=1.0,
+        timeout_seconds=5.0,
+    )
+
+    wrapper_index = calls[0].index(sys.executable)
+    assert calls[0][wrapper_index:] == [
+        sys.executable,
+        str(Path(madgraph.__file__).resolve()),
+        "_run-with-timeout",
+        "--timeout-seconds",
+        "5",
+        "--",
+        "probe",
+    ]
+
+
+def _watchdog_report(*, elapsed: float, peak_kib: int = 1024) -> dict[str, object]:
+    return {
+        "passes": True,
+        "execution": {
+            "elapsed_wall_seconds": elapsed,
+            "outcome": "command-finished",
+        },
+        "enforcement": {
+            "peak_guard_bytes": peak_kib * 1024,
+            "peak_rss_bytes": peak_kib * 1024,
+            "peak_physical_footprint_bytes": peak_kib * 1024,
+            "metric": "process-tree-rss",
+            "limit_bytes": 30 * 1024**3,
+        },
+    }
+
+
+def test_timeout_frontier_requires_authenticated_wrapper_marker() -> None:
+    natural_124 = subprocess.CompletedProcess([], 124, "", "child failed")
+    timed_out = subprocess.CompletedProcess(
+        [], 124, "", f"prefix\n{madgraph.TIMEOUT_MARKER}\nsuffix"
+    )
+    assert not madgraph._bounded_command_timed_out(natural_124)
+    assert madgraph._bounded_command_timed_out(timed_out)
+
+
+def test_measurement_runtime_consumes_remaining_cold_budget(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+    matrix_source: Path,
+) -> None:
+    source = madgraph.load_source_selection(source_report)
+    selected = source.cells["gg"][2]
+    cell_dir = tmp_path / "gg" / "n2"
+    process_dir = cell_dir / "generated" / "SubProcesses" / "P1_test"
+    process_dir.mkdir(parents=True)
+    shutil.copy2(matrix_source, process_dir / "matrix.f")
+    (process_dir / "makefile").write_text("check:\n\t@true\n", encoding="ascii")
+    mg5_root = tmp_path / "mg5"
+    mg5_root.mkdir()
+    (mg5_root / "VERSION").write_text("test-version\n", encoding="ascii")
+    calls: list[tuple[list[str], float | None, Path]] = []
+
+    def bounded(
+        command: list[str],
+        *,
+        cwd: Path,
+        report: Path,
+        limit_gib: float,
+        timeout_seconds: float | None = None,
+    ) -> tuple[subprocess.CompletedProcess[str], dict[str, object]]:
+        del limit_gib
+        calls.append((list(command), timeout_seconds, report))
+        if command[0] == "make":
+            executable = cwd / "check"
+            executable.write_bytes(b"test executable")
+            executable.chmod(0o755)
+            return (
+                subprocess.CompletedProcess(command, 0, "", ""),
+                _watchdog_report(elapsed=2.0, peak_kib=2000),
+            )
+        return (
+            subprocess.CompletedProcess(
+                command,
+                0,
+                _driver_output(
+                    point_values=selected.reference_point_values,
+                    initialization_seconds=1.0,
+                ),
+                "",
+            ),
+            _watchdog_report(elapsed=3.0, peak_kib=3000),
+        )
+
+    monkeypatch.setattr(madgraph, "_run_bounded_command", bounded)
+    cell = madgraph._measure_generated_cell(
+        source=source,
+        selected=selected,
+        generation={
+            "output": str(cell_dir / "generated"),
+            "process_dirs": [str(process_dir)],
+        },
+        generation_watchdog=_watchdog_report(elapsed=5.0, peak_kib=1000),
+        cell_dir=cell_dir,
+        fc="gfortran",
+        fflags="-O3",
+        make="make",
+        limit_gib=30.0,
+        mg5_root=mg5_root,
+        cold_to_ready_limit_seconds=20.0,
+    )
+    assert [call[1] for call in calls] == [15.0, 13.0]
+    assert all(
+        call[2].parent == cell_dir / "measurement-attempts" / "attempt-001"
+        for call in calls
+    )
+    assert cell["metrics"]["generation_seconds"] == 8.0
+    assert cell["provenance"]["generation_helicity_coverage"] == "all"
+    with pytest.raises(madgraph.ResourceFrontierError) as exhausted:
+        madgraph._remaining_cold_to_ready_budget(
+            5.0, madgraph._watchdog_resource(_watchdog_report(elapsed=5.0))
+        )
+    assert exhausted.value.category == "generation-time-limit"
+
+
+def test_attempt_paths_resume_without_reusing_watchdog_reports(tmp_path: Path) -> None:
+    cell_dir = tmp_path / "gg" / "n2"
+    cell_dir.mkdir(parents=True)
+    first = madgraph._new_attempt_directory(cell_dir, "measurement")
+    (first / "build-watchdog.json").write_text("{}\n", encoding="ascii")
+    (first / "runtime-watchdog.json").write_text("{}\n", encoding="ascii")
+    second = madgraph._new_attempt_directory(cell_dir, "measurement")
+    assert first.name == "attempt-001"
+    assert second.name == "attempt-002"
+    assert (first / "build-watchdog.json").is_file()
+    assert not (second / "build-watchdog.json").exists()
+
+
+def test_cache_lock_survives_cache_tree_replacement(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    lock_root = tmp_path / "locks"
+    monkeypatch.setattr(madgraph, "CACHE_LOCK_ROOT", lock_root)
+    run_directory = tmp_path / "run"
+    cache = run_directory / "madgraph" / "cache"
+    first = madgraph._acquire_cache_lock(cache)
+    try:
+        cache.mkdir(parents=True)
+        shutil.rmtree(run_directory)
+        with pytest.raises(
+            madgraph.SelectedMadGraphError,
+            match="another MadGraph profiler holds cache lock",
+        ):
+            madgraph._acquire_cache_lock(cache)
+    finally:
+        first.close()
+
+    resumed = madgraph._acquire_cache_lock(cache)
+    resumed.close()
+    assert madgraph._cache_lock_path(cache).parent == lock_root
+
+
+@pytest.mark.parametrize("keep_generated", [False, True])
+def test_checkpoint_resume_safely_prunes_only_cell_generated(
+    tmp_path: Path, keep_generated: bool
+) -> None:
+    cell_dir = tmp_path / "gg" / "n2"
+    generated = cell_dir / "generated"
+    generated.mkdir(parents=True)
+    sentinel = generated / "sentinel"
+    sentinel.write_text("owned\n", encoding="ascii")
+    checkpoint = cell_dir / "cell.json"
+    identity = {"producer": "test"}
+    madgraph._json_atomic(
+        checkpoint,
+        {"checkpoint_identity": identity, "cell": {"status": "measured"}},
+    )
+    cell = madgraph._load_checkpoint_cell(
+        checkpoint,
+        identity=identity,
+        cell_dir=cell_dir,
+        keep_generated=keep_generated,
+    )
+    assert cell["status"] == "measured"
+    assert generated.exists() is keep_generated
+    assert tmp_path.exists()
+
+
+@pytest.mark.parametrize("family", madgraph.FAMILIES)
+def test_checkpoint_producer_change_requires_fresh_cache(
+    tmp_path: Path, family: str
+) -> None:
+    cell_dir = tmp_path / family / "n2"
+    cell_dir.mkdir(parents=True)
+    checkpoint = cell_dir / "cell.json"
+    current = {
+        "producer_sha256": "current-producer",
+        "family": family,
+        "n": 2,
+        "sentinel": "same",
+    }
+    madgraph._json_atomic(
+        checkpoint,
+        {
+            "checkpoint_identity": {
+                **current,
+                "producer_sha256": "previous-producer",
+            },
+            "cell": {
+                "status": "failed",
+                "failure_category": "generation-time-limit",
+            },
+        },
+    )
+    with pytest.raises(
+        madgraph.SelectedMadGraphError,
+        match="checkpoint identity changed",
+    ):
+        madgraph._load_checkpoint_cell(
+            checkpoint,
+            identity=current,
+            cell_dir=cell_dir,
+            keep_generated=True,
+        )
+
+
+def test_checkpoint_reuse_ignores_only_unrelated_source_report_expansion(
+    tmp_path: Path,
+) -> None:
+    cell_dir = tmp_path / "gg" / "n2"
+    cell_dir.mkdir(parents=True)
+    checkpoint = cell_dir / "cell.json"
+    current = {
+        "producer_sha256": "same-producer",
+        "source_report_sha256": "expanded-report",
+        "source_cell_sha256": "same-cell",
+        "family": "gg",
+        "n": 2,
+    }
+    madgraph._json_atomic(
+        checkpoint,
+        {
+            "checkpoint_identity": {
+                **current,
+                "source_report_sha256": "sparse-report",
+            },
+            "cell": {"status": "measured"},
+        },
+    )
+
+    assert (
+        madgraph._load_checkpoint_cell(
+            checkpoint,
+            identity=current,
+            cell_dir=cell_dir,
+            keep_generated=True,
+        )["status"]
+        == "measured"
+    )
+
+
+def test_measured_checkpoint_reuse_ignores_caps_timing_and_legacy_producer(
+    tmp_path: Path,
+) -> None:
+    cell_dir = tmp_path / "gg" / "n2"
+    cell_dir.mkdir(parents=True)
+    checkpoint = cell_dir / "cell.json"
+    current = {
+        "checkpoint_protocol": madgraph.CHECKPOINT_PROTOCOL,
+        "source_report_sha256": "expanded-report",
+        "source_cell_sha256": "same-cell",
+        "family": "gg",
+        "n": 2,
+        "generation_timeout_seconds": 36000.0,
+        "memory_limit_gib": 200.0,
+        "target_seconds": 180.0,
+        "warm_sample_count": 1,
+    }
+    madgraph._json_atomic(
+        checkpoint,
+        {
+            "checkpoint_identity": {
+                "producer_sha256": "old-script-hash",
+                "source_report_sha256": "sparse-report",
+                "source_cell_sha256": "same-cell",
+                "family": "gg",
+                "n": 2,
+                "generation_timeout_seconds": 3600.0,
+                "memory_limit_gib": 100.0,
+                "target_seconds": 0.25,
+                "warm_sample_count": 10,
+            },
+            "cell": {"status": "measured"},
+        },
+    )
+
+    assert (
+        madgraph._load_checkpoint_cell(
+            checkpoint,
+            identity=current,
+            cell_dir=cell_dir,
+            keep_generated=True,
+        )["status"]
+        == "measured"
+    )
+
+
+def test_failed_checkpoint_cap_or_timing_change_is_not_reused(
+    tmp_path: Path,
+) -> None:
+    cell_dir = tmp_path / "gg" / "n2"
+    generated = cell_dir / "generated"
+    generated.mkdir(parents=True)
+    checkpoint = cell_dir / "cell.json"
+    current = {
+        "checkpoint_protocol": madgraph.CHECKPOINT_PROTOCOL,
+        "source_report_sha256": "expanded-report",
+        "source_cell_sha256": "same-cell",
+        "family": "gg",
+        "n": 2,
+        "generation_timeout_seconds": 36000.0,
+        "memory_limit_gib": 200.0,
+        "target_seconds": 180.0,
+        "warm_sample_count": 1,
+    }
+    madgraph._json_atomic(
+        checkpoint,
+        {
+            "checkpoint_identity": {
+                "producer_sha256": "old-script-hash",
+                "source_report_sha256": "sparse-report",
+                "source_cell_sha256": "same-cell",
+                "family": "gg",
+                "n": 2,
+                "generation_timeout_seconds": 3600.0,
+                "memory_limit_gib": 100.0,
+                "target_seconds": 0.25,
+                "warm_sample_count": 10,
+            },
+            "cell": {
+                "status": "failed",
+                "failure_category": "memory-limit",
+            },
+        },
+    )
+
+    assert (
+        madgraph._load_checkpoint_cell(
+            checkpoint,
+            identity=current,
+            cell_dir=cell_dir,
+            keep_generated=False,
+        )
+        is None
+    )
+    assert not generated.exists()
+
+
+def test_generated_cleanup_refuses_symlink_target(tmp_path: Path) -> None:
+    cell_dir = tmp_path / "gg" / "n2"
+    cell_dir.mkdir(parents=True)
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    (outside / "sentinel").write_text("preserve\n", encoding="ascii")
+    (cell_dir / "generated").symlink_to(outside, target_is_directory=True)
+    with pytest.raises(madgraph.SelectedMadGraphError, match="symlink"):
+        madgraph._prune_cell_generated(cell_dir)
+    assert (outside / "sentinel").read_text(encoding="ascii") == "preserve\n"
+
+
+def _fake_mg5_root(tmp_path: Path) -> Path:
+    root = tmp_path / "mg5"
+    (root / "bin").mkdir(parents=True)
+    (root / "bin" / "mg5_aMC").write_text("#!/bin/sh\n", encoding="ascii")
+    (root / "VERSION").write_text("test-version\n", encoding="ascii")
+    return root
+
+
+@pytest.mark.parametrize(
+    "category",
+    [
+        "generation-error",
+        "generation-launch-error",
+        "generation-structure-error",
+        "generation-watchdog-error",
+        "infrastructure-disk-exhaustion",
+    ],
+)
+def test_generation_diagnostics_abort_without_frontier_checkpoint(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+    category: str,
+) -> None:
+    monkeypatch.setattr(madgraph, "FAMILIES", ("gg",))
+    monkeypatch.setattr(madgraph, "FINAL_MULTIPLICITIES", (2, 3))
+    monkeypatch.setattr(
+        madgraph,
+        "_generation_attempt",
+        lambda **_kwargs: (
+            {
+                "status": "failed",
+                "failure_category": category,
+                "failure_reason": "diagnostic",
+            },
+            {},
+        ),
+    )
+    cache = tmp_path / "cache"
+    with pytest.raises(madgraph.SelectedMadGraphError, match="diagnostic"):
+        madgraph.build_runtime_report(
+            source_report=source_report,
+            cache_dir=cache,
+            fc="gfortran",
+            fflags="-O3",
+            timeout_seconds=10.0,
+            mg5_root=_fake_mg5_root(tmp_path),
+            memory_limit_gib=1.0,
+        )
+    assert not (cache / "gg" / "n2" / "cell.json").exists()
+
+
+@pytest.mark.parametrize(
+    "message",
+    [
+        "generated standalone build failed",
+        "MadGraph points disagree with reference",
+        "MadGraph output has incomplete timing cells",
+    ],
+)
+def test_measurement_diagnostics_abort_without_frontier_checkpoint(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+    message: str,
+) -> None:
+    monkeypatch.setattr(madgraph, "FAMILIES", ("gg",))
+    monkeypatch.setattr(madgraph, "FINAL_MULTIPLICITIES", (2, 3))
+    monkeypatch.setattr(
+        madgraph,
+        "_generation_attempt",
+        lambda **_kwargs: ({"status": "measured"}, {}),
+    )
+
+    def fail_measurement(**_kwargs: object) -> dict[str, object]:
+        raise madgraph.SelectedMadGraphError(message)
+
+    monkeypatch.setattr(madgraph, "_measure_generated_cell", fail_measurement)
+    cache = tmp_path / "cache"
+    with pytest.raises(madgraph.SelectedMadGraphError, match=message):
+        madgraph.build_runtime_report(
+            source_report=source_report,
+            cache_dir=cache,
+            fc="gfortran",
+            fflags="-O3",
+            timeout_seconds=10.0,
+            mg5_root=_fake_mg5_root(tmp_path),
+            memory_limit_gib=1.0,
+        )
+    assert not (cache / "gg" / "n2" / "cell.json").exists()
+
+
+@pytest.mark.parametrize("category", ["generation-time-limit", "memory-limit"])
+def test_only_resource_failures_create_and_censor_frontier(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+    category: str,
+) -> None:
+    monkeypatch.setattr(madgraph, "FAMILIES", ("gg",))
+    monkeypatch.setattr(madgraph, "FINAL_MULTIPLICITIES", (2, 3))
+    monkeypatch.setattr(
+        madgraph,
+        "_generation_attempt",
+        lambda **_kwargs: (
+            {
+                "status": "failed",
+                "failure_category": category,
+                "failure_reason": "resource cap",
+            },
+            {},
+        ),
+    )
+    cache = tmp_path / "cache"
+    report = madgraph.build_runtime_report(
+        source_report=source_report,
+        cache_dir=cache,
+        fc="gfortran",
+        fflags="-O3",
+        timeout_seconds=10.0,
+        mg5_root=_fake_mg5_root(tmp_path),
+        memory_limit_gib=1.0,
+    )
+    n2 = report["runtime_series"]["gg"][madgraph.MODE]["2"]
+    n3 = report["runtime_series"]["gg"][madgraph.MODE]["3"]
+    assert n2["status"] == "failed"
+    assert n2["failure_category"] == category
+    assert n3["status"] == "skipped"
+    assert n3["skipped_after_frontier"] is True
+
+
+def test_diagnostic_family_omission_is_not_an_availability_frontier() -> None:
+    cell = madgraph._diagnostic_skip_cell("gg", 2, "diagnostic")
+    assert cell["status"] == "skipped"
+    assert cell["censors_higher_multiplicities"] is False
+    assert cell["skipped_after_frontier"] is False
+    assert "availability_frontier_n" not in cell
+
+
+def _measured_stub(**arguments: object) -> dict[str, object]:
+    selected = arguments["selected"]
+    source = arguments["source"]
+    assert isinstance(selected, madgraph.SelectedCell)
+    assert isinstance(source, madgraph.SourceSelection)
+    return {
+        "status": "measured",
+        "family": selected.family,
+        "mode": madgraph.MODE,
+        "label": madgraph.LABEL,
+        "n": selected.n,
+        "total_external": selected.total_external,
+        "process": selected.process,
+        "helicity_workload": selected.helicity_workload,
+        "provenance": {
+            "source_report": {
+                "path": madgraph._display_path(source.path),
+                "sha256": source.sha256,
+                "cell": (
+                    f"cells.{selected.family}.{selected.source_mode}.{selected.n}"
+                ),
+            }
+        },
+    }
+
+
+def _write_source_payload(
+    tmp_path: Path, payload: dict[str, object], name: str
+) -> Path:
+    path = tmp_path / name
+    path.write_text(json.dumps(payload), encoding="utf-8")
+    return path
+
+
+def test_scaling_source_records_dependency_frontier_without_losing_lower_n(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+) -> None:
+    payload = json.loads(source_report.read_text(encoding="utf-8"))
+    payload["kind"] = madgraph.SCALING_STUDY_KIND
+    failed = payload["cells"]["ddbar"]["recurrence-fft"]["3"]
+    failed.update(
+        {
+            "status": "failed",
+            "failure_category": "memory-limit",
+            "failure_reason": "source reached its configured RAM cap",
+            "censors_higher_multiplicities": True,
+        }
+    )
+    skipped = payload["cells"]["ddbar"]["recurrence-fft"]["4"]
+    skipped.update(
+        {
+            "status": "skipped",
+            "failure_reason": "skipped after source frontier",
+            "censors_higher_multiplicities": True,
+        }
+    )
+    source_path = _write_source_payload(tmp_path, payload, "source.json")
+    source = madgraph.load_source_selection(
+        source_path, multiplicities=(2, 3, 4)
+    )
+    assert set(source.cells["ddbar"]) == {2}
+    assert set(source.unavailable["ddbar"]) == {3, 4}
+
+    monkeypatch.setattr(madgraph, "FAMILIES", ("ddbar",))
+    attempted: list[int] = []
+
+    def generation_attempt(**arguments: object) -> tuple[dict[str, object], dict]:
+        selected = arguments["selected"]
+        assert isinstance(selected, madgraph.SelectedCell)
+        attempted.append(selected.n)
+        return {"status": "measured"}, {}
+
+    monkeypatch.setattr(madgraph, "_generation_attempt", generation_attempt)
+    monkeypatch.setattr(madgraph, "_measure_generated_cell", _measured_stub)
+    progress_path = tmp_path / "overlay.progress.json"
+    report = madgraph.build_runtime_report(
+        source_report=source_path,
+        cache_dir=tmp_path / "cache",
+        fc="gfortran",
+        fflags="-O3",
+        timeout_seconds=7200.0,
+        mg5_root=_fake_mg5_root(tmp_path),
+        multiplicities=(2, 3, 4),
+        memory_limit_gib=64.0,
+        progress_output=progress_path,
+    )
+
+    cells = report["runtime_series"]["ddbar"][madgraph.MODE]
+    assert attempted == [2]
+    assert cells["2"]["status"] == "measured"
+    assert cells["3"]["failure_category"] == "dependency-unavailable"
+    assert cells["4"]["status"] == "skipped"
+    assert report["policy"]["final_state_multiplicities"] == [2, 3, 4]
+    assert report["policy"]["generation_timeout_seconds"] == 7200.0
+    assert report["policy"]["outer_memory_watchdog_gib"] == 64.0
+    progress = madgraph.load_runtime_progress(progress_path)
+    assert progress["status"] == "complete-with-failures"
+    assert progress["summary"]["completed_cell_count"] == 3
+    assert progress["pending_cells"] == []
+
+
+def test_scaling_source_non_frontier_failure_does_not_censor_higher_n(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+) -> None:
+    payload = json.loads(source_report.read_text(encoding="utf-8"))
+    payload["kind"] = madgraph.SCALING_STUDY_KIND
+    failed = payload["cells"]["ddbar"]["recurrence-fft"]["3"]
+    failed.update(
+        {
+            "status": "failed",
+            "failure_category": "error",
+            "failure_reason": "source diagnostic failed at this cell",
+            "censors_higher_multiplicities": False,
+        }
+    )
+    source_path = _write_source_payload(tmp_path, payload, "source.json")
+    source = madgraph.load_source_selection(
+        source_path, multiplicities=(2, 3, 4)
+    )
+    assert set(source.cells["ddbar"]) == {2, 4}
+    assert set(source.unavailable["ddbar"]) == {3}
+    assert source.unavailable["ddbar"][3].censors_higher_multiplicities is False
+
+    monkeypatch.setattr(madgraph, "FAMILIES", ("ddbar",))
+    attempted: list[int] = []
+
+    def generation_attempt(**arguments: object) -> tuple[dict[str, object], dict]:
+        selected = arguments["selected"]
+        assert isinstance(selected, madgraph.SelectedCell)
+        attempted.append(selected.n)
+        return {"status": "measured"}, {}
+
+    monkeypatch.setattr(madgraph, "_generation_attempt", generation_attempt)
+    monkeypatch.setattr(madgraph, "_measure_generated_cell", _measured_stub)
+    report = madgraph.build_runtime_report(
+        source_report=source_path,
+        cache_dir=tmp_path / "cache",
+        fc="gfortran",
+        fflags="-O3",
+        timeout_seconds=7200.0,
+        mg5_root=_fake_mg5_root(tmp_path),
+        multiplicities=(2, 3, 4),
+        memory_limit_gib=64.0,
+    )
+
+    cells = report["runtime_series"]["ddbar"][madgraph.MODE]
+    assert attempted == [2, 4]
+    assert cells["2"]["status"] == "measured"
+    assert cells["3"]["failure_category"] == "dependency-unavailable"
+    assert cells["3"]["censors_higher_multiplicities"] is False
+    assert "availability_frontier_n" not in cells["3"]
+    assert cells["4"]["status"] == "measured"
+
+
+def test_progress_is_atomic_sparse_and_names_the_current_cell(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+) -> None:
+    monkeypatch.setattr(madgraph, "FAMILIES", ("gg",))
+    monkeypatch.setattr(
+        madgraph,
+        "_generation_attempt",
+        lambda **_arguments: ({"status": "measured"}, {}),
+    )
+    monkeypatch.setattr(madgraph, "_measure_generated_cell", _measured_stub)
+    progress_path = tmp_path / "overlay.progress.json"
+    observed: list[dict[str, object]] = []
+    original_atomic = madgraph._json_atomic
+
+    def capture_atomic(
+        path: Path, payload: dict[str, object], *, replace: bool = True
+    ) -> None:
+        original_atomic(path, payload, replace=replace)
+        if path == progress_path.resolve(strict=False):
+            observed.append(json.loads(json.dumps(payload)))
+
+    monkeypatch.setattr(madgraph, "_json_atomic", capture_atomic)
+    report = madgraph.build_runtime_report(
+        source_report=source_report,
+        cache_dir=tmp_path / "cache",
+        fc="gfortran",
+        fflags="-O3",
+        timeout_seconds=7201.0,
+        mg5_root=_fake_mg5_root(tmp_path),
+        multiplicities=(2, 3),
+        memory_limit_gib=96.0,
+        progress_output=progress_path,
+    )
+
+    current = [entry["current_cell"] for entry in observed if entry["current_cell"]]
+    assert [(entry["family"], entry["n"]) for entry in current] == [
+        ("gg", 2),
+        ("gg", 3),
+    ]
+    completed = [entry["summary"]["completed_cell_count"] for entry in observed]
+    assert completed[0] == 0
+    assert 1 in completed
+    assert completed[-1] == 2
+    progress = madgraph.load_runtime_progress(progress_path)
+    assert progress["status"] == "complete"
+    assert progress["policy"]["final_state_multiplicities"] == [2, 3]
+    assert progress["policy"]["generation_timeout_seconds"] == 7201.0
+    assert progress["policy"]["outer_memory_watchdog_gib"] == 96.0
+    assert progress["source_report"]["sha256"] == hashlib.sha256(
+        source_report.read_bytes()
+    ).hexdigest()
+    assert set(progress["runtime_series"]["gg"][madgraph.MODE]) == {"2", "3"}
+    assert report["status"] == "complete"
+
+
+def test_resumed_progress_prehydrates_compatible_checkpoint_prefix(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+) -> None:
+    monkeypatch.setattr(madgraph, "FAMILIES", ("gg",))
+    monkeypatch.setattr(
+        madgraph,
+        "_generation_attempt",
+        lambda **_arguments: ({"status": "measured"}, {}),
+    )
+    monkeypatch.setattr(madgraph, "_measure_generated_cell", _measured_stub)
+    cache = tmp_path / "cache"
+    mg5_root = _fake_mg5_root(tmp_path)
+    madgraph.build_runtime_report(
+        source_report=source_report,
+        cache_dir=cache,
+        fc="gfortran",
+        fflags="-O3",
+        timeout_seconds=10.0,
+        mg5_root=mg5_root,
+        multiplicities=(2,),
+        memory_limit_gib=1.0,
+    )
+
+    progress_path = tmp_path / "overlay.progress.json"
+    observed: list[dict[str, object]] = []
+    original_atomic = madgraph._json_atomic
+
+    def capture_atomic(
+        path: Path, payload: dict[str, object], *, replace: bool = True
+    ) -> None:
+        original_atomic(path, payload, replace=replace)
+        if path == progress_path.resolve(strict=False):
+            observed.append(json.loads(json.dumps(payload)))
+
+    monkeypatch.setattr(madgraph, "_json_atomic", capture_atomic)
+
+    def stop_on_new_cell(**arguments: object) -> dict[str, object]:
+        selected = arguments["selected"]
+        assert isinstance(selected, madgraph.SelectedCell)
+        raise madgraph.SelectedMadGraphError(f"stop at n={selected.n}")
+
+    monkeypatch.setattr(madgraph, "_measure_generated_cell", stop_on_new_cell)
+    with pytest.raises(madgraph.SelectedMadGraphError, match="stop at n=3"):
+        madgraph.build_runtime_report(
+            source_report=source_report,
+            cache_dir=cache,
+            fc="gfortran",
+            fflags="-O3",
+            timeout_seconds=10.0,
+            mg5_root=mg5_root,
+            multiplicities=(2, 3),
+            memory_limit_gib=1.0,
+            progress_output=progress_path,
+        )
+
+    assert observed
+    first = observed[0]
+    assert first["summary"]["completed_cell_count"] == 1
+    assert set(first["runtime_series"]["gg"][madgraph.MODE]) == {"2"}
+    assert first["pending_cells"][0]["n"] == 3
+
+
+def test_final_plot_protocol_skips_pure_gluon_n6(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+) -> None:
+    monkeypatch.setattr(madgraph, "FAMILIES", ("gg",))
+    attempted: list[int] = []
+
+    def generation_attempt(**arguments: object) -> tuple[dict[str, object], dict]:
+        selected = arguments["selected"]
+        assert isinstance(selected, madgraph.SelectedCell)
+        attempted.append(selected.n)
+        return {"status": "measured"}, {}
+
+    monkeypatch.setattr(madgraph, "_generation_attempt", generation_attempt)
+    monkeypatch.setattr(madgraph, "_measure_generated_cell", _measured_stub)
+    progress_path = tmp_path / "overlay.progress.json"
+
+    report = madgraph.build_runtime_report(
+        source_report=source_report,
+        cache_dir=tmp_path / "cache",
+        fc="gfortran",
+        fflags="-O3",
+        timeout_seconds=10.0,
+        mg5_root=_fake_mg5_root(tmp_path),
+        multiplicities=tuple(range(2, 10)),
+        memory_limit_gib=1.0,
+        progress_output=progress_path,
+    )
+
+    assert attempted == list(range(2, 6))
+    cells = report["runtime_series"]["gg"][madgraph.MODE]
+    assert {cells[str(n)]["status"] for n in range(6, 10)} == {
+        "not-applicable"
+    }
+    assert cells["6"]["failure_category"] == "protocol-scope-pure-gluon-n6"
+    assert "gfortran -O3 f951 internal compiler error" in cells["6"][
+        "failure_reason"
+    ]
+    assert report["policy"]["maximum_measured_multiplicity"] == 6
+    assert report["policy"]["family_maximum_measured_multiplicity"] == {"gg": 5}
+    assert report["summary"]["runtime_series_status_counts"] == {
+        "measured": 4,
+        "not-applicable": 4,
+    }
+    progress = madgraph.load_runtime_progress(progress_path)
+    assert progress["status"] == "complete"
+
+
+def test_final_plot_protocol_still_launches_ddbar_n6(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+) -> None:
+    monkeypatch.setattr(madgraph, "FAMILIES", ("ddbar",))
+    attempted: list[int] = []
+
+    def generation_attempt(**arguments: object) -> tuple[dict[str, object], dict]:
+        selected = arguments["selected"]
+        assert isinstance(selected, madgraph.SelectedCell)
+        attempted.append(selected.n)
+        return {"status": "measured"}, {}
+
+    monkeypatch.setattr(madgraph, "_generation_attempt", generation_attempt)
+    monkeypatch.setattr(madgraph, "_measure_generated_cell", _measured_stub)
+
+    report = madgraph.build_runtime_report(
+        source_report=source_report,
+        cache_dir=tmp_path / "cache",
+        fc="gfortran",
+        fflags="-O3",
+        timeout_seconds=10.0,
+        mg5_root=_fake_mg5_root(tmp_path),
+        multiplicities=(5, 6, 7),
+        memory_limit_gib=1.0,
+    )
+
+    assert attempted == [5, 6]
+    cells = report["runtime_series"]["ddbar"][madgraph.MODE]
+    assert cells["6"]["status"] == "measured"
+    assert cells["7"]["status"] == "not-applicable"
+    assert report["policy"]["family_maximum_measured_multiplicity"] == {
+        "ddbar": 6
+    }
+
+
+def test_diagnostic_exit_leaves_completed_progress_renderable(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+) -> None:
+    monkeypatch.setattr(madgraph, "FAMILIES", ("gg",))
+    monkeypatch.setattr(
+        madgraph,
+        "_generation_attempt",
+        lambda **_arguments: ({"status": "measured"}, {}),
+    )
+
+    def measure(**arguments: object) -> dict[str, object]:
+        selected = arguments["selected"]
+        assert isinstance(selected, madgraph.SelectedCell)
+        if selected.n == 3:
+            raise madgraph.SelectedMadGraphError("synthetic diagnostic")
+        return _measured_stub(**arguments)
+
+    monkeypatch.setattr(madgraph, "_measure_generated_cell", measure)
+    progress_path = tmp_path / "overlay.progress.json"
+    with pytest.raises(madgraph.SelectedMadGraphError, match="synthetic diagnostic"):
+        madgraph.build_runtime_report(
+            source_report=source_report,
+            cache_dir=tmp_path / "cache",
+            fc="gfortran",
+            fflags="-O3",
+            timeout_seconds=10.0,
+            mg5_root=_fake_mg5_root(tmp_path),
+            multiplicities=(2, 3),
+            memory_limit_gib=1.0,
+            progress_output=progress_path,
+        )
+    progress = madgraph.load_runtime_progress(progress_path)
+    assert progress["status"] == "running"
+    assert progress["summary"]["completed_cell_count"] == 1
+    assert progress["current_cell"]["n"] == 3
+    assert set(progress["runtime_series"]["gg"][madgraph.MODE]) == {"2"}
+
+
+def test_cell_scoped_source_identity_reuses_and_rebinds_checkpoint(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    source_report: Path,
+) -> None:
+    monkeypatch.setattr(madgraph, "FAMILIES", ("gg",))
+    payload = json.loads(source_report.read_text(encoding="utf-8"))
+    payload["kind"] = madgraph.SCALING_STUDY_KIND
+    first_source = _write_source_payload(tmp_path, payload, "source-1.json")
+    attempts = 0
+
+    def generation_attempt(**_arguments: object) -> tuple[dict[str, object], dict]:
+        nonlocal attempts
+        attempts += 1
+        return {"status": "measured"}, {}
+
+    monkeypatch.setattr(madgraph, "_generation_attempt", generation_attempt)
+    monkeypatch.setattr(madgraph, "_measure_generated_cell", _measured_stub)
+    cache = tmp_path / "cache"
+    mg5_root = _fake_mg5_root(tmp_path)
+    madgraph.build_runtime_report(
+        source_report=first_source,
+        cache_dir=cache,
+        fc="gfortran",
+        fflags="-O3",
+        timeout_seconds=10.0,
+        mg5_root=mg5_root,
+        multiplicities=(2,),
+        memory_limit_gib=1.0,
+    )
+    assert attempts == 1
+
+    payload["cells"]["gg"]["reference-fft"]["3"]["label"] = "unrelated edit"
+    second_source = _write_source_payload(tmp_path, payload, "source-2.json")
+    report = madgraph.build_runtime_report(
+        source_report=second_source,
+        cache_dir=cache,
+        fc="gfortran",
+        fflags="-O3",
+        timeout_seconds=10.0,
+        mg5_root=mg5_root,
+        multiplicities=(2,),
+        memory_limit_gib=1.0,
+    )
+    assert attempts == 1
+    rebound = report["runtime_series"]["gg"][madgraph.MODE]["2"]
+    assert rebound["provenance"]["source_report"]["path"] == str(second_source)
+    assert rebound["provenance"]["source_report"]["sha256"] == hashlib.sha256(
+        second_source.read_bytes()
+    ).hexdigest()
+    checkpoint = json.loads((cache / "gg" / "n2" / "cell.json").read_text())
+    assert checkpoint["checkpoint_identity"]["source_report_sha256"] == rebound[
+        "provenance"
+    ]["source_report"]["sha256"]
+    assert len(checkpoint["checkpoint_identity"]["source_cell_sha256"]) == 64
+
+
+@pytest.mark.parametrize(
+    ("timeout", "memory", "message"),
+    (
+        (0.0, 1.0, "generation timeout"),
+        (math.inf, 1.0, "generation timeout"),
+        (True, 1.0, "generation timeout"),
+        (1.0, 0.0, "memory limit"),
+        (1.0, math.nan, "memory limit"),
+        (1.0, True, "memory limit"),
+    ),
+)
+def test_custom_caps_must_only_be_positive_finite_numbers(
+    tmp_path: Path,
+    source_report: Path,
+    timeout: float,
+    memory: float,
+    message: str,
+) -> None:
+    with pytest.raises(madgraph.SelectedMadGraphError, match=message):
+        madgraph.build_runtime_report(
+            source_report=source_report,
+            cache_dir=tmp_path / "cache",
+            fc="gfortran",
+            fflags="-O3",
+            timeout_seconds=timeout,
+            mg5_root=tmp_path / "unused",
+            multiplicities=(2,),
+            memory_limit_gib=memory,
+        )
+
+
+def test_default_progress_path_stays_beside_overlay(tmp_path: Path) -> None:
+    output = tmp_path / "overlay.json"
+    assert madgraph._default_progress_output(output) == (
+        tmp_path / "overlay.progress.json"
+    )
diff --git a/pyamplicol/tests/unit/test_fft_numerical_acceptance.py b/pyamplicol/tests/unit/test_fft_numerical_acceptance.py
new file mode 100644
index 0000000000..bd0fddc2f1
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fft_numerical_acceptance.py
@@ -0,0 +1,554 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import sys
+from decimal import Decimal
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+
+import pytest
+
+from tools.developer import fft_numerical_acceptance as gate
+
+
+def test_catalog_and_comparison_matrix_are_derived_at_locked_bounds() -> None:
+    selected = gate.catalog_cases(gate.SELECTED_MAX_N_FINAL)
+    totals = gate.catalog_cases(gate.TOTAL_MAX_N_FINAL)
+
+    assert len(selected) == 47
+    assert len(totals) == 33
+    assert {case.family_id for case in selected}.isdisjoint({14})
+    assert all(case.n_final <= 5 for case in selected)
+    assert all(case.n_final <= 4 for case in totals)
+
+    specs = gate.comparison_specs()
+    direct_fft = tuple(spec for spec in specs if spec.authority == "direct-vs-fft")
+    frozen = tuple(spec for spec in specs if spec.authority == "frozen-madgraph")
+    assert len(direct_fft) == 508
+    assert len(frozen) == 66
+    assert len(specs) == 574
+    assert all(spec.model == "ufo-sm" for spec in frozen)
+    assert all(spec.accuracy == "full" for spec in frozen)
+    assert all(spec.helicity_scope == "total" for spec in frozen)
+
+
+def test_dry_run_authenticates_frozen_fixture_and_declares_cache_policy() -> None:
+    payload = gate.dry_run_payload()
+
+    assert payload["dry_run"] is True
+    assert payload["point_policy"] == {
+        "generator": "generic_validation_point",
+        "seed": 101,
+    }
+    assert payload["comparison_counts"] == {
+        "direct_vs_fft": 508,
+        "frozen_madgraph": 66,
+        "total": 574,
+    }
+    cache = payload["process_set_cache_policy"]
+    assert cache["per_process_generation"] is False
+    assert cache["base_key_axes"] == [
+        "method",
+        "model",
+        "mode",
+        "accuracy",
+        "helicity_scope",
+    ]
+    assert cache["selected_execution"] == {
+        "recurrence": "generation-specialized",
+        "on-the-fly": "runtime-query-complete-coverage",
+    }
+    assert "shared by selected runtime queries" in cache["on_the_fly_complete_coverage"]
+    assert payload["frozen_authority"]["madgraph_rerun"] is False
+
+
+def test_dry_run_cli_does_not_create_output_root(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    output_root = tmp_path / "must-not-exist"
+    assert gate.main(["--dry-run", "--output-root", str(output_root)]) == 0
+
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["kind"] == gate.GATE_KIND
+    assert payload["comparison_counts"]["total"] == 574
+    assert not output_root.exists()
+
+
+def test_scale_relative_comparison_has_no_absolute_tolerance_escape() -> None:
+    assert gate.strict_relative_compare(0, 0).passed
+    assert gate.strict_relative_compare(Decimal("1.00000000005"), Decimal("1")).passed
+    assert not gate.strict_relative_compare(Decimal("1e-300"), Decimal("2e-300")).passed
+    assert not gate.strict_relative_compare(1 + 1e-8j, 1).passed
+
+
+def test_on_the_fly_reflection_census_validator_locks_fold_and_fallback() -> None:
+    def census(
+        current_count: int,
+        contribution_count: int,
+        finalization_count: int,
+        query_count: int,
+    ) -> dict[str, object]:
+        return {
+            "basis": "shared-query-family-union-v1",
+            "scope": "active-family-union",
+            "query_count": query_count,
+            "union_unique_current_count": current_count,
+            "union_contribution_rows": contribution_count,
+            "union_finalization_rows": finalization_count,
+            "union_closure_rows": query_count,
+        }
+
+    pure_direct = census(22, 36, 6, 6)
+    pure_fft = census(13, 18, 3, 6)
+    open_line = census(17, 24, 4, 2)
+    evidence = gate.validate_on_the_fly_reflection_census(
+        pure_adjoint_direct=pure_direct,
+        pure_adjoint_fft=pure_fft,
+        open_line_direct=open_line,
+        open_line_fft=dict(open_line),
+    )
+    assert evidence["pure_adjoint"] == {
+        "case_id": "catalog:gg_gluons:n2",
+        "fields": [
+            "union_unique_current_count",
+            "union_contribution_rows",
+            "union_finalization_rows",
+        ],
+        "direct": [22, 36, 6],
+        "symmetric_group_fft": [13, 18, 3],
+    }
+    assert evidence["open_line"] == {
+        "case_id": "catalog:gg_tt_jets:n2",
+        "direct_equals_symmetric_group_fft": True,
+        "fields": [
+            "union_unique_current_count",
+            "union_contribution_rows",
+            "union_finalization_rows",
+        ],
+        "shared": [17, 24, 4],
+    }
+
+    with pytest.raises(
+        gate.FFTAcceptanceError,
+        match=r"gg_gluons:n2 direct.*expected",
+    ):
+        gate.validate_on_the_fly_reflection_census(
+            pure_adjoint_direct=census(23, 36, 6, 6),
+            pure_adjoint_fft=pure_fft,
+            open_line_direct=open_line,
+            open_line_fft=open_line,
+        )
+
+    changed_open_line = dict(open_line)
+    changed_open_line["union_closure_rows"] = 3
+    with pytest.raises(
+        gate.FFTAcceptanceError,
+        match=r"gg_tt_jets:n2.*must be identical.*union_closure_rows",
+    ):
+        gate.validate_on_the_fly_reflection_census(
+            pure_adjoint_direct=pure_direct,
+            pure_adjoint_fft=pure_fft,
+            open_line_direct=open_line,
+            open_line_fft=changed_open_line,
+        )
+
+
+def test_nonzero_discovery_prefers_structural_selector_then_stable_fallback() -> None:
+    rows = (
+        gate.HelicityObservation("h:-1,-1", (-1, -1), False, 5.0),
+        gate.HelicityObservation("h:-1,+1", (-1, 1), False, 2.0),
+        gate.HelicityObservation("h:+1,-1", (1, -1), True, 0.0),
+        gate.HelicityObservation("h:+1,+1", (1, 1), False, 0.0),
+    )
+
+    preferred = gate.choose_nonzero_helicity(rows, preferred=(-1, 1))
+    assert preferred.observation.values == (-1, 1)
+    assert preferred.source == "preferred-structural-selector"
+    assert preferred.domains == ((-1, 1), (-1, 1))
+
+    fallback = gate.choose_nonzero_helicity(rows, preferred=(1, 1))
+    assert fallback.observation.values == (-1, -1)
+    assert fallback.source == "largest-nonzero-fallback"
+
+
+def test_nonzero_discovery_rejects_an_all_zero_or_structural_axis() -> None:
+    with pytest.raises(gate.FFTAcceptanceError, match="no nonzero"):
+        gate.choose_nonzero_helicity(
+            (
+                gate.HelicityObservation("h:-1", (-1,), False, 0.0),
+                gate.HelicityObservation("h:+1", (1,), True, 3.0),
+            ),
+            preferred=(-1,),
+        )
+
+
+def test_selected_groups_include_domain_and_exact_tuple_in_scope() -> None:
+    cases = gate.catalog_cases(2)[:3]
+
+    def selection(
+        case: gate.CatalogCase,
+        values: tuple[int, ...],
+        domains: tuple[tuple[int, ...], ...],
+    ) -> gate.SelectionRecord:
+        return gate.SelectionRecord(
+            model="built-in-sm",
+            accuracy="full",
+            case=case,
+            helicity_id="h:" + ",".join(f"{value:+d}" for value in values),
+            values=values,
+            domains=domains,
+            source="unit-test",
+            discovery_value=1.0,
+        )
+
+    first_values = (-1, 1, -1)
+    first_domains = ((-1, 1), (-1, 1), (-1, 0, 1))
+    second_domains = ((-1, 1), (-1, 1), (-1, 1))
+    selections = {
+        cases[0].case_id: selection(cases[0], first_values, first_domains),
+        cases[1].case_id: selection(cases[1], first_values, first_domains),
+        cases[2].case_id: selection(cases[2], first_values, second_domains),
+    }
+
+    groups = gate.group_selected_cases(cases, selections)
+    assert tuple(len(group.cases) for group in groups) == (2, 1)
+    assert groups[0].scope != groups[1].scope
+    assert groups[0].source_mapping == ((1, -1), (2, 1), (3, -1))
+
+
+def test_process_set_cache_builds_once_per_exact_boundary() -> None:
+    calls: list[gate.GroupRequest] = []
+
+    def build(request: gate.GroupRequest) -> object:
+        calls.append(request)
+        return object()
+
+    cases = gate.catalog_cases(1)
+    request = gate.GroupRequest(
+        gate.ArtifactKey(
+            "direct",
+            "built-in-sm",
+            "recurrence",
+            "full",
+            "all-helicity-total",
+        ),
+        cases,
+    )
+    cache: gate.ProcessSetCache[object] = gate.ProcessSetCache(build)
+
+    first = cache.get(request)
+    second = cache.get(request)
+    assert first is second
+    assert calls == [request]
+    assert cache.generation_count == 1
+
+    incompatible = gate.GroupRequest(request.key, cases[:1])
+    with pytest.raises(gate.FFTAcceptanceError, match="different case"):
+        cache.get(incompatible)
+
+
+@pytest.mark.parametrize(
+    ("request_method", "n_final", "inspection_method", "accepted"),
+    (
+        ("direct", 3, None, True),
+        ("direct", 3, "symmetric-group-fourier", False),
+        ("symmetric-group-fft", 1, None, True),
+        ("symmetric-group-fft", 2, None, True),
+        ("symmetric-group-fft", 2, "symmetric-group-fourier", False),
+        ("symmetric-group-fft", 3, None, False),
+        ("symmetric-group-fft", 3, "symmetric-group-fourier", True),
+    ),
+)
+@pytest.mark.parametrize("mode", gate.MODES)
+def test_artifact_validation_maps_request_to_canonical_inspection_method(
+    request_method: gate.MethodName,
+    n_final: int,
+    inspection_method: str | None,
+    accepted: bool,
+    mode: gate.ModeName,
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    case = next(
+        case
+        for case in gate.catalog_cases(n_final)
+        if case.family_id == 1 and case.n_final == n_final
+    )
+    request = gate.GroupRequest(
+        gate.ArtifactKey(
+            request_method,
+            "built-in-sm",
+            mode,
+            "full",
+            "complete-test",
+        ),
+        (case,),
+    )
+    config = tmp_path / "config"
+    config.mkdir()
+    (config / "effective.toml").write_text(
+        "\n".join(
+            (
+                "[color]",
+                'accuracy = "full"',
+                f'contraction = "{request_method}"',
+                "[evaluator]",
+                f'execution_mode = "{mode}"',
+                "",
+            )
+        ),
+        encoding="utf-8",
+    )
+    inspection = SimpleNamespace(
+        model_name="built-in-sm",
+        model_source="compiled-model",
+        processes=(
+            SimpleNamespace(
+                id=case.artifact_name,
+                expression=case.process,
+                aliases=(),
+                color_accuracy="full",
+                execution_mode=mode,
+                recurrence_color_contraction_method=inspection_method,
+                selected_source_helicities=(),
+                helicity_coverage="complete",
+                generation_specialized_axes=(),
+            ),
+        ),
+    )
+    fake_artifacts = ModuleType("pyamplicol.artifacts")
+    fake_artifacts.inspect_artifact = lambda _path: inspection  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, "pyamplicol.artifacts", fake_artifacts)
+
+    if accepted:
+        gate.NativeArtifactBuilder._validate(tmp_path, request)
+    else:
+        with pytest.raises(gate.FFTAcceptanceError, match="expected"):
+            gate.NativeArtifactBuilder._validate(tmp_path, request)
+
+
+def test_group_request_rejects_selection_outside_recorded_domain() -> None:
+    case = gate.catalog_cases(1)[0]
+    with pytest.raises(ValueError, match="outside its domain"):
+        gate.GroupRequest(
+            gate.ArtifactKey(
+                "direct",
+                "built-in-sm",
+                "recurrence",
+                "full",
+                "selected-invalid",
+            ),
+            (case,),
+            selected_source_helicities=((1, 0),),
+            external_helicity_domains=((-1, 1),),
+        )
+
+
+def test_otf_group_request_is_complete_and_rejects_generation_selection() -> None:
+    cases = gate.catalog_cases(gate.SELECTED_MAX_N_FINAL)
+    request = gate.otf_complete_group_request(
+        method="symmetric-group-fft",
+        model="ufo-sm",
+        accuracy="nlc",
+        cases=cases,
+    )
+
+    assert request.key.mode == "on-the-fly"
+    assert request.key.helicity_scope == "complete-helicity-runtime-query-and-total"
+    assert request.cases == cases
+    assert request.selected_source_helicities is None
+    assert request.external_helicity_domains is None
+    assert request.as_payload()["helicity_generation_contract"] == "complete-coverage"
+
+    with pytest.raises(ValueError, match="must retain complete helicity coverage"):
+        gate.GroupRequest(
+            gate.ArtifactKey(
+                "direct",
+                "built-in-sm",
+                "on-the-fly",
+                "full",
+                "invalid-selected-otf",
+            ),
+            cases[:1],
+            selected_source_helicities=((1, -1),),
+            external_helicity_domains=((-1, 1),),
+        )
+
+
+def test_selected_artifact_plan_specializes_recurrence_but_groups_complete_otf(
+    tmp_path: Path,
+) -> None:
+    cases = gate.catalog_cases(1)
+    harness = object.__new__(gate.NativeAcceptanceHarness)
+    harness.selected_cases = cases
+    harness.total_cases = cases
+    harness.selections = {
+        (model, accuracy, case.case_id): gate.SelectionRecord(
+            model=model,
+            accuracy=accuracy,
+            case=case,
+            helicity_id="h:-1,+1,-1",
+            values=(-1, 1, -1),
+            domains=((-1, 1), (-1, 1), (-1, 1)),
+            source="unit-test",
+            discovery_value=3.0,
+        )
+        for model in gate.MODELS
+        for accuracy in gate.ACCURACIES
+        for case in cases
+    }
+
+    class RecordingCache:
+        def __init__(self) -> None:
+            self.requests: list[gate.GroupRequest] = []
+
+        def get(self, request: gate.GroupRequest) -> gate.ArtifactRecord:
+            self.requests.append(request)
+            return gate.ArtifactRecord(request, tmp_path / request.key.slug)
+
+    cache = RecordingCache()
+    harness.cache = cache
+    fallback_scopes = frozenset(
+        (model, accuracy) for model in gate.MODELS for accuracy in gate.ACCURACIES
+    )
+    records = harness._selected_artifacts({}, fallback_scopes)
+
+    recurrence = tuple(
+        request for request in cache.requests if request.key.mode == "recurrence"
+    )
+    otf = tuple(
+        request for request in cache.requests if request.key.mode == "on-the-fly"
+    )
+    assert len(recurrence) == 8
+    assert all(request.selected_source_helicities for request in recurrence)
+    assert len(otf) == 8
+    assert all(request.cases == cases for request in otf)
+    assert all(request.selected_source_helicities is None for request in otf)
+    for model in gate.MODELS:
+        for accuracy in gate.ACCURACIES:
+            for method in gate.METHODS:
+                lane_paths = {
+                    records[(model, "on-the-fly", accuracy, method, case.case_id)].path
+                    for case in cases
+                }
+                assert len(lane_paths) == 1
+
+    request_count = len(cache.requests)
+    totals = harness._total_artifacts(records)
+    assert len(cache.requests) == request_count + 4
+    for model in gate.MODELS:
+        for method in gate.METHODS:
+            selected_path = records[
+                (model, "on-the-fly", "full", method, cases[0].case_id)
+            ].path
+            assert totals[(model, "on-the-fly", method)].path == selected_path
+
+
+def test_otf_selected_evaluation_uses_exact_runtime_helicity_query(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    case = gate.catalog_cases(1)[0]
+    values = (-1, 1, -1)
+    helicity_id = "h:-1,+1,-1"
+    selection = gate.SelectionRecord(
+        model="built-in-sm",
+        accuracy="full",
+        case=case,
+        helicity_id=helicity_id,
+        values=values,
+        domains=((-1, 1), (-1, 1), (-1, 1)),
+        source="unit-test",
+        discovery_value=3.0,
+    )
+    request = gate.otf_complete_group_request(
+        method="direct",
+        model="built-in-sm",
+        accuracy="full",
+        cases=(case,),
+    )
+    record = gate.ArtifactRecord(request, tmp_path / "artifact")
+    calls: list[tuple[str, ...] | None] = []
+
+    class FakeRuntime:
+        execution_mode = "on-the-fly"
+        physics = SimpleNamespace(
+            color_accuracy="full",
+            helicity_coverage="complete",
+            helicities=(
+                SimpleNamespace(id="h:-1,-1,-1", values=(-1, -1, -1)),
+                SimpleNamespace(id=helicity_id, values=values),
+            ),
+        )
+
+        def evaluate(
+            self,
+            _momenta: object,
+            *,
+            helicities: tuple[str, ...] | None = None,
+        ) -> tuple[complex, ...]:
+            calls.append(helicities)
+            return (3.0 + 0.0j,)
+
+        def clear(self) -> None:
+            pass
+
+    runtime = FakeRuntime()
+    fake_pyamplicol = ModuleType("pyamplicol")
+    fake_pyamplicol.Runtime = SimpleNamespace(  # type: ignore[attr-defined]
+        load=lambda _path, *, process: runtime
+    )
+    monkeypatch.setitem(sys.modules, "pyamplicol", fake_pyamplicol)
+    monkeypatch.setattr(
+        gate,
+        "_runtime_points",
+        lambda _case: (((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert gate._evaluate_scalar(record, case, selection=selection) == 3.0 + 0.0j
+    assert calls == [(helicity_id,)]
+
+
+def test_shared_complete_artifact_caches_selected_and_total_values_separately(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    case = gate.catalog_cases(1)[0]
+    request = gate.otf_complete_group_request(
+        method="direct",
+        model="built-in-sm",
+        accuracy="full",
+        cases=(case,),
+    )
+    record = gate.ArtifactRecord(request, tmp_path / "artifact")
+    selection = gate.SelectionRecord(
+        model="built-in-sm",
+        accuracy="full",
+        case=case,
+        helicity_id="h:-1,+1,-1",
+        values=(-1, 1, -1),
+        domains=((-1, 1), (-1, 1), (-1, 1)),
+        source="unit-test",
+        discovery_value=3.0,
+    )
+    calls: list[gate.SelectionRecord | None] = []
+
+    def evaluate(
+        _record: gate.ArtifactRecord,
+        _case: gate.CatalogCase,
+        *,
+        selection: gate.SelectionRecord | None,
+    ) -> float:
+        calls.append(selection)
+        return 3.0 if selection is not None else 7.0
+
+    monkeypatch.setattr(gate, "_evaluate_scalar", evaluate)
+    harness = object.__new__(gate.NativeAcceptanceHarness)
+    harness._values = {}
+
+    assert harness._value(record, case, selection=selection) == 3.0
+    assert harness._value(record, case, selection=None) == 7.0
+    assert harness._value(record, case, selection=selection) == 3.0
+    assert calls == [selection, None]
diff --git a/pyamplicol/tests/unit/test_fft_profiling.py b/pyamplicol/tests/unit/test_fft_profiling.py
new file mode 100644
index 0000000000..9da7210ef9
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fft_profiling.py
@@ -0,0 +1,3417 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import argparse
+import builtins
+import io
+import json
+import os
+import sys
+import tomllib
+from copy import deepcopy
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.developer import fft_scaling_study as study  # noqa: E402
+from tools.fft_profiling import fft_profiling as profiling  # noqa: E402
+
+
+def _arguments(*values: str):
+    return profiling._parser().parse_args(values)
+
+
+@pytest.fixture(autouse=True)
+def _redirect_canonical_results(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(
+        profiling, "CANONICAL_RESULTS_ROOT", tmp_path / "canonical-results"
+    )
+
+
+def test_dry_run_sparse_custom_caps_is_deterministic_and_write_free(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "cluster run"
+    arguments = _arguments(
+        "--dry-run",
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "--cores",
+        "8",
+        "--candidate-cores",
+        "2",
+        "--memory-limit-gib",
+        "64",
+        "--time-limit-seconds",
+        "14400",
+        "--madgraph-root",
+        str(tmp_path / "mg5"),
+    )
+    profiling._validate_arguments(arguments)
+
+    first = profiling.dry_run_plan(arguments)
+    second = profiling.dry_run_plan(arguments)
+
+    assert first == second
+    assert not output.exists()
+    assert first["identity"]["scan"]["multiplicity_universe"] == list(range(2, 10))
+    assert first["batch_size"] == 128
+    assert first["identity"]["scan"]["batch_size"] == 128
+    assert first["requested_fill_multiplicities"] == [2, 3]
+    assert first["identity"]["resources"] == {
+        "candidate_optimization_cores": 2,
+        "per_cell_generation_timeout_seconds": 14400.0,
+        "per_cell_memory_limit_gib": 64.0,
+        "per_cell_runtime_timeout_seconds": 14400.0,
+    }
+    assert set(first["shards"]) == {shard.name for shard in profiling.SHARDS}
+    for shard in first["shards"].values():
+        if shard["argv"] is not None:
+            batch_index = shard["argv"].index("--batch-size")
+            assert shard["argv"][batch_index + 1] == "128"
+    assert first["shards"]["gg-otf"]["owned_modes"] == [
+        "otf-direct",
+        "otf-fft",
+    ]
+    mg_argv = first["madgraph"]["argv"]
+    assert mg_argv is not None
+    assert mg_argv.count("--multiplicity") == 2
+    assert mg_argv[mg_argv.index("--memory-limit-gib") + 1] == "64"
+    assert mg_argv[mg_argv.index("--generation-timeout-seconds") + 1] == "14400"
+
+
+def test_helicity_sum_dry_run_generates_a_distinct_summed_madgraph_series(
+    tmp_path: Path,
+) -> None:
+    arguments = _arguments(
+        "--dry-run",
+        "--compare-helicity-sums",
+        "--output",
+        str(tmp_path / "summed"),
+        "--multiplicities",
+        "2",
+        "3",
+        "--memory-limit-gib",
+        "64",
+        "--time-limit-seconds",
+        "14400",
+        "--madgraph-root",
+        str(tmp_path / "mg5"),
+    )
+    profiling._validate_arguments(arguments)
+
+    plan = profiling.dry_run_plan(arguments)
+
+    assert plan["helicity_workload"] == "sum"
+    assert plan["batch_size"] == 128
+    assert plan["identity"]["scan"]["helicity_workload"] == "sum"
+    assert plan["identity"]["tools"]["madgraph_root"] == str(tmp_path / "mg5")
+    assert plan["madgraph"] == {
+        "phase": 4,
+        "applicable": True,
+        "helicity_workload": "sum",
+        "process_families": ["gg", "ddbar"],
+        "measurement_multiplicities": [2, 3],
+        "protocol_scope_multiplicities": [],
+        "measurement_multiplicities_by_family": {
+            "gg": [2, 3],
+            "ddbar": [2, 3],
+        },
+        "protocol_scope_multiplicities_by_family": {"gg": [], "ddbar": []},
+        "dependency": (
+            "completed pyAmpliCol source cells for the requested MadGraph fill"
+        ),
+        "not_applicable_reason": None,
+        "report": str(tmp_path / "summed" / "madgraph" / "overlay.json"),
+        "argv": plan["madgraph"]["argv"],
+        "shell_command": plan["madgraph"]["shell_command"],
+    }
+    assert plan["madgraph"]["argv"] is not None
+    assert "--compare-helicity-sums" in plan["madgraph"]["argv"]
+    assert plan["madgraph"]["argv"][
+        plan["madgraph"]["argv"].index("--target-seconds") + 1
+    ] == "180"
+    assert plan["outputs"]["final_pdf"].endswith(
+        "/summary_plots_final_helicity_sum.pdf"
+    )
+    for shard in plan["shards"].values():
+        if shard["argv"] is not None:
+            assert "--compare-helicity-sums" in shard["argv"]
+    master = profiling._master_arguments(arguments, tmp_path / "summed")
+    assert master.compare_helicity_sums is True
+    assert study.dry_run_plan(master)["measurement"]["helicity_workload"] == "sum"
+
+
+def test_madgraph_command_protocol_scopes_n_above_six(tmp_path: Path) -> None:
+    arguments = _arguments(
+        "--dry-run",
+        "--output",
+        str(tmp_path / "fixed"),
+        "--multiplicities",
+        "6",
+        "7",
+        "8",
+        "--madgraph-root",
+        str(tmp_path / "mg5"),
+    )
+
+    plan = profiling.dry_run_plan(arguments)
+    argv = plan["madgraph"]["argv"]
+
+    assert plan["madgraph"]["measurement_multiplicities"] == [6]
+    assert plan["madgraph"]["protocol_scope_multiplicities"] == [7, 8]
+    assert plan["madgraph"]["measurement_multiplicities_by_family"] == {
+        "gg": [],
+        "ddbar": [6],
+    }
+    assert plan["madgraph"]["protocol_scope_multiplicities_by_family"] == {
+        "gg": [6, 7, 8],
+        "ddbar": [7, 8],
+    }
+    assert argv is not None
+    assert argv[argv.index("--multiplicity") + 1] == "6"
+    assert argv[argv.index("--target-seconds") + 1] == "180"
+    assert [
+        argv[index + 1]
+        for index, value in enumerate(argv)
+        if value == "--protocol-scope-multiplicity"
+    ] == ["7", "8"]
+
+
+def test_canonical_authenticated_madgraph_overlay_has_resume_fast_path(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "fixed"
+    overlay = tmp_path / "overlay.json"
+    overlay.write_text("{}", encoding="ascii")
+    arguments = _arguments("--output", str(output))
+    calls: list[tuple[Path, Path]] = []
+    monkeypatch.setattr(profiling, "_report_publication_profile", lambda _report: True)
+    monkeypatch.setattr(
+        profiling,
+        "_matching_madgraph_overlay",
+        lambda *_args, **_kwargs: overlay,
+    )
+    monkeypatch.setattr(
+        profiling.publication,
+        "build_final_report",
+        lambda *, campaign_path, madgraph_overlay_path: calls.append(
+            (campaign_path, madgraph_overlay_path)
+        ),
+    )
+
+    assert profiling._canonical_madgraph_overlay_authenticated(
+        arguments, output, {"status": "complete"}
+    )
+    assert calls == [(profiling._master_report_path(output), overlay)]
+
+
+def test_workload_defaults_are_separate_and_explicit_output_is_exact(
+    tmp_path: Path,
+) -> None:
+    fixed = _arguments()
+    summed = _arguments("--compare-helicity-sums")
+    explicit_path = tmp_path / "chosen"
+    explicit = _arguments("--compare-helicity-sums", "--output", str(explicit_path))
+
+    assert profiling._run_directory(fixed) == profiling.DEFAULT_FIXED_OUTPUT
+    assert profiling._run_directory(summed) == profiling.DEFAULT_SUM_OUTPUT
+    assert profiling._run_directory(explicit) == explicit_path
+    assert fixed.batch_size == 128
+    assert summed.batch_size == 128
+    assert profiling._pdf_filename(fixed) == "summary_plots_final.pdf"
+    assert profiling._pdf_filename(summed) == "summary_plots_final_helicity_sum.pdf"
+
+
+def test_dashboard_headline_displays_workload_batch_cores_and_rss(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    headlines: list[str] = []
+
+    class FakeBar:
+        def start(self) -> None:
+            pass
+
+        def update(self, _value: int, **values: object) -> None:
+            headlines.append(str(values["headline"]))
+
+        def finish(self, **_kwargs: object) -> None:
+            pass
+
+    monkeypatch.setattr(
+        profiling.progressbar,
+        "ProgressBar",
+        lambda **_kwargs: FakeBar(),
+    )
+    monkeypatch.setattr(profiling, "_aggregate_rss", lambda _active: 3 * 1024**3)
+
+    class FakeJob:
+        claimed_cores = 2
+        detail = "gg/recurrence-fft/n4"
+
+    dashboard = profiling.Dashboard(
+        total=2,
+        core_budget=4,
+        helicity_workload="sum",
+        batch_size=128,
+    )
+
+    dashboard.update(1, phase="phase 2", active=(FakeJob(),))
+
+    assert "1/2 cells | sum batch=128" in headlines[-1]
+    assert "phase 2: gg/recurrence-fft/n4" in headlines[-1]
+    assert "cores active=2/4" in headlines[-1]
+    assert "RSS 3.00 GiB" in headlines[-1]
+    assert "elapsed " in headlines[-1]
+    assert "ETA" not in headlines[-1]
+
+
+def test_authoritative_study_supports_isolated_roots_and_custom_caps(
+    tmp_path: Path,
+) -> None:
+    arguments = study._parser().parse_args(
+        (
+            "--study-root",
+            str(tmp_path / "one"),
+            "--run-id",
+            "cell",
+            "--multiplicity",
+            "2",
+            "--generation-timeout",
+            "14400",
+            "--runtime-timeout",
+            "14400",
+            "--memory-limit-gib",
+            "64",
+            "--optimization-cores",
+            "3",
+        )
+    )
+    study._validate_arguments(arguments)
+    plan = study.dry_run_plan(arguments)
+    measurement = plan["measurement"]
+    assert measurement["requested_memory_ceiling_gib"] == 64.0
+    assert measurement["memory_watchdog_gib"] == 64.0
+    assert measurement["candidate_optimization_cores"] == 3
+    assert measurement["generation_timeout_seconds"] == 14400.0
+
+    first_root = tmp_path / "lock-one"
+    second_root = tmp_path / "lock-two"
+    first_root.mkdir()
+    second_root.mkdir()
+    first = study._acquire_campaign_lock(first_root)
+    second = study._acquire_campaign_lock(second_root)
+    first.close()
+    second.close()
+
+
+def test_authoritative_fill_selector_does_not_change_report_policy() -> None:
+    base = study._parser().parse_args(("--multiplicity", "2", "--multiplicity", "3"))
+    fill = study._parser().parse_args(
+        (
+            "--multiplicity",
+            "2",
+            "--multiplicity",
+            "3",
+            "--fill-multiplicity",
+            "3",
+        )
+    )
+    study._validate_arguments(fill)
+
+    assert study.dry_run_plan(fill) == study.dry_run_plan(base)
+    assert study._fill_multiplicities(fill) == (3,)
+
+
+def test_otf_protocol_scope_keeps_fixed_n6_and_skips_n7_n8_n9() -> None:
+    arguments = _arguments("--multiplicities", "6", "7", "8", "9")
+    shard = profiling.SHARD_BY_NAME["gg-otf"]
+    namespace = profiling._shard_arguments(arguments, Path("/tmp/otf-scope"), shard)
+    report = study.compose_report(namespace, {})
+
+    changed = study.apply_protocol_scope_cells(
+        report,
+        family="gg",
+        modes=shard.owned_modes,
+        multiplicities=(6, 7, 8, 9),
+    )
+
+    assert changed is True
+    for mode in shard.owned_modes:
+        assert "6" not in report["cells"]["gg"][mode]
+        assert {report["cells"]["gg"][mode][str(n)]["status"] for n in (7, 8, 9)} == {
+            "skipped"
+        }
+    assert not profiling._selected_shard_complete(arguments, shard, report)
+
+    plan = profiling.dry_run_plan(arguments)
+    assert plan["shards"]["gg-otf"]["measurement_multiplicities"] == [6]
+    assert plan["shards"]["gg-otf"]["protocol_skip_multiplicities"] == [7, 8, 9]
+    assert plan["shards"]["gg-otf"]["argv"] is not None
+
+
+def test_otf_protocol_scope_can_be_extended_for_selective_top_up() -> None:
+    arguments = _arguments(
+        "--multiplicities",
+        "7",
+        "8",
+        "--families",
+        "ddbar",
+        "--lines",
+        "pyamplicol-otf",
+        "--otf-max-multiplicity",
+        "8",
+    )
+
+    plan = profiling.dry_run_plan(arguments)
+    otf = plan["shards"]["ddbar-otf"]
+
+    assert otf["measurement_multiplicities"] == [7, 8]
+    assert otf["protocol_skip_multiplicities"] == []
+    assert [(job["n"], job["mode"]) for job in otf["jobs"]] == [
+        (7, "otf-direct"),
+        (7, "otf-fft"),
+        (8, "otf-direct"),
+        (8, "otf-fft"),
+    ]
+    for job in otf["jobs"]:
+        option = job["argv"].index("--otf-max-multiplicity")
+        assert job["argv"][option + 1] == "8"
+
+
+def test_candidate_direct_and_fft_modes_are_distinct_work_items(tmp_path: Path) -> None:
+    output = tmp_path / "split"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "6",
+        "--families",
+        "gg",
+        "--lines",
+        "pyamplicol-otf",
+    )
+
+    works = profiling._phase_work_items(arguments, output, 2)
+
+    assert [
+        (work.shard.name, work.final_multiplicity, work.owned_mode)
+        for work in works
+    ] == [
+        ("gg-otf", 6, "otf-direct"),
+        ("gg-otf", 6, "otf-fft"),
+    ]
+    assert len({profiling._work_report_path(output, work) for work in works}) == 2
+    for work in works:
+        command = profiling._child_command(arguments, output, work)
+        assert command.count("--fill-mode") == 1
+        assert command[command.index("--fill-mode") + 1] == work.owned_mode
+
+
+def test_helicity_sum_amplicol_work_items_do_not_overlap_shared_overlay() -> None:
+    arguments = _arguments("--compare-helicity-sums")
+    first = profiling.ShardWork(
+        profiling.SHARD_BY_NAME["ddbar-amplicol"], 2, "amplicol"
+    )
+    second = profiling.ShardWork(
+        profiling.SHARD_BY_NAME["gg-amplicol"], 2, "amplicol"
+    )
+    active = [
+        profiling.ActiveJob(
+            shard=first.shard,
+            final_multiplicity=first.final_multiplicity,
+            owned_mode=first.owned_mode,
+            command=(),
+            process=object(),
+            stdout=io.BytesIO(),
+            stderr=io.BytesIO(),
+            sampler=object(),
+            claimed_cores=1,
+            detail="",
+        )
+    ]
+
+    assert profiling._work_launch_conflicts(arguments, second, active) is True
+    assert profiling._work_launch_conflicts(arguments, first, ()) is False
+
+
+def test_composer_retains_measured_cells_above_out_of_order_frontier() -> None:
+    arguments = study._parser().parse_args(
+        (
+            "--multiplicity",
+            "2",
+            "--multiplicity",
+            "8",
+            "--family",
+            "gg",
+            "--mode",
+            "reference-fft",
+        )
+    )
+    failed = study._cell_base("gg", study.MODE_BY_KEY["reference-fft"], 2) | {
+        "status": "failed",
+        "censors_higher_multiplicities": True,
+    }
+    measured = study._cell_base("gg", study.MODE_BY_KEY["reference-fft"], 8) | {
+        "status": "measured"
+    }
+
+    report = study.compose_report(
+        arguments,
+        {"gg": {"reference-fft": {"2": failed, "8": measured}}},
+    )
+
+    assert report["status"] == "complete-with-failures"
+    assert report["cells"]["gg"]["reference-fft"]["8"] == measured
+    assert report["resource_frontier_inversions"] == [["gg", "reference-fft", 2, 8]]
+
+
+def test_dry_run_exposes_per_multiplicity_workers(tmp_path: Path) -> None:
+    arguments = _arguments(
+        "--dry-run",
+        "--output",
+        str(tmp_path / "run"),
+        "--multiplicities",
+        "2",
+        "3",
+        "4",
+        "--lines",
+        "reference-fft",
+        "--cores",
+        "3",
+    )
+
+    plan = profiling.dry_run_plan(arguments)
+    reference = plan["shards"]["gg-reference"]
+    jobs = reference["jobs"]
+
+    assert plan["scheduler"]["parallelism"] == (
+        "weighted dependency-aware shard-multiplicity workers"
+    )
+    assert [job["n"] for job in jobs] == [2, 3, 4]
+    assert len({job["study_root"] for job in jobs}) == 3
+    assert reference["argv"] == jobs[0]["argv"]
+    assert [
+        job["argv"][index + 1]
+        for job in jobs
+        for index, value in enumerate(job["argv"])
+        if value == "--fill-multiplicity"
+    ] == ["2", "3", "4"]
+
+
+def test_isolated_shard_reports_merge_and_retain_started_higher_measurement(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "--lines",
+        "reference-fft",
+    )
+    profiling._create_or_resume_manifest(arguments, output)
+    shard = profiling.SHARD_BY_NAME["gg-reference"]
+    failed = study._cell_base("gg", study.MODE_BY_KEY["reference-fft"], 2) | {
+        "status": "failed",
+        "failure_category": "memory-limit",
+        "failure_reason": "memory cap",
+        "censors_higher_multiplicities": True,
+    }
+    measured = study._cell_base("gg", study.MODE_BY_KEY["reference-fft"], 3) | {
+        "status": "measured",
+        "generation_seconds": 1.0,
+        "warm_seconds_per_point": 1.0e-6,
+        "max_rss_kib": 1024,
+    }
+    for final_multiplicity, cell in ((2, failed), (3, measured)):
+        report = study.compose_report(
+            profiling._shard_arguments(arguments, output, shard, final_multiplicity),
+            {"gg": {"reference-fft": {str(final_multiplicity): cell}}},
+        )
+        profiling._write_json_atomic(
+            profiling._shard_report_path(output, shard, final_multiplicity),
+            report,
+        )
+
+    report = profiling._load_shard_report(arguments, output, shard, required=True)
+
+    assert report["status"] == "running"
+    curve = report["cells"]["gg"]["reference-fft"]
+    assert curve["2"]["status"] == "failed"
+    assert curve["3"] == measured
+    assert study.resource_frontier_inversions(report) == (
+        ("gg", "reference-fft", 2, 3),
+    )
+
+
+def test_isolated_shard_reports_preserve_prior_measurement_over_later_failure(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "9",
+        "--lines",
+        "amplicol",
+    )
+    profiling._create_or_resume_manifest(arguments, output)
+    shard = profiling.SHARD_BY_NAME["ddbar-amplicol"]
+    measured = study._cell_base("ddbar", study.MODE_BY_KEY["amplicol"], 9) | {
+        "status": "measured",
+        "generation_seconds": 1.0,
+        "warm_seconds_per_point": 1.0e-6,
+        "max_rss_kib": 1024,
+    }
+    failed = study._cell_base("ddbar", study.MODE_BY_KEY["amplicol"], 9) | {
+        "status": "failed",
+        "failure_category": "legacy-amplicol-structural-limit",
+        "failure_reason": "legacy crash",
+        "censors_higher_multiplicities": True,
+    }
+    aggregate = study.compose_report(
+        profiling._shard_arguments(arguments, output, shard),
+        {"ddbar": {"amplicol": {"9": measured}}},
+    )
+    retry = study.compose_report(
+        profiling._shard_arguments(arguments, output, shard, 9),
+        {"ddbar": {"amplicol": {"9": failed}}},
+    )
+    profiling._write_json_atomic(profiling._shard_report_path(output, shard), aggregate)
+    profiling._write_json_atomic(profiling._shard_report_path(output, shard, 9), retry)
+
+    report = profiling._load_shard_report(arguments, output, shard, required=True)
+
+    assert report["cells"]["ddbar"]["amplicol"]["9"] == measured
+
+
+def test_shard_policy_compatibility_accepts_sampling_policy_updates(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "5",
+        "--lines",
+        "pyamplicol-otf",
+        "--compare-helicity-sums",
+        "--memory-limit-gib",
+        "100",
+        "--time-limit-seconds",
+        "3600",
+    )
+    shard = profiling.SHARD_BY_NAME["gg-otf"]
+    modes = ("reference-fft", "otf-direct")
+    expected = profiling._expected_shard_policy(
+        arguments,
+        output,
+        shard,
+        5,
+        modes=modes,
+    )
+    stale = deepcopy(expected)
+    measurement = stale["measurement"]
+    measurement["calibration_target_seconds"] = 0.25
+    measurement["candidate_profile_target_runtime_seconds"] = 0.25
+    measurement["candidate_profile_warmup_runs"] = 2
+    measurement["candidate_profile_minimum_samples"] = 10
+    measurement["warm_samples"] = 10
+    measurement["warm_sample_count"] = 10
+    measurement["warm_timing_metric"] = {"pyamplicol": "old short sampling"}
+    measurement["generation_timeout_seconds"] = 60.0
+    measurement["runtime_timeout_seconds"] = 60.0
+    measurement["requested_memory_ceiling_gib"] = 10.0
+    measurement["memory_watchdog_gib"] = 10.0
+    measurement["cell_admission_limits"] = {}
+
+    assert profiling._shard_policy_matches_requested_modes(
+        stale,
+        expected,
+        family="gg",
+        modes=modes,
+    )
+
+    measurement["alpha_s"] = 0.2
+    assert not profiling._shard_policy_matches_requested_modes(
+        stale,
+        expected,
+        family="gg",
+        modes=modes,
+    )
+
+
+def test_phase_refresh_does_not_queue_higher_work_after_lower_resource_failure(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "4",
+        "--lines",
+        "reference-fft",
+    )
+    profiling._create_or_resume_manifest(arguments, output)
+    shard = profiling.SHARD_BY_NAME["gg-reference"]
+    failed = study._cell_base("gg", study.MODE_BY_KEY["reference-fft"], 2) | {
+        "status": "failed",
+        "failure_category": "runtime-time-limit",
+        "failure_reason": "runtime cap",
+        "censors_higher_multiplicities": True,
+    }
+    report = study.compose_report(
+        profiling._shard_arguments(arguments, output, shard, 2),
+        {"gg": {"reference-fft": {"2": failed}}},
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, shard, 2),
+        report,
+    )
+
+    pending = profiling._refresh_phase_pending(
+        arguments,
+        output,
+        profiling._phase_work_items(arguments, output, 1),
+        active=(),
+    )
+    merged = profiling._load_shard_report(arguments, output, shard, required=True)
+
+    assert pending == []
+    assert {
+        n: merged["cells"]["gg"]["reference-fft"][str(n)]["status"] for n in (2, 3, 4)
+    } == {2: "failed", 3: "skipped", 4: "skipped"}
+    assert profiling._shard_report_path(output, shard).is_file()
+
+
+def test_overwrite_retains_queued_higher_result_after_lower_resource_failure(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "overwrite-frontier"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "--lines",
+        "reference-fft",
+        "--overwrite",
+    )
+    profiling._create_or_resume_manifest(arguments, output)
+    shard = profiling.SHARD_BY_NAME["gg-reference"]
+    failed = study._cell_base("gg", study.MODE_BY_KEY["reference-fft"], 2) | {
+        "status": "failed",
+        "failure_category": "runtime-time-limit",
+        "failure_reason": "runtime cap",
+        "censors_higher_multiplicities": True,
+    }
+    measured = study._cell_base("gg", study.MODE_BY_KEY["reference-fft"], 3) | {
+        "status": "measured",
+        "generation_seconds": 2.0,
+        "warm_seconds_per_point": 2.0e-6,
+        "max_rss_kib": 2048,
+    }
+    report = study.compose_report(
+        profiling._shard_arguments(arguments, output, shard),
+        {"gg": {"reference-fft": {"2": failed, "3": measured}}},
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, shard), report
+    )
+    works = profiling._phase_work_items(arguments, output, 1)
+    overwrite_pending = {profiling._work_identity(work) for work in works}
+
+    pending = profiling._refresh_phase_pending(
+        arguments,
+        output,
+        works,
+        active=(),
+        overwrite_pending=overwrite_pending,
+    )
+
+    assert [work.final_multiplicity for work in pending] == [2]
+    assert overwrite_pending == {("gg", "reference-fft", 2)}
+    retained = profiling._load_shard_report(arguments, output, shard, required=True)
+    assert retained["cells"]["gg"]["reference-fft"]["3"] == measured
+
+
+def test_phase_launches_independent_multiplicity_workers_when_cores_allow(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "4",
+        "--lines",
+        "reference-fft",
+        "--cores",
+        "3",
+        "--poll-seconds",
+        "0.001",
+    )
+    profiling._create_or_resume_manifest(arguments, output)
+    shard = profiling.SHARD_BY_NAME["gg-reference"]
+    launched: list[int] = []
+    active_counts: list[int] = []
+
+    class FakeProcess:
+        def __init__(self, work: profiling.ShardWork) -> None:
+            self.pid = 12345 + work.final_multiplicity
+            self.returncode: int | None = None
+            self.work = work
+
+        def poll(self) -> int | None:
+            if self.returncode is None:
+                cell = study._cell_base(
+                    self.work.shard.family,
+                    study.MODE_BY_KEY["reference-fft"],
+                    self.work.final_multiplicity,
+                ) | {"status": "measured"}
+                report = study.compose_report(
+                    profiling._shard_arguments(
+                        arguments,
+                        output,
+                        self.work.shard,
+                        self.work.final_multiplicity,
+                    ),
+                    {
+                        self.work.shard.family: {
+                            "reference-fft": {str(self.work.final_multiplicity): cell}
+                        }
+                    },
+                )
+                profiling._write_json_atomic(
+                    profiling._shard_report_path(
+                        output,
+                        self.work.shard,
+                        self.work.final_multiplicity,
+                    ),
+                    report,
+                )
+                self.returncode = 0
+            return self.returncode
+
+    class FakeDashboard:
+        def update(self, _completed, *, phase, active) -> None:
+            assert phase == "phase 1"
+            active_counts.append(len(active))
+
+    def launch(_arguments, _output, work: profiling.ShardWork):
+        launched.append(work.final_multiplicity)
+        return profiling.ActiveJob(
+            shard=work.shard,
+            final_multiplicity=work.final_multiplicity,
+            owned_mode=work.owned_mode,
+            command=(),
+            process=FakeProcess(work),
+            stdout=io.BytesIO(),
+            stderr=io.BytesIO(),
+            sampler=object(),
+            claimed_cores=profiling._claimed_cores(arguments, work),
+            detail="",
+        )
+
+    monkeypatch.setattr(profiling, "_launch_shard", launch)
+
+    profiling._phase(arguments, output, 1, FakeDashboard())
+
+    assert launched[:3] == [2, 3, 4]
+    assert max(active_counts) == 3
+    merged = profiling._load_shard_report(arguments, output, shard, required=True)
+    assert study.selected_cells_complete(
+        merged,
+        family="gg",
+        modes=("reference-fft",),
+        multiplicities=(2, 3, 4),
+    )
+
+
+def test_phase_accepts_authoritative_failed_cell_from_nonzero_child(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--families",
+        "ddbar",
+        "--multiplicities",
+        "9",
+        "--lines",
+        "amplicol",
+        "--cores",
+        "1",
+        "--poll-seconds",
+        "0.001",
+    )
+    profiling._create_or_resume_manifest(arguments, output)
+
+    class FakeProcess:
+        def __init__(self, work: profiling.ShardWork) -> None:
+            self.pid = 45678
+            self.returncode: int | None = None
+            self.work = work
+
+        def poll(self) -> int | None:
+            if self.returncode is None:
+                cell = study._cell_base(
+                    self.work.shard.family,
+                    study.MODE_BY_KEY[self.work.owned_mode],
+                    self.work.final_multiplicity,
+                ) | {
+                    "status": "failed",
+                    "failure_category": "error",
+                    "failure_reason": "legacy checkout contains tracked edits",
+                    "censors_higher_multiplicities": False,
+                }
+                report = study.compose_report(
+                    profiling._work_arguments(arguments, output, self.work),
+                    {
+                        self.work.shard.family: {
+                            self.work.owned_mode: {
+                                str(self.work.final_multiplicity): cell
+                            }
+                        }
+                    },
+                )
+                report["status"] = "stopped-correctness-failure"
+                profiling._write_json_atomic(
+                    profiling._work_report_path(output, self.work),
+                    report,
+                )
+                self.returncode = 1
+            return self.returncode
+
+    class FakeDashboard:
+        def update(self, _completed, *, phase, active) -> None:
+            assert phase == "phase 1"
+
+    def launch(_arguments, _output, work: profiling.ShardWork):
+        return profiling.ActiveJob(
+            shard=work.shard,
+            final_multiplicity=work.final_multiplicity,
+            owned_mode=work.owned_mode,
+            command=(),
+            process=FakeProcess(work),
+            stdout=io.BytesIO(),
+            stderr=io.BytesIO(),
+            sampler=object(),
+            claimed_cores=1,
+            detail="",
+        )
+
+    monkeypatch.setattr(profiling, "_launch_shard", launch)
+
+    profiling._phase(arguments, output, 1, FakeDashboard())
+    report = profiling._publish_master(arguments, output)
+
+    assert profiling._selected_completed_cells(
+        arguments, report, multiplicities=(9,)
+    ) == 1
+    assert (
+        profiling._selected_pending_cells(arguments, report, multiplicities=(9,)) == 0
+    )
+    assert (
+        report["cells"]["ddbar"]["amplicol"]["9"]["failure_category"] == "error"
+    )
+
+
+def test_candidate_core_setting_is_passed_to_generation() -> None:
+    command = study._candidate_generation_command(
+        python="python",
+        family="gg",
+        final_multiplicity=3,
+        mode=study.MODE_BY_KEY["otf-fft"],
+        artifact=Path("artifact"),
+        batch_size=1,
+        optimization_cores=4,
+    )
+    assert "evaluator.optimization.cores=4" in command
+
+
+def test_matching_manifest_resumes_automatically_and_rejects_identity_change(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments("--output", str(output), "--multiplicities", "2", "3")
+    first = profiling._create_or_resume_manifest(arguments, output)
+    assert profiling._create_or_resume_manifest(arguments, output) == first
+
+    later = _arguments("--output", str(output), "--multiplicities", "4", "5")
+    expanded = profiling._create_or_resume_manifest(later, output)
+    assert expanded["requested_multiplicities"] == [4, 5]
+    assert expanded["active_multiplicities"] == [4, 5]
+    assert expanded["fill_history_multiplicities"] == [2, 3, 4, 5]
+    shard_arguments = profiling._shard_arguments(
+        later, output, profiling.SHARD_BY_NAME["ddbar-recurrence"]
+    )
+    assert shard_arguments.fill_multiplicities == [4, 5]
+
+    resource_changed = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "--memory-limit-gib",
+        "64",
+        "--time-limit-seconds",
+        "7200",
+    )
+    resource_updated = profiling._create_or_resume_manifest(resource_changed, output)
+    assert resource_updated["identity"]["resources"] == {
+        "candidate_optimization_cores": 1,
+        "per_cell_generation_timeout_seconds": 7200.0,
+        "per_cell_memory_limit_gib": 64.0,
+        "per_cell_runtime_timeout_seconds": 7200.0,
+    }
+
+    target_changed = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "--memory-limit-gib",
+        "64",
+        "--time-limit-seconds",
+        "7200",
+        "--target-seconds",
+        "30",
+    )
+    target_updated = profiling._create_or_resume_manifest(target_changed, output)
+    assert target_updated["identity"]["scan"]["target_seconds"] == 30.0
+
+    summed = _arguments(
+        "--compare-helicity-sums",
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "--memory-limit-gib",
+        "64",
+        "--time-limit-seconds",
+        "7200",
+    )
+    with pytest.raises(profiling.ProfilingError, match="helicity_workload"):
+        profiling._create_or_resume_manifest(summed, output)
+
+    scalar = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "--batch-size",
+        "1",
+        "--memory-limit-gib",
+        "64",
+        "--time-limit-seconds",
+        "7200",
+    )
+    with pytest.raises(profiling.ProfilingError, match="batch_size"):
+        profiling._create_or_resume_manifest(scalar, output)
+
+    other_host = dict(first["identity"]["measurement_host"])
+    other_host["node_sha256"] = "f" * 64
+    monkeypatch.setattr(
+        profiling.madgraph, "measurement_host_identity", lambda: other_host
+    )
+    with pytest.raises(profiling.ProfilingError, match="measurement_host"):
+        profiling._create_or_resume_manifest(resource_changed, output)
+
+
+def test_render_arguments_inherit_helicity_workload_from_manifest(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "summed"
+    profiling._create_or_resume_manifest(
+        _arguments(
+            "--output",
+            str(output),
+            "--compare-helicity-sums",
+            "--multiplicities",
+            "2",
+        ),
+        output,
+    )
+
+    rendered = profiling._composition_arguments(
+        _arguments("--render", "--output", str(output)), output
+    )
+
+    assert rendered.compare_helicity_sums is True
+    assert profiling._helicity_workload(rendered) == "sum"
+    assert profiling._pdf_filename(rendered) == "summary_plots_final_helicity_sum.pdf"
+
+
+def test_resume_manifest_allows_midrun_resource_limit_decreases(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "run"
+    initial = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--memory-limit-gib",
+        "800",
+        "--time-limit-seconds",
+        "360000",
+    )
+    lowered = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--memory-limit-gib",
+        "200",
+        "--time-limit-seconds",
+        "36000",
+    )
+    status = _arguments(
+        "--status",
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--memory-limit-gib",
+        "100",
+        "--time-limit-seconds",
+        "18000",
+    )
+
+    profiling._create_or_resume_manifest(initial, output)
+    manifest = profiling._create_or_resume_manifest(lowered, output)
+
+    assert manifest["identity"]["resources"] == {
+        "candidate_optimization_cores": 1,
+        "per_cell_generation_timeout_seconds": 36000.0,
+        "per_cell_memory_limit_gib": 200.0,
+        "per_cell_runtime_timeout_seconds": 36000.0,
+    }
+    assert profiling.status_payload(status)["requested_multiplicities"] == [2]
+
+
+def test_existing_manifest_history_does_not_expand_current_multiplicity_request(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "run"
+    broad = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "4",
+        "5",
+        "6",
+        "7",
+        "8",
+        "9",
+        "--lines",
+        "reference-fft",
+    )
+    profiling._create_or_resume_manifest(broad, output)
+    lower = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+        "--lines",
+        "reference-fft",
+    )
+
+    manifest = profiling._create_or_resume_manifest(lower, output)
+    work = profiling._phase_work_items(lower, output, 1)
+    plan = profiling.dry_run_plan(lower)
+
+    assert manifest["requested_multiplicities"] == [2, 3]
+    assert manifest["fill_history_multiplicities"] == list(range(2, 10))
+    assert [item.final_multiplicity for item in work] == [2, 3]
+    assert [job["n"] for job in plan["shards"]["gg-reference"]["jobs"]] == [2, 3]
+
+
+def test_line_groups_track_history_but_schedule_only_requested_work(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "line-groups"
+    common = ("--output", str(output), "--madgraph-root", str(tmp_path / "mg5"))
+    reference = _arguments(
+        *common,
+        "--multiplicities",
+        "2",
+        "--lines",
+        "reference-fft",
+    )
+    first = profiling._create_or_resume_manifest(reference, output)
+    assert first["requested_line_groups"] == ["reference-fft"]
+    reference_plan = profiling.dry_run_plan(reference)
+    assert {
+        name for name, shard in reference_plan["shards"].items() if shard["scheduled"]
+    } == {"gg-reference"}
+    assert reference_plan["madgraph"]["applicable"] is False
+
+    otf = _arguments(
+        *common,
+        "--multiplicities",
+        "3",
+        "--lines",
+        "pyamplicol-otf",
+    )
+    expanded = profiling._create_or_resume_manifest(otf, output)
+    assert expanded["requested_multiplicities"] == [3]
+    assert expanded["requested_line_groups"] == ["pyamplicol-otf"]
+    assert expanded["fill_history_multiplicities"] == [2, 3]
+    assert expanded["line_group_history"] == [
+        "reference-fft",
+        "pyamplicol-otf",
+    ]
+    otf_plan = profiling.dry_run_plan(otf)
+    assert {
+        name for name, shard in otf_plan["shards"].items() if shard["scheduled"]
+    } == {"gg-reference", "gg-otf", "ddbar-amplicol", "ddbar-otf"}
+    assert otf_plan["madgraph"]["applicable"] is False
+    assert otf_plan["shards"]["gg-recurrence"]["argv"] is None
+
+    with_madgraph = _arguments(
+        *common,
+        "--multiplicities",
+        "4",
+        "--lines",
+        "madgraph",
+    )
+    final = profiling._create_or_resume_manifest(with_madgraph, output)
+    assert final["requested_multiplicities"] == [4]
+    assert final["requested_line_groups"] == ["madgraph"]
+    assert final["fill_history_multiplicities"] == [2, 3, 4]
+    assert final["line_group_history"] == [
+        "reference-fft",
+        "pyamplicol-otf",
+        "madgraph",
+    ]
+    madgraph_plan = profiling.dry_run_plan(with_madgraph)
+    assert madgraph_plan["madgraph"]["applicable"] is True
+    assert madgraph_plan["madgraph"]["argv"] is not None
+    assert madgraph_plan["shards"]["ddbar-recurrence"]["scheduled"] is True
+
+
+def test_concrete_line_selector_schedules_only_requested_fft_variant(
+    tmp_path: Path,
+) -> None:
+    arguments = _arguments(
+        "--dry-run",
+        "--output",
+        str(tmp_path / "line-mode"),
+        "--multiplicities",
+        "2",
+        "--lines",
+        "recurrence-fft",
+    )
+
+    plan = profiling.dry_run_plan(arguments)
+    scheduled = {name for name, shard in plan["shards"].items() if shard["scheduled"]}
+    gg = plan["shards"]["gg-recurrence"]
+    ddbar = plan["shards"]["ddbar-recurrence"]
+
+    assert plan["requested_line_groups"] == ["recurrence-fft"]
+    assert scheduled == {
+        "gg-reference",
+        "ddbar-amplicol",
+        "gg-recurrence",
+        "ddbar-recurrence",
+    }
+    assert gg["modes"] == ["reference-fft", "recurrence-fft"]
+    assert gg["owned_modes"] == ["recurrence-fft"]
+    assert ddbar["modes"] == ["amplicol", "recurrence-fft"]
+    assert ddbar["owned_modes"] == ["recurrence-fft"]
+    assert gg["argv"] is not None
+    assert "--mode recurrence-fft" in gg["shell_command"]
+    assert "--mode recurrence-direct" not in gg["shell_command"]
+    assert plan["shards"]["gg-otf"]["scheduled"] is False
+
+
+def test_process_family_selector_limits_scheduled_shards_and_madgraph(
+    tmp_path: Path,
+) -> None:
+    arguments = _arguments(
+        "--dry-run",
+        "--output",
+        str(tmp_path / "family-mode"),
+        "--multiplicities",
+        "2",
+        "--families",
+        "gg",
+        "--lines",
+        "recurrence-fft",
+        "madgraph",
+        "--madgraph-root",
+        str(tmp_path / "mg5"),
+    )
+
+    plan = profiling.dry_run_plan(arguments)
+    scheduled = {name for name, shard in plan["shards"].items() if shard["scheduled"]}
+    madgraph_argv = plan["madgraph"]["argv"]
+
+    assert plan["requested_process_families"] == ["gg"]
+    assert scheduled == {"gg-reference", "gg-recurrence"}
+    assert plan["shards"]["ddbar-amplicol"]["scheduled"] is False
+    assert plan["madgraph"]["process_families"] == ["gg"]
+    assert madgraph_argv is not None
+    assert madgraph_argv[madgraph_argv.index("--family") + 1] == "gg"
+
+
+def test_process_family_selector_rejects_inapplicable_line() -> None:
+    arguments = _arguments(
+        "--families",
+        "ddbar",
+        "--lines",
+        "reference-fft",
+    )
+    with pytest.raises(profiling.ProfilingError, match="no applicable"):
+        profiling._validate_arguments(arguments)
+
+
+def test_madgraph_completed_ignores_overlay_when_not_requested(tmp_path: Path) -> None:
+    output = tmp_path / "reference-only-with-overlay"
+    overlay = profiling._madgraph_overlay_path(output)
+    overlay.parent.mkdir(parents=True)
+    overlay.write_text(
+        json.dumps(
+            {
+                "host": profiling.madgraph.measurement_host_identity(),
+                "policy": {
+                    "final_state_multiplicities": [2],
+                    "maximum_measured_multiplicity": 6,
+                    "family_maximum_measured_multiplicity": {
+                        "gg": 5,
+                        "ddbar": 6,
+                    },
+                    "higher_multiplicity_policy": "not-applicable-protocol-scope",
+                },
+                "runtime_series": {
+                    "gg": {
+                        "madgraph-standalone": {
+                            "2": {
+                                "status": "measured",
+                                "warm_seconds_per_point": 1.0e-6,
+                            }
+                        }
+                    }
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--lines",
+        "reference-fft",
+    )
+
+    assert profiling._madgraph_completed(arguments, output) == 0
+
+
+def test_retry_invalidates_failed_selected_cell_without_dependency_count(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "retry"
+    initial = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "7",
+        "--families",
+        "gg",
+        "--lines",
+        "recurrence-direct",
+        "--memory-limit-gib",
+        "100",
+    )
+    retry = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "7",
+        "--families",
+        "gg",
+        "--lines",
+        "recurrence-direct",
+        "--memory-limit-gib",
+        "160",
+        "--retry",
+    )
+    profiling._create_or_resume_manifest(initial, output)
+    reference = profiling.SHARD_BY_NAME["gg-reference"]
+    recurrence = profiling.SHARD_BY_NAME["gg-recurrence"]
+    reference_cell = study._cell_base("gg", study.MODE_BY_KEY["reference-fft"], 7) | {
+        "status": "measured",
+        "generation_seconds": 1.0,
+        "warm_seconds_per_point": 1.0e-6,
+        "max_rss_kib": 1024,
+    }
+    failed_cell = study._cell_base("gg", study.MODE_BY_KEY["recurrence-direct"], 7) | {
+        "status": "failed",
+        "failure_category": "memory-limit",
+        "failure_reason": "memory cap",
+        "censors_higher_multiplicities": True,
+    }
+    reference_report = study.compose_report(
+        profiling._shard_arguments(initial, output, reference),
+        {"gg": {"reference-fft": {"7": reference_cell}}},
+    )
+    recurrence_cells = {
+        "gg": {
+            "reference-fft": {"7": reference_cell},
+            "recurrence-direct": {"7": failed_cell},
+        }
+    }
+    recurrence_aggregate = study.compose_report(
+        profiling._shard_arguments(initial, output, recurrence),
+        recurrence_cells,
+    )
+    recurrence_cell_report = study.compose_report(
+        profiling._shard_arguments(initial, output, recurrence, 7),
+        recurrence_cells,
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, reference),
+        reference_report,
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, recurrence),
+        recurrence_aggregate,
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, recurrence, 7),
+        recurrence_cell_report,
+    )
+
+    manifest = profiling._create_or_resume_manifest(retry, output)
+    removed = profiling._apply_retry_invalidation(retry, output)
+    master = profiling._publish_master(retry, output)
+    per_cell = json.loads(
+        profiling._shard_report_path(output, recurrence, 7).read_text(
+            encoding="utf-8"
+        )
+    )
+    plan = profiling.dry_run_plan(retry)
+
+    assert manifest["identity"]["resources"]["per_cell_memory_limit_gib"] == 160.0
+    assert removed == 1
+    assert profiling._phase_work_items(retry, output, 1) == ()
+    assert [
+        (work.shard.name, work.final_multiplicity)
+        for work in profiling._phase_work_items(retry, output, 2)
+    ] == [("gg-recurrence", 7)]
+    assert profiling._selected_completed_cells(retry, master, multiplicities=(7,)) == 0
+    assert profiling._selected_pending_cells(retry, master, multiplicities=(7,)) == 1
+    assert (
+        per_cell["cells"]["gg"]["reference-fft"]["7"]["status"] == "measured"
+    )
+    assert "7" not in per_cell["cells"]["gg"]["recurrence-direct"]
+    assert plan["shards"]["gg-reference"]["scheduled"] is False
+    assert plan["shards"]["gg-reference"]["jobs"] == []
+    assert [job["n"] for job in plan["shards"]["gg-recurrence"]["jobs"]] == [7]
+
+
+def test_overwrite_group_replaces_each_mode_only_when_its_worker_launches(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    output = tmp_path / "overwrite"
+    initial = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "6",
+        "--families",
+        "ddbar",
+        "--lines",
+        "pyamplicol-recurrence",
+    )
+    overwrite = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "6",
+        "--families",
+        "ddbar",
+        "--lines",
+        "pyamplicol-recurrence",
+        "--cores",
+        "2",
+        "--poll-seconds",
+        "0.001",
+        "--overwrite",
+    )
+    profiling._create_or_resume_manifest(initial, output)
+    profiling._create_or_resume_manifest(overwrite, output)
+    dependency = profiling.SHARD_BY_NAME["ddbar-amplicol"]
+    recurrence = profiling.SHARD_BY_NAME["ddbar-recurrence"]
+
+    def measured(mode: str, generation_seconds: float) -> dict[str, object]:
+        return study._cell_base("ddbar", study.MODE_BY_KEY[mode], 6) | {
+            "status": "measured",
+            "generation_seconds": generation_seconds,
+            "warm_seconds_per_point": generation_seconds / 1000.0,
+            "max_rss_kib": 1024,
+        }
+
+    amplicol = measured("amplicol", 1.0)
+    old = {
+        "recurrence-direct": measured("recurrence-direct", 11.0),
+        "recurrence-fft": measured("recurrence-fft", 12.0),
+    }
+    dependency_report = study.compose_report(
+        profiling._shard_arguments(initial, output, dependency),
+        {"ddbar": {"amplicol": {"6": amplicol}}},
+    )
+    aggregate = study.compose_report(
+        profiling._shard_arguments(initial, output, recurrence),
+        {
+            "ddbar": {
+                "amplicol": {"6": amplicol},
+                **{mode: {"6": cell} for mode, cell in old.items()},
+            }
+        },
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, dependency), dependency_report
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, recurrence), aggregate
+    )
+    legacy = study.compose_report(
+        profiling._shard_arguments(initial, output, recurrence, 6),
+        {
+            "ddbar": {
+                "amplicol": {"6": amplicol},
+                **{mode: {"6": cell} for mode, cell in old.items()},
+            }
+        },
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, recurrence, 6), legacy
+    )
+    works = profiling._phase_work_items(overwrite, output, 2)
+    assert [work.owned_mode for work in works] == [
+        "recurrence-direct",
+        "recurrence-fft",
+    ]
+    for work in works:
+        per_mode = study.compose_report(
+            profiling._work_arguments(initial, output, work),
+            {
+                "ddbar": {
+                    "amplicol": {"6": amplicol},
+                    work.owned_mode: {"6": old[work.owned_mode]},
+                }
+            },
+        )
+        profiling._write_json_atomic(
+            profiling._work_report_path(output, work), per_mode
+        )
+
+    overwrite_pending = {profiling._work_identity(work) for work in works}
+    initial_master = profiling._publish_master(overwrite, output)
+    assert (
+        profiling._selected_completed_cells(
+            overwrite,
+            initial_master,
+            multiplicities=(6,),
+            ignored_cells=overwrite_pending,
+        )
+        == 0
+    )
+    assert (
+        profiling._selected_pending_cells(
+            overwrite,
+            initial_master,
+            multiplicities=(6,),
+            ignored_cells=overwrite_pending,
+        )
+        == 2
+    )
+    assert all(profiling._work_report_path(output, work).is_file() for work in works)
+
+    launched: list[str] = []
+
+    class FakeProcess:
+        def __init__(self, work: profiling.ShardWork) -> None:
+            self.pid = 23456 + len(launched)
+            self.returncode: int | None = None
+            self.work = work
+
+        def poll(self) -> int | None:
+            if self.returncode is None:
+                replacement = measured(
+                    self.work.owned_mode,
+                    101.0 if self.work.owned_mode == "recurrence-direct" else 102.0,
+                )
+                report = study.compose_report(
+                    profiling._work_arguments(overwrite, output, self.work),
+                    {
+                        "ddbar": {
+                            "amplicol": {"6": amplicol},
+                            self.work.owned_mode: {"6": replacement},
+                        }
+                    },
+                )
+                profiling._write_json_atomic(
+                    profiling._work_report_path(output, self.work), report
+                )
+                self.returncode = 0
+            return self.returncode
+
+    class FakeDashboard:
+        def update(self, _completed, *, phase, active) -> None:
+            assert phase == "phase 2"
+
+    def launch(_arguments, _output, work: profiling.ShardWork):
+        seeded = json.loads(
+            profiling._work_report_path(output, work).read_text(encoding="utf-8")
+        )
+        assert "6" not in seeded["cells"]["ddbar"][work.owned_mode]
+        if work.owned_mode == "recurrence-direct":
+            fft_work = next(
+                candidate
+                for candidate in works
+                if candidate.owned_mode == "recurrence-fft"
+            )
+            fft_report = json.loads(
+                profiling._work_report_path(output, fft_work).read_text(
+                    encoding="utf-8"
+                )
+            )
+            assert (
+                fft_report["cells"]["ddbar"]["recurrence-fft"]["6"][
+                    "generation_seconds"
+                ]
+                == 12.0
+            )
+            legacy_report = json.loads(
+                profiling._shard_report_path(output, recurrence, 6).read_text(
+                    encoding="utf-8"
+                )
+            )
+            assert "6" not in legacy_report["cells"]["ddbar"]["recurrence-direct"]
+            assert (
+                legacy_report["cells"]["ddbar"]["recurrence-fft"]["6"][
+                    "generation_seconds"
+                ]
+                == 12.0
+            )
+        launched.append(work.owned_mode)
+        return profiling.ActiveJob(
+            shard=work.shard,
+            final_multiplicity=work.final_multiplicity,
+            owned_mode=work.owned_mode,
+            command=(),
+            process=FakeProcess(work),
+            stdout=io.BytesIO(),
+            stderr=io.BytesIO(),
+            sampler=object(),
+            claimed_cores=profiling._claimed_cores(overwrite, work),
+            detail="",
+        )
+
+    original_prepare = profiling._prepare_overwrite_work
+    original_seed = profiling._seed_cell_inputs
+
+    def prepare(_arguments, _output, work: profiling.ShardWork):
+        removed = original_prepare(_arguments, _output, work)
+        aggregate_report = json.loads(
+            profiling._shard_report_path(output, recurrence).read_text(
+                encoding="utf-8"
+            )
+        )
+        assert "6" not in aggregate_report["cells"]["ddbar"][work.owned_mode]
+        legacy_report = json.loads(
+            profiling._shard_report_path(output, recurrence, 6).read_text(
+                encoding="utf-8"
+            )
+        )
+        assert "6" not in legacy_report["cells"]["ddbar"][work.owned_mode]
+        assert not profiling._work_cell_root(output, work).exists()
+        stale_sources = []
+        for path in (output / "shards" / recurrence.name).rglob("report.json"):
+            payload = json.loads(path.read_text(encoding="utf-8"))
+            cell = payload.get("cells", {}).get("ddbar", {}).get(
+                work.owned_mode, {}
+            ).get("6")
+            if cell is not None:
+                stale_sources.append((str(path), cell.get("generation_seconds")))
+        assert stale_sources == []
+        merged_report = profiling._load_shard_report(
+            overwrite, output, recurrence, required=True
+        )
+        merged_cell = merged_report["cells"]["ddbar"][work.owned_mode].get("6")
+        assert merged_cell is None, (
+            merged_cell.get("status"),
+            merged_cell.get("generation_seconds"),
+            merged_cell.get("failure_reason"),
+        )
+        return removed
+
+    def seed(_arguments, _output, work: profiling.ShardWork):
+        original_seed(_arguments, _output, work)
+        seeded = json.loads(
+            profiling._work_report_path(output, work).read_text(encoding="utf-8")
+        )
+        assert "6" not in seeded["cells"]["ddbar"][work.owned_mode]
+
+    monkeypatch.setattr(profiling, "_prepare_overwrite_work", prepare)
+    monkeypatch.setattr(profiling, "_seed_cell_inputs", seed)
+    monkeypatch.setattr(profiling, "_launch_shard", launch)
+
+    profiling._phase(
+        overwrite,
+        output,
+        2,
+        FakeDashboard(),
+        overwrite_pending=overwrite_pending,
+    )
+
+    assert launched == ["recurrence-direct", "recurrence-fft"]
+    assert overwrite_pending == set()
+    merged = profiling._load_shard_report(
+        overwrite, output, recurrence, required=True
+    )
+    assert (
+        merged["cells"]["ddbar"]["recurrence-direct"]["6"][
+            "generation_seconds"
+        ]
+        == 101.0
+    )
+    assert (
+        merged["cells"]["ddbar"]["recurrence-fft"]["6"][
+            "generation_seconds"
+        ]
+        == 102.0
+    )
+
+
+def test_overwrite_and_retry_are_mutually_exclusive() -> None:
+    with pytest.raises(SystemExit):
+        _arguments("--overwrite", "--retry")
+
+
+def test_narrow_line_selector_reuses_existing_broader_shard_report(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "line-mode-resume"
+    shard = profiling.SHARD_BY_NAME["gg-recurrence"]
+    broad = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--lines",
+        "pyamplicol-recurrence",
+    )
+    narrow = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--lines",
+        "recurrence-fft",
+    )
+    cells = {"gg": {}}
+    for mode in ("reference-fft", "recurrence-direct", "recurrence-fft"):
+        cells["gg"][mode] = {
+            "2": study._cell_base("gg", study.MODE_BY_KEY[mode], 2)
+            | {
+                "status": "measured",
+                "generation_seconds": 1.0,
+                "warm_seconds_per_point": 1.0e-6,
+                "max_rss_kib": 1024,
+            }
+        }
+    report = study.compose_report(
+        profiling._shard_arguments(broad, output, shard, 2),
+        cells,
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, shard, 2),
+        report,
+    )
+
+    loaded = profiling._load_shard_report(narrow, output, shard, required=True)
+    family = loaded["cells"]["gg"]
+
+    assert set(family) == {"reference-fft", "recurrence-fft"}
+    assert family["recurrence-fft"]["2"]["status"] == "measured"
+
+
+def test_broad_line_selector_tops_up_existing_narrow_shard_reports(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "line-mode-top-up"
+    shard = profiling.SHARD_BY_NAME["gg-recurrence"]
+    direct = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--families",
+        "gg",
+        "--lines",
+        "recurrence-direct",
+    )
+    fft = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--families",
+        "gg",
+        "--lines",
+        "recurrence-fft",
+    )
+    broad = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--families",
+        "gg",
+        "--lines",
+        "pyamplicol-recurrence",
+    )
+    cells = {"gg": {}}
+    for mode in ("reference-fft", "recurrence-direct", "recurrence-fft"):
+        cells["gg"][mode] = {
+            "2": study._cell_base("gg", study.MODE_BY_KEY[mode], 2)
+            | {
+                "status": "measured",
+                "generation_seconds": 1.0,
+                "warm_seconds_per_point": 1.0e-6,
+                "max_rss_kib": 1024,
+            }
+        }
+    direct_aggregate = study.compose_report(
+        profiling._shard_arguments(direct, output, shard),
+        {
+            "gg": {
+                mode: cells["gg"][mode]
+                for mode in ("reference-fft", "recurrence-direct")
+            }
+        },
+    )
+    fft_per_cell = study.compose_report(
+        profiling._shard_arguments(fft, output, shard, 2),
+        {
+            "gg": {
+                mode: cells["gg"][mode]
+                for mode in ("reference-fft", "recurrence-fft")
+            }
+        },
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, shard),
+        direct_aggregate,
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, shard, 2),
+        fft_per_cell,
+    )
+
+    loaded = profiling._load_shard_report(broad, output, shard, required=True)
+    family = loaded["cells"]["gg"]
+
+    assert set(family) == {"reference-fft", "recurrence-direct", "recurrence-fft"}
+    assert family["recurrence-direct"]["2"]["status"] == "measured"
+    assert family["recurrence-fft"]["2"]["status"] == "measured"
+
+
+def test_mode_cell_report_run_root_does_not_block_shard_merge(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "mode-cell-run-root"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--families",
+        "ddbar",
+        "--lines",
+        "otf-direct",
+        "--compare-helicity-sums",
+    )
+    shard = profiling.SHARD_BY_NAME["ddbar-otf"]
+    work = profiling.ShardWork(shard, 2, "otf-direct")
+    amplicol_cell = study._cell_base(
+        "ddbar", study.MODE_BY_KEY["amplicol"], 2, sum_helicities=True
+    ) | {
+        "status": "measured",
+    }
+    otf_cell = study._cell_base(
+        "ddbar", study.MODE_BY_KEY["otf-direct"], 2, sum_helicities=True
+    ) | {
+        "status": "measured",
+    }
+    report = study.compose_report(
+        profiling._work_arguments(arguments, output, work),
+        {"ddbar": {"amplicol": {"2": amplicol_cell}, "otf-direct": {"2": otf_cell}}},
+    )
+    profiling._write_json_atomic(profiling._work_report_path(output, work), report)
+
+    loaded = profiling._load_shard_report(arguments, output, shard, required=True)
+
+    assert loaded["cells"]["ddbar"]["otf-direct"]["2"]["status"] == "measured"
+
+
+def test_output_render_rebuilds_master_from_manifest_history(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "render-history"
+    shard = profiling.SHARD_BY_NAME["gg-recurrence"]
+    broad = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--families",
+        "gg",
+        "--lines",
+        "pyamplicol-recurrence",
+    )
+    narrow = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--families",
+        "gg",
+        "--lines",
+        "recurrence-direct",
+    )
+    profiling._create_or_resume_manifest(broad, output)
+    profiling._create_or_resume_manifest(narrow, output)
+    cells = {"gg": {}}
+    for mode in ("reference-fft", "recurrence-direct", "recurrence-fft"):
+        cells["gg"][mode] = {
+            "2": study._cell_base("gg", study.MODE_BY_KEY[mode], 2)
+            | {
+                "status": "measured",
+                "generation_seconds": 1.0,
+                "warm_seconds_per_point": 1.0e-6,
+                "max_rss_kib": 1024,
+            }
+        }
+    per_cell = study.compose_report(
+        profiling._shard_arguments(broad, output, shard, 2),
+        cells,
+    )
+    partial_aggregate = study.compose_report(
+        profiling._shard_arguments(narrow, output, shard),
+        {
+            "gg": {
+                mode: cells["gg"][mode]
+                for mode in ("reference-fft", "recurrence-direct")
+            }
+        },
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, shard, 2),
+        per_cell,
+    )
+    profiling._write_json_atomic(
+        profiling._shard_report_path(output, shard),
+        partial_aggregate,
+    )
+    rendered: dict[str, object] = {}
+
+    def fake_run(command, **_kwargs):
+        command = tuple(command)
+        if Path(command[1]) == profiling.PLOT_TOOL:
+            rendered.update(json.loads(Path(command[2]).read_text(encoding="utf-8")))
+            plot_root = Path(command[3])
+            plot_root.mkdir(parents=True)
+            for family in ("gg", "ddbar"):
+                for metric in ("generation", "warm-runtime", "rss"):
+                    (plot_root / f"fullcolor-{family}-{metric}.png").write_bytes(
+                        b"png"
+                    )
+        else:
+            _write_fake_pdf_output(command)
+
+    monkeypatch.setattr(profiling, "_run_checked", fake_run)
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+
+    profiling.render_snapshot(_arguments("--render", "--output", str(output)))
+
+    assert rendered["cells"]["gg"]["recurrence-direct"]["2"]["status"] == "measured"
+    assert rendered["cells"]["gg"]["recurrence-fft"]["2"]["status"] == "measured"
+
+
+def test_line_groups_reject_duplicates() -> None:
+    arguments = _arguments(
+        "--lines",
+        "pyamplicol-otf",
+        "pyamplicol-otf",
+    )
+    with pytest.raises(profiling.ProfilingError, match="--lines"):
+        profiling._validate_arguments(arguments)
+
+
+def test_reference_fft_root_is_explicit_in_identity_and_child_commands(
+    tmp_path: Path,
+) -> None:
+    reference_root = tmp_path / "reference-fft"
+    arguments = _arguments(
+        "--output",
+        str(tmp_path / "run"),
+        "--multiplicities",
+        "2",
+        "--lines",
+        "reference-fft",
+        "--reference-fft-root",
+        str(reference_root),
+    )
+
+    plan = profiling.dry_run_plan(arguments)
+    assert plan["identity"]["tools"]["reference_fft_root"] == str(reference_root)
+    command = plan["shards"]["gg-reference"]["argv"]
+    assert command is not None
+    option = command.index("--reference-fft-root")
+    assert command[option + 1] == str(reference_root)
+
+
+def test_status_rejects_workload_mismatch_with_existing_output(tmp_path: Path) -> None:
+    output = tmp_path / "fixed-run"
+    fixed = _arguments("--output", str(output), "--multiplicities", "2")
+    profiling._create_or_resume_manifest(fixed, output)
+    summed = _arguments(
+        "--status",
+        "--compare-helicity-sums",
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+    )
+
+    with pytest.raises(profiling.ProfilingError, match="identity differs"):
+        profiling.status_payload(summed)
+
+
+def test_refresh_is_confined_to_recognized_output(tmp_path: Path) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments("--output", str(output))
+    profiling._create_or_resume_manifest(arguments, output)
+    retained = output / "owned.txt"
+    retained.write_text("owned", encoding="ascii")
+
+    profiling._safe_refresh(output)
+
+    assert not output.exists()
+    with pytest.raises(profiling.ProfilingError, match="ambiguous"):
+        profiling._safe_refresh(Path.home())
+    unrecognized = tmp_path / "not-a-run"
+    unrecognized.mkdir()
+    with pytest.raises(profiling.ProfilingError, match="recognized"):
+        profiling._safe_refresh(unrecognized)
+
+
+def test_first_refresh_of_a_missing_output_starts_cleanly(tmp_path: Path) -> None:
+    output = tmp_path / "new-run"
+
+    assert profiling._safe_refresh(output) is False
+    assert not output.exists()
+
+
+def test_refresh_lock_survives_output_deletion(tmp_path: Path) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments("--output", str(output))
+    profiling._create_or_resume_manifest(arguments, output)
+    first = profiling._acquire_execution_lock(output)
+    try:
+        profiling._safe_refresh(output)
+        assert not output.exists()
+        with pytest.raises(profiling.ProfilingError, match="another profiling"):
+            profiling._acquire_execution_lock(output)
+    finally:
+        first.close()
+
+
+def test_refresh_rejects_an_active_madgraph_cache_writer(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments("--output", str(output))
+    profiling._create_or_resume_manifest(arguments, output)
+    retained = output / "owned.txt"
+    retained.write_text("owned", encoding="ascii")
+    monkeypatch.setattr(profiling.madgraph, "CACHE_LOCK_ROOT", tmp_path / "locks")
+
+    cache_lock = profiling.madgraph._acquire_cache_lock(
+        profiling._madgraph_cache_path(output)
+    )
+    try:
+        with pytest.raises(
+            profiling.ProfilingError,
+            match="cannot refresh while another MadGraph profiler holds",
+        ):
+            profiling._safe_refresh(output)
+    finally:
+        cache_lock.close()
+
+    assert retained.read_text(encoding="ascii") == "owned"
+
+
+def test_render_wrapper_holds_generation_lock_until_publication(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "run"
+    arguments = _arguments("--output", str(output))
+
+    class Lock:
+        closed = False
+
+        def close(self) -> None:
+            self.closed = True
+
+    lock = Lock()
+    monkeypatch.setattr(profiling, "_acquire_render_lock", lambda _output: lock)
+
+    def render_locked(*_args, **_kwargs):
+        assert lock.closed is False
+        return output / "published.pdf"
+
+    monkeypatch.setattr(profiling, "_render_snapshot_locked", render_locked)
+
+    assert profiling.render_snapshot(arguments) == output / "published.pdf"
+    assert lock.closed is True
+
+
+def test_refresh_rejects_symlinked_output(tmp_path: Path) -> None:
+    target = tmp_path / "target"
+    target.mkdir()
+    link = tmp_path / "linked-run"
+    link.symlink_to(target, target_is_directory=True)
+
+    with pytest.raises(profiling.ProfilingError, match="symlinked"):
+        profiling._safe_refresh(link)
+
+    assert target.is_dir()
+
+
+def _partial_report(output: Path, *, summed: bool = False) -> dict[str, object]:
+    values = ["--output", str(output), "--multiplicities", "2"]
+    if summed:
+        values.append("--compare-helicity-sums")
+    arguments = _arguments(*values)
+    report = study._empty_report(profiling._master_arguments(arguments, output))
+    report["status"] = "running"
+    return report
+
+
+def _write_fake_pdf_output(command: tuple[str, ...]) -> None:
+    output = Path(command[command.index("--output") + 1])
+    output.write_bytes(b"pdf")
+    output.with_suffix(".json").write_text("{}\n", encoding="utf-8")
+
+
+def test_render_forwards_recola_results_to_plotter_only(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "render-recola"
+    source = tmp_path / "live.json"
+    recola_results = tmp_path / "recola.json"
+    source.write_text(json.dumps(_partial_report(output)), encoding="utf-8")
+    recola_results.write_text("{}\n", encoding="utf-8")
+    calls: list[tuple[str, ...]] = []
+
+    def fake_run(command, **_kwargs):
+        command = tuple(command)
+        calls.append(command)
+        if Path(command[1]) == profiling.PLOT_TOOL:
+            plot_root = Path(command[3])
+            plot_root.mkdir(parents=True)
+            for family in ("gg", "ddbar"):
+                for metric in ("generation", "warm-runtime", "rss"):
+                    (plot_root / f"fullcolor-{family}-{metric}.png").write_bytes(b"png")
+        elif Path(command[1]) == profiling.PDF_TOOL:
+            _write_fake_pdf_output(command)
+
+    monkeypatch.setattr(profiling, "_run_checked", fake_run)
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+    monkeypatch.setattr(
+        profiling,
+        "_madgraph_render_source",
+        lambda *_args: pytest.fail("external report must not inherit output MG data"),
+    )
+
+    profiling.render_snapshot(
+        _arguments(
+            "--render",
+            "--output",
+            str(output),
+            "--campaign-report",
+            str(source),
+            "--recola-results",
+            str(recola_results),
+            "--main-y-range",
+            "1e-6",
+            "1e3",
+            "--ratio-y-range",
+            "0",
+            "5",
+            "--ratio-y-scale",
+            "linear",
+            "--main-include-lines",
+            "recola",
+            "madgraph",
+            "--main-veto-lines",
+            "pyamplicol-recurrence",
+            "--ratio-include-lines",
+            "recola",
+            "--ratio-veto-lines",
+            "madgraph",
+        )
+    )
+
+    plot_command, pdf_command = calls
+    assert plot_command[plot_command.index("--recola-results") + 1] == str(
+        recola_results.resolve(strict=False)
+    )
+    assert plot_command[plot_command.index("--main-y-range") + 1 :][0:2] == (
+        "1e-06",
+        "1000.0",
+    )
+    assert plot_command[plot_command.index("--ratio-y-range") + 1 :][0:2] == (
+        "0.0",
+        "5.0",
+    )
+    assert plot_command[plot_command.index("--ratio-y-scale") + 1] == "linear"
+    assert plot_command[plot_command.index("--main-include-lines") + 1 :][0:2] == (
+        "recola",
+        "madgraph",
+    )
+    assert plot_command[plot_command.index("--main-veto-lines") + 1] == (
+        "pyamplicol-recurrence"
+    )
+    assert plot_command[plot_command.index("--ratio-include-lines") + 1] == "recola"
+    assert plot_command[plot_command.index("--ratio-veto-lines") + 1] == "madgraph"
+    assert "--recola-results" not in pdf_command
+    assert "--main-y-range" not in pdf_command
+    assert "--ratio-y-range" not in pdf_command
+    assert "--ratio-y-scale" not in pdf_command
+    assert "--main-include-lines" not in pdf_command
+    assert "--main-veto-lines" not in pdf_command
+    assert "--ratio-include-lines" not in pdf_command
+    assert "--ratio-veto-lines" not in pdf_command
+
+
+def test_render_axis_options_are_validated() -> None:
+    arguments = _arguments("--render", "--main-y-range", "0", "1")
+
+    with pytest.raises(profiling.ProfilingError, match="logarithmic y-axis"):
+        profiling._validate_arguments(arguments)
+
+    arguments = _arguments(
+        "--render",
+        "--ratio-y-scale",
+        "linear",
+        "--ratio-y-range",
+        "0",
+        "2",
+    )
+
+    profiling._validate_arguments(arguments)
+
+
+def test_render_line_filters_are_render_only_and_deduplicated() -> None:
+    arguments = _arguments("--main-include-lines", "recola")
+    with pytest.raises(profiling.ProfilingError, match="valid only with --render"):
+        profiling._validate_arguments(arguments)
+
+    arguments = _arguments("--render", "--main-include-lines", "recola", "recola")
+    with pytest.raises(profiling.ProfilingError, match="duplicates"):
+        profiling._validate_arguments(arguments)
+
+
+def test_render_freezes_once_and_publishes_only_complete_set(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "render-run"
+    source = tmp_path / "live.json"
+    source.write_text(json.dumps(_partial_report(output)), encoding="utf-8")
+    original = source.read_bytes()
+    calls: list[tuple[str, ...]] = []
+
+    def fake_run(command, **_kwargs):
+        command = tuple(command)
+        calls.append(command)
+        if Path(command[1]) == profiling.PLOT_TOOL:
+            plot_root = Path(command[3])
+            plot_root.mkdir(parents=True)
+            for family in ("gg", "ddbar"):
+                for metric in ("generation", "warm-runtime", "rss"):
+                    (plot_root / f"fullcolor-{family}-{metric}.png").write_bytes(b"png")
+        elif Path(command[1]) == profiling.PDF_TOOL:
+            _write_fake_pdf_output(command)
+
+    monkeypatch.setattr(profiling, "_run_checked", fake_run)
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+    monkeypatch.setattr(
+        profiling,
+        "_madgraph_render_source",
+        lambda *_args: pytest.fail("external report must not inherit output MG data"),
+    )
+    arguments = _arguments(
+        "--render",
+        "--output",
+        str(output),
+        "--campaign-report",
+        str(source),
+    )
+
+    pdf = profiling.render_snapshot(arguments)
+
+    assert source.read_bytes() == original
+    assert pdf.read_bytes() == b"pdf"
+    assert not profiling._canonical_pdf_path(arguments).exists()
+    assert (output / "render" / "current").is_symlink()
+    assert [Path(command[1]) for command in calls] == [
+        profiling.PLOT_TOOL,
+        profiling.PDF_TOOL,
+    ]
+    assert calls[0][2] == calls[1][calls[1].index("--campaign-report") + 1]
+
+
+def test_run_checked_suppresses_success_stdout(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    profiling._run_checked(
+        (
+            sys.executable,
+            "-c",
+            "print('generated/path.png')",
+        )
+    )
+
+    assert capsys.readouterr().out == ""
+
+
+def test_default_campaign_render_atomically_publishes_canonical_pdf(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "default-run"
+    monkeypatch.setattr(profiling, "DEFAULT_FIXED_OUTPUT", output)
+    source = profiling._master_report_path(output)
+    source.parent.mkdir(parents=True)
+    source.write_text(json.dumps(_partial_report(output)), encoding="utf-8")
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+
+    def fake_run(command, **_kwargs):
+        command = tuple(command)
+        if Path(command[1]) == profiling.PLOT_TOOL:
+            plot_root = Path(command[3])
+            plot_root.mkdir(parents=True)
+            for family in ("gg", "ddbar"):
+                for metric in ("generation", "warm-runtime", "rss"):
+                    (plot_root / f"fullcolor-{family}-{metric}.png").write_bytes(b"png")
+        else:
+            _write_fake_pdf_output(command)
+
+    monkeypatch.setattr(profiling, "_run_checked", fake_run)
+    arguments = _arguments("--render")
+
+    profiling.render_snapshot(arguments)
+
+    assert profiling._canonical_pdf_path(arguments).read_bytes() == b"pdf"
+    assert profiling._canonical_pdf_path(arguments).with_suffix(".json").is_file()
+
+
+def test_bare_render_falls_back_to_richest_compatible_existing_report(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "missing-default-run"
+    monkeypatch.setattr(profiling, "DEFAULT_FIXED_OUTPUT", output)
+    report_root = (
+        profiling.CANONICAL_RESULTS_ROOT / "fft-scaling-study" / "raw" / "runs"
+    )
+    sparse = report_root / "sparse" / "report.json"
+    richer = report_root / "richer" / "report.json"
+    summed = report_root / "summed" / "report.json"
+    for path, report in (
+        (sparse, _partial_report(output)),
+        (richer, _partial_report(output)),
+        (summed, _partial_report(output, summed=True)),
+    ):
+        path.parent.mkdir(parents=True)
+        path.write_text(json.dumps(report), encoding="utf-8")
+    richer_payload = json.loads(richer.read_text(encoding="utf-8"))
+    richer_payload["cells"]["gg"]["reference-fft"]["2"] = {
+        "status": "measured",
+        "generation_seconds": 1.0,
+        "warm_seconds_per_point": 1.0e-6,
+        "max_rss_kib": 1024,
+    }
+    richer.write_text(json.dumps(richer_payload), encoding="utf-8")
+
+    arguments = _arguments("--render")
+
+    assert profiling._render_source(arguments, output) == richer.resolve()
+
+
+def test_bare_render_compares_existing_primary_with_isolated_composite(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "default-run"
+    monkeypatch.setattr(profiling, "DEFAULT_FIXED_OUTPUT", output)
+    primary = profiling._master_report_path(output)
+    primary.parent.mkdir(parents=True)
+    primary.write_text(json.dumps(_partial_report(output)), encoding="utf-8")
+    composite = (
+        profiling.CANONICAL_RESULTS_ROOT
+        / "fft-profiling"
+        / "runs"
+        / "extension"
+        / "composites"
+        / "selected"
+        / "report.json"
+    )
+    richer = _partial_report(output)
+    richer["cells"]["ddbar"]["recurrence-direct"]["2"] = {
+        "status": "measured",
+        "generation_seconds": 1.0,
+        "warm_seconds_per_point": 1.0e-6,
+        "max_rss_kib": 1024,
+    }
+    composite.parent.mkdir(parents=True)
+    composite.write_text(json.dumps(richer), encoding="utf-8")
+    rendered_cell: dict[str, object] = {}
+
+    def fake_run(command, **_kwargs):
+        command = tuple(command)
+        if Path(command[1]) == profiling.PLOT_TOOL:
+            frozen = json.loads(Path(command[2]).read_text(encoding="utf-8"))
+            rendered_cell.update(frozen["cells"]["ddbar"]["recurrence-direct"]["2"])
+            plot_root = Path(command[3])
+            plot_root.mkdir(parents=True)
+            for family in ("gg", "ddbar"):
+                for metric in ("generation", "warm-runtime", "rss"):
+                    (plot_root / f"fullcolor-{family}-{metric}.png").write_bytes(b"png")
+        else:
+            _write_fake_pdf_output(command)
+
+    monkeypatch.setattr(profiling, "_run_checked", fake_run)
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+    arguments = _arguments("--render")
+
+    assert profiling._render_source(arguments, output) == composite.resolve()
+    profiling.render_snapshot(arguments)
+
+    assert rendered_cell["status"] == "measured"
+    assert profiling._canonical_pdf_path(arguments).read_bytes() == b"pdf"
+
+
+def test_implicit_render_selects_only_workload_compatible_global_overlay(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "summed-default"
+    monkeypatch.setattr(profiling, "DEFAULT_SUM_OUTPUT", output)
+    primary = profiling._master_report_path(output)
+    report = _partial_report(output, summed=True)
+    report["runtime_series"] = {}
+    primary.parent.mkdir(parents=True)
+    primary.write_text(json.dumps(report), encoding="utf-8")
+    fixed_overlay = (
+        profiling.CANONICAL_RESULTS_ROOT
+        / "fft-scaling-study"
+        / "data"
+        / "selected-scalar-madgraph-runtime-series-overlay.json"
+    )
+    summed_overlay = (
+        profiling.CANONICAL_RESULTS_ROOT
+        / "fft-profiling"
+        / "runs"
+        / "summed-extension"
+        / "madgraph"
+        / "overlay.json"
+    )
+    for path in (fixed_overlay, summed_overlay):
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps({"kind": profiling.madgraph.KIND}), encoding="utf-8")
+
+    def attach(report_payload: dict[str, object], path: Path) -> None:
+        if path == fixed_overlay.resolve():
+            raise profiling.ProfilingError("fixed-helicity overlay")
+        assert path == summed_overlay.resolve()
+        report_payload["runtime_series"] = {
+            "gg": {
+                "madgraph-standalone": {
+                    "2": {
+                        "status": "measured",
+                        "warm_seconds_per_point": 1.0e-6,
+                    }
+                }
+            }
+        }
+
+    monkeypatch.setattr(profiling, "_attach_partial_overlay", attach)
+    arguments = _arguments("--render", "--compare-helicity-sums")
+
+    selection = profiling._implicit_render_selection(arguments, output)
+
+    assert selection == profiling.RenderSelection(
+        source=primary,
+        overlay=summed_overlay.resolve(),
+    )
+
+
+def test_summed_bare_render_preserves_n6_extension_and_n2_n5_madgraph(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "summed-default"
+    monkeypatch.setattr(profiling, "DEFAULT_SUM_OUTPUT", output)
+    primary = profiling._master_report_path(output)
+    base = _partial_report(output, summed=True)
+    for family in ("gg", "ddbar"):
+        for final_multiplicity in range(2, 6):
+            base["cells"][family]["recurrence-direct"][str(final_multiplicity)] = {
+                "status": "measured",
+                "warm_seconds_per_point": 1.0e-6,
+            }
+    primary.parent.mkdir(parents=True)
+    primary.write_text(json.dumps(base), encoding="utf-8")
+    composite = (
+        profiling.CANONICAL_RESULTS_ROOT
+        / "fft-profiling"
+        / "runs"
+        / "summed-ddbar-n6"
+        / "composites"
+        / "selected"
+        / "report.json"
+    )
+    extended = json.loads(json.dumps(base))
+    extended["cells"]["ddbar"]["recurrence-direct"]["6"] = {
+        "status": "measured",
+        "warm_seconds_per_point": 2.0e-6,
+    }
+    composite.parent.mkdir(parents=True)
+    composite.write_text(json.dumps(extended), encoding="utf-8")
+    overlay = (
+        profiling.CANONICAL_RESULTS_ROOT
+        / "fft-profiling"
+        / "runs"
+        / "summed-madgraph-n2-n5"
+        / "madgraph"
+        / "overlay.json"
+    )
+    overlay.parent.mkdir(parents=True)
+    overlay.write_text(json.dumps({"kind": profiling.madgraph.KIND}), encoding="utf-8")
+
+    def attach(report_payload: dict[str, object], path: Path) -> None:
+        assert path == overlay.resolve()
+        report_payload["runtime_series"] = {
+            family: {
+                "madgraph-standalone": {
+                    str(final_multiplicity): {
+                        "status": "measured",
+                        "warm_seconds_per_point": 3.0e-6,
+                    }
+                    for final_multiplicity in range(2, 6)
+                }
+            }
+            for family in ("gg", "ddbar")
+        }
+
+    rendered: dict[str, object] = {}
+
+    def fake_run(command, **_kwargs):
+        command = tuple(command)
+        if Path(command[1]) == profiling.PLOT_TOOL:
+            rendered.update(json.loads(Path(command[2]).read_text(encoding="utf-8")))
+            plot_root = Path(command[3])
+            plot_root.mkdir(parents=True)
+            for family in ("gg", "ddbar"):
+                for metric in ("generation", "warm-runtime", "rss"):
+                    (plot_root / f"fullcolor-{family}-{metric}.png").write_bytes(b"png")
+        else:
+            _write_fake_pdf_output(command)
+
+    monkeypatch.setattr(profiling, "_attach_partial_overlay", attach)
+    monkeypatch.setattr(profiling, "_run_checked", fake_run)
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+    arguments = _arguments("--render", "--compare-helicity-sums")
+
+    assert profiling._implicit_render_selection(
+        arguments, output
+    ) == profiling.RenderSelection(
+        source=composite.resolve(),
+        overlay=overlay.resolve(),
+    )
+    profiling.render_snapshot(arguments)
+
+    assert rendered["cells"]["ddbar"]["recurrence-direct"]["6"]["status"] == (
+        "measured"
+    )
+    assert set(rendered["runtime_series"]["gg"]["madgraph-standalone"]) == {
+        "2",
+        "3",
+        "4",
+        "5",
+    }
+    assert profiling._canonical_pdf_path(arguments).read_bytes() == b"pdf"
+
+
+def test_fixed_bare_render_combines_otf_frontier_with_valid_madgraph_overlay(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "fixed-default"
+    monkeypatch.setattr(profiling, "DEFAULT_FIXED_OUTPUT", output)
+    composite_report = _partial_report(output)
+    for family, modes in profiling.publication.FAMILY_MODES.items():
+        for mode in modes:
+            for final_multiplicity in range(2, 8):
+                if (family, mode, final_multiplicity) == ("gg", "otf-fft", 7):
+                    continue
+                composite_report["cells"][family][mode][str(final_multiplicity)] = {
+                    "status": "measured",
+                    "warm_seconds_per_point": 1.0e-6,
+                }
+    primary_report = json.loads(json.dumps(composite_report))
+    for mode in ("otf-direct", "otf-fft"):
+        for final_multiplicity in (6, 7):
+            del primary_report["cells"]["ddbar"][mode][str(final_multiplicity)]
+
+    def runtime_series(*, protocol_scoped: bool) -> dict[str, object]:
+        series: dict[str, object] = {}
+        for family in ("gg", "ddbar"):
+            measured_max = 5 if family == "gg" else 6
+            cells: dict[str, object] = {}
+            for final_multiplicity in range(2, 10):
+                if final_multiplicity <= measured_max:
+                    status = "measured"
+                elif protocol_scoped and final_multiplicity > 6:
+                    status = "not-applicable"
+                elif final_multiplicity == measured_max + 1:
+                    status = "failed"
+                else:
+                    status = "skipped"
+                cells[str(final_multiplicity)] = {"status": status}
+            series[family] = {"madgraph-standalone": cells}
+        return series
+
+    primary_report["runtime_series"] = runtime_series(protocol_scoped=False)
+    primary = profiling._master_report_path(output)
+    primary.parent.mkdir(parents=True)
+    primary.write_text(json.dumps(primary_report), encoding="utf-8")
+    composite = (
+        profiling.CANONICAL_RESULTS_ROOT
+        / "fft-profiling"
+        / "runs"
+        / "fixed-otf-extension"
+        / "composites"
+        / "selected"
+        / "report.json"
+    )
+    composite.parent.mkdir(parents=True)
+    composite.write_text(json.dumps(composite_report), encoding="utf-8")
+    overlay_series = runtime_series(protocol_scoped=True)
+    overlay = (
+        profiling.CANONICAL_RESULTS_ROOT
+        / "fft-scaling-study"
+        / "data"
+        / "selected-fixed-madgraph-overlay.json"
+    )
+    overlay.parent.mkdir(parents=True)
+    overlay.write_text(
+        json.dumps(
+            {
+                "kind": profiling.madgraph.KIND,
+                "policy": {
+                    "final_state_multiplicities": list(range(2, 10)),
+                    "helicity_workload": "fixed",
+                    "warm_fixed_helicity": True,
+                    "warm_helicity_sum": False,
+                    "maximum_measured_multiplicity": 6,
+                    "family_maximum_measured_multiplicity": {
+                        "gg": 5,
+                        "ddbar": 6,
+                    },
+                    "higher_multiplicity_policy": ("not-applicable-protocol-scope"),
+                },
+                "runtime_series": overlay_series,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    def attach(report_payload: dict[str, object], path: Path) -> None:
+        assert path == overlay.resolve()
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        assert payload["policy"]["helicity_workload"] == "fixed"
+        for family_cells in payload["runtime_series"].values():
+            mode_cells = family_cells["madgraph-standalone"]
+            assert {
+                mode_cells[str(final_multiplicity)]["status"]
+                for final_multiplicity in range(7, 10)
+            } == {"not-applicable"}
+        report_payload["runtime_series"] = json.loads(
+            json.dumps(payload["runtime_series"])
+        )
+
+    rendered: dict[str, object] = {}
+
+    def fake_run(command, **_kwargs):
+        command = tuple(command)
+        if Path(command[1]) == profiling.PLOT_TOOL:
+            rendered.update(json.loads(Path(command[2]).read_text(encoding="utf-8")))
+            plot_root = Path(command[3])
+            plot_root.mkdir(parents=True)
+            for family in ("gg", "ddbar"):
+                for metric in ("generation", "warm-runtime", "rss"):
+                    (plot_root / f"fullcolor-{family}-{metric}.png").write_bytes(b"png")
+        else:
+            _write_fake_pdf_output(command)
+
+    monkeypatch.setattr(profiling, "_attach_partial_overlay", attach)
+    monkeypatch.setattr(profiling, "_run_checked", fake_run)
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+    arguments = _arguments("--render")
+    requested = set(profiling._selection(arguments))
+
+    assert profiling._render_inventory(primary_report, requested=requested)[0] == 70
+    assert profiling._render_inventory(composite_report, requested=requested)[0] == 65
+    assert profiling._implicit_render_selection(
+        arguments, output
+    ) == profiling.RenderSelection(
+        source=composite.resolve(),
+        overlay=overlay.resolve(),
+    )
+    profiling.render_snapshot(arguments)
+
+    for mode in ("otf-direct", "otf-fft"):
+        assert rendered["cells"]["ddbar"][mode]["6"]["status"] == "measured"
+    measured_madgraph = {
+        (family, int(final_multiplicity))
+        for family, family_cells in rendered["runtime_series"].items()
+        for final_multiplicity, cell in family_cells["madgraph-standalone"].items()
+        if cell["status"] == "measured"
+    }
+    expected_madgraph = {
+        ("gg", final_multiplicity) for final_multiplicity in range(2, 6)
+    } | {("ddbar", final_multiplicity) for final_multiplicity in range(2, 7)}
+    assert measured_madgraph == expected_madgraph
+    assert profiling._canonical_pdf_path(arguments).read_bytes() == b"pdf"
+
+
+def test_explicit_existing_output_ignores_richer_implicit_fallback(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "explicit"
+    primary = profiling._master_report_path(output)
+    primary.parent.mkdir(parents=True)
+    primary.write_text(json.dumps(_partial_report(output)), encoding="utf-8")
+    fallback = (
+        profiling.CANONICAL_RESULTS_ROOT
+        / "fft-profiling"
+        / "runs"
+        / "extension"
+        / "composites"
+        / "selected"
+        / "report.json"
+    )
+    richer = _partial_report(output)
+    richer["cells"]["gg"]["reference-fft"]["2"] = {"status": "measured"}
+    fallback.parent.mkdir(parents=True)
+    fallback.write_text(json.dumps(richer), encoding="utf-8")
+    arguments = _arguments("--render", "--output", str(output))
+
+    assert profiling._render_source(arguments, output) == primary
+
+
+def test_explicit_output_does_not_use_implicit_render_fallback(
+    tmp_path: Path,
+) -> None:
+    fallback = (
+        profiling.CANONICAL_RESULTS_ROOT
+        / "fft-scaling-study"
+        / "data"
+        / "campaign-report-existing.json"
+    )
+    fallback.parent.mkdir(parents=True)
+    fallback.write_text(
+        json.dumps(_partial_report(tmp_path / "unrelated")), encoding="utf-8"
+    )
+    output = tmp_path / "explicit-missing"
+    arguments = _arguments("--render", "--output", str(output))
+
+    with pytest.raises(profiling.ProfilingError, match="no campaign snapshot yet"):
+        profiling.render_snapshot(arguments)
+
+    assert not output.exists()
+
+
+def test_missing_render_snapshot_fails_without_waiting_or_writing(
+    tmp_path: Path,
+) -> None:
+    output = tmp_path / "missing"
+    arguments = _arguments("--render", "--output", str(output))
+    with pytest.raises(profiling.ProfilingError, match="no campaign snapshot yet"):
+        profiling.render_snapshot(arguments)
+    assert not output.exists()
+
+
+@pytest.mark.parametrize(
+    ("report_summed", "argument_summed"), ((False, True), (True, False))
+)
+def test_render_rejects_report_workload_filename_mismatch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    report_summed: bool,
+    argument_summed: bool,
+) -> None:
+    output = tmp_path / "mismatch"
+    source = tmp_path / "report.json"
+    source.write_text(
+        json.dumps(_partial_report(output, summed=report_summed)), encoding="utf-8"
+    )
+    values = ["--render", "--output", str(output), "--campaign-report", str(source)]
+    if argument_summed:
+        values.append("--compare-helicity-sums")
+    arguments = _arguments(*values)
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+    monkeypatch.setattr(
+        profiling,
+        "_run_checked",
+        lambda *_args, **_kwargs: pytest.fail("mismatched workload must not render"),
+    )
+
+    with pytest.raises(profiling.ProfilingError, match="helicity workload"):
+        profiling.render_snapshot(arguments)
+
+    assert not profiling._canonical_pdf_path(arguments).exists()
+
+
+def test_workload_validation_does_not_import_matplotlib_plotter(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    report = _partial_report(tmp_path / "fixed")
+    real_import = builtins.__import__
+
+    def guarded_import(name, *args, **kwargs):
+        if name.endswith("fft_scaling_study_plots"):
+            raise AssertionError("workload validation imported the renderer")
+        return real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", guarded_import)
+
+    profiling._validate_render_workload(_arguments(), report)
+
+
+def test_render_prefers_matching_running_madgraph_progress(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "render-progress"
+    source = profiling._master_report_path(output)
+    source.parent.mkdir(parents=True)
+    source.write_text(json.dumps(_partial_report(output)), encoding="utf-8")
+    progress_path = profiling._madgraph_progress_path(output)
+    progress_path.parent.mkdir(parents=True)
+    progress_path.write_text("{}", encoding="ascii")
+    attached: list[Path] = []
+
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+    monkeypatch.setattr(
+        profiling,
+        "_matching_madgraph_progress",
+        lambda _arguments, _output: {"status": "running"},
+    )
+    monkeypatch.setattr(
+        profiling,
+        "_attach_partial_overlay",
+        lambda _report, path: attached.append(path),
+    )
+
+    def fake_run(command, **_kwargs):
+        command = tuple(command)
+        if Path(command[1]) == profiling.PLOT_TOOL:
+            plot_root = Path(command[3])
+            plot_root.mkdir(parents=True)
+            for family in ("gg", "ddbar"):
+                for metric in ("generation", "warm-runtime", "rss"):
+                    (plot_root / f"fullcolor-{family}-{metric}.png").write_bytes(b"png")
+        else:
+            _write_fake_pdf_output(command)
+
+    monkeypatch.setattr(profiling, "_run_checked", fake_run)
+    arguments = _arguments("--render", "--output", str(output))
+
+    profiling.render_snapshot(arguments)
+
+    assert attached == [progress_path]
+
+
+def test_renderer_preflight_has_actionable_direct_requirements(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(profiling, "_command_available", lambda _command: True)
+    monkeypatch.setattr(
+        profiling.subprocess,
+        "run",
+        lambda *_args, **_kwargs: type("Result", (), {"returncode": 1})(),
+    )
+    with pytest.raises(profiling.ProfilingError) as raised:
+        profiling._preflight_renderer(_arguments())
+    message = str(raised.value)
+    assert "pip install" in message
+    assert "-e" not in message
+    for requirement in profiling.RENDER_REQUIREMENTS:
+        assert requirement in message
+
+
+def test_renderer_requirements_match_the_project_extra() -> None:
+    with (ROOT / "pyproject.toml").open("rb") as stream:
+        project = tomllib.load(stream)
+
+    assert (
+        tuple(project["project"]["optional-dependencies"]["fft-profiling"])
+        == profiling.RENDER_REQUIREMENTS
+    )
+
+
+def test_renderer_preflight_rejects_selected_python_version_mismatch(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(profiling, "_command_available", lambda _command: True)
+    monkeypatch.setattr(
+        profiling.subprocess,
+        "run",
+        lambda *_args, **_kwargs: type(
+            "Result", (), {"returncode": 0, "stdout": "0.0-incompatible\n"}
+        )(),
+    )
+
+    with pytest.raises(profiling.ProfilingError, match="profiling driver uses"):
+        profiling._preflight_renderer(_arguments())
+
+
+def _available_preflight_status(tmp_path: Path) -> dict[str, object]:
+    return {
+        "python": {"available": True, "path": sys.executable},
+        "cxx": {"available": True, "path": "c++"},
+        "fortran": {"available": True, "path": "gfortran"},
+        "amplicol_root": {
+            "compatible": True,
+            "path": str(tmp_path / "amplicol"),
+            "probe_available": True,
+            "probe": str(tmp_path / "amplicol" / "amplicol_color_probe"),
+        },
+        "reference_fft_root": {
+            "compatible": True,
+            "path": str(tmp_path / "reference-fft"),
+        },
+        "madgraph_root": {
+            "compatible": True,
+            "path": str(tmp_path / "mg5"),
+        },
+    }
+
+
+def test_preflight_skips_pyamplicol_runtime_for_reference_only(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    arguments = _arguments(
+        "--output",
+        str(tmp_path / "run"),
+        "--lines",
+        "reference-fft",
+    )
+    monkeypatch.setattr(
+        profiling,
+        "_dependency_status",
+        lambda _arguments: _available_preflight_status(tmp_path),
+    )
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+    monkeypatch.setattr(
+        profiling,
+        "_preflight_pyamplicol_runtime",
+        lambda _arguments: pytest.fail(
+            "reference-only scan should not import pyAmpliCol"
+        ),
+    )
+
+    profiling._preflight(arguments)
+
+
+def test_preflight_checks_pyamplicol_runtime_for_ddbar_work(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    arguments = _arguments(
+        "--output",
+        str(tmp_path / "run"),
+        "--lines",
+        "amplicol",
+    )
+    calls: list[argparse.Namespace] = []
+    monkeypatch.setattr(
+        profiling,
+        "_dependency_status",
+        lambda _arguments: _available_preflight_status(tmp_path),
+    )
+    monkeypatch.setattr(profiling, "_preflight_renderer", lambda _arguments: None)
+    monkeypatch.setattr(
+        profiling,
+        "_preflight_pyamplicol_runtime",
+        lambda runtime_arguments: calls.append(runtime_arguments),
+    )
+
+    profiling._preflight(arguments)
+
+    assert calls == [arguments]
+
+
+def test_pyamplicol_preflight_uses_checkout_source_path(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYTHONPATH", "/already/configured")
+    arguments = _arguments()
+
+    environment = profiling._python_source_environment(arguments)
+
+    assert environment["PYTHONPATH"].split(os.pathsep)[:2] == [
+        str(ROOT / "src"),
+        "/already/configured",
+    ]
+
+
+def test_pyamplicol_preflight_reports_import_failure(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured_environment: dict[str, str] = {}
+
+    def fake_run(*_args, **kwargs):
+        captured_environment.update(kwargs["env"])
+        return type(
+            "Result",
+            (),
+            {
+                "returncode": 1,
+                "stdout": "",
+                "stderr": "candidate wheel source checkout is unavailable",
+            },
+        )()
+
+    monkeypatch.setattr(profiling.subprocess, "run", fake_run)
+
+    with pytest.raises(profiling.ProfilingError) as raised:
+        profiling._preflight_pyamplicol_runtime(_arguments())
+
+    message = str(raised.value)
+    assert "just dev-install" in message
+    assert "candidate wheel source checkout is unavailable" in message
+    assert captured_environment["PYTHONPATH"].split(os.pathsep)[0] == str(ROOT / "src")
+
+
+def test_executable_normalization_preserves_virtualenv_symlink(
+    tmp_path: Path,
+) -> None:
+    launcher = tmp_path / "venv" / "bin" / "python"
+    launcher.parent.mkdir(parents=True)
+    launcher.symlink_to(Path(sys.executable))
+    arguments = _arguments("--python", str(launcher))
+
+    profiling._normalize_executables(arguments)
+
+    assert arguments.python == str(launcher.absolute())
+
+
+def test_progress_attachment_validates_one_immutable_read(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    live = tmp_path / "progress.json"
+    current = profiling.madgraph.measurement_host_identity()
+    payload = {
+        "kind": profiling.madgraph.PROGRESS_KIND,
+        "host": {key: current[key] for key in ("system", "machine", "python")},
+    }
+    raw = json.dumps(payload).encode("utf-8")
+    live.write_bytes(raw)
+    validated_paths: list[Path] = []
+    attached: list[profiling.selected.SourceReport] = []
+
+    def validate(path: Path):
+        validated_paths.append(path)
+        assert path != live
+        assert path.read_bytes() == raw
+        return payload
+
+    monkeypatch.setattr(profiling.madgraph, "load_runtime_progress", validate)
+    monkeypatch.setattr(
+        profiling.selected,
+        "apply_runtime_series_source",
+        lambda _report, source: attached.append(source),
+    )
+
+    profiling._attach_partial_overlay({}, live)
+
+    assert len(validated_paths) == 1
+    assert attached[0].path == live
+    assert attached[0].sha256 == profiling.hashlib.sha256(raw).hexdigest()
+
+
+def test_summed_overlay_replaces_stale_madgraph_omission_note(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    overlay = tmp_path / "summed-overlay.json"
+    current = profiling.madgraph.measurement_host_identity()
+    overlay.write_text(
+        json.dumps(
+            {
+                "kind": profiling.madgraph.KIND,
+                "host": {key: current[key] for key in ("system", "machine", "python")},
+                "policy": {
+                    "helicity_workload": "sum",
+                    "warm_fixed_helicity": False,
+                    "warm_helicity_sum": True,
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+    report = {
+        "policy": {
+            "plot": {
+                "notes": [
+                    "Complete helicity sum; MadGraph is omitted because its "
+                    "available series is fixed-helicity."
+                ]
+            }
+        }
+    }
+    monkeypatch.setattr(
+        profiling.selected, "apply_runtime_series_source", lambda *_args: None
+    )
+
+    profiling._attach_partial_overlay(report, overlay)
+
+    notes = report["policy"]["plot"]["notes"]
+    assert all("omitted" not in note.lower() for note in notes)
+    assert notes == [
+        profiling.LEGACY_MADGRAPH_NOTE,
+        "MadGraph standalone uses generated SMATRIX with USERHEL=-1; warmed "
+        "GOODHEL pruning remains enabled.",
+    ]
+
+
+def test_madgraph_source_freeze_depends_only_on_source_cells(tmp_path: Path) -> None:
+    output = tmp_path / "mg-source"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--lines",
+        "madgraph",
+    )
+    gg_source = study._cell_base("gg", study.MODE_BY_KEY["reference-fft"], 2) | {
+        "status": "measured"
+    }
+    ddbar_source = study._cell_base(
+        "ddbar", study.MODE_BY_KEY["recurrence-fft"], 2
+    ) | {"status": "measured"}
+    unrelated = study._cell_base("gg", study.MODE_BY_KEY["otf-direct"], 2) | {
+        "status": "measured",
+        "generation_seconds": 1.0,
+    }
+    cells = {
+        "gg": {
+            "reference-fft": {"2": gg_source},
+            "otf-direct": {"2": unrelated},
+        },
+        "ddbar": {"recurrence-fft": {"2": ddbar_source}},
+    }
+    master = study.compose_report(
+        profiling._master_arguments(arguments, output),
+        cells,
+    )
+    master["measurement_host"] = profiling.madgraph.measurement_host_identity()
+    profiling._write_json_atomic(profiling._master_report_path(output), master)
+
+    path = profiling._freeze_madgraph_source(arguments, output)
+    frozen = json.loads(path.read_text(encoding="utf-8"))
+
+    assert frozen["kind"] == profiling.madgraph.SOURCE_KIND
+    assert set(frozen["cells"]["gg"]) == {"reference-fft"}
+    assert set(frozen["cells"]["ddbar"]) == {"recurrence-fft"}
+
+    master["cells"]["gg"]["otf-direct"]["2"]["generation_seconds"] = 2.0
+    profiling._write_json_atomic(profiling._master_report_path(output), master)
+
+    assert profiling._freeze_madgraph_source(arguments, output) == path
+
+
+def test_helicity_sum_n2_n3_campaign_runs_summed_madgraph_and_renders_sum_pdf(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "sum-run"
+    arguments = _arguments(
+        "--compare-helicity-sums",
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "3",
+    )
+    report = {"status": "running", "cells": {}}
+    phases: list[int] = []
+    steps: list[str] = []
+
+    class FakeDashboard:
+        def __init__(self, **_kwargs) -> None:
+            pass
+
+        def update(self, *_args, **_kwargs) -> None:
+            pass
+
+        def finish(self) -> None:
+            pass
+
+    monkeypatch.setattr(profiling, "Dashboard", FakeDashboard)
+    monkeypatch.setattr(profiling, "_preflight", lambda _arguments: None)
+    monkeypatch.setattr(
+        profiling,
+        "_publish_master",
+        lambda *_args, **_kwargs: report,
+    )
+    def fake_phase(_arguments, _output, phase, _dashboard, **_kwargs):
+        phases.append(phase)
+        steps.append(f"phase-{phase}")
+
+    monkeypatch.setattr(profiling, "_phase", fake_phase)
+    monkeypatch.setattr(profiling, "_completed_cells", lambda _report: 0)
+    monkeypatch.setattr(
+        profiling, "_selected_pending_cells", lambda *_args, **_kwargs: 0
+    )
+    monkeypatch.setattr(
+        profiling, "_selected_master_complete", lambda *_args, **_kwargs: True
+    )
+    monkeypatch.setattr(profiling, "_madgraph_source_ready", lambda *_args: True)
+    madgraph_steps: list[str] = []
+
+    def fake_start_madgraph(*_args):
+        steps.append("madgraph-start")
+        madgraph_steps.append("start")
+        return None
+
+    monkeypatch.setattr(
+        profiling,
+        "_start_madgraph_overlay",
+        fake_start_madgraph,
+    )
+    monkeypatch.setattr(
+        profiling,
+        "_run_madgraph",
+        lambda *_args: pytest.fail("MadGraph should not block the campaign"),
+    )
+    expected = output / "render" / "current" / "summary_plots_final_helicity_sum.pdf"
+    render_calls: list[bool] = []
+
+    def fake_render(_arguments, *, renderer_preflight=True):
+        render_calls.append(renderer_preflight)
+        return expected
+
+    monkeypatch.setattr(profiling, "render_snapshot", fake_render)
+
+    result = profiling.run_campaign(arguments)
+
+    assert result == expected
+    assert phases == [1, 2]
+    assert steps == ["phase-1", "madgraph-start", "phase-2"]
+    assert madgraph_steps == ["start"]
+    assert render_calls == [False, False, False]
+    manifest = json.loads((output / "manifest.json").read_text(encoding="utf-8"))
+    assert manifest["identity"]["scan"]["helicity_workload"] == "sum"
+
+
+def test_campaign_without_madgraph_line_group_skips_madgraph_phase(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "reference-only"
+    arguments = _arguments(
+        "--output",
+        str(output),
+        "--multiplicities",
+        "2",
+        "--lines",
+        "reference-fft",
+    )
+    report = {"status": "running", "cells": {}}
+    monkeypatch.setattr(profiling, "_preflight", lambda _arguments: None)
+    monkeypatch.setattr(
+        profiling,
+        "_publish_master",
+        lambda *_args, **_kwargs: report,
+    )
+    monkeypatch.setattr(profiling, "_phase", lambda *_args, **_kwargs: None)
+    monkeypatch.setattr(profiling, "_completed_cells", lambda _report: 0)
+    monkeypatch.setattr(
+        profiling, "_selected_pending_cells", lambda *_args, **_kwargs: 0
+    )
+    monkeypatch.setattr(
+        profiling, "_selected_master_complete", lambda *_args, **_kwargs: True
+    )
+    monkeypatch.setattr(
+        profiling,
+        "_freeze_madgraph_source",
+        lambda *_args: pytest.fail("MadGraph source should not be frozen"),
+    )
+    monkeypatch.setattr(
+        profiling,
+        "_run_madgraph",
+        lambda *_args: pytest.fail("MadGraph should not run"),
+    )
+    expected = output / "render" / "current" / "summary_plots_final.pdf"
+    monkeypatch.setattr(
+        profiling,
+        "render_snapshot",
+        lambda *_args, **_kwargs: expected,
+    )
+
+    assert profiling.run_campaign(arguments) == expected
+
+
+def test_partial_render_can_reuse_ordered_subset_madgraph_overlay(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "expanded"
+    overlay = profiling._madgraph_overlay_path(output)
+    overlay.parent.mkdir(parents=True)
+    overlay.write_text(
+        json.dumps(
+            {
+                "host": profiling.madgraph.measurement_host_identity(),
+                "policy": {
+                    "final_state_multiplicities": [2, 3],
+                    "maximum_measured_multiplicity": 6,
+                    "family_maximum_measured_multiplicity": {
+                        "gg": 5,
+                        "ddbar": 6,
+                    },
+                    "higher_multiplicity_policy": ("not-applicable-protocol-scope"),
+                },
+                "runtime_series": {},
+            }
+        ),
+        encoding="utf-8",
+    )
+    arguments = _arguments("--output", str(output), "--multiplicities", "4")
+    monkeypatch.setattr(
+        profiling,
+        "_requested_multiplicities",
+        lambda _arguments, _output: (2, 3, 4),
+    )
+
+    assert profiling._matching_madgraph_overlay(arguments, output) is None
+    assert (
+        profiling._matching_madgraph_overlay(arguments, output, require_exact=False)
+        == overlay
+    )
+    assert profiling._madgraph_render_source(arguments, output) == overlay
+
+    legacy_payload = json.loads(overlay.read_text(encoding="utf-8"))
+    current = profiling.madgraph.measurement_host_identity()
+    legacy_payload["host"] = {
+        key: current[key] for key in ("system", "machine", "python")
+    }
+    overlay.write_text(json.dumps(legacy_payload), encoding="utf-8")
+    assert profiling._matching_madgraph_overlay(arguments, output) is None
+    assert (
+        profiling._matching_madgraph_overlay(arguments, output, require_exact=False)
+        == overlay
+    )
+    assert profiling._madgraph_render_source(arguments, output) == overlay
+
+    legacy_payload["host"]["machine"] = "foreign-machine"
+    overlay.write_text(json.dumps(legacy_payload), encoding="utf-8")
+    assert (
+        profiling._matching_madgraph_overlay(arguments, output, require_exact=False)
+        is None
+    )
+
+    legacy_payload["host"] = {
+        key: current[key] for key in ("system", "machine", "python")
+    } | {"node_sha256": "malformed-modern-fingerprint"}
+    overlay.write_text(json.dumps(legacy_payload), encoding="utf-8")
+    assert (
+        profiling._matching_madgraph_overlay(arguments, output, require_exact=False)
+        is None
+    )
+
+
+def test_partial_render_can_reuse_ordered_subset_madgraph_progress(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    output = tmp_path / "expanded-progress"
+    progress = profiling._madgraph_progress_path(output)
+    progress.parent.mkdir(parents=True)
+    progress.write_text("{}", encoding="utf-8")
+    payload = {
+        "status": "running",
+        "host": profiling.madgraph.measurement_host_identity(),
+        "policy": {
+            "final_state_multiplicities": [2, 3, 4, 5, 6],
+            "helicity_workload": "fixed",
+            "selected_process_families": ["gg", "ddbar"],
+            "family_maximum_measured_multiplicity": {
+                "gg": 5,
+                "ddbar": 6,
+            },
+        },
+        "runtime_series": {},
+    }
+    arguments = _arguments("--output", str(output), "--multiplicities", "4")
+    monkeypatch.setattr(
+        profiling,
+        "_requested_multiplicities",
+        lambda _arguments, _output: (2, 3, 4, 5, 6, 7, 8, 9),
+    )
+    monkeypatch.setattr(
+        profiling.madgraph,
+        "load_runtime_progress",
+        lambda _path: payload,
+    )
+
+    assert profiling._matching_madgraph_progress(arguments, output) == payload
+    assert profiling._madgraph_render_source(arguments, output) == progress
+
+    payload["policy"]["final_state_multiplicities"] = [6, 5, 4]
+    assert profiling._matching_madgraph_progress(arguments, output) is None
diff --git a/pyamplicol/tests/unit/test_fft_results_summary_pdf.py b/pyamplicol/tests/unit/test_fft_results_summary_pdf.py
new file mode 100644
index 0000000000..10b3773592
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fft_results_summary_pdf.py
@@ -0,0 +1,255 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tools.developer import fft_results_summary_pdf as summary_pdf
+
+
+def test_final_summary_pdf_contains_only_fresh_fixed_helicity_section() -> None:
+    pages = summary_pdf._plot_pages()
+
+    assert len(pages) == 6
+    assert {page.section for page in pages} == {
+        "Current-host fixed-helicity comparison (n=2..9)"
+    }
+    assert {page.path.parent.name for page in pages} == {"scalar-selected-n2-n9-final"}
+    assert summary_pdf._parser().get_default("output").name == "summary_plots_final.pdf"
+    assert (
+        summary_pdf._parser().get_default("campaign_report") == summary_pdf.FINAL_REPORT
+    )
+
+
+def test_pdf_note_requires_and_records_fft_and_helicity_provenance() -> None:
+    note = summary_pdf._campaign_note(
+        {
+            "status": "complete",
+            "policy": {
+                "fft_enabled": True,
+                "selected_pyamplicol_color_contractions": {
+                    "recurrence": ["direct", "symmetric-group-fft"],
+                    "on-the-fly": ["direct", "symmetric-group-fft"],
+                },
+                    "measurement": {
+                        "generation_helicity_coverage": "all",
+                        "warm_fixed_helicity": True,
+                        "warm_benchmark_batch_size": 128,
+                        "compiled_fft_enabled": False,
+                        "memory_watchdog_gib": 30.0,
+                        "generation_timeout_seconds": 3600.0,
+                        "runtime_timeout_seconds": 3600.0,
+                    },
+            }
+        }
+    )
+
+    assert note.splitlines() == [
+        "--fft | recurrence: persisted all-helicity physical schedule | "
+        "OTF compact artifact: all runtime helicities",
+        "pyAmpliCol setup: generation + fresh load + first fixed-helicity "
+        "evaluation; OTF includes family warm-up",
+        "Reference setup: build/init/first pass | AmpliCol setup: "
+        "process/color-object generation",
+        "Warmed runtime measured separately | compiled FFT disabled",
+        "pyAmpliCol CLI profile: batch 128 (cyclic 10 points) | "
+        "Reference/AmpliCol: scalar aggregates normalized per point",
+    ]
+    assert "compiled FFT disabled" in note
+
+
+def test_pdf_note_and_section_record_helicity_sum() -> None:
+    note = summary_pdf._campaign_note(
+        {
+            "policy": {
+                "fft_enabled": True,
+                "helicity_workload": "sum",
+                "selected_pyamplicol_color_contractions": {
+                    "recurrence": ["direct", "symmetric-group-fft"],
+                    "on-the-fly": ["direct", "symmetric-group-fft"],
+                },
+                "measurement": {
+                    "generation_helicity_coverage": "all",
+                    "warm_fixed_helicity": False,
+                    "warm_helicity_sum": True,
+                    "warm_benchmark_batch_size": 128,
+                    "compiled_fft_enabled": False,
+                },
+            }
+        }
+    )
+
+    assert "first complete helicity sum" in note
+    assert "Warmed runtime measured separately" in note
+    assert "immutable snapshot" in note
+    assert "create-raw bulk H family" in note
+    assert "analytic-nonzero H sweep" in note
+    pages = summary_pdf._plot_pages(helicity_workload="sum")
+    assert {page.section for page in pages} == {
+        "Current-host helicity-summed comparison (n=2..9)"
+    }
+    assert {page.path.parent.name for page in pages} == {
+        "scalar-helicity-sum-n2-n9-final"
+    }
+
+
+def test_pdf_header_reserves_space_for_every_wrapped_note_line() -> None:
+    note = (
+        "IN PROGRESS SNAPSHOT | absent cells are unattempted\n"
+        "--fft | recurrence: persisted all-helicity physical schedule | "
+        "OTF compact artifact: all runtime helicities\n"
+        "pyAmpliCol setup: generation + fresh load + first complete helicity "
+        "sum; OTF includes family warm-up\n"
+        "Reference setup: build/init/first pass | AmpliCol setup: process/raw-"
+        "library generation/build + immutable snapshot\n"
+        "Warmed runtime measured separately | compiled FFT disabled\n"
+        "pyAmpliCol CLI profile: batch 128 (cyclic 10 points) | "
+        "Reference/AmpliCol: scalar aggregates normalized per point\n"
+        "AmpliCol: create-raw bulk H family + probe-local zero pruning | "
+        "Reference FFT: analytic-nonzero H sweep"
+    )
+
+    lines = summary_pdf._campaign_note_lines(note, available_width=805.0)
+
+    assert len(lines) >= len(note.splitlines())
+    assert lines[-1].endswith("Reference FFT: analytic-nonzero H sweep")
+    header_height = summary_pdf._campaign_header_height(lines)
+    last_baseline_from_top = 15.5 + 8.0 * (len(lines) - 1)
+    assert header_height == 15.0 + 8.0 * len(lines)
+    assert header_height - last_baseline_from_top >= 7.0
+
+
+def test_pdf_note_rejects_fixed_helicity_cell_in_sum_campaign() -> None:
+    report = {
+        "policy": {
+            "fft_enabled": True,
+            "helicity_workload": "sum",
+            "selected_pyamplicol_color_contractions": {
+                "recurrence": ["direct", "symmetric-group-fft"],
+                "on-the-fly": ["direct", "symmetric-group-fft"],
+            },
+            "measurement": {
+                "generation_helicity_coverage": "all",
+                "warm_fixed_helicity": False,
+                "warm_helicity_sum": True,
+                "warm_benchmark_batch_size": 128,
+                "compiled_fft_enabled": False,
+            },
+        },
+        "runtime_series": {
+            "gg": {
+                "madgraph-standalone": {
+                    "2": {
+                        "status": "measured",
+                        "protocol": {"helicity_summed": False},
+                    }
+                }
+            }
+        },
+    }
+
+    with pytest.raises(ValueError, match="not authenticated as helicity-summed"):
+        summary_pdf._campaign_note(report)
+
+
+def test_pdf_rejects_contradictory_cell_workload_markers() -> None:
+    with pytest.raises(ValueError, match="markers are contradictory"):
+        summary_pdf._cell_helicity_workload(
+            {"helicity_workload": "sum", "warm_fixed_helicity": True}
+        )
+
+
+def test_pdf_rejects_disagreeing_policy_and_measurement_workloads() -> None:
+    with pytest.raises(ValueError, match="declarations disagree"):
+        summary_pdf._campaign_helicity_workload(
+            {"helicity_workload": "fixed"},
+            {
+                "helicity_workload": "sum",
+                "warm_fixed_helicity": False,
+                "warm_helicity_sum": True,
+            },
+        )
+
+
+def test_pdf_plot_manifest_rejects_changed_plot(tmp_path: Path) -> None:
+    campaign_report = tmp_path / "report.json"
+    campaign_report.write_text("{}\n", encoding="utf-8")
+    plot_directory = tmp_path / "plots"
+    plot_directory.mkdir()
+    hashes: dict[str, str] = {}
+    for index, filename in enumerate(summary_pdf.PLOT_FILENAMES):
+        plot_path = plot_directory / filename
+        plot_path.write_bytes(f"png-{index}".encode())
+        hashes[filename] = summary_pdf._sha256(plot_path)
+    (plot_directory / summary_pdf.PLOT_MANIFEST_NAME).write_text(
+        json.dumps(
+            {
+                "kind": "pyamplicol-fft-scaling-plots",
+                "schema_version": 1,
+                "report_sha256": summary_pdf._sha256(campaign_report),
+                "helicity_workload": "sum",
+                "plots": hashes,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    summary_pdf._validate_plot_manifest(
+        plot_directory, campaign_report, "sum"
+    )
+    (plot_directory / summary_pdf.PLOT_FILENAMES[0]).write_bytes(b"changed")
+    with pytest.raises(ValueError, match="hash does not match"):
+        summary_pdf._validate_plot_manifest(
+            plot_directory, campaign_report, "sum"
+        )
+
+
+def test_pdf_validates_and_publishes_raw_plot_data_sidecar(tmp_path: Path) -> None:
+    campaign_report = tmp_path / "report.json"
+    campaign_report.write_text("{}\n", encoding="utf-8")
+    plot_directory = tmp_path / "plots"
+    plot_directory.mkdir()
+    raw_data = (
+        json.dumps(
+            {
+                "kind": "pyamplicol-fft-scaling-plot-data",
+                "schema_version": 1,
+                "report_sha256": summary_pdf._sha256(campaign_report),
+                "helicity_workload": "fixed",
+                "families": {"gg": {}, "ddbar": {}},
+            },
+            indent=2,
+            sort_keys=True,
+        )
+        + "\n"
+    ).encode()
+    (plot_directory / summary_pdf.PLOT_DATA_NAME).write_bytes(raw_data)
+
+    assert (
+        summary_pdf._validated_plot_data_bytes(
+            plot_directory, campaign_report, "fixed"
+        )
+        == raw_data
+    )
+    destination = summary_pdf._publish_plot_data_sidecar(
+        raw_data, tmp_path / "summary_plots_final.pdf"
+    )
+
+    assert destination == tmp_path / "summary_plots_final.json"
+    assert destination.read_bytes() == raw_data
+
+
+def test_pdf_note_rejects_missing_otf_comparison() -> None:
+    report = {
+        "policy": {
+            "fft_enabled": True,
+            "selected_pyamplicol_color_contractions": {
+                "recurrence": ["direct", "symmetric-group-fft"]
+            },
+        }
+    }
+
+    with pytest.raises(ValueError, match="for on-the-fly"):
+        summary_pdf._campaign_note(report)
diff --git a/pyamplicol/tests/unit/test_fft_scaling_final_publication_report.py b/pyamplicol/tests/unit/test_fft_scaling_final_publication_report.py
new file mode 100644
index 0000000000..e27c44bbcc
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fft_scaling_final_publication_report.py
@@ -0,0 +1,743 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from tools.developer import (
+    fft_scaling_final_publication_report as final_report,
+)
+from tools.developer import (
+    fft_scaling_study_plots as plots,
+)
+
+MEASUREMENT_HOST = {
+    "schema_version": 1,
+    "node_sha256": "0" * 64,
+    "system": "TestOS",
+    "machine": "test-machine",
+    "python": "3.test",
+}
+
+
+def _write_json(path: Path, payload: object) -> Path:
+    path.write_text(json.dumps(payload, sort_keys=True), encoding="utf-8")
+    return path
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _events(tmp_path: Path, family: str, n: int) -> tuple[list[str], list[str]]:
+    root = tmp_path / "events" / family / f"n{n}"
+    root.mkdir(parents=True, exist_ok=True)
+    paths: list[str] = []
+    hashes: list[str] = []
+    for index in range(1, 11):
+        path = root / f"point-{index:02d}.event"
+        path.write_text(f"{family} n={n} point={index}\n", encoding="utf-8")
+        paths.append(str(path))
+        hashes.append(_sha256(path))
+    return paths, hashes
+
+
+def _campaign_cell(tmp_path: Path, family: str, mode: str, n: int) -> dict[str, Any]:
+    paths, _ = _events(tmp_path, family, n)
+    points = [float(100 * n + index) for index in range(1, 11)]
+    cell: dict[str, Any] = {
+        "status": "measured",
+        "family": family,
+        "mode": mode,
+        "label": mode,
+        "n": n,
+        "total_external": n + 2,
+        "process": final_report._process_expression(family, n),
+        "color_accuracy": "full",
+        "helicity": [1 if index % 2 else -1 for index in range(n + 2)],
+        "event_paths": paths,
+        "point_values": points[:1] if mode == "amplicol" else points,
+        "metrics": {
+            "generation_seconds": float(n),
+            "warm_seconds_per_point": n / 1_000_000.0,
+            "max_rss_kib": float(1000 + n),
+        },
+    }
+    if mode in final_report.CANDIDATE_MODE_CONTRACT:
+        execution_mode, contraction = final_report.CANDIDATE_MODE_CONTRACT[mode]
+        cell.update(
+            {
+                "execution_mode": execution_mode,
+                "color_contraction": contraction,
+                "generation_helicity_coverage": "all",
+                "warm_fixed_helicity": True,
+                "numerical": {"available": True, "passes": True},
+            }
+        )
+    return cell
+
+
+def _campaign(tmp_path: Path) -> dict[str, Any]:
+    cells = {
+        family: {
+            mode: {
+                str(n): _campaign_cell(tmp_path, family, mode, n)
+                for n in final_report.FINAL_MULTIPLICITIES
+            }
+            for mode in modes
+        }
+        for family, modes in final_report.FAMILY_MODES.items()
+    }
+    return {
+        "kind": final_report.CAMPAIGN_KIND,
+        "schema_version": 1,
+        "measurement_host": deepcopy(MEASUREMENT_HOST),
+        "status": "complete",
+        "failure_count": 0,
+        "policy": {
+            "kind": final_report.CAMPAIGN_KIND,
+            "schema_version": 1,
+            "run_root": str(tmp_path),
+            "fft_enabled": True,
+            "selected_pyamplicol_color_contractions": {
+                "recurrence": ["direct", "symmetric-group-fft"],
+                "on-the-fly": ["direct", "symmetric-group-fft"],
+            },
+            "process_families": {
+                family: {
+                    "expression": final_report.EXPECTED_EXPRESSIONS[family],
+                    "ratio_reference": final_report.EXPECTED_RATIO_REFERENCES[family],
+                    "modes": list(modes),
+                }
+                for family, modes in final_report.FAMILY_MODES.items()
+            },
+            "final_state_multiplicities": list(final_report.FINAL_MULTIPLICITIES),
+            "total_external_particles": [
+                n + 2 for n in final_report.FINAL_MULTIPLICITIES
+            ],
+            "measurement": {
+                "color_accuracy": "full",
+                "n_definition": "final-state-particle-count",
+                "generation_helicity_coverage": "all",
+                "warm_fixed_helicity": True,
+                "fixed_helicity": True,
+                "warm_benchmark_batch_size": 128,
+                "warm_sample_count": final_report.WARM_SAMPLE_COUNT,
+                "compiled_fft_enabled": False,
+                "memory_policy": "per-cell-strictly-below-publication-ceiling",
+                "requested_memory_ceiling_gib": 30.0,
+                "memory_watchdog_gib": 30.0,
+                "cell_admission_limits": {
+                    "generation_seconds": {"operator": "<", "limit": 3600.0},
+                    "runtime_seconds": {"operator": "<", "limit": 3600.0},
+                    "peak_rss_gib": {"operator": "<", "limit": 30.0},
+                },
+            },
+        },
+        "cells": cells,
+    }
+
+
+def _madgraph_cell(
+    campaign: dict[str, Any],
+    source_path: Path,
+    family: str,
+    n: int,
+) -> dict[str, Any]:
+    mode = final_report.SOURCE_MODE[family]
+    source = campaign["cells"][family][mode][str(n)]
+    factor = final_report._madgraph_normalization_factor(family, n)
+    points = [float(value) / factor for value in source["point_values"]]
+    hashes = [_sha256(Path(path)) for path in source["event_paths"]]
+    warm = n / 10_000.0
+    return {
+        "status": "measured",
+        "family": family,
+        "mode": "madgraph-standalone",
+        "label": "MadGraph standalone (fixed h)",
+        "n": n,
+        "total_external": n + 2,
+        "process": final_report._process_expression(family, n),
+        "helicity": source["helicity"],
+        "event_paths": source["event_paths"],
+        "event_sha256": hashes,
+        "point_values": points,
+        "matrix_element": points[0],
+        "generation_seconds": float(2 * n),
+        "warm_seconds_per_point": warm,
+        "max_rss_kib": float(2048 + n),
+        "warm_samples_seconds": [warm] * 10,
+        "metrics": {
+            "generation_seconds": float(2 * n),
+            "warm_seconds_per_point": warm,
+            "max_rss_kib": float(2048 + n),
+        },
+        "numerical": {
+            "reference_mode": mode,
+            "normalization_factor_reference_per_madgraph": factor,
+            "passes": True,
+        },
+        "protocol": {
+            "evaluator": "MATRIX(P,NHEL,IC)-direct",
+            "generation_helicity_coverage": "all",
+            "warm_fixed_helicity": True,
+            "helicity_summed": False,
+            "color_sum": "full-unaveraged",
+            "batch_size": 1,
+            "initialization_included": False,
+        },
+        "runtime_refresh": {
+            "accepted": True,
+            "fresh_process": True,
+            "scope": "generation-resource-and-warm-runtime",
+        },
+        "provenance": {
+            "smatrix_iden": final_report._expected_madgraph_iden(family, n),
+            "source_report": {
+                "path": str(source_path),
+                "sha256": _sha256(source_path),
+                "cell": f"cells.{family}.{mode}.{n}",
+            },
+        },
+    }
+
+
+def _madgraph_scope_cell(family: str, n: int) -> dict[str, Any]:
+    measured_limit = final_report.MADGRAPH_FAMILY_MAX_MEASURED_MULTIPLICITY[family]
+    return {
+        "status": "not-applicable",
+        "family": family,
+        "mode": "madgraph-standalone",
+        "label": "MadGraph standalone (fixed h)",
+        "n": n,
+        "total_external": n + 2,
+        "process": final_report._process_expression(family, n),
+        "failure_category": (
+            "protocol-scope-pure-gluon-n6"
+            if (family, n) == ("gg", 6)
+            else f"protocol-scope-n>{measured_limit}"
+        ),
+        "failure_reason": (
+            f"final-plot protocol measures {family} MadGraph only through "
+            f"n={measured_limit}"
+        ),
+        "censors_higher_multiplicities": False,
+        "protocol_scope": {
+            "maximum_measured_multiplicity": measured_limit,
+            "disposition": "not-applicable",
+        },
+    }
+
+
+def _overlay(campaign: dict[str, Any], source_path: Path) -> dict[str, Any]:
+    cells = {
+        family: {
+            "madgraph-standalone": {
+                str(n): (
+                    _madgraph_cell(campaign, source_path, family, n)
+                    if n
+                    <= final_report.MADGRAPH_FAMILY_MAX_MEASURED_MULTIPLICITY[family]
+                    else _madgraph_scope_cell(family, n)
+                )
+                for n in final_report.FINAL_MULTIPLICITIES
+            }
+        }
+        for family in final_report.FAMILY_MODES
+    }
+    return {
+        "kind": final_report.selected.RUNTIME_SERIES_OVERLAY_KIND,
+        "schema_version": 1,
+        "host": deepcopy(MEASUREMENT_HOST),
+        "status": "complete",
+        "failure_count": 0,
+        "policy": {
+            "final_state_multiplicities": list(final_report.FINAL_MULTIPLICITIES),
+            "process_families": list(final_report.FAMILY_MODES),
+            "point_validation_count": 10,
+            "warm_timed_point_index": 1,
+            "warm_sample_count": final_report.WARM_SAMPLE_COUNT,
+            "generation_timeout_seconds": 3595.0,
+            "outer_memory_watchdog_gib": 30.0,
+            "watchdog_enforced_per_generation_build_and_runtime": True,
+            "generation_helicity_coverage": "all",
+            "warm_fixed_helicity": True,
+            "maximum_measured_multiplicity": 6,
+            "family_maximum_measured_multiplicity": (
+                final_report.MADGRAPH_FAMILY_MAX_MEASURED_MULTIPLICITY
+            ),
+            "higher_multiplicity_policy": "not-applicable-protocol-scope",
+            "metric_scope": {
+                "generation_seconds": "cold to ready",
+                "warm_seconds_per_point": "fixed-helicity warm time",
+                "max_rss_kib": "conservative process-tree peak",
+            },
+        },
+        "summary": {
+            "runtime_series_status_counts": {
+                "measured": 9,
+                "not-applicable": 7,
+            }
+        },
+        "runtime_series": cells,
+    }
+
+
+def _inputs(tmp_path: Path) -> tuple[dict[str, Any], Path, dict[str, Any], Path]:
+    campaign = _campaign(tmp_path)
+    campaign_path = _write_json(tmp_path / "report.json", campaign)
+    overlay = _overlay(campaign, campaign_path)
+    overlay_path = _write_json(tmp_path / "madgraph.json", overlay)
+    return campaign, campaign_path, overlay, overlay_path
+
+
+def test_merge_preserves_fresh_cells_and_policy_and_adds_all_metrics(
+    tmp_path: Path,
+) -> None:
+    campaign, campaign_path, _, overlay_path = _inputs(tmp_path)
+
+    report = final_report.build_final_report(
+        campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+    )
+    repeated = final_report.build_final_report(
+        campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+    )
+
+    assert report == repeated
+    assert report["kind"] == final_report.FINAL_KIND
+    expected_policy = deepcopy(campaign["policy"])
+    expected_policy["measurement"].pop("fixed_helicity")
+    assert report["policy"] == expected_policy
+    assert report["policy"]["measurement"]["generation_helicity_coverage"] == "all"
+    assert report["policy"]["measurement"]["warm_fixed_helicity"] is True
+    assert report["cells"] == campaign["cells"]
+    assert report["cells"]["gg"]["otf-fft"]["9"]["execution_mode"] == (
+        "on-the-fly"
+    )
+    assert report["cells"]["ddbar"]["otf-direct"]["9"]["color_contraction"] == (
+        "direct"
+    )
+    assert report["policy"]["final_state_multiplicities"] == list(range(2, 10))
+    assert (
+        report["runtime_series"]["ddbar"]["madgraph-standalone"]["9"]["status"]
+        == "not-applicable"
+    )
+    assert report["summary"] == {
+        "cell_status_counts": {"measured": 88},
+        "runtime_series_status_counts": {
+            "measured": 9,
+            "not-applicable": 7,
+        },
+        "total_failure_count": 0,
+    }
+    assert report["publication_provenance"]["campaign_report"]["sha256"] == (
+        _sha256(campaign_path)
+    )
+    assert report["publication_provenance"]["same_host_authenticated"] is True
+
+
+def test_merge_rejects_cross_host_madgraph_overlay(tmp_path: Path) -> None:
+    _, campaign_path, overlay, _ = _inputs(tmp_path)
+    overlay["host"]["node_sha256"] = "1" * 64
+    overlay_path = _write_json(tmp_path / "cross-host.json", overlay)
+    with pytest.raises(
+        final_report.PublicationMergeError, match="different measurement"
+    ):
+        final_report.build_final_report(
+            campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+        )
+
+
+def test_merge_authenticates_a_native_smatrix_helicity_sum(
+    tmp_path: Path,
+) -> None:
+    campaign = _campaign(tmp_path)
+    measurement = campaign["policy"]["measurement"]
+    measurement.update(
+        {
+            "alpha_s": 0.118,
+            "helicity_workload": "sum",
+            "warm_fixed_helicity": False,
+            "warm_helicity_sum": True,
+        }
+    )
+    measurement.pop("fixed_helicity", None)
+    campaign["policy"]["plot"] = {
+        "notes": [
+            "MadGraph is omitted because its available series is fixed-helicity."
+        ]
+    }
+    for family_modes in campaign["cells"].values():
+        for mode, mode_cells in family_modes.items():
+            if mode not in final_report.CANDIDATE_MODE_CONTRACT:
+                continue
+            for cell in mode_cells.values():
+                cell["warm_fixed_helicity"] = False
+                cell["warm_helicity_sum"] = True
+    campaign_path = _write_json(tmp_path / "report.json", campaign)
+    overlay = _overlay(campaign, campaign_path)
+    overlay["policy"].update(
+        {
+            "helicity_workload": "sum",
+            "warm_fixed_helicity": False,
+            "warm_helicity_sum": True,
+        }
+    )
+    for family in final_report.FAMILY_MODES:
+        source_mode = final_report.SUM_SOURCE_MODE[family]
+        measured_limit = final_report.MADGRAPH_FAMILY_MAX_MEASURED_MULTIPLICITY[
+            family
+        ]
+        for n in range(2, measured_limit + 1):
+            cell = overlay["runtime_series"][family]["madgraph-standalone"][str(n)]
+            source = campaign["cells"][family][source_mode][str(n)]
+            cell.update(
+                {
+                    "label": "MadGraph standalone (helicity sum)",
+                    "alpha_s": 0.118,
+                    "helicity_workload": "sum",
+                    "warm_fixed_helicity": False,
+                    "warm_helicity_sum": True,
+                    "timed_helicity_count": 2 ** (n + 2),
+                    "helicity": source["helicity"],
+                    "event_paths": source["event_paths"],
+                    "event_sha256": [
+                        _sha256(Path(path)) for path in source["event_paths"]
+                    ],
+                    "point_values": source["point_values"],
+                    "matrix_element": source["point_values"][0],
+                }
+            )
+            cell["numerical"].update(
+                {
+                    "reference_mode": source_mode,
+                    "normalization_factor_reference_per_madgraph": 1.0,
+                }
+            )
+            cell["protocol"].update(
+                {
+                    "evaluator": "SMATRIX(P,ANS)-generated-complete-helicity-sum",
+                    "helicity_workload": "sum",
+                    "warm_fixed_helicity": False,
+                    "warm_helicity_sum": True,
+                    "helicity_summed": True,
+                    "timed_helicity_count": 2 ** (n + 2),
+                    "helicity_sum_implementation": (
+                        "generated-SMATRIX-with-USERHEL-minus-one"
+                    ),
+                    "warmed_native_call_pruning": (
+                        "generated GOODHEL cache may skip structurally zero helicities"
+                    ),
+                    "color_sum": "generated-SMATRIX-summed-and-averaged",
+                }
+            )
+            retained = tmp_path / "retained" / family / f"n{n}"
+            retained.mkdir(parents=True)
+            iden = final_report._expected_madgraph_iden(family, n)
+            matrix = retained / "matrix.f"
+            matrix.write_text(
+                "      SUBROUTINE SMATRIX(P,ANS)\n"
+                f"      INTEGER NCOMB\n      PARAMETER (NCOMB={2 ** (n + 2)})\n"
+                "      INTEGER NEXTERNAL\n"
+                "      INTEGER NHEL(NEXTERNAL,NCOMB)\n"
+                f"      DATA IDEN/{iden}/\n"
+                "      ANS=ANS/DBLE(IDEN)\n"
+                "      END\n",
+                encoding="utf-8",
+            )
+            check = retained / "check_sa.f"
+            check.write_text(
+                "      USERHEL=-1\n"
+                "      CALL SMATRIX(P,V)\n"
+                "      CALL SMATRIX(P,V)\n"
+                "      CALL SMATRIX(P,V)\n",
+                encoding="ascii",
+            )
+            cell["provenance"].update(
+                {
+                    "source_alpha_s": 0.118,
+                    "runtime_alpha_s": 0.118,
+                    "timed_helicity_count": 2 ** (n + 2),
+                    "matrix_sha256": _sha256(matrix),
+                    "check_source_sha256": _sha256(check),
+                    "retained": {
+                        "matrix_source": str(matrix),
+                        "matrix_sha256": _sha256(matrix),
+                        "check_source": str(check),
+                        "check_source_sha256": _sha256(check),
+                    },
+                    "source_report": {
+                        "path": str(campaign_path),
+                        "sha256": _sha256(campaign_path),
+                        "cell": f"cells.{family}.{source_mode}.{n}",
+                    },
+                }
+            )
+    overlay_path = _write_json(tmp_path / "madgraph-sum.json", overlay)
+
+    report = final_report.build_final_report(
+        campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+    )
+
+    assert report["status"] == "complete"
+    assert (
+        report["runtime_series"]["gg"]["madgraph-standalone"]["2"][
+            "helicity_workload"
+        ]
+        == "sum"
+    )
+    assert report["policy"]["measurement"]["warm_fixed_helicity"] is False
+    assert report["policy"]["measurement"]["warm_helicity_sum"] is True
+    assert all(
+        "omitted" not in note.lower()
+        for note in report["policy"]["plot"]["notes"]
+    )
+
+
+def test_protocol_scoped_n2_n9_final_report_renders_all_six_plots(
+    tmp_path: Path,
+) -> None:
+    _, campaign_path, _, overlay_path = _inputs(tmp_path)
+    report = final_report.build_final_report(
+        campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+    )
+    output = tmp_path / "plots"
+
+    plots._render(report, output, dpi=72)
+
+    assert {path.name for path in output.glob("*.png")} == {
+        f"fullcolor-{family}-{metric}.png"
+        for family in ("gg", "ddbar")
+        for metric in ("generation", "warm-runtime", "rss")
+    }
+
+
+def test_merge_accepts_one_amplicol_validation_value_per_measured_cell(
+    tmp_path: Path,
+) -> None:
+    campaign = _campaign(tmp_path)
+    for family_cells in campaign["cells"].values():
+        for cell in family_cells["amplicol"].values():
+            cell["point_values"] = cell["point_values"][:1]
+    campaign_path = _write_json(tmp_path / "report.json", campaign)
+    overlay_path = _write_json(
+        tmp_path / "madgraph.json", _overlay(campaign, campaign_path)
+    )
+
+    report = final_report.build_final_report(
+        campaign_path=campaign_path,
+        madgraph_overlay_path=overlay_path,
+    )
+
+    assert report["cells"]["gg"]["amplicol"]["2"]["point_values"] == [201.0]
+
+
+def test_merge_rejects_more_than_one_amplicol_validation_value(
+    tmp_path: Path,
+) -> None:
+    campaign = _campaign(tmp_path)
+    campaign["cells"]["gg"]["amplicol"]["2"]["point_values"] = [201.0, 202.0]
+    campaign_path = _write_json(tmp_path / "report.json", campaign)
+    overlay_path = _write_json(
+        tmp_path / "madgraph.json", _overlay(campaign, campaign_path)
+    )
+
+    with pytest.raises(final_report.PublicationMergeError, match="exactly 1"):
+        final_report.build_final_report(
+            campaign_path=campaign_path,
+            madgraph_overlay_path=overlay_path,
+        )
+
+
+@pytest.mark.parametrize(
+    ("path", "value", "message"),
+    (
+        (("fft_enabled",), False, "record --fft"),
+        (
+            ("measurement", "generation_helicity_coverage"),
+            "selected",
+            "generation_helicity_coverage",
+        ),
+        (
+            ("measurement", "compiled_fft_enabled"),
+            True,
+            "compiled_fft_enabled",
+        ),
+    ),
+)
+def test_merge_rejects_incompatible_campaign_protocol(
+    tmp_path: Path, path: tuple[str, ...], value: object, message: str
+) -> None:
+    campaign = _campaign(tmp_path)
+    target = campaign["policy"]
+    for key in path[:-1]:
+        target = target[key]
+    target[path[-1]] = value
+    campaign_path = _write_json(tmp_path / "report.json", campaign)
+    overlay_path = _write_json(
+        tmp_path / "madgraph.json", _overlay(campaign, campaign_path)
+    )
+
+    with pytest.raises(final_report.PublicationMergeError, match=message):
+        final_report.build_final_report(
+            campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+        )
+
+
+def test_merge_rejects_measurement_after_a_campaign_frontier(tmp_path: Path) -> None:
+    campaign = _campaign(tmp_path)
+    failed = campaign["cells"]["gg"]["recurrence-direct"]["5"]
+    failed["status"] = "failed"
+    failed["failure_reason"] = "strict resource frontier"
+    failed["censors_higher_multiplicities"] = True
+    failed.pop("metrics")
+    failed.pop("helicity")
+    failed.pop("event_paths")
+    failed.pop("point_values")
+    campaign["status"] = "complete-with-failures"
+    campaign["failure_count"] = 1
+    campaign_path = _write_json(tmp_path / "report.json", campaign)
+    overlay_path = _write_json(
+        tmp_path / "madgraph.json", _overlay(campaign, campaign_path)
+    )
+
+    with pytest.raises(final_report.PublicationMergeError, match="resumes measurement"):
+        final_report.build_final_report(
+            campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+        )
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "message"),
+    (
+        ("execution_mode", "recurrence", r"execution_mode is wrong"),
+        ("color_contraction", "direct", r"color_contraction is wrong"),
+        (
+            "generation_helicity_coverage",
+            "selected",
+            r"generation_helicity_coverage is wrong",
+        ),
+        ("warm_fixed_helicity", False, r"warm_fixed_helicity is wrong"),
+    ),
+)
+def test_merge_authenticates_otf_cell_protocol(
+    tmp_path: Path, field: str, value: object, message: str
+) -> None:
+    campaign = _campaign(tmp_path)
+    campaign["cells"]["gg"]["otf-fft"]["4"][field] = value
+    campaign_path = _write_json(tmp_path / "report.json", campaign)
+    overlay_path = _write_json(
+        tmp_path / "madgraph.json", _overlay(campaign, campaign_path)
+    )
+
+    with pytest.raises(final_report.PublicationMergeError, match=message):
+        final_report.build_final_report(
+            campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+        )
+
+
+@pytest.mark.parametrize(
+    ("mutation", "message"),
+    (
+        ("numerical", "failed its numerical comparison"),
+        ("events", "must contain ten paths"),
+    ),
+)
+def test_merge_preserves_otf_numerical_and_event_checks(
+    tmp_path: Path, mutation: str, message: str
+) -> None:
+    campaign = _campaign(tmp_path)
+    cell = campaign["cells"]["ddbar"]["otf-direct"]["3"]
+    if mutation == "numerical":
+        cell["numerical"]["passes"] = False
+    else:
+        cell["event_paths"] = cell["event_paths"][:-1]
+    campaign_path = _write_json(tmp_path / "report.json", campaign)
+    overlay_path = _write_json(
+        tmp_path / "madgraph.json", _overlay(campaign, campaign_path)
+    )
+
+    with pytest.raises(final_report.PublicationMergeError, match=message):
+        final_report.build_final_report(
+            campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+        )
+
+
+def test_merge_preserves_a_madgraph_failure_frontier(tmp_path: Path) -> None:
+    _, campaign_path, overlay, _ = _inputs(tmp_path)
+    curve = overlay["runtime_series"]["gg"]["madgraph-standalone"]
+    curve["5"] = {
+        "status": "failed",
+        "family": "gg",
+        "mode": "madgraph-standalone",
+        "label": "MadGraph standalone (fixed h)",
+        "n": 5,
+        "total_external": 7,
+        "process": final_report._process_expression("gg", 5),
+        "failure_reason": "strict resource frontier",
+    }
+    overlay["status"] = "complete-with-failures"
+    overlay["failure_count"] = 1
+    overlay["summary"]["runtime_series_status_counts"] = {
+        "failed": 1,
+        "measured": 8,
+        "not-applicable": 7,
+    }
+    overlay_path = _write_json(tmp_path / "madgraph.json", overlay)
+
+    report = final_report.build_final_report(
+        campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+    )
+
+    assert report["status"] == "complete-with-failures"
+    assert report["failure_count"] == 1
+    assert (
+        report["runtime_series"]["gg"]["madgraph-standalone"]["9"]["status"]
+        == "not-applicable"
+    )
+
+
+def test_merge_rejects_madgraph_event_or_source_provenance(tmp_path: Path) -> None:
+    _, campaign_path, overlay, _ = _inputs(tmp_path)
+    overlay["runtime_series"]["gg"]["madgraph-standalone"]["2"]["event_sha256"][0] = (
+        "0" * 64
+    )
+    overlay_path = _write_json(tmp_path / "madgraph.json", overlay)
+
+    with pytest.raises(final_report.PublicationMergeError, match="SHA-256 provenance"):
+        final_report.build_final_report(
+            campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+        )
+
+
+def test_merge_rejects_old_fixed_ddbar_normalization(tmp_path: Path) -> None:
+    _, campaign_path, overlay, _ = _inputs(tmp_path)
+    cell = overlay["runtime_series"]["ddbar"]["madgraph-standalone"]["4"]
+    cell["numerical"]["normalization_factor_reference_per_madgraph"] = 1.0 / 36.0
+    cell["provenance"]["smatrix_iden"] = 36
+    overlay_path = _write_json(tmp_path / "madgraph.json", overlay)
+
+    with pytest.raises(
+        final_report.PublicationMergeError,
+        match=r"incompatible normalization|wrong generated SMATRIX denominator",
+    ):
+        final_report.build_final_report(
+            campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+        )
+
+
+def test_merge_rejects_non_strict_resource_metrics(tmp_path: Path) -> None:
+    _, campaign_path, overlay, _ = _inputs(tmp_path)
+    cell = overlay["runtime_series"]["ddbar"]["madgraph-standalone"]["3"]
+    cell["generation_seconds"] = 3600.0
+    cell["metrics"]["generation_seconds"] = 3600.0
+    overlay_path = _write_json(tmp_path / "madgraph.json", overlay)
+
+    with pytest.raises(final_report.PublicationMergeError, match="exceeds one hour"):
+        final_report.build_final_report(
+            campaign_path=campaign_path, madgraph_overlay_path=overlay_path
+        )
diff --git a/pyamplicol/tests/unit/test_fft_scaling_selected_scalar_report.py b/pyamplicol/tests/unit/test_fft_scaling_selected_scalar_report.py
new file mode 100644
index 0000000000..b44b19693e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fft_scaling_selected_scalar_report.py
@@ -0,0 +1,612 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from tools.developer import fft_scaling_selected_scalar_report as selected
+
+
+def _measured(source: int, family: str, mode: str, n: int) -> dict[str, Any]:
+    warm = source + n / 100.0
+    return {
+        "family": family,
+        "mode": mode,
+        "n": n,
+        "total_external": n + 2,
+        "process": selected._process_expression(family, n),
+        "helicity": [1] * (n + 2),
+        "event_paths": [
+            f"/events/{family}/n{n}/point-{index:02d}.event" for index in range(1, 11)
+        ],
+        "label": mode,
+        "status": "measured",
+        "metrics": {
+            "generation_seconds": source * 10 + n,
+            "warm_seconds_per_point": warm,
+            "max_rss_kib": source * 100 + n,
+        },
+        "point_values": [float(index) for index in range(1, 11)],
+        "probe": {
+            "warm_median_seconds": warm,
+            "warm_samples_seconds": [warm] * 10,
+            "point_values": [float(index) for index in range(1, 11)],
+        },
+    }
+
+
+def _report(source: int, *, high: bool, canonical: bool = False) -> dict[str, Any]:
+    multiplicities = range(7, 11) if high else range(2, 8)
+    modes = selected.HIGH_MODES if high else selected.FAMILY_MODES
+    cells: dict[str, dict[str, dict[str, dict[str, Any]]]] = {}
+    for family, family_modes in modes.items():
+        cells[family] = {}
+        for mode in family_modes:
+            cells[family][mode] = {
+                str(n): _measured(source, family, mode, n) for n in multiplicities
+            }
+    if high:
+        for n in (8, 9):
+            cells["gg"]["amplicol"][str(n)] = {
+                "status": "skipped",
+                "failure_reason": "structural or prior resource censor",
+            }
+        cells["gg"]["recurrence-fft"]["9"] = {
+            "status": "failed",
+            "failure_category": "memory-limit",
+        }
+        cells["ddbar"]["amplicol"]["9"] = {
+            "status": "failed",
+            "failure_category": "memory-limit",
+        }
+    return {
+        "kind": selected.CANONICAL_KIND if canonical else selected.SCALAR_KIND,
+        "schema_version": 1,
+        "status": "complete-with-failures" if high else "complete",
+        "policy": {
+            "final_state_multiplicities": list(multiplicities),
+            "process_families": {
+                "gg": {
+                    "expression": "g g > g g + (n-2)*g",
+                    "modes": list(modes["gg"]),
+                    "ratio_reference": "reference-fft",
+                },
+                "ddbar": {
+                    "expression": "d d~ > d d~ + (n-2)*g",
+                    "modes": list(modes["ddbar"]),
+                    "ratio_reference": "amplicol",
+                },
+            },
+        },
+        "cells": cells,
+    }
+
+
+def _write(path: Path, payload: object) -> Path:
+    path.write_text(json.dumps(payload), encoding="utf-8")
+    return path
+
+
+def _sources(tmp_path: Path) -> tuple[Path, Path, Path]:
+    return (
+        _write(tmp_path / "scalar.json", _report(1, high=False)),
+        _write(
+            tmp_path / "canonical.json",
+            _report(2, high=False, canonical=True),
+        ),
+        _write(tmp_path / "high.json", _report(3, high=True)),
+    )
+
+
+def _clean_runtime_overlay(report: dict[str, Any]) -> dict[str, Any]:
+    cells: dict[str, dict[str, dict[str, Any]]] = {}
+    for family, family_modes in selected.RUNTIME_TARGETS.items():
+        cells[family] = {}
+        for mode, multiplicities in family_modes.items():
+            cells[family][mode] = {}
+            for n in multiplicities:
+                base = report["cells"][family][mode][str(n)]
+                warm = float(100 + n)
+                sample_count = 1 if mode == "amplicol" else 10
+                cell = {
+                    "status": "measured",
+                    "family": family,
+                    "mode": mode,
+                    "n": n,
+                    "total_external": n + 2,
+                    "process": base["process"],
+                    "helicity": base["helicity"],
+                    "event_paths": base["event_paths"],
+                    "event_sha256": ["a" * 64] * 10,
+                    "warm_seconds_per_point": warm,
+                    "warm_samples_seconds": [warm] * sample_count,
+                    "point_values": base["point_values"],
+                    "runtime_refresh": {
+                        "accepted": True,
+                        "fresh_process": True,
+                        "scope": "warm-runtime-only",
+                    },
+                }
+                if mode == "amplicol":
+                    cell["adaptive_runtime_points"] = 7
+                cells[family][mode][str(n)] = cell
+    censored: dict[str, dict[str, dict[str, Any]]] = {}
+    for (family, mode, n), status in selected.EXPECTED_CENSORED_CELLS.items():
+        censored.setdefault(family, {}).setdefault(mode, {})[str(n)] = {
+            "status": status
+        }
+    return {
+        "kind": selected.CLEAN_RUNTIME_OVERLAY_KIND,
+        "schema_version": 1,
+        "status": "complete",
+        "cells": cells,
+        "censored_cells": censored,
+    }
+
+
+def _madgraph_cell(family: str, n: int, status: str) -> dict[str, Any]:
+    cell: dict[str, Any] = {
+        "status": status,
+        "family": family,
+        "mode": "madgraph-standalone",
+        "label": "MadGraph standalone (fixed h)",
+        "n": n,
+        "total_external": n + 2,
+        "process": selected._process_expression(family, n),
+    }
+    if status == "measured":
+        warm = float(n)
+        cell.update(
+            {
+                "helicity": [1] * (n + 2),
+                "event_paths": [f"/events/mg/{family}/n{n}/{i}" for i in range(10)],
+                "event_sha256": ["b" * 64] * 10,
+                "warm_seconds_per_point": warm,
+                "warm_samples_seconds": [warm] * 10,
+                "metrics": {
+                    "generation_seconds": warm * 10.0,
+                    "warm_seconds_per_point": warm,
+                    "max_rss_kib": warm * 1024.0,
+                },
+                "matrix_element": 1.0,
+                "point_values": [1.0] * 10,
+                "protocol": {
+                    "evaluator": "MATRIX(P,NHEL,IC)-direct",
+                    "helicity_summed": False,
+                    "color_sum": "full-unaveraged",
+                    "batch_size": 1,
+                    "initialization_included": False,
+                },
+            }
+        )
+    elif status == "not-applicable":
+        measured_limit = selected.MADGRAPH_FAMILY_MAX_MEASURED_MULTIPLICITY[family]
+        cell.update(
+            {
+                "failure_category": (
+                    "protocol-scope-pure-gluon-n6"
+                    if (family, n) == ("gg", 6)
+                    else f"protocol-scope-n>{measured_limit}"
+                ),
+                "failure_reason": (
+                    f"final-plot protocol measures {family} only through "
+                    f"n={measured_limit}"
+                ),
+                "censors_higher_multiplicities": False,
+                "protocol_scope": {
+                    "maximum_measured_multiplicity": measured_limit,
+                    "disposition": "not-applicable",
+                },
+            }
+        )
+    else:
+        cell["failure_reason"] = "standalone source frontier"
+    return cell
+
+
+def _madgraph_overlay() -> dict[str, Any]:
+    return {
+        "kind": selected.RUNTIME_SERIES_OVERLAY_KIND,
+        "schema_version": 1,
+        "policy": {
+            "final_state_multiplicities": list(selected.FINAL_MULTIPLICITIES),
+            "helicity_workload": "fixed",
+            "warm_fixed_helicity": True,
+            "warm_helicity_sum": False,
+            "family_maximum_measured_multiplicity": (
+                selected.MADGRAPH_FAMILY_MAX_MEASURED_MULTIPLICITY
+            ),
+        },
+        "runtime_series": {
+            "gg": {
+                "madgraph-standalone": {
+                    str(n): _madgraph_cell(
+                        "gg",
+                        n,
+                        (
+                            "measured"
+                            if n <= 4
+                            else "failed"
+                            if n == 5
+                            else "not-applicable"
+                        ),
+                    )
+                    for n in range(2, 10)
+                }
+            },
+            "ddbar": {
+                "madgraph-standalone": {
+                    str(n): _madgraph_cell(
+                        "ddbar",
+                        n,
+                        (
+                            "failed"
+                            if n == 2
+                            else "skipped"
+                            if n <= 6
+                            else "not-applicable"
+                        ),
+                    )
+                    for n in range(2, 10)
+                }
+            },
+        },
+    }
+
+
+def test_composite_selects_exact_cells_and_metric_sources(tmp_path: Path) -> None:
+    scalar_path, canonical_path, high_path = _sources(tmp_path)
+
+    report = selected.build_selected_report(
+        scalar_path=scalar_path,
+        canonical_path=canonical_path,
+        high_path=high_path,
+    )
+
+    assert report["policy"]["final_state_multiplicities"] == list(range(2, 10))
+    assert report["policy"]["process_families"]["gg"]["modes"] == [
+        "reference-fft",
+        "amplicol",
+        "recurrence-direct",
+        "recurrence-fft",
+    ]
+    assert set(report["cells"]["gg"]["recurrence-direct"]) == {
+        "2",
+        "3",
+        "4",
+        "5",
+        "6",
+    }
+    assert report["cells"]["gg"]["recurrence-direct"]["6"]["label"] == (
+        "pyAmpliCol - recurrence (n≤6)"
+    )
+    assert all(
+        "10" not in mode_cells
+        for family_cells in report["cells"].values()
+        for mode_cells in family_cells.values()
+    )
+    assert report["summary"]["cell_status_counts"] == {
+        "failed": 2,
+        "measured": 46,
+        "skipped": 2,
+    }
+
+    low_reference = report["cells"]["gg"]["reference-fft"]["6"]
+    assert low_reference["metrics"] == {
+        "generation_seconds": 26.0,
+        "warm_seconds_per_point": 1.06,
+        "max_rss_kib": 106.0,
+    }
+    low_candidate = report["cells"]["gg"]["recurrence-fft"]["6"]
+    assert low_candidate["metrics"] == {
+        "generation_seconds": 26.0,
+        "warm_seconds_per_point": 1.06,
+        "max_rss_kib": 206.0,
+    }
+    assert low_candidate["plot_provenance"]["metrics"] == {
+        "generation_seconds": "canonical-final:cells.gg.recurrence-fft.6",
+        "warm_seconds_per_point": "scalar-current:cells.gg.recurrence-fft.6",
+        "max_rss_kib": "canonical-final:cells.gg.recurrence-fft.6",
+    }
+    assert report["cells"]["gg"]["recurrence-fft"]["7"]["metrics"] == {
+        "generation_seconds": 37.0,
+        "warm_seconds_per_point": 3.07,
+        "max_rss_kib": 307.0,
+    }
+
+
+def test_exact_runtime_overlay_updates_only_accepted_warm_cell(
+    tmp_path: Path,
+) -> None:
+    scalar_path, canonical_path, high_path = _sources(tmp_path)
+    overlay = {
+        "kind": selected.OVERLAY_KIND,
+        "schema_version": 1,
+        "cells": {
+            "8": {
+                "warm_seconds_per_point": 0.125,
+                "warm_samples_seconds": [0.125] * 10,
+                "point_values": [float(index) for index in range(1, 11)],
+                "runtime_refresh": {
+                    "accepted": True,
+                    "archive_sha256": "a" * 64,
+                    "paired_run_logs": ["p1-B.log", "p2-B.log", "p3-B.log"],
+                },
+            }
+        },
+    }
+    overlay_path = _write(tmp_path / "overlay.json", overlay)
+
+    report = selected.build_selected_report(
+        scalar_path=scalar_path,
+        canonical_path=canonical_path,
+        high_path=high_path,
+        runtime_overlay_path=overlay_path,
+    )
+
+    cell = report["cells"]["gg"]["recurrence-fft"]["8"]
+    assert cell["metrics"]["warm_seconds_per_point"] == 0.125
+    assert cell["probe"]["warm_samples_seconds"] == [0.125] * 10
+    assert cell["runtime_refresh"]["accepted"] is True
+    assert cell["plot_provenance"]["metrics"]["warm_seconds_per_point"] == (
+        "runtime-overlay:cells.8"
+    )
+    assert (
+        report["cells"]["gg"]["recurrence-fft"]["7"]["metrics"][
+            "warm_seconds_per_point"
+        ]
+        == 3.07
+    )
+
+
+def test_builder_fails_closed_on_missing_source_cell(tmp_path: Path) -> None:
+    scalar_path, canonical_path, high_path = _sources(tmp_path)
+    scalar = json.loads(scalar_path.read_text(encoding="utf-8"))
+    del scalar["cells"]["ddbar"]["recurrence-direct"]["6"]
+    _write(scalar_path, scalar)
+
+    with pytest.raises(
+        selected.CompositeError, match=r"cells\.ddbar\.recurrence-direct\.6"
+    ):
+        selected.build_selected_report(
+            scalar_path=scalar_path,
+            canonical_path=canonical_path,
+            high_path=high_path,
+        )
+
+
+def test_runtime_overlay_rejects_any_target_outside_n7_n8(tmp_path: Path) -> None:
+    scalar_path, canonical_path, high_path = _sources(tmp_path)
+    overlay_path = _write(
+        tmp_path / "overlay.json",
+        {
+            "kind": selected.OVERLAY_KIND,
+            "schema_version": 1,
+            "cells": {"9": {}},
+        },
+    )
+
+    with pytest.raises(selected.CompositeError, match="only gg recurrence-fft"):
+        selected.build_selected_report(
+            scalar_path=scalar_path,
+            canonical_path=canonical_path,
+            high_path=high_path,
+            runtime_overlay_path=overlay_path,
+        )
+
+
+def test_clean_runtime_overlay_refreshes_exactly_all_measured_warm_cells(
+    tmp_path: Path,
+) -> None:
+    scalar_path, canonical_path, high_path = _sources(tmp_path)
+    base = selected.build_selected_report(
+        scalar_path=scalar_path,
+        canonical_path=canonical_path,
+        high_path=high_path,
+    )
+    overlay_path = _write(tmp_path / "clean-overlay.json", _clean_runtime_overlay(base))
+
+    report = selected.build_selected_report(
+        scalar_path=scalar_path,
+        canonical_path=canonical_path,
+        high_path=high_path,
+        runtime_overlay_path=overlay_path,
+    )
+
+    assert report["runtime_refresh"] == {
+        "scope": "warm-runtime-only",
+        "coverage": "complete",
+        "fresh_measured_cell_count": 46,
+        "preserved_resource_censored_cell_count": 4,
+    }
+    assert (
+        report["summary"]["cell_status_counts"] == base["summary"]["cell_status_counts"]
+    )
+    assert report["policy"]["measurement"]["warm_samples"] == {
+        "reference-fft": 10,
+        "pyamplicol": 10,
+        "amplicol": 1,
+    }
+    assert report["policy"]["plot"]["metric_source_boundaries"] == {
+        "generation_seconds": {
+            "source_boundary_after_n": 6,
+            "source_boundary_label": "n=2..6 / n=7..9 source boundary",
+        },
+        "warm_seconds_per_point": None,
+        "max_rss_kib": {
+            "source_boundary_after_n": 6,
+            "source_boundary_label": "n=2..6 / n=7..9 source boundary",
+        },
+    }
+    refreshed = report["cells"]["ddbar"]["recurrence-fft"]["9"]
+    original = base["cells"]["ddbar"]["recurrence-fft"]["9"]
+    assert refreshed["metrics"]["warm_seconds_per_point"] == 109.0
+    assert (
+        refreshed["metrics"]["generation_seconds"]
+        == original["metrics"]["generation_seconds"]
+    )
+    assert refreshed["metrics"]["max_rss_kib"] == original["metrics"]["max_rss_kib"]
+    assert refreshed["runtime_refresh"]["fresh_process"] is True
+    assert refreshed["runtime_refresh"]["event_sha256"] == ["a" * 64] * 10
+    assert set(report["cells"]["gg"]["recurrence-direct"]) == set("23456")
+
+
+def test_clean_runtime_overlay_fails_closed_when_one_target_is_missing(
+    tmp_path: Path,
+) -> None:
+    scalar_path, canonical_path, high_path = _sources(tmp_path)
+    base = selected.build_selected_report(
+        scalar_path=scalar_path,
+        canonical_path=canonical_path,
+        high_path=high_path,
+    )
+    overlay = _clean_runtime_overlay(base)
+    del overlay["cells"]["ddbar"]["recurrence-fft"]["9"]
+    overlay_path = _write(tmp_path / "incomplete.json", overlay)
+
+    with pytest.raises(selected.CompositeError, match="exactly 46 measurable"):
+        selected.build_selected_report(
+            scalar_path=scalar_path,
+            canonical_path=canonical_path,
+            high_path=high_path,
+            runtime_overlay_path=overlay_path,
+        )
+
+
+def test_runtime_series_is_separate_from_the_46_existing_cells(
+    tmp_path: Path,
+) -> None:
+    scalar_path, canonical_path, high_path = _sources(tmp_path)
+    overlay_path = _write(tmp_path / "madgraph.json", _madgraph_overlay())
+
+    report = selected.build_selected_report(
+        scalar_path=scalar_path,
+        canonical_path=canonical_path,
+        high_path=high_path,
+        runtime_series_overlay_path=overlay_path,
+    )
+
+    assert report["summary"]["cell_status_counts"] == {
+        "failed": 2,
+        "measured": 46,
+        "skipped": 2,
+    }
+    assert report["summary"]["runtime_series_status_counts"] == {
+        "failed": 2,
+        "measured": 3,
+        "not-applicable": 7,
+        "skipped": 4,
+    }
+    assert (
+        report["runtime_series"]["gg"]["madgraph-standalone"]["4"][
+            "warm_seconds_per_point"
+        ]
+        == 4.0
+    )
+    assert report["runtime_series"]["gg"]["madgraph-standalone"]["4"]["metrics"] == {
+        "generation_seconds": 40.0,
+        "warm_seconds_per_point": 4.0,
+        "max_rss_kib": 4096.0,
+    }
+    assert "madgraph-standalone" not in report["cells"]["gg"]
+
+
+def test_runtime_series_uses_policy_warm_sample_count(tmp_path: Path) -> None:
+    scalar_path, canonical_path, high_path = _sources(tmp_path)
+    overlay = _madgraph_overlay()
+    overlay["policy"]["warm_sample_count"] = 1
+    for family_series in overlay["runtime_series"].values():
+        for cell in family_series["madgraph-standalone"].values():
+            if cell["status"] == "measured":
+                cell["warm_samples_seconds"] = [cell["warm_seconds_per_point"]]
+    overlay_path = _write(tmp_path / "madgraph.json", overlay)
+
+    report = selected.build_selected_report(
+        scalar_path=scalar_path,
+        canonical_path=canonical_path,
+        high_path=high_path,
+        runtime_series_overlay_path=overlay_path,
+    )
+
+    assert (
+        report["runtime_series"]["gg"]["madgraph-standalone"]["2"][
+            "warm_samples_seconds"
+        ]
+        == [2.0]
+    )
+
+
+def test_runtime_series_progress_accepts_authenticated_sparse_cells(
+    tmp_path: Path,
+) -> None:
+    scalar_path, canonical_path, high_path = _sources(tmp_path)
+    report = selected.build_selected_report(
+        scalar_path=scalar_path,
+        canonical_path=canonical_path,
+        high_path=high_path,
+    )
+    progress = _madgraph_overlay()
+    progress["kind"] = selected.RUNTIME_SERIES_PROGRESS_KIND
+    progress["policy"] = {"final_state_multiplicities": list(range(2, 10))}
+    progress["runtime_series"]["gg"]["madgraph-standalone"] = {
+        "2": progress["runtime_series"]["gg"]["madgraph-standalone"]["2"]
+    }
+    progress["runtime_series"]["ddbar"]["madgraph-standalone"] = {}
+    path = _write(tmp_path / "progress.json", progress)
+
+    selected.apply_runtime_series_source(
+        report,
+        selected.SourceReport(
+            key="progress",
+            path=path,
+            sha256="0" * 64,
+            payload=progress,
+        ),
+    )
+
+    assert set(report["runtime_series"]["gg"]["madgraph-standalone"]) == {"2"}
+    assert report["runtime_series"]["ddbar"]["madgraph-standalone"] == {}
+    assert report["plot_provenance"]["source_reports"]["progress"] == {
+        "path": str(path),
+        "sha256": "0" * 64,
+    }
+
+
+def test_summed_report_rejects_a_fixed_helicity_madgraph_overlay(
+    tmp_path: Path,
+) -> None:
+    scalar_path, canonical_path, high_path = _sources(tmp_path)
+    report = selected.build_selected_report(
+        scalar_path=scalar_path,
+        canonical_path=canonical_path,
+        high_path=high_path,
+    )
+    report["policy"]["measurement"].update(
+        {
+            "helicity_workload": "sum",
+            "warm_fixed_helicity": False,
+            "warm_helicity_sum": True,
+        }
+    )
+    overlay = _madgraph_overlay()
+    overlay["policy"] = {
+        "final_state_multiplicities": list(range(2, 10)),
+        "helicity_workload": "fixed",
+        "warm_fixed_helicity": True,
+        "warm_helicity_sum": False,
+    }
+    path = _write(tmp_path / "fixed-madgraph.json", overlay)
+
+    with pytest.raises(selected.CompositeError, match="differs from the report"):
+        selected.apply_runtime_series_source(
+            report,
+            selected.SourceReport(
+                key="fixed-madgraph",
+                path=path,
+                sha256="0" * 64,
+                payload=overlay,
+            ),
+        )
diff --git a/pyamplicol/tests/unit/test_fft_scaling_study.py b/pyamplicol/tests/unit/test_fft_scaling_study.py
new file mode 100644
index 0000000000..82ce9200f3
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fft_scaling_study.py
@@ -0,0 +1,1889 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib.util
+import json
+import statistics
+import sys
+from copy import deepcopy
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools" / "developer" / "fft_scaling_study.py"
+SPEC = importlib.util.spec_from_file_location("test_fft_scaling_study_module", SCRIPT)
+assert SPEC is not None and SPEC.loader is not None
+scaling = importlib.util.module_from_spec(SPEC)
+sys.modules[SPEC.name] = scaling
+SPEC.loader.exec_module(scaling)
+
+
+def test_watchdog_peak_rss_accepts_a_rounded_zero_for_short_children() -> None:
+    stderr = (
+        "memory-watchdog: command finished exit=0 peak_rss=0.000 GiB "
+        "peak_physical_footprint=0.001 GiB peak_guard=0.001 GiB"
+    )
+
+    assert scaling._parse_watchdog_peak_rss_kib(stderr) == 0
+
+
+def _pinned_summed_probe_source() -> bytes:
+    return (
+        "program probe\n"
+        + scaling._SUMMED_AMPLICOL_FERMION_GUARD
+        + "             continue\n"
+        + scaling._SUMMED_AMPLICOL_FALLBACK_GUARD
+        + "             continue\n"
+        + scaling._SUMMED_AMPLICOL_HELPER_ANCHOR
+        + "end program probe\n"
+    ).encode("utf-8")
+
+
+@pytest.mark.parametrize("body_raises", (False, True))
+def test_summed_amplicol_probe_overlay_restores_clean_pinned_source(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    body_raises: bool,
+) -> None:
+    repository = tmp_path / "amplicol"
+    repository.mkdir()
+    source = repository / "amplicol_color_library_probe.f03"
+    original = _pinned_summed_probe_source()
+    source.write_bytes(original)
+    source.chmod(0o640)
+    original_stat = source.stat()
+    monkeypatch.setattr(
+        scaling.legacy_amplicol,
+        "validate_checkout",
+        lambda checked: checked.samefile(repository),
+    )
+    monkeypatch.setattr(
+        scaling.legacy_amplicol,
+        "expected_revision",
+        lambda: "pinned-test-revision",
+    )
+    evidence = tmp_path / "evidence"
+    captured: dict[str, object] = {}
+
+    def exercise() -> None:
+        with scaling._summed_amplicol_probe_source_overlay(
+            repository, evidence
+        ) as record:
+            captured.update(record)
+            patched = source.read_bytes()
+            assert patched != original
+            assert b"fermion_relabel_is_unique" in patched
+            snapshot = evidence / "amplicol_color_library_probe.f03"
+            assert snapshot.read_bytes() == patched
+            if body_raises:
+                raise RuntimeError("body failed")
+
+    if body_raises:
+        with pytest.raises(RuntimeError, match="body failed"):
+            exercise()
+    else:
+        exercise()
+
+    restored_stat = source.stat()
+    assert source.read_bytes() == original
+    assert restored_stat.st_mode == original_stat.st_mode
+    assert restored_stat.st_size == original_stat.st_size
+    assert restored_stat.st_mtime_ns == original_stat.st_mtime_ns
+    manifest = json.loads((evidence / "provenance.json").read_text())
+    assert manifest["revision"] == "pinned-test-revision"
+    assert manifest["restoration"]["status"] == "restored"
+    assert manifest["restoration"]["body_exit"] == (
+        "exception" if body_raises else "success"
+    )
+    assert captured["original_sha256"] != captured["patched_sha256"]
+
+
+def test_summed_amplicol_campaign_skips_racy_preflight_checkout_validation(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    study_root = tmp_path / "study"
+    repository = tmp_path / "amplicol"
+    repository.mkdir()
+    monkeypatch.setattr(scaling, "STUDY_ROOT", study_root)
+    monkeypatch.setattr(scaling, "_study_environment", lambda _python: {})
+    monkeypatch.setattr(
+        scaling,
+        "_acquire_campaign_lock",
+        lambda: (tmp_path / "campaign.lock").open("a+", encoding="utf-8"),
+    )
+    monkeypatch.setattr(
+        scaling.legacy_amplicol,
+        "validate_checkout",
+        lambda _repository: pytest.fail(
+            "summed AmpliCol validation belongs inside the source overlay lock"
+        ),
+    )
+
+    def fake_inputs(
+        _report: object, _run_root: Path, family: str, final_multiplicity: int
+    ) -> tuple[tuple[Path, ...], tuple[int, ...]]:
+        assert family == "ddbar"
+        return (Path("event"),), scaling.fixed_ddbar_helicity(final_multiplicity)
+
+    def fake_amplicol_cell(**kwargs: object) -> dict[str, object]:
+        assert kwargs["arguments"].compare_helicity_sums is True
+        family = str(kwargs["family"])
+        final_multiplicity = int(kwargs["final_multiplicity"])
+        return scaling._cell_base(
+            family,
+            scaling.MODE_BY_KEY["amplicol"],
+            final_multiplicity,
+            sum_helicities=True,
+        ) | {"status": "measured"}
+
+    monkeypatch.setattr(scaling, "_inputs", fake_inputs)
+    monkeypatch.setattr(scaling, "_amplicol_cell", fake_amplicol_cell)
+    arguments = scaling._parser().parse_args(
+        (
+            "--run-id",
+            "summed-amplicol",
+            "--min-n",
+            "2",
+            "--max-n",
+            "2",
+            "--family",
+            "ddbar",
+            "--mode",
+            "amplicol",
+            "--amplicol-repository",
+            str(repository),
+            "--compare-helicity-sums",
+        )
+    )
+    scaling._validate_arguments(arguments)
+
+    report = scaling._campaign(arguments)
+
+    assert report["cells"]["ddbar"]["amplicol"]["2"]["status"] == "measured"
+
+
+def _amplicol_timing_output(points: int, total_seconds: float) -> str:
+    return (
+        "AmpliCol colour probe\n"
+        f"points {points}\n"
+        "generation setup 0.125 50.0% outside-runtime\n"
+        f"total {total_seconds:.17g} 100.0%\n"
+    )
+
+
+def test_amplicol_warm_sampling_grows_and_restarts_one_fixed_aggregate() -> None:
+    calls: list[tuple[int, int, int]] = []
+
+    def run_sample(sample_set: int, sample: int, repetitions: int) -> str:
+        calls.append((sample_set, sample, repetitions))
+        total = 0.20 if sample_set == 1 else 0.36 + sample * 0.001
+        return _amplicol_timing_output(repetitions, total)
+
+    measured = scaling._collect_amplicol_warm_samples(
+        seed_points=10,
+        seed_total_seconds=0.10,
+        target_seconds=0.25,
+        run_sample=run_sample,
+    )
+
+    assert calls == [(1, 1, 27), (2, 1, 36)]
+    assert measured.repetitions == 36
+    assert measured.sample_set_attempts == 2
+    assert len(measured.samples_seconds) == 1
+    assert min(measured.sample_totals_seconds) >= 0.25
+    assert statistics.median(measured.samples_seconds) == pytest.approx(0.361 / 36)
+
+
+def test_amplicol_timing_parser_retains_the_aggregate_duration() -> None:
+    output = _amplicol_timing_output(40, 0.4)
+
+    assert scaling._parse_amplicol_timing_aggregate(output) == (0.125, 0.4, 40)
+    assert scaling._parse_amplicol_timing(output) == (0.125, 0.01, 40)
+
+
+def test_amplicol_cell_uses_fresh_fixed_samples_and_program_rss(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    repository = tmp_path / "amplicol"
+    repository.mkdir()
+    event = tmp_path / "event"
+    event.write_text("mock event\n", encoding="utf-8")
+    helicity = (-1, 1, -1, 1)
+    momenta = (
+        (500.0, 0.0, 0.0, 500.0),
+        (500.0, 0.0, 0.0, -500.0),
+        (500.0, 500.0, 0.0, 0.0),
+        (500.0, -500.0, 0.0, 0.0),
+    )
+    entry = scaling.legacy_amplicol.ProcessEntry(1, 1, (1, -1, 1, -1), (1, 2, 3, 4))
+    monkeypatch.setattr(scaling, "_read_event", lambda _path: (momenta, helicity))
+    monkeypatch.setattr(
+        scaling.legacy_amplicol, "parse_process_file", lambda _path: [entry]
+    )
+    monkeypatch.setattr(
+        scaling.legacy_amplicol, "process_pdgs", lambda _process: entry.process_pdgs
+    )
+    monkeypatch.setattr(
+        scaling.legacy_amplicol,
+        "select_generated_process_entry",
+        lambda *_args, **_kwargs: (entry, [entry]),
+    )
+    monkeypatch.setattr(
+        scaling.legacy_amplicol,
+        "_permutation",
+        lambda source, _target: tuple(range(len(source))),
+    )
+    monkeypatch.setattr(
+        scaling.legacy_amplicol,
+        "_ordered_binary64_momenta",
+        lambda _source, _target, values: values,
+    )
+    monkeypatch.setattr(
+        scaling.legacy_amplicol,
+        "_parse_probe_output",
+        lambda _output: SimpleNamespace(value=2.0),
+    )
+
+    calls: list[dict[str, object]] = []
+
+    def fake_run_watched(
+        command: tuple[str, ...], **kwargs: object
+    ) -> scaling.performance.WatchedCompletedProcess:
+        log_path = Path(str(kwargs["log_path"]))
+        environment = dict(kwargs["environment"])
+        watchdog_report = Path(str(kwargs["watchdog_report_path"]))
+        calls.append(
+            {
+                "log_path": log_path,
+                "environment": environment,
+                "watchdog_report": watchdog_report,
+            }
+        )
+        if log_path.name == "process-generation.json":
+            return scaling.performance.WatchedCompletedProcess(
+                command,
+                0,
+                "",
+                "memory-watchdog: peak_rss=0.001 GiB peak_guard=0.009 GiB\n",
+                elapsed_seconds=1.0,
+                log_write_seconds=0.0,
+                timed_out=False,
+                timeout_cleanup="not-required",
+                peak_rss_kib=1_500,
+                peak_guard_kib=9_000,
+            )
+
+        if log_path.name == "probe.json":
+            points, total, child_rss = 10, 0.10, 1_100
+        elif "warm-sample-set-01" in log_path.name:
+            sample = int(log_path.stem.rsplit("-", 1)[1])
+            points = 27
+            total = 0.20
+            child_rss = 1_200 + 100 * sample
+        else:
+            sample = int(log_path.stem.rsplit("-", 1)[1])
+            points = 36
+            total = 0.36 + sample * 0.001
+            child_rss = 1_500 + 100 * sample
+        stderr = (
+            f"{scaling.RSS_MARKER} {child_rss}\n"
+            "memory-watchdog: peak_rss=0.008 GiB peak_guard=0.010 GiB\n"
+        )
+        return scaling.performance.WatchedCompletedProcess(
+            command,
+            0,
+            _amplicol_timing_output(points, total),
+            stderr,
+            elapsed_seconds=0.5,
+            log_write_seconds=0.0,
+            timed_out=False,
+            timeout_cleanup="not-required",
+            peak_rss_kib=8_000,
+            peak_guard_kib=10_000,
+        )
+
+    monkeypatch.setattr(scaling.performance, "_run_watched", fake_run_watched)
+    arguments = scaling._parser().parse_args(
+        (
+            "--run-id",
+            "amplicol-protocol",
+            "--family",
+            "ddbar",
+            "--mode",
+            "amplicol",
+            "--batch-size",
+            "1",
+            "--target-seconds",
+            "0.25",
+            "--python",
+            sys.executable,
+            "--amplicol-repository",
+            str(repository),
+        )
+    )
+
+    cell = scaling._amplicol_cell(
+        arguments=arguments,
+        family="ddbar",
+        final_multiplicity=2,
+        events=(event,),
+        helicity=helicity,
+        baseline=None,
+        run_root=tmp_path / "run",
+        environment={},
+    )
+
+    probe_calls = [
+        call
+        for call in calls
+        if Path(call["log_path"]).name != "process-generation.json"
+    ]
+    assert len(calls) == 4
+    assert len(probe_calls) == 3
+    assert len({Path(call["log_path"]) for call in calls}) == len(calls)
+    assert len({Path(call["watchdog_report"]) for call in calls}) == len(calls)
+    assert probe_calls[0]["environment"] == {
+        "AMPICOL_COLOR_PROBE_TARGET_RUNTIME_S": "0.25"
+    }
+    assert all(
+        "AMPICOL_COLOR_PROBE_TARGET_RUNTIME_S" not in call["environment"]
+        for call in probe_calls[1:]
+    )
+    assert cell["warm_repetitions"] == [36]
+    assert cell["warm_sample_set_attempts"] == 2
+    assert min(cell["warm_sample_totals_seconds"]) >= 0.25
+    assert cell["metrics"]["warm_seconds_per_point"] == pytest.approx(0.361 / 36)
+    assert cell["metrics"]["max_rss_kib"] == 1_600
+    assert cell["resource_peaks_kib"] == {
+        "generation": 1_500,
+        "generation_guard": 9_000,
+        "runtime_self": 1_600,
+        "runtime_watchdog": 8_000,
+        "runtime_guard": 10_000,
+        "runtime_watchdog_included_in_plotted_rss": False,
+    }
+
+
+def test_publication_defaults_use_strict_one_hour_and_30_gib_frontiers() -> None:
+    arguments = scaling._parser().parse_args(())
+    plan = scaling.dry_run_plan(arguments)
+
+    assert arguments.generation_timeout == 3600.0
+    assert arguments.runtime_timeout == 3600.0
+    assert arguments.memory_limit_gib == 30.0
+    assert arguments.target_seconds == 180.0
+    assert (
+        "median of 1 independent process-CPU aggregate"
+        in plan["measurement"]["warm_timing_metric"]["amplicol"]
+    )
+    assert (
+        "Fortran runtime child peak RSS" in plan["measurement"]["amplicol_rss_metric"]
+    )
+    assert scaling._require_bounded_rss(30 * 1024**2 - 1, 30.0) > 0
+    with pytest.raises(scaling.StudyError, match=r"strict <30 GiB"):
+        scaling._require_bounded_rss(30 * 1024**2, 30.0)
+
+
+def test_resume_accepts_sampling_and_resource_policy_updates(tmp_path: Path) -> None:
+    study_root = tmp_path / "study"
+    arguments = scaling._parser().parse_args(
+        (
+            "--study-root",
+            str(study_root),
+            "--run-id",
+            "campaign",
+            "--multiplicity",
+            "5",
+            "--family",
+            "gg",
+            "--mode",
+            "reference-fft",
+            "--resume",
+        )
+    )
+    report = scaling._empty_report(arguments)
+    stale_policy = deepcopy(report["policy"])
+    measurement = stale_policy["measurement"]
+    measurement["calibration_target_seconds"] = 0.25
+    measurement["candidate_profile_target_runtime_seconds"] = 0.25
+    measurement["candidate_profile_warmup_runs"] = 2
+    measurement["candidate_profile_minimum_samples"] = 10
+    measurement["warm_samples"] = 10
+    measurement["warm_sample_count"] = 10
+    measurement["warm_timing_metric"] = {"pyamplicol": "old short sampling"}
+    measurement["generation_timeout_seconds"] = 60.0
+    measurement["runtime_timeout_seconds"] = 60.0
+    measurement["requested_memory_ceiling_gib"] = 10.0
+    measurement["memory_watchdog_gib"] = 10.0
+    measurement["cell_admission_limits"] = {}
+    stale_policy["run_root"] = "/old/shard/layout"
+    report["policy"] = stale_policy
+    path = study_root / "runs" / "campaign" / "report.json"
+    path.parent.mkdir(parents=True)
+    path.write_text(json.dumps(report), encoding="utf-8")
+
+    loaded = scaling._load_report(path, arguments)
+
+    assert loaded["policy"] == scaling.dry_run_plan(arguments)
+
+    stale_policy["measurement"]["alpha_s"] = 0.2
+    report["policy"] = stale_policy
+    path.write_text(json.dumps(report), encoding="utf-8")
+    with pytest.raises(
+        scaling.StudyError,
+        match="resume arguments differ from the stored study policy",
+    ):
+        scaling._load_report(path, arguments)
+
+
+def test_publication_generation_uses_normal_optimized_defaults() -> None:
+    command = scaling._candidate_generation_command(
+        python="python-test",
+        family="ddbar",
+        final_multiplicity=7,
+        mode=scaling.MODE_BY_KEY["compiled-direct"],
+        artifact=Path("artifact"),
+        batch_size=1,
+    )
+
+    assert "--no-numerical-current-reuse" not in command
+    assert "--no-emit-api-bundle" not in command
+    assert "--workers" not in command
+    assert "--progress" not in command
+    assert "--log-level" not in command
+    assert "generation.validation.enabled=false" not in command
+    assert "generation.validation.post_build_validation=false" not in command
+    assert "model.cache=false" not in command
+    assert "evaluator.optimization.cores=1" not in command
+    assert "evaluator.jit.optimization_level=2" not in command
+    assert not any(
+        value.startswith("process.selected_source_helicities=") for value in command
+    )
+    assert command[command.index("--set") + 1] == "evaluator.batch_size=1"
+
+
+def test_timed_command_uses_python_getrusage_wrapper_on_linux(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(scaling.sys, "platform", "linux")
+
+    command, normalizer = scaling._timed_command(("payload",), python="python-test")
+
+    assert command == (
+        "python-test",
+        str(scaling.Path(scaling.__file__).resolve()),
+        "_time-rss",
+        "payload",
+    )
+    assert normalizer is None
+
+
+def _higher_n_arguments() -> object:
+    return scaling._parser().parse_args(
+        (
+            "--run-id",
+            "higher-n-scalar",
+            "--min-n",
+            "7",
+            "--max-n",
+            "10",
+            "--family",
+            "gg",
+            "--family",
+            "ddbar",
+            "--mode",
+            "reference-fft",
+            "--mode",
+            "amplicol",
+            "--mode",
+            "recurrence-fft",
+            "--batch-size",
+            "1",
+            "--generation-timeout",
+            "3600",
+            "--runtime-timeout",
+            "3600",
+            "--memory-limit-gib",
+            "20",
+        )
+    )
+
+
+def test_higher_n_scalar_policy_selects_only_requested_curves() -> None:
+    arguments = _higher_n_arguments()
+    scaling._validate_arguments(arguments)
+
+    plan = scaling.dry_run_plan(arguments)
+    assert plan["final_state_multiplicities"] == [7, 8, 9, 10]
+    assert plan["total_external_particles"] == [9, 10, 11, 12]
+    assert plan["measurement"]["warm_benchmark_batch_size"] == 1
+    assert plan["process_families"]["gg"]["modes"] == [
+        "reference-fft",
+        "amplicol",
+        "recurrence-fft",
+    ]
+    assert plan["process_families"]["ddbar"]["modes"] == [
+        "amplicol",
+        "recurrence-fft",
+    ]
+    assert set(scaling._empty_report(arguments)["cells"]) == {"gg", "ddbar"}
+
+
+def test_fft_steering_adds_applicable_pairs_and_records_provenance() -> None:
+    arguments = scaling._parser().parse_args(
+        (
+            "--family",
+            "gg",
+            "--mode",
+            "reference-fft",
+            "--mode",
+            "recurrence-direct",
+            "--mode",
+            "compiled-direct",
+            "--fft",
+        )
+    )
+    scaling._validate_arguments(arguments)
+
+    plan = scaling.dry_run_plan(arguments)
+    assert plan["fft_enabled"] is True
+    assert plan["process_families"]["gg"]["modes"] == [
+        "reference-fft",
+        "recurrence-direct",
+        "recurrence-fft",
+        "compiled-direct",
+    ]
+    assert plan["selected_pyamplicol_color_contractions"] == {
+        "recurrence": ["direct", "symmetric-group-fft"],
+        "compiled": ["direct"],
+    }
+    assert plan["measurement"]["generation_helicity_coverage"] == "all"
+    assert plan["measurement"]["warm_fixed_helicity"] is True
+    assert "fixed_helicity" not in plan["measurement"]
+    assert plan["measurement"]["compiled_fft_enabled"] is False
+
+
+def test_helicity_sum_policy_has_separate_identity_and_count_semantics() -> None:
+    fixed_arguments = scaling._parser().parse_args(("--multiplicity", "2"))
+    sum_arguments = scaling._parser().parse_args(
+        ("--multiplicity", "2", "--compare-helicity-sums")
+    )
+
+    fixed = scaling.dry_run_plan(fixed_arguments)["measurement"]
+    summed = scaling.dry_run_plan(sum_arguments)["measurement"]
+
+    assert fixed["warm_fixed_helicity"] is True
+    assert "helicity_workload" not in fixed
+    assert summed["helicity_workload"] == "sum"
+    assert summed["warm_fixed_helicity"] is False
+    assert summed["warm_helicity_sum"] is True
+    assert "candidate_timed_helicity_contract" in summed
+    semantics = summed["helicity_count_semantics"]
+    assert "complete physical API axis" in semantics["candidate"]
+    assert "analytic-nonzero subset" in semantics["reference_fft"]
+    assert "does not expose that retained count" in semantics["amplicol"]
+    assert "hel_fac filter" in semantics["amplicol"]
+    assert "generated-library" in summed["generation_metric"]["amplicol"]
+
+
+def test_compiled_fft_is_explicitly_not_applicable_to_publication() -> None:
+    cell = scaling._compiled_fft_not_applicable_cell(
+        family="gg",
+        mode=scaling.MODE_BY_KEY["compiled-fft"],
+        final_multiplicity=6,
+    )
+
+    assert cell is not None
+    assert cell["status"] == "not-applicable"
+    assert cell["censors_higher_multiplicities"] is False
+    assert cell["applicability"] == {
+        "compiled_direct": True,
+        "compiled_fft": False,
+        "reason_code": "publication-requires-all-runtime-helicities",
+    }
+    assert "all runtime helicities" in cell["failure_reason"]
+    assert "compiled-direct remains supported" in cell["failure_reason"]
+
+
+def test_sum_nonmeasurement_cells_keep_summed_workload_markers() -> None:
+    compiled = scaling._compiled_fft_not_applicable_cell(
+        family="gg",
+        mode=scaling.MODE_BY_KEY["compiled-fft"],
+        final_multiplicity=6,
+        sum_helicities=True,
+    )
+    otf = scaling.otf_protocol_scope_cell(
+        family="gg",
+        mode=scaling.MODE_BY_KEY["otf-direct"],
+        final_multiplicity=7,
+        sum_helicities=True,
+    )
+
+    for cell in (compiled, otf):
+        assert cell is not None
+        assert cell["helicity_workload"] == "sum"
+        assert cell["warm_fixed_helicity"] is False
+        assert cell["warm_helicity_sum"] is True
+
+
+def test_fixed_helicity_otf_frontier_matches_summed_n6_limit() -> None:
+    mode = scaling.MODE_BY_KEY["otf-direct"]
+
+    for sum_helicities in (False, True):
+        assert (
+            scaling.otf_protocol_scope_cell(
+                family="gg",
+                mode=mode,
+                final_multiplicity=6,
+                sum_helicities=sum_helicities,
+            )
+            is None
+        )
+    fixed_n7 = scaling.otf_protocol_scope_cell(
+        family="gg",
+        mode=mode,
+        final_multiplicity=7,
+    )
+    assert fixed_n7 is not None
+    assert fixed_n7["failed_at_n"] == 7
+    assert "n<=6" in fixed_n7["failure_reason"]
+
+    assert (
+        scaling.otf_protocol_scope_cell(
+            family="gg",
+            mode=mode,
+            final_multiplicity=7,
+            maximum_multiplicity=8,
+        )
+        is None
+    )
+    extended_n9 = scaling.otf_protocol_scope_cell(
+        family="gg",
+        mode=mode,
+        final_multiplicity=9,
+        maximum_multiplicity=8,
+    )
+    assert extended_n9 is not None
+    assert extended_n9["failed_at_n"] == 9
+    assert "n<=8" in extended_n9["failure_reason"]
+
+
+def test_publication_artifact_requires_complete_reusable_helicities(
+    tmp_path: Path,
+) -> None:
+    physics_path = tmp_path / "processes" / "gg_n2" / "physics.json"
+    physics_path.parent.mkdir(parents=True)
+    physics = {
+        "coverage": {"helicities": "complete"},
+        "extensions": {
+            "runtime_selectors": {
+                "axes": {
+                    "helicity": {
+                        "generation_coverage": "complete",
+                        "generation_selection": {},
+                        "runtime_contract": "complete-reusable",
+                    }
+                },
+                "generation_specialized_axes": [],
+            }
+        },
+        "helicities": [{"id": f"h:{index}"} for index in range(16)],
+    }
+    physics_path.write_text(json.dumps(physics), encoding="utf-8")
+
+    assert scaling._validate_publication_candidate_artifact(tmp_path, "gg_n2") == 16
+
+    physics["extensions"]["runtime_selectors"]["axes"]["helicity"] = {
+        "generation_coverage": "selected",
+        "generation_selection": {"1": 1},
+        "runtime_contract": "generation-specialized",
+    }
+    physics_path.write_text(json.dumps(physics), encoding="utf-8")
+    with pytest.raises(scaling.StudyError, match="not reusable"):
+        scaling._validate_publication_candidate_artifact(tmp_path, "gg_n2")
+
+
+def _publication_otf_execution() -> dict[str, object]:
+    return {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-on-the-fly-execution",
+        "selector_policy": {
+            "color_coverage": "contracted",
+            "selector_census": {"physical_helicity_count": 4},
+        },
+        "runtime_metadata": {
+            "process_seed_identity": {
+                "external_sources": [
+                    {
+                        "source_slot": 0,
+                        "states": [
+                            {"state_index": 0, "public_helicity": -1},
+                            {"state_index": 1, "public_helicity": 1},
+                        ],
+                    },
+                    {
+                        "source_slot": 1,
+                        "states": [
+                            {"state_index": 0, "public_helicity": -1},
+                            {"state_index": 1, "public_helicity": 1},
+                        ],
+                    },
+                ]
+            }
+        },
+    }
+
+
+def _write_publication_otf_execution(
+    root: Path, execution: object, *, raw: str | None = None
+) -> None:
+    path = root / "processes" / "gg_n2" / "execution.json"
+    path.parent.mkdir(parents=True)
+    path.write_text(raw if raw is not None else json.dumps(execution), encoding="utf-8")
+
+
+def test_publication_artifact_accepts_otf_seed_helicity_census(tmp_path: Path) -> None:
+    _write_publication_otf_execution(tmp_path, _publication_otf_execution())
+
+    assert scaling._validate_publication_candidate_artifact(tmp_path, "gg_n2") == 4
+
+
+@pytest.mark.parametrize(
+    "corruption",
+    (
+        "schema",
+        "kind",
+        "coverage",
+        "small-census",
+        "census-mismatch",
+        "source-slot",
+        "state-index",
+        "public-helicity",
+    ),
+)
+def test_publication_artifact_rejects_corrupt_otf_helicity_contract(
+    tmp_path: Path, corruption: str
+) -> None:
+    execution = deepcopy(_publication_otf_execution())
+    selector = execution["selector_policy"]
+    assert isinstance(selector, dict)
+    census = selector["selector_census"]
+    assert isinstance(census, dict)
+    runtime_metadata = execution["runtime_metadata"]
+    assert isinstance(runtime_metadata, dict)
+    identity = runtime_metadata["process_seed_identity"]
+    assert isinstance(identity, dict)
+    sources = identity["external_sources"]
+    assert isinstance(sources, list)
+    first_source = sources[0]
+    second_source = sources[1]
+    assert isinstance(first_source, dict) and isinstance(second_source, dict)
+    first_states = first_source["states"]
+    assert isinstance(first_states, list)
+
+    if corruption == "schema":
+        execution["schema_version"] = 2
+    elif corruption == "kind":
+        execution["kind"] = "pyamplicol-runtime-recurrence-execution"
+    elif corruption == "coverage":
+        selector["color_coverage"] = "complete"
+    elif corruption == "small-census":
+        census["physical_helicity_count"] = 1
+    elif corruption == "census-mismatch":
+        census["physical_helicity_count"] = 8
+    elif corruption == "source-slot":
+        second_source["source_slot"] = 0
+    elif corruption == "state-index":
+        assert isinstance(first_states[1], dict)
+        first_states[1]["state_index"] = 0
+    elif corruption == "public-helicity":
+        assert isinstance(first_states[1], dict)
+        first_states[1]["public_helicity"] = -1
+    else:  # pragma: no cover - parametrization is exhaustive
+        raise AssertionError(corruption)
+
+    _write_publication_otf_execution(tmp_path, execution)
+    with pytest.raises(scaling.StudyError):
+        scaling._validate_publication_candidate_artifact(tmp_path, "gg_n2")
+
+
+def test_publication_artifact_rejects_malformed_otf_execution(tmp_path: Path) -> None:
+    _write_publication_otf_execution(tmp_path, {}, raw="{")
+
+    with pytest.raises(scaling.StudyError):
+        scaling._validate_publication_candidate_artifact(tmp_path, "gg_n2")
+
+
+def test_higher_n_process_and_reference_seed_are_unbounded_above_n7() -> None:
+    assert scaling.process_expression("gg", 8) == "g g > g g g g g g g g"
+    assert scaling.process_expression("ddbar", 8) == "d d~ > d d~ g g g g g g"
+    assert scaling.performance.generator_seed(12) == scaling.performance.BASE_SEED + 12
+    with pytest.raises(scaling.performance.AcceptanceError):
+        scaling.performance.generator_seed(3)
+
+
+def test_only_resource_failures_censor_a_curve(tmp_path: Path) -> None:
+    base = scaling._cell_base("gg", scaling.MODE_BY_KEY["recurrence-fft"], 8)
+    resource = scaling._failure_cell(
+        base,
+        scaling._CellResourceLimitError(
+            "candidate artifact generation exhausted the cold cap",
+            category="generation-time-limit",
+        ),
+        tmp_path,
+    )
+    correctness = scaling._failure_cell(
+        base,
+        scaling.StudyError("candidate numerical comparison failed"),
+        tmp_path,
+    )
+    legacy_runtime = scaling._failure_cell(
+        base,
+        scaling.legacy_report.ProfilingTimeLimitError(
+            "legacy profiling stage exhausted its remaining budget"
+        ),
+        tmp_path,
+    )
+
+    assert resource["failure_category"] == "generation-time-limit"
+    assert resource["censors_higher_multiplicities"] is True
+    assert correctness["failure_category"] == "error"
+    assert correctness["censors_higher_multiplicities"] is False
+    assert legacy_runtime["failure_category"] == "runtime-time-limit"
+    assert legacy_runtime["censors_higher_multiplicities"] is True
+
+
+def _write_watched_command_record(
+    path: Path,
+    *,
+    timed_out: bool,
+    returncode: int,
+    watchdog_report: Path | None = None,
+    command: list[str] | None = None,
+    stdout: str | None = None,
+    stderr: str | None = None,
+) -> None:
+    command = command or ["amplicol_color_library_probe", "1"]
+    watchdog_command = [
+        sys.executable,
+        str(scaling.performance.WATCHDOG),
+        "--limit-gib",
+        "30",
+        "--",
+        *command,
+    ]
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(
+            {
+                "command": command,
+                "watchdog_command": watchdog_command,
+                "elapsed_seconds": 0.75,
+                "returncode": returncode,
+                "stdout": stdout
+                if stdout is not None
+                else (
+                    "Could not map colour row to generated-library integral 2\n"
+                    "row permutation: 3 1 2 4\n"
+                ),
+                "stderr": stderr
+                if stderr is not None
+                else "timing metadata: runtime was below its deadline",
+                "timed_out": timed_out,
+                "timeout_cleanup": "not-required",
+                "watchdog_report": (
+                    None if watchdog_report is None else str(watchdog_report)
+                ),
+            }
+        ),
+        encoding="utf-8",
+    )
+
+
+def test_structural_command_failure_is_not_misclassified_as_a_resource_limit(
+    tmp_path: Path,
+) -> None:
+    command_log = tmp_path / "commands" / "008-amplicol_color_library_probe.json"
+    _write_watched_command_record(
+        command_log,
+        timed_out=False,
+        returncode=1,
+    )
+    _write_watched_command_record(
+        tmp_path / "commands" / "stale-timeout.json",
+        timed_out=True,
+        returncode=-15,
+    )
+    base = scaling._cell_base("ddbar", scaling.MODE_BY_KEY["amplicol"], 2)
+    cell = scaling._failure_cell(
+        base,
+        scaling._CellCommandError(
+            "AmpliCol generated-library runtime command failed: "
+            f"command failed with status 1; see {command_log}",
+            timeout_category="runtime-time-limit",
+        ),
+        tmp_path,
+    )
+
+    assert cell["failure_category"] == "error"
+    assert cell["censors_higher_multiplicities"] is False
+
+
+def test_legacy_amplicol_colour_init_segfault_censors_the_curve(
+    tmp_path: Path,
+) -> None:
+    command_log = tmp_path / "amplicol" / "ddbar" / "n9" / "probe.json"
+    _write_watched_command_record(
+        command_log,
+        command=["amplicol_color_probe", "1000000000", "2", "1", "full"],
+        timed_out=False,
+        returncode=245,
+        stdout="Initialising amplitude for:\n",
+        stderr=(
+            "Program received signal SIGSEGV: Segmentation fault - invalid memory "
+            "reference.\n"
+            "#1 0x000000 in __amplitude_qcd_mod_MOD_init_col\n"
+        ),
+    )
+    base = scaling._cell_base("ddbar", scaling.MODE_BY_KEY["amplicol"], 9)
+    cell = scaling._failure_cell(
+        base,
+        scaling._CellCommandError(
+            "AmpliCol setup/runtime probe failed: "
+            f"command failed with status 245; see {command_log}",
+            timeout_category="setup-or-runtime-time-limit",
+        ),
+        tmp_path,
+    )
+
+    assert (
+        cell["failure_category"] == scaling.LEGACY_AMPLICOL_STRUCTURAL_LIMIT_CATEGORY
+    )
+    assert (
+        cell["failure_reason_short"]
+        == "legacy AmpliCol structural colour-init limit"
+    )
+    assert cell["censors_higher_multiplicities"] is True
+
+
+def test_loaded_legacy_amplicol_colour_init_segfault_report_is_normalized(
+    tmp_path: Path,
+) -> None:
+    run_root = tmp_path / "historical-aggregate"
+    command_log = tmp_path / "isolated" / "cells" / "n9" / "probe.json"
+    _write_watched_command_record(
+        command_log,
+        command=["amplicol_color_probe", "1000000000", "2", "1", "full"],
+        timed_out=False,
+        returncode=245,
+        stdout="Initialising amplitude for:\n",
+        stderr=(
+            "Program received signal SIGSEGV: Segmentation fault - invalid memory "
+            "reference.\n"
+            "#1 0x000000 in __amplitude_qcd_mod_MOD_init_col\n"
+        ),
+    )
+    report: dict[str, object] = {
+        "cells": {
+            "ddbar": {
+                "amplicol": {
+                    "9": {
+                        "status": "failed",
+                        "censors_higher_multiplicities": False,
+                        "failure_category": "error",
+                        "failure_reason": (
+                            "AmpliCol setup/runtime probe failed: "
+                            f"command failed with status 245; see {command_log}"
+                        ),
+                    }
+                }
+            }
+        }
+    }
+
+    assert scaling.normalize_loaded_failure_cells(report, run_root) is True
+
+    cell = report["cells"]["ddbar"]["amplicol"]["9"]  # type: ignore[index]
+    assert (
+        cell["failure_category"] == scaling.LEGACY_AMPLICOL_STRUCTURAL_LIMIT_CATEGORY
+    )
+    assert cell["censors_higher_multiplicities"] is True
+
+
+def test_typed_watched_command_timeout_censors_the_curve(tmp_path: Path) -> None:
+    command_log = tmp_path / "commands" / "probe.json"
+    _write_watched_command_record(
+        command_log,
+        timed_out=True,
+        returncode=-15,
+    )
+    base = scaling._cell_base("ddbar", scaling.MODE_BY_KEY["amplicol"], 2)
+    cell = scaling._failure_cell(
+        base,
+        scaling._CellCommandError(
+            f"runtime command failed; see {command_log}",
+            timeout_category="runtime-time-limit",
+        ),
+        tmp_path,
+    )
+
+    assert cell["failure_category"] == "runtime-time-limit"
+    assert cell["censors_higher_multiplicities"] is True
+
+
+def test_candidate_generation_retries_symbolica_single_instance_busy(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    arguments = scaling._parser().parse_args(
+        ("--generation-timeout", "60", "--memory-limit-gib", "100")
+    )
+    mode = scaling.MODE_BY_KEY["recurrence-direct"]
+    environment = {
+        scaling.SYMBOLICA_GENERATION_LOCK_ENV: str(tmp_path / "symbolica.lock")
+    }
+    calls: list[tuple[str, ...]] = []
+    sleeps: list[float] = []
+
+    def fake_run_watched(
+        command: tuple[str, ...], **kwargs: object
+    ) -> scaling.performance.WatchedCompletedProcess:
+        calls.append(tuple(command))
+        log_path = Path(str(kwargs["log_path"]))
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        if len(calls) == 1:
+            log_path.write_text(
+                json.dumps(
+                    {
+                        "command": list(command),
+                        "elapsed_seconds": 1.0,
+                        "returncode": 134,
+                        "stdout": scaling.SYMBOLICA_LICENSE_BUSY_FRAGMENT,
+                        "stderr": "",
+                        "timed_out": False,
+                        "timeout_cleanup": "not-required",
+                    }
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+            raise scaling.performance.AcceptanceError("generation failed")
+        log_path.write_text(
+            json.dumps(
+                {
+                    "command": list(command),
+                    "elapsed_seconds": 1.0,
+                    "returncode": 0,
+                    "stdout": "",
+                    "stderr": "",
+                    "timed_out": False,
+                    "timeout_cleanup": "not-required",
+                }
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        return scaling.performance.WatchedCompletedProcess(
+            command,
+            0,
+            "",
+            "",
+            elapsed_seconds=1.0,
+            log_write_seconds=0.0,
+            timed_out=False,
+            timeout_cleanup="not-required",
+        )
+
+    monkeypatch.setattr(scaling.performance, "_run_watched", fake_run_watched)
+    monkeypatch.setattr(scaling.time, "sleep", lambda seconds: sleeps.append(seconds))
+
+    result = scaling._run_candidate_generation(
+        arguments=arguments,
+        family="ddbar",
+        final_multiplicity=2,
+        mode=mode,
+        artifact=tmp_path / "cell" / "artifact",
+        cell_root=tmp_path / "cell",
+        environment=environment,
+    )
+
+    assert result.returncode == 0
+    assert len(calls) == 2
+    assert sleeps == [scaling.SYMBOLICA_BUSY_RETRY_SECONDS]
+
+
+def test_symbolica_generation_lock_is_skipped_for_explicit_license() -> None:
+    assert (
+        scaling._symbolica_generation_lock_path({"SYMBOLICA_LICENSE": "configured"})
+        is None
+    )
+    assert (
+        scaling._symbolica_generation_lock_path(
+            {"SYMBOLICA_LICENSE": "configured"}, force=True
+        )
+        is not None
+    )
+
+
+@pytest.mark.parametrize("with_report", [False, True])
+def test_watchdog_memory_limit_outcome_censors_the_curve(
+    tmp_path: Path, with_report: bool
+) -> None:
+    watchdog_report = tmp_path / "commands" / "probe.watchdog.json"
+    if with_report:
+        watchdog_report.parent.mkdir(parents=True)
+        watchdog_report.write_text(
+            json.dumps(
+                {
+                    "kind": scaling.memory_watchdog.WATCHDOG_REPORT_KIND,
+                    "schema_version": scaling.memory_watchdog.WATCHDOG_REPORT_SCHEMA,
+                    "complete": True,
+                    "execution": {"outcome": "memory-limit-exceeded"},
+                }
+            ),
+            encoding="utf-8",
+        )
+    command_log = tmp_path / "commands" / "probe.json"
+    _write_watched_command_record(
+        command_log,
+        timed_out=False,
+        returncode=scaling.memory_watchdog.MEMORY_LIMIT_EXIT_CODE,
+        watchdog_report=watchdog_report if with_report else None,
+    )
+    base = scaling._cell_base("gg", scaling.MODE_BY_KEY["recurrence-fft"], 8)
+    cell = scaling._failure_cell(
+        base,
+        scaling.StudyError(f"command failed; see {command_log}"),
+        tmp_path,
+    )
+
+    assert cell["failure_category"] == "memory-limit"
+    assert cell["censors_higher_multiplicities"] is True
+
+
+def test_selection_validation_requires_oracles_and_supported_scalar_modes() -> None:
+    missing_oracle = scaling._parser().parse_args(
+        ("--family", "ddbar", "--mode", "recurrence-fft")
+    )
+    with pytest.raises(scaling.StudyError, match="require --mode amplicol"):
+        scaling._validate_arguments(missing_oracle)
+
+    compiled_fft_scalar = scaling._parser().parse_args(
+        (
+            "--family",
+            "gg",
+            "--mode",
+            "reference-fft",
+            "--mode",
+            "compiled-fft",
+            "--batch-size",
+            "1",
+        )
+    )
+    scaling._validate_arguments(compiled_fft_scalar)
+
+    compiled_scalar = scaling._parser().parse_args(
+        (
+            "--family",
+            "gg",
+            "--mode",
+            "reference-fft",
+            "--mode",
+            "compiled-direct",
+            "--batch-size",
+            "1",
+        )
+    )
+    with pytest.raises(scaling.StudyError, match="not supported for compiled"):
+        scaling._validate_arguments(compiled_scalar)
+
+
+def test_correctness_failure_is_recorded_then_retried_on_resume(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    study_root = tmp_path / "study"
+    monkeypatch.setattr(scaling, "STUDY_ROOT", study_root)
+    monkeypatch.setattr(scaling, "_study_environment", lambda _python: {})
+    monkeypatch.setattr(
+        scaling,
+        "_acquire_campaign_lock",
+        lambda: (tmp_path / "campaign.lock").open("a+", encoding="utf-8"),
+    )
+    monkeypatch.setattr(scaling.performance, "_load_reference_module", lambda: object())
+    attempts = 0
+
+    def fake_reference_cell(**kwargs: object) -> dict[str, object]:
+        nonlocal attempts
+        attempts += 1
+        if attempts == 1:
+            raise scaling.StudyError("reference numerical comparison failed")
+        final_multiplicity = int(kwargs["final_multiplicity"])
+        return scaling._cell_base(
+            "gg", scaling.MODE_BY_KEY["reference-fft"], final_multiplicity
+        ) | {"status": "measured"}
+
+    monkeypatch.setattr(scaling, "_reference_cell", fake_reference_cell)
+    common = (
+        "--run-id",
+        "retry-correctness",
+        "--min-n",
+        "7",
+        "--max-n",
+        "7",
+        "--family",
+        "gg",
+        "--mode",
+        "reference-fft",
+    )
+    first = scaling._parser().parse_args(common)
+    scaling._validate_arguments(first)
+    with pytest.raises(scaling.StudyError, match="repair it, then resume"):
+        scaling._campaign(first)
+
+    report_path = study_root / "runs" / "retry-correctness" / "report.json"
+    stopped = json.loads(report_path.read_text(encoding="utf-8"))
+    failed = stopped["cells"]["gg"]["reference-fft"]["7"]
+    assert stopped["status"] == "stopped-correctness-failure"
+    assert failed["status"] == "failed"
+    assert failed["censors_higher_multiplicities"] is False
+
+    resumed = scaling._parser().parse_args((*common, "--resume"))
+    scaling._validate_arguments(resumed)
+    completed = scaling._campaign(resumed)
+    assert attempts == 2
+    assert completed["status"] == "complete"
+    assert completed["failure_count"] == 0
+    assert completed["cells"]["gg"]["reference-fft"]["7"]["status"] == "measured"
+
+
+def test_resume_retries_lower_resource_failure_below_retained_measurement(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    study_root = tmp_path / "study"
+    monkeypatch.setattr(scaling, "STUDY_ROOT", study_root)
+    monkeypatch.setattr(scaling, "_study_environment", lambda _python: {})
+    monkeypatch.setattr(
+        scaling,
+        "_acquire_campaign_lock",
+        lambda: (tmp_path / "campaign.lock").open("a+", encoding="utf-8"),
+    )
+    monkeypatch.setattr(scaling.performance, "_load_reference_module", lambda: object())
+    common = (
+        "--run-id",
+        "retry-lower-frontier",
+        "--multiplicity",
+        "2",
+        "--multiplicity",
+        "8",
+        "--fill-multiplicity",
+        "2",
+        "--family",
+        "gg",
+        "--mode",
+        "reference-fft",
+        "--resume",
+    )
+    arguments = scaling._parser().parse_args(common)
+    scaling._validate_arguments(arguments)
+    report = scaling._empty_report(arguments)
+    curve = report["cells"]["gg"]["reference-fft"]
+    curve["2"] = scaling._cell_base(
+        "gg", scaling.MODE_BY_KEY["reference-fft"], 2
+    ) | {
+        "status": "failed",
+        "failure_category": "memory-limit",
+        "failure_reason": "old lower-n resource observation",
+        "censors_higher_multiplicities": True,
+    }
+    curve["8"] = scaling._cell_base(
+        "gg", scaling.MODE_BY_KEY["reference-fft"], 8
+    ) | {"status": "measured"}
+    report_path = study_root / "runs" / "retry-lower-frontier" / "report.json"
+    scaling.performance._write_report(report_path, report)
+    attempts = 0
+
+    def fake_reference_cell(**kwargs: object) -> dict[str, object]:
+        nonlocal attempts
+        attempts += 1
+        final_multiplicity = int(kwargs["final_multiplicity"])
+        assert final_multiplicity == 2
+        return scaling._cell_base(
+            "gg", scaling.MODE_BY_KEY["reference-fft"], final_multiplicity
+        ) | {"status": "measured"}
+
+    monkeypatch.setattr(scaling, "_reference_cell", fake_reference_cell)
+    completed = scaling._campaign(arguments)
+
+    assert attempts == 1
+    assert completed["status"] == "complete"
+    assert completed["cells"]["gg"]["reference-fft"]["2"]["status"] == "measured"
+    assert completed["cells"]["gg"]["reference-fft"]["8"]["status"] == "measured"
+    assert scaling.resource_frontier_inversions(completed) == ()
+
+
+def test_candidate_public_cli_commands_and_profile_json_are_authoritative(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    momenta = tmp_path / "momenta.json"
+    parameters = tmp_path / "parameters.json"
+    helicity = (-1, -1, 1, 1)
+    fixed_evaluate = scaling._candidate_evaluate_command(
+        python="python",
+        artifact=artifact,
+        process="gg_n2",
+        momenta=momenta,
+        model_parameters=parameters,
+        helicity=helicity,
+        sum_helicities=False,
+    )
+    fixed_profile = scaling._candidate_profile_command(
+        python="python",
+        artifact=artifact,
+        process="gg_n2",
+        momenta=momenta,
+        helicity=helicity,
+        sum_helicities=False,
+        target_seconds=0.25,
+        batch_size=128,
+    )
+    summed_profile = scaling._candidate_profile_command(
+        python="python",
+        artifact=artifact,
+        process="gg_n2",
+        momenta=momenta,
+        helicity=helicity,
+        sum_helicities=True,
+        target_seconds=0.25,
+        batch_size=128,
+    )
+
+    assert fixed_evaluate[fixed_evaluate.index("--model-parameters") + 1] == str(
+        parameters
+    )
+    assert fixed_evaluate[fixed_evaluate.index("--helicity") + 1] == "h:-1,-1,+1,+1"
+    assert fixed_profile[fixed_profile.index("--helicity") + 1] == "h:-1,-1,+1,+1"
+    assert "--helicity" not in summed_profile
+    assert fixed_profile[fixed_profile.index("--target-runtime") + 1] == "0.25"
+    assert fixed_profile[fixed_profile.index("--batch-size") + 1] == "128"
+    assert fixed_profile[fixed_profile.index("--warmup-runs") + 1] == "0"
+    assert fixed_profile[fixed_profile.index("--minimum-samples") + 1] == "1"
+    assert all("fft_gluon_candidate_probe" not in token for token in fixed_profile)
+
+    values = scaling._parse_candidate_evaluate_json(
+        json.dumps([{"real": index + 1.0, "imag": 0.0} for index in range(10)])
+    )
+    assert values == [float(index) for index in range(1, 11)]
+
+    config = {
+        "batch_size": 128,
+        "color_flow_ids": [],
+        "helicity_ids": [],
+        "minimum_samples": 1,
+        "precision": 16,
+        "target_runtime": 0.25,
+        "warmup_runs": 0,
+    }
+    wall = 0.0005343891273355439
+    payload = {
+        "requested_config": config,
+        "effective_config": config,
+        "sample_count": 1,
+        "repetitions_per_sample": 1,
+        "wall_time_per_point": wall,
+        "interrupted": False,
+        "process_id": "gg_n2",
+        "process_expression": scaling.process_expression("gg", 2),
+        "environment": {
+            "target": str(artifact),
+            "execution_mode": "recurrence",
+            "color_accuracy": "full",
+            "batch_size": 128,
+            "precision": 16,
+            "selected_color_ids": [],
+            "selected_helicity_ids": [],
+            "completed_sample_count": 1,
+            "measured_point_count": 128,
+            "interrupted": False,
+        },
+        "retained_full_cli_provenance": {"sentinel": True},
+    }
+    parsed = scaling._parse_candidate_profile_json(
+        json.dumps(payload),
+        artifact=artifact,
+        family="gg",
+        final_multiplicity=2,
+        execution_mode="recurrence",
+        helicity=helicity,
+        sum_helicities=True,
+        target_seconds=0.25,
+        batch_size=128,
+    )
+
+    assert parsed["wall_time_per_point"] == wall
+    assert parsed["retained_full_cli_provenance"] == {"sentinel": True}
+
+
+def test_summed_reference_distinguishes_shared_and_timed_event_paths(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    shared = tuple(tmp_path / f"shared-{index}.event" for index in range(10))
+    timed = tuple(tmp_path / f"timed-{index}.event" for index in range(10))
+    for path in (*shared, *timed):
+        path.write_text("event\n", encoding="utf-8")
+    metrics = scaling.performance.ReferenceMetrics(
+        total_gluons=4,
+        generator_seed=scaling.performance.generator_seed(4),
+        backend=scaling.performance.REFERENCE_BACKEND,
+        clean_build_scope=scaling.performance.REFERENCE_CLEAN_BUILD_SCOPE,
+        clean_build_command_count=1,
+        clean_build_seconds=1.0,
+        setup_to_driver_seconds=1.0,
+        initialization_seconds=0.1,
+        first_pass_seconds=0.1,
+        warm_samples_seconds=(0.01,) * 10,
+        warm_median_seconds=0.01,
+        max_rss_kib=1024,
+        selected_helicity=(-1, -1, 1, 1),
+        selected_path="mhv",
+        event_paths=tuple(str(path) for path in shared),
+        matrix_elements=(1.0,) * 10,
+        helicity_workload="sum",
+        helicity_coverage_count=16,
+        timed_helicity_count=6,
+        active_helicity_count=6,
+        exhaustive_event_paths=tuple(str(path) for path in timed),
+    )
+    monkeypatch.setattr(
+        scaling.performance,
+        "_run_reference",
+        lambda **_kwargs: scaling.performance._ReferenceRun(
+            metrics=metrics, event_paths=shared
+        ),
+    )
+    arguments = scaling._parser().parse_args(("--compare-helicity-sums",))
+
+    cell = scaling._reference_cell(
+        arguments=arguments,
+        reference=object(),
+        run_root=tmp_path,
+        environment={},
+        final_multiplicity=2,
+    )
+
+    assert cell["event_paths"] == [str(path) for path in shared]
+    assert cell["shared_event_paths"] == [str(path) for path in shared]
+    assert cell["timed_event_paths"] == [str(path) for path in timed]
+    assert cell["reference"]["exhaustive_event_paths"] == tuple(
+        str(path) for path in timed
+    )
+    report = {"cells": {"gg": {"reference-fft": {"2": cell}}}}
+    events, helicity = scaling._inputs(report, tmp_path, "gg", 2)
+    assert events == shared
+    assert helicity == metrics.selected_helicity
+
+
+@pytest.mark.parametrize(
+    ("failed_phase", "expected_generation_calls", "expected_cli_calls"),
+    (("interruption", 1, 3), ("profile", 1, 4), ("generation", 2, 2)),
+)
+def test_candidate_resume_reuses_only_a_successful_generation_phase(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    failed_phase: str,
+    expected_generation_calls: int,
+    expected_cli_calls: int,
+) -> None:
+    study_root = tmp_path / "study"
+    final_multiplicity = 8
+    run_id = f"resume-{failed_phase}"
+    monkeypatch.setattr(scaling, "STUDY_ROOT", study_root)
+    monkeypatch.setattr(scaling, "_study_environment", lambda _python: {})
+    monkeypatch.setattr(
+        scaling,
+        "_acquire_campaign_lock",
+        lambda: (tmp_path / "campaign.lock").open("a+", encoding="utf-8"),
+    )
+    monkeypatch.setattr(scaling.performance, "_load_reference_module", lambda: object())
+    monkeypatch.setattr(
+        scaling.performance,
+        "_build_probe",
+        lambda **_kwargs: pytest.fail(
+            "publication candidate cells must not build the custom C++ probe"
+        ),
+    )
+    monkeypatch.setattr(
+        scaling,
+        "_validate_publication_candidate_artifact",
+        lambda _artifact, _process: 16,
+    )
+    factor = (
+        scaling.performance.INITIAL_GLUON_AVERAGE_FACTOR
+        * scaling.math.factorial(final_multiplicity)
+        / (4.0 * scaling.math.pi * scaling.DEFAULT_ALPHA_S) ** final_multiplicity
+    )
+    event_paths = tuple(tmp_path / f"event-{index}" for index in range(10))
+    for path in event_paths:
+        path.write_text("mock event\n", encoding="utf-8")
+
+    def fake_reference_cell(**_kwargs: object) -> dict[str, object]:
+        return scaling._cell_base(
+            "gg", scaling.MODE_BY_KEY["reference-fft"], final_multiplicity
+        ) | {
+            "status": "measured",
+            "event_paths": [str(path) for path in event_paths],
+            "helicity": [1] * (final_multiplicity + 2),
+            "point_values": [factor] * 10,
+        }
+
+    generation_calls = 0
+    cli_calls = 0
+    failure_triggered = False
+    evaluate_timeouts: list[float] = []
+    watchdog_stderr = (
+        "memory-watchdog: command finished exit=0 peak_rss=0.001 GiB "
+        "peak_physical_footprint=0.001 GiB peak_guard=0.001 GiB\n"
+    )
+
+    def fake_run_watched(
+        command: tuple[str, ...], **kwargs: object
+    ) -> scaling.performance.WatchedCompletedProcess:
+        nonlocal generation_calls, cli_calls, failure_triggered
+        assert all("fft_gluon_candidate_probe" not in token for token in command)
+        log_path = Path(str(kwargs["log_path"]))
+        if log_path.name == "generation.json":
+            generation_calls += 1
+            artifact = log_path.parent / "artifact"
+            artifact.mkdir(parents=True, exist_ok=True)
+            (artifact / "artifact.json").write_text("{}\n", encoding="utf-8")
+            returncode = int(failed_phase == "generation" and not failure_triggered)
+            failure_triggered = failure_triggered or returncode != 0
+            log_path.write_text(
+                json.dumps(
+                    {
+                        "command": list(command),
+                        "elapsed_seconds": 1.0,
+                        "returncode": returncode,
+                        "stdout": "",
+                        "stderr": watchdog_stderr,
+                        "timed_out": False,
+                        "timeout_cleanup": "not-required",
+                    }
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+            if returncode != 0:
+                raise scaling.performance.AcceptanceError("generation failed")
+            output = ""
+        elif log_path.name == "evaluate.json":
+            cli_calls += 1
+            evaluate_timeouts.append(float(kwargs["timeout_seconds"]))
+            if failed_phase == "interruption" and not failure_triggered:
+                failure_triggered = True
+                raise KeyboardInterrupt
+            output = json.dumps([{"real": 1.0, "imag": 0.0}] * 10)
+        else:
+            assert log_path.name == "profile.json"
+            cli_calls += 1
+            if failed_phase == "profile" and not failure_triggered:
+                failure_triggered = True
+                raise scaling.performance.AcceptanceError("profile failed")
+            config = {
+                "batch_size": 1,
+                "color_flow_ids": [],
+                "helicity_ids": ["h:" + ",".join(["+1"] * 10)],
+                "minimum_samples": 1,
+                "precision": 16,
+                "target_runtime": scaling.DEFAULT_PROFILE_TARGET_SECONDS,
+                "warmup_runs": 0,
+            }
+            output = json.dumps(
+                {
+                    "requested_config": config,
+                    "effective_config": config,
+                    "sample_count": 1,
+                    "repetitions_per_sample": 1,
+                    "wall_time_per_point": 0.001,
+                    "interrupted": False,
+                    "process_id": "gg_n8",
+                    "process_expression": scaling.process_expression("gg", 8),
+                    "environment": {
+                        "target": str(log_path.parent / "artifact"),
+                        "execution_mode": "recurrence",
+                        "color_accuracy": "full",
+                        "batch_size": 1,
+                        "precision": 16,
+                        "selected_color_ids": [],
+                        "selected_helicity_ids": config["helicity_ids"],
+                        "completed_sample_count": 1,
+                        "measured_point_count": 1,
+                        "interrupted": False,
+                    },
+                }
+            )
+        return scaling.performance.WatchedCompletedProcess(
+            command,
+            0,
+            output,
+            watchdog_stderr,
+            elapsed_seconds=1.0,
+            log_write_seconds=0.0,
+            timed_out=False,
+            timeout_cleanup="not-required",
+        )
+
+    monkeypatch.setattr(scaling, "_reference_cell", fake_reference_cell)
+    monkeypatch.setattr(
+        scaling,
+        "_write_candidate_cli_inputs",
+        lambda *, cell_root, **_kwargs: (
+            cell_root / "cli-momenta.json",
+            cell_root / "cli-model-parameters.json",
+        ),
+    )
+    monkeypatch.setattr(scaling.performance, "_run_watched", fake_run_watched)
+    common = (
+        "--run-id",
+        run_id,
+        "--min-n",
+        str(final_multiplicity),
+        "--max-n",
+        str(final_multiplicity),
+        "--family",
+        "gg",
+        "--mode",
+        "reference-fft",
+        "--mode",
+        "recurrence-fft",
+        "--batch-size",
+        "1",
+    )
+    first = scaling._parser().parse_args(common)
+    scaling._validate_arguments(first)
+    if failed_phase == "interruption":
+        with pytest.raises(KeyboardInterrupt):
+            scaling._campaign(first)
+    else:
+        with pytest.raises(scaling.StudyError, match="repair it, then resume"):
+            scaling._campaign(first)
+
+    resumed = scaling._parser().parse_args((*common, "--resume"))
+    scaling._validate_arguments(resumed)
+    report = scaling._campaign(resumed)
+
+    candidate_root = (
+        study_root / "runs" / run_id / "candidate" / "recurrence-fft" / "gg"
+    )
+    assert generation_calls == expected_generation_calls
+    assert cli_calls == expected_cli_calls
+    assert evaluate_timeouts
+    assert all(timeout == pytest.approx(3599.0) for timeout in evaluate_timeouts)
+    assert not (candidate_root / "n8.interrupted-1").exists()
+    assert not (candidate_root / ".n8.staging").exists()
+    assert (candidate_root / "n8" / "artifact" / "artifact.json").is_file()
+    measured = report["cells"]["gg"]["recurrence-fft"]["8"]
+    assert measured["status"] == "measured"
+    assert measured["metrics"]["warm_seconds_per_point"] == 0.001
+    assert "runtime_profile" in measured
+    assert "probe" not in measured
+
+
+def test_disk_exhaustion_is_not_misreported_as_an_rss_censor(tmp_path: Path) -> None:
+    cell = scaling._failure_cell(
+        scaling._cell_base("gg", scaling.MODE_BY_KEY["recurrence-fft"], 8),
+        OSError(28, "No space left on device"),
+        tmp_path,
+    )
+
+    assert cell["failure_category"] == "disk-infrastructure-failure"
+    assert cell["censors_higher_multiplicities"] is False
+
+
+def _prepare_mocked_selected_campaign(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> Path:
+    study_root = tmp_path / "study"
+    repository = tmp_path / "amplicol"
+    repository.mkdir()
+    (repository / "amplicol_color_probe").write_text("test probe\n", encoding="utf-8")
+    monkeypatch.setattr(scaling, "STUDY_ROOT", study_root)
+    monkeypatch.setattr(scaling, "_study_environment", lambda _python: {})
+    monkeypatch.setattr(
+        scaling,
+        "_acquire_campaign_lock",
+        lambda: (tmp_path / "campaign.lock").open("a+", encoding="utf-8"),
+    )
+    monkeypatch.setattr(scaling.performance, "_load_reference_module", lambda: object())
+    monkeypatch.setattr(
+        scaling.performance,
+        "_build_probe",
+        lambda **_kwargs: pytest.fail(
+            "publication candidate cells must not build the custom C++ probe"
+        ),
+    )
+    monkeypatch.setattr(
+        scaling.legacy_amplicol, "validate_checkout", lambda _repository: None
+    )
+    return repository
+
+
+def test_reference_resource_censor_skips_gg_dependencies_but_runs_ddbar(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    repository = _prepare_mocked_selected_campaign(tmp_path, monkeypatch)
+    calls = {"reference": 0, "amplicol-ddbar": 0, "candidate-ddbar": 0}
+
+    def fake_reference_cell(**_kwargs: object) -> dict[str, object]:
+        calls["reference"] += 1
+        raise scaling._CellResourceLimitError(
+            "reference generation reached its cell deadline",
+            category="generation-time-limit",
+        )
+
+    def fake_inputs(
+        _report: object, _run_root: Path, family: str, final_multiplicity: int
+    ) -> tuple[tuple[Path, ...], tuple[int, ...]]:
+        assert family == "ddbar"
+        return (Path("event"),), scaling.fixed_ddbar_helicity(final_multiplicity)
+
+    def fake_amplicol_cell(**kwargs: object) -> dict[str, object]:
+        family = str(kwargs["family"])
+        assert family == "ddbar"
+        calls["amplicol-ddbar"] += 1
+        final_multiplicity = int(kwargs["final_multiplicity"])
+        return scaling._cell_base(
+            family, scaling.MODE_BY_KEY["amplicol"], final_multiplicity
+        ) | {"status": "measured"}
+
+    def fake_candidate_cell(**kwargs: object) -> dict[str, object]:
+        family = str(kwargs["family"])
+        assert family == "ddbar"
+        calls["candidate-ddbar"] += 1
+        final_multiplicity = int(kwargs["final_multiplicity"])
+        mode = kwargs["mode"]
+        return scaling._cell_base(family, mode, final_multiplicity) | {
+            "status": "measured"
+        }
+
+    monkeypatch.setattr(scaling, "_reference_cell", fake_reference_cell)
+    monkeypatch.setattr(scaling, "_inputs", fake_inputs)
+    monkeypatch.setattr(scaling, "_amplicol_cell", fake_amplicol_cell)
+    monkeypatch.setattr(scaling, "_candidate_cell", fake_candidate_cell)
+    common = (
+        "--run-id",
+        "dependency-censor",
+        "--min-n",
+        "7",
+        "--max-n",
+        "8",
+        "--family",
+        "gg",
+        "--family",
+        "ddbar",
+        "--mode",
+        "reference-fft",
+        "--mode",
+        "amplicol",
+        "--mode",
+        "recurrence-fft",
+        "--amplicol-repository",
+        str(repository),
+    )
+    first = scaling._parser().parse_args(common)
+    scaling._validate_arguments(first)
+    report = scaling._campaign(first)
+
+    assert calls == {"reference": 1, "amplicol-ddbar": 2, "candidate-ddbar": 2}
+    for n in ("7", "8"):
+        for mode in ("amplicol", "recurrence-fft"):
+            dependency = report["cells"]["gg"][mode][n]
+            assert dependency["status"] == "skipped"
+            assert dependency["failure_category"] == "dependency-unavailable"
+            assert dependency["censors_higher_multiplicities"] is False
+        assert report["cells"]["ddbar"]["amplicol"][n]["status"] == "measured"
+        assert report["cells"]["ddbar"]["recurrence-fft"][n]["status"] == "measured"
+
+    resumed = scaling._parser().parse_args((*common, "--resume"))
+    scaling._validate_arguments(resumed)
+    scaling._campaign(resumed)
+    assert calls == {"reference": 1, "amplicol-ddbar": 2, "candidate-ddbar": 2}
+
+
+def test_amplicol_gg_dense_index_preflight_censors_only_that_curve(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    repository = _prepare_mocked_selected_campaign(tmp_path, monkeypatch)
+    calls = {"reference": 0, "amplicol": 0, "candidate": 0}
+
+    def fake_reference_cell(**kwargs: object) -> dict[str, object]:
+        calls["reference"] += 1
+        final_multiplicity = int(kwargs["final_multiplicity"])
+        return scaling._cell_base(
+            "gg", scaling.MODE_BY_KEY["reference-fft"], final_multiplicity
+        ) | {"status": "measured"}
+
+    def fake_inputs(
+        _report: object, _run_root: Path, family: str, final_multiplicity: int
+    ) -> tuple[tuple[Path, ...], tuple[int, ...]]:
+        assert family == "gg"
+        return (Path("event"),), (1,) * (final_multiplicity + 2)
+
+    def fake_amplicol_cell(**_kwargs: object) -> dict[str, object]:
+        calls["amplicol"] += 1
+        raise AssertionError("structurally infeasible AmpliCol cell was launched")
+
+    def fake_candidate_cell(**kwargs: object) -> dict[str, object]:
+        calls["candidate"] += 1
+        final_multiplicity = int(kwargs["final_multiplicity"])
+        mode = kwargs["mode"]
+        return scaling._cell_base("gg", mode, final_multiplicity) | {
+            "status": "measured"
+        }
+
+    monkeypatch.setattr(scaling, "_reference_cell", fake_reference_cell)
+    monkeypatch.setattr(scaling, "_inputs", fake_inputs)
+    monkeypatch.setattr(scaling, "_amplicol_cell", fake_amplicol_cell)
+    monkeypatch.setattr(scaling, "_candidate_cell", fake_candidate_cell)
+    arguments = scaling._parser().parse_args(
+        (
+            "--run-id",
+            "amplicol-preflight",
+            "--min-n",
+            "8",
+            "--max-n",
+            "9",
+            "--family",
+            "gg",
+            "--mode",
+            "reference-fft",
+            "--mode",
+            "amplicol",
+            "--mode",
+            "recurrence-fft",
+            "--memory-limit-gib",
+            "20",
+            "--amplicol-repository",
+            str(repository),
+        )
+    )
+    scaling._validate_arguments(arguments)
+    report = scaling._campaign(arguments)
+
+    n7 = scaling._amplicol_gg_dense_index_preflight(7, 20.0)
+    n8 = scaling._amplicol_gg_dense_index_preflight(8, 20.0)
+    assert n7["color_orders"] == 40_320
+    assert n7["feasible"] is True
+    assert n8["color_orders"] == 362_880
+    assert n8["lower_bound_bytes"] == 263_363_788_800
+    assert n8["feasible"] is False
+    assert calls == {"reference": 2, "amplicol": 0, "candidate": 2}
+    first_skip = report["cells"]["gg"]["amplicol"]["8"]
+    assert first_skip["status"] == "skipped"
+    assert first_skip["failure_category"] == "structural-memory-limit"
+    assert first_skip["censors_higher_multiplicities"] is True
+    higher_skip = report["cells"]["gg"]["amplicol"]["9"]
+    assert higher_skip["status"] == "skipped"
+    assert higher_skip["failed_at_n"] == 8
+    assert report["cells"]["gg"]["recurrence-fft"]["9"]["status"] == "measured"
diff --git a/pyamplicol/tests/unit/test_fft_scaling_study_plots.py b/pyamplicol/tests/unit/test_fft_scaling_study_plots.py
new file mode 100644
index 0000000000..4f1da1459e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_fft_scaling_study_plots.py
@@ -0,0 +1,957 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tools.developer import fft_scaling_study_plots as plots
+
+
+def _report(boundary: object = 6) -> dict[str, object]:
+    plot_policy = (
+        {}
+        if boundary is None
+        else {
+            "source_boundary_after_n": boundary,
+            "source_boundary_label": "n=2..6 / n=7..9 source boundary",
+        }
+    )
+    return {
+        "policy": {
+            "final_state_multiplicities": list(range(2, 10)),
+            "plot": plot_policy,
+        },
+        "cells": {},
+    }
+
+
+def test_source_boundary_is_drawn_between_n6_and_n7() -> None:
+    assert plots._source_boundary(_report()) == (
+        6.5,
+        "n=2..6 / n=7..9 source boundary",
+    )
+
+
+def test_source_boundary_is_optional() -> None:
+    assert plots._source_boundary(_report(None)) is None
+
+
+def test_source_boundary_can_be_disabled_for_only_the_refreshed_metric() -> None:
+    report = _report()
+    report["policy"]["plot"]["metric_source_boundaries"] = {
+        "generation_seconds": {
+            "source_boundary_after_n": 6,
+            "source_boundary_label": "generation boundary",
+        },
+        "warm_seconds_per_point": None,
+    }
+
+    assert plots._source_boundary(report, "warm_seconds_per_point") is None
+    assert plots._source_boundary(report, "generation_seconds") == (
+        6.5,
+        "generation boundary",
+    )
+    assert plots._source_boundary(report, "max_rss_kib") == (
+        6.5,
+        "n=2..6 / n=7..9 source boundary",
+    )
+
+
+def test_protocol_summary_records_fft_and_helicity_contract() -> None:
+    report = _report()
+    report["policy"].update(
+        {
+            "fft_enabled": True,
+            "measurement": {
+                "generation_helicity_coverage": "all",
+                "warm_fixed_helicity": True,
+                "warm_benchmark_batch_size": 128,
+                "compiled_fft_enabled": False,
+            },
+        }
+    )
+
+    assert plots._protocol_summary(report) == (
+        "Campaign --fft enabled | artifacts: all runtime helicities | "
+        "setup/warm workload: one fixed helicity | pyAmpliCol CLI profile: batch 128 "
+        "(cyclic 10 points) | Reference/AmpliCol: scalar aggregates normalized "
+        "per point | compiled FFT disabled | "
+        "main Y log; ratio Y log"
+    )
+    assert plots.METRICS[0].title == "Setup time"
+
+
+def test_protocol_summary_and_warm_title_record_helicity_sum() -> None:
+    report = _report()
+    report["policy"].update(
+        {
+            "fft_enabled": True,
+            "helicity_workload": "sum",
+            "measurement": {
+                "generation_helicity_coverage": "all",
+                "warm_fixed_helicity": False,
+                "warm_helicity_sum": True,
+                "warm_benchmark_batch_size": 128,
+                "compiled_fft_enabled": False,
+            },
+        }
+    )
+
+    assert plots._protocol_summary(report) == (
+        "Campaign --fft enabled | artifacts: all runtime helicities | "
+        "setup/warm workload: complete helicity sum | "
+        "AmpliCol: create-raw bulk H family | pyAmpliCol CLI profile: batch 128 "
+        "(cyclic 10 points) | Reference/AmpliCol: scalar aggregates normalized "
+        "per point | compiled FFT disabled | "
+        "main Y log; ratio Y log"
+    )
+    assert plots._metric_title(report, plots.METRICS[1]) == (
+        "Warmed helicity-summed runtime per point"
+    )
+    assert plots._metric_axis_label(report, plots.METRICS[1]) == (
+        "Time per helicity-summed point [s]"
+    )
+    protocol_lines = plots._protocol_summary_lines(report)
+    assert protocol_lines == (
+        "Campaign --fft enabled | artifacts: all runtime helicities | "
+        "setup/warm workload: complete helicity sum",
+        "AmpliCol: create-raw bulk H family | pyAmpliCol CLI profile: batch 128 "
+        "(cyclic 10 points)",
+        "Reference/AmpliCol: scalar aggregates normalized per point | "
+        "compiled FFT disabled | main Y log; ratio Y log",
+    )
+    assert max(map(len, protocol_lines)) <= 110
+
+
+def test_sum_plot_rejects_fixed_helicity_external_series() -> None:
+    report = _report(None)
+    report["policy"].update(
+        {
+            "fft_enabled": True,
+            "helicity_workload": "sum",
+            "process_families": {"gg": {"modes": ["reference-fft"]}},
+            "measurement": {
+                "warm_fixed_helicity": False,
+                "warm_helicity_sum": True,
+            },
+        }
+    )
+    report["cells"] = {
+        "gg": {
+            "reference-fft": {
+                "2": {
+                    "status": "measured",
+                    "helicity_workload": "sum",
+                    "metrics": {"warm_seconds_per_point": 1.0},
+                }
+            }
+        }
+    }
+    report["runtime_series"] = {
+        "gg": {
+            "madgraph-standalone": {
+                "2": {
+                    "status": "measured",
+                    "protocol": {"helicity_summed": False},
+                    "metrics": {"warm_seconds_per_point": 2.0},
+                }
+            }
+        }
+    }
+
+    with pytest.raises(plots.PlotError, match="not authenticated as a helicity-summed"):
+        plots._family_cells_for_metric(report, "gg", plots.METRICS[1])
+
+
+def test_plot_rejects_contradictory_helicity_workload_markers() -> None:
+    report = _report(None)
+    report["policy"].update(
+        {
+            "fft_enabled": True,
+            "helicity_workload": "sum",
+            "measurement": {
+                "warm_fixed_helicity": True,
+                "warm_helicity_sum": True,
+            },
+        }
+    )
+    with pytest.raises(plots.PlotError, match="summed policy"):
+        plots._protocol_summary(report)
+
+    cell = {
+        "helicity_workload": "sum",
+        "warm_fixed_helicity": True,
+    }
+    with pytest.raises(plots.PlotError, match="markers are contradictory"):
+        plots._declared_cell_workload(cell)
+
+
+def test_plot_rejects_disagreeing_policy_and_measurement_workloads() -> None:
+    report = _report(None)
+    report["policy"].update(
+        {
+            "helicity_workload": "fixed",
+            "measurement": {
+                "helicity_workload": "sum",
+                "warm_fixed_helicity": False,
+                "warm_helicity_sum": True,
+            },
+        }
+    )
+
+    with pytest.raises(plots.PlotError, match="declarations disagree"):
+        plots._helicity_workload(report)
+
+
+def test_plot_manifest_binds_report_workload_and_exact_pngs(tmp_path: Path) -> None:
+    report_path = tmp_path / "report.json"
+    report = _report(None)
+    report_path.write_text(json.dumps(report), encoding="utf-8")
+    output_directory = tmp_path / "plots"
+    output_directory.mkdir()
+    for index, filename in enumerate(plots.PLOT_FILENAMES):
+        (output_directory / filename).write_bytes(f"png-{index}".encode())
+
+    manifest_path = plots._write_plot_manifest(
+        plots._sha256(report_path), report, output_directory
+    )
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+
+    assert manifest["report_sha256"] == plots._sha256(report_path)
+    assert manifest["helicity_workload"] == "fixed"
+    assert set(manifest["plots"]) == set(plots.PLOT_FILENAMES)
+    assert manifest["plots"][plots.PLOT_FILENAMES[0]] == plots._sha256(
+        output_directory / plots.PLOT_FILENAMES[0]
+    )
+
+
+def test_plot_data_payload_records_plotted_values_and_ratios(tmp_path: Path) -> None:
+    report = _report(None)
+    report["policy"].update(
+        {
+            "process_families": {
+                "gg": {"modes": ["reference-fft", "recurrence-direct"]},
+                "ddbar": {"modes": ["amplicol"]},
+            },
+            "measurement": {"warm_fixed_helicity": True},
+        }
+    )
+    measured = {
+        "status": "measured",
+        "warm_fixed_helicity": True,
+    }
+    report["cells"] = {
+        "gg": {
+            "reference-fft": {
+                "2": measured
+                | {
+                    "label": "Reference FFT",
+                    "metrics": {
+                        "generation_seconds": 2.0,
+                        "warm_seconds_per_point": 0.2,
+                        "max_rss_kib": 2048.0,
+                    },
+                }
+            },
+            "recurrence-direct": {
+                "2": measured
+                | {
+                    "metrics": {
+                        "generation_seconds": 4.0,
+                        "warm_seconds_per_point": 0.1,
+                        "max_rss_kib": 4096.0,
+                    },
+                }
+            },
+        },
+        "ddbar": {
+            "amplicol": {
+                "2": measured
+                | {
+                    "metrics": {
+                        "generation_seconds": 3.0,
+                        "warm_seconds_per_point": 0.3,
+                        "max_rss_kib": 1024.0,
+                    },
+                }
+            }
+        },
+    }
+
+    payload = plots._plot_data_payload("abc123", report)
+    output_directory = tmp_path / "plots"
+    output_directory.mkdir()
+    data_path = plots._write_plot_data("abc123", report, output_directory)
+    persisted = json.loads(data_path.read_text(encoding="utf-8"))
+
+    generation = payload["families"]["gg"]["metrics"]["generation"]
+    rss = payload["families"]["gg"]["metrics"]["rss"]
+
+    assert persisted == payload
+    assert payload["kind"] == "pyamplicol-fft-scaling-plot-data"
+    assert generation["source_metric_key"] == "generation_seconds"
+    assert generation["modes"]["reference-fft"]["series"] == [
+        {"n": 2, "value": 2.0}
+    ]
+    assert generation["modes"]["recurrence-direct"]["ratio_to_baseline"] == [
+        {"n": 2, "value": 2.0}
+    ]
+    assert rss["axis_label"] == "Peak RSS [MiB]"
+    assert rss["modes"]["reference-fft"]["series"] == [{"n": 2, "value": 2.0}]
+
+
+def test_plot_data_payload_records_custom_axis_options() -> None:
+    report = _report(None)
+    report["policy"].update(
+        {
+            "process_families": {
+                "gg": {"modes": ["reference-fft", "recurrence-direct"]},
+                "ddbar": {"modes": ["amplicol"]},
+            },
+            "measurement": {"warm_fixed_helicity": True},
+        }
+    )
+    measured = {
+        "status": "measured",
+        "warm_fixed_helicity": True,
+    }
+    report["cells"] = {
+        "gg": {
+            "reference-fft": {
+                "2": measured
+                | {"metrics": {"generation_seconds": 2.0}},
+            },
+            "recurrence-direct": {
+                "2": measured
+                | {"metrics": {"generation_seconds": 4.0}},
+            },
+        },
+        "ddbar": {
+            "amplicol": {
+                "2": measured
+                | {"metrics": {"generation_seconds": 3.0}},
+            }
+        },
+    }
+    axis_options = plots.AxisOptions(
+        main_y_range=(1.0, 10.0),
+        ratio_y_range=(0.0, 3.0),
+        ratio_y_scale="linear",
+    )
+
+    payload = plots._plot_data_payload(
+        "abc123",
+        report,
+        axis_options=axis_options,
+    )
+    generation = payload["families"]["gg"]["metrics"]["generation"]
+
+    assert generation["main_axis"] == {"scale": "log", "range": [1.0, 10.0]}
+    assert generation["ratio_axis"] == {
+        "scale": "linear",
+        "range": [0.0, 3.0],
+    }
+
+
+def test_plot_data_payload_filters_main_and_ratio_lines_independently() -> None:
+    report = _report(None)
+    report["policy"].update(
+        {
+            "process_families": {
+                "gg": {
+                    "modes": [
+                        "reference-fft",
+                        "recurrence-direct",
+                        "madgraph-standalone",
+                    ]
+                },
+                "ddbar": {"modes": ["amplicol"]},
+            },
+            "measurement": {"warm_fixed_helicity": True},
+        }
+    )
+    measured = {
+        "status": "measured",
+        "warm_fixed_helicity": True,
+    }
+    report["cells"] = {
+        "gg": {
+            "reference-fft": {
+                "2": measured | {"metrics": {"generation_seconds": 2.0}},
+            },
+            "recurrence-direct": {
+                "2": measured | {"metrics": {"generation_seconds": 4.0}},
+            },
+            "madgraph-standalone": {
+                "2": measured | {"metrics": {"generation_seconds": 6.0}},
+            },
+        },
+        "ddbar": {
+            "amplicol": {
+                "2": measured | {"metrics": {"generation_seconds": 3.0}},
+            }
+        },
+    }
+    line_filters = plots.LineFilterOptions(
+        main_include_lines=("reference-fft",),
+        main_veto_lines=("reference-fft",),
+        ratio_veto_lines=("pyamplicol-recurrence",),
+    )
+
+    payload = plots._plot_data_payload(
+        "abc123",
+        report,
+        line_filters=line_filters,
+    )
+    generation = payload["families"]["gg"]["metrics"]["generation"]
+
+    assert payload["line_filters"]["main"]["include_lines"] == ["reference-fft"]
+    assert payload["line_filters"]["main"]["veto_lines"] == ["reference-fft"]
+    assert generation["main_axis"]["range"] == pytest.approx([1.0, 4.0])
+    assert generation["ratio_axis"]["range"] == pytest.approx(
+        [10**-0.1, 3.0 * 10**0.1]
+    )
+    assert set(generation["modes"]) == {"reference-fft", "madgraph-standalone"}
+    assert generation["modes"]["reference-fft"]["visible_in_main"] is True
+    assert generation["modes"]["reference-fft"]["visible_in_ratio"] is True
+    assert generation["modes"]["reference-fft"]["series"] == [
+        {"n": 2, "value": 2.0}
+    ]
+    assert generation["modes"]["madgraph-standalone"]["visible_in_main"] is False
+    assert generation["modes"]["madgraph-standalone"]["visible_in_ratio"] is True
+    assert generation["modes"]["madgraph-standalone"]["series"] == []
+    assert generation["modes"]["madgraph-standalone"]["ratio_to_baseline"] == [
+        {"n": 2, "value": 3.0}
+    ]
+
+
+def test_axis_options_validate_log_positive_ranges() -> None:
+    linear = plots._parser().parse_args(
+        [
+            "report.json",
+            "plots",
+            "--ratio-y-scale",
+            "linear",
+            "--ratio-y-range",
+            "0",
+            "2",
+        ]
+    )
+    assert plots._axis_options_from_arguments(linear).ratio_y_range == (0.0, 2.0)
+
+    log = plots._parser().parse_args(
+        ["report.json", "plots", "--ratio-y-range", "0", "2"]
+    )
+    with pytest.raises(plots.PlotError, match="logarithmic y-axis"):
+        plots._axis_options_from_arguments(log)
+
+
+def test_recola_results_overlay_is_plotted_and_exported(tmp_path: Path) -> None:
+    report = _report(None)
+    report["policy"].update(
+        {
+            "process_families": {
+                "gg": {"modes": ["reference-fft"]},
+                "ddbar": {"modes": ["amplicol"]},
+            },
+            "measurement": {"warm_fixed_helicity": True},
+        }
+    )
+    report["status"] = "complete"
+    measured = {
+        "status": "measured",
+        "warm_fixed_helicity": True,
+    }
+    report["cells"] = {
+        "gg": {
+            "reference-fft": {
+                "2": measured
+                | {
+                    "metrics": {
+                        "generation_seconds": 2.0,
+                        "warm_seconds_per_point": 0.2,
+                        "max_rss_kib": 2048.0,
+                    }
+                }
+            }
+        },
+        "ddbar": {
+            "amplicol": {
+                "2": measured
+                | {
+                    "metrics": {
+                        "generation_seconds": 4.0,
+                        "warm_seconds_per_point": 0.4,
+                        "max_rss_kib": 4096.0,
+                    }
+                }
+            }
+        },
+    }
+    recola_path = tmp_path / "recola.json"
+    recola_path.write_text(
+        json.dumps(
+            {
+                "config": {"polarized": True},
+                "results": {
+                    "all_gluon": {
+                        "2": {
+                            "family": "all_gluon",
+                            "process": "g g -> g g",
+                            "gen_time_s": 5.0,
+                            "run_time_s": 0.5,
+                            "ram_after_generation_mib": 7.0,
+                            "ram_after_profile_mib": 8.0,
+                            "peak_generation_rss_mib": 6.0,
+                            "polarized": True,
+                            "helicity": [1, 1, 1, 1],
+                            "profiled_call": "get_polarized_squared_amplitude_rcl",
+                        },
+                        "3": None,
+                        "4": {
+                            "status": "limit_reached",
+                            "error": "all_gluon, n=4: generation time exceeded",
+                        },
+                    },
+                    "down_quark_qcd": {
+                        "2": {
+                            "family": "down_quark_qcd",
+                            "process": "d d~ -> d d~",
+                            "gen_time_s": 6.0,
+                            "run_time_s": 0.6,
+                            "peak_generation_rss_mib": 9.0,
+                            "polarized": True,
+                        }
+                    },
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    metadata = plots._attach_recola_results(report, recola_path)
+    external_sources = {"recola_results": metadata}
+    payload = plots._plot_data_payload(
+        "abc123",
+        report,
+        external_sources=external_sources,
+    )
+    output_directory = tmp_path / "plots"
+    output_directory.mkdir()
+    data_path = plots._write_plot_data(
+        "abc123",
+        report,
+        output_directory,
+        external_sources=external_sources,
+    )
+    persisted = json.loads(data_path.read_text(encoding="utf-8"))
+
+    generation = payload["families"]["gg"]["metrics"]["generation"]
+    warm = payload["families"]["gg"]["metrics"]["warm-runtime"]
+    rss = payload["families"]["gg"]["metrics"]["rss"]
+    ddbar_generation = payload["families"]["ddbar"]["metrics"]["generation"]
+
+    assert payload["external_sources"]["recola_results"]["sha256"] == plots._sha256(
+        recola_path
+    )
+    assert persisted == payload
+    assert generation["modes"]["recola"]["label"] == "Recola"
+    assert generation["modes"]["recola"]["series"] == [{"n": 2, "value": 5.0}]
+    assert generation["modes"]["recola"]["ratio_to_baseline"] == [
+        {"n": 2, "value": 2.5}
+    ]
+    assert warm["modes"]["recola"]["series"] == [{"n": 2, "value": 0.5}]
+    assert rss["modes"]["recola"]["series"] == [{"n": 2, "value": 8.0}]
+    assert ddbar_generation["modes"]["recola"]["series"] == [
+        {"n": 2, "value": 6.0}
+    ]
+    assert plots._status_notes(
+        report,
+        "gg",
+        ("recola",),
+        family_cells=report["runtime_series"]["gg"],
+    ) == ["Recola: n=4 failed (configured setup-time limit)."]
+
+
+def test_recola_results_overlay_rejects_workload_mismatch(tmp_path: Path) -> None:
+    report = _report(None)
+    report["policy"].update(
+        {
+            "process_families": {"gg": {"modes": ["reference-fft"]}},
+            "measurement": {"warm_fixed_helicity": True},
+        }
+    )
+    report["cells"] = {"gg": {"reference-fft": {}}}
+    recola_path = tmp_path / "recola-unpolarized.json"
+    recola_path.write_text(
+        json.dumps(
+            {
+                "config": {"polarized": False},
+                "results": {
+                    "all_gluon": {
+                        "2": {
+                            "family": "all_gluon",
+                            "gen_time_s": 1.0,
+                            "run_time_s": 0.1,
+                        }
+                    }
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(plots.PlotError, match="campaign report is fixed"):
+        plots._attach_recola_results(report, recola_path)
+
+
+def test_final_series_palette_line_styles_and_legend_grouping() -> None:
+    assert plots.MODE_STYLES["reference-fft"] == ("#000000", "o", "-")
+    assert plots.MODE_STYLES["amplicol"] == ("#F0E442", "D", "-")
+    assert plots.MODE_STYLES["madgraph-standalone"] == ("#CC3311", "*", "-")
+    assert plots.MODE_STYLES["recurrence-fft"] == ("#009E73", "s", "-")
+    assert plots.MODE_STYLES["recurrence-direct"] == ("#009E73", "o", "--")
+    assert plots.MODE_STYLES["otf-fft"] == ("#0072B2", "v", "-")
+    assert plots.MODE_STYLES["otf-direct"] == ("#0072B2", "^", "--")
+    assert plots.MODE_STYLES["recola"] == ("#AA4499", "h", "-")
+
+    assert plots.LEGEND_MODE_ORDER["gg"] == (
+        "reference-fft",
+        "amplicol",
+        "recurrence-fft",
+        "recurrence-direct",
+        "otf-fft",
+        "otf-direct",
+        "madgraph-standalone",
+        "recola",
+    )
+    assert plots.LEGEND_MODE_ORDER["ddbar"] == (
+        "amplicol",
+        "madgraph-standalone",
+        "recurrence-fft",
+        "recurrence-direct",
+        "otf-fft",
+        "otf-direct",
+        "recola",
+    )
+
+
+def test_renderer_includes_measured_otf_cells_beyond_default_frontier() -> None:
+    family_cells = {
+        mode: {
+            str(n): {
+                "status": "measured",
+                "label": label,
+                "metrics": {"warm_seconds_per_point": float(n)},
+            }
+            for n in (6, 7)
+        }
+        for mode, label in (
+            ("otf-direct", "pyAmpliCol - OTF"),
+            ("otf-fft", "pyAmpliCol - OTF - FFT"),
+            ("recurrence-fft", "pyAmpliCol - recurrence - FFT"),
+        )
+    }
+
+    assert plots._series(family_cells, "otf-direct", plots.METRICS[1]) == [
+        (6, 6.0),
+        (7, 7.0),
+    ]
+    assert plots._series(family_cells, "otf-fft", plots.METRICS[1]) == [
+        (6, 6.0),
+        (7, 7.0),
+    ]
+    assert plots._series(family_cells, "recurrence-fft", plots.METRICS[1]) == [
+        (6, 6.0),
+        (7, 7.0),
+    ]
+    assert (
+        plots._plot_policy_notes(
+            _report(None), "ddbar", plots.METRICS[1], family_cells
+        )
+        == []
+    )
+
+
+def test_madgraph_external_series_is_added_to_all_three_metrics() -> None:
+    report = _report()
+    report["policy"]["process_families"] = {"gg": {"modes": ["reference-fft"]}}
+    report["cells"] = {
+        "gg": {
+            "reference-fft": {
+                "2": {
+                    "status": "measured",
+                    "metrics": {
+                        "generation_seconds": 2.0,
+                        "warm_seconds_per_point": 3.0,
+                    },
+                }
+            }
+        }
+    }
+    report["runtime_series"] = {
+        "gg": {
+            "madgraph-standalone": {
+                "2": {
+                    "status": "measured",
+                    "metrics": {
+                        "generation_seconds": 5.0,
+                        "warm_seconds_per_point": 4.0,
+                        "max_rss_kib": 6144.0,
+                    },
+                }
+            }
+        }
+    }
+
+    warm_cells, warm_modes = plots._family_cells_for_metric(
+        report, "gg", plots.METRICS[1]
+    )
+    generation_cells, generation_modes = plots._family_cells_for_metric(
+        report, "gg", plots.METRICS[0]
+    )
+    rss_cells, rss_modes = plots._family_cells_for_metric(
+        report, "gg", plots.METRICS[2]
+    )
+
+    assert warm_modes == ("reference-fft", "madgraph-standalone")
+    assert plots._series(warm_cells, "madgraph-standalone", plots.METRICS[1]) == [
+        (2, 4.0)
+    ]
+    assert generation_modes == ("reference-fft", "madgraph-standalone")
+    assert plots._series(generation_cells, "madgraph-standalone", plots.METRICS[0]) == [
+        (2, 5.0)
+    ]
+    assert rss_modes == ("reference-fft", "madgraph-standalone")
+    assert plots._series(rss_cells, "madgraph-standalone", plots.METRICS[2]) == [
+        (2, 6.0)
+    ]
+
+
+def test_metric_series_exclusion_omits_only_invalid_warm_curve() -> None:
+    report = _report(None)
+    report["policy"].update(
+        {
+            "process_families": {"gg": {"modes": ["reference-fft", "recurrence-fft"]}},
+            "plot": {
+                "metric_series_exclusions": {
+                    "warm_seconds_per_point": {
+                        "gg": {"recurrence-fft": "driver evaluated all helicities"}
+                    }
+                }
+            },
+        }
+    )
+    report["cells"] = {
+        "gg": {
+            mode: {
+                "2": {
+                    "status": "measured",
+                    "label": label,
+                    "metrics": {
+                        "generation_seconds": generation,
+                        "warm_seconds_per_point": warm,
+                    },
+                }
+            }
+            for mode, label, generation, warm in (
+                ("reference-fft", "Reference FFT", 1.0, 2.0),
+                ("recurrence-fft", "pyAmpliCol recurrence FFT", 3.0, 4.0),
+            )
+        }
+    }
+
+    warm_cells, warm_modes = plots._family_cells_for_metric(
+        report, "gg", plots.METRICS[1]
+    )
+    generation_cells, generation_modes = plots._family_cells_for_metric(
+        report, "gg", plots.METRICS[0]
+    )
+
+    assert warm_modes == ("reference-fft",)
+    assert "recurrence-fft" not in warm_cells
+    assert generation_modes == ("reference-fft", "recurrence-fft")
+    assert plots._series(generation_cells, "recurrence-fft", plots.METRICS[0]) == [
+        (2, 3.0)
+    ]
+    assert plots._plot_policy_notes(
+        report, "gg", plots.METRICS[1], report["cells"]["gg"]
+    ) == [
+        "pyAmpliCol recurrence FFT: warmed runtime per point omitted "
+        "(driver evaluated all helicities)."
+    ]
+
+
+def test_stopped_protocol_investigation_is_not_described_as_running() -> None:
+    report = _report(None)
+    report.update(
+        {
+            "status": "stopped-protocol-investigation",
+            "status_reason": "selected-output timing mismatch",
+        }
+    )
+
+    assert plots._status_notes(report, "gg", ()) == [
+        "Campaign stopped: selected-output timing mismatch. Absent cells are "
+        "unattempted and omitted."
+    ]
+
+
+def test_generation_timeout_is_presented_as_setup_time() -> None:
+    report = _report(None)
+    report["policy"]["measurement"] = {"generation_timeout_seconds": 300.0}
+    cell = {"failure_category": "generation-time-limit"}
+
+    assert plots._failure_detail(report, cell) == "5 min setup-time limit"
+
+
+def test_stopped_protocol_investigation_allows_empty_metric_panel(tmp_path) -> None:
+    report = _report(None)
+    report.update(
+        {
+            "status": "stopped-protocol-investigation",
+            "status_reason": "all warm measurements are withheld",
+            "cells": {"ddbar": {"amplicol": {}}},
+        }
+    )
+    report["policy"]["process_families"] = {"ddbar": {"modes": ["amplicol"]}}
+
+    output = tmp_path / "empty-warm.png"
+    plots._plot_metric(report, "ddbar", plots.METRICS[1], output, dpi=72)
+
+    assert output.is_file()
+    assert output.stat().st_size > 0
+
+
+def test_complete_report_rejects_empty_metric_panel(tmp_path) -> None:
+    report = _report(None)
+    report.update({"status": "complete", "cells": {"ddbar": {"amplicol": {}}}})
+    report["policy"]["process_families"] = {"ddbar": {"modes": ["amplicol"]}}
+
+    with pytest.raises(plots.PlotError, match="no measured positive"):
+        plots._plot_metric(
+            report,
+            "ddbar",
+            plots.METRICS[1],
+            tmp_path / "must-not-render.png",
+            dpi=72,
+        )
+
+
+def test_legacy_warm_quality_advisory_is_an_ordinary_series_point() -> None:
+    family_cells = {
+        "recurrence-fft": {
+            "3": {
+                "status": "measured",
+                "metrics": {"warm_seconds_per_point": 3.0},
+                "excluded_metrics": {
+                    "warm_seconds_per_point": {
+                        "status": "excluded-provisional-warm-quality",
+                        "value": 4.0,
+                    }
+                },
+            }
+        }
+    }
+
+    assert plots._series(
+        family_cells, "recurrence-fft", plots.METRICS[1]
+    ) == [(3, 4.0)]
+
+
+def test_other_metric_exclusion_reasons_remain_invisible() -> None:
+    family_cells = {
+        "recurrence-fft": {
+            "3": {
+                "status": "measured",
+                "metrics": {"warm_seconds_per_point": 3.0},
+                "excluded_metrics": {
+                    "warm_seconds_per_point": {
+                        "status": "excluded-runtime-selection-semantics",
+                        "value": 4.0,
+                    }
+                },
+            }
+        }
+    }
+
+    assert plots._series(
+        family_cells, "recurrence-fft", plots.METRICS[1]
+    ) == []
+
+
+def test_legacy_warm_quality_advisory_does_not_break_curve() -> None:
+    family_cells = {
+        "recurrence-fft": {
+            "2": {
+                "status": "measured",
+                "metrics": {"warm_seconds_per_point": 2.0},
+            },
+            "3": {
+                "status": "measured",
+                "metrics": {},
+                "excluded_metrics": {
+                    "warm_seconds_per_point": {
+                        "status": "excluded-provisional-warm-quality",
+                        "value": 3.0,
+                    }
+                },
+            },
+            "4": {
+                "status": "measured",
+                "metrics": {"warm_seconds_per_point": 4.0},
+            },
+        }
+    }
+
+    series = plots._series(family_cells, "recurrence-fft", plots.METRICS[1])
+
+    assert series == [(2, 2.0), (3, 3.0), (4, 4.0)]
+    assert list(plots._consecutive_runs(series)) == [series]
+
+
+def test_complete_panel_can_render_only_legacy_warm_quality_advisory(
+    tmp_path,
+) -> None:
+    report = _report(None)
+    report.update(
+        {
+            "status": "complete",
+            "cells": {
+                "ddbar": {
+                    "amplicol": {
+                        "2": {
+                            "status": "measured",
+                            "label": "AmpliCol",
+                            "metrics": {},
+                            "excluded_metrics": {
+                                "warm_seconds_per_point": {
+                                    "status": (
+                                        "excluded-provisional-warm-quality"
+                                    ),
+                                    "value": 2.5,
+                                }
+                            },
+                        }
+                    }
+                }
+            },
+        }
+    )
+    report["policy"]["process_families"] = {
+        "ddbar": {"modes": ["amplicol"]}
+    }
+
+    output = tmp_path / "legacy-advisory-only-warm.png"
+    plots._plot_metric(report, "ddbar", plots.METRICS[1], output, dpi=72)
+
+    assert output.is_file()
+    assert output.stat().st_size > 0
+
+
+@pytest.mark.parametrize("boundary", (6.0, True, 9))
+def test_source_boundary_rejects_ambiguous_values(boundary: object) -> None:
+    with pytest.raises(plots.PlotError, match="source_boundary_after_n"):
+        plots._source_boundary(_report(boundary))
diff --git a/pyamplicol/tests/unit/test_final_source_numerical_truth.py b/pyamplicol/tests/unit/test_final_source_numerical_truth.py
new file mode 100644
index 0000000000..af10f97180
--- /dev/null
+++ b/pyamplicol/tests/unit/test_final_source_numerical_truth.py
@@ -0,0 +1,327 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from decimal import Decimal
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.generation.structural_source_proof import (
+    ROLE as STRUCTURAL_SOURCE_PROOF_ROLE,
+)
+from pyamplicol.generation.structural_source_proof import (
+    build_generation_structural_proof,
+)
+from tools.developer.final_source_numerical_truth import (
+    REFERENCE_SCHEMA,
+    TruthProducerError,
+    build_witness,
+    comparison_sha256,
+    validate_witness_payload,
+)
+from tools.performance_report.models import Accuracy, ExecutionMode, Workload
+
+REVISION = "a" * 40
+
+
+@dataclass
+class _Resolved:
+    values: tuple[tuple[tuple[complex | Decimal, ...], ...], ...]
+    helicity_ids: tuple[str, ...]
+    color_ids: tuple[str, ...]
+    color_accuracy: str
+
+
+class _Runtime:
+    def __init__(self, artifact_id: str, mode: str, accuracy: str) -> None:
+        self.artifact_id = artifact_id
+        self.execution_mode = mode
+        self._accuracy = accuracy
+
+    def evaluate_resolved(
+        self,
+        _momenta: object,
+        *,
+        helicities: object,
+        color_flows: object,
+        precision: int,
+    ) -> _Resolved:
+        selected_helicities = ("h:0",) if helicities else ("h:0", "h:1")
+        selected_colors = ("c:0",)
+        value: complex | Decimal = 1 + 0j if precision == 16 else Decimal("1")
+        return _Resolved(
+            values=(
+                tuple(
+                    tuple(value for _color in selected_colors)
+                    for _helicity in selected_helicities
+                ),
+            ),
+            helicity_ids=selected_helicities,
+            color_ids=selected_colors,
+            color_accuracy=self._accuracy,
+        )
+
+
+def _write_artifact(
+    root: Path,
+    *,
+    artifact_id: str,
+    mode: str,
+    accuracy: str,
+    reference: bool,
+) -> None:
+    process_id = "process"
+    execution_path = "processes/process/execution.json"
+    validation_path = "processes/process/validation-momenta.json"
+    execution_payload = {
+        "schema_version": 3,
+        "kind": mode,
+        "key": process_id,
+        "process": "d d~ > z",
+        "color_accuracy": accuracy,
+        "external_pdg_order": [1, -1, 23],
+        "source_count": 3,
+        "current_count": 5,
+        "interaction_count": 7,
+        "amplitude_root_count": 1,
+        "semantic": "reference" if reference else "candidate",
+    }
+    execution = json.dumps(execution_payload, sort_keys=True).encode()
+    validation = json.dumps(
+        {
+            "available": True,
+            "points": [
+                [
+                    {"pdg": 1, "momentum": ["5", "0", "0", "5"]},
+                    {"pdg": -1, "momentum": ["5", "0", "0", "-5"]},
+                    {"pdg": 23, "momentum": ["10", "0", "0", "0"]},
+                ]
+            ],
+        },
+        sort_keys=True,
+    ).encode()
+    (root / "processes" / "process").mkdir(parents=True)
+    (root / execution_path).write_bytes(execution)
+    (root / validation_path).write_bytes(validation)
+    payloads: list[dict[str, object]] = [
+        {
+            "path": execution_path,
+            "role": "evaluator-manifest",
+            "process_id": process_id,
+            "sha256": hashlib.sha256(execution).hexdigest(),
+        },
+        {
+            "path": validation_path,
+            "role": "validation-momenta",
+            "process_id": process_id,
+            "sha256": hashlib.sha256(validation).hexdigest(),
+        },
+    ]
+    native_inputs = "b" * 64
+    structural_path = "processes/process/structural-source-proof.json"
+    structural = build_generation_structural_proof(
+        artifact_root=root,
+        process_id=process_id,
+        source_revision=REVISION,
+        native_build_inputs_sha256=native_inputs,
+        execution_path=execution_path,
+        execution_sha256=hashlib.sha256(execution).hexdigest(),
+        execution=execution_payload,
+        evaluator_container_path=None,
+        evaluator_container_index_sha256=None,
+    )
+    structural_bytes = json.dumps(structural, sort_keys=True).encode()
+    (root / structural_path).write_bytes(structural_bytes)
+    payloads.append(
+        {
+            "path": structural_path,
+            "role": STRUCTURAL_SOURCE_PROOF_ROLE,
+            "process_id": process_id,
+            "sha256": hashlib.sha256(structural_bytes).hexdigest(),
+        }
+    )
+    if reference:
+        contract_path = "independent-reference-semantics.json"
+        contract = json.dumps(
+            {
+                "schema": REFERENCE_SCHEMA,
+                "status": "materialized",
+                "source_revision": REVISION,
+                "artifact_id": artifact_id,
+                "process_id": process_id,
+                "semantics": "pre-optimization-reference",
+                "semantic_payloads": [
+                    {
+                        "path": execution_path,
+                        "sha256": hashlib.sha256(execution).hexdigest(),
+                    }
+                ],
+            },
+            sort_keys=True,
+        ).encode()
+        (root / contract_path).write_bytes(contract)
+        payloads.append(
+            {
+                "path": contract_path,
+                "role": "independent-reference-semantics",
+                "sha256": hashlib.sha256(contract).hexdigest(),
+            }
+        )
+    (root / "artifact.json").write_text(
+        json.dumps(
+            {
+                "artifact_id": artifact_id,
+                "producer": {
+                    "git_revision": REVISION,
+                    "native_build_inputs_sha256": native_inputs,
+                },
+                "default_process_id": process_id,
+                "processes": [
+                    {
+                        "id": process_id,
+                        "color_accuracy": accuracy,
+                    }
+                ],
+                "payloads": payloads,
+            }
+        )
+    )
+
+
+@pytest.mark.parametrize(
+    ("mode", "accuracy", "workload", "helicities", "colors"),
+    [
+        (
+            ExecutionMode.RECURRENCE,
+            Accuracy.LC,
+            Workload.SELECTED_FLOW,
+            ("h:0",),
+            ("c:0",),
+        ),
+        (ExecutionMode.COMPILED, Accuracy.NLC, Workload.CONTRACTED, (), ()),
+        (ExecutionMode.EAGER, Accuracy.FULL, Workload.CONTRACTED, (), ()),
+    ],
+)
+def test_builds_cross_mode_independent_precision80_witness(
+    tmp_path: Path,
+    mode: ExecutionMode,
+    accuracy: Accuracy,
+    workload: Workload,
+    helicities: tuple[str, ...],
+    colors: tuple[str, ...],
+) -> None:
+    candidate = tmp_path / "candidate"
+    reference = tmp_path / "reference"
+    candidate_id = hashlib.sha256(f"candidate-{mode.value}".encode()).hexdigest()
+    reference_id = hashlib.sha256(f"reference-{mode.value}".encode()).hexdigest()
+    _write_artifact(
+        candidate,
+        artifact_id=candidate_id,
+        mode=mode.value,
+        accuracy=accuracy.value,
+        reference=False,
+    )
+    _write_artifact(
+        reference,
+        artifact_id=reference_id,
+        mode=mode.value,
+        accuracy=accuracy.value,
+        reference=True,
+    )
+    runtimes = {
+        candidate.resolve(): _Runtime(candidate_id, mode.value, accuracy.value),
+        reference.resolve(): _Runtime(reference_id, mode.value, accuracy.value),
+    }
+
+    witness = build_witness(
+        candidate,
+        reference,
+        reference_contract_path="independent-reference-semantics.json",
+        cell_id=f"cell-{mode.value}-{accuracy.value}",
+        source_revision=REVISION,
+        mode=mode,
+        accuracy=accuracy,
+        workload=workload,
+        helicity_ids=helicities,
+        color_ids=colors,
+        runtime_loader=lambda path, **_kwargs: runtimes[Path(path).resolve()],
+    )
+
+    assert witness["status"] == "ok"
+    assert witness["precision_decimal_digits"] == 80
+    assert witness["agreement"]["passes"] is True
+    assert validate_witness_payload(witness) == witness
+
+
+def test_rejects_self_reference_and_digest_tampering(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    artifact_id = hashlib.sha256(b"same").hexdigest()
+    _write_artifact(
+        artifact,
+        artifact_id=artifact_id,
+        mode=ExecutionMode.COMPILED.value,
+        accuracy=Accuracy.LC.value,
+        reference=True,
+    )
+    runtime = _Runtime(artifact_id, ExecutionMode.COMPILED.value, Accuracy.LC.value)
+    with pytest.raises(TruthProducerError, match="one content identity"):
+        build_witness(
+            artifact,
+            artifact,
+            reference_contract_path="independent-reference-semantics.json",
+            cell_id="cell",
+            source_revision=REVISION,
+            mode=ExecutionMode.COMPILED,
+            accuracy=Accuracy.LC,
+            workload=Workload.ALL_FLOW,
+            runtime_loader=lambda _path, **_kwargs: runtime,
+        )
+
+
+def test_validator_recomputes_values_and_comparison_sha(tmp_path: Path) -> None:
+    candidate = tmp_path / "candidate"
+    reference = tmp_path / "reference"
+    candidate_id = hashlib.sha256(b"candidate").hexdigest()
+    reference_id = hashlib.sha256(b"reference").hexdigest()
+    for root, identifier, is_reference in (
+        (candidate, candidate_id, False),
+        (reference, reference_id, True),
+    ):
+        _write_artifact(
+            root,
+            artifact_id=identifier,
+            mode=ExecutionMode.COMPILED.value,
+            accuracy=Accuracy.LC.value,
+            reference=is_reference,
+        )
+    runtimes = {
+        candidate.resolve(): _Runtime(
+            candidate_id,
+            ExecutionMode.COMPILED.value,
+            Accuracy.LC.value,
+        ),
+        reference.resolve(): _Runtime(
+            reference_id,
+            ExecutionMode.COMPILED.value,
+            Accuracy.LC.value,
+        ),
+    }
+    witness = build_witness(
+        candidate,
+        reference,
+        reference_contract_path="independent-reference-semantics.json",
+        cell_id="cell",
+        source_revision=REVISION,
+        mode=ExecutionMode.COMPILED,
+        accuracy=Accuracy.LC,
+        workload=Workload.ALL_FLOW,
+        runtime_loader=lambda path, **_kwargs: runtimes[Path(path).resolve()],
+    )
+    witness["reference_exact"]["values"][0][0][0] = "2"
+    witness["reference_exact"]["values_sha256"] = "0" * 64
+    witness["comparison_sha256"] = comparison_sha256(witness)
+    with pytest.raises(TruthProducerError, match="values digest mismatch"):
+        validate_witness_payload(witness)
diff --git a/pyamplicol/tests/unit/test_flavor_blind_expansion.py b/pyamplicol/tests/unit/test_flavor_blind_expansion.py
new file mode 100644
index 0000000000..3fa20c4429
--- /dev/null
+++ b/pyamplicol/tests/unit/test_flavor_blind_expansion.py
@@ -0,0 +1,332 @@
+# SPDX-License-Identifier: 0BSD
+"""Charge-filtered multiset expansion and flavour-blind process collapsing."""
+
+from __future__ import annotations
+
+import itertools
+import logging
+from fractions import Fraction
+from pathlib import Path
+from typing import cast
+
+import pytest
+
+import pyamplicol.generation.service as generation_service
+import pyamplicol.licensing as licensing
+from pyamplicol import Generator, ModelSource, ProcessSet
+from pyamplicol.api.errors import GenerationError
+from pyamplicol.api.models import CompiledModel as CompiledModelHandle
+from pyamplicol.api.models import _compiled_model_payload
+from pyamplicol.api.requests import ProcessAlias
+from pyamplicol.color.plan import build_color_plan
+from pyamplicol.config import (
+    Action,
+    EvaluatorConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from pyamplicol.generation.dag_algorithms import has_model_supported_amplitudes
+from pyamplicol.generation.process_grouping import (
+    GroupingBasis,
+    GroupingProcess,
+    GroupMember,
+    flavor_blind_mapping,
+    particle_table,
+)
+from pyamplicol.generation.process_grouping_symmetry import VertexSymmetryTable
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.licensing import SymbolicaLicenseState
+from pyamplicol.models.external import CompiledUFOModel
+from pyamplicol.models.loading import CompiledModel
+from pyamplicol.processes.conservation import conserved_charges
+from pyamplicol.processes.model import (
+    ModelParticleCatalog,
+    build_model_process_ir,
+    expand_model_processes,
+)
+
+MODEL_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+
+
+@pytest.fixture(scope="module")
+def ufo_sm_handle() -> CompiledModelHandle:
+    return ModelSource(
+        kind="json",
+        path=MODEL_ROOT / "sm.json",
+        restriction=MODEL_ROOT / "restrict_default.json",
+    ).compile(use_cache=False)
+
+
+@pytest.fixture(scope="module")
+def ufo_sm(ufo_sm_handle: CompiledModelHandle) -> CompiledModel:
+    return cast(CompiledModel, _compiled_model_payload(ufo_sm_handle))
+
+
+def _restricted_license(**_kwargs: object) -> SymbolicaLicenseState:
+    return SymbolicaLicenseState(licensed=False, restricted=True)
+
+
+def _side_class(process: str) -> tuple[tuple[str, ...], tuple[str, ...]]:
+    initial, final = process.split(">")
+    return tuple(sorted(initial.split())), tuple(sorted(final.split()))
+
+
+def test_conserved_charges_follow_the_model_vertices(ufo_sm: CompiledModel) -> None:
+    charges = conserved_charges(ufo_sm.ir)
+
+    # Electric charge, baryon and lepton numbers per generation (diagonal CKM).
+    assert charges.balanced(("u", "d~"), ("W+",))
+    assert charges.balanced(("u", "d~"), ("c", "s~"))
+    assert charges.balanced(("e-", "mu+"), ("ve", "vm~"))
+    assert not charges.balanced(("u", "u"), ("d", "d"))
+    assert not charges.balanced(("u", "u~"), ("c", "u~"))
+    assert not charges.balanced(("e-", "e+"), ("mu-", "e+"))
+    assert charges.charges["u~"] == tuple(-value for value in charges.charges["u"])
+    assert "g" not in charges.charges and "Z" not in charges.charges
+
+
+def test_multiset_expansion_keeps_exactly_the_processes_with_amplitudes(
+    ufo_sm: CompiledModel,
+) -> None:
+    catalog = ModelParticleCatalog(
+        ufo_sm.ir.name, ufo_sm.ir.particles, ufo_sm.ir.parameters
+    )
+    model = CompiledUFOModel(ufo_sm)
+    jets = catalog.default_multiparticles()["j"]
+
+    def supported(process: str) -> bool:
+        process_ir = build_model_process_ir(process, ufo_sm.ir)
+        selected, _rejected = generation_service._select_color_ready_processes(
+            (process_ir,), color_accuracy="lc", basis="trace"
+        )
+        return bool(selected) and has_model_supported_amplitudes(
+            process_ir,
+            model=model,
+            color_plan=build_color_plan(
+                process_ir,
+                color_accuracy="lc",
+                fold_trace_reflections=(
+                    model.lc_trace_reflection_equivalence_is_proven(process_ir)
+                ),
+            ),
+        )
+
+    # The former expansion: ordered tuples, one process per side-permutation
+    # class, filtered by amplitudes.
+    first_of_class: dict[tuple[tuple[str, ...], tuple[str, ...]], str] = {}
+    for initial in itertools.product(jets, repeat=2):
+        for final in itertools.product(jets, repeat=2):
+            process = f"{' '.join(initial)} > {' '.join(final)}"
+            first_of_class.setdefault(_side_class(process), process)
+    expected = [process for process in first_of_class.values() if supported(process)]
+
+    expanded = expand_model_processes(
+        "p p > j j", catalog, charges=conserved_charges(ufo_sm.ir)
+    )
+
+    assert len({_side_class(process) for process in expanded}) == len(expanded)
+    assert [process for process in expanded if supported(process)] == expected
+    # For dijets the charge prefilter alone already removes every process
+    # without amplitudes.
+    assert list(expanded) == expected
+
+
+def _plan_names(**process: object) -> dict[str, str]:
+    plan = Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            process=ProcessConfig(flavor_scheme=5, **process),  # type: ignore[arg-type]
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        )
+    ).plan("p p > j j j j")
+    return {request.name: request.expression for request in plan.concrete_processes}
+
+
+def test_flavor_blind_plan_keeps_one_process_per_flavour_class(
+    monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+
+    every = _plan_names()
+    without_conjugation = _plan_names(
+        flavor_blind=True, consider_charge_conjugation=False
+    )
+    with caplog.at_level(logging.INFO, logger="pyamplicol.generation"):
+        with_conjugation = _plan_names(flavor_blind=True)
+    assert (
+        "Flavor-blind grouping: 486 subprocesses -> 23 generated representatives; "
+        "463 routed members (140 by charge conjugation); 0 relabelling warnings"
+    ) in caplog.messages
+
+    assert len(every) == 486
+    assert len(without_conjugation) == 33
+    assert len(with_conjugation) == 23
+    # Representatives keep the IDs and expressions they have without the flag.
+    for representatives in (without_conjugation, with_conjugation):
+        assert all(
+            every[name] == expression for name, expression in representatives.items()
+        )
+    assert set(with_conjugation.values()) <= set(without_conjugation.values())
+
+
+def _expanded(
+    processes: ProcessSet | str,
+    *,
+    model: CompiledModelHandle | None = None,
+    **process: object,
+) -> tuple[generation_service._ExpandedProcess, ...]:
+    backend = generation_service.GenerationBackend(
+        RunConfig(
+            action=Action.GENERATE,
+            process=ProcessConfig(flavor_blind=True, **process),  # type: ignore[arg-type]
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        ),
+        None,
+    )
+    if isinstance(processes, str):
+        processes = ProcessSet.from_expressions((processes,))
+    resolved = backend._resolve_model_for_plan(
+        model or backend._configured_model_source()
+    )
+    return backend._expand_process_set(
+        processes, resolved, PhaseHandle("test", None, 1)
+    )
+
+
+def _members(
+    entries: tuple[generation_service._ExpandedProcess, ...],
+) -> dict[str, tuple[str, GroupMember]]:
+    return {
+        member.expression: (entry.request.expression, member)
+        for entry in entries
+        for member in entry.group_members
+    }
+
+
+def test_flavor_blind_members_record_the_assumed_relation(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+
+    members = _members(_expanded("p p > j j", flavor_scheme=4))
+
+    representative, member = members["u u~ > g g"]
+    assert representative == "d d~ > g g"
+    assert member.basis is GroupingBasis.FLAVOR_BLIND
+    assert member.factor == Fraction(1)
+    assert not member.generated and not member.conjugated
+    assert member.permutation == (0, 1, 2, 3)
+    representative, member = members["u~ g > u~ g"]
+    assert representative == "d g > d g"
+    assert member.conjugated
+    # Pure QCD (the minimal coupling orders of jets) relabels and conjugates
+    # quarks exactly.
+    assert all(member.warning is None for _, member in members.values())
+
+
+def test_flavor_blind_warns_when_couplings_distinguish_the_flavours(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+
+    z_jet = _members(_expanded("p p > z j", flavor_scheme=4))
+    assert "relabelling" in z_jet["u u~ > g z"][1].warning
+    assert "chiral" in z_jet["d~ g > d~ z"][1].warning
+
+    dijet = _members(
+        _expanded("p p > j j", flavor_scheme=4, coupling_order_policy="explicit")
+    )
+    assert "relabelling" in dijet["u u~ > g g"][1].warning
+    # Exchanging whole generations is a symmetry of the built-in SM.
+    assert dijet["s c > s c"][0] == "d u > d u"
+    assert dijet["s c > s c"][1].warning is None
+
+
+def test_flavor_blind_keeps_processes_with_explicit_aliases(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    processes = ProcessSet.from_expressions(
+        ("d d~ > g g", "u u~ > g g", "s s~ > g g"),
+        names=("dd", "uu", "ss"),
+        aliases=(ProcessAlias("uu_swapped", "uu", (1, 0, 2, 3)),),
+    )
+
+    entries = _expanded(processes)
+
+    assert [entry.request.name for entry in entries] == ["dd", "uu"]
+    assert [member.process_id for member in entries[0].group_members] == ["ss"]
+
+
+def test_ufo_flavor_blind_conjugation_moves_the_charged_leptons(
+    monkeypatch: pytest.MonkeyPatch,
+    ufo_sm_handle: CompiledModelHandle,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+
+    members = _members(_expanded("p p > e+ e- j", model=ufo_sm_handle))
+
+    # C turns the member's e- into the representative's e+:
+    # ME(g d~ > e+ e- d~)(p) = ME(g d > e+ e- d)(p0, p1, p3, p2, p4).
+    representative, member = members["g d~ > e+ e- d~"]
+    assert representative == "g d > e+ e- d"
+    assert member.conjugated
+    assert member.permutation == (0, 1, 3, 2, 4)
+    assert "chiral" in member.warning
+    assert "relabelling" in members["g u > e+ e- u"][1].warning
+
+
+def test_ufo_request_without_charge_conserving_candidates_is_rejected(
+    monkeypatch: pytest.MonkeyPatch,
+    ufo_sm_handle: CompiledModelHandle,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+
+    with pytest.raises(GenerationError, match="conserving the additive charges"):
+        _expanded("p p > e+ mu-", model=ufo_sm_handle)
+
+
+def test_vertex_symmetry_of_ufo_relabellings_and_conjugation(
+    ufo_sm: CompiledModel,
+) -> None:
+    table = particle_table(
+        ufo_sm.ir.particles,
+        {parameter.name: parameter for parameter in ufo_sm.ir.parameters},
+    )
+    symmetry = VertexSymmetryTable.from_compiled_ir(ufo_sm.ir)
+    pdgs = {particle.name: particle.pdg_code for particle in ufo_sm.ir.particles}
+
+    def warning(member: str, representative: str, **limits: int) -> str | None:
+        processes = []
+        for expression in (member, representative):
+            initial, final = expression.split(">")
+            processes.append(
+                GroupingProcess(
+                    process_id=expression,
+                    expression=expression,
+                    pdgs=tuple(
+                        pdgs[name] for name in (*initial.split(), *final.split())
+                    ),
+                    initial_count=len(initial.split()),
+                )
+            )
+        mapping = flavor_blind_mapping(
+            processes[0], processes[1], table, consider_charge_conjugation=True
+        )
+        return symmetry.relation_warning(
+            processes[0], processes[1], mapping, table, limits=limits
+        )
+
+    assert warning("u u~ > g g", "d d~ > g g", QCD=2, QED=0) is None
+    assert warning("u~ g > u~ g", "u g > u g", QCD=2, QED=0) is None
+    assert "relabelling" in warning("u u~ > g g", "d d~ > g g", QCD=2, QED=2)
+    assert "[d~ d Z]" in warning("d~ g > d~ Z", "d g > d Z", QCD=1, QED=1)
diff --git a/pyamplicol/tests/unit/test_four_quark_compiled_gate.py b/pyamplicol/tests/unit/test_four_quark_compiled_gate.py
new file mode 100644
index 0000000000..3ace4f6200
--- /dev/null
+++ b/pyamplicol/tests/unit/test_four_quark_compiled_gate.py
@@ -0,0 +1,737 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import argparse
+import os
+from collections.abc import Callable
+from copy import deepcopy
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tools.developer import four_quark_compiled_gate as gate
+
+
+def test_checked_file_identity_rejects_a_symlink(tmp_path: Path) -> None:
+    if not hasattr(os, "O_NOFOLLOW"):
+        pytest.skip("O_NOFOLLOW is unavailable")
+    target = tmp_path / "target.bin"
+    target.write_bytes(b"authenticated")
+    link = tmp_path / "link.bin"
+    link.symlink_to(target)
+    with pytest.raises(gate.GateError, match="checked fd"):
+        gate._regular_file_identity(link)
+
+
+def _source_leaf(
+    *,
+    path: str = "evaluators/stage.symjit",
+    output_len: int = 1,
+    include_plane: bool = True,
+) -> dict[str, object]:
+    leaf: dict[str, object] = {
+        "kind": "symjit-application-evaluator",
+        "backend": "jit",
+        "runtime_capability": gate.SYMJIT_RUNTIME_CAPABILITY,
+        "input_len": 1,
+        "output_len": output_len,
+        "application_path": path,
+        "application_abi": gate.SYMJIT_APPLICATION_ABI,
+        "optimization_level": 3,
+    }
+    if include_plane:
+        leaf["plane_application"] = {
+            "application_path": path.replace(".symjit", ".plane.symjit"),
+            "application_abi": gate.SYMJIT_PLANE_APPLICATION_ABI,
+            "storage_abi": gate.SYMJIT_APPLICATION_ABI,
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": 3,
+            "direct_arena": True,
+            "source_digest": "1" * 64,
+        }
+    return leaf
+
+
+def _certificate(payload: dict[str, object]) -> dict[str, object]:
+    return {**payload, "digest": gate._canonical_sha256(payload)}
+
+
+def _direct_policies() -> dict[str, object]:
+    return {
+        "kind": gate.COMPILED_STAGE_PLAN_KIND,
+        "schema_version": gate.COMPILED_STAGE_PLAN_SCHEMA_VERSION,
+        "application_abi": gate.COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+        "source_application_abi": gate.SYMJIT_PLANE_APPLICATION_ABI,
+        "element_layout": "split-complex-component-major",
+        "input_output_aliasing": "forbidden",
+        "output_output_aliasing": "forbidden",
+        "output_operation": "overwrite",
+        "output_factor": "identity",
+        "input_bindings": [
+            {
+                "kind": "value",
+                "parameter_index": 0,
+                "source_id": 0,
+                "component": 0,
+                "global_component": 0,
+                "real_valued": False,
+            }
+        ],
+    }
+
+
+def _stage() -> dict[str, object]:
+    stage: dict[str, object] = {
+        "stage_index": 1,
+        "stage_kind": "amplitude-roots",
+        "interaction_ids": [],
+        "output_length": 1,
+        "output_slots": [
+            {
+                "current_id": -1,
+                "component_start": 0,
+                "component_stop": 1,
+                "output_start": 0,
+                "output_stop": 1,
+            }
+        ],
+        "evaluator": _source_leaf(),
+    }
+    order = {
+        "kind": "whole-current-canonical-order-v1",
+        "current_ids": [],
+        "source_stage_interaction_ids": [],
+        "interaction_ids": [],
+        "evaluation_group_ids": [],
+        "destinations": [
+            {
+                "destination_id": 0,
+                "owner_kind": "amplitude",
+                "owner_id": 0,
+                "output_start": 0,
+                "output_stop": 1,
+                "interaction_ids": [],
+                "evaluation_group_ids": [],
+                "ownership": {"kind": "residual"},
+            }
+        ],
+    }
+    stage["compiled_plane_arena"] = {
+        **_direct_policies(),
+        "output_bindings": [{"arena": "amplitude", "component": 0, "output_index": 0}],
+        "residual_leaves": [
+            {
+                "kind": gate.COMPILED_RESIDUAL_LEAF_KIND,
+                "leaf_id": 0,
+                "application_path": "evaluators/stage.plane.symjit",
+                "source_application_abi": gate.SYMJIT_PLANE_APPLICATION_ABI,
+                "optimization_level": 3,
+                "direct_codegen_optimization_level": 3,
+                "input_indices": [0],
+                "input_len": 1,
+                "output_len": 1,
+                "output_indices": [0],
+                "output_ranges": [{"output_start": 0, "output_stop": 1}],
+                "selector_domain_ids": [],
+                "color_selector_domain_ids": [],
+            }
+        ],
+        "residual_output_ranges": [{"output_start": 0, "output_stop": 1}],
+        "kernels": [],
+        "islands": [],
+        "order_certificate": _certificate(order),
+        "census": {
+            "schema_version": 1,
+            "stage_kernel_count": 0,
+            "stage_island_count": 0,
+            "stage_invocation_count": 0,
+            "stage_attachment_count": 0,
+            "stage_residual_leaf_count": 1,
+            "stage_table_destination_count": 0,
+            "stage_residual_destination_count": 1,
+        },
+    }
+    return stage
+
+
+def _mixed_current_stage() -> dict[str, object]:
+    stage: dict[str, object] = {
+        "stage_index": 0,
+        "stage_kind": "current-stage",
+        "interaction_ids": [],
+        "output_length": 2,
+        "output_slots": [
+            {
+                "current_id": 10,
+                "component_start": 4,
+                "component_stop": 5,
+                "output_start": 0,
+                "output_stop": 1,
+            },
+            {
+                "current_id": 11,
+                "component_start": 5,
+                "component_stop": 6,
+                "output_start": 1,
+                "output_stop": 2,
+            },
+        ],
+        "evaluator": _source_leaf(path="evaluators/residual.symjit"),
+    }
+    dependency = {
+        "kind": "independent-whole-current-group-v1",
+        "current_ids": [11],
+        "rows": [
+            {
+                "row_index": 0,
+                "current_id": 11,
+                "predecessor_current_ids": [1, 2],
+                "interaction_ids": [],
+                "evaluation_group_ids": [],
+            }
+        ],
+    }
+    order = {
+        "kind": "whole-current-canonical-order-v1",
+        "current_ids": [10, 11],
+        "source_stage_interaction_ids": [],
+        "interaction_ids": [],
+        "evaluation_group_ids": [],
+        "destinations": [
+            {
+                "destination_id": 0,
+                "owner_kind": "current",
+                "owner_id": 10,
+                "output_start": 0,
+                "output_stop": 1,
+                "interaction_ids": [],
+                "evaluation_group_ids": [],
+                "ownership": {"kind": "residual"},
+            },
+            {
+                "destination_id": 1,
+                "owner_kind": "current",
+                "owner_id": 11,
+                "output_start": 1,
+                "output_stop": 2,
+                "interaction_ids": [],
+                "evaluation_group_ids": [],
+                "ownership": {"kind": "table", "island_id": 0, "row_index": 0},
+            },
+        ],
+    }
+    stage["compiled_plane_arena"] = {
+        **_direct_policies(),
+        "output_bindings": [
+            {"arena": "current", "component": 4, "output_index": 0},
+            {"arena": "current", "component": 5, "output_index": 1},
+        ],
+        "residual_leaves": [
+            {
+                "kind": gate.COMPILED_RESIDUAL_LEAF_KIND,
+                "leaf_id": 0,
+                "application_path": "evaluators/residual.plane.symjit",
+                "source_application_abi": gate.SYMJIT_PLANE_APPLICATION_ABI,
+                "optimization_level": 3,
+                "direct_codegen_optimization_level": 3,
+                "input_indices": [0],
+                "input_len": 1,
+                "output_len": 1,
+                "output_indices": [0],
+                "output_ranges": [{"output_start": 0, "output_stop": 1}],
+                "selector_domain_ids": [],
+                "color_selector_domain_ids": [],
+            }
+        ],
+        "residual_output_ranges": [{"output_start": 0, "output_stop": 1}],
+        "kernels": [
+            {
+                "kernel_id": 0,
+                "motif_digest": "1" * 64,
+                "exact_source_digest": "2" * 64,
+                "source_application_abi": gate.SYMJIT_PLANE_APPLICATION_ABI,
+                "application_abi": gate.COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+                "descriptor_abi": gate.COMPILED_DIRECT_TABLE_DESCRIPTOR_ABI,
+                "binding_abi": gate.COMPILED_DIRECT_TABLE_BINDING_ABI,
+                "application_path": "evaluators/kernel.plane.symjit",
+                "application_sha256": "3" * 64,
+                "application_size_bytes": 4096,
+                "descriptor_path": "evaluators/kernel.table",
+                "descriptor_sha256": "4" * 64,
+                "descriptor_size_bytes": 256,
+                "optimization_level": 3,
+                "input_complex_count": 1,
+                "output_complex_count": 1,
+                "input_plane_count": 2,
+                "scalar_input_count": 0,
+                "parameter_bindings": [],
+            }
+        ],
+        "islands": [
+            {
+                "island_id": 0,
+                "kernel_id": 0,
+                "current_ids": [11],
+                "selector_domain_ids": [],
+                "invocation_rows": [
+                    {
+                        "plane_ids": [0, 1],
+                        "attachment_start": 0,
+                        "attachment_count": 1,
+                    }
+                ],
+                "attachment_rows": [
+                    {
+                        "destination_plane_ids": [2, 3],
+                        "factor_id": 0,
+                        "operation": "overwrite",
+                    }
+                ],
+                "factors": [[1.0, 0.0]],
+                "plane_bindings": [],
+                "scalar_bindings": [],
+                "dependency_certificate": _certificate(dependency),
+            }
+        ],
+        "order_certificate": _certificate(order),
+        "census": {
+            "schema_version": 1,
+            "stage_kernel_count": 1,
+            "stage_island_count": 1,
+            "stage_invocation_count": 1,
+            "stage_attachment_count": 1,
+            "stage_residual_leaf_count": 1,
+            "stage_table_destination_count": 1,
+            "stage_residual_destination_count": 1,
+        },
+    }
+    return stage
+
+
+def _execution_payload() -> dict[str, object]:
+    return {
+        "required_runtime_capabilities": [
+            gate.COMPILED_PLANE_ARENA_CAPABILITY,
+            gate.SYMJIT_RUNTIME_CAPABILITY,
+        ],
+        "compiled": {
+            "model_parameter_evaluator": {
+                "kind": "model-parameter-evaluator",
+                "evaluator": _source_leaf(include_plane=False),
+            },
+            "stage_evaluators": {
+                "kind": "generic-dag-stage-evaluator-artifacts",
+                "runtime_available": True,
+                "required_runtime_capabilities": [
+                    gate.COMPILED_PLANE_ARENA_CAPABILITY,
+                    gate.SYMJIT_RUNTIME_CAPABILITY,
+                ],
+                "stage_count": 2,
+                "stages": [_mixed_current_stage()],
+                "amplitude_stage": _stage(),
+            },
+        },
+    }
+
+
+def _capture(offset: float = 0.0) -> gate.EvaluationCapture:
+    return gate.EvaluationCapture(
+        physics_axes={
+            "process": gate.PROCESS,
+            "helicities": ["h:one"],
+            "color_flows": ["flow:one"],
+        },
+        f64_total=(complex(1.0 + offset), complex(2.0 + offset)),
+        exact_total=(complex(1.0 + offset), complex(2.0 + offset)),
+        f64_components=(complex(0.25 + offset), complex(0.75)),
+        exact_components=(complex(0.25 + offset), complex(0.75)),
+        color_probe=(complex(0.5 + offset), complex(1.0)),
+        helicity_probe=(complex(0.4 + offset), complex(0.8)),
+    )
+
+
+def test_recursive_direct_arena_audit_accepts_complete_o3_stage() -> None:
+    result = gate._audit_execution_payload(_execution_payload())
+
+    assert result == {
+        "capability": gate.COMPILED_PLANE_ARENA_CAPABILITY,
+        "capability_declaration_count": 2,
+        "stage_set_count": 1,
+        "stage_count": 2,
+        "descriptor_count": 2,
+        "leaf_count": 2,
+        "kernel_count": 1,
+        "island_count": 1,
+        "invocation_count": 1,
+        "attachment_count": 1,
+        "residual_destination_count": 2,
+        "table_destination_count": 1,
+        "model_parameter_slot_count": 1,
+        "model_parameter_evaluator_count": 1,
+        "model_parameter_direct_application_count": 0,
+        "passes": True,
+    }
+
+
+def test_recursive_audit_rejects_v1_and_split_ownership() -> None:
+    payload = _execution_payload()
+    amplitude = payload["compiled"]["stage_evaluators"]["amplitude_stage"]
+    amplitude["compiled_plane_arena"]["schema_version"] = 1
+    with pytest.raises(gate.GateError, match="wrong schema"):
+        gate._audit_execution_payload(payload)
+
+    payload = _execution_payload()
+    current = payload["compiled"]["stage_evaluators"]["stages"][0]
+    descriptor = current["compiled_plane_arena"]
+    order = descriptor["order_certificate"]
+    order["destinations"][0]["ownership"] = {
+        "kind": "table",
+        "island_id": 0,
+        "row_index": 0,
+    }
+    order["digest"] = gate._canonical_sha256(
+        {name: value for name, value in order.items() if name != "digest"}
+    )
+    with pytest.raises(gate.GateError, match="ownership"):
+        gate._audit_execution_payload(payload)
+
+
+def test_table_only_stage_may_omit_the_residual_evaluator() -> None:
+    stage = _mixed_current_stage()
+    stage["evaluator"] = None
+    stage["output_length"] = 1
+    stage["output_slots"] = [
+        {
+            "current_id": 11,
+            "component_start": 5,
+            "component_stop": 6,
+            "output_start": 0,
+            "output_stop": 1,
+        }
+    ]
+    descriptor = stage["compiled_plane_arena"]
+    descriptor["output_bindings"] = [
+        {"arena": "current", "component": 5, "output_index": 0}
+    ]
+    descriptor["residual_leaves"] = []
+    descriptor["residual_output_ranges"] = []
+    order_subject = {
+        "kind": "whole-current-canonical-order-v1",
+        "current_ids": [11],
+        "source_stage_interaction_ids": [],
+        "interaction_ids": [],
+        "evaluation_group_ids": [],
+        "destinations": [
+            {
+                "destination_id": 0,
+                "owner_kind": "current",
+                "owner_id": 11,
+                "output_start": 0,
+                "output_stop": 1,
+                "interaction_ids": [],
+                "evaluation_group_ids": [],
+                "ownership": {"kind": "table", "island_id": 0, "row_index": 0},
+            }
+        ],
+    }
+    descriptor["order_certificate"] = _certificate(order_subject)
+    descriptor["census"].update(
+        {
+            "stage_residual_leaf_count": 0,
+            "stage_residual_destination_count": 0,
+        }
+    )
+
+    result = gate._audit_direct_descriptor(
+        descriptor,
+        stage=stage,
+        label="table-only",
+    )
+
+    assert result["leaf_count"] == 0
+    assert result["table_destination_count"] == 1
+
+
+@pytest.mark.parametrize(
+    "mutation, message",
+    [
+        (
+            lambda payload: payload["compiled"]["stage_evaluators"][
+                "amplitude_stage"
+            ].pop("compiled_plane_arena"),
+            "compiled_plane_arena",
+        ),
+        (
+            lambda payload: payload["compiled"]["stage_evaluators"]["amplitude_stage"][
+                "compiled_plane_arena"
+            ]["residual_leaves"][0].update({"optimization_level": 2}),
+            "not JIT O3",
+        ),
+        (
+            lambda payload: payload["compiled"]["stage_evaluators"]["amplitude_stage"][
+                "compiled_plane_arena"
+            ]["residual_leaves"][0].update({"direct_codegen_optimization_level": 2}),
+            "does not match.*plane",
+        ),
+        (
+            lambda payload: payload["compiled"]["stage_evaluators"]["amplitude_stage"][
+                "compiled_plane_arena"
+            ]["residual_leaves"][0]["output_ranges"][0].update({"output_stop": 2}),
+            "residual",
+        ),
+        (
+            lambda payload: payload["compiled"]["model_parameter_evaluator"].update(
+                {"compiled_plane_arena": {"kind": "compiled-plane-arena-stage"}}
+            ),
+            "model_parameter_evaluator illegally",
+        ),
+        (
+            lambda payload: payload["compiled"]["model_parameter_evaluator"].update(
+                {
+                    "nested": {
+                        "application_abi": (gate.NATIVE_COMPILED_DIRECT_APPLICATION_ABI)
+                    }
+                }
+            ),
+            "direct application ABI",
+        ),
+    ],
+)
+def test_recursive_direct_arena_audit_rejects_descriptor_drift(
+    mutation: Callable[[dict[str, object]], object],
+    message: str,
+) -> None:
+    payload = deepcopy(_execution_payload())
+    mutation(payload)
+
+    with pytest.raises(gate.GateError, match=message):
+        gate._audit_execution_payload(payload)
+
+
+def test_lc_cross_layout_audit_requires_exact_axes_and_pointwise_parity() -> None:
+    result = gate._cross_lc_parity(_capture(), _capture())
+
+    assert result["passes"] is True
+    assert result["physical_axes_match"] is True
+    assert set(result["comparisons"]) == {
+        "f64_totals",
+        "precision32_totals",
+        "f64_resolved_components",
+        "precision32_resolved_components",
+        "color_selector",
+        "helicity_selector",
+    }
+
+    with pytest.raises(gate.GateError, match="physical axes differ"):
+        drift = _capture()
+        drift.physics_axes["color_flows"] = ["flow:other"]
+        gate._cross_lc_parity(_capture(), drift)
+
+    with pytest.raises(gate.GateError, match="f64 totals failed"):
+        gate._cross_lc_parity(_capture(), _capture(offset=1.0e-3))
+
+
+def test_union_rejection_is_checked_through_public_color_config() -> None:
+    result = gate._assert_union_rejections()
+
+    assert [entry["color_accuracy"] for entry in result] == ["nlc", "full"]
+    assert all(entry["rejected"] is True for entry in result)
+    assert all("all-flow-union" in entry["message"] for entry in result)
+
+
+def test_content_identity_addresses_the_complete_evidence_body() -> None:
+    body = {"kind": gate.RESULT_KIND, "passes": True, "lanes": {"lc": [1, 2]}}
+
+    addressed = gate._attach_content_identity(body)
+
+    assert addressed["content_identity"]["sha256"] == gate._canonical_sha256(body)
+    assert gate._attach_content_identity(body) == addressed
+    assert gate._attach_content_identity({**body, "passes": False}) != addressed
+
+
+def test_compiled_profile_requires_direct_calls_and_zero_boundary_traffic() -> None:
+    profile = {
+        "execution_mode": "compiled",
+        "evaluator_backend_call_count": 7,
+        "compiled_direct_arena_engine_count": 2,
+        "compiled_direct_arena_call_count": 7,
+    }
+    profile.update(dict.fromkeys(gate._ZERO_PROFILE_COUNTERS, 0))
+    profile.update(dict.fromkeys(gate._ZERO_PROFILE_TIMES, 0.0))
+
+    evidence = gate._audit_compiled_direct_profile(profile)
+
+    assert evidence["compiled_direct_arena_call_count"] == 7
+    assert evidence["compiled_direct_arena_engine_count"] == 2
+    assert evidence["legacy_boundary_component_total"] == 0
+    with pytest.raises(gate.GateError, match="no backend calls"):
+        gate._audit_compiled_direct_profile(
+            {**profile, "compiled_direct_arena_call_count": 0}
+        )
+    with pytest.raises(gate.GateError, match="legacy boundary traffic"):
+        gate._audit_compiled_direct_profile(
+            {**profile, "stage_input_copy_component_count": 1}
+        )
+    with pytest.raises(gate.GateError, match="every evaluator backend call"):
+        gate._audit_compiled_direct_profile(
+            {**profile, "compiled_direct_arena_call_count": 6}
+        )
+
+
+def test_helicity_probe_is_computed_nonzero_and_self_representing() -> None:
+    def helicity(
+        identifier: str,
+        *,
+        computed: bool,
+        structural_zero: bool,
+        coefficient: float,
+        representative_id: str,
+    ) -> SimpleNamespace:
+        return SimpleNamespace(
+            id=identifier,
+            computed=computed,
+            structural_zero=structural_zero,
+            coefficient=coefficient,
+            representative_id=representative_id,
+        )
+
+    physics = SimpleNamespace(
+        helicities=(
+            helicity(
+                "zero",
+                computed=False,
+                structural_zero=True,
+                coefficient=0.0,
+                representative_id="zero",
+            ),
+            helicity(
+                "first",
+                computed=True,
+                structural_zero=False,
+                coefficient=1.0,
+                representative_id="first",
+            ),
+            helicity(
+                "alias",
+                computed=False,
+                structural_zero=False,
+                coefficient=1.0,
+                representative_id="first",
+            ),
+            helicity(
+                "second",
+                computed=True,
+                structural_zero=False,
+                coefficient=1.0,
+                representative_id="second",
+            ),
+        )
+    )
+
+    selected, count = gate._select_helicity_probe(physics, lane_name="test")
+
+    assert selected.id == "second"
+    assert count == 2
+
+    with pytest.raises(gate.GateError, match="no executable helicity"):
+        gate._select_helicity_probe(
+            SimpleNamespace(helicities=(physics.helicities[0],)),
+            lane_name="test",
+        )
+
+
+def test_orchestrator_uses_exactly_four_isolated_generation_lanes(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    generated: list[str] = []
+    capture = _capture()
+    monkeypatch.setattr(gate, "_source_identity", lambda: {"revision": "a" * 40})
+    monkeypatch.setattr(gate, "_runtime_identity", lambda source: {"bound": source})
+    monkeypatch.setattr(
+        gate,
+        "_file_identity",
+        lambda path: {"path": str(path), "sha256": "c" * 64},
+    )
+    monkeypatch.setattr(
+        gate,
+        "_assert_union_rejections",
+        lambda: [{"color_accuracy": "nlc"}, {"color_accuracy": "full"}],
+    )
+    monkeypatch.setattr(
+        gate,
+        "_prepare_output_root",
+        lambda output_root, replace: tmp_path,
+    )
+    monkeypatch.setattr(gate, "_deterministic_points", lambda count: (((),),) * count)
+    monkeypatch.setattr(
+        gate,
+        "_points_identity",
+        lambda points: {"sha256": "b" * 64, "point_count": len(points)},
+    )
+
+    def generate(
+        artifact: Path,
+        lane: gate.Lane,
+        *,
+        timeout: float,
+        expected_revision: str,
+        expected_runtime_sha256: str,
+        expected_script_sha256: str,
+    ) -> dict[str, object]:
+        generated.append(lane.name)
+        return {
+            "lane": lane.name,
+            "timeout": timeout,
+            "artifact": str(artifact),
+            "expected_revision": expected_revision,
+            "expected_runtime_sha256": expected_runtime_sha256,
+            "expected_script_sha256": expected_script_sha256,
+        }
+
+    monkeypatch.setattr(gate, "_invoke_generation_worker", generate)
+    monkeypatch.setattr(
+        gate,
+        "_artifact_identity_and_audit",
+        lambda artifact, lane: ({"artifact_id": lane.name}, "process"),
+    )
+    monkeypatch.setattr(
+        gate,
+        "_evaluate_artifact",
+        lambda artifact, process_id, lane, points: ({"passes": True}, capture),
+    )
+    monkeypatch.setattr(
+        gate,
+        "_cross_lc_parity",
+        lambda topology, union: {"passes": True},
+    )
+    monkeypatch.setattr(gate, "_peak_rss_gib", lambda: 1.25)
+    arguments = argparse.Namespace(
+        output_root=tmp_path,
+        replace=False,
+        points=2,
+        generation_timeout=123.0,
+    )
+
+    result = gate.run_gate(arguments)
+
+    assert generated == [lane.name for lane in gate.LANES]
+    assert set(result["lanes"]) == {lane.name for lane in gate.LANES}
+    assert result["passes"] is True
+    assert result["status"] == "ok"
+    assert result["source_identity_match"] is True
+    assert result["runtime_identity_match"] is True
+    assert result["gate_script_identity_match"] is True
+    assert result["content_identity"]["sha256"] == gate._canonical_sha256(
+        {key: value for key, value in result.items() if key != "content_identity"}
+    )
+
+
+def test_parser_documents_mandatory_watchdog_and_two_point_default() -> None:
+    parsed = gate.parser().parse_args(["--output-root", "out"])
+
+    assert parsed.points == 2
+    assert parsed.generation_timeout == 10_800.0
+    assert "--limit-gib 30" in gate.WATCHDOG_INVOCATION
+    assert "--output-root" in gate.WATCHDOG_INVOCATION
diff --git a/pyamplicol/tests/unit/test_generation_api_validation_points.py b/pyamplicol/tests/unit/test_generation_api_validation_points.py
new file mode 100644
index 0000000000..67b5133dfe
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_api_validation_points.py
@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+
+import pyamplicol.generation.service as service_module
+from pyamplicol.generation.artifact_writer import (
+    CompiledProcessArtifact,
+    build_api_validation_points,
+)
+from pyamplicol.generation.contracts import RuntimeExpressionSchema
+from pyamplicol.generation.validation import ValidationPointRecord
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def test_api_validation_points_include_aliases_in_alias_order() -> None:
+    vectors = (
+        (20.0, 1.0, 2.0, 3.0),
+        (21.0, 4.0, 5.0, 6.0),
+        (22.0, 7.0, 8.0, 9.0),
+        (23.0, 10.0, 11.0, 12.0),
+    )
+    validation = ValidationPointRecord(
+        process_id="base",
+        process="d d~ > z g",
+        seed=7,
+        particles=tuple(
+            (pdg, vector) for pdg, vector in zip((1, -1, 23, 21), vectors, strict=True)
+        ),
+    )
+    runtime_schema = RuntimeExpressionSchema.from_mapping(
+        {
+            "amplitude_stage": {},
+            "current_storage": {},
+            "momentum_slots": [],
+            "parameter_layout": {},
+            "stages": [],
+            "value_storage": {},
+        }
+    )
+    process = CompiledProcessArtifact(
+        process_id="base",
+        expression="d d~ > z g",
+        color_accuracy="lc",
+        external_pdgs=(1, -1, 23, 21),
+        aliases=(
+            {
+                "id": "crossed",
+                "expression": "d d~ > g z",
+                "external_pdgs": [1, -1, 21, 23],
+                "external_permutation": [0, 1, 3, 2],
+            },
+        ),
+        runtime_schema=runtime_schema,
+        stage_manifest={},
+        model_parameter_evaluator=None,
+        dag_summary={},
+        evaluator_root=Path("."),
+        validation_point=validation,
+        generation_filters={},
+    )
+
+    points = build_api_validation_points((process,))
+
+    assert points == {
+        "base": vectors,
+        "crossed": (vectors[0], vectors[1], vectors[3], vectors[2]),
+    }
+
+
+def test_api_validation_points_scatter_non_self_inverse_alias_permutation() -> None:
+    vectors = tuple((float(index), 0.0, 0.0, 0.0) for index in range(5))
+    validation = ValidationPointRecord(
+        process_id="base",
+        process="d d~ > z g g",
+        seed=11,
+        particles=tuple(
+            (pdg, vector)
+            for pdg, vector in zip(
+                (1, -1, 23, 21, 21),
+                vectors,
+                strict=True,
+            )
+        ),
+    )
+    runtime_schema = RuntimeExpressionSchema.from_mapping(
+        {
+            "amplitude_stage": {},
+            "current_storage": {},
+            "momentum_slots": [],
+            "parameter_layout": {},
+            "stages": [],
+            "value_storage": {},
+        }
+    )
+    process = CompiledProcessArtifact(
+        process_id="base",
+        expression="d d~ > z g g",
+        color_accuracy="lc",
+        external_pdgs=(1, -1, 23, 21, 21),
+        aliases=(
+            {
+                "id": "cycled",
+                "expression": "d d~ > g z g",
+                "external_pdgs": [1, -1, 21, 23, 21],
+                "external_permutation": [0, 1, 3, 4, 2],
+            },
+        ),
+        runtime_schema=runtime_schema,
+        stage_manifest={},
+        model_parameter_evaluator=None,
+        dag_summary={},
+        evaluator_root=Path("."),
+        validation_point=validation,
+        generation_filters={},
+    )
+
+    points = build_api_validation_points((process,))
+
+    assert points["cycled"] == (
+        vectors[0],
+        vectors[1],
+        vectors[4],
+        vectors[2],
+        vectors[3],
+    )
+
+
+def test_alias_identity_uses_public_external_order() -> None:
+    process = build_process_ir("d d~ > z g a", color_accuracy="lc")
+
+    expression, pdgs = service_module._permuted_process_identity(
+        process,
+        (0, 1, 3, 4, 2),
+    )
+
+    assert expression == "d d~ > a z g"
+    assert pdgs == (1, -1, 22, 23, 21)
+
+
+def test_recurrence_validation_selector_cases_are_axis_bounded() -> None:
+    physics = SimpleNamespace(
+        color_flows=tuple(
+            SimpleNamespace(id=f"flow:{index}") for index in range(720)
+        ),
+        helicities=tuple(
+            SimpleNamespace(
+                id=f"h:{index}",
+                structural_zero=index >= 384,
+            )
+            for index in range(768)
+        ),
+    )
+
+    cases = service_module._recurrence_validation_selector_cases(physics)
+
+    assert cases == (
+        ("flow flow:0", {"color_flows": ("flow:0",)}),
+        ("flow flow:360", {"color_flows": ("flow:360",)}),
+        ("flow flow:719", {"color_flows": ("flow:719",)}),
+        ("helicity h:0", {"helicities": ("h:0",)}),
+        ("helicity h:192", {"helicities": ("h:192",)}),
+        ("helicity h:383", {"helicities": ("h:383",)}),
+        (
+            "combined flow and helicity",
+            {
+                "color_flows": ("flow:0",),
+                "helicities": ("h:0",),
+            },
+        ),
+        (
+            "structural-zero helicity",
+            {
+                "color_flows": ("flow:0",),
+                "helicities": ("h:384",),
+            },
+        ),
+    )
diff --git a/pyamplicol/tests/unit/test_generation_concurrency.py b/pyamplicol/tests/unit/test_generation_concurrency.py
new file mode 100644
index 0000000000..1d27e46678
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_concurrency.py
@@ -0,0 +1,613 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from threading import Barrier, Event, Lock, get_ident
+from types import SimpleNamespace
+
+import pytest
+
+import pyamplicol.generation.service as service_module
+import pyamplicol.licensing as licensing_module
+from pyamplicol.api import ModelSource, ProcessSet
+from pyamplicol.api.errors import GenerationError
+from pyamplicol.config import (
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    ProcessConfig,
+    ProcessEntry,
+    RunConfig,
+)
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.licensing import SymbolicaLicenseState
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+class _RuntimeSchemaStub:
+    def to_mapping(self) -> dict[str, object]:
+        return {"stages": []}
+
+
+def _process_artifact_stub(expanded: object) -> SimpleNamespace:
+    """The process fields that the artifact writer reads besides payloads."""
+
+    return SimpleNamespace(
+        process_id=expanded.request.name,  # type: ignore[attr-defined]
+        expression=expanded.request.expression,  # type: ignore[attr-defined]
+        external_pdgs=tuple(leg.pdg for leg in expanded.process_ir.legs),  # type: ignore[attr-defined]
+    )
+
+
+def test_parallel_process_phase_overlaps_and_preserves_input_order() -> None:
+    rendezvous = Barrier(2)
+    state_lock = Lock()
+    active = 0
+    peak_active = 0
+
+    def operation(item: int) -> str:
+        nonlocal active, peak_active
+        with state_lock:
+            active += 1
+            peak_active = max(peak_active, active)
+        try:
+            if item < 2:
+                rendezvous.wait(timeout=2.0)
+            time.sleep(0.002 * (4 - item))
+            return f"result-{item}"
+        finally:
+            with state_lock:
+                active -= 1
+
+    with ThreadPoolExecutor(max_workers=4) as executor:
+        results = service_module._map_process_phase(
+            (0, 1, 2, 3),
+            operation,
+            executor=executor,
+            max_in_flight=2,
+            phase_name="test phase",
+            item_name=lambda item: f"process-{item}",
+        )
+
+    assert peak_active == 2
+    assert results == ("result-0", "result-1", "result-2", "result-3")
+
+
+def test_one_generation_worker_runs_process_phase_serially() -> None:
+    backend = service_module.GenerationBackend(GenerationConfig(workers=1), None)
+    visited: list[int] = []
+
+    results = service_module._map_process_phase(
+        (0, 1, 2),
+        lambda item: visited.append(item) or item * 2,
+        executor=None,
+        max_in_flight=backend._process_worker_count(3),
+        phase_name="serial test phase",
+        item_name=lambda item: f"process-{item}",
+    )
+
+    assert backend._process_worker_count(3) == 1
+    assert visited == [0, 1, 2]
+    assert results == (0, 2, 4)
+
+
+def test_process_phase_stops_unscheduled_work_and_adds_process_context() -> None:
+    slow_started = Event()
+    started: list[str] = []
+    started_lock = Lock()
+
+    def operation(item: str) -> str:
+        with started_lock:
+            started.append(item)
+        if item == "slow":
+            slow_started.set()
+            time.sleep(0.05)
+            return item
+        if item == "bad":
+            assert slow_started.wait(timeout=1.0)
+            raise RuntimeError("deliberate failure")
+        raise AssertionError("unscheduled process ran")
+
+    with (
+        ThreadPoolExecutor(max_workers=2) as executor,
+        pytest.raises(
+            GenerationError,
+            match=("test compilation failed for process 'bad': deliberate failure"),
+        ),
+    ):
+        service_module._map_process_phase(
+            ("slow", "bad", "never"),
+            operation,
+            executor=executor,
+            max_in_flight=2,
+            phase_name="test compilation",
+            item_name=str,
+        )
+
+    assert sorted(started) == ["bad", "slow"]
+
+
+def test_symbolica_resources_do_not_nest_generation_worker_fanout() -> None:
+    backend = service_module.GenerationBackend(
+        RunConfig(
+            action="generate",
+            generation=GenerationConfig(workers=3),
+            evaluator=EvaluatorConfig(
+                optimization=EvaluatorOptimizationConfig(cores=4),
+                jit=JITConfig(compress=False),
+            ),
+        ),
+        None,
+    )
+
+    settings = backend._symbolica_settings()
+
+    assert backend._process_worker_count(5) == 3
+    assert settings.n_cores == 4
+    assert settings.jit_compress is False
+    assert settings.compiled_chunk_compile_workers == 1
+
+
+@pytest.mark.parametrize("mode", ("compiled", "recurrence", "on-the-fly", "eager"))
+def test_generation_symbolica_settings_resolve_python_compression_defaults(
+    mode: str,
+) -> None:
+    backend = service_module.GenerationBackend(
+        RunConfig(action="generate", evaluator=EvaluatorConfig(execution_mode=mode)),
+        None,
+    )
+    assert backend._symbolica_settings().jit_compress is (mode == "compiled")
+
+
+def test_symbolica_materialization_is_process_wide_serialized(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    backend = service_module.GenerationBackend(GenerationConfig(workers=2), None)
+    state_lock = Lock()
+    active = 0
+    peak_active = 0
+
+    def materialize(
+        process: object,
+        _model: object,
+        _temporary_root: Path,
+        _phase: object,
+        _progress: object,
+        *,
+        backend: str,
+    ) -> object:
+        assert backend == "JIT"
+        nonlocal active, peak_active
+        with state_lock:
+            active += 1
+            peak_active = max(peak_active, active)
+        try:
+            time.sleep(0.02)
+            return process
+        finally:
+            with state_lock:
+                active -= 1
+
+    monkeypatch.setattr(backend, "_materialize_evaluator_unlocked", materialize)
+    processes = tuple(
+        SimpleNamespace(
+            compiled=SimpleNamespace(
+                expanded=SimpleNamespace(request=SimpleNamespace(name=f"process-{index}"))
+            )
+        )
+        for index in range(3)
+    )
+    with ThreadPoolExecutor(max_workers=3) as executor:
+        results = tuple(
+            executor.map(
+                lambda process: backend._materialize_evaluator(
+                    process,  # type: ignore[arg-type]
+                    object(),  # type: ignore[arg-type]
+                    tmp_path,
+                    PhaseHandle("test", None, None),
+                ),
+                processes,
+            )
+        )
+
+    assert results == processes
+    assert peak_active == 1
+
+
+def test_restricted_policy_is_applied_before_model_generation_work(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    backend = service_module.GenerationBackend(
+        RunConfig(
+            action="generate",
+            generation=GenerationConfig(workers=4),
+            evaluator=EvaluatorConfig(
+                optimization=EvaluatorOptimizationConfig(cores=8)
+            ),
+        ),
+        None,
+    )
+    observed: list[tuple[object, object]] = []
+    monkeypatch.setattr(
+        backend,
+        "_detect_symbolica_license",
+        lambda: SymbolicaLicenseState(licensed=False, restricted=True),
+    )
+
+    def stop_at_model_loading(_source: object) -> object:
+        observed.append(
+            (
+                backend._generation_config.workers,
+                backend._symbolica_settings().n_cores,
+            )
+        )
+        raise GenerationError("stop after restricted preflight")
+
+    monkeypatch.setattr(backend, "_resolve_model", stop_at_model_loading)
+
+    with pytest.raises(GenerationError, match="stop after restricted preflight"):
+        backend.generate(
+            ProcessSet.from_expressions(("p p > z",)),
+            tmp_path / "artifact",
+        )
+
+    assert observed == [(1, 1)]
+    assert backend._process_worker_count(50) == 1
+    assert backend._configuration.requested.generation.workers == 4
+    assert backend._configuration.effective.generation.workers == 1
+
+
+def test_licensed_multiparticle_expansion_drives_workers_and_provenance(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    cpu_budget = 12
+    backend = service_module.GenerationBackend(
+        RunConfig(
+            action="generate",
+            process=ProcessConfig(entries=(ProcessEntry("p p > z"),)),
+            generation=GenerationConfig(
+                workers="auto",
+                validation=GenerationValidationConfig(
+                    enabled=False,
+                    post_build_validation=False,
+                ),
+            ),
+            evaluator=EvaluatorConfig(
+                execution_mode="compiled",
+                optimization=EvaluatorOptimizationConfig(cores="auto")
+            ),
+        ),
+        None,
+    )
+    monkeypatch.setattr(
+        backend,
+        "_detect_symbolica_license",
+        lambda: SymbolicaLicenseState(licensed=True, restricted=False),
+    )
+    monkeypatch.setattr(licensing_module, "_cpu_budget", lambda: cpu_budget)
+    monkeypatch.setattr(
+        backend,
+        "_artifact_model",
+        lambda _resolved: SimpleNamespace(name="test-model"),
+    )
+
+    expansion_calls = 0
+    expand_request = backend._expand_request
+
+    def track_expansion(
+        request: object,
+        resolved_model: object,
+    ) -> object:
+        nonlocal expansion_calls
+        expansion_calls += 1
+        return expand_request(request, resolved_model)  # type: ignore[arg-type]
+
+    monkeypatch.setattr(backend, "_expand_request", track_expansion)
+    monkeypatch.setattr(
+        backend,
+        "_compile_for_generation",
+        lambda entry, _model, _phase: SimpleNamespace(expanded=entry),
+    )
+    monkeypatch.setattr(
+        backend,
+        "_prepare_warmup_process",
+        lambda process, _model, **_kwargs: SimpleNamespace(
+            expanded=process.expanded,
+            filters={},
+            validation_points=(),
+        ),
+    )
+    schema = _RuntimeSchemaStub()
+    monkeypatch.setattr(
+        backend,
+        "_construct_evaluator",
+        lambda process, _model, _phase: SimpleNamespace(
+            compiled=process,
+            runtime_schema=schema,
+            helicity_sum_runtime_schema=None,
+            helicity_selector_lanes=(),
+            color_selector_lanes=(),
+        ),
+    )
+    generation_thread = get_ident()
+    materialization_threads: list[int] = []
+
+    def materialize_on_generation_thread(
+        process: object,
+        _model: object,
+        _root: Path,
+        _phase: object,
+    ) -> SimpleNamespace:
+        materialization_threads.append(get_ident())
+        return _process_artifact_stub(process.compiled.expanded)  # type: ignore[union-attr]
+
+    monkeypatch.setattr(
+        backend,
+        "_materialize_evaluator",
+        materialize_on_generation_thread,
+    )
+
+    worker_counts: list[int] = []
+    real_executor = service_module.ThreadPoolExecutor
+
+    def capture_executor(
+        *,
+        max_workers: int,
+        thread_name_prefix: str,
+    ) -> ThreadPoolExecutor:
+        worker_counts.append(max_workers)
+        return real_executor(
+            max_workers=max_workers,
+            thread_name_prefix=thread_name_prefix,
+        )
+
+    monkeypatch.setattr(service_module, "ThreadPoolExecutor", capture_executor)
+    captured: dict[str, object] = {}
+
+    def capture_artifact_configuration(
+        destination: Path,
+        **kwargs: object,
+    ) -> SimpleNamespace:
+        captured.update(kwargs)
+        return SimpleNamespace(
+            output=Path(destination),
+            files=(),
+            api_bundle_path=None,
+        )
+
+    monkeypatch.setattr(
+        service_module,
+        "write_schema_v3_artifact",
+        capture_artifact_configuration,
+    )
+
+    result = backend.generate(
+        ProcessSet.from_expressions(("p p > z",)),
+        tmp_path / "artifact",
+    )
+
+    assert expansion_calls == 1
+    assert len(result.processes.requests) == 5
+    assert worker_counts == [5]
+    assert materialization_threads == [generation_thread] * 5
+    settings = backend._symbolica_settings()
+    assert settings.n_cores == 2
+    assert worker_counts[0] * settings.n_cores <= cpu_budget
+
+    provenance = captured["configuration"]
+    requested = provenance.requested  # type: ignore[union-attr]
+    effective = provenance.effective  # type: ignore[union-attr]
+    adjustments = provenance.adjustments  # type: ignore[union-attr]
+    assert requested.generation.workers == "auto"
+    assert requested.evaluator.optimization.cores == "auto"
+    assert effective.generation.workers == 5
+    assert effective.evaluator.optimization.cores == 2
+    assert [adjustment.reason for adjustment in adjustments] == [
+        "shared affinity-aware CPU budget for concurrent process generation",
+        "shared affinity-aware CPU budget for Symbolica evaluator work",
+    ]
+
+
+def test_generation_prunes_unsupported_multiparticle_tree_channel(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    backend = service_module.GenerationBackend(
+        RunConfig(
+            action="generate",
+            generation=GenerationConfig(
+                workers=1,
+                validation=GenerationValidationConfig(
+                    enabled=False,
+                    post_build_validation=False,
+                ),
+            ),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        ),
+        None,
+    )
+    model = BuiltinSMModel()
+    resolved = service_module._ResolvedModel(
+        source=ModelSource.built_in_sm(),
+        model=model,
+        use_compiled_process_catalog=False,
+    )
+    monkeypatch.setattr(
+        backend,
+        "_detect_symbolica_license",
+        lambda: SymbolicaLicenseState(licensed=True, restricted=False),
+    )
+    monkeypatch.setattr(backend, "_resolve_model", lambda _source: resolved)
+    monkeypatch.setattr(
+        backend,
+        "_artifact_model",
+        lambda _resolved: SimpleNamespace(name="test-model"),
+    )
+    monkeypatch.setattr(
+        backend,
+        "_expand_request",
+        lambda _request, _resolved: (
+            build_process_ir("d d~ > z"),
+            build_process_ir("g g > z g g"),
+        ),
+    )
+    monkeypatch.setattr(
+        backend,
+        "_prepare_warmup_process",
+        lambda process, _model, **_kwargs: SimpleNamespace(
+            expanded=process.expanded,
+            validation_points=(),
+            filters={},
+        ),
+    )
+    schema = _RuntimeSchemaStub()
+    monkeypatch.setattr(
+        backend,
+        "_construct_evaluator",
+        lambda process, _model, _phase: SimpleNamespace(
+            compiled=process,
+            runtime_schema=schema,
+            helicity_sum_runtime_schema=None,
+            helicity_selector_lanes=(),
+            color_selector_lanes=(),
+        ),
+    )
+    monkeypatch.setattr(
+        backend,
+        "_materialize_evaluator",
+        lambda process, _model, _root, _phase: _process_artifact_stub(
+            process.compiled.expanded
+        ),
+    )
+    captured: dict[str, object] = {}
+
+    def capture_artifact(destination: Path, **kwargs: object) -> SimpleNamespace:
+        captured.update(kwargs)
+        return SimpleNamespace(
+            output=Path(destination),
+            files=(),
+            api_bundle_path=None,
+        )
+
+    monkeypatch.setattr(
+        service_module,
+        "write_schema_v3_artifact",
+        capture_artifact,
+    )
+
+    result = backend.generate(
+        ProcessSet.from_expressions(("p p > z j j",)),
+        tmp_path / "artifact",
+    )
+
+    assert [request.name for request in result.processes.requests] == [
+        "p_p_to_z_j_j_1"
+    ]
+    assert [
+        process.process_id for process in captured["processes"]  # type: ignore[union-attr]
+    ] == ["p_p_to_z_j_j_1"]
+    assert "g g > z g g" not in {
+        request.expression for request in result.processes.requests
+    }
+    assert (
+        "Skipped 1 concrete subprocess with no model-supported tree-level "
+        "amplitudes: p_p_to_z_j_j_2 (g g > z g g)"
+    ) in caplog.text
+
+
+def test_eager_generation_never_enters_compiled_evaluator_lane(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    backend = service_module.GenerationBackend(
+        RunConfig(
+            action="generate",
+            generation=GenerationConfig(
+                workers=1,
+                validation=GenerationValidationConfig(
+                    enabled=False,
+                    post_build_validation=False,
+                ),
+            ),
+            evaluator=EvaluatorConfig(execution_mode="eager"),
+        ),
+        None,
+    )
+    monkeypatch.setattr(
+        backend,
+        "_detect_symbolica_license",
+        lambda: SymbolicaLicenseState(licensed=True, restricted=False),
+    )
+    monkeypatch.setattr(backend, "_require_eager_kernel_pack", lambda _model: None)
+    monkeypatch.setattr(
+        backend, "_apply_prepared_kernel_pack_policy", lambda _model: None
+    )
+    monkeypatch.setattr(
+        backend,
+        "_artifact_model",
+        lambda _resolved: SimpleNamespace(name="prepared-test-model"),
+    )
+    monkeypatch.setattr(
+        backend,
+        "_compile_for_generation",
+        lambda entry, _model, _phase: SimpleNamespace(expanded=entry),
+    )
+    monkeypatch.setattr(
+        backend,
+        "_prepare_warmup_process",
+        lambda process, _model, **_kwargs: SimpleNamespace(
+            expanded=process.expanded,
+            filters={},
+            validation_points=(),
+        ),
+    )
+    eager_processes: list[str] = []
+
+    def construct_eager(process: object, *_args: object) -> SimpleNamespace:
+        eager_processes.append(process.expanded.request.name)  # type: ignore[union-attr]
+        return _process_artifact_stub(process.expanded)  # type: ignore[union-attr]
+
+    monkeypatch.setattr(backend, "_construct_eager_artifact", construct_eager)
+
+    def forbidden(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("eager generation entered the compiled evaluator lane")
+
+    monkeypatch.setattr(backend, "_construct_evaluator", forbidden)
+    monkeypatch.setattr(backend, "_materialize_evaluator", forbidden)
+    monkeypatch.setattr(
+        service_module,
+        "build_and_write_generic_stage_evaluator_artifacts",
+        forbidden,
+    )
+    captured: dict[str, object] = {}
+
+    def capture_artifact(destination: Path, **kwargs: object) -> SimpleNamespace:
+        captured.update(kwargs)
+        return SimpleNamespace(
+            output=Path(destination),
+            files=(),
+            api_bundle_path=None,
+        )
+
+    monkeypatch.setattr(service_module, "write_schema_v3_artifact", capture_artifact)
+    monkeypatch.setattr(backend, "_validate_generated_artifact", lambda *_a, **_k: None)
+
+    result = backend.generate(
+        ProcessSet.from_expressions(("d d~ > z",)),
+        tmp_path / "artifact",
+    )
+
+    assert eager_processes == ["d_dbar_to_z"]
+    assert [process.process_id for process in captured["processes"]] == [  # type: ignore[union-attr]
+        "d_dbar_to_z"
+    ]
+    assert result.output == tmp_path / "artifact"
diff --git a/pyamplicol/tests/unit/test_generation_config_provenance.py b/pyamplicol/tests/unit/test_generation_config_provenance.py
new file mode 100644
index 0000000000..090cd4b6eb
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_config_provenance.py
@@ -0,0 +1,340 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib
+import io
+import json
+import tomllib
+from pathlib import Path
+
+import pytest
+
+import pyamplicol.api.services as service_module
+import pyamplicol.evaluators.symbolica_adapters as symbolica_adapters
+import pyamplicol.generation.artifact_writer as artifact_writer
+import pyamplicol.licensing as licensing_module
+from pyamplicol.api import Generator, ProcessSet
+from pyamplicol.api.results import GenerationPlan, GenerationResult
+from pyamplicol.cli import run_cli
+from pyamplicol.config import (
+    ColorConfig,
+    ConfigResolution,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    ProcessConfig,
+    ProcessEntry,
+    RunConfig,
+    resolve_config,
+)
+from pyamplicol.licensing import SymbolicaLicenseState
+
+cli_main_module = importlib.import_module("pyamplicol.cli.main")
+
+
+class _PlanningBackend:
+    def __init__(self, resolution: ConfigResolution) -> None:
+        self._resolution = resolution
+
+    def plan(self, processes: ProcessSet, *, model: object = None) -> GenerationPlan:
+        del model
+        return GenerationPlan(
+            concrete_processes=processes.requests,
+            estimated_coverage={},
+            requested_settings=self._resolution.requested,
+            effective_settings=self._resolution.effective,
+            adjustments=self._resolution.clamps,
+        )
+
+    def generate(
+        self,
+        processes: ProcessSet,
+        output: Path,
+        **_kwargs: object,
+    ) -> GenerationResult:
+        return GenerationResult(output, processes, "error", files=())
+
+
+def _stub_candidate_artifact_generation(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(artifact_writer, "_default_api_bundle_hook", lambda: None)
+    monkeypatch.setattr(
+        artifact_writer,
+        "_target_metadata",
+        lambda _config: ({"triple": "aarch64-apple-darwin", "cpu_features": []}, 1),
+    )
+    monkeypatch.setattr(
+        symbolica_adapters._JITSymbolicaEvaluatorAdapter,
+        "_export_symjit_application",
+        lambda _self: (
+            b"test-symjit-application",
+            symbolica_adapters._symjit_element_layout(),
+        ),
+    )
+    monkeypatch.setattr(
+        symbolica_adapters._JITSymbolicaEvaluatorAdapter,
+        "_export_symjit_plane_application",
+        lambda _self, *, optimization_level: (
+            b"test-symjit-plane-application",
+            "0" * 64,
+            {"word_bits": 64, "endianness": "little"},
+        ),
+    )
+
+
+def test_programmatic_generator_forwards_config_resolution(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    resolution = resolve_config({"action": "generate"})
+    received: list[object] = []
+
+    def factory(config: object, progress: object) -> _PlanningBackend:
+        received.append((config, progress))
+        assert isinstance(config, ConfigResolution)
+        return _PlanningBackend(config)
+
+    monkeypatch.setattr(service_module, "_generator_factory", factory)
+    monkeypatch.setattr(
+        licensing_module,
+        "detect_symbolica_license",
+        lambda **_kwargs: SymbolicaLicenseState(licensed=True, restricted=False),
+    )
+
+    Generator(resolution).plan("d d~ > z")
+
+    assert received == [(resolution, None)]
+
+
+@pytest.mark.parametrize("contraction", ("auto", "direct"))
+def test_python_generator_preserves_automatic_fft_and_direct_opt_out(
+    monkeypatch: pytest.MonkeyPatch, contraction: str
+) -> None:
+    config = RunConfig(
+        action="generate", color=ColorConfig(accuracy="full", contraction=contraction)
+    )
+    received = []
+
+    def factory(resolution, _progress):
+        received.append(resolution)
+        return _PlanningBackend(resolution)
+
+    monkeypatch.setattr(service_module, "_generator_factory", factory)
+    monkeypatch.setattr(
+        licensing_module,
+        "detect_symbolica_license",
+        lambda **_kwargs: SymbolicaLicenseState(licensed=True, restricted=False),
+    )
+    Generator(config).plan("g g > g g")
+    assert len(received) == 1
+    assert received[0].effective.color.contraction == contraction
+    assert received[0].effective.color.fft_basis == (
+        "adjoint" if contraction == "auto" else "trace"
+    )
+
+
+@pytest.mark.parametrize("config", (None, GenerationConfig()))
+def test_python_generator_shortcuts_resolve_conditional_color_defaults(
+    monkeypatch: pytest.MonkeyPatch, config
+) -> None:
+    received = []
+
+    def factory(resolution, _progress):
+        received.append(resolution)
+        return _PlanningBackend(resolution)
+
+    monkeypatch.setattr(service_module, "_generator_factory", factory)
+    monkeypatch.setattr(
+        licensing_module,
+        "detect_symbolica_license",
+        lambda **_kwargs: SymbolicaLicenseState(licensed=True, restricted=False),
+    )
+    Generator(config).plan("g g > g g")
+    assert received[0].requested.color.contraction == "auto"
+    assert received[0].requested.color.fft_basis == "adjoint"
+    assert received[0].effective.color.accuracy == "lc"
+    assert received[0].effective.color.contraction == "direct"
+    assert received[0].effective.color.fft_basis == "trace"
+
+
+def test_programmatic_generation_applies_restricted_resource_policy(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    config = RunConfig(
+        action="generate",
+        process=ProcessConfig(entries=(ProcessEntry("d d~ > z"),)),
+        generation=GenerationConfig(workers=4),
+        evaluator=EvaluatorConfig(optimization=EvaluatorOptimizationConfig(cores=8)),
+    )
+    received: list[ConfigResolution] = []
+
+    def factory(resolution: object, _progress: object) -> _PlanningBackend:
+        assert isinstance(resolution, ConfigResolution)
+        received.append(resolution)
+        return _PlanningBackend(resolution)
+
+    monkeypatch.setattr(service_module, "_generator_factory", factory)
+    monkeypatch.setattr(
+        licensing_module,
+        "detect_symbolica_license",
+        lambda **_kwargs: SymbolicaLicenseState(licensed=False, restricted=True),
+    )
+
+    Generator(config).generate("d d~ > z", tmp_path / "artifact")
+
+    assert len(received) == 1
+    resolution = received[0]
+    assert resolution.requested.generation.workers == 4
+    assert resolution.effective.generation.workers == 1
+    assert resolution.requested.evaluator.optimization.cores == 8
+    assert resolution.effective.evaluator.optimization.cores == 1
+
+
+def test_cli_artifact_preserves_restricted_resource_provenance(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+
+    monkeypatch.setattr(
+        licensing_module,
+        "detect_symbolica_license",
+        lambda **_kwargs: SymbolicaLicenseState(licensed=False, restricted=True),
+    )
+    _stub_candidate_artifact_generation(monkeypatch)
+
+    status = run_cli(
+        (
+            "generate",
+            "p p > z",
+            str(artifact),
+            "--workers",
+            "4",
+            "--execution-mode",
+            "compiled",
+            "--cores",
+            "8",
+            "--no-jit-compress",
+            "--json",
+            "--progress",
+            "off",
+            "--set",
+            "generation.validation.post_build_validation=false",
+        ),
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 0, stderr.getvalue()
+    assert json.loads(stdout.getvalue())["output"] == str(artifact)
+
+    requested = tomllib.loads(
+        (artifact / "config/requested.toml").read_text(encoding="utf-8")
+    )
+    effective = tomllib.loads(
+        (artifact / "config/effective.toml").read_text(encoding="utf-8")
+    )
+    assert requested["generation"]["workers"] == 4
+    assert effective["generation"]["workers"] == 1
+    assert requested["process"]["entries"] == [{"expression": "p p > z"}]
+    assert effective["process"]["entries"] == [{"expression": "p p > z"}]
+    assert requested["evaluator"]["optimization"]["cores"] == 8
+    assert effective["evaluator"]["optimization"]["cores"] == 1
+    assert requested["evaluator"]["jit"]["compress"] is False
+    assert effective["evaluator"]["jit"]["compress"] is False
+    assert requested["generation"]["emit_api_bundle"] is True
+    assert effective["generation"]["emit_api_bundle"] is False
+    assert requested != effective
+
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    assert len(manifest["processes"]) == 5
+    assert manifest["configuration"]["adjustments"] == [
+        {
+            "path": "generation.workers",
+            "reason": ("Symbolica restricted mode permits one generation instance"),
+        },
+        {
+            "path": "evaluator.optimization.cores",
+            "reason": "Symbolica restricted mode permits one Symbolica core",
+        },
+        {
+            "path": "generation.emit_api_bundle",
+            "reason": "no root API-bundle emitter is installed",
+        },
+    ]
+    assert manifest["runtime"]["api_bundle_path"] is None
+
+
+def test_cli_licensed_multiparticle_uses_concrete_resource_partition(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    cpu_budget = 12
+
+    monkeypatch.setattr(
+        licensing_module,
+        "detect_symbolica_license",
+        lambda **_kwargs: SymbolicaLicenseState(licensed=True, restricted=False),
+    )
+    monkeypatch.setattr(licensing_module, "_cpu_budget", lambda: cpu_budget)
+    _stub_candidate_artifact_generation(monkeypatch)
+
+    status = run_cli(
+        (
+            "generate",
+            "p p > z",
+            str(artifact),
+            "--execution-mode",
+            "compiled",
+            "--json",
+            "--progress",
+            "off",
+            "--set",
+            "generation.validation.post_build_validation=false",
+            "--set",
+            "generation.relation_discovery.mode=off",
+        ),
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    assert status == 0, stderr.getvalue()
+    assert json.loads(stdout.getvalue())["output"] == str(artifact)
+    requested = tomllib.loads(
+        (artifact / "config/requested.toml").read_text(encoding="utf-8")
+    )
+    effective = tomllib.loads(
+        (artifact / "config/effective.toml").read_text(encoding="utf-8")
+    )
+    workers = effective["generation"]["workers"]
+    cores = effective["evaluator"]["optimization"]["cores"]
+    assert requested["generation"]["workers"] == "auto"
+    assert requested["evaluator"]["optimization"]["cores"] == "auto"
+    assert workers == 5
+    assert cores == 2
+    assert workers * cores <= cpu_budget
+
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    assert len(manifest["processes"]) == 5
+    assert manifest["configuration"]["adjustments"] == [
+        {
+            "path": "generation.workers",
+            "reason": (
+                "shared affinity-aware CPU budget for concurrent process generation"
+            ),
+        },
+        {
+            "path": "evaluator.optimization.cores",
+            "reason": "shared affinity-aware CPU budget for Symbolica evaluator work",
+        },
+        {
+            "path": "generation.emit_api_bundle",
+            "reason": "no root API-bundle emitter is installed",
+        },
+    ]
diff --git a/pyamplicol/tests/unit/test_generation_dag_extraction.py b/pyamplicol/tests/unit/test_generation_dag_extraction.py
new file mode 100644
index 0000000000..3724fb4a88
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_dag_extraction.py
@@ -0,0 +1,388 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import pytest
+
+import pyamplicol.generation.service as service_module
+from pyamplicol.api import Generator, ProcessAlias, ProcessRequest, ProcessSet
+from pyamplicol.api.errors import GenerationError
+from pyamplicol.color.plan import build_color_plan
+from pyamplicol.config import EvaluatorConfig, ProcessConfig, RunConfig
+from pyamplicol.generation.dag_algorithms import (
+    _infer_minimal_coupling_order_limits_from_color_plan,
+    infer_minimal_coupling_order_limits,
+)
+from pyamplicol.generation.dag_types import ColorState, CurrentIndex
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.generation.runtime_schema import build_runtime_expression_schema
+from pyamplicol.generation.service import GenerationBackend
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _index(*, chirality: int = 1, ordered: tuple[int, ...] = (1, 2)) -> CurrentIndex:
+    return CurrentIndex(
+        particle_id=1,
+        external_mask=3,
+        external_labels=(1, 2),
+        ordered_external_labels=ordered,
+        helicity_ancestry=3,
+        chirality=chirality,
+        spin_state=chirality,
+        flavour_flow=(1,),
+        quantum_number_flow=(("electric_charge", "-1/3"),),
+        color_state=ColorState(
+            accuracy="lc",
+            sector_id=0,
+            line_groups=(0,),
+            basis_key=(1, 2),
+        ),
+        momentum_mask=3,
+        coupling_orders=(("qed", 1),),
+    )
+
+
+def test_generation_current_identity_keeps_every_physics_field() -> None:
+    reference = _index()
+    assert reference == _index()
+    assert reference != _index(chirality=-1)
+    assert reference != _index(ordered=(2, 1))
+    payload = reference.to_json_dict()
+    assert payload["ordered_external_labels"] == [1, 2]
+    assert payload["coupling_orders"] == [["QED", 1]]
+    assert payload["color_state"]["basis_key"] == [1, 2]
+
+
+def test_generation_plan_defers_dag_compilation() -> None:
+    plan = Generator(
+        RunConfig(
+            action="generate",
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        )
+    ).plan("d d~ > z")
+    process = plan.estimated_coverage["processes"][0]
+
+    assert process["key"] == "d_dbar_to_z"
+    assert process["dag_compilation_deferred"] is True
+    assert "source_count" not in process
+    assert plan.concrete_processes[0].expression == "d d~ > z"
+
+
+def test_only_expansion_derived_unsupported_tree_channel_is_prunable() -> None:
+    backend = GenerationBackend(None, None)
+    model = BuiltinSMModel()
+    process_ir = build_process_ir("g g > z g g")
+    expanded = service_module._ExpandedProcess(
+        request=ProcessRequest.parse(
+            process_ir.process,
+            name="pp_zjj_19",
+        ),
+        process_ir=process_ir,
+        source_expansion_size=19,
+    )
+
+    outcome = backend._compile_for_generation(
+        expanded,
+        model,
+        PhaseHandle("multiparticle-dag", None, 1),
+    )
+
+    assert isinstance(outcome, service_module._UnsupportedProcess)
+    assert outcome.expanded == expanded
+    assert "no model-supported tree-level amplitudes" in outcome.reason
+
+    explicit = service_module._ExpandedProcess(
+        request=ProcessRequest.parse(process_ir.process, name="explicit"),
+        process_ir=process_ir,
+    )
+    with pytest.raises(
+        GenerationError,
+        match="no model-supported tree-level amplitudes",
+    ):
+        backend._compile_for_generation(
+            explicit,
+            model,
+            PhaseHandle("explicit-dag", None, 1),
+        )
+
+
+def test_unsupported_expansion_cannot_silently_remove_a_whole_request() -> None:
+    backend = GenerationBackend(None, None)
+    model = BuiltinSMModel()
+    supported_source = ProcessRequest.parse("d d~ > z", name="supported")
+    supported_ir = build_process_ir(supported_source.expression)
+    supported = backend._compile_for_generation(
+        service_module._ExpandedProcess(
+            request=supported_source,
+            process_ir=supported_ir,
+            source_request=supported_source,
+        ),
+        model,
+        PhaseHandle("supported-dag", None, 1),
+    )
+    assert isinstance(supported, service_module._DagProcess)
+
+    unsupported_source = ProcessRequest.parse("p p > z j j", name="loop-only")
+    unsupported_ir = build_process_ir("g g > z g g")
+    unsupported = backend._compile_for_generation(
+        service_module._ExpandedProcess(
+            request=ProcessRequest.parse(
+                unsupported_ir.process,
+                name="loop-only_1",
+            ),
+            process_ir=unsupported_ir,
+            source_expansion_size=2,
+            source_request=unsupported_source,
+        ),
+        model,
+        PhaseHandle("unsupported-dag", None, 1),
+    )
+    assert isinstance(unsupported, service_module._UnsupportedProcess)
+
+    with pytest.raises(
+        GenerationError,
+        match=(
+            "no model-supported tree-level amplitudes for requested process: "
+            "'p p > z j j'"
+        ),
+    ):
+        service_module._partition_model_supported_processes(
+            (supported, unsupported)
+        )
+
+
+def test_recurrence_generation_drops_expanded_processes_without_amplitudes() -> None:
+    """Recurrence builders need an amplitude: unconnectable children are skipped."""
+
+    backend = GenerationBackend(None, None)
+    model = BuiltinSMModel()
+    source = ProcessRequest.parse("p p > j j", name="pp_jj")
+
+    def expanded(expression: str, index: int) -> service_module._ExpandedProcess:
+        return service_module._ExpandedProcess(
+            request=ProcessRequest.parse(expression, name=f"pp_jj_{index}"),
+            process_ir=build_process_ir(expression),
+            source_expansion_size=3,
+            source_request=source,
+        )
+
+    candidates = (
+        expanded("d d~ > g g", 1),
+        expanded("d d > d d~", 2),
+        expanded("g g > g d", 3),
+    )
+    kept = backend._drop_processes_without_amplitudes(candidates, model)
+    assert kept == candidates[:1]
+
+    with pytest.raises(GenerationError, match="'p p > j j'"):
+        backend._drop_processes_without_amplitudes(candidates[1:], model)
+
+
+def test_generation_plan_and_physics_preserve_selected_coverage() -> None:
+    config = RunConfig(
+        action="generate",
+        process=ProcessConfig(
+            selected_color_sector_ids=(0,),
+            selected_source_helicities={"1": 1},
+        ),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+    generator = Generator(config)
+    plan = generator.plan("d d~ > z g g")
+    planned = plan.estimated_coverage["processes"][0]
+    assert planned["color_sector_count"] == 1
+    assert planned["color_coverage"] == "selected"
+    assert planned["helicity_coverage"] == "selected"
+
+    backend = GenerationBackend(config, None)
+    model = BuiltinSMModel()
+    dag, coverage = backend._compile_concrete_process(
+        build_process_ir("d d~ > z g g"),
+        model,
+    )
+    physics = build_runtime_expression_schema(dag, model).to_mapping()["physics"]
+
+    assert coverage["color_sector_count"] == 1
+    assert coverage["color_coverage"] == "selected"
+    assert coverage["helicity_coverage"] == "selected"
+    assert physics["coverage"]["color"] == "selected"
+    assert physics["coverage"]["helicities"] == "selected"
+    assert all(record["values"][0] == 1 for record in physics["helicities"])
+
+
+def test_generation_plan_rejects_missing_selected_sector() -> None:
+    config = RunConfig(
+        action="generate",
+        process=ProcessConfig(selected_color_sector_ids=(999,)),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+
+    with pytest.raises(GenerationError, match="did not materialize requested"):
+        Generator(config).plan("d d~ > z g g")
+
+
+def test_generation_plan_uses_production_alias_validation() -> None:
+    request = ProcessRequest.parse("d d~ > z g", name="base")
+    valid = ProcessSet(
+        (request,),
+        aliases=(
+            ProcessAlias(
+                name="permuted",
+                process_name="base",
+                particle_permutation=(0, 1, 3, 2),
+            ),
+        ),
+    )
+
+    compiled_config = RunConfig(
+        action="generate",
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+    plan = Generator(compiled_config).plan(valid)
+
+    assert plan.estimated_coverage["alias_count"] == 1
+    assert plan.concrete_processes == (request,)
+
+    both_sides = ProcessSet(
+        (request,),
+        aliases=(
+            ProcessAlias(
+                name="both_sides",
+                process_name="base",
+                particle_permutation=(1, 0, 3, 2),
+            ),
+        ),
+    )
+    assert Generator(compiled_config).plan(both_sides).estimated_coverage[
+        "alias_count"
+    ] == 1
+
+    crossing = ProcessSet(
+        (request,),
+        aliases=(
+            ProcessAlias(
+                name="crossing",
+                process_name="base",
+                particle_permutation=(0, 2, 1, 3),
+            ),
+        ),
+    )
+    with pytest.raises(GenerationError, match="incoming and outgoing sides"):
+        Generator(compiled_config).plan(crossing)
+
+    invalid = ProcessSet(
+        (request,),
+        aliases=(
+            ProcessAlias(
+                name="bad",
+                process_name="base",
+                particle_permutation=(0, 1, 2),
+            ),
+        ),
+    )
+    with pytest.raises(GenerationError, match="permutation has length"):
+        Generator(compiled_config).plan(invalid)
+
+
+def test_minimal_coupling_limits_zero_nonminimal_model_orders() -> None:
+    limits = infer_minimal_coupling_order_limits(
+        build_process_ir("d d~ > u u~"),
+        model=BuiltinSMModel(),
+    )
+
+    assert limits == {"QCD": 2, "QED": 0}
+
+
+def test_minimal_coupling_limits_accept_existing_complete_color_plan() -> None:
+    process = build_process_ir("d d~ > u u~")
+    model = BuiltinSMModel()
+    color_plan = build_color_plan(
+        process,
+        color_accuracy=process.color_accuracy,
+        fold_trace_reflections=(
+            model.lc_trace_reflection_equivalence_is_proven(process)
+        ),
+    )
+
+    assert _infer_minimal_coupling_order_limits_from_color_plan(
+        process,
+        model=model,
+        color_plan=color_plan,
+    ) == infer_minimal_coupling_order_limits(process, model=model)
+
+
+def test_process_preparation_reuses_complete_color_plan_for_minimal_inference(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    process = build_process_ir("d d~ > u u~")
+    model = BuiltinSMModel()
+    reused_plans: list[object] = []
+    infer_from_plan = (
+        service_module._infer_minimal_coupling_order_limits_from_color_plan
+    )
+
+    def track_inference(*args: object, **kwargs: object) -> dict[str, int]:
+        reused_plans.append(kwargs["color_plan"])
+        return infer_from_plan(*args, **kwargs)
+
+    def reject_rebuild(*_args: object, **_kwargs: object) -> dict[str, int]:
+        pytest.fail("minimal inference rebuilt a color plan")
+
+    monkeypatch.setattr(
+        service_module,
+        "_infer_minimal_coupling_order_limits_from_color_plan",
+        track_inference,
+    )
+    monkeypatch.setattr(
+        service_module,
+        "infer_minimal_coupling_order_limits",
+        reject_rebuild,
+    )
+    prepared = GenerationBackend(
+        RunConfig(
+            action="generate",
+            evaluator=EvaluatorConfig(execution_mode="recurrence"),
+        ),
+        None,
+    )._prepare_process_construction(process, model)
+
+    assert len(reused_plans) == 1
+    assert reused_plans[0] is prepared.complete_color_plan
+
+
+def test_process_preparation_preserves_custom_color_plan_inference_path(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    process = build_process_ir("d d~ > u u~")
+    model = BuiltinSMModel()
+    rebuilds = 0
+
+    def reject_reuse(*_args: object, **_kwargs: object) -> dict[str, int]:
+        pytest.fail("custom color-plan inference unexpectedly reused a truncated plan")
+
+    def track_rebuild(*_args: object, **_kwargs: object) -> dict[str, int]:
+        nonlocal rebuilds
+        rebuilds += 1
+        return {"QCD": 2, "QED": 0}
+
+    monkeypatch.setattr(
+        service_module,
+        "_infer_minimal_coupling_order_limits_from_color_plan",
+        reject_reuse,
+    )
+    monkeypatch.setattr(
+        service_module,
+        "infer_minimal_coupling_order_limits",
+        track_rebuild,
+    )
+    prepared = GenerationBackend(
+        RunConfig(
+            action="generate",
+            process=ProcessConfig(max_color_sectors=1),
+            evaluator=EvaluatorConfig(execution_mode="recurrence"),
+        ),
+        None,
+    )._prepare_process_construction(process, model)
+
+    assert rebuilds == 1
+    assert prepared.coupling_order_limits == {"QCD": 2, "QED": 0}
diff --git a/pyamplicol/tests/unit/test_generation_execution_schema.py b/pyamplicol/tests/unit/test_generation_execution_schema.py
new file mode 100644
index 0000000000..3e97657ab3
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_execution_schema.py
@@ -0,0 +1,198 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+
+from symbolica import S
+
+from pyamplicol.generation.artifact_writer import _execution_plan
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.runtime_schema import build_runtime_schema
+from pyamplicol.models import BuiltinSMModel, CompiledUFOModel, compile_model_source
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.processes.model import build_model_process_ir
+
+ROOT = Path(__file__).resolve().parents[2]
+MODEL_ROOT = ROOT / "src" / "pyamplicol" / "assets" / "models"
+
+
+def test_execution_plan_is_strict_schema_v3_runtime_dto() -> None:
+    model = BuiltinSMModel()
+    schema = build_runtime_schema(
+        compile_generic_dag(build_process_ir("d d~ > z"), model=model),
+        model,
+        process_id="ddbar_z",
+    )
+    for stage in schema["stages"]:
+        assert stage["interactions_compacted"] is True
+        assert stage["interactions"] == []
+        assert len(stage["interaction_ids"]) == stage["interaction_count"]
+
+    for leg in schema["external_particles"]:
+        assert "particle_class" not in leg
+        assert {
+            "statistics",
+            "wavefunction_family",
+            "color_role",
+            "source_orientation",
+        } <= leg.keys()
+
+    plan = _execution_plan(schema)
+
+    assert set(plan) == {
+        "amplitude_stage",
+        "current_storage",
+        "external_particles",
+        "kind",
+        "model",
+        "model_parameters",
+        "momentum_slots",
+        "normalization",
+        "parameter_layout",
+        "process",
+        "process_key",
+        "schema_version",
+        "source_fill",
+        "stages",
+        "value_storage",
+    }
+    assert plan["schema_version"] == 3
+    assert plan["kind"] == "pyamplicol-runtime-execution-plan"
+    assert plan["process_key"] == "ddbar_z"
+    assert "physics" not in plan
+    assert "momentum_conventions" not in plan
+    assert {
+        record["name"] for record in plan["model_parameters"]
+    } >= {
+        "normalization.alpha_s_me_check",
+        "normalization.alpha_ew",
+    }
+    physics_normalization = schema["physics"]["extensions"]["normalization"]
+    assert "coherent_groups" not in schema["physics"]["extensions"]
+    assert "color_contraction" not in schema["physics"]["extensions"]
+    assert "final_state_identical_factor" not in physics_normalization
+    assert "quark_line_partner_factor" not in physics_normalization
+
+    for slot in plan["value_storage"]["value_slots"]:
+        propagator = slot["propagator"]
+        assert propagator["particle_id"] == slot["particle_id"]
+        assert propagator["chirality"] == slot["chirality"]
+        assert propagator["kind"] in {
+            "identity",
+            "scalar",
+            "weyl-fermion",
+            "dirac-fermion",
+            "vector",
+            "spin2",
+            "custom",
+            "unsupported",
+        }
+        assert propagator["mass_class"] in {
+            "massless",
+            "massive",
+            "not-applicable",
+        }
+
+    layout = plan["parameter_layout"]
+    assert layout["parameter_count_if_flattened"] == (
+        layout["source_component_parameter_count"]
+        + layout["momentum_parameter_count"]
+        + layout["model_parameter_count"]
+    )
+    assert layout["real_valued_inputs"] == list(
+        range(
+            layout["source_component_parameter_count"],
+            layout["parameter_count_if_flattened"],
+        )
+    )
+
+    for stage in plan["stages"]:
+        assert "input_momentum_slot_ids" not in stage
+        assert "interaction_evaluation_count" not in stage
+        assert stage["interactions_compacted"] is True
+        assert stage["interactions"] == []
+        assert len(stage["interaction_ids"]) == stage["interaction_count"]
+
+    amplitude = plan["amplitude_stage"]
+    assert "coherent_groups" not in amplitude
+    assert "final_reduction" not in amplitude
+    for root in amplitude["roots"]:
+        assert "dag_root_id" not in root
+        assert "coupling_parameter_names" not in root
+
+
+def test_external_particle_masses_link_to_runtime_parameters() -> None:
+    compiled = compile_model_source(
+        MODEL_ROOT / "json" / "sm" / "sm.json",
+        restriction=str(
+            (MODEL_ROOT / "json" / "sm" / "restrict_default.json").resolve()
+        ),
+        use_cache=False,
+    )
+    model = CompiledUFOModel(compiled)
+
+    z_schema = build_runtime_schema(
+        compile_generic_dag(
+            build_model_process_ir("d d~ > z", compiled.ir),
+            model=model,
+        ),
+        model,
+        process_id="ddbar_z_external",
+    )
+    z_plan = _execution_plan(z_schema)
+    z_record = next(
+        particle for particle in z_plan["model"]["particles"] if particle["pdg"] == 23
+    )
+    assert z_record["mass_parameter"] == "MZ"
+
+    w_schema = build_runtime_schema(
+        compile_generic_dag(
+            build_model_process_ir("u d~ > w+", compiled.ir),
+            model=model,
+        ),
+        model,
+        process_id="udbar_wp_external",
+    )
+    w_plan = _execution_plan(w_schema)
+    w_record = next(
+        particle for particle in w_plan["model"]["particles"] if particle["pdg"] == 24
+    )
+    assert w_record["mass_parameter"] == "MW"
+    derived = {
+        record["runtime_name"]
+        for record in w_plan["model_parameters"]
+        if record["kind"] == "derived_parameter_component"
+    }
+    assert "MW" in derived
+    assert "MZ" in model.runtime_derived_parameter_definitions_for(("MW",))["MW"]
+
+
+def test_massless_vector_uses_generation_propagator_contract_with_symbolic_mass() -> (
+    None
+):
+    compiled = compile_model_source(
+        MODEL_ROOT / "json" / "sm" / "sm.json",
+        restriction=str(
+            (MODEL_ROOT / "json" / "sm" / "restrict_default.json").resolve()
+        ),
+        use_cache=False,
+    )
+    model = CompiledUFOModel(compiled)
+    propagator = model._propagator_ir(21)
+    assert propagator.kind == "vector"
+    assert propagator.mass_class == "massless"
+    assert propagator.gauge == "feynman"
+
+    symbolic_mass = S("runtime_mass_probe")
+    runtime_model = model.with_runtime_parameters({"ZERO": symbolic_mass})
+    result = runtime_model.propagator_component_expression(
+        21,
+        tuple(S(f"current_{index}") for index in range(4)),
+        (10.0, 1.0, 2.0, 3.0),
+        propagator=propagator,
+    )
+
+    assert all(
+        "runtime_mass_probe" not in component.to_canonical_string()
+        for component in result
+    )
diff --git a/pyamplicol/tests/unit/test_generation_filter_reporting.py b/pyamplicol/tests/unit/test_generation_filter_reporting.py
new file mode 100644
index 0000000000..9af0df4c74
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_filter_reporting.py
@@ -0,0 +1,402 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+
+import pytest
+
+import pyamplicol.generation.service as service_module
+from pyamplicol.api import ProcessRequest
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    RunConfig,
+)
+from pyamplicol.generation.helicity_replay import (
+    HELICITY_RECURRENCE_CONTRACT_VERSION,
+)
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def test_generation_reports_structural_reduction_and_helicity_recurrence() -> None:
+    model = BuiltinSMModel()
+    backend = service_module.GenerationBackend(GenerationConfig(), None)
+    process_ir = build_process_ir("d d~ > z", color_accuracy="lc")
+    dag, coverage = backend._compile_concrete_process(process_ir, model)
+    expanded = service_module._ExpandedProcess(
+        request=ProcessRequest.parse("d d~ > z", name="ddbar_z"),
+        process_ir=process_ir,
+        aliases=(
+            {
+                "id": "ddbar_z_alias",
+                "expression": "d d~ > z",
+                "external_pdgs": [1, -1, 23],
+                "external_permutation": [0, 1, 2],
+            },
+        ),
+    )
+
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(expanded, dag, coverage),
+        model,
+        index=0,
+        phase=PhaseHandle("test", None, 1),
+    )
+
+    assert set(prepared.filters) == {
+        "dynamic_color_projection",
+        "structural_helicity_reduction",
+        "helicity_recurrence",
+        "lc_flow_layout",
+        "relation_discovery",
+    }
+    dynamic_projection = prepared.filters["dynamic_color_projection"]
+    assert isinstance(dynamic_projection, dict)
+    assert dynamic_projection["equality_check_status"].startswith("passed-")
+    structural = prepared.filters["structural_helicity_reduction"]
+    assert isinstance(structural, dict)
+    assert structural["mode"] == "proven global-helicity-flip equivalence"
+    recurrence = prepared.filters["helicity_recurrence"]
+    assert isinstance(recurrence, dict)
+    assert recurrence["contract_version"] == HELICITY_RECURRENCE_CONTRACT_VERSION
+    assert recurrence["residual_current_count"] == 0
+    assert len(prepared.validation_points) == 1
+    assert [point.seed for point in prepared.validation_points] == [12345]
+
+    metadata_only_backend = service_module.GenerationBackend(
+        GenerationConfig(
+            validation=GenerationValidationConfig(enabled=False, samples=25)
+        ),
+        None,
+    )
+    metadata_only = metadata_only_backend._prepare_warmup_process(
+        service_module._DagProcess(expanded, dag, coverage),
+        model,
+        index=0,
+        phase=PhaseHandle("test-disabled", None, 1),
+    )
+    assert len(metadata_only.validation_points) == 1
+
+
+def test_opt_in_relation_discovery_is_scoped_in_generation_filters() -> None:
+    model = BuiltinSMModel()
+    backend = service_module.GenerationBackend(
+        GenerationConfig(
+            relation_discovery=GenerationRelationDiscoveryConfig(
+                mode="diagnostic",
+                precision_digits=80,
+                probe_count=2,
+                verification_probe_count=2,
+                seed=31,
+            )
+        ),
+        None,
+    )
+    process_ir = build_process_ir("d d~ > z", color_accuracy="lc")
+    dag, coverage = backend._compile_concrete_process(process_ir, model)
+    assert "relation_discovery" not in coverage
+
+    expanded = service_module._ExpandedProcess(
+        request=ProcessRequest.parse("d d~ > z", name="ddbar_z"),
+        process_ir=process_ir,
+        aliases=(),
+    )
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(expanded, dag, coverage),
+        model,
+        index=0,
+        phase=PhaseHandle("test-discovery", None, 1),
+    )
+    discovery = prepared.filters["relation_discovery"]
+    assert isinstance(discovery, dict)
+    assert discovery["abi"] == "pyamplicol-artifact-numerical-current-reuse-v1"
+    assert discovery["requested_mode"] == "diagnostic"
+    assert discovery["effective_mode"] == "diagnostic"
+    assert discovery["execution_mode"] == "compiled"
+    assert discovery["applied_relation_count"] == 0
+    assert discovery["relation_correctness"]["state"] == ("no-applied-relations")
+    assert discovery["warning"]["required"] is False
+    assert discovery == prepared.coverage["relation_discovery"]
+
+    lanes = discovery["lanes"]
+    assert isinstance(lanes, dict)
+    assert discovery["lane_count"] == len(lanes)
+    assert "primary" in lanes
+    primary = lanes["primary"]
+    assert primary["state"] == "no_certified_numerical_relation"
+    assert primary["scope"] == {
+        "execution_mode": "compiled",
+        "color_accuracy": "lc",
+        "representation": "generic-dag",
+    }
+    candidate = primary["candidate_capture"]
+    verification = primary["verification_capture"]
+    assert candidate["precision_digits"] == 80
+    assert candidate["point_count"] == 2
+    assert verification["point_count"] == 2
+    assert set(candidate["kinematic_sha256s"]).isdisjoint(
+        verification["kinematic_sha256s"]
+    )
+
+
+def test_numerical_current_reuse_opt_out_skips_every_warmup_capture(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model = BuiltinSMModel()
+    backend = service_module.GenerationBackend(
+        GenerationConfig(
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off")
+        ),
+        None,
+    )
+
+    def forbidden_capture(*args, **kwargs):
+        del args, kwargs
+        raise AssertionError("opt-out must not run numerical current capture")
+
+    monkeypatch.setattr(
+        service_module,
+        "run_generic_dag_numerical_current_warmup",
+        forbidden_capture,
+    )
+    process_ir = build_process_ir("d d~ > z", color_accuracy="lc")
+    dag, coverage = backend._compile_concrete_process(process_ir, model)
+    expanded = service_module._ExpandedProcess(
+        request=ProcessRequest.parse("d d~ > z", name="ddbar_z"),
+        process_ir=process_ir,
+        aliases=(),
+    )
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(expanded, dag, coverage),
+        model,
+        index=0,
+        phase=PhaseHandle("test-opt-out", None, 1),
+    )
+
+    discovery = prepared.filters["relation_discovery"]
+    assert discovery["requested_mode"] == "off"
+    assert discovery["effective_mode"] == "off"
+    assert discovery["applied_relation_count"] == 0
+    assert discovery["warning"]["required"] is False
+    assert discovery["lanes"]
+    for report in discovery["lanes"].values():
+        assert report["state"] == "disabled-by-user"
+        assert report["candidate_capture"] is None
+        assert report["verification_capture"] is None
+
+
+def test_full_color_opt_out_skips_inapplicable_projection_provenance(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model = BuiltinSMModel()
+    backend = service_module.GenerationBackend(
+        RunConfig(
+            action="generate",
+            color=ColorConfig(accuracy="full"),
+            generation=GenerationConfig(
+                relation_discovery=GenerationRelationDiscoveryConfig(mode="off")
+            ),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        ),
+        None,
+    )
+    process_ir = build_process_ir("d d~ > z", color_accuracy="full")
+    dag, coverage = backend._compile_concrete_process(process_ir, model)
+    current = dag.currents[0]
+    dag = replace(
+        dag,
+        currents=(
+            replace(
+                current,
+                index=replace(current.index, helicity_ancestry=10**4300),
+            ),
+            *dag.currents[1:],
+        ),
+    )
+    monkeypatch.setattr(
+        service_module,
+        "build_helicity_recurrence_plan",
+        lambda *_args, **_kwargs: None,
+    )
+    expanded = service_module._ExpandedProcess(
+        request=ProcessRequest.parse("d d~ > z", name="ddbar_z_full"),
+        process_ir=process_ir,
+        aliases=(),
+    )
+
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(expanded, dag, coverage),
+        model,
+        index=0,
+        phase=PhaseHandle("test-full-opt-out", None, 1),
+    )
+
+    projection = prepared.filters["dynamic_color_projection"]
+    assert projection["equality_check_status"] == "not-applicable-color-accuracy"
+    assert projection["color_accuracy"] == "full"
+    assert not any(key.endswith("_sha256") for key in projection)
+    assert "old_to_new_current_ids" not in projection
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    (
+        (None, False),
+        ({}, False),
+        ({"warning": {"required": False}}, False),
+        ({"warning": {"required": True}}, True),
+    ),
+)
+def test_numerical_current_warning_aggregation(value, expected) -> None:
+    assert service_module._numerical_current_warning_required(value) is expected
+
+
+def test_certified_numerical_current_reuse_applies_on_final_materialized_dag() -> None:
+    model = BuiltinSMModel()
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="full"),
+        generation=GenerationConfig(
+            relation_discovery=GenerationRelationDiscoveryConfig(
+                mode="certified-reuse",
+                precision_digits=80,
+                probe_count=2,
+                verification_probe_count=2,
+            )
+        ),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+    backend = service_module.GenerationBackend(config, None)
+    process_ir = build_process_ir("g g > g g", color_accuracy="full")
+    dag, coverage = backend._compile_concrete_process(process_ir, model)
+    expanded = service_module._ExpandedProcess(
+        request=ProcessRequest.parse("g g > g g", name="gg_gg"),
+        process_ir=process_ir,
+        aliases=(),
+    )
+
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(expanded, dag, coverage),
+        model,
+        index=0,
+        phase=PhaseHandle("test-applied", None, 1),
+    )
+
+    discovery = prepared.filters["relation_discovery"]
+    assert discovery["requested_mode"] == "certified-reuse"
+    assert discovery["certified_relation_count"] > 0
+    assert discovery["applied_relation_count"] > 0
+    assert discovery["warning"]["required"] is True
+    assert discovery["relation_correctness"] == {
+        "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+        "state": "member-scoped-v1",
+        "applied_relation_count": discovery["applied_relation_count"],
+    }
+    assert all(
+        "opposite" not in report["application_scope"]["allowed_relation_kinds"]
+        for report in discovery["lanes"].values()
+    )
+    assert prepared.dag.helicity_materialization is not None
+    assert any(
+        report["application_validation"]["status"] == "verified"
+        for report in discovery["lanes"].values()
+    )
+
+
+def test_n3_charged_current_all_flow_does_not_apply_generic_relations() -> None:
+    model = BuiltinSMModel()
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc", lc_flow_layout="all-flow-union"),
+        generation=GenerationConfig(
+            relation_discovery=GenerationRelationDiscoveryConfig(
+                mode="certified-reuse",
+                precision_digits=80,
+                probe_count=2,
+                verification_probe_count=2,
+            )
+        ),
+        evaluator=EvaluatorConfig(execution_mode="compiled"),
+    )
+    backend = service_module.GenerationBackend(config, None)
+    process_ir = build_process_ir("u d~ > e+ ve g", color_accuracy="lc")
+    dag, coverage = backend._compile_concrete_process(process_ir, model)
+    expanded = service_module._ExpandedProcess(
+        request=ProcessRequest.parse("u d~ > e+ ve g", name="udbar_ep_ve_g"),
+        process_ir=process_ir,
+        aliases=(),
+    )
+
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(expanded, dag, coverage),
+        model,
+        index=0,
+        phase=PhaseHandle("test-all-flow-contained", None, 1),
+    )
+
+    discovery = prepared.filters["relation_discovery"]
+    assert prepared.dag.helicity_recurrence is not None
+    assert prepared.dag.helicity_recurrence.physical_helicity_count > 1
+    assert discovery["applied_relation_count"] == 0
+    assert discovery["relation_correctness"]["state"] == ("no-applied-relations")
+    for report in discovery["lanes"].values():
+        scope = report["application_scope"]
+        assert scope["reason"] == "multi-helicity-all-flow-selector-domain"
+        assert scope["allowed_relation_kinds"] == []
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+@pytest.mark.parametrize("color_accuracy", ("lc", "nlc", "full"))
+def test_relation_discovery_scope_covers_every_dag_mode_and_color(
+    execution_mode,
+    color_accuracy,
+) -> None:
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy=color_accuracy),
+        generation=GenerationConfig(
+            relation_discovery=GenerationRelationDiscoveryConfig(
+                mode="diagnostic",
+                precision_digits=80,
+                probe_count=2,
+                verification_probe_count=2,
+            )
+        ),
+        evaluator=EvaluatorConfig(execution_mode=execution_mode),
+    )
+    backend = service_module.GenerationBackend(config, None)
+    process_ir = build_process_ir(
+        "d d~ > z",
+        color_accuracy=color_accuracy,
+    )
+    model = BuiltinSMModel()
+    dag, coverage = backend._compile_concrete_process(
+        process_ir,
+        model,
+    )
+    expanded = service_module._ExpandedProcess(
+        request=ProcessRequest.parse("d d~ > z", name="ddbar_z"),
+        process_ir=process_ir,
+        aliases=(),
+    )
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(expanded, dag, coverage),
+        model,
+        index=0,
+        phase=PhaseHandle("test-scope", None, 1),
+    )
+
+    aggregate = prepared.filters["relation_discovery"]
+    assert aggregate["execution_mode"] == execution_mode
+    discovery = aggregate["lanes"]["primary"]
+    assert isinstance(discovery, dict)
+    assert discovery["scope"] == {
+        "execution_mode": execution_mode,
+        "color_accuracy": color_accuracy,
+        "representation": "generic-dag",
+    }
diff --git a/pyamplicol/tests/unit/test_generation_physics_metadata.py b/pyamplicol/tests/unit/test_generation_physics_metadata.py
new file mode 100644
index 0000000000..91a5db981a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_physics_metadata.py
@@ -0,0 +1,206 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+from jsonschema import Draft202012Validator
+
+import pyamplicol.generation.physics_metadata as physics_metadata
+import pyamplicol.generation.runtime_schema as runtime_schema
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.physics_metadata import (
+    EAGER_PLAN_V3_REDUCTION_ENTRIES_MEMBER,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_CONTAINER_PATH,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_KIND,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_MEMBER,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_RUNTIME_LAYOUT_ABI,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_SCHEMA_VERSION,
+    EAGER_PLAN_V3_REDUCTION_GROUPS_STORAGE_ABI,
+    NATIVE_REDUCTION_GROUPS_EXTENSION_KEY,
+    _color_id,
+    build_resolved_physics_from_dag,
+)
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def test_public_lc_color_ids_are_physical_and_sector_independent() -> None:
+    assert _color_id(()) == "flow:singlet"
+    assert _color_id((2, 4, 1)) == "flow:2,4,1"
+
+
+@pytest.mark.parametrize(
+    ("color_accuracy", "expected_ids"),
+    (
+        ("lc", ("flow:2,1,3,4", "flow:2,4,3,1")),
+        ("nlc", ("color:contracted",)),
+        ("full", ("color:contracted",)),
+    ),
+)
+def test_crossed_two_line_public_flow_is_lc_only(
+    color_accuracy: str,
+    expected_ids: tuple[str, ...],
+) -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("d d~ > t t~", color_accuracy=color_accuracy),
+        model=model,
+    )
+
+    physics = build_resolved_physics_from_dag(dag, model)
+
+    assert tuple(item["id"] for item in physics["color_components"]) == expected_ids
+    assert {
+        color_id
+        for group in physics["reduction"]["groups"]
+        for color_id in group["physical_color_ids"]
+    } == set(expected_ids)
+
+
+@pytest.mark.parametrize("color_accuracy", ["lc", "full"])
+def test_bounded_public_physics_matches_expanded_schema_without_building_it(
+    color_accuracy: str,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("d d~ > z g", color_accuracy=color_accuracy),
+        model=model,
+    )
+    process_id = f"bounded-{color_accuracy}"
+    expanded = runtime_schema.build_runtime_schema(
+        dag,
+        model,
+        process_id=process_id,
+    )["physics"]
+
+    def forbidden(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("bounded physics called expanded runtime-schema builder")
+
+    monkeypatch.setattr(runtime_schema, "build_runtime_schema_layout", forbidden)
+    bounded = build_resolved_physics_from_dag(
+        dag,
+        model,
+        process_id=process_id,
+    )
+
+    assert bounded == expanded
+    schema = json.loads(
+        (
+            Path(__file__).resolve().parents[2]
+            / "schemas"
+            / "runtime-physics-v1.schema.json"
+        ).read_text(encoding="utf-8")
+    )
+    Draft202012Validator(schema).validate(bounded)
+    assert len(bounded["external_particles"]) == len(dag.process.legs)
+    assert bounded["helicities"]
+    assert bounded["color_components"]
+    assert bounded["reduction"]["groups"]
+    assert NATIVE_REDUCTION_GROUPS_EXTENSION_KEY not in bounded["extensions"]
+    assert bounded["model_parameters"]
+    assert set(bounded["selectors"]) == {
+        "helicity",
+        "color_flow",
+        "contracted_color",
+    }
+
+
+def test_eager_plan_v3_reduction_groups_are_pacbin_backed(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir("d d~ > z g"), model=model)
+
+    def forbidden(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("plan-v3 constructed expanded reduction groups")
+
+    monkeypatch.setattr(physics_metadata, "_reduction_groups", forbidden)
+    physics = build_resolved_physics_from_dag(
+        dag,
+        model,
+        process_id="compact-eager-v3",
+        native_eager_plan_v3_reduction_groups=True,
+    )
+
+    assert physics["reduction"] == {"kind": "lc-diagonal", "groups": []}
+    extensions = physics["extensions"]
+    descriptor = extensions[NATIVE_REDUCTION_GROUPS_EXTENSION_KEY]
+    assert descriptor == {
+        "kind": EAGER_PLAN_V3_REDUCTION_GROUPS_KIND,
+        "schema_version": EAGER_PLAN_V3_REDUCTION_GROUPS_SCHEMA_VERSION,
+        "storage_abi": EAGER_PLAN_V3_REDUCTION_GROUPS_STORAGE_ABI,
+        "runtime_layout_abi": EAGER_PLAN_V3_REDUCTION_GROUPS_RUNTIME_LAYOUT_ABI,
+        "container_path": EAGER_PLAN_V3_REDUCTION_GROUPS_CONTAINER_PATH,
+        "group_member": EAGER_PLAN_V3_REDUCTION_GROUPS_MEMBER,
+        "entry_member": EAGER_PLAN_V3_REDUCTION_ENTRIES_MEMBER,
+        "group_count": len(
+            physics_metadata._mapping_sequence(
+                physics_metadata.build_runtime_amplitude_metadata(dag, model).get(
+                    "coherent_groups", ()
+                )
+            )
+        ),
+    }
+    schema = json.loads(
+        (
+            Path(__file__).resolve().parents[2]
+            / "schemas"
+            / "runtime-physics-v1.schema.json"
+        ).read_text(encoding="utf-8")
+    )
+    Draft202012Validator(schema).validate(physics)
+
+
+def test_eager_physics_uses_authoritative_runtime_parameter_defaults(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir("d d~ > z g"), model=model)
+    imaginary = float.fromhex("0x1.d8fdbd004403dp-2")
+    records = (
+        {
+            "name": "derived_coupling_88.real",
+            "kind": "derived_parameter_component",
+            "parameter_index": 0,
+            "default": 0.0,
+            "runtime_name": "derived_coupling_88",
+            "complex_component": "real",
+        },
+        {
+            "name": "derived_coupling_88.imag",
+            "kind": "derived_parameter_component",
+            "parameter_index": 1,
+            "default": imaginary,
+            "runtime_name": "derived_coupling_88",
+            "complex_component": "imag",
+        },
+    )
+
+    def forbidden(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("eager physics reevaluated model-parameter defaults")
+
+    monkeypatch.setattr(
+        physics_metadata,
+        "build_runtime_model_parameter_records",
+        forbidden,
+    )
+    physics = build_resolved_physics_from_dag(
+        dag,
+        model,
+        process_id="authoritative-eager-parameters",
+        native_eager_plan_v3_reduction_groups=True,
+        runtime_model_parameters=records,
+    )
+
+    assert physics["model_parameters"] == [
+        {
+            "name": "derived_coupling_88",
+            "kind": "derived",
+            "default_real": 0.0,
+            "default_imaginary": imaginary,
+            "mutable": False,
+        }
+    ]
diff --git a/pyamplicol/tests/unit/test_generation_post_build_validation.py b/pyamplicol/tests/unit/test_generation_post_build_validation.py
new file mode 100644
index 0000000000..c85add7381
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_post_build_validation.py
@@ -0,0 +1,450 @@
+# SPDX-License-Identifier: 0BSD
+from types import SimpleNamespace
+
+import pytest
+
+import pyamplicol.generation.service as generation_service
+from pyamplicol.api import Runtime
+from pyamplicol.api.errors import ArtifactError, GenerationError
+from pyamplicol.config import (
+    Action,
+    EvaluatorConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    RunConfig,
+)
+from pyamplicol.generation.service import GenerationBackend
+from pyamplicol.generation.validation import ValidationPointRecord
+
+
+def _helicity(
+    identifier: str,
+    *,
+    computed: bool = True,
+    structural_zero: bool = False,
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        id=identifier,
+        computed=computed,
+        structural_zero=structural_zero,
+    )
+
+
+def _color_flow(identifier: str, *, computed: bool = True) -> SimpleNamespace:
+    return SimpleNamespace(id=identifier, computed=computed)
+
+
+def _on_the_fly_backend(*, validation_enabled: bool = True) -> GenerationBackend:
+    return GenerationBackend(
+        RunConfig(
+            action=Action.GENERATE,
+            generation=GenerationConfig(
+                validation=GenerationValidationConfig(
+                    enabled=validation_enabled,
+                    post_build_validation=True,
+                )
+            ),
+            evaluator=EvaluatorConfig(execution_mode="on-the-fly"),
+        ),
+        None,
+    )
+
+
+def _compact_manifest(*, artifact_id: str = "a" * 64) -> SimpleNamespace:
+    return SimpleNamespace(
+        artifact_id=artifact_id,
+        processes=({"id": "process"},),
+        payloads=tuple(
+            SimpleNamespace(path=f"processes/process/{name}")
+            for name in (
+                "physics.json",
+                "execution.json",
+                "validation-momenta.json",
+                "on-the-fly-runtime.pacbin",
+            )
+        ),
+        runtime={"api_bundle_path": None},
+    )
+
+
+class _CompactRuntime:
+    artifact_id = "a" * 64
+    execution_mode = "on-the-fly"
+    representative_process_key = "process"
+
+    def __init__(
+        self,
+        *,
+        total: complex = 1.0 + 0.0j,
+        resolved: complex | None = None,
+    ) -> None:
+        self.total = total
+        self.resolved = total if resolved is None else resolved
+        self.calls: list[
+            tuple[str, int, tuple[str, ...] | None, tuple[str, ...] | None]
+        ] = []
+
+    @property
+    def physics(self) -> object:
+        raise AssertionError("compact validation opened dense process physics")
+
+    def evaluate(
+        self,
+        samples: tuple[object, ...],
+        *,
+        helicities: tuple[str, ...] | None = None,
+        color_flows: tuple[str, ...] | None = None,
+    ) -> tuple[complex, ...]:
+        sample_count = len(samples)
+        self.calls.append(("total", sample_count, helicities, color_flows))
+        return (self.total,) * sample_count
+
+    def evaluate_resolved(
+        self,
+        samples: tuple[object, ...],
+        *,
+        helicities: tuple[str, ...] | None = None,
+        color_flows: tuple[str, ...] | None = None,
+    ) -> object:
+        sample_count = len(samples)
+        self.calls.append(("resolved", sample_count, helicities, color_flows))
+        values = (self.resolved,) * sample_count
+        return SimpleNamespace(total=lambda: values)
+
+
+_COMPACT_VALIDATION_SELECTORS = {
+    "process": {
+        "helicities": ("h:-1,+1,+0",),
+        "color_flows": ("1",),
+    }
+}
+
+
+def _validation_point() -> ValidationPointRecord:
+    return ValidationPointRecord(
+        process_id="process",
+        process="d d~ > z",
+        seed=1,
+        particles=(
+            (1, (500.0, 0.0, 0.0, 500.0)),
+            (-1, (500.0, 0.0, 0.0, -500.0)),
+            (23, (1000.0, 0.0, 0.0, 0.0)),
+        ),
+    )
+
+
+def _install_compact_validation_spies(
+    monkeypatch: pytest.MonkeyPatch,
+    runtime: object,
+    *,
+    manifest: object | None = None,
+) -> None:
+    monkeypatch.setattr(
+        Runtime,
+        "load",
+        classmethod(lambda _cls, _output, *, process: runtime),
+    )
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.load_manifest",
+        lambda _output: manifest or _compact_manifest(),
+    )
+    monkeypatch.setattr(
+        generation_service,
+        "_post_build_validation_slices",
+        lambda *_args: (_ for _ in ()).throw(
+            AssertionError("compact validation entered dense validation slicing")
+        ),
+    )
+
+
+def test_post_build_validation_keeps_small_resolved_axes_complete() -> None:
+    physics = SimpleNamespace(
+        helicities=(_helicity("h:0"), _helicity("h:1")),
+        color_flows=(_color_flow("flow:0"), _color_flow("flow:1")),
+        contracted_color_components=(),
+    )
+
+    assert generation_service._post_build_validation_slices(physics, 10) == (
+        ("complete", (), ()),
+    )
+
+
+def test_post_build_validation_slices_large_helicity_color_product(
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(
+        generation_service,
+        "_MAX_POST_BUILD_RESOLVED_COMPONENTS",
+        100,
+    )
+    physics = SimpleNamespace(
+        helicities=tuple(
+            [
+                _helicity("h:zero", structural_zero=True),
+                _helicity("h:representative"),
+            ]
+            + [_helicity(f"h:{index}", computed=False) for index in range(10)]
+        ),
+        color_flows=tuple(
+            [_color_flow("flow:representative")]
+            + [_color_flow(f"flow:{index}", computed=False) for index in range(14)]
+        ),
+        contracted_color_components=(),
+    )
+
+    assert generation_service._post_build_validation_slices(physics, 1) == (
+        ("selected-helicity", ("h:representative",), ()),
+        ("selected-flow", (), ("flow:representative",)),
+    )
+
+
+def test_post_build_validation_always_bounds_each_slice(monkeypatch) -> None:
+    monkeypatch.setattr(
+        generation_service,
+        "_MAX_POST_BUILD_RESOLVED_COMPONENTS",
+        5,
+    )
+    physics = SimpleNamespace(
+        helicities=tuple(_helicity(f"h:{index}") for index in range(3)),
+        color_flows=tuple(_color_flow(f"flow:{index}") for index in range(3)),
+        contracted_color_components=(),
+    )
+
+    assert generation_service._post_build_validation_slices(physics, 2) == (
+        ("selected-helicity-and-flow", ("h:0",), ("flow:0",)),
+    )
+
+
+def test_post_build_validation_never_evaluates_large_axes_unselected(
+    monkeypatch,
+    tmp_path,
+) -> None:
+    monkeypatch.setattr(
+        generation_service,
+        "_MAX_POST_BUILD_RESOLVED_COMPONENTS",
+        100,
+    )
+    physics = SimpleNamespace(
+        process_id="process",
+        helicities=tuple(_helicity(f"h:{index}") for index in range(12)),
+        color_flows=tuple(_color_flow(f"flow:{index}") for index in range(15)),
+        contracted_color_components=(),
+    )
+    calls: list[tuple[str, tuple[str, ...] | None, tuple[str, ...] | None]] = []
+
+    class _Runtime:
+        def __init__(self) -> None:
+            self.physics = physics
+
+        def evaluate(self, samples, *, helicities=None, color_flows=None):
+            calls.append(("total", helicities, color_flows))
+            return tuple(1.0 + 0.0j for _sample in samples)
+
+        def evaluate_resolved(self, samples, *, helicities=None, color_flows=None):
+            calls.append(("resolved", helicities, color_flows))
+            values = tuple(1.0 + 0.0j for _sample in samples)
+            return SimpleNamespace(total=lambda: values)
+
+    runtime = _Runtime()
+    monkeypatch.setattr(
+        Runtime,
+        "load",
+        classmethod(lambda _cls, _output, *, process: runtime),
+    )
+    manifest = SimpleNamespace(
+        processes=({"id": "process"},),
+        payloads=tuple(
+            SimpleNamespace(path=f"processes/process/{name}")
+            for name in (
+                "physics.json",
+                "execution.json",
+                "validation-momenta.json",
+            )
+        ),
+        runtime={"api_bundle_path": None},
+    )
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.load_manifest",
+        lambda _output: manifest,
+    )
+    point = ValidationPointRecord(
+        process_id="process",
+        process="d d~ > z",
+        seed=1,
+        particles=(
+            (1, (500.0, 0.0, 0.0, 500.0)),
+            (-1, (500.0, 0.0, 0.0, -500.0)),
+            (23, (1000.0, 0.0, 0.0, 0.0)),
+        ),
+    )
+
+    GenerationBackend(GenerationConfig(), None)._validate_generated_artifact(
+        tmp_path,
+        ("process",),
+        validation_points={"process": (point,)},
+        expected_api_bundle_path=None,
+    )
+
+    assert calls == [
+        ("total", ("h:0",), None),
+        ("resolved", ("h:0",), None),
+        ("total", None, ("flow:0",)),
+        ("resolved", None, ("flow:0",)),
+    ]
+
+
+def test_on_the_fly_post_build_validation_runs_one_compact_numerical_sample(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    runtime = _CompactRuntime()
+    _install_compact_validation_spies(monkeypatch, runtime)
+    point = _validation_point()
+
+    _on_the_fly_backend()._validate_generated_artifact(
+        tmp_path,
+        ("process",),
+        validation_points={"process": (point, point)},
+        expected_api_bundle_path=None,
+        compact_validation_selectors=_COMPACT_VALIDATION_SELECTORS,
+    )
+
+    assert runtime.calls == [
+        ("total", 1, ("h:-1,+1,+0",), ("1",)),
+        ("resolved", 1, ("h:-1,+1,+0",), ("1",)),
+    ]
+
+
+def test_on_the_fly_post_build_validation_rejects_total_resolved_mismatch(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    runtime = _CompactRuntime(resolved=2.0 + 0.0j)
+    _install_compact_validation_spies(monkeypatch, runtime)
+
+    with pytest.raises(GenerationError, match="does not reduce to the total"):
+        _on_the_fly_backend()._validate_generated_artifact(
+            tmp_path,
+            ("process",),
+            validation_points={"process": (_validation_point(),)},
+            expected_api_bundle_path=None,
+            compact_validation_selectors=_COMPACT_VALIDATION_SELECTORS,
+        )
+
+
+def test_on_the_fly_post_build_validation_disabled_skips_numerical_sample(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    runtime = _CompactRuntime()
+    _install_compact_validation_spies(monkeypatch, runtime)
+
+    _on_the_fly_backend(validation_enabled=False)._validate_generated_artifact(
+        tmp_path,
+        ("process",),
+        validation_points={"process": (_validation_point(),)},
+        expected_api_bundle_path=None,
+    )
+
+    assert runtime.calls == []
+
+
+def test_on_the_fly_validation_selector_uses_first_projected_source_states() -> None:
+    projection = SimpleNamespace(
+        external_sources=(
+            SimpleNamespace(
+                source_states=(
+                    SimpleNamespace(public_helicity=-1),
+                    SimpleNamespace(public_helicity=1),
+                )
+            ),
+            SimpleNamespace(
+                source_states=(
+                    SimpleNamespace(public_helicity=1),
+                    SimpleNamespace(public_helicity=-1),
+                )
+            ),
+            SimpleNamespace(source_states=(SimpleNamespace(public_helicity=0),)),
+        )
+    )
+
+    selectors = generation_service._on_the_fly_validation_selectors_v1(
+        projection  # type: ignore[arg-type]
+    )
+
+    assert dict(selectors) == {
+        "helicities": ("h:-1,+1,+0",),
+        "color_flows": ("1",),
+    }
+
+
+@pytest.mark.parametrize(
+    ("attribute", "value", "message"),
+    (
+        ("artifact_id", "b" * 64, "wrong artifact"),
+        ("execution_mode", "recurrence", "wrong execution mode"),
+        ("representative_process_key", "other", "wrong process"),
+    ),
+)
+def test_on_the_fly_post_build_validation_rejects_compact_identity_mismatch(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+    attribute: str,
+    value: str,
+    message: str,
+) -> None:
+    runtime = _CompactRuntime()
+    setattr(runtime, attribute, value)
+    _install_compact_validation_spies(monkeypatch, runtime)
+
+    with pytest.raises(GenerationError, match=message):
+        _on_the_fly_backend()._validate_generated_artifact(
+            tmp_path,
+            ("process",),
+            validation_points={},
+            expected_api_bundle_path=None,
+        )
+
+
+def test_on_the_fly_post_build_validation_propagates_compact_selector_rejection(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    def reject_selector(_cls, _output, *, process: str) -> object:
+        assert process == "process"
+        raise ArtifactError("compact selector contract is inconsistent")
+
+    monkeypatch.setattr(Runtime, "load", classmethod(reject_selector))
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.load_manifest",
+        lambda _output: _compact_manifest(),
+    )
+
+    with pytest.raises(ArtifactError, match="compact selector contract"):
+        _on_the_fly_backend()._validate_generated_artifact(
+            tmp_path,
+            ("process",),
+            validation_points={},
+            expected_api_bundle_path=None,
+        )
+
+
+def test_on_the_fly_post_build_validation_requires_canonical_seed_container(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    manifest = _compact_manifest()
+    manifest.payloads = manifest.payloads[:-1]
+    _install_compact_validation_spies(
+        monkeypatch,
+        _CompactRuntime(),
+        manifest=manifest,
+    )
+
+    with pytest.raises(GenerationError, match="payload set is incomplete"):
+        _on_the_fly_backend()._validate_generated_artifact(
+            tmp_path,
+            ("process",),
+            validation_points={},
+            expected_api_bundle_path=None,
+        )
diff --git a/pyamplicol/tests/unit/test_generation_process_groups.py b/pyamplicol/tests/unit/test_generation_process_groups.py
new file mode 100644
index 0000000000..37650c5b68
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_process_groups.py
@@ -0,0 +1,148 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+import pyamplicol.generation.process_grouping_numerical as numerical
+import pyamplicol.generation.service as service_module
+from pyamplicol.config import Action, ProcessConfig, RunConfig
+from pyamplicol.generation.process_grouping import GroupingBasis, GroupMember
+from pyamplicol.generation.progress import GenerationPhaseReporter
+
+
+def test_initial_groups_keep_the_members_recorded_at_expansion() -> None:
+    member = GroupMember(
+        process_id="u_ubar_to_g_g",
+        expression="u u~ > g g",
+        pdgs=(2, -2, 21, 21),
+        initial_count=2,
+        permutation=(0, 1, 2, 3),
+        basis=GroupingBasis.FLAVOR_BLIND,
+        generated=False,
+    )
+    processes = (
+        SimpleNamespace(
+            process_id="d_dbar_to_g_g",
+            expression="d d~ > g g",
+            external_pdgs=(1, -1, 21, 21),
+        ),
+        SimpleNamespace(
+            process_id="g_g_to_g_g",
+            expression="g g > g g",
+            external_pdgs=(21, 21, 21, 21),
+        ),
+    )
+    expanded = (
+        SimpleNamespace(
+            request=SimpleNamespace(name="d_dbar_to_g_g"), group_members=(member,)
+        ),
+        SimpleNamespace(request=SimpleNamespace(name="g_g_to_g_g"), group_members=()),
+    )
+
+    group_map = service_module._initial_process_groups(processes, expanded)  # type: ignore[arg-type]
+
+    assert {
+        identifier: [item.process_id for item in group.members]
+        for identifier, group in group_map.groups.items()
+    } == {
+        "d_dbar_to_g_g": ["d_dbar_to_g_g", "u_ubar_to_g_g"],
+        "g_g_to_g_g": ["g_g_to_g_g"],
+    }
+    assert group_map.groups["d_dbar_to_g_g"].members[1] == member
+
+
+def test_numerical_grouping_runs_only_when_requested(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[tuple[Path, dict[str, object]]] = []
+
+    def update(artifact: Path, **options: object) -> dict[str, object]:
+        calls.append((artifact, options))
+        return {}
+
+    monkeypatch.setattr(numerical, "update_artifact_process_groups", update)
+    for analysis in ("none", "numerical"):
+        backend = service_module.GenerationBackend(
+            RunConfig(
+                action=Action.GENERATE,
+                process=ProcessConfig(
+                    analyze_process_groups=analysis,  # type: ignore[arg-type]
+                    only_unit_multiplier=True,
+                ),
+            ),
+            None,
+        )
+        backend._analyze_process_groups(tmp_path, GenerationPhaseReporter(None))
+
+    assert calls == [
+        (
+            tmp_path,
+            {
+                "analysis": "numerical",
+                "only_unit_multiplier": True,
+                "consider_charge_conjugation": True,
+            },
+        )
+    ]
+
+
+def test_skipped_representative_reports_its_flavor_blind_members(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    member = GroupMember(
+        process_id="u_ubar_to_z_g_g",
+        expression="u u~ > z g g",
+        pdgs=(2, -2, 23, 21, 21),
+        initial_count=2,
+        generated=False,
+    )
+    expanded = SimpleNamespace(
+        request=SimpleNamespace(name="d_dbar_to_z_g_g"),
+        process_ir=SimpleNamespace(process="d d~ > z g g"),
+        group_members=(member,),
+    )
+
+    service_module._warn_unsupported_processes(
+        [SimpleNamespace(expanded=expanded, reason="no amplitudes")]  # type: ignore[list-item]
+    )
+
+    assert "d_dbar_to_z_g_g (d d~ > z g g, with 1 flavor-blind member(s))" in (
+        caplog.text
+    )
+
+
+def test_ungenerated_members_need_a_positive_factor() -> None:
+    from fractions import Fraction
+
+    from pyamplicol.api.errors import ArtifactError
+    from pyamplicol.artifacts.process_groups import (
+        initial_process_groups,
+        validate_process_groups,
+    )
+
+    def member(factor: Fraction) -> GroupMember:
+        return GroupMember(
+            process_id="u_ubar_to_g_g",
+            expression="u u~ > g g",
+            pdgs=(2, -2, 21, 21),
+            initial_count=2,
+            factor=factor,
+            permutation=(0, 1, 2, 3),
+            basis=GroupingBasis.FLAVOR_BLIND,
+            generated=False,
+        )
+
+    stored = [("d_dbar_to_g_g", "d d~ > g g", (1, -1, 21, 21))]
+    validate_process_groups(
+        initial_process_groups(stored, {"d_dbar_to_g_g": [member(Fraction(4))]}),
+        ["d_dbar_to_g_g"],
+    )
+    with pytest.raises(ArtifactError, match="must be positive"):
+        validate_process_groups(
+            initial_process_groups(stored, {"d_dbar_to_g_g": [member(Fraction(-1))]}),
+            ["d_dbar_to_g_g"],
+        )
diff --git a/pyamplicol/tests/unit/test_generation_progress_thread_safety.py b/pyamplicol/tests/unit/test_generation_progress_thread_safety.py
new file mode 100644
index 0000000000..9ed6548322
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_progress_thread_safety.py
@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+
+import pytest
+
+from pyamplicol.generation.progress import GenerationPhaseReporter, PhaseHandle
+from pyamplicol.reporting import (
+    CallbackProgressSink,
+    NullProgressSink,
+    ProgressEnd,
+    ProgressUpdate,
+)
+
+
+def test_phase_advances_are_thread_safe_monotonic_and_exact() -> None:
+    events: list[object] = []
+    handle = PhaseHandle(
+        "generation:test",
+        CallbackProgressSink(events.append),
+        total=200,
+    )
+
+    with ThreadPoolExecutor(max_workers=8) as executor:
+        futures = [
+            executor.submit(handle.advance, message=str(index)) for index in range(200)
+        ]
+        for future in futures:
+            future.result()
+
+    updates = [event for event in events if isinstance(event, ProgressUpdate)]
+    assert handle.completed == 200
+    assert [event.completed for event in updates] == list(range(1, 201))
+    assert {event.total for event in updates} == {200}
+
+
+def test_progress_off_normalizes_to_no_generation_callbacks() -> None:
+    reporter = GenerationPhaseReporter(NullProgressSink())
+
+    assert reporter.sink is None
+
+
+def test_child_progress_records_interrupt_without_timing_message() -> None:
+    events: list[object] = []
+    reporter = GenerationPhaseReporter(CallbackProgressSink(events.append))
+    reporter.start_generation(total=1, details={"execution_mode": "compiled"})
+
+    with (
+        pytest.raises(KeyboardInterrupt),
+        reporter.phase("dag", "DAG construction", total=1) as phase,
+        phase.child("process", "process DAG"),
+    ):
+        raise KeyboardInterrupt
+
+    endings = [event for event in events if isinstance(event, ProgressEnd)]
+    assert endings
+    assert all(event.elapsed_seconds is not None for event in endings)
+    assert all(
+        event.message is None or not event.message.endswith("s") for event in endings
+    )
+    assert endings[0].success is False
diff --git a/pyamplicol/tests/unit/test_generation_stage_contract.py b/pyamplicol/tests/unit/test_generation_stage_contract.py
new file mode 100644
index 0000000000..11aa8e7d96
--- /dev/null
+++ b/pyamplicol/tests/unit/test_generation_stage_contract.py
@@ -0,0 +1,253 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import pickle
+
+import pytest
+
+from pyamplicol.evaluators.symbolica_compile import (
+    _partitioned_output_chunk_ranges,
+)
+from pyamplicol.generation.contracts import RuntimeExpressionSchema
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.stage_compiler import (
+    _fanout_aware_current_order,
+    build_generic_stage_compiler_blueprint,
+)
+from pyamplicol.generation.stage_planning import (
+    _stage_with_fanout_aware_output_order,
+)
+from pyamplicol.generation.stage_types import (
+    GenericCompiledStageBlueprint,
+    GenericStageOutputSlot,
+)
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _minimal_schema() -> dict[str, object]:
+    return {
+        "parameter_layout": {
+            "value_component_count": 0,
+            "momentum_parameter_count": 0,
+            "model_parameter_count": 0,
+        },
+        "model_parameters": [],
+        "current_storage": {"current_slots": []},
+        "value_storage": {"value_slots": []},
+        "momentum_slots": [],
+        "stages": [],
+        "amplitude_stage": {"roots": []},
+    }
+
+
+def test_generation_runtime_expression_schema_is_canonical_and_frozen() -> None:
+    left = RuntimeExpressionSchema.from_mapping(_minimal_schema())
+    right = RuntimeExpressionSchema.from_mapping(
+        dict(reversed(tuple(_minimal_schema().items())))
+    )
+    assert left == right
+    assert left.sha256 == right.sha256
+    assert left.to_mapping()["stages"] == []
+    assert left.canonical_json == json.dumps(
+        _minimal_schema(),
+        allow_nan=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    )
+    assert left.canonical_json == json.dumps(
+        left.to_mapping(),
+        allow_nan=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    )
+
+    detached = left.to_mapping()
+    detached["stages"] = ["changed"]
+    detached["current_storage"]["current_slots"] = ["changed"]
+    assert left.to_mapping()["stages"] == []
+    assert left.to_mapping()["current_storage"] == {"current_slots": []}
+
+
+def test_generation_runtime_expression_schema_typed_construction_is_idempotent(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    schema = RuntimeExpressionSchema.from_mapping(_minimal_schema())
+
+    def fail_json_dump(*_args: object, **_kwargs: object) -> str:
+        raise AssertionError("typed construction must not canonicalize again")
+
+    monkeypatch.setattr(json, "dumps", fail_json_dump)
+    assert RuntimeExpressionSchema.from_mapping(schema) is schema
+
+
+def test_generation_runtime_expression_schema_reuses_decoded_cache(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    schema = RuntimeExpressionSchema.from_mapping(_minimal_schema())
+
+    def fail_json_load(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("mapping access must not decode canonical JSON again")
+
+    monkeypatch.setattr(json, "loads", fail_json_load)
+    assert schema.to_mapping() == _minimal_schema()
+
+
+@pytest.mark.parametrize(
+    ("construct", "message"),
+    (
+        (
+            lambda: RuntimeExpressionSchema(canonical_json="not-json"),
+            "not valid JSON",
+        ),
+        (
+            lambda: RuntimeExpressionSchema(canonical_json="[]"),
+            "root must be an object",
+        ),
+        (
+            lambda: RuntimeExpressionSchema(
+                canonical_json=json.dumps(_minimal_schema()),
+                contract_version=1,
+            ),
+            "unsupported runtime expression-schema contract version",
+        ),
+        (
+            lambda: RuntimeExpressionSchema.from_mapping({"stages": []}),
+            "runtime expression schema is missing",
+        ),
+        (
+            lambda: RuntimeExpressionSchema.from_mapping(
+                {**_minimal_schema(), "invalid": object()}
+            ),
+            "must contain canonical JSON values",
+        ),
+    ),
+)
+def test_generation_runtime_expression_schema_validation_is_preserved(
+    construct: object,
+    message: str,
+) -> None:
+    with pytest.raises(ValueError, match=message):
+        construct()
+
+
+def test_generation_runtime_expression_schema_normalizes_json_inputs() -> None:
+    payload = _minimal_schema()
+    payload["tuple_value"] = (1, 2)
+    payload["mapping_value"] = {2: "two", 1: "one"}
+    schema = RuntimeExpressionSchema.from_mapping(payload)
+
+    expected = json.loads(schema.canonical_json)
+    assert schema.to_mapping() == expected
+    assert list(schema.to_mapping()["mapping_value"]) == ["1", "2"]
+
+
+def test_generation_runtime_expression_schema_remains_pickleable() -> None:
+    schema = RuntimeExpressionSchema.from_mapping(_minimal_schema())
+    restored = pickle.loads(pickle.dumps(schema))
+
+    assert restored == schema
+    assert restored.to_mapping() == schema.to_mapping()
+
+
+def test_generation_stage_compiler_requires_schema_and_local_parameters() -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir("d d~ > z"), model=model)
+    with pytest.raises(ValueError, match="explicit runtime schema"):
+        build_generic_stage_compiler_blueprint(dag)
+    with pytest.raises(ValueError, match="stage-local parameter layout"):
+        build_generic_stage_compiler_blueprint(
+            dag,
+            runtime_schema=_minimal_schema(),
+            stage_local_parameter_layout=False,
+        )
+
+
+def test_generation_fanout_order_preserves_evaluation_reuse() -> None:
+    order, before, after = _fanout_aware_current_order(
+        (0, 1, 2, 3),
+        output_size_by_current={current_id: 2 for current_id in range(4)},
+        evaluation_groups_by_current={
+            0: frozenset((1, 10)),
+            1: frozenset((2, 20)),
+            2: frozenset((1, 30)),
+            3: frozenset((2, 40)),
+        },
+        chunk_size=4,
+    )
+    assert order in {(0, 2, 1, 3), (1, 3, 0, 2)}
+    assert (before, after) == (8, 6)
+
+
+def _selector_partition_stage(
+    *, amplitude: bool = False, color_domains: bool = False
+) -> GenericCompiledStageBlueprint:
+    signatures = ((3, 23), (10, 18), (3, 23))
+    slots = tuple(
+        GenericStageOutputSlot(
+            value_slot_id=-1 if amplitude else index,
+            current_id=-1 if amplitude else index,
+            variant="amplitude-root" if amplitude else "propagated",
+            component_start=index,
+            component_stop=index + 1,
+            output_start=index,
+            output_stop=index + 1,
+            selector_domain_ids=signature,
+            color_selector_domain_ids=(
+                ((0, 2) if index != 1 else (1,)) if color_domains else ()
+            ),
+        )
+        for index, signature in enumerate(signatures)
+    )
+    return GenericCompiledStageBlueprint(
+        stage_index=0 if amplitude else 1,
+        stage_kind="amplitude-roots" if amplitude else "current-combine",
+        subset_size=None if amplitude else 2,
+        evaluator_label="selector-partition-test",
+        parameter_layout="stage-local-value-momentum",
+        output_length=3,
+        output_slots=slots,
+        input_value_slot_ids=(),
+        output_value_slot_ids=(),
+        interaction_ids=(),
+        input_components=(),
+        parameter_count=0,
+        value_parameter_count=0,
+        momentum_parameter_count=0,
+        model_parameter_count=0,
+        real_valued_inputs=(),
+        expression_ready=True,
+        blockers=(),
+        first_output_previews=("a", "b", "c"),
+        output_expressions=("a", "b", "c"),
+    )
+
+
+@pytest.mark.parametrize("amplitude", (False, True))
+@pytest.mark.parametrize("color_domains", (False, True))
+def test_selector_domains_define_evaluator_chunk_boundaries(
+    amplitude: bool, color_domains: bool
+) -> None:
+    stage = _stage_with_fanout_aware_output_order(
+        _selector_partition_stage(
+            amplitude=amplitude,
+            color_domains=color_domains,
+        ),
+        chunk_size=512,
+    )
+
+    assert stage.output_expressions == ("a", "c", "b")
+    assert stage.selector_output_partitions == ((0, 2), (2, 3))
+    if amplitude:
+        assert tuple(slot.component_start for slot in stage.output_slots) == (0, 2, 1)
+    else:
+        assert tuple(slot.current_id for slot in stage.output_slots) == (0, 2, 1)
+
+
+def test_selector_partitions_are_subdivided_without_crossing_domains() -> None:
+    assert _partitioned_output_chunk_ranges(
+        10,
+        chunk_size=4,
+        output_partitions=((0, 3), (3, 10)),
+    ) == ((0, 3), (3, 7), (7, 10))
diff --git a/pyamplicol/tests/unit/test_heft_contact_trees.py b/pyamplicol/tests/unit/test_heft_contact_trees.py
new file mode 100644
index 0000000000..4dc4f2e59e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_heft_contact_trees.py
@@ -0,0 +1,323 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+
+import pytest
+from symbolica import Expression
+from ufo_model_loader.symbolica_processing import wrap_indices
+
+from pyamplicol._internal.physics.symbols import symbols
+from pyamplicol.models import compiler_symbolica as _sym
+from pyamplicol.models.compiler_auxiliary_components import (
+    reduce_contact_auxiliary_components,
+)
+from pyamplicol.models.compiler_contact_trees import (
+    _compile_heft_colored_contact_trees,
+)
+from pyamplicol.models.contracts import (
+    CompiledParticleRecord,
+    CompiledVertexTerm,
+)
+from pyamplicol.models.tensors import (
+    normalize_color_expression,
+    normalize_lorentz_expression,
+)
+
+_MODEL_SYMBOLS = symbols.model("synthetic-heft-contact")
+_VVVS2 = (
+    "P(3,1)*Metric(1,2) - P(3,2)*Metric(1,2) "
+    "- P(2,1)*Metric(1,3) + P(2,3)*Metric(1,3) "
+    "+ P(1,2)*Metric(2,3) - P(1,3)*Metric(2,3)"
+)
+_HGGGG_PAIRINGS = (
+    (
+        "f(-1,1,2)*f(3,4,-1)",
+        "Metric(1,4)*Metric(2,3) - Metric(1,3)*Metric(2,4)",
+        frozenset({(0, 1), (2, 3)}),
+    ),
+    (
+        "f(-1,1,3)*f(2,4,-1)",
+        "Metric(1,4)*Metric(2,3) - Metric(1,2)*Metric(3,4)",
+        frozenset({(0, 2), (1, 3)}),
+    ),
+    (
+        "f(-1,1,4)*f(2,3,-1)",
+        "Metric(1,3)*Metric(2,4) - Metric(1,2)*Metric(3,4)",
+        frozenset({(0, 3), (1, 2)}),
+    ),
+)
+
+
+def _particle(
+    name: str,
+    pdg: int,
+    *,
+    spin: int,
+    color: int,
+) -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=name,
+        pdg_code=pdg,
+        spin=spin,
+        color=color,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+_GLUON = _particle("G", 21, spin=3, color=8)
+_HIGGS = _particle("H", 25, spin=1, color=1)
+
+
+def _ufo_source(source: str) -> str:
+    return Expression.parse(source, default_namespace="UFO").to_canonical_string()
+
+
+def _wrapped_lorentz(source: str) -> str:
+    return wrap_indices(
+        Expression.parse(source, default_namespace="UFO")
+    ).to_canonical_string()
+
+
+def _term(
+    term_id: int,
+    *,
+    color: str,
+    lorentz: str,
+    valence: int,
+) -> CompiledVertexTerm:
+    particles = ("G",) * (valence - 1) + ("H",)
+    colors = (8,) * (valence - 1) + (1,)
+    spins = (3,) * (valence - 1) + (1,)
+    color_source = _ufo_source(color)
+    lorentz_source = _wrapped_lorentz(lorentz)
+    return CompiledVertexTerm(
+        id=term_id,
+        vertex=f"V_HEFT_{term_id}",
+        particles=particles,
+        color_index=0,
+        lorentz_index=0,
+        color_source=color_source,
+        color_expression=normalize_color_expression(
+            color_source,
+            colors,
+        ).expression,
+        lorentz_name=f"L_HEFT_{term_id}",
+        lorentz_source=lorentz_source,
+        lorentz_expression=normalize_lorentz_expression(
+            lorentz_source,
+            spins,
+            model_symbols=_MODEL_SYMBOLS,
+        ).expression,
+        coupling="GC_HEFT",
+        coupling_expression="ufo_heft_coupling",
+        coupling_orders=(("HIG", 1),),
+    )
+
+
+def _compile(*terms: CompiledVertexTerm):
+    return _compile_heft_colored_contact_trees(
+        terms,
+        (_GLUON, _HIGGS),
+        start_kind=0,
+        model_symbols=_MODEL_SYMBOLS,
+    )
+
+
+def test_hggg_contact_uses_authenticated_adjoint_and_identity_nodes() -> None:
+    term = _term(100, color="f(1,2,3)", lorentz=_VVVS2, valence=4)
+
+    auxiliaries, kernels = _compile(term)
+
+    assert len(auxiliaries) == 2
+    assert {(particle.spin, particle.color) for particle in auxiliaries} == {(-1, 8)}
+    assert len(kernels) == 7
+    assert {kernel.color_projection_structure for kernel in kernels} == {None}
+    assert {kernel.color_source.split("(")[0] for kernel in kernels} == {
+        "UFO::f",
+        "UFO::Identity",
+    }
+    assert all(kernel.coupling_expression == "1" for kernel in kernels)
+    partials = tuple(kernel for kernel in kernels if kernel.vertex.endswith("partial"))
+    finals = tuple(kernel for kernel in kernels if kernel.vertex.endswith("final"))
+    assert all(
+        not kernel.runtime_parameters and not kernel.coupling_orders
+        for kernel in partials
+    )
+    assert all(
+        kernel.runtime_parameters == ("derived_coupling_100",) for kernel in finals
+    )
+    assert all(kernel.coupling_orders == (("HIG", 1),) for kernel in finals)
+    assert all(
+        expression.count("derived_coupling_100") == 1
+        for kernel in finals
+        for expression in kernel.component_expressions
+    )
+
+
+def test_hggg_source_permutation_sign_is_carried_by_the_adjoint_node() -> None:
+    canonical = _term(101, color="f(1,2,3)", lorentz=_VVVS2, valence=4)
+    reversed_source = replace(
+        canonical,
+        color_source=_ufo_source("f(2,1,3)"),
+        color_expression=normalize_color_expression(
+            _ufo_source("f(2,1,3)"),
+            (8, 8, 8, 1),
+        ).expression,
+    )
+
+    _canonical_auxiliaries, canonical_kernels = _compile(canonical)
+    _reversed_auxiliaries, reversed_kernels = _compile(reversed_source)
+    assert len(canonical_kernels) == len(reversed_kernels) == 7
+    for canonical_kernel, reversed_kernel in zip(
+        canonical_kernels,
+        reversed_kernels,
+        strict=True,
+    ):
+        assert (
+            canonical_kernel.source_particle_legs
+            == reversed_kernel.source_particle_legs
+        )
+        carries_reversed_structure_constant = canonical_kernel.color_source.startswith(
+            "UFO::f"
+        )
+        comparison = (
+            (lambda left, right: _sym.E(left) + _sym.E(right))
+            if carries_reversed_structure_constant
+            else (lambda left, right: _sym.E(left) - _sym.E(right))
+        )
+        assert all(
+            comparison(left, right).to_canonical_string() == "0"
+            for left, right in zip(
+                canonical_kernel.component_expressions,
+                reversed_kernel.component_expressions,
+                strict=True,
+            )
+        )
+
+
+def test_hgggg_lowers_all_three_exact_color_lorentz_pairings() -> None:
+    terms = tuple(
+        _term(200 + index, color=color, lorentz=lorentz, valence=5)
+        for index, (color, lorentz, _pairs) in enumerate(_HGGGG_PAIRINGS)
+    )
+
+    auxiliaries, kernels = _compile(*terms)
+
+    assert auxiliaries
+    assert {kernel.term_id for kernel in kernels} == {200, 201, 202}
+    for term, (_color, _lorentz, expected_pairs) in zip(
+        terms,
+        _HGGGG_PAIRINGS,
+        strict=True,
+    ):
+        higgs_result_partials = {
+            tuple(sorted(kernel.source_particle_legs[:2]))
+            for kernel in kernels
+            if kernel.term_id == term.id
+            and kernel.vertex.endswith("partial")
+            and f"_{term.id}_r4_" in kernel.particles[2]
+        }
+        assert higgs_result_partials == expected_pairs
+        finals = tuple(
+            kernel
+            for kernel in kernels
+            if kernel.term_id == term.id and kernel.vertex.endswith("final")
+        )
+        assert finals
+        assert all(
+            expression.count(f"derived_coupling_{term.id}") == 1
+            for kernel in finals
+            for expression in kernel.component_expressions
+        )
+
+
+def test_heft_contact_identical_gluon_multiplicities_are_applied_once() -> None:
+    hggg = _term(300, color="f(1,2,3)", lorentz=_VVVS2, valence=4)
+    color, lorentz, _pairs = _HGGGG_PAIRINGS[0]
+    hgggg = _term(301, color=color, lorentz=lorentz, valence=5)
+
+    _auxiliaries, kernels = _compile(hggg, hgggg)
+
+    hggg_higgs = tuple(
+        kernel
+        for kernel in kernels
+        if kernel.term_id == 300
+        and kernel.vertex.endswith("final")
+        and kernel.source_particle_legs[-1] == 3
+    )
+    hgggg_higgs = tuple(
+        kernel
+        for kernel in kernels
+        if kernel.term_id == 301
+        and kernel.vertex.endswith("final")
+        and kernel.source_particle_legs[-1] == 4
+    )
+    assert hggg_higgs and hgggg_higgs
+    assert all("1/3" in kernel.component_expressions[0] for kernel in hggg_higgs)
+    assert all("1/6" in kernel.component_expressions[0] for kernel in hgggg_higgs)
+
+
+def test_all_hgggg_pairings_reduce_exactly_to_antisymmetric_current_components() -> (
+    None
+):
+    terms = tuple(
+        _term(500 + index, color=color, lorentz=lorentz, valence=5)
+        for index, (color, lorentz, _pairs) in enumerate(_HGGGG_PAIRINGS)
+    )
+    auxiliaries, kernels = _compile(*terms)
+    particles, reduced = reduce_contact_auxiliary_components(
+        (_GLUON, _HIGGS, *auxiliaries),
+        kernels,
+        auxiliary_particles=auxiliaries,
+        model_symbols=_MODEL_SYMBOLS,
+    )
+    projected = {
+        particle.name for particle in auxiliaries if particle.component_dimension == 16
+    }
+    assert len(projected) == 9
+    assert all(
+        particle.component_dimension == 6
+        for particle in particles
+        if particle.name in projected
+    )
+    for old, new in zip(kernels, reduced, strict=True):
+        assert replace(new, component_expressions=old.component_expressions) == old
+        if old.particles[2] not in projected:
+            continue
+        expected = tuple(
+            _sym.E(old.component_expressions[4 * left + right])
+            - _sym.E(old.component_expressions[4 * right + left])
+            for left in range(4)
+            for right in range(left + 1, 4)
+        )
+        assert all(
+            (value - _sym.E(actual)).expand().to_canonical_string() == "0"
+            for value, actual in zip(expected, new.component_expressions, strict=True)
+        )
+
+
+@pytest.mark.parametrize(
+    "term",
+    (
+        _term(400, color="f(1,2,3)", lorentz="Metric(1,2)", valence=5),
+        _term(
+            401,
+            color="f(-1,1,2)*f(3,4,-2)",
+            lorentz="Metric(1,2)*Metric(3,4)",
+            valence=5,
+        ),
+    ),
+)
+def test_other_colored_contact_topologies_fail_closed(term: CompiledVertexTerm) -> None:
+    auxiliaries, kernels = _compile(term)
+    assert auxiliaries == ()
+    assert kernels == ()
diff --git a/pyamplicol/tests/unit/test_heft_ufo.py b/pyamplicol/tests/unit/test_heft_ufo.py
new file mode 100644
index 0000000000..319ed50966
--- /dev/null
+++ b/pyamplicol/tests/unit/test_heft_ufo.py
@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import io
+import tarfile
+from pathlib import Path
+
+import pytest
+
+from tools.developer import heft_ufo
+
+
+def _upstream_sources() -> dict[str, str]:
+    return {
+        "Higgs_Effective_Couplings_UFO.log": "upstream log\n",
+        "__init__.py": ("import couplings\nall_couplings = couplings.all_couplings\n"),
+        "couplings.py": (
+            "GC_8 = Coupling(name='GC_8')\n"
+            "GC_9 = Coupling(name='GC_9')\n"
+            "GC_10 = Coupling(name='GC_10')\n"
+            "GC_11 = Coupling(name='GC_11')\n"
+            "GC_12 = Coupling(name='GC_12')\n"
+        ),
+        "function_library.py": "def complexconjugate(value):\n    return value\n",
+        "lorentz.py": (
+            "VVS3 = Lorentz(name='VVS3')\n"
+            "VVVS2 = Lorentz(name='VVVS2')\n"
+            "VVVVS1 = Lorentz(name='VVVVS1')\n"
+            "VVVVS2 = Lorentz(name='VVVVS2')\n"
+            "VVVVS3 = Lorentz(name='VVVVS3')\n"
+            "VVS1 = Lorentz(name='VVS1', structure='Epsilon(1,2,3,4)')\n"
+            "VVVS1 = Lorentz(name='VVVS1', structure='Epsilon(1,2,3,4)')\n"
+        ),
+        "object_library.py": (
+            "class UFOBaseClass:\n"
+            "    def values(self):\n"
+            "        return self.__dict__.iteritems()\n"
+        ),
+        "parameters.py": (
+            "AH = Parameter(name='AH', value=2.634632e7)\n"
+            "MP = Parameter(name='MP', value=1)\n"
+            "WH1 = Parameter(name='WH1', value=1)\n"
+            "Gphi = Parameter(name='Gphi', value=1)\n"
+        ),
+        "particles.py": (
+            "G = Particle(name='G')\nH = Particle(name='H')\nh1 = Particle(name='h1')\n"
+        ),
+        "vertices.py": (
+            "V_16 = Vertex(name='V_16')\n"
+            "V_17 = Vertex(name='V_17')\n"
+            "V_18 = Vertex(name='V_18')\n"
+            "V_19 = Vertex(name='V_19', particles=[P.h1])\n"
+            "V_20 = Vertex(name='V_20', particles=[P.h1])\n"
+        ),
+        "write_param_card.py": "print 'write ./param_card.dat'\n",
+    }
+
+
+def _archive(sources: dict[str, str]) -> bytes:
+    stream = io.BytesIO()
+    with tarfile.open(fileobj=stream, mode="w:gz") as archive:
+        for relative, source in sorted(sources.items()):
+            payload = source.encode("utf-8")
+            member = tarfile.TarInfo(f"{heft_ufo.HEFT_UFO_ARCHIVE_ROOT}/{relative}")
+            member.size = len(payload)
+            archive.addfile(member, io.BytesIO(payload))
+    return stream.getvalue()
+
+
+def _accept_payload(monkeypatch: pytest.MonkeyPatch, payload: bytes) -> None:
+    monkeypatch.setattr(
+        heft_ufo,
+        "HEFT_UFO_SHA256",
+        hashlib.sha256(payload).hexdigest(),
+    )
+
+
+def test_prepare_heft_ufo_authenticates_and_scalarizes(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    payload = _archive(_upstream_sources())
+    _accept_payload(monkeypatch, payload)
+
+    destination = heft_ufo.prepare_heft_ufo(
+        tmp_path / "heft-ufo",
+        downloader=lambda _url: payload,
+    )
+
+    assert heft_ufo.validate_prepared_heft_ufo(destination) == destination
+    combined = "\n".join(
+        path.read_text(encoding="utf-8") for path in destination.glob("*.py")
+    )
+    assert "26346320" in combined
+    assert "h1" not in combined
+    assert "Epsilon(" not in combined
+    assert "GC_11" not in combined
+    assert "GC_12" not in combined
+    assert "self.__dict__.items()" in combined
+    assert "print('write ./param_card.dat')" in combined
+    assert {"QCD", "QED", "HIG", "HIW"} <= {
+        line.split()[0]
+        for line in (destination / "coupling_orders.py")
+        .read_text(encoding="utf-8")
+        .splitlines()
+        if " = CouplingOrder" in line
+    }
+
+
+def test_prepare_heft_ufo_rejects_wrong_archive_hash(
+    tmp_path: Path,
+) -> None:
+    payload = _archive(_upstream_sources())
+    with pytest.raises(heft_ufo.HEFTUFOPreparationError, match="SHA-256 mismatch"):
+        heft_ufo.prepare_heft_ufo(
+            tmp_path / "heft-ufo",
+            downloader=lambda _url: payload,
+        )
+
+
+def test_prepare_heft_ufo_rejects_archive_inventory_drift(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    sources = _upstream_sources()
+    sources["unexpected.py"] = "pass\n"
+    payload = _archive(sources)
+    _accept_payload(monkeypatch, payload)
+
+    with pytest.raises(
+        heft_ufo.HEFTUFOPreparationError,
+        match="unexpected HEFT UFO archive contents",
+    ):
+        heft_ufo.prepare_heft_ufo(
+            tmp_path / "heft-ufo",
+            downloader=lambda _url: payload,
+        )
+
+
+def test_prepare_heft_ufo_rejects_upstream_source_drift(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    sources = _upstream_sources()
+    sources["parameters.py"] = sources["parameters.py"].replace(
+        "2.634632e7",
+        "26346320.0",
+    )
+    payload = _archive(sources)
+    _accept_payload(monkeypatch, payload)
+
+    with pytest.raises(heft_ufo.HEFTUFOPreparationError, match="expected one"):
+        heft_ufo.prepare_heft_ufo(
+            tmp_path / "heft-ufo",
+            downloader=lambda _url: payload,
+        )
diff --git a/pyamplicol/tests/unit/test_helicity_recurrence_generation.py b/pyamplicol/tests/unit/test_helicity_recurrence_generation.py
new file mode 100644
index 0000000000..f7b44be2b6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_helicity_recurrence_generation.py
@@ -0,0 +1,342 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+from pathlib import Path
+from types import MethodType
+
+import pytest
+
+import pyamplicol.generation.service as service_module
+from pyamplicol.api import ProcessRequest
+from pyamplicol.config import GenerationConfig
+from pyamplicol.generation.dag_algorithms import (
+    prune_global_helicity_flip_equivalent_roots,
+)
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.helicity_replay import (
+    HELICITY_RECURRENCE_CONTRACT_VERSION,
+    RUNTIME_SELECTOR_PROVENANCE,
+    HelicityRecurrencePlan,
+    build_helicity_recurrence_plan,
+)
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.generation.runtime_schema import build_runtime_schema
+from pyamplicol.models import BuiltinSMModel, CompiledUFOModel, compile_model_source
+from pyamplicol.models.base import Model, VertexEvaluationEquivalence
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.processes.model import build_model_process_ir
+
+ROOT = Path(__file__).resolve().parents[2]
+MODEL_ROOT = ROOT / "src" / "pyamplicol" / "assets" / "models" / "json" / "sm"
+
+
+@pytest.fixture(scope="module")
+def ufo_sm() -> CompiledUFOModel:
+    compiled = compile_model_source(
+        MODEL_ROOT / "sm.json",
+        restriction=str((MODEL_ROOT / "restrict_default.json").resolve()),
+        use_cache=False,
+    )
+    return CompiledUFOModel(compiled)
+
+
+def _built_in_plan(expression: str) -> tuple[object, HelicityRecurrencePlan]:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir(expression), model=model)
+    reduced = prune_global_helicity_flip_equivalent_roots(dag, model)
+    plan = build_helicity_recurrence_plan(reduced, model)
+    assert plan is not None
+    return reduced, plan
+
+
+def _class_topology(plan: HelicityRecurrencePlan) -> tuple[object, ...]:
+    return (
+        sorted(
+            (
+                recurrence.source_class,
+                recurrence.external_labels,
+                len(recurrence.members),
+            )
+            for recurrence in plan.recurrence_classes
+        ),
+        sorted(len(recurrence.members) for recurrence in plan.amplitude_classes),
+        plan.proof_counts(),
+    )
+
+
+def test_builtin_and_ufo_zjet_derive_the_same_recurrence_topology(
+    ufo_sm: CompiledUFOModel,
+) -> None:
+    built_in_model = BuiltinSMModel()
+    built_in_dag = compile_generic_dag(
+        build_process_ir("d d~ > z g"),
+        model=built_in_model,
+    )
+    built_in_dag = prune_global_helicity_flip_equivalent_roots(
+        built_in_dag,
+        built_in_model,
+    )
+    built_in_plan = build_helicity_recurrence_plan(
+        built_in_dag,
+        built_in_model,
+    )
+
+    ufo_dag = compile_generic_dag(
+        build_model_process_ir("d d~ > z g", ufo_sm.compiled.ir),
+        model=ufo_sm,
+    )
+    ufo_dag = prune_global_helicity_flip_equivalent_roots(ufo_dag, ufo_sm)
+    ufo_plan = build_helicity_recurrence_plan(ufo_dag, ufo_sm)
+
+    assert built_in_plan is not None
+    assert ufo_plan is not None
+    assert _class_topology(built_in_plan) == _class_topology(ufo_plan)
+    assert not built_in_plan.residual_current_ids
+    assert not ufo_plan.residual_current_ids
+    assert any(
+        contract.startswith("symbolica-sha256:")
+        for recurrence in ufo_plan.recurrence_classes
+        for contract in recurrence.transition_contract_ids
+    )
+
+
+def test_massive_qcd_source_helicities_share_recurrence_classes() -> None:
+    _dag, plan = _built_in_plan("g g > t t~")
+
+    for label in (3, 4):
+        mappings = tuple(
+            mapping
+            for mapping in plan.source_state_mappings
+            if mapping.external_label == label
+        )
+        assert {mapping.helicity for mapping in mappings} == {-1, 1}
+        assert {mapping.chirality for mapping in mappings} == {0}
+        assert len({mapping.recurrence_class_id for mapping in mappings}) == 1
+
+
+def test_massless_chiral_source_states_remain_separate() -> None:
+    _dag, plan = _built_in_plan("d d~ > z g")
+
+    for label in (1, 2):
+        mappings = tuple(
+            mapping
+            for mapping in plan.source_state_mappings
+            if mapping.external_label == label
+        )
+        assert {mapping.helicity for mapping in mappings} == {-1, 1}
+        assert {mapping.chirality for mapping in mappings} == {-1, 1}
+        assert len({mapping.recurrence_class_id for mapping in mappings}) == 2
+
+
+def test_unproven_transition_becomes_a_local_residual(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir("d d~ > z g"), model=model)
+    dag = prune_global_helicity_flip_equivalent_roots(dag, model)
+    failed_kind = min(interaction.vertex_kind for interaction in dag.interactions)
+    original = model.vertex_evaluation_equivalence
+
+    def with_one_failed_contract(
+        self: Model,
+        kind: int,
+    ) -> VertexEvaluationEquivalence:
+        del self
+        if kind == failed_kind:
+            return VertexEvaluationEquivalence(
+                class_id=f"deliberately-unproven:{kind}",
+                verified=False,
+            )
+        return original(kind)
+
+    monkeypatch.setattr(
+        model,
+        "vertex_evaluation_equivalence",
+        MethodType(with_one_failed_contract, model),
+    )
+    plan = build_helicity_recurrence_plan(dag, model)
+
+    assert plan is not None
+    assert plan.residual_current_ids
+    assert len(plan.residual_current_ids) < len(dag.currents)
+    assert plan.optimized_class_count > 0
+    assert any(f"kind {failed_kind}" in diagnostic for diagnostic in plan.diagnostics)
+
+
+def test_post_reduction_manifest_ids_and_weight_two_domains_are_complete() -> None:
+    model = BuiltinSMModel()
+    raw = compile_generic_dag(build_process_ir("g g > g g"), model=model)
+    reduced = prune_global_helicity_flip_equivalent_roots(raw, model)
+    plan = build_helicity_recurrence_plan(reduced, model)
+
+    assert plan is not None
+    assert len(reduced.currents) < len(raw.currents)
+    assert {root.helicity_weight for root in reduced.amplitude_roots} == {2.0}
+    assert {
+        member.current_id
+        for recurrence in plan.recurrence_classes
+        for member in recurrence.members
+    } | set(plan.residual_current_ids) == set(range(len(reduced.currents)))
+    assert {
+        member.root_id
+        for recurrence in plan.amplitude_classes
+        for member in recurrence.members
+    } | set(plan.residual_root_ids) == set(range(len(reduced.amplitude_roots)))
+    assert all(
+        len(member.selector_domain_ids) == 2
+        for recurrence in plan.amplitude_classes
+        for member in recurrence.members
+    )
+    assert plan.physical_helicity_count == 16
+
+
+def test_generation_service_attaches_plan_after_final_dense_remap() -> None:
+    model = BuiltinSMModel()
+    backend = service_module.GenerationBackend(GenerationConfig(), None)
+    process_ir = build_process_ir("g g > g g")
+    dag, coverage = backend._compile_concrete_process(process_ir, model)
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(
+            expanded=service_module._ExpandedProcess(
+                request=ProcessRequest.parse("g g > g g", name="gg_gg"),
+                process_ir=process_ir,
+            ),
+            dag=dag,
+            coverage=coverage,
+        ),
+        model,
+        index=0,
+        phase=PhaseHandle("test", None, 1),
+    )
+
+    plan = prepared.dag.helicity_recurrence
+    materialization = prepared.dag.helicity_materialization
+    assert plan is not None
+    assert materialization is not None
+    assert plan.current_count == materialization.proof_current_count
+    assert plan.amplitude_root_count == materialization.proof_root_count
+    assert materialization.materialized_current_count == len(prepared.dag.currents)
+    assert materialization.materialized_root_count == len(prepared.dag.amplitude_roots)
+    assert (
+        max(
+            member.current_id
+            for recurrence in plan.recurrence_classes
+            for member in recurrence.members
+        )
+        < materialization.proof_current_count
+    )
+    assert (
+        max(
+            member.root_id
+            for recurrence in plan.amplitude_classes
+            for member in recurrence.members
+        )
+        < materialization.proof_root_count
+    )
+    assert all(
+        0 <= route.materialized_current_id < len(prepared.dag.currents)
+        for route in materialization.source_routes
+    )
+    assert all(
+        0 <= route.materialized_root_id < len(prepared.dag.amplitude_roots)
+        for route in materialization.amplitude_routes
+    )
+    assert materialization.strategy == "quotient"
+    assert {root.helicity_weight for root in prepared.dag.amplitude_roots} == {1.0}
+    assert all(
+        route.factor == pytest.approx((1.0, 0.0))
+        for route in materialization.amplitude_routes
+    )
+    assert plan.physical_helicity_count == 16
+
+
+def test_complete_artifact_emits_selector_provenance_and_contract() -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(build_process_ir("d d~ > z"), model=model)
+    dag = prune_global_helicity_flip_equivalent_roots(dag, model)
+    plan = build_helicity_recurrence_plan(dag, model)
+    assert plan is not None
+    schema = build_runtime_schema(
+        replace(dag, helicity_recurrence=plan),
+        model,
+    )
+
+    selector_contract = schema["physics"]["extensions"]["runtime_selectors"]
+    assert selector_contract["provenance"] == RUNTIME_SELECTOR_PROVENANCE
+    assert selector_contract["generation_specialized_axes"] == []
+    assert selector_contract["helicity_recurrence"]["contract_version"] == (
+        HELICITY_RECURRENCE_CONTRACT_VERSION
+    )
+    assert schema["helicity_recurrence"]["current_count"] == len(dag.currents)
+    assert schema["helicity_recurrence"]["amplitude_root_count"] == len(
+        dag.amplitude_roots
+    )
+
+
+def test_selected_helicity_keeps_complete_color_axis_reusable() -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("d d~ > z"),
+        model=model,
+        selected_source_helicities={1: -1},
+    )
+    before = dag.to_json_dict()
+
+    assert build_helicity_recurrence_plan(dag, model) is None
+    assert dag.to_json_dict() == before
+    assert "helicity_recurrence" not in before
+    schema = build_runtime_schema(dag, model)
+    assert "helicity_recurrence" not in schema
+    selectors = schema["physics"]["extensions"]["runtime_selectors"]
+    assert selectors["generation_specialized_axes"] == ["helicity"]
+    assert selectors["axes"]["helicity"]["runtime_contract"] == (
+        "generation-specialized"
+    )
+    assert selectors["axes"]["color_flow"]["runtime_contract"] == ("complete-reusable")
+    assert "helicity_recurrence" not in selectors
+
+
+def test_selected_color_keeps_complete_helicity_axis_reusable() -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("d d~ > z g"),
+        model=model,
+        selected_color_sector_ids={0},
+    )
+    dag = prune_global_helicity_flip_equivalent_roots(dag, model)
+    plan = build_helicity_recurrence_plan(dag, model)
+    assert plan is not None
+    schema = build_runtime_schema(
+        replace(dag, helicity_recurrence=plan),
+        model,
+    )
+
+    selectors = schema["physics"]["extensions"]["runtime_selectors"]
+    assert selectors["generation_specialized_axes"] == ["color_flow"]
+    assert selectors["axes"]["helicity"]["runtime_contract"] == ("complete-reusable")
+    assert selectors["axes"]["color_flow"]["runtime_contract"] == (
+        "generation-specialized"
+    )
+    assert selectors["helicity_recurrence"]["status"] == "available"
+    assert "helicity_recurrence" in schema
+
+
+def test_color_and_helicity_specialization_are_reported_independently() -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("d d~ > z g"),
+        model=model,
+        selected_color_sector_ids={0},
+        selected_source_helicities={1: -1},
+    )
+    schema = build_runtime_schema(dag, model)
+
+    selectors = schema["physics"]["extensions"]["runtime_selectors"]
+    assert selectors["generation_specialized_axes"] == [
+        "helicity",
+        "color_flow",
+    ]
+    assert selectors["axes"]["helicity"]["generation_selection"] == {"1": -1}
+    assert selectors["axes"]["color_flow"]["generation_selection"] == [0]
+    assert "helicity_recurrence" not in selectors
diff --git a/pyamplicol/tests/unit/test_helicity_recurrence_materialization.py b/pyamplicol/tests/unit/test_helicity_recurrence_materialization.py
new file mode 100644
index 0000000000..1051e95de0
--- /dev/null
+++ b/pyamplicol/tests/unit/test_helicity_recurrence_materialization.py
@@ -0,0 +1,221 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+from types import MethodType
+
+import pytest
+
+from pyamplicol.generation.dag_algorithms import (
+    prune_global_helicity_flip_equivalent_roots,
+)
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.helicity_materialization import (
+    materialize_helicity_recurrence,
+    retain_helicity_recurrence_graph,
+)
+from pyamplicol.generation.helicity_replay import (
+    build_helicity_recurrence_plan,
+)
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.base import Model, VertexEvaluationEquivalence
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _materialize(expression: str):
+    model = BuiltinSMModel()
+    full = compile_generic_dag(build_process_ir(expression), model=model)
+    reduced = prune_global_helicity_flip_equivalent_roots(full, model)
+    plan = build_helicity_recurrence_plan(reduced, model)
+    assert plan is not None
+    return reduced, plan, materialize_helicity_recurrence(reduced, plan)
+
+
+def test_zjet_materializes_one_current_and_root_per_proven_class() -> None:
+    full, plan, materialization = _materialize("d d~ > z g")
+
+    assert materialization.strategy == "quotient"
+    assert not plan.residual_current_ids
+    assert not plan.residual_root_ids
+    assert materialization.materialized_current_count == len(plan.recurrence_classes)
+    assert materialization.materialized_root_count == len(plan.amplitude_classes)
+    assert materialization.materialized_current_count < len(full.currents)
+    assert materialization.materialized_root_count < len(full.amplitude_roots)
+    assert len(materialization.proof_to_materialized_current) == len(full.currents)
+    assert set(materialization.proof_to_materialized_current) == set(
+        range(materialization.materialized_current_count)
+    )
+    assert len(materialization.dag.interactions) < len(full.interactions)
+
+
+def test_weight_two_roots_expand_to_two_physical_selector_routes() -> None:
+    _full, plan, materialization = _materialize("g g > g g")
+
+    expected_domains = {
+        domain.id for domain in plan.selector_domains if domain.complete
+    } - set(plan.structural_zero_selector_domain_ids)
+    routed_domains = {
+        domain_id
+        for route in materialization.amplitude_routes
+        for domain_id in route.selector_domain_ids
+    }
+    assert routed_domains == expected_domains
+    assert all(
+        root.helicity_weight == 1.0 for root in materialization.dag.amplitude_roots
+    )
+    assert all(route.factor == (1.0, 0.0) for route in materialization.amplitude_routes)
+    assert {
+        schedule.selector_domain_id
+        for schedule in materialization.selector_schedules
+        if schedule.structural_zero
+    } == set(plan.structural_zero_selector_domain_ids)
+    assert all(
+        not schedule.active_current_ids and not schedule.active_root_ids
+        for schedule in materialization.selector_schedules
+        if schedule.structural_zero
+    )
+    assert all(
+        schedule.active_current_ids and schedule.active_root_ids
+        for schedule in materialization.selector_schedules
+        if not schedule.structural_zero
+    )
+
+
+def test_runtime_source_routes_cover_every_declared_physical_state() -> None:
+    _full, plan, materialization = _materialize("g g > t t~")
+
+    expected = {
+        (mapping.external_label, mapping.helicity, mapping.chirality)
+        for mapping in plan.source_state_mappings
+    }
+    actual = {
+        (route.external_label, route.helicity, route.chirality)
+        for route in materialization.source_routes
+    }
+    assert actual == expected
+    assert all(
+        0 <= route.materialized_current_id < len(materialization.dag.currents)
+        for route in materialization.source_routes
+    )
+
+
+def test_retained_graph_keeps_fused_sum_and_exact_selector_closures() -> None:
+    model = BuiltinSMModel()
+    full = compile_generic_dag(build_process_ir("d d~ > z g g"), model=model)
+    reduced = prune_global_helicity_flip_equivalent_roots(full, model)
+    plan = build_helicity_recurrence_plan(reduced, model)
+    assert plan is not None
+
+    retained = retain_helicity_recurrence_graph(reduced, plan)
+
+    assert retained.strategy == "retained-proof-graph"
+    assert retained.dag is reduced
+    assert retained.proof_to_materialized_current == tuple(
+        range(len(reduced.currents))
+    )
+    assert retained.materialized_current_count == len(reduced.currents)
+    assert retained.materialized_root_count == len(reduced.amplitude_roots)
+    assert {
+        route.materialized_root_id for route in retained.amplitude_routes
+    } == set(range(len(reduced.amplitude_roots)))
+    for route in retained.amplitude_routes:
+        expected = 1.0 / math.sqrt(
+            retained.dag.amplitude_roots[
+                route.materialized_root_id
+            ].helicity_weight
+        )
+        assert route.factor == pytest.approx((expected, 0.0))
+    assert all(route.factor == (1.0, 0.0) for route in retained.source_routes)
+    assert all(
+        bool(schedule.active_root_ids) is not schedule.structural_zero
+        for schedule in retained.selector_schedules
+    )
+    assert any(
+        len(schedule.active_current_ids) < len(reduced.currents)
+        for schedule in retained.selector_schedules
+        if not schedule.structural_zero
+    )
+
+
+def test_local_residuals_remain_materialized_without_disabling_other_classes(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model = BuiltinSMModel()
+    full = compile_generic_dag(build_process_ir("d d~ > z g"), model=model)
+    full = prune_global_helicity_flip_equivalent_roots(full, model)
+    failed_kind = min(interaction.vertex_kind for interaction in full.interactions)
+    original = model.vertex_evaluation_equivalence
+
+    def with_one_failed_contract(
+        self: Model,
+        kind: int,
+    ) -> VertexEvaluationEquivalence:
+        del self
+        if kind == failed_kind:
+            return VertexEvaluationEquivalence(
+                class_id=f"deliberately-unproven:{kind}",
+                verified=False,
+            )
+        return original(kind)
+
+    monkeypatch.setattr(
+        model,
+        "vertex_evaluation_equivalence",
+        MethodType(with_one_failed_contract, model),
+    )
+    plan = build_helicity_recurrence_plan(full, model)
+    assert plan is not None
+    materialization = materialize_helicity_recurrence(full, plan)
+
+    assert plan.residual_current_ids
+    assert plan.residual_root_ids
+    assert plan.optimized_class_count > 0
+    assert len(materialization.dag.currents) <= len(full.currents)
+    assert any(route.residual for route in materialization.amplitude_routes)
+
+    complete_domains = {
+        domain.id for domain in plan.selector_domains if domain.complete
+    }
+    schedules = {
+        schedule.selector_domain_id: schedule
+        for schedule in materialization.selector_schedules
+    }
+    routed_domains = {
+        domain_id
+        for route in materialization.amplitude_routes
+        for domain_id in route.selector_domain_ids
+    }
+    assert set(schedules) == complete_domains
+    assert routed_domains == {
+        domain_id
+        for domain_id in complete_domains
+        if not schedules[domain_id].structural_zero
+    }
+    assert all(
+        bool(schedule.active_root_ids) is not schedule.structural_zero
+        for schedule in schedules.values()
+    )
+    selector_states_by_domain = {
+        domain.id: set(domain.source_states) for domain in plan.selector_domains
+    }
+    for schedule in schedules.values():
+        required_sources = {
+            current_id
+            for current_id in schedule.active_current_ids
+            if materialization.dag.currents[current_id].is_source
+        }
+        complete_state = selector_states_by_domain[schedule.selector_domain_id]
+        routed_sources = {
+            route.materialized_current_id
+            for route in materialization.source_routes
+            if selector_states_by_domain[route.selector_domain_id] <= complete_state
+        }
+        assert required_sources <= routed_sources
+    assert {
+        (route.external_label, route.helicity)
+        for route in materialization.source_routes
+    } == {
+        state
+        for domain in plan.selector_domains
+        for state in domain.source_states
+    }
diff --git a/pyamplicol/tests/unit/test_lc_closure_anchor.py b/pyamplicol/tests/unit/test_lc_closure_anchor.py
new file mode 100644
index 0000000000..b78c7ae36f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_lc_closure_anchor.py
@@ -0,0 +1,546 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import replace
+
+import pytest
+
+from pyamplicol.color import build_color_plan
+from pyamplicol.generation.dag_algorithms import (
+    _canonical_open_line_alias_owner_sector_ids,
+    _canonical_open_line_alias_owner_sector_map,
+    _physical_sink_sector_ids,
+    _retain_canonical_open_line_alias_roots,
+    infer_minimal_coupling_order_limits,
+    prune_dag_to_amplitude_roots,
+)
+from pyamplicol.generation.dag_color import ColorEngine
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_ordering import _closure_candidate_splits
+from pyamplicol.generation.dag_types import AmplitudeRoot, GenericDAG
+from pyamplicol.generation.helicity_replay import _SemanticAmplitudeRootSignature
+from pyamplicol.models._physics_ir import ContractionIR
+from pyamplicol.models.builtin.model import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _sector_for_word(expression: str, word: tuple[int, ...]):
+    process = build_process_ir(expression)
+    plan = build_color_plan(process)
+    return process, next(
+        sector for sector in plan.sectors if sector.word_labels == word
+    )
+
+
+def _alias_root_test_dag(
+    sector_ids: tuple[int, ...],
+) -> GenericDAG:
+    process = build_process_ir(
+        "d d~ > t t~ g g",
+        color_accuracy="full",
+    )
+    plan = build_color_plan(process, color_accuracy="full")
+    contraction = ContractionIR(
+        name="alias-root-test",
+        left_basis="scalar",
+        right_basis="scalar",
+        coefficients=((1.0, 0.0),),
+    )
+    roots = tuple(
+        AmplitudeRoot(
+            id=root_id,
+            kind="direct",
+            left_id=root_id,
+            right_id=root_id,
+            color_weight=(1.0, 0.0),
+            contraction_ir=contraction,
+            color_sector_id=sector_id,
+        )
+        for root_id, sector_id in enumerate(sector_ids)
+    )
+    return GenericDAG(
+        process=process,
+        color_plan=plan,
+        currents=(),
+        sources=(),
+        interactions=(),
+        amplitude_roots=roots,
+    )
+
+
+def _first_open_line_alias_pair(dag: GenericDAG) -> tuple[int, int]:
+    owner_by_sector = _canonical_open_line_alias_owner_sector_map(dag.color_plan)
+    aliases_by_owner: dict[int, list[int]] = {}
+    for sector_id, owner_id in owner_by_sector.items():
+        aliases_by_owner.setdefault(owner_id, []).append(sector_id)
+    pair = next(
+        tuple(sorted(sector_ids))[:2]
+        for sector_ids in aliases_by_owner.values()
+        if len(sector_ids) >= 2
+    )
+    assert len(pair) == 2
+    return pair[0], pair[1]
+
+
+def _alias_signature(label: str) -> _SemanticAmplitudeRootSignature:
+    return _SemanticAmplitudeRootSignature(
+        proof_digest=label * 64,
+        selector_states=(),
+        factor=(1.0, 0.0),
+    )
+
+
+def test_proof_identical_aliases_reject_unequal_root_multiplicity(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    first, second = _first_open_line_alias_pair(_alias_root_test_dag(()))
+    dag = _alias_root_test_dag((first, first, second))
+    signature = _alias_signature("a")
+    monkeypatch.setattr(
+        "pyamplicol.generation.dag_algorithms."
+        "_semantic_amplitude_root_alias_signatures",
+        lambda *_args, **_kwargs: (signature, signature, signature),
+    )
+
+    with pytest.raises(ValueError, match="unequal root multiplicities"):
+        _retain_canonical_open_line_alias_roots(dag, BuiltinSMModel())
+
+
+def test_proof_identical_aliases_with_equal_multiplicity_still_collapse(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    first, second = _first_open_line_alias_pair(_alias_root_test_dag(()))
+    dag = _alias_root_test_dag((first, first, second, second))
+    signature = _alias_signature("a")
+    monkeypatch.setattr(
+        "pyamplicol.generation.dag_algorithms."
+        "_semantic_amplitude_root_alias_signatures",
+        lambda *_args, **_kwargs: (signature,) * 4,
+    )
+
+    retained = _retain_canonical_open_line_alias_roots(dag, BuiltinSMModel())
+
+    owner = _canonical_open_line_alias_owner_sector_map(dag.color_plan)[first]
+    assert len(retained.amplitude_roots) == 2
+    assert {root.color_sector_id for root in retained.amplitude_roots} == {owner}
+
+
+def test_distinct_alias_proof_signatures_remain_a_union(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    first, second = _first_open_line_alias_pair(_alias_root_test_dag(()))
+    dag = _alias_root_test_dag((first, first, second, second))
+    signature_a = _alias_signature("a")
+    signature_b = _alias_signature("b")
+    monkeypatch.setattr(
+        "pyamplicol.generation.dag_algorithms."
+        "_semantic_amplitude_root_alias_signatures",
+        lambda *_args, **_kwargs: (
+            signature_a,
+            signature_b,
+            signature_a,
+            signature_b,
+        ),
+    )
+
+    retained = _retain_canonical_open_line_alias_roots(dag, BuiltinSMModel())
+
+    assert len(retained.amplitude_roots) == 2
+    assert {root.left_id for root in retained.amplitude_roots} == {0, 1}
+
+
+def test_two_line_closure_rotates_public_blocks_from_source_slot_zero() -> None:
+    process, sector = _sector_for_word("d d~ > t t~ g g", (2, 5, 6, 4, 3, 1))
+
+    assert sector.canonical_closure_traversal_word(process) == (3, 1, 2, 5, 6, 4)
+    assert sector.canonical_closure_sink_label(process) == 4
+    assert sector.word_labels == (2, 5, 6, 4, 3, 1)
+
+
+def test_public_reference_selects_sector_without_overriding_private_closure() -> None:
+    process, sector = _sector_for_word(
+        "d d~ > t t~ g g",
+        (2, 5, 6, 4, 3, 1),
+    )
+    model = BuiltinSMModel()
+    plan = build_color_plan(process)
+    limits = infer_minimal_coupling_order_limits(
+        process,
+        model=model,
+        selected_color_sector_ids=(sector.id,),
+    )
+    dag = prune_dag_to_amplitude_roots(
+        compile_generic_dag(
+            process,
+            model=model,
+            color_plan=plan,
+            reference_color_order=sector.word_labels,
+            selected_color_sector_ids=(sector.id,),
+            max_coupling_orders=limits,
+            closure_side_mask_pruning=False,
+            color_order_mask_pruning=False,
+            species_reachability_pruning=False,
+        )
+    )
+
+    assert plan.sectors[sector.id].word_labels == (2, 5, 6, 4, 3, 1)
+    assert (
+        len(dag.currents),
+        len(dag.interactions),
+        len(dag.amplitude_roots),
+        sum(
+            current.index.external_mask.bit_count() == 1
+            for current in dag.currents
+        ),
+    ) == (78, 150, 32, 12)
+
+
+def test_closure_reconstructs_blocks_independently_of_line_tuple_order() -> None:
+    process, sector = _sector_for_word("d d~ > t t~ g", (2, 5, 4, 3, 1))
+    reordered = replace(
+        sector,
+        open_color_lines=tuple(reversed(sector.open_color_lines)),
+    )
+
+    assert reordered.canonical_closure_traversal_word(process) == (3, 1, 2, 5, 4)
+    assert reordered.canonical_closure_sink_label(process) == 4
+
+
+def test_closure_uses_source_position_not_numeric_public_label() -> None:
+    process, sector = _sector_for_word("d d~ > t t~", (2, 4, 3, 1))
+    label_map = {1: 10, 2: 5, 3: 20, 4: 30}
+    relabelled_process = replace(
+        process,
+        legs=tuple(
+            replace(leg, label=label_map[leg.label])
+            for leg in process.legs
+        ),
+    )
+    relabelled_sector = replace(
+        sector,
+        word_labels=tuple(label_map[label] for label in sector.word_labels),
+        open_color_lines=tuple(
+            replace(
+                line,
+                fundamental_label=label_map[line.fundamental_label],
+                antifundamental_label=label_map[line.antifundamental_label],
+                adjoint_labels=tuple(
+                    label_map[label] for label in line.adjoint_labels
+                ),
+            )
+            for line in sector.open_color_lines
+        ),
+    )
+
+    assert relabelled_process.legs[0].label == 10
+    assert min(label_map.values()) == 5
+    assert relabelled_sector.canonical_closure_traversal_word(
+        relabelled_process
+    ) == (20, 10, 5, 30)
+
+
+def test_singlet_source_zero_selects_minimum_coloured_source_slot() -> None:
+    process = build_process_ir("e- d > e- d t t~")
+    plan = build_color_plan(process)
+    sector = next(
+        sector
+        for sector in plan.sectors
+        if sector.word_labels == (4, 6, 5, 2)
+    )
+
+    assert process.legs[0].is_singlet
+    assert process.legs[1].label == 2
+    assert sector.canonical_closure_traversal_word(process) == (5, 2, 4, 6)
+    assert sector.canonical_closure_sink_label(process) == 6
+
+
+def test_single_trace_and_singlet_sectors_keep_public_words() -> None:
+    for expression in ("g g > g g", "z z > z z"):
+        process = build_process_ir(expression)
+        plan = build_color_plan(process)
+        assert all(
+            sector.canonical_closure_traversal_word(process)
+            == sector.color_words[0]
+            for sector in plan.sectors
+        )
+
+
+def test_non_lc_open_line_roots_use_the_canonical_private_sink() -> None:
+    model = BuiltinSMModel()
+    for accuracy in ("nlc", "full"):
+        process = build_process_ir(
+            "d d~ > t t~ g g",
+            color_accuracy=accuracy,
+        )
+        plan = build_color_plan(process, color_accuracy=accuracy)
+        engine = ColorEngine(plan, model)
+        candidate_splits = _closure_candidate_splits(process, model, engine)
+
+        assert candidate_splits == ((55, 8),)
+        assert _physical_sink_sector_ids(plan, candidate_splits) == frozenset(
+            sector.id for sector in plan.sectors
+        )
+
+        owner_sector_ids = frozenset(range(0, 24, 2))
+        assert _canonical_open_line_alias_owner_sector_ids(
+            plan,
+            (sector.id for sector in plan.sectors),
+        ) == owner_sector_ids
+        complete_limits = infer_minimal_coupling_order_limits(
+            process,
+            model=model,
+        )
+        complete_dag = compile_generic_dag(
+            process,
+            model=model,
+            color_plan=plan,
+            max_coupling_orders=complete_limits,
+        )
+        assert len(complete_dag.amplitude_roots) == 384
+        assert {
+            root.color_sector_id for root in complete_dag.amplitude_roots
+        } == owner_sector_ids
+        assert all(
+            sum(
+                root.color_sector_id == sector_id
+                for root in complete_dag.amplitude_roots
+            )
+            == 32
+            for sector_id in owner_sector_ids
+        )
+        backward_dag = compile_generic_dag(
+            process,
+            model=model,
+            color_plan=plan,
+            max_coupling_orders=complete_limits,
+            backward_live_planning=True,
+        )
+        assert {
+            root.color_sector_id for root in backward_dag.amplitude_roots
+        } == owner_sector_ids
+
+        # A restricted non-owner alias becomes the sole active owner rather
+        # than being erased by ownership derived from the complete plan.
+        sector = plan.sectors[13]
+        limits = infer_minimal_coupling_order_limits(
+            process,
+            model=model,
+            selected_color_sector_ids=(sector.id,),
+        )
+        dag = compile_generic_dag(
+            process,
+            model=model,
+            color_plan=plan,
+            selected_color_sector_ids=(sector.id,),
+            max_coupling_orders=limits,
+        )
+        traversal = sector.canonical_closure_traversal_word(process)
+
+        assert len(dag.amplitude_roots) == 32
+        assert {
+            dag.currents[root.right_id].index.external_labels
+            for root in dag.amplitude_roots
+        } == {(traversal[-1],)}
+        assert {
+            dag.currents[root.left_id].index.ordered_external_labels
+            for root in dag.amplitude_roots
+        } == {traversal[:-1]}
+        assert any(
+            current.index.particle_id == 6
+            and current.index.external_mask.bit_count() > 1
+            for current in dag.currents
+        )
+        assert not any(
+            current.index.particle_id == -6
+            and current.index.external_mask.bit_count() > 1
+            for current in dag.currents
+        )
+        root_keys = {
+            (
+                root.kind,
+                root.left_id,
+                root.right_id,
+                root.color_sector_id,
+                root.vertex_kind,
+                root.vertex_particles,
+                root.contraction_ir,
+            )
+            for root in dag.amplitude_roots
+        }
+        assert len(root_keys) == len(dag.amplitude_roots)
+
+
+def test_three_open_line_private_sinks_are_resolved_per_sector() -> None:
+    model = BuiltinSMModel()
+    full_mask = (1 << 6) - 1
+    for accuracy in ("nlc", "full"):
+        process = build_process_ir(
+            "d d~ > u u~ s s~",
+            color_accuracy=accuracy,
+        )
+        plan = build_color_plan(process, color_accuracy=accuracy)
+        engine = ColorEngine(plan, model)
+
+        assert len(plan.sectors) == 36
+        assert _canonical_open_line_alias_owner_sector_ids(
+            plan,
+            (sector.id for sector in plan.sectors),
+        ) == frozenset({0, 6, 12, 18, 24, 30})
+
+        assert {
+            sector.canonical_closure_sink_label(process) for sector in plan.sectors
+        } == {4, 6}
+        for sink_label in (4, 6):
+            sink_mask = 1 << (sink_label - 1)
+            expected_sector_ids = frozenset(
+                sector.id
+                for sector in plan.sectors
+                if sector.canonical_closure_sink_label(process) == sink_label
+            )
+            assert (
+                _physical_sink_sector_ids(
+                    plan,
+                    ((full_mask ^ sink_mask, sink_mask),),
+                )
+                == expected_sector_ids
+            )
+
+        assert {
+            right_mask
+            for _left_mask, right_mask in _closure_candidate_splits(
+                process,
+                model,
+                engine,
+            )
+        } == {1 << 3, 1 << 5}
+
+        limits = infer_minimal_coupling_order_limits(process, model=model)
+        dag = compile_generic_dag(
+            process,
+            model=model,
+            color_plan=plan,
+            max_coupling_orders=limits,
+        )
+        # The public tensor owners remain stable, including rootless sector 24.
+        # Semantic closure ownership retains both distinct traversal families
+        # where they exist instead of deleting an entire alias sector.
+        root_owner_ids = frozenset({0, 6, 12, 18, 24, 30})
+        assert len(dag.amplitude_roots) == 80
+        assert {root.color_sector_id for root in dag.amplitude_roots} == root_owner_ids
+        assert Counter(
+            root.color_sector_id for root in dag.amplitude_roots
+        ) == Counter({0: 16, 6: 16, 12: 16, 18: 8, 24: 8, 30: 16})
+        assert {
+            dag.currents[root.right_id].index.external_labels
+            for root in dag.amplitude_roots
+            if root.color_sector_id == 0
+        } == {(4,), (6,)}
+        backward_dag = compile_generic_dag(
+            process,
+            model=model,
+            color_plan=plan,
+            max_coupling_orders=limits,
+            backward_live_planning=True,
+        )
+        assert {
+            root.color_sector_id for root in backward_dag.amplitude_roots
+        } == root_owner_ids
+        assert len(backward_dag.amplitude_roots) == len(dag.amplitude_roots)
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_identical_three_line_aliases_preserve_exchange_closures(
+    accuracy: str,
+) -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir(
+        "d d~ > u u~ u u~",
+        color_accuracy=accuracy,
+    )
+    limits = infer_minimal_coupling_order_limits(process, model=model)
+
+    dag = compile_generic_dag(
+        process,
+        model=model,
+        max_coupling_orders=limits,
+    )
+    backward_dag = compile_generic_dag(
+        process,
+        model=model,
+        max_coupling_orders=limits,
+        backward_live_planning=True,
+    )
+
+    expected_by_owner = Counter({0: 24, 6: 24, 12: 20, 18: 20, 24: 20, 30: 20})
+    assert Counter(root.color_sector_id for root in dag.amplitude_roots) == (
+        expected_by_owner
+    )
+    assert Counter(
+        root.color_sector_id for root in backward_dag.amplitude_roots
+    ) == expected_by_owner
+    assert all(
+        {
+            dag.currents[root.right_id].index.external_labels
+            for root in dag.amplitude_roots
+            if root.color_sector_id == owner
+        }
+        == {(4,), (6,)}
+        for owner in expected_by_owner
+    )
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_four_open_line_aliases_retain_semantic_closure_union(
+    accuracy: str,
+) -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir(
+        "d d~ > u u~ s s~ c c~",
+        color_accuracy=accuracy,
+    )
+    limits = infer_minimal_coupling_order_limits(process, model=model)
+    dag = compile_generic_dag(
+        process,
+        model=model,
+        max_coupling_orders=limits,
+        online_evaluation_reuse=True,
+        backward_live_planning=True,
+    )
+
+    counts = Counter(root.color_sector_id for root in dag.amplitude_roots)
+    assert len(dag.color_plan.sectors) == 576
+    assert len(counts) == 24
+    assert len(dag.amplitude_roots) == 672
+    assert set(counts.values()) == {8, 24, 32, 48}
+    assert all(sector_id % 24 == 0 for sector_id in counts)
+
+
+def test_full_colour_pure_gluon_closure_remains_on_public_sinks() -> None:
+    process = build_process_ir("g g > g g", color_accuracy="full")
+    plan = build_color_plan(process, color_accuracy="full")
+    model = BuiltinSMModel()
+    candidate_splits = _closure_candidate_splits(
+        process,
+        model,
+        ColorEngine(plan, model),
+    )
+
+    assert all(
+        sector.canonical_closure_sink_label(process) == sector.color_words[0][-1]
+        for sector in plan.sectors
+    )
+    assert _physical_sink_sector_ids(plan, candidate_splits) == frozenset(
+        sector.id for sector in plan.sectors
+    )
+    assert _canonical_open_line_alias_owner_sector_ids(
+        plan,
+        (sector.id for sector in plan.sectors),
+    ) == frozenset(sector.id for sector in plan.sectors)
+    dag = compile_generic_dag(process, model=model, color_plan=plan)
+    assert len(dag.amplitude_roots) == 96
+    assert Counter(root.color_sector_id for root in dag.amplitude_roots) == Counter(
+        {sector.id: 16 for sector in plan.sectors}
+    )
+    with pytest.raises(ValueError, match="absent from the color plan: 999"):
+        _canonical_open_line_alias_owner_sector_ids(plan, (999,))
diff --git a/pyamplicol/tests/unit/test_lc_color_port_wiring.py b/pyamplicol/tests/unit/test_lc_color_port_wiring.py
new file mode 100644
index 0000000000..b2708b1cfa
--- /dev/null
+++ b/pyamplicol/tests/unit/test_lc_color_port_wiring.py
@@ -0,0 +1,227 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import pytest
+
+from pyamplicol.models.lc_color_port_wiring import (
+    LCColorPortWiring,
+    ParentPortPairing,
+    ParentPortRef,
+    compile_lc_color_port_wirings,
+)
+
+
+def _port(parent: int, local: int) -> ParentPortRef:
+    return ParentPortRef(parent, local)
+
+
+def _pair(
+    fundamental: ParentPortRef,
+    antifundamental: ParentPortRef,
+) -> ParentPortPairing:
+    return ParentPortPairing(fundamental, antifundamental)
+
+
+def test_fundamental_pair_exposes_ordered_adjoint_result_ports() -> None:
+    (wiring,) = compile_lc_color_port_wirings(
+        "fundamental-generator",
+        (3, -3, 8),
+        (3, -3, 8),
+    )
+
+    assert wiring.input_pairings == ()
+    assert wiring.result_port_bindings == (_port(0, 0), _port(1, 0))
+    assert wiring.output_representation == 8
+
+
+@pytest.mark.parametrize(
+    ("oriented", "tensor_roles", "pairing", "result_binding"),
+    (
+        (
+            (3, 8, 3),
+            (3, 8, -3),
+            _pair(_port(0, 0), _port(1, 1)),
+            _port(1, 0),
+        ),
+        (
+            (-3, 8, -3),
+            (-3, 8, 3),
+            _pair(_port(1, 0), _port(0, 0)),
+            _port(1, 1),
+        ),
+    ),
+)
+def test_fundamental_generator_respects_result_current_shape_crossing(
+    oriented: tuple[int, int, int],
+    tensor_roles: tuple[int, int, int],
+    pairing: ParentPortPairing,
+    result_binding: ParentPortRef,
+) -> None:
+    (wiring,) = compile_lc_color_port_wirings(
+        "fundamental-generator",
+        oriented,
+        tensor_roles,
+    )
+
+    assert wiring.input_pairings == (pairing,)
+    assert wiring.result_port_bindings == (result_binding,)
+
+
+def test_structure_constant_emits_both_exact_commutator_wirings() -> None:
+    terms = compile_lc_color_port_wirings(
+        "adjoint-structure-constant",
+        (8, 8, 8),
+        (8, 8, 8),
+    )
+
+    assert tuple(term.exact_factor for term in terms) == (1, -1)
+    assert tuple(term.term_index for term in terms) == (0, 1)
+    assert terms[0].input_pairings == (_pair(_port(0, 0), _port(1, 1)),)
+    assert terms[0].result_port_bindings == (_port(1, 0), _port(0, 1))
+    assert terms[1].input_pairings == (_pair(_port(1, 0), _port(0, 1)),)
+    assert terms[1].result_port_bindings == (_port(0, 0), _port(1, 1))
+
+
+@pytest.mark.parametrize(
+    ("representations", "expected_pairings"),
+    (
+        (
+            (3, -3),
+            (_pair(_port(0, 0), _port(1, 0)),),
+        ),
+        (
+            (-3, 3),
+            (_pair(_port(1, 0), _port(0, 0)),),
+        ),
+        (
+            (8, 8),
+            (
+                _pair(_port(0, 0), _port(1, 1)),
+                _pair(_port(1, 0), _port(0, 1)),
+            ),
+        ),
+    ),
+)
+def test_direct_closure_consumes_q_qbar_and_gluon_ports(
+    representations: tuple[int, int],
+    expected_pairings: tuple[ParentPortPairing, ...],
+) -> None:
+    (wiring,) = compile_lc_color_port_wirings(
+        "direct-closure",
+        representations,
+        representations,
+    )
+
+    assert wiring.input_pairings == expected_pairings
+    assert wiring.result_port_bindings == ()
+    assert wiring.output_representation is None
+
+
+def test_singlet_and_identity_families_have_bounded_exact_wiring() -> None:
+    (singlet,) = compile_lc_color_port_wirings(
+        "singlet",
+        (1, 1, 1),
+        (1, 1, 1),
+    )
+    (identity_copy,) = compile_lc_color_port_wirings(
+        "color-identity",
+        (1, 3, 3),
+        (1, 3, -3),
+    )
+    (identity_close,) = compile_lc_color_port_wirings(
+        "color-identity",
+        (8, 8, 1),
+        (8, 8, 1),
+    )
+
+    assert singlet.input_pairings == singlet.result_port_bindings == ()
+    assert identity_copy.input_pairings == ()
+    assert identity_copy.result_port_bindings == (_port(1, 0),)
+    assert identity_close.input_pairings == (
+        _pair(_port(0, 0), _port(1, 1)),
+        _pair(_port(1, 0), _port(0, 1)),
+    )
+    assert identity_close.result_port_bindings == ()
+
+
+@pytest.mark.parametrize(
+    ("family", "oriented", "tensor_roles", "message"),
+    (
+        (
+            "fundamental-generator",
+            (3, -3, 6),
+            (3, -3, 6),
+            "representation 6 is unsupported",
+        ),
+        (
+            "fundamental-generator",
+            (3, 8, 3),
+            (3, 8, 3),
+            "output tensor role must be dual",
+        ),
+        (
+            "color-identity",
+            (3, 8, 3),
+            (3, 8, -3),
+            "color-identity LC tensor requires",
+        ),
+        (
+            "direct-closure",
+            (3, 3),
+            (3, 3),
+            "direct LC closure requires",
+        ),
+        (
+            "singlet",
+            (1, 1),
+            (1, 1),
+            "requires 3 representations",
+        ),
+    ),
+)
+def test_malformed_or_unsupported_tensor_contracts_fail_closed(
+    family: str,
+    oriented: tuple[int, ...],
+    tensor_roles: tuple[int, ...],
+    message: str,
+) -> None:
+    with pytest.raises(ValueError, match=message):
+        compile_lc_color_port_wirings(  # type: ignore[arg-type]
+            family,
+            oriented,
+            tensor_roles,
+        )
+
+
+def test_wiring_record_rejects_duplicate_or_unconsumed_parent_ports() -> None:
+    with pytest.raises(ValueError, match="more than once"):
+        LCColorPortWiring(
+            tensor_family="fundamental-generator",
+            oriented_representations=(3, 8, 3),
+            tensor_role_representations=(3, 8, -3),
+            term_index=0,
+            exact_factor=1,
+            input_pairings=(
+                ParentPortPairing(_port(0, 0), _port(1, 1)),
+            ),
+            result_port_bindings=(_port(0, 0),),
+        )
+
+
+def test_port_wiring_is_model_neutral_and_deterministic() -> None:
+    # Built-in and UFO compilation provide the same certified tensor family and
+    # representation roles.  No model identity participates in this compiler.
+    built_in_contract = compile_lc_color_port_wirings(
+        "fundamental-generator",
+        (3, 8, 3),
+        (3, 8, -3),
+    )
+    ufo_contract = compile_lc_color_port_wirings(
+        "fundamental-generator",
+        [3, 8, 3],
+        [3, 8, -3],
+    )
+
+    assert built_in_contract == ufo_contract
+    assert hash(built_in_contract) == hash(ufo_contract)
diff --git a/pyamplicol/tests/unit/test_lc_topology_replay_generation.py b/pyamplicol/tests/unit/test_lc_topology_replay_generation.py
new file mode 100644
index 0000000000..850b85988b
--- /dev/null
+++ b/pyamplicol/tests/unit/test_lc_topology_replay_generation.py
@@ -0,0 +1,844 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+import pyamplicol.generation.service as service_module
+from pyamplicol.api import ProcessRequest
+from pyamplicol.api.errors import GenerationError
+from pyamplicol.color import plan_replay as replay_module
+from pyamplicol.color.plan import (
+    GenericColorPlan,
+    build_color_plan,
+    build_lc_topology_replay_plan,
+)
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from pyamplicol.generation import artifact_writer as artifact_writer_module
+from pyamplicol.generation.artifact_writer import CompiledProcessArtifact
+from pyamplicol.generation.dag_algorithms import (
+    prune_global_helicity_flip_equivalent_roots,
+)
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_types import GenericDAG, InteractionNode
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.generation.recurrence_schedule_sharing import (
+    RecurrenceScheduleLoweringCache,
+)
+from pyamplicol.generation.runtime_schema import build_runtime_expression_schema
+from pyamplicol.generation.service import (
+    GenerationBackend,
+    _ProcessSelection,
+)
+from pyamplicol.generation.stage_planning import (
+    _compiled_representative_dependencies,
+    _lc_materialized_sector_memberships,
+)
+from pyamplicol.generation.validation import ValidationPointRecord
+from pyamplicol.models import BuiltinSMModel, CompiledUFOModel, compile_model_source
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.processes.model import build_model_process_ir
+
+_UFO_SM_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+
+
+@dataclass(frozen=True)
+class _ProjectedLogicalStub:
+    external_legs: tuple[object, ...]
+    physical_sectors: tuple[object, ...]
+    public_flows: tuple[object, ...]
+    replay_partitions: tuple[object, ...]
+    selected_public_flow_ids: tuple[int, ...] | None
+
+
+def test_complete_lc_generation_materializes_replay_representative() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > z g g")
+
+    dag, coverage = GenerationBackend(None, None)._compile_concrete_process(
+        process,
+        model,
+    )
+
+    replay = dag.lc_topology_replay
+    assert replay is not None
+    assert replay.physical_sector_ids == (0, 1)
+    assert replay.materialized_sector_ids == (0,)
+    assert replay.residual_sector_ids == ()
+    assert {int(root.color_sector_id or 0) for root in dag.amplitude_roots} == {0}
+    assert tuple(sector.id for sector in dag.color_plan.sectors) == (0, 1)
+    assert coverage["color_sector_count"] == 2
+    assert coverage["materialized_color_sector_count"] == 1
+
+    schema = build_runtime_expression_schema(dag, model).to_mapping()
+    colors = schema["physics"]["color_components"]
+    assert [(record["word"], record["computed"]) for record in colors] == [
+        ([2, 4, 5, 1], True),
+        ([2, 5, 4, 1], False),
+    ]
+    manifest = schema["lc_topology_replay"]
+    assert manifest["physical_sector_count"] == 2
+    assert manifest["materialized_sector_ids"] == [0]
+    assert manifest["residual_sector_ids"] == []
+    assert manifest["groups"][0]["active_sector_ids"] == [0, 1]
+    assert all(
+        item["weight"] > 0.0
+        and item["sign"] in {-1, 1}
+        and item["factor"] == [item["weight"] * item["sign"], 0.0]
+        for item in manifest["groups"][0]["sector_permutations"]
+    )
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+def test_all_flow_union_materializes_complete_color_plan(
+    execution_mode: str,
+) -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > z g g")
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            color=ColorConfig(lc_flow_layout="all-flow-union"),
+            evaluator=EvaluatorConfig(execution_mode=execution_mode),
+        ),
+        None,
+    )
+
+    dag, coverage = backend._compile_concrete_process(process, model)
+
+    assert dag.lc_topology_replay is None
+    assert dag.color_coverage == "complete"
+    assert dag.helicity_coverage == "complete"
+    assert coverage["lc_flow_layout"] == "all-flow-union"
+    assert {
+        int(root.color_sector_id)
+        for root in dag.amplitude_roots
+        if root.color_sector_id is not None
+    } == {int(sector.id) for sector in dag.color_plan.sectors}
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_contracted_color_coverage_has_no_lc_layout_provenance(
+    accuracy: str,
+) -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > z g g", color_accuracy=accuracy)
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            color=ColorConfig(accuracy=accuracy),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        ),
+        None,
+    )
+
+    _dag, coverage = backend._compile_concrete_process(process, model)
+
+    assert "lc_flow_layout" not in coverage
+
+
+def test_compiled_all_flow_union_is_the_only_materialized_execution_lane() -> None:
+    model = BuiltinSMModel()
+    expression = "d d~ > z g g"
+    process = build_process_ir(expression)
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            color=ColorConfig(lc_flow_layout="all-flow-union"),
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        ),
+        None,
+    )
+    dag, coverage = backend._compile_concrete_process(process, model)
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(
+            expanded=service_module._ExpandedProcess(
+                request=ProcessRequest.parse(expression, name="all_flow_union"),
+                process_ir=process,
+            ),
+            dag=dag,
+            coverage=coverage,
+        ),
+        model,
+        index=0,
+        phase=PhaseHandle("test", None, 1),
+    )
+    evaluator = backend._construct_evaluator(
+        prepared,
+        model,
+        PhaseHandle("test", None, 1),
+    )
+
+    assert prepared.helicity_sum_dag is None
+    assert prepared.helicity_selector_union_dag is None
+    assert prepared.dag.helicity_materialization is not None
+    assert evaluator.helicity_sum_runtime_schema is None
+    assert evaluator.helicity_selector_lanes
+    assert all(
+        lane.schedule_mode == "parent-closure"
+        for lane in evaluator.helicity_selector_lanes
+    )
+    assert evaluator.color_selector_lanes == ()
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+@pytest.mark.parametrize(
+    "process",
+    (
+        ProcessConfig(max_color_sectors=1),
+        ProcessConfig(selected_color_sector_ids=(0,)),
+        ProcessConfig(selected_source_helicities={"1": -1}),
+    ),
+)
+def test_all_flow_union_rejects_generation_selected_coverage(
+    process: ProcessConfig,
+    execution_mode: str,
+) -> None:
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            process=process,
+            color=ColorConfig(lc_flow_layout="all-flow-union"),
+            evaluator=EvaluatorConfig(execution_mode=execution_mode),
+        ),
+        None,
+    )
+
+    with pytest.raises(
+        GenerationError,
+        match="requires complete runtime flow and helicity coverage",
+    ):
+        backend._compile_concrete_process(
+            build_process_ir("d d~ > z g g"),
+            BuiltinSMModel(),
+        )
+
+
+@pytest.mark.parametrize(
+    ("process_config", "expected_flows", "expected_helicities"),
+    (
+        (ProcessConfig(), None, None),
+        (ProcessConfig(selected_color_sector_ids=(1,)), (0,), None),
+        (
+            ProcessConfig(
+                selected_source_helicities={
+                    "1": -1,
+                    "2": 1,
+                    "3": -1,
+                    "4": 1,
+                    "5": -1,
+                }
+            ),
+            None,
+            ((1, -1), (2, 1), (3, -1), (4, 1), (5, -1)),
+        ),
+        (
+            ProcessConfig(
+                selected_color_sector_ids=(1,),
+                selected_source_helicities={
+                    "1": -1,
+                    "2": 1,
+                    "3": -1,
+                    "4": 1,
+                    "5": -1,
+                },
+            ),
+            (0,),
+            ((1, -1), (2, 1), (3, -1), (4, 1), (5, -1)),
+        ),
+    ),
+)
+def test_recurrence_all_flow_union_forwards_generation_selected_coverage(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    process_config: ProcessConfig,
+    expected_flows: tuple[int, ...] | None,
+    expected_helicities: tuple[tuple[int, int], ...] | None,
+) -> None:
+    class _StopBeforeNativeLowering(Exception):
+        pass
+
+    expression = "d d~ > z g g"
+    process = build_process_ir(expression)
+    slices: list[object] = []
+
+    def fake_project(
+        _process: object,
+        color_plan: GenericColorPlan,
+        *_args: object,
+        generation_slice: object,
+        **_kwargs: object,
+    ):
+        slices.append(generation_slice)
+        sectors = tuple(color_plan.sectors)
+        return _ProjectedLogicalStub(
+            external_legs=(1, 2, 3, 4, 5),
+            physical_sectors=tuple(range(len(sectors))),
+            public_flows=tuple(
+                SimpleNamespace(flow_id=index, construction_sector_id=index)
+                for index, _sector in enumerate(sectors)
+            ),
+            replay_partitions=(),
+            selected_public_flow_ids=generation_slice.selected_public_flow_ids,
+        )
+
+    projected_logicals: list[_ProjectedLogicalStub] = []
+
+    def stop_before_native_lowering(logical: _ProjectedLogicalStub) -> None:
+        projected_logicals.append(logical)
+        raise _StopBeforeNativeLowering
+
+    monkeypatch.setattr(
+        service_module,
+        "project_recurrence_process_v1",
+        fake_project,
+    )
+    monkeypatch.setattr(
+        service_module,
+        "build_recurrence_builder_input_v1",
+        stop_before_native_lowering,
+    )
+
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            process=process_config,
+            color=ColorConfig(lc_flow_layout="all-flow-union"),
+            evaluator=EvaluatorConfig(execution_mode="recurrence"),
+        ),
+        None,
+    )
+
+    with pytest.raises(_StopBeforeNativeLowering):
+        backend._construct_recurrence_artifact(
+            service_module._ExpandedProcess(
+                request=ProcessRequest.parse(expression, name="recurrence_union"),
+                process_ir=process,
+            ),
+            BuiltinSMModel(),
+            SimpleNamespace(catalog=object()),
+            tmp_path,
+            index=0,
+            phase=PhaseHandle("test", None, 1),
+            lowering_cache=RecurrenceScheduleLoweringCache(),
+        )
+
+    assert len(slices) == 1
+    generation_slice = slices[0]
+    assert generation_slice.selected_public_flow_ids is None
+    assert generation_slice.selected_source_helicities == expected_helicities
+    assert projected_logicals[-1].selected_public_flow_ids == expected_flows
+
+
+def test_recurrence_selected_n6_flow_projects_one_dense_sector(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    class _StopBeforeNativeLowering(Exception):
+        pass
+
+    expression = "d d~ > u u~ s s~ g g"
+    process = build_process_ir(expression)
+    expected_sector = build_color_plan(process).sectors[5]
+    projected_plans: list[GenericColorPlan] = []
+    slices: list[object] = []
+
+    def fake_project(
+        _process: object,
+        color_plan: GenericColorPlan,
+        *_args: object,
+        generation_slice: object,
+        **_kwargs: object,
+    ):
+        projected_plans.append(color_plan)
+        slices.append(generation_slice)
+        sectors = tuple(color_plan.sectors)
+        return _ProjectedLogicalStub(
+            external_legs=tuple(range(len(process.legs))),
+            physical_sectors=tuple(range(len(sectors))),
+            public_flows=tuple(
+                SimpleNamespace(flow_id=index, construction_sector_id=index)
+                for index, _sector in enumerate(sectors)
+            ),
+            replay_partitions=(),
+            selected_public_flow_ids=generation_slice.selected_public_flow_ids,
+        )
+
+    projected_logicals: list[_ProjectedLogicalStub] = []
+
+    def stop_before_native_lowering(logical: _ProjectedLogicalStub) -> None:
+        projected_logicals.append(logical)
+        raise _StopBeforeNativeLowering
+
+    monkeypatch.setattr(
+        service_module,
+        "project_recurrence_process_v1",
+        fake_project,
+    )
+    monkeypatch.setattr(
+        service_module,
+        "build_recurrence_builder_input_v1",
+        stop_before_native_lowering,
+    )
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            process=ProcessConfig(selected_color_sector_ids=(5,)),
+            evaluator=EvaluatorConfig(execution_mode="recurrence"),
+        ),
+        None,
+    )
+
+    with pytest.raises(_StopBeforeNativeLowering):
+        backend._construct_recurrence_artifact(
+            service_module._ExpandedProcess(
+                request=ProcessRequest.parse(expression, name="recurrence_n6"),
+                process_ir=process,
+            ),
+            BuiltinSMModel(),
+            SimpleNamespace(catalog=object()),
+            tmp_path,
+            index=0,
+            phase=PhaseHandle("test", None, 1),
+            lowering_cache=RecurrenceScheduleLoweringCache(),
+        )
+
+    assert len(projected_plans) == 1
+    assert tuple(sector.id for sector in projected_plans[0].sectors) == (0,)
+    assert projected_plans[0].sectors[0].word_labels == expected_sector.word_labels
+    assert slices[0].selected_public_flow_ids is None
+    assert projected_logicals[-1].selected_public_flow_ids == (0,)
+
+
+def test_recurrence_all_flow_union_rejects_truncated_color_coverage() -> None:
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            process=ProcessConfig(max_color_sectors=1),
+            color=ColorConfig(lc_flow_layout="all-flow-union"),
+            evaluator=EvaluatorConfig(execution_mode="recurrence"),
+        ),
+        None,
+    )
+
+    with pytest.raises(
+        GenerationError,
+        match="requires complete runtime flow and helicity coverage",
+    ):
+        backend._prepare_process_construction(
+            build_process_ir("d d~ > z g g"),
+            BuiltinSMModel(),
+        )
+
+
+def test_lc_replay_derives_exact_shared_and_private_current_closures() -> None:
+    model = BuiltinSMModel()
+    dag, _coverage = GenerationBackend(None, None)._compile_concrete_process(
+        build_process_ir("g g > g g"),
+        model,
+    )
+
+    replay = dag.lc_topology_replay
+    assert replay is not None
+    assert replay.materialized_sector_ids == (0, 2)
+    current_domains, root_domains = _lc_materialized_sector_memberships(dag)
+
+    assert set(root_domains) == {root.id for root in dag.amplitude_roots}
+    assert set(current_domains) == set(range(len(dag.currents)))
+    assert {domain for domains in root_domains.values() for domain in domains} == {
+        0,
+        2,
+    }
+    assert any(domains == (0, 2) for domains in current_domains.values())
+    assert any(domains == (0,) for domains in current_domains.values())
+    assert any(domains == (2,) for domains in current_domains.values())
+    compiled_dependencies = _compiled_representative_dependencies(dag)
+    for current_id, parent_ids in compiled_dependencies.items():
+        for parent_id in parent_ids:
+            assert set(current_domains[current_id]).issubset(
+                current_domains[parent_id]
+            )
+
+
+def test_lc_materialized_residuals_get_independent_selector_closures() -> None:
+    model = BuiltinSMModel()
+    dag, _coverage = GenerationBackend(None, None)._compile_concrete_process(
+        build_process_ir("d d~ > u u~ s s~ g"),
+        model,
+    )
+
+    assert dag.lc_topology_replay is None
+    expected_sectors = {int(sector.id) for sector in dag.color_plan.sectors}
+    assert len(expected_sectors) > 1
+
+    current_domains, root_domains = _lc_materialized_sector_memberships(dag)
+
+    assert {domain for domains in root_domains.values() for domain in domains} == (
+        expected_sectors
+    )
+    assert set(root_domains) == {root.id for root in dag.amplitude_roots}
+    assert set(dag.sources).issubset(current_domains)
+    assert all(
+        root.left_id in current_domains and root.right_id in current_domains
+        for root in dag.amplitude_roots
+    )
+    assert any(len(domains) == 1 for domains in current_domains.values())
+    assert any(len(domains) > 1 for domains in current_domains.values())
+
+
+def test_eager_complete_lc_generation_materializes_replay_representative() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > z g g")
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            evaluator=EvaluatorConfig(execution_mode="eager"),
+        ),
+        None,
+    )
+
+    dag, coverage = backend._compile_concrete_process(process, model)
+
+    replay = dag.lc_topology_replay
+    assert replay is not None
+    assert replay.physical_sector_ids == (0, 1)
+    assert replay.materialized_sector_ids == (0,)
+    assert replay.residual_sector_ids == ()
+    assert {int(root.color_sector_id or 0) for root in dag.amplitude_roots} == {0}
+    assert tuple(sector.id for sector in dag.color_plan.sectors) == (0, 1)
+    assert dag.color_coverage == "complete"
+    assert dag.helicity_coverage == "complete"
+    assert coverage["materialized_color_sector_count"] == 1
+
+
+@pytest.mark.parametrize(
+    "selection",
+    (
+        _ProcessSelection(selected_color_sector_ids=frozenset({1})),
+        _ProcessSelection(
+            selected_source_helicities={1: -1, 2: 1, 3: -1, 4: 1, 5: -1},
+        ),
+    ),
+    ids=("selected-color", "selected-helicity"),
+)
+def test_eager_selected_generation_axis_does_not_enable_replay(
+    selection: _ProcessSelection,
+) -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > z g g")
+    backend = GenerationBackend(
+        RunConfig(
+            action="generate",
+            evaluator=EvaluatorConfig(execution_mode="eager"),
+        ),
+        None,
+        process_selection=selection,
+    )
+
+    dag, coverage = backend._compile_concrete_process(process, model)
+    schema = build_runtime_expression_schema(dag, model).to_mapping()
+
+    assert dag.lc_topology_replay is None
+    assert "lc_topology_replay" not in dag.to_json_dict()
+    assert "lc_topology_replay" not in schema
+    assert "materialized_color_sector_count" not in coverage
+
+
+def test_specialized_lc_generation_retains_existing_schema() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > z g g")
+    backend = GenerationBackend(
+        None,
+        None,
+        process_selection=_ProcessSelection(
+            selected_color_sector_ids=frozenset({1})
+        ),
+    )
+
+    dag, coverage = backend._compile_concrete_process(process, model)
+    schema = build_runtime_expression_schema(dag, model).to_mapping()
+
+    assert tuple(sector.id for sector in dag.color_plan.sectors) == (1,)
+    assert dag.color_coverage == "selected"
+    assert dag.lc_topology_replay is None
+    assert _lc_materialized_sector_memberships(dag) == ({}, {})
+    assert "lc_topology_replay" not in dag.to_json_dict()
+    assert "lc_topology_replay" not in schema
+    assert "lc_topology_replay" not in schema["physics"]["extensions"]
+    assert "materialized_color_sector_count" not in coverage
+    assert "replayed_color_sector_count" not in coverage
+    assert "residual_color_sector_count" not in coverage
+
+
+@pytest.mark.parametrize("model_source", ("builtin", "ufo-sm"))
+def test_reversed_selected_flow_retains_exchange_signed_three_gluon_currents(
+    model_source: str,
+) -> None:
+    if model_source == "builtin":
+        model = BuiltinSMModel()
+        process = build_process_ir("d d~ > z g g")
+    else:
+        compiled = compile_model_source(
+            _UFO_SM_ROOT / "sm.json",
+            restriction=str((_UFO_SM_ROOT / "restrict_default.json").resolve()),
+            use_cache=True,
+        )
+        model = CompiledUFOModel(compiled)
+        process = build_model_process_ir("d d~ > z g g", compiled.ir)
+
+    color_plan = build_color_plan(process)
+    direct = compile_generic_dag(
+        process,
+        model=model,
+        color_plan=color_plan,
+        selected_color_sector_ids=(0,),
+    )
+    reversed_flow = compile_generic_dag(
+        process,
+        model=model,
+        color_plan=color_plan,
+        selected_color_sector_ids=(1,),
+    )
+
+    def three_gluon_terms(dag: GenericDAG) -> tuple[InteractionNode, ...]:
+        return tuple(
+            interaction
+            for interaction in dag.interactions
+            if tuple(abs(pdg) for pdg in interaction.vertex_particles)
+            == (21, 21, 21)
+            and model.vertex_evaluation_equivalence(
+                interaction.vertex_kind
+            ).input_exchange_factor
+            == (-1.0, 0.0)
+        )
+
+    direct_terms = three_gluon_terms(direct)
+    reversed_terms = three_gluon_terms(reversed_flow)
+    assert len(direct_terms) == len(reversed_terms) == 4
+    direct_weights = {term.color_weight for term in direct_terms}
+    assert {term.color_weight for term in reversed_terms} == {
+        (-real, -imaginary) for real, imaginary in direct_weights
+    }
+    assert {
+        reversed_flow.currents[term.result_id].index.ordered_external_labels
+        for term in reversed_terms
+    } == {(5, 4)}
+    assert len(direct.currents) == len(reversed_flow.currents)
+    assert len(direct.interactions) == len(reversed_flow.interactions)
+    assert len(direct.amplitude_roots) == len(reversed_flow.amplitude_roots)
+
+
+def test_fixed_helicity_complete_color_generation_retains_existing_schema() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > z g g")
+    backend = GenerationBackend(
+        None,
+        None,
+        process_selection=_ProcessSelection(
+            selected_source_helicities={1: -1, 2: 1, 3: -1, 4: 1, 5: -1},
+        ),
+    )
+
+    dag, coverage = backend._compile_concrete_process(process, model)
+    schema = build_runtime_expression_schema(dag, model).to_mapping()
+
+    assert dag.color_coverage == "complete"
+    assert dag.helicity_coverage == "selected"
+    assert dag.lc_topology_replay is None
+    assert "lc_topology_replay" not in dag.to_json_dict()
+    assert "lc_topology_replay" not in schema
+    assert "materialized_color_sector_count" not in coverage
+
+
+def test_ufo_sm_replay_proof_uses_compiled_canonical_contracts() -> None:
+    compiled = compile_model_source(
+        _UFO_SM_ROOT / "sm.json",
+        restriction=str((_UFO_SM_ROOT / "restrict_default.json").resolve()),
+        use_cache=True,
+    )
+    model = CompiledUFOModel(compiled)
+    process = build_model_process_ir("d d~ > z g g", compiled.ir)
+
+    replay = build_lc_topology_replay_plan(build_color_plan(process), model)
+
+    assert replay is not None
+    assert replay.materialized_sector_ids == (0,)
+    assert replay.residual_sector_ids == ()
+    proof = replay.partitions[0]
+    assert proof.proof_algorithm == (
+        "canonical-model-contract-label-equivariance-v1"
+    )
+    assert proof.proof_digest is not None
+
+
+def test_failed_replay_partition_does_not_disable_other_proven_groups(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("g g > g g g")
+    color_plan = build_color_plan(
+        process,
+        fold_trace_reflections=model.lc_trace_reflection_equivalence_is_proven(
+            process
+        ),
+    )
+    candidates = tuple(
+        partition
+        for partition in replay_module.lc_topology_replay_partitions(color_plan)
+        if len(partition.active_sector_ids) > 1
+    )
+    assert len(candidates) > 1
+    failed_partition = candidates[1]
+    original = replay_module._prove_lc_topology_replay_partition
+
+    def fail_one_partition(
+        plan: object,
+        partition: object,
+        proof_model: object,
+        *,
+        model_contract_digest: str,
+    ) -> object:
+        if (
+            partition.representative_sector_id  # type: ignore[attr-defined]
+            == failed_partition.representative_sector_id
+        ):
+            return None
+        return original(
+            plan,  # type: ignore[arg-type]
+            partition,  # type: ignore[arg-type]
+            proof_model,  # type: ignore[arg-type]
+            model_contract_digest=model_contract_digest,
+        )
+
+    monkeypatch.setattr(
+        replay_module,
+        "_prove_lc_topology_replay_partition",
+        fail_one_partition,
+    )
+
+    dag, coverage = GenerationBackend(None, None)._compile_concrete_process(
+        process,
+        model,
+    )
+    replay = dag.lc_topology_replay
+
+    assert replay is not None
+    assert replay.partitions
+    assert all(
+        part.representative_sector_id
+        != failed_partition.representative_sector_id
+        for part in replay.partitions
+    )
+    assert set(failed_partition.active_sector_ids).issubset(
+        replay.residual_sector_ids
+    )
+    assert set(replay.physical_sector_ids) == (
+        {
+            sector_id
+            for partition in replay.partitions
+            for sector_id in partition.active_sector_ids
+        }
+        | set(replay.residual_sector_ids)
+    )
+    assert {
+        int(root.color_sector_id)
+        for root in dag.amplitude_roots
+        if root.color_sector_id is not None
+    } == set(replay.materialized_sector_ids)
+    assert coverage["materialized_color_sector_count"] == len(
+        replay.materialized_sector_ids
+    )
+    assert coverage["residual_color_sector_count"] == len(
+        replay.residual_sector_ids
+    )
+
+
+def test_execution_manifest_carries_additive_replay_contract(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model = BuiltinSMModel()
+    process_ir = build_process_ir("d d~ > z g g")
+    dag, _coverage = GenerationBackend(None, None)._compile_concrete_process(
+        process_ir,
+        model,
+    )
+    schema = build_runtime_expression_schema(dag, model)
+    validation = ValidationPointRecord(
+        process_id=process_ir.key,
+        process=process_ir.process,
+        seed=1,
+        particles=tuple(
+            (int(leg.pdg or 0), (1.0, 0.0, 0.0, 0.0))
+            for leg in process_ir.legs
+        ),
+    )
+    artifact = CompiledProcessArtifact(
+        process_id=process_ir.key,
+        expression=process_ir.process,
+        color_accuracy="lc",
+        external_pdgs=(*process_ir.initial_pdgs, *process_ir.final_pdgs),
+        aliases=(),
+        runtime_schema=schema,
+        stage_manifest={},
+        model_parameter_evaluator=None,
+        dag_summary={
+            "current_count": len(dag.currents),
+            "source_count": len(dag.sources),
+            "interaction_count": len(dag.interactions),
+            "interaction_evaluation_count": dag.interaction_evaluation_count,
+            "amplitude_root_count": len(dag.amplitude_roots),
+            "truncated": dag.truncated,
+        },
+        evaluator_root=Path("."),
+        validation_point=validation,
+        generation_filters={},
+    )
+    monkeypatch.setattr(
+        artifact_writer_module,
+        "_stage_evaluator_set",
+        lambda _manifest: {"required_runtime_capabilities": []},
+    )
+
+    manifest = artifact_writer_module._execution_manifest(
+        artifact,
+        schema.to_mapping(),
+    )
+
+    replay = manifest["compiled"]["lc_topology_replay"]
+    assert replay["enabled"] is True
+    assert replay["contract_version"] == 2
+    assert replay["materialized_sector_ids"] == [0]
+    assert replay["residual_sector_ids"] == []
+
+
+def test_structural_helicity_reduction_preserves_lc_replay_contract() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > z g g")
+    dag, _coverage = GenerationBackend(None, None)._compile_concrete_process(
+        process,
+        model,
+    )
+    replay = dag.lc_topology_replay
+    assert replay is not None
+
+    reduced = prune_global_helicity_flip_equivalent_roots(dag, model)
+
+    assert reduced.lc_topology_replay == replay
+    schema = build_runtime_expression_schema(reduced, model).to_mapping()
+    assert schema["lc_topology_replay"]["contract_version"] == 2
diff --git a/pyamplicol/tests/unit/test_legacy_amplicol_oracle.py b/pyamplicol/tests/unit/test_legacy_amplicol_oracle.py
new file mode 100644
index 0000000000..d0248f0c6a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_legacy_amplicol_oracle.py
@@ -0,0 +1,1668 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+import hashlib
+import importlib
+import importlib.util
+import json
+import struct
+import subprocess
+import sys
+import tomllib
+from decimal import Decimal
+from itertools import product
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools" / "developer" / "legacy_amplicol.py"
+REPORT = ROOT / "tests" / "fixtures" / "reference" / "legacy-fortran-v1.json"
+PHYSICS = ROOT / "tests" / "fixtures" / "reference" / "physics-v1.json"
+_ACTIVE_HELICITY = (-1, 1, -1, -1, 1)
+
+
+def _module():
+    spec = importlib.util.spec_from_file_location("legacy_amplicol_oracle", SCRIPT)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_direct_path_import_works_in_an_isolated_interpreter(tmp_path: Path) -> None:
+    source = "\n".join(
+        (
+            "import importlib.util, json, pathlib, sys",
+            f"path = pathlib.Path({str(SCRIPT)!r})",
+            "spec = importlib.util.spec_from_file_location('isolated_legacy', path)",
+            "module = importlib.util.module_from_spec(spec)",
+            "sys.modules[spec.name] = module",
+            "spec.loader.exec_module(module)",
+            "print(json.dumps([str(module.ROOT), module.ProcessEntry.__name__]))",
+        )
+    )
+
+    completed = subprocess.run(
+        [sys.executable, "-I", "-c", source],
+        cwd=tmp_path,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert completed.returncode == 0, completed.stderr
+    assert json.loads(completed.stdout) == [str(ROOT), "ProcessEntry"]
+    assert completed.stderr == ""
+
+
+def test_facade_reexports_extracted_oracle_helpers() -> None:
+    module = _module()
+    package = module._ORACLE_PACKAGE
+    model = importlib.import_module(f"{package}.model")
+    processes = importlib.import_module(f"{package}.processes")
+    probe = importlib.import_module(f"{package}.probe")
+    evidence = importlib.import_module(f"{package}.evidence")
+
+    assert module.ROOT == model.ROOT == ROOT
+    assert module.LegacyOracleError is model.LegacyOracleError
+    assert module.ProcessEntry is model.ProcessEntry
+    assert module.LcRowPartition is model.LcRowPartition
+    assert module.CompilerProvenance is model.CompilerProvenance
+    assert module.ProbeResult is model.ProbeResult
+    assert module.SelectedFlowProbeResult is model.SelectedFlowProbeResult
+    assert module.parse_process_file is processes.parse_process_file
+    assert module.select_process_entry is processes.select_process_entry
+    assert (
+        module.select_generated_process_entry
+        is processes.select_generated_process_entry
+    )
+    assert module.source_mapped_color_order is processes.source_mapped_color_order
+    assert (
+        module.validate_selected_flow_quark_line_scope
+        is processes.validate_selected_flow_quark_line_scope
+    )
+    assert (
+        module.validate_direct_color_probe_quark_line_scope
+        is processes.validate_direct_color_probe_quark_line_scope
+    )
+    assert module._permutation is processes._permutation
+    assert module._parse_probe_output is probe._parse_probe_output
+    assert (
+        module._parse_selected_flow_probe_output
+        is probe._parse_selected_flow_probe_output
+    )
+    assert module._binary64_input_sha256 is probe._binary64_input_sha256
+    assert module._resolved_single_lc_row is probe._resolved_single_lc_row
+    assert module._reference_fixture_v2_module is evidence._reference_fixture_v2_module
+    assert module._semantic_replay_command is evidence._semantic_replay_command
+
+
+def test_fortran_physics_fixture_is_not_bound_to_checkout_revision() -> None:
+    module = _module()
+    fixture = {
+        "dependencies": [
+            {
+                "id": "dependency:legacy-amplicol",
+                "name": "Pinned legacy Fortran AmpliCol",
+                "revision": "historical-reference-revision",
+            }
+        ]
+    }
+
+    assert module._fortran_dependency_ids(fixture) == (
+        "dependency:legacy-amplicol",
+    )
+
+
+def test_direct_script_cli_preserves_help_and_error_exit_codes(
+    tmp_path: Path,
+) -> None:
+    help_result = subprocess.run(
+        [sys.executable, "-I", str(SCRIPT), "--help"],
+        cwd=tmp_path,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    invalid_result = subprocess.run(
+        [sys.executable, "-I", str(SCRIPT), "--jobs", "not-an-integer"],
+        cwd=tmp_path,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    missing_checkout_result = subprocess.run(
+        [
+            sys.executable,
+            "-I",
+            str(SCRIPT),
+            "--repository",
+            str(tmp_path / "missing-checkout"),
+            "--no-build",
+        ],
+        cwd=tmp_path,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert help_result.returncode == 0
+    assert help_result.stdout.startswith("usage: legacy_amplicol.py")
+    assert help_result.stderr == ""
+    assert invalid_result.returncode == 2
+    assert invalid_result.stdout == ""
+    assert "invalid int value: 'not-an-integer'" in invalid_result.stderr
+    assert missing_checkout_result.returncode == 2
+    assert missing_checkout_result.stdout == ""
+    assert missing_checkout_result.stderr.startswith(
+        "error: legacy AmpliCol checkout is absent:"
+    )
+    assert "Traceback" not in missing_checkout_result.stderr
+
+
+def _sha(label: str) -> str:
+    return hashlib.sha256(label.encode("ascii")).hexdigest()
+
+
+def _refresh_evidence_record_hash(module: Any, record: dict[str, Any]) -> None:
+    reference = module._reference_fixture_v2_module()
+    record["evidence_record_sha256"] = reference.evidence_record_sha256(record)
+
+
+def _git(repository: Path, *arguments: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *arguments],
+        cwd=repository,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _v2_fixture(revision: str) -> dict[str, Any]:
+    points = []
+    for index, point_class in enumerate(("generic", "generic", "generic", "stress")):
+        generic_final_states = (
+            (
+                ["250", "250", "0", "0"],
+                ["375", "-125", "353.5533905932738", "0"],
+                ["375", "-125", "-353.5533905932738", "0"],
+            ),
+            (
+                ["250", "0", "250", "0"],
+                ["375", "0", "-125", "353.5533905932738"],
+                ["375", "0", "-125", "-353.5533905932738"],
+            ),
+            (
+                ["250", "0", "0", "250"],
+                ["375", "353.5533905932738", "0", "-125"],
+                ["375", "-353.5533905932738", "0", "-125"],
+            ),
+        )
+        final_states = (
+            (
+                ["499.999", "0", "0", "499.999"],
+                ["500", "0", "0", "-500"],
+                ["0.001", "0", "0", "0.001"],
+            )
+            if point_class == "stress"
+            else generic_final_states[index]
+        )
+        points.append(
+            {
+                "id": f"point:{point_class}-{index}",
+                "process_id": "process:dd-zgg",
+                "class": point_class,
+                "algorithm": {
+                    "name": "deterministic-test-point",
+                    "version": "1",
+                    "rng": "PCG64" if point_class == "generic" else None,
+                    "seed": index if point_class == "generic" else None,
+                },
+                "sqrt_s": "1000",
+                "momenta": [
+                    ["500", "0", "0", "500"],
+                    ["500", "0", "0", "-500"],
+                    *final_states,
+                ],
+                "masses": ["0", "0", "0", "0", "0"],
+                "arithmetic_precision_bits": 53,
+                "round_trip_decimal_digits": 17,
+                "certified_decimal_digits": 12,
+                "stress_metric": (
+                    {
+                        "kind": "minimum-final-energy-fraction",
+                        "value": "0.000001",
+                    }
+                    if point_class == "stress"
+                    else None
+                ),
+            }
+        )
+
+    domains = ((-1, 1), (-1, 1), (-1, 1), (-1, 1), (-1, 1))
+    helicities = []
+    for index, values in enumerate(product(*domains)):
+        identifier = "h:" + ",".join(f"{value:+d}" for value in values)
+        active = values == _ACTIVE_HELICITY
+        helicities.append(
+            {
+                "id": identifier,
+                "index": index,
+                "values": list(values),
+                "computed": active,
+                "structural_zero": not active,
+                "representative_id": identifier,
+                "coefficient": "1" if active else "0",
+            }
+        )
+    lc_colors = [
+        {
+            "kind": "lc-flow",
+            "id": "flow:2,4,5,1",
+            "index": 0,
+            "word": [2, 4, 5, 1],
+            "computed": True,
+            "representative_id": "flow:2,4,5,1",
+            "coefficient": "1",
+        },
+        {
+            "kind": "lc-flow",
+            "id": "flow:2,5,4,1",
+            "index": 1,
+            "word": [2, 5, 4, 1],
+            "computed": True,
+            "representative_id": "flow:2,5,4,1",
+            "coefficient": "1",
+        },
+    ]
+    contracted_color = [
+        {
+            "kind": "contracted-color",
+            "id": "color:contracted",
+            "index": 0,
+            "description": "fully contracted color",
+        }
+    ]
+    normalization = {
+        "average_factor": "36",
+        "color_factor": "27",
+        "identical_factor": "2",
+        "global_coupling_factor": "1",
+        "quark_line_partner_factor": "1",
+        "couplings_in_stage_evaluators": True,
+    }
+
+    def case(color_accuracy: str, total: str) -> dict[str, Any]:
+        case_id = f"case:dd-zgg-{color_accuracy}"
+        lc = color_accuracy == "lc"
+        active_helicity_id = "h:" + ",".join(
+            f"{value:+d}" for value in _ACTIVE_HELICITY
+        )
+        reduction_colors = (
+            ("flow:2,4,5,1", "flow:2,5,4,1") if lc else ("color:contracted",)
+        )
+        values = [
+            (["1.25", "0.75"] if lc else [total])
+            if tuple(helicity["values"]) == _ACTIVE_HELICITY
+            else (["0", "0"] if lc else ["0"])
+            for helicity in helicities
+        ]
+        return {
+            "id": case_id,
+            "case_kind": "substantive",
+            "model_id": "model:builtin-sm",
+            "process_id": "process:dd-zgg",
+            "color_accuracy": color_accuracy,
+            "point_policy": "standard",
+            "point_ids": [point["id"] for point in points],
+            "coverage": {
+                "helicities": "complete",
+                "color": "complete" if lc else "contracted",
+                "color_kind": "physical-lc-flows" if lc else "contracted-color",
+                "helicity_count": len(helicities),
+                "color_component_count": 2 if lc else 1,
+                "structural_zero_helicity_count": len(helicities) - 1,
+            },
+            "selectors": {
+                "helicity": True,
+                "color_flow": lc,
+                "omitted_helicity": "all-components",
+                "omitted_color": "all-components" if lc else "contracted-component",
+            },
+            "normalization": normalization,
+            "topology": {
+                "currents": 17,
+                "interactions": 31,
+                "roots": 4,
+                "reduction_groups": len(reduction_colors),
+            },
+            "artifact_physics_sha256": _sha(f"physics:{case_id}"),
+            "artifact_execution_sha256": _sha(f"execution:{case_id}"),
+            "physics_case_sha256": "0" * 64,
+            "axes": {
+                "helicities": helicities,
+                "colors": lc_colors if lc else contracted_color,
+            },
+            "reduction": {
+                "kind": "lc-diagonal" if lc else "contracted-color",
+                "cell_semantics": (
+                    "sum-all-contributing-groups" if lc else "fully-contracted-color"
+                ),
+                "groups": [
+                    {
+                        "id": f"reduction:{index}",
+                        "representative_helicity_id": active_helicity_id,
+                        "representative_color_id": color_id,
+                        "physical_helicity_ids": [active_helicity_id],
+                        "physical_color_ids": [color_id],
+                    }
+                    for index, color_id in enumerate(reduction_colors)
+                ],
+                "plan_sha256": "0" * 64,
+            },
+            "observations": [
+                {
+                    "point_id": point["id"],
+                    "arithmetic_precision_bits": 53,
+                    "round_trip_decimal_digits": 17,
+                    "certified_decimal_digits": 10,
+                    "values": values,
+                    "total": total,
+                    "evidence_refs": [f"evidence:fortran:{case_id}:{point['id']}"],
+                }
+                for point in points
+            ],
+        }
+
+    return {
+        "fixture_schema_version": 2,
+        "kind": "pyamplicol-reference-physics",
+        "fixture_id": "fixture:fortran-v2-test",
+        "provenance": {
+            "source_repository": "https://github.com/mg5amcnlo/pyamplicol",
+            "source_revision": "1" * 40,
+            "source_tree_sha256": _sha("source-tree"),
+            "captured_at": "2026-07-16T12:00:00Z",
+            "capture_command": ["pyamplicol", "capture-reference"],
+            "working_tree_clean": True,
+            "memory_watchdog_gb": 30,
+        },
+        "dependencies": [
+            {
+                "id": "dependency:legacy-amplicol",
+                "name": "legacy Fortran AmpliCol",
+                "version": "pinned-git",
+                "revision": revision,
+                "content_sha256": _sha("legacy-amplicol"),
+                "serialization_abi": None,
+                "license": "GPL-3.0-or-later",
+            }
+        ],
+        "models": [
+            {
+                "id": "model:builtin-sm",
+                "name": "built-in-sm",
+                "source_kind": "built-in-sm",
+                "content_sha256": _sha("model"),
+                "compiled_model_sha256": _sha("compiled-model"),
+                "compiled_schema_version": 6,
+                "restriction": None,
+                "dependency_ids": [],
+                "parameter_defaults": {},
+            }
+        ],
+        "processes": [
+            {
+                "id": "process:dd-zgg",
+                "expression": "d d~ > z g g",
+                "external_pdgs": [1, -1, 23, 21, 21],
+                "external_labels": [1, 2, 3, 4, 5],
+                "external_leg_ids": [
+                    "leg:incoming-d",
+                    "leg:incoming-dbar",
+                    "leg:outgoing-z",
+                    "leg:outgoing-g-1",
+                    "leg:outgoing-g-2",
+                ],
+                "external_spins": [2, 2, 3, 3, 3],
+                "external_colors": [3, -3, 1, 8, 8],
+                "external_masses": ["0", "0", "0", "0", "0"],
+                "external_helicity_domains": [list(domain) for domain in domains],
+                "initial_state_count": 2,
+                "alias_of": None,
+                "final_state_permutation": None,
+            }
+        ],
+        "points": points,
+        "cases": [case("lc", "2"), case("nlc", "1.5"), case("full", "1.4")],
+        "evidence_sets": ["oracle:legacy-fortran-amplicol"],
+    }
+
+
+def test_process_file_parser_preserves_fortran_external_order(tmp_path: Path) -> None:
+    module = _module()
+    process_file = tmp_path / "processes.txt"
+    process_file.write_text(
+        """4 1
+1 -1 21 23
+
+
+1
+
+1   1   1   1 4 2 3
+1   1   1 -1 21 23   2 3 1 4   1.0
+""",
+        encoding="utf-8",
+    )
+
+    entries = module.parse_process_file(process_file)
+
+    assert entries == (
+        module.ProcessEntry(
+            group=1,
+            integral=1,
+            process_pdgs=(1, -1, 21, 23),
+            color_order=(2, 3, 1, 4),
+        ),
+    )
+    assert module.select_process_entry(entries, "d d~ > z g") == entries[0]
+    assert module._permutation((1, -1, 23, 21), entries[0].process_pdgs) == (
+        0,
+        1,
+        3,
+        2,
+    )
+
+
+def test_pinned_branch_checkout_rejects_tracked_edits_but_allows_build_outputs(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    tracked = repository / "tracked.txt"
+    tracked.write_text("base\n", encoding="utf-8")
+    _git(repository, "init")
+    _git(repository, "config", "user.name", "Fixture Author")
+    _git(repository, "config", "user.email", "fixture@example.invalid")
+    _git(repository, "add", "tracked.txt")
+    _git(repository, "commit", "-m", "base")
+    revision = _git(repository, "rev-parse", "HEAD").stdout.strip()
+    monkeypatch.setattr(module, "expected_revision", lambda: revision)
+
+    module.validate_checkout(repository)
+
+    (repository / "amplicol_color_probe").write_text("build output\n", encoding="utf-8")
+    module.validate_checkout(repository)
+
+    tracked.write_text("unexpected edit\n", encoding="utf-8")
+    with pytest.raises(module.LegacyOracleError, match="contains tracked edits"):
+        module.validate_checkout(repository)
+
+
+def test_process_selection_requires_the_declared_fortran_row() -> None:
+    module = _module()
+    entries = (
+        module.ProcessEntry(1, 1, (1, -1, 21, 23), (1, 2, 3, 4)),
+        module.ProcessEntry(2, 1, (1, -1, 23, 21), (1, 2, 4, 3)),
+    )
+
+    with pytest.raises(module.LegacyOracleError, match="expected declared row"):
+        module.select_process_entry(entries[:1], "d d~ > z g")
+
+    entries = (
+        module.expected_process_entry("d d~ > z g"),
+        entries[1],
+    )
+    assert module.select_process_entry(entries, "d d~ > z g") == entries[0]
+    assert module.matching_process_entries(entries, "d d~ > z g") == (
+        entries[1],
+        entries[0],
+    )
+
+
+def test_process_selection_rejects_ambiguous_pdg_rows() -> None:
+    module = _module()
+    expected = module.expected_process_entry("d d~ > z g")
+
+    with pytest.raises(module.LegacyOracleError, match="ambiguous duplicate"):
+        module.select_process_entry((expected, expected), "d d~ > z g")
+
+    candidates = (
+        module.ProcessEntry(7, 1, expected.process_pdgs, expected.color_order),
+        module.ProcessEntry(8, 1, expected.process_pdgs, expected.color_order),
+    )
+    with pytest.raises(module.LegacyOracleError, match="ambiguous PDG-only"):
+        module.select_process_entry(candidates, "d d~ > z g")
+
+
+@pytest.mark.parametrize(
+    ("process", "row_pdgs", "raw_color_order"),
+    (
+        ("u d~ > w+ g", (2, -1, 21, 24), (2, 3, 1, 4)),
+        ("u d~ > e+ ve", (2, -1, -11, 12), (2, 1, 3, 4)),
+        (
+            "d d~ > z g g g",
+            (1, -1, 21, 21, 21, 23),
+            (2, 3, 4, 5, 1, 6),
+        ),
+        ("d d~ > z z", (1, -1, 23, 23), (2, 1, 3, 4)),
+        ("d d~ > z z z", (1, -1, 23, 23, 23), (2, 1, 3, 4, 5)),
+        ("d d~ > e+ e-", (1, -1, -11, 11), (2, 1, 3, 4)),
+        ("d d~ > t t~", (1, -1, 6, -6), (3, 1, 2, 4)),
+        (
+            "d d~ > t t~ z h",
+            (1, -1, 6, -6, 23, 25),
+            (3, 1, 2, 4, 5, 6),
+        ),
+        ("g g > g g g", (21, 21, 21, 21, 21), (1, 2, 3, 4, 5)),
+        ("g g > t t~ g", (21, 21, 21, 6, -6), (4, 1, 2, 3, 5)),
+    ),
+)
+def test_generated_process_selection_covers_matrix_reference_families(
+    process: str,
+    row_pdgs: tuple[int, ...],
+    raw_color_order: tuple[int, ...],
+) -> None:
+    module = _module()
+    row = module.ProcessEntry(7, 3, row_pdgs, raw_color_order)
+    wanted = module.process_pdgs(process)
+
+    selected, matches = module.select_generated_process_entry(
+        (row,),
+        generated_process=process,
+        wanted_pdgs=wanted,
+    )
+
+    assert selected == row
+    assert matches == (row,)
+    mapped = module.source_mapped_color_order(row, source_pdgs=wanted)
+    assert sorted(mapped) == list(range(1, len(wanted) + 1))
+
+
+def test_generated_process_selection_prefers_exact_external_order() -> None:
+    module = _module()
+    reordered = module.ProcessEntry(1, 1, (1, -1, -6, 6), (4, 1, 2, 3))
+    exact = module.ProcessEntry(2, 1, (1, -1, 6, -6), (3, 1, 2, 4))
+
+    selected, matches = module.select_generated_process_entry(
+        (reordered, exact),
+        generated_process="d d~ > t t~",
+        wanted_pdgs=(1, -1, 6, -6),
+    )
+
+    assert selected == exact
+    assert matches == (exact, reordered)
+    assert (
+        module.GENERATED_PROCESS_ROW_SELECTION_POLICY
+        == "exact-external-pdg-order-then-process-file-order-v1"
+    )
+
+
+def test_source_mapped_color_order_preserves_raw_fortran_order_separately() -> None:
+    module = _module()
+    row = module.ProcessEntry(
+        1,
+        1,
+        (2, -1, 21, 24),
+        (2, 3, 1, 4),
+    )
+
+    mapped = module.source_mapped_color_order(
+        row,
+        source_pdgs=(2, -1, 24, 21),
+    )
+
+    assert row.color_order == (2, 3, 1, 4)
+    assert mapped == (2, 4, 1, 3)
+
+
+def test_source_mapped_color_order_rejects_invalid_fortran_positions() -> None:
+    module = _module()
+    row = module.ProcessEntry(1, 1, (1, -1, 23), (2, 1, 1))
+
+    with pytest.raises(module.LegacyOracleError, match="must be a permutation"):
+        module.source_mapped_color_order(row, source_pdgs=(1, -1, 23))
+
+
+def test_process_contract_pins_row_and_color_order_multiplicities() -> None:
+    module = _module()
+
+    assert module.expected_process_match_count("d d~ > z g g") == 1
+    assert module.expected_color_order_count("d d~ > z g g") == 2
+    assert module.expected_process_match_count("g g > g g") == 3
+    assert module.expected_color_order_count("g g > g g") == 6
+    assert module.expected_process_match_count("d d~ > d d~") == 2
+    assert module.expected_color_order_count("d d~ > d d~") == 2
+
+
+def test_oracle_rejects_processes_beyond_two_quark_lines() -> None:
+    module = _module()
+
+    assert (
+        module._validate_supported_quark_line_scope(
+            (1, -1, 2, -2),
+            context="two-line fixture",
+        )
+        == 2
+    )
+    with pytest.raises(module.LegacyOracleError, match="3 quark lines exceed"):
+        module._validate_supported_quark_line_scope(
+            (1, -1, 2, -2, 3, -3),
+            context="three-line fixture",
+        )
+
+
+def test_selected_flow_scope_does_not_inherit_the_all_flow_line_cap() -> None:
+    module = _module()
+    pdgs = (1, -1, 2, -2, 3, -3)
+    row = module.ProcessEntry(1, 1, pdgs, (1, 2, 3, 4, 5, 6))
+
+    assert (
+        module.validate_selected_flow_quark_line_scope(
+            pdgs,
+            context="three-line selected-flow campaign",
+        )
+        == 3
+    )
+    selected, matches = module.select_generated_process_entry(
+        (row,),
+        generated_process="d d~ > u u~ s s~",
+        wanted_pdgs=pdgs,
+    )
+    assert selected == row
+    assert matches == (row,)
+
+    with pytest.raises(module.LegacyOracleError, match="3 quark lines exceed"):
+        module._validate_supported_quark_line_scope(
+            pdgs,
+            context="three-line all-flow fixture",
+        )
+
+
+def test_direct_color_probe_supports_three_but_not_four_quark_lines() -> None:
+    module = _module()
+
+    assert (
+        module.validate_direct_color_probe_quark_line_scope(
+            (1, -1, 2, -2, 3, -3),
+            color_accuracy="full",
+            context="three-line direct probe",
+        )
+        == 3
+    )
+    with pytest.raises(module.LegacyOracleError, match="4 quark lines exceed"):
+        module.validate_direct_color_probe_quark_line_scope(
+            (1, -1, 2, -2, 3, -3, 4, -4),
+            color_accuracy="lc",
+            context="four-line direct probe",
+        )
+    assert (
+        module.validate_direct_color_probe_quark_line_scope(
+            (1, -1, 2, -2, 3, -3, 21, 21, 21, 21, 21),
+            color_accuracy="lc",
+            context="large leading-colour three-line direct probe",
+        )
+        == 3
+    )
+    with pytest.raises(module.LegacyOracleError, match=r"15120.*color flows exceed"):
+        module.validate_direct_color_probe_quark_line_scope(
+            (1, -1, 2, -2, 3, -3, 21, 21, 21, 21, 21),
+            color_accuracy="nlc",
+            context="oversized three-line direct probe",
+        )
+    with pytest.raises(module.LegacyOracleError, match="color singlets"):
+        module.validate_direct_color_probe_quark_line_scope(
+            (1, -1, 2, -2, 3, -3, 22),
+            color_accuracy="lc",
+            context="three-line photon probe",
+        )
+
+
+def test_public_legacy_checkout_uses_noninteractive_https() -> None:
+    module = _module()
+
+    assert module.checkout_url() == ("https://github.com/rikkert-frederix/AmpliCol.git")
+    assert module.checkout_branch() == "amplicol_with_patches"
+    assert module.expected_revision() == "dcb3efbcbe89c51969818cddf48113fba19ad763"
+
+
+def test_compiler_provenance_records_build_inputs_and_executable(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    executable = repository / "amplicol_color_probe"
+    executable.write_bytes(b"compiled probe")
+    commands: list[list[str]] = []
+
+    def fake_run(command, *, cwd, capture=True):
+        del cwd, capture
+        commands.append(command)
+        if command[0] == "make":
+            output = "FFLAGS = -ffast-math -O3\nFC = gfortran\n"
+        elif command[-1] == "--version":
+            output = "GNU Fortran (GCC) 14.2.0\nCopyright\n"
+        elif command[-1] == "-dumpmachine":
+            output = "aarch64-apple-darwin24\n"
+        else:
+            raise AssertionError(command)
+        return module.subprocess.CompletedProcess(command, 0, output, "")
+
+    class FakeShutil:
+        @staticmethod
+        def which(name: str) -> str:
+            return f"/toolchain/{name}"
+
+    monkeypatch.setattr(module, "_run", fake_run)
+    monkeypatch.setattr(module, "shutil", FakeShutil)
+
+    assert module._compiler_provenance(repository) == module.CompilerProvenance(
+        identity="gfortran",
+        version="GNU Fortran (GCC) 14.2.0",
+        flags=("-ffast-math", "-O3"),
+        target="aarch64-apple-darwin24",
+        executable_sha256=hashlib.sha256(b"compiled probe").hexdigest(),
+    )
+    assert commands[0] == [
+        "make",
+        "-f",
+        "makefile",
+        "PDF_BACKEND=internal",
+        "-pn",
+        "amplicol_color_probe",
+    ]
+
+
+def test_run_wrapper_uses_the_facade_subprocess_object(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    observed: dict[str, object] = {}
+
+    class FakeSubprocess:
+        @staticmethod
+        def run(command, **options):
+            observed.update(command=tuple(command), options=options)
+            return subprocess.CompletedProcess(command, 0, "ok\n", "")
+
+    monkeypatch.setattr(module, "subprocess", FakeSubprocess)
+
+    completed = module._run(["oracle", "--version"], cwd=tmp_path)
+
+    assert completed.stdout == "ok\n"
+    assert observed == {
+        "command": ("oracle", "--version"),
+        "options": {
+            "cwd": tmp_path,
+            "text": True,
+            "capture_output": True,
+        },
+    }
+
+
+def test_color_probe_runs_outside_the_legacy_checkout(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    process_file = tmp_path / "processes.txt"
+    process_file.write_text("fixture\n", encoding="utf-8")
+    observed: dict[str, object] = {}
+
+    def fake_run(command, *, cwd, capture=True):
+        observed.update(command=tuple(command), cwd=cwd, capture=capture)
+        output = """AMPICOL_COLOR_PROBE_CURRENTS 1
+AMPICOL_COLOR_PROBE_VERTICES 1
+AMPICOL_COLOR_PROBE_AMPLITUDES 1
+AMPICOL_COLOR_PROBE_COLOR_ORDERS 1
+AMPICOL_COLOR_PROBE_COMPONENTS 1.0 1.0 1.0
+AMPICOL_COLOR_PROBE_VALUE lc 1 1 1.0
+"""
+        return module.subprocess.CompletedProcess(command, 0, output, "")
+
+    monkeypatch.setattr(module, "_run", fake_run)
+    entry = module.ProcessEntry(1, 1, (1, -1, 23), (1, 2, 3))
+
+    result = module.run_color_probe(
+        repository,
+        process_file=process_file,
+        entry=entry,
+        source_pdgs=(1, -1, 23),
+        momenta=(
+            (50.0, 0.0, 0.0, 50.0),
+            (50.0, 0.0, 0.0, -50.0),
+            (100.0, 0.0, 0.0, 0.0),
+        ),
+        color_accuracy="lc",
+    )
+
+    assert result.value == 1.0
+    assert observed["cwd"] != repository
+    assert observed["command"][0] == str(
+        (repository / "amplicol_color_probe").resolve()
+    )
+
+
+def _selected_flow_probe_output(
+    *,
+    pdgs: tuple[int, ...] = (1, -1, 2, -2, 3, -3),
+    color_order: tuple[int, ...] = (2, 1, 3, 4, 5, 6),
+    helicities: tuple[int, ...] | None = None,
+) -> str:
+    lines = [
+        "AMPICOL_SELECTED_FLOW_PROBE_VALUE 3 1 6.3359823001718900E-10",
+        "AMPICOL_SELECTED_FLOW_PROBE_PDGS "
+        f"{len(pdgs)} {' '.join(str(value) for value in pdgs)}",
+        "AMPICOL_SELECTED_FLOW_PROBE_COLOR_ORDER "
+        f"{len(color_order)} {' '.join(str(value) for value in color_order)}",
+        "AMPICOL_SELECTED_FLOW_PROBE_AMPLITUDES 4",
+        "AMPICOL_SELECTED_FLOW_PROBE_COLOR_FACTOR 27",
+        "AMPICOL_SELECTED_FLOW_PROBE_IDENTICAL_FACTOR 36",
+        "AMPICOL_SELECTED_FLOW_PROBE_SINGLET_VERTICES 0",
+        "AMPICOL_SELECTED_FLOW_PROBE_NORMALIZATION 1.3425000000000000E-01",
+    ]
+    if helicities is not None:
+        lines.extend(
+            (
+                "AMPICOL_SELECTED_FLOW_PROBE_HELICITIES "
+                f"{len(helicities)} {' '.join(str(value) for value in helicities)}",
+                "AMPICOL_SELECTED_FLOW_PROBE_FIXED_HELICITY_VALUE "
+                "2.5000000000000000E+00",
+            )
+        )
+    return "\n".join(lines)
+
+
+def test_selected_flow_probe_parser_records_generated_row_metadata() -> None:
+    module = _module()
+
+    result = module._parse_selected_flow_probe_output(_selected_flow_probe_output())
+
+    assert result == module.SelectedFlowProbeResult(
+        value=6.33598230017189e-10,
+        group=3,
+        integral=1,
+        process_pdgs=(1, -1, 2, -2, 3, -3),
+        color_order=(2, 1, 3, 4, 5, 6),
+        amplitudes=4,
+        color_factor=27,
+        identical_factor=36,
+        singlet_vertices=0,
+        normalization=0.13425,
+        value_decimal=Decimal("6.3359823001718900E-10"),
+        normalization_decimal=Decimal("1.3425000000000000E-01"),
+    )
+
+
+def test_selected_flow_probe_parser_records_fixed_physical_helicity() -> None:
+    module = _module()
+    helicities = (-1, 1, -1, 1, -1, 1)
+
+    result = module._parse_selected_flow_probe_output(
+        _selected_flow_probe_output(helicities=helicities)
+    )
+
+    assert result.helicities == helicities
+    assert result.fixed_helicity_value == 2.5
+    assert result.fixed_helicity_value_decimal == Decimal("2.5000000000000000E+00")
+
+
+def test_selected_flow_library_probe_supports_three_quark_lines_and_indexed_rows(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    source_pdgs = (1, -1, 2, -2, 3, -3)
+    entry = module.ProcessEntry(
+        group=3,
+        integral=1,
+        process_pdgs=(1, -1, 2, -2, 3, -3),
+        color_order=(2, 1, 3, 4, 5, 6),
+    )
+    momenta = tuple(
+        (float(index), float(index + 1), float(index + 2), float(index + 3))
+        for index in range(0, 24, 4)
+    )
+    observed: dict[str, object] = {}
+
+    def fake_run(command, *, cwd, capture=True):
+        momentum_path = Path(command[4])
+        observed.update(
+            command=tuple(command),
+            cwd=cwd,
+            capture=capture,
+            momenta=momentum_path.read_text(encoding="utf-8"),
+        )
+        return module.subprocess.CompletedProcess(
+            command,
+            0,
+            _selected_flow_probe_output(helicities=(-1, 1, -1, 1, -1, 1)),
+            "",
+        )
+
+    monkeypatch.setattr(module, "_run", fake_run)
+
+    result = module.run_selected_flow_library_probe(
+        repository,
+        entry=entry,
+        source_pdgs=source_pdgs,
+        momenta=momenta,
+        helicities=(-1, 1, -1, 1, -1, 1),
+        points=7,
+    )
+
+    assert result.value == pytest.approx(6.33598230017189e-10)
+    assert result.process_pdgs == entry.process_pdgs
+    assert result.color_order == entry.color_order
+    assert observed["cwd"] == repository
+    assert observed["command"][1:4] == ("7", "3", "1")
+    assert observed["command"][5:] == ("-1", "1", "-1", "1", "-1", "1")
+    assert observed["momenta"] == "\n".join(
+        " ".join(format(component, ".17g") for component in vector)
+        for vector in momenta
+    ) + "\n"
+
+
+def test_selected_flow_library_probe_accepts_canonicalized_row_metadata(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    entry = module.ProcessEntry(
+        group=3,
+        integral=1,
+        process_pdgs=(1, -1, 2, -2, 3, -3),
+        color_order=(2, 1, 3, 4, 5, 6),
+    )
+
+    monkeypatch.setattr(
+        module,
+        "_run",
+        lambda command, *, cwd, capture=True: module.subprocess.CompletedProcess(
+            command,
+            0,
+            _selected_flow_probe_output(
+                pdgs=(2, -2, -3, 3, -1, 1),
+                color_order=(1, 3, 4, 5, 6, 2),
+            ),
+            "",
+        ),
+    )
+
+    result = module.run_selected_flow_library_probe(
+        repository,
+        entry=entry,
+        source_pdgs=entry.process_pdgs,
+        momenta=((1.0, 2.0, 3.0, 4.0),) * 6,
+    )
+
+    assert result.process_pdgs == (2, -2, -3, 3, -1, 1)
+    assert result.color_order == (1, 3, 4, 5, 6, 2)
+
+
+def test_selected_flow_library_probe_maps_source_helicity_to_generated_row(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    source_pdgs = (1, -1, 23, 21)
+    entry = module.ProcessEntry(
+        group=3,
+        integral=1,
+        process_pdgs=(1, -1, 21, 23),
+        color_order=(2, 3, 1, 4),
+    )
+    observed: dict[str, tuple[str, ...]] = {}
+
+    def fake_run(command, *, cwd, capture=True):
+        del cwd, capture
+        observed["command"] = tuple(command)
+        return module.subprocess.CompletedProcess(
+            command,
+            0,
+            _selected_flow_probe_output(
+                pdgs=entry.process_pdgs,
+                color_order=entry.color_order,
+                helicities=(-1, 1, -1, 0),
+            ),
+            "",
+        )
+
+    monkeypatch.setattr(module, "_run", fake_run)
+
+    result = module.run_selected_flow_library_probe(
+        repository,
+        entry=entry,
+        source_pdgs=source_pdgs,
+        momenta=((1.0, 2.0, 3.0, 4.0),) * 4,
+        helicities=(-1, 1, 0, -1),
+    )
+
+    assert result.helicities == (-1, 1, -1, 0)
+    assert observed["command"][5:] == ("-1", "1", "-1", "0")
+
+
+def test_selected_flow_library_probe_rejects_generated_pdg_mismatch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    entry = module.ProcessEntry(
+        group=3,
+        integral=1,
+        process_pdgs=(1, -1, 2, -2, 3, -3),
+        color_order=(2, 1, 3, 4, 5, 6),
+    )
+    monkeypatch.setattr(
+        module,
+        "_run",
+        lambda command, *, cwd, capture=True: module.subprocess.CompletedProcess(
+            command,
+            0,
+            _selected_flow_probe_output(pdgs=(1, -1, 2, -2, 4, -4)),
+            "",
+        ),
+    )
+
+    with pytest.raises(module.LegacyOracleError, match="PDG multiset"):
+        module.run_selected_flow_library_probe(
+            repository,
+            entry=entry,
+            source_pdgs=entry.process_pdgs,
+            momenta=((1.0, 2.0, 3.0, 4.0),) * 6,
+        )
+
+
+def test_binary64_input_hash_covers_exact_post_permutation_values() -> None:
+    module = _module()
+    source_pdgs = (1, -1, 23, 21)
+    target_pdgs = (1, -1, 21, 23)
+    momenta = (
+        (1.0, 2.0, 3.0, 4.0),
+        (5.0, 6.0, 7.0, 8.0),
+        (9.0, 10.0, 11.0, 12.0),
+        (13.0, 14.0, 15.0, 16.0),
+    )
+    transmitted = (*momenta[0], *momenta[1], *momenta[3], *momenta[2])
+
+    assert (
+        module._binary64_input_sha256(
+            source_pdgs,
+            target_pdgs,
+            momenta,
+        )
+        == hashlib.sha256(struct.pack(">16d", *transmitted)).hexdigest()
+    )
+    assert (
+        module._binary64_input_sha256(
+            source_pdgs,
+            target_pdgs,
+            momenta,
+        )
+        != hashlib.sha256(
+            struct.pack(">16d", *(value for row in momenta for value in row))
+        ).hexdigest()
+    )
+
+
+def test_probe_output_parser_records_values_and_topology() -> None:
+    module = _module()
+    result = module._parse_probe_output(
+        """AMPICOL_COLOR_PROBE_CURRENTS 7
+AMPICOL_COLOR_PROBE_VERTICES 4
+AMPICOL_COLOR_PROBE_AMPLITUDES 1
+AMPICOL_COLOR_PROBE_COLOR_ORDERS 1
+AMPICOL_COLOR_PROBE_COMPONENTS 4.0E-1 3.5E-1 3.4E-1
+AMPICOL_COLOR_PROBE_VALUE full 1 1 3.4E-1
+AMPICOL_COLOR_PROBE_FLOW_VALUE 1 2.0E-1
+AMPICOL_COLOR_PROBE_FLOW_PERM 1 2 4 1
+AMPICOL_COLOR_PROBE_FLOW_VALUE 2 1.4E-1
+AMPICOL_COLOR_PROBE_FLOW_PERM 2 2 1 4
+AMPICOL_COLOR_PROBE_FLOW_SUM 3.4E-1
+"""
+    )
+
+    assert result.value == pytest.approx(0.34)
+    assert result.value_decimal == Decimal("0.34")
+    assert result.components == pytest.approx((0.4, 0.35, 0.34))
+    assert result.component_decimals == (
+        Decimal("0.4"),
+        Decimal("0.35"),
+        Decimal("0.34"),
+    )
+    assert result.currents == 7
+    assert result.vertices == 4
+    assert result.amplitudes == 1
+    assert result.color_orders == 1
+    assert result.lc_row_partitions == (
+        module.LcRowPartition(1, 0.2, (2, 4, 1)),
+        module.LcRowPartition(2, 0.14, (2, 1, 4)),
+    )
+    assert result.lc_partition_sum == pytest.approx(0.34)
+    assert result.lc_partition_sum_decimal == Decimal("0.34")
+
+
+def test_probe_output_parser_rejects_duplicate_singleton_records() -> None:
+    module = _module()
+    output = """AMPICOL_COLOR_PROBE_CURRENTS 1
+AMPICOL_COLOR_PROBE_VERTICES 1
+AMPICOL_COLOR_PROBE_AMPLITUDES 1
+AMPICOL_COLOR_PROBE_COLOR_ORDERS 1
+AMPICOL_COLOR_PROBE_COMPONENTS 1.0 1.0 1.0
+AMPICOL_COLOR_PROBE_VALUE lc 1 1 1.0
+AMPICOL_COLOR_PROBE_VALUE lc 1 1 2.0
+"""
+
+    with pytest.raises(module.LegacyOracleError, match="exactly one"):
+        module._parse_probe_output(output)
+
+
+def test_probe_output_parser_normalizes_malformed_numbers() -> None:
+    module = _module()
+    output = """AMPICOL_COLOR_PROBE_CURRENTS 1
+AMPICOL_COLOR_PROBE_VERTICES 1
+AMPICOL_COLOR_PROBE_AMPLITUDES 1
+AMPICOL_COLOR_PROBE_COLOR_ORDERS 1
+AMPICOL_COLOR_PROBE_COMPONENTS 1.0 1.0 1.0
+AMPICOL_COLOR_PROBE_VALUE lc 1 1 .
+"""
+
+    with pytest.raises(module.LegacyOracleError, match="malformed"):
+        module._parse_probe_output(output)
+
+
+def test_cli_entrypoint_normalizes_expected_input_errors(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    module = _module()
+    monkeypatch.setattr(
+        module,
+        "main",
+        lambda argv=None: (_ for _ in ()).throw(ValueError("bad fixture")),
+    )
+
+    assert module._entrypoint([]) == 2
+    assert capsys.readouterr().err == "error: bad fixture\n"
+
+
+def test_lc_row_partition_resolves_only_a_single_physical_flow() -> None:
+    module = _module()
+    probe = module.ProbeResult(
+        value=0.34,
+        components=(0.34, 0.34, 0.34),
+        currents=7,
+        vertices=4,
+        amplitudes=1,
+        color_orders=1,
+        lc_row_partitions=(module.LcRowPartition(1, 0.34, (2, 3, 1)),),
+        lc_partition_sum=0.34,
+    )
+    color = {"id": "flow:2,3,1", "word": [2, 3, 1]}
+
+    assert module._resolved_single_lc_row(
+        probe,
+        colors=(color,),
+        source_to_row_permutation=(0, 1, 2),
+        context="single flow",
+    ) == ["0.34"]
+    with pytest.raises(module.LegacyOracleError, match="cannot resolve multiple"):
+        module._resolved_single_lc_row(
+            probe,
+            colors=(color, {"id": "flow:3,2,1", "word": [3, 2, 1]}),
+            source_to_row_permutation=(0, 1, 2),
+            context="multi flow",
+        )
+
+
+def _capture_v2(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    structural_zero: float = 0.0,
+    module: Any | None = None,
+) -> tuple[object, dict[str, Any], list[tuple[str, tuple[int, ...] | None]], int]:
+    module = _module() if module is None else module
+    tmp_path.mkdir(parents=True, exist_ok=True)
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    (repository / "amplicol_color_probe").write_text("probe", encoding="utf-8")
+    fixture_path = tmp_path / "physics-v2.json"
+    fixture = _v2_fixture(module.expected_revision())
+    reference = module._reference_fixture_v2_module()
+    for case in fixture["cases"]:
+        case["reduction"]["plan_sha256"] = reference.reduction_plan_sha256(
+            case["reduction"]
+        )
+        case["physics_case_sha256"] = reference.physics_case_sha256(
+            fixture,
+            case["id"],
+        )
+    fixture_path.write_text(json.dumps(fixture), encoding="utf-8")
+    process_generations = 0
+
+    def fake_run(command, *, cwd, capture=True):
+        nonlocal process_generations
+        process_generations += 1
+        return module.subprocess.CompletedProcess(command, 0, "", "")
+
+    entry = module.ProcessEntry(
+        group=1,
+        integral=1,
+        process_pdgs=(1, -1, 21, 21, 23),
+        color_order=(2, 3, 4, 1, 5),
+    )
+    probe_calls: list[tuple[str, tuple[int, ...] | None]] = []
+
+    def fake_probe(
+        repository,
+        *,
+        process_file,
+        entry,
+        source_pdgs,
+        momenta,
+        color_accuracy,
+        helicities=None,
+    ):
+        del repository, process_file, entry, source_pdgs, momenta
+        selected = None if helicities is None else tuple(helicities)
+        probe_calls.append((color_accuracy, selected))
+        totals = {"lc": 2.0, "nlc": 1.5, "full": 1.4}
+        value = totals[color_accuracy]
+        if selected is not None and selected != _ACTIVE_HELICITY:
+            value = structural_zero
+        if color_accuracy == "lc" and selected is not None:
+            first = structural_zero if selected != _ACTIVE_HELICITY else 1.25
+            second = 0.0 if selected != _ACTIVE_HELICITY else 0.75
+            # These deliberately do not map to the physical fixture flow words.
+            # Multi-flow evidence must use only their aggregate probe value.
+            lc_row_partitions = (
+                module.LcRowPartition(1, first, (1, 2, 3, 4)),
+                module.LcRowPartition(2, second, (4, 3, 2, 1)),
+            )
+            lc_partition_sum = first + second
+        else:
+            lc_row_partitions = ()
+            lc_partition_sum = None
+        return module.ProbeResult(
+            value=value,
+            components=(value, value, value),
+            currents=17,
+            vertices=31,
+            amplitudes=4,
+            color_orders=2,
+            lc_row_partitions=lc_row_partitions,
+            lc_partition_sum=lc_partition_sum,
+        )
+
+    monkeypatch.setattr(module, "validate_checkout", lambda repository: None)
+    monkeypatch.setattr(
+        module,
+        "_compiler_provenance",
+        lambda repository: module.CompilerProvenance(
+            identity="gfortran",
+            version="GNU Fortran (GCC) 14.2.0",
+            flags=("-ffast-math", "-O3"),
+            target="aarch64-apple-darwin24",
+            executable_sha256=_sha("probe"),
+        ),
+    )
+    monkeypatch.setattr(module, "_run", fake_run)
+    monkeypatch.setattr(module, "parse_process_file", lambda path: (entry,))
+    monkeypatch.setattr(module, "run_color_probe", fake_probe)
+    report = module.verify_fixture(
+        repository,
+        fixture_path,
+        jobs=1,
+        build=False,
+    )
+    return module, report, probe_calls, process_generations
+
+
+def test_v2_evidence_is_independent_of_temporary_paths(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _, first, _, _ = _capture_v2(tmp_path / "first", monkeypatch)
+    _, second, _, _ = _capture_v2(tmp_path / "second", monkeypatch)
+
+    assert first == second
+
+
+def test_v2_oracle_rejects_changed_process_row_multiplicity(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    monkeypatch.setattr(module, "expected_process_match_count", lambda process: 2)
+
+    with pytest.raises(module.LegacyOracleError, match="row multiplicity"):
+        _capture_v2(tmp_path, monkeypatch, module=module)
+
+
+def test_v2_oracle_rejects_changed_color_order_multiplicity(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    monkeypatch.setattr(module, "expected_color_order_count", lambda process: 1)
+
+    with pytest.raises(module.LegacyOracleError, match="color-order count"):
+        _capture_v2(tmp_path, monkeypatch, module=module)
+
+
+def test_v2_oracle_uses_helicity_aggregates_for_multi_flow_lc(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module, report, probe_calls, process_generations = _capture_v2(
+        tmp_path,
+        monkeypatch,
+    )
+
+    assert report["evidence_schema_version"] == 2
+    assert report["captured_at"] == "2026-07-16T12:00:00Z"
+    assert report["oracle"]["revision"] == module.expected_revision()
+    assert report["oracle"]["validation_profile"] == "binary64"
+    assert report["oracle"]["tolerance_ceiling"] == {
+        "relative": "0.0000000001",
+        "absolute": "0.000000000001",
+    }
+    assert report["dependency_ids"] == ["dependency:legacy-amplicol"]
+    assert process_generations == 1
+    assert len(probe_calls) == 396
+    assert len(report["records"]) == 12
+    assert {record["case_id"] for record in report["records"]} == {
+        "case:dd-zgg-lc",
+        "case:dd-zgg-nlc",
+        "case:dd-zgg-full",
+    }
+    for record in report["records"]:
+        expected_total = {"lc": "2", "nlc": "1.5", "full": "1.4"}[
+            record["case_id"].rsplit("-", 1)[1]
+        ]
+        assert record["id"] == (
+            f"evidence:fortran:{record['case_id']}:{record['point_id']}"
+        )
+        assert record["arithmetic_precision_bits"] == 53
+        assert record["round_trip_decimal_digits"] == 17
+        assert record["certified_decimal_digits"] == 10
+        assert record["arithmetic"] == "binary64"
+        assert len(record["helicity_ids"]) == 32
+        active_index = record["helicity_ids"].index("h:-1,+1,-1,-1,+1")
+        if record["case_id"].endswith("-lc"):
+            assert record["coverage"] == "helicity-aggregate"
+            assert record["color_ids"] == ["flow:2,4,5,1", "flow:2,5,4,1"]
+            assert record["observed_values"] is None
+            assert record["observed_helicity_totals"][active_index] == "2"
+            assert all(
+                value == "0"
+                for index, value in enumerate(record["observed_helicity_totals"])
+                if index != active_index
+            )
+        else:
+            assert record["coverage"] == "resolved"
+            assert record["color_ids"] == ["color:contracted"]
+            assert record["observed_values"][active_index] == [expected_total]
+            assert all(
+                all(value == "0" for value in row)
+                for index, row in enumerate(record["observed_values"])
+                if index != active_index
+            )
+            assert record["observed_helicity_totals"] is None
+        assert record["observed_total"] == expected_total
+        assert record["process_identity"] == {
+            "expression": "d d~ > z g g",
+            "ordered_external_pdgs": [1, -1, 21, 21, 23],
+            "ordered_external_leg_ids": [
+                "leg:incoming-d",
+                "leg:incoming-dbar",
+                "leg:outgoing-g-1",
+                "leg:outgoing-g-2",
+                "leg:outgoing-z",
+            ],
+            "source_to_row_permutation": [0, 1, 3, 4, 2],
+            "row_id": "group:1:integral:1",
+            "color_order_count": 2,
+            "ordered_color_legs": [
+                "leg:incoming-dbar",
+                "leg:outgoing-g-1",
+                "leg:outgoing-g-2",
+                "leg:incoming-d",
+                "leg:outgoing-z",
+            ],
+        }
+        assert record["command"][0] == "amplicol_color_probe"
+        assert all("/tmp/" not in argument for argument in record["command"])
+        command = dict(
+            argument.split("=", 1) for argument in record["command"] if "=" in argument
+        )
+        assert command["build_target"] == "amplicol_color_probe"
+        assert command["compiler_identity"] == "gfortran"
+        assert command["compiler_version"] == "GNU Fortran (GCC) 14.2.0"
+        assert json.loads(command["compiler_flags"]) == ["-ffast-math", "-O3"]
+        assert command["compiler_target"] == "aarch64-apple-darwin24"
+        assert command["oracle_executable_sha256"] == _sha("probe")
+        assert len(command["binary64_input_sha256"]) == 64
+        assert command["binary64_input_sha256"] != record["input_sha256"]
+        assert command["pdg_match_count"] == "1"
+        assert len(record["oracle_output_sha256"]) == 64
+        assert record["tolerances"] == {
+            "relative": "0.0000000001",
+            "absolute": "0.000000000001",
+        }
+
+
+def test_v2_multiflow_aggregate_report_validates_with_fixture(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module, report, _, _ = _capture_v2(tmp_path, monkeypatch)
+    fixture = _v2_fixture(module.expected_revision())
+    reference = module._reference_fixture_v2_module()
+    for case in fixture["cases"]:
+        case["reduction"]["plan_sha256"] = reference.reduction_plan_sha256(
+            case["reduction"]
+        )
+        case["physics_case_sha256"] = reference.physics_case_sha256(
+            fixture,
+            case["id"],
+        )
+
+    parsed = reference.parse_reference_fixture(fixture, [report])
+
+    assert len(parsed.cases) == 3
+    assert {
+        record.coverage
+        for record in parsed.evidence_sets[0].records
+        if record.case_id.endswith("-lc")
+    } == {"helicity-aggregate"}
+
+
+def test_v2_oracle_canonicalizes_bounded_structural_zero_residue(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module, report, _, _ = _capture_v2(
+        tmp_path,
+        monkeypatch,
+        structural_zero=1.0e-16,
+    )
+
+    fixture = _v2_fixture(module.expected_revision())
+    cases = {case["id"]: case for case in fixture["cases"]}
+    for record in report["records"]:
+        case = cases[record["case_id"]]
+        for index, helicity in enumerate(case["axes"]["helicities"]):
+            if not helicity["structural_zero"]:
+                continue
+            if record["coverage"] == "helicity-aggregate":
+                assert record["observed_helicity_totals"][index] == "0"
+            else:
+                assert all(value == "0" for value in record["observed_values"][index])
+
+
+def test_v2_oracle_rejects_structural_zero_residue_above_tolerance(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    with pytest.raises(
+        module.LegacyOracleError,
+        match="did not preserve structural zero",
+    ):
+        _capture_v2(
+            tmp_path,
+            monkeypatch,
+            structural_zero=1.0e-9,
+            module=module,
+        )
+
+
+def test_v2_report_replay_is_numeric_not_compiler_byte_exact(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module, tracked, _, _ = _capture_v2(tmp_path, monkeypatch)
+    fresh = copy.deepcopy(tracked)
+    record = fresh["records"][0]
+    record["observed_total"] = module._canonical_decimal(
+        Decimal(record["observed_total"]) * Decimal("1.00000000001")
+    )
+    record["oracle_output_sha256"] = _sha("fresh-compiler-output")
+    replacements = {
+        "compiler_identity": "other-gfortran",
+        "compiler_version": "GNU Fortran (GCC) 15.1.0",
+        "compiler_flags": '["-O2"]',
+        "compiler_target": "x86_64-unknown-linux-gnu",
+        "oracle_executable_sha256": _sha("fresh-executable"),
+    }
+    for index, argument in enumerate(record["command"]):
+        key = argument.partition("=")[0]
+        if key in replacements:
+            record["command"][index] = f"{key}={replacements[key]}"
+    _refresh_evidence_record_hash(module, record)
+
+    module._assert_v2_reports_semantically_equal(tracked, fresh)
+
+    record["observed_total"] = module._canonical_decimal(
+        Decimal(tracked["records"][0]["observed_total"]) * Decimal("1.001")
+    )
+    _refresh_evidence_record_hash(module, record)
+    with pytest.raises(module.LegacyOracleError, match="outside the tracked"):
+        module._assert_v2_reports_semantically_equal(tracked, fresh)
+
+
+def test_v2_report_replay_requires_exact_identity_and_structural_zeros(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module, tracked, _, _ = _capture_v2(tmp_path, monkeypatch)
+    fresh = copy.deepcopy(tracked)
+    fresh["records"][0]["process_identity"]["row_id"] = "group:99:integral:1"
+    _refresh_evidence_record_hash(module, fresh["records"][0])
+    with pytest.raises(module.LegacyOracleError, match="identity differs"):
+        module._assert_v2_reports_semantically_equal(tracked, fresh)
+
+    fresh = copy.deepcopy(tracked)
+    command = fresh["records"][0]["command"]
+    binary64_index = next(
+        index
+        for index, argument in enumerate(command)
+        if argument.startswith("binary64_input_sha256=")
+    )
+    command[binary64_index] = f"binary64_input_sha256={_sha('different-input')}"
+    _refresh_evidence_record_hash(module, fresh["records"][0])
+    with pytest.raises(module.LegacyOracleError, match="identity differs"):
+        module._assert_v2_reports_semantically_equal(tracked, fresh)
+
+    fresh = copy.deepcopy(tracked)
+    zero_row = next(
+        row
+        for row in fresh["records"][0]["observed_values"]
+        if all(value == "0" for value in row)
+    )
+    zero_row[0] = "0.0000000000000001"
+    _refresh_evidence_record_hash(module, fresh["records"][0])
+    with pytest.raises(module.LegacyOracleError, match="exact zero"):
+        module._assert_v2_reports_semantically_equal(tracked, fresh)
+
+
+def test_fixture_version_one_dispatch_preserves_legacy_path(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _module()
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    (repository / "amplicol_color_probe").write_text("probe", encoding="utf-8")
+    fixture_path = tmp_path / "physics-v1.json"
+    fixture_path.write_text('{"fixture_schema_version": 1}', encoding="utf-8")
+    sentinel = {"schema_version": 1, "unchanged": True}
+    monkeypatch.setattr(module, "validate_checkout", lambda repository: None)
+    monkeypatch.setattr(
+        module,
+        "_verify_fixture_v1",
+        lambda repository, fixture_path, fixture: sentinel,
+    )
+
+    assert (
+        module.verify_fixture(
+            repository,
+            fixture_path,
+            jobs=1,
+            build=False,
+        )
+        is sentinel
+    )
+
+
+def test_tracked_fortran_report_is_pinned_and_matches_physics_fixture() -> None:
+    report = json.loads(REPORT.read_text(encoding="utf-8"))
+    physics = json.loads(PHYSICS.read_text(encoding="utf-8"))
+    with (ROOT / "dependencies" / "contributor-lock.toml").open("rb") as stream:
+        lock = tomllib.load(stream)
+
+    assert report["schema_version"] == 1
+    assert report["oracle"] == "legacy-fortran-amplicol-color-probe"
+    assert report["revision"] == lock["legacy_amplicol"]["reference_fixture_revision"]
+    assert report["fixture_sha256"] == hashlib.sha256(PHYSICS.read_bytes()).hexdigest()
+    assert report["patches"] == []
+    assert report["tolerances"] == {"relative": 1.0e-8, "absolute": 1.0e-15}
+    assert set(report["cases"]) == {
+        "builtin_sm_ddbar_z_lc",
+        "builtin_sm_ddbar_z_nlc",
+        "builtin_sm_ddbar_z_full",
+        "builtin_sm_ddbar_zg_lc",
+        "builtin_sm_ddbar_zg_nlc",
+        "builtin_sm_ddbar_zg_full",
+    }
+    for name, observation in report["cases"].items():
+        assert "source_to_row_permutation" in observation["fortran_process_entry"]
+        assert observation["total"] == pytest.approx(
+            physics["cases"][name]["total"], rel=1.0e-12, abs=1.0e-15
+        )
+        assert (
+            observation["max_resolved_relative_difference"]
+            < report["tolerances"]["relative"]
+        )
diff --git a/pyamplicol/tests/unit/test_legacy_structural_proof.py b/pyamplicol/tests/unit/test_legacy_structural_proof.py
new file mode 100644
index 0000000000..4c600bb289
--- /dev/null
+++ b/pyamplicol/tests/unit/test_legacy_structural_proof.py
@@ -0,0 +1,403 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import multiprocessing
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.legacy_structure import (
+    LEGACY_PROOF_SCHEMA,
+    LEGACY_SCOPE_REASON,
+    InstrumentationRecord,
+    LegacyStructuralProofError,
+    _instrument_direct_source,
+    _instrument_library_source,
+    _parse_direct,
+    _parse_module,
+    emit_legacy_scope_unavailable_proof,
+    emit_legacy_structural_proof,
+    instrument_legacy_structural_probes,
+)
+from tools.performance_report.models import Accuracy, Workload
+
+_MODULE = """\
+module amp1_1_lib
+  contains
+  subroutine evaluate_amp1_1(p,amps)
+    complex(kind=8),dimension(1),intent(out) :: amps
+    complex(kind=8),dimension(1:6,3) :: val_c
+    complex(kind=8),dimension(1:6,2) :: int_c
+  end subroutine evaluate_amp1_1
+  subroutine compute_external_currents(pp,val_c)
+    call ext_quark(pp(0,1),-1,1,val_c(1,1))
+    call ext_gluon(pp(0,2),-1,1,val_c(1,2))
+  end subroutine compute_external_currents
+  subroutine vertex_2(pp,val_c,int_c)
+    integer,parameter,dimension(2) :: int1=[1,2]
+  end subroutine vertex_2
+  subroutine combine_currents_2(pp,val_c,int_c)
+    integer,parameter,dimension(0:2,1) :: int1=reshape([3,1,2], shape=[3,1])
+  end subroutine combine_currents_2
+  subroutine compute_amps(amps,val_c)
+    complex(kind=8),dimension(1),intent(out) :: amps
+    amps(1)=sum(val_c(1:2,3)*val_c(1:2,1))
+  end subroutine compute_amps
+end module amp1_1_lib
+"""
+
+
+_DIRECT_OUTPUT = """\
+color_accuracy lc
+AMPICOL_COLOR_PROBE_CURRENTS 3
+AMPICOL_COLOR_PROBE_VERTICES 2
+AMPICOL_COLOR_PROBE_AMPLITUDES 1
+AMPICOL_STRUCTURAL_CURRENT 1 1 1 0 1
+AMPICOL_STRUCTURAL_CURRENT 2 1 21 0 2
+AMPICOL_STRUCTURAL_CURRENT 3 0 1 0 3
+AMPICOL_STRUCTURAL_ATTACHMENT 3 1 1 1
+AMPICOL_STRUCTURAL_ATTACHMENT 3 2 2 -1
+AMPICOL_STRUCTURAL_KERNEL 1 2 0 1 2 1.0D+00 0.0D+00
+AMPICOL_STRUCTURAL_KERNEL_SINGLET 1 0
+AMPICOL_STRUCTURAL_KERNEL 2 3 0 2 1 2.0D+00 0.0D+00
+AMPICOL_STRUCTURAL_KERNEL_SINGLET 2 0
+AMPICOL_STRUCTURAL_DESTINATION 1 3 1
+"""
+
+_DIRECT_SOURCE = """\
+  logical :: print_matrix, fixed_helicity
+  print_matrix = .false.
+  fixed_helicity = .false.
+  call get_environment_variable('AMPICOL_COLOR_PROBE_MATRIX',env_value)
+  if (trim(adjustl(env_value)).eq.'1') print_matrix = .true.
+  env_value = ''
+  call print_recursion_counts()
+  subroutine parse_color_accuracy()
+"""
+
+_LIBRARY_SOURCE = """\
+  logical :: print_matrix
+  print_matrix = .false.
+  call get_environment_variable('AMPICOL_COLOR_PROBE_MATRIX',env_value)
+  if (trim(adjustl(env_value)).eq.'1') print_matrix = .true.
+
+  argc = command_argument_count()
+  call build_row_to_integral()
+  integer function colour_order_match_sign(jgroup,jint,row,pass,leg_map)
+"""
+
+
+def _instrument_probe_sources_in_process(
+    repository: str,
+    artifact_path: str,
+    entered: object,
+    release: object | None,
+    outcomes: object,
+    *,
+    interrupt: bool,
+) -> None:
+    try:
+        with instrument_legacy_structural_probes(
+            Path(repository),
+            Path(artifact_path),
+        ):
+            entered.set()
+            if release is not None and not release.wait(timeout=5):
+                raise TimeoutError("test did not release instrumented checkout")
+            if interrupt:
+                raise KeyboardInterrupt
+    except KeyboardInterrupt:
+        outcomes.put("interrupted")
+    except BaseException as error:
+        outcomes.put(f"error:{type(error).__name__}:{error}")
+    else:
+        outcomes.put("ok")
+
+
+def _reference(*, workload: Workload, accuracy: Accuracy = Accuracy.LC) -> object:
+    return next(
+        cell
+        for cell in REPORT_CATALOG.reference_cells()
+        if cell.workload is workload and cell.measurement.accuracy is accuracy
+    )
+
+
+def _instrumentation(artifact: Path) -> InstrumentationRecord:
+    evidence = artifact / "legacy-structural-evidence"
+    direct = evidence / "instrumented-amplicol_color_probe.f03"
+    library = evidence / "instrumented-amplicol_color_library_probe.f03"
+    direct.parent.mkdir(parents=True, exist_ok=True)
+    direct.write_text("direct diagnostic source\n")
+    library.write_text("library diagnostic source\n")
+    return InstrumentationRecord(
+        abi="pyamplicol-legacy-probe-structural-diagnostics-v1",
+        sources=(
+            {
+                "path": "amplicol_color_probe.f03",
+                "original_sha256": "1" * 64,
+                "instrumented_sha256": "2" * 64,
+                "instrumented_evidence_path": direct.relative_to(
+                    artifact
+                ).as_posix(),
+            },
+            {
+                "path": "amplicol_color_library_probe.f03",
+                "original_sha256": "3" * 64,
+                "instrumented_sha256": "4" * 64,
+                "instrumented_evidence_path": library.relative_to(
+                    artifact
+                ).as_posix(),
+            },
+        ),
+        evidence_paths=(direct, library),
+    )
+
+
+def _base_artifact(root: Path) -> None:
+    root.mkdir(parents=True)
+    (root / "processes.txt").write_text("process\n")
+    (root / "legacy.log").write_text("legacy commands\n")
+
+
+def _assert_evidence_inventory(artifact: Path, proof: dict[str, object]) -> None:
+    evidence = proof["evidence_files"]
+    assert isinstance(evidence, list)
+    assert evidence
+    for record in evidence:
+        assert isinstance(record, dict)
+        path = artifact / str(record["path"])
+        assert path.is_file()
+        assert hashlib.sha256(path.read_bytes()).hexdigest() == record["sha256"]
+
+
+def test_generated_module_preserves_exact_object_maps(tmp_path: Path) -> None:
+    path = tmp_path / "amp1_1_lib.f03"
+    path.write_text(_MODULE)
+    module = _parse_module(path)
+    assert module.source_current_ids == (1, 2)
+    assert module.produced_current_ids == (3,)
+    assert module.kernel_term_ids == (1, 2)
+    assert module.combine_routes == ((3, (1, 2)),)
+    assert module.amplitude_destinations == ((1, 3, 1),)
+    assert module.counts == {
+        "source_current_count": 2,
+        "produced_current_count": 1,
+        "kernel_evaluation_count": 2,
+        "attachment_count": 2,
+        "amplitude_destination_count": 1,
+    }
+
+
+def test_direct_probe_requires_dense_maps_and_exact_accuracy(
+    tmp_path: Path,
+) -> None:
+    path = tmp_path / "direct.stdout"
+    path.write_text(_DIRECT_OUTPUT)
+    structure = _parse_direct(path, "lc")
+    assert structure.counts == {
+        "source_current_count": 2,
+        "produced_current_count": 1,
+        "kernel_evaluation_count": 2,
+        "attachment_count": 2,
+        "amplitude_destination_count": 1,
+    }
+    with pytest.raises(LegacyStructuralProofError, match="expected full"):
+        _parse_direct(path, "full")
+
+
+def test_probe_instrumentation_has_real_histogram_emitter() -> None:
+    patched_direct = _instrument_direct_source(_DIRECT_SOURCE)
+    patched_library = _instrument_library_source(_LIBRARY_SOURCE)
+    assert "AMPICOL_STRUCTURAL_ATTACHMENT" in patched_direct
+    assert "AMPICOL_STRUCTURAL_DESTINATION" in patched_direct
+    assert "AMPICOL_COLOR_PROBE_LIBRARY_CALLS" in patched_library
+    assert (
+        "write (99,'(a,3(1x,i0))') 'AMPICOL_COLOR_PROBE_LIBRARY_CALLS'"
+        in patched_library
+    )
+    assert "AMPICOL_COLOR_PROBE_LIBRARY_ROW" in patched_library
+
+
+def test_probe_instrumentation_serializes_processes_and_restores_after_interrupt(
+    tmp_path: Path,
+) -> None:
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    direct = repository / "amplicol_color_probe.f03"
+    library = repository / "amplicol_color_library_probe.f03"
+    direct.write_text(_DIRECT_SOURCE, encoding="utf-8")
+    library.write_text(_LIBRARY_SOURCE, encoding="utf-8")
+    unrelated_repository = tmp_path / "unrelated-legacy"
+    unrelated_repository.mkdir()
+    (unrelated_repository / direct.name).write_text(_DIRECT_SOURCE, encoding="utf-8")
+    (unrelated_repository / library.name).write_text(_LIBRARY_SOURCE, encoding="utf-8")
+
+    context = multiprocessing.get_context("fork")
+    first_entered = context.Event()
+    release_first = context.Event()
+    second_entered = context.Event()
+    unrelated_entered = context.Event()
+    outcomes = context.Queue()
+    first = context.Process(
+        target=_instrument_probe_sources_in_process,
+        args=(
+            str(repository),
+            str(tmp_path / "first-artifact"),
+            first_entered,
+            release_first,
+            outcomes,
+        ),
+        kwargs={"interrupt": True},
+    )
+    second = context.Process(
+        target=_instrument_probe_sources_in_process,
+        args=(
+            str(repository),
+            str(tmp_path / "second-artifact"),
+            second_entered,
+            None,
+            outcomes,
+        ),
+        kwargs={"interrupt": False},
+    )
+    unrelated = context.Process(
+        target=_instrument_probe_sources_in_process,
+        args=(
+            str(unrelated_repository),
+            str(tmp_path / "unrelated-artifact"),
+            unrelated_entered,
+            None,
+            outcomes,
+        ),
+        kwargs={"interrupt": False},
+    )
+
+    first.start()
+    assert first_entered.wait(timeout=3)
+    unrelated.start()
+    assert unrelated_entered.wait(timeout=3)
+    unrelated.join(timeout=3)
+    assert unrelated.exitcode == 0
+    second.start()
+    assert not second_entered.wait(timeout=0.2)
+    assert second.is_alive()
+    release_first.set()
+    assert second_entered.wait(timeout=3)
+    first.join(timeout=3)
+    second.join(timeout=3)
+
+    assert first.exitcode == 0
+    assert second.exitcode == 0
+    assert sorted(outcomes.get(timeout=1) for _ in range(3)) == [
+        "interrupted",
+        "ok",
+        "ok",
+    ]
+    assert direct.read_text(encoding="utf-8") == _DIRECT_SOURCE
+    assert library.read_text(encoding="utf-8") == _LIBRARY_SOURCE
+    assert (
+        tmp_path
+        / "first-artifact"
+        / "legacy-structural-evidence"
+        / "instrumented-amplicol_color_probe.f03"
+    ).is_file()
+    assert (
+        tmp_path
+        / "second-artifact"
+        / "legacy-structural-evidence"
+        / "instrumented-amplicol_color_probe.f03"
+    ).is_file()
+
+
+def test_selected_flow_sidecar_is_atomic_and_producer_compatible(
+    tmp_path: Path,
+) -> None:
+    cell = _reference(workload=Workload.SELECTED_FLOW)
+    artifact = tmp_path / "artifact"
+    _base_artifact(artifact)
+    generated = artifact / "selected-flow-generated-library"
+    library = generated / "Library"
+    library.mkdir(parents=True)
+    (library / "amp1_1_lib.f03").write_text(_MODULE)
+    benchmark = generated / "amplicol_library_benchmark"
+    benchmark.write_bytes(b"benchmark")
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    proof_path = emit_legacy_structural_proof(
+        cell,
+        artifact_path=artifact,
+        process_row="group:1:integral:1",
+        source_revision="a" * 40,
+        repository=repository,
+        instrumentation=_instrumentation(artifact),
+    )
+    proof = json.loads(proof_path.read_text())
+    assert proof["schema"] == LEGACY_PROOF_SCHEMA
+    assert proof["scope"] == "available"
+    assert proof["active"]["source_current_count"] == 2
+    assert proof["static"] == proof["active"]
+    assert proof["object_mapping"]["status"] == "exact"
+    assert proof["row_multiplicity"]["call_count"] == 1
+    _assert_evidence_inventory(artifact, proof)
+    assert {item["path"] for item in proof["evidence_files"]} >= {
+        "processes.txt",
+        "legacy.log",
+        "selected-flow-generated-library/Library/amp1_1_lib.f03",
+        "legacy-structural-evidence/legacy-structural-index.json",
+        "legacy-structural-evidence/source-contract.json",
+    }
+    assert not list(artifact.glob(".legacy-structural-proof.json.*"))
+
+
+def test_direct_sidecar_separates_accuracy_and_maps(tmp_path: Path) -> None:
+    cell = _reference(workload=Workload.ALL_FLOW)
+    artifact = tmp_path / "artifact"
+    _base_artifact(artifact)
+    evidence = artifact / "legacy-structural-evidence"
+    evidence.mkdir(parents=True)
+    (evidence / "direct-structural-probe.stdout").write_text(_DIRECT_OUTPUT)
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    (repository / "amplicol_color_probe").write_bytes(b"probe")
+    proof_path = emit_legacy_structural_proof(
+        cell,
+        artifact_path=artifact,
+        process_row="group:1:integral:1",
+        source_revision="b" * 40,
+        repository=repository,
+        instrumentation=_instrumentation(artifact),
+    )
+    proof = json.loads(proof_path.read_text())
+    assert proof["accuracy"] == "lc"
+    assert proof["workload"] == Workload.ALL_FLOW.value
+    assert proof["active"]["kernel_evaluation_count"] == 2
+    assert proof["object_mapping"]["combine_route_map_sha256"]
+    assert proof["object_mapping"]["amplitude_destination_map_sha256"]
+    _assert_evidence_inventory(artifact, proof)
+
+
+def test_scope_unavailable_has_exact_reason_without_fake_counts(
+    tmp_path: Path,
+) -> None:
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.reference_cells()
+        if not REPORT_CATALOG.legacy_reference_available(cell)
+    )
+    path = emit_legacy_scope_unavailable_proof(
+        cell,
+        artifact_path=tmp_path,
+        source_revision="c" * 40,
+        maximum_open_quark_lines=3,
+        observed_open_quark_lines=4,
+    )
+    proof = json.loads(path.read_text())
+    assert proof["scope"] == "unavailable"
+    assert proof["reason"] == LEGACY_SCOPE_REASON
+    assert "active" not in proof
+    assert "static" not in proof
+    assert proof["evidence_files"][0]["sha256"]
+    _assert_evidence_inventory(tmp_path, proof)
diff --git a/pyamplicol/tests/unit/test_licensing.py b/pyamplicol/tests/unit/test_licensing.py
new file mode 100644
index 0000000000..001d433a55
--- /dev/null
+++ b/pyamplicol/tests/unit/test_licensing.py
@@ -0,0 +1,242 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import io
+import os
+from types import ModuleType
+from typing import Literal
+
+import pytest
+
+from pyamplicol.config import (
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    ProcessConfig,
+    ProcessEntry,
+    RunConfig,
+)
+from pyamplicol.licensing import (
+    SymbolicaLicenseState,
+    detect_symbolica_license,
+    request_hobbyist_license,
+    request_trial_license,
+    reset_suggestion_state_for_tests,
+    resolve_symbolica_resource_config,
+    symbolica_resource_clamps,
+)
+
+
+def _module(*, licensed: bool) -> ModuleType:
+    module = ModuleType("fake_symbolica")
+    module.is_licensed = lambda: licensed  # type: ignore[attr-defined]
+    return module
+
+
+def test_unlicensed_detection_suggests_once_and_hides_json_banner(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    reset_suggestion_state_for_tests()
+    monkeypatch.setenv("SYMBOLICA_HIDE_BANNER", "0")
+    stream = io.StringIO()
+    state = detect_symbolica_license(
+        stream=stream,
+        loader=lambda: _module(licensed=False),
+    )
+    detect_symbolica_license(stream=stream, loader=lambda: _module(licensed=False))
+    assert state == SymbolicaLicenseState(licensed=False, restricted=True)
+    assert stream.getvalue().count("restricted mode") == 1
+
+    detect_symbolica_license(
+        json_mode=True,
+        loader=lambda: _module(licensed=False),
+    )
+    assert os.environ["SYMBOLICA_HIDE_BANNER"] == "1"
+
+
+def test_restricted_mode_clamps_both_generation_axes() -> None:
+    config = RunConfig(
+        action="generate",
+        process=ProcessConfig(
+            entries=(ProcessEntry("d d~ > z"), ProcessEntry("d d~ > z g"))
+        ),
+    )
+    clamps = symbolica_resource_clamps(
+        config,
+        SymbolicaLicenseState(licensed=False, restricted=True),
+        cpu_budget=16,
+    )
+    assert [(item.path, item.effective) for item in clamps] == [
+        ("generation.workers", 1),
+        ("evaluator.optimization.cores", 1),
+    ]
+
+
+def test_licensed_mode_partitions_concrete_processes_across_affinity_budget() -> None:
+    config = RunConfig(
+        action="generate",
+        process=ProcessConfig(
+            entries=(
+                ProcessEntry("p1 > p2"),
+                ProcessEntry("p1 > p3"),
+                ProcessEntry("p1 > p4"),
+            )
+        ),
+    )
+    clamps = symbolica_resource_clamps(
+        config,
+        SymbolicaLicenseState(licensed=True, restricted=False),
+        cpu_budget=12,
+        process_count=3,
+    )
+    assert [(item.path, item.effective) for item in clamps] == [
+        ("generation.workers", 3),
+        ("evaluator.optimization.cores", 4),
+    ]
+
+
+def test_licensed_mode_defers_until_concrete_process_count_is_known() -> None:
+    config = RunConfig(
+        action="generate",
+        process=ProcessConfig(
+            entries=(
+                ProcessEntry("p1 > p2"),
+                ProcessEntry("p1 > p3"),
+                ProcessEntry("p1 > p4"),
+            )
+        ),
+    )
+
+    clamps = symbolica_resource_clamps(
+        config,
+        SymbolicaLicenseState(licensed=True, restricted=False),
+        cpu_budget=12,
+    )
+
+    assert clamps == ()
+
+
+def test_programmatic_process_count_controls_resource_partition() -> None:
+    config = RunConfig(action="generate")
+    clamps = symbolica_resource_clamps(
+        config,
+        SymbolicaLicenseState(licensed=True, restricted=False),
+        cpu_budget=12,
+        process_count=3,
+    )
+    assert [(item.path, item.effective) for item in clamps] == [
+        ("generation.workers", 3),
+        ("evaluator.optimization.cores", 4),
+    ]
+
+    with pytest.raises(ValueError, match="process_count"):
+        symbolica_resource_clamps(
+            config,
+            SymbolicaLicenseState(licensed=True, restricted=False),
+            process_count=0,
+        )
+
+
+@pytest.mark.parametrize(
+    ("requested_workers", "requested_cores", "process_count", "cpu_budget"),
+    (
+        ("auto", "auto", 50, 8),
+        (3, "auto", 20, 8),
+        (6, 4, 20, 10),
+        (2, 20, 20, 9),
+    ),
+)
+def test_licensed_partition_never_oversubscribes_cpu_budget(
+    requested_workers: int | Literal["auto"],
+    requested_cores: int | Literal["auto"],
+    process_count: int,
+    cpu_budget: int,
+) -> None:
+    config = RunConfig(
+        action="generate",
+        generation=GenerationConfig(workers=requested_workers),
+        evaluator=EvaluatorConfig(
+            optimization=EvaluatorOptimizationConfig(cores=requested_cores)
+        ),
+    )
+
+    resolution = resolve_symbolica_resource_config(
+        config,
+        SymbolicaLicenseState(licensed=True, restricted=False),
+        cpu_budget=cpu_budget,
+        process_count=process_count,
+    )
+    workers = resolution.effective.generation.workers
+    cores = resolution.effective.evaluator.optimization.cores
+
+    assert isinstance(workers, int)
+    assert isinstance(cores, int)
+    assert workers <= process_count
+    assert workers * cores <= cpu_budget
+
+
+def test_resource_repartition_replaces_stale_clamps_from_requested_values() -> None:
+    state = SymbolicaLicenseState(licensed=True, restricted=False)
+    provisional = resolve_symbolica_resource_config(
+        RunConfig(action="generate"),
+        state,
+        cpu_budget=12,
+        process_count=1,
+    )
+
+    final = resolve_symbolica_resource_config(
+        provisional,
+        state,
+        cpu_budget=12,
+        process_count=5,
+    )
+
+    assert final.requested.generation.workers == "auto"
+    assert final.requested.evaluator.optimization.cores == "auto"
+    assert final.effective.generation.workers == 5
+    assert final.effective.evaluator.optimization.cores == 2
+    assert [item.reason for item in final.clamps] == [
+        "shared affinity-aware CPU budget for concurrent process generation",
+        "shared affinity-aware CPU budget for Symbolica evaluator work",
+    ]
+
+
+def test_licensed_partition_uses_process_affinity_budget(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        os,
+        "sched_getaffinity",
+        lambda _pid: {2, 4, 8},
+        raising=False,
+    )
+
+    resolution = resolve_symbolica_resource_config(
+        RunConfig(action="generate"),
+        SymbolicaLicenseState(licensed=True, restricted=False),
+        process_count=10,
+    )
+
+    assert resolution.effective.generation.workers == 3
+    assert resolution.effective.evaluator.optimization.cores == 1
+
+
+def test_request_helpers_forward_only_after_validation() -> None:
+    calls: list[tuple[object, ...]] = []
+    module = _module(licensed=True)
+    module.request_trial_license = lambda *args: calls.append(args)  # type: ignore[attr-defined]
+    module.request_hobbyist_license = lambda *args: calls.append(args)  # type: ignore[attr-defined]
+
+    request_trial_license(
+        "Ada",
+        "ada@example.org",
+        "Institute",
+        loader=lambda: module,
+    )
+    request_hobbyist_license("Grace", "grace@example.org", loader=lambda: module)
+    assert calls == [
+        ("Ada", "ada@example.org", "Institute"),
+        ("Grace", "grace@example.org"),
+    ]
+    with pytest.raises(ValueError, match="valid email"):
+        request_hobbyist_license("Grace", "invalid", loader=lambda: module)
diff --git a/pyamplicol/tests/unit/test_logging_behavior.py b/pyamplicol/tests/unit/test_logging_behavior.py
new file mode 100644
index 0000000000..a4c2971352
--- /dev/null
+++ b/pyamplicol/tests/unit/test_logging_behavior.py
@@ -0,0 +1,112 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib
+import io
+import logging
+
+from pyamplicol.reporting import (
+    configure_cli_logging,
+    get_logger,
+    reset_cli_logging,
+)
+
+logging_module = importlib.import_module("pyamplicol.reporting.logging")
+
+
+def test_cli_logging_is_package_local_idempotent_and_resettable() -> None:
+    root = logging.getLogger()
+    root_handlers = tuple(root.handlers)
+    root_level = root.level
+    stream = io.StringIO()
+    reset_cli_logging()
+    try:
+        logger = configure_cli_logging("warning", stream=stream)
+        configure_cli_logging("warning", stream=stream)
+        owned = [
+            handler
+            for handler in logger.handlers
+            if getattr(handler, "_pyamplicol_cli_handler", False)
+        ]
+        assert len(owned) == 1
+        get_logger("unit").warning("diagnostic")
+        assert "diagnostic" in stream.getvalue()
+        assert tuple(root.handlers) == root_handlers
+        assert root.level == root_level
+    finally:
+        reset_cli_logging()
+    assert not any(
+        getattr(handler, "_pyamplicol_cli_handler", False)
+        for handler in get_logger().handlers
+    )
+
+
+def test_cli_logging_restores_embedding_application_state() -> None:
+    logger = get_logger()
+    reset_cli_logging()
+    original_level = logger.level
+    original_propagate = logger.propagate
+    external_handler = logging.NullHandler()
+    logger.addHandler(external_handler)
+    logger.setLevel(logging.ERROR)
+    logger.propagate = False
+    try:
+        configure_cli_logging(logging.INFO, stream=io.StringIO())
+        assert logger.level == logging.INFO
+        assert logger.propagate is False
+
+        reset_cli_logging()
+
+        assert logger.level == logging.ERROR
+        assert logger.propagate is False
+        assert external_handler in logger.handlers
+    finally:
+        reset_cli_logging()
+        logger.removeHandler(external_handler)
+        logger.setLevel(original_level)
+        logger.propagate = original_propagate
+
+
+def test_cli_logging_colors_terminal_warnings_without_coloring_plain_output() -> None:
+    colored = io.StringIO()
+    plain = io.StringIO()
+    reset_cli_logging()
+    try:
+        configure_cli_logging("warning", stream=colored, color=True)
+        get_logger("generation").warning("skipped unsupported process")
+        configure_cli_logging("warning", stream=plain, color=False)
+        get_logger("generation").warning("skipped unsupported process")
+    finally:
+        reset_cli_logging()
+
+    assert colored.getvalue().startswith("\x1b[33mWARNING pyamplicol.generation")
+    assert colored.getvalue().endswith("\x1b[0m\n")
+    assert plain.getvalue() == (
+        "WARNING pyamplicol.generation: skipped unsupported process\n"
+    )
+
+
+def test_cli_logging_falls_back_to_plain_text_without_colorama(monkeypatch) -> None:
+    stream = io.StringIO()
+    real_import_module = logging_module.importlib.import_module
+
+    def import_without_colorama(name: str) -> object:
+        if name == "colorama":
+            raise ImportError("colorama unavailable")
+        return real_import_module(name)
+
+    monkeypatch.setattr(
+        logging_module.importlib,
+        "import_module",
+        import_without_colorama,
+    )
+    reset_cli_logging()
+    try:
+        configure_cli_logging("warning", stream=stream, color=True)
+        get_logger("generation").warning("skipped unsupported process")
+    finally:
+        reset_cli_logging()
+
+    assert stream.getvalue() == (
+        "WARNING pyamplicol.generation: skipped unsupported process\n"
+    )
diff --git a/pyamplicol/tests/unit/test_madgraph_correctness.py b/pyamplicol/tests/unit/test_madgraph_correctness.py
new file mode 100644
index 0000000000..5c2dd8ae67
--- /dev/null
+++ b/pyamplicol/tests/unit/test_madgraph_correctness.py
@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from tools.developer.madgraph_correctness import (
+    CommandResult,
+    MadGraphAdapterError,
+    madgraph_command_card,
+    reject_failed_generation,
+    set_parameter_card_values,
+)
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def _result(tmp_path: Path, *, stderr: str = "") -> CommandResult:
+    return CommandResult(
+        args=("mg5_aMC",),
+        cwd=tmp_path,
+        elapsed_seconds=0.0,
+        returncode=0,
+        stdout="",
+        stderr=stderr,
+    )
+
+
+def test_heft_acceptance_driver_supports_direct_invocation(tmp_path: Path) -> None:
+    completed = subprocess.run(
+        [
+            sys.executable,
+            os.fspath(ROOT / "tools/developer/heft_madgraph_acceptance.py"),
+            "--help",
+        ],
+        cwd=tmp_path,
+        env={**os.environ, "PYTHONDONTWRITEBYTECODE": "1"},
+        capture_output=True,
+        check=False,
+        text=True,
+    )
+
+    assert completed.returncode == 0, completed.stderr
+    assert "MadGraph5_aMC installation" in completed.stdout
+
+
+def test_correctness_command_card_binds_exact_ufo_and_heft_order() -> None:
+    assert madgraph_command_card(
+        "g g > H g g",
+        model_import="/tmp/prepared-heft-ufo",
+        coupling_orders={"HIG": 1},
+    ) == (
+        "import model /tmp/prepared-heft-ufo\n"
+        "generate g g > H g g HIG=1\n"
+        "output standalone standalone -f\n"
+        "launch -f\n"
+    )
+
+
+def test_correctness_generation_guard_rejects_import_fallback(tmp_path: Path) -> None:
+    cards = tmp_path / "standalone/Cards"
+    cards.mkdir(parents=True)
+    process_card = cards / "proc_card_mg5.dat"
+    expected = "/tmp/prepared-heft-ufo"
+    process_card.write_text(f"import model {expected}\n", encoding="utf-8")
+
+    reject_failed_generation(
+        _result(tmp_path),
+        tmp_path / "standalone",
+        expected_model_import=expected,
+    )
+
+    process_card.write_text("import model sm\n", encoding="utf-8")
+    with pytest.raises(MadGraphAdapterError, match="bound exclusively"):
+        reject_failed_generation(
+            _result(tmp_path),
+            tmp_path / "standalone",
+            expected_model_import=expected,
+        )
+
+    process_card.write_text(f"import model {expected}\n", encoding="utf-8")
+    with pytest.raises(MadGraphAdapterError, match="possible model fallback"):
+        reject_failed_generation(
+            _result(tmp_path, stderr="UFOImportError: rejected"),
+            tmp_path / "standalone",
+            expected_model_import=expected,
+        )
+
+
+def test_correctness_parameter_card_uses_packaged_heft_inputs(tmp_path: Path) -> None:
+    card = tmp_path / "param_card.dat"
+    card.write_text(
+        "Block SMINPUTS\n"
+        "  1 1.279000e+02 # aEWM1\n"
+        "  3 1.184000e-01 # aS (not used with PDFs)\n"
+        "Block MASS\n"
+        "  25 1.200000e+02 # MH\n",
+        encoding="ascii",
+    )
+
+    observed = set_parameter_card_values(
+        card,
+        {"aEWM1": 132.507, "aS": 0.118, "MH": 125.0},
+    )
+
+    assert observed == ("MH", "aEWM1", "aS")
+    rendered = card.read_text(encoding="ascii")
+    assert "1.32507000000000e+02 # aEWM1" in rendered
+    assert "1.18000000000000e-01 # aS (not used with PDFs)" in rendered
+    assert "1.25000000000000e+02 # MH" in rendered
+    with pytest.raises(MadGraphAdapterError, match="lacks required"):
+        set_parameter_card_values(card, {"MT": 173.0})
diff --git a/pyamplicol/tests/unit/test_manual_campaign_audit_polish.py b/pyamplicol/tests/unit/test_manual_campaign_audit_polish.py
new file mode 100644
index 0000000000..b779857288
--- /dev/null
+++ b/pyamplicol/tests/unit/test_manual_campaign_audit_polish.py
@@ -0,0 +1,412 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from colorama import Fore
+
+import tools.performance_report.manual_campaign as manual_campaign
+from pyamplicol.cli import parse_cli
+from tools.performance_report.arena_profile import PAIRED_TIMING_SAMPLE_CONTRACT
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.manual_campaign import (
+    LightweightCurrent,
+    ManualCampaignError,
+    Palette,
+    build_parser,
+    reproduction_recipe,
+    selection_from_arguments,
+)
+from tools.performance_report.models import ExecutionMode, ModelKey, ResultStatus
+from tools.performance_report.timing import (
+    MEASURED_EXECUTION_TIMING_ABI,
+    RECURRENCE_EXECUTION_TIMING_SOURCE,
+)
+
+ROOT = Path(__file__).resolve().parents[2]
+CAMPAIGN_ARTIFACT_ROOT = (
+    ROOT / "src/pyamplicol/_profiling_campaign/campaign_artifacts"
+)
+
+
+def _parse(*arguments: str):
+    return build_parser().parse_args(arguments)
+
+
+def test_selective_retry_flags_parse_as_a_union_and_request_fresh_attempts() -> None:
+    arguments = _parse("run", "--rerun-failed", "--rerun-capped")
+
+    assert arguments.rerun_failed
+    assert arguments.rerun_capped
+    assert manual_campaign._selective_retry_requested(arguments)
+    assert manual_campaign._fresh_attempt_requested(arguments)
+
+
+def test_selective_retry_classification_is_structured_and_fail_closed(
+    tmp_path: Path,
+) -> None:
+    cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if manual_campaign._manual_static_na_reason(cell) is None
+    )[:6]
+
+    def current(
+        index: int,
+        *,
+        status: ResultStatus,
+        generation_limit: bool = False,
+        incomplete_worker_timeout: bool = False,
+    ) -> LightweightCurrent:
+        result = (
+            {"status": ResultStatus.OK.value}
+            if status is ResultStatus.OK
+            else manual_campaign.failure_measurement(status, "terminal fixture")
+        )
+        if generation_limit:
+            result["provenance"] = {
+                "manual_campaign": {"generation_limit_seconds": 3600.0}
+            }
+        if incomplete_worker_timeout:
+            result["provenance"] = {
+                "policy_censor": {"kind": "worker_timeout"}
+            }
+        return LightweightCurrent(
+            cell_id=cells[index].cell_id,
+            attempt_id=f"00000000-0000-4000-8000-00000000000{index}",
+            result_path=tmp_path / f"result-{index}.json",
+            result=result,
+            complete=True,
+            reusable=True,
+            reason="terminal fixture",
+        )
+
+    def outcome(
+        index: int,
+        status: str,
+        *,
+        attempt_id: str | None = None,
+    ) -> manual_campaign.LightweightPresentationOutcome:
+        return manual_campaign.LightweightPresentationOutcome(
+            profile="macbook_M3_manual",
+            cell_id=cells[index].cell_id,
+            source_revision="a" * 40,
+            campaign_invocation_id=f"invocation-{index}",
+            attempt_id=attempt_id,
+            status=status,
+            label=status,
+            completed_at_ns=index + 1,
+        )
+
+    ok = current(0, status=ResultStatus.OK)
+    failed = outcome(1, ResultStatus.FAILED.value)
+    unverified = outcome(2, ResultStatus.UNVERIFIED.value)
+    capped = current(3, status=ResultStatus.TIMEOUT, generation_limit=True)
+    authenticated_cap = outcome(
+        3,
+        "generation_limit",
+        attempt_id=capped.attempt_id,
+    )
+    incomplete_cap = current(
+        4,
+        status=ResultStatus.TIMEOUT,
+        incomplete_worker_timeout=True,
+    )
+    incomplete_cap_outcome = outcome(
+        4,
+        "worker_timeout",
+        attempt_id=incomplete_cap.attempt_id,
+    )
+    unauthenticated_cap_slug = outcome(
+        5,
+        "generation_limit",
+        attempt_id="00000000-0000-4000-8000-000000000099",
+    )
+
+    assert manual_campaign._selective_retry_category(ok, None) is None
+    assert manual_campaign._selective_retry_category(None, failed) == "failed"
+    assert manual_campaign._selective_retry_category(None, unverified) == "failed"
+    assert (
+        manual_campaign._selective_retry_category(capped, authenticated_cap)
+        == "capped"
+    )
+    assert (
+        manual_campaign._selective_retry_category(
+            incomplete_cap,
+            incomplete_cap_outcome,
+        )
+        == "failed"
+    )
+    assert (
+        manual_campaign._selective_retry_category(None, unauthenticated_cap_slug)
+        == "failed"
+    )
+    assert manual_campaign._selective_retry_category(None, None) is None
+
+    selected = manual_campaign._selective_retry_cells(
+        cells,
+        {
+            ok.cell_id: ok,
+            capped.cell_id: capped,
+            incomplete_cap.cell_id: incomplete_cap,
+        },
+        {
+            failed.cell_id: failed,
+            unverified.cell_id: unverified,
+            authenticated_cap.cell_id: authenticated_cap,
+            incomplete_cap_outcome.cell_id: incomplete_cap_outcome,
+            unauthenticated_cap_slug.cell_id: unauthenticated_cap_slug,
+        },
+        rerun_failed=True,
+        rerun_capped=True,
+    )
+    assert tuple(cell.cell_id for cell in selected) == tuple(
+        cell.cell_id for cell in cells[1:]
+    )
+
+
+def test_empty_selector_intersection_shows_canonical_values_and_suggestions() -> None:
+    arguments = _parse(
+        "inspect",
+        "--table",
+        "scalar_gravity",
+        "--generation-engine",
+        "recurrence",
+    )
+    with pytest.raises(ManualCampaignError) as captured:
+        selection_from_arguments(arguments)
+
+    message = str(captured.value)
+    assert "contains no catalog entries" in message
+    assert "Try removing one of --table, --generation-engine" in message
+    assert "canonical values / useful aliases" in message
+    assert "scalar_gravity" in message
+    assert "amplicol, recurrence, compiled, eager" in message
+    assert "wildcard `*`/`all`" in message
+
+
+@pytest.mark.parametrize(
+    "arguments",
+    (
+        ("run", "--generation-time-limit", "nan"),
+        ("run", "--worker-wall-limit", "inf"),
+        ("run", "--resource-sample-interval", "-inf"),
+        ("run", "--termination-grace", "nan"),
+        ("run", "--target-measurement-duration", "inf"),
+        ("refresh-pdf", "--pdf-timeout", "nan"),
+        ("dashboard-snapshot", "--stale-after", "inf"),
+    ),
+)
+def test_float_options_reject_non_finite_values(arguments: tuple[str, ...]) -> None:
+    with pytest.raises(SystemExit) as captured:
+        _parse(*arguments)
+    assert captured.value.code == 2
+
+
+def test_generation_recipe_spells_out_measurement_relevant_hyperparameters() -> None:
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+        and cell.measurement.backend == "jit"
+        and REPORT_CATALOG.static_na_reason(cell) is None
+    )
+    recipe = reproduction_recipe(
+        candidate,
+        repo_root=ROOT,
+        artifact_root=CAMPAIGN_ARTIFACT_ROOT,
+        cores=2,
+        target_runtime=0.75,
+        batch_size=32,
+        warmups=3,
+        minimum_samples=7,
+    )
+    assert recipe.generate is not None
+    generate = recipe.generate
+    expected_pairs = {
+        "--validation-samples": "1",
+        "--validation-seed": "12345",
+        "--relative-tolerance": "1e-12",
+        "--absolute-tolerance": "1e-300",
+        "--output-chunk-size": "512",
+        "--horner-iterations": "10",
+        "--cpe-iterations": "none",
+        "--max-horner-variables": "1000",
+        "--max-common-pair-cache-entries": "5000000",
+        "--max-common-pair-distance": "1000",
+        "--cpp-optimization": "O3",
+        "--cores": "2",
+        "--batch-size": "32",
+    }
+    for option, expected in expected_pairs.items():
+        assert generate[generate.index(option) + 1] == expected
+    assert "--model-cache" in generate
+    assert "--model-cache-dir" in generate
+    assert "--numerical-current-reuse" in generate
+    assert "--no-post-build-validation" in generate
+    generate_index = generate.index("generate")
+    assert parse_cli(generate[generate_index:]).resolve().effective.action == "generate"
+
+    assert recipe.profile is not None
+    profile = recipe.profile
+    for option, expected in (
+        ("--target-runtime", "0.75"),
+        ("--batch-size", "32"),
+        ("--warmup-runs", "3"),
+        ("--minimum-samples", "7"),
+        ("--precision", "16"),
+    ):
+        assert profile[profile.index(option) + 1] == expected
+    profile_index = profile.index("profile")
+    assert parse_cli(profile[profile_index:]).resolve().effective.action == "benchmark"
+
+
+def test_dry_run_recipe_blocks_cover_more_than_twenty_direct_cells() -> None:
+    cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is not ExecutionMode.AMPLICOL
+        and REPORT_CATALOG.static_na_reason(cell) is None
+    )[:21]
+    blocks = tuple(
+        manual_campaign._dry_run_recipe_blocks(
+            cells,
+            repo_root=ROOT,
+            artifact_root=CAMPAIGN_ARTIFACT_ROOT,
+            arguments=_parse("run", "--dry-run"),
+            width=120,
+        )
+    )
+    assert len(blocks) == 21
+    assert all(f"| recipe | {index}" in block for index, block in enumerate(blocks, 1))
+
+
+def test_evaluator_total_has_independent_statistics_and_semantic_colors() -> None:
+    candidate = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-full-n1-dd-z-jets-contracted"
+    )
+    baseline = manual_campaign._manual_baseline(candidate)
+    assert baseline is not None
+
+    def current(
+        cell_id: str,
+        wall: float,
+        evaluator_total: float,
+        *,
+        recurrence_core: float | None = None,
+    ) -> LightweightCurrent:
+        sample_count = 5
+        repetitions = 2
+        batch_size = 1
+        measured_points = sample_count * repetitions * batch_size
+        result = {
+            "status": ResultStatus.OK.value,
+            "wall_seconds_per_point": wall,
+            "execution_seconds_per_point": recurrence_core,
+            "sample_count": sample_count,
+            "provenance": {
+                "evaluator_total_timing": {
+                    "abi": "pyamplicol-report-evaluator-total-timing-v1",
+                    "status": "measured",
+                    "ratio_eligible": False,
+                    "raw_seconds_per_point": evaluator_total,
+                    "source": "runtime.evaluate.accumulated",
+                    "execution_mode": "recurrence",
+                    "sample_contract": (
+                        "accumulated-repeated-warmed-evaluator-total-v1"
+                    ),
+                    "sample_count": sample_count,
+                    "repetitions_per_sample": repetitions,
+                    "batch_size": batch_size,
+                    "points_per_sample": repetitions * batch_size,
+                    "measured_point_count": measured_points,
+                    "accumulated_seconds": evaluator_total * measured_points,
+                }
+            },
+        }
+        if recurrence_core is not None:
+            result["provenance"]["execution_timing"] = {
+                "abi": MEASURED_EXECUTION_TIMING_ABI,
+                "status": "measured",
+                "ratio_eligible": True,
+                "raw_seconds_per_point": recurrence_core,
+                "source": RECURRENCE_EXECUTION_TIMING_SOURCE,
+                "compiled_direct_arena_active": False,
+                "sample_count": sample_count,
+                "native_profile_points_per_sample": repetitions * batch_size,
+                "sample_contract": PAIRED_TIMING_SAMPLE_CONTRACT,
+            }
+        return LightweightCurrent(
+            cell_id=cell_id,
+            attempt_id=f"attempt-{cell_id}",
+            result_path=ROOT / "unused-result.json",
+            result=result,
+            complete=True,
+            reusable=True,
+            reason="reusable",
+        )
+
+    summary, exclusions = manual_campaign._inspect_metric(
+        (candidate,),
+        {
+            candidate.cell_id: current(candidate.cell_id, 2.0, 4.0),
+            baseline.cell_id: current(baseline.cell_id, 1.0, 2.0),
+        },
+        field=None,
+        generation=False,
+        evaluator_total=True,
+    )
+    assert exclusions == {}
+    assert summary["count"] == 1
+    assert summary["median"] == pytest.approx(2.0)
+    assert summary["weighted_mean"] == pytest.approx(2.0)
+
+    palette = Palette(enabled=True)
+    assert Fore.GREEN in manual_campaign._paint_multiplier(palette, 0.9)
+    assert Fore.RED in manual_campaign._paint_multiplier(palette, 1.1)
+    assert "\x1b[" not in manual_campaign._paint_multiplier(palette, 1.0)
+
+    malformed = current(candidate.cell_id, 2.0, 4.0)
+    malformed_total = malformed.result["provenance"]["evaluator_total_timing"]
+    assert isinstance(malformed_total, dict)
+    malformed_total["accumulated_seconds"] = 99.0
+    assert manual_campaign._evaluator_total_number(malformed.result) is None
+
+    other = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.cell_id != candidate.cell_id
+    )
+    core_summary, core_exclusions = manual_campaign._inspect_recurrence_core(
+        (candidate, other),
+        {
+            candidate.cell_id: current(
+                candidate.cell_id,
+                2.0,
+                4.0,
+                recurrence_core=4.0e-6,
+            ),
+            other.cell_id: current(
+                other.cell_id,
+                3.0,
+                6.0,
+                recurrence_core=2.0e-6,
+            ),
+        },
+    )
+    assert core_exclusions == {}
+    assert core_summary["count"] == 2
+    assert core_summary["median_seconds_per_point"] == pytest.approx(3.0e-6)
+    assert core_summary["mean_seconds_per_point"] == pytest.approx(3.0e-6)
+    fastest = core_summary["fastest"]
+    slowest = core_summary["slowest"]
+    assert isinstance(fastest, dict)
+    assert isinstance(slowest, dict)
+    assert fastest["cell_id"] == other.cell_id
+    assert fastest["seconds_per_point"] == pytest.approx(2.0e-6)
+    assert slowest["cell_id"] == candidate.cell_id
+    assert slowest["seconds_per_point"] == pytest.approx(4.0e-6)
+    assert "multiplier" not in fastest
diff --git a/pyamplicol/tests/unit/test_manual_campaign_entrypoint.py b/pyamplicol/tests/unit/test_manual_campaign_entrypoint.py
new file mode 100644
index 0000000000..bb91ce85ca
--- /dev/null
+++ b/pyamplicol/tests/unit/test_manual_campaign_entrypoint.py
@@ -0,0 +1,223 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import runpy
+import sys
+from collections.abc import Callable
+from pathlib import Path
+from typing import cast
+
+import pytest
+
+import tools.performance_report.manual_campaign as manual_campaign
+
+ROOT = Path(__file__).resolve().parents[2]
+ENTRYPOINT = (
+    ROOT / "src/pyamplicol/_profiling_campaign/steer_performance_campaign.py"
+)
+
+
+def _entrypoint_namespace() -> dict[str, object]:
+    return runpy.run_path(
+        str(ENTRYPOINT),
+        run_name="manual_campaign_entrypoint_test",
+    )
+
+
+def test_campaign_profile_is_derived_from_copied_directory_name() -> None:
+    derive = cast(
+        Callable[[Path, Path], str],
+        _entrypoint_namespace()["_embedded_profile"],
+    )
+    copied = (
+        ROOT
+        / "docs/performance_reports/another_macbook_campaign"
+        / "steer_performance_campaign.py"
+    )
+
+    assert derive(copied, ROOT) == "another_macbook_campaign"
+
+
+def test_campaign_entrypoint_rejects_nested_non_profile_directory() -> None:
+    derive = cast(
+        Callable[[Path, Path], str],
+        _entrypoint_namespace()["_embedded_profile"],
+    )
+    nested = (
+        ROOT
+        / "docs/performance_reports/campaign/archive"
+        / "steer_performance_campaign.py"
+    )
+
+    with pytest.raises(RuntimeError, match="directly inside"):
+        derive(nested, ROOT)
+
+
+def test_campaign_entrypoint_passes_copied_profile_to_controller(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    namespace = _entrypoint_namespace()
+    copied = (
+        ROOT
+        / "docs/performance_reports/independent_campaign"
+        / "steer_performance_campaign.py"
+    )
+    entrypoint_main = cast(Callable[[], int], namespace["main"])
+    entrypoint_main.__globals__["__file__"] = str(copied)
+    entrypoint_main.__globals__["_reexecute_with_repository_python"] = (
+        lambda _root, _entrypoint: None
+    )
+    observed: dict[str, object] = {}
+
+    def fake_campaign_main(
+        arguments: list[str],
+        *,
+        repo_root: Path,
+        profile: str,
+        docs_dir: Path,
+        launcher_path_checked: bool,
+    ) -> int:
+        observed.update(
+            arguments=arguments,
+            repo_root=repo_root,
+            profile=profile,
+            docs_dir=docs_dir,
+            launcher_path_checked=launcher_path_checked,
+        )
+        return 17
+
+    monkeypatch.setattr(manual_campaign, "main", fake_campaign_main)
+    monkeypatch.setattr(sys, "argv", [str(copied), "inspect"])
+
+    assert entrypoint_main() == 17
+    assert observed == {
+        "arguments": ["inspect"],
+        "repo_root": ROOT,
+        "profile": "independent_campaign",
+        "docs_dir": copied.parent,
+        "launcher_path_checked": True,
+    }
+
+
+def test_installed_campaign_entrypoint_passes_its_directory_to_controller(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    namespace = _entrypoint_namespace()
+    copied = tmp_path / "independent_campaign" / "steer_performance_campaign.py"
+    copied.parent.mkdir()
+    entrypoint_main = cast(Callable[[], int], namespace["main"])
+    entrypoint_main.__globals__["__file__"] = str(copied)
+    observed: dict[str, object] = {}
+
+    class InstalledController:
+        @staticmethod
+        def main(
+            arguments: list[str],
+            *,
+            repo_root: Path,
+            profile: str,
+            docs_dir: Path,
+            installed: bool,
+            launcher_path_checked: bool,
+        ) -> int:
+            observed.update(
+                arguments=arguments,
+                repo_root=repo_root,
+                profile=profile,
+                docs_dir=docs_dir,
+                installed=installed,
+                launcher_path_checked=launcher_path_checked,
+            )
+            return 19
+
+    entrypoint_main.__globals__["import_module"] = lambda _name: InstalledController
+    monkeypatch.setattr(sys, "argv", [str(copied), "inspect"])
+
+    assert entrypoint_main() == 19
+    assert observed == {
+        "arguments": ["inspect"],
+        "repo_root": copied.parent,
+        "profile": "independent_campaign",
+        "docs_dir": copied.parent,
+        "installed": True,
+        "launcher_path_checked": True,
+    }
+
+
+@pytest.mark.parametrize("pwd_state", ("unset", "renamed-away", "recreated"))
+def test_relative_campaign_entrypoint_rejects_stale_pwd_after_move(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    pwd_state: str,
+) -> None:
+    namespace = _entrypoint_namespace()
+    original = tmp_path / "campaign"
+    original.mkdir()
+    moved = tmp_path / "renamed-campaign"
+    original.rename(moved)
+    if pwd_state == "recreated":
+        original.mkdir()
+    monkeypatch.chdir(moved)
+    if pwd_state == "unset":
+        monkeypatch.delenv("PWD", raising=False)
+    else:
+        monkeypatch.setenv("PWD", str(original))
+    monkeypatch.setattr(sys, "argv", ["./steer_performance_campaign.py", "inspect"])
+    entrypoint_main = cast(Callable[[], int], namespace["main"])
+    entrypoint_main.__globals__["__file__"] = str(
+        moved / "steer_performance_campaign.py"
+    )
+    entrypoint_main.__globals__["import_module"] = lambda _name: pytest.fail(
+        "stale relative launcher reached the campaign controller"
+    )
+
+    assert entrypoint_main() == 2
+    assert "cd .." in capsys.readouterr().err
+
+
+def test_source_launcher_preserves_symlinked_campaign_path_for_rejection(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    namespace = _entrypoint_namespace()
+    fake_repo = tmp_path / "checkout"
+    (fake_repo / "tools/performance_report").mkdir(parents=True)
+    (fake_repo / "src/pyamplicol").mkdir(parents=True)
+    profile_parent = fake_repo / "docs/performance_reports"
+    profile_parent.mkdir(parents=True)
+    actual = tmp_path / "actual-campaign"
+    actual.mkdir()
+    linked = profile_parent / "linked-campaign"
+    linked.symlink_to(actual, target_is_directory=True)
+    monkeypatch.chdir(actual)
+    monkeypatch.setenv("PWD", str(linked))
+    entrypoint_main = cast(Callable[[], int], namespace["main"])
+    entrypoint_main.__globals__["__file__"] = "./steer_performance_campaign.py"
+    entrypoint_main.__globals__["_reexecute_with_repository_python"] = (
+        lambda _root, _entrypoint: None
+    )
+
+    def rejecting_campaign_main(
+        _arguments: list[str],
+        *,
+        repo_root: Path,
+        profile: str,
+        docs_dir: Path,
+        launcher_path_checked: bool,
+    ) -> int:
+        assert profile == "linked-campaign"
+        assert docs_dir == linked
+        assert launcher_path_checked is True
+        with pytest.raises(
+            manual_campaign.ManualCampaignError,
+            match="symbolic link",
+        ):
+            manual_campaign._campaign_report_paths(repo_root, docs_dir)
+        return 23
+
+    monkeypatch.setattr(manual_campaign, "main", rejecting_campaign_main)
+    monkeypatch.setattr(sys, "argv", ["./steer_performance_campaign.py", "inspect"])
+
+    assert entrypoint_main() == 23
diff --git a/pyamplicol/tests/unit/test_manual_campaign_interrupts.py b/pyamplicol/tests/unit/test_manual_campaign_interrupts.py
new file mode 100644
index 0000000000..35d1c43117
--- /dev/null
+++ b/pyamplicol/tests/unit/test_manual_campaign_interrupts.py
@@ -0,0 +1,491 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import io
+import json
+import threading
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+import tools.performance_report.manual_campaign as manual_campaign
+from tools.performance_report.agreements import DIRECT_AGREEMENT_FIELD
+from tools.performance_report.cache import empty_measurement
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import ArtifactPolicy, ResultStatus
+from tools.performance_report.resources import (
+    GenerationPhaseEvidence,
+    ResourceUsage,
+    SupervisedResult,
+)
+from tools.performance_report.scheduler import (
+    CampaignScheduler,
+    CampaignSettings,
+    PlannedCell,
+)
+from tools.performance_report.service import ReportPaths, ReportService
+from tools.performance_report.source_identity import ReportSourceIdentity
+
+
+def _service(tmp_path: Path) -> ReportService:
+    root = tmp_path / "repo"
+    (root / "docs/arxiv").mkdir(parents=True)
+    return ReportService(
+        ReportPaths.from_repo(
+            root,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+
+
+def _source() -> ReportSourceIdentity:
+    return ReportSourceIdentity("a" * 40, "b" * 40, ())
+
+
+def _cell():
+    return REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+
+
+def _completed_measurement(
+    source: ReportSourceIdentity,
+) -> dict[str, object]:
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": ResultStatus.OK.value,
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 8.0e-7,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 0.0,
+            "relative_standard_error": 0.0,
+            "artifact": {},
+            "validation": {
+                "status": ResultStatus.OK.value,
+                DIRECT_AGREEMENT_FIELD: [],
+            },
+            "resources": {},
+            "provenance": source.provenance(),
+        }
+    )
+    return measurement
+
+
+def _publish_completed_current(
+    service: ReportService,
+    source: ReportSourceIdentity,
+):
+    return service.store.new_attempt(
+        _cell().cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(_completed_measurement(source))
+
+
+def _planned() -> PlannedCell:
+    return PlannedCell(
+        _cell(),
+        dependency=False,
+        baseline_cell_id=None,
+        rank=0,
+    )
+
+
+def test_queued_cancellation_creates_no_failed_attempt_and_preserves_current(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    source = _source()
+    current = _publish_completed_current(service, source)
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            artifact_policy=ArtifactPolicy.REGENERATE,
+            source_identity_override=source,
+            cancellation_requested=lambda: True,
+        ),
+    )
+
+    outcome = scheduler._run_cell(_planned())
+
+    assert outcome.status == "cancelled"
+    assert outcome.detail == "not started"
+    assert service.store.load_current(_cell().cell_id).attempt_id == current.attempt_id
+    attempts = tuple(
+        service.store._cell_root(_cell().cell_id).joinpath("attempts").iterdir()
+    )
+    assert tuple(path.name for path in attempts) == (current.attempt_id,)
+
+
+@pytest.mark.parametrize(
+    ("phase", "final_phase"),
+    (
+        ("generation", "generation"),
+        ("profiling", "post-generation"),
+    ),
+)
+def test_running_cancellation_is_interrupted_history_and_preserves_current(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    phase: str,
+    final_phase: str,
+) -> None:
+    service = _service(tmp_path)
+    source = _source()
+    current = _publish_completed_current(service, source)
+    cancellation = threading.Event()
+
+    def cancelled_worker(
+        _command: object,
+        **arguments: object,
+    ) -> SupervisedResult:
+        callback = arguments["cancellation_requested"]
+        assert callable(callback)
+        cancellation.set()
+        assert callback()
+        return SupervisedResult(
+            -15,
+            "cancelled",
+            ResourceUsage(True, 0, 0, 0, 0.0, 0.1),
+            GenerationPhaseEvidence(
+                configured_timeout_seconds=3600.0,
+                supervisor_reason="cancelled",
+                authenticated=True,
+                run_id=f"{phase}-run",
+                worker_pid=123,
+                final_sequence=2,
+                final_phase=final_phase,
+                generation_started_monotonic_ns=1,
+                generation_finished_monotonic_ns=2,
+                generation_elapsed_seconds=1.0,
+                final_state_sha256="c" * 64,
+            ),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        cancelled_worker,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            artifact_policy=ArtifactPolicy.REGENERATE,
+            source_identity_override=source,
+            cancellation_requested=cancellation.is_set,
+            generation_time_limit_seconds=3600.0,
+        ),
+    )
+
+    outcome = scheduler._run_cell(_planned())
+
+    assert outcome.status == "cancelled"
+    assert outcome.detail == "previous valid current preserved"
+    assert service.store.load_current(_cell().cell_id).attempt_id == current.attempt_id
+    attempt_root = service.store._cell_root(_cell().cell_id) / "attempts"
+    manifests = {
+        path.parent.name: json.loads(path.read_text(encoding="ascii"))
+        for path in attempt_root.glob("*/manifest.json")
+    }
+    assert manifests[current.attempt_id]["status"] == "ok"
+    history_root = service.store._attempt_history_cell_root(_cell().cell_id)
+    archived = {
+        path.parent.name: json.loads(path.read_text(encoding="ascii"))
+        for path in history_root.glob("*/manifest.json")
+    }
+    assert len(archived) == 1
+    manifest = next(iter(archived.values()))
+    assert manifest["status"] == "interrupted"
+    assert manifest["result_path"] is None
+    assert manifest["error"] == "worker terminated by cancellation"
+    assert manifest["based_on"]["attempt_id"] == current.attempt_id
+    assert {path.parent.name for path in attempt_root.glob("*/result.json")} == {
+        current.attempt_id
+    }
+
+
+def test_manual_legacy_cancellation_discards_isolated_attempt(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    source = _source()
+    cell = REPORT_CATALOG.cell("reference-amplicol-full-n1-dd-z-jets-contracted")
+    source_repository = tmp_path / "original-amplicol"
+    source_repository.mkdir()
+    workspaces: list[Path] = []
+
+    def workspace_paths(
+        _scheduler: CampaignScheduler,
+        attempt_id: str,
+    ) -> tuple[Path, Path]:
+        workspace = tmp_path / "legacy-workspaces" / attempt_id
+        workspaces.append(workspace)
+        return source_repository, workspace
+
+    def cancelled_worker(
+        command: list[str],
+        **_arguments: object,
+    ) -> SupervisedResult:
+        source_option = command.index("--legacy-source-repository")
+        workspace_option = command.index("--legacy-workspace")
+        assert Path(command[source_option + 1]) == source_repository
+        assert Path(command[workspace_option + 1]) == workspaces[0]
+        assert "--legacy-copy-source" in command
+        # Workspace preparation has moved into this supervised subprocess;
+        # the controller must not copy or lock the source before supervision.
+        assert not workspaces[0].exists()
+        workspaces[0].mkdir(parents=True)
+        return SupervisedResult(
+            -15,
+            "cancelled",
+            ResourceUsage(True, 0, 0, 0, 0.0, 0.1),
+            GenerationPhaseEvidence(
+                configured_timeout_seconds=3600.0,
+                supervisor_reason="cancelled",
+                authenticated=True,
+                run_id="manual-legacy-run",
+                worker_pid=123,
+                final_sequence=1,
+                final_phase="generation",
+                generation_started_monotonic_ns=1,
+                generation_finished_monotonic_ns=None,
+                generation_elapsed_seconds=0.1,
+                final_state_sha256="d" * 64,
+            ),
+        )
+
+    monkeypatch.setattr(
+        CampaignScheduler,
+        "_legacy_workspace_paths",
+        workspace_paths,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        cancelled_worker,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            artifact_policy=ArtifactPolicy.REGENERATE,
+            source_identity_override=source,
+            generation_time_limit_seconds=3600.0,
+            manual_terminal_censors=True,
+            discard_cancelled_attempts=True,
+        ),
+    )
+
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            cell,
+            dependency=False,
+            baseline_cell_id=None,
+            rank=0,
+        )
+    )
+
+    assert outcome.status == "cancelled"
+    assert outcome.detail == "incomplete attempt discarded"
+    assert len(workspaces) == 1 and not workspaces[0].exists()
+    assert service.store.cell_attempt_ids(cell.cell_id) == ()
+
+
+def test_closed_lease_cannot_be_recreated_by_late_worker_event(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    source = _source()
+    monkeypatch.setattr(
+        manual_campaign,
+        "_repo_head",
+        lambda _repo_root: source.revision,
+    )
+    state = manual_campaign.DashboardState(
+        instance_id="interrupt-cleanup",
+        selected_ids=(_cell().cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision=source.revision,
+    )
+    lease = manual_campaign.LeaseManager(service, state)
+    lease.publish()
+    assert lease.path.is_file()
+
+    lease.close()
+    lease.observe(
+        {
+            "event": "started",
+            "cell_id": _cell().cell_id,
+        }
+    )
+    lease.publish()
+
+    assert not lease.path.exists()
+
+
+def test_repeated_keyboard_interrupt_waits_for_cleanup_before_closing_lease(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    events: list[str] = []
+    cancelled_callbacks: list[object] = []
+    leases: list[object] = []
+    threads: list[object] = []
+
+    class Tty(io.StringIO):
+        def isatty(self) -> bool:
+            return True
+
+    class FakeLease:
+        def __init__(self, _service: object, _state: object) -> None:
+            self.closed = False
+            leases.append(self)
+
+        def publish(self) -> None:
+            events.append("lease-published")
+
+        def observe(self, _payload: object) -> None:
+            return None
+
+        def close(self) -> None:
+            assert threads and not threads[0].is_alive()
+            self.closed = True
+            events.append("lease-closed")
+
+    class FakeThread:
+        def __init__(self, **_arguments: object) -> None:
+            self.join_timeouts: list[float | None] = []
+            self.alive = True
+            threads.append(self)
+
+        def start(self) -> None:
+            events.append("worker-started")
+
+        def join(self, timeout: float | None = None) -> None:
+            self.join_timeouts.append(timeout)
+            if len(self.join_timeouts) == 1:
+                events.append("join-interrupted")
+                raise KeyboardInterrupt
+            if len(self.join_timeouts) == 2:
+                events.append("cleanup-delayed")
+            if len(self.join_timeouts) == 22:
+                self.alive = False
+                events.append("cleanup-finished")
+
+        def is_alive(self) -> bool:
+            return self.alive
+
+    class FakeScheduler:
+        def __init__(self, _service: object, *, settings: object) -> None:
+            del settings
+
+        def run(self, _planned: object) -> None:
+            raise AssertionError("fake controller thread must not execute")
+
+    def settings(
+        _arguments: object,
+        _source: object,
+        *,
+        original_amplicol_available: bool = False,
+        observer: object = None,
+        cancelled: object = None,
+        campaign_invocation_id: str | None = None,
+    ) -> object:
+        del observer, original_amplicol_available
+        if cancelled is not None:
+            assert campaign_invocation_id
+            cancelled_callbacks.append(cancelled)
+        return SimpleNamespace(effective_cell_rss_limit=lambda: 30_000_000_000)
+
+    def dashboard(*_arguments: object, **_keywords: object) -> None:
+        del _keywords
+        try:
+            raise KeyboardInterrupt
+        finally:
+            events.append("terminal-restored")
+
+    monkeypatch.setattr(manual_campaign, "lightweight_currents", lambda *_a, **_k: {})
+    monkeypatch.setattr(
+        manual_campaign,
+        "plan_campaign",
+        lambda *_a, **_k: (_planned(),),
+    )
+    monkeypatch.setattr(manual_campaign, "require_measurement_ready", lambda _s: None)
+    monkeypatch.setattr(manual_campaign, "update_source_marker", lambda *_a: False)
+    monkeypatch.setattr(
+        manual_campaign,
+        "_bind_original_amplicol_if_required",
+        lambda *_a, **_k: None,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "reconcile_attempt_history",
+        lambda *_a, **_k: (),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_publish_campaign_summary_ids",
+        lambda *_a, **_k: (tmp_path / "campaign_summary_ids", {}),
+    )
+    monkeypatch.setattr(manual_campaign, "_campaign_settings", settings)
+    monkeypatch.setattr(manual_campaign, "CampaignScheduler", FakeScheduler)
+    monkeypatch.setattr(manual_campaign, "LeaseManager", FakeLease)
+    monkeypatch.setattr(manual_campaign.threading, "Thread", FakeThread)
+    monkeypatch.setattr(manual_campaign, "_run_live_dashboard", dashboard)
+    monkeypatch.setattr(manual_campaign.sys, "stdin", Tty())
+    monkeypatch.setattr(manual_campaign.sys, "stdout", Tty())
+    stderr = Tty()
+    monkeypatch.setattr(manual_campaign.sys, "stderr", stderr)
+    arguments = SimpleNamespace(
+        force_refresh=False,
+        dry_run=False,
+        no_dashboard=False,
+        generation_time_limit=3600.0,
+        ram_limit=30_000_000_000,
+        worker_wall_limit=None,
+        cores_per_worker=1,
+        target_measurement_duration=0.1,
+        batch_size=1,
+            warmups=0,
+            minimum_samples=5,
+            termination_grace=0.01,
+            cleanup_artifacts=False,
+            original_amplicol=None,
+            madgraph=None,
+        )
+    service = SimpleNamespace(
+        store=object(),
+        paths=SimpleNamespace(docs_dir=tmp_path, artifact_root=tmp_path / "artifacts"),
+        catalog=REPORT_CATALOG,
+    )
+
+    result = manual_campaign._run_campaign(
+        arguments,
+        repo_root=tmp_path,
+        service=service,
+        source=_source(),
+        cells=(_cell(),),
+        palette=manual_campaign.Palette(False),
+    )
+
+    assert result == 130
+    assert len(cancelled_callbacks) == 1
+    callback = cancelled_callbacks[0]
+    assert callable(callback) and callback()
+    assert len(threads) == 1
+    thread = threads[0]
+    assert thread.join_timeouts == [0.25] * 22
+    assert len(leases) == 1 and leases[0].closed
+    assert events == [
+        "lease-published",
+        "worker-started",
+        "terminal-restored",
+        "join-interrupted",
+        "cleanup-delayed",
+        "cleanup-finished",
+        "lease-closed",
+    ]
+    assert "still waiting for supervised worker-tree cleanup" in stderr.getvalue()
+    assert "no leases or claims will be released early" in stderr.getvalue()
diff --git a/pyamplicol/tests/unit/test_manual_campaign_lightweight_reuse.py b/pyamplicol/tests/unit/test_manual_campaign_lightweight_reuse.py
new file mode 100644
index 0000000000..48760d0134
--- /dev/null
+++ b/pyamplicol/tests/unit/test_manual_campaign_lightweight_reuse.py
@@ -0,0 +1,1718 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import builtins
+import hashlib
+import json
+import os
+import struct
+import subprocess
+import uuid
+import zlib
+from collections.abc import Mapping
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report import manual_campaign
+from tools.performance_report.agreements import DIRECT_AGREEMENT_FIELD
+from tools.performance_report.artifacts import (
+    ATTEMPT_SCHEMA,
+    CURRENT_SCHEMA,
+    ArtifactStore,
+    ManifestValidationError,
+)
+from tools.performance_report.cache import digest_json, empty_measurement
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.manual_campaign import (
+    Palette,
+    _index_metadata_dirty_paths,
+    _run_campaign,
+    build_parser,
+    lightweight_current,
+)
+from tools.performance_report.measurement import failure_measurement, load_measurement
+from tools.performance_report.models import (
+    Accuracy,
+    ArtifactPolicy,
+    CellSpec,
+    ExecutionMode,
+    ResultStatus,
+    Workload,
+)
+from tools.performance_report.runner import pointwise_validation
+from tools.performance_report.scheduler import CampaignSettings, plan_campaign
+from tools.performance_report.service import ReportPaths, ReportService
+from tools.performance_report.source_identity import ReportSourceIdentity
+from tools.performance_report.worker import _portable_current_paths
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def _recurrence_validation(cell: CellSpec) -> dict[str, object]:
+    point_digest = "a" * 64
+    ordering = "b" * 64
+
+    def resolved(precision: int, source: str) -> dict[str, object]:
+        point = pointwise_validation(
+            1.0,
+            1.0,
+            candidate_scale=1.0,
+            baseline_scale=1.0,
+            comparison_binding={
+                "abi": "pyamplicol-report-resolved-component-scale-v1",
+                "point_digest": point_digest,
+                "helicity_ids": [],
+                "color_flow_ids": [],
+                "resolved_ordering_sha256": ordering,
+                "resolved_source_sha256": source,
+                "point_index": 0,
+            },
+        )
+        return {
+            "abi": "pyamplicol-report-resolved-sum-validation-v2",
+            "status": ResultStatus.OK.value,
+            "maximum_absolute_difference": 0.0,
+            "maximum_relative_difference": 0.0,
+            "maximum_conditioned_residual": 0.0,
+            "relative_tolerance": 1.0e-12,
+            "point_digest": point_digest,
+            "helicity_ids": [],
+            "color_flow_ids": [],
+            "resolved_ordering_sha256": ordering,
+            "resolved_source_sha256": source,
+            "scale_source": "resolved-component-l1",
+            "precision_digits": precision,
+            "points": [point],
+        }
+
+    binary64 = resolved(16, "c" * 64)
+    precision32 = resolved(32, "d" * 64)
+    selector_identity = {
+        "cell_id": cell.cell_id,
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+        "selector_contract": None,
+        "value_kind": "matrix-element-p16-versus-p32",
+    }
+    return {
+        "status": ResultStatus.OK.value,
+        DIRECT_AGREEMENT_FIELD: [],
+        "resolved_sum": binary64,
+        "high_precision_resolved_sum": precision32,
+        "high_precision": pointwise_validation(
+            1.0,
+            1.0,
+            candidate_scale=1.0,
+            baseline_scale=1.0,
+            candidate_scale_source="resolved-component-l1-binary64",
+            baseline_scale_source="resolved-component-l1-p32",
+            comparison_binding={
+                "point_digest": point_digest,
+                "selector_component_identity": selector_identity,
+                "selector_component_sha256": digest_json(selector_identity),
+                "candidate_source_sha256": "c" * 64,
+                "baseline_source_sha256": "d" * 64,
+            },
+        ),
+    }
+
+
+def _cell_identity(cell: CellSpec) -> dict[str, object]:
+    return {
+        "cell_id": cell.cell_id,
+        "dataset_id": cell.dataset_id,
+        "process_key": cell.process_key,
+        "process": cell.process,
+        "n_final": cell.n_final,
+        "workload": cell.workload.value,
+        "execution_mode": cell.measurement.execution_mode.value,
+        "model": (
+            None if cell.measurement.model is None else cell.measurement.model.value
+        ),
+        "accuracy": cell.measurement.accuracy.value,
+        "backend": cell.measurement.backend,
+        "variant": cell.variant,
+    }
+
+
+def _amplicol_leaf_cell() -> CellSpec:
+    return next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        and cell.workload is Workload.SELECTED_FLOW
+        and cell.n_final == 1
+    )
+
+
+def _amplicol_contracted_cell() -> CellSpec:
+    return next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        and cell.measurement.accuracy is Accuracy.NLC
+        and cell.workload is Workload.CONTRACTED
+        and cell.n_final == 1
+    )
+
+
+def _pyamplicol_leaf_cell() -> CellSpec:
+    return next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.n_final == 1
+    )
+
+
+def _write_lightweight_terminal_current(
+    service: ReportService,
+    cell: CellSpec,
+    *,
+    revision: str,
+    extra_provenance: Mapping[str, object] | None = None,
+) -> tuple[Path, Path]:
+    attempt_id = str(uuid.uuid4())
+    attempt_root = service.store._cell_root(cell.cell_id) / "attempts" / attempt_id
+    attempt_root.mkdir(parents=True)
+    result = failure_measurement(ResultStatus.TIMEOUT, "generation cap")
+    result["provenance"] = {
+        "report_source_revision": revision,
+        "manual_campaign": {"cell_identity": _cell_identity(cell)},
+        **({} if extra_provenance is None else dict(extra_provenance)),
+    }
+    result_path = attempt_root / "result.json"
+    result_path.write_text(json.dumps(result), encoding="utf-8")
+    manifest = {
+        "schema": ATTEMPT_SCHEMA,
+        "cell_id": cell.cell_id,
+        "attempt_id": attempt_id,
+        "status": "ok",
+        "artifact_policy": ArtifactPolicy.REUSE.value,
+        "based_on": None,
+        "result_path": "result.json",
+        "artifacts": [
+            {
+                "path": "result.json",
+                "size": result_path.stat().st_size,
+                "sha256": "0" * 64,
+            }
+        ],
+        "error": None,
+    }
+    manifest_path = attempt_root / "manifest.json"
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    pointer = {
+        "schema": CURRENT_SCHEMA,
+        "cell_id": cell.cell_id,
+        "attempt_id": attempt_id,
+        "manifest_path": f"attempts/{attempt_id}/manifest.json",
+        "manifest_sha256": "1" * 64,
+    }
+    pointer_path = service.store._cell_root(cell.cell_id) / "current.json"
+    pointer_path.write_text(json.dumps(pointer), encoding="utf-8")
+    return manifest_path, result_path
+
+
+def _write_lightweight_success_current(
+    service: ReportService,
+    cell: CellSpec,
+    *,
+    revision: str,
+    numerical_relation_correctness: Mapping[str, object],
+) -> tuple[Path, Path]:
+    attempt_id = str(uuid.uuid4())
+    attempt_root = service.store._cell_root(cell.cell_id) / "attempts" / attempt_id
+    artifact_root = attempt_root / "artifact"
+    artifact_root.mkdir(parents=True)
+    (artifact_root / "artifact.json").write_text("{}\n", encoding="ascii")
+    result = empty_measurement()
+    result.update(
+        {
+            "status": ResultStatus.OK.value,
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 8.0e-7,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 0.0,
+            "relative_standard_error": 0.0,
+            "artifact": {
+                "path": str(artifact_root),
+                "process_id": cell.process,
+            },
+            "validation": (
+                _recurrence_validation(cell)
+                if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+                and cell.measurement.accuracy is not Accuracy.LC
+                else {
+                    "status": ResultStatus.OK.value,
+                    DIRECT_AGREEMENT_FIELD: [],
+                }
+            ),
+            "resources": {},
+            "provenance": {
+                "report_source_revision": revision,
+                "manual_campaign": {"cell_identity": _cell_identity(cell)},
+                "numerical_relation_correctness": dict(numerical_relation_correctness),
+            },
+        }
+    )
+    result_path = attempt_root / "result.json"
+    result_path.write_text(json.dumps(result), encoding="utf-8")
+    manifest = {
+        "schema": ATTEMPT_SCHEMA,
+        "cell_id": cell.cell_id,
+        "attempt_id": attempt_id,
+        "status": "ok",
+        "artifact_policy": ArtifactPolicy.REUSE.value,
+        "based_on": None,
+        "result_path": "result.json",
+        "artifacts": [
+            {
+                "path": "result.json",
+                "size": result_path.stat().st_size,
+                "sha256": "0" * 64,
+            }
+        ],
+        "error": None,
+    }
+    manifest_path = attempt_root / "manifest.json"
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    pointer = {
+        "schema": CURRENT_SCHEMA,
+        "cell_id": cell.cell_id,
+        "attempt_id": attempt_id,
+        "manifest_path": f"attempts/{attempt_id}/manifest.json",
+        "manifest_sha256": "1" * 64,
+    }
+    pointer_path = service.store._cell_root(cell.cell_id) / "current.json"
+    pointer_path.write_text(json.dumps(pointer), encoding="utf-8")
+    return manifest_path, result_path
+
+
+def _portable_manual_service(campaign: Path) -> ReportService:
+    campaign = campaign.expanduser().resolve(strict=False)
+    state = campaign / "campaign_artifacts"
+    paths = ReportPaths(
+        repo_root=ROOT,
+        docs_dir=campaign,
+        results_dir=campaign / "results",
+        artifact_root=state,
+        coordination_root=state / "coordination",
+    )
+    return ReportService(paths, portable_current_results=True)
+
+
+def _isolated_manual_service(root: Path) -> ReportService:
+    return ReportService(
+        ReportPaths(
+            repo_root=ROOT,
+            docs_dir=root / "docs",
+            results_dir=root / "results",
+            artifact_root=root / "artifacts",
+            coordination_root=root / "coordination",
+        )
+    )
+
+
+def _presentation_outcome(
+    cell: CellSpec,
+    *,
+    revision: str,
+    status: str = ResultStatus.FAILED.value,
+) -> manual_campaign.LightweightPresentationOutcome:
+    return manual_campaign.LightweightPresentationOutcome(
+        profile="macbook_M3_manual",
+        cell_id=cell.cell_id,
+        source_revision=revision,
+        campaign_invocation_id="selective-retry-fixture",
+        attempt_id=None,
+        status=status,
+        label=status,
+        completed_at_ns=1,
+    )
+
+
+def _publish_success_current(
+    service: ReportService,
+    cell: CellSpec,
+    *,
+    revision: str,
+) -> None:
+    attempt = service.store.new_attempt(cell.cell_id, ArtifactPolicy.REGENERATE)
+    artifact = attempt.path("artifact")
+    artifact.mkdir()
+    (artifact / "artifact.json").write_text("{}\n", encoding="ascii")
+    result = empty_measurement()
+    result.update(
+        {
+            "status": ResultStatus.OK.value,
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 8.0e-7,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 0.0,
+            "relative_standard_error": 0.0,
+            "artifact": {"path": str(artifact), "process_id": cell.process},
+            "validation": (
+                _recurrence_validation(cell)
+                if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+                and cell.measurement.accuracy is not Accuracy.LC
+                else {
+                    "status": ResultStatus.OK.value,
+                    DIRECT_AGREEMENT_FIELD: [],
+                }
+            ),
+            "resources": {},
+            "provenance": {
+                "report_source_revision": revision,
+                "manual_campaign": {
+                    "cell_identity": _cell_identity(cell),
+                    "public_cli_reproduction": manual_campaign.reproduction_recipe(
+                        cell,
+                        repo_root=service.paths.repo_root,
+                        artifact_root=service.paths.artifact_root,
+                    ).as_dict(),
+                },
+                "numerical_relation_correctness": {},
+            },
+        }
+    )
+    attempt.publish(result, artifact_paths=("artifact/artifact.json",))
+
+
+def test_manual_current_reuse_survives_whole_campaign_move(
+    tmp_path: Path,
+) -> None:
+    revision = "b" * 40
+    recurrence = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.cell_id
+        == "matrix-recurrence-builtin-sm-full-n1-dd-z-jets-contracted"
+    )
+    compiled = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.cell_id
+        == "matrix-compiled-builtin-sm-full-n1-dd-z-jets-contracted"
+    )
+    campaign_a = tmp_path / "parent-a" / "campaign-a"
+    service_a = _portable_manual_service(campaign_a)
+    _publish_success_current(service_a, recurrence, revision=revision)
+
+    campaign_b = tmp_path / "other-parent" / "renamed-campaign"
+    campaign_b.parent.mkdir()
+    campaign_a.rename(campaign_b)
+    service_b = _portable_manual_service(campaign_b)
+    state_b = campaign_b / "campaign_artifacts"
+
+    full = service_b.store.load_current(recurrence.cell_id)
+    lightweight = lightweight_current(
+        service_b.store,
+        recurrence,
+        source_revision=revision,
+    )
+    assert full is not None
+    assert lightweight is not None and lightweight.reusable
+    assert Path(str(full.result["artifact"]["path"])).is_relative_to(state_b)
+    assert Path(str(lightweight.result["artifact"]["path"])).is_relative_to(state_b)
+    portable_recipe = lightweight.result["provenance"]["manual_campaign"][
+        "public_cli_reproduction"
+    ]
+    assert isinstance(portable_recipe["generate"], list)
+    assert any(str(state_b) in argument for argument in portable_recipe["generate"])
+    assert str(campaign_a) not in json.dumps(portable_recipe, sort_keys=True)
+
+    resolver = manual_campaign._lightweight_current_resolver(
+        service_b,
+        source_revision=revision,
+        initial={recurrence.cell_id: lightweight},
+    )
+    resolved = resolver(recurrence)
+    assert resolved is not None
+    assert Path(str(resolved[0].result["artifact"]["path"])).is_relative_to(state_b)
+    planned = plan_campaign(
+        (compiled,),
+        store=service_b.store,
+        settings=CampaignSettings(),
+        expected_revision=revision,
+        current_resolver=resolver,
+    )
+    assert [item.cell.cell_id for item in planned] == [compiled.cell_id]
+    assert planned[0].baseline_cell_id is None
+    assert planned[0].optional_baseline_cell_id == recurrence.cell_id
+
+    worker_attempt = service_b.store.new_attempt(
+        compiled.cell_id,
+        ArtifactPolicy.REGENERATE,
+    )
+    worker_paths = _portable_current_paths(
+        repo_root=ROOT,
+        attempt_root=worker_attempt.root,
+    )
+    assert worker_paths is not None
+    worker_loaded = load_measurement(
+        full.result_path,
+        publication_paths=worker_paths,
+    )
+    assert Path(str(worker_loaded["artifact"]["path"])).is_relative_to(state_b)
+    worker_attempt.discard()
+
+    inspect_payload = manual_campaign._inspect_payload(
+        service_b,
+        (recurrence,),
+        source_revision=revision,
+        renderer_revision=revision,
+    )
+    assert inspect_payload["reusable_count"] == 1
+    assert inspect_payload["statuses"] == {ResultStatus.OK.value: 1}
+    assert str(campaign_a) not in json.dumps(inspect_payload, sort_keys=True)
+
+    merged_payloads, merged_count = manual_campaign._merge_lightweight_snapshot(
+        service_b,
+        {recurrence.cell_id: lightweight},
+    )
+    assert merged_count == 1
+    merged_measurement = next(
+        entry["measurement"]
+        for payload in merged_payloads.values()
+        for entry in payload["entries"]
+        if entry["cell_id"] == recurrence.cell_id
+    )
+    assert Path(str(merged_measurement["artifact"]["path"])).is_relative_to(state_b)
+    assert str(campaign_a) not in json.dumps(merged_measurement, sort_keys=True)
+
+    recipe = manual_campaign.reproduction_recipe(
+        recurrence,
+        repo_root=ROOT,
+        artifact_root=state_b,
+        measurement=lightweight.result,
+    )
+    reproduction_root = state_b / "manual-reproductions" / recurrence.cell_id
+    recipe_commands = tuple(
+        command
+        for command in (recipe.prepare, recipe.generate, recipe.profile)
+        if command is not None
+    )
+    rendered_recipe = "\n".join(" ".join(command) for command in recipe_commands)
+    assert str(reproduction_root) in rendered_recipe
+    assert str(campaign_b / ".artifacts") not in rendered_recipe
+    assert str(campaign_a) not in rendered_recipe
+
+    recycled_workers = manual_campaign._recycled_attention_workers(
+        (recurrence,),
+        {recurrence.cell_id: lightweight},
+        {recurrence.cell_id},
+        repo_root=ROOT,
+        artifact_root=state_b,
+        settings=manual_campaign.ReproductionSettings(),
+    )
+    recycled = recycled_workers[recurrence.cell_id]
+    assert recycled.status == "recycled"
+    assert recycled.recycled
+    rendered_worker_commands = "\n".join(
+        command
+        for command in (
+            recycled.reproduce_prepare,
+            recycled.reproduce_generate,
+            recycled.reproduce_profile,
+        )
+        if command is not None
+    )
+    assert str(reproduction_root) in rendered_worker_commands
+    assert str(campaign_b / ".artifacts") not in rendered_worker_commands
+    assert str(campaign_a) not in rendered_worker_commands
+
+
+def test_manual_portable_reuse_rejects_old_absolute_current(
+    tmp_path: Path,
+) -> None:
+    revision = "b" * 40
+    cell = _pyamplicol_leaf_cell()
+    campaign = tmp_path / "manual"
+    state = campaign / "campaign_artifacts"
+    ordinary = ReportService(
+        ReportPaths(
+            repo_root=ROOT,
+            docs_dir=campaign,
+            results_dir=campaign / "results",
+            artifact_root=state,
+            coordination_root=state / "coordination",
+        )
+    )
+    _publish_success_current(ordinary, cell, revision=revision)
+    portable = _portable_manual_service(campaign)
+
+    with pytest.raises(ManifestValidationError, match="current pointer schema"):
+        portable.store.load_current(cell.cell_id)
+    lightweight = lightweight_current(
+        portable.store,
+        cell,
+        source_revision=revision,
+    )
+    assert lightweight is None
+
+
+def _git_object(git_dir: Path, kind: bytes, body: bytes) -> str:
+    payload = kind + b" " + str(len(body)).encode("ascii") + b"\0" + body
+    digest = hashlib.sha1(payload, usedforsecurity=False).hexdigest()
+    path = git_dir / "objects" / digest[:2] / digest[2:]
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(zlib.compress(payload))
+    return digest
+
+
+def _git(repo: Path, *arguments: str) -> str:
+    completed = subprocess.run(
+        ("git", *arguments),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
+def _write_index(repo: Path, relative: str, object_id: str) -> None:
+    path = repo / relative
+    observed = path.stat()
+    encoded = os.fsencode(relative)
+    fields = struct.pack(
+        "!10I20sH",
+        int(observed.st_ctime_ns // 1_000_000_000),
+        int(observed.st_ctime_ns % 1_000_000_000),
+        int(observed.st_mtime_ns // 1_000_000_000),
+        int(observed.st_mtime_ns % 1_000_000_000),
+        int(observed.st_dev),
+        int(observed.st_ino),
+        int(observed.st_mode),
+        int(observed.st_uid),
+        int(observed.st_gid),
+        int(observed.st_size),
+        bytes.fromhex(object_id),
+        len(encoded),
+    )
+    entry = fields + encoded + b"\0"
+    entry += b"\0" * ((8 - len(entry) % 8) % 8)
+    body = struct.pack("!4sII", b"DIRC", 2, 1) + entry
+    checksum = hashlib.sha1(body, usedforsecurity=False).digest()
+    (repo / ".git/index").write_bytes(body + checksum)
+
+
+def test_index_vs_head_detects_staged_content_with_matching_stat_metadata(
+    tmp_path: Path,
+) -> None:
+    git_dir = tmp_path / ".git"
+    (git_dir / "refs/heads").mkdir(parents=True)
+    tracked = tmp_path / "tracked.py"
+    tracked.write_text("value = 1\n", encoding="utf-8")
+
+    original_blob = _git_object(git_dir, b"blob", tracked.read_bytes())
+    tree_body = b"100644 tracked.py\0" + bytes.fromhex(original_blob)
+    tree = _git_object(git_dir, b"tree", tree_body)
+    commit = _git_object(
+        git_dir,
+        b"commit",
+        f"tree {tree}\n\nfixture\n".encode("ascii"),
+    )
+    (git_dir / "HEAD").write_text("ref: refs/heads/main\n", encoding="ascii")
+    (git_dir / "refs/heads/main").write_text(f"{commit}\n", encoding="ascii")
+
+    _write_index(tmp_path, "tracked.py", original_blob)
+    assert _index_metadata_dirty_paths(tmp_path) == ()
+
+    tracked.write_text("value = 2\n", encoding="utf-8")
+    staged_blob = _git_object(git_dir, b"blob", tracked.read_bytes())
+    _write_index(tmp_path, "tracked.py", staged_blob)
+
+    assert _index_metadata_dirty_paths(tmp_path) == (
+        "<staged index differs from HEAD>",
+    )
+
+
+def test_lightweight_source_identity_accepts_clean_packed_head(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git(repo, "init", "-q")
+    _git(repo, "config", "user.email", "campaign@example.invalid")
+    _git(repo, "config", "user.name", "Campaign Test")
+    (repo / "tracked.py").write_text("value = 1\n", encoding="utf-8")
+    _git(repo, "add", "tracked.py")
+    _git(repo, "commit", "-q", "-m", "fixture")
+    revision = _git(repo, "rev-parse", "HEAD")
+    tree = _git(repo, "rev-parse", "HEAD^{tree}")
+
+    _git(repo, "gc", "--prune=now")
+    loose_commit = repo / ".git" / "objects" / revision[:2] / revision[2:]
+    assert not loose_commit.exists()
+
+    identity = manual_campaign.lightweight_source_identity(repo)
+
+    assert identity.revision == revision
+    assert identity.tree == tree
+    assert identity.dirty_paths == ()
+
+    (repo / "tracked.py").write_text("value = 2\n", encoding="utf-8")
+    _git(repo, "add", "tracked.py")
+
+    assert manual_campaign.lightweight_source_identity(repo).dirty_paths == (
+        "<staged index differs from HEAD>",
+    )
+
+
+def test_installed_source_identity_uses_candidate_checkout_only_when_allowed(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git(repo, "init", "-q")
+    _git(repo, "config", "user.email", "campaign@example.invalid")
+    _git(repo, "config", "user.name", "Campaign Test")
+    (repo / "tracked.py").write_text("value = 1\n", encoding="utf-8")
+    _git(repo, "add", "tracked.py")
+    _git(repo, "commit", "-q", "-m", "fixture")
+
+    from pyamplicol._internal import versions
+
+    monkeypatch.setattr(versions, "active_source_revision", lambda: None)
+    monkeypatch.setattr(versions, "active_source_checkout", lambda: repo)
+
+    with pytest.raises(
+        manual_campaign.ManualCampaignError,
+        match="has no source revision",
+    ):
+        manual_campaign.installed_source_identity()
+
+    identity = manual_campaign.installed_source_identity(
+        allow_candidate_checkout=True,
+    )
+    assert identity.revision == _git(repo, "rev-parse", "HEAD")
+    assert identity.tree == _git(repo, "rev-parse", "HEAD^{tree}")
+    assert identity.eligible
+
+
+def test_installed_dry_run_requests_candidate_checkout_identity(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    requested: list[bool] = []
+
+    class IdentityRequested(RuntimeError):
+        pass
+
+    def record_request(*, allow_candidate_checkout: bool = False) -> None:
+        requested.append(allow_candidate_checkout)
+        raise IdentityRequested
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "installed_source_identity",
+        record_request,
+    )
+
+    assert (
+        manual_campaign.main(
+            (
+                "run",
+                "--dry-run",
+                "--table",
+                "scalar_contact",
+                "--multiplicity",
+                "2",
+                "--generation-engine",
+                "compiled",
+                "--no-color",
+            ),
+            repo_root=tmp_path,
+            docs_dir=tmp_path,
+            installed=True,
+            launcher_path_checked=True,
+        )
+        == 2
+    )
+
+    assert requested == [True]
+
+
+def test_measurement_readiness_distinguishes_absent_runtime_revision(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = ReportSourceIdentity("a" * 40, "b" * 40, ())
+    monkeypatch.setattr(
+        manual_campaign,
+        "_installed_source_revision",
+        lambda: None,
+    )
+
+    with pytest.raises(
+        manual_campaign.ManualCampaignError,
+        match="runtime contains no clean source revision",
+    ):
+        manual_campaign.require_measurement_ready(source)
+
+
+def test_measurement_readiness_reports_runtime_revision_mismatch(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = ReportSourceIdentity("a" * 40, "b" * 40, ())
+    monkeypatch.setattr(
+        manual_campaign,
+        "_installed_source_revision",
+        lambda: "c" * 40,
+    )
+
+    with pytest.raises(
+        manual_campaign.ManualCampaignError,
+        match=r"checkout=a{40}, installed=c{40}",
+    ):
+        manual_campaign.require_measurement_ready(source)
+
+
+def test_installed_source_revision_wraps_package_import_provenance_error(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    original_import = builtins.__import__
+
+    def failing_import(name: str, *args: object, **kwargs: object) -> object:
+        if name == "pyamplicol._internal.versions":
+            raise RuntimeError("stale native build inputs")
+        return original_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", failing_import)
+
+    with pytest.raises(
+        manual_campaign.ManualCampaignError,
+        match="runtime provenance cannot be loaded: stale native build inputs",
+    ):
+        manual_campaign._installed_source_revision()
+
+
+def test_lightweight_current_rejects_attempt_and_measurement_schema_errors(
+    tmp_path: Path,
+) -> None:
+    revision = "a" * 40
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    cell = _amplicol_leaf_cell()
+    manifest_path, result_path = _write_lightweight_terminal_current(
+        service,
+        cell,
+        revision=revision,
+    )
+
+    current = lightweight_current(
+        service.store,
+        cell,
+        source_revision=revision,
+    )
+    assert current is not None
+    assert current.complete
+    assert current.reusable
+    assert current.record is not None
+
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest["schema"] = "unsupported-attempt-schema"
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    wrong_attempt_schema = lightweight_current(
+        service.store,
+        cell,
+        source_revision=revision,
+    )
+    assert wrong_attempt_schema is not None
+    assert not wrong_attempt_schema.complete
+    assert not wrong_attempt_schema.reusable
+    assert wrong_attempt_schema.reason == "incomplete metadata"
+
+    manifest["schema"] = ATTEMPT_SCHEMA
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    result = json.loads(result_path.read_text(encoding="utf-8"))
+    result.pop("failure")
+    result_path.write_text(json.dumps(result), encoding="utf-8")
+    wrong_measurement_schema = lightweight_current(
+        service.store,
+        cell,
+        source_revision=revision,
+    )
+    assert wrong_measurement_schema is not None
+    assert not wrong_measurement_schema.complete
+    assert not wrong_measurement_schema.reusable
+    assert wrong_measurement_schema.reason == "invalid measurement schema"
+
+
+def test_historical_current_reuse_requires_explicit_continuation(
+    tmp_path: Path,
+) -> None:
+    historical_revision = "a" * 40
+    active_revision = "b" * 40
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    cell = _amplicol_leaf_cell()
+    _write_lightweight_terminal_current(
+        service,
+        cell,
+        revision=historical_revision,
+    )
+
+    strict = lightweight_current(
+        service.store,
+        cell,
+        source_revision=active_revision,
+    )
+    continued = lightweight_current(
+        service.store,
+        cell,
+        source_revision=active_revision,
+        accept_historical_source=True,
+    )
+
+    assert strict is not None and strict.complete and not strict.reusable
+    assert strict.reason == "source mismatch"
+    assert continued is not None and continued.reusable
+    assert continued.reason == "historical resource-capped terminal"
+
+    inspected = manual_campaign._inspect_payload(
+        service,
+        (cell,),
+        source_revision=active_revision,
+        renderer_revision=active_revision,
+        accept_historical_source=True,
+    )
+    assert inspected["source_policy"] == "continue_across_revisions"
+    assert inspected["source_cohorts"] == {historical_revision: 1}
+    assert inspected["reusable_count"] == 1
+
+
+def test_successful_legacy_current_requires_corrected_numerical_authority(
+    tmp_path: Path,
+) -> None:
+    from tools.performance_report.legacy import (
+        LEGACY_NUMERICAL_AUTHORITY_ABI,
+        LEGACY_NUMERICAL_AUTHORITY_FIELD,
+    )
+
+    revision = "a" * 40
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    cell = _amplicol_contracted_cell()
+    _manifest_path, result_path = _write_lightweight_success_current(
+        service,
+        cell,
+        revision=revision,
+        numerical_relation_correctness={},
+    )
+
+    stale = lightweight_current(service.store, cell, source_revision=revision)
+    assert stale is not None and stale.complete and not stale.reusable
+    assert stale.reason == "legacy numerical authority requires refresh"
+
+    result = json.loads(result_path.read_text(encoding="utf-8"))
+    result["validation"][LEGACY_NUMERICAL_AUTHORITY_FIELD] = {
+        "abi": LEGACY_NUMERICAL_AUTHORITY_ABI,
+        "source": "contracted-generated-library",
+    }
+    result_path.write_text(json.dumps(result), encoding="utf-8")
+
+    corrected = lightweight_current(service.store, cell, source_revision=revision)
+    assert corrected is not None and corrected.complete and corrected.reusable
+
+
+@pytest.mark.parametrize(
+    ("workload", "generation_source", "expected_compatible"),
+    (
+        (Workload.SELECTED_FLOW, "generated-library-create-mode-1", True),
+        (Workload.ALL_FLOW, "direct-imode2-generation-setup", False),
+        (Workload.CONTRACTED, "generated-library-create-raw", False),
+        (
+            Workload.CONTRACTED,
+            "direct-imode2-three-quark-line-setup",
+            True,
+        ),
+    ),
+)
+def test_pre_authority_legacy_compatibility_is_narrowly_path_based(
+    workload: Workload,
+    generation_source: str,
+    expected_compatible: bool,
+) -> None:
+    cell = next(
+        candidate
+        for candidate in REPORT_CATALOG.measurement_cells()
+        if candidate.measurement.execution_mode is ExecutionMode.AMPLICOL
+        and candidate.workload is workload
+    )
+    result = {
+        "status": ResultStatus.OK.value,
+        "validation": {},
+        "provenance": {"generation_source": generation_source},
+    }
+
+    assert (
+        manual_campaign._legacy_numerical_authority_compatible(cell, result)
+        is expected_compatible
+    )
+
+
+@pytest.mark.parametrize(
+    ("extra_provenance", "expected_reusable"),
+    (
+        (
+            {
+                "effective_config": {
+                    "generation": {"relation_discovery": {"mode": "off"}}
+                }
+            },
+            True,
+        ),
+        (
+            {
+                "numerical_relation_correctness": {
+                    "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+                    "state": "no-applied-relations",
+                    "applied_relation_count": 0,
+                }
+            },
+            True,
+        ),
+        (
+            {
+                "numerical_relation_correctness": {
+                    "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+                    "state": "member-scoped-v1",
+                    "applied_relation_count": 3,
+                }
+            },
+            True,
+        ),
+        ({}, False),
+        (
+            {
+                "numerical_relation_correctness": {
+                    "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+                    "state": "no-applied-relations",
+                    "applied_relation_count": 1,
+                }
+            },
+            False,
+        ),
+        (
+            {
+                "numerical_relation_correctness": {
+                    "abi": "obsolete",
+                    "state": "member-scoped-v1",
+                    "applied_relation_count": 1,
+                }
+            },
+            False,
+        ),
+    ),
+)
+def test_historical_pyamplicol_reuse_requires_compact_relation_safety(
+    tmp_path: Path,
+    extra_provenance: Mapping[str, object],
+    expected_reusable: bool,
+) -> None:
+    historical_revision = "a" * 40
+    active_revision = "b" * 40
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    cell = _pyamplicol_leaf_cell()
+    _write_lightweight_terminal_current(
+        service,
+        cell,
+        revision=historical_revision,
+        extra_provenance=extra_provenance,
+    )
+
+    current = lightweight_current(
+        service.store,
+        cell,
+        source_revision=active_revision,
+        accept_historical_source=True,
+    )
+
+    assert current is not None
+    assert current.complete
+    assert current.reusable is expected_reusable
+    if not expected_reusable:
+        assert current.reason == "historical numerical-relation policy is not reusable"
+
+
+def test_successful_historical_pyamplicol_reuse_is_metadata_only_and_planned(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    historical_revision = "a" * 40
+    active_revision = "b" * 40
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    cell = next(
+        candidate
+        for candidate in REPORT_CATALOG.measurement_cells()
+        if candidate.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and candidate.measurement.accuracy is not Accuracy.LC
+        and candidate.n_final == 1
+    )
+    _manifest_path, result_path = _write_lightweight_success_current(
+        service,
+        cell,
+        revision=historical_revision,
+        numerical_relation_correctness={
+            "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+            "state": "no-applied-relations",
+            "applied_relation_count": 0,
+        },
+    )
+
+    def forbidden_load_current(
+        _store: ArtifactStore,
+        _cell_id: str,
+        *,
+        missing_ok: bool = False,
+    ) -> None:
+        del missing_ok
+        raise AssertionError("historical planning inspected authenticated history")
+
+    monkeypatch.setattr(ArtifactStore, "load_current", forbidden_load_current)
+    requested_batches: list[tuple[str, ...]] = []
+
+    def observe_plan(
+        requested: tuple[CellSpec, ...],
+        **_kwargs: object,
+    ) -> tuple[object, ...]:
+        requested_batches.append(tuple(item.cell_id for item in requested))
+        return ()
+
+    monkeypatch.setattr(manual_campaign, "plan_campaign", observe_plan)
+    arguments = build_parser().parse_args(
+        (
+            "run",
+            "--dry-run",
+            "--no-color",
+            "--continue-across-revisions",
+            "--cell-id",
+            cell.cell_id,
+        )
+    )
+    source = ReportSourceIdentity(active_revision, "c" * 40, ())
+
+    assert (
+        _run_campaign(
+            arguments,
+            repo_root=ROOT,
+            service=service,
+            source=source,
+            cells=(cell,),
+            palette=Palette(False),
+        )
+        == 0
+    )
+    assert requested_batches == [()]
+    capsys.readouterr()
+
+    result = json.loads(result_path.read_text(encoding="utf-8"))
+    result["provenance"]["numerical_relation_correctness"] = {
+        "abi": "obsolete",
+        "state": "member-scoped-v1",
+        "applied_relation_count": 1,
+    }
+    result_path.write_text(json.dumps(result), encoding="utf-8")
+
+    assert (
+        _run_campaign(
+            arguments,
+            repo_root=ROOT,
+            service=service,
+            source=source,
+            cells=(cell,),
+            palette=Palette(False),
+        )
+        == 0
+    )
+    assert requested_batches == [(), (cell.cell_id,)]
+
+
+def test_same_source_pyamplicol_reuse_does_not_require_historical_abi(
+    tmp_path: Path,
+) -> None:
+    revision = "a" * 40
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    cell = _pyamplicol_leaf_cell()
+    _write_lightweight_terminal_current(service, cell, revision=revision)
+
+    current = lightweight_current(
+        service.store,
+        cell,
+        source_revision=revision,
+    )
+
+    assert current is not None and current.reusable
+
+
+def test_continuation_keeps_direct_history_but_not_dependency_resolution(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    historical_revision = "a" * 40
+    active_revision = "b" * 40
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    historical = _amplicol_leaf_cell()
+    missing = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        and cell.workload is Workload.SELECTED_FLOW
+        and cell.cell_id != historical.cell_id
+    )
+    _write_lightweight_terminal_current(
+        service,
+        historical,
+        revision=historical_revision,
+    )
+    observed_requested: list[str] = []
+
+    def observe_plan(
+        requested: tuple[CellSpec, ...],
+        **kwargs: object,
+    ) -> tuple[object, ...]:
+        observed_requested.extend(cell.cell_id for cell in requested)
+        resolver = kwargs["current_resolver"]
+        assert callable(resolver)
+        assert resolver(historical) is None
+        return ()
+
+    monkeypatch.setattr(manual_campaign, "plan_campaign", observe_plan)
+    arguments = build_parser().parse_args(
+        (
+            "run",
+            "--dry-run",
+            "--no-color",
+            "--continue-across-revisions",
+        )
+    )
+
+    result = _run_campaign(
+        arguments,
+        repo_root=ROOT,
+        service=service,
+        source=ReportSourceIdentity(active_revision, "c" * 40, ()),
+        cells=(historical, missing),
+        palette=Palette(False),
+    )
+
+    assert result == 0
+    assert observed_requested == [missing.cell_id]
+    output = capsys.readouterr().out
+    assert "Cross-revision continuation is enabled" in output
+    assert historical_revision in output
+
+
+def test_selective_retry_conflicts_with_force_refresh_before_state_access(
+    tmp_path: Path,
+) -> None:
+    service = _isolated_manual_service(tmp_path)
+    arguments = build_parser().parse_args(
+        ("run", "--force-refresh", "--rerun-failed", "--no-dashboard")
+    )
+
+    with pytest.raises(
+        manual_campaign.ManualCampaignError,
+        match="--force-refresh cannot be combined with --rerun-failed",
+    ):
+        _run_campaign(
+            arguments,
+            repo_root=ROOT,
+            service=service,
+            source=ReportSourceIdentity("a" * 40, "b" * 40, ()),
+            cells=(),
+            palette=Palette(False),
+        )
+
+
+def test_selective_retry_no_match_preserves_existing_summary(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    service = _isolated_manual_service(tmp_path)
+    measurable = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is None
+    )[:2]
+    static_na = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is not None
+    )
+    ok = manual_campaign.LightweightCurrent(
+        cell_id=measurable[0].cell_id,
+        attempt_id="00000000-0000-4000-8000-000000000001",
+        result_path=tmp_path / "ok.json",
+        result={"status": ResultStatus.OK.value},
+        complete=True,
+        reusable=True,
+        reason="reusable",
+    )
+    summary = service.paths.docs_dir / "campaign_summary_ids"
+    summary.mkdir(parents=True)
+    sentinel = summary / "error.txt"
+    sentinel.write_text("existing-cell\n", encoding="utf-8")
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_currents",
+        lambda *_args, **_kwargs: {ok.cell_id: ok},
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_presentation_outcomes",
+        lambda *_args, **_kwargs: {},
+    )
+
+    def forbidden(*_args: object, **_kwargs: object) -> None:
+        raise AssertionError("no-match selective retry reached planning/publication")
+
+    monkeypatch.setattr(manual_campaign, "plan_campaign", forbidden)
+    monkeypatch.setattr(manual_campaign, "_publish_campaign_summary_ids", forbidden)
+    arguments = build_parser().parse_args(
+        ("run", "--rerun-failed", "--rerun-capped", "--no-dashboard")
+    )
+
+    result = _run_campaign(
+        arguments,
+        repo_root=ROOT,
+        service=service,
+        source=ReportSourceIdentity("a" * 40, "b" * 40, ()),
+        cells=(*measurable, static_na),
+        palette=Palette(False),
+    )
+
+    assert result == 0
+    assert sentinel.read_text(encoding="utf-8") == "existing-cell\n"
+    assert "No entries among 2 measurable selected cells match" in (
+        capsys.readouterr().out
+    )
+
+
+def test_selective_retry_historical_state_requires_continuation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    active_revision = "b" * 40
+    historical_revision = "a" * 40
+    service = _isolated_manual_service(tmp_path)
+    cell = _pyamplicol_leaf_cell()
+    historical = _presentation_outcome(
+        cell,
+        revision=historical_revision,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_currents",
+        lambda *_args, **_kwargs: {},
+    )
+
+    def outcomes(
+        *_args: object,
+        accept_historical_source: bool = False,
+        **_kwargs: object,
+    ) -> dict[str, manual_campaign.LightweightPresentationOutcome]:
+        return {cell.cell_id: historical} if accept_historical_source else {}
+
+    planned: list[tuple[str, ...]] = []
+
+    def observe_plan(
+        requested: tuple[CellSpec, ...],
+        **_kwargs: object,
+    ) -> tuple[object, ...]:
+        planned.append(tuple(item.cell_id for item in requested))
+        return ()
+
+    monkeypatch.setattr(manual_campaign, "lightweight_presentation_outcomes", outcomes)
+    monkeypatch.setattr(manual_campaign, "plan_campaign", observe_plan)
+
+    strict = build_parser().parse_args(
+        ("run", "--dry-run", "--rerun-failed", "--cell-id", cell.cell_id)
+    )
+    continued = build_parser().parse_args(
+        (
+            "run",
+            "--dry-run",
+            "--rerun-failed",
+            "--continue-across-revisions",
+            "--cell-id",
+            cell.cell_id,
+        )
+    )
+    source = ReportSourceIdentity(active_revision, "c" * 40, ())
+
+    assert (
+        _run_campaign(
+            strict,
+            repo_root=ROOT,
+            service=service,
+            source=source,
+            cells=(cell,),
+            palette=Palette(False),
+        )
+        == 0
+    )
+    assert planned == []
+    assert (
+        _run_campaign(
+            continued,
+            repo_root=ROOT,
+            service=service,
+            source=source,
+            cells=(cell,),
+            palette=Palette(False),
+        )
+        == 0
+    )
+    assert planned == [(cell.cell_id,)]
+
+
+def test_selective_retry_keeps_dependency_closure_and_reuses_ok_prerequisite(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    revision = "a" * 40
+    service = _isolated_manual_service(tmp_path)
+    target = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-lc-n1-dd-z-jets-all-flow"
+    )
+    prerequisite = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    )
+    failure = _presentation_outcome(target, revision=revision)
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_presentation_outcomes",
+        lambda *_args, **_kwargs: {target.cell_id: failure},
+    )
+    success_result = {"status": ResultStatus.OK.value}
+    success_record = manual_campaign.CurrentRecord(
+        cell_id=prerequisite.cell_id,
+        attempt_id="00000000-0000-4000-8000-000000000001",
+        manifest_path=tmp_path / "manifest.json",
+        manifest_sha256="0" * 64,
+        result_path=tmp_path / "result.json",
+        result=success_result,
+        artifacts=(),
+        artifact_policy=ArtifactPolicy.REUSE,
+    )
+    success = manual_campaign.LightweightCurrent(
+        cell_id=prerequisite.cell_id,
+        attempt_id=success_record.attempt_id,
+        result_path=success_record.result_path,
+        result=success_result,
+        complete=True,
+        reusable=True,
+        reason="reusable",
+        record=success_record,
+    )
+    recycle_prerequisite = False
+
+    def resolve_lightweight(
+        _store: ArtifactStore,
+        cell: CellSpec,
+        **_kwargs: object,
+    ) -> manual_campaign.LightweightCurrent | None:
+        if recycle_prerequisite and cell.cell_id == prerequisite.cell_id:
+            return success
+        return None
+
+    monkeypatch.setattr(manual_campaign, "lightweight_current", resolve_lightweight)
+    planned_batches: list[tuple[object, ...]] = []
+    real_dry_run_rows = manual_campaign._dry_run_rows
+
+    def observe_dry_run_rows(
+        direct: object,
+        planned: tuple[object, ...],
+        **kwargs: object,
+    ) -> tuple[object, ...]:
+        planned_batches.append(tuple(planned))
+        return tuple(real_dry_run_rows(direct, planned, **kwargs))
+
+    monkeypatch.setattr(manual_campaign, "_dry_run_rows", observe_dry_run_rows)
+    arguments = build_parser().parse_args(
+        (
+            "run",
+            "--dry-run",
+            "--rerun-failed",
+            "--no-dependencies-added",
+            "--cell-id",
+            target.cell_id,
+        )
+    )
+    source = ReportSourceIdentity(revision, "b" * 40, ())
+
+    assert (
+        _run_campaign(
+            arguments,
+            repo_root=ROOT,
+            service=service,
+            source=source,
+            cells=(target,),
+            palette=Palette(False),
+        )
+        == 0
+    )
+    assert [item.cell.cell_id for item in planned_batches[0]] == [
+        prerequisite.cell_id,
+        target.cell_id,
+    ]
+    assert planned_batches[0][0].dependency
+
+    recycle_prerequisite = True
+    assert (
+        _run_campaign(
+            arguments,
+            repo_root=ROOT,
+            service=service,
+            source=source,
+            cells=(target,),
+            palette=Palette(False),
+        )
+        == 0
+    )
+    assert [item.cell.cell_id for item in planned_batches[1]] == [target.cell_id]
+    assert not planned_batches[1][0].dependency
+
+
+def test_selective_retry_injects_authority_chain_unless_explicitly_disabled(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    revision = "a" * 40
+    service = _isolated_manual_service(tmp_path)
+    candidate = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n4-dd-3q-lines-contracted"
+    )
+    recurrence = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert recurrence is not None
+    amplicol = REPORT_CATALOG.validation_baseline_cell(recurrence)
+    assert amplicol is not None
+    failure = _presentation_outcome(candidate, revision=revision)
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_presentation_outcomes",
+        lambda *_args, **_kwargs: {candidate.cell_id: failure},
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_current",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_original_amplicol_available_for_planning",
+        lambda *_args, **_kwargs: True,
+    )
+    planned_batches: list[tuple[object, ...]] = []
+    real_dry_run_rows = manual_campaign._dry_run_rows
+
+    def observe_dry_run_rows(
+        direct: object,
+        planned: tuple[object, ...],
+        **kwargs: object,
+    ) -> tuple[object, ...]:
+        planned_batches.append(tuple(planned))
+        return tuple(real_dry_run_rows(direct, planned, **kwargs))
+
+    monkeypatch.setattr(manual_campaign, "_dry_run_rows", observe_dry_run_rows)
+    arguments = build_parser().parse_args(("run", "--dry-run", "--rerun-failed"))
+    source = ReportSourceIdentity(revision, "b" * 40, ())
+
+    assert (
+        _run_campaign(
+            arguments,
+            repo_root=ROOT,
+            service=service,
+            source=source,
+            cells=(candidate,),
+            palette=Palette(False),
+        )
+        == 0
+    )
+
+    assert [item.cell.cell_id for item in planned_batches[0]] == [
+        amplicol.cell_id,
+        recurrence.cell_id,
+        candidate.cell_id,
+    ]
+    assert [item.dependency for item in planned_batches[0]] == [True, True, False]
+    assert planned_batches[0][1].prerequisite_cell_ids == (amplicol.cell_id,)
+    assert planned_batches[0][2].prerequisite_cell_ids == (recurrence.cell_id,)
+    assert planned_batches[0][2].numerical_authority_cell_ids == (
+        recurrence.cell_id,
+    )
+
+    opt_out = build_parser().parse_args(
+        (
+            "run",
+            "--dry-run",
+            "--rerun-failed",
+            "--no-dependencies-added",
+        )
+    )
+    assert (
+        _run_campaign(
+            opt_out,
+            repo_root=ROOT,
+            service=service,
+            source=source,
+            cells=(candidate,),
+            palette=Palette(False),
+        )
+        == 0
+    )
+    assert [item.cell.cell_id for item in planned_batches[1]] == [candidate.cell_id]
+    assert not planned_batches[1][0].dependency
+    assert planned_batches[1][0].prerequisite_cell_ids == ()
+
+
+def test_manual_dry_run_plans_only_from_lightweight_metadata(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    revision = "b" * 40
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    cell = _amplicol_leaf_cell()
+    _write_lightweight_terminal_current(service, cell, revision=revision)
+
+    def forbidden_load_current(
+        _store: ArtifactStore,
+        _cell_id: str,
+        *,
+        missing_ok: bool = False,
+    ) -> None:
+        del missing_ok
+        raise AssertionError("manual planning called authenticated artifact loading")
+
+    monkeypatch.setattr(ArtifactStore, "load_current", forbidden_load_current)
+    arguments = build_parser().parse_args(
+        ("run", "--dry-run", "--no-color", "--cell-id", cell.cell_id)
+    )
+    result = _run_campaign(
+        arguments,
+        repo_root=ROOT,
+        service=service,
+        source=ReportSourceIdentity(revision, "c" * 40, ()),
+        cells=(cell,),
+        palette=Palette(False),
+    )
+
+    assert result == 0
+    output = capsys.readouterr().out
+    assert "recycled" in output
+    assert "1" in output
+    assert "planned with dependencies" in output
+
+
+def test_non_manual_planning_keeps_authenticated_store_lookup(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[str] = []
+
+    def observed_load_current(
+        _store: ArtifactStore,
+        cell_id: str,
+        *,
+        missing_ok: bool = False,
+    ) -> None:
+        assert missing_ok
+        calls.append(cell_id)
+        return None
+
+    monkeypatch.setattr(ArtifactStore, "load_current", observed_load_current)
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+    cell = _amplicol_leaf_cell()
+
+    planned = plan_campaign((cell,), store=store, settings=CampaignSettings())
+
+    assert planned
+    assert cell.cell_id in calls
+
+
+@pytest.mark.parametrize(
+    "setting",
+    (
+        "target_runtime_seconds",
+        "resource_sample_interval_seconds",
+        "termination_grace_seconds",
+        "timeout_seconds",
+    ),
+)
+@pytest.mark.parametrize("value", (float("nan"), float("inf")))
+def test_campaign_settings_reject_non_finite_float_controls(
+    setting: str,
+    value: float,
+) -> None:
+    with pytest.raises(ValueError):
+        CampaignSettings(**{setting: value})
diff --git a/pyamplicol/tests/unit/test_manual_campaign_observability.py b/pyamplicol/tests/unit/test_manual_campaign_observability.py
new file mode 100644
index 0000000000..6a935c7ab0
--- /dev/null
+++ b/pyamplicol/tests/unit/test_manual_campaign_observability.py
@@ -0,0 +1,332 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+import tools.performance_report.manual_campaign as manual_campaign
+from tools.ci.memory_watchdog import ProcessInfo as WatchdogProcessInfo
+from tools.performance_report.manual_campaign import (
+    DashboardState,
+    LeaseManager,
+    render_dashboard_frame,
+)
+from tools.performance_report.resources import (
+    ProcessRecord,
+    ProcessTreeSampler,
+    _parse_ps_cpu_time,
+    process_snapshot,
+)
+from tools.performance_report.service import ReportPaths, ReportService
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def test_darwin_process_snapshot_reports_native_tree_rss() -> None:
+    def reject_ps(_command: tuple[str, ...]) -> object:
+        raise AssertionError("Darwin resource monitoring must not execute ps")
+
+    records = process_snapshot(
+        "Darwin",
+        ps_runner=reject_ps,
+        darwin_snapshotter=lambda: {
+            100: WatchdogProcessInfo(100, 1, 100, 1024 * 1024, 1.25),
+            101: WatchdogProcessInfo(101, 100, 100, 2048 * 1024, 3_723.5),
+        },
+    )
+    sample = ProcessTreeSampler(100).sample(records)
+
+    assert records[100].cpu_seconds == 1.25
+    assert records[101].cpu_seconds == 3_723.5
+    assert sample.cpu_seconds == 3_724.75
+    assert sample.rss_bytes == 3 * 1024 * 1024
+    assert _parse_ps_cpu_time("2-03:04:05.50") == 183_845.5
+    partial = ProcessTreeSampler(100).sample(
+        {
+            100: ProcessRecord(100, 1, 100, 1.0),
+            101: ProcessRecord(101, 100, 100, None),
+        }
+    )
+    assert partial.cpu_seconds is None
+
+
+def test_dashboard_uses_guard_memory_and_incremental_progress_and_log_tails(
+    tmp_path: Path,
+) -> None:
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    cell_id = "observability-cell"
+    progress_path = tmp_path / "progress.jsonl"
+    log_path = tmp_path / "worker.log"
+    initial_progress = (
+        json.dumps(
+            {
+                "event": "update",
+                "completed": 2,
+                "total": 4,
+                "message": "building currents",
+            }
+        )
+        + "\n"
+    )
+    initial_log = "loaded model\n\x1b[31mprofiling batch 2\x1b[0m\n"
+    progress_path.write_text(initial_progress, encoding="utf-8")
+    log_path.write_text(initial_log, encoding="utf-8")
+    state = DashboardState(
+        instance_id="observability",
+        selected_ids=(cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+        memory_limit_bytes=1_000,
+    )
+    lease = LeaseManager(service, state)
+    lease.observe(
+        {
+            "event": "worker",
+            "cell_id": cell_id,
+            "attempt_id": "attempt",
+            "progress_path": str(progress_path),
+            "log_path": str(log_path),
+        }
+    )
+    resource = {
+        "event": "resource",
+        "cell_id": cell_id,
+        "phase": "profiling",
+        "pid": 100,
+        "member_pids": [100, 101],
+        "wall_seconds": 3.5,
+        "cpu_seconds": 5.25,
+        "current_rss_bytes": 800,
+        "peak_rss_bytes": 900,
+        "current_physical_footprint_bytes": 1_200,
+        "peak_physical_footprint_bytes": 1_300,
+        "current_guard_bytes": 1_200,
+        "peak_guard_bytes": 1_300,
+        "child_count": 1,
+    }
+    lease.observe(resource)
+
+    worker = state.workers[cell_id]
+    assert worker.cpu_seconds == 5.25
+    assert worker.current_rss_bytes == 800
+    assert worker.current_physical_footprint_bytes == 1_200
+    assert worker.current_guard_bytes == 1_200
+    assert worker.log_tail == ["loaded model", "profiling batch 2"]
+    assert worker._progress_tail_state.last_read_bytes == len(initial_progress.encode())
+    assert worker._log_tail_state.last_read_bytes == len(initial_log.encode())
+
+    appended_progress = (
+        json.dumps(
+            {
+                "event": "update",
+                "completed": 3,
+                "total": 4,
+                "message": "profiling batch 3",
+            }
+        )
+        + "\n"
+    )
+    appended_log = "profiling batch 3\n"
+    with progress_path.open("a", encoding="utf-8") as stream:
+        stream.write(appended_progress)
+    with log_path.open("a", encoding="utf-8") as stream:
+        stream.write(appended_log)
+    lease.observe(resource)
+
+    assert worker.progress_completed == 3
+    assert worker._progress_tail_state.last_read_bytes == len(
+        appended_progress.encode()
+    )
+    assert worker._log_tail_state.last_read_bytes == len(appended_log.encode())
+    assert worker.log_tail[-1] == "profiling batch 3"
+    assert worker.events.count("resource: profiling") == 1
+    lease_payload = json.loads(lease.path.read_text(encoding="utf-8"))
+    leased_worker = lease_payload["workers"][cell_id]
+    assert leased_worker["current_rss_bytes"] == 800
+    assert leased_worker["current_physical_footprint_bytes"] == 1_200
+    assert leased_worker["current_guard_bytes"] == 1_200
+    assert "_progress_tail_state" not in leased_worker
+
+    wide = render_dashboard_frame(state, width=160, height=48)
+    compact = render_dashboard_frame(state, width=80, height=24)
+    for frame in (wide, compact):
+        assert "progress" in frame
+        assert "▰" in frame
+        assert "Guard current" in frame
+        assert "1.20 kB" in frame
+        assert "Recent log" in frame
+        assert "profiling batch 3" in frame
+    assert "RSS current" in wide and "800 B" in wide
+    assert "RSS peak" in wide and "900 B" in wide
+    assert "Physical current" in wide and "1.20 kB" in wide
+    assert "RAM cap" in wide and "1.00 kB" in wide
+
+
+@pytest.mark.parametrize(
+    ("arguments", "environment_color", "expected"),
+    (
+        (("dashboard-snapshot",), None, True),
+        (("dashboard-snapshot", "--no-color"), None, False),
+        (("dashboard-snapshot",), "", False),
+        (("dashboard-snapshot", "--cells-json"), None, True),
+        (("dashboard-snapshot", "--cells-json", "--no-color"), None, False),
+        (("dashboard-snapshot", "--cells-json"), "", False),
+    ),
+)
+def test_dashboard_cli_propagates_color_policy(
+    arguments: tuple[str, ...],
+    environment_color: str | None,
+    expected: bool,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    if environment_color is None:
+        monkeypatch.delenv("NO_COLOR", raising=False)
+    else:
+        monkeypatch.setenv("NO_COLOR", environment_color)
+    observed: list[bool] = []
+
+    def capture(*_args: Any, **kwargs: Any) -> object:
+        observed.append(bool(kwargs["color"]))
+        return [] if kwargs["cells"] else "frame"
+
+    monkeypatch.setattr(manual_campaign, "render_dashboard_frame", capture)
+    docs_dir = tmp_path / "campaign"
+    docs_dir.mkdir()
+
+    assert manual_campaign.main(arguments, repo_root=ROOT, docs_dir=docs_dir) == 0
+    capsys.readouterr()
+    assert observed == [expected]
+
+
+def test_ratatui_style_toggle_removes_all_cell_styles() -> None:
+    state = manual_campaign._snapshot_fixture(selected=5, recycled=1, completed=1)
+
+    colored = render_dashboard_frame(
+        state,
+        width=120,
+        height=36,
+        cells=True,
+        color=True,
+    )
+    plain = render_dashboard_frame(
+        state,
+        width=120,
+        height=36,
+        cells=True,
+        color=False,
+    )
+
+    assert isinstance(colored, list)
+    assert isinstance(plain, list)
+    assert any(cell.get("fg") not in (None, 0) for cell in colored)
+    assert all(cell.get("fg") in (None, 0) for cell in plain)
+    assert all(cell.get("bg") in (None, 0) for cell in plain)
+    assert all(cell.get("mods") in (None, 0) for cell in plain)
+
+
+def test_dashboard_preserves_and_displays_three_independent_recurrence_clocks() -> None:
+    state = manual_campaign._snapshot_fixture(selected=5, recycled=1, completed=1)
+    state.show_completed = True
+    workers = state.visible_workers()
+    state.selected_index = next(
+        index
+        for index, worker in enumerate(workers)
+        if "matrix-recurrence-" in worker.cell_id
+    )
+    selected = state.selected_worker()
+    assert selected is not None
+
+    decoded = manual_campaign._worker_from_lease(
+        selected.cell_id,
+        selected.as_dict(),
+        peer_instance=None,
+    )
+    assert decoded.generation_engine == "recurrence"
+    assert decoded.published_wall_seconds_per_point == pytest.approx(218.105e-6)
+    assert decoded.published_evaluator_total_seconds_per_point == pytest.approx(
+        217.812e-6
+    )
+    assert decoded.published_recurrence_core_seconds_per_point == pytest.approx(
+        205.431e-6
+    )
+
+    frame = render_dashboard_frame(state, width=120, height=36)
+    assert "Outer wall" in frame
+    assert "218.105 μs/pt" in frame
+    assert "Evaluator total" in frame
+    assert "217.812 μs/pt" in frame
+    assert "Recurrence core" in frame
+    assert "205.431 μs/pt" in frame
+
+    state.selected_index = next(
+        index
+        for index, worker in enumerate(workers)
+        if "matrix-compiled-" in worker.cell_id
+    )
+    compiled_frame = render_dashboard_frame(state, width=120, height=36)
+    assert "Recurrence core" in compiled_frame
+    assert "not applicable" in compiled_frame
+
+
+def test_ratatui_terminal_session_uses_native_lifecycle_and_restores_environment(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import ratatui_py
+
+    events: list[tuple[str, str | None, str | None]] = []
+
+    class FakeTerminal:
+        def __init__(self) -> None:
+            events.append(
+                (
+                    "init",
+                    os.environ.get("RATATUI_FFI_ALTSCR"),
+                    os.environ.get("RATATUI_FFI_NO_RAW"),
+                )
+            )
+
+        def close(self) -> None:
+            events.append(("close", None, None))
+
+    def unsafe_session(**_options: object) -> object:
+        raise AssertionError("the unsafe ratatui_py.terminal_session was called")
+
+    monkeypatch.setattr(ratatui_py, "Terminal", FakeTerminal)
+    monkeypatch.setattr(ratatui_py, "terminal_session", unsafe_session)
+    monkeypatch.setenv("RATATUI_FFI_ALTSCR", "existing-alt")
+    monkeypatch.setenv("RATATUI_FFI_NO_RAW", "existing-no-raw")
+
+    with (
+        pytest.raises(KeyboardInterrupt),
+        manual_campaign._ratatui_terminal_session(),
+    ):
+        events.append(
+            (
+                "body",
+                os.environ.get("RATATUI_FFI_ALTSCR"),
+                os.environ.get("RATATUI_FFI_NO_RAW"),
+            )
+        )
+        raise KeyboardInterrupt
+
+    assert events == [
+        ("init", "1", None),
+        ("body", "existing-alt", "existing-no-raw"),
+        ("close", None, None),
+    ]
+    assert os.environ["RATATUI_FFI_ALTSCR"] == "existing-alt"
+    assert os.environ["RATATUI_FFI_NO_RAW"] == "existing-no-raw"
diff --git a/pyamplicol/tests/unit/test_manual_campaign_recycled_exit.py b/pyamplicol/tests/unit/test_manual_campaign_recycled_exit.py
new file mode 100644
index 0000000000..88ebb83975
--- /dev/null
+++ b/pyamplicol/tests/unit/test_manual_campaign_recycled_exit.py
@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+import tools.performance_report.manual_campaign as manual_campaign
+from tools.performance_report.artifacts import ArtifactStore
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.manual_campaign import LightweightCurrent
+from tools.performance_report.models import ExecutionMode
+from tools.performance_report.service import ReportPaths, ReportService
+from tools.performance_report.source_identity import ReportSourceIdentity
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def test_all_recycled_run_exits_before_lease_scheduler_or_attempt(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    measurable = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and REPORT_CATALOG.static_na_reason(cell) is None
+    )
+    static_na = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is not None
+    )
+    source = ReportSourceIdentity("a" * 40, "b" * 40, ())
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    arguments = manual_campaign.build_parser().parse_args(
+        (
+            "run",
+            "--cell-id",
+            measurable.cell_id,
+            static_na.cell_id,
+            "--no-dashboard",
+        )
+    )
+    current = LightweightCurrent(
+        cell_id=measurable.cell_id,
+        attempt_id="reusable-attempt",
+        result_path=tmp_path / "result.json",
+        result={},
+        complete=True,
+        reusable=True,
+        reason="reusable",
+    )
+    events: list[str] = []
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_currents",
+        lambda *_args, **_kwargs: {measurable.cell_id: current},
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "plan_campaign",
+        lambda *_args, **_kwargs: (),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "require_measurement_ready",
+        lambda observed: events.append(f"ready:{observed.revision}"),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "update_source_marker",
+        lambda _service, observed: events.append(f"marker:{observed.revision}"),
+    )
+
+    def forbidden(*_args: object, **_kwargs: object) -> None:
+        raise AssertionError("all-recycled run reached worker/attempt setup")
+
+    monkeypatch.setattr(manual_campaign, "LeaseManager", forbidden)
+    monkeypatch.setattr(manual_campaign, "CampaignScheduler", forbidden)
+    monkeypatch.setattr(ArtifactStore, "new_attempt", forbidden)
+
+    result = manual_campaign._run_campaign(
+        arguments,
+        repo_root=ROOT,
+        service=service,
+        source=source,
+        cells=(measurable, static_na),
+        palette=manual_campaign.Palette(enabled=True),
+    )
+
+    assert result == 0
+    assert events == [f"ready:{source.revision}", f"marker:{source.revision}"]
+    output = capsys.readouterr().out
+    assert "\x1b[" in output
+    assert "selected entries" in output
+    assert "measurable entries" in output
+    assert "recycled measurable entries" in output
+    assert "static N/A entries" in output
+    assert "workers created" in output
+    assert "attempts created" in output
+    assert "All selected measurable entries were recycled (1 of 1)" in output
+    assert "no workers or attempts were created" in output
+    assert "1 selected static N/A entry remains policy unavailable" in output
+    assert not (tmp_path / "coordination" / "manual-leases").exists()
+    assert not tuple((tmp_path / "artifacts" / "cells").rglob("attempts"))
diff --git a/pyamplicol/tests/unit/test_manual_campaign_summary_and_lifecycle.py b/pyamplicol/tests/unit/test_manual_campaign_summary_and_lifecycle.py
new file mode 100644
index 0000000000..3d0f1e2707
--- /dev/null
+++ b/pyamplicol/tests/unit/test_manual_campaign_summary_and_lifecycle.py
@@ -0,0 +1,1498 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import errno
+import json
+import threading
+from collections.abc import Callable
+from concurrent.futures import Future
+from pathlib import Path
+
+import pytest
+
+import tools.performance_report.artifacts as artifacts_module
+import tools.performance_report.manual_campaign as manual_campaign
+from tools.performance_report.artifacts import (
+    ArtifactStore,
+    ArtifactStoreError,
+    DiskFullError,
+    ManifestValidationError,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.manual_campaign import (
+    DashboardState,
+    LightweightCurrent,
+    WorkerView,
+)
+from tools.performance_report.models import ArtifactPolicy
+from tools.performance_report.scheduler import (
+    CampaignResult,
+    CampaignScheduler,
+    CampaignSettings,
+    CellOutcome,
+    PlannedCell,
+    _attempt_files,
+    archive_cell_attempt_history,
+    reconcile_attempt_history,
+)
+from tools.performance_report.service import ReportPaths, ReportService
+from tools.performance_report.source_identity import ReportSourceIdentity
+
+
+def _store(tmp_path: Path) -> ArtifactStore:
+    return ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "coordination",
+    )
+
+
+def _service(tmp_path: Path) -> ReportService:
+    root = tmp_path / "repo"
+    docs = root / "docs/performance_reports/manual"
+    docs.mkdir(parents=True)
+    return ReportService(
+        ReportPaths.from_repo(
+            root,
+            docs_dir=docs,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+
+
+def _publish_with_payload(
+    store: ArtifactStore,
+    cell_id: str,
+    marker: str,
+    *,
+    artifact_path: Path | None = None,
+):
+    attempt = store.new_attempt(cell_id, ArtifactPolicy.REGENERATE)
+    payload = attempt.path("artifact/payload.bin")
+    payload.write_bytes(marker.encode("ascii"))
+    attempt.path("worker.log").write_text(f"{marker}\n", encoding="utf-8")
+    return attempt.publish(
+        {
+            "status": "ok",
+            "artifact": {
+                "path": str(
+                    (attempt.root / "artifact")
+                    if artifact_path is None
+                    else artifact_path
+                )
+            },
+        },
+        artifact_paths=("artifact/payload.bin", "worker.log"),
+    )
+
+
+def test_cell_id_files_union_comments_and_intersect(tmp_path: Path) -> None:
+    first = "scalar-contact-n2-scalar-contact-contracted"
+    second = "scalar-gravity-n2-scalar-gravity-contracted"
+    ids = tmp_path / "failed.txt"
+    ids.write_text(f"# retry set\n{first}\n\n{second}\n{first}\n", encoding="utf-8")
+    arguments = manual_campaign.build_parser().parse_args(
+        (
+            "inspect",
+            "--cell-id-file",
+            str(ids),
+            "--model",
+            "scalar_contact",
+        )
+    )
+
+    _selection, cells = manual_campaign.selection_from_arguments(arguments)
+
+    assert tuple(cell.cell_id for cell in cells) == (first,)
+
+
+def test_fail_fast_parser_help_and_steering_guide_are_explicit(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    parser = manual_campaign.build_parser()
+    arguments = parser.parse_args(("run", "--fail-fast"))
+    with pytest.raises(SystemExit) as help_exit:
+        parser.parse_args(("run", "--help"))
+    run_help = capsys.readouterr().out
+
+    assert arguments.fail_fast
+    assert help_exit.value.code == 0
+    assert "--fail-fast" in run_help
+    assert "campaign_summary_ids/fail_fast_failure.log" in run_help
+    assert "--fail-fast --workers 4 --table matrix" in manual_campaign.STEERING_GUIDE
+
+
+def test_fail_fast_terminal_classification_ignores_stop_cancellation_but_not_recycled(
+) -> None:
+    cancellation = threading.Event()
+    observed: list[dict[str, object]] = []
+    observer = manual_campaign._FailFastObserver(
+        lambda payload: observed.append(dict(payload)),
+        cancellation,
+    )
+
+    observer.observe(
+        {"event": "finished", "cell_id": "ok", "status": "skipped-current"}
+    )
+    observer.observe(
+        {"event": "finished", "cell_id": "stopped", "status": "cancelled"}
+    )
+    assert observer.failure is None
+    assert not cancellation.is_set()
+
+    observer.observe(
+        {
+            "event": "finished",
+            "cell_id": "unexpected-recycled-terminal",
+            "status": "recycled",
+            "detail": "not a scheduler success status",
+        }
+    )
+    observer.observe(
+        {"event": "finished", "cell_id": "later", "status": "error"}
+    )
+
+    assert cancellation.is_set()
+    assert observer.failure is not None
+    assert observer.failure.cell_id == "unexpected-recycled-terminal"
+    assert len(observed) == 4
+
+
+def test_fail_fast_all_static_selection_creates_no_failure_report(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is not None
+    )
+    arguments = manual_campaign.build_parser().parse_args(
+        ("run", "--fail-fast", "--no-dashboard", "--cell-id", cell.cell_id)
+    )
+
+    exit_code = manual_campaign._run_campaign(
+        arguments,
+        repo_root=tmp_path,
+        service=service,
+        source=ReportSourceIdentity("a" * 40, "b" * 40, ()),
+        cells=(cell,),
+        palette=manual_campaign.Palette(False),
+    )
+
+    summary = service.paths.docs_dir / "campaign_summary_ids"
+    assert exit_code == 0
+    assert (summary / "static_na.txt").read_text(encoding="utf-8") == (
+        f"{cell.cell_id}\n"
+    )
+    assert not (summary / manual_campaign.FAIL_FAST_FAILURE_LOG).exists()
+
+
+def test_repeated_cell_id_files_union_with_direct_ids(tmp_path: Path) -> None:
+    contact = "scalar-contact-n2-scalar-contact-contracted"
+    gravity = "scalar-gravity-n2-scalar-gravity-contracted"
+    matrix = "matrix-recurrence-builtin-sm-lc-n2-dd-z-jets-selected-flow"
+    first = tmp_path / "first.txt"
+    second = tmp_path / "second.txt"
+    first.write_text(f"{contact}\n", encoding="utf-8")
+    second.write_text(f"{gravity}\n", encoding="utf-8")
+    arguments = manual_campaign.build_parser().parse_args(
+        (
+            "inspect",
+            "--cell-id-file",
+            str(first),
+            "--cell-id-file",
+            str(second),
+            "--cell-id",
+            matrix,
+            "--multiplicity",
+            "2",
+        )
+    )
+
+    _selection, cells = manual_campaign.selection_from_arguments(arguments)
+
+    assert {cell.cell_id for cell in cells} == {contact, gravity, matrix}
+
+
+def test_cell_id_file_reports_path_line_and_rejects_wildcard(tmp_path: Path) -> None:
+    ids = tmp_path / "failed.txt"
+    ids.write_text("*\n", encoding="utf-8")
+    arguments = manual_campaign.build_parser().parse_args(
+        ("inspect", "--cell-id-file", str(ids))
+    )
+
+    with pytest.raises(
+        manual_campaign.ManualCampaignError,
+        match=rf"{ids}:1: wildcards are not allowed",
+    ):
+        manual_campaign.selection_from_arguments(arguments)
+
+
+def test_empty_cell_id_file_does_not_expand_to_all_cells(tmp_path: Path) -> None:
+    ids = tmp_path / "empty.txt"
+    ids.write_text("# no retries\n\n", encoding="utf-8")
+    arguments = manual_campaign.build_parser().parse_args(
+        ("inspect", "--cell-id-file", str(ids))
+    )
+
+    with pytest.raises(
+        manual_campaign.ManualCampaignError,
+        match="contain no canonical cell IDs",
+    ):
+        manual_campaign.selection_from_arguments(arguments)
+
+
+@pytest.mark.parametrize("wildcard", ("*", "all", "ALL"))
+def test_direct_cell_id_wildcard_still_intersects_other_selectors(
+    wildcard: str,
+) -> None:
+    arguments = manual_campaign.build_parser().parse_args(
+        ("inspect", "--cell-id", wildcard, "--model", "scalar_contact")
+    )
+
+    _selection, cells = manual_campaign.selection_from_arguments(arguments)
+
+    assert cells
+    assert all(cell.measurement.model is not None for cell in cells)
+    assert all(cell.measurement.model.value == "scalar_contact" for cell in cells)
+
+
+def test_summary_publication_replaces_stale_files_and_empty_success(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    path, counts = manual_campaign._publish_campaign_summary_ids(
+        service,
+        {
+            "error": ["cell-b", "cell-a", "cell-a"],
+            "generation_limit": {"cell-c"},
+            "ok": {"ignored"},
+        },
+    )
+
+    assert counts == {"error": 2, "generation_limit": 1}
+    assert (path / "error.txt").read_text(encoding="utf-8") == (
+        "cell-a\ncell-b\n"
+    )
+    assert (path / "generation_limit.txt").read_text(encoding="utf-8") == (
+        "cell-c\n"
+    )
+    assert not (path / manual_campaign.FAIL_FAST_FAILURE_LOG).exists()
+    (path / ".DS_Store").write_bytes(b"stale Finder metadata")
+
+    replacement, counts = manual_campaign._publish_campaign_summary_ids(service, {})
+    assert replacement == path
+    assert counts == {}
+    assert tuple(path.iterdir()) == ()
+    publication_root = (
+        service.paths.coordination_root / "campaign-summary-publication"
+    )
+    assert publication_root.is_dir()
+    assert tuple(publication_root.iterdir()) == ()
+    assert not tuple(path.parent.glob(".campaign_summary_ids.*"))
+
+
+def test_fail_fast_report_contains_exact_cell_attempt_and_reproduction_evidence(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    service = _service(tmp_path)
+    cell = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-lc-n2-dd-z-jets-selected-flow"
+    )
+    attempt = service.store.new_attempt(cell.cell_id, ArtifactPolicy.REGENERATE)
+    artifact = attempt.path("artifact")
+    artifact.mkdir()
+    attempt.path("artifact/payload.bin").write_bytes(b"retained failure payload")
+    worker_log = attempt.path("worker.log")
+    worker_log.write_text("worker failed\n", encoding="utf-8")
+    worker_progress = attempt.path("worker-progress.jsonl")
+    worker_progress.write_text('{"phase":"generation"}\n', encoding="utf-8")
+    attempt.write_json(
+        "worker-result.json",
+        {
+            "status": "error",
+            "failure": {
+                "kind": "ExactFailureClass",
+                "message": "exact failure message",
+            },
+            "artifact": {"path": str(artifact)},
+        },
+    )
+    attempt.mark_failed(
+        "ExactFailureClass: exact failure message",
+        artifact_paths=(
+            "artifact/payload.bin",
+            "worker-result.json",
+            "worker.log",
+            "worker-progress.jsonl",
+        ),
+    )
+    state = DashboardState(
+        instance_id="exact-invocation-id",
+        selected_ids=(cell.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+    )
+    state.workers[cell.cell_id] = WorkerView(
+        cell.cell_id,
+        status="error",
+        attempt_id=attempt.attempt_id,
+        log_path=str(worker_log),
+        progress_path=str(worker_progress),
+        reproduce_prepare="pyamplicol model compile --exact",
+        reproduce_generate="pyamplicol generate --exact",
+        reproduce_profile="pyamplicol profile --exact",
+    )
+    failure = manual_campaign._FailFastTerminalFailure(
+        observed_at_utc="2026-08-07T12:34:56Z",
+        cell_id=cell.cell_id,
+        status="error",
+        detail=attempt.attempt_id,
+        terminal_detail="worker reported an exact terminal detail",
+        completed_at_ns=1,
+    )
+    stale_summary = service.paths.docs_dir / "campaign_summary_ids"
+    stale_summary.mkdir()
+    (stale_summary / "stale.txt").write_text("stale\n", encoding="utf-8")
+
+    summary_path = manual_campaign._publish_completion_summary(
+        service,
+        {"error": {cell.cell_id}},
+        state=state,
+        fail_fast_failure=failure,
+        invocation_command=(
+            "steer_performance_campaign.py run --fail-fast --cell-id "
+            f"{cell.cell_id}"
+        ),
+        palette=manual_campaign.Palette(False),
+    )
+
+    report_path = summary_path / manual_campaign.FAIL_FAST_FAILURE_LOG
+    report = report_path.read_text(encoding="utf-8")
+    assert report_path.name == "fail_fast_failure.log"
+    assert not (summary_path / "stale.txt").exists()
+    for expected in (
+        "timestamp_utc: 2026-08-07T12:34:56Z",
+        "campaign_invocation_id: exact-invocation-id",
+        "campaign_invocation: steer_performance_campaign.py run --fail-fast",
+        f"cell_id: {cell.cell_id}",
+        "process_family_id: 1",
+        f"process_key: {cell.process_key}",
+        f"process: {cell.process}",
+        f"n_final: {cell.n_final}",
+        "mode: recurrence",
+        "workload: selected-flow",
+        "accuracy: lc",
+        "terminal_status: error",
+        f"outcome_detail: {attempt.attempt_id}",
+        "terminal_detail: worker reported an exact terminal detail",
+        "failure_class: ExactFailureClass",
+        "failure_message: exact failure message",
+        f"attempt_uuid: {attempt.attempt_id}",
+        f"attempt_root: {attempt.root}",
+        f"artifact_path: {artifact}",
+        f"worker_log_path: {worker_log}",
+        f"worker_progress_path: {worker_progress}",
+        "reproduce_prepare: pyamplicol model compile --exact",
+        "reproduce_generate: pyamplicol generate --exact",
+        "reproduce_profile: pyamplicol profile --exact",
+    ):
+        assert expected in report
+    captured = capsys.readouterr()
+    assert str(report_path) in captured.err
+    assert str(artifact) in captured.err
+    assert str(worker_log) in captured.err
+    assert (summary_path / "error.txt").read_text(encoding="utf-8") == (
+        f"{cell.cell_id}\n"
+    )
+
+
+def test_fail_fast_cancels_live_worker_and_never_dispatches_third_cell(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cells = tuple(
+        REPORT_CATALOG.cell(
+            f"matrix-recurrence-builtin-sm-lc-n{n_final}-dd-z-jets-selected-flow"
+        )
+        for n_final in (1, 2, 3)
+    )
+    cancellation = threading.Event()
+    observer = manual_campaign._FailFastObserver(lambda _payload: None, cancellation)
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            workers=2,
+            source_identity_override=ReportSourceIdentity("a" * 40, "b" * 40, ()),
+            progress_observer=observer.observe,
+            cancellation_requested=cancellation.is_set,
+        ),
+    )
+    live_started = threading.Event()
+    live_saw_cancellation = threading.Event()
+    launched: list[str] = []
+    launched_guard = threading.Lock()
+
+    def run_lane(
+        _scheduler: CampaignScheduler,
+        item: PlannedCell,
+    ) -> CellOutcome:
+        with launched_guard:
+            launched.append(item.cell.cell_id)
+        if item.cell.cell_id == cells[0].cell_id:
+            assert live_started.wait(timeout=2.0)
+            return CellOutcome(item.cell.cell_id, "error", "first failure")
+        if item.cell.cell_id == cells[1].cell_id:
+            live_started.set()
+            assert cancellation.wait(timeout=2.0)
+            live_saw_cancellation.set()
+            return CellOutcome(
+                item.cell.cell_id,
+                "cancelled",
+                "worker terminated by cancellation",
+            )
+        raise AssertionError("fail-fast dispatched a third cell")
+
+    monkeypatch.setattr(CampaignScheduler, "_run_cell_in_lane", run_lane)
+    result = scheduler.run(
+        tuple(
+            PlannedCell(cell, False, None, index)
+            for index, cell in enumerate(cells)
+        )
+    )
+
+    assert set(launched) == {cells[0].cell_id, cells[1].cell_id}
+    assert live_saw_cancellation.is_set()
+    assert cells[2].cell_id not in launched
+    assert observer.failure is not None
+    assert observer.failure.cell_id == cells[0].cell_id
+    assert {outcome.status for outcome in result.outcomes} == {"error", "cancelled"}
+
+
+def test_scheduler_rechecks_fail_fast_before_each_multiworker_submission(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cells = tuple(
+        REPORT_CATALOG.cell(
+            f"matrix-recurrence-builtin-sm-lc-n{n_final}-dd-z-jets-selected-flow"
+        )
+        for n_final in (1, 2, 3)
+    )
+    cancellation = threading.Event()
+    observer = manual_campaign._FailFastObserver(lambda _payload: None, cancellation)
+    submitted: list[str] = []
+
+    class ImmediateExecutor:
+        def __init__(self, *_args: object, **_kwargs: object) -> None:
+            pass
+
+        def __enter__(self) -> ImmediateExecutor:
+            return self
+
+        def __exit__(self, *_args: object) -> None:
+            return None
+
+        def submit(
+            self,
+            function: Callable[[PlannedCell], CellOutcome],
+            item: PlannedCell,
+        ) -> Future[CellOutcome]:
+            submitted.append(item.cell.cell_id)
+            future: Future[CellOutcome] = Future()
+            try:
+                future.set_result(function(item))
+            except BaseException as error:
+                future.set_exception(error)
+            return future
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.ThreadPoolExecutor",
+        ImmediateExecutor,
+    )
+    monkeypatch.setattr(
+        CampaignScheduler,
+        "_run_cell_in_lane",
+        lambda _scheduler, item: CellOutcome(
+            item.cell.cell_id,
+            "error",
+            "synchronous first failure",
+        ),
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            workers=3,
+            source_identity_override=ReportSourceIdentity("a" * 40, "b" * 40, ()),
+            progress_observer=observer.observe,
+            cancellation_requested=cancellation.is_set,
+        ),
+    )
+
+    result = scheduler.run(
+        tuple(
+            PlannedCell(cell, False, None, index)
+            for index, cell in enumerate(cells)
+        )
+    )
+
+    assert submitted == [cells[0].cell_id]
+    assert tuple(outcome.cell_id for outcome in result.outcomes) == (
+        cells[0].cell_id,
+    )
+
+
+def test_epyc_n9_codec_limit_summary_round_trips_to_exact_run_selection(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    cell_id = "matrix-recurrence-builtin-sm-lc-n9-gg-gluons-selected-flow"
+    summary, _counts = manual_campaign._publish_campaign_summary_ids(
+        service,
+        {"error": {cell_id}},
+    )
+    arguments = manual_campaign.build_parser().parse_args(
+        ("run", "--dry-run", "--cell-id-file", str(summary / "error.txt"))
+    )
+
+    _selection, cells = manual_campaign.selection_from_arguments(arguments)
+
+    assert tuple(cell.cell_id for cell in cells) == (cell_id,)
+
+
+def test_unverified_summary_round_trips_to_exact_retry_selection(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    cell_id = "matrix-compiled-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    result = CampaignResult(
+        planned=(),
+        outcomes=(
+            CellOutcome(
+                cell_id,
+                "unverified",
+                "independent numerical authority unavailable",
+            ),
+        ),
+    )
+    categories = manual_campaign._campaign_summary_categories(result=result)
+    summary, counts = manual_campaign._publish_campaign_summary_ids(
+        service,
+        categories,
+    )
+
+    assert counts == {"unverified": 1}
+    selection_file = summary / "unverified.txt"
+    assert selection_file.read_text(encoding="utf-8") == f"{cell_id}\n"
+    arguments = manual_campaign.build_parser().parse_args(
+        ("run", "--dry-run", "--cell-id-file", str(selection_file))
+    )
+
+    _selection, cells = manual_campaign.selection_from_arguments(arguments)
+
+    assert tuple(cell.cell_id for cell in cells) == (cell_id,)
+
+
+def test_interrupted_summary_contains_observed_not_unstarted_cells() -> None:
+    state = DashboardState(
+        instance_id="invocation",
+        selected_ids=("running", "failed", "unstarted"),
+        recycled_ids=set(),
+        static_na_ids=set(),
+    )
+    state.workers["running"] = WorkerView("running", status="running")
+    state.workers["failed"] = WorkerView("failed", status="error")
+    state.invocation_evidence_ids.update({"running", "failed"})
+
+    categories = manual_campaign._campaign_summary_categories(
+        state=state,
+        interrupted=True,
+    )
+
+    assert categories == {"interrupted": {"running"}, "error": {"failed"}}
+
+
+def test_cancelled_outcome_is_omitted_without_started_observation() -> None:
+    state = DashboardState(
+        instance_id="invocation",
+        selected_ids=("started", "unstarted"),
+        recycled_ids=set(),
+        static_na_ids=set(),
+    )
+    state.workers["started"] = WorkerView("started", status="cancelled")
+    state.invocation_evidence_ids.add("started")
+    result = CampaignResult(
+        planned=(),
+        outcomes=(
+            CellOutcome("started", "cancelled", "worker cancelled"),
+            CellOutcome("unstarted", "cancelled", "not started"),
+        ),
+    )
+
+    categories = manual_campaign._campaign_summary_categories(
+        result=result,
+        state=state,
+        interrupted=True,
+    )
+
+    assert categories == {"interrupted": {"started"}}
+
+
+def test_lease_finished_cancelled_not_started_is_not_interruption_evidence(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    state = DashboardState(
+        instance_id="invocation",
+        selected_ids=("queued", "started"),
+        recycled_ids=set(),
+        static_na_ids=set(),
+    )
+    lease = manual_campaign.LeaseManager(service, state)
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": "queued",
+            "status": "cancelled",
+            "detail": "not started",
+        }
+    )
+    lease.observe({"event": "started", "cell_id": "started"})
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": "started",
+            "status": "cancelled",
+            "detail": "worker terminated by cancellation",
+        }
+    )
+    result = CampaignResult(
+        planned=(),
+        outcomes=(
+            CellOutcome("queued", "cancelled", "not started"),
+            CellOutcome("started", "cancelled", "worker cancelled"),
+        ),
+    )
+
+    categories = manual_campaign._campaign_summary_categories(
+        result=result,
+        state=state,
+        interrupted=True,
+    )
+    lease.close()
+
+    assert state.invocation_evidence_ids == {"started"}
+    assert categories == {"interrupted": {"started"}}
+
+
+def test_summary_omits_success_and_recycled_cells_but_keeps_future_statuses() -> None:
+    state = DashboardState(
+        instance_id="invocation",
+        selected_ids=("recycled-cap", "ok", "future", "static"),
+        recycled_ids={"recycled-cap"},
+        static_na_ids={"static"},
+    )
+    state.workers["recycled-cap"] = WorkerView(
+        "recycled-cap",
+        status="memory_limit",
+        recycled=True,
+    )
+    result = CampaignResult(
+        planned=(),
+        outcomes=(
+            CellOutcome("ok", "ok", "complete"),
+            CellOutcome("future", "Native Crash / Retry", "failed"),
+        ),
+    )
+
+    categories = manual_campaign._campaign_summary_categories(
+        static_na_ids=state.static_na_ids,
+        result=result,
+        state=state,
+    )
+
+    assert categories == {
+        "native_crash_retry": {"future"},
+        "static_na": {"static"},
+    }
+
+
+def test_cleanup_warning_is_retained_for_dashboard_and_printed_headlessly(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    service = _service(tmp_path)
+    state = DashboardState(
+        instance_id="invocation",
+        selected_ids=("cell",),
+        recycled_ids=set(),
+        static_na_ids=set(),
+    )
+    lease = manual_campaign.LeaseManager(service, state)
+
+    lease.observe(
+        {
+            "event": "cleanup-warning",
+            "cell_id": "cell",
+            "detail": "DiskFullError: 0 bytes available",
+        }
+    )
+    manual_campaign._print_cleanup_warnings(
+        state,
+        manual_campaign.Palette(False),
+    )
+    lease.close()
+
+    assert state.cleanup_warnings == [
+        ("cell", "DiskFullError: 0 bytes available")
+    ]
+    assert state.workers["cell"].events[-1] == (
+        "cleanup warning: DiskFullError: 0 bytes available"
+    )
+    assert capsys.readouterr().err == (
+        "artifact cleanup skipped for cell: "
+        "DiskFullError: 0 bytes available\n"
+    )
+
+
+def test_obsolete_attempt_archives_metadata_but_removes_heavy_payload(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    old = _publish_with_payload(store, "cell", "old")
+    current = _publish_with_payload(store, "cell", "current")
+
+    archived = store.archive_obsolete_attempts(
+        "cell",
+        consumer_cell_ids=("cell",),
+    )
+
+    assert archived == (old.attempt_id,)
+    history = store._attempt_history_cell_root("cell") / old.attempt_id
+    assert (history / "manifest.json").is_file()
+    assert (history / "result.json").is_file()
+    assert (history / "worker.log").read_text(encoding="utf-8") == "old\n"
+    assert not (history / "artifact").exists()
+    assert store.load_current("cell").attempt_id == current.attempt_id
+    assert (current.manifest_path.parent / "artifact/payload.bin").is_file()
+
+
+def test_equivalent_consumer_keeps_superseded_owner_until_reference_moves(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    owner = _publish_with_payload(store, "owner", "owner")
+    current = _publish_with_payload(store, "owner", "current")
+    consumer = store.new_attempt("consumer", ArtifactPolicy.REGENERATE)
+    consumer.publish(
+        {
+            "status": "ok",
+            "artifact": {"path": str(owner.manifest_path.parent / "artifact")},
+        }
+    )
+
+    assert store.archive_obsolete_attempts(
+        "owner",
+        consumer_cell_ids=("owner", "consumer"),
+    ) == ()
+    assert (owner.manifest_path.parent / "artifact/payload.bin").is_file()
+
+    _publish_with_payload(store, "consumer", "independent")
+    assert store.archive_obsolete_attempts(
+        "owner",
+        consumer_cell_ids=("owner", "consumer"),
+    ) == (owner.attempt_id,)
+    assert store.load_current("owner").attempt_id == current.attempt_id
+
+
+def test_active_unsealed_attempt_is_not_archived(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    current = _publish_with_payload(store, "cell", "current")
+    active = store.new_attempt("cell", ArtifactPolicy.REGENERATE, based_on=current)
+    active.path("worker.log").write_text("still running\n", encoding="utf-8")
+
+    assert store.archive_obsolete_attempts(
+        "cell", consumer_cell_ids=("cell",)
+    ) == ()
+    assert active.root.is_dir()
+    assert not (active.root / "manifest.json").exists()
+
+
+def test_malformed_current_pointer_prevents_cleanup(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    old = _publish_with_payload(store, "cell", "old")
+    current = _publish_with_payload(store, "cell", "current")
+    pointer_path = current.manifest_path.parent.parent.parent / "current.json"
+    pointer = json.loads(pointer_path.read_text(encoding="utf-8"))
+    pointer["manifest_path"] = "../unsafe/manifest.json"
+    pointer_path.write_text(json.dumps(pointer) + "\n", encoding="utf-8")
+
+    with pytest.raises(ManifestValidationError, match="canonical attempt manifest"):
+        store.archive_obsolete_attempts("cell", consumer_cell_ids=("cell",))
+
+    assert old.manifest_path.is_file()
+    assert current.manifest_path.is_file()
+
+
+def test_symlinked_cell_root_fails_closed_for_read_and_cleanup(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    external = tmp_path / "escaped-cell"
+    external.mkdir()
+    cell_root = store._cell_root("cell")
+    cell_root.symlink_to(external, target_is_directory=True)
+
+    with pytest.raises(ManifestValidationError, match="cell root is a symbolic link"):
+        store.load_current("cell", missing_ok=True)
+    with pytest.raises(ManifestValidationError, match="cell root is a symbolic link"):
+        store.archive_obsolete_attempts("cell", consumer_cell_ids=("cell",))
+
+    assert tuple(external.iterdir()) == ()
+
+
+def test_symlinked_current_pointer_fails_closed_for_read_and_cleanup(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    current = _publish_with_payload(store, "cell", "current")
+    pointer = store._cell_root("cell") / "current.json"
+    external = tmp_path / "escaped-current.json"
+    pointer.replace(external)
+    pointer.symlink_to(external)
+
+    with pytest.raises(ManifestValidationError, match="pointer is a symbolic link"):
+        store.load_current("cell")
+    with pytest.raises(ManifestValidationError, match="pointer is a symbolic link"):
+        store.archive_obsolete_attempts("cell", consumer_cell_ids=("cell",))
+
+    assert current.manifest_path.is_file()
+
+
+def test_symlinked_current_manifest_fails_closed_for_read_and_cleanup(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    old = _publish_with_payload(store, "cell", "old")
+    current = _publish_with_payload(store, "cell", "current")
+    external = tmp_path / "escaped-manifest.json"
+    current.manifest_path.replace(external)
+    current.manifest_path.symlink_to(external)
+
+    with pytest.raises(ManifestValidationError, match="manifest_path is not a regular"):
+        store.load_current("cell")
+    with pytest.raises(ManifestValidationError, match="manifest_path is not a regular"):
+        store.archive_obsolete_attempts("cell", consumer_cell_ids=("cell",))
+
+    assert old.manifest_path.is_file()
+
+
+def test_attempt_history_collision_prevents_cleanup(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    old = _publish_with_payload(store, "cell", "old")
+    _publish_with_payload(store, "cell", "current")
+    collision = store._attempt_history_cell_root("cell") / old.attempt_id
+    collision.mkdir(parents=True)
+
+    with pytest.raises(ArtifactStoreError, match="history collision"):
+        store.archive_obsolete_attempts("cell", consumer_cell_ids=("cell",))
+
+    assert old.manifest_path.is_file()
+
+
+def test_catalog_reconciliation_is_bounded_and_preserves_current(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    old = _publish_with_payload(service.store, cell.cell_id, "old")
+    current = _publish_with_payload(service.store, cell.cell_id, "current")
+
+    assert reconcile_attempt_history(service, (cell,)) == ()
+    assert service.store.load_current(cell.cell_id).attempt_id == current.attempt_id
+    assert not old.manifest_path.exists()
+    assert (
+        service.store._attempt_history_cell_root(cell.cell_id)
+        / old.attempt_id
+        / "manifest.json"
+    ).is_file()
+
+
+def test_scheduler_runs_cleanup_after_each_cell(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    old = _publish_with_payload(service.store, cell.cell_id, "old")
+    current = _publish_with_payload(service.store, cell.cell_id, "current")
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            source_identity_override=ReportSourceIdentity("a" * 40, "b" * 40, ()),
+            remove_heavy_attempt_artifacts=True,
+        ),
+    )
+    monkeypatch.setattr(
+        scheduler,
+        "_run_cell_in_lane",
+        lambda _planned: CellOutcome(cell.cell_id, "reused", current.attempt_id),
+    )
+
+    outcome = scheduler._run_cell(PlannedCell(cell, False, None, 0))
+
+    assert outcome.status == "reused"
+    assert not old.manifest_path.exists()
+    assert service.store.load_current(cell.cell_id).attempt_id == current.attempt_id
+
+
+@pytest.mark.parametrize(
+    ("extra_arguments", "cleanup_expected"),
+    (
+        ((), True),
+        (("--cleanup-artifacts",), True),
+        (("--retain-workspaces",), False),
+    ),
+)
+def test_all_recycled_run_applies_selected_startup_cleanup_policy(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    extra_arguments: tuple[str, ...],
+    cleanup_expected: bool,
+) -> None:
+    service = _service(tmp_path)
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    old = _publish_with_payload(service.store, cell.cell_id, "old")
+    current = _publish_with_payload(service.store, cell.cell_id, "current")
+    source = ReportSourceIdentity("a" * 40, "b" * 40, ())
+    lightweight_result = {
+        "status": "ok",
+        "provenance": {"report_source_revision": source.revision},
+    }
+    lightweight = LightweightCurrent(
+        cell.cell_id,
+        current.attempt_id,
+        current.result_path,
+        lightweight_result,
+        True,
+        True,
+        "reusable",
+        current,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_currents",
+        lambda *_args, **_kwargs: {cell.cell_id: lightweight},
+    )
+    monkeypatch.setattr(manual_campaign, "plan_campaign", lambda *_a, **_k: ())
+    monkeypatch.setattr(
+        manual_campaign,
+        "require_measurement_ready",
+        lambda _source: None,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "update_source_marker",
+        lambda *_args, **_kwargs: False,
+    )
+    arguments = manual_campaign.build_parser().parse_args(
+        (
+            "run",
+            "--no-dashboard",
+            "--cell-id",
+            cell.cell_id,
+            *extra_arguments,
+        )
+    )
+
+    exit_code = manual_campaign._run_campaign(
+        arguments,
+        repo_root=tmp_path,
+        service=service,
+        source=source,
+        cells=(cell,),
+        palette=manual_campaign.Palette(False),
+    )
+
+    assert exit_code == 0
+    assert old.manifest_path.exists() is not cleanup_expected
+    assert service.store.load_current(cell.cell_id).attempt_id == current.attempt_id
+
+
+def test_immediate_scheduler_preflight_error_preserves_previous_summary(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    source = ReportSourceIdentity("a" * 40, "b" * 40, ())
+    summary, _counts = manual_campaign._publish_campaign_summary_ids(
+        service,
+        {"error": {"previous-cell"}},
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_currents",
+        lambda *_args, **_kwargs: {},
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "plan_campaign",
+        lambda *_args, **_kwargs: (PlannedCell(cell, False, None, 0),),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_bind_original_amplicol_if_required",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(manual_campaign, "require_measurement_ready", lambda _s: None)
+    monkeypatch.setattr(manual_campaign, "update_source_marker", lambda *_a: False)
+    monkeypatch.setattr(
+        manual_campaign,
+        "reconcile_attempt_history",
+        lambda *_args, **_kwargs: (),
+    )
+
+    class ImmediateFailureScheduler:
+        def __init__(self, *_args: object, **_kwargs: object) -> None:
+            pass
+
+        def run(self, _planned: object) -> CampaignResult:
+            raise RuntimeError("plan preflight failed before dispatch")
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "CampaignScheduler",
+        ImmediateFailureScheduler,
+    )
+    arguments = manual_campaign.build_parser().parse_args(
+        ("run", "--no-dashboard", "--cell-id", cell.cell_id)
+    )
+
+    with pytest.raises(RuntimeError, match="before dispatch"):
+        manual_campaign._run_campaign(
+            arguments,
+            repo_root=tmp_path,
+            service=service,
+            source=source,
+            cells=(cell,),
+            palette=manual_campaign.Palette(False),
+        )
+
+    assert (summary / "error.txt").read_text(encoding="utf-8") == (
+        "previous-cell\n"
+    )
+    assert tuple(path.name for path in summary.iterdir()) == ("error.txt",)
+
+
+def test_fail_fast_first_failure_stops_later_scheduler_dispatch_and_exits_nonzero(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    service = _service(tmp_path)
+    cells = tuple(
+        REPORT_CATALOG.cell(
+            f"matrix-recurrence-builtin-sm-lc-n{n_final}-dd-z-jets-selected-flow"
+        )
+        for n_final in (1, 2, 3)
+    )
+    planned = tuple(
+        PlannedCell(cell, dependency=False, baseline_cell_id=None, rank=index)
+        for index, cell in enumerate(cells)
+    )
+    source = ReportSourceIdentity("a" * 40, "b" * 40, ())
+    dispatched: list[str] = []
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_currents",
+        lambda *_args, **_kwargs: {},
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "plan_campaign",
+        lambda *_args, **_kwargs: planned,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_bind_original_amplicol_if_required",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(manual_campaign, "require_measurement_ready", lambda _s: None)
+    monkeypatch.setattr(
+        manual_campaign,
+        "update_source_marker",
+        lambda *_args, **_kwargs: False,
+    )
+
+    def terminal_failure(
+        _scheduler: CampaignScheduler,
+        item: PlannedCell,
+    ) -> CellOutcome:
+        dispatched.append(item.cell.cell_id)
+        return CellOutcome(
+            item.cell.cell_id,
+            "validation_failed",
+            "first exact failure",
+            terminal_detail="independent audit mismatch",
+        )
+
+    monkeypatch.setattr(CampaignScheduler, "_run_cell_in_lane", terminal_failure)
+    arguments = manual_campaign.build_parser().parse_args(
+        (
+            "run",
+            "--fail-fast",
+            "--no-dashboard",
+            "--workers",
+            "1",
+            "--cell-id",
+            *(cell.cell_id for cell in cells),
+        )
+    )
+    arguments._campaign_invocation_command = (
+        "steer_performance_campaign.py run --fail-fast --no-dashboard --workers 1"
+    )
+
+    exit_code = manual_campaign._run_campaign(
+        arguments,
+        repo_root=tmp_path,
+        service=service,
+        source=source,
+        cells=cells,
+        palette=manual_campaign.Palette(False),
+    )
+
+    assert exit_code == 1
+    assert dispatched == [cells[0].cell_id]
+    summary_path = service.paths.docs_dir / "campaign_summary_ids"
+    report_path = summary_path / manual_campaign.FAIL_FAST_FAILURE_LOG
+    assert report_path.is_file()
+    report = report_path.read_text(encoding="utf-8")
+    assert f"cell_id: {cells[0].cell_id}" in report
+    assert "terminal_status: validation_failed" in report
+    assert "outcome_detail: first exact failure" in report
+    assert "terminal_detail: independent audit mismatch" in report
+    assert "attempt_uuid: <unavailable>" in report
+    assert not any(cell.cell_id in report for cell in cells[1:])
+    assert (summary_path / "validation_failed.txt").read_text(
+        encoding="utf-8"
+    ) == f"{cells[0].cell_id}\n"
+    captured = capsys.readouterr()
+    assert "Fail-fast stopped dispatch" in captured.err
+    assert str(report_path) in captured.err
+
+
+def test_concurrent_summary_publications_are_each_coherent(tmp_path: Path) -> None:
+    service = _service(tmp_path)
+    barrier = threading.Barrier(3)
+    errors: list[BaseException] = []
+
+    def publish(status: str, cell_id: str) -> None:
+        try:
+            barrier.wait(timeout=5)
+            manual_campaign._publish_campaign_summary_ids(
+                service,
+                {status: {cell_id}},
+            )
+        except BaseException as error:
+            errors.append(error)
+
+    threads = (
+        threading.Thread(target=publish, args=("error", "cell-error")),
+        threading.Thread(
+            target=publish,
+            args=("memory_limit", "cell-memory"),
+        ),
+    )
+    for thread in threads:
+        thread.start()
+    barrier.wait(timeout=5)
+    for thread in threads:
+        thread.join(timeout=5)
+
+    assert not errors
+    assert all(not thread.is_alive() for thread in threads)
+    summary = service.paths.docs_dir / "campaign_summary_ids"
+    files = tuple(summary.iterdir())
+    assert len(files) == 1
+    assert (files[0].name, files[0].read_text(encoding="utf-8")) in {
+        ("error.txt", "cell-error\n"),
+        ("memory_limit.txt", "cell-memory\n"),
+    }
+    assert not tuple(summary.parent.glob(".campaign_summary_ids.*"))
+
+
+def test_scheduler_cleanup_flag_defaults_on_and_invocation_is_validated() -> None:
+    assert CampaignSettings().remove_heavy_attempt_artifacts is True
+    settings = CampaignSettings(campaign_invocation_id="abc")
+    assert settings.campaign_invocation_id == "abc"
+    with pytest.raises(ValueError, match="campaign_invocation_id"):
+        CampaignSettings(campaign_invocation_id="bad\nvalue")
+
+
+def test_compact_attempt_inventory_excludes_only_heavy_artifact(tmp_path: Path) -> None:
+    root = tmp_path / "attempt"
+    (root / "artifact/nested").mkdir(parents=True)
+    (root / "artifact/nested/data.bin").write_bytes(b"heavy")
+    (root / "worker.log").write_text("diagnostic\n", encoding="utf-8")
+    (root / "worker-progress.jsonl").write_text("{}\n", encoding="utf-8")
+
+    assert _attempt_files(root, include_heavy_artifact=False) == (
+        "worker-progress.jsonl",
+        "worker.log",
+    )
+    assert "artifact/nested/data.bin" in _attempt_files(root)
+
+
+def test_manual_campaign_defaults_to_compact_artifacts() -> None:
+    source = ReportSourceIdentity("a" * 40, "b" * 40, ())
+    default_arguments = manual_campaign.build_parser().parse_args(("run", "--dry-run"))
+    cleanup_arguments = manual_campaign.build_parser().parse_args(
+        ("run", "--dry-run", "--cleanup-artifacts")
+    )
+    fail_fast_cleanup_arguments = manual_campaign.build_parser().parse_args(
+        ("run", "--dry-run", "--fail-fast", "--cleanup-artifacts")
+    )
+    retained_arguments = manual_campaign.build_parser().parse_args(
+        ("run", "--dry-run", "--retain-workspaces")
+    )
+
+    assert manual_campaign._campaign_settings(
+        default_arguments, source
+    ).remove_heavy_attempt_artifacts
+    assert not manual_campaign._campaign_settings(
+        default_arguments, source
+    ).discard_cancelled_attempts
+    assert manual_campaign._campaign_settings(
+        cleanup_arguments, source
+    ).remove_heavy_attempt_artifacts
+    fail_fast_settings = manual_campaign._campaign_settings(
+        fail_fast_cleanup_arguments,
+        source,
+    )
+    assert fail_fast_settings.remove_heavy_attempt_artifacts
+    assert not fail_fast_settings.discard_cancelled_attempts
+    retained_settings = manual_campaign._campaign_settings(
+        retained_arguments,
+        source,
+    )
+    assert retained_settings.retain_workspaces
+    assert not retained_settings.remove_heavy_attempt_artifacts
+
+
+@pytest.mark.parametrize(
+    ("extra_arguments", "expected"),
+    (
+        ((), "compact retention (default)"),
+        (("--cleanup-artifacts",), "compact retention (default)"),
+        (
+            ("--fail-fast", "--cleanup-artifacts"),
+            "compact retention (default)",
+        ),
+        (("--retain-workspaces",), "full debug workspaces (--retain-workspaces)"),
+    ),
+)
+def test_dry_run_prints_effective_artifact_cleanup_policy(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    extra_arguments: tuple[str, ...],
+    expected: str,
+) -> None:
+    service = _service(tmp_path)
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    source = ReportSourceIdentity("a" * 40, "b" * 40, ())
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_currents",
+        lambda *_a, **_k: {},
+    )
+    monkeypatch.setattr(manual_campaign, "plan_campaign", lambda *_a, **_k: ())
+    monkeypatch.setattr(
+        manual_campaign,
+        "_dry_run_recipe_blocks",
+        lambda *_args, **_kwargs: (),
+    )
+    arguments = manual_campaign.build_parser().parse_args(
+        (
+            "run",
+            "--dry-run",
+            "--no-color",
+            "--cell-id",
+            cell.cell_id,
+            *extra_arguments,
+        )
+    )
+
+    assert (
+        manual_campaign._run_campaign(
+            arguments,
+            repo_root=tmp_path,
+            service=service,
+            source=source,
+            cells=(cell,),
+            palette=manual_campaign.Palette(False),
+        )
+        == 0
+    )
+
+    assert expected in capsys.readouterr().out
+    assert not (
+        service.paths.docs_dir
+        / "campaign_summary_ids"
+        / manual_campaign.FAIL_FAST_FAILURE_LOG
+    ).exists()
+
+
+def test_cleanup_skips_busy_owner_use_lock(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    old = _publish_with_payload(store, "cell", "old")
+    _publish_with_payload(store, "cell", "current")
+    acquired = threading.Event()
+    release = threading.Event()
+
+    def hold() -> None:
+        with store.named_lock(f"campaign-artifact-use-{old.attempt_id}"):
+            acquired.set()
+            assert release.wait(timeout=5)
+
+    thread = threading.Thread(target=hold)
+    thread.start()
+    assert acquired.wait(timeout=5)
+    try:
+        assert store.archive_obsolete_attempts(
+            "cell", consumer_cell_ids=("cell",)
+        ) == ()
+        assert old.manifest_path.is_file()
+    finally:
+        release.set()
+        thread.join(timeout=5)
+    assert not thread.is_alive()
+
+
+def test_unsafe_heavy_payload_fails_closed_before_attempt_move(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    old = _publish_with_payload(store, "cell", "old")
+    _publish_with_payload(store, "cell", "current")
+    (old.manifest_path.parent / "artifact/unsafe-link").symlink_to(tmp_path)
+
+    with pytest.raises(ArtifactStoreError, match="unsafe member"):
+        store.archive_obsolete_attempts("cell", consumer_cell_ids=("cell",))
+
+    assert old.manifest_path.is_file()
+    assert store.load_current("cell") is not None
+
+
+def test_unsafe_root_diagnostic_fails_closed_before_attempt_move(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    old = _publish_with_payload(store, "cell", "old")
+    _publish_with_payload(store, "cell", "current")
+    worker_log = old.manifest_path.parent / "worker.log"
+    worker_log.unlink()
+    worker_log.symlink_to(tmp_path / "outside.log")
+
+    with pytest.raises(ArtifactStoreError, match="unsafe member"):
+        store.archive_obsolete_attempts("cell", consumer_cell_ids=("cell",))
+
+    assert old.manifest_path.is_file()
+    assert worker_log.is_symlink()
+    assert store.load_current("cell") is not None
+
+
+def test_atomic_report_write_normalizes_enospc(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    destination = tmp_path / "result.json"
+
+    def no_space(_source: object, _destination: object) -> None:
+        raise OSError(errno.ENOSPC, "no space left")
+
+    monkeypatch.setattr(artifacts_module.os, "replace", no_space)
+    with pytest.raises(DiskFullError, match=r"disk full while writing .*result.json"):
+        artifacts_module._atomic_write_json(destination, {"status": "ok"})
+
+
+def test_attempt_archive_normalizes_enospc_without_moving_source(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    store = _store(tmp_path)
+    old = _publish_with_payload(store, "cell", "old")
+    _publish_with_payload(store, "cell", "current")
+
+    def no_space(_source: object, _destination: object) -> None:
+        raise OSError(errno.ENOSPC, "no space left")
+
+    monkeypatch.setattr(artifacts_module.os, "replace", no_space)
+    with pytest.raises(
+        DiskFullError,
+        match=r"disk full while writing .*attempt-history",
+    ):
+        store.archive_obsolete_attempts("cell", consumer_cell_ids=("cell",))
+
+    assert old.manifest_path.is_file()
+
+
+def test_summary_publication_normalizes_enospc(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+
+    def no_space(_source: object, _destination: object) -> None:
+        raise OSError(errno.ENOSPC, "no space left")
+
+    monkeypatch.setattr(manual_campaign.os, "replace", no_space)
+    with pytest.raises(
+        DiskFullError,
+        match=r"disk full while writing .*campaign_summary_ids",
+    ):
+        manual_campaign._publish_campaign_summary_ids(
+            service,
+            {"error": {"cell"}},
+        )
+
+    publication_root = (
+        service.paths.coordination_root / "campaign-summary-publication"
+    )
+    assert tuple(publication_root.iterdir()) == ()
+
+
+def test_controller_atomic_json_normalizes_enospc_with_target_and_free_bytes(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    destination = tmp_path / "worker-result.json"
+
+    def no_space(_source: object, _destination: object) -> None:
+        raise OSError(errno.ENOSPC, "no space left")
+
+    monkeypatch.setattr(manual_campaign.os, "replace", no_space)
+    with pytest.raises(
+        DiskFullError,
+        match=(
+            r"disk full while writing .*worker-result\.json; "
+            r"[0-9]+ bytes available"
+        ),
+    ):
+        manual_campaign._atomic_json(destination, {"status": "error"})
+
+    assert not destination.exists()
+    assert not tuple(tmp_path.glob(".worker-result.json.*.tmp"))
+
+
+def test_scheduler_archive_helper_uses_catalog_equivalence(tmp_path: Path) -> None:
+    service = _service(tmp_path)
+    cell = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    )
+    old = _publish_with_payload(service.store, cell.cell_id, "old")
+    _publish_with_payload(service.store, cell.cell_id, "current")
+
+    assert archive_cell_attempt_history(service, cell) == (old.attempt_id,)
diff --git a/pyamplicol/tests/unit/test_manual_performance_campaign.py b/pyamplicol/tests/unit/test_manual_performance_campaign.py
new file mode 100644
index 0000000000..7c39f999b1
--- /dev/null
+++ b/pyamplicol/tests/unit/test_manual_performance_campaign.py
@@ -0,0 +1,6415 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import ast
+import base64
+import io
+import json
+import os
+import shutil
+import struct
+import subprocess
+import sys
+import threading
+import time
+import tomllib
+from pathlib import Path
+
+import pytest
+
+import tools.performance_report.manual_campaign as manual_campaign
+import tools.performance_report.workspace as workspace_module
+from tools.performance_report.artifacts import LockCancelledError
+from tools.performance_report.cache import empty_measurement
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.manual_campaign import (
+    DEFAULT_MANUAL_EXPECTED_PAGE_COUNT,
+    MANUAL_STATE_SCHEMA,
+    Comparison,
+    DashboardState,
+    LeaseManager,
+    LightweightCurrent,
+    ManualCampaignError,
+    ReproductionSettings,
+    WorkerView,
+    _handle_dashboard_key,
+    _index_metadata_dirty_paths,
+    _install_report_snapshot,
+    _live_dashboard_snapshot,
+    _manual_static_na_reason,
+    _merge_lightweight_snapshot,
+    _progress_detail_summary,
+    _result_matches_cell,
+    _snapshot_fixture,
+    _tail_progress,
+    build_parser,
+    comparison_statistics,
+    render_dashboard_frame,
+    reproduction_recipe,
+    selection_from_arguments,
+)
+from tools.performance_report.manual_campaign import main as campaign_main
+from tools.performance_report.models import (
+    CellSpec,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from tools.performance_report.publication import (
+    PublicationPortabilityError,
+    portable_publication_value,
+)
+from tools.performance_report.publisher import _compile_pdf
+from tools.performance_report.scheduler import CellOutcome, _CoordinationDeferred
+from tools.performance_report.service import ReportPaths, ReportService
+
+ROOT = Path(__file__).resolve().parents[2]
+PROFILE = ROOT / "src/pyamplicol/_profiling_campaign"
+CAMPAIGN_ARTIFACT_ROOT = PROFILE / "campaign_artifacts"
+
+
+@pytest.fixture
+def repository_with_cli(tmp_path: Path) -> Path:
+    repository = tmp_path / "repository"
+    (repository / "src/pyamplicol").mkdir(parents=True)
+    executable = repository / ".venv/bin/pyamplicol"
+    executable.parent.mkdir(parents=True)
+    executable.touch()
+    return repository
+
+
+def _parse(*arguments: str):
+    return build_parser().parse_args(arguments)
+
+
+def test_campaign_state_roots_are_local_and_isolated_by_full_destination(
+    tmp_path: Path,
+) -> None:
+    first_docs = tmp_path / "first" / "same-name"
+    second_docs = tmp_path / "second" / "same-name"
+    first_docs.mkdir(parents=True)
+    second_docs.mkdir(parents=True)
+
+    first = manual_campaign._campaign_report_paths(ROOT, first_docs)
+    second = manual_campaign._campaign_report_paths(ROOT, second_docs)
+
+    assert first.docs_dir == first_docs.resolve()
+    assert first.artifact_root == first_docs.resolve() / "campaign_artifacts"
+    assert first.coordination_root == first.artifact_root / "coordination"
+    assert second.artifact_root == second_docs.resolve() / "campaign_artifacts"
+    assert first.artifact_root != second.artifact_root
+    first_service = ReportService(first, portable_current_results=True)
+    second_service = ReportService(second, portable_current_results=True)
+    with (
+        first_service.store.named_lock("same-cell", timeout=0.0),
+        second_service.store.named_lock("same-cell", timeout=0.0),
+    ):
+        pass
+    attempt = first_service.store.new_attempt(
+        "same-cell",
+        manual_campaign.ArtifactPolicy.REGENERATE,
+    )
+    attempt.publish({"status": "ok"})
+    assert first_service.store.load_current("same-cell") is not None
+    assert second_service.store.load_current("same-cell", missing_ok=True) is None
+    assert (
+        second_service.store.lightweight_current_payload(
+            "same-cell",
+            missing_ok=True,
+        )
+        is None
+    )
+
+    legacy_store = manual_campaign.ArtifactStore(
+        artifact_root=tmp_path / ".artifacts/performance-report/same-name",
+        lock_root=tmp_path / ".artifacts/performance-report-coordination/same-name",
+    )
+    legacy_attempt = legacy_store.new_attempt(
+        "legacy-cell",
+        manual_campaign.ArtifactPolicy.REGENERATE,
+    )
+    legacy_attempt.publish({"status": "ok"})
+    assert first_service.store.load_current("legacy-cell", missing_ok=True) is None
+    assert second_service.store.load_current("legacy-cell", missing_ok=True) is None
+    assert not (first_docs / ".artifacts").exists()
+    assert not (second_docs / ".artifacts").exists()
+
+
+def test_campaign_state_root_is_created_fresh_when_absent(tmp_path: Path) -> None:
+    docs = tmp_path / "campaign"
+    docs.mkdir()
+    assert not (docs / "campaign_artifacts").exists()
+
+    paths = manual_campaign._campaign_report_paths(ROOT, docs)
+    ReportService(paths)
+
+    assert paths.artifact_root == docs / "campaign_artifacts"
+    assert paths.coordination_root == docs / "campaign_artifacts/coordination"
+    assert (paths.artifact_root / "cells").is_dir()
+    assert paths.coordination_root.is_dir()
+    assert not (docs / ".artifacts").exists()
+
+
+@pytest.mark.parametrize("member", ("campaign_artifacts", "coordination"))
+def test_campaign_state_rejects_symlinked_private_directories(
+    tmp_path: Path,
+    member: str,
+) -> None:
+    docs = tmp_path / "campaign"
+    docs.mkdir()
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    if member == "campaign_artifacts":
+        (docs / member).symlink_to(outside, target_is_directory=True)
+    else:
+        state = docs / "campaign_artifacts"
+        state.mkdir()
+        (state / member).symlink_to(outside, target_is_directory=True)
+
+    with pytest.raises(ManualCampaignError, match="must not be a symbolic link"):
+        manual_campaign._campaign_report_paths(ROOT, docs)
+
+
+def test_campaign_state_rejects_special_private_member(tmp_path: Path) -> None:
+    docs = tmp_path / "campaign"
+    docs.mkdir()
+    (docs / "campaign_artifacts").write_text("not a directory\n", encoding="ascii")
+
+    with pytest.raises(ManualCampaignError, match="must be a directory"):
+        manual_campaign._campaign_report_paths(ROOT, docs)
+
+
+def test_campaign_state_rejects_symlinked_campaign_directory(tmp_path: Path) -> None:
+    actual = tmp_path / "actual"
+    actual.mkdir()
+    linked = tmp_path / "campaign"
+    linked.symlink_to(actual, target_is_directory=True)
+
+    with pytest.raises(ManualCampaignError, match="must not be a symbolic link"):
+        manual_campaign._campaign_report_paths(ROOT, linked)
+
+
+@pytest.mark.parametrize("pwd_state", ("unset", "renamed-away", "recreated"))
+def test_existing_relative_launcher_rejects_stale_pwd_before_campaign_paths(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    pwd_state: str,
+) -> None:
+    original = tmp_path / "campaign"
+    original.mkdir()
+    moved = tmp_path / "renamed-campaign"
+    original.rename(moved)
+    if pwd_state == "recreated":
+        original.mkdir()
+    monkeypatch.chdir(moved)
+    if pwd_state == "unset":
+        monkeypatch.delenv("PWD", raising=False)
+    else:
+        monkeypatch.setenv("PWD", str(original))
+    monkeypatch.setattr(sys, "argv", ["./steer_performance_campaign.py"])
+    monkeypatch.setattr(
+        manual_campaign,
+        "_campaign_report_paths",
+        lambda *_args, **_kwargs: pytest.fail(
+            "stale relative launcher opened campaign paths"
+        ),
+    )
+
+    assert (
+        campaign_main(
+            ("dashboard-snapshot", "--width", "80", "--height", "24"),
+            repo_root=ROOT,
+            docs_dir=moved,
+        )
+        == 2
+    )
+    assert "cd .." in capsys.readouterr().err
+
+
+@pytest.mark.parametrize("checked_absolute", (False, True))
+def test_campaign_controller_allows_matching_or_checked_launcher_invocation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    checked_absolute: bool,
+) -> None:
+    docs = tmp_path / "campaign"
+    docs.mkdir()
+    monkeypatch.chdir(docs)
+    monkeypatch.setenv(
+        "PWD",
+        str(tmp_path / "different-directory" if checked_absolute else docs),
+    )
+    invocation = (
+        docs / "steer_performance_campaign.py"
+        if checked_absolute
+        else Path("./steer_performance_campaign.py")
+    )
+    monkeypatch.setattr(sys, "argv", [os.fspath(invocation)])
+
+    assert (
+        campaign_main(
+            ("dashboard-snapshot", "--width", "80", "--height", "24"),
+            repo_root=ROOT,
+            docs_dir=docs,
+            launcher_path_checked=checked_absolute,
+        )
+        == 0
+    )
+
+
+@pytest.mark.parametrize("replacement", (False, True))
+def test_old_absolute_launcher_reexecution_rejects_stale_pwd_by_default(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    replacement: bool,
+) -> None:
+    original = tmp_path / "campaign"
+    original.mkdir()
+    moved = tmp_path / "renamed-campaign"
+    original.rename(moved)
+    if replacement:
+        original.mkdir()
+    monkeypatch.chdir(moved)
+    monkeypatch.setenv("PWD", str(original))
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        [os.fspath(moved / "steer_performance_campaign.py")],
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_campaign_report_paths",
+        lambda *_args, **_kwargs: pytest.fail(
+            "old absolute launcher opened campaign paths after stale re-exec"
+        ),
+    )
+
+    assert (
+        campaign_main(
+            ("dashboard-snapshot", "--width", "80", "--height", "24"),
+            repo_root=ROOT,
+            docs_dir=moved,
+        )
+        == 2
+    )
+    assert "cd .." in capsys.readouterr().err
+
+
+def test_campaign_command_holds_shared_destination_lock(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import fcntl
+
+    docs = tmp_path / "campaign"
+    docs.mkdir()
+    original_fixture = manual_campaign._snapshot_fixture
+
+    def assert_locked() -> DashboardState:
+        descriptor = os.open(
+            docs,
+            os.O_RDONLY | getattr(os, "O_DIRECTORY", 0),
+        )
+        try:
+            with pytest.raises(BlockingIOError):
+                fcntl.flock(descriptor, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        finally:
+            os.close(descriptor)
+        return original_fixture()
+
+    monkeypatch.setattr(manual_campaign, "_snapshot_fixture", assert_locked)
+
+    assert (
+        campaign_main(
+            ("dashboard-snapshot", "--width", "80", "--height", "24"),
+            repo_root=ROOT,
+            docs_dir=docs,
+        )
+        == 0
+    )
+
+
+def test_catalog_and_fresh_profile_are_complete_but_measurement_empty() -> None:
+    assert len(REPORT_CATALOG.measurement_cells()) == 2198
+    assert PROFILE.is_dir()
+    assert not (PROFILE / "pyAmpliCol.pdf").exists()
+    assert not any(PROFILE.rglob("current.json"))
+    assert not any(PROFILE.rglob("manifest.json"))
+    assert not any(PROFILE.rglob("*.sha256"))
+    old_profile = ROOT / "docs/performance_reports/macbook_M3"
+    assert old_profile.resolve() != PROFILE.resolve()
+
+
+def test_selector_repetition_wildcard_aliases_and_intersection() -> None:
+    arguments = _parse(
+        "run",
+        "--dry-run",
+        "--multiplicity",
+        "3",
+        "--multiplicity",
+        "4",
+        "--model",
+        "built-in",
+        "sm_ufo",
+        "--color-approximation",
+        "LC",
+        "--generation-mode",
+        "union-flow",
+        "--generation-engine",
+        "recurrence",
+    )
+    _selection, cells = selection_from_arguments(arguments)
+    assert cells
+    assert {cell.n_final for cell in cells} == {3, 4}
+    assert {cell.measurement.model for cell in cells} == {
+        ModelKey.BUILTIN_SM,
+        ModelKey.UFO_SM,
+    }
+    assert {cell.workload for cell in cells} == {Workload.ALL_FLOW}
+    assert {cell.measurement.execution_mode for cell in cells} == {
+        ExecutionMode.RECURRENCE
+    }
+
+    all_arguments = _parse("inspect", "--table", "*", "--model", "all")
+    _all_selection, all_cells = selection_from_arguments(all_arguments)
+    assert len(all_cells) == 2198
+
+
+def test_variant_filter_keeps_unvaried_matrix_rows_in_a_broad_selection() -> None:
+    arguments = _parse(
+        "run",
+        "--dry-run",
+        "--multiplicity",
+        "8",
+        "9",
+        "--generation-engine",
+        "amplicol",
+        "recurrence",
+        "compiled",
+        "--variant",
+        "recurrence_jit_o2",
+        "jit_o3",
+    )
+    _selection, cells = selection_from_arguments(arguments)
+
+    assert {
+        "reference_amplicol_lc",
+        "matrix_recurrence_builtin_sm_lc",
+        "matrix_compiled_builtin_sm_lc",
+    }.issubset({cell.dataset_id for cell in cells})
+    assert all(cell.variant in {None, "recurrence_jit_o2", "jit_o3"} for cell in cells)
+
+
+def test_matrix_best_is_all_four_builtin_candidate_modes() -> None:
+    arguments = _parse("inspect", "--table", "matrix_best")
+    _selection, cells = selection_from_arguments(arguments)
+    assert len(cells) == 1108
+    assert {cell.measurement.execution_mode for cell in cells} == {
+        ExecutionMode.RECURRENCE,
+        ExecutionMode.COMPILED,
+        ExecutionMode.EAGER,
+        ExecutionMode.ON_THE_FLY,
+    }
+    assert {cell.measurement.model for cell in cells} == {ModelKey.BUILTIN_SM}
+
+
+def test_process_id_15_selector_targets_only_identical_quark_line_cells() -> None:
+    arguments = _parse(
+        "inspect",
+        "--process-id",
+        "15",
+        "--multiplicity",
+        "4",
+        "--generation-engine",
+        "recurrence",
+        "--model",
+        "builtin_sm",
+    )
+    _selection, cells = selection_from_arguments(arguments)
+
+    assert len(cells) == 4
+    assert {cell.process_key for cell in cells} == {"dd_3q_identical_lines"}
+    assert {cell.process for cell in cells} == {"d d~ > u u~ u u~"}
+    assert {cell.n_final for cell in cells} == {4}
+
+
+def test_builtin_model_and_table_aliases_handle_amplicol_references() -> None:
+    built_in = _parse(
+        "inspect",
+        "--model",
+        "built_in",
+        "--generation-engine",
+        "amplicol",
+    )
+    _selection, cells = selection_from_arguments(built_in)
+    assert cells
+    assert all(
+        cell.measurement.execution_mode is ExecutionMode.AMPLICOL for cell in cells
+    )
+
+    z_reference = _parse(
+        "inspect",
+        "--table",
+        "z_table",
+        "--generation-engine",
+        "amplicol",
+    )
+    _selection, cells = selection_from_arguments(z_reference)
+    assert cells
+    assert {cell.process_key for cell in cells} == {"dd_z_jets"}
+    assert {cell.workload for cell in cells} == {Workload.SELECTED_FLOW}
+
+
+def test_valid_but_empty_selector_has_concise_error() -> None:
+    arguments = _parse(
+        "inspect",
+        "--color-approximation",
+        "nlc",
+        "--generation-mode",
+        "union-flow",
+    )
+    with pytest.raises(ManualCampaignError, match="selector intersection"):
+        selection_from_arguments(arguments)
+
+
+def test_invalid_selector_lists_allowed_values_and_suggestion() -> None:
+    arguments = _parse("inspect", "--generation-engine", "recurrance")
+    with pytest.raises(ManualCampaignError, match="did you mean recurrence"):
+        selection_from_arguments(arguments)
+
+
+def test_help_is_exhaustive_and_run_defaults_match_contract() -> None:
+    parser = build_parser()
+    help_text = parser.format_help()
+    for fragment in (
+        "Steering model",
+        "pyamplicol generate",
+        "pyamplicol profile",
+        "dashboard-snapshot",
+        "refresh-pdf",
+        "matrix_recurrence_ufo_sm_lc",
+        "Inspect coverage",
+        "cannot fit the 1-GiB envelope",
+        "C++/ASM variants above",
+        "Keyboard controls",
+        "current/contribution counts",
+        "process-tree current/peak usage",
+        "--continue-across-revisions",
+        "--cell-id-file",
+        "--cleanup-artifacts",
+        "--retain-workspaces",
+        "--attempt-output-limit",
+        "--minimum-free-disk",
+        "`unverified.txt` needs no `--force-refresh`",
+        "bounded log tails",
+        "sealed with compact diagnostics",
+        "--no-dependencies-added",
+        "--list-sections",
+        "--remove-sections",
+        "dependency-only work",
+        "original-AmpliCol diagnostic, recurrence authority",
+        "quoted `*`",
+    ):
+        assert fragment in help_text
+    run_help = parser._subparsers._group_actions[0].choices["run"].format_help()
+    assert "Process family number 1..15" in run_help
+    assert "automatically added diagnostic dependency" in run_help
+    assert "recurrence remains available" in run_help
+    assert "Hard construction" in run_help
+    assert "Omitted or '*' engine" in run_help
+    assert "--madgraph" in run_help
+    assert "--campaign-ram-limit" in run_help
+    assert "Optional decimal RAM ceiling across all concurrent" in run_help
+    assert "--no-artifacts-removal" not in help_text
+    arguments = _parse("run", "--dry-run")
+    assert arguments.workers == 1
+    assert arguments.cores_per_worker == 1
+    assert arguments.amplicol_build_jobs == 1
+    assert arguments.generation_time_limit == 3600.0
+    assert arguments.ram_limit == 30_000_000_000
+    assert arguments.campaign_ram_limit is None
+    assert arguments.attempt_output_limit == 64 * 1024 * 1024
+    assert arguments.minimum_free_disk == 5 * 1024 * 1024 * 1024
+    assert arguments.worker_wall_limit == 3600.0
+    assert arguments.no_color is False
+    assert arguments.force_refresh is False
+    assert arguments.continue_across_revisions is False
+    assert arguments.no_dependencies_added is False
+    assert arguments.cleanup_artifacts is False
+    assert arguments.retain_workspaces is False
+    assert arguments.madgraph is None
+    assert _parse("run", "--no-dependencies-added").no_dependencies_added is True
+    assert _parse("run", "--cleanup-artifacts").cleanup_artifacts is True
+    assert manual_campaign._artifact_cleanup_enabled(arguments) is True
+    retained = _parse("run", "--retain-workspaces")
+    assert retained.retain_workspaces is True
+    assert manual_campaign._artifact_cleanup_enabled(retained) is False
+    assert _parse("run", "--continue-across-revisions").continue_across_revisions
+    source = manual_campaign.ReportSourceIdentity("a" * 40, "b" * 40, ())
+    settings = manual_campaign._campaign_settings(
+        arguments,
+        source,
+        original_amplicol_available=True,
+    )
+    assert settings.amplicol_build_jobs == 1
+    parallel_native = _parse(
+        "run",
+        "--dry-run",
+        "--cores-per-worker",
+        "4",
+        "--amplicol-build-jobs",
+        "2",
+        "--allow-oversubscription",
+    )
+    parallel_settings = manual_campaign._campaign_settings(
+        parallel_native,
+        source,
+        original_amplicol_available=True,
+    )
+    assert parallel_settings.cell_cores == 4
+    assert parallel_settings.amplicol_build_jobs == 2
+    assert settings.add_optional_dependencies is True
+    assert settings.original_amplicol_available is True
+    opt_out_settings = manual_campaign._campaign_settings(
+        _parse("run", "--dry-run", "--no-dependencies-added"),
+        source,
+        original_amplicol_available=True,
+    )
+    assert opt_out_settings.add_optional_dependencies is False
+    unvalidated_legacy = manual_campaign._campaign_settings(
+        _parse("run", "--dry-run", "--original-amplicol", "/tmp/legacy"),
+        source,
+        original_amplicol_available=True,
+    )
+    assert unvalidated_legacy.original_amplicol_available is True
+    assert unvalidated_legacy.original_amplicol_repository is None
+    madgraph = Path("/tmp/madgraph")
+    madgraph_settings = manual_campaign._campaign_settings(
+        _parse("run", "--dry-run", "--madgraph", str(madgraph)),
+        source,
+    )
+    assert madgraph_settings.madgraph_installation == madgraph
+    refresh = _parse("refresh-pdf")
+    assert refresh.expected_page_count is None
+    assert refresh.quiet is False
+    assert refresh.list_sections is False
+    assert refresh.remove_sections is None
+    assert _parse("refresh-pdf", "--quiet").quiet is True
+    assert _parse("refresh-pdf", "--list-sections").list_sections is True
+    assert _parse(
+        "refresh-pdf",
+        "--remove-sections",
+        "worked-zgg",
+        "ufo-support",
+    ).remove_sections == ["worked-zgg", "ufo-support"]
+    with pytest.raises(SystemExit):
+        _parse(
+            "refresh-pdf",
+            "--list-sections",
+            "--remove-sections",
+            "scope",
+        )
+    assert DEFAULT_MANUAL_EXPECTED_PAGE_COUNT == 73
+    underscore = _parse("inspect", "--color_approximation", "lc")
+    _selection, cells = selection_from_arguments(underscore)
+    assert cells
+    assert {cell.measurement.accuracy.value for cell in cells} == {"lc"}
+
+
+@pytest.mark.parametrize("value", ("0", "-1", "1.5"))
+def test_campaign_ram_limit_requires_a_positive_integer(value: str) -> None:
+    with pytest.raises(SystemExit):
+        _parse("run", "--dry-run", "--campaign-ram-limit", value)
+
+
+def test_campaign_ram_limit_conservatively_caps_ten_workers_and_provenance(
+    tmp_path: Path,
+) -> None:
+    source = manual_campaign.ReportSourceIdentity("a" * 40, "b" * 40, ())
+    arguments = _parse(
+        "run",
+        "--dry-run",
+        "--workers",
+        "10",
+        "--ram-limit",
+        "30000000000",
+        "--campaign-ram-limit",
+        "30000000000",
+        "--allow-oversubscription",
+    )
+    settings = manual_campaign._campaign_settings(arguments, source)
+
+    assert settings.max_rss_bytes == 30_000_000_000
+    assert settings.campaign_max_rss_bytes == 30_000_000_000
+    assert settings.attempt_output_limit_bytes == 64 * 1024 * 1024
+    assert settings.minimum_free_disk_bytes == 5 * 1024 * 1024 * 1024
+    assert settings.remove_heavy_attempt_artifacts is True
+    assert settings.retain_workspaces is False
+    assert settings.effective_cell_rss_limit() == 3_000_000_000
+    assert settings.effective_cell_rss_limit() * settings.workers == (
+        settings.campaign_max_rss_bytes
+    )
+
+    scheduler = manual_campaign.CampaignScheduler(
+        _manual_service(tmp_path),
+        settings=settings,
+    )
+    assert scheduler._effective_cell_rss_limit() == 3_000_000_000
+    result: dict[str, object] = {}
+    scheduler._attach_manual_provenance(
+        result,
+        cell=_presentation_test_cell(),
+    )
+    provenance = result["provenance"]
+    assert isinstance(provenance, dict)
+    manual = provenance["manual_campaign"]
+    assert isinstance(manual, dict)
+    assert manual["memory_limit_bytes"] == 3_000_000_000
+    assert manual["campaign_memory_limit_bytes"] == 30_000_000_000
+    assert manual["workers"] == 10
+
+
+def test_colours_are_default_and_only_explicitly_disabled(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("NO_COLOR", raising=False)
+    arguments = _parse("inspect")
+    palette = manual_campaign.Palette(
+        manual_campaign._color_enabled(arguments),
+    )
+    assert "\x1b[" in palette.key("profile")
+    assert "\x1b[" in palette.success("ok")
+
+    no_colour = _parse("inspect", "--no-color")
+    assert not manual_campaign._color_enabled(no_colour)
+    assert manual_campaign.Palette(False).key("profile") == "profile"
+
+    monkeypatch.setenv("NO_COLOR", "")
+    assert not manual_campaign._color_enabled(arguments)
+    monkeypatch.delenv("NO_COLOR")
+    assert not manual_campaign._color_enabled(arguments, json_output=True)
+
+
+def test_refresh_list_sections_exits_before_campaign_or_source_reads(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    def forbidden(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("section listing touched campaign state")
+
+    monkeypatch.setattr(manual_campaign, "_campaign_report_paths", forbidden)
+    monkeypatch.setattr(manual_campaign, "lightweight_source_identity", forbidden)
+
+    assert (
+        campaign_main(
+            ("refresh-pdf", "--list-sections", "--no-color"),
+            repo_root=tmp_path,
+            docs_dir=tmp_path / "campaign",
+            launcher_path_checked=True,
+        )
+        == 0
+    )
+    output = capsys.readouterr().out
+    for section in manual_campaign.REPORT_SECTIONS:
+        assert section.identifier in output
+        assert section.title in output
+
+
+def test_report_section_filter_changes_only_the_staged_master(tmp_path: Path) -> None:
+    source = PROFILE / "pyAmpliCol.tex"
+    original = source.read_text(encoding="utf-8")
+    staged = tmp_path / "pyAmpliCol.tex"
+    staged.write_text(original, encoding="utf-8")
+    removed = manual_campaign._selected_report_sections(
+        ("scalar-ladders", "worked-zgg", "scalar-ladders")
+    )
+
+    manual_campaign._filter_report_sections(staged, removed)
+
+    filtered = staged.read_text(encoding="utf-8")
+    assert "\\section{Colour-Singlet Model Ladders}" not in filtered
+    assert "\\input{section_zgg_example.tex}" not in filtered
+    assert "\\input{section_three_mode_performance_tables.tex}" in filtered
+    assert "\\input{section_ufo_support.tex}" in filtered
+    assert "\\begin{thebibliography}{9}" in filtered
+    assert source.read_text(encoding="utf-8") == original
+    assert tuple(section.identifier for section in removed) == (
+        "scalar-ladders",
+        "worked-zgg",
+    )
+
+
+def test_report_template_identifies_current_release() -> None:
+    release = tomllib.loads((ROOT / "Cargo.toml").read_text(encoding="utf-8"))[
+        "workspace"
+    ]["package"]["version"]
+    source = (PROFILE / "pyAmpliCol.tex").read_text(encoding="utf-8")
+
+    for expected in (
+        f"pdftitle={{pyAmpliCol {release} Methodology and Performance Report}}",
+        f"{{pyAmpliCol {release}}}",
+        f"Release {release}",
+        rf"performance of \PAC{{}} {release}.",
+    ):
+        assert expected in source
+    normalized = " ".join(source.split())
+    assert (
+        "compiled, eager, recurrence, and on-the-fly evaluation across the "
+        "report's stated built-in Standard Model and UFO or serialized-JSON scopes"
+        in normalized
+    )
+    assert "leading-colour on-the-fly" not in normalized
+    assert "the first three modes" not in normalized
+
+
+def test_independently_removable_sections_leave_no_dangling_references() -> None:
+    assert r"\ref{sec:zgg-example}" not in (
+        PROFILE / "section_zgg_dag.tex"
+    ).read_text(encoding="utf-8")
+    for source in (
+        PROFILE / "section_zgg_example.tex",
+        PROFILE / "section_eager_execution.tex",
+    ):
+        assert r"\ref{sec:lc-flow-layouts}" not in source.read_text(
+            encoding="utf-8"
+        )
+
+
+def test_unknown_report_section_fails_before_pdf_work() -> None:
+    with pytest.raises(ManualCampaignError, match="--list-sections"):
+        manual_campaign._selected_report_sections(("not-a-section",))
+
+
+def test_lightweight_snapshot_reports_four_throttled_scan_stages(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cells = (object(), object())
+
+    class Catalog:
+        @staticmethod
+        def measurement_cells() -> tuple[object, ...]:
+            return cells
+
+    class Service:
+        catalog = Catalog()
+
+    class Sink:
+        def __init__(self) -> None:
+            self.events: list[tuple[object, ...]] = []
+
+        def begin(
+            self,
+            *,
+            total: int,
+            attempt: int,
+            maximum_attempts: int,
+        ) -> None:
+            self.events.append(("begin", total, attempt, maximum_attempts))
+
+        def update(self, completed: int, total: int, message: str) -> None:
+            self.events.append(("update", completed, total, message))
+
+        def end(
+            self,
+            *,
+            success: bool,
+            message: str,
+            elapsed_seconds: float,
+        ) -> None:
+            self.events.append(("end", success, message, elapsed_seconds))
+
+        def close(self) -> None:
+            self.events.append(("close",))
+
+    def scan(
+        *_args: object,
+        progress=None,
+        **_kwargs: object,
+    ) -> dict[str, object]:
+        if progress is not None:
+            for completed in range(1, len(cells) + 1):
+                progress(completed, len(cells))
+        return {}
+
+    monkeypatch.setattr(manual_campaign, "lightweight_currents", scan)
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_presentation_outcomes",
+        scan,
+    )
+    sink = Sink()
+
+    assert manual_campaign._capture_lightweight_snapshot(
+        Service(),  # type: ignore[arg-type]
+        source_revision="a" * 40,
+        progress=sink,  # type: ignore[arg-type]
+    ) == ({}, {}, ())
+
+    starts = [event for event in sink.events if event[0] == "begin"]
+    updates = [event for event in sink.events if event[0] == "update"]
+    ends = [event for event in sink.events if event[0] == "end"]
+    assert len(starts) == 1
+    assert starts[0][1:] == (4 * len(cells), 1, 3)
+    assert {event[3] for event in updates} == {
+        "Reading current records",
+        "Reading terminal outcomes",
+        "Confirming current records",
+        "Confirming terminal outcomes",
+    }
+    assert max(int(event[1]) for event in updates) == 4 * len(cells)
+    assert len(ends) == 1
+    assert ends[0][1] is True
+    assert ends[0][2] == "stable snapshot captured"
+
+
+def test_refresh_scan_progress_is_coloured_and_closes_its_line() -> None:
+    stream = io.StringIO()
+    progress = manual_campaign._RefreshScanProgress(
+        stream,
+        manual_campaign.Palette(True),
+    )
+
+    progress.begin(total=8, attempt=1, maximum_attempts=3)
+    progress.update(4, 8, "Confirming current records")
+    progress.end(success=True, message="stable snapshot captured", elapsed_seconds=1.2)
+
+    output = stream.getvalue()
+    assert "\x1b[" in output
+    assert "Scanning campaign artifacts" in output
+    assert "██████████████" in output
+    assert "4/8 Confirming current records" in output
+    assert output.endswith("\n")
+
+
+def test_final_unstable_snapshot_reports_failure_instead_of_rescan(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cells = (object(),)
+
+    class Catalog:
+        @staticmethod
+        def measurement_cells() -> tuple[object, ...]:
+            return cells
+
+    class Service:
+        catalog = Catalog()
+
+    class Current:
+        reusable = True
+
+        def __init__(self, attempt_id: str) -> None:
+            self.attempt_id = attempt_id
+
+    class Sink:
+        def __init__(self) -> None:
+            self.ends: list[tuple[bool, str]] = []
+
+        def begin(self, **_kwargs: object) -> None:
+            pass
+
+        def update(self, *_args: object) -> None:
+            pass
+
+        def end(
+            self,
+            *,
+            success: bool,
+            message: str,
+            elapsed_seconds: float,
+        ) -> None:
+            assert elapsed_seconds >= 0.0
+            self.ends.append((success, message))
+
+        def close(self) -> None:
+            pass
+
+    current_call = 0
+
+    def changing_currents(*_args: object, **_kwargs: object) -> dict[str, Current]:
+        nonlocal current_call
+        current_call += 1
+        return {"cell": Current(f"attempt-{current_call}")}
+
+    monkeypatch.setattr(manual_campaign, "lightweight_currents", changing_currents)
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_presentation_outcomes",
+        lambda *_args, **_kwargs: {},
+    )
+    sink = Sink()
+
+    with pytest.raises(ManualCampaignError, match="changed during three"):
+        manual_campaign._capture_lightweight_snapshot(
+            Service(),  # type: ignore[arg-type]
+            source_revision="a" * 40,
+            progress=sink,  # type: ignore[arg-type]
+        )
+
+    assert sink.ends == [
+        (True, "campaign state changed; rescanning"),
+        (True, "campaign state changed; rescanning"),
+        (False, "campaign state remained unstable after three scans"),
+    ]
+
+
+def test_reproduction_recipe_uses_public_generate_and_profile(
+    repository_with_cli: Path,
+) -> None:
+    repository = repository_with_cli
+    artifact_root = repository / "campaign_artifacts"
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.workload is Workload.ALL_FLOW
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+    )
+    recipe = reproduction_recipe(
+        candidate,
+        repo_root=repository,
+        artifact_root=artifact_root,
+    )
+    assert recipe.kind == "public-cli-template+model-compile-prerequisite"
+    assert recipe.prepare is not None
+    assert recipe.prepare[:5] == (
+        "env",
+        f"PYTHONPATH={os.fspath((repository / 'src').resolve())}",
+        os.fspath((repository / ".venv/bin/pyamplicol").resolve()),
+        "model",
+        "compile",
+    )
+    assert "built-in-sm" in recipe.prepare
+    assert recipe.generate is not None
+    assert recipe.generate[:4] == (
+        "env",
+        f"PYTHONPATH={os.fspath((repository / 'src').resolve())}",
+        os.fspath((repository / ".venv/bin/pyamplicol").resolve()),
+        "generate",
+    )
+    assert "--lc-flow-layout" in recipe.generate
+    assert "all-flow-union" in recipe.generate
+    assert recipe.profile is not None
+    assert recipe.profile[:4] == (
+        "env",
+        f"PYTHONPATH={os.fspath((repository / 'src').resolve())}",
+        os.fspath((repository / ".venv/bin/pyamplicol").resolve()),
+        "profile",
+    )
+    assert recipe.exact is False
+    assert "<" not in " ".join(recipe.profile)
+
+    legacy = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+    )
+    legacy_recipe = reproduction_recipe(
+        legacy,
+        repo_root=repository,
+        artifact_root=artifact_root,
+    )
+    assert legacy_recipe.kind == "legacy-report-adapter"
+    assert legacy_recipe.generate is None
+    assert legacy_recipe.profile is None
+    assert legacy_recipe.exact is False
+
+
+def test_reproduction_recipe_exposes_authenticated_reuse_off_fallback() -> None:
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+    )
+    fallback = {
+        "abi": "pyamplicol-numerical-current-reuse-fallback-v1",
+        "requested_mode": "certified-reuse",
+        "effective_mode": "off",
+        "effective_reuse_state": "disabled",
+        "reason": "evidence-envelope-fallback",
+        "geometry": {
+            "current_count": 4,
+            "component_count": 8,
+            "candidate_probe_count": 2,
+            "verification_probe_count": 2,
+            "runtime_parameter_count": 3,
+            "scalar_count": 76,
+            "row_count": 11,
+        },
+        "certified_relation_count": 0,
+        "applied_relation_count": 0,
+    }
+
+    recipe = reproduction_recipe(
+        candidate,
+        repo_root=ROOT,
+        artifact_root=CAMPAIGN_ARTIFACT_ROOT,
+        measurement={"provenance": {"numerical_relation_fallback": fallback}},
+    )
+
+    assert recipe.generate is not None
+    assert "--no-numerical-current-reuse" in recipe.generate
+    assert "--numerical-current-reuse" not in recipe.generate
+    assert "effective-reuse-off-fallback" in recipe.kind
+    assert "evidence-envelope fallback" in recipe.note
+    assert "effectively disabled" in recipe.note
+
+    malformed = json.loads(json.dumps(fallback))
+    malformed["geometry"]["scalar_count"] = 77
+    with pytest.raises(ManualCampaignError, match="fallback geometry is inconsistent"):
+        reproduction_recipe(
+            candidate,
+            repo_root=ROOT,
+            artifact_root=CAMPAIGN_ARTIFACT_ROOT,
+            measurement={"provenance": {"numerical_relation_fallback": malformed}},
+        )
+
+
+def test_reproduction_cli_prefix_runs_from_an_unrelated_directory(
+    tmp_path: Path,
+) -> None:
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+    )
+    recipe = reproduction_recipe(
+        candidate,
+        repo_root=ROOT,
+        artifact_root=CAMPAIGN_ARTIFACT_ROOT,
+    )
+    assert recipe.generate is not None
+    command_prefix = recipe.generate[:3]
+    completed = subprocess.run(
+        (*command_prefix, "generate", "--help"),
+        cwd=tmp_path,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=15,
+    )
+    assert completed.returncode == 0, completed.stderr
+    assert "usage:" in completed.stdout
+
+
+def test_completed_reproduction_recipe_uses_exact_selectors_and_momenta(
+    tmp_path: Path,
+) -> None:
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.workload is Workload.ALL_FLOW
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+    )
+    recorded_momenta = [[[101.0, 1.0, 2.0, 3.0]]]
+    measurement = {
+        "status": "ok",
+        "artifact": {"path": "/tmp/example-artifact", "process_id": "stable-process"},
+        "selector_contract": {
+            "selected_color_flow_ids": ["cf:1"],
+            "selected_color_words": [[1, 2]],
+            "all_flow_helicity_ids": ["h:+1,-1"],
+            "all_flow_source_helicities": {"1": 1, "2": -1},
+            "point_digest": "1" * 64,
+        },
+        "provenance": {
+            "requested_config": {"model": {"source": "/tmp/prepared.pyamplicol-model"}},
+            "report_momenta": recorded_momenta,
+        },
+    }
+    recipe = reproduction_recipe(
+        candidate,
+        repo_root=tmp_path,
+        artifact_root=tmp_path / "campaign_artifacts",
+        measurement=measurement,
+    )
+    assert recipe.exact is True
+    assert recipe.prepare is not None
+    assert "built-in-sm" in recipe.prepare
+    assert recipe.generate is not None
+    assert recipe.generate[recipe.generate.index("--model") + 1].endswith(
+        "/prepared-models/built-in-sm-jit-o2.pyamplicol-model"
+    )
+    assert recipe.profile is not None
+    profile_index = recipe.profile.index("profile")
+    assert recipe.profile[profile_index + 1].endswith(f"/{candidate.cell_id}/artifact")
+    assert candidate.process in recipe.profile
+    assert "--helicity" in recipe.profile
+    assert "h:+1,-1" in recipe.profile
+    assert "--momenta" in recipe.profile
+    momenta_path = Path(recipe.profile[recipe.profile.index("--momenta") + 1])
+    assert json.loads(momenta_path.read_text(encoding="ascii")) == recorded_momenta
+    assert momenta_path.is_relative_to(tmp_path / "campaign_artifacts")
+    assert all(
+        ".artifacts" not in argument
+        for command in (recipe.prepare, recipe.generate, recipe.profile)
+        for argument in command[1:]
+    )
+    assert "<" not in " ".join((*recipe.generate, *recipe.profile))
+
+
+def test_ufo_recurrence_recipe_has_public_model_compile_prerequisite(
+    tmp_path: Path,
+) -> None:
+    from pyamplicol.cli import parse_cli
+
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.UFO_SM
+    )
+    recipe = reproduction_recipe(
+        candidate,
+        repo_root=tmp_path,
+        artifact_root=tmp_path / "campaign_artifacts",
+    )
+
+    assert recipe.prepare is not None
+    assert recipe.prepare[:5] == (
+        sys.executable,
+        "-m",
+        "pyamplicol",
+        "model",
+        "compile",
+    )
+    prepare_index = recipe.prepare.index("model")
+    assert (
+        parse_cli(recipe.prepare[prepare_index:]).resolve().effective.action
+        == "model-compile"
+    )
+    assert recipe.generate is not None
+    prepared_source = recipe.generate[recipe.generate.index("--model") + 1]
+    assert prepared_source.endswith(".pyamplicol-model")
+    generate_index = recipe.generate.index("generate")
+    assert (
+        parse_cli(recipe.generate[generate_index:]).resolve().effective.action
+        == "generate"
+    )
+    assert "model-compile-prerequisite" in recipe.kind
+
+
+def test_compiled_recipe_labels_both_private_timing_exceptions() -> None:
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.COMPILED
+    )
+    recipe = reproduction_recipe(
+        candidate,
+        repo_root=ROOT,
+        artifact_root=CAMPAIGN_ARTIFACT_ROOT,
+    )
+
+    assert recipe.exact is False
+    assert "precompiled-generation" in recipe.kind
+    assert "paired-arena" in recipe.kind
+    assert "outside generation_seconds" in recipe.note
+    assert "do not reproduce either timing boundary" in recipe.note
+
+
+def test_dry_run_is_compact_and_labels_each_recipe(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("NO_COLOR", "1")
+    cell_id = "matrix-compiled-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    docs_dir = tmp_path / "campaign"
+    docs_dir.mkdir()
+
+    assert (
+        campaign_main(
+            ("run", "--dry-run", "--cell-id", cell_id),
+            repo_root=ROOT,
+            docs_dir=docs_dir,
+        )
+        == 0
+    )
+    output = capsys.readouterr().out
+
+    assert "kind: public-cli+precompiled-generation+paired-arena-exceptions" in output
+    assert "exact: no" in output
+    assert "Diagnostic only:" in output
+    assert "Generate:" in output
+    assert "Profile template/diagnostic:" in output
+    assert max(map(len, output.splitlines())) < 300
+
+
+def test_statistics_use_ratio_of_sums_weighting() -> None:
+    candidates = [
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+    ][:2]
+    baselines = [REPORT_CATALOG.validation_baseline_cell(cell) for cell in candidates]
+    assert all(baseline is not None for baseline in baselines)
+    comparisons = (
+        Comparison(candidates[0], baselines[0], 2.0, 1.0),  # type: ignore[arg-type]
+        Comparison(candidates[1], baselines[1], 9.0, 3.0),  # type: ignore[arg-type]
+    )
+    summary = comparison_statistics(comparisons)
+    assert summary["median"] == 2.5
+    assert summary["mean"] == 2.5
+    assert summary["weighted_mean"] == 11.0 / 4.0
+    assert summary["best"] is comparisons[0]
+    assert summary["worst"] is comparisons[1]
+
+
+@pytest.mark.parametrize(("width", "height"), ((80, 24), (120, 36), (160, 48)))
+def test_ratatui_headless_frames_are_stable_and_informative(
+    width: int,
+    height: int,
+) -> None:
+    frame = render_dashboard_frame(
+        _snapshot_fixture(),
+        width=width,
+        height=height,
+    )
+    assert isinstance(frame, str)
+    assert "pyAmpliCol profiling campaign" in frame
+    assert "Selected" in frame
+    assert "Recycled" in frame
+    assert "Remaining" in frame
+    assert "Ready 0" in frame
+    assert "Waiting dependency 0" in frame
+    assert "Waiting coordination lock 0" in frame
+    assert "RAM" in frame
+    assert "Caps Generation 01:00:00" in frame
+    assert "RAM 30.00 GB" in frame
+    assert "Total wall 01:00:00" in frame
+    assert "Ctrl-C" in frame
+    assert len(frame.splitlines()) == height
+
+
+def test_ratatui_styled_cells_include_color_and_gauge_values() -> None:
+    from ratatui import Color
+
+    state = _snapshot_fixture()
+    width = 120
+    frame = render_dashboard_frame(state, width=width, height=36)
+    cells = render_dashboard_frame(state, width=width, height=36, cells=True)
+    assert isinstance(cells, list)
+    assert cells
+    assert any(item.get("fg") not in (None, 0) for item in cells)
+    assert any(item.get("ch") == ord("8") for item in cells)
+    header_y, header = next(
+        (index, line)
+        for index, line in enumerate(frame.splitlines())
+        if "cell" in line and "phase / step" in line
+    )
+    header_cell = cells[header_y * width + header.index("cell")]
+    assert header_cell["fg"] == int(Color.LightCyan)
+    assert int(header_cell["mods"]) & 1
+
+
+def test_dashboard_detail_columns_and_supervision_summary_are_styled() -> None:
+    from ratatui import Color
+
+    worker = WorkerView(
+        "completed-demo",
+        status="ok",
+        phase="complete",
+        step="published",
+        cpu_seconds=1.0,
+        current_rss_bytes=2_000,
+        peak_rss_bytes=3_000,
+        phase_timeline=(
+            manual_campaign.PhaseTimelineRow(
+                "Loading and compiling evaluator",
+                wall_seconds=1.25,
+                status="measured",
+            ),
+            manual_campaign.PhaseTimelineRow(
+                "Worker supervision",
+                wall_seconds=2.0,
+                cpu_seconds=1.0,
+                peak_memory_bytes=3_000,
+                status="observed",
+                detail="overall observed worker wall",
+            ),
+        ),
+    )
+    state = DashboardState(
+        instance_id="aligned-details",
+        selected_ids=(worker.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        workers={worker.cell_id: worker},
+        terminal_outcomes={
+            worker.cell_id: manual_campaign._DashboardTerminalOutcome.SUCCESS
+        },
+        show_completed=True,
+    )
+    width = 160
+    frame = render_dashboard_frame(state, width=width, height=48)
+    lines = frame.splitlines()
+    second_keys = {}
+    for first_key, key in (
+        ("Phase", "Step"),
+        ("Wall", "CPU"),
+        ("RSS current", "RSS peak"),
+        ("Guard current", "Guard peak"),
+        ("Outer wall", "Evaluator total"),
+        ("PID tree", "Attempt"),
+    ):
+        line = next(value for value in lines if first_key in value and key in value)
+        second_keys[key] = line.index(key)
+    assert len(set(second_keys.values())) == 1
+    assert "Loading and compiling evaluator" in frame
+
+    cells = render_dashboard_frame(state, width=width, height=48, cells=True)
+    summary_y, summary_line = next(
+        (index, line)
+        for index, line in enumerate(lines)
+        if "Worker supervision" in line
+    )
+    summary_cell = cells[summary_y * width + summary_line.index("Worker supervision")]
+    assert summary_cell["fg"] == int(Color.LightCyan)
+    assert summary_cell["bg"] == int(Color.DarkGray)
+    assert int(summary_cell["mods"]) & 1
+
+
+def test_dashboard_retains_and_renders_native_progress_counters(
+    tmp_path: Path,
+) -> None:
+    progress_path = tmp_path / "progress.jsonl"
+    progress_path.write_text(
+        json.dumps(
+            {
+                "event": "update",
+                "task_id": "generation:recurrence:process:rust-builder",
+                "completed": 8,
+                "total": 9,
+                "message": "recurrence stage",
+                "details": {
+                    "process": "dd_z_7g",
+                    "step": "recurrence stage",
+                    "stage_index": 8,
+                    "stage_total": 9,
+                    "current_count": 38_581,
+                    "contribution_count": 286_294,
+                    "certified_relation_count": 0,
+                    "applied_relation_count": 0,
+                },
+            }
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    worker = WorkerView(
+        "matrix-recurrence-builtin-sm-lc-n8-dd-z-jets-all-flow",
+        status="running",
+        phase="generation",
+        progress_path=str(progress_path),
+    )
+
+    _tail_progress(worker)
+
+    assert worker.progress_task_id == ("generation:recurrence:process:rust-builder")
+    assert worker.progress_completed == 8
+    assert worker.progress_total == 9
+    assert worker.progress_details["current_count"] == 38_581
+    assert worker.progress_details["contribution_count"] == 286_294
+    summary = _progress_detail_summary(worker.progress_details)
+    assert "currents 38,581" in summary
+    assert "contributions 286,294" in summary
+    assert "relations certified 0" in summary
+    state = DashboardState(
+        instance_id="progress-details",
+        selected_ids=(worker.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="6" * 40,
+        workers={worker.cell_id: worker},
+    )
+    frame = render_dashboard_frame(state, width=160, height=48)
+    assert "Progress data" in frame
+    assert "currents 38,581" in frame
+    assert "contributions 286,294" in frame
+
+
+def test_dashboard_keys_select_scroll_help_and_interrupt() -> None:
+    from ratatui import KeyCode, KeyMods
+
+    state = _snapshot_fixture()
+    cancellation = threading.Event()
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Down, "ch": 0, "mods": 0},
+        cancellation,
+    )
+    assert state.selected_index == 1
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.PageDown, "ch": 0, "mods": 0},
+        cancellation,
+    )
+    assert state.detail_scroll == 3
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("?"), "mods": 0},
+        cancellation,
+    )
+    assert state.show_help
+    assert _handle_dashboard_key(
+        state,
+        {
+            "kind": "key",
+            "code": KeyCode.Char,
+            "ch": ord("c"),
+            "mods": int(KeyMods.CTRL),
+        },
+        cancellation,
+    )
+    assert cancellation.is_set()
+    assert state.interrupted
+
+
+def test_dashboard_command_drawer_scrolls_and_copies_exact_command() -> None:
+    from ratatui import KeyCode
+
+    command = " ".join(
+        ["pyamplicol", "generate"]
+        + [f"--option-{index} 'value {index}'" for index in range(30)]
+    )
+    worker = WorkerView(
+        "command-demo",
+        status="running",
+        phase="generation",
+        reproduce_prepare="pyamplicol model compile built-in-sm /tmp/model",
+        reproduce_generate=command,
+        reproduce_profile="pyamplicol profile /tmp/artifact --process 'd d~ > z'",
+    )
+    state = DashboardState(
+        instance_id="command-drawer",
+        selected_ids=(worker.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        workers={worker.cell_id: worker},
+    )
+    cancellation = threading.Event()
+
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("2"), "mods": 0},
+        cancellation,
+    )
+    assert state.command_stage == "generate"
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Tab, "ch": 0, "mods": 0},
+        cancellation,
+    )
+    assert state.command_stage == "profile"
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Left, "ch": 0, "mods": 0},
+        cancellation,
+    )
+    assert state.command_stage == "generate"
+    first = render_dashboard_frame(state, width=80, height=24)
+    assert "Reproduction command · generate" in first
+    assert "wrapped lines 1-" in first
+    assert "--option-29" not in first
+
+    for _ in range(4):
+        assert not _handle_dashboard_key(
+            state,
+            {"kind": "key", "code": KeyCode.PageDown, "ch": 0, "mods": 0},
+            cancellation,
+        )
+    last = render_dashboard_frame(state, width=80, height=24)
+    assert "--option-29" in last
+
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("y"), "mods": 0},
+        cancellation,
+    )
+    assert state.pending_clipboard == ("generate", command)
+    sequence = manual_campaign._osc52_clipboard_sequence(command)
+    encoded = sequence.removeprefix("\x1b]52;c;").removesuffix("\x07")
+    assert base64.b64decode(encoded).decode("utf-8") == command
+    assert not cancellation.is_set()
+
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("p"), "mods": 0},
+        cancellation,
+    )
+    assert state.pending_print == ("generate", command)
+
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Esc, "ch": 0, "mods": 0},
+        cancellation,
+    )
+    assert state.command_stage is None
+    assert not cancellation.is_set()
+
+
+def test_dashboard_filters_order_and_keyboard_toggles() -> None:
+    from ratatui import KeyCode
+
+    workers = {
+        "done-ok": WorkerView("done-ok", status="ok"),
+        "done-reused": WorkerView("done-reused", status="reused"),
+        "attention-error": WorkerView("attention-error", status="error"),
+        "recycled-cap": WorkerView("recycled-cap", status="memory_limit"),
+        "active-queued": WorkerView("active-queued", status="queued"),
+        "active-preparing": WorkerView("active-preparing", status="preparing"),
+        "active-running": WorkerView("active-running", status="running"),
+    }
+    state = DashboardState(
+        instance_id="filters",
+        selected_ids=tuple(workers),
+        recycled_ids={"done-reused", "recycled-cap"},
+        static_na_ids=set(),
+        workers=workers,
+        terminal_outcomes={
+            "done-ok": manual_campaign._DashboardTerminalOutcome.SUCCESS,
+            "done-reused": manual_campaign._DashboardTerminalOutcome.SUCCESS,
+            "recycled-cap": manual_campaign._DashboardTerminalOutcome.CAPPED,
+            "attention-error": manual_campaign._DashboardTerminalOutcome.FAILED,
+        },
+    )
+    cancellation = threading.Event()
+
+    assert [worker.cell_id for worker in state.visible_workers()] == [
+        "active-running",
+        "active-preparing",
+        "active-queued",
+        "attention-error",
+        "recycled-cap",
+    ]
+
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("d"), "mods": 0},
+        cancellation,
+    )
+    assert state.show_completed
+    assert [worker.cell_id for worker in state.visible_workers()] == [
+        "active-running",
+        "active-preparing",
+        "active-queued",
+        "attention-error",
+        "recycled-cap",
+        "done-ok",
+        "done-reused",
+    ]
+
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("e"), "mods": 0},
+        cancellation,
+    )
+    assert not state.show_errors
+    assert [worker.cell_id for worker in state.visible_workers()] == [
+        "active-running",
+        "active-preparing",
+        "active-queued",
+        "done-ok",
+        "done-reused",
+    ]
+
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("d"), "mods": 0},
+        cancellation,
+    )
+    assert not state.show_completed
+    assert [worker.cell_id for worker in state.visible_workers()] == [
+        "active-running",
+        "active-preparing",
+        "active-queued",
+    ]
+
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("e"), "mods": 0},
+        cancellation,
+    )
+    assert state.show_errors
+    assert [worker.cell_id for worker in state.visible_workers()] == [
+        "active-running",
+        "active-preparing",
+        "active-queued",
+        "attention-error",
+        "recycled-cap",
+    ]
+
+
+def test_dashboard_error_total_is_in_primary_overview_summary() -> None:
+    workers = {
+        "active": WorkerView("active", status="running"),
+        "error": WorkerView("error", status="error"),
+        "unverified": WorkerView("unverified", status="unverified"),
+        "recycled-cap": WorkerView("recycled-cap", status="memory_limit"),
+    }
+    state = DashboardState(
+        instance_id="error-counter",
+        selected_ids=tuple(workers),
+        recycled_ids={"recycled-cap"},
+        static_na_ids=set(),
+        workers=workers,
+        terminal_outcomes={
+            "recycled-cap": manual_campaign._DashboardTerminalOutcome.CAPPED,
+            "error": manual_campaign._DashboardTerminalOutcome.FAILED,
+            "unverified": manual_campaign._DashboardTerminalOutcome.UNVERIFIED,
+        },
+    )
+
+    frame = render_dashboard_frame(state, width=120, height=36)
+    summary = next(line for line in frame.splitlines() if "Selected " in line)
+    assert "Errors 1" in summary
+    assert "Unverified 1" in summary
+    assert "Remaining 1" in summary
+    assert "Workers active 1" in frame
+    assert "Capped 0" in frame
+
+
+def test_finished_unverified_is_not_counted_as_an_error(tmp_path: Path) -> None:
+    service = _manual_service(tmp_path)
+    state = DashboardState(
+        instance_id="unverified-counter",
+        selected_ids=("diagnostic",),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+
+    LeaseManager(service, state).observe(
+        {
+            "event": "finished",
+            "cell_id": "diagnostic",
+            "status": ResultStatus.UNVERIFIED.value,
+            "detail": "independent authority unavailable",
+        }
+    )
+
+    assert state.failed_ids == set()
+    assert state.unverified_ids == {"diagnostic"}
+    assert state.counters()["failed"] == 0
+    assert state.counters()["unverified"] == 1
+    assert state.counters()["remaining"] == 0
+
+
+def test_finished_failure_shows_authenticated_reason_and_keeps_attempt_id(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    result = {
+        "status": ResultStatus.ERROR.value,
+        "failure": {
+            "kind": None,
+            "message": "worker terminated by phase_state_error",
+        },
+        "resources": {
+            "supervisor": {
+                "reason": "phase_state_error",
+                "phase_state_error": (
+                    "worker phase-state transition timestamp is outside the "
+                    "supervised process lifetime"
+                ),
+            },
+        },
+    }
+    with service.store.new_attempt(
+        cell.cell_id,
+        manual_campaign.ArtifactPolicy.REGENERATE,
+    ) as attempt:
+        attempt.write_json("worker-result.json", result)
+        attempt.mark_failed(
+            "phase-state failure",
+            artifact_paths=("worker-result.json",),
+        )
+        attempt_id = attempt.attempt_id
+
+    state = DashboardState(
+        instance_id="terminal-reason",
+        selected_ids=(cell.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+        workers={
+            cell.cell_id: WorkerView(
+                cell.cell_id,
+                status="running",
+                phase="terminating",
+                attempt_id=attempt_id,
+            )
+        },
+    )
+    monkeypatch.setattr(
+        service.store,
+        "load_sealed_unsuccessful_worker_result",
+        lambda *_args, **_kwargs: pytest.fail(
+            "terminal dashboard must not hash sealed attempt payloads"
+        ),
+    )
+
+    LeaseManager(service, state).observe(
+        {
+            "event": "finished",
+            "cell_id": cell.cell_id,
+            "status": ResultStatus.ERROR.value,
+            "detail": attempt_id,
+            "terminal_detail": (
+                "worker phase-state transition timestamp is outside the "
+                "supervised process lifetime"
+            ),
+            "completed_at_ns": 7,
+        }
+    )
+
+    worker = state.workers[cell.cell_id]
+    assert worker.step == (
+        "worker phase-state transition timestamp is outside the supervised "
+        "process lifetime"
+    )
+    assert worker.attempt_id == attempt_id
+    frame = render_dashboard_frame(state, width=220, height=36)
+    assert "worker phase-state transition timestamp" in frame
+    assert "Attempt" in frame
+    assert attempt_id in frame
+
+
+def test_terminal_result_step_uses_generic_failure_message() -> None:
+    assert (
+        manual_campaign._terminal_result_step(
+            {
+                "status": ResultStatus.VALIDATION_FAILED.value,
+                "failure": {
+                "kind": "MeasurementValidationError",
+                    "message": "resolved component sum disagrees with total",
+                },
+            }
+        )
+        == "resolved component sum disagrees with total"
+    )
+    assert (
+        manual_campaign._terminal_result_step(
+            {
+                "status": ResultStatus.MEMORY_LIMIT.value,
+                "failure": {"kind": "ReportPolicyCensor", "message": "memory cap"},
+            "provenance": {
+                    "manual_campaign": {"memory_limit_bytes": 15_000_000_000}
+                },
+            }
+        )
+        == ">15GB"
+    )
+
+
+def test_finished_failure_does_not_show_preserved_current_as_failed_attempt(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    result = {
+        "status": ResultStatus.VALIDATION_FAILED.value,
+        "failure": {
+            "kind": "MeasurementValidationError",
+            "message": "new attempt disagrees with the numerical authority",
+        },
+    }
+    with service.store.new_attempt(
+        cell.cell_id,
+        manual_campaign.ArtifactPolicy.REGENERATE,
+    ) as attempt:
+        attempt.write_json("worker-result.json", result)
+        attempt.mark_failed(
+            "validation failure",
+            artifact_paths=("worker-result.json",),
+        )
+        failed_attempt_id = attempt.attempt_id
+    preserved_attempt_id = "00000000-0000-4000-8000-000000000099"
+    preserved = LightweightCurrent(
+        cell_id=cell.cell_id,
+        attempt_id=preserved_attempt_id,
+        result_path=tmp_path / "preserved-result.json",
+        result={
+            "status": ResultStatus.OK.value,
+            "wall_seconds_per_point": 0.25,
+        },
+        complete=True,
+        reusable=True,
+        reason="previous valid current",
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_current",
+        lambda *_args, **_kwargs: preserved,
+    )
+    state = DashboardState(
+        instance_id="preserved-current",
+        selected_ids=(cell.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+        workers={
+            cell.cell_id: WorkerView(
+                cell.cell_id,
+                status="running",
+                attempt_id=failed_attempt_id,
+            )
+        },
+    )
+
+    LeaseManager(service, state).observe(
+        {
+            "event": "finished",
+            "cell_id": cell.cell_id,
+            "status": ResultStatus.VALIDATION_FAILED.value,
+            "detail": "previous valid current preserved",
+            "terminal_detail": (
+                "new attempt disagrees with the numerical authority"
+            ),
+            "completed_at_ns": 8,
+        }
+    )
+
+    worker = state.workers[cell.cell_id]
+    assert worker.attempt_id == failed_attempt_id
+    assert worker.step == "new attempt disagrees with the numerical authority"
+    assert worker.published_wall_seconds_per_point is None
+
+
+def test_recycled_resource_cap_is_available_to_error_filter(
+    tmp_path: Path,
+) -> None:
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+    )
+    current = LightweightCurrent(
+        cell_id=cell.cell_id,
+        attempt_id="recycled-cap-attempt",
+        result_path=tmp_path / "worker-result.json",
+        result={
+            "status": ResultStatus.TIMEOUT.value,
+            "resources": {
+                "wall_seconds": 3601.0,
+                "peak_rss_bytes": 2_000_000_000,
+            },
+            "provenance": {
+                "manual_campaign": {
+                    "generation_limit_seconds": 3600.0,
+                    "memory_limit_bytes": 30_000_000_000,
+                }
+            },
+        },
+        complete=True,
+        reusable=True,
+        reason="resource-capped terminal",
+    )
+
+    workers = manual_campaign._recycled_attention_workers(
+        (cell,),
+        {cell.cell_id: current},
+        {cell.cell_id},
+        repo_root=ROOT,
+        artifact_root=CAMPAIGN_ARTIFACT_ROOT,
+        settings=ReproductionSettings(),
+    )
+
+    assert set(workers) == {cell.cell_id}
+    worker = workers[cell.cell_id]
+    assert worker.status == "generation_limit"
+    assert worker.attempt_id == "recycled-cap-attempt"
+    assert worker.wall_seconds == 3601.0
+    assert worker.peak_rss_bytes == 2_000_000_000
+    assert worker.reproduce_generate is not None
+    assert worker.recycled
+
+    state = DashboardState(
+        instance_id="recycled-cap",
+        selected_ids=(cell.cell_id,),
+        recycled_ids={cell.cell_id},
+        static_na_ids=set(),
+        workers=workers,
+        show_completed=True,
+    )
+    assert [row.cell_id for row in state.visible_workers()] == [cell.cell_id]
+    state.show_errors = False
+    assert state.visible_workers() == ()
+
+
+def test_recycled_legacy_manual_memory_cap_needs_no_new_censor_record(
+    tmp_path: Path,
+) -> None:
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+    )
+    current = LightweightCurrent(
+        cell_id=cell.cell_id,
+        attempt_id="legacy-memory-cap",
+        result_path=tmp_path / "worker-result.json",
+        result={
+            "status": ResultStatus.MEMORY_LIMIT.value,
+            "provenance": {"manual_campaign": {"memory_limit_bytes": 30_000_000_000}},
+        },
+        complete=True,
+        reusable=True,
+        reason="resource-capped terminal",
+    )
+
+    worker = manual_campaign._recycled_attention_workers(
+        (cell,),
+        {cell.cell_id: current},
+        {cell.cell_id},
+        repo_root=ROOT,
+        artifact_root=CAMPAIGN_ARTIFACT_ROOT,
+        settings=ReproductionSettings(),
+    )[cell.cell_id]
+
+    assert worker.status == "memory_limit"
+    assert worker.recycled
+
+
+def test_successful_recycled_result_uses_done_filter_and_persisted_timeline(
+    tmp_path: Path,
+) -> None:
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+    )
+    result = {
+        "status": ResultStatus.OK.value,
+        "provenance": {
+            "report_source_revision": "a" * 40,
+            "manual_campaign": {
+                "cell_identity": {
+                    "execution_mode": "recurrence",
+                    "model": "builtin_sm",
+                },
+                "phase_timeline": {
+                    "schema": "pyamplicol-manual-campaign-phase-timeline-v1",
+                    "total_worker_wall_seconds": 12.5,
+                    "peak_rss_bytes": 2_048,
+                    "peak_guard_bytes": 4_096,
+                    "entries": [
+                        {
+                            "key": "preparation",
+                            "label": "Preparation",
+                            "seconds": 0.125,
+                            "status": "ok",
+                            "detail": "model ready",
+                        },
+                        {
+                            "key": "generation",
+                            "label": "Generation",
+                            "seconds": 2.5,
+                            "status": "ok",
+                        },
+                        {
+                            "key": "profiling",
+                            "label": "Profiling",
+                            "start_seconds": 3.0,
+                            "end_seconds": 9.0,
+                            "status": "ok",
+                        },
+                    ],
+                },
+            },
+        },
+    }
+    current = LightweightCurrent(
+        cell_id=cell.cell_id,
+        attempt_id="recycled-ok-attempt",
+        result_path=tmp_path / "worker-result.json",
+        result=result,
+        complete=True,
+        reusable=True,
+        reason="matching same-source current",
+    )
+
+    workers = manual_campaign._recycled_attention_workers(
+        (cell,),
+        {cell.cell_id: current},
+        {cell.cell_id},
+        repo_root=ROOT,
+        artifact_root=CAMPAIGN_ARTIFACT_ROOT,
+        settings=ReproductionSettings(),
+    )
+    worker = workers[cell.cell_id]
+    assert worker.status == "recycled"
+    assert worker.recycled
+    assert worker.wall_seconds == 12.5
+    assert worker.peak_rss_bytes == 2_048
+    assert worker.peak_guard_bytes == 4_096
+    assert [row.phase for row in worker.phase_timeline] == [
+        "Preparation",
+        "Generation",
+        "Profiling",
+    ]
+    assert worker.phase_timeline[2].wall_seconds is None
+    assert worker.provenance_summary == (
+        "source aaaaaaaaaaaa · engine recurrence · model builtin_sm"
+    )
+
+    state = DashboardState(
+        instance_id="recycled-ok",
+        selected_ids=(cell.cell_id,),
+        recycled_ids={cell.cell_id},
+        static_na_ids=set(),
+        workers=workers,
+    )
+    assert state.visible_workers() == ()
+    state.show_completed = True
+    assert [row.cell_id for row in state.visible_workers()] == [cell.cell_id]
+    state.show_errors = False
+    assert [row.cell_id for row in state.visible_workers()] == [cell.cell_id]
+
+    frame = render_dashboard_frame(state, width=160, height=48)
+    assert "recycled" in frame
+    assert "No work executed by this invocation" in frame
+    assert "Reuse matching same-source current" in frame
+    assert "Phase timeline" in frame
+    assert "Preparation" in frame
+    assert "125.0 ms" in frame
+    assert "2.50 s" in frame
+    assert "Generation" in frame
+    assert "Profiling" in frame
+    assert "unavailable" in frame
+    assert "source aaaaaaaaaaaa" in frame
+
+    decoded = manual_campaign._worker_from_lease(
+        worker.cell_id,
+        worker.as_dict(),
+        peer_instance=None,
+    )
+    assert decoded.status == "recycled"
+    assert decoded.recycled
+    assert decoded.phase_timeline == worker.phase_timeline
+
+
+def test_completed_legacy_result_marks_missing_timeline_unavailable() -> None:
+    worker = WorkerView(
+        "legacy-completed",
+        status="ok",
+        phase="completed",
+        step="measurement published",
+    )
+    state = DashboardState(
+        instance_id="legacy-completed",
+        selected_ids=(worker.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        workers={worker.cell_id: worker},
+        show_completed=True,
+    )
+
+    frame = render_dashboard_frame(state, width=120, height=36)
+    assert "Provenance unavailable" in frame
+    assert "Phase timeline unavailable (older result)" in frame
+
+
+def test_selected_worker_preserves_subsecond_wall_and_cpu_durations() -> None:
+    worker = WorkerView(
+        "short-worker",
+        status="running",
+        phase="profiling",
+        step="first sample",
+        wall_seconds=0.125,
+        cpu_seconds=0.004,
+    )
+    state = DashboardState(
+        instance_id="short-worker",
+        selected_ids=(worker.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        workers={worker.cell_id: worker},
+    )
+
+    frame = render_dashboard_frame(state, width=120, height=36)
+
+    assert "Wall              125.0 ms" in frame
+    assert "CPU               4.0 ms" in frame
+    assert "Wall              00:00:00" not in frame
+
+
+def test_phase_timeline_uses_only_explicit_legacy_durations() -> None:
+    rows = manual_campaign._extract_phase_timeline(
+        {
+            "generation_seconds": 2.25,
+            "provenance": {
+                "runtime_profile": {
+                    "measurement_phase_elapsed_seconds": 1.5,
+                    "started_seconds": 3.0,
+                    "finished_seconds": 99.0,
+                },
+            },
+        }
+    )
+
+    assert [(row.phase, row.wall_seconds) for row in rows] == [
+        ("Generation", 2.25),
+        ("Timed headline measurement", 1.5),
+    ]
+    assert (
+        manual_campaign._extract_phase_timeline(
+            {
+                "timeline": [{"label": "native core", "duration": 99.0}],
+                "provenance": {
+                    "manual_campaign": {
+                        "phase_timeline": {
+                            "schema": "unknown-timeline-v0",
+                            "entries": [
+                                {"label": "untrusted", "seconds": 123.0},
+                            ],
+                        }
+                    }
+                },
+            }
+        )
+        == ()
+    )
+
+
+@pytest.mark.parametrize(
+    ("width", "height", "expected_range"),
+    ((80, 24, "15-18/18"), (120, 36, "10-18/18")),
+)
+def test_dashboard_worker_viewport_pans_with_selection(
+    width: int,
+    height: int,
+    expected_range: str,
+) -> None:
+    from ratatui import KeyCode
+
+    workers = {
+        f"worker-{index:02d}": WorkerView(
+            f"worker-{index:02d}",
+            status="running",
+            step=f"profiling sample {index}",
+        )
+        for index in range(18)
+    }
+    state = DashboardState(
+        instance_id="viewport",
+        selected_ids=tuple(workers),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        workers=workers,
+    )
+    cancellation = threading.Event()
+    for _ in range(17):
+        assert not _handle_dashboard_key(
+            state,
+            {"kind": "key", "code": KeyCode.Down, "ch": 0, "mods": 0},
+            cancellation,
+        )
+
+    frame = render_dashboard_frame(state, width=width, height=height)
+    selected_rows = [line for line in frame.splitlines() if "▶" in line]
+    assert len(selected_rows) == 1
+    assert "worker-17" in selected_rows[0]
+    assert "worker-00" not in frame
+    assert expected_range in frame
+    assert "Cell worker-17" in frame
+    assert "profiling sample 17" in frame
+
+
+def test_dashboard_key_aliases_clamp_scroll_ignore_noise_and_escape() -> None:
+    from ratatui import KeyCode
+
+    state = _snapshot_fixture()
+    cancellation = threading.Event()
+    assert not _handle_dashboard_key(state, {"kind": "mouse"}, cancellation)
+    assert state.selected_index == 0
+
+    state.detail_scroll = 2
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.PageUp, "ch": 0, "mods": 0},
+        cancellation,
+    )
+    assert state.detail_scroll == 0
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("k"), "mods": 0},
+        cancellation,
+    )
+    assert state.selected_index == -1
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("j"), "mods": 0},
+        cancellation,
+    )
+    assert state.selected_index == 0
+    assert not _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Char, "ch": ord("c"), "mods": 0},
+        cancellation,
+    )
+    assert not cancellation.is_set()
+
+    assert _handle_dashboard_key(
+        state,
+        {"kind": "key", "code": KeyCode.Esc, "ch": 0, "mods": 0},
+        cancellation,
+    )
+    assert cancellation.is_set()
+    assert state.interrupted
+
+
+def _manual_service(
+    tmp_path: Path,
+    *,
+    repo_root: Path = ROOT,
+    initialize_source_marker: bool = True,
+) -> ReportService:
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo_root,
+            profile="macbook_M3_manual",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    if initialize_source_marker:
+        manual_campaign.update_source_marker(
+            service,
+            manual_campaign.ReportSourceIdentity("a" * 40, "b" * 40, ()),
+        )
+    return service
+
+
+def _presentation_test_cell() -> CellSpec:
+    return next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        and cell.workload is Workload.CONTRACTED
+        and REPORT_CATALOG.static_na_reason(cell) is None
+    )
+
+
+def _presentation_outcome(
+    cell_id: str,
+    *,
+    status: str,
+    completed_at_ns: int = 1,
+    invocation_id: str = "presentation-test",
+    source_revision: str = "a" * 40,
+    profile: str = manual_campaign._PRESENTATION_PROFILE,
+    attempt_id: str | None = None,
+) -> manual_campaign.LightweightPresentationOutcome:
+    return manual_campaign.LightweightPresentationOutcome(
+        profile=profile,
+        cell_id=cell_id,
+        source_revision=source_revision,
+        campaign_invocation_id=invocation_id,
+        attempt_id=attempt_id,
+        status=status,
+        label=manual_campaign._humanized_outcome_label(status),
+        completed_at_ns=completed_at_ns,
+    )
+
+
+def test_presentation_outcome_survives_campaign_parent_and_basename_move(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = manual_campaign.ReportSourceIdentity("a" * 40, "b" * 40, ())
+    campaign_a = tmp_path / "parent-a/original-name"
+    campaign_a.mkdir(parents=True)
+    service_a = ReportService(
+        manual_campaign._campaign_report_paths(ROOT, campaign_a),
+        portable_current_results=True,
+    )
+    manual_campaign.update_source_marker(service_a, source)
+    cell = _presentation_test_cell()
+    monkeypatch.setattr(manual_campaign, "_ACTIVE_PROFILE", "original-name")
+    expected = _presentation_outcome(cell.cell_id, status="error")
+    assert manual_campaign._publish_presentation_outcome(service_a, expected)
+
+    campaign_b = tmp_path / "parent-b/renamed-campaign"
+    campaign_b.parent.mkdir()
+    campaign_a.rename(campaign_b)
+    service_b = ReportService(
+        manual_campaign._campaign_report_paths(ROOT, campaign_b),
+        portable_current_results=True,
+    )
+    monkeypatch.setattr(manual_campaign, "_ACTIVE_PROFILE", "renamed-campaign")
+
+    moved = manual_campaign.lightweight_presentation_outcome(
+        service_b,
+        cell,
+        source_revision=source.revision,
+    )
+    assert moved == expected
+
+
+def _valid_presentation_current(
+    cell_id: str,
+    tmp_path: Path,
+) -> LightweightCurrent:
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": ResultStatus.OK.value,
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 8.0e-7,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 1.0e-9,
+            "relative_standard_error": 1.0e-3,
+            "artifact": {"digest": "presentation-test"},
+            "validation": {"status": "ok", "direct_agreements": []},
+            "resources": {"peak_rss_bytes": 1},
+            "provenance": {"method": "original-amplicol-generated-library"},
+            "failure": None,
+        }
+    )
+    return LightweightCurrent(
+        cell_id=cell_id,
+        attempt_id="00000000-0000-4000-8000-000000000001",
+        result_path=tmp_path / "result.json",
+        result=measurement,
+        complete=True,
+        reusable=True,
+        reason="reusable",
+    )
+
+
+def _capped_presentation_current(
+    cell_id: str,
+    tmp_path: Path,
+) -> LightweightCurrent:
+    measurement = manual_campaign.failure_measurement(
+        ResultStatus.TIMEOUT,
+        "generation exceeded the configured limit",
+    )
+    measurement["provenance"] = {
+        "manual_campaign": {"generation_limit_seconds": 3600.0}
+    }
+    return LightweightCurrent(
+        cell_id=cell_id,
+        attempt_id="00000000-0000-4000-8000-000000000002",
+        result_path=tmp_path / "capped-result.json",
+        result=measurement,
+        complete=True,
+        reusable=True,
+        reason="reusable terminal cap",
+    )
+
+
+def _cache_measurement(
+    caches: dict[str, dict[str, object]],
+    *,
+    dataset_id: str,
+    cell_id: str,
+) -> dict[str, object]:
+    entries = caches[f"{dataset_id}.json"]["entries"]
+    assert isinstance(entries, list)
+    entry = next(item for item in entries if item["cell_id"] == cell_id)
+    measurement = entry["measurement"]
+    assert isinstance(measurement, dict)
+    return measurement
+
+
+def test_presentation_failure_overlay_never_replaces_a_valid_current(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    failure = _presentation_outcome(cell.cell_id, status="validation_failed")
+
+    failure_caches, merged = _merge_lightweight_snapshot(
+        service,
+        {},
+        {cell.cell_id: failure},
+    )
+    assert merged == 1
+    failure_measurement = _cache_measurement(
+        failure_caches,
+        dataset_id=cell.dataset_id,
+        cell_id=cell.cell_id,
+    )
+    assert failure_measurement["status"] == ResultStatus.VALIDATION_FAILED.value
+    assert failure_measurement["failure"] == {
+        "kind": "ManualCampaignOutcome:validation_failed",
+        "message": "validation failed",
+    }
+
+    current = _valid_presentation_current(cell.cell_id, tmp_path)
+    success_caches, merged = _merge_lightweight_snapshot(
+        service,
+        {cell.cell_id: current},
+        {
+            cell.cell_id: _presentation_outcome(
+                cell.cell_id,
+                status="error",
+                completed_at_ns=2,
+            )
+        },
+    )
+    assert merged == 1
+    assert (
+        _cache_measurement(
+            success_caches,
+            dataset_id=cell.dataset_id,
+            cell_id=cell.cell_id,
+        )["status"]
+        == ResultStatus.OK.value
+    )
+
+
+def test_presentation_success_tombstone_suppresses_failure_fallback(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    manual_campaign._publish_presentation_outcome(
+        service,
+        _presentation_outcome(
+            cell.cell_id,
+            status="error",
+            completed_at_ns=1,
+        ),
+    )
+    tombstone = _presentation_outcome(
+        cell.cell_id,
+        status="ok",
+        completed_at_ns=2,
+    )
+    manual_campaign._publish_presentation_outcome(service, tombstone)
+    observed = manual_campaign.lightweight_presentation_outcome(
+        service,
+        cell,
+        source_revision="a" * 40,
+    )
+    assert observed == tombstone
+
+    caches, merged = _merge_lightweight_snapshot(
+        service,
+        {},
+        {cell.cell_id: observed},
+    )
+
+    assert merged == 0
+    assert (
+        _cache_measurement(
+            caches,
+            dataset_id=cell.dataset_id,
+            cell_id=cell.cell_id,
+        )
+        == empty_measurement()
+    )
+
+
+def test_presentation_outcome_publication_has_deterministic_last_writer(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    later_tie_breaker = _presentation_outcome(
+        cell.cell_id,
+        status="error",
+        completed_at_ns=10,
+        invocation_id="invocation-b",
+    )
+    earlier_tie_breaker = _presentation_outcome(
+        cell.cell_id,
+        status="validation_failed",
+        completed_at_ns=10,
+        invocation_id="invocation-a",
+    )
+    oldest = _presentation_outcome(
+        cell.cell_id,
+        status="blocked_dependency",
+        completed_at_ns=9,
+        invocation_id="invocation-z",
+    )
+
+    manual_campaign._publish_presentation_outcome(service, later_tie_breaker)
+    manual_campaign._publish_presentation_outcome(service, oldest)
+    manual_campaign._publish_presentation_outcome(service, earlier_tie_breaker)
+
+    observed = manual_campaign.lightweight_presentation_outcome(
+        service,
+        cell,
+        source_revision="a" * 40,
+    )
+    assert observed == later_tie_breaker
+
+
+def test_strict_source_marker_rejects_late_old_revision_writer(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    old = _presentation_outcome(
+        cell.cell_id,
+        status="validation_failed",
+        completed_at_ns=300,
+        source_revision="a" * 40,
+    )
+    manual_campaign._publish_presentation_outcome(service, old)
+    manual_campaign.update_source_marker(
+        service,
+        manual_campaign.ReportSourceIdentity("b" * 40, "c" * 40, ()),
+    )
+    active = _presentation_outcome(
+        cell.cell_id,
+        status="error",
+        completed_at_ns=200,
+        source_revision="b" * 40,
+    )
+
+    manual_campaign._publish_presentation_outcome(service, active)
+    manual_campaign._publish_presentation_outcome(
+        service,
+        _presentation_outcome(
+            cell.cell_id,
+            status="validation_failed",
+            completed_at_ns=400,
+            source_revision="a" * 40,
+        ),
+    )
+
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="b" * 40,
+        )
+        == active
+    )
+
+
+def test_cross_revision_marker_retains_global_outcome_ordering(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    manual_campaign.update_source_marker(
+        service,
+        manual_campaign.ReportSourceIdentity("b" * 40, "c" * 40, ()),
+        continue_across_revisions=True,
+    )
+    active = _presentation_outcome(
+        cell.cell_id,
+        status="error",
+        completed_at_ns=200,
+        source_revision="b" * 40,
+    )
+    historical = _presentation_outcome(
+        cell.cell_id,
+        status="validation_failed",
+        completed_at_ns=300,
+        source_revision="a" * 40,
+    )
+
+    manual_campaign._publish_presentation_outcome(service, active)
+    manual_campaign._publish_presentation_outcome(service, historical)
+
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="b" * 40,
+            accept_historical_source=True,
+        )
+        == historical
+    )
+
+
+def test_presentation_publication_requires_a_readable_source_marker(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path, initialize_source_marker=False)
+    cell = _presentation_test_cell()
+    outcome = _presentation_outcome(cell.cell_id, status="error")
+
+    with pytest.raises(ManualCampaignError, match="source marker is unreadable"):
+        manual_campaign._publish_presentation_outcome(service, outcome)
+
+    marker = service.paths.coordination_root / "manual-source.json"
+    marker.parent.mkdir(parents=True, exist_ok=True)
+    marker.write_text("{broken", encoding="utf-8")
+    with pytest.raises(ManualCampaignError, match="source marker is unreadable"):
+        manual_campaign._publish_presentation_outcome(service, outcome)
+
+
+def test_presentation_outcome_reader_filters_source_profile_and_malformed_data(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    path = manual_campaign._presentation_outcome_path(service, cell.cell_id)
+    path.parent.mkdir(parents=True)
+    historical = _presentation_outcome(
+        cell.cell_id,
+        status="error",
+        source_revision="a" * 40,
+    )
+    path.write_text(json.dumps(historical.as_dict()), encoding="utf-8")
+
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="b" * 40,
+        )
+        is None
+    )
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="b" * 40,
+            accept_historical_source=True,
+        )
+        == historical
+    )
+
+    wrong_profile = historical.as_dict()
+    wrong_profile["profile"] = "some_other_profile"
+    path.write_text(json.dumps(wrong_profile), encoding="utf-8")
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="a" * 40,
+        )
+        is None
+    )
+
+    path.write_text('{"schema":"truncated"', encoding="utf-8")
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="a" * 40,
+        )
+        is None
+    )
+
+
+def test_presentation_outcome_reader_rejects_timestamp_above_signed_64_bit(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    path = manual_campaign._presentation_outcome_path(service, cell.cell_id)
+    path.parent.mkdir(parents=True)
+    malformed = _presentation_outcome(cell.cell_id, status="error").as_dict()
+    malformed["completed_at_ns"] = 1 << 63
+    path.write_text(json.dumps(malformed), encoding="utf-8")
+
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="a" * 40,
+        )
+        is None
+    )
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("campaign_invocation_id", "campaign-λ"),
+        ("label", "error 🚫"),
+    ),
+)
+def test_presentation_outcome_parser_rejects_printable_non_ascii_metadata(
+    field: str,
+    value: str,
+) -> None:
+    cell = _presentation_test_cell()
+    malformed = _presentation_outcome(cell.cell_id, status="error").as_dict()
+    assert value.isprintable()
+    assert not value.isascii()
+    malformed[field] = value
+
+    assert (
+        manual_campaign._parse_presentation_outcome(
+            malformed,
+            expected_profile=manual_campaign._PRESENTATION_PROFILE,
+            expected_cell_id=cell.cell_id,
+            source_revision="a" * 40,
+            accept_historical_source=False,
+        )
+        is None
+    )
+
+
+def test_started_event_drops_stale_identity_before_generic_failure_overlay(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    current = _capped_presentation_current(cell.cell_id, tmp_path)
+    worker = WorkerView(
+        cell.cell_id,
+        status="generation_limit",
+        attempt_id=current.attempt_id,
+        log_path="stale-worker.log",
+        progress_path="stale-progress.jsonl",
+        progress_completed=9,
+        progress_total=10,
+        progress_message="stale progress",
+        progress_task_id="stale-task",
+        progress_details={"stale": True},
+        wall_seconds=12.0,
+        cpu_seconds=8.0,
+        current_rss_bytes=99,
+        peak_rss_bytes=101,
+        published_wall_seconds_per_point=0.5,
+        phase_timeline=(manual_campaign.PhaseTimelineRow("stale"),),
+        blocked_prerequisite_ids=("stale-prerequisite",),
+        events=["stale event"],
+        log_tail=["stale cap diagnostics"],
+    )
+    state = DashboardState(
+        instance_id="new-invocation",
+        selected_ids=(cell.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+        workers={cell.cell_id: worker},
+    )
+    lease = LeaseManager(service, state)
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_current",
+        lambda *_args, **_kwargs: current,
+    )
+
+    lease.observe({"event": "started", "cell_id": cell.cell_id})
+
+    fresh_worker = state.workers[cell.cell_id]
+    assert fresh_worker is not worker
+    worker = fresh_worker
+    assert worker.attempt_id is None
+    assert worker.log_path is None
+    assert worker.progress_path is None
+    assert worker.progress_completed is None
+    assert worker.progress_total is None
+    assert worker.progress_message == ""
+    assert worker.progress_task_id is None
+    assert worker.progress_details == {}
+    assert worker.log_tail == []
+    assert worker.wall_seconds == 0.0
+    assert worker.cpu_seconds is None
+    assert worker.current_rss_bytes == 0
+    assert worker.peak_rss_bytes == 0
+    assert worker.published_wall_seconds_per_point is None
+    assert worker.phase_timeline == ()
+    assert worker.blocked_prerequisite_ids == ()
+    assert worker.events == ["started: dependency preparation"]
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": cell.cell_id,
+            "status": "error",
+            "detail": "generic worker crash without attempt records",
+            "completed_at_ns": 7,
+        }
+    )
+    observed = manual_campaign.lightweight_presentation_outcome(
+        service,
+        cell,
+        source_revision="a" * 40,
+    )
+    assert observed is not None
+    assert observed.status == "error"
+    assert observed.attempt_id is None
+
+    caches, merged = _merge_lightweight_snapshot(
+        service,
+        {cell.cell_id: current},
+        {cell.cell_id: observed},
+    )
+    assert merged == 1
+    measurement = _cache_measurement(
+        caches,
+        dataset_id=cell.dataset_id,
+        cell_id=cell.cell_id,
+    )
+    assert measurement["status"] == ResultStatus.ERROR.value
+    assert measurement["failure"] == {
+        "kind": "ManualCampaignOutcome:error",
+        "message": "error",
+    }
+
+
+@pytest.mark.parametrize("recycle_status", ("reused", "skipped-current"))
+def test_non_ok_recycle_does_not_erase_newer_error_outcome(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    recycle_status: str,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    current = _capped_presentation_current(cell.cell_id, tmp_path)
+    error = _presentation_outcome(
+        cell.cell_id, status="error", completed_at_ns=2
+    )
+    manual_campaign._publish_presentation_outcome(service, error)
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_current",
+        lambda *_args, **_kwargs: current,
+    )
+    lease = LeaseManager(
+        service,
+        DashboardState(
+            instance_id="cap-recycle",
+            selected_ids=(cell.cell_id,),
+            recycled_ids=set(),
+            static_na_ids=set(),
+            source_revision="a" * 40,
+        ),
+    )
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": cell.cell_id,
+            "status": recycle_status,
+            "detail": "ordinary terminal-current recycle",
+            "completed_at_ns": 3,
+        }
+    )
+
+    observed = manual_campaign.lightweight_presentation_outcome(
+        service,
+        cell,
+        source_revision="a" * 40,
+    )
+    assert observed == error
+
+
+@pytest.mark.parametrize("existing_success", (False, True))
+def test_front_end_ok_recycle_does_not_write_without_existing_failure(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    existing_success: bool,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    current = _valid_presentation_current(cell.cell_id, tmp_path)
+    if existing_success:
+        manual_campaign._publish_presentation_outcome(
+            service,
+            _presentation_outcome(cell.cell_id, status="reused"),
+        )
+    writes: list[manual_campaign.LightweightPresentationOutcome] = []
+    publish = manual_campaign._publish_presentation_outcome
+
+    def capture(
+        target: ReportService,
+        outcome: manual_campaign.LightweightPresentationOutcome,
+        **kwargs: object,
+    ) -> bool:
+        written = publish(target, outcome, **kwargs)
+        if written:
+            writes.append(outcome)
+        return written
+
+    monkeypatch.setattr(manual_campaign, "_publish_presentation_outcome", capture)
+    warnings = manual_campaign._publish_recycled_presentation_outcomes(
+        service,
+        {cell.cell_id: current},
+        (cell.cell_id,),
+        source_revision="a" * 40,
+        campaign_invocation_id="passive-recycle",
+    )
+
+    assert warnings == ()
+    assert writes == []
+    observed = manual_campaign.lightweight_presentation_outcome(
+        service,
+        cell,
+        source_revision="a" * 40,
+    )
+    if existing_success:
+        assert observed is not None
+        assert observed.status == "reused"
+    else:
+        assert observed is None
+
+
+@pytest.mark.parametrize(
+    ("status", "existing_status", "expected_status", "expected_writes"),
+    (
+        ("ok", None, None, 0),
+        ("reused", "reused", "reused", 0),
+        ("skipped-current", "error", "skipped-current", 1),
+    ),
+)
+def test_lease_success_with_resolved_ok_only_suppresses_existing_failure(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    status: str,
+    existing_status: str | None,
+    expected_status: str | None,
+    expected_writes: int,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    current = _valid_presentation_current(cell.cell_id, tmp_path)
+    if existing_status is not None:
+        manual_campaign._publish_presentation_outcome(
+            service,
+            _presentation_outcome(cell.cell_id, status=existing_status),
+        )
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_current",
+        lambda *_args, **_kwargs: current,
+    )
+    writes: list[manual_campaign.LightweightPresentationOutcome] = []
+    publish = manual_campaign._publish_presentation_outcome
+
+    def capture(
+        target: ReportService,
+        outcome: manual_campaign.LightweightPresentationOutcome,
+        **kwargs: object,
+    ) -> bool:
+        written = publish(target, outcome, **kwargs)
+        if written:
+            writes.append(outcome)
+        return written
+
+    monkeypatch.setattr(manual_campaign, "_publish_presentation_outcome", capture)
+    lease = LeaseManager(
+        service,
+        DashboardState(
+            instance_id="finished-ok",
+            selected_ids=(cell.cell_id,),
+            recycled_ids=set(),
+            static_na_ids=set(),
+            source_revision="a" * 40,
+        ),
+    )
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": cell.cell_id,
+            "status": status,
+            "detail": "resolved reusable OK current",
+            "completed_at_ns": 2,
+        }
+    )
+
+    assert len(writes) == expected_writes
+    observed = manual_campaign.lightweight_presentation_outcome(
+        service,
+        cell,
+        source_revision="a" * 40,
+    )
+    if expected_status is None:
+        assert observed is None
+    else:
+        assert observed is not None
+        assert observed.status == expected_status
+        if expected_writes:
+            assert observed.attempt_id == current.attempt_id
+
+
+@pytest.mark.parametrize("continuation_at_success", (False, True))
+def test_cross_revision_success_tombstones_historical_failure(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    continuation_at_success: bool,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    manual_campaign._publish_presentation_outcome(
+        service,
+        _presentation_outcome(
+            cell.cell_id,
+            status="error",
+            completed_at_ns=1,
+            source_revision="a" * 40,
+        ),
+    )
+    manual_campaign.update_source_marker(
+        service,
+        manual_campaign.ReportSourceIdentity("b" * 40, "c" * 40, ()),
+        continue_across_revisions=continuation_at_success,
+    )
+    current = _valid_presentation_current(cell.cell_id, tmp_path)
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_current",
+        lambda *_args, **_kwargs: current,
+    )
+    lease = LeaseManager(
+        service,
+        DashboardState(
+            instance_id="cross-revision-success",
+            selected_ids=(cell.cell_id,),
+            recycled_ids=set(),
+            static_na_ids=set(),
+            source_revision="b" * 40,
+        ),
+    )
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": cell.cell_id,
+            "status": "ok",
+            "detail": "new revision succeeded",
+            "completed_at_ns": 2,
+        }
+    )
+
+    if not continuation_at_success:
+        manual_campaign.update_source_marker(
+            service,
+            manual_campaign.ReportSourceIdentity("b" * 40, "c" * 40, ()),
+            continue_across_revisions=True,
+        )
+
+    tombstone = manual_campaign.lightweight_presentation_outcome(
+        service,
+        cell,
+        source_revision="b" * 40,
+        accept_historical_source=True,
+    )
+    assert tombstone is not None
+    assert tombstone.successful
+    assert tombstone.source_revision == "b" * 40
+    caches, merged = _merge_lightweight_snapshot(
+        service,
+        {},
+        {cell.cell_id: tombstone},
+    )
+    assert merged == 0
+    assert (
+        _cache_measurement(
+            caches,
+            dataset_id=cell.dataset_id,
+            cell_id=cell.cell_id,
+        )["status"]
+        == ResultStatus.NOT_AVAILABLE.value
+    )
+
+
+def test_front_end_ok_recycle_skips_immediately_when_cell_lock_is_busy(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    current = _valid_presentation_current(cell.cell_id, tmp_path)
+    calls: list[tuple[str, float | None]] = []
+    writes: list[manual_campaign.LightweightPresentationOutcome] = []
+
+    class BusyLock:
+        def __enter__(self) -> None:
+            raise manual_campaign.LockTimeoutError("busy")
+
+        def __exit__(
+            self,
+            _error_type: object,
+            _error: object,
+            _traceback: object,
+        ) -> None:
+            return None
+
+    def busy_lock(name: str, **kwargs: object) -> BusyLock:
+        timeout = kwargs.get("timeout")
+        calls.append((name, timeout if isinstance(timeout, float) else None))
+        return BusyLock()
+
+    monkeypatch.setattr(service.store, "named_lock", busy_lock)
+    monkeypatch.setattr(
+        manual_campaign,
+        "_publish_presentation_outcome",
+        lambda _service, outcome, **_kwargs: writes.append(outcome),
+    )
+
+    warnings = manual_campaign._publish_recycled_presentation_outcomes(
+        service,
+        {cell.cell_id: current},
+        (cell.cell_id,),
+        source_revision="a" * 40,
+        campaign_invocation_id="no-ledger",
+    )
+
+    assert warnings == ()
+    assert calls == [(f"campaign-cell-{cell.cell_id}", 0.0)]
+    assert writes == []
+
+
+def test_front_end_recycle_reconciles_outcome_under_campaign_cell_lock(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    current = _valid_presentation_current(cell.cell_id, tmp_path)
+    manual_campaign._publish_presentation_outcome(
+        service,
+        _presentation_outcome(cell.cell_id, status="error"),
+    )
+    campaign_lock = f"campaign-cell-{cell.cell_id}"
+    held: list[str] = []
+
+    class TrackingLock:
+        def __init__(self, name: str) -> None:
+            self.name = name
+
+        def __enter__(self) -> None:
+            held.append(self.name)
+
+        def __exit__(
+            self,
+            _error_type: object,
+            _error: object,
+            _traceback: object,
+        ) -> None:
+            assert held.pop() == self.name
+
+    monkeypatch.setattr(
+        service.store,
+        "named_lock",
+        lambda name, **_kwargs: TrackingLock(name),
+    )
+    read = manual_campaign.lightweight_presentation_outcome
+    publish = manual_campaign._publish_presentation_outcome
+    operations: list[tuple[str, bool]] = []
+
+    def tracked_read(*args: object, **kwargs: object):
+        operations.append(("read", campaign_lock in held))
+        return read(*args, **kwargs)
+
+    def tracked_publish(*args: object, **kwargs: object) -> None:
+        assert campaign_lock in held
+        operations.append(("write", True))
+        publish(*args, **kwargs)
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_presentation_outcome",
+        tracked_read,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_publish_presentation_outcome",
+        tracked_publish,
+    )
+
+    warnings = manual_campaign._publish_recycled_presentation_outcomes(
+        service,
+        {cell.cell_id: current},
+        (cell.cell_id,),
+        source_revision="a" * 40,
+        campaign_invocation_id="lock-order",
+    )
+
+    assert warnings == ()
+    assert operations == [("read", False), ("write", True)]
+    assert held == []
+
+
+def test_front_end_recycle_honours_marker_switch_to_continuation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    manual_campaign._publish_presentation_outcome(
+        service,
+        _presentation_outcome(
+            cell.cell_id,
+            status="error",
+            source_revision="a" * 40,
+        ),
+    )
+    source_b = manual_campaign.ReportSourceIdentity("b" * 40, "c" * 40, ())
+    manual_campaign.update_source_marker(service, source_b)
+    current = _valid_presentation_current(cell.cell_id, tmp_path)
+    read = manual_campaign.lightweight_presentation_outcome
+    switched = False
+
+    def read_then_switch(*args: object, **kwargs: object):
+        nonlocal switched
+        outcome = read(*args, **kwargs)
+        if not switched:
+            switched = True
+            manual_campaign.update_source_marker(
+                service,
+                source_b,
+                continue_across_revisions=True,
+            )
+        return outcome
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_presentation_outcome",
+        read_then_switch,
+    )
+
+    warnings = manual_campaign._publish_recycled_presentation_outcomes(
+        service,
+        {cell.cell_id: current},
+        (cell.cell_id,),
+        source_revision=source_b.revision,
+        campaign_invocation_id="marker-switch",
+        accept_historical_source=False,
+    )
+
+    assert warnings == ()
+    outcome = read(
+        service,
+        cell,
+        source_revision=source_b.revision,
+        accept_historical_source=True,
+    )
+    assert outcome is not None
+    assert outcome.successful
+    assert outcome.source_revision == source_b.revision
+
+
+def _stub_run_campaign_boundaries(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    *,
+    currents: dict[str, LightweightCurrent],
+    planned: tuple[manual_campaign.PlannedCell, ...],
+    outcomes: tuple[CellOutcome, ...] = (),
+) -> None:
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_currents",
+        lambda *_args, **_kwargs: dict(currents),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "plan_campaign",
+        lambda *_args, **_kwargs: planned,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_bind_original_amplicol_if_required",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "require_measurement_ready",
+        lambda _source: None,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_publish_campaign_summary_ids",
+        lambda *_args, **_kwargs: (tmp_path / "summary", {}),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_print_campaign_summary_ids",
+        lambda *_args, **_kwargs: None,
+    )
+
+    class StubScheduler:
+        def __init__(self, _service: ReportService, *, settings: object) -> None:
+            self.settings = settings
+
+        def run(
+            self,
+            observed: tuple[manual_campaign.PlannedCell, ...],
+        ) -> manual_campaign.CampaignResult:
+            assert tuple(observed) == planned
+            return manual_campaign.CampaignResult(tuple(observed), outcomes)
+
+    monkeypatch.setattr(manual_campaign, "CampaignScheduler", StubScheduler)
+
+
+@pytest.mark.parametrize("mixed", (False, True))
+def test_run_campaign_recycle_paths_replace_failure_with_known_ok_tombstone(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    mixed: bool,
+) -> None:
+    service = _manual_service(tmp_path)
+    measurable = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is None
+    )
+    recycled_cell = measurable[0]
+    work_cell = measurable[1]
+    current = _valid_presentation_current(recycled_cell.cell_id, tmp_path)
+    manual_campaign._publish_presentation_outcome(
+        service,
+        _presentation_outcome(recycled_cell.cell_id, status="error"),
+    )
+    planned = (
+        (
+            manual_campaign.PlannedCell(
+                work_cell,
+                dependency=False,
+                baseline_cell_id=None,
+                rank=1,
+            ),
+        )
+        if mixed
+        else ()
+    )
+    outcomes = (CellOutcome(work_cell.cell_id, "ok", "completed"),) if mixed else ()
+    _stub_run_campaign_boundaries(
+        monkeypatch,
+        tmp_path,
+        currents={recycled_cell.cell_id: current},
+        planned=planned,
+        outcomes=outcomes,
+    )
+    arguments = _parse("run", "--no-dashboard")
+    source = manual_campaign.ReportSourceIdentity("a" * 40, "b" * 40, ())
+
+    return_code = manual_campaign._run_campaign(
+        arguments,
+        repo_root=ROOT,
+        service=service,
+        source=source,
+        cells=(recycled_cell, work_cell) if mixed else (recycled_cell,),
+        palette=manual_campaign.Palette(False),
+    )
+
+    assert return_code == 0
+    observed = manual_campaign.lightweight_presentation_outcome(
+        service,
+        recycled_cell,
+        source_revision=source.revision,
+    )
+    assert observed is not None
+    assert observed.status == "reused"
+    assert observed.attempt_id == current.attempt_id
+
+
+def test_cross_revision_continuation_recycles_ok_and_replans_blocked_cell(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    old_revision = "a" * 40
+    active_source = manual_campaign.ReportSourceIdentity("b" * 40, "c" * 40, ())
+    ok_cell = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-lc-n3-dd-z-jets-selected-flow"
+    )
+    blocked_cell = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-lc-n4-dd-ttzh-jets-selected-flow"
+    )
+
+    def historical(
+        cell: CellSpec,
+        *,
+        status: str,
+        reusable: bool,
+    ) -> LightweightCurrent:
+        return LightweightCurrent(
+            cell_id=cell.cell_id,
+            attempt_id=f"historical-{status}",
+            result_path=tmp_path / f"{cell.cell_id}.json",
+            result={
+                "status": status,
+                "provenance": {"report_source_revision": old_revision},
+            },
+            complete=reusable,
+            reusable=reusable,
+            reason=("historical source current" if reusable else "incomplete status"),
+        )
+
+    currents = {
+        ok_cell.cell_id: historical(ok_cell, status="ok", reusable=True),
+        blocked_cell.cell_id: historical(
+            blocked_cell,
+            status="skip",
+            reusable=False,
+        ),
+    }
+    planned = (
+        manual_campaign.PlannedCell(
+            blocked_cell,
+            dependency=False,
+            baseline_cell_id=None,
+            rank=0,
+            optional_baseline_cell_id=(
+                "reference-amplicol-lc-n4-dd-ttzh-jets-selected-flow"
+            ),
+        ),
+    )
+    _stub_run_campaign_boundaries(
+        monkeypatch,
+        tmp_path,
+        currents=currents,
+        planned=planned,
+        outcomes=(CellOutcome(blocked_cell.cell_id, "ok", "completed"),),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "lightweight_currents",
+        lambda *_args, **kwargs: (
+            dict(currents) if kwargs.get("accept_historical_source") else {}
+        ),
+    )
+    requested: list[tuple[str, ...]] = []
+
+    def capture_plan(cells: tuple[CellSpec, ...], **_kwargs: object):
+        requested.append(tuple(cell.cell_id for cell in cells))
+        return planned
+
+    monkeypatch.setattr(manual_campaign, "plan_campaign", capture_plan)
+
+    return_code = manual_campaign._run_campaign(
+        _parse("run", "--continue-across-revisions", "--no-dashboard"),
+        repo_root=ROOT,
+        service=service,
+        source=active_source,
+        cells=(ok_cell, blocked_cell),
+        palette=manual_campaign.Palette(False),
+    )
+
+    assert return_code == 0
+    assert requested == [(blocked_cell.cell_id,)]
+
+
+def test_run_campaign_recycled_cap_does_not_erase_newer_error(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    current = _capped_presentation_current(cell.cell_id, tmp_path)
+    error = _presentation_outcome(cell.cell_id, status="error")
+    manual_campaign._publish_presentation_outcome(service, error)
+    _stub_run_campaign_boundaries(
+        monkeypatch,
+        tmp_path,
+        currents={cell.cell_id: current},
+        planned=(),
+    )
+
+    return_code = manual_campaign._run_campaign(
+        _parse("run", "--no-dashboard"),
+        repo_root=ROOT,
+        service=service,
+        source=manual_campaign.ReportSourceIdentity("a" * 40, "b" * 40, ()),
+        cells=(cell,),
+        palette=manual_campaign.Palette(False),
+    )
+
+    assert return_code == 0
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="a" * 40,
+        )
+        == error
+    )
+
+
+def test_catalog_static_na_takes_precedence_over_presentation_outcome(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is not None
+    )
+    caches, merged = _merge_lightweight_snapshot(
+        service,
+        {},
+        {cell.cell_id: _presentation_outcome(cell.cell_id, status="error")},
+    )
+
+    assert merged == 0
+    assert (
+        _cache_measurement(
+            caches,
+            dataset_id=cell.dataset_id,
+            cell_id=cell.cell_id,
+        )
+        == empty_measurement()
+    )
+
+
+@pytest.mark.parametrize(
+    "status",
+    (
+        "generation_limit",
+        "memory_limit",
+        "worker_timeout",
+        "profiling_timeout",
+        "validation_timeout",
+        "dependency",
+        "resource_frontier",
+        "error",
+        "validation_failed",
+        "blocked_dependency",
+        "skip",
+        "preparation_error",
+        "failed",
+        "unsupported",
+        "cancelled",
+    ),
+)
+def test_lease_manager_routes_every_started_terminal_status_to_presentation(
+    tmp_path: Path,
+    status: str,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    state = DashboardState(
+        instance_id=f"terminal-{status}",
+        selected_ids=(cell.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+    lease = LeaseManager(service, state)
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": cell.cell_id,
+            "status": status,
+            "detail": (
+                "worker terminated by cancellation"
+                if status == "cancelled"
+                else "terminal outcome"
+            ),
+            "completed_at_ns": 123,
+        }
+    )
+
+    observed = manual_campaign.lightweight_presentation_outcome(
+        service,
+        cell,
+        source_revision="a" * 40,
+    )
+    assert observed is not None
+    assert observed.status == status
+    assert observed.label == manual_campaign._humanized_outcome_label(status)
+    assert observed.attempt_id is None
+    assert observed.completed_at_ns == 123
+
+
+@pytest.mark.parametrize("status", ("ok", "reused", "skipped-current"))
+def test_lease_manager_does_not_publish_success_without_reusable_ok_current(
+    tmp_path: Path,
+    status: str,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    lease = LeaseManager(
+        service,
+        DashboardState(
+            instance_id=f"terminal-{status}",
+            selected_ids=(cell.cell_id,),
+            recycled_ids=set(),
+            static_na_ids=set(),
+            source_revision="a" * 40,
+        ),
+    )
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": cell.cell_id,
+            "status": status,
+            "detail": "no reusable OK current exists",
+            "completed_at_ns": 123,
+        }
+    )
+
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="a" * 40,
+        )
+        is None
+    )
+
+
+@pytest.mark.parametrize("raises", (False, True))
+def test_scheduler_finished_event_has_positive_completion_timestamp_after_started(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    raises: bool,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    events: list[dict[str, object]] = []
+    campaign_lock = f"campaign-cell-{cell.cell_id}"
+    held: list[str] = []
+
+    class TrackingLock:
+        def __init__(self, name: str) -> None:
+            self.name = name
+
+        def __enter__(self) -> None:
+            held.append(self.name)
+
+        def __exit__(
+            self,
+            _error_type: object,
+            _error: object,
+            _traceback: object,
+        ) -> None:
+            assert held.pop() == self.name
+
+    monkeypatch.setattr(
+        service.store,
+        "named_lock",
+        lambda name, **_kwargs: TrackingLock(name),
+    )
+
+    def observe(payload: object) -> None:
+        assert isinstance(payload, dict)
+        if payload.get("event") == "finished":
+            assert campaign_lock in held
+        events.append(dict(payload))
+
+    scheduler = manual_campaign.CampaignScheduler(
+        service,
+        settings=manual_campaign.CampaignSettings(
+            source_identity_override=manual_campaign.ReportSourceIdentity(
+                "a" * 40,
+                "b" * 40,
+                (),
+            ),
+            progress_observer=observe,
+        ),
+    )
+    planned = manual_campaign.PlannedCell(
+        cell,
+        dependency=False,
+        baseline_cell_id=None,
+        rank=0,
+    )
+    def run_in_lane(_planned: manual_campaign.PlannedCell) -> CellOutcome:
+        scheduler._observe("started", cell, dependency=False)
+        if raises:
+            raise RuntimeError("synthetic worker failure")
+        return CellOutcome(cell.cell_id, "ok", "completed")
+
+    monkeypatch.setattr(scheduler, "_run_cell_in_lane", run_in_lane)
+    before = time.time_ns()
+    if raises:
+        with pytest.raises(RuntimeError, match="synthetic worker failure"):
+            scheduler._run_cell(planned)
+    else:
+        assert scheduler._run_cell(planned).status == "ok"
+    after = time.time_ns()
+
+    assert [event["event"] for event in events] == ["started", "finished"]
+    finished = events[-1]
+    assert isinstance(finished["completed_at_ns"], int)
+    assert before <= finished["completed_at_ns"] <= after
+    assert finished["status"] == ("error" if raises else "ok")
+
+
+def test_scheduler_finished_event_forwards_terminal_detail(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    events: list[dict[str, object]] = []
+    scheduler = manual_campaign.CampaignScheduler(
+        service,
+        settings=manual_campaign.CampaignSettings(
+            source_identity_override=manual_campaign.ReportSourceIdentity(
+                "a" * 40, "b" * 40, ()
+            ),
+            progress_observer=lambda payload: events.append(dict(payload)),
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_coordination_lock_names", lambda _cell: ())
+    monkeypatch.setattr(
+        scheduler,
+        "_run_cell_in_lane",
+        lambda _planned: CellOutcome(
+            cell.cell_id,
+            ResultStatus.VALIDATION_FAILED.value,
+            "00000000-0000-4000-8000-000000000088",
+            terminal_detail="resolved component sum disagrees with total",
+        ),
+    )
+
+    scheduler._run_cell(manual_campaign.PlannedCell(cell, False, None, 0))
+
+    finished = [event for event in events if event["event"] == "finished"]
+    assert len(finished) == 1
+    assert finished[0]["terminal_detail"] == (
+        "resolved component sum disagrees with total"
+    )
+
+
+def test_scheduler_inner_coordination_deferred_emits_no_finished_event(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    events: list[dict[str, object]] = []
+    scheduler = manual_campaign.CampaignScheduler(
+        _manual_service(tmp_path),
+        settings=manual_campaign.CampaignSettings(
+            source_identity_override=manual_campaign.ReportSourceIdentity(
+                "a" * 40, "b" * 40, ()
+            ),
+            progress_observer=lambda payload: events.append(dict(payload)),
+        ),
+    )
+    planned = manual_campaign.PlannedCell(
+        _presentation_test_cell(), False, None, 0
+    )
+    monkeypatch.setattr(scheduler, "_coordination_lock_names", lambda _cell: ())
+    monkeypatch.setattr(
+        scheduler,
+        "_run_cell_in_lane",
+        lambda _planned: (_ for _ in ()).throw(_CoordinationDeferred("inner")),
+    )
+
+    with pytest.raises(_CoordinationDeferred, match="inner"):
+        scheduler._run_cell(planned)
+
+    assert [event for event in events if event["event"] == "finished"] == []
+
+
+def test_scheduler_inner_lock_cancel_emits_one_cancelled_and_no_presentation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    events: list[dict[str, object]] = []
+    lease = LeaseManager(
+        service,
+        DashboardState(
+            instance_id="inner-lock-cancel",
+            selected_ids=(cell.cell_id,),
+            recycled_ids=set(),
+            static_na_ids=set(),
+            source_revision="a" * 40,
+        ),
+    )
+
+    def observe(payload: object) -> None:
+        assert isinstance(payload, dict)
+        events.append(dict(payload))
+        lease.observe(payload)
+
+    scheduler = manual_campaign.CampaignScheduler(
+        service,
+        settings=manual_campaign.CampaignSettings(
+            source_identity_override=manual_campaign.ReportSourceIdentity(
+                "a" * 40, "b" * 40, ()
+            ),
+            progress_observer=observe,
+        ),
+    )
+    planned = manual_campaign.PlannedCell(cell, False, None, 0)
+    monkeypatch.setattr(scheduler, "_coordination_lock_names", lambda _cell: ())
+    monkeypatch.setattr(
+        scheduler,
+        "_run_cell_in_lane",
+        lambda _planned: (_ for _ in ()).throw(LockCancelledError("cancelled")),
+    )
+
+    outcome = scheduler._run_cell(planned)
+
+    finished = [event for event in events if event["event"] == "finished"]
+    assert [(event["status"], event["detail"]) for event in finished] == [
+        ("cancelled", "lock wait cancelled")
+    ]
+    assert not any(event.get("status") == "error" for event in events)
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="a" * 40,
+        )
+        is None
+    )
+    assert outcome == CellOutcome(cell.cell_id, "cancelled", "lock wait cancelled")
+
+
+@pytest.mark.parametrize(
+    ("status", "detail"),
+    (
+        (ResultStatus.NOT_AVAILABLE.value, "canonical reset"),
+        ("cancelled", "not started"),
+        ("cancelled", "lock wait cancelled"),
+    ),
+)
+def test_lease_manager_does_not_publish_non_attempt_outcomes(
+    tmp_path: Path,
+    status: str,
+    detail: str,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    lease = LeaseManager(
+        service,
+        DashboardState(
+            instance_id="non-attempt",
+            selected_ids=(cell.cell_id,),
+            recycled_ids=set(),
+            static_na_ids=set(),
+            source_revision="a" * 40,
+        ),
+    )
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": cell.cell_id,
+            "status": status,
+            "detail": detail,
+            "completed_at_ns": 123,
+        }
+    )
+
+    assert (
+        manual_campaign.lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision="a" * 40,
+        )
+        is None
+    )
+
+
+def test_lease_publication_uses_runtime_revision_without_checkout_git(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    state = DashboardState(
+        instance_id="installed",
+        selected_ids=(),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+
+    def forbidden(_repo_root: Path) -> str:
+        raise AssertionError("installed campaign lease inspected checkout Git")
+
+    monkeypatch.setattr(manual_campaign, "_repo_head", forbidden)
+    lease = LeaseManager(service, state)
+    lease.publish()
+
+    payload = json.loads(lease.path.read_text(encoding="utf-8"))
+    assert payload["source_revision"] == "a" * 40
+
+
+def _environment_witness_current(
+    tmp_path: Path,
+    *,
+    cell_id: str,
+    source_revision: str,
+    native_extension_sha256: str = "b" * 64,
+    numpy_version: str | None = None,
+) -> LightweightCurrent:
+    runtime = {
+        "source_revision": source_revision,
+        "package_version": "0.1.4",
+        "python_package_tree": {"sha256": "a" * 64},
+        "candidate_build_identity": {
+            "candidate_fingerprint": "candidate-test",
+            "source_revision": source_revision,
+            "publishable": False,
+        },
+        "candidate_build_identity_sha256": "c" * 64,
+        "native_build_inputs_sha256": "d" * 64,
+        "native_extension": {
+            "sha256": native_extension_sha256,
+            "package_version": "0.1.4",
+        },
+        "native_target": {
+            "triple": "aarch64-apple-darwin",
+            "cpu_features": ["neon"],
+        },
+    }
+    provenance = {
+        "report_source_revision": source_revision,
+        "platform": "MeasuredOS 1.0; witness",
+        "machine": "measured-machine",
+        "processor": "measured-processor",
+        "python": "3.11.9",
+        "runtime_identity": runtime,
+    }
+    if numpy_version is not None:
+        provenance["numpy"] = numpy_version
+    return LightweightCurrent(
+        cell_id=cell_id,
+        attempt_id=f"attempt-{cell_id}",
+        result_path=tmp_path / f"{cell_id}.json",
+        result={
+            "status": ResultStatus.OK.value,
+            "provenance": provenance,
+        },
+        complete=True,
+        reusable=True,
+        reason="reusable",
+    )
+
+
+def test_environment_witness_is_active_source_and_consistent(tmp_path: Path) -> None:
+    active_revision = "a" * 40
+    assert (
+        manual_campaign._active_environment_runtime_witness(
+            {},
+            source_revision=active_revision,
+        )
+        is None
+    )
+    historical = _environment_witness_current(
+        tmp_path,
+        cell_id="historical",
+        source_revision="b" * 40,
+    )
+    first = _environment_witness_current(
+        tmp_path,
+        cell_id="first",
+        source_revision=active_revision,
+    )
+    second = _environment_witness_current(
+        tmp_path,
+        cell_id="second",
+        source_revision=active_revision,
+    )
+
+    selected = manual_campaign._active_environment_runtime_witness(
+        {
+            historical.cell_id: historical,
+            first.cell_id: first,
+            second.cell_id: second,
+        },
+        source_revision=active_revision,
+    )
+
+    assert selected is not None
+    assert selected.active_runtime == first.result["provenance"]["runtime_identity"]
+    assert selected.host_environment == {
+        "platform": "MeasuredOS 1.0; witness",
+        "machine": "measured-machine",
+        "processor": "measured-processor",
+        "python": "3.11.9",
+        "python_implementation": "CPython",
+        "numpy": manual_campaign._UNRECORDED_MEASUREMENT_NUMPY,
+    }
+    legacy_environment = workspace_module._authenticated_environment_payload(
+        "portable-campaign",
+        expected_source_revision=active_revision,
+        active_runtime=selected.active_runtime,
+        host_environment=selected.host_environment,
+    )
+    assert "NumPy unavailable (not recorded by measurement)" in (
+        workspace_module._environment_tex(legacy_environment)
+    )
+    assert (
+        manual_campaign._active_environment_runtime_witness(
+            {historical.cell_id: historical},
+            source_revision=active_revision,
+        )
+        is None
+    )
+
+    conflicting = _environment_witness_current(
+        tmp_path,
+        cell_id="conflicting",
+        source_revision=active_revision,
+        native_extension_sha256="e" * 64,
+    )
+    with pytest.raises(ManualCampaignError, match="currents disagree"):
+        manual_campaign._active_environment_runtime_witness(
+            {
+                first.cell_id: first,
+                conflicting.cell_id: conflicting,
+            },
+            source_revision=active_revision,
+        )
+
+    for candidate_revision in (None, "b" * 40):
+        malformed = _environment_witness_current(
+            tmp_path,
+            cell_id=f"malformed-{candidate_revision}",
+            source_revision=active_revision,
+        )
+        runtime = malformed.result["provenance"]["runtime_identity"]
+        candidate = runtime["candidate_build_identity"]
+        if candidate_revision is None:
+            candidate.pop("source_revision")
+        else:
+            candidate["source_revision"] = candidate_revision
+        with pytest.raises(ManualCampaignError, match="build identity"):
+            manual_campaign._active_environment_runtime_witness(
+                {malformed.cell_id: malformed},
+                source_revision=active_revision,
+            )
+
+
+def test_read_only_views_use_recorded_measurement_source_epoch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path, initialize_source_marker=False)
+    checkout_revision = "b" * 40
+    measurement_revision = "a" * 40
+    assert (
+        manual_campaign.recorded_measurement_source_revision(
+            service,
+            checkout_revision=checkout_revision,
+        )
+        == checkout_revision
+    )
+
+    marker = service.paths.coordination_root / "manual-source.json"
+    marker.parent.mkdir(parents=True, exist_ok=True)
+    marker.write_text(
+        json.dumps(
+            {
+                "schema": manual_campaign.SOURCE_MARKER_SCHEMA,
+                "source_revision": measurement_revision,
+            }
+        ),
+        encoding="utf-8",
+    )
+    assert (
+        manual_campaign.recorded_measurement_source_revision(
+            service,
+            checkout_revision=checkout_revision,
+        )
+        == measurement_revision
+    )
+
+    observed: list[tuple[str, bool]] = []
+
+    def stop_after_source_selection(
+        _service: ReportService,
+        *,
+        source_revision: str,
+        accept_historical_source: bool = False,
+    ) -> object:
+        observed.append((source_revision, accept_historical_source))
+        raise RuntimeError("snapshot stopped after source selection")
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "_capture_lightweight_snapshot",
+        stop_after_source_selection,
+    )
+    source = manual_campaign.ReportSourceIdentity(
+        checkout_revision,
+        "c" * 40,
+        (),
+    )
+    with pytest.raises(RuntimeError, match="snapshot stopped"):
+        manual_campaign._refresh_pdf(
+            _parse("refresh-pdf", "--quiet"),
+            service=service,
+            source=source,
+            palette=manual_campaign.Palette(False),
+        )
+    assert observed == [(measurement_revision, False)]
+
+
+def test_cross_revision_policy_persists_for_inspect_and_refresh(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path, initialize_source_marker=False)
+    source = manual_campaign.ReportSourceIdentity(
+        "a" * 40,
+        "c" * 40,
+        (),
+    )
+
+    manual_campaign.update_source_marker(
+        service,
+        source,
+        continue_across_revisions=True,
+    )
+    policy = manual_campaign.recorded_measurement_source_policy(
+        service,
+        checkout_revision="b" * 40,
+    )
+
+    assert policy.source_revision == source.revision
+    assert policy.continue_across_revisions
+    marker = json.loads(
+        (service.paths.coordination_root / "manual-source.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    assert marker["continue_across_revisions"] is True
+
+    observed: list[tuple[str, bool]] = []
+
+    def stop_after_source_selection(
+        _service: ReportService,
+        *,
+        source_revision: str,
+        accept_historical_source: bool = False,
+    ) -> object:
+        observed.append((source_revision, accept_historical_source))
+        raise RuntimeError("mixed snapshot selected")
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "_capture_lightweight_snapshot",
+        stop_after_source_selection,
+    )
+    with pytest.raises(RuntimeError, match="mixed snapshot selected"):
+        manual_campaign._refresh_pdf(
+            _parse("refresh-pdf", "--quiet"),
+            service=service,
+            source=manual_campaign.ReportSourceIdentity(
+                "b" * 40,
+                "d" * 40,
+                (),
+            ),
+            palette=manual_campaign.Palette(False),
+        )
+    assert observed == [(source.revision, True)]
+
+
+def test_refresh_renders_outcomes_without_serializing_them_as_results(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = _presentation_test_cell()
+    outcome = _presentation_outcome(cell.cell_id, status="error")
+    observed: dict[str, str] = {}
+    original_render = ReportService._render_tables
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "_capture_lightweight_snapshot",
+        lambda *_args, **_kwargs: ({}, {cell.cell_id: outcome}, ()),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_copy_report_sources",
+        lambda _source, destination: destination.mkdir(parents=True),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_stage_copied_profile_identity",
+        lambda *_args, **_kwargs: None,
+    )
+
+    def capture_render(
+        staging_service: ReportService,
+        caches: dict[str, dict[str, object]],
+    ) -> dict[str, str]:
+        observed["render_caches"] = json.dumps(caches, sort_keys=True)
+        tables = original_render(staging_service, caches)
+        observed["tables"] = "\n".join(tables.values())
+        return tables
+
+    def capture_snapshot(
+        _staging_service: ReportService,
+        caches: dict[str, dict[str, object]],
+        tables: dict[str, str],
+    ) -> tuple[Path, ...]:
+        observed["snapshot_caches"] = json.dumps(caches, sort_keys=True)
+        observed["snapshot_tables"] = "\n".join(tables.values())
+        return ()
+
+    monkeypatch.setattr(ReportService, "_render_tables", capture_render)
+    monkeypatch.setattr(ReportService, "_snapshot_files", capture_snapshot)
+    monkeypatch.setattr(manual_campaign, "_compile_pdf", lambda *_a, **_k: 59)
+    monkeypatch.setattr(
+        manual_campaign,
+        "_install_report_snapshot",
+        lambda *_args, **_kwargs: None,
+    )
+
+    assert (
+        manual_campaign._refresh_pdf(
+            _parse("refresh-pdf", "--quiet"),
+            service=service,
+            source=manual_campaign.ReportSourceIdentity(
+                "a" * 40,
+                "b" * 40,
+                (),
+            ),
+            palette=manual_campaign.Palette(False),
+        )
+        == 0
+    )
+
+    failure_kind = "ManualCampaignOutcome:error"
+    status_tex = r"\matrixstatus{ReportRed}{error}"
+    assert failure_kind in observed["render_caches"]
+    assert status_tex in observed["tables"]
+    assert failure_kind not in observed["snapshot_caches"]
+    assert status_tex in observed["snapshot_tables"]
+
+
+def test_malformed_measurement_source_marker_is_not_guessed(tmp_path: Path) -> None:
+    service = _manual_service(tmp_path, initialize_source_marker=False)
+    marker = service.paths.coordination_root / "manual-source.json"
+    marker.parent.mkdir(parents=True, exist_ok=True)
+    marker.write_text(
+        json.dumps(
+            {
+                "schema": manual_campaign.SOURCE_MARKER_SCHEMA,
+                "source_revision": "short",
+            }
+        ),
+        encoding="utf-8",
+    )
+    with pytest.raises(ManualCampaignError, match="source marker is malformed"):
+        manual_campaign.recorded_measurement_source_revision(
+            service,
+            checkout_revision="b" * 40,
+        )
+
+
+def _write_lease(
+    service: ReportService,
+    *,
+    instance_id: str,
+    source_revision: str,
+    updated_at: float,
+    workers: dict[str, dict[str, object]],
+    counters: dict[str, int] | None = None,
+    limits: dict[str, object] | None = None,
+    started_at: float | None = None,
+    schema: object = MANUAL_STATE_SCHEMA,
+) -> None:
+    path = service.paths.coordination_root / "manual-leases" / f"{instance_id}.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if counters is None:
+        active = sum(
+            worker.get("status") in {"queued", "preparing", "running"}
+            for worker in workers.values()
+        )
+        counters = {
+            "selected": len(workers),
+            "recycled": 0,
+            "active": active,
+            "selected_active": active,
+            "dependency_active": 0,
+            "completed": 0,
+            "remaining": len(workers),
+            "static_na": 0,
+            "capped": 0,
+            "failed": 0,
+            "unverified": 0,
+            "dependency_only": 0,
+            "dependency_completed": 0,
+            "dependency_issues": 0,
+        }
+    path.write_text(
+        json.dumps(
+            {
+                "schema": schema,
+                "instance_id": instance_id,
+                "source_revision": source_revision,
+                "started_at": updated_at if started_at is None else started_at,
+                "updated_at": updated_at,
+                "counters": counters,
+                **({} if limits is None else {"limits": limits}),
+                "workers": workers,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+
+def test_peer_leases_merge_by_sha_without_accumulating_or_double_counting(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    state = DashboardState(
+        instance_id="local",
+        selected_ids=("cell-a", "cell-b"),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+        workers={"cell-a": WorkerView("cell-a", status="running")},
+    )
+    lease = LeaseManager(service, state)
+    now = time.time()
+    active_worker = {
+        "cell_id": "cell-a",
+        "status": "running",
+        "phase": "generation",
+        "step": "generating",
+        "progress_task_id": "generation:recurrence:rust-builder",
+        "progress_details": {
+            "current_count": 38_581,
+            "contribution_count": 286_294,
+        },
+        "updated_at": now,
+    }
+    _write_lease(
+        service,
+        instance_id="peer-one",
+        source_revision=state.source_revision,
+        updated_at=now,
+        workers={"cell-a": active_worker},
+    )
+    _write_lease(
+        service,
+        instance_id="peer-two",
+        source_revision=state.source_revision,
+        updated_at=now,
+        workers={"cell-b": active_worker | {"cell_id": "cell-b"}},
+    )
+    _write_lease(
+        service,
+        instance_id="wrong-source",
+        source_revision="b" * 40,
+        updated_at=now,
+        workers={"cell-b": active_worker | {"cell_id": "cell-b"}},
+    )
+    _write_lease(
+        service,
+        instance_id="stale",
+        source_revision=state.source_revision,
+        updated_at=0.0,
+        workers={"cell-b": active_worker | {"cell_id": "cell-b"}},
+    )
+
+    first = lease.dashboard_snapshot()
+    second = lease.dashboard_snapshot()
+
+    expected_keys = {
+        "cell-a",
+        "peer:peer-one:cell-a",
+        "peer:peer-two:cell-b",
+    }
+    assert set(first.workers) == expected_keys
+    assert set(second.workers) == expected_keys
+    peer = first.workers["peer:peer-one:cell-a"]
+    assert peer.progress_task_id == "generation:recurrence:rust-builder"
+    assert peer.progress_details == {
+        "current_count": 38_581,
+        "contribution_count": 286_294,
+    }
+    assert first.counters()["active"] == 1
+    assert first.counters()["remaining"] == 2
+    assert len(first.peer_active) == 2
+    assert "Peer active 2" in render_dashboard_frame(first, width=120, height=36)
+
+    lease.publish()
+    payload = json.loads(lease.path.read_text(encoding="utf-8"))
+    assert payload["counters"]["active"] == 1
+
+
+def test_lease_manager_publishes_effective_invocation_caps(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    state = DashboardState(
+        instance_id="bounded-smoke",
+        selected_ids=("cell-a",),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+        generation_time_limit_seconds=600.0,
+        memory_limit_bytes=30_000_000_000,
+        worker_wall_limit_seconds=1200.0,
+    )
+    lease = LeaseManager(service, state)
+
+    lease.publish()
+
+    payload = json.loads(lease.path.read_text(encoding="utf-8"))
+    assert payload["limits"] == {
+        "generation_time_limit_seconds": 600.0,
+        "memory_limit_bytes": 30_000_000_000,
+        "worker_wall_limit_seconds": 1200.0,
+    }
+
+
+def test_preflight_completion_removes_only_matching_transient_worker(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+    )
+    state = DashboardState(
+        instance_id="preflight-lifecycle",
+        selected_ids=(cell.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+    lease = LeaseManager(service, state)
+    attempt_id = "prepared-model-builtin_sm"
+
+    lease.observe({"event": "started", "cell_id": cell.cell_id})
+    lease.observe(
+        {
+            "event": "worker",
+            "cell_id": cell.cell_id,
+            "attempt_id": attempt_id,
+        }
+    )
+
+    assert state.counters()["active"] == 1
+    lease.observe(
+        {
+            "event": "preflight-finished",
+            "cell_id": cell.cell_id,
+            "attempt_id": "different-attempt",
+        }
+    )
+    assert cell.cell_id in state.workers
+
+    lease.observe(
+        {
+            "event": "preflight-finished",
+            "cell_id": cell.cell_id,
+            "attempt_id": attempt_id,
+        }
+    )
+
+    assert cell.cell_id not in state.workers
+    assert state.completed_ids == set()
+    assert state.recycled_ids == set()
+    assert state.failed_ids == set()
+    assert state.counters()["active"] == 0
+    assert state.counters()["completed"] == 0
+    assert state.counters()["remaining"] == 1
+    payload = json.loads(lease.path.read_text(encoding="utf-8"))
+    assert payload["workers"] == {}
+
+
+def test_scheduler_state_is_visible_and_persisted_without_creating_worker_rows(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    state = DashboardState(
+        instance_id="scheduler-state",
+        selected_ids=("cell-a", "cell-b", "cell-c"),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+    lease = LeaseManager(service, state)
+
+    lease.observe(
+        {
+            "event": "scheduler-state",
+            "ready": 1,
+            "waiting_dependency": 1,
+            "waiting_coordination_lock": 1,
+        }
+    )
+
+    assert state.workers == {}
+    assert (state.ready_count, state.waiting_dependency_count) == (1, 1)
+    assert state.waiting_coordination_lock_count == 1
+    frame = render_dashboard_frame(state, width=120, height=36)
+    assert "Ready 1" in frame
+    assert "Waiting dependency 1" in frame
+    assert "Waiting coordination lock 1" in frame
+    payload = json.loads(lease.path.read_text(encoding="utf-8"))
+    assert payload["scheduler"] == {
+        "ready": 1,
+        "waiting_dependency": 1,
+        "waiting_coordination_lock": 1,
+    }
+
+
+def test_blocked_dependency_dashboard_retains_exact_prerequisite_ids(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell_id = "matrix-compiled-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    prerequisite = "matrix-recurrence-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    state = DashboardState(
+        instance_id="blocked-dependency",
+        selected_ids=(cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+    lease = LeaseManager(service, state)
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": cell_id,
+            "status": "blocked_dependency",
+            "detail": "blocked by dependency",
+            "prerequisite_cell_ids": (prerequisite,),
+        }
+    )
+
+    worker = state.workers[cell_id]
+    assert worker.blocked_prerequisite_ids == (prerequisite,)
+    assert prerequisite in render_dashboard_frame(state, width=160, height=48)
+    payload = json.loads(lease.path.read_text(encoding="utf-8"))
+    assert payload["workers"][cell_id]["blocked_prerequisite_ids"] == [prerequisite]
+
+
+def test_active_lease_recipe_uses_effective_invocation_settings(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+    )
+    defaults = ReproductionSettings()
+    assert (
+        defaults.cores,
+        defaults.target_runtime,
+        defaults.batch_size,
+        defaults.warmups,
+        defaults.minimum_samples,
+    ) == (1, 5.0, 128, 2, 5)
+    state = DashboardState(
+        instance_id="recipe-settings",
+        selected_ids=(cell.cell_id,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+        reproduction_settings=ReproductionSettings(
+            cores=3,
+            target_runtime=0.5,
+            batch_size=16,
+            warmups=1,
+            minimum_samples=7,
+        ),
+    )
+    lease = LeaseManager(service, state)
+
+    lease.observe({"event": "started", "cell_id": cell.cell_id})
+
+    worker = lease.dashboard_snapshot().workers[cell.cell_id]
+    assert worker.reproduce_generate is not None
+    assert "--workers 3" in worker.reproduce_generate
+    assert "--cores 3" in worker.reproduce_generate
+    assert "--batch-size 16" in worker.reproduce_generate
+    assert worker.reproduce_profile is not None
+    assert "--target-runtime 0.5" in worker.reproduce_profile
+    assert "--batch-size 16" in worker.reproduce_profile
+    assert "--warmup-runs 1" in worker.reproduce_profile
+    assert "--minimum-samples 7" in worker.reproduce_profile
+    payload = json.loads(lease.path.read_text(encoding="utf-8"))
+    assert "reproduction_settings" not in payload
+    assert (
+        payload["workers"][cell.cell_id]["reproduce_profile"]
+        == worker.reproduce_profile
+    )
+
+
+def test_live_dashboard_snapshot_selects_instance_and_shows_same_source_peers(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    now = 50_000.0
+    source_revision = "a" * 40
+    counters = {
+        "selected": 9,
+        "recycled": 3,
+        "active": 2,
+        "selected_active": 1,
+        "dependency_active": 1,
+        "completed": 1,
+        "remaining": 2,
+        "static_na": 1,
+        "capped": 1,
+        "failed": 0,
+        "unverified": 0,
+        "dependency_only": 2,
+        "dependency_completed": 1,
+        "dependency_issues": 0,
+    }
+    _write_lease(
+        service,
+        instance_id="primary-7f91c2",
+        source_revision=source_revision,
+        started_at=now - 65.0,
+        updated_at=now - 1.0,
+        counters=counters,
+        workers={
+            "matrix-primary": {
+                "cell_id": "matrix-primary",
+                "status": "running",
+                "phase": "profiling",
+                "step": "sample 4/8",
+                "pid": 4100,
+                "member_pids": [4100, 4101],
+                "wall_seconds": 64.0,
+                "cpu_seconds": 91.0,
+                "current_rss_bytes": 2_500_000_000,
+                "peak_rss_bytes": 3_000_000_000,
+                "progress_completed": 4,
+                "progress_total": 8,
+                "events": ["profiling: sample 4/8"],
+            }
+        },
+    )
+    _write_lease(
+        service,
+        instance_id="peer-81ab",
+        source_revision=source_revision,
+        updated_at=now - 2.0,
+        workers={
+            "scalar-peer": {
+                "cell_id": "scalar-peer",
+                "status": "running",
+                "phase": "generation",
+                "step": "gravity model generation",
+                "pid": 4200,
+            },
+            "finished-peer": {
+                "cell_id": "finished-peer",
+                "status": "ok",
+                "phase": "completed",
+                "step": "published",
+            },
+        },
+    )
+    _write_lease(
+        service,
+        instance_id="foreign-newer",
+        source_revision="b" * 40,
+        updated_at=now - 0.5,
+        workers={
+            "foreign": {
+                "cell_id": "foreign",
+                "status": "running",
+            }
+        },
+    )
+
+    state = _live_dashboard_snapshot(
+        service.paths.coordination_root,
+        instance="primary-7",
+        stale_after_seconds=15.0,
+        now=now,
+    )
+
+    assert state.live_snapshot
+    assert state.instance_id == "primary-7f91c2"
+    assert state.source_revision == source_revision
+    assert state.started_at == now - 65.0
+    assert state.lease_updated_at == now - 1.0
+    assert state.counters() == counters
+    assert set(state.workers) == {
+        "matrix-primary",
+        "peer:peer-81ab:scalar-peer",
+    }
+    peer = state.workers["peer:peer-81ab:scalar-peer"]
+    assert peer.peer_instance == "peer-81ab"
+    frame = render_dashboard_frame(state, width=160, height=48)
+    assert "LIVE pyAmpliCol profiling campaign" in frame
+    assert "primary-7f91" in frame
+    assert "Selected 9" in frame
+    assert "Recycled 3" in frame
+    assert "Remaining 2" in frame
+    assert "matrix-primary" in frame
+    assert "scalar-peer" in frame
+
+
+@pytest.mark.parametrize(("width", "height"), ((80, 24), (120, 36), (160, 48)))
+def test_live_dashboard_snapshot_renders_effective_invocation_caps(
+    tmp_path: Path,
+    width: int,
+    height: int,
+) -> None:
+    service = _manual_service(tmp_path)
+    now = 60_000.0
+    _write_lease(
+        service,
+        instance_id="bounded-smoke",
+        source_revision="b" * 40,
+        updated_at=now - 1.0,
+        limits={
+            "generation_time_limit_seconds": 600.0,
+            "memory_limit_bytes": 30_000_000_000,
+            "worker_wall_limit_seconds": 1200.0,
+        },
+        workers={
+            "scalar-gravity": {
+                "cell_id": "scalar-gravity",
+                "status": "running",
+                "phase": "generation",
+                "step": "building scalar-gravity evaluator",
+            }
+        },
+    )
+
+    state = _live_dashboard_snapshot(
+        service.paths.coordination_root,
+        instance="bounded",
+        stale_after_seconds=15.0,
+        now=now,
+    )
+
+    assert state.generation_time_limit_seconds == 600.0
+    assert state.memory_limit_bytes == 30_000_000_000
+    assert state.worker_wall_limit_seconds == 1200.0
+    frame = render_dashboard_frame(state, width=width, height=height)
+    assert "Caps Generation 00:10:00" in frame
+    assert "RAM 30.00 GB" in frame
+    assert "Total wall 00:20:00" in frame
+
+
+def test_live_snapshot_command_is_read_only_and_lease_only(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    docs = tmp_path / "docs/performance_reports/macbook_M3_manual"
+    docs.mkdir(parents=True)
+    service = ReportService(manual_campaign._campaign_report_paths(tmp_path, docs))
+    now = time.time()
+    _write_lease(
+        service,
+        instance_id="lease-only-instance",
+        source_revision="c" * 40,
+        started_at=now - 3.0,
+        updated_at=now,
+        counters={
+            "selected": 3,
+            "recycled": 1,
+            "active": 1,
+            "selected_active": 1,
+            "dependency_active": 0,
+            "completed": 0,
+            "remaining": 2,
+            "static_na": 0,
+            "capped": 0,
+            "failed": 0,
+            "unverified": 0,
+            "dependency_only": 1,
+            "dependency_completed": 0,
+            "dependency_issues": 0,
+        },
+        workers={
+            "gravity-cell": {
+                "cell_id": "gravity-cell",
+                "status": "running",
+                "phase": "generation",
+                "step": "building scalar-gravity evaluator",
+                "pid": 4300,
+            }
+        },
+    )
+    lease_files = tuple(
+        sorted((service.paths.coordination_root / "manual-leases").glob("*.json"))
+    )
+    before = {path: path.read_bytes() for path in lease_files}
+
+    def forbidden(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("live snapshot escaped the lease-only read path")
+
+    monkeypatch.setattr(manual_campaign, "_repo_head", forbidden)
+    monkeypatch.setattr(manual_campaign, "lightweight_source_identity", forbidden)
+    monkeypatch.setattr(manual_campaign, "lightweight_currents", forbidden)
+    monkeypatch.setattr(manual_campaign, "_capture_lightweight_snapshot", forbidden)
+
+    result = campaign_main(
+        (
+            "dashboard-snapshot",
+            "--live",
+            "--instance",
+            "lease-only",
+            "--width",
+            "120",
+            "--height",
+            "36",
+        ),
+        repo_root=tmp_path,
+        docs_dir=docs,
+    )
+
+    assert result == 0
+    output = capsys.readouterr().out
+    assert "LIVE pyAmpliCol profiling campaign" in output
+    assert "gravity-cell" in output
+    assert {path: path.read_bytes() for path in lease_files} == before
+
+
+def test_live_snapshot_rejects_stale_malformed_and_ambiguous_leases(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    now = 70_000.0
+    worker = {"cell": {"cell_id": "cell", "status": "running"}}
+    _write_lease(
+        service,
+        instance_id="stale",
+        source_revision="a" * 40,
+        updated_at=now - 20.0,
+        workers=worker,
+    )
+    _write_lease(
+        service,
+        instance_id="wrong-schema",
+        source_revision="a" * 40,
+        updated_at=now,
+        workers=worker,
+        schema="unknown-state-v0",
+    )
+    with pytest.raises(ManualCampaignError, match="no active manual-campaign lease"):
+        _live_dashboard_snapshot(
+            service.paths.coordination_root,
+            instance=None,
+            stale_after_seconds=15.0,
+            now=now,
+        )
+
+    for suffix in ("one", "two"):
+        _write_lease(
+            service,
+            instance_id=f"shared-{suffix}",
+            source_revision="a" * 40,
+            updated_at=now,
+            workers=worker,
+        )
+    with pytest.raises(ManualCampaignError, match="ambiguous"):
+        _live_dashboard_snapshot(
+            service.paths.coordination_root,
+            instance="shared-",
+            stale_after_seconds=15.0,
+            now=now,
+        )
+    with pytest.raises(ManualCampaignError, match="positive finite"):
+        _live_dashboard_snapshot(
+            service.paths.coordination_root,
+            instance=None,
+            stale_after_seconds=0.0,
+            now=now,
+        )
+
+
+def test_dashboard_snapshot_help_explains_synthetic_and_live_modes(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    with pytest.raises(SystemExit) as exit_info:
+        build_parser().parse_args(("dashboard-snapshot", "--help"))
+    assert exit_info.value.code == 0
+    output = capsys.readouterr().out
+    for fragment in (
+        "deterministic synthetic fixture",
+        "--live",
+        "--instance",
+        "unique prefix",
+        "--stale-after",
+        "does not inspect results, artifacts, source identity, or Git",
+        "never guessed or double-counted",
+    ):
+        assert fragment in output
+
+
+def test_dashboard_snapshot_default_does_not_read_live_leases(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    def forbidden(*_args: object, **_kwargs: object) -> DashboardState:
+        raise AssertionError("deterministic snapshot read a live lease")
+
+    monkeypatch.setattr(manual_campaign, "_live_dashboard_snapshot", forbidden)
+    docs_dir = tmp_path / "campaign"
+    docs_dir.mkdir()
+    result = campaign_main(
+        ("dashboard-snapshot", "--width", "80", "--height", "24"),
+        repo_root=ROOT,
+        docs_dir=docs_dir,
+    )
+    assert result == 0
+    output = capsys.readouterr().out
+    assert "pyAmpliCol profiling campaign" in output
+    assert "LIVE Manual" not in output
+
+
+def test_installed_run_disables_dashboard_when_optional_bindings_are_missing(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        manual_campaign,
+        "_missing_ratatui_bindings",
+        lambda: ("ratatui", "ratatui_py"),
+    )
+    arguments = _parse("run", "--dry-run")
+
+    changed = manual_campaign._configure_dashboard_capability(
+        arguments,
+        installed=True,
+    )
+
+    assert changed is True
+    assert arguments.no_dashboard is True
+
+
+def test_installed_campaign_uses_copied_local_amplicol_and_explicit_override(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    docs_dir = tmp_path / "campaign"
+    docs_dir.mkdir()
+    configured = (tmp_path / "configured-amplicol").resolve()
+    override = (tmp_path / "override-amplicol").resolve()
+    (docs_dir / ".pyamplicol-original-amplicol").write_text(
+        f"{configured}\n",
+        encoding="utf-8",
+    )
+    observed: list[Path] = []
+
+    def validate(path: Path) -> tuple[Path, str]:
+        observed.append(path)
+        return path, "a" * 40
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "_validated_original_amplicol_checkout",
+        validate,
+    )
+
+    legacy = next(
+        candidate
+        for candidate in REPORT_CATALOG.measurement_cells()
+        if candidate.measurement.execution_mode is ExecutionMode.AMPLICOL
+    )
+    planned = (manual_campaign.PlannedCell(legacy, False, None, 0),)
+    arguments = _parse("run")
+    manual_campaign._bind_original_amplicol_if_required(
+        arguments,
+        planned,
+        installed=True,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+    assert arguments.original_amplicol == configured
+    assert arguments.original_amplicol_revision == "a" * 40
+
+    arguments.original_amplicol = override
+    manual_campaign._bind_original_amplicol_if_required(
+        arguments,
+        planned,
+        installed=True,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+    assert arguments.original_amplicol == override
+    assert arguments.original_amplicol_revision == "a" * 40
+    assert observed == [configured, override]
+
+
+def test_installed_campaign_resolves_saved_madgraph_and_explicit_override(
+    tmp_path: Path,
+) -> None:
+    docs_dir = tmp_path / "campaign"
+    docs_dir.mkdir()
+    configured = tmp_path / "configured-madgraph"
+    override = tmp_path / "override-madgraph"
+    for installation in (configured, override):
+        executable = installation / "bin/mg5_aMC"
+        executable.parent.mkdir(parents=True)
+        executable.write_text("#!/bin/sh\n", encoding="ascii")
+        executable.chmod(0o755)
+    (docs_dir / ".pyamplicol-madgraph").write_text(
+        f"{configured.resolve()}\n",
+        encoding="utf-8",
+    )
+
+    arguments = _parse("run")
+    assert (
+        manual_campaign._resolve_madgraph(
+            arguments,
+            installed=True,
+            docs_dir=docs_dir,
+        )
+        == configured.resolve()
+    )
+    assert (
+        manual_campaign._resolve_madgraph(
+            arguments,
+            installed=False,
+            docs_dir=docs_dir,
+        )
+        is None
+    )
+
+    arguments.madgraph = override
+    assert (
+        manual_campaign._resolve_madgraph(
+            arguments,
+            installed=True,
+            docs_dir=docs_dir,
+        )
+        == override.resolve()
+    )
+
+
+def test_madgraph_validation_requires_regular_executable_mg5(
+    tmp_path: Path,
+) -> None:
+    installation = tmp_path / "madgraph"
+    executable = installation / "bin/mg5_aMC"
+    executable.parent.mkdir(parents=True)
+
+    with pytest.raises(ManualCampaignError, match="regular executable bin/mg5_aMC"):
+        manual_campaign._validated_madgraph_installation(installation)
+
+    executable.write_text("#!/bin/sh\n", encoding="ascii")
+    executable.chmod(0o644)
+    with pytest.raises(ManualCampaignError, match="regular executable bin/mg5_aMC"):
+        manual_campaign._validated_madgraph_installation(installation)
+
+    executable.chmod(0o755)
+    assert (
+        manual_campaign._validated_madgraph_installation(installation)
+        == installation.resolve()
+    )
+
+    executable.unlink()
+    target = tmp_path / "mg5_aMC-target"
+    target.write_text("#!/bin/sh\n", encoding="ascii")
+    target.chmod(0o755)
+    executable.symlink_to(target)
+    with pytest.raises(ManualCampaignError, match="regular executable bin/mg5_aMC"):
+        manual_campaign._validated_madgraph_installation(installation)
+
+
+def test_saved_madgraph_configuration_is_one_absolute_regular_line(
+    tmp_path: Path,
+) -> None:
+    docs_dir = tmp_path / "campaign"
+    docs_dir.mkdir()
+    config = docs_dir / ".pyamplicol-madgraph"
+    config.write_text("relative/path\n", encoding="utf-8")
+    with pytest.raises(ManualCampaignError, match="configuration is invalid"):
+        manual_campaign._configured_madgraph(docs_dir)
+
+    config.unlink()
+    target = tmp_path / "madgraph-config"
+    target.write_text(f"{tmp_path.resolve()}\n", encoding="utf-8")
+    config.symlink_to(target)
+    with pytest.raises(ManualCampaignError, match="not a regular file"):
+        manual_campaign._configured_madgraph(docs_dir)
+
+
+def test_original_amplicol_planning_availability_is_cheap_and_explicit(
+    tmp_path: Path,
+) -> None:
+    docs_dir = tmp_path / "campaign"
+    docs_dir.mkdir()
+    arguments = _parse("run", "--generation-engine", "compiled")
+
+    assert not manual_campaign._original_amplicol_available_for_planning(
+        arguments,
+        installed=True,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+
+    configured = tmp_path / "configured-amplicol"
+    configured.mkdir()
+    (docs_dir / ".pyamplicol-original-amplicol").write_text(
+        f"{configured.resolve()}\n",
+        encoding="utf-8",
+    )
+    assert manual_campaign._original_amplicol_available_for_planning(
+        arguments,
+        installed=True,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+
+    configured.rmdir()
+    assert not manual_campaign._original_amplicol_available_for_planning(
+        arguments,
+        installed=True,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+
+    (docs_dir / ".pyamplicol-original-amplicol").write_text(
+        "not-an-absolute-path\n",
+        encoding="utf-8",
+    )
+    assert not manual_campaign._original_amplicol_available_for_planning(
+        arguments,
+        installed=True,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+    arguments.no_dependencies_added = True
+    assert not manual_campaign._original_amplicol_available_for_planning(
+        arguments,
+        installed=True,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+    arguments.no_dependencies_added = False
+
+    contributor = tmp_path / "dependencies/checkouts/legacy-amplicol"
+    contributor.mkdir(parents=True)
+    assert manual_campaign._original_amplicol_available_for_planning(
+        arguments,
+        installed=False,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+
+    arguments.original_amplicol = tmp_path / "explicit-amplicol"
+    assert manual_campaign._original_amplicol_available_for_planning(
+        arguments,
+        installed=True,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+
+
+@pytest.mark.parametrize(
+    "cell_id",
+    (
+        "matrix-recurrence-builtin-sm-lc-n4-dd-ttzh-jets-all-flow",
+        "matrix-compiled-builtin-sm-lc-n4-dd-ttzh-jets-selected-flow",
+    ),
+)
+def test_pyamplicol_only_opt_out_plan_and_binding_need_no_original_checkout(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    cell_id: str,
+) -> None:
+    docs_dir = tmp_path / "campaign"
+    docs_dir.mkdir()
+    service = _manual_service(tmp_path)
+    selected = REPORT_CATALOG.cell(cell_id)
+    planned = manual_campaign.plan_campaign(
+        (selected,),
+        store=service.store,
+        settings=manual_campaign.CampaignSettings(add_optional_dependencies=False),
+    )
+
+    assert planned
+    assert all(
+        item.cell.measurement.execution_mode is not ExecutionMode.AMPLICOL
+        for item in planned
+    )
+    assert any(
+        item.optional_baseline_cell_id is not None
+        or item.optional_comparison_peer_ids
+        for item in planned
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_validated_original_amplicol_checkout",
+        lambda _path: pytest.fail("pyAmpliCol-only plan validated legacy checkout"),
+    )
+    arguments = _parse(
+        "run",
+        "--generation-engine",
+        selected.measurement.execution_mode.value,
+        "--no-dependencies-added",
+    )
+
+    manual_campaign._bind_original_amplicol_if_required(
+        arguments,
+        planned,
+        installed=True,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+
+    assert arguments.original_amplicol is None
+    assert arguments.original_amplicol_revision is None
+
+
+def test_direct_or_wildcard_amplicol_selection_still_requires_checkout(
+    tmp_path: Path,
+) -> None:
+    docs_dir = tmp_path / "campaign"
+    docs_dir.mkdir()
+    legacy = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        and REPORT_CATALOG.static_na_reason(cell) is None
+    )
+    planned = (manual_campaign.PlannedCell(legacy, False, None, 0),)
+
+    with pytest.raises(
+        ManualCampaignError,
+        match="selection requires original AmpliCol",
+    ):
+        manual_campaign._bind_original_amplicol_if_required(
+            _parse("run"),
+            planned,
+            installed=True,
+            root=tmp_path,
+            docs_dir=docs_dir,
+        )
+    _selection, wildcard_cells = selection_from_arguments(_parse("run", "--dry-run"))
+    assert any(
+        cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        for cell in wildcard_cells
+    )
+
+
+def test_saved_local_amplicol_is_not_validated_for_pyamplicol_only_work(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    docs_dir = tmp_path / "campaign"
+    docs_dir.mkdir()
+    missing = (tmp_path / "missing-amplicol").resolve()
+    (docs_dir / ".pyamplicol-original-amplicol").write_text(
+        f"{missing}\n",
+        encoding="utf-8",
+    )
+    cell = next(
+        candidate
+        for candidate in REPORT_CATALOG.measurement_cells()
+        if candidate.measurement.execution_mode is ExecutionMode.RECURRENCE
+    )
+    planned = (manual_campaign.PlannedCell(cell, False, None, 1),)
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "_validated_original_amplicol_checkout",
+        lambda _path: pytest.fail("unused legacy checkout was validated"),
+    )
+    arguments = _parse("run")
+
+    manual_campaign._bind_original_amplicol_if_required(
+        arguments,
+        planned,
+        installed=True,
+        root=tmp_path,
+        docs_dir=docs_dir,
+    )
+
+    assert arguments.original_amplicol is None
+    assert arguments.original_amplicol_revision is None
+
+
+def test_source_run_does_not_probe_or_change_dashboard_capability(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def forbidden() -> tuple[str, ...]:
+        raise AssertionError("source mode probed installed-wheel bindings")
+
+    monkeypatch.setattr(manual_campaign, "_missing_ratatui_bindings", forbidden)
+    arguments = _parse("run", "--dry-run")
+
+    changed = manual_campaign._configure_dashboard_capability(
+        arguments,
+        installed=False,
+    )
+
+    assert changed is False
+    assert arguments.no_dashboard is False
+
+
+def test_installed_dashboard_snapshot_explains_optional_bindings(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    monkeypatch.setattr(
+        manual_campaign,
+        "_missing_ratatui_bindings",
+        lambda: ("ratatui_py",),
+    )
+    (tmp_path / "campaign").mkdir()
+
+    result = campaign_main(
+        ("dashboard-snapshot", "--no-color"),
+        repo_root=tmp_path,
+        docs_dir=tmp_path / "campaign",
+        installed=True,
+    )
+
+    assert result == 2
+    error = capsys.readouterr().err
+    assert "contributor feature" in error
+    assert "ratatui_py" in error
+    assert "run --no-dashboard" in error
+    assert "just dev-install" in error
+
+
+def test_finished_reuse_stays_recycled_while_work_and_caps_complete(
+    tmp_path: Path,
+) -> None:
+    service = _manual_service(tmp_path)
+    state = DashboardState(
+        instance_id="local",
+        selected_ids=("reused", "skipped", "fresh", "capped"),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+    lease = LeaseManager(service, state)
+
+    for cell_id, status in (
+        ("reused", "reused"),
+        ("skipped", "skipped-current"),
+        ("fresh", "ok"),
+        ("capped", "generation_limit"),
+    ):
+        lease.observe(
+            {
+                "event": "finished",
+                "cell_id": cell_id,
+                "status": status,
+                "detail": status,
+            }
+        )
+
+    assert state.completed_ids == {"fresh"}
+    assert state.capped_ids == {"capped"}
+    assert state.workers["reused"].status == "recycled"
+    assert state.workers["reused"].recycled
+    assert state.workers["skipped"].status == "recycled"
+    assert state.workers["skipped"].recycled
+    assert state.counters() == {
+        "selected": 4,
+        "recycled": 2,
+        "active": 0,
+        "selected_active": 0,
+        "dependency_active": 0,
+        "completed": 1,
+        "remaining": 0,
+        "static_na": 0,
+        "capped": 1,
+        "failed": 0,
+        "unverified": 0,
+        "dependency_only": 0,
+        "dependency_completed": 0,
+        "dependency_issues": 0,
+    }
+
+
+def test_active_counter_includes_dependency_work_without_consuming_remaining() -> None:
+    state = DashboardState(
+        instance_id="dependency-active",
+        selected_ids=("direct-cell",),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        dependency_ids={"dependency-cell"},
+        workers={
+            "dependency-cell": WorkerView(
+                "dependency-cell",
+                dependency=True,
+                status="running",
+            )
+        },
+    )
+
+    counters = state.counters()
+
+    assert counters["active"] == 1
+    assert counters["selected_active"] == 0
+    assert counters["dependency_active"] == 1
+    assert counters["remaining"] == 1
+    assert counters["dependency_only"] == 1
+    assert "Workers active 1" in render_dashboard_frame(state, width=120, height=36)
+
+
+def test_replanned_selected_dependency_remains_in_selected_counter_scope() -> None:
+    state = DashboardState(
+        instance_id="selected-replanned-dependency",
+        selected_ids=("selected-cell",),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        dependency_ids={"selected-cell"},
+        workers={
+            "selected-cell": WorkerView(
+                "selected-cell",
+                dependency=True,
+                status="running",
+            )
+        },
+    )
+
+    active = state.counters()
+
+    assert active["active"] == 1
+    assert active["selected_active"] == 1
+    assert active["dependency_active"] == 0
+    assert active["dependency_only"] == 0
+    assert active["remaining"] == 1
+
+    state._reduce_finished("selected-cell", "ok")
+    finished = state.counters()
+
+    assert finished["completed"] == 1
+    assert finished["remaining"] == 0
+    assert finished["dependency_completed"] == 0
+    assert finished["dependency_issues"] == 0
+
+
+def test_worker_status_counters_include_dependency_only_rows_and_lease(
+    tmp_path: Path,
+) -> None:
+    dependency_ids = {
+        "dependency-ok",
+        "dependency-cap",
+        "dependency-error",
+        "dependency-unverified",
+        "dependency-running",
+    }
+    state = DashboardState(
+        instance_id="dependency-status-counters",
+        selected_ids=("direct-cell",),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        dependency_ids=dependency_ids,
+        source_revision="a" * 40,
+    )
+    lease = LeaseManager(_manual_service(tmp_path), state)
+    for cell_id, status in (
+        ("dependency-ok", "ok"),
+        ("dependency-cap", "memory_limit"),
+        ("dependency-error", "error"),
+        ("dependency-unverified", ResultStatus.UNVERIFIED.value),
+    ):
+        lease.observe({"event": "started", "cell_id": cell_id, "dependency": True})
+        lease.observe(
+            {
+                "event": "finished",
+                "cell_id": cell_id,
+                "status": status,
+                "detail": status,
+            }
+        )
+    lease.observe(
+        {
+            "event": "started",
+            "cell_id": "dependency-running",
+            "dependency": True,
+        }
+    )
+
+    counters = state.counters()
+
+    assert counters == {
+        "selected": 1,
+        "recycled": 0,
+        "active": 1,
+        "selected_active": 0,
+        "dependency_active": 1,
+        "completed": 0,
+        "remaining": 1,
+        "static_na": 0,
+        "capped": 0,
+        "failed": 0,
+        "unverified": 0,
+        "dependency_only": 5,
+        "dependency_completed": 1,
+        "dependency_issues": 3,
+    }
+    frame = render_dashboard_frame(state, width=160, height=40)
+    assert "Workers active 1" in frame
+    assert "selected 0" in frame
+    assert "dependency 1" in frame
+    assert "Errors 0" in frame
+    assert "Unverified 0" in frame
+    assert "Completed 0" in frame
+    assert "Capped 0" in frame
+    assert "Dependency done 1" in frame
+    assert "issues 3" in frame
+    payload = json.loads(lease.path.read_text(encoding="utf-8"))
+    assert payload["counters"] == counters
+
+    lease.observe({"event": "started", "cell_id": "direct-cell"})
+    active = state.counters()
+    assert active["selected_active"] == 1
+    assert active["remaining"] == 1
+    lease.observe({"event": "finished", "cell_id": "direct-cell", "status": "ok"})
+    finished = state.counters()
+    assert finished["completed"] == 1
+    assert finished["remaining"] == 0
+    assert (
+        sum(
+            finished[key]
+            for key in (
+                "recycled",
+            "completed",
+            "capped",
+            "failed",
+            "unverified",
+                "static_na",
+                "remaining",
+            )
+        )
+        == finished["selected"]
+    )
+    assert finished["dependency_completed"] == 1
+    assert finished["dependency_issues"] == 3
+
+
+def test_dashboard_reducer_replaces_prior_outcomes_across_retries(
+    tmp_path: Path,
+) -> None:
+    state = DashboardState(
+        instance_id="retry-transitions",
+        selected_ids=("retry-error", "retry-cap", "retry-recycled"),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+    lease = LeaseManager(_manual_service(tmp_path), state)
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": "retry-error",
+            "status": "error",
+        }
+    )
+    assert state.counters()["failed"] == 1
+    assert state.counters()["remaining"] == 2
+    lease.observe({"event": "started", "cell_id": "retry-error"})
+    assert state.failed_ids == set()
+    assert state.counters()["active"] == 1
+    lease.observe({"event": "finished", "cell_id": "retry-error", "status": "ok"})
+    assert state.completed_ids == {"retry-error"}
+    assert state.failed_ids == set()
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": "retry-cap",
+            "status": "memory_limit",
+        }
+    )
+    assert state.capped_ids == {"retry-cap"}
+    lease.observe({"event": "started", "cell_id": "retry-cap"})
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": "retry-cap",
+            "status": ResultStatus.UNVERIFIED.value,
+        }
+    )
+    assert state.capped_ids == set()
+    assert state.completed_ids == {"retry-error"}
+    assert state.unverified_ids == {"retry-cap"}
+
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": "retry-recycled",
+            "status": "reused",
+        }
+    )
+    assert state.recycled_ids == {"retry-recycled"}
+    lease.observe({"event": "started", "cell_id": "retry-recycled"})
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": "retry-recycled",
+            "status": "error",
+        }
+    )
+    assert state.recycled_ids == set()
+    assert state.failed_ids == {"retry-recycled"}
+    assert state.counters() == {
+        "selected": 3,
+        "recycled": 0,
+        "active": 0,
+        "selected_active": 0,
+        "dependency_active": 0,
+        "completed": 1,
+        "remaining": 0,
+        "static_na": 0,
+        "capped": 0,
+        "failed": 1,
+        "unverified": 1,
+        "dependency_only": 0,
+        "dependency_completed": 0,
+        "dependency_issues": 0,
+    }
+    payload = json.loads(lease.path.read_text(encoding="utf-8"))
+    assert payload["counters"] == state.counters()
+
+
+def test_cancelled_cell_remains_pending_in_dashboard_progress(tmp_path: Path) -> None:
+    state = DashboardState(
+        instance_id="cancelled-transition",
+        selected_ids=("cancelled-cell",),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+    lease = LeaseManager(_manual_service(tmp_path), state)
+    lease.observe({"event": "started", "cell_id": "cancelled-cell"})
+    lease.observe(
+        {
+            "event": "finished",
+            "cell_id": "cancelled-cell",
+            "status": "cancelled",
+        }
+    )
+
+    assert state.terminal_outcomes == {}
+    assert state.counters()["active"] == 0
+    assert state.counters()["remaining"] == 1
+
+
+def test_late_resource_event_cannot_reactivate_terminal_worker(tmp_path: Path) -> None:
+    state = DashboardState(
+        instance_id="late-resource",
+        selected_ids=("cell",),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+    lease = LeaseManager(_manual_service(tmp_path), state)
+    lease.observe({"event": "started", "cell_id": "cell"})
+    lease.observe(
+        {
+            "event": "worker",
+            "cell_id": "cell",
+            "attempt_id": "new-attempt",
+        }
+    )
+    lease.observe(
+        {
+            "event": "resource",
+            "cell_id": "cell",
+            "attempt_id": "old-attempt",
+            "wall_seconds": 50.0,
+        }
+    )
+    assert state.workers["cell"].wall_seconds == 0.0
+    lease.observe(
+        {
+            "event": "resource",
+            "cell_id": "cell",
+            "attempt_id": "new-attempt",
+            "wall_seconds": 2.0,
+        }
+    )
+    lease.observe({"event": "finished", "cell_id": "cell", "status": "ok"})
+    lease.observe(
+        {
+            "event": "resource",
+            "cell_id": "cell",
+            "attempt_id": "new-attempt",
+            "wall_seconds": 99.0,
+        }
+    )
+
+    assert state.workers["cell"].status == "ok"
+    assert state.workers["cell"].wall_seconds == 2.0
+    assert state.counters()["active"] == 0
+    assert state.counters()["completed"] == 1
+
+
+@pytest.mark.parametrize(
+    "status",
+    ("worker_timeout", "profiling_timeout", "validation_timeout"),
+)
+def test_manual_stage_timeouts_are_addressed_caps_in_dashboard_state(
+    tmp_path: Path,
+    status: str,
+) -> None:
+    service = _manual_service(tmp_path)
+    state = DashboardState(
+        instance_id="local",
+        selected_ids=(status,),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision="a" * 40,
+    )
+    LeaseManager(service, state).observe(
+        {
+            "event": "finished",
+            "cell_id": status,
+            "status": status,
+            "detail": status,
+        }
+    )
+
+    assert state.completed_ids == set()
+    assert state.capped_ids == {status}
+    assert state.failed_ids == set()
+    assert state.counters()["remaining"] == 0
+
+
+def test_n8_all_flow_recurrence_is_runnable_but_native_n7_stays_static_na() -> None:
+    recurrence = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.workload is Workload.ALL_FLOW
+        and cell.n_final == 8
+    )
+    assert _manual_static_na_reason(recurrence) is None
+
+    native = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id.startswith("z_")
+        and cell.variant in {"cpp_o3", "asm_o3"}
+        and cell.n_final == 7
+    )
+    assert _manual_static_na_reason(native) == ("native-backend-generation-cap-n6-v1")
+
+
+def _write_minimal_index(repo: Path, relative: str) -> None:
+    path = repo / relative
+    observed = path.stat()
+    encoded = relative.encode()
+    fields = struct.pack(
+        "!10I20sH",
+        int(observed.st_ctime_ns // 1_000_000_000),
+        int(observed.st_ctime_ns % 1_000_000_000),
+        int(observed.st_mtime_ns // 1_000_000_000),
+        int(observed.st_mtime_ns % 1_000_000_000),
+        int(observed.st_dev),
+        int(observed.st_ino),
+        int(observed.st_mode),
+        int(observed.st_uid),
+        int(observed.st_gid),
+        int(observed.st_size),
+        b"\0" * 20,
+        len(encoded),
+    )
+    entry = fields + encoded + b"\0"
+    entry += b"\0" * ((8 - len(entry) % 8) % 8)
+    (repo / ".git/index").write_bytes(struct.pack("!4sII", b"DIRC", 2, 1) + entry)
+
+
+def test_source_cleanliness_is_index_metadata_only(tmp_path: Path) -> None:
+    (tmp_path / ".git/objects").mkdir(parents=True)
+    source = tmp_path / "tracked.py"
+    source.write_text("value = 1\n", encoding="utf-8")
+    _write_minimal_index(tmp_path, "tracked.py")
+    assert _index_metadata_dirty_paths(tmp_path) == ()
+    source.write_text("value = 200\n", encoding="utf-8")
+    assert _index_metadata_dirty_paths(tmp_path) == ("tracked.py",)
+
+
+def test_repo_head_resolves_loose_branch_from_linked_worktree_common_dir(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "linked"
+    common = tmp_path / "common.git"
+    worktree_git = common / "worktrees/linked"
+    reference = "refs/heads/codex/manual-campaign-smoke"
+    revision = "a" * 40
+    repo.mkdir()
+    worktree_git.mkdir(parents=True)
+    (repo / ".git").write_text(
+        f"gitdir: {worktree_git}\n",
+        encoding="ascii",
+    )
+    (worktree_git / "HEAD").write_text(
+        f"ref: {reference}\n",
+        encoding="ascii",
+    )
+    (worktree_git / "commondir").write_text("../..\n", encoding="ascii")
+    loose = common / reference
+    loose.parent.mkdir(parents=True)
+    loose.write_text(f"{revision}\n", encoding="ascii")
+
+    assert manual_campaign._repo_head(repo) == revision
+
+
+def test_lightweight_result_identity_must_match_selected_cell() -> None:
+    cell = REPORT_CATALOG.measurement_cells()[0]
+    identity = {
+        "cell_id": cell.cell_id,
+        "dataset_id": cell.dataset_id,
+        "process_key": cell.process_key,
+        "process": cell.process,
+        "n_final": cell.n_final,
+        "workload": cell.workload.value,
+        "execution_mode": cell.measurement.execution_mode.value,
+        "model": None,
+        "accuracy": cell.measurement.accuracy.value,
+        "backend": cell.measurement.backend,
+        "variant": cell.variant,
+    }
+    result = {"provenance": {"manual_campaign": {"cell_identity": identity}}}
+    assert _result_matches_cell(result, cell)
+    identity["cell_id"] = "wrong-cell"
+    assert not _result_matches_cell(result, cell)
+
+
+def test_manual_refresh_projects_artifact_output_and_reproduction_commands(
+    tmp_path: Path,
+    repository_with_cli: Path,
+) -> None:
+    service = _manual_service(tmp_path, repo_root=repository_with_cli)
+    cell = next(
+        cell
+        for cell in service.catalog.measurement_cells()
+        if (
+            cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+            and cell.measurement.model is ModelKey.UFO_SM
+            and service.catalog.static_na_reason(cell) is None
+        )
+    )
+    artifact = (
+        service.paths.artifact_root
+        / "cells"
+        / cell.cell_id
+        / "attempts"
+        / "attempt-one"
+        / "artifact"
+    )
+    reproduction = reproduction_recipe(
+        cell,
+        repo_root=service.paths.repo_root,
+        artifact_root=service.paths.artifact_root,
+        artifact_path=str(artifact),
+    ).as_dict()
+    assert all(
+        isinstance(reproduction[field], list)
+        for field in ("prepare", "generate", "profile")
+    )
+
+    def merged_cache(
+        output: Path,
+        recipe: dict[str, object] = reproduction,
+    ) -> dict[str, dict[str, object]]:
+        measurement = empty_measurement()
+        measurement.update(
+            {
+                "status": ResultStatus.TIMEOUT.value,
+                "failure": {"kind": "generation_timeout"},
+                "provenance": {
+                    "effective_config": {
+                        "generation": {"output": str(output)},
+                    },
+                    "manual_campaign": {
+                        "public_cli_reproduction": recipe,
+                    },
+                },
+            }
+        )
+        current = LightweightCurrent(
+            cell_id=cell.cell_id,
+            attempt_id="attempt-one",
+            result_path=output.parent / "result.json",
+            result=measurement,
+            complete=True,
+            reusable=True,
+            reason="reusable",
+        )
+        caches, merged = _merge_lightweight_snapshot(
+            service,
+            {cell.cell_id: current},
+        )
+        assert merged == 1
+        return caches
+
+    caches = merged_cache(artifact)
+    portable = portable_publication_value(
+        caches[f"{cell.dataset_id}.json"],
+        service.paths,
+    )
+    assert isinstance(portable, dict)
+    entries = portable["entries"]
+    assert isinstance(entries, list)
+    entry = next(
+        item
+        for item in entries
+        if isinstance(item, dict) and item.get("cell_id") == cell.cell_id
+    )
+    output = entry["measurement"]["provenance"]["effective_config"][  # type: ignore[index]
+        "generation"
+    ]["output"]
+    assert output == (
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/"
+        f"cells/{cell.cell_id}/attempts/attempt-one/artifact"
+    )
+    provenance = entry["measurement"]["provenance"]  # type: ignore[index]
+    published_recipe = provenance["manual_campaign"][  # type: ignore[index]
+        "public_cli_reproduction"
+    ]
+    for field in ("prepare", "generate", "profile"):
+        argv = published_recipe[field]  # type: ignore[index]
+        assert isinstance(argv, list)
+        assert any("${PYAMPLICOL_SOURCE_ROOT}" in argument for argument in argv)
+    rendered = json.dumps(portable)
+    assert str(service.paths.artifact_root) not in rendered
+    assert str(service.paths.repo_root) not in rendered
+    assert portable_publication_value(portable, service.paths) == portable
+
+    external_recipe = dict(reproduction)
+    external_trace = (
+        service.paths.repo_root.parent / "pyamplicol-external-test" / "trace.json"
+    )
+    external_profile = external_recipe["profile"]
+    assert isinstance(external_profile, list)
+    external_recipe["profile"] = [*external_profile, "--trace", str(external_trace)]
+    external_diagnostic = merged_cache(artifact, external_recipe)
+    redacted = portable_publication_value(
+        external_diagnostic[f"{cell.dataset_id}.json"],
+        service.paths,
+    )
+    redacted_entry = next(
+        item
+        for item in redacted["entries"]  # type: ignore[index]
+        if isinstance(item, dict) and item.get("cell_id") == cell.cell_id
+    )
+    redacted_recipe = redacted_entry["measurement"]["provenance"][  # type: ignore[index]
+        "manual_campaign"
+    ]["public_cli_reproduction"]
+    assert redacted_recipe["profile"][-1] == "${LOCAL_PATH_REDACTED}"
+    assert str(tmp_path) not in json.dumps(redacted)
+    assert portable_publication_value(redacted, service.paths) == redacted
+
+    with pytest.raises(
+        PublicationPortabilityError,
+        match=r"/measurement/provenance/effective_config/generation/output",
+    ):
+        external = merged_cache(tmp_path / "external" / "artifact")
+        portable_publication_value(
+            external[f"{cell.dataset_id}.json"],
+            service.paths,
+        )
+
+
+def test_copied_campaign_rebinds_private_pdf_build_profile(tmp_path: Path) -> None:
+    staging = tmp_path / "copied_campaign"
+    staging.mkdir()
+    (staging / "report_environment.json").write_text(
+        json.dumps({"profile": "macbook_M3_manual"}),
+        encoding="utf-8",
+    )
+    (staging / "report-workspace.json").write_text(
+        json.dumps(
+            {
+                "profile": "macbook_M3_manual",
+                "artifact_root": ".artifacts/performance-report/macbook_M3_manual",
+                "coordination_root": (
+                    ".artifacts/performance-report-coordination/macbook_M3_manual"
+                ),
+                "initialized_environment": {"profile": "macbook_M3_manual"},
+            }
+        ),
+        encoding="utf-8",
+    )
+    (staging / "report_environment.tex").write_text(
+        "\\renewcommand{\\ReportProfileName}{macbook\\_M3\\_manual}\n",
+        encoding="utf-8",
+    )
+
+    manual_campaign._stage_copied_profile_identity(staging, "independent_run")
+
+    environment = json.loads(
+        (staging / "report_environment.json").read_text(encoding="utf-8")
+    )
+    workspace = json.loads(
+        (staging / "report-workspace.json").read_text(encoding="utf-8")
+    )
+    assert environment["profile"] == "independent_run"
+    assert workspace["profile"] == "independent_run"
+    assert workspace["initialized_environment"]["profile"] == "independent_run"
+    assert workspace["artifact_root"] == "campaign_artifacts"
+    assert workspace["coordination_root"] == "campaign_artifacts/coordination"
+    assert "{independent\\_run}" in (staging / "report_environment.tex").read_text(
+        encoding="utf-8"
+    )
+
+
+def test_staged_environment_without_witness_is_pending_or_same_source(
+    tmp_path: Path,
+) -> None:
+    environment_path = tmp_path / "report_environment.json"
+    profile = "portable-campaign"
+    active_revision = "a" * 40
+
+    for status, source_revision in (
+        ("pending_exact_runtime", "pending"),
+        ("authenticated", active_revision),
+    ):
+        environment_path.write_text(
+            json.dumps(
+                {
+                    "profile": profile,
+                    "status": status,
+                    "source_revision": source_revision,
+                }
+            ),
+            encoding="ascii",
+        )
+        manual_campaign._require_reusable_staged_environment(
+            tmp_path,
+            profile,
+            expected_source_revision=active_revision,
+        )
+
+    environment_path.write_text(
+        json.dumps(
+            {
+                "profile": profile,
+                "status": "authenticated",
+                "source_revision": "b" * 40,
+            }
+        ),
+        encoding="ascii",
+    )
+    with pytest.raises(ManualCampaignError, match="no active-source runtime witness"):
+        manual_campaign._require_reusable_staged_environment(
+            tmp_path,
+            profile,
+            expected_source_revision=active_revision,
+        )
+
+
+def test_refresh_installs_authenticated_active_source_environment(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    docs = tmp_path / "portable-campaign"
+    (docs / "results").mkdir(parents=True)
+    (docs / "pyAmpliCol.tex").write_text("report\n", encoding="ascii")
+    shutil.copy2(PROFILE / "report_environment.json", docs)
+    shutil.copy2(PROFILE / "report_environment.tex", docs)
+    service = ReportService(
+        manual_campaign._campaign_report_paths(ROOT, docs),
+        portable_current_results=True,
+    )
+    revision = "a" * 40
+    current = _environment_witness_current(
+        tmp_path,
+        cell_id="active-current",
+        source_revision=revision,
+        numpy_version="1.26.4-measurement",
+    )
+    real_import_module = workspace_module.importlib.import_module
+
+    def reject_renderer_numpy(name: str):
+        if name == "numpy":
+            raise AssertionError("portable refresh imported renderer NumPy")
+        return real_import_module(name)
+
+    monkeypatch.setattr(
+        workspace_module.importlib,
+        "import_module",
+        reject_renderer_numpy,
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_capture_lightweight_snapshot",
+        lambda *_args, **_kwargs: (
+            {current.cell_id: current},
+            {},
+            ((current.cell_id, current.attempt_id),),
+        ),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_merge_lightweight_snapshot",
+        lambda *_args, **_kwargs: ({}, 0),
+    )
+    monkeypatch.setattr(ReportService, "_render_tables", lambda *_args: {})
+    monkeypatch.setattr(ReportService, "_snapshot_files", lambda *_args: ())
+
+    def compile_staged(staging_docs: Path, **_kwargs: object) -> int:
+        environment = json.loads(
+            (staging_docs / "report_environment.json").read_text(encoding="ascii")
+        )
+        assert environment["status"] == "authenticated"
+        assert environment["profile"] == "portable-campaign"
+        assert environment["source_revision"] == revision
+        assert environment["platform"] == "MeasuredOS 1.0; witness"
+        assert environment["machine"] == "measured-machine"
+        assert environment["processor"] == "measured-processor"
+        assert environment["python"] == "3.11.9"
+        assert environment["python_implementation"] == "CPython"
+        assert environment["numpy"] == "1.26.4-measurement"
+        assert "pending" not in (staging_docs / "report_environment.tex").read_text(
+            encoding="utf-8"
+        )
+        (staging_docs / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.4\n")
+        return 1
+
+    monkeypatch.setattr(manual_campaign, "_compile_pdf", compile_staged)
+
+    assert (
+        manual_campaign._refresh_pdf(
+            _parse("refresh-pdf", "--quiet", "--expected-page-count", "1"),
+            service=service,
+            source=manual_campaign.ReportSourceIdentity(
+                revision,
+                "b" * 40,
+                (),
+            ),
+            palette=manual_campaign.Palette(False),
+        )
+        == 0
+    )
+    installed = json.loads(
+        (docs / "report_environment.json").read_text(encoding="ascii")
+    )
+    assert installed["status"] == "authenticated"
+    assert installed["platform"] == "MeasuredOS 1.0; witness"
+    assert "pending" not in (docs / "report_environment.tex").read_text(
+        encoding="utf-8"
+    )
+    assert (docs / "pyAmpliCol.pdf").read_bytes() == b"%PDF-1.4\n"
+
+
+def test_manual_refresh_source_copy_excludes_only_top_level_campaign_state(
+    tmp_path: Path,
+) -> None:
+    source = tmp_path / "source"
+    source.mkdir()
+    (source / "pyAmpliCol.tex").write_text("report\n", encoding="ascii")
+    state = source / "campaign_artifacts"
+    state.mkdir()
+    (state / "large-sentinel.bin").write_bytes(b"private")
+    nested = source / "appendix/campaign_artifacts"
+    nested.mkdir(parents=True)
+    (nested / "published.txt").write_text("keep\n", encoding="ascii")
+    destination = tmp_path / "staging"
+
+    manual_campaign._copy_report_sources(source, destination)
+
+    assert not (destination / "campaign_artifacts").exists()
+    assert (destination / "appendix/campaign_artifacts/published.txt").is_file()
+
+
+def test_refresh_pdf_does_not_stage_local_campaign_state_recursively(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    docs = tmp_path / "portable-campaign"
+    docs.mkdir()
+    (docs / "pyAmpliCol.tex").write_text("report\n", encoding="ascii")
+    service = ReportService(
+        manual_campaign._campaign_report_paths(ROOT, docs),
+        portable_current_results=True,
+    )
+    sentinel = service.paths.artifact_root / "large-private-sentinel.bin"
+    sentinel.write_bytes(b"private-state" * 1024)
+    manual_campaign.update_source_marker(
+        service,
+        manual_campaign.ReportSourceIdentity("a" * 40, "b" * 40, ()),
+    )
+    observed: dict[str, Path] = {}
+
+    monkeypatch.setattr(
+        manual_campaign,
+        "_capture_lightweight_snapshot",
+        lambda *_args, **_kwargs: ({}, {}, ()),
+    )
+    monkeypatch.setattr(
+        manual_campaign,
+        "_merge_lightweight_snapshot",
+        lambda *_args, **_kwargs: ({}, 0),
+    )
+    monkeypatch.setattr(ReportService, "_render_tables", lambda *_args: {})
+    monkeypatch.setattr(ReportService, "_snapshot_files", lambda *_args: ())
+
+    def compile_staged(staging_docs: Path, **_kwargs: object) -> int:
+        observed["staging_docs"] = staging_docs
+        assert not (staging_docs / "campaign_artifacts").exists()
+        assert not any(
+            path.name == sentinel.name for path in staging_docs.rglob("*")
+        )
+        (staging_docs / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.4\n")
+        return 1
+
+    monkeypatch.setattr(manual_campaign, "_compile_pdf", compile_staged)
+    monkeypatch.setattr(
+        manual_campaign,
+        "_install_report_snapshot",
+        lambda *_args, **_kwargs: None,
+    )
+
+    assert (
+        manual_campaign._refresh_pdf(
+            _parse("refresh-pdf", "--quiet", "--expected-page-count", "1"),
+            service=service,
+            source=manual_campaign.ReportSourceIdentity("a" * 40, "b" * 40, ()),
+            palette=manual_campaign.Palette(False),
+        )
+        == 0
+    )
+    assert "staging_docs" in observed
+    assert not observed["staging_docs"].exists()
+    assert sentinel.read_bytes() == b"private-state" * 1024
+    build_root = service.paths.artifact_root / "manual-publication-builds"
+    assert build_root.is_dir()
+    assert not tuple(build_root.iterdir())
+
+
+def test_controller_sources_only_use_read_only_git_for_external_checkout() -> None:
+    source_paths = (
+        PROFILE / "steer_performance_campaign.py",
+        ROOT / "tools/performance_report/manual_campaign.py",
+    )
+    sources = "\n".join(path.read_text(encoding="utf-8") for path in source_paths)
+    for forbidden in (
+        "subprocess.Popen(",
+        "os.system(",
+        "shell=True",
+        "pip install",
+        "git pull",
+        "git fetch",
+    ):
+        assert forbidden not in sources
+    commands: list[tuple[str | None, ...]] = []
+    for path in source_paths:
+        tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+        for node in ast.walk(tree):
+            if not (
+                isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Attribute)
+                and node.func.attr == "run"
+                and isinstance(node.func.value, ast.Name)
+                and node.func.value.id == "subprocess"
+            ):
+                continue
+            assert node.args and isinstance(node.args[0], (ast.Tuple, ast.List))
+            command = tuple(
+                element.value if isinstance(element, ast.Constant) else None
+                for element in node.args[0].elts
+            )
+            assert command[:2] in {("git", "rev-parse"), ("git", "status")}
+            assert not {
+                "add",
+                "apply",
+                "checkout",
+                "clean",
+                "commit",
+                "fetch",
+                "merge",
+                "pull",
+                "push",
+                "reset",
+                "stash",
+            }.intersection(value for value in command if value is not None)
+            commands.append(command)
+    assert ("git", "rev-parse", "HEAD") in commands
+    assert (
+        "git",
+        "status",
+        "--porcelain=v1",
+        "--untracked-files=all",
+    ) in commands
+    assert any(command[:3] == ("git", "rev-parse", "--verify") for command in commands)
+    assert os.access(PROFILE / "steer_performance_campaign.py", os.X_OK)
+
+
+def test_report_snapshot_install_is_atomic_and_rolls_back_on_failure(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    docs = tmp_path / "docs"
+    staging = tmp_path / "staging"
+    for root, prefix in ((docs, "old"), (staging, "new")):
+        (root / "results").mkdir(parents=True)
+        (root / "results/cache.json").write_text(
+            f"{prefix}-cache\n",
+            encoding="ascii",
+        )
+        (root / "result_demo_table.tex").write_text(
+            f"{prefix}-table\n",
+            encoding="utf-8",
+        )
+        (root / "report_environment.json").write_text(
+            f"{prefix}-environment-json\n",
+            encoding="ascii",
+        )
+        (root / "report_environment.tex").write_text(
+            f"{prefix}-environment-tex\n",
+            encoding="utf-8",
+        )
+        (root / "pyAmpliCol.pdf").write_bytes(f"{prefix}-pdf".encode("ascii"))
+    service = ReportService(
+        ReportPaths.from_repo(
+            ROOT,
+            docs_dir=docs,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    real_replace = os.replace
+
+    def fail_pdf_install(
+        source: os.PathLike[str],
+        destination: os.PathLike[str],
+    ) -> None:
+        if (
+            Path(destination).name == "pyAmpliCol.pdf"
+            and ".manual-" in Path(source).name
+        ):
+            raise OSError("injected PDF install interruption")
+        return real_replace(source, destination)
+
+    monkeypatch.setattr(os, "replace", fail_pdf_install)
+    with pytest.raises(OSError, match="injected PDF install"):
+        _install_report_snapshot(
+            service,
+            staging,
+            ("result_demo_table.tex",),
+        )
+
+    assert (docs / "results/cache.json").read_text(encoding="ascii") == "old-cache\n"
+    assert (docs / "result_demo_table.tex").read_text(encoding="utf-8") == "old-table\n"
+    assert (docs / "report_environment.json").read_text(encoding="ascii") == (
+        "old-environment-json\n"
+    )
+    assert (docs / "report_environment.tex").read_text(encoding="utf-8") == (
+        "old-environment-tex\n"
+    )
+    assert (docs / "pyAmpliCol.pdf").read_bytes() == b"old-pdf"
+
+
+@pytest.mark.skipif(shutil.which("latexmk") is None, reason="latexmk is unavailable")
+def test_fresh_manual_report_compiles_with_the_manual_page_contract(
+    tmp_path: Path,
+) -> None:
+    docs = tmp_path / "docs"
+    shutil.copytree(
+        PROFILE,
+        docs,
+        ignore=shutil.ignore_patterns("pyAmpliCol.pdf", "*.aux", "*.log"),
+    )
+    pages = _compile_pdf(
+        docs,
+        expected_page_count=DEFAULT_MANUAL_EXPECTED_PAGE_COUNT,
+        timeout_seconds=900.0,
+    )
+    assert pages == 73
+    assert (docs / "pyAmpliCol.pdf").stat().st_size > 100_000
diff --git a/pyamplicol/tests/unit/test_model_assets.py b/pyamplicol/tests/unit/test_model_assets.py
new file mode 100644
index 0000000000..2ea49e3b04
--- /dev/null
+++ b/pyamplicol/tests/unit/test_model_assets.py
@@ -0,0 +1,318 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+import tomllib
+from importlib import resources
+from pathlib import Path, PurePosixPath
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+SOURCE_ASSET_ROOT = PROJECT_ROOT / "src" / "pyamplicol" / "assets" / "models"
+MANIFEST_LINE = re.compile(r"([0-9a-f]{64})  ([^\r\n]+)")
+HOST_PATH_MARKERS = (b"/Users/", b"/home/", b"file://")
+
+EXPECTED_UFO_FILES = {
+    "scalar_gravity": {
+        "__init__.py",
+        "coupling_orders.py",
+        "couplings.py",
+        "function_library.py",
+        "lorentz.py",
+        "object_library.py",
+        "param_card.dat",
+        "parameters.py",
+        "particles.py",
+        "restrict_default.dat",
+        "restrict_full.dat",
+        "run_write_param_card.py",
+        "vertices.py",
+        "write_param_card.py",
+    },
+    "scalars": {
+        "__init__.py",
+        "coupling_orders.py",
+        "couplings.py",
+        "function_library.py",
+        "lorentz.py",
+        "object_library.py",
+        "parameters.py",
+        "particles.py",
+        "restrict_default.dat",
+        "restrict_full.dat",
+        "run_write_param_card.py",
+        "vertices.py",
+        "write_param_card.py",
+    },
+    "sm": {
+        "__init__.py",
+        "build_restrict.py",
+        "coupling_orders.py",
+        "couplings.py",
+        "decays.py",
+        "function_library.py",
+        "lorentz.py",
+        "object_library.py",
+        "parameters.py",
+        "particles.py",
+        "restrict_c_mass.dat",
+        "restrict_ckm.dat",
+        "restrict_default.dat",
+        "restrict_full.dat",
+        "restrict_lepton_masses.dat",
+        "restrict_no_b_mass.dat",
+        "restrict_no_masses.dat",
+        "restrict_no_tau_mass.dat",
+        "restrict_no_widths.dat",
+        "restrict_zeromass_ckm.dat",
+        "run_write_param_card.py",
+        "vertices.py",
+        "write_param_card.py",
+    },
+}
+
+EXPECTED_MODEL_SHAPES = {
+    "scalar_gravity/scalar_gravity.json": (4, 11, 14, 8),
+    "scalars/scalars.json": (3, 276, 1, 8),
+    "scalars/scalars_2p_3p.json": (3, 16, 1, 2),
+    "sm/sm.json": (43, 153, 108, 22),
+    "sm/sm_wrapped_indices.json": (43, 153, 108, 22),
+}
+
+
+def _assets_resource():
+    return resources.files("pyamplicol").joinpath("assets", "models")
+
+
+def _resource(relative: str):
+    current = _assets_resource()
+    for part in PurePosixPath(relative).parts:
+        current = current.joinpath(part)
+    return current
+
+
+def _is_interpreter_cache(path: Path, *, root: Path) -> bool:
+    relative = path.relative_to(root)
+    return "__pycache__" in relative.parts and path.suffix == ".pyc"
+
+
+def _manifest() -> tuple[list[str], dict[str, str]]:
+    lines = _resource("MANIFEST.sha256").read_text(encoding="utf-8").splitlines()
+    assert lines
+    entries: dict[str, str] = {}
+    paths: list[str] = []
+    for line in lines:
+        match = MANIFEST_LINE.fullmatch(line)
+        assert match is not None, f"malformed manifest line: {line!r}"
+        digest, relative = match.groups()
+        path = PurePosixPath(relative)
+        assert not path.is_absolute()
+        assert relative == path.as_posix()
+        assert "\\" not in relative
+        assert not {"", ".", ".."}.intersection(path.parts)
+        assert relative not in entries
+        entries[relative] = digest
+        paths.append(relative)
+    return paths, entries
+
+
+def test_manifest_is_exact_and_resources_are_readable() -> None:
+    paths, manifest = _manifest()
+    assert paths == sorted(paths)
+    assert "MANIFEST.sha256" not in manifest
+    assert "PROVENANCE.toml" in manifest
+
+    asset_root = Path(str(_assets_resource()))
+    actual = {
+        path.relative_to(asset_root).as_posix()
+        for path in asset_root.rglob("*")
+        if path.is_file()
+        and path.name != "MANIFEST.sha256"
+        and not _is_interpreter_cache(path, root=asset_root)
+    }
+    assert set(manifest) == actual
+
+    for relative, expected in manifest.items():
+        resource = _resource(relative)
+        assert resource.is_file(), relative
+        assert hashlib.sha256(resource.read_bytes()).hexdigest() == expected
+
+
+def test_assets_have_no_links_unsafe_paths_or_generated_files() -> None:
+    asset_root = Path(str(_assets_resource()))
+    resolved_root = asset_root.resolve()
+    installed_copy = resolved_root != SOURCE_ASSET_ROOT.resolve()
+    for path in asset_root.rglob("*"):
+        assert not path.is_symlink(), path
+        assert path.resolve().is_relative_to(resolved_root), path
+        relative = path.relative_to(asset_root)
+        if path.name == "__pycache__" or _is_interpreter_cache(path, root=asset_root):
+            assert installed_copy, path
+            assert path.name == "__pycache__" or path.suffix == ".pyc", path
+            continue
+        assert "__pycache__" not in relative.parts
+        assert path.suffix != ".pyc"
+        if not path.is_file():
+            continue
+        content = path.read_bytes()
+        assert b"../" not in content, path
+        assert b"..\\" not in content, path
+        assert not any(marker in content for marker in HOST_PATH_MARKERS), path
+
+
+def test_provenance_covers_every_source_asset_and_license() -> None:
+    _, manifest = _manifest()
+    provenance = tomllib.loads(_resource("PROVENANCE.toml").read_text(encoding="utf-8"))
+    assert provenance["schema_version"] == 1
+    assert provenance["release_status"] == "eligible"
+    assert provenance["source"]["revision"] == (
+        "643bc6f99d7b2249af0a85204768df243e612411"
+    )
+    assert provenance["generator"]["version"] == "0.1.8"
+    assert re.fullmatch(r"[0-9a-f]{40}", provenance["generator"]["revision"])
+
+    licenses = {entry["id"]: entry for entry in provenance["licenses"]}
+    assert set(licenses) == {
+        "0BSD",
+        "GammaLoop-model-assets",
+        "MIT",
+        "MadGraph5-aMCatNLO",
+    }
+    for entry in licenses.values():
+        assert (PROJECT_ROOT / entry["path"]).is_file(), entry["path"]
+
+    transformations = {entry["id"] for entry in provenance["transformations"]}
+    records = provenance["files"]
+    assert len(records) == 66
+    assert sum(entry["upstream_exact_blob_match"] for entry in records) == 27
+
+    record_paths = set()
+    for entry in records:
+        relative = entry["canonical_package_path"].removeprefix(
+            "pyamplicol/assets/models/"
+        )
+        assert relative != entry["canonical_package_path"]
+        assert relative in manifest
+        assert entry["package_sha256"] == manifest[relative]
+        assert re.fullmatch(r"[0-9a-f]{64}", entry["source_sha256"])
+        assert re.fullmatch(r"[0-9a-f]{40}", entry["source_blob_oid"])
+        assert entry["transformation_id"] in transformations
+        assert set(entry["license_ids"]).issubset(licenses)
+        record_paths.add(relative)
+
+    assert record_paths == set(manifest) - {"PROVENANCE.toml"}
+    models = {entry["id"]: entry for entry in provenance["models"]}
+    assert models["built-in-sm"]["canonical_package_path"] == (
+        "pyamplicol/models/builtin/__init__.py"
+    )
+    assert models["built-in-sm"]["source_sha256"] == (
+        "7b3bac9e53193260bf9c2829ef972f87d23246e93dc57f208bda4821195b7ad3"
+    )
+    assert all(entry["release_eligible"] for entry in models.values())
+
+
+def test_ufo_directories_are_complete_and_syntactically_valid() -> None:
+    ufo_root = Path(str(_assets_resource().joinpath("ufo")))
+    assert {path.name for path in ufo_root.iterdir() if path.is_dir()} == set(
+        EXPECTED_UFO_FILES
+    )
+    for model, expected in EXPECTED_UFO_FILES.items():
+        model_root = ufo_root / model
+        actual = {path.name for path in model_root.iterdir() if path.is_file()}
+        assert actual == expected
+        for path in model_root.glob("*.py"):
+            compile(path.read_bytes(), path.as_posix(), "exec")
+
+
+def test_all_json_is_parseable_and_models_have_expected_shape() -> None:
+    json_root = Path(str(_assets_resource().joinpath("json")))
+    json_files = sorted(json_root.rglob("*.json"))
+    assert len(json_files) == 16
+    payloads = {
+        path.relative_to(json_root).as_posix(): json.loads(
+            path.read_text(encoding="utf-8")
+        )
+        for path in json_files
+    }
+    assert all(isinstance(payload, dict) for payload in payloads.values())
+
+    for relative, expected in EXPECTED_MODEL_SHAPES.items():
+        payload = payloads[relative]
+        actual = tuple(
+            len(payload[key])
+            for key in (
+                "particles",
+                "vertex_rules",
+                "couplings",
+                "lorentz_structures",
+            )
+        )
+        assert actual == expected
+
+
+def test_json_restrictions_are_complete_explicit_ufo_cards() -> None:
+    from ufo_model_loader.common import optionally_lower_external_parameter_name
+    from ufo_model_loader.model import InputParamCard, Model, ParamCard
+
+    from pyamplicol.models.loading import _sanitized_model_environment
+
+    asset_root = Path(str(_assets_resource()))
+    for json_path in sorted((asset_root / "json").glob("*/restrict_*.json")):
+        model_name = json_path.parent.name
+        model_path = json_path.parent / f"{model_name}.json"
+        ufo_path = asset_root / "ufo" / model_name / f"{json_path.stem}.dat"
+        with _sanitized_model_environment():
+            model = Model.from_json(model_path.read_text(encoding="utf-8"))
+        parameter_names = {
+            optionally_lower_external_parameter_name(parameter.name)
+            for parameter in model.get_external_parameters()
+        }
+        expected = InputParamCard.from_param_card(
+            ParamCard(str(ufo_path)),
+            model=model,
+        )
+        actual = InputParamCard.from_json_file(str(json_path))
+
+        assert set(actual) == parameter_names, json_path
+        assert actual == InputParamCard(
+            {name: expected[name] for name in parameter_names}
+        ), json_path
+
+
+def test_packaged_jsons_store_evaluated_unrestricted_defaults() -> None:
+    from ufo_model_loader.commands import load_model
+
+    for relative in EXPECTED_MODEL_SHAPES:
+        path = Path(str(_assets_resource().joinpath("json", relative)))
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        # These values are part of the shipped serialization, not supplied by
+        # a pyAmpliCol loader workaround or filled only after reading the file.
+        for entry in (*payload["parameters"], *payload["couplings"]):
+            assert entry["value"] is not None, (relative, entry["name"])
+            assert all(math.isfinite(value) for value in entry["value"])
+        model, _card = load_model(str(path), "full", True)
+        reloaded = json.loads(model.to_json())
+        for field in ("parameters", "couplings"):
+            recomputed = {entry["name"]: entry["value"] for entry in reloaded[field]}
+            for entry in payload[field]:
+                assert all(
+                    math.isclose(a, b, rel_tol=2e-15, abs_tol=0.0)
+                    for a, b in zip(
+                        entry["value"], recomputed[entry["name"]], strict=True
+                    )
+                ), (relative, entry["name"])
+
+
+def test_scalar_ufo_shape_is_environment_independent() -> None:
+    scalars = _resource("ufo/scalars/parameters.py").read_text(encoding="utf-8")
+    gravity = _resource("ufo/scalar_gravity/parameters.py").read_text(encoding="utf-8")
+    combined = scalars + gravity
+    assert "os.environ" not in combined
+    assert "UFO_SCALARS_MODEL_" not in combined
+    assert "UFO_GRAVITY_MODEL_" not in combined
+    assert "N_SCALARS = 3" in scalars
+    assert "N_POINT_INTERACTIONS = [3, 4, 5, 6, 7, 8, 9, 10]" in scalars
+    assert "N_SCALARS = 3" in gravity
+    assert "N_POINT_INTERACTIONS" not in gravity
diff --git a/pyamplicol/tests/unit/test_model_boundary_audit.py b/pyamplicol/tests/unit/test_model_boundary_audit.py
new file mode 100644
index 0000000000..eba40313fa
--- /dev/null
+++ b/pyamplicol/tests/unit/test_model_boundary_audit.py
@@ -0,0 +1,335 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import ast
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+REPOSITORY_ROOT = Path(__file__).resolve().parents[2]
+PACKAGE_ROOT = REPOSITORY_ROOT / "src" / "pyamplicol"
+BUILTIN_ROOT = PACKAGE_ROOT / "models" / "builtin"
+
+NON_RUNTIME_ALLOWLIST = (
+    PACKAGE_ROOT / "assets",
+    REPOSITORY_ROOT / "docs",
+)
+
+BUILTIN_IMPORT_ALLOWLIST = {
+    "generation/lowering.py": {
+        ("pyamplicol.models.builtin.lowering_reports", "module"),
+        ("pyamplicol.models.builtin.lowering_tensor", "module"),
+    },
+    "generation/lowering_reports.py": {
+        ("pyamplicol.models.builtin", "module"),
+    },
+    "generation/lowering_tensor.py": {
+        ("pyamplicol.models.builtin", "module"),
+    },
+    "models/compiler.py": {
+        ("pyamplicol.models.builtin.compiler", "function"),
+    },
+    "models/loading.py": {
+        ("pyamplicol.models.builtin.adapters", "function"),
+    },
+    "generation/service.py": {
+        ("pyamplicol.models.builtin.process_catalog", "function"),
+        ("pyamplicol.models.builtin.process_ir", "function"),
+        ("pyamplicol.models.builtin.process_selection", "function"),
+        ("pyamplicol.models.builtin.process_types", "function"),
+    },
+}
+
+LEGACY_PROCESS_SYMBOLS = frozenset(
+    {
+        "ALL_COLOURED",
+        "ANTI_PARTICLE",
+        "ANTIQUARKS",
+        "CHARGES3",
+        "FAMILY",
+        "GLUONS",
+        "PDGS",
+        "QUARKS",
+        "SINGLETS",
+        "SORT_PARTICLES",
+    }
+)
+LEGACY_PROCESS_SYMBOL_ALLOWLIST = {
+    "generation/service.py": frozenset({"PDGS"}),
+}
+SM_PDG_VALUES = frozenset({*range(1, 7), *range(11, 17), 21, 22, 23, 24, 25, 26, 99})
+BUILTIN_IMPLEMENTATION_DEFINITIONS = frozenset(
+    {
+        "BuiltinModel",
+        "BuiltinSMDefinitionMixin",
+        "BuiltinSMLoweringMixin",
+        "BuiltinSMModel",
+        "ProcessEnumerator",
+        "_GraphTensorExpressionBuilder",
+        "_build_auxiliary_tensor_probe",
+        "_build_color_probe",
+        "_charge3_sum",
+        "_family_sum",
+        "_legacy_selection_records_from_request",
+        "_physical_pdgs",
+        "build_interleaved_tensor_network_scalar_bundle",
+        "build_symbolic_lowering_report",
+        "build_tensor_network_scalar_bundle",
+        "request_allows_charged_current",
+    }
+)
+
+
+def _runtime_python_files() -> tuple[Path, ...]:
+    return tuple(
+        path
+        for path in sorted(PACKAGE_ROOT.rglob("*.py"))
+        if not path.is_relative_to(BUILTIN_ROOT)
+        and not any(path.is_relative_to(root) for root in NON_RUNTIME_ALLOWLIST)
+    )
+
+
+def _relative(path: Path) -> str:
+    return path.relative_to(PACKAGE_ROOT).as_posix()
+
+
+def _parse(path: Path) -> ast.Module:
+    return ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+
+
+def _resolved_import_from(path: Path, node: ast.ImportFrom) -> str:
+    if node.level == 0:
+        return node.module or ""
+    relative_parent = path.relative_to(PACKAGE_ROOT).parent
+    package = ["pyamplicol", *relative_parent.parts]
+    keep = len(package) - (node.level - 1)
+    if keep < 1:
+        return node.module or ""
+    suffix = [] if node.module is None else node.module.split(".")
+    return ".".join([*package[:keep], *suffix])
+
+
+def _scope(node: ast.AST, parents: dict[ast.AST, ast.AST]) -> str:
+    parent = parents.get(node)
+    while parent is not None:
+        if isinstance(parent, (ast.AsyncFunctionDef, ast.FunctionDef)):
+            return "function"
+        parent = parents.get(parent)
+    return "module"
+
+
+def _pdg_expression(node: ast.AST) -> bool:
+    if isinstance(node, ast.Name):
+        name = node.id.casefold()
+        return (
+            name == "pdg"
+            or name.endswith("_pdg")
+            or name.endswith("_pdg_code")
+            or name in {"particle_id", "result_particle", "result_particle_id"}
+        )
+    if isinstance(node, ast.Attribute):
+        return _pdg_expression(ast.Name(id=node.attr))
+    if isinstance(node, ast.UnaryOp):
+        return _pdg_expression(node.operand)
+    if (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id in {"abs", "int"}
+        and len(node.args) == 1
+        and not node.keywords
+    ):
+        return _pdg_expression(node.args[0])
+    return False
+
+
+def _comparison_integer_literals(node: ast.AST) -> frozenset[int]:
+    if isinstance(node, ast.Constant) and isinstance(node.value, int):
+        return frozenset({int(node.value)})
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):
+        return _comparison_integer_literals(node.operand)
+    if isinstance(node, (ast.List, ast.Set, ast.Tuple)):
+        return frozenset().union(
+            *(_comparison_integer_literals(item) for item in node.elts)
+        )
+    if isinstance(node, ast.Dict):
+        return frozenset().union(
+            *(_comparison_integer_literals(key) for key in node.keys if key is not None)
+        )
+    if (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id in {"abs", "int", "range"}
+    ):
+        return frozenset().union(
+            *(_comparison_integer_literals(argument) for argument in node.args)
+        )
+    return frozenset()
+
+
+@pytest.mark.parametrize(
+    "module_name",
+    (
+        "pyamplicol.models.contracts",
+        "pyamplicol.models.external",
+        "pyamplicol.models.loading",
+        "pyamplicol.processes.model",
+    ),
+)
+def test_external_import_paths_do_not_load_builtin_model(module_name: str) -> None:
+    script = "\n".join(
+        (
+            "import importlib",
+            "import json",
+            "import sys",
+            f"sys.path.insert(0, {str(PACKAGE_ROOT.parent)!r})",
+            f"importlib.import_module({module_name!r})",
+            "loaded = sorted(name for name in sys.modules "
+            "if name == 'pyamplicol.models.builtin' "
+            "or name.startswith('pyamplicol.models.builtin.'))",
+            "print(json.dumps(loaded))",
+        )
+    )
+    environment = os.environ.copy()
+    environment.pop("PYTHONPATH", None)
+    completed = subprocess.run(
+        [sys.executable, "-I", "-c", script],
+        cwd=REPOSITORY_ROOT,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert completed.returncode == 0, completed.stderr
+    loaded = json.loads(completed.stdout.strip().splitlines()[-1])
+    assert loaded == [], (
+        f"importing {module_name} crossed the built-in model boundary: {loaded}"
+    )
+
+
+def test_builtin_imports_are_limited_to_compatibility_and_dispatch_facades() -> None:
+    violations: list[str] = []
+    for path in _runtime_python_files():
+        tree = _parse(path)
+        parents = {
+            child: parent
+            for parent in ast.walk(tree)
+            for child in ast.iter_child_nodes(parent)
+        }
+        relative = _relative(path)
+        allowed = BUILTIN_IMPORT_ALLOWLIST.get(relative, set())
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ImportFrom):
+                module = _resolved_import_from(path, node)
+                if not (
+                    module == "pyamplicol.models.builtin"
+                    or module.startswith("pyamplicol.models.builtin.")
+                ):
+                    continue
+                import_scope = _scope(node, parents)
+                if (module, import_scope) not in allowed:
+                    violations.append(
+                        f"{relative}:{node.lineno}: {module} ({import_scope})"
+                    )
+            elif isinstance(node, ast.Import):
+                for alias in node.names:
+                    if not (
+                        alias.name == "pyamplicol.models.builtin"
+                        or alias.name.startswith("pyamplicol.models.builtin.")
+                    ):
+                        continue
+                    import_scope = _scope(node, parents)
+                    if (alias.name, import_scope) not in allowed:
+                        violations.append(
+                            f"{relative}:{node.lineno}: {alias.name} ({import_scope})"
+                        )
+
+    assert violations == [], "unexpected built-in imports:\n" + "\n".join(violations)
+
+
+def test_sm_catalog_and_pdg_classifiers_are_quarantined() -> None:
+    catalog_violations: list[str] = []
+    pdg_violations: list[str] = []
+    for path in _runtime_python_files():
+        tree = _parse(path)
+        relative = _relative(path)
+        allowed_symbols = LEGACY_PROCESS_SYMBOL_ALLOWLIST.get(relative, frozenset())
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Name) and node.id in LEGACY_PROCESS_SYMBOLS:
+                if node.id not in allowed_symbols:
+                    catalog_violations.append(f"{relative}:{node.lineno}: {node.id}")
+            elif isinstance(node, ast.ImportFrom):
+                imported = LEGACY_PROCESS_SYMBOLS.intersection(
+                    alias.name for alias in node.names
+                )
+                unexpected = imported.difference(allowed_symbols)
+                if unexpected:
+                    catalog_violations.append(
+                        f"{relative}:{node.lineno}: {', '.join(sorted(unexpected))}"
+                    )
+            elif isinstance(node, ast.Compare):
+                operands = (node.left, *node.comparators)
+                if not any(_pdg_expression(operand) for operand in operands):
+                    continue
+                literals = frozenset().union(
+                    *(
+                        _comparison_integer_literals(operand)
+                        for operand in operands
+                        if not _pdg_expression(operand)
+                    )
+                )
+                matched = literals.intersection(SM_PDG_VALUES)
+                if matched:
+                    pdg_violations.append(
+                        f"{relative}:{node.lineno}: {sorted(matched)}"
+                    )
+
+    assert catalog_violations == [], "legacy process catalog escaped:\n" + "\n".join(
+        catalog_violations
+    )
+    assert pdg_violations == [], "SM PDG classifier escaped:\n" + "\n".join(
+        pdg_violations
+    )
+
+
+def test_builtin_implementation_uses_package_scoped_modules() -> None:
+    required = {
+        "definitions.py",
+        "lowering.py",
+        "lowering_reports.py",
+        "lowering_tensor.py",
+        "process_catalog.py",
+        "process_enumeration.py",
+        "process_ir.py",
+        "process_selection.py",
+        "process_types.py",
+    }
+    assert required.issubset({path.name for path in BUILTIN_ROOT.glob("*.py")})
+
+    legacy_paths = (
+        PACKAGE_ROOT / "models" / "builtin.py",
+        PACKAGE_ROOT / "models" / "builtin_definitions.py",
+        PACKAGE_ROOT / "models" / "builtin_lowering.py",
+    )
+    assert not any(path.exists() for path in legacy_paths)
+
+    escaped_definitions: list[str] = []
+    for path in _runtime_python_files():
+        for node in ast.walk(_parse(path)):
+            if (
+                isinstance(
+                    node,
+                    (ast.AsyncFunctionDef, ast.ClassDef, ast.FunctionDef),
+                )
+                and node.name in BUILTIN_IMPLEMENTATION_DEFINITIONS
+            ):
+                escaped_definitions.append(
+                    f"{_relative(path)}:{node.lineno}: {node.name}"
+                )
+    assert escaped_definitions == [], "built-in implementation escaped:\n" + "\n".join(
+        escaped_definitions
+    )
diff --git a/pyamplicol/tests/unit/test_model_builtin.py b/pyamplicol/tests/unit/test_model_builtin.py
new file mode 100644
index 0000000000..2eec42a10c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_model_builtin.py
@@ -0,0 +1,272 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import math
+
+import pytest
+
+import pyamplicol.models as models
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.base import Model, Vertex
+from pyamplicol.models.builtin.adapters import build_model_payload
+from pyamplicol.models.builtin.model import BuiltinModel
+from pyamplicol.models.loading import compile_model_source
+
+
+def test_builtin_sm_normalization_uses_the_compiled_alpha_ew_default() -> None:
+    model = BuiltinSMModel()
+    _payload, parameter_defaults = build_model_payload()
+
+    assert model.alpha_ew == 1.0 / 132.507
+    assert parameter_defaults["alpha_ew"] == (model.alpha_ew, 0.0)
+    assert (
+        model.runtime_normalization_parameter_defaults()["normalization.alpha_ew"]
+        == parameter_defaults["alpha_ew"][0]
+    )
+
+
+def test_model_builtin_sm_preserves_production_tables_and_couplings() -> None:
+    model = BuiltinSMModel()
+
+    assert len(model.particles) == 24
+    assert len(model.vertices) == 211
+    assert model.sin_weak == 0.47143025548407230
+    assert model.mass(23) == 91.188
+    assert model.width(23) == 2.441404
+    assert model.mass(24) == 80.419002445756163
+    left, right = model.z_fermion_coupling(1)
+    prefactor = 1.0 / (model.sin_weak * model.cos_weak)
+    assert math.isclose(left, prefactor * (-0.5 + model.sin_weak**2 / 3.0))
+    assert math.isclose(right, prefactor * (model.sin_weak**2 / 3.0))
+    assert model.leading_color_factor([1, -1, 23, 21, 21]) == 27
+    assert model.runtime_normalization_parameter_defaults() == {
+        "normalization.alpha_s_me_check": model.alpha_s_me_check,
+        "normalization.alpha_ew": model.alpha_ew,
+    }
+
+
+def test_model_builtin_lowering_metadata_uses_owned_symbol_names() -> None:
+    model = BuiltinSMModel()
+
+    tensor = model.vertex_lowering_rule(1)
+    assert tensor.tensor_names == ("pyamplicol::two_gluon_to_tensor",)
+    assert tensor.expression_head == "pyamplicol::two_gluon_to_tensor"
+    assert model.vertex_lowering_rule(6).expression_head == ("quark_gluon_weyl_current")
+    assert model.vertex_lowering_rule(999).backend == "unimplemented"
+    assert model.propagator_lowering_rule(-21).description.endswith(
+        "adjacent built-in-SM vertex kernels"
+    )
+    assert model.propagator_lowering_rule(125).description.endswith(
+        "the built-in-SM model"
+    )
+    full_bottom = model.propagator_lowering_rule(5, chirality=0)
+    assert full_bottom.kind == "dirac-fermion"
+    assert full_bottom.mass_class == "massless"
+    assert full_bottom.kernel == "massless_dirac_fermion"
+
+
+def test_builtin_yang_mills_kernel_evaluation_relations_are_exact() -> None:
+    model = BuiltinSMModel()
+    left = (1.0 + 2.0j, -0.5j, 3.0, -2.0 + 0.25j)
+    right = (0.75, 1.5 - 0.5j, -1.0j, 2.25)
+    left_momentum = (5.0, 1.0, -2.0, 0.5)
+    right_momentum = (4.0, -0.5, 1.5, -1.0)
+
+    three_vector = model.vertex_component_expression(
+        0,
+        left,
+        right,
+        result_particle_id=21,
+        result_chirality=0,
+        left_momentum=left_momentum,
+        right_momentum=right_momentum,
+    )
+    three_vector_swapped = model.vertex_component_expression(
+        0,
+        right,
+        left,
+        result_particle_id=21,
+        result_chirality=0,
+        left_momentum=right_momentum,
+        right_momentum=left_momentum,
+    )
+    assert three_vector_swapped == pytest.approx(
+        tuple(-value for value in three_vector)
+    )
+
+    tensor = model.vertex_component_expression(
+        1,
+        left,
+        right,
+        result_particle_id=-21,
+        result_chirality=0,
+    )
+    tensor_swapped = model.vertex_component_expression(
+        1,
+        right,
+        left,
+        result_particle_id=-21,
+        result_chirality=0,
+    )
+    assert tensor_swapped == pytest.approx(tuple(-value for value in tensor))
+
+    tensor_vector = model.vertex_component_expression(
+        2,
+        tensor,
+        left,
+        result_particle_id=21,
+        result_chirality=0,
+    )
+    vector_tensor = model.vertex_component_expression(
+        3,
+        left,
+        tensor,
+        result_particle_id=21,
+        result_chirality=0,
+    )
+    assert vector_tensor == pytest.approx(tuple(-value for value in tensor_vector))
+
+    assert model.vertex_evaluation_equivalence(0).input_exchange_factor == (
+        -1.0,
+        0.0,
+    )
+    assert model.vertex_evaluation_equivalence(1).input_exchange_factor == (
+        -1.0,
+        0.0,
+    )
+    assert model.vertex_evaluation_equivalence(2).class_id == (
+        model.vertex_evaluation_equivalence(3).class_id
+    )
+    assert model.vertex_evaluation_equivalence(3).input_order == (1, 0)
+    assert model.vertex_evaluation_equivalence(3).factor == (-1.0, 0.0)
+    assert model.vertex_evaluation_equivalence(4).class_id == (
+        model.vertex_evaluation_equivalence(6).class_id
+    )
+    assert model.vertex_evaluation_equivalence(4).input_order == (1, 0)
+    assert model.vertex_evaluation_equivalence(6).input_order == (0, 1)
+    assert model.vertex_evaluation_equivalence(5).class_id == (
+        model.vertex_evaluation_equivalence(7).class_id
+    )
+    assert model.vertex_evaluation_equivalence(5).input_order == (1, 0)
+    assert model.vertex_evaluation_equivalence(7).input_order == (0, 1)
+    assert model.vertex_evaluation_equivalence(21).class_id == (
+        model.vertex_evaluation_equivalence(22).class_id
+    )
+    assert model.vertex_evaluation_equivalence(21).input_order == (0, 1)
+    assert model.vertex_evaluation_equivalence(22).input_order == (1, 0)
+    assert model.vertex_evaluation_equivalence(18).class_id == (
+        model.vertex_evaluation_equivalence(19).class_id
+    )
+    assert model.vertex_evaluation_equivalence(18).input_order == (0, 1)
+    assert model.vertex_evaluation_equivalence(19).input_order == (1, 0)
+
+
+def test_builtin_higgs_vector_kernel_orientations_are_exact_aliases() -> None:
+    model = BuiltinSMModel()
+    scalar = (1.25 - 0.75j,)
+    vector = (2.0 + 0.5j, -1.0j, 0.25 - 0.5j, -3.0)
+    coupling = (model.mass(23) * model.weak_coupling_over_cosine(), 0.0)
+
+    scalar_vector = model.vertex_component_expression(
+        18,
+        scalar,
+        vector,
+        result_particle_id=23,
+        result_chirality=0,
+        coupling=coupling,
+    )
+    vector_scalar = model.vertex_component_expression(
+        19,
+        vector,
+        scalar,
+        result_particle_id=23,
+        result_chirality=0,
+        coupling=coupling,
+    )
+
+    assert vector_scalar == pytest.approx(scalar_vector, rel=0.0, abs=0.0)
+
+
+@pytest.mark.parametrize("kind,result_particle_id", ((10, 6), (11, -6)))
+@pytest.mark.parametrize("chirality", (-1, 1))
+def test_builtin_charged_current_embeds_weyl_input_in_massive_dirac_output(
+    kind: int,
+    result_particle_id: int,
+    chirality: int,
+) -> None:
+    model = BuiltinSMModel()
+    fermion = (1.25 - 0.5j, -0.75 + 2.0j)
+    vector = (2.0, -1.0j, 0.5 + 0.25j, -3.0)
+    coupling = (0.7 - 0.1j, -0.4 + 0.2j)
+    padded = (
+        (0j, 0j, *fermion)
+        if chirality == -1
+        else (*fermion, 0j, 0j)
+    )
+
+    mixed = model.vertex_component_expression(
+        kind,
+        fermion,
+        vector,
+        result_particle_id=result_particle_id,
+        result_chirality=0,
+        left_chirality=chirality,
+        coupling=coupling,
+    )
+    dirac = model.vertex_component_expression(
+        kind,
+        padded,
+        vector,
+        result_particle_id=result_particle_id,
+        result_chirality=0,
+        coupling=coupling,
+    )
+
+    assert mixed == pytest.approx(dirac)
+
+
+def test_model_builtin_compiles_to_canonical_records_without_replacing_path() -> None:
+    compiled = compile_model_source("built-in-sm", use_cache=False)
+
+    assert compiled.name == "built-in-sm"
+    assert len(compiled.ir.particles) == 38
+    assert len(compiled.ir.vertex_terms) == 211
+    assert compiled.ir.oriented_kernels == ()
+    assert compiled.source["kind"] == "built-in-sm"
+    assert compiled.source["source_name"] is None
+
+
+def test_model_builtin_public_name_has_no_legacy_alias() -> None:
+    assert models.BuiltinSMModel is BuiltinSMModel
+    assert not hasattr(models, "AmplicolSMLeadingColorModel")
+
+
+def test_shared_model_contract_has_no_builtin_sm_pdg_fallbacks() -> None:
+    generic = Model(name="generic-model-contract")
+
+    assert issubclass(BuiltinSMModel, BuiltinModel)
+    assert not issubclass(BuiltinModel, BuiltinSMModel)
+    with pytest.raises(NotImplementedError, match="massless adjoint-vector role"):
+        generic.is_massless_adjoint_vector(21)
+    with pytest.raises(NotImplementedError, match="fundamental colored-fermion role"):
+        generic.is_fundamental_colored_fermion(1)
+    with pytest.raises(NotImplementedError, match="propagator lowering"):
+        generic.propagator_lowering_rule(21)
+    assert not generic.global_helicity_flip_equivalence_is_proven(
+        (Vertex(0, (1, -1, 21)),)
+    )
+    assert not generic.pure_massless_adjoint_helicity_zero_rule_is_proven(
+        object(),
+        (Vertex(0, (21, 21, 21)),),
+    )
+
+
+def test_global_helicity_flip_proof_is_owned_by_the_builtin_model() -> None:
+    model = BuiltinSMModel()
+
+    assert model.global_helicity_flip_equivalence_is_proven(
+        (Vertex(0, (1, -1, 21)), Vertex(6, (1, 21, 1)))
+    )
+    assert not model.global_helicity_flip_equivalence_is_proven(
+        (Vertex(10, (1, -1, 22)),)
+    )
diff --git a/pyamplicol/tests/unit/test_model_loading.py b/pyamplicol/tests/unit/test_model_loading.py
new file mode 100644
index 0000000000..b0128fd616
--- /dev/null
+++ b/pyamplicol/tests/unit/test_model_loading.py
@@ -0,0 +1,638 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import os
+import sys
+from copy import deepcopy
+from pathlib import Path
+
+import pytest
+
+import pyamplicol
+from pyamplicol._internal.physics.symbols import symbols
+from pyamplicol.models import compiler_symbolica as _sym
+from pyamplicol.models._physics_ir import ContractionIR
+from pyamplicol.models.contracts import (
+    DEFAULT_FEYNMAN_PROPAGATOR_SOURCE,
+    MODEL_SUPPLIED_PROPAGATOR_SOURCE,
+    CompiledClosureContractionRecord,
+    CompiledCouplingRecord,
+    CompiledDirectContractionRecord,
+    CompiledModelIR,
+    CompiledParticleRecord,
+)
+from pyamplicol.models.loading import (
+    ModelCompileOptions,
+    _classify_external_propagators,
+    _load_external_model,
+    _loader_restriction_name,
+    _model_compiler_source_paths,
+    _require_ufo_model_loader,
+    _sanitized_model_environment,
+    _source_digest,
+)
+
+
+class _SerializedModel:
+    propagators: tuple[object, ...] = ()
+
+    def wrap_indices_in_lorentz_structures(self) -> None:
+        pass
+
+    def to_json(self, _look: object) -> str:
+        return '{"name":"synthetic","propagators":[]}'
+
+
+@pytest.mark.parametrize(
+    "source",
+    (
+        "x+1",
+        "x^(1/2)",
+        "sqrt(x)",
+        "2*UFO::{}::aS^(1/2)*𝜋^(1/2)",
+        "x^(1/3)",
+    ),
+)
+def test_ufo_sqrt_normalization_is_one_shot_and_idempotent(source: str) -> None:
+    from symbolica import Expression
+    from ufo_model_loader import symbolica_processing
+
+    expression = Expression.parse(source)
+    expected = expression.to_canonical_string()
+
+    normalized = symbolica_processing.replace_from_sqrt(expression)
+    normalized_again = symbolica_processing.replace_from_sqrt(normalized)
+
+    normalized_text = normalized.to_canonical_string()
+    assert "sqrt(" not in normalized_text
+    if source != "sqrt(x)":
+        assert normalized_text == expected
+    assert normalized_again.to_canonical_string() == normalized_text
+
+
+def test_ufo_standard_cmath_normalization_needs_no_runtime_patch() -> None:
+    from ufo_model_loader import model, symbolica_processing
+
+    original_processing_parse = symbolica_processing.parse_python_expression_safe
+    original_model_parse = model.parse_python_expression_safe
+
+    with _sanitized_model_environment():
+        assert model.parse_python_expression_safe is (
+            symbolica_processing.parse_python_expression_safe
+        )
+        normalized = symbolica_processing.parse_python_expression_safe(
+            "cmath.sin(x) + cmath.cos(x) + cmath.asin(y) + cmath.acos(y)"
+        ).to_canonical_string()
+        assert "cmath" not in normalized
+        assert all(f"{name}(" in normalized for name in ("sin", "cos", "asin", "acos"))
+
+    assert (
+        symbolica_processing.parse_python_expression_safe is original_processing_parse
+    )
+    assert model.parse_python_expression_safe is original_model_parse
+
+    try:
+        with _sanitized_model_environment():
+            raise RuntimeError("scope exit")
+    except RuntimeError as error:
+        assert str(error) == "scope exit"
+    assert (
+        symbolica_processing.parse_python_expression_safe is original_processing_parse
+    )
+    assert model.parse_python_expression_safe is original_model_parse
+
+
+@pytest.mark.parametrize("version", ["1.0.0", "1.0.1", "1.1.0", "1.0.0+local"])
+def test_ufo_loader_accepts_supported_releases(monkeypatch, version: str) -> None:
+    monkeypatch.setattr(
+        "pyamplicol.models.loading._distribution_version", lambda *_: version
+    )
+    _require_ufo_model_loader()
+
+
+@pytest.mark.parametrize("version", ["not installed", "0.1.8", "0.2.0", "1.0.0rc1"])
+def test_ufo_loader_rejects_unsupported_versions_before_loading(
+    monkeypatch, version: str
+) -> None:
+    monkeypatch.setattr(
+        "pyamplicol.models.loading._distribution_version", lambda *_: version
+    )
+    with pytest.raises(RuntimeError, match=r"1\.0\.0 or newer"):
+        _load_external_model(Path("unused.json"), options=ModelCompileOptions())
+
+
+def test_all_packaged_ufo_sm_parameter_expressions_normalize_once() -> None:
+    from ufo_model_loader import symbolica_processing
+
+    source = (
+        Path(pyamplicol.__file__).parent
+        / "assets"
+        / "models"
+        / "json"
+        / "sm"
+        / "sm.json"
+    )
+    payload = json.loads(source.read_text(encoding="utf-8"))
+    expressions = [
+        parameter["expression"]
+        for parameter in payload["parameters"]
+        if parameter["expression"] is not None
+    ]
+
+    with _sanitized_model_environment():
+        normalized = [
+            symbolica_processing.parse_python_expression_safe(expression)
+            for expression in expressions
+        ]
+
+    assert len(normalized) == len(expressions)
+    assert all(expression.to_canonical_string() for expression in normalized)
+
+
+def test_model_loading_sanitizes_historical_scalar_environment(
+    monkeypatch,
+) -> None:
+    from ufo_model_loader import commands
+
+    monkeypatch.setenv("UFO_SCALARS_MODEL_N_SCALARS", "91")
+    monkeypatch.setenv("UFO_GRAVITY_MODEL_N_POINT_INTERACTIONS", "3,4")
+    previous_dont_write_bytecode = sys.dont_write_bytecode
+    seen: dict[str, str | bool | None] = {}
+
+    def fake_load_model(*_args, **_kwargs):
+        seen["scalars"] = os.environ.get("UFO_SCALARS_MODEL_N_SCALARS")
+        seen["gravity"] = os.environ.get("UFO_GRAVITY_MODEL_N_POINT_INTERACTIONS")
+        seen["dont_write_bytecode"] = sys.dont_write_bytecode
+        return _SerializedModel(), {"lam": 1.0 + 2.0j}
+
+    monkeypatch.setattr(commands, "load_model", fake_load_model)
+    payload = _load_external_model(
+        Path("synthetic.json"),
+        options=ModelCompileOptions(),
+    )
+
+    assert seen == {
+        "scalars": None,
+        "gravity": None,
+        "dont_write_bytecode": True,
+    }
+    assert sys.dont_write_bytecode is previous_dont_write_bytecode
+    assert os.environ["UFO_SCALARS_MODEL_N_SCALARS"] == "91"
+    assert os.environ["UFO_GRAVITY_MODEL_N_POINT_INTERACTIONS"] == "3,4"
+    assert payload["parameter_card"] == {"lam": [1.0, 2.0]}
+
+
+def test_external_propagator_classification_uses_expressions_not_names() -> None:
+    from ufo_model_loader.commands import load_model
+
+    source = (
+        Path(pyamplicol.__file__).parent
+        / "assets"
+        / "models"
+        / "json"
+        / "scalars"
+        / "scalars.json"
+    )
+    with _sanitized_model_environment():
+        model, _parameter_card = load_model(
+            str(source),
+            None,
+            True,
+            wrap_indices_in_lorentz_structures=False,
+        )
+    propagator = model.propagators[0]
+    propagator.name = "renamed_without_a_default_suffix"
+
+    assert _classify_external_propagators(model)[propagator.particle.name] == (
+        DEFAULT_FEYNMAN_PROPAGATOR_SOURCE
+    )
+
+    propagator.name = "custom_propFeynman"
+    propagator.numerator += 1
+
+    assert _classify_external_propagators(model)[propagator.particle.name] == (
+        MODEL_SUPPLIED_PROPAGATOR_SOURCE
+    )
+
+
+def test_restriction_does_not_reclassify_loader_default_propagators() -> None:
+    from ufo_model_loader.commands import load_model
+
+    source = (
+        Path(pyamplicol.__file__).parent
+        / "assets"
+        / "models"
+        / "json"
+        / "sm"
+        / "sm.json"
+    )
+    with _sanitized_model_environment():
+        model, _parameter_card = load_model(
+            str(source),
+            None,
+            True,
+            wrap_indices_in_lorentz_structures=False,
+        )
+
+    assert set(_classify_external_propagators(model).values()) == {
+        DEFAULT_FEYNMAN_PROPAGATOR_SOURCE
+    }
+
+
+def test_runtime_domain_symbols_do_not_redefine_symbolica_attributes() -> None:
+    _sym._ensure_symbolica()
+    complex_symbol = symbols.runtime_domain(
+        "synthetic",
+        "shared_parameter",
+        "complex",
+    )
+    real_symbol = symbols.runtime_domain(
+        "synthetic",
+        "shared_parameter",
+        "real",
+    )
+    imaginary_symbol = symbols.runtime_domain(
+        "synthetic",
+        "shared_parameter",
+        "imaginary",
+    )
+
+    assert complex_symbol != real_symbol
+    assert complex_symbol != imaginary_symbol
+    assert real_symbol.is_real()
+    assert (-1j * imaginary_symbol).is_real()
+
+
+def test_model_symbol_registry_preserves_identity_and_is_collision_resistant() -> None:
+    _sym._ensure_symbolica()
+    model_symbols = symbols.model("sm")
+
+    assert model_symbols.namespace == "model_sm"
+    assert model_symbols.symbol("MZ") == model_symbols.expression("UFO::MZ")
+    assert model_symbols.symbol("MZ") != model_symbols.symbol("mz")
+    assert "UFO::" not in model_symbols.expression_string("UFO::MZ + UFO::aS")
+    assert symbols.model("SM-v1").namespace != symbols.model("SM v1").namespace
+
+
+def test_runtime_model_parameter_uses_the_declared_symbol_owner() -> None:
+    _sym._ensure_symbolica()
+
+    assert symbols.runtime_model_parameter("sm", "MZ") == symbols.model("sm").symbol(
+        "MZ"
+    )
+    assert symbols.runtime_model_parameter(
+        "sm", "derived_coupling_81"
+    ) == symbols.derived_coupling("sm", 81)
+
+
+def test_compiled_model_rejects_process_global_ufo_scalar_symbols() -> None:
+    with pytest.raises(ValueError, match="process-global UFO symbol"):
+        CompiledModelIR(
+            name="synthetic",
+            orders=(),
+            parameters=(),
+            particles=(),
+            couplings=(
+                CompiledCouplingRecord(
+                    name="GC_1",
+                    expression="UFO::aS",
+                    resolved_expression="UFO::aS",
+                    value=(1.0, 0.0),
+                    orders=(),
+                ),
+            ),
+            propagators=(),
+            vertex_terms=(),
+            oriented_kernels=(),
+            direct_contractions=(),
+            closure_contractions=(),
+        )
+
+
+def test_compiled_model_rejects_non_involutive_particle_identity() -> None:
+    particle = CompiledParticleRecord(
+        name="psi",
+        antiname="psi_bar",
+        pdg_code=700_001,
+        spin=2,
+        color=3,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+    with pytest.raises(ValueError, match="absent antiparticle"):
+        CompiledModelIR(
+            name="invalid-particle-pair",
+            orders=(),
+            parameters=(),
+            particles=(particle,),
+            couplings=(),
+            propagators=(),
+            vertex_terms=(),
+            oriented_kernels=(),
+            direct_contractions=(),
+            closure_contractions=(),
+        )
+
+
+def test_compiled_particle_role_metadata_round_trips() -> None:
+    particle = CompiledParticleRecord(
+        name="x",
+        antiname="x",
+        pdg_code=700_010,
+        spin=3,
+        color=8,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+    model = CompiledModelIR(
+        name="role-round-trip",
+        orders=(),
+        parameters=(),
+        particles=(particle,),
+        couplings=(),
+        propagators=(),
+        vertex_terms=(),
+        oriented_kernels=(),
+        direct_contractions=(),
+        closure_contractions=(),
+    )
+
+    restored = CompiledModelIR.from_dict(model.to_dict()).particles[0]
+
+    assert restored.statistics == "boson"
+    assert restored.wavefunction_family == "vector"
+    assert restored.color_role == "adjoint"
+    assert restored.self_conjugate is True
+    assert restored.source_orientation == "self-conjugate"
+
+
+def _compiled_scalar_contraction_model() -> CompiledModelIR:
+    particle = CompiledParticleRecord(
+        name="phi",
+        antiname="phi_bar",
+        pdg_code=700_020,
+        spin=1,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=1.0,
+        quantum_numbers=(("electric_charge", "1"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+    antiparticle = CompiledParticleRecord(
+        name="phi_bar",
+        antiname="phi",
+        pdg_code=-700_020,
+        spin=1,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=-1.0,
+        quantum_numbers=(("electric_charge", "-1"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+    scalar = ContractionIR(
+        name="scalar",
+        left_basis="scalar",
+        right_basis="scalar",
+        coefficients=((1.0, 0.0),),
+    )
+    return CompiledModelIR(
+        name="contraction-round-trip",
+        orders=(),
+        parameters=(),
+        particles=(particle, antiparticle),
+        couplings=(),
+        propagators=(),
+        vertex_terms=(),
+        oriented_kernels=(),
+        direct_contractions=(
+            CompiledDirectContractionRecord(
+                left_particle="phi",
+                left_chirality=0,
+                right_particle="phi_bar",
+                right_chirality=0,
+                contraction_ir=scalar,
+            ),
+        ),
+        closure_contractions=(
+            CompiledClosureContractionRecord(
+                particle="phi",
+                chirality=0,
+                contraction_ir=scalar,
+            ),
+        ),
+    )
+
+
+def test_compiled_contraction_records_round_trip_strictly() -> None:
+    model = _compiled_scalar_contraction_model()
+
+    restored = CompiledModelIR.from_dict(model.to_dict())
+
+    assert restored.direct_contractions == model.direct_contractions
+    assert restored.closure_contractions == model.closure_contractions
+
+    missing = model.to_dict()
+    del missing["direct_contractions"]
+    with pytest.raises(
+        ValueError,
+        match="missing required field 'direct_contractions'",
+    ):
+        CompiledModelIR.from_dict(missing)
+
+    unknown = model.to_dict()
+    direct = unknown["direct_contractions"]
+    assert isinstance(direct, list)
+    assert isinstance(direct[0], dict)
+    direct[0]["inferred_from_dimension"] = True
+    with pytest.raises(ValueError, match="unknown fields"):
+        CompiledModelIR.from_dict(unknown)
+
+
+def test_compiled_contraction_records_reject_duplicate_and_missing_selectors() -> None:
+    model = _compiled_scalar_contraction_model()
+    duplicate = model.to_dict()
+    direct = duplicate["direct_contractions"]
+    assert isinstance(direct, list)
+    direct.append(deepcopy(direct[0]))
+    with pytest.raises(ValueError, match="duplicate direct contraction selector"):
+        CompiledModelIR.from_dict(duplicate)
+
+    missing_particle = model.to_dict()
+    direct = missing_particle["direct_contractions"]
+    assert isinstance(direct, list)
+    assert isinstance(direct[0], dict)
+    direct[0]["right_particle"] = "absent"
+    with pytest.raises(ValueError, match="absent particle 'absent'"):
+        CompiledModelIR.from_dict(missing_particle)
+
+
+def test_compiled_contraction_records_reject_invalid_physics_contracts() -> None:
+    model = _compiled_scalar_contraction_model()
+
+    not_antiparticles = model.to_dict()
+    direct = not_antiparticles["direct_contractions"]
+    assert isinstance(direct, list)
+    assert isinstance(direct[0], dict)
+    direct[0]["right_particle"] = "phi"
+    with pytest.raises(ValueError, match="are not an antiparticle pair"):
+        CompiledModelIR.from_dict(not_antiparticles)
+
+    wrong_dimension = model.to_dict()
+    direct = wrong_dimension["direct_contractions"]
+    assert isinstance(direct, list)
+    assert isinstance(direct[0], dict)
+    contraction = direct[0]["contraction_ir"]
+    assert isinstance(contraction, dict)
+    contraction["coefficients"] = [[1.0, 0.0], [1.0, 0.0]]
+    with pytest.raises(
+        ValueError,
+        match="2 coefficients for current dimensions 1 and 1",
+    ):
+        CompiledModelIR.from_dict(wrong_dimension)
+
+    wrong_chirality = model.to_dict()
+    direct = wrong_chirality["direct_contractions"]
+    assert isinstance(direct, list)
+    assert isinstance(direct[0], dict)
+    contraction = direct[0]["contraction_ir"]
+    assert isinstance(contraction, dict)
+    contraction["chirality_relation"] = "opposite"
+    with pytest.raises(ValueError, match="violates opposite chirality relation"):
+        CompiledModelIR.from_dict(wrong_chirality)
+
+    non_scalar_closure = model.to_dict()
+    closure = non_scalar_closure["closure_contractions"]
+    assert isinstance(closure, list)
+    assert isinstance(closure[0], dict)
+    contraction = closure[0]["contraction_ir"]
+    assert isinstance(contraction, dict)
+    contraction["name"] = "not-a-scalar-projection"
+    with pytest.raises(ValueError, match="one-component scalar projection"):
+        CompiledModelIR.from_dict(non_scalar_closure)
+
+
+def test_model_cache_inputs_are_content_based(tmp_path: Path) -> None:
+    left = tmp_path / "left" / "model"
+    right = tmp_path / "right" / "model"
+    left.mkdir(parents=True)
+    right.mkdir(parents=True)
+    for root in (left, right):
+        (root / "__init__.py").write_text("VALUE = 1\n", encoding="utf-8")
+        (root / "particles.py").write_text("PARTICLES = []\n", encoding="utf-8")
+
+    assert _source_digest("ufo", left) == _source_digest("ufo", right)
+
+    first = tmp_path / "first restriction.dat"
+    second = tmp_path / "second restriction.dat"
+    first.write_text("BLOCK MASS\n", encoding="utf-8")
+    second.write_text("BLOCK MASS\n", encoding="utf-8")
+    first_payload = ModelCompileOptions(restriction=str(first)).canonical_payload()
+    second_payload = ModelCompileOptions(restriction=str(second)).canonical_payload()
+    assert first_payload == second_payload
+    assert str(tmp_path) not in repr(first_payload)
+
+
+def test_restriction_paths_are_adapted_to_loader_names(tmp_path: Path) -> None:
+    ufo = tmp_path / "ufo"
+    ufo.mkdir()
+    ufo_restriction = ufo / "restrict_no_widths.dat"
+    ufo_restriction.write_text("BLOCK DECAY\n", encoding="ascii")
+    serialized = tmp_path / "sm.json"
+    serialized.write_text("{}", encoding="ascii")
+    json_restriction = tmp_path / "restrict_no_widths.json"
+    json_restriction.write_text("{}", encoding="ascii")
+
+    assert _loader_restriction_name(ufo, "default") is None
+    assert _loader_restriction_name(ufo, "none") == "full"
+    assert _loader_restriction_name(ufo, str(ufo_restriction)) == "no_widths"
+    assert _loader_restriction_name(serialized, str(json_restriction)) == "no_widths"
+
+
+def test_restriction_paths_must_follow_loader_layout(tmp_path: Path) -> None:
+    ufo = tmp_path / "ufo"
+    ufo.mkdir()
+    misplaced = tmp_path / "restrict_default.dat"
+    misplaced.write_text("BLOCK MASS\n", encoding="ascii")
+    malformed = ufo / "default.dat"
+    malformed.write_text("BLOCK MASS\n", encoding="ascii")
+
+    with pytest.raises(ValueError, match="stored next to"):
+        _loader_restriction_name(ufo, str(misplaced))
+    with pytest.raises(ValueError, match="must be named"):
+        _loader_restriction_name(ufo, str(malformed))
+
+
+def test_model_compiler_fingerprint_covers_all_lowering_sources() -> None:
+    package_root = Path(pyamplicol.__file__).resolve().parent
+    source_paths = _model_compiler_source_paths()
+    relative_paths = {
+        path.relative_to(package_root).as_posix() for path in source_paths
+    }
+
+    model_sources = {
+        f"models/{path.name}" for path in (package_root / "models").glob("*.py")
+    }
+    assert model_sources <= relative_paths
+    assert {
+        "_internal/physics/parameters.py",
+        "_internal/physics/symbols.py",
+        "_internal/physics/types.py",
+        "processes/core_syntax.py",
+    } <= relative_paths
+
+
+def test_model_cache_identity_includes_symbolica_serialization_abi(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    from pyamplicol.models import loading
+
+    source = tmp_path / "model.json"
+    source.write_text("{}", encoding="ascii")
+    cache = tmp_path / "cache"
+    _digest, first_fingerprint, first_path = loading._compilation_cache_identity(
+        "json",
+        source,
+        options=ModelCompileOptions(),
+        cache_dir=cache,
+    )
+
+    monkeypatch.setattr(
+        loading,
+        "SYMBOLICA_SERIALIZATION_ABI",
+        "symbolica-test-serialization-v2",
+    )
+    _digest, second_fingerprint, second_path = loading._compilation_cache_identity(
+        "json",
+        source,
+        options=ModelCompileOptions(),
+        cache_dir=cache,
+    )
+
+    assert (
+        first_fingerprint["symbolica_serialization_abi"]
+        != (second_fingerprint["symbolica_serialization_abi"])
+    )
+    assert first_path != second_path
diff --git a/pyamplicol/tests/unit/test_model_source_prepared_compile.py b/pyamplicol/tests/unit/test_model_source_prepared_compile.py
new file mode 100644
index 0000000000..54add9c90c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_model_source_prepared_compile.py
@@ -0,0 +1,145 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol import ModelSource
+from pyamplicol.api import ModelError
+from pyamplicol.config import EvaluatorBackend, EvaluatorConfig
+
+
+class _CompiledPayload:
+    name = "toy"
+    schema_version = 9
+    model_compiler_version = 13
+    conversion_seconds = 0.1
+
+    def __init__(self, prepared_backend: str | None = None) -> None:
+        self.source = {"kind": "built-in-sm"}
+        self.capabilities = {"particle_count": 1}
+        self.parameter_defaults: dict[str, tuple[float, float]] = {}
+        self.issues: tuple[object, ...] = ()
+        self.phase_timings = {"total": 0.1}
+        self.prepared_backend = prepared_backend
+
+
+def test_model_source_compile_can_prepare_and_return_the_bundle_handle(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol.models import loading, prepared_compile
+
+    base_payload = _CompiledPayload()
+    prepared_payload = _CompiledPayload(prepared_backend="asm")
+    compilation_calls: list[tuple[object, dict[str, object]]] = []
+    preparation_calls: list[tuple[object, Path, EvaluatorConfig]] = []
+    load_calls: list[Path] = []
+
+    def compile_model_source(source: object, **options: object) -> object:
+        compilation_calls.append((source, options))
+        return base_payload
+
+    def prepare_model_bundle(
+        payload: object,
+        output: Path,
+        *,
+        evaluator: EvaluatorConfig,
+    ) -> object:
+        preparation_calls.append((payload, output, evaluator))
+        return SimpleNamespace(output=output)
+
+    def load_compiled_model(path: Path) -> object:
+        load_calls.append(path)
+        return prepared_payload
+
+    monkeypatch.setattr(loading, "compile_model_source", compile_model_source)
+    monkeypatch.setattr(loading, "load_compiled_model", load_compiled_model)
+    monkeypatch.setattr(
+        prepared_compile,
+        "prepare_model_bundle",
+        prepare_model_bundle,
+    )
+    evaluator = EvaluatorConfig(backend=EvaluatorBackend.ASM)
+    output = tmp_path / "toy.pyamplicol-model"
+
+    compiled = ModelSource.built_in_sm().compile(
+        cache_dir=tmp_path / "cache",
+        use_cache=False,
+        prepared_output=output,
+        evaluator=evaluator,
+    )
+
+    assert compilation_calls == [
+        (
+            "built-in-sm",
+            {
+                "restriction": "default",
+                "simplify": True,
+                "cache_dir": (tmp_path / "cache").resolve(),
+                "use_cache": False,
+                "require_supported": True,
+            },
+        )
+    ]
+    assert preparation_calls == [(base_payload, output.resolve(), evaluator)]
+    assert load_calls == [output.resolve()]
+    assert compiled.is_prepared
+    assert compiled.prepared_backend == "asm"
+
+
+def test_model_source_compile_default_does_not_prepare_kernels(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol.models import loading, prepared_compile
+
+    monkeypatch.setattr(
+        loading,
+        "compile_model_source",
+        lambda *args, **kwargs: _CompiledPayload(),
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "prepare_model_bundle",
+        lambda *_args, **_kwargs: pytest.fail(
+            "default ModelSource.compile must remain IR-only"
+        ),
+    )
+
+    compiled = ModelSource.built_in_sm().compile()
+
+    assert not compiled.is_prepared
+
+
+@pytest.mark.parametrize(
+    ("prepared_output", "evaluator", "message"),
+    (
+        (
+            Path("toy.pyamplicol-model"),
+            None,
+            "requires both prepared_output",
+        ),
+        (
+            None,
+            EvaluatorConfig(),
+            "requires both prepared_output",
+        ),
+        (
+            Path("toy.json"),
+            EvaluatorConfig(),
+            "must end with '.pyamplicol-model'",
+        ),
+    ),
+)
+def test_model_source_compile_rejects_incomplete_preparation_requests(
+    prepared_output: Path | None,
+    evaluator: EvaluatorConfig | None,
+    message: str,
+) -> None:
+    with pytest.raises(ModelError, match=message):
+        ModelSource.built_in_sm().compile(
+            prepared_output=prepared_output,
+            evaluator=evaluator,
+        )
diff --git a/pyamplicol/tests/unit/test_model_tensors.py b/pyamplicol/tests/unit/test_model_tensors.py
new file mode 100644
index 0000000000..ef9db47c45
--- /dev/null
+++ b/pyamplicol/tests/unit/test_model_tensors.py
@@ -0,0 +1,353 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import pytest
+
+from pyamplicol.models.compiler_entry import (
+    _annotate_oriented_kernel_color_projections,
+)
+from pyamplicol.models.contracts import (
+    CompiledOrientedKernel,
+    CompiledParticleRecord,
+    CompiledVertexTerm,
+)
+from pyamplicol.models.tensors import (
+    _materialized_color_components,
+    classify_trilinear_color_expression,
+    normalize_color_expression,
+    normalize_lorentz_expression,
+    project_trilinear_color_expression,
+)
+from pyamplicol.processes.model import ModelParticleCatalog
+
+
+def _particle(name: str, color: int) -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=name,
+        pdg_code=9000001,
+        spin=1,
+        color=color,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def test_model_tensors_reject_unsupported_colored_representations() -> None:
+    with pytest.raises(ValueError, match="unsupported UFO color representation 6"):
+        normalize_color_expression("1", [6, 1, 1])
+
+    with pytest.raises(ValueError, match="particle 'sextet'"):
+        ModelParticleCatalog("synthetic", (_particle("sextet", 6),))
+
+
+def test_model_tensors_keep_supported_singlet_projection() -> None:
+    normalized = normalize_color_expression("1", [1, 1, 1])
+    assert normalized.expression == "1"
+
+
+@pytest.mark.parametrize(
+    ("source", "spins", "factory", "indices"),
+    (
+        (
+            "UFO::Metric(UFO::idx(1,1),UFO::idx(1,2))",
+            (3, 3),
+            "metric",
+            ("ufo_l_1_1", "ufo_l_1_2"),
+        ),
+        (
+            "UFO::Gamma(UFO::idx(1,1),UFO::idx(1,2),UFO::idx(1,3))",
+            (3, 2, 2),
+            "dirac_gamma",
+            ("ufo_s_1_2", "ufo_s_1_3", "ufo_l_1_1"),
+        ),
+        (
+            "UFO::Gamma5(UFO::idx(1,1),UFO::idx(1,2))",
+            (2, 2),
+            "gamma5",
+            ("ufo_s_1_1", "ufo_s_1_2"),
+        ),
+        (
+            "UFO::ProjM(UFO::idx(1,1),UFO::idx(1,2))",
+            (2, 2),
+            "projp",
+            ("ufo_s_1_1", "ufo_s_1_2"),
+        ),
+        (
+            "UFO::ProjP(UFO::idx(1,1),UFO::idx(1,2))",
+            (2, 2),
+            "projm",
+            ("ufo_s_1_1", "ufo_s_1_2"),
+        ),
+        (
+            "UFO::Identity(UFO::idx(1,1),UFO::idx(1,2))",
+            (2, 2),
+            "identity",
+            ("ufo_s_1_2", "ufo_s_1_1"),
+        ),
+    ),
+)
+def test_lorentz_tensor_factories_preserve_ufo_index_conventions(
+    source: str,
+    spins: tuple[int, ...],
+    factory: str,
+    indices: tuple[str, ...],
+) -> None:
+    from symbolica import E
+    from symbolica.community.tensor import Representation, TensorExpression
+
+    if factory == "metric":
+        tensor = TensorExpression.g(Representation.mink(4))
+    elif factory == "identity":
+        tensor = TensorExpression.g(Representation.bis(4))
+    else:
+        tensor = getattr(TensorExpression, factory)(4)
+    expected = tensor(*indices).simplify_algebra(color=False).to_expression()
+
+    normalized = normalize_lorentz_expression(source, spins)
+
+    assert E(normalized.expression) == expected
+
+
+def test_vertex_spinor_slots_follow_the_standard_ufo_fermion_order() -> None:
+    """Vertices index a fermion pair as MadGraph's SM, Gamma(3,2,1) for FFV1;
+    propagators keep their own order."""
+    from symbolica import E
+
+    def gamma(first: int, second: int, *, vertex: bool = True) -> object:
+        return E(
+            normalize_lorentz_expression(
+                f"UFO::Gamma(UFO::idx(1,3),UFO::idx(1,{first}),UFO::idx(1,{second}))",
+                (2, 2, 3),
+                vertex=vertex,
+            ).expression
+        )
+
+    assert gamma(2, 1) == gamma(1, 2, vertex=False)
+    assert gamma(2, 1) != gamma(2, 1, vertex=False)
+
+
+def test_lorentz_clifford_contraction_preserves_4d_normalization() -> None:
+    from symbolica import E
+
+    normalized = normalize_lorentz_expression(
+        "UFO::Gamma(UFO::dummy(1),UFO::idx(1,1),UFO::dummy(2))*"
+        "UFO::Gamma(UFO::dummy(1),UFO::dummy(2),UFO::idx(1,2))",
+        (2, 2),
+    )
+    identity = normalize_lorentz_expression(
+        "UFO::Identity(UFO::idx(1,1),UFO::idx(1,2))",
+        (2, 2),
+    )
+
+    assert E(normalized.expression) == 4 * E(identity.expression)
+
+
+def test_color_contraction_substitutes_su3_casimir() -> None:
+    normalized = normalize_color_expression(
+        "UFO::f(1,-1,-2)*UFO::f(2,-1,-2)",
+        (8, 8),
+    )
+
+    assert _materialized_color_components(normalized.expression, (1, 2)) == {
+        (left, right): complex(3 * (left == right))
+        for left in range(8)
+        for right in range(8)
+    }
+
+
+@pytest.mark.parametrize(
+    ("right", "expected"), (("-1,-2,-3", "24"), ("-3,-2,-1", "-24"))
+)
+def test_closed_color_contraction_preserves_structure_constant_sign(
+    right: str, expected: str
+) -> None:
+    normalized = normalize_color_expression(
+        f"UFO::f(-1,-2,-3)*UFO::f({right})",
+        (),
+    )
+
+    assert normalized.expression == expected
+
+
+def test_materialized_adjoint_identity_preserves_physical_axis_order() -> None:
+    normalized = normalize_color_expression("UFO::Identity(1,2)", (8, 8))
+
+    for order in ((1, 2), (2, 1)):
+        actual = _materialized_color_components(normalized.expression, order)
+        assert actual == {
+            (left, right): complex(left == right)
+            for left in range(8)
+            for right in range(8)
+        }
+
+
+@pytest.mark.parametrize("representations", ((3, -3), (-3, 3), (3, 3), (-3, -3)))
+def test_color_identity_preserves_physical_and_oriented_index_variance(
+    representations: tuple[int, int],
+) -> None:
+    from symbolica import E
+    from symbolica.community.tensor import Representation, as_tensor
+
+    normalized = normalize_color_expression("UFO::Identity(1,2)", representations)
+    fundamental = Representation.cof(3)
+    expected = {
+        (fundamental if color == 3 else fundamental.dual())(f"ufo_c_{leg}")
+        .to_expression()
+        .format_plain()
+        for leg, color in enumerate(representations, start=1)
+    }
+    actual = {
+        slot.to_expression().format_plain()
+        for slot in as_tensor(E(normalized.expression)).axes
+    }
+
+    assert actual == expected
+
+
+def test_materialized_color_generator_reorders_logical_axes_once() -> None:
+    normalized = normalize_color_expression("UFO::T(3,1,2)", (3, -3, 8))
+
+    original = _materialized_color_components(normalized.expression, (1, 2, 3))
+    permuted = _materialized_color_components(normalized.expression, (3, 1, 2))
+
+    assert len(original) == 72
+    assert any(value != 0 for value in original.values())
+    assert permuted == {
+        (adjoint, fundamental, antifundamental): value
+        for (fundamental, antifundamental, adjoint), value in original.items()
+    }
+
+
+def test_color_identity_rejects_unpaired_representations() -> None:
+    with pytest.raises(ValueError, match="identity requires dual representations"):
+        normalize_color_expression("UFO::Identity(1,2)", (3, 8))
+
+
+def test_materialized_color_scalar_has_no_open_axes() -> None:
+    normalize_color_expression("2", (1,))
+
+    assert _materialized_color_components("2", ()) == {(): 2 + 0j}
+
+
+def test_trilinear_color_projection_proves_scaled_permuted_generator() -> None:
+    normalized = normalize_color_expression("2*UFO::T(3,1,2)", [3, -3, 8])
+
+    assert project_trilinear_color_expression(
+        normalized.expression,
+        [3, -3, 8],
+    ) == ("fundamental-generator", 2.0 + 0.0j)
+
+
+def test_trilinear_color_projection_does_not_trust_ufo_source_spelling() -> None:
+    assert classify_trilinear_color_expression(
+        "1",
+        "UFO::T(3,1,2)",
+        [3, -3, 8],
+    ) == ("generic-tensor", 1.0 + 0.0j)
+
+
+def test_external_compiler_rejects_unimplemented_symmetric_color_tensor() -> None:
+    particles = tuple(
+        CompiledParticleRecord(
+            name=f"adjoint_{index}",
+            antiname=f"adjoint_{index}",
+            pdg_code=8_100_000 + index,
+            spin=3,
+            color=8,
+            mass="ZERO",
+            width="ZERO",
+            charge=0.0,
+            quantum_numbers=(("electric_charge", "0"),),
+            ghost_number=0,
+            propagating=True,
+            goldstoneboson=False,
+            propagator=None,
+        )
+        for index in range(3)
+    )
+    color = normalize_color_expression("UFO::d(1,2,3)", [8, 8, 8])
+    term = CompiledVertexTerm(
+        id=0,
+        vertex="symmetric-adjoint",
+        particles=tuple(particle.name for particle in particles),
+        color_index=0,
+        lorentz_index=0,
+        color_source="UFO::d(1,2,3)",
+        color_expression=color.expression,
+        lorentz_name="L",
+        lorentz_source="1",
+        lorentz_expression="1",
+        coupling="GC",
+        coupling_expression="1",
+        coupling_orders=(),
+    )
+    kernel = CompiledOrientedKernel(
+        kind=0,
+        term_id=0,
+        vertex=term.vertex,
+        particles=tuple(particle.name for particle in particles),
+        source_particle_legs=(0, 1, 2),
+        component_expressions=("1",),
+        coupling_expression="1",
+        coupling_orders=(),
+        runtime_parameters=(),
+        color_source=term.color_source,
+        color_expression=term.color_expression,
+    )
+
+    with pytest.raises(ValueError, match="unsupported trilinear color tensor"):
+        _annotate_oriented_kernel_color_projections((kernel,), particles, (term,))
+
+
+def test_oriented_identity_retains_the_exact_vertex_color_proof() -> None:
+    particles = (
+        _particle("anti", -3),
+        _particle("singlet", 1),
+        _particle("fund", 3),
+    )
+    color = normalize_color_expression("UFO::Identity(1,3)", [-3, 1, 3])
+    term = CompiledVertexTerm(
+        id=0,
+        vertex="identity",
+        particles=("anti", "singlet", "fund"),
+        color_index=0,
+        lorentz_index=0,
+        color_source="UFO::Identity(1,3)",
+        color_expression=color.expression,
+        lorentz_name="L",
+        lorentz_source="1",
+        lorentz_expression="1",
+        coupling="GC",
+        coupling_expression="1",
+        coupling_orders=(),
+    )
+    kernel = CompiledOrientedKernel(
+        kind=0,
+        term_id=0,
+        vertex=term.vertex,
+        particles=("fund", "singlet", "fund"),
+        source_particle_legs=(2, 1, 0),
+        component_expressions=("1",),
+        coupling_expression="1",
+        coupling_orders=(),
+        runtime_parameters=(),
+        color_source="oriented-identity",
+        color_expression="1",
+    )
+
+    (annotated,) = _annotate_oriented_kernel_color_projections(
+        (kernel,), particles, (term,)
+    )
+
+    assert annotated.color_projection_structure == "color-identity"
+    assert len(annotated.lc_color_transition_terms) == 1
+    witness = annotated.lc_color_transition_terms[0]
+    assert witness.component_operation == "inherit-left"
+    assert witness.input_permutation == (0, 1)
diff --git a/pyamplicol/tests/unit/test_native_direct_cpp_producer.py b/pyamplicol/tests/unit/test_native_direct_cpp_producer.py
new file mode 100644
index 0000000000..c34df34f2b
--- /dev/null
+++ b/pyamplicol/tests/unit/test_native_direct_cpp_producer.py
@@ -0,0 +1,635 @@
+# SPDX-License-Identifier: 0BSD
+"""Fail-closed contracts for the native compiled DirectApplication producer."""
+
+from __future__ import annotations
+
+import math
+import os
+import subprocess
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import pytest
+
+from pyamplicol._internal.physics.types import NativeEvaluationError
+from pyamplicol._internal.versions import (
+    NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+)
+from pyamplicol.evaluators.native_direct_cpp import (
+    NativeDirectCppArtifact,
+    NativeDirectCppCompiler,
+    NativeDirectCppSpec,
+    compile_native_direct_cpp,
+    compiler_from_symbolica_settings,
+    render_native_direct_cpp,
+)
+from pyamplicol.evaluators.native_direct_cpp import (
+    NativeDirectCppParameterKind as ParameterKind,
+)
+from pyamplicol.evaluators.symbolica_adapters import (
+    _CompiledComplexEvaluatorAdapter,
+    _native_direct_application_manifest,
+)
+from pyamplicol.evaluators.symbolica_settings import SymbolicaEvaluatorSettings
+from pyamplicol.generation.artifact_writer import _evaluator
+
+
+class _Evaluator:
+    def __init__(self, instructions: list[tuple[object, ...]]) -> None:
+        self.instructions = instructions
+
+    def get_instructions(self) -> tuple[list[tuple[object, ...]], int, list[complex]]:
+        return self.instructions, 2, [1j]
+
+    def save(self) -> bytes:
+        return b"retained-real-evaluator-state"
+
+
+def _spec(**changes: object) -> NativeDirectCppSpec:
+    values: dict[str, object] = {
+        "function_name": "retained_leaf",
+        "parameter_kinds": (
+            ParameterKind.COMPLEX_PLANE,
+            ParameterKind.REAL_SCALAR,
+        ),
+        "output_count": 1,
+        "target_triple": "aarch64-apple-darwin",
+        "cpu_features": ("neon",),
+        "simd_lane_width": 2,
+    }
+    values.update(changes)
+    return NativeDirectCppSpec(**values)  # type: ignore[arg-type]
+
+
+def test_real_instruction_stream_renders_plane_native_simd_and_scalar_tail() -> None:
+    evaluator = _Evaluator(
+        [
+            ("mul", ("temp", 0), [("param", 0), ("param", 0)], 0),
+            ("mul", ("temp", 1), [("param", 1), ("param", 1)], 2),
+            ("pow", ("temp", 1), ("temp", 1), -1, True),
+            ("add", ("out", 0), [("temp", 0), ("temp", 1)], 0),
+        ]
+    )
+
+    rendered = render_native_direct_cpp(evaluator, _spec())
+
+    assert rendered.instruction_count == 4
+    assert rendered.temporary_count == 2
+    assert rendered.input_plane_count == 2
+    assert rendered.scalar_input_count == 1
+    assert rendered.output_plane_count == 2
+    assert rendered.logical_stack_bytes == 96
+    assert rendered.target_triple == "aarch64-apple-darwin"
+    assert rendered.cpu_features == ("neon",)
+    assert rendered.simd_lane_width == 2
+    assert "_complexf64(" not in rendered.source
+    assert "using DirectVector = double __attribute__((vector_size(16)))" in (
+        rendered.source
+    )
+    assert "evaluate_direct_bundle<DirectVector>" in rendered.source
+    assert "evaluate_direct_bundle<double>" in rendered.source
+    assert "direct_real_scalar<Lane>(*scalars[0].value)" in rendered.source
+    assert 'return "aarch64-apple-darwin";' in rendered.source
+    assert 'return "neon";' in rendered.source
+
+
+def test_unknown_symbolica_operation_fails_without_dense_fallback() -> None:
+    evaluator = _Evaluator(
+        [
+            (
+                "fun",
+                ("out", 0),
+                "sqrt",
+                [],
+                [("param", 0)],
+                False,
+            )
+        ]
+    )
+
+    with pytest.raises(
+        NativeEvaluationError,
+        match=r"cannot lower Symbolica operation.*refusing a dense-row fallback",
+    ):
+        render_native_direct_cpp(evaluator, _spec())
+
+
+def test_exact_wavefunction_radical_renders_as_an_f64_constant() -> None:
+    symbolica = pytest.importorskip("symbolica")
+    momentum = symbolica.S("direct_radical_input")
+    evaluator = symbolica.E("1i/sqrt(2)*direct_radical_input").evaluator(
+        [momentum], iterations=0, n_cores=1, jit_compile=False
+    )
+    exact_state = evaluator.save()
+
+    rendered = render_native_direct_cpp(
+        evaluator,
+        _spec(parameter_kinds=(ParameterKind.COMPLEX_PLANE,)),
+    )
+
+    assert (
+        f"direct_constant<Lane>({math.sqrt(0.5).hex()}, {0.0.hex()})"
+        in rendered.source
+    )
+    assert "direct_multiply(" in rendered.source
+    assert evaluator.save() == exact_state
+
+
+def test_real_argument_and_stack_contracts_fail_closed() -> None:
+    inconsistent = _Evaluator(
+        [
+            ("mul", ("out", 0), [("param", 0), ("param", 0)], 2),
+        ]
+    )
+    with pytest.raises(NativeEvaluationError, match="metadata is inconsistent"):
+        render_native_direct_cpp(inconsistent, _spec())
+
+    bounded = _Evaluator(
+        [
+            ("mul", ("out", 0), [("param", 0), ("param", 0)], 0),
+        ]
+    )
+    with pytest.raises(NativeEvaluationError, match="bounded stack contract"):
+        render_native_direct_cpp(
+            bounded,
+            _spec(max_logical_stack_bytes=1),
+        )
+
+
+def test_compiler_settings_retain_cpp_and_asm_direct_flags() -> None:
+    compiler = compiler_from_symbolica_settings(
+        {
+            "compiled_inline_asm": "none",
+            "compiled_optimization_level": 3,
+            "compiled_native": True,
+            "compiler_path": "/usr/bin/c++",
+            "effective_compiler_flags": [
+                "-std=c++17",
+                "-fno-math-errno",
+            ],
+        }
+    )
+    assert compiler.executable == "/usr/bin/c++"
+    assert compiler.optimization_level == 3
+    assert compiler.native_arch is True
+    assert compiler.extra_flags == ("-fno-math-errno",)
+    assert compiler.timeout_seconds == 1800.0
+
+    asm_compiler = compiler_from_symbolica_settings(
+        {
+            "compiled_inline_asm": "default",
+            "compiled_optimization_level": 3,
+            "compiled_native": False,
+            "compiler_flags": ["-fno-math-errno"],
+        }
+    )
+    assert asm_compiler.optimization_level == 3
+    assert asm_compiler.native_arch is False
+    assert asm_compiler.extra_flags == ("-fno-math-errno",)
+    assert asm_compiler.timeout_seconds == 1800.0
+
+
+def test_native_direct_cpp_timeout_is_explicit_and_cleans_partial_output(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def timeout_run(
+        command: tuple[str, ...],
+        *,
+        timeout_seconds: float,
+    ) -> subprocess.CompletedProcess[str]:
+        Path(command[command.index("-o") + 1]).write_bytes(b"partial-library")
+        raise subprocess.TimeoutExpired(command, timeout_seconds)
+
+    monkeypatch.setattr(
+        "pyamplicol.evaluators.native_direct_cpp._run_native_compiler",
+        timeout_run,
+    )
+    output_library = tmp_path / "libretained_leaf.direct"
+
+    with pytest.raises(
+        NativeEvaluationError,
+        match=r"compilation exceeded its finite 7s timeout",
+    ):
+        compile_native_direct_cpp(
+            _Evaluator(
+                [
+                    ("mul", ("out", 0), [("param", 0), ("param", 0)], 0),
+                ]
+            ),
+            spec=_spec(),
+            compiler=NativeDirectCppCompiler(timeout_seconds=7.0),
+            output_source_path=tmp_path / "retained_leaf.direct.cpp",
+            output_library_path=output_library,
+        )
+
+    assert not output_library.exists()
+    assert not tuple(tmp_path.glob(".libretained_leaf.direct.tmp-*"))
+
+
+@pytest.mark.skipif(os.name != "posix", reason="POSIX process-group contract")
+def test_native_direct_cpp_failure_kills_descendants_before_releasing_gate(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    compiler_script = tmp_path / "fake-c++"
+    driver_pid_path = tmp_path / "driver.pid"
+    child_pid_path = tmp_path / "child.pid"
+    compiler_script.write_text(
+        """#!/usr/bin/env python3
+import os
+from pathlib import Path
+import signal
+import subprocess
+import sys
+import time
+
+output = Path(sys.argv[sys.argv.index("-o") + 1])
+output.write_bytes(b"partial-library")
+if os.environ.get("PYAMPLICOL_TEST_COMPILER_MODE") == "success":
+    raise SystemExit(0)
+Path(os.environ["PYAMPLICOL_TEST_DRIVER_PID"]).write_text(str(os.getpid()))
+child = subprocess.Popen(
+    [
+        sys.executable,
+        "-c",
+        (
+            "import signal,time;"
+            "signal.signal(signal.SIGTERM,signal.SIG_IGN);"
+            "time.sleep(60)"
+        ),
+    ]
+)
+Path(os.environ["PYAMPLICOL_TEST_CHILD_PID"]).write_text(str(child.pid))
+signal.signal(signal.SIGTERM, signal.SIG_IGN)
+time.sleep(60)
+""",
+        encoding="utf-8",
+    )
+    compiler_script.chmod(0o755)
+    monkeypatch.setenv(
+        "PYAMPLICOL_NATIVE_COMPILER_GATE_DIR",
+        str(tmp_path / "compiler-gate"),
+    )
+    monkeypatch.setenv("PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT", "1")
+    monkeypatch.setenv("PYAMPLICOL_TEST_DRIVER_PID", str(driver_pid_path))
+    monkeypatch.setenv("PYAMPLICOL_TEST_CHILD_PID", str(child_pid_path))
+    output_library = tmp_path / "timed-out.so"
+    evaluator = _Evaluator(
+        [
+            ("mul", ("out", 0), [("param", 0), ("param", 0)], 0),
+        ]
+    )
+
+    with pytest.raises(
+        NativeEvaluationError,
+        match=r"compilation exceeded its finite 0.5s timeout",
+    ):
+        compile_native_direct_cpp(
+            evaluator,
+            spec=_spec(),
+            compiler=NativeDirectCppCompiler(
+                executable=str(compiler_script),
+                timeout_seconds=0.5,
+            ),
+            output_source_path=tmp_path / "timed-out.cpp",
+            output_library_path=output_library,
+        )
+
+    for pid_path in (driver_pid_path, child_pid_path):
+        pid = int(pid_path.read_text(encoding="ascii"))
+        with pytest.raises(ProcessLookupError):
+            os.kill(pid, 0)
+    assert not output_library.exists()
+    assert not tuple(tmp_path.glob(".timed-out.so.tmp-*"))
+
+    monkeypatch.setenv("PYAMPLICOL_TEST_COMPILER_MODE", "success")
+    succeeded = compile_native_direct_cpp(
+        evaluator,
+        spec=_spec(),
+        compiler=NativeDirectCppCompiler(
+            executable=str(compiler_script),
+            timeout_seconds=0.5,
+        ),
+        output_source_path=tmp_path / "succeeded.cpp",
+        output_library_path=tmp_path / "succeeded.so",
+    )
+    assert succeeded.library_path.read_bytes() == b"partial-library"
+    assert succeeded.compiler_gate_slot_count == 1
+
+    for pid_path in (driver_pid_path, child_pid_path):
+        pid_path.unlink()
+    monkeypatch.delenv("PYAMPLICOL_TEST_COMPILER_MODE")
+    original_communicate = subprocess.Popen.communicate
+    interrupt_pending = True
+
+    def interrupt_after_descendant_starts(
+        process: subprocess.Popen[str],
+        *args: object,
+        **kwargs: object,
+    ) -> tuple[str, str]:
+        nonlocal interrupt_pending
+        if interrupt_pending:
+            deadline = time.monotonic() + 5.0
+            while not child_pid_path.exists():
+                if time.monotonic() >= deadline:
+                    pytest.fail("fake compiler descendant did not start")
+                time.sleep(0.01)
+            interrupt_pending = False
+            raise KeyboardInterrupt
+        return original_communicate(process, *args, **kwargs)
+
+    monkeypatch.setattr(
+        subprocess.Popen,
+        "communicate",
+        interrupt_after_descendant_starts,
+    )
+    interrupted_output = tmp_path / "interrupted.so"
+    with pytest.raises(KeyboardInterrupt):
+        compile_native_direct_cpp(
+            evaluator,
+            spec=_spec(),
+            compiler=NativeDirectCppCompiler(
+                executable=str(compiler_script),
+                timeout_seconds=60.0,
+            ),
+            output_source_path=tmp_path / "interrupted.cpp",
+            output_library_path=interrupted_output,
+        )
+
+    for pid_path in (driver_pid_path, child_pid_path):
+        pid = int(pid_path.read_text(encoding="ascii"))
+        with pytest.raises(ProcessLookupError):
+            os.kill(pid, 0)
+    assert not interrupted_output.exists()
+    assert not tuple(tmp_path.glob(".interrupted.so.tmp-*"))
+
+    monkeypatch.setenv("PYAMPLICOL_TEST_COMPILER_MODE", "success")
+    succeeded_after_interrupt = compile_native_direct_cpp(
+        evaluator,
+        spec=_spec(),
+        compiler=NativeDirectCppCompiler(
+            executable=str(compiler_script),
+            timeout_seconds=0.5,
+        ),
+        output_source_path=tmp_path / "after-interrupt.cpp",
+        output_library_path=tmp_path / "after-interrupt.so",
+    )
+    assert succeeded_after_interrupt.library_path.read_bytes() == b"partial-library"
+    assert succeeded_after_interrupt.compiler_gate_slot_count == 1
+
+
+def test_native_compiler_gate_limits_four_parallel_compilers_and_reports_wait(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    gate_dir = tmp_path / "compiler-gate"
+    monkeypatch.setenv("PYAMPLICOL_NATIVE_COMPILER_GATE_DIR", str(gate_dir))
+    monkeypatch.setenv("PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT", "4")
+    four_entered = threading.Event()
+    release_first_four = threading.Event()
+    fifth_entered = threading.Event()
+    call_lock = threading.Lock()
+    call_count = 0
+    observed_timeouts: list[float] = []
+
+    def gated_run(
+        command: tuple[str, ...],
+        *,
+        timeout_seconds: float,
+    ) -> subprocess.CompletedProcess[str]:
+        nonlocal call_count
+        with call_lock:
+            call_index = call_count
+            call_count += 1
+            observed_timeouts.append(timeout_seconds)
+            if call_count == 4:
+                four_entered.set()
+        if call_index < 4:
+            assert release_first_four.wait(timeout=5.0)
+        else:
+            fifth_entered.set()
+        Path(command[command.index("-o") + 1]).write_bytes(b"native-library")
+        return subprocess.CompletedProcess(command, 0, "", "")
+
+    monkeypatch.setattr(
+        "pyamplicol.evaluators.native_direct_cpp._run_native_compiler",
+        gated_run,
+    )
+    evaluator = _Evaluator(
+        [
+            ("mul", ("out", 0), [("param", 0), ("param", 0)], 0),
+        ]
+    )
+
+    def compile_named(name: str) -> NativeDirectCppArtifact:
+        return compile_native_direct_cpp(
+            evaluator,
+            spec=_spec(),
+            compiler=NativeDirectCppCompiler(timeout_seconds=7.0),
+            output_source_path=tmp_path / f"{name}.cpp",
+            output_library_path=tmp_path / f"{name}.so",
+        )
+
+    with ThreadPoolExecutor(max_workers=5) as executor:
+        first_four = [
+            executor.submit(compile_named, f"parallel-{index}")
+            for index in range(4)
+        ]
+        assert four_entered.wait(timeout=5.0)
+        fifth = executor.submit(compile_named, "waiting")
+        assert not fifth_entered.wait(timeout=0.1)
+        release_first_four.set()
+        artifacts = [
+            future.result(timeout=5.0)
+            for future in (*first_four, fifth)
+        ]
+
+    assert call_count == 5
+    assert all(artifact.compiler_gate_slot_count == 4 for artifact in artifacts)
+    assert artifacts[-1].compiler_gate_wait_seconds > 0.0
+    assert observed_timeouts == [7.0] * 5
+
+
+def test_native_compiler_gate_releases_after_compiler_error(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv(
+        "PYAMPLICOL_NATIVE_COMPILER_GATE_DIR",
+        str(tmp_path / "compiler-gate"),
+    )
+    monkeypatch.setenv("PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT", "1")
+    call_count = 0
+
+    def fail_then_succeed(
+        command: tuple[str, ...],
+        *,
+        timeout_seconds: float,
+    ) -> subprocess.CompletedProcess[str]:
+        nonlocal call_count
+        assert timeout_seconds == 7.0
+        call_count += 1
+        if call_count == 1:
+            raise OSError("compiler unavailable")
+        Path(command[command.index("-o") + 1]).write_bytes(b"native-library")
+        return subprocess.CompletedProcess(command, 0, "", "")
+
+    monkeypatch.setattr(
+        "pyamplicol.evaluators.native_direct_cpp._run_native_compiler",
+        fail_then_succeed,
+    )
+    evaluator = _Evaluator(
+        [
+            ("mul", ("out", 0), [("param", 0), ("param", 0)], 0),
+        ]
+    )
+    compiler = NativeDirectCppCompiler(timeout_seconds=7.0)
+    with pytest.raises(
+        NativeEvaluationError,
+        match="could not execute the native DirectApplication C\\+\\+ compiler",
+    ):
+        compile_native_direct_cpp(
+            evaluator,
+            spec=_spec(),
+            compiler=compiler,
+            output_source_path=tmp_path / "failed.cpp",
+            output_library_path=tmp_path / "failed.so",
+        )
+
+    artifact = compile_native_direct_cpp(
+        evaluator,
+        spec=_spec(),
+        compiler=compiler,
+        output_source_path=tmp_path / "succeeded.cpp",
+        output_library_path=tmp_path / "succeeded.so",
+    )
+
+    assert call_count == 2
+    assert artifact.library_path.read_bytes() == b"native-library"
+    assert artifact.compiler_gate_slot_count == 1
+
+
+def test_direct_only_companion_identity_survives_evaluator_manifest(
+    tmp_path: Path,
+) -> None:
+    rendered = render_native_direct_cpp(
+        _Evaluator(
+            [
+                ("mul", ("out", 0), [("param", 0), ("param", 0)], 0),
+            ]
+        ),
+        _spec(),
+    )
+    source_path = tmp_path / "retained_leaf.direct.cpp"
+    library_path = tmp_path / "libretained_leaf.direct"
+    source_path.write_text(rendered.source, encoding="utf-8")
+    library_path.write_bytes(b"direct-only-test-library")
+    companion = NativeDirectCppArtifact(
+        source_path=source_path,
+        library_path=library_path,
+        source=rendered,
+        compiler_command=("c++",),
+        compile_seconds=0.125,
+        compiler_gate_wait_seconds=3.5,
+        compiler_gate_slot_count=4,
+    )
+
+    identity = _native_direct_application_manifest(
+        companion,
+        tmp_path,
+        expected_function_name="retained_leaf",
+    )
+    evaluator = _evaluator(
+        {
+            "kind": "compiled-complex-evaluator",
+            "runtime_capability": "symbolica.compiled-cpp.complex-f64.v1",
+            "function_name": "retained_leaf",
+            "input_len": 2,
+            "output_len": 1,
+            "library_path": "libretained_leaf.direct",
+            "evaluator_state_path": "retained_leaf.evaluator.bin",
+            "number_type": "complex",
+            "native_direct_application": identity,
+        }
+    )
+
+    assert identity["application_abi"] == NATIVE_COMPILED_DIRECT_APPLICATION_ABI
+    assert identity["target"] == {
+        "triple": "aarch64-apple-darwin",
+        "cpu_features": ["neon"],
+    }
+    assert identity["source_path"] == "retained_leaf.direct.cpp"
+    assert identity["library_path"] == "libretained_leaf.direct"
+    assert "compiler_gate_wait_seconds" not in identity
+    assert "compiler_gate_slot_count" not in identity
+    assert evaluator["native_direct_application"] == identity
+
+    asm_evaluator = _evaluator(
+        {
+            "kind": "compiled-complex-evaluator",
+            "runtime_capability": "symbolica.compiled-asm.complex-f64.v1",
+            "function_name": "retained_leaf",
+            "input_len": 2,
+            "output_len": 1,
+            "library_path": "libretained_leaf.direct",
+            "evaluator_state_path": "retained_leaf.evaluator.bin",
+            "number_type": "complex",
+            "native_direct_application": identity,
+        }
+    )
+    assert asm_evaluator["native_direct_application"] == identity
+
+
+def test_process_stage_adapter_serializes_no_dense_library(tmp_path: Path) -> None:
+    source = _Evaluator(
+        [
+            ("mul", ("out", 0), [("param", 0), ("param", 0)], 0),
+        ]
+    )
+    adapter = _CompiledComplexEvaluatorAdapter(
+        source,
+        SymbolicaEvaluatorSettings(
+            backend="compiled-complex",
+            compiled_inline_asm="none",
+            compiled_output_dir=str(tmp_path),
+        ),
+        "direct only stage",
+        input_len=1,
+        output_len=1,
+        compile_dense=False,
+    )
+    rendered = render_native_direct_cpp(
+        source,
+        _spec(
+            function_name=adapter.function_name,
+            parameter_kinds=(ParameterKind.COMPLEX_PLANE,),
+        ),
+    )
+    direct_source = tmp_path / f"{adapter.function_name}.direct.cpp"
+    direct_library = tmp_path / f"lib{adapter.function_name}.direct"
+    direct_source.write_text(rendered.source, encoding="utf-8")
+    direct_library.write_bytes(b"direct-only-test-library")
+    adapter.native_direct_application = NativeDirectCppArtifact(
+        source_path=direct_source,
+        library_path=direct_library,
+        source=rendered,
+        compiler_command=("c++",),
+        compile_seconds=0.125,
+    )
+
+    manifest = adapter.artifact_manifest(tmp_path)
+
+    assert manifest["library_path"] == direct_library.name
+    assert manifest["source_path"] == direct_source.name
+    assert not adapter.library_path.exists()
+    assert not adapter.source_path.exists()
+    assert sorted(path.name for path in tmp_path.iterdir()) == sorted(
+        [
+            direct_source.name,
+            direct_library.name,
+            adapter.evaluator_state_path.name,
+        ]
+    )
diff --git a/pyamplicol/tests/unit/test_native_eager_direct_cpp.py b/pyamplicol/tests/unit/test_native_eager_direct_cpp.py
new file mode 100644
index 0000000000..cc37c1df2d
--- /dev/null
+++ b/pyamplicol/tests/unit/test_native_eager_direct_cpp.py
@@ -0,0 +1,200 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import ctypes
+import hashlib
+import struct
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.evaluators.native_eager_direct_cpp import (
+    NATIVE_EAGER_DIRECT_TABLE_APPLICATION_ABI,
+    render_native_eager_direct_table_cpp,
+)
+
+
+class _AddEvaluator:
+    def get_instructions(self) -> tuple[list[object], int, list[object]]:
+        return (
+            [("add", ("out", 0), [("param", 0), ("param", 1)], 0)],
+            0,
+            [],
+        )
+
+    def save(self) -> bytes:
+        return b"native-eager-direct-table-test-state"
+
+
+class _DirectPlane(ctypes.Structure):
+    _fields_ = [
+        ("values", ctypes.POINTER(ctypes.c_double)),
+        ("length", ctypes.c_size_t),
+    ]
+
+
+class _DirectScalar(ctypes.Structure):
+    _fields_ = [("value", ctypes.POINTER(ctypes.c_double))]
+
+
+class _DirectTableCallView(ctypes.Structure):
+    _fields_ = [
+        ("invocations", ctypes.POINTER(ctypes.c_uint8)),
+        ("invocation_count", ctypes.c_uint32),
+        ("invocation_stride", ctypes.c_uint32),
+        ("attachments", ctypes.POINTER(ctypes.c_uint8)),
+        ("attachment_count", ctypes.c_uint32),
+        ("attachment_stride", ctypes.c_uint32),
+        ("planes", ctypes.POINTER(_DirectPlane)),
+        ("plane_count", ctypes.c_uint32),
+        ("scalar_count", ctypes.c_uint32),
+        ("scalars", ctypes.POINTER(_DirectScalar)),
+        ("factor_re", ctypes.POINTER(ctypes.c_double)),
+        ("factor_im", ctypes.POINTER(ctypes.c_double)),
+        ("factor_count", ctypes.c_uint32),
+        ("point_start", ctypes.c_uint32),
+        ("point_count", ctypes.c_uint32),
+    ]
+
+
+class _NativeEagerDirectTableMetadata(ctypes.Structure):
+    _fields_ = [
+        ("struct_size", ctypes.c_uint32),
+        ("abi_version", ctypes.c_uint32),
+        ("flags", ctypes.c_uint32),
+        ("invocation_stride", ctypes.c_uint32),
+        ("attachment_stride", ctypes.c_uint32),
+        ("input_complex_count", ctypes.c_uint32),
+        ("output_complex_count", ctypes.c_uint32),
+        ("simd_lane_width", ctypes.c_uint32),
+        ("application_abi", ctypes.c_char_p),
+        ("function_name", ctypes.c_char_p),
+        ("target_triple", ctypes.c_char_p),
+        ("evaluator_state_sha256", ctypes.c_char_p),
+    ]
+
+
+@pytest.mark.skipif(
+    sys.platform not in {"darwin", "linux"},
+    reason="native table smoke needs a POSIX shared-library compiler",
+)
+def test_native_eager_table_is_plane_native_and_preserves_fanout_order(
+    tmp_path: Path,
+) -> None:
+    rendered = render_native_eager_direct_table_cpp(
+        _AddEvaluator(),
+        kernel_id=7,
+        input_complex_count=2,
+        output_complex_count=1,
+        target_triple="unit-test-target",
+        evaluator_state_bytes=b"packaged-native-eager-state",
+    )
+    assert "_complexf64(" not in rendered.source
+    assert "_realf64(" not in rendered.source
+    assert rendered.invocation_stride == 24
+    assert rendered.attachment_stride == 16
+    assert rendered.evaluator_state_sha256 == hashlib.sha256(
+        b"packaged-native-eager-state"
+    ).hexdigest()
+
+    source = tmp_path / "eager_direct.cpp"
+    library = tmp_path / (
+        "libeager_direct.dylib" if sys.platform == "darwin" else "libeager_direct.so"
+    )
+    source.write_text(rendered.source, encoding="utf-8")
+    subprocess.run(
+        [
+            "c++",
+            "-std=c++17",
+            "-shared",
+            "-O3",
+            "-fPIC",
+            str(source),
+            "-o",
+            str(library),
+        ],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    points = 5  # exercises two SIMD bundles plus an odd scalar tail.
+    arrays = [
+        (ctypes.c_double * points)(1.0, 2.0, 3.0, 4.0, 5.0),
+        (ctypes.c_double * points)(0.5, 1.0, 1.5, 2.0, 2.5),
+        (ctypes.c_double * points)(10.0, 20.0, 30.0, 40.0, 50.0),
+        (ctypes.c_double * points)(-1.0, -2.0, -3.0, -4.0, -5.0),
+        (ctypes.c_double * points)(*([99.0] * points)),
+        (ctypes.c_double * points)(*([99.0] * points)),
+    ]
+    planes = (_DirectPlane * len(arrays))(
+        *(_DirectPlane(values, points) for values in arrays)
+    )
+    invocation = (ctypes.c_uint8 * rendered.invocation_stride).from_buffer_copy(
+        struct.pack("<6I", 0, 1, 2, 3, 0, 2)
+    )
+    attachments = (
+        ctypes.c_uint8 * (2 * rendered.attachment_stride)
+    ).from_buffer_copy(
+        struct.pack("<4I", 4, 5, 0, 0)
+        + struct.pack("<4I", 4, 5, 1, 1)
+    )
+    factor_re = (ctypes.c_double * 2)(1.0, 2.0)
+    factor_im = (ctypes.c_double * 2)(0.0, 0.0)
+    view = _DirectTableCallView(
+        invocation,
+        1,
+        rendered.invocation_stride,
+        attachments,
+        2,
+        rendered.attachment_stride,
+        planes,
+        len(arrays),
+        0,
+        None,
+        factor_re,
+        factor_im,
+        2,
+        0,
+        points,
+    )
+    loaded = ctypes.CDLL(str(library))
+    metadata_call = getattr(loaded, f"{rendered.function_name}_metadata_v1")
+    metadata_call.argtypes = []
+    metadata_call.restype = ctypes.POINTER(_NativeEagerDirectTableMetadata)
+    metadata = metadata_call().contents
+    assert metadata.struct_size == ctypes.sizeof(_NativeEagerDirectTableMetadata)
+    assert metadata.abi_version == 1
+    assert metadata.flags == 0x1F
+    assert metadata.invocation_stride == rendered.invocation_stride
+    assert metadata.attachment_stride == rendered.attachment_stride
+    assert metadata.input_complex_count == 2
+    assert metadata.output_complex_count == 1
+    assert metadata.simd_lane_width == rendered.simd_lane_width
+    assert metadata.application_abi.decode() == (
+        NATIVE_EAGER_DIRECT_TABLE_APPLICATION_ABI
+    )
+    assert metadata.function_name.decode() == rendered.function_name
+    assert metadata.target_triple.decode() == "unit-test-target"
+    assert (
+        metadata.evaluator_state_sha256.decode()
+        == rendered.evaluator_state_sha256
+    )
+    call = getattr(loaded, rendered.function_name)
+    call.argtypes = [ctypes.POINTER(_DirectTableCallView)]
+    call.restype = ctypes.c_int
+    assert call(ctypes.byref(view)) == 0
+
+    expected_re = [
+        3.0 * (arrays[0][point] + arrays[2][point])
+        for point in range(points)
+    ]
+    expected_im = [
+        3.0 * (arrays[1][point] + arrays[3][point])
+        for point in range(points)
+    ]
+    assert list(arrays[4]) == expected_re
+    assert list(arrays[5]) == expected_im
diff --git a/pyamplicol/tests/unit/test_nlo_limit_study.py b/pyamplicol/tests/unit/test_nlo_limit_study.py
new file mode 100644
index 0000000000..aa4f7dce8d
--- /dev/null
+++ b/pyamplicol/tests/unit/test_nlo_limit_study.py
@@ -0,0 +1,395 @@
+# SPDX-License-Identifier: 0BSD
+"""Cheap study checks: no generation, native evaluations, or Symbolica session."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+from contextlib import contextmanager
+from decimal import Decimal, localcontext
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+SCRIPT = (
+    Path(__file__).resolve().parents[2]
+    / "examples/NLO_limits/nlo_limit_stability_tests.py"
+)
+spec = importlib.util.spec_from_file_location("nlo_limit_study", SCRIPT)
+assert spec is not None and spec.loader is not None
+study = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(study)
+
+
+def value(real, imag=0):
+    return SimpleNamespace(real=Decimal(real), imag=Decimal(imag))
+
+
+@pytest.mark.parametrize("resolved", (False, True))
+def test_cached_born_requires_current_per_process_declarations(tmp_path, resolved):
+    expected = study.declarations().to_json_dict()
+    for name, expression in study.EXPRESSIONS.items():
+        directory = tmp_path / name
+        (directory / "config").mkdir(parents=True)
+        (directory / "artifact.json").write_text(json.dumps({
+            "artifact_id": name, "processes": [{"expression": expression}],
+        }))
+        (directory / "config/effective.toml").write_text(
+            '[color]\naccuracy="full"\ncontraction="direct"\n'
+            '[evaluator]\nexecution_mode="compiled"\n'
+            '[generation.relation_discovery]\n'
+            f'mode="{study.STUDY["relation_discovery"][name]}"\n'
+        )
+        if name == "born":
+            (directory / "correlators.json").write_text(json.dumps({
+                "declarations": expected,
+                "processes": {"born": {"declarations": expected} if resolved else {}},
+            }))
+    if resolved:
+        paths, identities = study.generate_artifacts(tmp_path)
+        assert paths["born"] == tmp_path / "born"
+        assert identities["born"] == "born"
+    else:
+        with pytest.raises(ValueError, match="fresh artifact directory"):
+            study.generate_artifacts(tmp_path)
+
+
+@pytest.mark.parametrize("limit", ("collinear", "soft"))
+@pytest.mark.parametrize("exponent", (1, 4, 15, 100))
+def test_source_is_onshell_conserving_and_maps_to_fixed_born(limit, exponent):
+    source = study.make_point(limit, exponent, 300)
+    for key, item in source["checks"].items():
+        if key == "positive_energies":
+            assert item
+        else:
+            assert Decimal(item) < Decimal("1e-175"), key
+    with localcontext() as context:
+        context.prec = 300
+        born = [[Decimal(v) for v in p] for p in source["born"]]
+        e = [Decimal(v) for v in source["spin"]]
+        assert abs(study.dot(e, e) + 1) < Decimal("1e-290")
+        assert abs(study.dot(e, born[2])) < Decimal("1e-285")
+        assert abs(study.dot(e, born[3])) < Decimal("1e-285")
+        if limit == "collinear":
+            expected = (Decimal(1000) * Decimal(source["delta"])) ** 2
+            expected /= Decimal("0.6") * Decimal("0.4")
+            assert abs(Decimal(source["s_ij"]) / expected - 1) < Decimal("1e-90")
+
+
+def test_soft_direction_is_fixed_and_wide_angle():
+    with localcontext() as context:
+        context.prec = 110
+        first, second = (study.make_point("soft", x, 100) for x in (2, 10))
+        q = [Decimal(v) / Decimal(first["delta"]) for v in first["real"][3]]
+        r = [Decimal(v) / Decimal(second["delta"]) for v in second["real"][3]]
+        assert max(abs(a - b) for a, b in zip(q, r, strict=True)) < Decimal("1e-90")
+        assert abs(q[0] - 500) < Decimal("1e-90")
+        for raw in first["born"]:
+            p = [Decimal(v) for v in raw]
+            assert study.dot(p, q) / (p[0] * q[0]) > Decimal("0.1")
+
+
+def test_binary64_operations_do_not_inherit_decimal_precision():
+    with localcontext() as context:
+        context.prec = 120
+        study.arithmetic_smoke("double")
+        d = study.Binary64
+        assert d(1) + d("1e-20") == 1
+        assert (d(1) / d(3)) == Decimal.from_float(1.0 / 3.0)
+        assert d(2).sqrt() == Decimal.from_float(2.0**0.5)
+        assert isinstance(sum((d(1), d(2))), d)
+        assert isinstance(-d(1), d)
+        assert isinstance(+d(1), d)
+
+
+def test_local_spin_counterterm_reduces_to_average_only_for_half_density():
+    source = study.make_point("collinear", 3, 100)
+    with localcontext() as context:
+        context.prec = 100
+        components = {"born": value(1), "spin": value("0.5")}
+        actual = study.counterterm(source, components, Decimal, Decimal(1))
+        z, sij = Decimal(source["z"]), Decimal(source["s_ij"])
+        expected = 8 * Decimal(study.ALPHA_S) / sij * 6
+        expected *= z / (1 - z) + (1 - z) / z + z * (1 - z)
+        expected *= 6  # Remove the public Born's 1/3!.
+        assert abs(actual / expected - 1) < Decimal("1e-90")
+        components["spin"] = value("0.3")
+        assert study.counterterm(source, components, Decimal, Decimal(1)) != expected
+
+
+def test_soft_sign_pair_count_and_scaling():
+    components = {"born": value("1.333333333333333333333333333333333")}
+    components.update({f"T{a}{b}": value(-1) for a, b in study.DIPOLES})
+    with localcontext() as context:
+        context.prec = 100
+        counterterms = [
+            study.counterterm(
+                study.make_point("soft", x, 110), components, Decimal, Decimal(1)
+            )
+            for x in (2, 3)
+        ]
+        assert counterterms[0] > 0
+        assert abs(counterterms[1] / counterterms[0] - 100) < Decimal("1e-90")
+        source = study.make_point("soft", 2, 110)
+        p = [[Decimal(v) for v in vector] for vector in source["born"]]
+        q = [Decimal(v) for v in source["real"][3]]
+        ordered = sum(
+            study.dot(a, b) / (study.dot(a, q) * study.dot(b, q))
+            for i, a in enumerate(p)
+            for j, b in enumerate(p)
+            if i != j
+        )
+        assert abs(
+            counterterms[0] / (4 * Decimal(study.ALPHA_S) * 6 * ordered) - 1
+        ) < Decimal("1e-90")
+
+
+def test_many_requests_include_physical_born_all_dipoles_and_vector_batch():
+    sources = [study.make_point("collinear", x, 80) for x in (2, 3, 4)]
+    requests = study.correlation_requests(sources, diagnostics=True)
+    assert requests["born"].spin_vectors == {}
+    assert requests["T13"].color_correlation == "T13"
+    assert len(requests["spin"].spin_vectors[3]) == len(sources)
+    assert {f"T{a}{b}" for a, b in study.DIPOLES} <= requests.keys()
+    assert {"basis1", "basis2", "ward", "T33"} <= requests.keys()
+
+
+def test_real_batch_bisection_is_exception_only():
+    class FakeRuntime:
+        def __init__(self, bad=False):
+            self.calls = []
+            self.bad = bad
+
+        def evaluate(self, points, precision):
+            self.calls.append(points)
+            if self.bad and any(p[0][0] == 2 for p in points):
+                raise ArithmeticError("singular endpoint")
+            return [complex(p[0][0]) for p in points]
+
+    sources = [{"real": [[str(i), "0", "0", "0"]]} for i in (1, 2, 3)]
+    runtime = FakeRuntime()
+    values, diagnostic = study.evaluate_real_batch(
+        runtime, sources, "double", 16, study.Binary64
+    )
+    assert values == [1, 2, 3]
+    assert len(runtime.calls) == 1 and not diagnostic["diagnostic_bisection"]
+    runtime = FakeRuntime(bad=True)
+    values, diagnostic = study.evaluate_real_batch(
+        runtime, sources, "double", 16, study.Binary64
+    )
+    assert values == [1, None, 3]
+    assert diagnostic["diagnostic_bisection"] and 1 in diagnostic["errors"]
+
+
+def test_stability_metric_does_not_invent_references():
+    record = {"format": "double", "status": "ok", "F": "1.0000000001"}
+    reference = {"precision": 1200, "status": "ok", "F": "1"}
+    result = study.compare_records(record, reference)
+    assert Decimal(result["stable_digits"]) == 10
+    assert 0 < result["stable_fraction"] < 1
+    assert study.compare_records(record, None) == {"reference_status": "missing"}
+    assert "stable_fraction" not in study.compare_records(
+        record, {**reference, "F": "0"}
+    )
+    assert (
+        study.compare_records({**record, "status": "failed"}, reference)[
+            "stable_fraction"
+        ]
+        == 0
+    )
+
+
+def test_checkpoint_and_render_parser_are_independent_of_execution(tmp_path):
+    path = tmp_path / "results.json"
+    report = {"study": study.STUDY, "records": {}}
+    study.checkpoint(path, report)
+    assert path.exists() and not path.with_suffix(".json.tmp").exists()
+    args = study.parser().parse_args(["--render", "--output", str(path)])
+    assert args.render and args.memory_limit_gib == 10.0
+
+
+def test_binary64_adapter_is_scoped_and_sets_retained_stage_precision():
+    from pyamplicol.runtime import _color_topology_exact, correlations, symbolica_exact
+
+    original_decimal = symbolica_exact.Decimal
+    original_working = symbolica_exact._working_precision
+    original_topology_zero = _color_topology_exact._ZERO
+    seen = []
+
+    class Stage:
+        def evaluate_complex(self, values):
+            seen.append(values)
+            return [[complex(0.1)]]
+
+        def evaluate_complex_with_prec(self, values, precision):
+            raise AssertionError("binary64 must not use arbitrary Float dispatch")
+
+    evaluator = symbolica_exact._ExactEvaluator(input_len=1, evaluator=Stage())
+    with study.arithmetic("double", 16):
+        assert symbolica_exact._working_precision(1000) == 16
+        assert correlations.Decimal is study.Binary64
+        assert _color_topology_exact.Decimal is study.Binary64
+        assert isinstance(_color_topology_exact._ZERO, study.Binary64)
+        assert isinstance(_color_topology_exact._ONE, study.Binary64)
+        assert isinstance(_color_topology_exact._TWO, study.Binary64)
+        output = evaluator.evaluate(((study.Binary64("0.1"), study.Binary64(0)),), 16)
+        assert seen[0] == [complex(0.1)]
+        assert isinstance(output[0][0], study.Binary64)
+    assert symbolica_exact.Decimal is original_decimal
+    assert symbolica_exact._working_precision is original_working
+    assert correlations.Decimal is Decimal
+    assert _color_topology_exact.Decimal is Decimal
+    assert _color_topology_exact._ZERO is original_topology_zero
+
+
+def test_evaluation_requests_whole_point_batch_once(monkeypatch):
+    import pyamplicol
+
+    calls = []
+    loads = []
+
+    class FakeRuntime:
+        @classmethod
+        def load(cls, path, model_parameters):
+            loads.append((path, model_parameters))
+            return cls()
+
+        def evaluate_correlated_many(self, points, requests, precision):
+            calls.append((points, requests))
+            return {
+                name: tuple(value(1 if name == "born" else "0.3") for _ in points)
+                for name in requests
+            }
+
+        def evaluate(self, points, precision):
+            return [1j * 0 + 1 for _ in points]
+
+    @contextmanager
+    def fake_arithmetic(name, precision):
+        with localcontext() as context:
+            context.prec = 60
+            yield Decimal
+
+    monkeypatch.setattr(pyamplicol, "Runtime", FakeRuntime)
+    monkeypatch.setattr(study, "arithmetic", fake_arithmetic)
+    monkeypatch.setattr(study, "target_pi", lambda scalar, precision: Decimal(1))
+    sources = [study.make_point("collinear", x, 80) for x in (2, 3, 4)]
+    records = study.evaluate_batch(
+        {"real": "real", "born": "born"}, sources, "double", 16
+    )
+    assert loads == [
+        ("real", {"alpha_s": float(study.ALPHA_S)}),
+        ("born", {"alpha_s": float(study.ALPHA_S)}),
+    ]
+    assert len(calls) == 1 and len(calls[0][0]) == 3
+    assert len(calls[0][1]) == 12
+    assert [record["exponent"] for record in records] == [2, 3, 4]
+    assert records[2]["correlations"]["T13"] == {"real": "0.3", "imag": "0"}
+    assert records[2]["batch"]["public_correlated_many_calls"] == 1
+    assert records[2]["batch"]["public_real_calls"] == 1
+    assert records[2]["batch"]["point_count"] == 3
+
+
+def test_resume_preserves_failed_measurements_unless_retry_is_explicit():
+    report = {
+        "records": {
+            "collinear:double:1": {"status": "ok"},
+            "collinear:double:2": {"status": "failed"},
+        }
+    }
+    assert study.pending_exponents(report, "collinear", "double", [1, 2, 3]) == [3]
+    assert study.pending_exponents(
+        report, "collinear", "double", [1, 2, 3], retry_failed=True
+    ) == [2, 3]
+
+
+@pytest.mark.parametrize(
+    ("oracle_status", "target_status"),
+    (("failed", "ok"), ("missing", "ok"), ("ok", "failed"), ("ok", "ok")),
+)
+def test_scan_requires_requested_oracles_but_partial_render_is_available(
+    tmp_path, monkeypatch, oracle_status, target_status
+):
+    output = tmp_path / "results.json"
+    study.checkpoint(output, {
+        "study": study.STUDY,
+        "oracle_precision": 1200,
+        "records": {
+            f"{limit}:oracle:{exponent}": {
+                "limit": limit, "format": "oracle", "exponent": exponent,
+                "status": "failed",
+            }
+            for limit, exponent in (("soft", 2), ("collinear", 99))
+        },
+    })
+    rendered = []
+
+    def evaluate(paths, sources, format_name, precision, **kwargs):
+        status = oracle_status if format_name == "oracle" else target_status
+        if status == "missing":
+            return []
+        return [{
+            "limit": source["limit"], "exponent": source["exponent"],
+            "format": format_name, "precision": precision, "status": status,
+            "F": "1", "F_over_R": "0.001",
+        } for source in sources]
+
+    monkeypatch.setattr(study, "generate_artifacts", lambda path: ({}, {}))
+    monkeypatch.setattr(study, "evaluate_batch", evaluate)
+    monkeypatch.setattr(study, "render", lambda report, path: rendered.append(report))
+    arguments = [
+        "--_guard-child", "--formats", "arbitrary-1000", "--limits", "collinear",
+        "--exponents", "2", "--output", str(output),
+    ]
+    if oracle_status == "ok":
+        # One requested point suffices; historical failed references are irrelevant.
+        assert study.main(arguments) == 0
+        assert len(rendered) == 1
+    else:
+        with pytest.raises(ValueError, match="oracle measurements: collinear:oracle:2"):
+            study.main(arguments)
+        assert not rendered
+    retained = json.loads(output.read_text())
+    target = retained["records"]["collinear:arbitrary-1000:2"]
+    assert target["status"] == target_status
+    if oracle_status == "failed":
+        assert retained["records"]["collinear:oracle:2"]["status"] == "failed"
+    if oracle_status == "ok" and target_status == "failed":
+        assert target["stable_fraction"] == 0
+    # An explicit redraw remains available even when no valid reference exists.
+    rendered.clear()
+    assert study.main(["--render", "--output", str(output)]) == 0
+    assert rendered == [retained]
+
+
+def test_prepare_only_allows_smaller_oracle_without_starting_arithmetic(monkeypatch):
+    calls = []
+
+    def prepare(directory):
+        calls.append(directory)
+        return {}, {"real": "a", "born": "b"}
+
+    def forbidden(*args, **kwargs):
+        raise AssertionError("prepare-only must not evaluate arithmetic or amplitudes")
+
+    monkeypatch.setattr(study, "generate_artifacts", prepare)
+    monkeypatch.setattr(study, "arithmetic_smoke", forbidden)
+    monkeypatch.setattr(study, "evaluate_batch", forbidden)
+    assert (
+        study.main(
+            [
+                "--prepare-only",
+                "--_guard-child",
+                "--formats",
+                "double",
+                "double-double",
+                "--oracle-precision",
+                "160",
+            ]
+        )
+        == 0
+    )
+    assert len(calls) == 1
+    with pytest.raises(ValueError, match="exceed every selected target"):
+        study.main(["--oracle-precision", "160"])
diff --git a/pyamplicol/tests/unit/test_numerical_acceptance.py b/pyamplicol/tests/unit/test_numerical_acceptance.py
new file mode 100644
index 0000000000..b31fcfe398
--- /dev/null
+++ b/pyamplicol/tests/unit/test_numerical_acceptance.py
@@ -0,0 +1,605 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+import sys
+from collections import Counter
+from decimal import Decimal
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+
+import pytest
+
+from tools.developer import numerical_acceptance as acceptance_module
+from tools.developer.numerical_acceptance import (
+    ACCEPTANCE_LANES,
+    CATALOG_CASE_COUNT,
+    CATALOG_MAX_N_FINAL,
+    EXTRA_FULL_COLOUR_CASES,
+    FULL_CANDIDATE_PRECISION_DIGITS,
+    NATIVE_PRECISION_DIGITS,
+    RELATIVE_TOLERANCE,
+    MadGraphReferenceIdentity,
+    NumericalAcceptanceError,
+    NumericalAcceptanceMismatch,
+    assert_relative_match,
+    build_fixture_payload,
+    capture_acceptance_fixture,
+    catalog_cases,
+    compare_relative,
+    current_model_identity,
+    ingest_authenticated_extra_madgraph_root,
+    ingest_authenticated_madgraph_wave_root,
+    lane_case_specs,
+    load_acceptance_fixture,
+    parse_acceptance_fixture,
+    write_acceptance_fixture,
+)
+from tools.performance_report.madgraph import (
+    MADGRAPH_DRIVER_SOURCE_SHA256,
+    madgraph_command_card,
+)
+from tools.performance_report.runner import point_digest
+
+
+@pytest.fixture(autouse=True)
+def synthetic_validation_points(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Keep wire-contract unit tests independent of a staged native runtime."""
+
+    def point(process: str) -> tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]:
+        initial, final = process.split(">", maxsplit=1)
+        width = len(initial.split()) + len(final.split())
+        return tuple(
+            (Decimal(index + 1), Decimal(0), Decimal(0), Decimal(0))
+            for index in range(width)
+        )
+
+    monkeypatch.setattr(acceptance_module, "validation_momenta", point)
+
+
+@pytest.fixture
+def synthetic_payload() -> dict[str, object]:
+    catalog = catalog_cases()
+    all_cases = (*catalog, *EXTRA_FULL_COLOUR_CASES)
+    full = {
+        case.case_id: Decimal(index + 1) * Decimal("0.000000000000000000000000000001")
+        for index, case in enumerate(all_cases)
+    }
+    lc = {
+        case.case_id: Decimal(index + 101) * Decimal("0.000000000000000000000000000001")
+        for index, case in enumerate(catalog)
+    }
+    nlc = {
+        case.case_id: Decimal(index + 201) * Decimal("0.000000000000000000000000000001")
+        for index, case in enumerate(catalog)
+    }
+    model = current_model_identity()
+    return build_fixture_payload(
+        full_values=full,
+        lc_values=lc,
+        nlc_values=nlc,
+        full_reference=MadGraphReferenceIdentity(
+            madgraph_version="synthetic-unit-test",
+            model_source_sha256="1" * 64,
+            driver_sha256=MADGRAPH_DRIVER_SOURCE_SHA256,
+            external_parameters_sha256=model.external_parameters_sha256,
+        ),
+        captured_source_revision="a" * 40,
+    )
+
+
+def test_catalog_census_extra_cases_and_exact_lane_matrix() -> None:
+    cases = catalog_cases()
+    assert len(cases) == CATALOG_CASE_COUNT == 33
+    assert Counter(case.n_final for case in cases) == {1: 2, 2: 8, 3: 9, 4: 14}
+    assert all(case.n_final <= CATALOG_MAX_N_FINAL for case in cases)
+    assert [case.case_id for case in EXTRA_FULL_COLOUR_CASES] == [
+        "extra:identical-u-four-lines",
+        "extra:identical-electron-three-pair",
+    ]
+    assert {case.process for case in cases}.isdisjoint(
+        case.process for case in EXTRA_FULL_COLOUR_CASES
+    )
+    assert [
+        (lane.accuracy, lane.mode, lane.lc_flow_layout)
+        for lane in ACCEPTANCE_LANES
+    ] == [
+        ("full", "recurrence", "topology-replay"),
+        ("full", "eager", "topology-replay"),
+        ("full", "compiled", "topology-replay"),
+        ("full", "on-the-fly", "topology-replay"),
+        ("lc", "recurrence", "topology-replay"),
+        ("lc", "eager", "topology-replay"),
+        ("lc", "compiled", "topology-replay"),
+        ("lc", "on-the-fly", "topology-replay"),
+        ("lc", "recurrence", "all-flow-union"),
+        ("lc", "eager", "all-flow-union"),
+        ("lc", "compiled", "all-flow-union"),
+        ("nlc", "recurrence", "topology-replay"),
+        ("nlc", "eager", "topology-replay"),
+        ("nlc", "compiled", "topology-replay"),
+        ("nlc", "on-the-fly", "topology-replay"),
+    ]
+    assert len({lane.lane_id for lane in ACCEPTANCE_LANES}) == 15
+    assert {
+        lane.mode
+        for lane in ACCEPTANCE_LANES
+        if lane.lc_flow_layout == "all-flow-union"
+    } == {"recurrence", "eager", "compiled"}
+    with pytest.raises(ValueError, match="compact query-local LC artifact"):
+        acceptance_module.AcceptanceLane(
+            "lc", "on-the-fly", 2, "all-flow-union"
+        )
+    assert {
+        lane.accuracy for lane in ACCEPTANCE_LANES if lane.mode == "on-the-fly"
+    } == {"full", "lc", "nlc"}
+
+
+def test_synthetic_fixture_round_trip_binds_model_points_and_provenance(
+    tmp_path: Path,
+    synthetic_payload: dict[str, object],
+) -> None:
+    path = tmp_path / "synthetic-numerical-acceptance.json"
+    fixture = write_acceptance_fixture(synthetic_payload, path)
+    loaded = load_acceptance_fixture(path)
+
+    assert loaded == fixture
+    assert loaded.model == current_model_identity()
+    assert loaded.full_reference.external_parameters_sha256 == (
+        loaded.model.external_parameters_sha256
+    )
+    assert loaded.captured_source_revision == "a" * 40
+    assert len(loaded.catalog) == 33
+    assert len(loaded.extra_full_colour) == 2
+    for case in (*loaded.catalog, *loaded.extra_full_colour):
+        assert case.momenta == acceptance_module.validation_momenta(case.spec.process)
+
+    with pytest.raises(NumericalAcceptanceError, match="refusing to overwrite"):
+        write_acceptance_fixture(synthetic_payload, path)
+
+
+def test_fixture_loader_rejects_changed_points_model_and_wire_contract(
+    synthetic_payload: dict[str, object],
+) -> None:
+    changed_point = copy.deepcopy(synthetic_payload)
+    changed_point["catalog_cases"][0]["momenta"][0][0] = "999"  # type: ignore[index]
+    with pytest.raises(NumericalAcceptanceError, match="momenta differ"):
+        parse_acceptance_fixture(changed_point)
+
+    changed_model = copy.deepcopy(synthetic_payload)
+    changed_model["model"]["source_sha256"] = "f" * 64  # type: ignore[index]
+    with pytest.raises(NumericalAcceptanceError, match="model identity differs"):
+        parse_acceptance_fixture(changed_model)
+
+    changed_comparison = copy.deepcopy(synthetic_payload)
+    changed_comparison["comparison"]["absolute_tolerance"] = "0"  # type: ignore[index]
+    with pytest.raises(NumericalAcceptanceError, match="relative-only"):
+        parse_acceptance_fixture(changed_comparison)
+
+    changed_driver = copy.deepcopy(synthetic_payload)
+    changed_driver["references"]["full"]["driver_sha256"] = "f" * 64  # type: ignore[index]
+    with pytest.raises(NumericalAcceptanceError, match="canonical adapter driver"):
+        parse_acceptance_fixture(changed_driver)
+
+    extra_field = copy.deepcopy(synthetic_payload)
+    extra_field["unreviewed"] = True
+    with pytest.raises(NumericalAcceptanceError, match="fields differ"):
+        parse_acceptance_fixture(extra_field)
+
+
+def test_relative_comparator_has_no_absolute_escape_hatch() -> None:
+    reference = Decimal("0.000000000000000266945931894745456")
+    inside = reference * (Decimal(1) + RELATIVE_TOLERANCE / 2)
+    outside = reference * (Decimal(1) + RELATIVE_TOLERANCE * 2)
+
+    assert compare_relative(inside, reference).passed
+    assert not compare_relative(outside, reference).passed
+    assert compare_relative(Decimal(0), Decimal(0)).passed
+    assert not compare_relative(Decimal(0), reference).passed
+    assert not compare_relative(-reference, reference).passed
+    assert not compare_relative(
+        complex(float(reference), float(reference)), reference
+    ).passed
+    with pytest.raises(NumericalAcceptanceMismatch, match="strict relative bound"):
+        assert_relative_match(outside, reference, context="synthetic/sign-gate")
+
+
+def test_lane_helpers_keep_ordered_process_sets_static_and_artifact_safe() -> None:
+    for lane in ACCEPTANCE_LANES:
+        specs = lane_case_specs(lane)
+        assert len(specs) == 33
+        assert tuple((spec.n_final, spec.family_id or 1000) for spec in specs) == tuple(
+            sorted(
+                ((spec.n_final, spec.family_id or 1000) for spec in specs),
+            )
+        )
+        assert all(":" not in spec.artifact_name for spec in specs)
+        assert all(spec.artifact_name[0].isalpha() for spec in specs)
+        assert lane.jit_optimization_level == (3 if lane.mode == "compiled" else 2)
+        config = acceptance_module.lane_run_config(lane)
+        assert config.color.lc_flow_layout.value == lane.lc_flow_layout
+        if lane.accuracy == "full":
+            assert lane_case_specs(lane, group="extra") == EXTRA_FULL_COLOUR_CASES
+        else:
+            with pytest.raises(NumericalAcceptanceError, match="no 'extra'"):
+                lane_case_specs(lane, group="extra")
+
+    assert FULL_CANDIDATE_PRECISION_DIGITS == 200
+    assert NATIVE_PRECISION_DIGITS == 16
+
+
+def test_lane_precision_policy_keeps_on_the_fly_at_p16() -> None:
+    for lane in ACCEPTANCE_LANES:
+        expected = (NATIVE_PRECISION_DIGITS,)
+        if lane.accuracy == "full" and lane.mode != "on-the-fly":
+            expected += (FULL_CANDIDATE_PRECISION_DIGITS,)
+        assert lane.evaluation_precisions == expected
+        assert lane.evaluation_precisions_for("catalog") == expected
+        assert lane.evaluation_precisions_for("extra") == (
+            NATIVE_PRECISION_DIGITS,
+        )
+
+
+def test_runtime_lane_validation_binds_mode_and_color_accuracy() -> None:
+    lane = acceptance_module.AcceptanceLane("lc", "recurrence", 2)
+    runtime = SimpleNamespace(
+        execution_mode="recurrence",
+        physics=SimpleNamespace(color_accuracy="lc"),
+    )
+    acceptance_module._validate_runtime_lane(runtime, lane, context="synthetic")
+
+    runtime.physics.color_accuracy = "full"
+    with pytest.raises(NumericalAcceptanceError, match="color_accuracy='full'"):
+        acceptance_module._validate_runtime_lane(runtime, lane, context="synthetic")
+    runtime.physics.color_accuracy = "lc"
+    runtime.execution_mode = "eager"
+    with pytest.raises(NumericalAcceptanceError, match="mode='eager'"):
+        acceptance_module._validate_runtime_lane(runtime, lane, context="synthetic")
+
+
+def test_artifact_lane_validation_binds_all_flow_union(tmp_path: Path) -> None:
+    artifact = tmp_path / "union"
+    (artifact / "config").mkdir(parents=True)
+    (artifact / "config" / "effective.toml").write_text(
+        """
+[color]
+accuracy = "lc"
+lc_flow_layout = "all-flow-union"
+[evaluator]
+execution_mode = "recurrence"
+""".lstrip(),
+        encoding="utf-8",
+    )
+    union = acceptance_module.AcceptanceLane(
+        "lc", "recurrence", 2, "all-flow-union"
+    )
+    acceptance_module._validate_artifact_lane(artifact, union)
+
+    topology = acceptance_module.AcceptanceLane("lc", "recurrence", 2)
+    with pytest.raises(NumericalAcceptanceError, match="effective lane"):
+        acceptance_module._validate_artifact_lane(artifact, topology)
+
+
+def test_capture_runtime_identity_requires_repo_venv_site_packages(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repository = tmp_path / "repository"
+    prefix = repository / ".venv"
+    package_file = (
+        prefix / "lib" / f"python{sys.version_info.major}.{sys.version_info.minor}"
+        / "site-packages/pyamplicol/__init__.py"
+    )
+    package_file.parent.mkdir(parents=True)
+    package_file.touch()
+    source_file = repository / "src/pyamplicol/__init__.py"
+    source_file.parent.mkdir(parents=True)
+    source_file.touch()
+    monkeypatch.setattr(acceptance_module, "ROOT", repository)
+    package = ModuleType("pyamplicol")
+    package.__file__ = str(package_file)
+    package.__path__ = []  # type: ignore[attr-defined]
+    internal = ModuleType("pyamplicol._internal")
+    internal.__path__ = []  # type: ignore[attr-defined]
+    versions = ModuleType("pyamplicol._internal.versions")
+    versions.active_native_source_identity = lambda: (  # type: ignore[attr-defined]
+        "a" * 40,
+        "b" * 64,
+    )
+    monkeypatch.setitem(sys.modules, "pyamplicol", package)
+    monkeypatch.setitem(sys.modules, "pyamplicol._internal", internal)
+    monkeypatch.setitem(sys.modules, "pyamplicol._internal.versions", versions)
+    monkeypatch.setattr(acceptance_module.sys, "prefix", str(prefix))
+    monkeypatch.setattr(
+        acceptance_module.importlib.metadata,
+        "version",
+        lambda _name: "synthetic",
+    )
+
+    identity = acceptance_module._current_runtime_identity()
+    assert identity.source_revision == "a" * 40
+    assert identity.native_build_inputs_sha256 == "b" * 64
+
+    package.__file__ = str(source_file)
+    with pytest.raises(NumericalAcceptanceError, match=r"\.venv site-packages"):
+        acceptance_module._current_runtime_identity()
+
+
+def test_json_loader_rejects_duplicate_fields(
+    tmp_path: Path,
+    synthetic_payload: dict[str, object],
+) -> None:
+    path = tmp_path / "duplicates.json"
+    encoded = json.dumps(synthetic_payload)
+    path.write_text(encoded[:-1] + ',"kind":"duplicate"}', encoding="ascii")
+    with pytest.raises(NumericalAcceptanceError, match="duplicate JSON field"):
+        load_acceptance_fixture(path)
+
+
+def _write_json(path: Path, payload: object) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+
+
+def _point_payload(process: str) -> list[list[str]]:
+    return [
+        [str(component) for component in row]
+        for row in acceptance_module.validation_momenta(process)
+    ]
+
+
+def _measurement_payload(
+    spec: acceptance_module.AcceptanceCaseSpec,
+    *,
+    driver_sha256: str = MADGRAPH_DRIVER_SOURCE_SHA256,
+) -> dict[str, object]:
+    point = (
+        tuple(
+            tuple(float(component) for component in row)
+            for row in acceptance_module.validation_momenta(spec.process)
+        ),
+    )
+    external_sha = current_model_identity().external_parameters_sha256
+    command_card = madgraph_command_card(spec.process)
+    card = {
+        "binary64_exact_match": True,
+        "external_parameter_count": 1,
+        "external_parameters_sha256": external_sha,
+        "format": "%.14e",
+    }
+    return {
+        "status": "ok",
+        "matrix_element": 1.25,
+        "validation": {
+            "status": "ok",
+            "method": "independent-madgraph-tree-level-oracle",
+            "point_digest": point_digest(point),
+        },
+        "provenance": {
+            "method": "madgraph-standalone-custom-fortran-driver",
+            "command_card": command_card,
+            "command_card_sha256": hashlib.sha256(
+                command_card.encode("utf-8")
+            ).hexdigest(),
+            "report_momenta": point,
+            "model": {"name": "sm", "source_sha256": "1" * 64},
+            "exact_param_card": dict(card),
+            "default_restriction": dict(card),
+            "version": "synthetic-madgraph",
+            "driver_sha256": driver_sha256,
+        },
+    }
+
+
+def test_madgraph_measurement_requires_canonical_driver_without_timing_census() -> None:
+    spec = catalog_cases()[0]
+    value, identity = acceptance_module._madgraph_measurement(
+        _measurement_payload(spec),
+        spec,
+    )
+    assert value == Decimal("1.25")
+    assert identity.driver_sha256 == MADGRAPH_DRIVER_SOURCE_SHA256
+
+    changed = _measurement_payload(spec, driver_sha256="f" * 64)
+    with pytest.raises(NumericalAcceptanceError, match="authority contract"):
+        acceptance_module._madgraph_measurement(changed, spec)
+
+
+def _stub_raw_measurements(
+    monkeypatch: pytest.MonkeyPatch,
+    values: dict[str, Decimal],
+) -> MadGraphReferenceIdentity:
+    model = current_model_identity()
+    identity = MadGraphReferenceIdentity(
+        madgraph_version="synthetic-gate",
+        model_source_sha256="1" * 64,
+        driver_sha256=MADGRAPH_DRIVER_SOURCE_SHA256,
+        external_parameters_sha256=model.external_parameters_sha256,
+    )
+
+    def parse(
+        measurement: object,
+        spec: acceptance_module.AcceptanceCaseSpec,
+    ) -> tuple[Decimal, MadGraphReferenceIdentity]:
+        assert measurement == {"case_id": spec.case_id}
+        return values[spec.case_id], identity
+
+    monkeypatch.setattr(acceptance_module, "_madgraph_measurement", parse)
+    return identity
+
+
+def _synthetic_wave_root(root: Path, values: dict[str, Decimal]) -> Path:
+    specs = catalog_cases()
+    _write_json(
+        root / "manifest.json",
+        {
+            "kind": "pyamplicol-madgraph-ufo-sm-full-p200-wave-gate-v1",
+            "status": "running",
+            "seed": 101,
+            "max_n": 6,
+            "ordering": "n-final-then-family-id-then-mode",
+            "plan": [
+                {
+                    "cell_ordinal": ordinal,
+                    "family_id": spec.family_id,
+                    "n_final": spec.n_final,
+                    "process": spec.process,
+                    "process_key": spec.family_key,
+                }
+                for ordinal, spec in enumerate(specs)
+            ],
+        },
+    )
+    for spec in specs:
+        case_root = root / f"n{spec.n_final}" / f"family-{spec.family_id:02d}"
+        _write_json(
+            case_root / "point-seed-101.json",
+            _point_payload(spec.process),
+        )
+        _write_json(
+            case_root / "madgraph-measurement.json",
+            {"case_id": spec.case_id},
+        )
+        _write_json(
+            case_root / "madgraph-authority.json",
+            {
+                "process": spec.process,
+                "n_final": spec.n_final,
+                "seed": 101,
+                "madgraph_value": str(values[spec.case_id]),
+            },
+        )
+    return root
+
+
+def _synthetic_stress_root(root: Path, values: dict[str, Decimal]) -> Path:
+    keys = ("uu_four_identical_lines", "ee_four_identical_lines")
+    _write_json(
+        root / "manifest.json",
+        {
+            "kind": "pyamplicol-authenticated-noncatalog-n6-madgraph-stress-v1",
+            "status": "ok",
+            "stage": "complete",
+            "seed": 101,
+            "process_order": [
+                {"key": key, "process": spec.process, "n_final": 6}
+                for key, spec in zip(keys, EXTRA_FULL_COLOUR_CASES, strict=True)
+            ],
+            "catalog_policy": "direct synthetic CellSpec; REPORT_CATALOG not modified",
+        },
+    )
+    for case_ordinal, (key, spec) in enumerate(
+        zip(keys, EXTRA_FULL_COLOUR_CASES, strict=True)
+    ):
+        case_root = root / f"case-{case_ordinal + 1:02d}-{key}"
+        point = _point_payload(spec.process)
+        _write_json(case_root / "point-seed-101.json", point)
+        _write_json(
+            case_root / "madgraph-measurement.json",
+            {"case_id": spec.case_id},
+        )
+        _write_json(
+            case_root / "madgraph-authority-verification.json",
+            {
+                "process": spec.process,
+                "seed": 101,
+                "point": point,
+                "matrix_element_binary64": str(values[spec.case_id]),
+                "checks": {
+                    "status": True,
+                    "exact_seed_101_point": True,
+                    "exact_command_card": True,
+                    "custom_fortran_method": True,
+                    "custom_driver_digest": True,
+                    "exact_generated_process": True,
+                },
+            },
+        )
+    return root
+
+
+def test_wave_ingestion_reuses_only_madgraph_authority(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    values = {
+        spec.case_id: Decimal(index + 1) for index, spec in enumerate(catalog_cases())
+    }
+    identity = _stub_raw_measurements(monkeypatch, values)
+    root = _synthetic_wave_root(tmp_path / "wave", values)
+
+    ingested = ingest_authenticated_madgraph_wave_root(root)
+    assert ingested.values == values
+    assert ingested.identity == identity
+
+    manifest_path = root / "manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    for terminal_status in ("validation-failed", "error"):
+        manifest["status"] = terminal_status
+        _write_json(manifest_path, manifest)
+        with pytest.raises(NumericalAcceptanceError, match="cannot supply"):
+            ingest_authenticated_madgraph_wave_root(root)
+    manifest["status"] = "running"
+    _write_json(manifest_path, manifest)
+
+    last = catalog_cases()[-1]
+    authority_path = (
+        root / "n4" / f"family-{last.family_id:02d}" / "madgraph-authority.json"
+    )
+    authority = json.loads(authority_path.read_text(encoding="utf-8"))
+    authority["madgraph_value"] = "999"
+    _write_json(authority_path, authority)
+    with pytest.raises(NumericalAcceptanceError, match="authority"):
+        ingest_authenticated_madgraph_wave_root(root)
+
+
+def test_stress_ingestion_reuses_only_madgraph_authority(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    values = {
+        spec.case_id: Decimal(index + 101)
+        for index, spec in enumerate(EXTRA_FULL_COLOUR_CASES)
+    }
+    identity = _stub_raw_measurements(monkeypatch, values)
+    root = _synthetic_stress_root(tmp_path / "stress", values)
+
+    ingested = ingest_authenticated_extra_madgraph_root(root)
+    assert ingested.values == values
+    assert ingested.identity == identity
+
+    authority_path = (
+        root
+        / "case-01-uu_four_identical_lines"
+        / "madgraph-authority-verification.json"
+    )
+    authority = json.loads(authority_path.read_text(encoding="utf-8"))
+    authority["checks"]["custom_driver_digest"] = False
+    _write_json(authority_path, authority)
+    with pytest.raises(NumericalAcceptanceError, match="authority"):
+        ingest_authenticated_extra_madgraph_root(root)
+
+
+def test_capture_preflight_rejects_bidirectional_and_input_path_overlap(
+    tmp_path: Path,
+) -> None:
+    destination = tmp_path / "fixture.json"
+    with pytest.raises(NumericalAcceptanceError, match=r"outside.*work root"):
+        capture_acceptance_fixture(
+            madgraph_wave_root=tmp_path / "wave",
+            extra_madgraph_root=tmp_path / "stress",
+            work_root=destination / "work",
+            output=destination,
+        )
+
+    wave_root = tmp_path / "authenticated-wave"
+    wave_root.mkdir()
+    with pytest.raises(NumericalAcceptanceError, match="must not overlap"):
+        capture_acceptance_fixture(
+            madgraph_wave_root=wave_root,
+            extra_madgraph_root=tmp_path / "stress",
+            work_root=tmp_path / "work",
+            output=wave_root / "fixture.json",
+        )
diff --git a/pyamplicol/tests/unit/test_numerical_current_observation_acceptance.py b/pyamplicol/tests/unit/test_numerical_current_observation_acceptance.py
new file mode 100644
index 0000000000..c4dc797887
--- /dev/null
+++ b/pyamplicol/tests/unit/test_numerical_current_observation_acceptance.py
@@ -0,0 +1,545 @@
+# SPDX-License-Identifier: 0BSD
+"""Adversarial acceptance tests for proof-less numerical current relations."""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Sequence
+from dataclasses import replace
+from decimal import Decimal, localcontext
+
+import pytest
+
+from pyamplicol.generation import numerical_current_warmup
+from pyamplicol.generation.dag_equivalence import (
+    NumericalCurrentRelationCertificate,
+    _canonical_decimal_string,
+    _numerical_current_observation_batch_sha256,
+    _numerical_observations_sha256,
+    certify_numerical_current_observations,
+    verify_numerical_current_relation_certificate,
+)
+
+_SOURCE_SEMANTICS = hashlib.sha256(b"acceptance-source-semantics").hexdigest()
+_OTHER_SOURCE_SEMANTICS = hashlib.sha256(b"drifted-source-semantics").hexdigest()
+_RUNTIME_SCHEMA = hashlib.sha256(b"acceptance-runtime-schema").hexdigest()
+_SOURCE_DAG = hashlib.sha256(b"acceptance-source-dag").hexdigest()
+_CANDIDATE_CAPTURE = hashlib.sha256(b"candidate-capture").hexdigest()
+_VERIFICATION_CAPTURE = hashlib.sha256(
+    b"verification-capture"
+).hexdigest()
+_CANDIDATE_BATCH = hashlib.sha256(b"candidate-batch").hexdigest()
+_VERIFICATION_BATCH = hashlib.sha256(b"verification-batch").hexdigest()
+_ZERO = Decimal(0)
+
+_CANDIDATE_REPRESENTATIVE = (
+    (Decimal("1.25"), Decimal("0.5")),
+    (Decimal("-2.0"), Decimal("3.5")),
+    (Decimal("4.125"), Decimal("-0.75")),
+    (Decimal("-8.0"), Decimal("-1.5")),
+)
+_VERIFICATION_REPRESENTATIVE = (
+    (Decimal("0.375"), Decimal("-2.25")),
+    (Decimal("6.5"), Decimal("1.0")),
+    (Decimal("-3.125"), Decimal("4.75")),
+    (Decimal("9.0"), Decimal("-0.625")),
+)
+
+
+def _scaled(
+    values: Sequence[tuple[Decimal, Decimal]],
+    factor: Decimal,
+) -> tuple[tuple[Decimal, Decimal], ...]:
+    return tuple((factor * real, factor * imag) for real, imag in values)
+
+
+def _zero_values(count: int = 4) -> tuple[tuple[Decimal, Decimal], ...]:
+    return tuple((_ZERO, _ZERO) for _ in range(count))
+
+
+def _certify(
+    relation_kind: str,
+    *,
+    candidate_current_values: Sequence[tuple[Decimal, Decimal]],
+    verification_current_values: Sequence[tuple[Decimal, Decimal]],
+    candidate_representative_values: (
+        Sequence[tuple[Decimal, Decimal]] | None
+    ) = _CANDIDATE_REPRESENTATIVE,
+    verification_representative_values: (
+        Sequence[tuple[Decimal, Decimal]] | None
+    ) = _VERIFICATION_REPRESENTATIVE,
+    current_id: int = 11,
+    representative_id: int | None = 3,
+    seed: int = 0x5059414D,
+    relative_tolerance: float = 1.0e-70,
+    absolute_tolerance: float = 1.0e-80,
+) -> NumericalCurrentRelationCertificate | None:
+    return certify_numerical_current_observations(
+        current_id=current_id,
+        representative_id=representative_id,
+        relation_kind=relation_kind,  # type: ignore[arg-type]
+        source_semantics_sha256=_SOURCE_SEMANTICS,
+        runtime_schema_sha256=_RUNTIME_SCHEMA,
+        source_dag_sha256=_SOURCE_DAG,
+        candidate_capture_sha256=_CANDIDATE_CAPTURE,
+        verification_capture_sha256=_VERIFICATION_CAPTURE,
+        candidate_observation_batch_sha256=_CANDIDATE_BATCH,
+        verification_observation_batch_sha256=_VERIFICATION_BATCH,
+        candidate_current_values=candidate_current_values,
+        candidate_representative_values=candidate_representative_values,
+        verification_current_values=verification_current_values,
+        verification_representative_values=verification_representative_values,
+        precision_digits=96,
+        seed=seed,
+        relative_tolerance=relative_tolerance,
+        absolute_tolerance=absolute_tolerance,
+    )
+
+
+@pytest.mark.parametrize(
+    (
+        "relation_kind",
+        "candidate_current",
+        "verification_current",
+        "candidate_representative",
+        "verification_representative",
+        "representative_id",
+        "expected_factor",
+    ),
+    (
+        (
+            "equal",
+            _CANDIDATE_REPRESENTATIVE,
+            _VERIFICATION_REPRESENTATIVE,
+            _CANDIDATE_REPRESENTATIVE,
+            _VERIFICATION_REPRESENTATIVE,
+            3,
+            ["0x1.0000000000000p+0", "0x0.0p+0"],
+        ),
+        (
+            "opposite",
+            _scaled(_CANDIDATE_REPRESENTATIVE, Decimal(-1)),
+            _scaled(_VERIFICATION_REPRESENTATIVE, Decimal(-1)),
+            _CANDIDATE_REPRESENTATIVE,
+            _VERIFICATION_REPRESENTATIVE,
+            3,
+            ["-0x1.0000000000000p+0", "0x0.0p+0"],
+        ),
+        (
+            "zero",
+            _zero_values(),
+            _zero_values(),
+            None,
+            None,
+            None,
+            None,
+        ),
+    ),
+)
+@pytest.mark.parametrize("ambient_precision", (28, 50, 96))
+def test_equal_opposite_and_zero_relations_certify_and_replay(
+    relation_kind: str,
+    candidate_current: Sequence[tuple[Decimal, Decimal]],
+    verification_current: Sequence[tuple[Decimal, Decimal]],
+    candidate_representative: Sequence[tuple[Decimal, Decimal]] | None,
+    verification_representative: Sequence[tuple[Decimal, Decimal]] | None,
+    representative_id: int | None,
+    expected_factor: list[str] | None,
+    ambient_precision: int,
+) -> None:
+    with localcontext() as context:
+        context.prec = ambient_precision
+        certificate = _certify(
+            relation_kind,
+            candidate_current_values=candidate_current,
+            verification_current_values=verification_current,
+            candidate_representative_values=candidate_representative,
+            verification_representative_values=verification_representative,
+            representative_id=representative_id,
+        )
+
+    assert certificate is not None
+    payload = certificate.to_json_dict()
+    assert payload["algorithm"] == (
+        "authenticated-independent-recursive-decimal-probes-v1"
+    )
+    assert payload["proof_kind"] == "authenticated-numerical"
+    assert payload["relation_kind"] == relation_kind
+    assert payload["current_id"] == 11
+    assert payload["representative_id"] == representative_id
+    assert payload["factor_binary64"] == expected_factor
+    assert payload["source_semantics_sha256"] == _SOURCE_SEMANTICS
+    assert payload["candidate_probe_count"] == 4
+    assert payload["verification_probe_count"] == 4
+    assert payload["current_dimension"] == 1
+    for digest_field in (
+        "candidate_observations_sha256",
+        "verification_observations_sha256",
+        "runtime_schema_sha256",
+        "source_dag_sha256",
+        "candidate_capture_sha256",
+        "verification_capture_sha256",
+        "candidate_observation_batch_sha256",
+        "verification_observation_batch_sha256",
+        "probe_contract_sha256",
+        "proof_sha256",
+    ):
+        assert len(payload[digest_field]) == 64
+
+    restored = NumericalCurrentRelationCertificate.from_json_dict(payload)
+    assert restored == certificate
+    assert verify_numerical_current_relation_certificate(
+        restored,
+        source_semantics_sha256=_SOURCE_SEMANTICS,
+    )
+    assert not verify_numerical_current_relation_certificate(
+        restored,
+        source_semantics_sha256=_OTHER_SOURCE_SEMANTICS,
+    )
+
+    for field in (
+        "relative_tolerance_binary64",
+        "absolute_tolerance_binary64",
+    ):
+        noncanonical = dict(payload)
+        noncanonical[field] = str(payload[field]).upper()
+        with pytest.raises(ValueError, match="tolerances are invalid"):
+            NumericalCurrentRelationCertificate.from_json_dict(noncanonical)
+    negative_zero = dict(payload)
+    negative_zero["relative_tolerance_binary64"] = "-0x0.0p+0"
+    with pytest.raises(ValueError, match="tolerances are invalid"):
+        NumericalCurrentRelationCertificate.from_json_dict(negative_zero)
+    for spelling in ("-0", "0.0", "0e99"):
+        noncanonical_residual = dict(payload)
+        noncanonical_residual[
+            "candidate_maximum_absolute_residual"
+        ] = spelling
+        with pytest.raises(ValueError, match="canonical decimal"):
+            NumericalCurrentRelationCertificate.from_json_dict(
+                noncanonical_residual
+            )
+
+
+def test_generic_numerical_tolerance_boundaries_reject_negative_zero() -> None:
+    exact = _certify(
+        "equal",
+        candidate_current_values=_CANDIDATE_REPRESENTATIVE,
+        verification_current_values=_VERIFICATION_REPRESENTATIVE,
+        relative_tolerance=float.fromhex("0x0.0000000000001p-1022"),
+        absolute_tolerance=0.0,
+    )
+    assert exact is not None
+    assert exact.relative_tolerance.hex() == "0x0.0000000000001p-1022"
+    for invalid in (-0.0, float("nan"), float("inf")):
+        assert _certify(
+            "equal",
+            candidate_current_values=_CANDIDATE_REPRESENTATIVE,
+            verification_current_values=_VERIFICATION_REPRESENTATIVE,
+            relative_tolerance=invalid,
+            absolute_tolerance=1.0e-80,
+        ) is None
+
+
+@pytest.mark.parametrize("relation_kind", ("equal", "opposite", "zero"))
+def test_nearest_false_relation_with_documented_residual_is_rejected(
+    relation_kind: str,
+) -> None:
+    residual = Decimal("2.7396e-2")
+    if relation_kind == "zero":
+        candidate_current = ((residual, _ZERO), *_zero_values(3))
+        verification_current = ((_ZERO, residual), *_zero_values(3))
+        candidate_representative = None
+        verification_representative = None
+        representative_id = None
+    else:
+        factor = Decimal(1) if relation_kind == "equal" else Decimal(-1)
+        candidate_current = list(_scaled(_CANDIDATE_REPRESENTATIVE, factor))
+        verification_current = list(_scaled(_VERIFICATION_REPRESENTATIVE, factor))
+        candidate_current[2] = (
+            candidate_current[2][0] + residual,
+            candidate_current[2][1],
+        )
+        verification_current[1] = (
+            verification_current[1][0],
+            verification_current[1][1] - residual,
+        )
+        candidate_representative = _CANDIDATE_REPRESENTATIVE
+        verification_representative = _VERIFICATION_REPRESENTATIVE
+        representative_id = 3
+
+    assert (
+        _certify(
+            relation_kind,
+            candidate_current_values=candidate_current,
+            verification_current_values=verification_current,
+            candidate_representative_values=candidate_representative,
+            verification_representative_values=verification_representative,
+            representative_id=representative_id,
+        )
+        is None
+    )
+
+
+@pytest.mark.parametrize("ambient_precision", (28, 50, 96))
+def test_tolerance_boundary_is_inclusive_but_nearest_outside_value_fails(
+    ambient_precision: int,
+) -> None:
+    representative = tuple((Decimal(index), _ZERO) for index in range(1, 5))
+    at_boundary = tuple(
+        (Decimal(f"{index}.125"), _ZERO) for index in range(1, 5)
+    )
+    outside = tuple(
+        (
+            Decimal(f"{index}.125000000000000000000000000001"),
+            _ZERO,
+        )
+        for index in range(1, 5)
+    )
+
+    with localcontext() as context:
+        context.prec = ambient_precision
+        assert (
+            _certify(
+                "equal",
+                candidate_current_values=at_boundary,
+                verification_current_values=at_boundary,
+                candidate_representative_values=representative,
+                verification_representative_values=representative,
+                relative_tolerance=0.0,
+                absolute_tolerance=0.125,
+            )
+            is not None
+        )
+        assert (
+            _certify(
+                "equal",
+                candidate_current_values=outside,
+                verification_current_values=outside,
+                candidate_representative_values=representative,
+                verification_representative_values=representative,
+                relative_tolerance=0.0,
+                absolute_tolerance=0.125,
+            )
+            is None
+        )
+
+
+@pytest.mark.parametrize("ambient_precision", (28, 50, 96))
+def test_distinct_40_digit_observations_and_batch_hashes_do_not_collide(
+    ambient_precision: int,
+) -> None:
+    first = Decimal("1.123456789012345678901234567890123456789")
+    second = Decimal("1.123456789012345678901234567890123456788")
+    signed_zero = Decimal("-0.000")
+    point_sha256s = (hashlib.sha256(b"decimal-hash-point").hexdigest(),)
+    first_observations = {0: ((first, signed_zero),)}
+    second_observations = {0: ((second, signed_zero),)}
+    assert len(first.as_tuple().digits) == 40
+    assert len(second.as_tuple().digits) == 40
+
+    with localcontext() as context:
+        context.prec = ambient_precision
+        first_relation_digest = _numerical_observations_sha256(
+            relation_kind="zero",
+            current_values=first_observations[0],
+            representative_values=None,
+        )
+        second_relation_digest = _numerical_observations_sha256(
+            relation_kind="zero",
+            current_values=second_observations[0],
+            representative_values=None,
+        )
+        first_discovery_batch = (
+            _numerical_current_observation_batch_sha256(
+                first_observations,
+                point_sha256s=point_sha256s,
+            )
+        )
+        second_discovery_batch = (
+            _numerical_current_observation_batch_sha256(
+                second_observations,
+                point_sha256s=point_sha256s,
+            )
+        )
+        first_capture_batch = (
+            numerical_current_warmup._current_observation_batch_sha256(
+                first_observations,
+                point_sha256s=point_sha256s,
+            )
+        )
+        second_capture_batch = (
+            numerical_current_warmup._current_observation_batch_sha256(
+                second_observations,
+                point_sha256s=point_sha256s,
+            )
+        )
+
+    assert _canonical_decimal_string(first) != _canonical_decimal_string(second)
+    assert _canonical_decimal_string(signed_zero) == "0"
+    assert numerical_current_warmup._decimal_string(signed_zero) == "0"
+    assert _canonical_decimal_string(Decimal("1.0")) != (
+        _canonical_decimal_string(Decimal("1.00"))
+    )
+    assert numerical_current_warmup._decimal_string(Decimal("1.0")) != (
+        numerical_current_warmup._decimal_string(Decimal("1.00"))
+    )
+    assert first_relation_digest != second_relation_digest
+    assert first_discovery_batch != second_discovery_batch
+    assert first_capture_batch != second_capture_batch
+    assert first_discovery_batch == first_capture_batch
+    assert second_discovery_batch == second_capture_batch
+
+
+def test_candidate_match_with_independent_verification_mismatch_fails_closed() -> None:
+    assert (
+        _certify(
+            "equal",
+            candidate_current_values=_CANDIDATE_REPRESENTATIVE,
+            verification_current_values=_scaled(
+                _VERIFICATION_REPRESENTATIVE,
+                Decimal(-1),
+            ),
+        )
+        is None
+    )
+
+
+@pytest.mark.parametrize(
+    "nonfinite",
+    (Decimal("NaN"), Decimal("Infinity"), Decimal("-Infinity")),
+)
+def test_nonfinite_observations_fail_closed(nonfinite: Decimal) -> None:
+    current = list(_CANDIDATE_REPRESENTATIVE)
+    current[1] = (nonfinite, current[1][1])
+    assert (
+        _certify(
+            "equal",
+            candidate_current_values=current,
+            verification_current_values=_VERIFICATION_REPRESENTATIVE,
+        )
+        is None
+    )
+
+
+def test_malformed_relation_shapes_and_forward_representatives_fail_closed() -> None:
+    assert (
+        _certify(
+            "equal",
+            candidate_current_values=_CANDIDATE_REPRESENTATIVE[:-1],
+            verification_current_values=_VERIFICATION_REPRESENTATIVE,
+        )
+        is None
+    )
+    assert (
+        _certify(
+            "equal",
+            candidate_current_values=_CANDIDATE_REPRESENTATIVE,
+            verification_current_values=_VERIFICATION_REPRESENTATIVE,
+            candidate_representative_values=None,
+            verification_representative_values=None,
+        )
+        is None
+    )
+    assert (
+        _certify(
+            "zero",
+            candidate_current_values=_zero_values(),
+            verification_current_values=_zero_values(),
+            candidate_representative_values=_CANDIDATE_REPRESENTATIVE,
+            verification_representative_values=_VERIFICATION_REPRESENTATIVE,
+            representative_id=None,
+        )
+        is None
+    )
+    assert (
+        _certify(
+            "equal",
+            candidate_current_values=_CANDIDATE_REPRESENTATIVE,
+            verification_current_values=_VERIFICATION_REPRESENTATIVE,
+            current_id=11,
+            representative_id=11,
+        )
+        is None
+    )
+
+
+def test_certificate_is_deterministic_and_seed_bound() -> None:
+    first = _certify(
+        "equal",
+        candidate_current_values=_CANDIDATE_REPRESENTATIVE,
+        verification_current_values=_VERIFICATION_REPRESENTATIVE,
+        seed=101,
+    )
+    repeated = _certify(
+        "equal",
+        candidate_current_values=_CANDIDATE_REPRESENTATIVE,
+        verification_current_values=_VERIFICATION_REPRESENTATIVE,
+        seed=101,
+    )
+    changed_seed = _certify(
+        "equal",
+        candidate_current_values=_CANDIDATE_REPRESENTATIVE,
+        verification_current_values=_VERIFICATION_REPRESENTATIVE,
+        seed=102,
+    )
+    assert first is not None
+    assert repeated is not None
+    assert changed_seed is not None
+    assert first.to_json_dict() == repeated.to_json_dict()
+    assert (
+        first.to_json_dict()["proof_sha256"]
+        != changed_seed.to_json_dict()["proof_sha256"]
+    )
+
+
+def test_certificate_fails_closed_on_capture_or_runtime_splicing() -> None:
+    certificate = _certify(
+        "equal",
+        candidate_current_values=_CANDIDATE_REPRESENTATIVE,
+        verification_current_values=_VERIFICATION_REPRESENTATIVE,
+    )
+    assert certificate is not None
+    replacement_digest = hashlib.sha256(b"spliced-evidence").hexdigest()
+    for field_name in (
+        "runtime_schema_sha256",
+        "source_dag_sha256",
+        "candidate_capture_sha256",
+        "verification_capture_sha256",
+        "candidate_observation_batch_sha256",
+        "verification_observation_batch_sha256",
+    ):
+        tampered = replace(
+            certificate,
+            **{field_name: replacement_digest},
+        )
+        assert not verify_numerical_current_relation_certificate(
+            tampered,
+            source_semantics_sha256=_SOURCE_SEMANTICS,
+        )
+
+
+def test_selector_permutation_is_not_silently_inferred_by_relation_certifier() -> None:
+    permutation = (2, 0, 3, 1)
+    permuted = tuple(_CANDIDATE_REPRESENTATIVE[index] for index in permutation)
+
+    assert (
+        _certify(
+            "equal",
+            candidate_current_values=permuted,
+            verification_current_values=_VERIFICATION_REPRESENTATIVE,
+        )
+        is None
+    )
+
+    canonicalized = _certify(
+        "equal",
+        candidate_current_values=permuted,
+        verification_current_values=tuple(
+            _VERIFICATION_REPRESENTATIVE[index] for index in permutation
+        ),
+        candidate_representative_values=permuted,
+        verification_representative_values=tuple(
+            _VERIFICATION_REPRESENTATIVE[index] for index in permutation
+        ),
+    )
+    assert canonicalized is not None
diff --git a/pyamplicol/tests/unit/test_numerical_current_warmup.py b/pyamplicol/tests/unit/test_numerical_current_warmup.py
new file mode 100644
index 0000000000..86ba966c0b
--- /dev/null
+++ b/pyamplicol/tests/unit/test_numerical_current_warmup.py
@@ -0,0 +1,889 @@
+# SPDX-License-Identifier: 0BSD
+"""Real high-precision warm-up observations for numerical current reuse."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import replace
+from decimal import Decimal, localcontext
+from itertools import pairwise
+from math import isclose
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+
+from pyamplicol.generation import numerical_current_warmup
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_types import GenericDAG
+from pyamplicol.generation.numerical_current_warmup import (
+    GenericDAGCurrentObservationCapture,
+    build_numerical_current_probe_points,
+    capture_generic_dag_current_observations,
+    generic_dag_numerical_current_opt_out_report,
+    run_generic_dag_numerical_current_warmup,
+    validate_independent_current_observation_captures,
+)
+from pyamplicol.generation.stage_types import GenericStageOutputSlot
+from pyamplicol.generation.validation import ValidationPointRecord
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+_PRECISION_DIGITS = 96
+_SEED = 17
+
+
+@pytest.fixture(scope="module")
+def z_dag_and_model() -> tuple[GenericDAG, BuiltinSMModel]:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("d d~ > z", color_accuracy="lc"),
+        model=model,
+    )
+    return dag, model
+
+
+def _points(
+    dag: GenericDAG,
+    model: BuiltinSMModel,
+) -> tuple[
+    tuple[ValidationPointRecord, ...],
+    tuple[ValidationPointRecord, ...],
+]:
+    return build_numerical_current_probe_points(
+        dag,
+        model,
+        process_id="ddbar_z_numerical_warmup",
+        seed=_SEED,
+        candidate_count=4,
+        verification_count=4,
+    )
+
+
+def _synthetic_capture(
+    value: Decimal,
+) -> GenericDAGCurrentObservationCapture:
+    point_sha256s = (hashlib.sha256(b"application-validation-point").hexdigest(),)
+    observations = {0: ((value, Decimal(0)),)}
+    return GenericDAGCurrentObservationCapture(
+        precision_digits=_PRECISION_DIGITS,
+        points=(),
+        point_sha256s=point_sha256s,
+        kinematic_sha256s=(
+            hashlib.sha256(b"application-validation-kinematics").hexdigest(),
+        ),
+        parameter_contexts=((),),
+        parameter_context_sha256s=(
+            hashlib.sha256(b"application-validation-parameters").hexdigest(),
+        ),
+        observations=observations,
+        runtime_schema_sha256=hashlib.sha256(b"runtime-schema").hexdigest(),
+        model_parameter_schema_sha256=hashlib.sha256(
+            b"model-parameter-schema"
+        ).hexdigest(),
+        source_dag_sha256=hashlib.sha256(b"source-dag").hexdigest(),
+        evaluator_output_partition_abi=(
+            numerical_current_warmup._CAPTURE_OUTPUT_PARTITION_ABI
+        ),
+        evaluator_output_partition_sha256=hashlib.sha256(
+            b"evaluator-output-partition"
+        ).hexdigest(),
+        observation_batch_sha256=(
+            numerical_current_warmup._current_observation_batch_sha256(
+                observations,
+                point_sha256s=point_sha256s,
+            )
+        ),
+        capture_contract_sha256=hashlib.sha256(
+            b"application-validation-capture"
+        ).hexdigest(),
+    )
+
+
+def _output_slot(
+    *,
+    current_id: int,
+    value_slot_id: int,
+    output_start: int,
+    output_stop: int,
+) -> GenericStageOutputSlot:
+    return GenericStageOutputSlot(
+        value_slot_id=value_slot_id,
+        current_id=current_id,
+        variant="propagated",
+        component_start=output_start,
+        component_stop=output_stop,
+        output_start=output_start,
+        output_stop=output_stop,
+    )
+
+
+def _partition_stage(
+    *slots: GenericStageOutputSlot,
+    output_length: int | None = None,
+    stage_index: int = 1,
+) -> Any:
+    return SimpleNamespace(
+        stage_index=stage_index,
+        stage_kind="current-combine",
+        subset_size=2,
+        output_length=(
+            slots[-1].output_stop if output_length is None and slots else output_length
+        ),
+        output_slots=slots,
+        output_value_slot_ids=tuple(slot.value_slot_id for slot in slots),
+    )
+
+
+def test_current_output_partition_policy_is_exhaustive_and_identity_bound() -> None:
+    stage = _partition_stage(
+        _output_slot(
+            current_id=2,
+            value_slot_id=20,
+            output_start=0,
+            output_stop=2,
+        ),
+        _output_slot(
+            current_id=3,
+            value_slot_id=30,
+            output_start=2,
+            output_stop=4,
+        ),
+    )
+
+    partitions, contract = numerical_current_warmup._current_capture_output_partitions(
+        stage
+    )
+    repeated_partitions, repeated_digest = (
+        numerical_current_warmup._current_capture_partition_plan((stage,))
+    )
+
+    assert partitions == ((0, 2), (2, 4))
+    assert repeated_partitions == (partitions,)
+    assert len(repeated_digest) == 64
+    assert contract["partitions"] == [
+        {
+            "current_id": 2,
+            "output_start": 0,
+            "output_stop": 2,
+            "slots": [
+                {
+                    "value_slot_id": 20,
+                    "variant": "propagated",
+                    "component_start": 0,
+                    "component_stop": 2,
+                    "output_start": 0,
+                    "output_stop": 2,
+                }
+            ],
+        },
+        {
+            "current_id": 3,
+            "output_start": 2,
+            "output_stop": 4,
+            "slots": [
+                {
+                    "value_slot_id": 30,
+                    "variant": "propagated",
+                    "component_start": 2,
+                    "component_stop": 4,
+                    "output_start": 2,
+                    "output_stop": 4,
+                }
+            ],
+        },
+    ]
+
+
+@pytest.mark.parametrize(
+    ("slots", "output_length", "message"),
+    (
+        (
+            (
+                _output_slot(
+                    current_id=2,
+                    value_slot_id=20,
+                    output_start=0,
+                    output_stop=2,
+                ),
+                _output_slot(
+                    current_id=3,
+                    value_slot_id=30,
+                    output_start=3,
+                    output_stop=5,
+                ),
+            ),
+            5,
+            "overlap, gap",
+        ),
+        (
+            (
+                _output_slot(
+                    current_id=2,
+                    value_slot_id=20,
+                    output_start=0,
+                    output_stop=2,
+                ),
+                _output_slot(
+                    current_id=3,
+                    value_slot_id=30,
+                    output_start=1,
+                    output_stop=3,
+                ),
+            ),
+            3,
+            "overlap, gap",
+        ),
+        (
+            (
+                _output_slot(
+                    current_id=3,
+                    value_slot_id=30,
+                    output_start=0,
+                    output_stop=2,
+                ),
+                _output_slot(
+                    current_id=2,
+                    value_slot_id=20,
+                    output_start=2,
+                    output_stop=4,
+                ),
+            ),
+            4,
+            "current order",
+        ),
+        (
+            (
+                _output_slot(
+                    current_id=2,
+                    value_slot_id=20,
+                    output_start=0,
+                    output_stop=2,
+                ),
+                _output_slot(
+                    current_id=3,
+                    value_slot_id=30,
+                    output_start=2,
+                    output_stop=4,
+                ),
+                _output_slot(
+                    current_id=2,
+                    value_slot_id=40,
+                    output_start=4,
+                    output_stop=6,
+                ),
+            ),
+            6,
+            "current order",
+        ),
+    ),
+)
+def test_current_output_partition_policy_rejects_gap_overlap_and_order_drift(
+    slots: tuple[GenericStageOutputSlot, ...],
+    output_length: int,
+    message: str,
+) -> None:
+    with pytest.raises(ValueError, match=message):
+        numerical_current_warmup._current_capture_output_partitions(
+            _partition_stage(*slots, output_length=output_length)
+        )
+
+
+def test_partitioned_high_precision_replay_preserves_order_and_width() -> None:
+    class ExactSource:
+        def __init__(
+            self,
+            outputs: tuple[tuple[Decimal, Decimal], ...],
+        ) -> None:
+            self.outputs = outputs
+            self.calls: list[tuple[tuple[tuple[Decimal, Decimal], ...], int]] = []
+
+        def evaluate_complex_with_prec(
+            self,
+            values: tuple[tuple[Decimal, Decimal], ...],
+            precision: int,
+        ) -> tuple[tuple[Decimal, Decimal], ...]:
+            self.calls.append((values, precision))
+            return self.outputs
+
+    class ExactLeaf:
+        def __init__(self, input_len: int, source: ExactSource) -> None:
+            self.input_len = input_len
+            self._source_evaluator = source
+
+    first_source = ExactSource(
+        (
+            (Decimal(1), Decimal(0)),
+            (Decimal(2), Decimal(0)),
+        )
+    )
+    second_source = ExactSource(((Decimal(3), Decimal(0)),))
+    evaluator = numerical_current_warmup._PartitionedCurrentCaptureStageEvaluator(
+        evaluators=(
+            ExactLeaf(2, first_source),
+            ExactLeaf(1, second_source),
+        ),
+        chunk_input_indices=((0, 2), (1,)),
+        output_partitions=((0, 2), (2, 3)),
+        input_len=3,
+        output_len=3,
+    )
+    values = (
+        (Decimal(10), Decimal(0)),
+        (Decimal(20), Decimal(0)),
+        (Decimal(30), Decimal(0)),
+    )
+
+    assert evaluator.evaluate_complex_with_prec(values, 112) == (
+        (Decimal(1), Decimal(0)),
+        (Decimal(2), Decimal(0)),
+        (Decimal(3), Decimal(0)),
+    )
+    assert first_source.calls == [((values[0], values[2]), 112)]
+    assert second_source.calls == [((values[1],), 112)]
+
+    second_source.outputs = ()
+    with pytest.raises(ValueError, match="wrong output width"):
+        evaluator.evaluate_complex_with_prec(values, 112)
+
+
+def test_interpreted_stage_converts_complex_float_without_decimal_rounding() -> None:
+    from types import SimpleNamespace
+
+    expected = (
+        Decimal("1.234567890123456789012345678901234567890123456789"),
+        Decimal("-0"),
+    )
+    evaluator = SimpleNamespace(
+        evaluate_complex_with_prec=lambda _values, _precision: [
+            SimpleNamespace(to_decimal_tuple=lambda: expected)
+        ]
+    )
+
+    with localcontext() as context:
+        context.prec = 6
+        result = numerical_current_warmup._evaluate_interpreted_stage(
+            evaluator, (), precision=80
+        )[0]
+
+    assert result[0] is expected[0]
+    assert result[1] is expected[1]
+    assert result[1].is_signed()
+
+
+@pytest.mark.parametrize("ambient_precision", (28, 50, 96))
+@pytest.mark.parametrize(
+    ("optimized", "accepted"),
+    (
+        (Decimal("1.125"), True),
+        (Decimal("1.125000000000000000000000000001"), False),
+    ),
+)
+def test_application_validation_uses_configured_precision_at_tolerance_boundary(
+    ambient_precision: int,
+    optimized: Decimal,
+    accepted: bool,
+) -> None:
+    reference = _synthetic_capture(Decimal(1))
+    applied = _synthetic_capture(optimized)
+
+    with localcontext() as context:
+        context.prec = ambient_precision
+        if accepted:
+            result = numerical_current_warmup._validate_applied_current_observations(
+                reference,
+                applied,
+                relative_tolerance=0.0,
+                absolute_tolerance=0.125,
+            )
+            assert result["status"] == "verified"
+            assert Decimal(str(result["maximum_tolerance_ratio"])) <= 1
+        else:
+            with pytest.raises(
+                ValueError,
+                match="beyond its authenticated tolerance",
+            ):
+                numerical_current_warmup._validate_applied_current_observations(
+                    reference,
+                    applied,
+                    relative_tolerance=0.0,
+                    absolute_tolerance=0.125,
+                )
+
+
+def test_probe_points_are_deterministic_physically_distinct_domains(
+    z_dag_and_model: tuple[GenericDAG, BuiltinSMModel],
+) -> None:
+    dag, model = z_dag_and_model
+    candidate, verification = _points(dag, model)
+
+    assert (candidate, verification) == _points(dag, model)
+    all_points = (*candidate, *verification)
+    assert len({point.seed for point in all_points}) == 8
+    assert len({point.four_vectors for point in all_points}) == 8
+    for point in all_points:
+        incoming = point.four_vectors[:2]
+        outgoing = point.four_vectors[2:]
+        for component in range(4):
+            assert isclose(
+                sum(momentum[component] for momentum in incoming),
+                sum(momentum[component] for momentum in outgoing),
+                rel_tol=0.0,
+                abs_tol=1.0e-10,
+            )
+
+
+def test_capture_uses_only_interpreted_high_precision_stage_replay(
+    z_dag_and_model: tuple[GenericDAG, BuiltinSMModel],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    dag, model = z_dag_and_model
+    candidate, _verification = _points(dag, model)
+    real_compile = numerical_current_warmup._compile_symbolica_outputs
+    compile_contracts: list[dict[str, Any]] = []
+
+    def guarded_compile(*args: Any, **kwargs: Any) -> Any:
+        assert kwargs["jit_compile"] is False
+        output_partitions = tuple(kwargs["output_partitions"])
+        assert output_partitions
+        assert output_partitions[0][0] == 0
+        assert all(left[1] == right[0] for left, right in pairwise(output_partitions))
+        assert output_partitions[-1][1] == len(args[0])
+        settings = kwargs["symbolica_settings"]
+        assert settings.direct_translation is False
+        assert settings.jit_direct_translation is False
+        assert settings.jit_optimization_level == 0
+        compile_contracts.append(dict(kwargs))
+        return real_compile(*args, **kwargs)
+
+    monkeypatch.setattr(
+        numerical_current_warmup,
+        "_compile_symbolica_outputs",
+        guarded_compile,
+    )
+    capture = capture_generic_dag_current_observations(
+        dag,
+        model,
+        candidate,
+        precision_digits=_PRECISION_DIGITS,
+    )
+
+    assert compile_contracts
+    assert capture.precision_digits == _PRECISION_DIGITS
+    assert capture.point_count == 4
+    assert capture.current_count == len(dag.currents)
+    assert len(set(capture.kinematic_sha256s)) == 4
+    assert set(capture.observations) == {current.id for current in dag.currents}
+    for current in dag.currents:
+        values = capture.observations[current.id]
+        assert len(values) == capture.point_count * current.dimension
+        assert all(
+            isinstance(component, Decimal) and component.is_finite()
+            for value in values
+            for component in value
+        )
+    provenance = capture.to_provenance_dict()
+    assert provenance["complete_current_component_digest"] is True
+    assert provenance["components_embedded"] is False
+    assert provenance["point_major"] is True
+    assert str(provenance["abi"]).endswith("-v2")
+    assert provenance["evaluator_output_partition"] == {
+        "abi": numerical_current_warmup._CAPTURE_OUTPUT_PARTITION_ABI,
+        "sha256": capture.evaluator_output_partition_sha256,
+    }
+    assert len(capture.evaluator_output_partition_sha256) == 64
+    assert provenance["points"] == [point.to_mapping() for point in candidate]
+
+
+def test_transaction_reuses_one_baseline_capture_session(
+    z_dag_and_model: tuple[GenericDAG, BuiltinSMModel],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    dag, model = z_dag_and_model
+    real_builder = numerical_current_warmup._build_current_capture_session
+    built_dags: list[GenericDAG] = []
+
+    def counted_builder(*args: object, **kwargs: Any) -> Any:
+        built_dags.append(args[0])  # type: ignore[arg-type]
+        return real_builder(*args, **kwargs)
+
+    monkeypatch.setattr(
+        numerical_current_warmup,
+        "_build_current_capture_session",
+        counted_builder,
+    )
+    result = run_generic_dag_numerical_current_warmup(
+        dag,
+        model,
+        process_id="ddbar_z_session_reuse",
+        mode="certified-reuse",
+        execution_mode="compiled",
+        precision_digits=_PRECISION_DIGITS,
+        probe_count=4,
+        verification_probe_count=4,
+        seed=_SEED,
+        relative_tolerance=1.0e-70,
+        absolute_tolerance=1.0e-80,
+    )
+
+    assert result.application.report.applied_relation_count == 0
+    assert built_dags == [dag]
+    assert (
+        result.candidate_capture.evaluator_output_partition_sha256
+        == result.verification_capture.evaluator_output_partition_sha256
+    )
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+def test_real_capture_drives_authenticated_discovery_and_application(
+    z_dag_and_model: tuple[GenericDAG, BuiltinSMModel],
+    execution_mode: str,
+) -> None:
+    dag, model = z_dag_and_model
+    result = run_generic_dag_numerical_current_warmup(
+        dag,
+        model,
+        process_id="ddbar_z_numerical_warmup",
+        mode="certified-reuse",
+        execution_mode=execution_mode,  # type: ignore[arg-type]
+        precision_digits=_PRECISION_DIGITS,
+        probe_count=4,
+        verification_probe_count=4,
+        seed=_SEED,
+        relative_tolerance=1.0e-70,
+        absolute_tolerance=1.0e-80,
+    )
+    candidate = result.candidate_capture
+    verification = result.verification_capture
+    discovery = result.discovery
+    assert discovery.report.inspected_current_count == len(dag.currents)
+    assert (
+        discovery.report.candidate_observation_batch_sha256
+        == candidate.observation_batch_sha256
+    )
+    assert (
+        discovery.report.verification_observation_batch_sha256
+        == verification.observation_batch_sha256
+    )
+    assert set(candidate.parameter_context_sha256s).isdisjoint(
+        verification.parameter_context_sha256s
+    )
+    assert candidate.parameter_contexts
+    assert verification.parameter_contexts
+    parameter_count = len(candidate.parameter_contexts[0])
+    assert parameter_count
+    assert all(
+        len(context) == parameter_count
+        for context in (
+            *candidate.parameter_contexts,
+            *verification.parameter_contexts,
+        )
+    )
+    for parameter_index in range(parameter_count):
+        assert (
+            len(
+                {
+                    context[parameter_index]
+                    for context in (
+                        *candidate.parameter_contexts,
+                        *verification.parameter_contexts,
+                    )
+                }
+            )
+            > 1
+        )
+
+    application = result.application
+    if discovery.certificates:
+        assert application.report.state == "authenticated-numerical-applied"
+        assert application.report.warning_required
+        assert application.report.applied_relation_count == len(discovery.certificates)
+    else:
+        assert (
+            discovery.report.state
+            == application.report.state
+            == "no_certified_numerical_relation"
+        )
+        assert not application.report.warning_required
+        assert application.report.applied_relation_count == 0
+        assert application.dag is dag
+        assert result.application_capture is None
+        assert result.application_validation["status"] == (
+            "not-required-no-applied-relations"
+        )
+    payload = result.to_json_dict()
+    disabled = generic_dag_numerical_current_opt_out_report(
+        dag,
+        execution_mode=execution_mode,  # type: ignore[arg-type]
+    )
+    assert set(payload) - {"source_semantics"} == set(disabled)
+    assert "source_semantics" in payload
+    assert payload["candidate_capture"]["points"]
+    assert payload["verification_capture"]["points"]
+    assert payload["warning"]["required"] is result.warning_required
+    assert payload["effective_mode"] == "certified-reuse"
+    assert payload["relation_correctness"]["applied_relation_count"] == (
+        result.application.report.applied_relation_count
+    )
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+def test_public_opt_out_records_disabled_unoptimized_path_without_capture(
+    z_dag_and_model: tuple[GenericDAG, BuiltinSMModel],
+    execution_mode: str,
+) -> None:
+    dag, _model = z_dag_and_model
+    report = generic_dag_numerical_current_opt_out_report(
+        dag,
+        execution_mode=execution_mode,  # type: ignore[arg-type]
+    )
+
+    assert report["requested_mode"] == "off"
+    assert report["state"] == "disabled-by-user"
+    assert report["candidate_capture"] is None
+    assert report["verification_capture"] is None
+    assert report["application_capture"] is None
+    assert report["application_validation"]["status"] == "disabled-by-user"
+    assert report["certified_relation_count"] == 0
+    assert report["applied_relation_count"] == 0
+    assert report["effective_mode"] == "off"
+    assert "source_semantics" not in report
+    assert report["relation_correctness"] == {
+        "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+        "state": "no-applied-relations",
+        "applied_relation_count": 0,
+    }
+    assert report["warning"] == {
+        "required": False,
+        "emit": "never",
+        "code": None,
+        "message": None,
+    }
+
+
+def test_public_opt_out_does_not_serialize_wide_helicity_ancestry(
+    z_dag_and_model: tuple[GenericDAG, BuiltinSMModel],
+) -> None:
+    dag, _model = z_dag_and_model
+    current = dag.currents[0]
+    wide_ancestry = 10**4300
+    wide_current = replace(
+        current,
+        index=replace(current.index, helicity_ancestry=wide_ancestry),
+    )
+    wide_dag = replace(dag, currents=(wide_current, *dag.currents[1:]))
+
+    report = generic_dag_numerical_current_opt_out_report(
+        wide_dag,
+        execution_mode="compiled",
+    )
+
+    assert report["state"] == "disabled-by-user"
+    assert "source_semantics" not in report
+
+
+def test_generic_application_scope_contains_unsafe_relation_kinds() -> None:
+    equal = SimpleNamespace(relation_kind="equal")
+    opposite = SimpleNamespace(relation_kind="opposite")
+    zero = SimpleNamespace(relation_kind="zero")
+
+    contracted = numerical_current_warmup._application_scoped_certificates(
+        (equal, opposite, zero),  # type: ignore[arg-type]
+        allowed_relation_kinds=("zero", "equal"),
+    )
+    multi_helicity = numerical_current_warmup._application_scoped_certificates(
+        (equal, opposite, zero),  # type: ignore[arg-type]
+        allowed_relation_kinds=(),
+    )
+
+    assert contracted == (equal, zero)
+    assert multi_helicity == ()
+    with pytest.raises(ValueError, match="relation kind is invalid"):
+        numerical_current_warmup._application_scoped_certificates(
+            (SimpleNamespace(relation_kind="projective"),),  # type: ignore[arg-type]
+            allowed_relation_kinds=("equal",),
+        )
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+def test_certified_zero_currents_are_applied_and_revalidated_by_default(
+    execution_mode: str,
+) -> None:
+    model = BuiltinSMModel()
+    dag = compile_generic_dag(
+        build_process_ir("g g > g g", color_accuracy="full"),
+        model=model,
+    )
+
+    result = run_generic_dag_numerical_current_warmup(
+        dag,
+        model,
+        process_id="gg_gg_numerical_warmup",
+        mode="certified-reuse",
+        execution_mode=execution_mode,  # type: ignore[arg-type]
+        precision_digits=_PRECISION_DIGITS,
+        probe_count=4,
+        verification_probe_count=4,
+        relative_tolerance=1.0e-70,
+        absolute_tolerance=1.0e-80,
+        seed=_SEED,
+    )
+
+    assert result.discovery.certificates
+    assert any(
+        certificate.relation_kind == "zero"
+        for certificate in result.discovery.certificates
+    )
+    for certificate in result.discovery.certificates:
+        assert certificate.candidate_probe_count == 4
+        assert certificate.verification_probe_count == 4
+        assert (
+            certificate.current_dimension
+            == dag.currents[certificate.current_id].dimension
+        )
+    assert result.application.report.applied_relation_count == len(
+        result.discovery.certificates
+    )
+    assert (
+        result.application.report.interaction_evaluation_count_projected
+        < result.application.report.interaction_evaluation_count_before
+    )
+    assert result.warning_required
+    assert result.application_capture is not None
+    assert result.application_capture.parameter_contexts == (
+        result.verification_capture.parameter_contexts
+    )
+    assert result.application_validation["status"] == "verified"
+    assert result.application_validation["checked_current_count"] == len(dag.currents)
+    assert Decimal(
+        str(result.application_validation["maximum_tolerance_ratio"])
+    ) <= Decimal(1)
+    assert result.application_validation["maximum_absolute_residual"] == "0"
+    assert (
+        result.application_validation["evaluator_output_partition_sha256"]
+        == result.verification_capture.evaluator_output_partition_sha256
+    )
+
+
+def test_capture_domains_fail_closed_on_replay_drift(
+    z_dag_and_model: tuple[GenericDAG, BuiltinSMModel],
+) -> None:
+    dag, model = z_dag_and_model
+    candidate_points, verification_points = _points(dag, model)
+    with pytest.raises(ValueError, match="distinct physical momenta"):
+        capture_generic_dag_current_observations(
+            dag,
+            model,
+            (candidate_points[0], candidate_points[0]),
+            precision_digits=_PRECISION_DIGITS,
+        )
+    with pytest.raises(ValueError, match="does not match"):
+        capture_generic_dag_current_observations(
+            dag,
+            model,
+            (
+                replace(candidate_points[0], process="g g > z"),
+                candidate_points[1],
+            ),
+            precision_digits=_PRECISION_DIGITS,
+        )
+
+    candidate = capture_generic_dag_current_observations(
+        dag,
+        model,
+        candidate_points,
+        precision_digits=_PRECISION_DIGITS,
+    )
+    verification = capture_generic_dag_current_observations(
+        dag,
+        model,
+        verification_points,
+        precision_digits=_PRECISION_DIGITS,
+    )
+    repeated_kinematics = replace(
+        verification,
+        kinematic_sha256s=candidate.kinematic_sha256s,
+    )
+    with pytest.raises(ValueError, match="independent replay domains"):
+        validate_independent_current_observation_captures(
+            candidate,
+            repeated_kinematics,
+        )
+
+    changed_parameter_schema = replace(
+        verification,
+        model_parameter_schema_sha256=hashlib.sha256(
+            b"changed-model-parameter-schema"
+        ).hexdigest(),
+    )
+    with pytest.raises(ValueError, match="independent replay domains"):
+        validate_independent_current_observation_captures(
+            candidate,
+            changed_parameter_schema,
+        )
+
+    changed_partitions = (
+        replace(
+            verification,
+            evaluator_output_partition_abi=(
+                "pyamplicol-stale-current-output-partitions-v0"
+            ),
+        ),
+        replace(
+            verification,
+            evaluator_output_partition_sha256=hashlib.sha256(
+                b"stale-output-partitions"
+            ).hexdigest(),
+        ),
+    )
+    for changed_partition in changed_partitions:
+        with pytest.raises(ValueError, match="independent replay domains"):
+            validate_independent_current_observation_captures(
+                candidate,
+                changed_partition,
+            )
+        with pytest.raises(ValueError, match="provenance drifted"):
+            numerical_current_warmup._validate_applied_current_observations(
+                verification,
+                changed_partition,
+                relative_tolerance=1.0e-70,
+                absolute_tolerance=1.0e-80,
+            )
+
+    current_id = min(candidate.observations)
+    incomplete = replace(
+        verification,
+        observations={
+            **verification.observations,
+            current_id: verification.observations[current_id][:-1],
+        },
+    )
+    with pytest.raises(ValueError, match="widths drifted"):
+        validate_independent_current_observation_captures(
+            candidate,
+            incomplete,
+        )
+
+    changed_values = dict(verification.observations)
+    changed = list(changed_values[current_id])
+    changed[0] = (changed[0][0] + Decimal(1), changed[0][1])
+    changed_values[current_id] = tuple(changed)
+    changed_capture = replace(
+        verification,
+        observations=changed_values,
+    )
+    with pytest.raises(ValueError, match="beyond its authenticated tolerance"):
+        numerical_current_warmup._validate_applied_current_observations(
+            verification,
+            changed_capture,
+            relative_tolerance=1.0e-70,
+            absolute_tolerance=1.0e-80,
+        )
+
+    with pytest.raises(ValueError, match="provenance drifted"):
+        numerical_current_warmup._validate_applied_current_observations(
+            verification,
+            changed_parameter_schema,
+            relative_tolerance=1.0e-70,
+            absolute_tolerance=1.0e-80,
+        )
diff --git a/pyamplicol/tests/unit/test_on_the_fly_artifact_scheduling.py b/pyamplicol/tests/unit/test_on_the_fly_artifact_scheduling.py
new file mode 100644
index 0000000000..65e87aed81
--- /dev/null
+++ b/pyamplicol/tests/unit/test_on_the_fly_artifact_scheduling.py
@@ -0,0 +1,246 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import subprocess
+from collections.abc import Sequence
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.artifacts import ArtifactStore, CurrentRecord
+from tools.performance_report.cache import empty_measurement
+from tools.performance_report.campaign_policy import PolicyMeasurementState
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import (
+    Accuracy,
+    ArtifactPolicy,
+    CellSpec,
+    ExecutionMode,
+    ResultStatus,
+    Workload,
+)
+from tools.performance_report.resources import ResourceUsage, SupervisedResult
+from tools.performance_report.scheduler import (
+    CampaignScheduler,
+    CampaignSettings,
+    PlannedCell,
+    _artifact_consumer_cell_ids,
+    plan_campaign,
+)
+from tools.performance_report.service import ReportPaths, ReportService
+
+_REVISION = "current-revision"
+
+
+def _otf_pair() -> tuple[CellSpec, CellSpec]:
+    cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.dataset_id == "matrix_on_the_fly_builtin_sm_lc"
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+    )
+    selected = next(
+        cell for cell in cells if cell.workload is Workload.SELECTED_FLOW
+    )
+    all_flow = next(cell for cell in cells if cell.workload is Workload.ALL_FLOW)
+    return selected, all_flow
+
+
+def _measurement(cell: CellSpec) -> dict[str, object]:
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": ResultStatus.OK.value,
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 8.0e-7,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 0.0,
+            "relative_standard_error": 0.0,
+            "artifact": {},
+            "selector_contract": None,
+            "validation": {"status": ResultStatus.OK.value},
+            "resources": {},
+            "provenance": {
+                "report_source_revision": _REVISION,
+                "test_cell_id": cell.cell_id,
+            },
+        }
+    )
+    return measurement
+
+
+def _publish_current(
+    store: ArtifactStore,
+    cell: CellSpec,
+) -> CurrentRecord:
+    return store.new_attempt(cell.cell_id, ArtifactPolicy.REGENERATE).publish(
+        _measurement(cell)
+    )
+
+
+def _service(tmp_path: Path) -> ReportService:
+    repo_root = tmp_path / "repo"
+    (repo_root / "src/pyamplicol/_profiling_campaign").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=repo_root, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "report-tests@example.invalid"),
+        cwd=repo_root,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Report Tests"),
+        cwd=repo_root,
+        check=True,
+    )
+    (repo_root / "README.md").write_text("# report fixture\n", encoding="ascii")
+    subprocess.run(("git", "add", "README.md"), cwd=repo_root, check=True)
+    subprocess.run(
+        ("git", "commit", "-q", "-m", "Initialize fixture"),
+        cwd=repo_root,
+        check=True,
+    )
+    return ReportService(
+        ReportPaths.from_repo(
+            repo_root,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "locks",
+        )
+    )
+
+
+def test_otf_artifact_reuse_is_directional_and_preserves_owner_consumers() -> None:
+    selected, all_flow = _otf_pair()
+
+    assert REPORT_CATALOG.equivalent_cells(selected) == ()
+    assert REPORT_CATALOG.equivalent_cells(all_flow) == (selected,)
+    assert _artifact_consumer_cell_ids(
+        selected,
+        catalog=REPORT_CATALOG,
+    ) == tuple(sorted((selected.cell_id, all_flow.cell_id)))
+
+
+def test_regenerate_all_flow_forces_its_fresh_selected_owner_into_the_plan(
+    tmp_path: Path,
+) -> None:
+    selected, all_flow = _otf_pair()
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+    current = _publish_current(store, selected)
+
+    def resolve(
+        _cell: CellSpec,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState]:
+        return current, PolicyMeasurementState.SUCCESS
+
+    planned = plan_campaign(
+        (all_flow,),
+        store=store,
+        settings=CampaignSettings(artifact_policy=ArtifactPolicy.REGENERATE),
+        current_resolver=resolve,
+    )
+    otf = tuple(
+        item
+        for item in planned
+        if item.cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+    )
+
+    assert tuple(item.cell for item in otf) == (selected, all_flow)
+    assert otf[0].dependency is True
+    assert selected.cell_id in otf[1].prerequisite_cell_ids
+    assert otf[0].rank < otf[1].rank
+
+
+@pytest.mark.parametrize("force_refresh", [False, True])
+def test_regenerate_and_force_refresh_generate_selected_once_then_reuse_it(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    force_refresh: bool,
+) -> None:
+    selected, all_flow = _otf_pair()
+    service = _service(tmp_path)
+    old_selected = _publish_current(service.store, selected) if force_refresh else None
+    old_all_flow = _publish_current(service.store, all_flow) if force_refresh else None
+    commands: list[list[str]] = []
+
+    def fake_supervise(
+        command: Sequence[str],
+        **_arguments: object,
+    ) -> SupervisedResult:
+        captured = list(command)
+        commands.append(captured)
+        cell = REPORT_CATALOG.cell(captured[captured.index("--cell-id") + 1])
+        result_path = Path(captured[captured.index("--result-json") + 1])
+        result_path.write_text(
+            json.dumps(_measurement(cell), sort_keys=True) + "\n",
+            encoding="ascii",
+        )
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.validate_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler._symbolica_generation_lock_path",
+        lambda *_args, **_kwargs: tmp_path / "generation.lock",
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            artifact_policy=ArtifactPolicy.REGENERATE,
+            rerun=force_refresh,
+            target_runtime_seconds=1.0,
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    scheduler.source_revision = _REVISION
+
+    selected_outcome = scheduler._run_cell(PlannedCell(selected, False, None, 0))
+    selected_current = service.store.load_current(selected.cell_id)
+    assert selected_current is not None
+    all_flow_outcome = scheduler._run_cell(PlannedCell(all_flow, False, None, 1))
+
+    assert selected_outcome.status == all_flow_outcome.status == "ok"
+    assert len(commands) == 2
+    selected_command, all_flow_command = commands
+    assert "--reused-measurement-json" not in selected_command
+    assert "--generation-lock-path" in selected_command
+    assert "--generation-lock-path" not in all_flow_command
+    assert all_flow_command[
+        all_flow_command.index("--reused-measurement-json") + 1
+    ] == str(selected_current.result_path)
+    if old_selected is not None:
+        assert selected_current.attempt_id != old_selected.attempt_id
+        assert str(old_selected.result_path) not in all_flow_command
+    if old_all_flow is not None:
+        assert str(old_all_flow.result_path) not in selected_command
+        assert str(old_all_flow.result_path) not in all_flow_command
+
+
+def test_directional_owner_contract_is_scoped_to_otf_lc() -> None:
+    selected, _all_flow = _otf_pair()
+    recurrence = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.accuracy is Accuracy.LC
+        and cell.process_key == selected.process_key
+        and cell.n_final == selected.n_final
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+
+    assert REPORT_CATALOG.equivalent_cells(recurrence)
diff --git a/pyamplicol/tests/unit/test_on_the_fly_artifact_writer.py b/pyamplicol/tests/unit/test_on_the_fly_artifact_writer.py
new file mode 100644
index 0000000000..d2d8b0f5a8
--- /dev/null
+++ b/pyamplicol/tests/unit/test_on_the_fly_artifact_writer.py
@@ -0,0 +1,1613 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+import hashlib
+import io
+import json
+from dataclasses import replace
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+import pyamplicol.generation.artifact_writer as artifact_writer
+import pyamplicol.generation.service as service_module
+from pyamplicol.api.errors import ArtifactError, GenerationError
+from pyamplicol.api.requests import ModelSource, ProcessRequest, ProcessSet
+from pyamplicol.api.services import Generator
+from pyamplicol.artifacts import inspect_artifact, load_manifest
+from pyamplicol.artifacts import inspection as artifact_inspection
+from pyamplicol.artifacts.process_groups import (
+    initial_process_groups,
+    read_process_groups,
+)
+from pyamplicol.color import build_color_plan
+from pyamplicol.config import (
+    Action,
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    RunConfig,
+)
+from pyamplicol.generation.artifact_writer import (
+    OnTheFlyProcessArtifact,
+    _GenerationConfigProvenance,
+    write_schema_v3_artifact,
+)
+from pyamplicol.generation.evaluator_container import (
+    PacbinMemberKind,
+    PacbinMemberSource,
+    PacbinReader,
+    write_pacbin_atomic,
+)
+from pyamplicol.generation.process_grouping import GroupingBasis, GroupMember
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.generation.recurrence_physics import (
+    build_on_the_fly_runtime_metadata,
+)
+from pyamplicol.generation.validation import ValidationPointRecord
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.loading import load_compiled_model
+from pyamplicol.models.prepared import load_prepared_model_bundle
+from pyamplicol.models.prepared_target import canonical_architecture
+
+ROOT = Path(__file__).resolve().parents[2]
+_PROCESS_ID = "d_dbar_to_z"
+_SEED_MEMBER = "on-the-fly/process-seed-v1.bin"
+
+
+def _seed_identity(
+    *,
+    process_digest: str = "1" * 64,
+    external_leg_count: int = 3,
+) -> dict[str, object]:
+    return {
+        "abi": "pyamplicol-on-the-fly-process-seed-identity-v1",
+        "process_digest": process_digest,
+        "compiled_model_digest": "2" * 64,
+        "recurrence_template_catalog_digest": "3" * 64,
+        "prepared_kernel_pack_digest": "4" * 64,
+        "recurrence_direct_template_catalog_digest": "5" * 64,
+        "semantic_digest": "6" * 64,
+        "external_permutation": list(range(external_leg_count)),
+        "external_sources": [
+            {
+                "source_slot": slot,
+                "public_label": slot + 1,
+                "is_initial": slot < 2,
+                "states": [
+                    {
+                        "state_index": 0,
+                        "public_helicity": 0,
+                        "prepared_mass_parameter_slot": None,
+                    }
+                ],
+            }
+            for slot in range(external_leg_count)
+        ],
+    }
+
+
+def _seed_identity_from_source_projection(
+    source_projection: dict[str, object],
+    *,
+    process_digest: str | None = None,
+) -> dict[str, object]:
+    projected_digest = source_projection["process_digest"]
+    permutation = source_projection["external_permutation"]
+    sources = source_projection["external_sources"]
+    assert isinstance(projected_digest, str)
+    assert isinstance(permutation, list)
+    assert isinstance(sources, list)
+    identity = _seed_identity(
+        process_digest=(projected_digest if process_digest is None else process_digest)
+    )
+    identity["external_permutation"] = list(permutation)
+    compact_sources: list[dict[str, object]] = []
+    for source in sources:
+        assert isinstance(source, dict)
+        states = source["states"]
+        assert isinstance(states, list)
+        compact_sources.append(
+            {
+                "source_slot": source["source_slot"],
+                "public_label": source["public_label"],
+                "is_initial": source["is_initial"],
+                "states": [
+                    {
+                        "state_index": state["state_index"],
+                        "public_helicity": state["public_helicity"],
+                        "prepared_mass_parameter_slot": None,
+                    }
+                    for state in states
+                    if isinstance(state, dict)
+                ],
+            }
+        )
+    identity["external_sources"] = compact_sources
+    return identity
+
+
+def _prepared_model_path() -> Path:
+    architecture = canonical_architecture()
+    return (
+        ROOT
+        / "src"
+        / "pyamplicol"
+        / "assets"
+        / "prepared_models"
+        / f"built-in-sm-jit-o2-{architecture}.pyamplicol-model"
+    )
+
+
+def _configuration(
+    color_accuracy: str = "lc",
+    *,
+    contraction: str = "direct",
+    fft_basis: str = "trace",
+) -> _GenerationConfigProvenance:
+    return _GenerationConfigProvenance.from_config(
+        RunConfig(
+            action=Action.GENERATE,
+            color=ColorConfig(
+                accuracy=color_accuracy,
+                contraction=contraction,
+                fft_basis=fft_basis,
+            ),
+            generation=GenerationConfig(
+                emit_api_bundle=False,
+                validation=GenerationValidationConfig(
+                    enabled=False,
+                    post_build_validation=False,
+                ),
+            ),
+            evaluator=EvaluatorConfig(
+                execution_mode="on-the-fly",
+                optimization=EvaluatorOptimizationConfig(cores=1),
+            ),
+        )
+    )
+
+
+def _write_seed_container(path: Path, payload: bytes = b"compact-process-seed"):
+    return write_pacbin_atomic(
+        path,
+        (
+            PacbinMemberSource(
+                _SEED_MEMBER,
+                PacbinMemberKind.ON_THE_FLY_PROCESS_SEED,
+                source=io.BytesIO(payload),
+            ),
+        ),
+    )
+
+
+def _process_artifact(
+    tmp_path: Path,
+    *,
+    runtime_name: str = "runtime.pacbin",
+    process_id: str = _PROCESS_ID,
+    expression: str = "d d~ > z",
+) -> OnTheFlyProcessArtifact:
+    runtime_path = tmp_path / runtime_name
+    runtime_index = _write_seed_container(runtime_path)
+    bundle = load_prepared_model_bundle(_prepared_model_path())
+    process = build_process_ir(expression, color_accuracy="full")
+    return OnTheFlyProcessArtifact(
+        process_id=process_id,
+        expression=expression,
+        color_accuracy="lc",
+        external_pdgs=tuple(leg.pdg for leg in process.legs),
+        aliases=(),
+        physics={
+            "schema_version": 1,
+            "kind": artifact_writer.ON_THE_FLY_PUBLIC_METADATA_KIND,
+            "process_id": process_id,
+            "process": expression,
+            "color_accuracy": "lc",
+            "external_particles": [
+                {
+                    "index": index,
+                    "label": index + 1,
+                    "particle": leg.particle,
+                    "pdg": leg.pdg,
+                    "role": "initial" if index < 2 else "final",
+                    "momentum_slot": index,
+                    "momentum_components": ["E", "px", "py", "pz"],
+                }
+                for index, leg in enumerate(process.legs)
+            ],
+            "model_parameters": [],
+        },
+        runtime_path=runtime_path,
+        runtime_size_bytes=runtime_index.file_size,
+        runtime_sha256=hashlib.sha256(runtime_path.read_bytes()).hexdigest(),
+        runtime_member_count=1,
+        runtime_unpacked_size_bytes=sum(
+            member.length for member in runtime_index.members
+        ),
+        runtime_index_sha256=runtime_index.index_sha256,
+        referenced_kernel_ids=frozenset(
+            kernel.kernel_id for kernel in bundle.kernel_pack.kernels
+        ),
+        runtime_metadata={
+            "runtime_parameters": [],
+            "prepared_parameter_defaults": [],
+            "parameter_projection": [],
+            "external_legs": [],
+            "particle_masses": [],
+            "normalization": {},
+            "process_seed_identity": _seed_identity(
+                external_leg_count=len(process.legs)
+            ),
+        },
+        selector_policy={
+            "color_coverage": "complete",
+            "reference_color_word": None,
+            "trace_reflections_folded": False,
+            "selector_census": {
+                "physical_helicity_count": 1,
+                "physical_color_flow_count": 1,
+            },
+        },
+        color_contraction_payload=None,
+        color_contraction_summary=None,
+        point_tile_size=128,
+        query_construction_threads=3,
+        validation_point=ValidationPointRecord(
+            process_id=process_id,
+            process=expression,
+            seed=7,
+            error="not sampled in writer test",
+        ),
+        generation_filters={"on_the_fly": {"selector_coverage": "complete"}},
+    )
+
+
+def _contracted_process_artifact(
+    tmp_path: Path,
+    *,
+    color_accuracy: str,
+    contraction: str = "direct",
+    fft_basis: str = "trace",
+    expression: str = "d d~ > z",
+    process_id: str = _PROCESS_ID,
+) -> OnTheFlyProcessArtifact:
+    process = build_process_ir(expression, color_accuracy=color_accuracy)
+    color_plan = build_color_plan(
+        process,
+        basis=fft_basis,
+        color_accuracy=color_accuracy,
+        fold_trace_reflections=False,
+    )
+    contracted = service_module._build_on_the_fly_contracted_color_payload_v1(
+        color_plan,
+        contraction=contraction,
+    )
+    base = _process_artifact(
+        tmp_path,
+        runtime_name=f"{process_id}-{contraction}-runtime.pacbin",
+        process_id=process_id,
+        expression=expression,
+    )
+    return replace(
+        base,
+        color_accuracy=color_accuracy,
+        physics={**base.physics, "color_accuracy": color_accuracy},
+        runtime_metadata={
+            **base.runtime_metadata,
+            "normalization": {
+                "color_accuracy": color_accuracy,
+                "color_factor": 3.0,
+            },
+        },
+        selector_policy={
+            **base.selector_policy,
+            **({"color_basis": fft_basis} if fft_basis != "trace" else {}),
+            "color_coverage": "contracted",
+            "trace_reflections_folded": False,
+            "selector_census": {
+                "physical_helicity_count": 1,
+                "physical_color_flow_count": 1,
+            },
+        },
+        color_contraction_payload=contracted.payload,
+        color_contraction_summary=contracted.summary,
+    )
+
+
+def _prepare_writer_identity(monkeypatch: pytest.MonkeyPatch) -> None:
+    source_revision = "a" * 40
+    native_inputs = "b" * 64
+    monkeypatch.setattr(
+        artifact_writer,
+        "active_source_revision",
+        lambda: source_revision,
+    )
+    monkeypatch.setattr(
+        artifact_writer,
+        "active_native_build_inputs_sha256",
+        lambda: native_inputs,
+    )
+    monkeypatch.setattr(
+        artifact_writer,
+        "_target_metadata",
+        lambda _config: (
+            {"triple": "aarch64-apple-darwin", "cpu_features": []},
+            1,
+        ),
+    )
+    monkeypatch.setattr(
+        artifact_writer,
+        "_derive_eager_direct_descriptor",
+        lambda source, **_widths: b"direct-table:" + source,
+    )
+
+
+def test_producer_keeps_authenticated_native_digest_without_revision(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    native_inputs = "b" * 64
+    monkeypatch.setattr(artifact_writer, "package_version", lambda: "0.1.0")
+    monkeypatch.setattr(artifact_writer, "active_source_revision", lambda: None)
+    monkeypatch.setattr(
+        artifact_writer,
+        "active_native_build_inputs_sha256",
+        lambda: native_inputs,
+    )
+    monkeypatch.setattr(
+        artifact_writer,
+        "_target_metadata",
+        lambda _config: (
+            {"triple": "aarch64-apple-darwin", "cpu_features": []},
+            1,
+        ),
+    )
+
+    producer = artifact_writer._producer_metadata(RunConfig(action=Action.GENERATE))
+
+    assert producer["native_build_inputs_sha256"] == native_inputs
+    assert "git_revision" not in producer
+
+
+def test_append_rejects_native_build_input_mismatch() -> None:
+    existing = SimpleNamespace(
+        runtime={"required_runtime_capabilities": []},
+        producer={
+            "distribution": "pyamplicol",
+            "version": "0.1.0",
+            "native_build_inputs_sha256": "a" * 64,
+        },
+    )
+
+    with pytest.raises(ValueError, match="native build-input digest differs"):
+        artifact_writer._validate_append_compatibility(
+            existing,
+            producer={
+                "distribution": "pyamplicol",
+                "version": "0.1.0",
+                "native_build_inputs_sha256": "b" * 64,
+            },
+            model={},
+            eager_pack_identity=None,
+            requested_bytes=b"",
+            effective_bytes=b"",
+            adjustments=(),
+            processes=(),
+        )
+
+
+def _payload_inventory(root: Path) -> tuple[tuple[object, ...], ...]:
+    manifest = load_manifest(root)
+    return tuple(
+        sorted(
+            (
+                record.path,
+                record.role,
+                record.process_id,
+            )
+            for record in manifest.payloads
+        )
+    )
+
+
+def test_on_the_fly_writer_publishes_one_seed_and_compact_metadata_deterministically(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _prepare_writer_identity(monkeypatch)
+    source_path = _prepared_model_path()
+    compiled = load_compiled_model(source_path)
+    first_process = _process_artifact(tmp_path, runtime_name="first.pacbin")
+    second_process = _process_artifact(tmp_path, runtime_name="second.pacbin")
+    first = tmp_path / "first-artifact"
+    second = tmp_path / "second-artifact"
+
+    for output, process in ((first, first_process), (second, second_process)):
+        write_schema_v3_artifact(
+            output,
+            mode="error",
+            source=ModelSource.from_path(source_path),
+            compiled_model=compiled,
+            configuration=_configuration(),
+            processes=(process,),
+            timings={"total": 0.1},
+            api_bundle_hook=None,
+        )
+
+    runtime_relative = f"processes/{_PROCESS_ID}/on-the-fly-runtime.pacbin"
+    for output in (first, second):
+        manifest = load_manifest(output)
+        structural_proof_path = f"processes/{_PROCESS_ID}/structural-source-proof.json"
+        assert [
+            (record.path, record.role)
+            for record in manifest.payloads
+            if record.path == structural_proof_path
+            or record.role == artifact_writer.STRUCTURAL_SOURCE_PROOF_ROLE
+        ] == []
+        assert not (output / structural_proof_path).exists()
+        runtime = output / runtime_relative
+        with PacbinReader.open(runtime, verify_payloads=True) as reader:
+            assert [
+                (member.logical_path, member.kind) for member in reader.members
+            ] == [(_SEED_MEMBER, PacbinMemberKind.ON_THE_FLY_PROCESS_SEED)]
+        physics = json.loads(
+            (output / f"processes/{_PROCESS_ID}/physics.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        assert physics["kind"] == artifact_writer.ON_THE_FLY_PUBLIC_METADATA_KIND
+        assert len(physics["external_particles"]) == 3
+        assert not {
+            "color_components",
+            "helicities",
+            "lc_topology_replay",
+            "recurrence",
+            "stages",
+        }.intersection(physics)
+        execution = json.loads(
+            (output / f"processes/{_PROCESS_ID}/execution.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        assert execution["kind"] == artifact_writer.ON_THE_FLY_RUNTIME_KIND
+        assert "color_contraction" not in execution["runtime_metadata"]
+        assert not (output / f"processes/{_PROCESS_ID}/on-the-fly-color.bin").exists()
+        assert execution["selector_policy"]["selector_census"] == {
+            "physical_helicity_count": 1,
+            "physical_color_flow_count": 1,
+        }
+        assert execution["runtime_options"] == {
+            "point_tile_size": 128,
+            "query_construction_threads": 3,
+        }
+        assert execution["runtime_container"] == {
+            "kind": artifact_writer.ON_THE_FLY_RUNTIME_CONTAINER_KIND,
+            "path": "on-the-fly-runtime.pacbin",
+            "schema_version": 1,
+            "seed_member_path": _SEED_MEMBER,
+            "storage_abi": "pacbin-v1",
+        }
+        inspected = inspect_artifact(output).processes[0]
+        assert inspected.execution_mode == "on-the-fly"
+        assert inspected.lc_flow_layout == "compact/query-local"
+        assert inspected.requested_point_tile_size == 128
+        assert inspected.effective_point_tile_size is None
+        assert inspected.requested_query_construction_threads == 3
+        assert inspected.physical_helicities == inspected.computed_helicities == 1
+        assert inspected.physical_color_components == 1
+        assert inspected.computed_color_components == 1
+        assert inspected.helicity_coverage == inspected.color_coverage == "complete"
+        assert inspected.generation_specialized_axes == ()
+        assert inspected.lc_physical_sector_count == 1
+        assert inspected.lc_materialized_sector_count is None
+        assert inspected.lc_replayed_sector_count is None
+        assert inspected.lc_residual_sector_count is None
+
+    assert isinstance(execution, dict)
+    process_record = manifest.processes[0]
+    capabilities = process_record["required_runtime_capabilities"]
+    assert isinstance(capabilities, tuple)
+    for index, mutation in enumerate(({"key": "wrong-process"}, {"invented": True})):
+        mutated_execution = {**execution, **mutation}
+        mutated_path = tmp_path / f"mutated-execution-{index}.json"
+        mutated_path.write_text(json.dumps(mutated_execution), encoding="utf-8")
+        with pytest.raises(ArtifactError, match=r"outer process|root fields"):
+            artifact_inspection._execution_inspection(
+                manifest,
+                mutated_path,
+                capabilities,
+                process=process_record,
+            )
+
+    assert (first / runtime_relative).read_bytes() == (
+        second / runtime_relative
+    ).read_bytes()
+    assert _payload_inventory(first) == _payload_inventory(second)
+
+
+@pytest.mark.parametrize("color_accuracy", ("nlc", "full"))
+def test_on_the_fly_writer_publishes_authenticated_contracted_color(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    color_accuracy: str,
+) -> None:
+    _prepare_writer_identity(monkeypatch)
+    source_path = _prepared_model_path()
+    output = tmp_path / f"{color_accuracy}-artifact"
+    process = _contracted_process_artifact(
+        tmp_path,
+        color_accuracy=color_accuracy,
+    )
+
+    write_schema_v3_artifact(
+        output,
+        mode="error",
+        source=ModelSource.from_path(source_path),
+        compiled_model=load_compiled_model(source_path),
+        configuration=_configuration(color_accuracy),
+        processes=(process,),
+        timings={"total": 0.1},
+        api_bundle_hook=None,
+    )
+
+    manifest = load_manifest(output)
+    color_path = f"processes/{_PROCESS_ID}/on-the-fly-color.bin"
+    color_record = next(
+        record for record in manifest.payloads if record.path == color_path
+    )
+    color_payload = (output / color_path).read_bytes()
+    execution = json.loads(
+        (output / f"processes/{_PROCESS_ID}/execution.json").read_text(encoding="utf-8")
+    )
+    reference = execution["runtime_metadata"]["color_contraction"]
+
+    assert color_payload == process.color_contraction_payload
+    assert color_record.sha256 == hashlib.sha256(color_payload).hexdigest()
+    assert reference == {
+        **process.color_contraction_summary,
+        "path": "on-the-fly-color.bin",
+        "size_bytes": len(color_payload),
+        "sha256": color_record.sha256,
+    }
+    assert execution["required_runtime_capabilities"] == sorted(
+        (
+            "rusticol.on-the-fly.complex-f64.v1",
+            "rusticol.on-the-fly.contracted-color.v1",
+        )
+    )
+    assert execution["selector_policy"] == {
+        "color_coverage": "contracted",
+        "reference_color_word": None,
+        "trace_reflections_folded": False,
+        "selector_census": {
+            "physical_helicity_count": 1,
+            "physical_color_flow_count": 1,
+        },
+    }
+    inspected = inspect_artifact(output).processes[0]
+    assert inspected.execution_mode == "on-the-fly"
+    assert inspected.color_accuracy == color_accuracy
+    assert inspected.physical_color_components == 1
+    assert inspected.computed_color_components == 1
+    assert inspected.color_coverage == "contracted"
+    assert inspected.color_flow_runtime_contract is None
+    assert inspected.recurrence_color_accuracy == color_accuracy
+    assert inspected.recurrence_color_storage == "expanded"
+    assert inspected.recurrence_color_component_count == 1
+    assert inspected.recurrence_color_group_count == 1
+    assert inspected.recurrence_color_destination_count == 1
+
+
+@pytest.mark.parametrize(
+    ("color_accuracy", "color_basis"),
+    (("lc", "trace"), ("nlc", "adjoint"), ("full", "adjoint")),
+)
+def test_on_the_fly_writer_and_inspector_validate_optional_color_basis(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    color_accuracy: str,
+    color_basis: str,
+) -> None:
+    _prepare_writer_identity(monkeypatch)
+    source_path = _prepared_model_path()
+    contracted = color_accuracy != "lc"
+    contraction = "symmetric-group-fft" if contracted else "direct"
+    process = (
+        _contracted_process_artifact(
+            tmp_path,
+            color_accuracy=color_accuracy,
+            contraction=contraction,
+            fft_basis=color_basis,
+            expression="g g > g g",
+        )
+        if contracted
+        else _process_artifact(tmp_path)
+    )
+    process = replace(
+        process, selector_policy={**process.selector_policy, "color_basis": color_basis}
+    )
+    output = tmp_path / "artifact"
+    write_schema_v3_artifact(
+        output,
+        mode="error",
+        source=ModelSource.from_path(source_path),
+        compiled_model=load_compiled_model(source_path),
+        configuration=_configuration(
+            color_accuracy, contraction=contraction, fft_basis=color_basis
+        ),
+        processes=(process,),
+        timings={},
+        api_bundle_hook=None,
+    )
+    manifest = load_manifest(output)
+    execution_path = output / f"processes/{_PROCESS_ID}/execution.json"
+    execution = json.loads(execution_path.read_text(encoding="utf-8"))
+    assert execution["selector_policy"]["color_basis"] == color_basis
+    assert inspect_artifact(output).processes[0].color_accuracy == color_accuracy
+    color_record = next(
+        (
+            record
+            for record in manifest.payloads
+            if record.path == f"processes/{_PROCESS_ID}/on-the-fly-color.bin"
+        ),
+        None,
+    )
+    mutations = [{"color_basis": value} for value in ("other", None, True, [])]
+    mutations.append(
+        {"trace_reflections_folded": True}
+        if contracted
+        else {"color_basis": "adjoint"}
+    )
+    if contracted:
+        mutations.append({"color_coverage": "complete"})
+    for index, mutation in enumerate(mutations):
+        policy = {**process.selector_policy, **mutation}
+        with pytest.raises(ValueError, match=r"basis|contracted|selector policy"):
+            artifact_writer._on_the_fly_execution_summary(
+                replace(process, selector_policy=policy),
+                color_contraction_record=color_record,
+            )
+        invalid_execution = {**execution, "selector_policy": policy}
+        invalid_path = tmp_path / f"invalid-basis-{index}.json"
+        invalid_path.write_text(json.dumps(invalid_execution), encoding="utf-8")
+        with pytest.raises(ArtifactError, match=r"basis|contracted|selector_policy"):
+            artifact_inspection._execution_inspection(
+                manifest,
+                invalid_path,
+                execution["required_runtime_capabilities"],
+                process=manifest.processes[0],
+            )
+
+
+def test_color_contraction_regenerates_only_the_process_artifact_identity(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _prepare_writer_identity(monkeypatch)
+    source_path = _prepared_model_path()
+    source = ModelSource.from_path(source_path)
+    compiled = load_compiled_model(source_path)
+    expression = "g g > g g"
+    process_id = "g_g_to_g_g"
+    manifests = {}
+    color_payload_digests = {}
+
+    for contraction in ("direct", "symmetric-group-fft"):
+        output = tmp_path / contraction
+        process = _contracted_process_artifact(
+            tmp_path,
+            color_accuracy="full",
+            contraction=contraction,
+            expression=expression,
+            process_id=process_id,
+        )
+        write_schema_v3_artifact(
+            output,
+            mode="error",
+            source=source,
+            compiled_model=compiled,
+            configuration=_configuration(
+                "full",
+                contraction=contraction,
+            ),
+            processes=(process,),
+            timings={"total": 0.1},
+            api_bundle_hook=None,
+        )
+        manifest = load_manifest(output)
+        manifests[contraction] = manifest
+        color_payload_digests[contraction] = next(
+            record.sha256
+            for record in manifest.payloads
+            if record.path == f"processes/{process_id}/on-the-fly-color.bin"
+        )
+
+    direct = manifests["direct"]
+    fft = manifests["symmetric-group-fft"]
+    assert (
+        color_payload_digests["direct"] != color_payload_digests["symmetric-group-fft"]
+    )
+    assert direct.artifact_id != fft.artifact_id
+
+    # The setting selects a process-owned reduction payload. It must not
+    # invalidate either the prepared model or its authenticated native kernels.
+    assert direct.model == fft.model
+    assert (
+        direct.extensions["eager_prepared_pack"]
+        == fft.extensions["eager_prepared_pack"]
+    )
+    assert (
+        direct.producer["native_build_inputs_sha256"]
+        == fft.producer["native_build_inputs_sha256"]
+    )
+
+
+def test_on_the_fly_writer_append_skips_structural_proofs_for_complete_set(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _prepare_writer_identity(monkeypatch)
+    source_path = _prepared_model_path()
+    source = ModelSource.from_path(source_path)
+    compiled = load_compiled_model(source_path)
+    artifact = tmp_path / "artifact"
+    first = _process_artifact(tmp_path, runtime_name="first.pacbin")
+    second_process_id = "d_dbar_to_z_copy"
+    second = _process_artifact(
+        tmp_path,
+        runtime_name="second.pacbin",
+        process_id=second_process_id,
+    )
+
+    write_schema_v3_artifact(
+        artifact,
+        mode="error",
+        source=source,
+        compiled_model=compiled,
+        configuration=_configuration(),
+        processes=(first,),
+        timings={"total": 0.1},
+        api_bundle_hook=None,
+    )
+    write_schema_v3_artifact(
+        artifact,
+        mode="append",
+        source=source,
+        compiled_model=compiled,
+        configuration=_configuration(),
+        processes=(second,),
+        timings={"total": 0.2},
+        api_bundle_hook=None,
+    )
+
+    manifest = load_manifest(artifact)
+    assert tuple(record["id"] for record in manifest.processes) == (
+        _PROCESS_ID,
+        second_process_id,
+    )
+    assert [
+        record.path
+        for record in manifest.payloads
+        if record.role == artifact_writer.STRUCTURAL_SOURCE_PROOF_ROLE
+    ] == []
+    for process_id in (_PROCESS_ID, second_process_id):
+        assert not (
+            artifact / f"processes/{process_id}/structural-source-proof.json"
+        ).exists()
+    assert [
+        process.execution_mode for process in inspect_artifact(artifact).processes
+    ] == ["on-the-fly", "on-the-fly"]
+
+
+def test_writer_records_process_groups_and_appended_processes(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _prepare_writer_identity(monkeypatch)
+    source_path = _prepared_model_path()
+    source = ModelSource.from_path(source_path)
+    compiled = load_compiled_model(source_path)
+    artifact = tmp_path / "artifact"
+    assumed = GroupMember(
+        process_id="u_ubar_to_z",
+        expression="u u~ > z",
+        pdgs=(2, -2, 23),
+        initial_count=2,
+        permutation=(0, 1, 2),
+        basis=GroupingBasis.FLAVOR_BLIND,
+        generated=False,
+    )
+    write_schema_v3_artifact(
+        artifact,
+        mode="error",
+        source=source,
+        compiled_model=compiled,
+        configuration=_configuration(),
+        processes=(_process_artifact(tmp_path, runtime_name="first.pacbin"),),
+        timings={"total": 0.1},
+        api_bundle_hook=None,
+        process_groups=initial_process_groups(
+            [(_PROCESS_ID, "d d~ > z", (1, -1, 23))], {_PROCESS_ID: [assumed]}
+        ),
+    )
+    stored = read_process_groups(artifact)
+    assert stored is not None
+    assert [(member.process_id, member.generated) for member in stored.members()] == [
+        (_PROCESS_ID, True),
+        ("u_ubar_to_z", False),
+    ]
+
+    # Generating an assumed member makes it a representative of its own.
+    write_schema_v3_artifact(
+        artifact,
+        mode="append",
+        source=source,
+        compiled_model=compiled,
+        configuration=_configuration(),
+        processes=(
+            _process_artifact(
+                tmp_path,
+                runtime_name="second.pacbin",
+                process_id="u_ubar_to_z",
+                expression="u u~ > z",
+            ),
+        ),
+        timings={"total": 0.2},
+        api_bundle_hook=None,
+    )
+    manifest = load_manifest(artifact, verify_payloads=True)
+    assert [
+        (record.role, record.media_type)
+        for record in manifest.payloads
+        if record.path == "process-groups.json"
+    ] == [("process-groups", "application/json")]
+    appended = read_process_groups(artifact)
+    assert appended is not None
+    assert {
+        identifier: [
+            (member.process_id, member.factor, member.permutation, member.basis)
+            for member in group.members
+        ]
+        for identifier, group in appended.groups.items()
+    } == {
+        _PROCESS_ID: [(_PROCESS_ID, 1, (0, 1, 2), GroupingBasis.IDENTITY)],
+        "u_ubar_to_z": [("u_ubar_to_z", 1, (0, 1, 2), GroupingBasis.IDENTITY)],
+    }
+
+
+@pytest.mark.parametrize(
+    ("roles", "expected_color_flows"),
+    (
+        (("singlet",) * 6, 1),
+        (("adjoint",) * 4, 6),
+        (
+            (
+                "fundamental",
+                "antifundamental",
+                "fundamental",
+                "antifundamental",
+                "adjoint",
+                "adjoint",
+            ),
+            12,
+        ),
+        (
+            (
+                "fundamental",
+                "antifundamental",
+                "fundamental",
+                "antifundamental",
+                "fundamental",
+                "antifundamental",
+            ),
+            6,
+        ),
+    ),
+)
+def test_on_the_fly_selector_census_matches_compact_adapter_formulas(
+    roles: tuple[str, ...],
+    expected_color_flows: int,
+) -> None:
+    projection = SimpleNamespace(
+        external_sources=tuple(
+            SimpleNamespace(source_states=(object(), object())) for _ in roles
+        )
+    )
+    labels = tuple(range(1, len(roles) + 1))
+    process = SimpleNamespace(
+        legs=tuple(SimpleNamespace(color_role=role) for role in roles),
+        fundamental_labels=tuple(
+            label
+            for label, role in zip(labels, roles, strict=True)
+            if role == "fundamental"
+        ),
+        antifundamental_labels=tuple(
+            label
+            for label, role in zip(labels, roles, strict=True)
+            if role == "antifundamental"
+        ),
+        adjoint_labels=tuple(
+            label
+            for label, role in zip(labels, roles, strict=True)
+            if role == "adjoint"
+        ),
+    )
+
+    census = service_module._on_the_fly_selector_census_v1(
+        projection,  # type: ignore[arg-type]
+        process,  # type: ignore[arg-type]
+    )
+    assert census["physical_helicity_count"] == 2 ** len(roles)
+    assert census["physical_color_flow_count"] == expected_color_flows
+
+
+def test_on_the_fly_writer_rejects_changed_or_noncanonical_runtime(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _prepare_writer_identity(monkeypatch)
+    source_path = _prepared_model_path()
+    compiled = load_compiled_model(source_path)
+    changed = _process_artifact(tmp_path, runtime_name="changed.pacbin")
+    changed.runtime_path.write_bytes(changed.runtime_path.read_bytes() + b"tamper")
+
+    with pytest.raises(ValueError, match="payload changed"):
+        write_schema_v3_artifact(
+            tmp_path / "changed-artifact",
+            mode="error",
+            source=ModelSource.from_path(source_path),
+            compiled_model=compiled,
+            configuration=_configuration(),
+            processes=(changed,),
+            timings={},
+            api_bundle_hook=None,
+        )
+
+    extra_path = tmp_path / "extra.pacbin"
+    extra_index = write_pacbin_atomic(
+        extra_path,
+        (
+            PacbinMemberSource(
+                _SEED_MEMBER,
+                PacbinMemberKind.ON_THE_FLY_PROCESS_SEED,
+                source=io.BytesIO(b"seed"),
+            ),
+            PacbinMemberSource(
+                "on-the-fly/extra.bin",
+                PacbinMemberKind.ON_THE_FLY_PROCESS_SEED,
+                source=io.BytesIO(b"extra"),
+            ),
+        ),
+    )
+    noncanonical = replace(
+        changed,
+        runtime_path=extra_path,
+        runtime_size_bytes=extra_index.file_size,
+        runtime_sha256=hashlib.sha256(extra_path.read_bytes()).hexdigest(),
+        runtime_member_count=len(extra_index.members),
+        runtime_unpacked_size_bytes=sum(
+            member.length for member in extra_index.members
+        ),
+        runtime_index_sha256=extra_index.index_sha256,
+    )
+    with pytest.raises(ValueError, match="exactly one canonical process seed"):
+        write_schema_v3_artifact(
+            tmp_path / "extra-artifact",
+            mode="error",
+            source=ModelSource.from_path(source_path),
+            compiled_model=compiled,
+            configuration=_configuration(),
+            processes=(noncanonical,),
+            timings={},
+            api_bundle_hook=None,
+        )
+
+    missing_color = _process_artifact(tmp_path, runtime_name="missing-color.pacbin")
+    missing_color = replace(
+        missing_color,
+        color_accuracy="nlc",
+        physics={**missing_color.physics, "color_accuracy": "nlc"},
+        selector_policy={
+            **missing_color.selector_policy,
+            "color_coverage": "contracted",
+        },
+    )
+    with pytest.raises(ValueError, match="no color payload"):
+        write_schema_v3_artifact(
+            tmp_path / "nlc-artifact",
+            mode="error",
+            source=ModelSource.from_path(source_path),
+            compiled_model=compiled,
+            configuration=_configuration(),
+            processes=(missing_color,),
+            timings={},
+            api_bundle_hook=None,
+        )
+
+    valid = _process_artifact(tmp_path, runtime_name="valid-census.pacbin")
+    for index, selector_policy in enumerate(
+        (
+            {
+                "color_coverage": "complete",
+                "reference_color_word": None,
+                "trace_reflections_folded": False,
+            },
+            {
+                **valid.selector_policy,
+                "selector_census": {
+                    "physical_helicity_count": 0,
+                    "physical_color_flow_count": 1,
+                },
+            },
+        )
+    ):
+        with pytest.raises(ValueError, match=r"selector census|selector policy"):
+            write_schema_v3_artifact(
+                tmp_path / f"invalid-census-{index}",
+                mode="error",
+                source=ModelSource.from_path(source_path),
+                compiled_model=compiled,
+                configuration=_configuration(),
+                processes=(replace(valid, selector_policy=selector_policy),),
+                timings={},
+                api_bundle_hook=None,
+            )
+
+
+@pytest.mark.parametrize(
+    "selection",
+    (
+        service_module._ProcessSelection(max_color_sectors=1),
+        service_module._ProcessSelection(selected_color_sector_ids=frozenset({0})),
+        service_module._ProcessSelection(selected_source_helicities={1: -1}),
+    ),
+)
+def test_on_the_fly_construction_rejects_generation_time_selector_trimming(
+    tmp_path: Path,
+    selection: service_module._ProcessSelection,
+) -> None:
+    backend = service_module.GenerationBackend(
+        _configuration().effective,
+        None,
+        process_selection=selection,
+    )
+    process = build_process_ir("d d~ > z")
+    expanded = service_module._ExpandedProcess(
+        ProcessRequest.parse(process.process, name=_PROCESS_ID),
+        process,
+    )
+
+    with pytest.raises(
+        GenerationError,
+        match="retain complete runtime selector coverage",
+    ):
+        backend._project_on_the_fly_process(
+            expanded,
+            BuiltinSMModel(),
+            None,  # type: ignore[arg-type]
+            index=0,
+        )
+
+
+def test_on_the_fly_construction_never_enters_materialized_process_lanes(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    backend = service_module.GenerationBackend(_configuration().effective, None)
+    source_path = _prepared_model_path()
+    resolved = backend._resolve_model(ModelSource.from_path(source_path))
+    model = resolved.model
+    assert model is not None
+    model_inputs = backend._recurrence_model_inputs(resolved)
+    process = build_process_ir("d d~ > z")
+    expanded = service_module._ExpandedProcess(
+        ProcessRequest.parse(process.process, name=_PROCESS_ID),
+        process,
+    )
+
+    def forbidden(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("on-the-fly construction materialized a process lane")
+
+    for name in (
+        "build_color_plan",
+        "compile_generic_dag",
+        "_invoke_rust_recurrence_lowering_v2",
+        "run_generic_dag_numerical_current_warmup",
+        "run_recurrence_numerical_current_warmup",
+    ):
+        monkeypatch.setattr(service_module, name, forbidden)
+    monkeypatch.setattr(backend, "_prepare_process_construction", forbidden)
+    projected = backend._project_on_the_fly_process(
+        expanded,
+        model,
+        model_inputs,
+        index=0,
+    )
+    seed_identity = _seed_identity_from_source_projection(
+        projected.projection.seed.to_json_dict()
+    )
+    wrong_seed_identity = _seed_identity_from_source_projection(
+        projected.projection.seed.to_json_dict(),
+        process_digest="f" * 64,
+    )
+    assert wrong_seed_identity["process_digest"] != (
+        projected.projection.seed.process_digest
+    )
+    monkeypatch.setattr(
+        service_module,
+        "_invoke_rust_on_the_fly_seed_inspector_v1",
+        lambda _payload: wrong_seed_identity,
+    )
+    with pytest.raises(GenerationError, match="process digest disagrees"):
+        backend._construct_on_the_fly_artifact(
+            projected,
+            b"native-compact-seed",
+            model,
+            model_inputs,
+            tmp_path,
+            phase=PhaseHandle("test", None, 1),
+        )
+    assert not (tmp_path / "on-the-fly-runtimes").exists()
+
+    monkeypatch.setattr(
+        service_module,
+        "_invoke_rust_on_the_fly_seed_inspector_v1",
+        lambda _payload: seed_identity,
+    )
+    generated = backend._construct_on_the_fly_artifact(
+        projected,
+        b"native-compact-seed",
+        model,
+        model_inputs,
+        tmp_path,
+        phase=PhaseHandle("test", None, 1),
+    )
+
+    assert generated.artifact.process_id == _PROCESS_ID
+    assert generated.artifact.runtime_path.parent == (
+        tmp_path / "on-the-fly-runtimes" / _PROCESS_ID
+    )
+    source_projection = projected.projection.seed.to_json_dict()
+    assert not {"dag", "color_plan", "recurrence", "direct_plan"}.intersection(
+        source_projection
+    )
+    with PacbinReader.open(generated.artifact.runtime_path) as reader:
+        member = reader.members[0]
+        assert (member.logical_path, member.kind) == (
+            _SEED_MEMBER,
+            PacbinMemberKind.ON_THE_FLY_PROCESS_SEED,
+        )
+        assert reader.read_member(_SEED_MEMBER, length=member.length) == (
+            b"native-compact-seed"
+        )
+    assert set(generated.artifact.runtime_metadata) == {
+        "runtime_parameters",
+        "prepared_parameter_defaults",
+        "parameter_projection",
+        "external_legs",
+        "particle_masses",
+        "normalization",
+        "process_seed_identity",
+    }
+
+
+def test_multi_process_on_the_fly_writer_uses_one_ordered_native_batch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _prepare_writer_identity(monkeypatch)
+    calls: list[dict[str, object]] = []
+
+    def batch_builder(
+        ordered_sources: object,
+        recurrence_json: object,
+        direct_json: object,
+        pack_digest: object,
+        *,
+        process_identities: object = (),
+    ) -> tuple[bytes, ...]:
+        sources = tuple(ordered_sources)  # type: ignore[arg-type]
+        identities = tuple(process_identities)  # type: ignore[arg-type]
+        calls.append(
+            {
+                "sources": sources,
+                "recurrence_json": recurrence_json,
+                "direct_json": direct_json,
+                "pack_digest": pack_digest,
+                "identities": identities,
+            }
+        )
+        return tuple(
+            f"native-compact-seed-{index}".encode() for index in range(len(sources))
+        )
+
+    monkeypatch.setattr(
+        service_module,
+        "_invoke_rust_on_the_fly_seed_batch_builder_v1",
+        batch_builder,
+    )
+
+    def inspect_seed(payload: bytes) -> dict[str, object]:
+        index = int(payload.rsplit(b"-", maxsplit=1)[1])
+        assert calls
+        ordered_sources = calls[0]["sources"]
+        assert isinstance(ordered_sources, tuple)
+        source_projection = json.loads(ordered_sources[index])
+        assert isinstance(source_projection, dict)
+        return _seed_identity_from_source_projection(source_projection)
+
+    monkeypatch.setattr(
+        service_module,
+        "_invoke_rust_on_the_fly_seed_inspector_v1",
+        inspect_seed,
+    )
+
+    def forbidden(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("on-the-fly generation materialized a process lane")
+
+    for name in (
+        "build_color_plan",
+        "compile_generic_dag",
+        "_invoke_rust_recurrence_lowering_v2",
+        "run_generic_dag_numerical_current_warmup",
+        "run_recurrence_numerical_current_warmup",
+    ):
+        monkeypatch.setattr(service_module, name, forbidden)
+    monkeypatch.setattr(
+        service_module.GenerationBackend,
+        "_prepare_process_construction",
+        forbidden,
+    )
+
+    process_ids = ("d_dbar_to_z", "u_ubar_to_z")
+    processes = ProcessSet.from_expressions(
+        ("d d~ > z", "u u~ > z"),
+        names=process_ids,
+    )
+    artifact = tmp_path / "multi-process-artifact"
+    Generator(_configuration().effective).generate(
+        processes,
+        artifact,
+        model=ModelSource.from_path(_prepared_model_path()),
+    )
+
+    assert len(calls) == 1
+    call = calls[0]
+    assert call["identities"] == process_ids
+    sources = call["sources"]
+    assert isinstance(sources, tuple) and len(sources) == 2
+    decoded_sources = tuple(json.loads(source) for source in sources)
+    assert [source["schema_version"] for source in decoded_sources] == [1, 1]
+    assert decoded_sources[0]["process_digest"] != decoded_sources[1]["process_digest"]
+    for source in decoded_sources:
+        assert not {"dag", "color_plan", "recurrence", "direct_plan"}.intersection(
+            source
+        )
+
+    for index, process_id in enumerate(process_ids):
+        runtime = artifact / "processes" / process_id / "on-the-fly-runtime.pacbin"
+        with PacbinReader.open(runtime, verify_payloads=True) as reader:
+            member = reader.members[0]
+            assert reader.read_member(_SEED_MEMBER, length=member.length) == (
+                f"native-compact-seed-{index}".encode()
+            )
+
+
+def test_public_generator_appends_on_the_fly_process(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _prepare_writer_identity(monkeypatch)
+
+    def batch_builder(
+        ordered_sources: object,
+        *_args: object,
+        **_kwargs: object,
+    ) -> tuple[bytes, ...]:
+        return tuple(
+            b"native-compact-seed:" + source
+            for source in tuple(ordered_sources)  # type: ignore[arg-type]
+        )
+
+    def inspect_seed(payload: bytes) -> dict[str, object]:
+        prefix = b"native-compact-seed:"
+        assert payload.startswith(prefix)
+        source_projection = json.loads(payload.removeprefix(prefix))
+        assert isinstance(source_projection, dict)
+        return _seed_identity_from_source_projection(source_projection)
+
+    monkeypatch.setattr(
+        service_module,
+        "_invoke_rust_on_the_fly_seed_batch_builder_v1",
+        batch_builder,
+    )
+    monkeypatch.setattr(
+        service_module,
+        "_invoke_rust_on_the_fly_seed_inspector_v1",
+        inspect_seed,
+    )
+
+    generator = Generator(_configuration().effective)
+    model = ModelSource.from_path(_prepared_model_path())
+    artifact = tmp_path / "public-append-artifact"
+    generator.generate("d d~ > z", artifact, model=model)
+    generator.generate("u u~ > z", artifact, model=model, mode="append")
+
+    manifest = load_manifest(artifact)
+    assert tuple(record["id"] for record in manifest.processes) == (
+        "d_dbar_to_z",
+        "u_ubar_to_z",
+    )
+    assert [
+        record.path
+        for record in manifest.payloads
+        if record.role == artifact_writer.STRUCTURAL_SOURCE_PROOF_ROLE
+    ] == []
+    assert [
+        process.execution_mode for process in inspect_artifact(artifact).processes
+    ] == ["on-the-fly", "on-the-fly"]
+
+
+def test_on_the_fly_runtime_metadata_reuses_recurrence_support_contract() -> None:
+    backend = service_module.GenerationBackend(_configuration().effective, None)
+    resolved = backend._resolve_model(ModelSource.from_path(_prepared_model_path()))
+    model = resolved.model
+    assert model is not None
+    inputs = backend._recurrence_model_inputs(resolved)
+    process = build_process_ir("d d~ > z")
+    projection = service_module.project_on_the_fly_process_seed_v1(
+        process,
+        inputs.catalog,
+        model,
+        coupling_order_policy="minimal",
+        coupling_order_limits={},
+    )
+
+    metadata = build_on_the_fly_runtime_metadata(
+        projection.seed.external_sources,
+        projection.seed.parameter_projection,
+        inputs.catalog,
+        model,
+        projection.runtime_normalization,
+    )
+
+    assert metadata["external_legs"] == [
+        {
+            "source_slot": leg.source_slot,
+            "public_label": leg.public_label,
+            "physical_pdg": leg.physical_pdg,
+            "outgoing_pdg": leg.outgoing_pdg,
+            "is_initial": leg.is_initial,
+        }
+        for leg in projection.seed.external_sources
+    ]
+    assert metadata["parameter_projection"] == [
+        {
+            "runtime_slot": row.runtime_slot,
+            "runtime_name": row.runtime_name,
+            "parameter_template_id": row.parameter_template_id,
+            "prepared_parameter_id": row.prepared_parameter_id,
+            "component": row.component,
+        }
+        for row in projection.seed.parameter_projection
+    ]
+    assert metadata["normalization"] == projection.runtime_normalization
+    assert "source_templates" not in metadata
+    assert "public_color_flows" not in metadata
+
+
+def test_on_the_fly_singleton_seed_bridge_wraps_plural_binding(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[object] = []
+
+    def binding(*args: object) -> list[bytes]:
+        calls.append(args)
+        return [b"stable-seed-bytes"]
+
+    module = SimpleNamespace(_build_on_the_fly_process_seeds_v1=binding)
+    monkeypatch.setattr(service_module.importlib, "import_module", lambda _name: module)
+    monkeypatch.setattr(service_module, "verify_native_module", lambda _module: None)
+
+    result = service_module._invoke_rust_on_the_fly_seed_builder_v1(
+        b"source",
+        b"recurrence",
+        b"direct",
+        "a" * 64,
+    )
+
+    assert result == b"stable-seed-bytes"
+    assert calls == [((b"source",), b"recurrence", b"direct", "a" * 64)]
+
+
+def test_on_the_fly_native_seed_inspector_returns_exact_identity(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    identity = _seed_identity()
+    module = SimpleNamespace(
+        _inspect_on_the_fly_process_seed_v1=lambda payload: (
+            json.dumps(identity) if payload == b"seed" else "{}"
+        )
+    )
+    monkeypatch.setattr(service_module.importlib, "import_module", lambda _name: module)
+    monkeypatch.setattr(service_module, "verify_native_module", lambda _module: None)
+
+    assert service_module._invoke_rust_on_the_fly_seed_inspector_v1(b"seed") == (
+        identity
+    )
+
+
+def test_on_the_fly_native_seed_identity_is_bound_to_source_projection() -> None:
+    projection_json: dict[str, object] = {
+        "process_digest": "a" * 64,
+        "external_permutation": [0, 1],
+        "external_sources": [
+            {
+                "source_slot": 0,
+                "public_label": 1,
+                "is_initial": True,
+                "states": [{"state_index": 0, "public_helicity": -1}],
+            },
+            {
+                "source_slot": 1,
+                "public_label": 2,
+                "is_initial": False,
+                "states": [{"state_index": 0, "public_helicity": 1}],
+            },
+        ],
+    }
+    projection = SimpleNamespace(
+        process_digest="a" * 64,
+        external_permutation=(0, 1),
+        external_sources=(
+            SimpleNamespace(
+                source_slot=0,
+                public_label=1,
+                is_initial=True,
+                source_states=(SimpleNamespace(state_index=0, public_helicity=-1),),
+            ),
+            SimpleNamespace(
+                source_slot=1,
+                public_label=2,
+                is_initial=False,
+                source_states=(SimpleNamespace(state_index=0, public_helicity=1),),
+            ),
+        ),
+    )
+    identity = _seed_identity_from_source_projection(projection_json)
+    service_module._bind_on_the_fly_process_seed_identity_v1(
+        identity,
+        projection,  # type: ignore[arg-type]
+    )
+
+    wrong_digest = {**identity, "process_digest": "f" * 64}
+    wrong_permutation = {**identity, "external_permutation": [1, 0]}
+    candidates: list[tuple[dict[str, object], str]] = [
+        (wrong_digest, "process digest disagrees"),
+        (wrong_permutation, "external permutation disagrees"),
+    ]
+    for field, replacement in (
+        ("source_slot", 7),
+        ("public_label", 7),
+        ("is_initial", False),
+    ):
+        candidate = copy.deepcopy(identity)
+        sources = candidate["external_sources"]
+        assert isinstance(sources, list) and isinstance(sources[0], dict)
+        sources[0][field] = replacement
+        candidates.append((candidate, "external source domain disagrees"))
+    for field, replacement in (
+        ("state_index", 7),
+        ("public_helicity", 7),
+    ):
+        candidate = copy.deepcopy(identity)
+        sources = candidate["external_sources"]
+        assert isinstance(sources, list) and isinstance(sources[0], dict)
+        states = sources[0]["states"]
+        assert isinstance(states, list) and isinstance(states[0], dict)
+        states[0][field] = replacement
+        candidates.append((candidate, "external source domain disagrees"))
+
+    for candidate, message in candidates:
+        with pytest.raises(GenerationError, match=message):
+            service_module._bind_on_the_fly_process_seed_identity_v1(
+                candidate,
+                projection,  # type: ignore[arg-type]
+            )
+
+
+@pytest.mark.parametrize(
+    ("binding", "message"),
+    (
+        (None, "does not provide the private"),
+        (lambda _payload: b"not-json-text", "inspection failed"),
+        (lambda _payload: "not-json", "inspection failed"),
+        (
+            lambda _payload: json.dumps(
+                {**_seed_identity(), "abi": "stale-seed-identity-v0"}
+            ),
+            "unsupported ABI",
+        ),
+        (
+            lambda _payload: json.dumps({**_seed_identity(), "invented": True}),
+            "wrong fields",
+        ),
+    ),
+)
+def test_on_the_fly_native_seed_inspector_fails_closed(
+    monkeypatch: pytest.MonkeyPatch,
+    binding: object,
+    message: str,
+) -> None:
+    module = SimpleNamespace()
+    if binding is not None:
+        module._inspect_on_the_fly_process_seed_v1 = binding
+    monkeypatch.setattr(service_module.importlib, "import_module", lambda _name: module)
+    monkeypatch.setattr(service_module, "verify_native_module", lambda _module: None)
+
+    with pytest.raises(GenerationError, match=message):
+        service_module._invoke_rust_on_the_fly_seed_inspector_v1(b"seed")
+
+
+@pytest.mark.parametrize(
+    ("binding", "message"),
+    (
+        (None, "does not provide the private"),
+        (lambda *_args: [], "wrong process count"),
+        (lambda *_args: [b""], "empty payload for process index 0"),
+        (lambda *_args: ["not-bytes"], "empty payload for process index 0"),
+        (
+            lambda *_args: (_ for _ in ()).throw(RuntimeError("native failure")),
+            "process-seed construction failed: native failure",
+        ),
+    ),
+)
+def test_on_the_fly_native_seed_bridge_fails_closed(
+    monkeypatch: pytest.MonkeyPatch,
+    binding: object,
+    message: str,
+) -> None:
+    module = SimpleNamespace()
+    if binding is not None:
+        module._build_on_the_fly_process_seeds_v1 = binding
+    monkeypatch.setattr(service_module.importlib, "import_module", lambda _name: module)
+    monkeypatch.setattr(service_module, "verify_native_module", lambda _module: None)
+
+    with pytest.raises(GenerationError, match=message):
+        service_module._invoke_rust_on_the_fly_seed_builder_v1(
+            b"{}",
+            b"{}",
+            b"{}",
+            "a" * 64,
+        )
+
+
+def test_on_the_fly_native_seed_bridge_preserves_indexed_process_identity(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def binding(*_args: object) -> object:
+        raise RuntimeError(
+            "on-the-fly process seed at index 1 "
+            '(process digest "abc") failed: stale source'
+        )
+
+    module = SimpleNamespace(_build_on_the_fly_process_seeds_v1=binding)
+    monkeypatch.setattr(service_module.importlib, "import_module", lambda _name: module)
+    monkeypatch.setattr(service_module, "verify_native_module", lambda _module: None)
+
+    with pytest.raises(
+        GenerationError,
+        match=r"process index 1 'u_ubar_to_z'.*process digest.*stale source",
+    ):
+        service_module._invoke_rust_on_the_fly_seed_batch_builder_v1(
+            (b"{}", b"{}"),
+            b"{}",
+            b"{}",
+            "a" * 64,
+            process_identities=("d_dbar_to_z", "u_ubar_to_z"),
+        )
diff --git a/pyamplicol/tests/unit/test_on_the_fly_contracted_color.py b/pyamplicol/tests/unit/test_on_the_fly_contracted_color.py
new file mode 100644
index 0000000000..7b4e5b3b01
--- /dev/null
+++ b/pyamplicol/tests/unit/test_on_the_fly_contracted_color.py
@@ -0,0 +1,94 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+
+import pytest
+
+from pyamplicol.color import build_color_plan
+from pyamplicol.generation import service as service_module
+from pyamplicol.generation.recurrence_physics import (
+    build_on_the_fly_color_contraction,
+)
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.runtime.recurrence_exact._color import (
+    _decode_recurrence_color_contraction,
+)
+
+
+@pytest.mark.parametrize("color_accuracy", ("nlc", "full"))
+def test_contracted_open_lines_publish_one_group_per_structural_owner(
+    color_accuracy: str,
+) -> None:
+    process = build_process_ir(
+        "u u~ > u u~",
+        color_accuracy=color_accuracy,
+    )
+    color_plan = build_color_plan(
+        process,
+        color_accuracy=color_accuracy,
+        fold_trace_reflections=False,
+    )
+
+    contraction, owner_by_sector, owner_sector_ids = (
+        build_on_the_fly_color_contraction(color_plan)
+    )
+    encoded = service_module._build_on_the_fly_contracted_color_payload_v1(
+        color_plan
+    )
+    decoded = _decode_recurrence_color_contraction(encoded.payload)
+
+    assert color_plan.sector_count == 4
+    assert color_plan.trace_reflections_folded is False
+    assert owner_by_sector == (0, 0, 2, 2)
+    assert owner_sector_ids == (0, 2)
+    assert contraction.repeated_block is None
+    assert contraction.includes_color_factor is True
+    assert decoded.storage == "expanded"
+    assert decoded.component_count == 1
+    assert decoded.group_count == decoded.destination_count == 2
+    assert decoded.group_sector_ids == owner_sector_ids
+    assert decoded.group_component_ids == (0, 0)
+    assert decoded.owner_by_sector == owner_by_sector
+    assert decoded.destination_by_group == encoded.destination_by_group == (0, 1)
+    assert encoded.summary == {
+        "abi": "pyamplicol-recurrence-color-contraction-v3",
+        "color_accuracy": color_accuracy,
+        "storage": "expanded",
+        "includes_color_factor": True,
+        "group_count": 2,
+        "sector_count": 4,
+        "active_sector_count": 2,
+        "component_count": 1,
+        "destination_count": 2,
+        "entry_count": len(contraction.entries),
+        "logical_entry_count": len(contraction.entries),
+        "semantic_digest": hashlib.sha256(encoded.payload).hexdigest(),
+        "factorization": None,
+    }
+
+
+@pytest.mark.parametrize("color_accuracy", ("nlc", "full"))
+def test_contracted_trace_plan_retains_every_orientation(
+    color_accuracy: str,
+) -> None:
+    process = build_process_ir(
+        "g g > g g",
+        color_accuracy=color_accuracy,
+    )
+    color_plan = build_color_plan(
+        process,
+        color_accuracy=color_accuracy,
+        fold_trace_reflections=False,
+    )
+    encoded = service_module._build_on_the_fly_contracted_color_payload_v1(
+        color_plan
+    )
+    decoded = _decode_recurrence_color_contraction(encoded.payload)
+
+    assert color_plan.sector_count == 6
+    assert decoded.group_count == 6
+    assert decoded.group_sector_ids == tuple(range(6))
+    assert decoded.owner_by_sector == tuple(range(6))
+    assert decoded.destination_by_group == tuple(range(6))
+    assert encoded.summary["active_sector_count"] == 6
diff --git a/pyamplicol/tests/unit/test_on_the_fly_high_multiplicity.py b/pyamplicol/tests/unit/test_on_the_fly_high_multiplicity.py
new file mode 100644
index 0000000000..3c1b4c37eb
--- /dev/null
+++ b/pyamplicol/tests/unit/test_on_the_fly_high_multiplicity.py
@@ -0,0 +1,2133 @@
+# SPDX-License-Identifier: 0BSD
+"""Focused contracts for the bounded OTF high-multiplicity driver."""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import os
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+import pytest
+
+from tools.developer import on_the_fly_high_multiplicity as study
+from tools.performance_report.runner import SelectorContract
+from tools.performance_report.selector_policy import fixed_selector_helicity
+
+
+def _args(
+    tmp_path: Path,
+    n: int,
+    workload: str,
+    *,
+    process_id: int = 7,
+) -> argparse.Namespace:
+    has_amplicol = workload == "selected" and process_id != 14 and n <= 7
+    return argparse.Namespace(
+        output=tmp_path / "out",
+        process_id=process_id,
+        multiplicity=n,
+        workload=workload,
+        prepared_model=None,
+        candidate_artifact=None,
+        selected_report=None,
+        reference_repo_root=tmp_path if has_amplicol else None,
+        reference_profile="reference" if has_amplicol else None,
+        target_runtime=0.1,
+        worker=False,
+    )
+
+
+def test_exact_cases_helicities_and_cli_routes(tmp_path: Path) -> None:
+    assert study.SUPPORTED_MULTIPLICITIES == (5, 6, 7, 8, 9)
+    assert study.SUPPORTED_PROCESS_MULTIPLICITIES == {
+        7: (5, 6, 7, 8, 9),
+        8: (5, 6, 7, 8, 9),
+        11: (5, 6, 7),
+        13: (5, 6, 7),
+        14: (6, 7),
+        15: (5, 6, 7),
+    }
+    bases = {
+        7: (1, -1, 6, -6),
+        8: (21, 21, 21, 21),
+        11: (1, -1, 6, -6, 23, 25),
+        13: (1, -1, 2, -2, 3, -3),
+        14: (1, -1, 2, -2, 3, -3, 4, -4),
+        15: (1, -1, 2, -2, 2, -2),
+    }
+    for process_id, multiplicities in study.SUPPORTED_PROCESS_MULTIPLICITIES.items():
+        for n in multiplicities:
+            case = study._case(process_id, n)
+            base = bases[process_id]
+            assert case.pdgs == (
+                *base,
+                *(21 for _ in range(n - (len(base) - 2))),
+            )
+            assert case.process_id == f"otf_p{process_id}_{case.process_key}_n{n}"
+            assert fixed_selector_helicity(case.pdgs) == tuple(
+                0 if abs(pdg) == 25 else (-1 if index % 2 else 1)
+                for index, pdg in enumerate(case.pdgs, start=1)
+            )
+    assert study._case(7, 5).process == "d d~ > t t~ g g g"
+    assert study._case(8, 5).process == "g g > g g g g g"
+    assert study._case(11, 5).process == "d d~ > t t~ z h g"
+    assert study._case(13, 5).process == "d d~ > u u~ s s~ g"
+    assert study._case(14, 6).process == "d d~ > u u~ s s~ c c~"
+    assert study._case(15, 5).process == "d d~ > u u~ u u~ g"
+    for process_id, n in ((11, 8), (13, 8), (14, 5), (14, 8), (15, 8)):
+        with pytest.raises(study.StudyError, match="planned high-multiplicity"):
+            study._case(process_id, n)
+    assert study._authority_kind(study._case(7, 5), "selected") == "amplicol"
+    assert study._authority_kind(study._case(14, 6), "selected") == "recurrence"
+    assert study._authority_kind(study._case(8, 9), "selected") == "otf-only"
+    assert study._authority_kind(study._case(7, 5), "all-flow") == "otf-only"
+    assert (
+        study._parser()
+        .parse_args(
+            [
+                "--output",
+                "x",
+                "--process-id",
+                "7",
+                "--multiplicity",
+                "5",
+                "--workload",
+                "selected",
+            ]
+        )
+        .target_runtime
+        == 5.0
+    )
+    candidate = tmp_path / "candidate"
+    candidate.mkdir()
+    prepared = tmp_path / "model"
+    prepared.touch()
+    invalid = (
+        _args(tmp_path, 5, "selected"),
+        _args(tmp_path, 8, "all-flow"),
+        argparse.Namespace(
+            **{**vars(_args(tmp_path, 5, "all-flow")), "candidate_artifact": candidate}
+        ),
+        argparse.Namespace(
+            **{
+                **vars(_args(tmp_path, 8, "all-flow")),
+                "candidate_artifact": candidate,
+                "prepared_model": prepared,
+            }
+        ),
+        argparse.Namespace(
+            **{
+                **vars(_args(tmp_path, 8, "selected")),
+                "prepared_model": prepared,
+                "reference_repo_root": tmp_path,
+                "reference_profile": "reference",
+            }
+        ),
+    )
+    for args in invalid:
+        with pytest.raises(study.StudyError):
+            study._validate_arguments(args)
+    with pytest.raises(SystemExit):
+        study._parser().parse_args(
+            ["--output", "x", "--multiplicity", "5", "--recurrence-artifact", "x"]
+        )
+
+    selected = _args(tmp_path, 5, "selected")
+    selected.prepared_model = prepared
+    study._validate_arguments(selected)
+    recurrence = _args(tmp_path, 6, "selected", process_id=14)
+    recurrence.prepared_model = prepared
+    study._validate_arguments(recurrence)
+    otf_only = _args(tmp_path, 8, "selected")
+    otf_only.prepared_model = prepared
+    study._validate_arguments(otf_only)
+    all_flow = _args(tmp_path, 5, "all-flow")
+    all_flow.candidate_artifact = candidate
+    all_flow.selected_report = prepared
+    study._validate_arguments(all_flow)
+
+
+def test_timing_batch_repeats_only_seed101_point() -> None:
+    assert study.SEEDS == (101, 211, 307, 401, 503, 607, 709, 811)
+    points = tuple(((float(index), 0.0, 0.0, 1.0),) for index in range(8))
+    timing = study._timing_points(points)
+    assert len(timing) == 128
+    assert all(point == points[0] for point in timing)
+    assert points[1] not in timing
+
+
+def test_otf_and_recurrence_use_explicit_distinct_thread_budgets() -> None:
+    otf = study._config("on-the-fly", "topology-replay")
+    recurrence = study._config("recurrence", "topology-replay")
+
+    assert otf.evaluator.optimization.cores == study.OTF_QUERY_CONSTRUCTION_THREADS == 4
+    assert (
+        recurrence.evaluator.optimization.cores
+        == study.RECURRENCE_GENERATION_THREADS
+        == 1
+    )
+
+
+def test_high_cost_lifecycle_policy_has_an_exhaustive_same_family_baseline() -> None:
+    expected = {
+        (7, 5): study.LIFECYCLE_EXHAUSTIVE,
+        (7, 6): study.LIFECYCLE_EXHAUSTIVE,
+        (7, 7): study.LIFECYCLE_LEAN,
+        (8, 5): study.LIFECYCLE_EXHAUSTIVE,
+        (8, 6): study.LIFECYCLE_LEAN,
+        (14, 6): study.LIFECYCLE_EXHAUSTIVE,
+        (14, 7): study.LIFECYCLE_LEAN,
+    }
+    for (process_id, multiplicity), mode in expected.items():
+        case = study._case(process_id, multiplicity)
+        policy = study._lifecycle_policy(case, "selected")
+        assert policy["mode"] == mode
+        assert policy["retain_requested_family_after_cold_warmup"] is (
+            mode == study.LIFECYCLE_LEAN
+        )
+        baseline = policy["expected_prior_campaign_prerequisite"]
+        if mode == study.LIFECYCLE_LEAN:
+            assert baseline["evidence_status"] == (
+                "expected-not-authenticated-by-this-report"
+            )
+            assert baseline["process_table_id"] == process_id
+            assert baseline["multiplicity"] < multiplicity
+            assert baseline["workload"] == "selected"
+            assert baseline["policy"] == study.LIFECYCLE_EXHAUSTIVE
+            all_flow_baseline = study._lifecycle_policy(case, "all-flow")[
+                "expected_prior_campaign_prerequisite"
+            ]
+            assert all_flow_baseline["workload"] == "all-flow"
+        else:
+            assert baseline is None
+
+
+def test_selector_derivation_and_compact_path_never_open_physics(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    case = study._case(14, 6)
+    states = fixed_selector_helicity(case.pdgs)
+    word = study._colored_source_labels(case)
+    contract = SelectorContract(
+        ("flow:" + ",".join(map(str, word)),),
+        (word,),
+        ("h:" + ",".join(f"{state:+d}" for state in states),),
+        tuple(enumerate(states, start=1)),
+        "a" * 64,
+    )
+    validate = mock.Mock()
+    derive = mock.Mock(return_value=contract)
+    monkeypatch.setattr(study, "validate_selector_contract", validate)
+    monkeypatch.setattr(study, "derive_selector_contract", derive)
+    recurrence = SimpleNamespace(execution_mode="recurrence")
+    selector, returned, payload = study._recurrence_authority_contract(
+        case, recurrence, ()
+    )
+    assert selector.flow_word == word and selector.helicities == states
+    assert returned is contract and payload == contract.as_dict()
+    derive.assert_called_once_with(recurrence, ())
+    validate.assert_called_once_with(recurrence, contract, ())
+
+    case = study._case(8, 8)
+    flow_id = "flow:1,2,3,4,5,6,7,8,9,10"
+    points = (((1.0, 0.0, 0.0, 1.0),),)
+
+    class Backend:
+        @property
+        def physics(self) -> object:
+            raise AssertionError("dense physics opened")
+
+        def _on_the_fly_benchmark_context(self, requested: object) -> dict[str, object]:
+            assert requested == ("1",)
+            return {
+                "process_id": case.process_id,
+                "process_expression": case.process,
+                "color_accuracy": "lc",
+                "helicity_count": 1,
+                "color_count": 1,
+                "selected_color_ids": [flow_id],
+            }
+
+    selector, compact_contract, context = study._selector_from_compact_ordinal_one(
+        SimpleNamespace(_backend=Backend()), case, points
+    )
+    assert selector.flow_word == tuple(range(1, 11))
+    assert compact_contract.selected_color_flow_ids == (flow_id,)
+    assert context["requested_color_ids"] == ["1"]
+    assert context["selector_source"] == "compact-seed-one-based-color-ordinal-1"
+
+
+@pytest.mark.parametrize(
+    ("process_id", "word"),
+    (
+        (7, (2, 5, 6, 7, 4, 3, 1)),
+        (8, (1, 2, 3, 4, 5, 6, 7)),
+        (11, (2, 7, 4, 3, 1)),
+        (13, (2, 7, 1, 3, 4, 5, 6)),
+        (15, (2, 7, 1, 3, 4, 5, 6)),
+    ),
+)
+def test_amplicol_current_is_portably_loaded_and_only_digest_rebound(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    process_id: int,
+    word: tuple[int, ...],
+) -> None:
+    case = study._case(process_id, 5)
+    states = fixed_selector_helicity(case.pdgs)
+    points = tuple(((float(index), 0.0, 0.0, 1.0),) for index in range(8))
+    singleton_digest = study.point_digest((points[0],))
+    active = study.ReportSourceIdentity("b" * 40, "d" * 40, ())
+    stored = SelectorContract(
+        ("flow:" + ",".join(map(str, word)),),
+        (word,),
+        ("h:" + ",".join(f"{state:+d}" for state in states),),
+        tuple(enumerate(states, start=1)),
+        singleton_digest,
+    )
+    docs = tmp_path / "docs" / "performance_reports" / "profile"
+    paths = SimpleNamespace(
+        repo_root=tmp_path,
+        docs_dir=docs,
+        artifact_root=docs / "campaign_artifacts",
+        coordination_root=docs / "campaign_artifacts" / "coordination",
+    )
+    for path in (paths.docs_dir, paths.artifact_root, paths.coordination_root):
+        path.mkdir(parents=True, exist_ok=True)
+    attempt = tmp_path / "attempt"
+    legacy_artifact = attempt / "artifact"
+    library = legacy_artifact / "selected-flow-generated-library"
+    (library / "Library").mkdir(parents=True)
+    (library / "processes.txt").touch()
+    (library / "libamp1.so").touch()
+    executable = library / "amplicol_library_benchmark"
+    executable.touch()
+    executable.chmod(0o755)
+    expected_cell = study._reference_cell(case, "selected")
+    result = {
+        "status": "ok",
+        "selector_contract": stored.as_dict(),
+        "matrix_element": 7.5,
+        "generation_seconds": 3.0,
+        "wall_seconds_per_point": 2.0e-6,
+        "execution_seconds_per_point": 1.5e-6,
+        "relative_standard_error": 0.0 if process_id == 8 else 0.01,
+        "sample_count": 5,
+        "artifact": {
+            "path": str(legacy_artifact),
+            "process_row": "group:1:integral:1",
+        },
+        "provenance": {
+            "revision": study.PINNED_REFERENCE_REVISION,
+            "report_source_revision": "b" * 40,
+            "report_measured_source_revision": "b" * 40,
+            "report_source_tree": "d" * 40,
+            "report_measured_source_tree": "d" * 40,
+            "report_source_clean": True,
+            "generation_timing_is_workload_specific": True,
+            "manual_campaign": {
+                "batch_size": 128,
+                "warmup_runs": 2,
+                "minimum_samples": 5,
+                "target_runtime_seconds": 0.1,
+                "cell_identity": {
+                    "accuracy": "lc",
+                    "backend": "fortran",
+                    "cell_id": expected_cell.cell_id,
+                    "dataset_id": "reference_amplicol_lc",
+                    "execution_mode": "amplicol",
+                    "model": None,
+                    "n_final": case.multiplicity,
+                    "process": case.process,
+                    "process_key": case.process_key,
+                    "variant": None,
+                    "workload": "selected-flow",
+                },
+            },
+        },
+    }
+    current = SimpleNamespace(
+        cell_id=expected_cell.cell_id,
+        result=result,
+        attempt_id="attempt",
+        manifest_sha256="c" * 64,
+        result_path=attempt / "result.json",
+    )
+    seen: dict[str, object] = {}
+
+    def artifact_store(**kwargs: object) -> object:
+        seen.update(kwargs)
+        return SimpleNamespace(load_current=lambda cell_id: current)
+
+    def report_paths(repo_root: Path, **kwargs: object) -> object:
+        assert repo_root == tmp_path.resolve()
+        assert kwargs == {
+            "docs_dir": docs,
+            "artifact_root": docs / "campaign_artifacts",
+            "coordination_root": docs / "campaign_artifacts" / "coordination",
+        }
+        return paths
+
+    validate = mock.Mock()
+    monkeypatch.setattr(study.ReportPaths, "from_repo", report_paths)
+    monkeypatch.setattr(study, "ArtifactStore", artifact_store)
+    monkeypatch.setattr(study, "validate_measurement", validate)
+    reference = study._load_amplicol_reference(
+        tmp_path, "profile", case, "selected", points, 0.1, active
+    )
+
+    assert seen["current_publication_paths"] is paths
+    validate.assert_called_once_with(result, expected_cell=expected_cell)
+    assert reference.selector.flow_word == word
+    assert reference.matrix_element == 7.5
+    assert reference.library_path == library.resolve()
+    assert reference.process_row == (1, 1)
+    assert reference.lineage["stored_selector_point_digest"] == singleton_digest
+    assert reference.timing["relative_standard_error"] == (
+        0.0 if process_id == 8 else 0.01
+    )
+    assert reference.selector_contract == {
+        **stored.as_dict(),
+        "point_digest": study.point_digest(points),
+    }
+    if process_id == 7:
+        outside = tmp_path / "outside-current-attempt"
+        outside.mkdir()
+        result["artifact"]["path"] = str(outside)
+        with pytest.raises(study.StudyError, match="outside its current attempt"):
+            study._load_amplicol_reference(
+                tmp_path, "profile", case, "selected", points, 0.1, active
+            )
+
+
+def test_process7_rejects_process8_amplicol_current(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    case7 = study._case(7, 5)
+    case8 = study._case(8, 5)
+    cell8 = study._reference_cell(case8, "selected")
+    paths = SimpleNamespace(
+        repo_root=tmp_path,
+        docs_dir=tmp_path / "docs",
+        artifact_root=tmp_path / "artifacts",
+        coordination_root=tmp_path / "coordination",
+    )
+    for path in (paths.docs_dir, paths.artifact_root, paths.coordination_root):
+        path.mkdir()
+    wrong = SimpleNamespace(cell_id=cell8.cell_id, result={"status": "ok"})
+    monkeypatch.setattr(study.ReportPaths, "from_repo", lambda *_args, **_kwargs: paths)
+    monkeypatch.setattr(
+        study,
+        "ArtifactStore",
+        lambda **_kwargs: SimpleNamespace(load_current=lambda _cell_id: wrong),
+    )
+    monkeypatch.setattr(study, "validate_measurement", lambda *_args, **_kwargs: None)
+    with pytest.raises(study.StudyError, match="workload identity"):
+        study._load_amplicol_reference(
+            tmp_path,
+            "profile",
+            case7,
+            "selected",
+            (((1.0, 0.0, 0.0, 1.0),),),
+            0.1,
+            study.ReportSourceIdentity("a" * 40, "b" * 40, ()),
+        )
+
+
+def test_amplicol_matrix_element_is_an_explicit_singleton_authority() -> None:
+    case = study._case(7, 5)
+    states = fixed_selector_helicity(case.pdgs)
+    word = tuple(range(1, len(case.pdgs) + 1))
+    selector = study.Selector(
+        word,
+        "flow:" + ",".join(map(str, word)),
+        states,
+        "h:" + ",".join(f"{state:+d}" for state in states),
+    )
+    points = tuple(((float(index), 0.0, 0.0, 1.0),) for index in range(8))
+    contract = SelectorContract(
+        (selector.flow_id,),
+        (selector.flow_word,),
+        (selector.helicity_id,),
+        tuple(enumerate(selector.helicities, start=1)),
+        study.point_digest(points),
+    )
+    reference = study.AmplicolReference(
+        selector=selector,
+        contract=contract,
+        selector_contract=contract.as_dict(),
+        matrix_element=3.0,
+        timing={},
+        lineage={},
+    )
+    check = study._amplicol_singleton_check(
+        study.Evaluation((3.0, *(9.0 for _ in range(7))), None),
+        reference,
+        points,
+    )
+    assert check["seed"] == 101
+    assert check["point_count"] == 1
+    assert check["stored_amplicol_matrix_element"] == 3.0
+    assert check["comparison"]["checks"] == 1
+    within_amplicol_tolerance = study._amplicol_singleton_check(
+        study.Evaluation((3.0 * (1.0 + 0.5e-8), *(9.0 for _ in range(7))), None),
+        reference,
+        points,
+    )
+    assert within_amplicol_tolerance["comparison"]["checks"] == 1
+    with pytest.raises(study.StudyError, match="disagrees"):
+        study._amplicol_singleton_check(
+            study.Evaluation((3.0 * (1.0 + 2.0e-8), *(9.0 for _ in range(7))), None),
+            reference,
+            points,
+        )
+
+
+def test_amplicol_replays_all_eight_points_from_exact_recorded_row(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    case = study._case(8, 5)
+    points = tuple(
+        tuple(
+            (float(index) + leg / 100.0, 0.0, 0.0, 1.0) for leg in range(len(case.pdgs))
+        )
+        for index in range(1, 9)
+    )
+    word = study._colored_source_labels(case)
+    states = fixed_selector_helicity(case.pdgs)
+    selector = study.Selector(
+        word,
+        "flow:" + ",".join(map(str, word)),
+        states,
+        "h:" + ",".join(f"{state:+d}" for state in states),
+    )
+    contract = SelectorContract(
+        (selector.flow_id,),
+        (selector.flow_word,),
+        (selector.helicity_id,),
+        tuple(enumerate(selector.helicities, start=1)),
+        study.point_digest(points),
+    )
+    library = tmp_path / "selected-flow-generated-library"
+    library.mkdir()
+    entry = study.legacy_amplicol.ProcessEntry(3, 7, case.pdgs, word)
+    reference = study.AmplicolReference(
+        selector=selector,
+        contract=contract,
+        selector_contract=contract.as_dict(),
+        matrix_element=1.0,
+        timing={},
+        lineage={},
+        library_path=library,
+        process_row=(3, 7),
+    )
+    monkeypatch.setattr(
+        study.legacy_amplicol, "parse_process_file", lambda _path: (entry,)
+    )
+    monkeypatch.setattr(
+        study.legacy_amplicol,
+        "source_mapped_color_order",
+        lambda entry, **_kwargs: entry.color_order,
+    )
+    monkeypatch.setenv("LD_LIBRARY_PATH", "/prior-ld")
+    monkeypatch.setenv("DYLD_LIBRARY_PATH", "/prior-dyld")
+    observed_environments: list[tuple[str | None, str | None]] = []
+
+    def replay_probe(_library: Path, **kwargs: object) -> object:
+        observed_environments.append(
+            (os.environ.get("LD_LIBRARY_PATH"), os.environ.get("DYLD_LIBRARY_PATH"))
+        )
+        return SimpleNamespace(
+            value=kwargs["momenta"][0][0],
+            process_pdgs=case.pdgs,
+            color_order=word,
+        )
+
+    probe = mock.Mock(side_effect=replay_probe)
+    monkeypatch.setattr(study.legacy_amplicol, "run_selected_flow_library_probe", probe)
+
+    values, evidence = study._replay_amplicol(reference, case, points)
+
+    assert values == tuple(float(index) for index in range(1, 9))
+    assert evidence["point_count"] == evidence["subprocess_launches"] == 8
+    assert evidence["seed101_replay_vs_stored_matrix_element"]["checks"] == 1
+    assert probe.call_count == 8
+    root = str(library.resolve())
+    assert (
+        observed_environments
+        == [(f"{root}{os.pathsep}/prior-ld", f"{root}{os.pathsep}/prior-dyld")] * 8
+    )
+    assert os.environ["LD_LIBRARY_PATH"] == "/prior-ld"
+    assert os.environ["DYLD_LIBRARY_PATH"] == "/prior-dyld"
+    for point, call in zip(points, probe.call_args_list, strict=True):
+        assert call.args == (library,)
+        assert call.kwargs["entry"] is entry
+        assert call.kwargs["source_pdgs"] == case.pdgs
+        assert call.kwargs["momenta"] == point
+        assert call.kwargs["helicities"] is None
+        assert call.kwargs["points"] == 1
+
+    monkeypatch.setattr(
+        study.legacy_amplicol,
+        "run_selected_flow_library_probe",
+        lambda _library, **kwargs: SimpleNamespace(
+            value=kwargs["momenta"][0][0],
+            process_pdgs=case.pdgs,
+            color_order=tuple(reversed(word)),
+        ),
+    )
+    with pytest.raises(study.StudyError, match="different semantic selector flow"):
+        study._replay_amplicol(reference, case, points)
+
+
+def test_process7_compact_context_does_not_equate_backend_local_ordinals() -> None:
+    case = study._case(7, 5)
+    word = (2, 5, 6, 7, 4, 3, 1)
+    flow_id = "flow:" + ",".join(map(str, word))
+    selector = study.Selector(
+        word,
+        flow_id,
+        fixed_selector_helicity(case.pdgs),
+        "h:-1,+1,-1,+1,-1,+1,-1",
+    )
+
+    class Backend:
+        @property
+        def physics(self) -> object:
+            raise AssertionError("dense physics opened")
+
+        def _on_the_fly_benchmark_context(self, requested: object) -> dict[str, object]:
+            assert requested == (flow_id,)
+            return {
+                "process_id": case.process_id,
+                "process_expression": case.process,
+                "color_accuracy": "lc",
+                "helicity_count": 2 ** len(case.pdgs),
+                "color_count": 10,
+                "selected_color_ids": [flow_id],
+            }
+
+    context = study._cross_check_compact_selector(
+        SimpleNamespace(_backend=Backend()),
+        case,
+        selector,
+        require_ordinal_one=False,
+    )
+    assert context["requested_color_ids"] == [flow_id]
+    assert context["selected_color_ids"] == [flow_id]
+    assert context["ordinal_one_required"] is False
+    assert context["ordinal_one_matches_authority"] is None
+
+
+def test_reference_source_must_match_generated_candidate() -> None:
+    revision = "a" * 40
+    active = study.ReportSourceIdentity(revision, "c" * 40, ())
+    assert study._candidate_source_binding(active, {"source_revision": revision}) == {
+        "status": "passed",
+        "policy": "exact-source-revision",
+        "source_revision": revision,
+        "source_tree": "c" * 40,
+    }
+    with pytest.raises(study.StudyError, match="active source"):
+        study._candidate_source_binding(active, {"source_revision": "b" * 40})
+
+
+def test_stale_reused_candidate_rejects_before_report_or_any_comparator(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    args = _args(tmp_path, 5, "all-flow")
+    candidate_path = tmp_path / "candidate"
+    candidate_path.mkdir()
+    selected_report = tmp_path / "selected-report.json"
+    selected_report.touch()
+    args.candidate_artifact = candidate_path
+    args.selected_report = selected_report
+    forbidden_recurrence = mock.Mock(
+        side_effect=AssertionError("recurrence generation must not start")
+    )
+    forbidden_reference = mock.Mock(
+        side_effect=AssertionError("AmpliCol reference must not load")
+    )
+    forbidden_report = mock.Mock(
+        side_effect=AssertionError("selected report validation must not start")
+    )
+    monkeypatch.setattr(
+        study,
+        "_active_report_source",
+        lambda: study.ReportSourceIdentity("a" * 40, "c" * 40, ()),
+    )
+    monkeypatch.setattr(study, "_load_amplicol_reference", forbidden_reference)
+    monkeypatch.setattr(study.Runtime, "load", lambda *_, **__: SimpleNamespace())
+    monkeypatch.setattr(
+        study,
+        "_artifact_identity",
+        lambda *_: {
+            "producer_identity": {
+                "source_revision": "b" * 40,
+                "native_build_inputs_sha256": "d" * 64,
+            },
+            "model_identity": {"content_sha256": "e" * 64},
+        },
+    )
+    monkeypatch.setattr(study, "_selected_report_lineage", forbidden_report)
+    monkeypatch.setattr(study, "_generate_recurrence", forbidden_recurrence)
+
+    with pytest.raises(study.StudyError, match=r"generated candidate.*active source"):
+        study._run_worker(args)
+    forbidden_report.assert_not_called()
+    forbidden_reference.assert_not_called()
+    forbidden_recurrence.assert_not_called()
+
+
+def test_ineligible_active_source_is_reported(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        study,
+        "require_eligible_report_source",
+        mock.Mock(side_effect=study.ReportSourceIdentityError("dirty source")),
+    )
+    with pytest.raises(study.StudyError, match=r"active report source.*dirty source"):
+        study._active_report_source()
+
+
+def _reference_provenance(
+    case: study.Case, workload: str, target: float = 0.1
+) -> dict[str, object]:
+    cell = study._reference_cell(case, workload)
+    workload_id = "selected-flow" if workload == "selected" else "all-flow"
+    return {
+        "revision": study.PINNED_REFERENCE_REVISION,
+        "generation_timing_is_workload_specific": True,
+        "manual_campaign": {
+            "batch_size": 128,
+            "warmup_runs": 2,
+            "minimum_samples": 5,
+            "target_runtime_seconds": target,
+            "cell_identity": {
+                "accuracy": "lc",
+                "backend": "fortran",
+                "cell_id": cell.cell_id,
+                "dataset_id": "reference_amplicol_lc",
+                "execution_mode": "amplicol",
+                "model": None,
+                "n_final": case.multiplicity,
+                "process": case.process,
+                "process_key": case.process_key,
+                "variant": None,
+                "workload": workload_id,
+            },
+        },
+    }
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "message"),
+    (
+        ("batch_size", 64, "batch size"),
+        ("warmup_runs", 1, "warm-up count"),
+        ("minimum_samples", 4, "sample minimum"),
+        ("target_runtime_seconds", 0.2, "target runtime"),
+    ),
+)
+def test_reference_timing_contract_rejects_wrong_campaign_settings(
+    field: str, value: object, message: str
+) -> None:
+    case = study._case(7, 5)
+    provenance = _reference_provenance(case, "selected")
+    manual = provenance["manual_campaign"]
+    assert isinstance(manual, dict)
+    manual[field] = value
+    with pytest.raises(study.StudyError, match=message):
+        study._reference_timing_contract(provenance, case, "selected", 0.1)
+
+
+@pytest.mark.parametrize("value", (True, 4, 5.0, None))
+def test_reference_rejects_insufficient_actual_sample_count(value: object) -> None:
+    with pytest.raises(study.StudyError, match="actual samples"):
+        study._required_reference_sample_count({"sample_count": value})
+    assert study._required_reference_sample_count({"sample_count": 5}) == 5
+
+
+def test_reference_selector_rejects_non_seed101_digest() -> None:
+    case = study._case(7, 5)
+    points = tuple(((float(index), 0.0, 0.0, 1.0),) for index in range(8))
+    states = fixed_selector_helicity(case.pdgs)
+    wrong = SelectorContract(
+        ("flow:2,5,6,7,4,3,1",),
+        ((2, 5, 6, 7, 4, 3, 1),),
+        ("h:" + ",".join(f"{state:+d}" for state in states),),
+        tuple(enumerate(states, start=1)),
+        "a" * 64,
+    )
+    with pytest.raises(study.StudyError, match="seed-101 singleton"):
+        study._rebind_reference_selector(wrong.as_dict(), case, points)
+
+
+def test_generation_reporting_separates_selected_ratios_from_all_flow_absolute() -> (
+    None
+):
+    selected, selected_ratios = study._generation_reporting(
+        "selected",
+        generation_seconds=2.0,
+        warmup_seconds=0.5,
+        amplicol_generation_seconds=1.0,
+        source="this-selected-run",
+    )
+    assert selected["notation"] == "([xG] x(G+W))"
+    assert selected["generation_only_over_amplicol"] == 2.0
+    assert selected["generation_plus_warmup_over_amplicol"] == 2.5
+    assert selected_ratios == {
+        "generation_only": 2.0,
+        "generation_plus_warmup": 2.5,
+    }
+
+    all_flow, all_flow_ratios = study._generation_reporting(
+        "all-flow",
+        generation_seconds=2.0,
+        warmup_seconds=0.75,
+        amplicol_generation_seconds=None,
+        source="reused-selected-artifact-generation",
+    )
+    assert all_flow == {
+        "notation": "[G] G+W",
+        "reporting": "absolute-on-the-fly-seconds",
+        "source": "reused-selected-artifact-generation",
+        "warmup_source": "this-all-flow-cold-batch128-run",
+        "on_the_fly_generation_seconds": 2.0,
+        "on_the_fly_warmup_seconds": 0.75,
+        "on_the_fly_generation_plus_warmup_seconds": 2.75,
+    }
+    assert all_flow_ratios == {}
+
+
+def _active(queries: int, destinations: int) -> dict[str, object]:
+    result = {
+        "basis": "shared-query-family-union-v1",
+        "scope": "active-family-union",
+        "query_count": queries,
+        "union_unique_current_count": 2,
+        "union_unique_current_component_count": 3,
+        "union_amplitude_destination_count": destinations,
+    }
+    for role in study.OPERATION_ROLES:
+        result[f"union_{role}_rows"] = 2
+        result[f"union_{role}_executor_call_groups"] = 1
+    return result
+
+
+def _state(
+    families: int,
+    active: dict[str, object] | None = None,
+    *,
+    semantic_bindings: int | None = None,
+    process_id: str = "otf-test",
+) -> dict[str, object]:
+    assert families in {0, 1}
+    warm = families == 1
+    requests = int(active["query_count"]) if warm and active is not None else 0
+    destinations = (
+        int(active["union_amplitude_destination_count"])
+        if warm and active is not None
+        else 0
+    )
+    return {
+        "kind": study.STATE_KIND,
+        "process_id": process_id,
+        "family_cache_policy": study.STATE_FAMILY_CACHE_POLICY,
+        "family_cache_limit": study.STATE_FAMILY_CACHE_LIMIT,
+        "process_preparation_count": int(warm),
+        "retained_family_count": families,
+        "pending_family_count": 0,
+        "retained_selection_count": families,
+        "retained_request_count": requests,
+        "retained_amplitude_destination_count": destinations,
+        "retained_executor_handle_count": families,
+        "retained_query_local_trace_count": 0,
+        "retained_embedded_lookup_key_count": 0,
+        "semantic_executor_binding_count": (
+            int(warm) * 3 if semantic_bindings is None else semantic_bindings
+        ),
+        "active_family_union_census": active,
+    }
+
+
+def test_census_uses_public_inspection_and_exact_last_family_contract() -> None:
+    process_id = "otf_p7_one_quark_line_n5"
+    retained = _state(1, _active(2, 1), process_id=process_id)
+    inspect_runtime = mock.Mock(
+        return_value={study.STATE_INSPECTION_KEY: copy.deepcopy(retained)}
+    )
+    runtime = SimpleNamespace(inspect=inspect_runtime)
+
+    assert study._census(runtime, process_id) == retained
+    inspect_runtime.assert_called_once_with()
+
+    for field, value in (
+        ("family_cache_policy", "all-seen"),
+        ("family_cache_limit", 2),
+        ("family_cache_limit", 1.0),
+        ("family_cache_limit", True),
+        ("unexpected", 1),
+    ):
+        broken = copy.deepcopy(retained)
+        broken[field] = value
+        candidate = SimpleNamespace(
+            inspect=lambda broken=broken: {study.STATE_INSPECTION_KEY: broken}
+        )
+        with pytest.raises(study.StudyError):
+            study._census(candidate, process_id)
+
+
+@pytest.mark.parametrize(
+    ("workload", "expected_kwargs"),
+    (
+        ("selected", {"color_flows": ("flow:1",)}),
+        ("all-flow", {"helicities": ("h:-1",)}),
+    ),
+)
+def test_requested_workload_cold_warmup_is_batch128_and_clears(
+    monkeypatch: pytest.MonkeyPatch,
+    workload: str,
+    expected_kwargs: dict[str, tuple[str, ...]],
+) -> None:
+    cold = _state(0)
+    warm = _state(1, _active(2, 1))
+    states = iter((cold, warm, cold))
+    monkeypatch.setattr(study, "_census", lambda *_: copy.deepcopy(next(states)))
+    monkeypatch.setattr(
+        study.time,
+        "perf_counter_ns",
+        mock.Mock(side_effect=(1_000_000, 4_000_000)),
+    )
+    points = tuple(((float(index), 0.0, 0.0, 1.0),) for index in range(8))
+    captured: dict[str, object] = {}
+
+    def evaluate(batch: object, **kwargs: object) -> tuple[complex, ...]:
+        captured["batch"] = batch
+        captured["kwargs"] = kwargs
+        return (1.0 + 0.0j,) * 128
+
+    runtime = SimpleNamespace(evaluate=evaluate, clear=mock.Mock())
+    evidence = study._requested_workload_cold_warmup(
+        runtime,
+        study._case(7, 5),
+        study.Selector((1,), "flow:1", (-1,), "h:-1"),
+        points,
+        workload,
+        ratio_eligible=workload == "selected",
+    )
+
+    assert captured["kwargs"] == expected_kwargs
+    assert captured["batch"] == (points[0],) * 128
+    assert evidence["requested_workload"] == workload
+    assert evidence["batch_size"] == evidence["point_count"] == 128
+    assert evidence["seed"] == 101
+    assert evidence["singleton_seed_point_digest"] == study.point_digest((points[0],))
+    assert evidence["elapsed_nanoseconds"] == 3_000_000
+    assert evidence["kind"] == study.REQUESTED_COLD_WARMUP_KIND
+    assert (
+        evidence["query_construction_threads"]
+        == study.OTF_QUERY_CONSTRUCTION_THREADS
+        == 4
+    )
+    assert evidence["clear_restored_cold_state"] is True
+    assert "Runtime.load" in evidence["excluded_from_elapsed"]
+    assert "artifact generation" in evidence["excluded_from_elapsed"]
+    assert evidence["ratio_eligible"] is (workload == "selected")
+    runtime.clear.assert_called_once_with()
+
+
+def test_lean_cold_warmup_correctness_repeat_and_benchmark_reuse_one_family(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cold = _state(0)
+    warm = _state(1, _active(2, 1))
+
+    class Runtime:
+        def __init__(self) -> None:
+            self.state = copy.deepcopy(cold)
+            self.family_builds = 0
+            self.clear_calls = 0
+            self.point_counts: list[int] = []
+
+        def evaluate(self, points: object, **_kwargs: object) -> tuple[complex, ...]:
+            point_count = len(points)  # type: ignore[arg-type]
+            self.point_counts.append(point_count)
+            if self.state["retained_family_count"] == 0:
+                self.family_builds += 1
+                self.state = copy.deepcopy(warm)
+            return (1.0 + 0.0j,) * point_count
+
+        def clear(self) -> None:
+            self.clear_calls += 1
+            self.state = copy.deepcopy(cold)
+
+    runtime = Runtime()
+    monkeypatch.setattr(
+        study, "_census", lambda candidate, _process: copy.deepcopy(candidate.state)
+    )
+    monkeypatch.setattr(
+        study.time,
+        "perf_counter_ns",
+        mock.Mock(side_effect=(1_000_000, 4_000_000)),
+    )
+    case = study._case(8, 6)
+    selector = study.Selector((1,), "flow:1", (-1,), "h:-1")
+    points = tuple(((float(index), 0.0, 0.0, 1.0),) for index in range(8))
+
+    cold_evidence = study._requested_workload_cold_warmup(
+        runtime,
+        case,
+        selector,
+        points,
+        "selected",
+        ratio_eligible=True,
+        retain_family=True,
+    )
+    before, after, lifecycle = study._lifecycle(
+        runtime, case, selector, points, "selected", False
+    )
+    runtime.evaluate(study._timing_points(points), color_flows=(selector.flow_id,))
+
+    assert before is after and len(before.total) == len(study.SEEDS)
+    assert runtime.family_builds == 1
+    assert runtime.clear_calls == 0
+    assert runtime.point_counts == [128, 8, 1, 128]
+    assert cold_evidence["retained_for_followup"] is True
+    assert cold_evidence["kind"] == study.REQUESTED_COLD_WARMUP_KIND
+    assert cold_evidence["after_clear"] is None
+    assert cold_evidence["clear_call_status"] == ("omitted-retained-for-lean-lifecycle")
+    assert lifecycle["policy"]["mode"] == study.LIFECYCLE_LEAN
+    assert lifecycle["headline_point_count"] == 8
+    assert lifecycle["plateau_repeat_point_count"] == 1
+    assert lifecycle["plateau_repeat_self_consistency"]["total"]["checks"] == 1
+    assert lifecycle["clear_rebuild"]["status"] == "omitted"
+    assert lifecycle["final_plateau"] == warm
+    assert runtime.state == lifecycle["final_plateau"]
+
+
+def test_a_b_repeat_revisit_clear_rebuild_and_census_invariants(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cold, active_a, active_b = _state(0), _active(2, 1), _active(4, 2)
+    state_a = _state(1, active_a, semantic_bindings=3)
+    state_b = _state(1, active_b, semantic_bindings=5)
+    values = iter(
+        (cold, state_a, state_b, state_b, state_b, state_a, state_a, cold, state_b)
+    )
+    monkeypatch.setattr(study, "_census", lambda *_: copy.deepcopy(next(values)))
+    monkeypatch.setattr(
+        study, "_evaluate", lambda *_, **__: study.Evaluation((1.0 + 0.0j,), None)
+    )
+    monkeypatch.setattr(study, "_compare", lambda *_: {})
+
+    def native_evaluate(points: object, **_kwargs: object) -> tuple[complex, ...]:
+        if len(points) == 0:  # type: ignore[arg-type]
+            raise study.EvaluationError(
+                "on-the-fly evaluation requires at least one point"
+            )
+        return (1.0 + 0.0j,) * len(points)  # type: ignore[arg-type]
+
+    runtime = SimpleNamespace(
+        clear=mock.Mock(), evaluate=mock.Mock(side_effect=native_evaluate)
+    )
+    lifecycle = study._lifecycle(
+        runtime,
+        study._case(7, 5),
+        study.Selector((1,), "flow:1", (-1,), "h:-1"),
+        ((((1.0, 0.0, 0.0, 1.0),),)),
+        "all-flow",
+        False,
+    )[2]
+    assert lifecycle["sequence"] == "A,B,B,failed-A,B,A,A; clear; A,B"
+    assert lifecycle["after_rebuild"] == state_b
+    assert lifecycle["final_plateau"] == state_b
+    assert lifecycle["selected_a_revisit"] == state_a
+    assert lifecycle["selected_a_revisit_repeat"] == state_a
+    assert (
+        lifecycle["failed_selected_a_candidate"]["retained_family_after_failure"]
+        == state_b
+    )
+    assert state_a["semantic_executor_binding_count"] == 3
+    assert state_b["semantic_executor_binding_count"] == 5
+    for state in (state_a, state_b):
+        assert state["retained_family_count"] == 1
+        assert state["retained_selection_count"] == 1
+        assert state["retained_executor_handle_count"] == 1
+    assert lifecycle["policy"]["mode"] == study.LIFECYCLE_EXHAUSTIVE
+    assert lifecycle["clear_rebuild"]["status"] == "performed"
+    assert "cold_first_evaluation_timing" not in lifecycle
+    assert runtime.evaluate.call_count == 2
+    assert runtime.evaluate.call_args_list[0] == mock.call(
+        ((((1.0, 0.0, 0.0, 1.0),),)), color_flows=("flow:1",)
+    )
+    assert runtime.evaluate.call_args_list[1] == mock.call((), color_flows=("flow:1",))
+    runtime.clear.assert_called_once_with()
+    for field, value in (
+        ("retained_amplitude_destination_count", 0),
+        ("retained_request_count", 0),
+    ):
+        broken = copy.deepcopy(state_a)
+        broken[field] = value
+        with pytest.raises(study.StudyError):
+            study._assert_family_state(broken, "A")
+    broken = copy.deepcopy(state_a)
+    broken["active_family_union_census"]["union_source_executor_call_groups"] = 3
+    with pytest.raises(study.StudyError):
+        study._assert_family_state(broken, "A")
+
+
+def test_selected_a_c_repeat_revisit_and_rebuild(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cold, active_a, active_c = _state(0), _active(2, 1), _active(1, 1)
+    state_a = _state(1, active_a, semantic_bindings=3)
+    state_c = _state(1, active_c, semantic_bindings=2)
+    values = iter(
+        (
+            cold,
+            state_a,
+            state_c,
+            state_c,
+            state_c,
+            state_a,
+            state_a,
+            cold,
+            state_a,
+            state_c,
+            state_a,
+            state_a,
+        )
+    )
+    calls: list[str] = []
+    monkeypatch.setattr(study, "_census", lambda *_: copy.deepcopy(next(values)))
+
+    def evaluate(
+        _runtime: object,
+        _points: object,
+        workload: str,
+        _selector: object,
+        *,
+        resolved: bool,
+        _precomputed_total: tuple[object, ...] | None = None,
+    ) -> study.Evaluation:
+        assert resolved is False
+        if not calls:
+            assert _precomputed_total == (1.0 + 0.0j,)
+        calls.append(workload)
+        return study.Evaluation((1.0 + 0.0j,), None)
+
+    monkeypatch.setattr(study, "_evaluate", evaluate)
+    monkeypatch.setattr(study, "_compare", lambda *_: {})
+
+    def native_evaluate(points: object, **_kwargs: object) -> tuple[complex, ...]:
+        if len(points) == 0:  # type: ignore[arg-type]
+            raise study.EvaluationError(
+                "on-the-fly evaluation requires at least one point"
+            )
+        return (1.0 + 0.0j,) * len(points)  # type: ignore[arg-type]
+
+    runtime = SimpleNamespace(
+        clear=mock.Mock(), evaluate=mock.Mock(side_effect=native_evaluate)
+    )
+    lifecycle = study._lifecycle(
+        runtime,
+        study._case(7, 6),
+        study.Selector((1,), "flow:1", (-1,), "h:-1"),
+        ((((1.0, 0.0, 0.0, 1.0),),)),
+        "selected",
+        False,
+    )[2]
+
+    assert calls == [
+        "selected",
+        "exact",
+        "exact",
+        "selected",
+        "selected",
+        "selected",
+        "exact",
+        "selected",
+        "selected",
+    ]
+    assert lifecycle["sequence"] == "A,C,C,failed-A,C,A,A; clear; A,C,A,A"
+    assert lifecycle["requested_family"] == state_c
+    assert lifecycle["selected_a_revisit"] == state_a
+    assert lifecycle["selected_a_revisit_repeat"] == state_a
+    assert lifecycle["after_rebuild"] == state_a
+    assert lifecycle["final_plateau"] == state_a
+    assert (
+        lifecycle["failed_selected_a_candidate"]["retained_family_after_failure"]
+        == state_c
+    )
+    assert state_a["semantic_executor_binding_count"] == 3
+    assert state_c["semantic_executor_binding_count"] == 2
+    assert lifecycle["policy"]["mode"] == study.LIFECYCLE_EXHAUSTIVE
+    assert lifecycle["clear_rebuild"]["status"] == "performed"
+    assert "cold_first_evaluation_timing" not in lifecycle
+    runtime.clear.assert_called_once_with()
+
+
+def _worker_selector(
+    case: study.Case, points: tuple[object, ...]
+) -> tuple[study.Selector, SelectorContract]:
+    word = study._colored_source_labels(case)
+    states = fixed_selector_helicity(case.pdgs)
+    selector = study.Selector(
+        word,
+        "flow:" + ",".join(map(str, word)),
+        states,
+        "h:" + ",".join(f"{state:+d}" for state in states),
+    )
+    return selector, SelectorContract(
+        (selector.flow_id,),
+        (selector.flow_word,),
+        (selector.helicity_id,),
+        tuple(enumerate(selector.helicities, start=1)),
+        study.point_digest(points),
+    )
+
+
+def _patch_selected_worker_basics(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    case: study.Case,
+    points: tuple[object, ...],
+    candidate: object,
+) -> tuple[study.ReportSourceIdentity, dict[str, object]]:
+    source = study.ReportSourceIdentity("b" * 40, "e" * 40, ())
+    identity = {
+        "path": str(tmp_path / "out" / "candidate-artifact"),
+        "artifact_id": "a" * 64,
+        "producer_identity": {
+            "source_revision": source.revision,
+            "native_build_inputs_sha256": "c" * 64,
+        },
+        "model_identity": {"content_sha256": "d" * 64},
+    }
+    monkeypatch.setattr(study, "_points", lambda _case: points)
+    monkeypatch.setattr(study, "_active_report_source", lambda: source)
+    monkeypatch.setattr(
+        study.ModelSource,
+        "from_path",
+        lambda _path: SimpleNamespace(compile=lambda: object()),
+    )
+    monkeypatch.setattr(
+        study.Runtime,
+        "load",
+        lambda path, **_kwargs: (
+            candidate
+            if "recurrence-authority" not in str(path)
+            else SimpleNamespace(execution_mode="recurrence")
+        ),
+    )
+    monkeypatch.setattr(study, "_artifact_identity", lambda *_args: dict(identity))
+    monkeypatch.setattr(
+        study,
+        "_requested_workload_cold_warmup",
+        lambda *_args, **_kwargs: {"seconds": 0.5},
+    )
+    monkeypatch.setattr(study, "_census", lambda *_args: {})
+    return source, identity
+
+
+@pytest.mark.parametrize(
+    ("process_id", "multiplicity"),
+    ((7, 5), (8, 5), (11, 5), (13, 5), (15, 5), (7, 7)),
+)
+def test_amplicol_cells_forbid_recurrence_and_compiled_and_replay_eight_points(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    process_id: int,
+    multiplicity: int,
+) -> None:
+    args = _args(tmp_path, multiplicity, "selected", process_id=process_id)
+    args.prepared_model = tmp_path / "model"
+    args.prepared_model.touch()
+    case = study._case(process_id, multiplicity)
+    points = tuple(((float(index), 0.0, 0.0, 1.0),) for index in range(8))
+    selector, contract = _worker_selector(case, points)
+    candidate = SimpleNamespace()
+    _patch_selected_worker_basics(monkeypatch, tmp_path, case, points, candidate)
+    cold_warmup = mock.Mock(return_value={"seconds": 0.5})
+    monkeypatch.setattr(study, "_requested_workload_cold_warmup", cold_warmup)
+    reference = study.AmplicolReference(
+        selector=selector,
+        contract=contract,
+        selector_contract=contract.as_dict(),
+        matrix_element=3.0,
+        timing={
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 0.5e-6,
+            "evaluator_seconds_per_point": 0.4e-6,
+        },
+        lineage={"status": "authenticated"},
+    )
+    monkeypatch.setattr(study, "_load_amplicol_reference", lambda *_args: reference)
+    monkeypatch.setattr(
+        study,
+        "_generate_otf",
+        lambda *_args: {
+            "seconds": 2.0,
+            "seed_binding_calls": 1,
+            "seed_count": 1,
+            "materialized_lane_calls": 0,
+            "query_construction_threads": study.OTF_QUERY_CONSTRUCTION_THREADS,
+        },
+    )
+    forbidden_recurrence = mock.Mock(
+        side_effect=AssertionError("AmpliCol cell entered recurrence")
+    )
+    monkeypatch.setattr(study, "_generate_recurrence", forbidden_recurrence)
+    compact = mock.Mock(
+        return_value={
+            "selected_color_ids": [selector.flow_id],
+            "ordinal_one_required": False,
+            "ordinal_one_matches_authority": None,
+        }
+    )
+    monkeypatch.setattr(study, "_cross_check_compact_selector", compact)
+    evaluation = study.Evaluation((3.0, *(4.0 for _ in range(7))), None)
+    lifecycle_evidence: dict[str, object] = {"final_plateau": {}}
+    if multiplicity >= 7:
+        lifecycle_evidence["plateau_repeat_self_consistency"] = {"total": {"checks": 1}}
+    lifecycle = mock.Mock(return_value=(evaluation, evaluation, lifecycle_evidence))
+    monkeypatch.setattr(study, "_lifecycle", lifecycle)
+    replay = mock.Mock(
+        return_value=(
+            evaluation.total,
+            {"status": "passed", "point_count": 8, "subprocess_launches": 8},
+        )
+    )
+    monkeypatch.setattr(study, "_replay_amplicol", replay)
+    monkeypatch.setattr(study, "_compare", lambda *_args: {"checks": 8})
+    monkeypatch.setattr(
+        study,
+        "_benchmark",
+        lambda *_args: {
+            "wall_seconds_per_point": 1.0e-6,
+            "evaluator_seconds_per_point": 0.8e-6,
+        },
+    )
+
+    result = study._run_worker(args)
+
+    assert set(result["generation"]) == {"on_the_fly"}
+    assert set(result["artifacts"]) == {"candidate"}
+    assert set(result["timings"]) == {"on_the_fly", "amplicol"}
+    assert (
+        result["correctness"]["otf_seed101_vs_amplicol_matrix_element"]["status"]
+        == "passed"
+    )
+    authority_key = (
+        "otf_retained_vs_amplicol_replay"
+        if multiplicity >= 7
+        else "otf_before_vs_amplicol_replay"
+    )
+    assert result["correctness"][authority_key]["checks"] == 8
+    assert result["correctness"]["claim_scope"]["external_amplicol_point_count"] == 8
+    assert result["forbidden_paths"]["compiled_generation"] == "not-called"
+    assert result["forbidden_paths"]["recurrence_generation"] == "not-called"
+    compact.assert_called_once_with(
+        candidate, case, selector, require_ordinal_one=False
+    )
+    replay.assert_called_once_with(reference, case, points)
+    assert lifecycle.call_args.args[-1] is True
+    assert cold_warmup.call_args.kwargs["retain_family"] is (multiplicity >= 7)
+    if multiplicity >= 7:
+        assert (
+            result["correctness"]["retained_family_plateau_self_consistency"]["total"][
+                "checks"
+            ]
+            == 1
+        )
+        assert "pre_post_clear_self_consistency" not in result["correctness"]
+    forbidden_recurrence.assert_not_called()
+    with pytest.raises(study.StudyError, match="forbids execution mode"):
+        study._config("compiled", "topology-replay")
+
+
+@pytest.mark.parametrize("multiplicity", (6, 7))
+def test_id14_uses_recurrence_only_and_derives_its_selector(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, multiplicity: int
+) -> None:
+    args = _args(tmp_path, multiplicity, "selected", process_id=14)
+    args.prepared_model = tmp_path / "model"
+    args.prepared_model.touch()
+    case = study._case(14, multiplicity)
+    points = tuple(((float(index), 0.0, 0.0, 1.0),) for index in range(8))
+    selector, contract = _worker_selector(case, points)
+    candidate = SimpleNamespace()
+    source, identity = _patch_selected_worker_basics(
+        monkeypatch, tmp_path, case, points, candidate
+    )
+    cold_warmup = mock.Mock(return_value={"seconds": 0.5})
+    monkeypatch.setattr(study, "_requested_workload_cold_warmup", cold_warmup)
+    recurrence = SimpleNamespace(execution_mode="recurrence")
+    monkeypatch.setattr(
+        study.Runtime,
+        "load",
+        lambda path, **_kwargs: (
+            recurrence if "recurrence-authority" in str(path) else candidate
+        ),
+    )
+    monkeypatch.setattr(
+        study,
+        "_artifact_identity",
+        lambda path, *_args: {
+            **identity,
+            "path": str(path),
+            "producer_identity": {
+                "source_revision": source.revision,
+                "native_build_inputs_sha256": "c" * 64,
+            },
+        },
+    )
+    forbidden_reference = mock.Mock(
+        side_effect=AssertionError("ID14 must not load AmpliCol")
+    )
+    monkeypatch.setattr(study, "_load_amplicol_reference", forbidden_reference)
+    monkeypatch.setattr(
+        study,
+        "_generate_otf",
+        lambda *_args: {
+            "seconds": 2.0,
+            "seed_binding_calls": 1,
+            "seed_count": 1,
+            "materialized_lane_calls": 0,
+            "query_construction_threads": study.OTF_QUERY_CONSTRUCTION_THREADS,
+        },
+    )
+    generate_recurrence = mock.Mock(
+        return_value={
+            "execution_mode": "recurrence",
+            "layout": "topology-replay",
+            "seconds": 4.0,
+            "generation_threads": study.RECURRENCE_GENERATION_THREADS,
+        }
+    )
+    monkeypatch.setattr(study, "_generate_recurrence", generate_recurrence)
+    derive = mock.Mock(return_value=contract)
+    validate = mock.Mock()
+    monkeypatch.setattr(study, "derive_selector_contract", derive)
+    monkeypatch.setattr(study, "validate_selector_contract", validate)
+    compact = mock.Mock(
+        return_value={
+            "selected_color_ids": [selector.flow_id],
+            "ordinal_one_required": False,
+            "ordinal_one_matches_authority": None,
+        }
+    )
+    monkeypatch.setattr(study, "_cross_check_compact_selector", compact)
+    evaluation = study.Evaluation((3.0,) * 8, None)
+    lifecycle_evidence: dict[str, object] = {"final_plateau": {}}
+    if multiplicity >= 7:
+        lifecycle_evidence["plateau_repeat_self_consistency"] = {"total": {"checks": 1}}
+    monkeypatch.setattr(
+        study,
+        "_lifecycle",
+        lambda *_args: (evaluation, evaluation, lifecycle_evidence),
+    )
+    evaluate = mock.Mock(return_value=evaluation)
+    monkeypatch.setattr(study, "_evaluate", evaluate)
+    monkeypatch.setattr(study, "_compare", lambda *_args: {"total": {"checks": 8}})
+    monkeypatch.setattr(
+        study,
+        "_benchmark",
+        lambda _runtime, mode, *_args: {
+            "wall_seconds_per_point": 1.0e-6 if mode == "on-the-fly" else 0.5e-6,
+            "evaluator_seconds_per_point": 0.8e-6 if mode == "on-the-fly" else 0.4e-6,
+        },
+    )
+
+    result = study._run_worker(args)
+
+    assert result["authority"]["kind"] == "recurrence"
+    assert set(result["generation"]) == {"on_the_fly", "recurrence"}
+    assert set(result["artifacts"]) == {"candidate", "recurrence_authority"}
+    assert set(result["timings"]) == {"on_the_fly", "recurrence"}
+    assert result["generation_comparison"]["recurrence_generation_seconds"] == 4.0
+    assert result["generation_comparison"]["generation_only_over_recurrence"] == 0.5
+    assert (
+        result["generation_comparison"]["generation_plus_warmup_over_recurrence"]
+        == 0.625
+    )
+    assert result["descriptive_ratios"]["on_the_fly_over_recurrence"] == {
+        "wall_seconds_per_point": 2.0,
+        "evaluator_seconds_per_point": 2.0,
+        "generation_only": 0.5,
+        "generation_plus_warmup": 0.625,
+    }
+    derive.assert_called_once_with(recurrence, points)
+    validate.assert_called_once_with(recurrence, contract, points)
+    compact.assert_called_once_with(
+        candidate, case, selector, require_ordinal_one=False
+    )
+    assert cold_warmup.call_args.kwargs["ratio_eligible"] is True
+    assert cold_warmup.call_args.kwargs["retain_family"] is (multiplicity >= 7)
+    authority_key = (
+        "otf_retained_vs_recurrence"
+        if multiplicity >= 7
+        else "otf_before_vs_recurrence"
+    )
+    assert result["correctness"][authority_key]["total"]["checks"] == 8
+    if multiplicity >= 7:
+        assert (
+            result["correctness"]["retained_family_plateau_self_consistency"]["total"][
+                "checks"
+            ]
+            == 1
+        )
+        assert "pre_post_clear_self_consistency" not in result["correctness"]
+    evaluate.assert_called_once_with(
+        recurrence, points, "selected", selector, resolved=True
+    )
+    generate_recurrence.assert_called_once()
+    forbidden_reference.assert_not_called()
+
+
+def test_n8_selected_is_compact_ordinal_one_and_forbids_comparators(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    args = _args(tmp_path, 8, "selected", process_id=8)
+    args.prepared_model = tmp_path / "model"
+    args.prepared_model.touch()
+    case = study._case(8, 8)
+    points = tuple(((float(index), 0.0, 0.0, 1.0),) for index in range(8))
+    flow_id = "flow:1,2,3,4,5,6,7,8,9,10"
+
+    class Backend:
+        @property
+        def physics(self) -> object:
+            raise AssertionError("n8 dense physics opened")
+
+        def _on_the_fly_benchmark_context(self, requested: object) -> dict[str, object]:
+            assert requested == ("1",)
+            return {
+                "process_id": case.process_id,
+                "process_expression": case.process,
+                "color_accuracy": "lc",
+                "helicity_count": 1024,
+                "color_count": 100,
+                "selected_color_ids": [flow_id],
+            }
+
+    candidate = SimpleNamespace(_backend=Backend())
+    _patch_selected_worker_basics(monkeypatch, tmp_path, case, points, candidate)
+    forbidden = mock.Mock(side_effect=AssertionError("n8 comparator called"))
+    monkeypatch.setattr(study, "_load_amplicol_reference", forbidden)
+    monkeypatch.setattr(study, "_generate_recurrence", forbidden)
+    monkeypatch.setattr(study, "derive_selector_contract", forbidden)
+    monkeypatch.setattr(
+        study,
+        "_generate_otf",
+        lambda *_args: {
+            "seconds": 2.0,
+            "seed_binding_calls": 1,
+            "seed_count": 1,
+            "materialized_lane_calls": 0,
+            "query_construction_threads": study.OTF_QUERY_CONSTRUCTION_THREADS,
+        },
+    )
+    evaluation = study.Evaluation((3.0,) * 8, None)
+    lifecycle = mock.Mock(
+        return_value=(
+            evaluation,
+            evaluation,
+            {
+                "final_plateau": {},
+                "plateau_repeat_self_consistency": {"total": {"checks": 1}},
+            },
+        )
+    )
+    monkeypatch.setattr(study, "_lifecycle", lifecycle)
+    monkeypatch.setattr(study, "_compare", lambda *_args: {"checks": 8})
+    monkeypatch.setattr(
+        study,
+        "_benchmark",
+        lambda *_args: {
+            "wall_seconds_per_point": 1.0e-6,
+            "evaluator_seconds_per_point": 0.8e-6,
+        },
+    )
+
+    result = study._run_worker(args)
+
+    assert result["authority"]["kind"] == "otf-only"
+    assert result["selector_contract"]["selected_color_flow_ids"] == [flow_id]
+    assert result["compact_selector_context"]["requested_color_ids"] == ["1"]
+    assert result["correctness"]["status"] == "not-claimed"
+    assert set(result["timings"]) == {"on_the_fly"}
+    assert result["descriptive_ratios"] == {}
+    assert lifecycle.call_args.args[-1] is False
+    assert result["forbidden_paths"]["physics_enumeration"] == "not-called"
+    assert result["forbidden_paths"]["resolved_output"] == "not-called"
+    forbidden.assert_not_called()
+
+
+def test_identity_n8_forbidden_route_and_worker_argv(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    case, artifact_id = study._case(7, 8), "a" * 64
+    manifest = SimpleNamespace(
+        root=tmp_path,
+        artifact_id=artifact_id,
+        processes=(
+            dict(
+                id=case.process_id,
+                expression=case.process,
+                external_pdgs=case.pdgs,
+                color_accuracy="lc",
+            ),
+        ),
+        producer={"git_revision": "b" * 40, "native_build_inputs_sha256": "c" * 64},
+        model={
+            "name": "built-in-sm",
+            "source_kind": "built-in-sm",
+            "content_sha256": "d" * 64,
+            "compiled_schema_version": 9,
+        },
+    )
+    metadata = dict(
+        execution_mode="on-the-fly",
+        process=case.process,
+        process_key=case.process_id,
+        representative_process=case.process,
+        representative_process_key=case.process_id,
+        color_accuracy="lc",
+        external_pdg_order=case.pdgs,
+        external_count=len(case.pdgs),
+    )
+    runtime = SimpleNamespace(
+        artifact_id=artifact_id,
+        execution_mode="on-the-fly",
+        representative_process_key=case.process_id,
+        _backend=SimpleNamespace(
+            _runtime=SimpleNamespace(artifact_id=artifact_id), _native_metadata=metadata
+        ),
+    )
+    monkeypatch.setattr(study, "load_manifest", lambda *_, **__: manifest)
+    identity = study._artifact_identity(tmp_path, runtime, case, "on-the-fly")
+    assert identity["producer_identity"]["source_revision"] == "b" * 40
+    mismatched = copy.deepcopy(identity)
+    mismatched["model_identity"]["content_sha256"] = "e" * 64
+    with pytest.raises(study.StudyError, match="different models"):
+        study._common_model_identity({"candidate": identity, "authority": mismatched})
+    wrong_report = tmp_path / "wrong-selected.json"
+    wrong_report.write_text(json.dumps({"kind": "wrong"}), encoding="utf-8")
+    with pytest.raises(study.StudyError, match="wrong study identity"):
+        study._selected_report_lineage(
+            wrong_report,
+            case,
+            identity,
+            study.ReportSourceIdentity("b" * 40, "e" * 40, ()),
+        )
+
+    candidate = tmp_path / "candidate with spaces; no shell"
+    candidate.mkdir()
+    selected_report = tmp_path / "selected-report.json"
+    selected_report.touch()
+    args = _args(tmp_path, 8, "all-flow")
+    args.candidate_artifact = candidate
+    args.selected_report = selected_report
+    command = study._worker_command(args, args.output)
+    assert isinstance(command, list) and command[0] == sys.executable
+    assert str(candidate.resolve()) in command
+    assert command[-1] == str(selected_report.resolve())
+
+    selector = study.Selector(
+        tuple(range(1, 11)),
+        "flow:" + ",".join(map(str, range(1, 11))),
+        fixed_selector_helicity(case.pdgs),
+        "h:-1,+1,-1,+1,-1,+1,-1,+1,-1,+1",
+    )
+    contract = SelectorContract(
+        (selector.flow_id,),
+        (selector.flow_word,),
+        (selector.helicity_id,),
+        tuple(enumerate(selector.helicities, start=1)),
+        study.point_digest(study._points(case)),
+    )
+    forbidden = mock.Mock(side_effect=AssertionError("forbidden n>=8 route"))
+    active_source = study.ReportSourceIdentity("b" * 40, "e" * 40, ())
+    candidate_identity = {
+        **identity,
+        "path": str(candidate.resolve()),
+        "artifact_id": artifact_id,
+    }
+    retained_state = _state(
+        1,
+        _active(2, 1),
+        process_id=case.process_id,
+    )
+    selected_report.write_text(
+        json.dumps(
+            {
+                "kind": f"{study.KIND}-run",
+                "schema_version": study.SCHEMA_VERSION,
+                "status": "passed",
+                "watchdog": {
+                    "passes": True,
+                    "limit_bytes": study.WATCHDOG_BYTES,
+                },
+                "study": {
+                    "kind": study.KIND,
+                    "schema_version": study.SCHEMA_VERSION,
+                    "status": "passed",
+                    "workload": "selected",
+                    "process": study.dataclass_payload(case),
+                    "authority": {"kind": study.AUTHORITY_OTF_ONLY},
+                    "correctness": {
+                        "status": "not-claimed",
+                        "retained_family_plateau_self_consistency": {
+                            "total": {"checks": 1}
+                        },
+                    },
+                    "lifecycle_policy": study._lifecycle_policy(case, "selected"),
+                    "cache_lifecycle": {
+                        "policy": study._lifecycle_policy(case, "selected"),
+                        "headline_point_count": 8,
+                        "headline_seeds": list(study.SEEDS),
+                        "plateau_repeat_point_count": 1,
+                        "retained_requested_family": retained_state,
+                        "clear_rebuild": study._clear_rebuild_evidence(
+                            study._lifecycle_policy(case, "selected")
+                        ),
+                        "final_plateau": retained_state,
+                    },
+                    "requested_workload_cold_warmup": {
+                        "kind": study.REQUESTED_COLD_WARMUP_KIND,
+                        "requested_workload": "selected",
+                        "batch_size": 128,
+                        "point_count": 128,
+                        "query_construction_threads": (
+                            study.OTF_QUERY_CONSTRUCTION_THREADS
+                        ),
+                        "retained_for_followup": True,
+                        "clear_call_status": ("omitted-retained-for-lean-lifecycle"),
+                        "after_clear": None,
+                        "after_first_evaluation": retained_state,
+                    },
+                    "compact_selector_context": {
+                        "selector_source": "compact-seed-one-based-color-ordinal-1",
+                        "requested_color_ids": ["1"],
+                        "selected_color_ids": [selector.flow_id],
+                        "resolved_semantic_flow_id": selector.flow_id,
+                    },
+                    "producer_identity": identity["producer_identity"],
+                    "model_identity": identity["model_identity"],
+                    "active_source": active_source.provenance(),
+                    "candidate_source_binding": study._candidate_source_binding(
+                        active_source, identity["producer_identity"]
+                    ),
+                    "generation": {
+                        "on_the_fly": {
+                            "seconds": 1.0,
+                            "seed_binding_calls": 1,
+                            "seed_count": 1,
+                            "materialized_lane_calls": 0,
+                            "query_construction_threads": (
+                                study.OTF_QUERY_CONSTRUCTION_THREADS
+                            ),
+                        }
+                    },
+                    "timing_contract": {
+                        "on_the_fly_query_construction_threads": (
+                            study.OTF_QUERY_CONSTRUCTION_THREADS
+                        ),
+                        "recurrence_generation_threads": (
+                            study.RECURRENCE_GENERATION_THREADS
+                        ),
+                    },
+                    "selector_contract": contract.as_dict(),
+                    "artifacts": {"candidate": candidate_identity},
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(study, "_active_report_source", lambda: active_source)
+    monkeypatch.setattr(study, "_load_amplicol_reference", forbidden)
+    loaded: list[tuple[Path, str]] = []
+
+    def load(path: Path, *, process: str) -> object:
+        loaded.append((Path(path), process))
+        return runtime
+
+    monkeypatch.setattr(study.Runtime, "load", load)
+    monkeypatch.setattr(
+        study,
+        "_artifact_identity",
+        lambda *_: candidate_identity,
+    )
+    monkeypatch.setattr(
+        study,
+        "_cross_check_compact_selector",
+        lambda *_, **__: {"selected_color_ids": [selector.flow_id]},
+    )
+    monkeypatch.setattr(
+        study,
+        "_requested_workload_cold_warmup",
+        lambda *_, **__: {
+            "requested_workload": "all-flow",
+            "batch_size": 128,
+            "point_count": 128,
+            "seconds": 0.5,
+        },
+    )
+    monkeypatch.setattr(
+        study,
+        "_lifecycle",
+        lambda *args: (
+            study.Evaluation((1j,), None),
+            study.Evaluation((1j,), None),
+            {
+                "final_plateau": {},
+                "plateau_repeat_self_consistency": {"total": {"checks": 1}},
+            },
+        ),
+    )
+    monkeypatch.setattr(
+        study,
+        "_benchmark",
+        lambda *_: {
+            "wall_seconds_per_point": 1e-6,
+            "evaluator_seconds_per_point": 0.8e-6,
+        },
+    )
+    monkeypatch.setattr(study, "_census", lambda *_: {})
+    monkeypatch.setattr(study, "_compare", lambda *_: {})
+    monkeypatch.setattr(study, "_generate_recurrence", forbidden)
+    monkeypatch.setattr(study, "derive_selector_contract", forbidden)
+    monkeypatch.setattr(study.ModelSource, "from_path", forbidden)
+    result = study._run_worker(args)
+    assert loaded == [(candidate.resolve(), case.process_id)]
+    assert result["candidate_reuse"]["status"] == "actual-reuse"
+    assert (
+        result["generation"] == {} and result["correctness"]["status"] == "not-claimed"
+    )
+    assert result["candidate_source_binding"]["status"] == "passed"
+    assert result["amplicol_reference"] is None
+    assert set(result["timings"]) == {"on_the_fly"}
+    assert result["generation_comparison"] == {
+        "notation": "[G] G+W",
+        "reporting": "absolute-on-the-fly-seconds",
+        "source": "reused-selected-artifact-generation",
+        "warmup_source": "this-all-flow-cold-batch128-run",
+        "on_the_fly_generation_seconds": 1.0,
+        "on_the_fly_warmup_seconds": 0.5,
+        "on_the_fly_generation_plus_warmup_seconds": 1.5,
+    }
+    assert result["descriptive_ratios"] == {}
+    assert result["forbidden_paths"]["external_comparator"] == "not-created"
+    assert result["forbidden_paths"]["physics_enumeration"] == "not-called"
+    valid_selected = json.loads(selected_report.read_text(encoding="utf-8"))
+    for mutation in (
+        "missing-warmup",
+        "wrong-warmed-census",
+        "wrong-prerequisite",
+        "wrong-thread-contract",
+    ):
+        invalid = copy.deepcopy(valid_selected)
+        selected = invalid["study"]
+        if mutation == "missing-warmup":
+            del selected["requested_workload_cold_warmup"]
+        elif mutation == "wrong-warmed-census":
+            selected["requested_workload_cold_warmup"]["after_first_evaluation"] = {
+                "retained_family_count": 2
+            }
+        elif mutation == "wrong-prerequisite":
+            selected["cache_lifecycle"]["clear_rebuild"][
+                "expected_prior_campaign_prerequisite"
+            ]["workload"] = "all-flow"
+        else:
+            selected["timing_contract"]["on_the_fly_query_construction_threads"] = 1
+        selected_report.write_text(json.dumps(invalid), encoding="utf-8")
+        with pytest.raises(study.StudyError):
+            study._selected_report_lineage(
+                selected_report, case, candidate_identity, active_source
+            )
+    forbidden.assert_not_called()
+
+
+def test_resolved_total_must_match_public_total() -> None:
+    selector = study.Selector((1,), "flow:1", (-1,), "h:-1")
+
+    class Resolved:
+        color_ids = ("flow:1",)
+
+        @staticmethod
+        def total() -> tuple[complex, ...]:
+            return (2.0 + 0.0j,)
+
+    runtime = SimpleNamespace(
+        evaluate=lambda *_args, **_kwargs: (1.0 + 0.0j,),
+        evaluate_resolved=lambda *_args, **_kwargs: Resolved(),
+    )
+    with pytest.raises(study.StudyError):
+        study._evaluate(
+            runtime,
+            ((((1.0, 0.0, 0.0, 1.0),),)),
+            "selected",
+            selector,
+            resolved=True,
+        )
+
+
+@pytest.mark.parametrize(
+    "mutation",
+    (
+        None,
+        "artifact-id",
+        "canonical-path",
+        "authority",
+        "source-lineage",
+        "selector-proof",
+        "contract-flow",
+    ),
+)
+def test_selected_report_binds_exact_candidate(
+    mutation: str | None, tmp_path: Path
+) -> None:
+    case = study._case(7, 5)
+    candidate_path = tmp_path / "candidate"
+    candidate_path.mkdir()
+    canonical = str(candidate_path.resolve())
+    artifact_id = "a" * 64
+    source = study.ReportSourceIdentity("b" * 40, "e" * 40, ())
+    producer = {
+        "source_revision": source.revision,
+        "native_build_inputs_sha256": "c" * 64,
+    }
+    model = {"content_sha256": "d" * 64}
+    recorded_path = canonical
+    recorded_id = artifact_id
+    if mutation == "artifact-id":
+        recorded_id = "b" * 64
+    elif mutation == "canonical-path":
+        recorded_path = (
+            f"{candidate_path.parent}/../{candidate_path.parent.name}/candidate"
+        )
+    cold_state = _state(0, process_id=case.process_id)
+    selected_a_state = _state(
+        1,
+        _active(2, 1),
+        semantic_bindings=3,
+        process_id=case.process_id,
+    )
+    exact_c_state = _state(
+        1,
+        _active(1, 1),
+        semantic_bindings=2,
+        process_id=case.process_id,
+    )
+    payload = {
+        "kind": f"{study.KIND}-run",
+        "schema_version": study.SCHEMA_VERSION,
+        "status": "passed",
+        "watchdog": {"passes": True, "limit_bytes": study.WATCHDOG_BYTES},
+        "study": {
+            "kind": study.KIND,
+            "schema_version": study.SCHEMA_VERSION,
+            "status": "passed",
+            "workload": "selected",
+            "process": study.dataclass_payload(case),
+            "authority": {"kind": study.AUTHORITY_AMPLICOL},
+            "correctness": {
+                "status": "passed",
+                "otf_before_vs_amplicol_replay": {"checks": 8},
+                "otf_after_vs_amplicol_replay": {"checks": 8},
+                "pre_post_clear_self_consistency": {"total": {"checks": 8}},
+            },
+            "lifecycle_policy": study._lifecycle_policy(case, "selected"),
+            "cache_lifecycle": {
+                "policy": study._lifecycle_policy(case, "selected"),
+                "clear_rebuild": study._clear_rebuild_evidence(
+                    study._lifecycle_policy(case, "selected")
+                ),
+                "selected_a": selected_a_state,
+                "requested_family": exact_c_state,
+                "requested_repeat": exact_c_state,
+                "failed_selected_a_candidate": {
+                    "status": "passed",
+                    "candidate_workload": "selected",
+                    "point_count": 0,
+                    "failure": "on-the-fly evaluation requires at least one point",
+                    "retained_family_after_failure": exact_c_state,
+                },
+                "selected_a_revisit": selected_a_state,
+                "selected_a_revisit_repeat": selected_a_state,
+                "after_clear": cold_state,
+                "after_rebuild_selected_a": selected_a_state,
+                "after_rebuild_exact_c": exact_c_state,
+                "after_rebuild_selected_a_revisit": selected_a_state,
+                "after_rebuild_selected_a_repeat": selected_a_state,
+                "after_rebuild": selected_a_state,
+                "final_plateau": selected_a_state,
+                "sequence": "A,C,C,failed-A,C,A,A; clear; A,C,A,A",
+            },
+            "requested_workload_cold_warmup": {
+                "query_construction_threads": study.OTF_QUERY_CONSTRUCTION_THREADS,
+            },
+            "compact_selector_context": {
+                "ordinal_one_required": False,
+                "ordinal_one_matches_authority": None,
+                "requested_color_ids": ["flow:2,5,6,7,4,3,1"],
+                "selected_color_ids": ["flow:2,5,6,7,4,3,1"],
+                "semantic_authority_flow_id": "flow:2,5,6,7,4,3,1",
+            },
+            "producer_identity": producer,
+            "model_identity": model,
+            "active_source": source.provenance(),
+            "candidate_source_binding": study._candidate_source_binding(
+                source, producer
+            ),
+            "generation": {
+                "on_the_fly": {
+                    "seconds": 1.0,
+                    "seed_binding_calls": 1,
+                    "seed_count": 1,
+                    "materialized_lane_calls": 0,
+                    "query_construction_threads": (
+                        study.OTF_QUERY_CONSTRUCTION_THREADS
+                    ),
+                }
+            },
+            "timing_contract": {
+                "on_the_fly_query_construction_threads": (
+                    study.OTF_QUERY_CONSTRUCTION_THREADS
+                ),
+                "recurrence_generation_threads": (study.RECURRENCE_GENERATION_THREADS),
+            },
+            "selector_contract": SelectorContract(
+                ("flow:2,5,6,7,4,3,1",),
+                ((2, 5, 6, 7, 4, 3, 1),),
+                ("h:-1,+1,-1,+1,-1,+1,-1",),
+                tuple(enumerate(fixed_selector_helicity(case.pdgs), start=1)),
+                "f" * 64,
+            ).as_dict(),
+            "artifacts": {
+                "candidate": {"path": recorded_path, "artifact_id": recorded_id}
+            },
+        },
+    }
+    if mutation == "authority":
+        payload["study"]["authority"]["kind"] = study.AUTHORITY_OTF_ONLY
+    elif mutation == "source-lineage":
+        payload["study"]["producer_identity"]["source_revision"] = "e" * 40
+    elif mutation == "selector-proof":
+        payload["study"]["compact_selector_context"]["requested_color_ids"] = ["1"]
+    elif mutation == "contract-flow":
+        payload["study"]["compact_selector_context"]["semantic_authority_flow_id"] = (
+            "flow:1,2,3,4,5,6,7"
+        )
+    report = tmp_path / f"selected-{mutation or 'valid'}.json"
+    report.write_text(json.dumps(payload), encoding="utf-8")
+    candidate = {
+        "path": canonical,
+        "artifact_id": artifact_id,
+        "producer_identity": producer,
+        "model_identity": model,
+    }
+    if mutation is None:
+        lineage = study._selected_report_lineage(report, case, candidate, source)
+        assert lineage["candidate_path"] == canonical
+        assert lineage["candidate_artifact_id"] == artifact_id
+    else:
+        with pytest.raises(study.StudyError):
+            study._selected_report_lineage(report, case, candidate, source)
+
+
+@pytest.mark.parametrize(
+    ("interrupted", "target", "batch", "warmups", "minimum", "samples"),
+    (
+        (True, 0.1, 128, 2, 5, 5),
+        (False, 0.2, 128, 2, 5, 5),
+        (False, 0.1, 64, 2, 5, 5),
+        (False, 0.1, 128, 1, 5, 5),
+        (False, 0.1, 128, 2, 4, 5),
+        (False, 0.1, 128, 2, 5, 4),
+    ),
+)
+def test_benchmark_rejects_partial_or_wrong_effective_contract(
+    monkeypatch: pytest.MonkeyPatch,
+    interrupted: bool,
+    target: float,
+    batch: int,
+    warmups: int,
+    minimum: int,
+    samples: int,
+) -> None:
+    result = SimpleNamespace(
+        interrupted=interrupted,
+        sample_count=samples,
+        effective_config=SimpleNamespace(
+            target_runtime=target,
+            precision=16,
+            batch_size=batch,
+            warmup_runs=warmups,
+            minimum_samples=minimum,
+            helicity_ids=(),
+            color_flow_ids=("flow:1",),
+        ),
+    )
+    monkeypatch.setattr(
+        study,
+        "BenchmarkRunner",
+        lambda _config: SimpleNamespace(run=lambda *_args, **_kwargs: result),
+    )
+    with pytest.raises(study.StudyError):
+        study._benchmark(
+            SimpleNamespace(),
+            "on-the-fly",
+            ((((1.0, 0.0, 0.0, 1.0),),)),
+            "selected",
+            study.Selector((1,), "flow:1", (-1,), "h:-1"),
+            0.1,
+        )
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("precision", 8),
+        ("helicity_ids", ("h:-1",)),
+        ("color_flow_ids", ("flow:2",)),
+    ),
+)
+def test_benchmark_rejects_wrong_precision_or_selector(
+    monkeypatch: pytest.MonkeyPatch, field: str, value: object
+) -> None:
+    effective = SimpleNamespace(
+        target_runtime=0.1,
+        precision=16,
+        batch_size=128,
+        warmup_runs=2,
+        minimum_samples=5,
+        helicity_ids=(),
+        color_flow_ids=("flow:1",),
+    )
+    setattr(effective, field, value)
+    result = SimpleNamespace(
+        interrupted=False,
+        sample_count=5,
+        effective_config=effective,
+    )
+    monkeypatch.setattr(
+        study,
+        "BenchmarkRunner",
+        lambda _config: SimpleNamespace(run=lambda *_args, **_kwargs: result),
+    )
+    with pytest.raises(study.StudyError, match="effective timing contract"):
+        study._benchmark(
+            SimpleNamespace(),
+            "on-the-fly",
+            ((((1.0, 0.0, 0.0, 1.0),),)),
+            "selected",
+            study.Selector((1,), "flow:1", (-1,), "h:-1"),
+            0.1,
+        )
diff --git a/pyamplicol/tests/unit/test_on_the_fly_lc_gate.py b/pyamplicol/tests/unit/test_on_the_fly_lc_gate.py
new file mode 100644
index 0000000000..e15fffefb6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_on_the_fly_lc_gate.py
@@ -0,0 +1,2099 @@
+# SPDX-License-Identifier: 0BSD
+"""Gate-level contracts for the developer on-the-fly LC harness."""
+
+from __future__ import annotations
+
+import io
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.artifacts import ArtifactBuilder, load_manifest
+from pyamplicol.generation.evaluator_container import (
+    PacbinMemberKind,
+    PacbinMemberSource,
+    write_pacbin_atomic,
+)
+from tools.developer import on_the_fly_lc_gate as gate
+
+
+def _write_execution(root: Path, payload: object) -> None:
+    process = root / "processes" / gate.PROCESS_ID
+    process.mkdir(parents=True)
+    (process / "execution.json").write_text(json.dumps(payload), encoding="utf-8")
+
+
+def _write_on_the_fly_contract_artifact(
+    root: Path,
+    *,
+    execution_field: str | None = None,
+    extra_seed_member: bool = False,
+    extra_sidecar: str | None = None,
+) -> str:
+    process_prefix = f"processes/{gate.PROCESS_ID}"
+    target = {"triple": "portable-64le", "cpu_features": []}
+    capabilities = list(gate.ON_THE_FLY_CAPABILITIES)
+    pdgs = (1, -1, 6, -6, 21, 21)
+    execution: dict[str, object] = {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-on-the-fly-execution",
+        "required_runtime_capabilities": capabilities,
+        "process": gate.PROCESS,
+        "key": gate.PROCESS_ID,
+        "color_accuracy": "lc",
+        "external_pdg_order": list(pdgs),
+        "kernel_pack": {
+            "manifest_path": "model/eager-kernel-pack.json",
+            "payload_root": "model/eager-kernels",
+        },
+        "runtime_options": {
+            "point_tile_size": 128,
+            "query_construction_threads": 1,
+        },
+        "selector_policy": {
+            "color_coverage": "complete",
+            "reference_color_word": None,
+            "trace_reflections_folded": False,
+            "selector_census": {
+                "physical_helicity_count": 64,
+                "physical_color_flow_count": 12,
+            },
+        },
+        "runtime_metadata": {
+            "runtime_parameters": [],
+            "prepared_parameter_defaults": [],
+            "parameter_projection": [],
+            "external_legs": [],
+            "particle_masses": [],
+            "normalization": {},
+        },
+        "runtime_container": {
+            "kind": "pyamplicol-on-the-fly-runtime-container",
+            "schema_version": 1,
+            "storage_abi": "pacbin-v1",
+            "path": "on-the-fly-runtime.pacbin",
+            "seed_member_path": gate.ON_THE_FLY_SEED_MEMBER_PATH,
+        },
+    }
+    if execution_field is not None:
+        execution[execution_field] = {"materialized": True}
+
+    with ArtifactBuilder(root) as builder:
+        builder.add_bytes(
+            "config/requested.toml",
+            b"[evaluator]\nexecution_mode = 'on-the-fly'\n",
+            role="configuration-requested",
+            media_type="application/toml",
+        )
+        builder.add_bytes(
+            "config/effective.toml",
+            b"[evaluator]\nexecution_mode = 'on-the-fly'\n",
+            role="configuration-effective",
+            media_type="application/toml",
+        )
+        builder.add_json(
+            "model/compiled-model.json",
+            {"schema_version": 1},
+            role="compiled-model",
+        )
+        builder.add_json(
+            "model/eager-kernel-pack.json",
+            {"kind": "fixture-prepared-kernel-pack"},
+            role="evaluator-manifest",
+        )
+        builder.add_json(
+            "processes/evaluators.json",
+            {
+                "schema_version": 3,
+                "kind": "pyamplicol-runtime-execution-set",
+                "required_runtime_capabilities": capabilities,
+                "processes": [
+                    {
+                        "process_id": gate.PROCESS_ID,
+                        "manifest_path": f"{gate.PROCESS_ID}/execution.json",
+                        "required_runtime_capabilities": capabilities,
+                    }
+                ],
+            },
+            role="evaluator-manifest",
+        )
+        builder.add_json(
+            f"{process_prefix}/execution.json",
+            execution,
+            role="evaluator-manifest",
+            process_id=gate.PROCESS_ID,
+            compact=True,
+        )
+        builder.add_json(
+            f"{process_prefix}/physics.json",
+            {
+                "schema_version": 1,
+                "kind": "pyamplicol-on-the-fly-public-metadata",
+                "process_id": gate.PROCESS_ID,
+                "process": gate.PROCESS,
+                "color_accuracy": "lc",
+                "external_particles": [
+                    {
+                        "index": index,
+                        "label": index + 1,
+                        "particle": name,
+                        "pdg": pdg,
+                        "role": "initial" if index < 2 else "final",
+                        "momentum_slot": index,
+                        "momentum_components": ["E", "px", "py", "pz"],
+                    }
+                    for index, (name, pdg) in enumerate(
+                        (
+                            ("d", 1),
+                            ("d~", -1),
+                            ("t", 6),
+                            ("t~", -6),
+                            ("g", 21),
+                            ("g", 21),
+                        )
+                    )
+                ],
+                "model_parameters": [],
+            },
+            role="runtime-physics",
+            process_id=gate.PROCESS_ID,
+            compact=True,
+        )
+        builder.add_json(
+            f"{process_prefix}/validation-momenta.json",
+            {"available": False},
+            role="validation-momenta",
+            process_id=gate.PROCESS_ID,
+            compact=True,
+        )
+        runtime_path = builder.staged_path(
+            f"{process_prefix}/on-the-fly-runtime.pacbin",
+            create_parent=True,
+        )
+        members = [
+            PacbinMemberSource(
+                gate.ON_THE_FLY_SEED_MEMBER_PATH,
+                PacbinMemberKind.ON_THE_FLY_PROCESS_SEED,
+                io.BytesIO(b"compact-process-seed"),
+            )
+        ]
+        if extra_seed_member:
+            members.append(
+                PacbinMemberSource(
+                    "on-the-fly/materialized-direct-plan-v1.bin",
+                    PacbinMemberKind.ON_THE_FLY_PROCESS_SEED,
+                    io.BytesIO(b"materialized-sidecar"),
+                )
+            )
+        write_pacbin_atomic(runtime_path, members)
+        builder.register_staged_file(
+            f"{process_prefix}/on-the-fly-runtime.pacbin",
+            role="evaluator-state",
+            media_type="application/octet-stream",
+            executable=False,
+            target=target,
+            process_id=gate.PROCESS_ID,
+        )
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer={
+                "distribution": "pyamplicol",
+                "version": "0.1.0",
+                "versions": {
+                    "python_api": 1,
+                    "toml": 1,
+                    "compiled_model": 1,
+                    "process_artifact": 3,
+                    "runtime_physics": 1,
+                    "symbolica_serialization": "fixture",
+                    "c_abi": 1,
+                },
+                "target": target,
+            },
+            model={
+                "name": "built-in-sm",
+                "source_kind": "built-in-sm",
+                "content_sha256": "1" * 64,
+                "compiled_schema_version": 1,
+            },
+            configuration={
+                "toml_schema_version": 1,
+                "requested_path": "config/requested.toml",
+                "effective_path": "config/effective.toml",
+                "adjustments": [],
+            },
+            processes=[
+                {
+                    "id": gate.PROCESS_ID,
+                    "expression": gate.PROCESS,
+                    "color_accuracy": "lc",
+                    "external_pdgs": list(pdgs),
+                    "physics_path": f"{process_prefix}/physics.json",
+                    "required_runtime_capabilities": capabilities,
+                    "aliases": [],
+                }
+            ],
+            default_process_id=gate.PROCESS_ID,
+            runtime={
+                "engine": "rusticol",
+                "engine_version": "0.1.0",
+                "evaluator_manifest_path": "processes/evaluators.json",
+                "api_bundle_path": None,
+                "required_runtime_capabilities": capabilities,
+            },
+        )
+
+    if extra_sidecar is not None:
+        sidecar = root / process_prefix / extra_sidecar
+        sidecar.parent.mkdir(parents=True, exist_ok=True)
+        sidecar.write_bytes(b"forbidden materialized sidecar")
+    return load_manifest(root, verify_payloads=True).artifact_id
+
+
+def _compiled_record(
+    *,
+    sources: int,
+    currents: int,
+    components: int,
+    attachments: int,
+    evaluations: int,
+    roots: int,
+) -> dict[str, object]:
+    return {
+        "kind": "pyamplicol-runtime-execution",
+        "dag_summary": {
+            "source_count": sources,
+            "current_count": currents,
+            "interaction_count": attachments,
+            "interaction_evaluation_count": evaluations,
+            "amplitude_root_count": roots,
+        },
+        "runtime_schema": {"current_storage": {"component_count": components}},
+    }
+
+
+def _runtime(
+    mode: str,
+    *,
+    flows: tuple[SimpleNamespace, ...] = (),
+    helicities: tuple[SimpleNamespace, ...] = (),
+    artifact_id: str = "a" * 64,
+    process: str = gate.PROCESS,
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        execution_mode=mode,
+        artifact_id=artifact_id,
+        physics=SimpleNamespace(
+            process_id=gate.PROCESS_ID,
+            process=process,
+            color_accuracy="lc",
+            external_particles=tuple(
+                SimpleNamespace(pdg_id=pdg) for pdg in gate.EXTERNAL_PDGS
+            ),
+            color_flows=flows,
+            helicities=helicities,
+        ),
+    )
+
+
+def _fixed_authority_physics(
+    flow: SimpleNamespace,
+    helicity: SimpleNamespace,
+    *,
+    process: str = gate.PROCESS,
+    color_accuracy: str = "lc",
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        process_id=gate.PROCESS_ID,
+        process=process,
+        color_accuracy=color_accuracy,
+        external_particles=tuple(
+            SimpleNamespace(pdg_id=pdg) for pdg in gate.EXTERNAL_PDGS
+        ),
+        color_flows=(flow,),
+        helicities=(helicity,),
+    )
+
+
+def _fake_public_phase() -> gate.PublicGatePhase:
+    resolved = SimpleNamespace(
+        helicity_ids=(gate.HELICITY_ID,),
+        color_ids=(gate.FLOW_ID,),
+        values=(((1.0,),),),
+        total=lambda: (1.0,),
+    )
+    evaluation = gate.PublicEvaluation(total=(1.0,), resolved=resolved)
+    correctness = gate.RecurrenceAuthorityCorrectness(
+        recurrence_selected=evaluation,
+        recurrence_all_flow=evaluation,
+        on_the_fly_selected=evaluation,
+        on_the_fly_all_flow=evaluation,
+        public_correctness={"public": "green"},
+        clear_checks={"clear": "green"},
+    )
+    candidate = SimpleNamespace(
+        artifact_id="a" * 64,
+        execution_mode="on-the-fly",
+    )
+    recurrence_selected = SimpleNamespace(
+        artifact_id="b" * 64,
+        execution_mode="recurrence",
+    )
+    recurrence_all = SimpleNamespace(
+        artifact_id="c" * 64,
+        execution_mode="recurrence",
+    )
+    timing = {"wall_seconds_per_point": 1.0}
+    return gate.PublicGatePhase(
+        runtime=candidate,
+        selected_recurrence_runtime=recurrence_selected,
+        all_flow_recurrence_runtime=recurrence_all,
+        comparator_selectors=(),
+        points=((((1.0,),),),),
+        timing_points=((((1.0,),),),),
+        correctness=correctness,
+        artifact_contract={"artifact_id": "a" * 64},
+        load_seconds=0.01,
+        public_profiles={
+            "selected_flow_helicity_sum": {"status": "profiled"},
+            "all_flow_single_helicity": {"status": "profiled"},
+        },
+        timings={
+            lane: {
+                "selected_flow_helicity_sum": timing,
+                "all_flow_single_helicity": timing,
+            }
+            for lane in ("on_the_fly", "recurrence")
+        },
+    )
+
+
+def test_real_on_the_fly_candidate_and_private_probe_carrier_are_separate() -> None:
+    candidate = gate._on_the_fly_config()
+    assert candidate.color.accuracy == "lc"
+    assert candidate.color.lc_flow_layout == "topology-replay"
+    assert candidate.evaluator.execution_mode == "on-the-fly"
+    assert candidate.evaluator.backend == "jit"
+    assert candidate.evaluator.jit.optimization_level == 2
+    assert candidate.generation.relation_discovery.mode == "off"
+    assert candidate.generation.validation.enabled is True
+    assert candidate.generation.validation.post_build_validation is True
+
+    carrier = gate._recurrence_probe_config()
+    assert carrier.evaluator.execution_mode == "recurrence"
+    assert carrier.generation.validation.enabled is False
+    assert carrier.generation.validation.post_build_validation is False
+
+    flow = SimpleNamespace(id=gate.FLOW_ID, word=gate.FLOW_WORD, index=7)
+    helicity = SimpleNamespace(
+        id=gate.HELICITY_ID,
+        values=gate.HELICITY_VALUES,
+        structural_zero=False,
+    )
+    assert gate._selectors(
+        SimpleNamespace(color_flows=(flow,), helicities=(helicity,))
+    ) == (flow, helicity)
+    assert gate._query(flow, helicity).flow_index == 7
+
+    authority = gate._dense_authority(
+        SimpleNamespace(artifact_id="a" * 64),
+        SimpleNamespace(artifact_id="b" * 64),
+        8,
+    )
+    assert authority["authority_kind"] == "validated_recurrence"
+    assert authority["authority_execution_mode"] == "recurrence"
+    assert authority["runtime_api"] == "Runtime.evaluate_resolved"
+    assert authority["selected_flow_artifact_id"] == "a" * 64
+    assert authority["all_flow_artifact_id"] == "b" * 64
+    assert authority["certifies"] == (
+        "selected_flow_helicity_sum",
+        "all_flow_single_helicity",
+    )
+    assert gate._sum(((1.0, 2.0), (3.0, 4.0)), 2) == (4.0, 6.0)
+    assert gate._series((0.0,), (0.0,), "zero")["worst"]["status"] == "ok"
+    with pytest.raises(gate.GateError, match="disagrees"):
+        gate._series((1.0e-300,), (0.0,), "no absolute floor")
+
+
+def test_resolved_authority_checks_each_component_not_only_the_total() -> None:
+    candidate = SimpleNamespace(
+        helicity_ids=("h:first", "h:second"),
+        color_ids=("flow:only",),
+        values=(((2.0,), (0.0,)),),
+    )
+    reference = SimpleNamespace(
+        helicity_ids=("h:first", "h:second"),
+        color_ids=("flow:only",),
+        values=(((1.0,), (1.0,)),),
+    )
+    assert sum(value[0] for value in candidate.values[0]) == sum(
+        value[0] for value in reference.values[0]
+    )
+    with pytest.raises(gate.GateError, match="disagrees"):
+        gate._resolved_component_checks(candidate, reference, "canceling components")
+
+
+def test_recurrence_authority_correctness_uses_public_ids_and_clears_in_order() -> None:
+    events: list[str] = []
+    points = tuple((((float(index),),),) for index in range(len(gate.SEEDS)))
+
+    class Resolved:
+        def __init__(
+            self,
+            helicity_ids: tuple[str, ...],
+            color_ids: tuple[str, ...],
+            component_rows: tuple[tuple[float, ...], ...],
+        ) -> None:
+            self.helicity_ids = helicity_ids
+            self.color_ids = color_ids
+            self.values = tuple(
+                tuple(
+                    tuple(
+                        component_rows[helicity][color]
+                        for color in range(len(color_ids))
+                    )
+                    for helicity in range(len(helicity_ids))
+                )
+                for _point in points
+            )
+
+        def total(self) -> tuple[float, ...]:
+            return tuple(
+                sum(value for helicity in point for value in helicity)
+                for point in self.values
+            )
+
+    selected_recurrence = Resolved(
+        ("h:first", "h:second"), (gate.FLOW_ID,), ((1.0,), (2.0,))
+    )
+    all_flow_recurrence = Resolved(
+        (gate.HELICITY_ID,), ("flow:first", "flow:second"), ((4.0, 5.0),)
+    )
+
+    class Runtime:
+        def __init__(
+            self,
+            label: str,
+            selected: Resolved,
+            all_flow: Resolved,
+            *,
+            flow_ordinal: int,
+        ) -> None:
+            self.label = label
+            self.selected = selected
+            self.all_flow = all_flow
+            self.flow_ordinal = flow_ordinal
+
+        def _resolved(self, selectors: object) -> tuple[str, Resolved]:
+            if selectors == {"color_flows": (gate.FLOW_ID,)}:
+                return "selected", self.selected
+            if selectors == {"helicities": (gate.HELICITY_ID,)}:
+                return "all-flow", self.all_flow
+            raise AssertionError(
+                f"{self.label} received a native ordinal instead of a public ID: "
+                f"{selectors!r} (ordinal={self.flow_ordinal})"
+            )
+
+        def evaluate(self, _points: object, **selectors: object) -> tuple[float, ...]:
+            workload, resolved = self._resolved(selectors)
+            events.append(f"{self.label}:{workload}:total")
+            return resolved.total()
+
+        def evaluate_resolved(self, _points: object, **selectors: object) -> Resolved:
+            workload, resolved = self._resolved(selectors)
+            events.append(f"{self.label}:{workload}:resolved")
+            return resolved
+
+        def clear(self) -> None:
+            events.append(f"{self.label}:clear")
+
+    recurrence_selected_runtime = Runtime(
+        "recurrence-selected",
+        selected_recurrence,
+        all_flow_recurrence,
+        flow_ordinal=8,
+    )
+    recurrence_all_flow_runtime = Runtime(
+        "recurrence-all-flow",
+        selected_recurrence,
+        all_flow_recurrence,
+        flow_ordinal=8,
+    )
+    candidate_runtime = Runtime(
+        "on-the-fly",
+        selected_recurrence,
+        all_flow_recurrence,
+        flow_ordinal=99,
+    )
+
+    result = gate._recurrence_authority_correctness(
+        candidate_runtime,
+        recurrence_selected_runtime,
+        recurrence_all_flow_runtime,
+        points,
+    )
+
+    assert len(points) == 8
+    assert events == [
+        "recurrence-selected:selected:total",
+        "recurrence-selected:selected:resolved",
+        "recurrence-all-flow:all-flow:total",
+        "recurrence-all-flow:all-flow:resolved",
+        "on-the-fly:selected:total",
+        "on-the-fly:selected:resolved",
+        "on-the-fly:all-flow:total",
+        "on-the-fly:all-flow:resolved",
+        "on-the-fly:clear",
+        "on-the-fly:selected:total",
+        "on-the-fly:selected:resolved",
+        "on-the-fly:all-flow:total",
+        "on-the-fly:all-flow:resolved",
+    ]
+    assert (
+        result.public_correctness["selected_flow_helicity_sum"]["resolved_authority"][
+            "checks"
+        ]
+        == 16
+    )
+    assert (
+        result.public_correctness["all_flow_single_helicity"]["resolved_authority"][
+            "checks"
+        ]
+        == 16
+    )
+    assert result.clear_checks["selected_resolved"]["checks"] == 16
+    assert events.count("on-the-fly:clear") == 1
+
+
+def test_public_gate_profiles_and_benchmarks_only_after_recurrence_authority(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    events: list[str] = []
+    flow = SimpleNamespace(id=gate.FLOW_ID, word=gate.FLOW_WORD, index=0)
+    helicity = SimpleNamespace(
+        id=gate.HELICITY_ID,
+        values=gate.HELICITY_VALUES,
+        structural_zero=False,
+    )
+    physics = _fixed_authority_physics(flow, helicity)
+    candidate = SimpleNamespace(execution_mode="on-the-fly", artifact_id="a" * 64)
+    authorities = {
+        tmp_path / "recurrence-selected": SimpleNamespace(
+            execution_mode="recurrence", artifact_id="b" * 64, physics=physics
+        ),
+        tmp_path / "recurrence-all": SimpleNamespace(
+            execution_mode="recurrence", artifact_id="c" * 64, physics=physics
+        ),
+    }
+    artifact = tmp_path / "candidate"
+
+    def load(path: Path, **_kwargs: object) -> object:
+        return candidate if Path(path) == artifact else authorities[Path(path)]
+
+    def correctness(*_args: object) -> gate.RecurrenceAuthorityCorrectness:
+        events.append("correctness")
+        return _fake_public_phase().correctness
+
+    def profile(*_args: object, **_kwargs: object) -> dict[str, object]:
+        events.append("profile")
+        return {"status": "profiled"}
+
+    def benchmark(*_args: object, **_kwargs: object) -> dict[str, object]:
+        events.append("benchmark")
+        return {"wall_seconds_per_point": 1.0}
+
+    monkeypatch.setattr(gate.Runtime, "load", load)
+    monkeypatch.setattr(gate, "_on_the_fly_artifact_contract", lambda *_args: {})
+    monkeypatch.setattr(gate, "_points", lambda: ((((1.0,),),),))
+    monkeypatch.setattr(gate, "_recurrence_authority_correctness", correctness)
+    monkeypatch.setattr(gate, "_on_the_fly_public_profile", profile)
+    monkeypatch.setattr(gate, "_benchmark_runtime", benchmark)
+
+    result = gate._run_public_gate_phase(
+        artifact,
+        tmp_path / "recurrence-selected",
+        tmp_path / "recurrence-all",
+        0.1,
+        1,
+    )
+
+    assert result.correctness.public_correctness == {"public": "green"}
+    assert events == ["correctness", "profile", "profile"] + ["benchmark"] * 4
+
+
+@pytest.mark.parametrize(
+    ("defect", "message"),
+    (
+        ("process", "wrong canonical process identity"),
+        ("color", "not an LC recurrence authority"),
+        ("pdgs", "wrong external PDG ordering"),
+    ),
+)
+def test_public_gate_rejects_wrong_comparator_physics_before_correctness(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    defect: str,
+    message: str,
+) -> None:
+    flow = SimpleNamespace(id=gate.FLOW_ID, word=gate.FLOW_WORD, index=0)
+    helicity = SimpleNamespace(
+        id=gate.HELICITY_ID,
+        values=gate.HELICITY_VALUES,
+        structural_zero=False,
+    )
+    physics = _fixed_authority_physics(
+        flow,
+        helicity,
+        process="u u~ > t t~ g g" if defect == "process" else gate.PROCESS,
+        color_accuracy="full" if defect == "color" else "lc",
+    )
+    if defect == "pdgs":
+        physics.external_particles = tuple(
+            SimpleNamespace(pdg_id=pdg) for pdg in (2, -2, 6, -6, 21, 21)
+        )
+    candidate_path = tmp_path / "candidate"
+    authorities = {
+        tmp_path / "recurrence-selected": SimpleNamespace(
+            execution_mode="recurrence", physics=physics
+        ),
+        tmp_path / "recurrence-all": SimpleNamespace(
+            execution_mode="recurrence", physics=physics
+        ),
+    }
+
+    def load(path: Path, **_kwargs: object) -> object:
+        if Path(path) == candidate_path:
+            return SimpleNamespace(execution_mode="on-the-fly")
+        return authorities[Path(path)]
+
+    monkeypatch.setattr(gate.Runtime, "load", load)
+    monkeypatch.setattr(gate, "_on_the_fly_artifact_contract", lambda *_args: {})
+    monkeypatch.setattr(
+        gate,
+        "_recurrence_authority_correctness",
+        lambda *_args: (_ for _ in ()).throw(
+            AssertionError("correctness ran with an invalid authority")
+        ),
+    )
+
+    with pytest.raises(gate.GateError, match=message):
+        gate._run_public_gate_phase(
+            candidate_path,
+            tmp_path / "recurrence-selected",
+            tmp_path / "recurrence-all",
+            0.1,
+            1,
+        )
+
+
+def test_comparator_physics_accepts_mapping_external_particles() -> None:
+    flow = SimpleNamespace(id=gate.FLOW_ID, word=gate.FLOW_WORD, index=0)
+    helicity = SimpleNamespace(
+        id=gate.HELICITY_ID,
+        values=gate.HELICITY_VALUES,
+        structural_zero=False,
+    )
+    physics = _fixed_authority_physics(flow, helicity)
+    physics.external_particles = tuple({"pdg_id": pdg} for pdg in gate.EXTERNAL_PDGS)
+    runtime = SimpleNamespace(execution_mode="recurrence", physics=physics)
+
+    assert (
+        gate._validate_comparator_physics(runtime, "recurrence", "mapping") is physics
+    )
+
+
+@pytest.mark.parametrize(
+    "particle", ({"pdg_id": "1"}, {"pdg_id": True}, {"pdg": 1}, {})
+)
+def test_comparator_physics_rejects_malformed_mapping_pdg(
+    particle: dict[str, object],
+) -> None:
+    flow = SimpleNamespace(id=gate.FLOW_ID, word=gate.FLOW_WORD, index=0)
+    helicity = SimpleNamespace(
+        id=gate.HELICITY_ID,
+        values=gate.HELICITY_VALUES,
+        structural_zero=False,
+    )
+    physics = _fixed_authority_physics(flow, helicity)
+    physics.external_particles = (
+        particle,
+        *({"pdg_id": pdg} for pdg in gate.EXTERNAL_PDGS[1:]),
+    )
+    runtime = SimpleNamespace(execution_mode="recurrence", physics=physics)
+
+    with pytest.raises(
+        gate.GateError, match="external particle 0 has an invalid PDG ID"
+    ):
+        gate._validate_comparator_physics(runtime, "recurrence", "mapping")
+
+
+def test_public_correctness_only_report_skips_every_private_lane(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    candidate = tmp_path / "candidate"
+    candidate.mkdir()
+    forbidden = (
+        "_generate_candidate_with_prepared_model",
+        "_generate_probe_carrier",
+        "_probe",
+        "_family_probe",
+        "_hidden_timing",
+        "_hidden_family_timing",
+        "_hidden_family_correctness",
+        "_query_family_census",
+    )
+
+    def reject(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("provisional public-only mode entered a private lane")
+
+    for symbol in forbidden:
+        monkeypatch.setattr(gate, symbol, reject)
+    monkeypatch.setattr(
+        gate, "_run_public_gate_phase", lambda *_args: _fake_public_phase()
+    )
+    monkeypatch.setattr(gate, "point_digest", lambda *_args: "point-digest")
+
+    result = gate._run_public_correctness_only(
+        tmp_path,
+        None,
+        candidate,
+        tmp_path / "recurrence-selected",
+        tmp_path / "recurrence-all",
+        0.1,
+        1,
+    )
+
+    assert result["status"] == "passed"
+    assert result["correctness_authority_contract"] == "recurrence-only-v1"
+    assert result["scope"] == "provisional-public-correctness-only"
+    assert result["provisional"] is True
+    assert result["public_only"] is True
+    assert result["full_gate_status"] == "not-run"
+    assert result["source_bound"] is False
+    assert result["source_binding"] == "not-asserted"
+    assert result["candidate_source"] == "reused-existing-artifact"
+    assert result["private_probe_carrier"]["status"] == "skipped"
+    assert result["private_census"]["status"] == "unavailable"
+    assert result["private_timing"]["status"] == "unavailable"
+    assert set(result["public_timings"]) == {
+        "selected_flow_helicity_sum",
+        "all_flow_single_helicity",
+    }
+    assert all(
+        set(workload) == {"on_the_fly", "recurrence"}
+        for workload in result["public_timings"].values()
+    )
+    outer = gate._driver_report(result, {"passes": True})
+    assert outer["source_bound"] is False
+    assert outer["source_binding"] == "not-asserted"
+    assert outer["provisional"] is True
+
+
+def test_real_candidate_contract_and_profile_never_open_dense_physics(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    artifact_id = _write_on_the_fly_contract_artifact(artifact)
+
+    class Backend:
+        def profile(self, _points: object, **kwargs: object) -> dict[str, object]:
+            assert kwargs == {
+                "helicities": None,
+                "color_flows": (gate.FLOW_ID,),
+                "precision": 16,
+                "include_values": True,
+            }
+            return {
+                "execution_mode": "on-the-fly",
+                "values": [1.0, 2.0],
+                "wall_time_s": 0.01,
+                **{
+                    name: 2 if name.endswith("row_count") else 1
+                    for name in gate.PUBLIC_PROFILE_WORK_FIELDS
+                },
+            }
+
+    class Candidate:
+        execution_mode = "on-the-fly"
+        representative_process_key = gate.PROCESS_ID
+        _backend = Backend()
+
+        @property
+        def physics(self) -> object:
+            raise AssertionError("candidate dense physics was opened")
+
+    candidate = Candidate()
+    candidate.artifact_id = artifact_id
+    contract = gate._on_the_fly_artifact_contract(artifact, candidate)
+    assert contract["execution_mode"] == "on-the-fly"
+    assert contract["dense_physics_accessed"] is False
+    assert contract["required_runtime_capabilities"] == gate.ON_THE_FLY_CAPABILITIES
+    assert contract["selector_census"] == {
+        "physical_helicity_count": 64,
+        "physical_color_flow_count": 12,
+    }
+    assert contract["process_evaluator_state_payload_count"] == 1
+    assert contract["runtime_container_authenticated"] is True
+    assert contract["runtime_container_member_count"] == 1
+    assert contract["seed_member_kind"] == "ON_THE_FLY_PROCESS_SEED"
+    profile = gate._on_the_fly_public_profile(
+        candidate,
+        (((1.0,),), ((2.0,),)),
+        (1.0, 2.0),
+        flows=(gate.FLOW_ID,),
+    )
+    assert profile["value_check"]["checks"] == 2
+    assert profile["work"]["recurrence_source_call_count"] == 1
+    assert profile["work"]["recurrence_source_row_count"] == 2
+
+    with pytest.raises(gate.GateError, match="disagrees"):
+        gate._on_the_fly_public_profile(
+            candidate,
+            (((1.0,),), ((2.0,),)),
+            (1.0, 3.0),
+            flows=(gate.FLOW_ID,),
+        )
+
+
+@pytest.mark.parametrize(
+    "sidecar",
+    (
+        "dag.json",
+        "color-plan.json",
+        "eager-runtime.pacbin",
+        "direct-plan.bin",
+        "recurrence-runtime.pacbin",
+        "compiled.so",
+        "structural-source-proof.json",
+    ),
+)
+def test_on_the_fly_contract_rejects_materialized_process_sidecars(
+    tmp_path: Path,
+    sidecar: str,
+) -> None:
+    artifact = tmp_path / sidecar.replace(".", "-")
+    artifact_id = _write_on_the_fly_contract_artifact(
+        artifact,
+        extra_sidecar=sidecar,
+    )
+    runtime = SimpleNamespace(
+        execution_mode="on-the-fly",
+        representative_process_key=gate.PROCESS_ID,
+        artifact_id=artifact_id,
+    )
+    with pytest.raises(gate.GateError, match="materialized sidecars"):
+        gate._on_the_fly_artifact_contract(artifact, runtime)
+
+
+def test_on_the_fly_contract_rejects_extra_pacbin_member(tmp_path: Path) -> None:
+    artifact = tmp_path / "extra-member"
+    artifact_id = _write_on_the_fly_contract_artifact(
+        artifact,
+        extra_seed_member=True,
+    )
+    runtime = SimpleNamespace(
+        execution_mode="on-the-fly",
+        representative_process_key=gate.PROCESS_ID,
+        artifact_id=artifact_id,
+    )
+    with pytest.raises(gate.GateError, match="exactly one process seed"):
+        gate._on_the_fly_artifact_contract(artifact, runtime)
+
+
+@pytest.mark.parametrize(
+    "field",
+    (
+        "dag",
+        "color_plan",
+        "eager_plan",
+        "direct_plan",
+        "recurrence_runtime",
+        "compiled_execution",
+        "structural_proof",
+    ),
+)
+def test_on_the_fly_contract_rejects_materialization_fields(
+    tmp_path: Path,
+    field: str,
+) -> None:
+    artifact = tmp_path / field
+    artifact_id = _write_on_the_fly_contract_artifact(
+        artifact,
+        execution_field=field,
+    )
+    runtime = SimpleNamespace(
+        execution_mode="on-the-fly",
+        representative_process_key=gate.PROCESS_ID,
+        artifact_id=artifact_id,
+    )
+    with pytest.raises(gate.GateError, match="forbidden materialization field"):
+        gate._on_the_fly_artifact_contract(artifact, runtime)
+
+
+def test_amplicol_anchor_requires_exact_cell_and_point_digest(tmp_path: Path) -> None:
+    def write(name: str, cell_id: str) -> Path:
+        path = tmp_path / name
+        path.write_text(
+            json.dumps(
+                {
+                    "status": "ok",
+                    "matrix_element": 3.0,
+                    "execution_seconds_per_point": 4.0e-6,
+                    "wall_seconds_per_point": 5.0e-6,
+                    "selector_contract": {
+                        "selected_color_flow_ids": [gate.FLOW_ID],
+                        "selected_color_words": [list(gate.FLOW_WORD)],
+                    },
+                    "validation": {
+                        "lc_common_component": {
+                            "cell_id": cell_id,
+                            "point_digest": "same-point",
+                            "helicity_ids": [gate.HELICITY_ID],
+                            "color_flow_ids": [gate.FLOW_ID],
+                            "value": 2.0,
+                        }
+                    },
+                }
+            ),
+            encoding="utf-8",
+        )
+        return path
+
+    wrong_cell = gate._anchor(write("wrong-cell.json", "another-cell"))
+    contextual = gate._anchor_checks(
+        wrong_cell,
+        "same-point",
+        public_component=99.0,
+        hidden_component=98.0,
+        public_sum=97.0,
+        hidden_sum=96.0,
+    )
+    assert contextual["comparison_performed"] is False
+    assert "cell identity differs" in str(contextual["reason"])
+
+    exact = gate._anchor(write("exact.json", gate.AMPICOL_CELL_ID))
+    different_point = gate._anchor_checks(
+        exact,
+        "different-point",
+        public_component=99.0,
+        hidden_component=98.0,
+        public_sum=97.0,
+        hidden_sum=96.0,
+    )
+    assert different_point["comparison_performed"] is False
+    assert "point digest differs" in str(different_point["reason"])
+
+    compared = gate._anchor_checks(
+        exact,
+        "same-point",
+        public_component=2.0,
+        hidden_component=2.0,
+        public_sum=3.0,
+        hidden_sum=3.0,
+    )
+    assert compared["comparison_performed"] is True
+    assert compared["execution_seconds_per_point"] == 4.0e-6
+    assert compared["wall_seconds_per_point"] == 5.0e-6
+    assert "independent clocks" in compared["clock_attribution"]["relationship"]
+
+
+def test_hidden_timing_contract_counts_lookup_fill_execute_and_no_poison() -> None:
+    def report(repetitions: int) -> dict[str, object]:
+        benchmark = repetitions > 0
+        cycles = gate.WARMUPS + repetitions if benchmark else 1
+        elapsed = 0.25 if benchmark else None
+        return {
+            "process_id": gate.PROCESS_ID,
+            "point_count": 2,
+            "work_census_basis": gate.WORK_CENSUS_BASIS,
+            "logical_current_count": 5,
+            "resident_current_count": 5,
+            "resident_current_component_count": 8,
+            "source_operation_count": 2,
+            "contribution_operation_count": 3,
+            "finalization_operation_count": 1,
+            "closure_operation_count": 1,
+            "total_kernel_application_count": 7,
+            "semantic_executor_binding_count": 4,
+            "distinct_prepared_executor_count": 3,
+            "trace_build_count": 1,
+            "trace_cache_hit_count": cycles if benchmark else 0,
+            "momentum_fill_count": cycles,
+            "currents": [],
+            "direct_plan_load_attempts": 0,
+            "direct_plan_decode_attempts": 0,
+            "direct_plan_materialization_attempts": 0,
+            "established_builder_attempts": 0,
+            "normalized_values": [1.0, 2.0],
+            "benchmark_elapsed_seconds": elapsed,
+            "benchmark_seconds_per_point": (
+                None if elapsed is None else elapsed / (repetitions * 2)
+            ),
+        }
+
+    assert gate._probe_values(report(0), 2) == (1.0, 2.0)
+    assert gate._probe_values(report(5), 2, 5) == (1.0, 2.0)
+    assert gate._work_census(report(5)) == {
+        "work_census_basis": gate.WORK_CENSUS_BASIS,
+        "logical_current_count": 5,
+        "resident_current_count": 5,
+        "resident_current_component_count": 8,
+        "source_operation_count": 2,
+        "contribution_operation_count": 3,
+        "finalization_operation_count": 1,
+        "closure_operation_count": 1,
+        "total_kernel_application_count": 7,
+        "semantic_executor_binding_count": 4,
+        "distinct_prepared_executor_count": 3,
+    }
+    assert gate._calibrate(0.25, 1.0) == 4
+
+    poisoned = report(0)
+    poisoned["direct_plan_load_attempts"] = 1
+    with pytest.raises(gate.GateError, match="poison"):
+        gate._probe_values(poisoned, 2)
+    wrong_fill = report(5)
+    wrong_fill["momentum_fill_count"] = 6
+    with pytest.raises(gate.GateError, match="contract"):
+        gate._probe_values(wrong_fill, 2, 5)
+    inconsistent_work = report(0)
+    inconsistent_work["total_kernel_application_count"] = 8
+    with pytest.raises(gate.GateError, match="kernel and operation"):
+        gate._probe_values(inconsistent_work, 2)
+
+
+def test_workload_census_sums_operations_and_keeps_recurrence_calls_distinct(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    first = {
+        "work_census_basis": gate.WORK_CENSUS_BASIS,
+        "source_operation_count": 2,
+        "contribution_operation_count": 3,
+        "finalization_operation_count": 1,
+        "closure_operation_count": 1,
+        "total_kernel_application_count": 7,
+    }
+    second = {
+        "work_census_basis": gate.WORK_CENSUS_BASIS,
+        "source_operation_count": 2,
+        "contribution_operation_count": 5,
+        "finalization_operation_count": 2,
+        "closure_operation_count": 1,
+        "total_kernel_application_count": 10,
+    }
+    assert gate._workload_operation_census(
+        ({"work_census": first}, {"work_census": second})
+    ) == {
+        "aggregation_basis": "sum-one-execution-per-serialized-query-v1",
+        "query_census_basis": gate.WORK_CENSUS_BASIS,
+        "query_count": 2,
+        "source_operation_count": 4,
+        "contribution_operation_count": 8,
+        "finalization_operation_count": 3,
+        "closure_operation_count": 2,
+        "total_kernel_application_count": 17,
+    }
+
+    counters = SimpleNamespace(
+        normalization="mean_per_profiled_point_or_runtime_call_v1",
+        recurrence_source_calls_per_call=2.0,
+        recurrence_source_rows_per_call=4.0,
+        recurrence_contribution_calls_per_call=3.0,
+        recurrence_contribution_rows_per_call=8.0,
+        recurrence_finalization_calls_per_call=1.0,
+        recurrence_finalization_rows_per_call=3.0,
+        recurrence_closure_calls_per_call=1.0,
+        recurrence_closure_rows_per_call=2.0,
+    )
+    established = gate._public_recurrence_work(
+        SimpleNamespace(timing_breakdown=SimpleNamespace(counters=counters))
+    )
+    assert established is not None
+    assert established["source_calls_per_runtime_call"] == 2.0
+    assert established["source_rows_per_runtime_call"] == 4.0
+    assert "grouped prepared-backend invocations" in str(established["semantics"])
+    assert gate._public_recurrence_work(SimpleNamespace(timing_breakdown=None)) is None
+
+    monkeypatch.setattr(gate.dataclasses, "asdict", lambda _value: {})
+    public = gate._public_timing(
+        SimpleNamespace(
+            sample_count=3,
+            repetitions_per_sample=4,
+            wall_time_per_point=2.0,
+            evaluator_time_per_point=1.5,
+            evaluator_total_time_per_point=1.75,
+            interrupted=False,
+            effective_config=SimpleNamespace(),
+            uncertainty=SimpleNamespace(),
+            timing_breakdown=SimpleNamespace(
+                counters=counters, execution_mode="recurrence"
+            ),
+        ),
+        "recurrence",
+    )
+    assert public["execution_mode"] == "recurrence"
+    assert public["evaluator_seconds_per_point"] == 1.5
+    assert public["clock_attribution"]["evaluator_seconds_per_point"] == (
+        "recurrence core"
+    )
+    assert "clocks are independent" in public["clock_attribution"]["relationship"]
+    with pytest.raises(gate.GateError, match="matching timing breakdown"):
+        gate._public_timing(
+            SimpleNamespace(
+                timing_breakdown=SimpleNamespace(execution_mode="compiled")
+            ),
+            "on-the-fly",
+        )
+
+
+def test_query_family_census_matches_query_local_work_and_retains_destinations() -> (
+    None
+):
+    observed: dict[str, object] = {}
+
+    def probe(*args: object, **kwargs: object) -> dict[str, int]:
+        observed["args"] = args
+        observed["kwargs"] = kwargs
+        return {
+            "query_count": 2,
+            "source_frame_partition_count": 1,
+            "projection_applied_query_count": 2,
+            "projection_pre_current_count": 12,
+            "projection_pre_contribution_count": 10,
+            "projection_pre_closure_count": 2,
+            "projection_post_current_count": 10,
+            "projection_post_contribution_count": 8,
+            "projection_post_closure_count": 2,
+            "dynamic_current_occurrence_count": 10,
+            "dynamic_current_component_occurrence_count": 16,
+            "dynamic_source_rows": 4,
+            "dynamic_contribution_rows": 8,
+            "dynamic_finalization_rows": 3,
+            "dynamic_closure_rows": 2,
+            "dynamic_source_calls": 4,
+            "dynamic_contribution_calls": 8,
+            "dynamic_finalization_calls": 3,
+            "dynamic_closure_calls": 2,
+            "union_unique_current_count": 6,
+            "union_unique_current_component_count": 10,
+            "union_source_rows": 2,
+            "union_contribution_rows": 5,
+            "union_finalization_rows": 2,
+            "union_closure_rows": 2,
+            "union_amplitude_destination_count": 2,
+            "union_source_executor_call_groups": 2,
+            "union_contribution_executor_call_groups": 3,
+            "union_finalization_executor_call_groups": 1,
+            "union_closure_executor_call_groups": 1,
+        }
+
+    retained = gate.RetainedInputs("builder", "template", b"{}", "a" * 64)
+    queries = (
+        gate.Query("flow:0", 0, "h:0", (1, -1)),
+        gate.Query("flow:1", 1, "h:1", (-1, 1)),
+    )
+    hidden = {
+        "queries": [
+            {
+                "work_census": {
+                    "logical_current_count": 5,
+                    "resident_current_component_count": 8,
+                }
+            },
+            {
+                "work_census": {
+                    "logical_current_count": 5,
+                    "resident_current_component_count": 8,
+                }
+            },
+        ],
+        "workload_operation_census": {
+            "source_operation_count": 4,
+            "contribution_operation_count": 8,
+            "finalization_operation_count": 3,
+            "closure_operation_count": 2,
+        },
+    }
+    result = gate._query_family_census(probe, retained, queries, hidden, True)
+    assert result["basis"] == "exact-current-core-key-query-family-union-v1"
+    assert result["union_unique_current_count"] == 6
+    assert result["union_amplitude_destination_count"] == 2
+    assert observed["args"][4] == [0, 1]
+    assert observed["args"][5] == [[1, -1], [-1, 1]]
+    assert observed["kwargs"] == {"enable_color_projection": True}
+
+    def stale(*_args: object, **_kwargs: object) -> dict[str, int]:
+        value = probe(*_args, **_kwargs)
+        value["dynamic_contribution_rows"] = 7
+        return value
+
+    with pytest.raises(gate.GateError, match="independently timed"):
+        gate._query_family_census(stale, retained, queries, hidden, True)
+
+
+def test_executable_family_report_has_exact_union_work_and_ordered_outputs() -> None:
+    queries = (
+        gate.Query("flow:0", 0, "h:0", (1, -1)),
+        gate.Query("flow:1", 1, "h:1", (-1, 1)),
+    )
+    census = {
+        "query_count": 2,
+        "source_frame_partition_count": 1,
+        "projection_applied_query_count": 2,
+        "projection_pre_current_count": 12,
+        "projection_pre_contribution_count": 10,
+        "projection_pre_closure_count": 2,
+        "projection_post_current_count": 10,
+        "projection_post_contribution_count": 8,
+        "projection_post_closure_count": 2,
+        "dynamic_current_occurrence_count": 10,
+        "dynamic_current_component_occurrence_count": 16,
+        "dynamic_source_rows": 4,
+        "dynamic_contribution_rows": 8,
+        "dynamic_finalization_rows": 3,
+        "dynamic_closure_rows": 2,
+        "dynamic_source_calls": 4,
+        "dynamic_contribution_calls": 8,
+        "dynamic_finalization_calls": 3,
+        "dynamic_closure_calls": 2,
+        "union_unique_current_count": 6,
+        "union_unique_current_component_count": 10,
+        "union_source_rows": 2,
+        "union_contribution_rows": 5,
+        "union_finalization_rows": 2,
+        "union_closure_rows": 2,
+        "union_amplitude_destination_count": 2,
+        "union_source_executor_call_groups": 1,
+        "union_contribution_executor_call_groups": 3,
+        "union_finalization_executor_call_groups": 1,
+        "union_closure_executor_call_groups": 1,
+    }
+    rows = [
+        {
+            "selected_public_flow_id": query.flow_index,
+            "public_helicities": list(query.helicities),
+            "query_digest": str(index) * 64,
+            "raw_amplitudes": [[1.0 + index, 2.0], [3.0, 4.0 + index]],
+            "normalized_values": [5.0 + index, 6.0 + index],
+        }
+        for index, query in enumerate(queries, start=1)
+    ]
+    report = {
+        "process_id": gate.PROCESS_ID,
+        "point_count": 2,
+        "work_census_basis": gate.FAMILY_WORK_CENSUS_BASIS,
+        "source_operation_count": 2,
+        "contribution_operation_count": 5,
+        "finalization_operation_count": 2,
+        "closure_operation_count": 2,
+        "total_kernel_application_count": 11,
+        "trace_build_count": 2,
+        "trace_cache_hit_count": 0,
+        "momentum_fill_count": gate.WARMUPS + 3,
+        "currents": [],
+        "direct_plan_load_attempts": 0,
+        "direct_plan_decode_attempts": 0,
+        "direct_plan_materialization_attempts": 0,
+        "established_builder_attempts": 0,
+        "query_family": {
+            "queries": rows,
+            "census": census,
+            "execution_cache_hit": True,
+            "execution_source_calls": 1,
+            "execution_source_rows": 2,
+            "execution_contribution_calls": 3,
+            "execution_contribution_rows": 5,
+            "execution_finalization_calls": 1,
+            "execution_finalization_rows": 2,
+            "execution_closure_calls": 1,
+            "execution_closure_rows": 2,
+            "cold_prepare_seconds": 0.01,
+            "private_warmed_elapsed_seconds": 0.12,
+            "private_warmed_seconds_per_point": 0.02,
+            "private_timing_excludes_source_crossing": True,
+        },
+    }
+    parsed = gate._family_probe_result(report, queries, 2, 3)
+    assert parsed["union_total_kernel_application_count"] == 11
+    assert parsed["census"] == census
+    gate._assert_executable_family_matches_structural_census(census, census)
+
+    broken = dict(report)
+    broken["total_kernel_application_count"] = 16
+    with pytest.raises(gate.GateError, match="top-level execution census"):
+        gate._family_probe_result(broken, queries, 2, 3)
+
+
+def test_separate_recurrence_artifacts_route_exact_selector_certificates(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    selected = tmp_path / "recurrence-selected"
+    all_flow = tmp_path / "recurrence-all-flow"
+    whole = {
+        "source_row_count": 2,
+        "current_count": 7,
+        "semantic_component_count": 11,
+        "contribution_count": 5,
+        "finalization_count": 3,
+        "closure_count": 2,
+        "row_count": 12,
+    }
+
+    def recurrence(layout: str, representatives: list[object]) -> dict[str, object]:
+        return {
+            "kind": "pyamplicol-runtime-recurrence-execution",
+            "recurrence_summary": {
+                "current_count": 7,
+                "contribution_count": 5,
+                "closure_term_count": 2,
+            },
+            "runtime_metadata": {
+                "public_color_flows": [
+                    {"public_id": gate.FLOW_ID, "target_sector_id": 8}
+                ]
+            },
+            "plan": {
+                "inspection_summary": {
+                    "lc_flow_layout": layout,
+                    "schedule": {
+                        "source_row_count": 2,
+                        "current_count": 7,
+                        "contribution_count": 5,
+                        "finalization_count": 3,
+                        "closure_term_count": 2,
+                        "amplitude_destination_count": 1,
+                    },
+                    "direct_arena": {"semantic_component_count": 11},
+                    "selector_work_certificate": {
+                        "persisted_union": whole,
+                        "representatives": representatives,
+                    },
+                }
+            },
+        }
+
+    live = {
+        "representative_sector_id": 8,
+        "source_row_count": 1,
+        "current_count": 4,
+        "semantic_component_count": 6,
+        "contribution_count": 2,
+        "finalization_count": 1,
+        "closure_count": 1,
+        "amplitude_destination_count": 1,
+        "row_count": 5,
+    }
+    _write_execution(selected, recurrence("topology-replay", [live]))
+    _write_execution(all_flow, recurrence("all-flow-union", []))
+    flow = SimpleNamespace(id=gate.FLOW_ID, index=8)
+    helicity = SimpleNamespace(id=gate.HELICITY_ID, index=21)
+    runtimes = {
+        selected.resolve(): _runtime("recurrence", flows=(flow,)),
+        all_flow.resolve(): _runtime("recurrence", helicities=(helicity,)),
+    }
+    loads: list[Path] = []
+
+    def load(path: Path) -> SimpleNamespace:
+        loads.append(path)
+        return runtimes[path]
+
+    monkeypatch.setattr(gate.Runtime, "load", load)
+    selected_result = gate._recurrence_artifact_census(
+        selected, layout="topology-replay"
+    )
+    all_result = gate._recurrence_artifact_census(all_flow, layout="all-flow-union")
+
+    assert loads == [selected.resolve(), all_flow.resolve()]
+    assert selected_result["selector_live"]["current_count"] == 4
+    assert selected_result["selector_live"]["kernel_row_count"] == 5
+    assert selected_result["whole"]["current_count"] == 7
+    assert all_result["whole"] == all_result["selector_live"]
+    assert all_result["selector"]["public_index"] == 21
+
+    runtimes[selected.resolve()] = _runtime(
+        "recurrence", flows=(flow,), process="g g > g g g g"
+    )
+    with pytest.raises(gate.GateError, match="wrong canonical process identity"):
+        gate._recurrence_artifact_census(selected, layout="topology-replay")
+
+
+def test_compiled_census_selects_one_exact_child_without_summing_alternatives(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    selected = tmp_path / "compiled-selected"
+    all_flow = tmp_path / "compiled-all-flow"
+    primary = _compiled_record(
+        sources=8,
+        currents=69,
+        components=258,
+        attachments=124,
+        evaluations=112,
+        roots=12,
+    )
+    program = _compiled_record(
+        sources=12,
+        currents=256,
+        components=984,
+        attachments=700,
+        evaluations=650,
+        roots=192,
+    )
+    chosen_leaf = _compiled_record(
+        sources=12,
+        currents=78,
+        components=296,
+        attachments=150,
+        evaluations=150,
+        roots=32,
+    )
+    alternative = _compiled_record(
+        sources=99,
+        currents=999,
+        components=1999,
+        attachments=999,
+        evaluations=999,
+        roots=999,
+    )
+    program.update(
+        {
+            "physics_reduction": {"groups": [{"physical_color_ids": [gate.FLOW_ID]}]},
+            "color_selector_executions": [
+                {"materialized_sector_id": 8, "execution": chosen_leaf},
+                {"materialized_sector_id": 3, "execution": alternative},
+            ],
+        }
+    )
+    selected_payload = dict(primary)
+    selected_payload.update(
+        {
+            "compiled": {
+                "lc_topology_replay": {
+                    "groups": [
+                        {"active_sector_ids": [8, 11], "materialized_sector_id": 8},
+                        {"active_sector_ids": [3], "materialized_sector_id": 3},
+                    ]
+                }
+            },
+            "helicity_sum_execution": program,
+        }
+    )
+    _write_execution(selected, selected_payload)
+
+    all_primary = _compiled_record(
+        sources=8,
+        currents=115,
+        components=440,
+        attachments=233,
+        evaluations=189,
+        roots=24,
+    )
+    middle = dict(all_primary)
+    middle["helicity_selector_executions"] = [
+        {"selector_domain_ids": [21], "execution": dict(all_primary)},
+        {"selector_domain_ids": [5], "execution": alternative},
+    ]
+    all_payload = dict(all_primary)
+    all_payload["helicity_selector_executions"] = [
+        {"selector_domain_ids": [21, 22], "execution": middle},
+        {"selector_domain_ids": [4], "execution": alternative},
+    ]
+    _write_execution(all_flow, all_payload)
+
+    flow = SimpleNamespace(id=gate.FLOW_ID, index=8)
+    helicity = SimpleNamespace(id=gate.HELICITY_ID, index=21)
+    runtimes = {
+        selected.resolve(): _runtime("compiled", flows=(flow,)),
+        all_flow.resolve(): _runtime("compiled", helicities=(helicity,)),
+    }
+    loads: list[Path] = []
+
+    def load(path: Path) -> SimpleNamespace:
+        loads.append(path)
+        return runtimes[path]
+
+    monkeypatch.setattr(gate.Runtime, "load", load)
+    selected_result = gate._compiled_artifact_census(
+        selected, workload="selected_flow_helicity_sum"
+    )
+    all_result = gate._compiled_artifact_census(
+        all_flow, workload="all_flow_single_helicity"
+    )
+
+    assert loads == [selected.resolve(), all_flow.resolve()]
+    assert selected_result["levels"]["primary"]["current_count"] == 69
+    assert selected_result["levels"]["program"]["current_count"] == 256
+    assert selected_result["levels"]["executed_leaf"]["current_count"] == 78
+    assert selected_result["levels"]["executed_leaf"]["current_component_count"] == 296
+    assert all_result["levels"]["primary"]["current_count"] == 115
+    assert all_result["levels"]["executed_leaf"]["current_count"] == 115
+    assert all_result["selector"]["selector_depth"] == 2
+    assert "never summed" in selected_result["semantics"]
+    assert "999" not in json.dumps(selected_result)
+
+    program["color_selector_executions"].append(
+        {"materialized_sector_id": 8, "execution": alternative}
+    )
+    execution_path = selected / "processes" / gate.PROCESS_ID / "execution.json"
+    execution_path.write_text(json.dumps(selected_payload), encoding="utf-8")
+    with pytest.raises(gate.GateError, match="absent or ambiguous"):
+        gate._compiled_artifact_census(selected, workload="selected_flow_helicity_sum")
+
+    with pytest.raises(gate.GateError, match="absent or ambiguous"):
+        gate._exact_public_index((), gate.FLOW_ID, "test")
+    with pytest.raises(gate.GateError, match="absent or ambiguous"):
+        gate._exact_public_index((flow, flow), gate.FLOW_ID, "test")
+
+
+def test_hidden_timing_serializes_one_query_census_and_workload_sum() -> None:
+    def probe(*args: object, **kwargs: object) -> dict[str, object]:
+        point_count = int(args[9])
+        repetitions = int(kwargs["benchmark_repetitions"])
+        cycles = gate.WARMUPS + repetitions
+        elapsed = repetitions * point_count * 0.01
+        return {
+            "process_id": gate.PROCESS_ID,
+            "point_count": point_count,
+            "work_census_basis": gate.WORK_CENSUS_BASIS,
+            "logical_current_count": 5,
+            "resident_current_count": 5,
+            "resident_current_component_count": 8,
+            "source_operation_count": 2,
+            "contribution_operation_count": 3,
+            "finalization_operation_count": 1,
+            "closure_operation_count": 1,
+            "total_kernel_application_count": 7,
+            "semantic_executor_binding_count": 4,
+            "distinct_prepared_executor_count": 3,
+            "trace_build_count": 1,
+            "trace_cache_hit_count": cycles,
+            "momentum_fill_count": cycles,
+            "currents": [],
+            "direct_plan_load_attempts": 0,
+            "direct_plan_decode_attempts": 0,
+            "direct_plan_materialization_attempts": 0,
+            "established_builder_attempts": 0,
+            "normalized_values": [1.0] * point_count,
+            "benchmark_elapsed_seconds": elapsed,
+            "benchmark_seconds_per_point": 0.01,
+            "trace_digest": "a" * 64,
+        }
+
+    retained = gate.RetainedInputs(object(), object(), b"{}", "a" * 64)
+    query = gate.Query("flow", 0, "helicity", (1, -1))
+    result = gate._hidden_timing(
+        probe,
+        Path("artifact"),
+        retained,
+        (query,),
+        (((1.0,),), ((2.0,),)),
+        target=0.04,
+    )
+    row = result["queries"][0]
+    assert row["work_census"]["logical_current_count"] == 5
+    assert result["workload_operation_census"] == {
+        "aggregation_basis": "sum-one-execution-per-serialized-query-v1",
+        "query_census_basis": gate.WORK_CENSUS_BASIS,
+        "query_count": 1,
+        "source_operation_count": 2,
+        "contribution_operation_count": 3,
+        "finalization_operation_count": 1,
+        "closure_operation_count": 1,
+        "total_kernel_application_count": 7,
+    }
+
+
+def test_cli_launches_one_worker_with_cross_platform_30_gib_guard(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    prepared_model = tmp_path / "built-in-sm.pyamplicol-model"
+    prepared_model.write_bytes(b"prepared")
+    arguments = gate._parser().parse_args(
+        [
+            "--output",
+            "out",
+            "--prepared-model",
+            str(prepared_model),
+            "--amplicol-result",
+            "legacy.json",
+            "--recurrence-selected-artifact",
+            "recurrence-selected",
+            "--recurrence-all-flow-artifact",
+            "recurrence-all-flow",
+            "--target-runtime",
+            "2",
+            "--batch-size",
+            "64",
+        ]
+    )
+    assert "--worker" not in gate._parser().format_help()
+    assert "--compiled-selected-artifact" not in gate._parser().format_help()
+    assert "--compiled-all-flow-artifact" not in gate._parser().format_help()
+    command = gate._worker_command(arguments, Path("/tmp/gate"))
+    assert command.count("--worker") == 1
+    assert "all-flow-union" not in command
+    assert command[command.index("--prepared-model") + 1] == str(
+        prepared_model.resolve()
+    )
+    assert command[command.index("--amplicol-result") + 1] == str(
+        Path("legacy.json").resolve()
+    )
+    for option, name in (
+        ("--recurrence-selected-artifact", "recurrence-selected"),
+        ("--recurrence-all-flow-artifact", "recurrence-all-flow"),
+    ):
+        assert command[command.index(option) + 1] == str(Path(name).resolve())
+    assert arguments.bypass_color_projection is False
+    assert "--bypass-color-projection" not in command
+    bypass = arguments
+    bypass.bypass_color_projection = True
+    assert "--bypass-color-projection" in gate._worker_command(
+        bypass, Path("/tmp/gate")
+    )
+    assert gate.WATCHDOG_BYTES == 30 * gate.GIB
+
+    summary = gate._watchdog_summary(
+        {
+            "passes": True,
+            "execution": {"outcome": "command-finished", "reason": None},
+            "enforcement": {
+                "limit_bytes": gate.WATCHDOG_BYTES,
+                "peak_rss_bytes": 10,
+                "peak_physical_footprint_bytes": 11,
+                "peak_guard_bytes": 11,
+                "peak_processes": 2,
+            },
+        }
+    )
+    assert summary["passes"] is True
+    assert summary["peak_guard_bytes"] == 11
+
+    def probe(_pids: object) -> dict[int, int]:
+        return {}
+
+    monkeypatch.setattr(gate.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(gate, "DarwinPhysicalFootprintProbe", lambda: probe)
+    assert gate._physical_footprint_probe() is probe
+    monkeypatch.setattr(gate.platform, "system", lambda: "Linux")
+    assert gate._physical_footprint_probe() is None
+
+
+def test_public_correctness_only_cli_reuses_candidate_in_same_guarded_worker(
+    tmp_path: Path,
+) -> None:
+    candidate = tmp_path / "candidate"
+    candidate.mkdir()
+    arguments = gate._parser().parse_args(
+        [
+            "--output",
+            "out",
+            "--candidate-artifact",
+            str(candidate),
+            "--public-correctness-only",
+            "--recurrence-selected-artifact",
+            "recurrence-selected",
+            "--recurrence-all-flow-artifact",
+            "recurrence-all-flow",
+        ]
+    )
+
+    command = gate._worker_command(arguments, tmp_path / "guarded-output")
+    assert command.count("--worker") == 1
+    assert command.count("--public-correctness-only") == 1
+    assert command[command.index("--candidate-artifact") + 1] == str(
+        candidate.resolve()
+    )
+    assert "--prepared-model" not in command
+    assert gate.WATCHDOG_BYTES == 30 * gate.GIB
+
+    arguments.public_correctness_only = False
+    with pytest.raises(gate.GateError, match="full gate requires"):
+        gate._worker_command(arguments, tmp_path / "rejected")
+
+
+def test_default_worker_dispatches_full_lane(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    output = tmp_path / "output"
+    output.mkdir()
+    prepared = tmp_path / "model.pyamplicol-model"
+    prepared.write_bytes(b"prepared")
+    arguments = gate._parser().parse_args(
+        [
+            "--worker",
+            "--output",
+            str(output),
+            "--prepared-model",
+            str(prepared),
+            "--recurrence-selected-artifact",
+            "recurrence-selected",
+            "--recurrence-all-flow-artifact",
+            "recurrence-all-flow",
+        ]
+    )
+    events: list[str] = []
+
+    def full(*_args: object, **_kwargs: object) -> dict[str, object]:
+        events.append("full-private-lane")
+        return {"kind": "pyamplicol-on-the-fly-lc-gate", "status": "passed"}
+
+    monkeypatch.setattr(gate, "_run", full)
+    monkeypatch.setattr(
+        gate,
+        "_run_public_correctness_only",
+        lambda *_args: (_ for _ in ()).throw(
+            AssertionError("default worker dispatched provisional lane")
+        ),
+    )
+
+    assert gate._worker_main(arguments) == 0
+    assert events == ["full-private-lane"]
+    assert json.loads((output / "worker.json").read_text())["status"] == "passed"
+
+
+def test_public_only_worker_mismatch_cannot_report_success(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    output = tmp_path / "output"
+    output.mkdir()
+    candidate = tmp_path / "candidate"
+    candidate.mkdir()
+    arguments = gate._parser().parse_args(
+        [
+            "--worker",
+            "--output",
+            str(output),
+            "--candidate-artifact",
+            str(candidate),
+            "--public-correctness-only",
+            "--recurrence-selected-artifact",
+            "recurrence-selected",
+            "--recurrence-all-flow-artifact",
+            "recurrence-all-flow",
+        ]
+    )
+
+    monkeypatch.setattr(
+        gate,
+        "_run_public_gate_phase",
+        lambda *_args: (_ for _ in ()).throw(gate.GateError("public disagrees")),
+    )
+    monkeypatch.setattr(
+        gate,
+        "_on_the_fly_public_profile",
+        lambda *_args: (_ for _ in ()).throw(
+            AssertionError("profile ran after public mismatch")
+        ),
+    )
+    monkeypatch.setattr(
+        gate,
+        "_benchmark_runtime",
+        lambda *_args: (_ for _ in ()).throw(
+            AssertionError("benchmark ran after public mismatch")
+        ),
+    )
+
+    assert gate._worker_main(arguments) == 1
+    worker = json.loads((output / "worker.json").read_text())
+    assert worker["status"] == "failed"
+    assert worker["scope"] == "provisional-public-correctness-only"
+    assert "disagrees" in worker["error"]
+
+
+def test_prepared_model_load_precedes_candidate_generation_without_carrier(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "built-in-sm.pyamplicol-model"
+    path.write_bytes(b"prepared")
+    events: list[object] = []
+    compiled = object()
+
+    class Source:
+        def compile(self) -> object:
+            events.append("load")
+            return compiled
+
+    def from_path(candidate: Path) -> Source:
+        events.append(("path", candidate))
+        return Source()
+
+    def generate_candidate(
+        artifact: Path, model: object
+    ) -> tuple[float, dict[str, int]]:
+        events.append(("generate-candidate", artifact, model))
+        return 2.5, {
+            "expanded_process_count": 1,
+            "on_the_fly_seed_batch_binding_call_count": 1,
+            "on_the_fly_seed_build_count": 1,
+            "recurrence_lowering_call_count": 0,
+            "materialized_process_lane_count": 0,
+        }
+
+    monkeypatch.setattr(gate.ModelSource, "from_path", from_path)
+    monkeypatch.setattr(gate, "_generate_on_the_fly", generate_candidate)
+    monkeypatch.setattr(
+        gate,
+        "_generate_probe_carrier",
+        lambda *_args: (_ for _ in ()).throw(
+            AssertionError("candidate generation created a private carrier")
+        ),
+    )
+
+    result = gate._generate_candidate_with_prepared_model(tmp_path / "artifact", path)
+
+    assert events == [
+        ("path", path.resolve()),
+        "load",
+        ("generate-candidate", tmp_path / "artifact", compiled),
+    ]
+    assert result[0] == 2.5
+    assert result[1]["on_the_fly_seed_batch_binding_call_count"] == 1
+    assert result[1]["on_the_fly_seed_build_count"] == 1
+    assert result[2:4] == (compiled, path.resolve())
+    assert result[4] >= 0.0
+
+
+def test_candidate_generation_uses_seed_binding_and_never_recurrence_lowering(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    seen_modes: list[str] = []
+    seed_inputs: list[tuple[object, ...]] = []
+
+    def seed_builder(*args: object, **_kwargs: object) -> tuple[bytes, ...]:
+        seed_inputs.append(args)
+        return (b"seed",)
+
+    class Generator:
+        def __init__(self, config: object) -> None:
+            seen_modes.append(config.evaluator.execution_mode)
+
+        def generate(self, *_args: object, **_kwargs: object) -> None:
+            gate.generation_service._invoke_rust_on_the_fly_seed_batch_builder_v1(
+                (b'{"schema_version":1}',),
+                b"templates",
+                b"direct",
+                "a" * 64,
+            )
+
+    monkeypatch.setattr(
+        gate.generation_service,
+        "_invoke_rust_on_the_fly_seed_batch_builder_v1",
+        seed_builder,
+    )
+    monkeypatch.setattr(gate, "Generator", Generator)
+    elapsed, census = gate._generate_on_the_fly(tmp_path / "artifact", object())
+    assert elapsed >= 0.0
+    assert seen_modes == ["on-the-fly"]
+    assert len(seed_inputs) == 1
+    assert census == {
+        "expanded_process_count": 1,
+        "on_the_fly_seed_batch_binding_call_count": 1,
+        "on_the_fly_seed_build_count": 1,
+        "recurrence_lowering_call_count": 0,
+        "materialized_process_lane_count": 0,
+    }
+
+
+@pytest.mark.parametrize("symbol", gate.MATERIALIZED_PROCESS_LANE_SYMBOLS)
+def test_candidate_generation_fails_fast_for_every_materialized_lane_symbol(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    symbol: str,
+) -> None:
+    seen_modes: list[str] = []
+
+    class Generator:
+        def __init__(self, config: object) -> None:
+            seen_modes.append(config.evaluator.execution_mode)
+
+        def generate(self, *_args: object, **_kwargs: object) -> None:
+            if symbol == "GenerationBackend._prepare_process_construction":
+                gate.generation_service.GenerationBackend._prepare_process_construction(
+                    object()
+                )
+            else:
+                getattr(gate.generation_service, symbol)()
+            raise AssertionError("materialized lane poison returned to Generator")
+
+    monkeypatch.setattr(gate, "Generator", Generator)
+    with pytest.raises(gate.GateError, match="materialized process lane"):
+        gate._generate_on_the_fly(tmp_path / symbol.replace(".", "-"), object())
+    assert seen_modes == ["on-the-fly"]
+
+
+def test_candidate_generation_rejects_materialized_source_projection_field(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    native_binding_called = False
+
+    def seed_builder(*_args: object, **_kwargs: object) -> tuple[bytes, ...]:
+        nonlocal native_binding_called
+        native_binding_called = True
+        return (b"seed",)
+
+    class Generator:
+        def __init__(self, _config: object) -> None:
+            pass
+
+        def generate(self, *_args: object, **_kwargs: object) -> None:
+            gate.generation_service._invoke_rust_on_the_fly_seed_batch_builder_v1(
+                (b'{"schema_version":1,"dag":{}}',),
+                b"templates",
+                b"direct",
+                "a" * 64,
+            )
+
+    monkeypatch.setattr(
+        gate.generation_service,
+        "_invoke_rust_on_the_fly_seed_batch_builder_v1",
+        seed_builder,
+    )
+    monkeypatch.setattr(gate, "Generator", Generator)
+    with pytest.raises(gate.GateError, match="forbidden materialization field"):
+        gate._generate_on_the_fly(tmp_path / "source-projection", object())
+    assert native_binding_called is False
+
+
+def test_public_candidate_mismatch_fails_before_any_timing_or_private_probe(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    output = tmp_path / "output"
+    output.mkdir()
+    selected = tmp_path / "selected"
+    all_flow = tmp_path / "all-flow"
+    flow = SimpleNamespace(id=gate.FLOW_ID, word=gate.FLOW_WORD, index=0)
+    helicity = SimpleNamespace(
+        id=gate.HELICITY_ID,
+        values=gate.HELICITY_VALUES,
+        index=0,
+        structural_zero=False,
+    )
+    physics = _fixed_authority_physics(flow, helicity)
+
+    class Resolved:
+        helicity_ids = (gate.HELICITY_ID,)
+        color_ids = (gate.FLOW_ID,)
+        values = (((1.0,),),)
+
+        @staticmethod
+        def total() -> tuple[float, ...]:
+            return (1.0,)
+
+    class Authority:
+        artifact_id = "b" * 64
+
+        def __init__(self, execution_mode: str) -> None:
+            self.execution_mode = execution_mode
+
+        @staticmethod
+        def evaluate_resolved(*_args: object, **_kwargs: object) -> Resolved:
+            return Resolved()
+
+        @staticmethod
+        def evaluate(*_args: object, **_kwargs: object) -> tuple[float, ...]:
+            return (1.0,)
+
+    class Candidate:
+        execution_mode = "on-the-fly"
+        artifact_id = "a" * 64
+        representative_process_key = gate.PROCESS_ID
+
+        @property
+        def physics(self) -> object:
+            raise AssertionError("candidate dense physics was opened")
+
+        @staticmethod
+        def evaluate(*_args: object, **_kwargs: object) -> tuple[float, ...]:
+            return (2.0,)
+
+        @staticmethod
+        def evaluate_resolved(*_args: object, **_kwargs: object) -> Resolved:
+            return Resolved()
+
+    candidate = Candidate()
+    recurrence_authority = Authority("recurrence")
+    recurrence_authority.physics = physics
+    monkeypatch.setattr(
+        gate,
+        "_generate_candidate_with_prepared_model",
+        lambda *_args: (
+            0.1,
+            {
+                "expanded_process_count": 1,
+                "on_the_fly_seed_batch_binding_call_count": 1,
+                "on_the_fly_seed_build_count": 1,
+                "recurrence_lowering_call_count": 0,
+                "materialized_process_lane_count": 0,
+            },
+            object(),
+            tmp_path / "model.pyamplicol-model",
+            0.01,
+        ),
+    )
+    monkeypatch.setattr(gate, "_on_the_fly_artifact_contract", lambda *_args: {})
+    monkeypatch.setattr(gate, "_points", lambda: ((((1.0,),),)))
+
+    def load(path: Path, **_kwargs: object) -> object:
+        path = Path(path)
+        if path == output / "artifact":
+            return candidate
+        if path in (selected, all_flow):
+            return recurrence_authority
+        raise AssertionError(f"unexpected load before mismatch: {path}")
+
+    monkeypatch.setattr(gate.Runtime, "load", load)
+
+    def forbidden_timing(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("timing ran before recurrence-authority correctness")
+
+    for symbol in (
+        "_on_the_fly_public_profile",
+        "_hidden_timing",
+        "_hidden_family_timing",
+        "_benchmark_runtime",
+    ):
+        monkeypatch.setattr(gate, symbol, forbidden_timing)
+    monkeypatch.setattr(
+        gate,
+        "_generate_probe_carrier",
+        lambda *_args: (_ for _ in ()).throw(
+            AssertionError("private carrier ran before public authority check")
+        ),
+    )
+    with pytest.raises(gate.GateError, match="disagrees"):
+        gate._run(
+            output,
+            tmp_path / "model.pyamplicol-model",
+            None,
+            selected,
+            all_flow,
+            0.1,
+            1,
+        )
+
+
+def test_prepared_model_path_rejects_missing_non_file_and_wrong_suffix(
+    tmp_path: Path,
+) -> None:
+    with pytest.raises(gate.GateError, match="does not exist"):
+        gate._prepared_model_path(tmp_path / "missing.pyamplicol-model")
+
+    directory = tmp_path / "directory.pyamplicol-model"
+    directory.mkdir()
+    with pytest.raises(gate.GateError, match="not a regular file"):
+        gate._prepared_model_path(directory)
+
+    wrong_suffix = tmp_path / "prepared.bin"
+    wrong_suffix.write_bytes(b"prepared")
+    with pytest.raises(gate.GateError, match="must end"):
+        gate._prepared_model_path(wrong_suffix)
diff --git a/pyamplicol/tests/unit/test_on_the_fly_performance_campaign.py b/pyamplicol/tests/unit/test_on_the_fly_performance_campaign.py
new file mode 100644
index 0000000000..9f6b820b64
--- /dev/null
+++ b/pyamplicol/tests/unit/test_on_the_fly_performance_campaign.py
@@ -0,0 +1,645 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.config import BenchmarkConfig
+from tools.performance_report.agreements import (
+    LC_CROSS_LAYOUT_COMPONENT,
+    incoming_agreement_edges,
+)
+from tools.performance_report.artifacts import ArtifactStore
+from tools.performance_report.cache import build_reset_caches
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.manual_campaign import reproduction_recipe
+from tools.performance_report.models import Accuracy, ExecutionMode, Workload
+from tools.performance_report.render import _BEST_MODE_CODES, render_all_matrix_tables
+from tools.performance_report.runner import (
+    CONVENTIONAL_WARMUP_TIMING_SCOPE,
+    LOADED_RUNTIME_PROFILE_COMMAND_PATH,
+    OTF_ACTIVE_FAMILY_COUNT_FIELDS,
+    OTF_COLD_WARMUP_RUNTIME_FRESHNESS,
+    OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE,
+    OTF_COLD_WARMUP_TIMING_SCOPE,
+    OTF_RUNTIME_STATE_CENSUS_KIND,
+    OTF_RUNTIME_STATE_COUNT_FIELDS,
+    OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT,
+    OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY,
+    OTF_RUNTIME_STATE_RETAINED_BASE_POSITIVE_FIELDS,
+    OTF_RUNTIME_STATE_RETAINED_EXECUTABLE_FIELDS,
+    PUBLIC_CLI_COMMAND_PATH,
+    WARMUP_TIMER_SOURCE,
+    RunnerError,
+    RunnerSettings,
+    SelectorContract,
+    _benchmark_measurement,
+    config_values,
+    point_digest,
+    profile_runtime,
+    validate_artifact_contract,
+    validate_runtime_contract,
+)
+from tools.performance_report.scheduler import CampaignSettings, plan_campaign
+
+
+def _otf_warmup_runtime_state(*, retained: bool) -> dict[str, object]:
+    counts = {field: 0 for field in OTF_RUNTIME_STATE_COUNT_FIELDS}
+    active: dict[str, object] | None = None
+    if retained:
+        counts.update(
+            {
+                field: 1
+                for field in (
+                    *OTF_RUNTIME_STATE_RETAINED_BASE_POSITIVE_FIELDS,
+                    *OTF_RUNTIME_STATE_RETAINED_EXECUTABLE_FIELDS,
+                )
+            }
+        )
+        active = {
+            "basis": "shared-query-family-union-v1",
+            "scope": "active-family-union",
+            **{field: 1 for field in OTF_ACTIVE_FAMILY_COUNT_FIELDS},
+        }
+    return {
+        "kind": OTF_RUNTIME_STATE_CENSUS_KIND,
+        "process_id": "otf_campaign_process",
+        "family_cache_policy": OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY,
+        "family_cache_limit": OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT,
+        **counts,
+        "active_family_union_census": active,
+    }
+
+
+def _otf_cells():
+    return tuple(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+    )
+
+
+def test_otf_matrix_surface_is_measurable_for_every_color_accuracy() -> None:
+    cells = _otf_cells()
+    by_accuracy = Counter(cell.measurement.accuracy for cell in cells)
+    lc = tuple(cell for cell in cells if cell.measurement.accuracy is Accuracy.LC)
+
+    assert by_accuracy == {
+        Accuracy.LC: 66,
+        Accuracy.NLC: 50,
+        Accuracy.FULL: 100,
+    }
+    assert len({(cell.process_key, cell.n_final) for cell in lc}) == 33
+    assert {cell.n_final for cell in lc} == {1, 2, 3, 4}
+    assert all(REPORT_CATALOG.static_na_reason(cell) is None for cell in cells)
+    assert _BEST_MODE_CODES[ExecutionMode.ON_THE_FLY] == "o"
+
+
+def test_otf_uses_amplicol_for_display_and_recurrence_for_correctness() -> None:
+    all_flow = next(
+        cell
+        for cell in _otf_cells()
+        if cell.measurement.accuracy is Accuracy.LC
+        and cell.process_key == "dd_tt_jets"
+        and cell.n_final == 4
+        and cell.workload is Workload.ALL_FLOW
+    )
+    display = REPORT_CATALOG.baseline_cell(all_flow)
+    validation = REPORT_CATALOG.validation_baseline_cell(all_flow)
+    edges = incoming_agreement_edges(all_flow)
+
+    assert display is not None
+    assert display.measurement.execution_mode is ExecutionMode.AMPLICOL
+    assert validation is not None
+    assert validation.measurement.execution_mode is ExecutionMode.RECURRENCE
+    assert all(
+        edge.baseline.measurement.execution_mode is not ExecutionMode.COMPILED
+        for edge in edges
+    )
+    selected = next(
+        edge.baseline for edge in edges if edge.kind == LC_CROSS_LAYOUT_COMPONENT
+    )
+    assert selected.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+    assert REPORT_CATALOG.equivalent_cells(all_flow) == (selected,)
+
+
+def test_otf_plan_orders_lc_and_contracted_authorities(
+    tmp_path: Path,
+) -> None:
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+    selected = next(
+        cell
+        for cell in _otf_cells()
+        if cell.measurement.accuracy is Accuracy.LC
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+    planned = plan_campaign(
+        (selected,),
+        store=store,
+        settings=CampaignSettings(),
+    )
+
+    assert tuple(item.cell.measurement.execution_mode for item in planned) == (
+        ExecutionMode.RECURRENCE,
+        ExecutionMode.ON_THE_FLY,
+    )
+    nlc = next(
+        cell for cell in _otf_cells() if cell.measurement.accuracy is Accuracy.NLC
+    )
+    assert nlc.workload is Workload.CONTRACTED
+    assert tuple(
+        item.cell.measurement.execution_mode
+        for item in plan_campaign(
+            (nlc,),
+            store=store,
+            settings=CampaignSettings(),
+        )
+    ) == (
+        ExecutionMode.RECURRENCE,
+        ExecutionMode.ON_THE_FLY,
+    )
+
+    z_cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.z_cells()
+        if cell.dataset_id == "z_builtin_sm"
+        and cell.n_final == 1
+        and cell.variant == "on_the_fly_jit_o2"
+    )
+    assert {cell.workload for cell in z_cells} == {
+        Workload.SELECTED_FLOW,
+        Workload.ALL_FLOW,
+    }
+    assert all(REPORT_CATALOG.static_na_reason(cell) is None for cell in z_cells)
+    z_selected = next(
+        cell for cell in z_cells if cell.workload is Workload.SELECTED_FLOW
+    )
+    z_plan = plan_campaign(
+        (z_selected,),
+        store=store,
+        settings=CampaignSettings(),
+    )
+    assert tuple(item.cell.measurement.execution_mode for item in z_plan) == (
+        ExecutionMode.RECURRENCE,
+        ExecutionMode.ON_THE_FLY,
+    )
+    assert z_plan[-1].baseline_cell_id == z_plan[0].cell.cell_id
+    z_all_flow = next(
+        cell for cell in z_cells if cell.workload is Workload.ALL_FLOW
+    )
+    z_all_plan = plan_campaign(
+        (z_all_flow,),
+        store=store,
+        settings=CampaignSettings(),
+    )
+    assert tuple(
+        (item.cell.workload, item.cell.measurement.execution_mode)
+        for item in z_all_plan
+    ) == (
+        (Workload.SELECTED_FLOW, ExecutionMode.RECURRENCE),
+        (Workload.SELECTED_FLOW, ExecutionMode.ON_THE_FLY),
+        (Workload.ALL_FLOW, ExecutionMode.RECURRENCE),
+        (Workload.ALL_FLOW, ExecutionMode.ON_THE_FLY),
+    )
+    assert z_all_plan[-1].baseline_cell_id == z_all_plan[-2].cell.cell_id
+    assert z_all_plan[-1].comparison_peer_ids == (
+        z_all_plan[1].cell.cell_id,
+    )
+
+    ufo_full = next(
+        cell
+        for cell in _otf_cells()
+        if cell.dataset_id == "matrix_on_the_fly_ufo_sm_full"
+    )
+    assert tuple(
+        item.cell.measurement.execution_mode
+        for item in plan_campaign(
+            (ufo_full,),
+            store=store,
+            settings=CampaignSettings(),
+        )
+    ) == (
+        ExecutionMode.MADGRAPH,
+        ExecutionMode.ON_THE_FLY,
+    )
+
+
+def test_otf_config_reuses_one_topology_replay_artifact_for_both_workloads(
+    tmp_path: Path,
+) -> None:
+    cells = tuple(
+        cell
+        for cell in _otf_cells()
+        if cell.measurement.accuracy is Accuracy.LC
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+    )
+
+    assert {cell.workload for cell in cells} == {
+        Workload.SELECTED_FLOW,
+        Workload.ALL_FLOW,
+    }
+    configurations = tuple(
+        config_values(cell, RunnerSettings(), repo_root=tmp_path) for cell in cells
+    )
+    assert {
+        config["color"]["lc_flow_layout"]  # type: ignore[index]
+        for config in configurations
+    } == {"topology-replay"}
+    for config in configurations:
+        assert config["generation"]["relation_discovery"] == {  # type: ignore[index]
+            "mode": "off"
+        }
+        assert config["generation"]["validation"]["enabled"] is False  # type: ignore[index]
+        assert (  # type: ignore[index]
+            config["generation"]["validation"]["post_build_validation"] is False
+        )
+        assert config["evaluator"]["backend"] == "jit"  # type: ignore[index]
+        assert config["evaluator"]["jit"]["optimization_level"] == 2  # type: ignore[index]
+
+
+@pytest.mark.parametrize("workload", [Workload.SELECTED_FLOW, Workload.ALL_FLOW])
+def test_otf_reproduction_recipe_uses_the_compact_public_generation_contract(
+    tmp_path: Path,
+    workload: Workload,
+) -> None:
+    cell = next(
+        cell
+        for cell in _otf_cells()
+        if cell.measurement.accuracy is Accuracy.LC
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is workload
+    )
+
+    recipe = reproduction_recipe(
+        cell,
+        repo_root=tmp_path / "repo",
+        artifact_root=tmp_path / "artifacts",
+    )
+
+    assert recipe.generate is not None
+    generate = recipe.generate
+    assert generate[generate.index("--execution-mode") + 1] == "on-the-fly"
+    assert generate[generate.index("--lc-flow-layout") + 1] == "topology-replay"
+    assert "--no-emit-api-bundle" in generate
+    assert "--emit-api-bundle" not in generate
+    assert "--no-validation" in generate
+    assert "--validation" not in generate
+    assert "--no-post-build-validation" in generate
+    assert "--post-build-validation" not in generate
+    assert "--no-numerical-current-reuse" in generate
+    assert "--numerical-current-reuse" not in generate
+
+
+@pytest.mark.parametrize("accuracy", (Accuracy.LC, Accuracy.NLC, Accuracy.FULL))
+def test_otf_artifact_requires_accuracy_specific_compact_runtime_capability(
+    monkeypatch: pytest.MonkeyPatch,
+    accuracy: Accuracy,
+) -> None:
+    cell = next(
+        cell
+        for cell in _otf_cells()
+        if cell.measurement.accuracy is accuracy
+        and cell.workload
+        is (Workload.SELECTED_FLOW if accuracy is Accuracy.LC else Workload.CONTRACTED)
+    )
+    process = SimpleNamespace(
+        execution_mode="on-the-fly",
+        generation_specialized_axes=(),
+        selected_source_helicities=(),
+        selected_color_sector_ids=(),
+        lc_flow_layout="compact/query-local",
+        recurrence_color_accuracy=accuracy.value,
+        recurrence_color_storage="expanded",
+        recurrence_color_component_count=1,
+        recurrence_color_group_count=2,
+        recurrence_color_destination_count=2,
+    )
+    color_capability = (
+        "rusticol.on-the-fly.lc-color.v1"
+        if accuracy is Accuracy.LC
+        else "rusticol.on-the-fly.contracted-color.v1"
+    )
+    inspection = SimpleNamespace(
+        processes=(process,),
+        runtime_capabilities=(
+            "rusticol.on-the-fly.complex-f64.v1",
+            color_capability,
+        ),
+    )
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.inspect_artifact",
+        lambda _path: inspection,
+    )
+
+    validate_artifact_contract(cell, Path("/artifact"))
+    if accuracy is not Accuracy.LC:
+        process.recurrence_color_component_count = 2
+        with pytest.raises(RunnerError, match="expanded color payload"):
+            validate_artifact_contract(cell, Path("/artifact"))
+        process.recurrence_color_component_count = 1
+        inspection.runtime_capabilities = (
+            "rusticol.on-the-fly.complex-f64.v1",
+            "rusticol.on-the-fly.lc-color.v1",
+        )
+        with pytest.raises(RunnerError, match="accuracy-specific"):
+            validate_artifact_contract(cell, Path("/artifact"))
+        return
+    process.lc_flow_layout = "topology-replay"
+    with pytest.raises(RunnerError, match="compact/query-local"):
+        validate_artifact_contract(cell, Path("/artifact"))
+    process.lc_flow_layout = "compact/query-local"
+    inspection.runtime_capabilities += ("unexpected-capability",)
+    with pytest.raises(RunnerError, match="exactly its two accuracy-specific"):
+        validate_artifact_contract(cell, Path("/artifact"))
+
+
+@pytest.mark.parametrize("accuracy", (Accuracy.NLC, Accuracy.FULL))
+def test_otf_contracted_runtime_uses_compact_context_without_flow_selectors(
+    accuracy: Accuracy,
+) -> None:
+    cell = next(
+        cell
+        for cell in _otf_cells()
+        if cell.measurement.accuracy is accuracy
+        and cell.workload is Workload.CONTRACTED
+    )
+
+    process_expression = cell.process.upper()
+
+    class Backend:
+        @staticmethod
+        def _on_the_fly_benchmark_context(
+            requested: tuple[str, ...],
+        ) -> dict[str, object]:
+            assert requested == ()
+            return {
+                "process_id": "contracted-otf",
+                "process_expression": process_expression,
+                "color_accuracy": accuracy.value,
+                "helicity_count": 4,
+                "color_count": 1,
+                "selected_color_ids": [],
+            }
+
+    runtime = SimpleNamespace(execution_mode="on-the-fly", _backend=Backend())
+    validate_runtime_contract(cell, runtime)
+
+    process_expression = "g g > g"
+    with pytest.raises(RunnerError, match="compact selector identity"):
+        validate_runtime_contract(cell, runtime)
+    process_expression = cell.process.upper()
+
+    class DensePhysicsTrap:
+        @property
+        def physics(self) -> object:
+            raise AssertionError("contracted OTF validation opened dense physics")
+
+    runtime._backend = DensePhysicsTrap()
+    with pytest.raises(RunnerError, match="compact selector context"):
+        validate_runtime_contract(cell, runtime)
+
+
+@pytest.mark.parametrize("workload", (Workload.SELECTED_FLOW, Workload.ALL_FLOW))
+def test_otf_public_profile_owns_first_evaluation_without_dense_physics(
+    monkeypatch: pytest.MonkeyPatch,
+    workload: Workload,
+) -> None:
+    import pyamplicol.api
+
+    cell = next(
+        cell
+        for cell in _otf_cells()
+        if cell.measurement.accuracy is Accuracy.LC and cell.workload is workload
+    )
+    points = (((1.0, 0.0, 0.0, 1.0),),)
+    contract = SelectorContract(
+        selected_color_flow_ids=("flow:1,2",),
+        selected_color_words=((1, 2),),
+        all_flow_helicity_ids=("h:+1,-1",),
+        all_flow_source_helicities=((1, 1), (2, -1)),
+        point_digest=point_digest(points),
+    )
+    events: list[str] = []
+    selector_calls: list[tuple[str, tuple[str, ...]]] = []
+    dense_physics_accesses = 0
+
+    class Backend:
+        @staticmethod
+        def _on_the_fly_benchmark_context(
+            requested: tuple[str, ...],
+        ) -> dict[str, object]:
+            assert requested == ()
+            return {
+                "process_id": "compact-profile-candidate",
+                "process_expression": cell.process,
+                "color_accuracy": "lc",
+                "helicity_count": 2,
+                "color_count": 2,
+                "selected_color_ids": [],
+            }
+
+        @staticmethod
+        def _point_selector_indices(
+            values: tuple[str, ...],
+            name: str,
+        ) -> tuple[int, ...]:
+            selector_calls.append((name, tuple(values)))
+            return (0,)
+
+    class Runtime:
+        execution_mode = "on-the-fly"
+        _backend = Backend()
+
+        @property
+        def physics(self) -> object:
+            nonlocal dense_physics_accesses
+            dense_physics_accesses += 1
+            raise AssertionError("OTF profile opened dense physics")
+
+        def evaluate(self, *_args: object, **_kwargs: object) -> list[float]:
+            events.append("campaign-evaluate")
+            expected = (
+                {"helicities": None, "color_flows": ("flow:1,2",)}
+                if workload is Workload.SELECTED_FLOW
+                else {"helicities": ("h:+1,-1",), "color_flows": None}
+            )
+            assert _kwargs == expected
+            return [2.0]
+
+    @dataclass(frozen=True)
+    class Result:
+        environment: dict[str, object]
+
+    class BenchmarkRunner:
+        def __init__(self, *_args: object, **_kwargs: object) -> None:
+            pass
+
+        def run(self, runtime: object, *, points: object) -> Result:
+            events.append("public-profile")
+            return Result(
+                environment={
+                    "execution_mode": "on-the-fly",
+                    "cold_warmup_elapsed_seconds": 0.25,
+                }
+            )
+
+    def benchmark_measurement(benchmark: Result, *, matrix_element: float):
+        assert matrix_element == 2.0
+        assert benchmark.environment["cold_warmup_elapsed_seconds"] == 0.25
+        assert benchmark.environment["report_command_path"] == (
+            LOADED_RUNTIME_PROFILE_COMMAND_PATH
+        )
+        assert benchmark.environment["report_public_cli_path"] == (
+            PUBLIC_CLI_COMMAND_PATH
+        )
+        return {"status": "ok"}
+
+    monkeypatch.setattr(pyamplicol.api, "BenchmarkRunner", BenchmarkRunner)
+    monkeypatch.setattr(
+        "tools.performance_report.runner._benchmark_measurement",
+        benchmark_measurement,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.runner.resolved_sum_validation",
+        lambda *_args, **_kwargs: {"status": "ok"},
+    )
+
+    result = profile_runtime(
+        Runtime(),
+        points,
+        cell=cell,
+        benchmark_config=BenchmarkConfig(),
+        selector_contract=contract,
+    )
+
+    assert result["status"] == "ok"
+    assert events == ["public-profile", "campaign-evaluate"]
+    assert dense_physics_accesses == 0
+    assert selector_calls == [
+        ("color_flow_by_point", ("flow:1,2",)),
+        ("helicity_by_point", ("h:+1,-1",)),
+    ]
+
+
+def test_otf_benchmark_measurement_requires_and_stores_cold_warmup() -> None:
+    environment = {
+        "execution_mode": "on-the-fly",
+        "batch_size": 128,
+        "evaluator_time_raw_seconds_per_point": 8.0e-7,
+        "evaluator_time_status": "measured",
+        "evaluator_time_ratio_eligible": True,
+        "evaluator_time_source": "runtime_profile_core_recurrence_schedule_time",
+        "native_profile_points_per_sample": 128,
+        "native_profile_repetitions_per_sample": 1,
+        "native_profile_batch_size": 128,
+        "timing_sample_contract": "paired-native-repeated-profile-v1",
+        "elapsed_seconds": 1.0,
+        "measured_point_count": 640,
+        "evaluator_total_time_raw_seconds_per_point": 9.0e-7,
+        "evaluator_total_time_status": "measured",
+        "evaluator_total_time_ratio_eligible": False,
+        "evaluator_total_time_source": ("runtime._benchmark_f64_wall_time.accumulated"),
+        "evaluator_total_time_sample_contract": (
+            "accumulated-repeated-warmed-evaluator-total-v1"
+        ),
+        "evaluator_total_accumulated_seconds": 5.76e-4,
+        "cold_warmup_elapsed_seconds": 0.25,
+        "cold_warmup_run_count": 1,
+        "cold_warmup_batch_size": 128,
+        "cold_warmup_point_count": 128,
+        "cold_warmup_timer_source": WARMUP_TIMER_SOURCE,
+        "cold_warmup_timing_scope": OTF_COLD_WARMUP_TIMING_SCOPE,
+        "cold_warmup_runtime_freshness": OTF_COLD_WARMUP_RUNTIME_FRESHNESS,
+        "cold_warmup_runtime_state_evidence": (OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE),
+        "cold_warmup_runtime_state_before": _otf_warmup_runtime_state(retained=False),
+        "cold_warmup_runtime_state_after": _otf_warmup_runtime_state(retained=True),
+        "cold_warmup_runtime_cold_before_first_evaluation": True,
+        "cold_warmup_runtime_retained_before_first_evaluation": False,
+        "cold_warmup_runtime_retained_after_first_evaluation": True,
+        "cold_warmup_ratio_eligible": False,
+        "cold_warmup_acceptance_eligible": False,
+        "warmup_elapsed_seconds": 0.2,
+        "warmup_configured_run_count": 2,
+        "warmup_batch_size": 128,
+        "warmup_point_count": 256,
+        "warmup_run_outer_wall_seconds": (0.1, 0.1),
+        "first_warmup_run_outer_wall_seconds": 0.1,
+        "warmup_timer_source": WARMUP_TIMER_SOURCE,
+        "warmup_timing_scope": CONVENTIONAL_WARMUP_TIMING_SCOPE,
+    }
+    benchmark = SimpleNamespace(
+        uncertainty=SimpleNamespace(
+            standard_error=1.0e-8,
+            relative_standard_error=0.01,
+        ),
+        environment=environment,
+        evaluator_time_per_point=8.0e-7,
+        evaluator_total_time_per_point=9.0e-7,
+        wall_time_per_point=1.0e-6,
+        sample_count=5,
+        effective_config=SimpleNamespace(
+            target_runtime=1.0,
+            batch_size=128,
+            warmup_runs=2,
+        ),
+    )
+
+    measurement = _benchmark_measurement(benchmark, matrix_element=2.0)
+    assert measurement["benchmark_evidence"]["cold_warmup_elapsed_seconds"] == 0.25
+    assert (
+        measurement["benchmark_evidence"]["cold_warmup_runtime_state_evidence"]
+        == OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE
+    )
+    assert (
+        measurement["benchmark_evidence"]["cold_warmup_runtime_state_before"][
+            "retained_family_count"
+        ]
+        == 0
+    )
+    assert (
+        measurement["benchmark_evidence"]["cold_warmup_runtime_state_after"][
+            "retained_family_count"
+        ]
+        == 1
+    )
+    assert measurement["evaluator_total_timing"] == {
+        "abi": "pyamplicol-report-evaluator-total-timing-v1",
+        "status": "measured",
+        "ratio_eligible": False,
+        "raw_seconds_per_point": 9.0e-7,
+        "source": "runtime._benchmark_f64_wall_time.accumulated",
+        "execution_mode": "on-the-fly",
+        "sample_contract": "accumulated-repeated-warmed-evaluator-total-v1",
+        "sample_count": 5,
+        "repetitions_per_sample": 1,
+        "batch_size": 128,
+        "points_per_sample": 128,
+        "measured_point_count": 640,
+        "accumulated_seconds": 5.76e-4,
+    }
+
+    del environment["cold_warmup_elapsed_seconds"]
+    with pytest.raises(RunnerError, match="incomplete cold warm-up evidence"):
+        _benchmark_measurement(benchmark, matrix_element=2.0)
+
+
+def test_otf_tables_are_in_the_normal_matrix_render_path() -> None:
+    tables = render_all_matrix_tables(build_reset_caches())
+
+    assert {
+        "result_matrix_on_the_fly_builtin_sm_lc_table.tex",
+        "result_matrix_on_the_fly_builtin_sm_nlc_table.tex",
+        "result_matrix_on_the_fly_builtin_sm_full_table.tex",
+        "result_matrix_on_the_fly_ufo_sm_full_vs_madgraph_table.tex",
+    } <= tables.keys()
diff --git a/pyamplicol/tests/unit/test_on_the_fly_recurrence_authority_campaign.py b/pyamplicol/tests/unit/test_on_the_fly_recurrence_authority_campaign.py
new file mode 100644
index 0000000000..d076825f5c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_on_the_fly_recurrence_authority_campaign.py
@@ -0,0 +1,1188 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import gc
+from copy import deepcopy
+from pathlib import Path
+from types import SimpleNamespace
+from weakref import ReferenceType, ref
+
+import pytest
+from jsonschema import Draft202012Validator, ValidationError
+
+from tools.performance_report import cache as report_cache
+from tools.performance_report import measurement as report_measurement
+from tools.performance_report import runner as report_runner
+from tools.performance_report.agreements import DIRECT_AGREEMENT_FIELD
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import Accuracy, CellSpec, ExecutionMode, Workload
+from tools.performance_report.runner import (
+    OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD,
+    GeneratedArtifact,
+    RunnerError,
+    RunnerSettings,
+    SelectorContract,
+    config_values,
+    derive_selector_contract,
+    on_the_fly_recurrence_authority_validation,
+    point_digest,
+    runtime_identity_payload,
+    validate_runtime_contract,
+    validate_selector_contract,
+)
+
+POINTS = (((1.0,),), ((2.0,),))
+FLOW_IDS = ("flow:1,2", "flow:2,1")
+HELICITY_IDS = ("h:+1,-1", "h:-1,+1")
+
+
+def _otf_cell(workload: Workload):
+    return next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+        and cell.measurement.accuracy is Accuracy.LC
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is workload
+    )
+
+
+def _recurrence_authority(cell):
+    recurrence = REPORT_CATALOG.validation_baseline_cell(cell)
+    assert recurrence is not None
+    assert recurrence.measurement.execution_mode is ExecutionMode.RECURRENCE
+    return recurrence
+
+
+def _contract() -> SelectorContract:
+    return SelectorContract(
+        selected_color_flow_ids=(FLOW_IDS[0],),
+        selected_color_words=((1, 2),),
+        all_flow_helicity_ids=(HELICITY_IDS[0],),
+        all_flow_source_helicities=((1, 1), (2, -1)),
+        point_digest=point_digest(POINTS),
+    )
+
+
+class _Runtime:
+    def __init__(
+        self,
+        mode: ExecutionMode,
+        artifact_character: str,
+        *,
+        reverse_resolved_axis: bool = False,
+        mutate_nonfirst_component: bool = False,
+        inconsistent_total: bool = False,
+        structural_zero_residue: float | None = None,
+    ) -> None:
+        self.execution_mode = mode.value
+        self.artifact_id = artifact_character * 64
+        self.reverse_resolved_axis = reverse_resolved_axis
+        self.mutate_nonfirst_component = mutate_nonfirst_component
+        self.inconsistent_total = inconsistent_total
+        self.structural_zero_residue = structural_zero_residue
+        self.events: list[tuple[object, ...]] = []
+        self.physics = SimpleNamespace(
+            color_accuracy="lc",
+            selector_capabilities=("helicity", "color_flow"),
+            color_flows=(
+                SimpleNamespace(id=FLOW_IDS[0], word=(1, 2)),
+                SimpleNamespace(id=FLOW_IDS[1], word=(2, 1)),
+            ),
+            helicities=(
+                SimpleNamespace(id=HELICITY_IDS[0], values=(1, -1)),
+                SimpleNamespace(id=HELICITY_IDS[1], values=(-1, 1)),
+            ),
+            external_particles=(
+                SimpleNamespace(label=1),
+                SimpleNamespace(label=2),
+            ),
+        )
+
+    def _on_the_fly_benchmark_context(
+        self,
+        requested: tuple[str, ...],
+    ) -> dict[str, object]:
+        assert self.execution_mode == ExecutionMode.ON_THE_FLY.value
+        return {
+            "process_id": "compact-candidate",
+            "process_expression": "d d~ > z",
+            "color_accuracy": "lc",
+            "helicity_count": len(HELICITY_IDS),
+            "color_count": len(FLOW_IDS),
+            "selected_color_ids": list(requested),
+        }
+
+    def _point_selector_indices(
+        self,
+        values: tuple[str, ...],
+        name: str,
+    ) -> tuple[int, ...]:
+        assert self.execution_mode == ExecutionMode.ON_THE_FLY.value
+        available = HELICITY_IDS if name == "helicity_by_point" else FLOW_IDS
+        return tuple(available.index(identifier) for identifier in values)
+
+    def evaluate(
+        self,
+        points: object,
+        *,
+        helicities: tuple[str, ...] | None = None,
+        color_flows: tuple[str, ...] | None = None,
+        precision: int = 16,
+    ) -> tuple[float, ...]:
+        assert precision == 16
+        self.events.append(("evaluate", helicities, color_flows))
+        _selected_helicities, _selected_colors, values = self._resolved_payload(
+            points,
+            helicities=helicities,
+            color_flows=color_flows,
+        )
+        totals = [
+            sum(component for row in point for component in row) for point in values
+        ]
+        if self.inconsistent_total:
+            totals[-1] += 1.0
+        return tuple(totals)
+
+    def _resolved_payload(
+        self,
+        points: object,
+        *,
+        helicities: tuple[str, ...] | None,
+        color_flows: tuple[str, ...] | None,
+    ) -> tuple[list[str], list[str], list[list[list[float]]]]:
+        selected_helicities = list(HELICITY_IDS if helicities is None else helicities)
+        selected_colors = list(FLOW_IDS if color_flows is None else color_flows)
+        if self.reverse_resolved_axis:
+            if len(selected_helicities) > 1:
+                selected_helicities.reverse()
+            elif len(selected_colors) > 1:
+                selected_colors.reverse()
+        first_component = (selected_helicities[0], selected_colors[0])
+        last_component = (selected_helicities[-1], selected_colors[-1])
+        values: list[list[list[float]]] = []
+        for point_index, _point in enumerate(points):  # type: ignore[arg-type]
+            point_rows: list[list[float]] = []
+            for helicity_id in selected_helicities:
+                row: list[float] = []
+                for color_id in selected_colors:
+                    value = (
+                        1.0
+                        + 10.0 * point_index
+                        + 2.0 * HELICITY_IDS.index(helicity_id)
+                        + FLOW_IDS.index(color_id)
+                    )
+                    component = (helicity_id, color_id)
+                    if (
+                        self.structural_zero_residue is not None
+                        and point_index == 0
+                        and component == (HELICITY_IDS[0], FLOW_IDS[0])
+                    ):
+                        value = self.structural_zero_residue
+                    if self.mutate_nonfirst_component and point_index == 1:
+                        if component == first_component:
+                            value -= 1.0
+                        if component == last_component:
+                            value += 1.0
+                    row.append(value)
+                point_rows.append(row)
+            values.append(point_rows)
+        return selected_helicities, selected_colors, values
+
+    def evaluate_resolved(
+        self,
+        points: object,
+        *,
+        helicities: tuple[str, ...] | None = None,
+        color_flows: tuple[str, ...] | None = None,
+        precision: int = 16,
+    ) -> SimpleNamespace:
+        assert precision == 16
+        self.events.append(("resolved", helicities, color_flows))
+        selected_helicities, selected_colors, values = self._resolved_payload(
+            points,
+            helicities=helicities,
+            color_flows=color_flows,
+        )
+        frozen_values = tuple(
+            tuple(tuple(row) for row in point_rows) for point_rows in values
+        )
+
+        def total() -> tuple[float, ...]:
+            self.events.append(("resolved-total", helicities, color_flows))
+            return tuple(
+                sum(component for row in point for component in row)
+                for point in frozen_values
+            )
+
+        return SimpleNamespace(
+            helicity_ids=tuple(selected_helicities),
+            color_ids=tuple(selected_colors),
+            values=frozen_values,
+            total=total,
+        )
+
+    def clear(self) -> None:
+        self.events.append(("clear",))
+
+
+class _CompactBackend:
+    def __init__(
+        self,
+        cell: CellSpec,
+        *,
+        context_updates: dict[str, object] | None = None,
+        ordinal_overrides: dict[str, tuple[int, ...]] | None = None,
+    ) -> None:
+        self.cell = cell
+        self.context_updates = context_updates or {}
+        self.ordinal_overrides = ordinal_overrides or {}
+        self.context_requests: list[tuple[str, ...]] = []
+        self.ordinal_requests: list[tuple[str, tuple[str, ...]]] = []
+
+    def _on_the_fly_benchmark_context(
+        self,
+        requested: tuple[str, ...],
+    ) -> dict[str, object]:
+        self.context_requests.append(requested)
+        value = {
+            "process_id": "compact-candidate",
+            "process_expression": self.cell.process,
+            "color_accuracy": "lc",
+            "helicity_count": len(HELICITY_IDS),
+            "color_count": len(FLOW_IDS),
+            "selected_color_ids": list(requested),
+        }
+        value.update(self.context_updates)
+        return value
+
+    def _point_selector_indices(
+        self,
+        values: tuple[str, ...],
+        name: str,
+    ) -> tuple[int, ...]:
+        frozen = tuple(values)
+        self.ordinal_requests.append((name, frozen))
+        override = self.ordinal_overrides.get(name)
+        if override is not None:
+            return override
+        available = HELICITY_IDS if name == "helicity_by_point" else FLOW_IDS
+        return tuple(available.index(identifier) for identifier in frozen)
+
+
+class _CompactCandidate:
+    execution_mode = ExecutionMode.ON_THE_FLY.value
+    artifact_id = "a" * 64
+
+    def __init__(
+        self,
+        cell: CellSpec,
+        *,
+        context_updates: dict[str, object] | None = None,
+        ordinal_overrides: dict[str, tuple[int, ...]] | None = None,
+    ) -> None:
+        self._delegate = _Runtime(ExecutionMode.ON_THE_FLY, "a")
+        self._backend = _CompactBackend(
+            cell,
+            context_updates=context_updates,
+            ordinal_overrides=ordinal_overrides,
+        )
+        self.dense_physics_access_count = 0
+
+    @property
+    def physics(self) -> object:
+        self.dense_physics_access_count += 1
+        raise AssertionError("compact candidate opened dense physics")
+
+    @property
+    def events(self) -> list[tuple[object, ...]]:
+        return self._delegate.events
+
+    def evaluate(self, *args: object, **kwargs: object) -> tuple[float, ...]:
+        return self._delegate.evaluate(*args, **kwargs)
+
+    def evaluate_resolved(self, *args: object, **kwargs: object) -> SimpleNamespace:
+        return self._delegate.evaluate_resolved(*args, **kwargs)
+
+    def clear(self) -> None:
+        self._delegate.clear()
+
+
+def _valid_gate(workload: Workload):
+    cell = _otf_cell(workload)
+    recurrence_cell = _recurrence_authority(cell)
+    candidate = _Runtime(ExecutionMode.ON_THE_FLY, "a")
+    recurrence = _Runtime(
+        ExecutionMode.RECURRENCE,
+        "b",
+        reverse_resolved_axis=True,
+    )
+    contract = _contract()
+    record = on_the_fly_recurrence_authority_validation(
+        candidate,
+        POINTS,
+        cell=cell,
+        selector_contract=contract,
+        authority=(recurrence_cell, recurrence),
+    )
+    return cell, contract, record, candidate, recurrence
+
+
+@pytest.mark.parametrize("workload", (Workload.SELECTED_FLOW, Workload.ALL_FLOW))
+def test_recurrence_authority_candidate_uses_only_compact_selector_contract(
+    workload: Workload,
+) -> None:
+    cell = _otf_cell(workload)
+    recurrence_cell = _recurrence_authority(cell)
+    candidate = _CompactCandidate(cell)
+
+    record = on_the_fly_recurrence_authority_validation(
+        candidate,
+        POINTS,
+        cell=cell,
+        selector_contract=_contract(),
+        authority=(
+            recurrence_cell,
+            _Runtime(ExecutionMode.RECURRENCE, "b"),
+        ),
+    )
+
+    assert record["status"] == "ok"
+    assert candidate.dense_physics_access_count == 0
+    assert candidate._backend.context_requests == [(), ()]
+    assert candidate._backend.ordinal_requests == [
+        ("color_flow_by_point", (FLOW_IDS[0],)),
+        ("helicity_by_point", (HELICITY_IDS[0],)),
+    ]
+
+
+@pytest.mark.parametrize(
+    ("context_updates", "message"),
+    (
+        ({"process_expression": "g g > g"}, "identity differs"),
+        ({"helicity_count": 0}, "helicity_count is invalid"),
+        ({"color_count": False}, "color_count is invalid"),
+    ),
+)
+def test_compact_runtime_contract_rejects_invalid_identity_or_counts(
+    context_updates: dict[str, object],
+    message: str,
+) -> None:
+    cell = _otf_cell(Workload.SELECTED_FLOW)
+    candidate = _CompactCandidate(cell, context_updates=context_updates)
+
+    with pytest.raises(RunnerError, match=message):
+        validate_runtime_contract(cell, candidate)
+
+    assert candidate.dense_physics_access_count == 0
+
+
+@pytest.mark.parametrize(
+    ("name", "count"),
+    (
+        ("color_flow_by_point", len(FLOW_IDS)),
+        ("helicity_by_point", len(HELICITY_IDS)),
+    ),
+)
+def test_compact_selector_contract_rejects_out_of_range_ordinal(
+    name: str,
+    count: int,
+) -> None:
+    cell = _otf_cell(Workload.SELECTED_FLOW)
+    candidate = _CompactCandidate(
+        cell,
+        ordinal_overrides={name: (count,)},
+    )
+
+    with pytest.raises(RunnerError, match=rf"invalid {name} ordinals"):
+        validate_selector_contract(
+            candidate,
+            _contract(),
+            POINTS,
+            cell=cell,
+        )
+
+    assert candidate.dense_physics_access_count == 0
+
+
+def test_selector_derivation_rejects_otf_before_dense_physics_access() -> None:
+    cell = _otf_cell(Workload.SELECTED_FLOW)
+    candidate = _CompactCandidate(cell)
+
+    with pytest.raises(RunnerError, match="must be inherited from a dense authority"):
+        derive_selector_contract(candidate, POINTS)
+
+    assert candidate.dense_physics_access_count == 0
+    assert candidate._backend.context_requests == []
+
+
+@pytest.mark.parametrize("validation", ("runtime", "selector"))
+def test_compact_runtime_rejects_non_otf_cell_before_dense_physics_access(
+    validation: str,
+) -> None:
+    otf_cell = _otf_cell(Workload.SELECTED_FLOW)
+    recurrence_cell = _recurrence_authority(otf_cell)
+    candidate = _CompactCandidate(otf_cell)
+
+    with pytest.raises(RunnerError, match="wrong execution mode"):
+        if validation == "runtime":
+            validate_runtime_contract(recurrence_cell, candidate)
+        else:
+            validate_selector_contract(
+                candidate,
+                _contract(),
+                POINTS,
+                cell=recurrence_cell,
+            )
+
+    assert candidate.dense_physics_access_count == 0
+    assert candidate._backend.context_requests == []
+    assert candidate._backend.ordinal_requests == []
+
+
+@pytest.mark.parametrize("workload", (Workload.SELECTED_FLOW, Workload.ALL_FLOW))
+def test_recurrence_authority_gate_aligns_semantic_axes_and_resets_before_profile(
+    workload: Workload,
+) -> None:
+    _cell, _contract_value, record, candidate, recurrence = _valid_gate(workload)
+    expected_selectors = (
+        (None, (FLOW_IDS[0],))
+        if workload is Workload.SELECTED_FLOW
+        else ((HELICITY_IDS[0],), None)
+    )
+
+    assert candidate.events == [
+        ("evaluate", *expected_selectors),
+        ("resolved", *expected_selectors),
+        ("resolved-total", *expected_selectors),
+        ("clear",),
+        ("evaluate", *expected_selectors),
+        ("resolved", *expected_selectors),
+        ("resolved-total", *expected_selectors),
+        ("clear",),
+    ]
+    assert recurrence.events == [
+        ("evaluate", *expected_selectors),
+        ("resolved", *expected_selectors),
+        ("resolved-total", *expected_selectors),
+    ]
+    assert record["lifecycle"]["clear_call_count"] == 2
+    assert record["lifecycle"]["final_clear_before_profile"] is True
+    assert record["resolved_check_count"] == 4
+    assert record["authority"]["resolved_sum"]["maximum_conditioned_residual"] == 0.0
+    assert all(
+        stage["candidate_resolved_sum"]["maximum_conditioned_residual"] == 0.0
+        for stage in (record["before_clear"], record["after_clear"])
+    )
+    assert (
+        record["authority"]["resolved_ordering_sha256"]
+        != record["before_clear"]["candidate_resolved_ordering_sha256"]
+    )
+    assert all(
+        stage["comparison"]["resolved_components"]["maximum_conditioned_residual"]
+        == 0.0
+        for stage in (record["before_clear"], record["after_clear"])
+    )
+
+
+def test_mutated_nonfirst_component_fails_before_public_profile(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cell = _otf_cell(Workload.SELECTED_FLOW)
+    recurrence_cell = _recurrence_authority(cell)
+    candidate = _Runtime(
+        ExecutionMode.ON_THE_FLY,
+        "a",
+        mutate_nonfirst_component=True,
+    )
+    recurrence = _Runtime(ExecutionMode.RECURRENCE, "b")
+    contract = _contract()
+    generated = GeneratedArtifact(
+        path=tmp_path / "candidate",
+        process_id="process",
+        generation_seconds=1.0,
+        model_preparation_seconds=0.0,
+        model_preparation_reused=True,
+        requested_config={},
+        effective_config={},
+    )
+    profile_calls: list[object] = []
+
+    monkeypatch.setattr(
+        report_measurement, "generate_artifact", lambda *_a, **_k: generated
+    )
+    monkeypatch.setattr(
+        report_measurement, "validate_artifact_contract", lambda *_a, **_k: None
+    )
+    monkeypatch.setattr(
+        report_measurement, "_load_runtime", lambda *_a, **_k: candidate
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "runtime_identity_payload",
+        lambda *_a, **_k: {"loaded_module_origin_policy": {"observations": []}},
+    )
+    monkeypatch.setattr(
+        report_measurement, "shared_validation_points", lambda _p: POINTS
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "_load_on_the_fly_recurrence_authority",
+        lambda *_a, **_k: (recurrence_cell, recurrence),
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "profile_runtime",
+        lambda *_a, **_k: profile_calls.append(object()),
+    )
+    baseline = {
+        "status": "ok",
+        "matrix_element": 1.0,
+        "selector_contract": contract.as_dict(),
+    }
+
+    with pytest.raises(RunnerError, match="resolved components disagrees"):
+        report_measurement.measure_pyamplicol_cell(
+            cell,
+            artifact_path=tmp_path / "artifact",
+            settings=RunnerSettings(source_revision_override="d" * 40),
+            repo_root=tmp_path,
+            baseline=baseline,
+        )
+
+    assert profile_calls == []
+    assert ("clear",) not in candidate.events
+
+
+def test_pure_gluon_structural_zero_residue_uses_resolved_slice_scale() -> None:
+    cell = _otf_cell(Workload.SELECTED_FLOW)
+    recurrence_cell = _recurrence_authority(cell)
+    record = on_the_fly_recurrence_authority_validation(
+        _Runtime(
+            ExecutionMode.ON_THE_FLY,
+            "a",
+            structural_zero_residue=1.0e-30,
+        ),
+        POINTS,
+        cell=cell,
+        selector_contract=_contract(),
+        authority=(
+            recurrence_cell,
+            _Runtime(
+                ExecutionMode.RECURRENCE,
+                "b",
+                reverse_resolved_axis=True,
+                structural_zero_residue=0.0,
+            ),
+        ),
+    )
+
+    comparisons = tuple(
+        stage["comparison"] for stage in (record["before_clear"], record["after_clear"])
+    )
+    assert all(
+        comparison["resolved_components"]["maximum_absolute_delta"]
+        == pytest.approx(1.0e-30)
+        for comparison in comparisons
+    )
+    assert all(
+        comparison["resolved_components"]["maximum_conditioned_residual"]
+        < report_runner.RELATIVE_TOLERANCE
+        for comparison in comparisons
+    )
+
+
+def test_inconsistent_optimized_and_resolved_sum_fails_before_clear() -> None:
+    cell = _otf_cell(Workload.SELECTED_FLOW)
+    recurrence_cell = _recurrence_authority(cell)
+    candidate = _Runtime(
+        ExecutionMode.ON_THE_FLY,
+        "a",
+        inconsistent_total=True,
+    )
+
+    with pytest.raises(RunnerError, match="optimized/resolved sum disagrees"):
+        on_the_fly_recurrence_authority_validation(
+            candidate,
+            POINTS,
+            cell=cell,
+            selector_contract=_contract(),
+            authority=(
+                recurrence_cell,
+                _Runtime(ExecutionMode.RECURRENCE, "b"),
+            ),
+        )
+
+    assert ("resolved-total", None, (FLOW_IDS[0],)) in candidate.events
+    assert ("clear",) not in candidate.events
+
+
+def test_measurement_releases_recurrence_authority_before_public_profile(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class _ProfileReached(Exception):
+        pass
+
+    cell = _otf_cell(Workload.SELECTED_FLOW)
+    recurrence_cell = _recurrence_authority(cell)
+    candidate = _Runtime(ExecutionMode.ON_THE_FLY, "a")
+    contract = _contract()
+    generated = GeneratedArtifact(
+        path=tmp_path / "candidate",
+        process_id="process",
+        generation_seconds=1.0,
+        model_preparation_seconds=0.0,
+        model_preparation_reused=True,
+        requested_config={},
+        effective_config={},
+    )
+    authority_refs: list[ReferenceType[_Runtime]] = []
+
+    def load_authority(*_args: object, **_kwargs: object):
+        recurrence = _Runtime(ExecutionMode.RECURRENCE, "b")
+        authority_refs.append(ref(recurrence))
+        return (recurrence_cell, recurrence)
+
+    def profile(*_args: object, **_kwargs: object):
+        gc.collect()
+        assert authority_refs and all(item() is None for item in authority_refs)
+        raise _ProfileReached
+
+    monkeypatch.setattr(
+        report_measurement, "generate_artifact", lambda *_a, **_k: generated
+    )
+    monkeypatch.setattr(
+        report_measurement, "validate_artifact_contract", lambda *_a, **_k: None
+    )
+    monkeypatch.setattr(
+        report_measurement, "_load_runtime", lambda *_a, **_k: candidate
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "runtime_identity_payload",
+        lambda *_a, **_k: {"loaded_module_origin_policy": {"observations": []}},
+    )
+    monkeypatch.setattr(
+        report_measurement, "shared_validation_points", lambda _process: POINTS
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "_load_on_the_fly_recurrence_authority",
+        load_authority,
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "_resolution_benchmark_config",
+        lambda _config: object(),
+    )
+    monkeypatch.setattr(report_measurement, "profile_runtime", profile)
+    baseline = {
+        "status": "ok",
+        "matrix_element": 1.0,
+        "selector_contract": contract.as_dict(),
+    }
+
+    with pytest.raises(_ProfileReached):
+        report_measurement.measure_pyamplicol_cell(
+            cell,
+            artifact_path=tmp_path / "artifact",
+            settings=RunnerSettings(source_revision_override="d" * 40),
+            repo_root=tmp_path,
+            baseline=baseline,
+        )
+
+
+def test_recurrence_authority_is_loaded_without_generation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cell = _otf_cell(Workload.SELECTED_FLOW)
+    recurrence_cell = _recurrence_authority(cell)
+    recurrence_path = tmp_path / "recurrence"
+    recurrence_path.mkdir()
+
+    def measurement(path: Path, process_id: str) -> dict[str, object]:
+        return {
+            "status": "ok",
+            "generation_seconds": 1.0,
+            "artifact": {"path": str(path), "process_id": process_id},
+            "provenance": {
+                "requested_config": {},
+                "effective_config": {},
+                "model_preparation_seconds": 0.0,
+                "model_preparation_reused": True,
+            },
+        }
+
+    baseline = measurement(recurrence_path, "recurrence-process")
+    loads: list[tuple[Path, str]] = []
+    validations: list[tuple[str, Path]] = []
+    monkeypatch.setattr(
+        report_measurement,
+        "validate_artifact_contract",
+        lambda authority_cell, path: validations.append((authority_cell.cell_id, path)),
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "_load_runtime",
+        lambda path, process_id: loads.append((path, process_id)) or object(),
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "generate_artifact",
+        lambda *_a, **_k: pytest.fail("authority generation must not run"),
+    )
+
+    loaded_cell, _loaded_runtime = (
+        report_measurement._load_on_the_fly_recurrence_authority(
+            cell,
+            baseline=baseline,
+            catalog=REPORT_CATALOG,
+        )
+    )
+
+    assert loaded_cell == recurrence_cell
+    assert loads == [(recurrence_path.resolve(), "recurrence-process")]
+    assert validations == [(recurrence_cell.cell_id, recurrence_path.resolve())]
+
+
+def test_otf_cache_requires_and_authenticates_compact_gate_record() -> None:
+    cell, contract, record, *_runtimes = _valid_gate(Workload.SELECTED_FLOW)
+    measurement = {
+        "selector_contract": contract.as_dict(),
+        "provenance": {
+            "runtime_identity": {"artifact_id": record["candidate_artifact_id"]}
+        },
+    }
+    validation = {OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD: record}
+    report_cache._validate_successful_otf_recurrence_authority(
+        measurement,
+        validation,
+        expected_cell=cell,
+        catalog=REPORT_CATALOG,
+    )
+
+    with pytest.raises(ValueError, match="must be an object"):
+        report_cache._validate_successful_otf_recurrence_authority(
+            measurement,
+            {},
+            expected_cell=cell,
+            catalog=REPORT_CATALOG,
+        )
+
+    for mutation in ("digest", "count", "resolved_sum", "lifecycle", "authority"):
+        corrupted = deepcopy(record)
+        if mutation == "digest":
+            corrupted["before_clear"]["candidate_resolved_source_sha256"] = "bad"
+        elif mutation == "count":
+            corrupted["resolved_check_count"] += 1
+        elif mutation == "resolved_sum":
+            corrupted["before_clear"]["candidate_resolved_sum"][
+                "maximum_conditioned_residual"
+            ] = 1.0e-6
+        elif mutation == "lifecycle":
+            corrupted["lifecycle"]["clear_call_count"] = 1
+        else:
+            corrupted["authority"]["cell_id"] = "wrong-recurrence-cell"
+        with pytest.raises(ValueError):
+            report_cache._validate_successful_otf_recurrence_authority(
+                measurement,
+                {OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD: corrupted},
+                expected_cell=cell,
+                catalog=REPORT_CATALOG,
+            )
+
+
+def _warmup_runtime_state(*, retained: bool) -> dict[str, object]:
+    counts = {field: 0 for field in report_runner.OTF_RUNTIME_STATE_COUNT_FIELDS}
+    active: dict[str, object] | None = None
+    if retained:
+        counts.update(
+            {
+                field: 1
+                for field in (
+                    *report_runner.OTF_RUNTIME_STATE_RETAINED_BASE_POSITIVE_FIELDS,
+                    *report_runner.OTF_RUNTIME_STATE_RETAINED_EXECUTABLE_FIELDS,
+                )
+            }
+        )
+        active = {
+            "basis": "shared-query-family-union-v1",
+            "scope": "active-family-union",
+            **{field: 1 for field in report_runner.OTF_ACTIVE_FAMILY_COUNT_FIELDS},
+        }
+    return {
+        "kind": report_runner.OTF_RUNTIME_STATE_CENSUS_KIND,
+        "process_id": "otf_warmup_process",
+        "family_cache_policy": report_runner.OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY,
+        "family_cache_limit": report_runner.OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT,
+        **counts,
+        "active_family_union_census": active,
+    }
+
+
+def _warmup_evidence() -> dict[str, object]:
+    return {
+        "cold_warmup_elapsed_seconds": 4.767252833,
+        "cold_warmup_run_count": 1,
+        "cold_warmup_batch_size": 128,
+        "cold_warmup_point_count": 128,
+        "cold_warmup_timer_source": report_runner.WARMUP_TIMER_SOURCE,
+        "cold_warmup_timing_scope": report_runner.OTF_COLD_WARMUP_TIMING_SCOPE,
+        "cold_warmup_runtime_freshness": (
+            report_runner.OTF_COLD_WARMUP_RUNTIME_FRESHNESS
+        ),
+        "cold_warmup_runtime_state_evidence": (
+            report_runner.OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE
+        ),
+        "cold_warmup_runtime_state_before": _warmup_runtime_state(retained=False),
+        "cold_warmup_runtime_state_after": _warmup_runtime_state(retained=True),
+        "cold_warmup_runtime_cold_before_first_evaluation": True,
+        "cold_warmup_runtime_retained_before_first_evaluation": False,
+        "cold_warmup_runtime_retained_after_first_evaluation": True,
+        "cold_warmup_ratio_eligible": False,
+        "cold_warmup_acceptance_eligible": False,
+        "warmup_elapsed_seconds": 0.021,
+        "warmup_configured_run_count": 2,
+        "warmup_batch_size": 128,
+        "warmup_point_count": 256,
+        "warmup_run_outer_wall_seconds": [0.010, 0.011],
+        "first_warmup_run_outer_wall_seconds": 0.010,
+        "warmup_timer_source": report_runner.WARMUP_TIMER_SOURCE,
+        "warmup_timing_scope": report_runner.CONVENTIONAL_WARMUP_TIMING_SCOPE,
+    }
+
+
+def test_otf_cache_requires_complete_cold_and_conventional_warmups() -> None:
+    cell = _otf_cell(Workload.SELECTED_FLOW)
+    measurement = {
+        "provenance": {
+            "runtime_profile": _warmup_evidence(),
+            "runtime_load_included_in_cold_warmup": False,
+            "generation_timer_excludes_model_preparation": True,
+            "effective_config": {"benchmark": {"batch_size": 128, "warmup_runs": 2}},
+        }
+    }
+
+    report_cache._validate_successful_otf_warmup_evidence(
+        measurement,
+        expected_cell=cell,
+    )
+
+    structural_zero = deepcopy(measurement)
+    structural_after = structural_zero["provenance"]["runtime_profile"][
+        "cold_warmup_runtime_state_after"
+    ]
+    for field in report_runner.OTF_RUNTIME_STATE_RETAINED_EXECUTABLE_FIELDS:
+        structural_after[field] = 0
+    structural_after["active_family_union_census"] = None
+    report_cache._validate_successful_otf_warmup_evidence(
+        structural_zero,
+        expected_cell=cell,
+    )
+    partial_structural_zero = deepcopy(structural_zero)
+    partial_structural_zero["provenance"]["runtime_profile"][
+        "cold_warmup_runtime_state_after"
+    ]["retained_executor_handle_count"] = 1
+    with pytest.raises(
+        ValueError,
+        match=r"after the first evaluation.*strictly retained",
+    ):
+        report_cache._validate_successful_otf_warmup_evidence(
+            partial_structural_zero,
+            expected_cell=cell,
+        )
+
+    retained_before = deepcopy(measurement)
+    retained_profile = retained_before["provenance"]["runtime_profile"]
+    retained_profile["cold_warmup_runtime_state_before"] = _warmup_runtime_state(
+        retained=True
+    )
+    retained_profile["cold_warmup_runtime_freshness"] = (
+        report_runner.OTF_COLD_WARMUP_RUNTIME_RETAINED_FRESHNESS
+    )
+    retained_profile["cold_warmup_runtime_cold_before_first_evaluation"] = False
+    retained_profile["cold_warmup_runtime_retained_before_first_evaluation"] = True
+    report_cache._validate_successful_otf_warmup_evidence(
+        retained_before,
+        expected_cell=cell,
+    )
+
+    partial_after = deepcopy(measurement)
+    partial_after_profile = partial_after["provenance"]["runtime_profile"]
+    partial_after_profile["cold_warmup_runtime_state_after"]["pending_family_count"] = 1
+    with pytest.raises(
+        ValueError,
+        match=r"after the first evaluation.*strictly retained",
+    ):
+        report_cache._validate_successful_otf_warmup_evidence(
+            partial_after,
+            expected_cell=cell,
+        )
+
+    invalid_limit = deepcopy(measurement)
+    invalid_limit["provenance"]["runtime_profile"]["cold_warmup_runtime_state_before"][
+        "family_cache_limit"
+    ] = True
+    with pytest.raises(ValueError, match="family cache limit 1"):
+        report_cache._validate_successful_otf_warmup_evidence(
+            invalid_limit,
+            expected_cell=cell,
+        )
+
+    missing = deepcopy(measurement)
+    del missing["provenance"]["runtime_profile"]["warmup_timer_source"]
+    with pytest.raises(ValueError, match="incomplete conventional warm-up"):
+        report_cache._validate_successful_otf_warmup_evidence(
+            missing,
+            expected_cell=cell,
+        )
+
+    eligible = deepcopy(measurement)
+    eligible["provenance"]["runtime_profile"]["cold_warmup_ratio_eligible"] = True
+    with pytest.raises(ValueError, match="ineligible for ratios and acceptance"):
+        report_cache._validate_successful_otf_warmup_evidence(
+            eligible,
+            expected_cell=cell,
+        )
+
+    for field, invalid in (
+        ("runtime_load_included_in_cold_warmup", True),
+        ("generation_timer_excludes_model_preparation", False),
+    ):
+        contradictory = deepcopy(measurement)
+        contradictory["provenance"][field] = invalid
+        with pytest.raises(ValueError, match="exclude"):
+            report_cache._validate_successful_otf_warmup_evidence(
+                contradictory,
+                expected_cell=cell,
+            )
+
+    coordinated_batch = deepcopy(measurement)
+    batch_profile = coordinated_batch["provenance"]["runtime_profile"]
+    batch_profile["cold_warmup_batch_size"] = 64
+    batch_profile["cold_warmup_point_count"] = 64
+    batch_profile["warmup_batch_size"] = 64
+    batch_profile["warmup_point_count"] = 128
+    with pytest.raises(ValueError, match="effective benchmark configuration"):
+        report_cache._validate_successful_otf_warmup_evidence(
+            coordinated_batch,
+            expected_cell=cell,
+        )
+
+    coordinated_runs = deepcopy(measurement)
+    run_profile = coordinated_runs["provenance"]["runtime_profile"]
+    run_profile["warmup_configured_run_count"] = 1
+    run_profile["warmup_point_count"] = 128
+    run_profile["warmup_run_outer_wall_seconds"] = [0.010]
+    run_profile["first_warmup_run_outer_wall_seconds"] = 0.010
+    run_profile["warmup_elapsed_seconds"] = 0.010
+    with pytest.raises(ValueError, match="effective benchmark configuration"):
+        report_cache._validate_successful_otf_warmup_evidence(
+            coordinated_runs,
+            expected_cell=cell,
+        )
+
+
+def test_report_cache_schema_carries_bounded_warmup_field_contracts() -> None:
+    schema = report_cache.schema_document()
+    measurement = schema["properties"]["entries"]["items"]["properties"]["measurement"]
+    provenance = measurement["properties"]["provenance"]["oneOf"][1]
+    runtime_profile = provenance["properties"]["runtime_profile"]
+
+    assert runtime_profile["properties"]["cold_warmup_run_count"] == {"const": 1}
+    assert runtime_profile["properties"]["cold_warmup_ratio_eligible"] == {
+        "const": False
+    }
+    assert runtime_profile["properties"]["cold_warmup_runtime_freshness"] == {
+        "enum": sorted(report_runner.OTF_COLD_WARMUP_RUNTIME_FRESHNESSES)
+    }
+    assert runtime_profile["properties"]["cold_warmup_runtime_state_evidence"] == {
+        "const": report_runner.OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE
+    }
+    state_schema = runtime_profile["properties"]["cold_warmup_runtime_state_before"]
+    assert state_schema["properties"]["kind"] == {
+        "const": report_runner.OTF_RUNTIME_STATE_CENSUS_KIND
+    }
+    assert state_schema["properties"]["family_cache_policy"] == {
+        "const": report_runner.OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY
+    }
+    assert state_schema["properties"]["family_cache_limit"] == {
+        "const": report_runner.OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT
+    }
+    assert state_schema["additionalProperties"] is False
+    assert runtime_profile["properties"][
+        "cold_warmup_runtime_retained_after_first_evaluation"
+    ] == {"const": True}
+    assert runtime_profile["properties"]["warmup_timer_source"] == {
+        "const": report_runner.WARMUP_TIMER_SOURCE
+    }
+    assert provenance["properties"]["runtime_load_included_in_cold_warmup"] == {
+        "const": False
+    }
+    assert provenance["properties"]["generation_timer_excludes_model_preparation"] == {
+        "const": True
+    }
+    assert set(runtime_profile["dependentRequired"]["cold_warmup_elapsed_seconds"]) == (
+        report_runner.OTF_COLD_WARMUP_FIELDS | report_runner.CONVENTIONAL_WARMUP_FIELDS
+    )
+    assert "warmup_elapsed_seconds" not in runtime_profile["dependentRequired"]
+
+    validator = Draft202012Validator(runtime_profile)
+    validator.validate(_warmup_evidence())
+    validator.validate({"warmup_elapsed_seconds": 0.2})
+    with pytest.raises(ValidationError):
+        validator.validate({"cold_warmup_elapsed_seconds": 0.2})
+
+    recurrence = _recurrence_authority(_otf_cell(Workload.SELECTED_FLOW))
+    historical = report_cache.build_reset_cache(
+        recurrence.dataset_id,
+        (recurrence,),
+    )
+    historical_measurement = historical["entries"][0]["measurement"]
+    historical_measurement["status"] = "ok"
+    historical_measurement["validation"] = {DIRECT_AGREEMENT_FIELD: []}
+    historical_measurement["provenance"] = {
+        "runtime_profile": {"warmup_elapsed_seconds": 0.2}
+    }
+    Draft202012Validator(schema).validate(historical)
+
+
+@pytest.mark.parametrize("count_field", ("check_count", "component_count"))
+def test_otf_compact_summary_rejects_boolean_counts(count_field: str) -> None:
+    summary = {
+        "check_count": 1,
+        "component_count": 1,
+        "maximum_conditioned_residual": 0.0,
+        "maximum_absolute_delta": 0.0,
+    }
+    summary[count_field] = True
+
+    with pytest.raises(ValueError, match="count"):
+        report_runner._validate_otf_compact_summary(
+            summary,
+            field="test-summary",
+            expected_checks=1,
+            expected_components=1,
+            relative_tolerance=1.0e-12,
+        )
+
+
+def test_otf_config_omits_api_bundle_and_materialized_generation_work(
+    tmp_path: Path,
+) -> None:
+    values = config_values(
+        _otf_cell(Workload.ALL_FLOW),
+        RunnerSettings(),
+        repo_root=tmp_path,
+    )
+
+    assert values["generation"]["emit_api_bundle"] is False
+    assert values["generation"]["relation_discovery"] == {"mode": "off"}
+    assert values["color"]["lc_flow_layout"] == "topology-replay"
+
+
+@pytest.mark.parametrize("accuracy", (Accuracy.LC, Accuracy.NLC, Accuracy.FULL))
+def test_otf_runtime_identity_uses_the_real_prepared_jit_source_contract(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    accuracy: Accuracy,
+) -> None:
+    import pyamplicol._internal.versions as versions
+    import pyamplicol.artifacts
+
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+        and cell.measurement.accuracy is accuracy
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload
+        is (Workload.SELECTED_FLOW if accuracy is Accuracy.LC else Workload.CONTRACTED)
+    )
+    artifact_id = "a" * 64
+    revision = "d" * 40
+    native_path = tmp_path / "_rusticol.so"
+    native_path.write_bytes(b"native")
+    manifest = SimpleNamespace(
+        artifact_id=artifact_id,
+        processes=(
+            {
+                "id": "process",
+                "required_runtime_capabilities": [
+                    "rusticol.on-the-fly.complex-f64.v1",
+                    (
+                        "rusticol.on-the-fly.lc-color.v1"
+                        if accuracy is Accuracy.LC
+                        else "rusticol.on-the-fly.contracted-color.v1"
+                    ),
+                ],
+            },
+        ),
+        runtime={"engine_version": "test"},
+    )
+    native = SimpleNamespace(
+        __file__=str(native_path),
+        native_build_inputs_sha256=lambda: "e" * 64,
+        target_info=lambda: SimpleNamespace(triple="test", cpu_features=()),
+        package_version=lambda: "test",
+    )
+    package_tree = {"kind": "tree"}
+    native_identity = {"kind": "native"}
+    monkeypatch.setattr(
+        pyamplicol.artifacts, "load_manifest", lambda *_a, **_k: manifest
+    )
+    monkeypatch.setattr(versions, "verify_native_module", lambda _native: None)
+    monkeypatch.setattr(
+        versions,
+        "_active_build_info",
+        lambda: {
+            "schema_version": 1,
+            "version": "test",
+            "source_revision": revision,
+            "publishable": True,
+            "selftest_fixture_bootstrap": False,
+        },
+    )
+    monkeypatch.setattr(report_runner.importlib, "import_module", lambda _name: native)
+    monkeypatch.setattr(
+        report_runner,
+        "established_preimport_runtime_identity",
+        lambda: {
+            "kind": "pyamplicol-preimport-runtime-identity-v1",
+            "python_package_tree": package_tree,
+            "native_extension": native_identity,
+        },
+    )
+    monkeypatch.setattr(
+        report_runner,
+        "python_package_tree_identity",
+        lambda _roots: package_tree,
+    )
+    monkeypatch.setattr(
+        report_runner,
+        "loaded_pyamplicol_origin_policy",
+        lambda *_a, **_k: {"kind": "loaded-origin"},
+    )
+
+    identity = runtime_identity_payload(
+        cell,
+        SimpleNamespace(artifact_id=artifact_id, execution_mode="on-the-fly"),
+        tmp_path,
+        "process",
+        expected_source_revision=revision,
+    )
+
+    assert identity["expected_evaluator_abi"] == (
+        "pyamplicol-runtime-on-the-fly-execution"
+    )
+    assert identity["expected_source_evaluator_abi"] == (
+        "pyamplicol-symjit-plane-application-v2"
+    )
+    assert identity["expected_source_evaluator_runtime_capability"] == (
+        "symjit.application.complex-f64.v1"
+    )
diff --git a/pyamplicol/tests/unit/test_on_the_fly_report_render.py b/pyamplicol/tests/unit/test_on_the_fly_report_render.py
new file mode 100644
index 0000000000..feb733533b
--- /dev/null
+++ b/pyamplicol/tests/unit/test_on_the_fly_report_render.py
@@ -0,0 +1,460 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+from collections.abc import Mapping
+
+import pytest
+
+from tools.performance_report import render as report_render
+from tools.performance_report.cache import build_reset_caches
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import Accuracy, ExecutionMode, Workload
+from tools.performance_report.render import (
+    BaselineCandidateAdapter,
+    JoinedWorkload,
+    _fixed_mode_generation_comparison_layout,
+    _fixed_mode_runtime_comparison_layout,
+    render_best_mode_table,
+    render_matrix_table,
+)
+from tools.performance_report.runner import (
+    OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD,
+)
+from tools.performance_report.validation_summary import render_validation_summary
+
+_POINT_DIGEST = "1" * 64
+_OTF_ARTIFACT_ID = "a" * 64
+_RECURRENCE_ARTIFACT_ID = "b" * 64
+_AMPLICOL_ARTIFACT_ID = "c" * 64
+_SELECTOR_CONTRACT = {
+    "selected_color_flow_ids": ["flow:2,1"],
+    "selected_color_words": [[2, 1]],
+    "all_flow_helicity_ids": ["h:-1,+1,-1"],
+    "all_flow_source_helicities": {"1": -1, "2": 1, "3": -1},
+    "point_digest": _POINT_DIGEST,
+}
+
+
+def _cache(caches: dict[str, dict[str, object]], dataset_id: str) -> dict[str, object]:
+    return next(
+        payload for payload in caches.values() if payload["dataset_id"] == dataset_id
+    )
+
+
+def _set_measurement(
+    cache: dict[str, object],
+    *,
+    process_key: str,
+    workload: Workload,
+    generation: float,
+    wall: float,
+    cold_warmup: float | None = None,
+    selector_contract: Mapping[str, object] | None = None,
+    artifact_id: str = _AMPLICOL_ARTIFACT_ID,
+    validation: Mapping[str, object] | None = None,
+) -> None:
+    entries = cache["entries"]
+    assert isinstance(entries, list)
+    entry = next(
+        item
+        for item in entries
+        if item["process_key"] == process_key
+        and item["n_final"] == 1
+        and item["workload"] == workload.value
+        and item["variant"] is None
+    )
+    runtime_profile = {
+        "warmup_elapsed_seconds": 50.0,
+    }
+    if cold_warmup is not None:
+        runtime_profile["cold_warmup_elapsed_seconds"] = cold_warmup
+    entry["measurement"] = {
+        "status": "ok",
+        "generation_seconds": generation,
+        "wall_seconds_per_point": wall,
+        "execution_seconds_per_point": wall,
+        "matrix_element": 1.0,
+        "sample_count": 5,
+        "standard_error_seconds_per_point": 1.0e-9,
+        "relative_standard_error": 0.01,
+        "artifact": {"digest": "test"},
+        "selector_contract": copy.deepcopy(selector_contract),
+        "validation": dict(validation or {"status": "ok"}),
+        "resources": {"peak_rss_gib": 1.0},
+        "provenance": {
+            "runtime_load_seconds": 100.0,
+            "runtime_profile": runtime_profile,
+            "runtime_identity": {"artifact_id": artifact_id},
+        },
+        "failure": None,
+    }
+
+
+def _measurement(
+    cache: dict[str, object],
+    *,
+    process_key: str,
+    workload: Workload,
+) -> dict[str, object]:
+    entries = cache["entries"]
+    assert isinstance(entries, list)
+    entry = next(
+        item
+        for item in entries
+        if item["process_key"] == process_key
+        and item["n_final"] == 1
+        and item["workload"] == workload.value
+        and item["variant"] is None
+    )
+    measurement = entry["measurement"]
+    assert isinstance(measurement, dict)
+    return measurement
+
+
+def _pointwise_validation() -> dict[str, object]:
+    return {
+        "status": "ok",
+        "pointwise": {
+            "status": "ok",
+            "candidate": 1.0,
+            "baseline": 1.0,
+        },
+    }
+
+
+@pytest.fixture
+def otf_render_caches(
+    monkeypatch: pytest.MonkeyPatch,
+) -> dict[str, dict[str, object]]:
+    caches = build_reset_caches()
+    baseline = _cache(caches, "reference_amplicol_lc")
+    candidate = _cache(caches, "matrix_on_the_fly_builtin_sm_lc")
+    recurrence = _cache(caches, "matrix_recurrence_builtin_sm_lc")
+    for workload, baseline_generation, generation, cold_warmup in (
+        (Workload.SELECTED_FLOW, 10.0, 4.0, 1.0),
+        (Workload.ALL_FLOW, 20.0, 6.0, 2.0),
+    ):
+        _set_measurement(
+            baseline,
+            process_key="dd_z_jets",
+            workload=workload,
+            generation=baseline_generation,
+            wall=10.0e-6,
+            selector_contract=_SELECTOR_CONTRACT,
+        )
+        _set_measurement(
+            recurrence,
+            process_key="dd_z_jets",
+            workload=workload,
+            generation=8.0,
+            wall=2.0e-6,
+            selector_contract=_SELECTOR_CONTRACT,
+            artifact_id=_RECURRENCE_ARTIFACT_ID,
+        )
+        _set_measurement(
+            candidate,
+            process_key="dd_z_jets",
+            workload=workload,
+            generation=generation,
+            wall=1.0e-6,
+            cold_warmup=cold_warmup,
+            selector_contract=_SELECTOR_CONTRACT,
+            artifact_id=_OTF_ARTIFACT_ID,
+            validation={
+                "status": "ok",
+                OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD: {
+                    "authority": {"artifact_id": _RECURRENCE_ARTIFACT_ID},
+                },
+            },
+        )
+    monkeypatch.setattr(
+        report_render,
+        "validate_on_the_fly_recurrence_authority_validation_record",
+        lambda *_args, **_kwargs: None,
+    )
+    return caches
+
+
+def test_otf_fixed_lc_table_pairs_generation_with_only_first_cold_warmup(
+    otf_render_caches: dict[str, dict[str, object]],
+) -> None:
+    dataset = REPORT_CATALOG.dataset("matrix_on_the_fly_builtin_sm_lc")
+    tex = render_matrix_table(dataset, otf_render_caches)
+    row = next(line for line in tex.splitlines() if line.startswith(r"\texttt{1}"))
+
+    assert (
+        r"\bestmodecompactprefix{0.400} & "
+        r"\bestmodeprimaryratio{ReportGreen}{0.500}"
+    ) in row
+    assert (
+        r"\bestmodecompactabsoluteprefix{6.00} & "
+        r"\bestmodeabsoluteprimary{8.00}"
+    ) in row
+    assert (
+        r"\providecommand{\bestmodecompactabsolute}[2]{"
+        r"\textcolor{ReportMuted}{\texttt{[#1]}}"
+        r"\hspace{0.04in}\textcolor{black}{\texttt{#2}}}"
+    ) in tex
+    assert r"\renewcommand{\arraystretch}{1.00}" in tex
+    assert "W excludes artifact loading and conventional benchmark warm-ups" in tex
+    assert "104" not in row
+    assert "56.0" not in row
+
+
+def test_otf_best_mode_winner_keeps_pair_semantics_and_o_marker(
+    otf_render_caches: dict[str, dict[str, object]],
+) -> None:
+    tex = render_best_mode_table(Accuracy.LC, otf_render_caches)
+    row = next(line for line in tex.splitlines() if line.startswith(r"\texttt{1}"))
+
+    assert (
+        r"\bestmodecodeprefix{o}\bestmodecompactprefix{0.400} & "
+        r"\bestmodeprimaryratio{ReportGreen}{0.500}"
+    ) in row
+    assert (
+        r"\bestmodecompactabsoluteprefix{6.00} & "
+        r"\bestmodeabsoluteprimary{8.00}"
+        r"\hspace{0.025in}\bestmodecode{o}"
+    ) in row
+    assert "r|c|e|o" in tex
+    assert "follows the enclosing cold-start contract" in tex
+
+
+@pytest.mark.parametrize("accuracy", (Accuracy.NLC, Accuracy.FULL))
+def test_otf_contracted_best_mode_winner_is_in_row_mix_and_legend(
+    accuracy: Accuracy,
+) -> None:
+    caches = build_reset_caches()
+    workload = Workload.CONTRACTED
+    baseline = _cache(caches, f"reference_amplicol_{accuracy.value}")
+    recurrence = _cache(
+        caches,
+        f"matrix_recurrence_builtin_sm_{accuracy.value}",
+    )
+    candidate = _cache(
+        caches,
+        f"matrix_on_the_fly_builtin_sm_{accuracy.value}",
+    )
+    _set_measurement(
+        baseline,
+        process_key="dd_z_jets",
+        workload=workload,
+        generation=10.0,
+        wall=10.0e-6,
+    )
+    _set_measurement(
+        recurrence,
+        process_key="dd_z_jets",
+        workload=workload,
+        generation=8.0,
+        wall=2.0e-6,
+        artifact_id=_RECURRENCE_ARTIFACT_ID,
+        validation=_pointwise_validation(),
+    )
+    _set_measurement(
+        candidate,
+        process_key="dd_z_jets",
+        workload=workload,
+        generation=4.0,
+        wall=1.0e-6,
+        cold_warmup=1.0,
+        artifact_id=_OTF_ARTIFACT_ID,
+        validation=_pointwise_validation(),
+    )
+
+    view = BaselineCandidateAdapter(caches).best_mode_cell(
+        accuracy,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    assert view.workloads[0].mode is ExecutionMode.ON_THE_FLY
+
+    tex = render_best_mode_table(accuracy, caches)
+    row = next(line for line in tex.splitlines() if line.startswith(r"\texttt{1}"))
+    assert (
+        r"\bestmodecodeprefix{o}\bestmodecompactprefix{0.400} & "
+        r"\bestmodeprimaryratio{ReportGreen}{0.500}"
+    ) in row
+    assert r"\bestmodemix{r:0|c:0|e:0|o:1}" in tex
+    assert "Summary mode counts use r|c|e|o" in tex
+    assert "contracted cold-start contract" in tex
+    generation_summary = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r"\multicolumn{3}{@{}l}{\textbf{summary: generation}}")
+    )
+    assert generation_summary.count(
+        r"\matrixsummaryratio{ReportGreen}{0.500}"
+    ) == 4
+    assert (
+        generation_summary.count(
+            r"\matrixsummaryratiohighlight{ReportGreen}{0.500}"
+        )
+        == 1
+    )
+    assert "0.400" not in generation_summary
+
+
+def test_otf_amplicol_links_are_metric_and_workload_specific(
+    otf_render_caches: dict[str, dict[str, object]],
+) -> None:
+    baseline = _cache(otf_render_caches, "reference_amplicol_lc")
+    for workload in (Workload.SELECTED_FLOW, Workload.ALL_FLOW):
+        measurement = _measurement(
+            baseline,
+            process_key="dd_z_jets",
+            workload=workload,
+        )
+        selector = measurement["selector_contract"]
+        assert isinstance(selector, dict)
+        selector["selected_color_flow_ids"] = ["flow:2,4,3,1"]
+        selector["selected_color_words"] = [[2, 4, 3, 1]]
+
+    dataset = REPORT_CATALOG.dataset("matrix_on_the_fly_builtin_sm_lc")
+    family = next(
+        item for item in REPORT_CATALOG.process_families if item.key == "dd_z_jets"
+    )
+    view = BaselineCandidateAdapter(otf_render_caches).matrix_cell(
+        dataset,
+        family,
+        1,
+    )
+    selected, all_flow = view.workloads
+
+    assert selected.generation_comparison_linked
+    assert not selected.comparison_linked
+    assert all_flow.generation_comparison_linked
+    assert all_flow.comparison_linked
+
+    selected_generation = _fixed_mode_generation_comparison_layout(
+        selected,
+        candidate_mode=ExecutionMode.ON_THE_FLY,
+        baseline_mode=ExecutionMode.AMPLICOL,
+    )
+    selected_runtime = _fixed_mode_runtime_comparison_layout(
+        selected,
+        candidate_mode=ExecutionMode.ON_THE_FLY,
+        baseline_mode=ExecutionMode.AMPLICOL,
+    )
+    all_flow_runtime = _fixed_mode_runtime_comparison_layout(
+        all_flow,
+        candidate_mode=ExecutionMode.ON_THE_FLY,
+        baseline_mode=ExecutionMode.AMPLICOL,
+    )
+    assert "bestmodecompactratio{0.400}" in selected_generation.inline
+    assert selected_runtime.inline == r"\texttt{1.00}"
+    assert "bestmodecompactratio{0.100}" in all_flow_runtime.inline
+
+    fixed_tex = render_matrix_table(dataset, otf_render_caches)
+    generation_summary = next(
+        line
+        for line in fixed_tex.splitlines()
+        if line.startswith(r"\multicolumn{3}{@{}l}{\textbf{summary: generation}}")
+    )
+    assert r"\matrixsummaryratio{ReportGreen}{0.400}" in generation_summary
+    assert "0.500" not in generation_summary
+
+    best_tex = render_best_mode_table(Accuracy.LC, otf_render_caches)
+    best_lines = best_tex.splitlines()
+    generation_index = next(
+        index
+        for index, line in enumerate(best_lines)
+        if line.startswith(r"\texttt{1}")
+    )
+    generation_row = best_lines[generation_index]
+    runtime_row = best_lines[generation_index + 2]
+    assert r"\bestmodecodeprefix{o}\bestmodecompactprefix{0.400}" in generation_row
+    assert r"\bestmodecode{o}" in generation_row
+    assert r"\bestmodeabsoluteprefix{\texttt{1.00}}" in runtime_row
+    assert r"\bestmodecompactprefix{0.100}" in runtime_row
+
+    best_view = BaselineCandidateAdapter(otf_render_caches).best_mode_cell(
+        Accuracy.LC,
+        family,
+        1,
+    )
+    best_selected, best_all_flow = best_view.workloads
+    assert best_selected.mode is ExecutionMode.ON_THE_FLY
+    assert best_selected.generation_comparison_linked
+    assert not best_selected.comparison_linked
+    assert best_all_flow.comparison_linked
+
+    best_generation_summary = next(
+        line
+        for line in best_lines
+        if line.startswith(r"\multicolumn{3}{@{}l}{\textbf{summary: generation}}")
+    )
+    assert best_generation_summary.count(
+        r"\matrixsummaryratio{ReportGreen}{0.500}"
+    ) == 4
+    assert (
+        best_generation_summary.count(
+            r"\matrixsummaryratiohighlight{ReportGreen}{0.500}"
+        )
+        == 1
+    )
+    assert "0.400" not in best_generation_summary
+
+
+def test_validation_summary_names_otf_recurrence_cross_mode() -> None:
+    tex = render_validation_summary(build_reset_caches())
+
+    assert "compiled/eager/OTF versus recurrence" in tex
+    assert "cross-mode (including OTF/recurrence)" in tex
+
+
+def test_otf_pair_is_provenance_strict_and_never_used_against_recurrence() -> None:
+    baseline = {
+        "status": "ok",
+        "generation_seconds": 10.0,
+    }
+    candidate = {
+        "status": "ok",
+        "generation_seconds": 4.0,
+        "provenance": {
+            "runtime_load_seconds": 100.0,
+            "runtime_profile": {"cold_warmup_elapsed_seconds": 1.0},
+        },
+    }
+    joined = JoinedWorkload(
+        Workload.SELECTED_FLOW,
+        baseline,
+        candidate,
+        comparison_linked=True,
+    )
+
+    recurrence_layout = _fixed_mode_generation_comparison_layout(
+        joined,
+        candidate_mode=ExecutionMode.ON_THE_FLY,
+        baseline_mode=ExecutionMode.RECURRENCE,
+    )
+    assert recurrence_layout.inline == r"\bestmoderatio{ReportGreen}{0.400}"
+
+    missing_cold = copy.deepcopy(candidate)
+    missing_cold["provenance"]["runtime_profile"].pop(  # type: ignore[index]
+        "cold_warmup_elapsed_seconds"
+    )
+    missing_layout = _fixed_mode_generation_comparison_layout(
+        JoinedWorkload(
+            Workload.SELECTED_FLOW,
+            baseline,
+            missing_cold,
+            comparison_linked=True,
+        ),
+        candidate_mode=ExecutionMode.ON_THE_FLY,
+        baseline_mode=ExecutionMode.AMPLICOL,
+    )
+    assert missing_layout.inline == r"\matrixna{ReportMuted}"
+
+
+@pytest.mark.parametrize("accuracy", [Accuracy.NLC, Accuracy.FULL])
+def test_static_otf_color_tables_keep_the_regular_contracted_layout(
+    accuracy: Accuracy,
+) -> None:
+    caches = build_reset_caches()
+    dataset = REPORT_CATALOG.dataset(f"matrix_on_the_fly_builtin_sm_{accuracy.value}")
+    tex = render_matrix_table(dataset, caches)
+
+    assert r"\multicolumn{3}{c}{\textbf{n=1}}" in tex
+    assert r"\matrixstaticna{ReportMuted}" in tex
diff --git a/pyamplicol/tests/unit/test_on_the_fly_seed_projection.py b/pyamplicol/tests/unit/test_on_the_fly_seed_projection.py
new file mode 100644
index 0000000000..9278eda7da
--- /dev/null
+++ b/pyamplicol/tests/unit/test_on_the_fly_seed_projection.py
@@ -0,0 +1,488 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import replace
+from typing import cast
+
+import pytest
+
+from pyamplicol.generation.on_the_fly_seed import (
+    project_on_the_fly_process_seed_v1,
+)
+from pyamplicol.generation.recurrence_fermion_pairing import (
+    build_recurrence_fermion_pairing_roots_v1,
+)
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.base import Model
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.prepared_catalog import build_prepared_kernel_catalog
+from pyamplicol.models.recurrence_catalog_builder import (
+    build_recurrence_template_catalog,
+)
+from pyamplicol.models.recurrence_template import (
+    CurrentStateTemplateV1,
+    EvaluatorBindingV1,
+    ExactComplexRationalV1,
+    LCColorSourceSeedV1,
+    ParameterTemplateV1,
+    RecurrenceTemplateCatalog,
+    SourceTemplateV1,
+)
+from pyamplicol.processes.ir import (
+    CanonicalProcessIR,
+    ColorEndpointSummary,
+    ProcessLegIR,
+)
+
+
+def _sha(value: str) -> str:
+    return hashlib.sha256(value.encode("ascii")).hexdigest()
+
+
+def _crossing() -> str:
+    return json.dumps(
+        {
+            "chirality_factor": -1,
+            "helicity_factor": -1,
+            "momentum_transform": "negate-four-momentum",
+            "phase": {
+                "imag_denominator": "1",
+                "imag_numerator": "0",
+                "real_denominator": "1",
+                "real_numerator": "1",
+            },
+            "spin_state_factor": -1,
+        },
+        separators=(",", ":"),
+        sort_keys=True,
+    )
+
+
+def _state(
+    template_id: str,
+    particle_id: int,
+    *,
+    family: str,
+    role: str,
+    orientation: str,
+) -> CurrentStateTemplateV1:
+    representation = {"adjoint": 8, "fundamental": 3, "antifundamental": -3}[role]
+    shape = {
+        "adjoint": "adjoint-segment",
+        "fundamental": "fundamental-open-string",
+        "antifundamental": "antifundamental-open-string",
+    }[role]
+    return CurrentStateTemplateV1(
+        template_id=template_id,
+        particle_id=particle_id,
+        anti_particle_id=(particle_id if particle_id == 21 else -particle_id),
+        species_id=("species:g" if particle_id == 21 else "species:q"),
+        orientation=orientation,
+        statistics="boson" if family == "vector" else "fermion",
+        color_representation=representation,
+        basis=family,
+        tensor_ordering=(f"{family}:0", f"{family}:1"),
+        dimension=2,
+        chirality=0,
+        lc_color_shape_kind=shape,
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+
+
+def _sources(
+    state: CurrentStateTemplateV1,
+    family: str,
+) -> tuple[SourceTemplateV1, ...]:
+    return tuple(
+        SourceTemplateV1(
+            template_id=f"source:{state.template_id}:{helicity}",
+            state_template_id=state.template_id,
+            crossing=_crossing(),
+            wavefunction_family=family,
+            helicity=helicity,
+            spin_state=helicity,
+            flavour_flow=(state.particle_id,),
+            quantum_number_flow=(),
+            lc_color_seed=LCColorSourceSeedV1(
+                operation="singleton",
+                output_shape_kind=state.lc_color_shape_kind,
+                component_kind=(
+                    "adjoint-segment" if family == "vector" else "open-string"
+                ),
+                component_role="active",
+                proof_digest=_sha(f"source-color:{state.template_id}"),
+            ),
+            wavefunction_expression_digest=_sha(
+                f"source-expression:{state.template_id}:{helicity}"
+            ),
+            evaluator_resolver_key=f"resolver:{state.template_id}:{helicity}",
+        )
+        for helicity in (-1, 1)
+    )
+
+
+def _catalog(*, fermions: bool = False) -> RecurrenceTemplateCatalog:
+    states = [
+        _state(
+            "state:g",
+            21,
+            family="vector",
+            role="adjoint",
+            orientation="self-conjugate",
+        )
+    ]
+    if fermions:
+        states.extend(
+            (
+                _state(
+                    "state:q",
+                    1,
+                    family="fermion",
+                    role="fundamental",
+                    orientation="particle",
+                ),
+                _state(
+                    "state:qbar",
+                    -1,
+                    family="fermion",
+                    role="antifundamental",
+                    orientation="antiparticle",
+                ),
+            )
+        )
+    parameter = ParameterTemplateV1(
+        template_id="parameter:gs",
+        name="gs",
+        parameter_kind="external",
+        value_type="real",
+        mutable=True,
+        default_value=ExactComplexRationalV1(1, 1, 0, 1),
+        exact_expression_digest=None,
+        dependency_parameter_ids=(),
+        prepared_parameter_id=0,
+    )
+    sources = tuple(
+        source
+        for state in states
+        for source in _sources(
+            state, "vector" if state.particle_id == 21 else "fermion"
+        )
+    )
+    state_by_id = {state.template_id: state for state in states}
+    bindings = tuple(
+        EvaluatorBindingV1(
+            resolver_key=source.evaluator_resolver_key,
+            prepared_kernel_id=None,
+            callable_kind="rusticol-template",
+            runtime_template=(
+                "rusticol.source-fill."
+                f"{source.wavefunction_family}.v1:"
+                f"{source.wavefunction_expression_digest[:24]}"
+            ),
+            contract_kind="source",
+            callable_signature=source.wavefunction_expression_digest,
+            input_state_template_ids=(),
+            output_state_template_id=source.state_template_id,
+            input_layout=("momentum:energy",),
+            output_layout=tuple(
+                f"source-component:{index}"
+                for index in range(state_by_id[source.state_template_id].dimension)
+            ),
+            exact_expression_digests=tuple(
+                _sha(f"source-output:{source.template_id}:{index}")
+                for index in range(state_by_id[source.state_template_id].dimension)
+            ),
+            semantic_template_ids=(source.template_id,),
+        )
+        for source in sources
+    )
+    return RecurrenceTemplateCatalog.create(
+        compiled_model_digest=_sha("model"),
+        prepared_kernel_pack_digest=_sha("pack"),
+        parameters=(parameter,),
+        current_states=tuple(states),
+        sources=sources,
+        evaluator_bindings=bindings,
+    )
+
+
+def _gluon_process(count: int) -> CanonicalProcessIR:
+    return CanonicalProcessIR(
+        process="g g > " + " ".join("g" for _ in range(count - 2)),
+        key="gluon_process",
+        color_accuracy="lc",
+        legs=tuple(
+            ProcessLegIR(
+                label=index + 1,
+                side="initial" if index < 2 else "final",
+                particle="g",
+                outgoing_particle="g",
+                pdg=21,
+                outgoing_pdg=21,
+                statistics="boson",
+                wavefunction_family="vector",
+                color_role="adjoint",
+                source_orientation="self-conjugate",
+            )
+            for index in range(count)
+        ),
+        color_endpoints=ColorEndpointSummary(0, 0, 0),
+    )
+
+
+def _many_fermion_process(pair_count: int) -> CanonicalProcessIR:
+    legs = tuple(
+        ProcessLegIR(
+            label=index + 1,
+            side="final",
+            particle=("q" if index < pair_count else "q~"),
+            outgoing_particle=("q" if index < pair_count else "q~"),
+            pdg=(1 if index < pair_count else -1),
+            outgoing_pdg=(1 if index < pair_count else -1),
+            statistics="fermion",
+            wavefunction_family="fermion",
+            color_role=("fundamental" if index < pair_count else "antifundamental"),
+            source_orientation=("particle" if index < pair_count else "antiparticle"),
+        )
+        for index in range(2 * pair_count)
+    )
+    return CanonicalProcessIR(
+        process="all > " + " ".join(leg.particle for leg in legs),
+        key=f"many_fermions_{pair_count}",
+        color_accuracy="lc",
+        legs=legs,
+        color_endpoints=ColorEndpointSummary(pair_count, pair_count, pair_count),
+    )
+
+
+class _NormalizationModel:
+    def coupling_order_hierarchies(self) -> dict[str, int]:
+        return {"QCD": 1}
+
+    def runtime_normalization_payload(self, _process: object) -> dict[str, object]:
+        return {
+            "average_factor": 1.0,
+            "color_factor": 1.0,
+            "couplings_in_stage_evaluators": True,
+            "global_coupling_factor": 1.0,
+            "identical_factor": 1.0,
+        }
+
+
+def _project(process: CanonicalProcessIR):
+    return project_on_the_fly_process_seed_v1(
+        process,
+        _catalog(),
+        cast(Model, _NormalizationModel()),
+        coupling_order_policy="minimal",
+        coupling_order_limits={"QCD": len(process.legs)},
+    )
+
+
+def test_source_only_projection_never_builds_a_dag_color_plan_or_schedule(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol.generation.recurrence_columnar as columnar
+    import pyamplicol.generation.service as service
+
+    def forbidden(*_args: object, **_kwargs: object) -> None:
+        raise AssertionError("materialized process construction was called")
+
+    monkeypatch.setattr(service, "compile_generic_dag", forbidden)
+    monkeypatch.setattr(service, "build_color_plan", forbidden)
+    monkeypatch.setattr(service, "_invoke_rust_recurrence_lowering_v2", forbidden)
+    monkeypatch.setattr(columnar, "build_recurrence_builder_input_v1", forbidden)
+
+    projected = _project(_gluon_process(4))
+    assert projected.color_plan is None
+    payload = projected.seed.to_json_dict()
+    assert set(payload) == {
+        "schema_version",
+        "process_digest",
+        "external_permutation",
+        "external_sources",
+        "parameter_projection",
+        "coupling_order_policy",
+        "coupling_hierarchies",
+        "coupling_limits",
+        "fermion_pairing",
+        "normalization",
+    }
+    assert payload["external_permutation"] == [0, 1, 2, 3]
+    assert payload["fermion_pairing"] is None
+    assert all(len(row["states"]) == 2 for row in payload["external_sources"])
+    encoded = projected.seed.to_json_bytes()
+    for forbidden_name in (
+        b"physical_sectors",
+        b"public_flows",
+        b"generic_dag",
+        b"direct_plan",
+        b"relation_discovery",
+    ):
+        assert forbidden_name not in encoded
+
+
+@pytest.mark.parametrize("color_accuracy", ("nlc", "full"))
+def test_contracted_projection_keeps_color_plan_outside_seed_v1(
+    color_accuracy: str,
+) -> None:
+    projected = _project(
+        replace(_gluon_process(4), color_accuracy=color_accuracy)
+    )
+    assert projected.color_plan is not None
+    assert projected.color_plan.color_accuracy == color_accuracy
+    assert projected.color_plan.sector_count == 6
+    assert projected.color_plan.trace_reflections_folded is False
+
+    payload = projected.seed.to_json_dict()
+    assert "color_plan" not in payload
+    assert "color_contraction" not in payload
+    assert set(payload) == {
+        "schema_version",
+        "process_digest",
+        "external_permutation",
+        "external_sources",
+        "parameter_projection",
+        "coupling_order_policy",
+        "coupling_hierarchies",
+        "coupling_limits",
+        "fermion_pairing",
+        "normalization",
+    }
+
+
+def test_projection_is_deterministic_and_scales_with_external_sources_only() -> None:
+    projected = tuple(_project(_gluon_process(count)).seed for count in (4, 6, 8))
+    assert projected[0].to_json_bytes() == (
+        _project(_gluon_process(4)).seed.to_json_bytes()
+    )
+    sizes = tuple(len(item.to_json_bytes()) for item in projected)
+    assert sizes[1] - sizes[0] == sizes[2] - sizes[1]
+    assert tuple(len(item.external_sources) for item in projected) == (4, 6, 8)
+    assert tuple(
+        sum(len(leg.source_states) for leg in item.external_sources)
+        for item in projected
+    ) == (8, 12, 16)
+
+
+def test_projection_omits_limits_absent_from_template_coupling_dimension() -> None:
+    projection = _project(_gluon_process(4)).seed
+
+    assert projection.coupling_hierarchies == ()
+    assert projection.coupling_limits == ()
+
+
+def test_vector_execution_states_cross_only_for_initials() -> None:
+    catalog = _catalog()
+    projection = _project(_gluon_process(4)).seed
+    payload = projection.to_json_dict()
+    sources = tuple(sorted(catalog.sources, key=lambda row: row.template_id))
+
+    for leg, encoded in zip(
+        projection.external_sources,
+        payload["external_sources"],
+        strict=True,
+    ):
+        assert isinstance(encoded, dict)
+        states = encoded["states"]
+        assert isinstance(states, list)
+        for state, row in zip(leg.source_states, states, strict=True):
+            assert isinstance(row, dict)
+            declared = sources[state.source_template_id]
+            factor = -1 if leg.is_initial else 1
+            assert row["public_helicity"] == declared.helicity * factor
+            assert row["source_helicity"] == row["public_helicity"]
+            assert row["spin_state"] == declared.spin_state * factor
+            assert row["momentum_sign"] == (-1 if leg.is_initial else 1)
+
+
+def test_builtin_incoming_fermions_keep_crossed_execution_contract() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > z")
+    prepared = build_prepared_kernel_catalog(model)
+    catalog = build_recurrence_template_catalog(
+        model,
+        prepared,
+        compiled_model_digest="a" * 64,
+        prepared_kernel_pack_digest="b" * 64,
+    )
+    projection = project_on_the_fly_process_seed_v1(
+        process,
+        catalog,
+        model,
+        coupling_order_policy="minimal",
+        coupling_order_limits={"QED": 1},
+    ).seed
+
+    assert tuple(
+        (row.name, row.minimum, row.maximum) for row in projection.coupling_limits
+    ) == (("QED", 0, 1),)
+    assert projection.process_digest == (
+        "8395a16bc0f605c05c7c746d7b428b07f175fb869ebd84f856f8886fe139d82f"
+    )
+    assert projection.external_permutation == (0, 1, 2)
+    assert tuple(leg.physical_pdg for leg in projection.external_sources[:2]) == (
+        1,
+        -1,
+    )
+    assert tuple(leg.outgoing_pdg for leg in projection.external_sources[:2]) == (
+        -1,
+        1,
+    )
+    source_rows = tuple(sorted(catalog.sources, key=lambda row: row.template_id))
+    current_rows = tuple(
+        sorted(catalog.current_states, key=lambda row: row.template_id)
+    )
+    current_by_name = {row.template_id: row for row in catalog.current_states}
+    encoded_legs = projection.to_json_dict()["external_sources"]
+    assert isinstance(encoded_legs, list)
+
+    for leg, encoded in zip(
+        projection.external_sources[:2],
+        encoded_legs[:2],
+        strict=True,
+    ):
+        assert leg.is_initial and leg.is_fermionic
+        assert tuple(state.spin_state for state in leg.source_states) == (1, -1)
+        assert isinstance(encoded, dict)
+        encoded_states = encoded["states"]
+        assert isinstance(encoded_states, list)
+        for state, row in zip(leg.source_states, encoded_states, strict=True):
+            assert isinstance(row, dict)
+            source = source_rows[state.source_template_id]
+            canonical_current = current_by_name[source.state_template_id]
+            effective_current = current_rows[state.current_state_template_id]
+            crossing = json.loads(source.crossing)
+            assert row["public_helicity"] == (
+                source.helicity * crossing["helicity_factor"]
+            )
+            assert row["source_helicity"] == row["public_helicity"]
+            assert row["spin_state"] == (
+                source.spin_state * crossing["spin_state_factor"]
+            )
+            assert row["chirality"] == effective_current.chirality
+            assert row["chirality"] == (
+                canonical_current.chirality * crossing["chirality_factor"]
+            )
+            assert row["momentum_sign"] == -1
+            assert row["crossing_phase"] == crossing["phase"]
+
+
+def test_compact_pairing_roots_do_not_enumerate_or_cap_runtime_pairings() -> None:
+    process = _many_fermion_process(9)
+    catalog = _catalog(fermions=True)
+    roots = build_recurrence_fermion_pairing_roots_v1(
+        process,
+        catalog.current_states,
+        quantum_flows=catalog.quantum_flows,
+    )
+    assert len(roots.endpoints) == 18
+    assert len(roots.classes) == 1
+    assert roots.classes[0].fundamental_source_slots == tuple(range(9))
+    assert roots.classes[0].antifundamental_source_slots == tuple(range(9, 18))
+    # The compact roots stay O(external legs); 9! concrete pairings are absent.
+    assert not hasattr(roots, "rules")
diff --git a/pyamplicol/tests/unit/test_otf_cache.py b/pyamplicol/tests/unit/test_otf_cache.py
new file mode 100644
index 0000000000..bb1ebf83cb
--- /dev/null
+++ b/pyamplicol/tests/unit/test_otf_cache.py
@@ -0,0 +1,129 @@
+# SPDX-License-Identifier: 0BSD
+"""Fast public-facade and native-adapter contracts for OTF cache persistence."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+
+from pyamplicol import Runtime
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+from pyamplicol.runtime.backend import RusticolRuntimeBackend
+
+
+class _Backend:
+    """The minimum runtime protocol, deliberately without optional cache APIs."""
+
+    physics: Any = None
+
+    def evaluate(self, *args: Any, **kwargs: Any) -> Any:
+        raise AssertionError("cache operations must not evaluate")
+
+    def evaluate_resolved(self, *args: Any, **kwargs: Any) -> Any:
+        raise AssertionError("cache operations must not evaluate")
+
+    def set_model_parameters(self, mapping: Any) -> None:
+        raise AssertionError("cache operations must not change parameters")
+
+    def clear(self) -> None:
+        raise AssertionError("cache operations must not clear before validation")
+
+    def mute_warnings(self) -> None:
+        pass
+
+    def unmute_warnings(self) -> None:
+        pass
+
+
+class _CacheBackend(_Backend):
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, Path]] = []
+
+    def save(self, path: Path) -> None:
+        self.calls.append(("save", path))
+
+    def load_cache(self, path: Path) -> None:
+        self.calls.append(("load_cache", path))
+
+
+@pytest.mark.parametrize("name", ("save", "load_cache"))
+@pytest.mark.parametrize("as_string", (False, True))
+def test_facade_normalizes_cache_paths(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, name: str, as_string: bool
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    backend = _CacheBackend()
+    runtime = Runtime(backend)
+    relative = Path("cache with spaces") / ".." / "recursion.cache"
+    assert getattr(runtime, name)(str(relative) if as_string else relative) is None
+    assert backend.calls == [(name, tmp_path / "recursion.cache")]
+
+
+@pytest.mark.parametrize("name", ("save", "load_cache"))
+def test_facade_cache_support_does_not_expand_minimum_backend_protocol(
+    name: str,
+) -> None:
+    runtime = Runtime(_Backend())
+    with pytest.raises(CompatibilityError, match="does not support"):
+        getattr(runtime, name)("recursion.cache")
+
+
+@pytest.mark.parametrize("name", ("save", "load_cache"))
+def test_facade_rejects_non_paths_before_calling_backend(name: str) -> None:
+    backend = _CacheBackend()
+    with pytest.raises(TypeError):
+        getattr(Runtime(backend), name)(object())
+    assert backend.calls == []
+
+
+class _NativeArtifactError(Exception):
+    pass
+
+
+def _adapter(native: Any, *, mode: str = "on-the-fly") -> RusticolRuntimeBackend:
+    # Constructor metadata validation is covered by test_runtime_adapter.py;
+    # this seam isolates cache forwarding and native exception translation.
+    backend = object.__new__(RusticolRuntimeBackend)
+    backend._runtime = native
+    backend._native_module = SimpleNamespace(ArtifactError=_NativeArtifactError)
+    backend._execution_mode = mode  # type: ignore[assignment]
+    return backend
+
+
+@pytest.mark.parametrize("name", ("save", "load_cache"))
+def test_native_adapter_forwards_path_without_opening_physics(
+    tmp_path: Path, name: str
+) -> None:
+    paths: list[Path] = []
+    backend = _adapter(SimpleNamespace(**{name: paths.append}))
+    path = tmp_path / "recursion.cache"
+    assert getattr(backend, name)(path) is None
+    assert paths == [path]
+
+
+@pytest.mark.parametrize("name", ("save", "load_cache"))
+def test_native_adapter_translates_restore_and_save_errors(name: str) -> None:
+    def fail(path: Path) -> None:
+        raise _NativeArtifactError("cache does not match this process")
+
+    backend = _adapter(SimpleNamespace(**{name: fail}))
+    with pytest.raises(ArtifactError, match="does not match") as error:
+        getattr(backend, name)(Path("cache"))
+    assert isinstance(error.value.__cause__, _NativeArtifactError)
+
+
+@pytest.mark.parametrize("name", ("save", "load_cache"))
+@pytest.mark.parametrize("mode", ("recurrence", "compiled", "eager"))
+def test_cache_operations_reject_non_otf_modes(name: str, mode: str) -> None:
+    backend = _adapter(SimpleNamespace(), mode=mode)
+    with pytest.raises(CompatibilityError, match="only for on-the-fly"):
+        getattr(backend, name)(Path("cache"))
+
+
+@pytest.mark.parametrize("name", ("save", "load_cache"))
+def test_native_adapter_reports_missing_binding(name: str) -> None:
+    with pytest.raises(CompatibilityError, match=f"no on-the-fly {name} binding"):
+        getattr(_adapter(SimpleNamespace()), name)(Path("cache"))
diff --git a/pyamplicol/tests/unit/test_otf_contracted_parity_gate.py b/pyamplicol/tests/unit/test_otf_contracted_parity_gate.py
new file mode 100644
index 0000000000..431d9b2085
--- /dev/null
+++ b/pyamplicol/tests/unit/test_otf_contracted_parity_gate.py
@@ -0,0 +1,171 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from decimal import Decimal
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+_GATE_PATH = (
+    Path(__file__).resolve().parents[2]
+    / "tools"
+    / "developer"
+    / "otf_contracted_parity_gate.py"
+)
+_GATE_SPEC = importlib.util.spec_from_file_location(
+    "test_otf_contracted_parity_gate_module",
+    _GATE_PATH,
+)
+if _GATE_SPEC is None or _GATE_SPEC.loader is None:  # pragma: no cover
+    raise RuntimeError("cannot load the OTF contracted parity gate")
+gate = importlib.util.module_from_spec(_GATE_SPEC)
+_GATE_SPEC.loader.exec_module(gate)
+
+
+def test_authority_and_compact_preflights_precede_evaluation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    events: list[str] = []
+    prepared = tmp_path / "prepared-model"
+    prepared.write_bytes(b"prepared")
+    point = tmp_path / "point.json"
+    point.write_text(json.dumps([[1.0, 0.0, 0.0, 1.0]]), encoding="ascii")
+    recurrence = tmp_path / "recurrence.json"
+    recurrence.write_text("{}\n", encoding="ascii")
+    artifact = tmp_path / "artifact"
+    output = tmp_path / "result.json"
+
+    class FakeCompiledModelSource:
+        def compile(self) -> object:
+            events.append("model-compile")
+            return object()
+
+    class FakeModelSource:
+        @staticmethod
+        def from_path(_path: Path) -> FakeCompiledModelSource:
+            return FakeCompiledModelSource()
+
+    class FakeProcessSet:
+        @staticmethod
+        def from_expressions(*_args: object, **_kwargs: object) -> object:
+            return object()
+
+    class FakeGenerator:
+        def __init__(self, _config: object) -> None:
+            pass
+
+        def generate(self, *_args: object, **_kwargs: object) -> None:
+            events.append("generation")
+            artifact.mkdir()
+
+    class FakeRuntimeInstance:
+        execution_mode = "on-the-fly"
+
+        @property
+        def physics(self) -> object:
+            raise AssertionError("ordering gate must not materialize dense physics")
+
+        def inspect(self) -> dict[str, object]:
+            events.append("compact-inspection")
+            return {
+                "runtime_metadata": {
+                    "execution_mode": "on-the-fly",
+                    "color_accuracy": "nlc",
+                }
+            }
+
+        def evaluate(self, *_args: object, **_kwargs: object) -> tuple[complex, ...]:
+            events.append("evaluation")
+            return (1.0 + 0.0j,)
+
+        def clear(self) -> None:
+            pass
+
+    class FakeRuntime:
+        @staticmethod
+        def load(*_args: object, **_kwargs: object) -> FakeRuntimeInstance:
+            events.append("runtime-load")
+            return FakeRuntimeInstance()
+
+    package = ModuleType("pyamplicol")
+    package.__file__ = str(tmp_path / "pyamplicol" / "__init__.py")
+    package.Generator = FakeGenerator  # type: ignore[attr-defined]
+    package.ModelSource = FakeModelSource  # type: ignore[attr-defined]
+    package.ProcessSet = FakeProcessSet  # type: ignore[attr-defined]
+    package.Runtime = FakeRuntime  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, "pyamplicol", package)
+    monkeypatch.setattr(gate.importlib.metadata, "version", lambda _name: "test")
+    monkeypatch.setattr(gate, "_run_config", lambda *_args: object())
+
+    def candidate_identity(*_args: object) -> dict[str, object]:
+        events.append("candidate-authentication")
+        return {
+            "version": "test",
+            "source_revision": None,
+            "native_build_inputs_sha256": "a" * 64,
+        }
+
+    def recurrence_target(*_args: object, **_kwargs: object) -> tuple[Decimal, dict]:
+        events.append("authority-authentication")
+        return Decimal(1), {"kind": "mock-recurrence-authority"}
+
+    def artifact_preflight(*_args: object, **_kwargs: object) -> dict[str, object]:
+        events.append("artifact-preflight")
+        return {
+            "producer": {"version": "test"},
+            "effective_config": {"evaluator_optimization_cores": 4},
+            "runtime_options": {"query_construction_threads": 4},
+        }
+
+    monkeypatch.setattr(gate, "_candidate_identity", candidate_identity)
+    monkeypatch.setattr(gate, "_recurrence_target", recurrence_target)
+    monkeypatch.setattr(gate, "_authenticate_artifact", artifact_preflight)
+
+    assert (
+        gate.main(
+            (
+                "--output",
+                str(output),
+                "--artifact",
+                str(artifact),
+                "--prepared-model",
+                str(prepared),
+                "--process",
+                "g g > g",
+                "--process-name",
+                "ordering_gate",
+                "--n-final",
+                "1",
+                "--family-id",
+                "1",
+                "--point",
+                str(point),
+                "--accuracy",
+                "nlc",
+                "--mode",
+                "on-the-fly",
+                "--precision",
+                "16",
+                "--query-construction-cores",
+                "4",
+                "--recurrence-authority",
+                str(recurrence),
+            )
+        )
+        == 0
+    )
+    assert events == [
+        "candidate-authentication",
+        "authority-authentication",
+        "model-compile",
+        "generation",
+        "artifact-preflight",
+        "runtime-load",
+        "compact-inspection",
+        "evaluation",
+    ]
diff --git a/pyamplicol/tests/unit/test_packaged_prepared_model.py b/pyamplicol/tests/unit/test_packaged_prepared_model.py
new file mode 100644
index 0000000000..e038d4d09c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_packaged_prepared_model.py
@@ -0,0 +1,290 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.assets import prepared_models
+from pyamplicol.models.prepared_catalog import PREPARED_INDEPENDENT_BLOCK_PROOF
+from pyamplicol.models.prepared_target import canonical_architecture
+
+ROOT = Path(__file__).resolve().parents[2]
+ASSET_ROOT = ROOT / "src" / "pyamplicol" / "assets" / "prepared_models"
+ASSET_STEM = f"built-in-sm-jit-o2-{canonical_architecture()}"
+
+
+def _metadata() -> dict[str, object]:
+    return json.loads(
+        (ASSET_ROOT / f"{ASSET_STEM}.metadata.json").read_text(encoding="utf-8")
+    )
+
+
+def test_packaged_builtin_sm_jit_o2_is_discoverable_and_validated(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol._internal.versions as versions
+    import pyamplicol.models.loading as loading
+
+    metadata = _metadata()
+    producer = metadata["producer"]
+    assert isinstance(producer, dict)
+    monkeypatch.setattr(
+        versions,
+        "package_version",
+        lambda: producer["package_version"],
+    )
+    monkeypatch.setattr(
+        loading,
+        "package_version",
+        lambda: producer["package_version"],
+    )
+
+    assert prepared_models.available_prepared_models() == (
+        prepared_models.BUILTIN_SM_JIT_O2,
+        prepared_models.BUILTIN_SM_HEFT_JIT_O2,
+    )
+    with prepared_models.packaged_prepared_model_path(
+        prepared_models.BUILTIN_SM_JIT_O2
+    ) as path:
+        from pyamplicol import ModelSource
+
+        assert path.name == f"{ASSET_STEM}.pyamplicol-model"
+        assert path.is_file()
+        compiled = ModelSource.from_path(path).compile(use_cache=False)
+        assert compiled.name == "built-in-sm"
+        assert compiled.prepared_backend == "jit"
+    with prepared_models.open_packaged_prepared_model() as bundle:
+        assert bundle.backend == "jit"
+        assert len(bundle.kernel_pack.kernels) == metadata["kernel_count"] == 53
+        eligible_ids = {
+            kernel.kernel_id
+            for kernel in bundle.kernel_pack.kernels
+            if PREPARED_INDEPENDENT_BLOCK_PROOF in kernel.proof_classes
+        }
+        assert len(eligible_ids) == 32
+        assert {
+            variant.base_kernel_id for variant in bundle.kernel_pack.kernel_variants
+        } == eligible_ids
+        assert all(
+            variant.variant_id == "independent-block-4"
+            for variant in bundle.kernel_pack.kernel_variants
+        )
+        assert bundle.kernel_pack.target["portable"] is True
+        assert bundle.kernel_pack.target["cpu_features"] == ()
+
+
+def test_packaged_builtin_sm_heft_jit_o2_is_selectable(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol._internal.versions as versions
+    import pyamplicol.models.loading as loading
+
+    architecture = canonical_architecture()
+    stem = f"built-in-sm-heft-jit-o2-{architecture}"
+    metadata = json.loads(
+        (ASSET_ROOT / f"{stem}.metadata.json").read_text(encoding="utf-8")
+    )
+    producer = metadata["producer"]
+    assert isinstance(producer, dict)
+    monkeypatch.setattr(
+        versions, "package_version", lambda: producer["package_version"]
+    )
+    monkeypatch.setattr(loading, "package_version", lambda: producer["package_version"])
+
+    with prepared_models.open_packaged_prepared_model(
+        prepared_models.BUILTIN_SM_HEFT_JIT_O2
+    ) as bundle:
+        assert bundle.compiled_model["model"]["name"] == "built-in-sm-heft"
+        assert bundle.compiled_model["source"]["kind"] == "built-in-sm-heft"
+        assert bundle.backend == "jit"
+        assert len(bundle.kernel_pack.kernels) == metadata["kernel_count"]
+
+
+def test_packaged_prepared_model_materializes_stable_cached_copy(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    import pyamplicol._internal.versions as versions
+    import pyamplicol.models.loading as loading
+
+    metadata = _metadata()
+    producer = metadata["producer"]
+    assert isinstance(producer, dict)
+    monkeypatch.setattr(
+        versions,
+        "package_version",
+        lambda: producer["package_version"],
+    )
+    monkeypatch.setattr(loading, "package_version", lambda: producer["package_version"])
+
+    first = prepared_models.materialize_packaged_prepared_model(cache_dir=tmp_path)
+    second = prepared_models.materialize_packaged_prepared_model(cache_dir=tmp_path)
+
+    assert first == second
+    assert first.is_file()
+    assert first.parent.name == _metadata()["bundle_sha256"]
+    assert (
+        first.read_bytes()
+        == (ASSET_ROOT / f"{ASSET_STEM}.pyamplicol-model").read_bytes()
+    )
+
+
+def test_packaged_prepared_model_rejects_unknown_identity() -> None:
+    with (
+        pytest.raises(
+            prepared_models.PackagedPreparedModelError,
+            match="unknown packaged prepared model",
+        ),
+        prepared_models.packaged_prepared_model_path("not-a-model"),
+    ):
+        pass
+
+
+def test_packaged_prepared_model_rejects_unsupported_host_architecture(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        "pyamplicol.models.prepared_target.platform.machine",
+        lambda: "sparc64",
+    )
+    with (
+        pytest.raises(
+            prepared_models.PackagedPreparedModelError,
+            match="host architecture",
+        ),
+        prepared_models.packaged_prepared_model_path(prepared_models.BUILTIN_SM_JIT_O2),
+    ):
+        pass
+
+
+def test_packaged_prepared_model_rejects_resource_tampering(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    copied = tmp_path / "prepared_models"
+    shutil.copytree(ASSET_ROOT, copied)
+    bundle = copied / f"{ASSET_STEM}.pyamplicol-model"
+    bundle.write_bytes(bundle.read_bytes() + b"tampered")
+    monkeypatch.setattr(prepared_models.resources, "files", lambda _package: copied)
+
+    with (
+        pytest.raises(
+            prepared_models.PackagedPreparedModelError,
+            match="size does not match",
+        ),
+        prepared_models.packaged_prepared_model_path(prepared_models.BUILTIN_SM_JIT_O2),
+    ):
+        pass
+
+
+def test_packaged_prepared_model_accepts_older_package_producer(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol._internal.versions as versions
+
+    producer = _metadata()["producer"]
+    assert isinstance(producer, dict)
+    recorded = str(producer["package_version"])
+    release = recorded.split(".dev", maxsplit=1)[0].split("+", maxsplit=1)[0]
+    major, minor, patch = (int(component) for component in release.split("."))
+    active = f"{major}.{minor}.{patch + 1}"
+    monkeypatch.setattr(versions, "package_version", lambda: active)
+
+    with prepared_models.packaged_prepared_model_path(
+        prepared_models.BUILTIN_SM_JIT_O2
+    ) as path:
+        assert path.is_file()
+
+
+def test_packaged_prepared_model_accepts_candidate_fingerprint_drift(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol._internal.versions as versions
+
+    metadata = _metadata()
+    producer = metadata["producer"]
+    assert isinstance(producer, dict)
+    recorded = str(producer["package_version"])
+    active = recorded.rsplit("+candidate.", maxsplit=1)[0] + ("+candidate." + "0" * 12)
+    monkeypatch.setattr(versions, "package_version", lambda: active)
+
+    with prepared_models.packaged_prepared_model_path(
+        prepared_models.BUILTIN_SM_JIT_O2
+    ) as path:
+        assert path.is_file()
+
+
+def test_packaged_prepared_model_rejects_internal_producer_version_mismatch(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    import pyamplicol._internal.versions as versions
+
+    copied = tmp_path / "prepared_models"
+    shutil.copytree(ASSET_ROOT, copied)
+    metadata = _metadata()
+    producer = metadata["producer"]
+    assert isinstance(producer, dict)
+    recorded = str(producer["package_version"])
+    producer["package_version"] = recorded.rsplit("+candidate.", maxsplit=1)[0] + (
+        "+candidate." + "0" * 12
+    )
+    (copied / f"{ASSET_STEM}.metadata.json").write_text(
+        json.dumps(metadata),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        versions,
+        "package_version",
+        lambda: producer["package_version"],
+    )
+    monkeypatch.setattr(prepared_models.resources, "files", lambda _package: copied)
+
+    with (
+        pytest.raises(
+            prepared_models.PackagedPreparedModelError,
+            match="package version disagrees with metadata",
+        ),
+        prepared_models.packaged_prepared_model_path(prepared_models.BUILTIN_SM_JIT_O2),
+    ):
+        pass
+
+
+def test_packaged_prepared_model_runtime_ignores_producer_source_fingerprints(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    import pyamplicol._internal.versions as versions
+    import pyamplicol.models.loading as loading
+
+    copied = tmp_path / "prepared_models"
+    shutil.copytree(ASSET_ROOT, copied)
+    metadata = _metadata()
+    producer = metadata["producer"]
+    assert isinstance(producer, dict)
+    for key in (
+        "model_compiler_sha256",
+        "model_source_digest",
+        "native_build_inputs_sha256",
+    ):
+        producer[key] = "0" * 64
+    (copied / f"{ASSET_STEM}.metadata.json").write_text(
+        json.dumps(metadata),
+        encoding="utf-8",
+    )
+    package_version = producer["package_version"]
+    monkeypatch.setattr(
+        versions,
+        "package_version",
+        lambda: package_version,
+    )
+    monkeypatch.setattr(loading, "package_version", lambda: package_version)
+    monkeypatch.setattr(prepared_models.resources, "files", lambda _package: copied)
+
+    with prepared_models.packaged_prepared_model_path(
+        prepared_models.BUILTIN_SM_JIT_O2
+    ) as path:
+        assert path.is_file()
diff --git a/pyamplicol/tests/unit/test_packaged_prepared_model_build.py b/pyamplicol/tests/unit/test_packaged_prepared_model_build.py
new file mode 100644
index 0000000000..25aa203a2f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_packaged_prepared_model_build.py
@@ -0,0 +1,734 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import shutil
+import sys
+import tomllib
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "build_backend"))
+
+import prepared_models as prepared_models_module  # noqa: E402
+from prepared_models import (  # noqa: E402
+    discard_release_packaged_prepared_model_store,
+    project_release_packaged_prepared_model_store,
+    stage_packaged_prepared_models,
+    write_candidate_packaged_prepared_model_asset,
+    write_release_packaged_prepared_model_asset,
+)
+
+with (ROOT / "dependencies" / "release-lock.toml").open("rb") as stream:
+    RELEASE_VERSION = str(tomllib.load(stream)["project"]["version"])
+
+
+@pytest.fixture(autouse=True)
+def _synthetic_prepared_contract(monkeypatch: pytest.MonkeyPatch) -> None:
+    # These tests exercise packaging metadata, not archive decoding or native
+    # kernels. Keep their inputs independent of the checked-in candidate packs.
+    def load_bundle(path: Path) -> SimpleNamespace:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        pack = payload["kernel_pack"]
+        pack["kernels"] = tuple(SimpleNamespace(**item) for item in pack["kernels"])
+        payload["kernel_pack"] = SimpleNamespace(**pack)
+        return SimpleNamespace(**payload)
+
+    monkeypatch.setattr(
+        prepared_models_module,
+        "_load_prepared_contract",
+        lambda _path: SimpleNamespace(load_prepared_model_bundle=load_bundle),
+    )
+
+
+def _overlay(tmp_path: Path) -> Path:
+    overlay = tmp_path / "overlay"
+    shutil.copytree(
+        ROOT / "src" / "pyamplicol",
+        overlay / "src" / "pyamplicol",
+        ignore=shutil.ignore_patterns(
+            "__pycache__", "*.pyc", "*.pyamplicol-model", "*.metadata.json"
+        ),
+    )
+    dependencies = overlay / "dependencies"
+    dependencies.mkdir()
+    shutil.copy2(
+        ROOT / "dependencies" / "release-lock.toml",
+        dependencies / "release-lock.toml",
+    )
+    shutil.copy2(
+        ROOT / "dependencies" / "contributor-lock.toml",
+        dependencies / "contributor-lock.toml",
+    )
+    shutil.copy2(ROOT / "Cargo.toml", overlay / "Cargo.toml")
+    # Only dependency versions are read for these synthetic bundles. Derive
+    # that fixture from tracked inputs, not a developer's ignored Cargo lock.
+    with (dependencies / "contributor-lock.toml").open("rb") as stream:
+        contributor = tomllib.load(stream)
+    (overlay / "Cargo.lock").write_text(
+        "version = 4\n"
+        + "".join(
+            f"\n[[package]]\nname = {json.dumps(name)}\n"
+            f"version = {json.dumps(contributor[name]['candidate_version'])}\n"
+            for name in ("symbolica", "symjit")
+        ),
+        encoding="utf-8",
+    )
+    _write_fixture_assets(overlay, mode="candidate")
+    package_root = overlay / "src" / "pyamplicol"
+    metadata = json.loads(
+        (
+            package_root
+            / "assets"
+            / "prepared_models"
+            / "built-in-sm-jit-o2-aarch64.metadata.json"
+        ).read_text(encoding="utf-8")
+    )
+    producer = metadata["producer"]
+    assert isinstance(producer, dict)
+    (overlay / "src" / "pyamplicol" / "_build_info.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "publishable": False,
+                "source_revision": None,
+                "version": producer["package_version"],
+            }
+        ),
+        encoding="utf-8",
+    )
+    return overlay
+
+
+def _release_overlay(tmp_path: Path) -> Path:
+    overlay = tmp_path / "release-overlay"
+    shutil.copytree(
+        ROOT / "src" / "pyamplicol",
+        overlay / "src" / "pyamplicol",
+        ignore=shutil.ignore_patterns(
+            "__pycache__", "*.pyc", "*.pyamplicol-model", "*.metadata.json"
+        ),
+    )
+    dependencies = overlay / "dependencies"
+    dependencies.mkdir()
+    shutil.copy2(
+        ROOT / "dependencies" / "release-lock.toml",
+        dependencies / "release-lock.toml",
+    )
+    shutil.copy2(ROOT / "Cargo.toml", overlay / "Cargo.toml")
+    shutil.copy2(ROOT / "Cargo.lock", overlay / "Cargo.lock")
+    _write_fixture_assets(overlay, mode="release")
+    return overlay
+
+
+def _release_store(overlay: Path) -> Path:
+    store = overlay / "release_assets" / "prepared_models"
+    store.mkdir(parents=True)
+    (store / "README.md").write_text("release source store\n", encoding="utf-8")
+    source = overlay / "src/pyamplicol/assets/prepared_models"
+    for path in source.iterdir():
+        if path.name != "__init__.py":
+            shutil.copy2(path, store / path.name)
+    return store
+
+
+def _release_bundle(
+    overlay: Path,
+    package_version: str = RELEASE_VERSION,
+    *,
+    model_source: str = "built-in-sm",
+) -> SimpleNamespace:
+    package_root = overlay / "src" / "pyamplicol"
+    compiled_schema = prepared_models_module._literal_assignment(
+        package_root / "_internal" / "versions.py",
+        "COMPILED_MODEL_SCHEMA_VERSION",
+    )
+    compiler_version = prepared_models_module._literal_assignment(
+        package_root / "models" / "loading.py",
+        "MODEL_COMPILER_VERSION",
+    )
+    compiler_digest = "a" * 64
+    source_digest = prepared_models_module._built_in_source_digest(
+        package_root, model_source
+    )
+    symbolica_abi = prepared_models_module._literal_assignment(
+        package_root / "_internal" / "versions.py",
+        "SYMBOLICA_SERIALIZATION_ABI",
+    )
+    symjit_abi = prepared_models_module._literal_assignment(
+        package_root / "_internal" / "versions.py",
+        "SYMJIT_APPLICATION_ABI",
+    )
+    symjit_plane_abi = prepared_models_module._literal_assignment(
+        package_root / "_internal" / "versions.py",
+        "SYMJIT_PLANE_APPLICATION_ABI",
+    )
+    pack = SimpleNamespace(
+        backend="jit",
+        dependency_abis={
+            "symbolica_serialization": symbolica_abi,
+            "symbolica_version": prepared_models_module._cargo_package_version(
+                overlay, "symbolica"
+            ),
+            "symjit_application": symjit_abi,
+            "symjit_plane_application": symjit_plane_abi,
+        },
+        kernels=(
+            SimpleNamespace(
+                kernel_id="fixture-kernel",
+                f64_evaluator_manifest={
+                    "kind": "symjit-application-evaluator",
+                    "backend": "jit",
+                    "runtime_capability": "symjit.application.complex-f64.v1",
+                    "application_abi": symjit_abi,
+                    "compiler_type": "native",
+                    "translation_mode": "indirect",
+                    "optimization_level": 2,
+                    "word_bits": 64,
+                    "endianness": "little",
+                    "required_defuns": [],
+                },
+            ),
+        ),
+        optimization_settings={"backend": "jit", "jit_optimization_level": 2},
+        producer={
+            "version": package_version,
+            "compiled_model_schema": compiled_schema,
+            "model_compiler_version": compiler_version,
+        },
+        provenance={
+            "compiled_model_digest": source_digest,
+            "model_name": model_source,
+            "model_source": {
+                "digest": source_digest,
+                "kind": model_source,
+            },
+        },
+        target={
+            "portable": True,
+            "word_bits": 64,
+            "endianness": "little",
+            "target_triple": "symjit-storage-v3-portable",
+            "cpu_features": [],
+        },
+    )
+    return SimpleNamespace(
+        backend="jit",
+        compiled_model={
+            "model": {"name": model_source},
+            "producer": {
+                "compiled_model_schema_version": compiled_schema,
+                "model_compiler_version": compiler_version,
+                "model_compiler_sha256": compiler_digest,
+                "pyamplicol": package_version,
+            },
+            "source": {
+                "digest": source_digest,
+                "kind": model_source,
+            },
+        },
+        kernel_pack=pack,
+        manifest={
+            "eager_kernel_abi": prepared_models_module._literal_assignment(
+                package_root / "models/prepared.py", "EAGER_KERNEL_ABI"
+            ),
+            "schema_version": prepared_models_module._literal_assignment(
+                package_root / "models/prepared.py",
+                "PREPARED_MODEL_BUNDLE_SCHEMA_VERSION",
+            ),
+        },
+    )
+
+
+def _write_fixture_assets(overlay: Path, *, mode: str) -> None:
+    with (overlay / "dependencies/release-lock.toml").open("rb") as stream:
+        release = tomllib.load(stream)
+    package_version = (
+        f"{RELEASE_VERSION}.dev0+candidate.123456789abc"
+        if mode == "candidate"
+        else RELEASE_VERSION
+    )
+    assets = overlay / "src/pyamplicol/assets/prepared_models"
+    for model_source in ("built-in-sm", "built-in-sm-heft"):
+        bundle = _release_bundle(overlay, package_version, model_source=model_source)
+        payload = json.dumps(bundle, default=vars, sort_keys=True).encode()
+        pack = bundle.kernel_pack
+        producer = bundle.compiled_model["producer"]
+        for architecture in ("aarch64", "x86_64"):
+            identifier = f"{model_source}-jit-o2"
+            stem = f"{identifier}-{architecture}"
+            bundle_name = f"{stem}.pyamplicol-model"
+            metadata = {
+                "backend": "jit",
+                "build_contract": {"mode": mode},
+                "bundle": bundle_name,
+                "bundle_sha256": hashlib.sha256(payload).hexdigest(),
+                "bundle_size": len(payload),
+                "dependencies": {
+                    "symbolica_version": pack.dependency_abis["symbolica_version"],
+                    "symbolica_serialization_abi": pack.dependency_abis[
+                        "symbolica_serialization"
+                    ],
+                    "symjit_application_abi": pack.dependency_abis[
+                        "symjit_application"
+                    ],
+                    "symjit_plane_application_abi": pack.dependency_abis[
+                        "symjit_plane_application"
+                    ],
+                    "symjit_version": prepared_models_module._symjit_version(overlay),
+                    "ufo_model_loader_version": release["ufo_model_loader"][
+                        "required_version"
+                    ],
+                },
+                "eager_kernel_abi": bundle.manifest["eager_kernel_abi"],
+                "id": identifier,
+                "jit_optimization_level": 2,
+                "kernel_count": len(pack.kernels),
+                "model": model_source,
+                "prepared_model_bundle_schema": bundle.manifest["schema_version"],
+                "producer": {
+                    "compiled_model_schema": producer["compiled_model_schema_version"],
+                    "model_compiler_sha256": producer["model_compiler_sha256"],
+                    "model_compiler_version": producer["model_compiler_version"],
+                    "model_source_digest": bundle.compiled_model["source"]["digest"],
+                    "package_version": package_version,
+                },
+                "schema_version": 1,
+                "target": pack.target,
+            }
+            (assets / bundle_name).write_bytes(payload)
+            (assets / f"{stem}.metadata.json").write_text(
+                json.dumps(metadata, sort_keys=True), encoding="utf-8"
+            )
+
+
+def test_source_ready_asset_metadata_is_derived_from_bundle_and_source(
+    tmp_path: Path,
+) -> None:
+    overlay = _overlay(tmp_path)
+    asset_root = overlay / "src/pyamplicol/assets/prepared_models"
+    source_bundle = asset_root / "built-in-sm-jit-o2-aarch64.pyamplicol-model"
+    expected_metadata = json.loads(
+        (asset_root / "built-in-sm-jit-o2-aarch64.metadata.json").read_text(
+            encoding="utf-8"
+        )
+    )
+
+    metadata_path, bundle_path = write_candidate_packaged_prepared_model_asset(
+        overlay,
+        source_bundle,
+        tmp_path / "prepared",
+        architecture="aarch64",
+    )
+
+    actual_metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
+    with (ROOT / "dependencies/contributor-lock.toml").open("rb") as stream:
+        contributor = tomllib.load(stream)
+    assert (
+        actual_metadata["dependencies"]["symbolica_version"]
+        == contributor["symbolica"]["candidate_version"]
+    )
+    assert actual_metadata["build_contract"] == {"mode": "candidate"}
+    assert "native_build_inputs_sha256" not in actual_metadata["producer"]
+    assert actual_metadata == expected_metadata
+    assert bundle_path.read_bytes() == source_bundle.read_bytes()
+
+
+def test_release_source_ready_asset_uses_only_release_lock_identity(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    overlay = _release_overlay(tmp_path)
+    assert not (overlay / "dependencies/contributor-lock.toml").exists()
+    source_bundle = tmp_path / "release.pyamplicol-model"
+    source_bundle.write_bytes(b"release prepared bundle fixture")
+    bundle = _release_bundle(overlay)
+    monkeypatch.setattr(
+        prepared_models_module,
+        "_load_prepared_contract",
+        lambda _path: SimpleNamespace(
+            load_prepared_model_bundle=lambda _bundle_path: bundle
+        ),
+    )
+
+    metadata_path, bundle_path = write_release_packaged_prepared_model_asset(
+        overlay,
+        source_bundle,
+        tmp_path / "prepared",
+        architecture="x86_64",
+    )
+
+    metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
+    assert metadata["build_contract"] == {"mode": "release"}
+    assert "native_build_inputs_sha256" not in metadata["producer"]
+    assert metadata["producer"]["package_version"] == RELEASE_VERSION
+    assert metadata["dependencies"]["symbolica_version"] == "3.0.0"
+    assert metadata["dependencies"]["symjit_version"] == "2.26.4"
+    assert bundle_path.read_bytes() == source_bundle.read_bytes()
+
+
+def test_release_source_ready_asset_rejects_candidate_producer_version(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    overlay = _release_overlay(tmp_path)
+    source_bundle = tmp_path / "candidate.pyamplicol-model"
+    source_bundle.write_bytes(b"candidate prepared bundle fixture")
+    bundle = _release_bundle(
+        overlay,
+        f"{RELEASE_VERSION}.dev0+candidate.123456789abc",
+    )
+    monkeypatch.setattr(
+        prepared_models_module,
+        "_load_prepared_contract",
+        lambda _path: SimpleNamespace(
+            load_prepared_model_bundle=lambda _bundle_path: bundle
+        ),
+    )
+
+    with pytest.raises(
+        RuntimeError,
+        match="canonical package version",
+    ):
+        write_release_packaged_prepared_model_asset(
+            overlay,
+            source_bundle,
+            tmp_path / "prepared",
+            architecture="aarch64",
+        )
+
+
+def test_release_source_store_projects_over_candidate_package_assets(
+    tmp_path: Path,
+) -> None:
+    overlay = _release_overlay(tmp_path)
+    package_assets = overlay / "src/pyamplicol/assets/prepared_models"
+    package_init = (package_assets / "__init__.py").read_bytes()
+    store = _release_store(overlay)
+    expected: dict[str, bytes] = {}
+    for path in store.iterdir():
+        if path.name == "README.md":
+            continue
+        payload = f"release:{path.name}\n".encode()
+        path.write_bytes(payload)
+        expected[path.name] = payload
+
+    assert project_release_packaged_prepared_model_store(
+        overlay,
+        require_store=True,
+    )
+
+    assert not (overlay / "release_assets").exists()
+    assert (package_assets / "__init__.py").read_bytes() == package_init
+    assert {
+        path.name: path.read_bytes()
+        for path in package_assets.iterdir()
+        if path.name != "__init__.py"
+    } == expected
+
+
+def test_release_staging_accepts_older_package_producer(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    overlay = _release_overlay(tmp_path)
+    _release_store(overlay)
+
+    assert project_release_packaged_prepared_model_store(
+        overlay,
+        require_store=True,
+    )
+    asset_root = overlay / "src/pyamplicol/assets/prepared_models"
+    for metadata_path in asset_root.glob("*.metadata.json"):
+        metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
+        metadata["build_contract"] = {"mode": "release"}
+        metadata["producer"]["package_version"] = "0.1.0"
+        metadata_path.write_text(json.dumps(metadata), encoding="utf-8")
+
+    original_contract = prepared_models_module._load_prepared_contract(
+        overlay / "src/pyamplicol/models/prepared.py"
+    )
+
+    def load_with_older_producer(path: Path) -> object:
+        bundle = original_contract.load_prepared_model_bundle(path)
+        compiled_model = dict(bundle.compiled_model)
+        producer = dict(compiled_model["producer"])
+        producer["pyamplicol"] = "0.1.0"
+        compiled_model["producer"] = producer
+        bundle.kernel_pack.producer["version"] = "0.1.0"
+        return SimpleNamespace(
+            backend=bundle.backend,
+            compiled_model=compiled_model,
+            kernel_pack=bundle.kernel_pack,
+            manifest=bundle.manifest,
+        )
+
+    monkeypatch.setattr(
+        prepared_models_module,
+        "_load_prepared_contract",
+        lambda _path: SimpleNamespace(
+            load_prepared_model_bundle=load_with_older_producer
+        ),
+    )
+    stage_packaged_prepared_models(overlay, "release")
+
+
+def test_release_source_store_is_required_only_for_source_checkout(
+    tmp_path: Path,
+) -> None:
+    overlay = _release_overlay(tmp_path)
+
+    with pytest.raises(RuntimeError, match="source store is missing"):
+        project_release_packaged_prepared_model_store(
+            overlay,
+            require_store=True,
+        )
+
+    assert (
+        project_release_packaged_prepared_model_store(
+            overlay,
+            require_store=False,
+        )
+        is False
+    )
+
+
+@pytest.mark.parametrize(
+    ("mutation", "match"),
+    [
+        ("missing", "inventory is invalid"),
+        ("unexpected", "inventory is invalid"),
+        ("container", "container inventory is invalid"),
+    ],
+)
+def test_release_source_store_rejects_incomplete_or_mixed_inventory(
+    tmp_path: Path,
+    mutation: str,
+    match: str,
+) -> None:
+    overlay = _release_overlay(tmp_path)
+    store = _release_store(overlay)
+    if mutation == "missing":
+        next(store.glob("*.metadata.json")).unlink()
+    elif mutation == "unexpected":
+        (store / "candidate-only.json").write_text("{}\n", encoding="utf-8")
+    else:
+        (overlay / "release_assets" / "candidate-pack").mkdir()
+
+    with pytest.raises(RuntimeError, match=match):
+        project_release_packaged_prepared_model_store(
+            overlay,
+            require_store=True,
+        )
+
+
+def test_release_source_store_rejects_wrong_build_mode(
+    tmp_path: Path,
+) -> None:
+    overlay = _release_overlay(tmp_path)
+    store = _release_store(overlay)
+    for metadata_path in store.glob("*.metadata.json"):
+        metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
+        metadata["build_contract"] = {"mode": "candidate"}
+        metadata_path.write_text(json.dumps(metadata), encoding="utf-8")
+
+    project_release_packaged_prepared_model_store(
+        overlay,
+        require_store=True,
+    )
+
+    with pytest.raises(RuntimeError, match="not the active 'release'"):
+        stage_packaged_prepared_models(overlay, "release")
+
+
+def test_store_discard_preserves_canonical_package_assets(
+    tmp_path: Path,
+) -> None:
+    overlay = _release_overlay(tmp_path)
+    package_assets = overlay / "src/pyamplicol/assets/prepared_models"
+    before = {path.name: path.read_bytes() for path in package_assets.iterdir()}
+    _release_store(overlay)
+
+    discard_release_packaged_prepared_model_store(overlay)
+
+    assert not (overlay / "release_assets").exists()
+    assert {path.name: path.read_bytes() for path in package_assets.iterdir()} == before
+
+
+def test_candidate_wheel_staging_accepts_exact_packaged_model(
+    tmp_path: Path,
+) -> None:
+    overlay = _overlay(tmp_path)
+    bundle = (
+        overlay
+        / "src"
+        / "pyamplicol"
+        / "assets"
+        / "prepared_models"
+        / "built-in-sm-jit-o2-aarch64.pyamplicol-model"
+    )
+    before = bundle.read_bytes()
+    stage_packaged_prepared_models(overlay, "candidate")
+    assert bundle.read_bytes() == before
+
+
+def test_candidate_wheel_staging_ignores_legacy_build_info_fingerprint(
+    tmp_path: Path,
+) -> None:
+    overlay = _overlay(tmp_path)
+    build_info_path = overlay / "src" / "pyamplicol" / "_build_info.json"
+    build_info = json.loads(build_info_path.read_text(encoding="utf-8"))
+    build_info["candidate_fingerprint"] = "0" * 12
+    version = str(build_info["version"])
+    build_info["version"] = version.rsplit("+candidate.", maxsplit=1)[0] + (
+        "+candidate." + "0" * 12
+    )
+    build_info_path.write_text(json.dumps(build_info), encoding="utf-8")
+
+    stage_packaged_prepared_models(overlay, "candidate")
+
+
+def test_candidate_wheel_staging_rejects_internal_producer_version_mismatch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    overlay = _overlay(tmp_path)
+    original_contract = prepared_models_module._load_prepared_contract(
+        overlay / "src/pyamplicol/models/prepared.py"
+    )
+
+    def load_with_mismatched_producer(path: Path) -> object:
+        bundle = original_contract.load_prepared_model_bundle(path)
+        compiled_model = dict(bundle.compiled_model)
+        producer = dict(compiled_model["producer"])
+        producer["pyamplicol"] = "0.1.0.dev0+candidate.000000000000"
+        compiled_model["producer"] = producer
+        return SimpleNamespace(
+            backend=bundle.backend,
+            compiled_model=compiled_model,
+            kernel_pack=bundle.kernel_pack,
+            manifest=bundle.manifest,
+        )
+
+    monkeypatch.setattr(
+        prepared_models_module,
+        "_load_prepared_contract",
+        lambda _path: SimpleNamespace(
+            load_prepared_model_bundle=load_with_mismatched_producer
+        ),
+    )
+
+    with pytest.raises(RuntimeError, match="package version disagrees with metadata"):
+        stage_packaged_prepared_models(overlay, "candidate")
+
+
+def test_wheel_staging_accepts_metadata_without_native_build_identity(
+    tmp_path: Path,
+) -> None:
+    overlay = _overlay(tmp_path)
+    asset_root = overlay / "src/pyamplicol/assets/prepared_models"
+    for metadata_path in asset_root.glob("*.metadata.json"):
+        metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
+        assert "native_build_inputs_sha256" not in metadata["producer"]
+
+    stage_packaged_prepared_models(overlay, "candidate")
+
+
+def test_wheel_staging_rejects_built_in_source_edits(tmp_path: Path) -> None:
+    overlay = _overlay(tmp_path)
+    source = overlay / "src" / "pyamplicol" / "models" / "builtin" / "model.py"
+    source.write_text(
+        source.read_text(encoding="utf-8") + "\n# drift\n",
+        encoding="utf-8",
+    )
+    with pytest.raises(RuntimeError, match="model_source_digest is stale"):
+        stage_packaged_prepared_models(overlay, "candidate")
+
+
+def test_wheel_staging_treats_model_compiler_digest_as_provenance(
+    tmp_path: Path,
+) -> None:
+    overlay = _overlay(tmp_path)
+    source = overlay / "src/pyamplicol/models/loading.py"
+    source.write_text(
+        source.read_text(encoding="utf-8") + "\n# drift\n",
+        encoding="utf-8",
+    )
+
+    stage_packaged_prepared_models(overlay, "candidate")
+
+
+def test_wheel_staging_rejects_bundle_hash_drift(tmp_path: Path) -> None:
+    overlay = _overlay(tmp_path)
+    bundle = (
+        overlay
+        / "src"
+        / "pyamplicol"
+        / "assets"
+        / "prepared_models"
+        / "built-in-sm-jit-o2-aarch64.pyamplicol-model"
+    )
+    bundle.write_bytes(bundle.read_bytes() + b"tampered")
+    with pytest.raises(RuntimeError, match="size does not match"):
+        stage_packaged_prepared_models(overlay, "candidate")
+
+
+def test_wheel_staging_requires_both_architecture_assets(tmp_path: Path) -> None:
+    overlay = _overlay(tmp_path)
+    asset_root = overlay / "src" / "pyamplicol" / "assets" / "prepared_models"
+    (asset_root / "built-in-sm-jit-o2-x86_64.pyamplicol-model").unlink()
+
+    with pytest.raises(RuntimeError, match=r"missing:.*x86_64"):
+        stage_packaged_prepared_models(overlay, "candidate")
+
+
+def test_wheel_staging_rejects_architecture_target_drift(tmp_path: Path) -> None:
+    overlay = _overlay(tmp_path)
+    metadata_path = (
+        overlay
+        / "src"
+        / "pyamplicol"
+        / "assets"
+        / "prepared_models"
+        / "built-in-sm-jit-o2-x86_64.metadata.json"
+    )
+    metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
+    metadata["target"]["target_triple"] = "symjit-storage-v3-aarch64"
+    metadata_path.write_text(json.dumps(metadata), encoding="utf-8")
+
+    with pytest.raises(RuntimeError, match="target does not match"):
+        stage_packaged_prepared_models(overlay, "candidate")
+
+
+def test_wheel_staging_rejects_unexpected_prepared_model_tree(
+    tmp_path: Path,
+) -> None:
+    overlay = _overlay(tmp_path)
+    unexpected = (
+        overlay / "src" / "pyamplicol" / "assets" / "prepared_models" / "second-pack"
+    )
+    unexpected.mkdir()
+    with pytest.raises(RuntimeError, match="unexpected: second-pack"):
+        stage_packaged_prepared_models(overlay, "candidate")
+
+
+def test_candidate_payload_fails_closed_in_release_mode(tmp_path: Path) -> None:
+    overlay = _overlay(tmp_path)
+    with pytest.raises(RuntimeError, match="not the active 'release'"):
+        stage_packaged_prepared_models(overlay, "release")
+
+
+def test_release_payload_fails_closed_in_candidate_mode(tmp_path: Path) -> None:
+    overlay = _overlay(tmp_path)
+    asset_root = overlay / "src/pyamplicol/assets/prepared_models"
+    for metadata_path in asset_root.glob("*.metadata.json"):
+        metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
+        metadata["build_contract"] = {"mode": "release"}
+        metadata_path.write_text(json.dumps(metadata), encoding="utf-8")
+
+    with pytest.raises(RuntimeError, match="not the active 'candidate'"):
+        stage_packaged_prepared_models(overlay, "candidate")
diff --git a/pyamplicol/tests/unit/test_packaging_hygiene.py b/pyamplicol/tests/unit/test_packaging_hygiene.py
new file mode 100644
index 0000000000..ef7f16a8d2
--- /dev/null
+++ b/pyamplicol/tests/unit/test_packaging_hygiene.py
@@ -0,0 +1,227 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "build_backend"))
+sys.path.insert(0, str(ROOT / "tools" / "release"))
+
+import package_version  # noqa: E402
+import sync_version  # noqa: E402
+
+RELEASE_VERSION = sync_version.madgraph_version()
+
+
+def _copy_version_contract(tmp_path: Path) -> Path:
+    root = tmp_path / "source"
+    (root / "dependencies").mkdir(parents=True)
+    for relative in (
+        Path("Cargo.toml"),
+        Path("pyproject.toml"),
+        Path("dependencies/release-lock.toml"),
+        Path("dependencies/contributor-lock.toml"),
+    ):
+        shutil.copy2(ROOT / relative, root / relative)
+    return root
+
+
+def test_cargo_workspace_is_the_canonical_package_version() -> None:
+    assert package_version.canonical_package_version(ROOT) == RELEASE_VERSION
+
+
+def test_package_version_contract_rejects_release_lock_drift(tmp_path: Path) -> None:
+    root = _copy_version_contract(tmp_path)
+    lock = root / "dependencies" / "release-lock.toml"
+    text = lock.read_text(encoding="utf-8")
+    lock.write_text(
+        text.replace(
+            f'version = "{RELEASE_VERSION}"',
+            'version = "9.9.9"',
+            1,
+        ),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(RuntimeError, match="package version mismatch"):
+        package_version.canonical_package_version(root)
+
+
+def test_package_version_contract_rejects_static_python_version(
+    tmp_path: Path,
+) -> None:
+    root = _copy_version_contract(tmp_path)
+    pyproject = root / "pyproject.toml"
+    pyproject.write_text(
+        pyproject.read_text(encoding="utf-8").replace(
+            'dynamic = ["version"]',
+            'version = "0.1.0"',
+            1,
+        ),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(RuntimeError, match=r"project\.version as dynamic"):
+        package_version.canonical_package_version(root)
+
+
+def test_contributor_and_release_locks_share_compatibility_abi(
+    tmp_path: Path,
+) -> None:
+    root = _copy_version_contract(tmp_path)
+    package_version.check_contributor_lock_consistency(root)
+    lock = root / "dependencies" / "contributor-lock.toml"
+    lock.write_text(
+        lock.read_text(encoding="utf-8").replace(
+            'symbolica_serialization = "symbolica-bincode2-v1"',
+            'symbolica_serialization = "incompatible-test-abi"',
+            1,
+        ),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(RuntimeError, match="dependency locks disagree"):
+        package_version.check_contributor_lock_consistency(root)
+
+
+def test_contributor_and_release_locks_share_symjit_plane_abi(
+    tmp_path: Path,
+) -> None:
+    root = _copy_version_contract(tmp_path)
+    package_version.check_contributor_lock_consistency(root)
+    lock = root / "dependencies" / "contributor-lock.toml"
+    lock.write_text(
+        lock.read_text(encoding="utf-8").replace(
+            'symjit_plane_application = "pyamplicol-symjit-plane-application-v2"',
+            'symjit_plane_application = "incompatible-test-abi"',
+            1,
+        ),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(RuntimeError, match="plane-application ABI"):
+        package_version.check_contributor_lock_consistency(root)
+
+
+def test_contributor_lock_has_no_local_symjit_source_or_patch_inventory() -> None:
+    contributor = (ROOT / "dependencies/contributor-lock.toml").read_text(
+        encoding="utf-8"
+    )
+
+    assert "candidate_version = \"2.26.0\"" in contributor
+    assert "revision = \"530304a07d1be6d5abc80291aa5e92cf28ac5546\"" in contributor
+    assert "\npatches =" not in contributor
+    assert not tuple((ROOT / "dependencies/patches/symjit").rglob("*.patch"))
+
+
+def test_nix_shell_provides_python_build_frontend() -> None:
+    flake = (ROOT / "flake.nix").read_text(encoding="utf-8")
+    match = re.search(
+        r"python = pkgs\.python311\.withPackages \(.*?\[(.*?)\]",
+        flake,
+        flags=re.DOTALL,
+    )
+    assert match is not None
+    assert re.search(r"(?m)^\s+build\s*$", match.group(1)) is not None
+    assert re.search(r"(?m)^\s+m4\s*$", flake) is not None
+    assert "pkgs.lsof" in flake
+    assert "pkgs.procps" in flake
+    assert '"x86_64-darwin"' not in flake
+    assert re.search(r"(?m)^\s+lhapdf\s*$", flake) is None
+
+
+def test_dev_install_keeps_all_build_caches_inside_the_workspace() -> None:
+    justfile = (ROOT / "justfile").read_text(encoding="utf-8")
+    match = re.search(
+        r"(?ms)^dev-install(?: [^:\n]+)?:.*?"
+        r"(?=^[A-Za-z0-9_-]+(?: [^:\n]+)?:|\Z)",
+        justfile,
+    )
+    assert match is not None
+    recipe = match.group(0)
+    assert 'dev_cache := ".artifacts/dev-install"' in justfile
+    for variable in (
+        "TMPDIR",
+        "CARGO_HOME",
+        "CARGO_TARGET_DIR",
+        "PIP_CACHE_DIR",
+        "XDG_CACHE_HOME",
+        "PYTHONPYCACHEPREFIX",
+    ):
+        assert recipe.count(f'{variable}="$PWD/{{{{dev_cache}}}}/') == 1
+    assert recipe.count('PYAMPLICOL_CANDIDATE_CACHE_ROOT="$PWD/{{dev_cache}}"') == 1
+    assert "*INSTALLER_ARGS" in recipe
+    assert "dependencies/install_dependencies.py {{INSTALLER_ARGS}}" in recipe
+    assert "prepare_source_runtime.py" not in recipe
+    assert "PYAMPLICOL_BUILD_MODE=candidate" not in recipe
+
+
+def test_dev_test_defaults_to_release_and_preserves_explicit_candidate_mode() -> None:
+    justfile = (ROOT / "justfile").read_text(encoding="utf-8")
+    assert (
+        'build_mode := env_var_or_default("PYAMPLICOL_BUILD_MODE", "release")'
+        in justfile
+    )
+    recipe = justfile.split("\ndev-test: _source-checkout\n", 1)[1].split("\n\n", 1)[0]
+    assert "PYAMPLICOL_BUILD_MODE={{build_mode}} just source-gate" in recipe
+    assert 'if [ "{{build_mode}}" = candidate ]' in recipe
+    assert "PYAMPLICOL_BUILD_MODE=release just test-deployment" in recipe
+    assert "PYAMPLICOL_BUILD_MODE=candidate just test-deployment-candidate" in recipe
+
+
+@pytest.mark.parametrize(
+    "recipe",
+    (
+        "dev-install",
+        "dev-build",
+        "dev-test",
+        "legacy-physics",
+        "legacy-physics-verify",
+        "independent-physics-oracle",
+        "test-deployment-candidate",
+        "release-artifacts",
+        "publish-dry-run",
+    ),
+)
+def test_source_checkout_commands_fail_immediately_from_sdist(
+    tmp_path: Path,
+    recipe: str,
+) -> None:
+    just = shutil.which("just")
+    if just is None:
+        pytest.skip("just is not installed")
+    source = tmp_path / "pyamplicol-0.1.0"
+    source.mkdir()
+    shutil.copy2(ROOT / "justfile", source / "justfile")
+    marker = tmp_path / "python-was-invoked"
+    fake_python = tmp_path / "python-must-not-run"
+    fake_python.write_text(
+        '#!/bin/sh\nprintf invoked > "$PYAMPLICOL_TEST_MARKER"\nexit 99\n',
+        encoding="utf-8",
+    )
+    fake_python.chmod(0o755)
+    environment = os.environ.copy()
+    environment["PYTHON"] = str(fake_python)
+    environment["PYAMPLICOL_TEST_MARKER"] = str(marker)
+
+    completed = subprocess.run(
+        [just, recipe],
+        cwd=source,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert completed.returncode != 0
+    assert "requires a full pyAmpliCol Git source checkout" in (
+        completed.stdout + completed.stderr
+    )
+    assert not marker.exists()
diff --git a/pyamplicol/tests/unit/test_performance_report_aggregate_audit.py b/pyamplicol/tests/unit/test_performance_report_aggregate_audit.py
new file mode 100644
index 0000000000..d74d6dee6f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_aggregate_audit.py
@@ -0,0 +1,202 @@
+# SPDX-License-Identifier: 0BSD
+"""Tests for architecture-report aggregation authentication."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.aggregate_audit import (
+    AggregateAuditError,
+    audit_aggregate_report,
+)
+
+
+def _git(repo: Path, *arguments: str) -> str:
+    return subprocess.run(
+        ("git", *arguments),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+
+def _write(path: Path, value: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(value, encoding="utf-8")
+
+
+def _commit(repo: Path, message: str) -> str:
+    _git(repo, "add", ".")
+    _git(repo, "commit", "-m", message)
+    return _git(repo, "rev-parse", "HEAD")
+
+
+def _seed(repo: Path) -> str:
+    _git(repo, "init")
+    _git(repo, "config", "user.email", "report@example.invalid")
+    _git(repo, "config", "user.name", "Report Test")
+    for profile in ("macbook_M3", "x86_EPYC"):
+        root = repo / "docs/performance_reports" / profile
+        _write(root / "README.md", "fixed prose\n")
+        _write(root / "results/data.json", '{"value":0}\n')
+        _write(root / "pyAmpliCol.pdf", "reset\n")
+    _write(repo / "src/runtime.py", "fixed = True\n")
+    return _commit(repo, "base")
+
+
+def _profile_commit(repo: Path, profile: str, branch: str, value: str) -> str:
+    _git(repo, "switch", "-c", branch)
+    root = repo / "docs/performance_reports" / profile
+    _write(root / "results/data.json", f'{{"value":{value}}}\n')
+    _write(root / "result_validation_summary.tex", f"summary {value}\n")
+    _write(root / "pyAmpliCol.pdf", f"pdf {value}\n")
+    return _commit(repo, profile)
+
+
+def test_accepts_exact_subtrees_from_two_audited_profiles(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    base = _seed(repo)
+    mac = _profile_commit(repo, "macbook_M3", "mac", "1")
+    _git(repo, "switch", "--detach", base)
+    x86 = _profile_commit(repo, "x86_EPYC", "x86", "2")
+    _git(repo, "switch", "-c", "aggregate", mac)
+    _git(repo, "merge", "--no-ff", "--no-edit", x86)
+    aggregate = _git(repo, "rev-parse", "HEAD")
+
+    result = audit_aggregate_report(
+        repo,
+        base_revision=base,
+        revision=aggregate,
+        audited_profiles={"macbook_M3": mac, "x86_EPYC": x86},
+    )
+
+    assert result["status"] == "ok"
+    assert result["changed_profiles"] == ["macbook_M3", "x86_EPYC"]
+
+
+def test_accepts_audited_profile_after_main_advances_independently(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    measured_source = _seed(repo)
+    mac = _profile_commit(repo, "macbook_M3", "mac", "1")
+    _git(repo, "switch", "--detach", measured_source)
+    _git(repo, "switch", "-c", "advanced-main")
+    _write(repo / "src/runtime.py", "fixed = 'later-main-change'\n")
+    landing_base = _commit(repo, "advance main independently")
+    _git(repo, "merge", "--no-ff", "--no-edit", mac)
+    aggregate = _git(repo, "rev-parse", "HEAD")
+
+    result = audit_aggregate_report(
+        repo,
+        base_revision=landing_base,
+        revision=aggregate,
+        audited_profiles={"macbook_M3": mac},
+    )
+
+    assert result["status"] == "ok"
+    assert result["base_revision"] == landing_base
+    assert result["changed_profiles"] == ["macbook_M3"]
+
+
+@pytest.mark.parametrize(
+    ("relative", "mutation"),
+    (
+        ("docs/performance_reports/macbook_M3/README.md", "prose\n"),
+        ("src/runtime.py", "fixed = False\n"),
+    ),
+)
+def test_rejects_non_output_changes(
+    tmp_path: Path,
+    relative: str,
+    mutation: str,
+) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    base = _seed(repo)
+    mac = _profile_commit(repo, "macbook_M3", "mac", "1")
+    _write(repo / relative, mutation)
+    revision = _commit(repo, "forbidden")
+
+    with pytest.raises(
+        AggregateAuditError,
+        match="non-publication output",
+    ):
+        audit_aggregate_report(
+            repo,
+            base_revision=base,
+            revision=revision,
+            audited_profiles={"macbook_M3": mac},
+        )
+
+
+def test_rejects_changed_profile_without_audited_revision(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    base = _seed(repo)
+    mac = _profile_commit(repo, "macbook_M3", "mac", "1")
+
+    with pytest.raises(AggregateAuditError, match="without audited revisions"):
+        audit_aggregate_report(
+            repo,
+            base_revision=base,
+            revision=mac,
+            audited_profiles={"x86_EPYC": base},
+        )
+
+
+def test_rejects_profile_subtree_that_differs_from_attestation(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    base = _seed(repo)
+    mac = _profile_commit(repo, "macbook_M3", "mac", "1")
+    _write(
+        repo / "docs/performance_reports/macbook_M3/results/data.json",
+        '{"value":3}\n',
+    )
+    aggregate = _commit(repo, "tampered")
+
+    with pytest.raises(AggregateAuditError, match="subtree differs"):
+        audit_aggregate_report(
+            repo,
+            base_revision=base,
+            revision=aggregate,
+            audited_profiles={"macbook_M3": mac},
+        )
+
+
+def test_rejects_executable_or_deleted_output(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    base = _seed(repo)
+    mac = _profile_commit(repo, "macbook_M3", "mac", "1")
+    pdf = repo / "docs/performance_reports/macbook_M3/pyAmpliCol.pdf"
+    pdf.chmod(0o755)
+    executable = _commit(repo, "executable")
+
+    with pytest.raises(AggregateAuditError, match="non-executable"):
+        audit_aggregate_report(
+            repo,
+            base_revision=base,
+            revision=executable,
+            audited_profiles={"macbook_M3": executable},
+        )
+
+    _git(repo, "reset", "--hard", mac)
+    pdf.unlink()
+    deleted = _commit(repo, "deleted")
+    with pytest.raises(AggregateAuditError, match="added or modified"):
+        audit_aggregate_report(
+            repo,
+            base_revision=base,
+            revision=deleted,
+            audited_profiles={"macbook_M3": deleted},
+        )
diff --git a/pyamplicol/tests/unit/test_performance_report_agreements.py b/pyamplicol/tests/unit/test_performance_report_agreements.py
new file mode 100644
index 0000000000..405409baeb
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_agreements.py
@@ -0,0 +1,974 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections import Counter
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+import tools.performance_report.final_audit as final_audit_module
+from tools.performance_report.agreements import (
+    BUILTIN_UFO_RECURRENCE,
+    DIRECT_AGREEMENT_FIELD,
+    DIRECT_AGREEMENT_V2_ABI,
+    LC_COMMON_COMPONENT_ABI,
+    LC_COMMON_COMPONENT_FIELD,
+    LC_CROSS_LAYOUT_COMPONENT,
+    LC_LEGACY_PYAMPLICOL_COMPONENT,
+    MADGRAPH_COMPARISON_FIELD,
+    MADGRAPH_FULL_COLOUR,
+    Z_RECURRENCE_CROSS_MODE,
+    AgreementError,
+    agreement_edges,
+    attach_direct_agreements,
+    evaluate_lc_common_component,
+    incoming_agreement_edges,
+    independent_numerical_authorities,
+    madgraph_candidate_precision,
+    madgraph_comparison_record,
+    requires_independent_numerical_authority,
+    validation_baseline_is_required,
+)
+from tools.performance_report.artifacts import ArtifactStore
+from tools.performance_report.cache import (
+    build_reset_cache,
+    empty_measurement,
+    validate_cache,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.final_audit import (
+    FinalAuditError,
+    _audit_replayed_direct_agreements,
+    _direct_replay_category,
+    _ReplayObservation,
+)
+from tools.performance_report.models import (
+    ArtifactPolicy,
+    ExecutionMode,
+    ResultStatus,
+    Workload,
+)
+from tools.performance_report.runner import (
+    SelectorContract,
+    pointwise_validation,
+)
+from tools.performance_report.scheduler import CampaignSettings, plan_campaign
+
+
+def _selector() -> dict[str, object]:
+    return {
+        "selected_color_flow_ids": ["flow:2,1"],
+        "selected_color_words": [[2, 1]],
+        "all_flow_helicity_ids": ["h:-1,+1,-1"],
+        "all_flow_source_helicities": {"1": -1, "2": 1, "3": -1},
+        "point_digest": "a" * 64,
+    }
+
+
+def _measurement(cell_id: str, value: float, component: float) -> dict[str, object]:
+    selector = _selector()
+    return {
+        "status": ResultStatus.OK.value,
+        "matrix_element": value,
+        "selector_contract": selector,
+        "validation": {
+            "status": ResultStatus.OK.value,
+            DIRECT_AGREEMENT_FIELD: [],
+            LC_COMMON_COMPONENT_FIELD: {
+                "abi": LC_COMMON_COMPONENT_ABI,
+                "cell_id": cell_id,
+                "value": component,
+                "point_digest": selector["point_digest"],
+                "helicity_ids": selector["all_flow_helicity_ids"],
+                "color_flow_ids": selector["selected_color_flow_ids"],
+            },
+        },
+        "failure": None,
+    }
+
+
+def _cell(
+    dataset_id: str,
+    *,
+    workload: Workload,
+    variant: str | None = None,
+):
+    return next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == dataset_id
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is workload
+        and cell.variant == variant
+    )
+
+
+def test_lc_common_component_uses_signed_zero_runtime_alias() -> None:
+    cell = _cell(
+        "matrix_recurrence_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+    contract = SelectorContract(
+        selected_color_flow_ids=("flow:2,1",),
+        selected_color_words=((2, 1),),
+        all_flow_helicity_ids=("h:-1,+1,-1,+1,-1,0",),
+        all_flow_source_helicities=(
+            (1, -1),
+            (2, 1),
+            (3, -1),
+            (4, 1),
+            (5, -1),
+            (6, 0),
+        ),
+        point_digest="a" * 64,
+    )
+
+    class Runtime:
+        def evaluate_resolved(self, _points: object, **selectors: object) -> object:
+            assert selectors["helicities"] == ("h:-1,+1,-1,+1,-1,+0",)
+            return SimpleNamespace(
+                helicity_ids=("h:-1,+1,-1,+1,-1,+0",),
+                color_ids=("flow:2,1",),
+                values=(((1.0 + 0.0j,),),),
+            )
+
+    component = evaluate_lc_common_component(
+        Runtime(),
+        object(),
+        cell=cell,
+        contract=contract,
+    )
+
+    assert component["value"] == 1.0
+    assert component["helicity_ids"] == ["h:-1,+1,-1,+1,-1,0"]
+
+
+@pytest.mark.parametrize("target_position", (0, 1))
+def test_selected_flow_common_component_selects_full_helicity_axis_by_id(
+    target_position: int,
+) -> None:
+    cell = _cell("matrix_compiled_builtin_sm_lc", workload=Workload.SELECTED_FLOW)
+    contract = SelectorContract.from_mapping(_selector())
+    helicity_ids = ["h:+1,-1,+1"]
+    values = [(19.0 + 0.0j,)]
+    helicity_ids.insert(target_position, contract.runtime_all_flow_helicity_ids[0])
+    values.insert(target_position, (7.0 + 0.0j,))
+
+    class Runtime:
+        def evaluate_resolved(self, _points: object, **selectors: object) -> object:
+            assert selectors == {
+                "precision": 16,
+                "helicities": None,
+                "color_flows": contract.selected_color_flow_ids,
+            }
+            return SimpleNamespace(
+                helicity_ids=tuple(helicity_ids),
+                color_ids=contract.selected_color_flow_ids,
+                values=(tuple(values),),
+            )
+
+    component = evaluate_lc_common_component(
+        Runtime(),
+        object(),
+        cell=cell,
+        contract=contract,
+    )
+    assert component["value"] == 7.0
+    assert component["helicity_ids"] == list(contract.all_flow_helicity_ids)
+
+
+@pytest.mark.parametrize(
+    ("helicity_ids", "values", "message"),
+    (
+        (("h:+1,-1,+1",), (((1.0,),),), "helicity axis"),
+        (("h:-1,+1,-1", "h:-1,+1,-1"), (((1.0,), (2.0,)),), "helicity axis"),
+        (("h:-1,+1,-1", "h:+1,-1,+1"), (((1.0,),),), "not a scalar"),
+        (("h:-1,+1,-1",), (((1.0, 2.0),),), "not a scalar"),
+    ),
+)
+def test_selected_flow_common_component_rejects_invalid_axes_or_shape(
+    helicity_ids: tuple[str, ...],
+    values: object,
+    message: str,
+) -> None:
+    cell = _cell("matrix_compiled_builtin_sm_lc", workload=Workload.SELECTED_FLOW)
+    contract = SelectorContract.from_mapping(_selector())
+
+    class Runtime:
+        def evaluate_resolved(self, _points: object, **_selectors: object) -> object:
+            return SimpleNamespace(
+                helicity_ids=helicity_ids,
+                color_ids=contract.selected_color_flow_ids,
+                values=values,
+            )
+
+    with pytest.raises(AgreementError, match=message):
+        evaluate_lc_common_component(Runtime(), object(), cell=cell, contract=contract)
+
+
+def test_canonical_n4_direct_agreement_graph_has_exact_locked_counts() -> None:
+    counts = Counter(edge.kind for edge in agreement_edges(maximum_n_final=4))
+
+    assert counts == {
+        BUILTIN_UFO_RECURRENCE: 140,
+        Z_RECURRENCE_CROSS_MODE: 80,
+        LC_CROSS_LAYOUT_COMPONENT: 254,
+        LC_LEGACY_PYAMPLICOL_COMPONENT: 221,
+        MADGRAPH_FULL_COLOUR: 132,
+    }
+    assert Counter(
+        _direct_replay_category(edge) for edge in agreement_edges(maximum_n_final=4)
+    ) == {
+        "fully-replayed-pyamplicol": 441,
+        "replayed-pyamplicol-vs-authenticated-legacy": 221,
+        "authenticated-stored-legacy-layout": 33,
+        "authenticated-stored-madgraph": 132,
+    }
+
+
+def test_full_direct_agreement_graph_excludes_unavailable_four_line_legacy() -> None:
+    edges = agreement_edges()
+    counts = Counter(edge.kind for edge in edges)
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == "matrix_recurrence_builtin_sm_lc"
+        and cell.process_key == "dd_4q_lines"
+        and cell.n_final == 6
+        and cell.workload is Workload.ALL_FLOW
+    )
+    legacy = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == "reference_amplicol_lc"
+        and cell.process_key == "dd_4q_lines"
+        and cell.n_final == 6
+        and cell.workload is Workload.ALL_FLOW
+    )
+
+    assert counts == {
+        BUILTIN_UFO_RECURRENCE: 332,
+        Z_RECURRENCE_CROSS_MODE: 180,
+        LC_CROSS_LAYOUT_COMPONENT: 690,
+        LC_LEGACY_PYAMPLICOL_COMPONENT: 571,
+        MADGRAPH_FULL_COLOUR: 200,
+    }
+    assert {edge.kind for edge in incoming_agreement_edges(candidate)} == {
+        LC_CROSS_LAYOUT_COMPONENT
+    }
+    assert incoming_agreement_edges(legacy) == ()
+
+    measurable_ids = {
+        cell.cell_id
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is None
+    }
+    measurable_edges = tuple(
+        edge
+        for edge in edges
+        if edge.candidate.cell_id in measurable_ids
+        and edge.baseline.cell_id in measurable_ids
+    )
+    assert Counter(edge.kind for edge in measurable_edges) == {
+        BUILTIN_UFO_RECURRENCE: 332,
+        Z_RECURRENCE_CROSS_MODE: 156,
+        LC_CROSS_LAYOUT_COMPONENT: 678,
+        LC_LEGACY_PYAMPLICOL_COMPONENT: 559,
+        MADGRAPH_FULL_COLOUR: 200,
+    }
+    assert Counter(_direct_replay_category(edge) for edge in measurable_edges) == {
+        "fully-replayed-pyamplicol": 1063,
+        "replayed-pyamplicol-vs-authenticated-legacy": 559,
+        "authenticated-stored-legacy-layout": 103,
+        "authenticated-stored-madgraph": 200,
+    }
+
+
+@pytest.mark.parametrize(
+    "process_key",
+    ("dd_3q_lines", "dd_3q_identical_lines"),
+)
+def test_three_line_lc_keeps_optional_legacy_and_required_layout_agreements(
+    process_key: str,
+) -> None:
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == "matrix_recurrence_builtin_sm_lc"
+        and cell.process_key == process_key
+        and cell.n_final == 4
+        and cell.workload is Workload.ALL_FLOW
+    )
+
+    edges = incoming_agreement_edges(candidate)
+    assert {edge.kind for edge in edges} == {
+        LC_CROSS_LAYOUT_COMPONENT,
+        LC_LEGACY_PYAMPLICOL_COMPONENT,
+    }
+    assert {edge.kind for edge in edges if edge.required} == {LC_CROSS_LAYOUT_COMPONENT}
+    assert {edge.kind for edge in edges if not edge.required} == {
+        LC_LEGACY_PYAMPLICOL_COMPONENT
+    }
+
+
+def test_optional_legacy_agreement_can_be_absent_but_required_layout_cannot() -> None:
+    candidate = _cell(
+        "matrix_compiled_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+    edges = incoming_agreement_edges(candidate)
+    layout = next(edge for edge in edges if edge.required)
+    topology = _measurement(layout.baseline.cell_id, 1.0, 0.25)
+    union = _measurement(candidate.cell_id, 1.0, 0.25)
+
+    attach_direct_agreements(
+        candidate,
+        union,
+        {layout.baseline.cell_id: topology},
+    )
+
+    assert union["status"] == ResultStatus.OK.value
+    assert [
+        record["edge_kind"] for record in union["validation"][DIRECT_AGREEMENT_FIELD]
+    ] == [LC_CROSS_LAYOUT_COMPONENT]
+
+    missing_required = _measurement(candidate.cell_id, 1.0, 0.25)
+    with pytest.raises(RuntimeError, match="direct-agreement peers differ"):
+        attach_direct_agreements(candidate, missing_required, {})
+
+
+@pytest.mark.parametrize("mismatch", (False, True))
+def test_unverified_candidate_still_enforces_hard_direct_agreement(
+    mismatch: bool,
+) -> None:
+    candidate = _cell(
+        "matrix_compiled_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+    edge = next(item for item in incoming_agreement_edges(candidate) if item.required)
+    component = 0.25
+    measurement = _measurement(
+        candidate.cell_id,
+        1.0,
+        component + (5.0e-9 if mismatch else 0.0),
+    )
+    measurement["status"] = ResultStatus.UNVERIFIED.value
+    measurement["validation"]["status"] = ResultStatus.UNVERIFIED.value
+    measurement["failure"] = {
+        "kind": "IndependentAuthorityUnavailable",
+        "message": "no successful independent numerical authority",
+    }
+
+    attach_direct_agreements(
+        candidate,
+        measurement,
+        {edge.baseline.cell_id: _measurement(edge.baseline.cell_id, 1.0, component)},
+    )
+
+    expected = (
+        ResultStatus.VALIDATION_FAILED.value
+        if mismatch
+        else ResultStatus.UNVERIFIED.value
+    )
+    assert measurement["status"] == expected
+    assert measurement["validation"]["status"] == expected
+    if mismatch:
+        assert measurement["failure"]["kind"] == "MeasurementValidationError"
+    else:
+        assert measurement["failure"]["kind"] == "IndependentAuthorityUnavailable"
+
+
+def test_ufo_recurrence_can_pass_independent_oracle_and_fail_direct_edge() -> None:
+    candidate = _cell(
+        "matrix_recurrence_ufo_sm_lc",
+        workload=Workload.SELECTED_FLOW,
+    )
+    edge = incoming_agreement_edges(candidate)[0]
+    independent = 1.0
+    builtin = _measurement(edge.baseline.cell_id, 1.0, 0.25)
+    ufo = _measurement(candidate.cell_id, 1.0 + 5.0e-9, 0.25)
+
+    assert (
+        pointwise_validation(
+            float(builtin["matrix_element"]),
+            independent,
+            relative_tolerance=1.0e-8,
+        )["status"]
+        == ResultStatus.OK.value
+    )
+    assert (
+        pointwise_validation(
+            float(ufo["matrix_element"]),
+            independent,
+            relative_tolerance=1.0e-8,
+        )["status"]
+        == ResultStatus.OK.value
+    )
+
+    attach_direct_agreements(
+        candidate,
+        ufo,
+        {edge.baseline.cell_id: builtin},
+    )
+
+    assert ufo["status"] == ResultStatus.VALIDATION_FAILED.value
+    record = ufo["validation"][DIRECT_AGREEMENT_FIELD][0]
+    assert record["edge_kind"] == BUILTIN_UFO_RECURRENCE
+    assert record["abi"] == DIRECT_AGREEMENT_V2_ABI
+    assert record["relative_tolerance"] == 1.0e-12
+    assert record["error_bound"] == pytest.approx(1.0e-12)
+    assert record["status"] == ResultStatus.VALIDATION_FAILED.value
+
+
+def test_z_timing_baseline_stays_amplicol_but_numerics_consume_recurrence() -> None:
+    candidate = _cell(
+        "z_builtin_sm",
+        workload=Workload.SELECTED_FLOW,
+        variant="jit_o1",
+    )
+    timing_baseline = REPORT_CATALOG.baseline_cell(candidate)
+    assert timing_baseline is not None
+    assert timing_baseline.measurement.execution_mode is ExecutionMode.AMPLICOL
+    edge = incoming_agreement_edges(candidate)[0]
+    assert edge.kind == Z_RECURRENCE_CROSS_MODE
+    assert edge.baseline.variant == "recurrence_jit_o2"
+
+    amplicol_value = 1.0
+    recurrence = _measurement(edge.baseline.cell_id, 1.0, 0.25)
+    compiled = _measurement(candidate.cell_id, 1.0 + 5.0e-9, 0.25)
+    assert (
+        pointwise_validation(
+            float(compiled["matrix_element"]),
+            amplicol_value,
+            relative_tolerance=1.0e-8,
+        )["status"]
+        == ResultStatus.OK.value
+    )
+
+    attach_direct_agreements(
+        candidate,
+        compiled,
+        {edge.baseline.cell_id: recurrence},
+    )
+
+    assert compiled["status"] == ResultStatus.VALIDATION_FAILED.value
+    record = compiled["validation"][DIRECT_AGREEMENT_FIELD][0]
+    assert record["edge_kind"] == Z_RECURRENCE_CROSS_MODE
+    assert record["baseline_cell_id"] == edge.baseline.cell_id
+
+
+def test_cross_layout_component_failure_is_not_hidden_by_equal_totals() -> None:
+    candidate = _cell(
+        "matrix_compiled_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+    edges = incoming_agreement_edges(candidate)
+    edge = next(item for item in edges if item.kind == LC_CROSS_LAYOUT_COMPONENT)
+    legacy_edge = next(
+        item for item in edges if item.kind == LC_LEGACY_PYAMPLICOL_COMPONENT
+    )
+    topology = _measurement(edge.baseline.cell_id, 1.0, 0.25)
+    union = _measurement(candidate.cell_id, 1.0, 0.25 + 5.0e-9)
+    legacy = _measurement(
+        legacy_edge.baseline.cell_id,
+        1.0,
+        0.25 + 5.0e-9,
+    )
+
+    attach_direct_agreements(
+        candidate,
+        union,
+        {
+            edge.baseline.cell_id: topology,
+            legacy_edge.baseline.cell_id: legacy,
+        },
+    )
+
+    assert topology["matrix_element"] == union["matrix_element"]
+    assert union["status"] == ResultStatus.VALIDATION_FAILED.value
+    assert (
+        next(
+            record
+            for record in union["validation"][DIRECT_AGREEMENT_FIELD]
+            if record["edge_kind"] == LC_CROSS_LAYOUT_COMPONENT
+        )["value_kind"]
+        == LC_COMMON_COMPONENT_FIELD
+    )
+
+
+def test_final_replay_checks_cross_layout_component_not_only_totals() -> None:
+    candidate = _cell(
+        "matrix_compiled_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+    edge = incoming_agreement_edges(candidate)[0]
+    topology = _measurement(edge.baseline.cell_id, 1.0, 0.25)
+    union = _measurement(candidate.cell_id, 1.0, 0.25)
+    replayed = {
+        edge.baseline.cell_id: _ReplayObservation(1.0, 0.0, 0.0, 0.25),
+        candidate.cell_id: _ReplayObservation(
+            1.0,
+            0.0,
+            0.0,
+            0.25 + 5.0e-9,
+        ),
+    }
+
+    with pytest.raises(FinalAuditError, match="direct-edge replay failed"):
+        _audit_replayed_direct_agreements(
+            (edge,),
+            {
+                edge.baseline.cell_id: topology,
+                candidate.cell_id: union,
+            },
+            replayed,
+        )
+
+
+def test_legacy_pyamplicol_component_uses_independent_tolerance() -> None:
+    candidate = _cell(
+        "matrix_compiled_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+    edges = incoming_agreement_edges(candidate)
+    layout = next(edge for edge in edges if edge.kind == LC_CROSS_LAYOUT_COMPONENT)
+    legacy = next(edge for edge in edges if edge.kind == LC_LEGACY_PYAMPLICOL_COMPONENT)
+    observed = 1.0 + 5.0e-9
+    measurement = _measurement(candidate.cell_id, 1.0, observed)
+
+    attach_direct_agreements(
+        candidate,
+        measurement,
+        {
+            layout.baseline.cell_id: _measurement(
+                layout.baseline.cell_id,
+                1.0,
+                observed,
+            ),
+            legacy.baseline.cell_id: _measurement(
+                legacy.baseline.cell_id,
+                1.0,
+                1.0,
+            ),
+        },
+    )
+
+    record = next(
+        item
+        for item in measurement["validation"][DIRECT_AGREEMENT_FIELD]
+        if item["edge_kind"] == LC_LEGACY_PYAMPLICOL_COMPONENT
+    )
+    assert measurement["status"] == ResultStatus.OK.value
+    assert record["relative_tolerance"] == 1.0e-8
+    assert record["abi"] == DIRECT_AGREEMENT_V2_ABI
+    assert record["error_bound"] == pytest.approx(1.0e-8)
+
+
+def test_legacy_amplicol_mismatch_is_retained_without_failing_candidate() -> None:
+    candidate = _cell(
+        "matrix_compiled_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+    edges = incoming_agreement_edges(candidate)
+    layout = next(edge for edge in edges if edge.kind == LC_CROSS_LAYOUT_COMPONENT)
+    legacy = next(edge for edge in edges if edge.kind == LC_LEGACY_PYAMPLICOL_COMPONENT)
+    observed = 1.0 + 5.0e-7
+    measurement = _measurement(candidate.cell_id, 1.0, observed)
+
+    peers = {
+        layout.baseline.cell_id: _measurement(
+            layout.baseline.cell_id,
+            1.0,
+            observed,
+        ),
+        legacy.baseline.cell_id: _measurement(
+            legacy.baseline.cell_id,
+            1.0,
+            1.0,
+        ),
+    }
+    attach_direct_agreements(
+        candidate,
+        measurement,
+        peers,
+    )
+
+    record = next(
+        item
+        for item in measurement["validation"][DIRECT_AGREEMENT_FIELD]
+        if item["edge_kind"] == LC_LEGACY_PYAMPLICOL_COMPONENT
+    )
+    assert record["status"] == ResultStatus.VALIDATION_FAILED.value
+    assert measurement["status"] == ResultStatus.OK.value
+    assert measurement["validation"]["status"] == ResultStatus.OK.value
+
+    audited, counts = final_audit_module._audit_direct_agreements(
+        (candidate,),
+        {candidate.cell_id: measurement, **peers},
+        catalog=REPORT_CATALOG,
+    )
+    assert counts[LC_LEGACY_PYAMPLICOL_COMPONENT] == 1
+    replayed = {
+        candidate.cell_id: _ReplayObservation(1.0, 0.0, 0.0, observed),
+        layout.baseline.cell_id: _ReplayObservation(1.0, 0.0, 0.0, observed),
+    }
+    replay_counts = _audit_replayed_direct_agreements(
+        audited,
+        {candidate.cell_id: measurement, **peers},
+        replayed,
+    )
+    assert replay_counts["replayed-pyamplicol-vs-authenticated-legacy"] == 1
+
+    replayed[candidate.cell_id] = _ReplayObservation(1.0, 0.0, 0.0, 1.0)
+    with pytest.raises(FinalAuditError, match="stored candidate"):
+        _audit_replayed_direct_agreements(
+            audited,
+            {candidate.cell_id: measurement, **peers},
+            replayed,
+        )
+
+
+@pytest.mark.parametrize(
+    ("dataset_id", "candidate_precision"),
+    (
+        ("matrix_compiled_ufo_sm_full", 200),
+        ("matrix_on_the_fly_ufo_sm_full", 16),
+    ),
+)
+def test_madgraph_candidate_precision_is_authenticated_and_authority_not_replayed(
+    dataset_id: str,
+    candidate_precision: int,
+) -> None:
+    candidate = _cell(
+        dataset_id,
+        workload=Workload.CONTRACTED,
+    )
+    edge = next(
+        edge
+        for edge in incoming_agreement_edges(candidate)
+        if edge.kind == MADGRAPH_FULL_COLOUR
+    )
+    baseline = _measurement(edge.baseline.cell_id, 1.0, 0.0)
+    measurement = _measurement(candidate.cell_id, 1.0, 0.0)
+    for value in (baseline, measurement):
+        value["selector_contract"] = None
+        validation = value["validation"]
+        assert isinstance(validation, dict)
+        validation.pop(LC_COMMON_COMPONENT_FIELD)
+        validation["point_digest"] = _selector()["point_digest"]
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+    validation[MADGRAPH_COMPARISON_FIELD] = madgraph_comparison_record(
+        edge,
+        candidate=1.0 + 5.0e-12,
+        baseline_measurement=baseline,
+        point_identity=_selector()["point_digest"],
+    )
+    assert madgraph_candidate_precision(candidate) == candidate_precision
+    assert (
+        validation[MADGRAPH_COMPARISON_FIELD]["candidate_precision"]
+        == candidate_precision
+    )
+    attach_direct_agreements(
+        candidate,
+        measurement,
+        {edge.baseline.cell_id: baseline},
+    )
+
+    audited, counts = final_audit_module._audit_direct_agreements(
+        (candidate,),
+        {candidate.cell_id: measurement, edge.baseline.cell_id: baseline},
+        catalog=REPORT_CATALOG,
+    )
+    assert counts[MADGRAPH_FULL_COLOUR] == 1
+    replay_counts = _audit_replayed_direct_agreements(
+        audited,
+        {candidate.cell_id: measurement, edge.baseline.cell_id: baseline},
+        {candidate.cell_id: _ReplayObservation(1.0, 0.0, 0.0, None)},
+    )
+    assert replay_counts["authenticated-stored-madgraph"] == 1
+
+    with pytest.raises(FinalAuditError, match=rf"stored p{candidate_precision}"):
+        _audit_replayed_direct_agreements(
+            audited,
+            {candidate.cell_id: measurement, edge.baseline.cell_id: baseline},
+            {
+                candidate.cell_id: _ReplayObservation(
+                    1.0 + 5.0e-9,
+                    0.0,
+                    0.0,
+                    None,
+                )
+            },
+        )
+
+
+def test_replay_categories_are_explicit_and_missing_endpoints_fail_closed() -> None:
+    edges = agreement_edges(maximum_n_final=1)
+    pac_pac = next(
+        edge
+        for edge in edges
+        if edge.baseline.measurement.execution_mode is not ExecutionMode.AMPLICOL
+        and edge.candidate.measurement.execution_mode is not ExecutionMode.AMPLICOL
+    )
+    pac_legacy = next(
+        edge for edge in edges if edge.kind == LC_LEGACY_PYAMPLICOL_COMPONENT
+    )
+    legacy_layout = next(
+        edge
+        for edge in edges
+        if edge.kind == LC_CROSS_LAYOUT_COMPONENT
+        and edge.candidate.measurement.execution_mode is ExecutionMode.AMPLICOL
+    )
+    selected = (pac_pac, pac_legacy, legacy_layout)
+    cells = {
+        endpoint.cell_id: endpoint
+        for edge in selected
+        for endpoint in (edge.baseline, edge.candidate)
+    }
+    measurements = {cell_id: _measurement(cell_id, 1.0, 1.0) for cell_id in cells}
+    attach_direct_agreements(
+        pac_legacy.candidate,
+        measurements[pac_legacy.candidate.cell_id],
+        {
+            pac_pac.baseline.cell_id: measurements[pac_pac.baseline.cell_id],
+            pac_legacy.baseline.cell_id: measurements[pac_legacy.baseline.cell_id],
+        },
+    )
+    attach_direct_agreements(
+        legacy_layout.candidate,
+        measurements[legacy_layout.candidate.cell_id],
+        {
+            legacy_layout.baseline.cell_id: measurements[
+                legacy_layout.baseline.cell_id
+            ],
+        },
+    )
+    replayed = {
+        cell_id: _ReplayObservation(1.0, 0.0, 0.0, 1.0)
+        for cell_id, cell in cells.items()
+        if cell.measurement.execution_mode is not ExecutionMode.AMPLICOL
+    }
+
+    counts = _audit_replayed_direct_agreements(
+        selected,
+        measurements,
+        replayed,
+    )
+
+    assert sorted(counts.values()) == [0, 1, 1, 1]
+    missing = dict(replayed)
+    missing.pop(pac_pac.baseline.cell_id)
+    with pytest.raises(FinalAuditError, match="missing its required pyAmpliCol replay"):
+        _audit_replayed_direct_agreements(
+            selected,
+            measurements,
+            missing,
+        )
+
+
+def _cache_measurement(cell_id: str) -> dict[str, object]:
+    compact = _measurement(cell_id, 1.0, 1.0)
+    result = empty_measurement()
+    result.update(
+        {
+            "status": ResultStatus.OK.value,
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 8.0e-7,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 0.0,
+            "relative_standard_error": 0.0,
+            "artifact": {},
+            "selector_contract": compact["selector_contract"],
+            "validation": compact["validation"],
+            "resources": {},
+            "provenance": {},
+        }
+    )
+    return result
+
+
+def test_cache_admission_requires_agreement_and_lc_component_evidence() -> None:
+    cell = _cell(
+        "reference_amplicol_lc",
+        workload=Workload.SELECTED_FLOW,
+    )
+    measurement = _cache_measurement(cell.cell_id)
+    cache = build_reset_cache(cell.dataset_id, (cell,))
+    cache["entries"][0]["measurement"] = measurement
+    validate_cache(cache, expected_cells=(cell,))
+
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+    direct = validation.pop(DIRECT_AGREEMENT_FIELD)
+    with pytest.raises(ValueError, match=DIRECT_AGREEMENT_FIELD):
+        validate_cache(cache, expected_cells=(cell,))
+    validation[DIRECT_AGREEMENT_FIELD] = direct
+    validation.pop(LC_COMMON_COMPONENT_FIELD)
+    with pytest.raises(ValueError, match=LC_COMMON_COMPONENT_FIELD):
+        validate_cache(cache, expected_cells=(cell,))
+
+
+def test_campaign_plan_keeps_z_numerical_peers_availability_optional(
+    tmp_path: Path,
+) -> None:
+    candidate = _cell(
+        "z_external_sm",
+        workload=Workload.ALL_FLOW,
+        variant="jit_o1",
+    )
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+
+    planned = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(artifact_policy=ArtifactPolicy.REGENERATE),
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+    target = by_id[candidate.cell_id]
+    baseline = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert baseline is not None
+
+    edges = incoming_agreement_edges(candidate)
+    assert validation_baseline_is_required(candidate, baseline) is False
+    authorities = independent_numerical_authorities(candidate)
+    assert tuple(authority.measurement.execution_mode for authority in authorities) == (
+        ExecutionMode.RECURRENCE,
+    )
+    assert target.baseline_cell_id is None
+    assert target.optional_baseline_cell_id == baseline.cell_id
+    assert baseline.cell_id not in by_id
+    assert set(target.comparison_peer_ids) == {
+        edge.baseline.cell_id for edge in edges if edge.required
+    }
+    assert set(target.optional_comparison_peer_ids) == {
+        edge.baseline.cell_id for edge in edges if not edge.required
+    }
+    assert target.numerical_authority_cell_ids == tuple(
+        authority.cell_id for authority in authorities
+    )
+    assert set(by_id) == {candidate.cell_id, *target.comparison_peer_ids}
+    assert not {authority.cell_id for authority in authorities}.intersection(by_id)
+
+
+def test_all_z_compiled_and_eager_cells_use_optional_ordered_authorities(
+    tmp_path: Path,
+) -> None:
+    candidates = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id.startswith("z_")
+        and cell.measurement.execution_mode
+        in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+    )
+
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+    static_count = 0
+    runnable_count = 0
+    assert len(candidates) == 180
+    for candidate in candidates:
+        baseline = REPORT_CATALOG.validation_baseline_cell(candidate)
+        authorities = independent_numerical_authorities(candidate)
+        assert baseline is not None
+        assert baseline.measurement.execution_mode is ExecutionMode.AMPLICOL
+        assert validation_baseline_is_required(candidate, baseline) is False
+        assert tuple(
+            authority.measurement.execution_mode for authority in authorities
+        ) == (ExecutionMode.RECURRENCE,)
+        assert any(
+            edge.kind == Z_RECURRENCE_CROSS_MODE
+            and not edge.required
+            and edge.baseline == authorities[0]
+            for edge in incoming_agreement_edges(candidate)
+        )
+        planned = plan_campaign(
+            (candidate,),
+            store=store,
+            settings=CampaignSettings(),
+        )
+        if REPORT_CATALOG.static_na_reason(candidate) is not None:
+            static_count += 1
+            assert planned == ()
+            continue
+        runnable_count += 1
+        by_id = {item.cell.cell_id: item for item in planned}
+        target = by_id[candidate.cell_id]
+        assert baseline.cell_id not in by_id
+        assert target.numerical_authority_cell_ids == tuple(
+            authority.cell_id for authority in authorities
+        )
+        assert set(by_id) == {candidate.cell_id, *target.comparison_peer_ids}
+        assert not {authority.cell_id for authority in authorities}.intersection(by_id)
+
+    assert (runnable_count, static_count) == (156, 24)
+
+
+def test_catalog_wide_independent_authority_policy_matches_surface_semantics() -> None:
+    cells = REPORT_CATALOG.measurement_cells()
+    authority_required = tuple(
+        cell for cell in cells if requires_independent_numerical_authority(cell)
+    )
+    standalone_compiled = tuple(
+        cell
+        for cell in cells
+        if cell.measurement.execution_mode
+        in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+        and not requires_independent_numerical_authority(cell)
+    )
+
+    assert len(authority_required) == 808
+    assert all(
+        cell.measurement.execution_mode in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+        for cell in authority_required
+    )
+    assert len(standalone_compiled) == 110
+    assert {cell.dataset_id for cell in standalone_compiled} == {
+        "matrix_compiled_ufo_sm_full",
+        "matrix_eager_ufo_sm_full",
+        "scalar_contact",
+        "scalar_gravity",
+    }
+    assert all(
+        not requires_independent_numerical_authority(cell)
+        for cell in cells
+        if cell.measurement.execution_mode
+        not in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+    )
+
+
+def test_canonical_n4_plan_keeps_bounded_acyclic_dependency_depth(
+    tmp_path: Path,
+) -> None:
+    selected = tuple(
+        cell for cell in REPORT_CATALOG.measurement_cells() if cell.n_final <= 4
+    )
+    planned = plan_campaign(
+        selected,
+        store=ArtifactStore(
+            artifact_root=tmp_path / "artifacts",
+            lock_root=tmp_path / "locks",
+        ),
+        settings=CampaignSettings(artifact_policy=ArtifactPolicy.REGENERATE),
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+
+    assert len(planned) == len(by_id) == 1042
+    assert max(item.rank for item in planned) == 4
+    for item in planned:
+        dependency_ids = set(item.comparison_peer_ids)
+        if item.baseline_cell_id is not None:
+            dependency_ids.add(item.baseline_cell_id)
+        assert all(
+            dependency_id in by_id and by_id[dependency_id].rank < item.rank
+            for dependency_id in dependency_ids
+        )
diff --git a/pyamplicol/tests/unit/test_performance_report_artifacts.py b/pyamplicol/tests/unit/test_performance_report_artifacts.py
new file mode 100644
index 0000000000..d19f97bc51
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_artifacts.py
@@ -0,0 +1,673 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import multiprocessing
+import shutil
+from pathlib import Path
+from queue import Empty
+from typing import Any
+
+import pytest
+
+from tools.performance_report.artifacts import (
+    ATTEMPT_SCHEMA,
+    CURRENT_SCHEMA,
+    PORTABLE_CURRENT_SCHEMA,
+    ArtifactAction,
+    ArtifactStore,
+    ArtifactStoreError,
+    LockTimeoutError,
+    ManifestValidationError,
+)
+from tools.performance_report.models import ArtifactPolicy
+from tools.performance_report.service import ReportPaths
+
+
+def _store(tmp_path: Path) -> ArtifactStore:
+    return ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "coordination",
+    )
+
+
+def _portable_store(campaign: Path, *, repo: Path) -> ArtifactStore:
+    artifact_root = campaign / "campaign_artifacts"
+    paths = ReportPaths(
+        repo_root=repo,
+        docs_dir=campaign,
+        results_dir=campaign / "results",
+        artifact_root=artifact_root,
+        coordination_root=artifact_root / "coordination",
+    )
+    return ArtifactStore(
+        artifact_root=paths.artifact_root,
+        lock_root=paths.coordination_root,
+        current_publication_paths=paths,
+    )
+
+
+def _canonical_bytes(payload: dict[str, Any]) -> bytes:
+    return (
+        json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        + "\n"
+    ).encode()
+
+
+def _rewrite_json(path: Path, payload: dict[str, Any]) -> None:
+    path.write_bytes(_canonical_bytes(payload))
+
+
+def _rewrite_pointer_digest(pointer_path: Path, manifest_path: Path) -> None:
+    pointer = json.loads(pointer_path.read_text(encoding="utf-8"))
+    pointer["manifest_sha256"] = hashlib.sha256(manifest_path.read_bytes()).hexdigest()
+    _rewrite_json(pointer_path, pointer)
+
+
+def _try_named_lock(
+    artifact_root: str,
+    lock_root: str,
+    queue: multiprocessing.Queue[str],
+) -> None:
+    store = ArtifactStore(
+        artifact_root=Path(artifact_root),
+        lock_root=Path(lock_root),
+    )
+    try:
+        with store.named_lock("prepared-ufo", timeout=0.1, poll_interval=0.01):
+            queue.put("acquired")
+    except LockTimeoutError:
+        queue.put("timeout")
+
+
+def test_successful_attempt_is_uuid_qualified_and_published_atomically(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    attempt = store.new_attempt("matrix/row:1", ArtifactPolicy.REGENERATE)
+    artifact = attempt.path("payload/process.bin")
+    artifact.write_bytes(b"compiled process")
+
+    current = attempt.publish(
+        {"status": "ok", "wall_seconds": 1.25},
+        artifact_paths=("payload/process.bin",),
+    )
+
+    assert attempt.root.name == attempt.attempt_id
+    assert attempt.root.parent.name == "attempts"
+    assert current.cell_id == "matrix/row:1"
+    assert current.result == {"status": "ok", "wall_seconds": 1.25}
+    assert {entry.relative_path for entry in current.artifacts} == {
+        "payload/process.bin",
+        "result.json",
+    }
+    pointer = json.loads(
+        (attempt.root.parent.parent / "current.json").read_text(encoding="utf-8")
+    )
+    assert pointer["schema"] == CURRENT_SCHEMA
+    assert pointer["manifest_path"] == (
+        f"attempts/{attempt.attempt_id}/manifest.json"
+    )
+    assert not list(attempt.root.rglob("*.tmp-*"))
+
+
+def test_portable_current_bytes_survive_campaign_move_and_materialize(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "source"
+    repo.mkdir()
+    campaign_a = tmp_path / "parent-a" / "manual-a"
+    store_a = _portable_store(campaign_a, repo=repo)
+    attempt = store_a.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    artifact = attempt.path("artifact")
+    artifact.mkdir()
+    (artifact / "payload.bin").write_bytes(b"payload")
+    identity = {"native_extension": {"path": "/authenticated/runtime.so"}}
+    current_a = attempt.publish(
+        {
+            "status": "ok",
+            "artifact": {"path": str(artifact)},
+            "provenance": {
+                "worker_log": str(attempt.root / "worker.log"),
+                "runtime_identity": identity,
+                "runtime_identity_sha256": hashlib.sha256(
+                    json.dumps(
+                        identity,
+                        separators=(",", ":"),
+                        sort_keys=True,
+                    ).encode("ascii")
+                ).hexdigest(),
+            },
+        },
+        artifact_paths=("artifact/payload.bin",),
+    )
+    stored = json.loads((attempt.root / "result.json").read_text())
+    pointer = json.loads(
+        (attempt.root.parent.parent / "current.json").read_text(encoding="utf-8")
+    )
+    assert pointer["schema"] == PORTABLE_CURRENT_SCHEMA
+    assert stored["artifact"]["path"].startswith(
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/"
+    )
+    assert stored["provenance"]["worker_log"].startswith(
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/"
+    )
+    assert stored["provenance"]["runtime_identity"] == identity
+
+    campaign_b = tmp_path / "parent-b" / "renamed-campaign"
+    campaign_b.parent.mkdir()
+    campaign_a.rename(campaign_b)
+    store_b = _portable_store(campaign_b, repo=repo)
+
+    current_b = store_b.load_current("cell")
+    lightweight = store_b.lightweight_current_payload("cell")
+    assert current_b is not None
+    assert lightweight is not None
+    expected_artifact = current_b.result_path.parent / "artifact"
+    assert current_b.result["artifact"]["path"] == str(expected_artifact)
+    assert lightweight[1]["artifact"]["path"] == str(expected_artifact)
+    assert current_b.manifest_sha256 == current_a.manifest_sha256
+
+
+def test_portable_store_rejects_old_absolute_current_without_migration(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "source"
+    repo.mkdir()
+    campaign = tmp_path / "manual"
+    artifact_root = campaign / "campaign_artifacts"
+    ordinary = ArtifactStore(
+        artifact_root=artifact_root,
+        lock_root=artifact_root / "coordination",
+    )
+    attempt = ordinary.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    artifact = attempt.path("artifact")
+    artifact.mkdir()
+    attempt.publish({"artifact": {"path": str(artifact)}})
+
+    portable = _portable_store(campaign, repo=repo)
+    with pytest.raises(ManifestValidationError, match="current pointer schema"):
+        portable.load_current("cell")
+    with pytest.raises(ManifestValidationError, match="unsupported shape"):
+        portable.lightweight_current_payload("cell")
+
+
+def test_portable_store_rejects_artifactless_legacy_terminal_current(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "source"
+    repo.mkdir()
+    campaign = tmp_path / "manual"
+    artifact_root = campaign / "campaign_artifacts"
+    ordinary = ArtifactStore(
+        artifact_root=artifact_root,
+        lock_root=artifact_root / "coordination",
+    )
+    attempt = ordinary.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    attempt.publish({"status": "memory_limit", "artifact": None})
+
+    portable = _portable_store(campaign, repo=repo)
+    with pytest.raises(ManifestValidationError, match="current pointer schema"):
+        portable.load_current("cell")
+    with pytest.raises(ManifestValidationError, match="unsupported shape"):
+        portable.lightweight_current_payload("cell")
+
+
+def test_failed_and_interrupted_attempts_cannot_replace_valid_current(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    first = store.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    original = first.publish({"sequence": 1})
+
+    failed = store.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    failed.mark_failed("backend failed")
+    interrupted = store.new_attempt("cell", ArtifactPolicy.RETIME, based_on=original)
+    interrupted.mark_interrupted("worker was terminated")
+
+    current = store.load_current("cell")
+    assert current is not None
+    assert current.attempt_id == original.attempt_id
+    assert current.result == {"sequence": 1}
+    assert json.loads(
+        (failed.root / "manifest.json").read_text(encoding="utf-8")
+    )["status"] == "failed"
+    assert json.loads(
+        (interrupted.root / "manifest.json").read_text(encoding="utf-8")
+    )["status"] == "interrupted"
+
+
+def _sealed_failed_worker_result(
+    store: ArtifactStore,
+    *,
+    cell_id: str = "cell",
+) -> tuple[str, Path]:
+    attempt = store.new_attempt(cell_id, ArtifactPolicy.REGENERATE)
+    attempt.write_json(
+        "worker-result.json",
+        {"status": "unverified", "marker": "diagnostic"},
+    )
+    attempt.mark_failed(
+        "independent authority unavailable",
+        artifact_paths=("worker-result.json",),
+    )
+    return attempt.attempt_id, attempt.root
+
+
+def test_named_unsuccessful_result_loads_only_authenticated_live_or_archive(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    attempt_id, root = _sealed_failed_worker_result(store)
+
+    assert store.load_sealed_unsuccessful_worker_result("cell", attempt_id) == {
+        "status": "unverified",
+        "marker": "diagnostic",
+    }
+
+    assert store.archive_obsolete_attempts("cell", consumer_cell_ids=()) == (
+        attempt_id,
+    )
+    assert not root.exists()
+    assert store.load_sealed_unsuccessful_worker_result("cell", attempt_id) == {
+        "status": "unverified",
+        "marker": "diagnostic",
+    }
+
+
+def test_archived_unsuccessful_result_ignores_only_pruned_heavy_payload(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    attempt = store.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    attempt.write_json(
+        "worker-result.json",
+        {"status": "unverified", "marker": "retained"},
+    )
+    attempt.path("artifact/native/payload.bin").write_bytes(b"heavy")
+    attempt.mark_failed(
+        "independent authority unavailable",
+        artifact_paths=("worker-result.json", "artifact/native/payload.bin"),
+    )
+
+    assert store.archive_obsolete_attempts("cell", consumer_cell_ids=()) == (
+        attempt.attempt_id,
+    )
+    archived = store._attempt_history_cell_root("cell") / attempt.attempt_id
+    assert not (archived / "artifact").exists()
+    assert store.load_sealed_unsuccessful_worker_result(
+        "cell",
+        attempt.attempt_id,
+    ) == {"status": "unverified", "marker": "retained"}
+
+def test_named_unsuccessful_result_rejects_collisions_and_tampering(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    attempt_id, live = _sealed_failed_worker_result(store)
+    archived = store._attempt_history_cell_root("cell") / attempt_id
+    archived.parent.mkdir(parents=True)
+    shutil.copytree(live, archived)
+
+    with pytest.raises(ManifestValidationError, match="colliding locations"):
+        store.load_sealed_unsuccessful_worker_result("cell", attempt_id)
+
+    shutil.rmtree(archived)
+    worker_result = live / "worker-result.json"
+    worker_result.write_text('{"status":"ok"}\n', encoding="utf-8")
+    with pytest.raises(
+        ManifestValidationError,
+        match=r"artifact (size|digest) mismatch",
+    ):
+        store.load_sealed_unsuccessful_worker_result("cell", attempt_id)
+
+
+@pytest.mark.parametrize("location", ("live", "archive"))
+def test_named_unsuccessful_result_rejects_symlinked_inventory_ancestors(
+    tmp_path: Path,
+    location: str,
+) -> None:
+    store = _store(tmp_path)
+    attempt_id, _root = _sealed_failed_worker_result(store)
+    if location == "live":
+        inventory = store._cell_root("cell") / "attempts"
+    else:
+        store.archive_obsolete_attempts("cell", consumer_cell_ids=())
+        inventory = store._attempt_history_cell_root("cell")
+    external = tmp_path / f"external-{location}"
+    inventory.replace(external)
+    inventory.symlink_to(external, target_is_directory=True)
+
+    with pytest.raises(ManifestValidationError, match="symbolic link"):
+        store.load_sealed_unsuccessful_worker_result("cell", attempt_id)
+
+
+def test_attempt_context_records_interruption_without_masking_exception(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    with (
+        pytest.raises(RuntimeError, match="deliberate"),
+        store.new_attempt("cell", ArtifactPolicy.REGENERATE) as attempt,
+    ):
+        raise RuntimeError("deliberate")
+
+    manifest = json.loads(
+        (attempt.root / "manifest.json").read_text(encoding="utf-8")
+    )
+    assert manifest["status"] == "interrupted"
+    assert manifest["error"] == "RuntimeError: deliberate"
+    assert store.load_current("cell", missing_ok=True) is None
+
+
+def test_unpublished_attempt_can_be_discarded_without_touching_current(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    current = store.new_attempt("cell", ArtifactPolicy.REGENERATE).publish(
+        {"status": "ok"}
+    )
+    partial = store.new_attempt(
+        "cell",
+        ArtifactPolicy.REGENERATE,
+        based_on=current,
+    )
+    partial.path("worker.log").write_text("partial\n", encoding="ascii")
+    partial_root = partial.root
+
+    partial.discard()
+
+    assert not partial_root.exists()
+    assert store.load_current("cell").attempt_id == current.attempt_id
+    with pytest.raises(ArtifactStoreError, match="already sealed"):
+        partial.discard()
+
+
+def test_artifact_policy_decisions_are_explicit(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    assert store.decide("cell", ArtifactPolicy.REUSE).action is ArtifactAction.GENERATE
+    assert (
+        store.decide("cell", ArtifactPolicy.RETIME).action
+        is ArtifactAction.GENERATE
+    )
+    current = store.new_attempt("cell", ArtifactPolicy.REGENERATE).publish(
+        {"status": "ok"}
+    )
+
+    reuse = store.decide("cell", ArtifactPolicy.REUSE)
+    retime = store.decide("cell", ArtifactPolicy.RETIME)
+    regenerate = store.decide("cell", ArtifactPolicy.REGENERATE)
+    assert reuse.action is ArtifactAction.REUSE_CURRENT
+    assert reuse.current == current
+    assert not reuse.requires_timing
+    assert retime.action is ArtifactAction.RETIME_CURRENT
+    assert retime.current == current
+    assert retime.requires_timing and not retime.requires_generation
+    assert regenerate.action is ArtifactAction.GENERATE
+    assert regenerate.requires_generation
+
+
+def test_recovery_enumerates_only_validated_current_records(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    expected = {
+        store.new_attempt(cell_id, ArtifactPolicy.REGENERATE)
+        .publish({"cell": cell_id})
+        .attempt_id
+        for cell_id in ("cell-a", "cell-b")
+    }
+    store.new_attempt("failed-cell", ArtifactPolicy.REGENERATE).mark_failed(
+        "not publishable"
+    )
+
+    recovered = store.recover_current_records()
+    assert {record.attempt_id for record in recovered} == expected
+    assert {record.cell_id for record in recovered} == {"cell-a", "cell-b"}
+
+
+def test_recovery_rejects_manifest_digest_mismatch(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    current = store.new_attempt("cell", ArtifactPolicy.REGENERATE).publish({"ok": 1})
+    current.manifest_path.write_text("{}\n", encoding="utf-8")
+
+    with pytest.raises(ManifestValidationError, match="manifest digest mismatch"):
+        store.recover_current_records()
+
+
+def test_recovery_rejects_pointer_path_traversal(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    attempt = store.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    attempt.publish({"ok": 1})
+    pointer_path = attempt.root.parent.parent / "current.json"
+    pointer = json.loads(pointer_path.read_text(encoding="utf-8"))
+    pointer["manifest_path"] = "../manifest.json"
+    _rewrite_json(pointer_path, pointer)
+
+    with pytest.raises(
+        ManifestValidationError,
+        match="canonical attempt manifest",
+    ):
+        store.recover_current_records()
+
+
+def test_recovery_rejects_artifact_path_traversal(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    attempt = store.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    attempt.publish({"ok": 1})
+    manifest_path = attempt.root / "manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest["artifacts"][0]["path"] = "../outside.json"
+    _rewrite_json(manifest_path, manifest)
+    pointer_path = attempt.root.parent.parent / "current.json"
+    _rewrite_pointer_digest(pointer_path, manifest_path)
+
+    with pytest.raises(ManifestValidationError, match="unsafe path"):
+        store.recover_current_records()
+
+
+@pytest.mark.parametrize(
+    ("target", "schema"),
+    (
+        ("pointer", "unknown-current-v9"),
+        ("manifest", "unknown-attempt-v9"),
+    ),
+)
+def test_recovery_rejects_schema_mismatch(
+    tmp_path: Path,
+    target: str,
+    schema: str,
+) -> None:
+    store = _store(tmp_path)
+    attempt = store.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    attempt.publish({"ok": 1})
+    pointer_path = attempt.root.parent.parent / "current.json"
+    manifest_path = attempt.root / "manifest.json"
+    path = pointer_path if target == "pointer" else manifest_path
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload["schema"] = schema
+    _rewrite_json(path, payload)
+    if target == "manifest":
+        _rewrite_pointer_digest(pointer_path, manifest_path)
+
+    with pytest.raises(ManifestValidationError, match=r"unsupported .* schema"):
+        store.recover_current_records()
+
+
+def test_recovery_rejects_artifact_digest_mismatch(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    attempt = store.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    payload_path = attempt.path("payload.bin")
+    payload_path.write_bytes(b"original")
+    attempt.publish({"ok": 1}, artifact_paths=("payload.bin",))
+    payload_path.write_bytes(b"modified")
+
+    with pytest.raises(
+        ManifestValidationError,
+        match=r"artifact (size|digest) mismatch",
+    ):
+        store.recover_current_records()
+
+
+def test_attempt_paths_cannot_escape_explicit_artifact_root(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    attempt = store.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    with pytest.raises(ManifestValidationError, match="unsafe path"):
+        attempt.path("../outside.json")
+    assert not (tmp_path / "outside.json").exists()
+
+
+def test_based_on_record_must_belong_to_same_cell(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    current = store.new_attempt("first", ArtifactPolicy.REGENERATE).publish({"ok": 1})
+    with pytest.raises(ArtifactStoreError, match="different cell"):
+        store.new_attempt("second", ArtifactPolicy.RETIME, based_on=current)
+
+
+def test_named_filesystem_lock_times_out_across_processes(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    context = multiprocessing.get_context("spawn")
+    queue: multiprocessing.Queue[str] = context.Queue()
+    with store.named_lock("prepared-ufo"):
+        process = context.Process(
+            target=_try_named_lock,
+            args=(
+                str(store.artifact_root),
+                str(store.lock_root),
+                queue,
+            ),
+        )
+        process.start()
+        process.join(timeout=3)
+    assert process.exitcode == 0
+    try:
+        outcome = queue.get(timeout=1)
+    except Empty as error:
+        raise AssertionError("child did not report its lock outcome") from error
+    assert outcome == "timeout"
+
+
+def test_named_filesystem_lock_is_reentrant_in_same_thread(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    competing = ArtifactStore(
+        artifact_root=store.artifact_root,
+        lock_root=store.lock_root,
+    )
+
+    with (
+        store.named_lock("measurement-lineage"),
+        competing.named_lock("measurement-lineage", timeout=0.0),
+        store.named_lock("measurement-lineage", timeout=0.0),
+    ):
+        pass
+
+    with store.named_lock("measurement-lineage", timeout=0.0):
+        pass
+
+
+def test_cell_and_named_locks_use_separate_explicit_roots(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    with store.cell_lock("cell"), store.named_lock("report-writer"):
+        assert store.artifact_root == (tmp_path / "artifacts").resolve()
+        assert store.lock_root == (tmp_path / "coordination").resolve()
+    assert list((store.lock_root / "cells").glob("*.lock"))
+    assert list((store.lock_root / "named").glob("*.lock"))
+
+
+def test_manifest_shape_is_stable_and_records_policy_lineage(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    first = store.new_attempt("cell", ArtifactPolicy.REGENERATE).publish({"run": 1})
+    second_attempt = store.new_attempt(
+        "cell",
+        ArtifactPolicy.RETIME,
+        based_on=first,
+    )
+    second_attempt.publish({"run": 2})
+    manifest = json.loads(
+        (second_attempt.root / "manifest.json").read_text(encoding="utf-8")
+    )
+
+    assert manifest["schema"] == ATTEMPT_SCHEMA
+    assert manifest["artifact_policy"] == "retime"
+    assert manifest["based_on"] == {
+        "attempt_id": first.attempt_id,
+        "manifest_sha256": first.manifest_sha256,
+    }
+
+
+def test_seal_existing_worker_result_publishes_same_authenticated_attempt(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    attempt = store.new_attempt("cell", ArtifactPolicy.REUSE)
+    attempt.write_json(
+        "worker-result.json",
+        {"status": "ok", "validation": {"status": "ok"}},
+    )
+    attempt.path("worker.log").write_text("completed\n", encoding="utf-8")
+    worker_result = attempt.root / "worker-result.json"
+    digest = hashlib.sha256(worker_result.read_bytes()).hexdigest()
+
+    current = store.seal_existing_worker_result(
+        "cell",
+        attempt.attempt_id,
+        worker_result_sha256=digest,
+        artifact_policy=ArtifactPolicy.REUSE,
+        validate_result=lambda result, root: (
+            None
+            if result["status"] == "ok" and (root / "worker.log").is_file()
+            else (_ for _ in ()).throw(ValueError("incomplete evidence"))
+        ),
+    )
+
+    assert current.attempt_id == attempt.attempt_id
+    assert current.artifact_policy is ArtifactPolicy.REUSE
+    assert current.result == {
+        "status": "ok",
+        "validation": {"status": "ok"},
+    }
+    assert {artifact.relative_path for artifact in current.artifacts} == {
+        "result.json",
+        "worker-result.json",
+        "worker.log",
+    }
+    assert json.loads((attempt.root / "result.json").read_text()) == current.result
+    assert store.load_current("cell") == current
+
+
+@pytest.mark.parametrize("mutation", ("digest", "wrong-cell", "incomplete"))
+def test_seal_existing_worker_result_rejects_untrusted_or_incomplete_evidence(
+    tmp_path: Path,
+    mutation: str,
+) -> None:
+    store = _store(tmp_path)
+    attempt = store.new_attempt("cell", ArtifactPolicy.REUSE)
+    attempt.write_json("worker-result.json", {"status": "ok"})
+    worker_result = attempt.root / "worker-result.json"
+    digest = hashlib.sha256(worker_result.read_bytes()).hexdigest()
+
+    with pytest.raises((ArtifactStoreError, ValueError)):
+        store.seal_existing_worker_result(
+            "other-cell" if mutation == "wrong-cell" else "cell",
+            attempt.attempt_id,
+            worker_result_sha256=(
+                "0" * 64 if mutation == "digest" else digest
+            ),
+            artifact_policy=ArtifactPolicy.REUSE,
+            validate_result=(
+                (lambda _result, _root: (_ for _ in ()).throw(
+                    ValueError("incomplete evidence")
+                ))
+                if mutation == "incomplete"
+                else lambda _result, _root: None
+            ),
+        )
+
+    assert not (attempt.root / "result.json").exists()
+    assert not (attempt.root / "manifest.json").exists()
+    assert store.load_current("cell", missing_ok=True) is None
diff --git a/pyamplicol/tests/unit/test_performance_report_boundary.py b/pyamplicol/tests/unit/test_performance_report_boundary.py
new file mode 100644
index 0000000000..187823a72c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_boundary.py
@@ -0,0 +1,164 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from tools.performance_report.artifacts import ArtifactStore
+from tools.performance_report.boundary import (
+    CELL_BOUNDARY_SCHEMA,
+    CellBoundaryError,
+    authenticate_current_delta,
+    load_cell_boundary,
+    snapshot_cell_boundary,
+)
+from tools.performance_report.cli import _parser
+from tools.performance_report.models import ArtifactPolicy
+
+
+def _store(tmp_path: Path) -> ArtifactStore:
+    return ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "coordination",
+    )
+
+
+def _publish_worker_result(
+    store: ArtifactStore,
+    cell_id: str,
+) -> str:
+    attempt = store.new_attempt(cell_id, ArtifactPolicy.REGENERATE)
+    attempt.path("worker-result.json").write_text(
+        '{"status":"ok"}\n',
+        encoding="ascii",
+    )
+    return attempt.publish(
+        {"status": "ok"},
+        artifact_paths=("worker-result.json",),
+    ).attempt_id
+
+
+def test_boundary_accepts_exactly_one_authenticated_current_delta(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    before = snapshot_cell_boundary(store, "cell")
+    attempt_id = _publish_worker_result(store, "cell")
+
+    accepted = authenticate_current_delta(
+        store,
+        cell_id="cell",
+        expected_attempt_id=attempt_id,
+        before=before,
+    )
+
+    assert accepted["schema"] == CELL_BOUNDARY_SCHEMA
+    assert accepted["attempt_ids"] == [attempt_id]
+    current = accepted["current"]
+    assert isinstance(current, dict)
+    assert current["attempt_id"] == attempt_id
+    assert current["status"] == "ok"
+    assert len(str(current["manifest_sha256"])) == 64
+    assert len(str(current["result_sha256"])) == 64
+    assert len(str(current["worker_result_sha256"])) == 64
+
+
+def test_boundary_rejects_an_extra_attempt_even_with_valid_current(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    before = snapshot_cell_boundary(store, "cell")
+    failed = store.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    failed.mark_failed("failed")
+    accepted_id = _publish_worker_result(store, "cell")
+
+    with pytest.raises(CellBoundaryError, match="exactly"):
+        authenticate_current_delta(
+            store,
+            cell_id="cell",
+            expected_attempt_id=accepted_id,
+            before=before,
+        )
+
+
+def test_boundary_runs_result_validation_before_acceptance(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    before = snapshot_cell_boundary(store, "cell")
+    attempt_id = _publish_worker_result(store, "cell")
+
+    def reject_result(result: Mapping[str, Any]) -> None:
+        assert result == {"status": "ok"}
+        raise ValueError("measurement schema differs")
+
+    with pytest.raises(ValueError, match="measurement schema"):
+        authenticate_current_delta(
+            store,
+            cell_id="cell",
+            expected_attempt_id=attempt_id,
+            before=before,
+            validate_result=reject_result,
+        )
+
+
+def test_boundary_rejects_current_without_authenticated_worker_result(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    before = snapshot_cell_boundary(store, "cell")
+    attempt = store.new_attempt("cell", ArtifactPolicy.REGENERATE)
+    attempt.publish({"status": "ok"})
+
+    with pytest.raises(
+        CellBoundaryError,
+        match=r"worker-result\.json",
+    ):
+        authenticate_current_delta(
+            store,
+            cell_id="cell",
+            expected_attempt_id=attempt.attempt_id,
+            before=before,
+        )
+
+
+def test_boundary_loads_legacy_fast_wrapper_snapshot(tmp_path: Path) -> None:
+    path = tmp_path / "pre-populate-current.json"
+    path.write_text(
+        json.dumps(
+            {
+                "attempt_ids": [],
+                "cell_root": "/legacy/cell",
+                "current": None,
+            }
+        ),
+        encoding="ascii",
+    )
+
+    assert load_cell_boundary(path)["attempt_ids"] == []
+
+
+def test_boundary_commands_have_explicit_cell_inputs() -> None:
+    snapshot = _parser().parse_args(
+        ("snapshot-cell-boundary", "--cell-id", "cell")
+    )
+    assert snapshot.cell_id == "cell"
+
+    accepted = _parser().parse_args(
+        (
+            "accept-cell-boundary",
+            "--cell-id",
+            "cell",
+            "--expected-attempt-id",
+            "attempt",
+            "--before-snapshot",
+            "before.json",
+        )
+    )
+    assert accepted.cell_id == "cell"
+    assert accepted.expected_attempt_id == "attempt"
+    assert accepted.before_snapshot == Path("before.json")
diff --git a/pyamplicol/tests/unit/test_performance_report_campaign_activity.py b/pyamplicol/tests/unit/test_performance_report_campaign_activity.py
new file mode 100644
index 0000000000..6c5e44a023
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_campaign_activity.py
@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.campaign_activity import (
+    CampaignActivityError,
+    blocking_coordination_files,
+    blocking_process_lines,
+    campaign_activity,
+    require_campaign_idle,
+)
+
+
+def test_publisher_render_processes_are_not_campaign_workers(tmp_path: Path) -> None:
+    entrypoint = tmp_path / "result_tables.py"
+    process_output = "\n".join(
+        (
+            (
+                "94622 Python /usr/bin/python "
+                f"{entrypoint} publish-snapshot --watch"
+            ),
+            "94623 latexmk /usr/bin/latexmk -pdf pyAmpliCol.tex",
+            f"94624 Python /usr/bin/python {entrypoint} populate --workers 1",
+            "94625 rustc /usr/bin/rustc --crate-name pyamplicol",
+        )
+    )
+
+    assert blocking_process_lines(
+        process_output,
+        entrypoints=(entrypoint,),
+    ) == (
+        f"94624 Python /usr/bin/python {entrypoint} populate --workers 1",
+        "94625 rustc /usr/bin/rustc --crate-name pyamplicol",
+    )
+
+
+def test_only_regular_publisher_private_coordination_files_are_ignored(
+    tmp_path: Path,
+) -> None:
+    coordination_root = tmp_path / "coordination"
+    publication = coordination_root / "publication"
+    named = coordination_root / "named"
+    lsof_output = "\n".join(
+        (
+            "p94622",
+            "cPython",
+            "f3u",
+            "tREG",
+            f"n{publication / 'daemon.guard'}",
+            "f4r",
+            "tREG",
+            f"n{publication / 'daemon.json'}",
+            "f5r",
+            "tREG",
+            f"n{publication / 'snapshot-staging' / 'current.json'}",
+            "f6r",
+            "tDIR",
+            f"n{publication}",
+            "p94624",
+            "cPython",
+            "f3u",
+            "tREG",
+            f"n{named / 'report-writer-deadbeef.lock'}",
+            "f4u",
+            "tREG",
+            f"n{named / 'cell-example-deadbeef.lock'}",
+        )
+    )
+
+    blocked = blocking_coordination_files(
+        lsof_output,
+        coordination_root=coordination_root,
+    )
+
+    assert [record.path for record in blocked] == [
+        publication,
+        named / "report-writer-deadbeef.lock",
+        named / "cell-example-deadbeef.lock",
+    ]
+
+
+def test_idle_census_ignores_publisher_but_rejects_report_writer(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    coordination_root = tmp_path / "coordination"
+    publication = coordination_root / "publication"
+    named = coordination_root / "named"
+    responses = iter(
+        (
+            subprocess.CompletedProcess(
+                args=("ps",),
+                returncode=0,
+                stdout=(
+                    "94622 Python /usr/bin/python result_tables.py "
+                    "publish-snapshot --watch\n"
+                ),
+                stderr="",
+            ),
+            subprocess.CompletedProcess(
+                args=("lsof",),
+                returncode=0,
+                stdout="\n".join(
+                    (
+                        "p94622",
+                        "cPython",
+                        "f3u",
+                        "tREG",
+                        f"n{publication / 'daemon.guard'}",
+                    )
+                ),
+                stderr="",
+            ),
+        )
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.campaign_activity.subprocess.run",
+        lambda *_args, **_kwargs: next(responses),
+    )
+
+    assert campaign_activity(coordination_root=coordination_root).idle
+
+    responses = iter(
+        (
+            subprocess.CompletedProcess(
+                args=("ps",),
+                returncode=0,
+                stdout="",
+                stderr="",
+            ),
+            subprocess.CompletedProcess(
+                args=("lsof",),
+                returncode=0,
+                stdout="\n".join(
+                    (
+                        "p94624",
+                        "cPython",
+                        "f3u",
+                        "tREG",
+                        f"n{named / 'report-writer-deadbeef.lock'}",
+                    )
+                ),
+                stderr="",
+            ),
+        )
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.campaign_activity.subprocess.run",
+        lambda *_args, **_kwargs: next(responses),
+    )
+
+    with pytest.raises(CampaignActivityError, match="report-writer"):
+        require_campaign_idle(coordination_root=coordination_root)
diff --git a/pyamplicol/tests/unit/test_performance_report_campaign_holds.py b/pyamplicol/tests/unit/test_performance_report_campaign_holds.py
new file mode 100644
index 0000000000..b7625d75da
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_campaign_holds.py
@@ -0,0 +1,698 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from tools.performance_report.agreements import (
+    DIRECT_AGREEMENT_FIELD,
+    LC_COMMON_COMPONENT_ABI,
+    LC_COMMON_COMPONENT_FIELD,
+)
+from tools.performance_report.artifacts import ArtifactStore, CurrentRecord
+from tools.performance_report.cache import empty_measurement
+from tools.performance_report.campaign_holds import (
+    DEPENDENCY_HOLD_REASON,
+    PriorHeldDisposition,
+    PriorHeldEligibilityError,
+    active_prior_held_ids,
+    catalog_prerequisite_closure,
+    classify_prior_held_cells,
+    prior_held_history_record,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.measurement import failure_measurement
+from tools.performance_report.measurement_lineage import MeasurementLineage
+from tools.performance_report.models import (
+    Accuracy,
+    ArtifactPolicy,
+    CellSpec,
+    ResultStatus,
+    Workload,
+)
+
+_SOURCE_REVISION = "1" * 40
+_SOURCE_TREE = "2" * 40
+
+
+def _store(tmp_path: Path) -> ArtifactStore:
+    return ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "coordination",
+    )
+
+
+def _cell(*, workload: Workload = Workload.SELECTED_FLOW) -> CellSpec:
+    return next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == "matrix_compiled_builtin_sm_lc"
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is workload
+    )
+
+
+def _hard_dependency_cell() -> CellSpec:
+    return _cell(workload=Workload.ALL_FLOW)
+
+
+def _ufo_recurrence_cell(
+    *, workload: Workload = Workload.SELECTED_FLOW
+) -> CellSpec:
+    return next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == "matrix_recurrence_ufo_sm_lc"
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is workload
+    )
+
+
+def _ok_measurement(
+    cell: CellSpec,
+    *,
+    source_revision: str | None = _SOURCE_REVISION,
+    source_tree: str | None = _SOURCE_TREE,
+) -> dict[str, object]:
+    measurement = empty_measurement()
+    selector = (
+        None
+        if cell.measurement.accuracy is not Accuracy.LC
+        else {
+            "selected_color_flow_ids": ["flow:2,1"],
+            "selected_color_words": [[2, 1]],
+            "all_flow_helicity_ids": ["h:-1,+1,-1"],
+            "all_flow_source_helicities": {"1": -1, "2": 1, "3": -1},
+            "point_digest": "a" * 64,
+        }
+    )
+    validation: dict[str, object] = {
+        "status": ResultStatus.OK.value,
+        DIRECT_AGREEMENT_FIELD: [],
+    }
+    if selector is not None:
+        validation[LC_COMMON_COMPONENT_FIELD] = {
+            "abi": LC_COMMON_COMPONENT_ABI,
+            "cell_id": cell.cell_id,
+            "value": 1.0,
+            "point_digest": selector["point_digest"],
+            "helicity_ids": selector["all_flow_helicity_ids"],
+            "color_flow_ids": selector["selected_color_flow_ids"],
+        }
+    measurement.update(
+        {
+            "status": ResultStatus.OK.value,
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 8.0e-7,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 0.0,
+            "relative_standard_error": 0.0,
+            "artifact": {},
+            "selector_contract": selector,
+            "validation": validation,
+            "resources": {},
+            "provenance": (
+                {}
+                if source_revision is None
+                else {
+                    "report_measured_source_revision": source_revision,
+                    "report_measured_source_tree": source_tree,
+                    "report_source_revision": source_revision,
+                    "report_source_tree": source_tree,
+                }
+            ),
+        }
+    )
+    return measurement
+
+
+def _publish_ok(store: ArtifactStore, cell: CellSpec) -> None:
+    store.new_attempt(cell.cell_id, ArtifactPolicy.REGENERATE).publish(
+        _ok_measurement(cell)
+    )
+
+
+def _publish_prerequisites(
+    store: ArtifactStore,
+    target: CellSpec,
+) -> tuple[CellSpec, ...]:
+    prerequisites = catalog_prerequisite_closure(target)
+    for prerequisite in prerequisites:
+        _publish_ok(store, prerequisite)
+    return prerequisites
+
+
+def _hold_observation(index: int, reason: str) -> dict[str, object]:
+    summary_path = f"/summaries/{index:04d}.json"
+    return {
+        "reason": reason,
+        "summary_path": summary_path,
+        "summary_sha256": hashlib.sha256(summary_path.encode()).hexdigest(),
+    }
+
+
+def _prior(
+    target: CellSpec,
+    *,
+    reasons: tuple[str, ...] = (DEPENDENCY_HOLD_REASON,),
+) -> dict[str, object]:
+    return {
+        target.cell_id: prior_held_history_record(
+            target.cell_id,
+            (_hold_observation(index, reason) for index, reason in enumerate(reasons)),
+        )
+    }
+
+
+def _classify(
+    store: ArtifactStore,
+    prior_held_records: dict[str, object],
+    **kwargs: Any,
+) -> dict[str, PriorHeldDisposition]:
+    kwargs.setdefault("expected_source_revision", _SOURCE_REVISION)
+    kwargs.setdefault("expected_source_tree", _SOURCE_TREE)
+    return classify_prior_held_cells(
+        store,
+        prior_held_records,
+        **kwargs,
+    )
+
+
+def _active_prior_held_ids(
+    store: ArtifactStore,
+    prior_held_records: dict[str, object],
+) -> frozenset[str]:
+    return active_prior_held_ids(
+        store,
+        prior_held_records,
+        expected_source_revision=_SOURCE_REVISION,
+        expected_source_tree=_SOURCE_TREE,
+    )
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def test_dependency_hold_becomes_eligible_after_every_prerequisite_is_ok(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    target = _hard_dependency_cell()
+    prerequisites = catalog_prerequisite_closure(target)
+    assert len(prerequisites) == 1
+    assert prerequisites[0] == _cell()
+
+    before = _classify(store, _prior(target))[target.cell_id]
+    assert before.eligible is False
+    assert {state for _cell_id, state in before.blocking_prerequisites} == {"missing"}
+
+    for prerequisite in prerequisites:
+        _publish_ok(store, prerequisite)
+    after = _classify(store, _prior(target))[target.cell_id]
+    assert after.eligible is True
+    assert after.reason == "eligible"
+    assert _active_prior_held_ids(store, _prior(target)) == frozenset()
+
+
+def test_compiled_recurrence_authority_is_not_a_hold_prerequisite(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    target = _cell()
+    authority = REPORT_CATALOG.validation_baseline_cell(target)
+
+    assert authority is not None
+    assert authority.measurement.execution_mode.value == "recurrence"
+    assert catalog_prerequisite_closure(target) == ()
+    assert _classify(store, _prior(target))[target.cell_id].eligible is True
+
+
+@pytest.mark.parametrize(
+    "reason",
+    (
+        "exact one-cell plan expanded or changed",
+        "signed-zero LC family awaits scoped continuity bridge",
+        "future hold reason",
+    ),
+)
+def test_non_dependency_historical_hold_is_never_readmitted(
+    tmp_path: Path,
+    reason: str,
+) -> None:
+    store = _store(tmp_path)
+    target = _cell()
+    _publish_prerequisites(store, target)
+
+    disposition = _classify(
+        store,
+        _prior(target, reasons=(reason,)),
+    )[target.cell_id]
+
+    assert disposition.eligible is False
+    assert disposition.reason == "historical-hold-not-dependency"
+    assert _active_prior_held_ids(
+        store,
+        _prior(target, reasons=(reason,)),
+    ) == frozenset((target.cell_id,))
+
+
+def test_later_non_dependency_reason_overrides_earlier_dependency_hold(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    target = _cell()
+    _publish_prerequisites(store, target)
+    reasons = (
+        DEPENDENCY_HOLD_REASON,
+        "exact one-cell plan expanded or changed",
+    )
+
+    disposition = _classify(
+        store,
+        _prior(target, reasons=reasons),
+    )[target.cell_id]
+
+    assert disposition.eligible is False
+    assert disposition.reason == "historical-hold-not-dependency"
+    assert disposition.historical_reasons == reasons
+    assert disposition.as_dict()["historical_reasons"] == list(reasons)
+    assert len(disposition.historical_observations) == 2
+
+
+@pytest.mark.parametrize(
+    "record",
+    (
+        None,
+        {},
+        {"reason": None},
+        {"reason": ""},
+    ),
+)
+def test_malformed_historical_hold_record_aborts_classification(
+    tmp_path: Path,
+    record: object,
+) -> None:
+    store = _store(tmp_path)
+    target = _cell()
+
+    with pytest.raises(PriorHeldEligibilityError, match="historical hold"):
+        _classify(store, {target.cell_id: record})
+
+
+def test_historical_hold_history_rejects_bad_digest_and_reason_tampering(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    target = _cell()
+
+    with pytest.raises(PriorHeldEligibilityError, match="observation"):
+        prior_held_history_record(
+            target.cell_id,
+            (
+                {
+                    "reason": DEPENDENCY_HOLD_REASON,
+                    "summary_path": "/summary.json",
+                    "summary_sha256": "bad",
+                },
+            ),
+        )
+    history = _prior(target)
+    raw_record = history[target.cell_id]
+    assert isinstance(raw_record, dict)
+    tampered = {**raw_record, "reasons": ["different"]}
+    with pytest.raises(PriorHeldEligibilityError, match="inconsistent"):
+        _classify(store, {target.cell_id: tampered})
+
+
+def test_optional_amplicol_diagnostic_is_not_a_hold_prerequisite(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    target = _ufo_recurrence_cell()
+    (direct,) = catalog_prerequisite_closure(target)
+    optional_diagnostic = REPORT_CATALOG.validation_baseline_cell(target)
+    assert optional_diagnostic is not None
+    assert optional_diagnostic.measurement.execution_mode.value == "amplicol"
+
+    disposition = _classify(
+        store,
+        _prior(target),
+    )[target.cell_id]
+
+    assert disposition.eligible is False
+    assert disposition.prerequisite_ids == (direct.cell_id,)
+    assert optional_diagnostic.cell_id not in disposition.prerequisite_ids
+    assert disposition.blocking_prerequisites == ((direct.cell_id, "missing"),)
+
+
+@pytest.mark.parametrize(
+    "status",
+    (
+        ResultStatus.ERROR,
+        ResultStatus.SKIP,
+        ResultStatus.UNSUPPORTED,
+    ),
+)
+def test_terminal_prerequisite_status_keeps_historical_hold(
+    tmp_path: Path,
+    status: ResultStatus,
+) -> None:
+    store = _store(tmp_path)
+    target = _hard_dependency_cell()
+    prerequisites = catalog_prerequisite_closure(target)
+    failed = prerequisites[-1]
+    for prerequisite in prerequisites:
+        result = (
+            failure_measurement(status, "terminal")
+            if prerequisite == failed
+            else _ok_measurement(prerequisite)
+        )
+        store.new_attempt(
+            prerequisite.cell_id,
+            ArtifactPolicy.REGENERATE,
+        ).publish(result)
+
+    disposition = _classify(
+        store,
+        _prior(target),
+    )[target.cell_id]
+
+    assert disposition.eligible is False
+    assert (failed.cell_id, status.value) in disposition.blocking_prerequisites
+
+
+@pytest.mark.parametrize("with_current", (False, True))
+def test_target_is_never_reselected_after_any_attempt(
+    tmp_path: Path,
+    with_current: bool,
+) -> None:
+    store = _store(tmp_path)
+    target = _cell()
+    _publish_prerequisites(store, target)
+    attempt = store.new_attempt(target.cell_id, ArtifactPolicy.REGENERATE)
+    if with_current:
+        attempt.publish(_ok_measurement(target))
+    else:
+        attempt.mark_failed("worker failed")
+
+    disposition = _classify(
+        store,
+        _prior(target),
+    )[target.cell_id]
+
+    assert disposition.eligible is False
+    assert disposition.reason == "target-already-attempted"
+    assert disposition.target_attempt_ids == (attempt.attempt_id,)
+
+
+def test_active_scoped_hold_blocks_target_and_dependency_descendants(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    target = _hard_dependency_cell()
+    prerequisites = _publish_prerequisites(store, target)
+    active_dependency = prerequisites[0]
+
+    direct = _classify(
+        store,
+        _prior(target),
+        active_scoped_hold_ids=(target.cell_id,),
+    )[target.cell_id]
+    descendant = _classify(
+        store,
+        _prior(target),
+        active_scoped_hold_ids=(active_dependency.cell_id,),
+    )[target.cell_id]
+
+    assert direct.reason == "active-scoped-defect-hold"
+    assert descendant.blocking_prerequisites == (
+        (active_dependency.cell_id, "active-scoped-defect-hold"),
+    )
+
+
+def test_agreement_equivalence_peers_are_required_before_readmission(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    target = _cell(workload=Workload.ALL_FLOW)
+    prerequisites = catalog_prerequisite_closure(target)
+    selected_peer = _cell()
+    assert selected_peer.cell_id in {
+        prerequisite.cell_id for prerequisite in prerequisites
+    }
+    for prerequisite in prerequisites:
+        if prerequisite != selected_peer:
+            _publish_ok(store, prerequisite)
+
+    blocked = _classify(
+        store,
+        _prior(target),
+    )[target.cell_id]
+    assert (selected_peer.cell_id, "missing") in blocked.blocking_prerequisites
+
+    _publish_ok(store, selected_peer)
+    assert _classify(
+        store,
+        _prior(target),
+    )[target.cell_id].eligible
+
+
+def test_unknown_or_invalid_current_fails_closed(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    target = _hard_dependency_cell()
+    prerequisite = catalog_prerequisite_closure(target)[0]
+    store.new_attempt(
+        prerequisite.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish({"status": "future"})
+
+    with pytest.raises(
+        PriorHeldEligibilityError,
+        match="current measurement is invalid",
+    ):
+        _classify(store, _prior(target))
+    with pytest.raises(PriorHeldEligibilityError, match="unknown catalog cells"):
+        _classify(
+            store,
+            {"unknown-cell": {"reason": DEPENDENCY_HOLD_REASON}},
+        )
+    with pytest.raises(PriorHeldEligibilityError, match="invalid catalog cell"):
+        _classify(
+            store,
+            {None: {"reason": DEPENDENCY_HOLD_REASON}},  # type: ignore[dict-item]
+        )
+
+
+@pytest.mark.parametrize("authenticated", (True, False, None, "yes"))
+def test_additional_current_authenticator_is_strictly_boolean(
+    tmp_path: Path,
+    authenticated: object,
+) -> None:
+    store = _store(tmp_path)
+    target = _hard_dependency_cell()
+    _publish_prerequisites(store, target)
+
+    disposition = classify_prior_held_cells(
+        store,
+        _prior(target),
+        authenticate_current=lambda _cell, _current: authenticated,  # type: ignore[return-value]
+    )[target.cell_id]
+
+    assert disposition.eligible is (authenticated is True)
+    states = {state for _cell_id, state in disposition.blocking_prerequisites}
+    assert states == (set() if authenticated is True else {"unauthenticated"})
+
+
+def test_measurement_lineage_authenticates_inherited_prerequisite_source(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    target = _hard_dependency_cell()
+    prerequisites = catalog_prerequisite_closure(target)
+    ancestor = prerequisites[0]
+    ancestor_revision = "3" * 40
+    ancestor_tree = "4" * 40
+    for prerequisite in prerequisites:
+        store.new_attempt(
+            prerequisite.cell_id,
+            ArtifactPolicy.REGENERATE,
+        ).publish(
+            _ok_measurement(
+                prerequisite,
+                source_revision=(
+                    ancestor_revision if prerequisite == ancestor else _SOURCE_REVISION
+                ),
+                source_tree=(
+                    ancestor_tree if prerequisite == ancestor else _SOURCE_TREE
+                ),
+            )
+        )
+    ancestor_current = store.load_current(ancestor.cell_id)
+    assert ancestor_current is not None
+    ancestor_pin = {
+        "attempt_id": ancestor_current.attempt_id,
+        "current_pointer_sha256": _sha256(
+            ancestor_current.manifest_path.parent.parent.parent / "current.json"
+        ),
+        "manifest_sha256": ancestor_current.manifest_sha256,
+        "result_sha256": _sha256(ancestor_current.result_path),
+        "source_revision": ancestor_revision,
+        "source_tree": ancestor_tree,
+    }
+    lineage = MeasurementLineage(
+        payload={},
+        retained_by_cell={ancestor.cell_id: ancestor_pin},
+        invalidated_cell_ids=frozenset(),
+        recompare_cell_ids=frozenset(),
+        required_descendant_cell_ids=frozenset(),
+        inherited_environments_by_revision={},
+    )
+
+    def authenticate(_cell: CellSpec, current: CurrentRecord) -> bool:
+        return (
+            lineage.source_for_current(
+                current,
+                active_revision=_SOURCE_REVISION,
+                active_tree=_SOURCE_TREE,
+            )
+            is not None
+        )
+
+    accepted = classify_prior_held_cells(
+        store,
+        _prior(target),
+        authenticate_current=authenticate,
+    )[target.cell_id]
+    rejected_lineage = MeasurementLineage(
+        payload={},
+        retained_by_cell={},
+        invalidated_cell_ids=frozenset(),
+        recompare_cell_ids=frozenset(),
+        required_descendant_cell_ids=frozenset(),
+        inherited_environments_by_revision={},
+    )
+    rejected = classify_prior_held_cells(
+        store,
+        _prior(target),
+        authenticate_current=lambda _cell, current: (
+            rejected_lineage.source_for_current(
+                current,
+                active_revision=_SOURCE_REVISION,
+                active_tree=_SOURCE_TREE,
+            )
+            is not None
+        ),
+    )[target.cell_id]
+
+    assert accepted.eligible is True
+    assert rejected.eligible is False
+    assert (ancestor.cell_id, "unauthenticated") in (rejected.blocking_prerequisites)
+
+
+def test_source_authentication_policy_is_required(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    target = _cell()
+
+    with pytest.raises(
+        PriorHeldEligibilityError,
+        match="source authentication policy",
+    ):
+        classify_prior_held_cells(store, _prior(target))
+
+
+@pytest.mark.parametrize(
+    ("revision", "tree"),
+    (
+        ("", ""),
+        ("not-a-git-object", "2" * 40),
+        ("1" * 39, "2" * 40),
+        ("1" * 40, "z" * 40),
+    ),
+)
+def test_single_source_authentication_rejects_malformed_git_identities(
+    tmp_path: Path,
+    revision: str,
+    tree: str,
+) -> None:
+    store = _store(tmp_path)
+    target = _cell()
+    _publish_prerequisites(store, target)
+
+    with pytest.raises(PriorHeldEligibilityError, match="Git object identities"):
+        classify_prior_held_cells(
+            store,
+            _prior(target),
+            expected_source_revision=revision,
+            expected_source_tree=tree,
+        )
+
+
+def test_expected_source_identity_blocks_stale_prerequisites(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    target = _hard_dependency_cell()
+    for prerequisite in catalog_prerequisite_closure(target):
+        store.new_attempt(
+            prerequisite.cell_id,
+            ArtifactPolicy.REGENERATE,
+        ).publish(
+            _ok_measurement(
+                prerequisite,
+                source_revision="5" * 40,
+                source_tree="6" * 40,
+            )
+        )
+
+    disposition = classify_prior_held_cells(
+        store,
+        _prior(target),
+        expected_source_revision=_SOURCE_REVISION,
+        expected_source_tree=_SOURCE_TREE,
+    )[target.cell_id]
+
+    assert disposition.eligible is False
+    assert {state for _cell_id, state in disposition.blocking_prerequisites} == {
+        "source-stale"
+    }
+    with pytest.raises(PriorHeldEligibilityError, match="provided together"):
+        classify_prior_held_cells(
+            store,
+            _prior(target),
+            expected_source_tree=_SOURCE_TREE,
+        )
+
+
+def test_single_source_authentication_checks_measured_identity(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    target = _hard_dependency_cell()
+    stale = catalog_prerequisite_closure(target)[0]
+    for prerequisite in catalog_prerequisite_closure(target):
+        measurement = _ok_measurement(prerequisite)
+        if prerequisite == stale:
+            provenance = measurement["provenance"]
+            assert isinstance(provenance, dict)
+            provenance["report_measured_source_revision"] = "5" * 40
+        store.new_attempt(
+            prerequisite.cell_id,
+            ArtifactPolicy.REGENERATE,
+        ).publish(measurement)
+
+    disposition = _classify(store, _prior(target))[target.cell_id]
+
+    assert disposition.eligible is False
+    assert (stale.cell_id, "source-stale") in (disposition.blocking_prerequisites)
diff --git a/pyamplicol/tests/unit/test_performance_report_campaign_policy.py b/pyamplicol/tests/unit/test_performance_report_campaign_policy.py
new file mode 100644
index 0000000000..1ca7a8fe03
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_campaign_policy.py
@@ -0,0 +1,2370 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from types import SimpleNamespace
+from typing import ClassVar
+
+import pytest
+
+from tools.ci.memory_watchdog import (
+    DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON,
+    RSS_LIMIT_REASON,
+)
+from tools.performance_report.artifacts import ArtifactStore
+from tools.performance_report.cache import build_reset_caches, empty_measurement
+from tools.performance_report.campaign_policy import (
+    MACBOOK_M3_MEMORY_LIMIT_BYTES,
+    MACBOOK_M3_POLICY,
+    MACBOOK_M3_Z_TABLE_F_GENERATION_LIMIT_SECONDS,
+    MACBOOK_M3_Z_TABLE_F_POLICY,
+    STRICT_POLICY,
+    X86_EPYC_GENERATION_LIMIT_SECONDS,
+    X86_EPYC_LEGACY_MEMORY_LIMIT_BYTES,
+    X86_EPYC_LEGACY_WORKERS,
+    X86_EPYC_MEMORY_LIMIT_BYTES,
+    X86_EPYC_NATIVE_COMPILER_SLOTS,
+    X86_EPYC_POLICY,
+    X86_EPYC_WORKERS,
+    CampaignPolicyError,
+    PolicyCensorKind,
+    PolicyMeasurementState,
+    _validate_generation_phase,
+    dependency_reference,
+    generation_limit_exempt,
+    generation_limit_for_cell,
+    policy_censor_measurement,
+    policy_from_manifest,
+    policy_status_label,
+    resource_frontier_reference,
+    resource_lane_identity,
+    validate_policy_measurement,
+)
+from tools.performance_report.catalog import (
+    REPORT_CATALOG,
+    STATIC_NA_ORIGINAL_AMPLICOL_OPEN_QUARK_LINE_LIMIT,
+)
+from tools.performance_report.cli import _gb_bytes, _parser
+from tools.performance_report.final_audit import FinalAuditError, audit_final_report
+from tools.performance_report.legacy import (
+    LegacyMeasurementAdapter,
+    LegacySettings,
+)
+from tools.performance_report.models import ArtifactPolicy, Workload
+from tools.performance_report.publication import portable_publication_value
+from tools.performance_report.render import _status
+from tools.performance_report.resources import (
+    PROCESS_TREE_MEMORY_METRIC_ABI,
+    GenerationPhaseEvidence,
+    ResourceUsage,
+    SupervisedResult,
+)
+from tools.performance_report.scheduler import (
+    CampaignScheduler,
+    CampaignSettings,
+    PlannedCell,
+    _partition_dependency_records,
+    _resource_payload,
+    plan_campaign,
+    validate_campaign_plan,
+)
+from tools.performance_report.service import ReportPaths, ReportService
+from tools.performance_report.source_identity import ReportSourceIdentity
+from tools.performance_report.study_contract import (
+    StudyContractError,
+    bind_z_table_f_attempt,
+    create_z_table_f_study_contract,
+)
+from tools.performance_report.worker import _worker_legacy_workspace
+from tools.performance_report.worker_harness import (
+    attach_worker_harness_identity,
+    worker_harness_identity,
+)
+from tools.performance_report.workspace import (
+    WORKSPACE_MANIFEST,
+    WORKSPACE_SCHEMA,
+    ReportWorkspaceError,
+    load_profile_campaign_policy,
+)
+
+_REVISION = "1" * 40
+_TREE = "2" * 40
+_IDENTITY = ReportSourceIdentity(_REVISION, _TREE, ())
+
+
+def _git_repo(
+    path: Path,
+    marker: str,
+    *,
+    report_wrapper: bool = False,
+) -> Path:
+    path.mkdir()
+    subprocess.run(("git", "init", "-q"), cwd=path, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "test@example.invalid"),
+        cwd=path,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Test"),
+        cwd=path,
+        check=True,
+    )
+    (path / "README.md").write_text(marker + "\n", encoding="ascii")
+    if report_wrapper:
+        (path / "src/pyamplicol/_profiling_campaign").mkdir(parents=True)
+        (path / "tools/performance_report").mkdir(parents=True)
+        (path / "src/pyamplicol/_profiling_campaign/result_tables.py").write_text(
+            f"# {marker} policy entrypoint\n",
+            encoding="ascii",
+        )
+        (path / "tools/performance_report/legacy.py").write_text(
+            f"# {marker} legacy adapter\n",
+            encoding="ascii",
+        )
+    subprocess.run(("git", "add", "."), cwd=path, check=True)
+    subprocess.run(("git", "commit", "-qm", "fixture"), cwd=path, check=True)
+    return path
+
+
+def _resources(peak: int) -> dict[str, object]:
+    return {
+        "available": True,
+        "current_rss_bytes": peak,
+        "peak_rss_bytes": peak,
+        "child_count": 1,
+        "cpu_seconds": 1.0,
+        "wall_seconds": 2.0,
+        "probe_error": None,
+    }
+
+
+def _guard_resources(
+    *,
+    limit: int,
+    rss: int,
+    physical: int | None,
+    reason: str | None,
+) -> dict[str, object]:
+    guard = max(rss, physical if physical is not None else rss)
+    return {
+        **_resources(rss),
+        "memory_metric_abi": PROCESS_TREE_MEMORY_METRIC_ABI,
+        "current_physical_footprint_bytes": physical,
+        "peak_physical_footprint_bytes": physical,
+        "current_guard_bytes": guard,
+        "peak_guard_bytes": guard,
+        "memory_limit_bytes": limit,
+        "memory_limit_reason": reason,
+        "memory_probe_reason": None,
+    }
+
+
+def _generation_phase(
+    *,
+    reason: str,
+    elapsed: float,
+) -> dict[str, object]:
+    completed = reason == "completed"
+    return {
+        "abi": "pyamplicol-report-generation-phase-evidence-v1",
+        "phase_state_abi": "pyamplicol-report-worker-phase-state-v1",
+        "configured_timeout_seconds": 3600.0,
+        "supervisor_reason": reason,
+        "authenticated": True,
+        "run_id": "f-worker",
+        "worker_pid": 123,
+        "final_sequence": 2 if completed else 1,
+        "final_phase": "post-generation" if completed else "generation",
+        "generation_started_monotonic_ns": 1,
+        "generation_finished_monotonic_ns": 2 if completed else None,
+        "generation_elapsed_seconds": elapsed,
+        "final_state_sha256": "3" * 64,
+        "error": None,
+    }
+
+
+def _test_worker_harness() -> dict[str, object]:
+    return worker_harness_identity(
+        study_contract_sha256="a" * 64,
+        policy_wrapper_revision="3" * 40,
+        policy_wrapper_tree="4" * 40,
+        policy_entrypoint_sha256="5" * 64,
+        legacy_adapter_sha256="6" * 64,
+        measured_source_revision=_REVISION,
+        measured_source_tree=_TREE,
+    )
+
+
+def _x86_settings(**changes: object) -> CampaignSettings:
+    values: dict[str, object] = {
+        "workers": X86_EPYC_WORKERS,
+        "cell_cores": 1,
+        "target_runtime_seconds": 5.0,
+        "max_rss_bytes": X86_EPYC_MEMORY_LIMIT_BYTES,
+        "allow_symbolica_parallel": True,
+        "campaign_policy": X86_EPYC_POLICY,
+        "report_profile": "x86_EPYC",
+    }
+    values.update(changes)
+    return CampaignSettings(**values)  # type: ignore[arg-type]
+
+
+def _mac_settings(**changes: object) -> CampaignSettings:
+    values: dict[str, object] = {
+        "workers": 1,
+        "cell_cores": 1,
+        "target_runtime_seconds": 5.0,
+        "max_rss_bytes": MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        "campaign_policy": MACBOOK_M3_POLICY,
+        "report_profile": "macbook_M3",
+    }
+    values.update(changes)
+    return CampaignSettings(**values)  # type: ignore[arg-type]
+
+
+def _z_table_f_settings(**changes: object) -> CampaignSettings:
+    values: dict[str, object] = {
+        "workers": 1,
+        "cell_cores": 1,
+        "target_runtime_seconds": 5.0,
+        "max_rss_bytes": MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        "campaign_policy": MACBOOK_M3_Z_TABLE_F_POLICY,
+        "report_profile": "macbook_M3",
+        "study_contract_sha256": "a" * 64,
+    }
+    values.update(changes)
+    return CampaignSettings(**values)  # type: ignore[arg-type]
+
+
+def _memory_censor(cell, *, peak: int) -> dict[str, object]:
+    return policy_censor_measurement(
+        X86_EPYC_POLICY,
+        "x86_EPYC",
+        cell,
+        kind=PolicyCensorKind.MEMORY_LIMIT,
+        source_identity=_IDENTITY,
+        resources=_resources(peak),
+        observed_rss_bytes=peak,
+    )
+
+
+def test_x86_policy_has_the_exact_canonical_n4_split() -> None:
+    cells = tuple(
+        cell for cell in REPORT_CATALOG.measurement_cells() if cell.n_final <= 4
+    )
+    exempt = tuple(cell for cell in cells if generation_limit_exempt(cell))
+
+    assert len(cells) == 1042
+    assert len(exempt) == 271
+    assert len(cells) - len(exempt) == 771
+    assert all(
+        cell.measurement.execution_mode.value == "amplicol"
+        or (
+            cell.measurement.execution_mode.value in {"compiled", "recurrence"}
+            and cell.measurement.accuracy.value == "lc"
+            and cell.workload is Workload.SELECTED_FLOW
+        )
+        for cell in exempt
+    )
+    full = REPORT_CATALOG.measurement_cells()
+    assert len(full) == 2198
+    assert sum(generation_limit_exempt(cell) for cell in full) == 725
+    assert sum(not generation_limit_exempt(cell) for cell in full) == 1473
+
+
+def test_x86_settings_are_exact_and_use_decimal_80_gb() -> None:
+    settings = _x86_settings()
+
+    assert settings.workers == 25
+    assert settings.cell_cores == 1
+    assert settings.max_rss_bytes == 80_000_000_000
+    assert settings.timeout_seconds is None
+    with pytest.raises(CampaignPolicyError, match="max_rss_bytes"):
+        _x86_settings(max_rss_bytes=80 * 1024**3)
+    with pytest.raises(CampaignPolicyError, match="workers"):
+        _x86_settings(workers=9)
+    with pytest.raises(CampaignPolicyError, match="workers"):
+        _x86_settings(workers=X86_EPYC_LEGACY_WORKERS)
+    assert CampaignSettings().campaign_policy is STRICT_POLICY
+    assert _gb_bytes(80.0) == X86_EPYC_MEMORY_LIMIT_BYTES
+    assert X86_EPYC_NATIVE_COMPILER_SLOTS == 4
+    parsed = _parser().parse_args(
+        (
+            "--report-profile",
+            "x86_EPYC",
+            "populate",
+            "--max-ram-gb",
+            "80",
+        )
+    )
+    assert parsed.max_ram_gb == 80.0
+
+
+def test_x86_policy_accepts_only_the_pinned_workers10_manifest_for_continuity() -> None:
+    legacy = X86_EPYC_POLICY.as_manifest()
+    legacy["workers"] = X86_EPYC_LEGACY_WORKERS
+    legacy["memory_limit_bytes"] = X86_EPYC_LEGACY_MEMORY_LIMIT_BYTES
+
+    assert policy_from_manifest(legacy, profile="x86_EPYC") is X86_EPYC_POLICY
+    assert X86_EPYC_POLICY.as_manifest()["workers"] == X86_EPYC_WORKERS
+
+    unsupported = dict(legacy)
+    unsupported["workers"] = 24
+    with pytest.raises(CampaignPolicyError, match="canonical definition"):
+        policy_from_manifest(unsupported, profile="x86_EPYC")
+
+    unsupported = dict(legacy)
+    unsupported["memory_limit_bytes"] = X86_EPYC_MEMORY_LIMIT_BYTES
+    with pytest.raises(CampaignPolicyError, match="canonical definition"):
+        policy_from_manifest(unsupported, profile="x86_EPYC")
+
+
+def test_macbook_policy_is_exact_memory_only_decimal_30_gb() -> None:
+    settings = _mac_settings()
+
+    assert settings.workers == 1
+    assert settings.cell_cores == 1
+    assert settings.target_runtime_seconds == 5.0
+    assert settings.max_rss_bytes == 30_000_000_000
+    assert settings.generation_time_limit_seconds is None
+    assert settings.timeout_seconds is None
+    assert settings.allow_symbolica_parallel is False
+    with pytest.raises(CampaignPolicyError, match="max_rss_bytes"):
+        _mac_settings(max_rss_bytes=30 * 1024**3)
+    with pytest.raises(CampaignPolicyError, match="generation_time_limit"):
+        _mac_settings(generation_time_limit_seconds=7200.0)
+
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    peak = MACBOOK_M3_MEMORY_LIMIT_BYTES + 1
+    result = policy_censor_measurement(
+        MACBOOK_M3_POLICY,
+        "macbook_M3",
+        cell,
+        kind=PolicyCensorKind.MEMORY_LIMIT,
+        source_identity=_IDENTITY,
+        resources=_resources(peak),
+        observed_rss_bytes=peak,
+    )
+    assert policy_status_label(result) == ">30GB"
+    assert (
+        validate_policy_measurement(
+            MACBOOK_M3_POLICY,
+            "macbook_M3",
+            cell,
+            result,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+        is PolicyMeasurementState.MEMORY_LIMIT
+    )
+
+
+def test_z_table_f_policy_caps_every_generation_at_one_hour() -> None:
+    settings = _z_table_f_settings()
+    cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id in {"z_builtin_sm", "reference_amplicol_lc"}
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final in {8, 9}
+        and cell.workload in {
+            Workload.SELECTED_FLOW,
+            Workload.ALL_FLOW,
+        }
+    )
+
+    assert settings.max_rss_bytes == 30_000_000_000
+    assert settings.generation_time_limit_seconds is None
+    assert settings.timeout_seconds is None
+    assert settings.study_contract_sha256 == "a" * 64
+    assert (
+        MACBOOK_M3_Z_TABLE_F_POLICY.generation_limit_seconds
+        == MACBOOK_M3_Z_TABLE_F_GENERATION_LIMIT_SECONDS
+        == 3600.0
+    )
+    assert (
+        MACBOOK_M3_Z_TABLE_F_POLICY.as_manifest()[
+            "generation_limit_exemptions"
+        ]
+        == "none"
+    )
+    assert cells
+    assert {
+        cell.workload for cell in cells
+    } == {Workload.SELECTED_FLOW, Workload.ALL_FLOW}
+    assert all(
+        generation_limit_for_cell(MACBOOK_M3_Z_TABLE_F_POLICY, cell)
+        == 3600.0
+        for cell in cells
+    )
+    assert any(
+        cell.measurement.execution_mode.value == "amplicol"
+        for cell in cells
+    )
+    assert any(
+        cell.measurement.execution_mode.value == "recurrence"
+        and cell.workload is Workload.SELECTED_FLOW
+        for cell in cells
+    )
+    with pytest.raises(CampaignPolicyError, match="max_rss_bytes"):
+        _z_table_f_settings(max_rss_bytes=30 * 1024**3)
+    with pytest.raises(
+        CampaignPolicyError,
+        match="generation_time_limit_seconds",
+    ):
+        _z_table_f_settings(generation_time_limit_seconds=3600.0)
+    with pytest.raises(ValueError, match="requires a study contract"):
+        _z_table_f_settings(study_contract_sha256=None)
+    with pytest.raises(ValueError, match="SHA-256"):
+        _z_table_f_settings(study_contract_sha256="not-a-digest")
+    with pytest.raises(ValueError, match="requires the Z-table F policy"):
+        CampaignSettings(study_contract_sha256="a" * 64)
+
+
+def test_physical_footprint_censor_is_authenticated_and_tamper_evident() -> None:
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    rss = MACBOOK_M3_MEMORY_LIMIT_BYTES - 1
+    physical = MACBOOK_M3_MEMORY_LIMIT_BYTES + 1
+    reason = "darwin-process-tree-physical-footprint-limit"
+    resources = _guard_resources(
+        limit=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        rss=rss,
+        physical=physical,
+        reason=reason,
+    )
+    result = policy_censor_measurement(
+        MACBOOK_M3_POLICY,
+        "macbook_M3",
+        cell,
+        kind=PolicyCensorKind.MEMORY_LIMIT,
+        source_identity=_IDENTITY,
+        resources=resources,
+        observed_rss_bytes=rss,
+        observed_guard_bytes=physical,
+        memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+        memory_limit_reason=reason,
+    )
+
+    assert policy_status_label(result) == ">30GB"
+    assert ">30GB" in _status(result)
+    assert (
+        validate_policy_measurement(
+            MACBOOK_M3_POLICY,
+            "macbook_M3",
+            cell,
+            result,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+        is PolicyMeasurementState.MEMORY_LIMIT
+    )
+
+    tampered = json.loads(json.dumps(result))
+    tampered["resources"]["peak_guard_bytes"] = physical - 2
+    with pytest.raises(CampaignPolicyError, match="memory guard"):
+        validate_policy_measurement(
+            MACBOOK_M3_POLICY,
+            "macbook_M3",
+            cell,
+            tampered,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+
+    unsupported = json.loads(json.dumps(result))
+    unsupported["resources"]["memory_metric_abi"] = "unsupported"
+    with pytest.raises(CampaignPolicyError, match="metric ABI"):
+        validate_policy_measurement(
+            MACBOOK_M3_POLICY,
+            "macbook_M3",
+            cell,
+            unsupported,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+
+    incomplete = json.loads(json.dumps(result))
+    incomplete["resources"]["memory_probe_reason"] = (
+        "darwin-process-tree-physical-footprint-probe-unavailable"
+    )
+    with pytest.raises(CampaignPolicyError, match="incomplete memory"):
+        validate_policy_measurement(
+            MACBOOK_M3_POLICY,
+            "macbook_M3",
+            cell,
+            incomplete,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+
+    missing_field = json.loads(json.dumps(result))
+    del missing_field["resources"]["memory_probe_reason"]
+    with pytest.raises(CampaignPolicyError, match="metric ABI"):
+        validate_policy_measurement(
+            MACBOOK_M3_POLICY,
+            "macbook_M3",
+            cell,
+            missing_field,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+
+
+def test_z_table_f_rejects_legacy_rss_only_censor_evidence() -> None:
+    ordinary_cell = REPORT_CATALOG.cell(
+        "scalar-contact-n2-scalar-contact-contracted"
+    )
+    ordinary = _memory_censor(
+        ordinary_cell,
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 1,
+    )
+    assert (
+        validate_policy_measurement(
+            X86_EPYC_POLICY,
+            "x86_EPYC",
+            ordinary_cell,
+            ordinary,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+        is PolicyMeasurementState.MEMORY_LIMIT
+    )
+
+    study_cell = REPORT_CATALOG.cell(
+        "reference-amplicol-lc-n8-dd-z-jets-selected-flow"
+    )
+    with pytest.raises(CampaignPolicyError, match="policy-censor v3"):
+        policy_censor_measurement(
+            MACBOOK_M3_Z_TABLE_F_POLICY,
+            "macbook_M3",
+            study_cell,
+            kind=PolicyCensorKind.MEMORY_LIMIT,
+            source_identity=_IDENTITY,
+            resources=_resources(MACBOOK_M3_MEMORY_LIMIT_BYTES + 1),
+            observed_rss_bytes=MACBOOK_M3_MEMORY_LIMIT_BYTES + 1,
+        )
+
+    peak = MACBOOK_M3_MEMORY_LIMIT_BYTES + 1
+    reason = DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON
+    v3_resources = _guard_resources(
+        limit=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        rss=peak,
+        physical=peak,
+        reason=reason,
+    )
+    study_v3 = policy_censor_measurement(
+        MACBOOK_M3_Z_TABLE_F_POLICY,
+        "macbook_M3",
+        study_cell,
+        kind=PolicyCensorKind.MEMORY_LIMIT,
+        source_identity=_IDENTITY,
+        resources=v3_resources,
+        observed_rss_bytes=peak,
+        observed_guard_bytes=peak,
+        memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+        memory_limit_reason=reason,
+    )
+    assert (
+        validate_policy_measurement(
+            MACBOOK_M3_Z_TABLE_F_POLICY,
+            "macbook_M3",
+            study_cell,
+            study_v3,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+        is PolicyMeasurementState.MEMORY_LIMIT
+    )
+
+
+@pytest.mark.parametrize(
+    "field",
+    (
+        "current_physical_footprint_bytes",
+        "peak_physical_footprint_bytes",
+    ),
+)
+@pytest.mark.parametrize(
+    "state",
+    ("success", "generation_limit", "memory_limit"),
+)
+def test_z_table_f_fails_closed_on_null_darwin_footprint(
+    field: str,
+    state: str,
+) -> None:
+    cell = REPORT_CATALOG.cell(
+        "reference-amplicol-lc-n8-dd-z-jets-selected-flow"
+    )
+    resources = _guard_resources(
+        limit=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        rss=100,
+        physical=120,
+        reason=None,
+    )
+    if state == "success":
+        phase = _generation_phase(reason="completed", elapsed=1.0)
+        resources["generation_phase"] = phase
+        result = empty_measurement()
+        result.update(
+            {
+                "status": "ok",
+                "generation_seconds": 1.0,
+                "resources": resources,
+                "provenance": _IDENTITY.provenance(),
+            }
+        )
+        attach_worker_harness_identity(result, _test_worker_harness())
+    elif state == "generation_limit":
+        phase = _generation_phase(
+            reason="generation_timeout",
+            elapsed=3600.0,
+        )
+        resources["generation_phase"] = phase
+        result = policy_censor_measurement(
+            MACBOOK_M3_Z_TABLE_F_POLICY,
+            "macbook_M3",
+            cell,
+            kind=PolicyCensorKind.GENERATION_LIMIT,
+            source_identity=_IDENTITY,
+            resources=resources,
+            observed_generation_seconds=3600.0,
+            phase_evidence=phase,
+        )
+    else:
+        peak = MACBOOK_M3_MEMORY_LIMIT_BYTES + 1
+        resources = _guard_resources(
+            limit=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+            rss=peak,
+            physical=peak - 1,
+            reason=RSS_LIMIT_REASON,
+        )
+        result = policy_censor_measurement(
+            MACBOOK_M3_Z_TABLE_F_POLICY,
+            "macbook_M3",
+            cell,
+            kind=PolicyCensorKind.MEMORY_LIMIT,
+            source_identity=_IDENTITY,
+            resources=resources,
+            observed_rss_bytes=peak,
+            observed_guard_bytes=peak,
+            memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+            memory_limit_reason=RSS_LIMIT_REASON,
+        )
+
+    result["resources"][field] = None
+    result["resources"][
+        (
+            "current_guard_bytes"
+            if field.startswith("current_")
+            else "peak_guard_bytes"
+        )
+    ] = result["resources"][
+        (
+            "current_rss_bytes"
+            if field.startswith("current_")
+            else "peak_rss_bytes"
+        )
+    ]
+    with pytest.raises(
+        CampaignPolicyError,
+        match="non-null authenticated current and peak Darwin",
+    ):
+        validate_policy_measurement(
+            MACBOOK_M3_Z_TABLE_F_POLICY,
+            "macbook_M3",
+            cell,
+            result,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+
+
+def test_ordinary_mac_policy_remains_compatible_with_null_footprint() -> None:
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    peak = MACBOOK_M3_MEMORY_LIMIT_BYTES + 1
+    resources = _guard_resources(
+        limit=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        rss=peak,
+        physical=None,
+        reason=RSS_LIMIT_REASON,
+    )
+    result = policy_censor_measurement(
+        MACBOOK_M3_POLICY,
+        "macbook_M3",
+        cell,
+        kind=PolicyCensorKind.MEMORY_LIMIT,
+        source_identity=_IDENTITY,
+        resources=resources,
+        observed_rss_bytes=peak,
+        observed_guard_bytes=peak,
+        memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+        memory_limit_reason=RSS_LIMIT_REASON,
+    )
+
+    assert (
+        validate_policy_measurement(
+            MACBOOK_M3_POLICY,
+            "macbook_M3",
+            cell,
+            result,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+        is PolicyMeasurementState.MEMORY_LIMIT
+    )
+
+
+def test_z_table_f_memory_reason_must_match_darwin_guard_tie_break() -> None:
+    cell = REPORT_CATALOG.cell(
+        "reference-amplicol-lc-n8-dd-z-jets-selected-flow"
+    )
+    peak = MACBOOK_M3_MEMORY_LIMIT_BYTES + 1
+    resources = _guard_resources(
+        limit=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        rss=peak,
+        physical=peak,
+        reason=RSS_LIMIT_REASON,
+    )
+
+    with pytest.raises(
+        CampaignPolicyError,
+        match="reason does not match the authenticated Darwin guard",
+    ):
+        policy_censor_measurement(
+            MACBOOK_M3_Z_TABLE_F_POLICY,
+            "macbook_M3",
+            cell,
+            kind=PolicyCensorKind.MEMORY_LIMIT,
+            source_identity=_IDENTITY,
+            resources=resources,
+            observed_rss_bytes=peak,
+            observed_guard_bytes=peak,
+            memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+            memory_limit_reason=RSS_LIMIT_REASON,
+        )
+
+
+def test_z_table_f_planning_rejects_stale_wrapper_harness_current(
+    tmp_path: Path,
+) -> None:
+    cell = REPORT_CATALOG.cell(
+        "reference-amplicol-lc-n8-dd-z-jets-selected-flow"
+    )
+    phase = _generation_phase(
+        reason="generation_timeout",
+        elapsed=3600.0,
+    )
+    resources = _guard_resources(
+        limit=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        rss=100,
+        physical=120,
+        reason=None,
+    )
+    resources["generation_phase"] = phase
+    result = policy_censor_measurement(
+        MACBOOK_M3_Z_TABLE_F_POLICY,
+        "macbook_M3",
+        cell,
+        kind=PolicyCensorKind.GENERATION_LIMIT,
+        source_identity=_IDENTITY,
+        resources=resources,
+        observed_generation_seconds=3600.0,
+        phase_evidence=phase,
+    )
+    current_harness = _test_worker_harness()
+    attach_worker_harness_identity(result, current_harness)
+    bind_z_table_f_attempt(result, "a" * 64)
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+    store.new_attempt(
+        cell.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(result)
+    settings = _z_table_f_settings(missing_only=True)
+
+    assert (
+        plan_campaign(
+            (cell,),
+            store=store,
+            settings=settings,
+            expected_revision=_REVISION,
+            expected_tree=_TREE,
+            expected_worker_harness=current_harness,
+        )
+        == ()
+    )
+    stale_expected = {
+        **current_harness,
+        "policy_wrapper_revision": "7" * 40,
+    }
+    planned = plan_campaign(
+        (cell,),
+        store=store,
+        settings=settings,
+        expected_revision=_REVISION,
+        expected_tree=_TREE,
+        expected_worker_harness=stale_expected,
+    )
+
+    assert tuple(item.cell_id for item in (entry.cell for entry in planned)) == (
+        cell.cell_id,
+    )
+
+
+def test_z_table_f_plan_rejects_dependency_expansion(
+    tmp_path: Path,
+) -> None:
+    cell = REPORT_CATALOG.cell(
+        "z-builtin-sm-n8-dd-z-jets-jit-o3-all-flow"
+    )
+    settings = _z_table_f_settings()
+    planned = plan_campaign(
+        (cell,),
+        store=ArtifactStore(
+            artifact_root=tmp_path / "artifacts",
+            lock_root=tmp_path / "locks",
+        ),
+        settings=settings,
+        expected_revision=_REVISION,
+        expected_tree=_TREE,
+    )
+
+    assert len(planned) > 1
+    assert any(item.dependency for item in planned)
+    with pytest.raises(
+        StudyContractError,
+        match="dependencies must already have authenticated currents",
+    ):
+        validate_campaign_plan(planned, settings)
+
+
+def test_policy_censors_are_canonical_and_tamper_evident() -> None:
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.n_final <= 4 and not generation_limit_exempt(cell)
+    )
+    phase_evidence = {
+        "abi": "pyamplicol-report-generation-phase-evidence-v1",
+        "phase_state_abi": "pyamplicol-report-worker-phase-state-v1",
+        "configured_timeout_seconds": X86_EPYC_GENERATION_LIMIT_SECONDS,
+        "supervisor_reason": "generation_timeout",
+        "authenticated": True,
+        "run_id": "run-1",
+        "worker_pid": 123,
+        "final_sequence": 1,
+        "final_phase": "generation",
+        "generation_started_monotonic_ns": 1,
+        "generation_finished_monotonic_ns": None,
+        "generation_elapsed_seconds": X86_EPYC_GENERATION_LIMIT_SECONDS,
+        "final_state_sha256": "3" * 64,
+        "error": None,
+    }
+    resources = _resources(1234)
+    resources["generation_phase"] = phase_evidence
+    result = policy_censor_measurement(
+        X86_EPYC_POLICY,
+        "x86_EPYC",
+        cell,
+        kind=PolicyCensorKind.GENERATION_LIMIT,
+        source_identity=_IDENTITY,
+        resources=resources,
+        observed_generation_seconds=X86_EPYC_GENERATION_LIMIT_SECONDS,
+        phase_evidence=phase_evidence,
+    )
+
+    assert policy_status_label(result) == ">2h"
+    assert (
+        validate_policy_measurement(
+            X86_EPYC_POLICY,
+            "x86_EPYC",
+            cell,
+            result,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+        is PolicyMeasurementState.GENERATION_LIMIT
+    )
+    provenance = result["provenance"]
+    assert isinstance(provenance, dict)
+    record = provenance["policy_censor"]
+    assert isinstance(record, dict)
+    record["observed_generation_seconds"] = 7201.0
+    with pytest.raises(CampaignPolicyError, match="sha256"):
+        validate_policy_measurement(
+            X86_EPYC_POLICY,
+            "x86_EPYC",
+            cell,
+            result,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+
+
+def test_completed_reused_artifact_accepts_zero_work_generation_phase() -> None:
+    phase_evidence = {
+        "abi": "pyamplicol-report-generation-phase-evidence-v1",
+        "phase_state_abi": "pyamplicol-report-worker-phase-state-v1",
+        "configured_timeout_seconds": X86_EPYC_GENERATION_LIMIT_SECONDS,
+        "supervisor_reason": "completed",
+        "authenticated": True,
+        "run_id": "run-1",
+        "worker_pid": 123,
+        "final_sequence": 2,
+        "final_phase": "post-generation",
+        "generation_started_monotonic_ns": 10,
+        "generation_finished_monotonic_ns": 10,
+        "generation_elapsed_seconds": 0.0,
+        "final_state_sha256": "3" * 64,
+        "error": None,
+    }
+
+    assert (
+        _validate_generation_phase(
+            phase_evidence,
+            X86_EPYC_POLICY,
+            expected_reason="completed",
+        )
+        is phase_evidence
+    )
+
+
+def test_generation_timeout_accepts_only_authenticated_preparation_boundary() -> None:
+    phase_evidence = {
+        **_generation_phase(reason="generation_timeout", elapsed=3600.0),
+        "final_sequence": 0,
+        "final_phase": "pre-generation",
+        "generation_started_monotonic_ns": None,
+    }
+
+    assert (
+        _validate_generation_phase(
+            phase_evidence,
+            MACBOOK_M3_Z_TABLE_F_POLICY,
+            expected_reason="generation_timeout",
+        )
+        is phase_evidence
+    )
+    for field, invalid in (
+        ("final_sequence", 2),
+        ("final_phase", "post-generation"),
+        ("generation_started_monotonic_ns", 1),
+    ):
+        corrupted = {**phase_evidence, field: invalid}
+        with pytest.raises(CampaignPolicyError, match="inconsistent"):
+            _validate_generation_phase(
+                corrupted,
+                MACBOOK_M3_Z_TABLE_F_POLICY,
+                expected_reason="generation_timeout",
+            )
+
+
+def test_missing_only_reuses_exact_dependency_censor_and_rebinds_changes(
+    tmp_path: Path,
+) -> None:
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == "matrix_compiled_builtin_sm_lc"
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is Workload.ALL_FLOW
+    )
+    baseline = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == candidate.dataset_id
+        and cell.process_key == candidate.process_key
+        and cell.n_final == candidate.n_final
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+    first = _memory_censor(
+        baseline,
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 1,
+    )
+    store.new_attempt(
+        baseline.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(first)
+    dependency = policy_censor_measurement(
+        X86_EPYC_POLICY,
+        "x86_EPYC",
+        candidate,
+        kind=PolicyCensorKind.DEPENDENCY,
+        source_identity=_IDENTITY,
+        resources=None,
+        dependencies=(dependency_reference(baseline.cell_id, first),),
+    )
+    store.new_attempt(
+        candidate.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(dependency)
+    settings = _x86_settings(missing_only=True)
+
+    assert (
+        plan_campaign(
+            (candidate,),
+            store=store,
+            settings=settings,
+            expected_revision=_REVISION,
+            expected_tree=_TREE,
+        )
+        == ()
+    )
+
+    second = _memory_censor(
+        baseline,
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 2,
+    )
+    store.new_attempt(
+        baseline.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(second)
+    planned = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=settings,
+        expected_revision=_REVISION,
+        expected_tree=_TREE,
+    )
+
+    assert tuple(item.cell.cell_id for item in planned) == (candidate.cell_id,)
+    assert planned[0].force_recompare is True
+
+
+def test_rendered_policy_markers_are_explicit() -> None:
+    cell = next(
+        cell for cell in REPORT_CATALOG.measurement_cells() if cell.n_final <= 4
+    )
+    result = _memory_censor(
+        cell,
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 1,
+    )
+
+    assert policy_status_label(result) == ">80GB"
+    assert ">80GB" in _status(result)
+
+
+def test_resource_frontier_is_lane_bound_and_tamper_evident() -> None:
+    source = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    target = REPORT_CATALOG.cell("scalar-contact-n3-scalar-contact-contracted")
+    root = _memory_censor(
+        source,
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 1,
+    )
+    frontier = resource_frontier_reference(target, source, root)
+    result = policy_censor_measurement(
+        X86_EPYC_POLICY,
+        "x86_EPYC",
+        target,
+        kind=PolicyCensorKind.RESOURCE_FRONTIER,
+        source_identity=_IDENTITY,
+        resources=None,
+        frontier=frontier,
+    )
+
+    assert policy_status_label(result) == "dependency >80GB"
+    assert (
+        validate_policy_measurement(
+            X86_EPYC_POLICY,
+            "x86_EPYC",
+            target,
+            result,
+            expected_source_revision=_REVISION,
+            expected_source_tree=_TREE,
+        )
+        is PolicyMeasurementState.RESOURCE_FRONTIER
+    )
+    assert frontier["lane"] == resource_lane_identity(target)
+    assert frontier["root"] == {
+        "cell_id": source.cell_id,
+        "n_final": 2,
+        "kind": PolicyCensorKind.MEMORY_LIMIT.value,
+        "status": "memory_limit",
+        "censor_sha256": root["provenance"]["policy_censor_sha256"],
+    }
+
+    other_lane = REPORT_CATALOG.cell("scalar-gravity-n3-scalar-gravity-contracted")
+    with pytest.raises(CampaignPolicyError, match="same lane"):
+        resource_frontier_reference(other_lane, source, root)
+
+
+def test_full_catalog_resource_lanes_are_unique_and_monotone(
+    tmp_path: Path,
+) -> None:
+    cells = REPORT_CATALOG.measurement_cells()
+    identities = tuple(
+        (tuple(resource_lane_identity(cell).items()), cell.n_final) for cell in cells
+    )
+    assert len(cells) == 2198
+    assert len(set(identities)) == len(identities)
+    assert len({lane for lane, _n_final in identities}) == 448
+
+    selected = tuple(
+        REPORT_CATALOG.cell(cell_id)
+        for cell_id in (
+            "scalar-contact-n2-scalar-contact-contracted",
+            "scalar-contact-n3-scalar-contact-contracted",
+            "scalar-gravity-n2-scalar-gravity-contracted",
+            "scalar-gravity-n3-scalar-gravity-contracted",
+        )
+    )
+    planned = plan_campaign(
+        selected,
+        store=ArtifactStore(
+            artifact_root=tmp_path / "artifacts",
+            lock_root=tmp_path / "locks",
+        ),
+        settings=_x86_settings(),
+        expected_revision=_REVISION,
+        expected_tree=_TREE,
+    )
+    ranks = {item.cell.cell_id: item.rank for item in planned}
+    assert (
+        ranks["scalar-contact-n3-scalar-contact-contracted"]
+        > ranks["scalar-contact-n2-scalar-contact-contracted"]
+    )
+    assert (
+        ranks["scalar-gravity-n3-scalar-gravity-contracted"]
+        > ranks["scalar-gravity-n2-scalar-gravity-contracted"]
+    )
+    assert (
+        ranks["scalar-contact-n2-scalar-contact-contracted"]
+        == ranks["scalar-gravity-n2-scalar-gravity-contracted"]
+    )
+
+
+def test_missing_only_reuses_and_rebinds_resource_frontier(
+    tmp_path: Path,
+) -> None:
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+    source = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    target = REPORT_CATALOG.cell("scalar-contact-n3-scalar-contact-contracted")
+    first = _memory_censor(
+        source,
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 1,
+    )
+    store.new_attempt(
+        source.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(first)
+    frontier = policy_censor_measurement(
+        X86_EPYC_POLICY,
+        "x86_EPYC",
+        target,
+        kind=PolicyCensorKind.RESOURCE_FRONTIER,
+        source_identity=_IDENTITY,
+        resources=None,
+        frontier=resource_frontier_reference(target, source, first),
+    )
+    store.new_attempt(
+        target.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(frontier)
+    settings = _x86_settings(missing_only=True)
+
+    assert (
+        plan_campaign(
+            (target,),
+            store=store,
+            settings=settings,
+            expected_revision=_REVISION,
+            expected_tree=_TREE,
+        )
+        == ()
+    )
+
+    second = _memory_censor(
+        source,
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 2,
+    )
+    store.new_attempt(
+        source.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(second)
+    planned = plan_campaign(
+        (target,),
+        store=store,
+        settings=settings,
+        expected_revision=_REVISION,
+        expected_tree=_TREE,
+    )
+    assert tuple(item.cell.cell_id for item in planned) == (target.cell_id,)
+    assert planned[0].force_recompare is True
+
+
+def test_workspace_policy_is_bound_to_the_exact_measured_commit(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    profile = repo / "docs" / "performance_reports" / "x86_EPYC"
+    profile.mkdir(parents=True)
+    legacy_policy = X86_EPYC_POLICY.as_manifest()
+    legacy_policy["workers"] = X86_EPYC_LEGACY_WORKERS
+    legacy_policy["memory_limit_bytes"] = X86_EPYC_LEGACY_MEMORY_LIMIT_BYTES
+    manifest = {
+        "schema": WORKSPACE_SCHEMA,
+        "profile": "x86_EPYC",
+        "campaign_policy": legacy_policy,
+    }
+    (profile / WORKSPACE_MANIFEST).write_text(
+        json.dumps(manifest),
+        encoding="ascii",
+    )
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "test@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Test"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(("git", "add", "."), cwd=repo, check=True)
+    subprocess.run(("git", "commit", "-qm", "profile"), cwd=repo, check=True)
+    revision = subprocess.run(
+        ("git", "rev-parse", "HEAD"),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+    assert (
+        load_profile_campaign_policy(
+            repo,
+            "x86_EPYC",
+            expected_source_revision=revision,
+        )
+        is X86_EPYC_POLICY
+    )
+    manifest["campaign_policy"] = STRICT_POLICY.as_manifest()
+    (profile / WORKSPACE_MANIFEST).write_text(
+        json.dumps(manifest),
+        encoding="ascii",
+    )
+    with pytest.raises(ReportWorkspaceError):
+        load_profile_campaign_policy(
+            repo,
+            "x86_EPYC",
+            expected_source_revision=revision,
+        )
+
+
+def test_legacy_workers_receive_distinct_pinned_shared_object_clones(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = tmp_path / "legacy-source"
+    source.mkdir()
+    subprocess.run(("git", "init", "-q"), cwd=source, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "test@example.invalid"),
+        cwd=source,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Test"),
+        cwd=source,
+        check=True,
+    )
+    (source / "makefile").write_text("all:\n\t@true\n", encoding="ascii")
+    subprocess.run(("git", "add", "."), cwd=source, check=True)
+    subprocess.run(("git", "commit", "-qm", "legacy"), cwd=source, check=True)
+    legacy_revision = subprocess.run(
+        ("git", "rev-parse", "HEAD"),
+        cwd=source,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+    class FakeLegacyApi:
+        default_repository = source
+
+        def expected_revision(self) -> str:
+            return legacy_revision
+
+        def validate_checkout(self, repository: Path) -> None:
+            observed = subprocess.run(
+                ("git", "rev-parse", "HEAD"),
+                cwd=repository,
+                check=True,
+                capture_output=True,
+                text=True,
+            ).stdout.strip()
+            assert observed == legacy_revision
+            status = subprocess.run(
+                ("git", "status", "--porcelain=v1", "--untracked-files=no"),
+                cwd=repository,
+                check=True,
+                capture_output=True,
+                text=True,
+            ).stdout
+            assert status == ""
+
+    monkeypatch.setattr(
+        "tools.performance_report.legacy.MaintainedLegacyApi",
+        FakeLegacyApi,
+    )
+    repo = tmp_path / "repo"
+    (repo / "src/pyamplicol/_profiling_campaign").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "test@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Test"),
+        cwd=repo,
+        check=True,
+    )
+    (repo / "README.md").write_text("fixture\n", encoding="ascii")
+    subprocess.run(("git", "add", "."), cwd=repo, check=True)
+    subprocess.run(("git", "commit", "-qm", "fixture"), cwd=repo, check=True)
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "locks",
+        )
+    )
+    scheduler = CampaignScheduler(service, settings=CampaignSettings())
+
+    first_source, first_workspace = scheduler._legacy_workspace_paths("first")
+    second_source, second_workspace = scheduler._legacy_workspace_paths("second")
+
+    assert first_source == second_source == source
+    assert first_workspace != second_workspace
+    assert not first_workspace.exists() and not second_workspace.exists()
+    with (
+        _worker_legacy_workspace(
+            repository=None,
+            source_repository=first_source,
+            workspace=first_workspace,
+            copy_source=False,
+        ) as first,
+        _worker_legacy_workspace(
+            repository=None,
+            source_repository=second_source,
+            workspace=second_workspace,
+            copy_source=False,
+        ) as second,
+    ):
+        assert first is not None and second is not None
+        assert (first / ".git").is_dir()
+        assert (second / ".git").is_dir()
+        (first / "makefile").write_text("changed\n", encoding="ascii")
+        assert (second / "makefile").read_text(encoding="ascii") == "all:\n\t@true\n"
+    assert not first_workspace.exists() and not second_workspace.exists()
+
+
+def test_legacy_generator_bootstrap_is_outside_generation_timing(
+    tmp_path: Path,
+) -> None:
+    adapter = LegacyMeasurementAdapter(
+        api=SimpleNamespace(),
+        executor=SimpleNamespace(),
+        snapshotter=SimpleNamespace(),
+        structural_proof=False,
+    )
+    commands: list[dict[str, object]] = []
+
+    def fake_run(args, **_kwargs):
+        commands.append(
+            {
+                "args": list(args),
+                "elapsed_seconds": 99.0 if not commands else 1.0,
+            }
+        )
+        return SimpleNamespace()
+
+    adapter._run = fake_run  # type: ignore[method-assign]
+    process_file = tmp_path / "input-processes.txt"
+    process_file.write_text("process fixture\n", encoding="ascii")
+
+    elapsed = adapter._generate_library(
+        context=SimpleNamespace(
+            entries=(),
+            process_file=process_file,
+            source_pdgs=(1, -1, 21, 21),
+        ),
+        repository=tmp_path / "legacy",
+        raw_color=False,
+        n_final=2,
+        process_key=None,
+        settings=LegacySettings(jobs=1),
+        commands=commands,
+        log_path=tmp_path / "legacy.log",
+    )
+
+    assert commands[0]["args"] == ["make", "-j1", "amplicol_generate"]
+    assert len(commands) == 5
+    assert elapsed == 4.0
+
+
+def test_legacy_n1_library_generation_bypasses_zero_ht_scale(
+    tmp_path: Path,
+) -> None:
+    adapter = LegacyMeasurementAdapter(
+        api=SimpleNamespace(),
+        executor=SimpleNamespace(),
+        snapshotter=SimpleNamespace(),
+        structural_proof=False,
+    )
+    commands: list[dict[str, object]] = []
+
+    def fake_run(args, **_kwargs):
+        commands.append({"args": list(args), "elapsed_seconds": 1.0})
+        return SimpleNamespace()
+
+    adapter._run = fake_run  # type: ignore[method-assign]
+    process_file = tmp_path / "input-processes.txt"
+    process_file.write_text("process fixture\n", encoding="ascii")
+
+    adapter._generate_library(
+        context=SimpleNamespace(
+            entries=(),
+            process_file=process_file,
+            source_pdgs=(1, -1, 23),
+        ),
+        repository=tmp_path / "legacy",
+        raw_color=False,
+        n_final=1,
+        process_key="dd_z_jets",
+        settings=LegacySettings(jobs=1),
+        commands=commands,
+        log_path=tmp_path / "legacy.log",
+    )
+
+    generator = next(
+        command["args"]
+        for command in commands
+        if command["args"] and command["args"][0] == "./amplicol_generate"
+    )
+    assert "--amplicol_momenta_probe=10" in generator
+    assert "--amplicol_probe_quiet" in generator
+    assert "--seed=101" not in generator
+
+
+def test_scheduler_publishes_authenticated_generation_censor(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo = _git_repo(tmp_path / "repo", "measured")
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "locks",
+        )
+    )
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+
+    def fake_supervise(command, **arguments):
+        channel = arguments["phase_channel"]
+        assert arguments["generation_timeout_seconds"] == 7200.0
+        assert channel is not None
+        assert "--phase-state-path" in command
+        return SupervisedResult(
+            returncode=-15,
+            reason="generation_timeout",
+            usage=ResourceUsage(True, 1, 1, 0, 1.0, 7200.0),
+            generation_phase=GenerationPhaseEvidence(
+                configured_timeout_seconds=7200.0,
+                supervisor_reason="generation_timeout",
+                authenticated=True,
+                run_id=channel.run_id,
+                worker_pid=123,
+                final_sequence=1,
+                final_phase="generation",
+                generation_started_monotonic_ns=1,
+                generation_finished_monotonic_ns=None,
+                generation_elapsed_seconds=7200.0,
+                final_state_sha256="4" * 64,
+                error=None,
+            ),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    scheduler = CampaignScheduler(service, settings=_x86_settings())
+
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            cell=cell,
+            dependency=False,
+            baseline_cell_id=None,
+            rank=0,
+        )
+    )
+
+    assert outcome.status == PolicyMeasurementState.GENERATION_LIMIT.value
+    current = service.store.load_current(cell.cell_id)
+    assert current is not None
+    assert policy_status_label(current.result) == ">2h"
+    assert (
+        validate_policy_measurement(
+            X86_EPYC_POLICY,
+            "x86_EPYC",
+            cell,
+            current.result,
+            expected_source_revision=scheduler.source_revision,
+            expected_source_tree=scheduler.source_tree,
+        )
+        is PolicyMeasurementState.GENERATION_LIMIT
+    )
+
+
+def test_z_table_f_scheduler_publishes_authenticated_one_hour_censor(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo = _git_repo(tmp_path / "repo", "measured")
+    wrapper = _git_repo(
+        tmp_path / "wrapper",
+        "policy",
+        report_wrapper=True,
+    )
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "locks",
+        )
+    )
+    cell = REPORT_CATALOG.cell(
+        "reference-amplicol-lc-n8-dd-z-jets-selected-flow"
+    )
+
+    def fake_supervise(command, **arguments):
+        channel = arguments["phase_channel"]
+        assert Path(command[4]) == (
+            wrapper / "src/pyamplicol/_profiling_campaign/result_tables.py"
+        )
+        assert command[command.index("--repo-root") + 1] == str(repo)
+        assert command[command.index("--measurement-source-root") + 1] == str(
+            repo
+        )
+        assert arguments["generation_timeout_seconds"] == 3600.0
+        assert arguments["timeout_seconds"] is None
+        assert arguments["max_rss_bytes"] == 30_000_000_000
+        assert arguments["scrub_import_environment"] is True
+        assert arguments["working_directory"] == repo
+        assert channel is not None
+        assert "--phase-state-path" in command
+        return SupervisedResult(
+            returncode=-15,
+            reason="generation_timeout",
+            usage=ResourceUsage(
+                available=True,
+                current_rss_bytes=100,
+                peak_rss_bytes=100,
+                child_count=0,
+                cpu_seconds=1.0,
+                wall_seconds=3600.0,
+                current_physical_footprint_bytes=120,
+                peak_physical_footprint_bytes=120,
+                current_guard_bytes=120,
+                peak_guard_bytes=120,
+                memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+            ),
+            generation_phase=GenerationPhaseEvidence(
+                configured_timeout_seconds=3600.0,
+                supervisor_reason="generation_timeout",
+                authenticated=True,
+                run_id=channel.run_id,
+                worker_pid=123,
+                final_sequence=1,
+                final_phase="generation",
+                generation_started_monotonic_ns=1,
+                generation_finished_monotonic_ns=None,
+                generation_elapsed_seconds=3600.0,
+                final_state_sha256="4" * 64,
+                error=None,
+            ),
+            memory_limit_bytes=30_000_000_000,
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    monkeypatch.setattr(
+        CampaignScheduler,
+        "_legacy_workspace_paths",
+        lambda _self, attempt_id: (
+            repo,
+            tmp_path / "legacy-workspaces" / attempt_id,
+        ),
+    )
+    contract = create_z_table_f_study_contract(
+        repo,
+        wrapper,
+        prior_store=service.store,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=_z_table_f_settings(
+            study_contract_sha256=str(contract["sha256"]),
+        ),
+        study_contract=contract,
+        study_contract_wrapper_root=wrapper,
+    )
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            cell=cell,
+            dependency=False,
+            baseline_cell_id=None,
+            rank=0,
+        )
+    )
+
+    assert outcome.status == PolicyMeasurementState.GENERATION_LIMIT.value
+    current = service.store.load_current(cell.cell_id)
+    assert current is not None
+    assert policy_status_label(current.result) == ">1h"
+    provenance = current.result["provenance"]
+    assert isinstance(provenance, dict)
+    assert provenance["study_contract"] == {
+        "abi": "pyamplicol-z-table-f-attempt-binding-v1",
+        "study_id": "macbook-m3-z-table-f",
+        "study_contract_sha256": contract["sha256"],
+    }
+    assert provenance["worker_harness"] == scheduler.worker_harness_identity
+    assert all(
+        str(repo) not in str(value) and str(wrapper) not in str(value)
+        for value in provenance["worker_harness"].values()
+    )
+    assert _status(current.result) == r"\matrixstatus{ReportOrange}{>1h}"
+    assert (
+        validate_policy_measurement(
+            MACBOOK_M3_Z_TABLE_F_POLICY,
+            "macbook_M3",
+            cell,
+            current.result,
+            expected_source_revision=scheduler.source_revision,
+            expected_source_tree=scheduler.source_tree,
+        )
+        is PolicyMeasurementState.GENERATION_LIMIT
+    )
+
+
+def test_z_table_f_prepare_runs_authenticated_wrapper_and_returns_harness(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    measured = _git_repo(tmp_path / "measured", "measured")
+    wrapper = _git_repo(
+        tmp_path / "wrapper",
+        "policy",
+        report_wrapper=True,
+    )
+    service = ReportService(
+        ReportPaths.from_repo(
+            measured,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "locks",
+        )
+    )
+    contract = create_z_table_f_study_contract(
+        measured,
+        wrapper,
+        prior_store=service.store,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=_z_table_f_settings(
+            study_contract_sha256=str(contract["sha256"]),
+        ),
+        study_contract=contract,
+        study_contract_wrapper_root=wrapper,
+    )
+    cell = REPORT_CATALOG.cell(
+        "z-builtin-sm-n8-dd-z-jets-eager-jit-o2-selected-flow"
+    )
+    prepared = tmp_path / "prepared-model"
+    prepared.mkdir()
+
+    def fake_supervise(command, **arguments):
+        assert Path(command[4]) == (
+            wrapper / "src/pyamplicol/_profiling_campaign/result_tables.py"
+        )
+        assert "_prepare" in command
+        assert arguments["scrub_import_environment"] is True
+        assert arguments["working_directory"] == measured
+        result_path = Path(command[command.index("--result-json") + 1])
+        result_path.parent.mkdir(parents=True, exist_ok=True)
+        result_path.write_text(
+            json.dumps(
+                {
+                    "path": str(prepared),
+                    "reused": False,
+                    "worker_harness": scheduler.worker_harness_identity,
+                }
+            ),
+            encoding="ascii",
+        )
+        return SupervisedResult(
+            returncode=0,
+            reason="completed",
+            usage=ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    scheduler._ensure_prepared_model(
+        (
+            PlannedCell(
+                cell=cell,
+                dependency=False,
+                baseline_cell_id=None,
+                rank=0,
+            ),
+        )
+    )
+
+    assert scheduler._prepared_model_paths[cell.measurement.model] == prepared
+
+
+def test_z_table_f_scheduler_rejects_scope_and_missing_dependencies_before_attempt(
+    tmp_path: Path,
+) -> None:
+    repo = _git_repo(tmp_path / "repo", "measured")
+    wrapper = _git_repo(
+        tmp_path / "wrapper",
+        "policy",
+        report_wrapper=True,
+    )
+    artifact_root = tmp_path / "artifacts"
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo,
+            artifact_root=artifact_root,
+            coordination_root=tmp_path / "locks",
+        )
+    )
+    cell = REPORT_CATALOG.cell(
+        "scalar-contact-n2-scalar-contact-contracted"
+    )
+    contract = create_z_table_f_study_contract(
+        repo,
+        wrapper,
+        prior_store=service.store,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=_z_table_f_settings(
+            study_contract_sha256=str(contract["sha256"]),
+        ),
+        study_contract=contract,
+        study_contract_wrapper_root=wrapper,
+    )
+
+    dependent_cell = REPORT_CATALOG.cell(
+        "z-builtin-sm-n8-dd-z-jets-jit-o3-all-flow"
+    )
+    expanded = plan_campaign(
+        (dependent_cell,),
+        store=service.store,
+        settings=scheduler.settings,
+        expected_revision=scheduler.source_revision,
+        expected_tree=scheduler.source_tree,
+    )
+    requested = next(item for item in expanded if not item.dependency)
+    with pytest.raises(
+        StudyContractError,
+        match="unauthenticated comparison dependencies",
+    ):
+        scheduler._run_cell(requested)
+
+    with pytest.raises(StudyContractError, match="outside the contracted"):
+        scheduler._run_cell(
+            PlannedCell(
+                cell=cell,
+                dependency=False,
+                baseline_cell_id=None,
+                rank=0,
+            )
+        )
+
+    assert service.store.load_current(cell.cell_id, missing_ok=True) is None
+    assert not tuple(artifact_root.rglob("manifest.json"))
+
+
+def test_z_table_f_scheduler_rejects_bare_forged_sha_before_attempt(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    (repo / "src/pyamplicol/_profiling_campaign").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "test@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Test"),
+        cwd=repo,
+        check=True,
+    )
+    (repo / "README.md").write_text("fixture\n", encoding="ascii")
+    subprocess.run(("git", "add", "."), cwd=repo, check=True)
+    subprocess.run(("git", "commit", "-qm", "fixture"), cwd=repo, check=True)
+    artifact_root = tmp_path / "artifacts"
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo,
+            artifact_root=artifact_root,
+            coordination_root=tmp_path / "locks",
+        )
+    )
+
+    with pytest.raises(
+        StudyContractError,
+        match="not only a SHA-256",
+    ):
+        CampaignScheduler(service, settings=_z_table_f_settings())
+
+    assert not tuple(artifact_root.rglob("manifest.json"))
+
+
+def test_scheduler_uses_mac_memory_limit_without_generation_channel(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo = tmp_path / "repo"
+    (repo / "src/pyamplicol/_profiling_campaign").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "test@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Test"),
+        cwd=repo,
+        check=True,
+    )
+    (repo / "README.md").write_text("fixture\n", encoding="ascii")
+    subprocess.run(("git", "add", "."), cwd=repo, check=True)
+    subprocess.run(("git", "commit", "-qm", "fixture"), cwd=repo, check=True)
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "locks",
+        )
+    )
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+
+    def fake_supervise(_command, **arguments):
+        assert arguments["generation_timeout_seconds"] is None
+        assert arguments["phase_channel"] is None
+        assert arguments["max_rss_bytes"] == MACBOOK_M3_MEMORY_LIMIT_BYTES
+        rss = MACBOOK_M3_MEMORY_LIMIT_BYTES - 1
+        physical = MACBOOK_M3_MEMORY_LIMIT_BYTES + 1
+        return SupervisedResult(
+            returncode=-15,
+            reason="memory_limit",
+            usage=ResourceUsage(
+                available=True,
+                current_rss_bytes=rss,
+                peak_rss_bytes=rss,
+                child_count=0,
+                cpu_seconds=1.0,
+                wall_seconds=2.0,
+                current_physical_footprint_bytes=physical,
+                peak_physical_footprint_bytes=physical,
+                current_guard_bytes=physical,
+                peak_guard_bytes=physical,
+                memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+            ),
+            memory_limit_bytes=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+            memory_limit_reason=("darwin-process-tree-physical-footprint-limit"),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    scheduler = CampaignScheduler(service, settings=_mac_settings())
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            cell=cell,
+            dependency=False,
+            baseline_cell_id=None,
+            rank=0,
+        )
+    )
+
+    assert outcome.status == PolicyMeasurementState.MEMORY_LIMIT.value
+    current = service.store.load_current(cell.cell_id)
+    assert current is not None
+    assert policy_status_label(current.result) == ">30GB"
+    assert _status(current.result) == r"\matrixstatus{ReportOrange}{>30GB}"
+    assert (
+        current.result["resources"]["peak_physical_footprint_bytes"]
+        == MACBOOK_M3_MEMORY_LIMIT_BYTES + 1
+    )
+
+
+def test_scheduler_never_promotes_incomplete_memory_observation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo = tmp_path / "repo"
+    (repo / "src/pyamplicol/_profiling_campaign").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "test@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Test"),
+        cwd=repo,
+        check=True,
+    )
+    (repo / "README.md").write_text("fixture\n", encoding="ascii")
+    subprocess.run(("git", "add", "."), cwd=repo, check=True)
+    subprocess.run(("git", "commit", "-qm", "fixture"), cwd=repo, check=True)
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "locks",
+        )
+    )
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    probe_reason = "darwin-process-tree-physical-footprint-probe-unavailable"
+    usage = ResourceUsage(
+        available=False,
+        current_rss_bytes=None,
+        peak_rss_bytes=None,
+        child_count=None,
+        cpu_seconds=None,
+        wall_seconds=2.0,
+        error="synthetic footprint probe failure",
+        memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+        memory_probe_reason=probe_reason,
+    )
+
+    def fake_supervise(_command, **_arguments):
+        return SupervisedResult(
+            returncode=-15,
+            reason="memory_probe_error",
+            usage=usage,
+            memory_limit_bytes=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    scheduler = CampaignScheduler(service, settings=_mac_settings())
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            cell=cell,
+            dependency=False,
+            baseline_cell_id=None,
+            rank=0,
+        )
+    )
+
+    assert outcome.status == "error"
+    assert service.store.load_current(cell.cell_id, missing_ok=True) is None
+    assert (
+        _resource_payload(
+            usage,
+            memory_limit_bytes=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        )["memory_probe_reason"]
+        == probe_reason
+    )
+
+
+def test_terminal_comparison_peer_and_terminal_baseline_both_block() -> None:
+    baseline = SimpleNamespace(result={"status": "ok"})
+    selected_peer = SimpleNamespace(result={"status": "ok"})
+    terminal_peer_result = _memory_censor(
+        REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted"),
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 1,
+    )
+    terminal_peer = SimpleNamespace(result=terminal_peer_result)
+    currents = {
+        "baseline": (baseline, PolicyMeasurementState.SUCCESS),
+        "selected": (selected_peer, PolicyMeasurementState.SUCCESS),
+        "recurrence": (terminal_peer, PolicyMeasurementState.MEMORY_LIMIT),
+    }
+
+    resolved_baseline, peers, blockers = _partition_dependency_records(
+        baseline_cell_id="baseline",
+        comparison_peer_ids=("selected", "recurrence"),
+        currents=currents,  # type: ignore[arg-type]
+    )
+
+    assert resolved_baseline is baseline
+    assert peers == {"selected": selected_peer}
+    assert len(blockers) == 1
+    assert blockers[0]["cell_id"] == "recurrence"
+
+    _baseline, _peers, blockers = _partition_dependency_records(
+        baseline_cell_id="recurrence",
+        comparison_peer_ids=("selected",),
+        currents=currents,  # type: ignore[arg-type]
+    )
+    assert len(blockers) == 1
+    assert blockers[0]["cell_id"] == "recurrence"
+
+
+def test_scheduler_frontier_censors_dependencies_but_not_explicit_cells(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo = tmp_path / "repo"
+    (repo / "src/pyamplicol/_profiling_campaign").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "test@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Test"),
+        cwd=repo,
+        check=True,
+    )
+    (repo / "README.md").write_text("fixture\n", encoding="ascii")
+    subprocess.run(("git", "add", "."), cwd=repo, check=True)
+    subprocess.run(("git", "commit", "-qm", "fixture"), cwd=repo, check=True)
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "locks",
+        )
+    )
+    scheduler = CampaignScheduler(service, settings=_x86_settings())
+    source = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    target = REPORT_CATALOG.cell("scalar-contact-n3-scalar-contact-contracted")
+    peak = X86_EPYC_MEMORY_LIMIT_BYTES + 1
+    root = policy_censor_measurement(
+        X86_EPYC_POLICY,
+        "x86_EPYC",
+        source,
+        kind=PolicyCensorKind.MEMORY_LIMIT,
+        source_identity=scheduler.source_identity,
+        resources=_resources(peak),
+        observed_rss_bytes=peak,
+    )
+    service.store.new_attempt(
+        source.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(root)
+
+    def forbidden_supervisor(*_args, **_kwargs):
+        raise AssertionError("frontier target must not launch a worker")
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        forbidden_supervisor,
+    )
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            cell=target,
+            dependency=True,
+            baseline_cell_id=None,
+            rank=1,
+        )
+    )
+
+    assert outcome.status == PolicyMeasurementState.RESOURCE_FRONTIER.value
+    current = service.store.load_current(target.cell_id)
+    assert current is not None
+    assert policy_status_label(current.result) == "dependency >80GB"
+    assert (
+        validate_policy_measurement(
+            X86_EPYC_POLICY,
+            "x86_EPYC",
+            target,
+            current.result,
+            expected_source_revision=scheduler.source_revision,
+            expected_source_tree=scheduler.source_tree,
+        )
+        is PolicyMeasurementState.RESOURCE_FRONTIER
+    )
+
+    class ExplicitCellLaunched(RuntimeError):
+        pass
+
+    def launched_supervisor(*_args, **_kwargs):
+        raise ExplicitCellLaunched
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        launched_supervisor,
+    )
+    with pytest.raises(ExplicitCellLaunched):
+        scheduler._run_cell(
+            PlannedCell(
+                cell=target,
+                dependency=False,
+                baseline_cell_id=None,
+                rank=1,
+            )
+        )
+
+
+def test_final_audit_counts_policy_terminal_cells_without_claiming_numerics(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cell = next(
+        cell for cell in REPORT_CATALOG.measurement_cells() if cell.n_final == 1
+    )
+    static_cell = REPORT_CATALOG.cell(
+        "reference-amplicol-full-n6-dd-4q-lines-contracted"
+    )
+
+    class OneCellCatalog:
+        matrix_datasets = ()
+        process_families = ()
+        scalar_datasets = ()
+        z_variants = ()
+        models: ClassVar[dict[object, object]] = {}
+
+        def measurement_cells(self):
+            return (cell, static_cell)
+
+        def baseline_cell(self, _cell):
+            return None
+
+        def validation_baseline_cell(self, _cell):
+            return None
+
+        def static_na_reason(self, candidate):
+            if candidate == static_cell:
+                return STATIC_NA_ORIGINAL_AMPLICOL_OPEN_QUARK_LINE_LIMIT
+            return None
+
+    catalog = OneCellCatalog()
+    paths = ReportPaths.from_repo(
+        tmp_path,
+        artifact_root=tmp_path / "artifacts",
+        coordination_root=tmp_path / "locks",
+    )
+    service = ReportService(paths, catalog=catalog)  # type: ignore[arg-type]
+    terminal = _memory_censor(
+        cell,
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 1,
+    )
+    service.store.new_attempt(
+        cell.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(terminal)
+    caches = build_reset_caches(catalog)  # type: ignore[arg-type]
+    for payload in caches.values():
+        for entry in payload["entries"]:
+            if entry["cell_id"] == cell.cell_id:
+                entry["measurement"] = portable_publication_value(
+                    terminal,
+                    paths,
+                )
+    paths.results_dir.mkdir(parents=True)
+    for name, payload in caches.items():
+        (paths.results_dir / name).write_text(
+            json.dumps(payload),
+            encoding="ascii",
+        )
+    monkeypatch.setattr(
+        service,
+        "audit",
+        lambda: {"cache_render_match": True},
+    )
+
+    result = audit_final_report(
+        tmp_path,
+        expected_source_revision=_REVISION,
+        max_n_final=6,
+        expected_cell_count=2,
+        catalog=catalog,  # type: ignore[arg-type]
+        service=service,
+        source_auditor=lambda *_args: None,
+        pdf_auditor=lambda _service: {"status": "ok"},
+        campaign_policy=X86_EPYC_POLICY,
+    )
+
+    assert result["policy_state_counts"] == {"memory_limit": 1}
+    assert result["policy_complete_cell_count"] == 1
+    assert result["numerically_evidenced_cell_count"] == 0
+    assert result["declared_cell_count"] == 2
+    assert result["measurable_cell_count"] == 1
+    assert result["catalog_static_na_cell_count"] == 1
+    assert result["catalog_static_na_reason_counts"] == {
+        STATIC_NA_ORIGINAL_AMPLICOL_OPEN_QUARK_LINE_LIMIT: 1,
+    }
+    assert result["authenticated_current_count"] == 1
+    visible = result["visible_completeness"]
+    assert isinstance(visible, dict)
+    assert visible["status"] == "ok"
+    assert visible["declared_measurement_cell_count"] == 2
+    assert visible["required_measurement_count"] == 1
+    assert visible["rendered_required_measurement_count"] == 1
+    assert visible["catalog_static_na_cell_count"] == 1
+    assert visible["rendered_catalog_static_na_cell_count"] == 1
+
+    service.store.new_attempt(
+        static_cell.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(empty_measurement())
+    with pytest.raises(
+        FinalAuditError,
+        match="catalog static N/A cell has a published current",
+    ):
+        audit_final_report(
+            tmp_path,
+            expected_source_revision=_REVISION,
+            max_n_final=6,
+            expected_cell_count=2,
+            catalog=catalog,  # type: ignore[arg-type]
+            service=service,
+            source_auditor=lambda *_args: None,
+            verify_pdf=False,
+            campaign_policy=X86_EPYC_POLICY,
+        )
+
+
+def test_final_audit_requires_exact_monotone_resource_frontier(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    target = REPORT_CATALOG.cell("scalar-contact-n3-scalar-contact-contracted")
+
+    class TwoCellCatalog:
+        matrix_datasets = ()
+        process_families = ()
+        scalar_datasets = ()
+        z_variants = ()
+        models: ClassVar[dict[object, object]] = {}
+
+        def measurement_cells(self):
+            return (source, target)
+
+        def baseline_cell(self, _cell):
+            return None
+
+        def validation_baseline_cell(self, _cell):
+            return None
+
+        def static_na_reason(self, _cell):
+            return None
+
+    catalog = TwoCellCatalog()
+    paths = ReportPaths.from_repo(
+        tmp_path,
+        artifact_root=tmp_path / "artifacts",
+        coordination_root=tmp_path / "locks",
+    )
+    service = ReportService(paths, catalog=catalog)  # type: ignore[arg-type]
+    root = _memory_censor(
+        source,
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 1,
+    )
+    frontier = policy_censor_measurement(
+        X86_EPYC_POLICY,
+        "x86_EPYC",
+        target,
+        kind=PolicyCensorKind.RESOURCE_FRONTIER,
+        source_identity=_IDENTITY,
+        resources=None,
+        frontier=resource_frontier_reference(target, source, root),
+    )
+
+    def publish(measurements: tuple[dict[str, object], ...]) -> None:
+        for cell, measurement in zip(
+            (source, target),
+            measurements,
+            strict=True,
+        ):
+            service.store.new_attempt(
+                cell.cell_id,
+                ArtifactPolicy.REGENERATE,
+            ).publish(measurement)
+        caches = build_reset_caches(catalog)  # type: ignore[arg-type]
+        for payload in caches.values():
+            entries = payload["entries"]
+            assert isinstance(entries, list)
+            for entry in entries:
+                cell_id = str(entry["cell_id"])
+                measurement = measurements[0 if cell_id == source.cell_id else 1]
+                entry["measurement"] = portable_publication_value(
+                    measurement,
+                    paths,
+                )
+        paths.results_dir.mkdir(parents=True, exist_ok=True)
+        for name, payload in caches.items():
+            (paths.results_dir / name).write_text(
+                json.dumps(payload),
+                encoding="ascii",
+            )
+
+    publish((root, frontier))
+    monkeypatch.setattr(
+        service,
+        "audit",
+        lambda: {"cache_render_match": True},
+    )
+    result = audit_final_report(
+        tmp_path,
+        expected_source_revision=_REVISION,
+        max_n_final=3,
+        expected_cell_count=2,
+        catalog=catalog,  # type: ignore[arg-type]
+        service=service,
+        source_auditor=lambda *_args: None,
+        pdf_auditor=lambda _service: {"status": "ok"},
+        campaign_policy=X86_EPYC_POLICY,
+    )
+    assert result["hard_resource_censor_count"] == 1
+    assert result["resource_frontier_cell_count"] == 1
+
+    second_root = _memory_censor(
+        target,
+        peak=X86_EPYC_MEMORY_LIMIT_BYTES + 2,
+    )
+    publish((root, second_root))
+    with pytest.raises(
+        FinalAuditError,
+        match="higher multiplicity is not bound to resource frontier",
+    ):
+        audit_final_report(
+            tmp_path,
+            expected_source_revision=_REVISION,
+            max_n_final=3,
+            expected_cell_count=2,
+            catalog=catalog,  # type: ignore[arg-type]
+            service=service,
+            source_auditor=lambda *_args: None,
+            pdf_auditor=lambda _service: {"status": "ok"},
+            campaign_policy=X86_EPYC_POLICY,
+        )
diff --git a/pyamplicol/tests/unit/test_performance_report_campaign_reset.py b/pyamplicol/tests/unit/test_performance_report_campaign_reset.py
new file mode 100644
index 0000000000..791251d888
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_campaign_reset.py
@@ -0,0 +1,704 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tools.performance_report.artifacts import ArtifactStore
+from tools.performance_report.campaign_policy import MACBOOK_M3_POLICY
+from tools.performance_report.campaign_reset import (
+    BASELINE_GATE_FILENAME,
+    CAMPAIGN_MARKER_FILENAME,
+    EXPECTED_AMPLICOL_CELL_COUNT,
+    EXPECTED_CATALOG_CELL_COUNT,
+    EXPECTED_NON_AMPLICOL_CELL_COUNT,
+    CampaignResetError,
+    OriginalAmplicolSeed,
+    ResetTransactionPaths,
+    _lc_seed_family_rejections,
+    _legacy_contract,
+    assert_campaign_marker,
+    build_seed_manifest,
+    campaign_marker,
+    commit_or_recover_reset,
+    mark_campaign_ready,
+    sha256_payload,
+    stage_seed_store,
+    write_prepared_journal,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import (
+    Accuracy,
+    ArtifactPolicy,
+    ExecutionMode,
+    Workload,
+)
+from tools.performance_report.scheduler import CampaignSettings, plan_campaign
+from tools.performance_report.service import ReportPaths, ReportService
+from tools.performance_report.source_identity import ReportSourceIdentity
+
+_REVISION = "1" * 40
+_TREE = "2" * 40
+_SHA = "3" * 64
+
+
+def _store(tmp_path: Path) -> ArtifactStore:
+    return ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+
+
+def _cell(mode: ExecutionMode):
+    return next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is mode
+        and (
+            mode is not ExecutionMode.AMPLICOL
+            or cell.measurement.accuracy is not Accuracy.LC
+        )
+    )
+
+
+def test_reset_cardinality_matches_the_current_catalog() -> None:
+    cells = REPORT_CATALOG.measurement_cells()
+    amplicol = sum(
+        cell.measurement.execution_mode is ExecutionMode.AMPLICOL for cell in cells
+    )
+
+    assert EXPECTED_CATALOG_CELL_COUNT == len(cells) == 2198
+    assert EXPECTED_AMPLICOL_CELL_COUNT == amplicol == 314
+    assert EXPECTED_NON_AMPLICOL_CELL_COUNT == len(cells) - amplicol == 1884
+    assert (
+        sum(REPORT_CATALOG.static_na_reason(cell) is not None for cell in cells) == 34
+    )
+    assert sum(REPORT_CATALOG.static_na_reason(cell) is None for cell in cells) == 2164
+
+
+def _contract() -> dict[str, object]:
+    return {
+        "legacy_revision": "4" * 40,
+        "report_source_revision": _REVISION,
+        "report_source_tree": _TREE,
+        "compiler_sha256": "5" * 64,
+        "selector_contract_sha256": "6" * 64,
+        "validation_sha256": "7" * 64,
+        "resource_evidence_sha256": "8" * 64,
+        "target_runtime_seconds": 5.0,
+        "workload_specific_generation": True,
+        "row_selection_policy": "row-v1",
+        "selector_color_word_policy": "selector-v1",
+    }
+
+
+def _publish(store: ArtifactStore, cell_id: str):
+    return store.new_attempt(
+        cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(
+        {
+            "status": "ok",
+            "provenance": {
+                "report_source_revision": _REVISION,
+                "report_source_tree": _TREE,
+                "report_measured_source_revision": _REVISION,
+                "report_measured_source_tree": _TREE,
+            },
+        }
+    )
+
+
+def _activate_marker(
+    root: Path,
+    seed: dict[str, object],
+    *,
+    profile: str,
+    revision: str,
+    tree: str,
+) -> None:
+    marker = campaign_marker(
+        campaign_id="campaign-1",
+        profile=profile,
+        source_revision=revision,
+        source_tree=tree,
+        policy_sha256=_SHA,
+        seed_manifest_sha256=str(seed["seed_manifest_sha256"]),
+        archive_manifest_sha256=_SHA,
+    )
+    (root / CAMPAIGN_MARKER_FILENAME).write_text(json.dumps(marker))
+    gate: dict[str, object] = {
+        "campaign_id": "campaign-1",
+        "profile": profile,
+        "source_revision": revision,
+        "source_tree": tree,
+        "prepared_marker_sha256": marker["marker_sha256"],
+    }
+    gate["baseline_gate_sha256"] = sha256_payload(gate)
+    (root / BASELINE_GATE_FILENAME).write_text(json.dumps(gate))
+    mark_campaign_ready(
+        root,
+        baseline_gate_sha256=str(gate["baseline_gate_sha256"]),
+    )
+
+
+def test_contracted_amplicol_contract_accepts_no_selector() -> None:
+    record = SimpleNamespace(
+        cell_id="reference-amplicol-full-example",
+        result={
+            "selector_contract": None,
+            "resources": {"monitor": "test", "peak_rss_bytes": 1},
+            "validation": {
+                "status": "ok",
+                "method": "independent-original-amplicol-oracle",
+                "point_digest": _SHA,
+            },
+            "provenance": {
+                "method": "original-amplicol-generated-library",
+                "revision": _REVISION,
+                "report_source_revision": _REVISION,
+                "report_source_tree": _TREE,
+                "report_measured_source_revision": _REVISION,
+                "report_measured_source_tree": _TREE,
+                "report_source_clean": True,
+                "compiler": {
+                    "identity": "gfortran",
+                    "version": "GNU Fortran",
+                    "flags": ["-O3"],
+                    "target": "test-target",
+                    "executable_sha256": _SHA,
+                },
+                "target_runtime_seconds": 5.0,
+                "runtime_profile": {
+                    "measurement": {"target_runtime_achieved": True}
+                },
+                "generation_timing_is_workload_specific": True,
+                "row_selection_policy": "row-v1",
+                "selector_color_word_policy": "selector-v1",
+            },
+        },
+    )
+
+    contract = _legacy_contract(
+        record,
+        requires_selector=False,
+        expected_legacy_revision=_REVISION,
+    )
+
+    assert contract["selector_contract_sha256"] is None
+
+
+def _lc_record(
+    cell_id: str,
+    *,
+    point: str = "a" * 64,
+    common_value: float = 1.0,
+) -> SimpleNamespace:
+    selector = {
+        "selected_color_flow_ids": ["flow:2,1"],
+        "selected_color_words": [[2, 1]],
+        "all_flow_helicity_ids": ["h:-1,+1"],
+        "all_flow_source_helicities": {"1": -1, "2": 1},
+        "point_digest": point,
+    }
+    return SimpleNamespace(
+        cell_id=cell_id,
+        result={
+            "selector_contract": selector,
+            "resources": {"monitor": "test", "peak_rss_bytes": 1},
+            "validation": {
+                "status": "ok",
+                "method": "independent-original-amplicol-oracle",
+                "point_digest": point,
+                "lc_common_component": {
+                    "abi": "pyamplicol-report-lc-common-component-v1",
+                    "cell_id": cell_id,
+                    "value": common_value,
+                    "point_digest": point,
+                    "helicity_ids": ["h:-1,+1"],
+                    "color_flow_ids": ["flow:2,1"],
+                },
+            },
+            "provenance": {
+                "method": "original-amplicol-generated-library",
+                "revision": _REVISION,
+                "report_source_revision": _REVISION,
+                "report_source_tree": _TREE,
+                "report_measured_source_revision": _REVISION,
+                "report_measured_source_tree": _TREE,
+                "report_source_clean": True,
+                "compiler": {
+                    "identity": "gfortran",
+                    "version": "GNU Fortran",
+                    "flags": ["-O3"],
+                    "target": "test-target",
+                    "executable_sha256": _SHA,
+                },
+                "target_runtime_seconds": 5.0,
+                "runtime_profile": {
+                    "measurement": {"target_runtime_achieved": True}
+                },
+                "generation_timing_is_workload_specific": True,
+                "row_selection_policy": "row-v1",
+                "selector_color_word_policy": "selector-v1",
+            },
+        },
+    )
+
+
+def test_lc_seed_rejects_stale_point_and_structural_zero() -> None:
+    record = _lc_record("reference-amplicol-lc-example-selected-flow")
+
+    contract = _legacy_contract(
+        record,
+        requires_selector=True,
+        expected_legacy_revision=_REVISION,
+        expected_point_digest="a" * 64,
+    )
+    assert contract["selector_contract_sha256"] is not None
+
+    with pytest.raises(CampaignResetError, match="predates"):
+        _legacy_contract(
+            record,
+            requires_selector=True,
+            expected_legacy_revision=_REVISION,
+            expected_point_digest="b" * 64,
+        )
+    with pytest.raises(CampaignResetError, match="structural zero"):
+        _legacy_contract(
+            _lc_record(record.cell_id, common_value=0.0),
+            requires_selector=True,
+            expected_legacy_revision=_REVISION,
+            expected_point_digest="a" * 64,
+        )
+
+
+def test_lc_seed_family_requires_matching_selected_and_all_flow() -> None:
+    selected = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        and cell.measurement.accuracy is Accuracy.LC
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+    all_flow = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == selected.dataset_id
+        and cell.process == selected.process
+        and cell.n_final == selected.n_final
+        and cell.measurement == selected.measurement
+        and cell.workload is Workload.ALL_FLOW
+    )
+    cells = {
+        selected.cell_id: selected,
+        all_flow.cell_id: all_flow,
+    }
+    records = {
+        selected.cell_id: _lc_record(selected.cell_id),
+        all_flow.cell_id: _lc_record(all_flow.cell_id),
+    }
+
+    assert (
+        _lc_seed_family_rejections(
+            cells=cells,
+            records_by_cell=records,
+            admitted_cell_ids=set(cells),
+        )
+        == {}
+    )
+
+    records[all_flow.cell_id].result["selector_contract"][
+        "selected_color_flow_ids"
+    ] = ["flow:1,2"]
+    rejected = _lc_seed_family_rejections(
+        cells=cells,
+        records_by_cell=records,
+        admitted_cell_ids=set(cells),
+    )
+    assert set(rejected) == set(cells)
+    assert all("contracts differ" in reason for reason in rejected.values())
+
+    incomplete = _lc_seed_family_rejections(
+        cells=cells,
+        records_by_cell=records,
+        admitted_cell_ids={selected.cell_id},
+    )
+    assert incomplete == {
+        selected.cell_id: (
+            "LC seed family is incomplete; selected/all-flow rows must be "
+            "remeasured under one selector authority"
+        )
+    }
+
+
+def test_seed_selects_only_ok_original_amplicol_and_preserves_bytes(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = _store(tmp_path / "source")
+    reference = _cell(ExecutionMode.AMPLICOL)
+    candidate = _cell(ExecutionMode.RECURRENCE)
+    original = _publish(source, reference.cell_id)
+    _publish(source, candidate.cell_id)
+    monkeypatch.setattr(
+        "tools.performance_report.campaign_reset.validate_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.campaign_reset.validate_policy_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.campaign_reset._legacy_contract",
+        lambda _record, **_kwargs: _contract(),
+    )
+
+    seed = build_seed_manifest(
+        profile="macbook_M3",
+        store=source,
+        policy=MACBOOK_M3_POLICY,
+        final_source_revision="9" * 40,
+        final_source_tree="a" * 40,
+        expected_legacy_revision="4" * 40,
+    )
+    assert seed["seed_count"] == 1
+    assert [pin["cell_id"] for pin in seed["pins"]] == [reference.cell_id]
+
+    destination = stage_seed_store(
+        source_store=source,
+        destination_root=tmp_path / "fresh-artifacts",
+        destination_lock_root=tmp_path / "fresh-locks",
+        seed_manifest=seed,
+    )
+    inherited = destination.load_current(reference.cell_id)
+    assert inherited is not None
+    assert inherited.attempt_id == original.attempt_id
+    assert destination.load_current(candidate.cell_id, missing_ok=True) is None
+    assert destination.cell_attempt_ids(reference.cell_id) == (
+        original.attempt_id,
+    )
+    loaded = OriginalAmplicolSeed.load(
+        destination.artifact_root / "original_amplicol_seed.json",
+        profile="macbook_M3",
+        store=destination,
+    )
+    assert loaded.source_for_current(
+        inherited,
+        active_revision="9" * 40,
+        active_tree="a" * 40,
+    ) == (_REVISION, _TREE)
+    assert (
+        loaded.source_for_current(
+            inherited,
+            active_revision="b" * 40,
+            active_tree="c" * 40,
+        )
+        is None
+    )
+
+
+def test_seed_rejects_changed_current_pointer(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = _store(tmp_path / "source")
+    reference = _cell(ExecutionMode.AMPLICOL)
+    _publish(source, reference.cell_id)
+    monkeypatch.setattr(
+        "tools.performance_report.campaign_reset.validate_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.campaign_reset.validate_policy_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.campaign_reset._legacy_contract",
+        lambda _record, **_kwargs: _contract(),
+    )
+    seed = build_seed_manifest(
+        profile="macbook_M3",
+        store=source,
+        policy=MACBOOK_M3_POLICY,
+        final_source_revision="9" * 40,
+        final_source_tree="a" * 40,
+        expected_legacy_revision="4" * 40,
+    )
+    destination = stage_seed_store(
+        source_store=source,
+        destination_root=tmp_path / "fresh-artifacts",
+        destination_lock_root=tmp_path / "fresh-locks",
+        seed_manifest=seed,
+    )
+    pointer = next(destination.cells_root.glob("*/current.json"))
+    payload = json.loads(pointer.read_text())
+    payload["manifest_sha256"] = "0" * 64
+    pointer.write_text(json.dumps(payload))
+
+    with pytest.raises(Exception, match="digest"):
+        OriginalAmplicolSeed.load(
+            destination.artifact_root / "original_amplicol_seed.json",
+            profile="macbook_M3",
+            store=destination,
+        )
+
+
+@pytest.mark.parametrize(
+    ("catalog_count", "amplicol_count"),
+    ((1646, 284), (1796, 314)),
+)
+def test_seed_load_accepts_only_supported_historical_catalog_cardinality(
+    tmp_path: Path,
+    catalog_count: int,
+    amplicol_count: int,
+) -> None:
+    store = _store(tmp_path)
+    seed_path = store.artifact_root / "original_amplicol_seed.json"
+    seed_path.parent.mkdir(parents=True, exist_ok=True)
+    payload: dict[str, object] = {
+        "schema": "pyamplicol-original-amplicol-seed-v1",
+        "profile": "x86_EPYC",
+        "final_source_revision": _REVISION,
+        "final_source_tree": _TREE,
+        "expected_legacy_revision": "4" * 40,
+        "catalog_cell_count": catalog_count,
+        "amplicol_catalog_cell_count": amplicol_count,
+        "seed_count": 0,
+        "pins": [],
+        "rejected": [],
+    }
+    payload["seed_manifest_sha256"] = sha256_payload(payload)
+    seed_path.write_text(json.dumps(payload), encoding="ascii")
+
+    loaded = OriginalAmplicolSeed.load(
+        seed_path,
+        profile="x86_EPYC",
+        store=store,
+    )
+    assert loaded.pins_by_cell == {}
+
+    payload.pop("seed_manifest_sha256")
+    payload["catalog_cell_count"] = catalog_count - 1
+    payload["seed_manifest_sha256"] = sha256_payload(payload)
+    seed_path.write_text(json.dumps(payload), encoding="ascii")
+    with pytest.raises(CampaignResetError, match="catalog coverage differs"):
+        OriginalAmplicolSeed.load(
+            seed_path,
+            profile="x86_EPYC",
+            store=store,
+        )
+
+
+def test_reset_transaction_moves_old_roots_and_is_idempotent(
+    tmp_path: Path,
+) -> None:
+    source_publication = tmp_path / "old-publication"
+    source_artifacts = tmp_path / "old-artifacts"
+    source_coordination = tmp_path / "old-coordination"
+    destination_publication = tmp_path / "new-publication"
+    destination_artifacts = tmp_path / "new-artifacts"
+    destination_coordination = tmp_path / "new-coordination"
+    archive = tmp_path / "archive"
+    staging = tmp_path / "staging"
+    for path, name in (
+        (source_publication, "old-doc"),
+        (source_artifacts, "old-artifact"),
+        (source_coordination, "old-lock"),
+        (staging / "archive-publication", "archived-doc"),
+        (staging / "fresh-artifacts", "seed"),
+        (staging / "fresh-coordination", "fresh-lock"),
+        (staging / "fresh-publication", "fresh-doc"),
+    ):
+        path.mkdir(parents=True)
+        (path / name).write_text(name)
+    (staging / "archive-manifest.json").write_text("{}")
+    paths = ResetTransactionPaths(
+        source_publication=source_publication,
+        source_artifact_root=source_artifacts,
+        source_coordination_root=source_coordination,
+        destination_publication=destination_publication,
+        destination_artifact_root=destination_artifacts,
+        destination_coordination_root=destination_coordination,
+        archive_root=archive,
+        staging_root=staging,
+        guard_path=tmp_path / "reset.guard",
+    )
+    write_prepared_journal(
+        profile="macbook_M3",
+        campaign_id="campaign-1",
+        archive_id="archive-1",
+        paths=paths,
+        archive_manifest_sha256=_SHA,
+        seed_manifest_sha256=_SHA,
+        marker_sha256=_SHA,
+    )
+
+    first = commit_or_recover_reset(paths.journal_path)
+    second = commit_or_recover_reset(paths.journal_path)
+
+    assert first["state"] == second["state"] == "COMMITTED"
+    assert (archive / "artifacts" / "old-artifact").is_file()
+    assert (archive / "coordination" / "old-lock").is_file()
+    assert (archive / "publication" / "archived-doc").is_file()
+    assert (destination_artifacts / "seed").is_file()
+    assert (destination_coordination / "fresh-lock").is_file()
+    assert (destination_publication / "fresh-doc").is_file()
+
+
+def test_campaign_marker_is_digest_bound(tmp_path: Path) -> None:
+    marker = campaign_marker(
+        campaign_id="campaign-1",
+        profile="x86_EPYC",
+        source_revision=_REVISION,
+        source_tree=_TREE,
+        policy_sha256=_SHA,
+        seed_manifest_sha256=_SHA,
+        archive_manifest_sha256=_SHA,
+    )
+    root = tmp_path / "artifacts"
+    root.mkdir()
+    (root / CAMPAIGN_MARKER_FILENAME).write_text(json.dumps(marker))
+
+    with pytest.raises(CampaignResetError, match="not READY"):
+        assert_campaign_marker(
+            root,
+            campaign_id="campaign-1",
+            profile="x86_EPYC",
+            source_revision=_REVISION,
+            source_tree=_TREE,
+        )
+    assert assert_campaign_marker(
+        root,
+        campaign_id="campaign-1",
+        profile="x86_EPYC",
+        source_revision=_REVISION,
+        source_tree=_TREE,
+        require_ready=False,
+    )["marker_sha256"] == marker["marker_sha256"]
+
+    marker["campaign_id"] = "different"
+    (root / CAMPAIGN_MARKER_FILENAME).write_text(json.dumps(marker))
+    with pytest.raises(CampaignResetError, match="differs"):
+        assert_campaign_marker(
+            root,
+            campaign_id="campaign-1",
+            profile="x86_EPYC",
+            source_revision=_REVISION,
+            source_tree=_TREE,
+            require_ready=False,
+        )
+
+
+def test_seed_is_authorized_by_scheduler_and_report_merge(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = _store(tmp_path / "source")
+    reference = _cell(ExecutionMode.AMPLICOL)
+    _publish(source, reference.cell_id)
+    for target in (
+        "tools.performance_report.campaign_reset.validate_measurement",
+        "tools.performance_report.campaign_reset.validate_policy_measurement",
+    ):
+        monkeypatch.setattr(target, lambda *_args, **_kwargs: None)
+    monkeypatch.setattr(
+        "tools.performance_report.campaign_reset._legacy_contract",
+        lambda _record, **_kwargs: _contract(),
+    )
+    seed = build_seed_manifest(
+        profile="macbook_M3",
+        store=source,
+        policy=MACBOOK_M3_POLICY,
+        final_source_revision="9" * 40,
+        final_source_tree="a" * 40,
+        expected_legacy_revision="4" * 40,
+    )
+    artifact_root = (
+        tmp_path
+        / "repo"
+        / ".artifacts"
+        / "performance-report"
+        / "macbook_M3"
+    )
+    coordination_root = (
+        tmp_path
+        / "repo"
+        / ".artifacts"
+        / "performance-report-coordination"
+        / "macbook_M3"
+    )
+    destination = stage_seed_store(
+        source_store=source,
+        destination_root=artifact_root,
+        destination_lock_root=coordination_root,
+        seed_manifest=seed,
+    )
+    _activate_marker(
+        artifact_root,
+        seed,
+        profile="macbook_M3",
+        revision="9" * 40,
+        tree="a" * 40,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.validate_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.validate_policy_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    settings = CampaignSettings(
+        workers=1,
+        cell_cores=1,
+        target_runtime_seconds=5.0,
+        max_rss_bytes=30_000_000_000,
+        campaign_policy=MACBOOK_M3_POLICY,
+        report_profile="macbook_M3",
+        missing_only=True,
+    )
+    assert plan_campaign(
+        (reference,),
+        store=destination,
+        settings=settings,
+        expected_revision="9" * 40,
+        expected_tree="a" * 40,
+    ) == ()
+
+    repo = tmp_path / "repo"
+    docs = repo / "docs" / "performance_reports" / "macbook_M3"
+    docs.mkdir(parents=True)
+    service = ReportService(
+        ReportPaths(
+            repo_root=repo,
+            docs_dir=docs,
+            results_dir=docs / "results",
+            artifact_root=artifact_root,
+            coordination_root=coordination_root,
+        )
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.service.require_eligible_report_source",
+        lambda _root: ReportSourceIdentity("9" * 40, "a" * 40, ()),
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.service.validate_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.cache.validate_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    caches = service.reset_payloads()
+    assert service.merge_current(caches) == 1
+    measurement = next(
+        entry["measurement"]
+        for cache in caches.values()
+        for entry in cache["entries"]
+        if entry["cell_id"] == reference.cell_id
+    )
+    assert measurement["status"] == "ok"
diff --git a/pyamplicol/tests/unit/test_performance_report_cli.py b/pyamplicol/tests/unit/test_performance_report_cli.py
new file mode 100644
index 0000000000..259d2283b6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_cli.py
@@ -0,0 +1,839 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tools.performance_report import final_audit
+from tools.performance_report.campaign_policy import (
+    MACBOOK_M3_POLICY,
+    MACBOOK_M3_Z_TABLE_F_POLICY_NAME,
+    X86_EPYC_POLICY,
+    CampaignPolicyError,
+    PolicyMeasurementState,
+    validate_policy_measurement,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.cli import (
+    _compile_pdf,
+    _is_pinned_epyc_orphan_without_rss,
+    _launch_async_publication,
+    _parser,
+    main,
+)
+from tools.performance_report.service import ReportPaths, ReportService
+
+
+def _initialize_git_repo(repo: Path) -> None:
+    (repo / "src/pyamplicol/_profiling_campaign/results").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "report-tests@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Report Tests"),
+        cwd=repo,
+        check=True,
+    )
+    (repo / "README.md").write_text("# report fixture\n", encoding="ascii")
+    subprocess.run(("git", "add", "README.md"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "commit", "-q", "-m", "Initialize fixture"),
+        cwd=repo,
+        check=True,
+    )
+
+
+def _fake_latexmk(tmp_path: Path, log: str) -> Path:
+    executable = tmp_path / "fake-latexmk"
+    executable.write_text(
+        "#!/usr/bin/env python3\n"
+        "from pathlib import Path\n"
+        "assert not Path('campaign_artifacts').exists()\n"
+        "Path('pyAmpliCol.pdf').write_bytes(b'%PDF-1.4\\n%%EOF\\n')\n"
+        f"Path('pyAmpliCol.log').write_text({log!r}, encoding='utf-8')\n",
+        encoding="utf-8",
+    )
+    executable.chmod(0o755)
+    return executable
+
+
+def test_table_filler_defaults_to_five_seconds_per_cell() -> None:
+    populate = _parser().parse_args(("populate",))
+    assert populate.target_runtime == 5.0
+    assert populate.generation_time_limit_seconds is None
+    assert populate.fast_lineage is False
+    assert populate.exclude_cell_id == []
+
+    publisher = _parser().parse_args(("publish-snapshot",))
+    assert publisher.watch is False
+    assert publisher.interval_seconds == 600.0
+    assert publisher.pdf_timeout_seconds == 900.0
+    assert publisher.expected_page_count == 73
+
+    worker = _parser().parse_args(
+        (
+            "_worker",
+            "--cell-id",
+            "cell",
+            "--attempt-root",
+            "attempt",
+            "--result-json",
+            "result.json",
+            "--memory-limit-bytes",
+            "15000000000",
+            "--madgraph",
+            "/tmp/madgraph",
+        )
+    )
+    assert worker.target_runtime == 5.0
+    assert worker.memory_limit_bytes == 15_000_000_000
+    assert worker.madgraph == Path("/tmp/madgraph")
+
+    limited = _parser().parse_args(
+        ("populate", "--generation-time-limit-seconds", "7200")
+    )
+    assert limited.generation_time_limit_seconds == 7200.0
+
+    decimal_limits = _parser().parse_args(
+        (
+            "populate",
+            "--max-ram-gb",
+            "30",
+            "--campaign-max-ram-gb",
+            "30",
+        )
+    )
+    assert decimal_limits.max_ram_gb == 30.0
+    assert decimal_limits.campaign_max_ram_gb == 30.0
+
+    study = _parser().parse_args(
+        (
+            "populate",
+            "--study-policy",
+            MACBOOK_M3_Z_TABLE_F_POLICY_NAME,
+            "--max-ram-gb",
+            "30",
+        )
+    )
+    assert study.study_policy == MACBOOK_M3_Z_TABLE_F_POLICY_NAME
+    assert study.max_ram_gb == 30.0
+
+
+def test_worker_cli_threads_madgraph_installation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cell = REPORT_CATALOG.measurement_cells()[0]
+    installation = tmp_path / "madgraph"
+    captured: dict[str, object] = {}
+
+    def write(
+        cell_id: str,
+        result_path: Path,
+        **arguments: object,
+    ) -> dict[str, object]:
+        captured["cell_id"] = cell_id
+        captured["result_path"] = result_path
+        captured.update(arguments)
+        return {"status": "ok"}
+
+    monkeypatch.setattr("tools.performance_report.cli.write_cell_result", write)
+    assert (
+        main(
+            (
+                "--repo-root",
+                str(tmp_path),
+                "_worker",
+                "--cell-id",
+                cell.cell_id,
+                "--attempt-root",
+                str(tmp_path / "attempt"),
+                "--result-json",
+                str(tmp_path / "result.json"),
+                "--madgraph",
+                str(installation),
+            )
+        )
+        == 0
+    )
+
+    assert captured["cell_id"] == cell.cell_id
+    assert captured["madgraph_installation"] == installation
+
+
+def test_async_publication_can_run_the_authenticated_wrapper_entrypoint(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    measured = tmp_path / "measured"
+    measured.mkdir()
+    wrapper_entrypoint = (
+        tmp_path / "wrapper/src/pyamplicol/_profiling_campaign/result_tables.py"
+    )
+    wrapper_entrypoint.parent.mkdir(parents=True)
+    wrapper_entrypoint.write_text("# authenticated wrapper\n", encoding="ascii")
+    service = ReportService(
+        ReportPaths.from_repo(
+            measured,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    captured: dict[str, object] = {}
+
+    def popen(command, **arguments):
+        captured["command"] = tuple(command)
+        captured.update(arguments)
+        return SimpleNamespace()
+
+    monkeypatch.setattr("tools.performance_report.cli.subprocess.Popen", popen)
+
+    log_path = _launch_async_publication(
+        service,
+        entrypoint=wrapper_entrypoint,
+    )
+
+    command = captured["command"]
+    assert isinstance(command, tuple)
+    assert Path(command[4]) == wrapper_entrypoint.resolve()
+    assert command[command.index("--repo-root") + 1] == str(
+        measured.resolve()
+    )
+    assert command[-1] == "publish-snapshot"
+    assert log_path == (
+        service.paths.artifact_root
+        / "publication-logs/refresh-pdf-end.log"
+    )
+
+
+def test_pinned_epyc_orphan_is_the_only_unavailable_rss_exception() -> None:
+    cell = REPORT_CATALOG.cell(
+        "reference-amplicol-lc-n8-gg-gluons-selected-flow"
+    )
+    measurement = {
+        "status": "ok",
+        "generation_seconds": 1.0,
+        "resources": {
+            "monitor": "external-cell-supervisor",
+            "peak_rss_gib": None,
+        },
+        "provenance": {
+            "report_source_identity_schema": "pyamplicol-report-source-v1",
+            "report_source_revision": "1" * 40,
+            "report_source_tree": "2" * 40,
+            "report_measured_source_revision": "1" * 40,
+            "report_measured_source_tree": "2" * 40,
+            "report_source_clean": True,
+        },
+    }
+    identity = {
+        "profile": "x86_EPYC",
+        "cell_id": cell.cell_id,
+        "attempt_id": "83e5c9c7-dbf6-4d61-b724-f4580df2cfa3",
+        "worker_result_sha256": (
+            "5f3a42f9e3d034efedd8b670e7acbf2b54a427449106dbabc29050f3d93afbe6"
+        ),
+        "result": measurement,
+    }
+
+    assert _is_pinned_epyc_orphan_without_rss(**identity)
+    with pytest.raises(CampaignPolicyError, match="resource monitoring"):
+        validate_policy_measurement(
+            X86_EPYC_POLICY,
+            "x86_EPYC",
+            cell,
+            measurement,
+            expected_source_revision="1" * 40,
+            expected_source_tree="2" * 40,
+        )
+    assert (
+        validate_policy_measurement(
+            X86_EPYC_POLICY,
+            "x86_EPYC",
+            cell,
+            measurement,
+            expected_source_revision="1" * 40,
+            expected_source_tree="2" * 40,
+            allow_pinned_orphan_unavailable_resources=True,
+        )
+        is PolicyMeasurementState.SUCCESS
+    )
+
+    for field, value in (
+        ("profile", "macbook_M3"),
+        ("cell_id", "reference-amplicol-lc-n7-gg-gluons-selected-flow"),
+        ("attempt_id", "00000000-0000-4000-8000-000000000000"),
+        ("worker_result_sha256", "0" * 64),
+    ):
+        changed = dict(identity)
+        changed[field] = value
+        assert not _is_pinned_epyc_orphan_without_rss(**changed)
+
+    resources = measurement["resources"]
+    assert isinstance(resources, dict)
+    for tampered in (
+        {"monitor": "external-cell-supervisor"},
+        {"monitor": "external-cell-supervisor", "peak_rss_gib": 0.0},
+        {"monitor": "other", "peak_rss_gib": None},
+        {
+            "monitor": "external-cell-supervisor",
+            "peak_rss_gib": None,
+            "peak_rss_bytes": 0,
+        },
+    ):
+        changed_measurement = dict(measurement)
+        changed_measurement["resources"] = tampered
+        changed = dict(identity)
+        changed["result"] = changed_measurement
+        assert not _is_pinned_epyc_orphan_without_rss(**changed)
+        with pytest.raises(CampaignPolicyError, match="resource monitoring"):
+            validate_policy_measurement(
+                X86_EPYC_POLICY,
+                "x86_EPYC",
+                cell,
+                changed_measurement,
+                expected_source_revision="1" * 40,
+                expected_source_tree="2" * 40,
+                allow_pinned_orphan_unavailable_resources=True,
+            )
+
+
+def test_report_profile_is_a_global_architecture_scope() -> None:
+    parsed = _parser().parse_args(("--report-profile", "macbook_M3", "populate"))
+    assert parsed.report_profile == "macbook_M3"
+
+
+def test_final_audit_is_routed_through_the_isolated_result_tables_entrypoint() -> None:
+    arguments = _parser().parse_args(
+        (
+            "--report-profile",
+            "macbook_M3",
+            "final-audit",
+            "--expected-source-revision",
+            "a" * 40,
+            "--publication-revision",
+            "b" * 40,
+            "--structural-only",
+        )
+    )
+
+    assert arguments.command == "final-audit"
+    assert arguments.report_profile == "macbook_M3"
+    assert arguments.expected_source_revision == "a" * 40
+    assert arguments.publication_revision == "b" * 40
+    assert arguments.max_n_final == 9
+    assert arguments.expected_cell_count == 2198
+    assert arguments.structural_only is True
+
+
+def test_final_audit_receives_the_bound_architecture_profile_service(
+    tmp_path: Path,
+    monkeypatch,
+    capsys,
+) -> None:
+    repo = tmp_path / "repo"
+    profile = "macbook_M3"
+    expected_paths = ReportPaths.from_repo(repo, profile=profile)
+    expected_service = ReportService(expected_paths)
+    observed: dict[str, object] = {}
+    environment_checks: list[tuple[Path, str, str]] = []
+
+    def construct_service(paths: ReportPaths) -> ReportService:
+        assert paths == expected_paths
+        return expected_service
+
+    def fake_audit(
+        repo_root: Path,
+        **arguments: object,
+    ) -> dict[str, object]:
+        observed["repo_root"] = repo_root
+        observed.update(arguments)
+        return {"final_gate_complete": True}
+
+    monkeypatch.setattr(
+        "tools.performance_report.cli.ReportService",
+        construct_service,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.cli.require_active_profile_environment",
+        lambda root, active_profile, *, expected_source_revision: (
+            environment_checks.append((root, active_profile, expected_source_revision))
+            or {}
+        ),
+    )
+    monkeypatch.setattr(final_audit, "audit_final_report", fake_audit)
+
+    assert (
+        main(
+            (
+                "--repo-root",
+                str(repo),
+                "--report-profile",
+                profile,
+                "final-audit",
+                "--expected-source-revision",
+                "a" * 40,
+                "--publication-revision",
+                "b" * 40,
+                "--structural-only",
+            )
+        )
+        == 0
+    )
+
+    assert observed["repo_root"] == repo.resolve()
+    assert observed["service"] is expected_service
+    assert expected_service.paths.docs_dir == (
+        repo.resolve() / "docs/performance_reports/macbook_M3"
+    )
+    assert expected_service.paths.artifact_root == (
+        repo.resolve() / ".artifacts/performance-report/macbook_M3"
+    )
+    assert expected_service.paths.coordination_root == (
+        repo.resolve() / ".artifacts/performance-report-coordination/macbook_M3"
+    )
+    assert observed["expected_source_revision"] == "a" * 40
+    assert observed["expected_publication_revision"] == "b" * 40
+    assert observed["max_n_final"] == 9
+    assert observed["expected_cell_count"] == 2198
+    assert observed["replay"] is False
+    assert environment_checks == [(repo.resolve(), profile, "a" * 40)]
+    assert json.loads(capsys.readouterr().out)["final_gate_complete"] is True
+
+
+def test_refresh_environment_is_routed_to_the_active_profile(
+    tmp_path: Path,
+    monkeypatch,
+    capsys,
+) -> None:
+    repo = tmp_path / "repo"
+    observed: dict[str, object] = {}
+
+    def fake_refresh(
+        root: Path,
+        profile: str,
+        *,
+        expected_source_revision: str,
+    ) -> dict[str, str]:
+        observed.update(
+            {
+                "root": root,
+                "profile": profile,
+                "expected_source_revision": expected_source_revision,
+            }
+        )
+        return {
+            "status": "authenticated",
+            "source_revision": expected_source_revision,
+        }
+
+    monkeypatch.setattr(
+        "tools.performance_report.cli.refresh_profile_environment",
+        fake_refresh,
+    )
+
+    assert (
+        main(
+            (
+                "--repo-root",
+                str(repo),
+                "--report-profile",
+                "macbook_M3",
+                "refresh-profile-environment",
+                "--expected-source-revision",
+                "a" * 40,
+            )
+        )
+        == 0
+    )
+
+    assert observed == {
+        "root": repo.resolve(),
+        "profile": "macbook_M3",
+        "expected_source_revision": "a" * 40,
+    }
+    assert json.loads(capsys.readouterr().out) == {
+        "status": "authenticated",
+        "source_revision": "a" * 40,
+    }
+
+
+def test_final_audit_requires_an_architecture_profile(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    called = False
+
+    def fake_audit(*_args: object, **_kwargs: object) -> dict[str, object]:
+        nonlocal called
+        called = True
+        return {"final_gate_complete": True}
+
+    monkeypatch.setattr(final_audit, "audit_final_report", fake_audit)
+
+    with pytest.raises(SystemExit, match="2"):
+        main(
+            (
+                "--repo-root",
+                str(tmp_path / "repo"),
+                "final-audit",
+                "--expected-source-revision",
+                "a" * 40,
+            )
+        )
+
+    assert called is False
+
+
+def test_refresh_pdf_rejects_successful_latex_with_overfull_box(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    repo = tmp_path / "repo"
+    service = ReportService(ReportPaths.from_repo(repo))
+    service.paths.docs_dir.mkdir(parents=True, exist_ok=True)
+    (service.paths.docs_dir / "campaign_artifacts").mkdir()
+    (service.paths.docs_dir / "campaign_artifacts/sentinel").write_text(
+        "private\n",
+        encoding="ascii",
+    )
+    (service.paths.docs_dir / "pyAmpliCol.tex").write_text(
+        "\\documentclass{article}\\begin{document}bad\\end{document}\n",
+        encoding="ascii",
+    )
+    executable = _fake_latexmk(
+        tmp_path,
+        "Overfull \\hbox (1.0pt too wide)\n",
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.cli.shutil.which",
+        lambda _name: str(executable),
+    )
+
+    with pytest.raises(RuntimeError, match="overfull"):
+        _compile_pdf(service)
+
+
+def test_reset_and_validate_cli_use_new_service(tmp_path: Path, capsys) -> None:
+    repo = tmp_path / "repo"
+    _initialize_git_repo(repo)
+
+    assert main(("--repo-root", str(repo), "reset")) == 0
+    reset_output = capsys.readouterr().out
+    assert (
+        "src/pyamplicol/_profiling_campaign/"
+        "result_matrix_recurrence_builtin_sm_lc_table.tex"
+        in reset_output
+    )
+
+    assert main(("--repo-root", str(repo), "validate")) == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["table_count"] == 27
+    assert payload["cache_count"] > 12
+
+    assert main(("--repo-root", str(repo), "audit")) == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["cache_render_match"]
+
+
+def test_populate_dry_run_supports_exact_filters_and_dependencies(
+    tmp_path: Path,
+    capsys,
+) -> None:
+    repo = tmp_path / "repo"
+    _initialize_git_repo(repo)
+    main(("--repo-root", str(repo), "reset"))
+    capsys.readouterr()
+    subprocess.run(
+        ("git", "add", "src/pyamplicol/_profiling_campaign"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "commit", "-q", "-m", "Track reset profile"),
+        cwd=repo,
+        check=True,
+    )
+
+    assert (
+        main(
+            (
+                "--repo-root",
+                str(repo),
+                "populate",
+                "--dataset",
+                "matrix_compiled_builtin_sm_lc",
+                "--process-key",
+                "dd_z_jets",
+                "--n-final",
+                "1",
+                "--workload",
+                "selected-flow",
+                "--dry-run",
+            )
+        )
+        == 0
+    )
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["requested"] == 1
+    assert payload["scheduled"] == 1
+    assert [cell["rank"] for cell in payload["cells"]] == [2]
+
+
+def test_epyc_workers25_dry_run_never_creates_an_attempt(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys,
+) -> None:
+    repo = tmp_path / "repo"
+    _initialize_git_repo(repo)
+    monkeypatch.setattr(
+        "tools.performance_report.cli.load_profile_campaign_policy",
+        lambda *_args, **_kwargs: X86_EPYC_POLICY,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.cli.load_and_audit_measurement_lineage",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.artifacts.ArtifactStore.new_attempt",
+        lambda *_args, **_kwargs: pytest.fail("dry-run created an attempt"),
+    )
+    command = (
+        "--repo-root",
+        str(repo),
+        "--report-profile",
+        "x86_EPYC",
+        "populate",
+        "--dataset",
+        "matrix_compiled_builtin_sm_lc",
+        "--process-key",
+        "dd_z_jets",
+        "--n-final",
+        "1",
+        "--workload",
+        "selected-flow",
+        "--workers",
+        "25",
+        "--cell-cores",
+        "1",
+        "--target-runtime",
+        "5",
+        "--max-ram-gb",
+        "80",
+        "--allow-symbolica-parallel",
+        "--dry-run",
+    )
+
+    assert main(command) == 0
+    assert json.loads(capsys.readouterr().out)["scheduled"] == 1
+
+    stale = list(command)
+    stale[stale.index("25")] = "10"
+    with pytest.raises(SystemExit):
+        main(tuple(stale))
+    assert "workers=10, expected 25" in capsys.readouterr().err
+
+    stale = list(command)
+    stale[stale.index("80")] = "100"
+    with pytest.raises(SystemExit):
+        main(tuple(stale))
+    assert (
+        "max_rss_bytes=100000000000, expected 80000000000"
+        in capsys.readouterr().err
+    )
+
+
+def test_profile_population_requires_the_active_authenticated_environment(
+    tmp_path: Path,
+    monkeypatch,
+    capsys,
+) -> None:
+    repo = tmp_path / "repo"
+    _initialize_git_repo(repo)
+    expected_revision = subprocess.run(
+        ("git", "rev-parse", "HEAD"),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    checked: list[tuple[Path, str, str]] = []
+    scheduler_settings: list[object] = []
+
+    def require_environment(
+        root: Path,
+        profile: str,
+        *,
+        expected_source_revision: str,
+    ) -> dict[str, str]:
+        checked.append((root, profile, expected_source_revision))
+        return {}
+
+    class FakeScheduler:
+        def __init__(self, _service, *, settings) -> None:
+            self.settings = settings
+            scheduler_settings.append(settings)
+
+        def run(self, planned):
+            return SimpleNamespace(
+                planned=planned,
+                outcomes=(),
+                failed=(),
+            )
+
+    monkeypatch.setattr(
+        "tools.performance_report.cli.require_active_profile_environment",
+        require_environment,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.cli.load_profile_campaign_policy",
+        lambda *_args, **_kwargs: MACBOOK_M3_POLICY,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.cli.CampaignScheduler",
+        FakeScheduler,
+    )
+
+    assert (
+        main(
+            (
+                "--repo-root",
+                str(repo),
+                "--report-profile",
+                "macbook_M3",
+                "populate",
+                "--dataset",
+                "matrix_compiled_builtin_sm_lc",
+                "--process-key",
+                "dd_z_jets",
+                "--n-final",
+                "1",
+                "--workload",
+                "selected-flow",
+                "--max-ram-gb",
+                "30",
+            )
+        )
+        == 0
+    )
+
+    assert checked == [(repo.resolve(), "macbook_M3", expected_revision)]
+    assert len(scheduler_settings) == 1
+    assert scheduler_settings[0].max_rss_bytes == 30_000_000_000
+    assert scheduler_settings[0].campaign_max_rss_bytes is None
+    assert json.loads(capsys.readouterr().out)["planned"] == 1
+
+
+def test_profile_fast_lineage_skips_historical_replay(
+    tmp_path: Path,
+    monkeypatch,
+    capsys,
+) -> None:
+    repo = tmp_path / "repo"
+    _initialize_git_repo(repo)
+    expected_revision = subprocess.run(
+        ("git", "rev-parse", "HEAD"),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    expected_tree = subprocess.run(
+        ("git", "rev-parse", "HEAD^{tree}"),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    lineage = SimpleNamespace()
+    loaded: list[tuple[Path, Path, str, str]] = []
+    bound: list[object] = []
+
+    def load_fast(
+        root: Path,
+        docs_dir: Path,
+        *,
+        expected_active_revision: str,
+        expected_active_tree: str,
+    ):
+        loaded.append(
+            (
+                root,
+                docs_dir,
+                expected_active_revision,
+                expected_active_tree,
+            )
+        )
+        return lineage
+
+    class FakeScheduler:
+        def __init__(self, service, *, settings) -> None:
+            assert settings.report_profile == "macbook_M3"
+            bound.append(service._authenticated_measurement_lineage)
+
+        def run(self, planned):
+            return SimpleNamespace(planned=planned, outcomes=(), failed=())
+
+    monkeypatch.setattr(
+        "tools.performance_report.cli.load_measurement_lineage",
+        load_fast,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.cli.load_and_audit_measurement_lineage",
+        lambda *_args, **_kwargs: pytest.fail("historical replay was called"),
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.cli.require_active_profile_environment",
+        lambda *_args, **_kwargs: {},
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.cli.load_profile_campaign_policy",
+        lambda *_args, **_kwargs: MACBOOK_M3_POLICY,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.cli.CampaignScheduler",
+        FakeScheduler,
+    )
+
+    assert (
+        main(
+            (
+                "--repo-root",
+                str(repo),
+                "--report-profile",
+                "macbook_M3",
+                "populate",
+                "--fast-lineage",
+                "--dataset",
+                "matrix_compiled_builtin_sm_lc",
+                "--process-key",
+                "dd_z_jets",
+                "--n-final",
+                "1",
+                "--workload",
+                "selected-flow",
+                "--max-ram-gb",
+                "30",
+            )
+        )
+        == 0
+    )
+
+    assert loaded == [
+        (
+            repo.resolve(),
+            repo / "docs/performance_reports/macbook_M3",
+            expected_revision,
+            expected_tree,
+        )
+    ]
+    assert bound == [lineage]
+    assert json.loads(capsys.readouterr().out)["planned"] == 1
diff --git a/pyamplicol/tests/unit/test_performance_report_final_audit.py b/pyamplicol/tests/unit/test_performance_report_final_audit.py
new file mode 100644
index 0000000000..40ea08a6c2
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_final_audit.py
@@ -0,0 +1,4840 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import io
+import json
+import sys
+from collections import Counter
+from collections.abc import Mapping
+from contextlib import contextmanager
+from copy import deepcopy
+from dataclasses import dataclass, replace
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+import tools.performance_report.final_audit as final_audit_module
+import tools.performance_report.runner as report_runner
+from tools.performance_report.agreements import (
+    DIRECT_AGREEMENT_FIELD,
+    INDEPENDENT_AUTHORITY_ABI,
+    INDEPENDENT_AUTHORITY_FIELD,
+    LC_COMMON_COMPONENT_ABI,
+    LC_COMMON_COMPONENT_FIELD,
+    LC_LEGACY_PYAMPLICOL_COMPONENT,
+    MADGRAPH_FULL_COLOUR,
+    Z_RECURRENCE_CROSS_MODE,
+    agreement_edges,
+    attach_direct_agreements,
+    independent_numerical_authorities,
+)
+from tools.performance_report.arena_profile import (
+    ARENA_PHASE_TIMING_SCOPE,
+    ARENA_PROFILE_BOUNDARY,
+    EMPTY_ARENA_PHASE_VECTOR_FIELDS,
+    ZERO_ARENA_COUNTER_FIELDS,
+    ZERO_ARENA_PHASE_TIME_FIELDS,
+    ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS,
+    build_arena_profile_evidence,
+    digest_arena_profile_value,
+)
+from tools.performance_report.cache import (
+    build_reset_caches,
+    digest_json,
+    empty_measurement,
+    reset_entry,
+)
+from tools.performance_report.campaign_policy import PolicyMeasurementState
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.final_audit import (
+    ArtifactEvidence,
+    FinalAuditError,
+    _active_runtime_snapshot,
+    _artifact_reference,
+    _audit_compiled_execution,
+    _audit_direct_agreements,
+    _audit_eager_execution,
+    _audit_effective_config_mapping,
+    _audit_measurement,
+    _audit_model_source,
+    _audit_on_the_fly_execution,
+    _audit_pdf,
+    _audit_pointwise,
+    _audit_recurrence_execution,
+    _audit_recurrence_source_pack,
+    _audit_replayed_direct_agreements,
+    _audit_runtime_identity,
+    _audit_runtime_profile_warmup_evidence,
+    _audit_tex_table_reachability,
+    _audit_unavailable_execution_timing,
+    _authenticated_effective_config,
+    _catalog_static_na_projection_errors,
+    _count_contract_matches_with_optional_categories,
+    _ensure_exact_cli_python,
+    _legacy_consumer_coverage,
+    _python_package_tree_identity,
+    _real_nonnegative,
+    _replay_count_contract_matches_direct_edges,
+    _runtime_for_measurement_source,
+    _runtime_namespace_paths,
+    _shared_artifact_contract,
+    _validation_baseline_for_audit,
+    audit_artifact,
+    audit_final_report,
+)
+from tools.performance_report.madgraph import madgraph_command_card
+from tools.performance_report.measurement_lineage import (
+    CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+)
+from tools.performance_report.models import (
+    Accuracy,
+    ArtifactPolicy,
+    CellSpec,
+    ExecutionMode,
+    MeasurementSpec,
+    ModelKey,
+    Workload,
+)
+from tools.performance_report.publication import portable_publication_value
+from tools.performance_report.render import VisibleCompleteness
+from tools.performance_report.service import ReportPaths, ReportService
+
+_REVISION = "a" * 40
+_LEGACY_REVISION = "dcb3efbcbe89c51969818cddf48113fba19ad763"
+_ARTIFACT_ID = "b" * 64
+_CAPABILITY = "rusticol.recurrence-direct-arena.complex-f64.v1"
+_COLOR_CAPABILITY = "rusticol.recurrence-color.lc.v1"
+
+
+def test_full_final_audit_distinguishes_declared_and_measurable_edge_totals() -> None:
+    declared_ids = {cell.cell_id for cell in REPORT_CATALOG.measurement_cells()}
+    measurable_ids = {
+        cell.cell_id
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is None
+    }
+    declared_edges = tuple(
+        edge
+        for edge in agreement_edges()
+        if edge.candidate.cell_id in declared_ids
+        and edge.baseline.cell_id in declared_ids
+    )
+    measurable_edges = tuple(
+        edge
+        for edge in declared_edges
+        if edge.candidate.cell_id in measurable_ids
+        and edge.baseline.cell_id in measurable_ids
+    )
+
+    assert len(declared_edges) == 1973
+    assert (
+        len(declared_edges) == final_audit_module._EXPECTED_FULL_DIRECT_AGREEMENT_COUNT
+    )
+    assert len(measurable_edges) == 1925
+    assert sum(
+        final_audit_module._EXPECTED_FULL_DIRECT_AGREEMENT_COUNTS.values()
+    ) == len(measurable_edges)
+    assert Counter(edge.kind for edge in measurable_edges) == (
+        final_audit_module._EXPECTED_FULL_DIRECT_AGREEMENT_COUNTS
+    )
+    static_reasons = Counter(
+        REPORT_CATALOG.static_na_reason(cell)
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is not None
+    )
+    assert static_reasons == {
+        "native-backend-generation-cap-n6-v1": 24,
+        "original-amplicol-open-quark-line-limit": 10,
+    }
+
+    n4_cells = tuple(
+        cell for cell in REPORT_CATALOG.measurement_cells() if cell.n_final <= 4
+    )
+    n4_ids = {cell.cell_id for cell in n4_cells}
+    n4_measurable_ids = {
+        cell.cell_id
+        for cell in n4_cells
+        if REPORT_CATALOG.static_na_reason(cell) is None
+    }
+    n4_edges = tuple(
+        edge
+        for edge in agreement_edges()
+        if edge.candidate.cell_id in n4_measurable_ids
+        and edge.baseline.cell_id in n4_measurable_ids
+    )
+    assert len(n4_ids) == final_audit_module._EXPECTED_N4_CELL_COUNT == 1042
+    assert Counter(edge.kind for edge in n4_edges) == (
+        final_audit_module._EXPECTED_N4_DIRECT_AGREEMENT_COUNTS
+    )
+    _empty_edges, empty_counts = _audit_direct_agreements(
+        (),
+        {},
+        catalog=REPORT_CATALOG,
+    )
+    assert set(empty_counts) == set(
+        final_audit_module._EXPECTED_FULL_DIRECT_AGREEMENT_COUNTS
+    )
+
+
+@pytest.mark.parametrize(
+    ("expected_edges", "expected_replays"),
+    (
+        (
+            final_audit_module._EXPECTED_FULL_DIRECT_AGREEMENT_COUNTS,
+            final_audit_module._EXPECTED_FULL_DIRECT_REPLAY_COUNTS,
+        ),
+        (
+            final_audit_module._EXPECTED_N4_DIRECT_AGREEMENT_COUNTS,
+            final_audit_module._EXPECTED_N4_DIRECT_REPLAY_COUNTS,
+        ),
+    ),
+)
+def test_final_audit_count_contract_bounds_only_optional_authority_edges(
+    expected_edges: Mapping[str, int],
+    expected_replays: Mapping[str, int],
+) -> None:
+    without_optional = dict(expected_edges)
+    without_optional[Z_RECURRENCE_CROSS_MODE] = 0
+    without_optional[LC_LEGACY_PYAMPLICOL_COMPONENT] = 0
+    assert _count_contract_matches_with_optional_categories(
+        without_optional,
+        expected_edges,
+        optional_categories={
+            Z_RECURRENCE_CROSS_MODE,
+            LC_LEGACY_PYAMPLICOL_COMPONENT,
+        },
+    )
+    expected_without_optional_replays = dict(expected_replays)
+    expected_without_optional_replays[
+        final_audit_module._FULLY_REPLAYED_PYAMPLICOL
+    ] -= expected_edges[Z_RECURRENCE_CROSS_MODE]
+    expected_without_optional_replays[
+        final_audit_module._REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY
+    ] = 0
+    assert _replay_count_contract_matches_direct_edges(
+        expected_without_optional_replays,
+        without_optional,
+        expected_replays,
+    )
+
+    optional_categories = {
+        Z_RECURRENCE_CROSS_MODE,
+        LC_LEGACY_PYAMPLICOL_COMPONENT,
+    }
+    for required_category in set(expected_edges) - optional_categories:
+        missing_required = dict(expected_edges)
+        missing_required[required_category] -= 1
+        assert not _count_contract_matches_with_optional_categories(
+            missing_required,
+            expected_edges,
+            optional_categories=optional_categories,
+        )
+
+    for optional_category in optional_categories:
+        too_many_optional = dict(expected_edges)
+        too_many_optional[optional_category] += 1
+        assert not _count_contract_matches_with_optional_categories(
+            too_many_optional,
+            expected_edges,
+            optional_categories=optional_categories,
+        )
+
+    missing_required_replay = dict(expected_without_optional_replays)
+    missing_required_replay[final_audit_module._FULLY_REPLAYED_PYAMPLICOL] -= 1
+    assert not _replay_count_contract_matches_direct_edges(
+        missing_required_replay,
+        without_optional,
+        expected_replays,
+    )
+
+    missing_available_z_replay = dict(expected_replays)
+    missing_available_z_replay[final_audit_module._FULLY_REPLAYED_PYAMPLICOL] -= 1
+    assert not _replay_count_contract_matches_direct_edges(
+        missing_available_z_replay,
+        expected_edges,
+        expected_replays,
+    )
+
+    missing_available_legacy_replay = dict(expected_replays)
+    missing_available_legacy_replay[
+        final_audit_module._REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY
+    ] -= 1
+    assert not _replay_count_contract_matches_direct_edges(
+        missing_available_legacy_replay,
+        expected_edges,
+        expected_replays,
+    )
+
+
+def _fake_latexmk(tmp_path: Path, log: str) -> Path:
+    executable = tmp_path / "fake-latexmk"
+    executable.write_text(
+        "#!/usr/bin/env python3\n"
+        "from pathlib import Path\n"
+        "assert not Path('campaign_artifacts').exists()\n"
+        "Path('pyAmpliCol.pdf').write_bytes(b'%PDF-1.4\\n%%EOF\\n')\n"
+        f"Path('pyAmpliCol.log').write_text({log!r}, encoding='utf-8')\n",
+        encoding="utf-8",
+    )
+    executable.chmod(0o755)
+    return executable
+
+
+def _cell(
+    mode: ExecutionMode,
+    *,
+    backend: str = "jit",
+    optimization_level: int | None = 3,
+) -> CellSpec:
+    return CellSpec(
+        dataset_id=f"test_{mode.value}",
+        process="d d~ > z",
+        n_final=1,
+        process_key="dd_z",
+        measurement=MeasurementSpec(
+            mode,
+            ModelKey.BUILTIN_SM,
+            Accuracy.LC,
+            backend,
+            optimization_level,
+        ),
+        workload=Workload.SELECTED_FLOW,
+    )
+
+
+@pytest.mark.parametrize(
+    "validation",
+    (
+        {
+            "enabled": True,
+            "samples": 10,
+            "seed": 12345,
+            "relative_tolerance": 1.0e-12,
+            "absolute_tolerance": 1.0e-300,
+            "post_build_validation": True,
+        },
+        {
+            "enabled": True,
+            "samples": 1,
+            "seed": 12345,
+            "relative_tolerance": 1.0e-12,
+            "absolute_tolerance": 1.0e-300,
+            "post_build_validation": False,
+        },
+    ),
+)
+def test_final_audit_does_not_promote_generation_smoke_policy_to_identity(
+    validation: dict[str, object],
+) -> None:
+    final_audit_module._audit_effective_config_mapping(
+        _cell(ExecutionMode.RECURRENCE),
+        {
+            "evaluator": {
+                "execution_mode": "recurrence",
+                "backend": "jit",
+                "jit": {"optimization_level": 3},
+            },
+            "color": {
+                "accuracy": "lc",
+                "lc_flow_layout": "topology-replay",
+            },
+            "generation": {"validation": validation},
+        },
+        context="test effective config",
+    )
+
+
+def test_final_pdf_audit_rejects_successful_latex_with_overfull_box(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    repo = tmp_path / "repo"
+    service = ReportService(ReportPaths.from_repo(repo))
+    service.paths.docs_dir.mkdir(parents=True, exist_ok=True)
+    (service.paths.docs_dir / "campaign_artifacts").mkdir()
+    (service.paths.docs_dir / "campaign_artifacts/sentinel").write_text(
+        "private\n",
+        encoding="ascii",
+    )
+    (service.paths.docs_dir / "pyAmpliCol.tex").write_text(
+        (
+            "\\documentclass{article}\\begin{document}"
+            "\\input{result_test_table.tex}\\end{document}\n"
+        ),
+        encoding="ascii",
+    )
+    (service.paths.docs_dir / "result_test_table.tex").write_text(
+        "bad\n",
+        encoding="ascii",
+    )
+    (service.paths.docs_dir / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.4\n%%EOF\n")
+    executable = _fake_latexmk(
+        tmp_path,
+        "Overfull \\vbox (1.0pt too high)\n",
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.final_audit.shutil.which",
+        lambda _name: str(executable),
+    )
+    monkeypatch.setattr(ReportService, "load_caches", lambda _self: {})
+    monkeypatch.setattr(
+        "tools.performance_report.final_audit.render_all_tables",
+        lambda *_args, **_kwargs: {"result_test_table.tex": "bad\n"},
+    )
+
+    with pytest.raises(FinalAuditError, match="overfull"):
+        _audit_pdf(service)
+
+
+def _recurrence_binding_digest(binding: dict[str, object]) -> str:
+    if binding["kind"] != "rusticol-intrinsic":
+        payload = dict(binding)
+        payload.pop("payload_digest", None)
+        return digest_json(payload)
+    fields = (
+        "abi",
+        "contribution_parent_permutation",
+        "kind",
+        "runtime_template",
+    )
+    return digest_json({field: binding.get(field) for field in fields})
+
+
+def _refresh_recurrence_source_catalog(
+    execution: dict[str, object],
+    pack: dict[str, object],
+    *,
+    refresh_binding_digest: bool = True,
+) -> None:
+    catalog = pack["recurrence_direct_template"]
+    assert isinstance(catalog, dict)
+    templates = catalog["templates"]
+    assert isinstance(templates, list)
+    for template in templates:
+        assert isinstance(template, dict)
+        binding = template["payload_binding"]
+        assert isinstance(binding, dict)
+        if refresh_binding_digest:
+            binding["payload_digest"] = _recurrence_binding_digest(binding)
+        semantic = dict(template)
+        semantic.pop("semantic_digest", None)
+        template["semantic_digest"] = digest_json(semantic)
+    semantic_catalog = dict(catalog)
+    semantic_catalog.pop("catalog_digest", None)
+    catalog["catalog_digest"] = digest_json(semantic_catalog)
+    execution["direct_template_catalog_digest"] = catalog["catalog_digest"]
+    plan = execution["plan"]
+    assert isinstance(plan, dict)
+    plan["direct_template_catalog_digest"] = catalog["catalog_digest"]
+
+
+def _canonical_symjit_evaluator(
+    application_path: str,
+    plane_path: str,
+    *,
+    optimization_level: int,
+    input_len: int = 1,
+    output_len: int = 1,
+) -> dict[str, object]:
+    return {
+        "kind": "symjit-application-evaluator",
+        "runtime_capability": "symjit.application.complex-f64.v1",
+        "input_len": input_len,
+        "output_len": output_len,
+        "application_abi": "symjit-application-storage-v3",
+        "application_path": application_path,
+        "element_layout": "complex-f64",
+        "batch_layout": "row-major",
+        "compiler_type": "native",
+        "translation_mode": "indirect",
+        "optimization_level": optimization_level,
+        "word_bits": 64,
+        "endianness": "little",
+        "required_defuns": [],
+        "evaluator_state_path": f"{application_path}.state",
+        "evaluator_state_runtime_capability": (
+            "symbolica.legacy-jit-container.complex-f64.v1"
+        ),
+        "plane_application": {
+            "application_path": plane_path,
+            "application_abi": "pyamplicol-symjit-plane-application-v2",
+            "storage_abi": "symjit-application-storage-v3",
+            "element_layout": "split-complex-plane-major",
+            "descriptor_order": "inputs-re-im-then-outputs-re-im",
+            "input_complex_count": input_len,
+            "output_complex_count": output_len,
+            "input_plane_count": 2 * input_len,
+            "output_plane_count": 2 * output_len,
+            "compiler_type": "native",
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": optimization_level,
+            "simd": True,
+            "complex": True,
+            "fast_math": True,
+            "fast_complex": False,
+            "compression": False,
+            "threading": False,
+            "direct_arena": True,
+            "source_digest": "1" * 64,
+            "target": {"word_bits": 64, "endianness": "little"},
+        },
+    }
+
+
+def _recurrence_source_fixture(
+    source_sha256: str,
+) -> tuple[dict[str, object], dict[str, object]]:
+    ordinary_source_path = "kernels/000000/application-0.symjit"
+    source_path = "kernels/000000/application-0.plane.symjit"
+    binding: dict[str, object] = {
+        "abi": "pyamplicol-recurrence-plane-binding-v2",
+        "contribution_parent_permutation": [0, 1],
+        "destination_operation": "finalize-in-place",
+        "direct_application_abi": "pyamplicol-symjit-plane-application-v2",
+        "exact_factor_scalar_slots": [0, 1],
+        "input_plane_count": 1,
+        "input_plane_projections": [{"kind": "destination-current"}],
+        "intrinsic_contract_digest": None,
+        "kind": "prepared-direct-call",
+        "output_alias_inputs": [0],
+        "parameter_bindings": [{"index": 0, "kind": "plane"}],
+        "payload_digest": "",
+        "payload_paths": [source_path],
+        "prepared_kernel_id": 0,
+        "prepared_template_semantic_digest": "d" * 64,
+        "role": "finalization",
+        "runtime_template": None,
+        "scalar_input_count": 2,
+        "scalar_projections": [
+            {"imaginary": False, "kind": "exact-factor"},
+            {"imaginary": True, "kind": "exact-factor"},
+        ],
+        "source_application_abi": "pyamplicol-symjit-plane-application-v2",
+        "source_application_path": source_path,
+        "source_application_sha256": source_sha256,
+        "state_plane_indices": [],
+    }
+    template: dict[str, object] = {
+        "abi": "pyamplicol-recurrence-direct-template-v1",
+        "alignment_bytes": 64,
+        "backend": "jit",
+        "coupling_slot_count": 0,
+        "destination_aliasing": True,
+        "destination_component_count": 1,
+        "destination_operation": "finalize-in-place",
+        "direct_executor_id": 0,
+        "evaluator_binding_id": 0,
+        "evaluator_resolver_key": "prepared-kernel-0",
+        "exact_expression_digest": "e" * 64,
+        "momentum_operand_count": 0,
+        "optimization_level": 2,
+        "parameter_slot_count": 0,
+        "parent_arity": 1,
+        "parent_component_counts": [1],
+        "payload_binding": binding,
+        "portable": True,
+        "role": "finalization",
+        "semantic_digest": "",
+        "semantic_template_ids": ["prepared-finalization"],
+        "simd_axis": "points-contiguous",
+        "target_triple": "symjit-storage-v3-portable",
+        "template_id": "template-0",
+    }
+    prepared_digest = "a" * 64
+    catalog: dict[str, object] = {
+        "abi": "pyamplicol-recurrence-direct-template-v1",
+        "backend": "jit",
+        "backend_abi": "rusticol.recurrence-direct-backend.v1",
+        "canonicalization_abi": "pyamplicol-canonical-json-v1",
+        "catalog_digest": "",
+        "compiled_model_digest": "b" * 64,
+        "optimization_level": 2,
+        "optimization_settings_digest": "c" * 64,
+        "portable": True,
+        "prepared_kernel_contract_digest": "4" * 64,
+        "prepared_kernel_pack_digest": prepared_digest,
+        "prepared_kernel_payload_digest": "5" * 64,
+        "recurrence_template_catalog_digest": "6" * 64,
+        "target_triple": "symjit-storage-v3-portable",
+        "templates": [template],
+    }
+    plan: dict[str, object] = {
+        "builder_input_abi": "pyamplicol-recurrence-builder-input-v2",
+        "recurrence_plan_abi": "pyamplicol-recurrence-plan-v2",
+        "runtime_layout_abi": "pyamplicol-recurrence-runtime-layout-v2",
+        "direct_template_abi": "pyamplicol-recurrence-direct-template-v1",
+        "direct_backend_abi": "rusticol.recurrence-direct-backend.v1",
+        "prepared_kernel_pack_digest": prepared_digest,
+        "direct_template_catalog_digest": "",
+        "inspection_summary": {
+            "direct_arena": {
+                "packed_input_bytes": 0,
+                "packed_output_bytes": 0,
+                "scatter_bytes": 0,
+                "row_group_count": 4,
+            }
+        },
+    }
+    execution: dict[str, object] = {
+        "kind": "pyamplicol-runtime-recurrence-execution",
+        "builder_input_abi": "pyamplicol-recurrence-builder-input-v2",
+        "recurrence_plan_abi": "pyamplicol-recurrence-plan-v2",
+        "runtime_layout_abi": "pyamplicol-recurrence-runtime-layout-v2",
+        "direct_template_abi": "pyamplicol-recurrence-direct-template-v1",
+        "direct_backend_abi": "rusticol.recurrence-direct-backend.v1",
+        "prepared_kernel_pack_digest": prepared_digest,
+        "direct_template_catalog_digest": "",
+        "kernel_pack": {
+            "manifest_path": "model/eager-kernel-pack.json",
+            "payload_root": "model/eager-kernels",
+        },
+        "required_runtime_capabilities": [_COLOR_CAPABILITY, _CAPABILITY],
+        "plan": plan,
+    }
+    pack: dict[str, object] = {
+        "backend": "jit",
+        "optimization_settings": {
+            "backend": "jit",
+            "jit_optimization_level": 2,
+        },
+        "recurrence_direct_template": catalog,
+        "kernel_variants": [],
+        "kernels": [
+            {
+                "kernel_id": 0,
+                "f64_evaluator_manifest": _canonical_symjit_evaluator(
+                    ordinary_source_path,
+                    source_path,
+                    optimization_level=2,
+                ),
+            }
+        ],
+    }
+    _refresh_recurrence_source_catalog(execution, pack)
+    return execution, pack
+
+
+def _legacy_cell() -> CellSpec:
+    return CellSpec(
+        dataset_id="reference_amplicol_lc",
+        process="d d~ > z",
+        n_final=1,
+        process_key="dd_z",
+        measurement=MeasurementSpec(
+            ExecutionMode.AMPLICOL,
+            None,
+            Accuracy.LC,
+            "fortran",
+            None,
+        ),
+        workload=Workload.SELECTED_FLOW,
+    )
+
+
+def test_catalog_static_na_projection_requires_reset_cache_and_no_current() -> None:
+    cell = replace(
+        _legacy_cell(),
+        dataset_id="reference_amplicol_static_na",
+        process="d d~ > u u~ s s~ c c~",
+        n_final=6,
+        process_key="dd_4q_lines",
+    )
+    canonical = reset_entry(cell)
+
+    assert (
+        _catalog_static_na_projection_errors(
+            (cell,),
+            {cell.cell_id: canonical},
+            load_current=lambda _cell_id: None,
+        )
+        == ()
+    )
+
+    tampered = deepcopy(canonical)
+    tampered["measurement"] = {
+        **empty_measurement(),
+        "status": "unsupported",
+    }
+    assert _catalog_static_na_projection_errors(
+        (cell,),
+        {cell.cell_id: tampered},
+        load_current=lambda _cell_id: None,
+    ) == (
+        f"{cell.cell_id}: catalog static N/A cache entry differs "
+        "from the canonical reset entry",
+    )
+    assert _catalog_static_na_projection_errors(
+        (cell,),
+        {},
+        load_current=lambda _cell_id: None,
+    ) == (f"{cell.cell_id}: cache entry is missing",)
+    assert _catalog_static_na_projection_errors(
+        (cell,),
+        {cell.cell_id: canonical},
+        load_current=lambda _cell_id: object(),
+    ) == (f"{cell.cell_id}: catalog static N/A cell has a published current",)
+
+
+def _compiled_stage(
+    *,
+    optimization_level: int = 3,
+    backend: str = "jit",
+) -> dict[str, object]:
+    source_application_abi = (
+        "pyamplicol-symjit-plane-application-v2"
+        if backend == "jit"
+        else "pyamplicol-native-compiled-direct-application-v1"
+    )
+    application_abi = (
+        "pyamplicol-compiled-plane-kernel-v2"
+        if backend == "jit"
+        else "pyamplicol-native-compiled-direct-application-v1"
+    )
+    evaluator = (
+        {
+            "kind": "symjit-application-evaluator",
+            "runtime_capability": "symjit.application.complex-f64.v1",
+            "input_len": 1,
+            "output_len": 1,
+            "application_abi": "symjit-application-storage-v3",
+            "application_path": "evaluators/stage.symjit",
+            "element_layout": "complex-f64",
+            "batch_layout": "row-major",
+            "compiler_type": "native",
+            "translation_mode": "indirect",
+            "optimization_level": optimization_level,
+            "word_bits": 64,
+            "endianness": "little",
+            "required_defuns": [],
+            "evaluator_state_path": "evaluators/stage.symjit.state",
+            "evaluator_state_runtime_capability": (
+                "symbolica.legacy-jit-container.complex-f64.v1"
+            ),
+            "plane_application": {
+                "application_path": "evaluators/stage.plane.symjit",
+                "application_abi": "pyamplicol-symjit-plane-application-v2",
+                "storage_abi": "symjit-application-storage-v3",
+                "element_layout": "split-complex-plane-major",
+                "descriptor_order": "inputs-re-im-then-outputs-re-im",
+                "input_complex_count": 1,
+                "output_complex_count": 1,
+                "input_plane_count": 2,
+                "output_plane_count": 2,
+                "compiler_type": "native",
+                "translation_mode": "symbolica-structured-instructions",
+                "optimization_level": optimization_level,
+                "simd": True,
+                "complex": True,
+                "fast_math": True,
+                "fast_complex": False,
+                "compression": False,
+                "threading": False,
+                "direct_arena": True,
+                "source_digest": "1" * 64,
+                "target": {"word_bits": 64, "endianness": "little"},
+            },
+        }
+        if backend == "jit"
+        else {
+            "kind": "compiled-complex-evaluator",
+            "runtime_capability": (f"symbolica.compiled-{backend}.complex-f64.v1"),
+        }
+    )
+    return {
+        "parameter_count": 1,
+        "output_length": 1,
+        "evaluator": evaluator,
+        "compiled_plane_arena": {
+            "schema_version": 1,
+            "kind": "compiled-plane-arena-stage",
+            "application_abi": application_abi,
+            "source_application_abi": source_application_abi,
+            "element_layout": "split-complex-component-major",
+            "output_operation": "overwrite",
+            "output_factor": "identity",
+            "input_output_aliasing": "forbidden",
+            "output_output_aliasing": "forbidden",
+            "input_bindings": [{"parameter_index": 0}],
+            "output_bindings": [{"output_index": 0}],
+            "leaves": [
+                {
+                    "application_path": (
+                        "evaluators/stage.plane.symjit"
+                        if backend == "jit"
+                        else "evaluators/stage.direct"
+                    ),
+                    "source_application_abi": source_application_abi,
+                    "optimization_level": optimization_level,
+                    "direct_codegen_optimization_level": optimization_level,
+                }
+            ],
+        },
+    }
+
+
+def test_compiled_arena_audits_fused_stages_and_parameter_exclusion() -> None:
+    execution = {
+        "kind": "pyamplicol-runtime-execution",
+        "compiled": {
+            "stage_evaluators": {
+                "stages": [_compiled_stage()],
+                "amplitude_stage": _compiled_stage(),
+            },
+            "model_parameter_evaluator": {
+                "evaluator": {"application_abi": "symjit-application-storage-v3"}
+            },
+        },
+    }
+    assert _audit_compiled_execution(
+        execution,
+        _cell(ExecutionMode.COMPILED),
+    ) == (2, 2)
+    jit_o1 = deepcopy(execution)
+    for stage in (
+        *jit_o1["compiled"]["stage_evaluators"]["stages"],  # type: ignore[index]
+        jit_o1["compiled"]["stage_evaluators"]["amplitude_stage"],  # type: ignore[index]
+    ):
+        stage["compiled_plane_arena"]["leaves"][0]["optimization_level"] = 1
+        stage["compiled_plane_arena"]["leaves"][0][
+            "direct_codegen_optimization_level"
+        ] = 1
+        stage["evaluator"]["optimization_level"] = 1
+        stage["evaluator"]["plane_application"]["optimization_level"] = 1
+    assert _audit_compiled_execution(
+        jit_o1,
+        _cell(ExecutionMode.COMPILED, optimization_level=1),
+    ) == (2, 2)
+
+    invalid_direct_codegen = deepcopy(execution)
+    invalid_direct_codegen["compiled"]["stage_evaluators"]["stages"][0][  # type: ignore[index]
+        "compiled_plane_arena"
+    ]["leaves"][0]["direct_codegen_optimization_level"] = 2
+    with pytest.raises(
+        FinalAuditError,
+        match=r"leaf\.direct_codegen_optimization_level",
+    ):
+        _audit_compiled_execution(
+            invalid_direct_codegen,
+            _cell(ExecutionMode.COMPILED),
+        )
+
+    execution["compiled"]["model_parameter_evaluator"] = {  # type: ignore[index]
+        "compiled_plane_arena": {}
+    }
+    with pytest.raises(FinalAuditError, match="model-parameter"):
+        _audit_compiled_execution(execution, _cell(ExecutionMode.COMPILED))
+
+    execution["compiled"]["model_parameter_evaluator"] = {  # type: ignore[index]
+        "nested": {"native_direct_application": {}}
+    }
+    with pytest.raises(FinalAuditError, match="DirectApplication metadata"):
+        _audit_compiled_execution(execution, _cell(ExecutionMode.COMPILED))
+
+    execution["compiled"]["model_parameter_evaluator"] = {  # type: ignore[index]
+        "nested": {
+            "application_abi": "pyamplicol-native-compiled-direct-application-v1"
+        }
+    }
+    with pytest.raises(FinalAuditError, match="direct application ABI"):
+        _audit_compiled_execution(execution, _cell(ExecutionMode.COMPILED))
+
+
+@pytest.mark.parametrize(
+    ("backend", "capability"),
+    [
+        ("jit", "symjit.application.complex-f64.v1"),
+        ("cpp", "symbolica.compiled-cpp.complex-f64.v1"),
+        ("asm", "symbolica.compiled-asm.complex-f64.v1"),
+    ],
+)
+def test_compiled_arena_authenticates_source_runtime_capability(
+    backend: str,
+    capability: str,
+) -> None:
+    stage = _compiled_stage(backend=backend)
+    execution = {
+        "kind": "pyamplicol-runtime-execution",
+        "compiled": {
+            "stage_evaluators": {
+                "stages": [],
+                "amplitude_stage": stage,
+            },
+        },
+    }
+    cell = _cell(
+        ExecutionMode.COMPILED,
+        backend=backend,
+        optimization_level=3 if backend == "jit" else None,
+    )
+    assert _audit_compiled_execution(execution, cell) == (1, 1)
+    assert stage["evaluator"]["runtime_capability"] == capability  # type: ignore[index]
+
+    stage["evaluator"]["runtime_capability"] = "wrong.capability"  # type: ignore[index]
+    with pytest.raises(FinalAuditError, match="runtime_capability"):
+        _audit_compiled_execution(execution, cell)
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("backend", "native"),
+        ("backend", None),
+        ("compiler_type", "interpreter"),
+    ),
+)
+def test_compiled_arena_rejects_contradictory_symjit_identity(
+    field: str,
+    value: object,
+) -> None:
+    stage = _compiled_stage()
+    stage["evaluator"][field] = value  # type: ignore[index]
+    execution = {
+        "kind": "pyamplicol-runtime-execution",
+        "compiled": {
+            "stage_evaluators": {
+                "stages": [],
+                "amplitude_stage": stage,
+            },
+        },
+    }
+
+    with pytest.raises(FinalAuditError, match=field):
+        _audit_compiled_execution(execution, _cell(ExecutionMode.COMPILED))
+
+
+def test_compiled_arena_accepts_fallback_free_portable_symjit_leaf() -> None:
+    stage = _compiled_stage()
+    evaluator = stage["evaluator"]
+    assert isinstance(evaluator, dict)
+    evaluator["evaluator_state_path"] = None
+    evaluator["evaluator_state_runtime_capability"] = None
+    execution = {
+        "kind": "pyamplicol-runtime-execution",
+        "compiled": {
+            "stage_evaluators": {
+                "stages": [],
+                "amplitude_stage": stage,
+            },
+        },
+    }
+
+    assert _audit_compiled_execution(
+        execution,
+        _cell(ExecutionMode.COMPILED),
+    ) == (1, 1)
+
+
+@pytest.mark.parametrize(
+    ("state_path", "capability"),
+    (
+        (None, "symbolica.legacy-jit-container.complex-f64.v1"),
+        ("evaluators/stage.symjit.state", None),
+    ),
+)
+def test_compiled_arena_rejects_partial_symjit_fallback_pair(
+    state_path: str | None,
+    capability: str | None,
+) -> None:
+    stage = _compiled_stage()
+    evaluator = stage["evaluator"]
+    assert isinstance(evaluator, dict)
+    evaluator["evaluator_state_path"] = state_path
+    evaluator["evaluator_state_runtime_capability"] = capability
+    execution = {
+        "kind": "pyamplicol-runtime-execution",
+        "compiled": {
+            "stage_evaluators": {
+                "stages": [],
+                "amplitude_stage": stage,
+            },
+        },
+    }
+
+    with pytest.raises(FinalAuditError, match="evaluator_state_fallback"):
+        _audit_compiled_execution(execution, _cell(ExecutionMode.COMPILED))
+
+
+@pytest.mark.parametrize(
+    "target",
+    (
+        {"word_bits": 64.0, "endianness": "little"},
+        {
+            "word_bits": 64,
+            "endianness": "little",
+            "cpu_features": ["z", "a"],
+        },
+        {"word_bits": 64, "endianness": "little", "unknown": True},
+    ),
+)
+def test_compiled_arena_rejects_noncanonical_symjit_target(
+    target: dict[str, object],
+) -> None:
+    stage = _compiled_stage()
+    evaluator = stage["evaluator"]
+    assert isinstance(evaluator, dict)
+    plane = evaluator["plane_application"]
+    assert isinstance(plane, dict)
+    plane["target"] = target
+    execution = {
+        "kind": "pyamplicol-runtime-execution",
+        "compiled": {
+            "stage_evaluators": {
+                "stages": [],
+                "amplitude_stage": stage,
+            },
+        },
+    }
+
+    with pytest.raises(FinalAuditError, match=r"plane_application\.target"):
+        _audit_compiled_execution(execution, _cell(ExecutionMode.COMPILED))
+
+
+def test_final_replay_matrix_conversion_rejects_sign_and_complex_drift() -> None:
+    assert _real_nonnegative(2.0 + 0.0j, "matrix") == 2.0
+    assert _real_nonnegative(-1.0e-16 + 0.0j, "matrix") == 0.0
+    with pytest.raises(FinalAuditError, match="materially negative"):
+        _real_nonnegative(-1.0e-3 + 0.0j, "matrix")
+    with pytest.raises(FinalAuditError, match="imaginary part"):
+        _real_nonnegative(1.0 + 1.0e-3j, "matrix")
+
+
+def test_shared_artifact_contract_binds_the_exact_physics_cell() -> None:
+    cell = _cell(ExecutionMode.RECURRENCE, optimization_level=2)
+    dataset_alias = replace(cell, dataset_id="another_dataset")
+    different_process = replace(
+        cell,
+        process="u u~ > z",
+        process_key="uu_z",
+    )
+
+    assert _shared_artifact_contract(dataset_alias) == _shared_artifact_contract(cell)
+    assert _shared_artifact_contract(different_process) != _shared_artifact_contract(
+        cell
+    )
+
+    on_the_fly = _cell(ExecutionMode.ON_THE_FLY, optimization_level=2)
+    all_flow = replace(on_the_fly, workload=Workload.ALL_FLOW)
+    assert _shared_artifact_contract(on_the_fly) == _shared_artifact_contract(all_flow)
+
+
+def test_native_otf_seed_inspector_wraps_native_decode_errors(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class NativeDecodeError(Exception):
+        pass
+
+    module = SimpleNamespace(
+        _inspect_on_the_fly_process_seed_v1=lambda _payload: (_ for _ in ()).throw(
+            NativeDecodeError("malformed native seed")
+        )
+    )
+    monkeypatch.setattr(
+        final_audit_module.importlib,
+        "import_module",
+        lambda _name: module,
+    )
+
+    with pytest.raises(FinalAuditError, match="cannot be decoded") as error:
+        final_audit_module._native_on_the_fly_process_seed_identity(b"bad-seed")
+    assert isinstance(error.value.__cause__, NativeDecodeError)
+
+
+def test_otf_artifact_audit_accepts_only_compact_seed_and_prepared_jit_contract(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import importlib.util
+    from types import ModuleType
+
+    # Load the pure-Python PACBIN codec without importing the intentionally
+    # stale shared-tree native runtime used by this publication-only test.
+    package = ModuleType("pyamplicol")
+    package.__path__ = []  # type: ignore[attr-defined]
+    generation = ModuleType("pyamplicol.generation")
+    generation.__path__ = []  # type: ignore[attr-defined]
+    codec_name = "pyamplicol.generation.evaluator_container"
+    codec_path = (
+        Path(__file__).resolve().parents[2]
+        / "src/pyamplicol/generation/evaluator_container.py"
+    )
+    spec = importlib.util.spec_from_file_location(codec_name, codec_path)
+    assert spec is not None and spec.loader is not None
+    codec = importlib.util.module_from_spec(spec)
+    monkeypatch.setitem(sys.modules, "pyamplicol", package)
+    monkeypatch.setitem(sys.modules, "pyamplicol.generation", generation)
+    monkeypatch.setitem(sys.modules, codec_name, codec)
+    spec.loader.exec_module(codec)
+    PacbinMemberKind = codec.PacbinMemberKind
+    PacbinMemberSource = codec.PacbinMemberSource
+    write_pacbin_atomic = codec.write_pacbin_atomic
+
+    process_id = "otf_dd_z"
+    pack_relative = "model/eager-kernel-pack.json"
+    runtime_relative = f"processes/{process_id}/on-the-fly-runtime.pacbin"
+    seed_identity = {
+        "abi": "pyamplicol-on-the-fly-process-seed-identity-v1",
+        "process_digest": "1" * 64,
+        "compiled_model_digest": "2" * 64,
+        "recurrence_template_catalog_digest": "3" * 64,
+        "prepared_kernel_pack_digest": "4" * 64,
+        "recurrence_direct_template_catalog_digest": "5" * 64,
+        "semantic_digest": "6" * 64,
+        "external_permutation": [0, 1, 2],
+        "external_sources": [
+            {
+                "source_slot": 0,
+                "public_label": 1,
+                "is_initial": True,
+                "states": [
+                    {
+                        "state_index": 0,
+                        "public_helicity": -1,
+                        "prepared_mass_parameter_slot": None,
+                    }
+                ],
+            },
+            {
+                "source_slot": 1,
+                "public_label": 2,
+                "is_initial": True,
+                "states": [
+                    {
+                        "state_index": 0,
+                        "public_helicity": 1,
+                        "prepared_mass_parameter_slot": None,
+                    }
+                ],
+            },
+            {
+                "source_slot": 2,
+                "public_label": 3,
+                "is_initial": False,
+                "states": [
+                    {
+                        "state_index": 0,
+                        "public_helicity": 0,
+                        "prepared_mass_parameter_slot": 6,
+                    }
+                ],
+            },
+        ],
+    }
+    pack = {
+        "backend": "jit",
+        "eager_kernel_abi": "pyamplicol-eager-kernel-v1",
+        "dependency_abis": {
+            "symjit_application": "symjit-application-storage-v3",
+            "symjit_plane_application": "pyamplicol-symjit-plane-application-v2",
+        },
+        "recurrence_template": {
+            "header": {
+                "compiled_model_digest": "2" * 64,
+                "catalog_digest": "3" * 64,
+                "prepared_kernel_pack_digest": "4" * 64,
+            }
+        },
+        "recurrence_direct_template": {
+            "catalog_digest": "5" * 64,
+            "compiled_model_digest": "2" * 64,
+            "recurrence_template_catalog_digest": "3" * 64,
+            "prepared_kernel_pack_digest": "4" * 64,
+        },
+        "optimization_settings": {
+            "backend": "jit",
+            "jit_optimization_level": 2,
+        },
+        "kernels": [
+            {
+                "contract_kind": "vertex",
+                "f64_evaluator_manifest": _canonical_symjit_evaluator(
+                    "kernels/000000/application.symjit",
+                    "kernels/000000/application.plane.symjit",
+                    optimization_level=2,
+                ),
+            }
+        ],
+        "kernel_variants": [],
+    }
+    pack_path = tmp_path / pack_relative
+    pack_path.parent.mkdir(parents=True)
+    pack_data = json.dumps(pack, sort_keys=True).encode("ascii")
+    pack_path.write_bytes(pack_data)
+    runtime_path = tmp_path / runtime_relative
+    runtime_path.parent.mkdir(parents=True)
+    write_pacbin_atomic(
+        runtime_path,
+        (
+            PacbinMemberSource(
+                "on-the-fly/process-seed-v1.bin",
+                PacbinMemberKind.ON_THE_FLY_PROCESS_SEED,
+                io.BytesIO(b"compact-process-seed"),
+            ),
+        ),
+    )
+    runtime_data = runtime_path.read_bytes()
+    prepared_identity = {
+        "kind": "pyamplicol-prepared-kernel-pack-identity",
+        "schema_version": 1,
+        "abi": "pyamplicol-prepared-kernel-pack-identity-v2",
+        "backend": "jit",
+        "eager_kernel_abi": "pyamplicol-eager-kernel-v1",
+        "identity_sha256": "7" * 64,
+        "kernel_count": 1,
+    }
+
+    def payload(
+        relative: str,
+        data: bytes,
+        *,
+        role: str,
+        media_type: str,
+        owner: str | None,
+    ) -> SimpleNamespace:
+        return SimpleNamespace(
+            path=relative,
+            size_bytes=len(data),
+            sha256=hashlib.sha256(data).hexdigest(),
+            role=role,
+            media_type=media_type,
+            process_id=owner,
+            executable=False,
+        )
+
+    manifest = SimpleNamespace(
+        payloads=(
+            payload(
+                pack_relative,
+                pack_data,
+                role="evaluator-manifest",
+                media_type="application/json",
+                owner=None,
+            ),
+            payload(
+                runtime_relative,
+                runtime_data,
+                role="evaluator-state",
+                media_type="application/octet-stream",
+                owner=process_id,
+            ),
+        ),
+        extensions={"eager_prepared_pack": prepared_identity},
+    )
+    execution = {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-on-the-fly-execution",
+        "required_runtime_capabilities": [
+            "rusticol.on-the-fly.complex-f64.v1",
+            "rusticol.on-the-fly.lc-color.v1",
+        ],
+        "process": "d d~ > z",
+        "key": process_id,
+        "color_accuracy": "lc",
+        "external_pdg_order": [1, -1, 23],
+        "kernel_pack": {
+            "manifest_path": pack_relative,
+            "payload_root": "model/eager-kernels",
+        },
+        "runtime_options": {
+            "point_tile_size": 128,
+            "query_construction_threads": 4,
+        },
+        "selector_policy": {
+            "color_coverage": "complete",
+            "reference_color_word": None,
+            "trace_reflections_folded": False,
+            "selector_census": {
+                "physical_helicity_count": 1,
+                "physical_color_flow_count": 1,
+            },
+        },
+        "runtime_metadata": {
+            "runtime_parameters": [],
+            "parameter_projection": [
+                {
+                    "runtime_name": "particle.23.mass",
+                    "component": 0,
+                    "prepared_parameter_id": 6,
+                }
+            ],
+            "external_legs": [
+                {
+                    "source_slot": 0,
+                    "public_label": 1,
+                    "outgoing_pdg": -1,
+                    "is_initial": True,
+                },
+                {
+                    "source_slot": 1,
+                    "public_label": 2,
+                    "outgoing_pdg": 1,
+                    "is_initial": True,
+                },
+                {
+                    "source_slot": 2,
+                    "public_label": 3,
+                    "outgoing_pdg": 23,
+                    "is_initial": False,
+                },
+            ],
+            "process_seed_identity": deepcopy(seed_identity),
+        },
+        "runtime_container": {
+            "kind": "pyamplicol-on-the-fly-runtime-container",
+            "schema_version": 1,
+            "storage_abi": "pacbin-v1",
+            "path": "on-the-fly-runtime.pacbin",
+            "seed_member_path": "on-the-fly/process-seed-v1.bin",
+        },
+    }
+    cell = _cell(ExecutionMode.ON_THE_FLY, optimization_level=2)
+    effective_config = {"evaluator": {"optimization": {"cores": 4}}}
+    monkeypatch.setattr(
+        final_audit_module,
+        "_expected_eager_prepared_pack_identity",
+        lambda _cell: dict(prepared_identity),
+    )
+    monkeypatch.setattr(
+        final_audit_module,
+        "_native_on_the_fly_process_seed_identity",
+        lambda payload: (
+            deepcopy(seed_identity)
+            if payload == b"compact-process-seed"
+            else (_ for _ in ()).throw(FinalAuditError("undecodable compact seed"))
+        ),
+    )
+
+    assert (
+        _audit_on_the_fly_execution(
+            tmp_path,
+            manifest,
+            execution,
+            cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+            effective_config=effective_config,
+        )
+        == 1
+    )
+
+    color_relative = f"processes/{process_id}/on-the-fly-color.bin"
+    color_data = b"authenticated-expanded-contracted-color"
+    color_path = tmp_path / color_relative
+    color_path.write_bytes(color_data)
+    color_sha256 = hashlib.sha256(color_data).hexdigest()
+    contracted_manifest = SimpleNamespace(
+        payloads=(
+            *manifest.payloads,
+            payload(
+                color_relative,
+                color_data,
+                role="evaluator-state",
+                media_type="application/octet-stream",
+                owner=process_id,
+            ),
+        ),
+        extensions=manifest.extensions,
+    )
+    contracted_execution = deepcopy(execution)
+    contracted_execution["required_runtime_capabilities"] = [
+        "rusticol.on-the-fly.complex-f64.v1",
+        "rusticol.on-the-fly.contracted-color.v1",
+    ]
+    contracted_execution["color_accuracy"] = "full"
+    contracted_execution["selector_policy"] = {
+        "color_coverage": "contracted",
+        "reference_color_word": None,
+        "trace_reflections_folded": False,
+        "selector_census": {
+            "physical_helicity_count": 1,
+            "physical_color_flow_count": 1,
+        },
+    }
+    contracted_execution["runtime_metadata"]["color_contraction"] = {  # type: ignore[index]
+        "abi": "pyamplicol-recurrence-color-contraction-v3",
+        "color_accuracy": "full",
+        "storage": "expanded",
+        "includes_color_factor": True,
+        "group_count": 2,
+        "sector_count": 2,
+        "active_sector_count": 2,
+        "component_count": 1,
+        "destination_count": 2,
+        "entry_count": 2,
+        "logical_entry_count": 2,
+        "semantic_digest": color_sha256,
+        "factorization": None,
+        "path": "on-the-fly-color.bin",
+        "size_bytes": len(color_data),
+        "sha256": color_sha256,
+    }
+    contracted_cell = replace(
+        cell,
+        measurement=replace(cell.measurement, accuracy=Accuracy.FULL),
+        workload=Workload.CONTRACTED,
+    )
+    assert (
+        _audit_on_the_fly_execution(
+            tmp_path,
+            contracted_manifest,
+            contracted_execution,
+            contracted_cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+            effective_config=effective_config,
+        )
+        == 1
+    )
+
+    selected_contracted = deepcopy(contracted_execution)
+    selected_contracted["selector_policy"]["reference_color_word"] = [1]  # type: ignore[index]
+    with pytest.raises(FinalAuditError, match="has a flow selector"):
+        _audit_on_the_fly_execution(
+            tmp_path,
+            contracted_manifest,
+            selected_contracted,
+            contracted_cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+        )
+
+    with pytest.raises(FinalAuditError, match="payload is missing or ambiguous"):
+        _audit_on_the_fly_execution(
+            tmp_path,
+            manifest,
+            contracted_execution,
+            contracted_cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+        )
+
+    mismatched_threads = deepcopy(execution)
+    mismatched_threads["runtime_options"]["query_construction_threads"] = 3  # type: ignore[index]
+    with pytest.raises(FinalAuditError, match="effective evaluator cores"):
+        _audit_on_the_fly_execution(
+            tmp_path,
+            manifest,
+            mismatched_threads,
+            cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+            effective_config=effective_config,
+        )
+
+    for mutation in ("missing", "zero", "extra", "seed-mismatch"):
+        changed_execution = deepcopy(execution)
+        census = changed_execution["selector_policy"]["selector_census"]
+        assert isinstance(census, dict)
+        if mutation == "missing":
+            del census["physical_color_flow_count"]
+        elif mutation == "zero":
+            census["physical_helicity_count"] = 0
+        elif mutation == "extra":
+            census["invented"] = 1
+        else:
+            census["physical_helicity_count"] = 2
+        with pytest.raises(FinalAuditError, match=r"selector (?:helicity )?census"):
+            _audit_on_the_fly_execution(
+                tmp_path,
+                manifest,
+                changed_execution,
+                cell,
+                process_id=process_id,
+                execution_manifest_path=f"processes/{process_id}/execution.json",
+            )
+
+    for mutation in ("digest", "missing-abi", "wrong-abi", "extra-field"):
+        changed = dict(prepared_identity)
+        if mutation == "digest":
+            changed["identity_sha256"] = "8" * 64
+        elif mutation == "missing-abi":
+            del changed["abi"]
+        elif mutation == "wrong-abi":
+            changed["abi"] = "pyamplicol-prepared-kernel-pack-identity-v1"
+        else:
+            changed["invented"] = True
+        changed_manifest = SimpleNamespace(
+            payloads=manifest.payloads,
+            extensions={"eager_prepared_pack": changed},
+        )
+        with pytest.raises(FinalAuditError, match="prepared-pack identity"):
+            _audit_on_the_fly_execution(
+                tmp_path,
+                changed_manifest,
+                execution,
+                cell,
+                process_id=process_id,
+                execution_manifest_path=f"processes/{process_id}/execution.json",
+            )
+
+    for field, replacement in (
+        ("process_digest", "7" * 64),
+        ("semantic_digest", "8" * 64),
+        ("prepared_kernel_pack_digest", "9" * 64),
+    ):
+        changed_native = deepcopy(seed_identity)
+        changed_native[field] = replacement
+        monkeypatch.setattr(
+            final_audit_module,
+            "_native_on_the_fly_process_seed_identity",
+            lambda _payload, identity=changed_native: deepcopy(identity),
+        )
+        with pytest.raises(FinalAuditError, match="does not identify"):
+            _audit_on_the_fly_execution(
+                tmp_path,
+                manifest,
+                execution,
+                cell,
+                process_id=process_id,
+                execution_manifest_path=f"processes/{process_id}/execution.json",
+            )
+
+    monkeypatch.setattr(
+        final_audit_module,
+        "_native_on_the_fly_process_seed_identity",
+        lambda _payload: deepcopy(seed_identity),
+    )
+    changed_state = deepcopy(execution)
+    changed_state["runtime_metadata"]["process_seed_identity"][  # type: ignore[index]
+        "external_sources"
+    ][2]["states"][0]["public_helicity"] = 1
+    with pytest.raises(FinalAuditError, match="does not identify"):
+        _audit_on_the_fly_execution(
+            tmp_path,
+            manifest,
+            changed_state,
+            cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+        )
+
+    changed_anchor = deepcopy(execution)
+    changed_anchor["runtime_metadata"]["external_legs"][2][  # type: ignore[index]
+        "public_label"
+    ] = 9
+    with pytest.raises(FinalAuditError, match="source identity disagrees"):
+        _audit_on_the_fly_execution(
+            tmp_path,
+            manifest,
+            changed_anchor,
+            cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+        )
+
+    changed_mass_slot = deepcopy(execution)
+    changed_mass_slot["runtime_metadata"]["parameter_projection"][0][  # type: ignore[index]
+        "prepared_parameter_id"
+    ] = 7
+    with pytest.raises(FinalAuditError, match="mass slot differs"):
+        _audit_on_the_fly_execution(
+            tmp_path,
+            manifest,
+            changed_mass_slot,
+            cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+        )
+
+    monkeypatch.setattr(
+        final_audit_module,
+        "_native_on_the_fly_process_seed_identity",
+        lambda _payload: (_ for _ in ()).throw(
+            FinalAuditError("undecodable compact seed")
+        ),
+    )
+    with pytest.raises(FinalAuditError, match="undecodable compact seed"):
+        _audit_on_the_fly_execution(
+            tmp_path,
+            manifest,
+            execution,
+            cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+        )
+
+    invented_seed_contract = deepcopy(execution)
+    invented_seed_contract["runtime_container"]["seed_member_path"] = (  # type: ignore[index]
+        "pyamplicol-on-the-fly-process-seed-v1"
+    )
+    with pytest.raises(FinalAuditError, match="runtime container contract"):
+        _audit_on_the_fly_execution(
+            tmp_path,
+            manifest,
+            invented_seed_contract,
+            cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+        )
+
+    recurrence_plan = deepcopy(execution)
+    recurrence_plan["plan"] = {"materialized": True}
+    with pytest.raises(FinalAuditError, match="compact contract"):
+        _audit_on_the_fly_execution(
+            tmp_path,
+            manifest,
+            recurrence_plan,
+            cell,
+            process_id=process_id,
+            execution_manifest_path=f"processes/{process_id}/execution.json",
+        )
+
+
+def test_otf_effective_config_contract() -> None:
+    cell = replace(
+        _cell(ExecutionMode.ON_THE_FLY, optimization_level=2),
+        workload=Workload.ALL_FLOW,
+    )
+    effective = {
+        "evaluator": {
+            "execution_mode": "on-the-fly",
+            "backend": "jit",
+            "jit": {"optimization_level": 2},
+        },
+        "color": {"accuracy": "lc", "lc_flow_layout": "topology-replay"},
+        "generation": {
+            "relation_discovery": {"mode": "off"},
+            "validation": {
+                "enabled": False,
+                "samples": 10,
+                "seed": 12345,
+                "relative_tolerance": 1.0e-12,
+                "absolute_tolerance": 1.0e-300,
+                "post_build_validation": False,
+            },
+        },
+    }
+
+    _audit_effective_config_mapping(cell, effective, context="otf")
+
+    wrong_layout = deepcopy(effective)
+    wrong_layout["color"]["lc_flow_layout"] = "all-flow-union"  # type: ignore[index]
+    with pytest.raises(FinalAuditError, match=r"color\.lc_flow_layout"):
+        _audit_effective_config_mapping(cell, wrong_layout, context="otf")
+
+
+@pytest.mark.parametrize("workload", (Workload.SELECTED_FLOW, Workload.ALL_FLOW))
+def test_otf_artifact_audit_distinguishes_requested_and_physical_layout(
+    tmp_path: Path,
+    monkeypatch,
+    workload: Workload,
+) -> None:
+    cell = replace(
+        _cell(ExecutionMode.ON_THE_FLY, optimization_level=2),
+        workload=workload,
+    )
+    process_id = "d_dbar_to_z"
+    effective = {
+        "evaluator": {
+            "execution_mode": "on-the-fly",
+            "backend": "jit",
+            "jit": {"optimization_level": 2},
+        },
+        "color": {"accuracy": "lc", "lc_flow_layout": "topology-replay"},
+        "generation": {
+            "relation_discovery": {"mode": "off"},
+            "validation": {
+                "enabled": False,
+                "samples": 10,
+                "seed": 12345,
+                "relative_tolerance": 1.0e-12,
+                "absolute_tolerance": 1.0e-300,
+                "post_build_validation": False,
+            },
+        },
+    }
+    capability = final_audit_module._ARENA_CAPABILITY[ExecutionMode.ON_THE_FLY]
+    process = {
+        "id": process_id,
+        "expression": cell.process,
+        "color_accuracy": cell.measurement.accuracy.value,
+        "required_runtime_capabilities": (capability,),
+    }
+    manifest = SimpleNamespace(
+        artifact_id=_ARTIFACT_ID,
+        producer={
+            "version": "0.1.0.dev0+candidate.test",
+            "git_revision": _REVISION,
+            "native_build_inputs_sha256": "e" * 64,
+        },
+        processes=(process,),
+        runtime={"engine_version": "runtime-v1"},
+    )
+    inspected = SimpleNamespace(
+        id=process_id,
+        execution_mode=ExecutionMode.ON_THE_FLY.value,
+        generation_specialized_axes=(),
+        selected_source_helicities=(),
+        selected_color_sector_ids=(),
+        lc_flow_layout="compact/query-local",
+    )
+    inspection = SimpleNamespace(integrity="verified", processes=(inspected,))
+
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.inspect_artifact", lambda _artifact: inspection
+    )
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.load_manifest", lambda *_args, **_kwargs: manifest
+    )
+    monkeypatch.setattr(
+        final_audit_module,
+        "_authenticated_effective_config",
+        lambda _artifact, _manifest: effective,
+    )
+    monkeypatch.setattr(
+        final_audit_module, "_audit_model_source", lambda _cell, _effective: None
+    )
+    monkeypatch.setattr(
+        final_audit_module,
+        "_find_process_execution",
+        lambda _artifact, _manifest, _process_id: (
+            {},
+            f"processes/{process_id}/execution.json",
+            "1" * 64,
+            (capability,),
+        ),
+    )
+    monkeypatch.setattr(
+        final_audit_module,
+        "_audit_on_the_fly_execution",
+        lambda *_args, **_kwargs: 1,
+    )
+
+    evidence = audit_artifact(cell, tmp_path, process_id)
+    assert evidence.execution_mode == ExecutionMode.ON_THE_FLY.value
+    assert evidence.arena_record_count == 1
+    assert evidence.producer_version == "0.1.0.dev0+candidate.test"
+    assert evidence.producer_git_revision == _REVISION
+    assert evidence.producer_native_build_inputs_sha256 == "e" * 64
+
+    inspected.lc_flow_layout = "topology-replay"
+    with pytest.raises(FinalAuditError, match="physics/execution contract"):
+        audit_artifact(cell, tmp_path, process_id)
+
+
+def test_effective_toml_is_payload_authenticated_and_model_bound(
+    tmp_path: Path,
+) -> None:
+    relative = "config/effective.toml"
+    path = tmp_path / relative
+    path.parent.mkdir(parents=True)
+    data = b'[model]\nsource = "built-in-sm"\n'
+    path.write_bytes(data)
+    manifest = SimpleNamespace(
+        configuration={"effective_path": relative},
+        model={"source_kind": "built-in-sm"},
+        payloads=(
+            SimpleNamespace(
+                path=relative,
+                role="configuration-effective",
+                media_type="application/toml",
+                process_id=None,
+                executable=False,
+                size_bytes=len(data),
+                sha256=hashlib.sha256(data).hexdigest(),
+            ),
+        ),
+    )
+    effective = _authenticated_effective_config(tmp_path, manifest)
+    _audit_model_source(_cell(ExecutionMode.COMPILED), effective)
+
+    path.write_bytes(b'[model]\nsource = "built-in-xx"\n')
+    with pytest.raises(FinalAuditError, match="artifact manifest"):
+        _authenticated_effective_config(tmp_path, manifest)
+
+
+def test_eager_and_recurrence_arena_abis_are_audited(tmp_path: Path) -> None:
+    pack_path = tmp_path / "model" / "eager-kernel-pack.json"
+    pack_path.parent.mkdir(parents=True)
+    vertex_evaluator = _canonical_symjit_evaluator(
+        "kernels/000000/application.symjit",
+        "kernels/000000/application.plane.symjit",
+        optimization_level=2,
+    )
+    vertex_evaluator["direct_table"] = {
+        "capability": "eager-direct-arena-v1",
+        "descriptor_abi": "pyamplicol-eager-plane-table-descriptor-v1",
+        "binding_abi": "pyamplicol-eager-plane-table-binding-v2",
+        "source_application_abi": "pyamplicol-symjit-plane-application-v2",
+    }
+    pack_payload = {
+        "backend": "jit",
+        "optimization_settings": {
+            "backend": "jit",
+            "jit_optimization_level": 2,
+        },
+        "recurrence_direct_template": {
+            "abi": "pyamplicol-recurrence-direct-template-v1",
+            "backend": "jit",
+            "optimization_level": 2,
+            "portable": True,
+            "templates": [{"backend": "jit", "optimization_level": 2}],
+        },
+        "kernel_variants": [],
+        "kernels": [
+            {
+                "contract_kind": "vertex",
+                "f64_evaluator_manifest": vertex_evaluator,
+            },
+            {
+                "contract_kind": "model-parameter",
+                "f64_evaluator_manifest": {
+                    "kind": "symjit-application-evaluator",
+                    "runtime_capability": "symjit.application.complex-f64.v1",
+                    "optimization_level": 2,
+                    "application_abi": "symjit-application-storage-v3",
+                },
+            },
+        ],
+    }
+    payload_record = SimpleNamespace(
+        path="model/eager-kernel-pack.json",
+        role="evaluator-manifest",
+        media_type="application/json",
+        process_id=None,
+        executable=False,
+        size_bytes=0,
+        sha256="",
+    )
+
+    def write_pack(value: object) -> None:
+        data = json.dumps(value).encode("utf-8")
+        pack_path.write_bytes(data)
+        payload_record.size_bytes = len(data)
+        payload_record.sha256 = hashlib.sha256(data).hexdigest()
+
+    write_pack(pack_payload)
+    manifest = SimpleNamespace(
+        payloads=(payload_record,),
+        extensions={
+            "eager_prepared_pack": {
+                "kind": "pyamplicol-prepared-kernel-pack-identity",
+                "schema_version": 1,
+                "backend": "jit",
+                "eager_kernel_abi": "pyamplicol-eager-kernel-v1",
+                "identity_sha256": "c" * 64,
+                "kernel_count": 2,
+            }
+        },
+    )
+    eager = {
+        "kind": "pyamplicol-runtime-eager-execution",
+        "eager_plan_abi": "pyamplicol-eager-plan-v3",
+        "plan": {
+            "eager_plan_abi": "pyamplicol-eager-plan-v3",
+            "lowering_input_abi": "pyamplicol-eager-lowering-input-v1",
+            "runtime_layout_abi": "pyamplicol-eager-runtime-layout-v1",
+        },
+        "kernel_pack": {"manifest_path": "model/eager-kernel-pack.json"},
+    }
+    assert (
+        _audit_eager_execution(
+            tmp_path,
+            manifest,
+            eager,
+            _cell(
+                ExecutionMode.EAGER,
+                optimization_level=2,
+            ),
+        )
+        == 1
+    )
+    wrong_capability = deepcopy(pack_payload)
+    wrong_capability["kernels"][0]["f64_evaluator_manifest"][  # type: ignore[index]
+        "runtime_capability"
+    ] = "symbolica.compiled-cpp.complex-f64.v1"
+    write_pack(wrong_capability)
+    with pytest.raises(FinalAuditError, match="runtime_capability"):
+        _audit_eager_execution(
+            tmp_path,
+            manifest,
+            eager,
+            _cell(ExecutionMode.EAGER, optimization_level=2),
+        )
+    for nested_corruption in (
+        {"nested": [{"direct_table": None}]},
+        {"nested": {"capability": "eager-direct-arena-v1"}},
+        {"nested": {"descriptor_abi": "pyamplicol-eager-plane-table-descriptor-v1"}},
+        {"nested": {"binding_abi": "pyamplicol-eager-plane-table-binding-v2"}},
+        {"nested": {"application_abi": "pyamplicol-eager-native-direct-table-v1"}},
+    ):
+        corrupted = deepcopy(pack_payload)
+        corrupted["kernels"][1]["f64_evaluator_manifest"].update(  # type: ignore[index]
+            nested_corruption
+        )
+        write_pack(corrupted)
+        with pytest.raises(FinalAuditError, match="model-parameter"):
+            _audit_eager_execution(
+                tmp_path,
+                manifest,
+                eager,
+                _cell(ExecutionMode.EAGER, optimization_level=2),
+            )
+    corrupted = deepcopy(pack_payload)
+    corrupted["kernels"][1]["nested_kernel_metadata"] = {  # type: ignore[index]
+        "direct_table": {}
+    }
+    write_pack(corrupted)
+    with pytest.raises(FinalAuditError, match="model-parameter"):
+        _audit_eager_execution(
+            tmp_path,
+            manifest,
+            eager,
+            _cell(ExecutionMode.EAGER, optimization_level=2),
+        )
+    source_relative = "model/eager-kernels/kernels/000000/application-0.plane.symjit"
+    source_data = b"authenticated-symjit-application"
+    source_sha256 = hashlib.sha256(source_data).hexdigest()
+    recurrence, recurrence_pack = _recurrence_source_fixture(source_sha256)
+    write_pack(recurrence_pack)
+    source_path = tmp_path / source_relative
+    source_path.parent.mkdir(parents=True)
+    source_path.write_bytes(source_data)
+    source_record = SimpleNamespace(
+        path=source_relative,
+        role="evaluator-state",
+        media_type="application/octet-stream",
+        process_id=None,
+        executable=False,
+        size_bytes=len(source_data),
+        sha256=source_sha256,
+    )
+    manifest.payloads = (*manifest.payloads, source_record)
+    assert (
+        _audit_recurrence_execution(
+            recurrence,
+            _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        )
+        == 4
+    )
+    source_identity = _audit_recurrence_source_pack(
+        tmp_path,
+        manifest,
+        recurrence,
+        _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        execution_manifest_path="processes/d_dbar_to_z/execution.json",
+        execution_manifest_sha256="1" * 64,
+    )
+    assert source_identity == {
+        "kind": "authenticated-recurrence-direct-template-source-v1",
+        "optimization_level": 2,
+        "direct_template_count": 1,
+        "prepared_direct_template_count": 1,
+        "source_evaluator_leaf_count": 1,
+        "source_application_abi": "pyamplicol-symjit-plane-application-v2",
+        "direct_application_abi": "pyamplicol-symjit-plane-application-v2",
+        "prepared_kernel_pack_digest": "a" * 64,
+        "direct_template_catalog_digest": recurrence["direct_template_catalog_digest"],
+        "execution_manifest_path": "processes/d_dbar_to_z/execution.json",
+        "execution_manifest_sha256": "1" * 64,
+        "kernel_pack_path": "model/eager-kernel-pack.json",
+        "kernel_pack_sha256": payload_record.sha256,
+    }
+    wrong_o2 = deepcopy(recurrence_pack)
+    wrong_o2["optimization_settings"]["jit_optimization_level"] = 1  # type: ignore[index]
+    write_pack(wrong_o2)
+    with pytest.raises(FinalAuditError, match="does not prove JIT O2"):
+        _audit_recurrence_source_pack(
+            tmp_path,
+            manifest,
+            recurrence,
+            _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+            execution_manifest_path="processes/d_dbar_to_z/execution.json",
+            execution_manifest_sha256="1" * 64,
+        )
+    write_pack(pack_payload)
+    recurrence["plan"]["inspection_summary"]["direct_arena"][  # type: ignore[index]
+        "packed_input_bytes"
+    ] = 8
+    with pytest.raises(FinalAuditError, match="packed_input_bytes"):
+        _audit_recurrence_execution(
+            recurrence,
+            _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        )
+
+
+@pytest.mark.parametrize(
+    ("corruption", "message"),
+    (
+        ("execution_template_abi", "direct_template_abi"),
+        ("plan_template_abi", "direct_template_abi"),
+        ("execution_backend_abi", "direct_backend_abi"),
+        ("plan_backend_abi", "direct_backend_abi"),
+        ("plan_prepared_digest", "source digests"),
+        ("plan_catalog_digest", "source digests"),
+        ("pack_prepared_digest", "execution_digest_links"),
+        ("execution_catalog_link", "execution_digest_links"),
+        ("catalog_backend_abi", "does not prove JIT O2"),
+        ("catalog_canonicalization_abi", "does not prove JIT O2"),
+        ("catalog_digest", "catalog_digest"),
+        ("template_portable", "template\\[0\\] contract"),
+        ("template_abi", "template\\[0\\] contract"),
+        ("binding_abi", "payload-binding contract"),
+        ("source_application_abi", "source application"),
+        ("direct_application_abi", "source application"),
+        ("payload_digest", "payload-binding contract"),
+        ("source_leaf_runtime_capability", "runtime_capability"),
+        ("source_leaf_application_abi", "application_abi"),
+        ("source_leaf_optimization", "optimization_level"),
+        ("source_leaf_plane_abi", "plane_application.application_abi"),
+        ("source_leaf_plane_digest", "plane_application.source_digest"),
+        (
+            "source_leaf_plane_optimization",
+            "plane_application.optimization_level",
+        ),
+        ("source_leaf_path", "payload is missing"),
+        ("source_payload_digest_link", "not bound to its prepared kernel"),
+    ),
+)
+def test_final_audit_recurrence_source_pack_rejects_every_broken_link(
+    tmp_path: Path,
+    corruption: str,
+    message: str,
+) -> None:
+    pack_relative = "model/eager-kernel-pack.json"
+    source_relative = "model/eager-kernels/kernels/000000/application-0.plane.symjit"
+    source_data = b"authenticated-symjit-application"
+    source_sha256 = hashlib.sha256(source_data).hexdigest()
+    execution, pack = _recurrence_source_fixture(source_sha256)
+    plan = execution["plan"]
+    assert isinstance(plan, dict)
+    catalog = pack["recurrence_direct_template"]
+    assert isinstance(catalog, dict)
+    templates = catalog["templates"]
+    assert isinstance(templates, list)
+    template = templates[0]
+    assert isinstance(template, dict)
+    binding = template["payload_binding"]
+    assert isinstance(binding, dict)
+    kernels = pack["kernels"]
+    assert isinstance(kernels, list)
+    kernel = kernels[0]
+    assert isinstance(kernel, dict)
+    source_leaf = kernel["f64_evaluator_manifest"]
+    assert isinstance(source_leaf, dict)
+    refresh_catalog: bool | None = None
+
+    if corruption == "execution_template_abi":
+        execution["direct_template_abi"] = "wrong"
+    elif corruption == "plan_template_abi":
+        plan["direct_template_abi"] = "wrong"
+    elif corruption == "execution_backend_abi":
+        execution["direct_backend_abi"] = "wrong"
+    elif corruption == "plan_backend_abi":
+        plan["direct_backend_abi"] = "wrong"
+    elif corruption == "plan_prepared_digest":
+        plan["prepared_kernel_pack_digest"] = "0" * 64
+    elif corruption == "plan_catalog_digest":
+        plan["direct_template_catalog_digest"] = "0" * 64
+    elif corruption == "pack_prepared_digest":
+        catalog["prepared_kernel_pack_digest"] = "0" * 64
+        refresh_catalog = True
+    elif corruption == "execution_catalog_link":
+        execution["direct_template_catalog_digest"] = "0" * 64
+        plan["direct_template_catalog_digest"] = "0" * 64
+    elif corruption == "catalog_backend_abi":
+        catalog["backend_abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "catalog_canonicalization_abi":
+        catalog["canonicalization_abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "catalog_digest":
+        catalog["compiled_model_digest"] = "0" * 64
+    elif corruption == "template_portable":
+        template["portable"] = False
+        refresh_catalog = True
+    elif corruption == "template_abi":
+        template["abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "binding_abi":
+        binding["abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "source_application_abi":
+        binding["source_application_abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "direct_application_abi":
+        binding["direct_application_abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "payload_digest":
+        binding["payload_digest"] = "0" * 64
+        refresh_catalog = False
+    elif corruption == "source_leaf_runtime_capability":
+        source_leaf["runtime_capability"] = "wrong"
+    elif corruption == "source_leaf_application_abi":
+        source_leaf["application_abi"] = "wrong"
+    elif corruption == "source_leaf_optimization":
+        source_leaf["optimization_level"] = 1
+    elif corruption == "source_leaf_plane_abi":
+        source_leaf["plane_application"]["application_abi"] = "wrong"
+    elif corruption == "source_leaf_plane_digest":
+        source_leaf["plane_application"]["source_digest"] = "wrong"
+    elif corruption == "source_leaf_plane_optimization":
+        source_leaf["plane_application"]["optimization_level"] = 1
+    elif corruption == "source_leaf_path":
+        source_leaf["plane_application"]["application_path"] = (
+            "kernels/000000/missing.plane.symjit"
+        )
+    elif corruption == "source_payload_digest_link":
+        binding["source_application_sha256"] = "0" * 64
+        refresh_catalog = True
+    else:
+        pytest.fail(f"unknown corruption {corruption}")
+
+    if refresh_catalog is not None:
+        _refresh_recurrence_source_catalog(
+            execution,
+            pack,
+            refresh_binding_digest=refresh_catalog,
+        )
+    pack_path = tmp_path / pack_relative
+    pack_path.parent.mkdir(parents=True)
+    pack_data = json.dumps(pack, sort_keys=True).encode("ascii")
+    pack_path.write_bytes(pack_data)
+    source_path = tmp_path / source_relative
+    source_path.parent.mkdir(parents=True)
+    source_path.write_bytes(source_data)
+    manifest = SimpleNamespace(
+        payloads=(
+            SimpleNamespace(
+                path=pack_relative,
+                role="evaluator-manifest",
+                media_type="application/json",
+                process_id=None,
+                executable=False,
+                size_bytes=len(pack_data),
+                sha256=hashlib.sha256(pack_data).hexdigest(),
+            ),
+            SimpleNamespace(
+                path=source_relative,
+                role="evaluator-state",
+                media_type="application/octet-stream",
+                process_id=None,
+                executable=False,
+                size_bytes=len(source_data),
+                sha256=source_sha256,
+            ),
+        ),
+        extensions={},
+    )
+    with pytest.raises(FinalAuditError, match=message):
+        _audit_recurrence_source_pack(
+            tmp_path,
+            manifest,
+            execution,
+            _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+            execution_manifest_path="processes/d_dbar_to_z/execution.json",
+            execution_manifest_sha256="1" * 64,
+        )
+
+
+def test_pointwise_audit_recomputes_arithmetic_and_status() -> None:
+    record = {
+        "status": "ok",
+        "candidate": 1.0 + 1.0e-13,
+        "baseline": 1.0,
+        "absolute_difference": abs((1.0 + 1.0e-13) - 1.0),
+        "relative_difference": abs((1.0 + 1.0e-13) - 1.0),
+        "relative_tolerance": 1.0e-12,
+        "absolute_tolerance": 1.0e-15,
+    }
+    _audit_pointwise(
+        record,
+        context="pointwise",
+        expected_candidate=1.0 + 1.0e-13,
+        expected_baseline=1.0,
+        expected_relative_tolerance=1.0e-12,
+    )
+    record["relative_difference"] = 0.0
+    with pytest.raises(FinalAuditError, match="relative difference"):
+        _audit_pointwise(
+            record,
+            context="pointwise",
+            expected_candidate=1.0 + 1.0e-13,
+            expected_baseline=1.0,
+            expected_relative_tolerance=1.0e-12,
+        )
+
+
+def test_pointwise_audit_authenticates_conditioned_point_binding() -> None:
+    from tools.performance_report.runner import pointwise_validation
+
+    selector_identity = {"cell_id": "candidate", "value_kind": "total"}
+    record = pointwise_validation(
+        1.0 + 1.0e-13,
+        1.0,
+        comparison_binding={
+            "point_digest": "a" * 64,
+            "selector_component_identity": selector_identity,
+            "selector_component_sha256": hashlib.sha256(
+                json.dumps(
+                    selector_identity,
+                    allow_nan=False,
+                    ensure_ascii=True,
+                    separators=(",", ":"),
+                    sort_keys=True,
+                ).encode("ascii")
+            ).hexdigest(),
+            "candidate_source_sha256": "b" * 64,
+            "baseline_source_sha256": "c" * 64,
+        },
+    )
+    _audit_pointwise(
+        record,
+        context="conditioned",
+        expected_candidate=1.0 + 1.0e-13,
+        expected_baseline=1.0,
+        expected_relative_tolerance=1.0e-12,
+        expected_point_digest="a" * 64,
+        expected_candidate_source_sha256="b" * 64,
+        expected_baseline_source_sha256="c" * 64,
+        expected_selector_identity=selector_identity,
+    )
+    with pytest.raises(FinalAuditError, match="different point"):
+        _audit_pointwise(
+            record,
+            context="conditioned",
+            expected_candidate=1.0 + 1.0e-13,
+            expected_baseline=1.0,
+            expected_relative_tolerance=1.0e-12,
+            expected_point_digest="b" * 64,
+        )
+    with pytest.raises(FinalAuditError, match="candidate scale source"):
+        _audit_pointwise(
+            record,
+            context="conditioned",
+            expected_candidate=1.0 + 1.0e-13,
+            expected_baseline=1.0,
+            expected_relative_tolerance=1.0e-12,
+            expected_point_digest="a" * 64,
+            expected_candidate_source_sha256="d" * 64,
+        )
+
+
+def test_python_package_tree_identity_is_canonical_and_ignores_caches(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    from tools.performance_report import runtime_evidence
+
+    cache_prefix = tmp_path / "absent-cache-prefix"
+    monkeypatch.setattr(
+        runtime_evidence,
+        "_isolated_startup_flags",
+        lambda: (True, True, True),
+    )
+    monkeypatch.setattr(sys, "dont_write_bytecode", True)
+    monkeypatch.setattr(sys, "pycache_prefix", str(cache_prefix))
+    package = tmp_path / "pyamplicol"
+    (package / "submodule").mkdir(parents=True)
+    (package / "__pycache__").mkdir()
+    (package / "api.py").write_text("VALUE = 1\n", encoding="utf-8")
+    (package / "submodule" / "data.bin").write_bytes(b"\x00\x01")
+    (package / "__pycache__" / "api.pyc").write_bytes(b"cache one")
+
+    first = _python_package_tree_identity(package)
+    assert first["kind"] == "pyamplicol-python-package-tree-v2"
+    assert first["roots"] == [str(package)]
+    assert first["file_count"] == 2
+    assert first["total_bytes"] == 12
+
+    (package / "__pycache__" / "api.pyc").write_bytes(b"changed cache")
+    assert _python_package_tree_identity(package) == first
+
+    (package / "api.py").write_text("VALUE = 2\n", encoding="utf-8")
+    changed = _python_package_tree_identity(package)
+    assert changed["sha256"] != first["sha256"]
+
+
+def test_runtime_namespace_uses_only_first_native_candidate(tmp_path: Path) -> None:
+    from importlib.machinery import EXTENSION_SUFFIXES
+
+    checkout = tmp_path / "checkout"
+    source_package = checkout / "src" / "pyamplicol"
+    source_package.mkdir(parents=True)
+    (source_package / "__init__.py").write_bytes(b"")
+    first_site = tmp_path / "first-site"
+    second_site = tmp_path / "second-site"
+    first_package = first_site / "pyamplicol"
+    second_package = second_site / "pyamplicol"
+    first_package.mkdir(parents=True)
+    second_package.mkdir(parents=True)
+    suffix = EXTENSION_SUFFIXES[0]
+    first_native = first_package / f"_rusticol{suffix}"
+    second_native = second_package / f"_rusticol{suffix}"
+    first_native.write_bytes(b"first")
+    second_native.write_bytes(b"stale")
+
+    roots, native = _runtime_namespace_paths(
+        checkout,
+        search_path=(str(first_site), str(second_site)),
+    )
+
+    assert roots == (source_package.resolve(), first_package.resolve())
+    assert native == first_native.resolve()
+    assert second_package.resolve() not in roots
+
+
+def test_runtime_namespace_rejects_ambiguous_first_native_root(
+    tmp_path: Path,
+) -> None:
+    from importlib.machinery import EXTENSION_SUFFIXES
+
+    checkout = tmp_path / "checkout"
+    (checkout / "src" / "pyamplicol").mkdir(parents=True)
+    site = tmp_path / "site"
+    package = site / "pyamplicol"
+    package.mkdir(parents=True)
+    suffix = EXTENSION_SUFFIXES[0]
+    (package / f"_rusticol{suffix}").write_bytes(b"one")
+    (package / f"_rusticol_duplicate{suffix}").write_bytes(b"two")
+
+    with pytest.raises(FinalAuditError, match="ambiguous"):
+        _runtime_namespace_paths(checkout, search_path=(str(site),))
+
+
+def test_direct_final_audit_cli_fails_closed_when_not_already_isolated(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    from tools.performance_report.runtime_evidence import RuntimeEvidenceError
+
+    checkout = tmp_path / "checkout"
+    monkeypatch.setattr(
+        "tools.performance_report.final_audit.source_only_bytecode_policy",
+        lambda: (_ for _ in ()).throw(RuntimeEvidenceError("not isolated")),
+    )
+    raw = ("--repo-root", str(checkout), "--expected-source-revision", _REVISION)
+    with pytest.raises(
+        FinalAuditError,
+        match=(r"src/pyamplicol/_profiling_campaign/result_tables\.py final-audit"),
+    ):
+        _ensure_exact_cli_python(checkout, raw)
+
+
+def test_master_tex_dependency_graph_reaches_every_canonical_table(
+    tmp_path: Path,
+) -> None:
+    docs = tmp_path / "docs"
+    sections = docs / "sections"
+    tables = docs / "tables"
+    sections.mkdir(parents=True)
+    tables.mkdir()
+    master = docs / "pyAmpliCol.tex"
+    section = sections / "performance.tex"
+    first = tables / "result_first_table.tex"
+    second = tables / "result_second_table.tex"
+    unreachable = tables / "result_unreachable_table.tex"
+    for table in (first, second, unreachable):
+        table.write_text(f"% {table.name}\n", encoding="utf-8")
+    master.write_text(
+        "\\input{sections/performance}\n"
+        "% \\\\input{tables/result_unreachable_table.tex}\n",
+        encoding="utf-8",
+    )
+    section.write_text(
+        "\\input{../tables/result_first_table.tex}\n"
+        "\\include{../tables/result_second_table}\n",
+        encoding="utf-8",
+    )
+
+    identity = _audit_tex_table_reachability(master, (first, second))
+    assert identity["reachable_table_source_count"] == 2
+    assert identity["reachable_tex_source_count"] == 4
+
+    with pytest.raises(FinalAuditError, match="not reachable"):
+        _audit_tex_table_reachability(master, (first, second, unreachable))
+
+
+def test_active_runtime_snapshot_binds_exact_checkout(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    import pyamplicol
+    from pyamplicol._internal import versions
+
+    native_path = tmp_path / "_rusticol.so"
+    native_path.write_bytes(b"native")
+    native_version = pyamplicol.__version__.replace(".dev", "-dev.")
+    native = SimpleNamespace(
+        __file__=str(native_path),
+        package_version=lambda: native_version,
+        native_build_inputs_sha256=lambda: "e" * 64,
+        target_info=lambda: SimpleNamespace(
+            triple="aarch64-apple-darwin",
+            cpu_features=(),
+        ),
+    )
+    package_root = Path(str(pyamplicol.__file__)).parent.resolve()
+    package_tree = {
+        "kind": "pyamplicol-python-package-tree-v2",
+        "root": str(package_root),
+        "roots": [str(package_root)],
+        "file_count": 1,
+        "total_bytes": 1,
+        "sha256": "9" * 64,
+        "member_set_stable": True,
+        "namespace_bound_to_root_fd": True,
+        "bytecode_policy": _bytecode_policy(),
+    }
+    native_identity = {
+        "path": str(native_path),
+        "size": len(b"native"),
+        "sha256": hashlib.sha256(b"native").hexdigest(),
+    }
+    preimport_identity = {
+        "kind": "pyamplicol-preimport-runtime-identity-v1",
+        "python_package_tree": package_tree,
+        "native_extension": native_identity,
+    }
+    monkeypatch.setattr(
+        "tools.performance_report.final_audit._prepare_exact_pyamplicol_namespace",
+        lambda _checkout: (
+            pyamplicol,
+            (package_root,),
+            native_path,
+            preimport_identity,
+        ),
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.final_audit._python_package_tree_identity",
+        lambda roots: (
+            package_tree
+            if tuple(roots) == (package_root,)
+            else pytest.fail(f"unexpected package roots: {roots}")
+        ),
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.final_audit.loaded_pyamplicol_origin_policy",
+        lambda roots, **kwargs: (
+            _loaded_origin_policy()
+            if (
+                tuple(roots) == (package_root,)
+                and kwargs["native_extension"] == native_path
+                and kwargs["expected_package_identity"] == package_tree
+                and kwargs["expected_native_identity"] == native_identity
+            )
+            else pytest.fail("unexpected loaded-origin evidence request")
+        ),
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.final_audit.importlib.import_module",
+        lambda name: native if name == "pyamplicol._rusticol" else None,
+    )
+    monkeypatch.setattr(versions, "verify_native_module", lambda _native: None)
+    monkeypatch.setattr(
+        versions,
+        "_active_build_info",
+        lambda: {
+            "schema_version": 1,
+            "version": pyamplicol.__version__,
+            "candidate_fingerprint": "candidate",
+            "source_revision": _REVISION,
+            "source_checkout": str(tmp_path),
+            "native_build_inputs_sha256": "e" * 64,
+            "publishable": False,
+        },
+    )
+
+    snapshot = _active_runtime_snapshot(
+        _REVISION,
+        expected_checkout=tmp_path,
+    )
+    assert snapshot["native_build_inputs_sha256"] == "e" * 64
+    assert snapshot["python_package_tree"]["kind"] == (  # type: ignore[index]
+        "pyamplicol-python-package-tree-v2"
+    )
+    assert snapshot["native_extension"]["package_version"] == native_version  # type: ignore[index]
+    assert snapshot["loaded_module_origin_policy"] == _loaded_origin_policy()
+
+    other = tmp_path / "other"
+    other.mkdir()
+    with pytest.raises(FinalAuditError, match="not bound"):
+        _active_runtime_snapshot(_REVISION, expected_checkout=other)
+
+
+@dataclass(frozen=True)
+class _Flow:
+    id: str
+    word: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class _Helicity:
+    id: str
+    values: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class _Particle:
+    label: int
+
+
+class _Resolved:
+    values = (((1.0 + 0.0j,),),)
+    helicity_ids = ("h:-1,+1,-1",)
+    color_ids = ("flow:2,1",)
+
+    def total(self) -> tuple[complex, ...]:
+        return (1.0 + 0.0j,)
+
+
+class _Runtime:
+    artifact_id = _ARTIFACT_ID
+    execution_mode = "recurrence"
+
+    def __init__(self) -> None:
+        self.physics = SimpleNamespace(
+            color_accuracy="lc",
+            selector_capabilities=("helicity", "color_flow"),
+            external_particles=(_Particle(1), _Particle(2), _Particle(3)),
+            helicities=(_Helicity("h:-1,+1,-1", (-1, 1, -1)),),
+            color_flows=(_Flow("flow:2,1", (2, 1)),),
+        )
+
+    def evaluate(
+        self,
+        _points: object,
+        **_kwargs: object,
+    ) -> tuple[complex, ...]:
+        return (1.0 + 0.0j,)
+
+    def evaluate_resolved(
+        self,
+        _points: object,
+        **_kwargs: object,
+    ) -> _Resolved:
+        return _Resolved()
+
+
+class _Catalog:
+    def __init__(self, baseline: CellSpec, candidate: CellSpec) -> None:
+        self.baseline = baseline
+        self.candidate = candidate
+
+    def measurement_cells(self) -> tuple[CellSpec, ...]:
+        return (self.baseline, self.candidate)
+
+    def baseline_cell(self, cell: CellSpec) -> CellSpec | None:
+        return self.baseline if cell == self.candidate else None
+
+    def validation_baseline_cell(self, cell: CellSpec) -> CellSpec | None:
+        return self.baseline_cell(cell)
+
+    def static_na_reason(self, _cell: CellSpec) -> None:
+        return None
+
+    def legacy_reference_available(self, _cell: CellSpec) -> bool:
+        return True
+
+
+def _selector() -> dict[str, object]:
+    return {
+        "selected_color_flow_ids": ["flow:2,1"],
+        "selected_color_words": [[2, 1]],
+        "all_flow_helicity_ids": ["h:-1,+1,-1"],
+        "all_flow_source_helicities": {"1": -1, "2": 1, "3": -1},
+        "point_digest": (
+            "20d4353b25501bdf6c980930babe948e7c1d0364a3169d1ef5dc2a9da427e05c"
+        ),
+    }
+
+
+def _lc_common_component(cell_id: str) -> dict[str, object]:
+    selector = _selector()
+    return {
+        "abi": LC_COMMON_COMPONENT_ABI,
+        "cell_id": cell_id,
+        "value": 1.0,
+        "point_digest": selector["point_digest"],
+        "helicity_ids": selector["all_flow_helicity_ids"],
+        "color_flow_ids": selector["selected_color_flow_ids"],
+    }
+
+
+def test_otf_v2_replay_uses_compact_selector_context_without_dense_physics(
+    tmp_path: Path,
+) -> None:
+    cell = _cell(ExecutionMode.ON_THE_FLY, optimization_level=2)
+    points = final_audit_module.shared_validation_points(cell.process)
+    raw_selector = _selector()
+    raw_selector["point_digest"] = report_runner.point_digest(points)
+    contract = report_runner.SelectorContract.from_mapping(raw_selector)
+
+    class Backend:
+        def __init__(self) -> None:
+            self.context_requests: list[tuple[str, ...]] = []
+            self.selector_requests: list[tuple[str, tuple[str, ...]]] = []
+
+        def _on_the_fly_benchmark_context(
+            self,
+            requested: tuple[str, ...],
+        ) -> dict[str, object]:
+            self.context_requests.append(requested)
+            return {
+                "process_id": "d_dbar_to_z",
+                "process_expression": cell.process,
+                "color_accuracy": "lc",
+                "helicity_count": 1,
+                "color_count": 1,
+                "selected_color_ids": list(requested),
+            }
+
+        def _point_selector_indices(
+            self,
+            values: tuple[str, ...],
+            name: str,
+        ) -> tuple[int, ...]:
+            self.selector_requests.append((name, values))
+            return (0,)
+
+    class Runtime:
+        artifact_id = _ARTIFACT_ID
+        execution_mode = "on-the-fly"
+
+        def __init__(self) -> None:
+            self._backend = Backend()
+            self.dense_physics_access_count = 0
+
+        @property
+        def physics(self) -> object:
+            self.dense_physics_access_count += 1
+            raise AssertionError("OTF replay opened dense physics")
+
+        def evaluate(self, _points: object, **_kwargs: object) -> tuple[complex, ...]:
+            return (1.0 + 0.0j,)
+
+        def evaluate_resolved(self, _points: object, **_kwargs: object) -> _Resolved:
+            return _Resolved()
+
+    runtime = Runtime()
+    resolved_sum = report_runner.resolved_sum_validation(
+        runtime,
+        points,
+        cell=cell,
+        selector_contract=contract,
+    )
+    measurement = {
+        "matrix_element": 1.0,
+        "selector_contract": raw_selector,
+        "validation": {
+            "resolved_sum": resolved_sum,
+            LC_COMMON_COMPONENT_FIELD: {
+                "abi": LC_COMMON_COMPONENT_ABI,
+                "cell_id": cell.cell_id,
+                "value": 1.0,
+                "point_digest": contract.point_digest,
+                "helicity_ids": list(contract.all_flow_helicity_ids),
+                "color_flow_ids": list(contract.selected_color_flow_ids),
+            },
+        },
+        "provenance": {"runtime_identity": {"loaded_execution_mode": "on-the-fly"}},
+    }
+    reference = final_audit_module._ArtifactReference(
+        cell=cell,
+        measurement=measurement,
+        path=tmp_path,
+        process_id="d_dbar_to_z",
+    )
+    evidence = ArtifactEvidence(
+        artifact_id=_ARTIFACT_ID,
+        process_id="d_dbar_to_z",
+        producer_version="test",
+        producer_git_revision=_REVISION,
+        producer_native_build_inputs_sha256="e" * 64,
+        runtime_version="test",
+        runtime_capabilities=(),
+        execution_manifest_path="execution.json",
+        execution_manifest_sha256="1" * 64,
+        execution_mode="on-the-fly",
+        arena_record_count=1,
+        direct_leaf_count=0,
+        effective_config={},
+        source_jit_identity=None,
+    )
+
+    replay = final_audit_module._replay_cell(runtime, reference, evidence)
+
+    assert replay.matrix_element == 1.0
+    assert replay.resolved_maximum_absolute == 0.0
+    assert replay.resolved_maximum_relative == 0.0
+    assert runtime.dense_physics_access_count == 0
+    assert runtime._backend.context_requests == [(), ()]
+    assert runtime._backend.selector_requests == [
+        ("color_flow_by_point", ("flow:2,1",)),
+        ("helicity_by_point", ("h:-1,+1,-1",)),
+    ]
+
+
+def _source_provenance() -> dict[str, object]:
+    tree = "c" * 40
+    return {
+        "report_source_identity_schema": "pyamplicol-report-source-v1",
+        "report_source_revision": _REVISION,
+        "report_source_tree": tree,
+        "report_measured_source_revision": _REVISION,
+        "report_measured_source_tree": tree,
+        "report_source_clean": True,
+    }
+
+
+def _baseline_measurement(
+    cell_id: str = "reference-amplicol-lc-n1-dd-z-selected-flow",
+) -> dict[str, object]:
+    result = empty_measurement()
+    result.update(
+        {
+            "status": "ok",
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 1.0e-6,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 1.0e-9,
+            "relative_standard_error": 1.0e-3,
+            "artifact": {"path": "/legacy", "process_row": "row"},
+            "selector_contract": _selector(),
+            "validation": {
+                "status": "ok",
+                "method": "independent-original-amplicol-oracle",
+                "point_digest": _selector()["point_digest"],
+                DIRECT_AGREEMENT_FIELD: [],
+                LC_COMMON_COMPONENT_FIELD: _lc_common_component(cell_id),
+            },
+            "resources": {"available": True},
+            "provenance": {
+                **_source_provenance(),
+                "revision": _LEGACY_REVISION,
+                "runtime_profile": {
+                    "measurement": {
+                        "target_runtime_seconds": 5.0,
+                        "achieved_runtime_seconds": 5.0,
+                        "target_runtime_achieved": True,
+                        "chunk_count": 5,
+                        "interrupted": False,
+                    }
+                },
+            },
+            "failure": None,
+        }
+    )
+    return result
+
+
+def _bytecode_policy() -> dict[str, object]:
+    return {
+        "kind": "pyamplicol-source-only-bytecode-policy-v1",
+        "dont_write_bytecode": True,
+        "external_pycache_prefix": True,
+        "external_pycache_prefix_absent": True,
+        "package_local_bytecode_eligible": False,
+        "isolated_startup": True,
+        "site_initialization": False,
+        "python_environment_ignored_at_startup": True,
+    }
+
+
+def _loaded_origin_policy() -> dict[str, object]:
+    observations = [
+        {
+            "module": "pyamplicol",
+            "kind": "package-member",
+            "root_index": 0,
+            "path": "__init__.py",
+            "size": 1,
+            "sha256": "1" * 64,
+        }
+    ]
+    return {
+        "kind": "pyamplicol-loaded-module-origin-policy-v1",
+        "all_loaded_origins_authenticated": True,
+        "native_image_origin_bound": True,
+        "loaded_bytecode_eligible": False,
+        "observed_module_count": len(observations),
+        "observations": observations,
+        "observations_sha256": digest_json(observations),
+    }
+
+
+def _runtime_identity_provenance(
+    identity: Mapping[str, object],
+    *,
+    postflight_policy: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    stable_identity = deepcopy(dict(identity))
+    stable_policy = stable_identity.get("loaded_module_origin_policy")
+    assert isinstance(stable_policy, dict)
+    for field in (
+        "observed_module_count",
+        "observations",
+        "observations_sha256",
+    ):
+        stable_policy.pop(field)
+    stable_digest = digest_json(stable_identity)
+    return {
+        "runtime_identity": dict(identity),
+        "runtime_identity_sha256": digest_json(identity),
+        "runtime_identity_stable_sha256": stable_digest,
+        "runtime_identity_postflight_stable_sha256": stable_digest,
+        "runtime_identity_postflight_loaded_module_origin_policy": deepcopy(
+            identity["loaded_module_origin_policy"]
+            if postflight_policy is None
+            else postflight_policy
+        ),
+        "runtime_identity_postflight_match": True,
+    }
+
+
+def _active_runtime() -> dict[str, object]:
+    candidate = {
+        "schema_version": 1,
+        "version": "0.1.0.dev0+candidate.test",
+        "candidate_fingerprint": "test",
+        "source_revision": _REVISION,
+        "source_checkout": "/repo",
+        "native_build_inputs_sha256": "e" * 64,
+        "publishable": False,
+    }
+    return {
+        "package_version": candidate["version"],
+        "python_package_tree": {
+            "kind": "pyamplicol-python-package-tree-v2",
+            "root": "/runtime/pyamplicol",
+            "roots": [
+                "/runtime/pyamplicol",
+                "/candidate/site-packages/pyamplicol",
+            ],
+            "file_count": 10,
+            "total_bytes": 1000,
+            "sha256": "9" * 64,
+            "member_set_stable": True,
+            "namespace_bound_to_root_fd": True,
+            "bytecode_policy": _bytecode_policy(),
+        },
+        "loaded_module_origin_policy": _loaded_origin_policy(),
+        "candidate_build_identity": candidate,
+        "candidate_build_identity_sha256": digest_json(candidate),
+        "native_build_inputs_sha256": "e" * 64,
+        "native_extension": {
+            "path": "/runtime/_rusticol.so",
+            "sha256": "f" * 64,
+            "package_version": candidate["version"],
+        },
+        "native_target": {
+            "triple": "aarch64-apple-darwin",
+            "cpu_features": [],
+        },
+    }
+
+
+def _candidate_measurement(artifact: Path) -> dict[str, object]:
+    active = _active_runtime()
+    capabilities = [_COLOR_CAPABILITY, _CAPABILITY]
+    identity = {
+        "kind": "pyamplicol-report-runtime-identity-v1",
+        "artifact_id": _ARTIFACT_ID,
+        "loaded_artifact_id": _ARTIFACT_ID,
+        "artifact_identity_match": True,
+        "process_id": "d_dbar_to_z",
+        "execution_mode": "recurrence",
+        "loaded_execution_mode": "recurrence",
+        "backend": "jit",
+        "required_arena_capability": _CAPABILITY,
+        "expected_evaluator_abi": "pyamplicol-recurrence-runtime-layout-v2",
+        "expected_source_evaluator_abi": ("pyamplicol-symjit-plane-application-v2"),
+        "expected_source_evaluator_runtime_capability": (
+            "symjit.application.complex-f64.v1"
+        ),
+        "source_jit_optimization_level": 2,
+        "source_jit_identity": {
+            "kind": "authenticated-recurrence-direct-template-source-v1",
+            "optimization_level": 2,
+            "direct_template_count": 4,
+            "prepared_direct_template_count": 3,
+            "source_evaluator_leaf_count": 5,
+            "source_application_abi": ("pyamplicol-symjit-plane-application-v2"),
+            "direct_application_abi": "pyamplicol-symjit-plane-application-v2",
+            "prepared_kernel_pack_digest": "7" * 64,
+            "direct_template_catalog_digest": "8" * 64,
+            "execution_manifest_path": "processes/d_dbar_to_z/execution.json",
+            "execution_manifest_sha256": "1" * 64,
+            "kernel_pack_path": "model/eager-kernel-pack.json",
+            "kernel_pack_sha256": "2" * 64,
+        },
+        "process_required_runtime_capabilities": capabilities,
+        "package_version": active["package_version"],
+        "python_package_tree": active["python_package_tree"],
+        "loaded_module_origin_policy": active["loaded_module_origin_policy"],
+        "artifact_runtime_version": active["package_version"],
+        "source_revision": _REVISION,
+        "candidate_build_identity": active["candidate_build_identity"],
+        "candidate_build_identity_sha256": active["candidate_build_identity_sha256"],
+        "native_build_inputs_sha256": active["native_build_inputs_sha256"],
+        "native_extension": active["native_extension"],
+        "native_target": active["native_target"],
+    }
+    result = empty_measurement()
+    result.update(
+        {
+            "status": "ok",
+            "generation_seconds": 2.0,
+            "wall_seconds_per_point": 2.0e-6,
+            "execution_seconds_per_point": 1.5e-6,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 1.0e-8,
+            "relative_standard_error": 0.01,
+            "artifact": {
+                "path": str(artifact),
+                "process_id": "d_dbar_to_z",
+                "policy": "generated",
+            },
+            "selector_contract": _selector(),
+            "validation": {
+                "status": "ok",
+                DIRECT_AGREEMENT_FIELD: [],
+                LC_COMMON_COMPONENT_FIELD: _lc_common_component(
+                    "matrix-recurrence-test-n1-dd-z-selected-flow"
+                ),
+                "resolved_sum": {
+                    "status": "ok",
+                    "maximum_absolute_difference": 0.0,
+                    "maximum_relative_difference": 0.0,
+                    "relative_tolerance": 1.0e-12,
+                    "absolute_tolerance": 1.0e-15,
+                },
+                "pointwise": {
+                    "status": "ok",
+                    "candidate": 1.0,
+                    "baseline": 1.0,
+                    "absolute_difference": 0.0,
+                    "relative_difference": 0.0,
+                    "relative_tolerance": 1.0e-8,
+                    "absolute_tolerance": 1.0e-15,
+                },
+            },
+            "resources": {"available": True},
+            "provenance": {
+                **_source_provenance(),
+                "source_revision": _REVISION,
+                "runtime_profile": {
+                    "target_runtime_seconds": 5.0,
+                    "achieved_runtime_seconds": 5.0,
+                    "target_runtime_achieved": True,
+                    "completed_sample_count": 5,
+                    "planned_sample_count": 5,
+                    "repetitions_per_sample": 128,
+                    "measured_point_count": 640,
+                    "interrupted": False,
+                },
+                "effective_config": {
+                    "evaluator": {
+                        "execution_mode": "recurrence",
+                        "backend": "jit",
+                        "jit": {"optimization_level": 2},
+                    },
+                    "color": {
+                        "accuracy": "lc",
+                        "lc_flow_layout": "topology-replay",
+                    },
+                    "generation": {
+                        "validation": {
+                            "enabled": True,
+                            "samples": 10,
+                            "seed": 12345,
+                            "relative_tolerance": 1.0e-12,
+                            "absolute_tolerance": 1.0e-300,
+                            "post_build_validation": True,
+                        }
+                    },
+                },
+                **_runtime_identity_provenance(identity),
+            },
+            "failure": None,
+        }
+    )
+    return result
+
+
+def test_final_audit_authenticates_madgraph_reference_without_pyamplicol_replay(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cell = REPORT_CATALOG.cell("reference-madgraph-full-n1-dd-z-jets-contracted")
+    points = (((100.0, 0.0, 0.0, 100.0), (100.0, 0.0, 0.0, -100.0)),)
+    monkeypatch.setattr(
+        final_audit_module,
+        "shared_validation_points",
+        lambda _process: points,
+    )
+    command_card = madgraph_command_card(cell.process)
+    parameter_record = {
+        "external_parameter_count": 26,
+        "external_parameters_sha256": "1" * 64,
+        "binary64_exact_match": True,
+        "format": "%.14e",
+    }
+    command = {
+        "args": ["driver"],
+        "cwd": "/tmp",
+        "elapsed_seconds": 0.1,
+        "returncode": 0,
+    }
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": "ok",
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 1.0e-6,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 1.0e-9,
+            "relative_standard_error": 1.0e-3,
+            "artifact": {"path": "/tmp/madgraph"},
+            "selector_contract": None,
+            "validation": {
+                "status": "ok",
+                "method": "independent-madgraph-tree-level-oracle",
+                "point_digest": report_runner.point_digest(points),
+                DIRECT_AGREEMENT_FIELD: [],
+            },
+            "resources": {"available": True},
+            "provenance": {
+                **_source_provenance(),
+                "method": "madgraph-standalone-custom-fortran-driver",
+                "command_card": command_card,
+                "command_card_sha256": hashlib.sha256(
+                    command_card.encode("utf-8")
+                ).hexdigest(),
+                "generation_timing_scope": ("generate-output-standalone-launch-force"),
+                "generation_includes_madgraph_compilation": True,
+                "driver_compilation_in_generation_seconds": False,
+                "driver_warmup_calls": 20,
+                "profile_chunk_count": 5,
+                "model": {
+                    "name": "sm",
+                    "source_directory": "/tmp/MG/models/sm",
+                    "source_sha256": "2" * 64,
+                },
+                "default_restriction": parameter_record,
+                "exact_param_card": parameter_record,
+                "commands": [command] * 7,
+            },
+            "failure": None,
+        }
+    )
+
+    assert (
+        _audit_measurement(
+            cell,
+            measurement,
+            baseline=None,
+            expected_source_revision=_REVISION,
+            expected_legacy_revision=_LEGACY_REVISION,
+            active_runtime=None,
+        )
+        is None
+    )
+
+    bad = deepcopy(measurement)
+    bad["provenance"]["command_card"] = "generate d d~ > z\n"  # type: ignore[index]
+    with pytest.raises(FinalAuditError, match="generation command"):
+        _audit_measurement(
+            cell,
+            bad,
+            baseline=None,
+            expected_source_revision=_REVISION,
+            expected_legacy_revision=_LEGACY_REVISION,
+            active_runtime=None,
+        )
+
+
+def test_class_c_runtime_projection_authenticates_relinked_endpoint(
+    tmp_path: Path,
+) -> None:
+    active = _active_runtime()
+    measurement = _candidate_measurement(tmp_path)
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    identity = deepcopy(provenance["runtime_identity"])
+    assert isinstance(identity, dict)
+    ancestor_revision = "b" * 40
+    candidate = identity["candidate_build_identity"]
+    package_tree = identity["python_package_tree"]
+    native_extension = identity["native_extension"]
+    assert isinstance(candidate, dict)
+    assert isinstance(package_tree, dict)
+    assert isinstance(native_extension, dict)
+    candidate["source_revision"] = ancestor_revision
+    candidate["source_checkout"] = "/ancestor/repo"
+    identity["source_revision"] = ancestor_revision
+    identity["candidate_build_identity_sha256"] = digest_json(candidate)
+    package_tree["root"] = "/ancestor/runtime/pyamplicol"
+    package_tree["roots"] = [
+        "/ancestor/runtime/pyamplicol",
+        "/ancestor/site-packages/pyamplicol",
+    ]
+    package_tree["sha256"] = "8" * 64
+    native_extension["path"] = "/ancestor/runtime/_rusticol.so"
+    native_extension["sha256"] = "7" * 64
+    ancestor_environment = {
+        "python_package_tree_sha256": package_tree["sha256"],
+        "pyamplicol": identity["package_version"],
+        "candidate_fingerprint": candidate["candidate_fingerprint"],
+        "native_build_inputs_sha256": identity["native_build_inputs_sha256"],
+        "native_extension_sha256": native_extension["sha256"],
+        "native_target": identity["native_target"]["triple"],
+        "native_cpu_features": "baseline",
+    }
+    lineage = SimpleNamespace(
+        ancestor_revision=ancestor_revision,
+        descendant_revision=_REVISION,
+        environment_for_source=lambda revision: (
+            ancestor_environment if revision == ancestor_revision else None
+        ),
+    )
+    retained_provenance = _runtime_identity_provenance(identity)
+
+    projected = _runtime_for_measurement_source(
+        active,
+        retained_provenance,
+        source_revision=ancestor_revision,
+        measurement_lineage=lineage,
+    )
+
+    assert projected["native_extension"] == native_extension
+    assert projected["native_extension"] != active["native_extension"]
+    _audit_runtime_identity(
+        _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        retained_provenance,
+        expected_source_revision=ancestor_revision,
+        active_runtime=projected,
+        artifact=None,
+    )
+
+    tampered_environment = dict(ancestor_environment)
+    tampered_environment["native_extension_sha256"] = "6" * 64
+    tampered_lineage = SimpleNamespace(
+        ancestor_revision=ancestor_revision,
+        descendant_revision=_REVISION,
+        environment_for_source=lambda revision: (
+            tampered_environment if revision == ancestor_revision else None
+        ),
+    )
+    with pytest.raises(
+        FinalAuditError,
+        match="retained ancestor runtime identity differs",
+    ):
+        _runtime_for_measurement_source(
+            active,
+            retained_provenance,
+            source_revision=ancestor_revision,
+            measurement_lineage=tampered_lineage,
+        )
+
+
+def test_class_c_runtime_projection_allows_only_pinned_summary_native_transition(
+    tmp_path: Path,
+) -> None:
+    ancestor_revision = "be11d8304fdc04893dc0e23e9619be848126e3bc"
+    descendant_revision = "2594d8b520b802f71d60bd646f73ebaa5547927a"
+    ancestor_digest = "23b9637d5d3fba0947d78cf688df18799b0c9ee5b3bcbfa6a2963a1f1a21f870"
+    descendant_digest = (
+        "96e1ff79a007aaf67a0900dd6d67327ee00f6bd2cca002589b879aa3a734de08"
+    )
+    active = _active_runtime()
+    active["native_build_inputs_sha256"] = descendant_digest
+    measurement = _candidate_measurement(tmp_path)
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    identity = deepcopy(provenance["runtime_identity"])
+    assert isinstance(identity, dict)
+    candidate = identity["candidate_build_identity"]
+    package_tree = identity["python_package_tree"]
+    native_extension = identity["native_extension"]
+    assert isinstance(candidate, dict)
+    assert isinstance(package_tree, dict)
+    assert isinstance(native_extension, dict)
+    candidate["source_revision"] = ancestor_revision
+    candidate["source_checkout"] = "/ancestor/repo"
+    candidate["native_build_inputs_sha256"] = ancestor_digest
+    identity["source_revision"] = ancestor_revision
+    identity["native_build_inputs_sha256"] = ancestor_digest
+    identity["candidate_build_identity_sha256"] = digest_json(candidate)
+    package_tree["sha256"] = "8" * 64
+    native_extension["sha256"] = "7" * 64
+    ancestor_environment = {
+        "python_package_tree_sha256": package_tree["sha256"],
+        "pyamplicol": identity["package_version"],
+        "candidate_fingerprint": candidate["candidate_fingerprint"],
+        "native_build_inputs_sha256": ancestor_digest,
+        "native_extension_sha256": native_extension["sha256"],
+        "native_target": identity["native_target"]["triple"],
+        "native_cpu_features": "baseline",
+    }
+    lineage = SimpleNamespace(
+        impact=CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+        ancestor_revision=ancestor_revision,
+        descendant_revision=descendant_revision,
+        environment_for_source=lambda revision: (
+            ancestor_environment if revision == ancestor_revision else None
+        ),
+    )
+    retained_provenance = _runtime_identity_provenance(identity)
+
+    projected = _runtime_for_measurement_source(
+        active,
+        retained_provenance,
+        source_revision=ancestor_revision,
+        measurement_lineage=lineage,
+    )
+    assert projected["native_build_inputs_sha256"] == ancestor_digest
+    assert projected["candidate_build_identity"] == candidate
+    _audit_runtime_identity(
+        _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        retained_provenance,
+        expected_source_revision=ancestor_revision,
+        active_runtime=projected,
+        artifact=None,
+    )
+
+    changed_active = dict(active)
+    changed_active["native_build_inputs_sha256"] = "0" * 64
+    with pytest.raises(
+        FinalAuditError,
+        match="Class-C invariant native identity",
+    ):
+        _runtime_for_measurement_source(
+            changed_active,
+            retained_provenance,
+            source_revision=ancestor_revision,
+            measurement_lineage=lineage,
+        )
+
+
+def test_portable_artifact_locator_resolves_only_within_profile_root(
+    tmp_path: Path,
+) -> None:
+    paths = ReportPaths.from_repo(
+        tmp_path,
+        artifact_root=tmp_path / "profile-artifacts",
+    )
+    artifact = paths.artifact_root / "cells/example/artifact"
+    artifact.mkdir(parents=True)
+    measurement = {
+        "artifact": {
+            "path": ("${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/cells/example/artifact"),
+            "process_id": "d_dbar_to_z",
+        }
+    }
+
+    reference = _artifact_reference(
+        _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        measurement,
+        report_paths=paths,
+    )
+
+    assert reference.path == artifact
+    escaped = deepcopy(measurement)
+    escaped["artifact"]["path"] = (  # type: ignore[index]
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/../outside"
+    )
+    with pytest.raises(FinalAuditError, match="not canonical"):
+        _artifact_reference(
+            _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+            escaped,
+            report_paths=paths,
+        )
+
+
+def _otf_warmup_runtime_state(*, retained: bool) -> dict[str, object]:
+    counts = {field: 0 for field in report_runner.OTF_RUNTIME_STATE_COUNT_FIELDS}
+    active: dict[str, object] | None = None
+    if retained:
+        counts.update(
+            {
+                field: 1
+                for field in (
+                    *report_runner.OTF_RUNTIME_STATE_RETAINED_BASE_POSITIVE_FIELDS,
+                    *report_runner.OTF_RUNTIME_STATE_RETAINED_EXECUTABLE_FIELDS,
+                )
+            }
+        )
+        active = {
+            "basis": "shared-query-family-union-v1",
+            "scope": "active-family-union",
+            **{field: 1 for field in report_runner.OTF_ACTIVE_FAMILY_COUNT_FIELDS},
+        }
+    return {
+        "kind": report_runner.OTF_RUNTIME_STATE_CENSUS_KIND,
+        "process_id": "otf_warmup_process",
+        "family_cache_policy": report_runner.OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY,
+        "family_cache_limit": report_runner.OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT,
+        **counts,
+        "active_family_union_census": active,
+    }
+
+
+def _otf_warmup_profile() -> dict[str, object]:
+    return {
+        "cold_warmup_elapsed_seconds": 4.767252833,
+        "cold_warmup_run_count": 1,
+        "cold_warmup_batch_size": 128,
+        "cold_warmup_point_count": 128,
+        "cold_warmup_timer_source": report_runner.WARMUP_TIMER_SOURCE,
+        "cold_warmup_timing_scope": report_runner.OTF_COLD_WARMUP_TIMING_SCOPE,
+        "cold_warmup_runtime_freshness": (
+            report_runner.OTF_COLD_WARMUP_RUNTIME_FRESHNESS
+        ),
+        "cold_warmup_runtime_state_evidence": (
+            report_runner.OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE
+        ),
+        "cold_warmup_runtime_state_before": _otf_warmup_runtime_state(retained=False),
+        "cold_warmup_runtime_state_after": _otf_warmup_runtime_state(retained=True),
+        "cold_warmup_runtime_cold_before_first_evaluation": True,
+        "cold_warmup_runtime_retained_before_first_evaluation": False,
+        "cold_warmup_runtime_retained_after_first_evaluation": True,
+        "cold_warmup_ratio_eligible": False,
+        "cold_warmup_acceptance_eligible": False,
+        "warmup_elapsed_seconds": 0.021,
+        "warmup_configured_run_count": 2,
+        "warmup_batch_size": 128,
+        "warmup_point_count": 256,
+        "warmup_run_outer_wall_seconds": [0.010, 0.011],
+        "first_warmup_run_outer_wall_seconds": 0.010,
+        "warmup_timer_source": report_runner.WARMUP_TIMER_SOURCE,
+        "warmup_timing_scope": report_runner.CONVENTIONAL_WARMUP_TIMING_SCOPE,
+    }
+
+
+def _otf_warmup_provenance(
+    profile: dict[str, object] | None = None,
+) -> dict[str, object]:
+    return {
+        "runtime_profile": _otf_warmup_profile() if profile is None else profile,
+        "runtime_load_included_in_cold_warmup": False,
+        "generation_timer_excludes_model_preparation": True,
+        "effective_config": {"benchmark": {"batch_size": 128, "warmup_runs": 2}},
+    }
+
+
+def test_final_audit_accepts_bounded_otf_warmup_evidence() -> None:
+    _audit_runtime_profile_warmup_evidence(
+        _cell(ExecutionMode.ON_THE_FLY, optimization_level=2),
+        _otf_warmup_provenance(),
+        context="otf.measurement",
+    )
+
+
+@pytest.mark.parametrize(
+    ("field", "replacement", "message"),
+    (
+        ("cold_warmup_run_count", 2, "exactly one run"),
+        ("cold_warmup_batch_size", 64, "full benchmark batch"),
+        (
+            "cold_warmup_runtime_freshness",
+            "fresh",
+            "authenticated runtime state",
+        ),
+        (
+            "cold_warmup_runtime_state_evidence",
+            "self-reported",
+            "state evidence is unsupported",
+        ),
+        (
+            "cold_warmup_runtime_cold_before_first_evaluation",
+            False,
+            "booleans do not match",
+        ),
+        ("cold_warmup_acceptance_eligible", True, "ineligible"),
+        ("warmup_configured_run_count", 1, "effective benchmark configuration"),
+    ),
+)
+def test_final_audit_rejects_invalid_otf_warmup_evidence(
+    field: str,
+    replacement: object,
+    message: str,
+) -> None:
+    profile = _otf_warmup_profile()
+    profile[field] = replacement
+
+    with pytest.raises(FinalAuditError, match=message):
+        _audit_runtime_profile_warmup_evidence(
+            _cell(ExecutionMode.ON_THE_FLY, optimization_level=2),
+            _otf_warmup_provenance(profile),
+            context="otf.measurement",
+        )
+
+
+def test_final_audit_rejects_missing_conventional_warmup_evidence() -> None:
+    profile = _otf_warmup_profile()
+    del profile["warmup_run_outer_wall_seconds"]
+
+    with pytest.raises(FinalAuditError, match="incomplete conventional warm-up"):
+        _audit_runtime_profile_warmup_evidence(
+            _cell(ExecutionMode.ON_THE_FLY, optimization_level=2),
+            _otf_warmup_provenance(profile),
+            context="otf.measurement",
+        )
+
+
+@pytest.mark.parametrize(
+    ("field", "invalid", "message"),
+    (
+        ("runtime_load_included_in_cold_warmup", True, "must be false"),
+        (
+            "generation_timer_excludes_model_preparation",
+            False,
+            "must be true",
+        ),
+    ),
+)
+def test_final_audit_rejects_contradictory_otf_phase_scope_flags(
+    field: str,
+    invalid: bool,
+    message: str,
+) -> None:
+    provenance = _otf_warmup_provenance()
+    provenance[field] = invalid
+
+    with pytest.raises(FinalAuditError, match=message):
+        _audit_runtime_profile_warmup_evidence(
+            _cell(ExecutionMode.ON_THE_FLY, optimization_level=2),
+            provenance,
+            context="otf.measurement",
+        )
+
+
+def test_final_audit_binds_otf_warmups_to_effective_benchmark_config() -> None:
+    coordinated_batch = _otf_warmup_profile()
+    coordinated_batch["cold_warmup_batch_size"] = 64
+    coordinated_batch["cold_warmup_point_count"] = 64
+    coordinated_batch["warmup_batch_size"] = 64
+    coordinated_batch["warmup_point_count"] = 128
+    with pytest.raises(FinalAuditError, match="effective benchmark configuration"):
+        _audit_runtime_profile_warmup_evidence(
+            _cell(ExecutionMode.ON_THE_FLY, optimization_level=2),
+            _otf_warmup_provenance(coordinated_batch),
+            context="otf.measurement",
+        )
+
+    coordinated_runs = _otf_warmup_profile()
+    coordinated_runs["warmup_configured_run_count"] = 1
+    coordinated_runs["warmup_point_count"] = 128
+    coordinated_runs["warmup_run_outer_wall_seconds"] = [0.010]
+    coordinated_runs["first_warmup_run_outer_wall_seconds"] = 0.010
+    coordinated_runs["warmup_elapsed_seconds"] = 0.010
+    with pytest.raises(FinalAuditError, match="effective benchmark configuration"):
+        _audit_runtime_profile_warmup_evidence(
+            _cell(ExecutionMode.ON_THE_FLY, optimization_level=2),
+            _otf_warmup_provenance(coordinated_runs),
+            context="otf.measurement",
+        )
+
+
+def test_final_audit_rejects_coordinated_nonpublication_otf_benchmark() -> None:
+    coordinated_batch = _otf_warmup_profile()
+    coordinated_batch["cold_warmup_batch_size"] = 64
+    coordinated_batch["cold_warmup_point_count"] = 64
+    coordinated_batch["warmup_batch_size"] = 64
+    coordinated_batch["warmup_point_count"] = 128
+    batch_provenance = _otf_warmup_provenance(coordinated_batch)
+    batch_provenance["effective_config"]["benchmark"]["batch_size"] = 64
+    with pytest.raises(
+        FinalAuditError,
+        match=r"batch_size must equal the final report contract 128",
+    ):
+        _audit_runtime_profile_warmup_evidence(
+            _cell(ExecutionMode.ON_THE_FLY, optimization_level=2),
+            batch_provenance,
+            context="otf.measurement",
+        )
+
+    coordinated_runs = _otf_warmup_profile()
+    coordinated_runs["warmup_configured_run_count"] = 1
+    coordinated_runs["warmup_point_count"] = 128
+    coordinated_runs["warmup_run_outer_wall_seconds"] = [0.010]
+    coordinated_runs["first_warmup_run_outer_wall_seconds"] = 0.010
+    coordinated_runs["warmup_elapsed_seconds"] = 0.010
+    run_provenance = _otf_warmup_provenance(coordinated_runs)
+    run_provenance["effective_config"]["benchmark"]["warmup_runs"] = 1
+    with pytest.raises(
+        FinalAuditError,
+        match=r"warmup_runs must equal the final report contract 2",
+    ):
+        _audit_runtime_profile_warmup_evidence(
+            _cell(ExecutionMode.ON_THE_FLY, optimization_level=2),
+            run_provenance,
+            context="otf.measurement",
+        )
+
+
+def test_legacy_measurement_requires_pinned_revision_and_physical_point_digest() -> (
+    None
+):
+    cell = _legacy_cell()
+    measurement = _baseline_measurement()
+    assert (
+        _audit_measurement(
+            cell,
+            measurement,
+            baseline=None,
+            expected_source_revision=_REVISION,
+            expected_legacy_revision=_LEGACY_REVISION,
+            active_runtime=None,
+        )
+        is None
+    )
+
+    wrong_revision = deepcopy(measurement)
+    wrong_revision["provenance"]["revision"] = "d" * 40  # type: ignore[index]
+    with pytest.raises(FinalAuditError, match="pinned original-AmpliCol revision"):
+        _audit_measurement(
+            cell,
+            wrong_revision,
+            baseline=None,
+            expected_source_revision=_REVISION,
+            expected_legacy_revision=_LEGACY_REVISION,
+            active_runtime=None,
+        )
+
+    wrong_points = deepcopy(measurement)
+    wrong_points["validation"]["point_digest"] = "0" * 64  # type: ignore[index]
+    with pytest.raises(FinalAuditError, match="physical process"):
+        _audit_measurement(
+            cell,
+            wrong_points,
+            baseline=None,
+            expected_source_revision=_REVISION,
+            expected_legacy_revision=_LEGACY_REVISION,
+            active_runtime=None,
+        )
+
+
+@pytest.mark.parametrize("execution_seconds", [0.0, -1.0, float("inf")])
+def test_candidate_measurement_requires_positive_finite_execution_time(
+    tmp_path: Path,
+    execution_seconds: float,
+) -> None:
+    measurement = _candidate_measurement(tmp_path)
+    measurement["execution_seconds_per_point"] = execution_seconds
+    with pytest.raises(
+        FinalAuditError,
+        match="execution_seconds_per_point",
+    ):
+        _audit_measurement(
+            _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+            measurement,
+            baseline=_baseline_measurement(),
+            expected_source_revision=_REVISION,
+            expected_legacy_revision=_LEGACY_REVISION,
+            active_runtime=_active_runtime(),
+        )
+
+
+def test_recurrence_without_legacy_oracle_requires_high_precision_validation(
+    tmp_path: Path,
+) -> None:
+    cell = replace(
+        _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        dataset_id="matrix_recurrence_builtin_sm_lc",
+        process="d d~ > u u~ s s~ c c~",
+        n_final=6,
+        process_key="dd_4q_lines",
+    )
+    measurement = _candidate_measurement(tmp_path)
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+    validation.pop("pointwise")
+    validation["high_precision"] = {
+        "status": "ok",
+        "candidate": 1.0,
+        "baseline": 1.0,
+        "absolute_difference": 0.0,
+        "relative_difference": 0.0,
+        "relative_tolerance": 1.0e-12,
+        "absolute_tolerance": 1.0e-15,
+    }
+
+    reference = _audit_measurement(
+        cell,
+        measurement,
+        baseline=None,
+        expected_source_revision=_REVISION,
+        expected_legacy_revision=_LEGACY_REVISION,
+        active_runtime=_active_runtime(),
+    )
+
+    assert reference is not None
+    assert reference.cell == cell
+
+    validation.pop("high_precision")
+    with pytest.raises(FinalAuditError, match="high_precision"):
+        _audit_measurement(
+            cell,
+            measurement,
+            baseline=None,
+            expected_source_revision=_REVISION,
+            expected_legacy_revision=_LEGACY_REVISION,
+            active_runtime=_active_runtime(),
+        )
+
+
+@pytest.mark.parametrize(
+    "baseline_state",
+    tuple(
+        state
+        for state in PolicyMeasurementState
+        if state is not PolicyMeasurementState.SUCCESS
+    ),
+)
+def test_final_audit_omits_only_non_successful_optional_legacy_baseline(
+    tmp_path: Path,
+    baseline_state: PolicyMeasurementState,
+) -> None:
+    baseline = _legacy_cell()
+    candidate = replace(
+        _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        dataset_id="matrix_recurrence_builtin_sm_lc",
+    )
+    catalog = _Catalog(baseline, candidate)
+    baseline_measurement = _baseline_measurement()
+    candidate_measurement = _candidate_measurement(tmp_path)
+
+    assert (
+        _validation_baseline_for_audit(
+            candidate,
+            {
+                baseline.cell_id: baseline_measurement,
+                candidate.cell_id: candidate_measurement,
+            },
+            {baseline.cell_id: baseline_state},
+            catalog=catalog,  # type: ignore[arg-type]
+        )
+        is None
+    )
+    assert (
+        _validation_baseline_for_audit(
+            candidate,
+            {candidate.cell_id: candidate_measurement},
+            {},
+            catalog=catalog,  # type: ignore[arg-type]
+        )
+        is None
+    )
+
+
+def test_final_audit_never_promotes_successful_optional_legacy_baseline(
+    tmp_path: Path,
+) -> None:
+    baseline = _legacy_cell()
+    candidate = replace(
+        _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        dataset_id="matrix_recurrence_builtin_sm_lc",
+    )
+    catalog = _Catalog(baseline, candidate)
+    baseline_measurement = _baseline_measurement()
+    candidate_measurement = _candidate_measurement(tmp_path)
+
+    assert (
+        _validation_baseline_for_audit(
+            candidate,
+            {
+                baseline.cell_id: baseline_measurement,
+                candidate.cell_id: candidate_measurement,
+            },
+            {baseline.cell_id: PolicyMeasurementState.SUCCESS},
+            catalog=catalog,  # type: ignore[arg-type]
+        )
+        is None
+    )
+    assert (
+        _validation_baseline_for_audit(
+            candidate,
+            {candidate.cell_id: candidate_measurement},
+            {baseline.cell_id: PolicyMeasurementState.SUCCESS},
+            catalog=catalog,  # type: ignore[arg-type]
+        )
+        is None
+    )
+
+
+def test_optional_legacy_endpoint_requires_high_precision_authority_route(
+    tmp_path: Path,
+) -> None:
+    baseline = _legacy_cell()
+    candidate = replace(
+        _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        dataset_id="matrix_recurrence_builtin_sm_lc",
+    )
+    catalog = _Catalog(baseline, candidate)
+    baseline_measurement = _baseline_measurement()
+    pointwise_measurement = _candidate_measurement(tmp_path)
+
+    assert (
+        _validation_baseline_for_audit(
+            candidate,
+            {
+                baseline.cell_id: baseline_measurement,
+                candidate.cell_id: pointwise_measurement,
+            },
+            {baseline.cell_id: PolicyMeasurementState.GENERATION_LIMIT},
+            catalog=catalog,  # type: ignore[arg-type]
+        )
+        is None
+    )
+    with pytest.raises(FinalAuditError, match="high_precision"):
+        _audit_measurement(
+            candidate,
+            pointwise_measurement,
+            baseline=None,
+            expected_source_revision=_REVISION,
+            expected_legacy_revision=_LEGACY_REVISION,
+            active_runtime=_active_runtime(),
+        )
+    high_precision_measurement = deepcopy(pointwise_measurement)
+    validation = high_precision_measurement["validation"]
+    assert isinstance(validation, dict)
+    pointwise = validation.pop("pointwise")
+    assert isinstance(pointwise, dict)
+    pointwise["relative_tolerance"] = final_audit_module.RELATIVE_TOLERANCE
+    validation["high_precision"] = pointwise
+    assert (
+        _validation_baseline_for_audit(
+            candidate,
+            {
+                baseline.cell_id: baseline_measurement,
+                candidate.cell_id: high_precision_measurement,
+            },
+            {baseline.cell_id: PolicyMeasurementState.SUCCESS},
+            catalog=catalog,  # type: ignore[arg-type]
+        )
+        is None
+    )
+    assert (
+        _audit_measurement(
+            candidate,
+            high_precision_measurement,
+            baseline=None,
+            expected_source_revision=_REVISION,
+            expected_legacy_revision=_LEGACY_REVISION,
+            active_runtime=_active_runtime(),
+        )
+        is not None
+    )
+    assert (
+        _legacy_consumer_coverage(
+            (baseline, candidate),
+            {
+                baseline.cell_id: baseline_measurement,
+                candidate.cell_id: high_precision_measurement,
+            },
+            {
+                baseline.cell_id: PolicyMeasurementState.SUCCESS,
+                candidate.cell_id: PolicyMeasurementState.SUCCESS,
+            },
+            catalog=catalog,  # type: ignore[arg-type]
+        )
+        == ()
+    )
+
+
+def test_stored_optional_legacy_agreement_survives_missing_current_endpoint(
+    tmp_path: Path,
+) -> None:
+    legacy_selected = _legacy_cell()
+    baseline = replace(legacy_selected, workload=Workload.ALL_FLOW)
+    candidate = replace(
+        _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        dataset_id="matrix_recurrence_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+    selected = replace(candidate, workload=Workload.SELECTED_FLOW)
+
+    class DirectCatalog(_Catalog):
+        def measurement_cells(self) -> tuple[CellSpec, ...]:
+            return (legacy_selected, self.baseline, selected, self.candidate)
+
+    catalog = DirectCatalog(baseline, candidate)
+    baseline_measurement = _baseline_measurement(baseline.cell_id)
+    selected_measurement = _candidate_measurement(tmp_path / "selected")
+    selected_validation = selected_measurement["validation"]
+    assert isinstance(selected_validation, dict)
+    selected_validation[LC_COMMON_COMPONENT_FIELD] = _lc_common_component(
+        selected.cell_id
+    )
+    candidate_measurement = _candidate_measurement(tmp_path)
+    validation = candidate_measurement["validation"]
+    assert isinstance(validation, dict)
+    validation[LC_COMMON_COMPONENT_FIELD] = _lc_common_component(candidate.cell_id)
+    attach_direct_agreements(
+        candidate,
+        candidate_measurement,
+        {
+            baseline.cell_id: baseline_measurement,
+            selected.cell_id: selected_measurement,
+        },
+        catalog=catalog,  # type: ignore[arg-type]
+    )
+
+    edges, counts = _audit_direct_agreements(
+        (selected, candidate),
+        {
+            selected.cell_id: selected_measurement,
+            candidate.cell_id: candidate_measurement,
+        },
+        catalog=catalog,  # type: ignore[arg-type]
+    )
+
+    assert len(edges) == 2
+    assert counts[LC_LEGACY_PYAMPLICOL_COMPONENT] == 1
+    replay_counts = _audit_replayed_direct_agreements(
+        edges,
+        {
+            selected.cell_id: selected_measurement,
+            candidate.cell_id: candidate_measurement,
+        },
+        {
+            selected.cell_id: final_audit_module._ReplayObservation(
+                matrix_element=1.0,
+                resolved_maximum_absolute=0.0,
+                resolved_maximum_relative=0.0,
+                lc_common_component=1.0,
+            ),
+            candidate.cell_id: final_audit_module._ReplayObservation(
+                matrix_element=1.0,
+                resolved_maximum_absolute=0.0,
+                resolved_maximum_relative=0.0,
+                lc_common_component=1.0,
+            ),
+        },
+    )
+    assert (
+        replay_counts[final_audit_module._REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY] == 1
+    )
+
+
+@pytest.mark.parametrize(
+    "execution_mode",
+    (ExecutionMode.COMPILED, ExecutionMode.EAGER),
+)
+def test_final_audit_treats_terminal_recurrence_authority_as_unavailable(
+    tmp_path: Path,
+    execution_mode: ExecutionMode,
+) -> None:
+    recurrence = _cell(ExecutionMode.RECURRENCE, optimization_level=2)
+    candidate = _cell(execution_mode, optimization_level=2)
+    catalog = _Catalog(recurrence, candidate)
+    candidate_measurement = _candidate_measurement(tmp_path)
+
+    with pytest.raises(
+        FinalAuditError,
+        match="no successful authenticated numerical authority",
+    ):
+        _validation_baseline_for_audit(
+            candidate,
+            {
+                recurrence.cell_id: {},
+                candidate.cell_id: candidate_measurement,
+            },
+            {recurrence.cell_id: PolicyMeasurementState.GENERATION_LIMIT},
+            catalog=catalog,  # type: ignore[arg-type]
+        )
+
+
+@pytest.mark.parametrize(
+    "execution_mode",
+    (ExecutionMode.COMPILED, ExecutionMode.EAGER),
+)
+def test_final_audit_consumes_durable_selected_independent_authority(
+    tmp_path: Path,
+    execution_mode: ExecutionMode,
+) -> None:
+    candidate = REPORT_CATALOG.cell(
+        f"matrix-{execution_mode.value}-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    )
+    authorities = independent_numerical_authorities(candidate)
+    (recurrence,) = authorities
+    candidate_measurement = _candidate_measurement(tmp_path / "candidate")
+    validation = candidate_measurement["validation"]
+    assert isinstance(validation, dict)
+    pointwise = validation["pointwise"]
+    assert isinstance(pointwise, dict)
+    pointwise["relative_tolerance"] = final_audit_module.RELATIVE_TOLERANCE
+    validation[INDEPENDENT_AUTHORITY_FIELD] = {
+        "abi": INDEPENDENT_AUTHORITY_ABI,
+        "expected_cell_ids": [authority.cell_id for authority in authorities],
+        "selected_cell_id": recurrence.cell_id,
+        "status": "verified",
+        "reason": "independent-authority-agreement",
+        "same_artifact_diagnostics_are_authority": False,
+    }
+    recurrence_measurement = _candidate_measurement(tmp_path / "recurrence")
+
+    assert (
+        _validation_baseline_for_audit(
+            candidate,
+            {
+                candidate.cell_id: candidate_measurement,
+                recurrence.cell_id: recurrence_measurement,
+            },
+            {
+                recurrence.cell_id: PolicyMeasurementState.SUCCESS,
+            },
+            catalog=REPORT_CATALOG,
+        )
+        is recurrence_measurement
+    )
+
+    with pytest.raises(FinalAuditError, match="selected independent authority"):
+        _validation_baseline_for_audit(
+            candidate,
+            {
+                candidate.cell_id: candidate_measurement,
+            },
+            {
+                recurrence.cell_id: PolicyMeasurementState.GENERATION_LIMIT,
+            },
+            catalog=REPORT_CATALOG,
+        )
+
+
+def _arena_profile_evidence(
+    *,
+    execution_mode: ExecutionMode = ExecutionMode.COMPILED,
+) -> dict[str, object]:
+    raw_profile = {
+        "execution_mode": execution_mode.value,
+        "profile_boundary": ARENA_PROFILE_BOUNDARY,
+        "borrowed_flat_input": True,
+        "preallocated_output": True,
+        "phase_timing_scope": ARENA_PHASE_TIMING_SCOPE,
+        "evaluator_timing_available": False,
+        "points": 128,
+        "wall_time_s": 128 * 1.1e-6,
+        "orchestration_time_s": 128 * 1.1e-6,
+        **{field: 0 for field in ZERO_ARENA_COUNTER_FIELDS},
+        **{field: 0.0 for field in ZERO_ARENA_PHASE_TIME_FIELDS},
+        **{field: [] for field in EMPTY_ARENA_PHASE_VECTOR_FIELDS},
+        **{field: 0 for field in ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS},
+    }
+    if execution_mode is ExecutionMode.COMPILED:
+        raw_profile.update(
+            {
+                "compiled_direct_arena_engine_count": 1,
+                "compiled_direct_arena_call_count": 128,
+                "evaluator_backend_call_count": 128,
+            }
+        )
+    return build_arena_profile_evidence(
+        [raw_profile] * 5,
+        execution_mode=execution_mode.value,
+        repetitions_per_profile=1,
+        batch_size=128,
+    )
+
+
+def _arena_unavailable_execution_timing(
+    *,
+    execution_mode: ExecutionMode = ExecutionMode.COMPILED,
+    arena_evidence: dict[str, object] | None = None,
+) -> dict[str, object]:
+    evidence = (
+        _arena_profile_evidence(execution_mode=execution_mode)
+        if arena_evidence is None
+        else arena_evidence
+    )
+    return {
+        "abi": "pyamplicol-report-arena-execution-timing-v2",
+        "status": "unavailable",
+        "ratio_eligible": False,
+        "raw_seconds_per_point": None,
+        "sample_count": 5,
+        "native_profile_points_per_sample": 128,
+        "repetitions_per_sample": 1,
+        "batch_size": 128,
+        "sample_contract": "paired_unprofiled_headline_profiled_attribution_v1",
+        "profile_protocol": "arena",
+        "profile_sample_pass": "runtime._profile_arena_repeated",
+        "profile_boundary": (
+            "warmed-direct-arena-borrowed-input-preallocated-output-v1"
+        ),
+        "borrowed_flat_input": True,
+        "preallocated_output": True,
+        "phase_timing_scope": "coarse-arena-boundary-only-v1",
+        "evaluator_timing_available": False,
+        "paired_with_headline": True,
+        "identical_batch": True,
+        "identical_repetitions": True,
+        "execution_mode": execution_mode.value,
+        "warmed_boundary_wall_seconds_per_point": 1.1e-6,
+        "arena_profile_evidence_sha256": digest_arena_profile_value(evidence),
+    }
+
+
+def _arena_unavailable_provenance(
+    *,
+    execution_mode: ExecutionMode = ExecutionMode.COMPILED,
+) -> dict[str, object]:
+    evidence = _arena_profile_evidence(execution_mode=execution_mode)
+    return {
+        "arena_profile_evidence": evidence,
+        "execution_timing": _arena_unavailable_execution_timing(
+            execution_mode=execution_mode,
+            arena_evidence=evidence,
+        ),
+    }
+
+
+@pytest.mark.parametrize(
+    "cell",
+    (
+        _cell(ExecutionMode.EAGER, optimization_level=2),
+        _cell(ExecutionMode.COMPILED, optimization_level=1),
+        _cell(ExecutionMode.COMPILED, backend="cpp", optimization_level=None),
+    ),
+)
+def test_final_audit_accepts_authenticated_arena_unavailable_timing(
+    cell: CellSpec,
+) -> None:
+    provenance = _arena_unavailable_provenance(
+        execution_mode=cell.measurement.execution_mode,
+    )
+    _audit_unavailable_execution_timing(
+        cell,
+        provenance,
+        measurement_sample_count=5,
+        context="candidate",
+    )
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("abi", "wrong"),
+        ("status", "measured"),
+        ("ratio_eligible", True),
+        ("raw_seconds_per_point", 0.0),
+        ("sample_count", 4),
+        ("sample_count", True),
+        ("native_profile_points_per_sample", 0),
+        ("native_profile_points_per_sample", None),
+        ("repetitions_per_sample", 2),
+        ("batch_size", 64),
+        ("sample_contract", "separate_native_profile_diagnostic_v1"),
+        ("profile_protocol", "frozen-pre-arena"),
+        ("profile_sample_pass", "runtime.profile_repeated"),
+        ("profile_boundary", "materialized-native-profile-v1"),
+        ("borrowed_flat_input", False),
+        ("preallocated_output", False),
+        ("phase_timing_scope", "profiled-evaluator-phases-v1"),
+        ("evaluator_timing_available", True),
+        ("paired_with_headline", False),
+        ("identical_batch", False),
+        ("identical_repetitions", False),
+        ("execution_mode", "eager"),
+        ("warmed_boundary_wall_seconds_per_point", 0.0),
+        ("warmed_boundary_wall_seconds_per_point", float("nan")),
+        ("arena_profile_evidence_sha256", "0" * 64),
+    ),
+)
+def test_final_audit_rejects_tampered_arena_unavailable_timing(
+    field: str,
+    value: object,
+) -> None:
+    provenance = _arena_unavailable_provenance()
+    timing = provenance["execution_timing"]
+    assert isinstance(timing, dict)
+    timing[field] = value
+    with pytest.raises(FinalAuditError, match="unavailable-attribution record"):
+        _audit_unavailable_execution_timing(
+            _cell(ExecutionMode.COMPILED, optimization_level=3),
+            provenance,
+            measurement_sample_count=5,
+            context="candidate",
+        )
+
+
+def test_final_audit_binds_arena_unavailable_shape_and_sample_count() -> None:
+    provenance = _arena_unavailable_provenance()
+    timing = provenance["execution_timing"]
+    assert isinstance(timing, dict)
+    timing["unexpected"] = True
+    with pytest.raises(FinalAuditError, match="fields do not match"):
+        _audit_unavailable_execution_timing(
+            _cell(ExecutionMode.COMPILED, optimization_level=3),
+            provenance,
+            measurement_sample_count=5,
+            context="candidate",
+        )
+
+    with pytest.raises(FinalAuditError, match="unavailable-attribution record"):
+        _audit_unavailable_execution_timing(
+            _cell(ExecutionMode.COMPILED, optimization_level=3),
+            _arena_unavailable_provenance(),
+            measurement_sample_count=6,
+            context="candidate",
+        )
+
+
+def test_runtime_identity_audit_distinguishes_source_and_direct_codegen_levels(
+    tmp_path: Path,
+) -> None:
+    measurement = _candidate_measurement(tmp_path)
+    raw_provenance = measurement["provenance"]
+    assert isinstance(raw_provenance, dict)
+    raw_identity = raw_provenance["runtime_identity"]
+    assert isinstance(raw_identity, dict)
+
+    def provenance(identity: dict[str, object]) -> dict[str, object]:
+        return _runtime_identity_provenance(identity)
+
+    recurrence = _cell(ExecutionMode.RECURRENCE, optimization_level=2)
+    _audit_runtime_identity(
+        recurrence,
+        provenance(raw_identity),
+        expected_source_revision=_REVISION,
+        active_runtime=_active_runtime(),
+        artifact=None,
+    )
+
+    missing_source = deepcopy(raw_identity)
+    del missing_source["source_jit_optimization_level"]
+    with pytest.raises(FinalAuditError, match="source_jit_optimization_level"):
+        _audit_runtime_identity(
+            recurrence,
+            provenance(missing_source),
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=None,
+        )
+
+    missing_source_identity = deepcopy(raw_identity)
+    del missing_source_identity["source_jit_identity"]
+    with pytest.raises(FinalAuditError, match="source_jit_identity"):
+        _audit_runtime_identity(
+            recurrence,
+            provenance(missing_source_identity),
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=None,
+        )
+
+    wrong_source_capability = deepcopy(raw_identity)
+    wrong_source_capability["expected_source_evaluator_runtime_capability"] = (
+        "symbolica.compiled-cpp.complex-f64.v1"
+    )
+    with pytest.raises(
+        FinalAuditError,
+        match="expected_source_evaluator_runtime_capability",
+    ):
+        _audit_runtime_identity(
+            recurrence,
+            provenance(wrong_source_capability),
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=None,
+        )
+
+    missing_loaded_mode = deepcopy(raw_identity)
+    del missing_loaded_mode["loaded_execution_mode"]
+    with pytest.raises(FinalAuditError, match="loaded_execution_mode"):
+        _audit_runtime_identity(
+            recurrence,
+            provenance(missing_loaded_mode),
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=None,
+        )
+
+    spurious_direct_codegen = deepcopy(raw_identity)
+    spurious_direct_codegen["direct_codegen_optimization_level"] = 3
+    with pytest.raises(FinalAuditError, match="direct_codegen_optimization_level"):
+        _audit_runtime_identity(
+            recurrence,
+            provenance(spurious_direct_codegen),
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=None,
+        )
+
+    compiled_identity = deepcopy(raw_identity)
+    del compiled_identity["source_jit_identity"]
+    compiled_identity.update(
+        {
+            "execution_mode": "compiled",
+            "loaded_execution_mode": "compiled",
+            "required_arena_capability": "compiled-plane-arena-v1",
+            "expected_evaluator_abi": "pyamplicol-compiled-plane-kernel-v2",
+            "expected_source_evaluator_abi": ("pyamplicol-symjit-plane-application-v2"),
+            "source_jit_optimization_level": 1,
+            "direct_codegen_optimization_level": 1,
+            "direct_codegen_identity": {
+                "kind": "authenticated-compiled-plane-arena-direct-codegen-v1",
+                "optimization_level": 1,
+                "source_optimization_level": 1,
+                "leaf_count": 2,
+                "execution_manifest_path": "execution.json",
+                "execution_manifest_sha256": "8" * 64,
+            },
+        }
+    )
+    compiled = _cell(ExecutionMode.COMPILED, optimization_level=1)
+    _audit_runtime_identity(
+        compiled,
+        provenance(compiled_identity),
+        expected_source_revision=_REVISION,
+        active_runtime=_active_runtime(),
+        artifact=None,
+    )
+    compiled_effective = {"evaluator": {"execution_mode": "compiled"}}
+    compiled_evidence = ArtifactEvidence(
+        artifact_id=_ARTIFACT_ID,
+        process_id="d_dbar_to_z",
+        producer_version=str(_active_runtime()["package_version"]),
+        producer_git_revision=_REVISION,
+        producer_native_build_inputs_sha256="e" * 64,
+        runtime_version=str(_active_runtime()["package_version"]),
+        runtime_capabilities=(_COLOR_CAPABILITY, _CAPABILITY),
+        execution_manifest_path="execution.json",
+        execution_manifest_sha256="8" * 64,
+        execution_mode="compiled",
+        arena_record_count=2,
+        direct_leaf_count=2,
+        effective_config=compiled_effective,
+        source_jit_identity=None,
+    )
+    compiled_provenance = provenance(compiled_identity)
+    compiled_provenance["effective_config"] = compiled_effective
+    _audit_runtime_identity(
+        compiled,
+        compiled_provenance,
+        expected_source_revision=_REVISION,
+        active_runtime=_active_runtime(),
+        artifact=compiled_evidence,
+    )
+
+    wrong_leaf_count = deepcopy(compiled_identity)
+    wrong_leaf_count["direct_codegen_identity"]["leaf_count"] = 3  # type: ignore[index]
+    wrong_leaf_provenance = provenance(wrong_leaf_count)
+    wrong_leaf_provenance["effective_config"] = compiled_effective
+    with pytest.raises(FinalAuditError, match=r"direct_codegen_identity\.leaf_count"):
+        _audit_runtime_identity(
+            compiled,
+            wrong_leaf_provenance,
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=compiled_evidence,
+        )
+
+    wrong_path = deepcopy(compiled_identity)
+    wrong_path["direct_codegen_identity"]["execution_manifest_path"] = (  # type: ignore[index]
+        "other.json"
+    )
+    wrong_path_provenance = provenance(wrong_path)
+    wrong_path_provenance["effective_config"] = compiled_effective
+    with pytest.raises(
+        FinalAuditError,
+        match=r"direct_codegen_identity\.execution_manifest_path",
+    ):
+        _audit_runtime_identity(
+            compiled,
+            wrong_path_provenance,
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=compiled_evidence,
+        )
+
+    wrong_effective_provenance = provenance(compiled_identity)
+    wrong_effective_provenance["effective_config"] = {
+        "evaluator": {"execution_mode": "eager"}
+    }
+    with pytest.raises(FinalAuditError, match="effective_config"):
+        _audit_runtime_identity(
+            compiled,
+            wrong_effective_provenance,
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=compiled_evidence,
+        )
+
+    missing_direct_codegen = deepcopy(compiled_identity)
+    del missing_direct_codegen["direct_codegen_optimization_level"]
+    with pytest.raises(FinalAuditError, match="direct_codegen_optimization_level"):
+        _audit_runtime_identity(
+            compiled,
+            provenance(missing_direct_codegen),
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=None,
+        )
+
+
+def test_artifact_producer_identity_uses_native_digest_for_dirty_candidate() -> None:
+    active = _active_runtime()
+    evidence = ArtifactEvidence(
+        artifact_id=_ARTIFACT_ID,
+        process_id="d_dbar_to_z",
+        producer_version=str(active["package_version"]),
+        producer_git_revision=_REVISION,
+        producer_native_build_inputs_sha256="e" * 64,
+        runtime_version=str(active["package_version"]),
+        runtime_capabilities=(),
+        execution_manifest_path="execution.json",
+        execution_manifest_sha256="1" * 64,
+        execution_mode="compiled",
+        arena_record_count=1,
+        direct_leaf_count=1,
+        effective_config={},
+        source_jit_identity=None,
+    )
+    final_audit_module._audit_artifact_producer_identity(
+        evidence,
+        expected_source_revision=_REVISION,
+        active_runtime=active,
+    )
+
+    dirty_active = deepcopy(active)
+    dirty_candidate = dirty_active["candidate_build_identity"]
+    assert isinstance(dirty_candidate, dict)
+    dirty_candidate["source_revision"] = None
+    dirty_active["candidate_build_identity_sha256"] = digest_json(dirty_candidate)
+    dirty_evidence = replace(evidence, producer_git_revision=None)
+    final_audit_module._audit_artifact_producer_identity(
+        dirty_evidence,
+        expected_source_revision=None,
+        active_runtime=dirty_active,
+    )
+
+    with pytest.raises(FinalAuditError, match="git_revision"):
+        final_audit_module._audit_artifact_producer_identity(
+            evidence,
+            expected_source_revision=None,
+            active_runtime=dirty_active,
+        )
+    with pytest.raises(FinalAuditError, match="native_build_inputs_sha256"):
+        final_audit_module._audit_artifact_producer_identity(
+            replace(
+                dirty_evidence,
+                producer_native_build_inputs_sha256="0" * 64,
+            ),
+            expected_source_revision=None,
+            active_runtime=dirty_active,
+        )
+    with pytest.raises(FinalAuditError, match="version"):
+        final_audit_module._audit_artifact_producer_identity(
+            replace(dirty_evidence, producer_version="other"),
+            expected_source_revision=None,
+            active_runtime=dirty_active,
+        )
+
+
+def test_runtime_identity_audit_accepts_real_otf_contract_and_rejects_seed_alias(
+    tmp_path: Path,
+) -> None:
+    measurement = _candidate_measurement(tmp_path)
+    raw_provenance = measurement["provenance"]
+    assert isinstance(raw_provenance, dict)
+    raw_identity = raw_provenance["runtime_identity"]
+    assert isinstance(raw_identity, dict)
+    identity = deepcopy(raw_identity)
+    identity.pop("source_jit_identity")
+    identity.update(
+        {
+            "execution_mode": "on-the-fly",
+            "loaded_execution_mode": "on-the-fly",
+            "required_arena_capability": "rusticol.on-the-fly.complex-f64.v1",
+            "expected_evaluator_abi": "pyamplicol-runtime-on-the-fly-execution",
+            "expected_source_evaluator_abi": ("pyamplicol-symjit-plane-application-v2"),
+            "expected_source_evaluator_runtime_capability": (
+                "symjit.application.complex-f64.v1"
+            ),
+            "source_jit_optimization_level": 2,
+            "process_required_runtime_capabilities": [
+                "rusticol.on-the-fly.complex-f64.v1",
+                "rusticol.on-the-fly.lc-color.v1",
+            ],
+        }
+    )
+    cell = _cell(ExecutionMode.ON_THE_FLY, optimization_level=2)
+
+    _audit_runtime_identity(
+        cell,
+        _runtime_identity_provenance(identity),
+        expected_source_revision=_REVISION,
+        active_runtime=_active_runtime(),
+        artifact=None,
+    )
+
+    invented_seed_alias = deepcopy(identity)
+    invented_seed_alias["expected_source_evaluator_abi"] = (
+        "pyamplicol-on-the-fly-process-seed-v1"
+    )
+    with pytest.raises(FinalAuditError, match="expected_source_evaluator_abi"):
+        _audit_runtime_identity(
+            cell,
+            _runtime_identity_provenance(invented_seed_alias),
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=None,
+        )
+
+
+def test_final_audit_rejects_tampered_raw_arena_profile_evidence() -> None:
+    provenance = _arena_unavailable_provenance()
+    evidence = provenance["arena_profile_evidence"]
+    assert isinstance(evidence, dict)
+    raw_profiles = evidence["raw_profiles"]
+    assert isinstance(raw_profiles, list)
+    assert isinstance(raw_profiles[0], dict)
+    raw_profiles[0]["native_input_pack_bytes"] = 1
+
+    with pytest.raises(
+        FinalAuditError,
+        match="not an authenticated Arena",
+    ):
+        _audit_unavailable_execution_timing(
+            _cell(ExecutionMode.COMPILED, optimization_level=1),
+            provenance,
+            measurement_sample_count=5,
+            context="candidate",
+        )
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "match"),
+    [
+        (
+            "runtime_identity_stable_sha256",
+            "0" * 64,
+            "runtime_identity_stable_sha256",
+        ),
+        (
+            "runtime_identity_postflight_stable_sha256",
+            "0" * 64,
+            "postflight stable SHA-256",
+        ),
+        (
+            "runtime_identity_postflight_match",
+            False,
+            "runtime_identity_postflight_match",
+        ),
+        (
+            "runtime_identity_postflight_loaded_module_origin_policy",
+            {},
+            "loaded-origin policy",
+        ),
+    ],
+)
+def test_runtime_identity_audit_requires_per_cell_postflight_evidence(
+    tmp_path: Path,
+    field: str,
+    value: object,
+    match: str,
+) -> None:
+    measurement = _candidate_measurement(tmp_path)
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    provenance[field] = value
+    with pytest.raises(FinalAuditError, match=match):
+        _audit_runtime_identity(
+            _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+            provenance,
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=None,
+        )
+
+
+def test_runtime_identity_audit_accepts_only_monotonic_postflight_origins(
+    tmp_path: Path,
+) -> None:
+    measurement = _candidate_measurement(tmp_path)
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    raw_postflight = provenance[
+        "runtime_identity_postflight_loaded_module_origin_policy"
+    ]
+    assert isinstance(raw_postflight, dict)
+    observations = raw_postflight["observations"]
+    assert isinstance(observations, list)
+    observations.append(
+        {
+            "module": "pyamplicol.runtime",
+            "kind": "package-member",
+            "root_index": 0,
+            "path": "runtime/__init__.py",
+            "size": 2,
+            "sha256": "2" * 64,
+        }
+    )
+    raw_postflight["observed_module_count"] = len(observations)
+    raw_postflight["observations_sha256"] = digest_json(observations)
+    _audit_runtime_identity(
+        _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+        provenance,
+        expected_source_revision=_REVISION,
+        active_runtime=_active_runtime(),
+        artifact=None,
+    )
+
+    observations[0] = {
+        "module": "pyamplicol.replaced",
+        "kind": "package-member",
+        "root_index": 0,
+        "path": "replaced.py",
+        "size": 3,
+        "sha256": "3" * 64,
+    }
+    raw_postflight["observations_sha256"] = digest_json(observations)
+    with pytest.raises(FinalAuditError, match="lost a loaded-module origin"):
+        _audit_runtime_identity(
+            _cell(ExecutionMode.RECURRENCE, optimization_level=2),
+            provenance,
+            expected_source_revision=_REVISION,
+            active_runtime=_active_runtime(),
+            artifact=None,
+        )
+
+
+def test_final_audit_authenticates_cache_store_and_replays_unique_artifact(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    dependencies = tmp_path / "dependencies"
+    dependencies.mkdir()
+    (dependencies / "contributor-lock.toml").write_text(
+        f'[legacy_amplicol]\nrevision = "{_LEGACY_REVISION}"\n',
+        encoding="utf-8",
+    )
+    baseline = _legacy_cell()
+    candidate = CellSpec(
+        dataset_id="matrix_recurrence_test",
+        process="d d~ > z",
+        n_final=1,
+        process_key="dd_z",
+        measurement=MeasurementSpec(
+            ExecutionMode.RECURRENCE,
+            ModelKey.BUILTIN_SM,
+            Accuracy.LC,
+            "jit",
+            2,
+        ),
+        workload=Workload.SELECTED_FLOW,
+    )
+    catalog = _Catalog(baseline, candidate)
+    paths = ReportPaths.from_repo(
+        tmp_path,
+        artifact_root=tmp_path / "artifacts",
+        coordination_root=tmp_path / "locks",
+    )
+    service = ReportService(paths, catalog=catalog)  # type: ignore[arg-type]
+    artifact = paths.artifact_root / "synthetic-artifact"
+    artifact.mkdir()
+    measurements = {
+        baseline.cell_id: _baseline_measurement(),
+        candidate.cell_id: _candidate_measurement(artifact),
+    }
+    candidate_validation = measurements[candidate.cell_id]["validation"]
+    assert isinstance(candidate_validation, dict)
+    points = final_audit_module.shared_validation_points(candidate.process)
+    selector_contract = report_runner.SelectorContract.from_mapping(_selector())
+    resolved = report_runner.resolved_sum_validation(
+        _Runtime(),
+        points,
+        cell=candidate,
+        selector_contract=selector_contract,
+        precision=16,
+    )
+    high_resolved = report_runner.resolved_sum_validation(
+        _Runtime(),
+        points,
+        cell=candidate,
+        selector_contract=selector_contract,
+        precision=32,
+    )
+    resolved_point = resolved["points"][0]
+    high_resolved_point = high_resolved["points"][0]
+    assert isinstance(resolved_point, dict)
+    assert isinstance(high_resolved_point, dict)
+    selector_identity = {
+        "cell_id": candidate.cell_id,
+        "accuracy": candidate.measurement.accuracy.value,
+        "workload": candidate.workload.value,
+        "selector_contract": selector_contract.as_dict(),
+        "value_kind": "matrix-element-p16-versus-p32",
+    }
+    high_precision = report_runner.pointwise_validation(
+        1.0,
+        1.0,
+        candidate_scale=float(resolved_point["candidate_scale"]),
+        baseline_scale=float(high_resolved_point["candidate_scale"]),
+        candidate_scale_source="resolved-component-l1-binary64",
+        baseline_scale_source="resolved-component-l1-p32",
+        comparison_binding={
+            "point_digest": report_runner.point_digest(points),
+            "selector_component_identity": selector_identity,
+            "selector_component_sha256": digest_json(selector_identity),
+            "candidate_source_sha256": resolved["resolved_source_sha256"],
+            "baseline_source_sha256": high_resolved["resolved_source_sha256"],
+        },
+    )
+    candidate_validation.pop("pointwise")
+    candidate_validation["resolved_sum"] = resolved
+    candidate_validation["high_precision_resolved_sum"] = high_resolved
+    candidate_validation["high_precision"] = high_precision
+    for cell in catalog.measurement_cells():
+        service.store.new_attempt(cell.cell_id, ArtifactPolicy.REGENERATE).publish(
+            measurements[cell.cell_id]
+        )
+    caches = build_reset_caches(catalog)  # type: ignore[arg-type]
+    for payload in caches.values():
+        for entry in payload["entries"]:
+            entry["measurement"] = portable_publication_value(
+                measurements[entry["cell_id"]],
+                paths,
+            )
+    paths.results_dir.mkdir(parents=True)
+    for name, payload in caches.items():
+        (paths.results_dir / name).write_text(
+            json.dumps(payload, sort_keys=True),
+            encoding="ascii",
+        )
+    lock_state = {"held": False, "entries": 0}
+
+    @contextmanager
+    def named_lock(name: str):
+        assert name == "report-writer"
+        assert lock_state["held"] is False
+        lock_state["held"] = True
+        lock_state["entries"] += 1
+        try:
+            yield
+        finally:
+            lock_state["held"] = False
+
+    def assert_locked() -> None:
+        assert lock_state["held"] is True
+
+    def render_auditor() -> dict[str, object]:
+        assert_locked()
+        return {"cache_render_match": True, "table_count": 1}
+
+    monkeypatch.setattr(service.store, "named_lock", named_lock)
+    monkeypatch.setattr(service, "audit", render_auditor)
+
+    def artifact_auditor(
+        _cell: CellSpec,
+        path: Path,
+        process_id: str,
+    ) -> ArtifactEvidence:
+        assert_locked()
+        assert path == artifact
+        candidate_provenance = measurements[candidate.cell_id]["provenance"]
+        assert isinstance(candidate_provenance, dict)
+        effective_config = candidate_provenance["effective_config"]
+        assert isinstance(effective_config, dict)
+        runtime_identity = candidate_provenance["runtime_identity"]
+        assert isinstance(runtime_identity, dict)
+        source_jit_identity = runtime_identity["source_jit_identity"]
+        assert isinstance(source_jit_identity, dict)
+        return ArtifactEvidence(
+            artifact_id=_ARTIFACT_ID,
+            process_id=process_id,
+            producer_version=str(_active_runtime()["package_version"]),
+            producer_git_revision=_REVISION,
+            producer_native_build_inputs_sha256="e" * 64,
+            runtime_version=str(_active_runtime()["package_version"]),
+            runtime_capabilities=(_COLOR_CAPABILITY, _CAPABILITY),
+            execution_manifest_path="processes/d_dbar_to_z/execution.json",
+            execution_manifest_sha256="1" * 64,
+            execution_mode="recurrence",
+            arena_record_count=4,
+            direct_leaf_count=0,
+            effective_config=effective_config,
+            source_jit_identity=source_jit_identity,
+        )
+
+    def runtime_loader(_path: Path, _process: str) -> _Runtime:
+        assert_locked()
+        return _Runtime()
+
+    def source_auditor(_root: Path, _revision: str) -> None:
+        assert_locked()
+
+    def runtime_auditor(_revision: str, _root: Path) -> dict[str, object]:
+        assert_locked()
+        return _active_runtime()
+
+    def pdf_auditor(_service: ReportService) -> dict[str, object]:
+        assert_locked()
+        return {
+            "status": "ok",
+            "published_sha256": "2" * 64,
+        }
+
+    result = audit_final_report(
+        tmp_path,
+        expected_source_revision=_REVISION,
+        max_n_final=1,
+        expected_cell_count=2,
+        replay=True,
+        catalog=catalog,  # type: ignore[arg-type]
+        service=service,
+        active_runtime=_active_runtime(),
+        artifact_auditor=artifact_auditor,
+        runtime_loader=runtime_loader,
+        source_auditor=source_auditor,
+        runtime_auditor=runtime_auditor,
+        pdf_auditor=pdf_auditor,
+    )
+
+    assert lock_state == {"held": False, "entries": 1}
+    assert result["status"] == "incomplete"
+    assert result["schema_version"] == 5
+    assert result["measurement_source_revision"] == _REVISION
+    assert result["publication_revision"] == _REVISION
+    assert result["publication_lineage"]["relationship"] == "same-commit"
+    assert result["authenticated_current_count"] == 2
+    assert result["declared_cell_count"] == 2
+    assert result["measurable_cell_count"] == 2
+    assert result["catalog_static_na_cell_count"] == 0
+    assert result["catalog_static_na_reason_counts"] == {}
+    assert result["portable_publication_projection_count"] == 2
+    assert result["publication_cache_role"] == ("portable-projection-of-current-result")
+    assert result["cryptographic_audit_source"] == "immutable-current-result"
+    assert result["numerically_evidenced_cell_count"] == 2
+    assert result["legacy_fresh_oracle_count"] == 1
+    assert result["legacy_oracles_with_inbound_agreement"] == 0
+    assert result["legacy_pointwise_agreement_edge_count"] == 0
+    assert result["direct_agreement_edge_count"] == 0
+    assert result["direct_agreement_edge_counts"] == {
+        "builtin-ufo-recurrence": 0,
+        "z-recurrence-cross-mode": 0,
+        "lc-cross-layout-component": 0,
+        "lc-legacy-pyamplicol-component": 0,
+        MADGRAPH_FULL_COLOUR: 0,
+    }
+    assert result["replayed_direct_agreement_edge_count"] == 0
+    assert set(result["direct_agreement_replay_category_counts"].values()) == {0}
+    assert result["unique_artifact_count"] == 1
+    assert result["canonical_publication_scope"] is False
+    assert result["final_gate_complete"] is False
+    assert result["audit_scope"] == "diagnostic-incomplete"
+    assert result["pyamplicol_replay_count"] == 1
+    assert result["replayed_measurement_count"] == 1
+    assert result["visible_completeness"] == {
+        "kind": "pyamplicol-report-visible-completeness",
+        "schema_version": 2,
+        "status": "ok",
+        "maximum_n_final": 1,
+        "declared_measurement_cell_count": 2,
+        "required_measurement_count": 2,
+        "rendered_required_measurement_count": 2,
+        "structurally_not_applicable_display_slot_count": 0,
+        "not_exposed_display_slot_count": 0,
+        "catalog_static_na_cell_count": 0,
+        "rendered_catalog_static_na_cell_count": 0,
+        "applicable_na_display_slot_count": 0,
+        "applicable_na_display_slots": [],
+        "missing_rendered_cell_count": 0,
+        "missing_rendered_cell_ids": [],
+        "contract_errors": [],
+    }
+
+    def wrong_runtime_loader(_path: Path, _process: str) -> _Runtime:
+        assert_locked()
+        runtime = _Runtime()
+        runtime.execution_mode = "compiled"
+        return runtime
+
+    with pytest.raises(FinalAuditError, match="loaded execution mode"):
+        audit_final_report(
+            tmp_path,
+            expected_source_revision=_REVISION,
+            max_n_final=1,
+            expected_cell_count=2,
+            replay=True,
+            catalog=catalog,  # type: ignore[arg-type]
+            service=service,
+            active_runtime=_active_runtime(),
+            artifact_auditor=artifact_auditor,
+            runtime_loader=wrong_runtime_loader,
+            source_auditor=source_auditor,
+            runtime_auditor=runtime_auditor,
+            pdf_auditor=pdf_auditor,
+        )
+    assert lock_state == {"held": False, "entries": 2}
+
+    structural = audit_final_report(
+        tmp_path,
+        expected_source_revision=_REVISION,
+        max_n_final=1,
+        expected_cell_count=2,
+        replay=False,
+        catalog=catalog,  # type: ignore[arg-type]
+        service=service,
+        active_runtime=_active_runtime(),
+        artifact_auditor=artifact_auditor,
+        source_auditor=source_auditor,
+        runtime_auditor=runtime_auditor,
+        pdf_auditor=pdf_auditor,
+    )
+    assert structural["status"] == "incomplete"
+    assert structural["final_gate_complete"] is False
+    assert structural["audit_scope"] == "diagnostic-incomplete"
+    assert structural["pyamplicol_replay_count"] == 0
+
+    no_pdf = audit_final_report(
+        tmp_path,
+        expected_source_revision=_REVISION,
+        max_n_final=1,
+        expected_cell_count=2,
+        replay=True,
+        catalog=catalog,  # type: ignore[arg-type]
+        service=service,
+        active_runtime=_active_runtime(),
+        artifact_auditor=artifact_auditor,
+        runtime_loader=runtime_loader,
+        source_auditor=source_auditor,
+        runtime_auditor=runtime_auditor,
+        verify_pdf=False,
+    )
+    assert no_pdf["status"] == "incomplete"
+    assert no_pdf["final_gate_complete"] is False
+    assert no_pdf["pdf_audit"] == {"status": "incomplete", "skipped": True}
+    assert lock_state == {"held": False, "entries": 4}
+
+    with monkeypatch.context() as local_patch:
+        local_patch.setattr(
+            final_audit_module,
+            "summarize_visible_completeness",
+            lambda *_args, **_kwargs: VisibleCompleteness(
+                maximum_n_final=1,
+                required_measurement_count=2,
+                rendered_required_measurement_count=2,
+                structurally_not_applicable_display_slot_count=0,
+                not_exposed_display_slot_count=0,
+                applicable_na_display_slots=("synthetic applicable N/A",),
+                missing_rendered_cell_ids=(),
+                contract_errors=(),
+            ),
+        )
+        with pytest.raises(
+            FinalAuditError,
+            match=r"visible-completeness.*applicable_NA=1",
+        ):
+            audit_final_report(
+                tmp_path,
+                expected_source_revision=_REVISION,
+                max_n_final=1,
+                expected_cell_count=2,
+                replay=False,
+                catalog=catalog,  # type: ignore[arg-type]
+                service=service,
+                active_runtime=_active_runtime(),
+                source_auditor=source_auditor,
+                runtime_auditor=runtime_auditor,
+                verify_pdf=False,
+            )
+    assert lock_state == {"held": False, "entries": 5}
diff --git a/pyamplicol/tests/unit/test_performance_report_madgraph.py b/pyamplicol/tests/unit/test_performance_report_madgraph.py
new file mode 100644
index 0000000000..72f3970581
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_madgraph.py
@@ -0,0 +1,436 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+from collections.abc import Sequence
+from pathlib import Path
+
+import pytest
+
+from tools.developer import madgraph_correctness
+from tools.performance_report import madgraph
+from tools.performance_report.models import (
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    MeasurementSpec,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+
+_REPOSITORY = Path(__file__).resolve().parents[2]
+_UFO_MODEL = _REPOSITORY / "src/pyamplicol/assets/models/ufo/sm"
+_JSON_MODEL = _REPOSITORY / "src/pyamplicol/assets/models/json/sm/sm.json"
+_JSON_RESTRICTION = (
+    _REPOSITORY / "src/pyamplicol/assets/models/json/sm/restrict_default.json"
+)
+
+
+def _command_result(
+    *,
+    cwd: Path,
+    stdout: str = "",
+    stderr: str = "",
+    returncode: int = 0,
+) -> madgraph.CommandResult:
+    return madgraph.CommandResult(
+        args=("fake-command",),
+        cwd=cwd,
+        elapsed_seconds=0.25,
+        returncode=returncode,
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+
+def _madgraph_cell() -> CellSpec:
+    return CellSpec(
+        dataset_id="reference_madgraph_full",
+        process="g g > g g",
+        n_final=2,
+        process_key="gg",
+        measurement=MeasurementSpec(
+            execution_mode=ExecutionMode.MADGRAPH,
+            model=ModelKey.UFO_SM,
+            accuracy=Accuracy.FULL,
+            backend="fortran",
+            jit_optimization_level=None,
+        ),
+        workload=Workload.CONTRACTED,
+    )
+
+
+def _installation(tmp_path: Path) -> Path:
+    installation = tmp_path / "madgraph"
+    launcher = installation / "bin/mg5_aMC"
+    launcher.parent.mkdir(parents=True)
+    launcher.write_text("#!/bin/sh\nexit 0\n", encoding="ascii")
+    launcher.chmod(0o755)
+    shutil.copytree(_UFO_MODEL, installation / "models/sm")
+    (installation / "VERSION").write_text("test-version\n", encoding="ascii")
+    return installation
+
+
+class _FakeExecutor:
+    def __init__(self, *, fail_import: bool = False) -> None:
+        self.fail_import = fail_import
+        self.calls: list[tuple[tuple[str, ...], Path]] = []
+
+    def run(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+    ) -> madgraph.CommandResult:
+        rendered = tuple(os.fspath(item) for item in args)
+        self.calls.append((rendered, cwd))
+        if Path(rendered[0]).name == "mg5_aMC":
+            if self.fail_import:
+                return madgraph.CommandResult(
+                    rendered,
+                    cwd,
+                    1.75,
+                    0,
+                    "UFOImportError: installed model rejected\n",
+                    "",
+                )
+            self._write_standalone(
+                cwd,
+                Path(rendered[0]).parents[1] / "models/sm",
+            )
+            return madgraph.CommandResult(rendered, cwd, 1.75, 0, "", "")
+        if "-o" in rendered:
+            output = cwd / rendered[rendered.index("-o") + 1]
+            output.write_text("fake driver\n", encoding="ascii")
+            output.chmod(0o755)
+            return madgraph.CommandResult(rendered, cwd, 0.4, 0, "", "")
+        points = int(rendered[3])
+        value = 2.5
+        seconds = points * 0.01
+        stdout = "\n".join(
+            (
+                f"PYAMPLICOL_MG_VALUE {value:.17e}",
+                f"PYAMPLICOL_MG_POINTS {points}",
+                f"PYAMPLICOL_MG_SECONDS {seconds:.17e}",
+                f"PYAMPLICOL_MG_CHECKSUM {points * value:.17e}",
+                "",
+            )
+        )
+        return madgraph.CommandResult(rendered, cwd, seconds, 0, stdout, "")
+
+    @staticmethod
+    def _write_standalone(artifact: Path, model: Path) -> None:
+        standalone = artifact / "standalone"
+        cards = standalone / "Cards"
+        subprocess_dir = standalone / "SubProcesses/P0_gg_gg"
+        library = standalone / "lib"
+        source = standalone / "Source"
+        for directory in (cards, subprocess_dir, library, source):
+            directory.mkdir(parents=True)
+        (cards / "proc_card_mg5.dat").write_text(
+            "import model sm\n",
+            encoding="utf-8",
+        )
+        (cards / "param_card.dat").write_text(
+            (model / "restrict_default.dat").read_text(encoding="utf-8"),
+            encoding="utf-8",
+        )
+        (subprocess_dir / "matrix.f").write_text("C fake matrix\n", encoding="ascii")
+        (subprocess_dir / "matrix.o").write_bytes(b"fake object")
+        (library / "libdhelas.a").write_bytes(b"fake library")
+        (library / "libmodel.a").write_bytes(b"fake library")
+        (source / "make_opts").write_text(
+            "DEFAULT_F_COMPILER = fake-fortran\n", encoding="ascii"
+        )
+
+
+class _QuantizedTimerExecutor(_FakeExecutor):
+    def run(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+    ) -> madgraph.CommandResult:
+        result = super().run(args, cwd=cwd)
+        rendered = tuple(os.fspath(item) for item in args)
+        if Path(rendered[0]).name == "mg5_aMC" or "-o" in rendered:
+            return result
+        points = int(rendered[3])
+        seconds = {10: 0.001, 20: 0.0}.get(points, points * 1.0e-5)
+        value = 2.5
+        stdout = "\n".join(
+            (
+                f"PYAMPLICOL_MG_VALUE {value:.17e}",
+                f"PYAMPLICOL_MG_POINTS {points}",
+                f"PYAMPLICOL_MG_SECONDS {seconds:.17e}",
+                f"PYAMPLICOL_MG_CHECKSUM {points * value:.17e}",
+                "",
+            )
+        )
+        return madgraph.CommandResult(rendered, cwd, seconds, 0, stdout, "")
+
+
+def test_command_card_uses_exact_standalone_launch_sequence_and_installed_sm() -> None:
+    assert madgraph.madgraph_command_card("g g > g g") == (
+        "import model sm\n"
+        "generate g g > g g\n"
+        "output standalone standalone -f\n"
+        "launch -f\n"
+    )
+    with pytest.raises(ValueError, match="one non-empty line"):
+        madgraph.madgraph_command_card("g g > g g\nimport model sm")
+    driver_source = madgraph_correctness._DRIVER_SOURCE
+    assert "iso_fortran_env, only: int64" in driver_source
+    assert "integer(kind=int64) :: clock_start" in driver_source
+    assert "if (answer /= reference) error stop 16" in driver_source
+    assert (
+        hashlib.sha256(driver_source.encode("utf-8")).hexdigest()
+        == madgraph.MADGRAPH_DRIVER_SOURCE_SHA256
+    )
+
+
+def test_numerical_acceptance_fixture_tracks_the_canonical_driver() -> None:
+    fixture = json.loads(
+        (
+            _REPOSITORY / "tests/fixtures/numerical_acceptance/ufo-sm-seed101-v1.json"
+        ).read_text(encoding="utf-8")
+    )
+
+    assert fixture["references"]["full"]["driver_sha256"] == (
+        madgraph.MADGRAPH_DRIVER_SOURCE_SHA256
+    )
+
+
+def test_generation_guard_rejects_model_fallback_and_import_failures(
+    tmp_path: Path,
+) -> None:
+    cards = tmp_path / "standalone/Cards"
+    cards.mkdir(parents=True)
+    process_card = cards / "proc_card_mg5.dat"
+    process_card.write_text("import model fallback\n", encoding="utf-8")
+
+    with pytest.raises(madgraph.MadGraphAdapterError, match="bound exclusively"):
+        madgraph._reject_failed_generation(
+            _command_result(cwd=tmp_path), tmp_path / "standalone"
+        )
+
+    process_card.write_text("import model sm\n", encoding="utf-8")
+    madgraph._reject_failed_generation(
+        _command_result(cwd=tmp_path), tmp_path / "standalone"
+    )
+    with pytest.raises(madgraph.MadGraphAdapterError, match="possible model fallback"):
+        madgraph._reject_failed_generation(
+            _command_result(cwd=tmp_path, stderr="UFOImportError: bad model"),
+            tmp_path / "standalone",
+        )
+
+
+def test_exact_parameter_card_matches_json_default_restriction(tmp_path: Path) -> None:
+    card = tmp_path / "param_card.dat"
+
+    record = madgraph._write_exact_param_card(
+        card,
+        parameters_path=_UFO_MODEL / "parameters.py",
+        model_path=_JSON_MODEL,
+        restriction_path=_JSON_RESTRICTION,
+    )
+
+    expected = madgraph._expected_external_parameters(_JSON_MODEL, _JSON_RESTRICTION)
+    restriction = json.loads(_JSON_RESTRICTION.read_text(encoding="utf-8"))
+    rendered = card.read_text(encoding="ascii")
+    assert record == {
+        "external_parameter_count": len(expected),
+        "external_parameters_sha256": record["external_parameters_sha256"],
+        "binary64_exact_match": True,
+        "format": "%.14e",
+    }
+    assert set(restriction) == {name for name, _value in expected.values()}
+    for name, value in expected.values():
+        assert f"{value:.14e} # {name}" in rendered
+        assert float(f"{value:.14e}") == float(restriction[name][0])
+    assert (
+        madgraph._validate_exact_param_card(card, _JSON_MODEL, _JSON_RESTRICTION)
+        == record
+    )
+
+
+def test_driver_output_parser_accepts_fortran_numbers_and_checks_checksum(
+    tmp_path: Path,
+) -> None:
+    result = _command_result(
+        cwd=tmp_path,
+        stdout=(
+            "PYAMPLICOL_MG_VALUE 1.25D+01\n"
+            "PYAMPLICOL_MG_POINTS 4\n"
+            "PYAMPLICOL_MG_SECONDS 2.0D-03\n"
+        ),
+        stderr="PYAMPLICOL_MG_CHECKSUM 5.0D+01\n",
+    )
+
+    parsed = madgraph_correctness.parse_driver_output(result, 4)
+
+    assert parsed.value == 12.5
+    assert parsed.points == 4
+    assert parsed.seconds == 0.002
+    assert parsed.checksum == 50.0
+    with pytest.raises(madgraph.MadGraphAdapterError, match="changed their value"):
+        madgraph_correctness.parse_driver_output(
+            _command_result(
+                cwd=tmp_path,
+                stdout=result.stdout + "PYAMPLICOL_MG_CHECKSUM 4.9D+01\n",
+            ),
+            4,
+        )
+
+    # Sequential floating-point accumulation has an O(points * epsilon)
+    # forward error even when every evaluated value is identical.  This is a
+    # real n=1 campaign calibration sample whose individual-value guard passed.
+    repeated_points = 65_790
+    repeated = _command_result(
+        cwd=tmp_path,
+        stdout=(
+            "PYAMPLICOL_MG_VALUE 2.29970567613276160E+002\n"
+            f"PYAMPLICOL_MG_POINTS {repeated_points}\n"
+            "PYAMPLICOL_MG_SECONDS 6.97789999999999938E-002\n"
+            "PYAMPLICOL_MG_CHECKSUM 1.51297636432885565E+007\n"
+        ),
+    )
+    parsed_repeated = madgraph_correctness.parse_driver_output(
+        repeated, repeated_points
+    )
+    assert parsed_repeated.value == 229.97056761327616
+    assert parsed_repeated.points == repeated_points
+
+
+def test_installation_validation_requires_regular_executable_launcher(
+    tmp_path: Path,
+) -> None:
+    installation = _installation(tmp_path)
+    launcher = installation / "bin/mg5_aMC"
+
+    assert madgraph._validate_installation(installation) == (
+        installation.resolve(),
+        launcher.resolve(),
+        (installation / "models/sm").resolve(),
+    )
+    launcher.chmod(0o644)
+    with pytest.raises(madgraph.MadGraphAdapterError, match="regular executable"):
+        madgraph._validate_installation(installation)
+    launcher.unlink()
+    target = tmp_path / "other-launcher"
+    target.write_text("#!/bin/sh\n", encoding="ascii")
+    target.chmod(0o755)
+    launcher.symlink_to(target)
+    with pytest.raises(madgraph.MadGraphAdapterError, match="regular executable"):
+        madgraph._validate_installation(installation)
+
+
+def test_adapter_fake_executor_happy_path_never_invokes_madgraph(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        madgraph.shutil,
+        "which",
+        lambda compiler: f"/fake/bin/{compiler}",
+    )
+    installation = _installation(tmp_path)
+    artifact = tmp_path / "artifact"
+    executor = _FakeExecutor()
+    settings = madgraph.MadGraphSettings(
+        installation=installation,
+        target_runtime_seconds=0.05,
+        minimum_calls=2,
+        maximum_calls=2,
+        minimum_profile_chunks=5,
+        json_model_path=_JSON_MODEL,
+        restriction_json_path=_JSON_RESTRICTION,
+    )
+
+    measurement = madgraph.MadGraphMeasurementAdapter(executor=executor).measure(
+        _madgraph_cell(), artifact_path=artifact, settings=settings
+    )
+
+    assert measurement["status"] == ResultStatus.OK.value
+    assert measurement["generation_seconds"] == 1.75
+    assert measurement["matrix_element"] == 2.5
+    assert measurement["sample_count"] == 10
+    assert measurement["wall_seconds_per_point"] == pytest.approx(0.01)
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    assert provenance["command_card"] == madgraph.madgraph_command_card(
+        _madgraph_cell().process
+    )
+    assert provenance["exact_param_card"]["format"] == "%.14e"
+    assert provenance["generation_includes_madgraph_compilation"] is True
+    assert provenance["model"]["name"] == "sm"
+    assert provenance["model"]["source_directory"] == os.fspath(
+        installation / "models/sm"
+    )
+    assert len(executor.calls) == 8
+    assert Path(executor.calls[0][0][0]) == installation / "bin/mg5_aMC"
+
+
+def test_adapter_retries_a_quantized_zero_duration_profile_batch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        madgraph.shutil,
+        "which",
+        lambda compiler: f"/fake/bin/{compiler}",
+    )
+    installation = _installation(tmp_path)
+    executor = _QuantizedTimerExecutor()
+    settings = madgraph.MadGraphSettings(
+        installation=installation,
+        target_runtime_seconds=0.01,
+        minimum_calls=10,
+        maximum_calls=2_000,
+        minimum_profile_chunks=5,
+        json_model_path=_JSON_MODEL,
+        restriction_json_path=_JSON_RESTRICTION,
+    )
+
+    measurement = madgraph.MadGraphMeasurementAdapter(executor=executor).measure(
+        _madgraph_cell(),
+        artifact_path=tmp_path / "artifact",
+        settings=settings,
+    )
+
+    driver_points = [
+        int(args[3])
+        for args, _cwd in executor.calls
+        if Path(args[0]).name == "pyamplicol_madgraph_driver"
+    ]
+    assert driver_points == [10, 20, 200, 200, 200, 200, 200]
+    assert measurement["sample_count"] == 1_000
+    assert measurement["wall_seconds_per_point"] == pytest.approx(1.0e-5)
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    assert provenance["driver_timer"] == "fortran-system-clock-int64"
+    assert provenance["profile_calls_per_chunk"] == 200
+    assert provenance["profile_attempted_chunk_count"] == 6
+    assert provenance["profile_discarded_chunk_count"] == 1
+    assert provenance["profile_zero_duration_chunk_count"] == 1
+
+
+def test_adapter_fake_executor_fails_closed_on_import_error(tmp_path: Path) -> None:
+    executor = _FakeExecutor(fail_import=True)
+    settings = madgraph.MadGraphSettings(
+        installation=_installation(tmp_path),
+        json_model_path=_JSON_MODEL,
+        restriction_json_path=_JSON_RESTRICTION,
+    )
+
+    with pytest.raises(madgraph.MadGraphAdapterError, match="possible model fallback"):
+        madgraph.MadGraphMeasurementAdapter(executor=executor).measure(
+            _madgraph_cell(),
+            artifact_path=tmp_path / "artifact",
+            settings=settings,
+        )
+    assert len(executor.calls) == 1
diff --git a/pyamplicol/tests/unit/test_performance_report_measurement.py b/pyamplicol/tests/unit/test_performance_report_measurement.py
new file mode 100644
index 0000000000..97b847811d
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_measurement.py
@@ -0,0 +1,1417 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import subprocess
+from copy import deepcopy
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tools.performance_report.agreements import independent_numerical_authorities
+from tools.performance_report.cache import _validate_independent_authority_record
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.measurement import (
+    _attach_baseline_validation,
+    _baseline_matrix_element,
+    _baseline_selector_contract,
+    _measurement_selector_contract,
+    _require_nonzero_lc_all_flow_baseline,
+    _requires_high_precision_validation,
+    _reuse_artifact_for_measurement,
+    _stable_runtime_identity,
+    _validate_runtime_identity_postflight,
+    _validation_failure_precision_diagnostic,
+    attach_validation_failure_precision_diagnostic,
+    baseline_uses_lc_common_component_authority,
+    failure_measurement,
+    generated_artifact_from_measurement,
+    measure_pyamplicol_cell,
+    source_revision,
+)
+from tools.performance_report.models import Accuracy, ExecutionMode, ResultStatus
+from tools.performance_report.phase_state import (
+    WorkerPhaseChannel,
+    WorkerPhaseReporter,
+    read_worker_phase_state,
+)
+from tools.performance_report.runner import (
+    LOADED_RUNTIME_PROFILE_COMMAND_PATH,
+    PUBLIC_CLI_COMMAND_PATH,
+    GeneratedArtifact,
+    RunnerError,
+    RunnerSettings,
+    SelectorContract,
+)
+
+
+def _contract() -> SelectorContract:
+    return SelectorContract(
+        selected_color_flow_ids=("flow:1,2,3",),
+        selected_color_words=((1, 2, 3),),
+        all_flow_helicity_ids=("h:-1,+1,-1",),
+        all_flow_source_helicities=((1, -1), (2, 1), (3, -1)),
+        point_digest="a" * 64,
+    )
+
+
+def _unchanged_diagnostic_projection(
+    points: object, *, precision: int
+) -> tuple[object, dict[str, object]]:
+    assert precision == 200
+    return points, {
+        "abi": "pyamplicol-diagnostic-onshell-projection-v1",
+        "kind": "per-leg-onshell-energy-v1",
+        "precision_digits": precision,
+        "unchanged": True,
+        "projected_digest": "b" * 64,
+    }
+
+
+def test_baseline_contract_and_matrix_element_are_strict() -> None:
+    baseline = {
+        "status": "ok",
+        "matrix_element": 2.0,
+        "selector_contract": _contract().as_dict(),
+    }
+    assert _baseline_selector_contract(baseline) == _contract()
+    assert _baseline_matrix_element(baseline) == 2.0
+
+    with pytest.raises(RunnerError, match="not a valid completed"):
+        _baseline_matrix_element({"status": "error"})
+    with pytest.raises(RunnerError, match="no matrix element"):
+        _baseline_matrix_element({"status": "ok", "matrix_element": None})
+
+
+def test_lc_selector_uses_baseline_then_selected_flow_provider() -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-lc-n7-dd-4q-lines-all-flow"
+    )
+    baseline_contract = _contract()
+    provider_contract = SelectorContract(
+        selected_color_flow_ids=("flow:3,2,1",),
+        selected_color_words=((3, 2, 1),),
+        all_flow_helicity_ids=("h:+1,-1,+1",),
+        all_flow_source_helicities=((1, 1), (2, -1), (3, 1)),
+        point_digest="b" * 64,
+    )
+    baseline = {"selector_contract": baseline_contract.as_dict()}
+    matching_provider = {
+        "status": ResultStatus.OK.value,
+        "selector_contract": baseline_contract.as_dict(),
+    }
+    provider = {
+        "status": ResultStatus.OK.value,
+        "selector_contract": provider_contract.as_dict(),
+    }
+
+    assert _measurement_selector_contract(cell, baseline, matching_provider) == (
+        baseline_contract
+    )
+    assert _measurement_selector_contract(cell, None, provider) == provider_contract
+
+
+@pytest.mark.parametrize(
+    "provider",
+    (
+        {"status": ResultStatus.ERROR.value},
+        {"status": ResultStatus.OK.value},
+        {
+            "status": ResultStatus.OK.value,
+            "selector_contract": {"selected_color_flow_ids": []},
+        },
+    ),
+)
+def test_invalid_lc_selector_provider_fails_before_generation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    provider: dict[str, object],
+) -> None:
+    import tools.performance_report.measurement as report_measurement
+
+    cell = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-lc-n7-dd-4q-lines-all-flow"
+    )
+    generation_called = False
+
+    def unexpected_generation(*_args: object, **_kwargs: object) -> None:
+        nonlocal generation_called
+        generation_called = True
+
+    monkeypatch.setattr(report_measurement, "generate_artifact", unexpected_generation)
+
+    with pytest.raises((RunnerError, ValueError)):
+        measure_pyamplicol_cell(
+            cell,
+            artifact_path=tmp_path / "artifact",
+            settings=RunnerSettings(),
+            repo_root=tmp_path,
+            baseline=None,
+            selector_provider=provider,
+        )
+
+    assert not generation_called
+
+
+def test_differing_baseline_and_peer_selectors_fail_before_generation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import tools.performance_report.measurement as report_measurement
+
+    cell = REPORT_CATALOG.cell("matrix-compiled-builtin-sm-lc-n2-ud-epve-jets-all-flow")
+    provider_contract = SelectorContract(
+        selected_color_flow_ids=("flow:3,2,1",),
+        selected_color_words=((3, 2, 1),),
+        all_flow_helicity_ids=("h:+1,-1,+1",),
+        all_flow_source_helicities=((1, 1), (2, -1), (3, 1)),
+        point_digest="b" * 64,
+    )
+    baseline = {
+        "status": ResultStatus.OK.value,
+        "selector_contract": _contract().as_dict(),
+        "validation": {"lc_common_component": {"value": 1.0}},
+    }
+    provider = {
+        "status": ResultStatus.OK.value,
+        "selector_contract": provider_contract.as_dict(),
+    }
+    generation_called = False
+
+    def unexpected_generation(*_args: object, **_kwargs: object) -> None:
+        nonlocal generation_called
+        generation_called = True
+
+    monkeypatch.setattr(report_measurement, "generate_artifact", unexpected_generation)
+
+    with pytest.raises(RunnerError, match=r"baseline and selected-flow.*disagree"):
+        measure_pyamplicol_cell(
+            cell,
+            artifact_path=tmp_path / "artifact",
+            settings=RunnerSettings(),
+            repo_root=tmp_path,
+            baseline=baseline,
+            expected_authority_cell_ids=tuple(
+                authority.cell_id
+                for authority in independent_numerical_authorities(cell)
+            ),
+            selected_authority_cell_id=independent_numerical_authorities(
+                cell
+            )[0].cell_id,
+            selector_provider=provider,
+        )
+
+    assert not generation_called
+
+
+def test_lc_all_flow_baseline_must_authenticate_nonzero_common_component() -> None:
+    cell = REPORT_CATALOG.cell("matrix-compiled-builtin-sm-lc-n2-ud-epve-jets-all-flow")
+    baseline = {
+        "validation": {
+            "lc_common_component": {
+                "value": 1.0,
+            }
+        }
+    }
+
+    _require_nonzero_lc_all_flow_baseline(cell, baseline)
+
+    for value in (0.0, float("nan"), None):
+        baseline["validation"]["lc_common_component"]["value"] = value
+        with pytest.raises(RunnerError, match="baseline selector is structural zero"):
+            _require_nonzero_lc_all_flow_baseline(cell, baseline)
+
+
+def _legacy_lc_component_baseline() -> dict[str, object]:
+    contract = _contract().as_dict()
+    return {
+        "status": ResultStatus.OK.value,
+        "matrix_element": 3.736057085488201e-8,
+        "selector_contract": contract,
+        "validation": {
+            "legacy_numerical_authority": {
+                "abi": "pyamplicol-report-legacy-numerical-authority-v1",
+                "source": "all-flow-selected-provider-replay",
+            },
+            "lc_common_component": {
+                "abi": "pyamplicol-report-lc-common-component-v1",
+                "cell_id": "reference-amplicol-lc-n4-dd-tt-jets-all-flow",
+                "value": 2.0402809302299425e-10,
+                "point_digest": contract["point_digest"],
+                "helicity_ids": contract["all_flow_helicity_ids"],
+                "color_flow_ids": contract["selected_color_flow_ids"],
+            },
+            "legacy_imode2_diagnostic": {
+                "authoritative_source": "selected-flow-generated-library-component",
+                "authoritative_value": 2.0402809302299425e-10,
+                "imode2_value": 2.0400817525978893e-10,
+            },
+        },
+    }
+
+
+def test_lc_provider_replay_authenticates_component_not_aggregate() -> None:
+    cell = REPORT_CATALOG.cell("matrix-recurrence-builtin-sm-lc-n4-dd-tt-jets-all-flow")
+    baseline = _legacy_lc_component_baseline()
+    validation: dict[str, object] = {}
+
+    assert baseline_uses_lc_common_component_authority(cell, baseline)
+    _attach_baseline_validation(
+        cell,
+        validation,
+        candidate_matrix_element=3.736053706261443e-8,
+        baseline=baseline,
+    )
+
+    assert "pointwise" not in validation
+
+
+@pytest.mark.parametrize(
+    ("cell_id", "candidate_text", "generated_library", "direct_imode2"),
+    (
+        (
+            "matrix-compiled-builtin-sm-full-n4-dd-tt-jets-contracted",
+            "1.0521884081060938437e-7",
+            1.0521886363225842e-7,
+            1.0521884081060942e-7,
+        ),
+        (
+            "matrix-compiled-builtin-sm-nlc-n4-dd-tt-jets-contracted",
+            "1.0434229425762874817e-7",
+            1.0434231717649298e-7,
+            1.0434229425762883e-7,
+        ),
+    ),
+)
+def test_n4_precision_diagnostic_retains_point_and_independent_authorities(
+    cell_id: str,
+    candidate_text: str,
+    generated_library: float,
+    direct_imode2: float,
+) -> None:
+    from decimal import Decimal
+
+    cell = REPORT_CATALOG.cell(cell_id)
+    candidate = Decimal(candidate_text)
+    calls: list[int] = []
+
+    class Resolved:
+        def total(self) -> tuple[Decimal]:
+            return (candidate,)
+
+    class Runtime:
+        _diagnostic_project_onshell = staticmethod(_unchanged_diagnostic_projection)
+
+        def evaluate(
+            self, _points: object, *, precision: int, **_selectors: object
+        ) -> tuple[Decimal]:
+            calls.append(precision)
+            return (candidate,)
+
+        def evaluate_resolved(
+            self, _points: object, *, precision: int, **_selectors: object
+        ) -> Resolved:
+            assert precision in {32, 200}
+            return Resolved()
+
+    baseline = {
+        "status": ResultStatus.OK.value,
+        "matrix_element": generated_library,
+        "validation": {
+            "legacy_numerical_authority": {
+                "abi": "pyamplicol-report-legacy-numerical-authority-v1",
+                "source": "contracted-generated-library",
+            },
+            "legacy_imode2_diagnostic": {
+                "authoritative_source": "dedicated-generated-library-probe",
+                "authoritative_value": generated_library,
+                "imode2_value": direct_imode2,
+            },
+        },
+    }
+    points = ((500.0, 0.0, 0.0, 500.0),)
+
+    diagnostic = _validation_failure_precision_diagnostic(
+        Runtime(),
+        points,
+        cell=cell,
+        contract=None,
+        baseline=baseline,
+        measurement_context={
+            "wall_seconds_per_point": 1.5e-6,
+            "provenance": {
+                "evaluator_total_timing": {"raw_seconds_per_point": 1.4e-6},
+                "execution_timing": {"raw_seconds_per_point": 1.3e-6},
+            },
+        },
+    )
+
+    assert diagnostic["status"] == "diagnostic-only"
+    assert diagnostic["promotes_measurement"] is False
+    assert diagnostic["timings_unchanged"] is True
+    assert diagnostic["execution_identity"] == {
+        "cell_id": cell_id,
+        "process": "d d~ > t t~ g g",
+        "multiplicity": 4,
+        "workload": "contracted",
+        "layout": "contracted",
+        "execution_mode": "compiled",
+        "backend": "jit",
+        "model": "builtin_sm",
+        "accuracy": cell.measurement.accuracy.value,
+        "variant": None,
+    }
+    assert diagnostic["measurement_timing_context"] == {
+        "source": "copied-from-measurement",
+        "recomputed": False,
+        "outer_wall_seconds_per_point": 1.5e-6,
+        "evaluator_total_timing": {"raw_seconds_per_point": 1.4e-6},
+        "recurrence_core_timing": None,
+    }
+    assert diagnostic["retained_point"]["momenta"] == [[500.0, 0.0, 0.0, 500.0]]
+    assert calls == [32, 200]
+    assert [attempt["precision_digits"] for attempt in diagnostic["attempts"]] == [
+        32,
+        200,
+    ]
+    comparisons = diagnostic["attempts"][-1]["comparisons"]
+    generated = [
+        item
+        for item in comparisons
+        if item["authority"] == "baseline:generated-library"
+    ]
+    direct = [
+        item for item in comparisons if item["authority"] == "baseline:direct-imode2"
+    ]
+    assert {item["candidate_value_kind"] for item in generated} == {
+        "total",
+        "resolved_sum",
+    }
+    assert {item["status"] for item in generated} == {
+        ResultStatus.VALIDATION_FAILED.value
+    }
+    assert {item["status"] for item in direct} == {ResultStatus.OK.value}
+
+
+def test_lc_precision_diagnostic_compares_shared_component() -> None:
+    from decimal import Decimal
+
+    cell = REPORT_CATALOG.cell("matrix-recurrence-builtin-sm-lc-n4-dd-tt-jets-all-flow")
+    contract = _contract()
+    aggregate = Decimal("3.7360537062614512535e-8")
+    component = Decimal("2.0402809302299355e-10")
+    points = ((500.0, 0.0, 0.0, 500.0),)
+    received: list[object] = []
+    projection_calls: list[tuple[object, int]] = []
+
+    class Resolved:
+        def __init__(self, component_only: bool) -> None:
+            self.helicity_ids = (
+                contract.runtime_all_flow_helicity_ids if component_only else ()
+            )
+            self.color_ids = contract.selected_color_flow_ids if component_only else ()
+            self.values = (((component,),),) if component_only else ()
+
+        def total(self) -> tuple[Decimal]:
+            return (aggregate,)
+
+    class Runtime:
+        def _diagnostic_project_onshell(
+            self, raw_points: object, *, precision: int
+        ) -> tuple[object, dict[str, object]]:
+            projection_calls.append((raw_points, precision))
+            return _unchanged_diagnostic_projection(
+                raw_points,
+                precision=precision,
+            )
+
+        def evaluate(self, raw_points: object, **_selectors: object):
+            received.append(raw_points)
+            return (aggregate,)
+
+        def evaluate_resolved(
+            self,
+            raw_points: object,
+            *,
+            color_flows: object = None,
+            **_selectors: object,
+        ) -> Resolved:
+            received.append(raw_points)
+            return Resolved(color_flows is not None)
+
+    diagnostic = _validation_failure_precision_diagnostic(
+        Runtime(),
+        points,
+        cell=cell,
+        contract=contract,
+        baseline=_legacy_lc_component_baseline(),
+        measurement_context={
+            "wall_seconds_per_point": 2.5e-6,
+            "provenance": {
+                "evaluator_total_timing": {"raw_seconds_per_point": 2.4e-6},
+                "execution_timing": {"raw_seconds_per_point": 2.3e-6},
+            },
+        },
+    )
+
+    final = diagnostic["attempts"][-1]
+    assert projection_calls == [(points, 200)]
+    assert len(received) == 6
+    assert all(raw_points is points for raw_points in received)
+    assert diagnostic["measurement_timing_context"] == {
+        "source": "copied-from-measurement",
+        "recomputed": False,
+        "outer_wall_seconds_per_point": 2.5e-6,
+        "evaluator_total_timing": {"raw_seconds_per_point": 2.4e-6},
+        "recurrence_core_timing": {"raw_seconds_per_point": 2.3e-6},
+    }
+    assert final["candidate"]["lc_common_component"]["value"] == str(component)
+    comparisons = {item["authority"]: item for item in final["comparisons"]}
+    assert comparisons["baseline:generated-library"]["status"] == (
+        ResultStatus.OK.value
+    )
+    assert comparisons["baseline:direct-imode2"]["status"] == (
+        ResultStatus.VALIDATION_FAILED.value
+    )
+
+
+def test_precision_diagnostic_stops_after_resolved_p32() -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n4-dd-tt-jets-contracted"
+    )
+    calls: list[int] = []
+
+    class Resolved:
+        def total(self) -> tuple[float]:
+            return (1.0,)
+
+    class Runtime:
+        _diagnostic_project_onshell = staticmethod(_unchanged_diagnostic_projection)
+
+        def evaluate(self, _points: object, *, precision: int, **_selectors: object):
+            calls.append(precision)
+            return (1.0,)
+
+        def evaluate_resolved(
+            self, _points: object, *, precision: int, **_selectors: object
+        ) -> Resolved:
+            return Resolved()
+
+    diagnostic = _validation_failure_precision_diagnostic(
+        Runtime(),
+        ((500.0, 0.0, 0.0, 500.0),),
+        cell=cell,
+        contract=None,
+        baseline={"status": ResultStatus.OK.value, "matrix_element": 1.0},
+    )
+
+    assert calls == [32]
+    assert [attempt["precision_digits"] for attempt in diagnostic["attempts"]] == [32]
+
+
+def test_precision_diagnostic_records_p32_error_then_attempts_p200() -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n4-dd-tt-jets-contracted"
+    )
+    calls: list[int] = []
+
+    class Resolved:
+        def total(self) -> tuple[float]:
+            return (1.0,)
+
+    class Runtime:
+        _diagnostic_project_onshell = staticmethod(_unchanged_diagnostic_projection)
+
+        def evaluate(self, _points: object, *, precision: int, **_selectors: object):
+            calls.append(precision)
+            if precision == 32:
+                raise RuntimeError("p32 diagnostic failure")
+            return (1.0,)
+
+        def evaluate_resolved(
+            self, _points: object, *, precision: int, **_selectors: object
+        ) -> Resolved:
+            return Resolved()
+
+    diagnostic = _validation_failure_precision_diagnostic(
+        Runtime(),
+        ((500.0, 0.0, 0.0, 500.0),),
+        cell=cell,
+        contract=None,
+        baseline={"status": ResultStatus.OK.value, "matrix_element": 1.0},
+    )
+
+    assert calls == [32, 200]
+    assert diagnostic["attempts"][0]["status"] == "unavailable"
+    assert diagnostic["attempts"][0]["error"]["message"] == ("p32 diagnostic failure")
+    assert diagnostic["attempts"][1]["status"] == "evaluated"
+
+
+def test_precision_diagnostic_reuses_projection_and_contextualizes_peers() -> None:
+    from decimal import Decimal
+
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n4-dd-tt-jets-contracted"
+    )
+    original = ((500.0, 0.0, 0.0, 500.0),)
+    projected = (
+        (Decimal("500.0000000000000001"), Decimal(0), Decimal(0), Decimal(500)),
+    )
+    received: list[object] = []
+    projection_calls: list[tuple[object, int]] = []
+
+    class Resolved:
+        def total(self) -> tuple[Decimal]:
+            return (Decimal("2"),)
+
+    class Runtime:
+        def _diagnostic_project_onshell(
+            self, points: object, *, precision: int
+        ) -> tuple[object, dict[str, object]]:
+            projection_calls.append((points, precision))
+            return projected, {
+                "unchanged": False,
+                "projected_digest": "c" * 64,
+            }
+
+        def evaluate(
+            self, points: object, *, precision: int, **_selectors: object
+        ) -> tuple[Decimal]:
+            assert precision in {32, 200}
+            received.append(points)
+            return (Decimal("2"),)
+
+        def evaluate_resolved(
+            self, points: object, *, precision: int, **_selectors: object
+        ) -> Resolved:
+            assert precision in {32, 200}
+            received.append(points)
+            return Resolved()
+
+    diagnostic = _validation_failure_precision_diagnostic(
+        Runtime(),
+        original,
+        cell=cell,
+        contract=None,
+        baseline={"status": ResultStatus.OK.value, "matrix_element": 1.0},
+    )
+
+    assert projection_calls == [(original, 200)]
+    assert len(received) == 4
+    assert all(points is projected for points in received)
+    assert (
+        diagnostic["kinematic_projection"]["original_digest"]
+        == (diagnostic["retained_point"]["digest"])
+    )
+    assert diagnostic["kinematic_projection"]["projected_digest"] == "c" * 64
+    assert [attempt["precision_digits"] for attempt in diagnostic["attempts"]] == [
+        32,
+        200,
+    ]
+    for attempt in diagnostic["attempts"]:
+        assert attempt["candidate"]["point_context"] == "projected-onshell-point"
+        for comparison in attempt["comparisons"]:
+            assert comparison["authority_point_context"] == "original-retained-point"
+            assert comparison["same_kinematic_point"] is False
+            assert comparison["certifying"] is False
+            assert comparison["context_only"] is True
+            assert "status" not in comparison
+
+
+def test_precision_diagnostic_is_bounded_and_non_promoting(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    outside = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-lc-n5-dd-z-jets-selected-flow"
+    )
+    measurement = {
+        "status": ResultStatus.VALIDATION_FAILED.value,
+        "validation": {"status": ResultStatus.VALIDATION_FAILED.value},
+    }
+    attach_validation_failure_precision_diagnostic(outside, measurement, baseline=None)
+    assert "precision_diagnostic" not in measurement["validation"]
+
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n4-dd-tt-jets-contracted"
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.measurement.point_digest",
+        lambda _points: (_ for _ in ()).throw(RuntimeError("diagnostic only")),
+    )
+    diagnostic = _validation_failure_precision_diagnostic(
+        object(), object(), cell=cell, contract=None, baseline=None
+    )
+    assert diagnostic["status"] == "unavailable"
+    assert diagnostic["promotes_measurement"] is False
+
+
+def test_failure_measurement_preserves_compact_cache_shape() -> None:
+    measurement = failure_measurement(
+        ResultStatus.MEMORY_LIMIT,
+        RuntimeError("over limit"),
+        resources={"peak_rss_bytes": 42},
+    )
+
+    assert measurement["status"] == "memory_limit"
+    assert measurement["generation_seconds"] is None
+    assert measurement["resources"] == {"peak_rss_bytes": 42}
+    assert measurement["failure"] == {
+        "kind": "RuntimeError",
+        "message": "over limit",
+    }
+
+
+def test_reused_artifact_closes_current_worker_generation_phase(
+    tmp_path: Path,
+) -> None:
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    ticks = iter((100, 200, 300))
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=42,
+        clock_ns=lambda: next(ticks),
+    )
+    artifact = GeneratedArtifact(
+        path=tmp_path / "artifact",
+        process_id="process",
+        generation_seconds=6.5,
+        model_preparation_seconds=1.0,
+        model_preparation_reused=True,
+        requested_config={},
+        effective_config={},
+    )
+
+    assert (
+        _reuse_artifact_for_measurement(
+            artifact,
+            phase_reporter=reporter,
+        )
+        is artifact
+    )
+    state = read_worker_phase_state(channel, expected_pid=42)
+
+    assert state.phase == "post-generation"
+    assert state.sequence == 2
+    assert state.generation_started_monotonic_ns == 200
+    assert state.generation_finished_monotonic_ns == 300
+    assert state.generation_elapsed_seconds(now_seconds=1.0) == 1.0e-7
+
+
+def test_measurement_routes_reused_artifact_through_phase_completion(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import tools.performance_report.measurement as report_measurement
+
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+    )
+    artifact = GeneratedArtifact(
+        path=tmp_path / "artifact",
+        process_id="process",
+        generation_seconds=6.5,
+        model_preparation_seconds=1.0,
+        model_preparation_reused=True,
+        requested_config={},
+        effective_config={},
+    )
+    reporter = object()
+    observed: list[tuple[GeneratedArtifact, object]] = []
+
+    def reuse(
+        value: GeneratedArtifact,
+        *,
+        phase_reporter: object,
+    ) -> GeneratedArtifact:
+        observed.append((value, phase_reporter))
+        return value
+
+    def stop_after_selection(*_args: object, **_kwargs: object) -> None:
+        raise RuntimeError("selection observed")
+
+    monkeypatch.setattr(report_measurement, "_reuse_artifact_for_measurement", reuse)
+    monkeypatch.setattr(
+        report_measurement,
+        "validate_artifact_contract",
+        stop_after_selection,
+    )
+
+    with pytest.raises(RuntimeError, match="selection observed"):
+        measure_pyamplicol_cell(
+            cell,
+            artifact_path=tmp_path / "unused",
+            settings=RunnerSettings(),
+            repo_root=tmp_path,
+            baseline=None,
+            reused_artifact=artifact,
+            phase_reporter=reporter,  # type: ignore[arg-type]
+        )
+
+    assert observed == [(artifact, reporter)]
+
+
+def test_reusable_artifact_retains_generation_command_path(tmp_path: Path) -> None:
+    artifact_path = tmp_path / "artifact"
+    artifact_path.mkdir()
+    measurement = {
+        "status": ResultStatus.OK.value,
+        "generation_seconds": 2.5,
+        "artifact": {"path": str(artifact_path), "process_id": "process"},
+        "provenance": {
+            "requested_config": {},
+            "effective_config": {},
+            "model_preparation_seconds": 0.25,
+            "model_preparation_reused": True,
+            "generation_command_path": PUBLIC_CLI_COMMAND_PATH,
+            "numerical_relation_correctness": {
+                "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+                "state": "no-applied-relations",
+                "applied_relation_count": 0,
+            },
+            "numerical_relation_fallback": {
+                "abi": "pyamplicol-numerical-current-reuse-fallback-v1",
+                "requested_mode": "certified-reuse",
+                "effective_mode": "off",
+                "effective_reuse_state": "disabled",
+                "reason": "evidence-envelope-fallback",
+                "geometry": {"current_count": 4},
+                "certified_relation_count": 0,
+                "applied_relation_count": 0,
+            },
+        },
+    }
+
+    artifact = generated_artifact_from_measurement(measurement)
+
+    assert artifact.generation_command_path == PUBLIC_CLI_COMMAND_PATH
+    assert artifact.numerical_relation_correctness == {
+        "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+        "state": "no-applied-relations",
+        "applied_relation_count": 0,
+    }
+    assert artifact.numerical_relation_fallback == {
+        "abi": "pyamplicol-numerical-current-reuse-fallback-v1",
+        "requested_mode": "certified-reuse",
+        "effective_mode": "off",
+        "effective_reuse_state": "disabled",
+        "reason": "evidence-envelope-fallback",
+        "geometry": {"current_count": 4},
+        "certified_relation_count": 0,
+        "applied_relation_count": 0,
+    }
+
+    del measurement["provenance"]["generation_command_path"]
+    legacy = generated_artifact_from_measurement(measurement)
+    assert legacy.generation_command_path is None
+
+    measurement["provenance"]["generation_command_path"] = 42
+    with pytest.raises(RunnerError, match="reusable artifact metadata is malformed"):
+        generated_artifact_from_measurement(measurement)
+
+    measurement["provenance"]["generation_command_path"] = PUBLIC_CLI_COMMAND_PATH
+    measurement["provenance"]["numerical_relation_fallback"] = 42
+    with pytest.raises(RunnerError, match="reusable artifact metadata is malformed"):
+        generated_artifact_from_measurement(measurement)
+
+
+def test_measurement_persists_generation_and_runtime_command_paths(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import tools.performance_report.measurement as report_measurement
+
+    cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.accuracy is Accuracy.NLC
+    )
+    artifact_path = tmp_path / "artifact"
+    artifact = GeneratedArtifact(
+        path=artifact_path,
+        process_id="process",
+        generation_seconds=2.5,
+        model_preparation_seconds=0.25,
+        model_preparation_reused=True,
+        requested_config={},
+        effective_config={},
+        generation_command_path=PUBLIC_CLI_COMMAND_PATH,
+        numerical_relation_correctness={
+            "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+            "state": "no-applied-relations",
+            "applied_relation_count": 0,
+        },
+        numerical_relation_fallback={
+            "abi": "pyamplicol-numerical-current-reuse-fallback-v1",
+            "requested_mode": "certified-reuse",
+            "effective_mode": "off",
+            "effective_reuse_state": "disabled",
+            "reason": "evidence-envelope-fallback",
+            "geometry": {"current_count": 4},
+            "certified_relation_count": 0,
+            "applied_relation_count": 0,
+        },
+    )
+
+    class Runtime:
+        def evaluate(self, *_args: object, **_kwargs: object) -> list[float]:
+            return [1.0]
+
+    identity = {
+        "loaded_module_origin_policy": {
+            "observations": [],
+        }
+    }
+
+    def resolved_record(precision: int) -> dict[str, object]:
+        comparison = report_measurement.pointwise_validation(
+            1.0,
+            1.0,
+            candidate_scale=1.0,
+            baseline_scale=1.0,
+            comparison_binding={
+                "abi": "pyamplicol-report-resolved-component-scale-v1",
+                "point_digest": "f" * 64,
+                "helicity_ids": [],
+                "color_flow_ids": [],
+                "resolved_ordering_sha256": "a" * 64,
+                "resolved_source_sha256": ("b" if precision == 16 else "c") * 64,
+                "point_index": 0,
+            },
+        )
+        return {
+            "abi": "pyamplicol-report-resolved-sum-validation-v2",
+            "status": ResultStatus.OK.value,
+            "maximum_absolute_difference": 0.0,
+            "maximum_relative_difference": 0.0,
+            "maximum_conditioned_residual": 0.0,
+            "relative_tolerance": 1.0e-12,
+            "point_digest": "f" * 64,
+            "helicity_ids": [],
+            "color_flow_ids": [],
+            "resolved_ordering_sha256": "a" * 64,
+            "resolved_source_sha256": ("b" if precision == 16 else "c") * 64,
+            "scale_source": "resolved-component-l1",
+            "precision_digits": precision,
+            "points": [comparison],
+        }
+
+    profile = {
+        "status": ResultStatus.OK.value,
+        "wall_seconds_per_point": 1.0e-6,
+        "execution_seconds_per_point": 0.5e-6,
+        "matrix_element": 1.0,
+        "sample_count": 5,
+        "standard_error_seconds_per_point": 0.1e-6,
+        "relative_standard_error": 0.1,
+        "execution_timing": {},
+        "arena_profile_evidence": {},
+        "benchmark_evidence": {
+            "report_command_path": LOADED_RUNTIME_PROFILE_COMMAND_PATH,
+        },
+        "resolved_sum_validation": resolved_record(16),
+    }
+    monkeypatch.setattr(
+        report_measurement,
+        "generate_artifact",
+        lambda *_args, **_kwargs: artifact,
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "validate_artifact_contract",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "_load_runtime",
+        lambda *_args, **_kwargs: Runtime(),
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "runtime_identity_payload",
+        lambda *_args, **_kwargs: identity,
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "shared_validation_points",
+        lambda _process: ((1.0,),),
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "_resolution_benchmark_config",
+        lambda _config: object(),
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "profile_runtime",
+        lambda *_args, **_kwargs: deepcopy(profile),
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "resolved_sum_validation",
+        lambda *_args, precision=16, **_kwargs: resolved_record(precision),
+    )
+
+    measurement = measure_pyamplicol_cell(
+        cell,
+        artifact_path=artifact_path,
+        settings=RunnerSettings(source_revision_override="a" * 40),
+        repo_root=tmp_path,
+        baseline=None,
+    )
+
+    provenance = measurement["provenance"]
+    assert provenance["generation_command_path"] == PUBLIC_CLI_COMMAND_PATH
+    assert provenance["numerical_relation_fallback"]["reason"] == (
+        "evidence-envelope-fallback"
+    )
+    assert provenance["report_momenta"] == [[1.0]]
+    assert (
+        provenance["runtime_profile"]["report_command_path"]
+        == LOADED_RUNTIME_PROFILE_COMMAND_PATH
+    )
+
+
+@pytest.mark.parametrize(
+    (
+        "cell_id",
+        "authority_available",
+        "standalone",
+        "p32_matches",
+        "custom_authority",
+    ),
+    (
+        (
+            "matrix-compiled-builtin-sm-nlc-n1-dd-z-jets-contracted",
+            True,
+            False,
+            True,
+            False,
+        ),
+        (
+            "matrix-compiled-builtin-sm-full-n1-dd-z-jets-contracted",
+            True,
+            False,
+            True,
+            False,
+        ),
+        (
+            "matrix-compiled-builtin-sm-full-n1-dd-z-jets-contracted",
+            False,
+            False,
+            True,
+            False,
+        ),
+        (
+            "scalar-contact-n2-scalar-contact-contracted",
+            False,
+            True,
+            True,
+            False,
+        ),
+        (
+            "scalar-gravity-n2-scalar-gravity-contracted",
+            False,
+            True,
+            True,
+            False,
+        ),
+        (
+            "scalar-contact-n2-scalar-contact-contracted",
+            False,
+            True,
+            False,
+            False,
+        ),
+        (
+            "scalar-contact-n2-scalar-contact-contracted",
+            True,
+            False,
+            True,
+            True,
+        ),
+    ),
+)
+def test_initial_compiled_authority_uses_nested_resolved_point_identity(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    cell_id: str,
+    authority_available: bool,
+    standalone: bool,
+    p32_matches: bool,
+    custom_authority: bool,
+) -> None:
+    import tools.performance_report.measurement as report_measurement
+
+    cell = REPORT_CATALOG.cell(cell_id)
+
+    class CustomAuthorityCatalog:
+        """Make one scalar use the ordinary matrix authority chain."""
+
+        def measurement_cells(self):
+            return REPORT_CATALOG.measurement_cells()
+
+        def validation_baseline_cell(self, candidate):
+            if candidate == cell:
+                return REPORT_CATALOG.cell(
+                    "matrix-recurrence-builtin-sm-full-n1-dd-z-jets-contracted"
+                )
+            return REPORT_CATALOG.validation_baseline_cell(candidate)
+
+    catalog = CustomAuthorityCatalog() if custom_authority else REPORT_CATALOG
+    validation_points = ((1.0,),)
+    point_identity = report_measurement.point_digest(validation_points)
+    source = "b" * 64
+    resolved_point = report_measurement.pointwise_validation(
+        1.0,
+        1.0,
+        candidate_scale=1.0,
+        baseline_scale=1.0,
+        comparison_binding={
+            "abi": "pyamplicol-report-resolved-component-scale-v1",
+            "point_digest": point_identity,
+            "helicity_ids": [],
+            "color_flow_ids": [],
+            "resolved_ordering_sha256": "a" * 64,
+            "resolved_source_sha256": source,
+            "point_index": 0,
+        },
+    )
+    resolved = {
+        "abi": "pyamplicol-report-resolved-sum-validation-v2",
+        "status": ResultStatus.OK.value,
+        "maximum_absolute_difference": 0.0,
+        "maximum_relative_difference": 0.0,
+        "maximum_conditioned_residual": 0.0,
+        "relative_tolerance": 1.0e-12,
+        "point_digest": point_identity,
+        "helicity_ids": [],
+        "color_flow_ids": [],
+        "resolved_ordering_sha256": "a" * 64,
+        "resolved_source_sha256": source,
+        "scale_source": "resolved-component-l1",
+        "precision_digits": 16,
+        "points": [resolved_point],
+    }
+    p32_resolved = {**deepcopy(resolved), "precision_digits": 32}
+    if not p32_matches:
+        p32_resolved["points"] = [
+            report_measurement.pointwise_validation(
+                2.0,
+                2.0,
+                candidate_scale=2.0,
+                baseline_scale=2.0,
+                comparison_binding={
+                    "abi": "pyamplicol-report-resolved-component-scale-v1",
+                    "point_digest": point_identity,
+                    "helicity_ids": [],
+                    "color_flow_ids": [],
+                    "resolved_ordering_sha256": "a" * 64,
+                    "resolved_source_sha256": source,
+                    "point_index": 0,
+                },
+            )
+        ]
+    artifact_path = tmp_path / "artifact"
+    artifact = GeneratedArtifact(
+        path=artifact_path,
+        process_id="process",
+        generation_seconds=1.0,
+        model_preparation_seconds=0.0,
+        model_preparation_reused=True,
+        requested_config={},
+        effective_config={},
+    )
+    profile = {
+        "status": ResultStatus.OK.value,
+        "wall_seconds_per_point": 1.0e-6,
+        "execution_seconds_per_point": 0.8e-6,
+        "matrix_element": 1.0,
+        "sample_count": 5,
+        "standard_error_seconds_per_point": 0.0,
+        "relative_standard_error": 0.0,
+        "execution_timing": {},
+        "arena_profile_evidence": {},
+        "benchmark_evidence": {},
+        "resolved_sum_validation": resolved,
+    }
+    identity = {"loaded_module_origin_policy": {"observations": []}}
+
+    class Runtime:
+        def _diagnostic_project_onshell(
+            self,
+            points: object,
+            *,
+            precision: int,
+        ) -> tuple[object, dict[str, object]]:
+            assert precision == 200
+            return points, {"unchanged": True, "projected_digest": point_identity}
+
+        def evaluate(self, *_args: object, **_kwargs: object) -> list[float]:
+            return [1.0]
+
+        def evaluate_resolved(
+            self,
+            *_args: object,
+            **_kwargs: object,
+        ) -> SimpleNamespace:
+            return SimpleNamespace(
+                total=lambda: (1.0,),
+                values=(((1.0,),),),
+                helicity_ids=(),
+                color_ids=(),
+            )
+    monkeypatch.setattr(
+        report_measurement,
+        "generate_artifact",
+        lambda *_args, **_kwargs: artifact,
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "validate_artifact_contract",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "_load_runtime",
+        lambda *_args, **_kwargs: Runtime(),
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "runtime_identity_payload",
+        lambda *_args, **_kwargs: identity,
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "shared_validation_points",
+        lambda _process: validation_points,
+    )
+    if standalone or cell.measurement.model in {
+        report_measurement.ModelKey.SCALAR_CONTACT,
+        report_measurement.ModelKey.SCALAR_GRAVITY,
+    }:
+        monkeypatch.setattr(
+            report_measurement,
+            "runtime_validation_points",
+            lambda _runtime: validation_points,
+        )
+    monkeypatch.setattr(
+        report_measurement,
+        "_resolution_benchmark_config",
+        lambda _config: object(),
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "profile_runtime",
+        lambda *_args, **_kwargs: deepcopy(profile),
+    )
+    monkeypatch.setattr(
+        report_measurement,
+        "resolved_sum_validation",
+        lambda *_args, **_kwargs: (
+            pytest.fail("p32 is diagnostic-only with authority")
+            if authority_available and not custom_authority
+            else deepcopy(p32_resolved)
+        ),
+    )
+    authorities = independent_numerical_authorities(cell, catalog=catalog)  # type: ignore[arg-type]
+    baseline = {
+        "status": ResultStatus.OK.value,
+        "matrix_element": 1.0,
+        "selector_contract": None,
+        "validation": {"point_digest": point_identity},
+        "provenance": {},
+    }
+
+    measurement = measure_pyamplicol_cell(
+        cell,
+        artifact_path=artifact_path,
+        settings=RunnerSettings(source_revision_override="a" * 40),
+        repo_root=tmp_path,
+        baseline=baseline if authority_available else None,
+        expected_authority_cell_ids=tuple(item.cell_id for item in authorities),
+        selected_authority_cell_id=(
+            authorities[0].cell_id if authority_available else None
+        ),
+        catalog=catalog,  # type: ignore[arg-type]
+    )
+
+    if custom_authority:
+        validation = measurement["validation"]
+        assert isinstance(validation, dict)
+        _validate_independent_authority_record(
+            validation,
+            expected_cell=cell,
+            expected_status="verified",
+            catalog=catalog,  # type: ignore[arg-type]
+        )
+        with pytest.raises(ValueError, match="not applicable"):
+            _validate_independent_authority_record(
+                validation,
+                expected_cell=cell,
+                expected_status="verified",
+                catalog=REPORT_CATALOG,
+            )
+
+    validation = measurement["validation"]
+    if authority_available:
+        assert measurement["status"] == ResultStatus.OK.value
+        assert validation["pointwise"]["status"] == ResultStatus.OK.value
+        assert validation["independent_authority"]["selected_cell_id"] == (
+            authorities[0].cell_id
+        )
+    elif standalone and p32_matches:
+        assert authorities == ()
+        assert measurement["status"] == ResultStatus.OK.value
+        assert measurement["failure"] is None
+        assert validation["high_precision"]["status"] == ResultStatus.OK.value
+        assert "independent_authority" not in validation
+        assert "precision_diagnostic" not in validation
+    elif standalone:
+        assert authorities == ()
+        assert measurement["status"] == ResultStatus.VALIDATION_FAILED.value
+        assert measurement["failure"]["kind"] == "MeasurementValidationError"
+        assert validation["high_precision"]["status"] == (
+            ResultStatus.VALIDATION_FAILED.value
+        )
+        assert "independent_authority" not in validation
+    else:
+        assert measurement["status"] == ResultStatus.UNVERIFIED.value
+        assert measurement["failure"]["kind"] == "IndependentAuthorityUnavailable"
+        assert validation["independent_authority"]["status"] == "unavailable"
+        assert [
+            attempt["precision_digits"]
+            for attempt in validation["precision_diagnostic"]["attempts"]
+        ] == [32, 200]
+
+
+def test_catalog_contains_no_amplicol_candidate_matrix_cell() -> None:
+    assert all(
+        cell.measurement.execution_mode.value != "amplicol"
+        for cell in REPORT_CATALOG.matrix_cells()
+    )
+
+
+def test_legacy_amplicol_diagnostic_does_not_replace_p32_certification() -> None:
+    recurrence = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-full-n1-dd-z-jets-contracted"
+    )
+    legacy = {"status": ResultStatus.OK.value, "matrix_element": 1.0}
+
+    assert _requires_high_precision_validation(
+        recurrence,
+        baseline=legacy,
+        selected_authority_cell_id=None,
+        catalog=REPORT_CATALOG,
+    ) == (True, True)
+
+    compiled = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n1-dd-z-jets-contracted"
+    )
+    recurrence_authority = {"status": ResultStatus.OK.value, "matrix_element": 1.0}
+    assert _requires_high_precision_validation(
+        compiled,
+        baseline=recurrence_authority,
+        selected_authority_cell_id=recurrence.cell_id,
+        catalog=REPORT_CATALOG,
+    ) == (False, False)
+
+
+def test_source_revision_rejects_source_dirt_but_allows_report_outputs(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "report-test@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Report Test"),
+        cwd=repo,
+        check=True,
+    )
+    source = repo / "source.py"
+    source.write_text("VALUE = 1\n", encoding="utf-8")
+    subprocess.run(("git", "add", "source.py"), cwd=repo, check=True)
+    subprocess.run(("git", "commit", "-q", "-m", "initial"), cwd=repo, check=True)
+
+    revision = source_revision(repo, require_clean=True)
+    assert len(revision) == 40
+
+    cache = repo / "docs/arxiv/results/z_builtin_sm.json"
+    cache.parent.mkdir(parents=True)
+    cache.write_text("{}\n", encoding="ascii")
+    table = repo / "docs/arxiv/result_z_builtin_sm_table.tex"
+    table.write_text("% generated\n", encoding="ascii")
+    assert source_revision(repo, require_clean=True) == revision
+
+    source.write_text("VALUE = 2\n", encoding="utf-8")
+    with pytest.raises(RunnerError, match="outside generated report outputs"):
+        source_revision(repo, require_clean=True)
+
+
+def _runtime_identity() -> dict[str, object]:
+    observations = [
+        {
+            "module": "pyamplicol",
+            "kind": "package-member",
+            "root_index": 0,
+            "path": "__init__.py",
+            "size": 10,
+            "sha256": "1" * 64,
+        }
+    ]
+    return {
+        "kind": "pyamplicol-report-runtime-identity-v1",
+        "loaded_module_origin_policy": {
+            "kind": "pyamplicol-loaded-module-origin-policy-v1",
+            "all_loaded_origins_authenticated": True,
+            "native_image_origin_bound": True,
+            "loaded_bytecode_eligible": False,
+            "observed_module_count": len(observations),
+            "observations": observations,
+            "observations_sha256": "a" * 64,
+        },
+    }
+
+
+def test_runtime_identity_postflight_is_stable_and_monotonic() -> None:
+    initial = _runtime_identity()
+    postflight = deepcopy(initial)
+    policy = postflight["loaded_module_origin_policy"]
+    assert isinstance(policy, dict)
+    observations = policy["observations"]
+    assert isinstance(observations, list)
+    observations.append(
+        {
+            "module": "pyamplicol.runtime",
+            "kind": "package-member",
+            "root_index": 0,
+            "path": "runtime/__init__.py",
+            "size": 20,
+            "sha256": "2" * 64,
+        }
+    )
+    policy["observed_module_count"] = len(observations)
+    _validate_runtime_identity_postflight(initial, postflight)
+    assert _stable_runtime_identity(initial) == _stable_runtime_identity(postflight)
+
+    changed = deepcopy(postflight)
+    changed["native_build_inputs_sha256"] = "3" * 64
+    with pytest.raises(RunnerError, match="changed during report measurement"):
+        _validate_runtime_identity_postflight(initial, changed)
+
+    lost = deepcopy(postflight)
+    lost_policy = lost["loaded_module_origin_policy"]
+    assert isinstance(lost_policy, dict)
+    lost_observations = lost_policy["observations"]
+    assert isinstance(lost_observations, list)
+    lost_observations.pop(0)
+    lost_policy["observed_module_count"] = len(lost_observations)
+    with pytest.raises(RunnerError, match="lost an authenticated"):
+        _validate_runtime_identity_postflight(initial, lost)
diff --git a/pyamplicol/tests/unit/test_performance_report_measurement_lineage.py b/pyamplicol/tests/unit/test_performance_report_measurement_lineage.py
new file mode 100644
index 0000000000..6e5c885f1a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_measurement_lineage.py
@@ -0,0 +1,466 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.artifacts import ArtifactStore
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.measurement_lineage import (
+    CLASS_C_HZZ_IMPACT,
+    MEASUREMENT_LINEAGE_FILENAME,
+    MEASUREMENT_LINEAGE_SCHEMA,
+    MeasurementLineageError,
+    _catalog_digest,
+    _digest,
+    _load_envelope,
+    audit_measurement_lineage,
+    class_c_pending_path,
+    finalize_class_c_bridge,
+    hzz_agreement_closure,
+    hzz_impacted_cells,
+    load_measurement_lineage,
+    prepare_class_c_bridge,
+)
+from tools.performance_report.models import ArtifactPolicy, ExecutionMode, ModelKey
+from tools.performance_report.workspace import (
+    _authenticated_environment_payload,
+    _environment_tex,
+)
+
+
+def _git(repo: Path, *arguments: str) -> str:
+    return subprocess.run(
+        ("git", *arguments),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+
+def _runtime(
+    package_tree: str,
+    *,
+    source_revision: str,
+    native_build_inputs: str = "a" * 64,
+    native_extension: str = "b" * 64,
+) -> dict[str, object]:
+    return {
+        "package_version": "0.1.0",
+        "native_build_inputs_sha256": native_build_inputs,
+        "native_extension": {"sha256": native_extension},
+        "python_package_tree": {"sha256": package_tree},
+        "candidate_build_identity": {
+            "candidate_fingerprint": "candidate-fixture",
+            "source_revision": source_revision,
+        },
+        "native_target": {
+            "triple": "aarch64-apple-darwin",
+            "cpu_features": ["neon"],
+        },
+    }
+
+
+def _write(repo: Path, relative: str, value: str | bytes) -> None:
+    path = repo / relative
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if isinstance(value, bytes):
+        path.write_bytes(value)
+    else:
+        path.write_text(value, encoding="utf-8")
+
+
+def _repository(tmp_path: Path) -> tuple[Path, Path, ArtifactStore, str]:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git(repo, "init", "-q")
+    _git(repo, "config", "user.email", "lineage@example.invalid")
+    _git(repo, "config", "user.name", "Lineage Test")
+    profile = repo / "docs/performance_reports/macbook_M3"
+    _write(
+        repo,
+        "docs/performance_reports/macbook_M3/report-workspace.json",
+        json.dumps({"campaign_policy": {"name": "fixture"}}) + "\n",
+    )
+    _write(repo, "src/pyamplicol/models/builtin/lowering.py", "VALUE = 1\n")
+    for path in (
+        "tests/unit/test_model_builtin.py",
+        "tests/unit/test_packaged_prepared_model.py",
+        "tests/unit/test_recurrence_catalog_builder.py",
+    ):
+        _write(repo, path, "VALUE = 1\n")
+    for root in (
+        "src/pyamplicol/assets/prepared_models",
+        "release_assets/prepared_models",
+    ):
+        for architecture in ("aarch64", "x86_64"):
+            stem = f"built-in-sm-jit-o2-{architecture}"
+            _write(repo, f"{root}/{stem}.pyamplicol-model", b"old bundle\n")
+            _write(repo, f"{root}/{stem}.metadata.json", '{"old":true}\n')
+    _git(repo, "add", ".")
+    _git(repo, "commit", "-q", "-m", "ancestor")
+    ancestor = _git(repo, "rev-parse", "HEAD")
+    environment = _authenticated_environment_payload(
+        "macbook_M3",
+        expected_source_revision=ancestor,
+        active_runtime=_runtime("c" * 64, source_revision=ancestor),
+    )
+    _write(
+        repo,
+        "docs/performance_reports/macbook_M3/report_environment.json",
+        json.dumps(environment, sort_keys=True) + "\n",
+    )
+    store = ArtifactStore(
+        artifact_root=repo / ".artifacts/performance-report/macbook_M3",
+        lock_root=repo
+        / ".artifacts/performance-report-coordination/macbook_M3",
+    )
+    retained = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+    )
+    ancestor_tree = _git(repo, "rev-parse", "HEAD^{tree}")
+    store.new_attempt(retained.cell_id, ArtifactPolicy.REGENERATE).publish(
+        {
+            "status": "ok",
+            "provenance": {
+                "report_source_revision": ancestor,
+                "report_source_tree": ancestor_tree,
+                "report_measured_source_revision": ancestor,
+                "report_measured_source_tree": ancestor_tree,
+            },
+        }
+    )
+    _write(repo, "src/pyamplicol/models/builtin/lowering.py", "VALUE = 2\n")
+    for path in (
+        "tests/unit/test_model_builtin.py",
+        "tests/unit/test_packaged_prepared_model.py",
+        "tests/unit/test_recurrence_catalog_builder.py",
+    ):
+        _write(repo, path, "VALUE = 2\n")
+    for root in (
+        "src/pyamplicol/assets/prepared_models",
+        "release_assets/prepared_models",
+    ):
+        for architecture in ("aarch64", "x86_64"):
+            stem = f"built-in-sm-jit-o2-{architecture}"
+            _write(repo, f"{root}/{stem}.pyamplicol-model", b"new bundle\n")
+            _write(repo, f"{root}/{stem}.metadata.json", '{"new":true}\n')
+    _git(repo, "add", "src/pyamplicol/models/builtin/lowering.py")
+    _git(repo, "add", "src/pyamplicol/assets/prepared_models")
+    _git(repo, "add", "release_assets/prepared_models")
+    _git(repo, "add", "tests/unit/test_model_builtin.py")
+    _git(repo, "add", "tests/unit/test_packaged_prepared_model.py")
+    _git(repo, "add", "tests/unit/test_recurrence_catalog_builder.py")
+    _git(repo, "commit", "-q", "-m", "descendant")
+    return repo, profile, store, ancestor
+
+
+def test_hzz_impact_and_direct_agreement_closure_are_exact() -> None:
+    impacted = hzz_impacted_cells()
+    closure = hzz_agreement_closure()
+
+    assert len(impacted) == 20
+    assert len(closure) == 20
+    assert all(
+        cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+        and cell.process_key == "dd_zzz_jets"
+        and cell.n_final >= 3
+        for cell in impacted
+    )
+    assert all(
+        cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.UFO_SM
+        and cell.process_key == "dd_zzz_jets"
+        and cell.n_final >= 3
+        for cell in closure
+    )
+    assert {cell.cell_id for cell in impacted}.isdisjoint(
+        cell.cell_id for cell in closure
+    )
+
+
+def test_lineage_v2_binds_static_na_catalog_semantics() -> None:
+    class CatalogWithoutStaticNa:
+        def __getattr__(self, name: str) -> object:
+            return getattr(REPORT_CATALOG, name)
+
+        def static_na_reason(self, _cell: object) -> None:
+            return None
+
+    assert MEASUREMENT_LINEAGE_SCHEMA == (
+        "pyamplicol-performance-measurement-lineage-v2"
+    )
+    assert _catalog_digest(
+        CatalogWithoutStaticNa(),  # type: ignore[arg-type]
+    ) != _catalog_digest(REPORT_CATALOG)
+
+
+def test_lineage_v1_envelope_is_rejected_and_requires_reseal(
+    tmp_path: Path,
+) -> None:
+    repo, profile, store, ancestor = _repository(tmp_path)
+    descendant = _git(repo, "rev-parse", "HEAD")
+    prepare_class_c_bridge(
+        repo,
+        profile,
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+        impact=CLASS_C_HZZ_IMPACT,
+    )
+    pending = class_c_pending_path(
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+    )
+    envelope = json.loads(pending.read_text(encoding="ascii"))
+    envelope["payload"]["schema"] = (
+        "pyamplicol-performance-measurement-lineage-v1"
+    )
+    envelope["payload_sha256"] = _digest(envelope["payload"])
+    pending.write_text(
+        json.dumps(
+            envelope,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        + "\n",
+        encoding="ascii",
+    )
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="schema is incompatible",
+    ):
+        _load_envelope(pending, expected_state="pending")
+
+
+def test_prepare_finalize_and_audit_class_c_bridge(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo, profile, store, ancestor = _repository(tmp_path)
+    descendant = _git(repo, "rev-parse", "HEAD")
+    prepared = prepare_class_c_bridge(
+        repo,
+        profile,
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+        impact=CLASS_C_HZZ_IMPACT,
+    )
+    pending = class_c_pending_path(
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+    )
+
+    assert prepared["state"] == "pending"
+    assert len(prepared["retained_currents"]) == 1
+    assert len(prepared["impacted_cells"]) == 20
+    assert len(prepared["agreement_closure_cells"]) == 20
+    assert len(prepared["no_attempt_cells"]) == len(
+        REPORT_CATALOG.measurement_cells()
+    ) - 1
+
+    relinked_runtime = _runtime(
+        "d" * 64,
+        source_revision=descendant,
+        native_extension="e" * 64,
+    )
+    new_environment = _authenticated_environment_payload(
+        "macbook_M3",
+        expected_source_revision=descendant,
+        active_runtime=relinked_runtime,
+    )
+
+    def fake_refresh(
+        _repo: Path,
+        _profile: str,
+        *,
+        expected_source_revision: str,
+        runtime_auditor: object,
+        _skip_workspace_validation: bool,
+    ) -> dict[str, str]:
+        assert expected_source_revision == descendant
+        assert _skip_workspace_validation is True
+        del runtime_auditor
+        with store.named_lock("measurement-lineage", timeout=0.0):
+            pass
+        (profile / "report_environment.json").write_text(
+            json.dumps(new_environment, sort_keys=True) + "\n",
+            encoding="ascii",
+        )
+        (profile / "report_environment.tex").write_text(
+            _environment_tex(new_environment),
+            encoding="utf-8",
+        )
+        return new_environment
+
+    monkeypatch.setattr(
+        "tools.performance_report.workspace.refresh_profile_environment",
+        fake_refresh,
+    )
+    finalized = finalize_class_c_bridge(
+        repo,
+        profile,
+        store,
+        pending_path=pending,
+        expected_active_source_revision=descendant,
+        runtime_auditor=lambda _revision, _root: relinked_runtime,
+    )
+
+    assert finalized["state"] == "finalized"
+    assert (
+        finalized["ancestor_environment"]["native_extension_sha256"]
+        != finalized["descendant_environment"]["native_extension_sha256"]
+    )
+    assert "native_extension_sha256" not in finalized["runtime_invariant_fields"]
+    assert (profile / MEASUREMENT_LINEAGE_FILENAME).is_file()
+    lineage = load_measurement_lineage(
+        repo,
+        profile,
+        expected_active_revision=descendant,
+        expected_active_tree=_git(repo, "rev-parse", "HEAD^{tree}"),
+    )
+    assert lineage is not None
+    retained = store.recover_current_records()[0]
+    assert lineage.source_for_current(
+        retained,
+        active_revision=descendant,
+        active_tree=_git(repo, "rev-parse", "HEAD^{tree}"),
+    ) == (ancestor, _git(repo, "rev-parse", f"{ancestor}^{{tree}}"))
+    assert audit_measurement_lineage(
+        repo,
+        profile,
+        store,
+        expected_active_source_revision=descendant,
+    )["runtime_invariants_match"] is True
+
+
+def test_class_c_bridge_rejects_changed_native_build_inputs(
+    tmp_path: Path,
+) -> None:
+    repo, profile, store, ancestor = _repository(tmp_path)
+    descendant = _git(repo, "rev-parse", "HEAD")
+    prepare_class_c_bridge(
+        repo,
+        profile,
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+        impact=CLASS_C_HZZ_IMPACT,
+    )
+    pending = class_c_pending_path(
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+    )
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="dependency/native/host runtime identity",
+    ):
+        finalize_class_c_bridge(
+            repo,
+            profile,
+            store,
+            pending_path=pending,
+            expected_active_source_revision=descendant,
+            runtime_auditor=lambda _revision, _root: _runtime(
+                "d" * 64,
+                source_revision=_revision,
+                native_build_inputs="f" * 64,
+            ),
+        )
+
+
+def test_class_c_bridge_rejects_disallowed_source_change(tmp_path: Path) -> None:
+    repo, profile, store, ancestor = _repository(tmp_path)
+    _write(repo, "dependencies/lock.toml", "changed = true\n")
+    _git(repo, "add", "dependencies/lock.toml")
+    _git(repo, "commit", "-q", "-m", "disallowed")
+
+    with pytest.raises(MeasurementLineageError, match="disallowed path"):
+        prepare_class_c_bridge(
+            repo,
+            profile,
+            store,
+            ancestor_revision=ancestor,
+            descendant_revision=_git(repo, "rev-parse", "HEAD"),
+            impact=CLASS_C_HZZ_IMPACT,
+        )
+
+
+def test_lineage_envelope_tampering_fails_closed(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo, profile, store, ancestor = _repository(tmp_path)
+    descendant = _git(repo, "rev-parse", "HEAD")
+    prepare_class_c_bridge(
+        repo,
+        profile,
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+        impact=CLASS_C_HZZ_IMPACT,
+    )
+    pending = class_c_pending_path(
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+    )
+    new_environment = _authenticated_environment_payload(
+        "macbook_M3",
+        expected_source_revision=descendant,
+        active_runtime=_runtime("d" * 64, source_revision=descendant),
+    )
+
+    def fake_refresh(*_args: object, **_kwargs: object) -> dict[str, str]:
+        (profile / "report_environment.json").write_text(
+            json.dumps(new_environment, sort_keys=True) + "\n",
+            encoding="ascii",
+        )
+        (profile / "report_environment.tex").write_text(
+            _environment_tex(new_environment),
+            encoding="utf-8",
+        )
+        return new_environment
+
+    monkeypatch.setattr(
+        "tools.performance_report.workspace.refresh_profile_environment",
+        fake_refresh,
+    )
+    finalize_class_c_bridge(
+        repo,
+        profile,
+        store,
+        pending_path=pending,
+        expected_active_source_revision=descendant,
+        runtime_auditor=lambda _revision, _root: _runtime(
+            "d" * 64,
+            source_revision=_revision,
+        ),
+    )
+    lineage_path = profile / MEASUREMENT_LINEAGE_FILENAME
+    raw = json.loads(lineage_path.read_text(encoding="ascii"))
+    raw["payload"]["retained_currents"][0]["manifest_sha256"] = "0" * 64
+    lineage_path.write_text(json.dumps(raw) + "\n", encoding="ascii")
+
+    with pytest.raises(MeasurementLineageError, match="canonical digest"):
+        load_measurement_lineage(
+            repo,
+            profile,
+            expected_active_revision=descendant,
+            expected_active_tree=_git(repo, "rev-parse", "HEAD^{tree}"),
+        )
diff --git a/pyamplicol/tests/unit/test_performance_report_measurement_lineage_adversarial.py b/pyamplicol/tests/unit/test_performance_report_measurement_lineage_adversarial.py
new file mode 100644
index 0000000000..69a653dfe3
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_measurement_lineage_adversarial.py
@@ -0,0 +1,1470 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import subprocess
+from pathlib import Path
+
+import pytest
+
+import tools.performance_report.measurement_lineage as measurement_lineage
+from tools.performance_report.artifacts import (
+    ArtifactPolicy,
+    ArtifactStore,
+    ArtifactStoreError,
+)
+from tools.performance_report.cache import digest_json, empty_measurement
+from tools.performance_report.campaign_policy import MACBOOK_M3_POLICY
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.measurement_lineage import (
+    _RECURRENCE_SUMMARY_CAP_ALLOWED_PATHS,
+    CLASS_C_HZZ_IMPACT,
+    CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+    MEASUREMENT_LINEAGE_FILENAME,
+    MeasurementLineageError,
+    _agreement_graph_digest_matches,
+    _is_authorized_native_inputs_transition,
+    _require_environment_transition,
+    _resolve_recurrence_artifact_owner,
+    class_c_pending_path,
+    finalize_class_c_bridge,
+    hzz_agreement_closure,
+    hzz_impacted_cells,
+    load_measurement_lineage,
+    prepare_class_c_bridge,
+    recurrence_summary_cap_agreement_closure,
+    recurrence_summary_cap_impacted_cells,
+    signed_zero_helicity_agreement_closure,
+    signed_zero_helicity_impacted_cells,
+)
+from tools.performance_report.models import ExecutionMode, ModelKey
+from tools.performance_report.scheduler import CampaignScheduler, CampaignSettings
+from tools.performance_report.service import ReportPaths, ReportService
+from tools.performance_report.workspace import (
+    ReportWorkspaceError,
+    _authenticated_environment_payload,
+    _environment_tex,
+    initialize_profile,
+)
+
+
+def _git(repo: Path, *arguments: str) -> str:
+    return subprocess.run(
+        ("git", *arguments),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+
+def _write(repo: Path, relative: str, value: str | bytes) -> None:
+    path = repo / relative
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if isinstance(value, bytes):
+        path.write_bytes(value)
+    else:
+        path.write_text(value, encoding="utf-8")
+
+
+def _lineage_digest(value: object) -> str:
+    encoded = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    )
+    return hashlib.sha256(f"{encoded}\n".encode("ascii")).hexdigest()
+
+
+def _runtime(
+    package_tree: str,
+    *,
+    source_revision: str = "e" * 40,
+    fingerprint: str = "candidate-fixture",
+    native_build_inputs: str = "a" * 64,
+) -> dict:
+    return {
+        "package_version": "0.1.0",
+        "native_build_inputs_sha256": native_build_inputs,
+        "native_extension": {"sha256": "b" * 64},
+        "python_package_tree": {"sha256": package_tree},
+        "candidate_build_identity": {
+            "candidate_fingerprint": fingerprint,
+            "source_revision": source_revision,
+        },
+        "native_target": {
+            "triple": "aarch64-apple-darwin",
+            "cpu_features": ["neon"],
+        },
+    }
+
+
+def _validation_failed_result(
+    ancestor: str,
+    ancestor_tree: str,
+    artifact_root: Path,
+    *,
+    failure_kind: str = "MeasurementValidationError",
+) -> dict[str, object]:
+    observations = [{"module": "fixture", "origin": "authenticated"}]
+    origin_policy = {
+        "kind": "pyamplicol-loaded-module-origin-policy-v1",
+        "all_loaded_origins_authenticated": True,
+        "native_image_origin_bound": True,
+        "loaded_bytecode_eligible": False,
+        "observed_module_count": len(observations),
+        "observations": observations,
+        "observations_sha256": digest_json(observations),
+    }
+    identity = {"loaded_module_origin_policy": origin_policy}
+    identity_sha256 = digest_json(identity)
+    stable_policy = {
+        key: value
+        for key, value in origin_policy.items()
+        if key
+        not in {
+            "observed_module_count",
+            "observations",
+            "observations_sha256",
+        }
+    }
+    stable_identity_sha256 = digest_json({"loaded_module_origin_policy": stable_policy})
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": "validation_failed",
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0,
+            "execution_seconds_per_point": 1.0,
+            "matrix_element": 4.0,
+            "sample_count": 1,
+            "standard_error_seconds_per_point": 0.1,
+            "relative_standard_error": 0.1,
+            "artifact": {
+                "path": str(artifact_root),
+                "process_id": "fixture-process",
+                "policy": "generated",
+            },
+            "validation": {
+                "status": "validation_failed",
+                "resolved_sum": {
+                    "status": "ok",
+                    "maximum_absolute_difference": 0.0,
+                    "maximum_relative_difference": 0.0,
+                    "relative_tolerance": 1.0e-12,
+                    "absolute_tolerance": 1.0e-15,
+                },
+                "pointwise": {
+                    "status": "validation_failed",
+                    "candidate": 4.0,
+                    "baseline": 1.0,
+                    "absolute_difference": 3.0,
+                    "relative_difference": 3.0,
+                    "relative_tolerance": 1.0e-12,
+                    "absolute_tolerance": 1.0e-15,
+                },
+                "direct_agreements": [],
+            },
+            "provenance": {
+                "report_source_revision": ancestor,
+                "report_source_tree": ancestor_tree,
+                "report_measured_source_revision": ancestor,
+                "report_measured_source_tree": ancestor_tree,
+                "runtime_identity": identity,
+                "runtime_identity_sha256": identity_sha256,
+                "runtime_identity_stable_sha256": stable_identity_sha256,
+                "runtime_identity_postflight_stable_sha256": (stable_identity_sha256),
+                "runtime_identity_postflight_loaded_module_origin_policy": (
+                    origin_policy
+                ),
+                "runtime_identity_postflight_match": True,
+            },
+            "failure": {
+                "kind": failure_kind,
+                "message": "candidate or same-artifact numerical validation failed",
+            },
+        }
+    )
+    return measurement
+
+
+_SUMMARY_CAP_FAILURE_BYTES = {
+    "matrix-recurrence-builtin-sm-lc-n7-gg-gluons-selected-flow": 4_270_140,
+    "matrix-recurrence-builtin-sm-lc-n8-dd-tt-jets-selected-flow": 1_083_926,
+    "matrix-recurrence-builtin-sm-lc-n9-dd-z-jets-selected-flow": 4_449_888,
+    "matrix-recurrence-builtin-sm-lc-n9-ud-w-jets-selected-flow": 4_449_912,
+}
+_SUMMARY_CAP_DIFF_PATHS = tuple(
+    sorted(_RECURRENCE_SUMMARY_CAP_ALLOWED_PATHS)
+)
+
+
+def _summary_cap_failure(summary_bytes: int) -> dict[str, object]:
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": "error",
+            "failure": {
+                "kind": "GenerationError",
+                "message": (
+                    "Rust recurrence execution summary must be smaller than "
+                    f"1 MiB; received {summary_bytes} bytes"
+                ),
+            },
+        }
+    )
+    return measurement
+
+
+def _summary_cap_repository(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> tuple[Path, Path, ArtifactStore, str, str]:
+    repo, profile, store, predecessor_ancestor, ancestor = _repository(tmp_path)
+    monkeypatch.setattr(
+        "tools.performance_report.measurement_lineage."
+        "_RECURRENCE_SUMMARY_CAP_PREDECESSOR_REVISION",
+        predecessor_ancestor,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.measurement_lineage."
+        "_RECURRENCE_SUMMARY_CAP_ANCESTOR_REVISION",
+        ancestor,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.measurement_lineage."
+        "_RECURRENCE_SUMMARY_CAP_PROFILE",
+        profile.name,
+    )
+    predecessor_pending = _prepare(
+        repo,
+        profile,
+        store,
+        predecessor_ancestor,
+        ancestor,
+    )
+    _finalize(
+        monkeypatch,
+        repo,
+        profile,
+        store,
+        ancestor,
+        predecessor_pending,
+    )
+    ancestor_tree = _git(repo, "rev-parse", "HEAD^{tree}")
+    retained = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        and store.load_current(cell.cell_id, missing_ok=True) is None
+    )
+    store.new_attempt(retained.cell_id, ArtifactPolicy.REGENERATE).publish(
+        {
+            "status": "ok",
+            "provenance": {
+                "report_source_revision": ancestor,
+                "report_source_tree": ancestor_tree,
+                "report_measured_source_revision": ancestor,
+                "report_measured_source_tree": ancestor_tree,
+            },
+        }
+    )
+    closure_current_id = (
+        "matrix-recurrence-builtin-sm-lc-n7-gg-gluons-all-flow"
+    )
+    store.new_attempt(
+        closure_current_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(
+        {
+            "status": "ok",
+            "provenance": {
+                "report_source_revision": ancestor,
+                "report_source_tree": ancestor_tree,
+                "report_measured_source_revision": ancestor,
+                "report_measured_source_tree": ancestor_tree,
+            },
+        }
+    )
+    for cell_id, summary_bytes in sorted(_SUMMARY_CAP_FAILURE_BYTES.items()):
+        store.new_attempt(cell_id, ArtifactPolicy.REGENERATE).publish(
+            _summary_cap_failure(summary_bytes)
+        )
+    excluded = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.cell_id not in _SUMMARY_CAP_FAILURE_BYTES
+        and cell.cell_id != closure_current_id
+    )
+    store.new_attempt(excluded.cell_id, ArtifactPolicy.REGENERATE).publish(
+        _summary_cap_failure(99)
+    )
+    for path in _SUMMARY_CAP_DIFF_PATHS:
+        _write(repo, path, "DESCENDANT = 2\n")
+    _git(repo, "add", *_SUMMARY_CAP_DIFF_PATHS)
+    _git(repo, "commit", "-q", "-m", "descendant")
+    descendant = _git(repo, "rev-parse", "HEAD")
+    monkeypatch.setattr(
+        "tools.performance_report.measurement_lineage."
+        "_RECURRENCE_SUMMARY_CAP_DESCENDANT_REVISION",
+        descendant,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.measurement_lineage."
+        "_RECURRENCE_SUMMARY_CAP_ANCESTOR_NATIVE_INPUTS_SHA256",
+        "a" * 64,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.measurement_lineage."
+        "_RECURRENCE_SUMMARY_CAP_DESCENDANT_NATIVE_INPUTS_SHA256",
+        "d" * 64,
+    )
+    return repo, profile, store, ancestor, descendant
+
+
+def _repository(tmp_path: Path) -> tuple[Path, Path, ArtifactStore, str, str]:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git(repo, "init", "-q")
+    _git(repo, "config", "user.email", "lineage@example.invalid")
+    _git(repo, "config", "user.name", "Lineage Test")
+    profile = repo / "docs/performance_reports/macbook_M3"
+    _write(
+        repo,
+        "docs/performance_reports/macbook_M3/report-workspace.json",
+        json.dumps({"campaign_policy": {"name": "fixture"}}) + "\n",
+    )
+    _write(repo, "src/pyamplicol/models/builtin/lowering.py", "VALUE = 1\n")
+    feature_paths = (
+        "tests/unit/test_model_builtin.py",
+        "tests/unit/test_packaged_prepared_model.py",
+        "tests/unit/test_recurrence_catalog_builder.py",
+    )
+    for path in feature_paths:
+        _write(repo, path, "VALUE = 1\n")
+    for root in (
+        "src/pyamplicol/assets/prepared_models",
+        "release_assets/prepared_models",
+    ):
+        for architecture in ("aarch64", "x86_64"):
+            stem = f"built-in-sm-jit-o2-{architecture}"
+            _write(repo, f"{root}/{stem}.pyamplicol-model", b"old bundle\n")
+            _write(repo, f"{root}/{stem}.metadata.json", '{"old":true}\n')
+    _git(repo, "add", ".")
+    _git(repo, "commit", "-q", "-m", "ancestor")
+    ancestor = _git(repo, "rev-parse", "HEAD")
+    environment = _authenticated_environment_payload(
+        "macbook_M3",
+        expected_source_revision=ancestor,
+        active_runtime=_runtime("c" * 64, source_revision=ancestor),
+    )
+    _write(
+        repo,
+        "docs/performance_reports/macbook_M3/report_environment.json",
+        json.dumps(environment, sort_keys=True) + "\n",
+    )
+    store = ArtifactStore(
+        artifact_root=repo / ".artifacts/performance-report/macbook_M3",
+        lock_root=repo / ".artifacts/performance-report-coordination/macbook_M3",
+    )
+    retained = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+    )
+    ancestor_tree = _git(repo, "rev-parse", "HEAD^{tree}")
+    store.new_attempt(retained.cell_id, ArtifactPolicy.REGENERATE).publish(
+        {
+            "status": "ok",
+            "provenance": {
+                "report_source_revision": ancestor,
+                "report_source_tree": ancestor_tree,
+                "report_measured_source_revision": ancestor,
+                "report_measured_source_tree": ancestor_tree,
+            },
+        }
+    )
+    _write(repo, "src/pyamplicol/models/builtin/lowering.py", "VALUE = 2\n")
+    for path in feature_paths:
+        _write(repo, path, "VALUE = 2\n")
+    for root in (
+        "src/pyamplicol/assets/prepared_models",
+        "release_assets/prepared_models",
+    ):
+        for architecture in ("aarch64", "x86_64"):
+            stem = f"built-in-sm-jit-o2-{architecture}"
+            _write(repo, f"{root}/{stem}.pyamplicol-model", b"new bundle\n")
+            _write(repo, f"{root}/{stem}.metadata.json", '{"new":true}\n')
+    _git(repo, "add", "src/pyamplicol/models/builtin/lowering.py")
+    _git(repo, "add", "src/pyamplicol/assets/prepared_models")
+    _git(repo, "add", "release_assets/prepared_models")
+    for path in feature_paths:
+        _git(repo, "add", path)
+    _git(repo, "commit", "-q", "-m", "descendant")
+    return repo, profile, store, ancestor, _git(repo, "rev-parse", "HEAD")
+
+
+def _prepare(
+    repo: Path,
+    profile: Path,
+    store: ArtifactStore,
+    ancestor: str,
+    descendant: str,
+) -> Path:
+    prepare_class_c_bridge(
+        repo,
+        profile,
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+        impact=CLASS_C_HZZ_IMPACT,
+    )
+    return class_c_pending_path(
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+    )
+
+
+def _finalize(
+    monkeypatch: pytest.MonkeyPatch,
+    repo: Path,
+    profile: Path,
+    store: ArtifactStore,
+    descendant: str,
+    pending: Path,
+    *,
+    package_tree: str = "d" * 64,
+    native_build_inputs: str = "a" * 64,
+) -> None:
+    environment = _authenticated_environment_payload(
+        profile.name,
+        expected_source_revision=descendant,
+        active_runtime=_runtime(
+            package_tree,
+            source_revision=descendant,
+            native_build_inputs=native_build_inputs,
+        ),
+    )
+
+    def fake_refresh(*_args: object, **_kwargs: object) -> dict[str, str]:
+        (profile / "report_environment.json").write_text(
+            json.dumps(environment, sort_keys=True) + "\n",
+            encoding="ascii",
+        )
+        (profile / "report_environment.tex").write_text(
+            _environment_tex(environment),
+            encoding="utf-8",
+        )
+        return environment
+
+    monkeypatch.setattr(
+        "tools.performance_report.workspace.refresh_profile_environment",
+        fake_refresh,
+    )
+    finalize_class_c_bridge(
+        repo,
+        profile,
+        store,
+        pending_path=pending,
+        expected_active_source_revision=descendant,
+        runtime_auditor=lambda _revision, _root: _runtime(
+            package_tree,
+            source_revision=_revision,
+            native_build_inputs=native_build_inputs,
+        ),
+    )
+
+
+def test_recurrence_summary_cap_native_transition_is_exactly_pinned() -> None:
+    ancestor_revision = "be11d8304fdc04893dc0e23e9619be848126e3bc"
+    descendant_revision = "2594d8b520b802f71d60bd646f73ebaa5547927a"
+    ancestor_digest = (
+        "23b9637d5d3fba0947d78cf688df18799b0c9ee5b3bcbfa6a2963a1f1a21f870"
+    )
+    descendant_digest = (
+        "96e1ff79a007aaf67a0900dd6d67327ee00f6bd2cca002589b879aa3a734de08"
+    )
+    ancestor_environment = _authenticated_environment_payload(
+        "x86_EPYC",
+        expected_source_revision=ancestor_revision,
+        active_runtime=_runtime(
+            "c" * 64,
+            source_revision=ancestor_revision,
+            native_build_inputs=ancestor_digest,
+        ),
+    )
+    descendant_environment = _authenticated_environment_payload(
+        "x86_EPYC",
+        expected_source_revision=descendant_revision,
+        active_runtime=_runtime(
+            "d" * 64,
+            source_revision=descendant_revision,
+            native_build_inputs=descendant_digest,
+        ),
+    )
+
+    _require_environment_transition(
+        impact=CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+        ancestor_revision=ancestor_revision,
+        descendant_revision=descendant_revision,
+        ancestor_environment=ancestor_environment,
+        descendant_environment=descendant_environment,
+    )
+    assert _is_authorized_native_inputs_transition(
+        impact=CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+        ancestor_revision=ancestor_revision,
+        descendant_revision=descendant_revision,
+        ancestor_digest=ancestor_digest,
+        descendant_digest=descendant_digest,
+    )
+
+    for (
+        changed_ancestor,
+        changed_descendant,
+        changed_ancestor_environment,
+        changed_descendant_environment,
+    ) in (
+        (
+            "0" * 40,
+            descendant_revision,
+            ancestor_environment,
+            descendant_environment,
+        ),
+        (
+            ancestor_revision,
+            "1" * 40,
+            ancestor_environment,
+            descendant_environment,
+        ),
+        (
+            ancestor_revision,
+            descendant_revision,
+            {
+                **ancestor_environment,
+                "native_build_inputs_sha256": "2" * 64,
+            },
+            descendant_environment,
+        ),
+        (
+            ancestor_revision,
+            descendant_revision,
+            ancestor_environment,
+            {
+                **descendant_environment,
+                "native_build_inputs_sha256": ancestor_digest,
+            },
+        ),
+        (
+            ancestor_revision,
+            descendant_revision,
+            {
+                **ancestor_environment,
+                "native_build_inputs_sha256": descendant_digest,
+            },
+            {
+                **descendant_environment,
+                "native_build_inputs_sha256": ancestor_digest,
+            },
+        ),
+        (
+            ancestor_revision,
+            descendant_revision,
+            ancestor_environment,
+            {
+                **descendant_environment,
+                "candidate_fingerprint": "unreviewed-native-drift",
+            },
+        ),
+    ):
+        with pytest.raises(
+            MeasurementLineageError,
+            match="exact recurrence-summary-cap transition",
+        ):
+            _require_environment_transition(
+                impact=CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+                ancestor_revision=changed_ancestor,
+                descendant_revision=changed_descendant,
+                ancestor_environment=changed_ancestor_environment,
+                descendant_environment=changed_descendant_environment,
+            )
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="dependency/native/host runtime identity",
+    ):
+        _require_environment_transition(
+            impact=CLASS_C_HZZ_IMPACT,
+            ancestor_revision=ancestor_revision,
+            descendant_revision=descendant_revision,
+            ancestor_environment=ancestor_environment,
+            descendant_environment=descendant_environment,
+        )
+
+
+def test_controller_agreement_transition_is_exactly_lineage_scoped(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    old_digest = "7" * 64
+    new_digest = "4" * 64
+    monkeypatch.setattr(
+        measurement_lineage,
+        "_PRE_ARBITRARY_QUARK_LINES_AGREEMENT_GRAPH_SHA256",
+        old_digest,
+    )
+    monkeypatch.setattr(
+        measurement_lineage,
+        "_ARBITRARY_QUARK_LINES_AGREEMENT_GRAPH_SHA256",
+        new_digest,
+    )
+    exact = {
+        "profile": "x86_EPYC",
+        "impact": CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+        "ancestor_revision": (
+            measurement_lineage._RECURRENCE_SUMMARY_CAP_ANCESTOR_REVISION
+        ),
+        "descendant_revision": (
+            measurement_lineage._RECURRENCE_SUMMARY_CAP_DESCENDANT_REVISION
+        ),
+        "agreement_graph_sha256": old_digest,
+    }
+
+    assert _agreement_graph_digest_matches(exact, old_digest)
+    assert _agreement_graph_digest_matches(exact, new_digest)
+    for changed in (
+        {**exact, "profile": "macbook_M3"},
+        {**exact, "impact": CLASS_C_HZZ_IMPACT},
+        {**exact, "ancestor_revision": "0" * 40},
+        {**exact, "descendant_revision": "1" * 40},
+        {**exact, "agreement_graph_sha256": "2" * 64},
+    ):
+        assert not _agreement_graph_digest_matches(changed, new_digest)
+    assert not _agreement_graph_digest_matches(exact, "3" * 64)
+
+
+def test_recurrence_summary_cap_bridge_has_exact_failure_and_closure_census(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo, profile, store, ancestor, descendant = _summary_cap_repository(
+        tmp_path,
+        monkeypatch,
+    )
+    prepared = prepare_class_c_bridge(
+        repo,
+        profile,
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+        impact=CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+    )
+
+    impacted_ids = {
+        cell.cell_id for cell in recurrence_summary_cap_impacted_cells()
+    }
+    closure_ids = {
+        cell.cell_id for cell in recurrence_summary_cap_agreement_closure()
+    }
+    signed_zero_ids = {
+        cell.cell_id for cell in signed_zero_helicity_impacted_cells()
+    }
+    signed_zero_closure_ids = {
+        cell.cell_id for cell in signed_zero_helicity_agreement_closure()
+    }
+    certificate = prepared["reachability_certificate"]
+    assert isinstance(certificate, dict)
+    assert impacted_ids == set(_SUMMARY_CAP_FAILURE_BYTES)
+    assert len(closure_ids) == 12
+    assert not impacted_ids & closure_ids
+    assert len(signed_zero_ids) == 24
+    assert len(signed_zero_closure_ids) == 42
+    assert not (impacted_ids | closure_ids) & (
+        signed_zero_ids | signed_zero_closure_ids
+    )
+    assert {
+        str(cell["cell_id"]) for cell in prepared["impacted_cells"]
+    } == impacted_ids | signed_zero_ids
+    assert {
+        str(cell["cell_id"])
+        for cell in prepared["agreement_closure_cells"]
+    } == closure_ids | signed_zero_closure_ids
+    assert certificate["target_summary_bytes"] == _SUMMARY_CAP_FAILURE_BYTES
+    assert certificate["inspected_current_count"] == 8
+    assert certificate["successful_current_count"] == 3
+    assert certificate["excluded_non_success_current_count"] == 1
+    assert len(certificate["predecessor"]["retained_currents"]) == 1
+    assert {
+        str(record["cell_id"]) for record in certificate["records"]
+    } == impacted_ids
+    assert {
+        str(pin["cell_id"]) for pin in prepared["invalidated_currents"]
+    } == impacted_ids
+    assert len(prepared["retained_currents"]) == 2
+    assert [
+        pin["cell_id"] for pin in prepared["recompare_currents"]
+    ] == ["matrix-recurrence-builtin-sm-lc-n7-gg-gluons-all-flow"]
+
+    pending = class_c_pending_path(
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+    )
+    historical_graph = measurement_lineage._agreement_digest(REPORT_CATALOG)
+    current_graph = "4" * 64
+    monkeypatch.setattr(
+        measurement_lineage,
+        "_PRE_ARBITRARY_QUARK_LINES_AGREEMENT_GRAPH_SHA256",
+        historical_graph,
+    )
+    monkeypatch.setattr(
+        measurement_lineage,
+        "_ARBITRARY_QUARK_LINES_AGREEMENT_GRAPH_SHA256",
+        current_graph,
+    )
+    monkeypatch.setattr(
+        measurement_lineage,
+        "_agreement_digest",
+        lambda _catalog: current_graph,
+    )
+    _finalize(
+        monkeypatch,
+        repo,
+        profile,
+        store,
+        descendant,
+        pending,
+        package_tree="e" * 64,
+        native_build_inputs="d" * 64,
+    )
+    lineage = load_measurement_lineage(
+        repo,
+        profile,
+        expected_active_revision=descendant,
+        expected_active_tree=_git(repo, "rev-parse", "HEAD^{tree}"),
+    )
+    assert lineage is not None
+    assert lineage.required_descendant_cell_ids == (
+        impacted_ids
+        | closure_ids
+        | signed_zero_ids
+        | signed_zero_closure_ids
+    )
+
+
+def test_recurrence_summary_cap_bridge_rejects_wrong_failure_byte_count(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo, profile, store, ancestor, descendant = _summary_cap_repository(
+        tmp_path,
+        monkeypatch,
+    )
+    cell_id, summary_bytes = next(iter(_SUMMARY_CAP_FAILURE_BYTES.items()))
+    store.new_attempt(cell_id, ArtifactPolicy.REGENERATE).publish(
+        _summary_cap_failure(summary_bytes + 1)
+    )
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="not the authenticated recurrence summary-cap GenerationError",
+    ):
+        prepare_class_c_bridge(
+            repo,
+            profile,
+            store,
+            ancestor_revision=ancestor,
+            descendant_revision=descendant,
+            impact=CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+        )
+
+
+def test_recurrence_summary_cap_bridge_rejects_excluded_current_pointer_change(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo, profile, store, ancestor, descendant = _summary_cap_repository(
+        tmp_path,
+        monkeypatch,
+    )
+    prepared = prepare_class_c_bridge(
+        repo,
+        profile,
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+        impact=CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+    )
+    certificate = prepared["reachability_certificate"]
+    assert isinstance(certificate, dict)
+    excluded = certificate["excluded_non_success_currents"]
+    assert isinstance(excluded, list)
+    assert len(excluded) == 1
+    cell_id = str(excluded[0]["cell_id"])
+    store.new_attempt(cell_id, ArtifactPolicy.REGENERATE).publish(
+        _summary_cap_failure(100)
+    )
+    pending = class_c_pending_path(
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+    )
+    with pytest.raises(
+        MeasurementLineageError,
+        match="certificate changed",
+    ):
+        finalize_class_c_bridge(
+            repo,
+            profile,
+            store,
+            pending_path=pending,
+            expected_active_source_revision=descendant,
+            runtime_auditor=lambda _revision, _root: _runtime(
+                "e" * 64,
+                source_revision=_revision,
+            ),
+        )
+
+
+def test_required_descendant_closure_is_exact_even_without_currents(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo, profile, store, ancestor, descendant = _repository(tmp_path)
+    pending = _prepare(repo, profile, store, ancestor, descendant)
+    _finalize(monkeypatch, repo, profile, store, descendant, pending)
+    lineage = load_measurement_lineage(
+        repo,
+        profile,
+        expected_active_revision=descendant,
+        expected_active_tree=_git(repo, "rev-parse", "HEAD^{tree}"),
+    )
+
+    assert lineage is not None
+    expected = {
+        cell.cell_id for cell in (*hzz_impacted_cells(), *hzz_agreement_closure())
+    }
+    current_ids = {record.cell_id for record in store.recover_current_records()}
+    assert len(expected) == 40
+    assert lineage.required_descendant_cell_ids == expected
+    assert not (expected & current_ids)
+
+
+def test_prepare_partitions_exact_epyc_validation_failures_for_replacement(
+    tmp_path: Path,
+) -> None:
+    repo, profile, store, ancestor, descendant = _repository(tmp_path)
+    ancestor_tree = _git(repo, "rev-parse", f"{ancestor}^{{tree}}")
+    failed_ids = {
+        "matrix-recurrence-builtin-sm-full-n3-dd-zzz-jets-contracted",
+        "matrix-recurrence-builtin-sm-lc-n3-dd-zzz-jets-selected-flow",
+    }
+    for cell_id in sorted(failed_ids):
+        attempt = store.new_attempt(cell_id, ArtifactPolicy.REGENERATE)
+        attempt.write_json("artifact/execution.json", {"fixture": True})
+        attempt.publish(
+            _validation_failed_result(
+                ancestor,
+                ancestor_tree,
+                attempt.root / "artifact",
+            ),
+            artifact_paths=("artifact/execution.json",),
+        )
+
+    prepared = prepare_class_c_bridge(
+        repo,
+        profile,
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+        impact=CLASS_C_HZZ_IMPACT,
+    )
+
+    reachability = prepared["reachability_certificate"]
+    assert isinstance(reachability, dict)
+    assert set(reachability["invalidated_validation_failed_current_ids"]) == failed_ids
+    assert failed_ids == {
+        str(pin["cell_id"]) for pin in prepared["invalidated_currents"]
+    }
+    assert not failed_ids & {
+        str(pin["cell_id"]) for pin in prepared["retained_currents"]
+    }
+
+
+def test_prepare_rejects_validation_failure_outside_hzz_closure(
+    tmp_path: Path,
+) -> None:
+    repo, profile, store, ancestor, descendant = _repository(tmp_path)
+    ancestor_tree = _git(repo, "rev-parse", f"{ancestor}^{{tree}}")
+    outside = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+        and cell.process_key != "dd_zzz_jets"
+    )
+    attempt = store.new_attempt(outside.cell_id, ArtifactPolicy.REGENERATE)
+    attempt.write_json("artifact/execution.json", {"fixture": True})
+    attempt.publish(
+        _validation_failed_result(
+            ancestor,
+            ancestor_tree,
+            attempt.root / "artifact",
+        ),
+        artifact_paths=("artifact/execution.json",),
+    )
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="outside the exact HZZ replacement closure",
+    ):
+        prepare_class_c_bridge(
+            repo,
+            profile,
+            store,
+            ancestor_revision=ancestor,
+            descendant_revision=descendant,
+            impact=CLASS_C_HZZ_IMPACT,
+        )
+
+
+def test_prepare_rejects_wrong_failure_class_inside_hzz_closure(
+    tmp_path: Path,
+) -> None:
+    repo, profile, store, ancestor, descendant = _repository(tmp_path)
+    ancestor_tree = _git(repo, "rev-parse", f"{ancestor}^{{tree}}")
+    cell_id = "matrix-recurrence-builtin-sm-full-n3-dd-zzz-jets-contracted"
+    attempt = store.new_attempt(cell_id, ArtifactPolicy.REGENERATE)
+    attempt.write_json("artifact/execution.json", {"fixture": True})
+    attempt.publish(
+        _validation_failed_result(
+            ancestor,
+            ancestor_tree,
+            attempt.root / "artifact",
+            failure_kind="UnexpectedFailure",
+        ),
+        artifact_paths=("artifact/execution.json",),
+    )
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="not an authenticated numerical-validation failure",
+    ):
+        prepare_class_c_bridge(
+            repo,
+            profile,
+            store,
+            ancestor_revision=ancestor,
+            descendant_revision=descendant,
+            impact=CLASS_C_HZZ_IMPACT,
+        )
+
+
+def test_prepare_rejects_in_closure_failure_runtime_digest_tamper(
+    tmp_path: Path,
+) -> None:
+    repo, profile, store, ancestor, descendant = _repository(tmp_path)
+    ancestor_tree = _git(repo, "rev-parse", f"{ancestor}^{{tree}}")
+    cell_id = "matrix-recurrence-builtin-sm-full-n3-dd-zzz-jets-contracted"
+    attempt = store.new_attempt(cell_id, ArtifactPolicy.REGENERATE)
+    attempt.write_json("artifact/execution.json", {"fixture": True})
+    result = _validation_failed_result(
+        ancestor,
+        ancestor_tree,
+        attempt.root / "artifact",
+    )
+    provenance = result["provenance"]
+    assert isinstance(provenance, dict)
+    provenance["runtime_identity_sha256"] = "0" * 64
+    attempt.publish(result, artifact_paths=("artifact/execution.json",))
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="runtime identity is invalid",
+    ):
+        prepare_class_c_bridge(
+            repo,
+            profile,
+            store,
+            ancestor_revision=ancestor,
+            descendant_revision=descendant,
+            impact=CLASS_C_HZZ_IMPACT,
+        )
+
+
+def test_lineage_rejects_failed_pin_moved_into_retained_group(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo, profile, store, ancestor, descendant = _repository(tmp_path)
+    ancestor_tree = _git(repo, "rev-parse", f"{ancestor}^{{tree}}")
+    cell_id = "matrix-recurrence-builtin-sm-full-n3-dd-zzz-jets-contracted"
+    attempt = store.new_attempt(cell_id, ArtifactPolicy.REGENERATE)
+    attempt.write_json("artifact/execution.json", {"fixture": True})
+    attempt.publish(
+        _validation_failed_result(
+            ancestor,
+            ancestor_tree,
+            attempt.root / "artifact",
+        ),
+        artifact_paths=("artifact/execution.json",),
+    )
+    pending = _prepare(repo, profile, store, ancestor, descendant)
+    _finalize(monkeypatch, repo, profile, store, descendant, pending)
+
+    lineage_path = profile / MEASUREMENT_LINEAGE_FILENAME
+    raw = json.loads(lineage_path.read_text(encoding="ascii"))
+    payload = raw["payload"]
+    failed_pin = next(
+        pin for pin in payload["invalidated_currents"] if pin["cell_id"] == cell_id
+    )
+    payload["invalidated_currents"].remove(failed_pin)
+    payload["retained_currents"].append(failed_pin)
+    payload["retained_currents"].sort(key=lambda pin: pin["cell_id"])
+    snapshot = {
+        field: payload[field]
+        for field in (
+            "retained_currents",
+            "invalidated_currents",
+            "recompare_currents",
+            "attempt_inventory",
+            "no_attempt_cells",
+        )
+    }
+    payload["current_snapshot_sha256"] = _lineage_digest(snapshot)
+    raw["payload_sha256"] = _lineage_digest(payload)
+    lineage_path.write_text(
+        json.dumps(
+            raw,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        + "\n",
+        encoding="ascii",
+    )
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="current groups do not match",
+    ):
+        load_measurement_lineage(
+            repo,
+            profile,
+            expected_active_revision=descendant,
+            expected_active_tree=_git(repo, "rev-parse", "HEAD^{tree}"),
+        )
+
+
+def test_attempt_artifact_byte_tamper_blocks_finalization(tmp_path: Path) -> None:
+    repo, profile, store, ancestor, descendant = _repository(tmp_path)
+    pending = _prepare(repo, profile, store, ancestor, descendant)
+    result_path = store.recover_current_records()[0].result_path
+    result_path.write_bytes(result_path.read_bytes() + b" ")
+
+    with pytest.raises(
+        ArtifactStoreError,
+        match=r"artifact (size|digest) mismatch",
+    ):
+        finalize_class_c_bridge(
+            repo,
+            profile,
+            store,
+            pending_path=pending,
+            expected_active_source_revision=descendant,
+            runtime_auditor=lambda _revision, _root: _runtime(
+                "d" * 64,
+                source_revision=_revision,
+            ),
+        )
+    assert not (profile / MEASUREMENT_LINEAGE_FILENAME).exists()
+
+
+def test_new_orphan_attempt_blocks_finalization(tmp_path: Path) -> None:
+    repo, profile, store, ancestor, descendant = _repository(tmp_path)
+    pending = _prepare(repo, profile, store, ancestor, descendant)
+    no_current = hzz_impacted_cells()[0]
+    store.new_attempt(
+        no_current.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).mark_failed("new orphan attempt")
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="current or attempt state changed",
+    ):
+        finalize_class_c_bridge(
+            repo,
+            profile,
+            store,
+            pending_path=pending,
+            expected_active_source_revision=descendant,
+            runtime_auditor=lambda _revision, _root: _runtime(
+                "d" * 64,
+                source_revision=_revision,
+            ),
+        )
+    assert not (profile / MEASUREMENT_LINEAGE_FILENAME).exists()
+
+
+def test_failed_refresh_rolls_back_environment_and_lineage_bytes(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo, profile, store, ancestor, descendant = _repository(tmp_path)
+    pending = _prepare(repo, profile, store, ancestor, descendant)
+    json_path = profile / "report_environment.json"
+    tex_path = profile / "report_environment.tex"
+    lineage_path = profile / MEASUREMENT_LINEAGE_FILENAME
+    tex_path.write_bytes(b"exact ancestor tex bytes\n")
+    lineage_path.write_bytes(b"exact prior lineage bytes\n")
+    before = {path: path.read_bytes() for path in (json_path, tex_path, lineage_path)}
+    expected = _authenticated_environment_payload(
+        "macbook_M3",
+        expected_source_revision=descendant,
+        active_runtime=_runtime("d" * 64, source_revision=descendant),
+    )
+
+    def corrupting_refresh(*_args: object, **_kwargs: object) -> dict[str, str]:
+        json_path.write_bytes(b"corrupt environment\n")
+        tex_path.write_bytes(b"corrupt tex\n")
+        lineage_path.write_bytes(b"corrupt lineage\n")
+        returned = dict(expected)
+        returned["candidate_fingerprint"] = "mutated-after-authentication"
+        return returned
+
+    monkeypatch.setattr(
+        "tools.performance_report.workspace.refresh_profile_environment",
+        corrupting_refresh,
+    )
+    with pytest.raises(
+        MeasurementLineageError,
+        match="written descendant environment differs",
+    ):
+        finalize_class_c_bridge(
+            repo,
+            profile,
+            store,
+            pending_path=pending,
+            expected_active_source_revision=descendant,
+            runtime_auditor=lambda _revision, _root: _runtime(
+                "d" * 64,
+                source_revision=_revision,
+            ),
+        )
+
+    assert {path: path.read_bytes() for path in before} == before
+
+
+def test_environment_projects_only_candidate_fingerprint() -> None:
+    first = _runtime("d" * 64)
+    second = _runtime("d" * 64)
+    first["candidate_build_identity"]["host_checkout"] = "/private/host/one"
+    first["candidate_build_identity"]["nested"] = {"digest": "1" * 64}
+    second["candidate_build_identity"]["host_checkout"] = "/other/host/two"
+    second["candidate_build_identity"]["nested"] = {"digest": "2" * 64}
+
+    left = _authenticated_environment_payload(
+        "macbook_M3",
+        expected_source_revision="e" * 40,
+        active_runtime=first,
+    )
+    right = _authenticated_environment_payload(
+        "macbook_M3",
+        expected_source_revision="e" * 40,
+        active_runtime=second,
+    )
+
+    assert left == right
+    assert left["candidate_fingerprint"] == "candidate-fixture"
+    assert "/private/host" not in json.dumps(left)
+
+
+def test_non_reset_profile_clone_rejects_source_lineage(tmp_path: Path) -> None:
+    repo, profile, _store, _ancestor, _descendant = _repository(tmp_path)
+    (profile / MEASUREMENT_LINEAGE_FILENAME).write_text("{}\n", encoding="ascii")
+
+    with pytest.raises(
+        ReportWorkspaceError,
+        match=r"mixed Class-C source lineage.*reset_measurements=True",
+    ):
+        initialize_profile(
+            repo,
+            "x86_EPYC",
+            source_profile="macbook_M3",
+            reset_measurements=False,
+        )
+    assert not (repo / "docs/performance_reports/x86_EPYC").exists()
+
+
+def test_scheduler_rejects_mixed_source_without_lineage_before_attempt(
+    tmp_path: Path,
+) -> None:
+    repo, _profile, store, _ancestor, _descendant = _repository(tmp_path)
+    before = tuple(store.artifact_root.rglob("manifest.json"))
+    policy = MACBOOK_M3_POLICY
+    settings = CampaignSettings(
+        workers=policy.workers or 1,
+        cell_cores=policy.cell_cores or 1,
+        target_runtime_seconds=policy.target_runtime_seconds,
+        max_rss_bytes=policy.memory_limit_bytes,
+        campaign_policy=policy,
+        report_profile="macbook_M3",
+    )
+    service = ReportService(ReportPaths.from_repo(repo, profile="macbook_M3"))
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="mixed/ancestor measurements but no authenticated measurement lineage",
+    ):
+        CampaignScheduler(service, settings=settings)
+
+    assert tuple(store.artifact_root.rglob("manifest.json")) == before
+
+
+def _runtime_digest(value: object) -> str:
+    return hashlib.sha256(
+        json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+
+
+def _owner_provenance(
+    *,
+    observation_path: str,
+    revision: str = "a" * 40,
+    tree: str = "b" * 40,
+) -> dict[str, object]:
+    observations = [{"path": observation_path}]
+    policy = {
+        "kind": "fixture-loaded-origin-policy",
+        "authenticated": True,
+        "observed_module_count": len(observations),
+        "observations": observations,
+        "observations_sha256": _runtime_digest(observations),
+    }
+    identity = {
+        "kind": "fixture-runtime-identity",
+        "artifact_id": "shared-artifact",
+        "loaded_module_origin_policy": policy,
+    }
+    stable_identity = dict(identity)
+    stable_policy = dict(policy)
+    for field in (
+        "observed_module_count",
+        "observations",
+        "observations_sha256",
+    ):
+        stable_policy.pop(field)
+    stable_identity["loaded_module_origin_policy"] = stable_policy
+    stable_digest = _runtime_digest(stable_identity)
+    return {
+        "report_source_revision": revision,
+        "report_source_tree": tree,
+        "report_measured_source_revision": revision,
+        "report_measured_source_tree": tree,
+        "runtime_identity": identity,
+        "runtime_identity_sha256": _runtime_digest(identity),
+        "runtime_identity_stable_sha256": stable_digest,
+        "runtime_identity_postflight_stable_sha256": stable_digest,
+        "runtime_identity_postflight_match": True,
+    }
+
+
+def _owner_cells() -> tuple[object, object]:
+    consumer = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id.startswith("z_")
+        and cell.n_final == 1
+        and cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+    )
+    owners = tuple(
+        cell
+        for cell in REPORT_CATALOG.equivalent_cells(consumer)
+        if cell.dataset_id.startswith("matrix_")
+    )
+    assert len(owners) == 1
+    return consumer, owners[0]
+
+
+def _publish_owned_artifact(
+    store: ArtifactStore,
+    cell_id: str,
+    *,
+    observation_path: str,
+    payload: bytes = b"authenticated artifact payload\n",
+) -> tuple[object, Path]:
+    attempt = store.new_attempt(cell_id, ArtifactPolicy.REGENERATE)
+    artifact_file = attempt.path("artifact/payload.bin")
+    artifact_file.write_bytes(payload)
+    artifact_root = artifact_file.parent
+    record = attempt.publish(
+        {
+            "status": "ok",
+            "artifact": {
+                "path": str(artifact_root),
+                "process_id": "fixture-process",
+            },
+            "provenance": _owner_provenance(
+                observation_path=observation_path,
+            ),
+        },
+        artifact_paths=("artifact/payload.bin",),
+    )
+    return record, artifact_root.resolve(strict=True)
+
+
+def _publish_artifact_consumer(
+    store: ArtifactStore,
+    cell_id: str,
+    artifact_root: Path,
+) -> object:
+    return store.new_attempt(
+        cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(
+        {
+            "status": "ok",
+            "artifact": {
+                "path": str(artifact_root),
+                "process_id": "fixture-process",
+            },
+            "provenance": _owner_provenance(
+                observation_path="/consumer/runtime.py",
+            ),
+        }
+    )
+
+
+def test_recurrence_reachability_accepts_exact_matrix_peer_artifact_owner(
+    tmp_path: Path,
+) -> None:
+    store = ArtifactStore(
+        artifact_root=tmp_path / "profile/artifacts",
+        lock_root=tmp_path / "profile/locks",
+    )
+    consumer, owner_cell = _owner_cells()
+    owner, artifact_root = _publish_owned_artifact(
+        store,
+        owner_cell.cell_id,
+        observation_path="/owner/runtime.py",
+    )
+    consumer_record = _publish_artifact_consumer(
+        store,
+        consumer.cell_id,
+        artifact_root,
+    )
+
+    evidence = _resolve_recurrence_artifact_owner(
+        store,
+        REPORT_CATALOG,
+        consumer_record,
+        consumer,
+        artifact_root,
+        "fixture-process",
+    )
+
+    assert evidence["relation"] == "equivalent-matrix-peer"
+    assert evidence["consumer_cell_id"] == consumer.cell_id
+    assert evidence["owner_cell_id"] == owner_cell.cell_id
+    assert evidence["owner_attempt_id"] == owner.attempt_id
+    assert evidence["owner_current_locator"].endswith("/current.json")
+    assert (
+        evidence["consumer_runtime_identity_sha256"]
+        != (evidence["owner_runtime_identity_sha256"])
+    )
+    assert (
+        evidence["consumer_runtime_identity_stable_sha256"]
+        == (evidence["owner_runtime_identity_stable_sha256"])
+    )
+
+
+def test_recurrence_reachability_rejects_foreign_artifact_owner(
+    tmp_path: Path,
+) -> None:
+    store = ArtifactStore(
+        artifact_root=tmp_path / "profile/artifacts",
+        lock_root=tmp_path / "profile/locks",
+    )
+    consumer, owner_cell = _owner_cells()
+    _publish_owned_artifact(
+        store,
+        owner_cell.cell_id,
+        observation_path="/owner/runtime.py",
+    )
+    foreign_cell = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id.startswith("matrix_")
+        and cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.model is ModelKey.BUILTIN_SM
+        and cell.process_key != consumer.process_key
+    )
+    _foreign, foreign_root = _publish_owned_artifact(
+        store,
+        foreign_cell.cell_id,
+        observation_path="/foreign/runtime.py",
+    )
+    consumer_record = _publish_artifact_consumer(
+        store,
+        consumer.cell_id,
+        foreign_root,
+    )
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="not owned by its matrix peer",
+    ):
+        _resolve_recurrence_artifact_owner(
+            store,
+            REPORT_CATALOG,
+            consumer_record,
+            consumer,
+            foreign_root,
+            "fixture-process",
+        )
+
+
+def test_recurrence_reachability_rejects_owner_artifact_hash_drift(
+    tmp_path: Path,
+) -> None:
+    store = ArtifactStore(
+        artifact_root=tmp_path / "profile/artifacts",
+        lock_root=tmp_path / "profile/locks",
+    )
+    consumer, owner_cell = _owner_cells()
+    _owner, artifact_root = _publish_owned_artifact(
+        store,
+        owner_cell.cell_id,
+        observation_path="/owner/runtime.py",
+    )
+    consumer_record = _publish_artifact_consumer(
+        store,
+        consumer.cell_id,
+        artifact_root,
+    )
+    (artifact_root / "payload.bin").write_bytes(b"altered after publication\n")
+
+    with pytest.raises(
+        MeasurementLineageError,
+        match="owner current is invalid",
+    ):
+        _resolve_recurrence_artifact_owner(
+            store,
+            REPORT_CATALOG,
+            consumer_record,
+            consumer,
+            artifact_root,
+            "fixture-process",
+        )
diff --git a/pyamplicol/tests/unit/test_performance_report_phase_state.py b/pyamplicol/tests/unit/test_performance_report_phase_state.py
new file mode 100644
index 0000000000..3b72286b49
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_phase_state.py
@@ -0,0 +1,139 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from contextlib import contextmanager
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.phase_state import (
+    WorkerPhaseChannel,
+    WorkerPhaseReporter,
+    WorkerPhaseStateError,
+    read_worker_phase_state,
+)
+
+
+class NanosecondClock:
+    def __init__(self) -> None:
+        self.now = 1_000_000_000
+
+    def __call__(self) -> int:
+        return self.now
+
+
+def test_reporter_publishes_authenticated_atomic_phase_boundaries(
+    tmp_path: Path,
+) -> None:
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    clock = NanosecondClock()
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=42,
+        clock_ns=clock,
+        track_post_generation_stages=True,
+    )
+
+    pre = read_worker_phase_state(channel, expected_pid=42)
+    assert (pre.sequence, pre.phase) == (0, "pre-generation")
+    assert pre.generation_elapsed_seconds(now_seconds=50.0) is None
+
+    phase = reporter.generation()
+    clock.now = 2_000_000_000
+    phase.__enter__()
+    active = read_worker_phase_state(channel, expected_pid=42)
+    assert (active.sequence, active.phase) == (1, "generation")
+    assert active.generation_elapsed_seconds(now_seconds=3.25) == 1.25
+
+    clock.now = 3_500_000_000
+    phase.__exit__(None, None, None)
+    post = read_worker_phase_state(channel, expected_pid=42)
+    assert (post.sequence, post.phase) == (2, "post-generation")
+    assert post.generation_elapsed_seconds(now_seconds=500.0) == 1.5
+    assert not list(tmp_path.glob("*.tmp"))
+
+    clock.now = 4_000_000_000
+    reporter.profiling_started()
+    profiling = read_worker_phase_state(channel, expected_pid=42)
+    assert (profiling.sequence, profiling.phase) == (3, "profiling")
+    assert profiling.generation_elapsed_seconds(now_seconds=500.0) == 1.5
+    assert profiling.stage_elapsed_seconds("profiling", now_seconds=4.25) == 0.25
+    assert profiling.stage_elapsed_seconds("validation", now_seconds=4.25) is None
+
+    clock.now = 5_000_000_000
+    reporter.validation_started()
+    validation = read_worker_phase_state(channel, expected_pid=42)
+    assert (validation.sequence, validation.phase) == (4, "validation")
+    assert validation.stage_elapsed_seconds("profiling", now_seconds=500.0) == 1.0
+    assert validation.stage_elapsed_seconds("validation", now_seconds=5.5) == 0.5
+
+    clock.now = 6_000_000_000
+    reporter.complete()
+    complete = read_worker_phase_state(channel, expected_pid=42)
+    assert (complete.sequence, complete.phase) == (5, "complete")
+    assert complete.stage_elapsed_seconds("profiling", now_seconds=500.0) == 1.0
+    assert complete.stage_elapsed_seconds("validation", now_seconds=500.0) == 1.0
+
+    with (
+        pytest.raises(WorkerPhaseStateError, match="exactly one"),
+        reporter.generation(),
+    ):
+        pass
+
+
+def test_phase_state_rejects_tampering_wrong_pid_and_malformed_fields(
+    tmp_path: Path,
+) -> None:
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    WorkerPhaseReporter(channel, worker_pid=42, clock_ns=lambda: 1)
+
+    with pytest.raises(WorkerPhaseStateError, match="PID"):
+        read_worker_phase_state(channel, expected_pid=41)
+
+    payload = json.loads(channel.path.read_text(encoding="ascii"))
+    payload["phase"] = "generation"
+    channel.path.write_text(json.dumps(payload), encoding="ascii")
+    with pytest.raises(WorkerPhaseStateError, match="authentication"):
+        read_worker_phase_state(channel, expected_pid=42)
+
+    channel.path.write_text('{"abi":"incomplete"}\n', encoding="ascii")
+    with pytest.raises(WorkerPhaseStateError, match="fields"):
+        read_worker_phase_state(channel, expected_pid=42)
+
+
+def test_generation_gate_is_released_before_profiling_and_validation(
+    tmp_path: Path,
+) -> None:
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    events: list[str] = []
+
+    @contextmanager
+    def gate():
+        events.append("gate-enter")
+        try:
+            yield
+        finally:
+            state = read_worker_phase_state(channel, expected_pid=42)
+            events.append(f"gate-exit-{state.phase}")
+
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=42,
+        clock_ns=lambda: 1,
+        track_post_generation_stages=True,
+        generation_gate=gate,
+    )
+    with reporter.generation():
+        events.append("generation")
+    reporter.profiling_started()
+    events.append("profiling")
+    reporter.validation_started()
+    reporter.complete()
+
+    assert events == [
+        "gate-enter",
+        "generation",
+        "gate-exit-post-generation",
+        "profiling",
+    ]
diff --git a/pyamplicol/tests/unit/test_performance_report_phase_timeline.py b/pyamplicol/tests/unit/test_performance_report_phase_timeline.py
new file mode 100644
index 0000000000..fdfc6bb916
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_phase_timeline.py
@@ -0,0 +1,143 @@
+# SPDX-License-Identifier: 0BSD
+"""Phase-timeline evidence must remain direct, typed, and reusable."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.phase_timeline import (
+    PHASE_TIMELINE_SCHEMA,
+    build_phase_timeline,
+)
+
+
+def _rows(timeline: dict[str, object]) -> dict[str, dict[str, object]]:
+    entries = timeline["entries"]
+    assert isinstance(entries, list)
+    return {str(entry["key"]): entry for entry in entries if isinstance(entry, dict)}
+
+
+def test_pyamplicol_timeline_keeps_only_direct_phase_clocks(tmp_path: Path) -> None:
+    progress = tmp_path / "worker-progress.jsonl"
+    events = (
+        {
+            "event": "start",
+            "task_id": "generation:validation",
+            "parent_task_id": "generation",
+            "description": "Validating generated artifact",
+        },
+        {
+            "event": "end",
+            "task_id": "generation:validation",
+            "success": True,
+            "elapsed_seconds": 0.125,
+        },
+    )
+    progress.write_text(
+        "".join(f"{json.dumps(event)}\n" for event in events),
+        encoding="utf-8",
+    )
+    result = {
+        "status": "ok",
+        "generation_seconds": 4.5,
+        "validation": {"status": "ok"},
+        "resources": {
+            "wall_seconds": 9.0,
+            "cpu_seconds": 7.0,
+            "peak_rss_bytes": 123,
+            "peak_guard_bytes": 456,
+        },
+        "provenance": {
+            "model_preparation_seconds": 0.25,
+            "model_preparation_reused": False,
+            "runtime_profile": {
+                "warmup_elapsed_seconds": 0.5,
+                "calibration_outer_elapsed_seconds": 0.75,
+                "measurement_phase_elapsed_seconds": 2.0,
+                "achieved_runtime_seconds": 1.8,
+                "profile_attribution_elapsed_seconds": 1.0,
+                "profile_total_elapsed_seconds": 4.25,
+                "completed_sample_count": 12,
+                "calibration_block_count": 3,
+            },
+            "manual_campaign": {
+                "cell_identity": {"execution_mode": "recurrence"},
+            },
+        },
+    }
+
+    timeline = build_phase_timeline(result, progress_path=progress)
+    rows = _rows(timeline)
+
+    assert timeline["schema"] == PHASE_TIMELINE_SCHEMA
+    assert rows["generation"]["seconds"] == pytest.approx(4.5)
+    assert rows["generation-step:validation"]["seconds"] == pytest.approx(0.125)
+    assert rows["generation-step:validation"]["included_in"] == "generation"
+    assert rows["runtime-warmup"]["seconds"] == pytest.approx(0.5)
+    assert rows["runtime-calibration"]["detail"] == "3 blocks"
+    assert rows["runtime-measurement"]["seconds"] == pytest.approx(1.8)
+    assert rows["runtime-measurement"]["detail"] == "12 samples"
+    assert rows["runtime-attribution"]["seconds"] == pytest.approx(1.0)
+    assert rows["runtime-profile-total"]["seconds"] == pytest.approx(4.25)
+    assert rows["attempt-publication"]["seconds"] is None
+    assert "not separately timed" in str(rows["attempt-publication"]["detail"])
+    assert timeline["total_worker_wall_seconds"] == pytest.approx(9.0)
+    assert timeline["peak_guard_bytes"] == 456
+
+
+def test_legacy_timeline_marks_calibration_not_applicable() -> None:
+    result = {
+        "status": "ok",
+        "generation_seconds": 2.0,
+        "validation": None,
+        "resources": {},
+        "provenance": {
+            "runtime_profile": {
+                "warmup": {"elapsed_seconds": 0.2},
+                "measurement": {
+                    "achieved_runtime_seconds": 5.1,
+                    "chunk_count": 8,
+                    "chunks": [
+                        {"elapsed_seconds": 2.6},
+                        {"elapsed_seconds": 2.7},
+                    ],
+                },
+            },
+            "manual_campaign": {
+                "cell_identity": {"execution_mode": "amplicol"},
+            },
+        },
+    }
+
+    rows = _rows(build_phase_timeline(result))
+
+    assert rows["runtime-warmup"]["seconds"] == pytest.approx(0.2)
+    assert rows["runtime-calibration"]["status"] == "not_applicable"
+    assert rows["runtime-calibration"]["seconds"] is None
+    assert rows["runtime-measurement"]["seconds"] == pytest.approx(5.3)
+    assert rows["runtime-measurement"]["detail"] == "8 chunks"
+
+
+def test_missing_phase_clocks_remain_unavailable() -> None:
+    result = {
+        "status": "ok",
+        "generation_seconds": 1.0,
+        "resources": {"wall_seconds": 10.0},
+        "provenance": {
+            "runtime_profile": {"achieved_runtime_seconds": 3.0},
+            "manual_campaign": {
+                "cell_identity": {"execution_mode": "compiled"},
+            },
+        },
+    }
+
+    rows = _rows(build_phase_timeline(result))
+
+    assert rows["runtime-warmup"]["seconds"] is None
+    assert rows["runtime-calibration"]["seconds"] is None
+    assert rows["runtime-attribution"]["seconds"] is None
+    assert rows["runtime-profile-total"]["seconds"] is None
+    assert rows["runtime-measurement"]["seconds"] == pytest.approx(3.0)
diff --git a/pyamplicol/tests/unit/test_performance_report_policy.py b/pyamplicol/tests/unit/test_performance_report_policy.py
new file mode 100644
index 0000000000..6823bd7986
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_policy.py
@@ -0,0 +1,257 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from copy import deepcopy
+from types import SimpleNamespace
+
+from tools.performance_report.arena_profile import (
+    ARENA_PHASE_TIMING_SCOPE,
+    ARENA_PROFILE_BOUNDARY,
+    EMPTY_ARENA_PHASE_VECTOR_FIELDS,
+    ZERO_ARENA_COUNTER_FIELDS,
+    ZERO_ARENA_PHASE_TIME_FIELDS,
+    ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS,
+    build_arena_profile_evidence,
+    digest_arena_profile_value,
+)
+from tools.performance_report.cache import empty_measurement
+from tools.performance_report.report_policy import (
+    publication_measurement_policy_issues,
+    timing_policy_issues,
+)
+from tools.performance_report.runner import _benchmark_measurement
+from tools.performance_report.source_identity import SOURCE_IDENTITY_SCHEMA
+
+
+def _measurement() -> dict[str, object]:
+    revision = "a" * 40
+    tree = "b" * 40
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": "ok",
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 2.0e-6,
+            "execution_seconds_per_point": 1.0e-6,
+            "matrix_element": 3.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 1.0e-9,
+            "relative_standard_error": 1.0e-3,
+            "artifact": {},
+            "selector_contract": None,
+            "validation": {"status": "ok"},
+            "resources": {},
+            "provenance": {
+                "runtime_profile": {
+                    "target_runtime_seconds": 5.0,
+                    "achieved_runtime_seconds": 5.01,
+                    "target_runtime_achieved": True,
+                    "completed_sample_count": 5,
+                    "planned_sample_count": 5,
+                    "interrupted": False,
+                },
+                "report_source_identity_schema": SOURCE_IDENTITY_SCHEMA,
+                "report_source_revision": revision,
+                "report_source_tree": tree,
+                "report_measured_source_revision": revision,
+                "report_measured_source_tree": tree,
+                "report_source_clean": True,
+            },
+            "failure": None,
+        }
+    )
+    return measurement
+
+
+def test_complete_five_second_timing_and_source_identity_pass() -> None:
+    assert publication_measurement_policy_issues(_measurement()) == ()
+
+
+def test_native_benchmark_duration_is_retained_as_publication_evidence() -> None:
+    benchmark = SimpleNamespace(
+        uncertainty=SimpleNamespace(
+            standard_error=1.0e-9,
+            relative_standard_error=1.0e-3,
+        ),
+        effective_config=SimpleNamespace(target_runtime=5.0),
+        wall_time_per_point=2.0e-6,
+        evaluator_time_per_point=1.0e-6,
+        sample_count=5,
+        environment={
+            "elapsed_seconds": 5.02,
+            "completed_sample_count": 5,
+            "planned_sample_count": 5,
+            "repetitions_per_sample": 100,
+            "measured_point_count": 64000,
+            "interrupted": False,
+            "evaluator_time_raw_seconds_per_point": 1.0e-6,
+            "evaluator_time_status": "measured",
+            "evaluator_time_ratio_eligible": True,
+            "evaluator_time_source": (
+                "runtime_profile_core_evaluator_call_time"
+            ),
+            "compiled_direct_arena_active": False,
+            "evaluator_sample_count": 5,
+            "native_profile_points_per_sample": 128,
+            "timing_sample_contract": (
+                "paired_unprofiled_headline_profiled_attribution_v1"
+            ),
+        },
+    )
+
+    result = _benchmark_measurement(benchmark, matrix_element=3.0)
+
+    assert result["benchmark_evidence"] == {
+        "measurement_phase_elapsed_seconds": 5.02,
+        "target_runtime_seconds": 5.0,
+        "achieved_runtime_seconds": 5.02,
+        "target_runtime_achieved": True,
+        "completed_sample_count": 5,
+        "planned_sample_count": 5,
+        "repetitions_per_sample": 100,
+        "measured_point_count": 64000,
+        "interrupted": False,
+    }
+
+
+def test_requested_and_achieved_runtime_are_both_enforced() -> None:
+    measurement = _measurement()
+    runtime = measurement["provenance"]["runtime_profile"]
+    runtime["target_runtime_seconds"] = 1.0
+    runtime["achieved_runtime_seconds"] = 0.2
+    runtime["target_runtime_achieved"] = False
+
+    issues = timing_policy_issues(measurement)
+    fields = {issue.field for issue in issues}
+
+    assert "provenance.runtime_profile.target_runtime_seconds" in fields
+    assert "provenance.runtime_profile.achieved_runtime_seconds" in fields
+    assert "provenance.runtime_profile.target_runtime_achieved" in fields
+
+
+def test_five_timed_samples_are_required() -> None:
+    measurement = _measurement()
+    measurement["sample_count"] = 4
+    runtime = measurement["provenance"]["runtime_profile"]
+    runtime["completed_sample_count"] = 4
+    runtime["planned_sample_count"] = 4
+
+    fields = {issue.field for issue in timing_policy_issues(measurement)}
+
+    assert "sample_count" in fields
+    assert "provenance.runtime_profile.completed_sample_count" in fields
+
+
+def test_unavailable_execution_requires_authenticated_arena_boundary() -> None:
+    measurement = _measurement()
+    measurement["execution_seconds_per_point"] = None
+
+    assert any(
+        issue.field == "execution_seconds_per_point"
+        for issue in timing_policy_issues(measurement)
+    )
+
+    provenance = measurement["provenance"]
+    raw_profile = {
+        "execution_mode": "compiled",
+        "profile_boundary": ARENA_PROFILE_BOUNDARY,
+        "borrowed_flat_input": True,
+        "preallocated_output": True,
+        "phase_timing_scope": ARENA_PHASE_TIMING_SCOPE,
+        "evaluator_timing_available": False,
+        "points": 128,
+        "wall_time_s": 128 * 2.1e-6,
+        "orchestration_time_s": 128 * 2.1e-6,
+        **{field: 0 for field in ZERO_ARENA_COUNTER_FIELDS},
+        **{field: 0.0 for field in ZERO_ARENA_PHASE_TIME_FIELDS},
+        **{field: [] for field in EMPTY_ARENA_PHASE_VECTOR_FIELDS},
+        **{
+            field: 0
+            for field in ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS
+        },
+        "compiled_direct_arena_engine_count": 1,
+        "compiled_direct_arena_call_count": 128,
+        "evaluator_backend_call_count": 128,
+    }
+    arena_evidence = build_arena_profile_evidence(
+        [raw_profile] * 5,
+        execution_mode="compiled",
+        repetitions_per_profile=1,
+        batch_size=128,
+    )
+    provenance["arena_profile_evidence"] = arena_evidence
+    provenance["execution_timing"] = {
+        "abi": "pyamplicol-report-arena-execution-timing-v2",
+        "status": "unavailable",
+        "ratio_eligible": False,
+        "raw_seconds_per_point": None,
+        "sample_count": 5,
+        "native_profile_points_per_sample": 128,
+        "repetitions_per_sample": 1,
+        "batch_size": 128,
+        "sample_contract": (
+            "paired_unprofiled_headline_profiled_attribution_v1"
+        ),
+        "profile_protocol": "arena",
+        "profile_sample_pass": "runtime._profile_arena_repeated",
+        "profile_boundary": (
+            "warmed-direct-arena-borrowed-input-preallocated-output-v1"
+        ),
+        "borrowed_flat_input": True,
+        "preallocated_output": True,
+        "phase_timing_scope": "coarse-arena-boundary-only-v1",
+        "evaluator_timing_available": False,
+        "paired_with_headline": True,
+        "identical_batch": True,
+        "identical_repetitions": True,
+        "execution_mode": "compiled",
+        "warmed_boundary_wall_seconds_per_point": 2.1e-6,
+        "arena_profile_evidence_sha256": digest_arena_profile_value(
+            arena_evidence
+        ),
+    }
+    assert not any(
+        issue.field == "execution_seconds_per_point"
+        for issue in timing_policy_issues(measurement)
+    )
+
+
+def test_zero_execution_is_not_treated_as_an_unavailable_attribution() -> None:
+    measurement = _measurement()
+    measurement["execution_seconds_per_point"] = 0.0
+
+    assert any(
+        issue.field == "execution_seconds_per_point"
+        for issue in timing_policy_issues(measurement)
+    )
+
+
+def test_hardcoded_zero_uncertainty_and_partial_blocks_are_rejected() -> None:
+    measurement = _measurement()
+    measurement["standard_error_seconds_per_point"] = 0.0
+    measurement["relative_standard_error"] = 0.0
+    runtime = measurement["provenance"]["runtime_profile"]
+    runtime["completed_sample_count"] = 4
+    runtime["interrupted"] = True
+
+    fields = {issue.field for issue in timing_policy_issues(measurement)}
+
+    assert "standard_error_seconds_per_point" in fields
+    assert "relative_standard_error" in fields
+    assert "provenance.runtime_profile.completed_sample_count" in fields
+    assert "provenance.runtime_profile.interrupted" in fields
+
+
+def test_missing_or_mismatched_source_tree_is_rejected() -> None:
+    measurement = deepcopy(_measurement())
+    provenance = measurement["provenance"]
+    provenance.pop("report_measured_source_tree")
+    provenance["report_source_clean"] = False
+
+    fields = {
+        issue.field
+        for issue in publication_measurement_policy_issues(measurement)
+    }
+
+    assert "provenance.report_measured_source_tree" in fields
+    assert "provenance.report_source_clean" in fields
diff --git a/pyamplicol/tests/unit/test_performance_report_prepared.py b/pyamplicol/tests/unit/test_performance_report_prepared.py
new file mode 100644
index 0000000000..750b1d717a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_prepared.py
@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.artifacts import ArtifactStore
+from tools.performance_report.models import ModelKey
+from tools.performance_report.prepared import (
+    PUBLIC_MODEL_COMPILE_COMMAND_PATH,
+    PreparedModelError,
+    _PublicCliModelCompiler,
+    ensure_prepared_model,
+    ensure_report_prepared_model,
+    prepared_identity,
+    validate_prepared_record,
+)
+
+
+class Source:
+    def __init__(self) -> None:
+        self.calls = 0
+
+    def compile(self, *, prepared_output: Path, **_kwargs: object) -> object:
+        self.calls += 1
+        prepared_output.write_bytes(b"prepared-bundle")
+        return object()
+
+
+def _identity() -> dict[str, object]:
+    return prepared_identity(
+        model=ModelKey.UFO_SM,
+        backend="jit",
+        jit_optimization_level=2,
+        source_digest="a" * 64,
+        producer_revision="revision",
+    )
+
+
+def test_prepared_bundle_is_built_once_and_reused(tmp_path: Path) -> None:
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+    source = Source()
+    bundle = tmp_path / "prepared" / "ufo.pyamplicol-model"
+
+    with ensure_prepared_model(
+        store=store,
+        bundle_path=bundle,
+        source=source,
+        evaluator=object(),
+        identity=_identity(),
+        model_cache_dir=tmp_path / "model-cache",
+    ) as (path, reused):
+        assert path == bundle
+        assert not reused
+
+    with ensure_prepared_model(
+        store=store,
+        bundle_path=bundle,
+        source=source,
+        evaluator=object(),
+        identity=_identity(),
+        model_cache_dir=tmp_path / "model-cache",
+    ) as (_path, reused):
+        assert reused
+
+    assert source.calls == 1
+    record = validate_prepared_record(bundle, expected_identity=_identity())
+    assert record["bundle_size"] == len(b"prepared-bundle")
+
+
+def test_report_prepared_model_requires_explicit_revision(tmp_path: Path) -> None:
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+
+    with pytest.raises(PreparedModelError, match="explicit producer revision"):
+        ensure_report_prepared_model(
+            store=store,
+            repo_root=tmp_path,
+            worker_cores=1,
+            model=ModelKey.UFO_SM,
+            producer_revision=None,
+        )
+
+
+def test_prepared_bundle_digest_or_identity_mismatch_fails_closed(
+    tmp_path: Path,
+) -> None:
+    store = ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+    source = Source()
+    bundle = tmp_path / "prepared" / "ufo.pyamplicol-model"
+    with ensure_prepared_model(
+        store=store,
+        bundle_path=bundle,
+        source=source,
+        evaluator=object(),
+        identity=_identity(),
+        model_cache_dir=tmp_path / "model-cache",
+    ):
+        pass
+
+    bundle.write_bytes(b"tampered")
+    with pytest.raises(PreparedModelError, match=r"digest|size"):
+        validate_prepared_record(bundle, expected_identity=_identity())
+
+    record_path = bundle.with_suffix(bundle.suffix + ".report.json")
+    record = json.loads(record_path.read_text(encoding="ascii"))
+    record["identity"]["producer_revision"] = "other"
+    record_path.write_text(json.dumps(record), encoding="ascii")
+    with pytest.raises(PreparedModelError, match="identity"):
+        validate_prepared_record(bundle, expected_identity=_identity())
+
+
+@pytest.mark.parametrize("mode", ("recurrence", "compiled"))
+@pytest.mark.parametrize("compress", ("auto", False, True))
+def test_report_model_compiler_uses_public_parse_resolve_dispatch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    mode: str,
+    compress: str | bool,
+) -> None:
+    from dataclasses import replace
+
+    from pyamplicol.config import (
+        EvaluatorBackend,
+        EvaluatorConfig,
+        EvaluatorOptimizationConfig,
+        JITConfig,
+    )
+
+    output = tmp_path / "prepared.pyamplicol-model"
+    evaluator = EvaluatorConfig(
+        backend=EvaluatorBackend.JIT,
+        execution_mode=mode,
+        optimization=EvaluatorOptimizationConfig(cores=3),
+        jit=JITConfig(optimization_level=2, compress=compress),
+    )
+    observed: dict[str, object] = {}
+
+    def fake_dispatch(config, services, progress, *, dry_run):
+        observed.update(
+            {
+                "config": config,
+                "services": services,
+                "progress": progress,
+                "dry_run": dry_run,
+            }
+        )
+        output.write_bytes(b"prepared")
+        return {"output": str(output)}
+
+    monkeypatch.setattr("pyamplicol.cli.handlers.dispatch", fake_dispatch)
+    compiler = _PublicCliModelCompiler("built-in-sm")
+    compiler.compile(
+        cache_dir=tmp_path / "cache",
+        evaluator=evaluator,
+        prepared_output=output,
+    )
+
+    config = observed["config"]
+    assert config.action == "model-compile"
+    assert config.model.source == "built-in-sm"
+    assert config.model.cache_dir == tmp_path / "cache"
+    expected_compression = mode == "compiled" if compress == "auto" else compress
+    assert config.evaluator == replace(
+        evaluator, jit=replace(evaluator.jit, compress=expected_compression)
+    )
+    assert config.evaluator.jit.compress is expected_compression
+    assert observed["dry_run"] is False
+    assert compiler.command_path == PUBLIC_MODEL_COMPILE_COMMAND_PATH
diff --git a/pyamplicol/tests/unit/test_performance_report_publication.py b/pyamplicol/tests/unit/test_performance_report_publication.py
new file mode 100644
index 0000000000..1370007f45
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_publication.py
@@ -0,0 +1,685 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import shlex
+from copy import deepcopy
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.publication import (
+    PORTABLE_CURRENT_REPRODUCTION_RECIPE_ABI,
+    PublicationPortabilityError,
+    materialize_current_value,
+    portable_current_value,
+    portable_publication_value,
+    publication_absolute_paths,
+    publication_measurement_matches_current,
+    resolve_publication_path,
+    resolve_publication_string,
+)
+from tools.performance_report.service import ReportPaths
+
+
+def _paths(tmp_path: Path, profile: str = "macbook_M3") -> ReportPaths:
+    repo = tmp_path / "source"
+    return ReportPaths.from_repo(repo, profile=profile)
+
+
+def _canonical_bytes(value: object) -> bytes:
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+def _digest(value: object) -> str:
+    return hashlib.sha256(_canonical_bytes(value)).hexdigest()
+
+
+def _identity_payload() -> tuple[dict[str, object], dict[str, object]]:
+    observations: list[dict[str, object]] = [
+        {
+            "module": "pyamplicol",
+            "kind": "package-member",
+            "root_index": 0,
+            "path": "__init__.py",
+            "size": 12,
+            "sha256": "a" * 64,
+        },
+        {
+            "module": "pyamplicol._rusticol",
+            "kind": "native-extension",
+            "path": "_rusticol.cpython.so",
+            "size": 34,
+            "sha256": "b" * 64,
+        },
+    ]
+    origin_policy: dict[str, object] = {
+        "kind": "pyamplicol-loaded-module-origin-policy-v1",
+        "all_loaded_origins_authenticated": True,
+        "native_image_origin_bound": True,
+        "loaded_bytecode_eligible": False,
+        "observed_module_count": len(observations),
+        "observations": observations,
+        "observations_sha256": _digest(observations),
+    }
+    candidate = {
+        "source_revision": "c" * 40,
+        "source_checkout": "source-checkout",
+        "native_build_inputs_sha256": "d" * 64,
+    }
+    identity: dict[str, object] = {
+        "kind": "pyamplicol-report-runtime-identity-v1",
+        "candidate_build_identity": candidate,
+        "candidate_build_identity_sha256": _digest(candidate),
+        "python_package_tree": {
+            "kind": "pyamplicol-python-package-tree-v2",
+            "root": "pyamplicol",
+            "roots": ["pyamplicol"],
+            "sha256": "e" * 64,
+        },
+        "native_extension": {
+            "path": "_rusticol.cpython.so",
+            "sha256": "f" * 64,
+        },
+        "loaded_module_origin_policy": origin_policy,
+    }
+    return identity, deepcopy(origin_policy)
+
+
+def test_projection_changes_only_explicit_unhashed_locators_and_preserves_digests(
+    tmp_path: Path,
+) -> None:
+    paths = _paths(tmp_path)
+    runtime_identity, postflight_policy = _identity_payload()
+    candidate = runtime_identity["candidate_build_identity"]
+    assert isinstance(candidate, dict)
+    candidate["source_checkout"] = str(paths.repo_root)
+    runtime_identity["candidate_build_identity_sha256"] = _digest(candidate)
+    package_tree = runtime_identity["python_package_tree"]
+    assert isinstance(package_tree, dict)
+    package_tree["root"] = str(paths.repo_root / "src/pyamplicol")
+    package_tree["roots"] = [str(paths.repo_root / "src/pyamplicol")]
+    native = runtime_identity["native_extension"]
+    assert isinstance(native, dict)
+    native["path"] = str(paths.repo_root / "native/_rusticol.so")
+    initial_policy = runtime_identity["loaded_module_origin_policy"]
+    assert isinstance(initial_policy, dict)
+    initial_observations = initial_policy["observations"]
+    assert isinstance(initial_observations, list)
+    initial_observations[1]["path"] = str(  # type: ignore[index]
+        paths.repo_root / "native/_rusticol.so"
+    )
+    initial_policy["observations_sha256"] = _digest(initial_observations)
+    postflight_observations = postflight_policy["observations"]
+    assert isinstance(postflight_observations, list)
+    postflight_observations[1]["path"] = str(  # type: ignore[index]
+        paths.repo_root / "native/_rusticol.so"
+    )
+    postflight_policy["observations_sha256"] = _digest(postflight_observations)
+    runtime_before = _canonical_bytes(runtime_identity)
+    postflight_before = _canonical_bytes(postflight_policy)
+    payload = {
+        "status": "ok",
+        "artifact": {
+            "path": str(paths.artifact_root / "cells/a/attempts/b/artifact"),
+            "log_path": str(paths.artifact_root / "cells/a/attempts/b/legacy.log"),
+            "standalone": str(
+                paths.artifact_root / "cells/a/attempts/b/artifact/standalone"
+            ),
+        },
+        "provenance": {
+            "installation": "/opt/local/MG5_aMC",
+            "model": {"source_directory": "/opt/local/MG5_aMC/models/sm"},
+            "requested_config": {
+                "model": {
+                    "source": str(paths.repo_root / "models/sm.json"),
+                    "cache_dir": str(paths.repo_root / ".cache/models"),
+                }
+            },
+            "effective_config": {
+                "model": {
+                    "source": str(paths.repo_root / "models/sm.json"),
+                    "cache_dir": str(paths.repo_root / ".cache/models"),
+                }
+            },
+            "worker_log": str(paths.artifact_root / "cells/a/worker.log"),
+            "runtime_identity": runtime_identity,
+            "runtime_identity_sha256": _digest(runtime_identity),
+            "runtime_identity_stable_sha256": _digest(runtime_identity),
+            "runtime_identity_postflight_loaded_module_origin_policy": (
+                postflight_policy
+            ),
+        },
+    }
+
+    portable = portable_publication_value(payload, paths)
+
+    assert isinstance(portable, dict)
+    assert publication_absolute_paths(portable) == ()
+    assert str(portable["artifact"]["path"]).startswith(  # type: ignore[index]
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/"
+    )
+    assert str(portable["artifact"]["standalone"]).startswith(  # type: ignore[index]
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/"
+    )
+    provenance = portable["provenance"]
+    assert isinstance(provenance, dict)
+    assert str(provenance["worker_log"]).startswith(
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/"
+    )
+    assert provenance["installation"] == "${LOCAL_PATH_REDACTED}"
+    assert provenance["model"] == {
+        "source_directory": "${LOCAL_PATH_REDACTED}"
+    }
+    assert _canonical_bytes(provenance["runtime_identity"]) == runtime_before
+    assert (
+        _canonical_bytes(
+            provenance["runtime_identity_postflight_loaded_module_origin_policy"]
+        )
+        == postflight_before
+    )
+    assert (
+        _digest(provenance["runtime_identity"]) == provenance["runtime_identity_sha256"]
+    )
+    retained_identity = provenance["runtime_identity"]
+    assert isinstance(retained_identity, dict)
+    candidate = retained_identity["candidate_build_identity"]
+    assert isinstance(candidate, dict)
+    assert _digest(candidate) == retained_identity["candidate_build_identity_sha256"]
+    origin_policy = retained_identity["loaded_module_origin_policy"]
+    assert isinstance(origin_policy, dict)
+    assert (
+        _digest(origin_policy["observations"]) == origin_policy["observations_sha256"]
+    )
+
+
+def test_projection_is_idempotent_for_a_complete_legacy_locator_shape(
+    tmp_path: Path,
+) -> None:
+    paths = _paths(tmp_path)
+    probe_args = [
+        str(paths.repo_root / "dependencies/legacy/amplicol_color_probe"),
+        "100000",
+        "1",
+        "1",
+        "lc",
+        "/private/tmp/pac-example/processes.txt",
+        "/private/tmp/pac-example/momenta.dat",
+        "-1",
+    ]
+    command = {
+        "args": [
+            str(paths.repo_root / ".venv/bin/python"),
+            str(paths.repo_root / "dependencies/legacy/process_list.py"),
+        ],
+        "cwd": str(paths.artifact_root / "cells/example/artifact"),
+        "environment": {
+            "LD_LIBRARY_PATH": (f"{paths.artifact_root}/lib:/opt/local/lib with spaces")
+        },
+    }
+    profile_command = {
+        "args": probe_args,
+        "cwd": str(paths.artifact_root / "cells/example/artifact"),
+        "environment": dict(command["environment"]),
+    }
+    payload = {
+        "artifact": {
+            "path": str(paths.artifact_root / "cells/example/artifact"),
+            "log_path": str(paths.artifact_root / "cells/example/legacy.log"),
+        },
+        "provenance": {
+            "repository": str(paths.repo_root / "dependencies/legacy"),
+            "commands": [command, profile_command],
+            "runtime_profile": {
+                "measurement": {
+                    **profile_command,
+                    "chunks": [profile_command],
+                },
+                "warmup": profile_command,
+            },
+            "worker_environment": {
+                "LD_LIBRARY_PATH": "/opt/local/lib:/private/tmp/lib",
+                "DYLD_LIBRARY_PATH": None,
+            },
+            "worker_log": str(paths.artifact_root / "cells/example/worker.log"),
+        },
+    }
+
+    once = portable_publication_value(payload, paths)
+    twice = portable_publication_value(once, paths)
+
+    assert once == twice
+    assert publication_absolute_paths(once) == ()
+    assert once["provenance"]["worker_environment"]["LD_LIBRARY_PATH"] == (  # type: ignore[index]
+        "${LOCAL_PATH_REDACTED}"
+    )
+    profile = once["provenance"]["runtime_profile"]  # type: ignore[index]
+    assert profile["measurement"]["args"][5:] == [  # type: ignore[index]
+        "${LOCAL_PATH_REDACTED}",
+        "${LOCAL_PATH_REDACTED}",
+        "-1",
+    ]
+    assert profile["measurement"]["chunks"][0]["args"][5:] == [  # type: ignore[index]
+        "${LOCAL_PATH_REDACTED}",
+        "${LOCAL_PATH_REDACTED}",
+        "-1",
+    ]
+
+
+def test_snapshot_projection_relocates_legacy_structural_proof(
+    tmp_path: Path,
+) -> None:
+    paths = _paths(tmp_path)
+    artifact = paths.artifact_root / "cells/example/attempts/one/artifact"
+    payload = {
+        "entries": [
+            {
+                "measurement": {
+                    "artifact": {
+                        "path": str(artifact),
+                        "legacy_structural_proof": str(
+                            artifact / "legacy-structural-proof.json"
+                        ),
+                    }
+                }
+            }
+        ]
+    }
+
+    portable = portable_publication_value(payload, paths)
+
+    proof = portable["entries"][0]["measurement"]["artifact"][  # type: ignore[index]
+        "legacy_structural_proof"
+    ]
+    assert proof == (
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/"
+        "cells/example/attempts/one/artifact/legacy-structural-proof.json"
+    )
+    assert publication_absolute_paths(portable) == ()
+    assert portable_publication_value(portable, paths) == portable
+
+
+def test_unknown_legacy_argument_position_fails_closed(tmp_path: Path) -> None:
+    paths = _paths(tmp_path)
+
+    with pytest.raises(
+        PublicationPortabilityError,
+        match=r"/provenance/commands/0/args/2",
+    ):
+        portable_publication_value(
+            {
+                "provenance": {
+                    "commands": [
+                        {
+                            "args": [
+                                "probe",
+                                "ordinary-operand",
+                                "/private/tmp/not-a-schema-locator",
+                            ]
+                        }
+                    ]
+                }
+            },
+            paths,
+        )
+
+
+@pytest.mark.parametrize(
+    "value",
+    (
+        "@/private/tmp/secret.bin",
+        r"\\server\share\private\a.dll",
+        "//server/share/private/a.dll",
+        "file:///C:/Users/example/private/a.dll",
+        "unknown=/Users/Alice Smith/private/file.so",
+    ),
+)
+def test_unknown_absolute_path_outside_allowlist_fails_closed(
+    tmp_path: Path,
+    value: str,
+) -> None:
+    paths = _paths(tmp_path)
+
+    with pytest.raises(
+        PublicationPortabilityError,
+        match=r"/diagnostic",
+    ):
+        portable_publication_value({"diagnostic": value}, paths)
+
+
+def test_digest_covered_identity_with_absolute_locator_is_opaque_and_not_mutated(
+    tmp_path: Path,
+) -> None:
+    paths = _paths(tmp_path)
+    identity, postflight = _identity_payload()
+    native = identity["native_extension"]
+    assert isinstance(native, dict)
+    native["path"] = "/private/runtime/_rusticol.so"
+    payload = {
+        "provenance": {
+            "runtime_identity": identity,
+            "runtime_identity_sha256": _digest(identity),
+            "runtime_identity_postflight_loaded_module_origin_policy": postflight,
+        }
+    }
+    before = deepcopy(payload)
+
+    portable = portable_publication_value(payload, paths)
+
+    assert payload == before
+    assert portable == payload
+    assert _canonical_bytes(portable["provenance"]["runtime_identity"]) == (  # type: ignore[index]
+        _canonical_bytes(payload["provenance"]["runtime_identity"])  # type: ignore[index]
+    )
+    assert publication_absolute_paths(payload) == ()
+
+
+def test_invalid_identity_digest_does_not_hide_an_absolute_path(
+    tmp_path: Path,
+) -> None:
+    paths = _paths(tmp_path)
+    identity, _postflight = _identity_payload()
+    native = identity["native_extension"]
+    assert isinstance(native, dict)
+    native["path"] = "/private/runtime/_rusticol.so"
+    payload = {
+        "provenance": {
+            "runtime_identity": identity,
+            "runtime_identity_sha256": "0" * 64,
+        }
+    }
+
+    with pytest.raises(
+        PublicationPortabilityError,
+        match=r"/provenance/runtime_identity/native_extension/path",
+    ):
+        portable_publication_value(payload, paths)
+
+    assert publication_absolute_paths(payload) == ("/private/runtime/_rusticol.so",)
+
+
+def test_any_valid_digest_covered_sibling_is_copied_byte_identically(
+    tmp_path: Path,
+) -> None:
+    paths = _paths(tmp_path)
+    evidence = {
+        "path": "/private/authenticated/evidence.bin",
+        "size": 123,
+        "member_sha256": "a" * 64,
+    }
+    payload = {
+        "authenticated_evidence": evidence,
+        "authenticated_evidence_sha256": _digest(evidence),
+    }
+    before = _canonical_bytes(evidence)
+
+    portable = portable_publication_value(payload, paths)
+
+    assert _canonical_bytes(portable["authenticated_evidence"]) == before  # type: ignore[index]
+    assert portable["authenticated_evidence"] is evidence  # type: ignore[index]
+    assert publication_absolute_paths(portable) == ()
+
+
+def test_known_root_replacement_observes_path_boundaries(tmp_path: Path) -> None:
+    paths = _paths(tmp_path)
+    sibling = f"{paths.repo_root}-sibling/models/sm.json"
+    embedded_suffix = f"/unrelated{paths.repo_root}/models/sm.json"
+    payload = {
+        "provenance": {
+            "effective_config": {
+                "model": {
+                    "source": sibling,
+                    "cache_dir": embedded_suffix,
+                }
+            }
+        }
+    }
+
+    portable = portable_publication_value(payload, paths)
+    model = portable["provenance"]["effective_config"]["model"]  # type: ignore[index]
+
+    assert model["source"] == "${LOCAL_PATH_REDACTED}"
+    assert model["cache_dir"] == "${LOCAL_PATH_REDACTED}"
+    assert "${PYAMPLICOL_SOURCE_ROOT}-sibling" not in repr(portable)
+
+
+def test_resolver_relocates_known_root_and_rejects_escape_or_raw_path(
+    tmp_path: Path,
+) -> None:
+    source_paths = _paths(tmp_path / "machine-a", "macbook_M3")
+    target_paths = _paths(tmp_path / "machine-b", "cluster_EPYC")
+    raw = source_paths.artifact_root / "cells/example/artifact"
+    portable = portable_publication_value(
+        {"artifact": {"path": str(raw)}},
+        source_paths,
+    )
+    locator = portable["artifact"]["path"]  # type: ignore[index]
+    assert isinstance(locator, str)
+
+    assert resolve_publication_string(locator, target_paths) == str(
+        target_paths.artifact_root / "cells/example/artifact"
+    )
+    assert resolve_publication_path(locator, target_paths) == (
+        target_paths.artifact_root / "cells/example/artifact"
+    )
+    with pytest.raises(ValueError, match="not canonical"):
+        resolve_publication_path(
+            "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/../../outside",
+            target_paths,
+        )
+    with pytest.raises(ValueError, match="recognized root"):
+        resolve_publication_path("/tmp/untrusted/artifact", target_paths)
+    with pytest.raises(ValueError, match="cannot be resolved"):
+        resolve_publication_path(
+            "${LOCAL_PATH_REDACTED}/libexample.dylib",
+            target_paths,
+        )
+
+
+def test_raw_current_is_audited_before_projection_and_is_never_mutated(
+    tmp_path: Path,
+) -> None:
+    paths = _paths(tmp_path)
+    identity, postflight = _identity_payload()
+    current = {
+        "status": "ok",
+        "artifact": {
+            "path": str(paths.artifact_root / "cells/example/artifact"),
+        },
+        "provenance": {
+            "runtime_identity": identity,
+            "runtime_identity_sha256": _digest(identity),
+            "runtime_identity_postflight_loaded_module_origin_policy": postflight,
+        },
+    }
+    before = deepcopy(current)
+    audit_order: list[str] = []
+
+    def audit_raw(value: dict[str, object]) -> None:
+        audit_order.append("raw")
+        assert value["artifact"]["path"] == str(  # type: ignore[index]
+            paths.artifact_root / "cells/example/artifact"
+        )
+        provenance = value["provenance"]
+        assert isinstance(provenance, dict)
+        assert (
+            _digest(provenance["runtime_identity"])
+            == provenance["runtime_identity_sha256"]
+        )
+
+    audit_raw(current)
+    portable = portable_publication_value(current, paths)
+    audit_order.append("projected")
+
+    assert publication_measurement_matches_current(portable, current, paths)
+    changed = dict(portable)
+    changed["status"] = "failed"
+    assert not publication_measurement_matches_current(changed, current, paths)
+    assert audit_order == ["raw", "projected"]
+    assert current == before
+
+
+def test_portable_current_round_trip_rebases_only_approved_locators(
+    tmp_path: Path,
+) -> None:
+    source = _paths(tmp_path / "before", "manual")
+    target = _paths(tmp_path / "after", "renamed")
+    identity = {"native_extension": {"path": "/authenticated/runtime.so"}}
+    payload = {
+        "artifact": {
+            "path": str(source.artifact_root / "cells/a/attempts/id/artifact"),
+            "log_path": str(source.artifact_root / "cells/a/attempts/id/worker.log"),
+        },
+        "provenance": {
+            "worker_log": str(
+                source.artifact_root / "cells/a/attempts/id/worker.log"
+            ),
+            "runtime_identity": identity,
+            "runtime_identity_sha256": _digest(identity),
+        },
+    }
+    identity_before = _canonical_bytes(identity)
+
+    portable = portable_current_value(payload, source)
+    materialized = materialize_current_value(portable, target)
+
+    assert portable["artifact"]["path"] == (  # type: ignore[index]
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/cells/a/attempts/id/artifact"
+    )
+    assert materialized["artifact"]["path"] == str(  # type: ignore[index]
+        target.artifact_root / "cells/a/attempts/id/artifact"
+    )
+    assert _canonical_bytes(portable["provenance"]["runtime_identity"]) == (  # type: ignore[index]
+        identity_before
+    )
+
+
+@pytest.mark.parametrize(
+    "locator",
+    (
+        "/tmp/old-campaign/artifact",
+        "relative/artifact",
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}",
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/../escape",
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/artifact\\member",
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}//artifact",
+    ),
+)
+def test_portable_current_rejects_legacy_or_noncanonical_artifact_locator(
+    tmp_path: Path,
+    locator: str,
+) -> None:
+    paths = _paths(tmp_path)
+
+    with pytest.raises(PublicationPortabilityError):
+        materialize_current_value({"artifact": {"path": locator}}, paths)
+
+
+def test_portable_current_rejects_artifact_symlink_traversal(tmp_path: Path) -> None:
+    paths = _paths(tmp_path)
+    paths.artifact_root.mkdir(parents=True)
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    (paths.artifact_root / "escape").symlink_to(outside, target_is_directory=True)
+
+    with pytest.raises(PublicationPortabilityError, match="invalid rooted path"):
+        materialize_current_value(
+            {
+                "artifact": {
+                    "path": "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/escape/payload"
+                }
+            },
+            paths,
+        )
+
+
+def test_portable_current_rejects_in_root_artifact_symlink_traversal(
+    tmp_path: Path,
+) -> None:
+    paths = _paths(tmp_path)
+    target = paths.artifact_root / "real"
+    target.mkdir(parents=True)
+    (paths.artifact_root / "alias").symlink_to(target, target_is_directory=True)
+
+    with pytest.raises(PublicationPortabilityError, match="symbolic link"):
+        materialize_current_value(
+            {
+                "artifact": {
+                    "path": "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/alias/payload"
+                }
+            },
+            paths,
+        )
+
+
+def test_portable_current_preserves_external_installed_command_and_moves_state(
+    tmp_path: Path,
+) -> None:
+    source = _paths(tmp_path / "before", "manual")
+    target = _paths(tmp_path / "after path's", "renamed")
+    external_python = "/opt/pyamplicol-venv/bin/python"
+    profile_argv = (
+        external_python,
+        "-m",
+        "pyamplicol",
+        "profile",
+        str(source.artifact_root / "manual-reproductions/cell/artifact"),
+    )
+    payload = {
+        "artifact": {
+            "path": str(source.artifact_root / "cells/a/attempts/id/artifact")
+        },
+        "provenance": {
+            "manual_campaign": {
+                "public_cli_reproduction": {
+                    "abi": PORTABLE_CURRENT_REPRODUCTION_RECIPE_ABI,
+                    "prepare": None,
+                    "generate": None,
+                    "profile": list(profile_argv),
+                }
+            }
+        },
+    }
+
+    portable = portable_current_value(payload, source)
+    stored_argv = portable["provenance"]["manual_campaign"][  # type: ignore[index]
+        "public_cli_reproduction"
+    ]["profile"]
+    assert external_python in stored_argv
+    assert stored_argv[-1].startswith(
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/manual-reproductions"
+    )
+    assert "${LOCAL_PATH_REDACTED}" not in stored_argv
+
+    materialized = materialize_current_value(portable, target)
+    moved_argv = materialized["provenance"]["manual_campaign"][  # type: ignore[index]
+        "public_cli_reproduction"
+    ]["profile"]
+    assert external_python in moved_argv
+    assert moved_argv[-1] == str(
+        target.artifact_root / "manual-reproductions/cell/artifact"
+    )
+    assert shlex.split(shlex.join(moved_argv)) == moved_argv
+
+    with pytest.raises(PublicationPortabilityError, match="structured ABI"):
+        materialize_current_value(
+            {
+                "provenance": {
+                    "manual_campaign": {
+                        "public_cli_reproduction": {
+                            "prepare": None,
+                            "generate": None,
+                            "profile": "old absolute command",
+                        }
+                    }
+                }
+            },
+            target,
+        )
diff --git a/pyamplicol/tests/unit/test_performance_report_publication_lineage.py b/pyamplicol/tests/unit/test_performance_report_publication_lineage.py
new file mode 100644
index 0000000000..e78782118b
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_publication_lineage.py
@@ -0,0 +1,185 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.final_audit import (
+    FinalAuditError,
+    _report_publication_lineage,
+)
+
+
+def _git(repo: Path, *arguments: str) -> str:
+    completed = subprocess.run(
+        ("git", *arguments),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
+def _commit(repo: Path, message: str) -> str:
+    _git(repo, "add", "--all")
+    _git(repo, "commit", "-m", message)
+    return _git(repo, "rev-parse", "HEAD")
+
+
+def _repository(tmp_path: Path) -> tuple[Path, str]:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git(repo, "init")
+    _git(repo, "config", "user.email", "report@example.invalid")
+    _git(repo, "config", "user.name", "Report Test")
+    _git(repo, "config", "core.fileMode", "true")
+    (repo / "src").mkdir()
+    (repo / "src/evaluator.py").write_text("VALUE = 1\n", encoding="utf-8")
+    (repo / "docs/arxiv/results").mkdir(parents=True)
+    (repo / "docs/arxiv/results/cache.json").write_text(
+        "{}\n",
+        encoding="ascii",
+    )
+    (repo / "docs/arxiv/pyAmpliCol.tex").write_text(
+        "\\documentclass{article}\n",
+        encoding="ascii",
+    )
+    return repo, _commit(repo, "measurement source")
+
+
+def test_same_commit_publication_lineage_is_authenticated(tmp_path: Path) -> None:
+    repo, measurement_revision = _repository(tmp_path)
+
+    result = _report_publication_lineage(repo, measurement_revision)
+
+    assert result["measurement_source_revision"] == measurement_revision
+    assert result["publication_revision"] == measurement_revision
+    assert result["relationship"] == "same-commit"
+    assert result["changed_paths"] == []
+    assert result["executable_source_unchanged"] is True
+
+
+def test_report_only_descendant_accepts_canonical_and_profile_outputs(
+    tmp_path: Path,
+) -> None:
+    repo, measurement_revision = _repository(tmp_path)
+    canonical = repo / "src/pyamplicol/_profiling_campaign"
+    (canonical / "results").mkdir(parents=True)
+    (canonical / "results/cache.json").write_text(
+        '{"measured":true}\n',
+        encoding="ascii",
+    )
+    profile = repo / "docs/performance_reports/macbook_M3"
+    (profile / "results").mkdir(parents=True)
+    publications = {
+        "README.md": "# M3 report\n",
+        "architecture-profile.json": "{}\n",
+        "report-workspace.json": "{}\n",
+        "result_example_table.tex": "% generated\n",
+        "section_results.tex": "% prose\n",
+    }
+    for name, content in publications.items():
+        (profile / name).write_text(content, encoding="ascii")
+    (profile / "results/cache.json").write_text("{}\n", encoding="ascii")
+    (profile / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.4\n%%EOF\n")
+    publication_revision = _commit(repo, "publish report")
+
+    result = _report_publication_lineage(repo, measurement_revision)
+
+    assert result["publication_revision"] == publication_revision
+    assert result["relationship"] == "report-only-descendant"
+    changed = result["changed_paths"]
+    assert isinstance(changed, list)
+    assert {entry["path"] for entry in changed} == {
+        "src/pyamplicol/_profiling_campaign/results/cache.json",
+        "docs/performance_reports/macbook_M3/README.md",
+        "docs/performance_reports/macbook_M3/architecture-profile.json",
+        "docs/performance_reports/macbook_M3/pyAmpliCol.pdf",
+        "docs/performance_reports/macbook_M3/report-workspace.json",
+        "docs/performance_reports/macbook_M3/result_example_table.tex",
+        "docs/performance_reports/macbook_M3/results/cache.json",
+        "docs/performance_reports/macbook_M3/section_results.tex",
+    }
+    assert result["changed_path_count"] == len(changed)
+
+
+@pytest.mark.parametrize(
+    ("relative_path", "content"),
+    [
+        ("src/evaluator.py", "VALUE = 2\n"),
+        (
+            "docs/performance_reports/macbook_M3/result_tables.py",
+            "raise SystemExit(1)\n",
+        ),
+        (
+            "docs/performance_reports/macbook_M3/results/worker.log",
+            "private\n",
+        ),
+        ("docs/development/runtime.md", "runtime changed\n"),
+    ],
+)
+def test_publication_descendant_rejects_every_nonreport_path(
+    tmp_path: Path,
+    relative_path: str,
+    content: str,
+) -> None:
+    repo, measurement_revision = _repository(tmp_path)
+    path = repo / relative_path
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+    _commit(repo, "forbidden publication")
+
+    with pytest.raises(FinalAuditError, match="outside the explicit"):
+        _report_publication_lineage(repo, measurement_revision)
+
+
+def test_publication_descendant_rejects_executable_allowed_member(
+    tmp_path: Path,
+) -> None:
+    repo, measurement_revision = _repository(tmp_path)
+    readme = repo / "src/pyamplicol/_profiling_campaign/README.md"
+    readme.parent.mkdir(parents=True)
+    readme.write_text("# report\n", encoding="utf-8")
+    readme.chmod(readme.stat().st_mode | 0o111)
+    _commit(repo, "executable report")
+
+    with pytest.raises(FinalAuditError, match="executable, a symlink"):
+        _report_publication_lineage(repo, measurement_revision)
+
+
+def test_publication_descendant_rejects_symlink_allowed_member(
+    tmp_path: Path,
+) -> None:
+    repo, measurement_revision = _repository(tmp_path)
+    readme = repo / "src/pyamplicol/_profiling_campaign/README.md"
+    readme.parent.mkdir(parents=True)
+    os.symlink("../src/evaluator.py", readme)
+    _commit(repo, "symlink report")
+
+    with pytest.raises(FinalAuditError, match="executable, a symlink"):
+        _report_publication_lineage(repo, measurement_revision)
+
+
+def test_publication_lineage_rejects_dirty_report_output(tmp_path: Path) -> None:
+    repo, measurement_revision = _repository(tmp_path)
+    (repo / "docs/arxiv/results/cache.json").write_text(
+        '{"uncommitted":true}\n',
+        encoding="ascii",
+    )
+
+    with pytest.raises(FinalAuditError, match="completely clean"):
+        _report_publication_lineage(repo, measurement_revision)
+
+
+def test_publication_lineage_rejects_non_descendant_commit(tmp_path: Path) -> None:
+    repo, measurement_revision = _repository(tmp_path)
+    empty_tree = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+    unrelated = _git(repo, "commit-tree", empty_tree, "-m", "unrelated publication")
+    _git(repo, "checkout", "--detach", unrelated)
+
+    with pytest.raises(FinalAuditError, match="not a descendant"):
+        _report_publication_lineage(repo, measurement_revision)
diff --git a/pyamplicol/tests/unit/test_performance_report_publisher.py b/pyamplicol/tests/unit/test_performance_report_publisher.py
new file mode 100644
index 0000000000..b3ad4af8a8
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_publisher.py
@@ -0,0 +1,292 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import subprocess
+import threading
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.publisher import (
+    PublicationResult,
+    ReportPublisherError,
+    _compile_pdf,
+    _copy_report_source,
+    publish_once,
+    run_publisher,
+    validate_published_snapshot,
+)
+from tools.performance_report.service import ReportPaths, ReportService
+
+
+def _clean_report_service(tmp_path: Path) -> ReportService:
+    root = tmp_path / "repo"
+    (root / "docs/arxiv").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=root, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "publisher-tests@example.invalid"),
+        cwd=root,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Publisher Tests"),
+        cwd=root,
+        check=True,
+    )
+    (root / "README.md").write_text("# publisher fixture\n", encoding="ascii")
+    service = ReportService(ReportPaths.from_repo(root))
+    service.publish(reset=True, merge_artifacts=False)
+    subprocess.run(("git", "add", "."), cwd=root, check=True)
+    subprocess.run(
+        ("git", "commit", "-q", "-m", "Initialize report fixture"),
+        cwd=root,
+        check=True,
+    )
+    return service
+
+
+def test_publisher_source_copy_excludes_only_top_level_campaign_state(
+    tmp_path: Path,
+) -> None:
+    source = tmp_path / "source"
+    source.mkdir()
+    (source / "pyAmpliCol.tex").write_text("report\n", encoding="ascii")
+    (source / "campaign_artifacts").mkdir()
+    (source / "campaign_artifacts/sentinel").write_text("private\n", encoding="ascii")
+    nested = source / "appendix/campaign_artifacts"
+    nested.mkdir(parents=True)
+    (nested / "published.txt").write_text("keep\n", encoding="ascii")
+    destination = tmp_path / "staging"
+
+    _copy_report_source(source, destination)
+
+    assert not (destination / "campaign_artifacts").exists()
+    assert (destination / "appendix/campaign_artifacts/published.txt").is_file()
+
+
+def test_pdf_compiler_can_allow_overfull_boxes_for_interactive_refresh(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    docs = tmp_path / "docs"
+    docs.mkdir()
+    (docs / "pyAmpliCol.tex").write_text(
+        "\\documentclass{article}\\begin{document}ok\\end{document}\n",
+        encoding="ascii",
+    )
+    latexmk = tmp_path / "latexmk"
+    latexmk.write_text(
+        "#!/usr/bin/env python3\n"
+        "from pathlib import Path\n"
+        "Path('pyAmpliCol.pdf').write_bytes(b'%PDF-1.4\\n%%EOF\\n')\n"
+        "Path('pyAmpliCol.log').write_text("
+        "'Overfull \\\\hbox (1.0pt too wide)\\n"
+        "Output written on pyAmpliCol.pdf (60 pages, 123 bytes).\\n', "
+        "encoding='utf-8')\n",
+        encoding="utf-8",
+    )
+    latexmk.chmod(0o755)
+    monkeypatch.setattr(
+        "tools.performance_report.publisher.shutil.which",
+        lambda _name: str(latexmk),
+    )
+
+    assert (
+        _compile_pdf(
+            docs,
+            expected_page_count=60,
+            timeout_seconds=10.0,
+            allow_overfull_boxes=True,
+        )
+        == 60
+    )
+
+    with pytest.raises(ReportPublisherError, match="overfull"):
+        _compile_pdf(
+            docs,
+            expected_page_count=60,
+            timeout_seconds=10.0,
+        )
+
+
+def test_pdf_compiler_streams_only_when_requested(
+    tmp_path: Path,
+    monkeypatch,
+    capfd: pytest.CaptureFixture[str],
+) -> None:
+    docs = tmp_path / "docs"
+    docs.mkdir()
+    (docs / "pyAmpliCol.tex").write_text(
+        "\\documentclass{article}\\begin{document}ok\\end{document}\n",
+        encoding="ascii",
+    )
+    latexmk = tmp_path / "latexmk"
+    latexmk.write_text(
+        "#!/usr/bin/env python3\n"
+        "import sys\n"
+        "from pathlib import Path\n"
+        "print('live latex stdout', flush=True)\n"
+        "print('live latex stderr', file=sys.stderr, flush=True)\n"
+        "Path('pyAmpliCol.pdf').write_bytes(b'%PDF-1.4\\n%%EOF\\n')\n"
+        "Path('pyAmpliCol.log').write_text("
+        "'Output written on pyAmpliCol.pdf (3 pages, 123 bytes).\\n', "
+        "encoding='utf-8')\n",
+        encoding="utf-8",
+    )
+    latexmk.chmod(0o755)
+    monkeypatch.setattr(
+        "tools.performance_report.publisher.shutil.which",
+        lambda _name: str(latexmk),
+    )
+
+    assert (
+        _compile_pdf(
+            docs,
+            expected_page_count=3,
+            timeout_seconds=10.0,
+        )
+        == 3
+    )
+    captured = capfd.readouterr()
+    assert "live latex stdout" not in captured.out
+    assert "live latex stderr" not in captured.err
+
+    assert (
+        _compile_pdf(
+            docs,
+            expected_page_count=3,
+            timeout_seconds=10.0,
+            stream_output=True,
+        )
+        == 3
+    )
+    captured = capfd.readouterr()
+    assert "live latex stdout" in captured.out
+    assert "live latex stderr" in captured.err
+
+
+def test_publish_once_installs_one_consistent_snapshot(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    service = _clean_report_service(tmp_path)
+
+    def fake_compile(
+        docs_dir: Path,
+        *,
+        expected_page_count: int,
+        timeout_seconds: float,
+    ) -> int:
+        assert expected_page_count == 73
+        assert timeout_seconds == 900.0
+        (docs_dir / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.4\n%%EOF\n")
+        return 73
+
+    monkeypatch.setattr(
+        "tools.performance_report.publisher._compile_pdf",
+        fake_compile,
+    )
+
+    published = publish_once(service)
+    validated = validate_published_snapshot(service)
+
+    assert published.current_count == 0
+    assert published.page_count == 73
+    assert validated["status"] == "ok"
+    assert validated["snapshot_sha256"] == published.snapshot_sha256
+    assert (service.paths.docs_dir / "pyAmpliCol.pdf").is_file()
+
+
+def test_active_publisher_never_holds_the_controller_named_lock(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    service = _clean_report_service(tmp_path)
+    entered = threading.Event()
+    release = threading.Event()
+    failure: list[BaseException] = []
+
+    def fake_publish_once(*_args: object, **_kwargs: object) -> PublicationResult:
+        entered.set()
+        assert release.wait(timeout=5.0)
+        return PublicationResult(
+            current_count=0,
+            page_count=59,
+            snapshot_sha256="a" * 64,
+            captured_at_utc="2026-01-01T00:00:00Z",
+            published_at_utc="2026-01-01T00:00:01Z",
+        )
+
+    def publisher() -> None:
+        try:
+            run_publisher(service, watch=False)
+        except BaseException as error:
+            failure.append(error)
+
+    monkeypatch.setattr(
+        "tools.performance_report.publisher.publish_once",
+        fake_publish_once,
+    )
+    thread = threading.Thread(target=publisher)
+    thread.start()
+    assert entered.wait(timeout=5.0)
+    assert (
+        service.paths.coordination_root / "publication" / "daemon.json"
+    ).is_file()
+
+    with (
+        service.store.named_lock("report-publisher-daemon", timeout=0.0),
+        service.store.named_lock("campaign-controller-boundary", timeout=0.0),
+    ):
+        pass
+    with pytest.raises(ReportPublisherError, match="already active"):
+        run_publisher(service, watch=False)
+
+    release.set()
+    thread.join(timeout=5.0)
+    assert not thread.is_alive()
+    assert failure == []
+
+
+def test_publisher_backs_off_behind_controller_report_install(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    service = _clean_report_service(tmp_path)
+    compiled = threading.Event()
+    completed: list[PublicationResult] = []
+    failure: list[BaseException] = []
+
+    def fake_compile(
+        docs_dir: Path,
+        *,
+        expected_page_count: int,
+        timeout_seconds: float,
+    ) -> int:
+        assert expected_page_count == 73
+        assert timeout_seconds == 900.0
+        (docs_dir / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.4\n%%EOF\n")
+        compiled.set()
+        return 73
+
+    def publisher() -> None:
+        try:
+            completed.append(publish_once(service))
+        except BaseException as error:
+            failure.append(error)
+
+    monkeypatch.setattr(
+        "tools.performance_report.publisher._compile_pdf",
+        fake_compile,
+    )
+    with service.store.named_lock("report-writer"):
+        thread = threading.Thread(target=publisher)
+        thread.start()
+        assert compiled.wait(timeout=30.0)
+        thread.join(timeout=0.15)
+        assert thread.is_alive()
+
+    thread.join(timeout=5.0)
+    assert not thread.is_alive()
+    assert failure == []
+    assert len(completed) == 1
diff --git a/pyamplicol/tests/unit/test_performance_report_resource_retention.py b/pyamplicol/tests/unit/test_performance_report_resource_retention.py
new file mode 100644
index 0000000000..44edd1c19f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_resource_retention.py
@@ -0,0 +1,187 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools.performance_report.artifacts import ArtifactStore
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import ArtifactPolicy, CellSpec, ExecutionMode
+from tools.performance_report.publication import (
+    portable_publication_value,
+    publication_absolute_paths,
+)
+from tools.performance_report.scheduler import CampaignScheduler, CampaignSettings
+from tools.performance_report.service import ReportPaths
+
+
+def _scheduler(*, retain_workspaces: bool = False) -> CampaignScheduler:
+    scheduler = object.__new__(CampaignScheduler)
+    scheduler.settings = CampaignSettings(retain_workspaces=retain_workspaces)
+    return scheduler
+
+
+def _cell(mode: ExecutionMode) -> CellSpec:
+    return next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode is mode
+    )
+
+
+def test_successful_reference_artifacts_are_compacted_by_default(
+    tmp_path: Path,
+) -> None:
+    scheduler = _scheduler()
+    legacy = tmp_path / "legacy-artifact"
+    legacy.mkdir()
+    (legacy / "legacy.log").write_bytes(b"a" * (128 * 1024))
+    for name in (
+        "contracted-generated-library",
+        "legacy-structural-evidence",
+        "selected-flow-generated-library",
+    ):
+        directory = legacy / name
+        directory.mkdir()
+        (directory / "evidence").write_text(name, encoding="ascii")
+
+    legacy_result: dict[str, object] = {"artifact": {"path": str(legacy)}}
+    scheduler._compact_reference_artifact(
+        _cell(ExecutionMode.AMPLICOL),
+        legacy,
+        legacy_result,
+    )
+
+    assert (legacy / "legacy.log").stat().st_size <= 64 * 1024
+    assert not (legacy / "contracted-generated-library").exists()
+    # The proof inventories these compact files by digest, so they stay with it.
+    assert (legacy / "legacy-structural-evidence").is_dir()
+    # The compact selected-flow provider remains reusable by an all-flow cell.
+    assert (legacy / "selected-flow-generated-library").is_dir()
+
+    madgraph = tmp_path / "madgraph-artifact"
+    (madgraph / "standalone").mkdir(parents=True)
+    (madgraph / "standalone" / "matrix.f").write_text("x", encoding="ascii")
+    (madgraph / "madgraph.log").write_bytes(b"b" * (128 * 1024))
+
+    madgraph_result: dict[str, object] = {
+        "artifact": {
+            "path": str(madgraph),
+            "standalone": str(madgraph / "standalone"),
+            "subprocess": "standalone/SubProcesses/P0_test",
+        }
+    }
+    scheduler._compact_reference_artifact(
+        _cell(ExecutionMode.MADGRAPH),
+        madgraph,
+        madgraph_result,
+    )
+
+    assert (madgraph / "madgraph.log").stat().st_size <= 64 * 1024
+    assert not (madgraph / "standalone").exists()
+    retained_artifact = madgraph_result["artifact"]
+    assert isinstance(retained_artifact, dict)
+    assert "standalone" not in retained_artifact
+    assert "subprocess" not in retained_artifact
+    assert retained_artifact["workspace_retention"] == {
+        "schema": "pyamplicol-reference-workspace-retention-v1",
+        "full_workspaces_retained": False,
+        "removed": ["standalone"],
+    }
+
+
+def test_failed_reference_keeps_only_bounded_diagnostic_tail(
+    tmp_path: Path,
+) -> None:
+    scheduler = _scheduler()
+    artifact = tmp_path / "attempt" / "artifact"
+    artifact.mkdir(parents=True)
+    (artifact / "legacy.log").write_bytes(b"prefix\n" + b"z" * (128 * 1024))
+    (artifact / "partial-build").mkdir()
+
+    scheduler._discard_terminal_artifact(artifact, artifact.parent)
+
+    diagnostic = artifact.parent / "legacy-artifact-tail.log"
+    assert not artifact.exists()
+    assert diagnostic.is_file()
+    assert diagnostic.stat().st_size <= 64 * 1024
+    assert diagnostic.read_bytes().endswith(b"z" * 1024)
+
+
+def test_legacy_workspace_cleanup_is_default_and_debug_retention_is_opt_in(
+    tmp_path: Path,
+) -> None:
+    workspace = tmp_path / "legacy-workspace"
+    log = workspace / "Outputs" / "log_file.txt"
+    log.parent.mkdir(parents=True)
+    log.write_bytes(b"line\n" * 20_000)
+    diagnostic = tmp_path / "attempt" / "legacy-generator-tail.log"
+
+    _scheduler()._finalize_legacy_workspace(
+        workspace,
+        diagnostic_path=diagnostic,
+    )
+
+    assert not workspace.exists()
+    assert diagnostic.is_file()
+    assert diagnostic.stat().st_size <= 64 * 1024
+
+    retained = tmp_path / "retained-workspace"
+    retained_log = retained / "Outputs" / "log_file.txt"
+    retained_log.parent.mkdir(parents=True)
+    retained_log.write_text("debug", encoding="ascii")
+    retained_diagnostic = tmp_path / "unused-tail.log"
+
+    _scheduler(retain_workspaces=True)._finalize_legacy_workspace(
+        retained,
+        diagnostic_path=retained_diagnostic,
+    )
+
+    assert retained_log.is_file()
+    assert not retained_diagnostic.exists()
+
+
+def test_worker_log_compaction_respects_debug_retention(tmp_path: Path) -> None:
+    compact_log = tmp_path / "compact-worker.log"
+    compact_log.write_bytes(b"c" * (128 * 1024))
+    _scheduler()._finalize_worker_log(compact_log)
+    assert compact_log.stat().st_size <= 64 * 1024
+
+    retained_log = tmp_path / "retained-worker.log"
+    retained_payload = b"d" * (128 * 1024)
+    retained_log.write_bytes(retained_payload)
+    _scheduler(retain_workspaces=True)._finalize_worker_log(retained_log)
+    assert retained_log.read_bytes() == retained_payload
+
+
+def test_compacted_madgraph_current_remains_resumable_and_portable(
+    tmp_path: Path,
+) -> None:
+    paths = ReportPaths.from_repo(tmp_path / "source", profile="retention-test")
+    store = ArtifactStore(
+        artifact_root=paths.artifact_root,
+        lock_root=paths.coordination_root / "locks",
+    )
+    cell = _cell(ExecutionMode.MADGRAPH)
+
+    with store.new_attempt(cell.cell_id, ArtifactPolicy.REGENERATE) as attempt:
+        artifact = attempt.path("artifact/madgraph.log").parent
+        (artifact / "madgraph.log").write_text("complete", encoding="ascii")
+        (artifact / "standalone").mkdir()
+        result: dict[str, object] = {
+            "artifact": {
+                "path": str(artifact),
+                "standalone": str(artifact / "standalone"),
+                "subprocess": "standalone/SubProcesses/P0_test",
+            }
+        }
+        _scheduler()._compact_reference_artifact(cell, artifact, result)
+        attempt.publish(result, artifact_paths=("artifact/madgraph.log",))
+
+    current = store.load_current(cell.cell_id)
+    assert current is not None
+    current_artifact = current.result["artifact"]
+    assert isinstance(current_artifact, dict)
+    assert "standalone" not in current_artifact
+    assert "subprocess" not in current_artifact
+    portable = portable_publication_value(current.result, paths)
+    assert publication_absolute_paths(portable) == ()
diff --git a/pyamplicol/tests/unit/test_performance_report_resources.py b/pyamplicol/tests/unit/test_performance_report_resources.py
new file mode 100644
index 0000000000..f43a809ba3
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_resources.py
@@ -0,0 +1,1976 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import ctypes
+import io
+import os
+import signal
+import subprocess
+import sys
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+import pytest
+
+from tools.ci import memory_watchdog
+from tools.ci.memory_watchdog import (
+    ProbeError as WatchdogProbeError,
+)
+from tools.ci.memory_watchdog import ProcessInfo as WatchdogProcessInfo
+from tools.performance_report.phase_state import (
+    WorkerPhaseChannel,
+    WorkerPhaseReporter,
+)
+from tools.performance_report.resources import (
+    DEFAULT_ATTEMPT_OUTPUT_LIMIT_BYTES,
+    DEFAULT_MINIMUM_FREE_DISK_BYTES,
+    DEFAULT_SAMPLE_INTERVAL_SECONDS,
+    PROCESS_TREE_MEMORY_METRIC_ABI,
+    ProcessRecord,
+    ProcessTreeSampler,
+    ResourceMonitor,
+    ResourceProbeError,
+    _darwin_process_identity,
+    _DarwinProcBsdInfo,
+    _linux_proc_snapshot,
+    _parse_linux_process_identity,
+    _parse_proc_stat,
+    _parse_proc_status_rss,
+    _parse_ps_output,
+    _ProcessIdentity,
+    _signal_process_tree,
+    process_snapshot,
+    supervise_worker,
+)
+
+
+def test_linux_proc_parsers_and_snapshot_include_cpu_time(tmp_path: Path) -> None:
+    stat = "42 (worker (phase 2)) S 7 42 42 0 -1 0 0 0 0 0 200 50"
+    status = "Name:\tworker\nVmPeak:\t9000 kB\nVmRSS:\t1536 kB\n"
+
+    assert _parse_proc_stat(stat, clock_ticks_per_second=100) == (7, 2.5)
+    assert _parse_proc_status_rss(status) == 1536 * 1024
+
+    process_dir = tmp_path / "42"
+    process_dir.mkdir()
+    (process_dir / "stat").write_text(stat, encoding="ascii")
+    (process_dir / "status").write_text(status, encoding="ascii")
+
+    assert _linux_proc_snapshot(
+        tmp_path,
+        clock_ticks_per_second=100,
+    ) == {
+        42: ProcessRecord(
+            pid=42,
+            ppid=7,
+            rss_bytes=1536 * 1024,
+            cpu_seconds=2.5,
+        )
+    }
+
+
+def test_linux_process_identity_uses_one_stat_snapshot() -> None:
+    stat = "42 (worker (phase 2)) S 1 77 77 0 -1 0 0 0 0 0 0 0 0 0 20 0 1 0 12345"
+
+    assert _parse_linux_process_identity(stat) == _ProcessIdentity(
+        birth_token=12345,
+        process_group=77,
+    )
+
+    with pytest.raises(ValueError, match="process identity"):
+        _parse_linux_process_identity(stat.replace(" 77 77 ", " 0 77 ", 1))
+
+
+def test_darwin_process_identity_uses_bsd_birth_and_group(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class FakeProcPidInfo:
+        argtypes: object = None
+        restype: object = None
+
+        def __init__(self) -> None:
+            self.short = False
+            self.mismatched_pid = False
+
+        def __call__(
+            self,
+            pid: int,
+            flavor: int,
+            arg: int,
+            buffer: object,
+            size: int,
+        ) -> int:
+            assert flavor == 3
+            assert arg == 0
+            assert size == ctypes.sizeof(_DarwinProcBsdInfo)
+            info = ctypes.cast(
+                buffer,
+                ctypes.POINTER(_DarwinProcBsdInfo),
+            ).contents
+            info.pbi_pid = pid + int(self.mismatched_pid)
+            info.pbi_pgid = 81
+            info.pbi_start_tvsec = 123
+            info.pbi_start_tvusec = 456
+            return size - 1 if self.short else size
+
+    fake_proc_pidinfo = FakeProcPidInfo()
+
+    class FakeLibproc:
+        proc_pidinfo = fake_proc_pidinfo
+
+    monkeypatch.setattr(
+        "tools.performance_report.resources._darwin_libproc",
+        lambda: FakeLibproc(),
+    )
+
+    assert _darwin_process_identity(42) == _ProcessIdentity(
+        birth_token=(123, 456),
+        process_group=81,
+    )
+    fake_proc_pidinfo.short = True
+    assert _darwin_process_identity(42) is None
+    fake_proc_pidinfo.short = False
+    fake_proc_pidinfo.mismatched_pid = True
+    assert _darwin_process_identity(42) is None
+
+
+def test_ps_parser_and_platform_fallback_are_injectable(tmp_path: Path) -> None:
+    output = " 12 7 1536\n 13 12 512\n"
+    assert _parse_ps_output(output) == {
+        12: ProcessRecord(12, 7, 1536 * 1024),
+        13: ProcessRecord(13, 12, 512 * 1024),
+    }
+
+    @dataclass
+    class Completed:
+        returncode: int = 0
+        stdout: str = output
+        stderr: str = ""
+
+    commands: list[tuple[str, ...]] = []
+
+    def run_ps(command: Sequence[str]) -> Completed:
+        commands.append(tuple(command))
+        return Completed()
+
+    records = process_snapshot(
+        "Linux",
+        proc_root=tmp_path / "missing",
+        ps_runner=run_ps,
+    )
+    assert records[12].rss_bytes == 1536 * 1024
+    assert commands == [("ps", "-axo", "pid=,ppid=,rss=")]
+
+
+def test_darwin_snapshot_uses_native_inventory_and_preserves_tree_rss() -> None:
+    def reject_ps(_command: Sequence[str]) -> object:
+        raise AssertionError("Darwin resource monitoring must not execute ps")
+
+    records = process_snapshot(
+        "Darwin",
+        ps_runner=reject_ps,
+        darwin_snapshotter=lambda: {
+            10: WatchdogProcessInfo(10, 1, 10, 100, 1.0),
+            11: WatchdogProcessInfo(11, 10, 10, 200, 2.0),
+            12: WatchdogProcessInfo(12, 11, 12, 300, 3.0),
+            20: WatchdogProcessInfo(20, 1, 20, 900, 9.0),
+        },
+    )
+
+    sample = ProcessTreeSampler(10).sample(records)
+
+    assert sample.rss_bytes == 600
+    assert sample.cpu_seconds == 6.0
+    assert sample.child_count == 2
+    assert sample.member_pids == (10, 11, 12)
+    assert sample.guard_bytes == 600
+
+
+def test_darwin_native_snapshot_failures_remain_fail_closed() -> None:
+    def fail_native() -> dict[int, WatchdogProcessInfo]:
+        raise WatchdogProbeError("libproc denied")
+
+    with pytest.raises(ResourceProbeError, match="libproc denied"):
+        process_snapshot("Darwin", darwin_snapshotter=fail_native)
+    with pytest.raises(ResourceProbeError, match="yielded no records"):
+        process_snapshot("Darwin", darwin_snapshotter=dict)
+
+
+@pytest.mark.skipif(sys.platform != "darwin", reason="requires Darwin libproc")
+def test_darwin_native_snapshot_observes_current_process() -> None:
+    def reject_ps(_command: Sequence[str]) -> object:
+        raise AssertionError("Darwin resource monitoring must not execute ps")
+
+    records = process_snapshot("Darwin", ps_runner=reject_ps)
+
+    assert records[os.getpid()].rss_bytes > 0
+    assert records[os.getpid()].cpu_seconds is not None
+
+
+@pytest.mark.skipif(sys.platform != "darwin", reason="requires Darwin libproc")
+def test_darwin_rss_remains_available_without_cpu_timebase(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def fail_timebase() -> tuple[int, int]:
+        raise WatchdogProbeError("synthetic timebase failure")
+
+    monkeypatch.setattr(memory_watchdog, "_darwin_mach_timebase", fail_timebase)
+
+    records = process_snapshot("Darwin")
+
+    assert records[os.getpid()].rss_bytes > 0
+    assert records[os.getpid()].cpu_seconds is None
+
+
+def test_process_tree_aggregates_descendants_and_tracks_reparenting() -> None:
+    sampler = ProcessTreeSampler(10)
+    first = sampler.sample(
+        {
+            10: ProcessRecord(10, 1, 100, 1.0),
+            11: ProcessRecord(11, 10, 200, 2.0),
+            12: ProcessRecord(12, 11, 300, 3.0),
+            20: ProcessRecord(20, 1, 900, 9.0),
+        }
+    )
+    assert first.rss_bytes == 600
+    assert first.child_count == 2
+    assert first.cpu_seconds == 6.0
+    assert first.member_pids == (10, 11, 12)
+    assert first.physical_footprint_bytes is None
+    assert first.guard_bytes == 600
+
+    second = sampler.sample(
+        {
+            10: ProcessRecord(10, 1, 110, 1.5),
+            12: ProcessRecord(12, 1, 310, 3.5),
+            20: ProcessRecord(20, 1, 900, 9.5),
+        }
+    )
+    assert second.rss_bytes == 420
+    assert second.child_count == 1
+    assert second.member_pids == (10, 12)
+    assert second.guard_bytes == 420
+
+
+def test_process_tree_sums_physical_footprint_with_race_fallback() -> None:
+    sampler = ProcessTreeSampler(10)
+    records = {
+        10: ProcessRecord(10, 1, 100, 1.0),
+        11: ProcessRecord(11, 10, 200, 2.0),
+        12: ProcessRecord(12, 11, 300, 3.0),
+    }
+
+    sample = sampler.sample(
+        records,
+        physical_footprint_probe=lambda _pids: {10: 80, 11: 400},
+    )
+
+    assert sample.rss_bytes == 600
+    assert sample.physical_footprint_bytes == 780
+    assert sample.guard_bytes == 780
+
+
+def test_monitor_tracks_current_peak_cpu_wall_and_probe_failure() -> None:
+    now = 100.0
+    snapshots = iter(
+        (
+            {
+                10: ProcessRecord(10, 1, 100, 1.0),
+                11: ProcessRecord(11, 10, 50, 0.5),
+            },
+            {10: ProcessRecord(10, 1, 90, 2.0)},
+        )
+    )
+    monitor = ResourceMonitor(
+        10,
+        snapshotter=lambda: next(snapshots),
+        clock=lambda: now,
+    )
+
+    now = 101.0
+    first = monitor.sample_once()
+    assert first.available
+    assert first.current_rss_bytes == 150
+    assert first.peak_rss_bytes == 150
+    assert first.child_count == 1
+    assert first.cpu_seconds == 1.5
+    assert first.wall_seconds == 1.0
+
+    now = 103.0
+    second = monitor.sample_once()
+    assert second.current_rss_bytes == 90
+    assert second.peak_rss_bytes == 150
+    assert second.child_count == 0
+    assert second.cpu_seconds == 2.0
+    assert second.wall_seconds == 3.0
+
+    failed = ResourceMonitor(
+        10,
+        snapshotter=lambda: (_ for _ in ()).throw(ResourceProbeError("offline")),
+        clock=lambda: 4.0,
+    ).sample_once()
+    assert not failed.available
+    assert failed.current_rss_bytes is None
+    assert failed.error == "offline"
+    assert failed.memory_probe_reason == "process-tree-memory-probe-unavailable"
+
+
+def test_monitor_tracks_physical_footprint_and_conservative_guard() -> None:
+    snapshots = iter(
+        (
+            {10: ProcessRecord(10, 1, 100)},
+            {10: ProcessRecord(10, 1, 140)},
+        )
+    )
+    footprints = iter(({10: 180}, {10: 120}))
+    monitor = ResourceMonitor(
+        10,
+        snapshotter=lambda: next(snapshots),
+        physical_footprint_probe=lambda _pids: next(footprints),
+        clock=lambda: 0.0,
+    )
+
+    first = monitor.sample_once()
+    second = monitor.sample_once()
+
+    assert first.current_physical_footprint_bytes == 180
+    assert first.current_guard_bytes == 180
+    assert second.current_rss_bytes == 140
+    assert second.current_physical_footprint_bytes == 120
+    assert second.current_guard_bytes == 140
+    assert second.peak_rss_bytes == 140
+    assert second.peak_physical_footprint_bytes == 180
+    assert second.peak_guard_bytes == 180
+    assert second.memory_metric_abi == PROCESS_TREE_MEMORY_METRIC_ABI
+
+
+class FakeClock:
+    def __init__(self) -> None:
+        self.now = 0.0
+
+    def __call__(self) -> float:
+        return self.now
+
+    def sleep(self, duration: float) -> None:
+        self.now += duration
+
+
+class FakeProcess:
+    def __init__(self, pid: int = 100, *, stderr: bytes | None = None) -> None:
+        self.pid = pid
+        self.returncode: int | None = None
+        self.stderr = None if stderr is None else io.BytesIO(stderr)
+
+    def poll(self) -> int | None:
+        return self.returncode
+
+    def wait(self, timeout: float | None = None) -> int:
+        if self.returncode is None:
+            raise subprocess.TimeoutExpired("worker", timeout)
+        return self.returncode
+
+
+def test_supervisor_enforces_timeout_on_worker_process_group() -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    popen_calls: list[tuple[tuple[str, ...], bool]] = []
+    signals: list[tuple[int, tuple[int, ...], int]] = []
+
+    def popen(
+        command: Sequence[str],
+        *,
+        start_new_session: bool,
+        env: Mapping[str, str],
+    ) -> FakeProcess:
+        assert env
+        popen_calls.append((tuple(command), start_new_session))
+        return process
+
+    def signal_tree(pgid: int | None, members: object, selected_signal: int) -> None:
+        member_tuple = tuple(sorted(members))  # type: ignore[arg-type]
+        signals.append((pgid, member_tuple, selected_signal))
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker", "--cell", "one"),
+        timeout_seconds=2.0,
+        interval_seconds=1.0,
+        snapshotter=lambda: {
+            100: ProcessRecord(100, 1, 100),
+            101: ProcessRecord(101, 100, 50),
+        },
+        popen_factory=popen,
+        clock=clock,
+        sleeper=clock.sleep,
+        signaler=signal_tree,
+    )
+
+    assert popen_calls == [(("worker", "--cell", "one"), True)]
+    assert result.reason == "worker_timeout"
+    assert result.returncode == -signal.SIGTERM
+    assert result.usage.wall_seconds == 2.0
+    assert signals == [(100, (), signal.SIGTERM)]
+
+
+def test_process_tree_signaler_broadcasts_once_and_signals_only_outliers(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    group_signals: list[tuple[int, int]] = []
+    individual_signals: list[tuple[int, int]] = []
+    monkeypatch.setattr(
+        "tools.performance_report.resources.os.killpg",
+        lambda pgid, selected_signal: group_signals.append((pgid, selected_signal)),
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.resources.os.kill",
+        lambda pid, selected_signal: individual_signals.append(
+            (pid, selected_signal)
+        ),
+    )
+
+    _signal_process_tree(100, (201, 202), signal.SIGTERM)
+
+    assert group_signals == [(100, signal.SIGTERM)]
+    assert individual_signals == [
+        (201, signal.SIGTERM),
+        (202, signal.SIGTERM),
+    ]
+
+
+def test_stubborn_memory_capped_tree_keeps_primary_outcome_until_reaped() -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    child_alive = True
+    kill_seen = False
+    post_kill_polls = 0
+    signals: list[tuple[int, tuple[int, ...], int]] = []
+    observed_phases: list[str | None] = []
+
+    snapshot_calls = 0
+
+    def snapshot() -> dict[int, ProcessRecord]:
+        nonlocal snapshot_calls
+        snapshot_calls += 1
+        if snapshot_calls == 1:
+            return {
+                100: ProcessRecord(100, 1, 60),
+                101: ProcessRecord(101, 100, 30),
+            }
+        return (
+            {}
+            if process.returncode is not None
+            else {100: ProcessRecord(100, 1, 110)}
+        )
+
+    def identity(pid: int) -> _ProcessIdentity | None:
+        if pid == process.pid and process.returncode is None:
+            return _ProcessIdentity(birth_token=1, process_group=process.pid)
+        if pid == 101 and child_alive:
+            return _ProcessIdentity(birth_token=2, process_group=process.pid)
+        return None
+
+    def signal_tree(pgid: int | None, members: object, selected_signal: int) -> None:
+        nonlocal kill_seen
+        signals.append(
+            (pgid, tuple(sorted(members)), selected_signal)  # type: ignore[arg-type]
+        )
+        if selected_signal == signal.SIGKILL:
+            kill_seen = True
+
+    def sleep(duration: float) -> None:
+        nonlocal child_alive, post_kill_polls
+        clock.now += duration
+        if not kill_seen:
+            return
+        post_kill_polls += 1
+        if post_kill_polls == 12:
+            process.returncode = -signal.SIGKILL
+        elif post_kill_polls == 14:
+            child_alive = False
+
+    result = supervise_worker(
+        ("worker",),
+        max_rss_bytes=100,
+        interval_seconds=0.1,
+        termination_grace_seconds=0.5,
+        snapshotter=snapshot,
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=sleep,
+        signaler=signal_tree,
+        process_identity_probe=identity,
+        observation_callback=lambda observation: observed_phases.append(
+            observation.phase
+        ),
+    )
+
+    assert result.reason == "memory_limit"
+    assert result.returncode == -signal.SIGKILL
+    assert result.signal_name == "SIGKILL"
+    assert result.teardown_escalated
+    assert result.teardown_seconds > 0.5
+    assert signals == [
+        (100, (), signal.SIGTERM),
+        (100, (), signal.SIGKILL),
+    ]
+    assert "terminating" in observed_phases
+    assert observed_phases.count("waiting-for-reap") >= 12
+    assert not child_alive
+    assert snapshot_calls > 2
+
+
+def test_stubborn_wall_timeout_keeps_primary_outcome_until_root_is_reaped() -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    kill_seen = False
+    post_kill_polls = 0
+    signals: list[tuple[int | None, tuple[int, ...], int]] = []
+
+    def identity(pid: int) -> _ProcessIdentity | None:
+        return (
+            _ProcessIdentity(birth_token=1, process_group=process.pid)
+            if pid == process.pid and process.returncode is None
+            else None
+        )
+
+    def signal_tree(
+        pgid: int | None,
+        members: object,
+        selected_signal: int,
+    ) -> None:
+        nonlocal kill_seen
+        signals.append(
+            (pgid, tuple(sorted(members)), selected_signal)  # type: ignore[arg-type]
+        )
+        if selected_signal == signal.SIGKILL:
+            kill_seen = True
+
+    def sleep(duration: float) -> None:
+        nonlocal post_kill_polls
+        clock.now += duration
+        if not kill_seen:
+            return
+        post_kill_polls += 1
+        if post_kill_polls == 3:
+            process.returncode = -signal.SIGKILL
+
+    result = supervise_worker(
+        ("worker",),
+        timeout_seconds=0.1,
+        interval_seconds=0.1,
+        termination_grace_seconds=0.2,
+        snapshotter=lambda: (
+            {}
+            if process.returncode is not None
+            else {100: ProcessRecord(100, 1, 10)}
+        ),
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=sleep,
+        signaler=signal_tree,
+        process_identity_probe=identity,
+    )
+
+    assert result.reason == "worker_timeout"
+    assert result.returncode == -signal.SIGKILL
+    assert result.teardown_escalated
+    assert signals == [
+        (100, (), signal.SIGTERM),
+        (100, (), signal.SIGKILL),
+    ]
+
+
+def test_descendant_group_change_keeps_birth_identity_until_gone() -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    child_alive = True
+    child_process_group = process.pid
+    kill_seen = False
+    post_kill_polls = 0
+    signals: list[tuple[int | None, tuple[int, ...], int]] = []
+
+    def identity(pid: int) -> _ProcessIdentity | None:
+        if pid == process.pid and process.returncode is None:
+            return _ProcessIdentity(birth_token=1, process_group=process.pid)
+        if pid == 101 and child_alive:
+            return _ProcessIdentity(
+                birth_token=2,
+                process_group=child_process_group,
+            )
+        return None
+
+    def signal_tree(
+        pgid: int | None,
+        members: object,
+        selected_signal: int,
+    ) -> None:
+        nonlocal child_process_group, kill_seen
+        selected_members = tuple(sorted(members))  # type: ignore[arg-type]
+        signals.append((pgid, selected_members, selected_signal))
+        if selected_signal == signal.SIGTERM:
+            child_process_group = 101
+        else:
+            assert selected_members == (101,)
+            kill_seen = True
+            process.returncode = -signal.SIGKILL
+
+    def sleep(duration: float) -> None:
+        nonlocal child_alive, post_kill_polls
+        clock.now += duration
+        if not kill_seen:
+            return
+        post_kill_polls += 1
+        if post_kill_polls == 3:
+            child_alive = False
+
+    result = supervise_worker(
+        ("worker",),
+        max_rss_bytes=100,
+        interval_seconds=0.1,
+        termination_grace_seconds=0.2,
+        snapshotter=lambda: {
+            **(
+                {100: ProcessRecord(100, 1, 70)}
+                if process.returncode is None
+                else {}
+            ),
+            **({101: ProcessRecord(101, 100, 40)} if child_alive else {}),
+        },
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=sleep,
+        signaler=signal_tree,
+        process_identity_probe=identity,
+    )
+
+    assert result.reason == "memory_limit"
+    assert result.returncode == -signal.SIGKILL
+    assert result.teardown_escalated
+    assert not child_alive
+    assert post_kill_polls == 3
+    assert signals == [
+        (100, (), signal.SIGTERM),
+        (100, (101,), signal.SIGKILL),
+    ]
+
+
+def test_natural_exit_does_not_signal_a_reused_descendant_pid() -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    child_identity: _ProcessIdentity | None = _ProcessIdentity(
+        birth_token=2,
+        process_group=process.pid,
+    )
+    signals: list[tuple[int | None, tuple[int, ...], int]] = []
+
+    def identity(pid: int) -> _ProcessIdentity | None:
+        if pid == process.pid and process.returncode is None:
+            return _ProcessIdentity(birth_token=1, process_group=process.pid)
+        if pid == 101:
+            return child_identity
+        return None
+
+    def sleep(duration: float) -> None:
+        nonlocal child_identity
+        clock.now += duration
+        process.returncode = 0
+        child_identity = _ProcessIdentity(
+            birth_token=3,
+            process_group=process.pid,
+        )
+
+    result = supervise_worker(
+        ("worker",),
+        interval_seconds=0.1,
+        snapshotter=lambda: {
+            **(
+                {100: ProcessRecord(100, 1, 10)}
+                if process.returncode is None
+                else {}
+            ),
+            101: ProcessRecord(
+                101,
+                100 if process.returncode is None else 1,
+                10,
+            ),
+        },
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=sleep,
+        signaler=lambda pgid, members, selected_signal: signals.append(
+            (pgid, tuple(sorted(members)), selected_signal)
+        ),
+        process_identity_probe=identity,
+    )
+
+    assert result.reason == "completed"
+    assert result.returncode == 0
+    assert signals == []
+
+
+def test_completed_root_cannot_leave_a_known_descendant_running() -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    child_alive = True
+    signals: list[tuple[int, tuple[int, ...], int]] = []
+
+    def snapshot() -> dict[int, ProcessRecord]:
+        records = (
+            {} if process.returncode is not None else {100: ProcessRecord(100, 1, 100)}
+        )
+        if child_alive:
+            records[101] = ProcessRecord(
+                101,
+                100 if process.returncode is None else 1,
+                50,
+            )
+        return records
+
+    def sleep(duration: float) -> None:
+        clock.now += duration
+        process.returncode = 0
+
+    def signal_tree(pgid: int | None, members: object, selected_signal: int) -> None:
+        nonlocal child_alive
+        signals.append(
+            (pgid, tuple(sorted(members)), selected_signal)  # type: ignore[arg-type]
+        )
+        if selected_signal == signal.SIGKILL:
+            child_alive = False
+
+    result = supervise_worker(
+        ("worker",),
+        interval_seconds=0.1,
+        termination_grace_seconds=0.1,
+        snapshotter=snapshot,
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=sleep,
+        signaler=signal_tree,
+        process_identity_probe=lambda pid: (
+            _ProcessIdentity(birth_token=pid, process_group=process.pid)
+            if (
+                (pid == process.pid and process.returncode is None)
+                or (pid == 101 and child_alive)
+            )
+            else None
+        ),
+    )
+
+    assert result.reason == "completed"
+    assert result.returncode == 0
+    assert not child_alive
+    assert signals == [
+        (100, (), signal.SIGTERM),
+        (100, (), signal.SIGKILL),
+    ]
+    assert result.teardown_escalated
+    assert result.teardown_seconds >= 0.1
+
+
+def test_completed_root_reports_graceful_descendant_teardown() -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    child_alive = True
+    signals: list[tuple[int | None, tuple[int, ...], int]] = []
+
+    def sleep(duration: float) -> None:
+        clock.now += duration
+        process.returncode = 0
+
+    def signal_tree(
+        pgid: int | None,
+        members: object,
+        selected_signal: int,
+    ) -> None:
+        nonlocal child_alive
+        signals.append(
+            (pgid, tuple(sorted(members)), selected_signal)  # type: ignore[arg-type]
+        )
+        assert selected_signal == signal.SIGTERM
+        child_alive = False
+
+    result = supervise_worker(
+        ("worker",),
+        interval_seconds=0.1,
+        termination_grace_seconds=0.2,
+        snapshotter=lambda: {
+            **(
+                {100: ProcessRecord(100, 1, 100)}
+                if process.returncode is None
+                else {}
+            ),
+            **({101: ProcessRecord(101, 100, 50)} if child_alive else {}),
+        },
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=sleep,
+        signaler=signal_tree,
+        process_identity_probe=lambda pid: (
+            _ProcessIdentity(birth_token=pid, process_group=process.pid)
+            if (
+                (pid == process.pid and process.returncode is None)
+                or (pid == 101 and child_alive)
+            )
+            else None
+        ),
+    )
+
+    assert result.reason == "completed"
+    assert result.returncode == 0
+    assert signals == [(100, (), signal.SIGTERM)]
+    assert not result.teardown_escalated
+    assert result.teardown_seconds > 0.0
+
+
+def test_supervisor_propagates_symbolica_license_to_worker_environment(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    license_value = "ordinary-test-license"
+    monkeypatch.setenv("SYMBOLICA_LICENSE", license_value)
+    process = FakeProcess()
+    process.returncode = 0
+    observed: dict[str, object] = {}
+
+    def popen(
+        command: Sequence[str],
+        *,
+        start_new_session: bool,
+        env: Mapping[str, str],
+    ) -> FakeProcess:
+        observed["command"] = tuple(command)
+        observed["start_new_session"] = start_new_session
+        observed["license"] = env.get("SYMBOLICA_LICENSE")
+        return process
+
+    result = supervise_worker(
+        ("worker", "--cell", "one"),
+        snapshotter=lambda: {},
+        popen_factory=popen,
+    )
+
+    assert observed == {
+        "command": ("worker", "--cell", "one"),
+        "start_new_session": True,
+        "license": license_value,
+    }
+    assert result.returncode == 0
+
+
+def test_supervisor_merges_explicit_worker_environment_overrides(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("SYMBOLICA_LICENSE", "ordinary-test-license")
+    process = FakeProcess()
+    process.returncode = 0
+    observed: dict[str, str | None] = {}
+
+    def popen(
+        _command: Sequence[str],
+        *,
+        start_new_session: bool,
+        env: Mapping[str, str],
+    ) -> FakeProcess:
+        assert start_new_session
+        observed["license"] = env.get("SYMBOLICA_LICENSE")
+        observed["gate"] = env.get("PYAMPLICOL_NATIVE_COMPILER_GATE_DIR")
+        observed["slots"] = env.get("PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT")
+        return process
+
+    result = supervise_worker(
+        ("worker",),
+        environment_overrides={
+            "PYAMPLICOL_NATIVE_COMPILER_GATE_DIR": "/tmp/compiler-gate",
+            "PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT": "4",
+        },
+        snapshotter=lambda: {},
+        popen_factory=popen,
+    )
+
+    assert observed == {
+        "license": "ordinary-test-license",
+        "gate": "/tmp/compiler-gate",
+        "slots": "4",
+    }
+    assert result.returncode == 0
+
+
+def test_split_worker_scrubs_import_environment_and_sets_measured_cwd(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import_environment = {
+        "PYTHONHOME",
+        "PYTHONINSPECT",
+        "PYTHONPATH",
+        "PYTHONPYCACHEPREFIX",
+        "PYTHONSTARTUP",
+        "PYTHONUSERBASE",
+        "PYAMPLICOL_EXACT_IMPORT_PATHS",
+        "PYAMPLICOL_EXACT_PYTHON_REEXEC",
+        "PYAMPLICOL_CACHE_DIR",
+        "PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP",
+        "PYAMPLICOL_NATIVE_COMPILER_GATE_DIR",
+        "PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT",
+        "VIRTUAL_ENV",
+        "_OLD_VIRTUAL_PATH",
+        "__PYVENV_LAUNCHER__",
+    }
+    for name in import_environment:
+        monkeypatch.setenv(name, f"attacker-{name}")
+    process = FakeProcess()
+    process.returncode = 0
+    observed: dict[str, object] = {}
+
+    def popen(
+        command: Sequence[str],
+        *,
+        start_new_session: bool,
+        env: Mapping[str, str],
+        cwd: str,
+    ) -> FakeProcess:
+        observed["command"] = tuple(command)
+        observed["start_new_session"] = start_new_session
+        observed["cwd"] = cwd
+        observed["present"] = import_environment.intersection(env)
+        return process
+
+    result = supervise_worker(
+        ("worker",),
+        scrub_import_environment=True,
+        environment_overrides={
+            "PYAMPLICOL_NATIVE_COMPILER_GATE_DIR": "/authenticated/gate",
+            "PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT": "4",
+        },
+        working_directory=tmp_path,
+        snapshotter=lambda: {},
+        popen_factory=popen,
+    )
+
+    assert result.returncode == 0
+    assert observed == {
+        "command": ("worker",),
+        "start_new_session": True,
+        "cwd": str(tmp_path.resolve()),
+        "present": {
+            "PYAMPLICOL_NATIVE_COMPILER_GATE_DIR",
+            "PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT",
+        },
+    }
+    with pytest.raises(ValueError, match="environment override"):
+        supervise_worker(
+            ("worker",),
+            scrub_import_environment=True,
+            environment_overrides={"PYTHONPATH": "/attacker"},
+        )
+
+
+def test_ordinary_worker_environment_remains_compatible(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYTHONPATH", "/ordinary/controller/path")
+    process = FakeProcess()
+    process.returncode = 0
+    observed: dict[str, object] = {}
+
+    def popen(
+        _command: Sequence[str],
+        *,
+        start_new_session: bool,
+        env: Mapping[str, str],
+    ) -> FakeProcess:
+        assert start_new_session
+        observed["pythonpath"] = env.get("PYTHONPATH")
+        return process
+
+    result = supervise_worker(
+        ("worker",),
+        snapshotter=lambda: {},
+        popen_factory=popen,
+    )
+
+    assert result.returncode == 0
+    assert observed["pythonpath"] == "/ordinary/controller/path"
+
+
+def test_supervisor_enforces_memory_limit_and_preserves_exit_on_probe_error() -> None:
+    process = FakeProcess()
+
+    def terminate(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    limited = supervise_worker(
+        ("worker",),
+        max_rss_bytes=100,
+        snapshotter=lambda: {
+            100: ProcessRecord(100, 1, 80),
+            101: ProcessRecord(101, 100, 30),
+        },
+        popen_factory=lambda *_args, **_kwargs: process,
+        signaler=terminate,
+    )
+    assert limited.reason == "memory_limit"
+    assert limited.usage.current_rss_bytes == 110
+    assert limited.usage.peak_rss_bytes == 110
+    assert limited.memory_limit_reason == "process-tree-rss-limit"
+
+    completed = FakeProcess()
+    completed.returncode = 7
+    unavailable = supervise_worker(
+        ("worker",),
+        max_rss_bytes=100,
+        snapshotter=lambda: (_ for _ in ()).throw(OSError("unavailable")),
+        popen_factory=lambda *_args, **_kwargs: completed,
+    )
+    assert unavailable.reason == "worker_exit"
+    assert unavailable.returncode == 7
+    assert not unavailable.usage.available
+    assert unavailable.usage.error == "unavailable"
+    assert (
+        unavailable.usage.memory_probe_reason == "process-tree-memory-probe-unavailable"
+    )
+
+
+def test_supervisor_enforces_physical_footprint_over_rss() -> None:
+    process = FakeProcess()
+
+    def terminate(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    limited = supervise_worker(
+        ("worker",),
+        max_rss_bytes=100,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 80)},
+        physical_footprint_probe=lambda _pids: {100: 150},
+        popen_factory=lambda *_args, **_kwargs: process,
+        signaler=terminate,
+    )
+
+    assert limited.reason == "memory_limit"
+    assert limited.memory_limit_bytes == 100
+    assert limited.memory_limit_reason == "darwin-process-tree-physical-footprint-limit"
+    assert limited.usage.peak_rss_bytes == 80
+    assert limited.usage.peak_physical_footprint_bytes == 150
+    assert limited.usage.peak_guard_bytes == 150
+
+
+def test_supervisor_fails_closed_when_worker_exits_during_probe_retry() -> None:
+    process = FakeProcess()
+    footprint_calls = 0
+
+    def footprint(_pids: object) -> dict[int, int]:
+        nonlocal footprint_calls
+        footprint_calls += 1
+        raise ResourceProbeError("synthetic footprint probe failure")
+
+    def exit_during_retry(_duration: float) -> None:
+        process.returncode = 0
+
+    result = supervise_worker(
+        ("worker",),
+        max_rss_bytes=100,
+        interval_seconds=0.01,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 80)},
+        physical_footprint_probe=footprint,
+        popen_factory=lambda *_args, **_kwargs: process,
+        sleeper=exit_during_retry,
+    )
+
+    assert result.reason == "memory_probe_error"
+    assert result.returncode == 0
+    assert footprint_calls == 1
+    assert not result.usage.available
+    assert (
+        result.usage.memory_probe_reason
+        == "darwin-process-tree-physical-footprint-probe-unavailable"
+    )
+
+
+def test_supervisor_terminates_after_third_required_probe_failure() -> None:
+    process = FakeProcess()
+    footprint_calls = 0
+    signals: list[int] = []
+
+    def footprint(_pids: object) -> dict[int, int]:
+        nonlocal footprint_calls
+        footprint_calls += 1
+        raise ResourceProbeError("synthetic footprint probe failure")
+
+    def terminate(_pgid: int, _members: object, selected_signal: int) -> None:
+        signals.append(selected_signal)
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        max_rss_bytes=100,
+        interval_seconds=0.01,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 80)},
+        physical_footprint_probe=footprint,
+        popen_factory=lambda *_args, **_kwargs: process,
+        sleeper=lambda _duration: None,
+        signaler=terminate,
+    )
+
+    assert result.reason == "memory_probe_error"
+    assert result.returncode == -signal.SIGTERM
+    assert footprint_calls == 3
+    assert signals == [signal.SIGTERM]
+    assert (
+        result.usage.memory_probe_reason
+        == "darwin-process-tree-physical-footprint-probe-unavailable"
+    )
+
+
+def test_supervisor_clears_recovered_probe_failure_while_worker_is_alive() -> None:
+    process = FakeProcess()
+    footprint_calls = 0
+    sleep_calls = 0
+
+    def footprint(_pids: object) -> dict[int, int]:
+        nonlocal footprint_calls
+        footprint_calls += 1
+        if footprint_calls == 1:
+            raise ResourceProbeError("synthetic footprint probe failure")
+        return {100: 90}
+
+    def complete_after_recovery(_duration: float) -> None:
+        nonlocal sleep_calls
+        sleep_calls += 1
+        if sleep_calls == 2:
+            process.returncode = 0
+
+    result = supervise_worker(
+        ("worker",),
+        max_rss_bytes=100,
+        interval_seconds=0.01,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 80)},
+        physical_footprint_probe=footprint,
+        popen_factory=lambda *_args, **_kwargs: process,
+        sleeper=complete_after_recovery,
+    )
+
+    assert result.reason == "completed"
+    assert result.returncode == 0
+    assert footprint_calls >= 2
+    assert result.usage.available
+    assert result.usage.memory_probe_reason is None
+    assert result.usage.peak_guard_bytes == 90
+
+
+def test_supervisor_enforces_cap_on_first_recovered_probe_sample() -> None:
+    process = FakeProcess()
+    footprint_calls = 0
+
+    def footprint(_pids: object) -> dict[int, int]:
+        nonlocal footprint_calls
+        footprint_calls += 1
+        if footprint_calls == 1:
+            raise ResourceProbeError("synthetic footprint probe failure")
+        return {100: 150}
+
+    def terminate(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        max_rss_bytes=100,
+        interval_seconds=0.01,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 80)},
+        physical_footprint_probe=footprint,
+        popen_factory=lambda *_args, **_kwargs: process,
+        sleeper=lambda _duration: None,
+        signaler=terminate,
+    )
+
+    assert result.reason == "memory_limit"
+    assert result.memory_limit_reason == (
+        "darwin-process-tree-physical-footprint-limit"
+    )
+    assert footprint_calls == 2
+    assert result.usage.memory_probe_reason is None
+    assert result.usage.peak_guard_bytes == 150
+
+
+def test_defaults_and_invalid_limits() -> None:
+    assert DEFAULT_SAMPLE_INTERVAL_SECONDS == 1.0
+    assert DEFAULT_ATTEMPT_OUTPUT_LIMIT_BYTES == 64 * 1024 * 1024
+    assert DEFAULT_MINIMUM_FREE_DISK_BYTES == 5 * 1024 * 1024 * 1024
+    with pytest.raises(ValueError, match="timeout_seconds"):
+        supervise_worker(("worker",), timeout_seconds=0)
+    with pytest.raises(ValueError, match="max_rss_bytes"):
+        supervise_worker(("worker",), max_rss_bytes=0)
+    with pytest.raises(ValueError, match="generation_timeout_seconds"):
+        supervise_worker(("worker",), generation_timeout_seconds=0)
+    with pytest.raises(ValueError, match="authenticated phase_channel"):
+        supervise_worker(("worker",), generation_timeout_seconds=1)
+    with pytest.raises(ValueError, match="environment override"):
+        supervise_worker(
+            ("worker",),
+            environment_overrides={"INVALID=NAME": "value"},
+        )
+    with pytest.raises(ValueError, match="stderr_limit_bytes"):
+        supervise_worker(("worker",), stderr_limit_bytes=0)
+    with pytest.raises(ValueError, match="output file limits"):
+        supervise_worker(("worker",), output_file_limits={Path("log"): 0})
+    with pytest.raises(ValueError, match="minimum_free_disk_bytes"):
+        supervise_worker(("worker",), minimum_free_disk_bytes=0)
+
+
+@pytest.mark.skipif(os.name != "posix", reason="process groups require POSIX")
+def test_supervisor_terminates_runaway_append_at_output_cap(tmp_path: Path) -> None:
+    output = tmp_path / "runaway.log"
+    script = (
+        "import time\n"
+        "from pathlib import Path\n"
+        f"stream = Path({str(output)!r}).open('ab', buffering=0)\n"
+        "block = b'x' * 4096\n"
+        "while True:\n"
+        "    stream.write(block)\n"
+        "    time.sleep(0.0001)\n"
+    )
+
+    result = supervise_worker(
+        (sys.executable, "-c", script),
+        output_file_limits={output: 32 * 1024},
+        interval_seconds=1.0,
+        termination_grace_seconds=1.0,
+    )
+
+    assert result.reason == "output_limit"
+    assert result.returncode < 0
+    assert result.output_limit_path == str(output.resolve())
+    assert result.output_limit_bytes == 32 * 1024
+    assert result.observed_output_bytes is not None
+    assert result.observed_output_bytes > result.output_limit_bytes
+    # The safety reason bypasses the ordinary one-second teardown grace.
+    assert result.teardown_seconds < 1.0
+    assert output.stat().st_size < 8 * 1024 * 1024
+
+
+@pytest.mark.parametrize(
+    ("exit_code", "expected_reason"),
+    ((0, "output_limit"), (23, "worker_exit")),
+)
+def test_exit_boundary_probes_output_without_hiding_worker_failure(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    exit_code: int,
+    expected_reason: str,
+) -> None:
+    output = tmp_path / "fast-writer.log"
+    output.write_bytes(b"x" * 33)
+    process = FakeProcess()
+    process.returncode = exit_code
+    # Keep the background guard dormant so this exercises the synchronous
+    # final probe after poll observes that the worker has already exited.
+    monkeypatch.setattr(
+        "tools.performance_report.resources.DEFAULT_STORAGE_SAFETY_INTERVAL_SECONDS",
+        60.0,
+    )
+
+    result = supervise_worker(
+        ("worker",),
+        output_file_limits={output: 32},
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 80)},
+        popen_factory=lambda *_args, **_kwargs: process,
+    )
+
+    assert result.reason == expected_reason
+    assert result.returncode == exit_code
+    assert result.output_limit_path == str(output.resolve())
+    assert result.output_limit_bytes == 32
+    assert result.observed_output_bytes == 33
+
+
+def test_storage_safety_precedes_cancellation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    output = tmp_path / "cancel-race.log"
+    output.write_bytes(b"x" * 33)
+    process = FakeProcess()
+    signals: list[int] = []
+    monkeypatch.setattr(
+        "tools.performance_report.resources.DEFAULT_STORAGE_SAFETY_INTERVAL_SECONDS",
+        60.0,
+    )
+
+    def signal_tree(
+        _pgid: int | None,
+        _members: object,
+        selected_signal: int,
+    ) -> None:
+        signals.append(selected_signal)
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        output_file_limits={output: 32},
+        cancellation_requested=lambda: True,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 80)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        signaler=signal_tree,
+    )
+
+    assert result.reason == "output_limit"
+    assert result.returncode == -signal.SIGTERM
+    assert signals == [signal.SIGTERM]
+
+
+def test_supervisor_terminates_when_free_disk_reserve_is_crossed(
+    tmp_path: Path,
+) -> None:
+    process = FakeProcess()
+    signals: list[int] = []
+
+    def signal_tree(
+        _pgid: int | None,
+        _members: object,
+        selected_signal: int,
+    ) -> None:
+        signals.append(selected_signal)
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        minimum_free_disk_bytes=10_000,
+        disk_probe_path=tmp_path,
+        disk_free_probe=lambda _path: 9_999,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 80)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        sleeper=lambda _duration: None,
+        signaler=signal_tree,
+    )
+
+    assert result.reason == "disk_space_limit"
+    assert result.minimum_free_disk_bytes == 10_000
+    assert result.observed_free_disk_bytes == 9_999
+    assert signals == [signal.SIGTERM]
+
+
+def test_supervisor_preserves_nonzero_worker_exit() -> None:
+    result = supervise_worker(
+        (sys.executable, "-c", "raise SystemExit(23)"),
+        interval_seconds=0.01,
+        capture_stderr=True,
+    )
+
+    assert result.reason == "worker_exit"
+    assert result.returncode == 23
+    assert result.signal_name is None
+    assert result.signal_number is None
+    assert result.pid is not None
+    assert result.pid in result.member_pids
+    assert result.started_at_utc is not None
+    assert result.finished_at_utc is not None
+    assert result.supervisor_stderr is None
+
+
+@pytest.mark.parametrize(
+    ("returncode", "expected_signal"),
+    (
+        (-signal.SIGSEGV, "SIGSEGV"),
+        (-signal.SIGKILL, "SIGKILL"),
+    ),
+)
+def test_supervisor_decodes_worker_signal_exit_without_crashing_a_child(
+    returncode: int,
+    expected_signal: str,
+) -> None:
+    process = FakeProcess()
+    process.returncode = returncode
+
+    result = supervise_worker(
+        ("worker",),
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+    )
+
+    assert result.reason == "worker_exit"
+    assert result.returncode == returncode
+    assert result.signal_name == expected_signal
+    assert result.signal_number == -returncode
+    assert result.pid == process.pid
+    assert result.member_pids == (process.pid,)
+
+
+def test_supervisor_retains_bounded_native_abort_stderr() -> None:
+    marker = "native evaluator abort: synthetic fault"
+    process = FakeProcess(stderr=f"{marker}\n".encode())
+    process.returncode = -signal.SIGABRT
+
+    result = supervise_worker(
+        ("worker",),
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        capture_stderr=True,
+        stderr_limit_bytes=32,
+    )
+
+    assert result.reason == "worker_exit"
+    assert result.returncode == -signal.SIGABRT
+    assert result.signal_name == "SIGABRT"
+    assert result.supervisor_stderr is not None
+    assert result.supervisor_stderr.endswith("synthetic fault\n")
+    assert result.supervisor_stderr_truncated
+    assert result.supervisor_stderr_limit_bytes == 32
+
+
+def test_worker_exit_remains_primary_when_phase_state_also_fails(
+    tmp_path: Path,
+) -> None:
+    process = FakeProcess()
+    process.returncode = -signal.SIGSEGV
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    channel.path.write_text("{malformed", encoding="ascii")
+
+    result = supervise_worker(
+        ("worker",),
+        generation_timeout_seconds=2.0,
+        phase_channel=channel,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+    )
+
+    assert result.reason == "worker_exit"
+    assert result.returncode == -signal.SIGSEGV
+    assert result.signal_name == "SIGSEGV"
+    assert result.phase_state_error is not None
+    assert "valid JSON" in result.phase_state_error
+    assert result.generation_phase is not None
+    assert result.generation_phase.supervisor_reason == "worker_exit"
+
+
+def test_generation_limit_excludes_preparation_and_post_generation(
+    tmp_path: Path,
+) -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=process.pid,
+        clock_ns=lambda: int(clock.now * 1_000_000_000),
+    )
+    generation = reporter.generation()
+    sleep_count = 0
+    signals: list[int] = []
+
+    def sleep(_duration: float) -> None:
+        nonlocal sleep_count
+        sleep_count += 1
+        if sleep_count == 1:
+            clock.now = 50.0
+            generation.__enter__()
+        elif sleep_count == 2:
+            clock.now = 51.0
+            generation.__exit__(None, None, None)
+        else:
+            clock.now = 101.0
+            process.returncode = 0
+
+    def signal_tree(_pgid: int, _members: object, selected_signal: int) -> None:
+        signals.append(selected_signal)
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        generation_timeout_seconds=2.0,
+        phase_channel=channel,
+        interval_seconds=1.0,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=sleep,
+        signaler=signal_tree,
+    )
+
+    assert result.reason == "completed"
+    assert result.returncode == 0
+    assert signals == []
+    assert result.generation_phase is not None
+    assert result.generation_phase.authenticated
+    assert result.generation_phase.supervisor_reason == "completed"
+    assert result.generation_phase.final_phase == "post-generation"
+    assert result.generation_phase.generation_elapsed_seconds == 1.0
+
+
+def test_manual_generation_guard_includes_worker_preparation(
+    tmp_path: Path,
+) -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    WorkerPhaseReporter(
+        channel,
+        worker_pid=process.pid,
+        clock_ns=lambda: int(clock.now * 1_000_000_000),
+    )
+
+    def signal_tree(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        generation_timeout_seconds=2.0,
+        generation_guard_includes_preparation=True,
+        phase_channel=channel,
+        interval_seconds=1.0,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=clock.sleep,
+        signaler=signal_tree,
+    )
+
+    assert result.reason == "generation_timeout"
+    assert result.usage.wall_seconds == 2.0
+    assert result.generation_phase is not None
+    assert result.generation_phase.final_phase == "pre-generation"
+    assert result.generation_phase.generation_elapsed_seconds == 2.0
+
+
+@pytest.mark.parametrize(
+    ("stage", "expected_reason"),
+    (
+        ("profiling", "profiling_timeout"),
+        ("validation", "validation_timeout"),
+    ),
+)
+def test_supervisor_enforces_authenticated_post_generation_stage_budget(
+    tmp_path: Path,
+    stage: str,
+    expected_reason: str,
+) -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / f"{stage}.json")
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=process.pid,
+        clock_ns=lambda: int(clock.now * 1_000_000_000),
+        track_post_generation_stages=True,
+    )
+    with reporter.generation():
+        pass
+    reporter.profiling_started()
+    if stage == "validation":
+        reporter.validation_started()
+
+    def signal_tree(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        timeout_seconds=30.0,
+        generation_timeout_seconds=10.0,
+        profiling_timeout_seconds=2.0,
+        validation_timeout_seconds=2.0,
+        phase_channel=channel,
+        interval_seconds=1.0,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=clock.sleep,
+        signaler=signal_tree,
+    )
+
+    assert result.reason == expected_reason
+    assert result.returncode == -signal.SIGTERM
+    assert result.usage.wall_seconds == 2.0
+
+
+def test_supervisor_allows_authenticated_stage_budget_without_generation_limit(
+    tmp_path: Path,
+) -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / "profiling-only.json")
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=process.pid,
+        clock_ns=lambda: int(clock.now * 1_000_000_000),
+        track_post_generation_stages=True,
+    )
+    with reporter.generation():
+        pass
+    reporter.profiling_started()
+
+    def signal_tree(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        profiling_timeout_seconds=2.0,
+        phase_channel=channel,
+        interval_seconds=1.0,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=clock.sleep,
+        signaler=signal_tree,
+    )
+
+    assert result.reason == "profiling_timeout"
+    assert result.generation_phase is None
+
+
+@pytest.mark.parametrize(
+    ("last_transition", "expected_phase"),
+    (
+        ("generation", "post-generation"),
+        ("profiling", "profiling"),
+        ("validation", "validation"),
+        ("complete", "complete"),
+    ),
+)
+def test_phase_transitions_during_slow_observation_use_fresh_clock(
+    tmp_path: Path,
+    last_transition: str,
+    expected_phase: str,
+) -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / f"{last_transition}.json")
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=process.pid,
+        clock_ns=lambda: int(clock.now * 1_000_000_000),
+        track_post_generation_stages=True,
+    )
+    transitioned = False
+
+    def observe(_observation: object) -> None:
+        nonlocal transitioned
+        if transitioned:
+            return
+        transitioned = True
+        # Longer than the sampling interval: the old supervisor compared the
+        # resulting authenticated timestamps with its pre-callback clock and
+        # rejected them as being outside the process lifetime.
+        clock.now = 5.0
+        with reporter.generation():
+            pass
+        if last_transition in {"profiling", "validation", "complete"}:
+            reporter.profiling_started()
+        if last_transition in {"validation", "complete"}:
+            reporter.validation_started()
+        if last_transition == "complete":
+            reporter.complete()
+
+    def sleep(duration: float) -> None:
+        clock.now += duration
+        process.returncode = 0
+
+    def signal_tree(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        generation_timeout_seconds=60.0,
+        profiling_timeout_seconds=60.0,
+        validation_timeout_seconds=60.0,
+        phase_channel=channel,
+        interval_seconds=1.0,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=sleep,
+        signaler=signal_tree,
+        observation_callback=observe,
+    )
+
+    assert result.reason == "completed"
+    assert result.returncode == 0
+    assert result.phase_state_error is None
+    assert result.generation_phase is not None
+    assert result.generation_phase.authenticated
+    assert result.generation_phase.final_phase == expected_phase
+
+
+def test_phase_monitor_still_rejects_authenticated_future_timestamp(
+    tmp_path: Path,
+) -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / "future.json")
+    WorkerPhaseReporter(
+        channel,
+        worker_pid=process.pid,
+        clock_ns=lambda: 10_000_000_000,
+    )
+
+    def signal_tree(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        generation_timeout_seconds=60.0,
+        phase_channel=channel,
+        interval_seconds=1.0,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=clock.sleep,
+        signaler=signal_tree,
+    )
+
+    assert result.reason == "phase_state_error"
+    assert result.returncode == -signal.SIGTERM
+    assert result.phase_state_error == (
+        "worker phase-state transition timestamp is outside the supervised "
+        "process lifetime"
+    )
+    assert result.generation_phase is not None
+    assert not result.generation_phase.authenticated
+
+
+@pytest.mark.parametrize(
+    ("boundaries", "expected_reason"),
+    (
+        ((0.0, 3.0, 3.5, 4.0), "generation_timeout"),
+        ((0.0, 1.0, 4.0, 4.5), "profiling_timeout"),
+        ((0.0, 1.0, 1.5, 4.0), "validation_timeout"),
+        # Deterministic timeline precedence chooses the earlier profiling
+        # overrun when both closed stages crossed their limits between polls.
+        ((0.0, 1.0, 4.0, 7.0), "profiling_timeout"),
+    ),
+)
+def test_supervisor_enforces_closed_stage_boundaries_between_samples(
+    tmp_path: Path,
+    boundaries: tuple[float, float, float, float],
+    expected_reason: str,
+) -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / f"{expected_reason}.json")
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=process.pid,
+        clock_ns=lambda: int(clock.now * 1_000_000_000),
+        track_post_generation_stages=True,
+    )
+    transitioned = False
+
+    def cross_all_boundaries(_duration: float) -> None:
+        nonlocal transitioned
+        if transitioned:
+            clock.now += 1.0
+            return
+        transitioned = True
+        generation_start, generation_end, validation_start, complete = boundaries
+        clock.now = generation_start
+        generation = reporter.generation()
+        generation.__enter__()
+        clock.now = generation_end
+        generation.__exit__(None, None, None)
+        reporter.profiling_started()
+        clock.now = validation_start
+        reporter.validation_started()
+        clock.now = complete
+        reporter.complete()
+
+    def signal_tree(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        timeout_seconds=30.0,
+        generation_timeout_seconds=2.0,
+        profiling_timeout_seconds=2.0,
+        validation_timeout_seconds=2.0,
+        phase_channel=channel,
+        interval_seconds=1.0,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=cross_all_boundaries,
+        signaler=signal_tree,
+    )
+
+    assert result.reason == expected_reason
+    assert result.returncode == -signal.SIGTERM
+
+
+@pytest.mark.parametrize(
+    ("phase", "expected_phase"),
+    (
+        ("preparation", "pre-generation"),
+        ("generation", "generation"),
+        ("profiling", "post-generation"),
+    ),
+)
+def test_cancellation_terminates_the_process_tree_in_every_worker_phase(
+    tmp_path: Path,
+    phase: str,
+    expected_phase: str,
+) -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / f"{phase}.json")
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=process.pid,
+        clock_ns=lambda: int(clock.now * 1_000_000_000),
+    )
+    generation = reporter.generation()
+    if phase == "generation":
+        generation.__enter__()
+    elif phase == "profiling":
+        with generation:
+            pass
+    cancellation = False
+    signals: list[tuple[int, tuple[int, ...], int]] = []
+
+    def sleep(duration: float) -> None:
+        nonlocal cancellation
+        clock.now += duration
+        cancellation = True
+
+    def signal_tree(pgid: int | None, members: object, selected_signal: int) -> None:
+        signals.append(
+            (pgid, tuple(sorted(members)), selected_signal)  # type: ignore[arg-type]
+        )
+        process.returncode = -selected_signal
+
+    try:
+        result = supervise_worker(
+            ("worker",),
+            generation_timeout_seconds=60.0,
+            phase_channel=channel,
+            interval_seconds=1.0,
+            snapshotter=lambda: {
+                100: ProcessRecord(100, 1, 100),
+                101: ProcessRecord(101, 100, 50),
+            },
+            popen_factory=lambda *_args, **_kwargs: process,
+            clock=clock,
+            sleeper=sleep,
+            signaler=signal_tree,
+            cancellation_requested=lambda: cancellation,
+        )
+    finally:
+        if phase == "generation":
+            generation.__exit__(None, None, None)
+
+    assert result.reason == "cancelled"
+    assert result.returncode == -signal.SIGTERM
+    assert signals == [(100, (), signal.SIGTERM)]
+    assert result.generation_phase is not None
+    assert result.generation_phase.authenticated
+    assert result.generation_phase.final_phase == expected_phase
+
+
+def test_supervisor_accepts_completed_zero_work_generation_phase(
+    tmp_path: Path,
+) -> None:
+    clock = FakeClock()
+    clock.now = 10.0
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=process.pid,
+        clock_ns=lambda: int(clock.now * 1_000_000_000),
+    )
+    with reporter.generation():
+        pass
+    process.returncode = 0
+
+    result = supervise_worker(
+        ("worker",),
+        generation_timeout_seconds=2.0,
+        phase_channel=channel,
+        interval_seconds=1.0,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=clock.sleep,
+    )
+
+    assert result.reason == "completed"
+    assert result.returncode == 0
+    assert result.generation_phase is not None
+    assert result.generation_phase.authenticated
+    assert result.generation_phase.final_sequence == 2
+    assert result.generation_phase.final_phase == "post-generation"
+    assert result.generation_phase.generation_elapsed_seconds == 0.0
+
+
+def test_generation_limit_terminates_only_active_generation(
+    tmp_path: Path,
+) -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    reporter = WorkerPhaseReporter(
+        channel,
+        worker_pid=process.pid,
+        clock_ns=lambda: int(clock.now * 1_000_000_000),
+    )
+    generation = reporter.generation()
+    sleep_count = 0
+
+    def sleep(_duration: float) -> None:
+        nonlocal sleep_count
+        sleep_count += 1
+        if sleep_count == 1:
+            clock.now = 50.0
+            generation.__enter__()
+        else:
+            clock.now += 1.0
+
+    def signal_tree(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        generation_timeout_seconds=2.0,
+        phase_channel=channel,
+        interval_seconds=1.0,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=sleep,
+        signaler=signal_tree,
+    )
+
+    assert result.reason == "generation_timeout"
+    assert result.returncode == -signal.SIGTERM
+    assert result.usage.wall_seconds == 52.0
+    assert result.generation_phase is not None
+    assert result.generation_phase.authenticated
+    assert result.generation_phase.supervisor_reason == "generation_timeout"
+    assert result.generation_phase.final_phase == "generation"
+    assert result.generation_phase.generation_elapsed_seconds == 2.0
+
+
+def test_generation_phase_monitor_fails_closed_on_malformed_state(
+    tmp_path: Path,
+) -> None:
+    clock = FakeClock()
+    process = FakeProcess()
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    channel.path.write_text("{malformed", encoding="ascii")
+
+    def signal_tree(_pgid: int, _members: object, selected_signal: int) -> None:
+        process.returncode = -selected_signal
+
+    result = supervise_worker(
+        ("worker",),
+        generation_timeout_seconds=2.0,
+        phase_channel=channel,
+        snapshotter=lambda: {100: ProcessRecord(100, 1, 100)},
+        popen_factory=lambda *_args, **_kwargs: process,
+        clock=clock,
+        sleeper=clock.sleep,
+        signaler=signal_tree,
+    )
+
+    assert result.reason == "phase_state_error"
+    assert result.returncode == -signal.SIGTERM
+    assert result.generation_phase is not None
+    assert not result.generation_phase.authenticated
+    assert result.generation_phase.supervisor_reason == "phase_state_error"
+    assert "valid JSON" in str(result.generation_phase.error)
diff --git a/pyamplicol/tests/unit/test_performance_report_runtime_evidence.py b/pyamplicol/tests/unit/test_performance_report_runtime_evidence.py
new file mode 100644
index 0000000000..605e2e8a4e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_runtime_evidence.py
@@ -0,0 +1,274 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tools.performance_report import runtime_evidence
+
+
+def _isolate_bytecode(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    prefix = tmp_path / "absent-cache-prefix"
+    assert not prefix.exists()
+    monkeypatch.setattr(sys, "dont_write_bytecode", True)
+    monkeypatch.setattr(sys, "pycache_prefix", str(prefix))
+    monkeypatch.setattr(
+        runtime_evidence,
+        "_isolated_startup_flags",
+        lambda: (True, True, True),
+    )
+
+
+def test_source_only_bytecode_policy_requires_both_controls(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    monkeypatch.setattr(
+        runtime_evidence,
+        "_isolated_startup_flags",
+        lambda: (True, True, True),
+    )
+    monkeypatch.setattr(sys, "dont_write_bytecode", False)
+    monkeypatch.setattr(sys, "pycache_prefix", None)
+    with pytest.raises(runtime_evidence.RuntimeEvidenceError, match="Python -B"):
+        runtime_evidence.source_only_bytecode_policy()
+
+    monkeypatch.setattr(sys, "dont_write_bytecode", True)
+    with pytest.raises(
+        runtime_evidence.RuntimeEvidenceError,
+        match="PYTHONPYCACHEPREFIX",
+    ):
+        runtime_evidence.source_only_bytecode_policy()
+
+    prefix = tmp_path / "populated"
+    prefix.mkdir()
+    monkeypatch.setattr(sys, "pycache_prefix", str(prefix))
+    with pytest.raises(runtime_evidence.RuntimeEvidenceError, match="remain absent"):
+        runtime_evidence.source_only_bytecode_policy()
+
+
+def test_package_identity_is_stable_and_ignores_ineligible_cache_namespace(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _isolate_bytecode(monkeypatch, tmp_path)
+    package = tmp_path / "pyamplicol"
+    cache = package / "__pycache__"
+    submodule = package / "submodule"
+    cache.mkdir(parents=True)
+    submodule.mkdir()
+    (package / "__init__.py").write_text("VALUE = 1\n", encoding="utf-8")
+    (submodule / "data.bin").write_bytes(b"\x00\x01")
+    (cache / "__init__.cpython-test.pyc").write_bytes(b"ineligible")
+
+    first = runtime_evidence.python_package_tree_identity(package)
+    second = runtime_evidence.python_package_tree_identity(package)
+
+    assert first == second
+    assert first["kind"] == "pyamplicol-python-package-tree-v2"
+    assert first["file_count"] == 2
+    assert first["member_set_stable"] is True
+    assert first["namespace_bound_to_root_fd"] is True
+    assert first["bytecode_policy"] == {
+        "kind": "pyamplicol-source-only-bytecode-policy-v1",
+        "dont_write_bytecode": True,
+        "external_pycache_prefix": True,
+        "external_pycache_prefix_absent": True,
+        "package_local_bytecode_eligible": False,
+        "isolated_startup": True,
+        "site_initialization": False,
+        "python_environment_ignored_at_startup": True,
+    }
+
+    (package / "__init__.py").write_text("VALUE = 2\n", encoding="utf-8")
+    assert runtime_evidence.python_package_tree_identity(package)["sha256"] != first[
+        "sha256"
+    ]
+
+
+def test_package_identity_rejects_sourceless_bytecode_and_symlinks(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _isolate_bytecode(monkeypatch, tmp_path)
+    package = tmp_path / "pyamplicol"
+    package.mkdir()
+    (package / "__init__.py").write_bytes(b"")
+    bytecode = package / "injected.pyc"
+    bytecode.write_bytes(b"eligible sourceless bytecode")
+    with pytest.raises(
+        runtime_evidence.RuntimeEvidenceError,
+        match="sourceless bytecode",
+    ):
+        runtime_evidence.python_package_tree_identity(package)
+
+    bytecode.unlink()
+    target = package / "target.py"
+    target.write_bytes(b"VALUE = 1\n")
+    (package / "alias.py").symlink_to(target)
+    with pytest.raises(
+        runtime_evidence.RuntimeEvidenceError,
+        match="not a regular file",
+    ):
+        runtime_evidence.python_package_tree_identity(package)
+
+
+def test_package_identity_binds_ordered_shadowing_roots(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _isolate_bytecode(monkeypatch, tmp_path)
+    first = tmp_path / "first" / "pyamplicol"
+    second = tmp_path / "second" / "pyamplicol"
+    first.mkdir(parents=True)
+    second.mkdir(parents=True)
+    (first / "__init__.py").write_text("ORIGIN = 'first'\n", encoding="utf-8")
+    (second / "__init__.py").write_text("ORIGIN = 'second'\n", encoding="utf-8")
+
+    forward = runtime_evidence.python_package_tree_identity((first, second))
+    reverse = runtime_evidence.python_package_tree_identity((second, first))
+
+    assert forward["roots"] == [str(first.resolve()), str(second.resolve())]
+    assert reverse["roots"] == [str(second.resolve()), str(first.resolve())]
+    assert forward["sha256"] != reverse["sha256"]
+
+
+def _module(
+    origin: Path,
+    *,
+    cached: Path | None = None,
+    namespace: bool = False,
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        __file__=None if namespace else str(origin),
+        __cached__=None if cached is None else str(cached),
+        __spec__=SimpleNamespace(
+            origin=None if namespace else str(origin),
+            submodule_search_locations=[str(origin)] if namespace else None,
+        ),
+    )
+
+
+def test_loaded_origins_are_exact_authenticated_members(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _isolate_bytecode(monkeypatch, tmp_path)
+    package = tmp_path / "pyamplicol"
+    package.mkdir()
+    package_init = package / "__init__.py"
+    package_init.write_text("VALUE = 1\n", encoding="utf-8")
+    cache = package / "__pycache__" / "__init__.cpython-test.pyc"
+    cache.parent.mkdir()
+    cache.write_bytes(b"ordinary pip-created bytecode cache")
+    native = package / "_rusticol.so"
+    native.write_bytes(b"native")
+    expected_tree = runtime_evidence.python_package_tree_identity(package)
+    expected_native = runtime_evidence._path_file_identity(native)
+    fake_sys = SimpleNamespace(
+        dont_write_bytecode=True,
+        pycache_prefix=sys.pycache_prefix,
+        modules={
+            "pyamplicol": _module(package_init, cached=cache),
+            "pyamplicol._rusticol": _module(native),
+        },
+    )
+    monkeypatch.setattr(runtime_evidence, "sys", fake_sys)
+
+    policy = runtime_evidence.loaded_pyamplicol_origin_policy(
+        package,
+        native_extension=native,
+        expected_package_identity=expected_tree,
+        expected_native_identity=expected_native,
+    )
+
+    assert policy["observed_module_count"] == 2
+    assert len(policy["observations"]) == 2
+    assert len(policy["observations_sha256"]) == 64
+
+
+def test_loaded_origins_reject_actual_sourceless_bytecode(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _isolate_bytecode(monkeypatch, tmp_path)
+    package = tmp_path / "pyamplicol"
+    package.mkdir()
+    package_init = package / "__init__.py"
+    package_init.write_text("VALUE = 1\n", encoding="utf-8")
+    native = package / "_rusticol.so"
+    native.write_bytes(b"native")
+    expected_tree = runtime_evidence.python_package_tree_identity(package)
+    expected_native = runtime_evidence._path_file_identity(native)
+    bytecode = package / "__pycache__" / "injected.pyc"
+    bytecode.parent.mkdir()
+    bytecode.write_bytes(b"sourceless bytecode")
+    fake_sys = SimpleNamespace(
+        dont_write_bytecode=True,
+        pycache_prefix=sys.pycache_prefix,
+        modules={"pyamplicol.injected": _module(bytecode)},
+    )
+    monkeypatch.setattr(runtime_evidence, "sys", fake_sys)
+
+    with pytest.raises(
+        runtime_evidence.RuntimeEvidenceError,
+        match="used sourceless bytecode",
+    ):
+        runtime_evidence.loaded_pyamplicol_origin_policy(
+            package,
+            native_extension=native,
+            expected_package_identity=expected_tree,
+            expected_native_identity=expected_native,
+        )
+
+
+def test_loaded_origins_reject_unrecorded_and_excluded_members(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _isolate_bytecode(monkeypatch, tmp_path)
+    package = tmp_path / "pyamplicol"
+    cache = package / "__pycache__"
+    cache.mkdir(parents=True)
+    package_init = package / "__init__.py"
+    package_init.write_text("VALUE = 1\n", encoding="utf-8")
+    native = package / "_rusticol.so"
+    native.write_bytes(b"native")
+    expected_tree = runtime_evidence.python_package_tree_identity(package)
+    expected_native = runtime_evidence._path_file_identity(native)
+    injected = package / "injected.py"
+    injected.write_text("VALUE = 2\n", encoding="utf-8")
+    fake_sys = SimpleNamespace(
+        dont_write_bytecode=True,
+        pycache_prefix=sys.pycache_prefix,
+        modules={"pyamplicol": _module(injected)},
+    )
+    monkeypatch.setattr(runtime_evidence, "sys", fake_sys)
+    with pytest.raises(
+        runtime_evidence.RuntimeEvidenceError,
+        match="preimport identity",
+    ):
+        runtime_evidence.loaded_pyamplicol_origin_policy(
+            package,
+            native_extension=native,
+            expected_package_identity=expected_tree,
+            expected_native_identity=expected_native,
+        )
+
+    injected.unlink()
+    cached_source = cache / "injected.py"
+    cached_source.write_text("VALUE = 3\n", encoding="utf-8")
+    fake_sys.modules = {"pyamplicol": _module(cached_source)}
+    with pytest.raises(
+        runtime_evidence.RuntimeEvidenceError,
+        match="excluded cache bytes",
+    ):
+        runtime_evidence.loaded_pyamplicol_origin_policy(
+            package,
+            native_extension=native,
+            expected_package_identity=expected_tree,
+            expected_native_identity=expected_native,
+        )
diff --git a/pyamplicol/tests/unit/test_performance_report_source_identity.py b/pyamplicol/tests/unit/test_performance_report_source_identity.py
new file mode 100644
index 0000000000..4313e16661
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_source_identity.py
@@ -0,0 +1,401 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.source_identity import (
+    PUBLICATION_SOURCE_IDENTITY_SCHEMA,
+    SOURCE_IDENTITY_SCHEMA,
+    ReportSourceIdentityError,
+    inspect_report_publication,
+    inspect_report_source,
+    require_eligible_report_source,
+    require_report_only_publication,
+)
+
+
+def _git(repo: Path, *arguments: str) -> str:
+    completed = subprocess.run(
+        ("git", *arguments),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
+def _repository(tmp_path: Path) -> Path:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git(repo, "init")
+    _git(repo, "config", "user.email", "report@example.invalid")
+    _git(repo, "config", "user.name", "Report Test")
+    (repo / "src").mkdir()
+    (repo / "src/evaluator.py").write_text("VALUE = 1\n", encoding="utf-8")
+    (repo / "docs/arxiv/results").mkdir(parents=True)
+    (repo / "docs/arxiv/results/cache.json").write_text(
+        "{}\n",
+        encoding="ascii",
+    )
+    (repo / "docs/arxiv/result_example_table.tex").write_text(
+        "% generated\n",
+        encoding="ascii",
+    )
+    profile = repo / "docs/performance_reports/macbook_M3"
+    (profile / "results").mkdir(parents=True)
+    (profile / "pyAmpliCol.tex").write_text("% report\n", encoding="ascii")
+    (profile / "result_tables.py").write_text("# entry point\n", encoding="ascii")
+    (profile / "results/cache.json").write_text("{}\n", encoding="ascii")
+    _git(repo, "add", ".")
+    _git(repo, "commit", "-m", "fixture")
+    return repo
+
+
+def test_source_identity_records_commit_tree_and_clean_state(
+    tmp_path: Path,
+) -> None:
+    repo = _repository(tmp_path)
+
+    identity = require_eligible_report_source(repo)
+
+    assert identity.revision == _git(repo, "rev-parse", "HEAD")
+    assert identity.tree == _git(repo, "rev-parse", "HEAD^{tree}")
+    assert identity.dirty_paths == ()
+    assert identity.provenance() == {
+        "report_source_identity_schema": SOURCE_IDENTITY_SCHEMA,
+        "report_source_revision": identity.revision,
+        "report_source_tree": identity.tree,
+        "report_measured_source_revision": identity.revision,
+        "report_measured_source_tree": identity.tree,
+        "report_source_clean": True,
+    }
+
+
+def test_source_identity_rejects_a_nested_path_inside_an_outer_checkout(
+    tmp_path: Path,
+) -> None:
+    repo = _repository(tmp_path)
+    nested = repo / "scratch/repo"
+    nested.mkdir(parents=True)
+
+    with pytest.raises(ReportSourceIdentityError, match="not the repository root"):
+        inspect_report_source(nested)
+
+
+def test_generated_report_outputs_do_not_dirty_measurement_source(
+    tmp_path: Path,
+) -> None:
+    repo = _repository(tmp_path)
+    (repo / "docs/arxiv/results/cache.json").write_text(
+        '{"measured":true}\n'
+    )
+    (repo / "docs/arxiv/result_example_table.tex").write_text("% refreshed\n")
+    profile = repo / "docs/performance_reports/macbook_M3"
+    (profile / "results/cache.json").write_text('{"measured":true}\n')
+    (profile / "result_example_table.tex").write_text("% generated\n")
+    (profile / "result_validation_summary.tex").write_text("% summary\n")
+    (profile / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.4\n")
+    (profile / "pyAmpliCol.aux").write_text("\\relax\n")
+    summary = profile / "campaign_summary_ids"
+    summary.mkdir()
+    (summary / "error.txt").write_text("cell-a\n", encoding="utf-8")
+    campaign_artifacts = profile / "campaign_artifacts"
+    (campaign_artifacts / "attempts/cell-a").mkdir(parents=True)
+    (campaign_artifacts / "attempts/cell-a/result.json").write_text(
+        '{"status":"ok"}\n', encoding="utf-8"
+    )
+    (campaign_artifacts / "coordination/locks").mkdir(parents=True)
+    (campaign_artifacts / "coordination/locks/cell.lock").write_text(
+        "locked\n", encoding="utf-8"
+    )
+    artifacts = repo / ".artifacts/performance-report/macbook_M3"
+    artifacts.mkdir(parents=True)
+    (artifacts / "attempt.bin").write_bytes(b"attempt")
+
+    identity = require_eligible_report_source(repo)
+
+    assert identity.eligible
+    assert identity.dirty_paths == ()
+
+
+@pytest.mark.parametrize(
+    "path",
+    (
+        "docs/performance_reports/macbook_M3/result_tables.py",
+        "docs/performance_reports/macbook_M3/pyAmpliCol.tex",
+        "docs/performance_reports/macbook_M3/section_scope.tex",
+        "docs/performance_reports/macbook_M3/README.md",
+        "docs/performance_reports/macbook_M3/report-workspace.json",
+        "docs/performance_reports/macbook_M3/arbitrary.txt",
+        "docs/performance_reports/macbook_M3/results/nested/raw.json",
+        "docs/performance_reports/macbook_M3/campaign_summary_ids/nested/error.txt",
+        "docs/performance_reports/macbook_M3/campaign_summary_ids/error.json",
+        "docs/performance_reports/macbook_M3/"
+        ".campaign_summary_ids.deadbeef.tmp/error.txt",
+        "docs/performance_reports/macbook_M3/campaign_artifact/attempt.bin",
+        "docs/performance_reports/campaign_artifacts/attempt.bin",
+        "scratch/macbook_M3/campaign_artifacts/attempt.bin",
+    ),
+)
+def test_profile_scaffold_or_arbitrary_changes_dirty_measurement_source(
+    tmp_path: Path,
+    path: str,
+) -> None:
+    repo = _repository(tmp_path)
+    target = repo / path
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text("changed\n", encoding="utf-8")
+
+    identity = inspect_report_source(repo)
+
+    assert path in identity.dirty_paths
+
+
+def test_tracked_or_untracked_source_changes_are_ineligible(
+    tmp_path: Path,
+) -> None:
+    repo = _repository(tmp_path)
+    (repo / "src/evaluator.py").write_text("VALUE = 2\n", encoding="utf-8")
+    (repo / "tools").mkdir()
+    (repo / "tools/untracked.py").write_text("VALUE = 3\n", encoding="utf-8")
+
+    identity = inspect_report_source(repo)
+
+    assert not identity.eligible
+    assert identity.dirty_paths == (
+        "src/evaluator.py",
+        "tools/untracked.py",
+    )
+    with pytest.raises(
+        ReportSourceIdentityError,
+        match=r"dirty source paths: src/evaluator\.py, tools/untracked\.py",
+    ):
+        require_eligible_report_source(repo)
+
+
+def test_generated_profile_environment_is_a_report_output(
+    tmp_path: Path,
+) -> None:
+    repo = _repository(tmp_path)
+    profile = repo / "docs/performance_reports/macbook_M3"
+    (profile / "report_environment.json").write_text(
+        '{"status":"authenticated"}\n',
+        encoding="ascii",
+    )
+    (profile / "report_environment.tex").write_text(
+        "% authenticated environment\n",
+        encoding="ascii",
+    )
+
+    identity = require_eligible_report_source(repo)
+
+    assert identity.eligible
+    assert identity.dirty_paths == ()
+
+
+def _commit_path(repo: Path, path: str, content: str) -> str:
+    target = repo / path
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(content, encoding="utf-8")
+    _git(repo, "add", path)
+    _git(repo, "commit", "-m", f"update {path}")
+    return _git(repo, "rev-parse", "HEAD")
+
+
+def test_publication_descendant_authenticates_both_shas_and_report_paths(
+    tmp_path: Path,
+) -> None:
+    repo = _repository(tmp_path)
+    measured = _git(repo, "rev-parse", "HEAD")
+    profile = "macbook_M3"
+    _commit_path(
+        repo,
+        f"docs/performance_reports/{profile}/result_example_table.tex",
+        "% measured table\n",
+    )
+    publication = _commit_path(
+        repo,
+        f"docs/performance_reports/{profile}/results/raw.json",
+        '{"status":"ok"}\n',
+    )
+
+    identity = require_report_only_publication(
+        repo,
+        measured_revision=measured,
+        profile=profile,
+    )
+
+    assert identity.measured_revision == measured
+    assert identity.publication_revision == publication
+    assert identity.measured_tree == _git(repo, "rev-parse", f"{measured}^{{tree}}")
+    assert identity.publication_tree == _git(
+        repo,
+        "rev-parse",
+        f"{publication}^{{tree}}",
+    )
+    assert identity.eligible
+    assert identity.provenance() == {
+        "report_publication_source_identity_schema": (
+            PUBLICATION_SOURCE_IDENTITY_SCHEMA
+        ),
+        "report_profile": profile,
+        "report_measured_source_revision": measured,
+        "report_measured_source_tree": identity.measured_tree,
+        "report_publication_revision": publication,
+        "report_publication_tree": identity.publication_tree,
+        "report_publication_report_only": True,
+        "report_publication_changed_paths": [
+            f"docs/performance_reports/{profile}/result_example_table.tex",
+            f"docs/performance_reports/{profile}/results/raw.json",
+        ],
+    }
+
+
+def test_publication_descendant_allows_authenticated_environment_outputs(
+    tmp_path: Path,
+) -> None:
+    repo = _repository(tmp_path)
+    measured = _git(repo, "rev-parse", "HEAD")
+    profile = "macbook_M3"
+    _commit_path(
+        repo,
+        f"docs/performance_reports/{profile}/report_environment.json",
+        '{"status":"authenticated"}\n',
+    )
+    publication = _commit_path(
+        repo,
+        f"docs/performance_reports/{profile}/report_environment.tex",
+        "% authenticated environment\n",
+    )
+
+    identity = require_report_only_publication(
+        repo,
+        measured_revision=measured,
+        profile=profile,
+        publication_revision=publication,
+    )
+
+    assert identity.eligible
+    assert identity.changed_paths == (
+        f"docs/performance_reports/{profile}/report_environment.json",
+        f"docs/performance_reports/{profile}/report_environment.tex",
+    )
+
+
+@pytest.mark.parametrize(
+    "path",
+    (
+        "src/evaluator.py",
+        "rust/runtime.rs",
+        "dependencies/symbolica/source.rs",
+        "build_backend/backend.py",
+        "tools/performance_report/runner.py",
+    ),
+)
+def test_publication_rejects_evaluator_or_tool_changes(
+    tmp_path: Path,
+    path: str,
+) -> None:
+    repo = _repository(tmp_path)
+    measured = _git(repo, "rev-parse", "HEAD")
+    _commit_path(repo, path, "CHANGED = True\n")
+
+    identity = inspect_report_publication(
+        repo,
+        measured_revision=measured,
+        profile="macbook_M3",
+    )
+
+    assert identity.disallowed_paths == (path,)
+    with pytest.raises(
+        ReportSourceIdentityError,
+        match="disallowed paths",
+    ):
+        require_report_only_publication(
+            repo,
+            measured_revision=measured,
+            profile="macbook_M3",
+        )
+
+
+def test_publication_rejects_scaffold_wrong_profile_and_nested_payloads(
+    tmp_path: Path,
+) -> None:
+    repo = _repository(tmp_path)
+    measured = _git(repo, "rev-parse", "HEAD")
+    paths = (
+        "docs/performance_reports/cluster_EPYC/results/raw.json",
+        "docs/performance_reports/macbook_M3/result_tables.py",
+        "docs/performance_reports/macbook_M3/results/nested/raw.json",
+        "docs/performance_reports/macbook_M3/section_scope.tex",
+    )
+    for path in paths:
+        _commit_path(repo, path, "payload\n")
+
+    identity = inspect_report_publication(
+        repo,
+        measured_revision=measured,
+        profile="macbook_M3",
+    )
+
+    assert identity.disallowed_paths == paths
+
+
+def test_publication_rejects_rename_executable_and_symlink_modes(
+    tmp_path: Path,
+) -> None:
+    repo = _repository(tmp_path)
+    profile = repo / "docs/performance_reports/macbook_M3"
+    measured = _git(repo, "rev-parse", "HEAD")
+
+    old_table = profile / "result_old_table.tex"
+    old_table.write_text("% old\n", encoding="ascii")
+    _git(repo, "add", old_table.relative_to(repo).as_posix())
+    _git(repo, "commit", "-m", "add old table before measurement")
+    measured = _git(repo, "rev-parse", "HEAD")
+
+    new_table = profile / "result_new_table.tex"
+    old_table.rename(new_table)
+    executable = profile / "result_executable_table.tex"
+    executable.write_text("% executable\n", encoding="ascii")
+    executable.chmod(0o755)
+    symlink = profile / "result_symlink_table.tex"
+    symlink.symlink_to("result_new_table.tex")
+    _git(repo, "add", "-A")
+    _git(repo, "commit", "-m", "unsafe publication members")
+
+    identity = inspect_report_publication(
+        repo,
+        measured_revision=measured,
+        profile="macbook_M3",
+    )
+
+    assert identity.disallowed_paths == (
+        "docs/performance_reports/macbook_M3/result_executable_table.tex",
+        "docs/performance_reports/macbook_M3/result_new_table.tex",
+        "docs/performance_reports/macbook_M3/result_old_table.tex",
+        "docs/performance_reports/macbook_M3/result_symlink_table.tex",
+    )
+
+
+def test_publication_must_descend_from_measured_commit(tmp_path: Path) -> None:
+    repo = _repository(tmp_path)
+    measured = _git(repo, "rev-parse", "HEAD")
+    _git(repo, "checkout", "--orphan", "unrelated")
+    _git(repo, "rm", "-rf", ".")
+    publication = _commit_path(repo, "README.md", "unrelated\n")
+
+    with pytest.raises(
+        ReportSourceIdentityError,
+        match="not a descendant",
+    ):
+        inspect_report_publication(
+            repo,
+            measured_revision=measured,
+            publication_revision=publication,
+            profile="macbook_M3",
+        )
diff --git a/pyamplicol/tests/unit/test_performance_report_standalone_build.py b/pyamplicol/tests/unit/test_performance_report_standalone_build.py
new file mode 100644
index 0000000000..b65fad50dc
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_standalone_build.py
@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.standalone_build import (
+    StandaloneBuildError,
+    compile_report,
+    validate_latex_log,
+)
+
+
+def _fake_engine(tmp_path: Path, log: str) -> Path:
+    engine = tmp_path / "fake-pdflatex"
+    engine.write_text(
+        "#!/usr/bin/env python3\n"
+        "from pathlib import Path\n"
+        "Path('pyAmpliCol.pdf').write_bytes(b'%PDF-1.4\\n%%EOF\\n')\n"
+        f"Path('pyAmpliCol.log').write_text({log!r}, encoding='utf-8')\n",
+        encoding="utf-8",
+    )
+    engine.chmod(0o755)
+    return engine
+
+
+def test_standalone_builder_compiles_relocated_report(tmp_path: Path) -> None:
+    report = tmp_path / "relocated report"
+    report.mkdir()
+    (report / "pyAmpliCol.tex").write_text(
+        "\\documentclass{article}\\begin{document}ok\\end{document}\n",
+        encoding="ascii",
+    )
+
+    output = compile_report(
+        report,
+        engine=str(_fake_engine(tmp_path, "clean publication log\n")),
+        passes=2,
+    )
+
+    assert output == report / "pyAmpliCol.pdf"
+    assert output.is_file()
+
+
+def test_standalone_builder_rejects_overfull_output(tmp_path: Path) -> None:
+    report = tmp_path / "report"
+    report.mkdir()
+    (report / "pyAmpliCol.tex").write_text(
+        "\\documentclass{article}\\begin{document}bad\\end{document}\n",
+        encoding="ascii",
+    )
+
+    with pytest.raises(StandaloneBuildError, match="overfull"):
+        compile_report(
+            report,
+            engine=str(
+                _fake_engine(
+                    tmp_path,
+                    "Overfull \\hbox (1.0pt too wide)\n",
+                )
+            ),
+            passes=2,
+        )
+
+
+def test_latex_log_can_explicitly_allow_overfull_boxes() -> None:
+    validate_latex_log(
+        "Overfull \\hbox (1.0pt too wide)\n"
+        "Overfull \\vbox (2.0pt too high)\n",
+        allow_overfull_boxes=True,
+    )
+
+
+def test_latex_log_still_rejects_unresolved_references_when_overfull_allowed() -> None:
+    with pytest.raises(StandaloneBuildError, match="unresolved"):
+        validate_latex_log(
+            "Overfull \\hbox (1.0pt too wide)\n"
+            "LaTeX Warning: There were undefined references.\n",
+            allow_overfull_boxes=True,
+        )
diff --git a/pyamplicol/tests/unit/test_performance_report_study_contract.py b/pyamplicol/tests/unit/test_performance_report_study_contract.py
new file mode 100644
index 0000000000..41e08a0c8e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_study_contract.py
@@ -0,0 +1,482 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.campaign_policy import (
+    MACBOOK_M3_POLICY,
+    MACBOOK_M3_Z_TABLE_F_POLICY,
+    PolicyCensorKind,
+    policy_censor_measurement,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import ArtifactPolicy
+from tools.performance_report.service import ReportPaths, ReportService
+from tools.performance_report.source_identity import ReportSourceIdentity
+from tools.performance_report.study_contract import (
+    Z_TABLE_F_PRIOR_CELL_COUNT,
+    Z_TABLE_F_PRIOR_EVIDENCE_ABI,
+    Z_TABLE_F_PRIOR_STATIC_NA_CELL_COUNT,
+    StudyContractError,
+    audit_z_table_f_policy_projection,
+    bind_z_table_f_attempt,
+    load_z_table_f_study_contract,
+    require_z_table_f_explicit_cell,
+    write_z_table_f_study_contract,
+    z_table_f_cell_ids,
+    z_table_f_prior_cell_ids,
+    z_table_f_worker_harness_identity,
+)
+from tools.performance_report.worker_harness import attach_worker_harness_identity
+
+
+def _git_repo(path: Path, marker: str) -> Path:
+    path.mkdir()
+    (path / "src/pyamplicol/_profiling_campaign").mkdir(parents=True)
+    (path / "tools/performance_report").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=path, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "test@example.invalid"),
+        cwd=path,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Test"),
+        cwd=path,
+        check=True,
+    )
+    (path / "README.md").write_text(marker + "\n", encoding="ascii")
+    (path / "src/pyamplicol/_profiling_campaign/result_tables.py").write_text(
+        f"# {marker} policy entrypoint\n",
+        encoding="ascii",
+    )
+    (path / "tools/performance_report/legacy.py").write_text(
+        f"# {marker} legacy adapter\n",
+        encoding="ascii",
+    )
+    subprocess.run(("git", "add", "."), cwd=path, check=True)
+    subprocess.run(
+        ("git", "commit", "-qm", "fixture"),
+        cwd=path,
+        check=True,
+    )
+    return path
+
+
+def test_study_contract_binds_source_wrapper_policy_and_exact_limits(
+    tmp_path: Path,
+) -> None:
+    source = _git_repo(tmp_path / "source", "measured")
+    wrapper = _git_repo(tmp_path / "wrapper", "policy")
+    contract_path = tmp_path / "contract.json"
+
+    created = write_z_table_f_study_contract(
+        contract_path,
+        source,
+        wrapper,
+    )
+    loaded = load_z_table_f_study_contract(
+        contract_path,
+        source,
+        wrapper,
+    )
+
+    assert loaded == created
+    assert loaded["campaign_policy"] == (
+        MACBOOK_M3_Z_TABLE_F_POLICY.as_manifest()
+    )
+    assert loaded["campaign_policy"] != MACBOOK_M3_POLICY.as_manifest()
+    assert loaded["policy_profile"] == "macbook_M3"
+    assert set(loaded["policy_wrapper"]) == {
+        "revision",
+        "tree",
+        "policy_entrypoint",
+        "policy_entrypoint_sha256",
+        "legacy_adapter",
+        "legacy_adapter_sha256",
+    }
+    assert loaded["policy_wrapper"]["policy_entrypoint"] == (
+        "src/pyamplicol/_profiling_campaign/result_tables.py"
+    )
+    assert loaded["policy_wrapper"]["legacy_adapter"] == (
+        "tools/performance_report/legacy.py"
+    )
+    assert loaded["memory_guard"] == {
+        "metric_abi": "pyamplicol-process-tree-memory-metric-v1",
+        "metric": (
+            "max(aggregate-process-tree-rss,"
+            "darwin-physical-footprint)"
+        ),
+        "limit_bytes": 30_000_000_000,
+    }
+    assert loaded["generation_guard"] == {
+        "evidence_abi": (
+            "pyamplicol-report-generation-phase-evidence-v1"
+        ),
+        "limit_seconds": 3600.0,
+        "scope": (
+            "every legacy, selected-flow, and all-flow generation"
+        ),
+    }
+    assert loaded["allowed_cell_ids"] == list(z_table_f_cell_ids())
+    assert len(loaded["allowed_cell_ids"]) == 32
+    retained = loaded["retained_prior_evidence"]
+    assert isinstance(retained, dict)
+    assert retained["n_final"] == list(range(1, 8))
+    assert retained["treatment"] == (
+        "outside this contract; retain each original attempt, "
+        "provenance record, and resource ABI unchanged"
+    )
+    assert retained["memory_guard_interpretation"] == (
+        "legacy RSS-only evidence remains legacy and is not "
+        "relabeled as Darwin physical-footprint or exact-decimal-"
+        "30GB evidence"
+    )
+    snapshot = retained["snapshot"]
+    assert isinstance(snapshot, dict)
+    prior_cell_ids = z_table_f_prior_cell_ids()
+    static_na_cell_ids = tuple(
+        cell_id
+        for cell_id in prior_cell_ids
+        if REPORT_CATALOG.static_na_reason(
+            REPORT_CATALOG.cell(cell_id)
+        )
+        is not None
+    )
+    assert snapshot == {
+        "abi": Z_TABLE_F_PRIOR_EVIDENCE_ABI,
+        "maximum_n_final": 7,
+        "cell_ids": list(prior_cell_ids),
+        "static_na_cell_ids": list(static_na_cell_ids),
+        "declared_cell_count": Z_TABLE_F_PRIOR_CELL_COUNT,
+        "static_na_cell_count": Z_TABLE_F_PRIOR_STATIC_NA_CELL_COUNT,
+        "current_cell_count": 0,
+        "snapshot_sha256": snapshot["snapshot_sha256"],
+    }
+    assert len(str(snapshot["snapshot_sha256"])) == 64
+
+
+def test_study_contract_replays_after_wrapper_path_relocation(
+    tmp_path: Path,
+) -> None:
+    source = _git_repo(tmp_path / "source", "measured")
+    wrapper = _git_repo(tmp_path / "wrapper", "policy")
+    contract_path = tmp_path / "contract.json"
+    created = write_z_table_f_study_contract(
+        contract_path,
+        source,
+        wrapper,
+    )
+    relocated = tmp_path / "relocated-wrapper"
+    shutil.move(wrapper, relocated)
+
+    loaded = load_z_table_f_study_contract(
+        contract_path,
+        source,
+        relocated,
+    )
+
+    assert loaded == created
+
+
+def test_study_contract_rejects_tamper_wrapper_drift_and_broad_cell(
+    tmp_path: Path,
+) -> None:
+    source = _git_repo(tmp_path / "source", "measured")
+    wrapper = _git_repo(tmp_path / "wrapper", "policy")
+    contract_path = tmp_path / "contract.json"
+    contract = write_z_table_f_study_contract(
+        contract_path,
+        source,
+        wrapper,
+    )
+    allowed = contract["allowed_cell_ids"]
+    assert isinstance(allowed, list)
+    require_z_table_f_explicit_cell(contract, str(allowed[0]))
+    with pytest.raises(StudyContractError, match="outside"):
+        require_z_table_f_explicit_cell(
+            contract,
+            "matrix-compiled-builtin-sm-lc-n1-dd-z-jets-contracted",
+        )
+
+    raw = json.loads(contract_path.read_text(encoding="ascii"))
+    raw["memory_guard"]["limit_bytes"] = 30 * 1024**3
+    contract_path.write_text(
+        json.dumps(raw, sort_keys=True),
+        encoding="ascii",
+    )
+    with pytest.raises(StudyContractError, match="digest"):
+        load_z_table_f_study_contract(contract_path, source, wrapper)
+
+    contract_path.unlink()
+    write_z_table_f_study_contract(contract_path, source, wrapper)
+    (wrapper / "README.md").write_text("changed\n", encoding="ascii")
+    with pytest.raises(StudyContractError, match="clean"):
+        load_z_table_f_study_contract(contract_path, source, wrapper)
+
+
+def test_study_contract_freezes_only_prior_z_table_current_provenance(
+    tmp_path: Path,
+) -> None:
+    source = _git_repo(tmp_path / "source", "measured")
+    wrapper = _git_repo(tmp_path / "wrapper", "policy")
+    service = ReportService(
+        ReportPaths.from_repo(
+            source,
+            docs_dir=tmp_path / "docs",
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    prior_cell = REPORT_CATALOG.cell(
+        "reference-amplicol-lc-n1-dd-z-jets-selected-flow"
+    )
+    unrelated_cell = REPORT_CATALOG.cell(
+        "scalar-contact-n2-scalar-contact-contracted"
+    )
+    original = {
+        "status": "ok",
+        "provenance": {"origin": "pre-study"},
+    }
+    current = service.store.new_attempt(
+        prior_cell.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(original)
+    unrelated_current = service.store.new_attempt(
+        unrelated_cell.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(
+        {
+            "status": "ok",
+            "provenance": {"origin": "unrelated-pre-study"},
+        }
+    )
+    contract_path = tmp_path / "contract.json"
+    contract = write_z_table_f_study_contract(
+        contract_path,
+        source,
+        wrapper,
+        prior_store=service.store,
+    )
+    assert (
+        load_z_table_f_study_contract(
+            contract_path,
+            source,
+            wrapper,
+            prior_store=service.store,
+        )
+        == contract
+    )
+
+    service.store.new_attempt(
+        unrelated_cell.cell_id,
+        ArtifactPolicy.REGENERATE,
+        based_on=unrelated_current,
+    ).publish(
+        {
+            "status": "ok",
+            "provenance": {"origin": "unrelated-update"},
+        }
+    )
+    assert (
+        load_z_table_f_study_contract(
+            contract_path,
+            source,
+            wrapper,
+            prior_store=service.store,
+        )
+        == contract
+    )
+
+    changed_prior = {
+        "status": "ok",
+        "provenance": {"origin": "rewritten-during-study"},
+    }
+    service.store.new_attempt(
+        prior_cell.cell_id,
+        ArtifactPolicy.REGENERATE,
+        based_on=current,
+    ).publish(changed_prior)
+
+    with pytest.raises(
+        StudyContractError,
+        match="retained prior evidence differs",
+    ):
+        load_z_table_f_study_contract(
+            contract_path,
+            source,
+            wrapper,
+            prior_store=service.store,
+        )
+    with pytest.raises(StudyContractError, match="snapshot differs"):
+        audit_z_table_f_policy_projection(
+            contract,
+            service,
+            maximum_n=8,
+        )
+
+
+def test_study_audit_replays_f_policy_without_ordinary_mac_policy(
+    tmp_path: Path,
+) -> None:
+    source = _git_repo(tmp_path / "source", "measured")
+    wrapper = _git_repo(tmp_path / "wrapper", "policy")
+    contract_path = tmp_path / "contract.json"
+    contract = write_z_table_f_study_contract(
+        contract_path,
+        source,
+        wrapper,
+    )
+    source_record = contract["measured_source"]
+    assert isinstance(source_record, dict)
+    identity = ReportSourceIdentity(
+        str(source_record["revision"]),
+        str(source_record["tree"]),
+        (),
+    )
+    docs = tmp_path / "docs"
+    docs.mkdir()
+    service = ReportService(
+        ReportPaths.from_repo(
+            source,
+            docs_dir=docs,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "coordination",
+        )
+    )
+    service.publish(reset=True, merge_artifacts=False)
+    allowed = frozenset(str(value) for value in contract["allowed_cell_ids"])
+    cells = tuple(
+        cell
+        for cell in service.catalog.measurement_cells()
+        if cell.cell_id in allowed and cell.n_final == 8
+    )
+    assert len(cells) == 16
+    measured_cells = tuple(
+        cell
+        for cell in cells
+        if service.catalog.static_na_reason(cell) is None
+    )
+    assert len(measured_cells) == 12
+    phase = {
+        "abi": "pyamplicol-report-generation-phase-evidence-v1",
+        "phase_state_abi": "pyamplicol-report-worker-phase-state-v1",
+        "configured_timeout_seconds": 3600.0,
+        "supervisor_reason": "generation_timeout",
+        "authenticated": True,
+        "run_id": "study-run",
+        "worker_pid": 123,
+        "final_sequence": 1,
+        "final_phase": "generation",
+        "generation_started_monotonic_ns": 1,
+        "generation_finished_monotonic_ns": None,
+        "generation_elapsed_seconds": 3600.0,
+        "final_state_sha256": "4" * 64,
+        "error": None,
+    }
+    resources = {
+        "available": True,
+        "current_rss_bytes": 100,
+        "peak_rss_bytes": 100,
+        "child_count": 0,
+        "cpu_seconds": 1.0,
+        "wall_seconds": 3600.0,
+        "probe_error": None,
+        "memory_metric_abi": (
+            "pyamplicol-process-tree-memory-metric-v1"
+        ),
+        "current_physical_footprint_bytes": 120,
+        "peak_physical_footprint_bytes": 120,
+        "current_guard_bytes": 120,
+        "peak_guard_bytes": 120,
+        "memory_limit_bytes": 30_000_000_000,
+        "memory_limit_reason": None,
+        "memory_probe_reason": None,
+        "generation_phase": phase,
+    }
+    worker_harness = z_table_f_worker_harness_identity(contract)
+    for cell in measured_cells:
+        result = policy_censor_measurement(
+            MACBOOK_M3_Z_TABLE_F_POLICY,
+            "macbook_M3",
+            cell,
+            kind=PolicyCensorKind.GENERATION_LIMIT,
+            source_identity=identity,
+            resources=resources,
+            observed_generation_seconds=3600.0,
+            phase_evidence=phase,
+        )
+        attach_worker_harness_identity(result, worker_harness)
+        bind_z_table_f_attempt(result, str(contract["sha256"]))
+        service.store.new_attempt(
+            cell.cell_id,
+            ArtifactPolicy.REGENERATE,
+        ).publish(result)
+    service.publish()
+
+    audited = audit_z_table_f_policy_projection(
+        contract,
+        service,
+        maximum_n=8,
+    )
+
+    assert audited["status"] == "ok"
+    assert audited["declared_cell_count"] == 16
+    assert audited["static_na_cell_count"] == 4
+    assert audited["policy_state_counts"] == {"generation_limit": 12}
+    assert audited["campaign_policy"] == (
+        MACBOOK_M3_Z_TABLE_F_POLICY.as_manifest()
+    )
+    assert audited["campaign_policy"] != MACBOOK_M3_POLICY.as_manifest()
+
+    current = service.store.load_current(measured_cells[0].cell_id)
+    assert current is not None
+    stale_harness = json.loads(
+        json.dumps(current.result, allow_nan=False, sort_keys=True)
+    )
+    stale_harness["provenance"]["worker_harness"][
+        "policy_wrapper_revision"
+    ] = "f" * 40
+    stale_current = service.store.new_attempt(
+        measured_cells[0].cell_id,
+        ArtifactPolicy.REGENERATE,
+        based_on=current,
+    ).publish(stale_harness)
+    service.publish()
+    with pytest.raises(StudyContractError, match="worker harness differs"):
+        audit_z_table_f_policy_projection(
+            contract,
+            service,
+            maximum_n=8,
+        )
+    current = service.store.new_attempt(
+        measured_cells[0].cell_id,
+        ArtifactPolicy.REGENERATE,
+        based_on=stale_current,
+    ).publish(current.result)
+    service.publish()
+
+    transplanted = json.loads(
+        json.dumps(current.result, allow_nan=False, sort_keys=True)
+    )
+    transplanted["provenance"]["study_contract"][
+        "study_contract_sha256"
+    ] = "f" * 64
+    with service.store.new_attempt(
+        measured_cells[0].cell_id,
+        ArtifactPolicy.REGENERATE,
+        based_on=current,
+    ) as attempt:
+        attempt.publish(transplanted)
+    service.publish()
+    with pytest.raises(StudyContractError, match="not bound"):
+        audit_z_table_f_policy_projection(
+            contract,
+            service,
+            maximum_n=8,
+        )
diff --git a/pyamplicol/tests/unit/test_performance_report_worker.py b/pyamplicol/tests/unit/test_performance_report_worker.py
new file mode 100644
index 0000000000..9b344e0d14
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_worker.py
@@ -0,0 +1,728 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import errno
+import json
+from pathlib import Path
+
+import pytest
+
+import tools.performance_report.worker as worker_module
+from tools.performance_report.agreements import (
+    independent_numerical_authorities,
+)
+from tools.performance_report.artifacts import DiskFullError
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.measurement import load_measurement
+from tools.performance_report.phase_state import (
+    WorkerPhaseChannel,
+    WorkerPhaseReporter,
+    read_worker_phase_state,
+)
+from tools.performance_report.runner import RunnerSettings
+from tools.performance_report.worker import (
+    _atomic_json,
+    _JsonlProgressSink,
+    _portable_current_paths,
+    _selector_provider_measurement,
+    _source_identity,
+    _worker_legacy_workspace,
+    measure_cell,
+    write_cell_result,
+)
+from tools.performance_report.worker_harness import worker_harness_identity
+
+
+def test_atomic_worker_result_is_canonical_and_complete(tmp_path: Path) -> None:
+    path = tmp_path / "attempt" / "result.json"
+    _atomic_json(path, {"status": "ok", "value": 1})
+
+    assert json.loads(path.read_text(encoding="ascii")) == {
+        "status": "ok",
+        "value": 1,
+    }
+    assert not list(path.parent.glob("*.tmp"))
+
+
+def test_worker_materializes_portable_peer_from_canonical_current_path(
+    tmp_path: Path,
+) -> None:
+    campaign = tmp_path / "manual"
+    state = campaign / "campaign_artifacts"
+    (state / "coordination").mkdir(parents=True)
+    worker_attempt = (
+        state
+        / "cells/worker/attempts/11111111-1111-4111-8111-111111111111"
+    )
+    peer_attempt = state / "cells/peer/attempts/22222222-2222-4222-8222-222222222222"
+    worker_attempt.mkdir(parents=True)
+    peer_artifact = peer_attempt / "artifact"
+    peer_artifact.mkdir(parents=True)
+    result_path = peer_attempt / "result.json"
+    result_path.write_text(
+        json.dumps(
+            {
+                "status": "ok",
+                "artifact": {
+                    "path": "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/cells/peer/attempts/"
+                    "22222222-2222-4222-8222-222222222222/artifact"
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    paths = _portable_current_paths(
+        repo_root=tmp_path / "source",
+        attempt_root=worker_attempt,
+    )
+
+    assert paths is not None
+    loaded = load_measurement(result_path, publication_paths=paths)
+    assert loaded["artifact"]["path"] == str(peer_artifact)
+
+
+def test_atomic_worker_result_normalizes_enospc_with_target_and_free_bytes(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "attempt" / "worker-result.json"
+
+    def no_space(_source: object, _destination: object) -> None:
+        raise OSError(errno.ENOSPC, "no space left")
+
+    monkeypatch.setattr(worker_module.os, "replace", no_space)
+    with pytest.raises(
+        DiskFullError,
+        match=(
+            r"disk full while writing .*worker-result\.json; "
+            r"[0-9]+ bytes available"
+        ),
+    ):
+        worker_module._atomic_json(path, {"status": "error"})
+
+    assert not path.exists()
+    assert not tuple(path.parent.glob(".worker-result.json.*.tmp"))
+
+
+def test_worker_source_identity_uses_controller_values_without_git(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        "tools.performance_report.worker.require_eligible_report_source",
+        lambda _root: pytest.fail("manual source identity must not invoke Git"),
+    )
+
+    identity = _source_identity(tmp_path, "A" * 40, "b" * 40)
+
+    assert identity.revision == "a" * 40
+    assert identity.tree == "b" * 40
+    assert identity.dirty_paths == ()
+    with pytest.raises(ValueError, match="specified together"):
+        _source_identity(tmp_path, "a" * 40, None)
+    with pytest.raises(ValueError, match="revision must be"):
+        _source_identity(tmp_path, "not-a-revision", "b" * 40)
+
+
+def test_jsonl_progress_sink_captures_compact_typed_events(tmp_path: Path) -> None:
+    from pyamplicol.reporting import ProgressEnd, ProgressStart, ProgressUpdate
+
+    path = tmp_path / "progress.jsonl"
+    sink = _JsonlProgressSink(path)
+    sink.emit(ProgressStart("profile", "Profiling", 2, unit="samples"))
+    sink.emit(ProgressUpdate("profile", 1, 2, "sampled"))
+    sink.emit(ProgressEnd("profile", elapsed_seconds=0.25))
+
+    events = [
+        json.loads(line) for line in path.read_text(encoding="ascii").splitlines()
+    ]
+    assert [event["event"] for event in events] == ["start", "update", "end"]
+    assert {event["task_id"] for event in events} == {"profile"}
+    assert events[0]["total"] == 2
+    assert events[1]["completed"] == 1
+    assert events[2]["elapsed_seconds"] == 0.25
+
+
+def test_every_catalog_cell_has_unique_worker_identity() -> None:
+    cells = REPORT_CATALOG.measurement_cells()
+    assert len({cell.cell_id for cell in cells}) == len(cells)
+
+
+@pytest.mark.parametrize("mutation", ("missing", "extra"))
+def test_worker_requires_exact_catalog_numerical_authority_chain(
+    tmp_path: Path,
+    mutation: str,
+) -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n4-dd-tt-jets-contracted"
+    )
+    canonical = tuple(
+        authority.cell_id for authority in independent_numerical_authorities(cell)
+    )
+    assert canonical == (
+        "matrix-recurrence-builtin-sm-full-n4-dd-tt-jets-contracted",
+    )
+    observed = {
+        "missing": canonical[:-1],
+        "extra": (*canonical, REPORT_CATALOG.measurement_cells()[0].cell_id),
+    }[mutation]
+
+    with pytest.raises(ValueError, match="canonical catalog chain"):
+        measure_cell(
+            cell.cell_id,
+            repo_root=tmp_path,
+            attempt_root=tmp_path / "attempt",
+            target_runtime_seconds=1.0,
+            batch_size=1,
+            worker_cores=1,
+            expected_authority_cell_ids=observed,
+        )
+
+
+def test_no_legacy_baseline_lc_all_flow_gets_selected_flow_selector_peer() -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-lc-n7-dd-4q-lines-all-flow"
+    )
+    peer_id = "matrix-recurrence-builtin-sm-lc-n7-dd-4q-lines-selected-flow"
+    provider = {
+        "status": "ok",
+        "selector_contract": {
+            "selected_color_flow_ids": ["flow:1"],
+            "selected_color_words": [[1]],
+            "all_flow_helicity_ids": ["h:-1"],
+            "all_flow_source_helicities": [[1, -1]],
+            "point_digest": "a" * 64,
+        },
+    }
+
+    assert REPORT_CATALOG.validation_baseline_cell(cell) is None
+    assert (
+        _selector_provider_measurement(
+            cell.cell_id,
+            {peer_id: provider},
+            catalog=REPORT_CATALOG,
+        )
+        is provider
+    )
+
+
+@pytest.mark.parametrize(
+    ("cell_id", "reason"),
+    (
+        (
+            "reference-amplicol-full-n6-dd-4q-lines-contracted",
+            "original-amplicol-open-quark-line-limit",
+        ),
+        (
+            "z-builtin-sm-n7-dd-z-jets-asm-o3-selected-flow",
+            "user cap: native C\\+\\+/ASM generation is not attempted above n=6",
+        ),
+    ),
+)
+def test_worker_rejects_catalog_static_na_before_measurement(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    cell_id: str,
+    reason: str,
+) -> None:
+    cell = REPORT_CATALOG.cell(cell_id)
+    monkeypatch.setattr(
+        "tools.performance_report.worker.require_eligible_report_source",
+        lambda _root: pytest.fail(
+            "source authentication must not run for catalog static N/A"
+        ),
+    )
+
+    with pytest.raises(
+        ValueError,
+        match=f"catalog static N/A cell.*{reason}",
+    ):
+        measure_cell(
+            cell.cell_id,
+            repo_root=tmp_path,
+            attempt_root=tmp_path / "attempt",
+            target_runtime_seconds=1.0,
+            batch_size=1,
+            worker_cores=1,
+        )
+
+
+def test_worker_failure_is_structured_and_traceback_stays_in_log(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def fail(*_args: object, **_kwargs: object) -> dict[str, object]:
+        raise RuntimeError("deliberate worker failure")
+
+    monkeypatch.setattr("tools.performance_report.worker.measure_cell", fail)
+    result_path = tmp_path / "result.json"
+    log_path = tmp_path / "worker.log"
+    result = write_cell_result(
+        "cell",
+        result_path,
+        log_path=log_path,
+    )
+
+    assert result["status"] == "error"
+    assert result["failure"]["message"] == "deliberate worker failure"
+    assert json.loads(result_path.read_text(encoding="ascii"))["status"] == "error"
+    assert "Traceback" in log_path.read_text(encoding="utf-8")
+
+
+def test_worker_success_carries_authenticated_split_harness(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    harness = worker_harness_identity(
+        study_contract_sha256="1" * 64,
+        policy_wrapper_revision="2" * 40,
+        policy_wrapper_tree="3" * 40,
+        policy_entrypoint_sha256="4" * 64,
+        legacy_adapter_sha256="5" * 64,
+        measured_source_revision="6" * 40,
+        measured_source_tree="7" * 40,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.worker.measure_cell",
+        lambda *_args, **_kwargs: {"status": "ok", "provenance": {}},
+    )
+
+    result = write_cell_result(
+        "cell",
+        tmp_path / "result.json",
+        worker_harness=harness,
+    )
+
+    assert result["provenance"]["worker_harness"] == harness
+    assert (
+        json.loads((tmp_path / "result.json").read_text(encoding="ascii"))[
+            "provenance"
+        ]["worker_harness"]
+        == harness
+    )
+
+
+def test_write_cell_result_threads_madgraph_installation_to_measurement(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    installation = tmp_path / "madgraph"
+    observed: list[Path | None] = []
+
+    def measure(
+        _cell_id: str,
+        *,
+        madgraph_installation: Path | None,
+        **_kwargs: object,
+    ) -> dict[str, object]:
+        observed.append(madgraph_installation)
+        return {"status": "ok", "provenance": {}}
+
+    monkeypatch.setattr("tools.performance_report.worker.measure_cell", measure)
+    result = write_cell_result(
+        "cell",
+        tmp_path / "result.json",
+        madgraph_installation=installation,
+    )
+
+    assert result["status"] == "ok"
+    assert observed == [installation]
+
+
+def test_worker_constructs_and_threads_parent_phase_reporter(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    observed: list[str] = []
+
+    def measure(
+        _cell_id: str,
+        *,
+        phase_reporter: WorkerPhaseReporter | None,
+        **_kwargs: object,
+    ) -> dict[str, object]:
+        assert phase_reporter is not None
+        state = read_worker_phase_state(
+            channel,
+            expected_pid=phase_reporter.worker_pid,
+        )
+        observed.append(state.phase)
+        return {"status": "ok", "provenance": {}}
+
+    monkeypatch.setattr("tools.performance_report.worker.measure_cell", measure)
+    result = write_cell_result(
+        "cell",
+        tmp_path / "result.json",
+        phase_state_path=channel.path,
+        phase_state_run_id=channel.run_id,
+        phase_state_authentication_key=channel.authentication_key,
+    )
+
+    assert result["status"] == "ok"
+    assert observed == ["pre-generation"]
+
+
+def test_legacy_workspace_copy_lives_only_inside_supervised_worker_scope(
+    tmp_path: Path,
+) -> None:
+    source = tmp_path / "original-amplicol"
+    source.mkdir()
+    (source / "source.f03").write_text("program fixture\n", encoding="ascii")
+    destination = tmp_path / "worker" / "legacy-workspace"
+
+    with _worker_legacy_workspace(
+        repository=None,
+        source_repository=source,
+        workspace=destination,
+        copy_source=True,
+    ) as prepared:
+        assert prepared == destination
+        assert (destination / "source.f03").read_text(encoding="ascii") == (
+            "program fixture\n"
+        )
+
+    assert not destination.exists()
+
+
+def test_worker_threads_effective_stage_budgets_and_tracks_extended_phases(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    channel = WorkerPhaseChannel.create(tmp_path / "phase.json")
+    observed: dict[str, object] = {}
+
+    def measure(
+        _cell_id: str,
+        *,
+        phase_reporter: WorkerPhaseReporter | None,
+        **kwargs: object,
+    ) -> dict[str, object]:
+        assert phase_reporter is not None
+        observed.update(kwargs)
+        with phase_reporter.generation():
+            pass
+        phase_reporter.profiling_started()
+        observed["phase"] = read_worker_phase_state(
+            channel,
+            expected_pid=phase_reporter.worker_pid,
+        ).phase
+        return {"status": "ok", "provenance": {}}
+
+    monkeypatch.setattr("tools.performance_report.worker.measure_cell", measure)
+    result = write_cell_result(
+        "cell",
+        tmp_path / "result.json",
+        phase_state_path=channel.path,
+        phase_state_run_id=channel.run_id,
+        phase_state_authentication_key=channel.authentication_key,
+        worker_wall_limit_seconds=12.0,
+        profiling_time_limit_seconds=5.0,
+        validation_time_limit_seconds=3.0,
+    )
+
+    assert result["status"] == "ok"
+    assert observed == {
+        "worker_wall_limit_seconds": 12.0,
+        "profiling_time_limit_seconds": 5.0,
+        "validation_time_limit_seconds": 3.0,
+        "madgraph_installation": None,
+        "phase": "profiling",
+    }
+
+
+@pytest.mark.parametrize(
+    "field",
+    (
+        "worker_wall_limit_seconds",
+        "profiling_time_limit_seconds",
+        "validation_time_limit_seconds",
+    ),
+)
+def test_worker_rejects_invalid_effective_stage_budget(
+    tmp_path: Path,
+    field: str,
+) -> None:
+    with pytest.raises(ValueError, match=f"{field} must be finite and positive"):
+        measure_cell(
+            "does-not-need-to-exist",
+            repo_root=tmp_path,
+            attempt_root=tmp_path / "attempt",
+            target_runtime_seconds=1.0,
+            batch_size=1,
+            worker_cores=1,
+            **{field: float("inf")},
+        )
+
+
+def test_legacy_worker_threads_generation_phase_reporter_to_adapter(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cell = REPORT_CATALOG.cell("reference-amplicol-lc-n1-dd-z-jets-selected-flow")
+    events: list[str] = []
+
+    class Reporter:
+        def complete(self) -> None:
+            events.append("complete")
+
+    reporter = Reporter()
+    observed: list[tuple[object, object, int]] = []
+
+    class SourceIdentity:
+        def provenance(self) -> dict[str, object]:
+            return {}
+
+    class Adapter:
+        def measure(self, *_args: object, **kwargs: object) -> dict[str, object]:
+            events.append("adapter")
+            observed.append(
+                (
+                    kwargs.get("phase_reporter"),
+                    kwargs.get("selector_provider"),
+                    kwargs["settings"].jobs,
+                )
+            )
+            return {
+                "status": "ok",
+                "validation": {"status": "ok"},
+                "provenance": {},
+            }
+
+    identity = SourceIdentity()
+    monkeypatch.setattr(
+        "tools.performance_report.worker.require_eligible_report_source",
+        lambda _root: identity,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.legacy.LegacyMeasurementAdapter",
+        Adapter,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.worker.attach_direct_agreements",
+        lambda *_args, **_kwargs: events.append("agreements"),
+    )
+
+    result = measure_cell(
+        cell.cell_id,
+        repo_root=tmp_path,
+        attempt_root=tmp_path / "attempt",
+        target_runtime_seconds=1.0,
+        batch_size=1,
+        worker_cores=4,
+        amplicol_build_jobs=1,
+        phase_reporter=reporter,  # type: ignore[arg-type]
+        legacy_repository=tmp_path / "legacy",
+    )
+
+    assert result["status"] == "ok"
+    assert observed == [(reporter, None, 1)]
+    assert events == ["adapter", "agreements", "complete"]
+
+
+def test_legacy_all_flow_worker_passes_selected_flow_provider(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cell = REPORT_CATALOG.cell("reference-amplicol-lc-n1-dd-z-jets-all-flow")
+    provider = {"status": "ok", "selector_contract": {"fixture": True}}
+    observed: list[tuple[object, object]] = []
+
+    class SourceIdentity:
+        def provenance(self) -> dict[str, object]:
+            return {}
+
+    class Adapter:
+        def measure(self, *_args: object, **kwargs: object) -> dict[str, object]:
+            observed.append(kwargs.get("selector_provider"))
+            return {
+                "status": "ok",
+                "validation": {"status": "ok"},
+                "provenance": {},
+            }
+
+    identity = SourceIdentity()
+    monkeypatch.setattr(
+        "tools.performance_report.worker.require_eligible_report_source",
+        lambda _root: identity,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.worker._selector_provider_measurement",
+        lambda *_args, **_kwargs: provider,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.legacy.LegacyMeasurementAdapter",
+        Adapter,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.worker.attach_direct_agreements",
+        lambda *_args, **_kwargs: None,
+    )
+
+    result = measure_cell(
+        cell.cell_id,
+        repo_root=tmp_path,
+        attempt_root=tmp_path / "attempt",
+        target_runtime_seconds=1.0,
+        batch_size=1,
+        worker_cores=1,
+        legacy_repository=tmp_path / "legacy",
+    )
+
+    assert result["status"] == "ok"
+    assert observed == [provider]
+
+
+def test_pyamplicol_worker_passes_all_validation_peers_to_measurement(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n4-dd-tt-jets-contracted"
+    )
+    baseline = {"status": "ok", "matrix_element": 1.0}
+    peer = {
+        "status": "ok",
+        "matrix_element": 1.0,
+        "validation": {
+            "legacy_imode2_diagnostic": {
+                "authoritative_value": 1.0,
+                "imode2_value": 1.0,
+            }
+        },
+    }
+    baseline_path = tmp_path / "baseline.json"
+    peer_path = tmp_path / "peer.json"
+    baseline_path.write_text(json.dumps(baseline), encoding="ascii")
+    peer_path.write_text(json.dumps(peer), encoding="ascii")
+    observed: list[object] = []
+
+    class SourceIdentity:
+        def provenance(self) -> dict[str, object]:
+            return {}
+
+    def measure(*_args: object, **kwargs: object) -> dict[str, object]:
+        settings = kwargs.get("settings")
+        assert isinstance(settings, RunnerSettings)
+        observed.append(
+            (
+                kwargs.get("validation_peers"),
+                kwargs.get("catalog"),
+                settings.memory_limit_bytes,
+            )
+        )
+        return {
+            "status": "validation_failed",
+            "validation": {"status": "validation_failed"},
+            "provenance": {},
+        }
+
+    identity = SourceIdentity()
+    monkeypatch.setattr(
+        "tools.performance_report.worker.require_eligible_report_source",
+        lambda _root: identity,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.worker.measure_pyamplicol_cell",
+        measure,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.worker.attach_direct_agreements",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.worker.attach_validation_failure_precision_diagnostic",
+        lambda *_args, **_kwargs: None,
+    )
+
+    result = measure_cell(
+        cell.cell_id,
+        repo_root=tmp_path,
+        attempt_root=tmp_path / "attempt",
+        target_runtime_seconds=1.0,
+        batch_size=1,
+        worker_cores=1,
+        memory_limit_bytes=15_000_000_000,
+        expected_authority_cell_ids=tuple(
+            authority.cell_id
+            for authority in independent_numerical_authorities(cell)
+        ),
+        selected_authority_cell_id=independent_numerical_authorities(cell)[0].cell_id,
+        baseline_json=baseline_path,
+        peer_json=(("reference-amplicol-full-n4-dd-tt-jets-contracted", peer_path),),
+    )
+
+    assert result["status"] == "validation_failed"
+    assert observed == [
+        (
+            {"reference-amplicol-full-n4-dd-tt-jets-contracted": peer},
+            REPORT_CATALOG,
+            15_000_000_000,
+        )
+    ]
+
+
+def test_z_worker_accepts_recurrence_as_baseline_and_direct_peer(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cell = REPORT_CATALOG.cell(
+        "z-builtin-sm-n1-dd-z-jets-jit-o1-selected-flow"
+    )
+    authorities = independent_numerical_authorities(cell)
+    assert len(authorities) == 1
+    recurrence = authorities[0]
+    measurement = {"status": "ok", "matrix_element": 1.0}
+    measurement_path = tmp_path / "recurrence.json"
+    measurement_path.write_text(json.dumps(measurement), encoding="ascii")
+    observed: list[tuple[object, object]] = []
+
+    class SourceIdentity:
+        def provenance(self) -> dict[str, object]:
+            return {}
+
+    def measure(*_args: object, **kwargs: object) -> dict[str, object]:
+        observed.append((kwargs.get("baseline"), kwargs.get("validation_peers")))
+        return {
+            "status": "ok",
+            "validation": {"status": "ok"},
+            "provenance": {},
+        }
+
+    identity = SourceIdentity()
+    monkeypatch.setattr(
+        "tools.performance_report.worker.require_eligible_report_source",
+        lambda _root: identity,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.worker.measure_pyamplicol_cell",
+        measure,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.worker.attach_direct_agreements",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.worker.attach_validation_failure_precision_diagnostic",
+        lambda *_args, **_kwargs: None,
+    )
+
+    result = measure_cell(
+        cell.cell_id,
+        repo_root=tmp_path,
+        attempt_root=tmp_path / "attempt",
+        target_runtime_seconds=1.0,
+        batch_size=1,
+        worker_cores=1,
+        expected_authority_cell_ids=tuple(
+            authority.cell_id
+            for authority in independent_numerical_authorities(cell)
+        ),
+        selected_authority_cell_id=recurrence.cell_id,
+        baseline_json=measurement_path,
+        peer_json=((recurrence.cell_id, measurement_path),),
+    )
+
+    assert result["status"] == "ok"
+    assert observed == [(measurement, {recurrence.cell_id: measurement})]
diff --git a/pyamplicol/tests/unit/test_performance_report_workspace.py b/pyamplicol/tests/unit/test_performance_report_workspace.py
new file mode 100644
index 0000000000..7720f9f751
--- /dev/null
+++ b/pyamplicol/tests/unit/test_performance_report_workspace.py
@@ -0,0 +1,891 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import multiprocessing
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report import workspace as workspace_module
+from tools.performance_report.artifacts import LockTimeoutError
+from tools.performance_report.campaign_policy import (
+    MACBOOK_M3_POLICY,
+    X86_EPYC_POLICY,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.service import (
+    ReportPaths,
+    ReportService,
+    validate_profile_name,
+)
+from tools.performance_report.source_identity import (
+    inspect_report_source,
+    require_report_only_publication,
+)
+from tools.performance_report.workspace import (
+    ENVIRONMENT_JSON,
+    ENVIRONMENT_SCHEMA,
+    ENVIRONMENT_TEX,
+    STANDALONE_BUILDER,
+    TABLE_FILLING_RUNBOOK,
+    WORKSPACE_MANIFEST,
+    ReportWorkspaceError,
+    export_profile,
+    initialize_profile,
+    record_authenticated_profile_environment,
+    refresh_profile_environment,
+    require_active_profile_environment,
+    require_authenticated_profile_environment,
+)
+
+
+def _seed_template(repo: Path) -> None:
+    docs = repo / "src/pyamplicol/_profiling_campaign"
+    docs.mkdir(parents=True)
+    (docs / "pyAmpliCol.tex").write_text(
+        "\\documentclass{article}\\begin{document}report\\end{document}\n",
+        encoding="ascii",
+    )
+    (docs / "result_tables.py").write_text(
+        "#!/usr/bin/env python3\n",
+        encoding="ascii",
+    )
+    ReportService(ReportPaths.from_repo(repo)).publish(
+        reset=True,
+        merge_artifacts=False,
+    )
+    (docs / "pyAmpliCol.pdf").write_bytes(b"%PDF-1.4\n%%EOF\n")
+
+
+def _try_report_writer_lock(
+    repo: str,
+    profile: str,
+    outcomes: object,
+) -> None:
+    service = ReportService(
+        ReportPaths.from_repo(Path(repo), profile=profile),
+    )
+    try:
+        with service.store.named_lock("report-writer", timeout=0.0):
+            outcomes.put("acquired")
+    except LockTimeoutError:
+        outcomes.put("timeout")
+
+
+def test_profile_names_and_paths_are_safe_and_machine_isolated(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    mac = ReportPaths.from_repo(repo, profile="macbook_M3")
+    cluster = ReportPaths.from_repo(repo, profile="cluster_EPYC")
+
+    assert mac.docs_dir == repo / "docs/performance_reports/macbook_M3"
+    assert mac.artifact_root == repo / ".artifacts/performance-report/macbook_M3"
+    assert mac.coordination_root == (
+        repo / ".artifacts/performance-report-coordination/macbook_M3"
+    )
+    assert mac.results_dir == mac.docs_dir / "results"
+    assert mac.artifact_root != cluster.artifact_root
+    assert mac.coordination_root != cluster.coordination_root
+    assert validate_profile_name("cluster_EPYC") == "cluster_EPYC"
+
+    for invalid in ("", "../escape", "a..b", "/absolute", "white space"):
+        with pytest.raises(ValueError, match="report profile"):
+            ReportPaths.from_repo(repo, profile=invalid)
+
+
+def test_initialize_profile_copies_publication_data_but_not_local_state(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+    template_state = (
+        repo / ".artifacts/performance-report/canonical/cells/attempt"
+    )
+    template_state.mkdir(parents=True)
+    (template_state / "worker.log").write_text("private\n", encoding="ascii")
+    coordination = (
+        repo / ".artifacts/performance-report-coordination/canonical"
+    )
+    coordination.mkdir(parents=True, exist_ok=True)
+    (coordination / "writer.lock").write_text("", encoding="ascii")
+
+    profile = initialize_profile(repo, "macbook_M3")
+
+    assert (profile / "pyAmpliCol.tex").is_file()
+    assert not (profile / "pyAmpliCol.pdf").exists()
+    assert (profile / "result_tables.py").is_file()
+    assert (profile / STANDALONE_BUILDER).is_file()
+    environment_tex = (profile / ENVIRONMENT_TEX).read_text()
+    assert r"\renewcommand{\ReportProfileName}{macbook\_M3}" in environment_tex
+    assert r"\renewcommand{\ReportPlatformSummary}" in environment_tex
+    assert r"\renewcommand{\ReportToolchainSummary}" in environment_tex
+    assert r"\renewcommand{\ReportEditionStatement}" in environment_tex
+    assert "pending an authenticated post-checkpoint build" in environment_tex
+    assert "source checkout" not in environment_tex
+    environment = json.loads((profile / ENVIRONMENT_JSON).read_text())
+    assert environment["schema"] == ENVIRONMENT_SCHEMA
+    assert environment["status"] == "pending_exact_runtime"
+    assert environment["source_revision"] == "pending"
+    assert environment["platform"] == "pending measurement-host authentication"
+    assert environment["machine"] == "pending measurement-host authentication"
+    assert "source checkout" not in environment["pyamplicol"]
+    assert (profile / "results/report-cache.schema.json").is_file()
+    assert not (profile / ".artifacts").exists()
+    assert not (profile / "results/.coordination").exists()
+    manifest = json.loads((profile / WORKSPACE_MANIFEST).read_text())
+    assert manifest["profile"] == "macbook_M3"
+    assert manifest["campaign_policy"] == MACBOOK_M3_POLICY.as_manifest()
+    assert (profile / TABLE_FILLING_RUNBOOK).is_file()
+    assert manifest["measurement_state"] == "copied"
+    assert manifest["initialized_environment"]["profile"] == "macbook_M3"
+    assert (
+        manifest["initialized_environment"]["status"]
+        == "pending_exact_runtime"
+    )
+    assert manifest["environment_json"] == ENVIRONMENT_JSON
+    assert "result_tables.py" in manifest["tracked_content"]
+    assert manifest["initialized_source_identity"] == {
+        "schema": "pyamplicol-report-source-v1",
+        "revision": "unknown",
+        "tree": "unknown",
+        "clean": False,
+        "dirty_paths": [],
+    }
+    assert manifest["artifact_root"] == (
+        ".artifacts/performance-report/macbook_M3"
+    )
+    runbook = (profile / TABLE_FILLING_RUNBOOK).read_text(encoding="utf-8")
+    assert (
+        "30 GB authenticated memory guard defined as max(process-tree RSS, "
+        "Darwin physical footprint)"
+    ) in runbook
+    assert "Legacy v2 RSS-only censor evidence remains readable" in runbook
+    assert "30 GB hard RSS" not in runbook
+    assert ReportService(
+        ReportPaths.from_repo(repo, profile="macbook_M3")
+    ).audit()["cache_render_match"]
+
+    with pytest.raises(ReportWorkspaceError, match="already exists"):
+        initialize_profile(repo, "macbook_M3")
+
+
+def test_initialize_x86_epyc_profile_binds_parallel_resource_policy(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+
+    profile = initialize_profile(repo, "x86_EPYC", reset_measurements=True)
+    manifest = json.loads((profile / WORKSPACE_MANIFEST).read_text())
+    readme = (profile / "README.md").read_text(encoding="utf-8")
+    runbook = (profile / "TABLE_FILLING.md").read_text(encoding="utf-8")
+
+    assert manifest["campaign_policy"] == X86_EPYC_POLICY.as_manifest()
+    assert manifest["campaign_policy"]["workers"] == 25
+    assert manifest["campaign_policy"]["memory_limit_bytes"] == 80_000_000_000
+    assert "--workers 25 --cell-cores 1" in runbook
+    assert "--max-ram-gb 80" in runbook
+    assert "25 independent workers" in runbook
+    assert "80 GB authenticated process-tree memory guard per worker" in runbook
+    assert "Legacy v2 RSS-only censor evidence remains readable" in runbook
+    assert "80 GB hard RSS" not in runbook
+    assert "`TABLE_FILLING.md` is the sole authoritative campaign procedure" in (
+        readme
+    )
+    assert "populate" not in readme
+    assert "export-profile x86_EPYC" in readme
+
+
+def test_profile_readme_requires_full_audited_five_second_campaign(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+
+    profile = initialize_profile(repo, "macbook_M3")
+    readme = (profile / "README.md").read_text(encoding="utf-8")
+
+    assert "`TABLE_FILLING.md` is the sole authoritative campaign procedure" in (
+        readme
+    )
+    assert "populate" not in readme
+    assert "render --compile" in readme
+    assert "result_tables.py audit" in readme
+    assert "export-profile macbook_M3" in readme
+
+
+def test_documentation_index_links_the_four_published_report_pdfs() -> None:
+    docs = Path(__file__).resolve().parents[2] / "docs"
+    root_readme = (docs / "README.md").read_text(encoding="utf-8")
+    report_readme = (docs / "performance_reports/README.md").read_text(
+        encoding="utf-8"
+    )
+
+    assert "performance_reports/README.md" in root_readme
+    assert "macbook_M3_pyAmpliCol.pdf" in report_readme
+    assert "EPYC_pyAmpliCol.pdf" in report_readme
+    assert "summary_plots_final.pdf" in report_readme
+    assert "summary_plots_final_helicity_sum.pdf" in report_readme
+    assert "performance_reports/results/" not in report_readme
+    assert "profiling-campaign copy" in report_readme
+    assert "refresh-pdf" in report_readme
+
+
+def _commit_all(repo: Path, message: str) -> str:
+    subprocess.run(("git", "add", "."), cwd=repo, check=True)
+    subprocess.run(("git", "commit", "-q", "-m", message), cwd=repo, check=True)
+    return subprocess.run(
+        ("git", "rev-parse", "HEAD"),
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+
+def _test_environment(
+    *,
+    platform_summary: str = "Darwin 24.0.0; arm64; Apple M3 Pro",
+    machine: str = "arm64",
+    processor: str = "Apple M3 Pro",
+) -> dict[str, str]:
+    return {
+        "schema": ENVIRONMENT_SCHEMA,
+        "profile": "macbook_M3",
+        "platform": platform_summary,
+        "machine": machine,
+        "processor": processor,
+        "python": "3.12.6",
+        "python_implementation": "CPython",
+        "status": "authenticated",
+        "source_revision": "a" * 40,
+        "pyamplicol": "0.1.0",
+        "numpy": "2.1.0",
+        "native_target": "aarch64-apple-darwin",
+        "native_cpu_features": "neon",
+        "native_build_inputs_sha256": "b" * 64,
+        "native_extension_sha256": "c" * 64,
+        "python_package_tree_sha256": "d" * 64,
+        "candidate_fingerprint": "candidate-aarch64",
+    }
+
+
+def _test_runtime(source_revision: str = "a" * 40) -> dict[str, object]:
+    return {
+        "package_version": "0.1.0",
+        "native_build_inputs_sha256": "a" * 64,
+        "native_extension": {"sha256": "b" * 64},
+        "python_package_tree": {"sha256": "c" * 64},
+        "candidate_build_identity": {
+            "candidate_fingerprint": "candidate-aarch64",
+            "source_revision": source_revision,
+        },
+        "native_target": {
+            "triple": "aarch64-apple-darwin",
+            "cpu_features": ["neon", "fp-armv8"],
+        },
+    }
+
+
+def test_processor_description_uses_sysctl_and_falls_back_when_denied(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class Completed:
+        def __init__(self, returncode: int, stdout: str) -> None:
+            self.returncode = returncode
+            self.stdout = stdout
+
+    with monkeypatch.context() as context:
+        context.setattr(workspace_module.platform, "system", lambda: "Darwin")
+        context.setattr(workspace_module.platform, "processor", lambda: "arm")
+        context.setattr(
+            workspace_module.subprocess,
+            "run",
+            lambda *_args, **_kwargs: Completed(0, "Apple M3 Pro\n"),
+        )
+        assert workspace_module._processor_description() == "Apple M3 Pro"
+
+    attempted: list[tuple[str, ...]] = []
+
+    def denied(command, **_kwargs):
+        attempted.append(command)
+        return Completed(1, "")
+
+    with monkeypatch.context() as context:
+        context.setattr(workspace_module.platform, "system", lambda: "Darwin")
+        context.setattr(workspace_module.platform, "processor", lambda: "arm")
+        context.setattr(workspace_module.subprocess, "run", denied)
+        assert workspace_module._processor_description() == "arm"
+
+    assert attempted == [
+        ("sysctl", "-n", "machdep.cpu.brand_string"),
+        ("sysctl", "-n", "hw.model"),
+    ]
+
+
+def test_active_runtime_accepts_only_processor_display_label_drift(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "report-tests@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Report Tests"),
+        cwd=repo,
+        check=True,
+    )
+    initialize_profile(repo, "macbook_M3")
+    measured = _commit_all(repo, "Initialize measured-source scaffold")
+    hosts = iter(
+        (
+            {
+                "schema": ENVIRONMENT_SCHEMA,
+                "profile": "macbook_M3",
+                "platform": "Darwin 24.0.0; arm64; Apple M3 Pro",
+                "machine": "arm64",
+                "processor": "Apple M3 Pro",
+                "python": "3.12.6",
+                "python_implementation": "CPython",
+            },
+            {
+                "schema": ENVIRONMENT_SCHEMA,
+                "profile": "macbook_M3",
+                "platform": "Darwin 24.0.0; arm64; arm",
+                "machine": "arm64",
+                "processor": "arm",
+                "python": "3.12.6",
+                "python_implementation": "CPython",
+            },
+        )
+    )
+    monkeypatch.setattr(
+        workspace_module,
+        "_host_environment_payload",
+        lambda _profile: next(hosts),
+    )
+
+    recorded = refresh_profile_environment(
+        repo,
+        "macbook_M3",
+        expected_source_revision=measured,
+        runtime_auditor=lambda _revision, _root: _test_runtime(measured),
+    )
+
+    assert recorded["processor"] == "Apple M3 Pro"
+    assert require_active_profile_environment(
+        repo,
+        "macbook_M3",
+        expected_source_revision=measured,
+        runtime_auditor=lambda _revision, _root: _test_runtime(measured),
+    ) == recorded
+
+
+@pytest.mark.parametrize(
+    "overrides",
+    (
+        {"platform": "Darwin 25.0.0; arm64; arm"},
+        {
+            "platform": "Linux 6.8.0; arm64; arm",
+        },
+        {
+            "platform": "Darwin 24.0.0; x86_64; arm",
+            "machine": "x86_64",
+        },
+        {"python": "3.13.1"},
+        {"source_revision": "e" * 40},
+        {"candidate_fingerprint": "candidate-other"},
+        {"native_build_inputs_sha256": "e" * 64},
+        {"native_extension_sha256": "e" * 64},
+        {"python_package_tree_sha256": "e" * 64},
+        {"native_target": "x86_64-apple-darwin"},
+    ),
+)
+def test_stable_environment_identity_retains_strict_runtime_fields(
+    overrides: dict[str, str],
+) -> None:
+    recorded = _test_environment()
+    active = {
+        **recorded,
+        "platform": "Darwin 24.0.0; arm64; arm",
+        "processor": "arm",
+        **overrides,
+    }
+
+    assert workspace_module._stable_environment_identity(
+        active
+    ) != workspace_module._stable_environment_identity(recorded)
+
+
+def test_stable_environment_identity_rejects_noncanonical_processor_suffix() -> None:
+    environment = _test_environment(
+        platform_summary="Darwin 24.0.0; arm64; Apple M3 Pro",
+        processor="arm",
+    )
+
+    with pytest.raises(
+        ReportWorkspaceError,
+        match="does not match its processor label",
+    ):
+        workspace_module._stable_environment_identity(environment)
+
+
+def test_stable_environment_identity_retains_linux_processor_model() -> None:
+    recorded = _test_environment(
+        platform_summary="Linux 6.8.0; x86_64; AMD EPYC 7551",
+        machine="x86_64",
+        processor="AMD EPYC 7551",
+    )
+    active = _test_environment(
+        platform_summary="Linux 6.8.0; x86_64; AMD EPYC 7763",
+        machine="x86_64",
+        processor="AMD EPYC 7763",
+    )
+
+    assert workspace_module._stable_environment_identity(
+        active
+    ) != workspace_module._stable_environment_identity(recorded)
+
+
+def test_environment_refresh_authenticates_runtime_without_dirtying_source(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "report-tests@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Report Tests"),
+        cwd=repo,
+        check=True,
+    )
+    profile = initialize_profile(repo, "macbook_M3")
+    measured = _commit_all(repo, "Initialize measured-source scaffold")
+    observed: list[tuple[str, Path]] = []
+
+    def runtime_auditor(revision: str, checkout: Path) -> dict[str, object]:
+        observed.append((revision, checkout))
+        return {
+            "package_version": "0.1.0",
+            "native_build_inputs_sha256": "a" * 64,
+            "native_extension": {"sha256": "b" * 64},
+            "python_package_tree": {"sha256": "c" * 64},
+            "candidate_build_identity": {
+                "candidate_fingerprint": "candidate-aarch64",
+                "source_revision": measured,
+            },
+            "native_target": {
+                "triple": "aarch64-apple-darwin",
+                "cpu_features": ["neon", "fp-armv8"],
+            },
+        }
+
+    environment = refresh_profile_environment(
+        repo,
+        "macbook_M3",
+        expected_source_revision=measured,
+        runtime_auditor=runtime_auditor,
+    )
+
+    assert observed == [(measured, repo.resolve())]
+    assert environment["status"] == "authenticated"
+    assert environment["source_revision"] == measured
+    assert environment["pyamplicol"] == "0.1.0"
+    assert environment["native_target"] == "aarch64-apple-darwin"
+    assert environment["native_cpu_features"] == "neon, fp-armv8"
+    assert environment["native_extension_sha256"] == "b" * 64
+    assert environment["python_package_tree_sha256"] == "c" * 64
+    assert environment["candidate_fingerprint"] == "candidate-aarch64"
+    assert "source checkout" not in json.dumps(environment)
+    assert require_authenticated_profile_environment(
+        repo,
+        "macbook_M3",
+        expected_source_revision=measured,
+    ) == environment
+    assert require_active_profile_environment(
+        repo,
+        "macbook_M3",
+        expected_source_revision=measured,
+        runtime_auditor=runtime_auditor,
+    ) == environment
+    source = inspect_report_source(repo)
+    assert source.eligible
+    assert source.revision == measured
+
+    publication = _commit_all(repo, "Publish authenticated environment")
+    lineage = require_report_only_publication(
+        repo,
+        measured_revision=measured,
+        profile="macbook_M3",
+        publication_revision=publication,
+    )
+    assert lineage.eligible
+    assert lineage.changed_paths == (
+        "docs/performance_reports/macbook_M3/report_environment.json",
+        "docs/performance_reports/macbook_M3/report_environment.tex",
+    )
+    assert (profile / ENVIRONMENT_JSON).is_file()
+
+
+def test_explicit_environment_recorder_supports_portable_release_runtime(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    docs = tmp_path / "copied-campaign"
+    docs.mkdir()
+    monkeypatch.setattr(
+        workspace_module,
+        "_host_environment_payload",
+        lambda profile: {
+            "schema": ENVIRONMENT_SCHEMA,
+            "profile": profile,
+            "platform": "Linux 6.8.0; x86_64; AMD EPYC",
+            "machine": "x86_64",
+            "processor": "AMD EPYC",
+            "python": "3.12.6",
+            "python_implementation": "CPython",
+        },
+    )
+
+    class Numpy:
+        __version__ = "2.1.0"
+
+    monkeypatch.setattr(
+        workspace_module.importlib,
+        "import_module",
+        lambda name: Numpy() if name == "numpy" else None,
+    )
+    runtime = _test_runtime()
+    runtime["candidate_build_identity"] = {
+        "publishable": True,
+        "source_revision": "a" * 40,
+    }
+    runtime["candidate_build_identity_sha256"] = "d" * 64
+
+    recorded = record_authenticated_profile_environment(
+        docs,
+        "copied-campaign",
+        expected_source_revision="a" * 40,
+        active_runtime=runtime,
+    )
+
+    assert recorded["status"] == "authenticated"
+    assert recorded["profile"] == "copied-campaign"
+    assert recorded["source_revision"] == "a" * 40
+    assert recorded["candidate_fingerprint"] == f"release:{'d' * 64}"
+    assert json.loads((docs / ENVIRONMENT_JSON).read_text()) == recorded
+    tex = (docs / ENVIRONMENT_TEX).read_text(encoding="utf-8")
+    assert r"\renewcommand{\ReportProfileName}{copied-campaign}" in tex
+    assert "pending" not in tex
+
+    invalid = dict(runtime)
+    invalid["candidate_build_identity_sha256"] = "short"
+    with pytest.raises(ReportWorkspaceError, match="is not SHA-256"):
+        record_authenticated_profile_environment(
+            docs,
+            "copied-campaign",
+            expected_source_revision="a" * 40,
+            active_runtime=invalid,
+        )
+    assert json.loads((docs / ENVIRONMENT_JSON).read_text()) == recorded
+
+    wrong_source = dict(runtime)
+    wrong_source["candidate_build_identity"] = {
+        "publishable": True,
+        "source_revision": "b" * 40,
+    }
+    with pytest.raises(ReportWorkspaceError, match="expected source revision"):
+        record_authenticated_profile_environment(
+            docs,
+            "copied-campaign",
+            expected_source_revision="a" * 40,
+            active_runtime=wrong_source,
+        )
+    assert json.loads((docs / ENVIRONMENT_JSON).read_text()) == recorded
+
+    missing_source = dict(runtime)
+    missing_source["candidate_build_identity"] = {"publishable": True}
+    with pytest.raises(ReportWorkspaceError, match="expected source revision"):
+        record_authenticated_profile_environment(
+            docs,
+            "copied-campaign",
+            expected_source_revision="a" * 40,
+            active_runtime=missing_source,
+        )
+    assert json.loads((docs / ENVIRONMENT_JSON).read_text()) == recorded
+
+
+def test_pending_or_wrong_source_environment_fails_closed(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "report-tests@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Report Tests"),
+        cwd=repo,
+        check=True,
+    )
+    initialize_profile(repo, "macbook_M3")
+    measured = _commit_all(repo, "Initialize measured-source scaffold")
+
+    with pytest.raises(
+        ReportWorkspaceError,
+        match="not authenticated for measurement source",
+    ):
+        require_authenticated_profile_environment(
+            repo,
+            "macbook_M3",
+            expected_source_revision=measured,
+        )
+    with pytest.raises(
+        ReportWorkspaceError,
+        match="clean evaluator source checkout",
+    ):
+        refresh_profile_environment(
+            repo,
+            "macbook_M3",
+            expected_source_revision="b" * 40,
+            runtime_auditor=lambda _revision, _root: {},
+        )
+
+
+def test_active_runtime_must_still_match_recorded_environment(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "report-tests@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Report Tests"),
+        cwd=repo,
+        check=True,
+    )
+    initialize_profile(repo, "macbook_M3")
+    measured = _commit_all(repo, "Initialize measured-source scaffold")
+
+    def runtime(version: str) -> dict[str, object]:
+        return {
+            "package_version": version,
+            "native_build_inputs_sha256": "a" * 64,
+            "native_extension": {"sha256": "b" * 64},
+            "python_package_tree": {"sha256": "c" * 64},
+            "candidate_build_identity": {
+                "candidate_fingerprint": "candidate-aarch64",
+                "source_revision": measured,
+            },
+            "native_target": {
+                "triple": "aarch64-apple-darwin",
+                "cpu_features": ["neon"],
+            },
+        }
+
+    refresh_profile_environment(
+        repo,
+        "macbook_M3",
+        expected_source_revision=measured,
+        runtime_auditor=lambda _revision, _root: runtime("0.1.0"),
+    )
+
+    with pytest.raises(
+        ReportWorkspaceError,
+        match="active measurement runtime differs",
+    ):
+        require_active_profile_environment(
+            repo,
+            "macbook_M3",
+            expected_source_revision=measured,
+            runtime_auditor=lambda _revision, _root: runtime("0.2.0"),
+        )
+
+
+def test_new_cluster_profile_resets_measurements_and_drops_source_pdf(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+    initialize_profile(repo, "macbook_M3")
+
+    cluster = initialize_profile(
+        repo,
+        "cluster_EPYC",
+        source_profile="macbook_M3",
+        reset_measurements=True,
+    )
+    result = ReportService(
+        ReportPaths.from_repo(repo, profile="cluster_EPYC")
+    ).validate()
+
+    assert result["statuses"] == {
+        "not_available": len(REPORT_CATALOG.measurement_cells())
+    }
+    assert not (cluster / "pyAmpliCol.pdf").exists()
+    manifest = json.loads((cluster / WORKSPACE_MANIFEST).read_text())
+    assert manifest["initialized_from"].endswith("/macbook_M3")
+    assert manifest["measurement_state"] == "reset"
+
+
+def test_export_profile_contains_only_fresh_publication_workspace(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+    profile = initialize_profile(repo, "macbook_M3")
+    stale_pdf = b"%PDF-1.4\n% stale source PDF\n%%EOF\n"
+    fresh_pdf = b"%PDF-1.4\n% fresh exported PDF\n%%EOF\n"
+    (profile / "pyAmpliCol.pdf").write_bytes(stale_pdf)
+    local_state = (
+        repo
+        / ".artifacts/performance-report/macbook_M3/cells/private/worker.log"
+    )
+    local_state.parent.mkdir(parents=True)
+    local_state.write_text("private\n", encoding="ascii")
+    compiled: list[Path] = []
+
+    def fake_compile(report_dir: Path) -> Path:
+        compiled.append(report_dir)
+        output = report_dir / "pyAmpliCol.pdf"
+        output.write_bytes(fresh_pdf)
+        (report_dir / "pyAmpliCol.log").write_text(
+            "clean\n",
+            encoding="ascii",
+        )
+        return output
+
+    monkeypatch.setattr(
+        "tools.performance_report.workspace.compile_report",
+        fake_compile,
+    )
+
+    exported = export_profile(
+        repo,
+        "macbook_M3",
+        tmp_path / "exports/macbook_M3",
+    )
+
+    assert (exported / "pyAmpliCol.tex").is_file()
+    assert (exported / "pyAmpliCol.pdf").is_file()
+    assert (exported / "pyAmpliCol.pdf").read_bytes() == fresh_pdf
+    assert (profile / "pyAmpliCol.pdf").read_bytes() == stale_pdf
+    assert len(compiled) == 1
+    assert (exported / STANDALONE_BUILDER).is_file()
+    assert (exported / TABLE_FILLING_RUNBOOK).is_file()
+    assert (exported / WORKSPACE_MANIFEST).is_file()
+    assert (exported / ENVIRONMENT_JSON).is_file()
+    assert (exported / ENVIRONMENT_TEX).is_file()
+    assert not (exported / ".artifacts").exists()
+    assert not tuple(exported.rglob("*.lock"))
+    assert not tuple(exported.rglob("*.log"))
+
+
+def test_export_profile_can_omit_pdf(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+    initialize_profile(repo, "macbook_M3")
+
+    def unexpected_compile(_report_dir: Path) -> Path:
+        raise AssertionError("PDF compilation must be disabled")
+
+    monkeypatch.setattr(
+        "tools.performance_report.workspace.compile_report",
+        unexpected_compile,
+    )
+    exported = export_profile(
+        repo,
+        "macbook_M3",
+        tmp_path / "exports/macbook_M3",
+        include_pdf=False,
+    )
+
+    assert not (exported / "pyAmpliCol.pdf").exists()
+
+
+def test_export_holds_source_writer_lock_while_copying(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+    initialize_profile(repo, "macbook_M3")
+    original_copy = workspace_module._copy_publication_members
+    observed_lock = False
+
+    def checking_copy(source: Path, destination: Path) -> None:
+        nonlocal observed_lock
+
+        context = multiprocessing.get_context("fork")
+        outcomes = context.Queue()
+        process = context.Process(
+            target=_try_report_writer_lock,
+            args=(
+                str(repo),
+                "macbook_M3",
+                outcomes,
+            ),
+        )
+        process.start()
+        process.join(timeout=3)
+        assert process.exitcode == 0
+        assert outcomes.get(timeout=1) == "timeout"
+        observed_lock = True
+        original_copy(source, destination)
+
+    monkeypatch.setattr(
+        workspace_module,
+        "_copy_publication_members",
+        checking_copy,
+    )
+    export_profile(
+        repo,
+        "macbook_M3",
+        tmp_path / "exports/macbook_M3",
+        include_pdf=False,
+    )
+
+    assert observed_lock
+
+
+def test_reset_profile_rejects_preexisting_local_artifact_state(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    _seed_template(repo)
+    stale = repo / ".artifacts/performance-report/macbook_M3/cells/stale"
+    stale.mkdir(parents=True)
+    (stale / "current.json").write_text("{}\n", encoding="ascii")
+
+    with pytest.raises(
+        ReportWorkspaceError,
+        match="artifact root already contains local state",
+    ):
+        initialize_profile(
+            repo,
+            "macbook_M3",
+            reset_measurements=True,
+        )
diff --git a/pyamplicol/tests/unit/test_prepare_class_c_bridge_bootstrap.py b/pyamplicol/tests/unit/test_prepare_class_c_bridge_bootstrap.py
new file mode 100644
index 0000000000..06958fbc3e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_prepare_class_c_bridge_bootstrap.py
@@ -0,0 +1,182 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+from pathlib import Path
+
+from tools.developer import prepare_class_c_bridge as bootstrap
+
+
+def _write(path: Path, data: bytes) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(data)
+
+
+def test_bind_ancestor_runtime_reconstructs_only_staged_runtime(
+    tmp_path: Path,
+) -> None:
+    live = tmp_path / "live-descendant"
+    ancestor = tmp_path / "ancestor"
+    for root in (live, ancestor):
+        _write(root / "pyproject.toml", b"[project]\nname='pyamplicol'\n")
+        _write(root / "Cargo.toml", b"[workspace]\n")
+        _write(root / "dependencies/contributor-lock.toml", b"[dependency]\n")
+        _write(root / "rust/lib.rs", b"pub fn tracked() {}\n")
+        _write(root / "src/pyamplicol/__init__.py", b"# tracked package\n")
+
+    live_package = live / "src/pyamplicol"
+    _write(live_package / "descendant_only.py", b"raise RuntimeError\n")
+    extension = live_package / "_rusticol.abi3.so"
+    _write(extension, b"retained native extension")
+    for relative in (
+        "_sdk/fortran/rusticol.f90",
+        "_sdk/include/rusticol.h",
+        "_sdk/lib/librusticol_capi.a",
+        "_sdk/link.json",
+    ):
+        _write(live_package / relative, relative.encode("ascii"))
+    _write(
+        live_package / "_sdk/metadata.json",
+        json.dumps({"target": "test-target"}).encode("ascii"),
+    )
+    _write(
+        live_package / "assets/selftest/test-target/expected.json",
+        b'{"ok":true}\n',
+    )
+    (live / "dependencies/checkouts").mkdir(parents=True)
+    for relative in bootstrap._IGNORED_NATIVE_INPUTS:
+        _write(live / relative, f"{relative}\n".encode("ascii"))
+
+    shadow = tmp_path / "shadow"
+    shutil.copytree(ancestor, shadow)
+    for relative in bootstrap._IGNORED_NATIVE_INPUTS:
+        _write(shadow / relative, (live / relative).read_bytes())
+    native_digest = bootstrap._native_build_inputs_digest(shadow)
+    extension_sha256 = hashlib.sha256(extension.read_bytes()).hexdigest()
+    _write(
+        live / ".artifacts/source-runtime/_build_info.json",
+        (
+            json.dumps(
+                {
+                    "candidate_fingerprint": "candidate-test",
+                    "source_runtime": {
+                        "extension_name": extension.name,
+                        "extension_sha256": extension_sha256,
+                        "native_build_inputs_sha256": native_digest,
+                    },
+                    "version": "0.1.0.dev0+candidate.test",
+                },
+                sort_keys=True,
+            )
+            + "\n"
+        ).encode("ascii"),
+    )
+
+    identity = bootstrap._bind_ancestor_runtime(live, ancestor)
+
+    ancestor_extension = ancestor / "src/pyamplicol" / extension.name
+    assert not ancestor_extension.is_symlink()
+    assert os.stat(ancestor_extension).st_ino == os.stat(extension).st_ino
+    linked_header = ancestor / "src/pyamplicol/_sdk/include/rusticol.h"
+    assert os.stat(linked_header).st_ino == os.stat(
+        live_package / "_sdk/include/rusticol.h"
+    ).st_ino
+    assert (ancestor / ".artifacts/source-runtime").is_symlink()
+    assert (ancestor / "dependencies/checkouts").is_symlink()
+    assert all(
+        (ancestor / path).is_symlink()
+        for path in bootstrap._IGNORED_NATIVE_INPUTS
+    )
+    assert not (ancestor / "src/pyamplicol/descendant_only.py").exists()
+    assert bootstrap._native_build_inputs_digest(ancestor) == native_digest
+    assert identity == {
+        "candidate_fingerprint": "candidate-test",
+        "extension_name": extension.name,
+        "extension_sha256": extension_sha256,
+        "native_build_inputs_sha256": native_digest,
+        "package_version": "0.1.0.dev0+candidate.test",
+        "target": "test-target",
+    }
+
+
+def test_bind_release_runtime_uses_release_projection_without_candidate_inputs(
+    tmp_path: Path,
+) -> None:
+    live = tmp_path / "live-descendant"
+    ancestor = tmp_path / "ancestor"
+    for root in (live, ancestor):
+        _write(root / "pyproject.toml", b"[project]\nname='pyamplicol'\n")
+        _write(root / "Cargo.toml", b"[workspace]\n")
+        _write(root / "src/pyamplicol/__init__.py", b"# tracked package\n")
+    _write(
+        ancestor / "build_backend/native_build_identity.py",
+        (
+            b"import hashlib\n"
+            b"def native_build_inputs_digest("
+            b"root, *, normalize_release_cargo_lock=False):\n"
+            b"    if not normalize_release_cargo_lock:\n"
+            b"        raise RuntimeError('release projection required')\n"
+            b"    return hashlib.sha256((root / 'Cargo.toml').read_bytes()).hexdigest()\n"
+        ),
+    )
+
+    live_package = live / "src/pyamplicol"
+    extension = live_package / "_rusticol.abi3.so"
+    _write(extension, b"release native extension")
+    for relative in (
+        "_sdk/fortran/rusticol.f90",
+        "_sdk/include/rusticol.h",
+        "_sdk/lib/librusticol_capi.a",
+        "_sdk/link.json",
+    ):
+        _write(live_package / relative, relative.encode("ascii"))
+    _write(
+        live_package / "_sdk/metadata.json",
+        json.dumps({"target": "release-target"}).encode("ascii"),
+    )
+    _write(
+        live_package / "assets/selftest/release-target/expected.json",
+        b'{"ok":true}\n',
+    )
+
+    native_digest = bootstrap._native_build_inputs_digest(
+        ancestor,
+        normalize_release_cargo_lock=True,
+    )
+    extension_sha256 = hashlib.sha256(extension.read_bytes()).hexdigest()
+    _write(
+        live / ".artifacts/source-runtime/_build_info.json",
+        (
+            json.dumps(
+                {
+                    "native_build_inputs_sha256": native_digest,
+                    "publishable": True,
+                    "source_runtime": {
+                        "extension_name": extension.name,
+                        "extension_sha256": extension_sha256,
+                        "mode": "release",
+                        "native_build_inputs_sha256": native_digest,
+                    },
+                    "version": "0.1.0",
+                },
+                sort_keys=True,
+            )
+            + "\n"
+        ).encode("ascii"),
+    )
+
+    identity = bootstrap._bind_ancestor_runtime(live, ancestor)
+
+    assert not (ancestor / "dependencies/checkouts").exists()
+    assert all(not (ancestor / path).exists() for path in bootstrap._IGNORED_NATIVE_INPUTS)
+    assert identity == {
+        "candidate_fingerprint": None,
+        "extension_name": extension.name,
+        "extension_sha256": extension_sha256,
+        "native_build_inputs_sha256": native_digest,
+        "package_version": "0.1.0",
+        "target": "release-target",
+    }
diff --git a/pyamplicol/tests/unit/test_prepared_kernel_catalog.py b/pyamplicol/tests/unit/test_prepared_kernel_catalog.py
new file mode 100644
index 0000000000..ffe9173287
--- /dev/null
+++ b/pyamplicol/tests/unit/test_prepared_kernel_catalog.py
@@ -0,0 +1,589 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections import Counter
+from copy import copy
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.models import (
+    BuiltinSMModel,
+    CompiledUFOModel,
+    compile_model_source,
+)
+from pyamplicol.models.prepared_catalog import (
+    PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF,
+    PREPARED_INDEPENDENT_BLOCK_PROOF,
+    PreparedKernelCatalogError,
+    PropagatorKernelKey,
+    build_prepared_kernel_catalog,
+)
+from pyamplicol.models.prepared_catalog_helpers import (
+    proves_homogeneous_complex_linearity,
+)
+from pyamplicol.models.prepared_compile import _independent_block_contract
+from pyamplicol.models.recurrence_catalog_builder import (
+    build_recurrence_template_catalog,
+)
+from pyamplicol.models.recurrence_template import ExactComplexRationalV1
+
+MODEL_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+
+
+def test_homogeneous_current_linearity_proof_fails_closed() -> None:
+    from symbolica import E
+
+    current = (E("proof_current_0"), E("proof_current_1"))
+    momentum = E("proof_momentum")
+
+    assert proves_homogeneous_complex_linearity(
+        (current[0] * momentum + 2 * current[1],), current
+    )
+    assert not proves_homogeneous_complex_linearity(
+        (current[0] * momentum + 2 * current[1] + 3,), current
+    )
+    assert not proves_homogeneous_complex_linearity((current[0] * current[1],), current)
+    assert not proves_homogeneous_complex_linearity(
+        (E("conj(proof_current_0)"),), current
+    )
+
+
+@pytest.fixture(scope="module")
+def builtin_catalog():
+    model = BuiltinSMModel()
+    return model, build_prepared_kernel_catalog(model)
+
+
+@pytest.fixture(scope="module")
+def external_sm_catalog():
+    compiled = compile_model_source(
+        MODEL_ROOT / "sm.json",
+        restriction=str((MODEL_ROOT / "restrict_default.json").resolve()),
+        use_cache=True,
+    )
+    model = CompiledUFOModel(compiled)
+    return compiled, model, build_prepared_kernel_catalog(model)
+
+
+def test_builtin_catalog_is_deterministic_and_process_independent(
+    builtin_catalog,
+) -> None:
+    model, expected = builtin_catalog
+    reordered = copy(model)
+    reordered.vertices = tuple(reversed(model.vertices))
+
+    assert build_prepared_kernel_catalog(model) == expected
+    assert build_prepared_kernel_catalog(reordered) == expected
+    assert (
+        build_prepared_kernel_catalog(reordered).resolver_manifest()
+        == expected.resolver_manifest()
+    )
+
+
+def test_every_builtin_vertex_kind_has_a_constructive_binding(
+    builtin_catalog,
+) -> None:
+    model, catalog = builtin_catalog
+
+    assert (
+        {binding.key.kind for binding in catalog.vertex_bindings}
+        == {vertex.kind for vertex in model.vertices}
+        == set(range(25))
+    )
+    assert not [
+        gap for gap in catalog.unsupported_variants if gap.contract_kind == "vertex"
+    ]
+
+
+def test_builtin_chirality_dimensions_and_propagator_coverage(
+    builtin_catalog,
+) -> None:
+    model, catalog = builtin_catalog
+    by_id = catalog.by_id
+
+    for binding in catalog.vertex_bindings:
+        assert binding.left_state.dimension == model.current_dimension(
+            binding.key.particles[0],
+            binding.key.left_chirality,
+        )
+        assert binding.right_state.dimension == model.current_dimension(
+            binding.key.particles[1],
+            binding.key.right_chirality,
+        )
+        assert binding.result_state.dimension == model.current_dimension(
+            binding.key.particles[2],
+            binding.key.result_chirality,
+        )
+        assert by_id[binding.kernel_id].output_dimension == (
+            binding.result_state.dimension
+        )
+
+    expected: set[PropagatorKernelKey] = set()
+    for particle_id in sorted(
+        {
+            *(
+                particle_id
+                for particle_id in model.particles
+                if model.source_wavefunction_kind(particle_id) != "ghost"
+            ),
+            *(
+                model.anti_particle(particle_id)
+                for particle_id in model.particles
+                if model.source_wavefunction_kind(particle_id) != "ghost"
+            ),
+        }
+    ):
+        chiralities = (
+            (0,)
+            if model.auxiliary_kind(particle_id) is not None
+            or model.particle(particle_id).spin < 0
+            else tuple(
+                sorted(
+                    {state.chirality for state in model.source_spin_states(particle_id)}
+                )
+            )
+        )
+        expected.update(
+            PropagatorKernelKey(particle_id, chirality) for chirality in chiralities
+        )
+    expected.update(
+        PropagatorKernelKey(state.particle_id, state.chirality)
+        for binding in catalog.vertex_bindings
+        for state in (binding.left_state, binding.right_state, binding.result_state)
+        if model.source_wavefunction_kind(state.particle_id) != "ghost"
+    )
+    assert {binding.key for binding in catalog.propagator_bindings} == expected
+    assert all(
+        (binding.kernel_id is not None) == binding.applies_propagator
+        for binding in catalog.propagator_bindings
+    )
+    assert all(
+        PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF
+        in by_id[binding.kernel_id].proof_classes
+        for binding in catalog.propagator_bindings
+        if binding.kernel_id is not None
+    )
+    assert all(
+        PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF not in kernel.proof_classes
+        for kernel in catalog.kernels
+        if kernel.contract_kind != "propagator"
+    )
+    full_bottom = next(
+        binding
+        for binding in catalog.propagator_bindings
+        if binding.key == PropagatorKernelKey(5, 0)
+    )
+    assert full_bottom.applies_propagator
+    assert full_bottom.propagator_kind == "dirac-fermion"
+    assert full_bottom.mass_class == "massless"
+    assert any(
+        binding.key.particles == (5, 21, 5)
+        and binding.key.left_chirality == 0
+        and binding.key.right_chirality == 0
+        and binding.key.result_chirality == 0
+        for binding in catalog.vertex_bindings
+    )
+
+
+def test_direct_contractions_remain_native_while_vertex_closures_are_catalogued(
+    builtin_catalog,
+) -> None:
+    _model, catalog = builtin_catalog
+    kinds = Counter(kernel.contract_kind for kernel in catalog.kernels)
+
+    assert "direct-contraction" not in kinds
+    assert kinds["closure"] > 0
+    assert catalog.closure_bindings
+    assert all(binding.projection == "scalar" for binding in catalog.closure_bindings)
+
+
+def test_builtin_catalog_factors_and_deduplicates_linear_coupling_outputs(
+    builtin_catalog,
+) -> None:
+    _model, catalog = builtin_catalog
+    bindings_by_kernel: dict[int, set[str]] = {}
+    factored_bindings = 0
+    for binding in catalog.vertex_bindings:
+        bindings_by_kernel.setdefault(binding.kernel_id, set()).add(
+            binding.output_factor_source
+        )
+        if binding.output_factor_source == "none":
+            continue
+        factored_bindings += 1
+        assert not {
+            descriptor.role for descriptor in catalog.by_id[binding.kernel_id].inputs
+        } & {"coupling-real", "coupling-imag"}
+
+    assert factored_bindings > 0
+    assert any(
+        "none" in sources and bool(sources & {"coupling-real", "coupling-imag"})
+        for sources in bindings_by_kernel.values()
+    )
+    assert all(
+        binding.output_factor_source == "coupling-real"
+        for binding in catalog.closure_bindings
+    )
+
+
+def test_catalog_exact_contracts_are_finite_namespaced_and_nonempty(
+    builtin_catalog,
+) -> None:
+    _model, catalog = builtin_catalog
+    forbidden = ("indeterminate", "nan", "infinity", "complexinf")
+
+    for kernel in catalog.kernels:
+        assert kernel.exact_expressions
+        assert kernel.output_dimension == len(kernel.output_layout)
+        assert all(
+            expression and not any(marker in expression.lower() for marker in forbidden)
+            for expression in kernel.exact_expressions
+        )
+        assert all(
+            descriptor.symbol.startswith("pyamplicol::") for descriptor in kernel.inputs
+        )
+
+
+def test_every_certified_builtin_block_reconstructs_four_scalar_calls(
+    builtin_catalog,
+) -> None:
+    from symbolica import E, Replacement
+
+    _model, catalog = builtin_catalog
+    certified = tuple(
+        kernel
+        for kernel in catalog.kernels
+        if PREPARED_INDEPENDENT_BLOCK_PROOF in kernel.proof_classes
+    )
+    assert certified
+    for kernel in certified:
+        assert kernel.contract_kind == "vertex"
+        assert {item.role for item in kernel.inputs}.issubset(
+            {"left-current", "right-current"}
+        )
+        contract = _independent_block_contract(kernel)
+        assert len(contract.parameters) == 4 * kernel.input_arity
+        assert len(contract.outputs) == 4 * kernel.output_dimension
+        scalar_inputs = tuple(E(item.symbol) for item in kernel.inputs)
+        expected = tuple(
+            E(item).to_canonical_string() for item in kernel.exact_expressions
+        )
+        for lane in range(4):
+            lane_inputs = contract.parameters[
+                lane * kernel.input_arity : (lane + 1) * kernel.input_arity
+            ]
+            reverse = tuple(
+                Replacement(block_input, scalar_input)
+                for block_input, scalar_input in zip(
+                    lane_inputs, scalar_inputs, strict=True
+                )
+            )
+            lane_outputs = contract.outputs[
+                lane * kernel.output_dimension : (lane + 1) * kernel.output_dimension
+            ]
+            assert (
+                tuple(
+                    output.replace_multiple(reverse).to_canonical_string()
+                    for output in lane_outputs
+                )
+                == expected
+            )
+
+
+def test_independent_block_proof_excludes_non_current_vertex_contracts(
+    builtin_catalog,
+) -> None:
+    _model, catalog = builtin_catalog
+    for kernel in catalog.kernels:
+        if PREPARED_INDEPENDENT_BLOCK_PROOF in kernel.proof_classes:
+            continue
+        if kernel.contract_kind != "vertex":
+            continue
+        assert any(
+            item.role not in {"left-current", "right-current"} for item in kernel.inputs
+        )
+
+
+def test_external_sm_active_oriented_kernels_and_parameters_are_catalogued(
+    external_sm_catalog,
+) -> None:
+    _compiled, model, catalog = external_sm_catalog
+    active_kinds = {vertex.kind for vertex in model.vertices}
+
+    assert {binding.key.kind for binding in catalog.vertex_bindings} == active_kinds
+    assert catalog.model_parameter_kernel_id is not None
+    parameter_kernel = catalog.by_id[catalog.model_parameter_kernel_id]
+    assert parameter_kernel.contract_kind == "model-parameter"
+    assert parameter_kernel.output_dimension == len(
+        model.runtime_derived_parameter_definitions()
+    )
+    assert not catalog.closure_bindings
+    assert not catalog.unsupported_variants
+    assert all(
+        PREPARED_HOMOGENEOUS_LINEAR_CURRENT_PROOF in kernel.proof_classes
+        for kernel in catalog.kernels
+        if kernel.contract_kind == "propagator"
+    )
+
+
+def test_builtin_and_external_runtime_helicity_contracts_cover_antifermions(
+    builtin_catalog,
+    external_sm_catalog,
+) -> None:
+    builtin_model, builtin_prepared = builtin_catalog
+    _compiled, external_model, external_prepared = external_sm_catalog
+
+    for model, prepared in (
+        (builtin_model, builtin_prepared),
+        (external_model, external_prepared),
+    ):
+        semantic = build_recurrence_template_catalog(
+            model,
+            prepared,
+            compiled_model_digest="a" * 64,
+            prepared_kernel_pack_digest="b" * 64,
+        )
+        states = {state.template_id: state for state in semantic.current_states}
+        contracts = {
+            states[contract.full_state_template_id].particle_id: contract
+            for contract in semantic.runtime_helicity_contracts
+        }
+        for particle_id in (1, -1):
+            contract = contracts[particle_id]
+            assert states[contract.full_state_template_id].chirality == 0
+            variants = {
+                states[variant.source_state_template_id].chirality: variant
+                for variant in contract.variants
+            }
+            assert variants[-1].embedding_source_components == (
+                None,
+                None,
+                0,
+                1,
+            )
+            assert variants[-1].projection_full_components == (2, 3)
+            assert variants[1].embedding_source_components == (
+                0,
+                1,
+                None,
+                None,
+            )
+            assert variants[1].projection_full_components == (0, 1)
+
+
+def test_builtin_and_external_reflection_proofs_cover_selected_transitions(
+    builtin_catalog,
+    external_sm_catalog,
+) -> None:
+    builtin_model, builtin_prepared = builtin_catalog
+    _compiled, external_model, external_prepared = external_sm_catalog
+
+    for model, prepared in (
+        (builtin_model, builtin_prepared),
+        (external_model, external_prepared),
+    ):
+        semantic = build_recurrence_template_catalog(
+            model,
+            prepared,
+            compiled_model_digest="a" * 64,
+            prepared_kernel_pack_digest="b" * 64,
+        )
+        evaluators = {
+            semantic_template_id: evaluator
+            for evaluator in semantic.evaluator_bindings
+            for semantic_template_id in evaluator.semantic_template_ids
+        }
+        colors = {color.template_id: color for color in semantic.color_contractions}
+        expected_subjects = {
+            transition.template_id
+            for transition in semantic.transitions
+            if colors[transition.color_contraction_template_id].input_representations
+            == (8, 8)
+            and colors[transition.color_contraction_template_id].output_representation
+            == 8
+            and {
+                witness.input_permutation
+                for witness in colors[
+                    transition.color_contraction_template_id
+                ].transition_witnesses
+            }
+            == {(0, 1), (1, 0)}
+        }
+        proofs = tuple(
+            proof
+            for proof in semantic.symmetry_proofs
+            if proof.proof_algorithm == "canonical-current-word-reversal-v1"
+        )
+
+        assert expected_subjects
+        assert {proof.subject_template_ids[0] for proof in proofs} == expected_subjects
+        assert all(proof.input_permutation == (1, 0) for proof in proofs)
+        assert {proof.exact_phase for proof in proofs} == {
+            ExactComplexRationalV1.from_binary64(-1.0)
+        }
+        for proof in proofs:
+            evaluator = evaluators[proof.subject_template_ids[0]]
+            assert proof.expression_digests == evaluator.exact_expression_digests
+
+
+def test_external_sm_catalog_signatures_ignore_compiled_inventory_order(
+    external_sm_catalog,
+) -> None:
+    compiled, _model, expected = external_sm_catalog
+    reordered_ir = replace(
+        compiled.ir,
+        oriented_kernels=tuple(reversed(compiled.ir.oriented_kernels)),
+    )
+    reordered = CompiledUFOModel(replace(compiled, ir=reordered_ir))
+    actual = build_prepared_kernel_catalog(reordered)
+
+    assert tuple(kernel.canonical_signature for kernel in actual.kernels) == tuple(
+        kernel.canonical_signature for kernel in expected.kernels
+    )
+    assert actual.resolver_mappings() == expected.resolver_mappings()
+
+
+def test_external_and_builtin_orientation_metadata_share_generic_contracts(
+    builtin_catalog,
+    external_sm_catalog,
+) -> None:
+    _builtin_model, builtin = builtin_catalog
+    _compiled, _external_model, external = external_sm_catalog
+    builtin_states = {
+        (
+            binding.left_state.orientation,
+            binding.left_state.basis,
+            binding.left_state.dimension,
+        )
+        for binding in builtin.vertex_bindings
+    }
+    external_states = {
+        (
+            binding.left_state.orientation,
+            binding.left_state.basis,
+            binding.left_state.dimension,
+        )
+        for binding in external.vertex_bindings
+    }
+
+    assert ("self-conjugate", "lorentz-vector", 4) in (builtin_states & external_states)
+    assert any(
+        state[1:] == ("weyl-chiral", 2) for state in builtin_states & external_states
+    )
+    assert any(
+        binding.left_state.chirality == 0
+        and binding.result_state.chirality == 0
+        and binding.left_state.dimension == 4
+        and binding.result_state.dimension == 4
+        for binding in external.vertex_bindings
+    )
+
+
+def test_catalog_fails_closed_when_a_vertex_kind_has_no_exact_lowering() -> None:
+    class BrokenBuiltin(BuiltinSMModel):
+        def vertex_component_expression(self, kind, *args, **kwargs):
+            if kind == 0:
+                raise ValueError("deliberately unavailable")
+            return super().vertex_component_expression(kind, *args, **kwargs)
+
+    with pytest.raises(
+        PreparedKernelCatalogError,
+        match=r"cannot lower admitted vertex orientation kind=0",
+    ):
+        build_prepared_kernel_catalog(BrokenBuiltin())
+
+
+def test_catalog_fails_closed_when_one_admitted_propagator_is_missing() -> None:
+    class BrokenBuiltin(BuiltinSMModel):
+        def _propagator_ir(self, particle_id, chirality=0):
+            if particle_id == 21:
+                raise ValueError("deliberately unavailable")
+            return super()._propagator_ir(particle_id, chirality)
+
+    with pytest.raises(
+        PreparedKernelCatalogError,
+        match=r"cannot lower admitted propagator particle=21, chirality=0",
+    ):
+        build_prepared_kernel_catalog(BrokenBuiltin())
+
+
+def _rational_scalar_candidate(factor):
+    from pyamplicol.models import compiler_symbolica
+    from pyamplicol.models.base import Vertex, VertexEvaluationEquivalence
+    from pyamplicol.models.prepared_catalog_builder import _vertex_candidate
+    from pyamplicol.models.prepared_catalog_helpers import formal_components
+
+    class RationalScalarModel(BuiltinSMModel):
+        def vertex_evaluation_equivalence(self, kind):
+            return VertexEvaluationEquivalence(
+                "rational-scalar", factor=(factor.real, factor.imag)
+            )
+
+        def vertex_component_expression(self, kind, left, right, **kwargs):
+            return (left[0] * right[0] / 3,)
+
+    compiler_symbolica._ensure_symbolica()
+    model = RationalScalarModel()
+    result = _vertex_candidate(
+        model,
+        Vertex(0, (25, 25, 25), (1.0, 0.0)),
+        left_chirality=0,
+        right_chirality=0,
+        result_chirality=0,
+        parameter_indices={},
+        contract_kind="vertex",
+    )
+    original = (
+        formal_components(model, "left-current", 1)[0]
+        * formal_components(model, "right-current", 1)[0]
+        / 3
+    )
+    return result, original
+
+
+@pytest.mark.parametrize("factor", (1 + 0j, -1 + 0j, 1j, 0.1 + 0j, 0.2j))
+def test_prepared_normalization_preserves_exact_rational_coefficients(factor):
+    from fractions import Fraction
+
+    from symbolica import E
+
+    candidate, original = _rational_scalar_candidate(factor)
+    # Preserve the stored binary64 value, not a nearby simple fraction.
+    exact_factor = E(f"({Fraction(factor.real)})+1i*({Fraction(factor.imag)})")
+    normalized = E(candidate.candidate.exact_expressions[0])
+    assert (normalized * exact_factor - original).expand() == 0
+
+
+@pytest.mark.parametrize("coefficient", (1 + 0j, -1 + 0j, 1j, 0.1 + 0j, 0.2j))
+def test_prepared_closure_preserves_exact_rational_coefficients(coefficient):
+    from fractions import Fraction
+
+    from symbolica import E
+
+    from pyamplicol.models._physics_ir import ContractionIR
+    from pyamplicol.models.prepared_catalog_builder import _closure_candidate
+
+    candidate, original = _rational_scalar_candidate(1 + 0j)
+    closure = _closure_candidate(
+        candidate,
+        ContractionIR(
+            "rational-scalar",
+            "scalar",
+            "scalar",
+            ((coefficient.real, coefficient.imag),),
+        ),
+    )
+    exact_coefficient = E(
+        f"({Fraction(coefficient.real)})+1i*({Fraction(coefficient.imag)})"
+    )
+    projected = E(closure.candidate.exact_expressions[0])
+    assert (projected - exact_coefficient * original).expand() == 0
diff --git a/pyamplicol/tests/unit/test_prepared_model_bundle.py b/pyamplicol/tests/unit/test_prepared_model_bundle.py
new file mode 100644
index 0000000000..d85476dfb3
--- /dev/null
+++ b/pyamplicol/tests/unit/test_prepared_model_bundle.py
@@ -0,0 +1,1187 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import stat
+import zipfile
+from collections.abc import Callable, Mapping
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.models import prepared as prepared_module
+from pyamplicol.models.prepared import (
+    EAGER_KERNEL_ABI,
+    PREPARED_KERNEL_PACK_IDENTITY_ABI,
+    PREPARED_KERNEL_VARIANT_ABI,
+    PREPARED_MODEL_BUNDLE_KIND,
+    PREPARED_MODEL_BUNDLE_SCHEMA_VERSION,
+    PREPARED_MODEL_COMPILED_MODEL_PATH,
+    PREPARED_MODEL_MANIFEST_PATH,
+    PreparedKernelPack,
+    PreparedKernelPackIdentity,
+    PreparedKernelRecord,
+    PreparedKernelVariantRecord,
+    PreparedModelBundleError,
+    load_prepared_model_bundle,
+    prepared_compiled_model_digest,
+    prepared_expression_digest,
+    prepared_input_contract_digest,
+    prepared_kernel_pack_identity,
+    prepared_kernel_pack_manifest_identity_sha256,
+    prepared_optimization_settings_digest,
+    prepared_output_contract_digest,
+    prepared_payload_identity_records,
+    write_prepared_model_bundle,
+)
+from pyamplicol.models.recurrence_direct_template import (
+    build_recurrence_direct_template_catalog,
+    prepared_kernel_payload_digest,
+)
+from pyamplicol.models.recurrence_template import (
+    CurrentStateTemplateV1,
+    EvaluatorBindingV1,
+    ParameterTemplateV1,
+    PropagatorTemplateV1,
+    RecurrenceTemplateCatalog,
+)
+
+
+def _kernel(
+    kernel_id: int = 0,
+    *,
+    signature: str = "vertex:q-qbar-g:v1",
+    contract_kind: str = "vertex",
+) -> PreparedKernelRecord:
+    root = f"kernels/{kernel_id}"
+    return PreparedKernelRecord(
+        kernel_id=kernel_id,
+        contract_kind=contract_kind,  # type: ignore[arg-type]
+        canonical_signature=signature,
+        input_arity=2,
+        output_arity=1,
+        input_layout=("left-current", "right-current"),
+        input_contracts=(
+            {
+                "role": "left-current",
+                "component": 0,
+                "symbol": "pyamplicol::left",
+                "model_parameter_name": None,
+                "model_parameter_index": None,
+            },
+            {
+                "role": "right-current",
+                "component": 0,
+                "symbol": "pyamplicol::right",
+                "model_parameter_name": None,
+                "model_parameter_index": None,
+            },
+        ),
+        output_layout=("current-contribution",),
+        exact_expressions=("pyamplicol::left+pyamplicol::right",),
+        exact_evaluator_state_path=f"{root}/exact.evaluator.bin",
+        f64_evaluator_manifest={
+            "kind": "symjit-application-evaluator",
+            "optimization_level": 2,
+            "settings": {"jit_optimization_level": 2},
+            "input_len": 2,
+            "output_len": 1,
+            "application_path": f"{root}/application.symjit",
+            "evaluator_state_path": f"{root}/exact.evaluator.bin",
+        },
+    )
+
+
+def _pack(
+    *kernels: PreparedKernelRecord,
+    kernel_variants: tuple[PreparedKernelVariantRecord, ...] = (),
+) -> PreparedKernelPack:
+    return PreparedKernelPack(
+        backend="jit",
+        optimization_settings={
+            "jit_optimization_level": 2,
+            "cpe_rounds": "default",
+        },
+        producer={"distribution": "pyamplicol", "version": "0.1.0"},
+        dependency_abis={
+            "symbolica_serialization": "symbolica-community-v1",
+            "symjit_application": "symjit-application-complex-f64-v1",
+            "symjit_plane_application": "pyamplicol-symjit-plane-application-v2",
+        },
+        provenance={
+            "model_content_sha256": "1" * 64,
+            "compiler_revision": "2" * 40,
+        },
+        target={
+            "portable": True,
+            "word_bits": 64,
+            "endianness": "little",
+            "target_triple": "symjit-storage-v3-portable",
+            "cpu_features": [],
+        },
+        resolver_manifest={
+            "abi": "pyamplicol-prepared-kernel-catalog-v1",
+            "model_name": "test-model",
+        },
+        kernels=kernels or (_kernel(),),
+        kernel_variants=kernel_variants,
+    )
+
+
+def _block_variant(kernel: PreparedKernelRecord) -> PreparedKernelVariantRecord:
+    settings = {"jit_optimization_level": 2, "cpe_rounds": "default"}
+    root = f"kernels/{kernel.kernel_id}/variants/independent-block-4"
+    return PreparedKernelVariantRecord(
+        variant_id="independent-block-4",
+        variant_abi=PREPARED_KERNEL_VARIANT_ABI,
+        kind="independent-block",
+        block_size=4,
+        lane_layout="lane-major",
+        base_kernel_id=kernel.kernel_id,
+        base_canonical_signature=kernel.canonical_signature,
+        base_expression_digest=prepared_expression_digest(kernel.exact_expressions),
+        base_input_contract_digest=prepared_input_contract_digest(
+            kernel.input_layout,
+            kernel.input_contracts,
+        ),
+        base_output_contract_digest=prepared_output_contract_digest(
+            kernel.output_layout
+        ),
+        backend="jit",
+        optimization_settings_digest=prepared_optimization_settings_digest(settings),
+        input_arity=4 * kernel.input_arity,
+        output_arity=4 * kernel.output_arity,
+        input_lane_stride=kernel.input_arity,
+        output_lane_stride=kernel.output_arity,
+        input_layout=tuple(
+            f"lane:{lane}:{item}" for lane in range(4) for item in kernel.input_layout
+        ),
+        output_layout=tuple(
+            f"lane:{lane}:{item}" for lane in range(4) for item in kernel.output_layout
+        ),
+        f64_evaluator_manifest={
+            "kind": "symjit-application-evaluator",
+            "optimization_level": 2,
+            "settings": {"jit_optimization_level": 2},
+            "input_len": 4 * kernel.input_arity,
+            "output_len": 4 * kernel.output_arity,
+            "application_path": f"{root}/application.symjit",
+            "evaluator_state_path": f"{root}/evaluator-state.evaluator.bin",
+        },
+    )
+
+
+def _compiled_model() -> dict[str, object]:
+    return {
+        "kind": "pyamplicol-compiled-model",
+        "schema_version": 9,
+        "model_compiler_version": 13,
+        "model": {"name": "test-model"},
+    }
+
+
+def _payloads(*kernels: PreparedKernelRecord) -> dict[str, bytes]:
+    result: dict[str, bytes] = {}
+    for kernel in kernels or (_kernel(),):
+        result[kernel.exact_evaluator_state_path] = f"exact:{kernel.kernel_id}".encode()
+        application_path = str(kernel.f64_evaluator_manifest["application_path"])
+        result[application_path] = f"jit:{kernel.kernel_id}".encode()
+    return result
+
+
+def _recurrence_catalog(
+    pack: PreparedKernelPack,
+    payloads: Mapping[str, bytes],
+    *,
+    compiled_model_digest: str | None = None,
+) -> RecurrenceTemplateCatalog:
+    identity = prepared_kernel_pack_identity(
+        pack,
+        prepared_payload_identity_records(payloads),
+    )
+    return RecurrenceTemplateCatalog.create(
+        compiled_model_digest=(
+            prepared_compiled_model_digest(_compiled_model())
+            if compiled_model_digest is None
+            else compiled_model_digest
+        ),
+        prepared_kernel_pack_digest=identity.pack_digest,
+    )
+
+
+def _pack_with_direct_recurrence() -> tuple[
+    PreparedKernelPack,
+    dict[str, bytes],
+    str,
+]:
+    kernel = _kernel()
+    base_pack = _pack(kernel)
+    payloads = _payloads(kernel)
+    payload_records = prepared_payload_identity_records(payloads)
+    identity = prepared_kernel_pack_identity(base_pack, payload_records)
+    state = CurrentStateTemplateV1(
+        template_id="state:test-scalar",
+        particle_id=9000001,
+        anti_particle_id=9000001,
+        species_id="test-scalar",
+        orientation="self-conjugate",
+        statistics="boson",
+        color_representation=1,
+        basis="scalar",
+        tensor_ordering=("scalar",),
+        dimension=1,
+        chirality=0,
+        lc_color_shape_kind="singlet-forest",
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+    identity_propagator = PropagatorTemplateV1(
+        template_id="propagator:test-identity",
+        state_template_id=state.template_id,
+        applies_propagator=False,
+        evaluator_resolver_key=None,
+        numerator_expression_digest=None,
+        denominator_expression_digest=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+        gauge=None,
+        linearity_proof_template_id=None,
+    )
+    semantic_catalog = RecurrenceTemplateCatalog.create(
+        compiled_model_digest=prepared_compiled_model_digest(_compiled_model()),
+        prepared_kernel_pack_digest=identity.pack_digest,
+        current_states=(state,),
+        propagators=(identity_propagator,),
+    )
+    optimization_digest = prepared_optimization_settings_digest(
+        base_pack.optimization_settings
+    )
+    direct_catalog = build_recurrence_direct_template_catalog(
+        semantic_catalog,
+        backend="jit",
+        target_triple=str(base_pack.target["target_triple"]),
+        portable=True,
+        optimization_level=2,
+        prepared_kernel_pack_digest=identity.pack_digest,
+        prepared_kernel_contract_digest=identity.contract_digest,
+        prepared_kernel_payload_digest=identity.payload_digest,
+        optimization_settings_digest=optimization_digest,
+        prepared_kernel_payload_digests={
+            kernel.kernel_id: prepared_kernel_payload_digest(
+                kernel_id=kernel.kernel_id,
+                payload_records=payload_records,
+                referenced_paths=kernel.referenced_payload_paths,
+            )
+        },
+    )
+    pack = replace(
+        base_pack,
+        provenance={
+            **dict(base_pack.provenance),
+            "direct_template_catalog_digest": direct_catalog.catalog_digest,
+            "prepared_kernel_contract_digest": identity.contract_digest,
+            "prepared_kernel_payload_digest": identity.payload_digest,
+            "prepared_kernel_pack_digest": identity.pack_digest,
+            "recurrence_direct_template_abi": direct_catalog.abi,
+            "recurrence_direct_template_digest": direct_catalog.catalog_digest,
+        },
+        recurrence_template=semantic_catalog.to_dict(),
+        recurrence_direct_template=direct_catalog.to_dict(),
+    )
+    return pack, payloads, direct_catalog.catalog_digest
+
+
+def _pack_with_bound_recurrence_kernel(
+    *,
+    prepared_kernel_id: int = 0,
+    callable_signature: str | None = None,
+    input_layout: tuple[str, ...] | None = None,
+    output_layout: tuple[str, ...] | None = None,
+    exact_expression_digests: tuple[str, ...] | None = None,
+) -> PreparedKernelPack:
+    signature = "a" * 64
+    kernel = _kernel(signature=signature, contract_kind="model-parameter")
+    pack = _pack(kernel)
+    payloads = _payloads(kernel)
+    expression_digest = hashlib.sha256(
+        kernel.exact_expressions[0].encode("utf-8")
+    ).hexdigest()
+    parameter = ParameterTemplateV1(
+        template_id="parameter:derived",
+        name="derived",
+        parameter_kind="derived",
+        value_type="real",
+        mutable=False,
+        default_value=None,
+        exact_expression_digest=expression_digest,
+        dependency_parameter_ids=(),
+        prepared_parameter_id=0,
+    )
+    canonical_inputs = tuple(
+        json.dumps(
+            dict(contract),
+            ensure_ascii=True,
+            allow_nan=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        for contract in kernel.input_contracts
+    )
+    binding = EvaluatorBindingV1(
+        resolver_key="evaluator:model-parameter:derived",
+        prepared_kernel_id=prepared_kernel_id,
+        contract_kind="model-parameter",
+        callable_signature=(
+            signature if callable_signature is None else callable_signature
+        ),
+        input_state_template_ids=(),
+        output_state_template_id=None,
+        input_layout=canonical_inputs if input_layout is None else input_layout,
+        output_layout=kernel.output_layout if output_layout is None else output_layout,
+        exact_expression_digests=(
+            (expression_digest,)
+            if exact_expression_digests is None
+            else exact_expression_digests
+        ),
+        semantic_template_ids=(parameter.template_id,),
+    )
+    identity = prepared_kernel_pack_identity(
+        pack,
+        prepared_payload_identity_records(payloads),
+    )
+    catalog = RecurrenceTemplateCatalog.create(
+        compiled_model_digest=prepared_compiled_model_digest(_compiled_model()),
+        prepared_kernel_pack_digest=identity.pack_digest,
+        parameters=(parameter,),
+        evaluator_bindings=(binding,),
+    )
+    return replace(pack, recurrence_template=catalog.to_dict())
+
+
+def _variant_payloads(
+    *variants: PreparedKernelVariantRecord,
+) -> dict[str, bytes]:
+    result: dict[str, bytes] = {}
+    for variant in variants:
+        for path in variant.referenced_payload_paths:
+            result[path] = f"variant:{variant.base_kernel_id}:{path}".encode()
+    return result
+
+
+def _valid_bundle(tmp_path: Path) -> Path:
+    kernel = _kernel()
+    return write_prepared_model_bundle(
+        tmp_path / "prepared",
+        compiled_model=_compiled_model(),
+        kernel_pack=_pack(kernel),
+        payloads=_payloads(kernel),
+    )
+
+
+def _entries(path: Path) -> list[tuple[zipfile.ZipInfo, bytes]]:
+    with zipfile.ZipFile(path, "r") as archive:
+        return [(info, archive.read(info)) for info in archive.infolist()]
+
+
+def _rewrite(
+    path: Path,
+    entries: list[tuple[zipfile.ZipInfo, bytes]],
+) -> None:
+    with zipfile.ZipFile(path, "w", allowZip64=True) as archive:
+        for original, data in entries:
+            info = zipfile.ZipInfo(original.filename, date_time=(1980, 1, 1, 0, 0, 0))
+            info.compress_type = zipfile.ZIP_STORED
+            info.create_system = 3
+            info.external_attr = original.external_attr
+            archive.writestr(info, data)
+
+
+def _mutate_manifest(
+    path: Path,
+    mutate: Callable[[dict[str, object]], None],
+) -> None:
+    entries = _entries(path)
+    updated: list[tuple[zipfile.ZipInfo, bytes]] = []
+    for info, data in entries:
+        if info.filename == PREPARED_MODEL_MANIFEST_PATH:
+            manifest = json.loads(data)
+            assert isinstance(manifest, dict)
+            mutate(manifest)
+            data = (
+                json.dumps(manifest, sort_keys=True, separators=(",", ":")) + "\n"
+            ).encode("ascii")
+        updated.append((info, data))
+    _rewrite(path, updated)
+
+
+def test_prepared_model_bundle_round_trip_and_payload_copy(tmp_path: Path) -> None:
+    path = _valid_bundle(tmp_path)
+
+    assert path == (tmp_path / "prepared.pyamplicol-model").resolve()
+    bundle = load_prepared_model_bundle(path)
+
+    assert bundle.backend == "jit"
+    assert bundle.compiled_model == _compiled_model()
+    assert bundle.kernel_pack.kernels[0].canonical_signature == "vertex:q-qbar-g:v1"
+    assert bundle.read_payload("kernels/0/application.symjit") == b"jit:0"
+    with pytest.raises(TypeError):
+        bundle.compiled_model["kind"] = "changed"  # type: ignore[index]
+
+    extracted = bundle.copy_referenced_payloads(tmp_path / "extracted")
+    extracted_paths = tuple(
+        path.relative_to(tmp_path / "extracted").as_posix() for path in extracted
+    )
+    assert extracted_paths == (
+        "kernels/0/application.symjit",
+        "kernels/0/exact.evaluator.bin",
+    )
+    assert extracted[0].read_bytes() == b"jit:0"
+    assert extracted[1].read_bytes() == b"exact:0"
+    assert not (tmp_path / "extracted" / "model").exists()
+
+    with zipfile.ZipFile(path, "r") as archive:
+        assert archive.namelist() == [
+            PREPARED_MODEL_MANIFEST_PATH,
+            "kernels/0/application.symjit",
+            "kernels/0/exact.evaluator.bin",
+            PREPARED_MODEL_COMPILED_MODEL_PATH,
+        ]
+        manifest = json.loads(archive.read(PREPARED_MODEL_MANIFEST_PATH))
+    assert manifest["kind"] == PREPARED_MODEL_BUNDLE_KIND
+    assert manifest["schema_version"] == PREPARED_MODEL_BUNDLE_SCHEMA_VERSION
+    assert manifest["eager_kernel_abi"] == EAGER_KERNEL_ABI
+    assert manifest["kernel_pack"]["backend"] == "jit"
+    assert "recurrence_template" not in manifest["kernel_pack"]
+    assert {record["path"] for record in manifest["members"]} == {
+        PREPARED_MODEL_COMPILED_MODEL_PATH,
+        "kernels/0/application.symjit",
+        "kernels/0/exact.evaluator.bin",
+    }
+
+
+def test_prepared_jit_pack_requires_plane_application_dependency_abi() -> None:
+    pack = _pack(_kernel())
+    stale_dependencies = dict(pack.dependency_abis)
+    stale_dependencies.pop("symjit_plane_application")
+
+    with pytest.raises(
+        PreparedModelBundleError,
+        match="authenticate SymJIT plane-application ABI",
+    ):
+        replace(pack, dependency_abis=stale_dependencies)
+
+    predecessor_dependencies = dict(pack.dependency_abis)
+    predecessor_dependencies["symjit_plane_application"] = (
+        "pyamplicol-symjit-plane-application-" + "v1"
+    )
+
+    with pytest.raises(PreparedModelBundleError, match="regenerate"):
+        replace(pack, dependency_abis=predecessor_dependencies)
+
+
+def test_prepared_model_bundle_round_trips_optional_recurrence_template(
+    tmp_path: Path,
+) -> None:
+    kernel = _kernel()
+    base_pack = _pack(kernel)
+    payloads = _payloads(kernel)
+    catalog = _recurrence_catalog(base_pack, payloads)
+    pack = replace(base_pack, recurrence_template=catalog.to_dict())
+
+    path = write_prepared_model_bundle(
+        tmp_path / "recurrence-ready",
+        compiled_model=_compiled_model(),
+        kernel_pack=pack,
+        payloads=payloads,
+    )
+    loaded = load_prepared_model_bundle(path)
+
+    assert loaded.kernel_pack.recurrence_template is not None
+    decoded = loaded.kernel_pack.recurrence_template_catalog
+    assert decoded is not None
+    assert decoded.catalog_digest == catalog.catalog_digest
+    with zipfile.ZipFile(path, "r") as archive:
+        manifest = json.loads(archive.read(PREPARED_MODEL_MANIFEST_PATH))
+    assert (
+        manifest["kernel_pack"]["recurrence_template"]["header"]["catalog_digest"]
+        == catalog.catalog_digest
+    )
+
+
+def test_direct_template_catalog_round_trip_is_independently_authenticated(
+    tmp_path: Path,
+) -> None:
+    pack, payloads, expected_digest = _pack_with_direct_recurrence()
+    path = write_prepared_model_bundle(
+        tmp_path / "direct",
+        compiled_model=_compiled_model(),
+        kernel_pack=pack,
+        payloads=payloads,
+    )
+
+    bundle = load_prepared_model_bundle(path)
+    catalog = bundle.kernel_pack.recurrence_direct_template_catalog
+
+    assert catalog is not None
+    assert catalog is bundle.kernel_pack.recurrence_direct_template_catalog
+    assert catalog.catalog_digest == expected_digest
+    assert bundle.direct_template_catalog_digest == expected_digest
+    assert bundle.manifest["direct_template_catalog_digest"] == expected_digest
+    assert len(expected_digest) == 64
+    assert expected_digest == expected_digest.lower()
+    assert set(expected_digest) <= set("0123456789abcdef")
+    assert catalog.direct_executor_id_for("finalization", 0) == 0
+    assert (
+        catalog.templates[0].payload_binding.runtime_template
+        == "rusticol.identity-finalize-in-place.v1"
+    )
+
+
+@pytest.mark.parametrize(
+    ("mutate", "message"),
+    (
+        (
+            lambda manifest: manifest.__setitem__(
+                "direct_template_catalog_digest",
+                str(manifest["direct_template_catalog_digest"]).upper(),
+            ),
+            "lowercase SHA-256",
+        ),
+        (
+            lambda manifest: manifest.__setitem__(
+                "direct_template_catalog_digest",
+                "0" * 64,
+            ),
+            "does not match",
+        ),
+        (
+            lambda manifest: manifest.pop("direct_template_catalog_digest"),
+            "does not match",
+        ),
+    ),
+)
+def test_direct_template_catalog_manifest_rejects_malformed_identity(
+    tmp_path: Path,
+    mutate: Callable[[dict[str, object]], object],
+    message: str,
+) -> None:
+    pack, payloads, _digest = _pack_with_direct_recurrence()
+    path = write_prepared_model_bundle(
+        tmp_path / "direct-malformed",
+        compiled_model=_compiled_model(),
+        kernel_pack=pack,
+        payloads=payloads,
+    )
+    _mutate_manifest(path, mutate)
+
+    with pytest.raises(PreparedModelBundleError, match=message):
+        load_prepared_model_bundle(path)
+
+
+def test_bundle_without_direct_companion_rejects_spurious_digest(
+    tmp_path: Path,
+) -> None:
+    path = _valid_bundle(tmp_path)
+    _mutate_manifest(
+        path,
+        lambda manifest: manifest.__setitem__(
+            "direct_template_catalog_digest",
+            None,
+        ),
+    )
+
+    with pytest.raises(
+        PreparedModelBundleError,
+        match="advertises a direct template catalog that is absent",
+    ):
+        load_prepared_model_bundle(path)
+
+
+def test_prepared_kernel_pack_rejects_stale_recurrence_template() -> None:
+    kernel = _kernel()
+    base_pack = _pack(kernel)
+    catalog = _recurrence_catalog(base_pack, _payloads(kernel))
+    payload = catalog.to_dict()
+    payload["header"]["catalog_digest"] = "b" * 64
+
+    with pytest.raises(PreparedModelBundleError, match="stale recurrence"):
+        replace(base_pack, recurrence_template=payload)
+
+
+def test_prepared_kernel_pack_authenticates_recurrence_callable_contract() -> None:
+    pack = _pack_with_bound_recurrence_kernel()
+
+    catalog = pack.recurrence_template_catalog
+    assert catalog is not None
+    assert catalog.evaluator_bindings[0].prepared_kernel_id == 0
+
+
+@pytest.mark.parametrize(
+    ("overrides", "message"),
+    (
+        ({"prepared_kernel_id": 7}, "unknown prepared kernel ID 7"),
+        ({"callable_signature": "b" * 64}, "callable signature"),
+        ({"input_layout": ("stale", "layout")}, "input layout"),
+        ({"output_layout": ("stale",)}, "output layout"),
+        ({"exact_expression_digests": ("c" * 64,)}, "exact expression digests"),
+    ),
+)
+def test_prepared_kernel_pack_rejects_stale_recurrence_callable_contract(
+    overrides: dict[str, object],
+    message: str,
+) -> None:
+    with pytest.raises(PreparedModelBundleError, match=message):
+        _pack_with_bound_recurrence_kernel(**overrides)  # type: ignore[arg-type]
+
+
+def test_prepared_bundle_rejects_recurrence_template_for_another_model(
+    tmp_path: Path,
+) -> None:
+    kernel = _kernel()
+    base_pack = _pack(kernel)
+    payloads = _payloads(kernel)
+    catalog = _recurrence_catalog(
+        base_pack,
+        payloads,
+        compiled_model_digest="f" * 64,
+    )
+    pack = replace(base_pack, recurrence_template=catalog.to_dict())
+
+    with pytest.raises(PreparedModelBundleError, match="compiled-model digest"):
+        write_prepared_model_bundle(
+            tmp_path / "wrong-model",
+            compiled_model=_compiled_model(),
+            kernel_pack=pack,
+            payloads=payloads,
+        )
+
+
+def test_prepared_bundle_rejects_recurrence_template_for_changed_payloads(
+    tmp_path: Path,
+) -> None:
+    kernel = _kernel()
+    base_pack = _pack(kernel)
+    payloads = _payloads(kernel)
+    catalog = _recurrence_catalog(base_pack, payloads)
+    pack = replace(base_pack, recurrence_template=catalog.to_dict())
+    changed_payloads = dict(payloads)
+    changed_payloads["kernels/0/application.symjit"] = b"changed application"
+
+    with pytest.raises(PreparedModelBundleError, match="prepared-pack digest"):
+        write_prepared_model_bundle(
+            tmp_path / "changed-payload",
+            compiled_model=_compiled_model(),
+            kernel_pack=pack,
+            payloads=changed_payloads,
+        )
+
+
+def test_reader_rejects_rehashed_payload_outside_recurrence_identity(
+    tmp_path: Path,
+) -> None:
+    kernel = _kernel()
+    base_pack = _pack(kernel)
+    payloads = _payloads(kernel)
+    catalog = _recurrence_catalog(base_pack, payloads)
+    pack = replace(base_pack, recurrence_template=catalog.to_dict())
+    path = write_prepared_model_bundle(
+        tmp_path / "rehashed-payload",
+        compiled_model=_compiled_model(),
+        kernel_pack=pack,
+        payloads=payloads,
+    )
+
+    payload_path = "kernels/0/application.symjit"
+    changed_payload = b"changed and rehashed application"
+    entries = _entries(path)
+    updated: list[tuple[zipfile.ZipInfo, bytes]] = []
+    for info, data in entries:
+        if info.filename == payload_path:
+            data = changed_payload
+        elif info.filename == PREPARED_MODEL_MANIFEST_PATH:
+            manifest = json.loads(data)
+            assert isinstance(manifest, dict)
+            members = manifest["members"]
+            assert isinstance(members, list)
+            record = next(item for item in members if item["path"] == payload_path)
+            record["size"] = len(changed_payload)
+            record["sha256"] = hashlib.sha256(changed_payload).hexdigest()
+            data = (
+                json.dumps(manifest, sort_keys=True, separators=(",", ":")) + "\n"
+            ).encode("ascii")
+        updated.append((info, data))
+    _rewrite(path, updated)
+
+    with pytest.raises(PreparedModelBundleError, match="prepared-pack digest"):
+        load_prepared_model_bundle(path)
+
+
+def test_prepared_block_variant_round_trip_and_payload_index(tmp_path: Path) -> None:
+    kernel = _kernel(signature="a" * 64)
+    variant = _block_variant(kernel)
+    pack = _pack(kernel, kernel_variants=(variant,))
+    path = write_prepared_model_bundle(
+        tmp_path / "block",
+        compiled_model=_compiled_model(),
+        kernel_pack=pack,
+        payloads={**_payloads(kernel), **_variant_payloads(variant)},
+    )
+
+    loaded = load_prepared_model_bundle(path)
+
+    assert loaded.kernel_pack.kernel_variants == (variant,)
+    assert variant.input_lane_stride == kernel.input_arity
+    assert variant.output_lane_stride == kernel.output_arity
+    assert set(variant.referenced_payload_paths).issubset(
+        loaded.kernel_pack.referenced_payload_paths
+    )
+    assert loaded.read_payload(
+        "kernels/0/variants/independent-block-4/application.symjit"
+    ).startswith(b"variant:0:")
+
+
+def test_reader_rejects_private_fork_prepared_variant_with_regeneration_message(
+    tmp_path: Path,
+) -> None:
+    kernel = _kernel(signature="a" * 64)
+    variant = _block_variant(kernel)
+    path = write_prepared_model_bundle(
+        tmp_path / "old-variant",
+        compiled_model=_compiled_model(),
+        kernel_pack=_pack(kernel, kernel_variants=(variant,)),
+        payloads={**_payloads(kernel), **_variant_payloads(variant)},
+    )
+
+    def restore_old_variant_abi(manifest: dict[str, object]) -> None:
+        pack = manifest["kernel_pack"]
+        assert isinstance(pack, dict)
+        variants = pack["kernel_variants"]
+        assert isinstance(variants, list)
+        variant_manifest = variants[0]
+        assert isinstance(variant_manifest, dict)
+        variant_manifest["variant_abi"] = "pyamplicol-prepared-kernel-" + "variant-v1"
+
+    _mutate_manifest(path, restore_old_variant_abi)
+
+    with pytest.raises(PreparedModelBundleError, match="regenerate"):
+        load_prepared_model_bundle(path)
+
+
+def test_prepared_pack_identity_rejects_predecessor_abi() -> None:
+    with pytest.raises(PreparedModelBundleError, match="regenerate"):
+        PreparedKernelPackIdentity(
+            contract_digest="a" * 64,
+            payload_digest="b" * 64,
+            pack_digest="c" * 64,
+            abi="pyamplicol-prepared-kernel-pack-" + "identity-v1",
+        )
+
+
+def test_prepared_bundle_manifest_identity_uses_the_published_abi_domain() -> None:
+    manifest = {
+        "kind": "pyamplicol-prepared-model",
+        "schema_version": 1,
+        "kernel_pack": {"backend": "jit", "kernels": []},
+    }
+    canonical = json.dumps(
+        manifest,
+        ensure_ascii=True,
+        allow_nan=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    expected = hashlib.sha256(
+        PREPARED_KERNEL_PACK_IDENTITY_ABI.encode("ascii")
+        + b"\x00"
+        + canonical
+    ).hexdigest()
+
+    assert prepared_kernel_pack_manifest_identity_sha256(manifest) == expected
+
+
+def test_reader_rejects_pack_without_kernel_variants(tmp_path: Path) -> None:
+    path = _valid_bundle(tmp_path)
+
+    def remove_variants(manifest: dict[str, object]) -> None:
+        pack = manifest["kernel_pack"]
+        assert isinstance(pack, dict)
+        del pack["kernel_variants"]
+
+    _mutate_manifest(path, remove_variants)
+
+    with pytest.raises(PreparedModelBundleError, match="missing fields"):
+        load_prepared_model_bundle(path)
+
+
+def test_reader_rejects_kernel_without_proof_classes(tmp_path: Path) -> None:
+    path = _valid_bundle(tmp_path)
+
+    def remove_proof_classes(manifest: dict[str, object]) -> None:
+        pack = manifest["kernel_pack"]
+        assert isinstance(pack, dict)
+        kernels = pack["kernels"]
+        assert isinstance(kernels, list)
+        kernel = kernels[0]
+        assert isinstance(kernel, dict)
+        del kernel["proof_classes"]
+
+    _mutate_manifest(path, remove_proof_classes)
+
+    with pytest.raises(PreparedModelBundleError, match="missing fields"):
+        load_prepared_model_bundle(path)
+
+
+@pytest.mark.parametrize(
+    ("field", "replacement_value", "pattern"),
+    (
+        ("base_kernel_id", 7, "unknown base kernel"),
+        ("base_expression_digest", "0" * 64, "contract digest"),
+        ("base_input_contract_digest", "0" * 64, "contract digest"),
+        ("base_output_contract_digest", "0" * 64, "contract digest"),
+        ("backend", "cpp", "backend does not match"),
+        ("optimization_settings_digest", "0" * 64, "optimization digest"),
+        ("input_layout", tuple(f"wrong:{index}" for index in range(8)), "layout"),
+    ),
+)
+def test_pack_rejects_mismatched_block_variant_binding(
+    field: str,
+    replacement_value: object,
+    pattern: str,
+) -> None:
+    kernel = _kernel(signature="a" * 64)
+    variant = replace(_block_variant(kernel), **{field: replacement_value})
+
+    with pytest.raises(PreparedModelBundleError, match=pattern):
+        _pack(kernel, kernel_variants=(variant,))
+
+
+def test_block_variant_rejects_evaluator_arity_mismatch() -> None:
+    kernel = _kernel(signature="a" * 64)
+    variant = _block_variant(kernel)
+    manifest = dict(variant.f64_evaluator_manifest)
+    manifest["output_len"] = 3
+
+    with pytest.raises(PreparedModelBundleError, match="output_len"):
+        replace(variant, f64_evaluator_manifest=manifest)
+
+
+def test_payload_reference_index_is_reused_after_bundle_load(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = _valid_bundle(tmp_path)
+    bundle = load_prepared_model_bundle(path)
+    expected = (
+        "kernels/0/application.symjit",
+        "kernels/0/exact.evaluator.bin",
+    )
+
+    def fail_manifest_traversal(*_args: object, **_kwargs: object) -> tuple[str, ...]:
+        raise AssertionError("manifest payload paths were recomputed")
+
+    monkeypatch.setattr(
+        prepared_module,
+        "_collect_manifest_paths",
+        fail_manifest_traversal,
+    )
+    assert bundle.kernel_pack.kernels[0].referenced_payload_paths == expected
+    assert bundle.kernel_pack.kernels[0].referenced_payload_paths == expected
+
+    def fail_kernel_scan(_kernel: PreparedKernelRecord) -> tuple[str, ...]:
+        raise AssertionError("kernel payload paths were rescanned")
+
+    monkeypatch.setattr(
+        PreparedKernelRecord,
+        "referenced_payload_paths",
+        property(fail_kernel_scan),
+    )
+    assert bundle.kernel_pack.referenced_payload_paths == expected
+    assert bundle.kernel_pack.referenced_payload_paths == expected
+    assert bundle.read_payload("kernels/0/application.symjit") == b"jit:0"
+    assert bundle.read_payload("kernels/0/application.symjit") == b"jit:0"
+
+
+def test_cached_payload_index_keeps_path_and_checksum_validation(
+    tmp_path: Path,
+) -> None:
+    path = _valid_bundle(tmp_path)
+    bundle = load_prepared_model_bundle(path)
+
+    with pytest.raises(PreparedModelBundleError, match="normalized relative POSIX"):
+        bundle.read_payload("../kernels/0/application.symjit")
+
+    entries = [
+        (info, b"bad!!" if info.filename.endswith("application.symjit") else data)
+        for info, data in _entries(path)
+    ]
+    _rewrite(path, entries)
+
+    with pytest.raises(PreparedModelBundleError, match="SHA-256 mismatch"):
+        bundle.read_payload("kernels/0/application.symjit")
+
+
+def test_prepared_model_bundle_bytes_are_deterministic(tmp_path: Path) -> None:
+    first_kernel = _kernel(5, signature="closure:q-qbar:v1")
+    second_kernel = _kernel(2, signature="vertex:g-g-g:v1")
+    pack = _pack(first_kernel, second_kernel)
+    payloads = _payloads(first_kernel, second_kernel)
+
+    first = write_prepared_model_bundle(
+        tmp_path / "first.pyamplicol-model",
+        compiled_model=_compiled_model(),
+        kernel_pack=pack,
+        payloads=payloads,
+    )
+    second = write_prepared_model_bundle(
+        tmp_path / "second.pyamplicol-model",
+        compiled_model=dict(reversed(tuple(_compiled_model().items()))),
+        kernel_pack=pack,
+        payloads=dict(reversed(tuple(payloads.items()))),
+    )
+
+    assert first.read_bytes() == second.read_bytes()
+    assert tuple(kernel.kernel_id for kernel in pack.kernels) == (2, 5)
+
+
+@pytest.mark.parametrize(
+    ("payload_path", "pattern"),
+    (
+        ("../escape.bin", "normalized relative POSIX"),
+        ("/absolute.bin", "normalized relative POSIX"),
+        ("nested\\windows.bin", "normalized relative POSIX"),
+    ),
+)
+def test_writer_rejects_unsafe_payload_references(
+    payload_path: str,
+    pattern: str,
+) -> None:
+    with pytest.raises(PreparedModelBundleError, match=pattern):
+        PreparedKernelRecord(
+            kernel_id=0,
+            contract_kind="closure",
+            canonical_signature="closure:test",
+            input_arity=1,
+            output_arity=1,
+            input_layout=("input",),
+            input_contracts=(
+                {
+                    "role": "current",
+                    "component": 0,
+                    "symbol": "pyamplicol::input",
+                    "model_parameter_name": None,
+                    "model_parameter_index": None,
+                },
+            ),
+            output_layout=("output",),
+            exact_expressions=("pyamplicol::input",),
+            exact_evaluator_state_path=payload_path,
+            f64_evaluator_manifest={
+                "kind": "test",
+                "application_path": "kernels/application.bin",
+            },
+        )
+
+
+def test_writer_requires_exact_referenced_payload_set(tmp_path: Path) -> None:
+    kernel = _kernel()
+    payloads = _payloads(kernel)
+    del payloads["kernels/0/application.symjit"]
+    payloads["kernels/0/unreferenced.bin"] = b"extra"
+
+    with pytest.raises(
+        PreparedModelBundleError,
+        match=r"missing: kernels/0/application\.symjit.*unreferenced",
+    ):
+        write_prepared_model_bundle(
+            tmp_path / "invalid",
+            compiled_model=_compiled_model(),
+            kernel_pack=_pack(kernel),
+            payloads=payloads,
+        )
+
+
+def test_writer_rejects_symlink_payload(tmp_path: Path) -> None:
+    source = tmp_path / "source.bin"
+    source.write_bytes(b"payload")
+    link = tmp_path / "payload-link.bin"
+    link.symlink_to(source)
+    kernel = _kernel()
+    payloads: dict[str, bytes | Path] = _payloads(kernel)
+    payloads[kernel.exact_evaluator_state_path] = link
+
+    with pytest.raises(PreparedModelBundleError, match="must not be a symlink"):
+        write_prepared_model_bundle(
+            tmp_path / "invalid",
+            compiled_model=_compiled_model(),
+            kernel_pack=_pack(kernel),
+            payloads=payloads,
+        )
+
+
+def test_reader_rejects_traversal_archive_member(tmp_path: Path) -> None:
+    path = _valid_bundle(tmp_path)
+    entries = _entries(path)
+    info = zipfile.ZipInfo("../escape.bin")
+    info.create_system = 3
+    info.external_attr = (stat.S_IFREG | 0o644) << 16
+    entries.append((info, b"escape"))
+    _rewrite(path, entries)
+
+    with pytest.raises(PreparedModelBundleError, match="normalized relative POSIX"):
+        load_prepared_model_bundle(path)
+
+
+def test_reader_rejects_duplicate_archive_member(tmp_path: Path) -> None:
+    path = _valid_bundle(tmp_path)
+    entries = _entries(path)
+    duplicate = next(
+        entry
+        for entry in entries
+        if entry[0].filename == "kernels/0/application.symjit"
+    )
+    entries.append(duplicate)
+    with pytest.warns(UserWarning, match="Duplicate name"):
+        _rewrite(path, entries)
+
+    with pytest.raises(PreparedModelBundleError, match="duplicate member"):
+        load_prepared_model_bundle(path)
+
+
+def test_reader_rejects_symlink_archive_member(tmp_path: Path) -> None:
+    path = _valid_bundle(tmp_path)
+    entries = _entries(path)
+    updated: list[tuple[zipfile.ZipInfo, bytes]] = []
+    for info, data in entries:
+        if info.filename == "kernels/0/application.symjit":
+            info.external_attr = (stat.S_IFLNK | 0o777) << 16
+        updated.append((info, data))
+    _rewrite(path, updated)
+
+    with pytest.raises(PreparedModelBundleError, match="regular file"):
+        load_prepared_model_bundle(path)
+
+
+def test_reader_rejects_missing_manifest_member(tmp_path: Path) -> None:
+    path = _valid_bundle(tmp_path)
+    entries = [
+        entry
+        for entry in _entries(path)
+        if entry[0].filename != "kernels/0/application.symjit"
+    ]
+    _rewrite(path, entries)
+
+    with pytest.raises(
+        PreparedModelBundleError,
+        match=r"members do not match.*missing",
+    ):
+        load_prepared_model_bundle(path)
+
+
+def test_reader_rejects_payload_hash_mismatch(tmp_path: Path) -> None:
+    path = _valid_bundle(tmp_path)
+    entries = [
+        (info, b"other" if info.filename.endswith("application.symjit") else data)
+        for info, data in _entries(path)
+    ]
+    _rewrite(path, entries)
+
+    with pytest.raises(PreparedModelBundleError, match="SHA-256 mismatch"):
+        load_prepared_model_bundle(path)
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "pattern"),
+    (
+        ("kind", "not-pyamplicol", "bundle kind"),
+        ("schema_version", 99, "bundle schema"),
+        ("eager_kernel_abi", "eager-v99", "kernel ABI"),
+    ),
+)
+def test_reader_rejects_bad_bundle_contract(
+    tmp_path: Path,
+    field: str,
+    value: object,
+    pattern: str,
+) -> None:
+    path = _valid_bundle(tmp_path)
+    _mutate_manifest(path, lambda manifest: manifest.__setitem__(field, value))
+
+    with pytest.raises(PreparedModelBundleError, match=pattern):
+        load_prepared_model_bundle(path)
+
+
+def test_reader_rejects_bad_backend(tmp_path: Path) -> None:
+    path = _valid_bundle(tmp_path)
+
+    def mutate(manifest: dict[str, object]) -> None:
+        pack = manifest["kernel_pack"]
+        assert isinstance(pack, dict)
+        pack["backend"] = "cuda"
+
+    _mutate_manifest(path, mutate)
+    with pytest.raises(PreparedModelBundleError, match="unsupported prepared backend"):
+        load_prepared_model_bundle(path)
+
+
+def test_exactly_one_pack_and_unique_kernel_contracts(tmp_path: Path) -> None:
+    first = _kernel(1, signature="same")
+    with pytest.raises(PreparedModelBundleError, match="kernel IDs must be unique"):
+        _pack(first, _kernel(1, signature="other"))
+    with pytest.raises(PreparedModelBundleError, match="signatures must be unique"):
+        _pack(first, _kernel(2, signature="same"))
+
+    path = _valid_bundle(tmp_path)
+
+    def replace_singular_pack(manifest: dict[str, object]) -> None:
+        pack = manifest.pop("kernel_pack")
+        manifest["kernel_packs"] = [pack, pack]
+
+    _mutate_manifest(path, replace_singular_pack)
+    with pytest.raises(PreparedModelBundleError, match="missing fields: kernel_pack"):
+        load_prepared_model_bundle(path)
+
+
+def test_reader_rejects_unreferenced_payload_member(tmp_path: Path) -> None:
+    path = _valid_bundle(tmp_path)
+    entries = _entries(path)
+    manifest_index = next(
+        index
+        for index, (info, _) in enumerate(entries)
+        if info.filename == PREPARED_MODEL_MANIFEST_PATH
+    )
+    manifest = json.loads(entries[manifest_index][1])
+    assert isinstance(manifest, dict)
+    members = manifest["members"]
+    assert isinstance(members, list)
+    members.append(
+        {
+            "path": "kernels/unreferenced.bin",
+            "size": 5,
+            "sha256": hashlib.sha256(b"extra").hexdigest(),
+        }
+    )
+    entries[manifest_index] = (
+        entries[manifest_index][0],
+        (json.dumps(manifest, sort_keys=True, separators=(",", ":")) + "\n").encode(
+            "ascii"
+        ),
+    )
+    extra = zipfile.ZipInfo("kernels/unreferenced.bin")
+    extra.create_system = 3
+    extra.external_attr = (stat.S_IFREG | 0o644) << 16
+    entries.append((extra, b"extra"))
+    _rewrite(path, entries)
+
+    with pytest.raises(PreparedModelBundleError, match="unreferenced"):
+        load_prepared_model_bundle(path)
+
+
+def test_manifest_payload_mapping_is_deeply_immutable() -> None:
+    kernel = _kernel()
+    manifest = kernel.f64_evaluator_manifest
+    assert isinstance(manifest, Mapping)
+    with pytest.raises(TypeError):
+        manifest["kind"] = "changed"  # type: ignore[index]
diff --git a/pyamplicol/tests/unit/test_prepared_model_compile.py b/pyamplicol/tests/unit/test_prepared_model_compile.py
new file mode 100644
index 0000000000..045ac81deb
--- /dev/null
+++ b/pyamplicol/tests/unit/test_prepared_model_compile.py
@@ -0,0 +1,1275 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.config import EvaluatorConfig, JITConfig
+from pyamplicol.generation.recurrence_template_columnar import (
+    RECURRENCE_TEMPLATE_INPUT_ABI,
+    RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION,
+)
+from pyamplicol.models.loading import compile_model_source
+from pyamplicol.models.prepared import PreparedKernelRecord, PreparedModelBundleError
+from pyamplicol.models.prepared_catalog import (
+    PREPARED_INDEPENDENT_BLOCK_PROOF,
+    PreparedKernelCatalog,
+    PreparedKernelInput,
+    PreparedKernelSpec,
+)
+from pyamplicol.models.prepared_compile import (
+    prepare_model_bundle,
+    prepared_symbolica_settings,
+)
+from pyamplicol.models.recurrence_direct_template import (
+    NATIVE_DIRECT_APPLICATION_ABI,
+    PreparedNativeDirectCallableSpecV1,
+    native_direct_entry_point,
+)
+from pyamplicol.models.recurrence_template import (
+    CurrentStateTemplateV1,
+    EvaluatorBindingV1,
+    PropagatorTemplateV1,
+    RecurrenceTemplateCatalog,
+)
+
+_NATIVE_BUILD_INPUTS_SHA256 = "a" * 64
+
+
+class _FakeJitAdapter:
+    def __init__(self, input_len: int = 1, output_len: int = 1) -> None:
+        self.input_len = input_len
+        self.output_len = output_len
+
+    def artifact_manifest(self, artifact_dir: Path) -> dict[str, object]:
+        payload_dir = artifact_dir / "evaluators"
+        payload_dir.mkdir(parents=True, exist_ok=True)
+        application = payload_dir / "random-application.symjit"
+        plane_application = payload_dir / "random-application.plane.symjit"
+        state = payload_dir / "random-state.evaluator.bin"
+        application.write_bytes(b"portable-symjit-application")
+        plane_application.write_bytes(b"portable-symjit-plane-application")
+        state.write_bytes(b"exact-symbolica-state")
+        return {
+            "kind": "symjit-application-evaluator",
+            "runtime_capability": "symjit.application.complex-f64.v1",
+            "backend": "jit",
+            "label": "prepared_test",
+            "input_len": self.input_len,
+            "output_len": self.output_len,
+            "application_path": str(application.relative_to(artifact_dir)),
+            "application_abi": "symjit-application-storage-v3",
+            "plane_application": {
+                "application_path": str(
+                    plane_application.relative_to(artifact_dir)
+                ),
+                "application_abi": "pyamplicol-symjit-plane-application-v2",
+                "storage_abi": "symjit-application-storage-v3",
+                "element_layout": "split-complex-plane-major",
+                "descriptor_order": "inputs-re-im-then-outputs-re-im",
+                "input_complex_count": self.input_len,
+                "output_complex_count": self.output_len,
+                "input_plane_count": 2 * self.input_len,
+                "output_plane_count": 2 * self.output_len,
+                "compiler_type": "native",
+                "translation_mode": "symbolica-structured-instructions",
+                "optimization_level": 2,
+                "simd": True,
+                "complex": True,
+                "fast_math": True,
+                "fast_complex": False,
+                "compression": True,
+                "threading": False,
+                "direct_arena": True,
+                "source_digest": hashlib.sha256(b"instructions").hexdigest(),
+                "target": {
+                    "word_bits": 64,
+                    "endianness": "little",
+                },
+            },
+            "element_layout": "complex-f64",
+            "batch_layout": "row-major",
+            "compiler_type": "native",
+            "translation_mode": "indirect",
+            "optimization_level": 2,
+            "word_bits": 64,
+            "endianness": "little",
+            "required_defuns": [],
+            "evaluator_state_path": str(state.relative_to(artifact_dir)),
+            "evaluator_state_runtime_capability": (
+                "symbolica.legacy-jit-container.complex-f64.v1"
+            ),
+            "settings": {"jit_optimization_level": 2},
+            "build_timing": {},
+        }
+
+
+def _catalog() -> PreparedKernelCatalog:
+    input_contract = PreparedKernelInput(
+        role="current",
+        component=0,
+        symbol="pyamplicol::prepared_test_input",
+    )
+    return PreparedKernelCatalog(
+        model_name="built-in-sm",
+        kernels=(
+            PreparedKernelSpec(
+                kernel_id=0,
+                contract_kind="propagator",
+                canonical_signature="1" * 64,
+                exact_expressions=("pyamplicol::prepared_test_input",),
+                inputs=(input_contract,),
+                output_layout=("scalar:c0",),
+            ),
+        ),
+        vertex_bindings=(),
+        propagator_bindings=(),
+        closure_bindings=(),
+        model_parameter_kernel_id=None,
+    )
+
+
+def test_prepared_jit_direct_source_reuses_authenticated_application() -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    application_path = "kernels/000000/application.symjit"
+    application_digest = hashlib.sha256(b"portable-o2").hexdigest()
+    record = PreparedKernelRecord(
+        kernel_id=0,
+        contract_kind="propagator",
+        canonical_signature="1" * 64,
+        input_arity=1,
+        output_arity=1,
+        input_layout=("current:0",),
+        input_contracts=(
+            {
+                "role": "current",
+                "component": 0,
+                "symbol": "pyamplicol::prepared_test_input",
+                "model_parameter_name": None,
+                "model_parameter_index": None,
+            },
+        ),
+        output_layout=("scalar:c0",),
+        exact_expressions=("pyamplicol::prepared_test_input",),
+        exact_evaluator_state_path="kernels/000000/exact.evaluator.bin",
+        f64_evaluator_manifest={
+            "plane_application": {
+                "application_path": application_path,
+                "application_abi": "pyamplicol-symjit-plane-application-v2",
+            },
+        },
+    )
+
+    source = prepared_compile._prepared_jit_direct_source(
+        record,
+        payload_identity_records={
+            application_path: (11, application_digest),
+            record.exact_evaluator_state_path: (
+                7,
+                hashlib.sha256(b"exact").hexdigest(),
+            ),
+        },
+    )
+
+    assert source.prepared_kernel_id == 0
+    assert source.source_application_path == application_path
+    assert source.source_application_sha256 == application_digest
+    assert (
+        source.source_application_abi
+        == "pyamplicol-symjit-plane-application-v2"
+    )
+    assert source.output_arity == 1
+    assert source.exact_expressions == record.exact_expressions
+    assert json.loads(source.input_contracts[0])["role"] == "current"
+
+
+def _native_direct_spec(
+    kernel: PreparedKernelSpec,
+) -> PreparedNativeDirectCallableSpecV1:
+    return PreparedNativeDirectCallableSpecV1(
+        prepared_kernel_id=kernel.kernel_id,
+        role="finalization",
+        native_entry_point=native_direct_entry_point(
+            "finalization",
+            kernel.kernel_id,
+        ),
+        input_contracts=tuple(
+            json.dumps(
+                item.to_dict(),
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            for item in kernel.inputs
+        ),
+        exact_expressions=kernel.exact_expressions,
+        output_arity=kernel.output_dimension,
+        parent_component_shapes=((1,), (4,)),
+        destination_component_counts=(1, 4),
+    )
+
+
+def test_prepared_native_direct_source_reuses_authenticated_library() -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    library_path = "kernels/000000/libprepared-native"
+    library_digest = hashlib.sha256(b"native-library").hexdigest()
+    kernel = _catalog().kernels[0]
+    spec = _native_direct_spec(kernel)
+    record = PreparedKernelRecord(
+        kernel_id=kernel.kernel_id,
+        contract_kind=kernel.contract_kind,
+        canonical_signature=kernel.canonical_signature,
+        input_arity=kernel.input_arity,
+        output_arity=kernel.output_dimension,
+        input_layout=tuple(
+            f"{item.role}:{item.component}" for item in kernel.inputs
+        ),
+        input_contracts=tuple(item.to_dict() for item in kernel.inputs),
+        output_layout=kernel.output_layout,
+        exact_expressions=kernel.exact_expressions,
+        exact_evaluator_state_path="kernels/000000/exact.evaluator.bin",
+        f64_evaluator_manifest={
+            "library_path": library_path,
+            "runtime_capability": "symbolica.compiled-cpp.complex-f64.v1",
+        },
+    )
+
+    source = prepared_compile._prepared_native_direct_source(
+        record,
+        spec=spec,
+        payload_identity_records={
+            library_path: (17, library_digest),
+            record.exact_evaluator_state_path: (
+                7,
+                hashlib.sha256(b"exact").hexdigest(),
+            ),
+        },
+    )
+
+    assert source.prepared_kernel_id == 0
+    assert source.role == "finalization"
+    assert source.native_entry_point == spec.native_entry_point
+    assert source.source_application_path == library_path
+    assert source.source_application_sha256 == library_digest
+    assert (
+        source.source_application_abi
+        == "symbolica.compiled-cpp.complex-f64.v1"
+    )
+
+
+def test_native_split_real_header_exports_only_direct_abis() -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    kernel = _catalog().kernels[0]
+    spec = _native_direct_spec(kernel)
+    header = prepared_compile._native_split_real_custom_header(
+        kernel,
+        raw_function_name="prepared_split",
+        direct_spec=spec,
+        eager_direct_source=(
+            'extern "C" int pyamplicol_eager_direct_table_k00000000_v1('
+            "const void*) { return 0; }"
+        ),
+    )
+
+    assert "prepared_complexf64_get_buffer_len" not in header
+    assert "prepared_complexf64(" not in header
+    assert "pyamplicol_eager_direct_table_k00000000_v1" in header
+    assert spec.native_entry_point in header
+    assert "DirectArenaView arena" in header
+    assert "DirectMomentumView momenta" in header
+    assert "DirectParameterView parameters" in header
+    assert "DirectFactorView factors" in header
+    assert "const DirectFinalizationRow* rows" in header
+    assert "row.component_count == 1u" in header
+    assert "row.component_count == 4u" in header
+    assert "std::vector" not in header
+    assert "malloc(" not in header
+    assert "EagerKernelInput" not in header
+    assert NATIVE_DIRECT_APPLICATION_ABI not in header
+    assert "static_assert(sizeof(DirectArenaView) == 56u)" in header
+    assert "static_assert(sizeof(DirectClosureRow) == 40u)" in header
+    assert "PAC_DIRECT_MAX_SCRATCH_DOUBLES" in header
+    assert "raw_buffer_len > PAC_DIRECT_MAX_SCRATCH_DOUBLES" in header
+    asm_header = prepared_compile._native_split_real_custom_header(
+        kernel,
+        raw_function_name="prepared_split",
+        direct_spec=spec,
+        raw_parameters_const=True,
+    )
+    assert (
+        'extern "C" void prepared_split_realf64('
+        "const double*, double*, double*);"
+    ) in asm_header
+
+
+@pytest.mark.parametrize(
+    ("target", "expected"),
+    [
+        (
+            {
+                "target_triple": "x86_64-unknown-linux-gnu",
+                "cpu_features": ["avx2"],
+            },
+            4,
+        ),
+        (
+            {
+                "target_triple": "x86_64-unknown-linux-gnu",
+                "cpu_features": [],
+            },
+            2,
+        ),
+        (
+            {
+                "target_triple": "aarch64-apple-darwin",
+                "cpu_features": ["neon"],
+            },
+            2,
+        ),
+    ],
+)
+def test_native_eager_simd_width_follows_portable_target(
+    target: dict[str, object],
+    expected: int,
+) -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    assert prepared_compile._native_eager_simd_lane_width(target) == expected
+
+
+def test_native_direct_header_reads_binding_coupling_from_context() -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    inputs = (
+        PreparedKernelInput(
+            role="coupling-real",
+            component=0,
+            symbol="prepared::coupling_re",
+        ),
+        PreparedKernelInput(
+            role="coupling-imag",
+            component=0,
+            symbol="prepared::coupling_im",
+        ),
+    )
+    kernel = PreparedKernelSpec(
+        kernel_id=17,
+        contract_kind="vertex",
+        canonical_signature="7" * 64,
+        exact_expressions=("prepared::coupling_re+prepared::coupling_im",),
+        inputs=inputs,
+        output_layout=("scalar:c0",),
+    )
+    spec = PreparedNativeDirectCallableSpecV1(
+        prepared_kernel_id=kernel.kernel_id,
+        role="contribution",
+        native_entry_point=native_direct_entry_point(
+            "contribution", kernel.kernel_id
+        ),
+        input_contracts=tuple(
+            json.dumps(
+                item.to_dict(),
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            for item in inputs
+        ),
+        exact_expressions=kernel.exact_expressions,
+        output_arity=1,
+        parent_component_shapes=((1, 1),),
+        destination_component_counts=(1,),
+    )
+    header = prepared_compile._native_split_real_custom_header(
+        kernel,
+        raw_function_name="prepared_split",
+        direct_spec=spec,
+    )
+
+    assert "struct DirectNativeBindingContextV1" in header
+    assert "if (context == nullptr) return 1;" in header
+    assert "binding_context->coupling_re" in header
+    assert "binding_context->coupling_im" in header
+
+
+@pytest.mark.parametrize("backend", ["cpp", "asm"])
+def test_native_direct_complex_contract_matches_exact_arithmetic(
+    tmp_path: Path,
+    backend: str,
+) -> None:
+    """Exercise coupling context, complex parameters, and row factors together."""
+
+    import ctypes
+
+    from symbolica import Expression
+
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    inputs = (
+        PreparedKernelInput(
+            role="current",
+            component=0,
+            symbol="test::current",
+        ),
+        PreparedKernelInput(
+            role="coupling-real",
+            component=0,
+            symbol="test::coupling_re",
+        ),
+        PreparedKernelInput(
+            role="coupling-imag",
+            component=0,
+            symbol="test::coupling_im",
+        ),
+        PreparedKernelInput(
+            role="model-parameter",
+            component=0,
+            symbol="test::model_parameter",
+            model_parameter_name="model.complex_parameter",
+            model_parameter_index=0,
+        ),
+    )
+    expression = (
+        "(test::coupling_re+sqrt(-1)*test::coupling_im)"
+        "*test::model_parameter*test::current"
+    )
+    kernel = PreparedKernelSpec(
+        kernel_id=73,
+        contract_kind="vertex",
+        canonical_signature="9" * 64,
+        exact_expressions=(expression,),
+        inputs=inputs,
+        output_layout=("scalar:c0",),
+    )
+    spec = PreparedNativeDirectCallableSpecV1(
+        prepared_kernel_id=kernel.kernel_id,
+        role="contribution",
+        native_entry_point=native_direct_entry_point(
+            "contribution",
+            kernel.kernel_id,
+        ),
+        input_contracts=tuple(
+            json.dumps(
+                item.to_dict(),
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            for item in inputs
+        ),
+        exact_expressions=kernel.exact_expressions,
+        output_arity=1,
+        parent_component_shapes=((1, 1),),
+        destination_component_counts=(1,),
+    )
+    settings = prepared_symbolica_settings(EvaluatorConfig(backend=backend))
+    manifest = prepared_compile._compile_native_split_real_kernel(
+        kernel,
+        outputs=(Expression.parse(expression),),
+        parameters=[Expression.parse(item.symbol) for item in inputs],
+        real_parameters=(1, 2),
+        settings=settings,
+        staging=tmp_path,
+        direct_spec=spec,
+    )
+    assert manifest["function_name"] == manifest["direct_table"]["function_name"]
+    manifest_settings = manifest["settings"]
+    assert isinstance(manifest_settings, dict)
+    assert manifest_settings["compiler_flags"] == []
+    assert manifest_settings["effective_compiler_flags"] == ["-std=c++17"]
+    assert "_complexf64(" not in Path(manifest["source_path"]).read_text(
+        encoding="utf-8"
+    )
+
+    class Arena(ctypes.Structure):
+        _fields_ = [
+            ("current_re", ctypes.POINTER(ctypes.c_double)),
+            ("current_im", ctypes.POINTER(ctypes.c_double)),
+            ("current_scalar_len", ctypes.c_uint64),
+            ("amplitude_re", ctypes.POINTER(ctypes.c_double)),
+            ("amplitude_im", ctypes.POINTER(ctypes.c_double)),
+            ("amplitude_scalar_len", ctypes.c_uint64),
+            ("point_stride", ctypes.c_uint32),
+        ]
+
+    class Momentum(ctypes.Structure):
+        _fields_ = [
+            ("values", ctypes.POINTER(ctypes.c_double)),
+            ("scalar_len", ctypes.c_uint64),
+            ("form_count", ctypes.c_uint32),
+            ("lorentz_component_count", ctypes.c_uint16),
+            ("point_stride", ctypes.c_uint32),
+        ]
+
+    class Values(ctypes.Structure):
+        _fields_ = [
+            ("values_re", ctypes.POINTER(ctypes.c_double)),
+            ("values_im", ctypes.POINTER(ctypes.c_double)),
+            ("value_count", ctypes.c_uint32),
+        ]
+
+    class Context(ctypes.Structure):
+        _fields_ = [
+            ("coupling_re", ctypes.c_double),
+            ("coupling_im", ctypes.c_double),
+        ]
+
+    class ContributionRow(ctypes.Structure):
+        _fields_ = [
+            ("parent0_component_base", ctypes.c_uint32),
+            ("parent1_component_base_or_sentinel", ctypes.c_uint32),
+            ("parent0_momentum_form_id", ctypes.c_uint32),
+            ("parent1_momentum_form_id_or_sentinel", ctypes.c_uint32),
+            ("destination_component_base", ctypes.c_uint32),
+            ("exact_factor_id", ctypes.c_uint32),
+            ("selector_domain_id", ctypes.c_uint32),
+            ("flags", ctypes.c_uint32),
+        ]
+
+    current_re = (ctypes.c_double * 2)(17.0, 0.0)
+    current_im = (ctypes.c_double * 2)(19.0, 0.0)
+    amplitudes_re = (ctypes.c_double * 1)(0.0)
+    amplitudes_im = (ctypes.c_double * 1)(0.0)
+    momentum_values = (ctypes.c_double * 1)(0.0)
+    parameter_re = (ctypes.c_double * 1)(5.0)
+    parameter_im = (ctypes.c_double * 1)(7.0)
+    factor_re = (ctypes.c_double * 1)(11.0)
+    factor_im = (ctypes.c_double * 1)(13.0)
+    arena = Arena(
+        current_re,
+        current_im,
+        2,
+        amplitudes_re,
+        amplitudes_im,
+        1,
+        1,
+    )
+    momenta = Momentum(momentum_values, 1, 1, 4, 1)
+    parameters = Values(parameter_re, parameter_im, 1)
+    factors = Values(factor_re, factor_im, 1)
+    context = Context(2.0, 3.0)
+    row = ContributionRow(0, 0xFFFFFFFF, 0, 0xFFFFFFFF, 1, 0, 0, 1)
+
+    library = ctypes.CDLL(str(manifest["library_path"]))
+    function = getattr(library, spec.native_entry_point)
+    function.argtypes = (
+        ctypes.c_void_p,
+        Arena,
+        Momentum,
+        Values,
+        Values,
+        ctypes.POINTER(ContributionRow),
+        ctypes.c_uint32,
+        ctypes.c_uint32,
+    )
+    function.restype = ctypes.c_int
+    status = function(
+        ctypes.byref(context),
+        arena,
+        momenta,
+        parameters,
+        factors,
+        ctypes.byref(row),
+        1,
+        1,
+    )
+
+    expected = (17 + 19j) * (2 + 3j) * (5 + 7j) * (11 + 13j)
+    assert status == 0
+    assert complex(current_re[1], current_im[1]) == pytest.approx(
+        expected,
+        rel=1.0e-14,
+        abs=1.0e-14,
+    )
+
+
+def test_native_split_real_contract_keeps_certified_real_inputs_real() -> None:
+    from symbolica import Expression
+
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    momentum = Expression.parse("test::p0")
+    current = Expression.parse("test::current0")
+    split_parameters, split_outputs = (
+        prepared_compile._split_complex_kernel_contract(
+            17,
+            outputs=(current / (momentum**2 + 1),),
+            parameters=[momentum, current],
+            real_parameters=(0,),
+        )
+    )
+
+    assert len(split_parameters) == 4
+    momentum_imaginary = split_parameters[1].to_canonical_string()
+    assert all(
+        momentum_imaginary
+        not in expression.to_canonical_string()
+        for expression in split_outputs
+    )
+    assert split_outputs[0].is_real()
+    assert split_outputs[1].is_real()
+
+
+def test_native_split_real_contract_supports_only_certified_real_roots() -> None:
+    from symbolica import Expression
+
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    real_parameter = Expression.parse("test::real_parameter")
+    complex_parameter = Expression.parse("test::complex_parameter")
+    split_parameters, split_outputs = (
+        prepared_compile._split_complex_kernel_contract(
+            19,
+            outputs=(
+                Expression.parse(
+                    "test::real_parameter^(1/2)"
+                    "+test::real_parameter^(-1/2)"
+                    "+test::real_parameter^(3/2)"
+                ),
+            ),
+            parameters=[real_parameter],
+            real_parameters=(0,),
+        )
+    )
+
+    admitted_symbols = {
+        symbol.to_atom_tree().head for symbol in split_parameters
+    }
+    assert prepared_compile._is_structurally_real_expression(
+        split_outputs[0],
+        admitted_symbols=admitted_symbols,
+    )
+    assert split_outputs[1].to_canonical_string() == "0"
+    with pytest.raises(PreparedModelBundleError, match="complex expression"):
+        prepared_compile._split_complex_kernel_contract(
+            20,
+            outputs=(Expression.parse("test::complex_parameter^(1/2)"),),
+            parameters=[complex_parameter],
+            real_parameters=(),
+        )
+    with pytest.raises(
+        PreparedModelBundleError,
+        match="unsupported real non-integer power",
+    ):
+        prepared_compile._split_complex_kernel_contract(
+            21,
+            outputs=(Expression.parse("test::real_parameter^(1/3)"),),
+            parameters=[real_parameter],
+            real_parameters=(0,),
+        )
+
+
+def test_native_real_parameter_indices_follow_catalog_domains() -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    kernel = PreparedKernelSpec(
+        kernel_id=23,
+        contract_kind="propagator",
+        canonical_signature="8" * 64,
+        exact_expressions=("test::p+test::mass+test::phase",),
+        inputs=(
+            PreparedKernelInput(
+                role="momentum",
+                component=0,
+                symbol="test::p",
+            ),
+            PreparedKernelInput(
+                role="model-parameter",
+                component=0,
+                symbol="test::mass",
+                model_parameter_name="particle.23.mass",
+                model_parameter_index=0,
+            ),
+            PreparedKernelInput(
+                role="model-parameter",
+                component=0,
+                symbol="test::phase",
+                model_parameter_name="model.phase",
+                model_parameter_index=1,
+            ),
+        ),
+        output_layout=("scalar:c0",),
+    )
+
+    assert prepared_compile._real_kernel_parameter_indices(
+        kernel,
+        real_model_parameter_names=frozenset({"particle.23.mass"}),
+    ) == (0, 1)
+
+
+def _block_catalog() -> PreparedKernelCatalog:
+    return PreparedKernelCatalog(
+        model_name="built-in-sm",
+        kernels=(
+            PreparedKernelSpec(
+                kernel_id=0,
+                contract_kind="vertex",
+                canonical_signature="2" * 64,
+                exact_expressions=(
+                    "pyamplicol::prepared_block_left+pyamplicol::prepared_block_right",
+                ),
+                inputs=(
+                    PreparedKernelInput(
+                        role="left-current",
+                        component=0,
+                        symbol="pyamplicol::prepared_block_left",
+                    ),
+                    PreparedKernelInput(
+                        role="right-current",
+                        component=0,
+                        symbol="pyamplicol::prepared_block_right",
+                    ),
+                ),
+                output_layout=("scalar:c0",),
+                proof_classes=(PREPARED_INDEPENDENT_BLOCK_PROOF,),
+            ),
+        ),
+        vertex_bindings=(),
+        propagator_bindings=(),
+        closure_bindings=(),
+        model_parameter_kernel_id=None,
+    )
+
+
+@pytest.mark.parametrize("compress", (True, False))
+def test_prepared_symbolica_settings_forward_jit_compression(
+    compress: bool,
+) -> None:
+    settings = prepared_symbolica_settings(
+        EvaluatorConfig(jit=JITConfig(compress=compress))
+    )
+
+    assert settings.jit_compress is compress
+    assert settings.to_json_dict()["jit_compress"] is compress
+
+
+def _native_recurrence_validation(*_args, **_kwargs) -> dict[str, object]:
+    return {
+        "kind": "pyamplicol-recurrence-template-validation-result",
+        "template_input_sha256": "d" * 64,
+    }
+
+
+def _recurrence_catalog(
+    *,
+    compiled_model_digest: str,
+    prepared_kernel_pack_digest: str,
+) -> RecurrenceTemplateCatalog:
+    state = CurrentStateTemplateV1(
+        template_id="state:test-scalar",
+        particle_id=9000001,
+        anti_particle_id=9000001,
+        species_id="test-scalar",
+        orientation="self-conjugate",
+        statistics="boson",
+        color_representation=1,
+        basis="scalar",
+        tensor_ordering=("scalar",),
+        dimension=1,
+        chirality=0,
+        lc_color_shape_kind="singlet-forest",
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+    expression_digest = hashlib.sha256(b"pyamplicol::prepared_test_input").hexdigest()
+    propagator = PropagatorTemplateV1(
+        template_id="propagator:test-active",
+        state_template_id=state.template_id,
+        applies_propagator=True,
+        evaluator_resolver_key="evaluator:propagator:test",
+        numerator_expression_digest=expression_digest,
+        denominator_expression_digest=expression_digest,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+        gauge=None,
+        linearity_proof_template_id=None,
+    )
+    binding = EvaluatorBindingV1(
+        resolver_key="evaluator:propagator:test",
+        prepared_kernel_id=0,
+        contract_kind="propagator",
+        callable_signature="1" * 64,
+        input_state_template_ids=(state.template_id,),
+        output_state_template_id=state.template_id,
+        input_layout=(
+            json.dumps(
+                {
+                    "component": 0,
+                    "model_parameter_index": None,
+                    "model_parameter_name": None,
+                    "role": "current",
+                    "symbol": "pyamplicol::prepared_test_input",
+                },
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            ),
+        ),
+        output_layout=("scalar:c0",),
+        exact_expression_digests=(expression_digest,),
+        semantic_template_ids=(propagator.template_id,),
+    )
+    return RecurrenceTemplateCatalog.create(
+        compiled_model_digest=compiled_model_digest,
+        prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+        current_states=(state,),
+        propagators=(propagator,),
+        evaluator_bindings=(binding,),
+    )
+
+
+def _identity_recurrence_catalog(
+    *,
+    compiled_model_digest: str,
+    prepared_kernel_pack_digest: str,
+) -> RecurrenceTemplateCatalog:
+    state = CurrentStateTemplateV1(
+        template_id="state:test-scalar",
+        particle_id=9000001,
+        anti_particle_id=9000001,
+        species_id="test-scalar",
+        orientation="self-conjugate",
+        statistics="boson",
+        color_representation=1,
+        basis="scalar",
+        tensor_ordering=("scalar",),
+        dimension=1,
+        chirality=0,
+        lc_color_shape_kind="singlet-forest",
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+    identity = PropagatorTemplateV1(
+        template_id="propagator:test-identity",
+        state_template_id=state.template_id,
+        applies_propagator=False,
+        evaluator_resolver_key=None,
+        numerator_expression_digest=None,
+        denominator_expression_digest=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+        gauge=None,
+        linearity_proof_template_id=None,
+    )
+    return RecurrenceTemplateCatalog.create(
+        compiled_model_digest=compiled_model_digest,
+        prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+        current_states=(state,),
+        propagators=(identity,),
+    )
+
+
+def _native_result(template_input, authenticated_ids) -> dict[str, object]:
+    assert authenticated_ids == [0]
+    return {
+        "kind": "pyamplicol-recurrence-template-validation-result",
+        "schema_version": 1,
+        "validation_status": "validated",
+        "template_input_abi": RECURRENCE_TEMPLATE_INPUT_ABI,
+        "template_input_schema_version": RECURRENCE_TEMPLATE_INPUT_SCHEMA_VERSION,
+        "template_input_sha256": template_input.canonical_digest,
+        "catalog_digest": template_input.catalog_digest,
+        "compiled_model_digest": template_input.compiled_model_digest,
+        "prepared_kernel_pack_digest": template_input.prepared_kernel_pack_digest,
+        "prepared_kernel_inventory_verified": True,
+        "prepared_kernel_inventory_count": 1,
+        "counts": {
+            "parameters": 0,
+            "current_states": 0,
+            "sources": 0,
+            "quantum_flows": 0,
+            "transitions": 0,
+            "propagators": 0,
+            "closures": 0,
+            "color_contractions": 0,
+            "symmetry_proofs": 0,
+            "runtime_helicity_contracts": 0,
+            "evaluator_bindings": 0,
+            "prepared_kernels": 0,
+            "referenced_prepared_kernels": 0,
+        },
+    }
+
+
+def test_native_recurrence_validation_checks_complete_result_contract(
+    monkeypatch,
+) -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    catalog = RecurrenceTemplateCatalog.create(
+        compiled_model_digest="a" * 64,
+        prepared_kernel_pack_digest="b" * 64,
+    )
+    module = type("NativeModule", (), {})()
+    module._validate_recurrence_template_input_v1 = _native_result
+    monkeypatch.setattr(
+        prepared_compile.importlib,
+        "import_module",
+        lambda _name: module,
+    )
+
+    result = prepared_compile._validate_native_recurrence_template_input_v1(
+        catalog,
+        (0,),
+    )
+    assert result["prepared_kernel_inventory_verified"] is True
+
+    def wrong_result(template_input, authenticated_ids):
+        result = _native_result(template_input, authenticated_ids)
+        result["schema_version"] = True
+        return result
+
+    module._validate_recurrence_template_input_v1 = wrong_result
+    with pytest.raises(PreparedModelBundleError, match="schema_version"):
+        prepared_compile._validate_native_recurrence_template_input_v1(catalog, (0,))
+
+
+def test_native_recurrence_validation_requires_matching_extension(
+    monkeypatch,
+) -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    catalog = RecurrenceTemplateCatalog.create(
+        compiled_model_digest="a" * 64,
+        prepared_kernel_pack_digest="b" * 64,
+    )
+    monkeypatch.setattr(
+        prepared_compile.importlib,
+        "import_module",
+        lambda _name: (_ for _ in ()).throw(ImportError("missing")),
+    )
+
+    with pytest.raises(PreparedModelBundleError, match="matching installed"):
+        prepared_compile._validate_native_recurrence_template_input_v1(catalog, ())
+
+
+def test_recurrence_preflight_fails_before_backend_compilation(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    compiled = compile_model_source("built-in-sm", use_cache=False)
+    compiled_kernel = False
+
+    def fail_recurrence(*_args, **_kwargs):
+        raise ValueError("unsupported recurrence semantics")
+
+    def observe_compile(*_args, **_kwargs):
+        nonlocal compiled_kernel
+        compiled_kernel = True
+        raise AssertionError("backend compilation must not run")
+
+    monkeypatch.setattr(
+        prepared_compile,
+        "build_prepared_kernel_catalog",
+        lambda _: _catalog(),
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "build_recurrence_template_catalog",
+        fail_recurrence,
+    )
+    monkeypatch.setattr(prepared_compile, "_compile_kernel", observe_compile)
+
+    with pytest.raises(ValueError, match="unsupported recurrence semantics"):
+        prepare_model_bundle(
+            compiled,
+            tmp_path / "unsupported-recurrence",
+            evaluator=EvaluatorConfig(),
+        )
+    assert compiled_kernel is False
+
+
+def test_native_recurrence_preflight_fails_before_backend_compilation(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    compiled = compile_model_source("built-in-sm", use_cache=False)
+    compiled_kernel = False
+
+    def observe_compile(*_args, **_kwargs):
+        nonlocal compiled_kernel
+        compiled_kernel = True
+        raise AssertionError("backend compilation must not run")
+
+    monkeypatch.setattr(
+        prepared_compile,
+        "build_prepared_kernel_catalog",
+        lambda _: _catalog(),
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "build_recurrence_template_catalog",
+        lambda *_args, compiled_model_digest, prepared_kernel_pack_digest, **_kwargs: (
+            _identity_recurrence_catalog(
+                compiled_model_digest=compiled_model_digest,
+                prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+            )
+        ),
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "_validate_native_recurrence_template_input_v1",
+        lambda *_args, **_kwargs: (_ for _ in ()).throw(
+            ValueError("native recurrence unavailable")
+        ),
+    )
+    monkeypatch.setattr(prepared_compile, "_compile_kernel", observe_compile)
+
+    with pytest.raises(ValueError, match="native recurrence unavailable"):
+        prepare_model_bundle(
+            compiled,
+            tmp_path / "missing-native-recurrence",
+            evaluator=EvaluatorConfig(),
+        )
+    assert compiled_kernel is False
+
+
+def test_prepared_compiler_writes_structured_architecture_kernel_pack(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    monkeypatch.setattr(
+        prepared_compile,
+        "build_prepared_kernel_catalog",
+        lambda _: _catalog(),
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "build_recurrence_template_catalog",
+        lambda *_args, compiled_model_digest, prepared_kernel_pack_digest, **_kwargs: (
+            _recurrence_catalog(
+                compiled_model_digest=compiled_model_digest,
+                prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+            )
+        ),
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "_compile_symbolica_outputs",
+        lambda *_args, **_kwargs: _FakeJitAdapter(),
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "_validate_native_recurrence_template_input_v1",
+        _native_recurrence_validation,
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "_native_build_inputs_sha256",
+        lambda: _NATIVE_BUILD_INPUTS_SHA256,
+    )
+    compiled = compile_model_source("built-in-sm", use_cache=False)
+    progress: list[tuple[str, int, int]] = []
+
+    result = prepare_model_bundle(
+        compiled,
+        tmp_path / "prepared-built-in",
+        evaluator=EvaluatorConfig(),
+        progress=lambda label, completed, total: progress.append(
+            (label, completed, total)
+        ),
+    )
+
+    assert result.output.name.endswith(".pyamplicol-model")
+    assert result.kernel_count == 1
+    assert result.bundle.backend == "jit"
+    assert (
+        result.bundle.kernel_pack.producer["native_build_inputs_sha256"]
+        == _NATIVE_BUILD_INPUTS_SHA256
+    )
+    assert result.bundle.kernel_pack.optimization_settings["jit_compress"] is False
+    assert result.bundle.kernel_pack.target["portable"] is True
+    assert (
+        result.bundle.kernel_pack.target["target_triple"]
+        == "symjit-storage-v3-portable"
+    )
+    assert result.bundle.kernel_pack.resolver_manifest["model_name"] == "built-in-sm"
+    kernel = result.bundle.kernel_pack.kernels[0]
+    assert kernel.input_contracts[0]["role"] == "current"
+    assert kernel.exact_expressions == ("pyamplicol::prepared_test_input",)
+    assert kernel.exact_evaluator_state_path.startswith("kernels/000000/")
+    assert all(
+        path.startswith("kernels/000000/") for path in kernel.referenced_payload_paths
+    )
+    direct_catalog = result.bundle.kernel_pack.recurrence_direct_template_catalog
+    assert direct_catalog is not None
+    assert direct_catalog.backend == "jit"
+    assert direct_catalog.portable is True
+    assert direct_catalog.optimization_level == 2
+    assert direct_catalog.direct_executor_id_for("finalization", 0) == 0
+    payload_binding = direct_catalog.templates[0].payload_binding
+    assert payload_binding.kind == "prepared-direct-call"
+    assert payload_binding.source_application_path in kernel.referenced_payload_paths
+    assert (
+        payload_binding.source_application_abi
+        == "pyamplicol-symjit-plane-application-v2"
+    )
+    assert payload_binding.direct_application_abi == (
+        "pyamplicol-symjit-plane-application-v2"
+    )
+    assert payload_binding.role == "finalization"
+    assert payload_binding.destination_operation == "finalize-in-place"
+    assert payload_binding.exact_factor_scalar_slots == (0, 1)
+    assert payload_binding.prepared_template_semantic_digest is not None
+    assert direct_catalog.executable
+    assert result.bundle.direct_template_catalog_digest == direct_catalog.catalog_digest
+    assert (
+        result.bundle.manifest["direct_template_catalog_digest"]
+        == direct_catalog.catalog_digest
+    )
+    assert progress[-1] == ("prepared model complete", 1, 1)
+    assert "recurrence_template_validation" in result.phase_timings_seconds
+
+
+def test_prepared_jit_compiler_forces_portable_o2_without_changing_public_config(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    observed_levels: list[int] = []
+
+    def fake_compile(*_args, symbolica_settings, **_kwargs):
+        observed_levels.append(symbolica_settings.jit_optimization_level)
+        return _FakeJitAdapter()
+
+    monkeypatch.setattr(
+        prepared_compile,
+        "build_prepared_kernel_catalog",
+        lambda _: _catalog(),
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "build_recurrence_template_catalog",
+        lambda *_args, compiled_model_digest, prepared_kernel_pack_digest, **_kwargs: (
+            _recurrence_catalog(
+                compiled_model_digest=compiled_model_digest,
+                prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+            )
+        ),
+    )
+    monkeypatch.setattr(prepared_compile, "_compile_symbolica_outputs", fake_compile)
+    monkeypatch.setattr(
+        prepared_compile,
+        "_validate_native_recurrence_template_input_v1",
+        _native_recurrence_validation,
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "_native_build_inputs_sha256",
+        lambda: _NATIVE_BUILD_INPUTS_SHA256,
+    )
+    requested = EvaluatorConfig(jit=JITConfig(optimization_level=3))
+    compiled = compile_model_source("built-in-sm", use_cache=False)
+
+    with pytest.warns(UserWarning, match="optimization level 2"):
+        result = prepare_model_bundle(
+            compiled,
+            tmp_path / "portable-o2",
+            evaluator=requested,
+        )
+
+    assert requested.jit.optimization_level == 3
+    assert observed_levels == [2]
+    assert (
+        result.bundle.kernel_pack.optimization_settings["jit_optimization_level"] == 2
+    )
+    assert (
+        result.bundle.kernel_pack.kernels[0].f64_evaluator_manifest[
+            "optimization_level"
+        ]
+        == 2
+    )
+    direct_catalog = result.bundle.kernel_pack.recurrence_direct_template_catalog
+    assert direct_catalog is not None
+    assert direct_catalog.optimization_level == 2
+    assert direct_catalog.portable is True
+
+
+def test_prepared_compiler_emits_independent_block4_jit_variant(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    import pyamplicol.models.prepared_compile as prepared_compile
+
+    compiled_shapes: list[tuple[int, int]] = []
+
+    def fake_compile(outputs, parameters, **_kwargs):
+        compiled_shapes.append((len(parameters), len(outputs)))
+        return _FakeJitAdapter(len(parameters), len(outputs))
+
+    monkeypatch.setattr(
+        prepared_compile,
+        "build_prepared_kernel_catalog",
+        lambda _: _block_catalog(),
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "build_recurrence_template_catalog",
+        lambda *_args, compiled_model_digest, prepared_kernel_pack_digest, **_kwargs: (
+            _identity_recurrence_catalog(
+                compiled_model_digest=compiled_model_digest,
+                prepared_kernel_pack_digest=prepared_kernel_pack_digest,
+            )
+        ),
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "_compile_symbolica_outputs",
+        fake_compile,
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "_validate_native_recurrence_template_input_v1",
+        _native_recurrence_validation,
+    )
+    monkeypatch.setattr(
+        prepared_compile,
+        "_native_build_inputs_sha256",
+        lambda: _NATIVE_BUILD_INPUTS_SHA256,
+    )
+    compiled = compile_model_source("built-in-sm", use_cache=False)
+
+    result = prepare_model_bundle(
+        compiled,
+        tmp_path / "prepared-block",
+        evaluator=EvaluatorConfig(),
+    )
+
+    assert compiled_shapes == [(2, 1), (8, 4)]
+    (variant,) = result.bundle.kernel_pack.kernel_variants
+    assert variant.variant_id == "independent-block-4"
+    assert variant.input_lane_stride == 2
+    assert variant.output_lane_stride == 1
+    assert variant.input_layout == (
+        "lane:0:left-current:0",
+        "lane:0:right-current:0",
+        "lane:1:left-current:0",
+        "lane:1:right-current:0",
+        "lane:2:left-current:0",
+        "lane:2:right-current:0",
+        "lane:3:left-current:0",
+        "lane:3:right-current:0",
+    )
+    assert all(
+        path.startswith("kernels/000000/variants/independent-block-4/")
+        for path in variant.referenced_payload_paths
+    )
diff --git a/pyamplicol/tests/unit/test_prepared_model_loading.py b/pyamplicol/tests/unit/test_prepared_model_loading.py
new file mode 100644
index 0000000000..e84ebcbce8
--- /dev/null
+++ b/pyamplicol/tests/unit/test_prepared_model_loading.py
@@ -0,0 +1,342 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+import pyamplicol.licensing as licensing
+from pyamplicol import Generator, ModelSource
+from pyamplicol.api.errors import GenerationError, ModelError
+from pyamplicol.api.models import _compiled_model_payload
+from pyamplicol.config import Action, EvaluatorConfig, JITConfig, ModelConfig, RunConfig
+from pyamplicol.licensing import SymbolicaLicenseState
+from pyamplicol.models.loading import compile_model_source, load_compiled_model
+from pyamplicol.models.prepared import (
+    PreparedKernelPack,
+    PreparedKernelRecord,
+    write_prepared_model_bundle,
+)
+from pyamplicol.models.prepared_target import (
+    SYMJIT_STORAGE_V3_ABI,
+    canonical_architecture,
+    symjit_storage_v3_target,
+)
+
+
+def _prepared_builtin_sm(
+    tmp_path: Path,
+    *,
+    machine: str | None = None,
+    jit_compress: bool | None = True,
+) -> Path:
+    compiled = compile_model_source("built-in-sm", use_cache=False)
+    kernel = PreparedKernelRecord(
+        kernel_id=0,
+        contract_kind="vertex",
+        canonical_signature="test:prepared-loading",
+        input_arity=1,
+        output_arity=1,
+        input_layout=("input",),
+        input_contracts=(
+            {
+                "role": "current",
+                "component": 0,
+                "symbol": "pyamplicol::input",
+                "model_parameter_name": None,
+                "model_parameter_index": None,
+            },
+        ),
+        output_layout=("output",),
+        exact_expressions=("pyamplicol::input",),
+        exact_evaluator_state_path="kernels/0/exact.evaluator.bin",
+        f64_evaluator_manifest={
+            "kind": "symjit-application-evaluator",
+            "optimization_level": 2,
+            "settings": {
+                "iterations": 10,
+                "cpe_iterations": None,
+                "jit_optimization_level": 2,
+                "max_horner_scheme_variables": 1000,
+                "max_common_pair_cache_entries": 5_000_000,
+                "max_common_pair_distance": 1000,
+                "collect_factors": False,
+            },
+            "input_len": 1,
+            "output_len": 1,
+            "application_path": "kernels/0/application.symjit",
+            "evaluator_state_path": "kernels/0/exact.evaluator.bin",
+        },
+    )
+    optimization_settings: dict[str, object] = {
+        "iterations": 10,
+        "cpe_iterations": None,
+        "jit_optimization_level": 2,
+        "max_horner_scheme_variables": 1000,
+        "max_common_pair_cache_entries": 5_000_000,
+        "max_common_pair_distance": 1000,
+        "collect_factors": False,
+    }
+    if jit_compress is not None:
+        optimization_settings["jit_compress"] = jit_compress
+    pack = PreparedKernelPack(
+        backend="jit",
+        optimization_settings=optimization_settings,
+        producer={"distribution": "pyamplicol", "version": "test"},
+        dependency_abis={
+            "symjit_application": SYMJIT_STORAGE_V3_ABI,
+            "symjit_plane_application": "pyamplicol-symjit-plane-application-v2",
+        },
+        provenance={"compiled_model": "test"},
+        target=symjit_storage_v3_target(machine=machine),
+        resolver_manifest={
+            "abi": "pyamplicol-prepared-kernel-catalog-v1",
+            "model_name": "built-in-sm",
+        },
+        kernels=(kernel,),
+    )
+    return write_prepared_model_bundle(
+        tmp_path / "builtin",
+        compiled_model=compiled.to_dict(),
+        kernel_pack=pack,
+        payloads={
+            "kernels/0/exact.evaluator.bin": b"exact",
+            "kernels/0/application.symjit": b"jit",
+        },
+    )
+
+
+def test_model_source_loads_prepared_bundle_without_changing_provenance(
+    tmp_path: Path,
+) -> None:
+    bundle_path = _prepared_builtin_sm(tmp_path)
+
+    source = ModelSource.from_path(bundle_path)
+    compiled = source.compile(use_cache=False)
+    payload = _compiled_model_payload(compiled)
+
+    assert source.kind == "prepared"
+    assert compiled.name == "built-in-sm"
+    assert compiled.source.kind == "built-in-sm"
+    assert compiled.is_prepared
+    assert compiled.prepared_backend == "jit"
+    assert payload.prepared_bundle is not None
+    assert payload.prepared_bundle.path == bundle_path
+
+
+def test_internal_compiled_model_loader_accepts_prepared_bundle(tmp_path: Path) -> None:
+    bundle_path = _prepared_builtin_sm(tmp_path)
+
+    compiled = load_compiled_model(bundle_path)
+
+    assert compiled.name == "built-in-sm"
+    assert compiled.prepared_backend == "jit"
+    assert compiled.prepared_bundle is not None
+
+
+def test_prepared_model_rejects_compilation_options(tmp_path: Path) -> None:
+    bundle_path = _prepared_builtin_sm(tmp_path)
+
+    with pytest.raises(ModelError, match="already compiled"):
+        ModelSource.from_path(bundle_path, simplify=False).compile(use_cache=False)
+
+
+def _eager_config() -> RunConfig:
+    return RunConfig(
+        action=Action.GENERATE,
+        evaluator=EvaluatorConfig(execution_mode="eager"),
+    )
+
+
+def _restricted_license(**_kwargs: object) -> SymbolicaLicenseState:
+    return SymbolicaLicenseState(licensed=False, restricted=True)
+
+
+def test_eager_plan_uses_packaged_builtin_model(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    bundle_path = _prepared_builtin_sm(tmp_path)
+    monkeypatch.setattr(
+        "pyamplicol.assets.prepared_models.materialize_packaged_prepared_model",
+        lambda _identifier: bundle_path,
+    )
+    plan = Generator(_eager_config()).plan("d d~ > z")
+
+    assert len(plan.concrete_processes) == 1
+    assert plan.estimated_coverage["model_kind"] == "prepared"
+
+
+def test_default_recurrence_plan_uses_packaged_builtin_model(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    bundle_path = _prepared_builtin_sm(tmp_path)
+    monkeypatch.setattr(
+        "pyamplicol.assets.prepared_models.materialize_packaged_prepared_model",
+        lambda _identifier: bundle_path,
+    )
+    # The small loading fixture predates the recurrence catalog; this test
+    # isolates default source selection, while recurrence-pack validation has
+    # dedicated bundle/preflight coverage.
+    monkeypatch.setattr(
+        "pyamplicol.generation.service.GenerationBackend._require_eager_kernel_pack",
+        lambda _self, _resolved: None,
+    )
+
+    plan = Generator(RunConfig(action=Action.GENERATE)).plan("d d~ > z")
+
+    assert plan.effective_settings.evaluator.execution_mode == "recurrence"
+    assert plan.estimated_coverage["model_kind"] == "prepared"
+
+
+def test_default_heft_recurrence_selects_its_own_packaged_model(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol.assets.prepared_models import BUILTIN_SM_HEFT_JIT_O2
+
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    bundle_path = _prepared_builtin_sm(tmp_path)
+    selected: list[str] = []
+
+    def materialize(identifier: str) -> Path:
+        selected.append(identifier)
+        return bundle_path
+
+    monkeypatch.setattr(
+        "pyamplicol.assets.prepared_models.materialize_packaged_prepared_model",
+        materialize,
+    )
+    monkeypatch.setattr(
+        "pyamplicol.generation.service.GenerationBackend._require_eager_kernel_pack",
+        lambda _self, _resolved: None,
+    )
+    config = RunConfig(
+        action=Action.GENERATE,
+        model=ModelConfig(source="built-in-sm-heft"),
+    )
+
+    plan = Generator(config).plan("d d~ > z")
+
+    assert selected == [BUILTIN_SM_HEFT_JIT_O2]
+    assert plan.estimated_coverage["model_kind"] == "prepared"
+
+
+def test_eager_compiled_handle_without_pack_fails_before_dag(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    model = ModelSource.built_in_sm().compile(use_cache=False)
+
+    with pytest.raises(
+        GenerationError,
+        match=r"pyamplicol model compile.*--backend jit",
+    ):
+        Generator(_eager_config()).plan("d d~ > z", model=model)
+
+
+def test_eager_accepts_portable_prepared_model_from_other_architecture_alias(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    other = "x86_64" if canonical_architecture() == "aarch64" else "aarch64"
+    model = ModelSource.from_path(_prepared_builtin_sm(tmp_path, machine=other))
+
+    plan = Generator(_eager_config()).plan("d d~ > z", model=model)
+
+    assert len(plan.concrete_processes) == 1
+    assert plan.effective_settings.evaluator.jit.optimization_level == 2
+
+
+def test_compiled_plan_does_not_materialize_packaged_model(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+
+    def fail(_identifier: str) -> Path:
+        raise AssertionError("compiled mode touched eager packaged resources")
+
+    monkeypatch.setattr(
+        "pyamplicol.assets.prepared_models.materialize_packaged_prepared_model",
+        fail,
+    )
+
+    plan = Generator(
+        RunConfig(
+            action=Action.GENERATE,
+            evaluator=EvaluatorConfig(execution_mode="compiled"),
+        )
+    ).plan("d d~ > z")
+
+    assert plan.estimated_coverage["model_kind"] == "built-in-sm"
+
+
+def test_eager_plan_accepts_prepared_model(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    model = ModelSource.from_path(_prepared_builtin_sm(tmp_path))
+
+    plan = Generator(_eager_config()).plan("d d~ > z", model=model)
+
+    assert len(plan.concrete_processes) == 1
+    assert plan.estimated_coverage["model_kind"] == "prepared"
+    assert plan.effective_settings.evaluator.backend == "jit"
+    assert plan.effective_settings.evaluator.jit.optimization_level == 2
+    assert plan.effective_settings.evaluator.jit.compress is True
+    assert {adjustment.path for adjustment in plan.adjustments} >= {
+        "evaluator.optimization.collect_factors"
+    }
+
+
+def test_eager_prepared_pack_settings_are_authoritative(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    model = ModelSource.from_path(_prepared_builtin_sm(tmp_path, jit_compress=False))
+    config = RunConfig(
+        action=Action.GENERATE,
+        evaluator=EvaluatorConfig(
+            backend="cpp",
+            execution_mode="eager",
+            jit=JITConfig(optimization_level=1, compress=True),
+        ),
+    )
+
+    plan = Generator(config).plan("d d~ > z", model=model)
+
+    assert plan.requested_settings.evaluator.backend == "cpp"
+    assert plan.requested_settings.evaluator.jit.optimization_level == 1
+    assert plan.requested_settings.evaluator.jit.compress is True
+    assert plan.effective_settings.evaluator.backend == "jit"
+    assert plan.effective_settings.evaluator.jit.optimization_level == 2
+    assert plan.effective_settings.evaluator.jit.compress is False
+    by_path = {adjustment.path: adjustment for adjustment in plan.adjustments}
+    assert by_path["evaluator.backend"].requested == "cpp"
+    assert by_path["evaluator.backend"].effective == "jit"
+    assert by_path["evaluator.jit.optimization_level"].requested == 1
+    assert by_path["evaluator.jit.optimization_level"].effective == 2
+    assert by_path["evaluator.jit.compress"].requested is True
+    assert by_path["evaluator.jit.compress"].effective is False
+    assert "prepared model settings" in caplog.text
+
+
+def test_prepared_jit_pack_requires_explicit_compression_setting(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(licensing, "detect_symbolica_license", _restricted_license)
+    model = ModelSource.from_path(_prepared_builtin_sm(tmp_path, jit_compress=None))
+
+    with pytest.raises(
+        GenerationError,
+        match="omits optimization setting 'jit_compress'",
+    ):
+        Generator(_eager_config()).plan("d d~ > z", model=model)
diff --git a/pyamplicol/tests/unit/test_prepared_target.py b/pyamplicol/tests/unit/test_prepared_target.py
new file mode 100644
index 0000000000..83eae58844
--- /dev/null
+++ b/pyamplicol/tests/unit/test_prepared_target.py
@@ -0,0 +1,94 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import pytest
+
+from pyamplicol.models.prepared_target import (
+    SYMJIT_STORAGE_V3_ABI,
+    PreparedTargetError,
+    canonical_architecture,
+    symjit_storage_v3_target,
+    validate_prepared_target,
+)
+
+
+@pytest.mark.parametrize(
+    ("machine", "expected"),
+    (
+        ("arm64", "aarch64"),
+        ("aarch64", "aarch64"),
+        ("AMD64", "x86_64"),
+        ("x86_64", "x86_64"),
+    ),
+)
+def test_canonical_architecture_aliases(machine: str, expected: str) -> None:
+    assert canonical_architecture(machine) == expected
+
+
+def test_symjit_storage_v3_target_is_cross_architecture_portable() -> None:
+    target = symjit_storage_v3_target(machine="arm64")
+
+    assert target == {
+        "portable": True,
+        "word_bits": 64,
+        "endianness": "little",
+        "target_triple": "symjit-storage-v3-portable",
+        "cpu_features": [],
+    }
+
+
+def test_symjit_storage_v3_target_rejects_unsupported_host() -> None:
+    with pytest.raises(PreparedTargetError, match="architecture"):
+        symjit_storage_v3_target(machine="sparc64")
+    with pytest.raises(PreparedTargetError, match="64-bit little-endian"):
+        symjit_storage_v3_target(machine="arm64", word_bits=32)
+
+
+def test_prepared_jit_target_accepts_same_architecture_across_os() -> None:
+    target = symjit_storage_v3_target(machine="AMD64")
+
+    validate_prepared_target(
+        target,
+        backend="jit",
+        symjit_application_abi=SYMJIT_STORAGE_V3_ABI,
+        machine="x86_64",
+        word_bits=64,
+        endianness="little",
+    )
+
+
+def test_prepared_jit_target_accepts_cross_architecture() -> None:
+    target = symjit_storage_v3_target(machine="arm64")
+
+    validate_prepared_target(
+        target,
+        backend="jit",
+        symjit_application_abi=SYMJIT_STORAGE_V3_ABI,
+        machine="x86_64",
+        word_bits=64,
+        endianness="little",
+    )
+
+
+def test_prepared_jit_target_rejects_architecture_scoped_legacy_target() -> None:
+    target = symjit_storage_v3_target(machine="arm64")
+    target["portable"] = False
+    target["target_triple"] = "symjit-storage-v3-aarch64"
+
+    with pytest.raises(PreparedTargetError, match="optimization level 2"):
+        validate_prepared_target(
+            target,
+            backend="jit",
+            symjit_application_abi=SYMJIT_STORAGE_V3_ABI,
+            machine="arm64",
+        )
+
+
+def test_prepared_jit_target_rejects_unknown_application_abi() -> None:
+    with pytest.raises(PreparedTargetError, match="unsupported SymJIT"):
+        validate_prepared_target(
+            symjit_storage_v3_target(machine="arm64"),
+            backend="jit",
+            symjit_application_abi="symjit-application-storage-v4",
+            machine="arm64",
+        )
diff --git a/pyamplicol/tests/unit/test_process_grouping.py b/pyamplicol/tests/unit/test_process_grouping.py
new file mode 100644
index 0000000000..dc93f90e0e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_process_grouping.py
@@ -0,0 +1,232 @@
+# SPDX-License-Identifier: 0BSD
+"""Flavour-profile canonicalization and process-group maps."""
+
+from __future__ import annotations
+
+from fractions import Fraction
+
+import pytest
+
+from pyamplicol.generation.process_grouping import (
+    GroupingBasis,
+    GroupingParticle,
+    GroupingProcess,
+    GroupMember,
+    ParticleType,
+    ProcessGroupMap,
+    candidate_mappings,
+    coarse_key,
+    flavor_blind_classes,
+    flavor_blind_mapping,
+    flavor_class_key,
+    profile_key,
+    profile_mappings,
+    rational_factor,
+    resolved_parameter_name,
+)
+
+_QUARK = ParticleType(2, 3, "ZERO", "ZERO", False)
+_GLUON = ParticleType(3, 8, "ZERO", "ZERO", True)
+_LEPTON = ParticleType(2, 1, "ZERO", "ZERO", False)
+_NAMES = {1: "d", 2: "u", 3: "s", 4: "c", 21: "g", 11: "e-", 12: "ve"}
+
+
+def _table() -> dict[int, GroupingParticle]:
+    table = {}
+    for pdg, name in _NAMES.items():
+        kind = _GLUON if pdg == 21 else _QUARK if pdg < 10 else _LEPTON
+        table[pdg] = GroupingParticle(pdg, name, kind)
+        if not kind.self_conjugate:
+            table[-pdg] = GroupingParticle(-pdg, name + "~", kind)
+    return table
+
+
+TABLE = _table()
+_PDGS = {
+    **{name: pdg for pdg, name in _NAMES.items()},
+    **{name + "~": -pdg for pdg, name in _NAMES.items() if pdg != 21},
+}
+
+
+def process(expression: str, process_id: str | None = None) -> GroupingProcess:
+    initial, final = expression.split(">")
+    pdgs = tuple(_PDGS[name] for name in (*initial.split(), *final.split()))
+    return GroupingProcess(
+        process_id=process_id or expression,
+        expression=expression,
+        pdgs=pdgs,
+        initial_count=len(initial.split()),
+    )
+
+
+def _momentum_labels(member: GroupingProcess, permutation) -> list[str]:
+    """Particle names the representative legs receive from the member."""
+
+    names = {pdg: name for name, pdg in _PDGS.items()}
+    return [names[member.pdgs[index]] for index in permutation]
+
+
+def test_profile_order_follows_flavour_relabelling_where_pdg_order_fails() -> None:
+    first = process("u u~ > d u d~ u~")
+    second = process("d d~ > d u d~ u~")
+
+    assert profile_key(first, TABLE) == profile_key(second, TABLE)
+    (mapping,) = profile_mappings(first, second, TABLE, limit=1)
+    # The representative's "d d~" beams receive the member's "u u~" beams and
+    # its single "u u~" final pair receives the member's "d d~" pair.
+    received = _momentum_labels(first, mapping.permutation)
+    assert received[:2] == ["u", "u~"]
+    representative_names = [
+        {pdg: name for name, pdg in _PDGS.items()}[pdg] for pdg in second.pdgs
+    ]
+    swap = {"u": "d", "d": "u", "u~": "d~", "d~": "u~"}
+    assert [swap[name] for name in received] == representative_names
+
+
+def test_flavour_patterns_are_global_across_initial_and_final_states() -> None:
+    assert profile_key(process("d d~ > u u~"), TABLE) != profile_key(
+        process("d d~ > d d~"), TABLE
+    )
+    assert profile_key(process("g g > d u d~ u~"), TABLE) != profile_key(
+        process("g g > d d d~ d~"), TABLE
+    )
+    assert profile_key(process("g g > d d~"), TABLE) == profile_key(
+        process("g g > u u~"), TABLE
+    )
+    assert profile_key(process("u u~ > d d~"), TABLE) == profile_key(
+        process("d d~ > u u~"), TABLE
+    )
+    assert coarse_key(process("d d~ > u u~"), TABLE) == coarse_key(
+        process("d d~ > d d~"), TABLE
+    )
+
+
+def test_charge_conjugation_is_a_separate_relation_with_reversed_flows() -> None:
+    quark = process("u g > u g")
+    antiquark = process("u~ g > u~ g")
+
+    assert profile_key(quark, TABLE) != profile_key(antiquark, TABLE)
+    assert flavor_class_key(
+        quark, TABLE, consider_charge_conjugation=True
+    ) == flavor_class_key(antiquark, TABLE, consider_charge_conjugation=True)
+    assert flavor_class_key(
+        quark, TABLE, consider_charge_conjugation=False
+    ) != flavor_class_key(antiquark, TABLE, consider_charge_conjugation=False)
+    mapping = flavor_blind_mapping(
+        antiquark, quark, TABLE, consider_charge_conjugation=True
+    )
+    assert mapping.conjugated
+    assert mapping.permutation == (0, 1, 2, 3)
+    with pytest.raises(ValueError, match="flavour relabelling"):
+        flavor_blind_mapping(antiquark, quark, TABLE, consider_charge_conjugation=False)
+
+
+def test_candidate_mappings_cover_ties_conjugation_and_signed_pdg_fallback() -> None:
+    member = process("u c > u c")
+    representative = process("d s > d s")
+    mappings = candidate_mappings(
+        member, representative, TABLE, consider_charge_conjugation=True
+    )
+    permutations = {mapping.permutation for mapping in mappings}
+    # Both pairings of the two tied flavours are offered.
+    assert (0, 1, 2, 3) in permutations
+    assert (1, 0, 3, 2) in permutations
+    fallback = candidate_mappings(
+        process("u d > u d"),
+        process("u d~ > u d~"),
+        TABLE,
+        consider_charge_conjugation=False,
+    )
+    assert [mapping.method for mapping in fallback] == ["signed-pdg"]
+
+
+def test_flavour_blind_classes_choose_the_canonical_representative() -> None:
+    processes = [
+        process(expression, f"p{index}")
+        for index, expression in enumerate(
+            (
+                "u u~ > g g",
+                "d d~ > g g",
+                "u~ u > g g",
+                "u g > u g",
+                "u~ g > u~ g",
+                "d d~ > u u~",
+                "d d~ > d d~",
+            )
+        )
+    ]
+    classes = flavor_blind_classes(processes, TABLE, consider_charge_conjugation=True)
+    by_representative = {
+        group[0].expression: sorted(p.expression for p in group[1:])
+        for group in classes
+    }
+    assert by_representative["d d~ > g g"] == ["u u~ > g g", "u~ u > g g"]
+    assert by_representative["u g > u g"] == ["u~ g > u~ g"]
+    assert by_representative["d d~ > d d~"] == []
+    assert by_representative["d d~ > u u~"] == []
+
+
+def test_group_map_merges_compose_permutations_factors_and_conjugation() -> None:
+    a = process("d d~ > g g", "a")
+    b = process("u u~ > g g", "b")
+    c = process("u~ u > g g", "c")
+    group_map = ProcessGroupMap.trivial([a, b, c])
+    mapping_b = profile_mappings(b, a, TABLE, limit=1)[0]
+    group_map.merge(
+        "a",
+        GroupMember.identity(b).related(
+            mapping_b, factor=Fraction(1), basis=GroupingBasis.NUMERICAL
+        ),
+        TABLE,
+    )
+    mapping_c = profile_mappings(c, b, TABLE, limit=1)[0]
+    assert mapping_c.permutation == (1, 0, 2, 3)
+    group_map.merge(
+        group_map.group_of("a").representative.process_id,  # type: ignore[union-attr]
+        GroupMember.identity(c).related(
+            mapping_c, factor=Fraction(-3, 2), basis=GroupingBasis.NUMERICAL
+        ),
+        TABLE,
+    )
+    (group,) = group_map.groups.values()
+    assert group.representative.process_id == "a"
+    members = {member.process_id: member for member in group.members}
+    assert members["c"].factor == Fraction(-3, 2)
+    assert members["c"].permutation == (1, 0, 2, 3)
+    assert members["b"].basis is GroupingBasis.NUMERICAL
+
+    restored = ProcessGroupMap.from_json(group_map.to_json())
+    assert restored.as_document() == group_map.as_document()
+
+
+def test_merge_keeps_the_smaller_representative_and_inverts_the_link() -> None:
+    small = process("d d~ > g g", "small")
+    large = process("u u~ > g g", "large")
+    group_map = ProcessGroupMap.trivial([small, large])
+    mapping = profile_mappings(small, large, TABLE, limit=1)[0]
+    kept = group_map.merge(
+        "large",
+        GroupMember.identity(small).related(
+            mapping, factor=Fraction(2), basis=GroupingBasis.NUMERICAL
+        ),
+        TABLE,
+    )
+    assert kept == "small"
+    members = {m.process_id: m for m in group_map.groups["small"].members}
+    assert members["large"].factor == Fraction(1, 2)
+
+
+def test_rational_factor_and_parameter_resolution() -> None:
+    assert rational_factor(4.0 + 1e-13, tolerance=1e-9) == Fraction(4)
+    assert rational_factor(-0.5, tolerance=1e-9) == Fraction(-1, 2)
+    assert rational_factor(3.14159, tolerance=1e-9) is None
+    assert rational_factor(150.0, tolerance=1e-9) is None
+
+    class Record:
+        def __init__(self, resolved: str) -> None:
+            self.resolved_expression = resolved
+
+    parameters = {"MC": Record("0"), "MB": Record("model::MB")}
+    assert resolved_parameter_name("MC", parameters) == "ZERO"
+    assert resolved_parameter_name("ZERO", parameters) == "ZERO"
+    assert resolved_parameter_name("MB", parameters) == "MB"
diff --git a/pyamplicol/tests/unit/test_process_grouping_numerical.py b/pyamplicol/tests/unit/test_process_grouping_numerical.py
new file mode 100644
index 0000000000..3e1dcaf5c6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_process_grouping_numerical.py
@@ -0,0 +1,303 @@
+# SPDX-License-Identifier: 0BSD
+"""Component matching of the numerical process-group analysis."""
+
+from __future__ import annotations
+
+import math
+from fractions import Fraction
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.api.process_groups import group_processes
+from pyamplicol.api.results import ResolvedEvaluation
+from pyamplicol.generation.process_grouping import LegMapping
+from pyamplicol.generation.process_grouping_numerical import (
+    PARAMETER_VARIATION,
+    accepted_factor,
+    color_roles,
+    common_factor,
+    flow_key,
+    member_point,
+    on_shell_point,
+    parameter_variation,
+    resolved_components,
+)
+
+_COLORS = {1: 3, -1: -3, 2: 3, -2: -3, 21: 8, 22: 1}
+_IDENTITY = tuple(range(4))
+
+
+def _resolved(
+    helicities: dict[str, tuple[int, ...]],
+    flows: tuple[str, ...],
+    values: dict[tuple[str, str], complex],
+    accuracy: str = "lc",
+) -> ResolvedEvaluation:
+    return ResolvedEvaluation(
+        values=(
+            tuple(
+                tuple(values.get((helicity, flow), 0j) for flow in flows)
+                for helicity in helicities
+            ),
+        ),
+        helicity_ids=tuple(helicities),
+        color_ids=flows,
+        color_accuracy=accuracy,  # type: ignore[arg-type]
+    )
+
+
+def test_color_roles_cross_initial_fundamentals() -> None:
+    # u g > u g: the incoming quark is an outgoing antifundamental.
+    assert color_roles((2, 21, 2, 21), 2, _COLORS) == (-3, 8, 3, 8)
+    assert color_roles((-2, 21, -2, 22), 2, _COLORS) == (3, 8, -3, 1)
+
+
+def test_flow_keys_compare_lines_as_sets_and_traces_up_to_rotation() -> None:
+    roles = (3, -3, 3, -3)
+    first = flow_key((0, 1, 2, 3), roles, _IDENTITY, reverse=False)
+    assert first == flow_key((2, 3, 0, 1), roles, _IDENTITY, reverse=False)
+    assert first != flow_key((0, 3, 2, 1), roles, _IDENTITY, reverse=False)
+
+    gluons = (8, 8, 8, 8)
+    trace = flow_key((0, 1, 2, 3), gluons, _IDENTITY, reverse=False)
+    assert trace == flow_key((2, 3, 0, 1), gluons, _IDENTITY, reverse=False)
+    # The reflected trace is a different colour flow ...
+    reflected = flow_key((0, 3, 2, 1), gluons, _IDENTITY, reverse=False)
+    assert trace != reflected
+    # ... which charge conjugation reaches.
+    assert trace == flow_key((0, 3, 2, 1), gluons, _IDENTITY, reverse=True)
+    # A relabelling moves the trace onto the target legs.
+    assert flow_key((0, 1, 2, 3), gluons, (1, 0, 2, 3), reverse=False) == (
+        "trace",
+        (0, 2, 3, 1),
+    )
+
+
+def test_conjugated_lines_reverse_into_the_representative_orientation() -> None:
+    # Member u~ g > u~ g, representative u g > u g, identity legs.
+    member_roles = color_roles((-2, 21, -2, 21), 2, _COLORS)
+    representative_roles = color_roles((2, 21, 2, 21), 2, _COLORS)
+    member = flow_key((0, 1, 3, 2), member_roles, _IDENTITY, reverse=True)
+    assert member == flow_key(
+        (2, 3, 1, 0), representative_roles, _IDENTITY, reverse=False
+    )
+    # Without conjugation the line runs against the representative's.
+    assert member != flow_key((0, 1, 3, 2), member_roles, _IDENTITY, reverse=False)
+    assert flow_key((0, 1, 3, 2), member_roles, _IDENTITY, reverse=False) not in {
+        flow_key(word, representative_roles, _IDENTITY, reverse=False)
+        for word in ((2, 3, 1, 0), (2, 1, 3, 0))
+    }
+
+
+def test_undecodable_words_are_kept_verbatim() -> None:
+    assert flow_key((0, 1), (-3, 3), (1, 0), reverse=False) == ("word", (1, 0))
+    assert flow_key((0, 1), (6, -6), (0, 1), reverse=True) == ("word", (1, 0))
+
+
+def _gq_process() -> tuple[dict[str, tuple[int, ...]], dict[str, tuple[int, ...]]]:
+    # u g > u g g
+    helicities = {
+        "h:a": (-1, 1, -1, 1, 1),
+        "h:b": (1, 1, 1, -1, 1),
+        "h:c": (1, -1, 1, 1, -1),
+    }
+    flows = {"flow:x": (2, 1, 3, 4, 0), "flow:y": (2, 3, 4, 1, 0)}
+    return helicities, flows
+
+
+def test_resolved_components_permute_helicities_and_relabel_flows() -> None:
+    # Representative u g > u g g, member u g > g u g: representative leg r is
+    # member leg perm[r]. The final legs are cycled, so perm is not its own
+    # inverse and the direction of the convention matters.
+    permutation = (0, 1, 3, 4, 2)
+
+    def to_member(legs: tuple[int, ...]) -> tuple[int, ...]:
+        member = [0] * len(legs)
+        for representative_index, value in enumerate(legs):
+            member[permutation[representative_index]] = value
+        return tuple(member)
+
+    helicities, flows = _gq_process()
+    pdgs = (2, 21, 2, 21, 21)
+    values = {
+        ("h:a", "flow:x"): 2.0,
+        ("h:a", "flow:y"): 3.0,
+        ("h:b", "flow:y"): 7.0,
+        ("h:c", "flow:x"): 5.0,
+    }
+    representative = resolved_components(
+        _resolved(helicities, tuple(flows), values),
+        0,
+        helicities=helicities,
+        words=flows,
+        roles=color_roles(pdgs, 2, _COLORS),
+        mapping=None,
+    )
+
+    member_helicities = {key: to_member(value) for key, value in helicities.items()}
+    member_flows = {
+        key: tuple(permutation[i] for i in word) for key, word in flows.items()
+    }
+    assert to_member(pdgs) == (2, 21, 21, 2, 21)
+    member_resolved = _resolved(
+        member_helicities,
+        tuple(member_flows),
+        {key: -1.5 * value for key, value in values.items()},
+    )
+
+    def member(mapping: LegMapping) -> dict:
+        return resolved_components(
+            member_resolved,
+            0,
+            helicities=member_helicities,
+            words=member_flows,
+            roles=color_roles(to_member(pdgs), 2, _COLORS),
+            mapping=mapping,
+        )
+
+    related = member(LegMapping(permutation, False, "flavor-profile"))
+    assert related.keys() == representative.keys()
+    assert common_factor([related], [representative]) == pytest.approx(-1.5)
+    assert accepted_factor(
+        common_factor([related], [representative]), only_unit_multiplier=False
+    ) == Fraction(-3, 2)
+
+    # The inverse permutation, the opposite convention, is rejected.
+    inverse = LegMapping((0, 1, 4, 2, 3), False, "signed-pdg")
+    assert common_factor([member(inverse)], [representative]) is None
+
+
+def test_common_factor_requires_one_ratio_and_shared_zeros() -> None:
+    key = ((1, 1), "c")
+    other = ((1, -1), "c")
+    third = ((-1, -1), "c")
+    representative = [{key: 4.0 + 0j, other: 1.0 + 0j, third: 0j}] * 2
+    assert common_factor(
+        [{key: 64.0 + 0j, other: 16.0 + 0j, third: 0j}] * 2, representative
+    ) == pytest.approx(16.0)
+    # Components absent on one side are zero there.
+    assert common_factor([{key: 64.0 + 0j, other: 16.0 + 0j}] * 2, representative)
+    # Numerical noise far below the largest component is zero.
+    noisy = {key: 64.0 + 0j, other: 16.0 + 0j, third: 1e-15 + 0j}
+    assert common_factor([noisy] * 2, representative) == pytest.approx(16.0)
+    # A zero must be zero on both sides.
+    assert (
+        common_factor([{key: 64.0 + 0j, other: 0j, third: 0j}] * 2, representative)
+        is None
+    )
+    assert (
+        common_factor(
+            [{key: 64.0 + 0j, other: 16.0 + 0j, third: 1e-3 + 0j}] * 2,
+            representative,
+        )
+        is None
+    )
+    # Components disagree, or the ratio changes between points.
+    assert (
+        common_factor([{key: 64.0 + 0j, other: 17.0 + 0j}] * 2, representative) is None
+    )
+    assert (
+        common_factor(
+            [
+                {key: 64.0 + 0j, other: 16.0 + 0j},
+                {key: 32.0 + 0j, other: 8.0 + 0j},
+            ],
+            representative,
+        )
+        is None
+    )
+    # A vanishing point decides nothing.
+    assert common_factor([{key: 0j}], [{key: 1.0 + 0j}]) is None
+
+
+def test_accepted_factor_is_rational_real_and_optionally_unit() -> None:
+    assert accepted_factor(16.0 + 0j, only_unit_multiplier=False) == 16
+    assert accepted_factor(16.0 + 0j, only_unit_multiplier=True) is None
+    assert accepted_factor(1.0 + 1e-14j, only_unit_multiplier=True) == 1
+    assert accepted_factor(1.0 + 1e-3j, only_unit_multiplier=False) is None
+    assert accepted_factor(math.pi + 0j, only_unit_multiplier=False) is None
+    assert accepted_factor(None, only_unit_multiplier=False) is None
+
+
+def _parameter(name: str, kind: str, value: float, *, mutable: bool = True):
+    return SimpleNamespace(
+        name=name,
+        kind=kind,
+        default_real=value,
+        default_imaginary=0.0,
+        mutable=mutable,
+    )
+
+
+def test_parameter_variation_is_per_name_deterministic_and_bounded() -> None:
+    parameters = [
+        _parameter("aEWM1", "external", 132.5),
+        _parameter("normalization.alpha_s", "normalization", 0.118),
+        _parameter("MW", "derived", 80.4, mutable=False),
+        _parameter("particle.6.mass", "mass", 173.0),
+        _parameter("particle.6.width", "width", 1.5),
+        _parameter("coupling.1.component_0", "coupling", 0.5),
+        # UFO masses and widths are external inputs, but stay fixed.
+        _parameter("MZ", "external", 91.188),
+        _parameter("WZ", "external", 2.44),
+    ]
+    first = parameter_variation(parameters, point=0, fixed={"MZ", "WZ"})
+    assert set(first) == {"aEWM1", "normalization.alpha_s"}
+    assert first == parameter_variation(parameters[:2], point=0)
+    assert first != parameter_variation(parameters, point=1, fixed={"MZ", "WZ"})
+    for parameter in parameters[:2]:
+        ratio = first[parameter.name] / parameter.default_real
+        assert abs(ratio - 1.0) <= PARAMETER_VARIATION
+        assert ratio != 1.0
+
+
+def _mass_squared(momentum) -> float:
+    energy, x, y, z = momentum
+    return energy * energy - x * x - y * y - z * z
+
+
+@pytest.mark.parametrize(
+    ("initial", "final"),
+    (
+        ((0.0, 0.0), (0.0, 0.0, 0.0)),
+        ((80.0, 173.0), (91.0, 0.0)),
+        ((125.0,), (4.7, 4.7)),
+        ((0.0, 0.0), (125.0,)),
+    ),
+)
+def test_on_shell_points_conserve_momentum_with_massive_legs(initial, final) -> None:
+    point = on_shell_point(initial, final, seed=7)
+    assert point is not None
+    count = len(initial)
+    for leg, mass in zip(point, (*initial, *final), strict=True):
+        assert _mass_squared(leg) == pytest.approx(mass * mass, abs=1e-9 * leg[0] ** 2)
+    for component in range(4):
+        incoming = sum(leg[component] for leg in point[:count])
+        outgoing = sum(leg[component] for leg in point[count:])
+        assert incoming == pytest.approx(outgoing, abs=1e-8)
+    assert point == on_shell_point(initial, final, seed=7)
+
+
+def test_on_shell_point_reports_closed_phase_space() -> None:
+    assert on_shell_point((4.7,), (125.0, 0.0), seed=1) is None
+    assert on_shell_point((100.0, 100.0), (150.0,), seed=1) is None
+
+
+def test_member_point_follows_the_relation_convention() -> None:
+    # A cycle of the final legs, which is not its own inverse.
+    permutation = (0, 1, 3, 4, 2)
+    representative = tuple((float(index), 0.0, 0.0, 0.0) for index in range(5))
+    member = member_point(representative, permutation)
+    assert [leg[0] for leg in member] == [0.0, 1.0, 4.0, 2.0, 3.0]
+    for representative_index, member_index in enumerate(permutation):
+        assert representative[representative_index] == member[member_index]
+
+
+def test_group_processes_validates_its_arguments(tmp_path) -> None:
+    with pytest.raises(ValueError, match="analysis"):
+        group_processes(tmp_path, analysis="exact")
+    with pytest.raises(TypeError, match="only_unit_multiplier"):
+        group_processes(tmp_path, only_unit_multiplier=1)  # type: ignore[arg-type]
+    with pytest.raises(FileNotFoundError):
+        group_processes(tmp_path / "missing")
diff --git a/pyamplicol/tests/unit/test_process_ir_extraction.py b/pyamplicol/tests/unit/test_process_ir_extraction.py
new file mode 100644
index 0000000000..8ca0e483c8
--- /dev/null
+++ b/pyamplicol/tests/unit/test_process_ir_extraction.py
@@ -0,0 +1,167 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.contracts import CompiledModelIR, CompiledParticleRecord
+from pyamplicol.processes.model import build_model_process_ir
+
+
+def _record(
+    name: str,
+    antiname: str,
+    pdg: int,
+    spin: int,
+    color: int,
+) -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=antiname,
+        pdg_code=pdg,
+        spin=spin,
+        color=color,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def test_process_ir_preserves_physical_and_all_outgoing_order() -> None:
+    ir = build_process_ir("d d~ > Z g")
+
+    assert ir.process == "d d~ > z g"
+    assert ir.key == "d_dbar_to_z_g"
+    assert tuple(leg.particle for leg in ir.legs) == ("d", "d~", "z", "g")
+    assert tuple(leg.outgoing_particle for leg in ir.legs) == (
+        "d~",
+        "d",
+        "z",
+        "g",
+    )
+    assert ir.initial_pdgs == (1, -1)
+    assert ir.final_pdgs == (23, 21)
+    assert ir.outgoing_pdgs == (-1, 1, 23, 21)
+    assert tuple(leg.statistics for leg in ir.legs) == (
+        "fermion",
+        "fermion",
+        "boson",
+        "boson",
+    )
+    assert tuple(leg.wavefunction_family for leg in ir.legs) == (
+        "fermion",
+        "fermion",
+        "vector",
+        "vector",
+    )
+    assert tuple(leg.color_role for leg in ir.legs) == (
+        "antifundamental",
+        "fundamental",
+        "singlet",
+        "adjoint",
+    )
+    assert tuple(leg.source_orientation for leg in ir.legs) == (
+        "antiparticle",
+        "particle",
+        "self-conjugate",
+        "self-conjugate",
+    )
+    assert ir.fundamental_labels == (2,)
+    assert ir.antifundamental_labels == (1,)
+    assert ir.adjoint_labels == (4,)
+    assert ir.singlet_labels == (3,)
+    assert ir.color_endpoints.fundamental_count == 1
+    assert ir.color_endpoints.antifundamental_count == 1
+    assert ir.color_endpoints.pair_count == 1
+
+
+def test_process_external_model_uses_the_same_crossing_contract() -> None:
+    particles = (
+        _record("state_f", "state_af", 810_001, 2, 3),
+        _record("state_af", "state_f", -810_001, 2, -3),
+        _record("state_s", "state_s", 710_001, 3, 1),
+        _record("state_a", "state_a", 910_101, 3, 8),
+    )
+    model = CompiledModelIR(
+        name="opaque-role-model",
+        orders=(),
+        parameters=(),
+        particles=particles,
+        couplings=(),
+        propagators=(),
+        vertex_terms=(),
+        oriented_kernels=(),
+        direct_contractions=(),
+        closure_contractions=(),
+    )
+
+    ir = build_model_process_ir(
+        "state_f state_af > state_s state_a",
+        model,
+    )
+
+    assert ir.process == "state_f state_af > state_s state_a"
+    assert ir.outgoing_pdgs == (-810_001, 810_001, 710_001, 910_101)
+    assert tuple(leg.label for leg in ir.legs) == (1, 2, 3, 4)
+    assert tuple(leg.statistics for leg in ir.legs) == (
+        "fermion",
+        "fermion",
+        "boson",
+        "boson",
+    )
+    assert tuple(leg.wavefunction_family for leg in ir.legs) == (
+        "fermion",
+        "fermion",
+        "vector",
+        "vector",
+    )
+    assert tuple(leg.color_role for leg in ir.legs) == (
+        "antifundamental",
+        "fundamental",
+        "singlet",
+        "adjoint",
+    )
+    assert tuple(leg.source_orientation for leg in ir.legs) == (
+        "antiparticle",
+        "particle",
+        "self-conjugate",
+        "self-conjugate",
+    )
+    assert ir.fundamental_labels == (2,)
+    assert ir.antifundamental_labels == (1,)
+    assert ir.adjoint_labels == (4,)
+    assert ir.singlet_labels == (3,)
+    assert ir.color_endpoints.pair_count == 1
+
+
+def test_process_json_exposes_only_structural_roles() -> None:
+    payload = build_process_ir("d d~ > Z g").to_json_dict()
+
+    assert payload["color_endpoints"] == {
+        "fundamental_count": 1,
+        "antifundamental_count": 1,
+        "pair_count": 1,
+        "balanced": True,
+    }
+    assert payload["color_role_labels"] == {
+        "fundamental": [2],
+        "antifundamental": [1],
+        "adjoint": [4],
+        "singlet": [3],
+    }
+    assert "quark_lines" not in payload
+    assert "labels" not in payload
+    assert all("particle_class" not in leg for leg in payload["legs"])
+    assert all(
+        {
+            "statistics",
+            "wavefunction_family",
+            "color_role",
+            "source_orientation",
+        }
+        <= leg.keys()
+        for leg in payload["legs"]
+    )
diff --git a/pyamplicol/tests/unit/test_process_legacy_quarantine.py b/pyamplicol/tests/unit/test_process_legacy_quarantine.py
new file mode 100644
index 0000000000..c0d28161b1
--- /dev/null
+++ b/pyamplicol/tests/unit/test_process_legacy_quarantine.py
@@ -0,0 +1,114 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+REPOSITORY_ROOT = Path(__file__).resolve().parents[2]
+SOURCE_ROOT = REPOSITORY_ROOT / "src"
+
+
+def _assert_isolated_import_does_not_load_builtin(statement: str) -> None:
+    script = "\n".join(
+        (
+            "import sys",
+            f"sys.path.insert(0, {str(SOURCE_ROOT)!r})",
+            statement,
+            "loaded = sorted(name for name in sys.modules ",
+            "    if name == 'pyamplicol.models.builtin' ",
+            "    or name.startswith('pyamplicol.models.builtin.'))",
+            "assert loaded == [], loaded",
+        )
+    )
+    environment = os.environ.copy()
+    environment.pop("PYTHONPATH", None)
+    completed = subprocess.run(
+        [sys.executable, "-I", "-c", script],
+        cwd=REPOSITORY_ROOT,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert completed.returncode == 0, completed.stderr
+
+
+@pytest.mark.parametrize(
+    "statement",
+    (
+        "import pyamplicol.processes",
+        "import pyamplicol.processes.ir",
+        "import pyamplicol.processes.model",
+        "import pyamplicol.generation.service",
+        "from pyamplicol.processes import ProcessTuple, canonical_process_key",
+    ),
+)
+def test_generic_process_imports_do_not_load_builtin_physics(statement: str) -> None:
+    _assert_isolated_import_does_not_load_builtin(statement)
+
+
+@pytest.mark.parametrize(
+    "name",
+    (
+        "QUARKS",
+        "ANTIQUARKS",
+        "GLUONS",
+        "SINGLETS",
+        "ALL_COLOURED",
+        "PDGS",
+        "ANTI_PARTICLE",
+        "SORT_PARTICLES",
+        "CHARGES3",
+        "FAMILY",
+        "ProcessOptions",
+        "ProcessEnumeration",
+        "ProcessSelectionRecord",
+        "ProcessSelectionReport",
+        "ProcessSetEntry",
+        "ProcessSetEnumeration",
+        "SubprocessRecord",
+        "ProcessEnumerator",
+        "build_generic_process_selection_report",
+        "enumerate_generic_process_set",
+        "enumerate_process_set",
+        "enumerate_processes",
+    ),
+)
+def test_generic_process_package_has_no_builtin_catalog_or_records(name: str) -> None:
+    import pyamplicol.processes as processes
+
+    assert not hasattr(processes, name)
+
+
+@pytest.mark.parametrize(
+    "module_name",
+    (
+        "pyamplicol.processes.core",
+        "pyamplicol.processes.enumeration",
+        "pyamplicol.processes.selection",
+    ),
+)
+def test_builtin_process_facades_are_removed(module_name: str) -> None:
+    with pytest.raises(ModuleNotFoundError):
+        __import__(module_name)
+
+
+def test_builtin_process_records_are_model_scoped() -> None:
+    from pyamplicol.models.builtin.process_types import BuiltinProcessOptions
+
+    options = BuiltinProcessOptions(flavour_scheme=4, include_cc=True)
+
+    assert options.flavour_scheme == 4
+    assert options.include_cc is True
+
+
+def test_generic_process_ir_has_no_builtin_construction_facade() -> None:
+    import pyamplicol.processes.ir as process_ir
+
+    assert not hasattr(process_ir, "build_process_ir")
+    assert not hasattr(process_ir, "build_process_set_ir")
diff --git a/pyamplicol/tests/unit/test_process_selection.py b/pyamplicol/tests/unit/test_process_selection.py
new file mode 100644
index 0000000000..1a7ede2939
--- /dev/null
+++ b/pyamplicol/tests/unit/test_process_selection.py
@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import pytest
+
+from pyamplicol.models.builtin.process_selection import (
+    build_generic_process_selection_report,
+    enumerate_generic_process_set,
+)
+
+
+def test_generic_selection_accepts_model_driven_pure_singlet_processes() -> None:
+    enumeration = enumerate_generic_process_set("e- e+ > mu- mu+")
+
+    assert tuple(entry.process for entry in enumeration.entries) == ("e- e+ > mu- mu+",)
+
+
+def test_generic_selection_still_rejects_charge_violating_singlets() -> None:
+    with pytest.raises(ValueError, match="no valid processes"):
+        enumerate_generic_process_set("e- e- > mu- mu+")
+
+
+@pytest.mark.parametrize(
+    ("process", "expected_quark_lines"),
+    (
+        ("d d~ > u u~ s s~ c c~", 4),
+        ("d d~ > u u~ s s~ c c~ b b~", 5),
+    ),
+)
+def test_generic_selection_has_no_default_open_quark_line_ceiling(
+    process: str,
+    expected_quark_lines: int,
+) -> None:
+    report = build_generic_process_selection_report(process)
+
+    assert report.selected_count == 1
+    assert report.entries[0].process == process
+    assert report.records[0].quark_lines == expected_quark_lines
+
+
+def test_generic_selection_honors_an_explicit_open_quark_line_ceiling() -> None:
+    process = "d d~ > u u~ s s~ c c~ b b~"
+    report = build_generic_process_selection_report(
+        process,
+        max_quark_pairs=4,
+    )
+
+    assert report.selected_count == 0
+    assert report.rejection_counts == (("max-quark-lines", 1),)
+    with pytest.raises(ValueError, match="no valid processes"):
+        enumerate_generic_process_set(process, max_quark_pairs=4)
diff --git a/pyamplicol/tests/unit/test_profile_warmup_reporting.py b/pyamplicol/tests/unit/test_profile_warmup_reporting.py
new file mode 100644
index 0000000000..1efe119547
--- /dev/null
+++ b/pyamplicol/tests/unit/test_profile_warmup_reporting.py
@@ -0,0 +1,372 @@
+# SPDX-License-Identifier: 0BSD
+"""Focused public-profile warm-up timing and presentation contracts."""
+
+from __future__ import annotations
+
+from types import MappingProxyType, SimpleNamespace
+
+import pytest
+
+from pyamplicol import benchmarking
+from pyamplicol.config import BenchmarkConfig
+from pyamplicol.reporting.summary import render_summary
+from tools.performance_report.runner import (
+    CONVENTIONAL_WARMUP_FIELDS,
+    CONVENTIONAL_WARMUP_TIMING_SCOPE,
+    OTF_ACTIVE_FAMILY_COUNT_FIELDS,
+    OTF_COLD_WARMUP_FIELDS,
+    OTF_COLD_WARMUP_RUNTIME_FRESHNESS,
+    OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE,
+    OTF_COLD_WARMUP_TIMING_SCOPE,
+    OTF_RUNTIME_STATE_CENSUS_KIND,
+    OTF_RUNTIME_STATE_COUNT_FIELDS,
+    OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT,
+    OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY,
+    OTF_RUNTIME_STATE_RETAINED_BASE_POSITIVE_FIELDS,
+    OTF_RUNTIME_STATE_RETAINED_EXECUTABLE_FIELDS,
+    WARMUP_TIMER_SOURCE,
+    RunnerError,
+    _benchmark_measurement,
+)
+
+
+def _otf_runtime_state(*, retained: bool) -> dict[str, object]:
+    counts = {field: 0 for field in OTF_RUNTIME_STATE_COUNT_FIELDS}
+    active: dict[str, object] | None = None
+    if retained:
+        counts.update(
+            {
+                field: 1
+                for field in (
+                    *OTF_RUNTIME_STATE_RETAINED_BASE_POSITIVE_FIELDS,
+                    *OTF_RUNTIME_STATE_RETAINED_EXECUTABLE_FIELDS,
+                )
+            }
+        )
+        active = {
+            "basis": "shared-query-family-union-v1",
+            "scope": "active-family-union",
+            **{field: 1 for field in OTF_ACTIVE_FAMILY_COUNT_FIELDS},
+        }
+    return {
+        "kind": OTF_RUNTIME_STATE_CENSUS_KIND,
+        "process_id": "otf_test",
+        "family_cache_policy": OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY,
+        "family_cache_limit": OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT,
+        **counts,
+        "active_family_union_census": active,
+    }
+
+
+class _OnTheFlyRuntime:
+    execution_mode = "on-the-fly"
+    supports_profiling = False
+
+    def __init__(self) -> None:
+        self.evaluate_calls: list[tuple[int, object, object, int]] = []
+        self.retained = False
+
+    @property
+    def physics(self) -> object:
+        return SimpleNamespace()
+
+    def _on_the_fly_benchmark_context(
+        self, requested: tuple[str, ...]
+    ) -> dict[str, object]:
+        assert requested == ()
+        return {
+            "process_id": "otf_test",
+            "process_expression": "d d~ > z",
+            "color_accuracy": "lc",
+            "helicity_count": 2,
+            "color_count": 1,
+            "selected_color_ids": [],
+        }
+
+    def evaluate(
+        self,
+        momenta: object,
+        *,
+        helicities: object = None,
+        color_flows: object = None,
+        precision: int = 16,
+    ) -> tuple[complex, ...]:
+        batch = tuple(momenta)  # type: ignore[arg-type]
+        self.evaluate_calls.append((len(batch), helicities, color_flows, precision))
+        self.retained = True
+        return tuple(1.0 + 0.0j for _ in batch)
+
+    def _on_the_fly_runtime_state_census(self) -> dict[str, object]:
+        return _otf_runtime_state(retained=self.retained)
+
+    def evaluate_resolved(self, *_args: object, **_kwargs: object) -> object:
+        raise AssertionError("resolved evaluation is not part of profiling")
+
+    def set_model_parameters(self, _mapping: object) -> None:
+        return None
+
+    def clear(self) -> None:
+        return None
+
+    def mute_warnings(self) -> None:
+        return None
+
+    def unmute_warnings(self) -> None:
+        return None
+
+
+def test_otf_initial_preparation_and_conventional_warmups_are_separate(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock = iter(
+        (
+            0.000,
+            0.000,
+            0.010,
+            0.012,
+            0.020,
+            0.021,
+            0.025,
+            0.026,
+            0.030,
+            0.031,
+            0.034,
+            0.035,
+            0.040,
+            0.041,
+            0.050,
+            0.051,
+            0.053,
+            0.054,
+        )
+    )
+    monkeypatch.setattr(benchmarking.time, "perf_counter", lambda: next(clock))
+    monkeypatch.setattr(
+        benchmarking,
+        "_calibrate_repetitions",
+        lambda *_args, **_kwargs: benchmarking._Calibration(
+            sample_count=1,
+            repetitions_per_sample=1,
+            target_sample_seconds=0.001,
+            probe_seconds=0.004,
+            block_count=0,
+            evaluation_count=0,
+            elapsed_seconds=0.0,
+        ),
+    )
+    config = BenchmarkConfig(
+        target_runtime=0.001,
+        batch_size=3,
+        precision=16,
+        warmup_runs=2,
+        minimum_samples=1,
+    )
+    runtime = _OnTheFlyRuntime()
+    result = benchmarking.BenchmarkBackend(config, None).run(
+        runtime,
+        points=(((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    environment = result.environment
+    assert environment["cold_warmup_elapsed_seconds"] == pytest.approx(0.012)
+    assert environment["cold_warmup_run_count"] == 1
+    assert environment["cold_warmup_batch_size"] == 3
+    assert environment["cold_warmup_point_count"] == 3
+    assert environment["cold_warmup_runtime_freshness"] == (
+        OTF_COLD_WARMUP_RUNTIME_FRESHNESS
+    )
+    assert environment["cold_warmup_runtime_state_evidence"] == (
+        OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE
+    )
+    assert environment["cold_warmup_runtime_cold_before_first_evaluation"] is True
+    assert environment["cold_warmup_runtime_retained_before_first_evaluation"] is False
+    assert environment["cold_warmup_runtime_retained_after_first_evaluation"] is True
+    assert environment["cold_warmup_ratio_eligible"] is False
+    assert environment["cold_warmup_acceptance_eligible"] is False
+    assert environment["cold_warmup_timer_source"] == WARMUP_TIMER_SOURCE
+    assert environment["cold_warmup_timing_scope"] == OTF_COLD_WARMUP_TIMING_SCOPE
+    assert "Runtime/artifact load are excluded" in str(
+        environment["cold_warmup_timing_scope"]
+    )
+
+    assert environment["warmup_elapsed_seconds"] == pytest.approx(0.011)
+    assert environment["warmup_configured_run_count"] == 2
+    assert environment["warmup_batch_size"] == 3
+    assert environment["warmup_point_count"] == 6
+    assert environment["warmup_run_outer_wall_seconds"] == pytest.approx((0.006, 0.005))
+    assert environment["first_warmup_run_outer_wall_seconds"] == pytest.approx(0.006)
+    assert environment["warmup_timer_source"] == WARMUP_TIMER_SOURCE
+    assert environment["warmup_timing_scope"] == CONVENTIONAL_WARMUP_TIMING_SCOPE
+    assert len(runtime.evaluate_calls) == 4
+    assert result.wall_time_per_point == pytest.approx(0.004 / 3.0)
+    assert result.evaluator_total_time_per_point == pytest.approx(0.002 / 3.0)
+
+    rendered = render_summary(result, color=True)
+    assert rendered is not None
+    assert "OTF runtime state" in rendered
+    assert "authenticated native census: cold -> strictly retained" in rendered
+    assert "OTF family cache" in rendered
+    assert "last-family-only; limit 1; retained families 0 -> 1" in rendered
+    assert "OTF initial preparation" in rendered
+    assert "12 ms" in rendered
+    assert "runtime freshness not authenticated here" not in rendered
+    assert "warm-up wall (total)" in rendered
+    assert "11 ms" in rendered
+    assert "first warm-up run" in rendered
+    assert "6 ms" in rendered
+    assert "\x1b[" in rendered
+
+
+def _complete_otf_profile_environment() -> dict[str, object]:
+    return {
+        "execution_mode": "on-the-fly",
+        "batch_size": 128,
+        "evaluator_time_raw_seconds_per_point": 8.0e-7,
+        "evaluator_time_status": "measured",
+        "evaluator_time_ratio_eligible": True,
+        "evaluator_time_source": "runtime_profile_core_recurrence_schedule_time",
+        "native_profile_points_per_sample": 128,
+        "timing_sample_contract": "paired-native-repeated-profile-v1",
+        "elapsed_seconds": 1.0,
+        "cold_warmup_elapsed_seconds": 4.767252833,
+        "cold_warmup_run_count": 1,
+        "cold_warmup_batch_size": 128,
+        "cold_warmup_point_count": 128,
+        "cold_warmup_timer_source": WARMUP_TIMER_SOURCE,
+        "cold_warmup_timing_scope": OTF_COLD_WARMUP_TIMING_SCOPE,
+        "cold_warmup_runtime_freshness": OTF_COLD_WARMUP_RUNTIME_FRESHNESS,
+        "cold_warmup_runtime_state_evidence": (OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE),
+        "cold_warmup_runtime_state_before": _otf_runtime_state(retained=False),
+        "cold_warmup_runtime_state_after": _otf_runtime_state(retained=True),
+        "cold_warmup_runtime_cold_before_first_evaluation": True,
+        "cold_warmup_runtime_retained_before_first_evaluation": False,
+        "cold_warmup_runtime_retained_after_first_evaluation": True,
+        "cold_warmup_ratio_eligible": False,
+        "cold_warmup_acceptance_eligible": False,
+        "warmup_elapsed_seconds": 0.021,
+        "warmup_configured_run_count": 2,
+        "warmup_batch_size": 128,
+        "warmup_point_count": 256,
+        "warmup_run_outer_wall_seconds": (0.010, 0.011),
+        "first_warmup_run_outer_wall_seconds": 0.010,
+        "warmup_timer_source": WARMUP_TIMER_SOURCE,
+        "warmup_timing_scope": CONVENTIONAL_WARMUP_TIMING_SCOPE,
+    }
+
+
+def _complete_otf_benchmark() -> SimpleNamespace:
+    return SimpleNamespace(
+        uncertainty=SimpleNamespace(
+            standard_error=1.0e-8,
+            relative_standard_error=0.01,
+        ),
+        environment=_complete_otf_profile_environment(),
+        evaluator_time_per_point=8.0e-7,
+        wall_time_per_point=1.0e-6,
+        sample_count=5,
+        effective_config=SimpleNamespace(
+            target_runtime=1.0,
+            batch_size=128,
+            warmup_runs=2,
+        ),
+    )
+
+
+def test_campaign_preserves_complete_cold_and_conventional_warmup_evidence() -> None:
+    measurement = _benchmark_measurement(
+        _complete_otf_benchmark(),
+        matrix_element=2.0,
+    )
+
+    evidence = measurement["benchmark_evidence"]
+    expected = OTF_COLD_WARMUP_FIELDS | CONVENTIONAL_WARMUP_FIELDS
+    assert expected <= evidence.keys()
+    source = _complete_otf_profile_environment()
+    assert {field: evidence[field] for field in expected} == {
+        field: source[field] for field in expected
+    }
+
+
+def test_campaign_materializes_frozen_runtime_census_snapshots() -> None:
+    benchmark = _complete_otf_benchmark()
+    for field in (
+        "cold_warmup_runtime_state_before",
+        "cold_warmup_runtime_state_after",
+    ):
+        state = dict(benchmark.environment[field])
+        active = state["active_family_union_census"]
+        if isinstance(active, dict):
+            state["active_family_union_census"] = MappingProxyType(active)
+        benchmark.environment[field] = MappingProxyType(state)
+
+    measurement = _benchmark_measurement(benchmark, matrix_element=2.0)
+
+    evidence = measurement["benchmark_evidence"]
+    assert isinstance(evidence["cold_warmup_runtime_state_before"], dict)
+    assert isinstance(evidence["cold_warmup_runtime_state_after"], dict)
+    assert isinstance(
+        evidence["cold_warmup_runtime_state_after"]["active_family_union_census"],
+        dict,
+    )
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+def test_private_arena_historical_single_warmup_elapsed_remains_valid(
+    execution_mode: str,
+) -> None:
+    benchmark = _complete_otf_benchmark()
+    benchmark.environment["execution_mode"] = execution_mode
+    for field in OTF_COLD_WARMUP_FIELDS | CONVENTIONAL_WARMUP_FIELDS:
+        benchmark.environment.pop(field, None)
+    benchmark.environment["warmup_elapsed_seconds"] = 0.2
+
+    measurement = _benchmark_measurement(benchmark, matrix_element=2.0)
+
+    evidence = measurement["benchmark_evidence"]
+    assert evidence["warmup_elapsed_seconds"] == pytest.approx(0.2)
+    assert (
+        not (
+            (OTF_COLD_WARMUP_FIELDS | CONVENTIONAL_WARMUP_FIELDS)
+            - {"warmup_elapsed_seconds"}
+        )
+        & evidence.keys()
+    )
+
+
+@pytest.mark.parametrize(
+    ("field", "replacement", "message"),
+    (
+        (
+            "cold_warmup_acceptance_eligible",
+            True,
+            "ineligible for ratios and acceptance",
+        ),
+        ("cold_warmup_point_count", 127, "full benchmark batch"),
+        ("warmup_point_count", 255, "configured runs times batch size"),
+        ("warmup_run_outer_wall_seconds", (0.010,), "configured run count"),
+        ("warmup_elapsed_seconds", 2.0, "does not equal its per-run"),
+        ("cold_warmup_timing_scope", "load included", "scope must exclude"),
+    ),
+)
+def test_campaign_rejects_semantically_invalid_otf_warmup_evidence(
+    field: str,
+    replacement: object,
+    message: str,
+) -> None:
+    benchmark = _complete_otf_benchmark()
+    benchmark.environment[field] = replacement
+
+    with pytest.raises(RunnerError, match=message):
+        _benchmark_measurement(benchmark, matrix_element=2.0)
+
+
+@pytest.mark.parametrize(
+    "field",
+    ("cold_warmup_run_count", "warmup_timer_source"),
+)
+def test_campaign_rejects_incomplete_otf_warmup_evidence(field: str) -> None:
+    benchmark = _complete_otf_benchmark()
+    del benchmark.environment[field]
+
+    with pytest.raises(RunnerError, match=r"incomplete .* warm-up evidence"):
+        _benchmark_measurement(benchmark, matrix_element=2.0)
diff --git a/pyamplicol/tests/unit/test_progress_events.py b/pyamplicol/tests/unit/test_progress_events.py
new file mode 100644
index 0000000000..ad8e85296e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_progress_events.py
@@ -0,0 +1,365 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import io
+import re
+import threading
+import time
+from dataclasses import FrozenInstanceError
+
+import pytest
+
+from pyamplicol.reporting import (
+    CallbackProgressSink,
+    LoggingProgressSink,
+    ProgressEnd,
+    ProgressStart,
+    ProgressUpdate,
+    StreamProgressSink,
+    TtyProgressSink,
+    progress_sink,
+)
+from pyamplicol.reporting import progress as progress_module
+from pyamplicol.reporting.progress import _dashboard_lines, _TaskState
+from pyamplicol.reporting.resources import ResourceUsage
+
+
+def test_progress_events_are_frozen_and_validated() -> None:
+    event = ProgressStart(
+        "build",
+        "Building",
+        total=3,
+        parent_task_id="root",
+        unit="chunks",
+        details={"chunk_index": 1},
+    )
+    assert event.parent_task_id == "root"
+    assert event.unit == "chunks"
+    assert event.details == {"chunk_index": 1}
+    with pytest.raises(FrozenInstanceError):
+        event.total = 4  # type: ignore[misc]
+    with pytest.raises(ValueError, match="exceed"):
+        ProgressUpdate("build", completed=4, total=3)
+    with pytest.raises(ValueError, match="finite"):
+        ProgressUpdate("build", 1, details={"waiting_seconds": float("inf")})
+
+
+def test_callback_and_stream_sinks_receive_typed_events() -> None:
+    received: list[object] = []
+    CallbackProgressSink(received.append).emit(ProgressEnd("build"))
+    assert received == [ProgressEnd("build")]
+
+    stream = io.StringIO()
+    StreamProgressSink(stream).emit(ProgressUpdate("build", 2, 3, "currents"))
+    assert stream.getvalue() == "build 2/3: currents\n"
+
+
+def test_log_progress_includes_recurrence_stage_counters() -> None:
+    stream = io.StringIO()
+    StreamProgressSink(stream).emit(
+        ProgressUpdate(
+            "generation:recurrence:process:rust-builder",
+            4,
+            8,
+            "recurrence stage",
+            details={
+                "process": "uubar_Z_4g",
+                "stage_index": 3,
+                "stage_total": 5,
+                "subset_size": 4,
+                "candidate_parent_pair_count": 65_536,
+                "candidate_parent_pair_total": 120_000,
+                "current_count": 18_304,
+                "dynamic_color_state_count": 812,
+                "color_target_prune_count": 12_345,
+                "contribution_count": 96_112,
+            },
+        )
+    )
+
+    line = stream.getvalue()
+    assert "process=uubar_Z_4g" in line
+    assert "stage=3/5" in line
+    assert "candidate_parent_pair_count=65536" in line
+    assert "color_target_prune_count=12345" in line
+    assert "current_count=18304" in line
+    assert "contribution_count=96112" in line
+
+
+def test_log_progress_renders_native_self_rss_samples() -> None:
+    stream = io.StringIO()
+    StreamProgressSink(stream).emit(
+        ProgressUpdate(
+            "runtime-warm-up:query_family",
+            2,
+            3,
+            details={
+                "native_current_rss_bytes": 256 * 1024**2,
+                "native_peak_rss_bytes": 384 * 1024**2,
+            },
+        )
+    )
+
+    assert "self_rss=0.25/0.38 GiB current/peak" in stream.getvalue()
+
+
+def test_auto_progress_uses_logging_for_non_tty_streams() -> None:
+    assert isinstance(progress_sink("auto", stream=io.StringIO()), LoggingProgressSink)
+    assert isinstance(progress_sink("tty", stream=io.StringIO()), TtyProgressSink)
+
+
+def test_logging_progress_rate_limits_updates_but_always_emits_completion(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    sink = LoggingProgressSink(minimum_interval=60.0)
+    with caplog.at_level("INFO", logger="pyamplicol.progress"):
+        sink.emit(ProgressStart("build", "Building", 3))
+        sink.emit(ProgressUpdate("build", 1, 3))
+        sink.emit(ProgressUpdate("build", 2, 3))
+        sink.emit(ProgressUpdate("build", 3, 3))
+        sink.emit(ProgressEnd("build"))
+    messages = [record.getMessage() for record in caplog.records]
+    assert "build 2/3" not in messages
+    assert "build 3/3" in messages
+    assert messages[-1] == "build done"
+
+
+def test_logging_progress_colors_typed_benchmark_statistics_without_changing_text(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    event = ProgressUpdate(
+        "runtime-benchmark",
+        3,
+        5,
+        (
+            "0.555/1s; wall 1.7773 us/point +/- 0.0072 us "
+            "(relative standard error 0.41%); 813 calls x 128 points"
+        ),
+        details={
+            "progress_kind": "benchmark-statistics",
+            "elapsed_seconds": 0.555,
+            "target_seconds": 1.0,
+            "wall_seconds_per_point": 1.7773e-6,
+            "wall_standard_error_seconds_per_point": 0.0072e-6,
+            "wall_relative_standard_error": 0.0041,
+            "repetitions": 813,
+            "batch_size": 128,
+            "sample_count": 3,
+        },
+    )
+    plain = progress_module._format_event(event)
+    sink = LoggingProgressSink(minimum_interval=0.0, color=True)
+
+    with caplog.at_level("INFO", logger="pyamplicol.progress"):
+        sink.emit(event)
+
+    colored = caplog.records[-1].getMessage()
+    assert "\x1b[" in colored
+    assert re.sub(r"\x1b\[[0-9;]*m", "", colored) == plain
+    assert "runtime-benchmark 3/5: 0.555/1s" in plain
+    assert "wall 1.7773 us/point" in plain
+    assert "relative standard error 0.41%" in plain
+
+
+def test_log_progress_factory_honors_resolved_color_setting() -> None:
+    sink = progress_sink("log", stream=io.StringIO(), color=True)
+
+    assert isinstance(sink, LoggingProgressSink)
+    assert sink.color is True
+
+
+def test_tty_progress_accepts_concurrent_phase_shape() -> None:
+    stream = io.StringIO()
+    sink = TtyProgressSink(stream)
+    sink.emit(ProgressStart("dag", "Building DAG", 2))
+    sink.emit(ProgressUpdate("dag", 1, 2, "currents"))
+    sink.emit(ProgressUpdate("dag", 2, 2))
+    sink.emit(ProgressEnd("dag"))
+    assert "Building DAG" in stream.getvalue()
+
+
+def test_tty_message_stream_preserves_write_only_text_stream_semantics() -> None:
+    class FlushRecordingStream(io.StringIO):
+        flush_count = 0
+
+        def flush(self) -> None:
+            self.flush_count += 1
+            super().flush()
+
+    stream = FlushRecordingStream()
+    message_stream = TtyProgressSink(stream).message_stream
+
+    assert message_stream.write("diagnostic") == len("diagnostic")
+    message_stream.flush()
+    assert stream.getvalue() == "diagnostic"
+    assert stream.flush_count == 1
+    assert message_stream.writable()
+    assert not message_stream.readable()
+    assert not message_stream.seekable()
+    with pytest.raises(io.UnsupportedOperation):
+        message_stream.read()
+    with pytest.raises(io.UnsupportedOperation):
+        message_stream.tell()
+
+
+def test_tty_progress_renders_without_holding_the_task_lock(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class TtyStream(io.StringIO):
+        def isatty(self) -> bool:
+            return True
+
+        def fileno(self) -> int:
+            raise OSError
+
+    class SnapshotDashboard:
+        def __init__(self, *, snapshot: object, **_: object) -> None:
+            self.snapshot = snapshot
+
+        def start(self) -> None:
+            return None
+
+        def render_now(self) -> None:
+            completed = threading.Event()
+
+            def take_snapshot() -> None:
+                self.snapshot()  # type: ignore[operator]
+                completed.set()
+
+            thread = threading.Thread(target=take_snapshot, daemon=True)
+            thread.start()
+            thread.join(timeout=0.5)
+            assert completed.is_set(), "dashboard snapshot blocked on the sink lock"
+
+        def close(self) -> None:
+            return None
+
+    monkeypatch.setattr(progress_module, "_Dashboard", SnapshotDashboard)
+    sink = TtyProgressSink(TtyStream())
+    sink.emit(ProgressStart("build", "Building", 2))
+    sink.emit(ProgressUpdate("build", 1, 2))
+    sink.close()
+
+
+def test_forced_tty_on_non_tty_is_deterministic_and_ansi_free() -> None:
+    stream = io.StringIO()
+    sink = TtyProgressSink(stream, color=True)
+    sink.emit(ProgressStart("profile", "Profiling runtime", 1))
+    sink.emit(ProgressUpdate("profile", 1, 1, "measured"))
+    sink.emit(ProgressEnd("profile"))
+
+    assert "Profiling runtime" in stream.getvalue()
+    assert "measured" in stream.getvalue()
+    assert "\x1b[" not in stream.getvalue()
+
+
+def test_dashboard_renders_elapsed_peak_rss_and_granular_status() -> None:
+    started = time.monotonic() - 68.0
+    root = _TaskState(
+        "generation",
+        "Generating processes",
+        8,
+        None,
+        "phases",
+        {"execution_mode": "compiled", "backend": "JIT", "optimization": "O2"},
+        started,
+        started + 60.0,
+        completed=3,
+    )
+    phase = _TaskState(
+        "generation:dag",
+        "DAG construction",
+        4,
+        "generation",
+        "processes",
+        {},
+        started + 40.0,
+        started + 65.0,
+        completed=3,
+    )
+    detail = _TaskState(
+        "generation:dag:uubar_Z_5g",
+        "uubar_Z_5g DAG",
+        62,
+        "generation:dag",
+        "masks",
+        {
+            "process": "uubar_Z_5g",
+            "step": "recursion",
+            "stage_index": 5,
+            "stage_total": 6,
+            "subset_size": 6,
+            "mask_index": 47,
+            "mask_total": 62,
+            "current_count": 18_304,
+            "interaction_count": 96_112,
+        },
+        started + 45.0,
+        started + 67.0,
+        completed=47,
+    )
+
+    lines = _dashboard_lines(
+        (root, phase, detail),
+        now=started + 68.0,
+        usage=ResourceUsage(
+            current_rss_bytes=3 * 1024**3,
+            peak_rss_bytes=4 * 1024**3,
+            process_count=3,
+        ),
+        width=180,
+        color=True,
+    )
+
+    assert "elapsed 1m08s" in lines[0]
+    assert "RSS 3.00/4.00 GiB current/peak" in lines[0]
+    assert "children 2" in lines[0]
+    assert "DAG construction" in lines[1]
+    assert "ETA" in lines[1]
+    assert "uubar_Z_5g" in lines[2]
+    assert "\x1b[35m  stage \x1b[0m" in lines[2]
+    assert "\x1b[32m5/6\x1b[0m" in lines[2]
+    assert "\x1b[35m  subset \x1b[0m" in lines[2]
+    assert "\x1b[32m6\x1b[0m" in lines[2]
+    assert "masks 47/62" in lines[2]
+    assert "currents 18,304" in lines[2]
+    assert "interactions 96,112" in lines[2]
+    assert any("\x1b[" in line for line in lines)
+
+    narrow = _dashboard_lines(
+        (root, phase, detail),
+        now=started + 68.0,
+        usage=ResourceUsage(),
+        width=48,
+        color=False,
+    )
+    assert all(len(line) <= 48 for line in narrow)
+    assert "RSS N/A" in narrow[0]
+
+
+def test_dashboard_enriches_legacy_evaluator_callback_messages() -> None:
+    now = time.monotonic()
+    task = _TaskState(
+        "generation:evaluators:process",
+        "Compile process evaluators",
+        1,
+        None,
+        "stages",
+        {"process": "uubar_Z_5g", "backend": "jit", "stage": "jit compile"},
+        now - 20.0,
+        now,
+        message="stage_4 chunk 12/43 p=1525/8000 waiting 18s",
+    )
+
+    detail = _dashboard_lines(
+        (task,),
+        now=now,
+        usage=ResourceUsage(),
+        width=180,
+        color=False,
+    )[2]
+
+    assert "chunk compilation" in detail
+    assert "chunks 12/43" in detail
+    assert "inputs 1,525" in detail
+    assert "waiting 18s" in detail
diff --git a/pyamplicol/tests/unit/test_progress_resources.py b/pyamplicol/tests/unit/test_progress_resources.py
new file mode 100644
index 0000000000..43b5aba467
--- /dev/null
+++ b/pyamplicol/tests/unit/test_progress_resources.py
@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import time
+
+from pyamplicol.reporting.resources import (
+    ProcessInfo,
+    ProcessTreeSampler,
+    ResourceUsageMonitor,
+    _parse_proc_stat_ppid,
+    _parse_proc_status_rss,
+    _parse_ps_output,
+)
+
+
+def test_resource_parsers_accept_proc_and_ps_shapes() -> None:
+    assert _parse_proc_stat_ppid("12 (python worker) S 7 12 12 0") == 7
+    assert _parse_proc_status_rss("Name:\tpython\nVmRSS:\t1536 kB\n") == 1536 * 1024
+    assert _parse_ps_output(" 12 7 1536\n") == {
+        12: ProcessInfo(pid=12, ppid=7, rss_bytes=1536 * 1024)
+    }
+
+
+def test_process_tree_sampler_aggregates_descendants_only() -> None:
+    records = {
+        10: ProcessInfo(10, 1, 100),
+        11: ProcessInfo(11, 10, 200),
+        12: ProcessInfo(12, 11, 300),
+        20: ProcessInfo(20, 1, 500),
+    }
+    sampler = ProcessTreeSampler(10)
+    assert sampler.sample(records) == (600, 3)
+
+    # A known descendant remains associated if its direct parent exits.
+    reparanted = {
+        10: ProcessInfo(10, 1, 110),
+        12: ProcessInfo(12, 1, 310),
+        20: ProcessInfo(20, 1, 500),
+    }
+    assert sampler.sample(reparanted) == (420, 2)
+
+
+def test_resource_monitor_tracks_current_and_peak_rss() -> None:
+    snapshots = iter(
+        (
+            {10: ProcessInfo(10, 1, 100)},
+            {
+                10: ProcessInfo(10, 1, 120),
+                11: ProcessInfo(11, 10, 80),
+            },
+            {10: ProcessInfo(10, 1, 90)},
+        )
+    )
+    monitor = ResourceUsageMonitor(root_pid=10, snapshotter=lambda: next(snapshots))
+    monitor._sample_once()
+    assert monitor.usage.current_rss_bytes == 100
+    assert monitor.usage.peak_rss_bytes == 100
+    monitor._sample_once()
+    assert monitor.usage.current_rss_bytes == 200
+    assert monitor.usage.peak_rss_bytes == 200
+    assert monitor.usage.process_count == 2
+    monitor._sample_once()
+    assert monitor.usage.current_rss_bytes == 90
+    assert monitor.usage.peak_rss_bytes == 200
+
+
+def test_resource_monitor_fails_open() -> None:
+    def unavailable() -> dict[int, ProcessInfo]:
+        raise OSError("not available")
+
+    monitor = ResourceUsageMonitor(root_pid=10, snapshotter=unavailable)
+    monitor._sample_once()
+    assert monitor.usage.current_rss_bytes is None
+    assert monitor.usage.peak_rss_bytes is None
+    assert monitor.usage.process_count is None
+
+
+def test_resource_monitor_thread_stops_cleanly() -> None:
+    monitor = ResourceUsageMonitor(
+        root_pid=10,
+        interval_seconds=0.01,
+        snapshotter=lambda: {10: ProcessInfo(10, 1, 123)},
+    )
+    monitor.start()
+    time.sleep(0.03)
+    monitor.close()
+
+    assert monitor._thread is None
+    assert monitor.usage.current_rss_bytes == 123
+    assert monitor.usage.peak_rss_bytes == 123
diff --git a/pyamplicol/tests/unit/test_public_compiled_model_views.py b/pyamplicol/tests/unit/test_public_compiled_model_views.py
new file mode 100644
index 0000000000..4fd0436373
--- /dev/null
+++ b/pyamplicol/tests/unit/test_public_compiled_model_views.py
@@ -0,0 +1,219 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import FrozenInstanceError, dataclass, fields
+from typing import cast
+
+import pytest
+
+from pyamplicol.api.models import (
+    CompiledModelCapabilities,
+    CompiledModelInfo,
+    CompiledModelSource,
+    ModelCompilationIssue,
+    ModelCompilationPhase,
+    _compiled_model_info,
+)
+
+
+@dataclass
+class _IssueRecord:
+    severity: str
+    code: str
+    message: str
+    context: str = ""
+
+
+def _set_attribute(record: object, name: str, value: object) -> None:
+    setattr(record, name, value)
+
+
+def _info_from_plain_records() -> tuple[
+    CompiledModelInfo,
+    dict[str, object],
+    dict[str, object],
+    list[object],
+    dict[str, object],
+    dict[str, object],
+]:
+    restriction = {"kind": "file", "sha256": "restriction-digest"}
+    options = {
+        "restriction": restriction,
+        "simplify": False,
+        "private_future_option": {"mutable": []},
+    }
+    source: dict[str, object] = {
+        "kind": "ufo",
+        "source_name": "toy_ufo",
+        "digest": "source-digest",
+        "options": options,
+    }
+    spins = [1, 2, 3]
+    colors = [-3, 1, 3, 8]
+    accuracies = ["lc", "nlc", "full"]
+    capabilities: dict[str, object] = {
+        "particle_count": 17,
+        "parameter_count": 6,
+        "vertex_count": 23,
+        "compiled_propagator_count": 2,
+        "form_factor_count": 0,
+        "max_vertex_valence": 4,
+        "spins": spins,
+        "color_representations": colors,
+        "color_accuracy_modes": accuracies,
+        "has_custom_propagators": True,
+        "verified_kernel_evaluation_class_count": 99,
+        "private_future_detail": {"mutable": []},
+    }
+    warning = _IssueRecord(
+        severity="warning",
+        code="experimental-feature",
+        message="feature is experimental",
+        context="X",
+    )
+    error: dict[str, object] = {
+        "severity": "error",
+        "code": "unsupported-feature",
+        "message": "feature is unsupported",
+        "context": "Y",
+    }
+    issues: list[object] = [warning, error]
+    phases: dict[str, object] = {
+        "model_loading": 0.125,
+        "preflight": 0.25,
+        "total": 0.5,
+    }
+    alpha_default = [0.118, 0.0]
+    parameter_defaults: dict[str, object] = {
+        "zeta": (2.0, -3.0),
+        "alpha": alpha_default,
+    }
+    info = _compiled_model_info(
+        name="toy",
+        schema_version=4,
+        model_compiler_version=9,
+        source=source,
+        capabilities=capabilities,
+        parameter_defaults=parameter_defaults,
+        issues=issues,
+        phase_timings=phases,
+        conversion_seconds=0.5,
+    )
+    return info, source, capabilities, issues, phases, parameter_defaults
+
+
+def test_plain_compiler_records_convert_to_typed_public_views() -> None:
+    info, _, _, _, _, _ = _info_from_plain_records()
+
+    assert info == CompiledModelInfo(
+        name="toy",
+        schema_version=4,
+        model_compiler_version=9,
+        source=CompiledModelSource(
+            kind="ufo",
+            name="toy_ufo",
+            digest="source-digest",
+            restriction_digest="restriction-digest",
+            simplify=False,
+        ),
+        capabilities=CompiledModelCapabilities(
+            particle_count=17,
+            parameter_count=6,
+            vertex_count=23,
+            propagator_count=2,
+            form_factor_count=0,
+            maximum_valence=4,
+            spins=(1, 2, 3),
+            color_representations=(-3, 1, 3, 8),
+            supported_color_accuracies=("lc", "nlc", "full"),
+            has_custom_propagators=True,
+        ),
+        parameters=info.parameters,
+        issues=(
+            ModelCompilationIssue(
+                severity="warning",
+                code="experimental-feature",
+                message="feature is experimental",
+                context="X",
+            ),
+            ModelCompilationIssue(
+                severity="error",
+                code="unsupported-feature",
+                message="feature is unsupported",
+                context="Y",
+            ),
+        ),
+        compilation_phases=(
+            ModelCompilationPhase(name="model_loading", seconds=0.125),
+            ModelCompilationPhase(name="preflight", seconds=0.25),
+            ModelCompilationPhase(name="total", seconds=0.5),
+        ),
+        conversion_seconds=0.5,
+    )
+    assert [parameter.name for parameter in info.parameters] == ["alpha", "zeta"]
+    assert info.parameters[0].kind == "external"
+    assert info.parameters[0].default_real == pytest.approx(0.118)
+    assert info.parameters[1].default_imaginary == pytest.approx(-3.0)
+    assert info.supported is False
+    assert info.phases is info.compilation_phases
+    assert info.capabilities.max_vertex_valence == 4
+    assert info.capabilities.color_accuracy_modes == ("lc", "nlc", "full")
+    assert not hasattr(
+        info.capabilities,
+        "verified_kernel_evaluation_class_count",
+    )
+    assert not hasattr(info.capabilities, "private_future_detail")
+
+
+def test_public_views_are_deeply_immutable_and_detached_from_inputs() -> None:
+    info, source, capabilities, issues, phases, defaults = _info_from_plain_records()
+
+    source_options = cast(dict[str, object], source["options"])
+    restriction = cast(dict[str, object], source_options["restriction"])
+    restriction["sha256"] = "changed"
+    cast(list[int], capabilities["spins"]).append(5)
+    cast(list[str], capabilities["color_accuracy_modes"]).clear()
+    cast(_IssueRecord, issues[0]).message = "changed"
+    cast(dict[str, object], issues[1])["context"] = "changed"
+    phases["total"] = 99.0
+    cast(list[float], defaults["alpha"])[0] = 1.0
+
+    assert info.source.restriction_digest == "restriction-digest"
+    assert info.capabilities.spins == (1, 2, 3)
+    assert info.capabilities.supported_color_accuracies == ("lc", "nlc", "full")
+    assert info.issues[0].message == "feature is experimental"
+    assert info.issues[1].context == "Y"
+    assert info.compilation_phases[-1].seconds == pytest.approx(0.5)
+    assert info.parameters[0].default_real == pytest.approx(0.118)
+
+    records = (
+        info,
+        info.source,
+        info.capabilities,
+        *info.parameters,
+        *info.issues,
+        *info.compilation_phases,
+    )
+    assert all(not hasattr(record, "__dict__") for record in records)
+    assert all(isinstance(hash(record), int) for record in records)
+    assert isinstance(info.parameters, tuple)
+    assert isinstance(info.issues, tuple)
+    assert isinstance(info.compilation_phases, tuple)
+    assert isinstance(info.capabilities.spins, tuple)
+    assert isinstance(info.capabilities.color_representations, tuple)
+    assert isinstance(info.capabilities.supported_color_accuracies, tuple)
+    assert all(
+        not isinstance(getattr(info.capabilities, field.name), dict)
+        for field in fields(info.capabilities)
+    )
+
+    with pytest.raises(FrozenInstanceError):
+        _set_attribute(info, "name", "changed")
+    with pytest.raises(FrozenInstanceError):
+        _set_attribute(info.source, "digest", "changed")
+    with pytest.raises(FrozenInstanceError):
+        _set_attribute(info.capabilities, "spins", ())
+    with pytest.raises(FrozenInstanceError):
+        _set_attribute(info.issues[0], "message", "changed")
+    with pytest.raises(FrozenInstanceError):
+        _set_attribute(info.compilation_phases[0], "seconds", 1.0)
diff --git a/pyamplicol/tests/unit/test_public_import_laziness.py b/pyamplicol/tests/unit/test_public_import_laziness.py
new file mode 100644
index 0000000000..2ac7888f5f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_public_import_laziness.py
@@ -0,0 +1,375 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+import pytest
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+SOURCE_ROOT = PROJECT_ROOT / "src"
+
+
+def _run_isolated(
+    source: str,
+    *,
+    script_path: Path | None = None,
+) -> subprocess.CompletedProcess[str]:
+    environment = os.environ.copy()
+    existing_pythonpath = environment.get("PYTHONPATH")
+    environment["PYTHONPATH"] = os.pathsep.join(
+        entry for entry in (str(SOURCE_ROOT), existing_pythonpath) if entry
+    )
+    if script_path is None:
+        command = (sys.executable, "-c", textwrap.dedent(source))
+    else:
+        script_path.write_text(textwrap.dedent(source), encoding="utf-8")
+        command = (sys.executable, str(script_path))
+    completed = subprocess.run(
+        command,
+        cwd=PROJECT_ROOT,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+    return completed
+
+
+def test_root_import_only_adds_symbolica_to_lightweight_public_imports() -> None:
+    _run_isolated(
+        """
+        import importlib.util
+        import sys
+        import pyamplicol
+
+        assert pyamplicol.__version__
+        assert set(pyamplicol.__all__) == {
+            *pyamplicol._PUBLIC_EXPORTS,
+            "__version__",
+        }
+        assert "Generator" in dir(pyamplicol)
+        assert "pyamplicol.api" not in sys.modules
+        assert "pyamplicol.config" not in sys.modules
+        assert ("symbolica" in sys.modules) == (
+            importlib.util.find_spec("symbolica") is not None
+        )
+        assert not any(
+            name == "pyamplicol.models" or name.startswith("pyamplicol.models.")
+            for name in sys.modules
+        )
+        assert not any(
+            name == prefix or name.startswith(prefix + ".")
+            for name in sys.modules
+            for prefix in ("ufo_model_loader",)
+        )
+        """
+    )
+
+
+def test_lightweight_public_exports_do_not_load_model_tooling() -> None:
+    _run_isolated(
+        """
+        import importlib.util
+        import sys
+        from pyamplicol import (
+            ColorConfig,
+            ColorFFTBasis,
+            CorrelatedRequest,
+            Generator,
+            ModelSource,
+            ProcessRequest,
+            ProcessSet,
+            Runtime,
+        )
+        import pyamplicol.api as public_api
+        from pyamplicol.api import ModelSource as ApiModelSource
+        from pyamplicol.api.requests import ProcessRequest as DirectProcessRequest
+
+        assert set(public_api.__all__) == set(public_api._PUBLIC_EXPORTS)
+        request = ProcessRequest.parse("d d~ > z")
+        process_set = ProcessSet((request,))
+        assert process_set.requests == (request,)
+        assert ModelSource is ApiModelSource
+        assert ProcessRequest is DirectProcessRequest
+        assert ModelSource.built_in_sm().kind == "built-in-sm"
+        assert Generator.__module__ == "pyamplicol.api.services"
+        assert Runtime.__module__ == "pyamplicol.api.services"
+        assert CorrelatedRequest().color_correlation == "born"
+        assert ColorConfig().fft_basis is ColorFFTBasis.ADJOINT
+        assert "pyamplicol.models.loading" not in sys.modules
+        assert ("symbolica" in sys.modules) == (
+            importlib.util.find_spec("symbolica") is not None
+        )
+        assert not any(
+            name.startswith("pyamplicol.models.compiler")
+            for name in sys.modules
+        )
+        assert not any(
+            name == prefix or name.startswith(prefix + ".")
+            for name in sys.modules
+            for prefix in ("ufo_model_loader",)
+        )
+        """
+    )
+
+
+def test_compiled_model_export_resolves_to_the_canonical_type() -> None:
+    _run_isolated(
+        """
+        from typing import get_type_hints
+
+        from pyamplicol import ModelSource
+        from pyamplicol import CompiledModel as RootCompiledModel
+        from pyamplicol.api import CompiledModel as ApiCompiledModel
+        from pyamplicol.api.models import CompiledModel as ModelCompiledModel
+
+        assert RootCompiledModel is ModelCompiledModel
+        assert ApiCompiledModel is ModelCompiledModel
+        assert get_type_hints(ModelSource.compile)["return"] is ModelCompiledModel
+        assert "pyamplicol.models.loading" not in __import__("sys").modules
+        """
+    )
+
+
+def test_cli_help_construction_does_not_load_model_tooling() -> None:
+    _run_isolated(
+        """
+        import importlib.util
+        import sys
+        from pyamplicol.cli.parser import build_parser
+
+        help_text = build_parser().format_help()
+        assert "generate" in help_text
+        assert "model" in help_text
+        assert "pyamplicol.models.loading" not in sys.modules
+        assert ("symbolica" in sys.modules) == (
+            importlib.util.find_spec("symbolica") is not None
+        )
+        assert not any(
+            name.startswith("pyamplicol.models.compiler")
+            for name in sys.modules
+        )
+        assert not any(
+            name == prefix or name.startswith(prefix + ".")
+            for name in sys.modules
+            for prefix in ("ufo_model_loader",)
+        )
+        """
+    )
+
+
+@pytest.mark.parametrize(
+    "registration", ("accepted", "ValueError", "PermissionError", "unavailable")
+)
+@pytest.mark.parametrize("personal_license", (False, True))
+def test_package_registration_preserves_authoritative_personal_and_restricted_fallback(
+    registration: str,
+    personal_license: bool,
+) -> None:
+    completed = _run_isolated(
+        f"""
+        import importlib.abc
+        import importlib.util
+        import io
+        import os
+        import sys
+
+        registration = {registration!r}
+        personal_license = {personal_license!r}
+        calls = []
+        if personal_license:
+            os.environ["SYMBOLICA_LICENSE"] = "test-personal-license"
+        else:
+            os.environ.pop("SYMBOLICA_LICENSE", None)
+        original_personal = os.environ.get("SYMBOLICA_LICENSE")
+        os.environ["SYMBOLICA_HIDE_BANNER"] = "0"
+
+        class SymbolicaLoader(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+            def find_spec(self, fullname, path, target=None):
+                if fullname == "symbolica":
+                    return importlib.util.spec_from_loader(fullname, self)
+
+            def create_module(self, spec):
+                return None
+
+            def exec_module(self, module):
+                assert os.environ["SYMBOLICA_HIDE_BANNER"] == "1"
+
+                def register(key):
+                    assert sys._getframe(1).f_globals["__name__"] == "pyamplicol"
+                    assert isinstance(key, str) and key
+                    calls.append("register")
+                    if registration == "ValueError":
+                        raise ValueError("test OEM rejection")
+                    if registration == "PermissionError":
+                        raise PermissionError("test OEM denial")
+
+                def is_licensed():
+                    caller = sys._getframe(1).f_globals["__name__"]
+                    assert caller == "pyamplicol.licensing"
+                    calls.append("is_licensed")
+                    return registration == "accepted" or personal_license
+
+                if registration != "unavailable":
+                    module.set_library_key = register
+                module.is_licensed = is_licensed
+                self.original_api = dict(vars(module))
+
+        loader = SymbolicaLoader()
+        sys.meta_path.insert(0, loader)
+        import pyamplicol
+
+        assert os.environ["SYMBOLICA_HIDE_BANNER"] == "0"
+        assert os.environ.get("SYMBOLICA_LICENSE") == original_personal
+        assert calls == ([] if registration == "unavailable" else ["register"])
+        assert "pyamplicol.config" not in sys.modules
+        from pyamplicol.licensing import (
+            detect_symbolica_license, symbolica_resource_clamps,
+        )
+        from pyamplicol.config import RunConfig
+
+        stream = io.StringIO()
+        state = detect_symbolica_license(stream=stream)
+        expected_licensed = registration == "accepted" or personal_license
+        assert state.licensed is expected_licensed
+        assert state.restricted is not expected_licensed
+        assert calls[-1] == "is_licensed"
+        # Only the public registration/check APIs are used; no upstream licence
+        # checker or private bypass flag is replaced to manufacture success.
+        assert vars(sys.modules["symbolica"]) == loader.original_api
+        clamps = symbolica_resource_clamps(RunConfig(action="generate"), state)
+        if expected_licensed:
+            assert clamps == ()
+            assert stream.getvalue() == ""
+        else:
+            assert [(item.path, item.effective) for item in clamps] == [
+                ("generation.workers", 1), ("evaluator.optimization.cores", 1)
+            ]
+            assert "request-symbolica-trial-license" in stream.getvalue()
+        json_stream = io.StringIO()
+        assert detect_symbolica_license(json_mode=True, stream=json_stream) == state
+        assert json_stream.getvalue() == ""
+        assert os.environ["SYMBOLICA_HIDE_BANNER"] == "1"
+        """
+    )
+    assert completed.stdout == ""
+    assert completed.stderr == ""
+
+
+def test_registration_does_not_hide_unexpected_failures() -> None:
+    _run_isolated(
+        """
+        import os
+        import sys
+        from types import ModuleType
+
+        module = ModuleType("symbolica")
+        def fail(key):
+            raise RuntimeError("unexpected registration failure")
+        module.set_library_key = fail
+        sys.modules["symbolica"] = module
+        os.environ.pop("SYMBOLICA_HIDE_BANNER", None)
+        try:
+            import pyamplicol
+        except RuntimeError as error:
+            assert str(error) == "unexpected registration failure"
+        else:
+            raise AssertionError("unexpected registration error was swallowed")
+        assert "SYMBOLICA_HIDE_BANNER" not in os.environ
+        """
+    )
+
+
+@pytest.mark.parametrize(
+    "missing_module", ("symbolica", "symbolica.core", "transitive")
+)
+def test_only_missing_symbolica_is_optional_for_lightweight_imports(
+    missing_module: str,
+) -> None:
+    _run_isolated(
+        f"""
+        import importlib.abc
+        import os
+        import sys
+
+        missing_module = {missing_module!r}
+        class MissingSymbolica(importlib.abc.MetaPathFinder):
+            def find_spec(self, fullname, path, target=None):
+                if fullname == "symbolica":
+                    raise ModuleNotFoundError(
+                        "test missing module", name=missing_module,
+                    )
+
+        sys.meta_path.insert(0, MissingSymbolica())
+        os.environ["SYMBOLICA_HIDE_BANNER"] = "0"
+        try:
+            from pyamplicol import Generator, Runtime
+            from pyamplicol.config import RunConfig
+            from pyamplicol.cli.parser import build_parser
+        except ModuleNotFoundError as error:
+            assert missing_module != "symbolica"
+            assert error.name == missing_module
+        else:
+            assert missing_module == "symbolica"
+            assert "symbolica" not in sys.modules
+            assert RunConfig(action="generate").action == "generate"
+            assert "generate" in build_parser().format_help()
+            # Missing Symbolica is not silently reported as a valid/restricted
+            # installation when symbolic work requests the actual license state.
+            from pyamplicol.licensing import detect_symbolica_license
+            try:
+                detect_symbolica_license()
+            except ModuleNotFoundError as error:
+                assert error.name == "symbolica"
+            else:
+                raise AssertionError("Symbolica-dependent operation should fail")
+        assert os.environ["SYMBOLICA_HIDE_BANNER"] == "0"
+        """
+    )
+
+
+def test_spawned_worker_registers_its_own_package_license(tmp_path: Path) -> None:
+    _run_isolated(
+        """
+        import multiprocessing
+        import os
+        import sys
+        from types import ModuleType
+
+        registration_pids = []
+        symbolica = ModuleType("symbolica")
+        def register(key):
+            assert isinstance(key, str) and key
+            registration_pids.append(os.getpid())
+        symbolica.set_library_key = register
+        sys.modules["symbolica"] = symbolica
+        import pyamplicol
+
+        def worker(queue):
+            queue.put((os.getpid(), registration_pids))
+
+        if __name__ == "__main__":
+            context = multiprocessing.get_context("spawn")
+            queue = context.Queue()
+            child = context.Process(target=worker, args=(queue,))
+            child.start()
+            try:
+                child_pid, child_registrations = queue.get(timeout=20)
+                child.join(timeout=20)
+                assert child.exitcode == 0
+                assert registration_pids == [os.getpid()]
+                assert child_pid != os.getpid()
+                assert child_registrations == [child_pid]
+            finally:
+                if child.is_alive():
+                    child.terminate()
+                    child.join(timeout=5)
+                queue.close()
+        """,
+        script_path=tmp_path / "spawn_license_probe.py",
+    )
diff --git a/pyamplicol/tests/unit/test_qq_z6g_final_comparison.py b/pyamplicol/tests/unit/test_qq_z6g_final_comparison.py
new file mode 100644
index 0000000000..0dabf80a63
--- /dev/null
+++ b/pyamplicol/tests/unit/test_qq_z6g_final_comparison.py
@@ -0,0 +1,988 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import importlib.util
+import json
+import statistics
+import sys
+from dataclasses import asdict
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+from typing import Any
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools" / "developer" / "qq_z6g_final_comparison.py"
+
+
+def _load(name: str, path: Path) -> ModuleType:
+    spec = importlib.util.spec_from_file_location(name, path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+comparison = _load("_test_qq_z6g_final_comparison", SCRIPT)
+
+
+def _raw_sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _write_json(path: Path, payload: object) -> dict[str, Any]:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    return {
+        "path": str(path),
+        "size_bytes": path.stat().st_size,
+        "sha256": _raw_sha256(path),
+    }
+
+
+def _matrix_aggregate_fixture(matrix: ModuleType) -> dict[str, Any]:
+    baseline = {
+        "source_revision": matrix.FROZEN_BASELINE_SOURCE_REVISION,
+        "native_build_inputs_sha256": "1" * 64,
+        "distribution_content_sha256": "2" * 64,
+        "native_module_sha256": "3" * 64,
+    }
+    current = {
+        "source_revision": "4" * 40,
+        "native_build_inputs_sha256": "5" * 64,
+        "distribution_content_sha256": "6" * 64,
+        "native_module_sha256": "7" * 64,
+    }
+    platform_record = {
+        "platform": "macOS-test-arm64",
+        "system": "Darwin",
+        "machine": "arm64",
+        "repository": {
+            "clean": True,
+            "head_revision": current["source_revision"],
+        },
+    }
+    cells = [
+        {
+            "cell_id": cell.cell_id,
+            "configuration": asdict(cell),
+            "result_content_sha256": "8" * 64,
+            "errors": [],
+            "passes": True,
+        }
+        for cell in matrix.CANONICAL_CELLS
+    ]
+    return {
+        "kind": matrix.RESULT_KIND,
+        "schema_version": matrix.SCHEMA_VERSION,
+        "matrix_contract": matrix.MATRIX_CONTRACT,
+        "matrix_definition": {
+            "sha256": matrix._canonical_sha256(
+                [
+                    asdict(cell) | {"cell_id": cell.cell_id}
+                    for cell in matrix.CANONICAL_CELLS
+                ]
+            )
+        },
+        "expected_builds": {"baseline": baseline, "current": current},
+        "complete": True,
+        "run_complete": True,
+        "passes": True,
+        "coverage": {
+            "expected": 168,
+            "observed": 168,
+            "missing": [],
+            "unexpected": [],
+            "passes": True,
+        },
+        "cell_gate": {"passes": True},
+        "identity_gate": {
+            "passes": True,
+            "distinct_sha256": {"runtime:baseline": ["9" * 64]},
+        },
+        "gain_gate": {"passes": True},
+        "generation_gate": {"passes": True},
+        "outer_provenance_gate": {"passes": True},
+        "provenance": {
+            "preflight": platform_record,
+            "postflight": copy.deepcopy(platform_record),
+        },
+        "cells": cells,
+    }
+
+
+def _primary_result_fixture(
+    matrix: ModuleType,
+    cell: Any,
+) -> tuple[dict[str, Any], dict[str, Any], str]:
+    baseline_runtime = {
+        "lane": "baseline",
+        "native_module": {"sha256": "3" * 64},
+    }
+    current_runtime = {
+        "lane": "current",
+        "native_module": {"sha256": "7" * 64},
+    }
+    measurements: list[dict[str, Any]] = []
+    values: dict[str, list[float]] = {"baseline": [], "current": []}
+    for pair_index in range(1, 8):
+        order = (
+            ("baseline", "current")
+            if (pair_index - 1) % 2 == 0
+            else ("current", "baseline")
+        )
+        for order_index, lane in enumerate(order, start=1):
+            wall = (
+                2.0e-6 + pair_index * 1.0e-8
+                if lane == "baseline"
+                else 1.0e-6 + pair_index * 1.0e-8
+            )
+            values[lane].append(wall)
+            measurements.append(
+                {
+                    "pair_index": pair_index,
+                    "measurement_order": order_index,
+                    "lane": lane,
+                    "wall_seconds_per_point": wall,
+                    "runtime_identity": (
+                        baseline_runtime if lane == "baseline" else current_runtime
+                    ),
+                }
+            )
+
+    def distribution(raw: list[float]) -> dict[str, Any]:
+        median = statistics.median(raw)
+        return {
+            "sample_count": len(raw),
+            "samples_seconds_per_point": raw,
+            "median_seconds_per_point": median,
+            "mad_seconds_per_point": statistics.median(
+                abs(value - median) for value in raw
+            ),
+            "minimum_seconds_per_point": min(raw),
+            "maximum_seconds_per_point": max(raw),
+        }
+
+    distributions = {lane: distribution(raw) for lane, raw in values.items()}
+    paired = matrix.regression._paired_distribution(measurements)
+    configuration = {
+        "process": cell.process,
+        "model_label": cell.model_kind,
+        "execution_mode": cell.execution_mode,
+        "workload": cell.workload,
+        "jit_optimization_level": cell.jit_optimization_level,
+        "color_accuracy": cell.color_accuracy,
+        "lc_flow_layout": cell.lc_flow_layout,
+        "batch_size": cell.batch_size,
+        "helicities": list(cell.helicities),
+        "color_flows": list(cell.color_flows),
+        "native_wall_time_source": matrix.regression.NATIVE_WALL_TIME_SOURCE,
+        "native_wall_time_sample_pass": (
+            matrix.regression.NATIVE_WALL_TIME_SAMPLE_PASS
+        ),
+        "timing_sample_contract": matrix.regression.PAIRED_TIMING_SAMPLE_CONTRACT,
+        "independent_samples_per_lane": 7,
+    }
+    correctness = {"passes": True, "fixture": "recomputed"}
+    result = {
+        "kind": matrix.regression.RESULT_KIND,
+        "schema_version": matrix.regression.SCHEMA_VERSION,
+        "complete": True,
+        "performance_result_authoritative": True,
+        "passes": True,
+        "configuration": configuration,
+        "gate": {"passes": True},
+        "correctness_gate": correctness,
+        "arena_profile_gate": {"passes": True},
+        "resource_gate": {"passes": True},
+        "measurements": measurements,
+        "pair_orders": [
+            ["baseline", "current"] if index % 2 == 0 else ["current", "baseline"]
+            for index in range(7)
+        ],
+        "distributions": distributions,
+        "paired_distribution": paired,
+    }
+    baseline_runtime_sha256 = matrix._canonical_sha256(
+        matrix._stable_runtime_identity_value(baseline_runtime)
+    )
+    audit = {
+        "configuration": asdict(cell),
+        "result_content_sha256": matrix._canonical_sha256(result),
+        "runtime_identity_sha256_by_lane": {
+            "baseline": baseline_runtime_sha256,
+            "current": matrix._canonical_sha256(
+                matrix._stable_runtime_identity_value(current_runtime)
+            ),
+        },
+    }
+    return result, audit, baseline_runtime_sha256
+
+
+def _section_evidence() -> Any:
+    modes = ("compiled", "eager", "recurrence")
+    layouts = ("topology-replay", "all-flow-union")
+    source_revision = "a" * 40
+    runtime = {
+        "interpreter": {
+            "implementation": "CPython",
+            "python_version": "3.12.6",
+            "sha256": "1" * 64,
+        },
+        "native_extension": {
+            "sha256": "2" * 64,
+            "build_inputs_sha256": "3" * 64,
+        },
+        "installed_distribution": {
+            "package_version": "0.1.0",
+            "distribution_content": {
+                "file_count": 10,
+                "size_bytes": 1024,
+                "sha256": "4" * 64,
+            },
+        },
+        "active_build_info": {
+            "payload": {
+                "source_revision": source_revision,
+                "candidate_fingerprint": "candidate-test",
+            }
+        },
+    }
+    captures: dict[tuple[str, str], Any] = {}
+    for layout_index, layout in enumerate(layouts):
+        profiles: dict[str, Any] = {}
+        timings: dict[str, Any] = {}
+        for mode_index, mode in enumerate(modes, start=1):
+            raw = [
+                float(mode_index + layout_index) * 1.0e-6 + index * 1.0e-9
+                for index in range(7)
+            ]
+            median = statistics.median(raw)
+            mad = statistics.median(abs(value - median) for value in raw)
+            profiles[mode] = {
+                "validation": {
+                    "passes": True,
+                    "maximum_absolute_difference": 1.0e-15,
+                    "maximum_relative_difference": 1.0e-16,
+                },
+                "profiles": [
+                    {
+                        "batch_size": 1,
+                        "subprocess_samples": [
+                            {
+                                "round": index,
+                                "wall_seconds_per_point": value,
+                                "interrupted": False,
+                            }
+                            for index, value in enumerate(raw)
+                        ],
+                    }
+                ],
+            }
+            timings[mode] = {
+                "1": {
+                    "sample_count": 7,
+                    "median_seconds_per_point": median,
+                    "mad_seconds_per_point": mad,
+                    "raw_seconds_per_point": raw,
+                }
+            }
+        comparisons = {
+            f"{left}__{right}": {
+                "passes": True,
+                "maximum_absolute_difference": 1.0e-15,
+                "maximum_relative_difference": 1.0e-16,
+            }
+            for left, right in comparison.RATIO_PAIRS
+        }
+        components = {
+            key: {
+                "passes": True,
+                "compared_component_count": 3,
+                "maximum_absolute_difference": 1.0e-15,
+                "maximum_relative_difference": 1.0e-16,
+            }
+            for key in comparisons
+        }
+        generation = {
+            mode: {
+                "generation_reused": False,
+                "generation_wall_seconds": 0.1 + mode_index * 0.01,
+                "artifact_stats": {
+                    "file_count": 2,
+                    "size_bytes": 2048,
+                },
+                "peak_rss": {"observed_lower_bound_bytes": 4096},
+                "phase_timings_seconds": {
+                    "model-loading": 0.01,
+                    "emission": 0.02,
+                },
+                "artifact_semantic_identity_sha256": (str(mode_index + 4) * 64),
+            }
+            for mode_index, mode in enumerate(modes)
+        }
+        payload = {
+            "profiles": profiles,
+            "lane_comparisons": comparisons,
+            "validation_summary": {"resolved_component_comparisons": components},
+            "generation": generation,
+        }
+        capture = SimpleNamespace(
+            loaded=SimpleNamespace(payload=payload),
+            validation_values=(1.0 + 0.0j, 2.0 + 0.0j),
+            timings=timings,
+            runtime_identity=runtime,
+            host={
+                "platform": "macOS-test",
+                "system": "Darwin",
+                "release": "test",
+                "machine": "arm64",
+                "cpu_model": "test",
+                "logical_cpu_count": 8,
+            },
+            color_axis={"count": 720},
+            helicity_axis={"count": 512},
+        )
+        captures[("built-in-sm", layout)] = capture
+        captures[("ufo-sm", layout)] = copy.deepcopy(capture)
+
+    amplicol: dict[str, Any] = {}
+    for role_index, role in enumerate(("selected-flow", "all-flow"), start=1):
+        raw = [role_index * 5.0e-6 + index * 1.0e-9 for index in range(7)]
+        median = statistics.median(raw)
+        amplicol[role] = SimpleNamespace(
+            values=(1.0 + 0.0j, 2.0 + 0.0j),
+            timing={
+                "sample_count": 7,
+                "median_seconds_per_point": median,
+                "mad_seconds_per_point": statistics.median(
+                    abs(value - median) for value in raw
+                ),
+                "raw_seconds_per_point": raw,
+                "timing_boundary": (
+                    "amplitude-evaluation"
+                    if role == "selected-flow"
+                    else "direct-library-total"
+                ),
+            },
+            interleave_records=tuple({"round": index} for index in range(7)),
+            source_identity={
+                "revision": "b" * 40,
+                "source_tree_sha256": "c" * 64,
+                "compiler": {
+                    "id": "gfortran",
+                    "version": "14",
+                    "target": "arm64-apple-darwin",
+                    "flags_sha256": "d" * 64,
+                },
+            },
+        )
+    m0 = SimpleNamespace(
+        MODELS=("built-in-sm", "ufo-sm"),
+        LAYOUTS=layouts,
+        MODES=modes,
+        BATCHES=(1,),
+        MIN_SAMPLES=7,
+        AMPLICOL_SELECTED_ROLE="selected-flow",
+        AMPLICOL_UNION_ROLE="all-flow",
+        ATOL=1.0e-15,
+        RTOL=1.0e-12,
+        PROCESS="u u~ > z g g g g g g",
+    )
+    return SimpleNamespace(
+        m0=m0,
+        captures=captures,
+        amplicol=amplicol,
+        expected={
+            "pyamplicol_source_revision": source_revision,
+            "runtime_provenance_sha256": "e" * 64,
+        },
+    )
+
+
+def test_default_output_and_parser_require_all_evidence_pins() -> None:
+    assert (
+        Path(".artifacts/developer/qq-z6g-arena-comparison.md")
+        == comparison.DEFAULT_OUTPUT
+    )
+    option_destinations = {
+        action.dest for action in comparison.parser()._actions if action.required
+    }
+    assert {
+        "request",
+        "request_sha256",
+        "acceptance",
+        "acceptance_sha256",
+        "expected_source_revision",
+        "expected_runtime_provenance_sha256",
+        "pre_arena_manifest",
+        "pre_arena_manifest_sha256",
+        "expected_pre_arena_source_revision",
+        "expected_pre_arena_build_sha256",
+        "expected_pre_arena_runtime_sha256",
+    } <= option_destinations
+
+
+def test_decision_semantics_rejects_unknown_and_stale_content() -> None:
+    recomputed = {
+        "accepted": True,
+        "created_at_utc": "2026-01-01T00:00:00+00:00",
+        "status": "accepted",
+    }
+    body = copy.deepcopy(recomputed)
+    acceptance = body | {"content_sha256": comparison._canonical_sha256(body)}
+    fake_m0 = SimpleNamespace(_utc=lambda value, label: value)
+
+    assert comparison._decision_semantics(
+        acceptance=acceptance,
+        recomputed=recomputed,
+        m0=fake_m0,
+    ) == {"accepted": True, "status": "accepted"}
+
+    unknown = acceptance | {"unexpected": True}
+    with pytest.raises(comparison.ComparisonError, match="unknown or missing"):
+        comparison._decision_semantics(
+            acceptance=unknown,
+            recomputed=recomputed,
+            m0=fake_m0,
+        )
+    stale = acceptance | {"accepted": False}
+    with pytest.raises(comparison.ComparisonError, match="digest is stale"):
+        comparison._decision_semantics(
+            acceptance=stale,
+            recomputed=recomputed,
+            m0=fake_m0,
+        )
+
+
+def test_validate_evidence_rejects_wrong_final_source_and_runtime_pins(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    request = {
+        "kind": "request",
+        "schema_version": 1,
+        "expected": {
+            "pyamplicol_source_revision": "a" * 40,
+            "runtime_provenance_sha256": "b" * 64,
+        },
+    }
+    fake_m0 = SimpleNamespace(
+        _REQUEST_KEYS=set(request),
+        REQUEST_KIND="request",
+        REQUEST_SCHEMA=1,
+        _require_exact_keys=lambda value, keys, label: None,
+        _validate_expected=lambda value: value,
+    )
+    loaded = SimpleNamespace(
+        payload=request,
+        ref=SimpleNamespace(path=tmp_path / "request.json"),
+        canonical_sha256="c" * 64,
+    )
+    monkeypatch.setattr(comparison, "_load_m0", lambda: fake_m0)
+    monkeypatch.setattr(comparison, "_load_json_ref", lambda *args, **kwargs: loaded)
+    common = {
+        "request_path": tmp_path / "request.json",
+        "request_sha256": "d" * 64,
+        "acceptance_path": tmp_path / "acceptance.json",
+        "acceptance_sha256": "e" * 64,
+        "expected_source_revision": "a" * 40,
+        "expected_runtime_provenance_sha256": "b" * 64,
+        "pre_arena_manifest_path": tmp_path / "pre-arena.json",
+        "pre_arena_manifest_sha256": "f" * 64,
+        "expected_pre_arena_source_revision": "1" * 40,
+        "expected_pre_arena_build_sha256": "2" * 64,
+        "expected_pre_arena_runtime_sha256": "3" * 64,
+    }
+
+    with pytest.raises(comparison.ComparisonError, match="final source"):
+        comparison.validate_evidence(
+            **(common | {"expected_source_revision": "4" * 40})
+        )
+    with pytest.raises(comparison.ComparisonError, match="runtime identity"):
+        comparison.validate_evidence(
+            **(common | {"expected_runtime_provenance_sha256": "5" * 64})
+        )
+
+
+def test_manifest_reference_is_content_addressed_and_exact(tmp_path: Path) -> None:
+    target = tmp_path / "target.json"
+    target.write_text('{"value":1}\n', encoding="utf-8")
+    m0 = comparison._load_m0()
+    reference = {
+        "path": target.name,
+        "size_bytes": target.stat().st_size,
+        "sha256": _raw_sha256(target),
+    }
+    loaded = comparison._manifest_ref(
+        m0=m0,
+        value=reference,
+        base=tmp_path,
+        label="fixture",
+    )
+    assert loaded.payload == {"value": 1}
+
+    with pytest.raises(comparison.ComparisonError, match="unknown"):
+        comparison._manifest_ref(
+            m0=m0,
+            value=reference | {"canonical_sha256": "0" * 64},
+            base=tmp_path,
+            label="fixture",
+        )
+    with pytest.raises(comparison.ComparisonError, match="content hash drifted"):
+        comparison._manifest_ref(
+            m0=m0,
+            value=reference | {"sha256": "0" * 64},
+            base=tmp_path,
+            label="fixture",
+        )
+
+
+def test_matrix_aggregate_requires_exact_aarch64_identity_pins() -> None:
+    matrix = comparison._load_matrix()
+    payload = _matrix_aggregate_fixture(matrix)
+    baseline = payload["expected_builds"]["baseline"]
+    assert isinstance(baseline, dict)
+    build_sha256 = comparison._canonical_sha256(baseline)
+    loaded = SimpleNamespace(payload=payload)
+
+    audits, observed_baseline, current, platform_record = (
+        comparison._validate_matrix_aggregate(
+            matrix=matrix,
+            loaded=loaded,
+            expected_pre_arena_source_revision=(matrix.FROZEN_BASELINE_SOURCE_REVISION),
+            expected_pre_arena_build_sha256=build_sha256,
+            expected_pre_arena_runtime_sha256="9" * 64,
+        )
+    )
+    assert len(audits) == 168
+    assert observed_baseline == baseline
+    assert current["source_revision"] == "4" * 40
+    assert platform_record["machine"] == "arm64"
+
+    tampered = copy.deepcopy(payload)
+    tampered["provenance"]["postflight"]["machine"] = "x86_64"
+    with pytest.raises(comparison.ComparisonError, match="changed"):
+        comparison._validate_matrix_aggregate(
+            matrix=matrix,
+            loaded=SimpleNamespace(payload=tampered),
+            expected_pre_arena_source_revision=(matrix.FROZEN_BASELINE_SOURCE_REVISION),
+            expected_pre_arena_build_sha256=build_sha256,
+            expected_pre_arena_runtime_sha256="9" * 64,
+        )
+    for overrides, message in (
+        (
+            {"expected_pre_arena_source_revision": "a" * 40},
+            "frozen pre-Arena source",
+        ),
+        (
+            {"expected_pre_arena_build_sha256": "a" * 64},
+            "build identity",
+        ),
+        (
+            {"expected_pre_arena_runtime_sha256": "a" * 64},
+            "runtime identity",
+        ),
+    ):
+        arguments = {
+            "matrix": matrix,
+            "loaded": loaded,
+            "expected_pre_arena_source_revision": (
+                matrix.FROZEN_BASELINE_SOURCE_REVISION
+            ),
+            "expected_pre_arena_build_sha256": build_sha256,
+            "expected_pre_arena_runtime_sha256": "9" * 64,
+        }
+        arguments.update(overrides)
+        with pytest.raises(comparison.ComparisonError, match=message):
+            comparison._validate_matrix_aggregate(**arguments)
+
+
+def test_matrix_current_build_is_identical_to_final_m0_runtime() -> None:
+    source_revision = "a" * 40
+    current = {
+        "source_revision": source_revision,
+        "native_build_inputs_sha256": "1" * 64,
+        "distribution_content_sha256": "2" * 64,
+        "native_module_sha256": "3" * 64,
+    }
+    pre_arena = SimpleNamespace(current_build=current)
+    capture = SimpleNamespace(
+        runtime_identity={
+            "native_extension": {
+                "build_inputs_sha256": "1" * 64,
+                "sha256": "3" * 64,
+            },
+            "installed_distribution": {"distribution_content": {"sha256": "2" * 64}},
+        }
+    )
+    comparison._bind_matrix_current_to_final(
+        pre_arena=pre_arena,
+        final_capture=capture,
+        expected_source_revision=source_revision,
+    )
+
+    mismatched = SimpleNamespace(current_build=current | {"source_revision": "b" * 40})
+    with pytest.raises(comparison.ComparisonError, match="does not equal"):
+        comparison._bind_matrix_current_to_final(
+            pre_arena=mismatched,
+            final_capture=capture,
+            expected_source_revision=source_revision,
+        )
+
+
+def test_validate_pre_arena_evidence_authenticates_all_24_primary_files(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    matrix = comparison._load_matrix()
+    monkeypatch.setattr(comparison, "_load_matrix", lambda: matrix)
+    monkeypatch.setattr(
+        matrix.regression,
+        "_correctness_gate",
+        lambda measurements: {"passes": True, "fixture": "recomputed"},
+    )
+    aggregate = _matrix_aggregate_fixture(matrix)
+    primary_cells = {
+        cell.cell_id: cell
+        for cell in matrix.CANONICAL_CELLS
+        if cell.category == "primary"
+    }
+    audit_by_id = {record["cell_id"]: record for record in aggregate["cells"]}
+    refs: list[dict[str, Any]] = []
+    runtime_sha256: str | None = None
+    first_result_path: Path | None = None
+    for cell_id, cell in sorted(primary_cells.items()):
+        result, audit, observed_runtime_sha256 = _primary_result_fixture(
+            matrix,
+            cell,
+        )
+        if runtime_sha256 is None:
+            runtime_sha256 = observed_runtime_sha256
+        assert runtime_sha256 == observed_runtime_sha256
+        audit_by_id[cell_id].update(audit)
+        path = tmp_path / "primary" / cell_id / "result.json"
+        identity = _write_json(path, result)
+        refs.append({"cell_id": cell_id, **identity})
+        first_result_path = first_result_path or path
+    assert runtime_sha256 is not None
+    aggregate["identity_gate"]["distinct_sha256"]["runtime:baseline"] = [runtime_sha256]
+    aggregate_identity = _write_json(
+        tmp_path / "matrix-result.json",
+        aggregate,
+    )
+    manifest = {
+        "kind": comparison.PRE_ARENA_REQUEST_KIND,
+        "schema_version": comparison.PRE_ARENA_REQUEST_SCHEMA,
+        "matrix_aggregate": aggregate_identity,
+        "primary_results": refs,
+    }
+    manifest_path = tmp_path / "pre-arena-request.json"
+    manifest_identity = _write_json(manifest_path, manifest)
+    baseline = aggregate["expected_builds"]["baseline"]
+    assert isinstance(baseline, dict)
+    m0 = comparison._load_m0()
+
+    evidence = comparison.validate_pre_arena_evidence(
+        m0=m0,
+        manifest_path=manifest_path,
+        manifest_sha256=manifest_identity["sha256"],
+        expected_pre_arena_source_revision=(matrix.FROZEN_BASELINE_SOURCE_REVISION),
+        expected_pre_arena_build_sha256=comparison._canonical_sha256(baseline),
+        expected_pre_arena_runtime_sha256=runtime_sha256,
+    )
+    assert len(evidence.results) == 24
+    assert len(evidence.timings) == 24
+
+    unknown_manifest = manifest | {"unexpected": True}
+    unknown_path = tmp_path / "unknown-request.json"
+    unknown_identity = _write_json(unknown_path, unknown_manifest)
+    with pytest.raises(comparison.ComparisonError, match="unknown or missing"):
+        comparison.validate_pre_arena_evidence(
+            m0=m0,
+            manifest_path=unknown_path,
+            manifest_sha256=unknown_identity["sha256"],
+            expected_pre_arena_source_revision=(matrix.FROZEN_BASELINE_SOURCE_REVISION),
+            expected_pre_arena_build_sha256=comparison._canonical_sha256(baseline),
+            expected_pre_arena_runtime_sha256=runtime_sha256,
+        )
+    missing_manifest = {
+        key: value for key, value in manifest.items() if key != "primary_results"
+    }
+    missing_path = tmp_path / "missing-request.json"
+    missing_identity = _write_json(missing_path, missing_manifest)
+    with pytest.raises(comparison.ComparisonError, match="unknown or missing"):
+        comparison.validate_pre_arena_evidence(
+            m0=m0,
+            manifest_path=missing_path,
+            manifest_sha256=missing_identity["sha256"],
+            expected_pre_arena_source_revision=(matrix.FROZEN_BASELINE_SOURCE_REVISION),
+            expected_pre_arena_build_sha256=comparison._canonical_sha256(baseline),
+            expected_pre_arena_runtime_sha256=runtime_sha256,
+        )
+
+    assert first_result_path is not None
+    first_result_path.write_text(
+        first_result_path.read_text(encoding="utf-8") + " ",
+        encoding="utf-8",
+    )
+    with pytest.raises(comparison.ComparisonError, match="drifted"):
+        comparison.validate_pre_arena_evidence(
+            m0=m0,
+            manifest_path=manifest_path,
+            manifest_sha256=manifest_identity["sha256"],
+            expected_pre_arena_source_revision=(matrix.FROZEN_BASELINE_SOURCE_REVISION),
+            expected_pre_arena_build_sha256=comparison._canonical_sha256(baseline),
+            expected_pre_arena_runtime_sha256=runtime_sha256,
+        )
+
+
+def test_primary_raw_medians_and_correctness_are_recomputed(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    matrix = comparison._load_matrix()
+    cell = next(cell for cell in matrix.CANONICAL_CELLS if cell.category == "primary")
+    result, audit, runtime_sha256 = _primary_result_fixture(matrix, cell)
+    monkeypatch.setattr(
+        matrix.regression,
+        "_correctness_gate",
+        lambda measurements: {"passes": True, "fixture": "recomputed"},
+    )
+
+    distributions = comparison._matrix_result_distributions(
+        matrix=matrix,
+        cell=cell,
+        result=result,
+        audit=audit,
+        baseline_runtime_sha256=runtime_sha256,
+    )
+    assert (
+        distributions["baseline"]["median_seconds_per_point"]
+        > (distributions["current"]["median_seconds_per_point"])
+    )
+
+    stale = copy.deepcopy(result)
+    stale["distributions"]["baseline"]["median_seconds_per_point"] *= 2.0
+    stale_audit = copy.deepcopy(audit)
+    stale_audit["result_content_sha256"] = matrix._canonical_sha256(stale)
+    with pytest.raises(comparison.ComparisonError, match="distributions are stale"):
+        comparison._matrix_result_distributions(
+            matrix=matrix,
+            cell=cell,
+            result=stale,
+            audit=stale_audit,
+            baseline_runtime_sha256=runtime_sha256,
+        )
+
+
+def test_runtime_numerical_generation_and_amplicol_sections_use_strict_shapes() -> None:
+    evidence = _section_evidence()
+
+    runtime_rows = comparison._runtime_identity_rows(evidence)
+    numerical = "\n".join(comparison._numerical_sections(evidence))
+    generation = "\n".join(comparison._generation_sections(evidence))
+    runtime = "\n".join(comparison._runtime_sections(evidence))
+    original_rows = comparison._original_identity_rows(evidence)
+    amplicol = "\n".join(comparison._amplicol_sections(evidence))
+
+    assert any(row[0] == "Native extension SHA-256" for row in runtime_rows)
+    assert "Selected-total versus resolved-sum closure" in numerical
+    assert "Cross-lane resolved-component agreement" in numerical
+    assert "Generation peak RSS lower bound" in generation
+    assert "Cold artifact load time | Unavailable" in generation
+    assert "Same-round runtime ratios" in runtime
+    assert any(row[0] == "Original AmpliCol revision" for row in original_rows)
+    assert "Same-round original selected/union ratio" in amplicol
+
+    broken = copy.deepcopy(
+        evidence.captures[("built-in-sm", "topology-replay")].loaded.payload
+    )
+    broken["generation"]["compiled"]["artifact_stats"]["size_bytes"] = None
+    evidence.captures[("built-in-sm", "topology-replay")].loaded.payload = broken
+    with pytest.raises(comparison.ComparisonError, match="artifact size"):
+        comparison._generation_sections(evidence)
+
+
+def test_generate_is_atomic_and_cli_failure_leaves_no_partial_output(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    monkeypatch.setattr(
+        comparison,
+        "validate_evidence",
+        lambda **kwargs: SimpleNamespace(),
+    )
+    monkeypatch.setattr(
+        comparison,
+        "render_markdown",
+        lambda evidence: "# deterministic\n",
+    )
+    output = tmp_path / "result.md"
+    arguments = {
+        "request_path": tmp_path / "request.json",
+        "request_sha256": "1" * 64,
+        "acceptance_path": tmp_path / "acceptance.json",
+        "acceptance_sha256": "2" * 64,
+        "expected_source_revision": "3" * 40,
+        "expected_runtime_provenance_sha256": "4" * 64,
+        "pre_arena_manifest_path": tmp_path / "pre-arena.json",
+        "pre_arena_manifest_sha256": "5" * 64,
+        "expected_pre_arena_source_revision": "6" * 40,
+        "expected_pre_arena_build_sha256": "7" * 64,
+        "expected_pre_arena_runtime_sha256": "8" * 64,
+        "output_path": output,
+    }
+    digest = comparison.generate(**arguments)
+    assert output.read_text(encoding="utf-8") == "# deterministic\n"
+    assert digest == hashlib.sha256(b"# deterministic\n").hexdigest()
+    assert not list(tmp_path.glob(".result.md.*.tmp"))
+
+    output.write_text("complete previous output\n", encoding="utf-8")
+    monkeypatch.setattr(
+        comparison,
+        "validate_evidence",
+        lambda **kwargs: comparison._die("rejected fixture"),
+    )
+    cli = [
+        "--request",
+        str(arguments["request_path"]),
+        "--request-sha256",
+        str(arguments["request_sha256"]),
+        "--acceptance",
+        str(arguments["acceptance_path"]),
+        "--acceptance-sha256",
+        str(arguments["acceptance_sha256"]),
+        "--expected-source-revision",
+        str(arguments["expected_source_revision"]),
+        "--expected-runtime-provenance-sha256",
+        str(arguments["expected_runtime_provenance_sha256"]),
+        "--pre-arena-manifest",
+        str(arguments["pre_arena_manifest_path"]),
+        "--pre-arena-manifest-sha256",
+        str(arguments["pre_arena_manifest_sha256"]),
+        "--expected-pre-arena-source-revision",
+        str(arguments["expected_pre_arena_source_revision"]),
+        "--expected-pre-arena-build-sha256",
+        str(arguments["expected_pre_arena_build_sha256"]),
+        "--expected-pre-arena-runtime-sha256",
+        str(arguments["expected_pre_arena_runtime_sha256"]),
+        "--output",
+        str(output),
+    ]
+    assert comparison.main(cli) == 2
+    assert output.read_text(encoding="utf-8") == "complete previous output\n"
+    assert "qq_Z6g comparison rejected" in capsys.readouterr().err
+
+
+def test_pre_arena_table_and_full_render_are_deterministic(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    timing = {
+        "median_seconds_per_point": 1.0e-6,
+        "mad_seconds_per_point": 1.0e-8,
+        "sample_count": 7,
+        "raw_seconds_per_point": [1.0e-6] * 7,
+    }
+    capture = SimpleNamespace(
+        host={
+            "platform": "macOS-test",
+            "system": "Darwin",
+            "release": "test",
+            "machine": "arm64",
+            "cpu_model": "test",
+            "logical_cpu_count": 8,
+        },
+        color_axis={"count": 720},
+        helicity_axis={"count": 512},
+        timings={
+            "compiled": {"1": timing},
+            "eager": {"1": timing | {"median_seconds_per_point": 2.0e-6}},
+        },
+    )
+    pre_arena_timings = {
+        ("built-in-sm", "topology-replay", "compiled", 1): {
+            "baseline": {
+                "median_seconds_per_point": 2.0e-6,
+                "mad_seconds_per_point": 2.0e-8,
+            },
+            "current": timing,
+        },
+        ("built-in-sm", "topology-replay", "eager", 1): {
+            "baseline": {
+                "median_seconds_per_point": 4.0e-6,
+                "mad_seconds_per_point": 4.0e-8,
+            },
+            "current": timing | {"median_seconds_per_point": 2.0e-6},
+        },
+    }
+    m0 = SimpleNamespace(
+        MODELS=("built-in-sm",),
+        LAYOUTS=("topology-replay",),
+        MODES=("compiled", "eager", "recurrence"),
+        BATCHES=(1,),
+        PROCESS="u u~ > z g g g g g g",
+        RTOL=1.0e-11,
+        ATOL=1.0e-300,
+    )
+    evidence = SimpleNamespace(
+        m0=m0,
+        captures={("built-in-sm", "topology-replay"): capture},
+        expected={
+            "color_flow": {"id": "flow:test"},
+            "helicity": {"id": "h:test"},
+            "model_common_physics_identity_sha256": {"built-in-sm": "a" * 64},
+            "generation_model_identities_sha256": {"built-in-sm": "b" * 64},
+        },
+        pre_arena=SimpleNamespace(timings=pre_arena_timings),
+    )
+    baseline_section = comparison._pre_arena_comparison_sections(evidence)
+    assert "Final Arena / pre-Arena" in "\n".join(baseline_section)
+    assert "0.5x" in "\n".join(baseline_section)
+
+    monkeypatch.setattr(
+        comparison, "_capture_input_rows", lambda evidence: [["x", "y", "z"]]
+    )
+    monkeypatch.setattr(
+        comparison, "_runtime_identity_rows", lambda evidence: [["x", "y"]]
+    )
+    monkeypatch.setattr(
+        comparison, "_pre_arena_identity_rows", lambda evidence: [["x", "y"]]
+    )
+    monkeypatch.setattr(
+        comparison, "_original_identity_rows", lambda evidence: [["x", "y"]]
+    )
+    monkeypatch.setattr(
+        comparison, "_numerical_sections", lambda evidence: ["## Numeric"]
+    )
+    monkeypatch.setattr(
+        comparison, "_generation_sections", lambda evidence: ["## Generation"]
+    )
+    monkeypatch.setattr(
+        comparison, "_runtime_sections", lambda evidence: ["## Runtime"]
+    )
+    monkeypatch.setattr(
+        comparison,
+        "_pre_arena_comparison_sections",
+        lambda evidence: baseline_section,
+    )
+    monkeypatch.setattr(
+        comparison, "_amplicol_sections", lambda evidence: ["## AmpliCol"]
+    )
+    first = comparison.render_markdown(evidence)
+    second = comparison.render_markdown(evidence)
+    assert first == second
+    assert "# Final qq → Z + 6g Arena comparison" in first
+    assert "**The all-flow union evidence here is LC-only.**" in first
+    assert (
+        hashlib.sha256(first.encode()).digest()
+        == hashlib.sha256(second.encode()).digest()
+    )
diff --git a/pyamplicol/tests/unit/test_quantum_number_flow.py b/pyamplicol/tests/unit/test_quantum_number_flow.py
new file mode 100644
index 0000000000..b440fc62ae
--- /dev/null
+++ b/pyamplicol/tests/unit/test_quantum_number_flow.py
@@ -0,0 +1,258 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.generation.artifact_writer import _current_storage
+from pyamplicol.generation.dag_types import ColorState, CurrentIndex, CurrentNode
+from pyamplicol.generation.runtime_schema import _current_slots
+from pyamplicol.models.base import Model, QuantumFlow
+from pyamplicol.models.builtin.model import BuiltinSMModel
+from pyamplicol.models.compiler_records import _particle
+from pyamplicol.models.contracts import (
+    CompiledModelIR,
+    CompiledParticleRecord,
+    validate_quantum_number_flow,
+)
+from pyamplicol.models.external_catalog import ExternalModelCatalogMixin
+
+
+def _compiled_particle(
+    *,
+    name: str,
+    antiname: str,
+    pdg_code: int,
+    quantum_numbers: tuple[tuple[str, str], ...],
+) -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=antiname,
+        pdg_code=pdg_code,
+        spin=1,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=quantum_numbers,
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def _compiled_model(
+    *particles: CompiledParticleRecord,
+) -> CompiledModelIR:
+    return CompiledModelIR(
+        name="quantum-number-test",
+        orders=(),
+        parameters=(),
+        particles=particles,
+        couplings=(),
+        propagators=(),
+        vertex_terms=(),
+        oriented_kernels=(),
+        direct_contractions=(),
+        closure_contractions=(),
+    )
+
+
+def test_loader_charge_uses_the_exact_float_ratio() -> None:
+    record = _particle(
+        {
+            "name": "fractional",
+            "antiname": "anti-fractional",
+            "pdg_code": 101,
+            "spin": 1,
+            "color": 1,
+            "mass": "ZERO",
+            "width": "ZERO",
+            "charge": 0.2,
+        }
+    )
+    numerator, denominator = (0.2).as_integer_ratio()
+    assert record.quantum_numbers == (
+        ("electric_charge", f"{numerator}/{denominator}"),
+    )
+
+
+@pytest.mark.parametrize(
+    ("flow", "message"),
+    [
+        (
+            (("second", "0"), ("first", "0")),
+            "sorted and unique",
+        ),
+        (
+            (("duplicate", "0"), ("duplicate", "0")),
+            "sorted and unique",
+        ),
+        ((("symbolic", "x"),), "symbol-free"),
+        ((("symbolic-function", "unknown(1)"),), "symbol-free"),
+        ((("complex", "sqrt(-1)"),), "must be real"),
+        # Symbolica identifies infinity as non-real before numeric evaluation.
+        ((("infinite", "log(0)"),), "must be real"),
+    ],
+)
+def test_quantum_number_metadata_rejects_noncanonical_constants(
+    flow: tuple[tuple[str, str], ...],
+    message: str,
+) -> None:
+    with pytest.raises(ValueError, match=message):
+        validate_quantum_number_flow(flow)
+
+
+def test_quantum_number_metadata_accepts_large_finite_exact_constants() -> None:
+    flow = (("large_exact_number", "exp(1000000)"),)
+    assert validate_quantum_number_flow(flow) == flow
+
+
+@pytest.mark.parametrize("expression", ("pi", "sqrt(2)"))
+def test_quantum_number_metadata_accepts_builtin_exact_constants(
+    expression: str,
+) -> None:
+    flow = (("exact_number", expression),)
+    assert validate_quantum_number_flow(flow) == flow
+
+
+def test_compiled_particle_quantum_numbers_obey_anti_relations() -> None:
+    particle = _compiled_particle(
+        name="fractional",
+        antiname="anti-fractional",
+        pdg_code=101,
+        quantum_numbers=(("electric_charge", "1/5"),),
+    )
+    antiparticle = _compiled_particle(
+        name="anti-fractional",
+        antiname="fractional",
+        pdg_code=-101,
+        quantum_numbers=(("electric_charge", "-1/5"),),
+    )
+    model = _compiled_model(particle, antiparticle)
+    assert CompiledModelIR.from_dict(model.to_dict()) == model
+
+    inconsistent = _compiled_particle(
+        name="anti-fractional",
+        antiname="fractional",
+        pdg_code=-101,
+        quantum_numbers=(("electric_charge", "-1/4"),),
+    )
+    with pytest.raises(ValueError, match="exactly negated"):
+        _compiled_model(particle, inconsistent)
+
+
+def test_self_conjugate_particles_require_zero_quantum_numbers() -> None:
+    with pytest.raises(ValueError, match="must declare exact electric_charge"):
+        _compiled_particle(
+            name="missing-charge",
+            antiname="missing-charge",
+            pdg_code=99,
+            quantum_numbers=(),
+        )
+
+    neutral = _compiled_particle(
+        name="neutral",
+        antiname="neutral",
+        pdg_code=100,
+        quantum_numbers=(("electric_charge", "0"),),
+    )
+    assert _compiled_model(neutral).particles == (neutral,)
+
+    charged = _compiled_particle(
+        name="charged-self-conjugate",
+        antiname="charged-self-conjugate",
+        pdg_code=102,
+        quantum_numbers=(("electric_charge", "1"),),
+    )
+    with pytest.raises(ValueError, match="must have zero"):
+        _compiled_model(charged)
+
+
+def test_model_flow_fails_closed_and_builtin_sm_is_exact() -> None:
+    with pytest.raises(NotImplementedError, match="exact quantum-number flow"):
+        Model(name="unspecified").quantum_number_flow(1)
+
+    model = BuiltinSMModel()
+    assert model.quantum_number_flow(2) == (("electric_charge", "2/3"),)
+    assert model.quantum_number_flow(-2) == (("electric_charge", "-2/3"),)
+    assert model.quantum_number_flow(1) == (("electric_charge", "-1/3"),)
+    assert model.quantum_number_flow(-1) == (("electric_charge", "1/3"),)
+    assert model.quantum_number_flow(-12) == (("electric_charge", "0"),)
+    assert model.quantum_number_flow(21) == (("electric_charge", "0"),)
+    assert model.quantum_number_flow(26) == (("electric_charge", "1"),)
+    assert model.quantum_number_flow(-26) == (("electric_charge", "-1"),)
+    assert model.quantum_number_flow(125) == (("electric_charge", "0"),)
+
+
+def test_external_catalog_consumes_compiled_quantum_numbers() -> None:
+    record = _compiled_particle(
+        name="fractional",
+        antiname="anti-fractional",
+        pdg_code=101,
+        quantum_numbers=(("electric_charge", "1/5"),),
+    )
+    catalog = ExternalModelCatalogMixin()
+    catalog._particle_records_by_pdg = {101: record}
+    assert catalog.quantum_number_flow(101) == record.quantum_numbers
+
+
+def test_current_identity_and_diagnostics_retain_exact_flow() -> None:
+    first = CurrentIndex(
+        particle_id=101,
+        external_mask=1,
+        external_labels=(1,),
+        helicity_ancestry=1,
+        chirality=0,
+        spin_state=0,
+        flavour_flow=(101,),
+        quantum_number_flow=(("electric_charge", "1/5"),),
+        color_state=ColorState("lc"),
+        momentum_mask=1,
+    )
+    second = CurrentIndex(
+        particle_id=101,
+        external_mask=1,
+        external_labels=(1,),
+        helicity_ancestry=1,
+        chirality=0,
+        spin_state=0,
+        flavour_flow=(101,),
+        quantum_number_flow=(("electric_charge", "1/7"),),
+        color_state=ColorState("lc"),
+        momentum_mask=1,
+    )
+    assert len({first, second}) == 2
+    assert first.to_json_dict()["quantum_number_flow"] == [["electric_charge", "1/5"]]
+    flow = QuantumFlow(
+        chirality=0,
+        spin_state=0,
+        flavour_flow=(101,),
+        quantum_number_flow=(("electric_charge", "1/5"),),
+        coupling=(1.0, 0.0),
+    )
+    assert flow.quantum_number_flow == first.quantum_number_flow
+
+    current = CurrentNode(id=0, index=first, dimension=1, is_source=True)
+    full_storage = {
+        "component_count": 1,
+        "number_type": "complex",
+        "current_slots": _current_slots(SimpleNamespace(currents=(current,))),
+    }
+    assert full_storage["current_slots"][0]["quantum_number_flow"] == [
+        ["electric_charge", "1/5"]
+    ]
+    assert full_storage["current_slots"][0]["helicity_ancestry"] == "0x1"
+    wide_ancestry = 10**4300
+    wide_current = replace(
+        current,
+        index=replace(first, helicity_ancestry=wide_ancestry),
+    )
+    wide_slot = _current_slots(SimpleNamespace(currents=(wide_current,)))[0]
+    assert int(wide_slot["helicity_ancestry"], 16) == wide_ancestry
+    compact_storage = _current_storage(full_storage)
+    assert "quantum_number_flow" not in compact_storage["current_slots"][0]
+    assert "charge_flow" not in compact_storage["current_slots"][0]
diff --git a/pyamplicol/tests/unit/test_recurrence_artifact_compare.py b/pyamplicol/tests/unit/test_recurrence_artifact_compare.py
new file mode 100644
index 0000000000..e0a654f5dd
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_artifact_compare.py
@@ -0,0 +1,866 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import struct
+from pathlib import Path
+
+import pytest
+
+from tools.developer import recurrence_artifact_compare as compare
+
+_SCHEDULE_DIGEST = "f" * 64
+_SCHEDULE_PATH = f"recurrence/schedules/{_SCHEDULE_DIGEST}/recurrence-runtime.pacbin"
+_PLAN_MEMBER = "schedule/recurrence-direct-schedule-v2.bin"
+_CERTIFICATE_MEMBER = "proof/recurrence-color-projection-v1.bin"
+
+
+def _write_json(path: Path, value: object) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(
+            value,
+            allow_nan=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _write_payload(root: Path, relative: str, data: bytes) -> None:
+    path = root.joinpath(*relative.split("/"))
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(data)
+
+
+def _rewrite_authenticated_manifest(root: Path, manifest: dict[str, object]) -> None:
+    manifest.pop("artifact_id", None)
+    manifest["artifact_id"] = compare._runtime_artifact_id(manifest)
+    _write_json(root / "artifact.json", manifest)
+
+
+def _domain_sha256(domain: str, value: object) -> str:
+    encoded = json.dumps(
+        {"domain": domain, "value": value},
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _add_structural_source_proof(root: Path) -> None:
+    execution_path = "processes/process/execution.json"
+    proof_path = "processes/process/structural-source-proof.json"
+    execution = json.loads((root / execution_path).read_text())
+    manifest = json.loads((root / "artifact.json").read_text())
+    execution_sha = _sha256(root / execution_path)
+    execution_size = (root / execution_path).stat().st_size
+    metrics = compare._structural_metrics(execution)
+    lane = {
+        "lane_id": "primary",
+        "loose_payload_paths": [execution_path],
+        "pacbin_member_paths": [],
+        "structural_metrics": metrics,
+        "structural_metrics_sha256": _domain_sha256(
+            "execution-lane-structural-metrics-v1",
+            metrics,
+        ),
+        "subtree_sha256": _domain_sha256(
+            "execution-lane-subtree-v1",
+            execution,
+        ),
+    }
+    inventory = {
+        "status": "complete",
+        "loose_payloads": [
+            {
+                "path": execution_path,
+                "sha256": execution_sha,
+                "size_bytes": execution_size,
+            }
+        ],
+        "pacbin_container": None,
+        "pacbin_members": [],
+        "lanes": [lane],
+        "roles": [
+            {
+                "lane_id": "primary",
+                "object_kind": "loose-payload",
+                "object_path": execution_path,
+            }
+        ],
+    }
+    inventory["inventory_sha256"] = _domain_sha256(
+        "physical-lane-inventory-v1",
+        inventory,
+    )
+    producer = manifest["producer"]
+    proof = {
+        "schema": "pyamplicol-generation-structural-source-proof-v1",
+        "status": "complete",
+        "process_id": "process",
+        "source_identity": {
+            "git_revision": producer["git_revision"],
+            "native_build_inputs_sha256": producer["native_build_inputs_sha256"],
+        },
+        "execution": {
+            "path": execution_path,
+            "sha256": execution_sha,
+            "kind": execution["kind"],
+            "color_accuracy": execution.get("color_accuracy"),
+        },
+        "semantic_maps": compare._structural_semantic_map_witnesses(execution),
+        "physical_lane_inventory": inventory,
+    }
+    proof["proof_content_sha256"] = _domain_sha256(
+        "generation-structural-source-proof-v1",
+        proof,
+    )
+    _write_json(root / proof_path, proof)
+    manifest["payloads"].append(
+        {
+            "executable": False,
+            "media_type": "application/json",
+            "path": proof_path,
+            "role": "structural-source-proof",
+            "sha256": _sha256(root / proof_path),
+            "size_bytes": (root / proof_path).stat().st_size,
+        }
+    )
+    manifest["payloads"].sort(key=lambda record: record["path"])
+    _rewrite_authenticated_manifest(root, manifest)
+
+
+def _rewrite_structural_source_proof(root: Path, proof: dict[str, object]) -> None:
+    proof_path = root / "processes/process/structural-source-proof.json"
+    inventory = proof["physical_lane_inventory"]
+    inventory.pop("inventory_sha256", None)
+    inventory["inventory_sha256"] = _domain_sha256(
+        "physical-lane-inventory-v1",
+        inventory,
+    )
+    proof.pop("proof_content_sha256", None)
+    proof["proof_content_sha256"] = _domain_sha256(
+        "generation-structural-source-proof-v1",
+        proof,
+    )
+    _write_json(proof_path, proof)
+    manifest = json.loads((root / "artifact.json").read_text())
+    proof_record = next(
+        record
+        for record in manifest["payloads"]
+        if record["path"].endswith("structural-source-proof.json")
+    )
+    proof_record["sha256"] = _sha256(proof_path)
+    proof_record["size_bytes"] = proof_path.stat().st_size
+    _rewrite_authenticated_manifest(root, manifest)
+
+
+def _projection_body(payload: bytes = b"structural-projection-proof") -> bytes:
+    framed = b"PYAMP-COLOR-PROJECTION-BODY-V1\0\0" + struct.pack("<I", 1) + payload
+    return framed + hashlib.sha256(framed).digest()
+
+
+def _pacbin(members: dict[str, tuple[int, bytes]]) -> tuple[bytes, dict[str, object]]:
+    header_struct = struct.Struct("<8sHHIIIQQ24s")
+    index_header_struct = struct.Struct("<8sHHIQQ")
+    index_entry_struct = struct.Struct("<IHHQQ32s")
+    footer_struct = struct.Struct("<8sHHIQQ32s")
+    content = bytearray(b"\0" * header_struct.size)
+    indexed: list[tuple[str, int, int, int, bytes]] = []
+    for path in sorted(members, key=lambda item: item.encode("utf-8")):
+        kind, payload = members[path]
+        content.extend(b"\0" * ((-len(content)) % 64))
+        offset = len(content)
+        content.extend(payload)
+        indexed.append(
+            (path, kind, offset, len(payload), hashlib.sha256(payload).digest())
+        )
+    content.extend(b"\0" * ((-len(content)) % 64))
+    index_offset = len(content)
+    index = bytearray(
+        index_header_struct.pack(b"PACIDX\0\0", 1, 32, 0, len(indexed), 0)
+    )
+    for path, kind, offset, length, digest in indexed:
+        encoded_path = path.encode("utf-8")
+        entry = (
+            index_entry_struct.pack(
+                len(encoded_path),
+                kind,
+                0,
+                offset,
+                length,
+                digest,
+            )
+            + encoded_path
+        )
+        entry += b"\0" * ((-len(entry)) % 8)
+        index.extend(entry)
+    index_sha256 = hashlib.sha256(index).digest()
+    content.extend(index)
+    content.extend(
+        footer_struct.pack(
+            b"PACEND\0\0",
+            1,
+            64,
+            0,
+            index_offset,
+            len(indexed),
+            index_sha256,
+        )
+    )
+    content[: header_struct.size] = header_struct.pack(
+        b"PACBIN\0\0",
+        1,
+        64,
+        0,
+        64,
+        0,
+        index_offset,
+        len(indexed),
+        b"\0" * 24,
+    )
+    metadata = {
+        "index_sha256": index_sha256.hex(),
+        "member_count": len(indexed),
+        "unpacked_size_bytes": sum(length for _, _, _, length, _ in indexed),
+        "members": {
+            path: {
+                "kind": kind,
+                "size_bytes": length,
+                "sha256": digest.hex(),
+            }
+            for path, kind, _, length, digest in indexed
+        },
+    }
+    return bytes(content), metadata
+
+
+def _artifact(
+    root: Path,
+    *,
+    timing: float = 1.0,
+    revision_digit: str = "1",
+    native_digit: str = "a",
+    version: str = "0.1.0+baseline",
+    runtime_payload: bytes = b"runtime-schedule",
+    current_count: int = 7,
+    model_name: str = "same-model",
+    projection_body: bytes | None = None,
+    generation_profile_counter: int | None = None,
+) -> Path:
+    revision = revision_digit * 40
+    native = native_digit * 64
+    members = {_PLAN_MEMBER: (7, runtime_payload)}
+    if projection_body is not None:
+        members[_CERTIFICATE_MEMBER] = (8, projection_body)
+    runtime_container, runtime_metadata = _pacbin(members)
+    _write_payload(root, _SCHEDULE_PATH, runtime_container)
+
+    schedule_index = {
+        "binding_count": 1,
+        "bindings": [
+            {
+                "abi": "pyamplicol-recurrence-process-binding-v4",
+                "native_schedule_semantic_digest": "d" * 64,
+                "path": "recurrence-binding.bin",
+                "process_id": "process",
+                "process_digest": "f" * 64,
+                "process_semantic_digest": "e" * 64,
+                "process_support_words": [1],
+                "remap": {"bijection_digest": "1" * 64},
+                "schedule_digest": _SCHEDULE_DIGEST,
+                "sha256": hashlib.sha256(b"binding").hexdigest(),
+                "size_bytes": len(b"binding"),
+            }
+        ],
+        "interning_phase": "before-direct-lowering",
+        "kind": "pyamplicol-recurrence-schedule-sharing",
+        "runtime_ownership": "root-schedule-plus-process-binding",
+        "schedule_alias_count": 0,
+        "schedule_count": 1,
+        "schedules": [
+            {
+                "digest": _SCHEDULE_DIGEST,
+                "index_sha256": runtime_metadata["index_sha256"],
+                "member_count": runtime_metadata["member_count"],
+                "path": _SCHEDULE_PATH,
+                "process_ids": ["process"],
+                "sha256": hashlib.sha256(runtime_container).hexdigest(),
+                "size_bytes": len(runtime_container),
+                "unpacked_size_bytes": runtime_metadata["unpacked_size_bytes"],
+            }
+        ],
+        "schema_version": 3,
+    }
+    _write_json(root / "recurrence/schedule-index.json", schedule_index)
+
+    inspection_summary: dict[str, object] = {
+        "generation_timings_seconds": {
+            "direct_lowering": timing,
+            "native_total": timing + 0.25,
+        },
+        "schedule": {"closure_count": 3, "current_count": current_count},
+        "semantic_digest": "b" * 64,
+    }
+    if projection_body is not None:
+        certificate_metadata = runtime_metadata["members"]
+        assert isinstance(certificate_metadata, dict)
+        certificate_record = certificate_metadata[_CERTIFICATE_MEMBER]
+        assert isinstance(certificate_record, dict)
+        inspection_summary["color_projection_certificate"] = {
+            "path": _CERTIFICATE_MEMBER,
+            "proof_kind": "exact-rectangular-sum-projection",
+            "publishable": True,
+            "schema_version": 1,
+            "sha256": certificate_record["sha256"],
+            "size_bytes": certificate_record["size_bytes"],
+        }
+    execution_path = "processes/process/execution.json"
+    execution = {
+        "kind": "pyamplicol-runtime-recurrence-execution",
+        "plan": {
+            "inspection_summary": inspection_summary,
+            "runtime_schedule": {
+                "index_sha256": runtime_metadata["index_sha256"],
+                "kind": "pyamplicol-recurrence-runtime-container",
+                "member_count": runtime_metadata["member_count"],
+                "path": _SCHEDULE_PATH,
+                "plan_member_path": _PLAN_MEMBER,
+                "schema_version": 1,
+                "sha256": hashlib.sha256(runtime_container).hexdigest(),
+                "size_bytes": len(runtime_container),
+                "storage_abi": "pacbin-v1",
+                "unpacked_size_bytes": runtime_metadata["unpacked_size_bytes"],
+            },
+        },
+        "process": "d d~ > z g",
+        "schema_version": 3,
+    }
+    _write_json(root / execution_path, execution)
+
+    payload_data = {
+        "evaluators.pacbin": b"evaluator-state",
+        "processes/process/recurrence-binding.bin": b"binding",
+    }
+    for relative, data in payload_data.items():
+        _write_payload(root, relative, data)
+
+    roles = {
+        "evaluators.pacbin": "evaluator-state",
+        "recurrence/schedule-index.json": "evaluator-manifest",
+        _SCHEDULE_PATH: "evaluator-state",
+        "processes/process/recurrence-binding.bin": "evaluator-state",
+        execution_path: "evaluator-manifest",
+    }
+    payloads = []
+    for relative in sorted(roles):
+        path = root.joinpath(*relative.split("/"))
+        payloads.append(
+            {
+                "executable": False,
+                "media_type": "application/octet-stream",
+                "path": relative,
+                "role": roles[relative],
+                "sha256": _sha256(path),
+                "size_bytes": path.stat().st_size,
+            }
+        )
+
+    manifest = {
+        "created_utc": f"2026-07-30T21:00:0{int(timing) % 10}Z",
+        "extensions": {
+            "generation": {
+                "concrete_processes": [
+                    {
+                        "execution_manifest_sha256": _sha256(root / execution_path),
+                        "expression": "d d~ > z g",
+                        "id": "process",
+                    }
+                ],
+                "phase_timings_seconds": {
+                    "model-loading": timing,
+                    "recurrence-construction": timing + 0.5,
+                },
+            },
+            "recurrence_schedule_sharing": {
+                "binding_count": 1,
+                "index_path": "recurrence/schedule-index.json",
+                "index_sha256": _sha256(root / "recurrence/schedule-index.json"),
+                "interning_phase": "before-direct-lowering",
+                "kind": "pyamplicol-recurrence-schedule-sharing",
+                "runtime_ownership": "root-schedule-plus-process-binding",
+                "schedule_alias_count": 0,
+                "schedule_count": 1,
+                "schema_version": 3,
+            },
+        },
+        "kind": "pyamplicol-process",
+        "model": {"name": model_name},
+        "payloads": payloads,
+        "producer": {
+            "distribution": "pyamplicol",
+            "git_revision": revision,
+            "native_build_inputs_sha256": native,
+            "version": version,
+        },
+        "schema_version": 3,
+    }
+    if generation_profile_counter is not None:
+        manifest["extensions"]["generation"]["recurrence_schedule_profiles"] = {
+            _SCHEDULE_DIGEST: {
+                "native_passes": {
+                    "final": {
+                        "operation_counters": {
+                            name: generation_profile_counter
+                            for name in compare._GENERATION_PROFILE_COUNTERS
+                        },
+                        "schema_version": 1,
+                        "scope": "generation-only",
+                        "serialized_bytes": {
+                            "container": len(runtime_container),
+                            "plan_payload": len(runtime_payload),
+                            "unpacked_container": runtime_metadata[
+                                "unpacked_size_bytes"
+                            ],
+                        },
+                        "timings_seconds": {
+                            name: timing for name in compare._GENERATION_PROFILE_TIMINGS
+                        },
+                    }
+                },
+                "schema_version": 1,
+            }
+        }
+    manifest["artifact_id"] = compare._runtime_artifact_id(manifest)
+    _write_json(root / "artifact.json", manifest)
+    return root
+
+
+def test_exact_artifacts_pass_without_allowed_differences(tmp_path: Path) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(tmp_path / "candidate")
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is True
+    assert report["allowed_metadata_difference_count"] == 0
+    assert report["unknown_difference_count"] == 0
+    assert report["summary"] == {
+        "payload_inventories_match": True,
+        "exact_payload_bytes_match": True,
+        "payloads_match_policy": True,
+        "execution_semantics_match": True,
+        "manifest_semantics_match": True,
+        "runtime_schedule_plan_bytes_match": True,
+        "projection_certificate_semantic_bodies_match": True,
+        "runtime_bearing_payloads_match": True,
+    }
+
+
+def test_only_enumerated_timing_and_provenance_differences_pass(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(
+        tmp_path / "candidate",
+        timing=2.0,
+        revision_digit="2",
+        native_digit="c",
+        version="0.1.0+candidate",
+    )
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is True
+    assert report["unknown_difference_count"] == 0
+    allowed_paths = {
+        record["json_path"] for record in report["allowed_metadata_differences"]
+    }
+    assert {
+        "/artifact_id",
+        "/created_utc",
+        "/producer/git_revision",
+        "/producer/native_build_inputs_sha256",
+        "/producer/version",
+        "/extensions/generation/phase_timings_seconds",
+        "/plan/inspection_summary/generation_timings_seconds",
+    } <= allowed_paths
+    assert any("execution_manifest_sha256" in path for path in allowed_paths)
+    assert any(
+        path.endswith("/sha256") and "execution.json" in path for path in allowed_paths
+    )
+
+
+def test_structural_proof_allows_only_authenticated_execution_derivations(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(
+        tmp_path / "candidate",
+        timing=2.0,
+        revision_digit="2",
+        native_digit="c",
+        version="0.1.0+candidate",
+    )
+    _add_structural_source_proof(baseline)
+    _add_structural_source_proof(candidate)
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is True
+    assert report["unknown_difference_count"] == 0
+    proof_comparison = next(
+        record
+        for record in report["payload_comparisons"]
+        if record["path"].endswith("structural-source-proof.json")
+    )
+    assert proof_comparison["byte_for_byte_match"] is False
+    assert proof_comparison["normalized_match"] is True
+
+
+def test_coherently_rehashed_structural_proof_semantics_are_rejected(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(tmp_path / "candidate")
+    _add_structural_source_proof(baseline)
+    _add_structural_source_proof(candidate)
+    proof_path = candidate / "processes/process/structural-source-proof.json"
+    proof = json.loads(proof_path.read_text())
+    source_contract = proof["semantic_maps"]["source_contract"]
+    source_contract["rows"].append({"path": "forged", "value": True})
+    source_contract["sha256"] = _domain_sha256(
+        "source_contract-v1",
+        source_contract["rows"],
+    )
+    _rewrite_structural_source_proof(candidate, proof)
+
+    with pytest.raises(compare.ComparisonError, match="semantic maps are stale"):
+        compare.compare_artifacts(baseline, candidate)
+
+
+@pytest.mark.parametrize(
+    ("mutation", "message"),
+    [
+        ("lane-metrics", "lane evidence is stale"),
+        ("duplicate-role", "role coverage is invalid"),
+        ("member-without-container", "members lack a container"),
+    ],
+)
+def test_coherently_rehashed_structural_inventory_forgery_is_rejected(
+    tmp_path: Path,
+    mutation: str,
+    message: str,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(tmp_path / "candidate")
+    _add_structural_source_proof(baseline)
+    _add_structural_source_proof(candidate)
+    proof_path = candidate / "processes/process/structural-source-proof.json"
+    proof = json.loads(proof_path.read_text())
+    inventory = proof["physical_lane_inventory"]
+    lane = inventory["lanes"][0]
+    if mutation == "lane-metrics":
+        lane["structural_metrics"].append({"path": "forged_count", "value": 1})
+        lane["structural_metrics_sha256"] = _domain_sha256(
+            "execution-lane-structural-metrics-v1",
+            lane["structural_metrics"],
+        )
+    elif mutation == "duplicate-role":
+        inventory["roles"].append(dict(inventory["roles"][0]))
+    else:
+        inventory["pacbin_members"].append(
+            {
+                "logical_path": "forged",
+                "kind": "symjit_application",
+                "length": 0,
+                "sha256": hashlib.sha256(b"").hexdigest(),
+            }
+        )
+    _rewrite_structural_source_proof(candidate, proof)
+
+    with pytest.raises(compare.ComparisonError, match=message):
+        compare.compare_artifacts(baseline, candidate)
+
+
+def test_runtime_payload_difference_fails_even_with_authenticated_hash(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(
+        tmp_path / "candidate", runtime_payload=b"changed-runtime-schedule"
+    )
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is False
+    assert report["summary"]["exact_payload_bytes_match"] is False
+    payload_differences = [
+        item
+        for item in report["unknown_differences"]
+        if item["kind"] == "pacbin-runtime-plan-bytes"
+    ]
+    assert [item["path"] for item in payload_differences] == [_SCHEDULE_PATH]
+
+
+def test_unknown_execution_semantic_difference_is_reported(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(tmp_path / "candidate", current_count=8)
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is False
+    assert report["summary"]["execution_semantics_match"] is False
+    assert any(
+        item.get("file") == "processes/process/execution.json"
+        and item.get("json_pointer")
+        == "/plan/inspection_summary/schedule/current_count"
+        for item in report["unknown_differences"]
+    )
+
+
+def test_unknown_artifact_manifest_difference_is_reported(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(tmp_path / "candidate", model_name="different-model")
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is False
+    assert report["summary"]["manifest_semantics_match"] is False
+    assert any(
+        item.get("file") == "artifact.json"
+        and item.get("json_pointer") == "/model/name"
+        for item in report["unknown_differences"]
+    )
+
+
+def test_stale_declared_payload_hash_is_rejected(tmp_path: Path) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(tmp_path / "candidate")
+    runtime = (
+        candidate
+        / "recurrence"
+        / "schedules"
+        / _SCHEDULE_DIGEST
+        / "recurrence-runtime.pacbin"
+    )
+    runtime.write_bytes(b"tampered-after-manifest")
+
+    with pytest.raises(
+        compare.ComparisonError, match="payload metadata does not authenticate"
+    ):
+        compare.compare_artifacts(baseline, candidate)
+
+
+def test_unlisted_file_is_rejected(tmp_path: Path) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(tmp_path / "candidate")
+    (candidate / "unknown.bin").write_bytes(b"unknown")
+
+    with pytest.raises(compare.ComparisonError, match="inventory is not exact"):
+        compare.compare_artifacts(baseline, candidate)
+
+
+def test_projection_certificate_is_independent_of_producer_identity(
+    tmp_path: Path,
+) -> None:
+    body = _projection_body()
+    baseline = _artifact(
+        tmp_path / "baseline",
+        projection_body=body,
+        revision_digit="1",
+        native_digit="a",
+    )
+    candidate = _artifact(
+        tmp_path / "candidate",
+        projection_body=body,
+        revision_digit="2",
+        native_digit="c",
+        version="0.1.0+candidate",
+    )
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is True
+    assert report["summary"]["exact_payload_bytes_match"] is True
+    assert report["summary"]["payloads_match_policy"] is True
+    assert report["summary"]["runtime_schedule_plan_bytes_match"] is True
+    assert report["summary"]["projection_certificate_semantic_bodies_match"] is True
+    schedule_comparison = next(
+        record
+        for record in report["payload_comparisons"]
+        if record["path"] == _SCHEDULE_PATH
+    )
+    assert schedule_comparison["byte_for_byte_match"] is True
+
+
+def test_projection_certificate_structural_body_difference_fails(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(
+        tmp_path / "baseline",
+        projection_body=_projection_body(b"baseline semantics"),
+    )
+    candidate = _artifact(
+        tmp_path / "candidate",
+        projection_body=_projection_body(b"candidate semantics"),
+    )
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is False
+    assert report["summary"]["projection_certificate_semantic_bodies_match"] is False
+    assert any(
+        item["kind"] == "projection-certificate-structural-body"
+        for item in report["unknown_differences"]
+    )
+
+
+def test_evaluator_kernel_difference_remains_byte_exact_failure(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(tmp_path / "candidate")
+    evaluator = candidate / "evaluators.pacbin"
+    evaluator.write_bytes(b"different-evaluator")
+    manifest = json.loads((candidate / "artifact.json").read_text())
+    for record in manifest["payloads"]:
+        if record["path"] == "evaluators.pacbin":
+            record["sha256"] = _sha256(evaluator)
+            record["size_bytes"] = evaluator.stat().st_size
+    _rewrite_authenticated_manifest(candidate, manifest)
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is False
+    assert any(
+        item["kind"] == "payload-bytes" and item["path"] == "evaluators.pacbin"
+        for item in report["unknown_differences"]
+    )
+
+
+def test_strict_generation_only_profile_is_allowed_and_may_be_candidate_only(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(
+        tmp_path / "candidate",
+        generation_profile_counter=17,
+    )
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is True
+    assert any(
+        record["file"] == "artifact.json"
+        and record["json_path"] == "/extensions/generation/recurrence_schedule_profiles"
+        and record["category"] == "generation-only-telemetry"
+        for record in report["allowed_metadata_differences"]
+    )
+
+
+def test_generation_profile_unknown_field_is_rejected(tmp_path: Path) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(
+        tmp_path / "candidate",
+        generation_profile_counter=17,
+    )
+    manifest = json.loads((candidate / "artifact.json").read_text())
+    profiles = manifest["extensions"]["generation"]["recurrence_schedule_profiles"]
+    profile = profiles[_SCHEDULE_DIGEST]["native_passes"]["final"]
+    profile["unknown_runtime_claim"] = 1
+    _rewrite_authenticated_manifest(candidate, manifest)
+
+    with pytest.raises(compare.ComparisonError, match="fields are invalid"):
+        compare.compare_artifacts(baseline, candidate)
+
+
+def test_generation_profile_serialized_bytes_must_link_to_schedule(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(
+        tmp_path / "candidate",
+        generation_profile_counter=17,
+    )
+    manifest = json.loads((candidate / "artifact.json").read_text())
+    profiles = manifest["extensions"]["generation"]["recurrence_schedule_profiles"]
+    serialized = profiles[_SCHEDULE_DIGEST]["native_passes"]["final"][
+        "serialized_bytes"
+    ]
+    serialized["plan_payload"] += 1
+    _rewrite_authenticated_manifest(candidate, manifest)
+
+    with pytest.raises(
+        compare.ComparisonError,
+        match="not linked to its authenticated runtime schedule",
+    ):
+        compare.compare_artifacts(baseline, candidate)
+
+
+def test_unknown_schedule_index_difference_is_not_hidden_by_derived_hashes(
+    tmp_path: Path,
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    candidate = _artifact(tmp_path / "candidate")
+    schedule_index_path = candidate / "recurrence/schedule-index.json"
+    schedule_index = json.loads(schedule_index_path.read_text())
+    schedule_index["schedules"][0]["process_ids"] = ["different-process"]
+    _write_json(schedule_index_path, schedule_index)
+
+    manifest = json.loads((candidate / "artifact.json").read_text())
+    schedule_index_sha = _sha256(schedule_index_path)
+    manifest["extensions"]["recurrence_schedule_sharing"]["index_sha256"] = (
+        schedule_index_sha
+    )
+    for record in manifest["payloads"]:
+        if record["path"] == "recurrence/schedule-index.json":
+            record["sha256"] = schedule_index_sha
+            record["size_bytes"] = schedule_index_path.stat().st_size
+    _rewrite_authenticated_manifest(candidate, manifest)
+
+    report = compare.compare_artifacts(baseline, candidate)
+
+    assert report["passes"] is False
+    assert any(
+        item.get("file") == "recurrence/schedule-index.json"
+        and item.get("json_pointer") == "/schedules/0/process_ids/0"
+        for item in report["unknown_differences"]
+    )
+
+
+def test_cli_exit_codes_distinguish_match_diff_and_invalid(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    baseline = _artifact(tmp_path / "baseline")
+    matching = _artifact(tmp_path / "matching", timing=2.0)
+    different = _artifact(tmp_path / "different", runtime_payload=b"different")
+    invalid = _artifact(tmp_path / "invalid")
+    (invalid / "unexpected").write_bytes(b"unexpected")
+
+    assert (
+        compare.main(["--baseline", str(baseline), "--candidate", str(matching)]) == 0
+    )
+    assert json.loads(capsys.readouterr().out)["passes"] is True
+
+    assert (
+        compare.main(["--baseline", str(baseline), "--candidate", str(different)]) == 1
+    )
+    assert json.loads(capsys.readouterr().out)["passes"] is False
+
+    assert compare.main(["--baseline", str(baseline), "--candidate", str(invalid)]) == 2
+    assert "inventory is not exact" in capsys.readouterr().err
diff --git a/pyamplicol/tests/unit/test_recurrence_catalog_builder.py b/pyamplicol/tests/unit/test_recurrence_catalog_builder.py
new file mode 100644
index 0000000000..1d7eefa625
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_catalog_builder.py
@@ -0,0 +1,1662 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import replace
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.models._physics_ir import ContractionIR
+from pyamplicol.models.base import (
+    Model,
+    Particle,
+    PropagatorLoweringRule,
+    QuantumFlow,
+    RecurrenceLCColorTransitionContract,
+    RecurrenceLCColorWitnessContract,
+    RecurrenceQuantumFlowContract,
+    Vertex,
+    VertexEvaluationEquivalence,
+)
+from pyamplicol.models.builtin.model import BuiltinSMModel
+from pyamplicol.models.contact_decomposition import (
+    CONTACT_ORBIT_ALGORITHM,
+    CONTACT_ORBIT_ALGORITHM_VERSION,
+    CONTACT_ORBIT_EVALUATOR_CLASS,
+    HEFT_CONTACT_ORBIT_EVALUATOR_CLASS,
+    CompiledContactOrbitCertificate,
+    CompiledContactOrbitStep,
+)
+from pyamplicol.models.prepared_catalog import (
+    PreparedKernelCatalog,
+    PreparedKernelCatalogError,
+    PreparedKernelInput,
+    PreparedKernelSpec,
+    PreparedParticleState,
+    PreparedPropagatorBinding,
+    PreparedVertexBinding,
+    PropagatorKernelKey,
+    VertexKernelKey,
+    build_prepared_kernel_catalog,
+)
+from pyamplicol.models.recurrence_catalog_builder import (
+    _canonical_recurrence_vertex_bindings,
+    _canonical_transition_alias_key,
+    _singleton_contact_orbit_step_groups,
+    build_recurrence_template_catalog,
+)
+from pyamplicol.models.recurrence_template import (
+    ExactComplexRationalV1,
+    RecurrenceTemplateCatalog,
+    RecurrenceTemplateError,
+)
+
+_MODEL_DIGEST = "a" * 64
+_PACK_DIGEST = "b" * 64
+_PREPARED_ABI = "pyamplicol-prepared-kernel-catalog-v1"
+
+
+def _canonical_json(payload: object) -> str:
+    return json.dumps(
+        payload,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    )
+
+
+def _signature(
+    contract_kind: str,
+    inputs: tuple[PreparedKernelInput, ...],
+    expressions: tuple[str, ...],
+    output_layout: tuple[str, ...],
+) -> str:
+    payload = {
+        "abi": _PREPARED_ABI,
+        "contract_kind": contract_kind,
+        "inputs": [item.to_dict() for item in inputs],
+        "outputs": list(expressions),
+        "output_layout": list(output_layout),
+    }
+    return hashlib.sha256(_canonical_json(payload).encode("ascii")).hexdigest()
+
+
+class _ParameterModel(Model):
+    def __init__(self) -> None:
+        super().__init__(name="generic-parameter-model")
+
+    def runtime_parameter_defaults(self):
+        return {"alpha": (0.1, 0.0)}
+
+    def runtime_parameter_type(self, name):
+        assert name == "alpha"
+        return "real"
+
+    def runtime_derived_parameter_definitions(self):
+        return {"beta": "2*alpha"}
+
+    def runtime_derived_parameter_defaults(self):
+        return {"beta": complex(0.2, 0.0)}
+
+    def runtime_normalization_parameter_defaults(self):
+        return {"normalization.scale": 1.0}
+
+
+def _parameter_catalog(*, parameter_index: int = 0) -> PreparedKernelCatalog:
+    inputs = (
+        PreparedKernelInput(
+            role="model-parameter",
+            component=0,
+            symbol="alpha",
+            model_parameter_name="alpha",
+            model_parameter_index=parameter_index,
+        ),
+    )
+    expressions = ("2*alpha",)
+    output_layout = ("model-parameter:beta",)
+    kernel = PreparedKernelSpec(
+        kernel_id=0,
+        contract_kind="model-parameter",
+        canonical_signature=_signature(
+            "model-parameter", inputs, expressions, output_layout
+        ),
+        exact_expressions=expressions,
+        inputs=inputs,
+        output_layout=output_layout,
+    )
+    return PreparedKernelCatalog(
+        model_name="generic-parameter-model",
+        kernels=(kernel,),
+        vertex_bindings=(),
+        propagator_bindings=(),
+        closure_bindings=(),
+        model_parameter_kernel_id=0,
+    )
+
+
+def test_parameter_catalog_is_deterministic_and_binary64_exact() -> None:
+    model = _ParameterModel()
+    first = build_recurrence_template_catalog(
+        model,
+        _parameter_catalog(),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+    second = build_recurrence_template_catalog(
+        model,
+        _parameter_catalog(),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    assert first == second
+    assert first.canonical_json == second.canonical_json
+    alpha = next(item for item in first.parameters if item.name == "alpha")
+    assert alpha.default_value == ExactComplexRationalV1.from_binary64(0.1)
+    assert alpha.prepared_parameter_id == 0
+    beta = next(item for item in first.parameters if item.name == "beta")
+    assert beta.parameter_kind == "derived"
+    assert beta.default_value is None
+    assert beta.prepared_parameter_id is None
+    assert len(first.evaluator_bindings) == 1
+    assert first.evaluator_bindings[0].semantic_template_ids == (beta.template_id,)
+
+
+def test_catalog_round_trip_preserves_builder_output() -> None:
+    catalog = build_recurrence_template_catalog(
+        _ParameterModel(),
+        _parameter_catalog(),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+    loaded = RecurrenceTemplateCatalog.from_dict(json.loads(catalog.canonical_json))
+    assert loaded == catalog
+
+
+def test_direct_closure_mirror_aliases_are_not_double_counted() -> None:
+    model = BuiltinSMModel()
+    catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    bindings = {
+        semantic_id: binding
+        for binding in catalog.evaluator_bindings
+        for semantic_id in binding.semantic_template_ids
+    }
+    aliases: dict[tuple[str, tuple[str, ...]], int] = {}
+    for closure in catalog.closures:
+        if closure.equivalence_class != "direct-contraction":
+            continue
+        binding = bindings[closure.template_id]
+        key = (
+            binding.callable_signature,
+            tuple(sorted(closure.input_state_template_ids)),
+        )
+        aliases[key] = aliases.get(key, 0) + 1
+
+    assert aliases
+    assert set(aliases.values()) == {1}
+
+
+def test_builtin_massive_sources_and_currents_bind_fallback_mass_only() -> None:
+    model = BuiltinSMModel()
+    catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    top_mass = next(
+        parameter
+        for parameter in catalog.parameters
+        if parameter.name == "particle.6.mass"
+    )
+    assert top_mass.prepared_parameter_id is not None
+    states_by_id = {state.template_id: state for state in catalog.current_states}
+
+    for particle_id in (6, -6):
+        currents = tuple(
+            state
+            for state in catalog.current_states
+            if state.particle_id == particle_id
+        )
+        sources = tuple(
+            source
+            for source in catalog.sources
+            if states_by_id[source.state_template_id].particle_id == particle_id
+        )
+        assert currents and sources
+        assert {state.mass_parameter_id for state in currents} == {top_mass.template_id}
+        assert {source.mass_parameter_id for source in sources} == {
+            top_mass.template_id
+        }
+        assert {state.width_parameter_id for state in currents} == {None}
+        assert {source.width_parameter_id for source in sources} == {None}
+
+    for particle_id in (1, -1, 21):
+        currents = tuple(
+            state
+            for state in catalog.current_states
+            if state.particle_id == particle_id
+        )
+        sources = tuple(
+            source
+            for source in catalog.sources
+            if states_by_id[source.state_template_id].particle_id == particle_id
+        )
+        assert currents and sources
+        assert {state.mass_parameter_id for state in currents} == {None}
+        assert {source.mass_parameter_id for source in sources} == {None}
+
+
+def test_verified_auxiliary_transition_mirrors_are_not_double_counted() -> None:
+    model = BuiltinSMModel()
+    catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    transitions = tuple(
+        transition
+        for transition in catalog.transitions
+        if transition.equivalence_class == "builtin-sm:tensor-vector-to-vector"
+    )
+
+    # Three exact quantum-flow variants remain.  Their mirrored (g, aux) and
+    # (aux, g) model bindings are one certified contribution each, not six
+    # independently accumulated recurrence rows.
+    assert len(transitions) == 3
+    assert {transition.canonical_input_order for transition in transitions} == {(0, 1)}
+
+
+def test_verified_fermion_pair_transition_mirrors_are_not_double_counted() -> None:
+    model = BuiltinSMModel()
+    catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+    states = {state.template_id: state for state in catalog.current_states}
+
+    transitions = tuple(
+        transition
+        for transition in catalog.transitions
+        if transition.equivalence_class == "builtin-sm:fermion-pair-to-vector"
+        and {
+            states[state_id].particle_id
+            for state_id in transition.input_state_template_ids
+        }
+        == {-11, 11}
+        and states[transition.result_state_template_id].particle_id in {22, 23}
+        and all(
+            states[state_id].dimension == 2
+            for state_id in transition.input_state_template_ids
+        )
+    )
+
+    # One photon and one Z transition survive for each physical chiral pair.
+    # The mirrored (fermion, antifermion) and (antifermion, fermion) model
+    # orientations are certified evaluator aliases, not independent diagrams.
+    assert len(transitions) == 4
+    assert {transition.canonical_input_order for transition in transitions} == {(0, 1)}
+    assert {
+        (
+            tuple(
+                states[state_id].chirality
+                for state_id in transition.input_state_template_ids
+            ),
+            states[transition.result_state_template_id].particle_id,
+        )
+        for transition in transitions
+    } == {
+        ((1, -1), 22),
+        ((1, -1), 23),
+        ((-1, 1), 22),
+        ((-1, 1), 23),
+    }
+
+
+@pytest.mark.parametrize(
+    ("direct_kind", "mirrored_kind", "equivalence_class"),
+    (
+        (10, 23, "builtin-sm:fermion-vector-to-fermion"),
+        (11, 24, "builtin-sm:antifermion-vector-to-antifermion"),
+    ),
+)
+def test_verified_fermion_vector_transition_mirrors_share_one_orientation(
+    direct_kind: int,
+    mirrored_kind: int,
+    equivalence_class: str,
+) -> None:
+    """Keep the two built-in electroweak input orientations as one diagram."""
+
+    model = BuiltinSMModel()
+
+    direct = model.vertex_evaluation_equivalence(direct_kind)
+    mirrored = model.vertex_evaluation_equivalence(mirrored_kind)
+
+    assert direct.class_id == mirrored.class_id == equivalence_class
+    assert direct.input_order == (0, 1)
+    assert mirrored.input_order == (1, 0)
+    assert direct.factor == mirrored.factor == (1.0, 0.0)
+
+
+def test_verified_scalar_vector_transition_mirrors_are_not_double_counted() -> None:
+    model = BuiltinSMModel()
+    catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+    states = {state.template_id: state for state in catalog.current_states}
+
+    transitions = tuple(
+        transition
+        for transition in catalog.transitions
+        if transition.equivalence_class == "builtin-sm:scalar-vector-to-vector"
+        and tuple(
+            states[state_id].particle_id
+            for state_id in transition.input_state_template_ids
+        )
+        == (25, 23)
+        and states[transition.result_state_template_id].particle_id == 23
+    )
+
+    # One H/Z -> Z transition survives for each physical Z spin state.
+    # The mirrored (H, Z) and (Z, H) model orientations are evaluator aliases,
+    # not two independently accumulated Higgsstrahlung contributions.
+    assert len(transitions) == 3
+    assert {transition.canonical_input_order for transition in transitions} == {(0, 1)}
+    assert {
+        next(
+            flow.input_spin_states
+            for flow in catalog.quantum_flows
+            if flow.template_id == transition.quantum_flow_template_id
+        )
+        for transition in transitions
+    } == {(0, -1), (0, 0), (0, 1)}
+
+
+def test_concatenate_keep_alias_retains_canonical_parent_order() -> None:
+    one = ExactComplexRationalV1.one()
+
+    def concrete_pair(
+        canonical: tuple[object, object],
+        order: tuple[int, int],
+    ) -> tuple[object, object]:
+        concrete: list[object] = [None, None]
+        for canonical_index, concrete_index in enumerate(order):
+            concrete[concrete_index] = canonical[canonical_index]
+        return concrete[0], concrete[1]
+
+    def alias_key(order: tuple[int, int]) -> str:
+        input_states = concrete_pair(("left", "right"), order)
+        input_spins = concrete_pair((-1, 1), order)
+        input_flavours = concrete_pair(((1,), (2,)), order)
+        input_quantum = concrete_pair(
+            ((("charge", "left"),), (("charge", "right"),)),
+            order,
+        )
+        representations = concrete_pair((3, -3), order)
+        shape_kinds = concrete_pair(("open-left", "open-right"), order)
+        momentum = concrete_pair(("incoming-left", "incoming-right"), order)
+        return _canonical_transition_alias_key(
+            binding=SimpleNamespace(canonical_input_order=order),
+            kernel=SimpleNamespace(
+                canonical_signature="callable",
+                contract_kind="vertex",
+            ),
+            flow=SimpleNamespace(
+                input_state_template_ids=input_states,
+                input_spin_states=input_spins,
+                input_flavour_flows=input_flavours,
+                input_quantum_number_flows=input_quantum,
+                flavour_flow_operation="constant-result",
+                result_flavour_flow=(3,),
+                quantum_number_flow_operation="constant-result",
+                coupling_orders=(("QCD", 1),),
+                result_state_template_id="result",
+                result_spin_state=0,
+                result_quantum_number_flow=(("charge", "result"),),
+                exact_coupling=one,
+            ),
+            color=SimpleNamespace(
+                rule_kind="ordered-open-strings",
+                input_representations=representations,
+                output_representation=8,
+                ordered_open_string_arity=2,
+                nc_polynomial=((0, one),),
+                exact_coefficient=one,
+                transition_witnesses=(
+                    SimpleNamespace(
+                        input_shape_kinds=shape_kinds,
+                        input_permutation=(0, 1),
+                        reverse_parent_mask=0,
+                        component_operation="concatenate-keep",
+                        result_component_kind="open-string",
+                        result_component_role="none",
+                        result_shape_kind="open-string",
+                        exact_factor=one,
+                        input_port_pairings=(),
+                        result_port_bindings=(),
+                    ),
+                ),
+            ),
+            transition=SimpleNamespace(
+                input_state_template_ids=input_states,
+                result_state_template_id="result",
+                momentum_convention=momentum,
+                coupling_parameter_ids=(),
+                contact_orbit_step_template_ids=(),
+                contact_orbit_step_semantic_digests=(),
+                coupling_orders=(("QCD", 1),),
+                binding_coupling=one,
+                exact_factor=one,
+                output_factor_source="transition",
+                equivalence_class="test",
+                input_exchange_factor=None,
+                output_projection=None,
+            ),
+        )
+
+    assert alias_key((0, 1)) != alias_key((1, 0))
+
+
+class _ComplexParameterModel(_ParameterModel):
+    def runtime_parameter_defaults(self):
+        return {"alpha": (0.1, 0.2)}
+
+    def runtime_parameter_type(self, name):
+        assert name == "alpha"
+        return "complex"
+
+    def runtime_derived_parameter_defaults(self):
+        return {"beta": complex(0.2, 0.4)}
+
+
+def test_complex_parameter_retains_authoritative_prepared_kernel_index() -> None:
+    catalog = build_recurrence_template_catalog(
+        _ComplexParameterModel(),
+        _parameter_catalog(parameter_index=17),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    alpha = next(item for item in catalog.parameters if item.name == "alpha")
+    assert alpha.value_type == "complex"
+    assert alpha.prepared_parameter_id == 17
+    assert alpha.default_value == ExactComplexRationalV1.from_binary64(0.1, 0.2)
+
+
+def test_model_identity_mismatch_is_rejected() -> None:
+    catalog = replace(_parameter_catalog(), model_name="different-model")
+    with pytest.raises(PreparedKernelCatalogError, match="model identity"):
+        build_recurrence_template_catalog(
+            _ParameterModel(),
+            catalog,
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+def test_stale_prepared_kernel_signature_is_rejected() -> None:
+    catalog = _parameter_catalog()
+    stale = replace(catalog.kernels[0], exact_expressions=("3*alpha",))
+    mutated = replace(catalog, kernels=(stale,))
+    with pytest.raises(PreparedKernelCatalogError, match="stale canonical signature"):
+        build_recurrence_template_catalog(
+            _ParameterModel(),
+            mutated,
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+class _ScalarModel(Model):
+    def __init__(self) -> None:
+        particle = Particle(
+            pdg=101,
+            anti_pdg=101,
+            spin=1,
+            dimension=1,
+            color_rep=1,
+        )
+        super().__init__(
+            name="generic-scalar-model",
+            particles={101: particle},
+            vertices=(Vertex(0, (101, 101, 101)),),
+        )
+        self.source_kernel_id = -1
+
+    def color_rep(self, pdg):
+        return self.particle(pdg).color_rep
+
+    def is_fermion(self, pdg):
+        del pdg
+        return False
+
+    def is_chiral_eligible(self, pdg):
+        del pdg
+        return False
+
+    def is_fundamental_colored_fermion(self, pdg):
+        del pdg
+        return False
+
+    def is_massless_adjoint_vector(self, pdg):
+        del pdg
+        return False
+
+    def quantum_number_flow(self, particle_id):
+        del particle_id
+        return (("generic-charge", "0"),)
+
+    def recurrence_quantum_flow_contract(
+        self, vertex, left_particle_id, right_particle_id
+    ):
+        return self._standard_recurrence_quantum_flow_contract(
+            vertex, left_particle_id, right_particle_id
+        )
+
+    def recurrence_lc_color_shape_contract(self, particle_id, chirality=0):
+        return self._standard_recurrence_lc_color_shape_contract(particle_id, chirality)
+
+    def recurrence_lc_source_color_contract(self, particle_id, chirality=0):
+        return self._standard_recurrence_lc_source_color_contract(
+            particle_id, chirality
+        )
+
+    def recurrence_lc_color_transition_contract(self, vertex, *, closure):
+        return self._standard_recurrence_lc_color_transition_contract(
+            vertex, closure=closure
+        )
+
+    def vertex_evaluation_equivalence(self, kind):
+        assert kind == 0
+        return VertexEvaluationEquivalence(class_id="generic-scalar-exact-identity-v1")
+
+    def vertex_coupling_orders(self, vertex):
+        assert vertex.kind == 0
+        return (("GENERIC", 1),)
+
+    def vertex_color_structure(self, vertex):
+        assert vertex.kind == 0
+        return "singlet"
+
+    def vertex_color_weight(self, vertex, *, color_accuracy):
+        assert vertex.kind == 0
+        assert color_accuracy == "lc"
+        return (1.0, 0.0)
+
+    def propagator_lowering_rule(self, particle_id, chirality=0):
+        assert particle_id == 101
+        assert chirality == 0
+        return PropagatorLoweringRule(
+            particle_id=particle_id,
+            chirality=chirality,
+            backend="identity",
+            full_tensor_network_ready=True,
+            applies_propagator=False,
+            kernel="generic-scalar-identity",
+            kind="identity",
+            mass_class="not-applicable",
+            auxiliary_policy="external-synthetic-scalar",
+        )
+
+    def recurrence_source_kernel_id(self, particle_id, chirality, helicity, spin_state):
+        assert (particle_id, chirality, helicity, spin_state) == (101, 0, 0, 0)
+        return self.source_kernel_id
+
+
+def _kernel_namespace(
+    *,
+    contract_kind: str,
+    inputs: tuple[PreparedKernelInput, ...],
+    expressions: tuple[str, ...],
+    output_layout: tuple[str, ...],
+):
+    return SimpleNamespace(
+        kernel_id=-1,
+        contract_kind=contract_kind,
+        canonical_signature=_signature(
+            contract_kind, inputs, expressions, output_layout
+        ),
+        exact_expressions=expressions,
+        inputs=inputs,
+        output_layout=output_layout,
+        proof_classes=(),
+    )
+
+
+def _scalar_catalog(
+    model: _ScalarModel,
+    *,
+    vertex_expression: str = "left0*right0",
+):
+    source_inputs = (PreparedKernelInput(role="momentum", component=0, symbol="p0"),)
+    source = _kernel_namespace(
+        contract_kind="source",
+        inputs=source_inputs,
+        expressions=("1",),
+        output_layout=("scalar:c0",),
+    )
+    vertex_inputs = (
+        PreparedKernelInput(role="left-current", component=0, symbol="left0"),
+        PreparedKernelInput(role="right-current", component=0, symbol="right0"),
+    )
+    vertex = _kernel_namespace(
+        contract_kind="vertex",
+        inputs=vertex_inputs,
+        expressions=(vertex_expression,),
+        output_layout=("scalar:c0",),
+    )
+    ordered = sorted((source, vertex), key=lambda item: item.canonical_signature)
+    for kernel_id, kernel in enumerate(ordered):
+        kernel.kernel_id = kernel_id
+    model.source_kernel_id = source.kernel_id
+
+    state = PreparedParticleState(
+        particle_id=101,
+        identity=model._particle_identity_ir(101).canonical_id,
+        orientation="self-conjugate",
+        basis="scalar",
+        chirality=0,
+        dimension=1,
+    )
+    equivalence = model.vertex_evaluation_equivalence(0)
+    vertex_binding = PreparedVertexBinding(
+        key=VertexKernelKey(0, (101, 101, 101), 0, 0, 0, (1.0, 0.0)),
+        kernel_id=vertex.kernel_id,
+        canonical_input_order=equivalence.input_order,
+        equivalence_class=equivalence.class_id,
+        equivalence_factor=equivalence.factor,
+        input_exchange_factor=equivalence.input_exchange_factor,
+        left_state=state,
+        right_state=state,
+        result_state=state,
+    )
+    propagator_binding = PreparedPropagatorBinding(
+        key=PropagatorKernelKey(101, 0),
+        kernel_id=None,
+        state=state,
+        applies_propagator=False,
+        propagator_kind="identity",
+        mass_class="not-applicable",
+        gauge=None,
+        model_parameters=(),
+    )
+    return SimpleNamespace(
+        model_name=model.name,
+        kernels=tuple(ordered),
+        vertex_bindings=(vertex_binding,),
+        propagator_bindings=(propagator_binding,),
+        closure_bindings=(),
+        model_parameter_kernel_id=None,
+        unsupported_variants=(),
+    )
+
+
+def _scalar_contact_orbit_contract() -> tuple[
+    tuple[CompiledContactOrbitCertificate, ...],
+    tuple[CompiledContactOrbitStep, ...],
+]:
+    certificate = CompiledContactOrbitCertificate(
+        algorithm=CONTACT_ORBIT_ALGORITHM,
+        algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+        term_id=0,
+        vertex="V_scalar_contact",
+        particles=("s", "s", "s", "s"),
+        color_expression="1",
+        lorentz_expression="1",
+        coupling_expression="i*lam",
+        evaluator_class=CONTACT_ORBIT_EVALUATOR_CLASS,
+        physical_leg_equivalence_classes=(0, 0, 0, 0),
+        reconstruction_factor="1",
+    )
+    steps = tuple(
+        sorted(
+            (
+                CompiledContactOrbitStep(
+                    algorithm=CONTACT_ORBIT_ALGORITHM,
+                    algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+                    term_id=0,
+                    stage="partial",
+                    result_leg=0,
+                    left_covered_legs=(1,),
+                    right_covered_legs=(2,),
+                    source_particle_legs=(1, 2, -1),
+                    reconstruction_factor="1",
+                ),
+                CompiledContactOrbitStep(
+                    algorithm=CONTACT_ORBIT_ALGORITHM,
+                    algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+                    term_id=0,
+                    stage="partial",
+                    result_leg=0,
+                    left_covered_legs=(2,),
+                    right_covered_legs=(1,),
+                    source_particle_legs=(2, 1, -1),
+                    reconstruction_factor="1",
+                ),
+                CompiledContactOrbitStep(
+                    algorithm=CONTACT_ORBIT_ALGORITHM,
+                    algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+                    term_id=0,
+                    stage="final",
+                    result_leg=0,
+                    left_covered_legs=(1, 2),
+                    right_covered_legs=(3,),
+                    source_particle_legs=(-1, 3, 0),
+                    reconstruction_factor="1",
+                ),
+                CompiledContactOrbitStep(
+                    algorithm=CONTACT_ORBIT_ALGORITHM,
+                    algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+                    term_id=0,
+                    stage="final",
+                    result_leg=0,
+                    left_covered_legs=(3,),
+                    right_covered_legs=(1, 2),
+                    source_particle_legs=(3, -1, 0),
+                    reconstruction_factor="1",
+                ),
+            )
+        )
+    )
+    return (certificate,), steps
+
+
+def _heft_mirror_bindings() -> tuple[
+    PreparedVertexBinding, PreparedVertexBinding
+]:
+    certificate = CompiledContactOrbitCertificate(
+        algorithm=CONTACT_ORBIT_ALGORITHM,
+        algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+        term_id=91,
+        vertex="V_HEFT_HGGG",
+        particles=("g", "g", "g", "H"),
+        color_expression="f(1,2,3)",
+        lorentz_expression="heft-lorentz",
+        coupling_expression="heft-coupling",
+        evaluator_class=HEFT_CONTACT_ORBIT_EVALUATOR_CLASS,
+        physical_leg_equivalence_classes=(0, 0, 0, 1),
+        reconstruction_factor="1",
+    )
+    canonical_step = CompiledContactOrbitStep(
+        algorithm=CONTACT_ORBIT_ALGORITHM,
+        algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+        term_id=91,
+        stage="partial",
+        result_leg=0,
+        left_covered_legs=(2,),
+        right_covered_legs=(3,),
+        source_particle_legs=(2, 3, -1),
+        reconstruction_factor="1",
+    )
+    mirrored_step = replace(
+        canonical_step,
+        left_covered_legs=(3,),
+        right_covered_legs=(2,),
+        source_particle_legs=(3, 2, -1),
+    )
+    gluon = PreparedParticleState(21, "g", "self", "vector", 0, 4)
+    higgs = PreparedParticleState(25, "H", "self", "scalar", 0, 1)
+    auxiliary = PreparedParticleState(
+        9_050_001,
+        "heft-aux",
+        "self",
+        "auxiliary",
+        0,
+        20,
+    )
+    canonical = PreparedVertexBinding(
+        key=VertexKernelKey(100, (21, 25, 9_050_001), 0, 0, 0, (1.0, 0.0)),
+        kernel_id=10,
+        canonical_input_order=(1, 0),
+        equivalence_class="heft-identity",
+        equivalence_factor=(1.0, 0.0),
+        input_exchange_factor=None,
+        left_state=gluon,
+        right_state=higgs,
+        result_state=auxiliary,
+        contact_orbit_certificates=(certificate,),
+        contact_orbit_steps=(canonical_step,),
+    )
+    mirrored = PreparedVertexBinding(
+        key=VertexKernelKey(101, (25, 21, 9_050_001), 0, 0, 0, (1.0, 0.0)),
+        kernel_id=11,
+        canonical_input_order=(0, 1),
+        equivalence_class="heft-identity",
+        equivalence_factor=(1.0, 0.0),
+        input_exchange_factor=None,
+        left_state=higgs,
+        right_state=gluon,
+        result_state=auxiliary,
+        contact_orbit_certificates=(certificate,),
+        contact_orbit_steps=(mirrored_step,),
+    )
+    return canonical, mirrored
+
+
+def test_heft_recurrence_bindings_keep_one_certified_input_orientation() -> None:
+    canonical, mirrored = _heft_mirror_bindings()
+
+    assert _canonical_recurrence_vertex_bindings((mirrored, canonical)) == (
+        canonical,
+    )
+
+
+def test_heft_recurrence_binding_without_its_mirror_fails_closed() -> None:
+    _canonical, mirrored = _heft_mirror_bindings()
+
+    with pytest.raises(
+        PreparedKernelCatalogError,
+        match="no unique compiler-certified canonical orientation",
+    ):
+        _canonical_recurrence_vertex_bindings((mirrored,))
+
+
+class _OrbitScalarModel(_ScalarModel):
+    def vertex_contact_orbit_contracts(self, kind):
+        assert kind == 0
+        return _scalar_contact_orbit_contract()
+
+
+class _ReverseOrbitScalarModel(_ScalarModel):
+    def vertex_contact_orbit_contracts(self, kind):
+        assert kind == 0
+        certificates, steps = _scalar_contact_orbit_contract()
+        return certificates, tuple(reversed(steps))
+
+
+def _prepared_orbit_scalar_catalog(model, *, reverse_steps: bool = False):
+    certificates, steps = _scalar_contact_orbit_contract()
+    prepared = _scalar_catalog(model)
+    binding = replace(
+        prepared.vertex_bindings[0],
+        contact_orbit_certificates=certificates,
+        contact_orbit_steps=steps,
+    )
+    if reverse_steps:
+        # Exercise the builder's canonicalization independently of the
+        # prepared-catalog constructor's normal sorted-input invariant.
+        object.__setattr__(binding, "contact_orbit_steps", tuple(reversed(steps)))
+    prepared.vertex_bindings = (binding,)
+    return prepared
+
+
+def test_certified_contact_orbit_transitions_are_singleton_and_share_evaluator(
+) -> None:
+    model = _OrbitScalarModel()
+    _, steps = _scalar_contact_orbit_contract()
+    prepared = _prepared_orbit_scalar_catalog(model)
+
+    first = build_recurrence_template_catalog(
+        model,
+        prepared,  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+    second = build_recurrence_template_catalog(
+        model,
+        prepared,  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    assert first == second
+    assert first.catalog_digest == second.catalog_digest
+    assert len(first.transitions) == len(steps)
+    assert len({item.template_id for item in first.transitions}) == len(steps)
+    assert all(
+        len(item.contact_orbit_step_template_ids) == 1
+        and len(item.contact_orbit_step_semantic_digests) == 1
+        for item in first.transitions
+    )
+    assert {
+        item.contact_orbit_step_template_ids[0] for item in first.transitions
+    } == {item.template_id for item in first.contact_orbit_steps}
+    vertex_evaluators = tuple(
+        item
+        for item in first.evaluator_bindings
+        if item.contract_kind == "vertex"
+    )
+    assert len(vertex_evaluators) == 1
+    assert vertex_evaluators[0].semantic_template_ids == tuple(
+        sorted(item.template_id for item in first.transitions)
+    )
+    assert {
+        item.evaluator_resolver_key for item in first.transitions
+    } == {vertex_evaluators[0].resolver_key}
+
+
+def test_contact_orbit_singleton_expansion_ignores_step_input_order() -> None:
+    model = _OrbitScalarModel()
+    prepared = _prepared_orbit_scalar_catalog(model)
+    catalog = build_recurrence_template_catalog(
+        model,
+        prepared,  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+    steps = catalog.contact_orbit_steps
+    assert _singleton_contact_orbit_step_groups(steps) == (
+        _singleton_contact_orbit_step_groups(tuple(reversed(steps)))
+    )
+
+    reverse_model = _ReverseOrbitScalarModel()
+    reverse_catalog = build_recurrence_template_catalog(
+        reverse_model,
+        _prepared_orbit_scalar_catalog(reverse_model, reverse_steps=True),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+    assert reverse_catalog == catalog
+    assert reverse_catalog.catalog_digest == catalog.catalog_digest
+
+
+def test_contact_orbit_expansion_preserves_uncertified_catalog_identity() -> None:
+    ordinary_model = _ScalarModel()
+    ordinary = build_recurrence_template_catalog(
+        ordinary_model,
+        _scalar_catalog(ordinary_model),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+    assert ordinary.catalog_digest == (
+        "67c63dda28fc341b090f1b4477b5665d1717465e4282bff364409031176baab3"
+    )
+    assert tuple(item.template_id for item in ordinary.transitions) == (
+        "transition:b0dde38995251bc098e9e1d0",
+    )
+    ordinary_vertex = next(
+        item for item in ordinary.evaluator_bindings if item.contract_kind == "vertex"
+    )
+    assert (
+        ordinary_vertex.resolver_key,
+        ordinary_vertex.prepared_kernel_id,
+        ordinary_vertex.callable_signature,
+        ordinary_vertex.exact_expression_digests,
+        ordinary_vertex.semantic_template_ids,
+    ) == (
+        "evaluator:947ab283dac851256e1b9d95",
+        1,
+        "fa1ddc519b10118458d46aba316aa6115fea6f481bb06b9e763aca4be7083ef8",
+        ("ba1269aaec248bfeaab4026b5cd7694f7516905d4eb8cdbf0177842c5ea238de",),
+        ("transition:b0dde38995251bc098e9e1d0",),
+    )
+
+    orbit_model = _OrbitScalarModel()
+    orbit = build_recurrence_template_catalog(
+        orbit_model,
+        _prepared_orbit_scalar_catalog(orbit_model),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+    orbit_vertex = next(
+        item for item in orbit.evaluator_bindings if item.contract_kind == "vertex"
+    )
+    assert (
+        orbit_vertex.resolver_key,
+        orbit_vertex.prepared_kernel_id,
+        orbit_vertex.callable_signature,
+        orbit_vertex.input_state_template_ids,
+        orbit_vertex.output_state_template_id,
+        orbit_vertex.input_layout,
+        orbit_vertex.output_layout,
+        orbit_vertex.exact_expression_digests,
+        orbit_vertex.callable_kind,
+        orbit_vertex.runtime_template,
+    ) == (
+        ordinary_vertex.resolver_key,
+        ordinary_vertex.prepared_kernel_id,
+        ordinary_vertex.callable_signature,
+        ordinary_vertex.input_state_template_ids,
+        ordinary_vertex.output_state_template_id,
+        ordinary_vertex.input_layout,
+        ordinary_vertex.output_layout,
+        ordinary_vertex.exact_expression_digests,
+        ordinary_vertex.callable_kind,
+        ordinary_vertex.runtime_template,
+    )
+    assert orbit_vertex.semantic_template_ids == tuple(
+        sorted(item.template_id for item in orbit.transitions)
+    )
+
+
+def test_model_generic_scalar_catalog_covers_source_flow_color_and_propagator() -> None:
+    model = _ScalarModel()
+    catalog = build_recurrence_template_catalog(
+        model,
+        _scalar_catalog(model),  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    assert len(catalog.current_states) == 1
+    assert len(catalog.sources) == 1
+    assert len(catalog.quantum_flows) == 1
+    assert len(catalog.transitions) == 1
+    assert len(catalog.propagators) == 1
+    assert not catalog.propagators[0].applies_propagator
+    assert catalog.color_contractions[0].rule_kind == "singlet"
+    assert len(catalog.runtime_helicity_contracts) == 1
+    assert (
+        catalog.runtime_helicity_contracts[0].full_state_template_id
+        == catalog.current_states[0].template_id
+    )
+    catalog.require_complete_runtime_helicity_contracts()
+    assert {item.contract_kind for item in catalog.evaluator_bindings} == {
+        "source",
+        "vertex",
+    }
+    assert "built-in" not in catalog.canonical_json
+    assert "ufo" not in catalog.canonical_json.lower()
+    assert not catalog.symmetry_proofs
+
+
+class _AdjointReflectionScalarModel(_ScalarModel):
+    def color_rep(self, pdg):
+        assert pdg == 101
+        return 8
+
+    def vertex_color_structure(self, vertex):
+        assert vertex.kind == 0
+        return "adjoint-structure-constant"
+
+    def recurrence_lc_color_transition_contract(self, vertex, *, closure):
+        assert vertex.kind == 0
+        assert not closure
+        return RecurrenceLCColorTransitionContract(
+            "adjoint-structure-constant",
+            (
+                RecurrenceLCColorWitnessContract(
+                    input_permutation=(0, 1),
+                    reverse_parent_mask=0,
+                    component_operation="concatenate-join",
+                    result_component_kind="adjoint-segment",
+                    result_component_role="active",
+                ),
+                RecurrenceLCColorWitnessContract(
+                    input_permutation=(1, 0),
+                    reverse_parent_mask=0,
+                    component_operation="concatenate-join",
+                    result_component_kind="adjoint-segment",
+                    result_component_role="active",
+                    exact_factor=(-1.0, 0.0),
+                ),
+            ),
+        )
+
+
+class _ReflectionScalarModel(_AdjointReflectionScalarModel):
+    def __init__(self, phase: tuple[float, float]) -> None:
+        super().__init__()
+        self._reflection_phase = phase
+
+    def adjoint_current_reflection_phase(self, vertex):
+        assert vertex.kind == 0
+        return self._reflection_phase
+
+
+def test_transition_reflection_proof_authenticates_kernel_and_model_callback() -> None:
+    model = _ReflectionScalarModel((-1.0, 0.0))
+    catalog = build_recurrence_template_catalog(
+        model,
+        _scalar_catalog(model),  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    proof = next(
+        item
+        for item in catalog.symmetry_proofs
+        if item.proof_algorithm == "canonical-current-word-reversal-v1"
+    )
+    assert proof.subject_template_ids == (catalog.transitions[0].template_id,)
+    assert proof.input_permutation == (1, 0)
+    assert proof.exact_phase == ExactComplexRationalV1.from_binary64(-1.0)
+    assert proof.expression_digests == (hashlib.sha256(b"left0*right0").hexdigest(),)
+
+    changed_callback_model = _ReflectionScalarModel((1.0, 0.0))
+    with pytest.raises(RecurrenceTemplateError, match="conflicting"):
+        build_recurrence_template_catalog(
+            changed_callback_model,
+            _scalar_catalog(changed_callback_model),  # type: ignore[arg-type]
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+    changed_kernel_model = _ReflectionScalarModel((-1.0, 0.0))
+    changed_kernel = build_recurrence_template_catalog(
+        changed_kernel_model,
+        _scalar_catalog(  # type: ignore[arg-type]
+            changed_kernel_model,
+            vertex_expression="right0*left0",
+        ),
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    ).symmetry_proofs[0]
+    assert changed_kernel.expression_digests != proof.expression_digests
+    assert changed_kernel.witness_digest != proof.witness_digest
+
+
+class _PreparedExchangeReflectionModel(_AdjointReflectionScalarModel):
+    def vertex_evaluation_equivalence(self, kind):
+        assert kind == 0
+        return VertexEvaluationEquivalence(
+            class_id="scalar-exchange-proof",
+            input_exchange_factor=(-1.0, 0.0),
+        )
+
+
+def test_transition_reflection_proof_accepts_exact_color_witness_pair() -> None:
+    model = _AdjointReflectionScalarModel()
+    catalog = build_recurrence_template_catalog(
+        model,
+        _scalar_catalog(model),  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    proof = next(
+        item
+        for item in catalog.symmetry_proofs
+        if item.proof_algorithm == "canonical-current-word-reversal-v1"
+    )
+    assert proof.subject_template_ids == (catalog.transitions[0].template_id,)
+    assert proof.input_permutation == (1, 0)
+    assert proof.exact_phase == ExactComplexRationalV1.from_binary64(-1.0)
+
+
+def test_transition_reflection_proof_accepts_prepared_input_exchange() -> None:
+    model = _PreparedExchangeReflectionModel()
+    catalog = build_recurrence_template_catalog(
+        model,
+        _scalar_catalog(model),  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    proof = next(
+        item
+        for item in catalog.symmetry_proofs
+        if item.proof_algorithm == "canonical-current-word-reversal-v1"
+    )
+    assert proof.subject_template_ids == (catalog.transitions[0].template_id,)
+    assert proof.input_permutation == (1, 0)
+    assert proof.exact_phase == ExactComplexRationalV1.from_binary64(-1.0)
+
+
+class _ConflictingPreparedExchangeReflectionModel(_PreparedExchangeReflectionModel):
+    def adjoint_current_reflection_phase(self, vertex):
+        assert vertex.kind == 0
+        return (1.0, 0.0)
+
+
+def test_prepared_and_callback_reflection_disagreement_fails_closed() -> None:
+    model = _ConflictingPreparedExchangeReflectionModel()
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="conflicting",
+    ):
+        build_recurrence_template_catalog(
+            model,
+            _scalar_catalog(model),  # type: ignore[arg-type]
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+class _NondeterministicReflectionModel(_AdjointReflectionScalarModel):
+    def __init__(self) -> None:
+        super().__init__()
+        self._reflection_calls = 0
+
+    def adjoint_current_reflection_phase(self, vertex):
+        assert vertex.kind == 0
+        self._reflection_calls += 1
+        return ((-1.0 if self._reflection_calls % 2 else 1.0), 0.0)
+
+
+def test_nondeterministic_transition_reflection_callback_fails_closed() -> None:
+    model = _NondeterministicReflectionModel()
+    with pytest.raises(RecurrenceTemplateError, match="nondeterministic"):
+        build_recurrence_template_catalog(
+            model,
+            _scalar_catalog(model),  # type: ignore[arg-type]
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+def test_source_fill_uses_a_generic_runtime_template() -> None:
+    model = _ScalarModel()
+    model.recurrence_source_kernel_id = None  # type: ignore[method-assign]
+    catalog = build_recurrence_template_catalog(
+        model,
+        _scalar_catalog(model),  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    source = next(
+        binding
+        for binding in catalog.evaluator_bindings
+        if binding.contract_kind == "source"
+    )
+    assert source.callable_kind == "rusticol-template"
+    assert source.prepared_kernel_id is None
+    assert source.runtime_template is not None
+    assert source.runtime_template.startswith("rusticol.source-fill.scalar.v1:")
+
+
+class _GhostFilteringModel(_ScalarModel):
+    def __init__(self) -> None:
+        super().__init__()
+        ghost = Particle(
+            pdg=909,
+            anti_pdg=-909,
+            spin=-1,
+            dimension=1,
+            color_rep=8,
+        )
+        anti_ghost = replace(ghost, pdg=-909, anti_pdg=909)
+        self.particles = {**self.particles, 909: ghost, -909: anti_ghost}
+        self.vertices = (*self.vertices, Vertex(1, (909, -909, 101)))
+
+    def source_wavefunction_kind(self, particle_id):
+        if abs(int(particle_id)) == 909:
+            return "ghost"
+        return super().source_wavefunction_kind(particle_id)
+
+
+def test_ghost_only_bindings_are_excluded_from_recurrence_semantics() -> None:
+    model = _GhostFilteringModel()
+    prepared = _scalar_catalog(model)
+    physical = prepared.vertex_bindings[0]
+    ghost_left = PreparedParticleState(
+        particle_id=909,
+        identity=model._particle_identity_ir(909).canonical_id,
+        orientation=model._particle_identity_ir(909).orientation,
+        basis=model._current_basis(909, 0),
+        chirality=0,
+        dimension=1,
+    )
+    ghost_right = PreparedParticleState(
+        particle_id=-909,
+        identity=model._particle_identity_ir(-909).canonical_id,
+        orientation=model._particle_identity_ir(-909).orientation,
+        basis=model._current_basis(-909, 0),
+        chirality=0,
+        dimension=1,
+    )
+    ghost_binding = PreparedVertexBinding(
+        key=VertexKernelKey(1, (909, -909, 101), 0, 0, 0, (1.0, 0.0)),
+        kernel_id=physical.kernel_id,
+        canonical_input_order=(0, 1),
+        equivalence_class="ghost-interaction",
+        equivalence_factor=(1.0, 0.0),
+        input_exchange_factor=None,
+        left_state=ghost_left,
+        right_state=ghost_right,
+        result_state=physical.result_state,
+    )
+    prepared.vertex_bindings = (physical, ghost_binding)
+
+    catalog = build_recurrence_template_catalog(
+        model,
+        prepared,  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    assert {state.particle_id for state in catalog.current_states} == {101}
+    assert len(catalog.transitions) == 1
+    assert all("ghost" not in item.contract_kind for item in catalog.evaluator_bindings)
+
+
+def test_direct_contraction_uses_exact_runtime_closure_template() -> None:
+    model = _ScalarModel()
+    model._direct_contraction_ir_by_state = {
+        (101, 0, 101, 0): ContractionIR(
+            name="generic-scalar-pairing",
+            left_basis="scalar",
+            right_basis="scalar",
+            coefficients=((0.5, 0.0),),
+        )
+    }
+
+    catalog = build_recurrence_template_catalog(
+        model,
+        _scalar_catalog(model),  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    assert len(catalog.closures) == 1
+    closure = catalog.closures[0]
+    assert closure.component_coefficients == (
+        ExactComplexRationalV1.from_binary64(0.5),
+    )
+    evaluator = next(
+        binding
+        for binding in catalog.evaluator_bindings
+        if binding.resolver_key == closure.evaluator_resolver_key
+    )
+    assert evaluator.callable_kind == "rusticol-template"
+    assert evaluator.runtime_template is not None
+    assert evaluator.runtime_template.startswith("rusticol.closure-reduce.v1:")
+
+
+def test_mutated_vertex_equivalence_factor_is_rejected() -> None:
+    model = _ScalarModel()
+    catalog = _scalar_catalog(model)
+    binding = replace(catalog.vertex_bindings[0], equivalence_factor=(-1.0, 0.0))
+    catalog.vertex_bindings = (binding,)
+    with pytest.raises(PreparedKernelCatalogError, match=r"stale.*proof metadata"):
+        build_recurrence_template_catalog(
+            model,
+            catalog,  # type: ignore[arg-type]
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+class _NondeterministicFlowModel(_ScalarModel):
+    def __init__(self) -> None:
+        super().__init__()
+        self._flow_calls = 0
+
+    def allowed_quantum_flows(self, vertex, left_index, right_index):
+        self._flow_calls += 1
+        coupling = (1.0 if self._flow_calls % 2 else 2.0, 0.0)
+        return (
+            QuantumFlow(
+                chirality=0,
+                spin_state=0,
+                flavour_flow=(101,),
+                quantum_number_flow=(("generic-charge", "0"),),
+                coupling=coupling,
+            ),
+        )
+
+    def recurrence_quantum_flow_contract(
+        self, vertex, left_particle_id, right_particle_id
+    ):
+        return super().recurrence_quantum_flow_contract(
+            vertex, left_particle_id, right_particle_id
+        )
+
+
+def test_nondeterministic_quantum_flow_callback_fails_closed() -> None:
+    model = _NondeterministicFlowModel()
+    with pytest.raises(RecurrenceTemplateError, match="nondeterministic"):
+        build_recurrence_template_catalog(
+            model,
+            _scalar_catalog(model),  # type: ignore[arg-type]
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+class _UndeclaredDynamicFlowModel(_ScalarModel):
+    def allowed_quantum_flows(self, vertex, left_index, right_index):
+        return super().allowed_quantum_flows(vertex, left_index, right_index)
+
+
+def test_quantum_flow_override_requires_an_explicit_matching_contract() -> None:
+    model = _UndeclaredDynamicFlowModel()
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="overrides the callback without declaring a matching recurrence",
+    ):
+        build_recurrence_template_catalog(
+            model,
+            _scalar_catalog(model),  # type: ignore[arg-type]
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+class _UndeclaredFlavourCombinationModel(_ScalarModel):
+    def combine_flavour_flow(self, result_particle, left_index, right_index):
+        return (
+            *left_index.flavour_flow,
+            *right_index.flavour_flow,
+            result_particle,
+        )
+
+
+def test_flavour_combination_override_requires_an_explicit_matching_contract() -> None:
+    model = _UndeclaredFlavourCombinationModel()
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="combine_flavour_flow overrides the callback without declaring "
+        "a matching recurrence",
+    ):
+        build_recurrence_template_catalog(
+            model,
+            _scalar_catalog(model),  # type: ignore[arg-type]
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+def test_standard_flavour_flow_drops_closed_boson_ancestry_only() -> None:
+    model = BuiltinSMModel()
+    fermion_left = SimpleNamespace(particle_id=1, flavour_flow=(11,))
+    fermion_right = SimpleNamespace(particle_id=-1, flavour_flow=(13,))
+    boson = SimpleNamespace(particle_id=21, flavour_flow=(21,))
+
+    assert model.combine_flavour_flow(21, fermion_left, fermion_right) == (21,)
+    assert model.combine_flavour_flow(1, fermion_left, boson) == (11, 1)
+    assert model.combine_flavour_flow(1, boson, fermion_right) == (13, 1)
+    assert (
+        model._standard_recurrence_quantum_flow_contract(
+            Vertex(kind=0, particles=(1, -1, 21)),
+            1,
+            -1,
+        ).flavour_flow_operation
+        == "constant-result"
+    )
+    assert (
+        model._standard_recurrence_quantum_flow_contract(
+            Vertex(kind=0, particles=(1, 21, 1)),
+            1,
+            21,
+        ).flavour_flow_operation
+        == "append-left-result"
+    )
+    assert (
+        model._standard_recurrence_quantum_flow_contract(
+            Vertex(kind=0, particles=(21, -1, 1)),
+            21,
+            -1,
+        ).flavour_flow_operation
+        == "append-right-result"
+    )
+
+
+class _DeclaredFlavourCombinationModel(_UndeclaredFlavourCombinationModel):
+    def recurrence_quantum_flow_contract(
+        self,
+        vertex,
+        left_particle_id,
+        right_particle_id,
+    ):
+        del vertex, left_particle_id, right_particle_id
+        return RecurrenceQuantumFlowContract(
+            flavour_flow_operation="concat-left-right-result",
+            quantum_number_flow_operation="particle-static-result",
+        )
+
+
+def test_explicit_flavour_combination_contract_preserves_ancestry() -> None:
+    model = _DeclaredFlavourCombinationModel()
+    catalog = build_recurrence_template_catalog(
+        model,
+        _scalar_catalog(model),  # type: ignore[arg-type]
+        compiled_model_digest=_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PACK_DIGEST,
+    )
+
+    assert {
+        (
+            flow.flavour_flow_operation,
+            flow.input_flavour_flows,
+            flow.result_flavour_flow,
+        )
+        for flow in catalog.quantum_flows
+    } == {
+        (
+            "concat-left-right-result",
+            ((101,), (101,)),
+            (101, 101, 101),
+        )
+    }
+
+
+class _DynamicQuantumNumberFlowModel(_ScalarModel):
+    def allowed_quantum_flows(self, vertex, left_index, right_index):
+        flow = super().allowed_quantum_flows(vertex, left_index, right_index)[0]
+        return (
+            replace(
+                flow,
+                quantum_number_flow=tuple(left_index.quantum_number_flow),
+            ),
+        )
+
+    def recurrence_quantum_flow_contract(
+        self, vertex, left_particle_id, right_particle_id
+    ):
+        return super().recurrence_quantum_flow_contract(
+            vertex, left_particle_id, right_particle_id
+        )
+
+
+def test_dynamic_quantum_number_flow_contradicts_static_contract() -> None:
+    model = _DynamicQuantumNumberFlowModel()
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="particle-static quantum-number operation",
+    ):
+        build_recurrence_template_catalog(
+            model,
+            _scalar_catalog(model),  # type: ignore[arg-type]
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+class _UnsupportedColorModel(_ScalarModel):
+    def vertex_color_structure(self, vertex):
+        del vertex
+        return "opaque-model-tensor"
+
+    def recurrence_lc_color_transition_contract(self, vertex, *, closure):
+        del vertex, closure
+        return RecurrenceLCColorTransitionContract(
+            "opaque-model-tensor",
+            (
+                RecurrenceLCColorWitnessContract(
+                    input_permutation=(0, 1),
+                    reverse_parent_mask=0,
+                    component_operation="concatenate-keep",
+                    result_component_kind=None,
+                    result_component_role="none",
+                ),
+            ),
+        )
+
+
+class _UndeclaredColorOverrideModel(_ScalarModel):
+    def vertex_color_structure(self, vertex):
+        del vertex
+        return "singlet"
+
+
+def test_color_callback_override_requires_matching_recurrence_contract() -> None:
+    model = _UndeclaredColorOverrideModel()
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="without declaring a matching recurrence LC color contract",
+    ):
+        build_recurrence_template_catalog(
+            model,
+            _scalar_catalog(model),  # type: ignore[arg-type]
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+def test_unsupported_color_semantics_fail_closed() -> None:
+    model = _UnsupportedColorModel()
+    with pytest.raises(RecurrenceTemplateError, match="cannot encode color rule"):
+        build_recurrence_template_catalog(
+            model,
+            _scalar_catalog(model),  # type: ignore[arg-type]
+            compiled_model_digest=_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PACK_DIGEST,
+        )
+
+
+def test_builtin_color_tensor_families_are_model_owned() -> None:
+    model = BuiltinSMModel()
+    expected = {
+        (8, 8, 8): "adjoint-structure-constant",
+        (8, 3, 3): "fundamental-generator",
+        (3, 8, 3): "fundamental-generator",
+        (-3, 3, 8): "fundamental-generator",
+        (1, 3, 3): "color-identity",
+        (3, -3, 1): "color-identity",
+        (1, 1, 1): "singlet",
+    }
+    observed = {
+        representations: model.vertex_color_structure(vertex)
+        for vertex in model.vertices
+        if (representations := tuple(model.color_rep(p) for p in vertex.particles))
+        in expected
+    }
+    for representations, rule_kind in expected.items():
+        assert observed[representations] == rule_kind
+
+
+def test_builtin_fundamental_color_words_follow_kernel_orientation() -> None:
+    model = BuiltinSMModel()
+    expected = {
+        4: ((1, 0), "open-string"),
+        5: ((0, 1), "open-string"),
+        6: ((0, 1), "open-string"),
+        7: ((1, 0), "open-string"),
+        9: ((1, 0), "adjoint-segment"),
+    }
+    observed: dict[int, tuple[tuple[int, int], str | None]] = {}
+    for vertex in model.vertices:
+        if vertex.kind not in expected or vertex.kind in observed:
+            continue
+        contract = model.recurrence_lc_color_transition_contract(
+            vertex,
+            closure=False,
+        )
+        assert contract.rule_kind == "fundamental-generator"
+        assert len(contract.witnesses) == 1
+        witness = contract.witnesses[0]
+        assert witness.component_operation == "concatenate-join"
+        observed[vertex.kind] = (
+            witness.input_permutation,
+            witness.result_component_kind,
+        )
+    assert observed == expected
diff --git a/pyamplicol/tests/unit/test_recurrence_closure_reconstruction.py b/pyamplicol/tests/unit/test_recurrence_closure_reconstruction.py
new file mode 100644
index 0000000000..73f54efabe
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_closure_reconstruction.py
@@ -0,0 +1,185 @@
+# SPDX-License-Identifier: 0BSD
+"""Authenticated roots for model-generic recurrence closure obligations."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import replace
+
+import pytest
+
+from pyamplicol.color.plan import GenericColorPlan, LCColorSector
+from pyamplicol.generation.recurrence_columnar import (
+    RecurrencePhysicalLCSectorV1,
+)
+from pyamplicol.generation.recurrence_fermion_pairing import (
+    FermionPairingCatalogV1,
+)
+from pyamplicol.generation.recurrence_projection import (
+    _project_closure_obligation_roots_digest,
+)
+from pyamplicol.models.recurrence_template import (
+    ExactComplexRationalV1,
+    LCColorTransitionWitnessV1,
+    RecurrenceTemplateCatalog,
+)
+from pyamplicol.processes.ir import (
+    CanonicalProcessIR,
+    ColorEndpointSummary,
+    ProcessLegIR,
+)
+
+
+def _sha256(label: str) -> str:
+    return hashlib.sha256(label.encode("ascii")).hexdigest()
+
+
+def _factor(real: int, imag: int = 0) -> ExactComplexRationalV1:
+    return ExactComplexRationalV1(real, 1, imag, 1)
+
+
+def _process() -> CanonicalProcessIR:
+    legs = tuple(
+        ProcessLegIR(
+            label,
+            "initial" if label <= 2 else "final",
+            "g",
+            "g",
+            21,
+            21,
+            "boson",
+            "vector",
+            "adjoint",
+            "self-conjugate",
+        )
+        for label in range(1, 5)
+    )
+    return CanonicalProcessIR(
+        process="g g > g g",
+        key="g_g_to_g_g",
+        color_accuracy="lc",
+        legs=legs,
+        color_endpoints=ColorEndpointSummary(0, 0, 0),
+    )
+
+
+def _color_plan(process: CanonicalProcessIR) -> GenericColorPlan:
+    return GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=(1, 2, 3, 4),
+                word_labels=(1, 2, 3, 4),
+            ),
+        ),
+    )
+
+
+def _template_catalog() -> RecurrenceTemplateCatalog:
+    return RecurrenceTemplateCatalog.create(
+        compiled_model_digest=_sha256("compiled-model"),
+        prepared_kernel_pack_digest=_sha256("prepared-kernel-pack"),
+    )
+
+
+def _sector() -> RecurrencePhysicalLCSectorV1:
+    return RecurrencePhysicalLCSectorV1(
+        sector_id=0,
+        public_id="flow:1,2,3,4",
+        kind="single-trace",
+        closure_source_slot=0,
+        closure_proof_algorithm="canonical-lc-closure-anchor-v2",
+        closure_proof_digest=_sha256("closure-proof"),
+        trace_source_slots=(0, 1, 2, 3),
+        word_source_slots=(0, 1, 2, 3),
+        support_mask=1,
+    )
+
+
+def _pairing_catalog() -> FermionPairingCatalogV1:
+    return FermionPairingCatalogV1(
+        process_key="g_g_to_g_g",
+        source_count=4,
+        endpoints=(),
+        pairing_classes=(),
+        rules=(),
+        topology_digest=_sha256("pairing-topology"),
+        semantic_digest=_sha256("pairing-semantics"),
+    )
+
+
+def _obligation_roots_digest(
+    *,
+    sector: RecurrencePhysicalLCSectorV1 | None = None,
+    pairing: FermionPairingCatalogV1 | None = None,
+    reflection_contract: tuple[
+        ExactComplexRationalV1 | None,
+        str | None,
+    ] = (None, None),
+) -> str:
+    process = _process()
+    return _project_closure_obligation_roots_digest(
+        process,
+        _color_plan(process),
+        _template_catalog(),
+        (_sector() if sector is None else sector,),
+        _pairing_catalog() if pairing is None else pairing,
+        reflection_contract=reflection_contract,
+    )
+
+
+def test_reflected_pure_gluon_witness_preserves_exact_phase() -> None:
+    witness = LCColorTransitionWitnessV1(
+        input_shape_kinds=("adjoint-segment", "adjoint-segment"),
+        input_permutation=(1, 0),
+        reverse_parent_mask=0b11,
+        component_operation="close",
+        result_component_kind=None,
+        result_component_role="none",
+        result_shape_kind=None,
+        exact_factor=_factor(-1),
+        proof_digest=_sha256("pure-gluon-reflection"),
+    )
+
+    payload = witness.to_dict()
+    assert payload["input_permutation"] == [1, 0]
+    assert payload["reverse_parent_mask"] == 0b11
+    assert payload["exact_factor"] == _factor(-1).to_dict()
+
+
+def test_obligation_roots_digest_binds_exact_sector_closure_proof() -> None:
+    sector = _sector()
+
+    assert _obligation_roots_digest(sector=sector) != _obligation_roots_digest(
+        sector=replace(
+            sector,
+            closure_proof_digest=_sha256("different-closure-proof"),
+        )
+    )
+
+
+@pytest.mark.parametrize("digest_field", ["semantic_digest", "topology_digest"])
+def test_obligation_roots_digest_binds_fermion_pairing_catalog(
+    digest_field: str,
+) -> None:
+    pairing = _pairing_catalog()
+
+    assert _obligation_roots_digest(pairing=pairing) != _obligation_roots_digest(
+        pairing=replace(
+            pairing,
+            **{digest_field: _sha256(f"different-{digest_field}")},
+        )
+    )
+
+
+def test_obligation_roots_digest_binds_exact_reflection_proof() -> None:
+    phase = _factor(-1)
+
+    assert _obligation_roots_digest(
+        reflection_contract=(phase, _sha256("reflection-proof-a"))
+    ) != _obligation_roots_digest(
+        reflection_contract=(phase, _sha256("reflection-proof-b"))
+    )
diff --git a/pyamplicol/tests/unit/test_recurrence_columnar.py b/pyamplicol/tests/unit/test_recurrence_columnar.py
new file mode 100644
index 0000000000..3483d8f107
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_columnar.py
@@ -0,0 +1,1041 @@
+# SPDX-License-Identifier: 0BSD
+"""Contracts for the Python-to-Rust recurrence builder input."""
+
+from __future__ import annotations
+
+import ast
+import hashlib
+import inspect
+from dataclasses import replace
+
+import numpy as np
+import pytest
+
+import pyamplicol.generation.recurrence_columnar as recurrence_columnar
+from pyamplicol.generation.recurrence_columnar import (
+    RECURRENCE_BUILDER_INPUT_ABI,
+    ExactComplexRationalV1,
+    RecurrenceBuilderInputV1,
+    RecurrenceBuilderLogicalInputV1,
+    RecurrenceColumn,
+    RecurrenceColumnarInputError,
+    RecurrenceColumnarTable,
+    RecurrenceCouplingLimitV1,
+    RecurrenceExternalLegV1,
+    RecurrenceLCOpenStringV1,
+    RecurrenceNormalizationV1,
+    RecurrenceParameterProjectionV1,
+    RecurrencePhysicalLCSectorV1,
+    RecurrencePublicLCFlowV1,
+    RecurrenceReplayPartitionV1,
+    RecurrenceReplayTargetV1,
+    RecurrenceSelectedSourceCoverageV1,
+    RecurrenceSemanticDigestV1,
+    RecurrenceSemanticTemplateReferenceV1,
+    RecurrenceSourceStateV1,
+    build_recurrence_builder_input_v1,
+)
+from pyamplicol.generation.recurrence_fermion_pairing import (
+    build_recurrence_fermion_pairing_catalog_v1,
+)
+from pyamplicol.models.recurrence_template import CurrentStateTemplateV1
+from pyamplicol.processes.ir import (
+    CanonicalProcessIR,
+    ColorEndpointSummary,
+    ProcessLegIR,
+)
+
+
+def _sha256(label: str) -> str:
+    return hashlib.sha256(label.encode("ascii")).hexdigest()
+
+
+def _pairing_state(particle_id: int) -> CurrentStateTemplateV1:
+    orientation = "particle" if particle_id > 0 else "antiparticle"
+    return CurrentStateTemplateV1(
+        template_id=f"state:{orientation}:down",
+        particle_id=particle_id,
+        anti_particle_id=-particle_id,
+        species_id="species:down",
+        orientation=orientation,
+        statistics="fermion",
+        color_representation=3 if particle_id > 0 else -3,
+        basis="weyl",
+        tensor_ordering=("weyl:0", "weyl:1"),
+        dimension=2,
+        chirality=0,
+        lc_color_shape_kind=(
+            "fundamental-open-string"
+            if particle_id > 0
+            else "antifundamental-open-string"
+        ),
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+
+
+def _logical_input_with_pairing() -> RecurrenceBuilderLogicalInputV1:
+    process = CanonicalProcessIR(
+        process="d d~ > g g",
+        key="d_dbar_to_g_g",
+        color_accuracy="lc",
+        legs=(
+            ProcessLegIR(
+                1,
+                "initial",
+                "d",
+                "d",
+                1,
+                1,
+                "fermion",
+                "fermion",
+                "fundamental",
+                "particle",
+            ),
+            ProcessLegIR(
+                2,
+                "initial",
+                "d~",
+                "d~",
+                -1,
+                -1,
+                "fermion",
+                "fermion",
+                "antifundamental",
+                "antiparticle",
+            ),
+            ProcessLegIR(
+                3,
+                "final",
+                "g",
+                "g",
+                21,
+                21,
+                "boson",
+                "vector",
+                "adjoint",
+                "self-conjugate",
+            ),
+            ProcessLegIR(
+                4,
+                "final",
+                "g",
+                "g",
+                21,
+                21,
+                "boson",
+                "vector",
+                "adjoint",
+                "self-conjugate",
+            ),
+        ),
+        color_endpoints=ColorEndpointSummary(1, 1, 1),
+    )
+    catalog = build_recurrence_fermion_pairing_catalog_v1(
+        process,
+        (_pairing_state(1), _pairing_state(-1)),
+    )
+    logical = _logical_input()
+    return replace(
+        logical,
+        semantic_digests=(
+            *logical.semantic_digests,
+            RecurrenceSemanticDigestV1(
+                "fermion-pairing-semantic",
+                catalog.semantic_digest,
+            ),
+            RecurrenceSemanticDigestV1(
+                "fermion-pairing-topology",
+                catalog.topology_digest,
+            ),
+        ),
+        fermion_pairing_catalog=catalog,
+    )
+
+
+def _template(
+    kind: str,
+    template_id: int,
+    *,
+    prepared_kernel_id: int | None = None,
+) -> RecurrenceSemanticTemplateReferenceV1:
+    return RecurrenceSemanticTemplateReferenceV1(
+        kind=kind,
+        template_id=template_id,
+        semantic_digest=_sha256(f"{kind}:{template_id}"),
+        prepared_kernel_id=prepared_kernel_id,
+    )
+
+
+def _logical_input(
+    *,
+    reverse_unordered_records: bool = False,
+) -> RecurrenceBuilderLogicalInputV1:
+    legs = (
+        RecurrenceExternalLegV1(
+            source_slot=0,
+            public_label=1,
+            physical_pdg=1,
+            outgoing_pdg=1,
+            is_initial=True,
+            is_fermionic=True,
+            source_states=(
+                RecurrenceSourceStateV1(0, -1, 0, -1, 10, 20),
+                RecurrenceSourceStateV1(1, 1, 0, 1, 10, 21),
+            ),
+            momentum_mask=(1 << 130) | (1 << 65) | 1,
+            support_mask=1,
+        ),
+        RecurrenceExternalLegV1(
+            source_slot=1,
+            public_label=2,
+            physical_pdg=-1,
+            outgoing_pdg=-1,
+            is_initial=True,
+            is_fermionic=True,
+            source_states=(
+                RecurrenceSourceStateV1(0, -1, 0, -1, 11, 22),
+                RecurrenceSourceStateV1(1, 1, 0, 1, 11, 23),
+            ),
+            momentum_mask=1 << 1,
+            support_mask=1 << 1,
+        ),
+        RecurrenceExternalLegV1(
+            source_slot=2,
+            public_label=3,
+            physical_pdg=21,
+            outgoing_pdg=21,
+            is_initial=False,
+            is_fermionic=False,
+            source_states=(
+                RecurrenceSourceStateV1(0, -1, 0, -1, 12, 24),
+                RecurrenceSourceStateV1(1, 1, 0, 1, 12, 25),
+            ),
+            momentum_mask=1 << 2,
+            support_mask=1 << 2,
+        ),
+        RecurrenceExternalLegV1(
+            source_slot=3,
+            public_label=4,
+            physical_pdg=21,
+            outgoing_pdg=21,
+            is_initial=False,
+            is_fermionic=False,
+            source_states=(
+                RecurrenceSourceStateV1(0, -1, 0, -1, 13, 24),
+                RecurrenceSourceStateV1(1, 1, 0, 1, 13, 25),
+            ),
+            momentum_mask=1 << 3,
+            support_mask=1 << 3,
+        ),
+    )
+    sectors = (
+        RecurrencePhysicalLCSectorV1(
+            sector_id=0,
+            public_id="flow:1,3,4,2",
+            kind="open-lines",
+            closure_source_slot=1,
+            closure_proof_algorithm="canonical-lc-closure-anchor-v2",
+            closure_proof_digest=_sha256("closure-anchor:0"),
+            open_strings=(RecurrenceLCOpenStringV1(0, 1, (2, 3)),),
+            word_source_slots=(0, 2, 3, 1),
+            support_mask=0b1111,
+        ),
+        RecurrencePhysicalLCSectorV1(
+            sector_id=1,
+            public_id="flow:1,4,3,2",
+            kind="open-lines",
+            closure_source_slot=1,
+            closure_proof_algorithm="canonical-lc-closure-anchor-v2",
+            closure_proof_digest=_sha256("closure-anchor:1"),
+            open_strings=(RecurrenceLCOpenStringV1(0, 1, (3, 2)),),
+            word_source_slots=(0, 3, 2, 1),
+            support_mask=0b1111,
+        ),
+    )
+    public_flows = (
+        RecurrencePublicLCFlowV1(
+            0,
+            "flow:1,3,4,2",
+            0,
+            (0, 2, 3, 1),
+            (0, 1, 2, 3),
+        ),
+        RecurrencePublicLCFlowV1(
+            1,
+            "flow:1,4,3,2",
+            1,
+            (0, 3, 2, 1),
+            (0, 1, 2, 3),
+        ),
+    )
+    targets = (
+        RecurrenceReplayTargetV1(
+            sector_id=0,
+            external_permutation=(0, 1, 2, 3),
+            source_slot_permutation=(0, 1, 2, 3),
+        ),
+        RecurrenceReplayTargetV1(
+            sector_id=1,
+            external_permutation=(0, 1, 3, 2),
+            source_slot_permutation=(0, 1, 3, 2),
+            amplitude_phase=ExactComplexRationalV1(-1),
+            fermion_sign=-1,
+        ),
+    )
+    partition = RecurrenceReplayPartitionV1(
+        representative_sector_id=0,
+        materialized_sector_id=0,
+        proof_algorithm="exact-source-permutation-v1",
+        proof_digest=_sha256("replay-proof"),
+        targets=targets[::-1] if reverse_unordered_records else targets,
+    )
+    templates = (
+        *(_template("current-state", value) for value in range(10, 14)),
+        *(_template("source", value) for value in range(20, 28)),
+        *(
+            _template("transition", 40, prepared_kernel_id=400),
+            _template("propagator", 41, prepared_kernel_id=401),
+            _template("closure", 42, prepared_kernel_id=402),
+            _template("parameter", 50),
+            _template("parameter", 51),
+        ),
+    )
+    semantic_digests = (
+        RecurrenceSemanticDigestV1("process", _sha256("process")),
+        RecurrenceSemanticDigestV1("model-catalog", _sha256("model")),
+        RecurrenceSemanticDigestV1("prepared-catalog", _sha256("prepared")),
+        RecurrenceSemanticDigestV1("color-plan", _sha256("color")),
+    )
+    coupling_limits = (
+        RecurrenceCouplingLimitV1("QCD", 0, 4),
+        RecurrenceCouplingLimitV1("QED", 0, 2),
+    )
+    parameters = (
+        RecurrenceParameterProjectionV1(0, "alpha_s", 50, 0),
+        RecurrenceParameterProjectionV1(1, "mass_6", 51, 1),
+    )
+    if reverse_unordered_records:
+        legs = legs[::-1]
+        sectors = sectors[::-1]
+        public_flows = public_flows[::-1]
+        templates = templates[::-1]
+        semantic_digests = semantic_digests[::-1]
+        coupling_limits = coupling_limits[::-1]
+        parameters = parameters[::-1]
+    return RecurrenceBuilderLogicalInputV1(
+        process_id="d_dbar_to_g_g",
+        layout="topology-replay",
+        semantic_digests=semantic_digests,
+        external_legs=legs,
+        physical_sectors=sectors,
+        public_flows=public_flows,
+        semantic_template_references=templates,
+        normalization=RecurrenceNormalizationV1(
+            factor=ExactComplexRationalV1(1, 4),
+            convention="spin-colour-average-v1",
+            semantic_digest=_sha256("normalization"),
+        ),
+        replay_partitions=(partition,),
+        selected_public_flow_ids=(1, 0),
+        selected_source_coverage=(
+            RecurrenceSelectedSourceCoverageV1(1, (1,)),
+            RecurrenceSelectedSourceCoverageV1(0, (0,)),
+            RecurrenceSelectedSourceCoverageV1(3, (0, 1)),
+            RecurrenceSelectedSourceCoverageV1(2, (0, 1)),
+        ),
+        coupling_limits=coupling_limits,
+        parameter_projection=parameters,
+        process_support_mask=(1 << 131) - 1,
+    )
+
+
+@pytest.fixture
+def logical_input() -> RecurrenceBuilderLogicalInputV1:
+    return _logical_input()
+
+
+@pytest.fixture
+def columnar_input(
+    logical_input: RecurrenceBuilderLogicalInputV1,
+) -> RecurrenceBuilderInputV1:
+    return build_recurrence_builder_input_v1(logical_input)
+
+
+def _table_bytes(value: RecurrenceBuilderInputV1) -> tuple[object, ...]:
+    return tuple(
+        (
+            table.name,
+            table.row_count,
+            tuple(
+                (
+                    column.name,
+                    column.values.dtype.str,
+                    column.values.shape,
+                    column.values.tobytes(order="C"),
+                )
+                for column in table.columns
+            ),
+        )
+        for table in value.tables
+    )
+
+
+def _replace_column(
+    value: RecurrenceBuilderInputV1,
+    table_name: str,
+    column_name: str,
+    replacement: np.ndarray[object, object],
+) -> tuple[RecurrenceColumnarTable, ...]:
+    replacement.flags.writeable = False
+    old = value.table(table_name)
+    columns = tuple(
+        RecurrenceColumn(column.name, replacement)
+        if column.name == column_name
+        else column
+        for column in old.columns
+    )
+    changed = RecurrenceColumnarTable(old.name, old.row_count, columns)
+    return tuple(
+        changed if table.name == table_name else table for table in value.tables
+    )
+
+
+def _rebuild_bitset(value: RecurrenceBuilderInputV1, bitset_id: int) -> int:
+    ranges = value.table("bitset_ranges")
+    words = value.table("bitset_words").column("value")
+    start = int(ranges.column("start")[bitset_id])
+    count = int(ranges.column("count")[bitset_id])
+    return sum(int(words[start + index]) << (64 * index) for index in range(count))
+
+
+def test_contract_has_owned_read_only_little_endian_tables(
+    columnar_input: RecurrenceBuilderInputV1,
+) -> None:
+    assert columnar_input.abi == RECURRENCE_BUILDER_INPUT_ABI
+    assert tuple(table.name for table in columnar_input.tables) == tuple(
+        sorted(table.name for table in columnar_input.tables)
+    )
+    expected = {
+        "header",
+        "header_digests",
+        "external_legs",
+        "source_states",
+        "physical_lc_sectors",
+        "public_lc_flows",
+        "lc_open_strings",
+        "replay_partitions",
+        "replay_targets",
+        "selected_public_flow_coverage",
+        "selected_source_coverage",
+        "coupling_limits",
+        "bitset_ranges",
+        "bitset_words",
+        "semantic_template_references",
+        "normalization",
+        "parameter_projection",
+        "string_ranges",
+        "string_bytes",
+        "u32_sequence_ranges",
+        "u32_sequence_values",
+    }
+    assert expected <= {table.name for table in columnar_input.tables}
+    header = columnar_input.table("header")
+    assert int(header.column("public_flow_count")[0]) == 2
+    sectors = columnar_input.table("physical_lc_sectors")
+    assert tuple(int(value) for value in sectors.column("closure_source_slot")) == (
+        1,
+        1,
+    )
+    assert sectors.column("closure_proof_digest_id").dtype.str == "<u4"
+    assert tuple(
+        int(value)
+        for value in columnar_input.table("external_legs").column("is_fermionic")
+    ) == (1, 1, 0, 0)
+    for table in columnar_input.tables:
+        for column in table.columns:
+            assert column.values.dtype != np.dtype("O")
+            assert column.values.flags.c_contiguous
+            assert column.values.flags.owndata
+            assert not column.values.flags.writeable
+            assert column.values.dtype.str[0] in {"<", "|"}
+
+
+def test_digest_and_bytes_ignore_nonsemantic_record_order() -> None:
+    first = build_recurrence_builder_input_v1(
+        _logical_input(reverse_unordered_records=False)
+    )
+    second = build_recurrence_builder_input_v1(
+        _logical_input(reverse_unordered_records=True)
+    )
+
+    assert first.canonical_digest == second.canonical_digest
+    assert _table_bytes(first) == _table_bytes(second)
+    first.require_digest(first.canonical_digest)
+    with pytest.raises(RecurrenceColumnarInputError, match="does not match"):
+        first.require_digest(_sha256("stale"))
+
+    changed_sector = replace(
+        _logical_input().physical_sectors[0],
+        closure_proof_digest=_sha256("different-closure-anchor-proof"),
+    )
+    changed = build_recurrence_builder_input_v1(
+        replace(
+            _logical_input(),
+            physical_sectors=(changed_sector, *_logical_input().physical_sectors[1:]),
+        )
+    )
+    assert changed.canonical_digest != first.canonical_digest
+
+
+def test_private_freeze_adopts_owned_columns_and_copies_views() -> None:
+    owned = np.arange(4, dtype=np.dtype("<u4"))
+    adopted = recurrence_columnar._freeze_table("owned", {"value": owned})
+
+    assert adopted.column("value") is owned
+    assert owned.flags.owndata
+    assert not owned.flags.writeable
+
+    backing = np.arange(8, dtype=np.dtype("<u4"))
+    view = backing[::2]
+    copied = recurrence_columnar._freeze_table("view", {"value": view})
+    frozen = copied.column("value")
+
+    assert frozen is not view
+    assert frozen.flags.owndata
+    assert frozen.flags.c_contiguous
+    assert not frozen.flags.writeable
+    assert np.array_equal(frozen, view)
+
+
+def test_process_owned_pairing_tables_are_deterministic_and_separately_digested() -> (
+    None
+):
+    logical = _logical_input_with_pairing()
+    first = build_recurrence_builder_input_v1(logical)
+    second = build_recurrence_builder_input_v1(logical)
+
+    assert first.canonical_digest == second.canonical_digest
+    assert first.fermion_pairing_digest == second.fermion_pairing_digest
+    assert first.fermion_pairing_digest is not None
+    assert len(first.fermion_pairing_digest) == 64
+    assert tuple(table.name for table in first.fermion_pairing_tables) == tuple(
+        table.name for table in second.fermion_pairing_tables
+    )
+    for left, right in zip(
+        first.fermion_pairing_tables,
+        second.fermion_pairing_tables,
+        strict=True,
+    ):
+        for left_column, right_column in zip(
+            left.columns,
+            right.columns,
+            strict=True,
+        ):
+            assert np.array_equal(left_column.values, right_column.values)
+
+    header = first.fermion_pairing_table("header")
+    assert int(header.column("endpoint_count")[0]) == 2
+    assert int(header.column("pairing_class_count")[0]) == 1
+    assert int(header.column("rule_count")[0]) == 1
+
+
+def test_pairing_catalog_identity_fails_closed_before_rust_binding() -> None:
+    logical = _logical_input_with_pairing()
+    assert logical.fermion_pairing_catalog is not None
+
+    with pytest.raises(RecurrenceColumnarInputError, match="digest roles"):
+        build_recurrence_builder_input_v1(
+            replace(
+                logical,
+                semantic_digests=tuple(
+                    item
+                    for item in logical.semantic_digests
+                    if not item.role.startswith("fermion-pairing-")
+                ),
+            )
+        )
+
+    with pytest.raises(RecurrenceColumnarInputError, match="process key"):
+        build_recurrence_builder_input_v1(
+            replace(
+                logical,
+                fermion_pairing_catalog=replace(
+                    logical.fermion_pairing_catalog,
+                    process_key="other_process",
+                ),
+            )
+        )
+
+
+def test_multiword_masks_are_flat_little_endian_u64(
+    columnar_input: RecurrenceBuilderInputV1,
+) -> None:
+    legs = columnar_input.table("external_legs")
+    mask_id = int(legs.column("momentum_mask_id")[0])
+    ranges = columnar_input.table("bitset_ranges")
+    start = int(ranges.column("start")[mask_id])
+    count = int(ranges.column("count")[mask_id])
+    words = columnar_input.table("bitset_words").column("value")
+
+    assert count == 3
+    assert words.dtype.str == "<u8"
+    assert int(words[start]) == 1
+    assert int(words[start + 1]) == 2
+    assert int(words[start + 2]) == 4
+    assert _rebuild_bitset(columnar_input, mask_id) == (1 << 130) | (1 << 65) | 1
+
+
+def test_flat_catalog_ranges_cover_values_exactly(
+    columnar_input: RecurrenceBuilderInputV1,
+) -> None:
+    for range_name, value_name in (
+        ("string_ranges", "string_bytes"),
+        ("u32_sequence_ranges", "u32_sequence_values"),
+        ("bitset_ranges", "bitset_words"),
+    ):
+        ranges = columnar_input.table(range_name)
+        cursor = 0
+        for row in range(ranges.row_count):
+            assert int(ranges.column("start")[row]) == cursor
+            cursor += int(ranges.column("count")[row])
+        assert cursor == columnar_input.table(value_name).row_count
+
+
+def test_contract_is_independent_of_generic_dag() -> None:
+    source = inspect.getsource(recurrence_columnar)
+    tree = ast.parse(source)
+    imported_modules = {
+        alias.name
+        for node in ast.walk(tree)
+        if isinstance(node, ast.Import)
+        for alias in node.names
+    }
+    imported_modules.update(
+        node.module or "" for node in ast.walk(tree) if isinstance(node, ast.ImportFrom)
+    )
+
+    assert not any(
+        isinstance(node, ast.Name) and node.id == "GenericDAG"
+        for node in ast.walk(tree)
+    )
+    assert not any("dag_types" in module for module in imported_modules)
+    header = build_recurrence_builder_input_v1(_logical_input()).table("header")
+    assert header.row_count == 1
+
+
+def test_exact_factor_requires_canonical_reduced_fractions() -> None:
+    with pytest.raises(RecurrenceColumnarInputError, match="must be reduced"):
+        ExactComplexRationalV1(2, 4)
+    with pytest.raises(RecurrenceColumnarInputError, match="encoded as 0/1"):
+        ExactComplexRationalV1(0, 2)
+    with pytest.raises(RecurrenceColumnarInputError, match="must be positive"):
+        ExactComplexRationalV1(1, -2)
+
+
+def test_checked_integer_bounds_reject_overflow_and_negative_masks() -> None:
+    with pytest.raises(RecurrenceColumnarInputError, match="does not fit u32"):
+        RecurrenceSourceStateV1(1 << 32, -1, 0, -1, 0, 0)
+    with pytest.raises(
+        RecurrenceColumnarInputError,
+        match="reserved dynamic-union sentinel",
+    ):
+        RecurrenceSourceStateV1(0, -1, 0, -(1 << 31), 0, 0)
+    with pytest.raises(RecurrenceColumnarInputError, match="must be nonnegative"):
+        replace(_logical_input().external_legs[0], momentum_mask=-1)
+    with pytest.raises(RecurrenceColumnarInputError, match="does not fit u64"):
+        RecurrenceColumnarTable("overflow", 1 << 64, ())
+
+
+def test_column_rejects_mutable_view_noncontiguous_and_big_endian_storage() -> None:
+    writable = np.array([1], dtype="<u4")
+    with pytest.raises(RecurrenceColumnarInputError, match="read-only"):
+        RecurrenceColumn("value", writable)
+
+    base = np.arange(4, dtype="<u4")
+    view = base[::2]
+    view.flags.writeable = False
+    with pytest.raises(RecurrenceColumnarInputError, match="C-contiguous"):
+        RecurrenceColumn("value", view)
+
+    owning_view = base.view()
+    owning_view.flags.writeable = False
+    with pytest.raises(RecurrenceColumnarInputError, match="own its storage"):
+        RecurrenceColumn("value", owning_view)
+
+    big_endian = np.array([1], dtype=">u4")
+    big_endian.flags.writeable = False
+    with pytest.raises(RecurrenceColumnarInputError, match="non-little-endian"):
+        RecurrenceColumn("value", big_endian)
+
+
+def test_malformed_flat_range_is_rejected(
+    columnar_input: RecurrenceBuilderInputV1,
+) -> None:
+    counts = columnar_input.table("string_ranges").column("count").copy()
+    counts[0] += 1
+    tables = _replace_column(columnar_input, "string_ranges", "count", counts)
+
+    with pytest.raises(RecurrenceColumnarInputError, match="ranges are not contiguous"):
+        RecurrenceBuilderInputV1(columnar_input.abi, tables)
+
+
+def test_malformed_reference_and_header_count_are_rejected(
+    columnar_input: RecurrenceBuilderInputV1,
+) -> None:
+    digest_ids = columnar_input.table("header_digests").column("digest_id").copy()
+    digest_ids[0] = columnar_input.table("digest_catalog").row_count
+    tables = _replace_column(
+        columnar_input,
+        "header_digests",
+        "digest_id",
+        digest_ids,
+    )
+    with pytest.raises(RecurrenceColumnarInputError, match="absent row"):
+        RecurrenceBuilderInputV1(columnar_input.abi, tables)
+
+    counts = columnar_input.table("header").column("external_leg_count").copy()
+    counts[0] += 1
+    tables = _replace_column(
+        columnar_input,
+        "header",
+        "external_leg_count",
+        counts,
+    )
+    with pytest.raises(RecurrenceColumnarInputError, match="does not match"):
+        RecurrenceBuilderInputV1(columnar_input.abi, tables)
+
+
+def test_malformed_little_endian_column_width_is_rejected(
+    columnar_input: RecurrenceBuilderInputV1,
+) -> None:
+    wrong_width = np.array(
+        columnar_input.table("header").column("schema_version"),
+        dtype="<u8",
+        copy=True,
+    )
+    tables = _replace_column(
+        columnar_input,
+        "header",
+        "schema_version",
+        wrong_width,
+    )
+
+    with pytest.raises(RecurrenceColumnarInputError, match="expected '<u4'"):
+        RecurrenceBuilderInputV1(columnar_input.abi, tables)
+
+
+def test_logical_cross_references_fail_closed(
+    logical_input: RecurrenceBuilderLogicalInputV1,
+) -> None:
+    with pytest.raises(RecurrenceColumnarInputError, match="absent current-state"):
+        build_recurrence_builder_input_v1(
+            replace(
+                logical_input,
+                semantic_template_references=tuple(
+                    item
+                    for item in logical_input.semantic_template_references
+                    if not (item.kind == "current-state" and item.template_id == 10)
+                ),
+            )
+        )
+
+    with pytest.raises(RecurrenceColumnarInputError, match="selected public flow"):
+        build_recurrence_builder_input_v1(
+            replace(logical_input, selected_public_flow_ids=(99,))
+        )
+
+    bad_anchor = replace(logical_input.physical_sectors[0], closure_source_slot=99)
+    with pytest.raises(RecurrenceColumnarInputError, match="closure source slot"):
+        build_recurrence_builder_input_v1(
+            replace(
+                logical_input,
+                physical_sectors=(bad_anchor, *logical_input.physical_sectors[1:]),
+            )
+        )
+
+    bad_target = replace(
+        logical_input.replay_partitions[0].targets[0],
+        external_permutation=(0, 1, 2, 2),
+    )
+    partition = replace(
+        logical_input.replay_partitions[0],
+        targets=(bad_target, logical_input.replay_partitions[0].targets[1]),
+    )
+    with pytest.raises(RecurrenceColumnarInputError, match="must be a permutation"):
+        build_recurrence_builder_input_v1(
+            replace(logical_input, replay_partitions=(partition,))
+        )
+
+    bad_flow = replace(
+        logical_input.public_flows[0],
+        construction_sector_id=99,
+    )
+    with pytest.raises(
+        RecurrenceColumnarInputError,
+        match="public flow construction sector",
+    ):
+        build_recurrence_builder_input_v1(
+            replace(
+                logical_input,
+                public_flows=(bad_flow, *logical_input.public_flows[1:]),
+            )
+        )
+
+
+def test_replay_rejects_cross_role_source_mapping(
+    logical_input: RecurrenceBuilderLogicalInputV1,
+) -> None:
+    permutation = (2, 1, 0, 3)
+    bad_target = replace(
+        logical_input.replay_partitions[0].targets[1],
+        external_permutation=permutation,
+        source_slot_permutation=permutation,
+    )
+    partition = replace(
+        logical_input.replay_partitions[0],
+        targets=(logical_input.replay_partitions[0].targets[0], bad_target),
+    )
+    with pytest.raises(RecurrenceColumnarInputError, match="initial/final"):
+        build_recurrence_builder_input_v1(
+            replace(logical_input, replay_partitions=(partition,))
+        )
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("source_template_id", 26),
+        ("momentum_sign", -1),
+        ("crossing_phase", ExactComplexRationalV1(-1)),
+    ),
+)
+def test_replay_rejects_mismatched_source_crossing_contract(
+    logical_input: RecurrenceBuilderLogicalInputV1,
+    field: str,
+    value: object,
+) -> None:
+    target_leg = logical_input.external_legs[3]
+    changed_state = replace(target_leg.source_states[0], **{field: value})
+    changed_leg = replace(
+        target_leg,
+        source_states=(changed_state, *target_leg.source_states[1:]),
+    )
+    external_legs = (
+        *logical_input.external_legs[:3],
+        changed_leg,
+    )
+    with pytest.raises(RecurrenceColumnarInputError, match="crossing contract"):
+        build_recurrence_builder_input_v1(
+            replace(logical_input, external_legs=external_legs)
+        )
+
+
+def test_external_leg_rejects_duplicate_source_template() -> None:
+    logical = _logical_input()
+    target_leg = logical.external_legs[3]
+    duplicate = replace(
+        target_leg.source_states[1],
+        source_template_id=target_leg.source_states[0].source_template_id,
+    )
+    with pytest.raises(RecurrenceColumnarInputError, match="source template"):
+        replace(
+            target_leg,
+            source_states=(target_leg.source_states[0], duplicate),
+        )
+
+
+def test_missing_required_header_digest_is_rejected(
+    logical_input: RecurrenceBuilderLogicalInputV1,
+) -> None:
+    with pytest.raises(RecurrenceColumnarInputError, match="missing semantic digests"):
+        build_recurrence_builder_input_v1(
+            replace(
+                logical_input,
+                semantic_digests=tuple(
+                    item
+                    for item in logical_input.semantic_digests
+                    if item.role != "prepared-catalog"
+                ),
+            )
+        )
+
+
+def test_replay_permutations_use_documented_gather_orientation(
+    logical_input: RecurrenceBuilderLogicalInputV1,
+) -> None:
+    uniform_source_states = logical_input.external_legs[0].source_states
+    compatible_legs = tuple(
+        replace(
+            leg,
+            is_initial=False,
+            source_states=uniform_source_states,
+        )
+        for leg in logical_input.external_legs
+    )
+    cycle = (0, 2, 3, 1)
+    representative_word = logical_input.physical_sectors[0].word_source_slots
+    target_word = tuple(cycle[source_slot] for source_slot in representative_word)
+    target_sector = replace(
+        logical_input.physical_sectors[1],
+        word_source_slots=target_word,
+        closure_source_slot=target_word[-1],
+    )
+    target_flow = replace(
+        logical_input.public_flows[1],
+        word_source_slots=target_word,
+    )
+    targets = tuple(
+        replace(
+            target,
+            external_permutation=cycle,
+            source_slot_permutation=cycle,
+        )
+        if target.sector_id == 1
+        else target
+        for target in logical_input.replay_partitions[0].targets
+    )
+    logical = replace(
+        logical_input,
+        external_legs=compatible_legs,
+        physical_sectors=(logical_input.physical_sectors[0], target_sector),
+        public_flows=(logical_input.public_flows[0], target_flow),
+        replay_partitions=(
+            replace(logical_input.replay_partitions[0], targets=targets),
+        ),
+    )
+
+    assert len(build_recurrence_builder_input_v1(logical).canonical_digest) == 64
+    inverse = (0, 3, 1, 2)
+    wrong_targets = tuple(
+        replace(
+            target,
+            external_permutation=inverse,
+            source_slot_permutation=inverse,
+        )
+        if target.sector_id == 1
+        else target
+        for target in targets
+    )
+    with pytest.raises(RecurrenceColumnarInputError, match="gather permutation"):
+        build_recurrence_builder_input_v1(
+            replace(
+                logical,
+                replay_partitions=(
+                    replace(logical.replay_partitions[0], targets=wrong_targets),
+                ),
+            )
+        )
+
+
+def test_replay_permutation_must_transport_all_singlet_closure_anchor(
+    logical_input: RecurrenceBuilderLogicalInputV1,
+) -> None:
+    singlet_sectors = tuple(
+        replace(
+            sector,
+            kind="singlet",
+            closure_source_slot=0,
+            open_strings=(),
+            singlet_source_slots=(0, 1, 2, 3),
+            word_source_slots=(),
+        )
+        for sector in logical_input.physical_sectors
+    )
+    singlet_flows = tuple(
+        replace(flow, word_source_slots=()) for flow in logical_input.public_flows
+    )
+    targets = tuple(
+        replace(
+            target,
+            external_permutation=(1, 0, 2, 3),
+            source_slot_permutation=(1, 0, 2, 3),
+        )
+        if target.sector_id == 1
+        else target
+        for target in logical_input.replay_partitions[0].targets
+    )
+    compatible_legs = (
+        logical_input.external_legs[0],
+        replace(
+            logical_input.external_legs[1],
+            source_states=logical_input.external_legs[0].source_states,
+        ),
+        *logical_input.external_legs[2:],
+    )
+
+    with pytest.raises(
+        RecurrenceColumnarInputError,
+        match="representative closure anchor",
+    ):
+        build_recurrence_builder_input_v1(
+            replace(
+                logical_input,
+                external_legs=compatible_legs,
+                physical_sectors=singlet_sectors,
+                public_flows=singlet_flows,
+                replay_partitions=(
+                    replace(logical_input.replay_partitions[0], targets=targets),
+                ),
+            )
+        )
+
+
+def test_union_layout_does_not_require_replay_partitions(
+    logical_input: RecurrenceBuilderLogicalInputV1,
+) -> None:
+    result = build_recurrence_builder_input_v1(
+        replace(
+            logical_input,
+            layout="all-flow-union",
+            replay_partitions=(),
+            selected_public_flow_ids=(1,),
+        )
+    )
+
+    assert result.table("replay_partitions").row_count == 0
+    assert int(result.table("header").column("layout")[0]) == 1
+    assert int(result.table("header").column("selected_flow_mode")[0]) == 1
+    assert int(result.table("header").column("selected_source_mode")[0]) == 1
+    assert tuple(
+        int(value)
+        for value in result.table("selected_public_flow_coverage").column("flow_id")
+    ) == (1,)
+    assert tuple(
+        int(value)
+        for value in result.table("selected_source_coverage").column("source_slot")
+    ) == (0, 1, 2, 2, 3, 3)
+
+
+def test_selected_source_coverage_must_cover_every_external_leg(
+    logical_input: RecurrenceBuilderLogicalInputV1,
+) -> None:
+    with pytest.raises(
+        RecurrenceColumnarInputError,
+        match="every external source slot",
+    ):
+        build_recurrence_builder_input_v1(
+            replace(
+                logical_input,
+                layout="all-flow-union",
+                replay_partitions=(),
+                selected_source_coverage=(
+                    RecurrenceSelectedSourceCoverageV1(0, (0,)),
+                    RecurrenceSelectedSourceCoverageV1(1, (1,)),
+                    RecurrenceSelectedSourceCoverageV1(2, (0, 1)),
+                ),
+            )
+        )
+
+
+def test_topology_replay_layout_allows_exact_residual_only_sectors(
+    logical_input: RecurrenceBuilderLogicalInputV1,
+) -> None:
+    result = build_recurrence_builder_input_v1(
+        replace(logical_input, replay_partitions=())
+    )
+
+    assert result.table("replay_partitions").row_count == 0
+    assert result.table("replay_targets").row_count == 0
+    assert int(result.table("header").column("layout")[0]) == 0
diff --git a/pyamplicol/tests/unit/test_recurrence_direct_artifact_metadata.py b/pyamplicol/tests/unit/test_recurrence_direct_artifact_metadata.py
new file mode 100644
index 0000000000..f6c0f377f3
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_direct_artifact_metadata.py
@@ -0,0 +1,1186 @@
+# SPDX-License-Identifier: 0BSD
+"""Python metadata contracts for direct-arena recurrence artifacts."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import replace
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol._internal import versions
+from pyamplicol.api.errors import ArtifactError
+from pyamplicol.artifacts import inspection, load_manifest
+from pyamplicol.artifacts.writer import ArtifactBuilder
+from pyamplicol.generation import artifact_writer, recurrence_physics, service
+from pyamplicol.generation.recurrence_columnar import RecurrenceSemanticDigestV1
+from pyamplicol.generation.recurrence_schedule_sharing import (
+    RecurrenceProcessExecutorPack,
+    RecurrenceProcessRemap,
+    recurrence_helicity_selector_schedule_digest,
+)
+from pyamplicol.generation.validation import ValidationPointRecord
+
+
+def _digest(character: str) -> str:
+    return character * 64
+
+
+def test_recurrence_bootstrap_publishes_exact_authenticated_runtime_inputs(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    process_id = "g_g_to_g_g"
+    prefix = f"processes/{process_id}"
+    execution_path = f"{prefix}/execution.json"
+    physics_path = f"{prefix}/physics.json"
+    bootstrap_path = f"{prefix}/recurrence-bootstrap.bin"
+    execution = b'{"kind":"pyamplicol-recurrence-runtime","schema_version":1}\n'
+    physics = b'{"kind":"pyamplicol-resolved-physics","schema_version":1}\n'
+    target = {"triple": "portable-64le", "cpu_features": []}
+    capability = artifact_writer.RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY
+    output = tmp_path / "artifact"
+    image = b"native-recurrence-bootstrap-image-v1"
+    captured: dict[str, object] = {}
+
+    def build(
+        context_json: bytes,
+        execution_json: bytes,
+        physics_json: bytes,
+    ) -> bytes:
+        captured.update(
+            context=json.loads(context_json),
+            execution=execution_json,
+            physics=physics_json,
+        )
+        return image
+
+    monkeypatch.setattr(
+        artifact_writer,
+        "_recurrence_bootstrap_operation",
+        lambda: build,
+    )
+    producer = {
+        "distribution": "pyamplicol",
+        "version": "0.1.0",
+        "versions": {
+            "python_api": 1,
+            "toml": 1,
+            "compiled_model": 1,
+            "process_artifact": 3,
+            "runtime_physics": 1,
+            "symbolica_serialization": "1",
+            "c_abi": 1,
+        },
+        "target": target,
+    }
+    process_record = {
+        "id": process_id,
+        "expression": "g g > g g",
+        "color_accuracy": "full",
+        "external_pdgs": [21, 21, 21, 21],
+        "physics_path": physics_path,
+        "required_runtime_capabilities": [capability],
+        "aliases": [],
+    }
+    runtime = {
+        "engine": "rusticol",
+        "engine_version": "0.1.0",
+        "evaluator_manifest_path": execution_path,
+        "api_bundle_path": None,
+        "required_runtime_capabilities": [capability],
+    }
+    container = {
+        "kind": "pyamplicol-evaluator-payload-container",
+        "schema_version": 1,
+        "storage_abi": "pacbin-v1",
+        "path": "evaluators.pacbin",
+        "member_count": 0,
+        "unpacked_size_bytes": 0,
+        "index_sha256": _digest("b"),
+    }
+
+    with ArtifactBuilder(output) as builder:
+        builder.add_bytes(
+            execution_path,
+            execution,
+            role="evaluator-manifest",
+            media_type="application/json",
+            process_id=process_id,
+        )
+        builder.add_bytes(
+            physics_path,
+            physics,
+            role="runtime-physics",
+            media_type="application/json",
+            process_id=process_id,
+        )
+        builder.add_bytes(
+            "evaluators.pacbin",
+            b"container",
+            role="evaluator-state",
+            media_type="application/octet-stream",
+            target=target,
+        )
+        artifact_writer._write_recurrence_bootstraps(
+            builder,
+            processes=(SimpleNamespace(process_id=process_id),),  # type: ignore[arg-type]
+            process_records=(process_record,),
+            producer=producer,
+            runtime=runtime,
+            evaluator_payload_container=container,
+            target=target,
+        )
+        builder.finalize(
+            kind="pyamplicol-process",
+            producer=producer,
+            model={
+                "name": "sm",
+                "source_kind": "built-in-sm",
+                "content_sha256": _digest("a"),
+                "compiled_schema_version": 1,
+            },
+            configuration={
+                "toml_schema_version": 1,
+                "requested_path": "configuration/requested.toml",
+                "effective_path": "configuration/effective.toml",
+                "adjustments": [],
+            },
+            processes=(process_record,),
+            runtime=runtime,
+            default_process_id=process_id,
+        )
+
+    manifest = load_manifest(output, verify_payloads=True)
+    bootstrap_record = next(
+        record for record in manifest.payloads if record.path == bootstrap_path
+    )
+    assert bootstrap_record.role == "evaluator-state"
+    assert bootstrap_record.process_id == process_id
+    assert bootstrap_record.target == {
+        "triple": "portable-64le",
+        "cpu_features": (),
+    }
+    bootstrap_bytes = (output / bootstrap_path).read_bytes()
+    assert bootstrap_bytes == image
+    assert hashlib.sha256(bootstrap_bytes).hexdigest() == bootstrap_record.sha256
+    assert captured["execution"] == execution
+    assert captured["physics"] == physics
+    context = captured["context"]
+    assert isinstance(context, dict)
+    assert context["process"] == process_record
+    assert context["producer"] == producer
+    assert context["runtime"] == runtime
+    assert context["evaluator_payload_container"] == container
+    assert Path(context["staged_root"]).is_absolute()
+    inventory = context["payloads"]
+    assert isinstance(inventory, list)
+    assert bootstrap_path not in {record["path"] for record in inventory}
+    assert {record["path"] for record in inventory} == {
+        execution_path,
+        physics_path,
+        "evaluators.pacbin",
+    }
+
+
+def test_recurrence_bootstrap_v1_skips_multi_process_artifacts(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        artifact_writer,
+        "_recurrence_bootstrap_operation",
+        lambda: pytest.fail("multi-process artifacts must not build a v1 bootstrap"),
+    )
+    # The multi-process guard returns before consulting the builder at all.
+    artifact_writer._write_recurrence_bootstraps(
+        SimpleNamespace(),  # type: ignore[arg-type]
+        processes=(SimpleNamespace(process_id="recurrence"),),  # type: ignore[arg-type]
+        process_records=(
+            {"id": "recurrence"},
+            {"id": "compiled"},
+        ),
+        producer={},
+        runtime={},
+        evaluator_payload_container=None,
+        target={},
+    )
+
+
+def test_recurrence_inspection_summary_binds_public_process_alias() -> None:
+    native_summary = {
+        "execution_mode": "recurrence",
+        "process_id": "g_g_to_g_g",
+        "semantic_digest": _digest("1"),
+        "schedule_digest": _digest("2"),
+    }
+
+    summary = service._process_scoped_recurrence_inspection_summary(
+        native_summary,
+        process_id="gg_n2",
+        semantic_digest=_digest("3"),
+        schedule_digest=_digest("4"),
+    )
+
+    assert summary["process_id"] == "gg_n2"
+    assert summary["semantic_digest"] == _digest("3")
+    assert summary["schedule_digest"] == _digest("4")
+    assert native_summary["process_id"] == "g_g_to_g_g"
+
+
+def _recurrence_process() -> SimpleNamespace:
+    return SimpleNamespace(
+        expression="d d~ > z g",
+        process_id="d_dbar_to_z_g",
+        color_accuracy="lc",
+        external_pdgs=(1, -1, 23, 21),
+        recurrence_schedule_size_bytes=256,
+        recurrence_schedule_sha256=_digest("a"),
+        recurrence_schedule_member_count=1,
+        recurrence_schedule_unpacked_size_bytes=192,
+        recurrence_schedule_index_sha256=_digest("b"),
+        builder_input_sha256=_digest("c"),
+        prepared_kernel_pack_digest=_digest("d"),
+        direct_template_catalog_digest=_digest("e"),
+        recurrence_process_executor_pack=SimpleNamespace(
+            compiled_model_digest=_digest("2"),
+            recurrence_template_catalog_digest=_digest("3"),
+            prepared_kernel_pack_digest=_digest("d"),
+            direct_template_catalog_digest=_digest("e"),
+        ),
+        inspection_summary={
+            "execution_mode": "recurrence",
+            "process_id": "d_dbar_to_z_g",
+            "semantic_digest": _digest("c"),
+            "schedule_digest": _digest("f"),
+            "prepared_kernel_count": 2,
+            "schedule": {
+                "source_row_count": 4,
+                "contribution_count": 34,
+                "finalization_count": 22,
+                "closure_term_count": 12,
+            },
+            "direct_arena": {
+                "semantic_component_count": 48,
+                "current_arena_components": 32,
+                "arena_component_reuse_count": 16,
+                "momentum_form_count": 7,
+                "row_group_count": 11,
+                "packed_input_bytes": 0,
+                "packed_output_bytes": 0,
+                "scatter_bytes": 0,
+            },
+        },
+        runtime_metadata={},
+        point_tile_size=1024,
+        workspace_mib=256,
+        recurrence_summary={"lc_flow_layout": "topology-replay"},
+        color_contraction_summary=None,
+        helicity_selector_companion=None,
+        process_digest=_digest("1"),
+    )
+
+
+def _selector_companion() -> artifact_writer.RecurrenceHelicitySelectorPlanArtifact:
+    base_schedule_digest = _digest("6")
+    dispatch_sha256 = _digest("4")
+    return artifact_writer.RecurrenceHelicitySelectorPlanArtifact(
+        recurrence_schedule_path=Path("selector-runtime.pacbin"),
+        recurrence_base_schedule_digest=base_schedule_digest,
+        recurrence_schedule_digest=recurrence_helicity_selector_schedule_digest(
+            base_schedule_digest,
+            dispatch_sha256,
+        ),
+        recurrence_native_schedule_semantic_digest=base_schedule_digest,
+        recurrence_schedule_size_bytes=512,
+        recurrence_schedule_sha256=_digest("8"),
+        recurrence_schedule_member_count=1,
+        recurrence_schedule_unpacked_size_bytes=448,
+        recurrence_schedule_index_sha256=_digest("a"),
+        helicity_dispatch_path=Path("selector-dispatch.bin"),
+        helicity_dispatch_size_bytes=96,
+        helicity_dispatch_sha256=dispatch_sha256,
+        helicity_dispatch_base_runtime_layout_digest=_digest("5"),
+        helicity_dispatch_resolved_helicity_count=8,
+        physical_destination_count=3,
+        builder_input_sha256=_digest("b"),
+        inspection_summary={
+            "execution_mode": "recurrence",
+            "runtime_layout_digest": _digest("5"),
+            "schedule_digest": base_schedule_digest,
+        },
+        referenced_kernel_ids=frozenset({0, 1}),
+        recurrence_process_remap=SimpleNamespace(),  # type: ignore[arg-type]
+        recurrence_process_executor_pack=SimpleNamespace(
+            compiled_model_digest=_digest("2"),
+            recurrence_template_catalog_digest=_digest("3"),
+            prepared_kernel_pack_digest=_digest("d"),
+            direct_template_catalog_digest=_digest("e"),
+        ),  # type: ignore[arg-type]
+    )
+
+
+def _identity_remap(*, physical_sector_count: int) -> RecurrenceProcessRemap:
+    return RecurrenceProcessRemap(
+        source_slots=(0,),
+        source_momentum_signs=(1,),
+        source_helicity_signs=(1,),
+        source_state_offsets=(0, 1),
+        source_state_indices=(0,),
+        public_flow_ids=(),
+        physical_sector_ids=tuple(range(physical_sector_count)),
+        state_template_count=0,
+        source_template_count=0,
+        direct_executor_count=1,
+        parameter_slot_count=0,
+        bijection_digest=_digest("7"),
+    )
+
+
+def _executor_pack(runtime_layout_digest: str) -> RecurrenceProcessExecutorPack:
+    return RecurrenceProcessExecutorPack(
+        compiled_model_digest=_digest("2"),
+        recurrence_template_catalog_digest=_digest("3"),
+        prepared_kernel_pack_digest=_digest("d"),
+        direct_template_catalog_digest=_digest("e"),
+        runtime_layout_digest=runtime_layout_digest,
+        backend="jit",
+        target_triple="symjit-storage-v3-portable",
+        portable=True,
+        cpu_features=(),
+        catalog_executor_count=1,
+        executor_ids=(0,),
+        descriptor_payloads=(bytes.fromhex("10000000000000000000000001000000"),),
+    )
+
+
+def _execution_manifest(process: SimpleNamespace | None = None) -> dict[str, object]:
+    process = process or _recurrence_process()
+    return artifact_writer._recurrence_execution_manifest(
+        process,
+        schedule_path=f"recurrence/schedules/{_digest('f')}/recurrence-runtime.pacbin",
+        binding={
+            "abi": "pyamplicol-recurrence-process-binding-v4",
+            "process_id": process.process_id,
+            "schedule_digest": _digest("f"),
+            "process_digest": process.process_digest,
+            "process_semantic_digest": _digest("c"),
+            "process_support_words": [1],
+            "path": "recurrence-binding.bin",
+            "size_bytes": 128,
+            "sha256": _digest("9"),
+        },
+        color_contraction_record=None,
+    )
+
+
+def _recurrence_execution_summary_with_size(
+    monkeypatch: pytest.MonkeyPatch,
+    target_size: int,
+) -> bytes:
+    empty_summary_size = len(b'{"padding":""}\n')
+    assert target_size >= empty_summary_size
+
+    def padded_manifest(
+        *_args: object,
+        **_kwargs: object,
+    ) -> dict[str, object]:
+        return {"padding": "x" * (target_size - empty_summary_size)}
+
+    monkeypatch.setattr(
+        artifact_writer,
+        "_recurrence_execution_manifest",
+        padded_manifest,
+    )
+    return artifact_writer._bounded_recurrence_execution_summary(
+        _recurrence_process(),
+        schedule_path="recurrence-runtime.pacbin",
+        binding={},
+        color_contraction_record=None,
+    )
+
+
+def _write_prepared_pack(root: Path) -> None:
+    pack_path = root / "model" / "eager-kernel-pack.json"
+    pack_path.parent.mkdir(parents=True)
+    pack_path.write_text(
+        json.dumps(
+            {
+                "backend": "jit",
+                "kernels": [{"kernel_id": 0}, {"kernel_id": 1}],
+                "recurrence_direct_template": {
+                    "templates": [
+                        {"payload_binding": {"prepared_kernel_id": 0}},
+                        {"payload_binding": {"prepared_kernel_id": 1}},
+                    ]
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+
+
+def test_direct_recurrence_versions_replace_packet_abi() -> None:
+    assert (
+        versions.RECURRENCE_BUILDER_INPUT_ABI
+        == "pyamplicol-recurrence-builder-input-v2"
+    )
+    assert versions.RECURRENCE_PLAN_ABI == "pyamplicol-recurrence-plan-v2"
+    assert (
+        versions.RECURRENCE_RUNTIME_LAYOUT_ABI
+        == "pyamplicol-recurrence-runtime-layout-v2"
+    )
+    assert (
+        versions.RECURRENCE_DIRECT_TEMPLATE_ABI
+        == "pyamplicol-recurrence-direct-template-v1"
+    )
+    assert (
+        versions.RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY
+        == "rusticol.recurrence-direct-arena.complex-f64.v1"
+    )
+    assert not hasattr(versions, "RECURRENCE_RUNTIME_CAPABILITY")
+
+
+def test_recurrence_execution_manifest_publishes_only_direct_arena_contract() -> None:
+    manifest = _execution_manifest()
+
+    assert manifest["builder_input_abi"] == versions.RECURRENCE_BUILDER_INPUT_ABI
+    assert manifest["recurrence_plan_abi"] == versions.RECURRENCE_PLAN_ABI
+    assert manifest["runtime_layout_abi"] == versions.RECURRENCE_RUNTIME_LAYOUT_ABI
+    assert manifest["direct_template_abi"] == versions.RECURRENCE_DIRECT_TEMPLATE_ABI
+    assert manifest["direct_backend_abi"] == versions.RECURRENCE_DIRECT_BACKEND_ABI
+    assert manifest["prepared_kernel_pack_digest"] == _digest("d")
+    assert manifest["direct_template_catalog_digest"] == _digest("e")
+    assert manifest["compiled_model_digest"] == _digest("2")
+    assert manifest["recurrence_template_catalog_digest"] == _digest("3")
+    assert manifest["process_digest"] is None
+    assert manifest["helicity_selector_companion"] is None
+    assert manifest["required_runtime_capabilities"] == [
+        versions.RECURRENCE_COLOR_RUNTIME_CAPABILITY,
+        versions.RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    ]
+    plan = manifest["plan"]
+    assert isinstance(plan, dict)
+    assert plan["builder_input_abi"] == versions.RECURRENCE_BUILDER_INPUT_ABI
+    assert plan["runtime_layout_abi"] == versions.RECURRENCE_RUNTIME_LAYOUT_ABI
+    assert plan["prepared_kernel_pack_digest"] == _digest("d")
+    assert plan["direct_template_catalog_digest"] == _digest("e")
+    container = plan["runtime_schedule"]
+    assert isinstance(container, dict)
+    assert container["plan_member_path"] == (
+        "schedule/recurrence-direct-schedule-v2.bin"
+    )
+    encoded = json.dumps(manifest)
+    assert "pyamplicol-recurrence-plan-v1" not in encoded
+    assert "pyamplicol-recurrence-runtime-layout-v1" not in encoded
+    assert "rusticol.recurrence-runtime.complex-f64.v1" not in encoded
+
+
+def test_recurrence_selector_v2_manifest_authenticates_persisted_direct_plan() -> None:
+    process = _recurrence_process()
+    process.color_accuracy = "full"
+    process.color_contraction_summary = {
+        "abi": "pyamplicol-recurrence-color-contraction-v3",
+        "color_accuracy": "full",
+        "storage": "repeated",
+        "group_count": 24,
+        "component_count": 8,
+        "factorization": None,
+    }
+    companion = _selector_companion()
+    process.helicity_selector_companion = companion
+    binding = {
+        "abi": "pyamplicol-recurrence-process-binding-v4",
+        "process_id": process.process_id,
+        "schedule_digest": companion.recurrence_schedule_digest,
+        "native_schedule_semantic_digest": (
+            companion.recurrence_native_schedule_semantic_digest
+        ),
+        "process_digest": process.process_digest,
+        "process_semantic_digest": companion.builder_input_sha256,
+        "process_support_words": [1],
+        "path": "helicity-selector-binding.bin",
+        "size_bytes": 256,
+        "sha256": _digest("9"),
+    }
+
+    manifest = artifact_writer._recurrence_execution_manifest(
+        process,
+        schedule_path=f"recurrence/schedules/{_digest('f')}/recurrence-runtime.pacbin",
+        binding={
+            **binding,
+            "schedule_digest": _digest("f"),
+            "process_semantic_digest": _digest("c"),
+            "path": "recurrence-binding.bin",
+        },
+        color_contraction_record=SimpleNamespace(
+            size_bytes=5,
+            sha256=_digest("0"),
+        ),
+        companion_binding=binding,
+    )
+
+    selector = manifest["helicity_selector_companion"]
+    assert isinstance(selector, dict)
+    assert selector == {
+        "schema_version": 2,
+        "kind": "pyamplicol-recurrence-helicity-selector-companion-v2",
+        "process_digest": process.process_digest,
+        "plan": selector["plan"],
+        "color_contraction": selector["color_contraction"],
+    }
+    plan = selector["plan"]
+    assert isinstance(plan, dict)
+    assert plan["builder_input_sha256"] == companion.builder_input_sha256
+    assert plan["process_binding"] == binding
+    schedule = plan["runtime_schedule"]
+    assert isinstance(schedule, dict)
+    assert schedule["path"] == (
+        f"recurrence/schedules/{companion.recurrence_schedule_digest}/"
+        "recurrence-runtime.pacbin"
+    )
+    dispatch = plan["helicity_dispatch"]
+    assert isinstance(dispatch, dict)
+    assert dispatch == {
+        "abi": "pyamplicol-recurrence-helicity-dispatch-v1",
+        "path": (
+            f"recurrence/schedules/{companion.recurrence_schedule_digest}/"
+            "recurrence-helicity-dispatch-v1.bin"
+        ),
+        "size_bytes": companion.helicity_dispatch_size_bytes,
+        "sha256": companion.helicity_dispatch_sha256,
+        "base_runtime_layout_digest": (
+            companion.helicity_dispatch_base_runtime_layout_digest
+        ),
+        "resolved_helicity_count": 8,
+    }
+    color = selector["color_contraction"]
+    assert isinstance(color, dict)
+    assert color == {
+        "source": "primary",
+        "view": "primary-local-color-view-v1",
+    }
+    assert "runtime_container" not in selector
+    assert "query_construction_threads" not in selector
+    assert "selector_policy" not in selector
+    assert "on-the-fly" not in json.dumps(manifest)
+
+    process.helicity_selector_companion = replace(
+        companion,
+        inspection_summary={
+            **companion.inspection_summary,
+            "schedule_digest": companion.recurrence_schedule_digest,
+        },
+    )
+    with pytest.raises(ValueError, match="native Direct-plan identity"):
+        artifact_writer._recurrence_execution_manifest(
+            process,
+            schedule_path=(
+                f"recurrence/schedules/{_digest('f')}/recurrence-runtime.pacbin"
+            ),
+            binding={
+                **binding,
+                "schedule_digest": _digest("f"),
+                "process_semantic_digest": _digest("c"),
+                "path": "recurrence-binding.bin",
+            },
+            color_contraction_record=SimpleNamespace(
+                size_bytes=5,
+                sha256=_digest("0"),
+            ),
+            companion_binding=binding,
+        )
+
+    process.helicity_selector_companion = companion
+    process.color_contraction_summary = {
+        **process.color_contraction_summary,
+        "storage": "expanded",
+    }
+    with pytest.raises(ValueError, match="direct, Walsh, or symmetric-group"):
+        artifact_writer._recurrence_execution_manifest(
+            process,
+            schedule_path=(
+                f"recurrence/schedules/{_digest('f')}/recurrence-runtime.pacbin"
+            ),
+            binding={
+                **binding,
+                "schedule_digest": _digest("f"),
+                "process_semantic_digest": _digest("c"),
+                "path": "recurrence-binding.bin",
+            },
+            color_contraction_record=SimpleNamespace(
+                size_bytes=5,
+                sha256=_digest("0"),
+            ),
+            companion_binding=binding,
+        )
+
+
+def test_recurrence_rejects_retired_on_the_fly_selector_companion() -> None:
+    process = _recurrence_process()
+    process.helicity_selector_companion = SimpleNamespace(kind="retired-otf-seed")
+
+    with pytest.raises(TypeError, match="persisted Direct plan"):
+        _execution_manifest(process)
+
+
+def test_recurrence_selector_publication_emits_only_v2_plan_sidecars(
+    tmp_path: Path,
+) -> None:
+    process_id = "d_dbar_to_z_g"
+    base_digest = _digest("6")
+    schedule_payload = b"selector direct schedule"
+    dispatch_payload = b"exact helicity dispatch"
+    schedule_path = tmp_path / "selector-runtime.pacbin"
+    dispatch_path = tmp_path / "selector-dispatch.bin"
+    schedule_path.write_bytes(schedule_payload)
+    dispatch_path.write_bytes(dispatch_payload)
+    dispatch_sha256 = hashlib.sha256(dispatch_payload).hexdigest()
+    selector_digest = recurrence_helicity_selector_schedule_digest(
+        base_digest,
+        dispatch_sha256,
+    )
+    primary_pack = _executor_pack(_digest("4"))
+    companion = replace(
+        _selector_companion(),
+        recurrence_schedule_path=schedule_path,
+        recurrence_base_schedule_digest=base_digest,
+        recurrence_schedule_digest=selector_digest,
+        recurrence_native_schedule_semantic_digest=base_digest,
+        recurrence_schedule_size_bytes=len(schedule_payload),
+        recurrence_schedule_sha256=hashlib.sha256(schedule_payload).hexdigest(),
+        helicity_dispatch_path=dispatch_path,
+        helicity_dispatch_size_bytes=len(dispatch_payload),
+        helicity_dispatch_sha256=dispatch_sha256,
+        recurrence_process_remap=_identity_remap(physical_sector_count=3),
+        recurrence_process_executor_pack=_executor_pack(_digest("5")),
+    )
+    process = artifact_writer.RecurrenceProcessArtifact(
+        process_id=process_id,
+        expression="d d~ > z g",
+        color_accuracy="full",
+        external_pdgs=(1, -1, 23, 21),
+        aliases=(),
+        physics={
+            "schema_version": 1,
+            "kind": "pyamplicol-resolved-physics",
+            "process_id": process_id,
+        },
+        recurrence_schedule_path=tmp_path / "primary-runtime.pacbin",
+        recurrence_schedule_digest=_digest("f"),
+        recurrence_native_schedule_semantic_digest=_digest("f"),
+        recurrence_schedule_size_bytes=1,
+        recurrence_schedule_sha256=_digest("a"),
+        recurrence_schedule_member_count=1,
+        recurrence_schedule_unpacked_size_bytes=1,
+        recurrence_schedule_index_sha256=_digest("b"),
+        builder_input_sha256=_digest("c"),
+        prepared_kernel_pack_digest=_digest("d"),
+        direct_template_catalog_digest=_digest("e"),
+        referenced_kernel_ids=frozenset({0}),
+        inspection_summary={
+            "runtime_layout_digest": _digest("4"),
+            "schedule_digest": _digest("f"),
+        },
+        runtime_metadata={},
+        color_contraction_payload=b"primary color reducer",
+        color_contraction_summary={
+            "abi": "pyamplicol-recurrence-color-contraction-v3",
+            "color_accuracy": "full",
+            "storage": "repeated",
+            "group_count": 24,
+            "component_count": 8,
+            "factorization": None,
+        },
+        point_tile_size=1,
+        workspace_mib=1,
+        recurrence_summary={"lc_flow_layout": "contracted-color-union"},
+        validation_point=ValidationPointRecord(
+            process_id=process_id,
+            process="d d~ > z g",
+            seed=1,
+            error="not needed",
+        ),
+        generation_filters={},
+        generation_profile={},
+        recurrence_process_remap=_identity_remap(physical_sector_count=3),
+        recurrence_process_executor_pack=primary_pack,
+        process_digest=_digest("1"),
+        helicity_selector_companion=companion,
+    )
+
+    class PayloadSink:
+        def __init__(self) -> None:
+            self.paths: list[str] = []
+
+        def add_file(
+            self,
+            relative: str,
+            source: Path,
+            *,
+            process_id: str | None,
+        ) -> SimpleNamespace:
+            del process_id
+            payload = source.read_bytes()
+            self.paths.append(relative)
+            return SimpleNamespace(
+                size_bytes=len(payload),
+                sha256=hashlib.sha256(payload).hexdigest(),
+            )
+
+        def add_bytes(
+            self,
+            relative: str,
+            content: bytes,
+            *,
+            process_id: str | None,
+            media_type: str | None = None,
+        ) -> SimpleNamespace:
+            del process_id, media_type
+            self.paths.append(relative)
+            return SimpleNamespace(
+                size_bytes=len(content),
+                sha256=hashlib.sha256(content).hexdigest(),
+            )
+
+    class ManifestSink:
+        def __init__(self) -> None:
+            self.execution: dict[str, object] | None = None
+
+        def add_json(self, relative: str, value: object, **_kwargs: object) -> None:
+            del relative, value
+
+        def add_bytes(
+            self,
+            relative: str,
+            content: bytes,
+            **_kwargs: object,
+        ) -> SimpleNamespace:
+            if relative.endswith("/execution.json"):
+                decoded = json.loads(content)
+                assert isinstance(decoded, dict)
+                self.execution = decoded
+            return SimpleNamespace(sha256=hashlib.sha256(content).hexdigest())
+
+    primary_binding_payload = b"primary binding"
+    primary_binding_mapping = {
+        "abi": "pyamplicol-recurrence-process-binding-v4",
+        "process_id": process_id,
+        "schedule_digest": process.recurrence_schedule_digest,
+        "native_schedule_semantic_digest": (
+            process.recurrence_native_schedule_semantic_digest
+        ),
+        "process_digest": process.process_digest,
+        "process_semantic_digest": process.builder_input_sha256,
+        "process_support_words": [1],
+        "path": "recurrence-binding.bin",
+        "size_bytes": len(primary_binding_payload),
+        "sha256": hashlib.sha256(primary_binding_payload).hexdigest(),
+    }
+    primary_binding = SimpleNamespace(
+        artifact_path=f"processes/{process_id}/recurrence-binding.bin",
+        schedule_digest=process.recurrence_schedule_digest,
+        payload=primary_binding_payload,
+        size_bytes=len(primary_binding_payload),
+        sha256=hashlib.sha256(primary_binding_payload).hexdigest(),
+        to_mapping=lambda: primary_binding_mapping,
+    )
+    sharing = SimpleNamespace(
+        binding=lambda requested: primary_binding,
+        schedule=lambda _digest_value: SimpleNamespace(
+            artifact_path=(
+                f"recurrence/schedules/{process.recurrence_schedule_digest}/"
+                "recurrence-runtime.pacbin"
+            )
+        ),
+    )
+    evaluator_payloads = PayloadSink()
+    artifact_writer._write_recurrence_helicity_selector_schedule_roots(
+        evaluator_payloads,  # type: ignore[arg-type]
+        (process,),
+        recurrence_sharing=None,
+    )
+    manifest_sink = ManifestSink()
+    artifact_writer._write_process_payloads(
+        manifest_sink,  # type: ignore[arg-type]
+        process,
+        evaluator_payloads=evaluator_payloads,  # type: ignore[arg-type]
+        recurrence_sharing=sharing,  # type: ignore[arg-type]
+    )
+
+    expected_root = f"recurrence/schedules/{selector_digest}"
+    assert sorted(evaluator_payloads.paths) == sorted(
+        (
+            f"{expected_root}/recurrence-runtime.pacbin",
+            f"{expected_root}/recurrence-helicity-dispatch-v1.bin",
+            f"processes/{process_id}/recurrence-binding.bin",
+            f"processes/{process_id}/recurrence-color.bin",
+            f"processes/{process_id}/helicity-selector-binding.bin",
+        )
+    )
+    assert not any("on-the-fly" in path for path in evaluator_payloads.paths)
+    assert manifest_sink.execution is not None
+    encoded_execution = json.dumps(manifest_sink.execution)
+    assert "pyamplicol-recurrence-helicity-selector-companion-v2" in encoded_execution
+    assert "primary-local-color-view-v1" in encoded_execution
+    assert "on-the-fly" not in encoded_execution
+
+
+def test_recurrence_execution_summary_accepts_observed_large_manifest(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    observed_cluster_size = 40_826_959
+
+    content = _recurrence_execution_summary_with_size(
+        monkeypatch,
+        observed_cluster_size,
+    )
+
+    assert len(content) == observed_cluster_size
+
+
+def test_recurrence_physics_identifies_direct_plan_and_runtime_layout() -> None:
+    exact_one = SimpleNamespace(
+        real_numerator=1,
+        real_denominator=1,
+        imag_numerator=0,
+        imag_denominator=1,
+    )
+    source_state = SimpleNamespace(state_index=0, public_helicity=-1)
+    external_leg = SimpleNamespace(
+        source_slot=0,
+        public_label=1,
+        source_states=(source_state,),
+    )
+    logical = SimpleNamespace(
+        process_id="d_dbar_to_z_g",
+        layout="topology-replay",
+        selected_source_coverage=None,
+        selected_public_flow_ids=None,
+        external_legs=(external_leg,),
+        public_flows=(
+            SimpleNamespace(
+                flow_id=0,
+                public_id="flow:1",
+                word_source_slots=(0,),
+                reduction_weight=exact_one,
+            ),
+        ),
+    )
+    process = SimpleNamespace(
+        key="d_dbar_to_z_g",
+        process="d d~ > z g",
+        color_accuracy="lc",
+        legs=(
+            SimpleNamespace(
+                label=1,
+                particle="d",
+                pdg=1,
+                is_initial=True,
+            ),
+        ),
+    )
+    physics = recurrence_physics.build_recurrence_physics(
+        process,
+        logical,
+        SimpleNamespace(parameters=()),
+        process_id="d_dbar_to_z_g",
+        resolved_helicities=((-1,),),
+        normalization={},
+        selected_color_sector_ids=None,
+    )
+
+    extensions = physics["extensions"]
+    assert isinstance(extensions, dict)
+    selectors = extensions["runtime_selectors"]
+    assert isinstance(selectors, dict)
+    assert selectors["provenance"] == versions.RECURRENCE_PLAN_ABI
+    recurrence = extensions["recurrence"]
+    assert isinstance(recurrence, dict)
+    assert recurrence == {
+        "builder_input_abi": versions.RECURRENCE_BUILDER_INPUT_ABI,
+        "plan_abi": versions.RECURRENCE_PLAN_ABI,
+        "runtime_layout_abi": versions.RECURRENCE_RUNTIME_LAYOUT_ABI,
+        "direct_template_abi": versions.RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "lc_flow_layout": "topology-replay",
+    }
+    reduction = extensions["recurrence_runtime_reduction"]
+    assert isinstance(reduction, dict)
+    assert reduction["kind"] == "pyamplicol-recurrence-native-reduction-v2"
+    assert reduction["plan_member_path"] == (
+        "schedule/recurrence-direct-schedule-v2.bin"
+    )
+
+
+def test_recurrence_physics_keeps_sector_ids_distinct_from_flow_ids() -> None:
+    exact_one = SimpleNamespace(
+        real_numerator=1,
+        real_denominator=1,
+        imag_numerator=0,
+        imag_denominator=1,
+    )
+    external_leg = SimpleNamespace(
+        source_slot=0,
+        public_label=1,
+        source_states=(SimpleNamespace(state_index=0, public_helicity=-1),),
+    )
+    logical = SimpleNamespace(
+        process_id="g_g_to_g_g",
+        layout="topology-replay",
+        selected_source_coverage=None,
+        selected_public_flow_ids=(0, 1),
+        external_legs=(external_leg,),
+        public_flows=tuple(
+            SimpleNamespace(
+                flow_id=index,
+                public_id=f"flow:{index}",
+                word_source_slots=(0,),
+                reduction_weight=exact_one,
+            )
+            for index in range(2)
+        ),
+    )
+    process = SimpleNamespace(
+        key="g_g_to_g_g",
+        process="g g > g g",
+        color_accuracy="lc",
+        legs=(
+            SimpleNamespace(
+                label=1,
+                particle="g",
+                pdg=21,
+                is_initial=True,
+            ),
+        ),
+    )
+
+    physics = recurrence_physics.build_recurrence_physics(
+        process,
+        logical,
+        SimpleNamespace(parameters=()),
+        process_id="g_g_to_g_g",
+        resolved_helicities=((-1,),),
+        normalization={},
+        selected_color_sector_ids=(7,),
+    )
+
+    color_axis = physics["extensions"]["runtime_selectors"]["axes"]["color_flow"]
+    assert color_axis["generation_coverage"] == "selected"
+    assert color_axis["generation_selection"] == [7]
+    assert tuple(component["id"] for component in physics["color_components"]) == (
+        "flow:0",
+        "flow:1",
+    )
+
+
+def test_recurrence_physics_expands_global_helicity_flip_aliases() -> None:
+    exact_one = SimpleNamespace(
+        real_numerator=1,
+        real_denominator=1,
+        imag_numerator=0,
+        imag_denominator=1,
+    )
+    external_leg = SimpleNamespace(
+        source_slot=0,
+        public_label=1,
+        source_states=(
+            SimpleNamespace(state_index=0, public_helicity=-1),
+            SimpleNamespace(state_index=1, public_helicity=1),
+        ),
+    )
+    proof_digest = _digest("7")
+    logical = SimpleNamespace(
+        process_id="d_dbar_to_z_g",
+        layout="topology-replay",
+        semantic_digests=(
+            RecurrenceSemanticDigestV1(
+                "helicity-equivalence:global-flip-v1",
+                proof_digest,
+            ),
+        ),
+        selected_source_coverage=None,
+        selected_public_flow_ids=None,
+        external_legs=(external_leg,),
+        public_flows=(
+            SimpleNamespace(
+                flow_id=0,
+                public_id="flow:1",
+                word_source_slots=(0,),
+                reduction_weight=exact_one,
+            ),
+        ),
+    )
+    process = SimpleNamespace(
+        key="d_dbar_to_z_g",
+        process="d d~ > z g",
+        color_accuracy="lc",
+        legs=(
+            SimpleNamespace(
+                label=1,
+                particle="d",
+                pdg=1,
+                is_initial=True,
+            ),
+        ),
+    )
+
+    physics = recurrence_physics.build_recurrence_physics(
+        process,
+        logical,
+        SimpleNamespace(parameters=()),
+        process_id="d_dbar_to_z_g",
+        resolved_helicities=((-1,),),
+        normalization={},
+        selected_color_sector_ids=None,
+    )
+
+    assert physics["coverage"]["structural_zero_helicity_count"] == 0
+    negative, positive = physics["helicities"]
+    assert negative["computed"] is True
+    assert negative["representative_id"] == "h:-1"
+    assert positive["computed"] is False
+    assert positive["structural_zero"] is False
+    assert positive["representative_id"] == "h:-1"
+    reduction = physics["extensions"]["global_helicity_flip_reduction"]
+    assert reduction == {
+        "kind": "pyamplicol-global-helicity-flip-reduction-v1",
+        "proof_role": "helicity-equivalence:global-flip-v1",
+        "proof_digest": proof_digest,
+        "physical_nonzero_helicity_count": 2,
+        "representative_helicity_count": 1,
+        "aliases": [
+            {
+                "physical_id": "h:+1",
+                "representative_id": "h:-1",
+            }
+        ],
+    }
+
+
+def test_inspection_rejects_retired_recurrence_before_strict_manifest_load(
+    tmp_path: Path,
+) -> None:
+    (tmp_path / "artifact.json").write_text(
+        json.dumps(
+            {
+                "runtime": {
+                    "required_runtime_capabilities": [
+                        "rusticol.recurrence-runtime.complex-f64.v1"
+                    ]
+                },
+                "processes": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(ArtifactError, match=r"retired packet ABI.*regenerate"):
+        inspection.inspect_artifact(tmp_path)
+
+
+def test_direct_recurrence_inspection_exposes_arena_counters(tmp_path: Path) -> None:
+    _write_prepared_pack(tmp_path)
+    execution = _execution_manifest()
+    result = inspection._recurrence_execution_inspection(
+        SimpleNamespace(root=tmp_path),
+        execution,
+    )
+
+    assert result.invocation_count == 34
+    assert result.attachment_count == 0
+    assert result.arena_semantic_component_count == 48
+    assert result.arena_component_count == 32
+    assert result.arena_component_reuse_count == 16
+    assert result.momentum_form_count == 7
+    assert result.direct_source_row_count == 4
+    assert result.direct_contribution_row_count == 34
+    assert result.direct_finalization_row_count == 22
+    assert result.direct_closure_row_count == 12
+    assert result.direct_row_group_count == 11
+    assert result.packed_input_bytes == 0
+    assert result.packed_output_bytes == 0
+    assert result.scatter_bytes == 0
+
+
+def test_direct_recurrence_inspection_exposes_contracted_color_summary(
+    tmp_path: Path,
+) -> None:
+    _write_prepared_pack(tmp_path)
+    execution = _execution_manifest()
+    execution["runtime_metadata"]["color_contraction"] = {
+        "abi": "pyamplicol-recurrence-color-contraction-v3",
+        "color_accuracy": "full",
+        "storage": "repeated",
+        "includes_color_factor": True,
+        "group_count": 384,
+        "sector_count": 36,
+        "active_sector_count": 6,
+        "component_count": 64,
+        "destination_count": 384,
+        "entry_count": 21,
+        "logical_entry_count": 1344,
+        "semantic_digest": _digest("7"),
+        "factorization": {
+            "kind": "klein-four-walsh",
+            "rank": 2,
+            "coset_count": 1,
+        },
+        "path": "recurrence-color.bin",
+        "size_bytes": 4096,
+        "sha256": _digest("8"),
+    }
+
+    result = inspection._recurrence_execution_inspection(
+        SimpleNamespace(root=tmp_path),
+        execution,
+    )
+
+    assert result.recurrence_color_accuracy == "full"
+    assert result.recurrence_color_storage == "repeated"
+    assert result.recurrence_color_sector_count == 36
+    assert result.recurrence_color_active_sector_count == 6
+    assert result.recurrence_color_component_count == 64
+    assert result.recurrence_color_group_count == 384
+    assert result.recurrence_color_destination_count == 384
+    assert result.recurrence_color_entry_count == 21
+    assert result.recurrence_color_logical_entry_count == 1344
+    assert result.recurrence_color_factorization_kind == "klein-four-walsh"
+    assert result.recurrence_color_factorization_rank == 2
+    assert result.recurrence_color_factorization_coset_count == 1
+
+
+def test_inspection_requires_v2_metadata_without_packet_fallback(
+    tmp_path: Path,
+) -> None:
+    _write_prepared_pack(tmp_path)
+    execution = _execution_manifest()
+    execution["recurrence_plan_abi"] = "pyamplicol-recurrence-plan-v1"
+
+    with pytest.raises(ArtifactError, match="regenerate the recurrence artifact"):
+        inspection._recurrence_execution_inspection(
+            SimpleNamespace(root=tmp_path),
+            execution,
+        )
+
+
+def test_v2_inspection_tolerates_pending_direct_counter_wiring(
+    tmp_path: Path,
+) -> None:
+    _write_prepared_pack(tmp_path)
+    process = _recurrence_process()
+    process.inspection_summary.pop("direct_arena")
+    execution = _execution_manifest(process)
+
+    result = inspection._recurrence_execution_inspection(
+        SimpleNamespace(root=tmp_path),
+        execution,
+    )
+
+    assert result.arena_component_count is None
+    assert result.momentum_form_count is None
+    assert result.direct_row_group_count is None
+    assert result.packed_input_bytes == 0
+    assert result.packed_output_bytes == 0
+    assert result.scatter_bytes == 0
diff --git a/pyamplicol/tests/unit/test_recurrence_direct_intrinsics.py b/pyamplicol/tests/unit/test_recurrence_direct_intrinsics.py
new file mode 100644
index 0000000000..e9fb808aa6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_direct_intrinsics.py
@@ -0,0 +1,676 @@
+# SPDX-License-Identifier: 0BSD
+# ruff: noqa: RUF001
+
+from __future__ import annotations
+
+import json
+from decimal import Decimal, localcontext
+from fractions import Fraction
+
+import pytest
+
+from pyamplicol.models.recurrence_direct_intrinsics import (
+    _FINALIZATION_WITNESSES,
+    RECURRENCE_INTRINSIC_SCALE_KIND,
+    _exact_binary64_coefficients,
+    _normalized_expressions,
+    certify_recurrence_contribution_intrinsic,
+    certify_recurrence_finalization_intrinsic,
+)
+from pyamplicol.models.recurrence_template import ExactComplexRationalV1
+
+
+@pytest.mark.parametrize("literal", ("-1.0", "1.0", "-2.0", "2.0", "1.0i", "-1.0i"))
+def test_certification_normalizes_floating_units_exactly(literal: str) -> None:
+    from symbolica import E
+
+    expression = E(f"({literal})*sqrt(1/2)*x")
+    normalized = _exact_binary64_coefficients(expression)
+    integer_literal = literal.replace(".0", "")
+    assert bool(normalized == E(f"({integer_literal})*sqrt(1/2)*x"))
+    # The retained expression used by exact evaluation is never rewritten.
+    assert bool(expression == E(f"({literal})*sqrt(1/2)*x"))
+
+
+def test_certification_preserves_the_exact_binary64_value() -> None:
+    from symbolica import E
+
+    numerator, denominator = (0.1).as_integer_ratio()
+    normalized = _exact_binary64_coefficients(E("0.1*x"))
+    assert bool(normalized == E(f"({numerator}/{denominator})*x"))
+    assert not bool(normalized == E("x/10"))
+    assert bool(_exact_binary64_coefficients(E("x/3")) == E("x/3"))
+
+
+def test_certification_preserves_exactly_representable_high_precision_literal() -> None:
+    from symbolica import Expression, S
+
+    coefficient = Expression.num(Decimal("0.5000000000000000000000000000000000"))
+    expression = coefficient * S("literal_kind_x")
+    normalized = _exact_binary64_coefficients(expression)
+
+    # Numeric equality with binary64 0.5 is insufficient: its declared precision
+    # must survive, and it must not become the exact rational 1/2 here.
+    assert normalized.to_canonical_string() == expression.to_canonical_string()
+    assert bool(normalized.matches(expression))
+
+
+@pytest.mark.parametrize("coefficient", ("-1.0", "-1.000000000000001", "(-1+1/10^60)"))
+def test_radical_intrinsic_matching_does_not_round_away_coefficient_changes(
+    coefficient: str,
+) -> None:
+    expressions = (
+        "sqrt(1/2)*(-1.0i*l0*r3-1i*l1*r1+l1*r2+1i*l0*r0)",
+        f"sqrt(1/2)*(({coefficient})*l0*r2-1i*l0*r1+1i*l1*r0+1i*l1*r3)",
+    )
+    result = certify_recurrence_contribution_intrinsic(
+        exact_expressions=tuple(_substitute(item) for item in expressions),
+        input_contracts=_contracts(2, 4),
+        parent_component_counts=(2, 4),
+        destination_component_count=2,
+        binding_coupling=None,
+    )
+    if coefficient != "-1.0":
+        assert result is None
+    else:
+        assert result is not None
+        assert result.runtime_template.endswith("weyl-vector-to-weyl-a.v1")
+        assert result.constant_scale == pytest.approx(2**-0.5)
+
+
+@pytest.mark.parametrize("precision", (32, 100))
+def test_intrinsic_certification_retains_high_precision_radical(precision: int) -> None:
+    from symbolica import E, Evaluator
+
+    source = E("-1.0*sqrt(1/2)")
+    exact_evaluator = source.evaluator([], jit_compile=False)
+    serialized = exact_evaluator.save()
+    _exact_binary64_coefficients(source)
+    assert exact_evaluator.save() == serialized
+    value, imaginary = (
+        Evaluator.load(serialized)
+        .evaluate_complex_with_prec((), precision)[0]
+        .to_decimal_tuple()
+    )
+    with localcontext() as context:
+        context.prec = precision
+        expected = -(Decimal(1) / Decimal(2)).sqrt()
+        assert abs(value - expected) < Decimal(10) ** (2 - precision)
+    assert imaginary == 0
+
+
+def _contracts(
+    left_components: int,
+    right_components: int,
+    *,
+    parameter_index: int | None = None,
+    coupling: bool = False,
+) -> tuple[str, ...]:
+    values: list[dict[str, object]] = []
+    for role, count, prefix in (
+        ("left-current", left_components, "left"),
+        ("right-current", right_components, "right"),
+    ):
+        values.extend(
+            {
+                "component": component,
+                "role": role,
+                "symbol": f"model::prepared::{prefix}_{component}",
+            }
+            for component in range(count)
+        )
+    if parameter_index is not None:
+        values.append(
+            {
+                "component": 0,
+                "model_parameter_index": parameter_index,
+                "role": "model-parameter",
+                "symbol": "model::prepared::parameter",
+            }
+        )
+    if coupling:
+        values.extend(
+            (
+                {
+                    "component": 0,
+                    "role": "coupling-real",
+                    "symbol": "model::prepared::coupling_re",
+                },
+                {
+                    "component": 0,
+                    "role": "coupling-imag",
+                    "symbol": "model::prepared::coupling_im",
+                },
+            )
+        )
+    return tuple(
+        json.dumps(
+            item,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        for item in values
+    )
+
+
+def _substitute(expression: str) -> str:
+    result = expression
+    for side, count in (("l", 6), ("r", 4)):
+        prefix = "left" if side == "l" else "right"
+        for component in range(count):
+            result = result.replace(
+                f"{side}{component}",
+                f"model::prepared::{prefix}_{component}",
+            )
+    return result
+
+
+def _reversed_contracts(
+    canonical_left_components: int,
+    canonical_right_components: int,
+    *,
+    parameter_indexes: tuple[int, ...] = (),
+) -> tuple[str, ...]:
+    values: list[dict[str, object]] = []
+    for role, count, prefix in (
+        ("left-current", canonical_right_components, "vector"),
+        ("right-current", canonical_left_components, "weyl"),
+    ):
+        values.extend(
+            {
+                "component": component,
+                "role": role,
+                "symbol": f"ufo::prepared::{prefix}_{component}",
+            }
+            for component in range(count)
+        )
+    values.extend(
+        {
+            "component": 0,
+            "model_parameter_index": parameter_index,
+            "role": "model-parameter",
+            "symbol": f"ufo::prepared::parameter_{parameter_index}",
+        }
+        for parameter_index in parameter_indexes
+    )
+    return tuple(
+        json.dumps(
+            item,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        for item in values
+    )
+
+
+def _substitute_reversed(expression: str) -> str:
+    result = expression
+    for component in range(2):
+        result = result.replace(
+            f"l{component}",
+            f"ufo::prepared::weyl_{component}",
+        )
+    for component in range(4):
+        result = result.replace(
+            f"r{component}",
+            f"ufo::prepared::vector_{component}",
+        )
+    return result
+
+
+def _three_vector_contracts() -> tuple[str, ...]:
+    values = [
+        {
+            "component": component,
+            "role": role,
+            "symbol": f"model::prepared::{prefix}_{component}",
+        }
+        for role, prefix in (
+            ("left-current", "left"),
+            ("right-current", "right"),
+            ("left-momentum", "left_momentum"),
+            ("right-momentum", "right_momentum"),
+        )
+        for component in range(4)
+    ]
+    return tuple(
+        json.dumps(
+            item,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        for item in values
+    )
+
+
+def _substitute_three_vector(expression: str) -> str:
+    result = expression
+    for symbol, prefix in (
+        ("l", "left"),
+        ("r", "right"),
+        ("p", "left_momentum"),
+        ("q", "right_momentum"),
+    ):
+        for component in range(4):
+            result = result.replace(
+                f"{symbol}{component}",
+                f"model::prepared::{prefix}_{component}",
+            )
+    return result
+
+
+def _finalization_contracts(components: int) -> tuple[str, ...]:
+    values = [
+        {
+            "component": component,
+            "role": "current",
+            "symbol": f"model::prepared::current_{component}",
+        }
+        for component in range(components)
+    ]
+    values.extend(
+        {
+            "component": component,
+            "role": "momentum",
+            "symbol": f"model::prepared::momentum_{component}",
+        }
+        for component in range(4)
+    )
+    return tuple(
+        json.dumps(
+            item,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        for item in values
+    )
+
+
+def _substitute_finalization(expression: str, components: int) -> str:
+    result = expression
+    for component in range(components):
+        result = result.replace(
+            f"l{component}",
+            f"model::prepared::current_{component}",
+        )
+    for component in range(4):
+        result = result.replace(
+            f"p{component}",
+            f"model::prepared::momentum_{component}",
+        )
+    return result
+
+
+@pytest.mark.parametrize(
+    ("expressions", "shape", "destination", "expected_template", "expected_scale"),
+    (
+        (
+            (
+                "-1𝑖*l0*r3-1𝑖*l1*r1+l1*r2+1𝑖*l0*r0",
+                "-l0*r2-1𝑖*l0*r1+1𝑖*l1*r0+1𝑖*l1*r3",
+            ),
+            (2, 4),
+            2,
+            "rusticol.recurrence-intrinsic.weyl-vector-to-weyl-a.v1",
+            1.0 + 0.0j,
+        ),
+        (
+            (
+                "-l1*r2+1𝑖*l0*r0+1𝑖*l0*r3+1𝑖*l1*r1",
+                "-1𝑖*l1*r3+l0*r2+1𝑖*l0*r1+1𝑖*l1*r0",
+            ),
+            (2, 4),
+            2,
+            "rusticol.recurrence-intrinsic.weyl-vector-to-weyl-b.v1",
+            1.0 + 0.0j,
+        ),
+        (
+            (
+                "1𝑖/2*(l0*r1+l1*r2+l2*r3)",
+                "1𝑖/2*(l0*r0+l3*r2+l4*r3)",
+                "1𝑖/2*(-l3*r1+l1*r0+l5*r3)",
+                "1𝑖/2*(-l4*r1-l5*r2+l2*r0)",
+            ),
+            (6, 4),
+            4,
+            "rusticol.recurrence-intrinsic.antisymmetric-tensor-vector.v1",
+            0.0 + 0.5j,
+        ),
+        (
+            (
+                "-l1*r0+l0*r1",
+                "-l2*r0+l0*r2",
+                "-l3*r0+l0*r3",
+                "-l2*r1+l1*r2",
+                "-l3*r1+l1*r3",
+                "-l3*r2+l2*r3",
+            ),
+            (4, 4),
+            6,
+            "rusticol.recurrence-intrinsic.vector-wedge-vector.v1",
+            1.0 + 0.0j,
+        ),
+    ),
+)
+def test_certifies_model_namespace_independent_intrinsics(
+    expressions: tuple[str, ...],
+    shape: tuple[int, int],
+    destination: int,
+    expected_template: str,
+    expected_scale: complex,
+) -> None:
+    result = certify_recurrence_contribution_intrinsic(
+        exact_expressions=tuple(_substitute(item) for item in expressions),
+        input_contracts=_contracts(*shape),
+        parent_component_counts=shape,
+        destination_component_count=destination,
+        binding_coupling=None,
+    )
+
+    assert result is not None
+    assert result.runtime_template == expected_template
+    assert result.constant_scale == expected_scale
+    assert result.model_parameter_index is None
+    assert result.parent_permutation == (0, 1)
+    assert result.scale_projection()["kind"] == RECURRENCE_INTRINSIC_SCALE_KIND
+
+
+@pytest.mark.parametrize(
+    ("base", "expected_template"),
+    (
+        (
+            (
+                "-1𝑖*l0*r3-1𝑖*l1*r1+l1*r2+1𝑖*l0*r0",
+                "-l0*r2-1𝑖*l0*r1+1𝑖*l1*r0+1𝑖*l1*r3",
+            ),
+            "rusticol.recurrence-intrinsic.weyl-vector-to-weyl-a.v1",
+        ),
+        (
+            (
+                "-l1*r2+1𝑖*l0*r0+1𝑖*l0*r3+1𝑖*l1*r1",
+                "-1𝑖*l1*r3+l0*r2+1𝑖*l0*r1+1𝑖*l1*r0",
+            ),
+            "rusticol.recurrence-intrinsic.weyl-vector-to-weyl-b.v1",
+        ),
+    ),
+)
+def test_built_in_and_ufo_parent_orders_certify_the_same_weyl_family(
+    base: tuple[str, str],
+    expected_template: str,
+) -> None:
+    built_in = certify_recurrence_contribution_intrinsic(
+        exact_expressions=tuple(
+            f"-1𝑖*model::prepared::parameter*({_substitute(item)})" for item in base
+        ),
+        input_contracts=_contracts(2, 4, parameter_index=17),
+        parent_component_counts=(2, 4),
+        destination_component_count=2,
+        binding_coupling=None,
+    )
+    ufo = certify_recurrence_contribution_intrinsic(
+        exact_expressions=tuple(
+            f"-1𝑖*ufo::prepared::parameter_91*({_substitute_reversed(item)})"
+            for item in base
+        ),
+        input_contracts=_reversed_contracts(
+            2,
+            4,
+            parameter_indexes=(91,),
+        ),
+        parent_component_counts=(4, 2),
+        destination_component_count=2,
+        binding_coupling=None,
+        allow_nontrivial_parent_permutation=True,
+    )
+
+    assert built_in is not None
+    assert ufo is not None
+    assert built_in.runtime_template == expected_template
+    assert ufo.runtime_template == expected_template
+    assert built_in.contract_digest == ufo.contract_digest
+    assert built_in.constant_scale == ufo.constant_scale == -1.0j
+    assert built_in.parent_permutation == (0, 1)
+    assert ufo.parent_permutation == (1, 0)
+    assert built_in.model_parameter_index == 17
+    assert ufo.model_parameter_index == 91
+
+
+def test_reversed_parent_intrinsic_is_fail_closed_without_permutation_support() -> None:
+    base = (
+        "-l1*r2+1𝑖*l0*r0+1𝑖*l0*r3+1𝑖*l1*r1",
+        "-1𝑖*l1*r3+l0*r2+1𝑖*l0*r1+1𝑖*l1*r0",
+    )
+
+    result = certify_recurrence_contribution_intrinsic(
+        exact_expressions=tuple(_substitute_reversed(item) for item in base),
+        input_contracts=_reversed_contracts(2, 4),
+        parent_component_counts=(4, 2),
+        destination_component_count=2,
+        binding_coupling=None,
+    )
+
+    assert result is None
+
+
+def test_rejects_reversed_weyl_family_with_two_independent_parameters() -> None:
+    base = (
+        "-l1*r2+1𝑖*l0*r0+1𝑖*l0*r3+1𝑖*l1*r1",
+        "-1𝑖*l1*r3+l0*r2+1𝑖*l0*r1+1𝑖*l1*r0",
+    )
+    scale = "(ufo::prepared::parameter_91+ufo::prepared::parameter_92)"
+
+    result = certify_recurrence_contribution_intrinsic(
+        exact_expressions=tuple(
+            f"{scale}*({_substitute_reversed(item)})" for item in base
+        ),
+        input_contracts=_reversed_contracts(
+            2,
+            4,
+            parameter_indexes=(91, 92),
+        ),
+        parent_component_counts=(4, 2),
+        destination_component_count=2,
+        binding_coupling=None,
+        allow_nontrivial_parent_permutation=True,
+    )
+
+    assert result is None
+
+
+def test_rejects_noncontiguous_reversed_parent_basis() -> None:
+    contracts = [json.loads(item) for item in _reversed_contracts(2, 4)]
+    contracts = [
+        item
+        for item in contracts
+        if not (item["role"] == "left-current" and item["component"] == 2)
+    ]
+
+    result = certify_recurrence_contribution_intrinsic(
+        exact_expressions=(
+            _substitute_reversed("-l1*r2+1𝑖*l0*r0+1𝑖*l0*r3+1𝑖*l1*r1"),
+            _substitute_reversed("-1𝑖*l1*r3+l0*r2+1𝑖*l0*r1+1𝑖*l1*r0"),
+        ),
+        input_contracts=tuple(
+            json.dumps(
+                item,
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            for item in contracts
+        ),
+        parent_component_counts=(4, 2),
+        destination_component_count=2,
+        binding_coupling=None,
+        allow_nontrivial_parent_permutation=True,
+    )
+
+    assert result is None
+
+
+def test_certifies_one_model_parameter_scale() -> None:
+    base = (
+        "-l1*r2+1𝑖*l0*r0+1𝑖*l0*r3+1𝑖*l1*r1",
+        "-1𝑖*l1*r3+l0*r2+1𝑖*l0*r1+1𝑖*l1*r0",
+    )
+    result = certify_recurrence_contribution_intrinsic(
+        exact_expressions=tuple(
+            f"-2*model::prepared::parameter*({_substitute(item)})" for item in base
+        ),
+        input_contracts=_contracts(2, 4, parameter_index=17),
+        parent_component_counts=(2, 4),
+        destination_component_count=2,
+        binding_coupling=None,
+    )
+
+    assert result is not None
+    assert result.constant_scale == -2.0 + 0.0j
+    assert result.model_parameter_index == 17
+
+
+def test_certifies_color_ordered_three_vector_with_momentum_operands() -> None:
+    dot_lr = "(l0*r0-l1*r1-l2*r2-l3*r3)"
+    dot_lq = "(l0*q0-l1*q1-l2*q2-l3*q3)"
+    dot_rp = "(r0*p0-r1*p1-r2*p2-r3*p3)"
+    expressions = tuple(
+        _substitute_three_vector(
+            f"3𝑖/2*({dot_lr}*(p{component}-q{component})"
+            f"+2*({dot_lq}*r{component}-{dot_rp}*l{component}))"
+        )
+        for component in range(4)
+    )
+
+    result = certify_recurrence_contribution_intrinsic(
+        exact_expressions=expressions,
+        input_contracts=_three_vector_contracts(),
+        parent_component_counts=(4, 4),
+        destination_component_count=4,
+        binding_coupling=None,
+    )
+
+    assert result is not None
+    assert (
+        result.runtime_template
+        == "rusticol.recurrence-intrinsic.color-ordered-three-vector.v1"
+    )
+    assert result.constant_scale == 0.0 + 1.5j
+    assert result.model_parameter_index is None
+
+
+def test_substitutes_exact_binding_coupling_before_certification() -> None:
+    base = (
+        "-l1*r2+1𝑖*l0*r0+1𝑖*l0*r3+1𝑖*l1*r1",
+        "-1𝑖*l1*r3+l0*r2+1𝑖*l0*r1+1𝑖*l1*r0",
+    )
+    result = certify_recurrence_contribution_intrinsic(
+        exact_expressions=tuple(
+            f"model::prepared::coupling_re*({_substitute(item)})" for item in base
+        ),
+        input_contracts=_contracts(2, 4, coupling=True),
+        parent_component_counts=(2, 4),
+        destination_component_count=2,
+        binding_coupling=ExactComplexRationalV1.from_fractions(
+            Fraction(3, 2), Fraction(0)
+        ),
+    )
+
+    assert result is not None
+    assert result.constant_scale == 1.5 + 0.0j
+
+
+def test_rejects_near_match_with_extra_tensor_term() -> None:
+    result = certify_recurrence_contribution_intrinsic(
+        exact_expressions=(
+            _substitute("-l1*r2+1𝑖*l0*r0+1𝑖*l0*r3+1𝑖*l1*r1+l0*r2"),
+            _substitute("-1𝑖*l1*r3+l0*r2+1𝑖*l0*r1+1𝑖*l1*r0"),
+        ),
+        input_contracts=_contracts(2, 4),
+        parent_component_counts=(2, 4),
+        destination_component_count=2,
+        binding_coupling=None,
+    )
+
+    assert result is None
+
+
+@pytest.mark.parametrize(
+    ("expressions", "components", "expected_template"),
+    (
+        (
+            (
+                "(-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1)"
+                "*(-1𝑖*l0*p3-1𝑖*l1*p1+l1*p2+1𝑖*l0*p0)",
+                "(-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1)"
+                "*(-l0*p2-1𝑖*l0*p1+1𝑖*l1*p0+1𝑖*l1*p3)",
+            ),
+            2,
+            "rusticol.recurrence-intrinsic.weyl-propagator-a.v1",
+        ),
+        (
+            (
+                "(-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1)"
+                "*(-l1*p2+1𝑖*l0*p0+1𝑖*l0*p3+1𝑖*l1*p1)",
+                "(-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1)"
+                "*(-1𝑖*l1*p3+l0*p2+1𝑖*l0*p1+1𝑖*l1*p0)",
+            ),
+            2,
+            "rusticol.recurrence-intrinsic.weyl-propagator-b.v1",
+        ),
+        (
+            (
+                "(-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1)*-1𝑖*l0",
+                "(-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1)*-1𝑖*l1",
+                "(-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1)*-1𝑖*l2",
+                "(-1*p1^2+-1*p2^2+-1*p3^2+p0^2)^(-1)*-1𝑖*l3",
+            ),
+            4,
+            "rusticol.recurrence-intrinsic.vector-propagator-feynman.v1",
+        ),
+    ),
+)
+@pytest.mark.parametrize("floating_units", (False, True))
+def test_certifies_finalization_intrinsics(
+    expressions: tuple[str, ...],
+    components: int,
+    expected_template: str,
+    floating_units: bool,
+) -> None:
+    if floating_units:
+        expressions = tuple(item.replace("-1", "-1.0") for item in expressions)
+    result = certify_recurrence_finalization_intrinsic(
+        exact_expressions=tuple(
+            _substitute_finalization(item, components) for item in expressions
+        ),
+        input_contracts=_finalization_contracts(components),
+        component_count=components,
+    )
+
+    assert result == expected_template
+    if "weyl-propagator" in expected_template:
+        from symbolica import E
+
+        # Unlike contribution intrinsics, these native finalizers have no
+        # extra scale input: the whole expression must equal the primitive.
+        normalized, _ = _normalized_expressions(
+            tuple(_substitute_finalization(item, components) for item in expressions),
+            _finalization_contracts(components),
+            binding_coupling=None,
+        )
+        witness = next(
+            item
+            for item in _FINALIZATION_WITNESSES
+            if item.runtime_template == expected_template
+        )
+        assert all(
+            bool(actual == E(reference).expand())
+            for actual, reference in zip(normalized, witness.expressions, strict=True)
+        )
diff --git a/pyamplicol/tests/unit/test_recurrence_direct_template.py b/pyamplicol/tests/unit/test_recurrence_direct_template.py
new file mode 100644
index 0000000000..6724279283
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_direct_template.py
@@ -0,0 +1,742 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import replace
+from fractions import Fraction
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.models import BuiltinSMModel, CompiledUFOModel, compile_model_source
+from pyamplicol.models.prepared_catalog import build_prepared_kernel_catalog
+from pyamplicol.models.recurrence_catalog_builder import (
+    build_recurrence_template_catalog,
+)
+from pyamplicol.models.recurrence_direct_intrinsics import (
+    CertifiedRecurrenceIntrinsic,
+)
+from pyamplicol.models.recurrence_direct_template import (
+    NATIVE_DIRECT_APPLICATION_ABI,
+    RECURRENCE_DIRECT_BACKEND_ABI,
+    RECURRENCE_DIRECT_IDENTITY_FINALIZER,
+    RECURRENCE_DIRECT_TEMPLATE_ABI,
+    SYMJIT_DIRECT_APPLICATION_ABI,
+    PreparedJitDirectSourceV1,
+    PreparedNativeDirectCallableSpecV1,
+    PreparedNativeDirectSourceV1,
+    RecurrenceDirectPayloadBindingV1,
+    RecurrenceDirectTemplateCatalogV1,
+    RecurrenceDirectTemplateError,
+    RecurrenceDirectTemplateV1,
+    _build_certified_intrinsic_binding,
+    _build_prepared_jit_direct_binding,
+    _uniform_binding_coupling,
+    build_prepared_native_direct_callable_specs,
+    build_recurrence_direct_template_catalog,
+    native_direct_entry_point,
+    prepared_kernel_payload_digest,
+)
+from pyamplicol.models.recurrence_template import ExactComplexRationalV1
+
+_DIGEST_A = "a" * 64
+_DIGEST_B = "b" * 64
+_DIGEST_C = "c" * 64
+_DIGEST_D = "d" * 64
+_DIGEST_E = "e" * 64
+_DIGEST_F = "f" * 64
+_UFO_SM_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+
+
+def _payload_binding(
+    *,
+    kind: str = "pending-direct-call-abi",
+) -> RecurrenceDirectPayloadBindingV1:
+    if kind == "rusticol-intrinsic":
+        return RecurrenceDirectPayloadBindingV1(
+            kind="rusticol-intrinsic",
+            payload_digest=_DIGEST_B,
+            runtime_template="rusticol.source-fill.vector.v1:test",
+        )
+    return RecurrenceDirectPayloadBindingV1(
+        kind="pending-direct-call-abi",
+        payload_digest=_DIGEST_B,
+        prepared_kernel_id=0,
+    )
+
+
+def _template(
+    *,
+    executor_id: int = 0,
+    evaluator_binding_id: int | None = None,
+    role: str = "contribution",
+    backend: str = "jit",
+    payload_kind: str = "pending-direct-call-abi",
+) -> RecurrenceDirectTemplateV1:
+    operations = {
+        "source": "initialize",
+        "contribution": "add",
+        "finalization": "finalize-in-place",
+        "closure": "closure-add",
+    }
+    parent_counts = {
+        "source": (),
+        "contribution": (4, 4),
+        "finalization": (4,),
+        "closure": (4, 4),
+    }
+    return RecurrenceDirectTemplateV1(
+        template_id=f"direct:{role}:{executor_id}",
+        direct_executor_id=executor_id,
+        evaluator_binding_id=(
+            executor_id if evaluator_binding_id is None else evaluator_binding_id
+        ),
+        evaluator_resolver_key=f"evaluator:{role}:{executor_id}",
+        role=role,  # type: ignore[arg-type]
+        parent_arity=len(parent_counts[role]),
+        parent_component_counts=parent_counts[role],
+        destination_component_count=4 if role != "closure" else 1,
+        momentum_operand_count=(
+            0 if role == "closure" else len(parent_counts[role]) or 1
+        ),
+        destination_operation=operations[role],  # type: ignore[arg-type]
+        coupling_slot_count=1 if role == "contribution" else 0,
+        parameter_slot_count=1,
+        semantic_template_ids=(f"semantic:{role}:{executor_id}",),
+        exact_expression_digest=_DIGEST_A,
+        payload_binding=_payload_binding(kind=payload_kind),
+        backend=backend,  # type: ignore[arg-type]
+        target_triple=(
+            "symjit-storage-v3-portable" if backend == "jit" else "x86_64-linux"
+        ),
+        portable=backend == "jit",
+        optimization_level=2 if backend == "jit" else 3,
+        alignment_bytes=64,
+        simd_axis="points-contiguous",
+        destination_aliasing=role == "finalization",
+    )
+
+
+def _catalog(
+    templates: tuple[RecurrenceDirectTemplateV1, ...],
+    *,
+    backend: str = "jit",
+) -> RecurrenceDirectTemplateCatalogV1:
+    return RecurrenceDirectTemplateCatalogV1(
+        templates=templates,
+        backend=backend,  # type: ignore[arg-type]
+        target_triple=(
+            "symjit-storage-v3-portable" if backend == "jit" else "x86_64-linux"
+        ),
+        portable=backend == "jit",
+        optimization_level=2 if backend == "jit" else 3,
+        compiled_model_digest=_DIGEST_A,
+        recurrence_template_catalog_digest=_DIGEST_B,
+        prepared_kernel_pack_digest=_DIGEST_C,
+        prepared_kernel_contract_digest=_DIGEST_D,
+        prepared_kernel_payload_digest=_DIGEST_E,
+        optimization_settings_digest=_DIGEST_F,
+    )
+
+
+def test_direct_template_catalog_round_trips_canonical_payload() -> None:
+    source = _template(
+        executor_id=0,
+        role="source",
+        payload_kind="rusticol-intrinsic",
+    )
+    contribution = _template(executor_id=1)
+    catalog = _catalog((source, contribution))
+
+    restored = RecurrenceDirectTemplateCatalogV1.from_dict(
+        json.loads(catalog.canonical_json)
+    )
+
+    assert restored == catalog
+    assert restored.abi == RECURRENCE_DIRECT_TEMPLATE_ABI
+    assert restored.backend_abi == RECURRENCE_DIRECT_BACKEND_ABI
+    assert restored.catalog_digest == catalog.catalog_digest
+    assert restored.direct_executor_id_for("source", 0) == 0
+    assert restored.direct_executor_id_for("contribution", 1) == 1
+    assert not restored.executable
+
+
+def test_catalog_digest_authenticates_serialized_metadata() -> None:
+    payload = _catalog((_template(),)).to_dict()
+    payload["prepared_kernel_payload_digest"] = "0" * 64
+
+    with pytest.raises(RecurrenceDirectTemplateError, match="catalog digest"):
+        RecurrenceDirectTemplateCatalogV1.from_dict(payload)
+
+
+def test_direct_jit_templates_require_portable_symjit_o2() -> None:
+    template = _template()
+
+    with pytest.raises(RecurrenceDirectTemplateError, match="portable SymJIT O2"):
+        replace(template, optimization_level=3, semantic_digest="")
+    with pytest.raises(RecurrenceDirectTemplateError, match="portable SymJIT O2"):
+        replace(template, portable=False, semantic_digest="")
+
+
+def test_direct_cpp_and_asm_templates_are_target_native() -> None:
+    for backend in ("cpp", "asm"):
+        template = _template(backend=backend)
+        assert template.optimization_level == 3
+        assert not template.portable
+        with pytest.raises(RecurrenceDirectTemplateError, match="target-native"):
+            replace(template, portable=True, semantic_digest="")
+
+
+def test_role_fixes_destination_operation_parent_contract_and_aliasing() -> None:
+    template = _template()
+
+    with pytest.raises(RecurrenceDirectTemplateError, match="must use 'add'"):
+        replace(template, destination_operation="initialize", semantic_digest="")
+    with pytest.raises(
+        RecurrenceDirectTemplateError, match="cover every nonempty parent"
+    ):
+        replace(template, parent_component_counts=(4,), semantic_digest="")
+    with pytest.raises(RecurrenceDirectTemplateError, match="only direct finalization"):
+        replace(template, destination_aliasing=True, semantic_digest="")
+
+
+def test_catalog_requires_dense_ids_and_unique_semantic_mapping() -> None:
+    first = _template(executor_id=0, evaluator_binding_id=4)
+    duplicate_mapping = replace(
+        _template(executor_id=1, evaluator_binding_id=5),
+        evaluator_binding_id=4,
+        semantic_digest="",
+    )
+    with pytest.raises(RecurrenceDirectTemplateError, match="mappings must be unique"):
+        _catalog((first, duplicate_mapping))
+
+    with pytest.raises(RecurrenceDirectTemplateError, match="dense zero-based"):
+        _catalog((_template(executor_id=1),))
+
+
+def test_pending_binding_cannot_claim_direct_payload_paths() -> None:
+    with pytest.raises(RecurrenceDirectTemplateError, match="cannot claim"):
+        RecurrenceDirectPayloadBindingV1(
+            kind="pending-direct-call-abi",
+            prepared_kernel_id=0,
+            payload_digest=_DIGEST_A,
+            payload_paths=("kernels/000000/direct.symjit",),
+        )
+
+
+def test_payload_binding_rejects_predecessor_abi_with_regeneration_message() -> None:
+    payload = _payload_binding().to_dict()
+    payload["abi"] = "pyamplicol-recurrence-direct-" + "payload-binding-v1"
+
+    with pytest.raises(RecurrenceDirectTemplateError, match="regenerate"):
+        RecurrenceDirectPayloadBindingV1.from_dict(payload)
+
+
+def test_certified_intrinsic_parent_permutation_round_trips_and_is_authenticated() -> (
+    None
+):
+    binding = _build_certified_intrinsic_binding(
+        CertifiedRecurrenceIntrinsic(
+            runtime_template=("rusticol.recurrence-intrinsic.weyl-vector-to-weyl-a.v1"),
+            contract_digest=_DIGEST_A,
+            constant_scale=-1.0j,
+            model_parameter_index=17,
+            parent_permutation=(1, 0),
+        )
+    )
+
+    assert binding.contribution_parent_permutation == (1, 0)
+    assert binding.to_dict()["contribution_parent_permutation"] == [1, 0]
+    assert RecurrenceDirectPayloadBindingV1.from_dict(binding.to_dict()) == binding
+
+    tampered = binding.to_dict()
+    tampered["contribution_parent_permutation"] = [0, 1]
+    with pytest.raises(
+        RecurrenceDirectTemplateError,
+        match="payload digest does not match",
+    ):
+        RecurrenceDirectPayloadBindingV1.from_dict(tampered)
+
+
+@pytest.mark.parametrize(
+    "parent_permutation",
+    ((0, 0), (1, 1), (0,), (0, 1, 2)),
+)
+def test_payload_binding_rejects_malformed_parent_permutation(
+    parent_permutation: tuple[int, ...],
+) -> None:
+    with pytest.raises(
+        RecurrenceDirectTemplateError,
+        match="parent permutation must be",
+    ):
+        replace(
+            _payload_binding(),
+            contribution_parent_permutation=parent_permutation,  # type: ignore[arg-type]
+        )
+
+
+def test_only_contribution_intrinsics_allow_reversed_parents() -> None:
+    with pytest.raises(
+        RecurrenceDirectTemplateError,
+        match="non-contribution intrinsics require the identity",
+    ):
+        replace(
+            _payload_binding(kind="rusticol-intrinsic"),
+            contribution_parent_permutation=(1, 0),
+        )
+    with pytest.raises(
+        RecurrenceDirectTemplateError,
+        match="prepared direct payloads require the identity",
+    ):
+        replace(
+            _payload_binding(),
+            contribution_parent_permutation=(1, 0),
+        )
+
+
+def test_per_kernel_payload_digest_is_deterministic_and_complete() -> None:
+    records = {
+        "kernels/000000/application.symjit": (3, _DIGEST_A),
+        "kernels/000000/exact.bin": (7, _DIGEST_B),
+    }
+    first = prepared_kernel_payload_digest(
+        kernel_id=0,
+        payload_records=records,
+        referenced_paths=tuple(reversed(tuple(records))),
+    )
+    second = prepared_kernel_payload_digest(
+        kernel_id=0,
+        payload_records=records,
+        referenced_paths=tuple(records),
+    )
+    assert first == second
+    with pytest.raises(RecurrenceDirectTemplateError, match="is absent"):
+        prepared_kernel_payload_digest(
+            kernel_id=0,
+            payload_records=records,
+            referenced_paths=("missing",),
+        )
+
+
+def test_direct_jit_binding_complexifies_real_inputs_with_shared_zero() -> None:
+    contracts = (
+        {"component": 0, "role": "left-current"},
+        {"component": 1, "role": "left-momentum"},
+        {"component": 2, "role": "coupling-real"},
+        {
+            "component": 3,
+            "model_parameter_index": 4,
+            "role": "model-parameter",
+        },
+    )
+    source = PreparedJitDirectSourceV1(
+        prepared_kernel_id=7,
+        source_application_path="kernels/000007/application.plane.symjit",
+        source_application_sha256=_DIGEST_A,
+        source_application_abi=SYMJIT_DIRECT_APPLICATION_ABI,
+        input_contracts=tuple(
+            json.dumps(
+                contract,
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            for contract in contracts
+        ),
+        exact_expressions=("pyamplicol::prepared_output",),
+        output_arity=1,
+    )
+
+    binding = _build_prepared_jit_direct_binding(
+        source=source,
+        role="contribution",
+        parent_component_counts=(4,),
+        destination_component_count=4,
+        binding_coupling=ExactComplexRationalV1.from_fractions(
+            Fraction(-3, 2),
+            Fraction(1, 4),
+        ),
+        prepared_template_semantic_digest=_DIGEST_B,
+    )
+    parameter_bindings = tuple(json.loads(item) for item in binding.parameter_bindings)
+    scalar_projections = tuple(json.loads(item) for item in binding.scalar_projections)
+
+    assert len(parameter_bindings) == 2 * len(contracts)
+    assert [item["kind"] for item in parameter_bindings] == [
+        "plane",
+        "plane",
+        "plane",
+        "scalar",
+        "scalar",
+        "scalar",
+        "scalar",
+        "scalar",
+    ]
+    zero_indices = [
+        item["index"] for item in (parameter_bindings[3], parameter_bindings[5])
+    ]
+    assert zero_indices[0] == zero_indices[1]
+    assert scalar_projections[zero_indices[0]] == {
+        "kind": "literal",
+        "value": 0.0,
+    }
+    assert {"kind": "literal", "value": -1.5} in scalar_projections
+    assert not any(
+        item.get("kind") == "parameter" and item.get("index") == 2
+        for item in scalar_projections
+    )
+    assert binding.contribution_parent_permutation == (0, 1)
+    with pytest.raises(
+        RecurrenceDirectTemplateError,
+        match="prepared direct payloads require the identity",
+    ):
+        replace(binding, contribution_parent_permutation=(1, 0))
+
+
+def test_direct_jit_binding_rejects_conflicting_semantic_couplings() -> None:
+    first = ExactComplexRationalV1.one()
+    second = ExactComplexRationalV1.from_fractions(2)
+    records = {
+        "first": SimpleNamespace(binding_coupling=first),
+        "second": SimpleNamespace(binding_coupling=second),
+    }
+
+    with pytest.raises(RecurrenceDirectTemplateError, match="conflicting"):
+        _uniform_binding_coupling(
+            ("first", "second"),
+            records,
+            required=True,
+        )
+
+
+@pytest.mark.parametrize("model_source", ("built-in", "ufo-sm"))
+def test_direct_catalog_is_model_generic_and_covers_identity_finalizers(
+    model_source: str,
+) -> None:
+    if model_source == "built-in":
+        model = BuiltinSMModel()
+    else:
+        compiled = compile_model_source(
+            _UFO_SM_ROOT / "sm.json",
+            restriction=str((_UFO_SM_ROOT / "restrict_default.json").resolve()),
+            use_cache=True,
+        )
+        model = CompiledUFOModel(compiled)
+    prepared = build_prepared_kernel_catalog(model)
+    semantic = build_recurrence_template_catalog(
+        model,
+        prepared,
+        compiled_model_digest=_DIGEST_A,
+        prepared_kernel_pack_digest=_DIGEST_C,
+    )
+    native_specs = build_prepared_native_direct_callable_specs(
+        semantic,
+        prepared.by_id,
+    )
+    assert native_specs
+    assert all(
+        kernel_id == spec.prepared_kernel_id for kernel_id, spec in native_specs.items()
+    )
+    assert all(spec.role != "source" for spec in native_specs.values())
+    assert all(
+        spec.native_entry_point
+        == native_direct_entry_point(spec.role, spec.prepared_kernel_id)
+        for spec in native_specs.values()
+    )
+    if model_source == "built-in":
+        # Kernel IDs are assigned in content-signature order and may therefore
+        # move when Symbolica changes an equivalent canonical spelling.  The
+        # callable shape inventory is the stable execution contract.
+        merged_parent_shapes = sorted(
+            spec.parent_component_shapes
+            for spec in native_specs.values()
+            if len(spec.parent_component_shapes) > 1
+        )
+        assert merged_parent_shapes == [
+            ((2, 2), (2, 4)),
+            ((2, 2), (2, 4)),
+            ((2, 2), (2, 4)),
+            ((2, 2), (4, 2)),
+            ((2, 2), (4, 2)),
+            ((2, 2), (4, 2)),
+        ]
+    direct = build_recurrence_direct_template_catalog(
+        semantic,
+        backend="jit",
+        target_triple="symjit-storage-v3-portable",
+        portable=True,
+        optimization_level=2,
+        prepared_kernel_pack_digest=_DIGEST_C,
+        prepared_kernel_contract_digest=_DIGEST_D,
+        prepared_kernel_payload_digest=_DIGEST_E,
+        optimization_settings_digest=_DIGEST_F,
+        prepared_kernel_payload_digests={
+            kernel.kernel_id: hashlib.sha256(
+                f"{kernel.kernel_id}:{kernel.canonical_signature}".encode()
+            ).hexdigest()
+            for kernel in prepared.kernels
+        },
+        prepared_jit_sources={
+            kernel.kernel_id: PreparedJitDirectSourceV1(
+                prepared_kernel_id=kernel.kernel_id,
+                source_application_path=(
+                    f"kernels/{kernel.kernel_id:06d}/application.plane.symjit"
+                ),
+                source_application_sha256=hashlib.sha256(
+                    f"application:{kernel.kernel_id}".encode()
+                ).hexdigest(),
+                source_application_abi=SYMJIT_DIRECT_APPLICATION_ABI,
+                input_contracts=tuple(
+                    json.dumps(
+                        item.to_dict(),
+                        allow_nan=False,
+                        ensure_ascii=True,
+                        separators=(",", ":"),
+                        sort_keys=True,
+                    )
+                    for item in kernel.inputs
+                ),
+                exact_expressions=kernel.exact_expressions,
+                output_arity=kernel.output_dimension,
+            )
+            for kernel in prepared.kernels
+        },
+    )
+
+    assert [item.direct_executor_id for item in direct.templates] == list(
+        range(len(direct.templates))
+    )
+    contract_roles = {
+        "source": "source",
+        "vertex": "contribution",
+        "propagator": "finalization",
+        "closure": "closure",
+    }
+    for binding_id, binding in enumerate(semantic.evaluator_bindings):
+        role = contract_roles.get(binding.contract_kind)
+        if role is not None:
+            direct.direct_executor_id_for(role, binding_id)  # type: ignore[arg-type]
+    identity_templates = tuple(
+        item
+        for item in direct.templates
+        if item.payload_binding.runtime_template
+        and item.payload_binding.runtime_template.startswith(
+            RECURRENCE_DIRECT_IDENTITY_FINALIZER
+        )
+    )
+    identity_propagator_ids = tuple(
+        sorted(
+            propagator.template_id
+            for propagator in semantic.propagators
+            if not propagator.applies_propagator
+        )
+    )
+    assert len(identity_templates) == (1 if identity_propagator_ids else 0)
+    assert all(item.role == "finalization" for item in identity_templates)
+    assert all(
+        item.payload_binding.runtime_template == RECURRENCE_DIRECT_IDENTITY_FINALIZER
+        for item in identity_templates
+    )
+    assert all(
+        item.semantic_template_ids == identity_propagator_ids
+        for item in identity_templates
+    )
+    assert all(
+        item.payload_binding.kind == "rusticol-intrinsic" for item in identity_templates
+    )
+    contribution_intrinsics = tuple(
+        item
+        for item in direct.templates
+        if item.role == "contribution"
+        and item.payload_binding.kind == "rusticol-intrinsic"
+    )
+    intrinsic_families = {
+        item.payload_binding.runtime_template for item in contribution_intrinsics
+    }
+    assert {
+        "rusticol.recurrence-intrinsic.weyl-vector-to-weyl-a.v1",
+        "rusticol.recurrence-intrinsic.weyl-vector-to-weyl-b.v1",
+    }.issubset(intrinsic_families)
+    if model_source == "ufo-sm":
+        assert any(
+            item.payload_binding.contribution_parent_permutation == (1, 0)
+            for item in contribution_intrinsics
+        )
+    prepared_templates = tuple(
+        item
+        for item in direct.templates
+        if item.payload_binding.prepared_kernel_id is not None
+    )
+    assert prepared_templates
+    assert all(
+        item.payload_binding.kind == "prepared-direct-call"
+        for item in prepared_templates
+    )
+    assert all(item.payload_binding.executable for item in prepared_templates)
+    assert all(
+        item.payload_binding.source_application_abi == SYMJIT_DIRECT_APPLICATION_ABI
+        for item in prepared_templates
+    )
+    assert all(
+        item.payload_binding.direct_application_abi == SYMJIT_DIRECT_APPLICATION_ABI
+        for item in prepared_templates
+    )
+    assert all(
+        item.payload_binding.exact_factor_scalar_slots == (0, 1)
+        for item in prepared_templates
+    )
+    assert all(
+        item.payload_binding.payload_paths
+        == (item.payload_binding.source_application_path,)
+        for item in prepared_templates
+    )
+    assert all(
+        item.payload_binding.contribution_parent_permutation == (0, 1)
+        for item in prepared_templates
+    )
+    assert all(
+        item.payload_binding.contribution_parent_permutation == (0, 1)
+        for item in direct.templates
+        if item.role != "contribution"
+    )
+    for item in prepared_templates:
+        payload = item.payload_binding.to_dict()
+        for projection in payload["input_plane_projections"]:
+            kind = projection["kind"]
+            if kind == "parent-current":
+                parent = projection["parent"]
+                assert parent < len(item.parent_component_counts)
+                assert projection["component"] < item.parent_component_counts[parent]
+            elif kind == "momentum":
+                assert projection["operand"] < item.momentum_operand_count
+                assert projection["lorentz_component"] < 4
+            elif kind in {"destination-current", "destination-amplitude"}:
+                assert projection["component"] < item.destination_component_count
+            else:  # pragma: no cover - schema validation owns this branch
+                raise AssertionError(f"unknown projection kind {kind!r}")
+    assert (
+        RecurrenceDirectTemplateCatalogV1.from_dict(json.loads(direct.canonical_json))
+        == direct
+    )
+    native_direct = build_recurrence_direct_template_catalog(
+        semantic,
+        backend="cpp",
+        target_triple="x86_64-linux",
+        portable=False,
+        optimization_level=3,
+        prepared_kernel_pack_digest=_DIGEST_C,
+        prepared_kernel_contract_digest=_DIGEST_D,
+        prepared_kernel_payload_digest=_DIGEST_E,
+        optimization_settings_digest=_DIGEST_F,
+        prepared_kernel_payload_digests={
+            kernel.kernel_id: hashlib.sha256(
+                f"{kernel.kernel_id}:{kernel.canonical_signature}".encode()
+            ).hexdigest()
+            for kernel in prepared.kernels
+        },
+        prepared_native_sources={
+            kernel_id: PreparedNativeDirectSourceV1(
+                prepared_kernel_id=kernel_id,
+                role=spec.role,
+                native_entry_point=spec.native_entry_point,
+                source_application_path=(
+                    f"kernels/{kernel_id:06d}/libprepared-native.so"
+                ),
+                source_application_sha256=hashlib.sha256(
+                    f"native-library:{kernel_id}".encode()
+                ).hexdigest(),
+                source_application_abi="symbolica.compiled-cpp.complex-f64.v1",
+                input_contracts=spec.input_contracts,
+                exact_expressions=spec.exact_expressions,
+                output_arity=spec.output_arity,
+            )
+            for kernel_id, spec in native_specs.items()
+        },
+    )
+    native_prepared = tuple(
+        item
+        for item in native_direct.templates
+        if item.payload_binding.prepared_kernel_id is not None
+    )
+    assert native_prepared
+    assert all(
+        item.payload_binding.kind == "prepared-direct-call"
+        and item.payload_binding.direct_application_abi == NATIVE_DIRECT_APPLICATION_ABI
+        and item.payload_binding.native_entry_point
+        == native_direct_entry_point(
+            item.role,
+            item.payload_binding.prepared_kernel_id,
+        )
+        for item in native_prepared
+    )
+    assert native_direct.executable
+    assert model_source not in direct.canonical_json
+
+
+def test_native_direct_specs_merge_shapes_but_reject_semantic_conflicts() -> None:
+    import pyamplicol.models.recurrence_direct_template as direct_template
+
+    common = {
+        "prepared_kernel_id": 20,
+        "role": "contribution",
+        "native_entry_point": native_direct_entry_point(
+            "contribution",
+            20,
+        ),
+        "input_contracts": (
+            json.dumps(
+                {"component": 1, "role": "left-current"},
+                separators=(",", ":"),
+                sort_keys=True,
+            ),
+        ),
+        "exact_expressions": ("test::out0", "test::out1"),
+        "output_arity": 2,
+        "destination_component_counts": (2,),
+    }
+    narrow = PreparedNativeDirectCallableSpecV1(
+        **common,
+        parent_component_shapes=((2, 2),),
+    )
+    wide = replace(
+        narrow,
+        parent_component_shapes=((4, 2),),
+        destination_component_counts=(2, 4),
+    )
+    merged = direct_template._merge_prepared_native_direct_callable_specs(narrow, wide)
+
+    assert merged.parent_component_shapes == ((2, 2), (4, 2))
+    assert merged.destination_component_counts == (2, 4)
+
+    incompatible = replace(wide, exact_expressions=("other::out0", "other::out1"))
+    with pytest.raises(RecurrenceDirectTemplateError, match="exact_expressions"):
+        direct_template._merge_prepared_native_direct_callable_specs(
+            narrow, incompatible
+        )
+
+    out_of_bounds = replace(
+        narrow,
+        input_contracts=(
+            json.dumps(
+                {"component": 2, "role": "left-current"},
+                separators=(",", ":"),
+                sort_keys=True,
+            ),
+        ),
+    )
+    with pytest.raises(RecurrenceDirectTemplateError, match="outside"):
+        direct_template._validate_prepared_native_direct_projection_bounds(
+            out_of_bounds
+        )
diff --git a/pyamplicol/tests/unit/test_recurrence_exact_contracted_color.py b/pyamplicol/tests/unit/test_recurrence_exact_contracted_color.py
new file mode 100644
index 0000000000..a2bae5ad72
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_exact_contracted_color.py
@@ -0,0 +1,1137 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact contracted-color recurrence tests over compact binary rows."""
+
+from __future__ import annotations
+
+import hashlib
+import struct
+from dataclasses import astuple, replace
+from decimal import Decimal, localcontext
+from fractions import Fraction
+from itertools import permutations
+from pathlib import Path
+
+import pytest
+
+from pyamplicol._internal.versions import (
+    RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+    SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+)
+from pyamplicol.api.errors import ArtifactError, CompatibilityError, EvaluationError
+from pyamplicol.artifacts.manifest import ArtifactManifest, PayloadRecord
+from pyamplicol.color import (
+    ColorContractionEntry,
+    ColorContractionPlan,
+    ColorContractionTemplateEntry,
+    SymmetricGroupColorContractionBlock,
+)
+from pyamplicol.generation.recurrence_color import (
+    RecurrenceColorCodecError,
+    encode_recurrence_color_contraction,
+)
+from pyamplicol.generation.recurrence_columnar import ExactComplexRationalV1
+from pyamplicol.runtime.recurrence_exact import _executor as executor_module
+from pyamplicol.runtime.recurrence_exact._color import (
+    RECURRENCE_COLOR_CONTRACTION_CODEC_ABI,
+    RECURRENCE_CONTRACTED_COLOR_CAPABILITY,
+    _contract_color_amplitudes,
+    _decode_recurrence_color_contraction,
+    _load_recurrence_color_contraction,
+)
+from pyamplicol.runtime.recurrence_exact._executor import RecurrenceExactExecutor
+from pyamplicol.runtime.recurrence_exact._plan import (
+    _RecurrenceExactPlan,
+    _validate_execution,
+)
+from pyamplicol.runtime.recurrence_exact._plan_v2 import (
+    RECURRENCE_DIRECT_RUNTIME_CAPABILITY,
+    RECURRENCE_EXACT_SECTIONS_ABI,
+    RECURRENCE_RUNTIME_LAYOUT_V2_ABI,
+    _AmplitudeDestination,
+    _parse_exact_sections,
+    _RecurrenceExactSectionsV1,
+    _ReplayTarget,
+    _ResolvedHelicity,
+    _SourceStateAssignment,
+)
+
+_HEADER = struct.Struct("<8s14I7Q")
+_ENTRY = struct.Struct("<IIdddI")
+_EXACT_FACTOR_BYTES = 64
+_U32 = struct.Struct("<I")
+
+
+def _contracted_execution_with_capabilities(
+    capabilities: tuple[str, ...],
+) -> dict[str, object]:
+    return {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-recurrence-execution",
+        "key": "synthetic_contracted",
+        "recurrence_plan_abi": "pyamplicol-recurrence-plan-v2",
+        "runtime_layout_abi": "pyamplicol-recurrence-runtime-layout-v2",
+        "recurrence_summary": {"lc_flow_layout": "contracted-color-union"},
+        "required_runtime_capabilities": capabilities,
+        "color_accuracy": "full",
+    }
+
+
+def test_exact_execution_permits_helicity_companion_and_exact_fft_fallback() -> None:
+    core = (
+        RECURRENCE_DIRECT_RUNTIME_CAPABILITY,
+        RECURRENCE_CONTRACTED_COLOR_CAPABILITY,
+    )
+    _validate_execution(
+        _contracted_execution_with_capabilities(
+            (*core, RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY)
+        ),
+        "synthetic_contracted",
+    )
+    _validate_execution(
+        _contracted_execution_with_capabilities(
+            (*core, SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY)
+        ),
+        "synthetic_contracted",
+    )
+
+    for capabilities in (
+        (core[0], RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY),
+        (*core, "rusticol.recurrence-unknown.v1"),
+    ):
+        with pytest.raises(
+            CompatibilityError,
+            match="unsupported recurrence runtime capability contract",
+        ):
+            _validate_execution(
+                _contracted_execution_with_capabilities(capabilities),
+                "synthetic_contracted",
+            )
+
+
+def _color_payload(
+    *,
+    storage: str,
+    sector_count: int,
+    component_count: int,
+    entries: tuple[tuple[int, int, float, float, float], ...],
+    destinations: tuple[int, ...] | None = None,
+    ordered_groups: tuple[int, ...] | None = None,
+    group_sector_ids: tuple[int, ...] | None = None,
+    group_component_ids: tuple[int, ...] | None = None,
+    sector_owner_ids: tuple[int, ...] | None = None,
+    color_accuracy: str = "full",
+    includes_color_factor: bool = True,
+) -> bytes:
+    if group_sector_ids is None and group_component_ids is None:
+        group_count = sector_count * component_count
+        sectors = tuple(group_id // component_count for group_id in range(group_count))
+        components = tuple(
+            group_id % component_count for group_id in range(group_count)
+        )
+    elif group_sector_ids is not None and group_component_ids is not None:
+        group_count = len(group_sector_ids)
+        sectors = group_sector_ids
+        components = group_component_ids
+    else:
+        raise AssertionError("test payload needs both group coordinate maps")
+    repeated = storage == "repeated"
+    ordered = ordered_groups or tuple(range(group_count))
+    destination_map = destinations or tuple(range(group_count))
+    destination_count = max(destination_map, default=-1) + 1
+    exact_factors = tuple(
+        (
+            Fraction(str(weight_re)) * Fraction(str(symmetry_factor)),
+            Fraction(str(weight_im)) * Fraction(str(symmetry_factor)),
+        )
+        for _, _, weight_re, weight_im, symmetry_factor in entries
+    )
+    active_sectors = set(sectors)
+    owners = (
+        sector_owner_ids
+        if sector_owner_ids is not None
+        else tuple(
+            sector_id if sector_id in active_sectors else 0xFFFF_FFFF
+            for sector_id in range(sector_count)
+        )
+    )
+    payload_size = (
+        len(entries) * _ENTRY.size
+        + len(exact_factors) * _EXACT_FACTOR_BYTES
+        + len(ordered) * _U32.size
+        + len(destination_map) * _U32.size
+        + len(sectors) * _U32.size
+        + len(components) * _U32.size
+        + len(owners) * _U32.size
+    )
+    header = _HEADER.pack(
+        b"PACRCLR3",
+        3,
+        _HEADER.size,
+        2 if repeated else 1,
+        2 if color_accuracy == "full" else 1,
+        1 if includes_color_factor else 0,
+        group_count,
+        sector_count,
+        component_count,
+        group_count // component_count if repeated else 0,
+        destination_count,
+        0,
+        0,
+        _ENTRY.size,
+        _EXACT_FACTOR_BYTES,
+        len(entries),
+        len(exact_factors),
+        0,
+        0,
+        len(entries) * component_count if repeated else len(entries),
+        len(owners),
+        payload_size,
+    )
+    encoded_factors = tuple(
+        value.to_bytes(16, "little", signed=True)
+        for real, imag in exact_factors
+        for value in (
+            real.numerator,
+            real.denominator,
+            imag.numerator,
+            imag.denominator,
+        )
+    )
+    return b"".join(
+        (
+            header,
+            *(_ENTRY.pack(*entry, index) for index, entry in enumerate(entries)),
+            *encoded_factors,
+            *(_U32.pack(value) for value in ordered),
+            *(_U32.pack(value) for value in destination_map),
+            *(_U32.pack(value) for value in sectors),
+            *(_U32.pack(value) for value in components),
+            *(_U32.pack(value) for value in owners),
+        )
+    )
+
+
+def test_compact_repeated_rows_expand_without_decimal_strings() -> None:
+    payload = _color_payload(
+        storage="repeated",
+        sector_count=2,
+        component_count=2,
+        entries=((0, 1, 0.1, 0.0, 2.0),),
+        ordered_groups=(2, 0, 3, 1),
+        destinations=(0, 1, 2, 3),
+        group_sector_ids=(0, 1, 0, 1),
+        group_component_ids=(1, 1, 0, 0),
+    )
+    contraction = _decode_recurrence_color_contraction(payload)
+
+    rows = tuple(contraction.runtime_entries())
+    assert tuple(
+        (row.left_destination_id, row.right_destination_id) for row in rows
+    ) == ((2, 3), (0, 1))
+    assert rows[0].coefficient_re == Decimal("0.2")
+    assert rows[0].coefficient_im == Decimal(0)
+    assert tuple(row.component_id for row in rows) == (0, 1)
+
+
+def test_compact_repeated_rows_support_a_rectangular_active_sector_subset() -> None:
+    payload = _color_payload(
+        storage="repeated",
+        sector_count=4,
+        component_count=2,
+        entries=((0, 1, 0.25, 0.0, 2.0),),
+        ordered_groups=(0, 2, 1, 3),
+        group_sector_ids=(1, 3, 1, 3),
+        group_component_ids=(0, 0, 1, 1),
+    )
+    contraction = _decode_recurrence_color_contraction(payload)
+
+    assert contraction.sector_count == 4
+    assert tuple(
+        (row.left_destination_id, row.right_destination_id)
+        for row in contraction.runtime_entries()
+    ) == ((0, 1), (2, 3))
+
+
+def test_compact_expanded_color_rows_reject_cross_helicity_contraction() -> None:
+    payload = _color_payload(
+        storage="expanded",
+        sector_count=2,
+        component_count=2,
+        entries=((0, 1, 1.0, 0.0, 1.0),),
+        group_sector_ids=(0, 1),
+        group_component_ids=(0, 1),
+    )
+    with pytest.raises(ArtifactError, match="mixes helicity components"):
+        _decode_recurrence_color_contraction(payload)
+
+
+def test_compact_expanded_color_rows_support_sparse_sector_component_cells() -> None:
+    payload = _color_payload(
+        storage="expanded",
+        sector_count=3,
+        component_count=2,
+        entries=((0, 1, 0.5, 0.0, 2.0),),
+        destinations=(2, 0, 1),
+        group_sector_ids=(0, 2, 1),
+        group_component_ids=(1, 1, 0),
+    )
+    contraction = _decode_recurrence_color_contraction(payload)
+
+    assert contraction.group_count == 3
+    assert contraction.sector_count == 3
+    assert contraction.component_count == 2
+    assert contraction.group_sector_ids == (0, 2, 1)
+    assert contraction.group_component_ids == (1, 1, 0)
+    row = next(contraction.runtime_entries())
+    assert row.component_id == 1
+    assert (row.left_destination_id, row.right_destination_id) == (2, 0)
+
+
+@pytest.mark.parametrize(
+    ("sectors", "components", "message"),
+    (
+        ((0, 2), (0, 0), "out of bounds"),
+        ((0, 1), (0, 2), "out of bounds"),
+        ((0, 0), (1, 1), "not unique"),
+    ),
+)
+def test_compact_color_rows_reject_malformed_group_coordinate_maps(
+    sectors: tuple[int, ...],
+    components: tuple[int, ...],
+    message: str,
+) -> None:
+    payload = _color_payload(
+        storage="expanded",
+        sector_count=2,
+        component_count=2,
+        entries=(),
+        group_sector_ids=sectors,
+        group_component_ids=components,
+    )
+    with pytest.raises(ArtifactError, match=message):
+        _decode_recurrence_color_contraction(payload)
+
+
+def test_compact_color_rows_authenticate_sector_aliases_and_structural_zeros() -> None:
+    valid = _color_payload(
+        storage="expanded",
+        sector_count=4,
+        component_count=1,
+        entries=((0, 1, 0.5, 0.0, 2.0),),
+        group_sector_ids=(0, 2),
+        group_component_ids=(0, 0),
+        sector_owner_ids=(0, 0, 2, 0xFFFF_FFFF),
+    )
+    contraction = _decode_recurrence_color_contraction(valid)
+    assert contraction.owner_by_sector == (0, 0, 2, 0xFFFF_FFFF)
+
+    invalid = bytearray(valid)
+    owner_offset = _HEADER.size + _ENTRY.size + _EXACT_FACTOR_BYTES + 4 * 2 * _U32.size
+    _U32.pack_into(invalid, owner_offset + _U32.size, 2)
+    with pytest.raises(ArtifactError, match="invalid owner"):
+        _decode_recurrence_color_contraction(bytes(invalid))
+
+
+def test_compact_color_rows_reject_exact_and_binary64_coefficient_drift() -> None:
+    payload = bytearray(
+        _color_payload(
+            storage="expanded",
+            sector_count=1,
+            component_count=1,
+            entries=((0, 0, 0.5, 0.0, 2.0),),
+        )
+    )
+    exact_factor_offset = _HEADER.size + _ENTRY.size
+    payload[exact_factor_offset : exact_factor_offset + 16] = (2).to_bytes(
+        16,
+        "little",
+        signed=True,
+    )
+    with pytest.raises(ArtifactError, match="disagrees with its exact factor"):
+        _decode_recurrence_color_contraction(bytes(payload))
+
+
+def test_compact_repeated_rows_reject_mixed_local_color_rows() -> None:
+    payload = _color_payload(
+        storage="repeated",
+        sector_count=2,
+        component_count=2,
+        entries=((0, 1, 1.0, 0.0, 1.0),),
+        ordered_groups=(0, 2, 1, 3),
+    )
+    with pytest.raises(ArtifactError, match="every component exactly once"):
+        _decode_recurrence_color_contraction(payload)
+
+
+def test_compact_color_decoder_rejects_v1_without_compatibility() -> None:
+    payload = bytearray(
+        _color_payload(
+            storage="expanded",
+            sector_count=1,
+            component_count=1,
+            entries=((0, 0, 1.0, 0.0, 1.0),),
+        )
+    )
+    payload[:8] = b"PACRCLR1"
+    struct.pack_into("<I", payload, 8, 1)
+    with pytest.raises(ArtifactError, match="unsupported"):
+        _decode_recurrence_color_contraction(bytes(payload))
+
+
+def test_color_encoder_accepts_sparse_expanded_coordinates() -> None:
+    plan = ColorContractionPlan(
+        color_accuracy="full",
+        supported=True,
+        reason=None,
+        group_count=3,
+        entries=(ColorContractionEntry(0, 1, 0.5, symmetry_factor=2.0),),
+    )
+    payload = encode_recurrence_color_contraction(
+        plan,
+        sector_count=3,
+        component_count=2,
+        ordered_group_ids=(2, 0, 1),
+        destination_by_group=(2, 0, 1),
+        group_sector_ids=(0, 2, 1),
+        group_component_ids=(1, 1, 0),
+        sector_owner_ids=(0, 1, 2),
+        exact_coefficients=(ExactComplexRationalV1(1),),
+        destination_count=3,
+    )
+    contraction = _decode_recurrence_color_contraction(payload)
+    assert contraction.group_count == 3
+    assert contraction.group_sector_ids == (0, 2, 1)
+
+
+def test_color_encoder_emits_canonical_symmetric_group_kernel_rows() -> None:
+    block = SymmetricGroupColorContractionBlock(
+        degree=2,
+        component_count=1,
+        component_group_ids=(0, 1, 2),
+        local_sector_ids=(0, 1, 2),
+        channel_cosets=((0, 1),),
+        kernel_entries=(
+            ColorContractionTemplateEntry(0, 0, 3.0),
+            ColorContractionTemplateEntry(0, 1, 1.0),
+        ),
+        kernel_exact_weights=(Fraction(3), Fraction(1)),
+        residual_entries=(
+            ColorContractionTemplateEntry(0, 2, 0.25, symmetry_factor=2.0),
+            ColorContractionTemplateEntry(1, 2, 0.0, symmetry_factor=2.0),
+            ColorContractionTemplateEntry(2, 2, 5.0),
+        ),
+        residual_exact_weights=(Fraction(1, 4), Fraction(0), Fraction(5)),
+        residual_local_group_indices=(2,),
+    )
+    plan = ColorContractionPlan(
+        color_accuracy="full",
+        supported=True,
+        reason=None,
+        group_count=3,
+        entries=(),
+        symmetric_group_block=block,
+        destination_by_group=(2, 0, 1),
+    )
+    exact_values = (
+        Fraction(3),
+        Fraction(1),
+        Fraction(1, 2),
+        Fraction(0),
+        Fraction(5),
+    )
+    exact = tuple(
+        ExactComplexRationalV1(value.numerator, value.denominator)
+        for value in exact_values
+    )
+    payload = encode_recurrence_color_contraction(
+        plan,
+        sector_count=3,
+        component_count=1,
+        ordered_group_ids=(0, 1, 2),
+        destination_by_group=(2, 0, 1),
+        group_sector_ids=(0, 1, 2),
+        group_component_ids=(0, 0, 0),
+        sector_owner_ids=(0, 1, 2),
+        exact_coefficients=exact,
+        destination_count=3,
+    )
+
+    header = _HEADER.unpack_from(payload)
+    assert header[0] == b"PACRCLR3"
+    assert header[1:4] == (3, _HEADER.size, 3)
+    assert header[11:13] == (3, 2)
+    assert header[15:20] == (5, 5, 1, 2, 5)
+    rows = tuple(
+        _ENTRY.unpack_from(payload, _HEADER.size + index * _ENTRY.size)[:5]
+        for index in range(5)
+    )
+    assert rows == (
+        (0, 0, 3.0, 0.0, 1.0),
+        (0, 1, 1.0, 0.0, 1.0),
+        (0, 2, 0.25, 0.0, 2.0),
+        (1, 2, 0.0, 0.0, 2.0),
+        (2, 2, 5.0, 0.0, 1.0),
+    )
+    assert struct.unpack_from("<2I", payload, len(payload) - 2 * _U32.size) == (
+        0,
+        1,
+    )
+
+    contraction = _decode_recurrence_color_contraction(payload)
+    assert contraction.storage == "convolution-kernels"
+    assert contraction.factorization_kind == "symmetric-group-fourier"
+    assert len(tuple(contraction.runtime_entries())) == 7
+    assert _contract_color_amplitudes(
+        contraction,
+        (
+            (Decimal(1), Decimal(2)),
+            (Decimal(3), Decimal(-1)),
+            (Decimal(-2), Decimal(1)),
+        ),
+        (0, 0, 0),
+    ) == {0: Decimal("76.5")}
+
+    with pytest.raises(RecurrenceColorCodecError, match="certified convolution plan"):
+        encode_recurrence_color_contraction(
+            plan,
+            sector_count=3,
+            component_count=1,
+            ordered_group_ids=(0, 1, 2),
+            destination_by_group=(2, 0, 1),
+            group_sector_ids=(0, 1, 2),
+            group_component_ids=(0, 0, 0),
+            sector_owner_ids=(0, 1, 2),
+            exact_coefficients=(*exact[:-1], ExactComplexRationalV1(6)),
+            destination_count=3,
+        )
+
+    object.__setattr__(
+        block,
+        "residual_entries",
+        (
+            block.residual_entries[1],
+            block.residual_entries[0],
+            block.residual_entries[2],
+        ),
+    )
+    object.__setattr__(
+        block,
+        "residual_exact_weights",
+        (
+            block.residual_exact_weights[1],
+            block.residual_exact_weights[0],
+            block.residual_exact_weights[2],
+        ),
+    )
+
+    with pytest.raises(RecurrenceColorCodecError, match="do not exhaust"):
+        encode_recurrence_color_contraction(
+            plan,
+            sector_count=3,
+            component_count=1,
+            ordered_group_ids=(0, 1, 2),
+            destination_by_group=(2, 0, 1),
+            group_sector_ids=(0, 1, 2),
+            group_component_ids=(0, 0, 0),
+            sector_owner_ids=(0, 1, 2),
+            exact_coefficients=(*exact[:2], exact[3], exact[2], exact[4]),
+            destination_count=3,
+        )
+
+
+def test_exact_fft_fallback_preserves_cross_channels_residuals_and_helicity_maps() -> (
+    None
+):
+    group = tuple(permutations(range(3)))
+    order = len(group)
+    local_count, component_count = 13, 2
+    ordered = tuple(reversed(range(local_count * component_count)))
+    destinations = tuple((index * 7) % len(ordered) for index in range(len(ordered)))
+    sectors, components = [0] * len(ordered), [0] * len(ordered)
+    for local in range(local_count):
+        for component in range(component_count):
+            group_id = ordered[local * component_count + component]
+            sectors[group_id], components[group_id] = local, component
+    # The diagonal kernels obey inversion symmetry, but the cross kernel
+    # deliberately does not: reversing L^{-1}R would change the answer.
+    kernels = (
+        tuple(Fraction(value, 7) for value in (10, 2, 3, 5, 5, 4)),
+        tuple(Fraction(value, 11) for value in (1, 2, 3, 4, 6, 7)),
+        tuple(Fraction(value, 13) for value in (8, 1, 2, 3, 3, 4)),
+    )
+    channel_pairs = ((0, 0), (0, 1), (1, 1))
+    kernel_entries = tuple(
+        ColorContractionTemplateEntry(
+            left * order,
+            right * order + relative,
+            float(value),
+            symmetry_factor=1.0 if left == right else 2.0,
+        )
+        for (left, right), kernel in zip(channel_pairs, kernels, strict=True)
+        for relative, value in enumerate(kernel)
+    )
+    residual = tuple(Fraction(index + 2, 17) for index in range(local_count))
+    residual_entries = tuple(
+        ColorContractionTemplateEntry(
+            index,
+            12,
+            float(value),
+            symmetry_factor=1.0 if index == 12 else 2.0,
+        )
+        for index, value in enumerate(residual)
+    )
+    weights = tuple(value for kernel in kernels for value in kernel) + residual
+    entries = kernel_entries + residual_entries
+    exact = tuple(
+        ExactComplexRationalV1(value.numerator, value.denominator)
+        for entry, weight in zip(entries, weights, strict=True)
+        for value in (weight * int(entry.symmetry_factor),)
+    )
+    block = SymmetricGroupColorContractionBlock(
+        degree=3,
+        component_count=component_count,
+        component_group_ids=ordered,
+        local_sector_ids=tuple(range(local_count)),
+        channel_cosets=(tuple(range(6)), tuple(range(6, 12))),
+        kernel_entries=kernel_entries,
+        kernel_exact_weights=weights[:18],
+        residual_entries=residual_entries,
+        residual_exact_weights=residual,
+        residual_local_group_indices=(12,),
+        hermiticity_check_mode="full",
+        hermiticity_relative_indices=tuple(range(6)),
+    )
+    payload = encode_recurrence_color_contraction(
+        ColorContractionPlan(
+            color_accuracy="full",
+            supported=True,
+            reason=None,
+            group_count=len(ordered),
+            entries=(),
+            symmetric_group_block=block,
+            destination_by_group=destinations,
+        ),
+        sector_count=local_count,
+        component_count=component_count,
+        ordered_group_ids=ordered,
+        destination_by_group=destinations,
+        group_sector_ids=tuple(sectors),
+        group_component_ids=tuple(components),
+        sector_owner_ids=tuple(range(local_count)),
+        exact_coefficients=exact,
+        destination_count=len(ordered),
+    )
+    contraction = _decode_recurrence_color_contraction(payload)
+    amplitudes = [(Decimal(0), Decimal(0))] * len(ordered)
+    helicities = [0] * len(ordered)
+    expected = {}
+    for component in range(component_count):
+        local_values = tuple(
+            ((-1) ** local * (local + 1), (2 * local + 1) * (component + 1))
+            for local in range(local_count)
+        )
+        for local, value in enumerate(local_values):
+            destination = destinations[ordered[local * component_count + component]]
+            amplitudes[destination] = tuple(Decimal(part) for part in value)
+            helicities[destination] = 10 + component
+
+        def real_product(left, right, values=local_values):
+            a, b = values[left], values[right]
+            return a[0] * b[0] + a[1] * b[1]
+
+        result = Fraction(0)
+        for (left_channel, right_channel), kernel in zip(
+            channel_pairs, kernels, strict=True
+        ):
+            for left_index, left in enumerate(group):
+                for right_index, right in enumerate(group):
+                    relative = group.index(tuple(left.index(value) for value in right))
+                    result += (
+                        kernel[relative]
+                        * (1 if left_channel == right_channel else 2)
+                        * real_product(
+                            left_channel * 6 + left_index,
+                            right_channel * 6 + right_index,
+                        )
+                    )
+        result += sum(
+            weight * (1 if local == 12 else 2) * real_product(local, 12)
+            for local, weight in enumerate(residual)
+        )
+        expected[10 + component] = result
+    with localcontext() as context:
+        context.prec = 70
+        actual = _contract_color_amplitudes(contraction, amplitudes, helicities)
+        for helicity, value in expected.items():
+            reference = Decimal(value.numerator) / Decimal(value.denominator)
+            assert abs(actual[helicity] - reference) < Decimal("1e-60")
+        assert _contract_color_amplitudes(
+            contraction, amplitudes, helicities, {11}
+        ) == {11: actual[11]}
+
+
+def test_color_encoder_rejects_duplicate_group_coordinates() -> None:
+    plan = ColorContractionPlan(
+        color_accuracy="nlc",
+        supported=True,
+        reason=None,
+        group_count=2,
+        entries=(),
+    )
+    with pytest.raises(RecurrenceColorCodecError, match="duplicate"):
+        encode_recurrence_color_contraction(
+            plan,
+            sector_count=2,
+            component_count=2,
+            ordered_group_ids=(0, 1),
+            destination_by_group=(0, 1),
+            group_sector_ids=(0, 0),
+            group_component_ids=(1, 1),
+            sector_owner_ids=(0, 1),
+            exact_coefficients=(),
+            destination_count=2,
+        )
+
+
+def test_compact_color_payload_is_authenticated_against_manifest_and_summary(
+    tmp_path: Path,
+) -> None:
+    payload = _color_payload(
+        storage="repeated",
+        sector_count=2,
+        component_count=2,
+        entries=(
+            (0, 0, 1.0, 0.0, 1.0),
+            (0, 1, 0.5, 0.0, 2.0),
+            (1, 1, 1.0, 0.0, 1.0),
+        ),
+    )
+    digest = hashlib.sha256(payload).hexdigest()
+    relative = "processes/process/recurrence-color.bin"
+    path = tmp_path / relative
+    path.parent.mkdir(parents=True)
+    path.write_bytes(payload)
+    manifest = ArtifactManifest(
+        root=tmp_path,
+        kind="pyamplicol-process",
+        artifact_id="artifact",
+        created_utc="2026-01-01T00:00:00Z",
+        producer={},
+        model={},
+        configuration={},
+        processes=(),
+        default_process_id=None,
+        runtime={},
+        payloads=(
+            PayloadRecord(
+                path=relative,
+                role="evaluator-state",
+                media_type="application/octet-stream",
+                size_bytes=len(payload),
+                sha256=digest,
+                executable=False,
+                process_id="process",
+            ),
+        ),
+        dependencies=(),
+        extensions={},
+    )
+    reference = {
+        "abi": RECURRENCE_COLOR_CONTRACTION_CODEC_ABI,
+        "path": "recurrence-color.bin",
+        "size_bytes": len(payload),
+        "sha256": digest,
+        "color_accuracy": "full",
+        "storage": "repeated",
+        "includes_color_factor": True,
+        "group_count": 4,
+        "sector_count": 2,
+        "active_sector_count": 2,
+        "component_count": 2,
+        "destination_count": 4,
+        "entry_count": 3,
+        "logical_entry_count": 6,
+        "semantic_digest": digest,
+    }
+    loaded = _load_recurrence_color_contraction(
+        artifact_root=tmp_path,
+        process_id="process",
+        execution_path="processes/process/execution.json",
+        execution={"runtime_metadata": {"color_contraction": reference}},
+        manifest=manifest,
+    )
+    assert loaded is not None
+    assert loaded.logical_entry_count == 6
+
+    corrupted = {**reference, "logical_entry_count": 7}
+    with pytest.raises(ArtifactError, match="bounded summary"):
+        _load_recurrence_color_contraction(
+            artifact_root=tmp_path,
+            process_id="process",
+            execution_path="processes/process/execution.json",
+            execution={"runtime_metadata": {"color_contraction": corrupted}},
+            manifest=manifest,
+        )
+
+
+def test_exact_color_contraction_uses_complex_hermitian_product() -> None:
+    contraction = _decode_recurrence_color_contraction(
+        _color_payload(
+            storage="expanded",
+            sector_count=2,
+            component_count=1,
+            entries=((0, 1, 2.0, 0.5, 2.0),),
+        )
+    )
+    amplitudes = (
+        (Decimal(1), Decimal(2)),
+        (Decimal(3), Decimal(4)),
+    )
+    result = _contract_color_amplitudes(contraction, amplitudes, (0, 0))
+    # A0 conj(A1) = 11 + 2i and c = 4 + i after symmetry folding.
+    assert result == {0: Decimal(42)}
+    assert _contract_color_amplitudes(contraction, amplitudes, (0, 0), {1}) == {}
+
+
+def _contracted_plan() -> _RecurrenceExactPlan:
+    resolved = (
+        _ResolvedHelicity(0, 0, 0, 0, 2, 0, 2, 0),
+        _ResolvedHelicity(2, 0, 2, 1, 2, 0, 2, 0),
+    )
+    destinations = tuple(
+        _AmplitudeDestination(
+            destination_id,
+            destination_id,
+            destination_id // 2,
+            destination_id % 2,
+            1,
+            0,
+        )
+        for destination_id in range(4)
+    )
+    sections = _RecurrenceExactSectionsV1(
+        process_id="contracted",
+        strategy="contracted-color-union",
+        semantic_digest="0" * 64,
+        runtime_layout_digest="1" * 64,
+        current_arena_components=1,
+        amplitude_destination_count=4,
+        parameter_value_count=0,
+        external_source_count=2,
+        currents=(),
+        sources=(),
+        contributions=(),
+        finalizations=(),
+        closures=(),
+        row_groups=(),
+        momentum_forms=(),
+        momentum_terms=(),
+        replay_targets=(),
+        source_permutations=(),
+        replay_momentum_signs=(),
+        replay_helicity_map=(),
+        amplitude_destinations=destinations,
+        resolved_helicities=resolved,
+        source_state_assignments=(
+            _SourceStateAssignment(0, 0),
+            _SourceStateAssignment(1, 0),
+            _SourceStateAssignment(0, 1),
+            _SourceStateAssignment(1, 1),
+        ),
+        source_dispatch_variants=(),
+        source_embeddings=(),
+        source_projections=(),
+        resolved_source_selections=(),
+        public_helicities=(0, 0, 1, 1),
+        exact_factors=(),
+        public_flow_ids=(),
+        executors=(),
+    )
+    contraction = _decode_recurrence_color_contraction(
+        _color_payload(
+            storage="repeated",
+            sector_count=2,
+            component_count=2,
+            entries=(
+                (0, 0, 1.0, 0.0, 1.0),
+                (0, 1, 0.5, 0.0, 2.0),
+                (1, 1, 1.0, 0.0, 1.0),
+            ),
+        )
+    )
+    return _RecurrenceExactPlan(
+        sections=sections,
+        kernels={},
+        executors={},
+        executor_exact_kernel_ids={},
+        executor_parent_permutations={},
+        source_templates={},
+        initial_source_slots=frozenset(),
+        executor_couplings={},
+        prepared_defaults=(),
+        parameter_projection=(),
+        parameter_derivation=None,
+        color_contraction=contraction,
+    )
+
+
+def _contracted_replay_plan() -> _RecurrenceExactPlan:
+    plan = _contracted_plan()
+    sections = replace(
+        plan.sections,
+        amplitude_destination_count=2,
+        replay_targets=(
+            _ReplayTarget(0, 0, 0, 2, 0, 2, 0, 1, 0),
+            _ReplayTarget(1, 0, 2, 2, 2, 2, 0, 1, 0),
+        ),
+        source_permutations=(0, 1, 1, 0),
+        replay_momentum_signs=(1, 1, 1, 1),
+        replay_helicity_map=(0, 1, 1, 0),
+        amplitude_destinations=plan.sections.amplitude_destinations[:2],
+    )
+    return replace(plan, sections=sections)
+
+
+def _native_sections(sections: _RecurrenceExactSectionsV1) -> dict[str, object]:
+    return {
+        "abi": RECURRENCE_EXACT_SECTIONS_ABI,
+        "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_V2_ABI,
+        "process_id": sections.process_id,
+        "strategy": sections.strategy,
+        "semantic_digest": sections.semantic_digest,
+        "runtime_layout_digest": sections.runtime_layout_digest,
+        "counts": (
+            sections.current_arena_components,
+            sections.amplitude_destination_count,
+            sections.parameter_value_count,
+            sections.external_source_count,
+        ),
+        "currents": [],
+        "sources": [],
+        "contributions": [],
+        "finalizations": [],
+        "closures": [],
+        "row_groups": [],
+        "momentum_forms": [],
+        "momentum_terms": [],
+        "replay_targets": [astuple(row) for row in sections.replay_targets],
+        "source_permutations": list(sections.source_permutations),
+        "replay_momentum_signs": list(sections.replay_momentum_signs),
+        "replay_helicity_map": list(sections.replay_helicity_map),
+        "amplitude_destinations": [
+            astuple(row) for row in sections.amplitude_destinations
+        ],
+        "resolved_helicities": [astuple(row) for row in sections.resolved_helicities],
+        "source_state_assignments": [
+            astuple(row) for row in sections.source_state_assignments
+        ],
+        "source_dispatch_variants": [],
+        "source_embeddings": [],
+        "source_projections": [],
+        "resolved_source_selections": [],
+        "public_helicities": list(sections.public_helicities),
+        "exact_factors": [],
+        "public_flow_ids": list(sections.public_flow_ids),
+        "executors": [],
+    }
+
+
+def test_contracted_native_section_adapter_accepts_fixed_source_grid() -> None:
+    sections = _contracted_plan().sections
+    raw = _native_sections(sections)
+    parsed = _parse_exact_sections(raw, sections.process_id)
+    assert parsed.strategy == "contracted-color-union"
+    assert parsed.amplitude_destinations == sections.amplitude_destinations
+
+    raw["public_flow_ids"] = [0]
+    with pytest.raises(ArtifactError, match="public color-flow axis"):
+        _parse_exact_sections(raw, sections.process_id)
+
+
+def test_contracted_native_section_adapter_accepts_internal_replay() -> None:
+    sections = _contracted_replay_plan().sections
+    parsed = _parse_exact_sections(_native_sections(sections), sections.process_id)
+
+    assert parsed.public_flow_ids == ()
+    assert parsed.replay_targets == sections.replay_targets
+    assert parsed.replay_helicity_map == (0, 1, 1, 0)
+
+    malformed = _native_sections(sections)
+    malformed["source_permutations"] = [0, 0, 1, 0]
+    with pytest.raises(ArtifactError, match="complete source bijection"):
+        _parse_exact_sections(malformed, sections.process_id)
+
+    malformed = _native_sections(sections)
+    malformed["replay_helicity_map"] = [0, 0, 1, 0]
+    with pytest.raises(ArtifactError, match="complete bijection"):
+        _parse_exact_sections(malformed, sections.process_id)
+
+
+def test_contracted_exact_replay_reconstructs_dense_physical_destinations(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    executor = object.__new__(RecurrenceExactExecutor)
+    executor._plan = _contracted_replay_plan()
+    executor._permutation = (0, 1)
+    executor._physics = {
+        "helicities": [
+            {"id": "h:0,0", "values": [0, 0]},
+            {"id": "h:1,1", "values": [1, 1]},
+        ]
+    }
+    replayed = {
+        0: ((Decimal(1), Decimal(0)), (Decimal(2), Decimal(0))),
+        1: ((Decimal(3), Decimal(0)), (Decimal(4), Decimal(0))),
+    }
+    monkeypatch.setattr(
+        executor_module,
+        "_evaluate_replay_point",
+        lambda _plan, _point, target, *_args: replayed[target.public_flow_id],
+    )
+
+    amplitudes = executor._contracted_amplitudes(object(), (), 70)
+    destination_helicities = executor._contracted_destination_helicity_map()
+
+    assert amplitudes == (
+        (Decimal(1), Decimal(0)),
+        (Decimal(2), Decimal(0)),
+        (Decimal(4), Decimal(0)),
+        (Decimal(3), Decimal(0)),
+    )
+    assert destination_helicities == (0, 1, 0, 1)
+    assert _contract_color_amplitudes(
+        executor._plan.color_contraction,
+        amplitudes,
+        destination_helicities,
+    ) == {0: Decimal(21), 1: Decimal(19)}
+
+
+def test_contracted_exact_resolved_output_and_selector_contract(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    executor = object.__new__(RecurrenceExactExecutor)
+    executor._plan = _contracted_plan()
+    executor._physics = {
+        "extensions": {"normalization": {"average_factor": 2}},
+        "external_particles": [{}, {}],
+        "helicities": [
+            {
+                "id": "h:0,0",
+                "values": [0, 0],
+                "computed": True,
+                "structural_zero": False,
+                "coefficient": 1,
+            },
+            {
+                "id": "h:1,1",
+                "values": [1, 1],
+                "computed": True,
+                "structural_zero": False,
+                "coefficient": 2,
+            },
+        ],
+        "color_components": [
+            {
+                "kind": "contracted-color",
+                "id": "color:contracted",
+                "index": 0,
+                "description": "contracted",
+            }
+        ],
+        "color_accuracy": "full",
+    }
+    executor._permutation = (0, 1)
+    executor._native_runtime = object()
+    (
+        executor._helicity_representative,
+        executor._helicity_orbit_members,
+    ) = executor._helicity_reduction_indices()
+    executor._replay_by_color = ()
+    executor._destination_helicities = ()
+    executor._union_destination_by_color = ()
+    executor._union_helicity_by_physics = ()
+    executor._contracted_destination_helicity = (
+        executor._contracted_destination_helicity_map()
+    )
+    monkeypatch.setattr(
+        executor_module,
+        "_prepare_points",
+        lambda *_: (((Decimal(1),) * 4, (Decimal(2),) * 4),),
+    )
+    monkeypatch.setattr(
+        executor_module,
+        "_runtime_state",
+        lambda _: {"model_parameter_values": [], "normalization_factor": "0.5"},
+    )
+    monkeypatch.setattr(
+        executor_module,
+        "_evaluate_contracted_point",
+        lambda *_: (
+            (Decimal(1), Decimal(0)),
+            (Decimal(2), Decimal(0)),
+            (Decimal(3), Decimal(0)),
+            (Decimal(4), Decimal(0)),
+        ),
+    )
+
+    resolved = executor.evaluate_resolved(
+        (((1, 0, 0, 1), (1, 0, 0, -1)),),
+        helicities=None,
+        color_flows=None,
+        precision=70,
+    )
+    assert resolved.values == (
+        (
+            (Decimal("6.5"),),
+            (Decimal(28),),
+        ),
+    )
+    assert resolved.total() == (Decimal("34.5"),)
+    assert resolved.color_ids == ("color:contracted",)
+
+    selected = executor.evaluate_resolved(
+        (((1, 0, 0, 1), (1, 0, 0, -1)),),
+        helicities=("h:1,1",),
+        color_flows=None,
+        precision=70,
+    )
+    assert selected.values == (((Decimal(28),),),)
+
+    with pytest.raises(EvaluationError, match="does not expose a color-flow selector"):
+        executor.evaluate_resolved(
+            (((1, 0, 0, 1), (1, 0, 0, -1)),),
+            helicities=None,
+            color_flows=("color:contracted",),
+            precision=70,
+        )
+
+
+def test_exact_helicity_reduction_indexes_physical_alias_orbits() -> None:
+    executor = object.__new__(RecurrenceExactExecutor)
+    executor._physics = {
+        "helicities": [
+            {
+                "id": "h:-1,+1",
+                "computed": True,
+                "structural_zero": False,
+                "representative_id": "h:-1,+1",
+            },
+            {
+                "id": "h:+1,-1",
+                "computed": False,
+                "structural_zero": False,
+                "representative_id": "h:-1,+1",
+            },
+            {
+                "id": "h:+1,+1",
+                "computed": False,
+                "structural_zero": True,
+                "representative_id": "h:+1,+1",
+            },
+        ]
+    }
+
+    representatives, members = executor._helicity_reduction_indices()
+
+    assert representatives == (0, 0, 2)
+    assert members == ((0, 1), (), ())
diff --git a/pyamplicol/tests/unit/test_recurrence_exact_union.py b/pyamplicol/tests/unit/test_recurrence_exact_union.py
new file mode 100644
index 0000000000..26dbcead3c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_exact_union.py
@@ -0,0 +1,834 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact all-flow-union execution over synthetic Direct-Arena v2 tables."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import astuple, replace
+from decimal import Decimal, localcontext
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.api.errors import ArtifactError, EvaluationError
+from pyamplicol.runtime.recurrence_exact import _executor as executor_module
+from pyamplicol.runtime.recurrence_exact._execution import (
+    _clear_stage,
+    _evaluate_union_point,
+    _execute_certified_reuse_row,
+    _execute_union_source,
+    _kernel_inputs,
+    _trusted_executor_recipe,
+    _trusted_kernel_inputs,
+)
+from pyamplicol.runtime.recurrence_exact._execution import (
+    _factor as _resolved_factor,
+)
+from pyamplicol.runtime.recurrence_exact._executor import RecurrenceExactExecutor
+from pyamplicol.runtime.recurrence_exact._plan import (
+    _RecurrenceExactPlan,
+    _SourceTemplate,
+)
+from pyamplicol.runtime.recurrence_exact._plan_v2 import (
+    DIRECT_NONE_U32,
+    RECURRENCE_EXACT_SECTIONS_ABI,
+    RECURRENCE_RUNTIME_LAYOUT_V2_ABI,
+    _AmplitudeDestination,
+    _Closure,
+    _Contribution,
+    _Current,
+    _ExactFactor,
+    _Executor,
+    _MomentumForm,
+    _MomentumTerm,
+    _parse_exact_sections,
+    _RecurrenceExactSectionsV1,
+    _ResolvedHelicity,
+    _ResolvedSourceSelection,
+    _RowGroup,
+    _Source,
+    _SourceDispatchVariant,
+    _SourceEmbedding,
+    _SourceProjection,
+    _SourceStateAssignment,
+)
+from pyamplicol.runtime.symbolica_exact import _quark_weyl
+
+_ZERO = Decimal(0)
+_ONE = Decimal(1)
+
+
+def _factor(real: int, imaginary: int = 0) -> _ExactFactor:
+    return _ExactFactor(real, 1, imaginary, 1)
+
+
+def test_recurrence_diagnostic_projection_uses_external_source_layout() -> None:
+    massive = _SourceTemplate(
+        0,
+        4,
+        1,
+        0,
+        1,
+        "fermion",
+        "particle",
+        0,
+        1,
+        1,
+        1,
+        mass_parameter_name="ufo.MT",
+    )
+    massless = _SourceTemplate(
+        1,
+        4,
+        1,
+        0,
+        1,
+        "vector",
+        "self-conjugate",
+        None,
+        1,
+        1,
+        1,
+    )
+
+    class Plan:
+        def __init__(self) -> None:
+            self.sections = SimpleNamespace(
+                external_source_count=2,
+                sources=(
+                    _Source(0, 0, 0, 0, 0, 0, 0),
+                    _Source(1, 0, 1, 1, 0, 0, 0),
+                ),
+                source_dispatch_variants=(),
+            )
+            self.source_templates = {0: massive, 1: massless}
+            # Physics/artifact order is (source slot 1, source slot 0).
+            self.external_source_slots = (1, 0)
+
+        @staticmethod
+        def resolve_model_parameters(
+            _runtime_parameters: object, _precision: int
+        ) -> SimpleNamespace:
+            return SimpleNamespace(prepared=((Decimal("7"), Decimal(0)),))
+
+    class Native:
+        @staticmethod
+        def _exact_runtime_state_json() -> str:
+            return json.dumps(
+                {
+                    "model_parameter_values": [7.0],
+                    "normalization_factor": 1.0,
+                }
+            )
+
+    executor = object.__new__(RecurrenceExactExecutor)
+    executor._plan = Plan()
+    executor._native_runtime = Native()
+    executor._physics = {
+        "external_particles": [
+            {"label": 1, "pdg": 21, "role": "initial"},
+            {"label": 2, "pdg": 6, "role": "final"},
+        ]
+    }
+    executor._representative_physics = executor._physics
+    executor._permutation = (0, 1)
+
+    projected, metadata = executor._diagnostic_project_onshell(
+        (((-5.0, 0.0, 0.0, 5.0), (24.9, 24.0, 0.0, 0.0)),),
+        precision=200,
+    )
+
+    assert projected[0][0][0] == Decimal("-5.0")
+    assert projected[0][1][0] == Decimal("25.0")
+    gluon, top = metadata["points"][0]["legs"]
+    assert gluon["mass"] == "0"
+    assert top["mass"] == "7"
+    assert top["mass_parameter"] == "ufo.MT"
+
+
+def _scalar_union_plan() -> _RecurrenceExactPlan:
+    exact_factors = (
+        _factor(1),
+        _factor(0),
+        _factor(2),
+        _factor(3),
+        _factor(0),
+        _factor(1),
+        _factor(0),
+        _factor(2),
+    )
+    sources = (
+        _Source(0, 0, 0, 0, 0, 0, 0),
+        _Source(1, 2, 1, 1, 0, 0, 0),
+    )
+    variants = (
+        _SourceDispatchVariant(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1),
+        _SourceDispatchVariant(2, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 2, 1),
+    )
+    sections = _RecurrenceExactSectionsV1(
+        process_id="synthetic_union",
+        strategy="all-flow-union",
+        semantic_digest="0" * 64,
+        runtime_layout_digest="1" * 64,
+        current_arena_components=4,
+        amplitude_destination_count=2,
+        parameter_value_count=0,
+        external_source_count=2,
+        currents=(),
+        sources=sources,
+        contributions=(),
+        finalizations=(),
+        closures=(
+            _Closure(0, 2, 0, 1, 0, 0, 4, 2, 0, 0),
+            _Closure(0, 2, 0, 1, 1, 0, 6, 2, 0, 0),
+        ),
+        row_groups=(
+            _RowGroup(0, 0, 0, DIRECT_NONE_U32, 0, 2),
+            _RowGroup(1, 3, 3, 1, 0, 2),
+        ),
+        momentum_forms=(_MomentumForm(0, 1), _MomentumForm(1, 1)),
+        momentum_terms=(_MomentumTerm(0, 1), _MomentumTerm(1, 1)),
+        replay_targets=(),
+        source_permutations=(),
+        replay_momentum_signs=(),
+        replay_helicity_map=(),
+        amplitude_destinations=(
+            _AmplitudeDestination(0, 0, 10, DIRECT_NONE_U32, 1, 0),
+            _AmplitudeDestination(1, 1, 20, DIRECT_NONE_U32, 1, 0),
+        ),
+        resolved_helicities=(_ResolvedHelicity(0, 0, 0, 0, 2, 2, 2, 0),),
+        source_state_assignments=(
+            _SourceStateAssignment(0, 0),
+            _SourceStateAssignment(1, 0),
+        ),
+        source_dispatch_variants=variants,
+        source_embeddings=(
+            _SourceEmbedding(0, DIRECT_NONE_U32, 1),
+            _SourceEmbedding(1, 0, 2),
+            _SourceEmbedding(0, DIRECT_NONE_U32, 1),
+            _SourceEmbedding(1, 0, 3),
+        ),
+        source_projections=(
+            _SourceProjection(0, 1),
+            _SourceProjection(0, 1),
+        ),
+        resolved_source_selections=(
+            _ResolvedSourceSelection(0, 0),
+            _ResolvedSourceSelection(1, 1),
+        ),
+        public_helicities=(0, 0),
+        exact_factors=exact_factors,
+        public_flow_ids=(10, 20),
+        executors=(
+            _Executor(0, "source", "initialize", (), 1, 1, None, "source"),
+            _Executor(
+                1,
+                "closure",
+                "closure-add",
+                (2, 2),
+                1,
+                2,
+                None,
+                "componentwise-dot",
+            ),
+        ),
+    )
+    return _RecurrenceExactPlan(
+        sections=sections,
+        kernels={},
+        executors={row.executor_id: row for row in sections.executors},
+        executor_exact_kernel_ids={},
+        executor_parent_permutations={0: (0, 1), 1: (0, 1)},
+        source_templates={
+            0: _SourceTemplate(
+                0, 1, 0, 0, 0, "scalar", "self-conjugate", None, 1, 1, 1
+            ),
+            1: _SourceTemplate(
+                1, 1, 0, 0, 0, "scalar", "self-conjugate", None, 1, 1, 1
+            ),
+        },
+        initial_source_slots=frozenset(),
+        executor_couplings={},
+        prepared_defaults=(),
+        parameter_projection=(),
+        parameter_derivation=None,
+    )
+
+
+def _point() -> tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]:
+    return (
+        (Decimal(10), Decimal(1), Decimal(2), Decimal(3)),
+        (Decimal(20), Decimal(4), Decimal(5), Decimal(6)),
+    )
+
+
+def test_union_schedule_returns_independent_flow_amplitudes() -> None:
+    plan = _scalar_union_plan()
+    amplitudes = _evaluate_union_point(
+        plan,
+        _point(),
+        plan.sections.resolved_helicities[0],
+        (),
+        50,
+    )
+    assert amplitudes == ((Decimal(6), _ZERO), (Decimal(12), _ZERO))
+
+
+def test_union_schedule_executes_certified_reuse_as_exact_scale_copy() -> None:
+    plan = _scalar_union_plan()
+    sections = plan.sections
+    plan.sections = replace(
+        sections,
+        exact_factors=(*sections.exact_factors, _factor(3, 2)),
+        contributions=(
+            _Contribution(
+                0,
+                DIRECT_NONE_U32,
+                2,
+                DIRECT_NONE_U32,
+                2,
+                len(sections.exact_factors),
+                0,
+                3,
+            ),
+        ),
+        row_groups=(
+            sections.row_groups[0],
+            _RowGroup(1, 1, 1, DIRECT_NONE_U32, 0, 1),
+            sections.row_groups[1],
+        ),
+    )
+
+    amplitudes = _evaluate_union_point(
+        plan,
+        _point(),
+        plan.sections.resolved_helicities[0],
+        (),
+        50,
+    )
+
+    assert amplitudes == (
+        (Decimal(12), Decimal(8)),
+        (Decimal(24), Decimal(16)),
+    )
+
+
+def test_zero_self_reuse_clears_stale_decimal_destination_before_copy() -> None:
+    plan = _scalar_union_plan()
+    sections = plan.sections
+    zero_factor_id = len(sections.exact_factors)
+    plan.sections = replace(
+        sections,
+        currents=(
+            _Current(
+                2,
+                1,
+                0,
+                2,
+                2,
+                0,
+                1,
+                0,
+                0,
+                0,
+                DIRECT_NONE_U32,
+                DIRECT_NONE_U32,
+            ),
+        ),
+        exact_factors=(*sections.exact_factors, _factor(0)),
+    )
+    arena = [
+        (Decimal(1), Decimal(2)),
+        (Decimal(3), Decimal(4)),
+        (Decimal("NaN"), Decimal("NaN")),
+        (Decimal("NaN"), Decimal("NaN")),
+    ]
+    row = _Contribution(
+        2,
+        DIRECT_NONE_U32,
+        2,
+        DIRECT_NONE_U32,
+        2,
+        zero_factor_id,
+        0,
+        3,
+    )
+
+    _clear_stage(plan, arena, 1)
+    _execute_certified_reuse_row(plan, row, arena)
+
+    assert arena[2:] == [(_ZERO, _ZERO), (_ZERO, _ZERO)]
+
+
+def test_certified_reuse_rejects_noncanonical_encoding() -> None:
+    plan = _scalar_union_plan()
+    arena = [
+        (Decimal(2), Decimal(3)),
+        (Decimal(4), Decimal(5)),
+        (Decimal(99), Decimal(101)),
+        (Decimal(103), Decimal(107)),
+    ]
+
+    with pytest.raises(ArtifactError, match="invalid encoding"):
+        _execute_certified_reuse_row(
+            plan,
+            _Contribution(
+                0,
+                DIRECT_NONE_U32,
+                2,
+                DIRECT_NONE_U32,
+                2,
+                3,
+                0,
+                1,
+            ),
+            arena,
+        )
+
+    assert arena == [
+        (Decimal(2), Decimal(3)),
+        (Decimal(4), Decimal(5)),
+        (Decimal(99), Decimal(101)),
+        (Decimal(103), Decimal(107)),
+    ]
+
+
+def test_union_source_zeroes_inactive_weyl_embedding_components() -> None:
+    plan = _scalar_union_plan()
+    sections = plan.sections
+    source = _Source(0, 0, 0, 0, 1, 0, 0)
+    variant = _SourceDispatchVariant(
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        7,
+        7,
+        9,
+        1,
+        0,
+        0,
+        4,
+        2,
+    )
+    plan.sections = replace(
+        sections,
+        sources=(source,),
+        source_dispatch_variants=(variant,),
+        source_embeddings=(
+            _SourceEmbedding(0, 0, 0),
+            _SourceEmbedding(1, DIRECT_NONE_U32, 1),
+            _SourceEmbedding(2, 1, 0),
+            _SourceEmbedding(3, DIRECT_NONE_U32, 1),
+        ),
+        source_projections=(
+            _SourceProjection(0, 0),
+            _SourceProjection(1, 2),
+        ),
+    )
+    plan.source_templates = {
+        7: _SourceTemplate(
+            7,
+            2,
+            1,
+            1,
+            1,
+            "fermion",
+            "particle",
+            None,
+            1,
+            1,
+            1,
+        )
+    }
+    momentum = (Decimal(10), Decimal(1), Decimal(2), Decimal(9))
+    arena = [(_ONE * 99, _ONE * 99) for _ in range(4)]
+    _execute_union_source(plan, source, variant, (momentum,), (), arena)
+    expected = _quark_weyl(momentum, 1, 1)
+    assert arena == [expected[0], (_ZERO, _ZERO), expected[1], (_ZERO, _ZERO)]
+
+
+def test_exact_kernel_inputs_use_executor_binding_coupling() -> None:
+    plan = _scalar_union_plan()
+    plan.executor_couplings = {7: (Decimal("1.25"), Decimal("-0.5"))}
+    plan.executor_parent_permutations = {**plan.executor_parent_permutations, 7: (0, 1)}
+    executor = _Executor(
+        7,
+        "contribution",
+        "add",
+        (1, 1),
+        1,
+        2,
+        3,
+        None,
+    )
+    row = _Contribution(0, 0, 0, 0, 0, 0, 0, 0)
+
+    inputs = _kernel_inputs(
+        plan,
+        (
+            {"component": 0, "role": "coupling-real"},
+            {"component": 1, "role": "coupling-imag"},
+        ),
+        executor,
+        row,
+        (),
+        ((Decimal(99), Decimal(101)),),
+        (),
+    )
+
+    assert inputs == (
+        (Decimal("1.25"), _ZERO),
+        (Decimal("-0.5"), _ZERO),
+    )
+
+
+@pytest.mark.parametrize(
+    ("parent_permutation", "expected"),
+    (
+        (
+            (0, 1),
+            (
+                (Decimal(10), _ZERO),
+                (Decimal(20), _ZERO),
+                (Decimal(100), _ZERO),
+                (Decimal(200), _ZERO),
+            ),
+        ),
+        (
+            (1, 0),
+            (
+                (Decimal(20), _ZERO),
+                (Decimal(10), _ZERO),
+                (Decimal(200), _ZERO),
+                (Decimal(100), _ZERO),
+            ),
+        ),
+    ),
+)
+def test_exact_contribution_inputs_apply_authenticated_parent_permutation_once(
+    parent_permutation: tuple[int, int],
+    expected: tuple[tuple[Decimal, Decimal], ...],
+) -> None:
+    plan = _scalar_union_plan()
+    plan.executor_parent_permutations = {
+        **plan.executor_parent_permutations,
+        7: parent_permutation,
+    }
+    executor = _Executor(
+        7,
+        "contribution",
+        "add",
+        (1, 1),
+        1,
+        2,
+        3,
+        None,
+    )
+    row = _Contribution(0, 1, 0, 1, 0, 0, 0, 0)
+
+    inputs = _kernel_inputs(
+        plan,
+        (
+            {"component": 0, "role": "left-current"},
+            {"component": 0, "role": "right-current"},
+            {"component": 0, "role": "left-momentum"},
+            {"component": 0, "role": "right-momentum"},
+        ),
+        executor,
+        row,
+        (
+            (Decimal(100), _ZERO, _ZERO, _ZERO),
+            (Decimal(200), _ZERO, _ZERO, _ZERO),
+        ),
+        (),
+        ((Decimal(10), _ZERO), (Decimal(20), _ZERO)),
+    )
+
+    assert inputs == expected
+
+
+def test_exact_contribution_inputs_reject_unauthenticated_parent_permutation() -> None:
+    plan = _scalar_union_plan()
+    plan.executor_parent_permutations = {
+        **plan.executor_parent_permutations,
+        7: (0, 0),
+    }
+    executor = _Executor(
+        7,
+        "contribution",
+        "add",
+        (1, 1),
+        1,
+        2,
+        3,
+        None,
+    )
+    row = _Contribution(0, 1, 0, 1, 0, 0, 0, 0)
+
+    with pytest.raises(ArtifactError, match="authenticated parent permutation"):
+        _kernel_inputs(
+            plan,
+            ({"component": 0, "role": "left-current"},),
+            executor,
+            row,
+            (),
+            (),
+            ((Decimal(10), _ZERO), (Decimal(20), _ZERO)),
+        )
+
+
+def test_exact_factor_cache_is_schedule_local_and_context_exact() -> None:
+    plan = _scalar_union_plan()
+    plan.sections = replace(
+        plan.sections,
+        exact_factors=(
+            *plan.sections.exact_factors,
+            _ExactFactor(1, 3, -2, 7),
+        ),
+    )
+    factor_id = len(plan.sections.exact_factors) - 1
+    low_precision_cache = [None] * len(plan.sections.exact_factors)
+    with localcontext() as context:
+        context.prec = 9
+        first = _resolved_factor(
+            plan,
+            factor_id,
+            cache=low_precision_cache,
+        )
+        second = _resolved_factor(
+            plan,
+            factor_id,
+            cache=low_precision_cache,
+        )
+    high_precision_cache = [None] * len(plan.sections.exact_factors)
+    with localcontext() as context:
+        context.prec = 40
+        high_precision = _resolved_factor(
+            plan,
+            factor_id,
+            cache=high_precision_cache,
+        )
+
+    assert first is second
+    assert first != high_precision
+    assert first == (Decimal("0.333333333"), Decimal("-0.285714286"))
+
+
+def test_trusted_executor_recipe_matches_validated_kernel_inputs() -> None:
+    plan = _scalar_union_plan()
+    plan.executor_couplings = {7: (Decimal("1.25"), Decimal("-0.5"))}
+    plan.executor_parent_permutations = {
+        **plan.executor_parent_permutations,
+        7: (1, 0),
+    }
+    executor = _Executor(
+        7,
+        "contribution",
+        "add",
+        (1, 1),
+        1,
+        2,
+        3,
+        None,
+    )
+    contracts = (
+        {"component": 0, "role": "left-current"},
+        {"component": 0, "role": "right-current"},
+        {"component": 0, "role": "left-momentum"},
+        {"component": 0, "role": "right-momentum"},
+        {"component": 0, "role": "coupling-real"},
+        {"component": 0, "role": "coupling-imag"},
+        {
+            "component": 0,
+            "role": "model-parameter",
+            "model_parameter_index": 0,
+        },
+    )
+    kernel = SimpleNamespace(record=SimpleNamespace(input_contracts=contracts))
+    plan.kernels = {3: kernel}
+    row = _Contribution(0, 1, 0, 1, 0, 0, 0, 0)
+    momenta = (
+        (Decimal(100), _ZERO, _ZERO, _ZERO),
+        (Decimal(200), _ZERO, _ZERO, _ZERO),
+    )
+    parameters = ((Decimal(300), Decimal(400)),)
+    arena = ((Decimal(10), _ZERO), (Decimal(20), _ZERO))
+
+    recipe = _trusted_executor_recipe(plan, executor)
+    inputs = _trusted_kernel_inputs(
+        plan,
+        recipe.inputs,
+        executor,
+        row,
+        momenta,
+        parameters,
+        arena,
+    )
+
+    assert _trusted_executor_recipe(plan, executor) is recipe
+    assert inputs == _kernel_inputs(
+        plan,
+        contracts,
+        executor,
+        row,
+        momenta,
+        parameters,
+        arena,
+    )
+
+
+def test_union_exact_resolved_values_sum_incoherently_by_flow(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    plan = _scalar_union_plan()
+    executor = object.__new__(RecurrenceExactExecutor)
+    executor._plan = plan
+    executor._physics = {
+        "extensions": {"normalization": {}},
+        "helicities": [
+            {
+                "id": "h:0,0",
+                "values": [0, 0],
+                "computed": True,
+                "structural_zero": False,
+                "coefficient": 1,
+            }
+        ],
+        "color_components": [
+            {"id": "flow:a", "coefficient": 1},
+            {"id": "flow:b", "coefficient": 1},
+        ],
+        "color_accuracy": "lc",
+    }
+    executor._permutation = (0, 1)
+    executor._native_runtime = object()
+    (
+        executor._helicity_representative,
+        executor._helicity_orbit_members,
+    ) = executor._helicity_reduction_indices()
+    executor._replay_by_color = ()
+    executor._destination_helicities = ()
+    executor._union_destination_by_color = executor._union_destinations_by_color()
+    executor._union_helicity_by_physics = executor._union_helicities_by_physics()
+    monkeypatch.setattr(executor_module, "_prepare_points", lambda *_: (_point(),))
+    monkeypatch.setattr(
+        executor_module,
+        "_runtime_state",
+        lambda _: {"model_parameter_values": [], "normalization_factor": 1},
+    )
+
+    resolved = executor.evaluate_resolved(
+        (((10, 1, 2, 3), (20, 4, 5, 6)),),
+        helicities=None,
+        color_flows=None,
+        precision=40,
+    )
+    assert resolved.values == (((Decimal(36), Decimal(144)),),)
+    assert resolved.total() == (Decimal(180),)
+    assert resolved.total() != (Decimal((6 + 12) ** 2),)
+
+    selected = executor.evaluate_resolved(
+        (((10, 1, 2, 3), (20, 4, 5, 6)),),
+        helicities=("h:0,0",),
+        color_flows=("flow:b",),
+        precision=40,
+    )
+    assert selected.values == (((Decimal(144),),),)
+    with pytest.raises(EvaluationError, match="unknown resolved helicity ID"):
+        executor.evaluate_resolved(
+            (((10, 1, 2, 3), (20, 4, 5, 6)),),
+            helicities=("missing",),
+            color_flows=None,
+            precision=40,
+        )
+    with pytest.raises(EvaluationError, match="unknown resolved color component ID"):
+        executor.evaluate_resolved(
+            (((10, 1, 2, 3), (20, 4, 5, 6)),),
+            helicities=None,
+            color_flows=("missing",),
+            precision=40,
+        )
+
+
+def test_union_native_section_adapter_parses_dispatch_tables() -> None:
+    sections = _scalar_union_plan().sections
+    raw = {
+        "abi": RECURRENCE_EXACT_SECTIONS_ABI,
+        "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_V2_ABI,
+        "process_id": sections.process_id,
+        "strategy": sections.strategy,
+        "semantic_digest": sections.semantic_digest,
+        "runtime_layout_digest": sections.runtime_layout_digest,
+        "counts": (
+            sections.current_arena_components,
+            sections.amplitude_destination_count,
+            sections.parameter_value_count,
+            sections.external_source_count,
+        ),
+        "currents": [astuple(row) for row in sections.currents],
+        "sources": [astuple(row) for row in sections.sources],
+        "contributions": [astuple(row) for row in sections.contributions],
+        "finalizations": [astuple(row) for row in sections.finalizations],
+        "closures": [astuple(row) for row in sections.closures],
+        "row_groups": [astuple(row) for row in sections.row_groups],
+        "momentum_forms": [astuple(row) for row in sections.momentum_forms],
+        "momentum_terms": [astuple(row) for row in sections.momentum_terms],
+        "replay_targets": [],
+        "source_permutations": [],
+        "replay_momentum_signs": [],
+        "replay_helicity_map": [],
+        "amplitude_destinations": [
+            astuple(row) for row in sections.amplitude_destinations
+        ],
+        "resolved_helicities": [astuple(row) for row in sections.resolved_helicities],
+        "source_state_assignments": [
+            astuple(row) for row in sections.source_state_assignments
+        ],
+        "source_dispatch_variants": [
+            astuple(row) for row in sections.source_dispatch_variants
+        ],
+        "source_embeddings": [astuple(row) for row in sections.source_embeddings],
+        "source_projections": [astuple(row) for row in sections.source_projections],
+        "resolved_source_selections": [
+            astuple(row) for row in sections.resolved_source_selections
+        ],
+        "public_helicities": list(sections.public_helicities),
+        "exact_factors": [
+            tuple(str(value) for value in astuple(row))
+            for row in sections.exact_factors
+        ],
+        "public_flow_ids": list(sections.public_flow_ids),
+        "executors": [
+            (
+                row.executor_id,
+                row.role,
+                row.destination_operation,
+                row.parent_component_counts,
+                row.destination_component_count,
+                row.momentum_operand_count,
+                row.prepared_kernel_id,
+                row.runtime_template,
+            )
+            for row in sections.executors
+        ],
+    }
+    parsed = _parse_exact_sections(raw, sections.process_id)
+    assert parsed.strategy == "all-flow-union"
+    assert parsed.source_dispatch_variants == sections.source_dispatch_variants
+    assert parsed.resolved_source_selections == sections.resolved_source_selections
+
+    raw["public_flow_ids"] = [10, 10, 20]
+    parsed = _parse_exact_sections(raw, sections.process_id)
+    assert parsed.public_flow_ids == (10, 10, 20)
+
+    raw["public_flow_ids"] = [10, 10]
+    with pytest.raises(ArtifactError, match="not completely covered"):
+        _parse_exact_sections(raw, sections.process_id)
+
+    raw["public_flow_ids"] = [10, 20]
+    raw["resolved_source_selections"] = [(0, 0)]
+    with pytest.raises(ArtifactError, match="does not cover every external source"):
+        _parse_exact_sections(raw, sections.process_id)
diff --git a/pyamplicol/tests/unit/test_recurrence_fermion_pairing.py b/pyamplicol/tests/unit/test_recurrence_fermion_pairing.py
new file mode 100644
index 0000000000..8611029f53
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_fermion_pairing.py
@@ -0,0 +1,309 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact, bounded external-fermion pairing catalog tests."""
+
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Iterable
+
+import pytest
+
+from pyamplicol.generation.recurrence_fermion_pairing import (
+    NO_FERMION_LINE,
+    RecurrenceFermionPairingError,
+    build_recurrence_fermion_pairing_catalog_v1,
+)
+from pyamplicol.models.recurrence_template import (
+    CurrentStateTemplateV1,
+    ExactComplexRationalV1,
+    QuantumFlowTemplateV1,
+)
+from pyamplicol.processes.ir import (
+    CanonicalProcessIR,
+    ColorEndpointSummary,
+    ProcessLegIR,
+)
+
+
+def _state_pair(
+    token: str,
+    particle_id: int,
+    *,
+    species_id: str | None = None,
+) -> tuple[CurrentStateTemplateV1, CurrentStateTemplateV1]:
+    species = species_id or f"contract:{token}:species"
+    particle = CurrentStateTemplateV1(
+        template_id=f"{token}:particle",
+        particle_id=particle_id,
+        anti_particle_id=-particle_id,
+        species_id=species,
+        orientation="particle",
+        statistics="fermion",
+        color_representation=3,
+        basis="generic-fermion",
+        tensor_ordering=("s0", "s1"),
+        dimension=2,
+        chirality=1,
+        lc_color_shape_kind="fundamental-open-string",
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+    antiparticle = CurrentStateTemplateV1(
+        template_id=f"{token}:antiparticle",
+        particle_id=-particle_id,
+        anti_particle_id=particle_id,
+        species_id=species,
+        orientation="antiparticle",
+        statistics="fermion",
+        color_representation=-3,
+        basis="generic-fermion",
+        tensor_ordering=("s0", "s1"),
+        dimension=2,
+        chirality=-1,
+        lc_color_shape_kind="antifundamental-open-string",
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+    return particle, antiparticle
+
+
+def _leg(label: int, state: CurrentStateTemplateV1) -> ProcessLegIR:
+    role = (
+        "fundamental"
+        if state.lc_color_shape_kind == "fundamental-open-string"
+        else "antifundamental"
+    )
+    return ProcessLegIR(
+        label=label,
+        side="final",
+        particle=state.template_id,
+        outgoing_particle=state.template_id,
+        pdg=state.particle_id,
+        outgoing_pdg=state.particle_id,
+        statistics="fermion",
+        wavefunction_family="fermion",
+        color_role=role,
+        source_orientation=state.orientation,
+    )
+
+
+def _charged_current_flow(
+    down: CurrentStateTemplateV1,
+    up: CurrentStateTemplateV1,
+) -> tuple[CurrentStateTemplateV1, QuantumFlowTemplateV1]:
+    boson = CurrentStateTemplateV1(
+        template_id="charged-current:w",
+        particle_id=990024,
+        anti_particle_id=-990024,
+        species_id="contract:charged-current:w",
+        orientation="particle",
+        statistics="boson",
+        color_representation=1,
+        basis="vector",
+        tensor_ordering=("v0", "v1", "v2", "v3"),
+        dimension=4,
+        chirality=0,
+        lc_color_shape_kind="singlet-forest",
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+    return boson, QuantumFlowTemplateV1(
+        template_id="charged-current:d-w-to-u",
+        input_state_template_ids=(down.template_id, boson.template_id),
+        input_spin_states=(1, 0),
+        input_flavour_flows=((down.particle_id,), (boson.particle_id,)),
+        input_quantum_number_flows=((), ()),
+        flavour_flow_operation="append-left-result",
+        quantum_number_flow_operation="particle-static-result",
+        coupling_orders=(("QED", 1),),
+        result_state_template_id=up.template_id,
+        result_spin_state=1,
+        result_flavour_flow=(down.particle_id, up.particle_id),
+        result_quantum_number_flow=(),
+        exact_coupling=ExactComplexRationalV1.one(),
+        predicate_digest="a" * 64,
+    )
+
+
+def _process(
+    key: str,
+    states: Iterable[CurrentStateTemplateV1],
+    *,
+    color_accuracy: str = "lc",
+) -> CanonicalProcessIR:
+    materialized = tuple(states)
+    fundamental_count = sum(
+        state.lc_color_shape_kind == "fundamental-open-string" for state in materialized
+    )
+    antifundamental_count = len(materialized) - fundamental_count
+    return CanonicalProcessIR(
+        process="canonical contract fixture",
+        key=key,
+        color_accuracy=color_accuracy,
+        legs=tuple(_leg(index + 1, state) for index, state in enumerate(materialized)),
+        color_endpoints=ColorEndpointSummary(
+            fundamental_count=fundamental_count,
+            antifundamental_count=antifundamental_count,
+            pair_count=min(fundamental_count, antifundamental_count),
+        ),
+    )
+
+
+def test_distinct_two_line_pairing_has_one_even_rule() -> None:
+    first, first_anti = _state_pair("first", 910001)
+    second, second_anti = _state_pair("second", 920001)
+    external = (first_anti, first, second, second_anti)
+
+    catalog = build_recurrence_fermion_pairing_catalog_v1(
+        _process("distinct-two-line", external),
+        (second_anti, first, first_anti, second),
+    )
+
+    assert len(catalog.pairing_classes) == 2
+    assert tuple(row.pairing_count for row in catalog.pairing_classes) == (1, 1)
+    assert len(catalog.rules) == 1
+    assert catalog.rules[0].fermion_parity == 1
+    assert catalog.rules[0].endpoint_pairings == ((1, 0), (2, 3))
+    assert catalog.rules[0].lineage_by_source_slot == (0, 0, 1, 1)
+
+
+def test_identical_two_line_pairings_are_direct_plus_exchange_minus() -> None:
+    particle, antiparticle = _state_pair("identical", 930001)
+    external = (antiparticle, particle, particle, antiparticle)
+
+    catalog = build_recurrence_fermion_pairing_catalog_v1(
+        _process("identical-two-line", external),
+        (particle, antiparticle),
+    )
+
+    assert len(catalog.pairing_classes) == 1
+    assert catalog.pairing_classes[0].reference_pairings == ((1, 0), (2, 3))
+    assert tuple(rule.fermion_parity for rule in catalog.rules) == (1, -1)
+    assert tuple(rule.exact_factor.real_numerator for rule in catalog.rules) == (
+        1,
+        -1,
+    )
+    assert catalog.rules[0].endpoint_pairings == ((1, 0), (2, 3))
+    assert catalog.rules[0].source_slot_permutation == (0, 1, 2, 3)
+    assert catalog.rules[1].endpoint_pairings == ((1, 3), (2, 0))
+    assert catalog.rules[1].source_slot_permutation == (3, 1, 2, 0)
+
+
+def test_four_identical_lines_have_accuracy_independent_canonical_pairings() -> None:
+    particle, antiparticle = _state_pair("four-identical", 930011)
+    external = (antiparticle, particle) * 4
+    catalogs = tuple(
+        build_recurrence_fermion_pairing_catalog_v1(
+            _process(
+                "four-identical-lines",
+                external,
+                color_accuracy=accuracy,
+            ),
+            (particle, antiparticle),
+        )
+        for accuracy in ("lc", "nlc", "full")
+    )
+
+    reference = catalogs[0]
+    canonical_pairings = tuple(rule.endpoint_pairings for rule in reference.rules)
+    assert len(canonical_pairings) == len(set(canonical_pairings)) == 24
+    assert all(pairings == tuple(sorted(pairings)) for pairings in canonical_pairings)
+    assert Counter(
+        (rule.fermion_parity, rule.exact_factor) for rule in reference.rules
+    ) == {
+        (1, ExactComplexRationalV1(1, 1, 0, 1)): 12,
+        (-1, ExactComplexRationalV1(-1, 1, 0, 1)): 12,
+    }
+    assert all(
+        (catalog.topology_digest, catalog.rules)
+        == (reference.topology_digest, reference.rules)
+        for catalog in catalogs[1:]
+    )
+
+
+def test_three_distinct_lines_have_one_rule_and_three_lineages() -> None:
+    one, one_anti = _state_pair("one", 940001)
+    two, two_anti = _state_pair("two", 940002)
+    three, three_anti = _state_pair("three", 940003)
+    external = (one, two_anti, three, one_anti, two, three_anti)
+
+    catalog = build_recurrence_fermion_pairing_catalog_v1(
+        _process("three-distinct-lines", external),
+        (three_anti, two, one_anti, three, one, two_anti),
+    )
+
+    assert len(catalog.pairing_classes) == 3
+    assert len(catalog.rules) == 1
+    assert catalog.rules[0].fermion_parity == 1
+    assert catalog.rules[0].endpoint_pairings == ((0, 3), (2, 5), (4, 1))
+    assert catalog.rules[0].lineage_by_source_slot == (0, 2, 1, 0, 2, 1)
+    assert NO_FERMION_LINE not in catalog.rules[0].lineage_by_source_slot
+
+
+def test_incompatible_species_are_rejected_before_rule_enumeration() -> None:
+    first, _first_anti = _state_pair("first-only", 950001)
+    _second, second_anti = _state_pair("second-only", 950002)
+    process = _process("incompatible-species", (first, second_anti))
+    states = (*_state_pair("first-only", 950001), *_state_pair("second-only", 950002))
+
+    with pytest.raises(
+        RecurrenceFermionPairingError,
+        match="incompatible fermion species endpoints",
+    ):
+        build_recurrence_fermion_pairing_catalog_v1(process, states)
+
+
+def test_model_proven_charged_current_species_share_one_pairing_class() -> None:
+    down, down_anti = _state_pair("charged-down", 950011)
+    up, up_anti = _state_pair("charged-up", 950012)
+    boson, flow = _charged_current_flow(down, up)
+
+    catalog = build_recurrence_fermion_pairing_catalog_v1(
+        _process("charged-current", (down, up_anti)),
+        (down, down_anti, up, up_anti, boson),
+        quantum_flows=(flow,),
+    )
+
+    assert len(catalog.pairing_classes) == 1
+    assert catalog.pairing_classes[0].fundamental_source_slots == (0,)
+    assert catalog.pairing_classes[0].antifundamental_source_slots == (1,)
+    assert catalog.rules[0].endpoint_pairings == ((0, 1),)
+
+
+def test_equivalent_model_contracts_have_identical_pairing_topology() -> None:
+    builtin_particle, builtin_anti = _state_pair(
+        "builtin:matter",
+        960001,
+        species_id="builtin:model-owned:matter",
+    )
+    ufo_particle, ufo_anti = _state_pair(
+        "ufo:matter",
+        960001,
+        species_id="ufo:model-owned:matter",
+    )
+    builtin_external = (
+        builtin_anti,
+        builtin_particle,
+        builtin_particle,
+        builtin_anti,
+    )
+    ufo_external = (ufo_anti, ufo_particle, ufo_particle, ufo_anti)
+
+    builtin = build_recurrence_fermion_pairing_catalog_v1(
+        _process("equivalent-model-contract", builtin_external),
+        (builtin_particle, builtin_anti),
+    )
+    ufo = build_recurrence_fermion_pairing_catalog_v1(
+        _process("equivalent-model-contract", ufo_external),
+        (ufo_anti, ufo_particle),
+    )
+
+    assert builtin.topology_digest == ufo.topology_digest
+    assert builtin.rules == ufo.rules
+    assert tuple(row.species_class_id for row in builtin.endpoints) == tuple(
+        row.species_class_id for row in ufo.endpoints
+    )
+    assert builtin.semantic_digest != ufo.semantic_digest
diff --git a/pyamplicol/tests/unit/test_recurrence_generation_ab_ladder.py b/pyamplicol/tests/unit/test_recurrence_generation_ab_ladder.py
new file mode 100644
index 0000000000..f499d9bcb4
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_generation_ab_ladder.py
@@ -0,0 +1,829 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tools.developer import recurrence_generation_ab_ladder as ladder
+
+
+def test_process_family_and_approved_timeout_policy() -> None:
+    assert ladder.process_expression(1) == "d d~ > Z"
+    assert ladder.process_expression(4) == "d d~ > Z g g g"
+    assert ladder.generation_timeout_seconds(2, "topology-replay") == 300.0
+    assert ladder.generation_timeout_seconds(7, "all-flow-union") == 900.0
+    assert ladder.generation_timeout_seconds(8, "topology-replay") == 3600.0
+    assert ladder.generation_timeout_seconds(8, "all-flow-union") == 7200.0
+    assert ladder.generation_timeout_seconds(9, "topology-replay") == 7200.0
+    assert ladder.generation_timeout_seconds(9, "all-flow-union") == 21600.0
+    with pytest.raises(ladder.LadderError):
+        ladder.generation_timeout_seconds(10, "topology-replay")
+
+
+def test_schedule_alternates_pair_order_and_selects_runtime_cells() -> None:
+    schedule = ladder.build_schedule(
+        (2, 6),
+        ("topology-replay",),
+        2,
+        frozenset({6}),
+    )
+
+    assert [sample.variant_name for sample in schedule] == [
+        "baseline",
+        "candidate",
+        "candidate",
+        "baseline",
+        "baseline",
+        "candidate",
+        "candidate",
+        "baseline",
+    ]
+    assert [sample.pair_index for sample in schedule] == [
+        0,
+        0,
+        1,
+        1,
+        2,
+        2,
+        3,
+        3,
+    ]
+    assert all(not sample.runtime_enabled for sample in schedule[:4])
+    assert all(sample.runtime_enabled for sample in schedule[4:])
+
+
+def _spec(*, multiplicity: int, runtime_enabled: bool) -> ladder.SampleSpec:
+    return ladder.SampleSpec(
+        sequence_index=0,
+        pair_index=0,
+        order_in_pair=0,
+        repetition=0,
+        multiplicity=multiplicity,
+        layout="all-flow-union",
+        variant_name="baseline",
+        runtime_enabled=runtime_enabled,
+    )
+
+
+def test_command_wraps_each_capture_and_runtime_workers_in_watchdog(
+    tmp_path: Path,
+) -> None:
+    checkout = tmp_path / "checkout"
+    variant = ladder.Variant(
+        name="baseline",
+        checkout=checkout,
+        python=tmp_path / "python",
+        pythonpath=tmp_path / "site-packages",
+        prepared_model=tmp_path / "model.pack",
+    )
+    settings = ladder.RunnerSettings()
+    sample_root = tmp_path / "sample"
+
+    generation_command = ladder.build_sample_command(
+        _spec(multiplicity=2, runtime_enabled=False),
+        variant,
+        sample_root,
+        settings,
+    )
+    assert generation_command[:6] == [
+        str(variant.python),
+        str(ladder.ROOT / ladder.WATCHDOG_RELATIVE_PATH),
+        "--limit-gib",
+        "30",
+        "--",
+        str(variant.python),
+    ]
+    assert str(ladder.ROOT / ladder.HARNESS_RELATIVE_PATH) in generation_command
+    assert generation_command.count("--mode") == 1
+    assert "recurrence" in generation_command
+    assert "--generation-only" in generation_command
+    assert "--allow-diagnostic-incomplete-success" not in generation_command
+    assert generation_command[generation_command.index("--process-expression") + 1] == (
+        "d d~ > Z g"
+    )
+    validation_index = generation_command.index("--validation-samples")
+    assert generation_command[validation_index : validation_index + 4] == [
+        "--validation-samples",
+        "10",
+        "--point-tile-size",
+        "1024",
+    ]
+
+    runtime_command = ladder.build_sample_command(
+        _spec(multiplicity=6, runtime_enabled=True),
+        variant,
+        sample_root,
+        settings,
+    )
+    assert "--generation-only" not in runtime_command
+    assert [
+        runtime_command[index + 1]
+        for index, value in enumerate(runtime_command)
+        if value == "--batch-size"
+    ] == ["1", "128", "1024"]
+    assert runtime_command[runtime_command.index("--subprocess-samples") + 1] == "7"
+    assert runtime_command[runtime_command.index("--warmup-runs") + 1] == "2"
+    assert runtime_command[runtime_command.index("--target-runtime") + 1] == "5"
+
+    scouting_command = ladder.build_sample_command(
+        _spec(multiplicity=9, runtime_enabled=False),
+        variant,
+        sample_root,
+        ladder.RunnerSettings(allow_diagnostic_incomplete_success=True),
+    )
+    assert "--allow-diagnostic-incomplete-success" in scouting_command
+
+    _, overrides = ladder._sample_environment(
+        variant,
+        tmp_path / "sample-environment",
+    )
+    assert overrides[ladder.HARNESS_SOURCE_CHECKOUT_ENV] == str(checkout)
+
+
+def test_incomplete_diagnostic_capture_is_never_classified_as_passed() -> None:
+    outcome = ladder.ProcessOutcome(
+        exit_code=0,
+        timed_out=False,
+        wall_seconds=1.0,
+        error=None,
+    )
+    watchdog = {"terminal_record": "command-finished"}
+    incomplete = {"complete": None, "passes": None}
+
+    assert (
+        ladder._sample_status(
+            outcome,
+            watchdog=watchdog,
+            result_error=None,
+            harness_summary=incomplete,
+            allow_diagnostic_incomplete_success=False,
+        )
+        == "failed-validation"
+    )
+    assert (
+        ladder._sample_status(
+            outcome,
+            watchdog=watchdog,
+            result_error=None,
+            harness_summary=incomplete,
+            allow_diagnostic_incomplete_success=True,
+        )
+        == "censored"
+    )
+    assert (
+        ladder._sample_status(
+            outcome,
+            watchdog=watchdog,
+            result_error=None,
+            harness_summary={"complete": True, "passes": True},
+            allow_diagnostic_incomplete_success=False,
+        )
+        == "passed"
+    )
+
+
+def test_generation_timeout_is_censored_only_in_explicit_scouting_mode(
+    tmp_path: Path,
+) -> None:
+    stderr = tmp_path / "stderr.log"
+    stderr.write_text(
+        "recurrence-z6g-benchmark: recurrence generation worker exceeded "
+        "21600 seconds\n"
+        "memory-watchdog: command finished exit=2 peak_rss=1.250 GiB "
+        "peak_physical_footprint=1.500 GiB peak_guard=1.500 GiB "
+        "peak_processes=4\n",
+        encoding="utf-8",
+    )
+    timeout = ladder.parse_harness_generation_timeout(stderr)
+    assert timeout == {"configured_seconds": 21600.0}
+    outcome = ladder.ProcessOutcome(
+        exit_code=2,
+        timed_out=False,
+        wall_seconds=21600.0,
+        error=None,
+    )
+    watchdog = {"terminal_record": "command-finished"}
+
+    assert (
+        ladder._sample_status(
+            outcome,
+            watchdog=watchdog,
+            result_error=None,
+            harness_summary=None,
+            harness_generation_timeout=timeout,
+            allow_diagnostic_incomplete_success=False,
+        )
+        == "timeout"
+    )
+    assert (
+        ladder._sample_status(
+            outcome,
+            watchdog=watchdog,
+            result_error=None,
+            harness_summary=None,
+            harness_generation_timeout=timeout,
+            allow_diagnostic_incomplete_success=True,
+        )
+        == "censored"
+    )
+
+
+def test_scouting_does_not_censor_arbitrary_or_memory_limit_failures(
+    tmp_path: Path,
+) -> None:
+    stderr = tmp_path / "stderr.log"
+    stderr.write_text(
+        "recurrence-z6g-benchmark: recurrence generation failed\n",
+        encoding="utf-8",
+    )
+    assert ladder.parse_harness_generation_timeout(stderr) is None
+    outcome = ladder.ProcessOutcome(
+        exit_code=2,
+        timed_out=False,
+        wall_seconds=1.0,
+        error=None,
+    )
+    assert (
+        ladder._sample_status(
+            outcome,
+            watchdog={"terminal_record": "memory-limit-exceeded"},
+            result_error=None,
+            harness_summary=None,
+            allow_diagnostic_incomplete_success=True,
+        )
+        == "failed"
+    )
+
+
+def test_watchdog_terminal_records_are_parsed() -> None:
+    finished = ladder.parse_watchdog_text(
+        "memory-watchdog: command finished exit=0"
+        " peak_rss=1.250 GiB"
+        " peak_physical_footprint=1.500 GiB"
+        " peak_guard=1.500 GiB peak_processes=4\n"
+    )
+    assert finished["terminal_record"] == "command-finished"
+    assert finished["child_exit_code"] == 0
+    assert finished["peak_rss"]["bytes_rounded_from_watchdog"] == round(1.25 * 1024**3)
+    assert finished["peak_guard"]["gib"] == 1.5
+
+    exceeded = ladder.parse_watchdog_text(
+        "memory-watchdog: memory limit exceeded"
+        " reason=process-tree-rss-limit"
+        " observed=30.125 GiB limit=30.000 GiB"
+        " rss=30.125 GiB physical_footprint=unavailable"
+        " processes=9; terminating tree\n"
+    )
+    assert exceeded["terminal_record"] == "memory-limit-exceeded"
+    assert exceeded["limit_exceeded"] is True
+    assert exceeded["reason"] == "process-tree-rss-limit"
+    assert exceeded["process_count_at_limit"] == 9
+
+
+def _write_json(path: Path, value: object) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value), encoding="utf-8")
+
+
+def test_harness_result_parser_extracts_phase_and_runtime_telemetry(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    execution = artifact / "processes" / "process" / "execution.json"
+    _write_json(
+        execution,
+        {
+            "kind": ladder.EXECUTION_KIND,
+            "schema_version": ladder.EXECUTION_SCHEMA_VERSION,
+            "plan": {
+                "inspection_summary": {
+                    "generation_timings_seconds": {
+                        "python_extraction": 1.0,
+                        "direct_lowering": 2.0,
+                        "native_total": 3.5,
+                    },
+                    "schedule": {"current_count": 11},
+                    "schedule_digest": "a" * 64,
+                }
+            },
+        },
+    )
+    result_path = tmp_path / "result.json"
+    _write_json(
+        result_path,
+        {
+            "kind": ladder.HARNESS_KIND,
+            "schema_version": ladder.HARNESS_SCHEMA_VERSION,
+            "complete": None,
+            "passes": None,
+            "process": "d d~ > Z g g g g g",
+            "configuration": {"lc_flow_layout": "all-flow-union"},
+            "source": {"git_revision": "1" * 40},
+            "runtime_provenance": {"extension_sha256": "2" * 64},
+            "provenance": {"wall_seconds": 12.0},
+            "generation": {
+                "recurrence": {
+                    "artifact": str(artifact),
+                    "artifact_identity": {"artifact_id": "3" * 64},
+                    "artifact_semantic_identity_sha256": "4" * 64,
+                    "generation_wall_seconds": 9.0,
+                    "worker_process_record": {"wall_seconds": 8.0},
+                    "peak_rss": {"observed_lower_bound_bytes": 1234},
+                    "phase_timings_seconds": {
+                        "model-loading": 1.5,
+                        "recurrence-construction": 6.0,
+                    },
+                    "phase_total_seconds": 7.5,
+                }
+            },
+            "profiles": {
+                "recurrence": {
+                    "process_id": "process",
+                    "process_expression": "d d~ > Z g g g g g",
+                    "profiles": [
+                        {
+                            "batch_size": 128,
+                            "sample_count": 1,
+                            "wall_seconds_per_point": 1.0e-6,
+                            "wall_seconds_per_point_median": 1.0e-6,
+                            "wall_seconds_per_point_mad": 1.0e-8,
+                            "interrupted": False,
+                            "subprocess_samples": [
+                                {
+                                    "schedule_index": 2,
+                                    "round": 0,
+                                    "wall_seconds_per_point": 1.0e-6,
+                                    "internal_sample_count": 7,
+                                    "repetitions_per_sample": 4,
+                                    "evaluation_count": 28,
+                                    "evaluated_point_count": 3584,
+                                    "interrupted": False,
+                                    "worker_process_record": {"wall_seconds": 5.0},
+                                }
+                            ],
+                        }
+                    ],
+                }
+            },
+        },
+    )
+
+    summary = ladder.parse_harness_result(result_path)
+
+    assert summary["generation_wall_seconds"] == 9.0
+    assert summary["generation_peak_rss"]["observed_lower_bound_bytes"] == 1234
+    assert summary["native_generation_timings_seconds"] == {
+        "python_extraction": 1.0,
+        "direct_lowering": 2.0,
+        "native_total": 3.5,
+    }
+    assert summary["native_inspection_summary"]["schedule"]["current_count"] == 11
+    measurement = summary["runtime_profile"]["measurements"][0]
+    assert measurement["batch_size"] == 128
+    assert measurement["subprocess_samples"][0]["worker_wall_seconds"] == 5.0
+
+
+def test_generation_only_result_has_an_independent_fail_closed_acceptance(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    execution = artifact / "processes" / "process" / "execution.json"
+    _write_json(
+        execution,
+        {
+            "kind": ladder.EXECUTION_KIND,
+            "schema_version": ladder.EXECUTION_SCHEMA_VERSION,
+            "plan": {
+                "inspection_summary": {
+                    "generation_timings_seconds": {
+                        "python_extraction": 1.0,
+                        "direct_lowering": 2.0,
+                        "native_total": 3.5,
+                    }
+                }
+            },
+        },
+    )
+    relative_execution = execution.relative_to(artifact).as_posix()
+    payload_entry = {
+        "path": relative_execution,
+        "role": "evaluator-manifest",
+        "process_id": "process",
+        "sha256": ladder._sha256_file(execution),
+        "size_bytes": execution.stat().st_size,
+    }
+    artifact_id = "3" * 64
+    manifest_path = artifact / "artifact.json"
+    _write_json(
+        manifest_path,
+        {
+            "artifact_id": artifact_id,
+            "payloads": [payload_entry],
+        },
+    )
+    signature = {
+        "kind": "pyamplicol-benchmark-generation-signature",
+        "schema_version": 1,
+        "mode": "recurrence",
+        "lc_flow_layout": "all-flow-union",
+        "validation": {
+            "enabled": True,
+            "post_build_validation": True,
+            "samples": 10,
+        },
+    }
+    semantic_identity = {
+        "coverage": {
+            "complete_physical_axes": True,
+            "color": "complete",
+            "helicities": "complete",
+        },
+        "execution_reduction_coverage": {
+            "complete": True,
+            "errors": [],
+        },
+    }
+    evidence = {
+        "kind": "pyamplicol-preserved-worker-result-evidence",
+        "schema_version": 1,
+        "payload": {
+            "mode": "recurrence",
+            "generation_reused": False,
+            "generation_wall_seconds": 9.0,
+        },
+        "worker_result_record": {},
+    }
+    evidence["content_sha256"] = ladder._canonical_sha256(evidence)
+    result_path = tmp_path / "generation-only-result.json"
+    _write_json(
+        result_path,
+        {
+            "kind": ladder.HARNESS_KIND,
+            "schema_version": ladder.HARNESS_SCHEMA_VERSION,
+            "complete": False,
+            "passes": None,
+            "process": "d d~ > Z g",
+            "configuration": {
+                "generation_only": True,
+                "lc_flow_layout": "all-flow-union",
+                "validation_samples": 10,
+            },
+            "source": {"git_revision": "1" * 40},
+            "runtime_provenance": {"extension_sha256": "2" * 64},
+            "provenance": {"wall_seconds": 12.0},
+            "generation": {
+                "recurrence": {
+                    "mode": "recurrence",
+                    "artifact": str(artifact),
+                    "artifact_identity": {
+                        "artifact_id": artifact_id,
+                        "path": str(artifact.resolve()),
+                        "manifest": {
+                            "resolved_path": str(manifest_path.resolve()),
+                            "sha256": ladder._sha256_file(manifest_path),
+                            "size_bytes": manifest_path.stat().st_size,
+                        },
+                        "payloads": [payload_entry],
+                    },
+                    "artifact_semantic_identity": semantic_identity,
+                    "artifact_semantic_identity_sha256": (
+                        ladder._canonical_sha256(semantic_identity)
+                    ),
+                    "semantic_generation_signature": signature,
+                    "semantic_generation_signature_sha256": (
+                        ladder._canonical_sha256(signature)
+                    ),
+                    "generation_worker_result_evidence": evidence,
+                    "generation_reused": False,
+                    "generation_wall_seconds": 9.0,
+                    "worker_process_record": {"wall_seconds": 8.0},
+                    "peak_rss": {"observed_lower_bound_bytes": 1234},
+                    "phase_timings_seconds": {
+                        "model-loading": 1.5,
+                        "recurrence-construction": 6.0,
+                    },
+                    "phase_total_seconds": 7.5,
+                }
+            },
+            "profiles": {},
+        },
+    )
+
+    summary = ladder.parse_harness_result(result_path)
+    acceptance = summary["generation_only_acceptance"]
+    assert acceptance["passes"] is True
+    assert acceptance["payload_count"] == 1
+    assert acceptance["post_build_validation_samples"] == 10
+    assert (
+        ladder._sample_status(
+            ladder.ProcessOutcome(
+                exit_code=0,
+                timed_out=False,
+                wall_seconds=12.0,
+                error=None,
+            ),
+            watchdog={"terminal_record": "command-finished"},
+            result_error=None,
+            harness_summary=summary,
+            allow_diagnostic_incomplete_success=True,
+        )
+        == "passed"
+    )
+
+    execution.write_text(execution.read_text(encoding="utf-8") + "\n", encoding="utf-8")
+    with pytest.raises(ladder.LadderError, match="payload identity differs"):
+        ladder.parse_harness_result(result_path)
+
+
+def _write_runtime_acceptance_result(tmp_path: Path) -> Path:
+    artifact = tmp_path / "runtime-artifact"
+    execution = artifact / "processes" / "process" / "execution.json"
+    _write_json(
+        execution,
+        {
+            "kind": ladder.EXECUTION_KIND,
+            "schema_version": ladder.EXECUTION_SCHEMA_VERSION,
+            "plan": {
+                "inspection_summary": {
+                    "generation_timings_seconds": {"native_total": 3.5}
+                }
+            },
+        },
+    )
+    relative_execution = execution.relative_to(artifact).as_posix()
+    payload_entry = {
+        "path": relative_execution,
+        "role": "evaluator-manifest",
+        "process_id": "process",
+        "sha256": ladder._sha256_file(execution),
+        "size_bytes": execution.stat().st_size,
+    }
+    artifact_id = "3" * 64
+    manifest_path = artifact / "artifact.json"
+    _write_json(
+        manifest_path,
+        {
+            "artifact_id": artifact_id,
+            "payloads": [payload_entry],
+        },
+    )
+    semantic_identity = {
+        "coverage": {"complete_physical_axes": True},
+        "generation_specialized_axes": [],
+    }
+    semantic_sha256 = ladder._canonical_sha256(semantic_identity)
+    artifact_identity = {
+        "artifact_id": artifact_id,
+        "path": str(artifact.resolve()),
+        "manifest": {
+            "resolved_path": str(manifest_path.resolve()),
+            "sha256": ladder._sha256_file(manifest_path),
+            "size_bytes": manifest_path.stat().st_size,
+        },
+        "payloads": [payload_entry],
+        "semantic_identity": semantic_identity,
+        "semantic_identity_sha256": semantic_sha256,
+    }
+    process = "d d~ > Z g g g g g"
+    configuration = {
+        "batch_sizes": [1, 128, 1024],
+        "target_runtime_seconds": 5.0,
+        "minimum_samples": 7,
+        "subprocess_samples": 7,
+        "warmup_runs": 2,
+        "generation_timeout_seconds": 900.0,
+        "profile_timeout_seconds": 300.0,
+        "color_flow_request": "1",
+        "helicity_request": "1",
+        "lc_flow_layout": "all-flow-union",
+        "gluon_count": 5,
+        "validation_samples": 10,
+        "point_tile_size": 1024,
+        "jit_optimization_level": 2,
+        "validation_point_artifact": str(artifact),
+        "generation_only": False,
+        "allow_diagnostic_incomplete_success": True,
+        "modes": ["recurrence"],
+        "prepared_model_path": "/workspace/model.pack",
+        "model_identities": {},
+        "validation_seed": 12345,
+        "specialize_flow_at_generation": False,
+        "external_watchdog_required_for_long_runs": True,
+    }
+    selector = {
+        "color_flow_request": "1",
+        "resolved_color_flow_id": "flow-1",
+        "helicity_request": "1",
+        "resolved_helicity_id": "helicity-1",
+        "color_flow_count": 8,
+        "helicity_count": 32,
+        "structural_zero_helicity_count": 0,
+        "workload": "all-flows/runtime-selected-single-helicity",
+    }
+    fixture = {
+        "point_count": 10,
+        "points_sha256": "4" * 64,
+        "file_sha256": "5" * 64,
+    }
+    validation = {
+        "passes": True,
+        "fixture": {
+            "point_count": fixture["point_count"],
+            "points_sha256": fixture["points_sha256"],
+            "file": {"sha256": fixture["file_sha256"]},
+        },
+    }
+    recurrence_profile = {
+        "mode": "recurrence",
+        "process_id": "process",
+        "process_expression": process.casefold(),
+        "selector_contract": selector,
+        "validation": validation,
+        "artifact_semantic_identity": semantic_identity,
+        "artifact_semantic_identity_sha256": semantic_sha256,
+        "profiles": [
+            {
+                "batch_size": batch_size,
+                "sample_count": 7,
+                "wall_seconds_per_point": 1.0e-6,
+                "wall_seconds_per_point_median": 1.0e-6,
+                "wall_seconds_per_point_mad": 1.0e-8,
+                "interrupted": False,
+                "subprocess_samples": [],
+            }
+            for batch_size in ladder.DEFAULT_BATCH_SIZES
+        ],
+    }
+    profile_schedule = {
+        "kind": "pyamplicol-interleaved-subprocess-profile-schedule",
+        "schema_version": 2,
+        "entries": [],
+    }
+    source = {"git_revision": "1" * 40}
+    runtime_provenance = {"extension_sha256": "2" * 64}
+    observed_configuration = {
+        "modes": ["recurrence"],
+        "generation_only": False,
+        "batch_sizes": [1, 128, 1024],
+        "target_runtime_seconds": 5.0,
+        "warmup_runs": 2,
+        "minimum_internal_samples": 7,
+        "subprocess_samples": 7,
+        "gluon_count": 5,
+        "process_expression_override": process,
+        "lc_flow_layout": "all-flow-union",
+        "color_flow_request": "1",
+        "helicity_request": "1",
+        "validation_samples": 10,
+        "point_tile_size": 1024,
+        "jit_optimization_level": 2,
+        "specialize_flow_at_generation": False,
+        "prepared_model_path": "/workspace/model.pack",
+    }
+    bindings = {
+        "source_identity_sha256": ladder._canonical_sha256(source),
+        "runtime_provenance_sha256": ladder._canonical_sha256(runtime_provenance),
+        "generation_artifact_id": artifact_id,
+        "generation_artifact_semantic_identity_sha256": semantic_sha256,
+        "profile_schedule_sha256": ladder._canonical_sha256(profile_schedule),
+        "recurrence_profile_sha256": ladder._canonical_sha256(recurrence_profile),
+        "selector_contract": selector,
+        "selector_contract_sha256": ladder._canonical_sha256(selector),
+        "validation_fixture": fixture,
+        "validation_fixture_sha256": ladder._canonical_sha256(fixture),
+        "process_id": "process",
+        "process_expression": process.casefold(),
+        "lc_flow_layout": "all-flow-union",
+        "configuration": observed_configuration,
+        "configuration_sha256": ladder._canonical_sha256(observed_configuration),
+    }
+    acceptance = {
+        "kind": ladder.RUNTIME_ACCEPTANCE_KIND,
+        "schema_version": ladder.RUNTIME_ACCEPTANCE_SCHEMA_VERSION,
+        "accepted": True,
+        "status": "accepted",
+        "errors": [],
+        "required": {
+            "modes": ["recurrence"],
+            "generation_only": False,
+            "batch_sizes": [1, 128, 1024],
+            "target_runtime_seconds": 5.0,
+            "warmup_runs": 2,
+            "minimum_internal_samples": 7,
+            "subprocess_samples_minimum": 7,
+            "subprocess_samples_maximum": 21,
+            "process_family": "d d~ > Z + (n-1)*g",
+            "accepted_n_values": [6, 7],
+            "generation_specialized_axes_allowed": False,
+            "complete_physical_axes_required": True,
+        },
+        "contracts": {
+            "measurement": {"passes": True},
+            "artifact_semantics": {"passes": True},
+            "lane_validation": {
+                "passes": True,
+                "lane_validation_passes": True,
+                "selectors_match": True,
+                "fixtures_match": True,
+                "pairwise_validation_passes": None,
+                "summary_sha256": "6" * 64,
+            },
+            "worker_rss": {
+                "passes": True,
+                "errors": [],
+                "worker_count": 21,
+                "maximum_cold_load_observed_lower_bound_bytes": 1024,
+                "maximum_post_profile_observed_lower_bound_bytes": 2048,
+            },
+        },
+        "bindings": bindings,
+    }
+    acceptance["content_sha256"] = ladder._canonical_sha256(acceptance)
+    result = {
+        "kind": ladder.HARNESS_KIND,
+        "schema_version": ladder.HARNESS_SCHEMA_VERSION,
+        "complete": False,
+        "passes": None,
+        "process": process,
+        "configuration": configuration,
+        "source": source,
+        "runtime_provenance": runtime_provenance,
+        "provenance": {"wall_seconds": 12.0},
+        "generation": {
+            "recurrence": {
+                "mode": "recurrence",
+                "artifact": str(artifact),
+                "artifact_identity": artifact_identity,
+                "artifact_semantic_identity_sha256": semantic_sha256,
+                "generation_reused": False,
+                "generation_wall_seconds": 9.0,
+                "worker_process_record": {"wall_seconds": 8.0},
+                "peak_rss": {"observed_lower_bound_bytes": 1234},
+                "phase_timings_seconds": {"recurrence-construction": 6.0},
+                "phase_total_seconds": 6.0,
+            }
+        },
+        "profile_schedule": profile_schedule,
+        "profiles": {"recurrence": recurrence_profile},
+        "recurrence_runtime_acceptance": acceptance,
+    }
+    result_path = tmp_path / "runtime-result.json"
+    _write_json(result_path, result)
+    return result_path
+
+
+def test_runtime_result_has_an_independent_fail_closed_acceptance(
+    tmp_path: Path,
+) -> None:
+    result_path = _write_runtime_acceptance_result(tmp_path)
+    summary = ladder.parse_harness_result(result_path)
+    acceptance = summary["recurrence_runtime_acceptance"]
+    assert acceptance["passes"] is True
+    assert acceptance["worker_count"] == 21
+    assert acceptance["maximum_cold_load_observed_lower_bound_bytes"] == 1024
+    assert acceptance["maximum_post_profile_observed_lower_bound_bytes"] == 2048
+    assert (
+        ladder._sample_status(
+            ladder.ProcessOutcome(
+                exit_code=0,
+                timed_out=False,
+                wall_seconds=12.0,
+                error=None,
+            ),
+            watchdog={"terminal_record": "command-finished"},
+            result_error=None,
+            harness_summary=summary,
+            allow_diagnostic_incomplete_success=True,
+        )
+        == "passed"
+    )
+
+
+def test_runtime_acceptance_rejects_tampered_digest_and_configuration(
+    tmp_path: Path,
+) -> None:
+    result_path = _write_runtime_acceptance_result(tmp_path)
+    result = json.loads(result_path.read_text(encoding="utf-8"))
+    result["recurrence_runtime_acceptance"]["content_sha256"] = "0" * 64
+    _write_json(result_path, result)
+    with pytest.raises(ladder.LadderError, match="address is invalid"):
+        ladder.parse_harness_result(result_path)
+
+    result_path = _write_runtime_acceptance_result(tmp_path)
+    result = json.loads(result_path.read_text(encoding="utf-8"))
+    result["configuration"]["lc_flow_layout"] = "topology-replay"
+    _write_json(result_path, result)
+    with pytest.raises(ladder.LadderError, match="bindings failed authentication"):
+        ladder.parse_harness_result(result_path)
+
+
+def test_runtime_n_must_be_selected_in_generation_ladder() -> None:
+    with pytest.raises(ladder.LadderError, match="runtime-n"):
+        ladder.build_schedule(
+            (2,),
+            ("topology-replay",),
+            1,
+            frozenset({6}),
+        )
diff --git a/pyamplicol/tests/unit/test_recurrence_generation_telemetry.py b/pyamplicol/tests/unit/test_recurrence_generation_telemetry.py
new file mode 100644
index 0000000000..aeb0956ce9
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_generation_telemetry.py
@@ -0,0 +1,220 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.generation import artifact_writer
+from pyamplicol.generation import service as generation_service
+from pyamplicol.generation.recurrence_schedule_sharing import (
+    RecurrenceProcessExecutorPack,
+)
+
+
+def _native_profile() -> dict[str, object]:
+    return {
+        "schema_version": 1,
+        "scope": "generation-only",
+        "timings_seconds": {
+            name: 0.125
+            for name in generation_service._RECURRENCE_GENERATION_PROFILE_TIMINGS
+        },
+        "operation_counters": {
+            name: 7
+            for name in generation_service._RECURRENCE_GENERATION_PROFILE_COUNTERS
+        },
+        "serialized_bytes": {
+            "plan_payload": 13,
+            "container": 37,
+            "unpacked_container": 19,
+        },
+    }
+
+
+def _inspection() -> dict[str, object]:
+    return {
+        "runtime_container_member": {
+            "size_bytes": 13,
+            "container_size_bytes": 37,
+        }
+    }
+
+
+def _recurrence_artifact(
+    process_id: str,
+    profile: dict[str, object],
+) -> artifact_writer.RecurrenceProcessArtifact:
+    return artifact_writer.RecurrenceProcessArtifact(
+        process_id=process_id,
+        expression="d d~ > Z g",
+        color_accuracy="lc",
+        external_pdgs=(1, -1, 23, 21),
+        aliases=(),
+        physics={},
+        recurrence_schedule_path=Path("recurrence-runtime.pacbin"),
+        recurrence_schedule_digest="a" * 64,
+        recurrence_native_schedule_semantic_digest="b" * 64,
+        recurrence_schedule_size_bytes=37,
+        recurrence_schedule_sha256="c" * 64,
+        recurrence_schedule_member_count=1,
+        recurrence_schedule_unpacked_size_bytes=19,
+        recurrence_schedule_index_sha256="d" * 64,
+        builder_input_sha256="e" * 64,
+        prepared_kernel_pack_digest="f" * 64,
+        direct_template_catalog_digest="1" * 64,
+        referenced_kernel_ids=frozenset(),
+        inspection_summary={},
+        runtime_metadata={},
+        color_contraction_payload=None,
+        color_contraction_summary=None,
+        point_tile_size=1,
+        workspace_mib=1,
+        recurrence_summary={},
+        validation_point=None,  # type: ignore[arg-type]
+        generation_filters={},
+        generation_profile=profile,
+        recurrence_process_remap=None,  # type: ignore[arg-type]
+        recurrence_process_executor_pack=RecurrenceProcessExecutorPack(
+            compiled_model_digest="2" * 64,
+            recurrence_template_catalog_digest="3" * 64,
+            prepared_kernel_pack_digest="f" * 64,
+            direct_template_catalog_digest="1" * 64,
+            runtime_layout_digest="4" * 64,
+            backend="jit",
+            target_triple="symjit-storage-v3-portable",
+            portable=True,
+            cpu_features=(),
+            catalog_executor_count=1,
+            executor_ids=(0,),
+            descriptor_payloads=(bytes.fromhex("10000000000000000000000001000000"),),
+        ),
+        process_digest="5" * 64,
+    )
+
+
+def test_generation_profile_is_strict_and_generation_only() -> None:
+    profile = _native_profile()
+
+    normalized = generation_service._validate_recurrence_generation_profile(
+        profile,
+        inspection=_inspection(),
+        unpacked_size_bytes=19,
+    )
+
+    assert normalized == profile
+    assert (
+        normalized["operation_counters"]["constructed_interaction_count"]  # type: ignore[index]
+        == 7
+    )
+    assert (
+        normalized["operation_counters"]["emitted_interaction_count"]  # type: ignore[index]
+        == 7
+    )
+    assert (
+        normalized["operation_counters"]["indexed_hash_lookup_count"]  # type: ignore[index]
+        == 7
+    )
+
+
+def test_generation_profile_is_keyed_by_shared_schedule_digest() -> None:
+    wrapped = {
+        "schema_version": 1,
+        "native_passes": {"final": _native_profile()},
+    }
+    processes = (
+        _recurrence_artifact("first", wrapped),
+        _recurrence_artifact("second", copy.deepcopy(wrapped)),
+    )
+
+    extensions = artifact_writer._extensions(
+        None,
+        processes=processes,
+        timings={},
+        api_bundle_requested=False,
+        api_bundle_path=None,
+        eager_pack_identity=None,
+        execution_manifest_sha256_by_process={
+            "first": "2" * 64,
+            "second": "3" * 64,
+        },
+        evaluator_payload_container=None,
+        recurrence_schedule_sharing=None,
+    )
+
+    assert extensions["generation"]["recurrence_schedule_profiles"] == {  # type: ignore[index]
+        "a" * 64: wrapped
+    }
+
+
+def test_generation_profile_rejects_inconsistent_shared_schedule_claims() -> None:
+    left = {
+        "schema_version": 1,
+        "native_passes": {"final": _native_profile()},
+    }
+    right = copy.deepcopy(left)
+    right["native_passes"]["final"]["operation_counters"][  # type: ignore[index]
+        "emitted_current_count"
+    ] = 8
+
+    with pytest.raises(ValueError, match="inconsistent generation telemetry"):
+        artifact_writer._extensions(
+            None,
+            processes=(
+                _recurrence_artifact("first", left),
+                _recurrence_artifact("second", right),
+            ),
+            timings={},
+            api_bundle_requested=False,
+            api_bundle_path=None,
+            eager_pack_identity=None,
+            execution_manifest_sha256_by_process={
+                "first": "2" * 64,
+                "second": "3" * 64,
+            },
+            evaluator_payload_container=None,
+            recurrence_schedule_sharing=None,
+        )
+
+
+@pytest.mark.parametrize(
+    ("mutate", "message"),
+    [
+        (
+            lambda profile: profile["timings_seconds"].__setitem__(  # type: ignore[union-attr]
+                "candidate-processing",
+                float("nan"),
+            ),
+            "timing",
+        ),
+        (
+            lambda profile: profile["operation_counters"].__setitem__(  # type: ignore[union-attr]
+                "unknown",
+                1,
+            ),
+            "fields do not match",
+        ),
+        (
+            lambda profile: profile["serialized_bytes"].__setitem__(  # type: ignore[union-attr]
+                "container",
+                38,
+            ),
+            "disagrees",
+        ),
+    ],
+)
+def test_generation_profile_rejects_invalid_or_unlinked_claims(
+    mutate: Callable[[dict[str, object]], None],
+    message: str,
+) -> None:
+    profile = copy.deepcopy(_native_profile())
+    mutate(profile)
+
+    with pytest.raises(generation_service.GenerationError, match=message):
+        generation_service._validate_recurrence_generation_profile(
+            profile,
+            inspection=_inspection(),
+            unpacked_size_bytes=19,
+        )
diff --git a/pyamplicol/tests/unit/test_recurrence_multiline_color.py b/pyamplicol/tests/unit/test_recurrence_multiline_color.py
new file mode 100644
index 0000000000..0c12e1cca5
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_multiline_color.py
@@ -0,0 +1,193 @@
+# SPDX-License-Identifier: 0BSD
+"""Adversarial contracts for ordered multi-open-line recurrence color state."""
+
+from __future__ import annotations
+
+import hashlib
+
+import pytest
+
+from pyamplicol import _rusticol
+from pyamplicol.generation.recurrence_columnar import (
+    ExactComplexRationalV1,
+    RecurrenceBuilderInputV1,
+    RecurrenceBuilderLogicalInputV1,
+    RecurrenceExternalLegV1,
+    RecurrenceLCOpenStringV1,
+    RecurrenceNormalizationV1,
+    RecurrencePhysicalLCSectorV1,
+    RecurrencePublicLCFlowV1,
+    RecurrenceSemanticDigestV1,
+    RecurrenceSemanticTemplateReferenceV1,
+    RecurrenceSourceStateV1,
+    build_recurrence_builder_input_v1,
+)
+
+
+def _sha256(label: str) -> str:
+    return hashlib.sha256(label.encode("ascii")).hexdigest()
+
+
+def _source_leg(source_slot: int) -> RecurrenceExternalLegV1:
+    state_template_id = 100 + source_slot
+    source_template_id = 200 + source_slot
+    return RecurrenceExternalLegV1(
+        source_slot=source_slot,
+        public_label=source_slot + 1,
+        physical_pdg=source_slot + 1,
+        outgoing_pdg=source_slot + 1,
+        is_initial=source_slot < 2,
+        is_fermionic=True,
+        source_states=(
+            RecurrenceSourceStateV1(
+                state_index=0,
+                public_helicity=-1 if source_slot % 2 == 0 else 1,
+                chirality=0,
+                spin_state=0,
+                current_state_template_id=state_template_id,
+                source_template_id=source_template_id,
+            ),
+        ),
+        momentum_mask=1 << source_slot,
+        support_mask=1 << source_slot,
+    )
+
+
+def _three_open_line_logical_input() -> RecurrenceBuilderLogicalInputV1:
+    """Two sectors differing only by the order of passive open-line blocks."""
+
+    line_a = RecurrenceLCOpenStringV1(0, 1)
+    line_b = RecurrenceLCOpenStringV1(2, 3)
+    line_c = RecurrenceLCOpenStringV1(4, 5)
+    sectors = (
+        RecurrencePhysicalLCSectorV1(
+            sector_id=0,
+            public_id="flow:1,2|3,4|5,6",
+            kind="open-lines",
+            closure_source_slot=5,
+            closure_proof_algorithm="canonical-lc-closure-anchor-v2",
+            closure_proof_digest=_sha256("closure:abc"),
+            open_strings=(line_a, line_b, line_c),
+            word_source_slots=(0, 1, 2, 3, 4, 5),
+            support_mask=0b11_1111,
+        ),
+        RecurrencePhysicalLCSectorV1(
+            sector_id=1,
+            public_id="flow:3,4|1,2|5,6",
+            kind="open-lines",
+            closure_source_slot=5,
+            closure_proof_algorithm="canonical-lc-closure-anchor-v2",
+            closure_proof_digest=_sha256("closure:bac"),
+            open_strings=(line_b, line_a, line_c),
+            word_source_slots=(2, 3, 0, 1, 4, 5),
+            support_mask=0b11_1111,
+        ),
+    )
+    references = tuple(
+        RecurrenceSemanticTemplateReferenceV1(
+            kind=kind,
+            template_id=base + source_slot,
+            semantic_digest=_sha256(f"{kind}:{source_slot}"),
+            prepared_kernel_id=(300 + source_slot if kind == "source" else None),
+        )
+        for kind, base in (("current-state", 100), ("source", 200))
+        for source_slot in range(6)
+    )
+    return RecurrenceBuilderLogicalInputV1(
+        process_id="synthetic_three_open_lines",
+        layout="all-flow-union",
+        semantic_digests=tuple(
+            RecurrenceSemanticDigestV1(role, _sha256(role))
+            for role in (
+                "process",
+                "model-catalog",
+                "prepared-catalog",
+                "color-plan",
+            )
+        ),
+        external_legs=tuple(_source_leg(slot) for slot in range(6)),
+        physical_sectors=sectors,
+        public_flows=tuple(
+            RecurrencePublicLCFlowV1(
+                flow_id=sector.sector_id,
+                public_id=sector.public_id,
+                construction_sector_id=sector.sector_id,
+                word_source_slots=sector.word_source_slots,
+                source_slot_permutation=tuple(range(6)),
+            )
+            for sector in sectors
+        ),
+        semantic_template_references=references,
+        normalization=RecurrenceNormalizationV1(
+            ExactComplexRationalV1(1),
+            "synthetic-adversarial-v1",
+            _sha256("normalization"),
+        ),
+        process_support_mask=0b11_1111,
+    )
+
+
+def _table_rows(
+    value: RecurrenceBuilderInputV1,
+    table_name: str,
+    *columns: str,
+) -> tuple[tuple[int, ...], ...]:
+    table = next(table for table in value.tables if table.name == table_name)
+    return tuple(
+        tuple(int(table.column(column)[row]) for column in columns)
+        for row in range(table.row_count)
+    )
+
+
+def test_columnar_input_preserves_passive_open_line_forest_order() -> None:
+    """Python must not canonicalize independent open-line blocks by sorting."""
+
+    encoded = build_recurrence_builder_input_v1(_three_open_line_logical_input())
+
+    rows = _table_rows(
+        encoded,
+        "lc_open_strings",
+        "sector_id",
+        "ordinal",
+        "fundamental_source_slot",
+        "antifundamental_source_slot",
+    )
+    assert rows == (
+        (0, 0, 0, 1),
+        (0, 1, 2, 3),
+        (0, 2, 4, 5),
+        (1, 0, 2, 3),
+        (1, 1, 0, 1),
+        (1, 2, 4, 5),
+    )
+
+
+@pytest.mark.xfail(
+    strict=True,
+    reason=(
+        "the native inspection API does not yet expose ordered dynamic LC forests; "
+        "it must return each state's ordered component words and active index"
+    ),
+)
+def test_native_schedule_keeps_permuted_passive_forests_distinct() -> None:
+    """A and B passive blocks may alias only with an exact permutation witness.
+
+    Required production contract: a bounded native schedule-inspection operation
+    accepting authenticated process/template inputs and returning ordered dynamic
+    LC component words, active indices, and any exact permutation certificate.
+    Merely returning ``dynamic_color_state_count`` cannot prove this invariant.
+    """
+
+    inspect_schedule = vars(_rusticol)["_inspect_recurrence_schedule_v1"]
+    inspection = inspect_schedule(
+        build_recurrence_builder_input_v1(_three_open_line_logical_input())
+    )
+    states = inspection["dynamic_lc_color_states"]
+    abc = ((0, 1), (2, 3), (4, 5))
+    bac = ((2, 3), (0, 1), (4, 5))
+    by_components = {tuple(map(tuple, row["components"])): row for row in states}
+    assert abc in by_components
+    assert bac in by_components
+    assert by_components[abc]["state_id"] != by_components[bac]["state_id"]
+    assert by_components[abc].get("permutation_certificate") is None
+    assert by_components[bac].get("permutation_certificate") is None
diff --git a/pyamplicol/tests/unit/test_recurrence_numerical_ab_parity.py b/pyamplicol/tests/unit/test_recurrence_numerical_ab_parity.py
new file mode 100644
index 0000000000..6f5a497f07
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_numerical_ab_parity.py
@@ -0,0 +1,1015 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+import os
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tools.developer import recurrence_numerical_ab_parity as parity
+
+PROCESS_KEY, PROCESS_EXPRESSION = parity.PROCESS_CASES[0]
+
+
+def test_file_identity_matches_harness_explicit_model_identity(
+    tmp_path: Path,
+) -> None:
+    prepared_model = tmp_path / "model.pack"
+    prepared_model.write_bytes(b"prepared-model")
+
+    assert parity._path_identity(
+        prepared_model.resolve()
+    ) == parity.harness._path_identity(prepared_model.resolve())
+
+
+def _selector_contract(layout: str) -> dict[str, object]:
+    if layout == "topology-replay":
+        body: dict[str, object] = {
+            "workload": "single-runtime-selected-flow/helicity-sum",
+            "physical_color_ids": ["c:1"],
+            "physical_helicity_ids": ["h:-1,+1", "h:+1,-1"],
+            "structural_zero_helicity_ids": [],
+            "selected_color_flow_ids": ["c:1"],
+            "selected_helicity_ids": [],
+        }
+    else:
+        body = {
+            "workload": "all-flows/runtime-selected-single-helicity",
+            "physical_color_ids": ["c:1"],
+            "physical_helicity_ids": ["h:-1,+1", "h:+1,-1"],
+            "structural_zero_helicity_ids": [],
+            "selected_color_flow_ids": [],
+            "selected_helicity_ids": ["h:-1,+1"],
+        }
+    return {
+        **body,
+        "contract_sha256": parity._canonical_sha256(body),
+    }
+
+
+def _capture(
+    variant: str,
+    *,
+    layout: str = "topology-replay",
+    process_key: str = PROCESS_KEY,
+    process_expression: str = PROCESS_EXPRESSION,
+    checkout: str | None = None,
+    prepared_model_identity: dict[str, object] | None = None,
+    source_revision: str | None = None,
+) -> dict[str, object]:
+    points = [
+        [
+            [50.0, 0.0, 0.0, 50.0],
+            [50.0, 0.0, 0.0, -50.0],
+        ]
+    ]
+    semantic = {
+        "coverage": {
+            "color": "complete",
+            "helicities": "complete",
+            "complete_physical_axes": True,
+        },
+        "physical_color_flows": {
+            "count": 1,
+            "ordered_entries": [{"id": "c:1", "index": 0}],
+            "ordered_ids": ["c:1"],
+        },
+        "physical_helicities": {
+            "count": 2,
+            "ordered_entries": [
+                {
+                    "id": "h:-1,+1",
+                    "index": 0,
+                    "structural_zero": False,
+                },
+                {
+                    "id": "h:+1,-1",
+                    "index": 1,
+                    "structural_zero": False,
+                },
+            ],
+            "ordered_ids": ["h:-1,+1", "h:+1,-1"],
+        },
+        "normalization": {"kind": "squared-matrix-element"},
+        "manifest_model_identity": {"name": "built-in-sm", "sha256": "a" * 64},
+        "runtime_selector_semantics": {
+            "color": "sum",
+            "helicity": "sum",
+            "generation_specialized_axes": [],
+        },
+        "reduction_ordering": {
+            "axes": ["helicity", "color"],
+            "component_order": "helicity-major/color-minor",
+        },
+        "execution_reduction_identity": {"kind": "ordered-complex-sum"},
+        "execution_reduction_coverage": {
+            "complete": True,
+            "errors": [],
+        },
+        "generation_specialized_axes": [],
+    }
+    parameter_payload = {"alpha_s": 0.118, "mu_r": 91.1876}
+    prepared_model = prepared_model_identity or {
+        "path": f"/source/{variant}/model.pack",
+        "size_bytes": 10,
+        "sha256": "a" * 64,
+    }
+    artifact_id = "c" * 64
+    source_checkout = checkout or f"/source/{variant}"
+    revision = source_revision or parity.EXPECTED_SOURCE_REVISIONS[variant]
+    artifact_root = f"/artifact/{variant}"
+    native_identity = {
+        "path": f"/runtime/{variant}/_rusticol.so",
+        "size_bytes": 100,
+        "sha256": "d" * 64,
+    }
+    build_info_identity = {
+        "path": f"/runtime/{variant}/_build_info.json",
+        "size_bytes": 100,
+        "sha256": "e" * 64,
+    }
+    model_manifest = {
+        "name": "built-in-sm",
+        "content_sha256": "a" * 64,
+    }
+    common_model_identity = {
+        "name": "built-in-sm",
+        "content_sha256": "a" * 64,
+    }
+
+    def loaded_verification(phase: str) -> dict[str, object]:
+        return {
+            "kind": "pyamplicol-loaded-runtime-artifact-verification",
+            "schema_version": 1,
+            "phase": phase,
+            "checked_at_utc": "2026-07-31T00:00:00Z",
+            "expected_artifact_id": artifact_id,
+            "loaded_artifact_id": artifact_id,
+            "passes": True,
+        }
+
+    resolved_helicity_ids = (
+        ["h:-1,+1", "h:+1,-1"] if layout == "topology-replay" else ["h:-1,+1"]
+    )
+    resolved_components = (
+        [[[1.0, 0.0], [2.0, 0.0]]] if layout == "topology-replay" else [[[3.0, 0.0]]]
+    )
+    validation = {
+        "fixture": {
+            "file": {
+                "path": f"{artifact_root}/processes/process/validation-momenta.json",
+                "size_bytes": 100,
+                "sha256": "b" * 64,
+            },
+            "point_count": 1,
+            "points_sha256": parity._canonical_sha256(points),
+            "points": points,
+        },
+        "selector_contract": _selector_contract(layout),
+        "selected_totals": [[3.0, 0.0]],
+        "resolved_sums": [[3.0, 0.0]],
+        "resolved_helicity_ids": resolved_helicity_ids,
+        "resolved_color_ids": ["c:1"],
+        "resolved_components": resolved_components,
+        "point_comparisons": [
+            {
+                "point_index": 0,
+                "selected_total": [3.0, 0.0],
+                "resolved_sum": [3.0, 0.0],
+                "absolute_difference": 0.0,
+                "relative_difference": 0.0,
+                "passes": True,
+            }
+        ],
+        "maximum_absolute_difference": 0.0,
+        "maximum_relative_difference": 0.0,
+        "passes": True,
+    }
+    return parity._content_address(
+        {
+            "kind": parity.CAPTURE_KIND,
+            "schema_version": parity.CAPTURE_SCHEMA,
+            "variant": variant,
+            "process_key": process_key,
+            "requested_process": process_expression,
+            "observed_process": process_expression.lower(),
+            "layout": layout,
+            "generation_request": parity._generation_request(
+                validation_samples=1,
+                point_tile_size=1024,
+                jit_optimization_level=2,
+            ),
+            "source": {
+                "checkout": source_checkout,
+                "revision": revision,
+                "dirty": False,
+                "untracked_files_checked": True,
+            },
+            "runtime_provenance": {
+                "interpreter": {
+                    "path": "/runtime/python",
+                    "size_bytes": 100,
+                    "sha256": "2" * 64,
+                    "python_version": "3.12.6",
+                    "implementation": "CPython",
+                },
+                "installed_distribution": {
+                    "package_version": "0.1.0",
+                    "distribution_content": {
+                        "algorithm": "sha256-relative-path-size-content-v1",
+                        "file_count": 2,
+                        "size_bytes": 200,
+                        "sha256": "3" * 64,
+                    },
+                    "native_modules": [native_identity],
+                    "build_info_files": [build_info_identity],
+                },
+                "active_build_info": {
+                    **build_info_identity,
+                    "payload": {
+                        "source_checkout": source_checkout,
+                        "source_revision": revision,
+                        "native_build_inputs_sha256": "4" * 64,
+                    },
+                },
+                "native_extension": {
+                    **native_identity,
+                    "package_version": "0.1.0",
+                    "build_inputs_sha256": "4" * 64,
+                },
+                "dependencies": {
+                    "Cargo.lock": {
+                        "present": True,
+                        "path": f"{source_checkout}/Cargo.lock",
+                        "resolved_path": f"{source_checkout}/Cargo.lock",
+                        "size_bytes": 100,
+                        "sha256": "5" * 64,
+                    }
+                },
+            },
+            "prepared_model": prepared_model,
+            "generation": {
+                "mode": "recurrence",
+                "generation_reused": False,
+                "model_source": {
+                    "kind": "explicit-prepared-model",
+                    "file": prepared_model,
+                    "compile_excluded_from_generation": True,
+                },
+            },
+            "artifact": {
+                "path": artifact_root,
+                "artifact_id": artifact_id,
+                "manifest": {
+                    "path": f"{artifact_root}/artifact.json",
+                    "size_bytes": 100,
+                    "sha256": "6" * 64,
+                },
+                "tree": {
+                    "algorithm": "sha256-relative-path-size-content-v1",
+                    "file_count": 4,
+                    "size_bytes": 400,
+                    "sha256": "7" * 64,
+                },
+                "payloads": [
+                    {
+                        "path": "config/effective.toml",
+                        "role": "configuration-effective",
+                        "process_id": None,
+                        "size_bytes": 100,
+                        "sha256": "8" * 64,
+                    },
+                    {
+                        "path": "model/parameters.json",
+                        "role": "model-parameters",
+                        "process_id": None,
+                        "size_bytes": 100,
+                        "sha256": "9" * 64,
+                    },
+                    {
+                        "path": "processes/process/validation-momenta.json",
+                        "role": "validation-momenta",
+                        "process_id": "process",
+                        "size_bytes": 100,
+                        "sha256": "b" * 64,
+                    },
+                ],
+                "process_id": "process",
+                "process_expression": process_expression,
+                "color_accuracy": "lc",
+                "producer": {"version": "0.1.0"},
+                "model_identity": {
+                    "manifest": model_manifest,
+                    "manifest_sha256": parity._canonical_sha256(model_manifest),
+                    "common_physics_identity": common_model_identity,
+                    "common_physics_identity_sha256": parity._canonical_sha256(
+                        common_model_identity
+                    ),
+                },
+                "semantic_identity": semantic,
+                "semantic_identity_sha256": parity._canonical_sha256(semantic),
+            },
+            "effective_contract": {
+                "execution_mode": "recurrence",
+                "backend": "jit",
+                "color_accuracy": "lc",
+                "lc_flow_layout": layout,
+                "jit_optimization_level": 2,
+            },
+            "parameters": {
+                "file": {
+                    "path": f"{artifact_root}/model/parameters.json",
+                    "size_bytes": 100,
+                    "sha256": "9" * 64,
+                },
+                "payload": parameter_payload,
+                "payload_sha256": parity._canonical_sha256(parameter_payload),
+            },
+            "loaded_artifact_verification": {
+                "before_evaluation": loaded_verification(
+                    "before-numerical-parity-evaluation"
+                ),
+                "after_evaluation": loaded_verification(
+                    "after-numerical-parity-evaluation"
+                ),
+            },
+            "validation": validation,
+            "tolerances": {
+                "absolute": parity.ABSOLUTE_TOLERANCE,
+                "relative": parity.RELATIVE_TOLERANCE,
+            },
+        }
+    )
+
+
+def _readdress(capture: dict[str, object]) -> dict[str, object]:
+    capture.pop("content_sha256", None)
+    return parity._content_address(capture)
+
+
+def _compare(
+    baseline: dict[str, object],
+    candidate: dict[str, object],
+    *,
+    layout: str = "topology-replay",
+) -> dict[str, object]:
+    return parity._compare_captures(
+        baseline,
+        candidate,
+        process_key=PROCESS_KEY,
+        process_expression=PROCESS_EXPRESSION,
+        layout=layout,
+    )
+
+
+def test_acceptance_matrix_and_defaults_are_fixed() -> None:
+    assert parity.PROCESS_CASES == (
+        ("dd_z_4g", "d d~ > Z g g g g"),
+        ("dd_tt_3g", "d d~ > t t~ g g g"),
+        ("gg_4g", "g g > g g g g"),
+    )
+    assert parity.LAYOUTS == ("topology-replay", "all-flow-union")
+    assert parity.EXPECTED_SOURCE_REVISIONS == {
+        "baseline": "172e58fd33a3c65563866c50cfbb5e1ddcd7b302",
+        "candidate": "4e2b1e02dddde2d55b7250cbd52a93001f09b2c2",
+    }
+    assert parity.WATCHDOG_LIMIT_GIB == 30.0
+    assert parity.ABSOLUTE_TOLERANCE == 1.0e-15
+    assert parity.RELATIVE_TOLERANCE == 1.0e-12
+    assert parity.DEFAULT_VALIDATION_SAMPLES == 10
+    assert (
+        parity._generation_request(
+            validation_samples=10,
+            point_tile_size=1024,
+            jit_optimization_level=2,
+        )["specialize_flow_at_generation"]
+        is False
+    )
+
+
+def test_value_comparison_uses_strict_absolute_or_relative_tolerance() -> None:
+    exact = parity._value_comparison([2.0, -1.0], [2.0, -1.0])
+    relative = parity._value_comparison([1.0e6, 0.0], [1.0e6 + 1.0e-7, 0.0])
+    failure = parity._value_comparison([1.0, 0.0], [1.0 + 1.0e-8, 0.0])
+
+    assert exact["passes"] is True
+    assert relative["absolute_difference"] > parity.ABSOLUTE_TOLERANCE
+    assert relative["passes"] is True
+    assert failure["passes"] is False
+
+
+def test_workload_selection_is_deterministic_and_skips_structural_zeros() -> None:
+    physics = SimpleNamespace(
+        color_flows=(
+            SimpleNamespace(id="c:first"),
+            SimpleNamespace(id="c:second"),
+        ),
+        helicities=(
+            SimpleNamespace(id="h:zero", structural_zero=True),
+            SimpleNamespace(id="h:first-live", structural_zero=False),
+            SimpleNamespace(id="h:second-live", structural_zero=False),
+        ),
+    )
+
+    topology_selectors, topology_contract = parity._select_workload(
+        physics,
+        layout="topology-replay",
+    )
+    union_selectors, union_contract = parity._select_workload(
+        physics,
+        layout="all-flow-union",
+    )
+
+    assert topology_selectors == {"color_flows": ("c:first",)}
+    assert topology_contract["selected_color_flow_ids"] == ["c:first"]
+    assert union_selectors == {"helicities": ("h:first-live",)}
+    assert union_contract["selected_helicity_ids"] == ["h:first-live"]
+    assert union_contract["structural_zero_helicity_ids"] == ["h:zero"]
+    for contract in (topology_contract, union_contract):
+        body = {
+            key: value for key, value in contract.items() if key != "contract_sha256"
+        }
+        assert contract["contract_sha256"] == parity._canonical_sha256(body)
+
+
+@pytest.mark.parametrize(
+    ("layout", "component_count"),
+    (("topology-replay", 2), ("all-flow-union", 1)),
+)
+def test_matching_captures_emit_content_addressed_point_component_and_selector_evidence(
+    layout: str,
+    component_count: int,
+) -> None:
+    comparison = _compare(
+        _capture("baseline", layout=layout),
+        _capture("candidate", layout=layout),
+        layout=layout,
+    )
+
+    assert comparison["passes"] is True
+    parity._validate_content_address(
+        comparison,
+        kind=parity.COMPARISON_KIND,
+        schema_version=parity.COMPARISON_SCHEMA,
+        label="comparison",
+    )
+    assert comparison["summary"] == {
+        "point_count": 1,
+        "resolved_component_count": component_count,
+        "maximum_absolute_point_difference": 0.0,
+        "maximum_relative_point_difference": 0.0,
+        "maximum_absolute_component_difference": 0.0,
+        "maximum_relative_component_difference": 0.0,
+    }
+    records = [
+        comparison["fixture_comparison"],
+        comparison["selector_comparison"],
+        comparison["parameter_comparison"],
+        *comparison["pointwise_comparisons"],
+        *comparison["resolved_component_comparisons"],
+    ]
+    assert all(
+        record["content_sha256"]
+        == parity._canonical_sha256(
+            {key: value for key, value in record.items() if key != "content_sha256"}
+        )
+        for record in records
+    )
+    observed_components = [
+        (entry["point_index"], entry["helicity_id"], entry["color_id"])
+        for entry in comparison["resolved_component_comparisons"]
+    ]
+    expected_components = [(0, "h:-1,+1", "c:1")]
+    if layout == "topology-replay":
+        expected_components.append((0, "h:+1,-1", "c:1"))
+    assert observed_components == expected_components
+
+
+def test_point_and_resolved_component_drift_fail_independently() -> None:
+    def set_components(
+        capture: dict[str, object],
+        components: list[list[float]],
+    ) -> dict[str, object]:
+        validation = capture["validation"]
+        total = sum((complex(*component) for component in components), 0.0j)
+        total_payload = [total.real, total.imag]
+        validation["resolved_components"][0] = components
+        validation["selected_totals"][0] = total_payload
+        validation["resolved_sums"][0] = total_payload
+        validation["point_comparisons"][0].update(
+            {
+                "selected_total": total_payload,
+                "resolved_sum": total_payload,
+                "absolute_difference": 0.0,
+                "relative_difference": 0.0,
+                "passes": True,
+            }
+        )
+        validation["maximum_absolute_difference"] = 0.0
+        validation["maximum_relative_difference"] = 0.0
+        validation["passes"] = True
+        return _readdress(capture)
+
+    point_baseline = set_components(
+        _capture("baseline"),
+        [[1.0e9, 0.0], [-999_999_997.0, 0.0]],
+    )
+    point_candidate = set_components(
+        _capture("candidate"),
+        [[1.0e9 + 5.0e-4, 0.0], [-999_999_997.0 + 5.0e-4, 0.0]],
+    )
+
+    point_comparison = _compare(point_baseline, point_candidate)
+    assert point_comparison["passes"] is False
+    assert point_comparison["pointwise_comparisons"][0]["passes"] is False
+    assert all(
+        entry["passes"] for entry in point_comparison["resolved_component_comparisons"]
+    )
+
+    component_baseline = set_components(
+        _capture("baseline"),
+        [[1.0e9, 0.0], [2.0, 0.0]],
+    )
+    component_candidate = set_components(
+        _capture("candidate"),
+        [[1.0e9 - 1.0e-4, 0.0], [2.0 + 1.0e-4, 0.0]],
+    )
+    component_comparison = _compare(component_baseline, component_candidate)
+    assert component_comparison["passes"] is False
+    assert component_comparison["pointwise_comparisons"][0]["passes"] is True
+    assert [
+        entry["passes"]
+        for entry in component_comparison["resolved_component_comparisons"]
+    ] == [True, False]
+
+
+def test_fixture_or_selector_drift_prevents_semantically_invalid_pairing() -> None:
+    baseline = _capture("baseline")
+    fixture_candidate = copy.deepcopy(_capture("candidate"))
+    fixture = fixture_candidate["validation"]["fixture"]
+    fixture["points"][0][0][0] = 51.0
+    fixture["points_sha256"] = parity._canonical_sha256(fixture["points"])
+    fixture_candidate = _readdress(fixture_candidate)
+
+    fixture_comparison = _compare(baseline, fixture_candidate)
+    assert fixture_comparison["passes"] is False
+    assert fixture_comparison["pointwise_comparisons"] == []
+    assert fixture_comparison["resolved_component_comparisons"] == []
+    assert "deterministic phase-space fixtures differ" in fixture_comparison["errors"]
+
+    selector_candidate = copy.deepcopy(_capture("candidate"))
+    semantic = selector_candidate["artifact"]["semantic_identity"]
+    semantic["physical_color_flows"]["ordered_ids"] = ["c:other"]
+    semantic["physical_color_flows"]["ordered_entries"][0]["id"] = "c:other"
+    selector_candidate["artifact"]["semantic_identity_sha256"] = (
+        parity._canonical_sha256(semantic)
+    )
+    selector = selector_candidate["validation"]["selector_contract"]
+    selector["physical_color_ids"] = ["c:other"]
+    selector["selected_color_flow_ids"] = ["c:other"]
+    selector_candidate["validation"]["resolved_color_ids"] = ["c:other"]
+    selector["contract_sha256"] = parity._canonical_sha256(
+        {key: value for key, value in selector.items() if key != "contract_sha256"}
+    )
+    selector_candidate = _readdress(selector_candidate)
+    selector_comparison = _compare(baseline, selector_candidate)
+    assert selector_comparison["passes"] is False
+    assert selector_comparison["pointwise_comparisons"] == []
+    assert selector_comparison["resolved_component_comparisons"] == []
+    assert selector_comparison["selector_comparison"]["passes"] is False
+
+
+def test_capture_digest_tampering_and_incomplete_semantics_fail_closed() -> None:
+    tampered = _capture("baseline")
+    tampered["prepared_model"]["sha256"] = "f" * 64
+    with pytest.raises(parity.ParityError, match="content-address"):
+        parity._validate_capture(
+            tampered,
+            expected_variant="baseline",
+            expected_process_key=PROCESS_KEY,
+            expected_process=PROCESS_EXPRESSION,
+            expected_layout="topology-replay",
+        )
+
+    incomplete = copy.deepcopy(_capture("baseline"))
+    semantic = incomplete["artifact"]["semantic_identity"]
+    semantic.pop("reduction_ordering")
+    incomplete["artifact"]["semantic_identity_sha256"] = parity._canonical_sha256(
+        semantic
+    )
+    incomplete = _readdress(incomplete)
+    with pytest.raises(parity.ParityError, match="selector semantics"):
+        parity._validate_capture(
+            incomplete,
+            expected_variant="baseline",
+            expected_process_key=PROCESS_KEY,
+            expected_process=PROCESS_EXPRESSION,
+            expected_layout="topology-replay",
+        )
+
+
+def test_capture_distinguishes_generation_validation_from_persisted_fixture() -> None:
+    capture = _capture("baseline")
+    capture["generation_request"]["validation_samples"] = 10
+    capture = _readdress(capture)
+
+    assert (
+        parity._validate_capture(
+            capture,
+            expected_variant="baseline",
+            expected_process_key=PROCESS_KEY,
+            expected_process=PROCESS_EXPRESSION,
+            expected_layout="topology-replay",
+        )["generation_request"]["validation_samples"]
+        == 10
+    )
+
+
+def test_capture_rejects_invalid_generation_request_and_truncated_provenance() -> None:
+    invalid_request = _capture("baseline")
+    invalid_request["generation_request"]["validation_samples"] = 0
+    invalid_request = _readdress(invalid_request)
+    with pytest.raises(parity.ParityError, match="capture is inconsistent"):
+        parity._validate_capture(
+            invalid_request,
+            expected_variant="baseline",
+            expected_process_key=PROCESS_KEY,
+            expected_process=PROCESS_EXPRESSION,
+            expected_layout="topology-replay",
+        )
+
+    truncated = _capture("baseline")
+    truncated["runtime_provenance"].pop("native_extension")
+    truncated = _readdress(truncated)
+    with pytest.raises(parity.ParityError, match="runtime provenance"):
+        parity._validate_capture(
+            truncated,
+            expected_variant="baseline",
+            expected_process_key=PROCESS_KEY,
+            expected_process=PROCESS_EXPRESSION,
+            expected_layout="topology-replay",
+        )
+
+
+def test_capture_rejects_flow_specialization_in_request_or_semantics() -> None:
+    specialized_request = _capture("baseline")
+    specialized_request["generation_request"]["specialize_flow_at_generation"] = True
+    specialized_request = _readdress(specialized_request)
+    with pytest.raises(parity.ParityError, match="capture is inconsistent"):
+        parity._validate_capture(
+            specialized_request,
+            expected_variant="baseline",
+            expected_process_key=PROCESS_KEY,
+            expected_process=PROCESS_EXPRESSION,
+            expected_layout="topology-replay",
+        )
+
+    specialized_semantics = _capture("baseline")
+    semantic = specialized_semantics["artifact"]["semantic_identity"]
+    semantic["generation_specialized_axes"] = ["color"]
+    specialized_semantics["artifact"]["semantic_identity_sha256"] = (
+        parity._canonical_sha256(semantic)
+    )
+    specialized_semantics = _readdress(specialized_semantics)
+    with pytest.raises(parity.ParityError, match="capture is inconsistent"):
+        parity._validate_capture(
+            specialized_semantics,
+            expected_variant="baseline",
+            expected_process_key=PROCESS_KEY,
+            expected_process=PROCESS_EXPRESSION,
+            expected_layout="topology-replay",
+        )
+
+    specialized_nested_semantics = _capture("baseline")
+    semantic = specialized_nested_semantics["artifact"]["semantic_identity"]
+    semantic["runtime_selector_semantics"]["generation_specialized_axes"] = ["color"]
+    specialized_nested_semantics["artifact"]["semantic_identity_sha256"] = (
+        parity._canonical_sha256(semantic)
+    )
+    specialized_nested_semantics = _readdress(specialized_nested_semantics)
+    with pytest.raises(parity.ParityError, match="capture is inconsistent"):
+        parity._validate_capture(
+            specialized_nested_semantics,
+            expected_variant="baseline",
+            expected_process_key=PROCESS_KEY,
+            expected_process=PROCESS_EXPRESSION,
+            expected_layout="topology-replay",
+        )
+
+
+def test_artifact_manifest_parameter_and_fixture_links_fail_closed() -> None:
+    invalid_manifest = _capture("baseline")
+    invalid_manifest["artifact"]["manifest"]["path"] = "/outside/artifact.json"
+
+    invalid_parameters = _capture("baseline")
+    invalid_parameters["parameters"]["file"]["sha256"] = "f" * 64
+
+    invalid_fixture = _capture("baseline")
+    invalid_fixture["validation"]["fixture"]["file"]["path"] = (
+        "/outside/validation-momenta.json"
+    )
+
+    for capture, message in (
+        (invalid_manifest, "manifest path"),
+        (invalid_parameters, "parameters is not bound"),
+        (invalid_fixture, "fixture is not bound"),
+    ):
+        with pytest.raises(parity.ParityError, match=message):
+            parity._validate_capture(
+                _readdress(capture),
+                expected_variant="baseline",
+                expected_process_key=PROCESS_KEY,
+                expected_process=PROCESS_EXPRESSION,
+                expected_layout="topology-replay",
+            )
+
+
+def test_canonical_parameter_identity_rejects_int_float_type_drift() -> None:
+    baseline = _capture("baseline")
+    candidate = _capture("candidate")
+    baseline["parameters"]["payload"] = {"x": 1}
+    baseline["parameters"]["payload_sha256"] = parity._canonical_sha256({"x": 1})
+    candidate["parameters"]["payload"] = {"x": 1.0}
+    candidate["parameters"]["payload_sha256"] = parity._canonical_sha256({"x": 1.0})
+
+    comparison = _compare(
+        _readdress(baseline),
+        _readdress(candidate),
+    )
+
+    assert comparison["passes"] is False
+    assert comparison["parameter_comparison"]["passes"] is False
+    assert "default model parameters differ" in comparison["errors"]
+
+
+def test_source_preflight_rejects_any_revision_other_than_the_pinned_commit(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    checkout = tmp_path / "baseline"
+    checkout.mkdir()
+    variant = parity.Variant(
+        name="baseline",
+        python=tmp_path / "python",
+        checkout=checkout,
+        pythonpath=tmp_path / "site-packages",
+        prepared_model=tmp_path / "model.pack",
+    )
+
+    def git_stdout(
+        _checkout: Path,
+        *arguments: str,
+        label: str,
+    ) -> str:
+        del label
+        if arguments == ("rev-parse", "--show-toplevel"):
+            return str(checkout)
+        if arguments == ("rev-parse", "--verify", "HEAD"):
+            return parity.EXPECTED_SOURCE_REVISIONS["candidate"]
+        if arguments == ("status", "--porcelain=v1", "--untracked-files=all"):
+            return ""
+        raise AssertionError(arguments)
+
+    monkeypatch.setattr(parity, "_git_stdout", git_stdout)
+    with pytest.raises(parity.ParityError, match="expected 172e58f"):
+        parity._preflight_variant_source(variant)
+
+
+def test_variant_binding_rejects_mixed_runtime_provenance_across_workers() -> None:
+    capture = _capture("baseline")
+    variant = parity.Variant(
+        name="baseline",
+        python=Path("/runtime/python"),
+        checkout=Path("/source/baseline"),
+        pythonpath=Path("/runtime/site-packages"),
+        prepared_model=Path("/source/baseline/model.pack"),
+    )
+    bindings: dict[str, dict[str, object]] = {}
+    parity._pin_variant_binding(
+        bindings,
+        variant=variant,
+        capture=capture,
+        expected_model=capture["prepared_model"],
+        expected_generation_request=capture["generation_request"],
+        expected_source=capture["source"],
+    )
+
+    drifted = copy.deepcopy(capture)
+    drifted["runtime_provenance"]["native_extension"]["package_version"] = "0.2.0"
+    with pytest.raises(parity.ParityError, match="changed during the campaign"):
+        parity._pin_variant_binding(
+            bindings,
+            variant=variant,
+            capture=drifted,
+            expected_model=drifted["prepared_model"],
+            expected_generation_request=drifted["generation_request"],
+            expected_source=drifted["source"],
+        )
+
+
+def test_workspace_python_symlink_is_retained_and_output_scope_is_fail_closed(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(parity, "DRIVER_ROOT", tmp_path.resolve())
+    interpreter = tmp_path / "python"
+    interpreter.symlink_to(Path(sys.executable))
+    assert (
+        parity._resolve_python_inside_workspace(interpreter, label="test Python")
+        == interpreter.absolute()
+    )
+
+    allowed = tmp_path / "allowed"
+    allowed.mkdir()
+    monkeypatch.setattr(parity, "ALLOWED_OUTPUT_PARENT", allowed.resolve())
+    requested = allowed / "campaign"
+    assert parity._resolve_output_root(requested) == requested.resolve()
+    with pytest.raises(parity.ParityError, match="below"):
+        parity._resolve_output_root(tmp_path / "escaped")
+    requested.mkdir()
+    with pytest.raises(parity.ParityError, match="already exists"):
+        parity._resolve_output_root(requested)
+
+
+def test_worker_command_and_environment_isolate_all_writes_under_watchdog(
+    tmp_path: Path,
+) -> None:
+    checkout = tmp_path / "checkout"
+    pythonpath = tmp_path / "site-packages"
+    prepared_model = tmp_path / "model.pack"
+    python = tmp_path / "python"
+    for directory in (checkout, pythonpath):
+        directory.mkdir()
+    for file_path in (prepared_model, python):
+        file_path.write_bytes(b"x")
+    variant = parity.Variant(
+        name="baseline",
+        python=python,
+        checkout=checkout,
+        pythonpath=pythonpath,
+        prepared_model=prepared_model,
+    )
+    capture_root = tmp_path / "capture"
+    capture_root.mkdir()
+    command = parity._worker_command(
+        variant,
+        capture_root=capture_root,
+        process_key=PROCESS_KEY,
+        process_expression=PROCESS_EXPRESSION,
+        layout="all-flow-union",
+        validation_samples=10,
+        point_tile_size=1024,
+        jit_optimization_level=2,
+    )
+    assert command[:6] == [
+        str(python),
+        str(parity.WATCHDOG_PATH),
+        "--limit-gib",
+        "30",
+        "--",
+        str(python),
+    ]
+    assert command[command.index("--artifact") + 1] == str(capture_root / "artifact")
+    assert command[command.index("--capture-json") + 1] == str(
+        capture_root / "capture.json"
+    )
+
+    environment_root = tmp_path / "environment"
+    environment_root.mkdir()
+    environment, overrides = parity._worker_environment(
+        variant,
+        environment_root,
+    )
+    assert overrides[parity.SOURCE_CHECKOUT_ENV] == str(checkout)
+    assert overrides["PYTHONPATH"] == str(pythonpath)
+    for key in ("TMPDIR", "XDG_CACHE_HOME", "PYTHONPYCACHEPREFIX", "MPLCONFIGDIR"):
+        assert Path(overrides[key]).resolve().is_relative_to(environment_root.resolve())
+        assert environment[key] == overrides[key]
+    assert os.environ.get(parity.SOURCE_CHECKOUT_ENV) != str(checkout)
+
+
+def test_orchestrator_runs_the_complete_matrix_with_balanced_pair_order(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(parity, "ALLOWED_OUTPUT_PARENT", tmp_path.resolve())
+    shared_python = tmp_path / "python"
+    shared_python.write_bytes(b"python")
+    variants: dict[str, parity.Variant] = {}
+    for name in ("baseline", "candidate"):
+        checkout = tmp_path / name / "checkout"
+        pythonpath = tmp_path / name / "site-packages"
+        prepared_model = tmp_path / name / "model.pack"
+        checkout.mkdir(parents=True)
+        pythonpath.mkdir(parents=True)
+        prepared_model.write_bytes(b"identical-model")
+        variants[name] = parity.Variant(
+            name=name,
+            python=shared_python,
+            checkout=checkout,
+            pythonpath=pythonpath,
+            prepared_model=prepared_model,
+        )
+
+    monkeypatch.setattr(
+        parity,
+        "_variant",
+        lambda name, **_values: variants[name],
+    )
+    preflight_calls: list[str] = []
+
+    def preflight_source(variant: parity.Variant) -> dict[str, object]:
+        preflight_calls.append(variant.name)
+        return {
+            "checkout": str(variant.checkout.resolve()),
+            "revision": parity.EXPECTED_SOURCE_REVISIONS[variant.name],
+            "dirty": False,
+            "untracked_files_checked": True,
+        }
+
+    monkeypatch.setattr(parity, "_preflight_variant_source", preflight_source)
+    calls: list[tuple[str, str, str]] = []
+
+    def capture_variant(
+        variant: parity.Variant,
+        *,
+        process_key: str,
+        process_expression: str,
+        layout: str,
+        **_values: object,
+    ) -> tuple[dict[str, object], dict[str, object]]:
+        assert preflight_calls[:2] == ["baseline", "candidate"]
+        calls.append((variant.name, process_key, layout))
+        capture = _capture(
+            variant.name,
+            layout=layout,
+            process_key=process_key,
+            process_expression=process_expression,
+            checkout=str(variant.checkout.resolve()),
+            prepared_model_identity=parity._path_identity(variant.prepared_model),
+        )
+        invocation = parity._content_address(
+            {
+                "kind": "test-invocation",
+                "schema_version": 1,
+                "variant": variant.name,
+                "process_key": process_key,
+                "layout": layout,
+            }
+        )
+        return capture, invocation
+
+    monkeypatch.setattr(parity, "_capture_variant", capture_variant)
+    arguments = SimpleNamespace(
+        baseline_python=shared_python,
+        candidate_python=shared_python,
+        baseline_checkout=variants["baseline"].checkout,
+        candidate_checkout=variants["candidate"].checkout,
+        baseline_pythonpath=variants["baseline"].pythonpath,
+        candidate_pythonpath=variants["candidate"].pythonpath,
+        baseline_prepared_model=variants["baseline"].prepared_model,
+        candidate_prepared_model=variants["candidate"].prepared_model,
+        output_root=tmp_path / "campaign",
+        validation_samples=1,
+        point_tile_size=1024,
+        jit_optimization_level=2,
+        worker_timeout=60.0,
+    )
+
+    result = parity.run(arguments)
+
+    assert result["passes"] is True
+    assert result["comparison_count"] == 6
+    assert result["passing_comparison_count"] == 6
+    assert len(calls) == 12
+    assert preflight_calls == ["baseline", "candidate", "baseline", "candidate"]
+    assert [name for name, _process, _layout in calls] == [
+        "baseline",
+        "candidate",
+        "candidate",
+        "baseline",
+        "candidate",
+        "baseline",
+        "baseline",
+        "candidate",
+        "baseline",
+        "candidate",
+        "candidate",
+        "baseline",
+    ]
+    assert {(process_key, layout) for _name, process_key, layout in calls} == {
+        (process_key, layout)
+        for process_key, _expression in parity.PROCESS_CASES
+        for layout in parity.LAYOUTS
+    }
+    result_path = arguments.output_root / "result.json"
+    assert result_path.is_file()
+    parity._validate_content_address(
+        parity._json_object(result_path, label="result"),
+        kind=parity.RESULT_KIND,
+        schema_version=parity.RESULT_SCHEMA,
+        label="result",
+    )
diff --git a/pyamplicol/tests/unit/test_recurrence_numerical_current_warmup.py b/pyamplicol/tests/unit/test_recurrence_numerical_current_warmup.py
new file mode 100644
index 0000000000..1d4c72410d
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_numerical_current_warmup.py
@@ -0,0 +1,2666 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import gc
+import hashlib
+import json
+import math
+import tempfile
+import weakref
+import zlib
+from collections.abc import Iterator, Mapping
+from dataclasses import replace
+from decimal import Decimal, localcontext
+from fractions import Fraction
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+
+import pyamplicol.generation.recurrence_numerical_current_warmup as recurrence_warmup
+import pyamplicol.generation.service as generation_service
+from pyamplicol.api.errors import ArtifactError, GenerationError
+from pyamplicol.generation.dag_equivalence import (
+    _advance_rejection_digest,
+    _rejected_candidate_diagnostics,
+)
+from pyamplicol.generation.numerical_candidate_index import (
+    build_numerical_observation_candidate_index,
+    numerical_observation_tolerance_window_ids,
+)
+from pyamplicol.generation.recurrence_numerical_current_warmup import (
+    _COMPRESSED_EVIDENCE_HEADER,
+    _MIN_RAW_EVIDENCE_WIRE_BYTES,
+    _RAW_EVIDENCE_MEMORY_TARGET_BYTES,
+    RecurrenceNumericalEvidenceEnvelopeExceeded,
+    RecurrenceNumericalEvidenceGeometry,
+    _build_candidate_indexes,
+    _decimal_string,
+    _discover_relations,
+    _pair_residuals,
+    _raw_evidence_memory_upper_bound,
+    _raw_evidence_wire_byte_limit,
+    _read_compressed_evidence_spool,
+    _relation_residuals,
+    _runtime_parameter_schema_payload,
+    _spooled_capture_memory_upper_bound,
+    _SpooledObservationMapping,
+    _synthetic_raw_evidence_bytes,
+    _synthetic_raw_evidence_bytes_by_dimension_counts,
+    _validate_raw_evidence_canonical_size,
+    _validate_raw_evidence_geometry,
+    _write_compressed_canonical_evidence,
+    capture_recurrence_current_observations,
+    recurrence_numerical_current_envelope_fallback_report,
+    recurrence_numerical_current_opt_out_report,
+    recurrence_numerical_relation_correctness_summary,
+    recurrence_numerical_relation_fallback_summary,
+    recurrence_numerical_source_semantics_sha256,
+    run_recurrence_numerical_current_warmup,
+    validate_recurrence_numerical_current_application,
+    validate_recurrence_numerical_evidence_fallback,
+)
+from pyamplicol.generation.service import (
+    _recurrence_relation_reporting,
+)
+from pyamplicol.generation.validation import ValidationPointRecord
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.runtime.recurrence_exact._plan import (
+    _RecurrenceExactPlan,
+    _RuntimeParameterSchemaRow,
+    _SourceTemplate,
+)
+from pyamplicol.runtime.recurrence_exact._plan_v2 import (
+    DIRECT_NONE_U32,
+    _Contribution,
+    _Current,
+    _ExactFactor,
+    _Executor,
+    _MomentumForm,
+    _MomentumTerm,
+    _RecurrenceExactSectionsV1,
+    _ReplayTarget,
+    _ResolvedHelicity,
+    _RowGroup,
+    _Source,
+)
+
+
+def _factor(value: int) -> _ExactFactor:
+    return _ExactFactor(value, 1, 0, 1)
+
+
+def test_opposite_residual_is_independent_of_ambient_decimal_context() -> None:
+    exact = Decimal("0.123456789012345678901234567890123456789012345678901234567890")
+    with localcontext() as context:
+        context.prec = 7
+        residuals = _pair_residuals(
+            ((Decimal(f"-{exact}"), Decimal(0)),),
+            ((exact, Decimal(0)),),
+            sign=-1,
+            relative_tolerance=Decimal("1e-70"),
+            absolute_tolerance=Decimal("1e-80"),
+        )
+
+    assert residuals == (0, 0, 0)
+
+
+@pytest.mark.parametrize(
+    ("process_expression", "process_id"),
+    (
+        ("d d~ > z", "d_dbar_to_z"),
+        ("u d~ > w+", "u_dbar_to_w"),
+    ),
+)
+def test_massive_one_body_recurrence_probe_domains_are_physical_and_distinct(
+    process_expression: str,
+    process_id: str,
+) -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir(process_expression, color_accuracy="full")
+    probes = recurrence_warmup.build_recurrence_numerical_current_probe_points(
+        process,
+        model,
+        process_id=process_id,
+        seed=17,
+        candidate_count=4,
+        verification_count=4,
+    )
+
+    assert probes == (
+        recurrence_warmup.build_recurrence_numerical_current_probe_points(
+            process,
+            model,
+            process_id=process_id,
+            seed=17,
+            candidate_count=4,
+            verification_count=4,
+        )
+    )
+    candidate, verification = probes
+    candidate_hashes = {
+        recurrence_warmup._kinematic_sha256(point) for point in candidate
+    }
+    verification_hashes = {
+        recurrence_warmup._kinematic_sha256(point) for point in verification
+    }
+    assert len(candidate_hashes) == len(candidate)
+    assert len(verification_hashes) == len(verification)
+    assert candidate_hashes.isdisjoint(verification_hashes)
+
+    for point in (*candidate, *verification):
+        assert point.available
+        assert point.process == process_expression
+        assert point.process_id == process_id
+        assert all(
+            math.isfinite(component)
+            for _pdg, momentum in point.particles
+            for component in momentum
+        )
+        incoming = point.four_vectors[:2]
+        outgoing = point.four_vectors[2:]
+        for component in range(4):
+            assert math.isclose(
+                sum(momentum[component] for momentum in incoming),
+                sum(momentum[component] for momentum in outgoing),
+                rel_tol=0.0,
+                abs_tol=1.0e-10,
+            )
+        for pdg, (energy, x_component, y_component, z_component) in point.particles:
+            invariant_mass_squared = (
+                energy * energy
+                - x_component * x_component
+                - y_component * y_component
+                - z_component * z_component
+            )
+            expected_mass_squared = float(model.mass(pdg)) ** 2
+            assert math.isclose(
+                invariant_mass_squared,
+                expected_mass_squared,
+                rel_tol=1.0e-12,
+                abs_tol=1.0e-10,
+            )
+
+
+def test_zero_residual_specialization_matches_explicit_zero_comparison() -> None:
+    current = (
+        (Decimal("0"), Decimal("-0")),
+        (Decimal("1.25"), Decimal("-3.5")),
+        (
+            Decimal("0.123456789012345678901234567890123456789"),
+            Decimal("-9.87654321098765432109876543210987654321"),
+        ),
+    )
+    relative = Fraction(1, 10**70)
+    absolute = Fraction(1, 10**80)
+
+    expected = _pair_residuals(
+        current,
+        tuple((Decimal(0), Decimal(0)) for _ in current),
+        sign=1,
+        relative_tolerance=Decimal("1e-70"),
+        absolute_tolerance=Decimal("1e-80"),
+    )
+    actual = _relation_residuals(
+        "zero",
+        current,
+        None,
+        relative_tolerance=relative,
+        absolute_tolerance=absolute,
+    )
+
+    assert actual == expected
+    with pytest.raises(ValueError, match="relation width is invalid"):
+        _relation_residuals(
+            "equal",
+            current,
+            None,
+            relative_tolerance=relative,
+            absolute_tolerance=absolute,
+        )
+
+
+def _topology_replay_plan() -> _RecurrenceExactPlan:
+    sections = _RecurrenceExactSectionsV1(
+        process_id="synthetic_replay",
+        strategy="topology-replay",
+        semantic_digest="1" * 64,
+        runtime_layout_digest="2" * 64,
+        current_arena_components=4,
+        amplitude_destination_count=1,
+        parameter_value_count=0,
+        external_source_count=2,
+        currents=(
+            _Current(0, 0, 0, 0, 1, 0, 0, 0, 0, 4, 0, DIRECT_NONE_U32),
+            _Current(1, 0, 0, 1, 1, 1, 0, 0, 0, 4, 1, DIRECT_NONE_U32),
+            _Current(
+                2,
+                1,
+                0,
+                2,
+                1,
+                0,
+                1,
+                0,
+                2,
+                4,
+                DIRECT_NONE_U32,
+                DIRECT_NONE_U32,
+            ),
+            _Current(
+                3,
+                1,
+                0,
+                3,
+                1,
+                0,
+                1,
+                0,
+                3,
+                4,
+                DIRECT_NONE_U32,
+                DIRECT_NONE_U32,
+            ),
+        ),
+        sources=(
+            _Source(0, 0, 0, 0, 0, 0, 0),
+            _Source(1, 1, 1, 0, 0, 0, 0),
+        ),
+        contributions=(
+            _Contribution(
+                0,
+                DIRECT_NONE_U32,
+                1,
+                DIRECT_NONE_U32,
+                2,
+                0,
+                0,
+                3,
+            ),
+            _Contribution(
+                0,
+                DIRECT_NONE_U32,
+                1,
+                DIRECT_NONE_U32,
+                3,
+                0,
+                0,
+                3,
+            ),
+        ),
+        finalizations=(),
+        closures=(),
+        row_groups=(
+            _RowGroup(0, 0, 0, 0, 0, 2),
+            _RowGroup(1, 1, 1, DIRECT_NONE_U32, 0, 2),
+        ),
+        momentum_forms=(_MomentumForm(0, 1), _MomentumForm(1, 1)),
+        momentum_terms=(_MomentumTerm(0, 1), _MomentumTerm(1, 1)),
+        replay_targets=(
+            _ReplayTarget(10, 0, 0, 2, 0, 0, 0, 1, 0),
+            _ReplayTarget(11, 0, 2, 2, 0, 0, 0, 1, 0),
+        ),
+        source_permutations=(0, 1, 1, 0),
+        replay_momentum_signs=(1, 1, 1, 1),
+        replay_helicity_map=(),
+        amplitude_destinations=(),
+        resolved_helicities=(),
+        source_state_assignments=(),
+        source_dispatch_variants=(),
+        source_embeddings=(),
+        source_projections=(),
+        resolved_source_selections=(),
+        public_helicities=(),
+        exact_factors=(_factor(1),),
+        public_flow_ids=(10, 11),
+        executors=(
+            _Executor(
+                0,
+                "source",
+                "initialize",
+                (),
+                1,
+                1,
+                None,
+                "source",
+            ),
+        ),
+    )
+    return _RecurrenceExactPlan(
+        sections=sections,
+        kernels={},
+        executors={0: sections.executors[0]},
+        executor_exact_kernel_ids={},
+        executor_parent_permutations={0: (0, 1)},
+        source_templates={
+            0: _SourceTemplate(
+                0,
+                1,
+                0,
+                0,
+                0,
+                "scalar",
+                "self-conjugate",
+                None,
+                1,
+                1,
+                1,
+            )
+        },
+        initial_source_slots=frozenset({0, 1}),
+        executor_couplings={},
+        prepared_defaults=(),
+        parameter_projection=(),
+        parameter_derivation=None,
+        runtime_defaults=(Decimal("1.25"), Decimal("2.5")),
+        runtime_parameter_schema=(
+            _RuntimeParameterSchemaRow(0, "probe_a", 0, None, 0),
+            _RuntimeParameterSchemaRow(1, "probe_b", 1, None, 0),
+        ),
+    )
+
+
+def _no_relation_plan() -> _RecurrenceExactPlan:
+    plan = _topology_replay_plan()
+    contributions = list(plan.sections.contributions)
+    contributions[1] = replace(contributions[1], exact_factor_id=1)
+    plan.sections = replace(
+        plan.sections,
+        contributions=tuple(contributions),
+        exact_factors=(*plan.sections.exact_factors, _factor(2)),
+    )
+    return plan
+
+
+def _signed_relation_plan() -> _RecurrenceExactPlan:
+    plan = _topology_replay_plan()
+    prototype = plan.sections.currents[3]
+    contribution = plan.sections.contributions[0]
+    plan.sections = replace(
+        plan.sections,
+        current_arena_components=6,
+        currents=(
+            *plan.sections.currents,
+            replace(
+                prototype,
+                semantic_id=4,
+                component_base=4,
+                first_use=4,
+                last_use=4,
+            ),
+            replace(
+                prototype,
+                semantic_id=5,
+                component_base=5,
+                first_use=5,
+                last_use=5,
+            ),
+        ),
+        contributions=(
+            *plan.sections.contributions,
+            replace(
+                contribution,
+                destination_base=4,
+                exact_factor_id=1,
+            ),
+            replace(
+                contribution,
+                destination_base=5,
+                exact_factor_id=2,
+            ),
+        ),
+        row_groups=(
+            plan.sections.row_groups[0],
+            replace(plan.sections.row_groups[1], row_count=4),
+        ),
+        exact_factors=(
+            *plan.sections.exact_factors,
+            _factor(-1),
+            _factor(0),
+        ),
+    )
+    return plan
+
+
+def _contracted_signed_relation_plan() -> _RecurrenceExactPlan:
+    plan = _signed_relation_plan()
+    plan.sections = replace(
+        plan.sections, strategy="contracted-color-union", replay_targets=()
+    )
+    return plan
+
+
+def _points(seed_start: int) -> tuple[ValidationPointRecord, ...]:
+    return tuple(
+        ValidationPointRecord(
+            process_id="synthetic_replay",
+            process="s s > s s",
+            seed=seed,
+            particles=(
+                (1, (10.0 + seed, 0.0, 0.0, 10.0 + seed)),
+                (-1, (20.0 + seed, 0.0, 0.0, -20.0 - seed)),
+            ),
+        )
+        for seed in range(seed_start, seed_start + 2)
+    )
+
+
+def test_replay_capture_observes_contribution_only_currents() -> None:
+    plan = _topology_replay_plan()
+    source_digest = recurrence_numerical_source_semantics_sha256(plan.sections)
+    captured = capture_recurrence_current_observations(
+        plan,
+        _points(1),
+        precision_digits=80,
+        source_semantics_sha256=source_digest,
+        seed=41,
+        domain="candidate-current-probes-v1",
+    )
+
+    assert captured.current_count == 4
+    assert captured.current_dimensions == {0: 1, 1: 1, 2: 1, 3: 1}
+    assert captured.observations[2] == captured.observations[3]
+    assert captured.context_policy == "seeded-replay-target-per-physical-point-v1"
+    assert len(captured.context_sha256s) == 2
+
+
+def test_python_parameter_default_hex_matches_native_signed_binary64_contract() -> None:
+    plan = _topology_replay_plan()
+    plan.runtime_defaults = (
+        Decimal.from_float(-1.5),
+        Decimal.from_float(float.fromhex("-0x0.0000000000001p-1022")),
+    )
+
+    payload = _runtime_parameter_schema_payload(plan)
+
+    assert [row["default_binary64"] for row in payload["parameters"]] == [
+        "-0x1.8000000000000p+0",
+        "-0x0.0000000000001p-1022",
+    ]
+
+
+def test_warmup_builds_static_semantics_once(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    contract_calls = 0
+    default_calls = 0
+    source_semantics_calls = 0
+    original_contracts = recurrence_warmup._current_contracts
+    original_defaults = recurrence_warmup._runtime_parameter_defaults
+    original_source_semantics = recurrence_warmup._source_semantics_payload
+
+    def counted_contracts(
+        sections: _RecurrenceExactSectionsV1,
+    ) -> tuple[tuple[object, ...], ...]:
+        nonlocal contract_calls
+        contract_calls += 1
+        return original_contracts(sections)
+
+    def counted_defaults(plan: _RecurrenceExactPlan) -> tuple[Decimal, ...]:
+        nonlocal default_calls
+        default_calls += 1
+        return original_defaults(plan)
+
+    def counted_source_semantics(
+        sections: _RecurrenceExactSectionsV1,
+        *,
+        contracts: tuple[tuple[object, ...], ...] | None = None,
+    ) -> dict[str, object]:
+        nonlocal source_semantics_calls
+        source_semantics_calls += 1
+        return original_source_semantics(sections, contracts=contracts)
+
+    monkeypatch.setattr(recurrence_warmup, "_current_contracts", counted_contracts)
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_runtime_parameter_defaults",
+        counted_defaults,
+    )
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_source_semantics_payload",
+        counted_source_semantics,
+    )
+    result = run_recurrence_numerical_current_warmup(
+        _topology_replay_plan(),
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="certified-reuse",
+        color_accuracy="lc",
+        precision_digits=80,
+        seed=53,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+    try:
+        assert contract_calls == 1
+        assert default_calls == 1
+        assert source_semantics_calls == 1
+        candidate_dimensions = result.candidate_capture.current_dimensions
+        verification_dimensions = result.verification_capture.current_dimensions
+        assert candidate_dimensions == verification_dimensions
+        assert candidate_dimensions is not verification_dimensions
+        assert isinstance(candidate_dimensions, dict)
+        assert isinstance(verification_dimensions, dict)
+        current_id = next(iter(candidate_dimensions))
+        verification_dimension = verification_dimensions[current_id]
+        candidate_dimensions[current_id] = verification_dimension + 1
+        assert verification_dimensions[current_id] == verification_dimension
+    finally:
+        result.close()
+
+
+def test_warmup_phase_timings_are_diagnostic_only() -> None:
+    arguments = {
+        "candidate_points": _points(1),
+        "verification_points": _points(101),
+        "mode": "certified-reuse",
+        "color_accuracy": "lc",
+        "precision_digits": 80,
+        "seed": 53,
+        "relative_tolerance": 1.0e-60,
+        "absolute_tolerance": 1.0e-70,
+    }
+    result = run_recurrence_numerical_current_warmup(
+        _topology_replay_plan(),
+        **arguments,
+    )
+    repeated = run_recurrence_numerical_current_warmup(
+        _topology_replay_plan(),
+        **arguments,
+    )
+    try:
+        assert result.generation_profile_timings
+        assert all(
+            isinstance(seconds, float) and seconds >= 0.0
+            for seconds in result.generation_profile_timings.values()
+        )
+        assert {
+            key
+            for key in result.generation_profile_timings
+            if key.startswith("warmup_candidate_probe_")
+        } == {"warmup_candidate_probe_0", "warmup_candidate_probe_1"}
+        assert {
+            key
+            for key in result.generation_profile_timings
+            if key.startswith("warmup_verification_probe_")
+        } == {"warmup_verification_probe_0", "warmup_verification_probe_1"}
+        assert "generation_profile_timings" not in json.dumps(
+            result.to_json_dict(),
+            sort_keys=True,
+        )
+        assert result.evidence_json == repeated.evidence_json
+        assert result == repeated
+        assert result == replace(
+            result,
+            generation_profile_timings={"diagnostic-only": 1.0},
+        )
+        with pytest.raises(TypeError):
+            result.generation_profile_timings["not-mutable"] = 1.0  # type: ignore[index]
+    finally:
+        result.close()
+        repeated.close()
+
+
+def test_recurrence_certified_reuse_uses_two_independent_probe_sets(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    capture = Mock(wraps=recurrence_warmup._capture_recurrence_current_observations)
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_capture_recurrence_current_observations",
+        capture,
+    )
+    result = run_recurrence_numerical_current_warmup(
+        _topology_replay_plan(),
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="certified-reuse",
+        color_accuracy="lc",
+        precision_digits=80,
+        seed=53,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+
+    assert result.applied_relation_count == 1
+    certificate = result.certificates[0]
+    assert certificate.current_id == 3
+    assert certificate.representative_id == 2
+    assert certificate.execution_representative_id == 2
+    assert certificate.relation_kind == "equal"
+    assert certificate.current_dimension == 1
+    assert certificate.candidate_probe_count == 2
+    assert certificate.verification_probe_count == 2
+    assert result.candidate_capture.current_count == 4
+    assert result.verification_capture.current_count == 4
+    assert set(result.candidate_capture.observations) == {2, 3}
+    assert set(result.verification_capture.observations) == {2, 3}
+    assert result.candidate_capture.complete_observations_retained is False
+    assert result.verification_capture.complete_observations_retained is False
+    with pytest.raises(ValueError, match="cannot recreate raw evidence"):
+        result.candidate_capture.to_evidence_dict()
+    assert set(result.candidate_capture.kinematic_sha256s).isdisjoint(
+        result.verification_capture.kinematic_sha256s
+    )
+    evidence = json.loads(result.evidence_json)
+    assert evidence["requested_mode"] == "certified-reuse"
+    assert "relative_tolerance" not in evidence
+    assert "absolute_tolerance" not in evidence
+    assert evidence["relative_tolerance_binary64"] == (1.0e-60).hex()
+    assert evidence["absolute_tolerance_binary64"] == (1.0e-70).hex()
+    assert evidence["mappings"][0]["factor_integer"] == [1, 0]
+    assert len(evidence["candidate_capture"]["observations"]) == 4
+    assert len(evidence["verification_capture"]["observations"]) == 4
+    report = result.to_json_dict()
+    assert report["warning"]["required"] is True
+    rejected = report["discovery"]["rejected_candidate_diagnostics"]
+    assert rejected["retained_count"] == len(report["discovery"]["rejected_candidates"])
+    assert rejected["total_rejected_hypothesis_count"] >= rejected["retained_count"]
+    assert rejected["full_decision_sha256"] == report["discovery"]["decision_sha256"]
+    persisted = report["persisted_numerical_evidence"]
+    assert persisted["raw_evidence_retained"] is False
+    census = persisted["full_census"]
+    assert (
+        census["uncertified_candidate_count"] == census["verification_rejected_count"]
+    )
+    assert census["numerical_candidate_count"] == (
+        census["certified_relation_count"] + census["uncertified_candidate_count"]
+    )
+    assert census["rejected_hypothesis_count"] == (
+        census["tested_hypothesis_count"] - census["certified_relation_count"]
+    )
+    assert (
+        census["rejection_decision_sha256"]
+        == report["discovery"]["rejection_decision_sha256"]
+    )
+    assert persisted["measured_payload_bytes"] > 0
+    assert {
+        row["current_id"] for row in persisted["candidate_capture"]["observations"]
+    } == {2, 3}
+    assert persisted["candidate_capture"]["full_batch_commitment"]["current_count"] == 4
+    assert len(json.dumps(persisted, separators=(",", ":"), sort_keys=True)) < len(
+        result.evidence_json
+    )
+    assert [call.kwargs["domain"] for call in capture.call_args_list] == [
+        "candidate-current-probes-v1",
+        "independent-verification-current-probes-v1",
+    ]
+
+    validated = validate_recurrence_numerical_current_application(
+        result,
+        _topology_replay_plan(),
+        baseline_plan=_topology_replay_plan(),
+        precision_digits=80,
+        seed=53,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+    assert validated.application_validation["status"] == "verified"
+    assert validated.application_validation["maximum_absolute_residual"] == "0"
+
+
+def test_recurrence_diagnostic_certifies_without_applying_or_warning() -> None:
+    result = run_recurrence_numerical_current_warmup(
+        _topology_replay_plan(),
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="diagnostic",
+        color_accuracy="lc",
+        precision_digits=80,
+        seed=67,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+
+    assert len(result.certificates) == 1
+    assert result.applied_relation_count == 0
+    assert result.candidate_capture.current_count == 4
+    assert result.verification_capture.current_count == 4
+    assert result.candidate_capture.observations == {}
+    assert result.verification_capture.observations == {}
+    assert result.candidate_capture.complete_observations_retained is False
+    assert result.verification_capture.complete_observations_retained is False
+    report = result.to_json_dict()
+    assert report["state"] == "authenticated-numerical-diagnostic-only"
+    assert report["warning"]["required"] is False
+    assert json.loads(result.evidence_json)["requested_mode"] == "diagnostic"
+
+
+def test_recurrence_no_relation_skips_independent_verification_with_full_census(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    capture = Mock(wraps=recurrence_warmup._capture_recurrence_current_observations)
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_capture_recurrence_current_observations",
+        capture,
+    )
+    result = run_recurrence_numerical_current_warmup(
+        _no_relation_plan(),
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="certified-reuse",
+        color_accuracy="lc",
+        precision_digits=80,
+        seed=71,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+
+    assert result.certificates == ()
+    assert result.candidate_capture.current_count == 4
+    assert result.candidate_capture.observations == {}
+    assert result.verification_capture is None
+    assert result.evidence_json == b""
+    assert result.evidence_transport_bytes == 0
+    assert result.evidence_canonical_bytes == 0
+    assert result.evidence_encoding is None
+    assert result.discovery_report["inspected_current_count"] == 4
+    assert result.discovery_report["tested_hypothesis_count"] > 0
+    assert result.discovery_report["numerical_candidate_count"] == 0
+    probe_contract = result.discovery_report["probe_contract"]
+    assert probe_contract["independent_verification"] is False
+    assert probe_contract["verification_status"] == (
+        "not-required-no-candidate-hypothesis"
+    )
+    assert probe_contract["verification_point_sha256s"] == []
+    assert probe_contract["verification_capture_sha256"] is None
+    report = result.to_json_dict()
+    assert report["verification_capture"] is None
+    persisted = report["persisted_numerical_evidence"]
+    assert persisted["verification_capture"] is None
+    assert persisted["generation_raw_evidence_bytes"] == 0
+    assert persisted["generation_evidence_transport_bytes"] == 0
+    assert persisted["generation_evidence_encoding"] is None
+    assert [call.kwargs["domain"] for call in capture.call_args_list] == [
+        "candidate-current-probes-v1"
+    ]
+    result.close()
+    result.close()
+
+
+def test_recurrence_no_relation_returns_before_compressed_candidate_spooling(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_select_raw_evidence_storage_geometry",
+        lambda *_args, **_kwargs: recurrence_warmup._RawEvidenceStorageGeometry(
+            scalar_count=128,
+            row_count=16,
+            canonical_byte_limit=1 << 20,
+            encoding="zlib-canonical-json-v1",
+            producer_resident_upper_bound=1 << 20,
+        ),
+    )
+    result = run_recurrence_numerical_current_warmup(
+        _no_relation_plan(),
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="certified-reuse",
+        color_accuracy="lc",
+        precision_digits=80,
+        seed=71,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+
+    assert result.candidate_capture.observations == {}
+    assert result.verification_capture is None
+    assert "warmup_candidate_spool" not in result.generation_profile_timings
+    assert "warmup_verification_spool" not in result.generation_profile_timings
+    result.close()
+    result.close()
+
+
+def test_application_recapture_rejects_stale_plan_and_capture_commitment() -> None:
+    result = run_recurrence_numerical_current_warmup(
+        _topology_replay_plan(),
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="certified-reuse",
+        color_accuracy="lc",
+        precision_digits=80,
+        seed=73,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+
+    with pytest.raises(ValueError, match="did not reproduce"):
+        validate_recurrence_numerical_current_application(
+            result,
+            _topology_replay_plan(),
+            baseline_plan=_no_relation_plan(),
+            precision_digits=80,
+            seed=73,
+            relative_tolerance=1.0e-60,
+            absolute_tolerance=1.0e-70,
+        )
+
+    tampered = replace(
+        result,
+        verification_capture=replace(
+            result.verification_capture,
+            observation_batch_sha256="0" * 64,
+        ),
+    )
+    with pytest.raises(ValueError, match="did not reproduce"):
+        validate_recurrence_numerical_current_application(
+            tampered,
+            _topology_replay_plan(),
+            baseline_plan=_topology_replay_plan(),
+            precision_digits=80,
+            seed=73,
+            relative_tolerance=1.0e-60,
+            absolute_tolerance=1.0e-70,
+        )
+
+
+def test_recurrence_opt_out_has_no_capture_or_warning() -> None:
+    report = recurrence_numerical_current_opt_out_report(
+        _topology_replay_plan().sections,
+        color_accuracy="lc",
+    )
+
+    assert report["requested_mode"] == "off"
+    assert report["state"] == "disabled-by-user"
+    assert report["candidate_capture"] is None
+    assert report["verification_capture"] is None
+    assert report["applied_relation_count"] == 0
+    assert report["warning"]["required"] is False
+
+
+def test_raw_evidence_scaling_is_quantified_without_a_fixed_ceiling() -> None:
+    common = {
+        "component_count": 4,
+        "candidate_probe_count": 4,
+        "verification_probe_count": 4,
+        "decimal_characters": 112,
+    }
+    b_like_bytes = _synthetic_raw_evidence_bytes(652, **common)
+    a_like_bytes = _synthetic_raw_evidence_bytes(17_000, **common)
+
+    assert b_like_bytes == 4_918_550
+    assert a_like_bytes == 128_293_862
+    assert a_like_bytes > 25 * b_like_bytes
+    a_like_upper_bound = _raw_evidence_memory_upper_bound(
+        a_like_bytes,
+        scalar_count=1_088_000,
+        row_count=34_000,
+    )
+    assert a_like_upper_bound == 1_003_870_156
+    assert a_like_upper_bound < _RAW_EVIDENCE_MEMORY_TARGET_BYTES
+    just_over = _synthetic_raw_evidence_bytes(50_000, **common)
+    assert just_over > a_like_bytes
+    _validate_raw_evidence_canonical_size(just_over)
+
+
+def test_real_a_mixed_dimension_shape_uses_dynamic_wire_budget() -> None:
+    dimension_counts = {4: 15_834, 6: 1_240}
+    current_count = sum(dimension_counts.values())
+    component_count = sum(
+        dimension * count for dimension, count in dimension_counts.items()
+    )
+    point_count = 4 + 4
+    runtime_parameter_count = 10
+    scalar_count = (
+        2 * component_count * point_count + runtime_parameter_count * point_count
+    )
+    row_count = current_count * 2 + runtime_parameter_count
+    byte_limit = _raw_evidence_wire_byte_limit(
+        scalar_count=scalar_count,
+        row_count=row_count,
+    )
+
+    assert (current_count, component_count) == (17_074, 70_776)
+    assert (scalar_count, row_count) == (1_132_496, 34_158)
+    assert byte_limit == 148_950_528
+    wire_sizes = {
+        characters: _synthetic_raw_evidence_bytes_by_dimension_counts(
+            dimension_counts,
+            candidate_probe_count=4,
+            verification_probe_count=4,
+            decimal_characters=characters,
+        )
+        for characters in (96, 112, 128)
+    }
+    assert wire_sizes == {
+        96: 115_356_478,
+        112: 133_475_134,
+        128: 151_593_790,
+    }
+    _validate_raw_evidence_canonical_size(
+        wire_sizes[96],
+        byte_limit=byte_limit,
+    )
+    _validate_raw_evidence_canonical_size(
+        wire_sizes[112],
+        byte_limit=byte_limit,
+    )
+    with pytest.raises(ValueError, match="memory envelope"):
+        _validate_raw_evidence_canonical_size(
+            wire_sizes[128],
+            byte_limit=byte_limit,
+        )
+
+
+def test_runtime_parameter_metadata_reduces_dynamic_wire_budget() -> None:
+    without_parameters = _raw_evidence_wire_byte_limit(
+        scalar_count=1_132_416,
+        row_count=34_148,
+    )
+    with_ten_parameters = _raw_evidence_wire_byte_limit(
+        scalar_count=1_132_496,
+        row_count=34_158,
+    )
+
+    assert without_parameters == 148_978_688
+    assert with_ten_parameters == 148_950_528
+    assert without_parameters - with_ten_parameters == 28_160
+
+
+def test_parameter_context_geometry_is_preflighted_without_allocation() -> None:
+    sections = _topology_replay_plan().sections
+    scalar_count, row_count, byte_limit = _validate_raw_evidence_geometry(
+        sections,
+        candidate_probe_count=2,
+        verification_probe_count=2,
+        runtime_parameter_count=400_000,
+    )
+    assert scalar_count > 400_000
+    assert row_count > 400_000
+    assert byte_limit is None
+
+
+def test_exact_z_n8_sequential_spool_bound_includes_the_global_index() -> None:
+    resident = _spooled_capture_memory_upper_bound(
+        current_count=38_581,
+        component_count=162_976,
+        maximum_probe_count=4,
+        runtime_parameter_count=10,
+    )
+
+    assert resident == 935_671_296
+    assert resident < _RAW_EVIDENCE_MEMORY_TARGET_BYTES
+    assert _RAW_EVIDENCE_MEMORY_TARGET_BYTES - resident == 138_070_528
+
+
+def test_large_geometry_selects_spool_without_a_default_memory_limit() -> None:
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=116_319,
+        component_count=561_426,
+        candidate_probe_count=4,
+        verification_probe_count=4,
+        runtime_parameter_count=10,
+    )
+
+    selected = recurrence_warmup._select_raw_evidence_storage_geometry_for_counts(
+        geometry
+    )
+    assert selected.encoding == "zlib-canonical-json-v1"
+    assert selected.canonical_byte_limit is None
+    assert selected.producer_resident_upper_bound == 3_095_140_864
+    explicitly_allowed = (
+        recurrence_warmup._select_raw_evidence_storage_geometry_for_counts(
+            geometry, memory_envelope_bytes=4 << 30
+        )
+    )
+    assert explicitly_allowed.producer_resident_upper_bound == 3_095_140_864
+
+
+@pytest.mark.parametrize(
+    "memory_envelope_bytes",
+    (True, 0, -1),
+)
+def test_invalid_injected_envelope_is_not_converted_to_geometry_fallback(
+    memory_envelope_bytes: object,
+) -> None:
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=4,
+        component_count=4,
+        candidate_probe_count=2,
+        verification_probe_count=2,
+        runtime_parameter_count=2,
+    )
+
+    with pytest.raises(ValueError, match="memory envelope is invalid") as captured:
+        recurrence_warmup._select_raw_evidence_storage_geometry_for_counts(
+            geometry,
+            memory_envelope_bytes=memory_envelope_bytes,  # type: ignore[arg-type]
+        )
+
+    assert not isinstance(
+        captured.value,
+        RecurrenceNumericalEvidenceEnvelopeExceeded,
+    )
+
+
+def test_geometry_fallback_precedes_static_context_and_current_capture(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=4,
+        component_count=4,
+        candidate_probe_count=2,
+        verification_probe_count=2,
+        runtime_parameter_count=2,
+    )
+    outcome = RecurrenceNumericalEvidenceEnvelopeExceeded(
+        geometry,
+        memory_envelope_bytes=1,
+        spooled_producer_resident_bytes=2,
+        raw_reason="injected test envelope",
+    )
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_select_raw_evidence_storage_geometry",
+        lambda *_args, **_kwargs: (_ for _ in ()).throw(outcome),
+    )
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_build_warmup_static_context",
+        lambda *_args, **_kwargs: pytest.fail(
+            "static context was built after an envelope fallback"
+        ),
+    )
+
+    with pytest.raises(RecurrenceNumericalEvidenceEnvelopeExceeded) as raised:
+        run_recurrence_numerical_current_warmup(
+            _topology_replay_plan(),
+            candidate_points=_points(1),
+            verification_points=_points(101),
+            mode="certified-reuse",
+            color_accuracy="lc",
+            precision_digits=80,
+            seed=53,
+            relative_tolerance=1.0e-60,
+            absolute_tolerance=1.0e-70,
+        )
+
+    assert raised.value is outcome
+
+
+def test_envelope_fallback_has_reuse_off_runtime_and_visible_provenance() -> None:
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=4,
+        component_count=4,
+        candidate_probe_count=2,
+        verification_probe_count=2,
+        runtime_parameter_count=2,
+    )
+    with pytest.raises(RecurrenceNumericalEvidenceEnvelopeExceeded) as captured:
+        recurrence_warmup._select_raw_evidence_storage_geometry_for_counts(
+            geometry,
+            memory_envelope_bytes=1 << 20,
+        )
+    plan = _topology_replay_plan()
+    fallback = recurrence_numerical_current_envelope_fallback_report(
+        plan.sections,
+        color_accuracy="lc",
+        requested_mode="certified-reuse",
+        outcome=captured.value,
+    )
+    explicit_off = recurrence_numerical_current_opt_out_report(
+        plan.sections,
+        color_accuracy="lc",
+    )
+
+    fallback_runtime, fallback_aggregate = _recurrence_relation_reporting(
+        {},
+        mode="certified-reuse",
+        lane_report=fallback,
+    )
+    off_runtime, off_aggregate = _recurrence_relation_reporting(
+        {},
+        mode="off",
+        lane_report=explicit_off,
+    )
+
+    assert fallback_runtime == off_runtime == {}
+    assert fallback_aggregate["effective_mode"] == "off"
+    assert fallback_aggregate["effective_reuse_state"] == "disabled"
+    assert fallback_aggregate["applied_relation_count"] == 0
+    assert fallback_aggregate["fallback"]["reason"] == ("evidence-envelope-fallback")
+    assert fallback_aggregate["warning"]["required"] is True
+    assert off_aggregate["applied_relation_count"] == 0
+    assert recurrence_numerical_relation_correctness_summary(fallback_aggregate) == {
+        "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+        "state": "no-applied-relations",
+        "applied_relation_count": 0,
+    }
+    assert recurrence_numerical_relation_fallback_summary(fallback_aggregate) == {
+        "abi": "pyamplicol-numerical-current-reuse-fallback-v1",
+        "requested_mode": "certified-reuse",
+        "effective_mode": "off",
+        "effective_reuse_state": "disabled",
+        "reason": "evidence-envelope-fallback",
+        "geometry": geometry.to_json_dict(),
+        "certified_relation_count": 0,
+        "applied_relation_count": 0,
+    }
+    with pytest.raises(ValueError, match="fallback provenance is absent"):
+        recurrence_numerical_relation_fallback_summary(
+            {**fallback_aggregate, "fallback": None}
+        )
+    fallback_payload = fallback["fallback"]
+    assert isinstance(fallback_payload, Mapping)
+    fallback_geometry = fallback_payload["geometry"]
+    assert isinstance(fallback_geometry, Mapping)
+
+    for mutation in (
+        {"effective_reuse_state": "enabled"},
+        {"state": "disabled-by-user"},
+        {"fallback": {"reason": "evidence-envelope-fallback"}},
+        {
+            "fallback": {
+                **fallback_payload,
+                "geometry": {
+                    **fallback_geometry,
+                    "scalar_count": 1,
+                },
+            }
+        },
+        {
+            "fallback": {
+                **fallback_payload,
+                "spooled_producer_resident_bytes": (
+                    int(fallback_payload["spooled_producer_resident_bytes"]) + 1
+                ),
+            }
+        },
+    ):
+        with pytest.raises(GenerationError):
+            _recurrence_relation_reporting(
+                {},
+                mode="certified-reuse",
+                lane_report={**fallback, **mutation},
+            )
+
+    with pytest.raises(GenerationError, match="opt-out metadata"):
+        _recurrence_relation_reporting(
+            {},
+            mode="off",
+            lane_report={**explicit_off, "effective_reuse_state": "enabled"},
+        )
+
+
+def _fallback_lowering_output(
+    tmp_path: Path,
+    name: str,
+    *,
+    inspection: Mapping[str, object],
+) -> generation_service._RustRecurrenceLoweringOutput:
+    return generation_service._RustRecurrenceLoweringOutput(
+        inspection_summary=inspection,
+        resolved_helicities=(),
+        amplitude_destinations=(),
+        structural_zero_physical_sector_certificate=None,
+        exact_sections={},
+        generation_profile={"pass": name},
+        numerical_current_reuse_report=None,
+        payload_path=tmp_path / f"{name}.pacbin",
+        payload_size_bytes=1,
+        payload_sha256="a" * 64,
+        member_count=1,
+        unpacked_size_bytes=1,
+        index_sha256="b" * 64,
+    )
+
+
+@pytest.mark.parametrize(
+    ("plan_factory", "mode", "expected_lowering_calls"),
+    (
+        (_no_relation_plan, "certified-reuse", 1),
+        (_topology_replay_plan, "diagnostic", 2),
+    ),
+)
+def test_service_only_skips_second_lowering_for_zero_certificates(
+    tmp_path: Path,
+    plan_factory: object,
+    mode: str,
+    expected_lowering_calls: int,
+) -> None:
+    assert callable(plan_factory)
+    warmup = run_recurrence_numerical_current_warmup(
+        plan_factory(),
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode=mode,  # type: ignore[arg-type]
+        color_accuracy="lc",
+        precision_digits=80,
+        seed=71,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+    calls: list[tuple[Path, dict[str, object]]] = []
+
+    def lower_once(
+        destination: Path,
+        **kwargs: object,
+    ) -> generation_service._RustRecurrenceLoweringOutput:
+        calls.append((destination, dict(kwargs)))
+        pass_name = "baseline" if len(calls) == 1 else "final"
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_bytes(f"{pass_name}-payload".encode("ascii"))
+        return replace(
+            _fallback_lowering_output(
+                tmp_path,
+                pass_name,
+                inspection={"runtime": pass_name},
+            ),
+            resolved_helicities=((len(calls),),),
+            exact_sections={"pass": pass_name},
+            payload_path=destination,
+            payload_size_bytes=destination.stat().st_size,
+            payload_sha256=str(len(calls)) * 64,
+        )
+
+    baseline = lower_once(
+        tmp_path / ".baseline" / "recurrence-runtime.pacbin",
+        mode="off",
+        evidence=None,
+        report_progress=True,
+        timing_name="native-baseline-generation",
+    )
+    final_path = tmp_path / "final" / "recurrence-runtime.pacbin"
+    if not warmup.certificates:
+        warmup = warmup.without_evidence_transport()
+    try:
+        output, application_validation_required = (
+            generation_service._lower_recurrence_after_numerical_warmup(
+                lower_once=lower_once,
+                final_schedule_path=final_path,
+                baseline=baseline,
+                warmup=warmup,
+                requested_mode=mode,
+            )
+        )
+        assert len(calls) == expected_lowering_calls
+        assert application_validation_required is bool(warmup.certificates)
+        assert output.payload_path == final_path
+        if not warmup.certificates:
+            assert final_path.read_bytes() == b"baseline-payload"
+            assert not baseline.payload_path.exists()
+            assert output.resolved_helicities == baseline.resolved_helicities
+            assert output.exact_sections == baseline.exact_sections
+            assert output.inspection_summary == {"runtime": "baseline"}
+            assert output.generation_profile == {
+                "schema_version": 1,
+                "native_passes": {"final": {"pass": "baseline"}},
+            }
+            report = output.numerical_current_reuse_report
+            assert isinstance(report, Mapping)
+            assert report["requested_mode"] == mode
+            assert report["effective_mode"] == warmup.effective_mode
+            assert report["certified_relation_count"] == 0
+            assert report["applied_relation_count"] == 0
+            assert report["native_relation_application"] is None
+        else:
+            assert mode == "diagnostic"
+            assert final_path.read_bytes() == b"final-payload"
+            assert output.numerical_current_reuse_report is None
+            assert calls[1][1] == {
+                "mode": warmup.effective_mode,
+                "evidence": warmup.evidence_json,
+                "report_progress": False,
+                "timing_name": "native-final-generation",
+            }
+    finally:
+        warmup.close()
+
+
+def test_service_fallback_publishes_the_existing_reuse_off_lowering(
+    tmp_path: Path,
+) -> None:
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=4,
+        component_count=4,
+        candidate_probe_count=2,
+        verification_probe_count=2,
+        runtime_parameter_count=2,
+    )
+    outcome = RecurrenceNumericalEvidenceEnvelopeExceeded(
+        geometry,
+        memory_envelope_bytes=1,
+        spooled_producer_resident_bytes=(
+            geometry.spooled_producer_resident_upper_bound()
+        ),
+        raw_reason="injected test envelope",
+    )
+
+    calls: list[tuple[Path, dict[str, object]]] = []
+
+    def lower_once(
+        destination: Path,
+        **kwargs: object,
+    ) -> generation_service._RustRecurrenceLoweringOutput:
+        calls.append((destination, dict(kwargs)))
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_bytes(b"validated-mode-off-payload")
+        return replace(
+            _fallback_lowering_output(
+                tmp_path,
+                "baseline",
+                inspection={"runtime": "original-plan"},
+            ),
+            payload_path=destination,
+            payload_size_bytes=destination.stat().st_size,
+        )
+
+    baseline_path = tmp_path / ".baseline" / "recurrence-runtime.pacbin"
+    baseline = lower_once(
+        baseline_path,
+        mode="off",
+        evidence=None,
+        report_progress=True,
+        timing_name="native-baseline-generation",
+    )
+    final_schedule_path = tmp_path / "recurrence-runtime.pacbin"
+    completed = generation_service._complete_recurrence_evidence_envelope_fallback(
+        final_schedule_path=final_schedule_path,
+        baseline=baseline,
+        baseline_plan=_topology_replay_plan(),
+        color_accuracy="lc",
+        outcome=outcome,
+    )
+
+    assert calls == [
+        (
+            baseline_path,
+            {
+                "mode": "off",
+                "evidence": None,
+                "report_progress": True,
+                "timing_name": "native-baseline-generation",
+            },
+        )
+    ]
+    assert completed.payload_path == final_schedule_path
+    assert final_schedule_path.read_bytes() == b"validated-mode-off-payload"
+    assert not baseline_path.exists()
+    assert completed.inspection_summary == {"runtime": "original-plan"}
+    assert completed.generation_profile == {
+        "schema_version": 1,
+        "native_passes": {"final": {"pass": "baseline"}},
+    }
+    report = completed.numerical_current_reuse_report
+    assert isinstance(report, Mapping)
+    assert report["requested_mode"] == "certified-reuse"
+    assert report["effective_mode"] == "off"
+    assert report["effective_reuse_state"] == "disabled"
+    assert report["applied_relation_count"] == 0
+    report_fallback = report["fallback"]
+    assert isinstance(report_fallback, Mapping)
+    assert report_fallback["geometry"] == geometry.to_json_dict()
+
+
+def test_python_envelope_fallback_detaches_exception_before_publish(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class RetainedFrameResource:
+        pass
+
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=4,
+        component_count=4,
+        candidate_probe_count=2,
+        verification_probe_count=2,
+        runtime_parameter_count=2,
+    )
+    retained: list[weakref.ReferenceType[RetainedFrameResource]] = []
+
+    def fail_warmup() -> None:
+        frame_resource = RetainedFrameResource()
+        retained.append(weakref.ref(frame_resource))
+        try:
+            raise RuntimeError("canonical evidence writer overflow")
+        except RuntimeError as cause:
+            raise RecurrenceNumericalEvidenceEnvelopeExceeded(
+                geometry,
+                memory_envelope_bytes=1,
+                spooled_producer_resident_bytes=(
+                    geometry.spooled_producer_resident_upper_bound()
+                ),
+                raw_reason="injected Python warmup envelope",
+            ) from cause
+
+    try:
+        fail_warmup()
+    except RecurrenceNumericalEvidenceEnvelopeExceeded as exc:
+        detached = generation_service._detached_recurrence_evidence_envelope_outcome(
+            exc,
+            source_error=exc,
+        )
+    else:  # pragma: no cover - the injected fallback is mandatory
+        raise AssertionError("injected Python fallback did not fail")
+
+    assert detached.__traceback__ is None
+    assert detached.__cause__ is None
+    assert detached.__context__ is None
+    assert detached.to_json_dict()["geometry"] == geometry.to_json_dict()
+
+    baseline = _fallback_lowering_output(tmp_path, "baseline", inspection={})
+    baseline.payload_path.write_bytes(b"baseline")
+    publish = generation_service._publish_validated_recurrence_baseline
+
+    def publish_without_retained_exception(
+        *,
+        baseline: generation_service._RustRecurrenceLoweringOutput,
+        final_schedule_path: Path,
+    ) -> generation_service._RustRecurrenceLoweringOutput:
+        gc.collect()
+        assert retained[0]() is None
+        return publish(
+            baseline=baseline,
+            final_schedule_path=final_schedule_path,
+        )
+
+    monkeypatch.setattr(
+        generation_service,
+        "_publish_validated_recurrence_baseline",
+        publish_without_retained_exception,
+    )
+
+    generation_service._complete_recurrence_evidence_envelope_fallback(
+        final_schedule_path=tmp_path / "python-fallback.pacbin",
+        baseline=baseline,
+        baseline_plan=_topology_replay_plan(),
+        color_accuracy="lc",
+        outcome=detached,
+    )
+
+
+def test_native_capacity_fallback_releases_warmup_before_publish(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class RetainedResource:
+        pass
+
+    class WarmupOwner:
+        def __init__(
+            self,
+            retained: list[weakref.ReferenceType[RetainedResource]],
+            events: list[str],
+        ) -> None:
+            self.evidence_transport = RetainedResource()
+            self.candidate_capture = RetainedResource()
+            self.verification_capture = RetainedResource()
+            self.open_spool: RetainedResource | None = RetainedResource()
+            retained.extend(
+                weakref.ref(value)
+                for value in (
+                    self.evidence_transport,
+                    self.candidate_capture,
+                    self.verification_capture,
+                    self.open_spool,
+                )
+            )
+            self._events = events
+
+        def close(self) -> None:
+            self._events.append("warmup-closed")
+            self.open_spool = None
+
+    message = (
+        "raw numerical evidence exceeds the streaming 1 GiB resident memory envelope"
+    )
+    retained_frames: list[weakref.ReferenceType[RetainedResource]] = []
+
+    def fail_native() -> None:
+        frame_resource = RetainedResource()
+        retained_frames.append(weakref.ref(frame_resource))
+        raise GenerationError(message)
+
+    plan = _topology_replay_plan()
+    try:
+        fail_native()
+    except GenerationError as exc:
+        outcome = recurrence_warmup.recurrence_numerical_evidence_capacity_outcome(
+            plan.sections,
+            candidate_probe_count=2,
+            verification_probe_count=2,
+            runtime_parameter_count=len(plan.runtime_parameter_schema),
+            error=exc,
+        )
+        assert isinstance(outcome, RecurrenceNumericalEvidenceEnvelopeExceeded)
+        detached = generation_service._detached_recurrence_evidence_envelope_outcome(
+            outcome,
+            source_error=exc,
+        )
+    else:  # pragma: no cover - the injected fallback is mandatory
+        raise AssertionError("injected native fallback did not fail")
+
+    events: list[str] = []
+    retained_warmup: list[weakref.ReferenceType[RetainedResource]] = []
+    warmup = WarmupOwner(retained_warmup, events)
+    warmup_owner = [warmup]
+    del warmup
+    baseline = _fallback_lowering_output(tmp_path, "baseline", inspection={})
+    baseline.payload_path.write_bytes(b"baseline")
+    publish = generation_service._publish_validated_recurrence_baseline
+
+    def publish_without_evidence(
+        *,
+        baseline: generation_service._RustRecurrenceLoweringOutput,
+        final_schedule_path: Path,
+    ) -> generation_service._RustRecurrenceLoweringOutput:
+        gc.collect()
+        events.append("publish")
+        assert warmup_owner == []
+        assert retained_frames[0]() is None
+        assert all(reference() is None for reference in retained_warmup)
+        assert detached.__traceback__ is None
+        assert detached.__cause__ is None
+        assert detached.__context__ is None
+        return publish(
+            baseline=baseline,
+            final_schedule_path=final_schedule_path,
+        )
+
+    monkeypatch.setattr(
+        generation_service,
+        "_publish_validated_recurrence_baseline",
+        publish_without_evidence,
+    )
+
+    generation_service._complete_recurrence_evidence_envelope_fallback(
+        final_schedule_path=tmp_path / "native-fallback.pacbin",
+        baseline=baseline,
+        baseline_plan=plan,
+        color_accuracy="lc",
+        outcome=detached,
+        warmup_owner=warmup_owner,  # type: ignore[arg-type]
+    )
+    assert events == ["warmup-closed", "publish"]
+
+
+def test_compressed_canonical_transport_round_trips_with_length_and_digest() -> None:
+    value = {
+        "candidate_capture": {"observations": []},
+        "verification_capture": {"observations": []},
+    }
+    expected = json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("ascii")
+    with tempfile.TemporaryFile() as stream:
+        canonical_bytes = _write_compressed_canonical_evidence(
+            value,
+            stream,
+            canonical_byte_limit=1 << 20,
+        )
+        encoded = _read_compressed_evidence_spool(stream)
+
+    magic, declared_bytes, digest = _COMPRESSED_EVIDENCE_HEADER.unpack_from(encoded)
+    assert magic == b"PACNCEZ1"
+    assert canonical_bytes == declared_bytes == len(expected)
+    assert zlib.decompress(encoded[_COMPRESSED_EVIDENCE_HEADER.size :]) == expected
+    assert digest.hex() == hashlib.sha256(expected).hexdigest()
+
+
+def test_compressed_warmup_keeps_relation_rows_spooled_through_validation(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_select_raw_evidence_storage_geometry",
+        lambda *_args, **_kwargs: recurrence_warmup._RawEvidenceStorageGeometry(
+            scalar_count=128,
+            row_count=16,
+            canonical_byte_limit=1 << 20,
+            encoding="zlib-canonical-json-v1",
+            producer_resident_upper_bound=1 << 20,
+        ),
+    )
+    plan = _topology_replay_plan()
+    result = run_recurrence_numerical_current_warmup(
+        plan,
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="certified-reuse",
+        color_accuracy="lc",
+        precision_digits=80,
+        seed=53,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+    candidate_spool = result.candidate_capture.observations
+    assert result.verification_capture is not None
+    verification_spool = result.verification_capture.observations
+    assert isinstance(candidate_spool, _SpooledObservationMapping)
+    assert isinstance(verification_spool, _SpooledObservationMapping)
+    assert result.evidence_transport_bytes == len(result.evidence_json)
+    consumed = result.without_evidence_transport()
+    assert consumed.evidence_json == b""
+    assert consumed.evidence_transport_bytes == result.evidence_transport_bytes
+    try:
+        validated = validate_recurrence_numerical_current_application(
+            consumed,
+            plan,
+            baseline_plan=plan,
+            precision_digits=80,
+            seed=53,
+            relative_tolerance=1.0e-60,
+            absolute_tolerance=1.0e-70,
+        )
+        persisted = validated.to_json_dict()["persisted_numerical_evidence"]
+        assert persisted["generation_evidence_encoding"] == ("zlib-canonical-json-v1")
+        assert validated.application_validation["status"] == "verified"
+    finally:
+        result.close()
+        result.close()
+    with pytest.raises(RuntimeError, match="spool is closed"):
+        candidate_spool[0]
+    with pytest.raises(RuntimeError, match="spool is closed"):
+        verification_spool[0]
+
+
+def test_explicit_raw_wire_limit_is_honored_without_compression(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_select_raw_evidence_storage_geometry",
+        lambda *_args, **_kwargs: recurrence_warmup._RawEvidenceStorageGeometry(
+            scalar_count=128,
+            row_count=16,
+            canonical_byte_limit=128,
+            encoding="canonical-json-v3",
+            producer_resident_upper_bound=1 << 20,
+        ),
+    )
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_write_compressed_canonical_evidence",
+        lambda *_args, **_kwargs: pytest.fail(
+            "late raw overflow attempted compressed evidence transport"
+        ),
+    )
+
+    with pytest.raises(
+        recurrence_warmup._CanonicalEvidenceCapacityExceeded
+    ) as captured:
+        run_recurrence_numerical_current_warmup(
+            _topology_replay_plan(),
+            candidate_points=_points(1),
+            verification_points=_points(101),
+            mode="certified-reuse",
+            color_accuracy="lc",
+            precision_digits=80,
+            seed=53,
+            relative_tolerance=1.0e-60,
+            absolute_tolerance=1.0e-70,
+        )
+
+    assert "canonical boundary" in str(captured.value)
+
+
+def test_initial_compressed_capacity_error_is_propagated(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_select_raw_evidence_storage_geometry",
+        lambda *_args, **_kwargs: recurrence_warmup._RawEvidenceStorageGeometry(
+            scalar_count=128,
+            row_count=16,
+            canonical_byte_limit=1 << 20,
+            encoding="zlib-canonical-json-v1",
+            producer_resident_upper_bound=1 << 20,
+        ),
+    )
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_write_compressed_canonical_evidence",
+        lambda *_args, **_kwargs: (_ for _ in ()).throw(
+            recurrence_warmup._CanonicalEvidenceCapacityExceeded(
+                "injected compressed transport capacity"
+            )
+        ),
+    )
+
+    with pytest.raises(
+        recurrence_warmup._CanonicalEvidenceCapacityExceeded
+    ) as captured:
+        run_recurrence_numerical_current_warmup(
+            _topology_replay_plan(),
+            candidate_points=_points(1),
+            verification_points=_points(101),
+            mode="certified-reuse",
+            color_accuracy="lc",
+            precision_digits=80,
+            seed=53,
+            relative_tolerance=1.0e-60,
+            absolute_tolerance=1.0e-70,
+        )
+
+    assert "compressed transport capacity" in str(captured.value)
+
+
+def test_native_capacity_classifier_excludes_integrity_and_structure_errors() -> None:
+    sections = _topology_replay_plan().sections
+    outcome = recurrence_warmup.recurrence_numerical_evidence_capacity_outcome(
+        sections,
+        candidate_probe_count=4,
+        verification_probe_count=4,
+        runtime_parameter_count=2,
+        error=ArtifactError(
+            "raw numerical evidence exceeds the streaming 1 GiB resident memory "
+            "envelope"
+        ),
+    )
+
+    assert isinstance(outcome, RecurrenceNumericalEvidenceEnvelopeExceeded)
+    assert outcome.geometry.current_count == len(sections.currents)
+    assert (
+        validate_recurrence_numerical_evidence_fallback(outcome.to_json_dict())
+        == outcome.to_json_dict()
+    )
+    for message in (
+        "compressed numerical relation evidence digest mismatch",
+        "numerical relation evidence JSON lexical structure is incomplete",
+        "recurrence runtime parameter schema/defaults do not match",
+    ):
+        assert (
+            recurrence_warmup.recurrence_numerical_evidence_capacity_outcome(
+                sections,
+                candidate_probe_count=4,
+                verification_probe_count=4,
+                runtime_parameter_count=2,
+                error=ArtifactError(message),
+            )
+            is None
+        )
+
+
+def test_spooled_discovery_preserves_global_equal_opposite_and_zero_relations() -> None:
+    plan = _signed_relation_plan()
+    source_digest = recurrence_numerical_source_semantics_sha256(plan.sections)
+    candidate = capture_recurrence_current_observations(
+        plan,
+        _points(1),
+        precision_digits=80,
+        source_semantics_sha256=source_digest,
+        seed=67,
+        domain="candidate-current-probes-v1",
+    )
+    verification = capture_recurrence_current_observations(
+        plan,
+        _points(101),
+        precision_digits=80,
+        source_semantics_sha256=source_digest,
+        seed=67,
+        domain="independent-verification-current-probes-v1",
+    )
+    expected, _expected_report = _discover_relations(
+        plan.sections,
+        candidate,
+        verification,
+        source_semantics_sha256=source_digest,
+        precision_digits=80,
+        seed=67,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+        color_accuracy="lc",
+    )
+    candidate_spool = _SpooledObservationMapping(
+        candidate.observations,
+        candidate_indexes=_build_candidate_indexes(
+            plan.sections,
+            candidate.observations,
+        ),
+    )
+    verification_spool = _SpooledObservationMapping(
+        verification.observations,
+    )
+    try:
+        actual, _actual_report = _discover_relations(
+            plan.sections,
+            replace(candidate, observations=candidate_spool),
+            replace(verification, observations=verification_spool),
+            source_semantics_sha256=source_digest,
+            precision_digits=80,
+            seed=67,
+            relative_tolerance=1.0e-60,
+            absolute_tolerance=1.0e-70,
+            color_accuracy="lc",
+        )
+    finally:
+        candidate_spool.close()
+        verification_spool.close()
+
+    assert actual == expected
+    assert {
+        (certificate.current_id, certificate.relation_kind) for certificate in actual
+    } >= {(3, "equal"), (4, "opposite"), (5, "zero")}
+
+
+def test_synthetic_multi_helicity_all_flow_skips_unsafe_selector_hypotheses() -> None:
+    plan = _signed_relation_plan()
+    source_digest = recurrence_numerical_source_semantics_sha256(plan.sections)
+    candidate = capture_recurrence_current_observations(
+        plan,
+        _points(1),
+        precision_digits=80,
+        source_semantics_sha256=source_digest,
+        seed=67,
+        domain="candidate-current-probes-v1",
+    )
+    verification = capture_recurrence_current_observations(
+        plan,
+        _points(101),
+        precision_digits=80,
+        source_semantics_sha256=source_digest,
+        seed=67,
+        domain="independent-verification-current-probes-v1",
+    )
+    sections = replace(
+        plan.sections,
+        strategy="all-flow-union",
+        replay_targets=(),
+        resolved_helicities=(
+            _ResolvedHelicity(0, 0, 0, 0, 2, 2, 2, 0),
+            _ResolvedHelicity(2, 2, 2, 1, 2, 2, 2, 0),
+        ),
+    )
+
+    certificates, report = _discover_relations(
+        sections,
+        candidate,
+        verification,
+        source_semantics_sha256=source_digest,
+        precision_digits=80,
+        seed=67,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+        color_accuracy="lc",
+    )
+
+    assert certificates == ()
+    scope = report["application_scope"]
+    assert scope["multi_helicity_all_flow_domain_ids"] == [0]
+    assert scope["multi_helicity_all_flow_application"] == "disabled"
+    assert scope["suppressed_current_count"] == 4
+    assert report["tested_hypothesis_count"] == 0
+    candidate_index = report["candidate_index"]
+    assert candidate_index["theoretical_pair_hypothesis_count"] == 0
+    assert candidate_index["screened_pair_hypothesis_count"] == 0
+    assert candidate_index["zero_hypothesis_count"] == 0
+    assert (
+        recurrence_warmup._effective_numerical_relation_mode(
+            sections,
+            requested_mode="certified-reuse",
+            certificates=certificates,
+        )
+        == "diagnostic"
+    )
+
+
+def test_contracted_binary64_policy_keeps_census_but_contains_opposite_relations() -> (
+    None
+):
+    plan = _signed_relation_plan()
+    source_digest = recurrence_numerical_source_semantics_sha256(plan.sections)
+    candidate = capture_recurrence_current_observations(
+        plan,
+        _points(1),
+        precision_digits=80,
+        source_semantics_sha256=source_digest,
+        seed=67,
+        domain="candidate-current-probes-v1",
+    )
+    verification = capture_recurrence_current_observations(
+        plan,
+        _points(101),
+        precision_digits=80,
+        source_semantics_sha256=source_digest,
+        seed=67,
+        domain="independent-verification-current-probes-v1",
+    )
+    sections = replace(
+        plan.sections,
+        strategy="contracted-color-union",
+        replay_targets=(),
+    )
+
+    certificates, report = _discover_relations(
+        sections,
+        candidate,
+        verification,
+        source_semantics_sha256=source_digest,
+        precision_digits=80,
+        seed=67,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+        color_accuracy="full",
+    )
+
+    relation_kinds = {certificate.relation_kind for certificate in certificates}
+    assert relation_kinds == {"equal", "opposite", "zero"}
+    assert report["application_scope"]["contracted_opposite_application"] == "disabled"
+    assert (
+        recurrence_warmup._effective_numerical_relation_mode(
+            sections,
+            requested_mode="certified-reuse",
+            certificates=certificates,
+        )
+        == "certified-reuse"
+    )
+    eligible = recurrence_warmup._applicable_numerical_certificates(
+        certificates, application_scope=report["application_scope"]
+    )
+    assert {certificate.relation_kind for certificate in eligible} == {"equal", "zero"}
+    assert len(eligible) == 2
+    assert all(
+        any(item is certificate for item in certificates) for certificate in eligible
+    )
+    assert (
+        recurrence_warmup._effective_numerical_relation_mode(
+            sections,
+            requested_mode="certified-reuse",
+            certificates=tuple(
+                certificate
+                for certificate in certificates
+                if certificate.relation_kind == "opposite"
+            ),
+        )
+        == "diagnostic"
+    )
+
+
+def test_contracted_partial_reuse_preserves_full_native_evidence_and_census() -> None:
+    result = run_recurrence_numerical_current_warmup(
+        _contracted_signed_relation_plan(),
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="certified-reuse",
+        color_accuracy="full",
+        precision_digits=80,
+        seed=67,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+    try:
+        assert len(result.certificates) == 3
+        assert result.applied_relation_count == 2
+        assert {item.relation_kind for item in result.applied_certificates} == {
+            "equal",
+            "zero",
+        }
+        assert result.effective_mode_reason is None
+        evidence = json.loads(result.evidence_json)
+        assert len(evidence["certificates"]) == len(evidence["mappings"]) == 3
+        assert {item["relation_kind"] for item in evidence["mappings"]} == {
+            "equal",
+            "opposite",
+            "zero",
+        }
+        report = result.to_json_dict()
+        assert report["certified_relation_count"] == 3
+        assert report["applied_relation_count"] == 2
+        assert report["application"]["certified_relation_count"] == 3
+        assert report["application"]["applied_relation_count"] == 2
+        assert len(report["application"]["certificates"]) == 3
+        assert (
+            report["persisted_numerical_evidence"]["full_census"][
+                "certificate_set_sha256"
+            ]
+            == evidence["certificate_set_sha256"]
+        )
+        assert 4 not in result.candidate_capture.observations
+        assert 5 in result.candidate_capture.observations
+        assert result.warning_required is True
+    finally:
+        result.close()
+
+
+def test_applicable_relation_preserves_a_skipped_opposite_representative() -> None:
+    plan = _contracted_signed_relation_plan()
+    result = run_recurrence_numerical_current_warmup(
+        plan,
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="certified-reuse",
+        color_accuracy="full",
+        precision_digits=80,
+        seed=67,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+    try:
+        opposite = next(
+            item for item in result.certificates if item.relation_kind == "opposite"
+        )
+        # Application filtering does not create certificates or rewrite their
+        # representative. The native mapper keeps skipped currents computed.
+        dependent = replace(
+            result.applied_certificates[0],
+            current_id=opposite.current_id + 2,
+            representative_id=opposite.current_id,
+            execution_representative_id=opposite.current_id,
+            relation_kind="equal",
+        )
+        filtered = recurrence_warmup._applicable_numerical_certificates(
+            (opposite, dependent),
+            application_scope=result.discovery_report["application_scope"],
+        )
+        assert filtered == (dependent,)
+        assert filtered[0] is dependent
+        assert filtered[0].execution_representative_id == opposite.current_id
+    finally:
+        result.close()
+
+
+def test_discovery_reads_each_candidate_current_once_and_reuses_residual_text(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    plan = _no_relation_plan()
+    source_digest = recurrence_numerical_source_semantics_sha256(plan.sections)
+    candidate = capture_recurrence_current_observations(
+        plan,
+        _points(1),
+        precision_digits=80,
+        source_semantics_sha256=source_digest,
+        seed=71,
+        domain="candidate-current-probes-v1",
+    )
+    verification = capture_recurrence_current_observations(
+        plan,
+        _points(101),
+        precision_digits=80,
+        source_semantics_sha256=source_digest,
+        seed=71,
+        domain="independent-verification-current-probes-v1",
+    )
+    candidate_indexes = _build_candidate_indexes(
+        plan.sections,
+        candidate.observations,
+    )
+    expected_certificates, expected_report = _discover_relations(
+        plan.sections,
+        candidate,
+        verification,
+        source_semantics_sha256=source_digest,
+        precision_digits=80,
+        seed=71,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+        color_accuracy="lc",
+        candidate_indexes=candidate_indexes,
+    )
+    spool = _SpooledObservationMapping(candidate.observations)
+
+    class CountingRows(
+        Mapping[int, tuple[tuple[Decimal, Decimal], ...]],
+    ):
+        def __init__(self) -> None:
+            self.reads: dict[int, int] = {}
+
+        def __getitem__(
+            self,
+            current_id: int,
+        ) -> tuple[tuple[Decimal, Decimal], ...]:
+            self.reads[current_id] = self.reads.get(current_id, 0) + 1
+            return spool[current_id]
+
+        def __iter__(self) -> Iterator[int]:
+            return iter(spool)
+
+        def __len__(self) -> int:
+            return len(spool)
+
+    rows = CountingRows()
+    fraction_string_calls = 0
+    fraction_string = recurrence_warmup._fraction_string
+
+    def counted_fraction_string(value: Fraction) -> str:
+        nonlocal fraction_string_calls
+        fraction_string_calls += 1
+        return fraction_string(value)
+
+    monkeypatch.setattr(
+        recurrence_warmup,
+        "_fraction_string",
+        counted_fraction_string,
+    )
+    try:
+        actual_certificates, actual_report = _discover_relations(
+            plan.sections,
+            replace(candidate, observations=rows),
+            verification,
+            source_semantics_sha256=source_digest,
+            precision_digits=80,
+            seed=71,
+            relative_tolerance=1.0e-60,
+            absolute_tolerance=1.0e-70,
+            color_accuracy="lc",
+            candidate_indexes=candidate_indexes,
+        )
+    finally:
+        spool.close()
+
+    assert actual_certificates == expected_certificates == ()
+    assert actual_report == expected_report
+    assert rows.reads == {2: 1, 3: 1}
+    assert fraction_string_calls == 3 * (
+        int(actual_report["tested_hypothesis_count"]) + 1
+    )
+
+
+def test_dynamic_raw_geometry_rejects_adversarial_sizes_and_reserves_wire() -> None:
+    with pytest.raises(ValueError, match="memory envelope"):
+        _raw_evidence_wire_byte_limit(
+            scalar_count=1 << 63,
+            row_count=1 << 63,
+        )
+
+    maximum = _raw_evidence_wire_byte_limit(
+        scalar_count=0,
+        row_count=0,
+    )
+    assert maximum == (_RAW_EVIDENCE_MEMORY_TARGET_BYTES - (32 << 20)) // 2
+    assert maximum >= _MIN_RAW_EVIDENCE_WIRE_BYTES
+
+
+@pytest.mark.parametrize("text", ("1e+20000", "1e-20000"))
+def test_raw_evidence_accepts_decimal_widths_above_the_old_ceiling(
+    text: str,
+) -> None:
+    encoded = _decimal_string(Decimal(text))
+    assert len(encoded) > 16_384
+    assert Decimal(encoded) == Decimal(text)
+
+
+def test_shared_candidate_index_is_complete_at_exact_signed_boundaries() -> None:
+    large = Fraction(10**100)
+    observations = {
+        0: ((Fraction(100, 9), Fraction(0)), (large, Fraction(0))),
+        1: ((Fraction(-100, 9), Fraction(0)), (-large, Fraction(0))),
+        2: ((Fraction(1_000), Fraction(0)), (Fraction(0), Fraction(0))),
+        4: ((Fraction(10), Fraction(0)), (large, Fraction(0))),
+    }
+    index = build_numerical_observation_candidate_index(
+        (0, 1, 2, 4),
+        observations,
+        normalize=Fraction,
+    )
+    assert (index.observation_index, index.scalar_component) == (0, 0)
+    common = {
+        "current_id": 4,
+        "relative_tolerance": Fraction(1, 10),
+        "absolute_tolerance": Fraction(0),
+        "normalize": Fraction,
+    }
+    assert numerical_observation_tolerance_window_ids(
+        index,
+        observations[4],
+        relation_kind="equal",
+        **common,
+    ) == (0,)
+    assert numerical_observation_tolerance_window_ids(
+        index,
+        observations[4],
+        relation_kind="opposite",
+        **common,
+    ) == (1,)
+    # The unrelated 10**100 component has zero residual for the accepted
+    # signed pairs and cannot enlarge the selected pair's tolerance window.
+    assert abs(Fraction(10) - Fraction(100, 9)) == Fraction(10, 9)
+    assert Fraction(1, 10) * Fraction(100, 9) == Fraction(10, 9)
+
+
+def test_rejected_diagnostic_full_digest_binds_unretained_tail() -> None:
+    retained = tuple({"current_id": index} for index in range(16))
+    root = "00" * 32
+    common_tail = _advance_rejection_digest(root, {"current_id": 16})
+    left_digest = _advance_rejection_digest(common_tail, {"current_id": 17})
+    right_digest = _advance_rejection_digest(common_tail, {"current_id": 18})
+    left = _rejected_candidate_diagnostics(
+        retained,
+        total_rejected=18,
+        full_census={"tested": 18},
+        full_rejection_sha256=left_digest,
+    )
+    right = _rejected_candidate_diagnostics(
+        retained,
+        total_rejected=18,
+        full_census={"tested": 18},
+        full_rejection_sha256=right_digest,
+    )
+    assert left["retained_sha256"] == right["retained_sha256"]
+    assert left["full_census_sha256"] == right["full_census_sha256"]
+    assert left["full_rejection_sha256"] != right["full_rejection_sha256"]
+    assert left["truncated"] is True
+
+
+@pytest.mark.parametrize(
+    ("relative_tolerance", "absolute_tolerance"),
+    (
+        (-0.0, 1.0e-70),
+        (1.0e-60, -0.0),
+        (float("nan"), 1.0e-70),
+        (1.0e-60, float("inf")),
+    ),
+)
+def test_recurrence_raw_evidence_rejects_noncanonical_tolerances_before_capture(
+    relative_tolerance: float,
+    absolute_tolerance: float,
+) -> None:
+    with pytest.raises(ValueError, match="tolerances are invalid"):
+        run_recurrence_numerical_current_warmup(
+            _topology_replay_plan(),
+            candidate_points=_points(1),
+            verification_points=_points(101),
+            mode="certified-reuse",
+            color_accuracy="lc",
+            precision_digits=80,
+            seed=53,
+            relative_tolerance=relative_tolerance,
+            absolute_tolerance=absolute_tolerance,
+        )
+
+
+@pytest.mark.parametrize("partial_contracted", (False, True))
+def test_recurrence_aggregate_reports_applied_warning_and_explicit_opt_out(
+    partial_contracted: bool,
+) -> None:
+    result = run_recurrence_numerical_current_warmup(
+        (
+            _contracted_signed_relation_plan()
+            if partial_contracted
+            else _topology_replay_plan()
+        ),
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="certified-reuse",
+        color_accuracy="full" if partial_contracted else "lc",
+        precision_digits=80,
+        seed=71,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+    lane = result.to_json_dict()
+    discovery = lane["discovery"]
+    application = lane["application"]
+    assert isinstance(discovery, dict)
+    assert isinstance(application, dict)
+    certified = len(result.certificates)
+    applied = result.applied_relation_count
+    assert (certified, applied) == ((3, 2) if partial_contracted else (1, 1))
+    native = {
+        "requested_mode": "certified-reuse",
+        "state": "native-applied",
+        "exact_certified_relation_count": certified,
+        "applied_relation_count": applied,
+        "certificate_count": certified,
+        "numerical_candidate_count": discovery["numerical_candidate_count"],
+        "uncertified_candidate_count": discovery["verification_rejected_count"],
+        "rejected_hypothesis_count": discovery["rejected_hypothesis_count"],
+        "certificate_replay": application["certificate_replay"],
+        "probe": {
+            "probe_count": lane["candidate_capture"]["point_count"],
+            "verification_probe_count": (lane["verification_capture"]["point_count"]),
+            "verification_rejected_count": discovery["verification_rejected_count"],
+            "tested_hypothesis_count": discovery["tested_hypothesis_count"],
+            "runtime_parameter_schema_sha256": lane["candidate_capture"][
+                "runtime_parameter_schema_sha256"
+            ],
+            "candidate_observation_batch_sha256": lane["candidate_capture"][
+                "observation_batch_sha256"
+            ],
+            "verification_observation_batch_sha256": lane["verification_capture"][
+                "observation_batch_sha256"
+            ],
+            "decision_sha256": discovery["decision_sha256"],
+            "rejection_decision_sha256": discovery["rejection_decision_sha256"],
+        },
+        "rejected_candidate_diagnostics": {
+            "total_rejected_hypothesis_count": discovery["rejected_hypothesis_count"],
+            "full_rejection_sha256": discovery["rejection_decision_sha256"],
+        },
+    }
+    runtime_inspection, aggregate = _recurrence_relation_reporting(
+        {"relation_discovery": native},
+        mode="certified-reuse",
+        lane_report=lane,
+    )
+    assert "relation_discovery" not in runtime_inspection
+    assert aggregate["execution_mode"] == "recurrence"
+    assert aggregate["lanes"]["primary"]["applied_relation_count"] == applied
+    assert aggregate["certified_relation_count"] == certified
+    assert aggregate["applied_relation_count"] == applied
+    assert aggregate["warning"]["required"] is True
+    assert aggregate["warning"]["emit"] == "once-per-generated-artifact"
+    assert aggregate["native_relation_application"] == native
+
+    for mutation in (
+        {"requested_mode": "diagnostic"},
+        {"exact_certified_relation_count": 0},
+        {"applied_relation_count": 0},
+        {"certificate_count": 0},
+        {
+            "certificate_replay": {
+                **native["certificate_replay"],
+                "certificate_set_sha256": "0" * 64,
+            }
+        },
+        {
+            "probe": {
+                **native["probe"],
+                "verification_probe_count": 3,
+            }
+        },
+    ):
+        drifted = {**native, **mutation}
+        with pytest.raises(GenerationError):
+            _recurrence_relation_reporting(
+                {"relation_discovery": drifted},
+                mode="certified-reuse",
+                lane_report=lane,
+            )
+
+    if partial_contracted:
+        for incorrect_count in (1, 3):
+            with pytest.raises(GenerationError):
+                _recurrence_relation_reporting(
+                    {
+                        "relation_discovery": {
+                            **native,
+                            "applied_relation_count": incorrect_count,
+                        }
+                    },
+                    mode="certified-reuse",
+                    lane_report={**lane, "applied_relation_count": incorrect_count},
+                )
+
+    off_lane = recurrence_numerical_current_opt_out_report(
+        _topology_replay_plan().sections,
+        color_accuracy="lc",
+    )
+    off_runtime_inspection, off_aggregate = _recurrence_relation_reporting(
+        {},
+        mode="off",
+        lane_report=off_lane,
+    )
+    assert "relation_discovery" not in off_runtime_inspection
+    assert off_aggregate["requested_mode"] == "off"
+    assert off_aggregate["lanes"]["primary"]["state"] == "disabled-by-user"
+    assert off_aggregate["warning"]["required"] is False
+
+
+def test_application_rejects_current_dimension_drift() -> None:
+    result = run_recurrence_numerical_current_warmup(
+        _topology_replay_plan(),
+        candidate_points=_points(1),
+        verification_points=_points(101),
+        mode="certified-reuse",
+        color_accuracy="lc",
+        precision_digits=80,
+        seed=79,
+        relative_tolerance=1.0e-60,
+        absolute_tolerance=1.0e-70,
+    )
+    drifted = _topology_replay_plan()
+    current = drifted.sections.currents[3]
+    drifted.sections = replace(
+        drifted.sections,
+        currents=(
+            *drifted.sections.currents[:3],
+            replace(current, component_count=2),
+        ),
+    )
+
+    try:
+        validate_recurrence_numerical_current_application(
+            result,
+            drifted,
+            baseline_plan=_topology_replay_plan(),
+            precision_digits=80,
+            seed=79,
+            relative_tolerance=1.0e-60,
+            absolute_tolerance=1.0e-70,
+        )
+    except (ArtifactError, ValueError):
+        pass
+    else:  # pragma: no cover - fail-closed contract
+        raise AssertionError("current-dimension drift was accepted")
+
+
+def test_recurrence_service_forwards_complete_numerical_contract_to_pyo3(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    calls: list[tuple[tuple[object, ...], dict[str, object]]] = []
+
+    def binding(*args: object, **kwargs: object) -> object:
+        calls.append((args, kwargs))
+        Path(str(args[5])).write_bytes(b"pacbin")
+        dispatch_destination = kwargs.get("helicity_dispatch_destination")
+        if dispatch_destination is not None:
+            Path(str(dispatch_destination)).write_bytes(b"dispatch")
+        return object()
+
+    native = SimpleNamespace(_lower_recurrence_direct_v2=binding)
+    monkeypatch.setattr(
+        generation_service.importlib,
+        "import_module",
+        lambda _name: native,
+    )
+    monkeypatch.setattr(
+        generation_service,
+        "verify_native_module",
+        lambda _module: None,
+    )
+    monkeypatch.setattr(
+        generation_service,
+        "_validate_rust_recurrence_lowering_result",
+        lambda *_args, **kwargs: {
+            "inspection_summary": {},
+            "resolved_helicities": (),
+            "amplitude_destinations": (),
+            "structural_zero_physical_sector_certificate": None,
+            "exact_sections": {},
+            "generation_profile": {"serialized_bytes": {"container": len(b"pacbin")}},
+            "member_count": 1,
+            "unpacked_size_bytes": 6,
+            "index_sha256": "b" * 64,
+            "helicity_dispatch": (
+                {
+                    "abi": "pyamplicol-recurrence-helicity-dispatch-v1",
+                    "size_bytes": len(b"dispatch"),
+                    "sha256": hashlib.sha256(b"dispatch").hexdigest(),
+                    "base_runtime_layout_digest": "2" * 64,
+                    "resolved_helicity_count": 4,
+                }
+                if kwargs["expect_helicity_dispatch"]
+                else None
+            ),
+        },
+    )
+    builder = SimpleNamespace(digest="c" * 64, layout="topology-replay")
+    template = SimpleNamespace(digest="d" * 64)
+    catalog = SimpleNamespace(
+        catalog_digest="e" * 64,
+        to_dict=lambda: {"z": 1, "a": 2},
+    )
+
+    def progress(_payload: object) -> None:
+        pass
+
+    evidence = b'{"raw":"evidence"}'
+    destination = tmp_path / "recurrence-runtime.pacbin"
+
+    output = generation_service._invoke_rust_recurrence_lowering_v2(
+        builder,
+        template,
+        catalog,
+        "f" * 64,
+        "1" * 64,
+        destination,
+        point_tile_size=17,
+        workspace_mib=23,
+        relation_discovery_mode="certified-reuse",
+        relation_discovery_precision_digits=101,
+        relation_discovery_probe_count=3,
+        relation_discovery_verification_probe_count=5,
+        relation_discovery_relative_tolerance=1.25e-70,
+        relation_discovery_absolute_tolerance=2.5e-80,
+        relation_discovery_seed=123456789,
+        color_accuracy="nlc",
+        relation_discovery_evidence_json=evidence,
+        progress_callback=progress,
+    )
+    cached_destination = tmp_path / "recurrence-runtime-cached.pacbin"
+    cached_catalog = SimpleNamespace(
+        catalog_digest="e" * 64,
+        to_dict=lambda: pytest.fail("cached direct-template JSON was rebuilt"),
+    )
+    cached_output = generation_service._invoke_rust_recurrence_lowering_v2(
+        builder,
+        template,
+        cached_catalog,
+        "f" * 64,
+        "1" * 64,
+        cached_destination,
+        point_tile_size=17,
+        workspace_mib=23,
+        relation_discovery_mode="certified-reuse",
+        relation_discovery_precision_digits=101,
+        relation_discovery_probe_count=3,
+        relation_discovery_verification_probe_count=5,
+        relation_discovery_relative_tolerance=1.25e-70,
+        relation_discovery_absolute_tolerance=2.5e-80,
+        relation_discovery_seed=123456789,
+        color_accuracy="nlc",
+        relation_discovery_evidence_json=evidence,
+        progress_callback=progress,
+        direct_template_catalog_json=b'{"a":2,"z":1}',
+    )
+    dispatch_destination = tmp_path / "recurrence-helicity-dispatch-v1.bin"
+    dispatched_output = generation_service._invoke_rust_recurrence_lowering_v2(
+        builder,
+        template,
+        cached_catalog,
+        "f" * 64,
+        "1" * 64,
+        tmp_path / "recurrence-runtime-dispatched.pacbin",
+        point_tile_size=17,
+        workspace_mib=23,
+        relation_discovery_mode="off",
+        relation_discovery_precision_digits=101,
+        relation_discovery_probe_count=3,
+        relation_discovery_verification_probe_count=5,
+        relation_discovery_relative_tolerance=1.25e-70,
+        relation_discovery_absolute_tolerance=2.5e-80,
+        relation_discovery_seed=123456789,
+        color_accuracy="full",
+        helicity_dispatch_destination=dispatch_destination,
+        direct_template_catalog_json=b'{"a":2,"z":1}',
+    )
+
+    assert output.payload_path == destination
+    assert output.generation_profile == {
+        "serialized_bytes": {"container": len(b"pacbin")}
+    }
+    assert cached_output.payload_path == cached_destination
+    assert dispatched_output.helicity_dispatch is not None
+    assert dispatched_output.helicity_dispatch.payload_path == dispatch_destination
+    assert (
+        dispatched_output.helicity_dispatch.payload_sha256
+        == hashlib.sha256(b"dispatch").hexdigest()
+    )
+    assert len(calls) == 3
+    args, kwargs = calls[0]
+    assert args[:2] == (builder, template)
+    assert args[2] == b'{"a":2,"z":1}'
+    assert args[3:5] == ("f" * 64, "1" * 64)
+    assert args[5] == str(destination)
+    assert kwargs == {
+        "point_tile_size": 17,
+        "workspace_mib": 23,
+        "relation_discovery_mode": "certified-reuse",
+        "relation_discovery_precision_digits": 101,
+        "relation_discovery_probe_count": 3,
+        "relation_discovery_verification_probe_count": 5,
+        "relation_discovery_relative_tolerance": 1.25e-70,
+        "relation_discovery_absolute_tolerance": 2.5e-80,
+        "relation_discovery_seed": 123456789,
+        "color_accuracy": "nlc",
+        "relation_discovery_evidence_json": evidence,
+        "helicity_dispatch_destination": None,
+        "progress_callback": progress,
+    }
+    cached_args, cached_kwargs = calls[1]
+    assert cached_args[2] == args[2]
+    assert cached_kwargs == kwargs
+    assert calls[2][1]["helicity_dispatch_destination"] == str(dispatch_destination)
+
+
+def test_recurrence_service_preserves_native_capacity_message_for_fallback(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    message = (
+        "raw numerical evidence exceeds the streaming 1 GiB resident memory envelope"
+    )
+
+    def binding(*_args: object, **_kwargs: object) -> object:
+        # Native evidence validation exposes invalid_argument as ValueError;
+        # the service wrapper deliberately retains the exact marker in its
+        # typed GenerationError for the bounded fallback classifier.
+        raise ValueError(message)
+
+    native = SimpleNamespace(_lower_recurrence_direct_v2=binding)
+    monkeypatch.setattr(
+        generation_service.importlib,
+        "import_module",
+        lambda _name: native,
+    )
+    monkeypatch.setattr(
+        generation_service,
+        "verify_native_module",
+        lambda _module: None,
+    )
+    builder = SimpleNamespace(digest="c" * 64, layout="topology-replay")
+    template = SimpleNamespace(digest="d" * 64)
+    catalog = SimpleNamespace(
+        catalog_digest="e" * 64,
+        to_dict=lambda: {"z": 1, "a": 2},
+    )
+
+    with pytest.raises(GenerationError, match="streaming 1 GiB") as captured:
+        generation_service._invoke_rust_recurrence_lowering_v2(
+            builder,
+            template,
+            catalog,
+            "f" * 64,
+            "1" * 64,
+            tmp_path / "recurrence-runtime.pacbin",
+            point_tile_size=17,
+            workspace_mib=23,
+            relation_discovery_mode="certified-reuse",
+            relation_discovery_precision_digits=101,
+            relation_discovery_probe_count=3,
+            relation_discovery_verification_probe_count=5,
+            relation_discovery_relative_tolerance=1.25e-70,
+            relation_discovery_absolute_tolerance=2.5e-80,
+            relation_discovery_seed=123456789,
+            color_accuracy="nlc",
+            relation_discovery_evidence_json=b"{}",
+            progress_callback=None,
+        )
+    outcome = recurrence_warmup.recurrence_numerical_evidence_capacity_outcome(
+        _topology_replay_plan().sections,
+        candidate_probe_count=3,
+        verification_probe_count=5,
+        runtime_parameter_count=2,
+        error=captured.value,
+    )
+    assert isinstance(outcome, RecurrenceNumericalEvidenceEnvelopeExceeded)
diff --git a/pyamplicol/tests/unit/test_recurrence_pairing_columnar.py b/pyamplicol/tests/unit/test_recurrence_pairing_columnar.py
new file mode 100644
index 0000000000..01b55c7e50
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_pairing_columnar.py
@@ -0,0 +1,342 @@
+# SPDX-License-Identifier: 0BSD
+"""Private fixed-width fermion-pairing columnar ABI tests."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import replace
+
+import numpy as np
+import pytest
+
+import pyamplicol.generation.recurrence_pairing_columnar as pairing_columnar
+from pyamplicol.generation.recurrence_columnar import RecurrenceColumnarInputError
+from pyamplicol.generation.recurrence_fermion_pairing import (
+    NO_FERMION_LINE,
+    FermionPairingCatalogV1,
+    build_recurrence_fermion_pairing_catalog_v1,
+)
+from pyamplicol.models.recurrence_template import CurrentStateTemplateV1
+from pyamplicol.processes.ir import (
+    CanonicalProcessIR,
+    ColorEndpointSummary,
+    ProcessLegIR,
+)
+
+
+def _state_pair(
+    token: str,
+    particle_id: int,
+    *,
+    species_id: str | None = None,
+) -> tuple[CurrentStateTemplateV1, CurrentStateTemplateV1]:
+    species = species_id or f"contract:{token}:species"
+    particle = CurrentStateTemplateV1(
+        template_id=f"{token}:particle",
+        particle_id=particle_id,
+        anti_particle_id=-particle_id,
+        species_id=species,
+        orientation="particle",
+        statistics="fermion",
+        color_representation=3,
+        basis="generic-fermion",
+        tensor_ordering=("s0", "s1"),
+        dimension=2,
+        chirality=1,
+        lc_color_shape_kind="fundamental-open-string",
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+    antiparticle = CurrentStateTemplateV1(
+        template_id=f"{token}:antiparticle",
+        particle_id=-particle_id,
+        anti_particle_id=particle_id,
+        species_id=species,
+        orientation="antiparticle",
+        statistics="fermion",
+        color_representation=-3,
+        basis="generic-fermion",
+        tensor_ordering=("s0", "s1"),
+        dimension=2,
+        chirality=-1,
+        lc_color_shape_kind="antifundamental-open-string",
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+    return particle, antiparticle
+
+
+def _fermion_leg(label: int, state: CurrentStateTemplateV1) -> ProcessLegIR:
+    role = (
+        "fundamental"
+        if state.lc_color_shape_kind == "fundamental-open-string"
+        else "antifundamental"
+    )
+    return ProcessLegIR(
+        label=label,
+        side="final",
+        particle=state.template_id,
+        outgoing_particle=state.template_id,
+        pdg=state.particle_id,
+        outgoing_pdg=state.particle_id,
+        statistics="fermion",
+        wavefunction_family="fermion",
+        color_role=role,
+        source_orientation=state.orientation,
+    )
+
+
+def _fermion_process(
+    key: str, states: Iterable[CurrentStateTemplateV1]
+) -> CanonicalProcessIR:
+    materialized = tuple(states)
+    fundamentals = sum(
+        state.lc_color_shape_kind == "fundamental-open-string" for state in materialized
+    )
+    antifundamentals = len(materialized) - fundamentals
+    return CanonicalProcessIR(
+        process="canonical pairing-columnar fixture",
+        key=key,
+        color_accuracy="lc",
+        legs=tuple(
+            _fermion_leg(index + 1, state) for index, state in enumerate(materialized)
+        ),
+        color_endpoints=ColorEndpointSummary(
+            fundamental_count=fundamentals,
+            antifundamental_count=antifundamentals,
+            pair_count=min(fundamentals, antifundamentals),
+        ),
+    )
+
+
+def _boson_process() -> CanonicalProcessIR:
+    legs = tuple(
+        ProcessLegIR(
+            label=index + 1,
+            side="final",
+            particle="g",
+            outgoing_particle="g",
+            pdg=21,
+            outgoing_pdg=21,
+            statistics="boson",
+            wavefunction_family="vector",
+            color_role="adjoint",
+            source_orientation="inclusive",
+        )
+        for index in range(2)
+    )
+    return CanonicalProcessIR(
+        process="g g",
+        key="boson-only",
+        color_accuracy="lc",
+        legs=legs,
+        color_endpoints=ColorEndpointSummary(
+            fundamental_count=0,
+            antifundamental_count=0,
+            pair_count=0,
+        ),
+    )
+
+
+def _encode(catalog: FermionPairingCatalogV1):  # type: ignore[no-untyped-def]
+    return pairing_columnar._encode_fermion_pairing_catalog_v1(catalog)
+
+
+def _table_rows(payload, name: str, *columns: str):  # type: ignore[no-untyped-def]
+    table = payload.table(name)
+    return tuple(
+        tuple(int(table.column(column)[row]) for column in columns)
+        for row in range(table.row_count)
+    )
+
+
+def _header_digest(payload, name: str) -> str:  # type: ignore[no-untyped-def]
+    return bytes(payload.table("header").column(name)[0]).hex()
+
+
+def _identical_catalog(
+    *, token: str = "identical", species_id: str | None = None
+) -> FermionPairingCatalogV1:
+    particle, antiparticle = _state_pair(token, 930001, species_id=species_id)
+    external = (antiparticle, particle, particle, antiparticle)
+    return build_recurrence_fermion_pairing_catalog_v1(
+        _fermion_process("identical-two-line", external),
+        (particle, antiparticle),
+    )
+
+
+def test_no_fermion_catalog_encodes_one_trivial_rule() -> None:
+    catalog = build_recurrence_fermion_pairing_catalog_v1(_boson_process(), ())
+    payload = _encode(catalog)
+
+    assert payload.table("endpoints").row_count == 0
+    assert payload.table("pairing_classes").row_count == 0
+    assert payload.table("rules").row_count == 1
+    assert _table_rows(payload, "rule_source_slot_permutations", "source_slot") == (
+        (0,),
+        (1,),
+    )
+    assert _table_rows(payload, "rule_lineages", "line_id") == (
+        (NO_FERMION_LINE,),
+        (NO_FERMION_LINE,),
+    )
+    assert int(payload.table("rules").column("fermion_parity")[0]) == 1
+
+
+def test_distinct_lines_encode_endpoint_classes_and_flat_ranges() -> None:
+    first, first_anti = _state_pair("first", 910001)
+    second, second_anti = _state_pair("second", 920001)
+    external = (first_anti, first, second, second_anti)
+    catalog = build_recurrence_fermion_pairing_catalog_v1(
+        _fermion_process("distinct-two-line", external),
+        (second_anti, first, first_anti, second),
+    )
+
+    payload = _encode(catalog)
+
+    assert _table_rows(
+        payload,
+        "rule_endpoint_pairings",
+        "fundamental_source_slot",
+        "antifundamental_source_slot",
+    ) == ((1, 0), (2, 3))
+    assert _table_rows(payload, "rule_lineages", "line_id") == (
+        (0,),
+        (0,),
+        (1,),
+        (1,),
+    )
+    classes = payload.table("pairing_classes")
+    assert tuple(int(value) for value in classes.column("pairing_count")) == (1, 1)
+    assert tuple(int(value) for value in classes.column("reference_pairing_start")) == (
+        0,
+        1,
+    )
+
+
+def test_identical_lines_encode_direct_exchange_and_exact_integer_limbs() -> None:
+    payload = _encode(_identical_catalog())
+
+    rules = payload.table("rules")
+    assert tuple(int(value) for value in rules.column("fermion_parity")) == (1, -1)
+    assert _table_rows(
+        payload,
+        "rule_endpoint_pairings",
+        "fundamental_source_slot",
+        "antifundamental_source_slot",
+    ) == ((1, 0), (2, 3), (1, 3), (2, 0))
+    assert _table_rows(payload, "rule_source_slot_permutations", "source_slot") == (
+        (0,),
+        (1,),
+        (2,),
+        (3,),
+        (3,),
+        (1,),
+        (2,),
+        (0,),
+    )
+
+    integers = payload.table("exact_integers")
+    signs = tuple(int(value) for value in integers.column("sign"))
+    assert signs == (-1, 0, 1)
+    assert _table_rows(payload, "exact_integer_limbs", "value") == ((1,), (1,))
+    assert tuple(int(value) for value in rules.column("real_numerator_integer_id")) == (
+        2,
+        0,
+    )
+
+
+def test_encoding_is_deterministic_and_model_equivalent_topology_is_stable() -> None:
+    builtin = _identical_catalog(
+        token="builtin:matter", species_id="builtin:model-owned:matter"
+    )
+    ufo = _identical_catalog(token="ufo:matter", species_id="ufo:model-owned:matter")
+    first = _encode(builtin)
+    repeated = _encode(builtin)
+    equivalent = _encode(ufo)
+
+    for left, right in zip(first.tables, repeated.tables, strict=True):
+        for left_column, right_column in zip(left.columns, right.columns, strict=True):
+            assert np.array_equal(left_column.values, right_column.values)
+            assert left_column.values.dtype.str in {"|u1", "<u4", "<u8", "<i4"}
+            assert left_column.values.flags.c_contiguous
+            assert left_column.values.flags.owndata
+            assert not left_column.values.flags.writeable
+
+    assert _header_digest(first, "topology_digest") == _header_digest(
+        equivalent, "topology_digest"
+    )
+    assert _header_digest(first, "semantic_digest") != _header_digest(
+        equivalent, "semantic_digest"
+    )
+    for table_name in (
+        "rules",
+        "rule_class_pairing_indices",
+        "rule_endpoint_pairings",
+        "rule_source_slot_permutations",
+        "rule_lineages",
+    ):
+        left = first.table(table_name)
+        right = equivalent.table(table_name)
+        for left_column, right_column in zip(left.columns, right.columns, strict=True):
+            if left_column.name == "proof_algorithm_string_id":
+                continue
+            assert np.array_equal(left_column.values, right_column.values)
+
+
+def test_private_freeze_adopts_schema_exact_owned_columns() -> None:
+    columns = pairing_columnar._allocate("rule_endpoint_pairings", 2)
+    columns["fundamental_source_slot"][:] = (2, 3)
+    columns["antifundamental_source_slot"][:] = (4, 5)
+    original = dict(columns)
+
+    table = pairing_columnar._freeze_table("rule_endpoint_pairings", columns)
+
+    for column in table.columns:
+        assert column.values is original[column.name]
+        assert column.values.flags.owndata
+        assert column.values.flags.c_contiguous
+        assert not column.values.flags.writeable
+
+
+def test_private_freeze_does_not_coerce_a_schema_mismatch() -> None:
+    payload = _encode(_identical_catalog())
+    columns = pairing_columnar._allocate("rule_endpoint_pairings", 4)
+    wrong_dtype = columns["fundamental_source_slot"].astype("<u8")
+    columns["fundamental_source_slot"] = wrong_dtype
+
+    malformed = pairing_columnar._freeze_table("rule_endpoint_pairings", columns)
+
+    assert malformed.column("fundamental_source_slot") is not wrong_dtype
+    assert malformed.column("fundamental_source_slot").dtype == wrong_dtype.dtype
+    tables = tuple(
+        malformed if table.name == "rule_endpoint_pairings" else table
+        for table in payload.tables
+    )
+    with pytest.raises(
+        RecurrenceColumnarInputError,
+        match="wrong little-endian fixed-width representation",
+    ):
+        pairing_columnar._FermionPairingColumnarV1(payload.abi, tables)
+
+
+def test_malformed_catalog_and_integer_bounds_fail_closed() -> None:
+    catalog = _identical_catalog()
+    with pytest.raises(RecurrenceColumnarInputError, match="topology digest"):
+        _encode(replace(catalog, topology_digest="0" * 64))
+
+    stale_endpoint = replace(catalog.endpoints[0], endpoint_id=1)
+    with pytest.raises(RecurrenceColumnarInputError, match="endpoint IDs"):
+        _encode(replace(catalog, endpoints=(stale_endpoint, *catalog.endpoints[1:])))
+
+    stale_rule = replace(
+        catalog.rules[0],
+        source_slot_permutation=(0, 0, 2, 3),
+    )
+    with pytest.raises(RecurrenceColumnarInputError, match="source-slot permutation"):
+        _encode(replace(catalog, rules=(stale_rule, *catalog.rules[1:])))
+
+    with pytest.raises(RecurrenceColumnarInputError, match="does not fit u32"):
+        _encode(replace(catalog, source_count=1 << 32))
diff --git a/pyamplicol/tests/unit/test_recurrence_preflight.py b/pyamplicol/tests/unit/test_recurrence_preflight.py
new file mode 100644
index 0000000000..670270eaa8
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_preflight.py
@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.api import ModelSource
+from pyamplicol.api.errors import GenerationError
+from pyamplicol.config import ColorConfig, EvaluatorConfig, RunConfig
+from pyamplicol.generation.service import GenerationBackend
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _backend(*, accuracy: str = "lc") -> GenerationBackend:
+    return GenerationBackend(
+        RunConfig(
+            action="generate",
+            color=ColorConfig(accuracy=accuracy),
+            evaluator=EvaluatorConfig(execution_mode="recurrence"),
+        ),
+        None,
+    )
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_recurrence_accepts_contracted_color_before_process_expansion(
+    accuracy: str,
+) -> None:
+    _backend(accuracy=accuracy)._validate_recurrence_request()
+
+
+def test_recurrence_lc_is_fail_closed_before_generic_dag_construction() -> None:
+    backend = _backend()
+    process = build_process_ir("d d~ > z g")
+
+    with pytest.raises(GenerationError, match="recurrence-template-v1"):
+        backend._compile_concrete_process(process, BuiltinSMModel())
+
+
+def test_recurrence_requires_prepared_template_with_exact_rebuild_command() -> None:
+    backend = _backend()
+    source = ModelSource(kind="prepared", path=Path("model.pyamplicol-model"))
+    resolved = SimpleNamespace(
+        source=source,
+        compiled=SimpleNamespace(
+            prepared_bundle=SimpleNamespace(
+                kernel_pack=SimpleNamespace(recurrence_template=None)
+            )
+        ),
+    )
+
+    with pytest.raises(
+        GenerationError,
+        match=(
+            r"pyamplicol-recurrence-template-v1.*pyamplicol model compile "
+            r".*model\.pyamplicol-model MODEL\.pyamplicol-model --backend jit"
+        ),
+    ):
+        backend._require_eager_kernel_pack(resolved)  # type: ignore[arg-type]
diff --git a/pyamplicol/tests/unit/test_recurrence_projection.py b/pyamplicol/tests/unit/test_recurrence_projection.py
new file mode 100644
index 0000000000..1850662371
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_projection.py
@@ -0,0 +1,1613 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from dataclasses import replace
+
+import pytest
+
+from pyamplicol.color.plan import (
+    GenericColorPlan,
+    LCColorSector,
+    LCColorSectorReplayPartition,
+    LCColorTopologyReplayPlan,
+    LCOpenColorLine,
+    build_color_plan,
+    build_color_topology_replay_certificate,
+)
+from pyamplicol.generation.recurrence_columnar import (
+    ExactComplexRationalV1 as BuilderExact,
+)
+from pyamplicol.generation.recurrence_columnar import (
+    RecurrenceNormalizationV1,
+    build_recurrence_builder_input_v1,
+)
+from pyamplicol.generation.recurrence_physics import (
+    recurrence_color_contraction_destinations,
+    recurrence_color_sector_owner_map,
+)
+from pyamplicol.generation.recurrence_projection import (
+    RecurrenceGenerationSliceV1,
+    RecurrenceProjectionError,
+    project_recurrence_process_v1,
+)
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.prepared_catalog import build_prepared_kernel_catalog
+from pyamplicol.models.recurrence_catalog_builder import (
+    build_recurrence_template_catalog,
+)
+from pyamplicol.models.recurrence_template import (
+    CurrentStateTemplateV1,
+    EvaluatorBindingV1,
+    ExactComplexRationalV1,
+    LCColorSourceSeedV1,
+    ParameterTemplateV1,
+    RecurrenceTemplateCatalog,
+    SourceTemplateV1,
+    SymmetryProofV1,
+)
+from pyamplicol.processes.ir import (
+    CanonicalProcessIR,
+    ColorEndpointSummary,
+    ParticleStatistics,
+    ProcessLegIR,
+    WavefunctionFamily,
+)
+
+
+def _sha(value: str) -> str:
+    return hashlib.sha256(value.encode("ascii")).hexdigest()
+
+
+def _crossing(
+    *,
+    momentum_transform: str = "negate-four-momentum",
+    phase: tuple[int, int] = (1, 0),
+) -> str:
+    return json.dumps(
+        {
+            "chirality_factor": -1,
+            "helicity_factor": -1,
+            "momentum_transform": momentum_transform,
+            "phase": {
+                "imag_denominator": "1",
+                "imag_numerator": str(phase[1]),
+                "real_denominator": "1",
+                "real_numerator": str(phase[0]),
+            },
+            "spin_state_factor": -1,
+        },
+        separators=(",", ":"),
+        sort_keys=True,
+    )
+
+
+def _state(
+    template_id: str,
+    particle_id: int,
+    *,
+    family: str,
+    dimension: int,
+) -> CurrentStateTemplateV1:
+    color_representation = 8 if particle_id == 21 else 3 if particle_id > 0 else -3
+    color_shape = (
+        "adjoint-segment"
+        if particle_id == 21
+        else "fundamental-open-string"
+        if particle_id > 0
+        else "antifundamental-open-string"
+    )
+    return CurrentStateTemplateV1(
+        template_id=template_id,
+        particle_id=particle_id,
+        anti_particle_id=-particle_id if abs(particle_id) == 1 else particle_id,
+        species_id=f"species:{abs(particle_id)}",
+        orientation=(
+            "self-conjugate"
+            if particle_id == 21
+            else "particle"
+            if particle_id > 0
+            else "antiparticle"
+        ),
+        statistics="fermion" if family == "fermion" else "boson",
+        color_representation=color_representation,
+        basis=family,
+        tensor_ordering=tuple(f"{family}:c{index}" for index in range(dimension)),
+        dimension=dimension,
+        chirality=0,
+        lc_color_shape_kind=color_shape,
+        auxiliary_kind=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+    )
+
+
+def _source(
+    state: CurrentStateTemplateV1,
+    *,
+    helicity: int,
+    family: str,
+) -> tuple[SourceTemplateV1, EvaluatorBindingV1]:
+    token = f"source:{state.particle_id}:{helicity}"
+    resolver = f"resolver:{state.particle_id}:{helicity}"
+    signature = _sha(f"callable:{token}")
+    source = SourceTemplateV1(
+        template_id=token,
+        state_template_id=state.template_id,
+        crossing=_crossing(),
+        wavefunction_family=family,
+        helicity=helicity,
+        spin_state=helicity,
+        flavour_flow=(state.particle_id,),
+        quantum_number_flow=(),
+        lc_color_seed=LCColorSourceSeedV1(
+            operation="singleton",
+            output_shape_kind=state.lc_color_shape_kind,
+            component_kind=(
+                "adjoint-segment"
+                if state.lc_color_shape_kind == "adjoint-segment"
+                else "open-string"
+            ),
+            component_role="active",
+            proof_digest=_sha(f"source-seed:{state.template_id}"),
+            provenance=(("test-fixture", "model-generic-source-contract"),),
+        ),
+        wavefunction_expression_digest=signature,
+        evaluator_resolver_key=resolver,
+    )
+    output_layout = tuple(
+        f"source-component:{index}" for index in range(state.dimension)
+    )
+    binding = EvaluatorBindingV1(
+        resolver_key=resolver,
+        prepared_kernel_id=None,
+        callable_kind="rusticol-template",
+        runtime_template=(f"rusticol.source-fill.{family}.v1:{signature[:24]}"),
+        contract_kind="source",
+        callable_signature=signature,
+        input_state_template_ids=(),
+        output_state_template_id=state.template_id,
+        input_layout=("momentum:energy",),
+        output_layout=output_layout,
+        exact_expression_digests=tuple(
+            _sha(f"expression:{token}:{index}") for index in range(state.dimension)
+        ),
+        semantic_template_ids=(source.template_id,),
+    )
+    return source, binding
+
+
+def _catalog(*, omit_particle: int | None = None) -> RecurrenceTemplateCatalog:
+    states = (
+        _state("state:anti-u", -1, family="fermion", dimension=2),
+        _state("state:u", 1, family="fermion", dimension=2),
+        _state("state:g", 21, family="vector", dimension=4),
+    )
+    source_pairs = tuple(
+        _source(
+            state,
+            helicity=helicity,
+            family="vector" if state.particle_id == 21 else "fermion",
+        )
+        for state in states
+        if state.particle_id != omit_particle
+        for helicity in (-1, 1)
+    )
+    parameter = ParameterTemplateV1(
+        template_id="parameter:alpha_s",
+        name="alpha_s",
+        parameter_kind="external",
+        value_type="real",
+        mutable=True,
+        default_value=ExactComplexRationalV1(1, 10, 0, 1),
+        exact_expression_digest=None,
+        dependency_parameter_ids=(),
+    )
+    return RecurrenceTemplateCatalog.create(
+        compiled_model_digest=_sha("compiled-model"),
+        prepared_kernel_pack_digest=_sha("prepared-kernel-pack"),
+        parameters=(parameter,),
+        current_states=states,
+        sources=tuple(pair[0] for pair in source_pairs),
+        evaluator_bindings=tuple(pair[1] for pair in source_pairs),
+    )
+
+
+def _catalog_with_reflection_phases(
+    *phases: int,
+) -> RecurrenceTemplateCatalog:
+    base = _catalog()
+    proofs = tuple(
+        SymmetryProofV1(
+            template_id=f"proof:current-reflection:{index}",
+            proof_algorithm="canonical-current-word-reversal-v1",
+            subject_template_ids=("state:g",),
+            input_permutation=(1, 0),
+            exact_phase=ExactComplexRationalV1.from_fractions(phase),
+            expression_digests=(_sha(f"reflection-expression:{index}"),),
+            witness_digest=_sha(f"reflection-witness:{index}"),
+        )
+        for index, phase in enumerate(phases)
+    )
+    return RecurrenceTemplateCatalog.create(
+        compiled_model_digest=base.header.compiled_model_digest,
+        prepared_kernel_pack_digest=base.header.prepared_kernel_pack_digest,
+        parameters=base.parameters,
+        current_states=base.current_states,
+        sources=base.sources,
+        quantum_flows=base.quantum_flows,
+        transitions=base.transitions,
+        propagators=base.propagators,
+        closures=base.closures,
+        color_contractions=base.color_contractions,
+        symmetry_proofs=proofs,
+        runtime_helicity_contracts=base.runtime_helicity_contracts,
+        evaluator_bindings=base.evaluator_bindings,
+    )
+
+
+def _process(*, color_accuracy: str = "lc") -> CanonicalProcessIR:
+    return CanonicalProcessIR(
+        process="u u~ > g g",
+        key="u_ubar_to_g_g",
+        color_accuracy=color_accuracy,
+        legs=(
+            ProcessLegIR(
+                1,
+                "initial",
+                "u",
+                "u~",
+                1,
+                -1,
+                "fermion",
+                "fermion",
+                "antifundamental",
+                "antiparticle",
+            ),
+            ProcessLegIR(
+                2,
+                "initial",
+                "u~",
+                "u",
+                -1,
+                1,
+                "fermion",
+                "fermion",
+                "fundamental",
+                "particle",
+            ),
+            ProcessLegIR(
+                3,
+                "final",
+                "g",
+                "g",
+                21,
+                21,
+                "boson",
+                "vector",
+                "adjoint",
+                "self-conjugate",
+            ),
+            ProcessLegIR(
+                4,
+                "final",
+                "g",
+                "g",
+                21,
+                21,
+                "boson",
+                "vector",
+                "adjoint",
+                "self-conjugate",
+            ),
+        ),
+        color_endpoints=ColorEndpointSummary(1, 1, 1),
+    )
+
+
+def _pure_gluon_process() -> CanonicalProcessIR:
+    legs = tuple(
+        ProcessLegIR(
+            label,
+            "initial" if label <= 2 else "final",
+            "g",
+            "g",
+            21,
+            21,
+            "boson",
+            "vector",
+            "adjoint",
+            "self-conjugate",
+        )
+        for label in range(1, 5)
+    )
+    return CanonicalProcessIR(
+        process="g g > g g",
+        key="g_g_to_g_g",
+        color_accuracy="lc",
+        legs=legs,
+        color_endpoints=ColorEndpointSummary(0, 0, 0),
+    )
+
+
+def _all_singlet_process() -> CanonicalProcessIR:
+    process = _process()
+    return replace(
+        process,
+        key="all_singlet_process",
+        legs=tuple(replace(leg, color_role="singlet") for leg in process.legs),
+        color_endpoints=ColorEndpointSummary(0, 0, 0),
+    )
+
+
+def _all_singlet_boson_process() -> CanonicalProcessIR:
+    process = _pure_gluon_process()
+    return replace(
+        process,
+        key="all_singlet_boson_process",
+        legs=tuple(replace(leg, color_role="singlet") for leg in process.legs),
+        color_endpoints=ColorEndpointSummary(0, 0, 0),
+    )
+
+
+def _color_plan(
+    process: CanonicalProcessIR,
+    *,
+    truncated: bool = False,
+    bad_label: bool = False,
+) -> GenericColorPlan:
+    final_label = 99 if bad_label else 4
+    return GenericColorPlan(
+        process=process,
+        color_accuracy=process.color_accuracy,
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="open-lines",
+                open_color_lines=(LCOpenColorLine(2, 1, (3, final_label)),),
+                word_labels=(2, 3, final_label, 1),
+            ),
+            LCColorSector(
+                id=1,
+                kind="open-lines",
+                open_color_lines=(LCOpenColorLine(2, 1, (final_label, 3)),),
+                word_labels=(2, final_label, 3, 1),
+            ),
+        ),
+        truncated=truncated,
+    )
+
+
+def _replay() -> LCColorTopologyReplayPlan:
+    return LCColorTopologyReplayPlan(
+        physical_sector_ids=(0, 1),
+        partitions=(
+            LCColorSectorReplayPartition(
+                representative_sector_id=0,
+                materialized_sector_id=0,
+                active_sector_ids=(0, 1),
+                label_permutations=((), ((3, 4), (4, 3))),
+                replay_weights=(1.0, 1.0),
+                replay_signs=(1, -1),
+                proof_algorithm="canonical-recurrence-replay-witness-v1",
+                proof_digest=_sha("replay-proof"),
+            ),
+        ),
+        residual_sector_ids=(),
+    )
+
+
+def _normalization() -> RecurrenceNormalizationV1:
+    return RecurrenceNormalizationV1(
+        factor=BuilderExact(1, 4),
+        convention="spin-colour-average-v1",
+        semantic_digest=_sha("normalization"),
+    )
+
+
+def test_topology_replay_projects_exact_axes_and_generation_coverage() -> None:
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="topology-replay",
+        topology_replay=_replay(),
+        normalization=_normalization(),
+        generation_slice=RecurrenceGenerationSliceV1(
+            selected_public_flow_ids=(1,),
+            # Initial-state crossing maps the catalog's -1 source to +1.
+            selected_source_helicities=((1, 1),),
+        ),
+        coupling_order_limits={"qcd": 4},
+    )
+
+    assert logical.process_id == "u_ubar_to_g_g"
+    assert tuple(leg.public_label for leg in logical.external_legs) == (1, 2, 3, 4)
+    assert tuple(len(leg.source_states) for leg in logical.external_legs) == (
+        2,
+        2,
+        2,
+        2,
+    )
+    assert tuple(leg.is_initial for leg in logical.external_legs) == (
+        True,
+        True,
+        False,
+        False,
+    )
+    assert tuple(
+        state.public_helicity for state in logical.external_legs[0].source_states
+    ) == (-1, 1)
+    assert all(
+        state.crossing_phase == BuilderExact(1)
+        for state in logical.external_legs[0].source_states
+    )
+    assert all(
+        state.momentum_sign == -1 for state in logical.external_legs[0].source_states
+    )
+    assert logical.selected_public_flow_ids == (1,)
+    assert logical.selected_source_coverage is not None
+    assert logical.selected_source_coverage[0].source_slot == 0
+    assert logical.selected_source_coverage[0].source_state_indices == (1,)
+    assert tuple(sector.public_id for sector in logical.physical_sectors) == (
+        "flow:2,3,4,1",
+        "flow:2,4,3,1",
+    )
+    assert tuple(sector.closure_source_slot for sector in logical.physical_sectors) == (
+        0,
+        0,
+    )
+    assert {sector.closure_proof_algorithm for sector in logical.physical_sectors} == {
+        "canonical-lc-closure-anchor-v3"
+    }
+    assert all(
+        len(sector.closure_proof_digest) == 64 for sector in logical.physical_sectors
+    )
+    assert (
+        len({sector.closure_proof_digest for sector in logical.physical_sectors}) == 2
+    )
+    assert len(logical.replay_partitions) == 1
+    replayed = sorted(
+        logical.replay_partitions[0].targets,
+        key=lambda target: target.sector_id,
+    )
+    assert replayed[0].external_permutation == (0, 1, 2, 3)
+    assert replayed[1].external_permutation == (0, 1, 3, 2)
+    assert replayed[1].source_slot_permutation == (0, 1, 3, 2)
+    assert replayed[1].fermion_sign == -1
+    assert logical.coupling_limits[0].name == "QCD"
+    assert logical.parameter_projection[0].runtime_name == "alpha_s"
+    assert logical.parameter_projection[0].prepared_parameter_id is None
+
+    # The result is accepted unchanged by the existing deterministic encoder.
+    assert len(build_recurrence_builder_input_v1(logical).canonical_digest) == 64
+
+
+def test_projection_binds_global_helicity_flip_proof_only_for_complete_axes() -> None:
+    process = _process()
+    common = {
+        "process": process,
+        "color_plan": _color_plan(process),
+        "template_catalog": _catalog(),
+        "layout": "topology-replay",
+        "topology_replay": _replay(),
+        "normalization": _normalization(),
+        "coupling_order_limits": {"qcd": 4},
+        "model": BuiltinSMModel(),
+    }
+
+    complete = project_recurrence_process_v1(**common)
+    specialized = project_recurrence_process_v1(
+        **common,
+        generation_slice=RecurrenceGenerationSliceV1(
+            selected_source_helicities=((1, 1),),
+        ),
+    )
+
+    role = "helicity-equivalence:global-flip-v1"
+    complete_proofs = tuple(
+        item for item in complete.semantic_digests if item.role == role
+    )
+    assert len(complete_proofs) == 1
+    assert len(complete_proofs[0].digest) == 64
+    assert all(item.role != role for item in specialized.semantic_digests)
+
+
+def test_projection_global_flip_proof_rejects_massive_fundamental_fermions() -> None:
+    """Massive helicity partners are not equal at a fixed phase-space point.
+
+    This is an adversarial boundary regression: parity relates a massive
+    fermion amplitude to parity-transformed kinematics, so the massless
+    fixed-point global-flip reduction must remain disabled even when every
+    reachable interaction is QCD and parity preserving.
+    """
+
+    class MassiveFundamentalModel(BuiltinSMModel):
+        def mass(self, pdg: int) -> float:
+            if abs(int(pdg)) == 1:
+                return 173.0
+            return super().mass(pdg)
+
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="topology-replay",
+        topology_replay=_replay(),
+        normalization=_normalization(),
+        coupling_order_limits={"qcd": 4},
+        model=MassiveFundamentalModel(),
+    )
+
+    assert all(
+        item.role != "helicity-equivalence:global-flip-v1"
+        for item in logical.semantic_digests
+    )
+
+
+def test_projection_attaches_exact_fixed_width_fermion_pairing_tables() -> None:
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="topology-replay",
+        topology_replay=_replay(),
+        normalization=_normalization(),
+    )
+
+    pairing = logical.fermion_pairing_catalog
+    assert pairing is not None
+    assert pairing.process_key == process.key
+    assert pairing.source_count == len(process.legs)
+    assert tuple(endpoint.source_slot for endpoint in pairing.endpoints) == (0, 1)
+    assert tuple(endpoint.color_orientation for endpoint in pairing.endpoints) == (
+        "antifundamental",
+        "fundamental",
+    )
+    assert pairing.rules[0].endpoint_pairings == ((1, 0),)
+    digest_roles = {item.role: item.digest for item in logical.semantic_digests}
+    assert digest_roles["fermion-pairing-semantic"] == pairing.semantic_digest
+    assert digest_roles["fermion-pairing-topology"] == pairing.topology_digest
+
+    encoded = build_recurrence_builder_input_v1(logical)
+    assert encoded.fermion_pairing_digest is not None
+    assert len(encoded.fermion_pairing_digest) == 64
+    header = encoded.fermion_pairing_table("header")
+    assert int(header.column("source_count")[0]) == 4
+    assert int(header.column("endpoint_count")[0]) == 2
+    assert int(header.column("pairing_class_count")[0]) == 1
+    assert int(header.column("rule_count")[0]) == 1
+    endpoints = encoded.fermion_pairing_table("endpoints")
+    assert tuple(int(value) for value in endpoints.column("source_slot")) == (0, 1)
+    for table in encoded.fermion_pairing_tables:
+        for column in table.columns:
+            assert column.values.dtype.kind != "O"
+            assert column.values.flags.c_contiguous
+            assert column.values.flags.owndata
+            assert not column.values.flags.writeable
+
+
+def test_all_flow_union_retains_all_sectors_without_replay_partitions() -> None:
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="all-flow-union",
+        topology_replay=_replay(),
+        normalization=_normalization(),
+    )
+
+    assert logical.selected_public_flow_ids is None
+    assert logical.selected_source_coverage is None
+    assert tuple(sector.sector_id for sector in logical.physical_sectors) == (0, 1)
+    assert logical.replay_partitions == ()
+    encoded = build_recurrence_builder_input_v1(logical)
+    assert encoded.table("selected_public_flow_coverage").row_count == 0
+    assert encoded.table("selected_source_coverage").row_count == 0
+    assert len(encoded.canonical_digest) == 64
+
+
+def test_contracted_pure_gluon_replay_projects_six_n5_template_orbits() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("g g > g g g g g", color_accuracy="full")
+    color_plan = build_color_plan(process, color_accuracy="full")
+    replay = build_color_topology_replay_certificate(color_plan, model)
+
+    assert replay is not None
+    logical = project_recurrence_process_v1(
+        process,
+        color_plan,
+        _catalog(),
+        layout="contracted-color-union",
+        topology_replay=replay,
+        normalization=_normalization(),
+        model=model,
+    )
+
+    assert len(logical.physical_sectors) == 720
+    assert len(logical.replay_partitions) == 6
+    assert tuple(
+        partition.materialized_sector_id for partition in logical.replay_partitions
+    ) == (0, 120, 144, 150, 152, 153)
+    assert {len(partition.targets) for partition in logical.replay_partitions} == {120}
+    assert {
+        target.sector_id
+        for partition in logical.replay_partitions
+        for target in partition.targets
+    } == set(range(720))
+    assert all(
+        target.fermion_sign == 1
+        for partition in logical.replay_partitions
+        for target in partition.targets
+    )
+    encoded = build_recurrence_builder_input_v1(logical)
+    assert encoded.table("replay_partitions").row_count == 6
+    assert encoded.table("replay_targets").row_count == 720
+    contraction_destinations = recurrence_color_contraction_destinations(
+        logical,
+        ((-1, -1), (-1, 1), (1, -1), (1, 1)),
+        tuple(
+            (sector_id, helicity_id)
+            for sector_id in replay.materialized_sector_ids
+            for helicity_id in range(4)
+        ),
+    )
+    assert len(contraction_destinations) == 720 * 4
+    assert contraction_destinations[:4] == ((0, 0), (0, 1), (0, 2), (0, 3))
+    assert contraction_destinations[-1] == (719, 3)
+
+
+def test_symmetric_group_anchor_falls_back_for_complete_contracted_replay() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("g g > g g", color_accuracy="full")
+    color_plan = build_color_plan(process, color_accuracy="full")
+    replay = build_color_topology_replay_certificate(color_plan, model)
+    catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_sha("closure-anchor-compiled-model"),
+        prepared_kernel_pack_digest=_sha("closure-anchor-prepared-pack"),
+    )
+    common = {
+        "process": process,
+        "color_plan": color_plan,
+        "template_catalog": catalog,
+        "layout": "contracted-color-union",
+        "topology_replay": replay,
+        "normalization": _normalization(),
+        "model": model,
+    }
+    direct = project_recurrence_process_v1(**common)
+    anchored = project_recurrence_process_v1(
+        **common,
+        prefer_symmetric_group_closure_anchor=True,
+    )
+
+    assert {sector.closure_proof_algorithm for sector in direct.physical_sectors} == {
+        "canonical-lc-closure-anchor-v2"
+    }
+    assert anchored.physical_sectors == direct.physical_sectors
+    assert anchored.public_flows == direct.public_flows
+    assert anchored.replay_partitions == direct.replay_partitions
+    assert anchored.replay_partitions
+    build_recurrence_builder_input_v1(anchored)
+
+
+def test_symmetric_group_anchor_is_independent_of_particle_21_identity() -> None:
+    synthetic_particle_id = 9_000_001
+    model = BuiltinSMModel()
+    base_catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_sha("synthetic-adjoint-compiled-model"),
+        prepared_kernel_pack_digest=_sha("synthetic-adjoint-prepared-pack"),
+    )
+    base_state = next(
+        state
+        for state in base_catalog.current_states
+        if state.particle_id == 21
+        and state.orientation == "self-conjugate"
+        and state.color_representation == 8
+    )
+    state = replace(
+        base_state,
+        particle_id=synthetic_particle_id,
+        anti_particle_id=synthetic_particle_id,
+        species_id="synthetic-adjoint",
+        semantic_digest="",
+    )
+    sources = tuple(
+        replace(
+            source,
+            flavour_flow=(synthetic_particle_id,),
+            semantic_digest="",
+        )
+        for source in base_catalog.sources
+        if source.state_template_id == state.template_id
+    )
+    closure = next(
+        item
+        for item in base_catalog.closures
+        if item.input_state_template_ids == (state.template_id, state.template_id)
+        and item.result_state_template_id is None
+        and not item.coupling_parameter_ids
+        and not item.coupling_orders
+        and not item.eligible_quantum_flow_template_ids
+        and item.output_factor_source == "none"
+        and item.equivalence_class == "direct-contraction"
+    )
+    resolver_keys = {
+        closure.evaluator_resolver_key,
+        *(source.evaluator_resolver_key for source in sources),
+    }
+    catalog = RecurrenceTemplateCatalog.create(
+        compiled_model_digest=base_catalog.header.compiled_model_digest,
+        prepared_kernel_pack_digest=(base_catalog.header.prepared_kernel_pack_digest),
+        current_states=(state,),
+        sources=sources,
+        closures=(closure,),
+        color_contractions=tuple(
+            item
+            for item in base_catalog.color_contractions
+            if item.template_id == closure.color_contraction_template_id
+        ),
+        evaluator_bindings=tuple(
+            item
+            for item in base_catalog.evaluator_bindings
+            if item.resolver_key in resolver_keys
+        ),
+    )
+    process = replace(
+        _pure_gluon_process(),
+        process="x x > x x",
+        key="synthetic_adjoint_scattering",
+        legs=tuple(
+            replace(
+                leg,
+                particle="x",
+                outgoing_particle="x",
+                pdg=synthetic_particle_id,
+                outgoing_pdg=synthetic_particle_id,
+            )
+            for leg in _pure_gluon_process().legs
+        ),
+    )
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=(1, 2, 3, 4),
+                word_labels=(1, 2, 3, 4),
+            ),
+        ),
+    )
+    logical = project_recurrence_process_v1(
+        process,
+        plan,
+        catalog,
+        layout="all-flow-union",
+        normalization=_normalization(),
+        prefer_symmetric_group_closure_anchor=True,
+    )
+
+    assert {leg.physical_pdg for leg in logical.external_legs} == {
+        synthetic_particle_id
+    }
+    assert logical.physical_sectors[0].closure_proof_algorithm == (
+        "canonical-lc-closure-anchor-v4"
+    )
+    assert logical.physical_sectors[0].closure_source_slot == 0
+
+
+def test_symmetric_group_anchor_falls_back_without_exact_template_contract() -> None:
+    process = _pure_gluon_process()
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=(1, 2, 3, 4),
+                word_labels=(1, 2, 3, 4),
+            ),
+        ),
+    )
+    logical = project_recurrence_process_v1(
+        process,
+        plan,
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+        prefer_symmetric_group_closure_anchor=True,
+    )
+
+    assert logical.physical_sectors[0].closure_proof_algorithm == (
+        "canonical-lc-closure-anchor-v2"
+    )
+    assert logical.physical_sectors[0].closure_source_slot == 3
+
+
+def test_symmetric_group_anchor_preserves_high_n_factorial_trace_domains() -> None:
+    model = BuiltinSMModel()
+    catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_sha("closure-anchor-count-compiled-model"),
+        prepared_kernel_pack_digest=_sha("closure-anchor-count-prepared-pack"),
+    )
+    for total_gluons in (7, 8):
+        process = build_process_ir(
+            "g g > " + " ".join("g" for _ in range(total_gluons - 2)),
+            color_accuracy="full",
+        )
+        color_plan = build_color_plan(process, color_accuracy="full")
+        logical = project_recurrence_process_v1(
+            process,
+            color_plan,
+            catalog,
+            layout="contracted-color-union",
+            normalization=_normalization(),
+            model=model,
+            prefer_symmetric_group_closure_anchor=True,
+        )
+
+        assert len(logical.physical_sectors) == math.factorial(total_gluons - 1)
+        assert all(
+            sector.closure_proof_algorithm == "canonical-lc-closure-anchor-v4"
+            and sector.closure_source_slot == 0
+            for sector in logical.physical_sectors
+        )
+        assert logical.replay_partitions == ()
+
+
+def test_contracted_color_owner_map_rejects_an_unproved_missing_sector() -> None:
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+
+    with pytest.raises(ValueError, match="no complete structural-zero certificate"):
+        recurrence_color_sector_owner_map(logical, {0}, set())
+
+
+def test_contracted_color_owner_map_preserves_open_string_singlets() -> None:
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+    first, second = logical.physical_sectors
+    second_string = replace(
+        second.open_strings[0],
+        adjoint_source_slots=first.open_strings[0].adjoint_source_slots,
+        singlet_source_slots=(3,),
+    )
+    logical = replace(
+        logical,
+        physical_sectors=(
+            first,
+            replace(second, open_strings=(second_string,)),
+        ),
+    )
+
+    with pytest.raises(ValueError, match="no complete structural-zero certificate"):
+        recurrence_color_sector_owner_map(logical, {0}, set())
+
+
+def test_contracted_color_owner_map_accepts_a_complete_zero_class() -> None:
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+
+    assert recurrence_color_sector_owner_map(logical, {0}, {1}) == (
+        0,
+        0xFFFF_FFFF,
+    )
+
+
+def test_contracted_color_owner_map_rejects_partial_zero_owner_class() -> None:
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+    first, second = logical.physical_sectors
+    logical = replace(
+        logical,
+        physical_sectors=(first, replace(second, open_strings=first.open_strings)),
+    )
+
+    with pytest.raises(ValueError, match="uncertified sectors=\\[1\\]"):
+        recurrence_color_sector_owner_map(logical, set(), {0})
+    assert recurrence_color_sector_owner_map(logical, set(), {0, 1}) == (
+        0xFFFF_FFFF,
+        0xFFFF_FFFF,
+    )
+
+
+def test_contracted_color_owner_map_rejects_active_zero_overlap() -> None:
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+
+    with pytest.raises(ValueError, match="overlaps active sectors"):
+        recurrence_color_sector_owner_map(logical, {0}, {0, 1})
+
+
+def test_contracted_color_owner_map_rejects_out_of_range_certificate() -> None:
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+
+    with pytest.raises(ValueError, match="references unknown sectors"):
+        recurrence_color_sector_owner_map(logical, {0}, {2})
+
+
+def test_all_singlet_sector_uses_smallest_fermionic_source_as_closure_anchor() -> None:
+    process = _all_singlet_process()
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="singlet",
+                singlet_labels=tuple(leg.label for leg in process.legs),
+            ),
+        ),
+    )
+    logical = project_recurrence_process_v1(
+        process,
+        plan,
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+
+    sector = logical.physical_sectors[0]
+    assert sector.word_source_slots == ()
+    assert sector.closure_source_slot == 0
+    assert sector.closure_proof_algorithm == "canonical-lc-closure-anchor-v2"
+    assert (
+        sector.closure_proof_digest
+        == "ce2ac679bcb9dba2688fe07d4a0c6382b28a76e4a91ac24026041782623b07ef"
+    )
+
+
+def test_all_singlet_boson_sector_uses_smallest_source_as_closure_anchor() -> None:
+    process = _all_singlet_boson_process()
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="singlet",
+                singlet_labels=tuple(leg.label for leg in process.legs),
+            ),
+        ),
+    )
+    logical = project_recurrence_process_v1(
+        process,
+        plan,
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+
+    sector = logical.physical_sectors[0]
+    assert sector.closure_source_slot == 0
+    assert sector.closure_proof_algorithm == "canonical-lc-closure-anchor-v2"
+    assert (
+        sector.closure_proof_digest
+        == "225a0e4e145b1c0e28719d4670b4379bb602fbbe59fe6c6804ae5694f7b754f2"
+    )
+
+
+@pytest.mark.parametrize(
+    ("statistics", "wavefunction_family", "message"),
+    [
+        ("inclusive", "inclusive", "requires concrete"),
+        ("boson", "fermion", "inconsistent"),
+    ],
+)
+def test_closure_anchor_fails_closed_for_ambiguous_leg_spin_metadata(
+    statistics: ParticleStatistics,
+    wavefunction_family: WavefunctionFamily,
+    message: str,
+) -> None:
+    process = _all_singlet_process()
+    process = replace(
+        process,
+        legs=(
+            replace(
+                process.legs[0],
+                statistics=statistics,
+                wavefunction_family=wavefunction_family,
+            ),
+            *process.legs[1:],
+        ),
+    )
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="singlet",
+                singlet_labels=tuple(leg.label for leg in process.legs),
+            ),
+        ),
+    )
+
+    with pytest.raises(RecurrenceProjectionError, match=message):
+        project_recurrence_process_v1(
+            process,
+            plan,
+            _catalog(),
+            layout="all-flow-union",
+            normalization=_normalization(),
+        )
+
+
+def test_projection_does_not_materialize_source_incompatible_anchor_replay() -> None:
+    process = _all_singlet_process()
+    labels = tuple(leg.label for leg in process.legs)
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=tuple(
+            LCColorSector(id=sector_id, kind="singlet", singlet_labels=labels)
+            for sector_id in range(2)
+        ),
+    )
+    replay = LCColorTopologyReplayPlan(
+        physical_sector_ids=(0, 1),
+        partitions=(
+            LCColorSectorReplayPartition(
+                representative_sector_id=0,
+                materialized_sector_id=0,
+                active_sector_ids=(0, 1),
+                label_permutations=((), ((1, 2), (2, 1))),
+                replay_weights=(1.0, 1.0),
+                replay_signs=(1, 1),
+                proof_algorithm="canonical-recurrence-replay-witness-v1",
+                proof_digest=_sha("singlet-replay-proof"),
+            ),
+        ),
+        residual_sector_ids=(),
+    )
+
+    with pytest.raises(RecurrenceProjectionError, match="crossing contract"):
+        project_recurrence_process_v1(
+            process,
+            plan,
+            _catalog(),
+            layout="topology-replay",
+            topology_replay=replay,
+            normalization=_normalization(),
+        )
+
+
+def test_folded_trace_reflection_remains_a_public_runtime_flow() -> None:
+    process = _pure_gluon_process()
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=(1, 2, 3, 4),
+                word_labels=(1, 2, 3, 4),
+            ),
+        ),
+        trace_reflections_folded=True,
+    )
+    replay = LCColorTopologyReplayPlan(
+        physical_sector_ids=(0,),
+        partitions=(),
+        residual_sector_ids=(0,),
+    )
+    logical = project_recurrence_process_v1(
+        process,
+        plan,
+        _catalog_with_reflection_phases(-1),
+        layout="topology-replay",
+        topology_replay=replay,
+        normalization=_normalization(),
+    )
+
+    assert tuple(flow.public_id for flow in logical.public_flows) == (
+        "flow:1,2,3,4",
+        "flow:1,4,3,2",
+    )
+    assert tuple(flow.construction_sector_id for flow in logical.public_flows) == (
+        0,
+        0,
+    )
+    assert logical.public_flows[1].source_slot_permutation == (0, 1, 2, 3)
+    assert len(logical.replay_partitions) == 1
+    residual = logical.replay_partitions[0]
+    assert residual.proof_algorithm == (
+        "canonical-recurrence-identity-materialization-v1"
+    )
+    assert residual.representative_sector_id == residual.materialized_sector_id == 0
+    assert residual.targets[0].source_slot_permutation == (0, 1, 2, 3)
+    assert len(build_recurrence_builder_input_v1(logical).canonical_digest) == 64
+
+
+def test_folded_trace_reflection_rejects_missing_current_proof() -> None:
+    process = _pure_gluon_process()
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=(1, 2, 3, 4),
+                word_labels=(1, 2, 3, 4),
+            ),
+        ),
+        trace_reflections_folded=True,
+    )
+
+    with pytest.raises(
+        RecurrenceProjectionError,
+        match="folded LC trace reflections require an exact model",
+    ):
+        project_recurrence_process_v1(
+            process,
+            plan,
+            _catalog(),
+            layout="all-flow-union",
+            normalization=_normalization(),
+        )
+
+
+def test_folded_trace_reflection_rejects_inconsistent_exact_phases() -> None:
+    process = _pure_gluon_process()
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=(1, 2, 3, 4),
+                word_labels=(1, 2, 3, 4),
+            ),
+        ),
+        trace_reflections_folded=True,
+    )
+
+    with pytest.raises(
+        RecurrenceProjectionError,
+        match="inconsistent exact phases",
+    ):
+        project_recurrence_process_v1(
+            process,
+            plan,
+            _catalog_with_reflection_phases(-1, 1),
+            layout="topology-replay",
+            normalization=_normalization(),
+        )
+
+
+@pytest.mark.parametrize("flow_id", [0, 1])
+def test_folded_trace_flows_can_be_specialized_independently(flow_id: int) -> None:
+    process = _pure_gluon_process()
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="lc",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="single-trace",
+                trace_labels=(1, 2, 3, 4),
+                word_labels=(1, 2, 3, 4),
+            ),
+        ),
+        trace_reflections_folded=True,
+    )
+    logical = project_recurrence_process_v1(
+        process,
+        plan,
+        _catalog_with_reflection_phases(-1),
+        layout="topology-replay",
+        normalization=_normalization(),
+        generation_slice=RecurrenceGenerationSliceV1(
+            selected_public_flow_ids=(flow_id,)
+        ),
+    )
+    columns = build_recurrence_builder_input_v1(logical)
+
+    assert logical.selected_public_flow_ids == (flow_id,)
+    assert tuple(flow.flow_id for flow in logical.public_flows) == (0, 1)
+    assert tuple(
+        int(value)
+        for value in columns.table("selected_public_flow_coverage").column("flow_id")
+    ) == (flow_id,)
+
+
+def test_crossed_source_carries_effective_momentum_transform_and_phase() -> None:
+    base = _catalog()
+    source = next(
+        item
+        for item in base.sources
+        if item.state_template_id == "state:anti-u" and item.helicity == -1
+    )
+    changed = replace(
+        source,
+        crossing=_crossing(momentum_transform="identity", phase=(0, 1)),
+        semantic_digest="",
+    )
+    catalog = RecurrenceTemplateCatalog.create(
+        compiled_model_digest=base.header.compiled_model_digest,
+        prepared_kernel_pack_digest=base.header.prepared_kernel_pack_digest,
+        parameters=base.parameters,
+        current_states=base.current_states,
+        sources=tuple(changed if item == source else item for item in base.sources),
+        evaluator_bindings=base.evaluator_bindings,
+    )
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        catalog,
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+
+    crossed = next(
+        item
+        for item in logical.external_legs[0].source_states
+        if item.source_template_id
+        == sorted(template.template_id for template in catalog.sources).index(
+            changed.template_id
+        )
+    )
+    assert crossed.momentum_sign == 1
+    assert crossed.crossing_phase == BuilderExact(0, 1, 1, 1)
+    assert all(
+        state.momentum_sign == 1 and state.crossing_phase == BuilderExact(1)
+        for state in logical.external_legs[2].source_states
+    )
+
+
+def test_projection_and_columnar_digest_are_deterministic() -> None:
+    process = _process()
+    arguments = dict(
+        process=process,
+        color_plan=_color_plan(process),
+        template_catalog=_catalog(),
+        layout="topology-replay",
+        topology_replay=_replay(),
+        normalization=_normalization(),
+        coupling_order_limits={"QED": 2, "QCD": 4},
+    )
+    first = project_recurrence_process_v1(**arguments)
+    second = project_recurrence_process_v1(**arguments)
+
+    assert first == second
+    first_columns = build_recurrence_builder_input_v1(first)
+    second_columns = build_recurrence_builder_input_v1(second)
+    assert first_columns.canonical_digest == second_columns.canonical_digest
+
+
+@pytest.mark.parametrize("accuracy", ["nlc", "full"])
+def test_non_lc_projection_requires_contracted_color_union(accuracy: str) -> None:
+    process = _process(color_accuracy=accuracy)
+    with pytest.raises(
+        RecurrenceProjectionError,
+        match="requires the contracted-color-union strategy",
+    ):
+        project_recurrence_process_v1(
+            process,
+            _color_plan(process),
+            _catalog(),
+            layout="all-flow-union",
+            normalization=_normalization(),
+        )
+
+    physical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+        contracted_physical_color_union=True,
+    )
+    assert physical.layout == "all-flow-union"
+    assert physical.replay_partitions == ()
+    assert physical.selected_public_flow_ids is None
+    assert physical.selected_source_coverage is None
+
+
+def test_contracted_physical_union_densely_projects_open_line_owners() -> None:
+    process = build_process_ir("d d~ > d d~", color_accuracy="full")
+    fundamentals = process.fundamental_labels
+    antifundamentals = process.antifundamental_labels
+    assert len(fundamentals) == len(antifundamentals) == 2
+    first = LCOpenColorLine(fundamentals[0], antifundamentals[0], ())
+    second = LCOpenColorLine(fundamentals[1], antifundamentals[1], ())
+    first_word = (*first.coloured_labels, *second.coloured_labels)
+    second_word = (*second.coloured_labels, *first.coloured_labels)
+    plan = GenericColorPlan(
+        process=process,
+        color_accuracy="full",
+        sectors=(
+            LCColorSector(
+                id=0,
+                kind="open-lines",
+                open_color_lines=(first, second),
+                word_labels=first_word,
+            ),
+            LCColorSector(
+                id=1,
+                kind="open-lines",
+                open_color_lines=(second, first),
+                word_labels=second_word,
+            ),
+        ),
+    )
+
+    logical = project_recurrence_process_v1(
+        process,
+        plan,
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+        contracted_physical_color_union=True,
+    )
+
+    assert tuple(sector.sector_id for sector in logical.physical_sectors) == (0,)
+    assert tuple(flow.construction_sector_id for flow in logical.public_flows) == (0,)
+    assert logical.replay_partitions == ()
+
+
+def test_projection_rejects_truncated_plan_and_allows_residual_only_replay() -> None:
+    process = _process()
+    with pytest.raises(RecurrenceProjectionError, match="truncated"):
+        project_recurrence_process_v1(
+            process,
+            _color_plan(process, truncated=True),
+            _catalog(),
+            layout="all-flow-union",
+            normalization=_normalization(),
+        )
+    residual = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="topology-replay",
+        normalization=_normalization(),
+    )
+    assert residual.replay_partitions == ()
+
+
+def test_projection_rejects_missing_source_semantics_and_malformed_references() -> None:
+    process = _process()
+    with pytest.raises(RecurrenceProjectionError, match="no supported source"):
+        project_recurrence_process_v1(
+            process,
+            _color_plan(process),
+            _catalog(omit_particle=-1),
+            layout="all-flow-union",
+            normalization=_normalization(),
+        )
+    with pytest.raises(RecurrenceProjectionError, match="unknown external label"):
+        project_recurrence_process_v1(
+            process,
+            _color_plan(process, bad_label=True),
+            _catalog(),
+            layout="all-flow-union",
+            normalization=_normalization(),
+        )
+
+
+def test_union_projects_generation_selected_flow_and_partial_helicity() -> None:
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        _catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+        generation_slice=RecurrenceGenerationSliceV1(
+            selected_public_flow_ids=(1,),
+            # Initial-state crossing maps the catalog's -1 source to +1.
+            selected_source_helicities=((1, 1),),
+        ),
+    )
+    encoded = build_recurrence_builder_input_v1(logical)
+
+    assert logical.selected_public_flow_ids == (1,)
+    assert logical.selected_source_coverage is not None
+    assert tuple(row.source_slot for row in logical.selected_source_coverage) == (
+        0,
+        1,
+        2,
+        3,
+    )
+    assert logical.selected_source_coverage[0].source_state_indices == (1,)
+    assert all(
+        row.source_state_indices == (0, 1)
+        for row in logical.selected_source_coverage[1:]
+    )
+    assert tuple(
+        int(value)
+        for value in encoded.table("selected_public_flow_coverage").column("flow_id")
+    ) == (1,)
+    assert tuple(
+        (
+            int(source_slot),
+            int(state_index),
+        )
+        for source_slot, state_index in zip(
+            encoded.table("selected_source_coverage").column("source_slot"),
+            encoded.table("selected_source_coverage").column("source_state_index"),
+            strict=True,
+        )
+    ) == (
+        (0, 1),
+        (1, 0),
+        (1, 1),
+        (2, 0),
+        (2, 1),
+        (3, 0),
+        (3, 1),
+    )
+    assert int(encoded.table("header").column("selected_flow_mode")[0]) == 1
+    assert int(encoded.table("header").column("selected_source_mode")[0]) == 1
+
+
+@pytest.mark.parametrize(
+    ("generation_slice", "message"),
+    [
+        (
+            RecurrenceGenerationSliceV1(selected_public_flow_ids=(99,)),
+            "unknown public LC flows",
+        ),
+        (
+            RecurrenceGenerationSliceV1(selected_source_helicities=((99, 1),)),
+            "unknown source labels",
+        ),
+        (
+            RecurrenceGenerationSliceV1(selected_source_helicities=((1, 0),)),
+            "selected helicity 0 is unavailable",
+        ),
+    ],
+)
+def test_union_generation_specialization_fails_closed(
+    generation_slice: RecurrenceGenerationSliceV1,
+    message: str,
+) -> None:
+    process = _process()
+    with pytest.raises(RecurrenceProjectionError, match=message):
+        project_recurrence_process_v1(
+            process,
+            _color_plan(process),
+            _catalog(),
+            layout="all-flow-union",
+            normalization=_normalization(),
+            generation_slice=generation_slice,
+        )
+
+
+def test_projection_does_not_depend_on_generic_dag_types() -> None:
+    import pyamplicol.generation.recurrence_projection as projection
+
+    names = set(projection.__dict__)
+    assert "GenericDAG" not in names
+    assert "compile_generic_dag" not in names
+
+
+def test_mismatched_color_plan_process_is_rejected() -> None:
+    process = _process()
+    other = replace(process, key="different_process")
+    with pytest.raises(RecurrenceProjectionError, match="does not belong"):
+        project_recurrence_process_v1(
+            process,
+            _color_plan(other),
+            _catalog(),
+            layout="all-flow-union",
+            normalization=_normalization(),
+        )
+
+
+def test_projection_rejects_ambiguous_builder_axes() -> None:
+    process = _process()
+    common = dict(
+        process=process,
+        color_plan=_color_plan(process),
+        template_catalog=_catalog(),
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+    with pytest.raises(RecurrenceProjectionError, match="support mask"):
+        project_recurrence_process_v1(**common, process_support_mask=1.0)
+    with pytest.raises(RecurrenceProjectionError, match="unique"):
+        project_recurrence_process_v1(
+            **common,
+            coupling_order_limits={"QCD": 4, "qcd": 4},
+        )
+
+
+def test_complex_parameters_use_authoritative_prepared_slots() -> None:
+    base = _catalog()
+    complex_parameter = ParameterTemplateV1(
+        template_id="parameter:complex_coupling",
+        name="complex_coupling",
+        parameter_kind="external",
+        value_type="complex",
+        mutable=True,
+        default_value=ExactComplexRationalV1(1, 10, 1, 20),
+        exact_expression_digest=None,
+        dependency_parameter_ids=(),
+        prepared_parameter_id=17,
+    )
+    catalog = RecurrenceTemplateCatalog.create(
+        compiled_model_digest=base.header.compiled_model_digest,
+        prepared_kernel_pack_digest=base.header.prepared_kernel_pack_digest,
+        parameters=(*base.parameters, complex_parameter),
+        current_states=base.current_states,
+        sources=base.sources,
+        evaluator_bindings=base.evaluator_bindings,
+    )
+    process = _process()
+    logical = project_recurrence_process_v1(
+        process,
+        _color_plan(process),
+        catalog,
+        layout="all-flow-union",
+        normalization=_normalization(),
+    )
+
+    complex_rows = tuple(
+        item
+        for item in logical.parameter_projection
+        if item.runtime_name == "complex_coupling"
+    )
+    assert tuple(item.component for item in complex_rows) == (0, 1)
+    assert tuple(item.prepared_parameter_id for item in complex_rows) == (17, 17)
+    assert tuple(item.runtime_slot for item in logical.parameter_projection) == tuple(
+        range(len(logical.parameter_projection))
+    )
diff --git a/pyamplicol/tests/unit/test_recurrence_real_process_schedule.py b/pyamplicol/tests/unit/test_recurrence_real_process_schedule.py
new file mode 100644
index 0000000000..86294f2771
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_real_process_schedule.py
@@ -0,0 +1,887 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.color.plan import (
+    build_color_plan,
+    build_lc_topology_replay_plan,
+)
+from pyamplicol.generation.dag_algorithms import (
+    infer_minimal_coupling_order_limits,
+)
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.recurrence_columnar import (
+    ExactComplexRationalV1,
+    RecurrenceNormalizationV1,
+    build_recurrence_builder_input_v1,
+)
+from pyamplicol.generation.recurrence_physics import (
+    build_recurrence_runtime_metadata,
+)
+from pyamplicol.generation.recurrence_projection import (
+    project_recurrence_process_v1,
+)
+from pyamplicol.generation.recurrence_template_columnar import (
+    build_recurrence_template_input_v1,
+)
+from pyamplicol.models import (
+    BuiltinSMModel,
+    CompiledUFOModel,
+    compile_model_source,
+)
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.prepared_catalog import build_prepared_kernel_catalog
+from pyamplicol.models.recurrence_catalog_builder import (
+    build_recurrence_template_catalog,
+)
+from pyamplicol.processes.model import build_model_process_ir
+
+_COMPILED_MODEL_DIGEST = "a" * 64
+_PREPARED_PACK_DIGEST = "b" * 64
+_UFO_SM_ROOT = (
+    Path(__file__).resolve().parents[2]
+    / "src"
+    / "pyamplicol"
+    / "assets"
+    / "models"
+    / "json"
+    / "sm"
+)
+
+
+@pytest.mark.parametrize("model_source", ("built-in", "ufo-sm"))
+def test_symmetric_group_trace_anchor_uses_model_generic_catalog_contracts(
+    model_source: str,
+) -> None:
+    if model_source == "built-in":
+        model = BuiltinSMModel()
+        process = build_process_ir("g g > g g", color_accuracy="full")
+    else:
+        compiled = compile_model_source(
+            _UFO_SM_ROOT / "sm.json",
+            restriction=str((_UFO_SM_ROOT / "restrict_default.json").resolve()),
+            use_cache=True,
+        )
+        model = CompiledUFOModel(compiled)
+        process = build_model_process_ir(
+            "g g > g g",
+            compiled.ir,
+            color_accuracy="full",
+        )
+    recurrence_catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_COMPILED_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+    )
+    color_plan = build_color_plan(process, color_accuracy="full")
+    logical = project_recurrence_process_v1(
+        process,
+        color_plan,
+        recurrence_catalog,
+        layout="contracted-color-union",
+        normalization=RecurrenceNormalizationV1(
+            ExactComplexRationalV1(1),
+            "model-generic-cyclic-anchor-canary-v1",
+            "9" * 64,
+        ),
+        coupling_order_limits=infer_minimal_coupling_order_limits(
+            process,
+            model=model,
+        ),
+        model=model,
+        prefer_symmetric_group_closure_anchor=True,
+    )
+
+    assert logical.physical_sectors
+    assert all(
+        sector.closure_proof_algorithm == "canonical-lc-closure-anchor-v4"
+        and sector.closure_source_slot == 0
+        for sector in logical.physical_sectors
+    )
+    build_recurrence_builder_input_v1(logical)
+
+
+def test_ufo_full_ddbar_to_ee_prepares_source_only_electron_mass() -> None:
+    compiled = compile_model_source(
+        _UFO_SM_ROOT / "sm.json",
+        restriction=str((_UFO_SM_ROOT / "restrict_default.json").resolve()),
+        use_cache=True,
+    )
+    model = CompiledUFOModel(compiled)
+    process = build_model_process_ir(
+        "d d~ > e+ e-",
+        compiled.ir,
+        color_accuracy="full",
+    )
+    prepared_catalog = build_prepared_kernel_catalog(model)
+    recurrence_catalog = build_recurrence_template_catalog(
+        model,
+        prepared_catalog,
+        compiled_model_digest=_COMPILED_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+    )
+    color_plan = build_color_plan(
+        process,
+        color_accuracy="full",
+        fold_trace_reflections=False,
+    )
+    logical = project_recurrence_process_v1(
+        process,
+        color_plan,
+        recurrence_catalog,
+        layout="contracted-color-union",
+        normalization=RecurrenceNormalizationV1(
+            ExactComplexRationalV1(1),
+            "source-only-parameter-canary-v1",
+            "c" * 64,
+        ),
+        coupling_order_limits=infer_minimal_coupling_order_limits(
+            process,
+            model=model,
+        ),
+        model=model,
+    )
+
+    electron_mass = next(
+        row for row in logical.parameter_projection if row.runtime_name == "Me"
+    )
+    assert electron_mass.prepared_parameter_id is not None
+    metadata = build_recurrence_runtime_metadata(
+        logical,
+        recurrence_catalog,
+        model,
+        {
+            "averaging_factor": 1.0,
+            "coupling_factor": 1.0,
+            "symmetry_factor": 1.0,
+            "source": "source-only-parameter-canary-v1",
+        },
+    )
+    assert metadata["prepared_parameter_defaults"][
+        electron_mass.prepared_parameter_id
+    ] == [0.0, 0.0]
+
+
+def test_builtin_charged_current_all_flow_union_retains_chiral_sources() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("u d~ > e+ ve", color_accuracy="lc")
+    recurrence_catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_COMPILED_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+    )
+    color_plan = build_color_plan(
+        process,
+        color_accuracy="lc",
+        fold_trace_reflections=model.lc_trace_reflection_equivalence_is_proven(process),
+    )
+    logical = project_recurrence_process_v1(
+        process,
+        color_plan,
+        recurrence_catalog,
+        layout="all-flow-union",
+        normalization=RecurrenceNormalizationV1(
+            ExactComplexRationalV1(1),
+            "runtime-chiral-source-canary-v1",
+            "e" * 64,
+        ),
+        coupling_order_limits=infer_minimal_coupling_order_limits(
+            process,
+            model=model,
+        ),
+        model=model,
+    )
+
+    assert tuple(leg.public_label for leg in logical.external_legs) == (1, 2, 3, 4)
+    assert all(
+        {state.spin_state for state in leg.source_states} == {-1, 1}
+        for leg in logical.external_legs
+    )
+    assert all(len(leg.source_states) == 2 for leg in logical.external_legs)
+    columnar = build_recurrence_builder_input_v1(logical)
+    assert columnar.table("source_states").row_count == 8
+
+
+def test_builtin_ddbar_to_ttbar_exposes_canonical_crossed_lc_flow() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d~ > t t~", color_accuracy="lc")
+    recurrence_catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_COMPILED_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+    )
+    color_plan = build_color_plan(
+        process,
+        color_accuracy="lc",
+        fold_trace_reflections=model.lc_trace_reflection_equivalence_is_proven(process),
+    )
+    replay = build_lc_topology_replay_plan(color_plan, model)
+    expected_public_flows = (
+        ("flow:2,1,3,4", (2, 1, 3, 4)),
+        ("flow:2,4,3,1", (2, 4, 3, 1)),
+    )
+
+    for layout in ("topology-replay", "all-flow-union"):
+        logical = project_recurrence_process_v1(
+            process,
+            color_plan,
+            recurrence_catalog,
+            layout=layout,
+            normalization=RecurrenceNormalizationV1(
+                ExactComplexRationalV1(1),
+                "legacy-two-line-flow-canary-v1",
+                "f" * 64,
+            ),
+            topology_replay=replay if layout == "topology-replay" else None,
+            coupling_order_limits=infer_minimal_coupling_order_limits(
+                process,
+                model=model,
+            ),
+            model=model,
+        )
+
+        assert (
+            tuple(
+                (
+                    flow.public_id,
+                    tuple(
+                        process.legs[source_slot].label
+                        for source_slot in flow.word_source_slots
+                    ),
+                )
+                for flow in logical.public_flows
+            )
+            == expected_public_flows
+        )
+        # Public selectors and construction words use the same canonical
+        # fundamental-to-antifundamental representation.
+        assert tuple(
+            tuple(
+                process.legs[source_slot].label
+                for source_slot in sector.word_source_slots
+            )
+            for sector in logical.physical_sectors
+        ) == ((2, 1, 3, 4), (2, 4, 3, 1))
+        assert tuple(
+            sector.closure_source_slot for sector in logical.physical_sectors
+        ) == (3, 3)
+        assert tuple(
+            sector.closure_proof_algorithm for sector in logical.physical_sectors
+        ) == (
+            "canonical-lc-closure-anchor-v3",
+            "canonical-lc-closure-anchor-v3",
+        )
+        build_recurrence_builder_input_v1(logical)
+        if layout == "all-flow-union":
+            first_sector = logical.physical_sectors[0]
+            v3_sector = logical.physical_sectors[1]
+            reordered = replace(
+                logical,
+                physical_sectors=(
+                    first_sector,
+                    replace(
+                        v3_sector,
+                        open_strings=tuple(reversed(v3_sector.open_strings)),
+                    ),
+                ),
+            )
+            build_recurrence_builder_input_v1(reordered)
+
+            stale_first_word = (
+                *first_sector.word_source_slots[2:],
+                *first_sector.word_source_slots[:2],
+            )
+            tampered_inputs = (
+                replace(
+                    logical,
+                    physical_sectors=(
+                        first_sector,
+                        replace(v3_sector, closure_source_slot=0),
+                    ),
+                ),
+                replace(
+                    logical,
+                    physical_sectors=(
+                        first_sector,
+                        replace(v3_sector, closure_proof_digest="1" * 64),
+                    ),
+                ),
+                # The no-rotation sector still authenticates its public blocks.
+                replace(
+                    logical,
+                    physical_sectors=(
+                        replace(
+                            first_sector,
+                            word_source_slots=stale_first_word,
+                        ),
+                        v3_sector,
+                    ),
+                    public_flows=(
+                        replace(
+                            logical.public_flows[0],
+                            word_source_slots=stale_first_word,
+                        ),
+                        *logical.public_flows[1:],
+                    ),
+                ),
+                # Open-string endpoint and adjoint membership are authenticated.
+                replace(
+                    logical,
+                    physical_sectors=(
+                        replace(
+                            first_sector,
+                            open_strings=(
+                                replace(
+                                    first_sector.open_strings[0],
+                                    fundamental_source_slot=2,
+                                ),
+                                *first_sector.open_strings[1:],
+                            ),
+                        ),
+                        v3_sector,
+                    ),
+                ),
+                replace(
+                    logical,
+                    physical_sectors=(
+                        replace(
+                            first_sector,
+                            open_strings=(
+                                replace(
+                                    first_sector.open_strings[0],
+                                    adjoint_source_slots=(2,),
+                                ),
+                                *first_sector.open_strings[1:],
+                            ),
+                        ),
+                        v3_sector,
+                    ),
+                ),
+                # Public-label/source ordering is part of the v3 digest.
+                replace(
+                    logical,
+                    external_legs=(
+                        replace(logical.external_legs[0], public_label=99),
+                        *logical.external_legs[1:],
+                    ),
+                ),
+            )
+            for tampered in tampered_inputs:
+                with pytest.raises(
+                    ValueError,
+                    match=r"v3 LC|open-line block",
+                ):
+                    build_recurrence_builder_input_v1(tampered)
+
+
+def test_open_line_projection_skips_singlet_slot_zero_and_emits_v3() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("e- d > e- d t t~", color_accuracy="lc")
+    recurrence_catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_COMPILED_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+    )
+    color_plan = build_color_plan(
+        process,
+        color_accuracy="lc",
+        fold_trace_reflections=model.lc_trace_reflection_equivalence_is_proven(process),
+    )
+    logical = project_recurrence_process_v1(
+        process,
+        color_plan,
+        recurrence_catalog,
+        layout="all-flow-union",
+        normalization=RecurrenceNormalizationV1(
+            ExactComplexRationalV1(1),
+            "minimum-coloured-source-slot-canary-v1",
+            "3" * 64,
+        ),
+        coupling_order_limits=infer_minimal_coupling_order_limits(
+            process,
+            model=model,
+        ),
+        model=model,
+    )
+    sector = next(
+        sector
+        for sector in logical.physical_sectors
+        if sector.public_id == "flow:4,6,5,2"
+    )
+
+    assert logical.external_legs[0].public_label == 1
+    assert sector.word_source_slots == (3, 5, 4, 1)
+    assert sector.closure_source_slot == 5
+    assert sector.closure_proof_algorithm == "canonical-lc-closure-anchor-v3"
+    build_recurrence_builder_input_v1(logical)
+
+
+def test_same_sign_quark_replay_materializes_v3_anchor_mismatches() -> None:
+    model = BuiltinSMModel()
+    process = build_process_ir("d d > d d g g", color_accuracy="lc")
+    recurrence_catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_COMPILED_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+    )
+    color_plan = build_color_plan(
+        process,
+        color_accuracy="lc",
+        fold_trace_reflections=model.lc_trace_reflection_equivalence_is_proven(process),
+    )
+    replay = build_lc_topology_replay_plan(color_plan, model)
+    assert replay is not None
+    assert replay.residual_sector_ids == ()
+
+    logical = project_recurrence_process_v1(
+        process,
+        color_plan,
+        recurrence_catalog,
+        layout="topology-replay",
+        topology_replay=replay,
+        normalization=RecurrenceNormalizationV1(
+            ExactComplexRationalV1(1),
+            "same-sign-quark-v3-replay-canary-v1",
+            "4" * 64,
+        ),
+        coupling_order_limits=infer_minimal_coupling_order_limits(
+            process,
+            model=model,
+        ),
+        model=model,
+    )
+
+    replayed = tuple(
+        partition
+        for partition in logical.replay_partitions
+        if partition.proof_algorithm
+        != "canonical-recurrence-identity-materialization-v1"
+    )
+    materialized = tuple(
+        partition
+        for partition in logical.replay_partitions
+        if partition.proof_algorithm
+        == "canonical-recurrence-identity-materialization-v1"
+    )
+    assert tuple(
+        tuple(target.sector_id for target in partition.targets)
+        for partition in replayed
+    ) == ((0, 3), (1, 4), (2, 5))
+    assert tuple(partition.representative_sector_id for partition in materialized) == (
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+    )
+    identity = tuple(range(len(process.legs)))
+    assert all(
+        partition.materialized_sector_id
+        == partition.representative_sector_id
+        == partition.targets[0].sector_id
+        and partition.targets[0].source_slot_permutation == identity
+        and partition.targets[0].external_permutation == identity
+        and partition.targets[0].fermion_sign == 1
+        for partition in materialized
+    )
+    assert {
+        target.sector_id
+        for partition in logical.replay_partitions
+        for target in partition.targets
+    } == set(replay.physical_sector_ids)
+    columnar = build_recurrence_builder_input_v1(logical)
+    assert columnar.table("replay_partitions").row_count == 9
+    assert columnar.table("replay_targets").row_count == 12
+
+
+def test_builtin_two_line_contracted_color_keeps_unique_construction_flows() -> None:
+    model = BuiltinSMModel()
+    recurrence_catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_COMPILED_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+    )
+
+    for expression in ("d d~ > t t~", "d d~ > d d~"):
+        for accuracy in ("nlc", "full"):
+            process = build_process_ir(expression, color_accuracy=accuracy)
+            color_plan = build_color_plan(
+                process,
+                color_accuracy=accuracy,
+                fold_trace_reflections=model.lc_trace_reflection_equivalence_is_proven(
+                    process
+                ),
+            )
+            logical = project_recurrence_process_v1(
+                process,
+                color_plan,
+                recurrence_catalog,
+                layout="contracted-color-union",
+                normalization=RecurrenceNormalizationV1(
+                    ExactComplexRationalV1(1),
+                    "contracted-two-line-flow-canary-v1",
+                    "0" * 64,
+                ),
+                coupling_order_limits=infer_minimal_coupling_order_limits(
+                    process,
+                    model=model,
+                ),
+                model=model,
+            )
+
+            public_ids = tuple(flow.public_id for flow in logical.public_flows)
+            construction_ids = tuple(
+                sector.public_id for sector in logical.physical_sectors
+            )
+            assert public_ids == construction_ids
+            assert len(set(public_ids)) == len(public_ids)
+            assert tuple(
+                (
+                    flow.construction_sector_id,
+                    flow.word_source_slots,
+                )
+                for flow in logical.public_flows
+            ) == tuple(
+                (
+                    sector.sector_id,
+                    sector.word_source_slots,
+                )
+                for sector in logical.physical_sectors
+            )
+            build_recurrence_builder_input_v1(logical)
+
+
+def test_sm_process_projects_model_generic_topology_replay_input() -> None:
+    summaries: dict[str, dict[str, int]] = {}
+    dag_shapes: dict[str, tuple[int, int]] = {}
+    for model_source in ("built-in", "ufo-sm"):
+        if model_source == "built-in":
+            model = BuiltinSMModel()
+            process = build_process_ir("d d~ > z g", color_accuracy="lc")
+        else:
+            compiled = compile_model_source(
+                _UFO_SM_ROOT / "sm.json",
+                restriction=str((_UFO_SM_ROOT / "restrict_default.json").resolve()),
+                use_cache=True,
+            )
+            model = CompiledUFOModel(compiled)
+            process = build_model_process_ir("d d~ > z g", compiled.ir)
+
+        prepared_catalog = build_prepared_kernel_catalog(model)
+        recurrence_catalog = build_recurrence_template_catalog(
+            model,
+            prepared_catalog,
+            compiled_model_digest=_COMPILED_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+        )
+        color_plan = build_color_plan(
+            process,
+            color_accuracy="lc",
+            fold_trace_reflections=model.lc_trace_reflection_equivalence_is_proven(
+                process
+            ),
+        )
+        replay = build_lc_topology_replay_plan(color_plan, model)
+        coupling_order_limits = infer_minimal_coupling_order_limits(
+            process,
+            model=model,
+        )
+        dag = compile_generic_dag(
+            process,
+            model=model,
+            max_coupling_orders=coupling_order_limits,
+        )
+        logical = project_recurrence_process_v1(
+            process,
+            color_plan,
+            recurrence_catalog,
+            layout="topology-replay",
+            normalization=RecurrenceNormalizationV1(
+                ExactComplexRationalV1(1),
+                "structural-canary-v1",
+                "c" * 64,
+            ),
+            topology_replay=replay,
+            coupling_order_limits=coupling_order_limits,
+            model=model,
+        )
+
+        sources_by_numeric_id = tuple(
+            sorted(recurrence_catalog.sources, key=lambda row: row.template_id)
+        )
+        states_by_numeric_id = tuple(
+            sorted(recurrence_catalog.current_states, key=lambda row: row.template_id)
+        )
+        states_by_template_id = {
+            state.template_id: state for state in recurrence_catalog.current_states
+        }
+        crossed_internal_spin_pairs = tuple(
+            (
+                state.spin_state,
+                sources_by_numeric_id[state.source_template_id].spin_state,
+            )
+            for leg in logical.external_legs
+            if leg.is_initial
+            for state in leg.source_states
+        )
+        assert any(
+            public != canonical for public, canonical in crossed_internal_spin_pairs
+        )
+        crossed_internal_chirality_pairs = tuple(
+            (
+                states_by_numeric_id[state.current_state_template_id].chirality,
+                states_by_template_id[
+                    sources_by_numeric_id[state.source_template_id].state_template_id
+                ].chirality,
+            )
+            for leg in logical.external_legs
+            if leg.is_initial
+            for state in leg.source_states
+        )
+        assert any(
+            effective != canonical
+            for effective, canonical in crossed_internal_chirality_pairs
+        )
+        assert all(
+            state.chirality
+            == states_by_numeric_id[state.current_state_template_id].chirality
+            for leg in logical.external_legs
+            for state in leg.source_states
+        )
+
+        columnar = build_recurrence_builder_input_v1(logical)
+        build_recurrence_template_input_v1(recurrence_catalog)
+        assert len(columnar.digest) == 64
+        assert len(columnar.fermion_pairing_digest or "") == 64
+        assert columnar.table("external_legs").row_count == len(process.legs)
+        assert columnar.table("physical_lc_sectors").row_count == (
+            color_plan.sector_count
+        )
+        assert columnar.table("public_lc_flows").row_count == color_plan.sector_count
+        assert columnar.table("replay_partitions").row_count == len(
+            logical.replay_partitions
+        )
+        assert columnar.table("replay_targets").row_count == sum(
+            len(partition.targets) for partition in logical.replay_partitions
+        )
+        assert columnar.table("source_states").row_count > len(process.legs)
+        summaries[model_source] = {
+            table.name: table.row_count
+            for table in columnar.tables
+            if table.name
+            in {
+                "external_legs",
+                "physical_lc_sectors",
+                "public_lc_flows",
+                "replay_partitions",
+                "replay_targets",
+                "source_states",
+            }
+        }
+        dag_shapes[model_source] = (len(dag.currents), len(dag.interactions))
+
+    assert summaries["built-in"] == summaries["ufo-sm"]
+    assert dag_shapes == {"built-in": (31, 34), "ufo-sm": (31, 34)}
+
+
+def test_sm_recurrence_closure_projections_match_without_forest_aliases() -> None:
+    """Exercise every LC closure family before public recurrence dispatch."""
+
+    expressions = (
+        "g g > g g",
+        "d d~ > z g",
+        "u d~ > w+",
+        "d d~ > u u~",
+        "d d~ > d d~",
+        "d d~ > u u~ s s~",
+        "d d~ > u u~ s s~ c c~",
+        "d d~ > u u~ s s~ c c~ b b~",
+    )
+    summaries: dict[str, dict[str, tuple[int, ...]]] = {}
+    compiled_ufo = compile_model_source(
+        _UFO_SM_ROOT / "sm.json",
+        restriction=str((_UFO_SM_ROOT / "restrict_default.json").resolve()),
+        use_cache=True,
+    )
+    for model_source, model in (
+        ("built-in", BuiltinSMModel()),
+        ("ufo-sm", CompiledUFOModel(compiled_ufo)),
+    ):
+        prepared_catalog = build_prepared_kernel_catalog(model)
+        recurrence_catalog = build_recurrence_template_catalog(
+            model,
+            prepared_catalog,
+            compiled_model_digest=_COMPILED_MODEL_DIGEST,
+            prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+        )
+        summaries[model_source] = {}
+        for expression in expressions:
+            process = (
+                build_process_ir(expression, color_accuracy="lc")
+                if model_source == "built-in"
+                else build_model_process_ir(expression, compiled_ufo.ir)
+            )
+            color_plan = build_color_plan(
+                process,
+                color_accuracy="lc",
+                fold_trace_reflections=model.lc_trace_reflection_equivalence_is_proven(
+                    process
+                ),
+            )
+            replay = build_lc_topology_replay_plan(color_plan, model)
+            logical = project_recurrence_process_v1(
+                process,
+                color_plan,
+                recurrence_catalog,
+                layout="topology-replay",
+                normalization=RecurrenceNormalizationV1(
+                    ExactComplexRationalV1(1),
+                    "closure-family-canary-v1",
+                    "d" * 64,
+                ),
+                topology_replay=replay,
+                coupling_order_limits=infer_minimal_coupling_order_limits(
+                    process,
+                    model=model,
+                ),
+                model=model,
+            )
+            columnar = build_recurrence_builder_input_v1(logical)
+            pairing = logical.fermion_pairing_catalog
+            assert pairing is not None
+            assert pairing.source_count == len(process.legs)
+            assert len(columnar.fermion_pairing_digest or "") == 64
+            assert len(pairing.topology_digest) == 64
+            assert len(pairing.semantic_digest) == 64
+            assert len(pairing.rules) >= 1
+            assert columnar.table("physical_lc_sectors").row_count == (
+                color_plan.sector_count
+            )
+            assert columnar.table("replay_targets").row_count == sum(
+                len(partition.targets) for partition in logical.replay_partitions
+            )
+            if expression == "g g > g g":
+                assert not pairing.endpoints
+                assert not pairing.pairing_classes
+                assert len(pairing.rules) == 1
+            elif expression == "d d~ > u u~":
+                assert len(pairing.endpoints) == 4
+                assert len(pairing.pairing_classes) == 1
+                assert len(pairing.rules) == 2
+            elif expression == "u d~ > w+":
+                assert len(pairing.endpoints) == 2
+                assert len(pairing.pairing_classes) == 1
+                assert len(pairing.rules) == 1
+            elif expression == "d d~ > d d~":
+                assert len(pairing.endpoints) == 4
+                assert len(pairing.pairing_classes) == 1
+                assert len(pairing.rules) == 2
+            elif expression == "d d~ > u u~ s s~":
+                assert len(pairing.endpoints) == 6
+                assert len(pairing.pairing_classes) == 2
+                assert len(pairing.rules) == 2
+            elif expression == "d d~ > u u~ s s~ c c~":
+                assert len(pairing.endpoints) == 8
+                assert len(pairing.pairing_classes) == 2
+                assert len(pairing.rules) == 4
+            elif expression == "d d~ > u u~ s s~ c c~ b b~":
+                assert len(pairing.endpoints) == 10
+                assert len(pairing.pairing_classes) == 3
+                assert len(pairing.rules) == 4
+            summaries[model_source][expression] = (
+                len(pairing.endpoints),
+                len(pairing.pairing_classes),
+                len(pairing.rules),
+                color_plan.sector_count,
+                columnar.table("replay_targets").row_count,
+            )
+
+    assert summaries["built-in"] == summaries["ufo-sm"]
+    assert summaries["built-in"]["d d~ > u u~ s s~"][3] > 1
+    assert summaries["built-in"]["d d~ > u u~ s s~ c c~"][3] == 24
+    assert summaries["built-in"]["d d~ > u u~ s s~ c c~ b b~"][3] == 120
+
+
+def test_arbitrary_quark_lines_project_every_report_color_layout() -> None:
+    """Four-line contracted and five-line LC projections have no core ceiling."""
+
+    model = BuiltinSMModel()
+    recurrence_catalog = build_recurrence_template_catalog(
+        model,
+        build_prepared_kernel_catalog(model),
+        compiled_model_digest=_COMPILED_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+    )
+    cases = (
+        ("d d~ > u u~ s s~ c c~", "lc", "topology-replay", 8),
+        ("d d~ > u u~ s s~ c c~", "lc", "all-flow-union", 8),
+        ("d d~ > u u~ s s~ c c~", "nlc", "contracted-color-union", 8),
+        ("d d~ > u u~ s s~ c c~", "full", "contracted-color-union", 8),
+        ("d d~ > u u~ s s~ c c~ b b~", "lc", "topology-replay", 10),
+        ("d d~ > u u~ s s~ c c~ b b~", "lc", "all-flow-union", 10),
+    )
+
+    for expression, accuracy, layout, expected_endpoints in cases:
+        process = build_process_ir(expression, color_accuracy=accuracy)
+        if layout == "topology-replay":
+            dag = compile_generic_dag(
+                process,
+                model=model,
+                max_coupling_orders=infer_minimal_coupling_order_limits(
+                    process,
+                    model=model,
+                ),
+            )
+            assert dag.currents
+            assert dag.interactions
+        color_plan = build_color_plan(
+            process,
+            color_accuracy=accuracy,
+            fold_trace_reflections=model.lc_trace_reflection_equivalence_is_proven(
+                process
+            ),
+        )
+        replay = (
+            build_lc_topology_replay_plan(color_plan, model)
+            if layout == "topology-replay"
+            else None
+        )
+        logical = project_recurrence_process_v1(
+            process,
+            color_plan,
+            recurrence_catalog,
+            layout=layout,
+            normalization=RecurrenceNormalizationV1(
+                ExactComplexRationalV1(1),
+                "arbitrary-quark-line-canary-v1",
+                "9" * 64,
+            ),
+            topology_replay=replay,
+            coupling_order_limits=infer_minimal_coupling_order_limits(
+                process,
+                model=model,
+            ),
+            model=model,
+        )
+        columnar = build_recurrence_builder_input_v1(logical)
+        pairing = logical.fermion_pairing_catalog
+
+        assert pairing is not None
+        assert pairing.source_count == len(process.legs)
+        assert len(pairing.endpoints) == expected_endpoints
+        assert len(pairing.topology_digest) == 64
+        assert len(pairing.semantic_digest) == 64
+        assert columnar.table("physical_lc_sectors").row_count == (
+            color_plan.sector_count
+        )
diff --git a/pyamplicol/tests/unit/test_recurrence_runtime_ab_analyzer.py b/pyamplicol/tests/unit/test_recurrence_runtime_ab_analyzer.py
new file mode 100644
index 0000000000..0bde9abfc8
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_runtime_ab_analyzer.py
@@ -0,0 +1,290 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import Any
+
+import pytest
+
+from tools.developer import recurrence_generation_ab_ladder as ladder
+from tools.developer import recurrence_runtime_ab_analyzer as analyzer
+from tools.developer import recurrence_z6g_benchmark as harness
+
+
+def _runtime_peak(value: int) -> dict[str, object]:
+    return {
+        "source": "resource.getrusage",
+        "self_peak_bytes": value,
+        "maximum_child_peak_bytes": 0,
+        "observed_lower_bound_bytes": value,
+        "semantics": harness._RESOURCE_PEAK_SEMANTICS,
+    }
+
+
+def _outer_sample(
+    *,
+    pair_index: int,
+    variant: str,
+    order_in_pair: int,
+    timing_ratios: Sequence[float],
+    include_runtime_rss: bool,
+    rss_ratio: float,
+) -> dict[str, object]:
+    workers = []
+    for round_index, ratio in enumerate(timing_ratios):
+        baseline_timing = 1.0e-6 * (1.0 + round_index / 100.0)
+        timing = baseline_timing if variant == "baseline" else baseline_timing * ratio
+        baseline_rss = 1_000_000_000 + round_index * 1_000_000
+        rss = baseline_rss if variant == "baseline" else round(baseline_rss * rss_ratio)
+        worker: dict[str, object] = {
+            "schedule_index": round_index,
+            "round": round_index,
+            "wall_seconds_per_point": timing,
+            "internal_sample_count": 7,
+            "repetitions_per_sample": 3,
+            "evaluation_count": 21,
+            "evaluated_point_count": 21,
+            "interrupted": False,
+            "worker_wall_seconds": 5.1,
+        }
+        if include_runtime_rss:
+            worker["peak_rss_after_profile"] = _runtime_peak(rss)
+        workers.append(worker)
+    return {
+        "sample_id": f"pair-{pair_index}-{variant}",
+        "pair_index": pair_index,
+        "order_in_pair": order_in_pair,
+        "variant": variant,
+        "multiplicity": 6,
+        "layout": "topology-replay",
+        "runtime_enabled": True,
+        "status": "passed",
+        # These records must never be accepted as runtime-only memory evidence.
+        "watchdog": {"peak_rss": {"bytes_rounded_from_watchdog": 123}},
+        "telemetry": {
+            "generation_peak_rss": {"observed_lower_bound_bytes": 456},
+            "runtime_profile": {
+                "measurements": [
+                    {
+                        "batch_size": 1,
+                        "sample_count": len(workers),
+                        "wall_seconds_per_point": 1.0e-6,
+                        "wall_seconds_per_point_median": 1.0e-6,
+                        "wall_seconds_per_point_mad": 0.0,
+                        "interrupted": False,
+                        "subprocess_samples": workers,
+                    }
+                ]
+            },
+        },
+    }
+
+
+def _campaign(
+    *,
+    pair_count: int = 1,
+    ratio_for_observation: Callable[[int], float] = lambda _index: 0.98,
+    include_runtime_rss: bool = True,
+    rss_ratio: float = 1.0,
+) -> dict[str, object]:
+    samples = []
+    observation_index = 0
+    for pair_index in range(pair_count):
+        ratios = []
+        for _round_index in range(7):
+            ratios.append(ratio_for_observation(observation_index))
+            observation_index += 1
+        order = (
+            ("baseline", "candidate")
+            if pair_index % 2 == 0
+            else ("candidate", "baseline")
+        )
+        for order_in_pair, variant in enumerate(order):
+            samples.append(
+                _outer_sample(
+                    pair_index=pair_index,
+                    variant=variant,
+                    order_in_pair=order_in_pair,
+                    timing_ratios=ratios,
+                    include_runtime_rss=include_runtime_rss,
+                    rss_ratio=rss_ratio,
+                )
+            )
+    return {
+        "kind": analyzer.CAMPAIGN_KIND,
+        "schema_version": analyzer.CAMPAIGN_SCHEMA_VERSION,
+        "campaign_id": "runtime-test",
+        "configuration": {
+            "multiplicities": [6],
+            "layouts": ["topology-replay"],
+            "runtime_multiplicities": [6],
+            "batch_sizes": [1],
+            "warmup_runs": 2,
+            "target_runtime_seconds": 5.0,
+            "minimum_samples": 7,
+            "subprocess_samples": 7,
+            "ordering_policy": "alternating-baseline-candidate-pairs-v1",
+            "cold_cache_policy": "unique-roots-per-outer-sample-v1",
+        },
+        "samples": samples,
+    }
+
+
+def _analyze(campaign: dict[str, Any]) -> dict[str, object]:
+    return analyzer.analyze_campaign(
+        campaign,
+        multiplicities=(6,),
+        layouts=("topology-replay",),
+        batch_sizes=(1,),
+    )
+
+
+def test_paired_log_interval_and_seven_sample_pass_are_deterministic() -> None:
+    interval = analyzer.paired_log_ratio_interval([1.0] * 7, [0.98] * 7)
+    assert interval["sample_count"] == 7
+    assert interval["candidate_over_baseline_geometric_mean"] == pytest.approx(0.98)
+    assert interval["candidate_over_baseline_upper_confidence_bound"] == pytest.approx(
+        0.98
+    )
+
+    result = _analyze(_campaign())
+    assert result["status"] == "passed"
+    assert result["passes"] is True
+    cell = result["cells"][0]
+    assert cell["paired_sample_count"] == 7
+    assert cell["timing"]["gate"]["status"] == "passed"
+    assert cell["runtime_rss"]["gate"]["status"] == "passed"
+
+
+def test_inconclusive_seven_samples_requests_expansion_to_twenty_one() -> None:
+    result = _analyze(
+        _campaign(ratio_for_observation=lambda index: 0.99 if index % 2 == 0 else 1.01)
+    )
+    cell = result["cells"][0]
+    assert result["status"] == "needs-more-samples"
+    assert cell["timing"]["gate"]["status"] == "needs-more-samples"
+    assert cell["timing"]["gate"]["additional_paired_samples_allowed"] == 14
+
+
+def test_inconclusive_twenty_one_samples_rejects_runtime_change() -> None:
+    result = _analyze(
+        _campaign(
+            pair_count=3,
+            ratio_for_observation=lambda index: 0.99 if index % 2 == 0 else 1.01,
+        )
+    )
+    cell = result["cells"][0]
+    assert result["status"] == "rejected"
+    assert cell["paired_sample_count"] == 21
+    assert cell["timing"]["gate"]["status"] == "rejected-inconclusive"
+    assert cell["timing"]["gate"]["additional_paired_samples_allowed"] == 0
+
+
+def test_statistically_supported_slowdown_rejects_immediately() -> None:
+    result = _analyze(_campaign(ratio_for_observation=lambda _index: 1.02))
+    cell = result["cells"][0]
+    assert result["status"] == "rejected"
+    assert cell["timing"]["gate"]["status"] == "rejected-supported-slowdown"
+
+
+def test_runtime_rss_gate_ignores_generation_and_outer_watchdog_memory() -> None:
+    result = _analyze(_campaign(include_runtime_rss=False))
+    cell = result["cells"][0]
+    assert result["status"] == "incomplete-runtime-rss"
+    assert cell["runtime_rss"]["interval"] is None
+    assert cell["runtime_rss"]["gate"]["status"] == "missing-runtime-only-rss"
+
+
+def test_supported_material_runtime_rss_increase_rejects() -> None:
+    result = _analyze(_campaign(rss_ratio=1.20))
+    cell = result["cells"][0]
+    assert result["status"] == "rejected"
+    assert (
+        cell["runtime_rss"]["gate"]["status"]
+        == "rejected-supported-material-rss-increase"
+    )
+
+
+def test_outer_pair_order_must_alternate() -> None:
+    campaign = _campaign(pair_count=3)
+    samples = campaign["samples"]
+    assert isinstance(samples, list)
+    pair_one = [
+        sample
+        for sample in samples
+        if isinstance(sample, dict) and sample["pair_index"] == 1
+    ]
+    for sample in pair_one:
+        sample["order_in_pair"] = 0 if sample["variant"] == "baseline" else 1
+    with pytest.raises(analyzer.RuntimeABError, match="did not alternate"):
+        _analyze(campaign)
+
+
+def test_runtime_rss_survives_harness_aggregation_and_campaign_compaction(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    schedule = harness._build_profile_schedule(
+        ("recurrence",),
+        (1,),
+        subprocess_samples=1,
+    )
+    semantic_identity: dict[str, object] = {"test": "identity"}
+    semantic_sha256 = harness._canonical_sha256(semantic_identity)
+    peak = _runtime_peak(1_234_567_890)
+    worker: dict[str, object] = {
+        "mode": "recurrence",
+        "schedule_index": 0,
+        "schedule_round": 0,
+        "process_id": "process",
+        "process_expression": "d d~ > Z g g g g g",
+        "selector_contract": {},
+        "validation": {},
+        "pre_timing_verification": {
+            "artifact_semantic_identity": semantic_identity,
+            "artifact_semantic_identity_sha256": semantic_sha256,
+        },
+        "post_timing_loaded_runtime_artifact": {},
+        "worker_command": {},
+        "worker_invocation": {},
+        "worker_process_record": {},
+        "worker_result_record": {},
+        "cold_load_seconds": 0.01,
+        "peak_rss_after_cold_load": _runtime_peak(1_000_000_000),
+        "peak_rss_after_profile": peak,
+        "timing_configuration": {},
+        "profiles": [
+            {
+                "batch_size": 1,
+                "sample_count": 7,
+                "repetitions_per_sample": 1,
+                "evaluation_count": 7,
+                "evaluated_point_count": 7,
+                "wall_seconds_per_point": 1.0e-6,
+                "inner_native_wall_blocks": {},
+                "timing_sources": {},
+                "environment": {},
+                "interrupted": False,
+            }
+        ],
+    }
+    monkeypatch.setattr(
+        harness,
+        "_retained_profile_worker_result_record",
+        lambda *_args, **_kwargs: {
+            "addressed_payload_sha256": "a" * 64,
+        },
+    )
+    profiles = harness._aggregate_profile_workers(schedule, [worker])
+    aggregated = profiles["recurrence"]["profiles"][0]["subprocess_samples"][0]
+    assert aggregated["peak_rss_after_profile"] == peak
+
+    compact = ladder._runtime_profile_summary(
+        {
+            "process_id": "process",
+            "process_expression": "d d~ > Z g g g g g",
+            "profiles": profiles["recurrence"]["profiles"],
+        }
+    )
+    assert compact is not None
+    compact_worker = compact["measurements"][0]["subprocess_samples"][0]
+    assert compact_worker["peak_rss_after_profile"] == peak
diff --git a/pyamplicol/tests/unit/test_recurrence_schedule_sharing.py b/pyamplicol/tests/unit/test_recurrence_schedule_sharing.py
new file mode 100644
index 0000000000..333749e467
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_schedule_sharing.py
@@ -0,0 +1,935 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import struct
+from collections.abc import Mapping
+from dataclasses import dataclass, replace
+from pathlib import Path
+from types import SimpleNamespace
+from typing import cast
+
+import pytest
+
+import pyamplicol.generation.recurrence_schedule_sharing as schedule_sharing
+from pyamplicol.generation.artifact_writer import (
+    _recurrence_binding_native_schedule_semantic_digest,
+)
+from pyamplicol.generation.recurrence_columnar import (
+    ExactComplexRationalV1,
+    RecurrenceBuilderLogicalInputV1,
+    RecurrenceCouplingLimitV1,
+    RecurrenceExternalLegV1,
+    RecurrenceLCOpenStringV1,
+    RecurrenceNormalizationV1,
+    RecurrenceParameterProjectionV1,
+    RecurrencePhysicalLCSectorV1,
+    RecurrencePublicLCFlowV1,
+    RecurrenceReplayPartitionV1,
+    RecurrenceReplayTargetV1,
+    RecurrenceSemanticDigestV1,
+    RecurrenceSemanticTemplateReferenceV1,
+    RecurrenceSourceStateV1,
+)
+from pyamplicol.generation.recurrence_fermion_pairing import (
+    NO_FERMION_LINE,
+    ExternalFermionEndpointRowV1,
+    FermionPairingCatalogV1,
+    FermionPairingClassRowV1,
+    FermionPairingRuleRowV1,
+)
+from pyamplicol.generation.recurrence_schedule_sharing import (
+    RECURRENCE_PROCESS_BINDING_MAGIC,
+    RecurrenceProcessExecutorPack,
+    RecurrenceProcessRemap,
+    RecurrenceScheduleLoweringCache,
+    RecurrenceScheduleSharingError,
+    encode_recurrence_process_binding,
+    exact_recurrence_process_bijection,
+    intern_recurrence_schedules,
+    recurrence_helicity_selector_schedule_digest,
+    recurrence_native_schedule_semantic_digest,
+    recurrence_schedule_semantic_digest,
+)
+from pyamplicol.models.recurrence_template import (
+    ExactComplexRationalV1 as ModelExactComplexRationalV1,
+)
+
+
+def _digest(value: str) -> str:
+    return hashlib.sha256(value.encode()).hexdigest()
+
+
+def test_helicity_selector_schedule_identity_binds_dispatch_sidecar() -> None:
+    base = _digest("base schedule")
+    first_dispatch = _digest("dispatch one")
+    second_dispatch = _digest("dispatch two")
+
+    first = recurrence_helicity_selector_schedule_digest(base, first_dispatch)
+
+    assert first == recurrence_helicity_selector_schedule_digest(
+        base,
+        first_dispatch,
+    )
+    assert first != recurrence_helicity_selector_schedule_digest(
+        base,
+        second_dispatch,
+    )
+    assert first != base
+
+
+def _identity_remap(
+    *,
+    source_count: int = 2,
+    flow_count: int = 1,
+    sector_count: int = 1,
+) -> RecurrenceProcessRemap:
+    return RecurrenceProcessRemap(
+        source_slots=tuple(range(source_count)),
+        source_momentum_signs=(1,) * source_count,
+        source_helicity_signs=(1,) * source_count,
+        source_state_offsets=tuple(range(source_count + 1)),
+        source_state_indices=(0,) * source_count,
+        public_flow_ids=tuple(range(flow_count)),
+        physical_sector_ids=tuple(range(sector_count)),
+        state_template_count=3,
+        source_template_count=3,
+        direct_executor_count=4,
+        parameter_slot_count=1,
+    ).with_digest(_digest("identity remap"))
+
+
+def _executor_pack() -> RecurrenceProcessExecutorPack:
+    descriptor = struct.pack("<IIBBHI", 16, 0, 0, 0, 0, 1)
+    return RecurrenceProcessExecutorPack(
+        compiled_model_digest=_digest("compiled model"),
+        recurrence_template_catalog_digest=_digest("recurrence templates"),
+        prepared_kernel_pack_digest=_digest("prepared pack"),
+        direct_template_catalog_digest=_digest("direct templates"),
+        runtime_layout_digest=_digest("runtime layout"),
+        backend="jit",
+        target_triple="symjit-storage-v3-portable",
+        portable=True,
+        cpu_features=(),
+        catalog_executor_count=4,
+        executor_ids=(0,),
+        descriptor_payloads=(descriptor,),
+    )
+
+
+@dataclass(frozen=True)
+class _Leg:
+    physical_pdg: int
+    support_mask: int
+
+
+@dataclass(frozen=True)
+class _Logical:
+    process_id: str
+    process_support_mask: int
+    external_legs: tuple[_Leg, ...]
+    proof_digest: str
+
+
+def _schedule_key(logical: _Logical) -> str:
+    return recurrence_schedule_semantic_digest(
+        cast(RecurrenceBuilderLogicalInputV1, logical),
+        prepared_kernel_pack_digest=_digest("pack"),
+        direct_template_catalog_digest=_digest("templates"),
+        point_tile_size=1024,
+        workspace_mib=256,
+    )
+
+
+def test_prelower_identity_normalizes_only_process_ownership() -> None:
+    first = _Logical("subprocess-a", 1, (_Leg(1, 1), _Leg(-1, 1)), _digest("p"))
+    alias = _Logical("subprocess-b", 8, (_Leg(1, 8), _Leg(-1, 8)), _digest("p"))
+    different = _Logical("subprocess-c", 2, (_Leg(2, 2), _Leg(-2, 2)), _digest("p"))
+
+    assert _schedule_key(first) == _schedule_key(alias)
+    assert _schedule_key(first) != _schedule_key(different)
+    assert recurrence_schedule_semantic_digest(
+        cast(RecurrenceBuilderLogicalInputV1, first),
+        prepared_kernel_pack_digest=_digest("different pack"),
+        direct_template_catalog_digest=_digest("templates"),
+        point_tile_size=1024,
+        workspace_mib=256,
+    ) != _schedule_key(first)
+
+
+def test_relation_discovery_only_changes_request_cache_identity() -> None:
+    logical = cast(
+        RecurrenceBuilderLogicalInputV1,
+        _Logical("subprocess-a", 1, (_Leg(1, 1), _Leg(-1, 1)), _digest("p")),
+    )
+
+    def schedule_digest(
+        relation_discovery: Mapping[str, object] | None = None,
+    ) -> str:
+        return recurrence_schedule_semantic_digest(
+            logical,
+            prepared_kernel_pack_digest=_digest("pack"),
+            direct_template_catalog_digest=_digest("templates"),
+            point_tile_size=1024,
+            workspace_mib=256,
+            relation_discovery=relation_discovery,
+        )
+
+    baseline = schedule_digest()
+    native = recurrence_native_schedule_semantic_digest(
+        logical,
+        prepared_kernel_pack_digest=_digest("pack"),
+        direct_template_catalog_digest=_digest("templates"),
+        point_tile_size=1024,
+        workspace_mib=256,
+    )
+    assert schedule_digest(None) == baseline
+    assert native == baseline
+    contract = {
+        "mode": "diagnostic",
+        "precision_digits": 96,
+        "probe_count": 4,
+        "verification_probe_count": 4,
+        "relative_tolerance": 1.0e-70,
+        "absolute_tolerance": 1.0e-80,
+        "seed": 7,
+        "color_accuracy": "lc",
+        "probe_process_id": "subprocess-a",
+    }
+    diagnostic = schedule_digest(contract)
+    certified = schedule_digest(
+        {**contract, "mode": "certified-reuse"},
+    )
+    assert diagnostic != baseline
+    assert certified != diagnostic
+    assert native != diagnostic
+    assert native != certified
+    for field, replacement in (
+        ("precision_digits", 112),
+        ("probe_count", 5),
+        ("verification_probe_count", 5),
+        ("relative_tolerance", 1.0e-60),
+        ("absolute_tolerance", 1.0e-75),
+        ("seed", 8),
+        ("color_accuracy", "nlc"),
+        ("probe_process_id", "subprocess-b"),
+    ):
+        assert schedule_digest({**contract, field: replacement}) != diagnostic
+
+
+def test_combined_schedule_digests_match_public_wrappers() -> None:
+    logical = cast(
+        RecurrenceBuilderLogicalInputV1,
+        _Logical("subprocess-a", 1, (_Leg(1, 1), _Leg(-1, 1)), _digest("p")),
+    )
+    kwargs = {
+        "prepared_kernel_pack_digest": _digest("pack"),
+        "direct_template_catalog_digest": _digest("templates"),
+        "point_tile_size": 1024,
+        "workspace_mib": 256,
+    }
+    relation_discovery = {
+        "mode": "certified-reuse",
+        "precision_digits": 96,
+        "probe_count": 4,
+    }
+
+    native, request, sharing_domain = (
+        schedule_sharing._recurrence_schedule_semantic_digests(
+            logical,
+            **kwargs,
+            relation_discovery=relation_discovery,
+        )
+    )
+    baseline_native, baseline_request, baseline_domain = (
+        schedule_sharing._recurrence_schedule_semantic_digests(
+            logical,
+            **kwargs,
+        )
+    )
+
+    assert native == recurrence_native_schedule_semantic_digest(logical, **kwargs)
+    assert request == recurrence_schedule_semantic_digest(
+        logical,
+        **kwargs,
+        relation_discovery=relation_discovery,
+    )
+    assert baseline_native == baseline_request == native
+    assert sharing_domain != baseline_domain
+    _, _, other_probe_domain = schedule_sharing._recurrence_schedule_semantic_digests(
+        logical,
+        **kwargs,
+        relation_discovery={
+            **relation_discovery,
+            "probe_process_id": "different-process",
+        },
+    )
+    assert other_probe_domain != sharing_domain
+
+
+def test_combined_schedule_digests_traverse_logical_input_once(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    logical = cast(
+        RecurrenceBuilderLogicalInputV1,
+        _Logical("subprocess-a", 1, (_Leg(1, 1), _Leg(-1, 1)), _digest("p")),
+    )
+    original_schedule_plain = schedule_sharing._schedule_plain
+    logical_traversals = 0
+
+    def counting_schedule_plain(value: object) -> object:
+        nonlocal logical_traversals
+        if value is logical:
+            logical_traversals += 1
+        return original_schedule_plain(value)
+
+    monkeypatch.setattr(schedule_sharing, "_schedule_plain", counting_schedule_plain)
+    schedule_sharing._recurrence_schedule_semantic_digests(
+        logical,
+        prepared_kernel_pack_digest=_digest("pack"),
+        direct_template_catalog_digest=_digest("templates"),
+        point_tile_size=1024,
+        workspace_mib=256,
+        relation_discovery={"mode": "diagnostic"},
+    )
+
+    assert logical_traversals == 1
+
+
+def test_identical_process_schedules_are_lowered_once() -> None:
+    cache = RecurrenceScheduleLoweringCache[str]()
+    calls = 0
+
+    def lower() -> str:
+        nonlocal calls
+        calls += 1
+        return "root schedule"
+
+    digest = _digest("schedule")
+    assert cache.lower_once(digest, lower) == "root schedule"
+    assert cache.lower_once(digest, lower) == "root schedule"
+    assert calls == 1
+
+
+def _pairing(
+    process_id: str,
+    *,
+    fundamental: int,
+    antifundamental: int,
+    source_count: int,
+) -> FermionPairingCatalogV1:
+    endpoints = (
+        ExternalFermionEndpointRowV1(
+            endpoint_id=0,
+            source_slot=antifundamental,
+            public_label=antifundamental + 1,
+            species_class_id=0,
+            species_id="model:d",
+            particle_orientation="antiparticle",
+            color_orientation="antifundamental",
+            state_template_ids=("dbar",),
+            anti_state_template_ids=("d",),
+            basis_ids=("dirac",),
+            color_representations=(-3,),
+            contract_digest=_digest(f"{process_id}:anti"),
+        ),
+        ExternalFermionEndpointRowV1(
+            endpoint_id=1,
+            source_slot=fundamental,
+            public_label=fundamental + 1,
+            species_class_id=0,
+            species_id="model:d",
+            particle_orientation="particle",
+            color_orientation="fundamental",
+            state_template_ids=("d",),
+            anti_state_template_ids=("dbar",),
+            basis_ids=("dirac",),
+            color_representations=(3,),
+            contract_digest=_digest(f"{process_id}:fund"),
+        ),
+    )
+    pairing_class = FermionPairingClassRowV1(
+        class_id=0,
+        species_class_id=0,
+        species_id="model:d",
+        fundamental_source_slots=(fundamental,),
+        antifundamental_source_slots=(antifundamental,),
+        reference_pairings=((fundamental, antifundamental),),
+        pairing_count=1,
+        proof_digest=_digest(f"{process_id}:class"),
+    )
+    lineage = [NO_FERMION_LINE] * source_count
+    lineage[fundamental] = 0
+    lineage[antifundamental] = 0
+    rule = FermionPairingRuleRowV1(
+        rule_id=0,
+        class_pairing_indices=((0, 0),),
+        endpoint_pairings=((fundamental, antifundamental),),
+        source_slot_permutation=tuple(range(source_count)),
+        lineage_by_source_slot=tuple(lineage),
+        fermion_parity=1,
+        exact_factor=ModelExactComplexRationalV1.one(),
+        multiplicity=1,
+        proof_algorithm="canonical-external-fermion-pairing-v1",
+        proof_digest=_digest(f"{process_id}:rule"),
+    )
+    return FermionPairingCatalogV1(
+        process_key=process_id,
+        source_count=source_count,
+        endpoints=endpoints,
+        pairing_classes=(pairing_class,),
+        rules=(rule,),
+        topology_digest=_digest(f"{process_id}:pairing-topology"),
+        semantic_digest=_digest(f"{process_id}:pairing-semantic"),
+    )
+
+
+def _source_state(
+    *,
+    state_template_id: int,
+    public_helicity: int,
+    momentum_sign: int,
+) -> RecurrenceSourceStateV1:
+    return RecurrenceSourceStateV1(
+        state_index=0,
+        public_helicity=public_helicity,
+        chirality=0,
+        spin_state=public_helicity,
+        current_state_template_id=state_template_id,
+        source_template_id=state_template_id,
+        momentum_sign=momentum_sign,
+        crossing_phase=ExactComplexRationalV1(1),
+    )
+
+
+def _crossed_logical(*, target: bool) -> RecurrenceBuilderLogicalInputV1:
+    process_id = "d_g_to_d_g" if target else "d_dbar_to_g_g"
+    if target:
+        outgoing = (-1, 21, 1, 21)
+        physical = (1, 21, 1, 21)
+        initial = (True, True, False, False)
+        helicities = (-1, -1, 1, 1)
+        momentum_signs = (-1, -1, 1, 1)
+        state_ids = (0, 2, 1, 2)
+        source_map = (0, 2, 1, 3)
+    else:
+        outgoing = (-1, 1, 21, 21)
+        physical = (1, -1, 21, 21)
+        initial = (True, True, False, False)
+        helicities = (-1, 1, -1, 1)
+        momentum_signs = (-1, -1, 1, 1)
+        state_ids = (0, 1, 2, 2)
+        source_map = (0, 1, 2, 3)
+    external = tuple(
+        RecurrenceExternalLegV1(
+            source_slot=slot,
+            public_label=slot + 1,
+            physical_pdg=physical[slot],
+            outgoing_pdg=outgoing[slot],
+            is_initial=initial[slot],
+            is_fermionic=abs(outgoing[slot]) == 1,
+            source_states=(
+                _source_state(
+                    state_template_id=state_ids[slot],
+                    public_helicity=helicities[slot],
+                    momentum_sign=momentum_signs[slot],
+                ),
+            ),
+            momentum_mask=1 << slot,
+            support_mask=2 if target else 1,
+        )
+        for slot in range(4)
+    )
+    root_word = (1, 2, 3, 0)
+    word = tuple(source_map[slot] for slot in root_word)
+    open_string = RecurrenceLCOpenStringV1(
+        fundamental_source_slot=source_map[1],
+        antifundamental_source_slot=source_map[0],
+        adjoint_source_slots=(source_map[2], source_map[3]),
+    )
+    sector = RecurrencePhysicalLCSectorV1(
+        sector_id=0,
+        public_id=f"{process_id}:sector",
+        kind="open-lines",
+        closure_source_slot=source_map[0],
+        closure_proof_algorithm="canonical-lc-closure-anchor-v2",
+        closure_proof_digest=_digest(f"{process_id}:closure"),
+        open_strings=(open_string,),
+        word_source_slots=word,
+        support_mask=2 if target else 1,
+    )
+    flow = RecurrencePublicLCFlowV1(
+        flow_id=0,
+        public_id="flow:" + ",".join(str(slot + 1) for slot in word),
+        construction_sector_id=0,
+        word_source_slots=word,
+        source_slot_permutation=(0, 1, 2, 3),
+    )
+    replay_target = RecurrenceReplayTargetV1(
+        sector_id=0,
+        external_permutation=(0, 1, 2, 3),
+        source_slot_permutation=(0, 1, 2, 3),
+    )
+    replay = RecurrenceReplayPartitionV1(
+        representative_sector_id=0,
+        materialized_sector_id=0,
+        proof_algorithm="exact-crossing-replay-v1",
+        proof_digest=_digest(f"{process_id}:replay"),
+        targets=(replay_target,),
+    )
+    references = tuple(
+        RecurrenceSemanticTemplateReferenceV1(
+            kind=kind,
+            template_id=index,
+            semantic_digest=_digest(f"{kind}:{index}"),
+        )
+        for kind in ("current-state", "source")
+        for index in range(3)
+    )
+    semantics = (
+        *(
+            RecurrenceSemanticDigestV1(role, _digest(f"{process_id}:{role}"))
+            for role in (
+                "process",
+                "color-plan",
+                "fermion-pairing-semantic",
+                "fermion-pairing-topology",
+                "closure-reconstruction",
+            )
+        ),
+        RecurrenceSemanticDigestV1("model-catalog", _digest("model")),
+        RecurrenceSemanticDigestV1("prepared-catalog", _digest("prepared")),
+        RecurrenceSemanticDigestV1(
+            "helicity-equivalence:global-flip-v1",
+            _digest(f"{process_id}:global-flip"),
+        ),
+    )
+    return RecurrenceBuilderLogicalInputV1(
+        process_id=process_id,
+        layout="topology-replay",
+        semantic_digests=semantics,
+        external_legs=external,
+        physical_sectors=(sector,),
+        public_flows=(flow,),
+        semantic_template_references=references,
+        normalization=RecurrenceNormalizationV1(
+            ExactComplexRationalV1(2 if target else 1),
+            "binding-local-normalization",
+            _digest(f"{process_id}:normalization"),
+        ),
+        fermion_pairing_catalog=_pairing(
+            process_id,
+            fundamental=source_map[1],
+            antifundamental=source_map[0],
+            source_count=4,
+        ),
+        replay_partitions=(replay,),
+        coupling_limits=(RecurrenceCouplingLimitV1("QCD", 2, 2),),
+        parameter_projection=(RecurrenceParameterProjectionV1(0, "alpha_s", 0, 0),),
+        process_support_mask=2 if target else 1,
+    )
+
+
+def test_crossed_processes_share_only_through_an_exact_bijection() -> None:
+    root = _crossed_logical(target=False)
+    target = _crossed_logical(target=True)
+    remap = exact_recurrence_process_bijection(
+        root,
+        target,
+        direct_executor_count=4,
+        parameter_slot_count=1,
+    )
+    assert remap is not None
+    assert remap.source_slots == (0, 2, 1, 3)
+    assert remap.source_momentum_signs == (1, -1, -1, 1)
+    assert remap.source_helicity_signs == (1, 1, 1, 1)
+    assert remap.source_state_offsets == (0, 1, 2, 3, 4)
+    assert remap.source_state_indices == (0, 0, 0, 0)
+    assert remap.public_flow_ids == (0,)
+    assert remap.physical_sector_ids == (0,)
+
+    cache = RecurrenceScheduleLoweringCache[str]()
+    calls = 0
+
+    def lower(value: str) -> str:
+        nonlocal calls
+        calls += 1
+        return value
+
+    first = cache.lower_process(
+        root,
+        schedule_digest=_digest("root request"),
+        sharing_domain_digest=_digest("shared domain"),
+        native_schedule_semantic_digest=_digest("root native semantics"),
+        direct_executor_count=4,
+        parameter_slot_count=1,
+        lower=lambda: lower("root"),
+    )
+    second = cache.lower_process(
+        target,
+        schedule_digest=_digest("target request"),
+        sharing_domain_digest=_digest("shared domain"),
+        native_schedule_semantic_digest=_digest("target native semantics"),
+        direct_executor_count=4,
+        parameter_slot_count=1,
+        lower=lambda: lower("target"),
+    )
+    assert calls == 1
+    assert first.output == second.output == "root"
+    assert second.schedule_digest == first.schedule_digest
+    assert second.native_schedule_semantic_digest == (
+        first.native_schedule_semantic_digest
+    )
+    assert second.remap == remap
+
+
+def test_isomorphic_processes_do_not_share_different_sharing_domains() -> None:
+    root = _crossed_logical(target=False)
+    target = _crossed_logical(target=True)
+    cache = RecurrenceScheduleLoweringCache[str]()
+    calls = 0
+
+    def lower(value: str) -> str:
+        nonlocal calls
+        calls += 1
+        return value
+
+    first = cache.lower_process(
+        root,
+        schedule_digest=_digest("root probe context"),
+        sharing_domain_digest=_digest("root probe domain"),
+        native_schedule_semantic_digest=_digest("root probe native semantics"),
+        direct_executor_count=4,
+        parameter_slot_count=1,
+        lower=lambda: lower("root evidence"),
+    )
+    second = cache.lower_process(
+        target,
+        schedule_digest=_digest("target probe context"),
+        sharing_domain_digest=_digest("target probe domain"),
+        native_schedule_semantic_digest=_digest("target probe native semantics"),
+        direct_executor_count=4,
+        parameter_slot_count=1,
+        lower=lambda: lower("target evidence"),
+    )
+
+    assert calls == 2
+    assert first.output == "root evidence"
+    assert second.output == "target evidence"
+    assert first.schedule_digest != second.schedule_digest
+
+
+def test_cross_process_aliasing_fails_closed_on_contract_changes() -> None:
+    root = _crossed_logical(target=False)
+    target = _crossed_logical(target=True)
+
+    changed_parameter = replace(
+        target,
+        parameter_projection=(
+            replace(target.parameter_projection[0], prepared_parameter_id=None),
+        ),
+    )
+    assert (
+        exact_recurrence_process_bijection(
+            root,
+            changed_parameter,
+            direct_executor_count=4,
+            parameter_slot_count=1,
+        )
+        is None
+    )
+
+    changed_flow = replace(
+        target,
+        public_flows=(
+            replace(
+                target.public_flows[0],
+                reduction_weight=ExactComplexRationalV1(2),
+            ),
+        ),
+    )
+    assert (
+        exact_recurrence_process_bijection(
+            root,
+            changed_flow,
+            direct_executor_count=4,
+            parameter_slot_count=1,
+        )
+        is None
+    )
+
+    changed_templates = list(target.semantic_template_references)
+    changed_templates[0] = replace(
+        changed_templates[0],
+        semantic_digest=_digest("different kernel contract"),
+    )
+    assert (
+        exact_recurrence_process_bijection(
+            root,
+            replace(target, semantic_template_references=tuple(changed_templates)),
+            direct_executor_count=4,
+            parameter_slot_count=1,
+        )
+        is None
+    )
+
+
+def _process(
+    root: Path,
+    *,
+    process_id: str,
+    schedule_digest: str,
+    native_schedule_digest: str | None = None,
+    payload: bytes,
+    support_mask: int,
+) -> SimpleNamespace:
+    path = root / f"{schedule_digest}-{process_id}.pacbin"
+    path.write_bytes(payload)
+    return SimpleNamespace(
+        process_id=process_id,
+        recurrence_schedule_path=path,
+        recurrence_schedule_digest=schedule_digest,
+        recurrence_native_schedule_semantic_digest=(
+            schedule_digest
+            if native_schedule_digest is None
+            else native_schedule_digest
+        ),
+        recurrence_schedule_size_bytes=len(payload),
+        recurrence_schedule_sha256=hashlib.sha256(payload).hexdigest(),
+        recurrence_schedule_member_count=1,
+        recurrence_schedule_unpacked_size_bytes=len(payload),
+        recurrence_schedule_index_sha256=_digest(f"index-{schedule_digest}"),
+        builder_input_sha256=_digest(f"binding-{process_id}"),
+        process_digest=_digest(f"process-{process_id}"),
+        process_support_mask=support_mask,
+        recurrence_process_remap=_identity_remap(),
+        recurrence_process_executor_pack=_executor_pack(),
+    )
+
+
+def test_bounded_process_set_interns_before_publication(tmp_path: Path) -> None:
+    shared = _digest("shared schedule")
+    distinct = _digest("distinct schedule")
+    plan = intern_recurrence_schedules(
+        (
+            _process(
+                tmp_path,
+                process_id="u_ubar_to_g_g",
+                schedule_digest=shared,
+                payload=b"shared",
+                support_mask=1,
+            ),
+            _process(
+                tmp_path,
+                process_id="d_dbar_to_g_g",
+                schedule_digest=shared,
+                payload=b"shared",
+                support_mask=2,
+            ),
+            _process(
+                tmp_path,
+                process_id="g_g_to_g_g",
+                schedule_digest=distinct,
+                payload=b"distinct",
+                support_mask=4,
+            ),
+        )
+    )
+
+    assert len(plan.bindings) == 3
+    assert len(plan.schedules) == 2
+    assert plan.to_mapping()["runtime_ownership"] == (
+        "root-schedule-plus-process-binding"
+    )
+    assert plan.to_mapping()["interning_phase"] == "before-direct-lowering"
+    assert plan.binding("u_ubar_to_g_g").artifact_path.endswith(
+        "/recurrence-binding.bin"
+    )
+    assert plan.binding("u_ubar_to_g_g").native_schedule_semantic_digest == shared
+    assert plan.binding("u_ubar_to_g_g").process_digest == _digest(
+        "process-u_ubar_to_g_g"
+    )
+
+
+def test_package_identity_is_distinct_from_native_schedule_semantics(
+    tmp_path: Path,
+) -> None:
+    request_digest = _digest("certified request")
+    native_digest = _digest("relation-independent source schedule")
+    plan = intern_recurrence_schedules(
+        (
+            _process(
+                tmp_path,
+                process_id="u_ubar_to_g_g",
+                schedule_digest=request_digest,
+                native_schedule_digest=native_digest,
+                payload=b"schedule",
+                support_mask=1,
+            ),
+        )
+    )
+
+    binding = plan.binding("u_ubar_to_g_g")
+    assert plan.schedules[0].digest == request_digest
+    assert binding.schedule_digest == request_digest
+    assert binding.native_schedule_semantic_digest == native_digest
+    assert binding.to_mapping()["native_schedule_semantic_digest"] == native_digest
+
+
+def test_shared_request_digest_rejects_different_native_semantics(
+    tmp_path: Path,
+) -> None:
+    request_digest = _digest("shared certified request")
+    with pytest.raises(
+        RecurrenceScheduleSharingError,
+        match="maps to different native semantics",
+    ):
+        intern_recurrence_schedules(
+            (
+                _process(
+                    tmp_path,
+                    process_id="first",
+                    schedule_digest=request_digest,
+                    native_schedule_digest=_digest("first source schedule"),
+                    payload=b"shared",
+                    support_mask=1,
+                ),
+                _process(
+                    tmp_path,
+                    process_id="second",
+                    schedule_digest=request_digest,
+                    native_schedule_digest=_digest("second source schedule"),
+                    payload=b"shared",
+                    support_mask=2,
+                ),
+            )
+        )
+
+
+def test_binding_requires_native_schedule_semantic_digest() -> None:
+    schedule_digest = _digest("native schedule identity")
+    with pytest.raises(ValueError, match="native schedule semantic digest"):
+        _recurrence_binding_native_schedule_semantic_digest(
+            {"schedule_digest": schedule_digest},
+            process_id="missing",
+        )
+    with pytest.raises(ValueError, match="native schedule semantic digest"):
+        _recurrence_binding_native_schedule_semantic_digest(
+            {
+                "schedule_digest": schedule_digest,
+                "native_schedule_semantic_digest": None,
+            },
+            process_id="malformed",
+        )
+
+
+def test_binding_payload_is_compact_and_process_owned() -> None:
+    schedule = _digest("schedule")
+    process = _digest("canonical process")
+    semantic = _digest("process")
+    payload = encode_recurrence_process_binding(
+        process_id="u_ubar_to_g_g",
+        schedule_digest=schedule,
+        process_digest=process,
+        process_semantic_digest=semantic,
+        process_support_mask=1 << 70,
+        remap=_identity_remap(),
+        executor_pack=_executor_pack(),
+    )
+    (
+        version,
+        fixed_size,
+        process_len,
+        word_count,
+        target_len,
+        feature_count,
+        descriptor_count,
+        catalog_count,
+    ) = struct.unpack_from("<8I", payload, 8)
+    assert payload[:8] == RECURRENCE_PROCESS_BINDING_MAGIC
+    assert payload == encode_recurrence_process_binding(
+        process_id="u_ubar_to_g_g",
+        schedule_digest=schedule,
+        process_digest=process,
+        process_semantic_digest=semantic,
+        process_support_mask=1 << 70,
+        remap=_identity_remap(),
+        executor_pack=_executor_pack(),
+    )
+    assert version == 4
+    assert fixed_size == 344
+    assert word_count == 2
+    assert target_len == len(b"symjit-storage-v3-portable")
+    assert feature_count == 0
+    assert descriptor_count == 1
+    assert catalog_count == 4
+    assert payload[88:120] == bytes.fromhex(schedule)
+    assert payload[120:152] == bytes.fromhex(semantic)
+    assert payload[152:184] == bytes.fromhex(_digest("compiled model"))
+    assert payload[280:312] == bytes.fromhex(_digest("runtime layout"))
+    assert payload[312:344] == bytes.fromhex(process)
+    assert payload[344 : 344 + process_len] == b"u_ubar_to_g_g"
+    assert payload.endswith(_executor_pack().descriptor_payloads[0])
+    assert len(payload) < 512
+
+
+def test_same_schedule_digest_cannot_name_different_payloads(
+    tmp_path: Path,
+) -> None:
+    digest = _digest("schedule")
+    with pytest.raises(
+        RecurrenceScheduleSharingError,
+        match="different payloads",
+    ):
+        intern_recurrence_schedules(
+            (
+                _process(
+                    tmp_path,
+                    process_id="first",
+                    schedule_digest=digest,
+                    payload=b"one",
+                    support_mask=1,
+                ),
+                _process(
+                    tmp_path,
+                    process_id="second",
+                    schedule_digest=digest,
+                    payload=b"two",
+                    support_mask=2,
+                ),
+            )
+        )
+
+
+def test_process_support_bits_are_independent() -> None:
+    first = SimpleNamespace(
+        process_id="first",
+        recurrence_schedule_path=Path(__file__),
+        recurrence_schedule_digest=_digest("schedule"),
+        recurrence_native_schedule_semantic_digest=_digest("schedule"),
+        recurrence_schedule_size_bytes=Path(__file__).stat().st_size,
+        recurrence_schedule_sha256=hashlib.sha256(
+            Path(__file__).read_bytes()
+        ).hexdigest(),
+        recurrence_schedule_member_count=1,
+        recurrence_schedule_unpacked_size_bytes=Path(__file__).stat().st_size,
+        recurrence_schedule_index_sha256=_digest("index"),
+        builder_input_sha256=_digest("first"),
+        process_digest=_digest("first process"),
+        process_support_mask=1,
+        recurrence_process_remap=_identity_remap(),
+        recurrence_process_executor_pack=_executor_pack(),
+    )
+    second = SimpleNamespace(**{**vars(first), "process_id": "second"})
+    with pytest.raises(RecurrenceScheduleSharingError, match="support mask"):
+        intern_recurrence_schedules((first, second))
+
+
+@pytest.mark.skip(
+    reason=(
+        "full p p > j j j j generation belongs to the 30 GiB guarded "
+        "post-build process-set acceptance run"
+    )
+)
+def test_full_pp_to_four_jets_has_fewer_schedules_than_subprocesses() -> None:
+    """Acceptance placeholder retained until the native split build is available."""
diff --git a/pyamplicol/tests/unit/test_recurrence_semantic_census.py b/pyamplicol/tests/unit/test_recurrence_semantic_census.py
new file mode 100644
index 0000000000..af2e18786a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_semantic_census.py
@@ -0,0 +1,415 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+from dataclasses import astuple, replace
+
+import pytest
+
+from pyamplicol.runtime.recurrence_exact._plan_v2 import (
+    DIRECT_NONE_U32,
+    RECURRENCE_EXACT_SECTIONS_ABI,
+    RECURRENCE_RUNTIME_LAYOUT_V2_ABI,
+    _parse_exact_sections,
+)
+from tools.developer import recurrence_semantic_census as census
+
+
+def _sections():
+    raw = {
+        "abi": RECURRENCE_EXACT_SECTIONS_ABI,
+        "runtime_layout_abi": RECURRENCE_RUNTIME_LAYOUT_V2_ABI,
+        "process_id": "synthetic",
+        "strategy": "topology-replay",
+        "semantic_digest": "1" * 64,
+        "runtime_layout_digest": "2" * 64,
+        "counts": [3, 1, 0, 2],
+        "currents": [
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 3, 0, DIRECT_NONE_U32],
+            [1, 0, 1, 1, 1, 1, 0, 0, 0, 3, 1, DIRECT_NONE_U32],
+            [2, 1, 2, 2, 1, 2, 1, 0, 1, 3, DIRECT_NONE_U32, 0],
+        ],
+        "sources": [
+            [0, 0, 0, 0, -1, 0, 0],
+            [1, 1, 1, 1, 1, 0, 0],
+        ],
+        "contributions": [[0, 1, 0, 1, 2, 0, 0, 0]],
+        "finalizations": [[2, 1, 2, 0, 0, 0]],
+        "closures": [[2, DIRECT_NONE_U32, 2, DIRECT_NONE_U32, 0, 0, 0, 1, 0, 0]],
+        "row_groups": [
+            [0, 0, 0, 0, 0, 2],
+            [1, 1, 1, 1, 0, 1],
+            [1, 2, 2, 2, 0, 1],
+            [2, 3, 3, 3, 0, 1],
+        ],
+        "momentum_forms": [[0, 1], [1, 1], [2, 2]],
+        "momentum_terms": [[0, 1], [1, 1], [0, 1], [1, 1]],
+        "replay_targets": [[0, 0, 0, 2, 0, 1, 0, 1, 0]],
+        "source_permutations": [0, 1],
+        "replay_momentum_signs": [1, 1],
+        "replay_helicity_map": [0],
+        "amplitude_destinations": [[0, 0, 0, 0, 1, 0]],
+        "resolved_helicities": [[0, 0, 0, 0, 2, 0, 2, 0]],
+        "source_state_assignments": [[0, 0], [1, 1]],
+        "source_dispatch_variants": [],
+        "source_embeddings": [],
+        "source_projections": [],
+        "resolved_source_selections": [],
+        "public_helicities": [-1, 1],
+        "exact_factors": [["1", "1", "0", "1"]],
+        "public_flow_ids": [0],
+        "executors": [
+            [0, "source", "initialize", [], 1, 1, None, "source"],
+            [1, "contribution", "add", [1, 1], 1, 2, 10, None],
+            [2, "finalization", "finalize-in-place", [1], 1, 1, 11, None],
+            [3, "closure", "closure-add", [1], 1, 1, 12, None],
+        ],
+    }
+    return _parse_exact_sections(raw, "synthetic")
+
+
+def _binding(
+    executor_id: int,
+    role: str,
+    semantic_id: str,
+    *,
+    records: tuple[dict[str, object], ...] = (),
+) -> census.ExecutorSemanticBinding:
+    return census.ExecutorSemanticBinding(
+        executor_id=executor_id,
+        role=role,
+        semantic_digest=f"{executor_id + 3:x}" * 64,
+        semantic_template_ids=(semantic_id,),
+        direct_template={
+            "direct_executor_id": executor_id,
+            "role": role,
+            "semantic_digest": f"{executor_id + 3:x}" * 64,
+            "semantic_template_ids": [semantic_id],
+        },
+        referenced_semantic_records=records
+        or (
+            {
+                "record_kind": role,
+                "semantic_digest": f"{executor_id + 7:x}" * 64,
+                "template_id": semantic_id,
+            },
+        ),
+    )
+
+
+def _inputs():
+    sections = _sections()
+    transition = {
+        "binding_coupling": {
+            "real_numerator": "1",
+            "real_denominator": "1",
+            "imag_numerator": "0",
+            "imag_denominator": "1",
+        },
+        "color_contraction_template_id": "color:test",
+        "quantum_flow_template_id": "quantum:test",
+        "record_kind": "transition",
+        "semantic_digest": "8" * 64,
+        "template_id": "transition:test",
+    }
+    color = {
+        "record_kind": "color-contraction",
+        "semantic_digest": "9" * 64,
+        "template_id": "color:test",
+        "transition_witnesses": [{"proof_digest": "a" * 64}],
+    }
+    quantum = {
+        "record_kind": "quantum-flow",
+        "semantic_digest": "b" * 64,
+        "template_id": "quantum:test",
+    }
+    bindings = {
+        0: _binding(0, "source", "source:test"),
+        1: _binding(
+            1,
+            "contribution",
+            "transition:test",
+            records=(transition, color, quantum),
+        ),
+        2: _binding(2, "finalization", "propagator:test"),
+        3: _binding(3, "closure", "closure:test"),
+    }
+    metadata = {
+        "digests": {
+            "process_semantic_digest": sections.semantic_digest,
+            "runtime_layout_digest": sections.runtime_layout_digest,
+            "schedule_digest": "c" * 64,
+            "native_schedule_semantic_digest": "d" * 64,
+        },
+        "normalization_and_parameters": {
+            "normalization": {"average_factor": 36, "color_factor": 9},
+            "runtime_parameters": [{"name": "alpha_s", "default": 0.118}],
+        },
+        "selectors": {
+            "color_accuracy": "lc",
+            "public_color_flows": [{"public_id": "flow:test"}],
+        },
+        "sources": {
+            "external_pdg_order": [1, -1],
+            "source_templates": [{"source_template_id": 0}],
+        },
+    }
+    states = (
+        {"semantic_digest": "e" * 64, "template_id": "state:left"},
+        {"semantic_digest": "f" * 64, "template_id": "state:right"},
+        {"semantic_digest": "0" * 64, "template_id": "state:result"},
+    )
+    return sections, metadata, bindings, states
+
+
+def _build(
+    sections=None,
+    metadata=None,
+    bindings=None,
+    states=None,
+):
+    base_sections, base_metadata, base_bindings, base_states = _inputs()
+    return census.build_semantic_census(
+        sections=sections or base_sections,
+        process_metadata=metadata or base_metadata,
+        executor_bindings=bindings or base_bindings,
+        state_templates=states or base_states,
+    )
+
+
+def _changed_domains(left, right) -> set[str]:
+    report = census.compare_census_sets({"synthetic": left}, {"synthetic": right})
+    assert report["passes"] is False
+    return {
+        difference["domain"]
+        for difference in report["differences"]
+        if difference["kind"] == "semantic-domain"
+    }
+
+
+def test_identical_semantic_censuses_pass_with_complete_domain_set() -> None:
+    built = _build()
+
+    report = census.compare_census_sets(
+        {"synthetic": built}, {"synthetic": copy.deepcopy(built)}
+    )
+
+    assert report["passes"] is True
+    assert set(built["domains"]) == census._REQUIRED_DOMAINS
+    assert report["difference_count"] == 0
+
+
+def test_current_identity_state_support_color_and_helicity_projection_fail_closed() -> (
+    None
+):
+    sections, metadata, bindings, states = _inputs()
+    currents = list(sections.currents)
+    currents[2] = replace(
+        currents[2],
+        state_template_id=1,
+        selector_domain_id=7,
+        momentum_form_id=0,
+    )
+    changed = replace(sections, currents=tuple(currents))
+
+    domains = _changed_domains(
+        _build(sections, metadata, bindings, states),
+        _build(changed, metadata, bindings, states),
+    )
+
+    assert {"currents", "runtime_layout"} <= domains
+
+
+def test_source_semantics_fail_closed() -> None:
+    sections, metadata, bindings, states = _inputs()
+    sources = list(sections.sources)
+    sources[0] = replace(sources[0], spin_state_class=1)
+
+    domains = _changed_domains(
+        _build(sections, metadata, bindings, states),
+        _build(replace(sections, sources=tuple(sources)), metadata, bindings, states),
+    )
+
+    assert {"sources", "runtime_layout"} <= domains
+
+
+def test_union_source_rows_may_be_owned_without_a_direct_executor() -> None:
+    sections, metadata, bindings, states = _inputs()
+    groups = list(sections.row_groups)
+    groups[0] = replace(groups[0], executor_id=DIRECT_NONE_U32)
+    union_sections = replace(
+        sections,
+        strategy="all-flow-union",
+        row_groups=tuple(groups),
+    )
+
+    built = _build(union_sections, metadata, bindings, states)
+    report = census.compare_census_sets(
+        {"synthetic": built},
+        {"synthetic": copy.deepcopy(built)},
+    )
+
+    assert report["passes"] is True
+    assert built["domains"]["sources"]["record_count"] == 3
+
+
+def test_interaction_endpoints_sign_and_contribution_multiset_fail_closed() -> None:
+    sections, metadata, bindings, states = _inputs()
+    factors = (
+        *sections.exact_factors,
+        replace(sections.exact_factors[0], real_numerator=-1),
+    )
+    contributions = list(sections.contributions)
+    contributions[0] = replace(
+        contributions[0],
+        parent0_base=1,
+        exact_factor_id=1,
+    )
+    changed = replace(
+        sections,
+        exact_factors=factors,
+        contributions=tuple(contributions),
+    )
+
+    domains = _changed_domains(
+        _build(sections, metadata, bindings, states),
+        _build(changed, metadata, bindings, states),
+    )
+
+    assert {"contribution_multisets", "runtime_layout"} <= domains
+
+
+@pytest.mark.parametrize(
+    ("record_index", "mutation"),
+    (
+        (0, ("template_id", "transition:changed")),
+        (0, ("binding_coupling", {"real_numerator": "2"})),
+        (1, ("transition_witnesses", [{"proof_digest": "0" * 64}])),
+    ),
+    ids=("transition-identity", "coupling", "color-witness"),
+)
+def test_transition_coupling_and_witness_catalogs_fail_closed(
+    record_index: int,
+    mutation: tuple[str, object],
+) -> None:
+    sections, metadata, bindings, states = _inputs()
+    changed_bindings = dict(bindings)
+    original = bindings[1]
+    records = [
+        copy.deepcopy(dict(record)) for record in original.referenced_semantic_records
+    ]
+    key, value = mutation
+    if key == "binding_coupling":
+        coupling = dict(records[record_index][key])
+        coupling.update(value)
+        records[record_index][key] = coupling
+    else:
+        records[record_index][key] = value
+    changed_bindings[1] = replace(original, referenced_semantic_records=tuple(records))
+
+    domains = _changed_domains(
+        _build(sections, metadata, bindings, states),
+        _build(sections, metadata, changed_bindings, states),
+    )
+
+    assert "semantic_catalog_bindings" in domains
+
+
+def test_closure_endpoints_and_selector_axes_fail_closed() -> None:
+    sections, metadata, bindings, states = _inputs()
+    closures = list(sections.closures)
+    closures[0] = replace(closures[0], amplitude_destination_id=3)
+    changed_closure = replace(sections, closures=tuple(closures))
+    changed_selector = replace(sections, public_flow_ids=(4,))
+
+    assert "closures" in _changed_domains(
+        _build(sections, metadata, bindings, states),
+        _build(changed_closure, metadata, bindings, states),
+    )
+    assert "selectors" in _changed_domains(
+        _build(sections, metadata, bindings, states),
+        _build(changed_selector, metadata, bindings, states),
+    )
+
+
+def test_normalization_digests_and_layout_each_fail_closed() -> None:
+    sections, metadata, bindings, states = _inputs()
+    changed_metadata = copy.deepcopy(metadata)
+    changed_metadata["normalization_and_parameters"]["normalization"][
+        "average_factor"
+    ] = 18
+    assert "normalization_and_parameters" in _changed_domains(
+        _build(sections, metadata, bindings, states),
+        _build(sections, changed_metadata, bindings, states),
+    )
+
+    changed_digest_sections = replace(sections, semantic_digest="a" * 64)
+    changed_digest_metadata = copy.deepcopy(metadata)
+    changed_digest_metadata["digests"]["process_semantic_digest"] = "a" * 64
+    assert "digests" in _changed_domains(
+        _build(sections, metadata, bindings, states),
+        _build(
+            changed_digest_sections,
+            changed_digest_metadata,
+            bindings,
+            states,
+        ),
+    )
+
+    currents = list(sections.currents)
+    currents[2] = replace(currents[2], component_base=8)
+    assert "runtime_layout" in _changed_domains(
+        _build(sections, metadata, bindings, states),
+        _build(
+            replace(sections, currents=tuple(currents)),
+            metadata,
+            bindings,
+            states,
+        ),
+    )
+
+
+def test_authenticated_storage_hashes_do_not_define_semantic_equivalence() -> None:
+    sections, metadata, bindings, states = _inputs()
+    baseline_metadata = copy.deepcopy(metadata)
+    candidate_metadata = copy.deepcopy(metadata)
+    for index, field in enumerate(
+        sorted(census._STORAGE_AUTHENTICATION_DIGEST_FIELDS),
+        start=1,
+    ):
+        baseline_metadata["digests"][field] = f"{index:x}" * 64
+        candidate_metadata["digests"][field] = f"{index + 4:x}" * 64
+
+    baseline = _build(sections, baseline_metadata, bindings, states)
+    candidate = _build(sections, candidate_metadata, bindings, states)
+
+    assert baseline == candidate
+    assert (
+        census.compare_census_sets(
+            {"synthetic": baseline},
+            {"synthetic": candidate},
+        )["passes"]
+        is True
+    )
+
+
+def test_missing_domain_and_inconsistent_transitive_digest_are_rejected() -> None:
+    built = _build()
+    incomplete = copy.deepcopy(built)
+    incomplete["domains"].pop("closures")
+    with pytest.raises(census.SemanticCensusError, match="incomplete census domains"):
+        census.compare_census_sets({"synthetic": built}, {"synthetic": incomplete})
+
+    sections, metadata, bindings, states = _inputs()
+    metadata["digests"]["process_semantic_digest"] = "a" * 64
+    with pytest.raises(
+        census.SemanticCensusError, match="does not match exact sections"
+    ):
+        _build(sections, metadata, bindings, states)
+
+
+def test_exact_section_fixture_uses_authoritative_parser() -> None:
+    sections = _sections()
+
+    assert sections.currents[2].semantic_id == 2
+    assert astuple(sections.contributions[0]) == (0, 1, 0, 1, 2, 0, 0, 0)
diff --git a/pyamplicol/tests/unit/test_recurrence_template_contract.py b/pyamplicol/tests/unit/test_recurrence_template_contract.py
new file mode 100644
index 0000000000..c16f665e3c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_template_contract.py
@@ -0,0 +1,1376 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from dataclasses import FrozenInstanceError, replace
+from fractions import Fraction
+
+import numpy as np
+import pytest
+
+import pyamplicol.generation.recurrence_template_columnar as template_columnar
+from pyamplicol import _rusticol
+from pyamplicol.generation.recurrence_columnar import (
+    RecurrenceColumn,
+)
+from pyamplicol.generation.recurrence_template_columnar import (
+    RecurrenceColumnarInputError,
+    RecurrenceTemplateInputV1,
+    build_recurrence_template_input_v1,
+)
+from pyamplicol.models.contact_decomposition import (
+    CONTACT_ORBIT_ALGORITHM_VERSION,
+)
+from pyamplicol.models.recurrence_template import (
+    ClosureTemplateV1,
+    ColorContractionTemplateV1,
+    ContactOrbitCertificateV1,
+    ContactOrbitStepV1,
+    CurrentStateTemplateV1,
+    EvaluatorBindingV1,
+    EvaluatorCallableKind,
+    ExactComplexRationalV1,
+    LCColorSourceSeedV1,
+    LCColorTransitionWitnessV1,
+    ParameterTemplateV1,
+    PropagatorTemplateV1,
+    QuantumFlowTemplateV1,
+    RecurrenceRuntimeHelicityContractV1,
+    RecurrenceRuntimeHelicityVariantV1,
+    RecurrenceTemplateCatalog,
+    RecurrenceTemplateError,
+    SourceTemplateV1,
+    SymmetryProofV1,
+    TransitionTemplateV1,
+)
+
+_COMPILED_MODEL_DIGEST = "a" * 64
+_PREPARED_PACK_DIGEST = "c" * 64
+_EXPRESSION_A = "1" * 64
+_EXPRESSION_B = "2" * 64
+_EXPRESSION_C = "3" * 64
+_PREDICATE = "4" * 64
+_WITNESS = "5" * 64
+_CALLABLE_A = "6" * 64
+_CALLABLE_B = "7" * 64
+_CALLABLE_C = "8" * 64
+_CALLABLE_D = "9" * 64
+_CALLABLE_E = "b" * 64
+
+
+def _parameter_templates() -> tuple[ParameterTemplateV1, ...]:
+    return (
+        ParameterTemplateV1(
+            template_id="parameter:coupling",
+            name="model.coupling",
+            parameter_kind="external",
+            value_type="complex",
+            mutable=True,
+            default_value=ExactComplexRationalV1.from_fractions(
+                Fraction(1, 3), Fraction(-1, 7)
+            ),
+            exact_expression_digest=None,
+            dependency_parameter_ids=(),
+        ),
+        ParameterTemplateV1(
+            template_id="parameter:mass",
+            name="particle.mass",
+            parameter_kind="external",
+            value_type="real",
+            mutable=True,
+            default_value=ExactComplexRationalV1.from_binary64(172.5),
+            exact_expression_digest=None,
+            dependency_parameter_ids=(),
+        ),
+    )
+
+
+def _state_templates() -> tuple[CurrentStateTemplateV1, ...]:
+    return (
+        CurrentStateTemplateV1(
+            template_id="state:adjoint",
+            particle_id=9000021,
+            anti_particle_id=9000021,
+            species_id="example:species:adjoint",
+            orientation="self-conjugate",
+            statistics="boson",
+            color_representation=8,
+            basis="lorentz-vector",
+            tensor_ordering=("mu0", "mu1", "mu2", "mu3"),
+            dimension=4,
+            chirality=0,
+            lc_color_shape_kind="adjoint-segment",
+            auxiliary_kind=None,
+            mass_parameter_id=None,
+            width_parameter_id=None,
+        ),
+        CurrentStateTemplateV1(
+            template_id="state:matter",
+            particle_id=9000001,
+            anti_particle_id=-9000001,
+            species_id="example:species:matter",
+            orientation="particle",
+            statistics="fermion",
+            color_representation=3,
+            basis="weyl-chiral",
+            tensor_ordering=("spin0", "spin1"),
+            dimension=2,
+            chirality=1,
+            lc_color_shape_kind="fundamental-open-string",
+            auxiliary_kind=None,
+            mass_parameter_id="parameter:mass",
+            width_parameter_id=None,
+        ),
+    )
+
+
+def _color_template() -> ColorContractionTemplateV1:
+    return ColorContractionTemplateV1(
+        template_id="color:matter-adjoint",
+        rule_kind="ordered-open-string-append",
+        input_representations=(3, 8),
+        output_representation=3,
+        ordered_open_string_arity=1,
+        exact_coefficient=ExactComplexRationalV1.one(),
+        nc_polynomial=((0, ExactComplexRationalV1.one()),),
+        expression_digest=_EXPRESSION_A,
+        transition_witnesses=(
+            LCColorTransitionWitnessV1(
+                input_shape_kinds=(
+                    "fundamental-open-string",
+                    "adjoint-segment",
+                ),
+                input_permutation=(0, 1),
+                reverse_parent_mask=0,
+                component_operation="concatenate-join",
+                result_component_kind="open-string",
+                result_component_role="active",
+                result_shape_kind="fundamental-open-string",
+                exact_factor=ExactComplexRationalV1.one(),
+                proof_digest=_WITNESS,
+                input_port_pairings=(((0, 0), (1, 1)),),
+                result_port_bindings=((1, 0),),
+            ),
+        ),
+    )
+
+
+def _proof() -> SymmetryProofV1:
+    return SymmetryProofV1(
+        template_id="proof:matter-linearity",
+        proof_algorithm="prepared-kernel-homogeneous-complex-linear-current-v1",
+        subject_template_ids=("state:matter",),
+        input_permutation=(0,),
+        exact_phase=ExactComplexRationalV1.one(),
+        expression_digests=(_EXPRESSION_B,),
+        witness_digest=_WITNESS,
+    )
+
+
+def _source_templates() -> tuple[SourceTemplateV1, ...]:
+    return (
+        SourceTemplateV1(
+            template_id="source:adjoint:+1",
+            state_template_id="state:adjoint",
+            crossing="identity",
+            wavefunction_family="vector",
+            helicity=1,
+            spin_state=1,
+            flavour_flow=(21,),
+            quantum_number_flow=(("electric_charge", "0"),),
+            lc_color_seed=LCColorSourceSeedV1(
+                operation="singleton",
+                output_shape_kind="adjoint-segment",
+                component_kind="adjoint-segment",
+                component_role="active",
+                proof_digest=_EXPRESSION_C,
+            ),
+            wavefunction_expression_digest=_EXPRESSION_B,
+            evaluator_resolver_key="evaluator:source:adjoint",
+        ),
+        SourceTemplateV1(
+            template_id="source:matter:+1",
+            state_template_id="state:matter",
+            crossing="identity",
+            wavefunction_family="fermion",
+            helicity=1,
+            spin_state=1,
+            flavour_flow=(1,),
+            quantum_number_flow=(("electric_charge", "-1/3"),),
+            lc_color_seed=LCColorSourceSeedV1(
+                operation="singleton",
+                output_shape_kind="fundamental-open-string",
+                component_kind="open-string",
+                component_role="active",
+                proof_digest=_PREDICATE,
+            ),
+            wavefunction_expression_digest=_EXPRESSION_A,
+            evaluator_resolver_key="evaluator:source:matter",
+            mass_parameter_id="parameter:mass",
+        ),
+    )
+
+
+def _flow_template() -> QuantumFlowTemplateV1:
+    return QuantumFlowTemplateV1(
+        template_id="flow:matter-adjoint-to-matter",
+        input_state_template_ids=("state:matter", "state:adjoint"),
+        input_spin_states=(1, 1),
+        input_flavour_flows=((1,), (21,)),
+        input_quantum_number_flows=(
+            (("electric_charge", "-1/3"),),
+            (("electric_charge", "0"),),
+        ),
+        flavour_flow_operation="append-left-result",
+        quantum_number_flow_operation="particle-static-result",
+        coupling_orders=(("QCD", 1),),
+        result_state_template_id="state:matter",
+        result_spin_state=1,
+        result_flavour_flow=(1, 9000001),
+        result_quantum_number_flow=(("electric_charge", "-1/3"),),
+        exact_coupling=ExactComplexRationalV1.one(),
+        predicate_digest=_PREDICATE,
+    )
+
+
+def _transition() -> TransitionTemplateV1:
+    return TransitionTemplateV1(
+        template_id="transition:matter-adjoint-to-matter",
+        input_state_template_ids=("state:matter", "state:adjoint"),
+        result_state_template_id="state:matter",
+        quantum_flow_template_id="flow:matter-adjoint-to-matter",
+        evaluator_resolver_key="evaluator:vertex:matter-adjoint",
+        canonical_input_order=(0, 1),
+        momentum_convention=("incoming-left", "incoming-right"),
+        coupling_parameter_ids=("parameter:coupling",),
+        coupling_orders=(("QCD", 1),),
+        color_contraction_template_id="color:matter-adjoint",
+        binding_coupling=ExactComplexRationalV1.one(),
+        exact_factor=ExactComplexRationalV1.one(),
+        output_factor_source="none",
+        equivalence_class="ordered-matter-adjoint",
+        input_exchange_factor=None,
+        output_projection="weyl-chiral:+1",
+    )
+
+
+def _contact_orbit_records() -> tuple[
+    tuple[ContactOrbitCertificateV1, ...],
+    tuple[ContactOrbitStepV1, ...],
+]:
+    certificates = (
+        ContactOrbitCertificateV1(
+            template_id="contact-orbit-certificate:scalar:0",
+            algorithm="compiler-certified-contact-orbit",
+            algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+            term_id=0,
+            vertex="V_scalar_0",
+            particles=("s", "s", "s", "s"),
+            evaluator_class=("constant-scalar-literal-singlet-self-conjugate-boson"),
+            physical_leg_equivalence_classes=(0, 0, 0, 0),
+            reconstruction_factor=ExactComplexRationalV1.one(),
+        ),
+        ContactOrbitCertificateV1(
+            template_id="contact-orbit-certificate:scalar:1",
+            algorithm="compiler-certified-contact-orbit",
+            algorithm_version=CONTACT_ORBIT_ALGORITHM_VERSION,
+            term_id=1,
+            vertex="V_scalar_1",
+            particles=("s", "s", "t", "u"),
+            evaluator_class=("constant-scalar-literal-singlet-self-conjugate-boson"),
+            physical_leg_equivalence_classes=(0, 0, 1, 2),
+            reconstruction_factor=ExactComplexRationalV1.one(),
+        ),
+    )
+    steps = (
+        ContactOrbitStepV1(
+            template_id="contact-orbit-step:scalar:partial",
+            certificate_template_id=certificates[0].template_id,
+            stage="partial",
+            result_leg=2,
+            left_covered_legs=(0,),
+            right_covered_legs=(1,),
+            source_particle_legs=(0, 1, -1),
+            reconstruction_factor=ExactComplexRationalV1.one(),
+        ),
+        ContactOrbitStepV1(
+            template_id="contact-orbit-step:scalar:final",
+            certificate_template_id=certificates[1].template_id,
+            stage="final",
+            result_leg=3,
+            left_covered_legs=(0, 1),
+            right_covered_legs=(2,),
+            source_particle_legs=(-1, 2, 3),
+            reconstruction_factor=ExactComplexRationalV1.one(),
+        ),
+    )
+    return certificates, steps
+
+
+def _contact_orbit_catalog(
+    *, reverse_records: bool = False
+) -> RecurrenceTemplateCatalog:
+    certificates, steps = _contact_orbit_records()
+    bound_steps = tuple(sorted(steps, key=lambda item: item.template_id))
+    transition = replace(
+        _transition(),
+        contact_orbit_step_template_ids=tuple(step.template_id for step in bound_steps),
+        contact_orbit_step_semantic_digests=tuple(
+            step.semantic_digest for step in bound_steps
+        ),
+        semantic_digest="",
+    )
+    if reverse_records:
+        certificates = tuple(reversed(certificates))
+        steps = tuple(reversed(steps))
+    return _catalog(
+        contact_orbit_certificates=certificates,
+        contact_orbit_steps=steps,
+        transitions=(transition,),
+    )
+
+
+def _propagator() -> PropagatorTemplateV1:
+    return PropagatorTemplateV1(
+        template_id="propagator:matter",
+        state_template_id="state:matter",
+        applies_propagator=True,
+        evaluator_resolver_key="evaluator:propagator:matter",
+        numerator_expression_digest=_EXPRESSION_B,
+        denominator_expression_digest=_EXPRESSION_C,
+        mass_parameter_id="parameter:mass",
+        width_parameter_id=None,
+        gauge=None,
+        linearity_proof_template_id="proof:matter-linearity",
+    )
+
+
+def _identity_propagator() -> PropagatorTemplateV1:
+    return PropagatorTemplateV1(
+        template_id="propagator:adjoint:identity",
+        state_template_id="state:adjoint",
+        applies_propagator=False,
+        evaluator_resolver_key=None,
+        numerator_expression_digest=None,
+        denominator_expression_digest=None,
+        mass_parameter_id=None,
+        width_parameter_id=None,
+        gauge=None,
+        linearity_proof_template_id=None,
+    )
+
+
+def _closure() -> ClosureTemplateV1:
+    return ClosureTemplateV1(
+        template_id="closure:matter-pair",
+        input_state_template_ids=("state:matter", "state:adjoint"),
+        result_state_template_id="state:matter",
+        evaluator_resolver_key="evaluator:closure:matter-pair",
+        canonical_input_order=(0, 1),
+        coupling_parameter_ids=(),
+        coupling_orders=(("QCD", 1),),
+        eligible_quantum_flow_template_ids=("flow:matter-adjoint-to-matter",),
+        color_contraction_template_id="color:matter-adjoint",
+        binding_coupling=ExactComplexRationalV1.one(),
+        exact_factor=ExactComplexRationalV1.one(),
+        output_factor_source="none",
+        equivalence_class="ordered-matter-pair",
+        input_exchange_factor=None,
+        projection="scalar",
+    )
+
+
+def _state_input_layout(*state_ids: str) -> tuple[str, ...]:
+    dimensions = {"state:adjoint": 4, "state:matter": 2}
+    return tuple(
+        f"state:{state_id}:{component}"
+        for state_id in state_ids
+        for component in range(dimensions[state_id])
+    )
+
+
+def _evaluator_bindings() -> tuple[EvaluatorBindingV1, ...]:
+    return (
+        EvaluatorBindingV1(
+            resolver_key="evaluator:closure:matter-pair",
+            prepared_kernel_id=4,
+            contract_kind="closure",
+            callable_signature=_CALLABLE_E,
+            input_state_template_ids=("state:matter", "state:adjoint"),
+            output_state_template_id=None,
+            input_layout=_state_input_layout("state:matter", "state:adjoint"),
+            output_layout=("scalar",),
+            exact_expression_digests=(_EXPRESSION_C,),
+            semantic_template_ids=("closure:matter-pair",),
+        ),
+        EvaluatorBindingV1(
+            resolver_key="evaluator:propagator:matter",
+            prepared_kernel_id=3,
+            contract_kind="propagator",
+            callable_signature=_CALLABLE_D,
+            input_state_template_ids=("state:matter",),
+            output_state_template_id="state:matter",
+            input_layout=_state_input_layout("state:matter"),
+            output_layout=("spin0", "spin1"),
+            exact_expression_digests=(_EXPRESSION_A, _EXPRESSION_B),
+            semantic_template_ids=("propagator:matter",),
+        ),
+        EvaluatorBindingV1(
+            resolver_key="evaluator:source:adjoint",
+            prepared_kernel_id=1,
+            contract_kind="source",
+            callable_signature=_CALLABLE_B,
+            input_state_template_ids=(),
+            output_state_template_id="state:adjoint",
+            input_layout=("momentum:E",),
+            output_layout=("mu0", "mu1", "mu2", "mu3"),
+            exact_expression_digests=(
+                _EXPRESSION_A,
+                _EXPRESSION_A,
+                _EXPRESSION_A,
+                _EXPRESSION_A,
+            ),
+            semantic_template_ids=("source:adjoint:+1",),
+        ),
+        EvaluatorBindingV1(
+            resolver_key="evaluator:source:matter",
+            prepared_kernel_id=0,
+            contract_kind="source",
+            callable_signature=_CALLABLE_A,
+            input_state_template_ids=(),
+            output_state_template_id="state:matter",
+            input_layout=("momentum:E", "parameter:mass"),
+            output_layout=("spin0", "spin1"),
+            exact_expression_digests=(_EXPRESSION_A, _EXPRESSION_B),
+            semantic_template_ids=("source:matter:+1",),
+        ),
+        EvaluatorBindingV1(
+            resolver_key="evaluator:vertex:matter-adjoint",
+            prepared_kernel_id=2,
+            contract_kind="vertex",
+            callable_signature=_CALLABLE_C,
+            input_state_template_ids=("state:matter", "state:adjoint"),
+            output_state_template_id="state:matter",
+            input_layout=(
+                *_state_input_layout("state:matter", "state:adjoint"),
+                "parameter:coupling:real",
+                "parameter:coupling:imag",
+            ),
+            output_layout=("spin0", "spin1"),
+            exact_expression_digests=(_EXPRESSION_B, _EXPRESSION_C),
+            semantic_template_ids=("transition:matter-adjoint-to-matter",),
+        ),
+    )
+
+
+def _catalog(**overrides: object) -> RecurrenceTemplateCatalog:
+    values: dict[str, object] = {
+        "compiled_model_digest": _COMPILED_MODEL_DIGEST,
+        "prepared_kernel_pack_digest": _PREPARED_PACK_DIGEST,
+        "parameters": _parameter_templates(),
+        "current_states": _state_templates(),
+        "sources": _source_templates(),
+        "quantum_flows": (_flow_template(),),
+        "transitions": (_transition(),),
+        "propagators": (_identity_propagator(), _propagator()),
+        "closures": (_closure(),),
+        "color_contractions": (_color_template(),),
+        "symmetry_proofs": (_proof(),),
+        "evaluator_bindings": _evaluator_bindings(),
+    }
+    values.update(overrides)
+    return RecurrenceTemplateCatalog.create(**values)  # type: ignore[arg-type]
+
+
+def _mutated_projected_input(
+    table_name: str,
+    column_name: str,
+    value: int,
+    *,
+    row: int = 0,
+    catalog: RecurrenceTemplateCatalog | None = None,
+) -> RecurrenceTemplateInputV1:
+    projected = build_recurrence_template_input_v1(
+        _catalog() if catalog is None else catalog
+    )
+    tables = list(projected.tables)
+    table_index = next(
+        index for index, table in enumerate(tables) if table.name == table_name
+    )
+    table = tables[table_index]
+    columns = list(table.columns)
+    column_index = next(
+        index for index, column in enumerate(columns) if column.name == column_name
+    )
+    values = np.array(columns[column_index].values, copy=True, order="C")
+    values[row] = value
+    values.flags.writeable = False
+    columns[column_index] = RecurrenceColumn(
+        name=columns[column_index].name,
+        values=values,
+    )
+    tables[table_index] = replace(table, columns=tuple(columns))
+    return RecurrenceTemplateInputV1(
+        abi=projected.abi,
+        catalog_digest=projected.catalog_digest,
+        compiled_model_digest=projected.compiled_model_digest,
+        prepared_kernel_pack_digest=projected.prepared_kernel_pack_digest,
+        tables=tuple(tables),
+    )
+
+
+def test_private_table_adopts_owned_columns_and_copies_views() -> None:
+    owned = np.arange(4, dtype=np.dtype("<u4"))
+    adopted = template_columnar._table("owned", {"value": owned})
+
+    assert adopted.column("value") is owned
+    assert not owned.flags.writeable
+
+    backing = np.arange(8, dtype=np.dtype("<u4"))
+    view = backing[::2]
+    copied = template_columnar._table("view", {"value": view})
+    frozen = copied.column("value")
+
+    assert frozen is not view
+    assert frozen.flags.owndata
+    assert frozen.flags.c_contiguous
+    assert not frozen.flags.writeable
+    assert np.array_equal(frozen, view)
+
+
+def test_binary64_conversion_is_exact_and_distinguishes_sub_ulp_terms() -> None:
+    tenth = ExactComplexRationalV1.from_binary64(0.1)
+    assert tenth.real == Fraction(3602879701896397, 36028797018963968)
+    assert tenth.imag == 0
+
+    one = ExactComplexRationalV1.one()
+    one_plus_sub_ulp = ExactComplexRationalV1.from_fractions(
+        Fraction(1, 1) + Fraction(1, 2**54)
+    )
+    assert one != one_plus_sub_ulp
+    assert one_plus_sub_ulp.real == Fraction(2**54 + 1, 2**54)
+
+
+@pytest.mark.parametrize(
+    "arguments",
+    [
+        (2, 4, 0, 1),
+        (0, 2, 0, 1),
+        (1, -2, 0, 1),
+        (1, 2, 0, 0),
+    ],
+)
+def test_exact_rational_rejects_noncanonical_fractions(
+    arguments: tuple[int, int, int, int],
+) -> None:
+    with pytest.raises(RecurrenceTemplateError):
+        ExactComplexRationalV1(*arguments)
+
+
+def test_exact_rational_json_requires_canonical_decimal_integers() -> None:
+    payload = ExactComplexRationalV1.one().to_dict()
+    payload["real_numerator"] = "+1"
+    with pytest.raises(RecurrenceTemplateError, match=r"canonically|decimal"):
+        ExactComplexRationalV1.from_dict(payload)
+
+
+def test_catalog_round_trip_is_canonical_and_content_addressed() -> None:
+    catalog = _catalog()
+    loaded = RecurrenceTemplateCatalog.from_dict(json.loads(catalog.canonical_json))
+
+    assert loaded == catalog
+    assert loaded.canonical_json == catalog.canonical_json
+    assert loaded.catalog_digest == catalog.catalog_digest
+    assert catalog.current_states[0].template_id == "state:adjoint"
+    with pytest.raises(FrozenInstanceError):
+        catalog.current_states[0].dimension = 3  # type: ignore[misc]
+
+
+def test_contact_orbit_records_round_trip_and_ignore_input_row_order() -> None:
+    catalog = _contact_orbit_catalog()
+    reordered = _contact_orbit_catalog(reverse_records=True)
+    restored = RecurrenceTemplateCatalog.from_dict(catalog.to_dict())
+
+    assert restored == catalog
+    assert reordered == catalog
+    assert reordered.canonical_json == catalog.canonical_json
+    assert reordered.catalog_digest == catalog.catalog_digest
+    assert restored.transitions[0].contact_orbit_step_template_ids == (
+        "contact-orbit-step:scalar:final",
+        "contact-orbit-step:scalar:partial",
+    )
+    assert restored.transitions[0].contact_orbit_step_semantic_digests == (
+        restored.contact_orbit_steps[0].semantic_digest,
+        restored.contact_orbit_steps[1].semantic_digest,
+    )
+
+
+def test_contact_orbit_semantic_tampering_fails_closed() -> None:
+    certificate, steps = _contact_orbit_records()
+    with pytest.raises(RecurrenceTemplateError, match="stale semantic digest"):
+        replace(certificate[0], term_id=17)
+
+    with pytest.raises(RecurrenceTemplateError, match="not canonical"):
+        replace(
+            certificate[0],
+            physical_leg_equivalence_classes=(0, 1, 2, 3),
+            semantic_digest="",
+        )
+
+    with pytest.raises(RecurrenceTemplateError, match="partial step lineage"):
+        replace(steps[0], source_particle_legs=(1, 0, -1), semantic_digest="")
+    with pytest.raises(RecurrenceTemplateError, match="final step lineage"):
+        replace(steps[1], left_covered_legs=(0,), semantic_digest="")
+
+
+def test_contact_orbit_columnar_contract_rejects_transition_digest_tampering() -> None:
+    catalog = _contact_orbit_catalog()
+    projected = build_recurrence_template_input_v1(catalog)
+    tables = {table.name: table for table in projected.tables}
+
+    assert tables["contact_orbit_certificates"].row_count == 2
+    assert tables["contact_orbit_steps"].row_count == 2
+    assert {
+        "contact_orbit_step_sequence_id",
+        "contact_orbit_step_semantic_digest_sequence_id",
+    } <= {column.name for column in tables["transitions"].columns}
+    result = _rusticol._validate_recurrence_template_input_v1(
+        projected,
+        [0, 1, 2, 3, 4],
+    )
+    assert result["counts"]["contact_orbit_certificates"] == 2
+    assert result["counts"]["contact_orbit_steps"] == 2
+
+    transition_table = tables["transitions"]
+    sequence_id = int(
+        transition_table.column("contact_orbit_step_semantic_digest_sequence_id")[0]
+    )
+    sequence_ranges = tables["u32_sequence_ranges"]
+    start = int(sequence_ranges.column("start")[sequence_id])
+    different_valid_digest_id = int(transition_table.column("semantic_digest_id")[0])
+    mismatched = _mutated_projected_input(
+        "u32_sequence_values",
+        "value",
+        different_valid_digest_id,
+        row=start,
+        catalog=catalog,
+    )
+    with pytest.raises(ValueError, match="step digest does not match"):
+        _rusticol._validate_recurrence_template_input_v1(
+            mismatched,
+            [0, 1, 2, 3, 4],
+        )
+
+
+def test_contact_orbit_native_certificate_contract_rejects_tampering() -> None:
+    catalog = _contact_orbit_catalog()
+    projected = build_recurrence_template_input_v1(catalog)
+    tables = {table.name: table for table in projected.tables}
+    certificates = tables["contact_orbit_certificates"]
+    cases = (
+        (
+            _rusticol.CompatibilityError,
+            "algorithm_string_id",
+            int(certificates.column("evaluator_class_string_id")[0]),
+            "contact-orbit certificate algorithm",
+        ),
+        (
+            _rusticol.CompatibilityError,
+            "evaluator_class_string_id",
+            int(certificates.column("algorithm_string_id")[0]),
+            "contact-orbit evaluator class",
+        ),
+        (
+            ValueError,
+            "reconstruction_factor_id",
+            int(tables["parameters"].column("default_factor_id")[0]),
+            "reconstruction factor is not one",
+        ),
+    )
+    for error_type, column_name, value, message in cases:
+        tampered = _mutated_projected_input(
+            "contact_orbit_certificates",
+            column_name,
+            value,
+            catalog=catalog,
+        )
+        with pytest.raises(error_type, match=message):
+            _rusticol._validate_recurrence_template_input_v1(
+                tampered,
+                [0, 1, 2, 3, 4],
+            )
+
+
+def test_contact_orbit_native_certificate_rows_reject_reordering() -> None:
+    projected = build_recurrence_template_input_v1(_contact_orbit_catalog())
+    tables = list(projected.tables)
+    table_index = next(
+        index
+        for index, table in enumerate(tables)
+        if table.name == "contact_orbit_certificates"
+    )
+    table = tables[table_index]
+    reversed_columns = []
+    for column in table.columns:
+        values = np.ascontiguousarray(column.values[::-1])
+        values.flags.writeable = False
+        reversed_columns.append(RecurrenceColumn(name=column.name, values=values))
+    columns = tuple(reversed_columns)
+    tables[table_index] = replace(table, columns=columns)
+    reordered = replace(projected, tables=tuple(tables))
+
+    with pytest.raises(
+        ValueError,
+        match="contact-orbit certificate row 0 has noncanonical id 1",
+    ):
+        _rusticol._validate_recurrence_template_input_v1(
+            reordered,
+            [0, 1, 2, 3, 4],
+        )
+
+
+def test_contact_orbit_native_step_lineage_tampering_fails_closed() -> None:
+    projected = build_recurrence_template_input_v1(_contact_orbit_catalog())
+    tables = list(projected.tables)
+    table_index = next(
+        index
+        for index, table in enumerate(tables)
+        if table.name == "contact_orbit_steps"
+    )
+    table = tables[table_index]
+    columns = list(table.columns)
+    stage_index = next(
+        index for index, column in enumerate(columns) if column.name == "stage"
+    )
+    values = np.array(columns[stage_index].values, copy=True, order="C")
+    values[0] = 0
+    values.flags.writeable = False
+    columns[stage_index] = RecurrenceColumn(name="stage", values=values)
+    tables[table_index] = replace(table, columns=tuple(columns))
+    tampered = replace(projected, tables=tuple(tables))
+
+    with pytest.raises(ValueError, match="partial step 0 has inconsistent lineage"):
+        _rusticol._validate_recurrence_template_input_v1(
+            tampered,
+            [0, 1, 2, 3, 4],
+        )
+
+
+def test_extended_recurrence_records_round_trip_exactly() -> None:
+    catalog = _catalog()
+    restored = RecurrenceTemplateCatalog.from_dict(catalog.to_dict())
+
+    assert restored.quantum_flows[0].input_flavour_flows == ((1,), (21,))
+    assert restored.quantum_flows[0].input_quantum_number_flows == (
+        (("electric_charge", "-1/3"),),
+        (("electric_charge", "0"),),
+    )
+    assert restored.quantum_flows[0].exact_coupling == ExactComplexRationalV1.one()
+    assert restored.quantum_flows[0].flavour_flow_operation == "append-left-result"
+    assert restored.quantum_flows[0].result_spin_state == 1
+    assert restored.sources[0].flavour_flow == (21,)
+    assert restored.sources[0].quantum_number_flow == (("electric_charge", "0"),)
+    assert restored.transitions[0].equivalence_class == "ordered-matter-adjoint"
+    assert restored.transitions[0].output_factor_source == "none"
+    assert restored.closures[0].equivalence_class == "ordered-matter-pair"
+    assert restored.closures[0].input_exchange_factor is None
+    assert restored.closures[0].eligible_quantum_flow_template_ids == (
+        "flow:matter-adjoint-to-matter",
+    )
+
+    payload = json.loads(catalog.canonical_json)
+    flow = payload["quantum_flows"][0]
+    assert flow["input_flavour_flows"] == [[1], [21]]
+    assert flow["flavour_flow_operation"] == "append-left-result"
+    assert flow["input_quantum_number_flows"][0] == [["electric_charge", "-1/3"]]
+
+
+@pytest.mark.parametrize(
+    ("record_name", "field", "value"),
+    [
+        ("quantum_flows", "exact_coupling", ExactComplexRationalV1.zero()),
+        ("transitions", "binding_coupling", ExactComplexRationalV1.zero()),
+        ("transitions", "output_factor_source", "coupling-real"),
+        ("transitions", "equivalence_class", "another-proof"),
+        (
+            "transitions",
+            "input_exchange_factor",
+            ExactComplexRationalV1.from_fractions(-1),
+        ),
+        ("closures", "binding_coupling", ExactComplexRationalV1.zero()),
+        ("closures", "output_factor_source", "coupling-imag"),
+        ("closures", "equivalence_class", "another-closure-proof"),
+        (
+            "closures",
+            "input_exchange_factor",
+            ExactComplexRationalV1.from_fractions(-1),
+        ),
+    ],
+)
+def test_extended_fields_affect_semantic_and_catalog_digests(
+    record_name: str,
+    field: str,
+    value: object,
+) -> None:
+    catalog = _catalog()
+    records = getattr(catalog, record_name)
+    updated = replace(records[0], **{field: value, "semantic_digest": ""})
+    changed = _catalog(**{record_name: (updated,)})
+
+    assert updated.semantic_digest != records[0].semantic_digest
+    assert changed.catalog_digest != catalog.catalog_digest
+
+
+def test_model_wide_columnar_projection_preserves_typed_contracts() -> None:
+    projected = build_recurrence_template_input_v1(_catalog())
+    tables = {table.name: table for table in projected.tables}
+
+    assert projected.canonical_digest == projected.digest
+    assert tables["flavour_flow_ranges"].row_count == 3
+    assert tables["quantum_number_flow_ranges"].row_count == 2
+    assert tables["quantum_flows"].row_count == 1
+    assert tables["transitions"].row_count == 1
+    assert tables["closures"].row_count == 1
+    assert tables["lc_color_transition_witnesses"].row_count == 1
+    assert "exact_coupling_factor_id" in {
+        column.name for column in tables["quantum_flows"].columns
+    }
+    assert "binding_coupling_factor_id" in {
+        column.name for column in tables["transitions"].columns
+    }
+    assert {"flavour_flow_id", "quantum_number_flow_id"} <= {
+        column.name for column in tables["sources"].columns
+    }
+    assert "result_spin_state" in {
+        column.name for column in tables["quantum_flows"].columns
+    }
+    assert "flavour_flow_operation_string_id" in {
+        column.name for column in tables["quantum_flows"].columns
+    }
+    assert "eligible_quantum_flow_sequence_id" in {
+        column.name for column in tables["closures"].columns
+    }
+    assert "lc_color_shape_string_id" in {
+        column.name for column in tables["current_states"].columns
+    }
+    assert {"witness_start", "witness_count"} <= {
+        column.name for column in tables["color_contractions"].columns
+    }
+
+
+def _runtime_helicity_catalog() -> RecurrenceTemplateCatalog:
+    states = _state_templates()
+    full_matter = replace(
+        states[1],
+        template_id="state:matter-full",
+        basis="dirac",
+        tensor_ordering=("spin0", "spin1", "spin2", "spin3"),
+        dimension=4,
+        chirality=0,
+        semantic_digest="",
+    )
+    one = ExactComplexRationalV1.one()
+    zero = ExactComplexRationalV1.zero()
+    contracts = (
+        RecurrenceRuntimeHelicityContractV1(
+            template_id="runtime-helicity:adjoint",
+            full_state_template_id="state:adjoint",
+            variants=(
+                RecurrenceRuntimeHelicityVariantV1(
+                    source_template_id="source:adjoint:+1",
+                    source_state_template_id="state:adjoint",
+                    embedding_source_components=(0, 1, 2, 3),
+                    embedding_factors=(one, one, one, one),
+                    projection_full_components=(0, 1, 2, 3),
+                    proof_digest=_EXPRESSION_A,
+                ),
+            ),
+            proof_algorithm="prepared-current-ordering-runtime-helicity-embedding-v1",
+            proof_digest=_EXPRESSION_B,
+        ),
+        RecurrenceRuntimeHelicityContractV1(
+            template_id="runtime-helicity:matter",
+            full_state_template_id="state:matter-full",
+            variants=(
+                RecurrenceRuntimeHelicityVariantV1(
+                    source_template_id="source:matter:+1",
+                    source_state_template_id="state:matter",
+                    embedding_source_components=(0, 1, None, None),
+                    embedding_factors=(one, one, zero, zero),
+                    projection_full_components=(0, 1),
+                    proof_digest=_EXPRESSION_C,
+                ),
+            ),
+            proof_algorithm="prepared-current-ordering-runtime-helicity-embedding-v1",
+            proof_digest=_PREDICATE,
+        ),
+    )
+    return _catalog(
+        current_states=(*states, full_matter),
+        runtime_helicity_contracts=contracts,
+    )
+
+
+def test_runtime_helicity_contract_round_trips_and_flattens() -> None:
+    catalog = _runtime_helicity_catalog()
+    restored = RecurrenceTemplateCatalog.from_dict(catalog.to_dict())
+    restored.require_complete_runtime_helicity_contracts()
+
+    assert restored == catalog
+    tables = {
+        table.name: table
+        for table in build_recurrence_template_input_v1(catalog).tables
+    }
+    assert tables["runtime_helicity_contracts"].row_count == 2
+    assert tables["runtime_helicity_variants"].row_count == 2
+    assert tables["runtime_helicity_embeddings"].row_count == 8
+    assert tables["runtime_helicity_projections"].row_count == 6
+
+
+def test_prepared_pack_digest_rebind_preserves_runtime_helicity_contracts() -> None:
+    from pyamplicol.models.prepared_compile import (
+        _rebind_recurrence_template_pack_digest,
+    )
+
+    catalog = _runtime_helicity_catalog()
+    rebound = _rebind_recurrence_template_pack_digest(catalog, "f" * 64)
+
+    assert rebound.header.prepared_kernel_pack_digest == "f" * 64
+    assert rebound.runtime_helicity_contracts == catalog.runtime_helicity_contracts
+
+
+def test_prepared_pack_digest_rebind_preserves_contact_orbit_records() -> None:
+    from pyamplicol.models.prepared_compile import (
+        _rebind_recurrence_template_pack_digest,
+    )
+
+    catalog = _contact_orbit_catalog()
+    rebound = _rebind_recurrence_template_pack_digest(catalog, "f" * 64)
+
+    assert rebound.header.prepared_kernel_pack_digest == "f" * 64
+    assert rebound.contact_orbit_certificates == catalog.contact_orbit_certificates
+    assert rebound.contact_orbit_steps == catalog.contact_orbit_steps
+    assert rebound.transitions == catalog.transitions
+
+
+def test_runtime_helicity_preflight_reports_uncertified_source() -> None:
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match=r"recurrence all-flow-union preflight.*source:adjoint",
+    ):
+        _catalog().require_complete_runtime_helicity_contracts()
+
+
+def test_runtime_helicity_embedding_must_be_exactly_invertible() -> None:
+    one = ExactComplexRationalV1.one()
+    zero = ExactComplexRationalV1.zero()
+    with pytest.raises(RecurrenceTemplateError, match="projection must invert"):
+        RecurrenceRuntimeHelicityVariantV1(
+            source_template_id="source:matter:+1",
+            source_state_template_id="state:matter",
+            embedding_source_components=(0, 1, None, None),
+            embedding_factors=(one, one, zero, zero),
+            projection_full_components=(1, 0),
+            proof_digest=_EXPRESSION_A,
+        )
+
+
+def test_native_builder_exposes_only_the_direct_arena_v2_entry_point() -> None:
+    assert callable(_rusticol._lower_recurrence_direct_v2)
+    assert not hasattr(_rusticol, "_validate_recurrence_builder_input_v1")
+
+
+@pytest.mark.parametrize("numerator", (1 << 127, -(1 << 127)))
+def test_model_wide_columnar_projection_rejects_i128_overflow(numerator: int) -> None:
+    transition = replace(
+        _transition(),
+        binding_coupling=ExactComplexRationalV1.from_fractions(numerator),
+        semantic_digest="",
+    )
+    catalog = _catalog(transitions=(transition,))
+
+    with pytest.raises(RecurrenceColumnarInputError, match=r"cannot cross.*i128"):
+        build_recurrence_template_input_v1(catalog)
+
+
+def test_model_wide_columnar_projection_rejects_fixed_width_overflow() -> None:
+    states = list(_state_templates())
+    states[0] = replace(states[0], particle_id=1 << 31, semantic_digest="")
+    catalog = _catalog(current_states=tuple(states))
+
+    with pytest.raises(
+        RecurrenceColumnarInputError,
+        match=r"current_states\.particle_id row 0.*does not fit <i4",
+    ):
+        build_recurrence_template_input_v1(catalog)
+
+
+def test_runtime_template_evaluator_binding_round_trips() -> None:
+    bindings = list(_evaluator_bindings())
+    source_index = next(
+        index
+        for index, binding in enumerate(bindings)
+        if binding.contract_kind == "source"
+    )
+    bindings[source_index] = replace(
+        bindings[source_index],
+        prepared_kernel_id=None,
+        callable_kind="rusticol-template",
+        runtime_template=(
+            f"rusticol.source-fill.vector.v1:"
+            f"{bindings[source_index].callable_signature[:24]}"
+        ),
+        semantic_digest="",
+    )
+
+    catalog = _catalog(evaluator_bindings=tuple(bindings))
+    restored = RecurrenceTemplateCatalog.from_dict(catalog.to_dict())
+    binding = restored.evaluator_bindings[source_index]
+    assert binding.callable_kind == "rusticol-template"
+    assert binding.runtime_template == (
+        f"rusticol.source-fill.vector.v1:{binding.callable_signature[:24]}"
+    )
+    assert binding.prepared_kernel_id is None
+
+
+def test_runtime_template_evaluator_binding_rejects_unregistered_contract() -> None:
+    binding = next(
+        item for item in _evaluator_bindings() if item.contract_kind == "source"
+    )
+
+    with pytest.raises(RecurrenceTemplateError, match="authenticated"):
+        replace(
+            binding,
+            prepared_kernel_id=None,
+            callable_kind="rusticol-template",
+            runtime_template="rusticol.source-fill.vector.v1:stale",
+            semantic_digest="",
+        )
+
+
+@pytest.mark.parametrize(
+    ("prepared_kernel_id", "callable_kind", "runtime_template"),
+    [
+        (None, "prepared-kernel", None),
+        (1, "rusticol-template", "rusticol.source-fill.vector.v1"),
+        (None, "rusticol-template", None),
+        (1, "prepared-kernel", "rusticol.source-fill.vector.v1"),
+    ],
+)
+def test_evaluator_binding_requires_exactly_one_callable_lane(
+    prepared_kernel_id: int | None,
+    callable_kind: EvaluatorCallableKind,
+    runtime_template: str | None,
+) -> None:
+    binding = _evaluator_bindings()[0]
+    with pytest.raises(RecurrenceTemplateError):
+        replace(
+            binding,
+            prepared_kernel_id=prepared_kernel_id,
+            callable_kind=callable_kind,
+            runtime_template=runtime_template,
+            semantic_digest="",
+        )
+
+
+def test_catalog_creation_sorts_records_deterministically() -> None:
+    forward = _catalog()
+    reverse = _catalog(
+        parameters=tuple(reversed(_parameter_templates())),
+        current_states=tuple(reversed(_state_templates())),
+        sources=tuple(reversed(_source_templates())),
+        evaluator_bindings=tuple(reversed(_evaluator_bindings())),
+    )
+    assert reverse.canonical_json == forward.canonical_json
+    assert reverse.catalog_digest == forward.catalog_digest
+
+
+def test_record_rejects_stale_semantic_digest() -> None:
+    source = _source_templates()[0]
+    with pytest.raises(RecurrenceTemplateError, match="stale semantic digest"):
+        replace(source, helicity=-1)
+
+
+def test_concrete_source_and_quantum_spins_reject_dynamic_union_sentinel() -> None:
+    sentinel = -(1 << 31)
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="source spin_state uses the reserved dynamic-union sentinel",
+    ):
+        replace(_source_templates()[0], spin_state=sentinel, semantic_digest="")
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="quantum-flow spin states uses the reserved dynamic-union sentinel",
+    ):
+        replace(
+            _flow_template(),
+            input_spin_states=(sentinel, 1),
+            semantic_digest="",
+        )
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="quantum-flow result spin state uses the reserved dynamic-union sentinel",
+    ):
+        replace(
+            _flow_template(),
+            result_spin_state=sentinel,
+            semantic_digest="",
+        )
+
+
+def test_catalog_rejects_stale_catalog_digest() -> None:
+    catalog = _catalog()
+    stale_header = replace(catalog.header, catalog_digest="f" * 64)
+    with pytest.raises(RecurrenceTemplateError, match=r"stale.*catalog digest"):
+        replace(catalog, header=stale_header)
+
+
+def test_catalog_rejects_duplicate_semantic_identity() -> None:
+    first = _parameter_templates()[0]
+    duplicate = replace(
+        first,
+        name="another.parameter",
+        semantic_digest="",
+    )
+    with pytest.raises(RecurrenceTemplateError, match="duplicate semantic identity"):
+        _catalog(parameters=(first, duplicate, _parameter_templates()[1]))
+
+
+def test_catalog_rejects_indirect_parameter_dependency_cycle() -> None:
+    parameters = _parameter_templates()
+    cyclic = (
+        replace(
+            parameters[0],
+            dependency_parameter_ids=(parameters[1].template_id,),
+            semantic_digest="",
+        ),
+        replace(
+            parameters[1],
+            dependency_parameter_ids=(parameters[0].template_id,),
+            semantic_digest="",
+        ),
+    )
+
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="parameter dependency graph contains a cycle",
+    ):
+        _catalog(parameters=cyclic)
+
+
+def test_catalog_rejects_duplicate_evaluator_resolver_key() -> None:
+    first = _evaluator_bindings()[0]
+    duplicate = replace(
+        first,
+        prepared_kernel_id=99,
+        callable_signature="c" * 64,
+        semantic_digest="",
+    )
+    with pytest.raises(RecurrenceTemplateError, match="resolver keys must be unique"):
+        _catalog(evaluator_bindings=(*_evaluator_bindings(), duplicate))
+
+
+def test_unknown_proof_algorithm_fails_closed() -> None:
+    with pytest.raises(RecurrenceTemplateError, match=r"unsupported.*algorithm"):
+        replace(
+            _proof(),
+            proof_algorithm="trust-the-model-name-v1",
+            semantic_digest="",
+        )
+
+
+def test_catalog_rejects_unknown_state_reference() -> None:
+    transition = replace(
+        _transition(),
+        result_state_template_id="state:missing",
+        semantic_digest="",
+    )
+    with pytest.raises(RecurrenceTemplateError, match="unknown 'state:missing'"):
+        _catalog(transitions=(transition,))
+
+
+def test_catalog_rejects_transition_quantum_flow_coupling_mismatch() -> None:
+    transition = replace(
+        _transition(),
+        coupling_orders=(),
+        semantic_digest="",
+    )
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="transition and quantum-flow state/coupling contracts",
+    ):
+        _catalog(transitions=(transition,))
+
+
+def test_catalog_rejects_prepared_closure_without_quantum_flow_witness() -> None:
+    closure = replace(
+        _closure(),
+        eligible_quantum_flow_template_ids=(),
+        semantic_digest="",
+    )
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="prepared closure must carry at least one eligible quantum-flow",
+    ):
+        _catalog(closures=(closure,))
+
+
+@pytest.mark.parametrize(
+    ("table_name", "column_name", "value", "message"),
+    [
+        (
+            "quantum_flows",
+            "flavour_flow_operation_string_id",
+            0,
+            "unsupported flavour operation",
+        ),
+        (
+            "transitions",
+            "coupling_order_set_id",
+            0,
+            "state/coupling contracts do not match",
+        ),
+        (
+            "closures",
+            "eligible_quantum_flow_sequence_id",
+            0,
+            "prepared closure 0 has no eligible quantum-flow witness",
+        ),
+        (
+            "closures",
+            "result_state_template_id",
+            0,
+            "different result-state contracts",
+        ),
+        (
+            "evaluator_bindings",
+            "callable_kind",
+            1,
+            "direct Rusticol closure 0 carries prepared quantum-flow witnesses",
+        ),
+        (
+            "color_contractions",
+            "witness_count",
+            0,
+            "LC color transition witnesses",
+        ),
+        (
+            "lc_color_transition_witnesses",
+            "component_operation",
+            6,
+            "LC color witness operation 6 is not supported",
+        ),
+        (
+            "lc_color_transition_witnesses",
+            "result_component_kind",
+            255,
+            "LC color join witness requires component kind and role",
+        ),
+    ],
+)
+def test_native_catalog_validation_rejects_mutated_dynamic_contracts(
+    table_name: str,
+    column_name: str,
+    value: int,
+    message: str,
+) -> None:
+    projected = _mutated_projected_input(table_name, column_name, value)
+    with pytest.raises(ValueError, match=message):
+        _rusticol._validate_recurrence_template_input_v1(
+            projected,
+            [0, 1, 2, 3, 4],
+        )
+
+
+def test_catalog_rejects_closure_quantum_flow_state_mismatch() -> None:
+    closure = replace(
+        _closure(),
+        input_state_template_ids=("state:matter", "state:matter"),
+        semantic_digest="",
+    )
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="closure and eligible quantum-flow input/result/coupling contracts",
+    ):
+        _catalog(closures=(closure,))
+
+
+def test_catalog_rejects_closure_quantum_flow_result_state_mismatch() -> None:
+    closure = replace(
+        _closure(),
+        result_state_template_id="state:adjoint",
+        semantic_digest="",
+    )
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="closure and eligible quantum-flow input/result/coupling contracts",
+    ):
+        _catalog(closures=(closure,))
+
+
+def test_catalog_rejects_closure_quantum_flow_coupling_mismatch() -> None:
+    closure = replace(
+        _closure(),
+        coupling_orders=(),
+        semantic_digest="",
+    )
+    with pytest.raises(
+        RecurrenceTemplateError,
+        match="closure and eligible quantum-flow input/result/coupling contracts",
+    ):
+        _catalog(closures=(closure,))
+
+
+def test_catalog_rejects_malformed_evaluator_state_contract() -> None:
+    bindings = list(_evaluator_bindings())
+    index = next(
+        index
+        for index, binding in enumerate(bindings)
+        if binding.resolver_key == "evaluator:vertex:matter-adjoint"
+    )
+    bindings[index] = replace(
+        bindings[index],
+        input_state_template_ids=("state:adjoint", "state:matter"),
+        semantic_digest="",
+    )
+    with pytest.raises(RecurrenceTemplateError, match="input states do not match"):
+        _catalog(evaluator_bindings=tuple(bindings))
+
+
+def test_catalog_rejects_malformed_evaluator_output_dimension() -> None:
+    bindings = list(_evaluator_bindings())
+    index = next(
+        index
+        for index, binding in enumerate(bindings)
+        if binding.resolver_key == "evaluator:source:matter"
+    )
+    bindings[index] = replace(
+        bindings[index],
+        output_layout=("spin0",),
+        exact_expression_digests=(_EXPRESSION_A,),
+        semantic_digest="",
+    )
+    with pytest.raises(RecurrenceTemplateError, match="output layout"):
+        _catalog(evaluator_bindings=tuple(bindings))
+
+
+def test_catalog_loader_rejects_unknown_fields() -> None:
+    payload = _catalog().to_dict()
+    payload["model_name"] = "forbidden-model-specific-dispatch"
+    with pytest.raises(RecurrenceTemplateError, match="unknown=model_name"):
+        RecurrenceTemplateCatalog.from_dict(payload)
+
+
+def test_catalog_loader_rejects_stale_nested_record_digest() -> None:
+    payload = _catalog().to_dict()
+    payload["sources"][0]["helicity"] = -1  # type: ignore[index]
+    with pytest.raises(RecurrenceTemplateError, match="stale semantic digest"):
+        RecurrenceTemplateCatalog.from_dict(payload)
+
+
+def test_contract_is_model_generic() -> None:
+    catalog = _catalog()
+    serialized = catalog.canonical_json
+    assert "built-in-sm" not in serialized
+    assert "ufo" not in serialized.lower()
+    assert "example:species:matter" in serialized
diff --git a/pyamplicol/tests/unit/test_recurrence_template_native.py b/pyamplicol/tests/unit/test_recurrence_template_native.py
new file mode 100644
index 0000000000..c82ed3db88
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_template_native.py
@@ -0,0 +1,124 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from pyamplicol import _rusticol
+from pyamplicol.generation.recurrence_columnar import RecurrenceColumn
+from pyamplicol.generation.recurrence_template_columnar import (
+    build_recurrence_template_input_v1,
+)
+from pyamplicol.models.recurrence_template import (
+    EvaluatorBindingV1,
+    ParameterTemplateV1,
+    RecurrenceTemplateCatalog,
+)
+
+_COMPILED_MODEL_DIGEST = "a" * 64
+_PREPARED_PACK_DIGEST = "b" * 64
+_EXPRESSION_DIGEST = "c" * 64
+_CALLABLE_SIGNATURE = "d" * 64
+_PREPARED_KERNEL_ID = 7
+
+
+def _catalog() -> RecurrenceTemplateCatalog:
+    parameter = ParameterTemplateV1(
+        template_id="parameter:derived",
+        name="derived",
+        parameter_kind="derived",
+        value_type="real",
+        mutable=False,
+        default_value=None,
+        exact_expression_digest=_EXPRESSION_DIGEST,
+        dependency_parameter_ids=(),
+        prepared_parameter_id=0,
+    )
+    binding = EvaluatorBindingV1(
+        resolver_key="evaluator:model-parameter:derived",
+        prepared_kernel_id=_PREPARED_KERNEL_ID,
+        contract_kind="model-parameter",
+        callable_signature=_CALLABLE_SIGNATURE,
+        input_state_template_ids=(),
+        output_state_template_id=None,
+        input_layout=("model-parameter-input:none",),
+        output_layout=("derived",),
+        exact_expression_digests=(_EXPRESSION_DIGEST,),
+        semantic_template_ids=(parameter.template_id,),
+    )
+    return RecurrenceTemplateCatalog.create(
+        compiled_model_digest=_COMPILED_MODEL_DIGEST,
+        prepared_kernel_pack_digest=_PREPARED_PACK_DIGEST,
+        parameters=(parameter,),
+        evaluator_bindings=(binding,),
+    )
+
+
+def _input_with_stale_digest() -> SimpleNamespace:
+    projected = build_recurrence_template_input_v1(_catalog())
+    declared_digest = projected.digest
+    tables = list(projected.tables)
+    header_index = next(
+        index for index, table in enumerate(tables) if table.name == "catalog_header"
+    )
+    header = tables[header_index]
+    columns = list(header.columns)
+    schema_index = next(
+        index for index, column in enumerate(columns) if column.name == "schema_version"
+    )
+    values = np.array(columns[schema_index].values, copy=True, order="C")
+    values[0] += 1
+    values.flags.writeable = False
+    columns[schema_index] = RecurrenceColumn(
+        name=columns[schema_index].name,
+        values=values,
+    )
+    tables[header_index] = replace(header, columns=tuple(columns))
+    return SimpleNamespace(
+        abi=projected.abi,
+        catalog_digest=projected.catalog_digest,
+        compiled_model_digest=projected.compiled_model_digest,
+        prepared_kernel_pack_digest=projected.prepared_kernel_pack_digest,
+        tables=tuple(tables),
+        digest=declared_digest,
+        canonical_digest=declared_digest,
+    )
+
+
+def test_native_recurrence_template_validation_authenticates_kernel_inventory() -> None:
+    projected = build_recurrence_template_input_v1(_catalog())
+
+    result = _rusticol._validate_recurrence_template_input_v1(
+        projected,
+        [_PREPARED_KERNEL_ID],
+    )
+
+    assert result["validation_status"] == "validated"
+    assert result["template_input_sha256"] == projected.digest
+    assert result["prepared_kernel_inventory_verified"] is True
+    assert result["prepared_kernel_inventory_count"] == 1
+    assert result["counts"]["prepared_kernels"] == 1
+    assert result["counts"]["referenced_prepared_kernels"] == 1
+
+
+def test_native_recurrence_template_validation_rejects_stale_digest() -> None:
+    with pytest.raises(ValueError, match="template input digest mismatch"):
+        _rusticol._validate_recurrence_template_input_v1(
+            _input_with_stale_digest(),
+            [_PREPARED_KERNEL_ID],
+        )
+
+
+def test_native_recurrence_template_validation_rejects_missing_kernel() -> None:
+    projected = build_recurrence_template_input_v1(_catalog())
+
+    with pytest.raises(
+        ValueError,
+        match=(
+            r"prepared-kernel IDs absent from the authenticated pack inventory: \[7\]"
+        ),
+    ):
+        _rusticol._validate_recurrence_template_input_v1(projected, [0])
diff --git a/pyamplicol/tests/unit/test_recurrence_z6g_benchmark.py b/pyamplicol/tests/unit/test_recurrence_z6g_benchmark.py
new file mode 100644
index 0000000000..fea6e6337a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_recurrence_z6g_benchmark.py
@@ -0,0 +1,4174 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import importlib.util
+import json
+import math
+import statistics
+import sys
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+from typing import Any
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools" / "developer" / "recurrence_z6g_benchmark.py"
+SPEC = importlib.util.spec_from_file_location("recurrence_z6g_benchmark", SCRIPT)
+assert SPEC is not None and SPEC.loader is not None
+benchmark = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(benchmark)
+
+
+def _arguments(*values: str) -> object:
+    arguments = benchmark.parser().parse_args(list(values))
+    arguments.modes = benchmark._normalize_modes(arguments)
+    arguments.batch_size = benchmark._normalize_batch_sizes(arguments)
+    return arguments
+
+
+def test_modes_default_to_all_lanes_and_preserve_requested_order() -> None:
+    default = benchmark.parser().parse_args([])
+    assert benchmark._normalize_modes(default) == [
+        "compiled",
+        "eager",
+        "recurrence",
+    ]
+
+    selected = benchmark.parser().parse_args(
+        ["--mode", "recurrence", "--mode", "eager"]
+    )
+    assert benchmark._normalize_modes(selected) == ["recurrence", "eager"]
+
+
+def test_modes_reject_duplicates_and_old_new_flag_mix() -> None:
+    duplicate = benchmark.parser().parse_args(
+        ["--mode", "compiled", "--mode", "compiled"]
+    )
+    with pytest.raises(benchmark.HarnessError, match="must be unique"):
+        benchmark._normalize_modes(duplicate)
+
+    mixed = benchmark.parser().parse_args(
+        ["--mode", "compiled", "--only-mode", "recurrence"]
+    )
+    with pytest.raises(benchmark.HarnessError, match="cannot be combined"):
+        benchmark._normalize_modes(mixed)
+
+
+def test_default_batches_cover_milestone_zero_and_explicit_values_replace() -> None:
+    assert benchmark.DEFAULT_BATCH_SIZES == (1, 128, 1024)
+    defaults = benchmark.parser().parse_args([])
+    assert defaults.minimum_samples == 7
+    assert defaults.subprocess_samples == 7
+    assert benchmark._normalize_batch_sizes(defaults) == [
+        1,
+        128,
+        1024,
+    ]
+    assert benchmark._normalize_batch_sizes(
+        benchmark.parser().parse_args(["--batch-size", "8", "--batch-size", "32"])
+    ) == [8, 32]
+
+    duplicate = benchmark.parser().parse_args(
+        ["--batch-size", "8", "--batch-size", "8"]
+    )
+    with pytest.raises(benchmark.HarnessError, match="must be unique"):
+        benchmark._normalize_batch_sizes(duplicate)
+
+
+def test_paired_migration_capture_requires_exactly_two_warmups() -> None:
+    arguments = _arguments(
+        "--paired-profile-coordination-dir",
+        "coordination",
+        "--paired-profile-role",
+        "candidate",
+        "--paired-profile-session-id",
+        "session",
+        "--warmup-runs",
+        "3",
+    )
+
+    with pytest.raises(benchmark.HarnessError, match="exactly two warmup"):
+        benchmark.run(arguments)
+
+
+def test_migration_process_request_expands_without_changing_default_route() -> None:
+    default = benchmark.parser().parse_args([])
+    assert benchmark._selected_process(default) == "u u~ > Z g g g g g g"
+    assert benchmark._selected_process_name(default) == "uubar_Z_6g"
+    assert benchmark._authoritative_process_family(default)
+
+    migration = benchmark.parser().parse_args(
+        ["--process-expression", "d d~ > z + 6*g"]
+    )
+    assert benchmark._selected_process(migration) == "d d~ > Z g g g g g g"
+    assert benchmark._selected_process_name(migration) == "ddbar_Z_6g"
+    assert benchmark._authoritative_process_family(migration)
+
+    custom = benchmark.parser().parse_args(["--process-expression", "g g > t t~"])
+    assert benchmark._selected_process_name(custom) == "custom_process"
+    assert not benchmark._authoritative_process_family(custom)
+
+
+def test_benchmark_source_root_can_select_an_immutable_external_checkout(
+    tmp_path: Path,
+) -> None:
+    assert (
+        benchmark._resolve_benchmark_source_root(str(ROOT), script_path=SCRIPT) == ROOT
+    )
+    with pytest.raises(RuntimeError, match="must be an absolute path"):
+        benchmark._resolve_benchmark_source_root(
+            "relative/checkout",
+            script_path=SCRIPT,
+        )
+    with pytest.raises(RuntimeError, match="not a pyAmpliCol source checkout"):
+        benchmark._resolve_benchmark_source_root(str(tmp_path), script_path=SCRIPT)
+
+
+def test_incomplete_capture_requires_explicit_diagnostic_success() -> None:
+    assert (
+        benchmark._result_exit_code(
+            {"complete": True, "passes": True},
+            allow_diagnostic_incomplete_success=False,
+        )
+        == 0
+    )
+    assert (
+        benchmark._result_exit_code(
+            {"complete": True, "passes": False},
+            allow_diagnostic_incomplete_success=True,
+        )
+        == 1
+    )
+    assert (
+        benchmark._result_exit_code(
+            {"complete": False, "passes": None},
+            allow_diagnostic_incomplete_success=False,
+        )
+        == 1
+    )
+    assert (
+        benchmark._result_exit_code(
+            {"complete": False, "passes": None},
+            allow_diagnostic_incomplete_success=True,
+        )
+        == 0
+    )
+    assert (
+        benchmark._result_exit_code(
+            {"complete": False, "passes": True},
+            allow_diagnostic_incomplete_success=True,
+        )
+        == 1
+    )
+
+
+def _fixture(
+    *,
+    point_count: int = 2,
+    points_sha256: str = "b" * 64,
+    file_sha256: str = "c" * 64,
+) -> dict[str, object]:
+    return {
+        "point_count": point_count,
+        "points_sha256": points_sha256,
+        "file": {
+            "path": "/fixture.json",
+            "resolved_path": "/fixture.json",
+            "size_bytes": 123,
+            "sha256": file_sha256,
+        },
+    }
+
+
+def _resource_peak(
+    *,
+    self_peak_bytes: int = 1024,
+    maximum_child_peak_bytes: int = 0,
+) -> dict[str, object]:
+    return {
+        "source": "resource.getrusage",
+        "self_peak_bytes": self_peak_bytes,
+        "maximum_child_peak_bytes": maximum_child_peak_bytes,
+        "observed_lower_bound_bytes": max(
+            self_peak_bytes,
+            maximum_child_peak_bytes,
+        ),
+        "semantics": benchmark._RESOURCE_PEAK_SEMANTICS,
+    }
+
+
+def _artifact_semantic_identity(
+    *,
+    specialized_axes: tuple[str, ...] = (),
+    complete: bool = True,
+    model_name: str = "built-in-sm",
+    model_content_sha256: str = "c" * 64,
+    color_id: str = "flow:2,1",
+    color_word: tuple[int, ...] = (2, 1),
+    color_count: int = 1,
+    helicity_id: str = "h:-1,+1",
+    helicity_values: tuple[int, ...] = (-1, 1),
+    secondary_helicity_structural_zero: bool = False,
+) -> dict[str, object]:
+    color_ids = [
+        color_id,
+        *(f"flow:{index + 3},2,1" for index in range(color_count - 1)),
+    ]
+    opposite_helicity_values = tuple(-value for value in helicity_values)
+    opposite_helicity_id = "h:" + ",".join(
+        f"{value:+d}" for value in opposite_helicity_values
+    )
+    helicity_ids = [helicity_id, opposite_helicity_id]
+    color_entries = [
+        {
+            "index": index,
+            "id": identifier,
+            "kind": "lc-flow",
+            "word": (list(color_word) if index == 0 else [index + 3, 2, 1]),
+            "representative_id": identifier,
+            "computed": True,
+            "coefficient": 1.0,
+            "structural_zero": None,
+        }
+        for index, identifier in enumerate(color_ids)
+    ]
+    helicity_entries = [
+        {
+            "index": 0,
+            "id": helicity_id,
+            "values": list(helicity_values),
+            "representative_id": helicity_id,
+            "computed": True,
+            "coefficient": 1.0,
+            "structural_zero": False,
+        },
+        {
+            "index": 1,
+            "id": opposite_helicity_id,
+            "values": list(opposite_helicity_values),
+            "representative_id": (
+                opposite_helicity_id
+                if secondary_helicity_structural_zero
+                else helicity_id
+            ),
+            "computed": False,
+            "coefficient": (0.0 if secondary_helicity_structural_zero else 1.0),
+            "structural_zero": secondary_helicity_structural_zero,
+        },
+    ]
+    normalization = {"average_factor": 36, "color_factor": 3}
+    model_common = {
+        "name": model_name,
+        "content_sha256": model_content_sha256,
+        "compiled_schema_version": 9,
+        "restriction": None,
+    }
+    model_manifest = {**model_common, "source_kind": "compiled-model"}
+    model_identity = {
+        "manifest": model_manifest,
+        "manifest_sha256": benchmark._canonical_sha256(model_manifest),
+        "common_physics_identity": model_common,
+        "common_physics_identity_sha256": benchmark._canonical_sha256(model_common),
+    }
+    color_specialized = "color_flow" in specialized_axes
+    helicity_specialized = "helicity" in specialized_axes
+    selector_semantics = {
+        "kind": "pyamplicol-runtime-selectors",
+        "contract_version": 1,
+        "axes": {
+            "color_flow": {
+                "generation_coverage": (
+                    "selected" if color_specialized else "complete"
+                ),
+                "generation_selection": [0] if color_specialized else [],
+                "runtime_contract": (
+                    "generation-specialized"
+                    if color_specialized
+                    else "complete-reusable"
+                ),
+            },
+            "helicity": {
+                "generation_coverage": (
+                    "selected" if helicity_specialized else "complete"
+                ),
+                "generation_selection": ({"1": -1} if helicity_specialized else {}),
+                "runtime_contract": (
+                    "generation-specialized"
+                    if helicity_specialized
+                    else "complete-reusable"
+                ),
+            },
+        },
+        "generation_specialized_axes": list(specialized_axes),
+    }
+    runtime_selectors = {
+        **selector_semantics,
+        "provenance": "test-runtime-selectors-v1",
+    }
+    reduction_ordering = {
+        "kind": "lc-diagonal",
+        "ordered_groups": [
+            {
+                "id": f"reduction:{index}",
+                "physical_color_ids": [identifier],
+                "physical_helicity_ids": (
+                    [helicity_ids[0]]
+                    if secondary_helicity_structural_zero
+                    else helicity_ids
+                ),
+                "representative_color_id": identifier,
+                "representative_helicity_id": helicity_ids[0],
+            }
+            for index, identifier in enumerate(color_ids)
+        ],
+    }
+    execution_color_axis = benchmark._ordered_physical_axis(
+        color_entries,
+        label="color-flow",
+        require_structural_zero=False,
+    )
+    execution_helicity_axis = benchmark._ordered_physical_axis(
+        helicity_entries,
+        label="helicity",
+        require_structural_zero=True,
+    )
+    color_axis = benchmark._logical_physical_axis(
+        execution_color_axis,
+        require_structural_zero=False,
+    )
+    helicity_axis = benchmark._logical_physical_axis(
+        execution_helicity_axis,
+        require_structural_zero=True,
+    )
+    logical_reduction = benchmark._logical_reduction_ordering_identity(
+        reduction_ordering["kind"],
+        color_axis=color_axis,
+        helicity_axis=helicity_axis,
+        artifact=Path("<test-profile>"),
+    )
+    execution_reduction = benchmark._reduction_ordering_identity(
+        {
+            "kind": reduction_ordering["kind"],
+            "groups": reduction_ordering["ordered_groups"],
+        },
+        color_axis=execution_color_axis,
+        helicity_axis=execution_helicity_axis,
+        artifact=Path("<test-profile>"),
+    )
+    execution_reduction_identity = {
+        "kind": "expanded-json-reduction-v1",
+        "reduction_kind": reduction_ordering["kind"],
+        "group_count": len(reduction_ordering["ordered_groups"]),
+        "computed_physical_color_count": sum(
+            entry["computed"] is True for entry in color_entries
+        ),
+        "live_physical_helicity_count": sum(
+            entry["structural_zero"] is False for entry in helicity_entries
+        ),
+        "materialized_ordering_sha256": execution_reduction["ordering_sha256"],
+    }
+    execution_ordering = {
+        "runtime_process_contract": {"id": "process-1"},
+        "manifest_payload_order": [{"path": "plan.bin", "role": "runtime"}],
+    }
+    return {
+        "kind": "pyamplicol-benchmark-artifact-semantic-identity",
+        "schema_version": benchmark.ARTIFACT_SEMANTIC_IDENTITY_SCHEMA,
+        "coverage": {
+            "color": ("complete" if complete and not color_specialized else "selected"),
+            "helicities": (
+                "complete" if complete and not helicity_specialized else "selected"
+            ),
+            "complete_physical_axes": (
+                complete and not color_specialized and not helicity_specialized
+            ),
+        },
+        "physical_color_flows": color_axis,
+        "physical_helicities": helicity_axis,
+        "normalization": normalization,
+        "normalization_sha256": benchmark._canonical_sha256(normalization),
+        "manifest_model_identity": model_identity,
+        "runtime_selector_semantics": selector_semantics,
+        "runtime_selector_semantics_sha256": benchmark._canonical_sha256(
+            selector_semantics
+        ),
+        "runtime_selectors": runtime_selectors,
+        "runtime_selectors_sha256": benchmark._canonical_sha256(runtime_selectors),
+        "reduction_ordering": logical_reduction["ordering"],
+        "reduction_ordering_sha256": logical_reduction["ordering_sha256"],
+        "reduction_coverage": logical_reduction["coverage"],
+        "execution_reduction_identity": execution_reduction_identity,
+        "execution_reduction_identity_sha256": benchmark._canonical_sha256(
+            execution_reduction_identity
+        ),
+        "execution_reduction_coverage": execution_reduction["coverage"],
+        "execution_schedule_ordering": execution_ordering,
+        "execution_schedule_ordering_sha256": benchmark._canonical_sha256(
+            execution_ordering
+        ),
+        "generation_specialized_axes": list(specialized_axes),
+    }
+
+
+def _passing_schedule(
+    *,
+    modes: tuple[str, ...] = benchmark.EXECUTION_MODES,
+    batch_sizes: tuple[int, ...] = benchmark.DEFAULT_BATCH_SIZES,
+    subprocess_samples: int = benchmark.MIN_AUTHORITATIVE_SAMPLES,
+    jit_optimization_level: int = 2,
+    lc_flow_layout: str = "topology-replay",
+) -> dict[str, object]:
+    schedule: dict[str, object] = benchmark._build_profile_schedule(
+        modes,
+        batch_sizes,
+        subprocess_samples=subprocess_samples,
+    )
+    entries = schedule["entries"]
+    assert isinstance(entries, list)
+    semantic_identity_sha256 = benchmark._canonical_sha256(
+        _artifact_semantic_identity()
+    )
+    for entry in entries:
+        assert isinstance(entry, dict)
+        index = entry["schedule_index"]
+        command = benchmark._command_identity(
+            ("python", "profile-worker", "--schedule-index", str(index))
+        )
+        verification = {
+            "kind": benchmark.WORKER_VERIFICATION_KIND,
+            "schema_version": benchmark.WORKER_VERIFICATION_SCHEMA,
+            "verified_at_utc": "2026-07-24T00:00:00+00:00",
+            "expected": {
+                field: (
+                    semantic_identity_sha256
+                    if field == "artifact_semantic_identity_sha256"
+                    else "a" * 64
+                )
+                for field in benchmark._PROFILE_EXPECTATION_FIELDS
+            },
+            "observed": {
+                field: (
+                    semantic_identity_sha256
+                    if field == "artifact_semantic_identity_sha256"
+                    else "a" * 64
+                )
+                for field in benchmark._PROFILE_EXPECTATION_FIELDS
+            },
+            "artifact_semantic_identity_sha256": semantic_identity_sha256,
+            "effective_contract": {
+                "execution_mode": entry["mode"],
+                "backend": "jit",
+                "jit_optimization_level": jit_optimization_level,
+                "color_accuracy": "lc",
+                "lc_flow_layout": lc_flow_layout,
+            },
+            "loaded_runtime_artifact": {
+                "kind": "pyamplicol-loaded-runtime-artifact-verification",
+                "schema_version": 1,
+                "phase": "after-native-load-before-timing",
+                "checked_at_utc": "2026-07-24T00:00:00+00:00",
+                "expected_artifact_id": "a" * 64,
+                "loaded_artifact_id": "a" * 64,
+                "passes": True,
+            },
+        }
+        invocation = {
+            "started_at_utc": "2026-07-24T00:00:00+00:00",
+            "finished_at_utc": "2026-07-24T00:00:01+00:00",
+            "wall_seconds": 12.0,
+            "command": command,
+        }
+        invocation["content_sha256"] = benchmark._canonical_sha256(invocation)
+        addressed_payload_sha256 = hashlib.sha256(
+            f"worker-payload-{index}".encode()
+        ).hexdigest()
+        result_record = {
+            "kind": benchmark.RETAINED_WORKER_RESULT_KIND,
+            "schema_version": benchmark.RETAINED_WORKER_RESULT_SCHEMA,
+            "recorded_at_utc": "2026-07-24T00:00:01+00:00",
+            "addressed_payload_sha256": addressed_payload_sha256,
+            "upstream_worker_result_record_sha256": hashlib.sha256(
+                f"upstream-result-{index}".encode()
+            ).hexdigest(),
+            "worker_process_record_sha256": hashlib.sha256(
+                f"worker-process-{index}".encode()
+            ).hexdigest(),
+            "worker_invocation_sha256": invocation["content_sha256"],
+        }
+        result_record["content_sha256"] = benchmark._canonical_sha256(result_record)
+        entry["worker_invocation"] = invocation
+        entry["pre_timing_verification"] = verification
+        entry["worker_result_record"] = result_record
+        entry["worker_result_sha256"] = addressed_payload_sha256
+    return schedule
+
+
+def _raw_native_wall_blocks(
+    *,
+    wall_seconds_per_point: float,
+    batch_size: int,
+    fixture_points_sha256: str,
+    repetitions_per_block: int | None = None,
+    block_count: int = benchmark.MIN_AUTHORITATIVE_SAMPLES,
+    minimum_native_wall_seconds: float = 5.0,
+) -> dict[str, object]:
+    if repetitions_per_block is None:
+        repetitions_per_block = math.ceil(
+            (minimum_native_wall_seconds * 1.02)
+            / (block_count * wall_seconds_per_point * batch_size)
+        )
+    blocks: list[dict[str, object]] = []
+    for block_index in range(block_count):
+        block = {
+            "block_index": block_index,
+            "started_at_utc": (f"2026-07-24T00:00:00.{block_index:06d}+00:00"),
+            "finished_at_utc": (f"2026-07-24T00:00:00.{block_index + 1:06d}+00:00"),
+            "caller_elapsed_seconds": (
+                wall_seconds_per_point * repetitions_per_block * batch_size
+            ),
+            "native_wall_seconds": (
+                wall_seconds_per_point * repetitions_per_block * batch_size
+            ),
+            "wall_seconds_per_point": wall_seconds_per_point,
+            "repetitions": repetitions_per_block,
+            "batch_size": batch_size,
+            "evaluation_count": repetitions_per_block,
+            "evaluated_point_count": repetitions_per_block * batch_size,
+        }
+        block["content_sha256"] = benchmark._canonical_sha256(block)
+        blocks.append(block)
+    observed_native_wall_seconds = sum(
+        float(block["native_wall_seconds"]) for block in blocks
+    )
+    observed_caller_elapsed_seconds = sum(
+        float(block["caller_elapsed_seconds"]) for block in blocks
+    )
+    return {
+        "kind": benchmark.RAW_NATIVE_WALL_BLOCK_KIND,
+        "schema_version": benchmark.RAW_NATIVE_WALL_BLOCK_SCHEMA,
+        "measurement_contract": benchmark.RAW_NATIVE_WALL_MEASUREMENT_CONTRACT,
+        "source": "runtime._benchmark_f64_wall_time",
+        "fixture_points_sha256": fixture_points_sha256,
+        "minimum_native_wall_seconds": minimum_native_wall_seconds,
+        "observed_native_wall_seconds": observed_native_wall_seconds,
+        "observed_caller_elapsed_seconds": observed_caller_elapsed_seconds,
+        "minimum_duration_satisfied": (
+            observed_native_wall_seconds >= minimum_native_wall_seconds
+        ),
+        "calibration": {
+            "kind": "benchmark-runner-wall-rate-calibration",
+            "schema_version": 1,
+            "benchmark_runner_sample_count": 20,
+            "benchmark_runner_repetitions_per_sample": 1,
+            "benchmark_runner_total_repetitions": 20,
+            "benchmark_runner_wall_seconds_per_point": wall_seconds_per_point,
+            "requested_minimum_block_count": block_count,
+            "preceded_by_benchmark_runner_warmup_runs": 2,
+            "duration_headroom_factor": 1.02,
+            "scaled_repetitions_per_block": repetitions_per_block,
+        },
+        "block_count": block_count,
+        "repetitions_per_block": repetitions_per_block,
+        "evaluation_count": block_count * repetitions_per_block,
+        "evaluated_point_count": (block_count * repetitions_per_block * batch_size),
+        "wall_seconds_per_point_median": wall_seconds_per_point,
+        "wall_seconds_per_point_mad": 0.0,
+        "blocks": blocks,
+        "blocks_sha256": benchmark._canonical_sha256(blocks),
+    }
+
+
+def _profile(
+    mode: str,
+    values: tuple[complex, ...],
+    *,
+    fixture: dict[str, object] | None = None,
+    passes: bool = True,
+    schedule: dict[str, object] | None = None,
+    specialized_axes: tuple[str, ...] = (),
+    semantic_identity: dict[str, object] | None = None,
+    selector_contract: dict[str, object] | None = None,
+    process_expression: str = "u u~ > Z g g g g g g",
+) -> dict[str, object]:
+    schedule = _passing_schedule() if schedule is None else schedule
+    validation_fixture = _fixture() if fixture is None else fixture
+    selector_contract = (
+        {
+            "color_flow_request": "1",
+            "resolved_color_flow_id": "flow:2,1",
+            "helicity_request": "1",
+            "resolved_helicity_id": None,
+            "color_flow_count": 1,
+            "helicity_count": 2,
+            "structural_zero_helicity_count": 0,
+            "workload": "single-runtime-selected-flow/helicity-sum",
+        }
+        if selector_contract is None
+        else copy.deepcopy(selector_contract)
+    )
+    semantic_identity = (
+        _artifact_semantic_identity(specialized_axes=specialized_axes)
+        if semantic_identity is None
+        else copy.deepcopy(semantic_identity)
+    )
+    semantic_identity_sha256 = benchmark._canonical_sha256(semantic_identity)
+    complex_payloads = [[value.real, value.imag] for value in values]
+    if selector_contract["workload"] == "all-flows/runtime-selected-single-helicity":
+        resolved_helicity_ids = [selector_contract["resolved_helicity_id"]]
+        resolved_color_ids = semantic_identity["physical_color_flows"]["ordered_ids"]
+    else:
+        resolved_helicity_ids = semantic_identity["physical_helicities"]["ordered_ids"]
+        resolved_color_ids = [selector_contract["resolved_color_flow_id"]]
+    component_count = len(resolved_helicity_ids) * len(resolved_color_ids)
+    resolved_components = [
+        [list(value), *([[0.0, 0.0]] * (component_count - 1))]
+        for value in complex_payloads
+    ]
+    validation_record = {
+        "passes": passes,
+        "fixture": validation_fixture,
+        "selected_totals": complex_payloads,
+        "resolved_sums": copy.deepcopy(complex_payloads),
+        "resolved_helicity_ids": resolved_helicity_ids,
+        "resolved_color_ids": resolved_color_ids,
+        "resolved_components": resolved_components,
+        "point_comparisons": [
+            {
+                "point_index": index,
+                "selected_total": value,
+                "resolved_sum": list(value),
+                "absolute_difference": 0.0,
+                "relative_difference": 0.0,
+                "passes": True,
+            }
+            for index, value in enumerate(complex_payloads)
+        ],
+        "maximum_absolute_difference": 0.0,
+        "maximum_relative_difference": 0.0,
+    }
+    lane_contract = {
+        "process_id": "process-1",
+        "process_expression": process_expression,
+        "selector_contract": selector_contract,
+        "validation": validation_record,
+        "artifact_semantic_identity": semantic_identity,
+        "artifact_semantic_identity_sha256": semantic_identity_sha256,
+    }
+    lane_contract_sha256 = benchmark._canonical_sha256(lane_contract)
+    fixture_points_sha256 = validation_fixture["points_sha256"]
+    assert isinstance(fixture_points_sha256, str)
+    entries = schedule["entries"]
+    assert isinstance(entries, list)
+    measurements: list[dict[str, object]] = []
+    for batch_size in benchmark.DEFAULT_BATCH_SIZES:
+        cell_entries = [
+            entry
+            for entry in entries
+            if isinstance(entry, dict)
+            and entry["mode"] == mode
+            and entry["batch_size"] == batch_size
+        ]
+        samples = []
+        for entry in cell_entries:
+            wall = 1.0e-6 * (1.0 + 0.01 * int(entry["round"]))
+            raw_blocks = _raw_native_wall_blocks(
+                wall_seconds_per_point=wall,
+                batch_size=batch_size,
+                fixture_points_sha256=fixture_points_sha256,
+            )
+            verification = copy.deepcopy(entry["pre_timing_verification"])
+            verification["artifact_semantic_identity_sha256"] = semantic_identity_sha256
+            verification["expected"]["artifact_semantic_identity_sha256"] = (
+                semantic_identity_sha256
+            )
+            verification["observed"]["artifact_semantic_identity_sha256"] = (
+                semantic_identity_sha256
+            )
+            entry["pre_timing_verification"] = verification
+            process_record = {
+                "started_at_utc": "2026-07-24T00:00:00+00:00",
+                "finished_at_utc": "2026-07-24T00:00:01+00:00",
+                "wall_seconds": 12.0,
+                "process_id": 1000 + int(entry["schedule_index"]),
+                "operation": "profile",
+                "mode": mode,
+                "payload_sha256": hashlib.sha256(
+                    f"profile-payload-{entry['schedule_index']}".encode()
+                ).hexdigest(),
+            }
+            process_record["content_sha256"] = benchmark._canonical_sha256(
+                process_record
+            )
+            timing_sources = {
+                "wall": "runtime_core_repeated_wall_time",
+                "evaluator": "diagnostic",
+            }
+            environment = {
+                "wall_time_source": "runtime_core_repeated_wall_time",
+                "wall_time_sample_pass": "runtime._benchmark_f64_wall_time",
+            }
+            worker_measurement = {
+                "batch_size": batch_size,
+                "sample_count": raw_blocks["block_count"],
+                "repetitions_per_sample": raw_blocks["repetitions_per_block"],
+                "evaluation_count": raw_blocks["evaluation_count"],
+                "evaluated_point_count": raw_blocks["evaluated_point_count"],
+                "wall_seconds_per_point": wall,
+                "inner_native_wall_blocks": raw_blocks,
+                "benchmark_runner_sample_count": 20,
+                "benchmark_runner_repetitions_per_sample": 1,
+                "benchmark_runner_evaluation_count": 20,
+                "benchmark_runner_evaluated_point_count": 20 * batch_size,
+                "benchmark_runner_wall_seconds_per_point": wall,
+                "timing_sources": timing_sources,
+                "environment": environment,
+                "interrupted": False,
+            }
+            sample = {
+                "schedule_index": entry["schedule_index"],
+                "round": entry["round"],
+                "worker_command": entry["worker_invocation"]["command"],
+                "worker_invocation": entry["worker_invocation"],
+                "worker_process_record": process_record,
+                "peak_rss_after_cold_load": _resource_peak(),
+                "peak_rss_after_profile": _resource_peak(self_peak_bytes=2048),
+                "pre_timing_verification": verification,
+                "post_timing_loaded_runtime_artifact": {
+                    "kind": "pyamplicol-loaded-runtime-artifact-verification",
+                    "schema_version": 1,
+                    "phase": "after-timing",
+                    "checked_at_utc": "2026-07-24T00:00:01+00:00",
+                    "expected_artifact_id": "a" * 64,
+                    "loaded_artifact_id": "a" * 64,
+                    "passes": True,
+                },
+                "cold_load_seconds": 0.01 + 0.001 * int(entry["round"]),
+                "lane_contract_sha256": lane_contract_sha256,
+                "timing_configuration": {
+                    "minimum_internal_samples": (benchmark.MIN_AUTHORITATIVE_SAMPLES),
+                    "warmup_runs": 2,
+                    "target_runtime_seconds": 5.0,
+                },
+                "worker_measurement": worker_measurement,
+                "internal_sample_count": raw_blocks["block_count"],
+                "repetitions_per_sample": raw_blocks["repetitions_per_block"],
+                "evaluation_count": raw_blocks["evaluation_count"],
+                "evaluated_point_count": raw_blocks["evaluated_point_count"],
+                "wall_seconds_per_point": wall,
+                "inner_native_wall_blocks": raw_blocks,
+                "timing_sources": timing_sources,
+                "environment": environment,
+                "interrupted": False,
+            }
+            retained_result_record = benchmark._retained_profile_worker_result_record(
+                sample,
+                upstream_result_record=entry["worker_result_record"],
+            )
+            sample["worker_result_record"] = retained_result_record
+            entry["worker_result_record"] = retained_result_record
+            entry["worker_result_sha256"] = retained_result_record[
+                "addressed_payload_sha256"
+            ]
+            samples.append(sample)
+        wall_values = [float(sample["wall_seconds_per_point"]) for sample in samples]
+        median = statistics.median(wall_values)
+        mad = statistics.median(abs(value - median) for value in wall_values)
+        measurements.append(
+            {
+                "batch_size": batch_size,
+                "sample_count": len(samples),
+                "subprocess_sample_count": len(samples),
+                "wall_seconds_per_point": median,
+                "wall_seconds_per_point_median": median,
+                "wall_seconds_per_point_mad": mad,
+                "statistics_contract": "subprocess-median-and-raw-mad-v1",
+                "subprocess_samples": samples,
+                "interrupted": False,
+            }
+        )
+    return {
+        "process_id": "process-1",
+        "process_expression": process_expression,
+        "selector_contract": selector_contract,
+        "validation": validation_record,
+        "mode": mode,
+        "artifact_semantic_identity": semantic_identity,
+        "artifact_semantic_identity_sha256": semantic_identity_sha256,
+        "profiles": measurements,
+    }
+
+
+def _passing_profiles(
+    schedule: dict[str, object] | None = None,
+    *,
+    semantic_identity: dict[str, object] | None = None,
+    selector_contract: dict[str, object] | None = None,
+    fixture: dict[str, object] | None = None,
+) -> dict[str, dict[str, Any]]:
+    schedule = _passing_schedule() if schedule is None else schedule
+    values = (1.0 + 2.0j, 3.0 + 4.0j)
+    return {
+        "compiled": _profile(
+            "compiled",
+            values,
+            schedule=schedule,
+            semantic_identity=semantic_identity,
+            selector_contract=selector_contract,
+            fixture=fixture,
+        ),
+        "eager": _profile(
+            "eager",
+            values,
+            schedule=schedule,
+            semantic_identity=semantic_identity,
+            selector_contract=selector_contract,
+            fixture=fixture,
+        ),
+        "recurrence": _profile(
+            "recurrence",
+            values,
+            schedule=schedule,
+            semantic_identity=semantic_identity,
+            selector_contract=selector_contract,
+            fixture=fixture,
+        ),
+    }
+
+
+def _selected_union_profiles() -> dict[str, dict[str, Any]]:
+    schedule = _passing_schedule(modes=("compiled", "recurrence"))
+    selector_common = {
+        "color_flow_request": "1",
+        "resolved_color_flow_id": None,
+        "helicity_request": benchmark.MIGRATION_UNION_SELECTED_HELICITY_ID,
+        "resolved_helicity_id": benchmark.MIGRATION_UNION_SELECTED_HELICITY_ID,
+        "color_flow_count": benchmark.MIGRATION_UNION_PHYSICAL_COLOR_COUNT,
+        "helicity_count": 2,
+        "workload": "all-flows/runtime-selected-single-helicity",
+    }
+    profiles: dict[str, dict[str, Any]] = {}
+    for mode, secondary_zero in (("compiled", True), ("recurrence", False)):
+        semantic_identity = _artifact_semantic_identity(
+            color_count=benchmark.MIGRATION_UNION_PHYSICAL_COLOR_COUNT,
+            helicity_id=benchmark.MIGRATION_UNION_SELECTED_HELICITY_ID,
+            helicity_values=benchmark.MIGRATION_UNION_SELECTED_HELICITY_VALUES,
+            secondary_helicity_structural_zero=secondary_zero,
+        )
+        profiles[mode] = _profile(
+            mode,
+            (1.0e-20 + 2.0e-21j, 3.0e-20 + 4.0e-21j),
+            schedule=schedule,
+            semantic_identity=semantic_identity,
+            selector_contract={
+                **selector_common,
+                "structural_zero_helicity_count": int(secondary_zero),
+            },
+            process_expression=benchmark.MIGRATION_PROCESS_CANONICAL,
+        )
+    return profiles
+
+
+def _rebind_sample_result(
+    schedule: dict[str, object],
+    sample: dict[str, Any],
+) -> None:
+    previous_record = sample["worker_result_record"]
+    assert isinstance(previous_record, dict)
+    retained_record = benchmark._retained_profile_worker_result_record(
+        sample,
+        upstream_result_record=previous_record,
+    )
+    sample["worker_result_record"] = retained_record
+    entries = schedule["entries"]
+    assert isinstance(entries, list)
+    entry = next(
+        item
+        for item in entries
+        if isinstance(item, dict) and item["schedule_index"] == sample["schedule_index"]
+    )
+    entry["worker_result_record"] = retained_record
+    entry["worker_result_sha256"] = retained_record["addressed_payload_sha256"]
+
+
+def test_preserved_worker_result_survives_driver_enrichment() -> None:
+    command = benchmark._command_identity(("python", "worker"))
+    invocation = {
+        "started_at_utc": "2026-07-24T00:00:00+00:00",
+        "finished_at_utc": "2026-07-24T00:00:03+00:00",
+        "wall_seconds": 3.0,
+        "command": command,
+    }
+    invocation["content_sha256"] = benchmark._canonical_sha256(invocation)
+    operation_payload = {
+        "mode": "compiled",
+        "model_source": {"kind": "test"},
+    }
+    process_record = {
+        "started_at_utc": "2026-07-24T00:00:01+00:00",
+        "finished_at_utc": "2026-07-24T00:00:02+00:00",
+        "wall_seconds": 1.0,
+        "process_id": 123,
+        "operation": "generate",
+        "mode": "compiled",
+        "payload_sha256": benchmark._canonical_sha256(operation_payload),
+    }
+    process_record["content_sha256"] = benchmark._canonical_sha256(process_record)
+    payload = {
+        **operation_payload,
+        "worker_command": command,
+        "worker_invocation": invocation,
+        "worker_process_record": process_record,
+    }
+    result_record = {
+        "recorded_at_utc": "2026-07-24T00:00:04+00:00",
+        "addressed_payload_sha256": benchmark._canonical_sha256(payload),
+        "worker_process_record_sha256": process_record["content_sha256"],
+        "worker_invocation_sha256": invocation["content_sha256"],
+    }
+    result_record["content_sha256"] = benchmark._canonical_sha256(result_record)
+    returned = {**payload, "worker_result_record": result_record}
+    evidence = benchmark._preserved_worker_result_evidence(returned)
+    forged = copy.deepcopy(returned)
+    forged_process = forged["worker_process_record"]
+    forged_process["payload_sha256"] = "b" * 64
+    forged_process["content_sha256"] = benchmark._canonical_sha256(
+        {key: value for key, value in forged_process.items() if key != "content_sha256"}
+    )
+    forged_record = forged["worker_result_record"]
+    forged_record["worker_process_record_sha256"] = forged_process["content_sha256"]
+    forged_payload = {
+        key: value for key, value in forged.items() if key != "worker_result_record"
+    }
+    forged_record["addressed_payload_sha256"] = benchmark._canonical_sha256(
+        forged_payload
+    )
+    forged_record["content_sha256"] = benchmark._canonical_sha256(
+        {key: value for key, value in forged_record.items() if key != "content_sha256"}
+    )
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="content-address contract",
+    ):
+        benchmark._preserved_worker_result_evidence(forged)
+    returned["artifact_identity"] = {"later": "driver enrichment"}
+    assert evidence["payload"] == payload
+    assert evidence["worker_result_record"]["addressed_payload_sha256"] == (
+        benchmark._canonical_sha256(evidence["payload"])
+    )
+    assert evidence["content_sha256"] == benchmark._canonical_sha256(
+        {key: value for key, value in evidence.items() if key != "content_sha256"}
+    )
+
+
+def test_pairwise_validation_includes_eager_and_every_point() -> None:
+    summary = benchmark._pairwise_profile_validation(_passing_profiles())
+    comparisons = summary["comparisons"]
+    assert set(comparisons) == {
+        "compiled__eager",
+        "compiled__recurrence",
+        "eager__recurrence",
+    }
+    assert len(comparisons["compiled__eager"]["point_comparisons"]) == 2
+    assert summary["selectors_match"]
+    assert summary["fixtures_match"]
+    assert summary["lane_validation_passes"]
+    assert summary["pairwise_validation_passes"]
+    assert summary["passes"]
+
+
+def test_numerical_tolerance_is_additive_not_absolute_or_relative() -> None:
+    expected = 1.0e-3
+    actual = expected + 1.5e-15
+    absolute = abs(actual - expected)
+    old_relative = absolute / max(abs(actual), abs(expected), 1.0e-300)
+
+    assert absolute > benchmark.ATOL
+    assert old_relative > benchmark.RTOL
+    assert benchmark._within_numerical_tolerance(actual, expected)
+    assert not benchmark._within_numerical_tolerance(2.0 * benchmark.ATOL, 0.0)
+
+    comparison = benchmark._comparison(
+        "actual",
+        [[actual, 0.0]],
+        "expected",
+        [[expected, 0.0]],
+    )
+    assert comparison["point_comparisons"][0]["relative_difference"] == old_relative
+    assert comparison["passes"]
+
+
+def test_lane_evidence_recomputation_uses_additive_tolerance() -> None:
+    expected = 1.0e-3
+    actual = expected + 1.5e-15
+    profiles = {
+        mode: _profile(mode, (complex(expected), 2.0e-3 + 0.0j))
+        for mode in ("compiled", "eager", "recurrence")
+    }
+    absolute = abs(actual - expected)
+    relative = absolute / max(abs(actual), abs(expected), 1.0e-300)
+    for profile in profiles.values():
+        validation = profile["validation"]
+        validation["selected_totals"][0] = [actual, 0.0]
+        comparison = validation["point_comparisons"][0]
+        comparison["selected_total"] = [actual, 0.0]
+        comparison["absolute_difference"] = absolute
+        comparison["relative_difference"] = relative
+        comparison["passes"] = True
+        validation["maximum_absolute_difference"] = absolute
+        validation["maximum_relative_difference"] = relative
+
+    summary = benchmark._pairwise_profile_validation(profiles)
+    assert summary["lane_validation_passes"]
+    assert summary["pairwise_validation_passes"]
+    assert summary["passes"]
+
+
+def test_component_sum_and_pairwise_components_use_additive_tolerance() -> None:
+    expected = 1.0e-3
+    actual = expected + 1.5e-15
+    profiles = {
+        mode: _profile(mode, (complex(expected), 2.0e-3 + 0.0j))
+        for mode in ("compiled", "eager", "recurrence")
+    }
+    profiles["eager"]["validation"]["resolved_components"][0][0] = [actual, 0.0]
+
+    summary = benchmark._pairwise_profile_validation(profiles)
+    assert summary["lane_validation_passes"]
+    assert summary["resolved_component_comparisons"]["compiled__eager"]["passes"]
+    assert summary["resolved_component_comparisons"]["eager__recurrence"]["passes"]
+    assert summary["pairwise_validation_passes"]
+    assert summary["passes"]
+
+
+def test_selected_union_projection_permits_only_nonselected_zero_metadata() -> None:
+    arguments = _arguments(
+        "--process-expression",
+        benchmark.MIGRATION_PROCESS_REQUEST,
+        "--lc-flow-layout",
+        "all-flow-union",
+        "--helicity",
+        benchmark.MIGRATION_UNION_SELECTED_HELICITY_ID,
+    )
+    profiles = _selected_union_profiles()
+
+    strict_semantics = benchmark._profile_artifact_semantic_contract(profiles)
+    strict_numerical = benchmark._pairwise_profile_validation(profiles)
+    assert strict_semantics["lanes_match"] is False
+    assert strict_numerical["selectors_match"] is False
+
+    semantics = benchmark._profile_artifact_semantic_contract(
+        profiles,
+        arguments=arguments,
+    )
+    numerical = benchmark._pairwise_profile_validation(
+        profiles,
+        arguments=arguments,
+    )
+    preflight = benchmark._validation_preflight_contract(arguments, profiles)
+
+    assert semantics["comparison_policy"].endswith("selected-helicity-v1")
+    assert semantics["passes"]
+    assert semantics["lanes_match"]
+    assert numerical["selector_comparison_policy"].endswith("selected-helicity-v1")
+    assert numerical["selectors_match"]
+    assert numerical["pairwise_validation_passes"]
+    assert preflight["passes"]
+
+
+@pytest.mark.parametrize(
+    ("argument", "value"),
+    (
+        ("--process-expression", "u u~ > Z g g g g g g"),
+        ("--lc-flow-layout", "topology-replay"),
+        ("--helicity", "1"),
+    ),
+)
+def test_selected_union_projection_is_not_used_outside_exact_route(
+    argument: str,
+    value: str,
+) -> None:
+    values = [
+        "--process-expression",
+        benchmark.MIGRATION_PROCESS_REQUEST,
+        "--lc-flow-layout",
+        "all-flow-union",
+        "--helicity",
+        benchmark.MIGRATION_UNION_SELECTED_HELICITY_ID,
+    ]
+    option_index = values.index(argument)
+    values[option_index + 1] = value
+    arguments = _arguments(*values)
+    profiles = _selected_union_profiles()
+
+    semantics = benchmark._profile_artifact_semantic_contract(
+        profiles,
+        arguments=arguments,
+    )
+    numerical = benchmark._pairwise_profile_validation(
+        profiles,
+        arguments=arguments,
+    )
+
+    assert semantics["comparison_policy"] == "strict-exact-v1"
+    assert semantics["lanes_match"] is False
+    assert numerical["selector_comparison_policy"] == "strict-exact-v1"
+    assert numerical["selectors_match"] is False
+
+
+def test_selected_union_projection_rejects_nonselected_helicity_values() -> None:
+    arguments = _arguments(
+        "--process-expression",
+        benchmark.MIGRATION_PROCESS_REQUEST,
+        "--lc-flow-layout",
+        "all-flow-union",
+        "--helicity",
+        benchmark.MIGRATION_UNION_SELECTED_HELICITY_ID,
+    )
+    profiles = _selected_union_profiles()
+    recurrence = profiles["recurrence"]
+    identity = recurrence["artifact_semantic_identity"]
+    helicities = identity["physical_helicities"]
+    entries = copy.deepcopy(helicities["ordered_entries"])
+    entries[1]["values"][0] = 7
+    helicities["ordered_entries"] = entries
+    helicities["ordered_entries_sha256"] = benchmark._canonical_sha256(entries)
+    recurrence["artifact_semantic_identity_sha256"] = benchmark._canonical_sha256(
+        identity
+    )
+
+    semantics = benchmark._profile_artifact_semantic_contract(
+        profiles,
+        arguments=arguments,
+    )
+
+    assert semantics["passes"] is False
+    assert semantics["lanes_match"] is False
+    assert semantics["errors"]
+
+
+def test_selected_union_projection_rejects_selected_coefficient_mismatch() -> None:
+    arguments = _arguments(
+        "--process-expression",
+        benchmark.MIGRATION_PROCESS_REQUEST,
+        "--lc-flow-layout",
+        "all-flow-union",
+        "--helicity",
+        benchmark.MIGRATION_UNION_SELECTED_HELICITY_ID,
+    )
+    profiles = _selected_union_profiles()
+    recurrence = profiles["recurrence"]
+    identity = recurrence["artifact_semantic_identity"]
+    helicities = identity["physical_helicities"]
+    entries = copy.deepcopy(helicities["ordered_entries"])
+    selected = next(
+        entry
+        for entry in entries
+        if entry["id"] == benchmark.MIGRATION_UNION_SELECTED_HELICITY_ID
+    )
+    selected["coefficient"] = 2.0
+    helicities["ordered_entries"] = entries
+    helicities["ordered_entries_sha256"] = benchmark._canonical_sha256(entries)
+    recurrence["artifact_semantic_identity_sha256"] = benchmark._canonical_sha256(
+        identity
+    )
+
+    semantics = benchmark._profile_artifact_semantic_contract(
+        profiles,
+        arguments=arguments,
+    )
+
+    assert semantics["passes"] is False
+    assert semantics["lanes_match"] is False
+
+
+def test_selected_union_preflight_rejects_resolved_component_drift() -> None:
+    arguments = _arguments(
+        "--process-expression",
+        benchmark.MIGRATION_PROCESS_REQUEST,
+        "--lc-flow-layout",
+        "all-flow-union",
+        "--helicity",
+        benchmark.MIGRATION_UNION_SELECTED_HELICITY_ID,
+    )
+    profiles = _selected_union_profiles()
+    components = profiles["recurrence"]["validation"]["resolved_components"]
+    assert isinstance(components, list)
+    components[0][0] = [9.0, 0.0]
+
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="failed before timing",
+    ):
+        benchmark._require_validation_preflight(arguments, profiles)
+
+
+def test_pairwise_validation_fails_when_only_a_later_eager_point_differs() -> None:
+    profiles = _passing_profiles()
+    profiles["eager"] = _profile("eager", (1.0 + 2.0j, 3.1 + 4.0j))
+    summary = benchmark._pairwise_profile_validation(profiles)
+    comparison = summary["comparisons"]["compiled__eager"]
+    assert comparison["point_comparisons"][0]["passes"]
+    assert not comparison["point_comparisons"][1]["passes"]
+    assert not summary["pairwise_validation_passes"]
+    assert not summary["passes"]
+
+
+def test_pairwise_validation_fails_on_resolved_component_difference() -> None:
+    profiles = _passing_profiles()
+    eager_components = profiles["eager"]["validation"]["resolved_components"]
+    assert isinstance(eager_components, list)
+    eager_components[0][0] = [0.5, 2.0]
+    eager_components[0][1] = [0.5, 0.0]
+    summary = benchmark._pairwise_profile_validation(profiles)
+    comparison = summary["resolved_component_comparisons"]["compiled__eager"]
+    assert not comparison["passes"]
+    assert not summary["pairwise_validation_passes"]
+    assert not summary["passes"]
+
+
+def test_pairwise_validation_fails_on_resolved_axis_difference() -> None:
+    profiles = _passing_profiles()
+    profiles["eager"]["validation"]["resolved_helicity_ids"][0] = "h:+1,+1"
+    summary = benchmark._pairwise_profile_validation(profiles)
+    comparison = summary["resolved_component_comparisons"]["compiled__eager"]
+    assert not comparison["axes_match"]
+    assert not comparison["passes"]
+    assert not summary["passes"]
+
+
+def test_pairwise_validation_fails_on_fixture_mismatch() -> None:
+    profiles = _passing_profiles()
+    profiles["eager"] = _profile(
+        "eager",
+        (1.0 + 2.0j, 3.0 + 4.0j),
+        fixture=_fixture(points_sha256="d" * 64),
+    )
+    summary = benchmark._pairwise_profile_validation(profiles)
+    assert not summary["fixtures_match"]
+    assert not summary["passes"]
+
+
+@pytest.mark.parametrize("value", ("false", 1))
+def test_pairwise_validation_requires_boolean_lane_pass(value: object) -> None:
+    profiles = _passing_profiles()
+    profiles["compiled"]["validation"]["passes"] = value
+    with pytest.raises(benchmark.HarnessError, match="summary is inconsistent"):
+        benchmark._pairwise_profile_validation(profiles)
+
+
+def test_pairwise_validation_requires_fixture_point_count() -> None:
+    profiles = _passing_profiles()
+    for profile in profiles.values():
+        profile["validation"]["selected_totals"] = [[1.0, 2.0]]
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="inventory disagrees with fixture",
+    ):
+        benchmark._pairwise_profile_validation(profiles)
+
+
+def test_pairwise_validation_rejects_boolean_complex_components() -> None:
+    profiles = _passing_profiles()
+    for profile in profiles.values():
+        profile["validation"]["selected_totals"] = [
+            [True, False],
+            [True, False],
+        ]
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="invalid complex value",
+    ):
+        benchmark._pairwise_profile_validation(profiles)
+
+
+def test_pairwise_validation_recomputes_lane_point_evidence() -> None:
+    profiles = _passing_profiles()
+    profiles["compiled"]["validation"]["resolved_sums"][0] = [9.0, 9.0]
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="point evidence is inconsistent",
+    ):
+        benchmark._pairwise_profile_validation(profiles)
+
+
+@pytest.mark.parametrize(
+    ("mode", "prepared", "expected"),
+    [
+        ("compiled", False, 3),
+        ("eager", False, benchmark.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL),
+        ("recurrence", False, benchmark.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL),
+        ("compiled", True, 3),
+        ("eager", True, benchmark.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL),
+        ("recurrence", True, benchmark.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL),
+    ],
+)
+def test_effective_jit_level_distinguishes_source_and_prepared_execution(
+    tmp_path: Path,
+    mode: str,
+    prepared: bool,
+    expected: int,
+) -> None:
+    values = ["--jit-optimization-level", "3"]
+    if prepared:
+        values.extend(("--prepared-model", str(tmp_path / "model.pyamplicol-model")))
+    arguments = _arguments(*values)
+    assert (
+        benchmark._expected_effective_jit_optimization_level(arguments, mode=mode)
+        == expected
+    )
+
+
+def test_partial_lane_capture_never_vacuously_passes() -> None:
+    arguments = _arguments("--mode", "recurrence")
+    schedule = _passing_schedule(modes=("recurrence",))
+    profiles = {
+        "recurrence": _profile(
+            "recurrence",
+            (1.0 + 2.0j, 3.0 + 4.0j),
+            schedule=schedule,
+        )
+    }
+    summary = benchmark._pairwise_profile_validation(profiles)
+    assert summary["lane_validation_passes"]
+    assert summary["pairwise_validation_passes"] is None
+
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert not capture["complete"]
+    assert capture["passes"] is None
+    assert capture["missing_modes"] == ["compiled"]
+    assert capture["eager_diagnostic"]["requested"] is False
+
+
+def _recurrence_runtime_acceptance_fixture(
+    *,
+    semantic_identity: dict[str, object] | None = None,
+    gluon_count: int = 6,
+    lc_flow_layout: str = "topology-replay",
+) -> dict[str, Any]:
+    process_expression = "d d~ > Z" + " g" * gluon_count
+    arguments = _arguments(
+        "--mode",
+        "recurrence",
+        "--gluon-count",
+        str(gluon_count),
+        "--process-expression",
+        process_expression,
+        "--lc-flow-layout",
+        lc_flow_layout,
+    )
+    source_identity = {"revision": "1" * 40, "dirty": False}
+    runtime_provenance = {"native_extension": {"sha256": "2" * 64}}
+    schedule = _passing_schedule(
+        modes=("recurrence",),
+        lc_flow_layout=lc_flow_layout,
+    )
+    schedule_entries = schedule["entries"]
+    assert isinstance(schedule_entries, list)
+    for entry in schedule_entries:
+        verification = entry["pre_timing_verification"]
+        for identities in (verification["expected"], verification["observed"]):
+            identities["source_identity_sha256"] = benchmark._canonical_sha256(
+                source_identity
+            )
+            identities["runtime_provenance_sha256"] = benchmark._canonical_sha256(
+                runtime_provenance
+            )
+    selector_contract = (
+        None
+        if lc_flow_layout == "topology-replay"
+        else {
+            "color_flow_request": "1",
+            "resolved_color_flow_id": None,
+            "helicity_request": "1",
+            "resolved_helicity_id": "h:-1,+1",
+            "color_flow_count": 1,
+            "helicity_count": 2,
+            "structural_zero_helicity_count": 0,
+            "workload": "all-flows/runtime-selected-single-helicity",
+        }
+    )
+    profile = _profile(
+        "recurrence",
+        (1.0 + 2.0j, 3.0 + 4.0j),
+        schedule=schedule,
+        semantic_identity=semantic_identity,
+        selector_contract=selector_contract,
+        process_expression=process_expression,
+    )
+    profiles = {"recurrence": profile}
+    validation_summary = benchmark._pairwise_profile_validation(profiles)
+    semantic_identity = profile["artifact_semantic_identity"]
+    semantic_sha256 = profile["artifact_semantic_identity_sha256"]
+    generation = {
+        "recurrence": {
+            "mode": "recurrence",
+            "generation_reused": False,
+            "artifact_identity": {
+                "artifact_id": "a" * 64,
+                "semantic_identity": copy.deepcopy(semantic_identity),
+                "semantic_identity_sha256": semantic_sha256,
+            },
+            "artifact_semantic_identity_sha256": semantic_sha256,
+            "effective_contract": {
+                "execution_mode": "recurrence",
+                "backend": "jit",
+                "jit_optimization_level": (
+                    benchmark.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL
+                ),
+                "color_accuracy": "lc",
+                "lc_flow_layout": lc_flow_layout,
+            },
+        }
+    }
+    return {
+        "arguments": arguments,
+        "source_identity": source_identity,
+        "runtime_provenance": runtime_provenance,
+        "generation": generation,
+        "profiles": profiles,
+        "validation_summary": validation_summary,
+        "profile_schedule": schedule,
+    }
+
+
+def _recurrence_runtime_acceptance_record(
+    fixture: dict[str, Any],
+) -> dict[str, object]:
+    return benchmark._recurrence_runtime_acceptance(**fixture)
+
+
+@pytest.mark.parametrize("gluon_count", (5, 6))
+@pytest.mark.parametrize(
+    "lc_flow_layout",
+    ("topology-replay", "all-flow-union"),
+)
+def test_recurrence_runtime_acceptance_passes_and_is_content_addressed(
+    gluon_count: int,
+    lc_flow_layout: str,
+) -> None:
+    fixture = _recurrence_runtime_acceptance_fixture(
+        gluon_count=gluon_count,
+        lc_flow_layout=lc_flow_layout,
+    )
+    record = _recurrence_runtime_acceptance_record(fixture)
+
+    assert record["kind"] == benchmark.RECURRENCE_RUNTIME_ACCEPTANCE_KIND
+    assert record["schema_version"] == benchmark.RECURRENCE_RUNTIME_ACCEPTANCE_SCHEMA
+    assert record["accepted"] is True
+    assert record["status"] == "accepted"
+    assert record["errors"] == []
+    assert record["contracts"]["measurement"]["passes"] is True
+    assert record["contracts"]["artifact_semantics"]["passes"] is True
+    assert record["contracts"]["lane_validation"] == {
+        "passes": True,
+        "lane_validation_passes": True,
+        "selectors_match": True,
+        "fixtures_match": True,
+        "pairwise_validation_passes": None,
+        "summary_sha256": benchmark._canonical_sha256(fixture["validation_summary"]),
+    }
+    assert record["contracts"]["worker_rss"]["passes"] is True
+    assert record["contracts"]["worker_rss"]["worker_count"] == 21
+    bindings = record["bindings"]
+    assert bindings["generation_artifact_id"] == "a" * 64
+    assert (
+        bindings["generation_artifact_semantic_identity_sha256"]
+        == fixture["profiles"]["recurrence"]["artifact_semantic_identity_sha256"]
+    )
+    assert bindings["profile_schedule_sha256"] == benchmark._canonical_sha256(
+        fixture["profile_schedule"]
+    )
+    assert bindings["recurrence_profile_sha256"] == benchmark._canonical_sha256(
+        fixture["profiles"]["recurrence"]
+    )
+    assert record["content_sha256"] == benchmark._canonical_sha256(
+        {key: value for key, value in record.items() if key != "content_sha256"}
+    )
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "error"),
+    (
+        ("modes", ["compiled", "recurrence"], "only the recurrence mode"),
+        ("generation_only", True, "completed profiling"),
+        ("batch_size", [1, 1024, 128], "exact batches"),
+        ("warmup_runs", 1, "two warm-up"),
+        ("target_runtime", 4.999, "five-second"),
+        ("minimum_samples", 6, "at least seven"),
+        ("subprocess_samples", 6, "seven through twenty-one"),
+        ("subprocess_samples", 22, "seven through twenty-one"),
+        ("gluon_count", 4, "ladder process"),
+        ("process_expression", "u u~ > Z g", "ladder process"),
+        ("specialize_flow_at_generation", True, "forbids generation"),
+    ),
+)
+def test_recurrence_runtime_acceptance_rejects_noncanonical_configuration(
+    field: str,
+    value: object,
+    error: str,
+) -> None:
+    fixture = _recurrence_runtime_acceptance_fixture()
+    setattr(fixture["arguments"], field, value)
+    record = _recurrence_runtime_acceptance_record(fixture)
+    assert record["accepted"] is False
+    assert record["status"] == "rejected"
+    assert any(error in item for item in record["errors"])
+
+
+@pytest.mark.parametrize(
+    "failure",
+    (
+        "schedule",
+        "measurement",
+        "lane_validation",
+        "selector",
+        "fixture",
+        "profile_inventory",
+    ),
+)
+def test_recurrence_runtime_acceptance_reuses_authenticated_contracts(
+    failure: str,
+) -> None:
+    fixture = _recurrence_runtime_acceptance_fixture()
+    profile = fixture["profiles"]["recurrence"]
+    if failure == "schedule":
+        del fixture["profile_schedule"]["entries"][0]["worker_invocation"]
+    elif failure == "measurement":
+        profile["profiles"][0]["subprocess_samples"][0]["interrupted"] = True
+    elif failure == "lane_validation":
+        profile["validation"]["passes"] = False
+    elif failure == "selector":
+        profile["selector_contract"]["color_flow_request"] = "forged"
+    elif failure == "fixture":
+        profile["validation"]["fixture"]["points_sha256"] = "invalid"
+    else:
+        fixture["profiles"]["compiled"] = copy.deepcopy(profile)
+    record = _recurrence_runtime_acceptance_record(fixture)
+    assert record["accepted"] is False
+    if failure == "schedule":
+        assert record["contracts"]["measurement"]["schedule"]["passes"] is False
+    elif failure == "profile_inventory":
+        assert any(
+            "profile inventory is not recurrence-only" in item
+            for item in record["errors"]
+        )
+    else:
+        assert (
+            record["contracts"]["measurement"]["passes"] is False
+            or record["contracts"]["lane_validation"]["passes"] is False
+        )
+
+
+@pytest.mark.parametrize(
+    "failure",
+    (
+        "incomplete_axes",
+        "specialized_axes",
+        "artifact_id",
+        "semantic_digest",
+        "effective_contract",
+        "generation_reused",
+        "worker_binding",
+        "source",
+        "runtime",
+    ),
+)
+def test_recurrence_runtime_acceptance_rejects_unbound_semantics_or_provenance(
+    failure: str,
+) -> None:
+    semantic_identity = (
+        _artifact_semantic_identity(complete=False)
+        if failure == "incomplete_axes"
+        else (
+            _artifact_semantic_identity(specialized_axes=("color_flow",))
+            if failure == "specialized_axes"
+            else None
+        )
+    )
+    fixture = _recurrence_runtime_acceptance_fixture(
+        semantic_identity=semantic_identity
+    )
+    generation = fixture["generation"]["recurrence"]
+    if failure == "artifact_id":
+        generation["artifact_identity"]["artifact_id"] = "invalid"
+    elif failure == "semantic_digest":
+        generation["artifact_identity"]["semantic_identity_sha256"] = "3" * 64
+    elif failure == "effective_contract":
+        generation["effective_contract"]["backend"] = "forged"
+    elif failure == "generation_reused":
+        generation["generation_reused"] = True
+    elif failure == "worker_binding":
+        fixture["profile_schedule"]["entries"][0]["pre_timing_verification"][
+            "expected"
+        ]["artifact_id"] = "4" * 64
+    elif failure == "source":
+        fixture["source_identity"] = {}
+    elif failure == "runtime":
+        fixture["runtime_provenance"] = {}
+    record = _recurrence_runtime_acceptance_record(fixture)
+    assert record["accepted"] is False
+    if failure in {"incomplete_axes", "specialized_axes"}:
+        assert any(
+            "complete unspecialized physical axes" in item for item in record["errors"]
+        )
+    if failure == "worker_binding":
+        assert any("profile workers are not bound" in item for item in record["errors"])
+
+
+@pytest.mark.parametrize(
+    "failure",
+    (
+        "missing",
+        "extra_key",
+        "source",
+        "boolean",
+        "negative",
+        "maximum",
+        "post_below_cold",
+    ),
+)
+def test_recurrence_runtime_acceptance_validates_every_worker_rss_mapping(
+    failure: str,
+) -> None:
+    fixture = _recurrence_runtime_acceptance_fixture()
+    sample = fixture["profiles"]["recurrence"]["profiles"][0]["subprocess_samples"][0]
+    if failure == "missing":
+        del sample["peak_rss_after_cold_load"]
+    elif failure == "extra_key":
+        sample["peak_rss_after_cold_load"]["unexpected"] = 1
+    elif failure == "source":
+        sample["peak_rss_after_cold_load"]["source"] = "forged"
+    elif failure == "boolean":
+        sample["peak_rss_after_cold_load"]["self_peak_bytes"] = True
+    elif failure == "negative":
+        sample["peak_rss_after_cold_load"]["self_peak_bytes"] = -1
+    elif failure == "maximum":
+        sample["peak_rss_after_cold_load"]["observed_lower_bound_bytes"] = 1
+    else:
+        sample["peak_rss_after_profile"] = _resource_peak(self_peak_bytes=512)
+    _rebind_sample_result(fixture["profile_schedule"], sample)
+    record = _recurrence_runtime_acceptance_record(fixture)
+    assert record["accepted"] is False
+    rss_contract = record["contracts"]["worker_rss"]
+    assert rss_contract["passes"] is False
+    if failure == "post_below_cold":
+        assert any("below cold-load" in item for item in rss_contract["errors"])
+
+
+def test_complete_three_lane_capture_can_pass_but_m0_remains_fail_closed() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"]
+    assert capture["passes"]
+    assert capture["schema_version"] == benchmark.CAPTURE_ACCEPTANCE_SCHEMA
+    assert schedule["schema_version"] == 2
+
+    manifest = benchmark._milestone0_acceptance_manifest(arguments, capture)
+    assert manifest["kind"] == benchmark.M0_ACCEPTANCE_KIND
+    assert manifest["schema_version"] == benchmark.M0_ACCEPTANCE_SCHEMA
+    assert not manifest["accepted"]
+    assert manifest["status"] == "incomplete"
+    assert {"kind": "layout_capture", "value": "all-flow-union"} in manifest[
+        "missing_evidence"
+    ]
+    assert {"kind": "external_lane", "value": "amplicol"} in manifest[
+        "missing_evidence"
+    ]
+    assert "separate fail-closed orchestrator" in manifest["integration_step"]
+
+
+def test_generation_specialized_axes_are_not_authoritative() -> None:
+    arguments = _arguments("--specialize-flow-at-generation")
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    profiles["recurrence"] = _profile(
+        "recurrence",
+        (1.0 + 2.0j, 3.0 + 4.0j),
+        schedule=schedule,
+        specialized_axes=("color_flow",),
+    )
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["evidence_complete"]
+    assert not capture["authoritative_eligible"]
+    assert not capture["complete"]
+    assert capture["passes"] is None
+    assert capture["generation_specialized_axes_by_mode"] == {
+        "recurrence": ["color_flow"]
+    }
+
+
+def test_eager_normalization_mismatch_is_diagnostic_only() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    eager_identity = profiles["eager"]["artifact_semantic_identity"]
+    eager_identity["normalization"] = {"average_factor": 72, "color_factor": 3}
+    eager_identity["normalization_sha256"] = benchmark._canonical_sha256(
+        eager_identity["normalization"]
+    )
+    profiles["eager"]["artifact_semantic_identity_sha256"] = (
+        benchmark._canonical_sha256(eager_identity)
+    )
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["authoritative_eligible"]
+    assert capture["artifact_semantic_contract"]["lanes_match"]
+    assert capture["complete"]
+    diagnostic = capture["eager_diagnostic"]
+    assert diagnostic["complete"] is False
+    assert diagnostic["passes"] is None
+    assert diagnostic["artifact_semantic_contract"]["lanes_match"] is False
+
+
+def test_profile_semantic_identity_digest_is_required() -> None:
+    profiles = _passing_profiles()
+    eager_identity = profiles["eager"]["artifact_semantic_identity"]
+    eager_identity["normalization"]["average_factor"] = 72
+    eager_identity["normalization_sha256"] = benchmark._canonical_sha256(
+        eager_identity["normalization"]
+    )
+    contract = benchmark._profile_artifact_semantic_contract(profiles)
+    assert contract["passes"] is False
+    assert contract["lanes_match"] is False
+    assert any("not content-addressed" in error for error in contract["errors"])
+
+
+def test_physical_axis_value_is_cross_compared() -> None:
+    profiles = _passing_profiles()
+    eager_profile = profiles["eager"]
+    eager_identity = eager_profile["artifact_semantic_identity"]
+    eager_axis = eager_identity["physical_helicities"]
+    eager_entries = copy.deepcopy(eager_axis["ordered_entries"])
+    eager_entries[1]["values"][0] = -7
+    eager_axis["ordered_entries"] = eager_entries
+    eager_axis["ordered_entries_sha256"] = benchmark._canonical_sha256(eager_entries)
+    eager_profile["artifact_semantic_identity_sha256"] = benchmark._canonical_sha256(
+        eager_identity
+    )
+    contract = benchmark._profile_artifact_semantic_contract(profiles)
+    assert contract["passes"] is False
+    assert contract["lanes_match"] is False
+
+
+def test_physical_axis_coefficient_is_cross_compared() -> None:
+    profiles = _passing_profiles()
+    eager_profile = profiles["eager"]
+    eager_identity = eager_profile["artifact_semantic_identity"]
+    eager_axis = eager_identity["physical_helicities"]
+    eager_entries = copy.deepcopy(eager_axis["ordered_entries"])
+    eager_entries[1]["coefficient"] = 2.0
+    eager_axis["ordered_entries"] = eager_entries
+    eager_axis["ordered_entries_sha256"] = benchmark._canonical_sha256(eager_entries)
+    eager_profile["artifact_semantic_identity_sha256"] = benchmark._canonical_sha256(
+        eager_identity
+    )
+
+    contract = benchmark._profile_artifact_semantic_contract(profiles)
+
+    assert contract["passes"] is False
+    assert contract["lanes_match"] is False
+
+
+def test_empty_runtime_selector_axes_are_ineligible() -> None:
+    profiles = _passing_profiles()
+    eager_profile = profiles["eager"]
+    eager_identity = eager_profile["artifact_semantic_identity"]
+    eager_selector_semantics = copy.deepcopy(
+        eager_identity["runtime_selector_semantics"]
+    )
+    eager_runtime_selectors = copy.deepcopy(eager_identity["runtime_selectors"])
+    eager_selector_semantics["axes"] = {}
+    eager_runtime_selectors["axes"] = {}
+    eager_identity["runtime_selector_semantics"] = eager_selector_semantics
+    eager_identity["runtime_selector_semantics_sha256"] = benchmark._canonical_sha256(
+        eager_selector_semantics
+    )
+    eager_identity["runtime_selectors"] = eager_runtime_selectors
+    eager_identity["runtime_selectors_sha256"] = benchmark._canonical_sha256(
+        eager_runtime_selectors
+    )
+    eager_profile["artifact_semantic_identity_sha256"] = benchmark._canonical_sha256(
+        eager_identity
+    )
+    contract = benchmark._profile_artifact_semantic_contract(profiles)
+    assert contract["passes"] is False
+    assert any(
+        "model/selector/reduction semantic identity is invalid" in error
+        for error in contract["errors"]
+    )
+
+
+def test_empty_profile_selector_workload_contract_is_ineligible() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    for profile in profiles.values():
+        profile["selector_contract"] = {}
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is False
+    assert capture["measurement_contract"]["passes"] is False
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("color_flow_count", 99),
+        ("resolved_color_flow_id", "flow:forged"),
+        ("structural_zero_helicity_count", 1),
+    ),
+)
+def test_profile_selector_reconciles_with_semantic_axes(
+    field: str,
+    value: object,
+) -> None:
+    arguments = _arguments()
+    profile = _profile("compiled", (1.0 + 2.0j, 3.0 + 4.0j))
+    selector_contract = copy.deepcopy(profile["selector_contract"])
+    assert isinstance(selector_contract, dict)
+    selector_contract[field] = value
+    assert (
+        benchmark._profile_selector_contract_matches(
+            arguments,
+            selector_contract,
+            profile["artifact_semantic_identity"],
+        )
+        is False
+    )
+
+
+def test_eager_root_process_mismatch_is_diagnostic_only() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    profiles["eager"]["process_id"] = "wrong"
+    profiles["eager"]["process_expression"] = "wrong > process"
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is True
+    assert capture["measurement_contract"]["root_processes_match"] is True
+    assert capture["eager_diagnostic"]["complete"] is False
+    assert capture["eager_diagnostic"]["passes"] is None
+
+
+def test_runtime_selector_contract_version_rejects_boolean() -> None:
+    identity = _artifact_semantic_identity()
+    runtime_selectors = copy.deepcopy(identity["runtime_selectors"])
+    assert isinstance(runtime_selectors, dict)
+    runtime_selectors["contract_version"] = True
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="runtime-selector semantics are incomplete",
+    ):
+        benchmark._runtime_selector_semantic_identity(
+            runtime_selectors,
+            color_coverage="complete",
+            helicity_coverage="complete",
+            artifact=Path("<test-profile>"),
+        )
+
+
+def test_color_axis_rejects_empty_physics_word() -> None:
+    identity = _artifact_semantic_identity()
+    color_axis = identity["physical_color_flows"]
+    assert isinstance(color_axis, dict)
+    entries = copy.deepcopy(color_axis["ordered_entries"])
+    entries[0]["word"] = []
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="not complete and ordered",
+    ):
+        benchmark._ordered_physical_axis(
+            entries,
+            label="color-flow",
+            require_structural_zero=False,
+        )
+
+
+def test_missing_reduction_order_identity_is_ineligible() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    del profiles["recurrence"]["artifact_semantic_identity"][
+        "reduction_ordering_sha256"
+    ]
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert not capture["artifact_semantic_contract"]["passes"]
+    assert not capture["authoritative_eligible"]
+    assert not capture["complete"]
+
+
+def test_eager_manifest_model_identity_mismatch_is_diagnostic_only() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    eager_identity = profiles["eager"]["artifact_semantic_identity"]
+    eager_model_identity = eager_identity["manifest_model_identity"]
+    eager_manifest_model = copy.deepcopy(eager_model_identity["manifest"])
+    eager_manifest_model["content_sha256"] = "d" * 64
+    eager_common_model = {
+        key: value
+        for key, value in eager_manifest_model.items()
+        if key != "source_kind"
+    }
+    eager_model_identity.update(
+        {
+            "manifest": eager_manifest_model,
+            "manifest_sha256": benchmark._canonical_sha256(eager_manifest_model),
+            "common_physics_identity": eager_common_model,
+            "common_physics_identity_sha256": benchmark._canonical_sha256(
+                eager_common_model
+            ),
+        }
+    )
+    profiles["eager"]["artifact_semantic_identity_sha256"] = (
+        benchmark._canonical_sha256(eager_identity)
+    )
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["artifact_semantic_contract"]["passes"] is True
+    assert capture["authoritative_eligible"] is True
+    eager_contract = capture["eager_diagnostic"]["artifact_semantic_contract"]
+    assert eager_contract["passes"] is False
+    assert eager_contract["lanes_match"] is False
+
+
+def test_eager_structural_zero_entry_mismatch_is_diagnostic_only() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    eager_identity = profiles["eager"]["artifact_semantic_identity"]
+    eager_helicities = eager_identity["physical_helicities"]
+    eager_entries = copy.deepcopy(eager_helicities["ordered_entries"])
+    eager_entries[1]["structural_zero"] = True
+    eager_helicities["ordered_entries"] = eager_entries
+    eager_helicities["ordered_entries_sha256"] = benchmark._canonical_sha256(
+        eager_entries
+    )
+    profiles["eager"]["artifact_semantic_identity_sha256"] = (
+        benchmark._canonical_sha256(eager_identity)
+    )
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["artifact_semantic_contract"]["passes"] is True
+    assert capture["authoritative_eligible"] is True
+    assert capture["eager_diagnostic"]["artifact_semantic_contract"]["passes"] is False
+
+
+def test_eager_reduction_order_mismatch_is_diagnostic_only() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    eager_identity = profiles["eager"]["artifact_semantic_identity"]
+    eager_reduction = copy.deepcopy(eager_identity["reduction_ordering"])
+    eager_reduction["pair_order_abi"] = "color-major-helicity-minor-v1"
+    eager_identity["reduction_ordering"] = eager_reduction
+    eager_identity["reduction_ordering_sha256"] = benchmark._canonical_sha256(
+        eager_reduction
+    )
+    profiles["eager"]["artifact_semantic_identity_sha256"] = (
+        benchmark._canonical_sha256(eager_identity)
+    )
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["artifact_semantic_contract"]["passes"] is True
+    assert capture["artifact_semantic_contract"]["lanes_match"] is True
+    assert capture["authoritative_eligible"] is True
+    eager_contract = capture["eager_diagnostic"]["artifact_semantic_contract"]
+    assert eager_contract["passes"] is False
+    assert eager_contract["lanes_match"] is False
+
+
+def test_reduction_members_must_map_to_the_group_representative() -> None:
+    identity = _artifact_semantic_identity()
+    logical_helicities = identity["physical_helicities"]["ordered_entries"]
+    logical_colors = identity["physical_color_flows"]["ordered_entries"]
+    helicity_entries = [
+        {
+            **entry,
+            "representative_id": logical_helicities[0]["id"],
+            "computed": index == 0,
+            "coefficient": 1.0,
+        }
+        for index, entry in enumerate(logical_helicities)
+    ]
+    helicity_entries[1]["computed"] = True
+    helicity_entries[1]["representative_id"] = "h:+1,-1"
+    helicity_axis = benchmark._ordered_physical_axis(
+        helicity_entries,
+        label="helicity",
+        require_structural_zero=True,
+    )
+    color_axis = benchmark._ordered_physical_axis(
+        [
+            {
+                **entry,
+                "representative_id": entry["id"],
+                "computed": True,
+                "coefficient": 1.0,
+            }
+            for entry in logical_colors
+        ],
+        label="color-flow",
+        require_structural_zero=False,
+    )
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="not closed over physical axes",
+    ):
+        benchmark._reduction_ordering_identity(
+            {
+                "kind": "lc-diagonal",
+                "groups": [
+                    {
+                        "id": "reduction:0",
+                        "physical_color_ids": ["flow:2,1"],
+                        "physical_helicity_ids": ["h:-1,+1", "h:+1,-1"],
+                        "representative_color_id": "flow:2,1",
+                        "representative_helicity_id": "h:-1,+1",
+                    }
+                ],
+            },
+            color_axis=color_axis,
+            helicity_axis=helicity_axis,
+            artifact=Path("<test-profile>"),
+        )
+
+
+@pytest.mark.parametrize(
+    ("computed", "representative_id", "structural_zero", "coefficient"),
+    (
+        (True, "h:-1,+1", False, 1.0),
+        (True, "h:+1,-1", True, 0.0),
+        (False, "h:-1,+1", False, 0.0),
+    ),
+)
+def test_helicity_axis_rejects_invalid_mapping_states(
+    computed: bool,
+    representative_id: str,
+    structural_zero: bool,
+    coefficient: float,
+) -> None:
+    helicity_axis = _artifact_semantic_identity()["physical_helicities"]
+    assert isinstance(helicity_axis, dict)
+    logical_entries = copy.deepcopy(helicity_axis["ordered_entries"])
+    entries = [
+        {
+            **entry,
+            "representative_id": logical_entries[0]["id"],
+            "computed": index == 0,
+            "coefficient": 1.0,
+        }
+        for index, entry in enumerate(logical_entries)
+    ]
+    assert isinstance(entries, list)
+    assert isinstance(entries[1], dict)
+    entries[1].update(
+        {
+            "computed": computed,
+            "representative_id": representative_id,
+            "structural_zero": structural_zero,
+            "coefficient": coefficient,
+        }
+    )
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="representative mapping is not closed",
+    ):
+        benchmark._ordered_physical_axis(
+            entries,
+            label="helicity",
+            require_structural_zero=True,
+        )
+
+
+def test_eager_execution_reduction_coverage_is_diagnostic_only() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    eager_identity = profiles["eager"]["artifact_semantic_identity"]
+    eager_identity["execution_reduction_coverage"] = {
+        "complete": False,
+        "expected_physical_pair_count": 2,
+        "observed_physical_pair_count": 1,
+        "errors": ["missing one execution pair"],
+    }
+    profiles["eager"]["artifact_semantic_identity_sha256"] = (
+        benchmark._canonical_sha256(eager_identity)
+    )
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["artifact_semantic_contract"]["passes"] is True
+    eager_contract = capture["eager_diagnostic"]["artifact_semantic_contract"]
+    assert eager_contract["passes"] is False
+    assert any(
+        "model/selector/reduction semantic identity is invalid" in error
+        for error in eager_contract["errors"]
+    )
+    assert capture["authoritative_eligible"] is True
+
+
+def test_execution_reduction_summary_is_revalidated() -> None:
+    profiles = _passing_profiles()
+    eager_profile = profiles["eager"]
+    eager_identity = eager_profile["artifact_semantic_identity"]
+    eager_identity["execution_reduction_identity"] = {
+        "kind": "forged-reduction",
+    }
+    eager_identity["execution_reduction_identity_sha256"] = benchmark._canonical_sha256(
+        eager_identity["execution_reduction_identity"]
+    )
+    eager_profile["artifact_semantic_identity_sha256"] = benchmark._canonical_sha256(
+        eager_identity
+    )
+
+    contract = benchmark._profile_artifact_semantic_contract(profiles)
+
+    assert contract["passes"] is False
+    assert any(
+        "model/selector/reduction semantic identity is invalid" in error
+        for error in contract["errors"]
+    )
+
+
+def test_complete_execution_reduction_coverage_rejects_impossible_counts() -> None:
+    profiles = _passing_profiles()
+    eager_profile = profiles["eager"]
+    eager_identity = eager_profile["artifact_semantic_identity"]
+    eager_identity["execution_reduction_coverage"] = {
+        "complete": True,
+        "expected_physical_pair_count": 1,
+        "observed_physical_pair_count": 1,
+        "errors": [],
+    }
+    eager_profile["artifact_semantic_identity_sha256"] = benchmark._canonical_sha256(
+        eager_identity
+    )
+
+    contract = benchmark._profile_artifact_semantic_contract(profiles)
+
+    assert contract["passes"] is False
+
+
+def test_capture_rejects_missing_or_interrupted_timing_measurements() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    profiles["eager"]["profiles"] = profiles["eager"]["profiles"][1:]
+    profiles["recurrence"]["profiles"][0]["interrupted"] = True
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert not capture["complete"]
+    assert capture["passes"] is None
+    contract = capture["measurement_contract"]["lanes"]
+    assert not contract["recurrence"]["passes"]
+    eager_contract = capture["eager_diagnostic"]["measurement_contract"]["lanes"]
+    assert eager_contract["eager"]["missing_batch_sizes"] == [1]
+
+
+def test_single_worker_five_sample_timing_cannot_pass_authoritative_capture() -> None:
+    arguments = _arguments(
+        "--subprocess-samples",
+        "1",
+        "--minimum-samples",
+        "5",
+    )
+    schedule = _passing_schedule(subprocess_samples=1)
+    profiles = _passing_profiles(schedule)
+    for profile in profiles.values():
+        for measurement in profile["profiles"]:
+            measurement["subprocess_samples"][0]["internal_sample_count"] = 5
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert not capture["complete"]
+    contract = capture["measurement_contract"]
+    assert not contract["passes"]
+    assert contract["configured_subprocess_samples"] == 1
+    assert contract["configured_internal_minimum_samples"] == 5
+
+
+def test_aggregate_headline_sample_count_must_match_inventory() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    profiles["compiled"]["profiles"][0]["sample_count"] = False
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is False
+    assert capture["measurement_contract"]["passes"] is False
+
+
+@pytest.mark.parametrize(
+    "failure",
+    (
+        "native_wall",
+        "warmup",
+        "internal_samples",
+        "repetitions",
+        "evaluation_count",
+        "raw_blocks",
+        "worker_result_binding",
+        "median_mad",
+        "schedule",
+        "result_record",
+    ),
+)
+def test_authoritative_timing_contract_fails_closed(
+    failure: str,
+) -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    measurement = profiles["compiled"]["profiles"][0]
+    first_sample = measurement["subprocess_samples"][0]
+    if failure == "native_wall":
+        first_sample["timing_sources"]["wall"] = "runtime_evaluate_wall_time"
+    elif failure == "warmup":
+        first_sample["timing_configuration"]["warmup_runs"] = 0
+    elif failure == "internal_samples":
+        first_sample["internal_sample_count"] = 6
+    elif failure == "repetitions":
+        first_sample["repetitions_per_sample"] = 0
+    elif failure == "evaluation_count":
+        first_sample["evaluation_count"] = 0
+    elif failure == "raw_blocks":
+        first_sample["inner_native_wall_blocks"]["blocks"][0][
+            "native_wall_seconds"
+        ] *= 2.0
+    elif failure == "worker_result_binding":
+        raw_blocks = first_sample["inner_native_wall_blocks"]
+        block = raw_blocks["blocks"][0]
+        block["started_at_utc"] = "2026-07-24T00:00:00.5+00:00"
+        block["content_sha256"] = benchmark._canonical_sha256(
+            {key: value for key, value in block.items() if key != "content_sha256"}
+        )
+        raw_blocks["blocks_sha256"] = benchmark._canonical_sha256(raw_blocks["blocks"])
+    elif failure == "median_mad":
+        measurement["wall_seconds_per_point_mad"] = None
+    elif failure == "schedule":
+        entries = schedule["entries"]
+        assert isinstance(entries, list)
+        del entries[0]["worker_invocation"]
+    else:
+        entries = schedule["entries"]
+        assert isinstance(entries, list)
+        entries[0]["worker_result_record"]["recorded_at_utc"] = (
+            "2026-07-24T00:00:02+00:00"
+        )
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert not capture["complete"]
+    assert not capture["measurement_contract"]["passes"]
+
+
+def test_raw_block_boolean_counts_fail_even_when_readdressed() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    sample = profiles["compiled"]["profiles"][0]["subprocess_samples"][0]
+    raw_blocks = sample["inner_native_wall_blocks"]
+    block = raw_blocks["blocks"][0]
+    for field in (
+        "repetitions",
+        "batch_size",
+        "evaluation_count",
+        "evaluated_point_count",
+    ):
+        block[field] = True
+    block["content_sha256"] = benchmark._canonical_sha256(
+        {key: value for key, value in block.items() if key != "content_sha256"}
+    )
+    raw_blocks["blocks_sha256"] = benchmark._canonical_sha256(raw_blocks["blocks"])
+    _rebind_sample_result(schedule, sample)
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is False
+    assert any(
+        "raw block content address is invalid" in error
+        for error in capture["measurement_contract"]["lanes"]["compiled"]["errors"]
+    )
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("repetitions_per_block", True),
+        ("evaluation_count", 7.0),
+        ("evaluated_point_count", 7.0),
+    ),
+)
+def test_raw_inventory_counts_require_positive_integers_when_readdressed(
+    field: str,
+    value: object,
+) -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    sample = profiles["compiled"]["profiles"][0]["subprocess_samples"][0]
+    raw_blocks = sample["inner_native_wall_blocks"]
+    raw_blocks[field] = value
+    _rebind_sample_result(schedule, sample)
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is False
+    assert any(
+        "raw native-wall inventory is invalid" in error
+        for error in capture["measurement_contract"]["lanes"]["compiled"]["errors"]
+    )
+
+
+def test_raw_inventory_mad_rejects_boolean_when_readdressed() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    sample = profiles["compiled"]["profiles"][0]["subprocess_samples"][0]
+    raw_blocks = sample["inner_native_wall_blocks"]
+    raw_blocks["wall_seconds_per_point_mad"] = False
+    _rebind_sample_result(schedule, sample)
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is False
+    assert any(
+        "raw native-wall inventory is invalid" in error
+        for error in capture["measurement_contract"]["lanes"]["compiled"]["errors"]
+    )
+
+
+def test_retained_native_wall_duration_below_target_fails_when_readdressed() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    sample = profiles["compiled"]["profiles"][0]["subprocess_samples"][0]
+    raw_blocks = sample["inner_native_wall_blocks"]
+    raw_blocks["observed_native_wall_seconds"] = 4.999
+    raw_blocks["minimum_duration_satisfied"] = True
+    _rebind_sample_result(schedule, sample)
+
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+
+    assert capture["complete"] is False
+    assert any(
+        "raw native-wall inventory is invalid" in error
+        for error in capture["measurement_contract"]["lanes"]["compiled"]["errors"]
+    )
+
+
+def test_retained_raw_calibration_tampering_fails_when_readdressed() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    sample = profiles["compiled"]["profiles"][0]["subprocess_samples"][0]
+    raw_blocks = sample["inner_native_wall_blocks"]
+    raw_blocks["calibration"]["duration_headroom_factor"] = 1.01
+    _rebind_sample_result(schedule, sample)
+
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+
+    assert capture["complete"] is False
+    assert any(
+        "raw native-wall inventory is invalid" in error
+        for error in capture["measurement_contract"]["lanes"]["compiled"]["errors"]
+    )
+
+
+def test_raw_inventory_schema_rejects_boolean_when_readdressed() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    sample = profiles["compiled"]["profiles"][0]["subprocess_samples"][0]
+    raw_blocks = sample["inner_native_wall_blocks"]
+    raw_blocks["schema_version"] = True
+    _rebind_sample_result(schedule, sample)
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is False
+    assert any(
+        "raw native-wall inventory is invalid" in error
+        for error in capture["measurement_contract"]["lanes"]["compiled"]["errors"]
+    )
+
+
+def test_raw_block_timestamps_must_be_chronological_when_readdressed() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    sample = profiles["compiled"]["profiles"][0]["subprocess_samples"][0]
+    raw_blocks = sample["inner_native_wall_blocks"]
+    block = raw_blocks["blocks"][0]
+    block["started_at_utc"] = "2026-07-24T00:00:02+00:00"
+    block["content_sha256"] = benchmark._canonical_sha256(
+        {key: value for key, value in block.items() if key != "content_sha256"}
+    )
+    raw_blocks["blocks_sha256"] = benchmark._canonical_sha256(raw_blocks["blocks"])
+    _rebind_sample_result(schedule, sample)
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is False
+    assert any(
+        "raw block content address is invalid" in error
+        for error in capture["measurement_contract"]["lanes"]["compiled"]["errors"]
+    )
+
+
+def test_raw_block_inventory_must_be_chronological_when_readdressed() -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    sample = profiles["compiled"]["profiles"][0]["subprocess_samples"][0]
+    raw_blocks = sample["inner_native_wall_blocks"]
+    first, second = raw_blocks["blocks"][:2]
+    first["started_at_utc"] = "2026-07-24T00:00:00.800000+00:00"
+    first["finished_at_utc"] = "2026-07-24T00:00:00.900000+00:00"
+    second["started_at_utc"] = "2026-07-24T00:00:00.100000+00:00"
+    second["finished_at_utc"] = "2026-07-24T00:00:00.200000+00:00"
+    for block in (first, second):
+        block["content_sha256"] = benchmark._canonical_sha256(
+            {key: value for key, value in block.items() if key != "content_sha256"}
+        )
+    raw_blocks["blocks_sha256"] = benchmark._canonical_sha256(raw_blocks["blocks"])
+    _rebind_sample_result(schedule, sample)
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is False
+    assert any(
+        "raw block content address is invalid" in error
+        for error in capture["measurement_contract"]["lanes"]["compiled"]["errors"]
+    )
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("minimum_internal_samples", 0),
+        ("warmup_runs", True),
+        ("target_runtime_seconds", -1.0),
+    ),
+)
+def test_retained_timing_configuration_must_match_cli(
+    field: str,
+    value: object,
+) -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    sample = profiles["compiled"]["profiles"][0]["subprocess_samples"][0]
+    sample["timing_configuration"][field] = value
+    _rebind_sample_result(schedule, sample)
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is False
+    assert any(
+        "is not warmed" in error
+        for error in capture["measurement_contract"]["lanes"]["compiled"]["errors"]
+    )
+
+
+@pytest.mark.parametrize(
+    "contradiction",
+    (
+        "round",
+        "measurement_batch",
+        "worker_command",
+        "verified_at",
+        "effective_contract",
+    ),
+)
+def test_retained_sample_contradictions_fail_after_readdressing(
+    contradiction: str,
+) -> None:
+    arguments = _arguments()
+    schedule = _passing_schedule()
+    profiles = _passing_profiles(schedule)
+    sample = profiles["compiled"]["profiles"][0]["subprocess_samples"][0]
+    if contradiction == "round":
+        sample["round"] = False
+    elif contradiction == "measurement_batch":
+        sample["worker_measurement"]["batch_size"] = True
+    elif contradiction == "worker_command":
+        sample["worker_command"] = benchmark._command_identity(("forged-worker",))
+    elif contradiction == "verified_at":
+        sample["pre_timing_verification"]["verified_at_utc"] = "not-a-time"
+    else:
+        sample["pre_timing_verification"]["effective_contract"] = {
+            "execution_mode": "eager",
+            "backend": "not-jit",
+        }
+    _rebind_sample_result(schedule, sample)
+    summary = benchmark._pairwise_profile_validation(profiles)
+    capture = benchmark._capture_acceptance(
+        arguments,
+        profiles,
+        summary,
+        profile_schedule=schedule,
+    )
+    assert capture["complete"] is False
+    assert capture["measurement_contract"]["passes"] is False
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("schedule_index", False),
+        ("round", False),
+        ("batch_size", True),
+    ),
+)
+def test_profile_schedule_rejects_boolean_slot_coordinates(
+    field: str,
+    value: object,
+) -> None:
+    schedule = _passing_schedule()
+    entries = schedule["entries"]
+    assert isinstance(entries, list)
+    entries[0][field] = value
+    contract = benchmark._profile_schedule_contract(
+        schedule,
+        modes=benchmark.EXECUTION_MODES,
+        batch_sizes=benchmark.DEFAULT_BATCH_SIZES,
+        subprocess_samples=benchmark.MIN_AUTHORITATIVE_SAMPLES,
+    )
+    assert contract["passes"] is False
+    assert any("invalid slot coordinates" in error for error in contract["errors"])
+
+
+@pytest.mark.parametrize("record_kind", ("verification", "result"))
+def test_profile_schedule_rejects_boolean_nested_schema_versions(
+    record_kind: str,
+) -> None:
+    schedule = _passing_schedule()
+    entries = schedule["entries"]
+    assert isinstance(entries, list)
+    entry = entries[0]
+    if record_kind == "verification":
+        entry["pre_timing_verification"]["schema_version"] = True
+    else:
+        result_record = entry["worker_result_record"]
+        result_record["schema_version"] = True
+        result_record["content_sha256"] = benchmark._canonical_sha256(
+            {
+                key: value
+                for key, value in result_record.items()
+                if key != "content_sha256"
+            }
+        )
+    contract = benchmark._profile_schedule_contract(
+        schedule,
+        modes=benchmark.EXECUTION_MODES,
+        batch_sizes=benchmark.DEFAULT_BATCH_SIZES,
+        subprocess_samples=benchmark.MIN_AUTHORITATIVE_SAMPLES,
+    )
+    assert contract["passes"] is False
+
+
+def test_profile_schedule_timestamps_must_be_chronological() -> None:
+    schedule = _passing_schedule()
+    entries = schedule["entries"]
+    assert isinstance(entries, list)
+    entry = entries[0]
+    invocation = entry["worker_invocation"]
+    invocation["started_at_utc"] = "2026-07-24T00:00:02+00:00"
+    invocation["content_sha256"] = benchmark._canonical_sha256(
+        {key: value for key, value in invocation.items() if key != "content_sha256"}
+    )
+    result_record = entry["worker_result_record"]
+    result_record["worker_invocation_sha256"] = invocation["content_sha256"]
+    result_record["content_sha256"] = benchmark._canonical_sha256(
+        {key: value for key, value in result_record.items() if key != "content_sha256"}
+    )
+    contract = benchmark._profile_schedule_contract(
+        schedule,
+        modes=benchmark.EXECUTION_MODES,
+        batch_sizes=benchmark.DEFAULT_BATCH_SIZES,
+        subprocess_samples=benchmark.MIN_AUTHORITATIVE_SAMPLES,
+    )
+    assert contract["passes"] is False
+    assert any(
+        "inverted invocation timestamps" in error for error in contract["errors"]
+    )
+
+
+def test_profile_schedule_rejects_reordered_noninterleaved_lanes() -> None:
+    schedule = _passing_schedule()
+    entries = schedule["entries"]
+    assert isinstance(entries, list)
+    entries[1]["mode"] = entries[0]["mode"]
+    contract = benchmark._profile_schedule_contract(
+        schedule,
+        modes=benchmark.EXECUTION_MODES,
+        batch_sizes=benchmark.DEFAULT_BATCH_SIZES,
+        subprocess_samples=benchmark.MIN_AUTHORITATIVE_SAMPLES,
+    )
+    assert not contract["passes"]
+    assert any("interleaved" in error for error in contract["errors"])
+
+
+def _write_source_checkout_markers(checkout: Path) -> None:
+    (checkout / ".git").mkdir(parents=True)
+    for marker in benchmark._SOURCE_CHECKOUT_FILE_MARKERS:
+        path = checkout / marker
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(f"fixture for {marker.as_posix()}\n", encoding="utf-8")
+
+
+def test_source_checkout_override_defaults_to_frozen_driver_root(
+    tmp_path: Path,
+) -> None:
+    driver_root = tmp_path / "workspace"
+    driver_root.mkdir()
+    assert (
+        benchmark._resolve_source_checkout_root(
+            driver_root=driver_root,
+            environment={},
+        )
+        == driver_root.resolve()
+    )
+
+
+def test_source_checkout_override_accepts_a_nested_source_worktree(
+    tmp_path: Path,
+) -> None:
+    driver_root = tmp_path / "workspace"
+    checkout = driver_root / ".artifacts" / "baseline" / "source-test"
+    driver_root.mkdir()
+    _write_source_checkout_markers(checkout)
+    assert (
+        benchmark._resolve_source_checkout_root(
+            driver_root=driver_root,
+            environment={
+                benchmark.SOURCE_CHECKOUT_OVERRIDE_ENV: str(checkout.resolve()),
+            },
+        )
+        == checkout.resolve()
+    )
+
+
+def test_source_checkout_override_fails_closed(
+    tmp_path: Path,
+) -> None:
+    driver_root = tmp_path / "workspace"
+    driver_root.mkdir()
+
+    with pytest.raises(benchmark.HarnessError, match="absolute source checkout"):
+        benchmark._resolve_source_checkout_root(
+            driver_root=driver_root,
+            environment={benchmark.SOURCE_CHECKOUT_OVERRIDE_ENV: ""},
+        )
+    with pytest.raises(benchmark.HarnessError, match="absolute path"):
+        benchmark._resolve_source_checkout_root(
+            driver_root=driver_root,
+            environment={benchmark.SOURCE_CHECKOUT_OVERRIDE_ENV: "baseline"},
+        )
+
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    with pytest.raises(benchmark.HarnessError, match="inside the driver workspace"):
+        benchmark._resolve_source_checkout_root(
+            driver_root=driver_root,
+            environment={
+                benchmark.SOURCE_CHECKOUT_OVERRIDE_ENV: str(outside.resolve()),
+            },
+        )
+
+    incomplete = driver_root / "incomplete"
+    incomplete.mkdir()
+    with pytest.raises(benchmark.HarnessError, match="not a pyAmpliCol source"):
+        benchmark._resolve_source_checkout_root(
+            driver_root=driver_root,
+            environment={
+                benchmark.SOURCE_CHECKOUT_OVERRIDE_ENV: str(incomplete.resolve()),
+            },
+        )
+
+
+@pytest.mark.parametrize("status", (" M tracked.py\n", "?? scratch.py\n"))
+def test_source_identity_fails_closed_on_tracked_and_untracked_changes(
+    monkeypatch: pytest.MonkeyPatch,
+    status: str,
+) -> None:
+    commands: list[tuple[str, ...]] = []
+    results = iter(
+        (
+            SimpleNamespace(returncode=0, stdout="a" * 40 + "\n"),
+            SimpleNamespace(returncode=0, stdout=status),
+        )
+    )
+
+    def run(command: tuple[str, ...], **_kwargs: object) -> object:
+        commands.append(command)
+        return next(results)
+
+    monkeypatch.setattr(benchmark.subprocess, "run", run)
+    with pytest.raises(benchmark.HarnessError, match="source is dirty"):
+        benchmark._git_source_identity()
+    assert commands[1] == (
+        "git",
+        "status",
+        "--porcelain=v1",
+        "--untracked-files=all",
+    )
+
+
+def test_source_identity_accepts_only_a_full_clean_revision(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    results = iter(
+        (
+            SimpleNamespace(returncode=0, stdout="a" * 40 + "\n"),
+            SimpleNamespace(returncode=0, stdout=""),
+        )
+    )
+    monkeypatch.setattr(
+        benchmark.subprocess,
+        "run",
+        lambda *args, **kwargs: next(results),
+    )
+    identity = benchmark._git_source_identity()
+    assert identity["revision"] == "a" * 40
+    assert identity["dirty"] is False
+    assert identity["untracked_files_checked"] is True
+
+
+def test_source_identity_uses_the_selected_checkout(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    checkout = tmp_path / "selected"
+    checkout.mkdir()
+    calls: list[tuple[tuple[str, ...], Path]] = []
+    results = iter(
+        (
+            SimpleNamespace(returncode=0, stdout="a" * 40 + "\n"),
+            SimpleNamespace(returncode=0, stdout=""),
+        )
+    )
+
+    def run(command: tuple[str, ...], **kwargs: object) -> object:
+        cwd = kwargs.get("cwd")
+        assert isinstance(cwd, Path)
+        calls.append((command, cwd))
+        return next(results)
+
+    monkeypatch.setattr(benchmark, "ROOT", checkout)
+    monkeypatch.setattr(benchmark.subprocess, "run", run)
+    identity = benchmark._git_source_identity()
+
+    assert identity["checkout"] == str(checkout.resolve())
+    assert [cwd for _command, cwd in calls] == [checkout, checkout]
+
+
+def test_worker_keeps_frozen_driver_and_inherits_checkout_override(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    checkout = tmp_path / "selected"
+    checkout.mkdir()
+    override = str(checkout.resolve())
+    captured: dict[str, object] = {}
+
+    def run(command: tuple[str, ...], **kwargs: object) -> object:
+        captured["command"] = command
+        captured.update(kwargs)
+        return SimpleNamespace(returncode=0, stdout="", stderr=None)
+
+    monkeypatch.setattr(benchmark, "ROOT", checkout)
+    monkeypatch.setenv(benchmark.SOURCE_CHECKOUT_OVERRIDE_ENV, override)
+    monkeypatch.setattr(benchmark.subprocess, "run", run)
+    with pytest.raises(benchmark.HarnessError, match="did not emit a JSON result"):
+        benchmark._run_worker(
+            ("generate",),
+            mode="recurrence",
+            phase="generation",
+            timeout_seconds=1.0,
+        )
+
+    command = captured["command"]
+    environment = captured["env"]
+    assert isinstance(command, tuple)
+    assert isinstance(environment, dict)
+    assert command[:3] == (
+        sys.executable,
+        str(benchmark.DRIVER_PATH),
+        "_worker",
+    )
+    assert command[1] != str(
+        checkout / "tools" / "developer" / "recurrence_z6g_benchmark.py"
+    )
+    assert captured["cwd"] == checkout
+    assert environment[benchmark.SOURCE_CHECKOUT_OVERRIDE_ENV] == override
+
+
+def test_path_state_identity_records_optional_absence(tmp_path: Path) -> None:
+    missing = tmp_path / "candidate-Cargo.lock"
+    absent = benchmark._path_state_identity(missing)
+    assert absent == {
+        "present": False,
+        "path": str(missing),
+        "resolved_path": str(missing.resolve()),
+    }
+
+    missing.write_bytes(b"candidate lock")
+    present = benchmark._path_state_identity(missing)
+    assert present["present"] is True
+    assert present["size_bytes"] == len(b"candidate lock")
+    assert present["sha256"] == hashlib.sha256(b"candidate lock").hexdigest()
+
+
+def _build_info(
+    checkout: Path,
+    *,
+    revision: object = "a" * 40,
+    digest: object = "b" * 64,
+) -> dict[str, object]:
+    return {
+        "source_checkout": str(checkout),
+        "source_revision": revision,
+        "native_build_inputs_sha256": digest,
+    }
+
+
+def test_runtime_binding_requires_clean_matching_source_revision(
+    tmp_path: Path,
+) -> None:
+    source = {
+        "checkout": str(tmp_path),
+        "revision": "a" * 40,
+    }
+    benchmark._validate_runtime_binding(
+        source,
+        _build_info(tmp_path),
+        native_build_inputs_sha256="b" * 64,
+    )
+
+    with pytest.raises(benchmark.HarnessError, match="no clean source revision"):
+        benchmark._validate_runtime_binding(
+            source,
+            _build_info(tmp_path, revision=None),
+            native_build_inputs_sha256="b" * 64,
+        )
+    with pytest.raises(benchmark.HarnessError, match="does not match benchmark HEAD"):
+        benchmark._validate_runtime_binding(
+            source,
+            _build_info(tmp_path, revision="c" * 40),
+            native_build_inputs_sha256="b" * 64,
+        )
+    with pytest.raises(benchmark.HarnessError, match="build inputs"):
+        benchmark._validate_runtime_binding(
+            source,
+            _build_info(tmp_path, digest="c" * 64),
+            native_build_inputs_sha256="b" * 64,
+        )
+
+
+def test_runtime_binding_rejects_a_different_checkout(
+    tmp_path: Path,
+) -> None:
+    source_checkout = tmp_path / "source"
+    other_checkout = tmp_path / "other"
+    source_checkout.mkdir()
+    other_checkout.mkdir()
+    source = {
+        "checkout": str(source_checkout),
+        "revision": "a" * 40,
+    }
+    with pytest.raises(benchmark.HarnessError, match="different source checkout"):
+        benchmark._validate_runtime_binding(
+            source,
+            _build_info(other_checkout),
+            native_build_inputs_sha256="b" * 64,
+        )
+
+
+def test_expected_runtime_identity_is_externally_pinned() -> None:
+    source = {"revision": "a" * 40}
+    runtime = {
+        "native_extension": {
+            "build_inputs_sha256": "b" * 64,
+        }
+    }
+    benchmark._validate_expected_runtime_identity(
+        source,
+        runtime,
+        expected_source_revision="a" * 40,
+        expected_native_build_inputs_sha256="b" * 64,
+    )
+
+    with pytest.raises(benchmark.HarnessError, match="provided together"):
+        benchmark._validate_expected_runtime_identity(
+            source,
+            runtime,
+            expected_source_revision="a" * 40,
+            expected_native_build_inputs_sha256=None,
+        )
+    with pytest.raises(benchmark.HarnessError, match="externally pinned revision"):
+        benchmark._validate_expected_runtime_identity(
+            source,
+            runtime,
+            expected_source_revision="c" * 40,
+            expected_native_build_inputs_sha256="b" * 64,
+        )
+    with pytest.raises(benchmark.HarnessError, match="externally pinned build-input"):
+        benchmark._validate_expected_runtime_identity(
+            source,
+            runtime,
+            expected_source_revision="a" * 40,
+            expected_native_build_inputs_sha256="d" * 64,
+        )
+
+
+@pytest.mark.parametrize("field", benchmark._PROFILE_EXPECTATION_FIELDS)
+def test_profile_worker_rejects_each_identity_mismatch(field: str) -> None:
+    expected = {name: "a" * 64 for name in benchmark._PROFILE_EXPECTATION_FIELDS}
+    observed = dict(expected)
+    observed[field] = "b" * 64
+    with pytest.raises(benchmark.HarnessError, match="drifted before timing"):
+        benchmark._validate_profile_worker_expectations(expected, observed)
+
+
+def test_profile_worker_rejects_artifact_retarget_after_tree_rebind() -> None:
+    pinned_artifact_id = "a" * 64
+    replacement_runtime = SimpleNamespace(artifact_id="b" * 64)
+
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="loaded a different artifact",
+    ):
+        benchmark._loaded_runtime_artifact_verification(
+            replacement_runtime,
+            expected_artifact_id=pinned_artifact_id,
+            phase="after-native-load-before-timing",
+        )
+
+    accepted = benchmark._loaded_runtime_artifact_verification(
+        SimpleNamespace(artifact_id=pinned_artifact_id),
+        expected_artifact_id=pinned_artifact_id,
+        phase="after-native-load-before-timing",
+    )
+    benchmark._validate_loaded_runtime_artifact_verification(
+        accepted,
+        expected_artifact_id=pinned_artifact_id,
+        phase="after-native-load-before-timing",
+    )
+
+
+@pytest.mark.parametrize(
+    "drift",
+    ("source", "runtime", "artifact", "artifact-metadata"),
+)
+def test_driver_post_worker_recheck_rejects_identity_drift(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    drift: str,
+) -> None:
+    source = {"revision": "a" * 40, "checkout": str(tmp_path)}
+    runtime = {"native_extension": {"sha256": "b" * 64}}
+    semantic_identity = {"kind": "test-semantic-identity"}
+    artifact_identity = {
+        "path": str((tmp_path / "artifact").resolve()),
+        "artifact_id": "1" * 64,
+        "manifest": {
+            "resolved_path": str((tmp_path / "artifact" / "artifact.json").resolve()),
+            "size_bytes": 1,
+            "sha256": "2" * 64,
+        },
+        "tree": {
+            "algorithm": "sha256-relative-path-size-content-v1",
+            "sha256": "c" * 64,
+            "file_count": 1,
+            "size_bytes": 1,
+        },
+        "payloads": [],
+        "process_id": "process-1",
+        "process_expression": "d d~ > z g",
+        "color_accuracy": "lc",
+        "producer": {"name": "test"},
+        "model_identity": {"name": "test-model"},
+        "semantic_identity": semantic_identity,
+        "semantic_identity_sha256": benchmark._canonical_sha256(semantic_identity),
+    }
+    reuse_signature = {"semantic_signature_sha256": "d" * 64}
+    observed_source = dict(source)
+    observed_runtime = dict(runtime)
+    observed_artifact = dict(artifact_identity)
+    if drift == "source":
+        observed_source["revision"] = "e" * 40
+    elif drift == "runtime":
+        observed_runtime = {"native_extension": {"sha256": "e" * 64}}
+    else:
+        observed_artifact = copy.deepcopy(artifact_identity)
+        if drift == "artifact":
+            observed_artifact["tree"]["sha256"] = "e" * 64
+        else:
+            observed_artifact["path"] = str(
+                (tmp_path / "retargeted-artifact").resolve()
+            )
+    observed_artifact.pop("payloads", None)
+
+    monkeypatch.setattr(
+        benchmark,
+        "_git_source_identity",
+        lambda: observed_source,
+    )
+    monkeypatch.setattr(
+        benchmark,
+        "_runtime_provenance",
+        lambda _source: observed_runtime,
+    )
+    monkeypatch.setattr(
+        benchmark,
+        "_require_bound_reusable_artifact",
+        lambda *_args, **_kwargs: (
+            observed_artifact,
+            reuse_signature,
+            {"sha256": "f" * 64},
+        ),
+    )
+    baselines = {
+        "compiled": {
+            "artifact": str(tmp_path / "artifact"),
+            "generation_signature": {"kind": "generation"},
+            "artifact_identity": artifact_identity,
+            "reuse_signature": reuse_signature,
+            "reuse_sidecar_sha256": "f" * 64,
+        }
+    }
+    with pytest.raises(benchmark.HarnessError, match="drifted"):
+        benchmark._recheck_driver_state(
+            source,
+            runtime,
+            baselines,
+            phase="after-test-worker",
+        )
+
+
+def test_explicit_model_identity_is_accurate_and_not_builtin(
+    tmp_path: Path,
+) -> None:
+    prepared = tmp_path / "ufo-sm.pyamplicol-model"
+    prepared.write_bytes(b"explicit model")
+    arguments = _arguments("--prepared-model", str(prepared))
+    identity = benchmark._selected_model_identity(
+        arguments,
+        mode="compiled",
+        source_identity={"revision": "a" * 40},
+    )
+    assert identity["kind"] == "explicit-prepared-model"
+    assert identity["resource_id"] is None
+    assert identity["file"]["resolved_path"] == str(prepared.resolve())
+    assert identity["file"]["sha256"] == hashlib.sha256(b"explicit model").hexdigest()
+    benchmark._validate_worker_model_identity(
+        identity,
+        {
+            "kind": "explicit-prepared-model",
+            "resource_id": None,
+            "compile_excluded_from_generation": True,
+            "file": dict(identity["file"]),
+        },
+    )
+    changed_file = dict(identity["file"])
+    changed_file["sha256"] = "0" * 64
+    with pytest.raises(benchmark.HarnessError, match="disagrees on sha256"):
+        benchmark._validate_worker_model_identity(
+            identity,
+            {
+                "kind": "explicit-prepared-model",
+                "resource_id": None,
+                "compile_excluded_from_generation": True,
+                "file": changed_file,
+            },
+        )
+
+
+def _write_fake_artifact(path: Path) -> None:
+    path.mkdir()
+    payload = path / "payload.bin"
+    payload.write_bytes(b"payload")
+    payload_sha256 = hashlib.sha256(b"payload").hexdigest()
+    physics_path = path / "processes" / "process-1" / "physics.json"
+    physics_path.parent.mkdir(parents=True)
+    physics = {
+        "coverage": {
+            "color": "complete",
+            "helicities": "complete",
+        },
+        "color_components": [
+            {
+                "index": 0,
+                "id": "flow:2,1",
+                "kind": "lc-flow",
+                "word": [2, 1],
+                "representative_id": "flow:2,1",
+                "computed": True,
+                "coefficient": 1.0,
+            }
+        ],
+        "helicities": [
+            {
+                "index": 0,
+                "id": "h:-1,+1",
+                "values": [-1, 1],
+                "representative_id": "h:-1,+1",
+                "computed": True,
+                "coefficient": 1.0,
+                "structural_zero": False,
+            },
+            {
+                "index": 1,
+                "id": "h:+1,-1",
+                "values": [1, -1],
+                "representative_id": "h:-1,+1",
+                "computed": False,
+                "coefficient": 1.0,
+                "structural_zero": False,
+            },
+        ],
+        "extensions": {
+            "normalization": {
+                "average_factor": 36,
+                "color_factor": 3,
+                "coupling_policy": "stage-local",
+            },
+            "runtime_selectors": {
+                "kind": "pyamplicol-runtime-selectors",
+                "contract_version": 1,
+                "generation_specialized_axes": [],
+                "axes": {
+                    "color_flow": {
+                        "generation_coverage": "complete",
+                        "generation_selection": [],
+                        "runtime_contract": "complete-reusable",
+                    },
+                    "helicity": {
+                        "generation_coverage": "complete",
+                        "generation_selection": {},
+                        "runtime_contract": "complete-reusable",
+                    },
+                },
+            },
+        },
+        "reduction": {
+            "kind": "lc-diagonal",
+            "groups": [
+                {
+                    "id": "reduction:0",
+                    "physical_color_ids": ["flow:2,1"],
+                    "physical_helicity_ids": ["h:-1,+1", "h:+1,-1"],
+                    "representative_color_id": "flow:2,1",
+                    "representative_helicity_id": "h:-1,+1",
+                }
+            ],
+        },
+    }
+    physics_path.write_text(json.dumps(physics, sort_keys=True), encoding="utf-8")
+    manifest = {
+        "artifact_id": "artifact-1",
+        "producer": {"name": "test"},
+        "model": {
+            "name": "built-in-sm",
+            "content_sha256": "c" * 64,
+            "compiled_schema_version": 9,
+            "restriction": None,
+            "source_kind": "compiled-model",
+        },
+        "extensions": {
+            "generation": {
+                "concrete_processes": [
+                    {
+                        "id": "process-1",
+                        "runtime_schema_sha256": "a" * 64,
+                        "reduction_schedule": "manifest-order",
+                    }
+                ]
+            }
+        },
+        "processes": [
+            {
+                "id": "process-1",
+                "expression": "d d~ > z g",
+                "color_accuracy": "lc",
+                "physics_path": "processes/process-1/physics.json",
+            }
+        ],
+        "payloads": [
+            {
+                "path": "payload.bin",
+                "size_bytes": len(b"payload"),
+                "sha256": payload_sha256,
+                "role": "runtime",
+                "process_id": "process-1",
+            },
+            {
+                "path": "processes/process-1/physics.json",
+                "size_bytes": physics_path.stat().st_size,
+                "sha256": hashlib.sha256(physics_path.read_bytes()).hexdigest(),
+                "role": "physics",
+                "process_id": "process-1",
+            },
+        ],
+    }
+    (path / "artifact.json").write_text(
+        json.dumps(manifest, sort_keys=True),
+        encoding="utf-8",
+    )
+
+
+def test_logical_axis_projection_ignores_execution_representatives() -> None:
+    physical = [
+        {
+            "index": 0,
+            "id": "flow:2,1",
+            "kind": "lc-flow",
+            "word": [2, 1],
+            "coefficient": 1.0,
+        },
+        {
+            "index": 1,
+            "id": "flow:1,2",
+            "kind": "lc-flow",
+            "word": [1, 2],
+            "coefficient": 1.0,
+        },
+    ]
+    quotient = [
+        {
+            **entry,
+            "computed": index == 0,
+            "representative_id": physical[0]["id"],
+        }
+        for index, entry in enumerate(physical)
+    ]
+    materialized = [
+        {
+            **entry,
+            "computed": True,
+            "representative_id": entry["id"],
+        }
+        for entry in physical
+    ]
+
+    quotient_axis = benchmark._logical_physical_axis(
+        benchmark._ordered_physical_axis(
+            quotient,
+            label="color-flow",
+            require_structural_zero=False,
+        ),
+        require_structural_zero=False,
+    )
+    materialized_axis = benchmark._logical_physical_axis(
+        benchmark._ordered_physical_axis(
+            materialized,
+            label="color-flow",
+            require_structural_zero=False,
+        ),
+        require_structural_zero=False,
+    )
+
+    assert quotient_axis == materialized_axis
+    assert all(
+        "computed" not in entry and "representative_id" not in entry
+        for entry in quotient_axis["ordered_entries"]
+    )
+
+
+@pytest.mark.parametrize(
+    "descriptor_key",
+    ("native_reduction_groups", "recurrence_runtime_reduction"),
+)
+def test_expanded_reduction_rejects_reserved_native_descriptor_presence(
+    tmp_path: Path,
+    descriptor_key: str,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_fake_artifact(artifact)
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process = manifest["processes"][0]
+    physics_path = artifact / process["physics_path"]
+    physics = json.loads(physics_path.read_text(encoding="utf-8"))
+    physics["extensions"][descriptor_key] = None
+    physics_path.write_text(json.dumps(physics, sort_keys=True), encoding="utf-8")
+
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="expanded reduction duplicates a native descriptor",
+    ):
+        benchmark._artifact_semantic_identity(artifact, manifest, process)
+
+
+@pytest.mark.parametrize(
+    ("descriptor_key", "descriptor", "error"),
+    [
+        (
+            "native_reduction_groups",
+            {
+                "kind": "pyamplicol-eager-plan-v3-reduction-groups",
+                "schema_version": 1,
+                "storage_abi": "pacbin-v1",
+                "runtime_layout_abi": "pyamplicol-eager-runtime-layout-v1",
+                "container_path": "eager-runtime.pacbin",
+                "group_member": "reductions/groups.bin",
+                "entry_member": "reductions/entries.bin",
+                "group_count": 1,
+            },
+            "could not authenticate compact eager reduction",
+        ),
+        (
+            "recurrence_runtime_reduction",
+            {
+                "kind": "pyamplicol-recurrence-native-reduction-v2",
+                "runtime_layout_abi": "pyamplicol-recurrence-runtime-layout-v2",
+                "container_path": "recurrence-runtime.pacbin",
+                "plan_member_path": "schedule/recurrence-direct-schedule-v2.bin",
+            },
+            "could not authenticate compact recurrence reduction",
+        ),
+    ],
+)
+def test_compact_reduction_missing_native_payload_fails_closed(
+    tmp_path: Path,
+    descriptor_key: str,
+    descriptor: dict[str, object],
+    error: str,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_fake_artifact(artifact)
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process = manifest["processes"][0]
+    physics_path = artifact / process["physics_path"]
+    physics = json.loads(physics_path.read_text(encoding="utf-8"))
+    physics["reduction"]["groups"] = []
+    physics["extensions"][descriptor_key] = descriptor
+    physics_path.write_text(json.dumps(physics, sort_keys=True), encoding="utf-8")
+
+    with pytest.raises(benchmark.HarnessError, match=error):
+        benchmark._artifact_semantic_identity(artifact, manifest, process)
+
+
+def test_compact_eager_reduction_is_authenticated_and_logically_complete(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_fake_artifact(artifact)
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process = manifest["processes"][0]
+    physics_path = artifact / process["physics_path"]
+    physics = json.loads(physics_path.read_text(encoding="utf-8"))
+    groups = physics["reduction"]["groups"]
+    physics["reduction"]["groups"] = []
+    physics["extensions"]["native_reduction_groups"] = {
+        "kind": "pyamplicol-eager-plan-v3-reduction-groups",
+        "schema_version": 1,
+        "storage_abi": "pacbin-v1",
+        "runtime_layout_abi": "pyamplicol-eager-runtime-layout-v1",
+        "container_path": "eager-runtime.pacbin",
+        "group_member": "reductions/groups.bin",
+        "entry_member": "reductions/entries.bin",
+        "group_count": 1,
+    }
+    physics_path.write_text(json.dumps(physics, sort_keys=True), encoding="utf-8")
+    monkeypatch.setattr(
+        benchmark,
+        "_load_compact_eager_reduction_groups",
+        lambda _artifact, _process_id: groups,
+    )
+
+    identity = benchmark._artifact_semantic_identity(artifact, manifest, process)
+
+    assert identity["reduction_coverage"]["complete"] is True
+    assert identity["execution_reduction_coverage"]["complete"] is True
+    assert identity["execution_reduction_identity"]["kind"] == (
+        "eager-plan-v3-pacbin-reduction-v1"
+    )
+
+    physics["extensions"]["native_reduction_groups"]["group_count"] = 0
+    physics_path.write_text(json.dumps(physics, sort_keys=True), encoding="utf-8")
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="compact eager reduction descriptor is invalid",
+    ):
+        benchmark._artifact_semantic_identity(artifact, manifest, process)
+
+
+def test_compact_recurrence_reduction_binds_complete_public_replay(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_fake_artifact(artifact)
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process = manifest["processes"][0]
+    physics_path = artifact / process["physics_path"]
+    physics = json.loads(physics_path.read_text(encoding="utf-8"))
+    physics["reduction"]["groups"] = []
+    physics["extensions"]["recurrence_runtime_reduction"] = {
+        "kind": "pyamplicol-recurrence-native-reduction-v2",
+        "runtime_layout_abi": "pyamplicol-recurrence-runtime-layout-v2",
+        "container_path": "recurrence-runtime.pacbin",
+        "plan_member_path": "schedule/recurrence-direct-schedule-v2.bin",
+    }
+    physics_path.write_text(json.dumps(physics, sort_keys=True), encoding="utf-8")
+    sections = SimpleNamespace(
+        strategy="topology-replay",
+        semantic_digest="a" * 64,
+        runtime_layout_digest="b" * 64,
+        public_flow_ids=(0,),
+        resolved_helicities=(
+            SimpleNamespace(public_helicity_start=0, public_helicity_count=2),
+            SimpleNamespace(public_helicity_start=2, public_helicity_count=2),
+        ),
+        public_helicities=(-1, 1, 1, -1),
+        replay_targets=(SimpleNamespace(public_flow_id=0),),
+        amplitude_destination_count=2,
+        replay_helicity_map=(0, 1),
+        amplitude_destinations=(
+            SimpleNamespace(target_sector_id=0, target_helicity_id=0),
+            SimpleNamespace(target_sector_id=0, target_helicity_id=1),
+        ),
+    )
+    monkeypatch.setattr(
+        benchmark,
+        "_load_compact_recurrence_reduction",
+        lambda _artifact, _process_id: sections,
+    )
+
+    identity = benchmark._artifact_semantic_identity(artifact, manifest, process)
+
+    assert identity["reduction_coverage"] == {
+        "complete": True,
+        "expected_physical_pair_count": 2,
+        "observed_physical_pair_count": 2,
+        "errors": [],
+    }
+    assert identity["execution_reduction_identity"]["kind"] == (
+        "recurrence-plan-v2-pacbin-reduction-v1"
+    )
+
+    sections.replay_helicity_map = (0,)
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="compact recurrence reduction coverage is incomplete",
+    ):
+        benchmark._artifact_semantic_identity(artifact, manifest, process)
+
+
+def test_compact_recurrence_union_accepts_folded_public_flow_bindings(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_fake_artifact(artifact)
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process = manifest["processes"][0]
+    physics_path = artifact / process["physics_path"]
+    physics = json.loads(physics_path.read_text(encoding="utf-8"))
+    physics["color_components"].append(
+        {
+            "index": 1,
+            "id": "flow:1,2",
+            "kind": "lc-flow",
+            "word": [1, 2],
+            "representative_id": "flow:1,2",
+            "computed": True,
+            "coefficient": 1.0,
+        }
+    )
+    physics["reduction"]["groups"] = []
+    physics["extensions"]["recurrence_runtime_reduction"] = {
+        "kind": "pyamplicol-recurrence-native-reduction-v2",
+        "runtime_layout_abi": "pyamplicol-recurrence-runtime-layout-v2",
+        "container_path": "recurrence-runtime.pacbin",
+        "plan_member_path": "schedule/recurrence-direct-schedule-v2.bin",
+    }
+    physics_path.write_text(json.dumps(physics, sort_keys=True), encoding="utf-8")
+    sections = SimpleNamespace(
+        strategy="all-flow-union",
+        semantic_digest="a" * 64,
+        runtime_layout_digest="b" * 64,
+        public_flow_ids=(0, 0),
+        resolved_helicities=(
+            SimpleNamespace(public_helicity_start=0, public_helicity_count=2),
+            SimpleNamespace(public_helicity_start=2, public_helicity_count=2),
+        ),
+        public_helicities=(-1, 1, 1, -1),
+        replay_targets=(),
+        amplitude_destination_count=1,
+        replay_helicity_map=(),
+        amplitude_destinations=(
+            SimpleNamespace(target_sector_id=0, target_helicity_id=(2**32 - 1)),
+        ),
+    )
+    monkeypatch.setattr(
+        benchmark,
+        "_load_compact_recurrence_reduction",
+        lambda _artifact, _process_id: sections,
+    )
+
+    identity = benchmark._artifact_semantic_identity(artifact, manifest, process)
+    execution = identity["execution_reduction_identity"]
+
+    assert identity["execution_reduction_coverage"] == {
+        "complete": True,
+        "expected_physical_pair_count": 4,
+        "observed_physical_pair_count": 4,
+        "errors": [],
+    }
+    assert execution["public_flow_binding_count"] == 2
+    assert execution["construction_sector_count"] == 1
+    assert execution["amplitude_destination_count"] == 1
+    benchmark._validate_execution_reduction_summary(
+        execution,
+        identity["execution_reduction_coverage"],
+        logical_reduction=identity["reduction_ordering"],
+        artifact=artifact,
+    )
+
+    forged_execution = copy.deepcopy(execution)
+    forged_execution["replay_helicity_map_sha256"] = "f" * 64
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="compact recurrence execution reduction summary is invalid",
+    ):
+        benchmark._validate_execution_reduction_summary(
+            forged_execution,
+            identity["execution_reduction_coverage"],
+            logical_reduction=identity["reduction_ordering"],
+            artifact=artifact,
+        )
+
+    sections.public_flow_ids = (0,)
+    with pytest.raises(
+        benchmark.HarnessError,
+        match="compact recurrence reduction coverage is incomplete",
+    ):
+        benchmark._artifact_semantic_identity(artifact, manifest, process)
+
+
+def test_artifact_reuse_requires_exact_signature_and_tree(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_fake_artifact(artifact)
+    signature = {"kind": "test-signature", "process": "d d~ > z g"}
+    identity = benchmark._artifact_identity(artifact)
+    benchmark._write_reuse_signature(
+        artifact,
+        signature=signature,
+        artifact_identity=identity,
+        generation_command=benchmark._command_identity(("python", "generate-artifact")),
+    )
+    reused, provenance = benchmark._require_reusable_artifact(
+        artifact,
+        expected_signature=signature,
+    )
+    assert reused["tree"] == identity["tree"]
+    assert provenance["generation_command"]["argv"] == [
+        "python",
+        "generate-artifact",
+    ]
+    assert (
+        provenance["semantic_signature"]["artifact_semantic_identity"]
+        == identity["semantic_identity"]
+    )
+
+    with pytest.raises(benchmark.HarnessError, match="generation request changed"):
+        benchmark._require_reusable_artifact(
+            artifact,
+            expected_signature={**signature, "process": "g g > g g"},
+        )
+
+    (artifact / "extra.bin").write_bytes(b"ambient mutation")
+    with pytest.raises(benchmark.HarnessError, match="identity or tree changed"):
+        benchmark._require_reusable_artifact(
+            artifact,
+            expected_signature=signature,
+        )
+
+
+def _bound_artifact_fixture(
+    tmp_path: Path,
+) -> tuple[
+    Path,
+    dict[str, object],
+    dict[str, object],
+    dict[str, object],
+]:
+    artifact = tmp_path / "artifact"
+    _write_fake_artifact(artifact)
+    signature = {"kind": "test-signature", "process": "d d~ > z g"}
+    identity = benchmark._artifact_identity(artifact)
+    benchmark._write_reuse_signature(
+        artifact,
+        signature=signature,
+        artifact_identity=identity,
+        generation_command=benchmark._command_identity(("python", "generate-artifact")),
+    )
+    sidecar_path = benchmark._reuse_signature_path(artifact)
+    sidecar = json.loads(sidecar_path.read_text(encoding="utf-8"))
+    sidecar_identity = benchmark._path_identity(sidecar_path)
+    return (
+        artifact,
+        signature,
+        identity,
+        {
+            "payload": sidecar,
+            "identity": sidecar_identity,
+        },
+    )
+
+
+def test_bound_artifact_recheck_skips_semantic_hydration(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    artifact, signature, identity, sidecar = _bound_artifact_fixture(tmp_path)
+
+    def reject_hydration(*_args: object, **_kwargs: object) -> object:
+        raise AssertionError("bound recheck must not hydrate artifact semantics")
+
+    monkeypatch.setattr(
+        benchmark,
+        "_artifact_semantic_identity",
+        reject_hydration,
+    )
+    monkeypatch.setattr(
+        benchmark,
+        "_artifact_identity",
+        reject_hydration,
+    )
+    for _ in range(3):
+        rebound, provenance, observed_sidecar = (
+            benchmark._require_bound_reusable_artifact(
+                artifact,
+                expected_tree_sha256=identity["tree"]["sha256"],
+                expected_semantic_identity_sha256=identity["semantic_identity_sha256"],
+                expected_reuse_semantic_signature_sha256=sidecar["payload"][
+                    "semantic_signature_sha256"
+                ],
+                expected_sidecar_sha256=sidecar["identity"]["sha256"],
+                expected_signature=signature,
+            )
+        )
+        assert rebound["tree"] == identity["tree"]
+        assert rebound["semantic_identity"] == identity["semantic_identity"]
+        assert provenance == sidecar["payload"]
+        assert observed_sidecar == sidecar["identity"]
+
+
+def test_bound_artifact_recheck_rejects_same_size_tree_mutation(
+    tmp_path: Path,
+) -> None:
+    artifact, signature, identity, sidecar = _bound_artifact_fixture(tmp_path)
+    payload = artifact / "payload.bin"
+    payload.write_bytes(b"payloae")
+    assert payload.stat().st_size == len(b"payload")
+
+    with pytest.raises(benchmark.HarnessError, match="tree changed"):
+        benchmark._require_bound_reusable_artifact(
+            artifact,
+            expected_tree_sha256=identity["tree"]["sha256"],
+            expected_semantic_identity_sha256=identity["semantic_identity_sha256"],
+            expected_reuse_semantic_signature_sha256=sidecar["payload"][
+                "semantic_signature_sha256"
+            ],
+            expected_sidecar_sha256=sidecar["identity"]["sha256"],
+            expected_signature=signature,
+        )
+
+
+def test_bound_artifact_recheck_rejects_readdressed_sidecar_mutation(
+    tmp_path: Path,
+) -> None:
+    artifact, signature, identity, sidecar = _bound_artifact_fixture(tmp_path)
+    sidecar_path = benchmark._reuse_signature_path(artifact)
+    forged = copy.deepcopy(sidecar["payload"])
+    semantic_signature = forged["semantic_signature"]
+    semantic_identity = semantic_signature["artifact_semantic_identity"]
+    semantic_identity["normalization"]["average_factor"] = 999
+    semantic_identity["normalization_sha256"] = benchmark._canonical_sha256(
+        semantic_identity["normalization"]
+    )
+    forged["artifact_semantic_identity_sha256"] = benchmark._canonical_sha256(
+        semantic_identity
+    )
+    forged["semantic_signature_sha256"] = benchmark._canonical_sha256(
+        semantic_signature
+    )
+    sidecar_path.write_text(json.dumps(forged, sort_keys=True), encoding="utf-8")
+
+    with pytest.raises(benchmark.HarnessError, match="sidecar changed"):
+        benchmark._require_bound_reusable_artifact(
+            artifact,
+            expected_tree_sha256=identity["tree"]["sha256"],
+            expected_semantic_identity_sha256=identity["semantic_identity_sha256"],
+            expected_reuse_semantic_signature_sha256=sidecar["payload"][
+                "semantic_signature_sha256"
+            ],
+            expected_sidecar_sha256=sidecar["identity"]["sha256"],
+            expected_signature=signature,
+        )
+
+
+def test_bound_artifact_recheck_rejects_generation_request_drift(
+    tmp_path: Path,
+) -> None:
+    artifact, _signature, identity, sidecar = _bound_artifact_fixture(tmp_path)
+
+    with pytest.raises(benchmark.HarnessError, match="generation request changed"):
+        benchmark._require_bound_reusable_artifact(
+            artifact,
+            expected_tree_sha256=identity["tree"]["sha256"],
+            expected_semantic_identity_sha256=identity["semantic_identity_sha256"],
+            expected_reuse_semantic_signature_sha256=sidecar["payload"][
+                "semantic_signature_sha256"
+            ],
+            expected_sidecar_sha256=sidecar["identity"]["sha256"],
+            expected_signature={"kind": "different-generation-request"},
+        )
+
+
+def test_artifact_reuse_rejects_missing_sidecar(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    _write_fake_artifact(artifact)
+    with pytest.raises(benchmark.HarnessError, match="reuse signature is missing"):
+        benchmark._require_reusable_artifact(
+            artifact,
+            expected_signature={"kind": "test-signature"},
+        )
+
+
+def test_artifact_tree_identity_rejects_symlinks(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    artifact.mkdir()
+    payload = artifact / "payload.bin"
+    payload.write_bytes(b"payload")
+    (artifact / "payload-link.bin").symlink_to(payload)
+    with pytest.raises(benchmark.HarnessError, match="unsupported symlink"):
+        benchmark._tree_identity(artifact)
+
+
+def test_artifact_semantics_bind_axes_normalization_and_reduction_order(
+    tmp_path: Path,
+) -> None:
+    artifact = tmp_path / "artifact"
+    _write_fake_artifact(artifact)
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process = manifest["processes"][0]
+    original = benchmark._artifact_semantic_identity(artifact, manifest, process)
+    assert original["physical_color_flows"]["ordered_ids"] == ["flow:2,1"]
+    assert original["physical_helicities"]["ordered_ids"] == [
+        "h:-1,+1",
+        "h:+1,-1",
+    ]
+
+    physics_path = artifact / "processes" / "process-1" / "physics.json"
+    physics = json.loads(physics_path.read_text(encoding="utf-8"))
+    physics["extensions"]["normalization"]["average_factor"] = 72
+    physics["reduction"]["groups"][0]["physical_helicity_ids"].reverse()
+    physics_path.write_text(json.dumps(physics, sort_keys=True), encoding="utf-8")
+    changed = benchmark._artifact_semantic_identity(artifact, manifest, process)
+    assert changed["normalization_sha256"] != original["normalization_sha256"]
+    assert (
+        changed["reduction_ordering_sha256"] == (original["reduction_ordering_sha256"])
+    )
+    assert (
+        changed["execution_reduction_identity_sha256"]
+        != original["execution_reduction_identity_sha256"]
+    )
+
+    physics["helicities"].reverse()
+    physics_path.write_text(json.dumps(physics, sort_keys=True), encoding="utf-8")
+    with pytest.raises(benchmark.HarnessError, match="complete and ordered"):
+        benchmark._artifact_semantic_identity(artifact, manifest, process)
+
+
+def test_artifact_semantics_reject_model_free_manifest(tmp_path: Path) -> None:
+    artifact = tmp_path / "artifact"
+    _write_fake_artifact(artifact)
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process = manifest["processes"][0]
+    del manifest["model"]
+    with pytest.raises(benchmark.HarnessError, match="no model identity"):
+        benchmark._artifact_semantic_identity(artifact, manifest, process)
+
+
+def test_semantic_signature_covers_generation_configuration() -> None:
+    source = {"revision": "a" * 40}
+    runtime = {"native": {"sha256": "b" * 64}}
+    model = {"kind": "built-in-sm-source", "source_revision": "a" * 40}
+    default = _arguments()
+    changed = _arguments("--point-tile-size", "2048")
+    default_signature = benchmark._semantic_generation_signature(
+        default,
+        mode="recurrence",
+        source_identity=source,
+        runtime_provenance=runtime,
+        model_identity=model,
+    )
+    changed_signature = benchmark._semantic_generation_signature(
+        changed,
+        mode="recurrence",
+        source_identity=source,
+        runtime_provenance=runtime,
+        model_identity=model,
+    )
+    assert default_signature["point_tile_size"] == 1024
+    assert changed_signature["point_tile_size"] == 2048
+    assert default_signature["validation"]["relative_tolerance"] == benchmark.RTOL
+    assert default_signature["validation"]["absolute_tolerance"] == benchmark.ATOL
+    assert benchmark.RTOL == 1.0e-12
+    assert benchmark.ATOL == 1.0e-15
+    assert benchmark._canonical_sha256(default_signature) != (
+        benchmark._canonical_sha256(changed_signature)
+    )
+
+
+def test_generation_config_uses_additive_validation_tolerances() -> None:
+    config = benchmark._generation_config(
+        "recurrence",
+        validation_samples=3,
+        lc_flow_layout="topology-replay",
+        point_tile_size=1024,
+        jit_optimization_level=2,
+    )
+
+    validation = config.generation.validation
+    assert validation.relative_tolerance == benchmark.RTOL
+    assert validation.absolute_tolerance == benchmark.ATOL
+    assert validation.absolute_tolerance == 1.0e-15
+
+
+def test_validation_fixture_records_raw_and_semantic_digests(
+    tmp_path: Path,
+) -> None:
+    process_root = tmp_path / "processes" / "process-1"
+    process_root.mkdir(parents=True)
+    path = process_root / "validation-momenta.json"
+    payload = {
+        "points": [
+            [
+                {"momentum": [1.0, 0.0, 0.0, 1.0]},
+                {"momentum": [1.0, 0.0, 0.0, -1.0]},
+            ],
+            [
+                {"momentum": [2.0, 0.0, 0.0, 2.0]},
+                {"momentum": [2.0, 0.0, 0.0, -2.0]},
+            ],
+        ]
+    }
+    path.write_text(json.dumps(payload), encoding="utf-8")
+    points, identity = benchmark._validation_fixture(tmp_path, "process-1")
+    assert len(points) == 2
+    assert identity["point_count"] == 2
+    assert identity["file"]["sha256"] == hashlib.sha256(path.read_bytes()).hexdigest()
+    assert identity["points_sha256"] == benchmark._canonical_sha256(points)
+
+
+def test_profile_worker_evaluates_every_validation_point(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    artifact = tmp_path / "artifact"
+    process_root = artifact / "processes" / "process-1"
+    process_root.mkdir(parents=True)
+    points = [
+        [
+            {"momentum": [float(index + 1), 0.0, 0.0, 1.0]},
+            {"momentum": [float(index + 1), 0.0, 0.0, -1.0]},
+        ]
+        for index in range(3)
+    ]
+    (process_root / "validation-momenta.json").write_text(
+        json.dumps({"points": points}),
+        encoding="utf-8",
+    )
+    calls: list[tuple[str, int]] = []
+    benchmark_point_sets: list[object] = []
+    events: list[str] = []
+
+    def verify(_arguments: object) -> dict[str, object]:
+        events.append("verify")
+        return {
+            "kind": benchmark.WORKER_VERIFICATION_KIND,
+            "schema_version": benchmark.WORKER_VERIFICATION_SCHEMA,
+            "artifact_semantic_identity": _artifact_semantic_identity(),
+            "artifact_semantic_identity_sha256": "a" * 64,
+            "expected": {"artifact_id": "a" * 64},
+        }
+
+    monkeypatch.setattr(
+        benchmark,
+        "_verify_profile_worker_environment",
+        verify,
+    )
+
+    class FakeResolved:
+        def __init__(self, values: tuple[complex, ...]) -> None:
+            self._values = values
+            self.values = tuple(((value,),) for value in values)
+            self.helicity_ids = ("h:-1,+1,-1,+1",)
+            self.color_ids = ("flow:2,1",)
+
+        def total(self) -> tuple[complex, ...]:
+            return self._values
+
+    class FakeRuntime:
+        artifact_id = "a" * 64
+        physics = SimpleNamespace(
+            process="d d~ > z g",
+            process_id="process-1",
+            color_accuracy="lc",
+            color_flows=(SimpleNamespace(id="flow:2,1"),),
+            helicities=(SimpleNamespace(id="h:-1,+1,-1,+1"),),
+            structural_zero_helicity_count=0,
+        )
+
+        def __init__(self) -> None:
+            self._backend = SimpleNamespace(
+                _benchmark_f64_wall_time=lambda batch, repetitions, **_selectors: (
+                    1.0e-6 * len(batch) * repetitions
+                )
+            )
+
+        def evaluate(
+            self,
+            batch: tuple[object, ...],
+            **_selectors: object,
+        ) -> tuple[complex, ...]:
+            calls.append(("evaluate", len(batch)))
+            return tuple(complex(index + 1) for index in range(len(batch)))
+
+        def evaluate_resolved(
+            self,
+            batch: tuple[object, ...],
+            **_selectors: object,
+        ) -> FakeResolved:
+            calls.append(("evaluate_resolved", len(batch)))
+            return FakeResolved(
+                tuple(complex(index + 1) for index in range(len(batch)))
+            )
+
+    class FakeRuntimeFactory:
+        @staticmethod
+        def load(_artifact: Path, *, process: str) -> FakeRuntime:
+            events.append("load")
+            assert process == "d d~ > z g"
+            return FakeRuntime()
+
+    class FakeBenchmarkConfig:
+        batch_size: int
+
+        def __init__(self, **values: object) -> None:
+            self.__dict__.update(values)
+            batch_size = values["batch_size"]
+            assert isinstance(batch_size, int)
+            self.batch_size = batch_size
+
+    class FakeBenchmarkRunner:
+        def __init__(self, config: FakeBenchmarkConfig) -> None:
+            self.config = config
+
+        def run(self, _runtime: FakeRuntime, *, points: object) -> object:
+            benchmark_point_sets.append(points)
+            uncertainty = SimpleNamespace(
+                standard_deviation=0.0,
+                standard_error=0.0,
+                relative_standard_error=0.0,
+            )
+            return SimpleNamespace(
+                effective_config=SimpleNamespace(batch_size=self.config.batch_size),
+                sample_count=7,
+                repetitions_per_sample=1,
+                evaluation_count=7,
+                evaluated_point_count=7 * self.config.batch_size,
+                wall_time_per_point=1.0e-6,
+                evaluator_time_per_point=1.0e-6,
+                uncertainty=uncertainty,
+                evaluator_uncertainty=uncertainty,
+                environment={
+                    "wall_time_source": "runtime_core_repeated_wall_time",
+                    "wall_time_sample_pass": "runtime._benchmark_f64_wall_time",
+                },
+                interrupted=False,
+            )
+
+    pyamplicol = ModuleType("pyamplicol")
+    pyamplicol.BenchmarkRunner = FakeBenchmarkRunner  # type: ignore[attr-defined]
+    pyamplicol.Runtime = FakeRuntimeFactory  # type: ignore[attr-defined]
+    config = ModuleType("pyamplicol.config")
+    config.BenchmarkConfig = FakeBenchmarkConfig  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, "pyamplicol", pyamplicol)
+    monkeypatch.setitem(sys.modules, "pyamplicol.config", config)
+
+    arguments = SimpleNamespace(
+        artifact=artifact,
+        process_expression="d d~ > z g",
+        gluon_count=1,
+        mode="compiled",
+        color_flow="1",
+        helicity="1",
+        lc_flow_layout="topology-replay",
+        validation_point_artifact=artifact,
+        batch_size=[1],
+        schedule_index=0,
+        schedule_round=0,
+        target_runtime=0.1,
+        minimum_samples=7,
+        warmup_runs=2,
+        validation_samples=3,
+    )
+    result = benchmark._profile_worker(arguments)
+    assert events[:2] == ["verify", "load"]
+    assert calls[:2] == [("evaluate", 3), ("evaluate_resolved", 3)]
+    assert len(benchmark_point_sets) == 1
+    assert (
+        benchmark._canonical_sha256(benchmark_point_sets[0])
+        == (result["validation"]["fixture"]["points_sha256"])
+    )
+    assert result["validation"]["fixture"]["point_count"] == 3
+    assert len(result["validation"]["selected_totals"]) == 3
+    assert len(result["validation"]["resolved_components"]) == 3
+    assert len(result["validation"]["point_comparisons"]) == 3
+    raw_blocks = result["profiles"][0]["inner_native_wall_blocks"]
+    assert (
+        raw_blocks["fixture_points_sha256"]
+        == (result["validation"]["fixture"]["points_sha256"])
+    )
+    assert len(raw_blocks["blocks"]) == benchmark.MIN_AUTHORITATIVE_SAMPLES
+    assert raw_blocks["observed_native_wall_seconds"] >= arguments.target_runtime
+    assert raw_blocks["minimum_native_wall_seconds"] == arguments.target_runtime
+    assert raw_blocks["minimum_duration_satisfied"] is True
+    assert raw_blocks["repetitions_per_block"] > 1
+    assert (
+        result["profiles"][0]["repetitions_per_sample"]
+        == raw_blocks["repetitions_per_block"]
+    )
diff --git a/pyamplicol/tests/unit/test_reference_fixture_v2.py b/pyamplicol/tests/unit/test_reference_fixture_v2.py
new file mode 100644
index 0000000000..4fd8f250cf
--- /dev/null
+++ b/pyamplicol/tests/unit/test_reference_fixture_v2.py
@@ -0,0 +1,1193 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+import hashlib
+import importlib.util
+import json
+import subprocess
+import sys
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+
+import pytest
+from jsonschema import Draft202012Validator
+
+from tools.developer import reference_capture as CAPTURE
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools" / "developer" / "reference_fixture_v2.py"
+
+
+def _module():
+    spec = importlib.util.spec_from_file_location("reference_fixture_v2", SCRIPT)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+REFERENCE = _module()
+
+
+def test_compatibility_facade_imports_from_outside_checkout(tmp_path: Path) -> None:
+    completed = subprocess.run(
+        [sys.executable, str(SCRIPT)],
+        cwd=tmp_path,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+
+    assert completed.returncode == 0, completed.stderr
+    for name in (
+        "ReferenceFixtureError",
+        "Tolerances",
+        "load_reference_fixture",
+        "parse_reference_fixture",
+        "physics_case_sha256",
+        "reduction_plan_sha256",
+    ):
+        assert hasattr(REFERENCE, name)
+
+
+@pytest.mark.parametrize(
+    "name",
+    [
+        "reference-fixture-bundle-v1.schema.json",
+        "reference-physics-v2.schema.json",
+        "reference-oracle-evidence-v2.schema.json",
+    ],
+)
+def test_reference_v2_json_schemas_are_valid_draft_2020_12(name: str) -> None:
+    schema = json.loads((ROOT / "schemas" / name).read_text(encoding="utf-8"))
+
+    Draft202012Validator.check_schema(schema)
+
+
+def _sha(label: str) -> str:
+    return hashlib.sha256(label.encode("ascii")).hexdigest()
+
+
+def _input_sha(point: dict[str, Any]) -> str:
+    payload = {
+        "arithmetic_precision_bits": point["arithmetic_precision_bits"],
+        "certified_decimal_digits": point["certified_decimal_digits"],
+        "masses": point["masses"],
+        "momenta": point["momenta"],
+        "process_id": point["process_id"],
+        "round_trip_decimal_digits": point["round_trip_decimal_digits"],
+        "sqrt_s": point["sqrt_s"],
+    }
+    encoded = json.dumps(
+        payload,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _point(point_id: str, point_class: str, seed: int | None) -> dict[str, Any]:
+    generic_momenta = {
+        "point:generic-0": [
+            ["600", "0", "0", "600"],
+            ["600", "0", "0", "-600"],
+            ["300", "0", "0", "0"],
+            ["450", "450", "0", "0"],
+            ["450", "-450", "0", "0"],
+        ],
+        "point:generic-1": [
+            ["600", "0", "0", "600"],
+            ["600", "0", "0", "-600"],
+            ["300", "0", "0", "0"],
+            ["450", "0", "450", "0"],
+            ["450", "0", "-450", "0"],
+        ],
+        "point:generic-2": [
+            ["600", "0", "0", "600"],
+            ["600", "0", "0", "-600"],
+            ["300", "0", "0", "0"],
+            ["450", "0", "0", "450"],
+            ["450", "0", "0", "-450"],
+        ],
+    }
+    is_stress = point_class == "stress"
+    return {
+        "id": point_id,
+        "process_id": "process:dd-zgg",
+        "class": point_class,
+        "algorithm": {
+            "name": "deterministic-rambo" if seed is not None else "near-collinear",
+            "version": "1",
+            "rng": "PCG64" if seed is not None else None,
+            "seed": seed,
+        },
+        "sqrt_s": "1000" if is_stress else "1200",
+        "momenta": (
+            [
+                ["500", "0", "0", "500"],
+                ["500", "0", "0", "-500"],
+                ["545", "455", "0", "0"],
+                ["454.999999", "-454.999999", "0", "0"],
+                ["0.000001", "-0.000001", "0", "0"],
+            ]
+            if is_stress
+            else generic_momenta[point_id]
+        ),
+        "masses": ["0", "0", "300", "0", "0"],
+        "arithmetic_precision_bits": 266 if is_stress else 128,
+        "round_trip_decimal_digits": 80 if is_stress else 32,
+        "certified_decimal_digits": 40 if is_stress else 24,
+        "stress_metric": (
+            {
+                "kind": "minimum-final-energy-fraction",
+                "value": "0.000000001",
+            }
+            if is_stress
+            else None
+        ),
+    }
+
+
+def _refresh_physics_case_hashes(
+    fixture: dict[str, Any],
+    evidence: dict[str, Any],
+) -> None:
+    case_hashes: dict[str, str] = {}
+    for case in fixture["cases"]:
+        case["reduction"]["plan_sha256"] = REFERENCE.reduction_plan_sha256(
+            case["reduction"]
+        )
+        digest = REFERENCE.physics_case_sha256(fixture, case["id"])
+        case["physics_case_sha256"] = digest
+        case_hashes[case["id"]] = digest
+    for record in evidence["records"]:
+        case_id = record["case_id"]
+        if case_id in case_hashes:
+            record["physics_case_sha256"] = case_hashes[case_id]
+        record["evidence_record_sha256"] = REFERENCE.evidence_record_sha256(record)
+
+
+def _valid_payloads() -> tuple[dict[str, Any], dict[str, Any]]:
+    points = [
+        _point("point:generic-0", "generic", 11),
+        _point("point:generic-1", "generic", 12),
+        _point("point:generic-2", "generic", 13),
+        _point("point:stress-0", "stress", None),
+    ]
+    observations = [
+        {
+            "point_id": point["id"],
+            "arithmetic_precision_bits": point["arithmetic_precision_bits"],
+            "round_trip_decimal_digits": point["round_trip_decimal_digits"],
+            "certified_decimal_digits": point["certified_decimal_digits"],
+            "values": [
+                ["1", "2"],
+                ["2", "4"],
+                ["3", "6"],
+                ["0", "0"],
+            ],
+            "total": "18",
+            "evidence_refs": [f"evidence:{point['id'].split(':', 1)[1]}"],
+        }
+        for point in points
+    ]
+    fixture = {
+        "fixture_schema_version": 2,
+        "kind": "pyamplicol-reference-physics",
+        "fixture_id": "fixture:compact-lc",
+        "provenance": {
+            "source_repository": "https://github.com/mg5amcnlo/pyamplicol",
+            "source_revision": "1" * 40,
+            "source_tree_sha256": _sha("source-tree"),
+            "captured_at": "2026-07-16T12:00:00Z",
+            "capture_command": ["pyamplicol", "fixture", "capture"],
+            "working_tree_clean": True,
+            "memory_watchdog_gb": 30,
+        },
+        "dependencies": [
+            {
+                "id": "dependency:oracle",
+                "name": "independent analytic oracle",
+                "version": "1.0",
+                "revision": "oracle-r1",
+                "content_sha256": _sha("oracle-dependency"),
+                "serialization_abi": None,
+                "license": "0BSD",
+            }
+        ],
+        "models": [
+            {
+                "id": "model:builtin-sm",
+                "name": "built-in-sm",
+                "source_kind": "built-in-sm",
+                "content_sha256": _sha("model-source"),
+                "compiled_model_sha256": _sha("compiled-model"),
+                "compiled_schema_version": 1,
+                "restriction": None,
+                "dependency_ids": [],
+                "parameter_defaults": {
+                    "normalization.alpha_s": {"real": "0.118", "imag": "0"}
+                },
+            }
+        ],
+        "processes": [
+            {
+                "id": "process:dd-zgg",
+                "expression": "d d~ > z g g",
+                "external_pdgs": [1, -1, 23, 21, 21],
+                "external_labels": [1, 2, 3, 4, 5],
+                "external_leg_ids": [
+                    "leg:d-in",
+                    "leg:dbar-in",
+                    "leg:z-out",
+                    "leg:g1-out",
+                    "leg:g2-out",
+                ],
+                "external_spins": [2, 2, 1, 1, 1],
+                "external_colors": [3, -3, 1, 8, 8],
+                "external_masses": ["0", "0", "300", "0", "0"],
+                "external_helicity_domains": [
+                    [-1, 1],
+                    [-1, 1],
+                    [0],
+                    [0],
+                    [0],
+                ],
+                "initial_state_count": 2,
+                "alias_of": None,
+                "final_state_permutation": None,
+            },
+            {
+                "id": "process:dd-ggz",
+                "expression": "d d~ > g g z",
+                "external_pdgs": [1, -1, 21, 21, 23],
+                "external_labels": [1, 2, 3, 4, 5],
+                "external_leg_ids": [
+                    "leg:d-in",
+                    "leg:dbar-in",
+                    "leg:g1-out",
+                    "leg:g2-out",
+                    "leg:z-out",
+                ],
+                "external_spins": [2, 2, 1, 1, 1],
+                "external_colors": [3, -3, 8, 8, 1],
+                "external_masses": ["0", "0", "0", "0", "300"],
+                "external_helicity_domains": [
+                    [-1, 1],
+                    [-1, 1],
+                    [0],
+                    [0],
+                    [0],
+                ],
+                "initial_state_count": 2,
+                "alias_of": "process:dd-zgg",
+                "final_state_permutation": [1, 2, 0],
+            },
+        ],
+        "points": points,
+        "cases": [
+            {
+                "id": "case:dd-zgg-lc",
+                "case_kind": "substantive",
+                "model_id": "model:builtin-sm",
+                "process_id": "process:dd-zgg",
+                "color_accuracy": "lc",
+                "point_policy": "standard",
+                "point_ids": [point["id"] for point in points],
+                "coverage": {
+                    "helicities": "complete",
+                    "color": "complete",
+                    "color_kind": "physical-lc-flows",
+                    "helicity_count": 4,
+                    "color_component_count": 2,
+                    "structural_zero_helicity_count": 1,
+                },
+                "selectors": {
+                    "helicity": True,
+                    "color_flow": True,
+                    "omitted_helicity": "all-components",
+                    "omitted_color": "all-components",
+                },
+                "normalization": {
+                    "average_factor": "36",
+                    "color_factor": "27",
+                    "identical_factor": "2",
+                    "global_coupling_factor": "1",
+                    "quark_line_partner_factor": "1",
+                    "couplings_in_stage_evaluators": True,
+                },
+                "topology": {
+                    "currents": 17,
+                    "interactions": 31,
+                    "roots": 4,
+                    "reduction_groups": 2,
+                },
+                "artifact_physics_sha256": _sha("physics-payload"),
+                "artifact_execution_sha256": _sha("execution-payload"),
+                "physics_case_sha256": "0" * 64,
+                "axes": {
+                    "helicities": [
+                        {
+                            "id": "helicity:active",
+                            "index": 0,
+                            "values": [-1, -1, 0, 0, 0],
+                            "computed": True,
+                            "structural_zero": False,
+                            "representative_id": "helicity:active",
+                            "coefficient": "1",
+                        },
+                        {
+                            "id": "helicity:folded",
+                            "index": 1,
+                            "values": [-1, 1, 0, 0, 0],
+                            "computed": False,
+                            "structural_zero": False,
+                            "representative_id": "helicity:active",
+                            "coefficient": "2",
+                        },
+                        {
+                            "id": "helicity:second-active",
+                            "index": 2,
+                            "values": [1, -1, 0, 0, 0],
+                            "computed": True,
+                            "structural_zero": False,
+                            "representative_id": "helicity:second-active",
+                            "coefficient": "1",
+                        },
+                        {
+                            "id": "helicity:zero",
+                            "index": 3,
+                            "values": [1, 1, 0, 0, 0],
+                            "computed": False,
+                            "structural_zero": True,
+                            "representative_id": "helicity:zero",
+                            "coefficient": "0",
+                        },
+                    ],
+                    "colors": [
+                        {
+                            "kind": "lc-flow",
+                            "id": "flow:2,4,5,1",
+                            "index": 0,
+                            "word": [2, 4, 5, 1],
+                            "computed": True,
+                            "representative_id": "flow:2,4,5,1",
+                            "coefficient": "1",
+                        },
+                        {
+                            "kind": "lc-flow",
+                            "id": "flow:2,5,4,1",
+                            "index": 1,
+                            "word": [2, 5, 4, 1],
+                            "computed": False,
+                            "representative_id": "flow:2,4,5,1",
+                            "coefficient": "2",
+                        },
+                    ],
+                },
+                "reduction": {
+                    "kind": "lc-diagonal",
+                    "cell_semantics": "sum-all-contributing-groups",
+                    "groups": [
+                        {
+                            "id": "reduction:0",
+                            "representative_helicity_id": "helicity:active",
+                            "representative_color_id": "flow:2,4,5,1",
+                            "physical_helicity_ids": [
+                                "helicity:active",
+                                "helicity:folded",
+                            ],
+                            "physical_color_ids": [
+                                "flow:2,4,5,1",
+                                "flow:2,5,4,1",
+                            ],
+                        },
+                        {
+                            "id": "reduction:1",
+                            "representative_helicity_id": ("helicity:second-active"),
+                            "representative_color_id": "flow:2,4,5,1",
+                            "physical_helicity_ids": ["helicity:second-active"],
+                            "physical_color_ids": [
+                                "flow:2,4,5,1",
+                                "flow:2,5,4,1",
+                            ],
+                        },
+                    ],
+                    "plan_sha256": "0" * 64,
+                },
+                "observations": observations,
+            }
+        ],
+        "evidence_sets": ["oracle:analytic"],
+    }
+    evidence = {
+        "evidence_schema_version": 2,
+        "kind": "pyamplicol-reference-oracle-evidence",
+        "evidence_set_id": "oracle:analytic",
+        "captured_at": "2026-07-16T12:00:00Z",
+        "oracle": {
+            "id": "oracle:analytic",
+            "name": "independent analytic fixture oracle",
+            "implementation": "closed-form test expression",
+            "revision": "oracle-r1",
+            "content_sha256": _sha("oracle-implementation"),
+            "independence_statement": (
+                "The oracle does not import or execute pyAmpliCol generation code."
+            ),
+            "validation_profile": "high-precision",
+            "tolerance_ceiling": {
+                "relative": "0.000000000000000000000001",
+                "absolute": "0.000000000000000000000000000001",
+            },
+        },
+        "dependency_ids": ["dependency:oracle"],
+        "records": [
+            {
+                "id": f"evidence:{point['id'].split(':', 1)[1]}",
+                "case_id": "case:dd-zgg-lc",
+                "point_id": point["id"],
+                "independent_of_pyamplicol": True,
+                "arithmetic_precision_bits": point["arithmetic_precision_bits"],
+                "round_trip_decimal_digits": point["round_trip_decimal_digits"],
+                "certified_decimal_digits": point["certified_decimal_digits"],
+                "arithmetic": "analytic",
+                "coverage": "resolved",
+                "helicity_ids": [
+                    "helicity:active",
+                    "helicity:folded",
+                    "helicity:second-active",
+                    "helicity:zero",
+                ],
+                "color_ids": ["flow:2,4,5,1", "flow:2,5,4,1"],
+                "observed_total": "18",
+                "observed_helicity_totals": None,
+                "observed_values": [
+                    ["1", "2"],
+                    ["2", "4"],
+                    ["3", "6"],
+                    ["0", "0"],
+                ],
+                "process_identity": {
+                    "expression": "d d~ > z g g",
+                    "ordered_external_pdgs": [1, -1, 23, 21, 21],
+                    "ordered_external_leg_ids": [
+                        "leg:d-in",
+                        "leg:dbar-in",
+                        "leg:z-out",
+                        "leg:g1-out",
+                        "leg:g2-out",
+                    ],
+                    "source_to_row_permutation": [0, 1, 2, 3, 4],
+                    "row_id": None,
+                    "color_order_count": 2,
+                    "ordered_color_legs": [
+                        "leg:dbar-in",
+                        "leg:g1-out",
+                        "leg:g2-out",
+                        "leg:d-in",
+                    ],
+                },
+                "input_sha256": _input_sha(point),
+                "physics_case_sha256": "0" * 64,
+                "oracle_output_sha256": _sha(f"raw:{point['id']}"),
+                "command": ["analytic-oracle", point["id"]],
+                "tolerances": {"relative": "0", "absolute": "0"},
+            }
+            for point in points
+        ],
+    }
+    _refresh_physics_case_hashes(fixture, evidence)
+    return fixture, evidence
+
+
+def _parse(
+    fixture: dict[str, Any],
+    evidence: dict[str, Any],
+    *,
+    refresh_physics_case_hashes: bool = True,
+):
+    if refresh_physics_case_hashes:
+        _refresh_physics_case_hashes(fixture, evidence)
+    return REFERENCE.parse_reference_fixture(fixture, [evidence])
+
+
+def _degenerate_payloads() -> tuple[dict[str, Any], dict[str, Any]]:
+    fixture, evidence = _valid_payloads()
+    point = {
+        "id": "point:canonical",
+        "process_id": "process:dd-z",
+        "class": "canonical",
+        "algorithm": {
+            "name": "exact-two-to-one",
+            "version": "1",
+            "rng": None,
+            "seed": None,
+        },
+        "sqrt_s": "1000",
+        "momenta": [
+            ["500", "0", "0", "500"],
+            ["500", "0", "0", "-500"],
+            ["1000", "0", "0", "0"],
+        ],
+        "masses": ["0", "0", "1000"],
+        "arithmetic_precision_bits": 128,
+        "round_trip_decimal_digits": 32,
+        "certified_decimal_digits": 24,
+        "stress_metric": None,
+    }
+    fixture["processes"] = [
+        {
+            "id": "process:dd-z",
+            "expression": "d d~ > z",
+            "external_pdgs": [1, -1, 23],
+            "external_labels": [1, 2, 3],
+            "external_leg_ids": ["leg:d-in", "leg:dbar-in", "leg:z-out"],
+            "external_spins": [2, 1, 1],
+            "external_colors": [3, -3, 1],
+            "external_masses": ["0", "0", "1000"],
+            "external_helicity_domains": [[-1, 1], [0], [0]],
+            "initial_state_count": 2,
+            "alias_of": None,
+            "final_state_permutation": None,
+        }
+    ]
+    fixture["points"] = [point]
+    case = fixture["cases"][0]
+    case.update(
+        id="case:dd-z-lc",
+        process_id="process:dd-z",
+        point_policy="degenerate-2to1",
+        point_ids=["point:canonical"],
+        observations=[
+            {
+                "point_id": "point:canonical",
+                "arithmetic_precision_bits": 128,
+                "round_trip_decimal_digits": 32,
+                "certified_decimal_digits": 24,
+                "values": [["2"], ["0"]],
+                "total": "2",
+                "evidence_refs": ["evidence:canonical"],
+            }
+        ],
+    )
+    case["axes"]["helicities"] = [
+        {
+            "id": "helicity:active",
+            "index": 0,
+            "values": [-1, 0, 0],
+            "computed": True,
+            "structural_zero": False,
+            "representative_id": "helicity:active",
+            "coefficient": "1",
+        },
+        {
+            "id": "helicity:zero",
+            "index": 1,
+            "values": [1, 0, 0],
+            "computed": False,
+            "structural_zero": True,
+            "representative_id": "helicity:zero",
+            "coefficient": "0",
+        },
+    ]
+    case["axes"]["colors"] = [case["axes"]["colors"][0]]
+    case["axes"]["colors"][0].update(
+        id="flow:2,1",
+        word=[2, 1],
+        representative_id="flow:2,1",
+    )
+    case["coverage"]["helicity_count"] = 2
+    case["coverage"]["color_component_count"] = 1
+    case["topology"]["reduction_groups"] = 1
+    case["reduction"]["groups"] = [
+        {
+            "id": "reduction:0",
+            "representative_helicity_id": "helicity:active",
+            "representative_color_id": "flow:2,1",
+            "physical_helicity_ids": ["helicity:active"],
+            "physical_color_ids": ["flow:2,1"],
+        }
+    ]
+    evidence["records"] = [
+        {
+            "id": "evidence:canonical",
+            "case_id": "case:dd-z-lc",
+            "point_id": "point:canonical",
+            "independent_of_pyamplicol": True,
+            "arithmetic_precision_bits": 128,
+            "round_trip_decimal_digits": 32,
+            "certified_decimal_digits": 24,
+            "arithmetic": "analytic",
+            "coverage": "resolved",
+            "helicity_ids": ["helicity:active", "helicity:zero"],
+            "color_ids": ["flow:2,1"],
+            "observed_total": "2",
+            "observed_helicity_totals": None,
+            "observed_values": [["2"], ["0"]],
+            "process_identity": {
+                "expression": "d d~ > z",
+                "ordered_external_pdgs": [1, -1, 23],
+                "ordered_external_leg_ids": [
+                    "leg:d-in",
+                    "leg:dbar-in",
+                    "leg:z-out",
+                ],
+                "source_to_row_permutation": [0, 1, 2],
+                "row_id": None,
+                "color_order_count": 1,
+                "ordered_color_legs": ["leg:dbar-in", "leg:d-in"],
+            },
+            "input_sha256": _input_sha(point),
+            "physics_case_sha256": "0" * 64,
+            "oracle_output_sha256": _sha("raw:canonical"),
+            "command": ["analytic-oracle", "point:canonical"],
+            "tolerances": {"relative": "0", "absolute": "0"},
+        }
+    ]
+    _refresh_physics_case_hashes(fixture, evidence)
+    return fixture, evidence
+
+
+def _contracted_payloads(
+    color_accuracy: str,
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    fixture, evidence = _valid_payloads()
+    case = fixture["cases"][0]
+    case["color_accuracy"] = color_accuracy
+    case["coverage"].update(
+        color="contracted",
+        color_kind="contracted-color",
+        color_component_count=1,
+    )
+    case["selectors"].update(
+        color_flow=False,
+        omitted_color="contracted-component",
+    )
+    case["axes"]["colors"] = [
+        {
+            "kind": "contracted-color",
+            "id": "color:contracted",
+            "index": 0,
+            "description": f"fully contracted {color_accuracy} color",
+        }
+    ]
+    case["reduction"] = {
+        "kind": "contracted-color",
+        "cell_semantics": "fully-contracted-color",
+        "groups": [
+            {
+                **group,
+                "representative_color_id": "color:contracted",
+                "physical_color_ids": ["color:contracted"],
+            }
+            for group in case["reduction"]["groups"]
+        ],
+        "plan_sha256": "0" * 64,
+    }
+    for observation in case["observations"]:
+        observation["values"] = [["3"], ["6"], ["9"], ["0"]]
+    for record in evidence["records"]:
+        record["color_ids"] = ["color:contracted"]
+        record["observed_values"] = [["3"], ["6"], ["9"], ["0"]]
+    _refresh_physics_case_hashes(fixture, evidence)
+    return fixture, evidence
+
+
+def _binary64_degenerate_payloads() -> tuple[dict[str, Any], dict[str, Any]]:
+    fixture, evidence = _degenerate_payloads()
+    observation = fixture["cases"][0]["observations"][0]
+    observation.update(
+        arithmetic_precision_bits=53,
+        round_trip_decimal_digits=17,
+        certified_decimal_digits=15,
+    )
+    oracle = evidence["oracle"]
+    oracle["validation_profile"] = "binary64"
+    oracle["tolerance_ceiling"] = {
+        "relative": "0.0000000001",
+        "absolute": "0.000000000001",
+    }
+    record = evidence["records"][0]
+    record.update(
+        arithmetic="binary64",
+        arithmetic_precision_bits=53,
+        round_trip_decimal_digits=17,
+        certified_decimal_digits=15,
+    )
+    _refresh_physics_case_hashes(fixture, evidence)
+    return fixture, evidence
+
+
+def test_valid_lc_multiflow_fixture_parses_to_frozen_decimal_dtos() -> None:
+    fixture_payload, evidence_payload = _valid_payloads()
+
+    fixture = _parse(fixture_payload, evidence_payload)
+
+    point = fixture.point("point:stress-0")
+    assert point.runtime_momenta()[0][0] == Decimal("500")
+    assert isinstance(point.runtime_momenta()[0][0], Decimal)
+    assert point.f64_momenta()[0][0] == 500.0
+    assert point.input_sha256() == evidence_payload["records"][3]["input_sha256"]
+    assert len(fixture.cases[0].colors) == 2
+    assert fixture.processes[1].final_state_permutation == (1, 2, 0)
+    with pytest.raises((AttributeError, TypeError)):
+        point.id = "mutated"
+
+
+@pytest.mark.parametrize("bad_value", [1.25, "1.250", "1e-3", "-0"])
+def test_numeric_expectations_must_be_canonical_decimal_strings(
+    bad_value: object,
+) -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["observations"][0]["values"][0][0] = bad_value
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="schema violation"):
+        _parse(fixture, evidence)
+
+
+def test_sparse_observation_matrix_is_rejected() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["observations"][0]["values"][0].pop()
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="dense"):
+        _parse(fixture, evidence)
+
+
+def test_missing_axis_is_rejected_against_declared_coverage() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["axes"]["colors"].pop()
+    for observation in fixture["cases"][0]["observations"]:
+        for row in observation["values"]:
+            row.pop()
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="axis count"):
+        _parse(fixture, evidence)
+
+
+def test_structural_zero_must_be_explicit_and_exact() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["observations"][0]["values"][3][0] = "0.1"
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="structural helicity"):
+        _parse(fixture, evidence)
+
+
+def test_aggregate_evidence_must_preserve_structural_zero_exactly() -> None:
+    fixture, evidence = _valid_payloads()
+    record = evidence["records"][0]
+    record.update(
+        coverage="helicity-aggregate",
+        observed_helicity_totals=[
+            "3",
+            "6",
+            "9",
+            "0.0000000000000000000000001",
+        ],
+        observed_values=None,
+        observed_total="18.0000000000000000000000001",
+        tolerances={
+            "relative": "0",
+            "absolute": "0.000000000000000000000001",
+        },
+    )
+    evidence["oracle"]["tolerance_ceiling"]["absolute"] = "0.000000000000000000000001"
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="structural zero"):
+        _parse(fixture, evidence)
+
+
+def test_standard_case_requires_three_generic_and_one_stress_point() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["points"][3]["class"] = "generic"
+    fixture["points"][3]["stress_metric"] = None
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="three generic"):
+        _parse(fixture, evidence)
+
+
+def test_declared_total_must_equal_exact_decimal_component_sum() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["observations"][0]["total"] = "3"
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="component sum"):
+        _parse(fixture, evidence)
+
+
+def test_component_sum_is_exact_beyond_ambient_decimal_precision() -> None:
+    fixture, evidence = _contracted_payloads("full")
+    observation = fixture["cases"][0]["observations"][0]
+    observation["values"] = [
+        ["10000000000000000000000000000"],
+        ["20000000000000000000000000000"],
+        ["0.0000000000000000000000000001"],
+        ["0"],
+    ]
+    observation["total"] = "30000000000000000000000000000"
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="component sum"):
+        _parse(fixture, evidence)
+
+
+def test_nlc_and_full_cannot_expose_lc_flow_axes() -> None:
+    fixture, evidence = _valid_payloads()
+    case = fixture["cases"][0]
+    case["color_accuracy"] = "nlc"
+    case["coverage"].update(color="contracted", color_kind="contracted-color")
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="contracted color axis"):
+        _parse(fixture, evidence)
+
+
+@pytest.mark.parametrize("color_accuracy", ["nlc", "full"])
+def test_contracted_nlc_and_full_fixtures_are_valid(color_accuracy: str) -> None:
+    fixture, evidence = _contracted_payloads(color_accuracy)
+
+    parsed = _parse(fixture, evidence)
+
+    case = parsed.cases[0]
+    assert case.color_accuracy == color_accuracy
+    assert len(case.colors) == 1
+    assert case.colors[0].id == "color:contracted"
+
+
+def test_observation_requires_existing_independent_evidence() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["observations"][0]["evidence_refs"] = ["evidence:missing"]
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="unknown evidence"):
+        _parse(fixture, evidence)
+
+
+def test_total_only_evidence_cannot_back_resolved_cells() -> None:
+    fixture, evidence = _valid_payloads()
+    for record in evidence["records"]:
+        record.update(
+            coverage="total",
+            helicity_ids=[],
+            color_ids=[],
+            observed_helicity_totals=None,
+            observed_values=None,
+        )
+
+    with pytest.raises(
+        REFERENCE.ReferenceFixtureError,
+        match="resolved or complete-color aggregate evidence",
+    ):
+        _parse(fixture, evidence)
+
+
+def test_complete_helicity_aggregates_can_certify_multiflow_observation() -> None:
+    fixture, evidence = _valid_payloads()
+    for record in evidence["records"]:
+        record.update(
+            coverage="helicity-aggregate",
+            observed_helicity_totals=["3", "6", "9", "0"],
+            observed_values=None,
+        )
+
+    parsed = _parse(fixture, evidence)
+
+    assert len(parsed.cases[0].colors) == 2
+    assert all(
+        record.coverage == "helicity-aggregate"
+        for record in parsed.evidence_sets[0].records
+    )
+
+
+def test_helicity_aggregate_must_cover_complete_color_axis() -> None:
+    fixture, evidence = _valid_payloads()
+    for record in evidence["records"]:
+        record.update(
+            coverage="helicity-aggregate",
+            color_ids=["flow:2,4,5,1"],
+            observed_helicity_totals=["1", "2", "3", "0"],
+            observed_values=None,
+            observed_total="6",
+        )
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="complete color axis"):
+        _parse(fixture, evidence)
+
+
+def test_evidence_cannot_underwrite_more_digits_than_it_certifies() -> None:
+    fixture, evidence = _valid_payloads()
+    evidence["records"][3]["certified_decimal_digits"] = 21
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="observation claim"):
+        _parse(fixture, evidence)
+
+
+def test_structural_zero_requires_zero_reduction_coefficient() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["axes"]["helicities"][3]["coefficient"] = "1"
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="zero coefficient"):
+        _parse(fixture, evidence)
+
+
+def test_reduction_plan_hash_detects_normalized_mapping_tampering() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["reduction"]["groups"][0]["physical_color_ids"].reverse()
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="reduction plan hash"):
+        REFERENCE.parse_reference_fixture(fixture, [evidence])
+
+
+def test_reduction_groups_must_partition_every_nonzero_cell() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["reduction"]["groups"][0]["physical_helicity_ids"] = [
+        "helicity:active"
+    ]
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="do not partition"):
+        _parse(fixture, evidence)
+
+
+def test_contracted_reduction_allows_many_groups_to_feed_one_cell() -> None:
+    fixture, evidence = _contracted_payloads("nlc")
+    case = fixture["cases"][0]
+    duplicate = copy.deepcopy(case["reduction"]["groups"][0])
+    duplicate["id"] = "reduction:additional-contracted-contribution"
+    case["reduction"]["groups"].append(duplicate)
+    case["topology"]["reduction_groups"] += 1
+
+    _parse(fixture, evidence)
+
+
+def test_lc_reduction_still_rejects_overlapping_physical_cells() -> None:
+    fixture, evidence = _valid_payloads()
+    case = fixture["cases"][0]
+    duplicate = copy.deepcopy(case["reduction"]["groups"][0])
+    duplicate["id"] = "reduction:overlap"
+    case["reduction"]["groups"].append(duplicate)
+    case["topology"]["reduction_groups"] += 1
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="overlap"):
+        _parse(fixture, evidence)
+
+
+def test_invalid_alias_permutation_is_rejected() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["processes"][1]["final_state_permutation"] = [0, 2, 1]
+
+    with pytest.raises(
+        REFERENCE.ReferenceFixtureError, match="does not match its PDGs"
+    ):
+        _parse(fixture, evidence)
+
+
+def test_alias_case_hash_covers_transitive_source_process() -> None:
+    fixture, _evidence = _valid_payloads()
+    case = fixture["cases"][0]
+    case["process_id"] = "process:dd-ggz"
+    before = REFERENCE.physics_case_sha256(fixture, case["id"])
+
+    fixture["processes"][0]["expression"] = "d d~ > changed-source"
+
+    assert REFERENCE.physics_case_sha256(fixture, case["id"]) != before
+
+
+def test_identical_particle_alias_must_preserve_stable_leg_identity() -> None:
+    fixture, evidence = _valid_payloads()
+    alias = fixture["processes"][1]
+    alias["external_leg_ids"][2:4] = ["leg:g2-out", "leg:g1-out"]
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="leg identities"):
+        _parse(fixture, evidence)
+
+
+def test_color_singlet_lc_flow_may_have_an_empty_word() -> None:
+    fixture, evidence = _degenerate_payloads()
+    fixture["processes"][0]["external_colors"] = [1, 1, 1]
+    color = fixture["cases"][0]["axes"]["colors"][0]
+    color.update(
+        id="flow:singlet",
+        word=[],
+        representative_id="flow:singlet",
+    )
+    reduction_group = fixture["cases"][0]["reduction"]["groups"][0]
+    reduction_group["representative_color_id"] = "flow:singlet"
+    reduction_group["physical_color_ids"] = ["flow:singlet"]
+    evidence["records"][0]["color_ids"] = ["flow:singlet"]
+    evidence["records"][0]["process_identity"]["ordered_color_legs"] = []
+
+    parsed = _parse(fixture, evidence)
+
+    assert parsed.cases[0].colors[0].word == ()
+
+
+@pytest.mark.parametrize("word", ([2, 4, 4, 1], [2, 4, 999, 1]))
+def test_lc_flow_word_must_reference_distinct_external_labels(
+    word: list[int],
+) -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["axes"]["colors"][0]["word"] = word
+
+    with pytest.raises(
+        REFERENCE.ReferenceFixtureError, match="model-derived colored external"
+    ):
+        _parse(fixture, evidence)
+
+
+def test_complete_helicity_coverage_is_not_self_declared() -> None:
+    fixture, evidence = _valid_payloads()
+    case = fixture["cases"][0]
+    case["axes"]["helicities"].pop()
+    case["coverage"]["helicity_count"] = 3
+    case["coverage"]["structural_zero_helicity_count"] = 0
+    for observation in case["observations"]:
+        observation["values"].pop()
+    for record in evidence["records"]:
+        record["helicity_ids"].pop()
+        record["observed_values"].pop()
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="complete physical"):
+        _parse(fixture, evidence)
+
+
+def test_helicity_domains_are_derived_from_spin_and_mass_metadata() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["processes"][0]["external_spins"][2] = 3
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="model-derived spin"):
+        _parse(fixture, evidence)
+
+
+def test_point_masses_must_match_model_derived_process_masses() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["points"][0]["masses"][2] = "299"
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="model-derived masses"):
+        _parse(fixture, evidence)
+
+
+def test_dirty_or_synthetic_provenance_is_rejected() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["provenance"]["working_tree_clean"] = False
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="clean source tree"):
+        _parse(fixture, evidence)
+
+    fixture, evidence = _valid_payloads()
+    fixture["provenance"]["source_tree_sha256"] = "0" * 64
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="all-zero digest"):
+        _parse(fixture, evidence)
+
+
+def test_synthetic_oracle_output_digest_is_rejected() -> None:
+    fixture, evidence = _valid_payloads()
+    evidence["records"][0]["oracle_output_sha256"] = "0" * 64
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="all-zero digest"):
+        _parse(fixture, evidence)
+
+
+def test_evidence_record_hash_detects_normalized_record_tampering() -> None:
+    fixture, evidence = _valid_payloads()
+    evidence["records"][0]["command"].append("tampered=true")
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="canonical hash"):
+        REFERENCE.parse_reference_fixture(fixture, [evidence])
+
+
+def test_bundle_manifest_commits_and_authenticates_loaded_documents(
+    tmp_path: Path,
+) -> None:
+    fixture, evidence = _valid_payloads()
+    paths = CAPTURE.atomic_write_documents(
+        tmp_path,
+        {
+            CAPTURE.PHYSICS_FILENAME: fixture,
+            CAPTURE.ANALYTIC_EVIDENCE_FILENAME: evidence,
+        },
+        bundle_manifest_name=CAPTURE.BUNDLE_MANIFEST_FILENAME,
+    )
+
+    parsed = REFERENCE.load_reference_fixture(paths[0], paths[1:])
+
+    assert parsed.id == fixture["fixture_id"]
+    manifest_path = tmp_path / CAPTURE.BUNDLE_MANIFEST_FILENAME
+    assert manifest_path.is_file()
+    paths[1].write_text("{}\n", encoding="ascii")
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="digest mismatch"):
+        REFERENCE.load_reference_fixture(paths[0], paths[1:])
+
+
+def test_bundle_loader_rejects_documents_without_commit_marker(tmp_path: Path) -> None:
+    fixture, evidence = _valid_payloads()
+    fixture_path = tmp_path / CAPTURE.PHYSICS_FILENAME
+    evidence_path = tmp_path / CAPTURE.ANALYTIC_EVIDENCE_FILENAME
+    fixture_path.write_text(json.dumps(fixture), encoding="ascii")
+    evidence_path.write_text(json.dumps(evidence), encoding="ascii")
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="commit marker"):
+        REFERENCE.load_reference_fixture(fixture_path, (evidence_path,))
+
+
+def test_binary64_precision_metadata_is_explicit_and_valid() -> None:
+    fixture, evidence = _binary64_degenerate_payloads()
+
+    parsed = _parse(fixture, evidence)
+
+    record = parsed.evidence_sets[0].records[0]
+    assert record.arithmetic_precision_bits == 53
+    assert record.round_trip_decimal_digits == 17
+    assert record.certified_decimal_digits == 15
+
+
+@pytest.mark.parametrize(
+    ("field", "bad_value"),
+    [
+        ("arithmetic_precision_bits", 54),
+        ("round_trip_decimal_digits", 16),
+        ("certified_decimal_digits", 16),
+    ],
+)
+def test_binary64_precision_fields_cannot_be_conflated(
+    field: str,
+    bad_value: int,
+) -> None:
+    fixture, evidence = _binary64_degenerate_payloads()
+    evidence["records"][0][field] = bad_value
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="schema violation"):
+        _parse(fixture, evidence)
+
+
+def test_degenerate_two_to_one_policy_accepts_one_canonical_point() -> None:
+    fixture, evidence = _degenerate_payloads()
+
+    parsed = _parse(fixture, evidence)
+
+    assert parsed.cases[0].point_policy == "degenerate-2to1"
+    assert parsed.cases[0].point_ids == ("point:canonical",)
+
+
+def test_degenerate_two_to_one_policy_is_rejected_for_other_topologies() -> None:
+    fixture, evidence = _valid_payloads()
+    fixture["cases"][0]["point_policy"] = "degenerate-2to1"
+
+    with pytest.raises(
+        REFERENCE.ReferenceFixtureError,
+        match="exactly two incoming and one outgoing",
+    ):
+        _parse(fixture, evidence)
+
+
+def test_degenerate_two_to_one_policy_rejects_multiple_points() -> None:
+    fixture, evidence = _degenerate_payloads()
+    extra_point = copy.deepcopy(fixture["points"][0])
+    extra_point["id"] = "point:canonical-extra"
+    fixture["points"].append(extra_point)
+    fixture["cases"][0]["point_ids"].append("point:canonical-extra")
+    extra_observation = copy.deepcopy(fixture["cases"][0]["observations"][0])
+    extra_observation["point_id"] = "point:canonical-extra"
+    fixture["cases"][0]["observations"].append(extra_observation)
+
+    with pytest.raises(REFERENCE.ReferenceFixtureError, match="one canonical point"):
+        _parse(fixture, evidence)
diff --git a/pyamplicol/tests/unit/test_reference_fixtures.py b/pyamplicol/tests/unit/test_reference_fixtures.py
new file mode 100644
index 0000000000..2c25040ff6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_reference_fixtures.py
@@ -0,0 +1,76 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import tomllib
+from math import fsum
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+REFERENCE_ROOT = ROOT / "tests" / "fixtures" / "reference"
+FIXTURE = REFERENCE_ROOT / "physics-v1.json"
+CAPTURE = REFERENCE_ROOT / "CAPTURE.toml"
+PHYSICS_V2 = REFERENCE_ROOT / "physics-v2.json"
+BUNDLE_V2 = REFERENCE_ROOT / "reference-fixture-v2.manifest.json"
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def test_reference_fixture_is_compact_and_self_consistent() -> None:
+    payload = json.loads(FIXTURE.read_text(encoding="utf-8"))
+    assert payload["fixture_schema_version"] == 1
+    cases = payload["cases"]
+    assert {
+        "builtin_sm_ddbar_z_lc",
+        "builtin_sm_ddbar_z_nlc",
+        "builtin_sm_ddbar_z_full",
+        "builtin_sm_ddbar_zg_lc",
+        "builtin_sm_ddbar_zg_nlc",
+        "builtin_sm_ddbar_zg_full",
+        "scalars_2to2_lc",
+        "scalar_gravity_2to2_lc",
+    } == set(cases)
+
+    for case in cases.values():
+        resolved = case.get("resolved")
+        if resolved is None:
+            resolved = cases[case["resolved_from"]]["resolved"]
+        resolved_total = fsum(
+            value for colors in resolved.values() for value in colors.values()
+        )
+        assert resolved_total == case["total"] or abs(
+            resolved_total - case["total"]
+        ) <= 2.0e-15 * max(abs(case["total"]), 1.0)
+
+
+def test_current_reference_capture_matches_v2_bundle() -> None:
+    with CAPTURE.open("rb") as stream:
+        capture = tomllib.load(stream)
+    physics = json.loads(PHYSICS_V2.read_text(encoding="utf-8"))
+    bundle = json.loads(BUNDLE_V2.read_text(encoding="utf-8"))
+
+    assert capture["schema_version"] == 2
+    assert capture["fixture_bundle"] == BUNDLE_V2.name
+    assert capture["memory_watchdog_gb"] == 30
+    assert capture["source"]["revision"] == physics["provenance"]["source_revision"]
+    assert capture["source"]["tree_sha256"] == physics["provenance"][
+        "source_tree_sha256"
+    ]
+    assert capture["source"]["working_tree_clean"] is True
+    assert capture["coverage"]["case_count"] == len(physics["cases"])
+    assert capture["coverage"]["point_count"] == len(physics["points"])
+    assert capture["evidence"]["legacy_fortran"]["records"] == 90
+    assert capture["evidence"]["analytic"]["records"] == 8
+    assert {record["path"] for record in bundle["files"]} == {
+        "analytic-oracles-v2.json",
+        "legacy-fortran-v2.json",
+        "physics-v2.json",
+    }
+    assert next(
+        record["sha256"]
+        for record in bundle["files"]
+        if record["path"] == PHYSICS_V2.name
+    ) == _sha256(PHYSICS_V2)
diff --git a/pyamplicol/tests/unit/test_relation_discovery.py b/pyamplicol/tests/unit/test_relation_discovery.py
new file mode 100644
index 0000000000..006f4ac3d2
--- /dev/null
+++ b/pyamplicol/tests/unit/test_relation_discovery.py
@@ -0,0 +1,1290 @@
+# SPDX-License-Identifier: 0BSD
+"""Numerical nomination and exact-certificate promotion contracts."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import replace
+from decimal import Decimal, localcontext
+from itertools import product
+from typing import Any
+
+import pytest
+
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.dag_equivalence import (
+    NUMERICAL_CURRENT_CAPTURE_ABI,
+    NUMERICAL_CURRENT_CAPTURE_OUTPUT_PARTITION_ABI,
+    ExactCurrentRelationCertificate,
+    _build_numerical_observation_candidate_index,
+    _canonical_payload_sha256,
+    _current_evaluation_contract,
+    _numerical_current_observation_batch_sha256,
+    _numerical_observation_tolerance_window_ids,
+    apply_numerical_current_relation_certificates,
+    assign_recursive_current_evaluation_reuse,
+    certify_numerical_current_observations,
+    discover_generic_dag_numerical_current_relations,
+    discover_recursive_evaluation_relations,
+    generic_dag_numerical_capture_output_partition_sha256,
+    generic_dag_numerical_model_parameter_schema_sha256,
+    generic_dag_numerical_runtime_schema_sha256,
+    generic_dag_numerical_source_dag_sha256,
+    generic_dag_numerical_source_semantics_sha256,
+    verify_dag_relation_certificates,
+)
+from pyamplicol.generation.runtime_schema import build_runtime_expression_schema
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+class _RuntimeCouplingBuiltin(BuiltinSMModel):
+    def runtime_parameter_names_for_vertex(
+        self,
+        kind: int,
+    ) -> tuple[str, str]:
+        return (
+            f"runtime.vertex.{kind}.component_0",
+            f"runtime.vertex.{kind}.component_1",
+        )
+
+
+def _ambiguous_projective_dag():
+    """Build a tiny DAG whose existing projective index safely fails closed."""
+
+    model = BuiltinSMModel()
+    seed = compile_generic_dag(
+        build_process_ir("d d~ > z g", color_accuracy="lc"),
+        model=model,
+    )
+    source_templates = []
+    source_keys = set()
+    for source_id in seed.sources:
+        source = seed.currents[source_id]
+        key = (
+            _current_evaluation_contract(source),
+            source.source_leg_label,
+            source.source_helicity,
+        )
+        if key in source_keys:
+            continue
+        source_keys.add(key)
+        source_templates.append(source)
+        if len(source_templates) == 3:
+            break
+    assert len(source_templates) == 3
+    sources = tuple(
+        replace(source, id=current_id)
+        for current_id, source in enumerate(source_templates)
+    )
+
+    template = seed.interactions[0]
+    generated_template = seed.currents[template.result_id]
+    generated = tuple(
+        replace(generated_template, id=current_id) for current_id in range(3, 8)
+    )
+
+    def interaction(
+        interaction_id: int,
+        left_id: int,
+        right_id: int,
+        result_id: int,
+        color_weight: tuple[float, float],
+    ):
+        return replace(
+            template,
+            id=interaction_id,
+            left_id=left_id,
+            right_id=right_id,
+            result_id=result_id,
+            color_weight=color_weight,
+            evaluation_group_id=None,
+            evaluation_factor=(1.0, 0.0),
+        )
+
+    interactions = (
+        interaction(0, 0, 1, 3, (3.0, 0.0)),
+        interaction(1, 0, 2, 3, (6.0, 0.0)),
+        interaction(2, 0, 1, 4, (1.0, 0.0)),
+        interaction(3, 0, 2, 4, (2.0, 0.0)),
+        interaction(4, 0, 1, 5, (6.0, 0.0)),
+        interaction(5, 0, 2, 5, (12.0, 0.0)),
+        interaction(6, 3, 1, 6, (1.0, 0.0)),
+        interaction(7, 5, 1, 7, (1.0, 0.0)),
+    )
+    root = replace(
+        seed.amplitude_roots[0],
+        id=0,
+        left_id=7,
+        right_id=1,
+    )
+    dag = replace(
+        seed,
+        currents=(*sources, *generated),
+        sources=(0, 1, 2),
+        interactions=interactions,
+        amplitude_roots=(root,),
+        selected_source_helicities=(),
+        selected_color_sector_ids=(),
+        lc_topology_replay=None,
+        helicity_recurrence=None,
+        helicity_materialization=None,
+    )
+    return dag, model
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+def test_exact_certified_discovery_promotes_missed_dag_reuse(
+    execution_mode,
+) -> None:
+    dag, model = _ambiguous_projective_dag()
+    baseline = assign_recursive_current_evaluation_reuse(dag, model)
+    assert (
+        baseline.interactions[6].evaluation_group_id
+        != baseline.interactions[7].evaluation_group_id
+    )
+
+    result = discover_recursive_evaluation_relations(
+        dag,
+        model,
+        mode="certified-reuse",
+        execution_mode=execution_mode,
+        precision_digits=80,
+        probe_count=4,
+        seed=17,
+    )
+
+    report = result.report
+    assert report.execution_mode == execution_mode
+    assert report.color_accuracy == "lc"
+    assert report.state == "exact-certified-applied"
+    assert report.numerical_candidate_count >= 3
+    assert report.uncertified_candidate_count >= 1
+    assert report.exact_certified_relation_count == 1
+    assert report.applied_relation_count == 1
+    assert report.certificate_replay_status == "verified"
+    assert (
+        result.dag.interactions[6].evaluation_group_id
+        == result.dag.interactions[7].evaluation_group_id
+    )
+    assert verify_dag_relation_certificates(dag, model, report.certificates)
+    restored = ExactCurrentRelationCertificate.from_json_dict(
+        report.certificates[0].to_json_dict()
+    )
+    assert restored == report.certificates[0]
+    assert verify_dag_relation_certificates(dag, model, (restored,))
+
+    tampered = replace(report.certificates[0], factor=(3.0, 0.0))
+    assert not verify_dag_relation_certificates(dag, model, (tampered,))
+
+
+def test_diagnostic_mode_reports_promotable_reuse_without_applying_it() -> None:
+    dag, model = _ambiguous_projective_dag()
+
+    result = discover_recursive_evaluation_relations(
+        dag,
+        model,
+        mode="diagnostic",
+        execution_mode="compiled",
+        precision_digits=96,
+        probe_count=3,
+        seed=23,
+    )
+
+    assert result.dag is dag
+    assert result.report.state == "diagnostic-only"
+    assert result.report.applied_relation_count == 0
+    assert result.report.exact_certified_relation_count == 1
+    assert result.report.interaction_evaluation_count_after is not None
+    assert result.report.interaction_evaluation_count_before is not None
+    assert (
+        result.report.interaction_evaluation_count_after
+        < result.report.interaction_evaluation_count_before
+    )
+    payload = result.report.to_json_dict()
+    assert payload["probe"] == {
+        "status": "completed",
+        "precision_digits": 96,
+        "probe_count": 3,
+        "seed": 23,
+        "deterministic": True,
+        "candidate_only": True,
+    }
+
+
+def _authenticated_relation_for_ambiguous_dag(
+    relation_kind: str,
+):
+    dag, model = _ambiguous_projective_dag()
+    certificate = _authenticated_relation_certificate(dag, relation_kind)
+    return dag, model, certificate
+
+
+def _authenticated_relation_certificate(
+    dag,
+    relation_kind: str,
+):
+    model = BuiltinSMModel()
+    source_digest = generic_dag_numerical_source_semantics_sha256(
+        dag,
+        execution_mode="compiled",
+    )
+    representative_candidate = (
+        (Decimal("1.25"), Decimal("-0.5")),
+        (Decimal("-3.0"), Decimal("2.25")),
+        (Decimal("0.75"), Decimal("4.0")),
+        (Decimal("-2.5"), Decimal("-1.125")),
+    )
+    representative_verification = (
+        (Decimal("5.5"), Decimal("0.25")),
+        (Decimal("-1.75"), Decimal("-3.0")),
+        (Decimal("2.125"), Decimal("6.25")),
+        (Decimal("-4.0"), Decimal("1.5")),
+    )
+    if relation_kind == "zero":
+        candidate = tuple((Decimal(0), Decimal(0)) for _ in range(4))
+        verification = candidate
+        candidate_representative = None
+        verification_representative = None
+        representative_id = None
+    else:
+        sign = Decimal(1) if relation_kind == "equal" else Decimal(-1)
+        candidate = tuple(
+            (sign * real, sign * imaginary)
+            for real, imaginary in representative_candidate
+        )
+        verification = tuple(
+            (sign * real, sign * imaginary)
+            for real, imaginary in representative_verification
+        )
+        candidate_representative = representative_candidate
+        verification_representative = representative_verification
+        representative_id = 3
+    certificate = certify_numerical_current_observations(
+        current_id=5,
+        representative_id=representative_id,
+        relation_kind=relation_kind,  # type: ignore[arg-type]
+        source_semantics_sha256=source_digest,
+        runtime_schema_sha256=(
+            generic_dag_numerical_runtime_schema_sha256(dag, model)
+        ),
+        source_dag_sha256=generic_dag_numerical_source_dag_sha256(dag),
+        candidate_capture_sha256=hashlib.sha256(
+            b"candidate-capture"
+        ).hexdigest(),
+        verification_capture_sha256=hashlib.sha256(
+            b"verification-capture"
+        ).hexdigest(),
+        candidate_observation_batch_sha256=hashlib.sha256(
+            b"candidate-batch"
+        ).hexdigest(),
+        verification_observation_batch_sha256=hashlib.sha256(
+            b"verification-batch"
+        ).hexdigest(),
+        candidate_current_values=candidate,
+        candidate_representative_values=candidate_representative,
+        verification_current_values=verification,
+        verification_representative_values=verification_representative,
+        precision_digits=96,
+        seed=0x5059414D,
+        relative_tolerance=1.0e-70,
+        absolute_tolerance=1.0e-80,
+        candidate_probe_count=2,
+        verification_probe_count=2,
+    )
+    assert certificate is not None
+    return certificate
+
+
+@pytest.mark.parametrize("relation_kind", ("equal", "opposite", "zero"))
+def test_authenticated_numerical_relations_are_applied_by_default(
+    relation_kind: str,
+) -> None:
+    dag, model, certificate = _authenticated_relation_for_ambiguous_dag(
+        relation_kind
+    )
+
+    result = apply_numerical_current_relation_certificates(
+        dag,
+        model,
+        (certificate,),
+        mode="certified-reuse",
+        execution_mode="compiled",
+    )
+
+    assert result.report.state == "authenticated-numerical-applied"
+    assert result.report.certificate_replay_status == "verified"
+    assert result.report.applied_relation_count == 1
+    assert result.report.warning_required
+    assert result.report.interaction_evaluation_count_before == 4
+    assert result.report.interaction_evaluation_count_projected == 3
+    payload = result.report.to_json_dict()
+    assert payload["relation_kind_counts"][relation_kind] == 1
+    assert payload["warning"] == {
+        "required": True,
+        "emit": "once-per-generated-artifact",
+        "code": "proofless-numerical-current-relations-applied-v1",
+        "message": (
+            "applied authenticated numerical equal/opposite/zero current "
+            "reuse without an exact structural proof; disable with "
+            "--no-numerical-current-reuse"
+        ),
+    }
+    mapping = payload["mappings"][0]
+    assert mapping["current_id"] == 5
+    assert mapping["relation_kind"] == relation_kind
+    assert mapping["resolved_current_ids"] == [5]
+    assert mapping["projected_interaction_count"] == 1
+    assert len(mapping["projected_interaction_ids_sha256"]) == 64
+    if relation_kind == "zero":
+        assert mapping["representative_id"] is None
+        assert mapping["execution_representative_id"] == 3
+        assert mapping["factor_binary64"] == ["0x0.0p+0", "0x0.0p+0"]
+
+
+@pytest.mark.parametrize("relation_kind", ("equal", "opposite", "zero"))
+def test_authenticated_application_only_merges_or_suppresses_existing_groups(
+    relation_kind: str,
+) -> None:
+    dag, model = _ambiguous_projective_dag()
+    baseline = assign_recursive_current_evaluation_reuse(dag, model)
+    certificate = _authenticated_relation_certificate(
+        baseline,
+        relation_kind,
+    )
+
+    result = apply_numerical_current_relation_certificates(
+        baseline,
+        model,
+        (certificate,),
+        mode="certified-reuse",
+        execution_mode="compiled",
+    )
+
+    assert result.report.interaction_evaluation_count_before == 4
+    assert result.report.interaction_evaluation_count_projected == 3
+    assert (
+        result.report.interaction_evaluation_count_projected
+        <= result.report.interaction_evaluation_count_before
+    )
+    assert result.dag.interactions[:7] == baseline.interactions[:7]
+    changed = result.dag.interactions[7]
+    if relation_kind == "zero":
+        assert changed.evaluation_group_id == (
+            baseline.interactions[7].evaluation_group_id
+        )
+        assert changed.evaluation_factor == (0.0, 0.0)
+    else:
+        assert changed.evaluation_group_id == (
+            baseline.interactions[6].evaluation_group_id
+        )
+        assert changed.evaluation_factor == (
+            (1.0, 0.0)
+            if relation_kind == "equal"
+            else (-1.0, 0.0)
+        )
+
+
+def test_authenticated_zero_suppresses_only_its_downstream_attachment() -> None:
+    dag, model = _ambiguous_projective_dag()
+    baseline = assign_recursive_current_evaluation_reuse(dag, model)
+    extra_contribution = replace(
+        baseline.interactions[7],
+        id=8,
+        left_id=4,
+        result_id=7,
+        evaluation_group_id=91,
+    )
+    multi_term = replace(
+        baseline,
+        interactions=(*baseline.interactions, extra_contribution),
+    )
+    certificate = _authenticated_relation_certificate(multi_term, "zero")
+
+    result = apply_numerical_current_relation_certificates(
+        multi_term,
+        model,
+        (certificate,),
+        mode="certified-reuse",
+        execution_mode="compiled",
+    )
+
+    assert result.dag.interactions[7].evaluation_factor == (0.0, 0.0)
+    assert result.dag.interactions[8] == extra_contribution
+    assert result.dag.interactions[:7] == multi_term.interactions[:7]
+    assert (
+        result.report.interaction_evaluation_count_projected
+        == result.report.interaction_evaluation_count_before - 1
+    )
+
+
+def test_authenticated_zero_propagates_through_exact_structural_class() -> None:
+    dag, model = _ambiguous_projective_dag()
+    duplicate_first = replace(
+        dag.interactions[4],
+        id=6,
+        result_id=6,
+    )
+    duplicate_second = replace(
+        dag.interactions[5],
+        id=7,
+        result_id=6,
+    )
+    consume_certified = replace(
+        dag.interactions[7],
+        id=8,
+        left_id=5,
+        result_id=7,
+    )
+    consume_structural_member = replace(
+        consume_certified,
+        id=9,
+        left_id=6,
+    )
+    unaffected = replace(
+        consume_certified,
+        id=10,
+        left_id=4,
+    )
+    structural_fanout = replace(
+        dag,
+        interactions=(
+            *dag.interactions[:6],
+            duplicate_first,
+            duplicate_second,
+            consume_certified,
+            consume_structural_member,
+            unaffected,
+        ),
+    )
+    baseline = assign_recursive_current_evaluation_reuse(
+        structural_fanout,
+        model,
+    )
+    assert (
+        baseline.interactions[8].evaluation_group_id
+        == baseline.interactions[9].evaluation_group_id
+    )
+    certificate = _authenticated_relation_certificate(baseline, "zero")
+
+    result = apply_numerical_current_relation_certificates(
+        baseline,
+        model,
+        (certificate,),
+        mode="certified-reuse",
+        execution_mode="compiled",
+    )
+
+    assert result.dag.interactions[:8] == baseline.interactions[:8]
+    assert result.dag.interactions[8].evaluation_factor == (0.0, 0.0)
+    assert result.dag.interactions[9].evaluation_factor == (0.0, 0.0)
+    assert result.dag.interactions[10] == baseline.interactions[10]
+    mapping = result.report.to_json_dict()["mappings"][0]
+    assert mapping["resolved_current_ids"] == [5, 6]
+    assert mapping["projected_interaction_count"] == 2
+    assert (
+        result.report.interaction_evaluation_count_projected
+        <= result.report.interaction_evaluation_count_before
+    )
+
+
+@pytest.mark.parametrize(
+    ("index_change", "expected_value"),
+    (
+        ("ordered_external_labels", (3, 2)),
+        ("helicity_ancestry", 21),
+    ),
+)
+def test_authenticated_zero_does_not_cross_runtime_routing_contracts(
+    index_change: str,
+    expected_value: object,
+) -> None:
+    dag, model = _ambiguous_projective_dag()
+    certified = dag.currents[5]
+    distinct_index = replace(
+        certified.index,
+        **{index_change: expected_value},
+    )
+    assert _current_evaluation_contract(certified) != (
+        _current_evaluation_contract(
+            replace(certified, index=distinct_index)
+        )
+    )
+
+    duplicate_first = replace(
+        dag.interactions[4],
+        id=6,
+        result_id=6,
+    )
+    duplicate_second = replace(
+        dag.interactions[5],
+        id=7,
+        result_id=6,
+    )
+    consume_certified = replace(
+        dag.interactions[7],
+        id=8,
+        left_id=5,
+        result_id=7,
+    )
+    consume_distinct_route = replace(
+        consume_certified,
+        id=9,
+        left_id=6,
+    )
+    routed_currents = (
+        *dag.currents[:6],
+        replace(dag.currents[6], index=distinct_index),
+        *dag.currents[7:],
+    )
+    routed = replace(
+        dag,
+        currents=routed_currents,
+        interactions=(
+            *dag.interactions[:6],
+            duplicate_first,
+            duplicate_second,
+            consume_certified,
+            consume_distinct_route,
+        ),
+    )
+    baseline = assign_recursive_current_evaluation_reuse(routed, model)
+    assert (
+        baseline.interactions[8].evaluation_group_id
+        != baseline.interactions[9].evaluation_group_id
+    )
+    certificate = _authenticated_relation_certificate(baseline, "zero")
+
+    result = apply_numerical_current_relation_certificates(
+        baseline,
+        model,
+        (certificate,),
+        mode="certified-reuse",
+        execution_mode="compiled",
+    )
+
+    assert result.dag.interactions[8].evaluation_factor == (0.0, 0.0)
+    assert result.dag.interactions[9] == baseline.interactions[9]
+    assert result.report.to_json_dict()["mappings"][0][
+        "resolved_current_ids"
+    ] == [5]
+
+
+def test_authenticated_merge_rejects_unauthenticated_existing_group_factors() -> None:
+    dag, model = _ambiguous_projective_dag()
+    antisymmetric = replace(
+        dag,
+        interactions=(
+            *dag.interactions[:6],
+            replace(dag.interactions[6], vertex_kind=0),
+            replace(
+                dag.interactions[7],
+                vertex_kind=0,
+                left_id=1,
+                right_id=5,
+            ),
+        ),
+    )
+    baseline = assign_recursive_current_evaluation_reuse(
+        antisymmetric,
+        model,
+    )
+    target = replace(
+        baseline.interactions[6],
+        evaluation_factor=(2.0, 0.0),
+    )
+    grouped = replace(
+        baseline,
+        interactions=(
+            *baseline.interactions[:6],
+            target,
+            baseline.interactions[7],
+        ),
+    )
+    certificate = _authenticated_relation_certificate(grouped, "equal")
+
+    with pytest.raises(ValueError, match="unauthenticated"):
+        apply_numerical_current_relation_certificates(
+            grouped,
+            model,
+            (certificate,),
+            mode="certified-reuse",
+            execution_mode="compiled",
+        )
+
+
+def test_authenticated_merge_rejects_spliced_existing_group_membership() -> None:
+    dag, model = _ambiguous_projective_dag()
+    baseline = assign_recursive_current_evaluation_reuse(dag, model)
+    spliced = replace(
+        baseline,
+        interactions=(
+            *baseline.interactions[:7],
+            replace(
+                baseline.interactions[7],
+                evaluation_group_id=(
+                    baseline.interactions[0].evaluation_group_id
+                ),
+            ),
+        ),
+    )
+    certificate = _authenticated_relation_certificate(spliced, "equal")
+
+    with pytest.raises(ValueError, match="aliases distinct"):
+        apply_numerical_current_relation_certificates(
+            spliced,
+            model,
+            (certificate,),
+            mode="certified-reuse",
+            execution_mode="compiled",
+        )
+
+
+def test_authenticated_relation_without_a_safe_target_remains_unapplied() -> None:
+    dag, model = _ambiguous_projective_dag()
+    baseline = assign_recursive_current_evaluation_reuse(dag, model)
+    no_target = replace(
+        baseline,
+        interactions=(
+            *baseline.interactions[:6],
+            replace(
+                baseline.interactions[6],
+                left_id=4,
+                right_id=2,
+            ),
+            baseline.interactions[7],
+        ),
+    )
+    certificate = _authenticated_relation_certificate(no_target, "equal")
+
+    result = apply_numerical_current_relation_certificates(
+        no_target,
+        model,
+        (certificate,),
+        mode="certified-reuse",
+        execution_mode="compiled",
+    )
+
+    assert result.dag is no_target
+    assert result.report.state == (
+        "authenticated-numerical-no-reuse-opportunity"
+    )
+    assert result.report.applied_relation_count == 0
+    assert not result.report.warning_required
+    assert result.report.to_json_dict()["mappings"][0][
+        "projected_interaction_count"
+    ] == 0
+
+
+def test_empty_numerical_audit_is_explicit_and_does_not_warn_or_apply() -> None:
+    dag, model = _ambiguous_projective_dag()
+
+    result = apply_numerical_current_relation_certificates(
+        dag,
+        model,
+        (),
+        mode="certified-reuse",
+        execution_mode="compiled",
+    )
+
+    assert result.dag is dag
+    assert result.report.state == "no_certified_numerical_relation"
+    assert (
+        result.report.certificate_replay_status
+        == "no_certified_numerical_relation"
+    )
+    assert result.report.applied_relation_count == 0
+    assert not result.report.warning_required
+    assert result.report.to_json_dict()["warning"] == {
+        "required": False,
+        "emit": "never",
+        "code": None,
+        "message": None,
+    }
+
+
+def test_numerical_diagnostic_mode_records_but_does_not_apply_or_warn() -> None:
+    dag, model, certificate = _authenticated_relation_for_ambiguous_dag("equal")
+
+    result = apply_numerical_current_relation_certificates(
+        dag,
+        model,
+        (certificate,),
+        mode="diagnostic",
+        execution_mode="compiled",
+    )
+
+    assert result.dag is dag
+    assert result.report.state == "authenticated-numerical-diagnostic-only"
+    assert result.report.applied_relation_count == 0
+    assert not result.report.warning_required
+    assert result.report.interaction_evaluation_count_projected == 3
+
+
+def test_numerical_relation_set_fails_closed_on_mode_or_source_drift() -> None:
+    dag, model, certificate = _authenticated_relation_for_ambiguous_dag("equal")
+
+    with pytest.raises(ValueError, match="does not replay"):
+        apply_numerical_current_relation_certificates(
+            dag,
+            model,
+            (certificate,),
+            mode="certified-reuse",
+            execution_mode="eager",
+        )
+
+    drifted = replace(
+        dag,
+        interactions=(
+            replace(dag.interactions[0], color_weight=(7.0, 0.0)),
+            *dag.interactions[1:],
+        ),
+    )
+    with pytest.raises(ValueError, match="does not replay"):
+        apply_numerical_current_relation_certificates(
+            drifted,
+            model,
+            (certificate,),
+            mode="certified-reuse",
+            execution_mode="compiled",
+        )
+
+    with pytest.raises(ValueError, match="provenance"):
+        apply_numerical_current_relation_certificates(
+            dag,
+            _RuntimeCouplingBuiltin(),
+            (certificate,),
+            mode="certified-reuse",
+            execution_mode="compiled",
+        )
+
+
+def _observation_points(domain: str) -> tuple[str, ...]:
+    return tuple(
+        hashlib.sha256(f"{domain}:{index}".encode()).hexdigest()
+        for index in range(4)
+    )
+
+
+def _complete_current_observations(
+    dag,
+    *,
+    domain: int,
+) -> dict[int, tuple[tuple[Decimal, Decimal], ...]]:
+    return {
+        current.id: tuple(
+            (
+                Decimal(
+                    domain
+                    + current.id * 10_000
+                    + point_index * 100
+                    + component_index
+                    + 1
+                ),
+                Decimal(
+                    -domain
+                    - current.id * 20_000
+                    - point_index * 200
+                    - component_index
+                    - 1
+                ),
+            )
+            for point_index in range(4)
+            for component_index in range(current.dimension)
+        )
+        for current in dag.currents
+    }
+
+
+def _complete_observation_evidence(
+    dag,
+    model,
+    candidate,
+    verification,
+    *,
+    candidate_points: tuple[str, ...] | None = None,
+    verification_points: tuple[str, ...] | None = None,
+) -> dict[str, Any]:
+    candidate_point_hashes = candidate_points or _observation_points(
+        "candidate"
+    )
+    verification_point_hashes = verification_points or _observation_points(
+        "verification"
+    )
+    candidate_kinematics = _observation_points("candidate-kinematics")
+    verification_kinematics = _observation_points(
+        "verification-kinematics"
+    )
+    candidate_parameters = _observation_points("candidate-parameters")
+    verification_parameters = _observation_points(
+        "verification-parameters"
+    )
+    runtime_schema = build_runtime_expression_schema(
+        dag,
+        model,
+    )
+    runtime_schema_digest = runtime_schema.sha256
+    model_parameter_schema_digest = (
+        generic_dag_numerical_model_parameter_schema_sha256(
+            dag,
+            model,
+        )
+    )
+    source_dag_digest = generic_dag_numerical_source_dag_sha256(dag)
+    candidate_batch_digest = _numerical_current_observation_batch_sha256(
+        candidate,
+        point_sha256s=candidate_point_hashes,
+    )
+    verification_batch_digest = _numerical_current_observation_batch_sha256(
+        verification,
+        point_sha256s=verification_point_hashes,
+    )
+    output_partition_digest = (
+        generic_dag_numerical_capture_output_partition_sha256(
+            runtime_schema.to_mapping()
+        )
+    )
+
+    def capture_digest(
+        point_hashes: tuple[str, ...],
+        kinematic_hashes: tuple[str, ...],
+        parameter_hashes: tuple[str, ...],
+        batch_digest: str,
+    ) -> str:
+        return _canonical_payload_sha256(
+            {
+                "abi": NUMERICAL_CURRENT_CAPTURE_ABI,
+                "precision_digits": 96,
+                "point_sha256s": list(point_hashes),
+                "kinematic_sha256s": list(kinematic_hashes),
+                "parameter_context_sha256s": list(parameter_hashes),
+                "runtime_schema_sha256": runtime_schema_digest,
+                "model_parameter_schema_sha256": (
+                    model_parameter_schema_digest
+                ),
+                "source_dag_sha256": source_dag_digest,
+                "evaluator_output_partition_abi": (
+                    NUMERICAL_CURRENT_CAPTURE_OUTPUT_PARTITION_ABI
+                ),
+                "evaluator_output_partition_sha256": (
+                    output_partition_digest
+                ),
+                "observation_batch_sha256": batch_digest,
+            }
+        )
+
+    return {
+        "candidate_point_sha256s": candidate_point_hashes,
+        "verification_point_sha256s": verification_point_hashes,
+        "candidate_kinematic_sha256s": candidate_kinematics,
+        "verification_kinematic_sha256s": verification_kinematics,
+        "candidate_parameter_context_sha256s": candidate_parameters,
+        "verification_parameter_context_sha256s": verification_parameters,
+        "runtime_schema_sha256": runtime_schema_digest,
+        "source_dag_sha256": source_dag_digest,
+        "evaluator_output_partition_abi": (
+            NUMERICAL_CURRENT_CAPTURE_OUTPUT_PARTITION_ABI
+        ),
+        "evaluator_output_partition_sha256": output_partition_digest,
+        "candidate_capture_sha256": capture_digest(
+            candidate_point_hashes,
+            candidate_kinematics,
+            candidate_parameters,
+            candidate_batch_digest,
+        ),
+        "verification_capture_sha256": capture_digest(
+            verification_point_hashes,
+            verification_kinematics,
+            verification_parameters,
+            verification_batch_digest,
+        ),
+        "process_id": dag.process.key,
+    }
+
+
+@pytest.mark.parametrize("relation_kind", ("equal", "opposite", "zero"))
+def test_complete_warmup_discovers_and_applies_each_relation_kind(
+    relation_kind: str,
+) -> None:
+    dag, model = _ambiguous_projective_dag()
+    candidate = _complete_current_observations(dag, domain=100_000)
+    verification = _complete_current_observations(dag, domain=900_000)
+    if relation_kind == "zero":
+        candidate[5] = tuple(
+            (Decimal(0), Decimal(0)) for _value in candidate[5]
+        )
+        verification[5] = tuple(
+            (Decimal(0), Decimal(0)) for _value in verification[5]
+        )
+    else:
+        sign = Decimal(1) if relation_kind == "equal" else Decimal(-1)
+        candidate[5] = tuple(
+            (sign * real, sign * imaginary)
+            for real, imaginary in candidate[3]
+        )
+        verification[5] = tuple(
+            (sign * real, sign * imaginary)
+            for real, imaginary in verification[3]
+        )
+
+    discovery = discover_generic_dag_numerical_current_relations(
+        dag,
+        model,
+        candidate_observations=candidate,
+        verification_observations=verification,
+        **_complete_observation_evidence(
+            dag,
+            model,
+            candidate,
+            verification,
+        ),
+        execution_mode="compiled",
+        precision_digits=96,
+        seed=0x5059414D,
+        relative_tolerance=1.0e-70,
+        absolute_tolerance=1.0e-80,
+    )
+
+    assert discovery.report.state == "certified_numerical_relations"
+    assert len(discovery.certificates) == 1
+    certificate = discovery.certificates[0]
+    assert certificate.current_id == 5
+    assert certificate.relation_kind == relation_kind
+    applied = apply_numerical_current_relation_certificates(
+        dag,
+        model,
+        discovery.certificates,
+        mode="certified-reuse",
+        execution_mode="compiled",
+    )
+    assert applied.report.applied_relation_count == 1
+    assert applied.report.interaction_evaluation_count_projected == 3
+
+
+def test_complete_warmup_negative_audit_is_first_class_and_warning_free() -> None:
+    dag, model = _ambiguous_projective_dag()
+    candidate = _complete_current_observations(
+        dag,
+        domain=100_000,
+    )
+    verification = _complete_current_observations(
+        dag,
+        domain=900_000,
+    )
+    discovery = discover_generic_dag_numerical_current_relations(
+        dag,
+        model,
+        candidate_observations=candidate,
+        verification_observations=verification,
+        **_complete_observation_evidence(
+            dag,
+            model,
+            candidate,
+            verification,
+        ),
+        execution_mode="compiled",
+        precision_digits=96,
+        seed=0x5059414D,
+        relative_tolerance=1.0e-70,
+        absolute_tolerance=1.0e-80,
+    )
+
+    assert discovery.certificates == ()
+    assert discovery.report.state == "no_certified_numerical_relation"
+    assert discovery.report.numerical_candidate_count == 0
+    assert discovery.report.nearest_rejected_hypothesis is not None
+    payload = discovery.report.to_json_dict()
+    assert payload["warning"]["required"] is False
+    assert payload["certified_numerical_relation_count"] == 0
+    candidate_index = payload["candidate_index"]
+    assert candidate_index["completeness"] == (
+        "complete-within-configured-tolerance"
+    )
+    assert (
+        candidate_index["screened_pair_hypothesis_count"]
+        < candidate_index["theoretical_pair_hypothesis_count"]
+    )
+    assert discovery.report.tested_hypothesis_count == (
+        candidate_index["zero_hypothesis_count"]
+        + candidate_index["screened_pair_hypothesis_count"]
+    )
+
+
+@pytest.mark.parametrize(
+    ("field", "replacement"),
+    (
+        (
+            "evaluator_output_partition_abi",
+            "pyamplicol-stale-current-output-partitions-v0",
+        ),
+        (
+            "evaluator_output_partition_sha256",
+            hashlib.sha256(b"stale-current-output-partitions").hexdigest(),
+        ),
+    ),
+)
+def test_discovery_recomputes_and_rejects_stale_output_partition_evidence(
+    field: str,
+    replacement: str,
+) -> None:
+    dag, model = _ambiguous_projective_dag()
+    candidate = _complete_current_observations(dag, domain=100_000)
+    verification = _complete_current_observations(dag, domain=900_000)
+    evidence = _complete_observation_evidence(
+        dag,
+        model,
+        candidate,
+        verification,
+    )
+    evidence[field] = replacement
+    model_parameter_schema_digest = (
+        generic_dag_numerical_model_parameter_schema_sha256(dag, model)
+    )
+
+    for domain, observations in (
+        ("candidate", candidate),
+        ("verification", verification),
+    ):
+        point_hashes = tuple(evidence[f"{domain}_point_sha256s"])
+        batch_digest = _numerical_current_observation_batch_sha256(
+            observations,
+            point_sha256s=point_hashes,
+        )
+        evidence[f"{domain}_capture_sha256"] = _canonical_payload_sha256(
+            {
+                "abi": NUMERICAL_CURRENT_CAPTURE_ABI,
+                "precision_digits": 96,
+                "point_sha256s": list(point_hashes),
+                "kinematic_sha256s": list(
+                    evidence[f"{domain}_kinematic_sha256s"]
+                ),
+                "parameter_context_sha256s": list(
+                    evidence[
+                        f"{domain}_parameter_context_sha256s"
+                    ]
+                ),
+                "runtime_schema_sha256": evidence[
+                    "runtime_schema_sha256"
+                ],
+                "model_parameter_schema_sha256": (
+                    model_parameter_schema_digest
+                ),
+                "source_dag_sha256": evidence["source_dag_sha256"],
+                "evaluator_output_partition_abi": evidence[
+                    "evaluator_output_partition_abi"
+                ],
+                "evaluator_output_partition_sha256": evidence[
+                    "evaluator_output_partition_sha256"
+                ],
+                "observation_batch_sha256": batch_digest,
+            }
+        )
+
+    with pytest.raises(ValueError, match="point contract"):
+        discover_generic_dag_numerical_current_relations(
+            dag,
+            model,
+            candidate_observations=candidate,
+            verification_observations=verification,
+            **evidence,
+            execution_mode="compiled",
+            precision_digits=96,
+            seed=0x5059414D,
+            relative_tolerance=1.0e-70,
+            absolute_tolerance=1.0e-80,
+        )
+
+
+@pytest.mark.parametrize(
+    ("difference", "expected_relation_count"),
+    (
+        (Decimal("0.125"), 1),
+        (Decimal("0.125000000000000000000000000001"), 0),
+    ),
+)
+@pytest.mark.parametrize("ambient_precision", (28, 50, 96))
+def test_candidate_index_is_complete_at_absolute_tolerance_boundary(
+    difference: Decimal,
+    expected_relation_count: int,
+    ambient_precision: int,
+) -> None:
+    dag, model = _ambiguous_projective_dag()
+    candidate = _complete_current_observations(dag, domain=100_000)
+    verification = _complete_current_observations(dag, domain=900_000)
+    with localcontext() as construction_context:
+        construction_context.prec = 128
+        candidate[5] = tuple(
+            (real + difference, imaginary)
+            for real, imaginary in candidate[3]
+        )
+        verification[5] = tuple(
+            (real + difference, imaginary)
+            for real, imaginary in verification[3]
+        )
+
+    with localcontext() as context:
+        context.prec = ambient_precision
+        discovery = discover_generic_dag_numerical_current_relations(
+            dag,
+            model,
+            candidate_observations=candidate,
+            verification_observations=verification,
+            **_complete_observation_evidence(
+                dag,
+                model,
+                candidate,
+                verification,
+            ),
+            execution_mode="compiled",
+            precision_digits=96,
+            seed=0x5059414D,
+            relative_tolerance=0.0,
+            absolute_tolerance=0.125,
+        )
+
+    assert len(discovery.certificates) == expected_relation_count
+
+
+def test_candidate_index_relative_window_uses_complete_complex_pair_scale() -> None:
+    observations = {
+        0: ((Decimal(0), Decimal("1e100")),),
+        1: ((Decimal("1e30"), Decimal("1e100")),),
+    }
+    index = _build_numerical_observation_candidate_index(
+        (0, 1),
+        observations,
+    )
+
+    assert _numerical_observation_tolerance_window_ids(
+        index,
+        observations[1],
+        relation_kind="equal",
+        current_id=1,
+        relative_tolerance=Decimal("1e-70"),
+        absolute_tolerance=Decimal(0),
+        precision_digits=96,
+    ) == (0,)
+
+
+@pytest.mark.parametrize("relative_tolerance", ("0", "0.1", "0.9"))
+@pytest.mark.parametrize("relation_kind", ("equal", "opposite"))
+def test_candidate_index_window_contains_every_small_exhaustive_match(
+    relative_tolerance: str,
+    relation_kind: str,
+) -> None:
+    values = tuple(map(Decimal, (-10, -1, 0, 1, 10)))
+    relative = Decimal(relative_tolerance)
+    absolute = Decimal("0.25")
+    sign = Decimal(1) if relation_kind == "equal" else Decimal(-1)
+    for components in product(values, repeat=4):
+        (
+            representative_real,
+            representative_imaginary,
+            current_real,
+            current_imaginary,
+        ) = components
+        representative = (representative_real, representative_imaginary)
+        current = (current_real, current_imaginary)
+        reference = (
+            sign * representative_real,
+            sign * representative_imaginary,
+        )
+        difference = max(
+            abs(current_real - reference[0]),
+            abs(current_imaginary - reference[1]),
+        )
+        scale = max(
+            abs(current_real),
+            abs(current_imaginary),
+            abs(reference[0]),
+            abs(reference[1]),
+        )
+        if difference > absolute + relative * scale:
+            continue
+        observations = {0: (representative,), 1: (current,)}
+        index = _build_numerical_observation_candidate_index(
+            (0, 1),
+            observations,
+        )
+        assert 0 in _numerical_observation_tolerance_window_ids(
+            index,
+            observations[1],
+            relation_kind=relation_kind,  # type: ignore[arg-type]
+            current_id=1,
+            relative_tolerance=relative,
+            absolute_tolerance=absolute,
+            precision_digits=96,
+        )
+
+
+def test_candidate_only_relation_is_rejected_by_independent_points() -> None:
+    dag, model = _ambiguous_projective_dag()
+    candidate = _complete_current_observations(dag, domain=100_000)
+    verification = _complete_current_observations(dag, domain=900_000)
+    candidate[5] = candidate[3]
+
+    discovery = discover_generic_dag_numerical_current_relations(
+        dag,
+        model,
+        candidate_observations=candidate,
+        verification_observations=verification,
+        **_complete_observation_evidence(
+            dag,
+            model,
+            candidate,
+            verification,
+        ),
+        execution_mode="compiled",
+        precision_digits=96,
+        seed=0x5059414D,
+        relative_tolerance=1.0e-70,
+        absolute_tolerance=1.0e-80,
+    )
+
+    assert discovery.certificates == ()
+    assert discovery.report.state == "no_certified_numerical_relation"
+    assert discovery.report.numerical_candidate_count == 1
+    assert discovery.report.verification_rejected_count == 1
+    assert any(
+        item["reason"] == "independent-verification-rejected-candidate"
+        for item in discovery.report.rejected_candidates
+    )
+    payload = discovery.report.to_json_dict()
+    assert payload["rejected_hypothesis_count"] == (
+        payload["tested_hypothesis_count"]
+        - payload["certified_numerical_relation_count"]
+    )
+    diagnostics = payload["rejected_candidate_diagnostics"]
+    assert diagnostics["total_rejected_hypothesis_count"] == payload[
+        "rejected_hypothesis_count"
+    ]
+    assert diagnostics["full_rejection_sha256"] == (
+        discovery.report.rejected_decision_sha256
+    )
+
+
+def test_warmup_requires_disjoint_candidate_and_verification_points() -> None:
+    dag, model = _ambiguous_projective_dag()
+    observations = _complete_current_observations(dag, domain=100_000)
+    points = _observation_points("shared")
+
+    with pytest.raises(ValueError, match="point contract"):
+        discover_generic_dag_numerical_current_relations(
+            dag,
+            model,
+            candidate_observations=observations,
+            verification_observations=observations,
+            **_complete_observation_evidence(
+                dag,
+                model,
+                observations,
+                observations,
+                candidate_points=points,
+                verification_points=points,
+            ),
+            execution_mode="compiled",
+            precision_digits=96,
+            seed=0x5059414D,
+            relative_tolerance=1.0e-70,
+            absolute_tolerance=1.0e-80,
+        )
diff --git a/pyamplicol/tests/unit/test_release_commands.py b/pyamplicol/tests/unit/test_release_commands.py
new file mode 100644
index 0000000000..08ac9b0c2a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_release_commands.py
@@ -0,0 +1,547 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import subprocess
+import sys
+import tomllib
+import zipfile
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tools" / "release"))
+
+import _artifacts as release_artifacts  # noqa: E402
+import build_from_sdist  # noqa: E402
+import build_release_artifacts  # noqa: E402
+import install_wheel  # noqa: E402
+import publish_dry_run  # noqa: E402
+import test_deployment as release_deployment  # noqa: E402
+from _common import ReleaseError  # noqa: E402
+
+
+def _dependency_wheel(
+    directory: Path,
+    distribution: str,
+    version: str,
+    tag: str,
+) -> Path:
+    directory.mkdir(parents=True, exist_ok=True)
+    normalized = distribution.replace("-", "_")
+    wheel = directory / f"{normalized}-{version}-{tag}.whl"
+    dist_info = f"{normalized}-{version}.dist-info"
+    with zipfile.ZipFile(wheel, "w") as archive:
+        archive.writestr(
+            f"{dist_info}/METADATA",
+            f"Metadata-Version: 2.4\nName: {distribution}\nVersion: {version}\n\n",
+        )
+        archive.writestr(
+            f"{dist_info}/WHEEL",
+            f"Wheel-Version: 1.0\nTag: {tag}\n\n",
+        )
+    return wheel
+
+
+@pytest.fixture
+def candidate_dependency_provenance(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    contributor_path = tmp_path / "contributor-lock.toml"
+    state_path = tmp_path / "install-state.json"
+    contributor_data = (ROOT / "dependencies" / "contributor-lock.toml").read_bytes()
+    contributor_path.write_bytes(contributor_data)
+    contributor = tomllib.loads(contributor_data.decode("utf-8"))
+    symbolica = contributor["symbolica"]
+    state_path.write_text(
+        json.dumps(
+            {
+                "publishable": False,
+                "schema_version": 1,
+                "sources": {
+                    "symbolica": {
+                        "revision": symbolica["candidate_revision"],
+                        "url": symbolica["source_url"],
+                    }
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        release_artifacts,
+        "_CONTRIBUTOR_DEPENDENCY_LOCK",
+        contributor_path,
+    )
+    monkeypatch.setattr(
+        release_artifacts,
+        "_CANDIDATE_INSTALL_STATE",
+        state_path,
+    )
+
+
+def test_select_compatible_abi3_wheel_uses_target_tag_order(tmp_path: Path) -> None:
+    mac = tmp_path / "pyamplicol-0.1.0-cp311-abi3-macosx_11_0_arm64.whl"
+    linux = tmp_path / "pyamplicol-0.1.0-cp311-abi3-manylinux_2_28_x86_64.whl"
+    mac.touch()
+    linux.touch()
+    selected = install_wheel.select_compatible_wheel(
+        [linux, mac],
+        [
+            "cp314-cp314-macosx_15_0_arm64",
+            "cp311-abi3-macosx_11_0_arm64",
+            "py3-none-any",
+        ],
+    )
+    assert selected == mac.resolve()
+
+
+@pytest.mark.parametrize(
+    ("mode", "candidate_flag"),
+    [("candidate", True), ("release", False)],
+)
+def test_install_builds_through_release_artifact_tool_when_missing(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    mode: str,
+    candidate_flag: bool,
+) -> None:
+    observed: dict[str, object] = {}
+
+    def fake_run(command, *, cwd, env, **_kwargs):
+        observed.update(command=list(map(os.fspath, command)), cwd=cwd, env=env)
+        return subprocess.CompletedProcess(command, 0, "", "")
+
+    monkeypatch.setenv("PYTHONPATH", "/parent/source")
+    monkeypatch.setattr(install_wheel, "run", fake_run)
+    install_wheel.build_if_missing(mode, tmp_path)
+    command = observed["command"]
+    assert isinstance(command, list)
+    assert command[1].endswith("build_release_artifacts.py")
+    assert ("--candidate" in command) is candidate_flag
+    assert observed["cwd"] == ROOT
+    environment = observed["env"]
+    assert isinstance(environment, dict)
+    assert "PYTHONPATH" not in environment
+
+
+def test_deployment_path_guard_allows_only_the_isolated_sandbox(
+    tmp_path: Path,
+) -> None:
+    checkout = tmp_path / "checkout"
+    sandbox = checkout / "PYPI_DEPLOYMENT_TEST" / "release-1"
+    site_packages = sandbox / "venv" / "lib" / "site-packages"
+    source = checkout / "src"
+    environment = {
+        **os.environ,
+        "PYAMPLICOL_FORBIDDEN_ROOT": str(checkout),
+        "PYAMPLICOL_DEPLOYMENT_SANDBOX": str(sandbox),
+    }
+
+    def guarded_path(path: Path) -> subprocess.CompletedProcess[str]:
+        script = (
+            "import os\nfrom pathlib import Path\nimport sys\n"
+            f"sys.path[:] = [{str(path)!r}]\n"
+            + release_deployment._PATH_ISOLATION_SMOKE
+        )
+        return subprocess.run(
+            [sys.executable, "-I", "-c", script],
+            env=environment,
+            capture_output=True,
+            text=True,
+        )
+
+    assert guarded_path(site_packages).returncode == 0
+    assert guarded_path(source).returncode != 0
+
+
+def test_candidate_deployment_installs_source_dependencies_by_exact_local_path(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    candidate_dependency_provenance: None,
+) -> None:
+    wheelhouse = tmp_path / "wheelhouse"
+    contributor = tomllib.loads(
+        (ROOT / "dependencies/contributor-lock.toml").read_text(encoding="utf-8")
+    )
+    release = tomllib.loads(
+        (ROOT / "dependencies/release-lock.toml").read_text(encoding="utf-8")
+    )
+    symbolica_version = contributor["symbolica"]["candidate_version"]
+    loader_version = release["ufo_model_loader"]["required_version"]
+    symbolica = _dependency_wheel(
+        wheelhouse / "symbolica",
+        "symbolica",
+        symbolica_version,
+        "cp311-abi3-test_platform",
+    )
+    release_symbolica = _dependency_wheel(
+        wheelhouse / "release-symbolica",
+        "symbolica",
+        "2.1.0",
+        "cp311-abi3-test_platform",
+    )
+    loader = _dependency_wheel(
+        wheelhouse / "ufo-model-loader",
+        "ufo-model-loader",
+        loader_version,
+        "py3-none-any",
+    )
+    commands: list[list[str]] = []
+
+    def fake_run(command, **_kwargs):
+        commands.append([os.fspath(item) for item in command])
+        return subprocess.CompletedProcess(command, 0, "", "")
+
+    monkeypatch.setattr(release_deployment, "run", fake_run)
+    virtual_env = tmp_path / "venv"
+    installation = release_deployment._install_dependencies(
+        Path(sys.executable),
+        virtual_env=virtual_env,
+        mode="candidate",
+        wheelhouses=[wheelhouse],
+        supported_tags=["cp311-abi3-test_platform", "py3-none-any"],
+    )
+
+    assert installation.local_wheels == {
+        "symbolica": symbolica.resolve(),
+        "ufo-model-loader": loader.resolve(),
+    }
+    assert installation.versions["symbolica"] == symbolica_version
+    assert installation.versions["ufo-model-loader"] == loader_version
+    assert len(commands) == 1
+    command = commands[0]
+    assert "--require-hashes" not in command
+    assert "--find-links" not in command
+    assert "--index-url" in command
+    assert str(symbolica.resolve()) in command
+    assert str(release_symbolica.resolve()) not in command
+    assert str(loader.resolve()) in command
+    assert not any(item.startswith("ufo-model-loader==") for item in command)
+    assert "numpy==2.4.6" in command
+    assert not any(item.startswith("python-utils==") for item in command)
+    assert not any(item.startswith("typing-extensions==") for item in command)
+    assert not any(item.startswith("wcwidth==") for item in command)
+    assert not (tmp_path / "locked-requirements.txt").exists()
+
+
+def test_candidate_deployment_rejects_ambiguous_local_patched_wheels(
+    tmp_path: Path,
+) -> None:
+    first = tmp_path / "first"
+    second = tmp_path / "second"
+    for directory in (first, second):
+        _dependency_wheel(
+            directory,
+            "symbolica",
+            "2.1.0",
+            "cp311-abi3-test_platform",
+        )
+    with pytest.raises(ReleaseError, match="expected one compatible local symbolica"):
+        release_deployment._candidate_dependency_wheels(
+            {"symbolica": "2.1.0"},
+            [first, second],
+            ["cp311-abi3-test_platform", "py3-none-any"],
+        )
+
+
+def test_candidate_deployment_rejects_symlinked_wheelhouse(tmp_path: Path) -> None:
+    wheelhouse = tmp_path / "wheelhouse"
+    wheelhouse.mkdir()
+    linked = tmp_path / "linked-wheelhouse"
+    linked.symlink_to(wheelhouse, target_is_directory=True)
+    with pytest.raises(ReleaseError, match="wheelhouse may not be a symlink"):
+        release_deployment._candidate_dependency_wheels(
+            {"symbolica": "2.1.0"},
+            [linked],
+            ["py3-none-any"],
+        )
+
+
+def test_sdist_build_uses_clean_external_source_without_byte_parity(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source_wheel = tmp_path / "pyamplicol-0.1.0-cp311-abi3-test.whl"
+    source_wheel.write_bytes(b"source wheel")
+    sdist = tmp_path / "pyamplicol-0.1.0.tar.gz"
+    sdist.write_bytes(b"sdist")
+    scratch = tmp_path / "external"
+    extracted = scratch / "unpacked" / "pyamplicol-0.1.0"
+    extracted.mkdir(parents=True)
+    observed: dict[str, object] = {}
+
+    @contextlib.contextmanager
+    def fake_temporary(_prefix: str):
+        scratch.mkdir(exist_ok=True)
+        yield scratch
+
+    def fake_run(command, *, cwd, env, **_kwargs):
+        observed["python"] = Path(command[0])
+        observed["cwd"] = cwd
+        observed["env"] = env
+        output = Path(command[command.index("--outdir") + 1])
+        output.mkdir(exist_ok=True)
+        (output / source_wheel.name).write_bytes(b"independently rebuilt wheel")
+        return subprocess.CompletedProcess(command, 0, "", "")
+
+    monkeypatch.setenv("PYTHONPATH", "/parent/source")
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(build_from_sdist, "audit_sdist", lambda *_a, **_k: None)
+    monkeypatch.setattr(
+        build_from_sdist,
+        "audit_wheel",
+        lambda *_a, **_k: SimpleNamespace(
+            version="0.1.0",
+            python_tag="cp311",
+            abi_tag="abi3",
+            target="test",
+            rust_target="test-target",
+        ),
+    )
+    monkeypatch.setattr(
+        build_from_sdist, "external_temporary_directory", fake_temporary
+    )
+    monkeypatch.setattr(build_from_sdist, "safe_extract_sdist", lambda *_a: extracted)
+    monkeypatch.setattr(build_from_sdist, "run", fake_run)
+    output = tmp_path / "retained"
+    rebuilt = build_from_sdist.build_wheel_from_sdist(
+        sdist,
+        source_wheel,
+        output,
+        mode="release",
+        python=Path(".venv/bin/python"),
+    )
+    assert rebuilt.read_bytes() == b"independently rebuilt wheel"
+    assert observed["cwd"] == extracted
+    assert observed["python"] == (tmp_path / ".venv/bin/python").resolve()
+    assert "PYTHONPATH" not in observed["env"]
+
+
+def test_release_gate_failure_prevents_artifact_build(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    built = False
+
+    monkeypatch.setattr(
+        build_release_artifacts, "require_clean_checkout", lambda **_kwargs: None
+    )
+
+    def closed_gate(*_args, **_kwargs):
+        raise ReleaseError("closed by check_dependencies")
+
+    def unexpected_build(*_args, **_kwargs):
+        nonlocal built
+        built = True
+
+    monkeypatch.setattr(build_release_artifacts, "check_dependency_gate", closed_gate)
+    monkeypatch.setattr(build_release_artifacts, "_build", unexpected_build)
+    with pytest.raises(ReleaseError, match="check_dependencies"):
+        build_release_artifacts.build_release_artifacts(
+            tmp_path / "output",
+            mode="release",
+            python=Path(sys.executable),
+            allow_dirty_candidate=False,
+            sdist_only=False,
+            retained_sdist_path=None,
+        )
+    assert built is False
+
+
+def test_release_build_normalizes_python_without_inspecting_git_cleanliness(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    scratch = tmp_path / "scratch"
+
+    @contextlib.contextmanager
+    def fake_temporary(_prefix: str):
+        scratch.mkdir()
+        yield scratch
+
+    def unexpected_cleanliness_check(**_kwargs) -> None:
+        raise AssertionError("release builds must validate artifacts, not Git status")
+
+    def fake_build(
+        _python: Path,
+        destination: Path,
+        *,
+        mode: str,
+        wheel: bool,
+        sdist: bool,
+    ) -> None:
+        assert _python == (tmp_path / ".venv/bin/python").resolve()
+        assert mode == "release"
+        assert wheel is False
+        assert sdist is True
+        (destination / "pyamplicol-0.1.0.tar.gz").write_bytes(b"sdist")
+
+    monkeypatch.setattr(
+        build_release_artifacts,
+        "check_dependency_gate",
+        lambda _mode: None,
+    )
+    monkeypatch.setattr(
+        build_release_artifacts,
+        "require_clean_checkout",
+        unexpected_cleanliness_check,
+    )
+    monkeypatch.setattr(
+        build_release_artifacts,
+        "external_temporary_directory",
+        fake_temporary,
+    )
+    monkeypatch.setattr(build_release_artifacts, "_build", fake_build)
+    monkeypatch.setattr(build_release_artifacts, "audit_sdist", lambda *_a, **_k: None)
+
+    monkeypatch.chdir(tmp_path)
+    artifacts = build_release_artifacts.build_release_artifacts(
+        tmp_path / "output",
+        mode="release",
+        python=Path(".venv/bin/python"),
+        allow_dirty_candidate=False,
+        sdist_only=True,
+        retained_sdist_path=None,
+    )
+
+    assert [path.name for path in artifacts] == ["pyamplicol-0.1.0.tar.gz"]
+
+
+def test_publish_dry_run_prints_but_never_executes_upload(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    wheel = tmp_path / "pyamplicol-0.1.0-cp311-abi3-test.whl"
+    sdist = tmp_path / "pyamplicol-0.1.0.tar.gz"
+    wheel.write_bytes(b"wheel")
+    sdist.write_bytes(b"sdist")
+    commands: list[list[str]] = []
+    clean_install_wheels: list[Path] = []
+
+    monkeypatch.delenv("PYAMPLICOL_BUILD_MODE", raising=False)
+    monkeypatch.setattr(
+        publish_dry_run, "check_dependency_gate", lambda *_a, **_k: None
+    )
+    monkeypatch.setattr(
+        publish_dry_run,
+        "audit_wheel",
+        lambda *_a, **_k: SimpleNamespace(target="test"),
+    )
+    monkeypatch.setattr(publish_dry_run, "audit_sdist", lambda *_a, **_k: None)
+
+    def fake_run(command, **_kwargs):
+        commands.append([os.fspath(item) for item in command])
+        return subprocess.CompletedProcess(command, 0, "", "")
+
+    monkeypatch.setattr(publish_dry_run, "run", fake_run)
+    monkeypatch.setattr(
+        publish_dry_run,
+        "_run_clean_install",
+        lambda wheels: clean_install_wheels.extend(wheels),
+    )
+    assert (
+        publish_dry_run.main(
+            ["--artifact-dir", str(tmp_path), "--no-build", "--skip-twine-check"]
+        )
+        == 0
+    )
+    output = capsys.readouterr().out
+    assert "twine upload" in output
+    assert commands == []
+    assert clean_install_wheels == [wheel]
+
+
+def test_publish_dry_run_stages_plain_cross_platform_package_files(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    incoming = tmp_path / "incoming"
+    output = tmp_path / "upload"
+    platforms = (
+        "macosx_11_0_arm64",
+        "macosx_11_0_x86_64",
+        "manylinux_2_28_x86_64",
+    )
+    for index, platform in enumerate(platforms):
+        directory = incoming / f"platform-{index}"
+        directory.mkdir(parents=True)
+        (directory / f"pyamplicol-0.1.0-cp311-abi3-{platform}.whl").write_bytes(
+            platform.encode()
+        )
+    source = incoming / "source"
+    source.mkdir(parents=True)
+    (source / "pyamplicol-0.1.0.tar.gz").write_bytes(b"sdist")
+
+    monkeypatch.delenv("PYAMPLICOL_BUILD_MODE", raising=False)
+    monkeypatch.setattr(
+        publish_dry_run, "check_dependency_gate", lambda *_a, **_k: None
+    )
+    monkeypatch.setattr(publish_dry_run, "audit_sdist", lambda *_a, **_k: None)
+
+    def fake_audit_wheel(path: Path, **_kwargs):
+        target = next(platform for platform in platforms if platform in path.name)
+        return SimpleNamespace(target=target)
+
+    monkeypatch.setattr(publish_dry_run, "audit_wheel", fake_audit_wheel)
+    assert (
+        publish_dry_run.main(
+            [
+                "--artifact-dir",
+                str(incoming),
+                "--output-dir",
+                str(output),
+                "--no-build",
+                "--require-all-targets",
+                "--skip-twine-check",
+                "--skip-clean-install",
+            ]
+        )
+        == 0
+    )
+    assert sorted(path.name for path in output.iterdir()) == [
+        "pyamplicol-0.1.0-cp311-abi3-macosx_11_0_arm64.whl",
+        "pyamplicol-0.1.0-cp311-abi3-macosx_11_0_x86_64.whl",
+        "pyamplicol-0.1.0-cp311-abi3-manylinux_2_28_x86_64.whl",
+        "pyamplicol-0.1.0.tar.gz",
+    ]
+
+
+def test_candidate_dry_run_accepts_wheel_only_and_withholds_upload(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    wheel = tmp_path / "pyamplicol-candidate-cp311-abi3-test.whl"
+    wheel.write_bytes(b"candidate wheel")
+    monkeypatch.delenv("PYAMPLICOL_BUILD_MODE", raising=False)
+    monkeypatch.setattr(
+        publish_dry_run, "check_dependency_gate", lambda *_a, **_k: None
+    )
+    monkeypatch.setattr(
+        publish_dry_run,
+        "audit_wheel",
+        lambda *_a, **_k: SimpleNamespace(target="test"),
+    )
+    assert (
+        publish_dry_run.main(
+            [
+                "--candidate",
+                "--artifact-dir",
+                str(tmp_path),
+                "--no-build",
+                "--skip-twine-check",
+            ]
+        )
+        == 0
+    )
+    output = capsys.readouterr().out
+    assert "non-publishable" in output
+    assert "twine upload" not in output
diff --git a/pyamplicol/tests/unit/test_release_common.py b/pyamplicol/tests/unit/test_release_common.py
new file mode 100644
index 0000000000..fb1f7c7bd6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_release_common.py
@@ -0,0 +1,109 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import io
+import os
+import subprocess
+import sys
+import tarfile
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tools" / "release"))
+
+import _common  # noqa: E402
+
+
+def _tar(path: Path, name: str, data: bytes = b"content") -> None:
+    with tarfile.open(path, "w:gz") as archive:
+        info = tarfile.TarInfo(name)
+        info.size = len(data)
+        archive.addfile(info, io.BytesIO(data))
+
+
+def test_clean_environment_removes_python_and_pip_injection(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYTHONPATH", "/parent/source")
+    monkeypatch.setenv("PYTHONHOME", "/parent/python")
+    monkeypatch.setenv("PIP_FIND_LINKS", "/parent/wheels")
+    monkeypatch.setenv("PIP_INDEX_URL", "https://example.invalid/simple")
+    environment = _common.clean_environment(mode="candidate")
+    assert "PYTHONPATH" not in environment
+    assert "PYTHONHOME" not in environment
+    assert "PIP_FIND_LINKS" not in environment
+    assert "PIP_INDEX_URL" not in environment
+    assert environment["PIP_CONFIG_FILE"] == os.devnull
+    assert environment["PYAMPLICOL_BUILD_MODE"] == "candidate"
+
+
+def test_safe_sdist_extraction_rejects_traversal_and_links(tmp_path: Path) -> None:
+    traversal = tmp_path / "traversal.tar.gz"
+    _tar(traversal, "../outside")
+    with pytest.raises(_common.ReleaseError, match="unsafe"):
+        _common.safe_extract_sdist(traversal, tmp_path / "traversal-output")
+
+    linked = tmp_path / "linked.tar.gz"
+    with tarfile.open(linked, "w:gz") as archive:
+        info = tarfile.TarInfo("project/link")
+        info.type = tarfile.SYMTYPE
+        info.linkname = "/etc/passwd"
+        archive.addfile(info)
+    with pytest.raises(_common.ReleaseError, match="regular files"):
+        _common.safe_extract_sdist(linked, tmp_path / "linked-output")
+
+
+def test_safe_sdist_extraction_returns_one_clean_root(tmp_path: Path) -> None:
+    sdist = tmp_path / "valid.tar.gz"
+    _tar(sdist, "project-0.1.0/pyproject.toml", b"[project]\n")
+    root = _common.safe_extract_sdist(sdist, tmp_path / "output")
+    assert root == tmp_path / "output" / "project-0.1.0"
+    assert (root / "pyproject.toml").read_bytes() == b"[project]\n"
+
+
+def test_dependency_gate_uses_candidate_and_release_contracts(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    commands: list[list[str]] = []
+
+    def fake_run(command, **_kwargs):
+        commands.append([os.fspath(item) for item in command])
+        return subprocess.CompletedProcess(command, 0, "", "")
+
+    monkeypatch.setattr(_common, "run", fake_run)
+    _common.check_dependency_gate("candidate")
+    _common.check_dependency_gate("release")
+    assert commands[0][-1:] == ["--candidate"]
+    assert "--candidate" not in commands[1]
+
+
+def test_build_mode_rejects_conflicting_candidate_request(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "release")
+    with pytest.raises(_common.ReleaseError, match="conflicts"):
+        _common.build_mode(candidate=True)
+
+
+def test_container_root_checkout_does_not_treat_filesystem_root_as_workspace(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(_common, "ROOT", Path("/io"))
+    assert _common.containing_workspace() == Path("/io")
+    assert not _common.is_relative_to(Path("/tmp/release-build"), Path("/io"))
+
+
+def test_release_temporary_path_accepts_only_external_or_artifact_scratch(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(_common, "ROOT", Path("/io/pyamplicol"))
+    assert _common._release_temporary_path_is_isolated(
+        Path("/io/pyamplicol/.artifacts/migration/tmp/build")
+    )
+    assert _common._release_temporary_path_is_isolated(Path("/tmp/release-build"))
+    assert not _common._release_temporary_path_is_isolated(
+        Path("/io/other-checkout/release-build")
+    )
diff --git a/pyamplicol/tests/unit/test_reporting_summary.py b/pyamplicol/tests/unit/test_reporting_summary.py
new file mode 100644
index 0000000000..2dcae110d2
--- /dev/null
+++ b/pyamplicol/tests/unit/test_reporting_summary.py
@@ -0,0 +1,1493 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import io
+import itertools
+import json
+from dataclasses import dataclass, replace
+from decimal import Decimal
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.api import (
+    BenchmarkComponentTiming,
+    BenchmarkProfileCounters,
+    BenchmarkResult,
+    BenchmarkStageTiming,
+    BenchmarkStatistics,
+    BenchmarkTimingBreakdown,
+    GenerationResult,
+    ProcessRequest,
+    ProcessSet,
+    ResolvedEvaluation,
+)
+from pyamplicol.artifacts import (
+    ArtifactAliasInspection,
+    ArtifactDependencyInspection,
+    ArtifactInspection,
+    ArtifactProcessInspection,
+)
+from pyamplicol.artifacts.inspection import (
+    ArtifactProcessGroupInspection,
+    ArtifactProcessGroupMemberInspection,
+    ArtifactProcessGroupSelection,
+    ArtifactProcessGroupsInspection,
+)
+from pyamplicol.cli.main import write_result
+from pyamplicol.cli.utilities import ExampleEntry, UtilityResult
+from pyamplicol.config import BenchmarkConfig
+from pyamplicol.diagnostics import DiagnosticCheck, DiagnosticReport
+from pyamplicol.reporting import render_summary
+
+
+@dataclass(frozen=True)
+class _Result:
+    status: str
+    generated_processes: int
+    adjustments: tuple[str, ...]
+
+
+def test_human_structured_results_use_aligned_prettytable() -> None:
+    rendered = render_summary(_Result("complete", 2, ()), color=False)
+    assert rendered is not None
+    assert set(rendered.splitlines()[-1]) <= {"+", "-"}
+    assert "field" in rendered
+    assert "generated processes" in rendered
+    assert "complete" in rendered
+
+
+def test_examples_and_diagnostics_have_dedicated_colored_record_tables() -> None:
+    examples = (
+        ExampleEntry("otf_pp_zjj", "generate", "OTF p p > Z j j walkthrough"),
+        ExampleEntry("benchmark", "benchmark", "Profile one process output"),
+    )
+    rendered_examples = render_summary(examples, color=True)
+    assert rendered_examples is not None
+    assert "Packaged Examples" in rendered_examples
+    assert "name" in rendered_examples
+    assert "action" in rendered_examples
+    assert "description" in rendered_examples
+    assert "\x1b[" in rendered_examples
+    assert not rendered_examples.lstrip().startswith("[")
+
+    diagnostics = DiagnosticReport(
+        "0.1.4",
+        (
+            DiagnosticCheck("native-sdk", "pass", "ABI 1"),
+            DiagnosticCheck("symbolica", "warning", "restricted single-core"),
+        ),
+    )
+    rendered_diagnostics = render_summary(diagnostics, color=True)
+    assert rendered_diagnostics is not None
+    assert "pyAmpliCol Diagnostics" in rendered_diagnostics
+    assert "native-sdk" in rendered_diagnostics
+    assert "\x1b[32mpass" in rendered_diagnostics
+    assert "\x1b[33mwarning" in rendered_diagnostics
+
+
+def test_human_renderer_never_embeds_or_falls_back_to_json() -> None:
+    result = {
+        "status": "complete",
+        "nested": {"worker_count": 4, "backend": "jit"},
+        "entries": (
+            {"name": "first", "process": "d d~ > z"},
+            {"name": "second", "process": "u d~ > w+"},
+        ),
+    }
+    stream = io.StringIO()
+    write_result(result, format="human", stream=stream, color=False)
+    output = stream.getvalue()
+    assert "worker count" in output
+    assert "Entries" in output
+    assert '"status"' not in output
+    assert "[{" not in output
+    with pytest.raises(json.JSONDecodeError):
+        json.loads(output)
+
+    operation = UtilityResult("examples copy", "complete", Path("examples"))
+    rendered = render_summary(operation, color=False)
+    assert rendered is not None
+    assert "Operation Complete" in rendered
+    assert "destination" in rendered
+
+
+def test_generation_mode_is_labelled_as_existing_output_policy() -> None:
+    rendered = render_summary(
+        GenerationResult(
+            output=Path("artifact"),
+            processes=ProcessSet((ProcessRequest.parse("d d~ > z"),)),
+            mode="error",
+        ),
+        color=True,
+    )
+
+    assert rendered is not None
+    assert "existing-output policy" in rendered
+    assert "error" in rendered
+    assert "\x1b[36mexisting-output policy" in rendered
+    assert "\x1b[33merror" in rendered
+    assert "\x1b[31merror" not in rendered
+
+
+def test_generation_summary_compacts_file_inventory(
+    monkeypatch, tmp_path: Path
+) -> None:
+    artifact = tmp_path / "artifact"
+    artifact.mkdir()
+    (artifact / "artifact.json").write_bytes(b"x" * 24)
+    manifest = SimpleNamespace(
+        payloads=(
+            SimpleNamespace(size_bytes=1000),
+            SimpleNamespace(size_bytes=500),
+        )
+    )
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.load_manifest",
+        lambda *_args, **_kwargs: manifest,
+    )
+    result = GenerationResult(
+        output=artifact,
+        processes=ProcessSet((ProcessRequest.parse("d d~ > z"),)),
+        mode="error",
+        files=(artifact / "one", artifact / "two", artifact / "artifact.json"),
+    )
+
+    rendered = render_summary(result, color=False)
+
+    assert rendered is not None
+    assert "3 files; 1.49 KiB total" in rendered
+    assert str(result.files) not in rendered
+
+
+def test_json_result_never_contains_table_or_color_sequences() -> None:
+    stream = io.StringIO()
+    write_result(_Result("complete", 2, ()), format="json", stream=stream, color=True)
+    assert json.loads(stream.getvalue()) == {
+        "adjustments": [],
+        "generated_processes": 2,
+        "status": "complete",
+    }
+    assert "\x1b[" not in stream.getvalue()
+
+
+def test_total_evaluation_uses_a_colored_point_table_without_changing_json() -> None:
+    result = (complex(1.25, 0.0), Decimal("2.5"))
+
+    rendered = render_summary(result, color=True)
+
+    assert rendered is not None
+    assert "Summed Evaluation" in rendered
+    assert "matrix element" in rendered
+    assert "1.250000000000000e+00" in rendered
+    assert "2.500000000000000e+00" in rendered
+    assert "\x1b[" in rendered
+    assert set(rendered.splitlines()[-1]) <= {"+", "-"}
+    stream = io.StringIO()
+    write_result(result, format="json", stream=stream, color=True)
+    assert json.loads(stream.getvalue()) == [
+        {"imag": 0.0, "real": 1.25},
+        "2.5",
+    ]
+    assert "\x1b[" not in stream.getvalue()
+
+
+def test_resolved_evaluation_uses_colored_component_and_sum_tables() -> None:
+    result = ResolvedEvaluation(
+        values=(
+            (
+                (complex(1.0, 2.0), complex(3.0, 0.0)),
+                (complex(4.0, 0.0), complex(5.0, 0.0)),
+            ),
+        ),
+        helicity_ids=("h:first", "h:second"),
+        color_ids=("flow:first", "flow:second"),
+    )
+
+    rendered = render_summary(result, color=True)
+
+    assert rendered is not None
+    assert "Resolved Evaluation (LC)" in rendered
+    assert "h:first" in rendered
+    assert "flow:second" in rendered
+    assert "1.000000000000000e+00+2.000000000000000e+00j" in rendered
+    assert "Resolved Sum" in rendered
+    assert "1.300000000000000e+01+2.000000000000000e+00j" in rendered
+    assert "\x1b[" in rendered
+    component_table, total_table = rendered.split("\n\n", maxsplit=1)
+    for table in (component_table, total_table):
+        assert set(table.splitlines()[-1]) <= {"+", "-"}
+    stream = io.StringIO()
+    write_result(result, format="json", stream=stream, color=True)
+    payload = json.loads(stream.getvalue())
+    assert payload["values"][0][0][0] == {"imag": 2.0, "real": 1.0}
+    assert payload["helicity_ids"] == ["h:first", "h:second"]
+    assert payload["color_ids"] == ["flow:first", "flow:second"]
+    assert "\x1b[" not in stream.getvalue()
+
+
+def test_evaluation_values_use_scientific_notation_except_exact_zero() -> None:
+    rendered = render_summary((0.0002519743243773565, 0.0), color=False)
+
+    assert rendered is not None
+    assert "2.519743243773565e-04" in rendered
+    zero_row = next(line for line in rendered.splitlines() if "|     1 |" in line)
+    assert zero_row.split("|")[-2].strip() == "0"
+
+
+def _benchmark_result() -> BenchmarkResult:
+    config = BenchmarkConfig(target_runtime=1.0, batch_size=32, minimum_samples=8)
+    wall_uncertainty = BenchmarkStatistics(0.2e-6, 0.05e-6, 0.02)
+    evaluator_uncertainty = BenchmarkStatistics(0.1e-6, 0.025e-6, 0.0125)
+    component = BenchmarkComponentTiming(0.5e-6, evaluator_uncertainty, 8)
+    wall_component = BenchmarkComponentTiming(2.5e-6, wall_uncertainty, 8)
+    evaluator_component = BenchmarkComponentTiming(2.0e-6, evaluator_uncertainty, 8)
+    counters = BenchmarkProfileCounters(
+        sample_count=8,
+        native_input_components_per_point=20.0,
+        native_input_pack_bytes_per_point=160.0,
+        state_components_per_point=400.0,
+        stage_input_copy_components_per_point=120.0,
+        stage_leaf_input_copy_components_per_point=240.0,
+        stage_evaluator_output_gather_components_per_point=60.0,
+        stage_output_assign_components_per_point=80.0,
+        amplitude_input_copy_components_per_point=40.0,
+        amplitude_leaf_input_copy_components_per_point=42.0,
+        amplitude_evaluator_output_gather_components_per_point=10.0,
+        amplitude_output_remap_components_per_point=8.0,
+        evaluator_backend_calls_per_call=12.0,
+        compiled_direct_arena_engines_per_call=2.0,
+        compiled_direct_arena_calls_per_call=12.0,
+        compiled_direct_arena_boundary_input_bytes_per_call=0.0,
+        compiled_direct_arena_boundary_current_output_bytes_per_call=0.0,
+        compiled_direct_arena_boundary_amplitude_output_bytes_per_call=0.0,
+        recurrence_schedule_executions_per_call=1.0,
+        recurrence_contribution_calls_per_call=7.0,
+        recurrence_contribution_rows_per_call=126.0,
+        reduction_input_components_per_point=16.0,
+        total_materialized_values_per_point=1.0,
+        observed_scratch_reallocations_per_call=0.0,
+        native_output_allocations_per_call=1.0,
+    )
+    breakdown = BenchmarkTimingBreakdown(
+        sample_count=8,
+        wall_time=wall_component,
+        source_fill_time=component,
+        momentum_setup_time=component,
+        stage_input_pack_time=component,
+        stage_evaluator_call_time=evaluator_component,
+        output_assign_time=component,
+        amplitude_input_pack_time=component,
+        amplitude_evaluator_call_time=None,
+        stage_leaf_input_pack_time=component,
+        stage_backend_call_time=component,
+        stage_evaluator_output_gather_time=component,
+        amplitude_leaf_input_pack_time=component,
+        amplitude_backend_call_time=component,
+        amplitude_evaluator_output_gather_time=component,
+        amplitude_output_remap_time=component,
+        reduction_time=component,
+        other_core_time=component,
+        stages=(
+            BenchmarkStageTiming(
+                1,
+                component,
+                component,
+                component,
+                leaf_input_pack_time=component,
+                backend_call_time=component,
+                evaluator_output_gather_time=component,
+            ),
+        ),
+        counters=counters,
+    )
+    return BenchmarkResult(
+        requested_config=config,
+        effective_config=config,
+        sample_count=8,
+        wall_time_per_point=2.5e-6,
+        evaluator_time_per_point=2.0e-6,
+        uncertainty=wall_uncertainty,
+        environment={
+            "target": "/tmp/artifact",
+            "elapsed_seconds": 1.01,
+            "platform": "test-platform",
+            "wall_time_source": "python_outer_perf_counter_wall_time",
+            "wall_time_sample_pass": "time.perf_counter[measure_repetitions]",
+            "evaluator_total_time_source": (
+                "runtime._benchmark_f64_wall_time.accumulated"
+            ),
+            "evaluator_time_source": "runtime_profile_core_evaluator_call_time",
+            "evaluator_time_sample_pass": "runtime.profile_repeated",
+            "execution_mode": "compiled",
+            "color_workload": "all 1 generated physical LC flows",
+            "helicity_workload": "all 24 generated helicity configurations",
+            "timing_sample_contract": (
+                "paired_unprofiled_headline_profiled_attribution_v1"
+            ),
+            "evaluator_sample_count": 8,
+            "native_profile_repetitions_per_sample": 50,
+            "native_profile_points_per_sample": 1600,
+        },
+        repetitions_per_sample=50,
+        evaluator_uncertainty=evaluator_uncertainty,
+        evaluator_total_time_per_point=2.25e-6,
+        process_id="ddbar_zg",
+        process_expression="d d~ > z g",
+        timing_breakdown=breakdown,
+    )
+
+
+def test_benchmark_result_uses_clear_runtime_profile_table() -> None:
+    rendered = render_summary(_benchmark_result(), color=False)
+
+    assert rendered is not None
+    assert "Runtime Profile" in rendered
+    assert "ddbar_zg (d d~ > z g)" in rendered
+    assert "execution mode" in rendered
+    assert "compiled" in rendered
+    assert "all 1 generated physical LC flows" in rendered
+    assert "all 24 generated helicity configurations" in rendered
+    assert "outer wall" in rendered
+    assert "2.5 +/- 0.05 us/point (standard error)" in rendered
+    assert "evaluator total" in rendered
+    assert "2.25 us/point" in rendered
+    assert "evaluator core" in rendered
+    assert "8 blocks x 50 repetitions x 32 points" in rendered
+    assert "timed points" in rendered
+    assert "Rusticol Timing Breakdown" in rendered
+    assert "Source fill" in rendered
+    assert "Other Rusticol core" in rendered
+    assert "Rusticol Stage Detail" in rendered
+    assert "Stage evaluator envelope (top-level)" in rendered
+    assert "Stage leaf input pack (attribution)" in rendered
+    assert "Amplitude output remap (attribution)" in rendered
+    assert "Rusticol Stage Internal Attribution (do not add to top-level)" in rendered
+    assert "evaluator call" in rendered
+    assert "Native Work Counters (mean across 8 profiled blocks)" in rendered
+    assert "schedule executions" in rendered
+    assert "contribution rows" in rendered
+    assert "stage leaf copy" in rendered
+    assert "240 components" in rendered
+    assert "per runtime call" in rendered
+    assert "compiled Direct-Arena" in rendered
+    assert "Arena engines" in rendered
+    assert "2 engines" in rendered
+    assert "Arena calls" in rendered
+    assert "boundary current output" in rendered
+    assert "boundary amplitude output" in rendered
+    assert "observed scratch reallocations" in rendered
+    assert "paired passes: unprofiled headline" in rendered
+    assert "profiled evaluator core attribution" in rendered
+    assert "Profile wall (paired profiled pass)" in rendered
+    assert "Rusticol Timing Breakdown (paired profiled attribution)" in rendered
+
+
+def test_compiled_direct_arena_labels_the_inclusive_runtime_envelope() -> None:
+    result = _benchmark_result()
+    rendered = render_summary(
+        replace(
+            result,
+            environment={
+                **result.environment,
+                "compiled_direct_arena_active": True,
+                "evaluator_time_source": (
+                    "runtime_profile_core_compiled_direct_arena_orchestration_time"
+                ),
+            },
+        ),
+        color=False,
+    )
+
+    assert rendered is not None
+    assert rendered.count("Direct-Arena runtime envelope") == 2
+    assert "evaluator core" not in rendered
+    assert "Runtime orchestration" not in rendered
+
+
+def test_timing_breakdown_omits_exact_zero_component_rows() -> None:
+    result = _benchmark_result()
+    breakdown = result.timing_breakdown
+    assert breakdown is not None
+    exact_zero = BenchmarkComponentTiming(
+        0.0,
+        BenchmarkStatistics(0.0, 0.0, 0.0),
+        breakdown.sample_count,
+    )
+    uncertain_zero = BenchmarkComponentTiming(
+        0.0,
+        BenchmarkStatistics(1.0e-9, 0.5e-9, 1.0),
+        breakdown.sample_count,
+    )
+    zero_stage = BenchmarkStageTiming(
+        2,
+        exact_zero,
+        exact_zero,
+        exact_zero,
+        leaf_input_pack_time=exact_zero,
+        backend_call_time=exact_zero,
+        evaluator_output_gather_time=exact_zero,
+    )
+    partially_unavailable_stage = BenchmarkStageTiming(
+        3,
+        None,
+        exact_zero,
+        None,
+        backend_call_time=uncertain_zero,
+    )
+
+    rendered = render_summary(
+        replace(
+            result,
+            timing_breakdown=replace(
+                breakdown,
+                state_clear_time=exact_zero,
+                state_prepare_time=uncertain_zero,
+                selector_planner_time=None,
+                stages=(
+                    *breakdown.stages,
+                    zero_stage,
+                    partially_unavailable_stage,
+                ),
+            ),
+        ),
+        color=False,
+    )
+
+    assert rendered is not None
+    assert "| State clear" not in rendered
+    assert "| State prepare" in rendered
+    assert "| Selector planning" in rendered
+    assert "|     2 |" not in rendered
+    assert "|     3 |" in rendered
+    assert "| Other Rusticol core" in rendered
+
+
+def test_recurrence_profile_reports_paired_schedule_and_nested_attribution() -> None:
+    result = _benchmark_result()
+    breakdown = result.timing_breakdown
+    assert breakdown is not None
+    component = breakdown.source_fill_time
+    schedule = breakdown.stage_evaluator_call_time
+    recurrence_breakdown = replace(
+        breakdown,
+        execution_mode="recurrence",
+        stage_input_pack_time=None,
+        stage_evaluator_call_time=None,
+        output_assign_time=None,
+        amplitude_input_pack_time=None,
+        amplitude_evaluator_call_time=None,
+        reduction_time=component,
+        stages=(),
+        recurrence_momentum_fill_time=component,
+        recurrence_union_source_fill_time=component,
+        recurrence_schedule_time=schedule,
+        recurrence_source_kernel_time=component,
+        recurrence_contribution_kernel_time=component,
+        recurrence_finalization_time=component,
+        recurrence_closure_time=component,
+        recurrence_replay_output_mapping_time=component,
+    )
+    rendered = render_summary(
+        replace(
+            result,
+            environment={
+                **result.environment,
+                "execution_mode": "recurrence",
+                "evaluator_time_source": (
+                    "runtime_profile_core_recurrence_schedule_time"
+                ),
+            },
+            timing_breakdown=recurrence_breakdown,
+        ),
+        color=False,
+    )
+
+    assert rendered is not None
+    assert "recurrence core" in rendered
+    assert "evaluator core" not in rendered
+    assert (
+        "Rusticol Recurrence Timing Breakdown (paired profiled attribution)" in rendered
+    )
+    assert "Profile wall (paired profiled pass)" in rendered
+    assert "Recurrence schedule (inclusive)" in rendered
+    assert "Contribution kernels (schedule attribution; do not add)" in rendered
+    assert "Current finalization (schedule attribution; do not add)" in rendered
+    assert "Replay output mapping (exclusive)" in rendered
+    assert "runtime_profile_core_recurrence_schedule_time" in rendered
+
+
+def test_on_the_fly_profile_names_its_recurrence_schedule_attribution() -> None:
+    result = _benchmark_result()
+    breakdown = result.timing_breakdown
+    assert breakdown is not None
+    component = breakdown.source_fill_time
+    schedule = breakdown.stage_evaluator_call_time
+    on_the_fly_breakdown = replace(
+        breakdown,
+        execution_mode="on-the-fly",
+        stage_input_pack_time=None,
+        stage_evaluator_call_time=None,
+        output_assign_time=None,
+        amplitude_input_pack_time=None,
+        amplitude_evaluator_call_time=None,
+        reduction_time=component,
+        stages=(),
+        recurrence_momentum_fill_time=component,
+        recurrence_schedule_time=schedule,
+        recurrence_source_kernel_time=component,
+        recurrence_contribution_kernel_time=component,
+        recurrence_finalization_time=component,
+        recurrence_closure_time=component,
+    )
+    rendered = render_summary(
+        replace(
+            result,
+            environment={
+                **result.environment,
+                "execution_mode": "on-the-fly",
+                "evaluator_time_source": (
+                    "runtime_profile_core_recurrence_schedule_time"
+                ),
+            },
+            timing_breakdown=on_the_fly_breakdown,
+        ),
+        color=False,
+    )
+
+    assert rendered is not None
+    assert "OTF recurrence-schedule core" in rendered
+    assert "evaluator core" not in rendered
+    assert (
+        "Rusticol OTF Recurrence-Schedule Timing Breakdown "
+        "(paired profiled attribution)" in rendered
+    )
+    assert "OTF recurrence schedule (inclusive)" in rendered
+    assert "Contribution kernels (schedule attribution; do not add)" in rendered
+
+
+def test_runtime_profile_renders_three_independent_clocks_with_full_precision() -> None:
+    result = _benchmark_result()
+    breakdown = result.timing_breakdown
+    assert breakdown is not None
+    zero_uncertainty = BenchmarkStatistics(0.0, 0.0, 0.0)
+    rendered = render_summary(
+        replace(
+            result,
+            wall_time_per_point=218.105e-6,
+            evaluator_total_time_per_point=217.812e-6,
+            evaluator_time_per_point=10.1234e-6,
+            uncertainty=zero_uncertainty,
+            evaluator_uncertainty=zero_uncertainty,
+            environment={
+                **result.environment,
+                "execution_mode": "recurrence",
+                "evaluator_time_source": (
+                    "runtime_profile_core_recurrence_schedule_time"
+                ),
+            },
+            timing_breakdown=replace(breakdown, execution_mode="recurrence"),
+        ),
+        color=False,
+    )
+
+    assert rendered is not None
+    lines = rendered.splitlines()
+    assert any(
+        "outer wall" in line and "218.105 +/- 0 us/point" in line for line in lines
+    )
+    assert any(
+        "evaluator total" in line and "217.812 us/point" in line for line in lines
+    )
+    assert any(
+        "recurrence core" in line and "10.1234 +/- 0 us/point" in line for line in lines
+    )
+    assert "evaluator total=runtime._benchmark_f64_wall_time.accumulated" in rendered
+    assert "runtime_profile_core_recurrence_schedule_time" in rendered
+
+
+def test_runtime_profile_marks_missing_total_and_core_unavailable() -> None:
+    result = _benchmark_result()
+    rendered = render_summary(
+        replace(
+            result,
+            evaluator_total_time_per_point=None,
+            evaluator_time_per_point=None,
+            evaluator_uncertainty=None,
+            environment={
+                **result.environment,
+                "execution_mode": "recurrence",
+                "evaluator_time_source": "unavailable",
+                "evaluator_total_time_source": "unavailable",
+            },
+            timing_breakdown=None,
+        ),
+        color=False,
+    )
+
+    assert rendered is not None
+    lines = rendered.splitlines()
+    assert any("evaluator total" in line and "N/A" in line for line in lines)
+    assert any("recurrence core" in line and "N/A" in line for line in lines)
+
+
+def test_separate_breakdown_samples_are_labeled_explicitly() -> None:
+    result = _benchmark_result()
+    breakdown = result.timing_breakdown
+    assert breakdown is not None
+    environment = {
+        **result.environment,
+        "timing_sample_contract": "separate_native_profile_diagnostic_v1",
+        "wall_time_sample_pass": "time.perf_counter[measure_repetitions]",
+        "evaluator_time_sample_pass": "runtime.profile",
+        "evaluator_sample_count": 3,
+        "native_profile_repetitions_per_sample": 1,
+        "native_profile_points_per_sample": 32,
+        "evaluator_elapsed_seconds": 0.25,
+    }
+    rendered = render_summary(
+        replace(
+            result,
+            environment=environment,
+            timing_breakdown=replace(breakdown, sample_count=3),
+        ),
+        color=False,
+    )
+
+    assert rendered is not None
+    assert "Rusticol Timing Breakdown (separate diagnostic samples)" in rendered
+    assert "evaluator core" in rendered
+    assert "separate passes" in rendered
+    assert (
+        "headline outer wall and evaluator total 8 blocks x 50 repetitions x 32 points"
+        in rendered
+    )
+    assert "evaluator core and breakdown 3" in rendered
+    assert "diagnostic blocks x 1 repetitions" in rendered
+    assert "Profile wall (diagnostic pass)" in rendered
+
+
+def test_separate_evaluator_uncertainty_uses_diagnostic_sample_count() -> None:
+    result = _benchmark_result()
+    environment = {
+        **result.environment,
+        "timing_sample_contract": "separate_native_profile_diagnostic_v1",
+        "evaluator_sample_count": 1,
+    }
+
+    rendered = render_summary(replace(result, environment=environment), color=False)
+
+    assert rendered is not None
+    assert "evaluator core" in rendered
+    assert "uncertainty needs at least 2 blocks" in rendered
+
+
+def test_benchmark_profile_table_color_is_optional() -> None:
+    rendered = render_summary(_benchmark_result(), color=True)
+
+    assert rendered is not None
+    assert "\x1b[" in rendered
+    tables = tuple(
+        section for section in rendered.split("\n\n") if section.startswith("+")
+    )
+    assert tables
+    assert all(set(table.splitlines()[-1]) <= {"+", "-"} for table in tables)
+
+
+def test_benchmark_profile_counters_remain_machine_readable() -> None:
+    stream = io.StringIO()
+
+    write_result(
+        _benchmark_result(),
+        format="json",
+        stream=stream,
+        color=True,
+    )
+
+    payload = json.loads(stream.getvalue())
+    counters = payload["timing_breakdown"]["counters"]
+    assert counters["normalization"] == ("mean_per_profiled_point_or_runtime_call_v1")
+    assert counters["stage_leaf_input_copy_components_per_point"] == 240.0
+    assert counters["evaluator_backend_calls_per_call"] == 12.0
+    assert counters["compiled_direct_arena_engines_per_call"] == 2.0
+    assert counters["compiled_direct_arena_calls_per_call"] == 12.0
+    assert counters["compiled_direct_arena_boundary_input_bytes_per_call"] == 0.0
+    assert (
+        counters["compiled_direct_arena_boundary_current_output_bytes_per_call"] == 0.0
+    )
+    assert (
+        counters["compiled_direct_arena_boundary_amplitude_output_bytes_per_call"]
+        == 0.0
+    )
+    assert (
+        payload["timing_breakdown"]["stage_backend_call_time"]["mean_seconds_per_point"]
+        == 0.5e-6
+    )
+    assert (
+        payload["timing_breakdown"]["amplitude_output_remap_time"][
+            "mean_seconds_per_point"
+        ]
+        == 0.5e-6
+    )
+    assert "\x1b[" not in stream.getvalue()
+
+
+def test_eager_benchmark_uses_eager_phase_labels() -> None:
+    result = _benchmark_result()
+    breakdown = result.timing_breakdown
+    assert breakdown is not None
+    component = breakdown.stage_evaluator_call_time
+    assert component is not None
+    eager_breakdown = replace(
+        breakdown,
+        execution_mode="eager",
+        stage_evaluator_call_time=None,
+        eager_execution_time=component,
+        eager_initialize_time=component,
+        eager_gather_time=component,
+        eager_kernel_call_time=component,
+        eager_invocation_scatter_time=component,
+        eager_finalization_time=component,
+        eager_scatter_finalization_time=component,
+        eager_closure_time=component,
+        eager_copy_out_time=component,
+        stages=(),
+    )
+
+    rendered = render_summary(
+        replace(result, timing_breakdown=eager_breakdown), color=False
+    )
+
+    assert rendered is not None
+    assert "Rusticol Eager Timing Breakdown" in rendered
+    assert "Initialize (exclusive)" in rendered
+    assert "Gather (exclusive)" in rendered
+    assert "Kernel calls (exclusive)" in rendered
+    assert "Invocation scatter (exclusive)" in rendered
+    assert "Current finalization (exclusive)" in rendered
+    assert "Amplitude closure (exclusive)" in rendered
+    assert "Amplitude copy-out (exclusive)" in rendered
+    assert "Eager execution (inclusive)" in rendered
+    assert "Rusticol Stage Detail" not in rendered
+
+
+def test_eager_benchmark_labels_aggregate_until_native_phases_exist() -> None:
+    result = _benchmark_result()
+    breakdown = result.timing_breakdown
+    assert breakdown is not None
+
+    rendered = render_summary(
+        replace(
+            result,
+            timing_breakdown=replace(
+                breakdown,
+                execution_mode="eager",
+                stage_evaluator_call_time=None,
+                eager_execution_time=breakdown.stage_evaluator_call_time,
+                stages=(),
+            ),
+        ),
+        color=False,
+    )
+
+    assert rendered is not None
+    assert "Eager execution (inclusive)" in rendered
+    assert "Stage input pack" not in rendered
+    assert "Output assign" not in rendered
+
+
+def test_interrupted_benchmark_renders_partial_status() -> None:
+    rendered = render_summary(
+        replace(_benchmark_result(), interrupted=True), color=False
+    )
+
+    assert rendered is not None
+    assert "interrupted - partial statistics from 8 complete blocks" in rendered
+
+
+def _artifact_inspection() -> ArtifactInspection:
+    alias = ArtifactAliasInspection(
+        id="ddbar_zg_alias",
+        expression="d d~ > g z",
+        representative_id="ddbar_zg",
+        external_pdgs=(1, -1, 21, 23),
+    )
+    process = ArtifactProcessInspection(
+        id="ddbar_zg",
+        expression="d d~ > z g",
+        color_accuracy="lc",
+        external_pdgs=(1, -1, 23, 21),
+        default=True,
+        physical_helicities=24,
+        computed_helicities=12,
+        physical_color_components=1,
+        computed_color_components=1,
+        helicity_coverage="complete",
+        color_coverage="complete",
+        aliases=(alias,),
+        lc_flow_layout="all-flow-union",
+        lc_union_sector_count=1,
+    )
+    return ArtifactInspection(
+        kind="pyamplicol-artifact-inspection",
+        path=Path("/tmp/artifact"),
+        artifact_kind="pyamplicol-process-set",
+        artifact_id="a" * 64,
+        created_utc="2026-07-16T00:00:00Z",
+        producer_version="0.1.0",
+        target="x86_64-unknown-linux-gnu",
+        cpu_features=(),
+        model_name="sm",
+        model_source="ufo-json",
+        model_restriction="default",
+        default_process_id="ddbar_zg",
+        runtime_engine="rusticol",
+        runtime_version="0.1.0",
+        runtime_capabilities=("symjit.application.complex-f64.v1",),
+        payload_count=12,
+        payload_size_bytes=2048,
+        integrity="verified",
+        processes=(process,),
+        dependencies=(
+            ArtifactDependencyInspection(
+                name="symbolica",
+                version="2.1.0",
+                license="Symbolica Software License Agreement",
+                source="https://symbolica.io/",
+            ),
+        ),
+    )
+
+
+def test_artifact_inspection_uses_process_and_alias_tables() -> None:
+    rendered = render_summary(_artifact_inspection(), color=False)
+
+    assert rendered is not None
+    assert "Artifact" in rendered
+    assert "Processes" in rendered
+    assert "Aliases" in rendered
+    assert "Dependencies" in rendered
+    assert "Execution" in rendered
+    assert "ddbar_zg" in rendered
+    assert "d d~ > z g" in rendered
+    assert "24 (12 eval.)" in rendered
+    assert "LC flow layout" in rendered
+    assert "all-flow-union" in rendered
+    assert "1 physical / materialized; 0 residual" in rendered
+
+
+def test_eager_artifact_inspection_reports_execution_contract() -> None:
+    inspection = _artifact_inspection()
+    eager_process = replace(
+        inspection.processes[0],
+        execution_mode="eager",
+        prepared_backend="jit",
+        prepared_kernel_count=12,
+        referenced_kernel_count=9,
+        invocation_count=80,
+        attachment_count=100,
+        evaluation_alias_count=20,
+        maximum_fanout=4,
+        finalization_count=30,
+        closure_count=12,
+        selector_closure_available=True,
+        selector_domain_count=12,
+        selector_domain_membership_count=160,
+        requested_point_tile_size=1024,
+        effective_point_tile_size=None,
+        workspace_limit_bytes=256 * 1024 * 1024,
+        workspace_bytes=None,
+        native_profile_phases=(
+            "source-fill",
+            "momentum-setup",
+            "eager-execution-aggregate",
+        ),
+    )
+
+    rendered = render_summary(
+        replace(inspection, processes=(eager_process,)), color=False
+    )
+
+    assert rendered is not None
+    assert "eager (jit)" in rendered
+    assert "12 in pack; 9 referenced" in rendered
+    assert "80 canonical; 100 attachments; 20 reused aliases; max fanout 4" in rendered
+    assert "12 domains; 160 memberships" in rendered
+    assert "1024 / available after runtime load" in rendered
+    assert "256.00 MiB / available after runtime load" in rendered
+
+
+def test_on_the_fly_artifact_inspection_reports_static_compact_contract() -> None:
+    inspection = _artifact_inspection()
+    on_the_fly_process = replace(
+        inspection.processes[0],
+        execution_mode="on-the-fly",
+        physical_helicities=64,
+        computed_helicities=64,
+        physical_color_components=24,
+        computed_color_components=24,
+        lc_flow_layout="compact/query-local",
+        lc_physical_sector_count=24,
+        lc_union_sector_count=None,
+        requested_point_tile_size=128,
+        effective_point_tile_size=None,
+        requested_query_construction_threads=4,
+        native_profile_phases=(
+            "selector-plan",
+            "recurrence-direct-contribution",
+            "recurrence-direct-closure",
+        ),
+    )
+
+    rendered = render_summary(
+        replace(inspection, processes=(on_the_fly_process,)), color=False
+    )
+
+    assert rendered is not None
+    assert "compact/query-local" in rendered
+    assert "64 physical helicities; 24 physical LC color flows" in rendered
+    assert "128 requested; not applied by on-the-fly execution" in rendered
+    assert "query construction threads" in rendered
+    assert "4 requested" in rendered
+    assert "f64 only" in rendered
+    assert "topology-replay" not in rendered
+    assert "LC replay sectors" not in rendered
+    assert "None materialized" not in rendered
+    assert "None replayed" not in rendered
+    assert "None residual" not in rendered
+
+
+def test_recurrence_artifact_inspection_reports_contracted_color() -> None:
+    inspection = _artifact_inspection()
+    recurrence_process = replace(
+        inspection.processes[0],
+        color_accuracy="full",
+        execution_mode="recurrence",
+        prepared_backend="jit",
+        direct_source_row_count=12,
+        direct_contribution_row_count=126,
+        direct_finalization_row_count=69,
+        direct_closure_row_count=24,
+        recurrence_color_accuracy="full",
+        recurrence_color_storage="repeated",
+        recurrence_color_sector_count=36,
+        recurrence_color_active_sector_count=6,
+        recurrence_color_component_count=64,
+        recurrence_color_group_count=384,
+        recurrence_color_entry_count=21,
+        recurrence_color_logical_entry_count=1344,
+        recurrence_color_factorization_kind="klein-four-walsh",
+        recurrence_color_factorization_rank=2,
+        recurrence_color_factorization_coset_count=1,
+    )
+
+    rendered = render_summary(
+        replace(inspection, processes=(recurrence_process,)), color=False
+    )
+
+    assert rendered is not None
+    assert "recurrence (jit)" in rendered
+    assert "12 sources; 126 contributions; 69 finalizations; 24 closures" in rendered
+    assert "6/36 active sectors" in rendered
+    assert "21/1344" in rendered
+    assert "stored/logical entries" in rendered
+    assert "klein-four-walsh, rank 2, 1 cosets" in rendered
+
+
+def test_artifact_inspection_reports_runtime_selector_proofs() -> None:
+    inspection = _artifact_inspection()
+    reusable_process = replace(
+        inspection.processes[0],
+        selector_provenance="pyamplicol-runtime-selectors-v1",
+        helicity_runtime_contract="complete-reusable",
+        color_flow_runtime_contract="complete-reusable",
+        generation_specialized_axes=(),
+        selected_source_helicities=(),
+        selected_color_sector_ids=(),
+        helicity_recurrence_status="available",
+        helicity_optimized_class_count=14,
+        helicity_optimized_current_count=72,
+        helicity_residual_current_count=0,
+        helicity_optimized_amplitude_class_count=4,
+        helicity_residual_amplitude_count=0,
+        helicity_materialized_current_count=40,
+        helicity_materialized_amplitude_count=6,
+        lc_physical_sector_count=6,
+        lc_materialized_sector_count=2,
+        lc_replayed_sector_count=6,
+        lc_residual_sector_count=0,
+    )
+
+    rendered = render_summary(
+        replace(inspection, processes=(reusable_process,)), color=False
+    )
+
+    assert rendered is not None
+    assert "helicity complete-reusable; color flow complete-reusable" in rendered
+    assert "generation specialization" in rendered
+    assert "generation selection" in rendered
+    assert "pyamplicol-runtime-selectors-v1" in rendered
+    assert "6 physical; 2 materialized; 6 replayed; 0 residual" in rendered
+    assert "72 optimized currents in 14 classes; 0 residual" in rendered
+    assert "amplitude classes; 0 residual roots" in rendered
+    assert "materialized 40 currents / 6 roots" in rendered
+
+
+def test_artifact_inspection_color_is_optional() -> None:
+    rendered = render_summary(_artifact_inspection(), color=True)
+
+    assert rendered is not None
+    assert "\x1b[36mddbar_zg" in rendered
+    assert "\x1b[32md d~ > z g" in rendered
+    assert "\x1b[35mmode / backend" in rendered
+    assert "\x1b[36mcompiled" in rendered
+    assert "\x1b[36msymbolica" in rendered
+    assert "\x1b[33mSymbolica Software License Agreement" in rendered
+
+
+def _member(
+    identifier: str,
+    process: str,
+    *,
+    factor: str = "1",
+    permutation: tuple[int, ...] = (0, 1, 2, 3),
+    conjugated: bool = False,
+    basis: str = "flavor-blind",
+    generated: bool = False,
+    warning: str | None = None,
+) -> ArtifactProcessGroupMemberInspection:
+    return ArtifactProcessGroupMemberInspection(
+        id=identifier,
+        process=process,
+        pdgs=(1,) * len(permutation),
+        initial_count=2,
+        factor=factor,
+        permutation=permutation,
+        conjugated=conjugated,
+        basis=basis,
+        generated=generated,
+        warning=warning,
+    )
+
+
+def _group(
+    representative: str, process: str, *members: ArtifactProcessGroupMemberInspection
+) -> ArtifactProcessGroupInspection:
+    return ArtifactProcessGroupInspection(
+        representative_id=representative,
+        representative=process,
+        members=(
+            _member(representative, process, basis="identity", generated=True),
+            *members,
+        ),
+    )
+
+
+def _grouped_inspection() -> ArtifactInspection:
+    """A flavour-blind map with a conjugated, a non-unit and a warned member."""
+
+    groups = ArtifactProcessGroupsInspection(
+        stored=True,
+        groups=(
+            _group(
+                "ddbar_zg",
+                "d d~ > z g",
+                _member("uubar_zg", "u u~ > z g", warning="Z couplings differ"),
+                _member(
+                    "dbar_d_zg",
+                    "d~ d > z g",
+                    permutation=(1, 0, 2, 3),
+                    conjugated=True,
+                ),
+                _member(
+                    "ssbar_zg",
+                    "s s~ > z g",
+                    factor="16/9",
+                    basis="numerical",
+                    generated=True,
+                ),
+            ),
+            _group("gg_zg", "g g > z g"),
+        ),
+        analyses=({"variant": "numerical", "only_unit_multiplier": True},),
+    )
+    return replace(_artifact_inspection(), process_groups=groups)
+
+
+def test_process_group_map_renders_overview_rows_and_footnotes() -> None:
+    rendered = render_summary(_grouped_inspection(), color=False)
+
+    assert rendered is not None
+    assert "\x1b[" not in rendered
+    section = rendered[rendered.index("Process groups") : rendered.index("Execution")]
+    lines = section.splitlines()
+    assert lines[3].split("|")[1:7] == [
+        " groups ",
+        " subprocesses ",
+        " generated ",
+        " routed ",
+        " conjugated ",
+        " factor != 1 ",
+    ]
+    assert [cell.strip() for cell in lines[5].split("|")[1:10]] == [
+        "2",
+        "5",
+        "3",
+        "2",
+        "1",
+        "1",
+        "flavor-blind 2",
+        "numerical",
+        "1",
+    ]
+    assert "| numerical 1    | (unit factor |" in lines[6]
+    assert "| ddbar_zg     | d d~ > z g | representative |        |   |" in section
+    assert "| |- ssbar_zg  | s s~ > z g | generated      |   16/9 |   |" in section
+    assert "| |- uubar_zg  | u u~ > z g | routed         |      1 |   |" in section
+    assert "| `- dbar_d_zg | d~ d > z g | routed         |      1 | C | [1 0 2 3]" in (
+        section
+    )
+    assert "| flavor-blind | [1]  |" in section
+    assert "| gg_zg        | g g > z g  | representative |" in section
+    assert "\n[1] Z couplings differ" in section
+    assert "C: charge-conjugated relation" in section
+    assert "permutation p: representative leg r" in section
+    assert "factor F: ME = F x ME(representative)" in section
+    assert "\nnumerical analysis: unit factors only" in section
+    assert "| contents        | 1 process, 1 alias; 5 subprocesses in 2 groups " in (
+        rendered
+    )
+    assert all(len(line) <= 120 for line in lines)
+
+
+def test_unit_factor_process_group_map_omits_the_factor_column() -> None:
+    groups = ArtifactProcessGroupsInspection(
+        stored=True,
+        groups=(
+            _group(
+                "ddbar_zg",
+                "d d~ > z g",
+                _member("uubar_zg", "u u~ > z g"),
+                _member("ssbar_zg", "s s~ > z g"),
+            ),
+        ),
+    )
+
+    rendered = render_summary(
+        replace(_artifact_inspection(), process_groups=groups), color=False
+    )
+
+    assert rendered is not None
+    section = rendered[rendered.index("Process groups") : rendered.index("Execution")]
+    assert "| process ID  | process    | role           | basis        |" in section
+    assert "| |- ssbar_zg | s s~ > z g | routed         | flavor-blind |" in section
+    assert "| `- uubar_zg | u u~ > z g | routed         | flavor-blind |" in section
+    assert "factor F" not in section
+    assert "permutation" not in section
+    assert "C: charge-conjugated" not in section
+
+    # a numerical group of generated members needs no legend at all
+    numerical = ArtifactProcessGroupsInspection(
+        stored=True,
+        groups=(
+            _group(
+                "ddbar_zg",
+                "d d~ > z g",
+                _member("ssbar_zg", "s s~ > z g", basis="numerical", generated=True),
+            ),
+        ),
+    )
+    rendered = render_summary(
+        replace(_artifact_inspection(), process_groups=numerical), color=False
+    )
+    assert rendered is not None
+    section = rendered[rendered.index("Process groups") : rendered.index("Execution")]
+    assert section.endswith(
+        "+-------------+------------+----------------+-----------+\n\n"
+    )
+    assert "| `- ssbar_zg | s s~ > z g | generated      | numerical |" in section
+
+
+def test_process_group_map_colors_relations() -> None:
+    rendered = render_summary(_grouped_inspection(), color=True)
+
+    assert rendered is not None
+    assert "\x1b[36mProcess groups" in rendered
+    assert "\x1b[1m\x1b[32md d~ > z g" in rendered  # representative in bold
+    # bold without a colour stays readable on light and dark terminals
+    assert "\x1b[1mrepresentative" in rendered
+    assert "\x1b[37m" not in rendered[rendered.index("Process groups") :]
+    assert "\x1b[33m16/9" in rendered  # non-unit factor
+    assert "\x1b[32m1\x1b[0m" in rendered  # unit factor
+    assert "\x1b[1m\x1b[35mC" in rendered  # conjugation marker
+    assert "\x1b[94mflavor-blind" in rendered
+    assert "\x1b[32mnumerical" in rendered
+    assert "\x1b[36mrouted" in rendered
+    assert "\x1b[33m[1]" in rendered  # warning reference and footnote
+
+
+def test_trivial_process_group_map_is_a_one_line_note() -> None:
+    inspection = _artifact_inspection()
+    identity = ArtifactProcessGroupsInspection(
+        stored=True, groups=(_group("ddbar_zg", "d d~ > z g"),)
+    )
+
+    rendered = render_summary(replace(inspection, process_groups=identity), color=False)
+    absent = render_summary(
+        replace(inspection, process_groups=replace(identity, stored=False)),
+        color=False,
+    )
+
+    assert rendered is not None and absent is not None
+    assert "Process groups: none; the process is its own group" in rendered
+    assert "subprocesses" not in rendered
+    assert "Process groups: no process-groups.json" in absent
+
+
+def _generation_result(*names: tuple[str, str]) -> GenerationResult:
+    return GenerationResult(
+        output=Path("artifact"),
+        processes=ProcessSet(
+            tuple(
+                ProcessRequest.parse(expression, name=name)
+                for name, expression in names
+            )
+        ),
+        mode="error",
+    )
+
+
+def test_generation_summary_reports_the_process_grouping(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    groups = _grouped_inspection().process_groups
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.inspection.stored_process_groups",
+        lambda _output: groups,
+    )
+    result = _generation_result(
+        ("ddbar_zg", "d d~ > z g"), ("ssbar_zg", "s s~ > z g"), ("gg_zg", "g g > z g")
+    )
+
+    rendered = render_summary(result, color=False)
+    colored = render_summary(result, color=True)
+
+    assert rendered is not None and colored is not None
+    lines = rendered.splitlines()
+    row = next(
+        index for index, line in enumerate(lines) if "| process grouping" in line
+    )
+    assert "| processes " in lines[row - 1]
+    # the warning count moves to its own line rather than overflow 88 columns
+    assert [line.split("|")[2].strip() for line in lines[row : row + 4]] == [
+        "5 subprocesses -> 2 groups: 3 generated, 2 routed",
+        "2 flavor-blind + 1 numerical relations (1 charge-conjugated, 1 with factor "
+        "!= 1)",
+        "1 warning",
+        "numerical analysis: unit factors only",
+    ]
+    assert "| existing-output policy" in lines[row + 4]
+    assert "| name     | process    | group                      |" in rendered
+    assert "| ddbar_zg | d d~ > z g | 4 subprocesses (2 routed)  |" in rendered
+    # a generated member names its representative and its non-unit factor
+    assert "| ssbar_zg | s s~ > z g | member of ddbar_zg (x16/9) |" in rendered
+    assert "| gg_zg    | g g > z g  |                            |" in rendered
+    assert "\x1b[36mprocess grouping" in colored
+    assert "\x1b[1m5 subprocesses" in colored
+    assert "\x1b[32m3 generated" in colored
+    assert "\x1b[36m2 routed" in colored
+    assert "\x1b[94mflavor-blind" in colored
+    assert "\x1b[32mnumerical" in colored
+    assert "\x1b[35m1 charge-conjugated" in colored
+    assert "\x1b[33m1 with factor != 1" in colored
+    assert "\x1b[33m1 warning" in colored
+
+
+def test_generation_summary_omits_a_trivial_process_grouping(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    trivial = ArtifactProcessGroupsInspection(
+        stored=True,
+        groups=(_group("ddbar_zg", "d d~ > z g"), _group("gg_zg", "g g > z g")),
+    )
+    stored: list[ArtifactProcessGroupsInspection | None] = [trivial, None]
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.inspection.stored_process_groups",
+        lambda _output: stored.pop(0),
+    )
+    result = _generation_result(("ddbar_zg", "d d~ > z g"), ("gg_zg", "g g > z g"))
+
+    for _ in range(2):
+        rendered = render_summary(result, color=False)
+        assert rendered is not None
+        assert "process grouping" not in rendered
+        assert "| name     | process    |\n" in rendered
+
+    analysed = replace(trivial, analyses=({"variant": "numerical", "points": 3},))
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.inspection.stored_process_groups",
+        lambda _output: analysed,
+    )
+    rendered = render_summary(result, color=False)
+    assert rendered is not None
+    # worded as `inspect` words a trivial map
+    assert (
+        "| process grouping       | no relation found; each of the 2 processes is "
+        "its own group" in rendered
+    )
+    assert "|                        | numerical analysis: 3 points " in rendered
+    assert "| group" not in rendered
+
+
+def test_large_process_group_map_lists_members_compactly() -> None:
+    flavours = ("d", "u", "s", "c", "b")
+    members = [
+        _member(
+            f"m{index}",
+            f"{first} {second}~ > {first} {second}~ {third} {third}~",
+            conjugated=index >= 60,
+        )
+        for index, (first, second, third) in enumerate(
+            itertools.product(flavours, repeat=3)
+        )
+        if index < 100
+    ]
+    groups = ArtifactProcessGroupsInspection(
+        stored=True,
+        groups=(
+            _group("ddbar_4j", "d d~ > d d~ d d~", *members),
+            _group("gg_4g", "g g > g g g g"),
+        ),
+    )
+
+    rendered = render_summary(
+        replace(_artifact_inspection(), process_groups=groups), color=False
+    )
+
+    assert rendered is not None
+    section = rendered[rendered.index("Process groups") : rendered.index("Execution")]
+    lines = section.splitlines()
+    assert "| representative   | members" in section
+    assert any(
+        line.startswith("| d d~ > d d~ d d~ | 60 routed    d d~ > d d~ d d~  ")
+        for line in lines
+    )
+    assert (
+        "| ddbar_4j         |              d d~ > d d~ b b~  d u~ > d u~ d d~"
+        in section
+    )
+    assert "| 101 subprocesses |" in section
+    assert "|                  | 40 routed C  " in section
+    assert "| ungrouped        |              g g > g g g g" in section
+    assert "| 1 subprocess     |" in section
+    assert "compact view of 102 subprocesses" in section
+    assert "--process REPRESENTATIVE" in section
+    assert "|- " not in section
+    # four members per line instead of one row each
+    assert len(lines) < 50
+    assert all(len(line) <= 120 for line in lines)
+
+    # `--process REPRESENTATIVE` keeps one group, which is listed row by row
+    selected = render_summary(
+        replace(
+            _artifact_inspection(),
+            process_groups=replace(groups, groups=groups.groups[:1]),
+        ),
+        color=False,
+    )
+    assert selected is not None
+    assert "| |- m0 " in selected
+    assert "compact view" not in selected
+
+
+def test_grouped_full_physics_renders_the_process_group_block() -> None:
+    selection = ArtifactProcessGroupSelection(
+        process_id="dbar_d_zg",
+        role="routed member",
+        representative_id="ddbar_zg",
+        representative="d d~ > z g",
+        factor="1",
+        permutation=(1, 0, 2, 3),
+        conjugated=True,
+        basis="flavor-blind",
+        warning=None,
+        group_size=4,
+        routed_count=2,
+        conjugated_count=1,
+    )
+    physics = {
+        "process_id": "dbar_d_zg",
+        "process": "d~ d > z g",
+        "external_particles": [],
+        "helicities": [{"id": "h:-1,-1,-1,-1"}],
+    }
+
+    rendered = render_summary({**physics, "process_group": selection}, color=False)
+    representative = render_summary(
+        {
+            **physics,
+            "process_group": replace(
+                selection, role="representative", conjugated=False
+            ),
+        },
+        color=False,
+    )
+
+    assert rendered is not None and representative is not None
+    assert rendered.index("Process Group") < rendered.index("Process Physics")
+    assert "routed member: not generated, evaluated through the representative" in (
+        rendered
+    )
+    assert "| representative | ddbar_zg  d d~ > z g" in rendered
+    assert (
+        "| permutation    | p = [1 0 2 3]: representative leg r takes the momentum "
+        "of leg p[r]"
+    ) in rendered
+    assert "| conjugated     | yes (C)" in rendered
+    assert "4 subprocesses: 2 generated, 2 routed, 1 conjugated" in rendered
+    assert "representative: generated, evaluated by its own runtime" in (representative)
+    # the representative requested in another leg order shows that order
+    assert (
+        "| permutation | p = [1 0 2 3]: representative leg r takes the momentum of "
+        "leg p[r] |"
+    ) in representative
+    stored_order = render_summary(
+        {
+            **physics,
+            "process_group": replace(
+                selection,
+                role="representative",
+                conjugated=False,
+                permutation=(0, 1, 2, 3),
+            ),
+        },
+        color=False,
+    )
+    assert stored_order is not None
+    assert "permutation" not in stored_order.split("Process Physics")[0]
+
+
+def test_process_groups_json_is_complete_and_uncolored() -> None:
+    stream = io.StringIO()
+    write_result(_grouped_inspection(), format="json", stream=stream, color=True)
+
+    assert "\x1b[" not in stream.getvalue()
+    payload = json.loads(stream.getvalue())["process_groups"]
+    assert payload["stored"] is True
+    assert payload["analyses"] == [
+        {"only_unit_multiplier": True, "variant": "numerical"}
+    ]
+    assert [len(group["members"]) for group in payload["groups"]] == [4, 1]
+    assert payload["groups"][0]["members"][2] == {
+        "basis": "flavor-blind",
+        "conjugated": True,
+        "factor": "1",
+        "generated": False,
+        "id": "dbar_d_zg",
+        "initial_count": 2,
+        "pdgs": [1, 1, 1, 1],
+        "permutation": [1, 0, 2, 3],
+        "process": "d~ d > z g",
+        "warning": None,
+    }
diff --git a/pyamplicol/tests/unit/test_repository_policy.py b/pyamplicol/tests/unit/test_repository_policy.py
new file mode 100644
index 0000000000..38dc6ed7d6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_repository_policy.py
@@ -0,0 +1,298 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import ast
+import os
+import re
+import subprocess
+import tomllib
+from collections.abc import Iterable
+from pathlib import Path
+
+from pyamplicol._internal import versions
+
+ROOT = Path(__file__).resolve().parents[2]
+FIRST_PARTY_ROOTS = (
+    ROOT / "src" / "pyamplicol",
+    ROOT / "src" / "rusticol_config",
+    ROOT / "build_backend",
+    ROOT / "dependencies",
+    ROOT / "tools",
+    ROOT / "tests",
+    ROOT / "rust",
+)
+SOURCE_SUFFIXES = {".py", ".rs", ".h", ".hpp", ".f90"}
+IGNORED_PARTS = {
+    ".agent-work",
+    ".git",
+    ".artifacts",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".trash",
+    ".venv",
+    "__pycache__",
+    "PYPI_DEPLOYMENT_TEST",
+    "build",
+    "checkouts",
+    "dist",
+    "target",
+    "venv",
+    "wheelhouse",
+}
+
+
+def _is_model_asset_root(path: Path) -> bool:
+    return path.name == "models" and "assets" in path.parts[:-1]
+
+
+def _working_tree_model_asset_roots() -> set[Path]:
+    roots: set[Path] = set()
+    # Local dependency checkouts are not first-party source. The separate
+    # tracked-path check still rejects misplaced assets anywhere in the repo.
+    for source_root in FIRST_PARTY_ROOTS:
+        for directory, child_directories, _files in os.walk(source_root):
+            child_directories[:] = [
+                child for child in child_directories if child not in IGNORED_PARTS
+            ]
+            path = Path(directory)
+            if _is_model_asset_root(path.relative_to(ROOT)):
+                roots.add(path)
+    return roots
+
+
+def _tracked_model_asset_roots(tracked_paths: Iterable[Path]) -> set[Path]:
+    roots: set[Path] = set()
+    for tracked_path in tracked_paths:
+        for candidate in tracked_path.parents:
+            if _is_model_asset_root(candidate):
+                roots.add(ROOT / candidate)
+    return roots
+
+
+def _repository_tracked_paths() -> tuple[Path, ...]:
+    result = subprocess.run(
+        ["git", "ls-files", "-z"],
+        cwd=ROOT,
+        check=True,
+        capture_output=True,
+    )
+    tracked_paths = result.stdout.split(b"\0")
+    return tuple(Path(os.fsdecode(raw_path)) for raw_path in tracked_paths if raw_path)
+
+
+def _eligible(path: Path) -> bool:
+    relative = path.relative_to(ROOT)
+    if IGNORED_PARTS.intersection(relative.parts):
+        return False
+    return not relative.is_relative_to("src/pyamplicol/assets/models/ufo")
+
+
+def test_first_party_source_has_explicit_0bsd_spdx_identifier() -> None:
+    missing: list[str] = []
+    for source_root in FIRST_PARTY_ROOTS:
+        for path in source_root.rglob("*"):
+            if not path.is_file() or path.suffix not in SOURCE_SUFFIXES:
+                continue
+            if not _eligible(path):
+                continue
+            # This authoritative third-party ABI header retains MadGraph's
+            # license; do not relicense it or exempt the first-party adapter.
+            if path == ROOT / "src/pyamplicol/assets/api_templates/umami/umami.h":
+                continue
+            header = "\n".join(path.read_text(encoding="utf-8").splitlines()[:5])
+            if "SPDX-License-Identifier: 0BSD" not in header:
+                missing.append(path.relative_to(ROOT).as_posix())
+    assert not missing, "missing 0BSD SPDX identifiers:\n" + "\n".join(missing)
+
+
+def test_release_source_roots_contain_no_symlinks() -> None:
+    links = [
+        path.relative_to(ROOT).as_posix()
+        for source_root in FIRST_PARTY_ROOTS
+        for path in source_root.rglob("*")
+        if _eligible(path) and path.is_symlink()
+    ]
+    assert not links, "release source contains symlinks:\n" + "\n".join(links)
+
+
+def test_model_assets_have_one_canonical_package_root() -> None:
+    expected = ROOT / "src" / "pyamplicol" / "assets" / "models"
+    candidates = sorted(
+        _working_tree_model_asset_roots()
+        | _tracked_model_asset_roots(_repository_tracked_paths())
+    )
+    assert candidates == [expected]
+
+
+def test_tracked_model_assets_cannot_hide_below_an_ignored_work_root() -> None:
+    tracked_duplicate = Path(
+        ".agent-work/copy/src/pyamplicol/assets/models/MANIFEST.sha256"
+    )
+    assert _tracked_model_asset_roots((tracked_duplicate,)) == {
+        ROOT / tracked_duplicate.parent
+    }
+
+
+def test_working_tree_assets_are_scoped_to_first_party_roots(
+    tmp_path: Path, monkeypatch
+) -> None:
+    package = tmp_path / "src" / "pyamplicol"
+    tools = tmp_path / "tools"
+    canonical = package / "assets" / "models"
+    misplaced = tools / "assets" / "models"
+    dependency = tmp_path / "foreign-checkout" / "assets" / "models"
+    for path in (canonical, misplaced, dependency):
+        path.mkdir(parents=True)
+    monkeypatch.setitem(globals(), "ROOT", tmp_path)
+    monkeypatch.setitem(globals(), "FIRST_PARTY_ROOTS", (package, tools))
+
+    assert _working_tree_model_asset_roots() == {canonical, misplaced}
+    # A dependency-like name does not exempt mistakenly committed assets.
+    tracked_dependency = dependency.relative_to(tmp_path) / "model.json"
+    assert _tracked_model_asset_roots((tracked_dependency,)) == {dependency}
+
+
+def test_vendored_ufo_sources_are_not_relicensed_as_first_party_code() -> None:
+    ufo_root = ROOT / "src" / "pyamplicol" / "assets" / "models" / "ufo"
+    assert ufo_root.is_dir()
+    assert not any(
+        "SPDX-License-Identifier: 0BSD"
+        in "\n".join(path.read_text(encoding="utf-8").splitlines()[:5])
+        for path in ufo_root.rglob("*.py")
+    )
+
+
+def test_vendored_umami_header_retains_its_upstream_license() -> None:
+    directory = ROOT / "src/pyamplicol/assets/api_templates/umami"
+    assert "SPDX-License-Identifier: 0BSD" not in (directory / "umami.h").read_text(
+        encoding="utf-8"
+    )
+    assert "Copyright (c) 2009, 2013, the MadTeam." in (
+        directory / "UMAMI_LICENSE"
+    ).read_text(encoding="utf-8")
+
+
+def test_pyamplicol_symbolica_heads_are_owned_by_the_central_registry() -> None:
+    package_root = ROOT / "src" / "pyamplicol"
+    registry = package_root / "_internal" / "physics" / "symbols.py"
+    violations: list[str] = []
+    for path in sorted(package_root.rglob("*.py")):
+        if path == registry:
+            continue
+        source = path.read_text(encoding="utf-8")
+        relative = path.relative_to(ROOT).as_posix()
+        if "pyamplicol::" in source:
+            violations.append(f"{relative}: direct pyamplicol namespace literal")
+        tree = ast.parse(source, filename=str(path))
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.Call):
+                continue
+            if (
+                isinstance(node.func, ast.Name)
+                and node.func.id == "str"
+                and node.args
+                and isinstance(node.args[0], ast.Attribute)
+                and isinstance(node.args[0].value, ast.Name)
+                and node.args[0].value.id == "symbols"
+            ):
+                violations.append(
+                    f"{relative}:{node.lineno}: str(symbols.*) drops its namespace"
+                )
+            is_symbol_constructor = (
+                isinstance(node.func, ast.Name) and node.func.id == "S"
+            ) or (isinstance(node.func, ast.Attribute) and node.func.attr == "S")
+            if not is_symbol_constructor:
+                continue
+            literal = (
+                node.args[0].value
+                if node.args
+                and isinstance(node.args[0], ast.Constant)
+                and isinstance(node.args[0].value, str)
+                else None
+            )
+            if literal in {"spenso::f", "spenso::t"}:
+                continue
+            violations.append(
+                f"{relative}:{node.lineno}: Symbolica S(...) bypasses symbols.py"
+            )
+    assert not violations, "non-central Symbolica symbol construction:\n" + "\n".join(
+        violations
+    )
+
+
+def test_python_rust_and_release_lock_wire_versions_are_identical() -> None:
+    release = tomllib.loads(
+        (ROOT / "dependencies" / "release-lock.toml").read_text(encoding="utf-8")
+    )["abis"]
+    rust = (ROOT / "rust/crates/rusticol-core/src/lib.rs").read_text(encoding="utf-8")
+    contracts = {
+        "python_api": "PYTHON_API_VERSION",
+        "toml": "TOML_SCHEMA_VERSION",
+        "compiled_model": "COMPILED_MODEL_SCHEMA_VERSION",
+        "process_artifact": "PROCESS_ARTIFACT_SCHEMA_VERSION",
+        "runtime_physics": "RUNTIME_PHYSICS_SCHEMA_VERSION",
+        "c_abi": "C_ABI_VERSION",
+    }
+    for lock_name, constant_name in contracts.items():
+        python_value = getattr(versions, constant_name)
+        match = re.search(
+            rf"pub const {constant_name}: u32 = (\d+);",
+            rust,
+        )
+        assert match is not None, constant_name
+        assert int(match.group(1)) == python_value == release[lock_name]
+
+    match = re.search(
+        r'pub const SYMBOLICA_SERIALIZATION_ABI: &str = "([^"]+)";',
+        rust,
+    )
+    assert match is not None
+    assert (
+        match.group(1)
+        == versions.SYMBOLICA_SERIALIZATION_ABI
+        == release["symbolica_serialization"]
+    )
+
+    from pyamplicol.generation.eager_tables import (
+        EAGER_PLAN_ABI,
+        EAGER_SELECTOR_DOMAINS_ABI,
+    )
+    from pyamplicol.models.prepared import (
+        EAGER_KERNEL_ABI,
+        PREPARED_KERNEL_VARIANT_ABI,
+        PREPARED_MODEL_BUNDLE_SCHEMA_VERSION,
+    )
+
+    string_contracts = {
+        "eager_kernel": EAGER_KERNEL_ABI,
+        "eager_plan": EAGER_PLAN_ABI,
+        "eager_selector_domains": EAGER_SELECTOR_DOMAINS_ABI,
+    }
+    rust_eager_tables = (
+        ROOT / "rust/crates/rusticol-core/src/eager_tables.rs"
+    ).read_text(encoding="utf-8")
+    for lock_name, python_value in string_contracts.items():
+        rust_name = lock_name.upper() + "_ABI"
+        match = re.search(
+            rf'pub const {rust_name}: &str = "([^"]+)";',
+            rust_eager_tables,
+        )
+        assert match is not None, rust_name
+        assert match.group(1) == python_value == release[lock_name]
+
+    eager_manifest = (
+        ROOT / "rust/crates/rusticol-core/src/engine/eager_manifest.rs"
+    ).read_text(encoding="utf-8")
+    match = re.search(
+        r'const SYMJIT_APPLICATION_STORAGE_V3_ABI: &str = "([^"]+)";',
+        eager_manifest,
+    )
+    assert match is not None
+    assert (
+        match.group(1)
+        == versions.SYMJIT_APPLICATION_ABI
+        == release["symjit_application"]
+    )
+    assert release["prepared_model_bundle"] == PREPARED_MODEL_BUNDLE_SCHEMA_VERSION
+    assert release["prepared_kernel_variant"] == PREPARED_KERNEL_VARIANT_ABI
diff --git a/pyamplicol/tests/unit/test_reusable_helicity_contract.py b/pyamplicol/tests/unit/test_reusable_helicity_contract.py
new file mode 100644
index 0000000000..34ca3441a9
--- /dev/null
+++ b/pyamplicol/tests/unit/test_reusable_helicity_contract.py
@@ -0,0 +1,316 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+
+import pytest
+
+import pyamplicol.generation.service as service_module
+from pyamplicol.api import ProcessRequest
+from pyamplicol.config import GenerationConfig
+from pyamplicol.generation.dag_algorithms import (
+    prune_global_helicity_flip_equivalent_roots,
+)
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.helicity_materialization import (
+    HelicityMaterialization,
+    materialize_helicity_recurrence,
+)
+from pyamplicol.generation.helicity_replay import build_helicity_recurrence_plan
+from pyamplicol.generation.progress import PhaseHandle
+from pyamplicol.generation.runtime_schema import build_runtime_schema
+from pyamplicol.models import BuiltinSMModel, CompiledUFOModel, compile_model_source
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.processes.model import build_model_process_ir
+
+ROOT = Path(__file__).resolve().parents[2]
+MODEL_ROOT = ROOT / "src" / "pyamplicol" / "assets" / "models" / "json" / "sm"
+
+
+@pytest.fixture(scope="module")
+def ufo_sm() -> CompiledUFOModel:
+    compiled = compile_model_source(
+        MODEL_ROOT / "sm.json",
+        restriction=str((MODEL_ROOT / "restrict_default.json").resolve()),
+        use_cache=False,
+    )
+    return CompiledUFOModel(compiled)
+
+
+def _prepare_builtin(
+    expression: str,
+    *,
+    selected_source_helicities: dict[int, int] | None = None,
+) -> tuple[object, object]:
+    model = BuiltinSMModel()
+    backend = service_module.GenerationBackend(
+        GenerationConfig(),
+        None,
+        process_selection=service_module._ProcessSelection(
+            selected_source_helicities=selected_source_helicities,
+        ),
+    )
+    process_ir = build_process_ir(expression)
+    dag, coverage = backend._compile_concrete_process(process_ir, model)
+    prepared = backend._prepare_warmup_process(
+        service_module._DagProcess(
+            expanded=service_module._ExpandedProcess(
+                request=ProcessRequest.parse(expression, name="contract_case"),
+                process_ir=process_ir,
+            ),
+            dag=dag,
+            coverage=coverage,
+        ),
+        model,
+        index=0,
+        phase=PhaseHandle("test", None, 1),
+    )
+    return model, prepared
+
+
+def _active_current_closure(
+    materialization: HelicityMaterialization,
+    root_ids: tuple[int, ...],
+) -> tuple[int, ...]:
+    interactions_by_result: dict[int, list[object]] = defaultdict(list)
+    for interaction in materialization.dag.interactions:
+        interactions_by_result[interaction.result_id].append(interaction)
+
+    active: set[int] = set()
+    pending: list[int] = []
+    for root_id in root_ids:
+        root = materialization.dag.amplitude_roots[root_id]
+        pending.extend((root.left_id, root.right_id))
+    while pending:
+        current_id = pending.pop()
+        if current_id in active:
+            continue
+        active.add(current_id)
+        for interaction in interactions_by_result.get(current_id, ()):
+            pending.extend((interaction.left_id, interaction.right_id))
+    return tuple(sorted(active))
+
+
+def _materialization_topology(materialization: HelicityMaterialization) -> object:
+    return {
+        "proof_counts": (
+            materialization.proof_current_count,
+            materialization.proof_root_count,
+        ),
+        "runtime_counts": (
+            materialization.materialized_current_count,
+            len(materialization.dag.interactions),
+            materialization.materialized_root_count,
+        ),
+        "source_routes": sorted(
+            (
+                route.external_label,
+                route.helicity,
+                route.chirality,
+                route.selector_domain_id,
+            )
+            for route in materialization.source_routes
+        ),
+        "amplitude_routes": sorted(
+            (
+                route.selector_domain_ids,
+                route.residual,
+            )
+            for route in materialization.amplitude_routes
+        ),
+        "selector_schedules": sorted(
+            (
+                schedule.selector_domain_id,
+                len(schedule.active_current_ids),
+                len(schedule.active_root_ids),
+                schedule.structural_zero,
+            )
+            for schedule in materialization.selector_schedules
+        ),
+    }
+
+
+def test_complete_helicity_service_builds_exact_quotient_schedules() -> None:
+    _model, prepared = _prepare_builtin("g g > g g")
+    recurrence = prepared.dag.helicity_recurrence
+    materialization = prepared.dag.helicity_materialization
+
+    assert recurrence is not None
+    assert materialization is not None
+    complete_domains = {
+        domain.id for domain in recurrence.selector_domains if domain.complete
+    }
+    assert {
+        schedule.selector_domain_id
+        for schedule in materialization.selector_schedules
+    } == complete_domains
+
+    roots_by_domain: dict[int, set[int]] = defaultdict(set)
+    for route in materialization.amplitude_routes:
+        for domain_id in route.selector_domain_ids:
+            roots_by_domain[domain_id].add(route.materialized_root_id)
+    for schedule in materialization.selector_schedules:
+        expected_roots = tuple(
+            sorted(roots_by_domain.get(schedule.selector_domain_id, ()))
+        )
+        assert schedule.active_root_ids == expected_roots
+        assert schedule.active_current_ids == _active_current_closure(
+            materialization,
+            expected_roots,
+        )
+
+
+def test_generation_specialized_helicity_does_not_materialize_a_quotient() -> None:
+    model, prepared = _prepare_builtin(
+        "d d~ > z",
+        selected_source_helicities={1: -1},
+    )
+
+    assert dict(prepared.dag.selected_source_helicities) == {1: -1}
+    assert prepared.dag.helicity_recurrence is None
+    assert prepared.dag.helicity_materialization is None
+    assert "helicity_recurrence" not in prepared.filters
+    schema = build_runtime_schema(prepared.dag, model)
+    assert "helicity_recurrence" not in schema
+    selectors = schema["physics"]["extensions"]["runtime_selectors"]
+    assert selectors["generation_specialized_axes"] == ["helicity"]
+    assert selectors["axes"]["helicity"]["runtime_contract"] == (
+        "generation-specialized"
+    )
+
+
+def test_structural_zero_domains_have_empty_exact_schedules() -> None:
+    _model, prepared = _prepare_builtin("g g > g g")
+    recurrence = prepared.dag.helicity_recurrence
+    materialization = prepared.dag.helicity_materialization
+    assert recurrence is not None
+    assert materialization is not None
+
+    schedules = {
+        schedule.selector_domain_id: schedule
+        for schedule in materialization.selector_schedules
+    }
+    zero_domains = set(recurrence.structural_zero_selector_domain_ids)
+    assert zero_domains
+    assert {
+        domain_id
+        for domain_id, schedule in schedules.items()
+        if schedule.structural_zero
+    } == zero_domains
+    assert all(
+        not schedules[domain_id].active_current_ids
+        and not schedules[domain_id].active_root_ids
+        for domain_id in zero_domains
+    )
+    assert all(
+        schedules[domain_id].active_current_ids
+        and schedules[domain_id].active_root_ids
+        for domain_id in schedules.keys() - zero_domains
+    )
+
+
+def test_builtin_and_ufo_sm_derive_the_same_materialized_topology(
+    ufo_sm: CompiledUFOModel,
+) -> None:
+    expression = "d d~ > z g"
+    builtin = BuiltinSMModel()
+    builtin_dag = compile_generic_dag(build_process_ir(expression), model=builtin)
+    builtin_dag = prune_global_helicity_flip_equivalent_roots(
+        builtin_dag,
+        builtin,
+    )
+    builtin_plan = build_helicity_recurrence_plan(builtin_dag, builtin)
+
+    ufo_dag = compile_generic_dag(
+        build_model_process_ir(expression, ufo_sm.compiled.ir),
+        model=ufo_sm,
+    )
+    ufo_dag = prune_global_helicity_flip_equivalent_roots(ufo_dag, ufo_sm)
+    ufo_plan = build_helicity_recurrence_plan(ufo_dag, ufo_sm)
+
+    assert builtin_plan is not None
+    assert ufo_plan is not None
+    builtin_materialization = materialize_helicity_recurrence(
+        builtin_dag,
+        builtin_plan,
+    )
+    ufo_materialization = materialize_helicity_recurrence(ufo_dag, ufo_plan)
+    assert _materialization_topology(builtin_materialization) == (
+        _materialization_topology(ufo_materialization)
+    )
+
+
+def test_metadata_records_quotient_strategy_and_counts() -> None:
+    model, prepared = _prepare_builtin("d d~ > z g")
+    recurrence = prepared.dag.helicity_recurrence
+    materialization = prepared.dag.helicity_materialization
+    assert recurrence is not None
+    assert materialization is not None
+    assert materialization.strategy == "quotient"
+    assert (
+        materialization.materialized_current_count
+        <= materialization.proof_current_count
+    )
+    assert materialization.materialized_root_count <= materialization.proof_root_count
+
+    schema = build_runtime_schema(prepared.dag, model)
+    manifest = schema["helicity_recurrence"]["materialization"]
+    assert manifest["strategy"] == "quotient"
+    assert manifest["proof_current_count"] == materialization.proof_current_count
+    assert manifest["proof_root_count"] == materialization.proof_root_count
+    assert manifest["materialized_current_count"] == len(prepared.dag.currents)
+    assert manifest["materialized_root_count"] == len(prepared.dag.amplitude_roots)
+
+    filter_counts = prepared.filters["helicity_recurrence"]
+    assert filter_counts["materialization_strategy"] == "quotient"
+    assert filter_counts["materialized_current_count"] == len(prepared.dag.currents)
+    assert filter_counts["materialized_amplitude_count"] == len(
+        prepared.dag.amplitude_roots
+    )
+    assert prepared.coverage["proof_current_count"] == (
+        materialization.proof_current_count
+    )
+    assert prepared.coverage["helicity_materialization_strategy"] == (
+        "quotient"
+    )
+    assert (
+        prepared.coverage["current_count"]
+        <= prepared.coverage["proof_current_count"]
+    )
+    assert prepared.coverage["amplitude_root_count"] <= (
+        prepared.coverage["proof_amplitude_count"]
+    )
+
+    selector_counts = schema["physics"]["extensions"]["runtime_selectors"][
+        "helicity_recurrence"
+    ]
+    assert selector_counts["execution"] == (
+        "materialized-recurrence-quotient"
+    )
+    assert selector_counts["materialization_strategy"] == "quotient"
+    assert selector_counts["proof_current_count"] == (
+        materialization.proof_current_count
+    )
+    assert selector_counts["materialized_current_count"] == len(
+        prepared.dag.currents
+    )
+
+
+def test_materialized_reduction_uses_the_quotient_helicity_representative() -> None:
+    model, prepared = _prepare_builtin("g g > t t~")
+    physics = build_runtime_schema(prepared.dag, model)["physics"]
+    helicities = {record["id"]: record for record in physics["helicities"]}
+    groups = physics["reduction"]["groups"]
+
+    assert any(
+        group["representative_helicity_id"] != group["physical_helicity_ids"][0]
+        for group in groups
+    )
+    for group in groups:
+        representatives = {
+            helicities[identifier]["representative_id"]
+            for identifier in group["physical_helicity_ids"]
+            if not helicities[identifier]["structural_zero"]
+        }
+        assert representatives == {group["representative_helicity_id"]}
diff --git a/pyamplicol/tests/unit/test_run_cargo.py b/pyamplicol/tests/unit/test_run_cargo.py
new file mode 100644
index 0000000000..33dfe1722f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_run_cargo.py
@@ -0,0 +1,98 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools/release/run_cargo.py"
+
+
+def _module() -> object:
+    spec = importlib.util.spec_from_file_location("run_cargo", SCRIPT)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_run_cargo_requires_subcommand() -> None:
+    module = _module()
+    with pytest.raises(SystemExit, match="2"):
+        module.main(["--mode", "release", "--"])
+
+
+def test_run_cargo_uses_clean_overlay(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    monkeypatch.setattr(module.sys, "platform", "darwin")
+    monkeypatch.setenv("CC", "/attacker/cc")
+    monkeypatch.setenv("CXX", "/attacker/c++")
+    overlay = tmp_path / "overlay"
+    target = tmp_path / "target"
+    overlay.mkdir()
+    calls: list[object] = []
+
+    class Overlay:
+        def __enter__(self) -> tuple[Path, Path]:
+            calls.append(("overlay", "candidate"))
+            return overlay, target
+
+        def __exit__(self, *args: object) -> None:
+            del args
+
+    monkeypatch.setattr(module.backend, "_overlay", lambda mode: Overlay())
+    monkeypatch.setattr(
+        module.backend,
+        "_clean_environment",
+        lambda updates: {"PATH": os.environ.get("PATH", ""), **updates},
+    )
+
+    class Completed:
+        returncode = 7
+
+    def run(command: list[str], **kwargs: object) -> Completed:
+        calls.append((command, kwargs))
+        return Completed()
+
+    import os
+
+    monkeypatch.setattr(module.subprocess, "run", run)
+
+    assert module.main(["--mode", "candidate", "--", "check", "--locked"]) == 7
+    command, options = calls[1]
+    assert command == ["cargo", "check", "--locked"]
+    assert options["cwd"] == overlay
+    assert options["env"]["CARGO_HOME"] == str(tmp_path / "cargo-home")
+    assert options["env"]["CARGO_TARGET_DIR"] == str(target)
+    assert options["env"]["CC"] == "/usr/bin/clang"
+    assert options["env"]["CXX"] == "/usr/bin/clang++"
+    assert options["env"]["MACOSX_DEPLOYMENT_TARGET"] == "11.0"
+
+
+def test_rust_tests_use_only_the_selected_python_loader_directories(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    libdir = tmp_path / "lib"
+    libpl = tmp_path / "config"
+    libdir.mkdir()
+    libpl.mkdir()
+    values = {"LIBDIR": str(libdir), "LIBPL": str(libpl)}
+
+    monkeypatch.setattr(module.sys, "platform", "linux")
+    monkeypatch.setattr(
+        module.sysconfig,
+        "get_config_var",
+        lambda name: values.get(name),
+    )
+
+    assert module._python_test_loader_updates(["test", "--workspace"]) == {
+        "LD_LIBRARY_PATH": f"{libdir}{module.os.pathsep}{libpl}"
+    }
+    assert module._python_test_loader_updates(["check", "--workspace"]) == {}
diff --git a/pyamplicol/tests/unit/test_runtime_adapter.py b/pyamplicol/tests/unit/test_runtime_adapter.py
new file mode 100644
index 0000000000..c8c49715d1
--- /dev/null
+++ b/pyamplicol/tests/unit/test_runtime_adapter.py
@@ -0,0 +1,1492 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib
+import json
+import sys
+from decimal import Decimal
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+from typing import Any
+
+import pytest
+
+from pyamplicol._internal.versions import (
+    COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+    EAGER_DAG_F64_RUNTIME_CAPABILITY,
+    EAGER_RUNTIME_LAYOUT_F64_CAPABILITY,
+    ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_RUNTIME_CAPABILITY,
+    RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+    SYMJIT_F64_RUNTIME_CAPABILITY,
+    SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+)
+from pyamplicol.api import (
+    ArtifactError,
+    ColorFlow,
+    ContractedColorComponent,
+    ExternalParticle,
+    HelicityConfiguration,
+    ModelParameter,
+    ProcessPhysics,
+    ResolvedEvaluation,
+    Runtime,
+    RuntimeBackend,
+    WarmUpResult,
+)
+from pyamplicol.api.errors import CompatibilityError, EvaluationError
+from pyamplicol.artifacts import ArtifactManifest
+from pyamplicol.reporting import (
+    CallbackProgressSink,
+    ProgressEnd,
+    ProgressStart,
+    ProgressUpdate,
+)
+
+
+class _FailingWarmUpProgressSink:
+    def __init__(self, *, fail_during_update: bool = False) -> None:
+        self.fail_during_update = fail_during_update
+        self.events: list[ProgressStart | ProgressUpdate | ProgressEnd] = []
+
+    def emit(self, event: ProgressStart | ProgressUpdate | ProgressEnd) -> None:
+        self.events.append(event)
+        if self.fail_during_update and isinstance(event, ProgressUpdate):
+            raise LookupError("warm-up progress callback failed")
+        if isinstance(event, ProgressEnd) and event.task_id == "runtime-warm-up":
+            raise RuntimeError("terminal warm-up progress delivery failed")
+
+
+def _native_physics(accuracy: str = "lc") -> SimpleNamespace:
+    particles = [
+        SimpleNamespace(
+            index=index,
+            label=index + 1,
+            name=name,
+            pdg_id=pdg,
+            state="incoming" if index < 2 else "outgoing",
+            momentum_slot=index,
+        )
+        for index, (name, pdg) in enumerate((("u", 2), ("u~", -2), ("g", 21)))
+    ]
+    helicities = [
+        SimpleNamespace(
+            id="h0",
+            index=0,
+            values=[-1, 1, 1],
+            computed=True,
+            structural_zero=False,
+            representative_id="h0",
+            coefficient=2.0,
+        )
+    ]
+    flows = []
+    contracted = []
+    if accuracy == "lc":
+        flows.append(
+            SimpleNamespace(
+                id="c0",
+                index=0,
+                word=[1, 2, 3],
+                computed=True,
+                representative_id="c0",
+                coefficient=1.0,
+            )
+        )
+    else:
+        contracted.append(
+            SimpleNamespace(id="contracted", index=0, description="summed color")
+        )
+    return SimpleNamespace(
+        process_id="uux_g",
+        process="u u~ > g",
+        color_accuracy=accuracy,
+        helicity_coverage="complete",
+        color_coverage="complete" if accuracy == "lc" else "contracted",
+        color_kind="physical-lc-flows" if accuracy == "lc" else "contracted-color",
+        structural_zero_helicity_count=0,
+        external_particles=particles,
+        helicities=helicities,
+        color_flows=flows,
+        contracted_color_components=contracted,
+        reduction=SimpleNamespace(
+            kind="lc-diagonal" if accuracy == "lc" else "contracted-color",
+            groups=[
+                SimpleNamespace(
+                    id="g0",
+                    representative_helicity_id="h0",
+                    representative_color_id=(
+                        "c0" if accuracy == "lc" else "contracted"
+                    ),
+                    physical_helicity_ids=["h0"],
+                    physical_color_ids=["c0" if accuracy == "lc" else "contracted"],
+                )
+            ],
+        ),
+        model_parameters=[
+            SimpleNamespace(
+                name="aS",
+                kind="coupling",
+                default_real=0.118,
+                default_imaginary=0.0,
+                mutable=True,
+            )
+        ],
+        selector_capabilities=["helicity"]
+        + (["color_flow"] if accuracy == "lc" else []),
+    )
+
+
+class _NativeArtifactError(Exception):
+    pass
+
+
+class _NativeRuntime:
+    physics_value = _native_physics()
+    load_arguments: tuple[object, ...] | None = None
+    execution_mode = "compiled"
+    artifact_id = "a" * 64
+    last_evaluate_options: dict[str, object] | None = None
+    last_benchmark_options: dict[str, object] | None = None
+    last_profile_options: dict[str, object] | None = None
+    last_arena_profile_options: dict[str, object] | None = None
+    last_warm_up_options: dict[str, object] | None = None
+
+    def __init__(self) -> None:
+        self.parameter_updates: list[dict[str, complex | float | int]] = []
+        self.muted = False
+        self.clear_count = 0
+        self.physics_access_count = 0
+        self.selector_context_access_count = 0
+        self.selector_ordinal_access_count = 0
+        self.runtime_state_census_access_count = 0
+        self.otf_process_preparation_count = 0
+        self.otf_retained_family_count = 0
+        self.otf_retained_selection_count = 0
+
+    @classmethod
+    def load(cls, artifact: Path, **kwargs: object) -> _NativeRuntime:
+        cls.load_arguments = (artifact, kwargs)
+        return cls()
+
+    @property
+    def physics(self) -> SimpleNamespace:
+        self.physics_access_count += 1
+        return self.physics_value
+
+    def metadata_json(self) -> str:
+        return json.dumps(
+            {
+                "execution_mode": self.execution_mode,
+                "color_accuracy": self.physics_value.color_accuracy,
+                "process_key": "uux_g",
+                "representative_process_key": "uux_g",
+                "external_count": 3,
+                "external_permutation": [0, 1, 2],
+                "on_the_fly_requested_query_construction_threads": (
+                    8 if self.execution_mode == "on-the-fly" else None
+                ),
+                "on_the_fly_effective_query_construction_threads": (
+                    4 if self.execution_mode == "on-the-fly" else None
+                ),
+            }
+        )
+
+    def _on_the_fly_benchmark_context_json(
+        self,
+        color_flow_ids: tuple[str, ...] | None = None,
+    ) -> str:
+        self.selector_context_access_count += 1
+        return json.dumps(
+            {
+                "process_id": "uux_g",
+                "process_expression": "u u~ > g",
+                "color_accuracy": "lc",
+                "helicity_count": 1,
+                "color_count": 1,
+                "selected_color_ids": list(color_flow_ids or ()),
+            }
+        )
+
+    def _on_the_fly_selector_ordinals_json(
+        self,
+        helicity_ids: tuple[str, ...] | None = None,
+        color_flow_ids: tuple[str, ...] | None = None,
+    ) -> str:
+        self.selector_ordinal_access_count += 1
+        return json.dumps(
+            {
+                "helicity_ordinals": (
+                    None if helicity_ids is None else [0] * len(helicity_ids)
+                ),
+                "color_ordinals": (
+                    None if color_flow_ids is None else [0] * len(color_flow_ids)
+                ),
+            }
+        )
+
+    def _on_the_fly_runtime_state_census_json(self) -> str | None:
+        self.runtime_state_census_access_count += 1
+        if self.execution_mode not in {"on-the-fly", "recurrence"}:
+            return None
+        payload = {
+            "kind": "rusticol-on-the-fly-runtime-state-census-v1",
+            "process_id": "uux_g",
+            "family_cache_policy": "last-family-only",
+            "family_cache_limit": 1,
+            "process_preparation_count": self.otf_process_preparation_count,
+            "retained_family_count": self.otf_retained_family_count,
+            "pending_family_count": 0,
+            "retained_selection_count": self.otf_retained_selection_count,
+            "retained_request_count": self.otf_retained_family_count,
+            "retained_amplitude_destination_count": (self.otf_retained_family_count),
+            "retained_executor_handle_count": self.otf_retained_family_count,
+            "retained_query_local_trace_count": 0,
+            "retained_embedded_lookup_key_count": 0,
+            "semantic_executor_binding_count": self.otf_retained_family_count,
+            "active_family_union_census": None,
+        }
+        if self.execution_mode == "recurrence":
+            payload["owner"] = "recurrence-helicity-selector-companion"
+        return json.dumps(payload)
+
+    def _warm_on_the_fly(self) -> None:
+        if self.execution_mode == "on-the-fly":
+            self.otf_process_preparation_count = 1
+            self.otf_retained_family_count = 1
+            self.otf_retained_selection_count = 1
+
+    def _on_the_fly_warm_up_f64_json(
+        self,
+        momenta: object,
+        helicity_ids: tuple[str, ...] | None = None,
+        color_flow_ids: tuple[str, ...] | None = None,
+        progress_callback: object = None,
+        n_cores: int | None = None,
+    ) -> str:
+        type(self).last_warm_up_options = {
+            "momenta": momenta,
+            "helicity_ids": helicity_ids,
+            "color_flow_ids": color_flow_ids,
+            "n_cores": n_cores,
+        }
+        if callable(progress_callback):
+            for kind, stage, completed, total in (
+                ("start", "process_preparation", 0, 1),
+                ("update", "process_preparation", 1, 1),
+                ("update", "query_family", 2, 3),
+                ("update", "query_family", 3, 3),
+                ("update", "family_finalization", 1, 1),
+                ("end", "first_evaluation", 1, 1),
+            ):
+                keep_going = progress_callback(
+                    json.dumps(
+                        {
+                            "schema_version": 1,
+                            "kind": kind,
+                            "stage": stage,
+                            "completed": completed,
+                            "total": total,
+                            "elapsed_seconds": 0.25,
+                            "current_rss_bytes": 256 * 1024**2,
+                            "peak_rss_bytes": 384 * 1024**2,
+                            "workers": 4,
+                            "message": None,
+                        }
+                    )
+                )
+                if keep_going is False:
+                    raise RuntimeError("warm-up cancelled")
+        self._warm_on_the_fly()
+        return json.dumps(
+            {
+                "schema_version": 1,
+                "elapsed_seconds": 0.5,
+                "query_count": 3,
+                "warmed_query_count": 3,
+                "current_rss_bytes": 256 * 1024**2,
+                "peak_rss_bytes": 384 * 1024**2,
+                "already_warm": False,
+                "first_evaluation_completed": True,
+            }
+        )
+
+    def evaluate(self, _momenta: object, **kwargs: object) -> list[object]:
+        self._warm_on_the_fly()
+        type(self).last_evaluate_options = dict(kwargs)
+        return [Decimal("1.25")] if kwargs["precision"] == 32 else [2.0]
+
+    def evaluate_resolved(self, _momenta: object, **kwargs: object) -> SimpleNamespace:
+        self._warm_on_the_fly()
+        accuracy = self.physics_value.color_accuracy
+        color_id = "c0" if accuracy == "lc" else "contracted"
+        scalar: object = Decimal("1.25") if kwargs["precision"] == 32 else 2.0
+        return SimpleNamespace(
+            values=[[[scalar]]],
+            helicity_ids=["h0"],
+            color_ids=[color_id],
+            color_accuracy=accuracy,
+        )
+
+    def _benchmark_f64_wall_time(
+        self, _momenta: object, _repetitions: int, **kwargs: object
+    ) -> float:
+        self._warm_on_the_fly()
+        type(self).last_benchmark_options = dict(kwargs)
+        return 0.25
+
+    def profile(self, _momenta: object, **kwargs: object) -> dict[str, object]:
+        self._warm_on_the_fly()
+        type(self).last_profile_options = dict(kwargs)
+        return {"wall_time_s": 0.25}
+
+    def profile_repeated(
+        self, _momenta: object, _repetitions: int, **kwargs: object
+    ) -> dict[str, object]:
+        self._warm_on_the_fly()
+        type(self).last_profile_options = dict(kwargs)
+        return {"wall_time_s": 0.5}
+
+    def _profile_arena_repeated(
+        self, _momenta: object, _repetitions: int, **kwargs: object
+    ) -> dict[str, object]:
+        self._warm_on_the_fly()
+        type(self).last_arena_profile_options = dict(kwargs)
+        return {"wall_time_s": 0.4}
+
+    def set_model_parameters(self, mapping: dict[str, complex | float | int]) -> None:
+        self.parameter_updates.append(mapping)
+
+    def clear(self) -> None:
+        self.clear_count += 1
+        self.otf_process_preparation_count = 0
+        self.otf_retained_family_count = 0
+        self.otf_retained_selection_count = 0
+
+    def mute_warnings(self) -> None:
+        self.muted = True
+
+    def unmute_warnings(self) -> None:
+        self.muted = False
+
+    def take_warnings(self) -> list[str]:
+        return ["native warning"]
+
+
+class _PreSelectorNativeRuntime(_NativeRuntime):
+    @classmethod
+    def load(cls, artifact: Path, **kwargs: object) -> _PreSelectorNativeRuntime:
+        cls.load_arguments = (artifact, kwargs)
+        return cls()
+
+    def evaluate(
+        self,
+        _momenta: object,
+        *,
+        helicities: object = None,
+        color_flows: object = None,
+        precision: int = 16,
+    ) -> list[object]:
+        type(self).last_evaluate_options = {
+            "helicities": helicities,
+            "color_flows": color_flows,
+            "precision": precision,
+        }
+        return [2.0]
+
+
+class _ExactExecutor:
+    def __init__(self, _artifact: Path, _process_id: str, _runtime: object) -> None:
+        pass
+
+    def evaluate_resolved(
+        self, _momenta: object, **_kwargs: object
+    ) -> ResolvedEvaluation:
+        accuracy = _NativeRuntime.physics_value.color_accuracy
+        color_id = "c0" if accuracy == "lc" else "contracted"
+        return ResolvedEvaluation(
+            values=(((Decimal("1.25"),),),),
+            helicity_ids=("h0",),
+            color_ids=(color_id,),
+            color_accuracy=accuracy,
+        )
+
+
+def _install_native(monkeypatch: pytest.MonkeyPatch) -> ModuleType:
+    module = ModuleType("pyamplicol._rusticol")
+    module.Runtime = _NativeRuntime  # type: ignore[attr-defined]
+    module.ArtifactError = _NativeArtifactError  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, module.__name__, module)
+    return module
+
+
+def _selector_manifest(
+    tmp_path: Path,
+    *,
+    capabilities: tuple[str, ...],
+) -> ArtifactManifest:
+    physics_path = Path("processes/uux_g/physics.json")
+    destination = tmp_path / physics_path
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    destination.write_text(
+        json.dumps(
+            {
+                "extensions": {
+                    "runtime_selectors": {
+                        "axes": {
+                            "helicity": {"runtime_contract": "complete-reusable"},
+                            "color_flow": {"runtime_contract": "complete-reusable"},
+                        }
+                    }
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+    (tmp_path / "artifact.json").write_text("{}", encoding="utf-8")
+    process = {
+        "id": "uux_g",
+        "physics_path": physics_path.as_posix(),
+        "required_runtime_capabilities": capabilities,
+        "aliases": (),
+    }
+    return ArtifactManifest(
+        root=tmp_path,
+        kind="pyamplicol-process",
+        artifact_id="0" * 64,
+        created_utc="2026-07-21T00:00:00Z",
+        producer={},
+        model={},
+        configuration={},
+        processes=(process,),
+        default_process_id="uux_g",
+        runtime={"required_runtime_capabilities": capabilities},
+        payloads=(),
+        dependencies=(),
+        extensions={},
+    )
+
+
+def _load_on_the_fly_backend(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> Any:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    manifest = _selector_manifest(
+        tmp_path,
+        capabilities=(
+            ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+        ),
+    )
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+    _NativeRuntime.execution_mode = "on-the-fly"
+    _NativeRuntime.physics_value = _native_physics("lc")
+    _NativeRuntime.last_evaluate_options = None
+    _NativeRuntime.last_benchmark_options = None
+    _NativeRuntime.last_profile_options = None
+    _NativeRuntime.last_arena_profile_options = None
+    _NativeRuntime.last_warm_up_options = None
+    return backend_module.load_runtime_backend(tmp_path, process="uux_g")
+
+
+def _load_recurrence_companion_backend(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> Any:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    manifest = _selector_manifest(
+        tmp_path,
+        capabilities=(
+            RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            RECURRENCE_HELICITY_SELECTOR_COMPANION_RUNTIME_CAPABILITY,
+        ),
+    )
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+    _NativeRuntime.execution_mode = "recurrence"
+    _NativeRuntime.physics_value = _native_physics("full")
+    return backend_module.load_runtime_backend(tmp_path, process="uux_g")
+
+
+def test_runtime_discovery_does_not_import_native_extension(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    real_import = importlib.import_module
+    imports: list[str] = []
+
+    def tracked_import(name: str, package: str | None = None) -> Any:
+        imports.append(name)
+        return real_import(name, package)
+
+    monkeypatch.delitem(sys.modules, "pyamplicol._rusticol", raising=False)
+    monkeypatch.setattr(importlib, "import_module", tracked_import)
+    runtime = real_import("pyamplicol.runtime")
+
+    assert callable(runtime.load_runtime_backend)
+    assert "pyamplicol._rusticol" not in imports
+
+
+def test_adapter_maps_typed_metadata_totals_and_runtime_state(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _install_native(monkeypatch)
+    monkeypatch.setattr(
+        "pyamplicol.runtime.symbolica_exact.SymbolicaExactExecutor",
+        _ExactExecutor,
+    )
+    from pyamplicol.runtime import load_runtime_backend
+
+    _NativeRuntime.physics_value = _native_physics("lc")
+    backend = load_runtime_backend(
+        tmp_path,
+        process="uux_g",
+        model_parameters={"aS": 0.12},
+        mute_warnings=True,
+    )
+
+    assert isinstance(backend, RuntimeBackend)
+    assert isinstance(backend.physics, ProcessPhysics)
+    assert isinstance(backend.physics.external_particles[0], ExternalParticle)
+    assert isinstance(backend.physics.helicities[0], HelicityConfiguration)
+    assert isinstance(backend.physics.color_flows[0], ColorFlow)
+    assert isinstance(backend.physics.model_parameters[0], ModelParameter)
+    assert backend.artifact_id == "a" * 64
+    assert backend.representative_process_key == "uux_g"
+    assert backend.external_permutation == (0, 1, 2)
+    assert backend.physics.external_particles[0].name == "u"
+    assert backend.physics.external_particles[0].pdg_id == 2
+    assert backend.physics.external_particles[0].state == "incoming"
+    assert backend.physics.selector_capabilities == ("helicity", "color_flow")
+    assert backend.evaluate([], precision=16) == (2.0 + 0.0j,)
+    assert backend.evaluate([], precision=32) == (Decimal("1.25"),)
+
+    resolved = backend.evaluate_resolved([], precision=32)
+    assert isinstance(resolved, ResolvedEvaluation)
+    assert resolved.shape == (1, 1, 1)
+    assert resolved.total() == (Decimal("1.25"),)
+
+    backend.set_model_parameters({"aS": 0.13})
+    backend.clear()
+    backend.mute_warnings()
+    assert backend._runtime.parameter_updates == [{"aS": 0.13}]
+    assert backend._runtime.clear_count == 1
+    assert backend._runtime.muted is True
+    backend.unmute_warnings()
+    assert backend._runtime.muted is False
+    assert backend.take_warnings() == ("native warning",)
+
+    path, options = _NativeRuntime.load_arguments or (None, {})
+    assert path == tmp_path.resolve()
+    assert options == {
+        "process": "uux_g",
+        "model_parameters": {"aS": 0.12},
+        "mute_warnings": True,
+    }
+
+    public = Runtime.load(tmp_path, process="uux_g")
+    public.clear()
+    assert public._backend._runtime.clear_count == 1
+    assert public.artifact_id == "a" * 64
+    assert public.execution_mode == "compiled"
+    assert public.representative_process_key == "uux_g"
+    assert public.external_permutation == (0, 1, 2)
+    assert isinstance(public.physics, ProcessPhysics)
+    assert public.evaluate([], precision=32) == (Decimal("1.25"),)
+    for invalid_artifact_id in ("g" * 64, "A" * 64):
+        _NativeRuntime.artifact_id = invalid_artifact_id
+        with pytest.raises(EvaluationError, match="authenticated artifact identity"):
+            _ = public.artifact_id
+    _NativeRuntime.artifact_id = "a" * 64
+
+
+def test_adapter_routes_eager_high_precision_to_eager_exact_executor(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _install_native(monkeypatch)
+    monkeypatch.setattr(
+        "pyamplicol.runtime.eager_exact.EagerExactExecutor",
+        _ExactExecutor,
+    )
+    from pyamplicol.runtime import load_runtime_backend
+
+    _NativeRuntime.execution_mode = "eager"
+    try:
+        backend = load_runtime_backend(tmp_path, process="uux_g")
+        assert backend.evaluate([], precision=32) == (Decimal("1.25"),)
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+def test_default_runtime_paths_do_not_force_process_physics(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _install_native(monkeypatch)
+    from pyamplicol.runtime import load_runtime_backend
+
+    backend = load_runtime_backend(tmp_path, process="uux_g")
+
+    backend.evaluate([], precision=16)
+    backend.evaluate_resolved([], precision=16)
+    backend._benchmark_f64_wall_time([], 2)
+    backend._profile_arena_repeated([], 2)
+    backend.profile([])
+    backend.profile_repeated([], 2)
+    backend.clear()
+    assert backend._runtime.physics_access_count == 0
+
+    backend.evaluate([()], helicity_by_point=("h0",))
+    assert backend._runtime.physics_access_count == 1
+
+
+def test_external_permutation_does_not_materialize_process_physics(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _install_native(monkeypatch)
+    from pyamplicol.runtime import load_runtime_backend
+
+    backend = load_runtime_backend(tmp_path, process="uux_g")
+    runtime = Runtime(backend)
+
+    assert backend._runtime.physics_access_count == 0
+    assert backend.external_count == 3
+    assert backend.external_permutation == (0, 1, 2)
+    assert runtime.external_permutation == (0, 1, 2)
+    assert backend._runtime.physics_access_count == 0
+
+
+def test_on_the_fly_non_f64_paths_fail_before_selector_or_physics_access(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    backend = _load_on_the_fly_backend(monkeypatch, tmp_path)
+    runtime = Runtime(backend)
+    point = ((),)
+    try:
+        operations = (
+            lambda: runtime.evaluate(point, color_flows=("1",), precision=32),
+            lambda: runtime.evaluate_with_prec(
+                point,
+                32,
+                color_flows=("1",),
+            ),
+            lambda: backend.evaluate(
+                point,
+                helicity_by_point=("h0",),
+                precision=32,
+            ),
+            lambda: runtime.evaluate_resolved(
+                point,
+                color_flows=("1",),
+                precision=32,
+            ),
+            lambda: runtime.evaluate_resolved_with_prec(
+                point,
+                32,
+                color_flows=("1",),
+            ),
+            lambda: backend._benchmark_f64_wall_time(
+                point,
+                2,
+                color_flows=("1",),
+                precision=32,
+            ),
+            lambda: backend._profile_arena_repeated(
+                point,
+                2,
+                color_flows=("1",),
+                precision=32,
+            ),
+            lambda: backend.profile(
+                point,
+                color_flows=("1",),
+                precision=32,
+            ),
+            lambda: backend.profile_repeated(
+                point,
+                2,
+                color_flows=("1",),
+                precision=32,
+            ),
+            lambda: backend.evaluate_profile(
+                point,
+                color_flows=("1",),
+                precision=32,
+            ),
+            lambda: runtime._diagnostic_project_onshell(point, precision=32),
+        )
+        for operation in operations:
+            with pytest.raises(
+                CompatibilityError,
+                match=r"on-the-fly execution supports only precision=16",
+            ):
+                operation()
+
+        native = backend._runtime
+        assert native.physics_access_count == 0
+        assert native.selector_context_access_count == 0
+        assert native.selector_ordinal_access_count == 0
+        assert native.runtime_state_census_access_count == 0
+        assert native.otf_process_preparation_count == 0
+        assert native.otf_retained_family_count == 0
+        assert native.otf_retained_selection_count == 0
+        assert backend._exact_executor is None
+        assert _NativeRuntime.last_evaluate_options is None
+        assert _NativeRuntime.last_benchmark_options is None
+        assert _NativeRuntime.last_profile_options is None
+        assert _NativeRuntime.last_arena_profile_options is None
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+def test_runtime_inspect_observes_otf_state_without_opening_physics(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    backend = _load_on_the_fly_backend(monkeypatch, tmp_path)
+    runtime = Runtime(backend)
+    try:
+        cold = runtime.inspect()
+        assert cold["kind"] == "pyamplicol-runtime-inspection"
+        assert cold["schema_version"] == 1
+        assert cold["artifact_id"] == "a" * 64
+        assert cold["supported_precisions"] == (16,)
+        metadata = cold["runtime_metadata"]
+        assert isinstance(metadata, dict)
+        assert metadata["execution_mode"] == "on-the-fly"
+        assert metadata["external_count"] == 3
+        assert metadata["external_permutation"] == [0, 1, 2]
+        assert metadata["on_the_fly_requested_query_construction_threads"] == 8
+        assert metadata["on_the_fly_effective_query_construction_threads"] == 4
+        cold_state = cold["on_the_fly_state"]
+        assert isinstance(cold_state, dict)
+        assert cold_state["family_cache_policy"] == "last-family-only"
+        assert cold_state["family_cache_limit"] == 1
+        assert cold_state["retained_family_count"] == 0
+        assert cold_state["retained_selection_count"] == 0
+
+        metadata["external_permutation"][0] = 2
+        repeated = runtime.inspect()
+        repeated_metadata = repeated["runtime_metadata"]
+        assert isinstance(repeated_metadata, dict)
+        assert repeated_metadata["external_permutation"] == [0, 1, 2]
+
+        assert runtime.evaluate(((),), precision=16) == (2.0 + 0.0j,)
+        warm = runtime.inspect()
+        warm_state = warm["on_the_fly_state"]
+        assert isinstance(warm_state, dict)
+        assert warm_state["process_preparation_count"] == 1
+        assert warm_state["retained_family_count"] == 1
+        assert warm_state["retained_selection_count"] == 1
+
+        runtime.clear()
+        cleared = runtime.inspect()
+        cleared_state = cleared["on_the_fly_state"]
+        assert isinstance(cleared_state, dict)
+        assert cleared_state["process_preparation_count"] == 0
+        assert cleared_state["retained_family_count"] == 0
+        assert cleared_state["retained_selection_count"] == 0
+        assert backend._runtime.physics_access_count == 0
+        assert backend._runtime.selector_context_access_count == 0
+        assert backend._runtime.selector_ordinal_access_count == 0
+        assert backend._runtime.runtime_state_census_access_count == 4
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+def test_runtime_inspect_observes_recurrence_companion_without_relabeling_lane(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    backend = _load_recurrence_companion_backend(monkeypatch, tmp_path)
+    runtime = Runtime(backend)
+    try:
+        inspected = runtime.inspect()
+
+        assert runtime.execution_mode == "recurrence"
+        assert inspected["runtime_metadata"]["execution_mode"] == "recurrence"
+        assert "supported_precisions" not in inspected
+        companion = inspected["on_the_fly_state"]
+        assert isinstance(companion, dict)
+        assert companion["owner"] == "recurrence-helicity-selector-companion"
+        assert companion["retained_family_count"] == 0
+        assert backend._runtime.physics_access_count == 0
+        assert backend._runtime.runtime_state_census_access_count == 1
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+def test_runtime_inspect_does_not_probe_ordinary_recurrence_as_otf(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    manifest = _selector_manifest(
+        tmp_path,
+        capabilities=(RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,),
+    )
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+    _NativeRuntime.execution_mode = "recurrence"
+    try:
+        backend = backend_module.load_runtime_backend(tmp_path, process="uux_g")
+
+        assert backend.inspect()["on_the_fly_state"] is None
+        assert backend._runtime.runtime_state_census_access_count == 0
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+def test_adapter_accepts_one_based_color_flow_ordinals(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _install_native(monkeypatch)
+    from pyamplicol.runtime import load_runtime_backend
+
+    _NativeRuntime.physics_value = _native_physics("lc")
+    _NativeRuntime.last_evaluate_options = None
+    backend = load_runtime_backend(tmp_path, process="uux_g")
+
+    backend.evaluate([], color_flows=("1",))
+
+    assert _NativeRuntime.last_evaluate_options is not None
+    assert _NativeRuntime.last_evaluate_options["color_flows"] == ("c0",)
+    with pytest.raises(EvaluationError, match=r"choose 1\.\.1"):
+        backend.evaluate([], color_flows=("2",))
+
+
+def test_adapter_resolves_per_point_selector_ids_to_native_indices(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _install_native(monkeypatch)
+    from pyamplicol.runtime import load_runtime_backend
+
+    _NativeRuntime.physics_value = _native_physics("lc")
+    _NativeRuntime.last_evaluate_options = None
+    backend = load_runtime_backend(tmp_path, process="uux_g")
+
+    backend.evaluate(
+        [(), ()],
+        helicity_by_point=("h0", "h0"),
+        color_flow_by_point=("1", "c0"),
+    )
+
+    assert _NativeRuntime.last_evaluate_options is not None
+    assert _NativeRuntime.last_evaluate_options["helicity_by_point"] == (0, 0)
+    assert _NativeRuntime.last_evaluate_options["color_flow_by_point"] == (0, 0)
+    with pytest.raises(EvaluationError, match=r"helicity_by_point\[1\]"):
+        backend.evaluate(
+            [(), ()],
+            helicity_by_point=("h0", "missing"),
+        )
+
+
+def test_adapter_requires_selector_capability_for_reusable_artifact(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    manifest = _selector_manifest(
+        tmp_path,
+        capabilities=(SYMJIT_F64_RUNTIME_CAPABILITY,),
+    )
+    manifest_options: list[dict[str, object]] = []
+
+    def load_adapter_manifest(
+        _path: Path,
+        **options: object,
+    ) -> ArtifactManifest:
+        manifest_options.append(options)
+        return manifest
+
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        load_adapter_manifest,
+    )
+
+    with pytest.raises(
+        CompatibilityError,
+        match=r"declares reusable runtime selectors.*does not require",
+    ):
+        backend_module.load_runtime_backend(tmp_path, process="uux_g")
+    assert manifest_options == [{"verify_payloads": False}]
+
+
+def test_adapter_checks_native_selector_callable_against_capability(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _install_native(monkeypatch)
+    module.Runtime = _PreSelectorNativeRuntime  # type: ignore[attr-defined]
+    import pyamplicol.runtime.backend as backend_module
+
+    capabilities = (
+        COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+        SYMJIT_F64_RUNTIME_CAPABILITY,
+    )
+    manifest = _selector_manifest(tmp_path, capabilities=capabilities)
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+
+    with pytest.raises(
+        CompatibilityError,
+        match="installed native runtime does not accept per-point selectors",
+    ):
+        backend_module.load_runtime_backend(tmp_path, process="uux_g")
+
+
+def test_adapter_accepts_compact_eager_runtime_selector_capability(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    manifest = _selector_manifest(
+        tmp_path,
+        capabilities=(EAGER_RUNTIME_LAYOUT_F64_CAPABILITY,),
+    )
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+    _NativeRuntime.execution_mode = "eager"
+    try:
+        backend = backend_module.load_runtime_backend(tmp_path, process="uux_g")
+        assert backend.supports_per_point_selectors is True
+        backend.evaluate(
+            [(), ()],
+            helicity_by_point=("h0", "h0"),
+            color_flow_by_point=("c0", "c0"),
+        )
+        assert _NativeRuntime.last_evaluate_options is not None
+        assert _NativeRuntime.last_evaluate_options["helicity_by_point"] == (0, 0)
+        assert _NativeRuntime.last_evaluate_options["color_flow_by_point"] == (0, 0)
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+def test_adapter_accepts_on_the_fly_without_reading_dense_selector_metadata(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    manifest = _selector_manifest(
+        tmp_path,
+        capabilities=(
+            ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+        ),
+    )
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+    monkeypatch.setattr(
+        backend_module,
+        "_has_reusable_runtime_selector_contract",
+        lambda *_args, **_kwargs: (_ for _ in ()).throw(
+            AssertionError("on-the-fly adapter read dense selector metadata")
+        ),
+    )
+    _NativeRuntime.execution_mode = "on-the-fly"
+    try:
+        backend = backend_module.load_runtime_backend(tmp_path, process="uux_g")
+        assert backend.execution_mode == "on-the-fly"
+        assert backend.supports_per_point_selectors is True
+        assert backend.evaluate([()], helicities=("h0",)) == (2.0 + 0.0j,)
+        backend.evaluate(
+            [(), ()],
+            helicity_by_point=("h0", "h0"),
+            color_flow_by_point=("c0", "c0"),
+        )
+        assert _NativeRuntime.last_evaluate_options is not None
+        assert _NativeRuntime.last_evaluate_options["helicity_by_point"] == (0, 0)
+        assert _NativeRuntime.last_evaluate_options["color_flow_by_point"] == (0, 0)
+        backend._benchmark_f64_wall_time(
+            [(), ()],
+            2,
+            helicity_by_point=("h0", "h0"),
+            color_flow_by_point=("c0", "c0"),
+        )
+        backend.profile(
+            [(), ()],
+            helicity_by_point=("h0", "h0"),
+            color_flow_by_point=("c0", "c0"),
+        )
+        assert backend._runtime.physics_access_count == 0
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+def test_on_the_fly_warm_up_maps_native_progress_without_dense_physics(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    backend = _load_on_the_fly_backend(monkeypatch, tmp_path)
+    events: list[object] = []
+    try:
+        result = Runtime(backend).warm_up(
+            ((),),
+            helicities=("h0",),
+            color_flows=("c0",),
+            progress=CallbackProgressSink(events.append),
+            n_cores=4,
+        )
+
+        assert result == WarmUpResult(
+            elapsed_seconds=0.5,
+            query_count=3,
+            warmed_query_count=3,
+            current_rss_bytes=256 * 1024**2,
+            peak_rss_bytes=384 * 1024**2,
+            already_warm=False,
+        )
+        assert _NativeRuntime.last_warm_up_options == {
+            "momenta": ((),),
+            "helicity_ids": ("h0",),
+            "color_flow_ids": ("c0",),
+            "n_cores": 4,
+        }
+        assert backend._runtime.physics_access_count == 0
+        assert (
+            sum(
+                isinstance(event, ProgressStart) and event.task_id == "runtime-warm-up"
+                for event in events
+            )
+            == 1
+        )
+        assert (
+            sum(
+                isinstance(event, ProgressEnd)
+                and event.task_id == "runtime-warm-up"
+                and event.success
+                for event in events
+            )
+            == 1
+        )
+        query_updates = [
+            event
+            for event in events
+            if isinstance(event, ProgressUpdate)
+            and event.task_id == "runtime-warm-up:query_family"
+        ]
+        assert query_updates[-1].completed == 3
+        assert query_updates[-1].total == 3
+        assert query_updates[-1].details["native_current_rss_bytes"] == (256 * 1024**2)
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+def test_on_the_fly_warm_up_ignores_terminal_progress_error_after_commit(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    backend = _load_on_the_fly_backend(monkeypatch, tmp_path)
+    sink = _FailingWarmUpProgressSink()
+    try:
+        result = Runtime(backend).warm_up(((),), progress=sink)
+
+        assert result.warmed_query_count == 3
+        assert backend._runtime.otf_retained_family_count == 1
+        assert any(
+            isinstance(event, ProgressEnd)
+            and event.task_id == "runtime-warm-up"
+            and event.success
+            for event in sink.events
+        )
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+def test_on_the_fly_warm_up_cleanup_does_not_mask_callback_error(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    backend = _load_on_the_fly_backend(monkeypatch, tmp_path)
+    sink = _FailingWarmUpProgressSink(fail_during_update=True)
+    try:
+        with pytest.raises(LookupError, match="progress callback failed"):
+            Runtime(backend).warm_up(((),), progress=sink)
+
+        assert backend._runtime.otf_retained_family_count == 0
+        assert any(
+            isinstance(event, ProgressEnd)
+            and event.task_id == "runtime-warm-up"
+            and not event.success
+            for event in sink.events
+        )
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+@pytest.mark.parametrize("first_evaluation_completed", (None, False))
+def test_on_the_fly_warm_up_requires_completed_first_evaluation(
+    first_evaluation_completed: bool | None,
+) -> None:
+    import pyamplicol.runtime.backend as backend_module
+
+    payload: dict[str, object] = {
+        "schema_version": 1,
+        "elapsed_seconds": 0.5,
+        "query_count": 3,
+        "warmed_query_count": 3,
+        "current_rss_bytes": None,
+        "peak_rss_bytes": None,
+        "already_warm": False,
+    }
+    if first_evaluation_completed is not None:
+        payload["first_evaluation_completed"] = first_evaluation_completed
+
+    with pytest.raises(ArtifactError, match="first_evaluation_completed"):
+        backend_module._warm_up_result(json.dumps(payload))
+
+
+def test_adapter_accepts_on_the_fly_contracted_color_capability(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    manifest = _selector_manifest(
+        tmp_path,
+        capabilities=(
+            ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+        ),
+    )
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+    _NativeRuntime.execution_mode = "on-the-fly"
+    _NativeRuntime.physics_value = _native_physics("full")
+    _NativeRuntime.last_warm_up_options = None
+    try:
+        backend = backend_module.load_runtime_backend(tmp_path, process="uux_g")
+        assert backend.execution_mode == "on-the-fly"
+        assert backend.physics.color_accuracy == "full"
+        assert backend.required_runtime_capabilities == (
+            ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+        )
+        with pytest.raises(EvaluationError, match="does not expose color-flow"):
+            Runtime(backend).warm_up(((),), color_flows=("c0",))
+        assert _NativeRuntime.last_warm_up_options is None
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+        _NativeRuntime.physics_value = _native_physics("lc")
+
+
+def test_adapter_accepts_on_the_fly_symmetric_group_fft_capability(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    capabilities = (
+        ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+        ON_THE_FLY_RUNTIME_CAPABILITY,
+        SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+    )
+    manifest = _selector_manifest(tmp_path, capabilities=capabilities)
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+    _NativeRuntime.execution_mode = "on-the-fly"
+    _NativeRuntime.physics_value = _native_physics("full")
+    try:
+        runtime = Runtime.load(tmp_path, process="uux_g")
+        assert runtime.execution_mode == "on-the-fly"
+        assert runtime.physics.color_accuracy == "full"
+        assert runtime._backend.required_runtime_capabilities == capabilities
+        assert runtime._backend.supports_per_point_selectors
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+        _NativeRuntime.physics_value = _native_physics("lc")
+
+
+def test_compiled_symmetric_group_fft_rejects_exact_precision_before_dispatch(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    capabilities = (
+        COMPILED_RUNTIME_SELECTORS_CAPABILITY,
+        SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+    )
+    manifest = _selector_manifest(tmp_path, capabilities=capabilities)
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+    _NativeRuntime.execution_mode = "compiled"
+    _NativeRuntime.physics_value = _native_physics("full")
+    runtime = Runtime.load(tmp_path, process="uux_g")
+
+    assert runtime.evaluate([], precision=16) == (2.0 + 0.0j,)
+    with pytest.raises(CompatibilityError, match="only precision=16 native f64"):
+        runtime.evaluate([], precision=32)
+
+
+@pytest.mark.parametrize(
+    "capabilities",
+    (
+        (
+            ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+            "unknown.runtime-capability.v1",
+        ),
+        (
+            ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+            SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+            "unknown.runtime-capability.v1",
+        ),
+        (
+            ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+            SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+        ),
+        (
+            ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+            SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+            SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+        ),
+        (
+            ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+            SYMMETRIC_GROUP_FFT_COLOR_RUNTIME_CAPABILITY,
+        ),
+    ),
+    ids=(
+        "direct-extra",
+        "fft-extra",
+        "fft-with-lc",
+        "duplicate-fft",
+        "fft-without-otf",
+    ),
+)
+def test_adapter_rejects_invalid_on_the_fly_capability_sets(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    capabilities: tuple[str, ...],
+) -> None:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    manifest = _selector_manifest(tmp_path, capabilities=capabilities)
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+    _NativeRuntime.execution_mode = "on-the-fly"
+    _NativeRuntime.physics_value = _native_physics("full")
+    try:
+        with pytest.raises(
+            CompatibilityError,
+            match="invalid runtime capability contract",
+        ):
+            Runtime.load(tmp_path, process="uux_g")
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+        _NativeRuntime.physics_value = _native_physics("lc")
+
+
+def test_adapter_does_not_treat_retired_eager_v2_as_selector_support(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _install_native(monkeypatch)
+    import pyamplicol.runtime.backend as backend_module
+
+    manifest = _selector_manifest(
+        tmp_path,
+        capabilities=(EAGER_DAG_F64_RUNTIME_CAPABILITY,),
+    )
+    monkeypatch.setattr(
+        backend_module,
+        "load_manifest",
+        lambda _path, **_kwargs: manifest,
+    )
+    _NativeRuntime.execution_mode = "eager"
+    try:
+        backend = backend_module.load_runtime_backend(tmp_path, process="uux_g")
+        assert backend.supports_per_point_selectors is False
+    finally:
+        _NativeRuntime.execution_mode = "compiled"
+
+
+def test_adapter_does_not_pass_selector_keywords_when_axes_are_empty(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    module = _install_native(monkeypatch)
+    module.Runtime = _PreSelectorNativeRuntime  # type: ignore[attr-defined]
+    from pyamplicol.runtime import load_runtime_backend
+
+    _PreSelectorNativeRuntime.last_evaluate_options = None
+    backend = load_runtime_backend(tmp_path, process="uux_g")
+
+    assert backend.evaluate(
+        [],
+        helicities=(),
+        color_flows=(),
+        helicity_by_point=(),
+        color_flow_by_point=(),
+    ) == (2.0 + 0.0j,)
+    assert _PreSelectorNativeRuntime.last_evaluate_options == {
+        "helicities": None,
+        "color_flows": None,
+        "precision": 16,
+    }
+
+    with pytest.raises(CompatibilityError, match="does not support per-point"):
+        backend.evaluate([()], helicity_by_point=("h0",))
+
+
+def test_native_wall_timer_resolves_per_point_selectors(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _install_native(monkeypatch)
+    from pyamplicol.runtime import load_runtime_backend
+
+    _NativeRuntime.physics_value = _native_physics("lc")
+    backend = load_runtime_backend(tmp_path, process="uux_g")
+    elapsed = backend._benchmark_f64_wall_time(
+        ((), ()),
+        3,
+        helicity_by_point=("h0", "h0"),
+        color_flow_by_point=("1", "c0"),
+    )
+
+    assert elapsed == 0.25
+    assert _NativeRuntime.last_benchmark_options == {
+        "helicities": None,
+        "color_flows": None,
+        "precision": 16,
+        "helicity_by_point": (0, 0),
+        "color_flow_by_point": (0, 0),
+    }
+
+
+def test_native_profile_resolves_per_point_selectors(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _install_native(monkeypatch)
+    from pyamplicol.runtime import load_runtime_backend
+
+    _NativeRuntime.physics_value = _native_physics("lc")
+    backend = load_runtime_backend(tmp_path, process="uux_g")
+    payload = backend.profile_repeated(
+        ((), ()),
+        3,
+        helicity_by_point=("h0", "h0"),
+        color_flow_by_point=("1", "c0"),
+    )
+
+    assert payload == {"wall_time_s": 0.5}
+    assert _NativeRuntime.last_profile_options == {
+        "helicities": None,
+        "color_flows": None,
+        "precision": 16,
+        "include_values": False,
+        "helicity_by_point": (0, 0),
+        "color_flow_by_point": (0, 0),
+    }
+
+
+def test_private_arena_profiler_never_uses_public_profile_repeated(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _install_native(monkeypatch)
+    from pyamplicol.runtime import load_runtime_backend
+
+    _NativeRuntime.physics_value = _native_physics("lc")
+    _NativeRuntime.last_profile_options = None
+    _NativeRuntime.last_arena_profile_options = None
+    backend = load_runtime_backend(tmp_path, process="uux_g")
+    payload = backend._profile_arena_repeated(
+        ((), ()),
+        3,
+        helicities=("h0",),
+        color_flows=("1",),
+    )
+
+    assert payload == {"wall_time_s": 0.4}
+    assert _NativeRuntime.last_arena_profile_options == {
+        "helicities": ("h0",),
+        "color_flows": ("c0",),
+        "precision": 16,
+        "include_values": False,
+    }
+    assert _NativeRuntime.last_profile_options is None
+
+
+def test_adapter_maps_contracted_color_and_native_errors(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _install_native(monkeypatch)
+    from pyamplicol.runtime import load_runtime_backend
+
+    _NativeRuntime.physics_value = _native_physics("full")
+    backend = load_runtime_backend(
+        tmp_path,
+        process=None,
+        model_parameters=None,
+        mute_warnings=False,
+    )
+
+    assert backend.physics.color_flows == ()
+    assert isinstance(
+        backend.physics.contracted_color_components[0],
+        ContractedColorComponent,
+    )
+    assert backend.evaluate_resolved([], precision=16).color_ids == ("contracted",)
+    assert backend.physics.selector_capabilities == ("helicity",)
+
+    def fail(*_args: object, **_kwargs: object) -> None:
+        raise _NativeArtifactError("broken artifact")
+
+    backend._runtime.evaluate = fail
+    with pytest.raises(ArtifactError, match="broken artifact"):
+        backend.evaluate([])
diff --git a/pyamplicol/tests/unit/test_runtime_native_selection.py b/pyamplicol/tests/unit/test_runtime_native_selection.py
new file mode 100644
index 0000000000..c49ff6e305
--- /dev/null
+++ b/pyamplicol/tests/unit/test_runtime_native_selection.py
@@ -0,0 +1,290 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from decimal import Decimal
+from fractions import Fraction
+
+import pytest
+
+from pyamplicol.api.errors import ArtifactError
+from pyamplicol.api.results import ResolvedEvaluation
+from pyamplicol.runtime._native_selection import (
+    charge_conjugate_color_id,
+    native_physics_axes,
+    native_process_group_relation,
+    native_process_selection,
+    remap_reduction,
+    representative_vector_to_public,
+)
+from pyamplicol.runtime.backend import _ProcessGroupExactExecutor
+
+
+class _NativeRuntime:
+    def __init__(
+        self,
+        payload: dict[str, object],
+        *,
+        physics: dict[str, object] | None = None,
+    ) -> None:
+        self._payload = payload
+        self._physics = physics
+
+    def _exact_runtime_state_json(self) -> str:
+        return json.dumps(self._payload)
+
+    def physics_json(self) -> str:
+        return json.dumps(self._physics)
+
+
+def _state(**updates: object) -> dict[str, object]:
+    payload: dict[str, object] = {
+        "model_parameter_values": [],
+        "normalization_factor": 1.0,
+        "representative_process_id": "representative",
+        "representative_process_key": "representative-key",
+        "external_permutation": [1, 0, 3, 2],
+    }
+    payload.update(updates)
+    return payload
+
+
+_PROCESSES = (
+    {
+        "id": "representative",
+        "external_pdgs": [2, -2, 23, 21],
+        "aliases": [],
+    },
+)
+
+
+def test_native_selection_is_authoritative_for_inferred_public_expression() -> None:
+    selection = native_process_selection(_NativeRuntime(_state()), _PROCESSES)
+
+    assert selection.process is _PROCESSES[0]
+    assert selection.representative_process_id == "representative"
+    assert selection.representative_process_key == "representative-key"
+    assert selection.external_permutation == (1, 0, 3, 2)
+
+
+@pytest.mark.parametrize(
+    "updates",
+    [
+        {"representative_process_id": "missing"},
+        {"representative_process_key": ""},
+        {"external_permutation": [0, 1, 2]},
+        {"external_permutation": [0, 1, 2, 2]},
+        {"external_permutation": [0, 1, 2, True]},
+    ],
+)
+def test_native_selection_rejects_untrusted_bridge_state(
+    updates: dict[str, object],
+) -> None:
+    with pytest.raises(ArtifactError):
+        native_process_selection(_NativeRuntime(_state(**updates)), _PROCESSES)
+
+
+def test_native_physics_axes_remap_representative_reductions() -> None:
+    representative = {
+        "color_accuracy": "lc",
+        "helicities": [{"id": "h:-1,+1"}, {"id": "h:+1,-1"}],
+        "color_components": [{"id": "flow:1,2"}, {"id": "flow:2,1"}],
+    }
+    public = {
+        "color_accuracy": "lc",
+        "helicities": [{"id": "h:+1,-1"}, {"id": "h:-1,+1"}],
+        "color_components": [{"id": "flow:2,1"}, {"id": "flow:1,2"}],
+    }
+    axes = native_physics_axes(
+        _NativeRuntime(_state(), physics=public), representative
+    )
+
+    assert axes.public_physics == public
+    assert remap_reduction(
+        {
+            "groups": [
+                {
+                    "id": "reduction:0",
+                    "representative_helicity_id": "h:-1,+1",
+                    "representative_color_id": "flow:1,2",
+                    "physical_helicity_ids": ["h:-1,+1", "h:+1,-1"],
+                    "physical_color_ids": ["flow:1,2", "flow:2,1"],
+                }
+            ]
+        },
+        axes,
+    ) == {
+        "groups": [
+            {
+                "id": "reduction:0",
+                "representative_helicity_id": "h:+1,-1",
+                "representative_color_id": "flow:2,1",
+                "physical_helicity_ids": ["h:+1,-1", "h:-1,+1"],
+                "physical_color_ids": ["flow:2,1", "flow:1,2"],
+            }
+        ]
+    }
+    assert representative_vector_to_public((-1, 1), (1, 0)) == (1, -1)
+
+
+def test_native_physics_axes_reject_missing_reduction_selector() -> None:
+    representative = {
+        "color_accuracy": "lc",
+        "helicities": [{"id": "h:-1"}],
+        "color_components": [{"id": "flow:1"}],
+    }
+    public = {
+        "color_accuracy": "lc",
+        "helicities": [{"id": "h:+1"}],
+        "color_components": [{"id": "flow:1"}],
+    }
+    axes = native_physics_axes(
+        _NativeRuntime(_state(), physics=public), representative
+    )
+
+    with pytest.raises(ArtifactError, match="absent from its axis"):
+        remap_reduction(
+            {
+                "groups": [
+                    {
+                        "representative_helicity_id": "h:missing",
+                        "representative_color_id": "flow:1",
+                        "physical_helicity_ids": ["h:-1"],
+                        "physical_color_ids": ["flow:1"],
+                    }
+                ]
+            },
+            axes,
+        )
+
+
+def _particle(index: int, name: str, pdg: int) -> dict[str, object]:
+    return {"index": index, "label": index + 1, "particle": name, "pdg": pdg}
+
+
+def test_process_group_member_physics_returns_to_the_execution_view() -> None:
+    representative = {
+        "color_accuracy": "lc",
+        "external_particles": [
+            _particle(0, "u", 2),
+            _particle(1, "g", 21),
+            _particle(2, "u", 2),
+            _particle(3, "g", 21),
+        ],
+        "helicities": [{"id": "h:+1,+1,+1,+1"}],
+        "color_components": [{"id": "flow:3,2,4,1"}, {"id": "flow:3,4,2,1"}],
+    }
+    public = {
+        "process_id": "ubar_g_to_ubar_g",
+        "color_accuracy": "lc",
+        "external_particles": [
+            _particle(0, "u~", -2),
+            _particle(1, "g", 21),
+            _particle(2, "u~", -2),
+            _particle(3, "g", 21),
+        ],
+        "helicities": [{"id": "h:+1,+1,+1,+1"}],
+        "color_components": [
+            {
+                "kind": "lc-flow",
+                "id": "flow:1,4,2,3",
+                "word": [1, 4, 2, 3],
+                "representative_id": "flow:1,4,2,3",
+            },
+            {
+                "kind": "lc-flow",
+                "id": "flow:1,2,4,3",
+                "word": [1, 2, 4, 3],
+                "representative_id": "flow:1,4,2,3",
+            },
+        ],
+        "reduction": {
+            "groups": [
+                {
+                    "representative_color_id": "flow:1,4,2,3",
+                    "physical_color_ids": ["flow:1,4,2,3", "flow:1,2,4,3"],
+                }
+            ]
+        },
+    }
+    state = _state(
+        external_permutation=[0, 1, 2, 3],
+        process_group_member_of="representative-key",
+        process_group_factor={"numerator": 1, "denominator": 1},
+        charge_conjugated=True,
+    )
+    native = _NativeRuntime(state, physics=public)
+    relation = native_process_group_relation(native)
+    assert relation is not None
+    assert (relation.factor, relation.conjugated) == (Fraction(1), True)
+
+    axes = native_physics_axes(native, representative)
+    execution = axes.public_physics
+    assert [item["pdg"] for item in execution["external_particles"]] == [2, 21, 2, 21]
+    assert [item["id"] for item in execution["color_components"]] == [
+        "flow:3,2,4,1",
+        "flow:3,4,2,1",
+    ]
+    assert execution["color_components"][1]["word"] == [3, 4, 2, 1]
+    assert execution["reduction"]["groups"][0]["physical_color_ids"] == [
+        "flow:3,2,4,1",
+        "flow:3,4,2,1",
+    ]
+    assert axes.color_ids == {
+        "flow:3,2,4,1": "flow:3,2,4,1",
+        "flow:3,4,2,1": "flow:3,4,2,1",
+    }
+    assert public["external_particles"][0]["pdg"] == -2
+    for identifier in ("flow:3,2,4,1", "flow:singlet", "color:contracted"):
+        assert charge_conjugate_color_id(charge_conjugate_color_id(identifier)) == (
+            identifier
+        )
+    assert native_process_group_relation(_NativeRuntime(_state())) is None
+    with pytest.raises(ArtifactError, match="process-group factor"):
+        native_process_group_relation(
+            _NativeRuntime(
+                {
+                    **state,
+                    "process_group_factor": {"numerator": 0, "denominator": 1},
+                }
+            )
+        )
+
+
+class _Executor:
+    def __init__(self) -> None:
+        self.color_flows: object = None
+
+    def evaluate_resolved(
+        self,
+        momenta: object,
+        *,
+        helicities: object,
+        color_flows: object,
+        precision: int,
+    ) -> ResolvedEvaluation:
+        del momenta, helicities, precision
+        self.color_flows = color_flows
+        return ResolvedEvaluation(
+            values=(((Decimal("0.1234567890123456789012345"), Decimal(3)),),),
+            helicity_ids=("h:+1,+1,+1,+1",),
+            color_ids=("flow:3,2,4,1", "flow:3,4,2,1"),
+        )
+
+
+def test_process_group_exact_results_are_scaled_and_relabelled() -> None:
+    inner = _Executor()
+    adapter = _ProcessGroupExactExecutor(inner, Fraction(16, 3), True)
+    result = adapter.evaluate_resolved(
+        (),
+        helicities=None,
+        color_flows=("flow:1,4,2,3",),
+        precision=25,
+    )
+
+    assert inner.color_flows == ("flow:3,2,4,1",)
+    assert result.color_ids == ("flow:1,4,2,3", "flow:1,2,4,3")
+    assert result.values[0][0] == (
+        Decimal("0.6584362080658436208065840"),
+        Decimal(16),
+    )
diff --git a/pyamplicol/tests/unit/test_runtime_selector_profile.py b/pyamplicol/tests/unit/test_runtime_selector_profile.py
new file mode 100644
index 0000000000..449128b286
--- /dev/null
+++ b/pyamplicol/tests/unit/test_runtime_selector_profile.py
@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from tools.developer.runtime_selector_profile import selector_pattern
+
+
+def test_selector_patterns_are_deterministic_stable_grouping_inputs() -> None:
+    selectors = ("a", "b", "c", "d")
+    assert selector_pattern("homogeneous", selectors, 8, seed=7) == ("a",) * 8
+    assert selector_pattern("pre-pooled", selectors, 10, seed=7) == (
+        "a",
+        "a",
+        "a",
+        "b",
+        "b",
+        "b",
+        "c",
+        "c",
+        "d",
+        "d",
+    )
+    assert selector_pattern("alternating", selectors, 8, seed=7) == selectors * 2
+    random_first = selector_pattern("seeded-random", selectors, 32, seed=7)
+    random_second = selector_pattern("seeded-random", selectors, 32, seed=7)
+    assert random_first == random_second
+    assert set(random_first) == set(selectors)
+    assert random_first != selector_pattern("seeded-random", selectors, 32, seed=8)
diff --git a/pyamplicol/tests/unit/test_runtime_validation_momenta.py b/pyamplicol/tests/unit/test_runtime_validation_momenta.py
new file mode 100644
index 0000000000..82f0e9a667
--- /dev/null
+++ b/pyamplicol/tests/unit/test_runtime_validation_momenta.py
@@ -0,0 +1,73 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+import pyamplicol.runtime.backend as backend_module
+from pyamplicol.runtime.backend import RusticolRuntimeBackend
+
+
+class _NativeRuntime:
+    @staticmethod
+    def _exact_runtime_state_json() -> str:
+        return json.dumps(
+            {
+                "model_parameter_values": [],
+                "normalization_factor": 1.0,
+                "representative_process_id": "representative",
+                "representative_process_key": "representative",
+                "external_permutation": [1, 0, 3, 2],
+            }
+        )
+
+
+def test_validation_momenta_uses_native_inferred_process_permutation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    vectors = tuple((float(index), 0.0, 0.0, 0.0) for index in range(4))
+    (tmp_path / "validation.json").write_text(
+        json.dumps(
+            {
+                "available": True,
+                "points": [
+                    [
+                        {"pdg": pdg, "momentum": list(vector)}
+                        for pdg, vector in zip(
+                            (2, -2, 23, 21), vectors, strict=True
+                        )
+                    ]
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+    process = {
+        "id": "representative",
+        "external_pdgs": [2, -2, 23, 21],
+        "aliases": [],
+    }
+    manifest = SimpleNamespace(
+        root=tmp_path,
+        processes=(process,),
+        payloads=(
+            SimpleNamespace(
+                role="validation-momenta",
+                process_id="representative",
+                path="validation.json",
+            ),
+        ),
+    )
+    monkeypatch.setattr(backend_module, "load_manifest", lambda _path: manifest)
+    runtime = object.__new__(RusticolRuntimeBackend)
+    runtime._artifact_path = tmp_path
+    runtime._runtime = _NativeRuntime()
+    runtime._physics = SimpleNamespace(process_id="representative")
+
+    assert runtime.validation_momenta() == (
+        (vectors[1], vectors[0], vectors[3], vectors[2]),
+    )
diff --git a/pyamplicol/tests/unit/test_sdk_config.py b/pyamplicol/tests/unit/test_sdk_config.py
new file mode 100644
index 0000000000..6548b8d1e2
--- /dev/null
+++ b/pyamplicol/tests/unit/test_sdk_config.py
@@ -0,0 +1,245 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import os
+import runpy
+import shlex
+import shutil
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+import pytest
+
+import rusticol_config as config
+
+
+def _sdk(tmp_path: Path) -> Path:
+    root = tmp_path / "installed path with spaces" / "_sdk"
+    (root / "include").mkdir(parents=True)
+    (root / "fortran").mkdir()
+    (root / "lib").mkdir()
+    (root / "rust").mkdir()
+    (root / "include" / "rusticol.h").write_text("", encoding="utf-8")
+    (root / "include" / "rusticol.hpp").write_text("", encoding="utf-8")
+    (root / "fortran" / "rusticol.f90").write_text("", encoding="utf-8")
+    (root / "rust" / "rusticol.rs").write_text("", encoding="utf-8")
+    (root / "lib" / "librusticol_capi.a").write_bytes(b"archive")
+    (root / "metadata.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "abi_version": 1,
+                "version": "0.1.0",
+                "target": "aarch64-apple-darwin",
+                "archive": "lib/librusticol_capi.a",
+                "rust_source": "rust/rusticol.rs",
+            }
+        ),
+        encoding="utf-8",
+    )
+    (root / "link.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "target": "aarch64-apple-darwin",
+                "system_libraries": ["System", "m"],
+                "frameworks": ["Security"],
+            }
+        ),
+        encoding="utf-8",
+    )
+    return root
+
+
+def test_sdk_info_returns_a_complete_native_link_line(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    root = _sdk(tmp_path)
+    monkeypatch.setattr(config, "_resource_root", lambda: root)
+    monkeypatch.setattr(config, "_package_version", lambda: "0.1.0")
+
+    info = config.load_sdk_info()
+    assert info.library == root / "lib" / "librusticol_capi.a"
+    assert info.rust_source == root / "rust" / "rusticol.rs"
+    assert info.link_flags == (
+        str(root / "lib" / "librusticol_capi.a"),
+        "-lSystem",
+        "-lm",
+        "-framework",
+        "Security",
+    )
+    assert info.rust_flags == tuple(
+        token
+        for link_flag in info.link_flags
+        for token in ("-C", f"link-arg={link_flag}")
+    )
+    assert info.to_json()["rust_flags"] == list(info.rust_flags)
+    assert info.to_json()["rust_source"] == str(info.rust_source)
+    assert info.cargo_encoded_rust_flags.split("\x1f") == list(info.rust_flags)
+
+
+def test_rustflags_cli_emits_shell_safe_rustc_arguments(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    root = _sdk(tmp_path)
+    monkeypatch.setattr(config, "_resource_root", lambda: root)
+    monkeypatch.setattr(config, "_package_version", lambda: "0.1.0")
+
+    assert config.main(["--rustflags"]) == 0
+    output = capsys.readouterr().out.strip()
+    assert shlex.split(output) == list(config.load_sdk_info().rust_flags)
+    assert str(root / "lib" / "librusticol_capi.a") in output
+
+    assert config.main(["--rust-source"]) == 0
+    assert capsys.readouterr().out.strip() == str(root / "rust" / "rusticol.rs")
+
+    assert config.main(["--cargo-rustflags"]) == 0
+    encoded = capsys.readouterr().out.rstrip("\n")
+    assert encoded.split("\x1f") == list(config.load_sdk_info().rust_flags)
+
+
+@pytest.mark.parametrize("field", ("archive", "rust_source"))
+def test_sdk_metadata_rejects_path_traversal(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    field: str,
+) -> None:
+    root = _sdk(tmp_path)
+    metadata = json.loads((root / "metadata.json").read_text(encoding="utf-8"))
+    metadata[field] = "../../outside"
+    (root / "metadata.json").write_text(json.dumps(metadata), encoding="utf-8")
+    monkeypatch.setattr(config, "_resource_root", lambda: root)
+    monkeypatch.setattr(config, "_package_version", lambda: "0.1.0")
+
+    with pytest.raises(config.SdkUnavailableError, match="escapes"):
+        config.load_sdk_info()
+
+
+def test_sdk_metadata_requires_exact_version_and_uses_wheel_record_for_integrity(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    root = _sdk(tmp_path)
+    monkeypatch.setattr(config, "_resource_root", lambda: root)
+    monkeypatch.setattr(
+        config,
+        "_package_version",
+        lambda: "0.1.0.dev0+candidate.deadbeef",
+    )
+    with pytest.raises(config.SdkUnavailableError, match="version"):
+        config.load_sdk_info()
+
+    monkeypatch.setattr(config, "_package_version", lambda: "0.1.0")
+    (root / "lib" / "librusticol_capi.a").write_bytes(b"tampered")
+    info = config.load_sdk_info()
+    assert info.library.read_bytes() == b"tampered"
+    metadata = json.loads((root / "metadata.json").read_text(encoding="utf-8"))
+    assert "archive_sha256" not in metadata
+
+
+@pytest.fixture
+def standalone_sdk(tmp_path: Path) -> tuple[Path, dict[str, str]]:
+    """A wheel-shaped SDK whose package initializer must never be executed."""
+    source_root = Path(__file__).resolve().parents[2] / "src"
+    site = tmp_path / "site packages"
+    package = site / "pyamplicol"
+    shutil.copytree(_sdk(tmp_path), package / "_sdk")
+    (package / "__init__.py").write_text(
+        "raise RuntimeError('numerical package initialization is forbidden')\n",
+        encoding="utf-8",
+    )
+    (site / "symbolica.py").write_text(
+        "raise RuntimeError('Symbolica initialization is forbidden')\n",
+        encoding="utf-8",
+    )
+    (package / "_internal").mkdir()
+    shutil.copyfile(
+        source_root / "pyamplicol" / "_internal" / "versions.py",
+        package / "_internal" / "versions.py",
+    )
+    (package / "_build_info.json").write_text(
+        json.dumps({"version": "0.1.0", "publishable": True}),
+        encoding="utf-8",
+    )
+    environment = dict(os.environ)
+    environment["PYTHONPATH"] = os.pathsep.join((str(site), str(source_root)))
+    return package, environment
+
+
+@pytest.mark.parametrize("invocation", ("console", "module"))
+def test_standalone_sdk_query_does_not_initialize_numerical_packages(
+    standalone_sdk: tuple[Path, dict[str, str]], invocation: str
+) -> None:
+    package, environment = standalone_sdk
+    command = (
+        [sys.executable, "-m", "rusticol_config"]
+        if invocation == "module"
+        else [
+            sys.executable,
+            "-c",
+            "import sys; from rusticol_config import main; result = main(); "
+            "assert 'pyamplicol' not in sys.modules; "
+            "assert 'symbolica' not in sys.modules; raise SystemExit(result)",
+        ]
+    )
+    result = subprocess.run(
+        [*command, "--json"],
+        cwd=package.parent,
+        env=environment,
+        capture_output=True,
+        text=True,
+        check=True,
+        timeout=15,
+    )
+    payload = json.loads(result.stdout)
+    assert result.stderr == ""
+    assert payload["package_version"] == "0.1.0"
+    assert payload["library"] == str(package / "_sdk/lib/librusticol_capi.a")
+    assert payload["link_flags"] == [
+        payload["library"],
+        "-lSystem",
+        "-lm",
+        "-framework",
+        "Security",
+    ]
+
+
+def test_standalone_sdk_retains_authoritative_version_validation(
+    standalone_sdk: tuple[Path, dict[str, str]],
+) -> None:
+    package, environment = standalone_sdk
+    (package / "_build_info.json").write_text(
+        json.dumps({"version": None, "publishable": True}), encoding="utf-8"
+    )
+    result = subprocess.run(
+        [sys.executable, "-m", "rusticol_config", "--version"],
+        cwd=package.parent,
+        env=environment,
+        capture_output=True,
+        text=True,
+        timeout=15,
+    )
+    assert result.returncode != 0
+    assert "wheel build version provenance is invalid" in result.stderr
+    assert "initialization is forbidden" not in result.stderr
+
+
+def test_sdk_console_entry_and_package_are_declared() -> None:
+    root = Path(__file__).resolve().parents[2]
+    project = tomllib.loads((root / "pyproject.toml").read_text(encoding="utf-8"))
+    assert project["project"]["scripts"]["rusticol-config"] == "rusticol_config:main"
+    assert "rusticol_config" in project["tool"]["maturin"]["python-packages"]
+
+
+def test_existing_sdk_import_forwards_to_the_same_implementation() -> None:
+    source = Path(__file__).resolve().parents[2] / "src/pyamplicol/_sdk/config.py"
+    compatibility = runpy.run_path(str(source))
+    assert compatibility["main"] is config.main
+    assert compatibility["load_sdk_info"] is config.load_sdk_info
+    assert compatibility["SdkInfo"] is config.SdkInfo
diff --git a/pyamplicol/tests/unit/test_selftest_fixture.py b/pyamplicol/tests/unit/test_selftest_fixture.py
new file mode 100644
index 0000000000..e6126ab61d
--- /dev/null
+++ b/pyamplicol/tests/unit/test_selftest_fixture.py
@@ -0,0 +1,656 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import io
+import json
+import re
+from copy import deepcopy
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools/release/prepare_selftest_fixture.py"
+FIXTURE = ROOT / "src/pyamplicol/assets/selftest/portable-64le"
+ARENA_CAPABILITY = "compiled-plane-arena-v1"
+SOURCE_APPLICATION_ABI = "symjit-application-storage-v3"
+PLANE_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+DIRECT_APPLICATION_ABI = "pyamplicol-compiled-plane-kernel-v2"
+SYMJIT_CAPABILITY = "symjit.application.complex-f64.v1"
+SELFTEST_API_DRIVERS = (
+    Path("python/check_standalone.py"),
+    Path("c/check_standalone.c"),
+    Path("cpp/check_standalone.cpp"),
+    Path("fortran/check_standalone.f90"),
+    Path("rust/check_standalone.rs"),
+)
+
+
+def _module() -> ModuleType:
+    spec = importlib.util.spec_from_file_location("prepare_selftest_fixture", SCRIPT)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _portable_stage(
+    *,
+    amplitude: bool,
+    optimization_level: int = 2,
+) -> dict[str, object]:
+    application_path = (
+        "evaluators/amplitude.symjit" if amplitude else "evaluators/current.symjit"
+    )
+    plane_application_path = application_path.replace(
+        ".symjit",
+        ".plane.symjit",
+    )
+    arena = "amplitude" if amplitude else "current"
+    output_component = 0 if amplitude else 2
+    evaluator = {
+        "kind": "symjit-application-evaluator",
+        "runtime_capability": SYMJIT_CAPABILITY,
+        "application_abi": SOURCE_APPLICATION_ABI,
+        "application_path": application_path,
+        "plane_application": {
+            "application_path": plane_application_path,
+            "application_abi": PLANE_APPLICATION_ABI,
+            "storage_abi": SOURCE_APPLICATION_ABI,
+            "element_layout": "split-complex-plane-major",
+            "descriptor_order": "inputs-re-im-then-outputs-re-im",
+            "input_complex_count": 1,
+            "output_complex_count": 1,
+            "input_plane_count": 2,
+            "output_plane_count": 2,
+            "compiler_type": "native",
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": optimization_level,
+            "simd": True,
+            "complex": True,
+            "fast_math": True,
+            "fast_complex": False,
+            "compression": False,
+            "threading": False,
+            "direct_arena": True,
+            "source_digest": hashlib.sha256(
+                f"instructions:{arena}".encode()
+            ).hexdigest(),
+            "target": {"word_bits": 64, "endianness": "little"},
+        },
+        "compiler_type": "native",
+        "translation_mode": "indirect",
+        "optimization_level": optimization_level,
+        "element_layout": "complex-f64",
+        "batch_layout": "row-major",
+        "input_len": 1,
+        "output_len": 1,
+    }
+    input_component = {
+        "parameter_index": 0,
+        "kind": "value",
+        "source_id": 0,
+        "component": 0,
+        "global_component": 0,
+        "real_valued": False,
+    }
+    output_slot = {
+        "output_start": 0,
+        "output_stop": 1,
+        "component_start": output_component,
+        "component_stop": output_component + 1,
+    }
+    return {
+        "stage_kind": "amplitude-roots" if amplitude else "current-combine",
+        "parameter_layout": "stage-local-value-momentum",
+        "parameter_count": 1,
+        "output_length": 1,
+        "input_components": [input_component],
+        "output_slots": [output_slot],
+        "evaluator": evaluator,
+        "compiled_plane_arena": {
+            "schema_version": 1,
+            "kind": "compiled-plane-arena-stage",
+            "application_abi": DIRECT_APPLICATION_ABI,
+            "source_application_abi": PLANE_APPLICATION_ABI,
+            "element_layout": "split-complex-component-major",
+            "output_operation": "overwrite",
+            "output_factor": "identity",
+            "input_output_aliasing": "forbidden",
+            "output_output_aliasing": "forbidden",
+            "input_bindings": [input_component],
+            "output_bindings": [
+                {
+                    "output_index": 0,
+                    "arena": arena,
+                    "component": output_component,
+                }
+            ],
+            "leaves": [
+                {
+                    "application_path": plane_application_path,
+                    "source_application_abi": PLANE_APPLICATION_ABI,
+                    "optimization_level": optimization_level,
+                    "direct_codegen_optimization_level": optimization_level,
+                    "input_len": 1,
+                    "output_len": 1,
+                    "input_indices": [0],
+                    "output_start": 0,
+                    "output_stop": 1,
+                }
+            ],
+        },
+    }
+
+
+def _portable_execution(
+    *,
+    optimization_level: int = 2,
+) -> dict[str, object]:
+    return {
+        "required_runtime_capabilities": [
+            ARENA_CAPABILITY,
+            SYMJIT_CAPABILITY,
+        ],
+        "compiled": {
+            "kind": "generic-dag-stage-blueprint",
+            "stage_evaluators": {
+                "kind": "generic-dag-stage-evaluator-artifacts",
+                "required_runtime_capabilities": [
+                    ARENA_CAPABILITY,
+                    SYMJIT_CAPABILITY,
+                ],
+                "stage_count": 2,
+                "stages": [
+                    _portable_stage(
+                        amplitude=False,
+                        optimization_level=optimization_level,
+                    )
+                ],
+                "amplitude_stage": _portable_stage(
+                    amplitude=True,
+                    optimization_level=optimization_level,
+                ),
+            },
+        },
+    }
+
+
+def _portable_artifact_manifest() -> dict[str, object]:
+    capabilities = [ARENA_CAPABILITY, SYMJIT_CAPABILITY]
+    return {
+        "runtime": {"required_runtime_capabilities": list(capabilities)},
+        "processes": [
+            {"required_runtime_capabilities": list(capabilities)},
+        ],
+    }
+
+
+def _write_portable_execution(
+    tmp_path: Path,
+    execution: dict[str, object],
+) -> dict[str, object]:
+    relative = Path("processes/example/execution.json")
+    execution_path = tmp_path / relative
+    execution_path.parent.mkdir(parents=True)
+    execution_path.write_text(json.dumps(execution), encoding="utf-8")
+    return {
+        "payloads": [
+            {
+                "role": "evaluator-manifest",
+                "path": relative.as_posix(),
+            }
+        ]
+    }
+
+
+def test_resolved_reduction_accepts_floating_point_roundoff() -> None:
+    module = _module()
+
+    assert module._complex_sequences_close(
+        [0.3298449642209169 + 0j],
+        [0.32984496422091686 + 0j],
+    )
+    assert not module._complex_sequences_close([1.0 + 0j], [1.001 + 0j])
+    assert not module._complex_sequences_close([1.0 + 0j], [])
+
+
+def test_generation_output_sanitizer_accepts_programmatic_config() -> None:
+    module = _module()
+
+    programmatic = '[generation]\nmode = "error"\n'
+    assert module._sanitize_generation_output(programmatic, "x") == programmatic
+    assert (
+        module._sanitize_generation_output(
+            '[generation]\noutput = "/private/tmp/build"\n', "x"
+        )
+        == '[generation]\noutput = "."\n'
+    )
+
+
+def test_generation_output_sanitizer_rejects_ambiguous_config() -> None:
+    module = _module()
+
+    text = 'output = "/first"\noutput = "/second"\n'
+    with pytest.raises(RuntimeError, match="multiple generation outputs"):
+        module._sanitize_generation_output(text, "configuration-effective")
+
+
+def test_portable_manifest_retargeting_rewrites_every_target_tag() -> None:
+    module = _module()
+    manifest = {
+        "producer": {
+            "target": {"triple": "aarch64-apple-darwin", "cpu_features": ["x"]}
+        },
+        "payloads": [
+            {"path": "metadata.json"},
+            {
+                "path": "stage.symjit",
+                "target": {
+                    "triple": "aarch64-apple-darwin",
+                    "cpu_features": ["neon"],
+                },
+            },
+        ],
+    }
+
+    module._retarget_portable_manifest(
+        manifest,
+        source_target="aarch64-apple-darwin",
+    )
+
+    expected_target = {"triple": "portable-64le", "cpu_features": []}
+    assert manifest["producer"]["target"] == expected_target
+    assert manifest["payloads"][1]["target"] == expected_target
+
+
+def test_source_selftest_fixture_is_one_portable_64bit_template() -> None:
+    module = _module()
+    expected = json.loads((FIXTURE / "expected.json").read_text(encoding="utf-8"))
+    manifest = json.loads(
+        (FIXTURE / "artifact/artifact.json").read_text(encoding="utf-8")
+    )
+
+    assert expected["target"] == module.PORTABLE_TEMPLATE
+    assert expected["compatible_targets"] == list(module.COMPATIBLE_TARGETS)
+    assert expected["serialization"] == {
+        "endianness": "little",
+        "kind": "symjit-application-mir-v3",
+        "load_behavior": "recompile-mir-for-loading-host",
+        "source_optimization_level": 2,
+        "word_size_bits": 64,
+    }
+    assert manifest["producer"]["target"] == {
+        "cpu_features": [],
+        "triple": module.PORTABLE_TEMPLATE,
+    }
+    assert (
+        manifest["extensions"]["artifact_identity"] == module.ARTIFACT_IDENTITY_CONTRACT
+    )
+    assert {
+        payload["target"]["triple"]
+        for payload in manifest["payloads"]
+        if "target" in payload
+    } == {module.PORTABLE_TEMPLATE}
+    assert manifest["artifact_id"] == module._artifact_id(manifest)
+    assert (
+        module.validate_portable_artifact_capabilities(
+            manifest,
+            context="tracked portable self-test artifact",
+        )
+        > 0
+    )
+    assert (
+        module._validate_portable_evaluator_configuration(
+            FIXTURE / "artifact",
+            manifest,
+        )
+        > 0
+    )
+
+
+def test_selftest_api_drivers_match_the_public_templates() -> None:
+    template_root = ROOT / "src/pyamplicol/assets/api_templates"
+    artifact = FIXTURE / "artifact"
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    payloads = {
+        payload["path"]: payload
+        for payload in manifest["payloads"]
+        if payload.get("role") == "api-source"
+    }
+    for relative in SELFTEST_API_DRIVERS:
+        expected = (template_root / relative).read_bytes()
+        artifact_relative = Path("API") / relative
+        actual = (artifact / artifact_relative).read_bytes()
+        payload = payloads[artifact_relative.as_posix()]
+
+        assert actual == expected
+        assert payload["size_bytes"] == len(actual)
+        assert payload["sha256"] == hashlib.sha256(actual).hexdigest()
+
+
+@pytest.mark.parametrize("optimization_level", (0, 1, 3))
+def test_portable_fixture_requires_its_canonical_o2_optimization_level(
+    tmp_path: Path,
+    optimization_level: int,
+) -> None:
+    module = _module()
+    manifest = _write_portable_execution(
+        tmp_path,
+        _portable_execution(optimization_level=optimization_level),
+    )
+
+    with pytest.raises(RuntimeError, match="optimization level 2"):
+        module._validate_portable_evaluator_configuration(tmp_path, manifest)
+
+
+def test_portable_fixture_accepts_portable_o2_mir(tmp_path: Path) -> None:
+    module = _module()
+    manifest = _write_portable_execution(tmp_path, _portable_execution())
+
+    assert module._validate_portable_evaluator_configuration(tmp_path, manifest) == 2
+
+
+@pytest.mark.parametrize("capability_owner", ("execution", "stage_evaluators"))
+@pytest.mark.parametrize(
+    "capability",
+    (ARENA_CAPABILITY, SYMJIT_CAPABILITY),
+)
+def test_portable_fixture_requires_compiled_runtime_capabilities(
+    tmp_path: Path,
+    capability_owner: str,
+    capability: str,
+) -> None:
+    module = _module()
+    execution = _portable_execution()
+    if capability_owner == "execution":
+        capabilities = execution["required_runtime_capabilities"]
+    else:
+        capabilities = execution["compiled"]["stage_evaluators"][
+            "required_runtime_capabilities"
+        ]
+    capabilities.remove(capability)
+    manifest = _write_portable_execution(tmp_path, execution)
+
+    with pytest.raises(RuntimeError, match=rf"must require {re.escape(capability)}"):
+        module._validate_portable_evaluator_configuration(tmp_path, manifest)
+
+
+@pytest.mark.parametrize("capability_owner", ("artifact_runtime", "process"))
+@pytest.mark.parametrize(
+    "capability",
+    (ARENA_CAPABILITY, SYMJIT_CAPABILITY),
+)
+def test_portable_fixture_requires_outer_runtime_capabilities(
+    capability_owner: str,
+    capability: str,
+) -> None:
+    module = _module()
+    manifest = _portable_artifact_manifest()
+    owner = (
+        manifest["runtime"]
+        if capability_owner == "artifact_runtime"
+        else manifest["processes"][0]
+    )
+    owner["required_runtime_capabilities"].remove(capability)
+
+    with pytest.raises(RuntimeError, match=rf"must require {re.escape(capability)}"):
+        module.validate_portable_artifact_capabilities(
+            manifest,
+            context="portable artifact",
+        )
+
+
+@pytest.mark.parametrize("stage_kind", ("current", "amplitude"))
+def test_portable_fixture_requires_every_arena_stage_descriptor(
+    tmp_path: Path,
+    stage_kind: str,
+) -> None:
+    module = _module()
+    execution = _portable_execution()
+    stage_set = execution["compiled"]["stage_evaluators"]
+    stage = (
+        stage_set["stages"][0]
+        if stage_kind == "current"
+        else stage_set["amplitude_stage"]
+    )
+    del stage["compiled_plane_arena"]
+    manifest = _write_portable_execution(tmp_path, execution)
+
+    with pytest.raises(RuntimeError, match="complete compiled_plane_arena"):
+        module._validate_portable_evaluator_configuration(tmp_path, manifest)
+
+
+def test_portable_fixture_rejects_incomplete_arena_bindings(tmp_path: Path) -> None:
+    module = _module()
+    execution = _portable_execution()
+    descriptor = execution["compiled"]["stage_evaluators"]["stages"][0][
+        "compiled_plane_arena"
+    ]
+    descriptor["input_bindings"] = []
+    manifest = _write_portable_execution(tmp_path, execution)
+
+    with pytest.raises(RuntimeError, match="input bindings are incomplete"):
+        module._validate_portable_evaluator_configuration(tmp_path, manifest)
+
+
+def test_portable_fixture_requires_plane_codegen_optimization_match(
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    execution = _portable_execution()
+    descriptor = execution["compiled"]["stage_evaluators"]["amplitude_stage"][
+        "compiled_plane_arena"
+    ]
+    descriptor["leaves"][0]["direct_codegen_optimization_level"] = 3
+    manifest = _write_portable_execution(tmp_path, execution)
+
+    with pytest.raises(RuntimeError, match=r"direct codegen optimization.*plane"):
+        module._validate_portable_evaluator_configuration(tmp_path, manifest)
+
+
+def test_portable_fixture_binds_arena_leaf_to_o2_source(tmp_path: Path) -> None:
+    module = _module()
+    execution = _portable_execution()
+    descriptor = execution["compiled"]["stage_evaluators"]["stages"][0][
+        "compiled_plane_arena"
+    ]
+    descriptor["leaves"][0]["application_path"] = "evaluators/drift.symjit"
+    manifest = _write_portable_execution(tmp_path, execution)
+
+    with pytest.raises(RuntimeError, match="does not bind its SymJIT source"):
+        module._validate_portable_evaluator_configuration(tmp_path, manifest)
+
+
+def test_portable_fixture_validates_nested_selector_executions(
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    execution = _portable_execution()
+    nested = deepcopy(execution)
+    descriptor = nested["compiled"]["stage_evaluators"]["amplitude_stage"][
+        "compiled_plane_arena"
+    ]
+    descriptor["leaves"][0]["direct_codegen_optimization_level"] = 3
+    execution["helicity_sum_execution"] = nested
+    manifest = _write_portable_execution(tmp_path, execution)
+
+    with pytest.raises(RuntimeError, match=r"direct codegen optimization.*plane"):
+        module._validate_portable_evaluator_configuration(tmp_path, manifest)
+
+
+def test_compiled_model_version_normalization_refreshes_payload(
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    artifact = tmp_path / "artifact"
+    compiled_path = artifact / "model" / "compiled-model.json"
+    compiled_path.parent.mkdir(parents=True)
+    compiled_path.write_text(
+        json.dumps({"producer": {"pyamplicol": "old"}}),
+        encoding="utf-8",
+    )
+    manifest = {
+        "payloads": [
+            {
+                "path": "model/compiled-model.json",
+                "role": "compiled-model",
+                "sha256": "stale",
+                "size_bytes": 0,
+            }
+        ]
+    }
+
+    module._normalize_compiled_model_version(
+        artifact,
+        manifest,
+        version="0.1.0.dev0+candidate.test",
+    )
+
+    data = compiled_path.read_bytes()
+    compiled = json.loads(data)
+    payload = manifest["payloads"][0]
+    assert compiled["producer"]["pyamplicol"] == "0.1.0.dev0+candidate.test"
+    assert payload["sha256"] == hashlib.sha256(data).hexdigest()
+    assert payload["size_bytes"] == len(data)
+
+
+def test_symbolica_fallback_stripping_rewrites_packed_container(
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    from pyamplicol.generation.evaluator_container import (
+        PacbinMemberKind,
+        PacbinMemberSource,
+        PacbinReader,
+        write_pacbin_atomic,
+    )
+
+    artifact = tmp_path / "artifact"
+    execution_path = artifact / "processes/example/execution.json"
+    execution_path.parent.mkdir(parents=True)
+    execution_path.write_text(
+        json.dumps(
+            {
+                "compiled": {
+                    "evaluator": {
+                        "kind": "symjit-application-evaluator",
+                        "evaluator_state_path": "chunk.evaluator.bin",
+                        "evaluator_state_runtime_capability": "symbolica",
+                    }
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+    container_path = artifact / "evaluators.pacbin"
+    index = write_pacbin_atomic(
+        container_path,
+        (
+            PacbinMemberSource(
+                "processes/example/chunk.evaluator.bin",
+                PacbinMemberKind.SYMBOLICA_EXACT_STATE,
+                io.BytesIO(b"exact"),
+            ),
+            PacbinMemberSource(
+                "processes/example/chunk.symjit",
+                PacbinMemberKind.SYMJIT_APPLICATION,
+                io.BytesIO(b"runtime"),
+            ),
+        ),
+    )
+    manifest = {
+        "extensions": {
+            "evaluator_payload_container": {
+                "path": "evaluators.pacbin",
+                "member_count": 2,
+                "unpacked_size_bytes": 12,
+                "index_sha256": index.index_sha256,
+            }
+        },
+        "payloads": [
+            {
+                "path": "processes/example/execution.json",
+                "role": "evaluator-manifest",
+                "sha256": "stale",
+                "size_bytes": 0,
+            },
+            {
+                "path": "evaluators.pacbin",
+                "role": "evaluator-state",
+                "sha256": "stale",
+                "size_bytes": 0,
+            },
+        ],
+    }
+
+    module._strip_symbolica_fallbacks(artifact, manifest)
+
+    execution = json.loads(execution_path.read_text(encoding="utf-8"))
+    evaluator = execution["compiled"]["evaluator"]
+    assert evaluator["evaluator_state_path"] is None
+    assert evaluator["evaluator_state_runtime_capability"] is None
+    with PacbinReader.open(container_path) as reader:
+        assert [member.logical_path for member in reader.members] == [
+            "processes/example/chunk.symjit"
+        ]
+        extension = manifest["extensions"]["evaluator_payload_container"]
+        assert extension["member_count"] == 1
+        assert extension["unpacked_size_bytes"] == len(b"runtime")
+        assert extension["index_sha256"] == reader.index.index_sha256
+    payload = next(
+        payload
+        for payload in manifest["payloads"]
+        if payload["path"] == "evaluators.pacbin"
+    )
+    assert payload["sha256"] == hashlib.sha256(container_path.read_bytes()).hexdigest()
+    assert payload["size_bytes"] == container_path.stat().st_size
+
+
+def test_source_selftest_compiled_model_matches_active_compiler_sources() -> None:
+    module = _module()
+    manifest = json.loads(
+        (FIXTURE / "artifact/artifact.json").read_text(encoding="utf-8")
+    )
+    _payload, relative = module._compiled_model_payload(manifest)
+    compiled = json.loads((FIXTURE / "artifact" / relative).read_text(encoding="utf-8"))
+
+    from pyamplicol.models import loading
+
+    expected_producer = loading.compiler_fingerprint()
+    actual_producer = dict(compiled["producer"])
+    # The portable source template is retargeted to the concrete candidate or
+    # release version by the wheel overlay. The full compiler-source hash is
+    # provenance rather than a compatibility boundary, just as it is for the
+    # packaged prepared-model store.
+    for provenance_field in ("pyamplicol", "model_compiler_sha256"):
+        expected_producer.pop(provenance_field)
+        actual_producer.pop(provenance_field)
+
+    assert compiled["kind"] == loading.COMPILED_MODEL_KIND
+    assert compiled["schema_version"] == loading.COMPILED_MODEL_SCHEMA_VERSION
+    assert compiled["model_compiler_version"] == loading.MODEL_COMPILER_VERSION
+    assert actual_producer == expected_producer
+    assert compiled["source"]["digest"] == loading._source_digest(
+        "built-in-sm",
+        "built-in-sm",
+    )
+
+
+def test_staged_selftest_fixture_loads_with_the_current_native_runtime() -> None:
+    native = pytest.importorskip("pyamplicol._rusticol")
+    from pyamplicol import Runtime
+
+    fixture = FIXTURE.parent / str(native.target_info().triple)
+    if not fixture.is_dir():
+        pytest.skip("the source runtime has not staged its target self-test fixture")
+    expected = json.loads((fixture / "expected.json").read_text(encoding="utf-8"))
+    runtime = Runtime.load(fixture / expected["artifact_path"], mute_warnings=True)
+
+    total = runtime.evaluate(expected["momenta"])
+    expected_total = [complex(real, imag) for real, imag in expected["total"]]
+
+    assert total == pytest.approx(expected_total, rel=1.0e-12, abs=1.0e-15)
diff --git a/pyamplicol/tests/unit/test_sm_heft_model.py b/pyamplicol/tests/unit/test_sm_heft_model.py
new file mode 100644
index 0000000000..c53e0e2bba
--- /dev/null
+++ b/pyamplicol/tests/unit/test_sm_heft_model.py
@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+
+import pytest
+
+from pyamplicol import CompiledModel, ModelSource
+from pyamplicol._internal.sm_heft import (
+    CANONICAL_SM_HEFT_SOURCE,
+    SM_HEFT_ALIASES,
+    extend_sm_model_payload,
+    packaged_sm_source_path,
+)
+from pyamplicol.api.models import _compiled_model_payload
+
+
+@pytest.fixture(scope="module")
+def compiled_sm_heft() -> CompiledModel:
+    return ModelSource.built_in_sm_heft().compile(use_cache=False)
+
+
+def _named_records(
+    payload: Mapping[str, object], field: str
+) -> dict[str, Mapping[str, object]]:
+    records = payload[field]
+    assert isinstance(records, list)
+    return {
+        str(record["name"]): record for record in records if isinstance(record, Mapping)
+    }
+
+
+def test_packaged_sm_heft_has_canonical_aliases() -> None:
+    assert CANONICAL_SM_HEFT_SOURCE in SM_HEFT_ALIASES
+
+
+def test_sm_heft_extension_is_independent_and_has_constant_coupling() -> None:
+    base = json.loads(packaged_sm_source_path().read_text(encoding="utf-8"))
+    extended = extend_sm_model_payload(base)
+
+    assert extended is not base
+    assert extended["name"] == CANONICAL_SM_HEFT_SOURCE
+    assert "GH" not in _named_records(base, "parameters")
+    assert not any(
+        name.startswith("V_HEFT") for name in _named_records(base, "vertex_rules")
+    )
+
+    parameters = _named_records(extended, "parameters")
+    couplings = _named_records(extended, "couplings")
+    gh_expression = str(parameters["GH"]["expression"])
+    assert "P(" not in gh_expression
+    assert "Momentum(" not in gh_expression
+    assert {name for name in couplings if name.startswith("GC_HEFT_")} == {
+        "GC_HEFT_HGG",
+        "GC_HEFT_HGGG",
+        "GC_HEFT_HGGGG",
+    }
+    assert all(
+        "P(" not in str(couplings[name]["expression"])
+        for name in ("GC_HEFT_HGG", "GC_HEFT_HGGG", "GC_HEFT_HGGGG")
+    )
+
+
+def test_compiled_sm_heft_contains_all_scalar_gluon_vertices(
+    compiled_sm_heft: CompiledModel,
+) -> None:
+    private = _compiled_model_payload(compiled_sm_heft)
+    heft_terms = tuple(
+        term for term in private.ir.vertex_terms if term.vertex.startswith("V_HEFT_")
+    )
+
+    assert compiled_sm_heft.name == CANONICAL_SM_HEFT_SOURCE
+    assert compiled_sm_heft.source.kind == "built-in-sm-heft"
+    assert compiled_sm_heft.supported
+    assert compiled_sm_heft.capabilities.form_factor_count == 0
+    assert compiled_sm_heft.capabilities.maximum_valence == 5
+    observed_terms = [
+        (term.vertex, term.color_index, term.lorentz_index) for term in heft_terms
+    ]
+    assert observed_terms == [
+        ("V_HEFT_HGG", 0, 0),
+        ("V_HEFT_HGGG", 0, 0),
+        ("V_HEFT_HGGGG", 0, 0),
+        ("V_HEFT_HGGGG", 1, 1),
+        ("V_HEFT_HGGGG", 2, 2),
+    ]
+    contact_ids = {term.id for term in heft_terms if len(term.particles) > 3}
+    lowered_ids = {
+        term_id
+        for kernel in private.ir.oriented_kernels
+        if "::contact-" in kernel.vertex and "final" in kernel.vertex
+        for term_id in (kernel.term_ids or (kernel.term_id,))
+    }
+    assert contact_ids <= lowered_ids
+
+
+def test_sm_heft_extension_rejects_record_collisions() -> None:
+    base = json.loads(packaged_sm_source_path().read_text(encoding="utf-8"))
+    base["parameters"].append({"name": "GH"})
+
+    with pytest.raises(ValueError, match="already defines HEFT parameters"):
+        extend_sm_model_payload(base)
diff --git a/pyamplicol/tests/unit/test_source_runtime.py b/pyamplicol/tests/unit/test_source_runtime.py
new file mode 100644
index 0000000000..d29692b410
--- /dev/null
+++ b/pyamplicol/tests/unit/test_source_runtime.py
@@ -0,0 +1,1298 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import platform
+import sys
+import tomllib
+import zipfile
+from contextlib import nullcontext
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools" / "developer" / "prepare_source_runtime.py"
+
+_VERSIONS_SPEC = importlib.util.spec_from_file_location(
+    "source_runtime_versions",
+    ROOT / "src/pyamplicol/_internal/versions.py",
+)
+assert _VERSIONS_SPEC is not None and _VERSIONS_SPEC.loader is not None
+versions = importlib.util.module_from_spec(_VERSIONS_SPEC)
+sys.modules[_VERSIONS_SPEC.name] = versions
+_VERSIONS_SPEC.loader.exec_module(versions)
+
+
+def _module():
+    spec = importlib.util.spec_from_file_location("prepare_source_runtime", SCRIPT)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _native_build_identity_module():
+    spec = importlib.util.spec_from_file_location(
+        "source_runtime_native_build_identity",
+        ROOT / "build_backend/native_build_identity.py",
+    )
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _source_root(tmp_path: Path) -> Path:
+    root = tmp_path / "source"
+    source = root / "rust/crates/example/src/lib.rs"
+    source.parent.mkdir(parents=True)
+    source.write_text("pub fn value() -> u32 { 1 }\n", encoding="utf-8")
+    (root / "pyproject.toml").write_bytes((ROOT / "pyproject.toml").read_bytes())
+    (root / "src/pyamplicol").mkdir(parents=True)
+    return root
+
+
+def _write_candidate_native_inputs(
+    root: Path,
+    *,
+    checkout_root: Path | None = None,
+    include_legacy: bool = False,
+) -> Path:
+    dependencies = root / "dependencies"
+    dependencies.mkdir(exist_ok=True)
+    checkout_root = checkout_root or dependencies / "checkouts"
+    config = dependencies / "candidate-cargo-config.toml"
+    config.write_text(
+        "# generated location is deliberately volatile\n"
+        "[patch.crates-io]\n"
+        f'graphica = {{ path = "{checkout_root / "symbolica/lib/graphica"}" }}\n'
+        f'numerica = {{ path = "{checkout_root / "symbolica/lib/numerica"}" }}\n'
+        f'symbolica = {{ path = "{checkout_root / "symbolica"}" }}\n'
+        f'symjit = {{ path = "{checkout_root / "symjit"}" }}\n',
+        encoding="utf-8",
+    )
+    lock_paths = {
+        "candidate": dependencies / "candidate-Cargo.lock",
+        "contributor": dependencies / "contributor-lock.toml",
+        "python-runtime": dependencies / "python-runtime-lock.toml",
+        "release": dependencies / "release-lock.toml",
+    }
+    for index, path in enumerate(lock_paths.values()):
+        path.write_text(f"lock {index}\n", encoding="utf-8")
+    sources: dict[str, dict[str, str]] = {
+        "gammaloop": {
+            "revision": "1" * 40,
+            "url": "https://example.invalid/gammaloop.git",
+        },
+        "ratatui-ffi": {
+            "revision": "5" * 40,
+            "url": "https://example.invalid/ratatui-ffi.git",
+        },
+        "symbolica": {
+            "revision": "2" * 40,
+            "url": "https://example.invalid/symbolica.git",
+        },
+        "symbolica-community": {
+            "revision": "3" * 40,
+            "url": "https://example.invalid/symbolica-community.git",
+        },
+        "symjit": {
+            "revision": "4" * 40,
+            "url": "https://example.invalid/symjit-crate.git",
+        },
+    }
+    if include_legacy:
+        sources["legacy-amplicol"] = {
+            "branch": "historical",
+            "revision": "7" * 40,
+            "url": "https://example.invalid/AmpliCol.git",
+        }
+    lock_paths["contributor"].write_text(
+        "schema_version = 1\n",
+        encoding="utf-8",
+    )
+    state = {
+        "publishable": False,
+        "schema_version": 1,
+        "sources": sources,
+    }
+    state_path = dependencies / "install-state.json"
+    state_path.write_text(
+        json.dumps(state, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    return state_path
+
+
+def _wheel(
+    path: Path,
+    *,
+    native_build_inputs_sha256: str,
+    mode: str = "candidate",
+    target: str | None = None,
+) -> None:
+    if target is None:
+        machine = platform.machine().lower()
+        if sys.platform == "darwin" and machine in {"arm64", "aarch64"}:
+            target = "aarch64-apple-darwin"
+        elif sys.platform == "darwin" and machine in {"amd64", "x86_64"}:
+            target = "x86_64-apple-darwin"
+        else:
+            target = "x86_64-unknown-linux-gnu"
+    assert mode in {"candidate", "release"}
+    version = "0.1.0.dev0+candidate.testsource" if mode == "candidate" else "0.1.0"
+    with zipfile.ZipFile(path, "w") as archive:
+        archive.writestr(
+            f"pyamplicol-{version}.dist-info/METADATA",
+            f"Metadata-Version: 2.4\nName: pyamplicol\nVersion: {version}\n\n",
+        )
+        archive.writestr("pyamplicol/_rusticol.abi3.so", b"extension")
+        if mode == "candidate":
+            archive.writestr(
+                "pyamplicol/_build_info.json",
+                json.dumps(
+                    {
+                        "schema_version": 1,
+                        "publishable": False,
+                        "native_build_inputs_sha256": native_build_inputs_sha256,
+                        "source_checkout": "/candidate/source",
+                        "version": version,
+                    }
+                ),
+            )
+        archive.writestr(
+            "pyamplicol/_sdk/metadata.json",
+            json.dumps({"target": target}),
+        )
+        archive.writestr("pyamplicol/_sdk/link.json", "{}\n")
+        archive.writestr("pyamplicol/_sdk/lib/librusticol_capi.a", b"archive")
+        archive.writestr("pyamplicol/_sdk/include/rusticol.h", "/* header */\n")
+        archive.writestr("pyamplicol/_sdk/fortran/rusticol.f90", "module r\n")
+        archive.writestr(
+            f"pyamplicol/assets/selftest/{target}/expected.json",
+            "{}\n",
+        )
+        archive.writestr(
+            f"pyamplicol/assets/selftest/{target}/artifact/artifact.json",
+            "{}\n",
+        )
+        driver = zipfile.ZipInfo(
+            f"pyamplicol/assets/selftest/{target}/artifact/API/python/"
+            "check_standalone.py"
+        )
+        driver.external_attr = 0o100755 << 16
+        archive.writestr(driver, "#!/usr/bin/env python3\n")
+        archive.writestr("README.md", "must not be staged\n")
+        archive.writestr("pyamplicol/_sdk/config.py", "must not overwrite source\n")
+
+
+def test_source_runtime_stages_one_attested_extension(tmp_path: Path) -> None:
+    module = _module()
+    source_root = _source_root(tmp_path)
+    native_digest = module._native_build_inputs_digest(source_root)
+    wheel = tmp_path / "pyamplicol-test.whl"
+    _wheel(wheel, native_build_inputs_sha256=native_digest)
+    package = source_root / "src/pyamplicol"
+    build_info = source_root / ".artifacts/source-runtime/_build_info.json"
+    stale_extension = package / "_rusticol.cpython-312-darwin.so"
+    stale_extension.write_bytes(b"stale")
+    tracked_config = package / "_sdk/config.py"
+    tracked_config.parent.mkdir()
+    tracked_config.write_text("tracked\n", encoding="utf-8")
+
+    report = module.stage_runtime(
+        wheel,
+        source_package=package,
+        source_build_info=build_info,
+        source_root=source_root,
+        mode="candidate",
+        audit=False,
+    )
+
+    assert report["version"] == "0.1.0.dev0+candidate.testsource"
+    extension = package / "_rusticol.abi3.so"
+    assert extension.read_bytes() == b"extension"
+    assert not stale_extension.exists()
+    assert tracked_config.read_text(encoding="utf-8") == "tracked\n"
+    payload = json.loads(build_info.read_text(encoding="utf-8"))
+    assert payload["source_runtime"] == {
+        "extension_name": extension.name,
+        "extension_sha256": hashlib.sha256(b"extension").hexdigest(),
+        "mode": "candidate",
+        "native_build_inputs_sha256": native_digest,
+    }
+    assert not (build_info.parent / ".staging").exists()
+
+
+@pytest.mark.parametrize(
+    ("mode", "bootstrap", "publishable", "release_bootstrap", "failure"),
+    (
+        ("candidate", True, False, False, None),
+        ("candidate", False, False, False, "no self-test fixture"),
+        ("candidate", True, True, False, "not marked candidate"),
+        ("release", True, True, False, "no self-test fixture"),
+        ("release", False, True, False, "no self-test fixture"),
+        ("release", True, False, True, None),
+    ),
+)
+def test_source_runtime_allows_missing_fixture_only_for_nonpublishable_bootstrap(
+    tmp_path: Path,
+    mode: str,
+    bootstrap: bool,
+    publishable: bool,
+    release_bootstrap: bool,
+    failure: str | None,
+) -> None:
+    module = _module()
+    source_root = _source_root(tmp_path)
+    native_digest = module._native_build_inputs_digest(
+        source_root, normalize_release_cargo_lock=mode == "release"
+    )
+    wheel = tmp_path / "pyamplicol-bootstrap.whl"
+    _wheel(wheel, native_build_inputs_sha256=native_digest, mode=mode)
+    with zipfile.ZipFile(wheel) as archive:
+        members = {
+            info.filename: archive.read(info)
+            for info in archive.infolist()
+            if not info.filename.startswith("pyamplicol/assets/selftest/")
+        }
+    build_info_name = "pyamplicol/_build_info.json"
+    payload = json.loads(members.get(build_info_name, b'{"version": "0.1.0"}'))
+    payload.update(publishable=publishable, selftest_fixture_bootstrap=bootstrap)
+    if release_bootstrap:
+        payload["release_prepared_model_bootstrap"] = True
+    members[build_info_name] = json.dumps(payload).encode()
+    with zipfile.ZipFile(wheel, "w") as archive:
+        for name, content in members.items():
+            archive.writestr(name, content)
+    package = source_root / "src/pyamplicol"
+    build_info = source_root / ".artifacts/source-runtime/_build_info.json"
+    kwargs = {
+        "source_package": package,
+        "source_build_info": build_info,
+        "source_root": source_root,
+        "mode": mode,
+        "audit": False,
+    }
+
+    if failure is not None:
+        with pytest.raises(module.ReleaseError, match=failure):
+            module.stage_runtime(wheel, **kwargs)
+        return
+
+    module.stage_runtime(wheel, **kwargs)
+    assert (package / "_rusticol.abi3.so").read_bytes() == b"extension"
+    assert (package / "_sdk/lib/librusticol_capi.a").read_bytes() == b"archive"
+    assert not (package / "assets/selftest").exists()
+    staged = json.loads(build_info.read_text())
+    assert staged["selftest_fixture_bootstrap"] is True
+    if release_bootstrap:
+        assert staged["publishable"] is False
+        assert staged["release_prepared_model_bootstrap"] is True
+        versions._verify_source_runtime(
+            staged, package_root=package, source_root=source_root
+        )
+        return
+
+    (source_root / "rust/crates/example/src/lib.rs").write_text("changed\n")
+    with pytest.raises(module.ReleaseError, match="different native sources"):
+        module.stage_runtime(wheel, **kwargs)
+
+
+def test_release_source_runtime_uses_the_release_native_identity(
+    tmp_path: Path,
+) -> None:
+    module = _module()
+    source_root = _source_root(tmp_path)
+    state_path = _write_candidate_native_inputs(source_root)
+    candidate_digest = module._native_build_inputs_digest(source_root)
+    release_digest = module._native_build_inputs_digest(
+        source_root,
+        normalize_release_cargo_lock=True,
+    )
+    assert release_digest != candidate_digest
+    wheel = tmp_path / "pyamplicol-release.whl"
+    _wheel(
+        wheel,
+        mode="release",
+        native_build_inputs_sha256=release_digest,
+    )
+    package = source_root / "src/pyamplicol"
+    build_info = source_root / ".artifacts/source-runtime/_build_info.json"
+
+    report = module.stage_runtime(
+        wheel,
+        source_package=package,
+        source_build_info=build_info,
+        source_root=source_root,
+        mode="release",
+        audit=False,
+    )
+
+    assert report["version"] == "0.1.0"
+    payload = json.loads(build_info.read_text(encoding="utf-8"))
+    assert payload["publishable"] is True
+    assert payload["native_build_inputs_sha256"] == release_digest
+    assert payload["source_runtime"]["mode"] == "release"
+    assert payload["source_runtime"]["native_build_inputs_sha256"] == release_digest
+    versions._verify_source_runtime(
+        payload,
+        package_root=package,
+        source_root=source_root,
+    )
+
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+    state["created_utc"] = "2030-01-01T00:00:00+00:00"
+    state_path.write_text(json.dumps(state) + "\n", encoding="utf-8")
+    versions._verify_source_runtime(
+        payload,
+        package_root=package,
+        source_root=source_root,
+    )
+
+
+def test_source_runtime_rejects_an_old_candidate_wheel(tmp_path: Path) -> None:
+    module = _module()
+    source_root = _source_root(tmp_path)
+    wheel = tmp_path / "pyamplicol-test.whl"
+    _wheel(
+        wheel,
+        native_build_inputs_sha256=module._native_build_inputs_digest(source_root),
+    )
+    (source_root / "rust/crates/example/src/lib.rs").write_text(
+        "pub fn value() -> u32 { 2 }\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(module.ReleaseError, match="different native sources"):
+        module.stage_runtime(
+            wheel,
+            source_package=source_root / "src/pyamplicol",
+            source_build_info=source_root / ".artifacts/runtime/_build_info.json",
+            source_root=source_root,
+            mode="candidate",
+            audit=False,
+        )
+
+
+def test_source_runtime_verification_rejects_replaced_binary_and_source(
+    tmp_path: Path,
+) -> None:
+    source_root = _source_root(tmp_path)
+    package = source_root / "src/pyamplicol"
+    extension = package / "_rusticol.abi3.so"
+    extension.write_bytes(b"current")
+    native_digest = versions._native_build_inputs_digest(source_root)
+    payload = {
+        "publishable": False,
+        "native_build_inputs_sha256": native_digest,
+        "source_runtime": {
+            "extension_name": extension.name,
+            "extension_sha256": hashlib.sha256(b"current").hexdigest(),
+            "mode": "candidate",
+            "native_build_inputs_sha256": native_digest,
+        },
+    }
+
+    versions._verify_source_runtime(
+        payload,
+        package_root=package,
+        source_root=source_root,
+    )
+    extension.write_bytes(b"stale")
+    with pytest.raises(RuntimeError, match="stale or was replaced"):
+        versions._verify_source_runtime(
+            payload,
+            package_root=package,
+            source_root=source_root,
+        )
+
+    extension.write_bytes(b"current")
+    (source_root / "rust/crates/example/src/lib.rs").write_text(
+        "pub fn value() -> u32 { 2 }\n",
+        encoding="utf-8",
+    )
+    with pytest.raises(RuntimeError, match="native build inputs changed"):
+        versions._verify_source_runtime(
+            payload,
+            package_root=package,
+            source_root=source_root,
+        )
+
+
+def test_installed_candidate_is_bound_to_its_checkout(tmp_path: Path) -> None:
+    source_root = _source_root(tmp_path)
+    payload = {
+        "publishable": False,
+        "source_checkout": str(source_root),
+        "native_build_inputs_sha256": versions._native_build_inputs_digest(source_root),
+    }
+
+    versions._verify_candidate_install(payload)
+    (source_root / "rust/crates/example/src/lib.rs").write_text(
+        "pub fn value() -> u32 { 2 }\n",
+        encoding="utf-8",
+    )
+    with pytest.raises(RuntimeError, match="candidate wheel is stale"):
+        versions._verify_candidate_install(payload)
+
+
+def test_release_prepared_model_bootstrap_uses_release_native_identity(
+    tmp_path: Path,
+) -> None:
+    source_root = _source_root(tmp_path)
+    _write_candidate_native_inputs(source_root)
+    release_digest = versions._native_build_inputs_digest(
+        source_root,
+        normalize_release_cargo_lock=True,
+    )
+    assert release_digest != versions._native_build_inputs_digest(source_root)
+    payload = {
+        "publishable": False,
+        "release_prepared_model_bootstrap": True,
+        "source_checkout": str(source_root),
+        "native_build_inputs_sha256": release_digest,
+    }
+
+    versions._verify_candidate_install(payload)
+    (source_root / "rust/crates/example/src/lib.rs").write_text(
+        "pub fn value() -> u32 { 2 }\n",
+        encoding="utf-8",
+    )
+    with pytest.raises(RuntimeError, match="release prepared-model bootstrap is stale"):
+        versions._verify_candidate_install(payload)
+
+
+def test_native_module_build_id_must_match_candidate_metadata(monkeypatch) -> None:
+    build_info = {
+        "publishable": False,
+        "native_build_inputs_sha256": "a" * 64,
+    }
+    monkeypatch.setattr(versions, "_active_build_info", lambda: build_info)
+    native = type(
+        "Native",
+        (),
+        {
+            "__file__": "/candidate/pyamplicol/_rusticol.so",
+            "package_version": staticmethod(lambda: "0.1.0-dev.0+candidate.same"),
+            "native_build_inputs_sha256": staticmethod(lambda: "a" * 64),
+        },
+    )()
+    versions.verify_native_module(
+        native,
+        expected_version="0.1.0.dev0+candidate.same",
+    )
+
+    build_info["native_build_inputs_sha256"] = "b" * 64
+    with pytest.raises(RuntimeError, match="different source inputs"):
+        versions.verify_native_module(
+            native,
+            expected_version="0.1.0.dev0+candidate.same",
+        )
+
+
+def test_publishable_native_module_does_not_require_developer_build_id(
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(
+        versions,
+        "_active_build_info",
+        lambda: {"publishable": True, "version": "0.1.0"},
+    )
+    native = type(
+        "Native",
+        (),
+        {
+            "__file__": "/wheel/pyamplicol/_rusticol.so",
+            "package_version": staticmethod(lambda: "0.1.0"),
+        },
+    )()
+
+    versions.verify_native_module(native, expected_version="0.1.0")
+
+
+def test_publishable_native_source_identity_uses_wheel_extension(
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(
+        versions,
+        "_active_build_info",
+        lambda: {
+            "publishable": True,
+            "source_revision": "a" * 40,
+            "version": "0.1.0",
+        },
+    )
+    native = type(
+        "Native",
+        (),
+        {"native_build_inputs_sha256": staticmethod(lambda: "b" * 64)},
+    )()
+    monkeypatch.setattr(
+        versions.importlib,
+        "import_module",
+        lambda name: native if name == "pyamplicol._rusticol" else None,
+    )
+
+    assert versions.active_native_source_identity() == ("a" * 40, "b" * 64)
+
+
+def test_active_source_checkout_is_limited_to_local_candidate_builds(
+    monkeypatch,
+    tmp_path: Path,
+) -> None:
+    monkeypatch.setattr(
+        versions,
+        "_active_build_info",
+        lambda: {
+            "publishable": False,
+            "source_checkout": str(tmp_path),
+        },
+    )
+    assert versions.active_source_checkout() == tmp_path
+
+    monkeypatch.setattr(
+        versions,
+        "_active_build_info",
+        lambda: {
+            "publishable": True,
+            "source_checkout": str(tmp_path),
+        },
+    )
+    assert versions.active_source_checkout() is None
+
+
+def test_active_source_checkout_rejects_relative_path(monkeypatch) -> None:
+    monkeypatch.setattr(
+        versions,
+        "_active_build_info",
+        lambda: {
+            "publishable": False,
+            "source_checkout": "relative/checkout",
+        },
+    )
+    assert versions.active_source_checkout() is None
+
+
+def test_publishable_staged_source_runtime_requires_its_native_build_id(
+    monkeypatch,
+) -> None:
+    build_info = {
+        "publishable": True,
+        "native_build_inputs_sha256": "a" * 64,
+        "source_runtime": {"mode": "release"},
+    }
+    monkeypatch.setattr(versions, "_active_build_info", lambda: build_info)
+    native = type(
+        "Native",
+        (),
+        {
+            "__file__": "/source/pyamplicol/_rusticol.so",
+            "package_version": staticmethod(lambda: "0.1.0"),
+            "native_build_inputs_sha256": staticmethod(lambda: "a" * 64),
+        },
+    )()
+
+    versions.verify_native_module(native, expected_version="0.1.0")
+    build_info["native_build_inputs_sha256"] = "b" * 64
+    with pytest.raises(RuntimeError, match="different source inputs"):
+        versions.verify_native_module(native, expected_version="0.1.0")
+
+
+def test_package_version_prefers_attested_source_runtime(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    source_root = _source_root(tmp_path)
+    package = source_root / "src/pyamplicol"
+    extension = package / "_rusticol.abi3.so"
+    extension.write_bytes(b"extension")
+    runtime = source_root / ".artifacts/source-runtime"
+    runtime.mkdir(parents=True)
+    build_info = runtime / "_build_info.json"
+    build_info.write_text(
+        json.dumps(
+            {
+                "publishable": False,
+                "native_build_inputs_sha256": versions._native_build_inputs_digest(
+                    source_root
+                ),
+                "source_runtime": {
+                    "extension_name": extension.name,
+                    "extension_sha256": hashlib.sha256(b"extension").hexdigest(),
+                    "mode": "candidate",
+                    "native_build_inputs_sha256": (
+                        versions._native_build_inputs_digest(source_root)
+                    ),
+                },
+                "version": "0.1.0.dev0+candidate.current",
+            }
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(versions, "_SOURCE_ROOT", source_root)
+    monkeypatch.setattr(versions, "_SOURCE_PACKAGE_ROOT", package)
+    monkeypatch.setattr(versions, "_SOURCE_BUILD_INFO_PATH", build_info)
+    monkeypatch.setattr(versions, "_SOURCE_RUNTIME_STAGING_PATH", runtime / ".staging")
+    monkeypatch.setattr(versions, "_PACKAGE_BUILD_INFO_PATH", tmp_path / "missing")
+
+    assert versions.package_version() == "0.1.0.dev0+candidate.current"
+
+
+def test_package_version_fails_closed_during_staging(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    source_root = _source_root(tmp_path)
+    runtime = source_root / ".artifacts/source-runtime"
+    runtime.mkdir(parents=True)
+    marker = runtime / ".staging"
+    marker.write_text("incomplete\n", encoding="utf-8")
+    monkeypatch.setattr(versions, "_SOURCE_ROOT", source_root)
+    monkeypatch.setattr(
+        versions,
+        "_SOURCE_PACKAGE_ROOT",
+        source_root / "src/pyamplicol",
+    )
+    monkeypatch.setattr(versions, "_SOURCE_BUILD_INFO_PATH", runtime / "missing")
+    monkeypatch.setattr(versions, "_SOURCE_RUNTIME_STAGING_PATH", marker)
+
+    with pytest.raises(RuntimeError, match="staging is incomplete"):
+        versions.package_version()
+
+
+def test_source_runtime_rejects_dot_target(tmp_path: Path) -> None:
+    module = _module()
+    source_root = _source_root(tmp_path)
+    wheel = tmp_path / "pyamplicol-test.whl"
+    _wheel(
+        wheel,
+        native_build_inputs_sha256=module._native_build_inputs_digest(source_root),
+        target="..",
+    )
+
+    with pytest.raises(module.ReleaseError, match="unsafe target"):
+        module.stage_runtime(
+            wheel,
+            source_package=source_root / "src/pyamplicol",
+            source_build_info=source_root / ".artifacts/runtime/_build_info.json",
+            source_root=source_root,
+            mode="candidate",
+            audit=False,
+        )
+
+
+def test_source_runtime_rejects_a_wheel_for_another_host(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    module = _module()
+    source_root = _source_root(tmp_path)
+    wheel = tmp_path / "pyamplicol-test.whl"
+    _wheel(
+        wheel,
+        native_build_inputs_sha256=module._native_build_inputs_digest(source_root),
+        target="x86_64-unknown-linux-gnu",
+    )
+    monkeypatch.setattr(module, "_host_target", lambda: "aarch64-apple-darwin")
+
+    with pytest.raises(module.ReleaseError, match="this host requires"):
+        module.stage_runtime(
+            wheel,
+            source_package=source_root / "src/pyamplicol",
+            source_build_info=source_root / ".artifacts/runtime/_build_info.json",
+            source_root=source_root,
+            mode="candidate",
+            audit=False,
+        )
+
+
+@pytest.mark.parametrize("mode", ("candidate", "release"))
+@pytest.mark.parametrize("platform_name", ("linux", "darwin"))
+def test_source_runtime_build_requests_host_wheel_only_on_linux(
+    tmp_path: Path, monkeypatch, mode: str, platform_name: str
+) -> None:
+    module = _module()
+    wheel = tmp_path / "pyamplicol-test.whl"
+    wheel.touch()
+    calls = []
+    monkeypatch.setattr(module.sys, "platform", platform_name)
+    monkeypatch.setattr(
+        module, "external_temporary_directory", lambda _name: nullcontext(tmp_path)
+    )
+    monkeypatch.setattr(
+        module, "run", lambda command, **kwargs: calls.append((command, kwargs))
+    )
+    monkeypatch.setattr(module, "clean_environment", lambda **_kwargs: {})
+    monkeypatch.setattr(module, "stage_runtime", lambda path, **kwargs: (path, kwargs))
+    assert module.build_and_stage(python=Path("python"), mode=mode) == (
+        wheel,
+        {"mode": mode, "audit": False},
+    )
+    command, _ = calls[0]
+    assert ("pyamplicol.host-wheel=true" in command) == (platform_name == "linux")
+    if platform_name == "linux":
+        assert (
+            command[command.index("--config-setting") + 1]
+            == "pyamplicol.host-wheel=true"
+        )
+
+
+def test_source_runtime_stages_an_existing_local_wheel_directory(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    module = _module()
+    wheel_directory = tmp_path / "wheelhouse"
+    wheel_directory.mkdir()
+    wheel = wheel_directory / "pyamplicol-test.whl"
+    wheel.write_bytes(b"wheel")
+    observed: dict[str, object] = {}
+
+    def stage(path: Path, *, mode: str, audit: bool) -> dict[str, object]:
+        observed.update(path=path, mode=mode, audit=audit)
+        return {"wheel": path.name}
+
+    monkeypatch.setattr(module, "stage_runtime", stage)
+    report = module.stage_from_directory(wheel_directory, mode="candidate")
+
+    assert report == {"wheel": wheel.name}
+    assert observed == {"path": wheel, "mode": "candidate", "audit": False}
+
+
+@pytest.mark.parametrize("mode", ("candidate", "release"))
+def test_reuse_current_runtime_uses_existing_authoritative_verifier(
+    tmp_path: Path, monkeypatch, mode: str
+) -> None:
+    module = _module()
+    runtime_root = tmp_path / "runtime"
+    runtime_root.mkdir()
+    build_info = runtime_root / "_build_info.json"
+    payload = {"source_runtime": {"mode": mode}, "version": "1.0.0"}
+    build_info.write_text(json.dumps(payload), encoding="utf-8")
+    observed = []
+
+    def verify(value, **kwargs):
+        observed.append((value, kwargs))
+
+    monkeypatch.setattr(module, "SOURCE_RUNTIME_ROOT", runtime_root)
+    monkeypatch.setattr(module, "SOURCE_BUILD_INFO", build_info)
+    monkeypatch.setattr(module, "SOURCE_RUNTIME_STAGING", runtime_root / ".staging")
+    monkeypatch.setattr(
+        module,
+        "_runtime_versions",
+        lambda: SimpleNamespace(
+            _read_build_info=versions._read_build_info,
+            _verify_source_runtime=verify,
+        ),
+    )
+
+    assert module.reuse_current_runtime(mode=mode) == {
+        "mode": mode,
+        "version": "1.0.0",
+        "reused": True,
+    }
+    assert observed == [
+        (payload, {"package_root": module.SOURCE_PACKAGE, "source_root": module.ROOT})
+    ]
+
+
+@pytest.mark.parametrize(
+    "failure", ("mode", "incomplete", "missing", "invalid", "stale")
+)
+def test_reuse_current_runtime_rejects_unusable_staging(
+    tmp_path: Path, monkeypatch, failure: str
+) -> None:
+    module = _module()
+    runtime_root = tmp_path / "runtime"
+    runtime_root.mkdir()
+    build_info = runtime_root / "_build_info.json"
+    payload = {
+        "source_runtime": {"mode": "candidate" if failure == "mode" else "release"},
+        "version": "1.0.0",
+    }
+    if failure != "missing":
+        build_info.write_text(
+            "not json" if failure == "invalid" else json.dumps(payload),
+            encoding="utf-8",
+        )
+    if failure == "incomplete":
+        (runtime_root / ".staging").touch()
+
+    def verify(*args, **kwargs):
+        assert failure == "stale", "invalid staging reached the identity verifier"
+        raise RuntimeError("native inputs changed")
+
+    monkeypatch.setattr(module, "SOURCE_RUNTIME_ROOT", runtime_root)
+    monkeypatch.setattr(module, "SOURCE_BUILD_INFO", build_info)
+    monkeypatch.setattr(module, "SOURCE_RUNTIME_STAGING", runtime_root / ".staging")
+    monkeypatch.setattr(
+        module,
+        "_runtime_versions",
+        lambda: SimpleNamespace(
+            _read_build_info=versions._read_build_info,
+            _verify_source_runtime=verify,
+        ),
+    )
+    assert module.reuse_current_runtime(mode="release") is None
+
+
+@pytest.mark.parametrize(
+    ("reuse_requested", "reuse_available"), ((False, True), (True, True), (True, False))
+)
+def test_source_runtime_main_reuse_is_opt_in_with_build_fallback(
+    monkeypatch, capsys, reuse_requested: bool, reuse_available: bool
+) -> None:
+    module = _module()
+    monkeypatch.setenv("PYAMPLICOL_BUILD_MODE", "release")
+    calls = []
+
+    def reuse(*, mode):
+        calls.append("reuse")
+        assert mode == "release"
+        return {"reused": True} if reuse_available else None
+
+    def build(*, python, mode):
+        calls.append("build")
+        assert mode == "release"
+        return {"wheel": "fresh.whl"}
+
+    monkeypatch.setattr(module, "reuse_current_runtime", reuse)
+    monkeypatch.setattr(module, "build_and_stage", build)
+    assert module.main(["--reuse-current"] if reuse_requested else []) == 0
+    reused = reuse_requested and reuse_available
+    assert calls == (
+        ["reuse"] if reused else ["reuse", "build"] if reuse_requested else ["build"]
+    )
+    assert json.loads(capsys.readouterr().out) == (
+        {"reused": True} if reused else {"wheel": "fresh.whl"}
+    )
+
+
+def test_native_provenance_digest_implementations_match(tmp_path: Path) -> None:
+    module = _module()
+    spec = importlib.util.spec_from_file_location(
+        "source_runtime_build_backend",
+        ROOT / "build_backend/_pyamplicol_build.py",
+    )
+    assert spec is not None and spec.loader is not None
+    backend = importlib.util.module_from_spec(spec)
+    sys.path.insert(0, str(ROOT / "build_backend"))
+    try:
+        sys.modules[spec.name] = backend
+        spec.loader.exec_module(backend)
+    finally:
+        sys.path.pop(0)
+    source_root = _source_root(tmp_path)
+
+    before = module._native_build_inputs_digest(source_root)
+    native_source = source_root / "rust/crates/example/src/lib.rs"
+    native_source.write_text("pub fn value() -> u32 { 2 }\n", encoding="utf-8")
+    expected = module._native_build_inputs_digest(source_root)
+    assert expected != before
+    assert backend._native_build_inputs_digest(source_root) == expected
+    assert versions._native_build_inputs_digest(source_root) == expected
+
+    native_source.write_text("pub fn value() -> u32 { 3 }\n", encoding="utf-8")
+    changed = module._native_build_inputs_digest(source_root)
+    assert changed != expected
+    assert backend._native_build_inputs_digest(source_root) == changed
+    assert versions._native_build_inputs_digest(source_root) == changed
+
+
+def test_native_digest_v2_projects_only_native_pyproject_inputs(
+    tmp_path: Path,
+) -> None:
+    identity = _native_build_identity_module()
+    source_root = _source_root(tmp_path)
+    pyproject = source_root / "pyproject.toml"
+    original = pyproject.read_text(encoding="utf-8")
+    expected = identity.native_build_inputs_digest(source_root)
+    assert versions._native_build_inputs_digest(source_root) == expected
+
+    packaging_only = original.replace(
+        'description = "Generator using current recursion',
+        'description = "Packaging-only edit; generator using current recursion',
+        1,
+    ).replace("locked = true", "locked = false", 1)
+    packaging_only = packaging_only.replace(
+        '"maturin==1.15.0",\n  "mypy',
+        '"maturin==9.9.9",\n  "mypy',
+        1,
+    )
+    pyproject.write_text(packaging_only, encoding="utf-8")
+    assert identity.native_build_inputs_digest(source_root) == expected
+    assert versions._native_build_inputs_digest(source_root) == expected
+
+    pyproject.write_text(
+        original.replace("maturin==1.15.0", "maturin==1.15.1", 1),
+        encoding="utf-8",
+    )
+    pin_changed = identity.native_build_inputs_digest(source_root)
+    assert pin_changed != expected
+    assert versions._native_build_inputs_digest(source_root) == pin_changed
+
+    pyproject.write_text(
+        original.replace(
+            'features = ["extension-module", "numpy"]',
+            'features = ["extension-module", "numpy", "native-change"]',
+            1,
+        ),
+        encoding="utf-8",
+    )
+    feature_changed = identity.native_build_inputs_digest(source_root)
+    assert feature_changed != expected
+    assert versions._native_build_inputs_digest(source_root) == feature_changed
+
+    pyproject.write_text(
+        original.replace(
+            "/pyamplicol/build",
+            "/pyamplicol/changed-build",
+            1,
+        ),
+        encoding="utf-8",
+    )
+    contract_changed = identity.native_build_inputs_digest(source_root)
+    assert contract_changed != expected
+    assert versions._native_build_inputs_digest(source_root) == contract_changed
+
+
+@pytest.mark.parametrize(
+    "replacement",
+    (
+        "maturin>=1.15.0",
+        "maturin==1.15.0; python_version >= '3.11'",
+        "packaging==26.3",
+        'maturin==1.15.0",\n  "maturin==1.15.0',
+    ),
+)
+def test_native_digest_rejects_unpinned_or_missing_build_maturin(
+    tmp_path: Path,
+    replacement: str,
+) -> None:
+    source_root = _source_root(tmp_path)
+    pyproject = source_root / "pyproject.toml"
+    pyproject.write_text(
+        pyproject.read_text(encoding="utf-8").replace(
+            "maturin==1.15.0",
+            replacement,
+            1,
+        ),
+        encoding="utf-8",
+    )
+    for digest in (
+        _native_build_identity_module().native_build_inputs_digest,
+        versions._native_build_inputs_digest,
+    ):
+        with pytest.raises(RuntimeError, match="Maturin"):
+            digest(source_root)
+
+
+def test_native_digest_rejects_unclassified_maturin_configuration(
+    tmp_path: Path,
+) -> None:
+    source_root = _source_root(tmp_path)
+    pyproject = source_root / "pyproject.toml"
+    pyproject.write_text(
+        pyproject.read_text(encoding="utf-8").replace(
+            "[tool.maturin]\n",
+            "[tool.maturin]\nfuture-native-option = true\n",
+            1,
+        ),
+        encoding="utf-8",
+    )
+    for digest in (
+        _native_build_identity_module().native_build_inputs_digest,
+        versions._native_build_inputs_digest,
+    ):
+        with pytest.raises(RuntimeError, match="unclassified Maturin"):
+            digest(source_root)
+
+
+def test_native_digest_rejects_boolean_contract_schema_version(
+    tmp_path: Path,
+) -> None:
+    source_root = _source_root(tmp_path)
+    pyproject = source_root / "pyproject.toml"
+    pyproject.write_text(
+        pyproject.read_text(encoding="utf-8").replace(
+            "schema-version = 1",
+            "schema-version = true",
+            1,
+        ),
+        encoding="utf-8",
+    )
+    for digest in (
+        _native_build_identity_module().native_build_inputs_digest,
+        versions._native_build_inputs_digest,
+    ):
+        with pytest.raises(RuntimeError, match="schema-version 1"):
+            digest(source_root)
+
+
+def test_native_digest_uses_explicit_test_only_inventory(tmp_path: Path) -> None:
+    identity = _native_build_identity_module()
+    source_root = _source_root(tmp_path)
+    expected = identity.native_build_inputs_digest(source_root)
+
+    backend_python = source_root / "build_backend/_pyamplicol_build.py"
+    backend_python.parent.mkdir(parents=True)
+    backend_python.write_text("PACKAGING_ONLY = True\n", encoding="utf-8")
+    staging = source_root / "rust/.artifacts/profile/report.json"
+    staging.parent.mkdir(parents=True)
+    staging.write_text("{}\n", encoding="utf-8")
+    ignored = source_root / "rust/crates/rusticol-core/src/artifact_tests.rs"
+    ignored.parent.mkdir(parents=True)
+    ignored.write_text("#[test] fn changed() {}\n", encoding="utf-8")
+    assert identity.native_build_inputs_digest(source_root) == expected
+
+    productive_name = source_root / "rust/crates/example/src/future_tests.rs"
+    productive_name.write_text("pub fn production() {}\n", encoding="utf-8")
+    changed = identity.native_build_inputs_digest(source_root)
+    assert changed != expected
+    assert versions._native_build_inputs_digest(source_root) == changed
+
+    test_support = (
+        source_root
+        / "rust/crates/rusticol-core/src/recurrence/on_the_fly/test_support.rs"
+    )
+    test_support.parent.mkdir(parents=True, exist_ok=True)
+    test_support.write_text("pub fn feature_api() {}\n", encoding="utf-8")
+    feature_changed = identity.native_build_inputs_digest(source_root)
+    assert feature_changed != changed
+    assert versions._native_build_inputs_digest(source_root) == feature_changed
+
+
+def test_candidate_native_digest_is_stable_across_install_and_relocation(
+    tmp_path: Path,
+) -> None:
+    identity = _native_build_identity_module()
+    staging = _module()
+    first = _source_root(tmp_path / "first")
+    second = _source_root(tmp_path / "second")
+    _write_candidate_native_inputs(first)
+    _write_candidate_native_inputs(
+        second,
+        checkout_root=(tmp_path / "relocated" / "dependencies" / "checkouts"),
+        include_legacy=True,
+    )
+
+    expected = identity.native_build_inputs_digest(first)
+    assert identity.native_build_inputs_digest(second) == expected
+    assert versions._native_build_inputs_digest(first) == expected
+    assert versions._native_build_inputs_digest(second) == expected
+    assert staging._native_build_inputs_digest(first) == expected
+
+    config = first / "dependencies/candidate-cargo-config.toml"
+    config.write_text(
+        "# a repeat install may alter comments and formatting\n"
+        + config.read_text(encoding="utf-8"),
+        encoding="utf-8",
+    )
+    assert identity.native_build_inputs_digest(first) == expected
+
+
+def test_candidate_native_digest_hashes_only_native_checkout_revisions(
+    tmp_path: Path,
+) -> None:
+    identity = _native_build_identity_module()
+    source_root = _source_root(tmp_path)
+    state_path = _write_candidate_native_inputs(source_root, include_legacy=True)
+    expected = identity.native_build_inputs_digest(source_root)
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+
+    state["sources"]["gammaloop"]["revision"] = "a" * 40
+    state["sources"]["legacy-amplicol"]["revision"] = "b" * 40
+    state_path.write_text(json.dumps(state, sort_keys=True) + "\n", encoding="utf-8")
+    assert identity.native_build_inputs_digest(source_root) == expected
+    assert versions._native_build_inputs_digest(source_root) == expected
+
+    state["sources"]["symbolica"]["revision"] = "c" * 40
+    state_path.write_text(json.dumps(state, sort_keys=True) + "\n", encoding="utf-8")
+    changed = identity.native_build_inputs_digest(source_root)
+    assert changed != expected
+    assert versions._native_build_inputs_digest(source_root) == changed
+
+
+def test_candidate_native_digest_requires_the_minimal_install_state_schema(
+    tmp_path: Path,
+) -> None:
+    identity = _native_build_identity_module()
+    source_root = _source_root(tmp_path)
+    state_path = _write_candidate_native_inputs(source_root)
+    expected = identity.native_build_inputs_digest(source_root)
+
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+    state["sources"]["symjit"]["worktree_sha256"] = "9" * 64
+    state_path.write_text(
+        json.dumps(state, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    for digest in (
+        identity.native_build_inputs_digest,
+        versions._native_build_inputs_digest,
+    ):
+        with pytest.raises(RuntimeError, match="optional branch only"):
+            digest(source_root)
+
+    del state["sources"]["symjit"]["worktree_sha256"]
+    state_path.write_text(
+        json.dumps(state, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    config = source_root / "dependencies/candidate-cargo-config.toml"
+    config.write_text(
+        config.read_text(encoding="utf-8") + "# formatting-only rewrite\n",
+        encoding="utf-8",
+    )
+    for digest in (
+        identity.native_build_inputs_digest,
+        versions._native_build_inputs_digest,
+    ):
+        assert digest(source_root) == expected
+
+
+def test_local_symjit_inputs_invalidate_native_cache_without_extension_noise(
+    tmp_path: Path,
+) -> None:
+    identity = _native_build_identity_module()
+    source_root = _source_root(tmp_path)
+    _write_candidate_native_inputs(source_root)
+    config = source_root / "dependencies/candidate-cargo-config.toml"
+    config.write_text(
+        config.read_text(encoding="utf-8").replace(
+            str(source_root / "dependencies/checkouts/symjit"),
+            str(source_root / "TMP_FIXED_SYMJIT"),
+        ),
+        encoding="utf-8",
+    )
+    (source_root / "Cargo.toml").write_text(
+        '[patch.crates-io]\nsymjit = { path = "./TMP_FIXED_SYMJIT" }\n',
+        encoding="utf-8",
+    )
+    local = source_root / "TMP_FIXED_SYMJIT"
+    (local / "src").mkdir(parents=True)
+    compiler = local / "src/lib.rs"
+    compiler.write_text("pub fn compiler() {}\n", encoding="utf-8")
+    before = identity.native_build_inputs_digest(source_root)
+    assert versions._native_build_inputs_digest(source_root) == before
+
+    # Spenso is part of the separate community extension, not RustiCol.
+    with config.open("a", encoding="utf-8") as stream:
+        stream.write('spenso = { path = "TMP_FIXED_SPENSO/crates/spenso" }\n')
+    (local / "README.md").write_text("documentation only\n", encoding="utf-8")
+    (local / "tests").mkdir()
+    (local / "tests/check.rs").write_text("// test only\n", encoding="utf-8")
+    assert identity.native_build_inputs_digest(source_root) == before
+    assert versions._native_build_inputs_digest(source_root) == before
+
+    compiler.write_text("pub fn compiler() { let _fixed = true; }\n", encoding="utf-8")
+    after = identity.native_build_inputs_digest(source_root)
+    assert after != before
+    assert versions._native_build_inputs_digest(source_root) == after
+
+
+def test_candidate_native_digest_rejects_wrong_patch_target(tmp_path: Path) -> None:
+    identity = _native_build_identity_module()
+    source_root = _source_root(tmp_path)
+    _write_candidate_native_inputs(source_root)
+    config = source_root / "dependencies/candidate-cargo-config.toml"
+    text = config.read_text(encoding="utf-8").replace(
+        "dependencies/checkouts/symjit",
+        "dependencies/checkouts/symbolica",
+    )
+    config.write_text(text, encoding="utf-8")
+    for digest in (
+        identity.native_build_inputs_digest,
+        versions._native_build_inputs_digest,
+    ):
+        with pytest.raises(RuntimeError, match="symjit must resolve"):
+            digest(source_root)
+
+
+def test_candidate_native_digest_ignores_provenance_locks_and_hashes_cargo_lock(
+    tmp_path: Path,
+) -> None:
+    identity = _native_build_identity_module()
+    source_root = _source_root(tmp_path)
+    _write_candidate_native_inputs(source_root)
+    expected = identity.native_build_inputs_digest(source_root)
+    dependencies = source_root / "dependencies"
+    for name in (
+        "contributor-lock.toml",
+        "python-runtime-lock.toml",
+        "release-lock.toml",
+    ):
+        (dependencies / name).write_text("changed provenance\n", encoding="utf-8")
+        assert identity.native_build_inputs_digest(source_root) == expected
+        assert versions._native_build_inputs_digest(source_root) == expected
+
+    (source_root / "Cargo.lock").write_text(
+        "unused release resolution\n",
+        encoding="utf-8",
+    )
+    assert identity.native_build_inputs_digest(source_root) == expected
+    assert versions._native_build_inputs_digest(source_root) == expected
+
+    lock = dependencies / "candidate-Cargo.lock"
+    lock.write_text("changed Cargo resolution\n", encoding="utf-8")
+    changed = identity.native_build_inputs_digest(source_root)
+    assert changed != expected
+    assert versions._native_build_inputs_digest(source_root) == changed
+
+
+def test_release_native_digest_hashes_the_registry_cargo_lock_verbatim(
+    tmp_path: Path,
+) -> None:
+    identity = _native_build_identity_module()
+    source_root = _source_root(tmp_path)
+    lock = tomllib.loads(
+        (ROOT / "dependencies/release-lock.toml").read_text(encoding="utf-8")
+    )
+    symjit = lock["symjit"]
+    source = "registry+https://github.com/rust-lang/crates.io-index"
+    marker = (
+        "[[package]]\n"
+        'name = "symjit"\n'
+        f'version = "{symjit["version"]}"\n'
+        f'source = "{source}"\n'
+    )
+    replacement = f'[[package]]\nname = "symjit"\nversion = "{symjit["version"]}"\n'
+    git_lock = (ROOT / "Cargo.lock").read_text(encoding="utf-8")
+    assert git_lock.count(marker) == 1
+    projected_lock = git_lock.replace(marker, replacement, 1).encode("utf-8")
+    cargo_lock = source_root / "Cargo.lock"
+
+    cargo_lock.write_text(git_lock, encoding="utf-8")
+    git_shared = identity.native_build_inputs_digest(
+        source_root,
+        normalize_release_cargo_lock=True,
+    )
+    git_runtime = versions._native_build_inputs_digest(
+        source_root,
+        normalize_release_cargo_lock=True,
+    )
+    assert git_runtime == git_shared
+    assert identity.canonical_release_cargo_lock_bytes(
+        source_root,
+        git_lock.encode("utf-8"),
+    ) == git_lock.encode("utf-8")
+
+    cargo_lock.write_bytes(projected_lock)
+    projected_shared = identity.native_build_inputs_digest(
+        source_root,
+        normalize_release_cargo_lock=True,
+    )
+    projected_runtime = versions._native_build_inputs_digest(
+        source_root,
+        normalize_release_cargo_lock=True,
+    )
+
+    assert projected_shared != git_shared
+    assert projected_runtime == projected_shared
diff --git a/pyamplicol/tests/unit/test_source_wavefunction_metadata.py b/pyamplicol/tests/unit/test_source_wavefunction_metadata.py
new file mode 100644
index 0000000000..766c1fc3d2
--- /dev/null
+++ b/pyamplicol/tests/unit/test_source_wavefunction_metadata.py
@@ -0,0 +1,465 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from dataclasses import replace
+from decimal import Decimal
+
+import pytest
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+from pyamplicol.generation.artifact_writer import _execution_plan
+from pyamplicol.generation.dag_compiler import compile_generic_dag
+from pyamplicol.generation.runtime_schema import build_runtime_schema
+from pyamplicol.models import BuiltinSMModel
+from pyamplicol.models._physics_ir import CrossingIR, PropagatorIR
+from pyamplicol.models.base import Model, Particle
+from pyamplicol.models.builtin.process_ir import build_process_ir
+from pyamplicol.models.contracts import CompiledParticleRecord
+from pyamplicol.models.external_catalog import ExternalModelCatalogMixin
+from pyamplicol.runtime.symbolica_exact import (
+    _antiquark_weyl,
+    _massive_vector,
+    _particle_mass,
+    _quark_weyl,
+    _source_wavefunction,
+)
+
+
+class _ExternalCatalog(ExternalModelCatalogMixin, Model):
+    def _propagator_record(self, particle_id: int) -> None:
+        del particle_id
+        return None
+
+    def _parameter_default(self, name: str) -> float:
+        if name.casefold() == "zero":
+            return 0.0
+        raise KeyError(name)
+
+
+def _compiled_particle(
+    name: str,
+    antiname: str,
+    pdg: int,
+    *,
+    spin: int = 2,
+) -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=antiname,
+        pdg_code=pdg,
+        spin=spin,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def _external_catalog(*records: CompiledParticleRecord) -> _ExternalCatalog:
+    by_name = {record.name: record for record in records}
+    model = _ExternalCatalog(name="relabelled-source-model")
+    model._particle_records_by_name = by_name
+    model._particle_records_by_pdg = {record.pdg_code: record for record in records}
+    model.particles = {
+        record.pdg_code: Particle(
+            pdg=record.pdg_code,
+            anti_pdg=by_name[record.antiname].pdg_code,
+            spin=record.spin,
+            dimension=4,
+            color_rep=record.color,
+        )
+        for record in records
+    }
+    return model
+
+
+def _exact_source(
+    *,
+    particle_id: int,
+    anti_particle_id: int,
+    source_orientation: str,
+    dimension: int = 2,
+) -> dict[str, object]:
+    identity = {
+        "canonical_id": f"model:test:state:{particle_id}",
+        "species_id": f"model:test:species:{abs(particle_id)}",
+        "anti_canonical_id": f"model:test:state:{anti_particle_id}",
+        "display_name": f"state_{particle_id}",
+        "anti_display_name": f"state_{anti_particle_id}",
+        "pdg_label": particle_id,
+        "anti_pdg_label": anti_particle_id,
+        "orientation": source_orientation,
+        "self_conjugate": particle_id == anti_particle_id,
+    }
+    crossing = {
+        "momentum_transform": "identity",
+        "helicity_factor": 1,
+        "chirality_factor": 1,
+        "spin_state_factor": 1,
+        "phase": [1.0, 0.0],
+    }
+    return {
+        "leg_label": 1,
+        "side": "final",
+        "crossing": "identity",
+        "particle_id": particle_id,
+        "anti_particle_id": anti_particle_id,
+        "wavefunction_kind": "fermion",
+        "source_orientation": source_orientation,
+        "source_basis": "weyl-chiral" if dimension == 2 else "dirac",
+        "source_ir": {
+            "identity": identity,
+            "statistics": "fermion",
+            "wavefunction_family": "fermion",
+            "component_dimension": dimension,
+            "states": [{"helicity": 1, "chirality": 1, "spin_state": 1}],
+            "crossing": crossing,
+            "basis": "weyl-chiral" if dimension == 2 else "dirac",
+            "mass_parameter": None,
+            "width_parameter": None,
+        },
+        "applied_crossing": crossing,
+        "source_helicity": 1,
+        "chirality": 1,
+        "spin_state": 1,
+        "dimension": dimension,
+    }
+
+
+def test_external_relabelled_pdg_source_metadata() -> None:
+    particle = _compiled_particle("chi", "chi_bar", 810_001)
+    antiparticle = _compiled_particle("chi_bar", "chi", -810_001)
+    model = _external_catalog(particle, antiparticle)
+
+    assert model.source_wavefunction_kind(810_001) == "fermion"
+    assert model.source_orientation(810_001) == "particle"
+    assert model.source_orientation(-810_001) == "antiparticle"
+    particle_source = model._source_ir(810_001)
+    antiparticle_source = model._source_ir(-810_001)
+    assert particle_source.identity.canonical_id.endswith(":chi")
+    assert particle_source.identity.species_id.endswith(":chi")
+    assert antiparticle_source.identity.canonical_id.endswith(":chi_bar")
+    assert (
+        antiparticle_source.identity.species_id == particle_source.identity.species_id
+    )
+    assert particle_source.identity.anti_canonical_id.endswith(":chi_bar")
+    assert particle_source.basis == "weyl-chiral"
+
+
+def test_builtin_source_crossing_is_explicit_and_state_preserving() -> None:
+    model = BuiltinSMModel()
+
+    fermion = model._source_ir(1)
+    assert fermion.basis == "weyl-chiral"
+    assert fermion.crossing.to_json_dict() == {
+        "momentum_transform": "negate-four-momentum",
+        "helicity_factor": 1,
+        "chirality_factor": -1,
+        "spin_state_factor": -1,
+        "phase": [1.0, 0.0],
+    }
+    assert {
+        (state.helicity, state.chirality, state.spin_state) for state in fermion.states
+    } == {(-1, -1, -1), (1, 1, 1)}
+    assert {
+        (state.helicity, state.chirality, state.spin_state)
+        for state in map(fermion.crossing.apply, fermion.states)
+    } == {(-1, 1, 1), (1, -1, -1)}
+
+    adjoint = model._source_ir(21)
+    assert adjoint.basis == "lorentz-vector"
+    assert adjoint.crossing.helicity_factor == -1
+    assert adjoint.crossing.chirality_factor == 1
+    assert adjoint.crossing.spin_state_factor == -1
+
+    singlet_vector = model._source_ir(23)
+    assert singlet_vector.crossing.helicity_factor == -1
+    assert singlet_vector.crossing.spin_state_factor == -1
+    assert tuple(
+        (state.helicity, state.spin_state)
+        for state in map(singlet_vector.crossing.apply, singlet_vector.states)
+    ) == ((1, 1), (0, 0), (-1, -1))
+
+
+def test_external_scalar_and_spin2_sources_are_metadata_driven() -> None:
+    model = _external_catalog(
+        _compiled_particle("phi", "phi", 700_001, spin=1),
+        _compiled_particle("graviton", "graviton", 700_002, spin=5),
+    )
+
+    scalar = model._source_ir(700_001)
+    assert scalar.wavefunction_family == "scalar"
+    assert scalar.basis == "scalar"
+    assert scalar.component_dimension == 1
+    assert tuple(state.helicity for state in scalar.states) == (0,)
+
+    spin2 = model._source_ir(700_002)
+    assert spin2.wavefunction_family == "spin2"
+    assert spin2.basis == "lorentz-rank-2"
+    assert spin2.component_dimension == 16
+    assert tuple(state.helicity for state in spin2.states) == (-2, 2)
+    assert spin2.crossing.momentum_transform == "negate-four-momentum"
+    assert tuple(spin2.crossing.apply(state).helicity for state in spin2.states) == (
+        2,
+        -2,
+    )
+
+
+@pytest.mark.parametrize("helicity", [-1, 0, 1])
+def test_massive_vector_negative_energy_obeys_crossing_convention(
+    helicity: int,
+) -> None:
+    momentum = tuple(Decimal(value) for value in ("13", "4", "8", "8"))
+    crossed = tuple(-component for component in momentum)
+    mass = Decimal("5")
+
+    assert _massive_vector(crossed, -helicity, mass) == _massive_vector(
+        momentum,
+        helicity,
+        mass,
+    )
+
+
+@pytest.mark.parametrize("helicity", [-1, 0, 1])
+def test_massive_vector_is_transverse_for_both_energy_signs(helicity: int) -> None:
+    momentum = tuple(Decimal(value) for value in ("13", "4", "8", "8"))
+    mass = Decimal("5")
+
+    for candidate, source_helicity in (
+        (momentum, helicity),
+        (tuple(-component for component in momentum), -helicity),
+    ):
+        wave = _massive_vector(candidate, source_helicity, mass)
+        contraction = (
+            candidate[0] * wave[0][0]
+            - candidate[1] * wave[1][0]
+            - candidate[2] * wave[2][0]
+            - candidate[3] * wave[3][0],
+            candidate[0] * wave[0][1]
+            - candidate[1] * wave[1][1]
+            - candidate[2] * wave[2][1]
+            - candidate[3] * wave[3][1],
+        )
+        assert abs(contraction[0]) < Decimal("1e-25")
+        assert abs(contraction[1]) < Decimal("1e-25")
+
+
+def test_source_ir_rejects_inconsistent_statistics() -> None:
+    source = BuiltinSMModel()._source_ir(1)
+
+    with pytest.raises(ValueError, match="requires statistics 'fermion'"):
+        replace(source, statistics="boson")
+
+
+def test_source_ir_is_canonical_per_oriented_particle() -> None:
+    model = BuiltinSMModel()
+
+    assert model._source_ir(1) is model._source_ir(1)
+    assert model._source_ir(-1) is model._source_ir(-1)
+    assert model._source_ir(1) is not model._source_ir(-1)
+
+
+@pytest.mark.parametrize("factor", [True, 1.0, "1"])
+def test_crossing_ir_rejects_non_integer_factors(factor: object) -> None:
+    with pytest.raises(TypeError, match="must be an integer"):
+        CrossingIR(helicity_factor=factor)  # type: ignore[arg-type]
+
+
+def test_crossing_ir_normalizes_and_rejects_zero_sequence_phase() -> None:
+    crossing = CrossingIR(phase=[0, 1])  # type: ignore[arg-type]
+    assert crossing.phase == (0.0, 1.0)
+
+    with pytest.raises(ValueError, match="must be nonzero"):
+        CrossingIR(phase=[0, 0])  # type: ignore[arg-type]
+
+
+@pytest.mark.parametrize("dimension", [True, 1.5, "2"])
+def test_source_ir_rejects_non_integer_component_dimensions(
+    dimension: object,
+) -> None:
+    source = BuiltinSMModel()._source_ir(1)
+
+    with pytest.raises(TypeError, match="must be an integer"):
+        replace(source, component_dimension=dimension)
+
+
+def test_propagator_ir_records_basis_gauge_and_formula() -> None:
+    model = BuiltinSMModel()
+
+    massless_vector = model._propagator_ir(21)
+    assert massless_vector.basis == "lorentz-vector"
+    assert massless_vector.kind == "vector"
+    assert massless_vector.mass_class == "massless"
+    assert massless_vector.gauge == "feynman"
+    assert massless_vector.numerator == "-i*metric"
+    assert massless_vector.denominator == "momentum_squared"
+
+    massive_vector = model._propagator_ir(23)
+    assert massive_vector.gauge == "unitary"
+    assert massive_vector.mass_class == "massive"
+    assert massive_vector.goldstone_policy == "absorbed"
+    assert massive_vector.mass_parameter is None
+    assert massive_vector.denominator == ("momentum_squared-mass_squared+i*mass*width")
+
+    auxiliary = model._propagator_ir(-21)
+    assert auxiliary.applies_propagator is False
+    assert auxiliary.kind == "identity"
+    assert auxiliary.mass_class == "not-applicable"
+    assert auxiliary.basis == "auxiliary:antisymmetric-tensor"
+    assert auxiliary.auxiliary_policy == "antisymmetric-tensor"
+    assert PropagatorIR.from_json_dict(massive_vector.to_json_dict()) == massive_vector
+
+
+def test_external_self_conjugate_fermion_source_fails_clearly() -> None:
+    majorana = _compiled_particle("neutral_fermion", "neutral_fermion", 810_003)
+    model = _external_catalog(majorana)
+
+    with pytest.raises(ValueError, match="unsupported self-conjugate fermion source"):
+        model.source_orientation(810_003)
+
+
+def test_schema_v3_projects_source_relation() -> None:
+    model = BuiltinSMModel()
+    schema = build_runtime_schema(
+        compile_generic_dag(build_process_ir("d d~ > z"), model=model),
+        model,
+        process_id="source_orientation",
+    )
+    plan = _execution_plan(schema)
+
+    sources = plan["source_fill"]["sources"]
+    by_particle = {source["particle_id"]: source for source in sources}
+    assert by_particle[-1]["anti_particle_id"] == 1
+    assert by_particle[-1]["source_orientation"] == "antiparticle"
+    assert by_particle[1]["anti_particle_id"] == -1
+    assert by_particle[1]["source_orientation"] == "particle"
+    assert by_particle[23]["anti_particle_id"] == 23
+    assert by_particle[23]["source_orientation"] == "self-conjugate"
+    assert by_particle[1]["source_basis"] == "weyl-chiral"
+    assert by_particle[1]["source_ir"]["identity"]["display_name"] == "d"
+    assert by_particle[1]["applied_crossing"] == {
+        "momentum_transform": "negate-four-momentum",
+        "helicity_factor": 1,
+        "chirality_factor": -1,
+        "spin_state_factor": -1,
+        "phase": [1.0, 0.0],
+    }
+
+
+def test_schema_v3_projects_antiparticle_mass_metadata() -> None:
+    model = BuiltinSMModel()
+    schema = build_runtime_schema(
+        compile_generic_dag(build_process_ir("d u~ > w-"), model=model),
+        model,
+        process_id="antiparticle_mass",
+    )
+    plan = _execution_plan(schema)
+
+    source = next(
+        item for item in plan["source_fill"]["sources"] if item["particle_id"] == -24
+    )
+    mass_record = next(item for item in plan["model"]["particles"] if item["pdg"] == 24)
+
+    assert source["anti_particle_id"] == 24
+    assert source["source_orientation"] == "antiparticle"
+    assert mass_record["mass"] == pytest.approx(80.41900244575616)
+
+
+@pytest.mark.parametrize(
+    ("particle_id", "source_orientation", "expected"),
+    (
+        (810_001, "antiparticle", _antiquark_weyl),
+        (-810_001, "particle", _quark_weyl),
+    ),
+)
+def test_exact_sources_use_orientation_instead_of_pdg_sign(
+    particle_id: int,
+    source_orientation: str,
+    expected: object,
+) -> None:
+    point = ((Decimal(5), Decimal(3), Decimal(4), Decimal(0)),)
+    source = _exact_source(
+        particle_id=particle_id,
+        anti_particle_id=-particle_id,
+        source_orientation=source_orientation,
+    )
+    schema = {"model": {"particles": []}, "model_parameters": []}
+
+    wave = _source_wavefunction(source, point, schema, ())
+
+    assert callable(expected)
+    assert wave == expected(point[0], 1, 1)
+
+
+def test_exact_source_applies_declared_crossing_phase() -> None:
+    point = ((Decimal(5), Decimal(3), Decimal(4), Decimal(0)),)
+    source = _exact_source(
+        particle_id=810_001,
+        anti_particle_id=-810_001,
+        source_orientation="particle",
+    )
+    crossing = {
+        "momentum_transform": "negate-four-momentum",
+        "helicity_factor": 1,
+        "chirality_factor": 1,
+        "spin_state_factor": 1,
+        "phase": [0.0, 1.0],
+    }
+    source["side"] = "initial"
+    source["crossing"] = "negate-incoming-momentum"
+    source["source_ir"]["crossing"] = crossing
+    source["applied_crossing"] = crossing
+    schema = {"model": {"particles": []}, "model_parameters": []}
+
+    wave = _source_wavefunction(source, point, schema, ())
+
+    crossed_momentum = tuple(-component for component in point[0])
+    unphased = _quark_weyl(crossed_momentum, 1, 1)
+    assert wave == tuple((-imaginary, real) for real, imaginary in unphased)
+
+
+def test_exact_source_mass_uses_explicit_antiparticle_relation() -> None:
+    schema = {
+        "model": {
+            "particles": [
+                {"pdg": -810_001, "mass": "99"},
+                {"pdg": 910_002, "mass_parameter": "MX", "mass": "5"},
+            ]
+        },
+        "model_parameters": [{"name": "MX", "parameter_index": 0}],
+    }
+
+    mass = _particle_mass(schema, 810_001, 910_002, (Decimal(7),))
+
+    assert mass == Decimal(7)
+
+
+def test_exact_self_conjugate_fermion_source_fails_clearly() -> None:
+    source = _exact_source(
+        particle_id=810_003,
+        anti_particle_id=810_003,
+        source_orientation="self-conjugate",
+    )
+    point = ((Decimal(5), Decimal(3), Decimal(4), Decimal(0)),)
+    schema = {"model": {"particles": []}, "model_parameters": []}
+
+    with pytest.raises(CompatibilityError, match="self-conjugate fermion source"):
+        _source_wavefunction(source, point, schema, ())
+
+
+def test_exact_source_rejects_inconsistent_orientation_relation() -> None:
+    source = _exact_source(
+        particle_id=810_003,
+        anti_particle_id=810_004,
+        source_orientation="self-conjugate",
+    )
+    point = ((Decimal(5), Decimal(3), Decimal(4), Decimal(0)),)
+    schema = {"model": {"particles": []}, "model_parameters": []}
+
+    with pytest.raises(ArtifactError, match="inconsistent with its antiparticle"):
+        _source_wavefunction(source, point, schema, ())
diff --git a/pyamplicol/tests/unit/test_stage_exact_weights.py b/pyamplicol/tests/unit/test_stage_exact_weights.py
new file mode 100644
index 0000000000..5ec912dedc
--- /dev/null
+++ b/pyamplicol/tests/unit/test_stage_exact_weights.py
@@ -0,0 +1,134 @@
+# SPDX-License-Identifier: 0BSD
+"""Binary64 metadata must not round exact symbolic kernel coefficients."""
+
+from fractions import Fraction
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.generation import stage_expressions
+from pyamplicol.generation.stage_parameters import _apply_contraction_coefficient
+from pyamplicol.models.expressions import _exact_complex_expression
+
+
+def _expected(value):
+    from symbolica import E
+
+    return E(str(Fraction(value.real))) + E("1i") * E(str(Fraction(value.imag)))
+
+
+@pytest.mark.parametrize("value", (0j, 1 + 0j, -1 + 0j, 1j, -1j, 0.1 + 0.2j))
+def test_exact_complex_weight_preserves_stored_binary64_value(value):
+    from symbolica import E
+
+    exact = _exact_complex_expression(value)
+    assert (exact - _expected(value)).expand() == E("0")
+    assert _exact_complex_expression(value) is exact
+    if value == 0.1 + 0.2j:
+        assert exact != E("1/10+1i/5")
+
+
+@pytest.mark.parametrize("weight", (-1 + 0j, 1j, -1j, 0.1 + 0.2j))
+@pytest.mark.parametrize("source", ("x/3", "x/3+y/6", "(x/3+y/6)*z"))
+def test_root_and_contraction_weights_keep_rational_coefficients(weight, source):
+    from symbolica import E
+
+    expression = E(source)
+    expected = _expected(weight) * expression
+    pair = (weight.real, weight.imag)
+    for actual in (
+        stage_expressions._apply_amplitude_color_weight(pair, expression),
+        _apply_contraction_coefficient(pair, expression),
+    ):
+        assert (actual - expected).expand() == E("0")
+    numeric = _apply_contraction_coefficient(pair, 2.0)
+    assert isinstance(numeric, complex | float)
+    assert numeric == weight * 2.0
+
+
+def _fixture(monkeypatch, *, factor, weight):
+    from symbolica import E
+
+    currents = tuple(
+        SimpleNamespace(
+            index=SimpleNamespace(particle_id=1, chirality=0, momentum_mask=index),
+            dimension=1,
+        )
+        for index in range(3)
+    )
+    interaction = SimpleNamespace(
+        evaluation_group_id=7,
+        evaluation_factor=(factor.real, factor.imag),
+        color_weight=(weight.real, weight.imag),
+        left_id=0,
+        right_id=1,
+        result_id=2,
+        vertex_kind=1,
+        vertex_particles=(1, 1, 1),
+        coupling=(1.0, 0.0),
+    )
+    dag = SimpleNamespace(currents=currents, interactions=(interaction,))
+    model = SimpleNamespace(
+        vertex_component_expression=lambda *args, **kwargs: (E("x/3"),)
+    )
+    monkeypatch.setattr(
+        stage_expressions, "_runtime_coupling_parameter_names", lambda *a, **kw: ()
+    )
+    return dag, model
+
+
+@pytest.mark.parametrize("factor", (-1 + 0j, 1j, 0.1 + 0.2j))
+def test_compact_reused_evaluation_keeps_exact_normalization(monkeypatch, factor):
+    from symbolica import E
+
+    weight = 0.3 + 0.4j
+    dag, model = _fixture(monkeypatch, factor=factor, weight=weight)
+    cache = {}
+    arguments = dict(
+        value_components_by_slot_id={0: (), 1: ()},
+        input_value_slot_by_current_id={0: 0, 1: 1},
+        momentum_components_by_slot_id={0: (), 1: ()},
+        momentum_slot_by_mask={0: 0, 1: 1},
+        model_parameter_symbols={},
+        coupling_cache={},
+        evaluation_cache=cache,
+    )
+    actual = stage_expressions._compact_interaction_contribution(
+        dag, model, 0, **arguments
+    )
+    assert (actual[0] - _expected(weight) * E("x/3")).expand() == E("0")
+    assert (cache[7][0] - E("x/3") / _expected(factor)).expand() == E("0")
+    # A shared cached kernel must multiply the two exact factors separately,
+    # without first rounding their product as a Python complex number.
+    cache[7] = (E("x/3"),)
+    actual = stage_expressions._compact_interaction_contribution(
+        dag, model, 0, **arguments
+    )
+    expected = _expected(weight) * _expected(factor) * E("x/3")
+    assert (actual[0] - expected).expand() == E("0")
+
+
+def test_legacy_interaction_color_weight_keeps_rational_coefficients(monkeypatch):
+    from symbolica import E
+
+    dag, model = _fixture(monkeypatch, factor=1 + 0j, weight=-1 + 0j)
+    interaction = {
+        "left_value_slot": {"value_slot_id": 0},
+        "right_value_slot": {"value_slot_id": 1},
+        "momentum_slots": {"left": 0, "right": 1},
+        "left_current_id": 0,
+        "right_current_id": 1,
+        "result_current_id": 2,
+        "vertex_kind": 1,
+        "coupling": (1.0, 0.0),
+        "color_weight": (-1.0, 0.0),
+    }
+    result = stage_expressions._interaction_contribution(
+        dag,
+        model,
+        interaction,
+        value_components_by_slot_id={0: (), 1: ()},
+        momentum_components_by_slot_id={0: (), 1: ()},
+        model_parameter_symbols={},
+    )
+    assert (result[0] + E("x/3")).expand() == E("0")
diff --git a/pyamplicol/tests/unit/test_stage_settings.py b/pyamplicol/tests/unit/test_stage_settings.py
new file mode 100644
index 0000000000..024c300a9c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_stage_settings.py
@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from pyamplicol.evaluators import SymbolicaEvaluatorSettings
+from pyamplicol.generation.stage_settings import _stage_symbolica_settings
+
+
+def _stage(*, slot_width: int, stage_kind: str = "current-combine") -> object:
+    return SimpleNamespace(
+        stage_kind=stage_kind,
+        output_length=1024,
+        output_slots=(
+            SimpleNamespace(
+                component_start=0,
+                component_stop=slot_width,
+                output_start=0,
+                output_stop=16 * slot_width,
+            ),
+        ),
+    )
+
+
+def test_high_rank_current_stage_caps_native_output_chunks_at_256() -> None:
+    settings = SymbolicaEvaluatorSettings(compiled_output_chunk_size=512)
+
+    effective = _stage_symbolica_settings(
+        _stage(slot_width=16),
+        None,
+        settings,
+    )
+
+    assert effective.compiled_output_chunk_size == 256
+
+
+def test_standard_current_and_amplitude_stages_retain_requested_chunk_size() -> None:
+    settings = SymbolicaEvaluatorSettings(compiled_output_chunk_size=512)
+
+    vector = _stage_symbolica_settings(_stage(slot_width=4), None, settings)
+    auxiliary_tensor = _stage_symbolica_settings(
+        _stage(slot_width=6),
+        None,
+        settings,
+    )
+    amplitude = _stage_symbolica_settings(
+        _stage(slot_width=16, stage_kind="amplitude"),
+        None,
+        settings,
+    )
+
+    assert vector.compiled_output_chunk_size == 512
+    assert auxiliary_tensor.compiled_output_chunk_size == 512
+    assert amplitude.compiled_output_chunk_size == 512
diff --git a/pyamplicol/tests/unit/test_structural_source_proof.py b/pyamplicol/tests/unit/test_structural_source_proof.py
new file mode 100644
index 0000000000..4e738e3871
--- /dev/null
+++ b/pyamplicol/tests/unit/test_structural_source_proof.py
@@ -0,0 +1,145 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import io
+import json
+from copy import deepcopy
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.generation.evaluator_container import (
+    PacbinMemberKind,
+    PacbinMemberSource,
+    write_pacbin_atomic,
+)
+from pyamplicol.generation.structural_source_proof import (
+    _payload_paths,
+    build_generation_structural_proof,
+    validate_generation_structural_proof,
+)
+
+REVISION = "a" * 40
+NATIVE_INPUTS = "b" * 64
+
+
+def _fixture(root: Path) -> tuple[dict[str, object], dict[str, object]]:
+    execution: dict[str, object] = {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-execution",
+        "key": "process",
+        "process": "d d~ > z",
+        "color_accuracy": "lc",
+        "external_pdg_order": [1, -1, 23],
+        "compiled": {
+            "stage_evaluators": {
+                "application_path": "processes/process/stage.symjit",
+                "settings": {"compiler_path": "/usr/bin/c++"},
+            }
+        },
+        "runtime_schema": {
+            "source_fill": {"source_count": 3},
+            "amplitude_stage": {"output_count": 1},
+            "stages": [{"interaction_count": 7}],
+        },
+        "dag_summary": {
+            "source_count": 3,
+            "current_count": 5,
+            "interaction_count": 7,
+            "interaction_evaluation_count": 6,
+            "amplitude_root_count": 1,
+        },
+    }
+    execution_path = "processes/process/execution.json"
+    concrete = root / execution_path
+    concrete.parent.mkdir(parents=True)
+    concrete.write_text(json.dumps(execution, sort_keys=True))
+    container = root / "evaluators.pacbin"
+    index = write_pacbin_atomic(
+        container,
+        [
+            PacbinMemberSource(
+                "processes/process/stage.symjit",
+                PacbinMemberKind.SYMJIT_APPLICATION,
+                io.BytesIO(b"compiled evaluator"),
+            )
+        ],
+    )
+    proof = build_generation_structural_proof(
+        artifact_root=root,
+        process_id="process",
+        source_revision=REVISION,
+        native_build_inputs_sha256=NATIVE_INPUTS,
+        execution_path=execution_path,
+        execution_sha256=hashlib.sha256(concrete.read_bytes()).hexdigest(),
+        execution=execution,
+        evaluator_container_path="evaluators.pacbin",
+        evaluator_container_index_sha256=index.index_sha256,
+    )
+    return execution, proof
+
+
+def test_generation_proof_authenticates_semantics_lanes_and_pacbin(
+    tmp_path: Path,
+) -> None:
+    execution, proof = _fixture(tmp_path)
+
+    assert (
+        validate_generation_structural_proof(
+            proof,
+            artifact_root=tmp_path,
+            expected_process_id="process",
+            expected_source_revision=REVISION,
+            expected_native_build_inputs_sha256=NATIVE_INPUTS,
+            execution=execution,
+        )
+        == proof
+    )
+    inventory = proof["physical_lane_inventory"]
+    assert inventory["pacbin_members"] == [
+        {
+            "kind": "symjit_application",
+            "length": 18,
+            "logical_path": "processes/process/stage.symjit",
+            "sha256": hashlib.sha256(b"compiled evaluator").hexdigest(),
+        }
+    ]
+    assert inventory["lanes"][0]["structural_metrics"]
+
+
+def test_generation_proof_rejects_semantic_and_member_tampering(
+    tmp_path: Path,
+) -> None:
+    execution, proof = _fixture(tmp_path)
+    changed = deepcopy(proof)
+    changed["semantic_maps"]["current_member_map"]["rows"][0]["value"] = 99
+    with pytest.raises(ValueError, match="semantic maps do not recompute"):
+        validate_generation_structural_proof(
+            changed,
+            artifact_root=tmp_path,
+            expected_process_id="process",
+            expected_source_revision=REVISION,
+            execution=execution,
+        )
+
+    (tmp_path / "evaluators.pacbin").write_bytes(b"changed")
+    with pytest.raises(ValueError, match="pacbin container changed"):
+        validate_generation_structural_proof(
+            proof,
+            artifact_root=tmp_path,
+            expected_process_id="process",
+            expected_source_revision=REVISION,
+            execution=execution,
+        )
+
+
+def test_generation_proof_keeps_payload_paths_confined() -> None:
+    assert _payload_paths(
+        {
+            "application_path": "processes/process/stage.symjit",
+            "compiler_path": "/usr/bin/c++",
+        }
+    ) == ("processes/process/stage.symjit",)
+    with pytest.raises(ValueError, match="execution payload path is not confined"):
+        _payload_paths({"application_path": "/outside/stage.symjit"})
diff --git a/pyamplicol/tests/unit/test_structural_work_certificate.py b/pyamplicol/tests/unit/test_structural_work_certificate.py
new file mode 100644
index 0000000000..731ac3284d
--- /dev/null
+++ b/pyamplicol/tests/unit/test_structural_work_certificate.py
@@ -0,0 +1,591 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tools.developer.structural_work_certificate import (
+    StructuralWorkError,
+    adjacent_multiplicity_census,
+    certify,
+    require_static_template_materialization_parity,
+    static_template_materialization_census,
+)
+
+
+def _legacy(
+    root: Path,
+    *,
+    module_currents: int = 406,
+    module_interactions: int = 2440,
+    retained_colors: int = 720,
+    generated_modules: int = 6,
+) -> Path:
+    library = root / "contracted-generated-library" / "Library"
+    library.mkdir(parents=True)
+    probe = (
+        root / "contracted-generated-library" / "amplicol_color_library_probe.output"
+    )
+    probe.write_text(
+        "Total number of currents, vertices and amplitudes after filter"
+        f" 1597 4260 {retained_colors}\n"
+    )
+    for index in range(generated_modules):
+        (library / f"amp{index + 1}_1_lib.f03").write_text(
+            f"complex(kind=8),dimension(1:6,{module_currents}) :: val_c\n"
+            f"complex(kind=8),dimension(1:6,{module_interactions}) :: int_c\n"
+        )
+    return root
+
+
+def _candidate(
+    root: Path,
+    payload: dict[str, object],
+    *,
+    external_count: int = 7,
+) -> Path:
+    process = root / "processes" / "g_g_to_g_g_g_g_g"
+    process.mkdir(parents=True)
+    common = {
+        "external_pdg_order": [21] * external_count,
+        "color_accuracy": "full",
+        "process": "g_g_to_g_g_g_g_g",
+    }
+    (process / "execution.json").write_text(json.dumps(common | payload))
+    return root
+
+
+@pytest.mark.parametrize(
+    "payload,mode",
+    [
+        (
+            {
+                "kind": "pyamplicol-runtime-recurrence-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "schedule": {
+                            "current_count": 101_942,
+                            "contribution_count": 955_368,
+                        },
+                        "construction": {
+                            "peak_current_count": 372_422,
+                            "peak_contribution_count": 4_868_016,
+                            "peak_contribution_count_semantics": (
+                                "resident-pending-contributions-v1"
+                            ),
+                        },
+                    }
+                },
+            },
+            "recurrence",
+        ),
+        (
+            {
+                "kind": "pyamplicol-runtime-execution",
+                "helicity_sum_execution": {
+                    "dag_summary": {
+                        "current_count": 90_000,
+                        "interaction_count": 900_000,
+                    }
+                },
+            },
+            "compiled",
+        ),
+        (
+            {
+                "kind": "pyamplicol-runtime-eager-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "current_count": 90_000,
+                        "attachment_count": 900_000,
+                    }
+                },
+            },
+            "eager",
+        ),
+    ],
+)
+def test_certifies_all_generation_modes(
+    tmp_path: Path,
+    payload: dict[str, object],
+    mode: str,
+) -> None:
+    certificate = certify(
+        _legacy(tmp_path / "legacy"),
+        _candidate(tmp_path / "candidate", payload),
+    )
+    assert certificate.status == "ok"
+    assert certificate.candidate.mode == mode
+    assert certificate.legacy.replay_current_count == 406 * 720
+    assert certificate.legacy.replay_interaction_count == 2440 * 720
+    assert certificate.final_work_comparison.classification == "proven-recycling"
+    assert certificate.final_work_comparison.current_savings_fraction > 0.0
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {
+            "kind": "pyamplicol-runtime-recurrence-execution",
+            "plan": {
+                "inspection_summary": {
+                    "schedule": {
+                        "current_count": int(406 * 720 * 1.05) + 1,
+                        "contribution_count": 2440 * 720,
+                    },
+                    "construction": {
+                        "peak_current_count": 406 * 720 + 1,
+                        "peak_contribution_count": 2440 * 720,
+                        "peak_contribution_count_semantics": (
+                            "resident-pending-contributions-v1"
+                        ),
+                    },
+                }
+            },
+        },
+        {
+            "kind": "pyamplicol-runtime-execution",
+            "helicity_sum_execution": {
+                "dag_summary": {
+                    "current_count": int(406 * 720 * 1.05) + 1,
+                    "interaction_count": 2440 * 720,
+                }
+            },
+        },
+        {
+            "kind": "pyamplicol-runtime-eager-execution",
+            "plan": {
+                "inspection_summary": {
+                    "current_count": int(406 * 720 * 1.05) + 1,
+                    "attachment_count": 2440 * 720,
+                }
+            },
+        },
+    ],
+)
+def test_rejects_final_work_above_legacy_replay(
+    tmp_path: Path,
+    payload: dict[str, object],
+) -> None:
+    with pytest.raises(
+        StructuralWorkError,
+        match="final current work exceeds legacy replay",
+    ):
+        certify(
+            _legacy(tmp_path / "legacy"),
+            _candidate(tmp_path / "candidate", payload),
+        )
+
+
+def test_accepts_only_bounded_unproven_structural_tolerance(
+    tmp_path: Path,
+) -> None:
+    replay_currents = 406 * 720
+    certificate = certify(
+        _legacy(tmp_path / "legacy"),
+        _candidate(
+            tmp_path / "candidate",
+            {
+                "kind": "pyamplicol-runtime-execution",
+                "helicity_sum_execution": {
+                    "dag_summary": {
+                        "current_count": replay_currents + 1,
+                        "interaction_count": 2440 * 720,
+                    }
+                },
+            },
+        ),
+    )
+    assert (
+        certificate.final_work_comparison.classification
+        == "within-structural-tolerance"
+    )
+    with pytest.raises(StructuralWorkError, match="unreviewed final-work budget"):
+        certify(
+            _legacy(tmp_path / "legacy-too-wide"),
+            _candidate(
+                tmp_path / "candidate-too-wide",
+                {
+                    "kind": "pyamplicol-runtime-execution",
+                    "helicity_sum_execution": {
+                        "dag_summary": {
+                            "current_count": 1,
+                            "interaction_count": 1,
+                        }
+                    },
+                },
+            ),
+            max_final_to_legacy=1.051,
+        )
+
+
+def test_adjacent_multiplicity_census_normalizes_candidate_growth(
+    tmp_path: Path,
+) -> None:
+    lower = certify(
+        _legacy(
+            tmp_path / "legacy-n4",
+            module_currents=188,
+            module_interactions=816,
+            retained_colors=120,
+            generated_modules=5,
+        ),
+        _candidate(
+            tmp_path / "candidate-n4",
+            {
+                "kind": "pyamplicol-runtime-recurrence-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "schedule": {
+                            "current_count": 8_372,
+                            "contribution_count": 57_720,
+                        },
+                        "construction": {
+                            "peak_current_count": 26_052,
+                            "peak_contribution_count": 255_600,
+                            "peak_contribution_count_semantics": (
+                                "resident-pending-contributions-v1"
+                            ),
+                        },
+                    }
+                },
+            },
+            external_count=6,
+        ),
+    )
+    higher = certify(
+        _legacy(tmp_path / "legacy-n5"),
+        _candidate(
+            tmp_path / "candidate-n5",
+            {
+                "kind": "pyamplicol-runtime-recurrence-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "schedule": {
+                            "current_count": 101_942,
+                            "contribution_count": 955_368,
+                        },
+                        "construction": {
+                            "peak_current_count": 372_422,
+                            "peak_contribution_count": 4_868_016,
+                            "peak_contribution_count_semantics": (
+                                "resident-pending-contributions-v1"
+                            ),
+                        },
+                    }
+                },
+            },
+        ),
+    )
+    census = adjacent_multiplicity_census(lower, higher)
+    assert census.status == "ok"
+    assert census.mode == "recurrence"
+    assert (census.lower_n_final, census.higher_n_final) == (4, 5)
+    assert census.normalized_current_growth < 1.0
+    assert census.normalized_interaction_growth < 1.0
+    assert census.normalized_peak_current_growth is not None
+    assert census.normalized_peak_current_growth < 1.25
+
+
+def test_n5_static_template_census_exposes_cold_generation_excess(
+    tmp_path: Path,
+) -> None:
+    certificate = certify(
+        _legacy(tmp_path / "legacy"),
+        _candidate(
+            tmp_path / "candidate",
+            {
+                "kind": "pyamplicol-runtime-recurrence-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "schedule": {
+                            "current_count": 101_942,
+                            "contribution_count": 955_368,
+                        },
+                        "construction": {
+                            "peak_current_count": 372_422,
+                            "peak_contribution_count": 4_868_016,
+                            "peak_contribution_count_semantics": (
+                                "resident-pending-contributions-v1"
+                            ),
+                        },
+                    }
+                },
+            },
+        ),
+    )
+    census = static_template_materialization_census(certificate)
+    assert census.status == "exceeds-budget"
+    assert census.legacy_generated_module_count == 6
+    assert census.legacy_static_current_count == 2_436
+    assert census.legacy_static_interaction_count == 14_640
+    assert census.legacy_replay_multiplicity_per_module == 120
+    assert census.candidate_final_current_ratio == pytest.approx(101_942 / 2_436)
+    assert census.candidate_final_interaction_ratio == pytest.approx(955_368 / 14_640)
+    assert census.candidate_peak_current_ratio == pytest.approx(372_422 / 2_436)
+    assert census.candidate_peak_interaction_ratio == pytest.approx(4_868_016 / 14_640)
+    assert census.violations == (
+        "final currents exceed legacy static-template budget",
+        "final interactions exceed legacy static-template budget",
+        "peak currents exceed legacy static-template budget",
+        "peak interactions exceed legacy static-template budget",
+    )
+    with pytest.raises(
+        StructuralWorkError,
+        match="final currents exceed legacy static-template budget",
+    ):
+        require_static_template_materialization_parity(certificate)
+
+
+def test_n5_resident_construction_peak_fits_static_template_budget(
+    tmp_path: Path,
+) -> None:
+    certificate = certify(
+        _legacy(tmp_path / "legacy"),
+        _candidate(
+            tmp_path / "candidate",
+            {
+                "kind": "pyamplicol-runtime-recurrence-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "schedule": {
+                            "current_count": 1_795,
+                            "contribution_count": 9_990,
+                        },
+                        "construction": {
+                            "peak_current_count": 2_430,
+                            "peak_contribution_count": 11_597,
+                            "peak_contribution_count_semantics": (
+                                "resident-pending-contributions-v1"
+                            ),
+                        },
+                    }
+                },
+            },
+        ),
+    )
+    construction = certificate.recurrence_construction
+    assert construction is not None
+    assert construction.peak_contribution_count == 11_597
+    census = require_static_template_materialization_parity(certificate)
+    assert census.status == "ok"
+    assert census.candidate_peak_current_count == 2_430
+    assert census.candidate_peak_interaction_count == 11_597
+
+
+def test_n5_resident_construction_peak_rejects_one_row_above_budget(
+    tmp_path: Path,
+) -> None:
+    certificate = certify(
+        _legacy(tmp_path / "legacy"),
+        _candidate(
+            tmp_path / "candidate",
+            {
+                "kind": "pyamplicol-runtime-recurrence-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "schedule": {
+                            "current_count": 1_795,
+                            "contribution_count": 9_990,
+                        },
+                        "construction": {
+                            "peak_current_count": 2_366,
+                            "peak_contribution_count": 15_373,
+                            "peak_contribution_count_semantics": (
+                                "resident-pending-contributions-v1"
+                            ),
+                        },
+                    }
+                },
+            },
+        ),
+    )
+    census = static_template_materialization_census(certificate)
+    assert census.status == "exceeds-budget"
+    assert census.violations == (
+        "peak interactions exceed legacy static-template budget",
+    )
+
+
+@pytest.mark.parametrize(
+    "payload,mode",
+    [
+        (
+            {
+                "kind": "pyamplicol-runtime-recurrence-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "schedule": {
+                            "current_count": 2_436,
+                            "contribution_count": 14_640,
+                        },
+                        "construction": {
+                            "peak_current_count": 2_436,
+                            "peak_contribution_count": 14_640,
+                            "peak_contribution_count_semantics": (
+                                "resident-pending-contributions-v1"
+                            ),
+                        },
+                    }
+                },
+            },
+            "recurrence",
+        ),
+        (
+            {
+                "kind": "pyamplicol-runtime-execution",
+                "helicity_sum_execution": {
+                    "dag_summary": {
+                        "current_count": 2_436,
+                        "interaction_count": 14_640,
+                    }
+                },
+            },
+            "compiled",
+        ),
+        (
+            {
+                "kind": "pyamplicol-runtime-eager-execution",
+                "plan": {
+                    "inspection_summary": {
+                        "current_count": 2_436,
+                        "attachment_count": 14_640,
+                    }
+                },
+            },
+            "eager",
+        ),
+    ],
+)
+def test_static_template_parity_gate_covers_all_generation_modes(
+    tmp_path: Path,
+    payload: dict[str, object],
+    mode: str,
+) -> None:
+    certificate = certify(
+        _legacy(tmp_path / "legacy"),
+        _candidate(tmp_path / "candidate", payload),
+    )
+    census = require_static_template_materialization_parity(certificate)
+    assert census.status == "ok"
+    assert census.mode == mode
+    assert census.candidate_final_current_ratio == 1.0
+    assert census.candidate_final_interaction_ratio == 1.0
+    if mode == "recurrence":
+        assert census.candidate_peak_current_ratio == 1.0
+        assert census.candidate_peak_interaction_ratio == 1.0
+    else:
+        assert census.candidate_peak_current_ratio is None
+        assert census.candidate_peak_interaction_ratio is None
+
+
+def test_static_template_census_requires_integral_color_replay(
+    tmp_path: Path,
+) -> None:
+    certificate = certify(
+        _legacy(
+            tmp_path / "legacy",
+            retained_colors=720,
+            generated_modules=7,
+        ),
+        _candidate(
+            tmp_path / "candidate",
+            {
+                "kind": "pyamplicol-runtime-execution",
+                "helicity_sum_execution": {
+                    "dag_summary": {
+                        "current_count": 1,
+                        "interaction_count": 1,
+                    }
+                },
+            },
+        ),
+    )
+    with pytest.raises(
+        StructuralWorkError,
+        match="not an integer multiple",
+    ):
+        static_template_materialization_census(certificate)
+
+
+def test_rejects_ambiguous_legacy_recurrence_construction_peak(
+    tmp_path: Path,
+) -> None:
+    payload = {
+        "kind": "pyamplicol-runtime-recurrence-execution",
+        "plan": {
+            "inspection_summary": {
+                "schedule": {
+                    "current_count": 10,
+                    "contribution_count": 10,
+                },
+                "construction": {
+                    "peak_current_count": 10,
+                    "peak_contribution_count": 10,
+                },
+            }
+        },
+    }
+
+    with pytest.raises(
+        StructuralWorkError,
+        match="authenticated resident peak-contribution semantics",
+    ):
+        certify(
+            _legacy(tmp_path / "legacy"),
+            _candidate(tmp_path / "candidate", payload),
+        )
+
+
+def test_rejects_recurrence_construction_inflation(tmp_path: Path) -> None:
+    payload = {
+        "kind": "pyamplicol-runtime-recurrence-execution",
+        "plan": {
+            "inspection_summary": {
+                "schedule": {
+                    "current_count": 10,
+                    "contribution_count": 10,
+                },
+                "construction": {
+                    "peak_current_count": 100,
+                    "peak_contribution_count": 100,
+                    "peak_contribution_count_semantics": (
+                        "resident-pending-contributions-v1"
+                    ),
+                },
+            }
+        },
+    }
+    with pytest.raises(
+        StructuralWorkError,
+        match="peak/final construction current ratio exceeds budget",
+    ):
+        certify(
+            _legacy(tmp_path / "legacy"),
+            _candidate(tmp_path / "candidate", payload),
+        )
+
+
+def test_rejects_nonuniform_legacy_modules(tmp_path: Path) -> None:
+    legacy = _legacy(tmp_path / "legacy")
+    module = legacy / "contracted-generated-library" / "Library" / "amp2_1_lib.f03"
+    module.write_text(
+        "complex(kind=8),dimension(1:6,407) :: val_c\n"
+        "complex(kind=8),dimension(1:6,2440) :: int_c\n"
+    )
+    candidate = _candidate(
+        tmp_path / "candidate",
+        {
+            "kind": "pyamplicol-runtime-eager-execution",
+            "plan": {
+                "inspection_summary": {
+                    "current_count": 1,
+                    "attachment_count": 1,
+                }
+            },
+        },
+    )
+    with pytest.raises(StructuralWorkError, match="do not share one replay shape"):
+        certify(legacy, candidate)
diff --git a/pyamplicol/tests/unit/test_symbol_registry_thread_safety.py b/pyamplicol/tests/unit/test_symbol_registry_thread_safety.py
new file mode 100644
index 0000000000..4e0874ac48
--- /dev/null
+++ b/pyamplicol/tests/unit/test_symbol_registry_thread_safety.py
@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
+from threading import Barrier, Lock
+from time import sleep
+
+import pytest
+
+import pyamplicol._internal.physics.symbols as symbols_module
+from pyamplicol.models.builtin.symbols import BuiltinSymbolRegistry
+
+
+def test_builtin_lowering_vocabulary_is_not_on_shared_registry() -> None:
+    shared = symbols_module.SymbolRegistry()
+    builtin = BuiltinSymbolRegistry()
+
+    for name in (
+        "two_gluon_to_tensor_name",
+        "tensor_gluon_to_gluon_name",
+        "gluon_tensor_to_gluon_name",
+        "quark_vector_weyl_plus_name",
+        "quark_vector_weyl_minus_name",
+        "matrix_element_plan",
+    ):
+        assert not hasattr(shared, name)
+    assert builtin.two_gluon_to_tensor_name == "pyamplicol::two_gluon_to_tensor"
+    assert builtin.quark_vector_weyl_plus_name == (
+        "pyamplicol::quark_vector_weyl_plus"
+    )
+
+
+def test_tensor_canonization_indices_use_the_shared_namespace() -> None:
+    index = symbols_module.SymbolRegistry().canonical_tensor_index(
+        "c",
+        "adjoint",
+        3,
+    )
+
+    assert index.to_canonical_string() == (
+        "pyamplicol::canonical_tensor_index::c::adjoint::{}::i3"
+    )
+
+
+def test_symbol_construction_is_serialized_and_cached(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    participants = 24
+    start = Barrier(participants)
+    observations_lock = Lock()
+    calls: list[tuple[str, bool]] = []
+    active = 0
+    max_active = 0
+
+    def fake_symbol(name: str, *, is_real: bool) -> object:
+        nonlocal active, max_active
+        with observations_lock:
+            calls.append((name, is_real))
+            active += 1
+            max_active = max(max_active, active)
+        sleep(0.01)
+        value = object()
+        with observations_lock:
+            active -= 1
+        return value
+
+    monkeypatch.setattr(symbols_module, "_construct_symbol", fake_symbol)
+    registry = symbols_module.SymbolRegistry(namespace="thread_safety_test")
+    model_registry = registry.model("thread-safety-test")
+    cache_keys = (
+        (registry.qualified_name("shared_complex"), False),
+        (registry.qualified_name("shared_real"), True),
+        (model_registry.qualified_name("shared"), False),
+    )
+    for key in cache_keys:
+        symbols_module._SYMBOL_CACHE.pop(key, None)
+
+    def construct(index: int) -> object:
+        start.wait(timeout=5)
+        operation = index % 3
+        if operation == 0:
+            return registry.symbol("shared_complex")
+        if operation == 1:
+            return registry.real_symbol("shared_real")
+        return model_registry.symbol("shared")
+
+    with ThreadPoolExecutor(max_workers=participants) as executor:
+        results = list(executor.map(construct, range(participants)))
+
+    assert max_active == 1
+    assert Counter(calls) == Counter(
+        {
+            (registry.qualified_name("shared_complex"), False): 1,
+            (registry.qualified_name("shared_real"), True): 1,
+            (model_registry.qualified_name("shared"), False): 1,
+        }
+    )
+    assert len({id(result) for result in results}) == 3
+    for key in cache_keys:
+        symbols_module._SYMBOL_CACHE.pop(key, None)
diff --git a/pyamplicol/tests/unit/test_symbolica_compile.py b/pyamplicol/tests/unit/test_symbolica_compile.py
new file mode 100644
index 0000000000..b5a7cea6e5
--- /dev/null
+++ b/pyamplicol/tests/unit/test_symbolica_compile.py
@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import pytest
+
+import pyamplicol.evaluators.symbolica_compile as symbolica_compile
+from pyamplicol.evaluators.symbolica_settings import SymbolicaEvaluatorSettings
+
+
+@pytest.mark.parametrize("merge", [False, True])
+@pytest.mark.parametrize("chunk_size", [None, 1])
+def test_named_functions_are_inlined_with_tags_and_closed_parameters(
+    monkeypatch: pytest.MonkeyPatch, merge: bool, chunk_size: int | None
+) -> None:
+    from symbolica import S
+
+    x, unused, closed, argument, function, tagged = S(
+        "compile_x",
+        "compile_unused",
+        "compile_closed",
+        "compile_argument",
+        "compile_function",
+        "compile_tagged",
+    )
+    finalized: list[Any] = []
+    finalize = symbolica_compile._finalize_symbolica_evaluator
+
+    def record_finalized(evaluator: Any, *args: Any, **kwargs: Any) -> Any:
+        finalized.append(evaluator)
+        return finalize(evaluator, *args, **kwargs)
+
+    monkeypatch.setattr(
+        symbolica_compile, "_finalize_symbolica_evaluator", record_finalized
+    )
+    evaluator = symbolica_compile._compile_symbolica_outputs(
+        (function(x), tagged(7, x) + 1),
+        [x, unused, closed],
+        functions={
+            (function, (argument,)): argument**2 + closed,
+            (tagged(7), (argument,)): function(argument) + argument,
+        },
+        merge_evaluators_strategy=merge,
+        verbose_evaluator_build=False,
+        jit_compile=False,
+        symbolica_settings=SymbolicaEvaluatorSettings(
+            iterations=1,
+            n_cores=1,
+            compiled_output_chunk_size=chunk_size,
+        ),
+    )
+    rows = np.asarray([[2, 99, 3], [1 + 2j, -11, 4]], dtype=np.complex128)
+    actual = evaluator.evaluate_complex(rows)
+    expected_first = rows[:, 0] ** 2 + rows[:, 2]
+    expected = np.column_stack((expected_first, expected_first + rows[:, 0] + 1))
+
+    np.testing.assert_array_equal(actual, expected)
+    assert len(finalized) == (1 if chunk_size is None else 2)
+    for compiled in finalized:
+        assert compiled.get_instructions().sub_evaluators == []
diff --git a/pyamplicol/tests/unit/test_symbolica_exact.py b/pyamplicol/tests/unit/test_symbolica_exact.py
new file mode 100644
index 0000000000..2deec269f0
--- /dev/null
+++ b/pyamplicol/tests/unit/test_symbolica_exact.py
@@ -0,0 +1,1765 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+import json
+from decimal import ROUND_UP, Decimal, localcontext
+from types import MethodType, SimpleNamespace
+
+import pytest
+
+from pyamplicol.api.errors import ArtifactError, CompatibilityError
+from pyamplicol.runtime._normalization_exact import _pi
+from pyamplicol.runtime.symbolica_exact import (
+    SymbolicaExactExecutor,
+    _apply_lc_replay_input_mapping,
+    _apply_lc_replay_resolved,
+    _canonical_amplitude_outputs,
+    _decimal,
+    _diagnostic_schema_mass_bindings,
+    _exact_helicity_plan,
+    _ExactEvaluator,
+    _ExactExpressionEvaluator,
+    _ExactRuntimeSourceState,
+    _fill_sources_with_states,
+    _lc_replay_plan,
+    _reduce_materialized_helicity,
+    _reduce_resolved,
+    _upcast_decimal,
+    _validated_color_contraction_entries,
+    _working_precision,
+)
+
+
+class _DiagnosticNativeRuntime:
+    def __init__(self, values: tuple[float, ...]) -> None:
+        self._values = values
+
+    def _exact_runtime_state_json(self) -> str:
+        return json.dumps(
+            {
+                "model_parameter_values": self._values,
+                "normalization_factor": 1.0,
+            }
+        )
+
+
+def _diagnostic_schema() -> dict[str, object]:
+    return {
+        "model": {
+            "particles": [
+                {"pdg": 6, "mass": 173.0, "mass_parameter": "ufo.MT"},
+                {"pdg": 21, "mass": 0.0, "mass_parameter": None},
+            ]
+        },
+        "model_parameters": [
+            {"name": "ufo.MT", "parameter_index": 0},
+        ],
+    }
+
+
+def _diagnostic_physics() -> dict[str, object]:
+    return {
+        "external_particles": [
+            {"label": 1, "pdg": 21, "role": "initial"},
+            {"label": 2, "pdg": 6, "role": "final"},
+        ]
+    }
+
+
+def test_binary64_decimal_tag_preserves_exact_float_value() -> None:
+    parsed = _decimal("binary64:3fb999999999999a", "test scalar")
+
+    assert parsed == Decimal.from_float(0.1)
+    assert parsed != Decimal("0.1")
+
+
+def test_diagnostic_projection_uses_current_ufo_mass_and_input_order() -> None:
+    executor = object.__new__(SymbolicaExactExecutor)
+    schema = _diagnostic_schema()
+    physics = _diagnostic_physics()
+    executor._native_runtime = _DiagnosticNativeRuntime((7.0,))
+    executor._execution = {"runtime_schema": schema}
+    executor._physics = physics
+    executor._primary_execution = executor._execution
+    executor._primary_physics = physics
+    # Artifact order is (top, gluon); native physics is already caller order.
+    executor._permutation = (1, 0)
+
+    original = (
+        (
+            (-5.0, 0.0, 0.0, 5.0),
+            (24.9, 24.0, 0.0, 0.0),
+        ),
+    )
+    projected, metadata = executor._diagnostic_project_onshell(
+        original,
+        precision=200,
+    )
+
+    assert projected[0][0] == (
+        Decimal("-5"),
+        Decimal("0.0"),
+        Decimal("0.0"),
+        Decimal("5.0"),
+    )
+    assert projected[0][1] == (
+        Decimal("25.0"),
+        Decimal("24.0"),
+        Decimal("0.0"),
+        Decimal("0.0"),
+    )
+    assert metadata["precision_digits"] == 200
+    assert metadata["working_precision_digits"] == 208
+    assert metadata["spatial_components_unchanged"] is True
+    assert metadata["global_rebalance_applied"] is False
+    assert metadata["unchanged"] is False
+    point = metadata["points"][0]
+    assert point["global_residual_before"] != point["global_residual_after"]
+    gluon, top = point["legs"]
+    assert gluon["pdg"] == 21
+    assert gluon["projected_energy"] == "-5.0"
+    assert top["pdg"] == 6
+    assert top["mass"] == "7.0"
+    assert top["mass_parameter"] == "ufo.MT"
+    assert top["mass_authority"] == ("authenticated-current-runtime-model-parameter")
+    assert Decimal(top["shell_residual_after"]) == 0
+
+
+def test_diagnostic_schema_mass_binding_rejects_missing_parameter() -> None:
+    schema = _diagnostic_schema()
+    schema["model_parameters"] = []
+
+    with pytest.raises(ArtifactError, match="does not have one authenticated binding"):
+        _diagnostic_schema_mass_bindings(
+            schema,
+            _diagnostic_physics(),
+            (Decimal("7"),),
+        )
+
+
+class _RecordingEvaluator:
+    def __init__(self) -> None:
+        self.values: object = None
+        self.precision: int | None = None
+        self.result = (Decimal("1.25"), Decimal("-0.5"))
+
+    def evaluate_complex_with_prec(
+        self, values: object, precision: int
+    ) -> list[SimpleNamespace]:
+        self.values = values
+        self.precision = precision
+        return [SimpleNamespace(to_decimal_tuple=lambda: self.result)]
+
+
+def test_upcast_decimal_preserves_value_and_carries_requested_precision() -> None:
+    cases = (
+        Decimal("500"),
+        Decimal("0.00123"),
+        Decimal("1e100"),
+        Decimal("-7.25"),
+    )
+
+    for value in cases:
+        upcast = _upcast_decimal(value, 40)
+        assert upcast == value
+        assert len(upcast.as_tuple().digits) == 40
+
+    zero = _upcast_decimal(Decimal("0"), 40)
+    assert zero == 0
+    assert zero.as_tuple().exponent == -40
+
+
+def test_exact_evaluator_upcasts_every_complex_input() -> None:
+    recording = _RecordingEvaluator()
+    evaluator = _ExactEvaluator(input_len=2, evaluator=recording)
+
+    result = evaluator.evaluate(
+        ((Decimal("500"), Decimal("0")), (Decimal("0.125"), Decimal("-2"))),
+        80,
+    )
+
+    assert result == ((Decimal("1.25"), Decimal("-0.5")),)
+    assert recording.precision == 80
+    values = recording.values
+    assert isinstance(values, tuple)
+    for real, imaginary in values:
+        assert isinstance(real, Decimal)
+        assert isinstance(imaginary, Decimal)
+        assert len(real.as_tuple().digits) == 80 or real.is_zero()
+        assert len(imaginary.as_tuple().digits) == 80 or imaginary.is_zero()
+
+
+def test_exact_chunked_evaluator_selects_parent_inputs() -> None:
+    first = _RecordingEvaluator()
+    second = _RecordingEvaluator()
+    evaluator = _ExactEvaluator(
+        input_len=3,
+        chunks=(
+            _ExactEvaluator(input_len=2, evaluator=first),
+            _ExactEvaluator(input_len=1, evaluator=second),
+        ),
+        chunk_input_indices=((0, 2), (1,)),
+    )
+
+    result = evaluator.evaluate(
+        (
+            (Decimal("1"), Decimal("0")),
+            (Decimal("10"), Decimal("0")),
+            (Decimal("3"), Decimal("0")),
+        ),
+        40,
+    )
+
+    assert result == (
+        (Decimal("1.25"), Decimal("-0.5")),
+        (Decimal("1.25"), Decimal("-0.5")),
+    )
+    assert first.values is not None
+    assert second.values is not None
+    assert tuple(value[0] for value in first.values) == (Decimal("1"), Decimal("3"))
+    assert tuple(value[0] for value in second.values) == (Decimal("10"),)
+
+
+@pytest.mark.parametrize("precision", (32, 80))
+def test_exact_evaluator_converts_complex_float_without_decimal_rounding(
+    precision: int,
+) -> None:
+    recording = _RecordingEvaluator()
+    recording.result = (
+        Decimal("1.234567890123456789012345678901234567890123456789"),
+        Decimal("-0"),
+    )
+    evaluator = _ExactEvaluator(input_len=0, evaluator=recording)
+
+    with localcontext() as context:
+        context.prec = 6
+        result = evaluator.evaluate((), precision)[0]
+
+    assert result[0] is recording.result[0]
+    assert result[1] is recording.result[1]
+    assert result[1].is_signed()
+
+
+def test_exact_parameter_derivation_converts_complex_float_for_both_arithmetics(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import symbolica
+
+    recording = _RecordingEvaluator()
+    recording.result = (
+        Decimal("1.234567890123456789012345678901234567890123456789"),
+        Decimal("-0"),
+    )
+    expression = SimpleNamespace(
+        evaluate=lambda *_args, **_kwargs: SimpleNamespace(
+            to_decimal_tuple=lambda: recording.result
+        ),
+        evaluator=lambda *_args, **_kwargs: recording,
+    )
+    monkeypatch.setattr(symbolica, "E", lambda _text: expression)
+    evaluator = _ExactExpressionEvaluator(("constant",), ())
+
+    with localcontext() as context:
+        context.prec = 6
+        arbitrary = evaluator.evaluate((), 80)[0]
+        double_double = evaluator.evaluate_double_double(())[0]
+
+    for result in (arbitrary, double_double):
+        assert result[0] is recording.result[0]
+        assert result[1] is recording.result[1]
+        assert result[1].is_signed()
+    assert recording.precision == 32
+
+
+def test_exact_pi_converts_complex_float_without_decimal_rounding(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import symbolica
+
+    expected = Decimal("3.14159265358979323846264338327950288419716939937510")
+    calls: list[tuple[object, int]] = []
+
+    def evaluate(constants: object, *, decimal_digit_precision: int) -> SimpleNamespace:
+        calls.append((constants, decimal_digit_precision))
+        return SimpleNamespace(to_decimal_tuple=lambda: (expected, Decimal(0)))
+
+    monkeypatch.setattr(
+        symbolica, "E", lambda _text: SimpleNamespace(evaluate=evaluate)
+    )
+    _pi.cache_clear()
+    try:
+        with localcontext() as context:
+            context.prec = 6
+            assert _pi(80) is expected
+        assert calls == [({}, 80)]
+    finally:
+        _pi.cache_clear()
+
+
+def test_exact_amplitude_outputs_follow_plane_arena_bindings() -> None:
+    outputs = tuple((Decimal(index), Decimal(-index)) for index in range(4))
+    stage = {
+        "output_length": 4,
+        "compiled_plane_arena": {
+            "output_bindings": [
+                {"output_index": 0, "arena": "amplitude", "component": 0},
+                {"output_index": 1, "arena": "amplitude", "component": 2},
+                {"output_index": 2, "arena": "amplitude", "component": 1},
+                {"output_index": 3, "arena": "amplitude", "component": 3},
+            ]
+        },
+    }
+
+    assert _canonical_amplitude_outputs(outputs, stage) == (
+        outputs[0],
+        outputs[2],
+        outputs[1],
+        outputs[3],
+    )
+
+
+def test_exact_amplitude_outputs_fall_back_to_output_slots() -> None:
+    outputs = tuple((Decimal(index), Decimal(-index)) for index in range(3))
+    stage = {
+        "output_length": 3,
+        "output_slots": [
+            {
+                "output_start": 0,
+                "output_stop": 1,
+                "component_start": 2,
+                "component_stop": 3,
+            },
+            {
+                "output_start": 1,
+                "output_stop": 3,
+                "component_start": 0,
+                "component_stop": 2,
+            },
+        ],
+    }
+
+    assert _canonical_amplitude_outputs(outputs, stage) == (
+        outputs[1],
+        outputs[2],
+        outputs[0],
+    )
+
+
+def test_exact_amplitude_outputs_reject_non_permutation() -> None:
+    outputs = (
+        (Decimal(1), Decimal(0)),
+        (Decimal(2), Decimal(0)),
+    )
+    stage = {
+        "output_length": 2,
+        "compiled_plane_arena": {
+            "output_bindings": [
+                {"output_index": 0, "arena": "amplitude", "component": 0},
+                {"output_index": 1, "arena": "amplitude", "component": 0},
+            ]
+        },
+    }
+
+    with pytest.raises(ArtifactError, match="not a permutation"):
+        _canonical_amplitude_outputs(outputs, stage)
+
+
+def test_upcast_rounding_does_not_depend_on_ambient_decimal_context() -> None:
+    with localcontext() as context:
+        context.rounding = ROUND_UP
+        assert _upcast_decimal(Decimal("1.25"), 2) == Decimal("1.2")
+
+
+def test_every_exact_request_stays_above_symbolica_binary64_shortcut() -> None:
+    assert all(_working_precision(precision) >= 40 for precision in range(1, 40))
+    assert _working_precision(80) == 88
+
+
+def _replay_metadata() -> tuple[dict[str, object], dict[str, object]]:
+    execution: dict[str, object] = {
+        "compiled": {
+            "lc_topology_replay": {
+                "enabled": True,
+                "mode": "external-label-permutation",
+                "replayed_sector_count": 2,
+                "groups": [
+                    {
+                        "sector_permutations": [
+                            {"weight": 2.0, "label_permutation": []},
+                            {
+                                "weight": 1.0,
+                                "label_permutation": [
+                                    {
+                                        "representative_label": 3,
+                                        "sector_label": 4,
+                                    },
+                                    {
+                                        "representative_label": 4,
+                                        "sector_label": 3,
+                                    },
+                                ],
+                            },
+                        ]
+                    }
+                ],
+            }
+        }
+    }
+    physics: dict[str, object] = {
+        "color_accuracy": "lc",
+        "external_particles": [{}, {}, {}, {}],
+        "helicities": [
+            {
+                "id": "h:+1,-1,+1,-1",
+                "values": [1, -1, 1, -1],
+                "coefficient": 1.0,
+            },
+            {
+                "id": "h:+1,-1,-1,+1",
+                "values": [1, -1, -1, 1],
+                "coefficient": 1.0,
+            },
+        ],
+        "color_components": [
+            {
+                "kind": "lc-flow",
+                "id": "flow:1,2,3,4",
+                "word": [1, 2, 3, 4],
+                "coefficient": 1.0,
+            },
+            {
+                "kind": "lc-flow",
+                "id": "flow:1,4,3,2",
+                "word": [1, 4, 3, 2],
+                "coefficient": 1.0,
+            },
+            {
+                "kind": "lc-flow",
+                "id": "flow:1,2,4,3",
+                "word": [1, 2, 4, 3],
+                "coefficient": 1.0,
+            },
+        ],
+        "reduction": {
+            "groups": [
+                {
+                    "physical_helicity_ids": ["h:+1,-1,+1,-1"],
+                    "physical_color_ids": ["flow:1,2,3,4"],
+                }
+            ]
+        },
+    }
+    return execution, physics
+
+
+def _materialized_cell(value: str) -> tuple[tuple[Decimal, ...], ...]:
+    return (
+        (Decimal(value), Decimal(0), Decimal(0)),
+        (Decimal(0), Decimal(0), Decimal(0)),
+    )
+
+
+def test_exact_lc_replay_routes_public_flows_and_selectors() -> None:
+    execution, physics = _replay_metadata()
+    plan = _lc_replay_plan(execution, physics, None)
+    assert plan is not None
+    assert len(plan.entries) == 2
+    materialized = (
+        _materialized_cell("3"),
+        _materialized_cell("5"),
+        _materialized_cell("7"),
+        _materialized_cell("11"),
+    )
+    helicity_ids = ("h:+1,-1,+1,-1", "h:+1,-1,-1,+1")
+    color_ids = ("flow:1,2,3,4", "flow:1,4,3,2", "flow:1,2,4,3")
+    full, _, _ = _apply_lc_replay_resolved(
+        materialized,
+        plan,
+        2,
+        helicity_ids,
+        color_ids,
+        None,
+        None,
+    )
+    assert tuple(
+        sum((value for helicity in point for value in helicity), Decimal(0))
+        for point in full
+    ) == (Decimal(13), Decimal(21))
+
+    values, helicities, colors = _apply_lc_replay_resolved(
+        materialized,
+        plan,
+        2,
+        helicity_ids,
+        color_ids,
+        ("h:+1,-1,-1,+1",),
+        ("flow:1,2,4,3",),
+    )
+
+    assert helicities == ("h:+1,-1,-1,+1",)
+    assert colors == ("flow:1,2,4,3",)
+    assert values == (((Decimal(7),),), ((Decimal(11),),))
+
+    point = tuple(
+        (Decimal(index), Decimal(0), Decimal(0), Decimal(0)) for index in range(4)
+    )
+    assert _apply_lc_replay_input_mapping(point, plan.entries[1].input_mapping) == (
+        point[0],
+        point[1],
+        point[3],
+        point[2],
+    )
+
+
+def test_exact_lc_replay_accepts_eager_execution_contract() -> None:
+    execution, physics = _replay_metadata()
+    compiled = execution.pop("compiled")
+    assert isinstance(compiled, dict)
+    execution["lc_topology_replay"] = compiled["lc_topology_replay"]
+
+    plan = _lc_replay_plan(execution, physics, None)
+
+    assert plan is not None
+    assert len(plan.entries) == 2
+
+
+def test_exact_lc_replay_rejects_disagreeing_execution_lane_mirrors() -> None:
+    execution, physics = _replay_metadata()
+    compiled = execution["compiled"]
+    assert isinstance(compiled, dict)
+    execution["lc_topology_replay"] = {
+        **compiled["lc_topology_replay"],
+        "mode": "different-mode",
+    }
+
+    with pytest.raises(ArtifactError, match="disagrees between execution lanes"):
+        _lc_replay_plan(execution, physics, None)
+
+
+def test_exact_lc_replay_rejects_missing_public_flow_reduction() -> None:
+    execution, physics = _replay_metadata()
+    colors = list(physics["color_components"])  # type: ignore[arg-type]
+    colors.pop(1)
+    physics["color_components"] = colors
+
+    with pytest.raises(CompatibilityError, match="missing replayed LC flow word"):
+        _lc_replay_plan(execution, physics, None)
+
+
+def _six_flow_replay_metadata() -> tuple[dict[str, object], dict[str, object]]:
+    words = (
+        (1, 2, 3, 4),
+        (1, 2, 4, 3),
+        (1, 3, 2, 4),
+        (1, 3, 4, 2),
+        (1, 4, 2, 3),
+        (1, 4, 3, 2),
+    )
+    representative_words = (words[0], words[0], words[2], words[0], words[2], words[0])
+
+    def flow(index: int) -> dict[str, object]:
+        word = words[index]
+        representative = representative_words[index]
+        return {
+            "id": "flow:" + ",".join(map(str, word)),
+            "index": index,
+            "kind": "lc-flow",
+            "word": list(word),
+            "computed": index in {0, 2},
+            "representative_id": "flow:" + ",".join(map(str, representative)),
+            "coefficient": 1.0,
+        }
+
+    identity = [
+        {"representative_label": label, "sector_label": label} for label in range(1, 5)
+    ]
+    swap = [
+        {"representative_label": 1, "sector_label": 1},
+        {"representative_label": 2, "sector_label": 2},
+        {"representative_label": 3, "sector_label": 4},
+        {"representative_label": 4, "sector_label": 3},
+    ]
+    execution: dict[str, object] = {
+        "compiled": {
+            "lc_topology_replay": {
+                "contract_version": 2,
+                "enabled": True,
+                "mode": "external-label-permutation",
+                "physical_sector_count": 3,
+                "replayed_sector_count": 2,
+                "materialized_sector_ids": [0, 2],
+                "residual_sector_ids": [2],
+                "groups": [
+                    {
+                        "active_sector_ids": [0, 1],
+                        "materialized_sector_id": 0,
+                        "representative_sector_id": 0,
+                        "proof": {
+                            "status": "proven",
+                            "algorithm": "canonical-test-proof-v1",
+                            "digest": "a" * 64,
+                        },
+                        "sector_permutations": [
+                            {
+                                "sector_id": 0,
+                                "label_permutation": identity,
+                                "weight": 2.0,
+                                "sign": 1,
+                                "factor": [2.0, 0.0],
+                            },
+                            {
+                                "sector_id": 1,
+                                "label_permutation": swap,
+                                "weight": 2.0,
+                                "sign": 1,
+                                "factor": [2.0, 0.0],
+                            },
+                        ],
+                    }
+                ],
+            }
+        },
+        "runtime_schema": {
+            "amplitude_stage": {
+                "roots": [
+                    {
+                        "root_id": 0,
+                        "output_index": 0,
+                        "coherent_group_id": 0,
+                        "color_sector_id": 0,
+                        "all_sector_weight": 2.0,
+                    },
+                    {
+                        "root_id": 1,
+                        "output_index": 1,
+                        "coherent_group_id": 1,
+                        "color_sector_id": 2,
+                        "all_sector_weight": 2.0,
+                    },
+                ]
+            }
+        },
+    }
+    color_ids = [str(flow(index)["id"]) for index in range(6)]
+    physics: dict[str, object] = {
+        "color_accuracy": "lc",
+        "external_particles": [{}, {}, {}, {}],
+        "helicities": [
+            {
+                "id": "h:+1,-1,+1,+1",
+                "values": [1, -1, 1, 1],
+                "coefficient": 1.0,
+            }
+        ],
+        "color_components": [flow(index) for index in range(6)],
+        "reduction": {
+            "groups": [
+                {
+                    "id": "reduction:0",
+                    "representative_helicity_id": "h:+1,-1,+1,+1",
+                    "representative_color_id": color_ids[0],
+                    "physical_helicity_ids": ["h:+1,-1,+1,+1"],
+                    "physical_color_ids": [color_ids[0], color_ids[5]],
+                },
+                {
+                    "id": "reduction:1",
+                    "representative_helicity_id": "h:+1,-1,+1,+1",
+                    "representative_color_id": color_ids[2],
+                    "physical_helicity_ids": ["h:+1,-1,+1,+1"],
+                    "physical_color_ids": [color_ids[2], color_ids[4]],
+                },
+            ]
+        },
+    }
+    return execution, physics
+
+
+def test_exact_lc_replay_routes_residual_folded_sector_once() -> None:
+    execution, physics = _six_flow_replay_metadata()
+    plan = _lc_replay_plan(execution, physics, None)
+    assert plan is not None
+    assert len(plan.entries) == 2
+    target_indices = [
+        route.target_index for entry in plan.entries for route in entry.routes
+    ]
+    assert sorted(target_indices) == list(range(6))
+    assert {route.weight for entry in plan.entries for route in entry.routes} == {
+        Decimal(1)
+    }
+
+    identity = (
+        (
+            Decimal(3),
+            Decimal(300),
+            Decimal(5),
+            Decimal(700),
+            Decimal(500),
+            Decimal(900),
+        ),
+    )
+    swapped = (
+        (
+            Decimal(7),
+            Decimal(301),
+            Decimal(999),
+            Decimal(701),
+            Decimal(501),
+            Decimal(901),
+        ),
+    )
+    full, helicities, colors = _apply_lc_replay_resolved(
+        (identity, swapped),
+        plan,
+        1,
+        ("h:+1,-1,+1,+1",),
+        tuple(str(record["id"]) for record in physics["color_components"]),
+        None,
+        None,
+    )
+    assert full == (
+        ((Decimal(3), Decimal(7), Decimal(5), Decimal(7), Decimal(5), Decimal(3)),),
+    )
+    assert helicities == ("h:+1,-1,+1,+1",)
+    assert len(colors) == 6
+
+    selected, selected_helicities, selected_colors = _apply_lc_replay_resolved(
+        (identity, swapped),
+        plan,
+        1,
+        ("h:+1,-1,+1,+1",),
+        tuple(str(record["id"]) for record in physics["color_components"]),
+        ("h:+1,-1,+1,+1",),
+        (colors[4],),
+    )
+    assert selected == (((Decimal(5),),),)
+    assert selected_helicities == ("h:+1,-1,+1,+1",)
+    assert selected_colors == (colors[4],)
+
+
+def test_exact_lc_replay_rejects_incorrect_residual_folded_weight() -> None:
+    execution, physics = _six_flow_replay_metadata()
+    execution["runtime_schema"]["amplitude_stage"]["roots"][1]["all_sector_weight"] = (
+        1.0
+    )
+
+    with pytest.raises(ArtifactError, match="covers 5 of 6 public color components"):
+        _lc_replay_plan(execution, physics, None)
+
+
+def _quotient_metadata() -> tuple[dict[str, object], dict[str, object]]:
+    source = {
+        "current_id": 0,
+        "source_id": 0,
+        "leg_label": 1,
+        "source_helicity": -1,
+        "chirality": 0,
+        "spin_state": -1,
+        "side": "final",
+        "particle_id": 1,
+        "anti_particle_id": 1,
+        "source_orientation": "self-conjugate",
+        "wavefunction_kind": "scalar",
+        "dimension": 1,
+        "source_basis": "scalar",
+        "crossing": "identity",
+        "value_slot": {
+            "component_start": 0,
+            "component_stop": 1,
+        },
+        "source_ir": {
+            "basis": "scalar",
+            "component_dimension": 1,
+            "wavefunction_family": "scalar",
+            "identity": {
+                "pdg_label": 1,
+                "anti_pdg_label": 1,
+                "orientation": "self-conjugate",
+            },
+            "crossing": {
+                "momentum_transform": "identity",
+                "helicity_factor": 1,
+                "chirality_factor": 1,
+                "spin_state_factor": 1,
+                "phase": [1.0, 0.0],
+            },
+            "states": [
+                {"helicity": -1, "chirality": 0, "spin_state": -1},
+                {"helicity": 1, "chirality": 0, "spin_state": 1},
+            ],
+        },
+        "applied_crossing": {
+            "momentum_transform": "identity",
+            "helicity_factor": 1,
+            "chirality_factor": 1,
+            "spin_state_factor": 1,
+            "phase": [1.0, 0.0],
+        },
+    }
+    materialization = {
+        "kind": "pyamplicol-helicity-recurrence-materialization",
+        "contract_version": 1,
+        "materialized_current_count": 1,
+        "materialized_root_count": 1,
+        "proof_current_count": 2,
+        "proof_root_count": 2,
+        "proof_to_materialized_current": [0, 0],
+        "selector_schedules": [
+            {
+                "selector_domain_id": 0,
+                "structural_zero": False,
+                "active_current_ids": [0],
+                "active_root_ids": [0],
+            },
+            {
+                "selector_domain_id": 1,
+                "structural_zero": True,
+                "active_current_ids": [],
+                "active_root_ids": [],
+            },
+            {
+                "selector_domain_id": 2,
+                "structural_zero": False,
+                "active_current_ids": [0],
+                "active_root_ids": [0],
+            },
+        ],
+        "source_routes": [
+            {
+                "materialized_current_id": 0,
+                "external_label": 1,
+                "helicity": -1,
+                "chirality": 0,
+                "spin_state": -1,
+                "declared_state_index": 0,
+                "selector_domain_id": 3,
+                "factor": [2.0, 0.0],
+            },
+            {
+                "materialized_current_id": 0,
+                "external_label": 1,
+                "helicity": 1,
+                "chirality": 0,
+                "spin_state": 1,
+                "declared_state_index": 1,
+                "selector_domain_id": 4,
+                "factor": [3.0, 0.0],
+            },
+        ],
+        "amplitude_routes": [
+            {
+                "materialized_root_id": 0,
+                "selector_domain_ids": [0],
+                "factor": [1.0, 0.0],
+                "residual": False,
+            },
+            {
+                "materialized_root_id": 0,
+                "selector_domain_ids": [2],
+                "factor": [0.0, 1.0],
+                "residual": False,
+            },
+        ],
+    }
+    execution: dict[str, object] = {
+        "compiled": {},
+        "runtime_schema": {
+            "source_fill": {"sources": [source]},
+            "amplitude_stage": {
+                "roots": [
+                    {
+                        "root_id": 0,
+                        "output_index": 0,
+                        "coherent_group_id": 0,
+                        "all_sector_weight": 1.0,
+                        "helicity_weight": 1.0,
+                    }
+                ],
+                "color_contraction": None,
+            },
+            "helicity_recurrence": {
+                "contract_version": 1,
+                "selector_domains": [
+                    {
+                        "id": 0,
+                        "complete": True,
+                        "source_states": [{"external_label": 1, "helicity": -1}],
+                    },
+                    {
+                        "id": 1,
+                        "complete": True,
+                        "source_states": [{"external_label": 1, "helicity": 0}],
+                    },
+                    {
+                        "id": 2,
+                        "complete": True,
+                        "source_states": [{"external_label": 1, "helicity": 1}],
+                    },
+                    {
+                        "id": 3,
+                        "complete": False,
+                        "source_states": [{"external_label": 1, "helicity": -1}],
+                    },
+                    {
+                        "id": 4,
+                        "complete": False,
+                        "source_states": [{"external_label": 1, "helicity": 1}],
+                    },
+                ],
+                "materialization": materialization,
+            },
+        },
+    }
+    physics: dict[str, object] = {
+        "color_accuracy": "lc",
+        "external_particles": [{}],
+        "extensions": {"normalization": {"global_coupling_factor": 2}},
+        "helicities": [
+            {
+                "id": "h:-1",
+                "values": [-1],
+                "coefficient": 1.0,
+                "structural_zero": False,
+            },
+            {
+                "id": "h:+0",
+                "values": [0],
+                "coefficient": 0.0,
+                "structural_zero": True,
+            },
+            {
+                "id": "h:+1",
+                "values": [1],
+                "coefficient": 1.0,
+                "structural_zero": False,
+            },
+        ],
+        "color_components": [{"id": "flow:1", "kind": "lc-flow", "coefficient": 1.0}],
+        "reduction": {
+            "groups": [
+                {
+                    "id": "reduction:0",
+                    "physical_helicity_ids": ["h:-1", "h:+1"],
+                    "physical_color_ids": ["flow:1"],
+                }
+            ]
+        },
+    }
+    return execution, physics
+
+
+class _ExactRuntimeState:
+    def _exact_runtime_state_json(self) -> str:
+        return json.dumps({"model_parameter_values": [], "normalization_factor": 2.0})
+
+
+def _synthetic_quotient_executor() -> SymbolicaExactExecutor:
+    execution, physics = _quotient_metadata()
+    executor = object.__new__(SymbolicaExactExecutor)
+    executor._execution = execution
+    executor._physics = physics
+    executor._native_runtime = _ExactRuntimeState()
+    executor._permutation = None
+    executor._lc_replay = None
+    executor._color_replay = None
+    executor._helicity_plan = _exact_helicity_plan(execution, physics, None)
+    executor._stage_evaluators = ()
+    executor._amplitude_evaluator = None
+    executor._load_evaluators = MethodType(lambda _self: None, executor)
+
+    def evaluate_point(
+        _self: SymbolicaExactExecutor,
+        _point: object,
+        _parameters: object,
+        _precision: int,
+        source_states: object = None,
+    ) -> tuple[tuple[Decimal, Decimal], ...]:
+        assert isinstance(source_states, tuple)
+        state = source_states[0]
+        assert isinstance(state, _ExactRuntimeSourceState)
+        return (state.factor,)
+
+    executor._evaluate_point = MethodType(evaluate_point, executor)
+    return executor
+
+
+def test_exact_executor_switches_to_helicity_sum_color_replay(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    primary_execution: dict[str, object] = {"runtime_schema": {}, "compiled": {}}
+    summed_execution: dict[str, object] = {"runtime_schema": {}, "compiled": {}}
+    physics: dict[str, object] = {
+        "color_accuracy": "full",
+        "external_particles": [{}, {}],
+        "extensions": {"normalization": {"global_coupling_factor": 2}},
+        "helicities": [{"id": "h", "values": [1, -1]}],
+        "color_components": [{"id": "contracted"}],
+    }
+    identity = SimpleNamespace(input_mapping=())
+    swapped = SimpleNamespace(input_mapping=((0, 1), (1, 0)))
+    replay = SimpleNamespace(mappings=(identity, swapped))
+    parse_calls: list[tuple[object, object, object]] = []
+
+    def parse_replay(
+        execution: object, selected_physics: object, permutation: object
+    ) -> object:
+        parse_calls.append((execution, selected_physics, permutation))
+        return replay
+
+    monkeypatch.setattr(
+        "pyamplicol.runtime.symbolica_exact.parse_exact_color_topology_replay",
+        parse_replay,
+    )
+    monkeypatch.setattr(
+        "pyamplicol.runtime.symbolica_exact._lc_replay_plan",
+        lambda *_args: None,
+    )
+    monkeypatch.setattr(
+        "pyamplicol.runtime.symbolica_exact._exact_helicity_plan",
+        lambda *_args: None,
+    )
+
+    executor = object.__new__(SymbolicaExactExecutor)
+    executor._execution = primary_execution
+    executor._physics = physics
+    executor._primary_execution = primary_execution
+    executor._primary_physics = physics
+    executor._helicity_sum_execution = summed_execution
+    executor._helicity_sum_physics = physics
+    executor._native_runtime = _ExactRuntimeState()
+    executor._permutation = None
+    executor._lc_replay = None
+    executor._color_replay = None
+    executor._helicity_plan = None
+    executor._stage_evaluators = ()
+    executor._amplitude_evaluator = None
+    executor._load_evaluators = MethodType(lambda _self: None, executor)
+    evaluated_points: list[object] = []
+
+    def evaluate_point(
+        _self: SymbolicaExactExecutor,
+        point: object,
+        _parameters: object,
+        _precision: int,
+        _source_states: object = None,
+    ) -> tuple[tuple[Decimal, Decimal], ...]:
+        evaluated_points.append(point)
+        assert isinstance(point, tuple)
+        return ((point[0][0], Decimal(0)),)
+
+    executor._evaluate_point = MethodType(evaluate_point, executor)
+    reduction_calls: list[tuple[object, ...]] = []
+
+    def reduce_replay(*args: object) -> tuple[object, tuple[str, ...], tuple[str, ...]]:
+        reduction_calls.append(args)
+        return (((Decimal(42),),),), ("h",), ("contracted",)
+
+    monkeypatch.setattr(
+        "pyamplicol.runtime.symbolica_exact.reduce_exact_color_topology_replay",
+        reduce_replay,
+    )
+
+    result = executor.evaluate_resolved(
+        (
+            (
+                (1.0, 0.0, 0.0, 1.0),
+                (2.0, 0.0, 0.0, -1.0),
+            ),
+        ),
+        helicities=None,
+        color_flows=None,
+        precision=40,
+    )
+
+    assert executor._execution is summed_execution
+    # Activation checks the gather; evaluation rebinds rational colour weights
+    # inside the requested arithmetic context, not the load-time context.
+    assert parse_calls == [(summed_execution, physics, None)] * 2
+    assert tuple(point[0][0] for point in evaluated_points) == (
+        Decimal(1),
+        Decimal(2),
+    )
+    assert len(reduction_calls) == 1
+    amplitudes, selected_replay, point_count, normalization, selected_h, selected_c = (
+        reduction_calls[0]
+    )
+    assert len(amplitudes) == 2
+    assert selected_replay is replay
+    assert point_count == 1
+    assert normalization == Decimal(2)
+    assert selected_h is None
+    assert selected_c is None
+    assert result.values == (((Decimal(42),),),)
+    assert result.helicity_ids == ("h",)
+    assert result.color_ids == ("contracted",)
+
+
+def test_exact_executor_replays_physical_helicities_and_selectors() -> None:
+    executor = _synthetic_quotient_executor()
+    result = executor.evaluate_resolved(
+        (((1.0, 0.0, 0.0, 0.0),),),
+        helicities=None,
+        color_flows=None,
+        precision=40,
+    )
+
+    assert result.helicity_ids == ("h:-1", "h:+0", "h:+1")
+    assert result.color_ids == ("flow:1",)
+    assert result.values == (
+        (
+            (Decimal(8),),
+            (Decimal(0),),
+            (Decimal(18),),
+        ),
+    )
+    selected = executor.evaluate_resolved(
+        (((1.0, 0.0, 0.0, 0.0),),),
+        helicities=("h:+1",),
+        color_flows=("flow:1",),
+        precision=40,
+    )
+    assert selected.helicity_ids == ("h:+1",)
+    assert selected.values == (((Decimal(18),),),)
+
+
+def test_exact_executor_replays_retained_amplitude_route(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    execution, physics = _quotient_metadata()
+    runtime_schema = execution["runtime_schema"]
+    assert isinstance(runtime_schema, dict)
+    recurrence = runtime_schema["helicity_recurrence"]
+    assert isinstance(recurrence, dict)
+    materialization = recurrence["materialization"]
+    assert isinstance(materialization, dict)
+    amplitude_routes = materialization["amplitude_routes"]
+    assert isinstance(amplitude_routes, list)
+    amplitude_routes[0]["selector_domain_ids"] = [0, 2]
+    del amplitude_routes[1]
+    helicities = physics["helicities"]
+    assert isinstance(helicities, list)
+    helicities[0].update(
+        {
+            "computed": True,
+            "representative_id": "h:-1",
+        }
+    )
+    helicities[1].update(
+        {
+            "computed": False,
+            "representative_id": "h:+0",
+        }
+    )
+    helicities[2].update(
+        {
+            "computed": False,
+            "representative_id": "h:-1",
+        }
+    )
+    executor = _synthetic_quotient_executor()
+    executor._physics = physics
+    executor._helicity_plan = _exact_helicity_plan(execution, physics, None)
+    evaluate_point = executor._evaluate_point
+    evaluation_count = 0
+
+    def counted_evaluate_point(
+        _self: SymbolicaExactExecutor,
+        point: object,
+        parameters: object,
+        precision: int,
+        source_states: object = None,
+    ) -> tuple[tuple[Decimal, Decimal], ...]:
+        nonlocal evaluation_count
+        evaluation_count += 1
+        return evaluate_point(point, parameters, precision, source_states)
+
+    executor._evaluate_point = MethodType(counted_evaluate_point, executor)
+    reduction_indices: list[int] = []
+
+    def recording_reduce(*args: object, **kwargs: object) -> tuple[Decimal, ...]:
+        reduction_indices.append(args[4])
+        return _reduce_materialized_helicity(*args, **kwargs)
+
+    monkeypatch.setattr(
+        "pyamplicol.runtime.symbolica_exact._reduce_materialized_helicity",
+        recording_reduce,
+    )
+
+    result = executor.evaluate_resolved(
+        (((1.0, 0.0, 0.0, 0.0),),),
+        helicities=None,
+        color_flows=None,
+        precision=40,
+    )
+
+    assert result.values == (
+        (
+            (Decimal(8),),
+            (Decimal(0),),
+            (Decimal(8),),
+        ),
+    )
+    assert evaluation_count == 1
+    assert reduction_indices == [0, 0]
+
+    evaluation_count = 0
+    reduction_indices.clear()
+    selected = executor.evaluate_resolved(
+        (((1.0, 0.0, 0.0, 0.0),),),
+        helicities=("h:+1",),
+        color_flows=None,
+        precision=40,
+    )
+    assert selected.helicity_ids == ("h:+1",)
+    assert selected.values == (((Decimal(8),),),)
+    assert evaluation_count == 1
+    assert reduction_indices == [0]
+
+
+def test_exact_executor_does_not_treat_physics_representative_as_execution() -> None:
+    execution, physics = _quotient_metadata()
+    helicities = physics["helicities"]
+    assert isinstance(helicities, list)
+    helicities[0].update(
+        {
+            "computed": True,
+            "representative_id": "h:-1",
+        }
+    )
+    helicities[1].update(
+        {
+            "computed": False,
+            "representative_id": "h:+0",
+        }
+    )
+    helicities[2].update(
+        {
+            "computed": False,
+            "representative_id": "h:-1",
+        }
+    )
+    executor = _synthetic_quotient_executor()
+    executor._physics = physics
+    executor._helicity_plan = _exact_helicity_plan(execution, physics, None)
+    evaluate_point = executor._evaluate_point
+    evaluation_count = 0
+
+    def counted_evaluate_point(
+        _self: SymbolicaExactExecutor,
+        point: object,
+        parameters: object,
+        precision: int,
+        source_states: object = None,
+    ) -> tuple[tuple[Decimal, Decimal], ...]:
+        nonlocal evaluation_count
+        evaluation_count += 1
+        return evaluate_point(point, parameters, precision, source_states)
+
+    executor._evaluate_point = MethodType(counted_evaluate_point, executor)
+
+    result = executor.evaluate_resolved(
+        (((1.0, 0.0, 0.0, 0.0),),),
+        helicities=None,
+        color_flows=None,
+        precision=40,
+    )
+
+    assert result.values == (
+        (
+            (Decimal(8),),
+            (Decimal(0),),
+            (Decimal(18),),
+        ),
+    )
+    assert evaluation_count == 2
+
+
+def test_exact_helicity_plan_rejects_reduction_representative_drift() -> None:
+    execution, physics = _quotient_metadata()
+    helicities = physics["helicities"]
+    assert isinstance(helicities, list)
+    helicities[0].update(
+        {
+            "computed": True,
+            "representative_id": "h:-1",
+        }
+    )
+    helicities[2].update(
+        {
+            "computed": False,
+            "representative_id": "h:-1",
+        }
+    )
+    reduction = physics["reduction"]
+    assert isinstance(reduction, dict)
+    groups = reduction["groups"]
+    assert isinstance(groups, list)
+    groups[0]["representative_helicity_id"] = "h:+1"
+
+    with pytest.raises(
+        ArtifactError,
+        match="representative disagrees with its reduction group",
+    ):
+        _exact_helicity_plan(execution, physics, None)
+
+
+def test_exact_materialized_source_fill_applies_route_factor() -> None:
+    execution, _physics = _quotient_metadata()
+    schema = execution["runtime_schema"]
+    assert isinstance(schema, dict)
+    state = [(Decimal(0), Decimal(0))]
+    _fill_sources_with_states(
+        state,
+        ((Decimal(1), Decimal(0), Decimal(0), Decimal(0)),),
+        schema,
+        (),
+        (_ExactRuntimeSourceState(1, 0, 1, (Decimal(2), Decimal(3))),),
+    )
+    assert state == [(Decimal(2), Decimal(3))]
+
+
+def test_exact_helicity_plan_uses_selected_source_route_in_active_closure() -> None:
+    execution, physics = _quotient_metadata()
+    plan = _exact_helicity_plan(execution, physics, None)
+
+    assert plan is not None
+    state = plan.schedules[2].source_states[0]
+    assert state == _ExactRuntimeSourceState(
+        helicity=1,
+        chirality=0,
+        spin_state=1,
+        factor=(Decimal(3), Decimal(0)),
+    )
+
+
+def test_exact_helicity_plan_recovers_globally_flipped_anchor_from_source_ir() -> None:
+    execution, physics = _quotient_metadata()
+    recurrence = execution["runtime_schema"]["helicity_recurrence"]
+    recurrence["materialization"]["source_routes"] = recurrence["materialization"][
+        "source_routes"
+    ][:1]
+
+    plan = _exact_helicity_plan(execution, physics, None)
+
+    assert plan is not None
+    assert plan.schedules[2].source_states[0] == _ExactRuntimeSourceState(
+        helicity=1,
+        chirality=0,
+        spin_state=1,
+        factor=(Decimal(1), Decimal(0)),
+    )
+
+
+def test_exact_materialized_helicity_distributes_lc_color_weights() -> None:
+    execution, physics = _quotient_metadata()
+    physics["color_components"] = [
+        {"id": "flow:a", "kind": "lc-flow", "coefficient": 1.0},
+        {"id": "flow:b", "kind": "lc-flow", "coefficient": 3.0},
+    ]
+    physics["reduction"] = {
+        "groups": [
+            {
+                "id": "reduction:0",
+                "physical_helicity_ids": ["h:-1"],
+                "physical_color_ids": ["flow:a", "flow:b"],
+            }
+        ]
+    }
+    value = _reduce_materialized_helicity(
+        ((Decimal(2), Decimal(0)),),
+        execution,
+        physics,
+        Decimal(2),
+        0,
+        ((Decimal(1), Decimal(0)),),
+    )
+    assert value == (Decimal(2), Decimal(6))
+
+
+@pytest.mark.parametrize("accuracy", ["nlc", "full"])
+def test_exact_materialized_helicity_applies_color_contraction(
+    accuracy: str,
+) -> None:
+    execution, physics = _quotient_metadata()
+    physics["color_accuracy"] = accuracy
+    physics["color_components"] = [{"id": "contracted", "kind": "contracted"}]
+    physics["reduction"] = {
+        "groups": [
+            {
+                "id": "reduction:0",
+                "physical_helicity_ids": ["h:-1"],
+                "physical_color_ids": ["contracted"],
+            },
+            {
+                "id": "reduction:1",
+                "physical_helicity_ids": ["h:-1"],
+                "physical_color_ids": ["contracted"],
+            },
+        ]
+    }
+    runtime_schema = execution["runtime_schema"]
+    assert isinstance(runtime_schema, dict)
+    amplitude = runtime_schema["amplitude_stage"]
+    assert isinstance(amplitude, dict)
+    amplitude["roots"] = [
+        {
+            "root_id": 0,
+            "output_index": 0,
+            "coherent_group_id": 0,
+            "all_sector_weight": 1.0,
+            "helicity_weight": 1.0,
+        },
+        {
+            "root_id": 1,
+            "output_index": 1,
+            "coherent_group_id": 1,
+            "all_sector_weight": 1.0,
+            "helicity_weight": 1.0,
+        },
+    ]
+    amplitude["color_contraction"] = {
+        "entries": [
+            {
+                "left_group_id": 0,
+                "right_group_id": 1,
+                "weight": [2.0, 0.0],
+                "symmetry_factor": 0.5,
+            }
+        ]
+    }
+    value = _reduce_materialized_helicity(
+        ((Decimal(2), Decimal(1)), (Decimal(3), Decimal(-1))),
+        execution,
+        physics,
+        Decimal(4),
+        0,
+        ((Decimal(1), Decimal(0)), (Decimal(0), Decimal(1))),
+    )
+    assert value == (Decimal(20),)
+
+
+def test_exact_color_contraction_compact_and_expanded_parity() -> None:
+    execution, physics = _quotient_metadata()
+    physics["color_accuracy"] = "full"
+    physics["color_components"] = [{"id": "contracted", "kind": "contracted"}]
+    physics["reduction"] = {
+        "groups": [
+            {
+                "id": "reduction:0",
+                "physical_helicity_ids": ["h:-1"],
+                "physical_color_ids": ["contracted"],
+            },
+            {
+                "id": "reduction:1",
+                "physical_helicity_ids": ["h:+1"],
+                "physical_color_ids": ["contracted"],
+            },
+        ]
+    }
+    runtime_schema = execution["runtime_schema"]
+    assert isinstance(runtime_schema, dict)
+    amplitude = runtime_schema["amplitude_stage"]
+    assert isinstance(amplitude, dict)
+    amplitude["roots"] = [
+        {
+            "root_id": 0,
+            "output_index": 0,
+            "coherent_group_id": 0,
+            "all_sector_weight": 1.0,
+            "helicity_weight": 1.0,
+        },
+        {
+            "root_id": 1,
+            "output_index": 1,
+            "coherent_group_id": 1,
+            "all_sector_weight": 1.0,
+            "helicity_weight": 1.0,
+        },
+    ]
+    expanded = {
+        "group_count": 2,
+        "entries": [
+            {
+                "left_group_id": group_id,
+                "right_group_id": group_id,
+                "weight": [2.0, 0.0],
+                "symmetry_factor": 1.0,
+            }
+            for group_id in range(2)
+        ],
+    }
+    compact = {
+        "group_count": 2,
+        "entries": [],
+        "logical_entry_count": 2,
+        "repeated_block": {
+            "component_count": 2,
+            "component_group_ids": [0, 1],
+            "entries": [
+                {
+                    "left_group_index": 0,
+                    "right_group_index": 0,
+                    "weight": [2.0, 0.0],
+                    "symmetry_factor": 1.0,
+                }
+            ],
+        },
+    }
+    raw_amplitudes = (
+        (Decimal(2), Decimal(1)),
+        (Decimal(3), Decimal(-1)),
+    )
+    root_factors = ((Decimal(1), Decimal(0)),) * 2
+
+    amplitude["color_contraction"] = expanded
+    expanded_materialized = _reduce_materialized_helicity(
+        raw_amplitudes,
+        execution,
+        physics,
+        Decimal(4),
+        0,
+        root_factors,
+    )
+    expanded_resolved = _reduce_resolved(
+        (raw_amplitudes,),
+        execution,
+        physics,
+        Decimal(4),
+        None,
+        None,
+    )
+    amplitude["color_contraction"] = compact
+    compact_materialized = _reduce_materialized_helicity(
+        raw_amplitudes,
+        execution,
+        physics,
+        Decimal(4),
+        0,
+        root_factors,
+    )
+    compact_resolved = _reduce_resolved(
+        (raw_amplitudes,),
+        execution,
+        physics,
+        Decimal(4),
+        None,
+        None,
+    )
+
+    assert compact_materialized == expanded_materialized == (Decimal(40),)
+    assert compact_resolved == expanded_resolved
+
+
+def test_exact_color_contraction_rejects_mixed_storage() -> None:
+    execution, physics = _quotient_metadata()
+    physics["color_accuracy"] = "full"
+    physics["color_components"] = [{"id": "contracted", "kind": "contracted"}]
+    runtime_schema = execution["runtime_schema"]
+    assert isinstance(runtime_schema, dict)
+    amplitude = runtime_schema["amplitude_stage"]
+    assert isinstance(amplitude, dict)
+    amplitude["color_contraction"] = {
+        "group_count": 1,
+        "entries": [
+            {
+                "left_group_id": 0,
+                "right_group_id": 0,
+                "weight": [1.0, 0.0],
+                "symmetry_factor": 1.0,
+            }
+        ],
+        "repeated_block": {
+            "component_count": 2,
+            "component_group_ids": [0, 1],
+            "entries": [],
+        },
+    }
+
+    with pytest.raises(ArtifactError, match="mixes expanded and repeated entries"):
+        _reduce_materialized_helicity(
+            ((Decimal(1), Decimal(0)),),
+            execution,
+            physics,
+            Decimal(1),
+            0,
+            ((Decimal(1), Decimal(0)),),
+        )
+
+
+def test_exact_compact_complex_off_diagonal_entries_match_expanded() -> None:
+    groups = {group_id: object() for group_id in range(4)}
+    expanded = {
+        "entries": [
+            {
+                "left_group_id": left,
+                "right_group_id": right,
+                "weight": [2.0, -0.5],
+                "symmetry_factor": 2.0,
+            }
+            for left, right in ((0, 2), (1, 3))
+        ]
+    }
+    compact = {
+        "group_count": 4,
+        "entries": [],
+        "logical_entry_count": 2,
+        "repeated_block": {
+            "component_count": 2,
+            "component_group_ids": [0, 1, 2, 3],
+            "entries": [
+                {
+                    "left_group_index": 0,
+                    "right_group_index": 1,
+                    "weight": [2.0, -0.5],
+                    "symmetry_factor": 2.0,
+                }
+            ],
+        },
+    }
+
+    assert tuple(_validated_color_contraction_entries(compact, groups)) == tuple(
+        _validated_color_contraction_entries(expanded, groups)
+    )
+
+
+@pytest.mark.parametrize(
+    "factorized_block",
+    [
+        {
+            "kind": "klein-four-walsh",
+            "cosets": [[0, 1, 2, 3]],
+        },
+        {
+            "kind": "elementary-abelian-walsh",
+            "rank": 3,
+            "cosets": [list(range(8))],
+        },
+    ],
+)
+def test_exact_color_contraction_ignores_walsh_acceleration_metadata(
+    factorized_block: dict[str, object],
+) -> None:
+    local_group_count = len(factorized_block["cosets"][0])
+    group_count = 2 * local_group_count
+    groups = {group_id: object() for group_id in range(group_count)}
+    compact = {
+        "group_count": group_count,
+        "entries": [],
+        "logical_entry_count": 2,
+        "repeated_block": {
+            "component_count": 2,
+            "component_group_ids": list(range(group_count)),
+            "entries": [
+                {
+                    "left_group_index": 0,
+                    "right_group_index": 3,
+                    "weight": [2.0, 0.0],
+                    "symmetry_factor": 2.0,
+                }
+            ],
+            "factorized_block": factorized_block,
+        },
+    }
+    without_acceleration = copy.deepcopy(compact)
+    del without_acceleration["repeated_block"]["factorized_block"]
+
+    assert tuple(_validated_color_contraction_entries(compact, groups)) == tuple(
+        _validated_color_contraction_entries(without_acceleration, groups)
+    )
+
+
+def test_exact_helicity_plan_fails_closed_on_inconsistent_routes() -> None:
+    execution, physics = _quotient_metadata()
+    malformed = copy.deepcopy(execution)
+    recurrence = malformed["runtime_schema"]["helicity_recurrence"]
+    recurrence["materialization"]["amplitude_routes"][0]["selector_domain_ids"] = [2]
+
+    with pytest.raises(ArtifactError, match="do not match active roots"):
+        _exact_helicity_plan(malformed, physics, None)
+
+
+@pytest.mark.parametrize(
+    ("domain_ids", "message"),
+    [
+        ([2, 0], "distinct ordered complete selector domains"),
+        ([0, 0], "selector domains are invalid"),
+        ([0, 3], "distinct ordered complete selector domains"),
+    ],
+)
+def test_exact_helicity_plan_requires_ordered_complete_amplitude_route_domains(
+    domain_ids: list[int],
+    message: str,
+) -> None:
+    execution, physics = _quotient_metadata()
+    malformed = copy.deepcopy(execution)
+    recurrence = malformed["runtime_schema"]["helicity_recurrence"]
+    materialization = recurrence["materialization"]
+    materialization["amplitude_routes"][0]["selector_domain_ids"] = domain_ids
+
+    with pytest.raises(ArtifactError, match=message):
+        _exact_helicity_plan(malformed, physics, None)
+
+
+def test_exact_helicity_plan_rejects_conflicting_execution_domains() -> None:
+    execution, physics = _quotient_metadata()
+    malformed = copy.deepcopy(execution)
+    recurrence = malformed["runtime_schema"]["helicity_recurrence"]
+    materialization = recurrence["materialization"]
+    materialization["amplitude_routes"] = [
+        {
+            "materialized_root_id": 0,
+            "selector_domain_ids": [0, 2],
+            "factor": [1.0, 0.0],
+            "residual": False,
+        },
+        {
+            "materialized_root_id": 0,
+            "selector_domain_ids": [1, 2],
+            "factor": [1.0, 0.0],
+            "residual": False,
+        },
+    ]
+
+    with pytest.raises(ArtifactError, match="inconsistent execution domains"):
+        _exact_helicity_plan(malformed, physics, None)
+
+
+def test_exact_helicity_plan_rejects_primary_that_is_replay_only() -> None:
+    execution, physics = _quotient_metadata()
+    malformed = copy.deepcopy(execution)
+    recurrence = malformed["runtime_schema"]["helicity_recurrence"]
+    materialization = recurrence["materialization"]
+    materialization["amplitude_routes"][0]["selector_domain_ids"] = [0, 2]
+
+    with pytest.raises(ArtifactError, match="both a primary and replay-only domain"):
+        _exact_helicity_plan(malformed, physics, None)
+
+
+def test_exact_helicity_plan_wraps_malformed_scalar_metadata() -> None:
+    execution, physics = _quotient_metadata()
+    malformed = copy.deepcopy(execution)
+    recurrence = malformed["runtime_schema"]["helicity_recurrence"]
+    recurrence["materialization"]["source_routes"][0].pop("helicity")
+
+    with pytest.raises(ArtifactError, match="malformed helicity recurrence"):
+        _exact_helicity_plan(malformed, physics, None)
+
+
+def test_exact_helicity_plan_leaves_legacy_artifacts_unchanged() -> None:
+    _execution, physics = _quotient_metadata()
+    assert _exact_helicity_plan({"runtime_schema": {}}, physics, None) is None
+    assert (
+        _exact_helicity_plan(
+            {
+                "runtime_schema": {
+                    "helicity_recurrence": {
+                        "contract_version": 1,
+                        "selector_domains": [],
+                    }
+                }
+            },
+            physics,
+            None,
+        )
+        is None
+    )
diff --git a/pyamplicol/tests/unit/test_symjit_2_22_generated_fixture_gate.py b/pyamplicol/tests/unit/test_symjit_2_22_generated_fixture_gate.py
new file mode 100644
index 0000000000..bf4c41e667
--- /dev/null
+++ b/pyamplicol/tests/unit/test_symjit_2_22_generated_fixture_gate.py
@@ -0,0 +1,628 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from tools.developer import symjit_2_22_generated_fixture_gate as gate
+
+_FIXTURE_NAMES = (
+    "compiled_o3",
+    "eager_o2",
+    "recurrence_topology_o2",
+    "recurrence_union_o2",
+    "contracted_nlc",
+)
+_SOURCE_REVISION = "a" * 40
+_NATIVE_BUILD_INPUTS_SHA256 = "b" * 64
+_CANDIDATE_VERSION = "0.1.0.dev0+candidate.0123456789ab"
+
+
+def _manifest(name: str) -> dict[str, Any]:
+    return {
+        "artifact_id": name,
+        "default_process_id": gate._EXPECTED_PROCESS_ID,
+        "processes": [
+            {
+                "id": gate._EXPECTED_PROCESS_ID,
+                "expression": gate._EXPECTED_PROCESS_EXPRESSION,
+                "external_pdgs": list(gate._EXPECTED_EXTERNAL_PDGS),
+            }
+        ],
+        "producer": {
+            "distribution": "pyamplicol",
+            "git_revision": _SOURCE_REVISION,
+            "native_build_inputs_sha256": _NATIVE_BUILD_INPUTS_SHA256,
+            "version": _CANDIDATE_VERSION,
+        },
+        "extensions": {
+            "artifact_identity": dict(gate._ARTIFACT_IDENTITY_CONTRACT),
+        },
+    }
+
+
+def _build_info(
+    *,
+    source_revision: str = _SOURCE_REVISION,
+    native_build_inputs_sha256: str = _NATIVE_BUILD_INPUTS_SHA256,
+    version: str = _CANDIDATE_VERSION,
+) -> dict[str, Any]:
+    return {
+        "schema_version": 1,
+        "publishable": False,
+        "candidate_fingerprint": version.rsplit("+candidate.", maxsplit=1)[1],
+        "native_build_inputs_sha256": native_build_inputs_sha256,
+        "selftest_fixture_bootstrap": False,
+        "source_checkout": "/workspace/source",
+        "source_revision": source_revision,
+        "version": version,
+    }
+
+
+def _preflight(
+    raw: dict[str, Path],
+    *,
+    workspace_root: Path,
+) -> gate.FixturePaths:
+    return gate.preflight_fixtures(
+        raw,
+        workspace_root=workspace_root,
+        source_revision=_SOURCE_REVISION,
+        native_build_inputs_sha256=_NATIVE_BUILD_INPUTS_SHA256,
+    )
+
+
+def _identity_arguments() -> list[str]:
+    return [
+        "--source-revision",
+        _SOURCE_REVISION,
+        "--native-build-inputs-sha256",
+        _NATIVE_BUILD_INPUTS_SHA256,
+    ]
+
+
+def _workspace(tmp_path: Path) -> tuple[Path, dict[str, Path]]:
+    root = tmp_path / "workspace"
+    root.mkdir()
+    (root / "Cargo.toml").write_text("[workspace]\n", encoding="utf-8")
+    fixtures: dict[str, Path] = {}
+    for name in _FIXTURE_NAMES:
+        artifact = root / "fixtures" / name
+        artifact.mkdir(parents=True)
+        (artifact / "artifact.json").write_text(
+            json.dumps(_manifest(name)),
+            encoding="utf-8",
+        )
+        fixtures[name] = artifact
+    return root, fixtures
+
+
+def _execution_paths(root: Path) -> dict[str, Path]:
+    state = root / ".artifacts" / "gate-state"
+    return {
+        "cargo_home": state / "cargo-home",
+        "cargo_target_dir": state / "cargo-target",
+        "tmpdir": state / "tmp",
+        "pip_cache_dir": state / "pip-cache",
+        "xdg_cache_home": state / "xdg-cache",
+        "python_cache_prefix": state / "python-cache",
+    }
+
+
+def test_preflight_requires_distinct_workspace_local_artifact_manifests(
+    tmp_path: Path,
+) -> None:
+    root, fixtures = _workspace(tmp_path)
+    resolved = _preflight(fixtures, workspace_root=root)
+    assert resolved.as_dict() == fixtures
+
+    missing_manifest = root / "fixtures" / "missing-manifest"
+    missing_manifest.mkdir()
+    invalid = dict(fixtures)
+    invalid["compiled_o3"] = missing_manifest
+    with pytest.raises(gate.GateError, match=r"missing artifact\.json"):
+        _preflight(invalid, workspace_root=root)
+
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    (outside / "artifact.json").write_text("{}", encoding="utf-8")
+    invalid = dict(fixtures)
+    invalid["compiled_o3"] = outside
+    with pytest.raises(gate.GateError, match="workspace-local"):
+        _preflight(invalid, workspace_root=root)
+
+    duplicate = dict(fixtures)
+    duplicate["compiled_o3"] = duplicate["eager_o2"]
+    with pytest.raises(gate.GateError, match="distinct artifact directories"):
+        _preflight(duplicate, workspace_root=root)
+
+
+@pytest.mark.parametrize("fixture_name", _FIXTURE_NAMES)
+def test_preflight_authenticates_the_producer_of_every_fixture_role(
+    fixture_name: str,
+    tmp_path: Path,
+) -> None:
+    root, fixtures = _workspace(tmp_path)
+    manifest = fixtures[fixture_name] / "artifact.json"
+    payload = json.loads(manifest.read_text(encoding="utf-8"))
+    payload["producer"]["git_revision"] = "c" * 40
+    manifest.write_text(json.dumps(payload), encoding="utf-8")
+
+    with pytest.raises(gate.GateError, match="producer git_revision"):
+        _preflight(fixtures, workspace_root=root)
+
+
+def test_preflight_requires_exact_candidate_and_z6g_identity(
+    tmp_path: Path,
+) -> None:
+    root, fixtures = _workspace(tmp_path)
+    manifest = fixtures["compiled_o3"] / "artifact.json"
+
+    invalid = _manifest("compiled_o3")
+    invalid["producer"]["version"] = "0.1.0"
+    manifest.write_text(json.dumps(invalid), encoding="utf-8")
+    with pytest.raises(gate.GateError, match="not a candidate build"):
+        _preflight(fixtures, workspace_root=root)
+
+    invalid = _manifest("compiled_o3")
+    invalid["producer"]["native_build_inputs_sha256"] = "c" * 64
+    manifest.write_text(json.dumps(invalid), encoding="utf-8")
+    with pytest.raises(
+        gate.GateError,
+        match="producer native_build_inputs_sha256",
+    ):
+        _preflight(fixtures, workspace_root=root)
+
+    invalid = _manifest("compiled_o3")
+    invalid["processes"][0]["expression"] = "u u~ > z g g g g g g"
+    manifest.write_text(json.dumps(invalid), encoding="utf-8")
+    with pytest.raises(gate.GateError, match="exact Z\\+6g fixture"):
+        _preflight(fixtures, workspace_root=root)
+
+    invalid = _manifest("compiled_o3")
+    invalid["processes"][0]["external_pdgs"] = [
+        2,
+        -2,
+        23,
+        21,
+        21,
+        21,
+        21,
+        21,
+        21,
+    ]
+    manifest.write_text(json.dumps(invalid), encoding="utf-8")
+    with pytest.raises(gate.GateError, match="exact Z\\+6g fixture"):
+        _preflight(fixtures, workspace_root=root)
+
+    invalid = _manifest("compiled_o3")
+    invalid["default_process_id"] = "not-the-z6g-process"
+    manifest.write_text(json.dumps(invalid), encoding="utf-8")
+    with pytest.raises(gate.GateError, match="default_process_id"):
+        _preflight(fixtures, workspace_root=root)
+
+
+def test_preflight_rejects_unauthenticated_identity_arguments(
+    tmp_path: Path,
+) -> None:
+    root, fixtures = _workspace(tmp_path)
+
+    with pytest.raises(gate.GateError, match="lowercase 40-digit hex"):
+        gate.preflight_fixtures(
+            fixtures,
+            workspace_root=root,
+            source_revision="A" * 40,
+            native_build_inputs_sha256=_NATIVE_BUILD_INPUTS_SHA256,
+        )
+    with pytest.raises(gate.GateError, match="lowercase 64-digit hex"):
+        gate.preflight_fixtures(
+            fixtures,
+            workspace_root=root,
+            source_revision=_SOURCE_REVISION,
+            native_build_inputs_sha256="b" * 63,
+        )
+
+
+def test_execution_paths_are_workspace_local_and_preflight_does_not_create_them(
+    tmp_path: Path,
+) -> None:
+    root, _ = _workspace(tmp_path)
+    raw = _execution_paths(root)
+
+    paths = gate.preflight_execution_paths(raw, workspace_root=root)
+
+    assert paths.as_dict() == raw
+    assert all(not path.exists() for path in raw.values())
+
+    invalid = dict(raw)
+    invalid["tmpdir"] = tmp_path / "outside-tmp"
+    with pytest.raises(gate.GateError, match="workspace-local"):
+        gate.preflight_execution_paths(invalid, workspace_root=root)
+
+
+def test_environment_uses_every_audited_fixture_mapping(tmp_path: Path) -> None:
+    root, raw = _workspace(tmp_path)
+    fixtures = _preflight(raw, workspace_root=root)
+
+    assert gate.artifact_environment(fixtures) == {
+        "RUSTICOL_COMPILED_DIRECT_ARTIFACT": str(raw["compiled_o3"]),
+        "RUSTICOL_COMPILED_ARTIFACT": str(raw["compiled_o3"]),
+        "RUSTICOL_TEST_COMPILED_REPLAY_QUICK_ARTIFACT": str(raw["compiled_o3"]),
+        "RUSTICOL_SELECTOR_ARTIFACT": str(raw["compiled_o3"]),
+        "RUSTICOL_EAGER_ARTIFACT": str(raw["eager_o2"]),
+        "RUSTICOL_RECURRENCE_ARTIFACT": str(raw["recurrence_topology_o2"]),
+        "RUSTICOL_RECURRENCE_TOPOLOGY_ALLOCATION_ARTIFACT": str(
+            raw["recurrence_topology_o2"]
+        ),
+        "RUSTICOL_RECURRENCE_UNION_ALLOCATION_ARTIFACT": str(
+            raw["recurrence_union_o2"]
+        ),
+        "RUSTICOL_RECURRENCE_CONTRACTED_ALLOCATION_ARTIFACT": str(
+            raw["contracted_nlc"]
+        ),
+        "RUSTICOL_CONTRACTED_SELECTOR_ARTIFACT": str(raw["contracted_nlc"]),
+    }
+
+
+def test_execution_creates_local_state_and_exports_the_required_environment(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    root, raw_fixtures = _workspace(tmp_path)
+    fixtures = _preflight(raw_fixtures, workspace_root=root)
+    raw_execution = _execution_paths(root)
+    execution = gate.preflight_execution_paths(
+        raw_execution,
+        workspace_root=root,
+    )
+    command = gate.GateCommand(
+        label="mock focused gate",
+        arguments=("cargo", "test"),
+        expected_tests=("required_test",),
+    )
+    calls: list[dict[str, object]] = []
+
+    class Completed:
+        returncode = 0
+        stdout = "test required_test ... ok\n"
+
+    def run(*args: object, **kwargs: object) -> Completed:
+        del args
+        calls.append(kwargs)
+        return Completed()
+
+    monkeypatch.setattr(gate.subprocess, "run", run)
+
+    gate.run_commands(
+        (command,),
+        environment=gate.artifact_environment(fixtures),
+        execution_paths=execution,
+        workspace_root=root,
+    )
+
+    assert all(path.is_dir() for path in raw_execution.values())
+    child_environment = calls[0]["env"]
+    assert isinstance(child_environment, dict)
+    assert child_environment["PYAMPLICOL_REQUIRE_NATIVE_TESTS"] == "1"
+    assert child_environment["CARGO_HOME"] == str(raw_execution["cargo_home"])
+    assert child_environment["CARGO_TARGET_DIR"] == str(
+        raw_execution["cargo_target_dir"]
+    )
+    assert child_environment["TMPDIR"] == str(raw_execution["tmpdir"])
+
+
+def test_authenticated_candidate_overlay_is_local_and_reuses_the_gate_target(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    root, _ = _workspace(tmp_path)
+    raw_execution = _execution_paths(root)
+    execution = gate.preflight_execution_paths(
+        raw_execution,
+        workspace_root=root,
+    )
+    overlay = raw_execution["tmpdir"] / "pyamplicol-build-test" / "source"
+    (overlay / ".cargo").mkdir(parents=True)
+    (overlay / "Cargo.lock").write_text("version = 4\n", encoding="utf-8")
+    (overlay / ".cargo" / "config.toml").write_text(
+        "[patch.crates-io]\n",
+        encoding="utf-8",
+    )
+    build_info = overlay / "src" / "pyamplicol" / "_build_info.json"
+    build_info.parent.mkdir(parents=True)
+    build_info.write_text(
+        json.dumps(_build_info()),
+        encoding="utf-8",
+    )
+    calls: list[tuple[str, dict[str, Path]]] = []
+    dependency_checks: list[str] = []
+
+    @contextmanager
+    def fake_overlay(mode: str, **kwargs: Path):
+        calls.append((mode, kwargs))
+        yield overlay, kwargs["cargo_target_directory"]
+
+    monkeypatch.setattr(
+        gate.build_backend,
+        "_check_dependencies",
+        dependency_checks.append,
+    )
+    monkeypatch.setattr(gate.build_backend, "_overlay", fake_overlay)
+
+    with gate.authenticated_candidate_overlay(
+        execution,
+        source_revision=_SOURCE_REVISION,
+        native_build_inputs_sha256=_NATIVE_BUILD_INPUTS_SHA256,
+        candidate_version=_CANDIDATE_VERSION,
+    ) as observed:
+        assert observed == overlay
+
+    assert calls == [
+        (
+            "candidate",
+            {
+                "temporary_directory": raw_execution["tmpdir"],
+                "cargo_target_directory": raw_execution["cargo_target_dir"],
+            },
+        )
+    ]
+    assert dependency_checks == ["candidate"]
+
+
+@pytest.mark.parametrize(
+    ("updates", "message"),
+    [
+        ({"source_revision": "c" * 40}, "source_revision"),
+        ({"native_build_inputs_sha256": "d" * 64}, "native_build_inputs_sha256"),
+        (
+            {"version": "0.1.0.dev0+candidate.fedcba987654"},
+            "version",
+        ),
+        ({"selftest_fixture_bootstrap": True}, "selftest_fixture_bootstrap"),
+    ],
+)
+def test_authenticated_candidate_overlay_rejects_mismatched_build_identity(
+    updates: dict[str, object],
+    message: str,
+    tmp_path: Path,
+) -> None:
+    overlay = tmp_path / "overlay"
+    build_info = overlay / "src" / "pyamplicol" / "_build_info.json"
+    build_info.parent.mkdir(parents=True)
+    payload = _build_info()
+    payload.update(updates)
+    build_info.write_text(json.dumps(payload), encoding="utf-8")
+
+    with pytest.raises(gate.GateError, match=message):
+        gate._authenticate_candidate_overlay_build_info(
+            overlay.resolve(),
+            source_revision=_SOURCE_REVISION,
+            native_build_inputs_sha256=_NATIVE_BUILD_INPUTS_SHA256,
+            candidate_version=_CANDIDATE_VERSION,
+        )
+
+
+def test_preflight_requires_one_candidate_version(tmp_path: Path) -> None:
+    root, raw = _workspace(tmp_path)
+    fixtures = _preflight(raw, workspace_root=root)
+    assert gate._common_fixture_candidate_version(fixtures) == _CANDIDATE_VERSION
+
+    manifest = raw["compiled_o3"] / "artifact.json"
+    payload = json.loads(manifest.read_text(encoding="utf-8"))
+    payload["producer"]["version"] = "0.1.0.dev0+candidate.fedcba987654"
+    manifest.write_text(json.dumps(payload), encoding="utf-8")
+    with pytest.raises(gate.GateError, match="one candidate build"):
+        _preflight(raw, workspace_root=root)
+
+
+def test_main_executes_every_command_in_one_authenticated_candidate_overlay(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    root, fixtures = _workspace(tmp_path)
+    overlay = root / ".artifacts" / "authenticated-overlay"
+    overlay.mkdir(parents=True)
+    (overlay / "Cargo.toml").write_text("[workspace]\n", encoding="utf-8")
+    monkeypatch.setattr(gate, "ROOT", root)
+    calls: list[tuple[tuple[gate.GateCommand, ...], Path]] = []
+
+    @contextmanager
+    def fake_candidate_overlay(
+        _execution: gate.ExecutionPaths,
+        *,
+        source_revision: str,
+        native_build_inputs_sha256: str,
+        candidate_version: str,
+    ):
+        assert source_revision == _SOURCE_REVISION
+        assert native_build_inputs_sha256 == _NATIVE_BUILD_INPUTS_SHA256
+        assert candidate_version == _CANDIDATE_VERSION
+        yield overlay
+
+    def capture_commands(
+        commands: tuple[gate.GateCommand, ...],
+        *,
+        environment: object,
+        execution_paths: object,
+        workspace_root: Path,
+    ) -> None:
+        del environment, execution_paths
+        calls.append((commands, workspace_root))
+
+    monkeypatch.setattr(
+        gate,
+        "authenticated_candidate_overlay",
+        fake_candidate_overlay,
+    )
+    monkeypatch.setattr(gate, "run_commands", capture_commands)
+    arguments = [
+        "--compiled-o3-artifact",
+        str(fixtures["compiled_o3"]),
+        "--eager-o2-artifact",
+        str(fixtures["eager_o2"]),
+        "--recurrence-topology-o2-artifact",
+        str(fixtures["recurrence_topology_o2"]),
+        "--recurrence-union-o2-artifact",
+        str(fixtures["recurrence_union_o2"]),
+        "--contracted-nlc-artifact",
+        str(fixtures["contracted_nlc"]),
+        *_identity_arguments(),
+    ]
+
+    assert gate.main(arguments) == 0
+    assert len(calls) == 1
+    commands, workspace_root = calls[0]
+    assert workspace_root == overlay
+    assert len(commands) == 8
+    assert all(
+        str(overlay / "Cargo.toml") in command.arguments
+        for command in commands
+    )
+    assert all(
+        str(root / "Cargo.toml") not in command.arguments for command in commands
+    )
+
+
+def test_plan_contains_every_focused_gate_and_expected_marker(
+    tmp_path: Path,
+) -> None:
+    root, _ = _workspace(tmp_path)
+    commands = gate.gate_commands(cargo="/toolchain/bin/cargo", workspace_root=root)
+
+    assert len(commands) == 8
+    assert all(command.arguments[0] == "/toolchain/bin/cargo" for command in commands)
+    assert all("--locked" in command.arguments for command in commands)
+    assert all(str(root / "Cargo.toml") in command.arguments for command in commands)
+    assert all(
+        command.arguments.count(str(root / "Cargo.toml")) == 1
+        for command in commands
+    )
+    assert all("--show-output" in command.arguments for command in commands)
+    assert all("--test-threads=1" in command.arguments for command in commands)
+    odd_tail_command = next(
+        command
+        for command in commands
+        if command.expected_tests == gate._ODD_TAIL_TESTS
+    )
+    assert "generated_artifact_odd_tails" in odd_tail_command.arguments
+    assert {test for command in commands for test in command.expected_tests} == {
+        gate._COMPILED_FULL_TEST,
+        gate._COMPILED_QUICK_TEST,
+        gate._EAGER_ALLOCATION_TEST,
+        gate._RECURRENCE_SMOKE_TEST,
+        gate._RECURRENCE_BOUNDARY_TEST,
+        *gate._RECURRENCE_ALLOCATION_TESTS,
+        *gate._ODD_TAIL_TESTS,
+        *gate._CAPI_ARTIFACT_TESTS,
+        *gate._CAPI_SELECTOR_TESTS,
+    }
+
+
+def test_success_requires_an_ok_marker_for_every_requested_test(
+    tmp_path: Path,
+) -> None:
+    root, _ = _workspace(tmp_path)
+    command = gate.gate_commands(cargo="cargo", workspace_root=root)[4]
+    output = "\n".join(
+        f"test {test_name} ... ok" for test_name in command.expected_tests
+    )
+    gate.verify_test_markers(command, output)
+
+    with pytest.raises(gate.GateError, match="did not run every required test"):
+        gate.verify_test_markers(
+            command,
+            f"test {command.expected_tests[0]} ... ok\n"
+            "test unrelated_test ... ok\n",
+        )
+
+
+def test_plan_mode_preflights_without_launching_cargo(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    root, fixtures = _workspace(tmp_path)
+    monkeypatch.setattr(gate, "ROOT", root)
+
+    def unexpected_run(*args: object, **kwargs: object) -> None:
+        del args, kwargs
+        raise AssertionError("plan mode must not launch Cargo")
+
+    monkeypatch.setattr(gate.subprocess, "run", unexpected_run)
+    arguments = [
+        "--compiled-o3-artifact",
+        str(fixtures["compiled_o3"]),
+        "--eager-o2-artifact",
+        str(fixtures["eager_o2"]),
+        "--recurrence-topology-o2-artifact",
+        str(fixtures["recurrence_topology_o2"]),
+        "--recurrence-union-o2-artifact",
+        str(fixtures["recurrence_union_o2"]),
+        "--contracted-nlc-artifact",
+        str(fixtures["contracted_nlc"]),
+        *_identity_arguments(),
+        "--plan",
+    ]
+
+    assert gate.main(arguments) == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["workspace_root"] == str(root)
+    assert payload["cargo_input"] == {
+        "mode": "authenticated-candidate-overlay",
+        "manifest": gate._CANDIDATE_MANIFEST_PLACEHOLDER,
+        "shared_target": payload["execution_paths"]["cargo_target_dir"],
+    }
+    assert payload["fixture_identity"] == {
+        "producer": {
+            "distribution": "pyamplicol",
+            "git_revision": _SOURCE_REVISION,
+            "native_build_inputs_sha256": _NATIVE_BUILD_INPUTS_SHA256,
+            "version_pattern": gate._CANDIDATE_VERSION_PATTERN.pattern,
+        },
+        "process": {
+            "id": gate._EXPECTED_PROCESS_ID,
+            "expression": gate._EXPECTED_PROCESS_EXPRESSION,
+            "external_pdgs": list(gate._EXPECTED_EXTERNAL_PDGS),
+        },
+    }
+    assert len(payload["commands"]) == 8
+    assert len(payload["execution_paths"]) == 6
+    assert len(payload["environment"]) == 18
+    assert payload["environment"]["PYAMPLICOL_REQUIRE_NATIVE_TESTS"] == "1"
+    assert payload["environment"]["CARGO_TERM_COLOR"] == "never"
+    default_state_root = (
+        root
+        / ".artifacts"
+        / "symjit-2.22-migration"
+        / "generated-fixture-gate"
+    )
+    assert all(
+        Path(path).is_relative_to(default_state_root)
+        for path in payload["execution_paths"].values()
+    )
+    assert payload["environment"]["CARGO_HOME"] == payload["execution_paths"][
+        "cargo_home"
+    ]
+    assert payload["environment"]["CARGO_TARGET_DIR"] == payload[
+        "execution_paths"
+    ]["cargo_target_dir"]
+    assert payload["environment"]["TMPDIR"] == payload["execution_paths"]["tmpdir"]
+    assert payload["environment"]["PIP_CACHE_DIR"] == payload["execution_paths"][
+        "pip_cache_dir"
+    ]
+    assert payload["environment"]["XDG_CACHE_HOME"] == payload[
+        "execution_paths"
+    ]["xdg_cache_home"]
+    assert all(
+        gate._CANDIDATE_MANIFEST_PLACEHOLDER in command["arguments"]
+        for command in payload["commands"]
+    )
+    assert all(
+        str(root / "Cargo.toml") not in command["arguments"]
+        for command in payload["commands"]
+    )
+    assert not (root / ".artifacts").exists()
diff --git a/pyamplicol/tests/unit/test_symjit_2_22_migration_benchmark_gate.py b/pyamplicol/tests/unit/test_symjit_2_22_migration_benchmark_gate.py
new file mode 100644
index 0000000000..3fd07776ed
--- /dev/null
+++ b/pyamplicol/tests/unit/test_symjit_2_22_migration_benchmark_gate.py
@@ -0,0 +1,2319 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import copy
+import datetime as dt
+import hashlib
+import importlib.util
+import json
+import math
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools" / "developer" / "symjit_2_22_migration_benchmark_gate.py"
+SPEC = importlib.util.spec_from_file_location(
+    "symjit_2_22_migration_benchmark_gate",
+    SCRIPT,
+)
+assert SPEC is not None and SPEC.loader is not None
+gate = importlib.util.module_from_spec(SPEC)
+sys.modules[SPEC.name] = gate
+SPEC.loader.exec_module(gate)
+
+ALL_MODES = (*gate.CAPTURE_MODES, *gate.DIAGNOSTIC_MODES)
+EXPECTED_CANDIDATE_REVISION = "2" * 40
+EXPECTED_BASELINE_NATIVE_BUILD_INPUTS = "e" * 64
+EXPECTED_CANDIDATE_NATIVE_BUILD_INPUTS = "f" * 64
+EXPECTED_BASELINE_PREPARED_MODEL = "8" * 64
+EXPECTED_CANDIDATE_PREPARED_MODEL = "9" * 64
+
+
+def _canonical(value: object) -> bytes:
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+def _sha256(value: object) -> str:
+    return hashlib.sha256(_canonical(value)).hexdigest()
+
+
+def _address(value: dict[str, object]) -> dict[str, object]:
+    result = dict(value)
+    result["content_sha256"] = _sha256(result)
+    return result
+
+
+def _peak(value: int) -> dict[str, object]:
+    return {
+        "source": "resource.getrusage",
+        "self_peak_bytes": value,
+        "maximum_child_peak_bytes": 0,
+        "observed_lower_bound_bytes": value,
+        "semantics": "synthetic process high-water mark",
+    }
+
+
+def _statistics(values: list[float]) -> tuple[float, float]:
+    ordered = sorted(values)
+    median = ordered[len(ordered) // 2]
+    deviations = sorted(abs(value - median) for value in values)
+    return median, deviations[len(deviations) // 2]
+
+
+_TEST_EPOCH = dt.datetime(2026, 7, 30, tzinfo=dt.UTC)
+
+
+def _layout_epoch(layout: str) -> dt.datetime:
+    return _TEST_EPOCH + (
+        dt.timedelta(seconds=10_000)
+        if layout == "all-flow-union"
+        else dt.timedelta()
+    )
+
+
+def _slot_times(
+    *,
+    role: str,
+    layout: str,
+    schedule_index: int,
+    round_index: int,
+) -> tuple[dt.datetime, dt.datetime, dt.datetime, dt.datetime]:
+    expected_order = (
+        ("baseline", "candidate")
+        if round_index % 2 == 0
+        else ("candidate", "baseline")
+    )
+    order = expected_order.index(role)
+    pair_start = _layout_epoch(layout) + dt.timedelta(seconds=schedule_index * 10)
+    issued = pair_start + dt.timedelta(seconds=order * 3)
+    return (
+        issued,
+        issued + dt.timedelta(seconds=1),
+        issued + dt.timedelta(seconds=2),
+        issued + dt.timedelta(seconds=2, milliseconds=500),
+    )
+
+
+def _semantic_identity(
+    layout: str,
+    mode: str,
+    *,
+    selected_union: bool = False,
+) -> dict[str, object]:
+    normalization = {"average_factor": 36, "color_factor": 2187}
+    reduction_ordering = {
+        "kind": "lc-diagonal",
+        "pair_order_abi": "helicity-major-color-minor-v1",
+        **({"lane_internal": mode} if selected_union else {}),
+    }
+    selector_semantics = {
+        "kind": "pyamplicol-runtime-selectors",
+        "layout": layout,
+    }
+    common_model = {
+        "name": "built-in-sm",
+        "content_sha256": "9" * 64,
+        "compiled_schema_version": 9,
+        "restriction": None,
+    }
+    if selected_union:
+        color_ids = [
+            f"flow:synthetic:{index}"
+            for index in range(gate.SELECTED_UNION_COLOR_COUNT)
+        ]
+        color_entries = [
+            {
+                "index": index,
+                "id": identifier,
+                "kind": "lc-flow",
+                "word": [index + 1],
+                "coefficient": 1.0,
+            }
+            for index, identifier in enumerate(color_ids)
+        ]
+        helicity_count = gate.SELECTED_UNION_HELICITY_INDEX + 1
+        helicity_ids = [
+            (
+                gate.SELECTED_UNION_HELICITY_ID
+                if index == gate.SELECTED_UNION_HELICITY_INDEX
+                else f"h:synthetic:{index}"
+            )
+            for index in range(helicity_count)
+        ]
+        helicity_entries = [
+            {
+                "index": index,
+                "id": identifier,
+                "values": (
+                    list(gate.SELECTED_UNION_HELICITY_VALUES)
+                    if index == gate.SELECTED_UNION_HELICITY_INDEX
+                    else [index]
+                ),
+                "coefficient": (
+                    1.0
+                    if index == gate.SELECTED_UNION_HELICITY_INDEX or mode != "compiled"
+                    else 0.0
+                ),
+                "structural_zero": (
+                    index != gate.SELECTED_UNION_HELICITY_INDEX and mode == "compiled"
+                ),
+            }
+            for index, identifier in enumerate(helicity_ids)
+        ]
+        physical_colors = {
+            "count": len(color_ids),
+            "ordered_ids": color_ids,
+            "ordered_ids_sha256": _sha256(color_ids),
+            "ordered_entries": color_entries,
+            "ordered_entries_sha256": _sha256(color_entries),
+        }
+        physical_helicities = {
+            "count": len(helicity_ids),
+            "ordered_ids": helicity_ids,
+            "ordered_ids_sha256": _sha256(helicity_ids),
+            "ordered_entries": helicity_entries,
+            "ordered_entries_sha256": _sha256(helicity_entries),
+        }
+    else:
+        physical_colors = {
+            "count": 2,
+            "ordered_entries": [{"index": 0}, {"index": 1}],
+        }
+        physical_helicities = {
+            "count": 2,
+            "ordered_entries": [{"index": 0}, {"index": 1}],
+        }
+    return {
+        "kind": "pyamplicol-benchmark-artifact-semantic-identity",
+        "schema_version": 3,
+        "mode_internal_marker": mode,
+        "generation_specialized_axes": [],
+        "coverage": {
+            "color": "complete",
+            "helicities": "complete",
+            "complete_physical_axes": True,
+        },
+        "reduction_coverage": {
+            "complete": True,
+            "errors": [],
+            "expected_physical_pair_count": 4,
+            "observed_physical_pair_count": 4,
+        },
+        "normalization": normalization,
+        "normalization_sha256": _sha256(normalization),
+        "reduction_ordering": reduction_ordering,
+        "reduction_ordering_sha256": _sha256(reduction_ordering),
+        "runtime_selector_semantics": selector_semantics,
+        "runtime_selector_semantics_sha256": _sha256(selector_semantics),
+        "manifest_model_identity": {
+            "common_physics_identity": common_model,
+            "common_physics_identity_sha256": _sha256(common_model),
+        },
+        "physical_color_flows": physical_colors,
+        "physical_helicities": physical_helicities,
+    }
+
+
+def _selected_union_projection(
+    semantic: dict[str, object],
+    *,
+    process_id: str,
+    color_flow_request: str,
+) -> dict[str, object]:
+    colors = semantic["physical_color_flows"]
+    helicities = semantic["physical_helicities"]
+    assert isinstance(colors, dict)
+    assert isinstance(helicities, dict)
+    entries = helicities["ordered_entries"]
+    assert isinstance(entries, list)
+    kinematic_entries = [
+        {
+            "index": entry["index"],
+            "id": entry["id"],
+            "values": entry["values"],
+            **(
+                {
+                    "coefficient": entry["coefficient"],
+                    "structural_zero": entry["structural_zero"],
+                }
+                if entry["id"] == gate.SELECTED_UNION_HELICITY_ID
+                else {}
+            ),
+        }
+        for entry in entries
+    ]
+    selected_entry = entries[gate.SELECTED_UNION_HELICITY_INDEX]
+    model = semantic["manifest_model_identity"]
+    assert isinstance(model, dict)
+    return {
+        "policy": gate.SELECTED_UNION_SEMANTIC_COMPARISON_POLICY,
+        "process_id": process_id,
+        "process_expression": gate.SELECTED_UNION_PROCESS,
+        "physical_color_flows": {
+            "count": colors["count"],
+            "ordered_ids_sha256": colors["ordered_ids_sha256"],
+            "ordered_entries_sha256": colors["ordered_entries_sha256"],
+        },
+        "physical_helicities": {
+            "count": helicities["count"],
+            "ordered_ids_sha256": helicities["ordered_ids_sha256"],
+            "kinematic_entries_sha256": _sha256(kinematic_entries),
+            "selected_index": gate.SELECTED_UNION_HELICITY_INDEX,
+            "selected_entry": selected_entry,
+        },
+        "normalization_sha256": semantic["normalization_sha256"],
+        "model_common_physics_identity_sha256": model["common_physics_identity_sha256"],
+        "runtime_selector_semantics_sha256": semantic[
+            "runtime_selector_semantics_sha256"
+        ],
+        "profile_selector": {
+            "color_flow_request": color_flow_request,
+            "resolved_color_flow_id": None,
+            "helicity_request": gate.SELECTED_UNION_HELICITY_ID,
+            "resolved_helicity_id": gate.SELECTED_UNION_HELICITY_ID,
+            "color_flow_count": gate.SELECTED_UNION_COLOR_COUNT,
+            "helicity_count": helicities["count"],
+            "workload": "all-flows/runtime-selected-single-helicity",
+        },
+        "resolved_color_ids_sha256": _sha256(colors["ordered_ids"]),
+    }
+
+
+def _sample(
+    *,
+    role: str,
+    layout: str,
+    identifier: int,
+    schedule_index: int,
+    round_index: int,
+    batch_size: int,
+    runtime: float,
+    cold_load: float,
+    cold_rss: int,
+    profiled_rss: int,
+) -> tuple[dict[str, object], dict[str, object]]:
+    _, started, finished, recorded = _slot_times(
+        role=role,
+        layout=layout,
+        schedule_index=schedule_index,
+        round_index=round_index,
+    )
+    invocation = _address(
+        {
+            "kind": "invocation",
+            "identifier": identifier,
+            "role": role,
+            "layout": layout,
+            "started_at_utc": started.isoformat(),
+            "finished_at_utc": finished.isoformat(),
+            "wall_seconds": 12.0,
+        }
+    )
+    process_record = _address(
+        {
+            "kind": "worker-process",
+            "identifier": identifier,
+            "role": role,
+            "layout": layout,
+            "wall_seconds": 12.0,
+        }
+    )
+    block_count = gate.MINIMUM_INTERNAL_SAMPLES
+    repetitions = math.ceil(
+        (5.0 * 1.02) / (block_count * runtime * batch_size)
+    )
+    blocks: list[dict[str, object]] = []
+    for block_index in range(block_count):
+        native = runtime * repetitions * batch_size
+        block = _address(
+            {
+                "block_index": block_index,
+                "started_at_utc": (
+                    started + dt.timedelta(microseconds=block_index)
+                ).isoformat(),
+                "finished_at_utc": (
+                    started + dt.timedelta(microseconds=block_index + 1)
+                ).isoformat(),
+                "caller_elapsed_seconds": native,
+                "native_wall_seconds": native,
+                "wall_seconds_per_point": runtime,
+                "repetitions": repetitions,
+                "batch_size": batch_size,
+                "evaluation_count": repetitions,
+                "evaluated_point_count": repetitions * batch_size,
+            }
+        )
+        blocks.append(block)
+    observed_native = sum(float(block["native_wall_seconds"]) for block in blocks)
+    raw_native_wall = {
+        "kind": gate.RAW_NATIVE_WALL_BLOCK_KIND,
+        "schema_version": gate.RAW_NATIVE_WALL_BLOCK_SCHEMA,
+        "measurement_contract": gate.RAW_NATIVE_WALL_MEASUREMENT_CONTRACT,
+        "source": "runtime._benchmark_f64_wall_time",
+        "fixture_points_sha256": "b" * 64,
+        "minimum_native_wall_seconds": 5.0,
+        "observed_native_wall_seconds": observed_native,
+        "observed_caller_elapsed_seconds": observed_native,
+        "minimum_duration_satisfied": True,
+        "calibration": {
+            "kind": "benchmark-runner-wall-rate-calibration",
+            "schema_version": 1,
+            "benchmark_runner_sample_count": 20,
+            "benchmark_runner_repetitions_per_sample": 1,
+            "benchmark_runner_total_repetitions": 20,
+            "benchmark_runner_wall_seconds_per_point": runtime,
+            "requested_minimum_block_count": block_count,
+            "preceded_by_benchmark_runner_warmup_runs": 2,
+            "duration_headroom_factor": 1.02,
+            "scaled_repetitions_per_block": repetitions,
+        },
+        "block_count": block_count,
+        "repetitions_per_block": repetitions,
+        "evaluation_count": block_count * repetitions,
+        "evaluated_point_count": block_count * repetitions * batch_size,
+        "wall_seconds_per_point_median": runtime,
+        "wall_seconds_per_point_mad": 0.0,
+        "blocks": blocks,
+        "blocks_sha256": _sha256(blocks),
+    }
+    worker_measurement = {
+        "batch_size": batch_size,
+        "sample_count": block_count,
+        "repetitions_per_sample": repetitions,
+        "evaluation_count": block_count * repetitions,
+        "evaluated_point_count": block_count * repetitions * batch_size,
+        "wall_seconds_per_point": runtime,
+        "inner_native_wall_blocks": raw_native_wall,
+        "benchmark_runner_sample_count": 20,
+        "benchmark_runner_repetitions_per_sample": 1,
+        "benchmark_runner_evaluation_count": 20,
+        "benchmark_runner_evaluated_point_count": 20 * batch_size,
+        "benchmark_runner_wall_seconds_per_point": runtime,
+    }
+    sample: dict[str, object] = {
+        "schedule_index": schedule_index,
+        "round": round_index,
+        "wall_seconds_per_point": runtime,
+        "cold_load_seconds": cold_load,
+        "peak_rss_after_cold_load": _peak(cold_rss),
+        "peak_rss_after_profile": _peak(profiled_rss),
+        "internal_sample_count": block_count,
+        "repetitions_per_sample": repetitions,
+        "evaluation_count": block_count * repetitions,
+        "evaluated_point_count": block_count * repetitions * batch_size,
+        "inner_native_wall_blocks": raw_native_wall,
+        "worker_measurement": worker_measurement,
+        "interrupted": False,
+        "timing_configuration": {
+            "minimum_internal_samples": 7,
+            "warmup_runs": 2,
+            "target_runtime_seconds": 5.0,
+        },
+        "timing_sources": {"wall": "runtime_core_repeated_wall_time"},
+        "worker_invocation": invocation,
+        "worker_process_record": process_record,
+    }
+    result_record = {
+        "kind": "pyamplicol-retained-profile-worker-result",
+        "schema_version": 1,
+        "recorded_at_utc": recorded.isoformat(),
+        "addressed_payload_sha256": _sha256(sample),
+        "upstream_worker_result_record_sha256": "a" * 64,
+        "worker_process_record_sha256": process_record["content_sha256"],
+        "worker_invocation_sha256": invocation["content_sha256"],
+    }
+    sample["worker_result_record"] = _address(result_record)
+    schedule_entry = {
+        "schedule_index": schedule_index,
+        "round": round_index,
+        "worker_result_sha256": result_record["addressed_payload_sha256"],
+        "worker_invocation": invocation,
+        "worker_result_record": sample["worker_result_record"],
+    }
+    return sample, schedule_entry
+
+
+def _aggregate(batch_size: int, samples: list[dict[str, object]]) -> dict[str, object]:
+    runtime = [float(sample["wall_seconds_per_point"]) for sample in samples]
+    cold = [float(sample["cold_load_seconds"]) for sample in samples]
+    cold_rss = [
+        float(sample["peak_rss_after_cold_load"]["observed_lower_bound_bytes"])
+        for sample in samples
+    ]
+    profiled_rss = [
+        float(sample["peak_rss_after_profile"]["observed_lower_bound_bytes"])
+        for sample in samples
+    ]
+    runtime_median, runtime_mad = _statistics(runtime)
+    cold_median, cold_mad = _statistics(cold)
+    cold_rss_median, _ = _statistics(cold_rss)
+    profiled_rss_median, _ = _statistics(profiled_rss)
+    return {
+        "batch_size": batch_size,
+        "sample_count": len(samples),
+        "subprocess_sample_count": len(samples),
+        "wall_seconds_per_point": runtime_median,
+        "wall_seconds_per_point_median": runtime_median,
+        "wall_seconds_per_point_mad": runtime_mad,
+        "statistics_contract": "subprocess-median-and-raw-mad-v1",
+        "cold_load_seconds_median": cold_median,
+        "cold_load_seconds_mad": cold_mad,
+        "cold_load_peak_rss_bytes_median": cold_rss_median,
+        "profiled_peak_rss_bytes_median": profiled_rss_median,
+        "resource_statistics_contract": "subprocess-median-and-raw-mad-v1",
+        "subprocess_samples": samples,
+        "interrupted": False,
+    }
+
+
+def _capture(
+    *,
+    role: str,
+    layout: str,
+    process: str,
+    runtime_ratio: float = 1.0,
+    compiled_to_recurrence_ratio: float = 1.05,
+    generation_ratio: float = 1.0,
+    resource_ratio: float = 1.0,
+    eager_runtime_ratio: float = 1.0,
+    eager_generation_ratio: float = 1.0,
+    eager_resource_ratio: float = 1.0,
+) -> dict[str, object]:
+    candidate = role == "candidate"
+    revision = "2" * 40 if candidate else gate.BASELINE_REVISION
+    interpreter_path = "/synthetic/shared/bin/python"
+    prepared_model_path = f"/synthetic/{role}/prepared-model.pack"
+    prepared_model_sha256 = ("9" if candidate else "8") * 64
+    runtime_role_ratio = runtime_ratio if candidate else 1.0
+    generation_role_ratio = generation_ratio if candidate else 1.0
+    resource_role_ratio = resource_ratio if candidate else 1.0
+    eager_runtime_role_ratio = eager_runtime_ratio if candidate else 1.0
+    eager_generation_role_ratio = eager_generation_ratio if candidate else 1.0
+    eager_resource_role_ratio = eager_resource_ratio if candidate else 1.0
+    workload = (
+        "single-runtime-selected-flow/helicity-sum"
+        if layout == "topology-replay"
+        else "all-flows/runtime-selected-single-helicity"
+    )
+    selected_union = process.casefold().startswith("d ") and layout == "all-flow-union"
+    selected_union_helicity_count = gate.SELECTED_UNION_HELICITY_INDEX + 1
+    selector = {
+        "color_flow_count": (gate.SELECTED_UNION_COLOR_COUNT if selected_union else 2),
+        "helicity_count": selected_union_helicity_count if selected_union else 2,
+        "workload": workload,
+        "color_flow_request": "flow:2,1" if layout == "topology-replay" else "1",
+        "helicity_request": (
+            "1"
+            if layout == "topology-replay"
+            else gate.SELECTED_UNION_HELICITY_ID
+            if selected_union
+            else "h:-1,+1"
+        ),
+        "resolved_color_flow_id": ("flow:2,1" if layout == "topology-replay" else None),
+        "resolved_helicity_id": (
+            None
+            if layout == "topology-replay"
+            else gate.SELECTED_UNION_HELICITY_ID
+            if selected_union
+            else "h:-1,+1"
+        ),
+        "structural_zero_helicity_count": 0,
+    }
+    color_request = selector["color_flow_request"]
+    helicity_request = selector["helicity_request"]
+    generation: dict[str, object] = {}
+    profiles: dict[str, object] = {}
+    samples_by_cell: dict[tuple[str, int], list[dict[str, object]]] = {
+        (mode, batch): [] for mode in ALL_MODES for batch in gate.BATCH_SIZES
+    }
+    schedule_entries: list[dict[str, object]] = []
+    schedule_index = 0
+    identifier = 1
+    deviations = (-0.003, -0.002, -0.001, 0.0, 0.001, 0.002, 0.003)
+    for round_index, deviation in enumerate(deviations):
+        offset = round_index % len(ALL_MODES)
+        modes = ALL_MODES[offset:] + ALL_MODES[:offset]
+        for batch_size in gate.BATCH_SIZES:
+            for mode in modes:
+                mode_ratio = (
+                    compiled_to_recurrence_ratio
+                    if mode == "compiled"
+                    else 1.02
+                    if mode == "eager"
+                    else 1.0
+                )
+                base_runtime = (
+                    1.0e-6
+                    * (1.0 + 0.1 * gate.BATCH_SIZES.index(batch_size))
+                    * mode_ratio
+                )
+                mode_runtime_ratio = (
+                    runtime_role_ratio * eager_runtime_role_ratio
+                    if mode == "eager"
+                    else runtime_role_ratio
+                )
+                mode_resource_ratio = (
+                    resource_role_ratio * eager_resource_role_ratio
+                    if mode == "eager"
+                    else resource_role_ratio
+                )
+                runtime = base_runtime * mode_runtime_ratio * (1.0 + deviation)
+                sample, entry = _sample(
+                    role=role,
+                    layout=layout,
+                    identifier=identifier,
+                    schedule_index=schedule_index,
+                    round_index=round_index,
+                    batch_size=batch_size,
+                    runtime=runtime,
+                    cold_load=0.2 * mode_resource_ratio * (1.0 + deviation),
+                    cold_rss=int(100_000_000 * mode_resource_ratio * (1.0 + deviation)),
+                    profiled_rss=int(
+                        120_000_000 * mode_resource_ratio * (1.0 + deviation)
+                    ),
+                )
+                entry.update({"mode": mode, "batch_size": batch_size})
+                schedule_entries.append(entry)
+                samples_by_cell[(mode, batch_size)].append(sample)
+                identifier += 1
+                schedule_index += 1
+
+    for mode in ALL_MODES:
+        semantic = _semantic_identity(
+            layout,
+            mode,
+            selected_union=selected_union,
+        )
+        semantic_sha256 = _sha256(semantic)
+        optimization = 3 if mode == "compiled" else 2
+        mode_generation_ratio = (
+            generation_role_ratio * eager_generation_role_ratio
+            if mode == "eager"
+            else generation_role_ratio
+        )
+        mode_resource_ratio = (
+            resource_role_ratio * eager_resource_role_ratio
+            if mode == "eager"
+            else resource_role_ratio
+        )
+        generation[mode] = {
+            "mode": mode,
+            "generation_wall_seconds": (
+                (12.0 if mode == "compiled" else 11.0 if mode == "eager" else 10.0)
+                * mode_generation_ratio
+            ),
+            "generation_reused": False,
+            "peak_rss": _peak(int(400_000_000 * mode_resource_ratio)),
+            "artifact_stats": {
+                "file_count": 4,
+                "size_bytes": int(10_000_000 * mode_resource_ratio),
+            },
+            "artifact_identity": {
+                "semantic_identity": semantic,
+                "semantic_identity_sha256": semantic_sha256,
+            },
+            "effective_contract": {
+                "backend": "jit",
+                "color_accuracy": "lc",
+                "execution_mode": mode,
+                "jit_optimization_level": optimization,
+                "lc_flow_layout": layout,
+            },
+        }
+        physical_colors = semantic["physical_color_flows"]
+        assert isinstance(physical_colors, dict)
+        mode_selector = dict(selector)
+        if selected_union and mode == "compiled":
+            mode_selector["structural_zero_helicity_count"] = (
+                selected_union_helicity_count - 1
+            )
+        profiles[mode] = {
+            "mode": mode,
+            "process_expression": process,
+            "process_id": "d_dbar_to_z_6g"
+            if process.startswith("d ")
+            else "u_ubar_to_z_6g",
+            "selector_contract": mode_selector,
+            "validation": {
+                "passes": True,
+                "fixture": {
+                    "point_count": 1,
+                    "points_sha256": "b" * 64,
+                },
+                **(
+                    {
+                        "resolved_color_ids": physical_colors["ordered_ids"],
+                        "resolved_helicity_ids": [gate.SELECTED_UNION_HELICITY_ID],
+                    }
+                    if selected_union
+                    else {}
+                ),
+            },
+            "artifact_semantic_identity": semantic,
+            "artifact_semantic_identity_sha256": semantic_sha256,
+            "profiles": [
+                _aggregate(batch, samples_by_cell[(mode, batch)])
+                for batch in gate.BATCH_SIZES
+            ],
+        }
+
+    native_sha = "d" * 64 if candidate else "c" * 64
+    build_inputs_sha = "f" * 64 if candidate else "e" * 64
+    lane_measurements = {
+        mode: {
+            "passes": True,
+            "observed_batch_sizes": list(gate.BATCH_SIZES),
+            "missing_batch_sizes": [],
+            "errors": [],
+        }
+        for mode in gate.CAPTURE_MODES
+    }
+    if selected_union:
+        selected_union_projections = {
+            mode: _selected_union_projection(
+                profiles[mode]["artifact_semantic_identity"],
+                process_id="d_dbar_to_z_6g",
+                color_flow_request=str(color_request),
+            )
+            for mode in gate.CAPTURE_MODES
+        }
+        assert (
+            len({_sha256(value) for value in selected_union_projections.values()}) == 1
+        )
+        common_physics_contract = selected_union_projections["compiled"]
+        artifact_lane_contracts = {
+            mode: {
+                "synthetic_lane_identity": mode,
+                "selected_union_workload_projection": projection,
+            }
+            for mode, projection in selected_union_projections.items()
+        }
+        comparison_policy = gate.SELECTED_UNION_SEMANTIC_COMPARISON_POLICY
+    else:
+        common_physics_contract = {"synthetic": True}
+        artifact_lane_contracts = {
+            mode: {"synthetic_lane_identity": mode} for mode in gate.CAPTURE_MODES
+        }
+        comparison_policy = gate.STRICT_SEMANTIC_COMPARISON_POLICY
+    eager_measurement = {
+        "passes": True,
+        "lanes": {
+            "eager": {
+                "passes": True,
+                "observed_batch_sizes": list(gate.BATCH_SIZES),
+                "missing_batch_sizes": [],
+                "errors": [],
+            }
+        },
+    }
+    capture_acceptance = {
+        "kind": "pyamplicol-three-lane-layout-capture",
+        "schema_version": 6,
+        "complete": True,
+        "evidence_complete": True,
+        "passes": True,
+        "authoritative_eligible": True,
+        "authoritative_ineligibility_reasons": [],
+        "generation_specialized_axes_by_mode": {},
+        "incomplete_physical_axes": [],
+        "required_modes": list(gate.CAPTURE_MODES),
+        "observed_modes": list(gate.CAPTURE_MODES),
+        "missing_modes": [],
+        "diagnostic_modes": list(gate.DIAGNOSTIC_MODES),
+        "eager_diagnostic": {
+            "requested": True,
+            "observed": True,
+            "complete": True,
+            "passes": True,
+            "measurement_contract": eager_measurement,
+            "artifact_semantic_contract": {
+                "passes": True,
+                "errors": [],
+                "lanes_match": True,
+            },
+            "validation_summary": {"passes": True},
+            "ineligibility_reasons": [],
+        },
+        "required_batch_sizes": list(gate.BATCH_SIZES),
+        "observed_batch_sizes": list(gate.BATCH_SIZES),
+        "missing_batch_sizes": [],
+        "measurement_contract": {
+            "passes": True,
+            "lanes": lane_measurements,
+            "minimum_authoritative_samples": 7,
+            "configured_internal_minimum_samples": 7,
+            "configured_subprocess_samples": 7,
+            "configured_warmup_runs": 2,
+            "root_processes_match": True,
+            "schedule": {
+                "passes": True,
+                "errors": [],
+                "entry_count": len(schedule_entries),
+                "unique_worker_command_count": len(schedule_entries),
+                "subprocess_samples_per_cell": 7,
+            },
+        },
+        "artifact_semantic_contract": {
+            "passes": True,
+            "errors": [],
+            "lanes_match": True,
+            "comparison_policy": comparison_policy,
+            "lane_contracts": artifact_lane_contracts,
+            "common_physics_contract": common_physics_contract,
+        },
+        "layout": layout,
+        "generation_only": False,
+        "lane_self_validation_passes": True,
+        "pairwise_validation_passes": True,
+    }
+    session_id = "synthetic-paired-session"
+    plan = [
+        {
+            field: entry[field]
+            for field in ("schedule_index", "round", "mode", "batch_size")
+        }
+        for entry in schedule_entries
+    ]
+    ready = _address(
+        {
+            "kind": "pyamplicol-paired-profile-ready",
+            "schema_version": 1,
+            "session_id": session_id,
+            "role": role,
+            "layout": layout,
+            "source_revision": revision,
+            "ready_at_utc": (
+                _layout_epoch(layout) - dt.timedelta(seconds=1)
+            ).isoformat(),
+            "profile_schedule_plan": plan,
+            "profile_schedule_plan_sha256": _sha256(plan),
+        }
+    )
+    completions: list[dict[str, object]] = []
+    for entry in schedule_entries:
+        index = int(entry["schedule_index"])
+        round_index = int(entry["round"])
+        expected_order = (
+            ("baseline", "candidate")
+            if round_index % 2 == 0
+            else ("candidate", "baseline")
+        )
+        order = expected_order.index(role)
+        issued, started, finished, recorded = _slot_times(
+            role=role,
+            layout=layout,
+            schedule_index=index,
+            round_index=round_index,
+        )
+        token = _address(
+            {
+                "kind": "pyamplicol-paired-profile-token",
+                "schema_version": 1,
+                "session_id": session_id,
+                "role": role,
+                "layout": layout,
+                **{
+                    field: entry[field]
+                    for field in ("schedule_index", "round", "mode", "batch_size")
+                },
+                "pair_index": index,
+                "order_in_pair": order,
+                "issued_at_utc": issued.isoformat(),
+            }
+        )
+        completion = _address(
+            {
+                "kind": "pyamplicol-paired-profile-completion",
+                "schema_version": 1,
+                "session_id": session_id,
+                "role": role,
+                "layout": layout,
+                **{
+                    field: entry[field]
+                    for field in ("schedule_index", "round", "mode", "batch_size")
+                },
+                "token_sha256": token["content_sha256"],
+                "worker_invocation_sha256": entry["worker_invocation"][
+                    "content_sha256"
+                ],
+                "worker_result_record_sha256": entry["worker_result_record"][
+                    "content_sha256"
+                ],
+                "worker_started_at_utc": started.isoformat(),
+                "worker_finished_at_utc": finished.isoformat(),
+                "recorded_at_utc": recorded.isoformat(),
+            }
+        )
+        entry["paired_profile_token"] = token
+        entry["paired_profile_completion"] = completion
+        completions.append(completion)
+    return {
+        "kind": gate.CAPTURE_KIND,
+        "schema_version": gate.MINIMUM_CAPTURE_SCHEMA,
+        "complete": True,
+        "passes": True,
+        "capture_acceptance": capture_acceptance,
+        "process": process,
+        "process_name": ("ddbar_Z_6g" if process.startswith("d ") else "uubar_Z_6g"),
+        "workload": workload,
+        "source": {
+            "revision": revision,
+            "dirty": False,
+            "untracked_files_checked": True,
+        },
+        "provenance": {
+            "host": {
+                "system": "TestOS",
+                "machine": "test64",
+                "cpu_model": "synthetic",
+                "logical_cpu_count": 8,
+            }
+        },
+        "runtime_provenance": {
+            "interpreter": {
+                "implementation": "CPython",
+                "python_version": "3.12.6",
+                "path": interpreter_path,
+                "resolved_path": interpreter_path,
+                "sha256": "1" * 64,
+            },
+            "native_extension": {
+                "sha256": native_sha,
+                "build_inputs_sha256": build_inputs_sha,
+                "package_version": "0.1.0+candidate",
+            },
+            "active_build_info": {
+                "payload": {
+                    "source_revision": revision,
+                    "version": "0.1.0+candidate",
+                }
+            },
+        },
+        "configuration": {
+            "batch_sizes": list(gate.BATCH_SIZES),
+            "target_runtime_seconds": 5.0,
+            "minimum_samples": 7,
+            "subprocess_samples": 7,
+            "warmup_runs": 2,
+            "color_flow_request": color_request,
+            "helicity_request": helicity_request,
+            "lc_flow_layout": layout,
+            "validation_seed": 12345,
+            "point_tile_size": 1024,
+            "jit_optimization_level": 3,
+            "generation_only": False,
+            "modes": list(ALL_MODES),
+            "model_identities": {
+                mode: {
+                    "kind": "explicit-prepared-model",
+                    "resource_id": None,
+                    "file": {
+                        "path": prepared_model_path,
+                        "resolved_path": prepared_model_path,
+                        "size_bytes": 1234,
+                        "sha256": prepared_model_sha256,
+                    },
+                    "compile_excluded_from_generation": True,
+                }
+                for mode in ALL_MODES
+            },
+        },
+        "generation": generation,
+        "profile_schedule": {
+            "kind": "pyamplicol-interleaved-subprocess-profile-schedule",
+            "schema_version": 2,
+            "algorithm": "round-major-cyclic-mode-and-batch-interleave-v1",
+            "sample_unit": "independent-profile-worker-subprocess",
+            "subprocess_samples_per_cell": 7,
+            "modes": list(ALL_MODES),
+            "batch_sizes": list(gate.BATCH_SIZES),
+            "entries": schedule_entries,
+        },
+        "profiles": profiles,
+        "paired_profile_coordination": {
+            "kind": "pyamplicol-paired-profile-coordination",
+            "schema_version": 1,
+            "session_id": session_id,
+            "role": role,
+            "layout": layout,
+            "ready_record": ready,
+            "completion_records": completions,
+        },
+        "validation_summary": {
+            "passes": True,
+            "selectors_match": True,
+            "fixtures_match": True,
+            "lane_validation_passes": True,
+            "pairwise_validation_passes": True,
+        },
+        "selector_contracts_match": True,
+        "validation_fixtures_match": True,
+    }
+
+
+def _write_campaign(
+    tmp_path: Path,
+    *,
+    process: str = "d d~ > Z g g g g g g",
+    runtime_ratio: float = 1.0,
+    compiled_to_recurrence_ratio: float = 1.05,
+    generation_ratio: float = 1.0,
+    resource_ratio: float = 1.0,
+    eager_runtime_ratio: float = 1.0,
+    eager_generation_ratio: float = 1.0,
+    eager_resource_ratio: float = 1.0,
+) -> dict[str, Path]:
+    tmp_path.mkdir(parents=True, exist_ok=True)
+    result: dict[str, Path] = {}
+    for role in ("baseline", "candidate"):
+        for layout in gate.LAYOUTS:
+            payload = _capture(
+                role=role,
+                layout=layout,
+                process=process,
+                runtime_ratio=runtime_ratio,
+                compiled_to_recurrence_ratio=compiled_to_recurrence_ratio,
+                generation_ratio=generation_ratio,
+                resource_ratio=resource_ratio,
+                eager_runtime_ratio=eager_runtime_ratio,
+                eager_generation_ratio=eager_generation_ratio,
+                eager_resource_ratio=eager_resource_ratio,
+            )
+            path = tmp_path / f"{role}-{layout}.json"
+            path.write_bytes(_canonical(payload) + b"\n")
+            result[f"{role}-{layout}"] = path
+    campaign_path = tmp_path / "paired-campaign.json"
+    campaign_path.write_bytes(
+        _canonical(_paired_campaign_record(result, process=process)) + b"\n"
+    )
+    result["campaign"] = campaign_path
+    watchdog_path = tmp_path / "memory-watchdog-report.json"
+    watchdog_path.write_bytes(
+        _canonical(_watchdog_report_record(campaign_path)) + b"\n"
+    )
+    result["watchdog-report"] = watchdog_path
+    return result
+
+
+def _file_identity(path: Path) -> dict[str, object]:
+    resolved = path.resolve(strict=True)
+    data = resolved.read_bytes()
+    return {
+        "path": str(path),
+        "resolved_path": str(resolved),
+        "size_bytes": len(data),
+        "sha256": hashlib.sha256(data).hexdigest(),
+    }
+
+
+def _watchdog_report_record(campaign_path: Path) -> dict[str, object]:
+    campaign = json.loads(campaign_path.read_text())
+    result_identity = _file_identity(campaign_path)
+    command = [
+        campaign["roles"]["candidate"]["python"],
+        str(ROOT / gate.PAIRED_DRIVER_RELATIVE_PATH),
+        "--result-json",
+        str(campaign_path),
+        "--session-id",
+        campaign["session_id"],
+    ]
+    return _address(
+        {
+            "kind": gate.WATCHDOG_REPORT_KIND,
+            "schema_version": gate.WATCHDOG_REPORT_SCHEMA,
+            "complete": True,
+            "passes": True,
+            "watchdog": _file_identity(ROOT / gate.WATCHDOG_RELATIVE_PATH),
+            "working_directory": str(ROOT),
+            "execution": {
+                "command": command,
+                "command_sha256": _sha256(command),
+                "started_at_utc": (
+                    dt.datetime.fromisoformat(campaign["started_at_utc"])
+                    - dt.timedelta(seconds=1)
+                ).isoformat(),
+                "finished_at_utc": (
+                    dt.datetime.fromisoformat(campaign["finished_at_utc"])
+                    + dt.timedelta(seconds=1)
+                ).isoformat(),
+                "elapsed_wall_seconds": 20_000.0,
+                "child_pid": 4242,
+                "child_exit_code": 0,
+                "watchdog_exit_code": 0,
+                "outcome": "command-finished",
+                "reason": None,
+            },
+            "enforcement": {
+                "scope": gate.WATCHDOG_SCOPE,
+                "limit_bytes": gate.WATCHDOG_LIMIT_BYTES,
+                "poll_interval_seconds": 0.25,
+                "terminate_grace_seconds": 5.0,
+                "metric": "process-tree-rss",
+                "probe_sample_count": 80_000,
+                "probe_failure_count": 0,
+                "maximum_consecutive_probe_failures": 0,
+                "completed_under_retry_policy": True,
+                "peak_rss_bytes": 10 * 1024**3,
+                "peak_physical_footprint_bytes": None,
+                "peak_guard_bytes": 10 * 1024**3,
+                "peak_processes": 4,
+            },
+            "result_binding": {
+                "requested": True,
+                "requested_path": str(campaign_path),
+                "identity": result_identity,
+                "error": None,
+            },
+        }
+    )
+
+
+def _paired_campaign_record(
+    paths: dict[str, Path],
+    *,
+    process: str,
+) -> dict[str, object]:
+    captures = {
+        role: {
+            layout: json.loads(paths[f"{role}-{layout}"].read_text())
+            for layout in gate.LAYOUTS
+        }
+        for role in ("baseline", "candidate")
+    }
+    harness_path = ROOT / gate.PAIRED_HARNESS_RELATIVE_PATH
+    harness_sha256 = hashlib.sha256(harness_path.read_bytes()).hexdigest()
+    harness = _address(
+        {
+            "kind": gate.PAIRED_HARNESS_KIND,
+            "schema_version": gate.PAIRED_HARNESS_SCHEMA,
+            "candidate_relative_path": gate.PAIRED_HARNESS_RELATIVE_PATH,
+            "head_blob_sha256": harness_sha256,
+            "working_file_sha256": harness_sha256,
+            "head_blob_equals_working_file": True,
+        }
+    )
+    orchestrator_path = ROOT / gate.PAIRED_DRIVER_RELATIVE_PATH
+    orchestrator_sha256 = hashlib.sha256(orchestrator_path.read_bytes()).hexdigest()
+    orchestrator = _address(
+        {
+            "kind": gate.PAIRED_HARNESS_KIND,
+            "schema_version": gate.PAIRED_HARNESS_SCHEMA,
+            "candidate_relative_path": gate.PAIRED_DRIVER_RELATIVE_PATH,
+            "head_blob_sha256": orchestrator_sha256,
+            "working_file_sha256": orchestrator_sha256,
+            "head_blob_equals_working_file": True,
+        }
+    )
+    layouts: dict[str, object] = {}
+    latest_recorded = _TEST_EPOCH
+    for layout in gate.LAYOUTS:
+        pairs: list[dict[str, object]] = []
+        baseline_entries = captures["baseline"][layout]["profile_schedule"]["entries"]
+        candidate_entries = captures["candidate"][layout]["profile_schedule"]["entries"]
+        for pair_index, (baseline_entry, candidate_entry) in enumerate(
+            zip(baseline_entries, candidate_entries, strict=True)
+        ):
+            assert all(
+                baseline_entry[field] == candidate_entry[field]
+                for field in ("schedule_index", "round", "mode", "batch_size")
+            )
+            round_index = baseline_entry["round"]
+            role_order = (
+                ["baseline", "candidate"]
+                if round_index % 2 == 0
+                else ["candidate", "baseline"]
+            )
+            completions = {
+                "baseline": baseline_entry["paired_profile_completion"],
+                "candidate": candidate_entry["paired_profile_completion"],
+            }
+            for completion in completions.values():
+                latest_recorded = max(
+                    latest_recorded,
+                    dt.datetime.fromisoformat(completion["recorded_at_utc"]),
+                )
+            pairs.append(
+                _address(
+                    {
+                        "kind": "pyamplicol-paired-profile-pair",
+                        "schema_version": 1,
+                        "pair_index": pair_index,
+                        **{
+                            field: baseline_entry[field]
+                            for field in (
+                                "schedule_index",
+                                "round",
+                                "mode",
+                                "batch_size",
+                            )
+                        },
+                        "role_order": role_order,
+                        "completions": completions,
+                    }
+                )
+            )
+        layouts[layout] = {
+            "layout": layout,
+            "ready_records": {
+                role: captures[role][layout]["paired_profile_coordination"][
+                    "ready_record"
+                ]
+                for role in ("baseline", "candidate")
+            },
+            "paired_schedule_algorithm": (
+                "slot-adjacent-round-alternating-role-order-v1"
+            ),
+            "pairs": pairs,
+            "captures": {
+                role: _file_identity(paths[f"{role}-{layout}"])
+                for role in ("baseline", "candidate")
+            },
+        }
+    roles = {}
+    for role in ("baseline", "candidate"):
+        capture = captures[role]["topology-replay"]
+        runtime = capture["runtime_provenance"]["interpreter"]
+        model = capture["configuration"]["model_identities"]["recurrence"]["file"]
+        roles[role] = {
+            "source_root": f"/synthetic/{role}/source",
+            "source_revision": capture["source"]["revision"],
+            "python": runtime["path"],
+            "python_resolved_target": runtime["resolved_path"],
+            "python_sha256": runtime["sha256"],
+            "prepared_model": model["resolved_path"],
+            "prepared_model_sha256": model["sha256"],
+        }
+    topology_configuration = captures["baseline"]["topology-replay"]["configuration"]
+    expanded_process = (
+        "d d~ > Z g g g g g g"
+        if process.casefold().startswith("d ")
+        else "u u~ > Z g g g g g g"
+    )
+    return _address(
+        {
+            "kind": gate.PAIRED_CAMPAIGN_KIND,
+            "schema_version": gate.PAIRED_CAMPAIGN_SCHEMA,
+            "complete": True,
+            "session_id": "synthetic-paired-session",
+            "started_at_utc": (_TEST_EPOCH - dt.timedelta(seconds=2)).isoformat(),
+            "finished_at_utc": (
+                latest_recorded + dt.timedelta(seconds=1)
+            ).isoformat(),
+            "process": expanded_process,
+            "orchestrator": orchestrator,
+            "harness": harness,
+            "roles": roles,
+            "configuration": {
+                "authoritative_modes": list(gate.AUTHORITATIVE_MODES),
+                "diagnostic_modes": list(gate.DIAGNOSTIC_MODES),
+                "batch_sizes": list(gate.BATCH_SIZES),
+                "target_runtime_seconds": topology_configuration[
+                    "target_runtime_seconds"
+                ],
+                "minimum_samples": topology_configuration["minimum_samples"],
+                "subprocess_samples": topology_configuration["subprocess_samples"],
+                "warmup_runs": topology_configuration["warmup_runs"],
+                "watchdog": {
+                    "required": True,
+                    "report_kind": gate.WATCHDOG_REPORT_KIND,
+                    "report_schema_version": gate.WATCHDOG_REPORT_SCHEMA,
+                    "limit_bytes": gate.WATCHDOG_LIMIT_BYTES,
+                    "scope": gate.WATCHDOG_SCOPE,
+                    "binding": gate.WATCHDOG_BINDING,
+                },
+            },
+            "layouts": layouts,
+        }
+    )
+
+
+def _compare(
+    paths: dict[str, Path],
+    **expected_overrides: str,
+) -> dict[str, object]:
+    expected = {
+        "expected_candidate_source_revision": EXPECTED_CANDIDATE_REVISION,
+        "expected_baseline_native_build_inputs_sha256": (
+            EXPECTED_BASELINE_NATIVE_BUILD_INPUTS
+        ),
+        "expected_candidate_native_build_inputs_sha256": (
+            EXPECTED_CANDIDATE_NATIVE_BUILD_INPUTS
+        ),
+        "expected_baseline_prepared_model_sha256": (
+            EXPECTED_BASELINE_PREPARED_MODEL
+        ),
+        "expected_candidate_prepared_model_sha256": (
+            EXPECTED_CANDIDATE_PREPARED_MODEL
+        ),
+    }
+    expected.update(expected_overrides)
+    return gate.compare_capture_files(
+        campaign=paths["campaign"],
+        watchdog_report=paths["watchdog-report"],
+        baseline_topology=paths["baseline-topology-replay"],
+        baseline_all_flow_union=paths["baseline-all-flow-union"],
+        candidate_topology=paths["candidate-topology-replay"],
+        candidate_all_flow_union=paths["candidate-all-flow-union"],
+        **expected,
+    )
+
+
+def _write_payload(path: Path, payload: dict[str, object]) -> None:
+    path.write_bytes(_canonical(payload) + b"\n")
+
+
+def _readdress(record: dict[str, object]) -> dict[str, object]:
+    unsigned = dict(record)
+    unsigned.pop("content_sha256", None)
+    return _address(unsigned)
+
+
+def _entry_and_sample(
+    payload: dict[str, object],
+    schedule_index: int,
+) -> tuple[dict[str, object], dict[str, object]]:
+    entry = payload["profile_schedule"]["entries"][schedule_index]
+    mode = entry["mode"]
+    batch_size = entry["batch_size"]
+    aggregate = next(
+        aggregate
+        for aggregate in payload["profiles"][mode]["profiles"]
+        if aggregate["batch_size"] == batch_size
+    )
+    sample = next(
+        sample
+        for sample in aggregate["subprocess_samples"]
+        if sample["schedule_index"] == schedule_index
+    )
+    return entry, sample
+
+
+def _replace_completion(
+    payload: dict[str, object],
+    schedule_index: int,
+    completion: dict[str, object],
+) -> None:
+    entry = payload["profile_schedule"]["entries"][schedule_index]
+    entry["paired_profile_completion"] = completion
+    payload["paired_profile_coordination"]["completion_records"][
+        schedule_index
+    ] = completion
+
+
+def _replace_worker_provenance(
+    payload: dict[str, object],
+    schedule_index: int,
+    *,
+    invocation: dict[str, object],
+    process_record: dict[str, object],
+) -> None:
+    entry, sample = _entry_and_sample(payload, schedule_index)
+    old_result = sample.pop("worker_result_record")
+    sample["worker_invocation"] = invocation
+    sample["worker_process_record"] = process_record
+    result_unsigned = dict(old_result)
+    result_unsigned.pop("content_sha256")
+    result_unsigned["addressed_payload_sha256"] = _sha256(sample)
+    result_unsigned["worker_invocation_sha256"] = invocation["content_sha256"]
+    result_unsigned["worker_process_record_sha256"] = process_record["content_sha256"]
+    invocation_finished = dt.datetime.fromisoformat(invocation["finished_at_utc"])
+    result_unsigned["recorded_at_utc"] = (
+        invocation_finished + dt.timedelta(milliseconds=500)
+    ).isoformat()
+    result = _address(result_unsigned)
+    sample["worker_result_record"] = result
+    entry["worker_invocation"] = invocation
+    entry["worker_result_record"] = result
+    entry["worker_result_sha256"] = result_unsigned["addressed_payload_sha256"]
+    completion_unsigned = dict(entry["paired_profile_completion"])
+    completion_unsigned.pop("content_sha256")
+    completion_unsigned["worker_invocation_sha256"] = invocation["content_sha256"]
+    completion_unsigned["worker_result_record_sha256"] = result["content_sha256"]
+    completion_unsigned["worker_started_at_utc"] = invocation["started_at_utc"]
+    completion_unsigned["worker_finished_at_utc"] = invocation["finished_at_utc"]
+    completion_unsigned["recorded_at_utc"] = result_unsigned["recorded_at_utc"]
+    _replace_completion(
+        payload,
+        schedule_index,
+        _address(completion_unsigned),
+    )
+
+
+def _replace_token_issued_at(
+    payload: dict[str, object],
+    schedule_index: int,
+    issued_at: dt.datetime,
+) -> None:
+    entry = payload["profile_schedule"]["entries"][schedule_index]
+    token = dict(entry["paired_profile_token"])
+    token["issued_at_utc"] = issued_at.isoformat()
+    token = _readdress(token)
+    entry["paired_profile_token"] = token
+    completion = dict(entry["paired_profile_completion"])
+    completion["token_sha256"] = token["content_sha256"]
+    _replace_completion(payload, schedule_index, _readdress(completion))
+
+
+def _replace_ready_at(payload: dict[str, object], ready_at: dt.datetime) -> None:
+    ready = dict(payload["paired_profile_coordination"]["ready_record"])
+    ready["ready_at_utc"] = ready_at.isoformat()
+    payload["paired_profile_coordination"]["ready_record"] = _readdress(ready)
+
+
+def _rewrite_campaign(
+    path: Path,
+    mutation: object,
+    *,
+    readdress_harness: bool = False,
+    readdress_outer: bool = True,
+) -> None:
+    payload = json.loads(path.read_text())
+    assert callable(mutation)
+    mutation(payload)
+    if readdress_harness:
+        payload["harness"] = _readdress(payload["harness"])
+    if readdress_outer:
+        payload = _readdress(payload)
+    _write_payload(path, payload)
+
+
+def _rewrite_watchdog_report(
+    path: Path,
+    mutation: object,
+    *,
+    readdress: bool = True,
+) -> None:
+    payload = json.loads(path.read_text())
+    assert callable(mutation)
+    mutation(payload)
+    if readdress:
+        payload = _readdress(payload)
+    _write_payload(path, payload)
+
+
+def _rebind_retained_sample(
+    payload: dict[str, object],
+    schedule_index: int,
+) -> None:
+    entry, sample = _entry_and_sample(payload, schedule_index)
+    prior = sample.pop("worker_result_record")
+    result = dict(prior)
+    result.pop("content_sha256")
+    result["addressed_payload_sha256"] = _sha256(sample)
+    rebound = _address(result)
+    sample["worker_result_record"] = rebound
+    entry["worker_result_record"] = rebound
+    entry["worker_result_sha256"] = result["addressed_payload_sha256"]
+    completion = dict(entry["paired_profile_completion"])
+    completion["worker_result_record_sha256"] = rebound["content_sha256"]
+    _replace_completion(payload, schedule_index, _readdress(completion))
+
+
+def _refresh_mode_semantic(
+    payload: dict[str, object],
+    mode: str,
+) -> dict[str, object]:
+    semantic = payload["profiles"][mode]["artifact_semantic_identity"]
+    digest = _sha256(semantic)
+    payload["profiles"][mode]["artifact_semantic_identity_sha256"] = digest
+    payload["generation"][mode]["artifact_identity"]["semantic_identity"] = (
+        copy.deepcopy(semantic)
+    )
+    payload["generation"][mode]["artifact_identity"]["semantic_identity_sha256"] = (
+        digest
+    )
+    return semantic
+
+
+def _rebuild_selected_union_projections(payload: dict[str, object]) -> None:
+    color_request = payload["configuration"]["color_flow_request"]
+    projections = {
+        mode: _selected_union_projection(
+            payload["profiles"][mode]["artifact_semantic_identity"],
+            process_id="d_dbar_to_z_6g",
+            color_flow_request=color_request,
+        )
+        for mode in gate.CAPTURE_MODES
+    }
+    assert len({_sha256(value) for value in projections.values()}) == 1
+    contract = payload["capture_acceptance"]["artifact_semantic_contract"]
+    contract["common_physics_contract"] = projections["compiled"]
+    for mode, projection in projections.items():
+        contract["lane_contracts"][mode]["selected_union_workload_projection"] = (
+            projection
+        )
+
+
+def test_gate_rejects_split_schedule_and_sample_worker_provenance(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    entry, sample = _entry_and_sample(payload, 0)
+    invocation = dict(sample["worker_invocation"])
+    invocation["identifier"] = 999_001
+    invocation = _readdress(invocation)
+    result = dict(sample["worker_result_record"])
+    result["worker_invocation_sha256"] = invocation["content_sha256"]
+    result = _readdress(result)
+    entry["worker_invocation"] = invocation
+    entry["worker_result_record"] = result
+    completion = dict(entry["paired_profile_completion"])
+    completion["worker_invocation_sha256"] = invocation["content_sha256"]
+    completion["worker_result_record_sha256"] = result["content_sha256"]
+    _replace_completion(payload, 0, _readdress(completion))
+    _write_payload(path, payload)
+
+    with pytest.raises(gate.EvidenceError, match="sample worker provenance differs"):
+        _compare(paths)
+
+
+def test_gate_rejects_global_cross_role_worker_identity_reuse(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    baseline_path = paths["baseline-topology-replay"]
+    candidate_path = paths["candidate-topology-replay"]
+    baseline = json.loads(baseline_path.read_text())
+    candidate = json.loads(candidate_path.read_text())
+    started = _TEST_EPOCH + dt.timedelta(seconds=14)
+    invocation = _address(
+        {
+            "kind": "shared-forged-invocation",
+            "started_at_utc": started.isoformat(),
+            "finished_at_utc": (started + dt.timedelta(seconds=1)).isoformat(),
+            "wall_seconds": 12.0,
+        }
+    )
+    process_record = _address(
+        {"kind": "shared-forged-process", "wall_seconds": 12.0}
+    )
+    _replace_worker_provenance(
+        baseline,
+        0,
+        invocation=invocation,
+        process_record=process_record,
+    )
+    _replace_worker_provenance(
+        candidate,
+        1,
+        invocation=invocation,
+        process_record=process_record,
+    )
+    _write_payload(baseline_path, baseline)
+    _write_payload(candidate_path, candidate)
+
+    with pytest.raises(
+        gate.EvidenceError,
+        match=r"reuses worker_(invocation|process_record)_sha256 identity",
+    ):
+        _compare(paths)
+
+
+def test_gate_rejects_second_token_before_first_worker_finishes(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    _replace_token_issued_at(
+        payload,
+        0,
+        _TEST_EPOCH + dt.timedelta(seconds=1, milliseconds=500),
+    )
+    _write_payload(path, payload)
+
+    with pytest.raises(gate.EvidenceError, match="admitted the second role"):
+        _compare(paths)
+
+
+def test_gate_rejects_ready_record_after_first_token(tmp_path: Path) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    _replace_ready_at(
+        payload,
+        _TEST_EPOCH + dt.timedelta(seconds=3, milliseconds=500),
+    )
+    _write_payload(path, payload)
+
+    with pytest.raises(gate.EvidenceError, match="timestamps are inverted"):
+        _compare(paths)
+
+
+def test_gate_rejects_cross_layout_overlap(tmp_path: Path) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-all-flow-union"]
+    payload = json.loads(path.read_text())
+    _replace_ready_at(payload, _TEST_EPOCH + dt.timedelta(seconds=100))
+    _write_payload(path, payload)
+
+    with pytest.raises(gate.EvidenceError, match="layouts overlap or reorder"):
+        _compare(paths)
+
+
+def test_gate_binds_valid_outer_campaign_manifest(tmp_path: Path) -> None:
+    comparison = _compare(_write_campaign(tmp_path))
+    campaign = comparison["inputs"]["paired_campaign"]
+    watchdog = comparison["inputs"]["outer_memory_watchdog"]
+    assert campaign["campaign_content_sha256"]
+    assert campaign["harness_content_sha256"]
+    assert campaign["orchestrator_content_sha256"]
+    assert watchdog["report_content_sha256"]
+    assert watchdog["bound_campaign_sha256"] == campaign["sha256"]
+    assert comparison["inputs"]["externally_pinned_role_inputs"] == {
+        "candidate_source_revision": EXPECTED_CANDIDATE_REVISION,
+        "roles": {
+            "baseline": {
+                "native_build_inputs_sha256": (
+                    EXPECTED_BASELINE_NATIVE_BUILD_INPUTS
+                ),
+                "prepared_model_sha256": EXPECTED_BASELINE_PREPARED_MODEL,
+            },
+            "candidate": {
+                "native_build_inputs_sha256": (
+                    EXPECTED_CANDIDATE_NATIVE_BUILD_INPUTS
+                ),
+                "prepared_model_sha256": EXPECTED_CANDIDATE_PREPARED_MODEL,
+            },
+        },
+    }
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "message"),
+    [
+        (
+            "expected_candidate_source_revision",
+            "3" * 40,
+            "externally pinned source revision",
+        ),
+        (
+            "expected_baseline_native_build_inputs_sha256",
+            "3" * 64,
+            "baseline .*capture.*native-build-input",
+        ),
+        (
+            "expected_candidate_native_build_inputs_sha256",
+            "4" * 64,
+            "candidate .*capture.*native-build-input",
+        ),
+        (
+            "expected_baseline_prepared_model_sha256",
+            "5" * 64,
+            "baseline .*capture.*prepared-model",
+        ),
+        (
+            "expected_candidate_prepared_model_sha256",
+            "6" * 64,
+            "candidate .*capture.*prepared-model",
+        ),
+    ],
+)
+def test_gate_requires_externally_pinned_role_inputs(
+    field: str,
+    value: str,
+    message: str,
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    with pytest.raises(gate.EvidenceError, match=message):
+        _compare(paths, **{field: value})
+
+
+@pytest.mark.parametrize(
+    ("identity", "message"),
+    (
+        ("native", "candidate all-flow-union capture.*native-build-input"),
+        ("prepared", "candidate all-flow-union capture.*prepared-model"),
+    ),
+)
+def test_gate_applies_external_identity_pins_to_every_layout(
+    identity: str,
+    message: str,
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-all-flow-union"]
+    payload = json.loads(path.read_text())
+    if identity == "native":
+        payload["runtime_provenance"]["native_extension"][
+            "build_inputs_sha256"
+        ] = "7" * 64
+    else:
+        for model in payload["configuration"]["model_identities"].values():
+            model["file"]["sha256"] = "7" * 64
+    _write_payload(path, payload)
+
+    with pytest.raises(gate.EvidenceError, match=message):
+        _compare(paths)
+
+
+def test_gate_accepts_watchdog_probe_failures_recovered_below_policy(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+
+    def recovered(payload: dict[str, object]) -> None:
+        enforcement = payload["enforcement"]
+        enforcement["probe_failure_count"] = 7
+        enforcement["maximum_consecutive_probe_failures"] = 1
+
+    _rewrite_watchdog_report(paths["watchdog-report"], recovered)
+    comparison = _compare(paths)
+    assert comparison["passes"] is True
+
+
+@pytest.mark.parametrize(
+    ("mutation", "expected"),
+    (
+        ("tool", "authenticated watchdog tool"),
+        ("limit", "30-GiB enforcement"),
+        ("retry", "recovered-probe retry policy"),
+        ("session", "command session differs"),
+        ("result", "content-address the supplied paired campaign"),
+    ),
+)
+def test_gate_rejects_readdressed_watchdog_report_tampering(
+    tmp_path: Path,
+    mutation: str,
+    expected: str,
+) -> None:
+    paths = _write_campaign(tmp_path)
+
+    def tamper(payload: dict[str, object]) -> None:
+        if mutation == "tool":
+            payload["watchdog"]["sha256"] = "f" * 64
+        elif mutation == "limit":
+            payload["enforcement"]["limit_bytes"] -= 1
+        elif mutation == "retry":
+            payload["enforcement"]["probe_failure_count"] = 3
+            payload["enforcement"]["maximum_consecutive_probe_failures"] = 3
+        elif mutation == "session":
+            command = payload["execution"]["command"]
+            session_index = command.index("--session-id") + 1
+            command[session_index] = "forged-session"
+            payload["execution"]["command_sha256"] = _sha256(command)
+        else:
+            payload["result_binding"]["identity"]["sha256"] = "f" * 64
+
+    _rewrite_watchdog_report(paths["watchdog-report"], tamper)
+    with pytest.raises(gate.EvidenceError, match=expected):
+        _compare(paths)
+
+
+def test_gate_rejects_outer_campaign_address_tamper(tmp_path: Path) -> None:
+    paths = _write_campaign(tmp_path)
+    _rewrite_campaign(
+        paths["campaign"],
+        lambda payload: payload.__setitem__("complete", False),
+        readdress_outer=False,
+    )
+
+    with pytest.raises(gate.EvidenceError, match="content address"):
+        _compare(paths)
+
+
+def test_gate_rejects_campaign_capture_hash_drift(tmp_path: Path) -> None:
+    paths = _write_campaign(tmp_path)
+    with paths["candidate-topology-replay"].open("ab") as stream:
+        stream.write(b" ")
+
+    with pytest.raises(
+        gate.EvidenceError,
+        match="does not identify its supplied capture file",
+    ):
+        _compare(paths)
+
+
+@pytest.mark.parametrize(
+    ("field", "expected"),
+    (
+        ("session", "session_id differs"),
+        ("revision", "differs from its capture provenance"),
+        ("pack", "differs from its capture provenance"),
+        ("configuration", "configuration differs"),
+    ),
+)
+def test_gate_rejects_semantically_forged_campaign_fields(
+    tmp_path: Path,
+    field: str,
+    expected: str,
+) -> None:
+    paths = _write_campaign(tmp_path)
+
+    def mutate(payload: dict[str, object]) -> None:
+        if field == "session":
+            payload["session_id"] = "forged-session"
+        elif field == "revision":
+            payload["roles"]["candidate"]["source_revision"] = "f" * 40
+        elif field == "pack":
+            payload["roles"]["candidate"]["prepared_model_sha256"] = "f" * 64
+        else:
+            payload["configuration"]["warmup_runs"] = 3
+
+    _rewrite_campaign(paths["campaign"], mutate)
+    with pytest.raises(gate.EvidenceError, match=expected):
+        _compare(paths)
+
+
+def test_gate_rejects_capture_with_more_than_two_warmups(tmp_path: Path) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    payload["configuration"]["warmup_runs"] = 3
+    _write_payload(path, payload)
+
+    with pytest.raises(gate.EvidenceError, match="exactly 2 warmup"):
+        _compare(paths)
+
+
+def test_gate_rejects_eight_outer_subprocess_pairs(tmp_path: Path) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    payload["configuration"]["subprocess_samples"] = 8
+    _write_payload(path, payload)
+
+    with pytest.raises(
+        gate.EvidenceError,
+        match="exactly 7 independent subprocess pairs",
+    ):
+        _compare(paths)
+
+
+@pytest.mark.parametrize("field", ("candidate_relative_path", "head_blob_sha256"))
+def test_gate_rejects_forged_campaign_harness(
+    tmp_path: Path,
+    field: str,
+) -> None:
+    paths = _write_campaign(tmp_path)
+
+    def mutate(payload: dict[str, object]) -> None:
+        payload["harness"][field] = (
+            "tools/developer/forged.py"
+            if field == "candidate_relative_path"
+            else "f" * 64
+        )
+
+    _rewrite_campaign(
+        paths["campaign"],
+        mutate,
+        readdress_harness=True,
+    )
+    with pytest.raises(gate.EvidenceError, match="exact candidate benchmark driver"):
+        _compare(paths)
+
+
+@pytest.mark.parametrize(
+    "process",
+    (
+        "d d~ > z + 6*g",
+        "d d~ > Z g g g g g g",
+        "u u~ > Z g g g g g g",
+    ),
+)
+def test_gate_accepts_exact_d_route_and_existing_u_route(
+    tmp_path: Path,
+    process: str,
+) -> None:
+    comparison = _compare(_write_campaign(tmp_path, process=process))
+    assert comparison["complete"] is True
+    assert comparison["passes"] is True
+    assert comparison["failures"] == []
+    unsigned = dict(comparison)
+    digest = unsigned.pop("content_sha256")
+    assert digest == _sha256(unsigned)
+    assert len(comparison["runtime_cells"]) == 12
+    assert len(comparison["paired_compiled_recurrence_ratios"]) == 4
+    assert len(comparison["eager_diagnostic"]["runtime_cells"]) == 6
+    assert comparison["eager_diagnostic"]["passes"] is True
+    assert (
+        comparison["eager_diagnostic"]["paired_compiled_recurrence_ratio_applicable"]
+        is False
+    )
+
+
+def test_selected_union_projection_allows_only_audited_lane_metadata_drift(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    payload = json.loads(paths["baseline-all-flow-union"].read_text())
+    compiled = payload["profiles"]["compiled"]["artifact_semantic_identity"]
+    recurrence = payload["profiles"]["recurrence"]["artifact_semantic_identity"]
+    assert compiled["reduction_ordering"] != recurrence["reduction_ordering"]
+    assert (
+        compiled["physical_helicities"]["ordered_entries"]
+        != recurrence["physical_helicities"]["ordered_entries"]
+    )
+    contract = payload["capture_acceptance"]["artifact_semantic_contract"]
+    assert contract["comparison_policy"] == (
+        gate.SELECTED_UNION_SEMANTIC_COMPARISON_POLICY
+    )
+    assert all(
+        lane["selected_union_workload_projection"]
+        == contract["common_physics_contract"]
+        for lane in contract["lane_contracts"].values()
+    )
+    comparison = _compare(paths)
+    assert comparison["passes"] is True
+
+
+@pytest.mark.parametrize(
+    "mutation",
+    ("policy", "lane", "color", "model", "selector", "selected"),
+)
+def test_selected_union_projection_fails_closed_on_projection_drift(
+    tmp_path: Path,
+    mutation: str,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-all-flow-union"]
+    payload = json.loads(path.read_text())
+    contract = payload["capture_acceptance"]["artifact_semantic_contract"]
+    common = contract["common_physics_contract"]
+    if mutation == "policy":
+        contract["comparison_policy"] = gate.STRICT_SEMANTIC_COMPARISON_POLICY
+    elif mutation == "lane":
+        lane = contract["lane_contracts"]["recurrence"][
+            "selected_union_workload_projection"
+        ]
+        lane["physical_helicities"]["selected_entry"]["coefficient"] = 2.0
+    else:
+        if mutation == "color":
+            common["physical_color_flows"]["ordered_ids_sha256"] = "0" * 64
+        elif mutation == "model":
+            common["model_common_physics_identity_sha256"] = "0" * 64
+        elif mutation == "selector":
+            common["profile_selector"]["resolved_color_flow_id"] = "flow:forged"
+        else:
+            common["physical_helicities"]["selected_entry"]["coefficient"] = 0.0
+        for lane in contract["lane_contracts"].values():
+            lane["selected_union_workload_projection"] = copy.deepcopy(common)
+    _write_payload(path, payload)
+    with pytest.raises(
+        gate.EvidenceError,
+        match=r"policy|projection|selector|helic|coefficient",
+    ):
+        _compare(paths)
+
+
+def test_selected_union_projection_drift_across_captures_is_rejected(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-all-flow-union"]
+    payload = json.loads(path.read_text())
+    for mode in ALL_MODES:
+        semantic = payload["profiles"][mode]["artifact_semantic_identity"]
+        selected = semantic["physical_helicities"]["ordered_entries"][
+            gate.SELECTED_UNION_HELICITY_INDEX
+        ]
+        selected["coefficient"] = 2.0
+        semantic["physical_helicities"]["ordered_entries_sha256"] = _sha256(
+            semantic["physical_helicities"]["ordered_entries"]
+        )
+        _refresh_mode_semantic(payload, mode)
+    _rebuild_selected_union_projections(payload)
+    _write_payload(path, payload)
+
+    with pytest.raises(gate.EvidenceError, match="workload identities differ"):
+        _compare(paths)
+
+
+@pytest.mark.parametrize(
+    ("process", "layout", "helicity"),
+    (
+        ("d d~ > Z g g g g g g", "topology-replay", "1"),
+        ("u u~ > Z g g g g g g", "all-flow-union", "h:-1,+1"),
+        ("d d~ > Z g g g g g g", "all-flow-union", "1"),
+    ),
+)
+def test_selected_union_exception_is_unavailable_outside_exact_route(
+    tmp_path: Path,
+    process: str,
+    layout: str,
+    helicity: str,
+) -> None:
+    paths = _write_campaign(tmp_path, process=process)
+    path = paths[f"candidate-{layout}"]
+    payload = json.loads(path.read_text())
+    payload["configuration"]["helicity_request"] = helicity
+    payload["capture_acceptance"]["artifact_semantic_contract"]["comparison_policy"] = (
+        gate.SELECTED_UNION_SEMANTIC_COMPARISON_POLICY
+    )
+    _write_payload(path, payload)
+    with pytest.raises(gate.EvidenceError, match=r"policy|must select"):
+        _compare(paths)
+
+
+def test_strict_topology_still_rejects_full_axis_drift(tmp_path: Path) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    semantic = payload["profiles"]["compiled"]["artifact_semantic_identity"]
+    semantic["physical_helicities"]["ordered_entries"][0]["index"] = 99
+    _refresh_mode_semantic(payload, "compiled")
+    _write_payload(path, payload)
+    with pytest.raises(gate.EvidenceError, match="workload identities differ"):
+        _compare(paths)
+
+
+def test_gate_recomputes_runtime_statistics_and_rejects_forged_aggregate(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    aggregate = payload["profiles"]["compiled"]["profiles"][0]
+    aggregate["wall_seconds_per_point_median"] *= 0.5
+    path.write_bytes(_canonical(payload) + b"\n")
+    with pytest.raises(gate.EvidenceError, match="not reproducible"):
+        _compare(paths)
+
+
+def test_gate_independently_revalidates_eager_raw_samples(tmp_path: Path) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    aggregate = payload["profiles"]["eager"]["profiles"][0]
+    aggregate["wall_seconds_per_point_median"] *= 0.5
+    path.write_bytes(_canonical(payload) + b"\n")
+    with pytest.raises(gate.EvidenceError, match="not reproducible"):
+        _compare(paths)
+
+
+def test_gate_rejects_readdressed_sub_five_second_native_wall_evidence(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    _, sample = _entry_and_sample(payload, 0)
+    raw = sample["inner_native_wall_blocks"]
+    raw["observed_native_wall_seconds"] = 4.999
+    raw["minimum_duration_satisfied"] = True
+    _rebind_retained_sample(payload, 0)
+    _write_payload(path, payload)
+
+    with pytest.raises(
+        gate.EvidenceError,
+        match="raw native-wall measurement contract is invalid",
+    ):
+        _compare(paths)
+
+
+def test_gate_rejects_readdressed_raw_calibration_tampering(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    _, sample = _entry_and_sample(payload, 0)
+    raw = sample["inner_native_wall_blocks"]
+    raw["calibration"]["duration_headroom_factor"] = 1.01
+    sample["worker_measurement"]["inner_native_wall_blocks"] = copy.deepcopy(raw)
+    _rebind_retained_sample(payload, 0)
+    _write_payload(path, payload)
+
+    with pytest.raises(
+        gate.EvidenceError,
+        match="raw native-wall measurement contract is invalid",
+    ):
+        _compare(paths)
+
+
+def test_gate_reports_runtime_and_same_round_ratio_failures(tmp_path: Path) -> None:
+    runtime = _compare(_write_campaign(tmp_path / "runtime", runtime_ratio=1.04))
+    assert runtime["passes"] is False
+    assert any(
+        failure.startswith("runtime regression:") for failure in runtime["failures"]
+    )
+
+    ratio = _compare(
+        _write_campaign(
+            tmp_path / "ratio",
+            compiled_to_recurrence_ratio=1.20,
+        )
+    )
+    assert ratio["passes"] is False
+    assert any(
+        failure.startswith("compiled/recurrence ratio regression:")
+        for failure in ratio["failures"]
+    )
+
+
+def test_gate_enforces_generation_cell_and_geometric_mean_limits(
+    tmp_path: Path,
+) -> None:
+    comparison = _compare(_write_campaign(tmp_path, generation_ratio=1.11))
+    assert comparison["passes"] is False
+    assert comparison["generation"]["geometric_mean_passes"] is False
+    assert "generation geometric-mean regression" in comparison["failures"]
+    assert (
+        sum(
+            failure.startswith("generation regression:")
+            for failure in comparison["failures"]
+        )
+        == 4
+    )
+
+
+def test_eager_diagnostic_runtime_generation_and_resource_failures(
+    tmp_path: Path,
+) -> None:
+    runtime = _compare(
+        _write_campaign(
+            tmp_path / "runtime",
+            eager_runtime_ratio=1.04,
+        )
+    )
+    assert runtime["passes"] is False
+    assert all(cell["passes"] is True for cell in runtime["runtime_cells"])
+    assert runtime["eager_diagnostic"]["runtime_passes"] is False
+    assert any(
+        failure.startswith("eager diagnostic runtime regression:")
+        for failure in runtime["eager_diagnostic"]["failures"]
+    )
+    assert any(
+        failure.startswith("eager diagnostic runtime regression:")
+        for failure in runtime["failures"]
+    )
+
+    generation = _compare(
+        _write_campaign(
+            tmp_path / "generation",
+            eager_generation_ratio=1.11,
+        )
+    )
+    assert generation["passes"] is False
+    assert generation["generation"]["geometric_mean_passes"] is True
+    assert generation["eager_diagnostic"]["generation"]["passes"] is False
+    assert any(
+        failure.startswith("eager diagnostic generation regression:")
+        for failure in generation["eager_diagnostic"]["failures"]
+    )
+    assert any(
+        failure.startswith("eager diagnostic generation regression:")
+        for failure in generation["failures"]
+    )
+
+    resources = _compare(
+        _write_campaign(
+            tmp_path / "resources",
+            eager_resource_ratio=1.04,
+        )
+    )
+    assert resources["passes"] is False
+    assert resources["eager_diagnostic"]["resource_passes"] is False
+    assert any(
+        failure.startswith("eager diagnostic resource regression:")
+        for failure in resources["eager_diagnostic"]["failures"]
+    )
+    assert any(
+        failure.startswith("eager diagnostic resource regression:")
+        for failure in resources["failures"]
+    )
+
+
+def test_eager_generation_has_a_five_percent_geometric_mean_gate(
+    tmp_path: Path,
+) -> None:
+    comparison = _compare(
+        _write_campaign(
+            tmp_path,
+            eager_generation_ratio=1.06,
+        )
+    )
+    eager_generation = comparison["eager_diagnostic"]["generation"]
+    assert comparison["passes"] is False
+    assert all(cell["passes"] is True for cell in eager_generation["cells"])
+    assert eager_generation["geometric_mean_passes"] is False
+    assert eager_generation["passes"] is False
+    assert any(
+        failure == "eager diagnostic generation geometric-mean regression"
+        for failure in comparison["eager_diagnostic"]["failures"]
+    )
+
+
+def test_gate_requires_eager_present_and_admissible(tmp_path: Path) -> None:
+    missing_paths = _write_campaign(tmp_path / "missing")
+    missing_path = missing_paths["candidate-topology-replay"]
+    missing = json.loads(missing_path.read_text())
+    missing["configuration"]["modes"].remove("eager")
+    _write_payload(missing_path, missing)
+    with pytest.raises(gate.EvidenceError, match="compiled, recurrence, and eager"):
+        _compare(missing_paths)
+
+    inadmissible_paths = _write_campaign(tmp_path / "inadmissible")
+    inadmissible_path = inadmissible_paths["candidate-topology-replay"]
+    inadmissible = json.loads(inadmissible_path.read_text())
+    eager = inadmissible["capture_acceptance"]["eager_diagnostic"]
+    eager["complete"] = False
+    eager["passes"] = None
+    eager["ineligibility_reasons"] = ["synthetic failure"]
+    _write_payload(inadmissible_path, inadmissible)
+    with pytest.raises(gate.EvidenceError, match="not complete and admissible"):
+        _compare(inadmissible_paths)
+
+
+def test_eager_resource_growth_uses_the_runtime_gain_exception(
+    tmp_path: Path,
+) -> None:
+    comparison = _compare(
+        _write_campaign(
+            tmp_path,
+            eager_runtime_ratio=0.85,
+            eager_resource_ratio=1.20,
+        )
+    )
+    eager = comparison["eager_diagnostic"]
+    assert comparison["passes"] is True
+    assert eager["passes"] is True
+    assert any(
+        resource["within_3_percent_growth_limit"] is False
+        and resource["runtime_gain_exception"]["passes"] is True
+        for resource in eager["payload_cold_load_rss"]
+    )
+
+
+def test_resource_growth_needs_a_ten_percent_noise_clear_runtime_gain(
+    tmp_path: Path,
+) -> None:
+    regression = _compare(_write_campaign(tmp_path / "regression", resource_ratio=1.04))
+    assert regression["passes"] is False
+    assert any(
+        failure.startswith("resource regression:") for failure in regression["failures"]
+    )
+
+    exception = _compare(
+        _write_campaign(
+            tmp_path / "exception",
+            runtime_ratio=0.85,
+            resource_ratio=1.20,
+        )
+    )
+    assert exception["passes"] is True
+    assert all(
+        resource["passes"] is True for resource in exception["payload_cold_load_rss"]
+    )
+    assert any(
+        resource["within_3_percent_growth_limit"] is False
+        and resource["runtime_gain_exception"]["passes"] is True
+        for resource in exception["payload_cold_load_rss"]
+    )
+
+
+def test_gate_fails_closed_on_workload_identity_drift(tmp_path: Path) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-all-flow-union"]
+    payload = json.loads(path.read_text())
+    payload["profiles"]["compiled"]["selector_contract"]["color_flow_count"] = 3
+    path.write_bytes(_canonical(payload) + b"\n")
+    with pytest.raises(
+        gate.EvidenceError,
+        match="selector differs from its selected-union projection",
+    ):
+        _compare(paths)
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (("complete", False), ("passes", None)),
+)
+def test_gate_requires_top_level_complete_passing_captures(
+    tmp_path: Path,
+    field: str,
+    value: object,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-topology-replay"]
+    payload = json.loads(path.read_text())
+    payload[field] = value
+    path.write_bytes(_canonical(payload) + b"\n")
+    with pytest.raises(
+        gate.EvidenceError,
+        match="not top-level complete and passing",
+    ):
+        _compare(paths)
+
+
+def test_gate_requires_consistent_authoritative_capture_acceptance(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["candidate-all-flow-union"]
+    payload = json.loads(path.read_text())
+    payload["capture_acceptance"]["evidence_complete"] = False
+    path.write_bytes(_canonical(payload) + b"\n")
+    with pytest.raises(
+        gate.EvidenceError,
+        match="not authoritative, complete, and passing",
+    ):
+        _compare(paths)
+
+
+def test_legacy_capture_without_cold_load_has_actionable_error(
+    tmp_path: Path,
+) -> None:
+    paths = _write_campaign(tmp_path)
+    path = paths["baseline-topology-replay"]
+    payload = json.loads(path.read_text())
+    del payload["profiles"]["compiled"]["profiles"][0]["subprocess_samples"][0][
+        "cold_load_seconds"
+    ]
+    path.write_bytes(_canonical(payload) + b"\n")
+    with pytest.raises(
+        gate.EvidenceError,
+        match=r"predates the resource-evidence contract.*re-run",
+    ):
+        _compare(paths)
+
+
+def test_cli_writes_canonical_content_addressed_report(tmp_path: Path) -> None:
+    paths = _write_campaign(tmp_path)
+    output = tmp_path / "comparison.json"
+    exit_code = gate.main(
+        [
+            "--baseline-topology",
+            str(paths["baseline-topology-replay"]),
+            "--campaign",
+            str(paths["campaign"]),
+            "--watchdog-report",
+            str(paths["watchdog-report"]),
+            "--baseline-all-flow-union",
+            str(paths["baseline-all-flow-union"]),
+            "--candidate-topology",
+            str(paths["candidate-topology-replay"]),
+            "--candidate-all-flow-union",
+            str(paths["candidate-all-flow-union"]),
+            "--expected-candidate-source-revision",
+            EXPECTED_CANDIDATE_REVISION,
+            "--expected-baseline-native-build-inputs-sha256",
+            EXPECTED_BASELINE_NATIVE_BUILD_INPUTS,
+            "--expected-candidate-native-build-inputs-sha256",
+            EXPECTED_CANDIDATE_NATIVE_BUILD_INPUTS,
+            "--expected-baseline-prepared-model-sha256",
+            EXPECTED_BASELINE_PREPARED_MODEL,
+            "--expected-candidate-prepared-model-sha256",
+            EXPECTED_CANDIDATE_PREPARED_MODEL,
+            "--output",
+            str(output),
+        ]
+    )
+    assert exit_code == 0
+    payload = json.loads(output.read_text())
+    unsigned = copy.deepcopy(payload)
+    digest = unsigned.pop("content_sha256")
+    assert digest == _sha256(unsigned)
+    assert output.read_bytes() == _canonical(payload) + b"\n"
diff --git a/pyamplicol/tests/unit/test_symjit_2_22_paired_benchmark.py b/pyamplicol/tests/unit/test_symjit_2_22_paired_benchmark.py
new file mode 100644
index 0000000000..fd34c79382
--- /dev/null
+++ b/pyamplicol/tests/unit/test_symjit_2_22_paired_benchmark.py
@@ -0,0 +1,753 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import argparse
+import copy
+import hashlib
+import importlib.util
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "tools" / "developer" / "symjit_2_22_paired_benchmark.py"
+SPEC = importlib.util.spec_from_file_location(
+    "symjit_2_22_paired_benchmark",
+    SCRIPT,
+)
+assert SPEC is not None and SPEC.loader is not None
+paired = importlib.util.module_from_spec(SPEC)
+sys.modules[SPEC.name] = paired
+SPEC.loader.exec_module(paired)
+
+
+def _expected_identity_arguments(
+    candidate_revision: str = "c" * 40,
+) -> tuple[str, ...]:
+    return (
+        "--expected-candidate-source-revision",
+        candidate_revision,
+        "--expected-baseline-native-build-inputs-sha256",
+        "a" * 64,
+        "--expected-candidate-native-build-inputs-sha256",
+        "b" * 64,
+        "--expected-baseline-prepared-model-sha256",
+        "c" * 64,
+        "--expected-candidate-prepared-model-sha256",
+        "d" * 64,
+    )
+
+
+def _git(repository: Path, *arguments: str) -> str:
+    result = subprocess.run(
+        ("git", *arguments),
+        cwd=repository,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip()
+
+
+def _repository(path: Path, files: dict[str, str]) -> tuple[Path, str]:
+    path.mkdir()
+    _git(path, "init", "--quiet")
+    for relative, content in files.items():
+        destination = path / relative
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_text(content, encoding="utf-8")
+    _git(path, "add", "--all")
+    _git(
+        path,
+        "-c",
+        "user.name=paired benchmark test",
+        "-c",
+        "user.email=paired-benchmark-test@invalid",
+        "commit",
+        "--quiet",
+        "-m",
+        "fixture",
+    )
+    return path.resolve(), _git(path, "rev-parse", "HEAD")
+
+
+def _fake_driver_source() -> str:
+    return r"""#!/usr/bin/env python3
+import argparse
+import datetime as dt
+import hashlib
+import json
+import os
+import subprocess
+import time
+from pathlib import Path
+
+
+def canonical(value):
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+def addressed(value):
+    result = dict(value)
+    result["content_sha256"] = hashlib.sha256(canonical(result)).hexdigest()
+    return result
+
+
+def write(path, value):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(canonical(value) + b"\n")
+
+
+def now():
+    return dt.datetime.now(dt.timezone.utc).isoformat()
+
+
+parser = argparse.ArgumentParser(add_help=False)
+parser.add_argument("--result-json", type=Path, required=True)
+parser.add_argument("--paired-profile-coordination-dir", type=Path, required=True)
+parser.add_argument("--paired-profile-role", required=True)
+parser.add_argument("--paired-profile-session-id", required=True)
+parser.add_argument("--lc-flow-layout", required=True)
+arguments, _ = parser.parse_known_args()
+source_root = Path(os.environ["PYAMPLICOL_BENCHMARK_SOURCE_ROOT"])
+revision = subprocess.run(
+    ("git", "rev-parse", "HEAD"),
+    cwd=source_root,
+    check=True,
+    capture_output=True,
+    text=True,
+).stdout.strip()
+role_root = (
+    arguments.paired_profile_coordination_dir
+    / arguments.paired_profile_session_id
+    / arguments.lc_flow_layout
+    / arguments.paired_profile_role
+)
+plan = [
+    {
+        "schedule_index": 0,
+        "round": 0,
+        "mode": "compiled",
+        "batch_size": 1,
+    }
+]
+write(
+    role_root / "ready.json",
+    addressed(
+        {
+            "kind": "pyamplicol-paired-profile-ready",
+            "schema_version": 1,
+            "session_id": arguments.paired_profile_session_id,
+            "role": arguments.paired_profile_role,
+            "layout": arguments.lc_flow_layout,
+            "source_revision": revision,
+            "ready_at_utc": now(),
+            "profile_schedule_plan": plan,
+            "profile_schedule_plan_sha256": hashlib.sha256(
+                canonical(plan)
+            ).hexdigest(),
+        }
+    ),
+)
+token_path = role_root / "token-000000.json"
+deadline = time.monotonic() + 15.0
+while not token_path.is_file():
+    if time.monotonic() >= deadline:
+        raise RuntimeError("fake driver timed out waiting for token")
+    time.sleep(0.01)
+token = json.loads(token_path.read_text(encoding="utf-8"))
+started = now()
+time.sleep(0.01)
+finished = now()
+write(
+    role_root / "completion-000000.json",
+    addressed(
+        {
+            "kind": "pyamplicol-paired-profile-completion",
+            "schema_version": 1,
+            "session_id": arguments.paired_profile_session_id,
+            "role": arguments.paired_profile_role,
+            "layout": arguments.lc_flow_layout,
+            "token_sha256": token["content_sha256"],
+            "schedule_index": 0,
+            "round": 0,
+            "mode": "compiled",
+            "batch_size": 1,
+            "worker_started_at_utc": started,
+            "worker_finished_at_utc": finished,
+            "recorded_at_utc": now(),
+            "worker_invocation_sha256": "1" * 64,
+            "worker_result_record_sha256": "2" * 64,
+        }
+    ),
+)
+write(arguments.result_json, addressed({"role": arguments.paired_profile_role}))
+"""
+
+
+def _campaign_record_fixture() -> dict[str, object]:
+    harness = paired._address(
+        {
+            "kind": paired.HARNESS_IDENTITY_KIND,
+            "schema_version": paired.HARNESS_IDENTITY_SCHEMA,
+            "candidate_relative_path": "tools/developer/fixture.py",
+            "head_blob_sha256": "1" * 64,
+            "working_file_sha256": "1" * 64,
+            "head_blob_equals_working_file": True,
+        }
+    )
+    orchestrator = paired._address(
+        {
+            "kind": paired.HARNESS_IDENTITY_KIND,
+            "schema_version": paired.HARNESS_IDENTITY_SCHEMA,
+            "candidate_relative_path": paired.PAIRED_DRIVER_RELATIVE_PATH,
+            "head_blob_sha256": "2" * 64,
+            "working_file_sha256": "2" * 64,
+            "head_blob_equals_working_file": True,
+        }
+    )
+    return paired._address(
+        {
+            "kind": paired.CAMPAIGN_KIND,
+            "schema_version": paired.CAMPAIGN_SCHEMA,
+            "complete": True,
+            "session_id": "binding-fixture",
+            "orchestrator": orchestrator,
+            "harness": harness,
+            "roles": {
+                role: {
+                    "source_revision": character * 40,
+                    "python_resolved_target": f"/fixture/{role}/python",
+                    "python_sha256": character * 64,
+                    "prepared_model": f"/fixture/{role}/model.pack",
+                    "prepared_model_sha256": character.upper() * 64,
+                }
+                for role, character in (("baseline", "a"), ("candidate", "b"))
+            },
+            "configuration": {
+                "authoritative_modes": ["compiled", "recurrence"],
+                "batch_sizes": [1, 128, 1024],
+            },
+            "layouts": {
+                layout: {
+                    "layout": layout,
+                    "captures": {
+                        role: {"sha256": character * 64}
+                        for role, character in (
+                            ("baseline", "c"),
+                            ("candidate", "d"),
+                        )
+                    },
+                }
+                for layout in paired.LAYOUTS
+            },
+        }
+    )
+
+
+def test_parser_defaults_are_gate_compatible_and_eager_opt_out_is_explicit() -> None:
+    required = (
+        "--baseline-python",
+        "baseline-python",
+        "--baseline-source-root",
+        "baseline-source",
+        "--baseline-prepared-model",
+        "baseline-model",
+        "--candidate-python",
+        "candidate-python",
+        "--candidate-source-root",
+        "candidate-source",
+        "--candidate-prepared-model",
+        "candidate-model",
+        *_expected_identity_arguments(),
+        "--output-root",
+        "output",
+        "--result-json",
+        "result.json",
+        "--session-id",
+        "session",
+    )
+
+    defaults = paired.parser().parse_args(required)
+    diagnostic = paired.parser().parse_args((*required, "--no-eager"))
+
+    assert defaults.include_eager is True
+    assert defaults.warmup_runs == paired.MINIMUM_WARMUPS == 2
+    assert defaults.subprocess_samples == paired.MINIMUM_SUBPROCESS_SAMPLES == 7
+    assert (
+        defaults.generation_timeout
+        == paired.MINIMUM_GENERATION_TIMEOUT_SECONDS
+        == 10_800.0
+    )
+    assert (
+        defaults.coordination_timeout
+        == paired.MINIMUM_COORDINATION_TIMEOUT_SECONDS
+        == 43_200.0
+    )
+    assert diagnostic.include_eager is False
+
+    defaults.generation_timeout = 3_600.0
+    with pytest.raises(paired.CampaignError, match="10800 seconds"):
+        paired.run(defaults)
+
+
+def test_campaign_rejects_more_than_exactly_two_warmups() -> None:
+    arguments = paired.parser().parse_args(
+        (
+            "--baseline-python",
+            "baseline-python",
+            "--baseline-source-root",
+            "baseline-source",
+            "--baseline-prepared-model",
+            "baseline-model",
+            "--candidate-python",
+            "candidate-python",
+            "--candidate-source-root",
+            "candidate-source",
+            "--candidate-prepared-model",
+            "candidate-model",
+            *_expected_identity_arguments(),
+            "--output-root",
+            "output",
+            "--result-json",
+            "result.json",
+            "--session-id",
+            "session",
+            "--warmup-runs",
+            "3",
+        )
+    )
+
+    with pytest.raises(paired.CampaignError, match="exactly two warmups"):
+        paired.run(arguments)
+
+
+def test_campaign_rejects_eight_outer_subprocess_pairs() -> None:
+    arguments = paired.parser().parse_args(
+        (
+            "--baseline-python",
+            "baseline-python",
+            "--baseline-source-root",
+            "baseline-source",
+            "--baseline-prepared-model",
+            "baseline-model",
+            "--candidate-python",
+            "candidate-python",
+            "--candidate-source-root",
+            "candidate-source",
+            "--candidate-prepared-model",
+            "candidate-model",
+            *_expected_identity_arguments(),
+            "--output-root",
+            "output",
+            "--result-json",
+            "result.json",
+            "--session-id",
+            "session",
+            "--subprocess-samples",
+            "8",
+        )
+    )
+
+    with pytest.raises(
+        paired.CampaignError,
+        match="exactly seven independent subprocess pairs",
+    ):
+        paired.run(arguments)
+
+
+@pytest.mark.skipif(os.name != "posix", reason="executable symlinks require POSIX")
+def test_executable_file_preserves_lexical_venv_symlink(tmp_path: Path) -> None:
+    target = tmp_path / "python-real"
+    target.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8")
+    target.chmod(0o755)
+    link = tmp_path / "venv" / "bin" / "python"
+    link.parent.mkdir(parents=True)
+    link.symlink_to(target)
+
+    lexical, resolved = paired._executable_file(link, label="fixture Python")
+
+    assert lexical == link.absolute()
+    assert lexical.is_symlink()
+    assert resolved == target.resolve()
+
+
+def test_head_bound_harness_identity_records_head_and_working_bytes(
+    tmp_path: Path,
+) -> None:
+    source = "print('authenticated harness')\n"
+    repository, _ = _repository(
+        tmp_path / "repository",
+        {"tools/developer/harness.py": source},
+    )
+
+    resolved, identity = paired._head_bound_file_identity(
+        repository / "tools" / "developer" / "harness.py",
+        source_root=repository,
+        label="benchmark harness",
+    )
+
+    expected_sha256 = hashlib.sha256(source.encode("utf-8")).hexdigest()
+    assert resolved == repository / "tools" / "developer" / "harness.py"
+    assert identity == {
+        "kind": paired.HARNESS_IDENTITY_KIND,
+        "schema_version": paired.HARNESS_IDENTITY_SCHEMA,
+        "candidate_relative_path": "tools/developer/harness.py",
+        "head_blob_sha256": expected_sha256,
+        "working_file_sha256": expected_sha256,
+        "head_blob_equals_working_file": True,
+        "content_sha256": identity["content_sha256"],
+    }
+    unsigned = dict(identity)
+    content_sha256 = unsigned.pop("content_sha256")
+    assert content_sha256 == paired._sha256(unsigned)
+
+
+def test_source_revision_rejects_nested_repository_root(tmp_path: Path) -> None:
+    repository, _ = _repository(tmp_path / "repository", {"tracked": "value\n"})
+    nested = repository / "nested"
+    nested.mkdir()
+
+    with pytest.raises(
+        paired.CampaignError,
+        match="not the exact Git repository root",
+    ):
+        paired._source_revision(nested, role="candidate")
+
+
+def test_head_bound_file_rejects_untracked_and_modified_harness(
+    tmp_path: Path,
+) -> None:
+    repository, _ = _repository(
+        tmp_path / "repository",
+        {"tracked.py": "print('tracked')\n"},
+    )
+    tracked = repository / "tracked.py"
+    untracked = repository / "untracked.py"
+    untracked.write_text("print('untracked')\n", encoding="utf-8")
+
+    with pytest.raises(paired.CampaignError, match="is not tracked"):
+        paired._head_bound_file(
+            untracked,
+            source_root=repository,
+            label="benchmark harness",
+        )
+
+    tracked.write_text("print('modified')\n", encoding="utf-8")
+    with pytest.raises(paired.CampaignError, match="not byte-identical"):
+        paired._head_bound_file(
+            tracked,
+            source_root=repository,
+            label="benchmark harness",
+        )
+
+
+@pytest.mark.parametrize(
+    "field_path",
+    [
+        ("harness", "candidate_relative_path"),
+        ("orchestrator", "working_file_sha256"),
+        ("roles", "baseline", "source_revision"),
+        ("roles", "candidate", "source_revision"),
+        ("roles", "baseline", "python_resolved_target"),
+        ("roles", "baseline", "python_sha256"),
+        ("roles", "candidate", "python_resolved_target"),
+        ("roles", "candidate", "python_sha256"),
+        ("roles", "baseline", "prepared_model"),
+        ("roles", "baseline", "prepared_model_sha256"),
+        ("roles", "candidate", "prepared_model"),
+        ("roles", "candidate", "prepared_model_sha256"),
+        ("layouts", "topology-replay", "captures", "baseline", "sha256"),
+        ("layouts", "topology-replay", "captures", "candidate", "sha256"),
+        ("layouts", "all-flow-union", "captures", "baseline", "sha256"),
+        ("layouts", "all-flow-union", "captures", "candidate", "sha256"),
+        ("session_id",),
+        ("configuration", "batch_sizes"),
+        ("layouts", "topology-replay", "layout"),
+        ("layouts", "all-flow-union", "layout"),
+    ],
+)
+def test_outer_campaign_address_binds_campaign_inputs_and_captures(
+    tmp_path: Path,
+    field_path: tuple[str, ...],
+) -> None:
+    tampered = copy.deepcopy(_campaign_record_fixture())
+    owner = tampered
+    for field in field_path[:-1]:
+        child = owner[field]
+        assert isinstance(child, dict)
+        owner = child
+    owner[field_path[-1]] = "tampered"
+    path = tmp_path / "campaign.json"
+    path.write_bytes(paired._canonical_json_bytes(tampered) + b"\n")
+
+    with pytest.raises(paired.CampaignError, match="is not content-addressed"):
+        paired._read_addressed(path, label="campaign")
+
+
+def test_nested_harness_tamper_is_rejected_even_if_outer_address_is_rewritten(
+    tmp_path: Path,
+) -> None:
+    tampered = copy.deepcopy(_campaign_record_fixture())
+    harness = tampered["harness"]
+    assert isinstance(harness, dict)
+    harness["working_file_sha256"] = "e" * 64
+    unsigned = dict(tampered)
+    unsigned.pop("content_sha256")
+    tampered["content_sha256"] = paired._sha256(unsigned)
+    path = tmp_path / "campaign.json"
+    path.write_bytes(paired._canonical_json_bytes(tampered) + b"\n")
+
+    with pytest.raises(
+        paired.CampaignError,
+        match=r"campaign\.harness is not content-addressed",
+    ):
+        paired._read_addressed(path, label="campaign")
+
+
+def test_group_signal_falls_back_to_process(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    observed: list[int] = []
+
+    class Process:
+        pid = 12345
+
+        @staticmethod
+        def poll() -> None:
+            return None
+
+        @staticmethod
+        def send_signal(signal_number: int) -> None:
+            observed.append(signal_number)
+
+    def inaccessible_group(_group: int, _signal: int) -> None:
+        raise PermissionError
+
+    monkeypatch.setattr(paired.os, "killpg", inaccessible_group)
+    paired._signal_capture_group(Process(), signal.SIGTERM)
+
+    assert observed == [signal.SIGTERM]
+
+
+@pytest.mark.skipif(
+    os.name != "posix" or not hasattr(os, "killpg"),
+    reason="process-group cleanup requires POSIX",
+)
+def test_terminate_cleans_up_capture_child(tmp_path: Path) -> None:
+    child_ready = tmp_path / "child-ready"
+    child_stopped = tmp_path / "child-stopped"
+    child_pid_path = tmp_path / "child-pid"
+    driver = tmp_path / "driver.py"
+    driver.write_text(
+        """\
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ready, stopped, pid_path = map(Path, sys.argv[1:])
+child_source = '''\
+import signal
+import sys
+import time
+from pathlib import Path
+
+ready = Path(sys.argv[1])
+stopped = Path(sys.argv[2])
+
+def stop(_signal, _frame):
+    stopped.write_text("stopped", encoding="utf-8")
+    raise SystemExit(0)
+
+signal.signal(signal.SIGTERM, stop)
+ready.write_text("ready", encoding="utf-8")
+while True:
+    time.sleep(1)
+'''
+child = subprocess.Popen(
+    [sys.executable, "-c", child_source, str(ready), str(stopped)]
+)
+while not ready.is_file():
+    time.sleep(0.01)
+pid_path.write_text(str(child.pid), encoding="ascii")
+while True:
+    time.sleep(1)
+""",
+        encoding="utf-8",
+    )
+    log_path = tmp_path / "driver.log"
+    with log_path.open("w", encoding="utf-8") as log:
+        process = paired._start_capture(
+            (
+                sys.executable,
+                str(driver),
+                str(child_ready),
+                str(child_stopped),
+                str(child_pid_path),
+            ),
+            environment=os.environ,
+            log=log,
+        )
+        deadline = time.monotonic() + 5.0
+        child_pid: int | None = None
+        while child_pid is None:
+            if process.poll() is not None:
+                pytest.fail(f"driver exited early with status {process.returncode}")
+            if time.monotonic() >= deadline:
+                pytest.fail("timed out waiting for capture child")
+            raw_pid = (
+                child_pid_path.read_text(encoding="ascii")
+                if child_pid_path.is_file()
+                else ""
+            )
+            if raw_pid.isdecimal():
+                child_pid = int(raw_pid)
+            time.sleep(0.01)
+        paired._terminate({"driver": process}, grace_seconds=2.0)
+
+    deadline = time.monotonic() + 2.0
+    while not child_stopped.is_file() and time.monotonic() < deadline:
+        time.sleep(0.01)
+    child_alive = True
+    while child_alive and time.monotonic() < deadline:
+        status = subprocess.run(
+            ("ps", "-o", "stat=", "-p", str(child_pid)),
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        child_alive = (
+            status.returncode == 0
+            and bool(status.stdout.strip())
+            and not status.stdout.lstrip().startswith("Z")
+        )
+        if child_alive:
+            time.sleep(0.01)
+    if child_alive:
+        os.kill(child_pid, signal.SIGKILL)
+
+    assert process.poll() is not None
+    assert child_stopped.read_text(encoding="utf-8") == "stopped"
+    assert not child_alive
+
+
+@pytest.mark.skipif(os.name != "posix", reason="venv symlinks require POSIX")
+def test_fake_driver_campaign_preserves_pairing_and_executable_paths(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    baseline_root, baseline_revision = _repository(
+        tmp_path / "baseline",
+        {"identity": "baseline\n"},
+    )
+    candidate_root, candidate_revision = _repository(
+        tmp_path / "candidate",
+        {
+            "identity": "candidate\n",
+            "fake_driver.py": _fake_driver_source(),
+            paired.PAIRED_DRIVER_RELATIVE_PATH: SCRIPT.read_text(encoding="utf-8"),
+        },
+    )
+    interpreter_target = Path(sys.executable).resolve()
+    python_paths: dict[str, Path] = {}
+    for role in paired.ROLES:
+        python_path = tmp_path / f"{role}-venv" / "bin" / "python"
+        python_path.parent.mkdir(parents=True)
+        python_path.symlink_to(interpreter_target)
+        python_paths[role] = python_path
+    prepared_models: dict[str, Path] = {}
+    for role in paired.ROLES:
+        prepared_model = tmp_path / f"{role}.pack"
+        prepared_model.write_bytes(role.encode("ascii"))
+        prepared_models[role] = prepared_model
+
+    monkeypatch.setattr(paired, "BASELINE_REVISION", baseline_revision)
+    monkeypatch.setattr(paired, "LAYOUTS", ("topology-replay",))
+    monkeypatch.setattr(paired, "AUTHORITATIVE_MODES", ("compiled",))
+    monkeypatch.setattr(paired, "BATCH_SIZES", (1,))
+    monkeypatch.setattr(paired, "MINIMUM_SUBPROCESS_SAMPLES", 1)
+    monkeypatch.setattr(paired, "MINIMUM_WARMUPS", 1)
+    monkeypatch.setattr(paired, "MINIMUM_TARGET_RUNTIME_SECONDS", 0.001)
+    monkeypatch.setattr(paired, "MINIMUM_GENERATION_TIMEOUT_SECONDS", 5.0)
+    monkeypatch.setattr(paired, "MINIMUM_COORDINATION_TIMEOUT_SECONDS", 15.0)
+    output_root = tmp_path / "campaign-output"
+    result_json = tmp_path / "campaign.json"
+    arguments = argparse.Namespace(
+        baseline_python=python_paths["baseline"],
+        baseline_source_root=baseline_root,
+        baseline_prepared_model=prepared_models["baseline"],
+        candidate_python=python_paths["candidate"],
+        candidate_source_root=candidate_root,
+        candidate_prepared_model=prepared_models["candidate"],
+        expected_candidate_source_revision=candidate_revision,
+        expected_baseline_native_build_inputs_sha256="a" * 64,
+        expected_candidate_native_build_inputs_sha256="b" * 64,
+        expected_baseline_prepared_model_sha256=hashlib.sha256(
+            b"baseline"
+        ).hexdigest(),
+        expected_candidate_prepared_model_sha256=hashlib.sha256(
+            b"candidate"
+        ).hexdigest(),
+        harness=candidate_root / "fake_driver.py",
+        output_root=output_root,
+        result_json=result_json,
+        session_id="fake-e2e",
+        include_eager=False,
+        process_expression="d d~ > z + 6*g",
+        target_runtime=0.001,
+        minimum_samples=1,
+        subprocess_samples=1,
+        warmup_runs=1,
+        validation_samples=1,
+        point_tile_size=1,
+        generation_timeout=5.0,
+        profile_timeout=5.0,
+        coordination_timeout=15.0,
+        topology_color_flow="1",
+        topology_helicity="1",
+        union_color_flow="1",
+        union_helicity="1",
+    )
+
+    result = paired.run(arguments)
+
+    assert result["complete"] is True
+    assert result_json.is_file()
+    assert paired._read_addressed(result_json, label="campaign") == result
+    assert candidate_revision == result["roles"]["candidate"]["source_revision"]
+    harness = result["harness"]
+    assert harness["candidate_relative_path"] == "fake_driver.py"
+    assert harness["head_blob_sha256"] == harness["working_file_sha256"]
+    assert harness["head_blob_equals_working_file"] is True
+    paired._validate_addressed_mapping(
+        harness,
+        label="benchmark harness identity",
+    )
+    for role in paired.ROLES:
+        identity = result["roles"][role]
+        assert identity["python"] == str(python_paths[role].absolute())
+        assert identity["python_resolved_target"] == str(interpreter_target)
+    layout = result["layouts"]["topology-replay"]
+    assert len(layout["pairs"]) == 1
+    assert layout["pairs"][0]["role_order"] == ["baseline", "candidate"]
+    assert result["configuration"]["watchdog"] == {
+        "required": True,
+        "report_kind": paired.WATCHDOG_REPORT_KIND,
+        "report_schema_version": paired.WATCHDOG_REPORT_SCHEMA,
+        "limit_bytes": paired.WATCHDOG_LIMIT_BYTES,
+        "scope": paired.WATCHDOG_SCOPE,
+        "binding": paired.WATCHDOG_BINDING,
+    }
diff --git a/pyamplicol/tests/unit/test_symmetric_group_color_contraction.py b/pyamplicol/tests/unit/test_symmetric_group_color_contraction.py
new file mode 100644
index 0000000000..9aa67d8f95
--- /dev/null
+++ b/pyamplicol/tests/unit/test_symmetric_group_color_contraction.py
@@ -0,0 +1,750 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import importlib
+import math
+from collections import Counter
+from fractions import Fraction
+from itertools import permutations
+
+import pytest
+
+from pyamplicol.color import (
+    ColorGroupDescriptor,
+    build_color_plan,
+    build_symmetric_group_color_contraction_plan,
+    certify_symmetric_group_orbits,
+    exact_color_contraction_factor,
+    reconstruct_symmetric_group_dense_exact,
+)
+from pyamplicol.generation.recurrence_physics import (
+    build_on_the_fly_color_contraction,
+    on_the_fly_color_sector_owner_map,
+)
+from pyamplicol.generation.service import (
+    _build_on_the_fly_contracted_color_payload_v1,
+)
+from pyamplicol.models.builtin.process_ir import build_process_ir
+
+
+def _plan(process: str, *, accuracy: str = "full"):
+    return build_color_plan(
+        build_process_ir(process, color_accuracy=accuracy),
+        color_accuracy=accuracy,
+    )
+
+
+def _owner_descriptors(color_plan):
+    owners = on_the_fly_color_sector_owner_map(color_plan)
+    owner_sector_ids = tuple(
+        sector_id for sector_id, owner_id in enumerate(owners) if sector_id == owner_id
+    )
+    descriptors = tuple(
+        ColorGroupDescriptor(
+            group_id=group_id,
+            helicity_key=(),
+            sector_id=sector_id,
+            word=color_plan.sectors[sector_id].color_words[0],
+            helicity_weight=1.0,
+        )
+        for group_id, sector_id in enumerate(owner_sector_ids)
+    )
+    return owners, owner_sector_ids, descriptors
+
+
+def _assert_dense_reconstruction(color_plan, block) -> None:
+    dense = reconstruct_symmetric_group_dense_exact(block)
+    sectors_by_id = {sector.id: sector for sector in color_plan.sectors}
+    for left_index, left_sector_id in enumerate(block.local_sector_ids):
+        for right_index in range(left_index, len(block.local_sector_ids)):
+            expected = exact_color_contraction_factor(
+                color_plan,
+                sectors_by_id[left_sector_id],
+                sectors_by_id[block.local_sector_ids[right_index]],
+                accuracy=color_plan.color_accuracy,
+            )
+            assert dense.get((left_index, right_index), Fraction(0)) == expected
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_pure_trace_orbit_is_anchored_and_reconstructs_dense_metric(
+    accuracy: str,
+) -> None:
+    color_plan = _plan("g g > g g", accuracy=accuracy)
+    owners, owner_sector_ids, descriptors = _owner_descriptors(color_plan)
+
+    partition = certify_symmetric_group_orbits(
+        color_plan,
+        owner_sector_ids,
+        sector_owner_ids=owners,
+    )
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+
+    assert partition.fixed_adjoint_labels == (1,)
+    assert partition.permuted_adjoint_labels == (2, 3, 4)
+    assert partition.residual_sector_ids == ()
+    assert len(partition.orbits) == 1
+    assert partition.orbits[0].sector_ids == tuple(range(6))
+    block = contraction.symmetric_group_block
+    assert block is not None
+    assert block.degree == 3
+    assert block.channel_cosets == (tuple(range(6)),)
+    assert block.local_sector_ids == tuple(range(6))
+    assert len(block.kernel_entries) == 6
+    assert block.residual_entries == ()
+    assert block.hermiticity_check_mode == "vacuous"
+    assert block.hermiticity_relative_indices == ()
+    assert block.hermiticity_check_count == 0
+    _assert_dense_reconstruction(color_plan, block)
+
+
+def test_one_open_line_uses_every_adjoint_in_regular_orbit() -> None:
+    color_plan = _plan("d d~ > z g g g")
+    owners, owner_sector_ids, descriptors = _owner_descriptors(color_plan)
+
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+
+    block = contraction.symmetric_group_block
+    assert block is not None
+    assert block.degree == 3
+    assert block.channel_count == 1
+    assert block.local_sector_ids == owner_sector_ids
+    _assert_dense_reconstruction(color_plan, block)
+
+
+def test_on_the_fly_builder_selects_symmetric_group_planner() -> None:
+    color_plan = _plan("g g > g g")
+
+    contraction, owner_by_sector, owner_sector_ids = build_on_the_fly_color_contraction(
+        color_plan,
+        contraction="symmetric-group-fft",
+    )
+
+    assert owner_by_sector == tuple(range(6))
+    assert owner_sector_ids == tuple(range(6))
+    assert contraction.symmetric_group_block is not None
+    assert contraction.symmetric_group_block.degree == 3
+    assert contraction.destination_by_group == tuple(range(6))
+
+
+def test_on_the_fly_fft_summary_exposes_kernel_storage_and_provenance() -> None:
+    color_plan = _plan("g g > g g")
+
+    encoded = _build_on_the_fly_contracted_color_payload_v1(
+        color_plan,
+        contraction="symmetric-group-fft",
+    )
+
+    assert encoded.summary["storage"] == "convolution-kernels"
+    assert encoded.summary["entry_count"] == 6
+    assert encoded.summary["factorization"] == {
+        "kind": "symmetric-group-fourier",
+        "rank": 3,
+        "coset_count": 1,
+    }
+    assert encoded.summary["fft_provenance"] == {
+        "method": "symmetric-group-fourier",
+        "degree": 3,
+        "channel_count": 1,
+        "covered_local_group_count": 6,
+        "residual_group_count": 0,
+        "residual_entry_count": 0,
+        "raw_kernel_bytes": 96,
+        "transformed_kernel_bytes": 48,
+        "capability": "rusticol.color-contraction.symmetric-group-fft.v1",
+    }
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_multi_open_line_channels_keep_zero_rows_and_reconstruct_dense_metric(
+    accuracy: str,
+) -> None:
+    color_plan = _plan("d d~ > u u~ g g", accuracy=accuracy)
+    owners, _, descriptors = _owner_descriptors(color_plan)
+
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+
+    block = contraction.symmetric_group_block
+    assert block is not None
+    assert block.degree == 2
+    assert block.channel_count == 6
+    assert block.group_order == 2
+    assert len(block.kernel_entries) == 6 * 7 // 2 * 2
+    assert any(weight == 0 for weight in block.kernel_exact_weights)
+    assert block.residual_local_group_indices == ()
+    assert block.hermiticity_check_mode == "full"
+    assert block.hermiticity_relative_indices == (0, 1)
+    assert block.hermiticity_check_count == 6 * 5 // 2 * 2
+    _assert_dense_reconstruction(color_plan, block)
+
+
+def test_identical_open_lines_keep_endpoint_pairing_channels_separate() -> None:
+    color_plan = _plan("d d~ > d d~ g g")
+    owners, owner_sector_ids, descriptors = _owner_descriptors(color_plan)
+
+    partition = certify_symmetric_group_orbits(
+        color_plan,
+        owner_sector_ids,
+        sector_owner_ids=owners,
+    )
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+
+    block = contraction.symmetric_group_block
+    assert block is not None
+    assert block.degree == 2
+    assert block.channel_count == 6
+    sectors_by_id = {sector.id: sector for sector in color_plan.sectors}
+    endpoint_pairings = [
+        tuple(
+            sorted(
+                (
+                    line.fundamental_label,
+                    line.antifundamental_label,
+                )
+                for line in sectors_by_id[orbit.sector_ids[0]].open_color_lines
+            )
+        )
+        for orbit in partition.orbits
+    ]
+    assert sorted(Counter(endpoint_pairings).values()) == [3, 3]
+    _assert_dense_reconstruction(color_plan, block)
+
+
+def test_whole_open_line_replicas_collapse_to_owner_destination_projection() -> None:
+    color_plan = _plan("d d~ > u u~ g g")
+    owners = on_the_fly_color_sector_owner_map(color_plan)
+    component_count = 2
+    descriptors = tuple(
+        ColorGroupDescriptor(
+            group_id=sector.id * component_count + component,
+            helicity_key=(component,),
+            sector_id=sector.id,
+            word=sector.color_words[0],
+            helicity_weight=1.0,
+        )
+        for sector in color_plan.sectors
+        for component in range(component_count)
+    )
+
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+
+    block = contraction.symmetric_group_block
+    assert block is not None
+    # There are 24 traversal sectors, but only 12 canonical tensor owners.
+    assert len(descriptors) == 48
+    assert block.channel_count == 6
+    assert block.local_group_count == 12
+    assert contraction.group_count == 24
+    assert block.component_group_ids == tuple(range(24))
+    assert contraction.destination_by_group == tuple(
+        sector_id * component_count + component
+        for sector_id in block.local_sector_ids
+        for component in range(component_count)
+    )
+    assert all(owners[sector_id] == sector_id for sector_id in block.local_sector_ids)
+    _assert_dense_reconstruction(color_plan, block)
+
+    reversed_contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        tuple(reversed(descriptors)),
+        sector_owner_ids=owners,
+    )
+    assert reversed_contraction.destination_by_group == (
+        contraction.destination_by_group
+    )
+    assert (
+        reversed_contraction.symmetric_group_block.component_group_ids
+        == block.component_group_ids
+    )
+
+
+def test_four_adjoint_two_line_plan_is_ten_coupled_s_four_owner_channels() -> None:
+    color_plan = _plan("d d~ > u u~ g g g g")
+    owners = on_the_fly_color_sector_owner_map(color_plan)
+    descriptors = tuple(
+        ColorGroupDescriptor(
+            group_id=sector.id,
+            helicity_key=(),
+            sector_id=sector.id,
+            word=sector.color_words[0],
+            helicity_weight=1.0,
+        )
+        for sector in color_plan.sectors
+    )
+
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+
+    block = contraction.symmetric_group_block
+    assert block is not None
+    assert color_plan.sector_count == 480
+    assert len(set(owners)) == 240
+    assert block.degree == 4
+    assert block.group_order == 24
+    assert block.channel_count == 10
+    assert block.local_group_count == 240
+    assert block.channel_cosets == tuple(
+        tuple(range(channel * 24, (channel + 1) * 24)) for channel in range(10)
+    )
+    assert len(block.kernel_entries) == 10 * 11 // 2 * 24
+    assert block.residual_local_group_indices == ()
+    assert block.hermiticity_check_mode == "full"
+    assert block.hermiticity_relative_indices == tuple(range(24))
+    assert block.hermiticity_check_count == 10 * 9 // 2 * 24
+    assert all(owners[sector_id] == sector_id for sector_id in block.local_sector_ids)
+    assert contraction.destination_by_group == block.local_sector_ids
+
+    dense = reconstruct_symmetric_group_dense_exact(block)
+    sectors_by_id = {sector.id: sector for sector in color_plan.sectors}
+    for left_index, right_index in (
+        (0, 0),
+        (0, 23),
+        (1, 23),
+        (0, 24),
+        (23, 239),
+        (100, 200),
+        (239, 239),
+    ):
+        assert dense[(left_index, right_index)] == exact_color_contraction_factor(
+            color_plan,
+            sectors_by_id[block.local_sector_ids[left_index]],
+            sectors_by_id[block.local_sector_ids[right_index]],
+            accuracy="full",
+        )
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_incomplete_channel_is_an_exact_direct_residual_and_cross_metric(
+    accuracy: str,
+) -> None:
+    color_plan = _plan("d d~ > u u~ g g", accuracy=accuracy)
+    owners, owner_sector_ids, _ = _owner_descriptors(color_plan)
+    complete_channel = (owner_sector_ids[0], owner_sector_ids[3])
+    incomplete_member = owner_sector_ids[1]
+    selected = (*complete_channel, incomplete_member)
+    descriptors = tuple(
+        ColorGroupDescriptor(
+            group_id=index,
+            helicity_key=(),
+            sector_id=sector_id,
+            word=color_plan.sectors[sector_id].color_words[0],
+            helicity_weight=1.0,
+        )
+        for index, sector_id in enumerate(selected)
+    )
+
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+
+    block = contraction.symmetric_group_block
+    assert block is not None
+    assert block.channel_count == 1
+    assert block.residual_local_group_indices == (2,)
+    assert block.local_sector_ids[-1] == incomplete_member
+    assert block.residual_entries
+    assert tuple(
+        (entry.left_group_index, entry.right_group_index)
+        for entry in block.residual_entries
+    ) == ((0, 2), (1, 2), (2, 2))
+    assert block.residual_exact_weights[:2] == (Fraction(0), Fraction(0))
+    assert all(
+        2 in (entry.left_group_index, entry.right_group_index)
+        for entry in block.residual_entries
+    )
+    _assert_dense_reconstruction(color_plan, block)
+
+
+def test_nontrivial_degree_without_a_complete_orbit_is_unsupported() -> None:
+    color_plan = _plan("d d~ > u u~ g g")
+    owners, owner_sector_ids, _ = _owner_descriptors(color_plan)
+    sector_id = owner_sector_ids[0]
+    descriptors = (
+        ColorGroupDescriptor(
+            group_id=0,
+            helicity_key=(),
+            sector_id=sector_id,
+            word=color_plan.sectors[sector_id].color_words[0],
+            helicity_weight=1.0,
+        ),
+    )
+
+    partition = certify_symmetric_group_orbits(
+        color_plan,
+        (sector_id,),
+        sector_owner_ids=owners,
+    )
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+
+    assert partition.degree == 2
+    assert partition.orbits == ()
+    assert partition.residual_sector_ids == (sector_id,)
+    assert not contraction.supported
+    assert contraction.symmetric_group_block is None
+    assert contraction.reason == (
+        "symmetric-group FFT found no certified orbit at nontrivial degree 2"
+    )
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_three_open_lines_with_two_adjoints_reconstruct_exact_s_two_interference(
+    accuracy: str,
+) -> None:
+    color_plan = _plan("d d~ > u u~ s s~ g g", accuracy=accuracy)
+    owners, _, descriptors = _owner_descriptors(color_plan)
+
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+
+    block = contraction.symmetric_group_block
+    assert block is not None
+    assert block.degree == 2
+    assert block.group_order == 2
+    assert block.channel_count > 1
+    sectors_by_id = {sector.id: sector for sector in color_plan.sectors}
+    assert {
+        len(sectors_by_id[block.local_sector_ids[coset[0]]].open_color_lines)
+        for coset in block.channel_cosets
+    } == {3}
+    dense = reconstruct_symmetric_group_dense_exact(block)
+    assert any(
+        dense.get((left_coset[0], right_coset[0]), Fraction(0)) != 0
+        for left_channel, left_coset in enumerate(block.channel_cosets)
+        for right_coset in block.channel_cosets[left_channel + 1 :]
+    )
+    _assert_dense_reconstruction(color_plan, block)
+
+
+def test_s_zero_and_s_one_use_owner_collapsed_direct_residual() -> None:
+    for process in ("d d~ > u u~", "d d~ > u u~ s s~ g"):
+        color_plan = _plan(process)
+        owners = on_the_fly_color_sector_owner_map(color_plan)
+        descriptors = tuple(
+            ColorGroupDescriptor(
+                group_id=sector.id,
+                helicity_key=(),
+                sector_id=sector.id,
+                word=sector.color_words[0],
+                helicity_weight=1.0,
+            )
+            for sector in color_plan.sectors
+        )
+
+        contraction = build_symmetric_group_color_contraction_plan(
+            color_plan,
+            descriptors,
+            sector_owner_ids=owners,
+        )
+
+        assert contraction.supported
+        assert contraction.symmetric_group_block is None
+        assert contraction.entries
+        assert contraction.group_count == len(set(owners))
+        assert contraction.destination_by_group is not None
+        assert len(contraction.destination_by_group) == contraction.group_count
+
+
+def test_owner_map_must_preserve_the_canonical_color_tensor() -> None:
+    color_plan = _plan("g g > g g")
+    _, owner_sector_ids, _ = _owner_descriptors(color_plan)
+    invalid_owners = (0, 0, 2, 3, 4, 5)
+
+    with pytest.raises(ValueError, match="canonical color tensor"):
+        certify_symmetric_group_orbits(
+            color_plan,
+            owner_sector_ids,
+            sector_owner_ids=invalid_owners,
+        )
+
+
+def test_alias_only_descriptors_are_projected_to_authenticated_owners() -> None:
+    color_plan = _plan("d d~ > u u~ g g")
+    owners = on_the_fly_color_sector_owner_map(color_plan)
+    aliases_by_owner: dict[int, list[int]] = {}
+    for sector_id, owner_id in enumerate(owners):
+        aliases_by_owner.setdefault(owner_id, []).append(sector_id)
+    replica_sector_ids = tuple(
+        max(sector_ids) for _, sector_ids in sorted(aliases_by_owner.items())
+    )
+    assert all(owners[sector_id] != sector_id for sector_id in replica_sector_ids)
+    descriptors = tuple(
+        ColorGroupDescriptor(
+            group_id=group_id,
+            helicity_key=(),
+            sector_id=sector_id,
+            word=color_plan.sectors[sector_id].color_words[0],
+            helicity_weight=1.0,
+        )
+        for group_id, sector_id in enumerate(replica_sector_ids)
+    )
+
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+
+    block = contraction.symmetric_group_block
+    assert block is not None
+    assert block.channel_count == 6
+    assert block.local_group_count == 12
+    assert all(owners[sector_id] == sector_id for sector_id in block.local_sector_ids)
+    assert sorted(contraction.destination_by_group) == list(range(12))
+    assert (
+        tuple(
+            owners[replica_sector_ids[destination_id]]
+            for destination_id in contraction.destination_by_group
+        )
+        == block.local_sector_ids
+    )
+    _assert_dense_reconstruction(color_plan, block)
+
+
+def test_partition_retains_one_bounded_lazy_permutation_view(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    color_plan = _plan("d d~ > u u~ g g g g")
+    owners, owner_sector_ids, _ = _owner_descriptors(color_plan)
+    symmetric_group_module = importlib.import_module("pyamplicol.color.symmetric_group")
+    original_unrank = symmetric_group_module._lexicographic_permutation_unrank
+    materialized_ranks: list[int] = []
+
+    def counted_unrank(degree: int, rank: int):
+        materialized_ranks.append(rank)
+        return original_unrank(degree, rank)
+
+    monkeypatch.setattr(
+        symmetric_group_module,
+        "_lexicographic_permutation_unrank",
+        counted_unrank,
+    )
+    partition = certify_symmetric_group_orbits(
+        color_plan,
+        owner_sector_ids,
+        sector_owner_ids=owners,
+    )
+
+    assert materialized_ranks == []
+    shared = partition.orbits[0].permutations
+    assert all(orbit.permutations is shared for orbit in partition.orbits)
+    assert not isinstance(shared, tuple)
+    assert len(shared) == math.factorial(4)
+    assert shared[0] == (0, 1, 2, 3)
+    assert shared[-1] == (3, 2, 1, 0)
+    assert materialized_ranks == [0, math.factorial(4) - 1]
+
+
+@pytest.mark.parametrize("degree", range(7))
+def test_lexicographic_rank_unrank_matches_itertools_order(degree: int) -> None:
+    symmetric_group_module = importlib.import_module("pyamplicol.color.symmetric_group")
+    expected = tuple(permutations(range(degree)))
+
+    for rank, permutation in enumerate(expected):
+        assert (
+            symmetric_group_module._lexicographic_permutation_unrank(degree, rank)
+            == permutation
+        )
+        assert (
+            symmetric_group_module._lexicographic_permutation_rank(
+                permutation,
+                degree=degree,
+            )
+            == rank
+        )
+
+
+def test_lexicographic_rank_unrank_rejects_invalid_inputs() -> None:
+    symmetric_group_module = importlib.import_module("pyamplicol.color.symmetric_group")
+
+    with pytest.raises(ValueError, match="degree"):
+        symmetric_group_module._lexicographic_permutation_unrank(11, 0)
+    with pytest.raises(ValueError, match="out of bounds"):
+        symmetric_group_module._lexicographic_permutation_unrank(4, math.factorial(4))
+    with pytest.raises(ValueError, match="bijection"):
+        symmetric_group_module._lexicographic_permutation_rank(
+            (0, 1, 1, 3),
+            degree=4,
+        )
+    with pytest.raises(ValueError, match="inconsistent"):
+        symmetric_group_module._lexicographic_permutation_rank(
+            (0, 1, 2),
+            degree=4,
+        )
+
+
+@pytest.mark.parametrize("degree", (8, 10))
+def test_high_degree_structure_uses_only_sampled_rank_unrank(degree: int) -> None:
+    symmetric_group_module = importlib.import_module("pyamplicol.color.symmetric_group")
+    group_order = math.factorial(degree)
+    view = symmetric_group_module._LexicographicPermutations(degree)
+    sampled_ranks = (0, 1, group_order // 2, group_order - 2, group_order - 1)
+
+    assert len(view) == group_order
+    for rank in sampled_ranks:
+        permutation = view[rank]
+        assert len(permutation) == degree
+        assert sorted(permutation) == list(range(degree))
+        assert (
+            symmetric_group_module._lexicographic_permutation_rank(
+                permutation,
+                degree=degree,
+            )
+            == rank
+        )
+
+    relative_indices = symmetric_group_module._hermiticity_relative_indices(
+        degree,
+        channel_count=2,
+    )
+    equivariance_indices = symmetric_group_module._equivariance_sample_indices(degree)
+    assert relative_indices == equivariance_indices
+    assert len(relative_indices) == degree + 1
+    selected = tuple(view[index] for index in relative_indices)
+    assert selected[0] == tuple(range(degree))
+    assert any(
+        permutation != symmetric_group_module._inverse_permutation(permutation)
+        for permutation in selected
+    )
+
+
+def test_large_degree_hermiticity_samples_are_deterministic_and_nontrivial() -> None:
+    symmetric_group_module = importlib.import_module("pyamplicol.color.symmetric_group")
+    relative_indices = symmetric_group_module._hermiticity_relative_indices(
+        5,
+        channel_count=2,
+    )
+    selected = tuple(
+        symmetric_group_module._lexicographic_permutation_unrank(5, index)
+        for index in relative_indices
+    )
+
+    assert selected[0] == tuple(range(5))
+    for left_position in range(4):
+        adjacent = list(range(5))
+        adjacent[left_position], adjacent[left_position + 1] = (
+            adjacent[left_position + 1],
+            adjacent[left_position],
+        )
+        assert tuple(adjacent) in selected
+    assert any(
+        permutation != symmetric_group_module._inverse_permutation(permutation)
+        for permutation in selected
+    )
+    assert len(relative_indices) < math.factorial(5)
+
+
+@pytest.mark.parametrize("accuracy", ("nlc", "full"))
+def test_single_trace_kernel_quotient_matches_every_direct_exact_row(
+    monkeypatch: pytest.MonkeyPatch,
+    accuracy: str,
+) -> None:
+    symmetric_group_module = importlib.import_module("pyamplicol.color.symmetric_group")
+    color_plan = _plan("g g > g g g", accuracy=accuracy)
+    owners, owner_sector_ids, descriptors = _owner_descriptors(color_plan)
+    partition = certify_symmetric_group_orbits(
+        color_plan,
+        owner_sector_ids,
+        sector_owner_ids=owners,
+    )
+    (orbit,) = partition.orbits
+    identity_sector_id = orbit.sector_ids[0]
+    direct = symmetric_group_module.exact_color_contraction_factor
+    identity_left_calls = 0
+
+    def counted(color_plan, left, right, **kwargs):
+        nonlocal identity_left_calls
+        if left.id == identity_sector_id:
+            identity_left_calls += 1
+        return direct(color_plan, left, right, **kwargs)
+
+    monkeypatch.setattr(
+        symmetric_group_module,
+        "exact_color_contraction_factor",
+        counted,
+    )
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+    block = contraction.symmetric_group_block
+    assert block is not None
+    sectors = {sector.id: sector for sector in color_plan.sectors}
+    expected = tuple(
+        direct(
+            color_plan,
+            sectors[identity_sector_id],
+            sectors[sector_id],
+            accuracy=accuracy,
+            full_col_acc=20,
+        )
+        for sector_id in orbit.sector_ids
+    )
+    representatives = {
+        symmetric_group_module._single_trace_diagonal_kernel_representative(item)
+        for item in permutations(range(partition.degree))
+    }
+    assert block.kernel_exact_weights == expected
+    assert (
+        identity_left_calls == len(representatives) < math.factorial(partition.degree)
+    )
+    if accuracy == "nlc":
+        assert any(value < 0 for value in expected)
+
+
+def test_single_trace_kernel_quotient_stays_off_for_open_line_channels(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    symmetric_group_module = importlib.import_module("pyamplicol.color.symmetric_group")
+    color_plan = _plan("d d~ > u u~ g g")
+    owners, _, descriptors = _owner_descriptors(color_plan)
+
+    def unexpected(_permutation):
+        raise AssertionError("single-trace quotient reached an open-line channel")
+
+    monkeypatch.setattr(
+        symmetric_group_module,
+        "_single_trace_diagonal_kernel_representative",
+        unexpected,
+    )
+    contraction = build_symmetric_group_color_contraction_plan(
+        color_plan,
+        descriptors,
+        sector_owner_ids=owners,
+    )
+    block = contraction.symmetric_group_block
+    assert block is not None
+    assert block.channel_count == 6
+    _assert_dense_reconstruction(color_plan, block)
diff --git a/pyamplicol/tests/unit/test_target_portability.py b/pyamplicol/tests/unit/test_target_portability.py
new file mode 100644
index 0000000000..8c2f0f1981
--- /dev/null
+++ b/pyamplicol/tests/unit/test_target_portability.py
@@ -0,0 +1,220 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol._internal.versions import (
+    SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+    SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY,
+)
+from pyamplicol.artifacts.manifest import PORTABLE_64LE_TARGET
+from pyamplicol.config import (
+    CppConfig,
+    EvaluatorBackend,
+    EvaluatorConfig,
+    GenerationConfig,
+    JITConfig,
+    RunConfig,
+)
+from pyamplicol.generation import artifact_writer
+
+
+def _config(
+    *,
+    backend: EvaluatorBackend,
+    native_arch: bool,
+    jit_optimization_level: int = 2,
+) -> RunConfig:
+    return RunConfig(
+        action="generate",
+        evaluator=EvaluatorConfig(
+            backend=backend,
+            cpp=CppConfig(native_arch=native_arch),
+            jit=JITConfig(optimization_level=jit_optimization_level),
+        ),
+    )
+
+
+def _install_target_info(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    triple: str = "x86_64-unknown-linux-gnu",
+    features: tuple[str, ...] = ("avx2", "fma", "sse2"),
+) -> None:
+    rusticol = SimpleNamespace(
+        target_info=lambda: SimpleNamespace(
+            triple=triple,
+            cpu_features=list(features),
+        ),
+        abi_version=lambda: 7,
+    )
+    monkeypatch.setattr(
+        artifact_writer.importlib,
+        "import_module",
+        lambda name: rusticol,
+    )
+
+
+@pytest.mark.parametrize("optimization_level", (1, 2))
+def test_portable_jit_artifacts_declare_portable_64le_target(
+    monkeypatch: pytest.MonkeyPatch,
+    optimization_level: int,
+) -> None:
+    _install_target_info(monkeypatch)
+    target, c_abi = artifact_writer._artifact_target_metadata(
+        _config(
+            backend=EvaluatorBackend.JIT,
+            native_arch=False,
+            jit_optimization_level=optimization_level,
+        )
+    )
+    assert target == {
+        "triple": PORTABLE_64LE_TARGET,
+        "cpu_features": [],
+    }
+    assert c_abi == 7
+
+
+def test_implicit_generation_config_requires_portable_jit_content_evidence(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _install_target_info(monkeypatch)
+    concrete, _ = artifact_writer._artifact_target_metadata(GenerationConfig())
+    portable, _ = artifact_writer._artifact_target_metadata(
+        GenerationConfig(),
+        implicit_portable_jit_evidence=True,
+    )
+    assert concrete == {
+        "triple": "x86_64-unknown-linux-gnu",
+        "cpu_features": [],
+    }
+    assert portable == {
+        "triple": PORTABLE_64LE_TARGET,
+        "cpu_features": [],
+    }
+
+
+def test_portable_cpp_still_declares_concrete_host_target(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _install_target_info(monkeypatch)
+    target, _ = artifact_writer._artifact_target_metadata(
+        _config(backend=EvaluatorBackend.CPP, native_arch=False)
+    )
+    assert target == {
+        "triple": "x86_64-unknown-linux-gnu",
+        "cpu_features": [],
+    }
+
+
+@pytest.mark.parametrize("optimization_level", (0, 3))
+def test_nonportable_jit_artifacts_stay_on_the_concrete_host_target(
+    monkeypatch: pytest.MonkeyPatch,
+    optimization_level: int,
+) -> None:
+    _install_target_info(monkeypatch)
+    target, _ = artifact_writer._artifact_target_metadata(
+        _config(
+            backend=EvaluatorBackend.JIT,
+            native_arch=False,
+            jit_optimization_level=optimization_level,
+        )
+    )
+    assert target == {
+        "triple": "x86_64-unknown-linux-gnu",
+        "cpu_features": [],
+    }
+
+
+@pytest.mark.parametrize(
+    "runtime_capability",
+    (SYMBOLICA_CPP_RUNTIME_CAPABILITY, SYMBOLICA_LEGACY_JIT_RUNTIME_CAPABILITY),
+)
+def test_target_specific_capability_prevents_portable_jit_target(
+    monkeypatch: pytest.MonkeyPatch,
+    runtime_capability: str,
+) -> None:
+    _install_target_info(monkeypatch)
+    target, _ = artifact_writer._artifact_target_metadata(
+        _config(backend=EvaluatorBackend.JIT, native_arch=False),
+        runtime_capabilities=(runtime_capability,),
+    )
+    assert target == {
+        "triple": "x86_64-unknown-linux-gnu",
+        "cpu_features": [],
+    }
+
+
+@pytest.mark.parametrize(
+    ("kind", "optimization_level", "expected"),
+    (
+        ("symjit-application-evaluator", 2, (True, 1)),
+        ("symjit-application-evaluator", 1, (True, 1)),
+        ("symjit-application-evaluator", 0, (False, 1)),
+        ("symjit-application-evaluator", 3, (False, 1)),
+        ("compiled-complex-evaluator", 2, (False, 0)),
+        ("jit-symbolica-evaluator", 2, (False, 0)),
+    ),
+)
+def test_implicit_generation_evaluator_evidence_requires_portable_symjit(
+    kind: str,
+    optimization_level: int,
+    expected: tuple[bool, int],
+) -> None:
+    record = {
+        "evaluator": {
+            "kind": kind,
+            "optimization_level": optimization_level,
+            "plane_application": {
+                "optimization_level": optimization_level,
+            },
+        }
+    }
+    assert (
+        artifact_writer._mapping_has_only_portable_symjit_evaluators(record)
+        == expected
+    )
+
+
+def test_jit_stays_baseline_when_cpp_native_option_is_irrelevant(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _install_target_info(monkeypatch)
+    target, _ = artifact_writer._artifact_target_metadata(
+        _config(backend=EvaluatorBackend.JIT, native_arch=True)
+    )
+    assert target["triple"] == PORTABLE_64LE_TARGET
+    assert target["cpu_features"] == []
+
+
+@pytest.mark.parametrize("backend", (EvaluatorBackend.ASM, EvaluatorBackend.CPP))
+def test_native_compiled_evaluators_record_detected_features(
+    monkeypatch: pytest.MonkeyPatch, backend: EvaluatorBackend
+) -> None:
+    _install_target_info(monkeypatch)
+    target, _ = artifact_writer._target_metadata(
+        _config(backend=backend, native_arch=True)
+    )
+    assert target["cpu_features"] == ["avx2", "fma", "sse2"]
+
+
+def test_writer_rejects_noncanonical_rusticol_target_metadata(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _install_target_info(monkeypatch, features=("sse2", "avx2"))
+    with pytest.raises(RuntimeError, match="non-canonical"):
+        artifact_writer._target_metadata(
+            _config(backend=EvaluatorBackend.CPP, native_arch=True)
+        )
+
+
+def test_writer_rejects_targets_outside_the_release_contract(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _install_target_info(monkeypatch, triple="aarch64-unknown-linux-gnu")
+    with pytest.raises(RuntimeError, match="not supported"):
+        artifact_writer._target_metadata(
+            _config(backend=EvaluatorBackend.JIT, native_arch=False)
+        )
diff --git a/pyamplicol/tests/unit/test_tensor_ordering_ir.py b/pyamplicol/tests/unit/test_tensor_ordering_ir.py
new file mode 100644
index 0000000000..693ff486a6
--- /dev/null
+++ b/pyamplicol/tests/unit/test_tensor_ordering_ir.py
@@ -0,0 +1,500 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import replace
+
+import pytest
+
+from pyamplicol.models._physics_ir import TensorAxisIR, TensorOrderingIR
+from pyamplicol.models.compiler_contacts import _compress_contact_components
+from pyamplicol.models.compiler_tensor_ordering import (
+    compile_tensor_ordering_metadata,
+    compile_vertex_index_bindings,
+    identity_ordering_for_materialized_axes,
+)
+from pyamplicol.models.contracts import (
+    CompiledModelIR,
+    CompiledOrientedKernel,
+    CompiledParticleRecord,
+    CompiledVertexTerm,
+)
+from pyamplicol.models.loading import compiler_fingerprint
+
+
+def _scalar(name: str = "phi") -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=name,
+        pdg_code=8_100_001,
+        spin=1,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def _fermion(name: str, antiname: str, pdg: int) -> CompiledParticleRecord:
+    charge = 1.0 if pdg > 0 else -1.0
+    return CompiledParticleRecord(
+        name=name,
+        antiname=antiname,
+        pdg_code=pdg,
+        spin=2,
+        color=1,
+        mass="ZERO",
+        width="ZERO",
+        charge=charge,
+        quantum_numbers=(("electric_charge", "1" if pdg > 0 else "-1"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def _vector(name: str = "phi") -> CompiledParticleRecord:
+    return CompiledParticleRecord(
+        name=name,
+        antiname=name,
+        pdg_code=8_100_002,
+        spin=3,
+        color=8,
+        mass="ZERO",
+        width="ZERO",
+        charge=0.0,
+        quantum_numbers=(("electric_charge", "0"),),
+        ghost_number=0,
+        propagating=True,
+        goldstoneboson=False,
+        propagator=None,
+    )
+
+
+def _term(*, dummy: int | None = None) -> CompiledVertexTerm:
+    color_expression = "1"
+    lorentz_expression = "1"
+    if dummy is not None:
+        color_expression = (
+            f"spenso::f(ufo_c_1,ufo_c_dummy_{dummy}_adjoint,ufo_c_2)"
+            f"*spenso::f(ufo_c_dummy_{dummy}_adjoint,ufo_c_3,ufo_c_1)"
+        )
+        lorentz_expression = (
+            f"spenso::g(ufo_l_1_1,ufo_l_dummy_{dummy})"
+            f"*spenso::g(ufo_l_dummy_{dummy},ufo_l_1_2)"
+        )
+    return CompiledVertexTerm(
+        id=0,
+        vertex="V_1",
+        particles=("phi", "phi", "phi"),
+        color_index=0,
+        lorentz_index=0,
+        color_source="1",
+        color_expression=color_expression,
+        lorentz_name="L_1",
+        lorentz_source="1",
+        lorentz_expression=lorentz_expression,
+        coupling="GC_1",
+        coupling_expression="1",
+        coupling_orders=(),
+    )
+
+
+def _compiled_scalar_model() -> CompiledModelIR:
+    particle = _scalar()
+    term = _term()
+    kernel = CompiledOrientedKernel(
+        kind=0,
+        term_id=0,
+        vertex="V_1",
+        particles=("phi", "phi", "phi"),
+        source_particle_legs=(0, 1, 2),
+        component_expressions=("1",),
+        coupling_expression="1",
+        coupling_orders=(),
+        runtime_parameters=(),
+        color_source="1",
+        color_expression="1",
+        term_ids=(0,),
+    )
+    terms, kernels, orderings, current_orderings = compile_tensor_ordering_metadata(
+        (term,),
+        (particle,),
+        (kernel,),
+        (),
+        (),
+    )
+    return CompiledModelIR(
+        name="tensor-ordering-model",
+        orders=(),
+        parameters=(),
+        particles=(particle,),
+        couplings=(),
+        propagators=(),
+        vertex_terms=terms,
+        oriented_kernels=kernels,
+        direct_contractions=(),
+        closure_contractions=(),
+        tensor_orderings=orderings,
+        current_orderings=current_orderings,
+    )
+
+
+def _compiled_fermion_model() -> CompiledModelIR:
+    particles = (
+        _fermion("psi", "psi_bar", 8_200_001),
+        _fermion("psi_bar", "psi", -8_200_001),
+        _scalar(),
+    )
+    term = CompiledVertexTerm(
+        id=0,
+        vertex="V_fermion",
+        particles=("psi", "psi_bar", "phi"),
+        color_index=0,
+        lorentz_index=0,
+        color_source="1",
+        color_expression="1",
+        lorentz_name="L_fermion",
+        lorentz_source="1",
+        lorentz_expression="1",
+        coupling="GC_1",
+        coupling_expression="1",
+        coupling_orders=(),
+    )
+    kernel = CompiledOrientedKernel(
+        kind=0,
+        term_id=0,
+        vertex="V_fermion",
+        particles=("psi", "psi_bar", "phi"),
+        source_particle_legs=(0, 1, 2),
+        component_expressions=("1",),
+        coupling_expression="1",
+        coupling_orders=(),
+        runtime_parameters=(),
+        color_source="1",
+        color_expression="1",
+        term_ids=(0,),
+    )
+    terms, kernels, orderings, current_orderings = compile_tensor_ordering_metadata(
+        (term,), particles, (kernel,), (), ()
+    )
+    return CompiledModelIR(
+        name="tensor-ordering-fermion-model",
+        orders=(),
+        parameters=(),
+        particles=particles,
+        couplings=(),
+        propagators=(),
+        vertex_terms=terms,
+        oriented_kernels=kernels,
+        direct_contractions=(),
+        closure_contractions=(),
+        tensor_orderings=orderings,
+        current_orderings=current_orderings,
+    )
+
+
+def _replace_ordering_id(payload: dict[str, object], old: str, new: str) -> None:
+    for term in payload["vertex_terms"]:
+        term["source_ordering_ids"] = [
+            new if value == old else value for value in term["source_ordering_ids"]
+        ]
+    for kernel in payload["oriented_kernels"]:
+        kernel["input_ordering_ids"] = [
+            new if value == old else value for value in kernel["input_ordering_ids"]
+        ]
+        if kernel["output_ordering_id"] == old:
+            kernel["output_ordering_id"] = new
+    for current in payload["current_orderings"]:
+        if current["ordering_id"] == old:
+            current["ordering_id"] = new
+        if current["kernel_ordering_id"] == old:
+            current["kernel_ordering_id"] = new
+
+
+def test_non_square_tensor_ordering_round_trips_with_permuted_storage() -> None:
+    component_basis = (2, 0, 5, 1, 4, 3)
+    component_expansion: list[tuple[int, int] | None] = [None] * 6
+    for storage_slot, canonical_component in enumerate(component_basis):
+        component_expansion[canonical_component] = (storage_slot, 1)
+    ordering = TensorOrderingIR.create(
+        basis="rectangular-test",
+        axes=(
+            TensorAxisIR("axis-0", "test-row", 2),
+            TensorAxisIR("axis-1", "test-column", 3),
+        ),
+        component_basis=component_basis,
+        component_expansion=component_expansion,
+    )
+
+    assert ordering.canonical_size == 6
+    assert ordering.stored_size == 6
+    assert TensorOrderingIR.from_json_dict(ordering.to_json_dict()) == ordering
+
+
+@pytest.mark.parametrize(
+    ("mutate", "message"),
+    [
+        (
+            lambda payload: payload.__setitem__("ordering_id", "stale"),
+            "ID does not match",
+        ),
+        (
+            lambda payload: payload["axes"].append(deepcopy(payload["axes"][0])),
+            "axis names must be unique",
+        ),
+        (
+            lambda payload: payload["component_basis"].__setitem__(0, 99),
+            "basis index is out of range",
+        ),
+        (
+            lambda payload: payload["component_expansion"][0].__setitem__(1, 2),
+            r"sign must be \+/-1",
+        ),
+    ],
+)
+def test_tensor_ordering_corruption_fails_closed(mutate, message: str) -> None:
+    ordering = TensorOrderingIR.identity(
+        basis="rectangular-test",
+        axes=(
+            TensorAxisIR("axis-0", "test-row", 2),
+            TensorAxisIR("axis-1", "test-column", 3),
+        ),
+    )
+    payload = ordering.to_json_dict()
+
+    mutate(payload)
+
+    with pytest.raises(ValueError, match=message):
+        TensorOrderingIR.from_json_dict(payload)
+
+
+def test_source_axis_and_dummy_renaming_do_not_change_ordering_identity() -> None:
+    first = identity_ordering_for_materialized_axes(
+        ("ufo_l_1_1", "ufo_l_2_1"),
+        (2, 3),
+    )
+    relabelled = identity_ordering_for_materialized_axes(
+        ("ufo_l_1_9", "ufo_l_2_9"),
+        (2, 3),
+    )
+    particle = _vector()
+    bindings_7 = compile_vertex_index_bindings(_term(dummy=7), {"phi": particle})
+    bindings_91 = compile_vertex_index_bindings(_term(dummy=91), {"phi": particle})
+
+    assert first.ordering_id == relabelled.ordering_id
+    assert tuple(binding.normalized_name for binding in bindings_7) == tuple(
+        binding.normalized_name for binding in bindings_91
+    )
+    assert {binding.source_dummy for binding in bindings_7 if binding.source_dummy} == {
+        -7
+    }
+    assert {
+        binding.source_dummy for binding in bindings_91 if binding.source_dummy
+    } == {-91}
+
+
+def test_compiled_model_ordering_graph_round_trips_and_rejects_stale_links() -> None:
+    model = _compiled_scalar_model()
+    payload = model.to_dict()
+
+    assert CompiledModelIR.from_dict(payload) == model
+
+    stale_kernel = deepcopy(payload)
+    stale_kernel["oriented_kernels"][0]["output_ordering_id"] = "absent"
+    with pytest.raises(ValueError, match="absent tensor ordering 'absent'"):
+        CompiledModelIR.from_dict(stale_kernel)
+
+    wrong_size = deepcopy(payload)
+    wrong_size["oriented_kernels"][0]["component_expressions"].append("0")
+    with pytest.raises(ValueError, match="2 components for output ordering size 1"):
+        CompiledModelIR.from_dict(wrong_size)
+
+    stale_source = deepcopy(payload)
+    stale_source["vertex_terms"][0]["source_ordering_ids"][0] = "absent"
+    with pytest.raises(ValueError, match="source leg 1 refers to absent"):
+        CompiledModelIR.from_dict(stale_source)
+
+    duplicate_ordering = deepcopy(payload)
+    duplicate_ordering["tensor_orderings"].append(
+        deepcopy(duplicate_ordering["tensor_orderings"][0])
+    )
+    with pytest.raises(ValueError, match="duplicate tensor ordering"):
+        CompiledModelIR.from_dict(duplicate_ordering)
+
+    invalid_embedding = deepcopy(payload)
+    invalid_embedding["current_orderings"][0]["input_embedding"] = [1]
+    with pytest.raises(ValueError, match="does not map every stored component"):
+        CompiledModelIR.from_dict(invalid_embedding)
+
+    unverified_exchange = deepcopy(payload)
+    unverified_exchange["oriented_kernels"][0][
+        "evaluation_input_exchange_factor"
+    ] = [-1.0, 0.0]
+    with pytest.raises(ValueError, match="unverified input-exchange relation"):
+        CompiledModelIR.from_dict(unverified_exchange)
+
+    invalid_exchange = deepcopy(unverified_exchange)
+    invalid_exchange["oriented_kernels"][0][
+        "evaluation_equivalence_verified"
+    ] = True
+    invalid_exchange["oriented_kernels"][0][
+        "evaluation_input_exchange_factor"
+    ] = [0.0, 1.0]
+    with pytest.raises(ValueError, match="invalid input-exchange phase"):
+        CompiledModelIR.from_dict(invalid_exchange)
+
+
+def test_compiled_model_rejects_self_consistent_but_false_ordering() -> None:
+    payload = _compiled_scalar_model().to_dict()
+    ordering = payload["tensor_orderings"][0]
+    old_id = ordering["ordering_id"]
+    ordering["basis"] = "forged-scalar"
+    replacement = TensorOrderingIR.create(
+        basis=ordering["basis"],
+        axes=(),
+        component_basis=ordering["component_basis"],
+        component_expansion=tuple(
+            None if entry is None else tuple(entry)
+            for entry in ordering["component_expansion"]
+        ),
+    )
+    ordering["ordering_id"] = replacement.ordering_id
+    _replace_ordering_id(payload, old_id, replacement.ordering_id)
+
+    with pytest.raises(ValueError, match="stale source tensor orderings"):
+        CompiledModelIR.from_dict(payload)
+
+
+def test_compiled_model_rejects_fabricated_index_bindings() -> None:
+    particle = _vector()
+    term = _term(dummy=7)
+    kernel = CompiledOrientedKernel(
+        kind=0,
+        term_id=0,
+        vertex="V_1",
+        particles=("phi", "phi", "phi"),
+        source_particle_legs=(0, 1, 2),
+        component_expressions=("1", "1", "1", "1"),
+        coupling_expression="1",
+        coupling_orders=(),
+        runtime_parameters=(),
+        color_source="1",
+        color_expression="1",
+        term_ids=(0,),
+    )
+    terms, kernels, orderings, current_orderings = compile_tensor_ordering_metadata(
+        (term,), (particle,), (kernel,), (), ()
+    )
+    model = CompiledModelIR(
+        name="tensor-index-binding-model",
+        orders=(),
+        parameters=(),
+        particles=(particle,),
+        couplings=(),
+        propagators=(),
+        vertex_terms=terms,
+        oriented_kernels=kernels,
+        direct_contractions=(),
+        closure_contractions=(),
+        tensor_orderings=orderings,
+        current_orderings=current_orderings,
+    )
+    payload = model.to_dict()
+    payload["vertex_terms"][0]["index_bindings"][0]["normalized_name"] = (
+        "color:color-singlet:dummy-99"
+    )
+
+    with pytest.raises(ValueError, match="stale tensor index bindings"):
+        CompiledModelIR.from_dict(payload)
+
+
+@pytest.mark.parametrize(
+    ("expression", "message"),
+    [
+        ("spenso::g(ufo_l_bad_1,ufo_l_1_1)", "malformed normalized"),
+        ("spenso::g(ufo_s_1_1,ufo_l_1_2)", "incompatible with particle"),
+    ],
+)
+def test_index_bindings_reject_malformed_or_particle_incompatible_indices(
+    expression: str,
+    message: str,
+) -> None:
+    term = replace(
+        _term(),
+        particles=("phi", "phi", "phi"),
+        lorentz_expression=expression,
+    )
+
+    with pytest.raises(ValueError, match=message):
+        compile_vertex_index_bindings(term, {"phi": _vector()})
+
+
+def test_compiled_model_rejects_runtime_incompatible_current_mapping() -> None:
+    payload = _compiled_fermion_model().to_dict()
+    current = next(
+        item
+        for item in payload["current_orderings"]
+        if item["particle"] == "psi" and item["chirality"] == 1
+    )
+    current["input_embedding"] = [1, 0, None, None]
+    current["result_projection"] = [3, 2]
+
+    with pytest.raises(ValueError, match="current tensor mappings are not canonical"):
+        CompiledModelIR.from_dict(payload)
+
+
+def test_all_zero_contact_compression_keeps_one_explicit_zero_slot() -> None:
+    component_basis, component_expansion = _compress_contact_components(("0", "0"))
+
+    assert component_basis == (0,)
+    assert component_expansion == ((0, 1), None)
+    ordering = TensorOrderingIR.create(
+        basis="zero-contact",
+        axes=(TensorAxisIR("axis-0", "test", 2),),
+        component_basis=component_basis,
+        component_expansion=component_expansion,
+    )
+    assert ordering.stored_size == 1
+
+
+def test_compiled_model_ordering_fields_are_required_on_deserialization() -> None:
+    payload = _compiled_scalar_model().to_dict()
+    del payload["tensor_orderings"]
+
+    with pytest.raises(
+        ValueError,
+        match="missing required field 'tensor_orderings'",
+    ):
+        CompiledModelIR.from_dict(payload)
+
+    assert compiler_fingerprint()["tensor_ordering_contract"] == (
+        "explicit-canonical-component-order-v1"
+    )
+
+
+def test_weyl_current_embeddings_and_result_projections_are_explicit() -> None:
+    particles = (
+        _fermion("psi", "psi_bar", 8_200_001),
+        _fermion("psi_bar", "psi", -8_200_001),
+    )
+    _terms, _kernels, orderings, current_orderings = (
+        compile_tensor_ordering_metadata((), particles, (), (), ())
+    )
+    by_selector = {record.selector: record for record in current_orderings}
+
+    assert by_selector[("psi", 1)].input_embedding == (0, 1, None, None)
+    assert by_selector[("psi", 1)].result_projection == (2, 3)
+    assert by_selector[("psi", -1)].input_embedding == (None, None, 0, 1)
+    assert by_selector[("psi", -1)].result_projection == (0, 1)
+    assert {ordering.basis for ordering in orderings} == {
+        "dirac",
+        "weyl-chirality:+1",
+        "weyl-chirality:-1",
+    }
diff --git a/pyamplicol/tests/unit/test_three_mode_report_catalog.py b/pyamplicol/tests/unit/test_three_mode_report_catalog.py
new file mode 100644
index 0000000000..72d035f6d7
--- /dev/null
+++ b/pyamplicol/tests/unit/test_three_mode_report_catalog.py
@@ -0,0 +1,1484 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+from collections import Counter
+from copy import deepcopy
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+import tools.performance_report.manual_campaign as manual_campaign
+from tools.performance_report.agreements import (
+    DIRECT_AGREEMENT_FIELD,
+    DIRECT_AGREEMENT_KINDS,
+    INDEPENDENT_AUTHORITY_ABI,
+    INDEPENDENT_AUTHORITY_FIELD,
+    LC_LEGACY_PYAMPLICOL_COMPONENT,
+    incoming_agreement_edges,
+    independent_numerical_authorities,
+)
+from tools.performance_report.arena_profile import (
+    ARENA_PHASE_TIMING_SCOPE,
+    ARENA_PROFILE_BOUNDARY,
+    EMPTY_ARENA_PHASE_VECTOR_FIELDS,
+    ZERO_ARENA_COUNTER_FIELDS,
+    ZERO_ARENA_PHASE_TIME_FIELDS,
+    ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS,
+    build_arena_profile_evidence,
+    digest_arena_profile_value,
+)
+from tools.performance_report.cache import (
+    CACHE_SCHEMA_VERSION,
+    REPORT_VERSION,
+    _validate_unverified_direct_agreement_coverage,
+    build_reset_caches,
+    digest_json,
+    empty_measurement,
+    schema_document,
+    validate_cache,
+    validate_measurement,
+)
+from tools.performance_report.catalog import (
+    MADGRAPH_FULL_COMPARISON_VIEWS,
+    REPORT_CATALOG,
+    STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6,
+    STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6_DESCRIPTION,
+    STATIC_NA_ORIGINAL_AMPLICOL_OPEN_QUARK_LINE_LIMIT,
+)
+from tools.performance_report.models import (
+    Accuracy,
+    ArtifactPolicy,
+    CellSpec,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+    ZVariant,
+)
+from tools.performance_report.runner import pointwise_validation
+from tools.performance_report.service import ReportPaths, ReportService
+
+
+def test_matrix_catalog_adds_only_the_three_missing_ufo_full_candidates() -> None:
+    datasets = REPORT_CATALOG.matrix_datasets
+
+    assert len(datasets) == 18
+    assert Counter(item.candidate.execution_mode for item in datasets) == {
+        ExecutionMode.RECURRENCE: 6,
+        ExecutionMode.COMPILED: 4,
+        ExecutionMode.EAGER: 4,
+        ExecutionMode.ON_THE_FLY: 4,
+    }
+    assert Counter(item.candidate.model for item in datasets) == {
+        ModelKey.BUILTIN_SM: 12,
+        ModelKey.UFO_SM: 6,
+    }
+    assert all(
+        item.baseline.execution_mode is ExecutionMode.AMPLICOL
+        for item in datasets
+        if item.candidate.execution_mode is ExecutionMode.RECURRENCE
+    )
+    assert all(
+        item.baseline.execution_mode is ExecutionMode.RECURRENCE
+        for item in datasets
+        if item.candidate.execution_mode
+        in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+        and item.candidate.model is ModelKey.BUILTIN_SM
+    )
+    assert all(
+        item.baseline.execution_mode is ExecutionMode.MADGRAPH
+        for item in datasets
+        if item.candidate.model is ModelKey.UFO_SM
+        and item.candidate.accuracy is Accuracy.FULL
+        and item.candidate.execution_mode
+        in {
+            ExecutionMode.COMPILED,
+            ExecutionMode.EAGER,
+            ExecutionMode.ON_THE_FLY,
+        }
+    )
+
+
+def test_madgraph_full_reference_is_one_shared_fifty_cell_ufo_surface() -> None:
+    references = tuple(
+        cell
+        for cell in REPORT_CATALOG.reference_cells()
+        if cell.dataset_id == "reference_madgraph_full"
+    )
+
+    assert len(references) == 50
+    assert len({cell.cell_id for cell in references}) == 50
+    assert all(
+        cell.measurement.execution_mode is ExecutionMode.MADGRAPH
+        and cell.measurement.model is ModelKey.UFO_SM
+        and cell.measurement.accuracy is Accuracy.FULL
+        and cell.measurement.backend == "fortran"
+        and cell.workload is Workload.CONTRACTED
+        for cell in references
+    )
+
+
+def test_madgraph_comparison_views_reuse_one_recurrence_profile() -> None:
+    views = MADGRAPH_FULL_COMPARISON_VIEWS
+
+    assert REPORT_CATALOG.matrix_comparison_views is views
+    assert len(views) == 4
+    assert {view.baseline_dataset_id for view in views} == {
+        "reference_madgraph_full"
+    }
+    assert {view.candidate_dataset_id for view in views} == {
+        f"matrix_{mode.value.replace('-', '_')}_ufo_sm_full"
+        for mode in {
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.COMPILED,
+            ExecutionMode.EAGER,
+            ExecutionMode.ON_THE_FLY,
+        }
+    }
+    assert len(
+        [
+            dataset
+            for dataset in REPORT_CATALOG.matrix_datasets
+            if dataset.dataset_id == "matrix_recurrence_ufo_sm_full"
+        ]
+    ) == 1
+    assert len(
+        [
+            cell
+            for cell in REPORT_CATALOG.matrix_cells()
+            if cell.dataset_id == "matrix_recurrence_ufo_sm_full"
+        ]
+    ) == 50
+    assert all(
+        REPORT_CATALOG.comparison_view(view.comparison_id) is view for view in views
+    )
+
+
+def test_madgraph_candidate_baselines_and_direct_cell_ids_are_unambiguous() -> None:
+    candidates = tuple(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.dataset_id
+        in {
+            "matrix_compiled_ufo_sm_full",
+            "matrix_eager_ufo_sm_full",
+            "matrix_on_the_fly_ufo_sm_full",
+        }
+    )
+
+    assert len(candidates) == 150
+    assert all(
+        (baseline := REPORT_CATALOG.baseline_cell(cell)) is not None
+        and baseline.dataset_id == "reference_madgraph_full"
+        and baseline.measurement.execution_mode is ExecutionMode.MADGRAPH
+        for cell in candidates
+    )
+    cell_ids = tuple(cell.cell_id for cell in REPORT_CATALOG.measurement_cells())
+    assert len(cell_ids) == len(set(cell_ids))
+
+
+def test_required_agreement_evidence_bumps_report_cache_contract() -> None:
+    assert CACHE_SCHEMA_VERSION == 5
+    assert REPORT_VERSION == "0.3.0"
+
+
+def test_packaged_report_cache_schema_is_canonical() -> None:
+    packaged = (
+        Path(__file__).resolve().parents[2]
+        / "src/pyamplicol/_profiling_campaign/results/report-cache.schema.json"
+    )
+    assert json.loads(packaged.read_text(encoding="ascii")) == schema_document()
+
+
+def test_report_cache_schema_accepts_every_direct_agreement_kind() -> None:
+    def edge_kind_enums(value: object) -> list[tuple[str, ...]]:
+        if isinstance(value, dict):
+            found: list[tuple[str, ...]] = []
+            edge_kind = value.get("edge_kind")
+            if isinstance(edge_kind, dict) and isinstance(edge_kind.get("enum"), list):
+                found.append(tuple(edge_kind["enum"]))
+            for child in value.values():
+                found.extend(edge_kind_enums(child))
+            return found
+        if isinstance(value, list):
+            return [item for child in value for item in edge_kind_enums(child)]
+        return []
+
+    enums = edge_kind_enums(schema_document())
+    assert len(enums) == 6
+    assert all(enum == DIRECT_AGREEMENT_KINDS for enum in enums)
+
+
+def test_prepared_modes_are_portable_o2_and_compiled_is_o3() -> None:
+    by_mode = {
+        mode: {
+            dataset.candidate.jit_optimization_level
+            for dataset in REPORT_CATALOG.matrix_datasets
+            if dataset.candidate.execution_mode is mode
+        }
+        for mode in (
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.COMPILED,
+            ExecutionMode.EAGER,
+            ExecutionMode.ON_THE_FLY,
+        )
+    }
+
+    assert by_mode == {
+        ExecutionMode.RECURRENCE: {2},
+        ExecutionMode.COMPILED: {3},
+        ExecutionMode.EAGER: {2},
+        ExecutionMode.ON_THE_FLY: {2},
+    }
+
+
+def test_lc_cells_have_two_runtime_workloads_and_contracted_cells_have_one() -> None:
+    counts = Counter(
+        (cell.measurement.accuracy, cell.workload)
+        for cell in REPORT_CATALOG.matrix_cells()
+    )
+
+    assert counts[(Accuracy.LC, Workload.SELECTED_FLOW)] == 461
+    assert counts[(Accuracy.LC, Workload.ALL_FLOW)] == 461
+    assert counts[(Accuracy.NLC, Workload.CONTRACTED)] == 250
+    assert counts[(Accuracy.FULL, Workload.CONTRACTED)] == 400
+    assert all(
+        cell.workload is Workload.CONTRACTED
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.accuracy is not Accuracy.LC
+    )
+
+
+def test_extended_lc_families_are_declared_through_n9() -> None:
+    process_keys = {
+        "gg_tt_jets",
+        "gg_gluons",
+        "dd_3q_lines",
+        "dd_4q_lines",
+        "dd_3q_identical_lines",
+    }
+    cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.n_final == 9
+        and cell.process_key in process_keys
+        and cell.measurement.accuracy is Accuracy.LC
+    )
+
+    assert len(cells) == 50
+    assert {
+        (
+            cell.process_key,
+            cell.measurement.execution_mode,
+            cell.measurement.model,
+            cell.workload,
+        )
+        for cell in cells
+    } == {
+        (process_key, mode, model, workload)
+        for process_key in process_keys
+        for mode, model in {
+            (ExecutionMode.AMPLICOL, None),
+            (ExecutionMode.RECURRENCE, ModelKey.BUILTIN_SM),
+            (ExecutionMode.RECURRENCE, ModelKey.UFO_SM),
+            (ExecutionMode.COMPILED, ModelKey.BUILTIN_SM),
+            (ExecutionMode.EAGER, ModelKey.BUILTIN_SM),
+        }
+        for workload in {Workload.SELECTED_FLOW, Workload.ALL_FLOW}
+    }
+    assert {
+        cell.process_key
+        for cell in cells
+        if REPORT_CATALOG.static_na_reason(cell) is not None
+    } == {"dd_4q_lines"}
+
+
+def test_n_le_four_matrix_smoke_has_594_logical_process_cells() -> None:
+    cells = [cell for cell in REPORT_CATALOG.matrix_cells() if cell.n_final <= 4]
+    logical = {(cell.dataset_id, cell.process_key, cell.n_final) for cell in cells}
+
+    assert len(logical) == 594
+    assert len(cells) == 759
+
+
+def test_identical_quark_line_family_has_canonical_order_and_full_coverage() -> None:
+    family = next(
+        family for family in REPORT_CATALOG.process_families if family.identifier == 15
+    )
+
+    assert family.key == "dd_3q_identical_lines"
+    assert family.label_tex == r"$d\bar d\to u\bar u\,u\bar u+(n-4)g$"
+    assert family.minimum_n == 4
+    assert family.maximum_n(Accuracy.LC) == 9
+    assert family.maximum_n(Accuracy.NLC) == 6
+    assert family.maximum_n(Accuracy.FULL) == 6
+    assert family.include_3qqbar is True
+    assert family.process(3) is None
+    assert family.process(4) == "d d~ > u u~ u u~"
+    assert family.process(8) == "d d~ > u u~ u u~ g g g g"
+
+    cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.process_key == family.key
+    )
+    assert len(cells) == 110
+    assert Counter(REPORT_CATALOG.static_na_reason(cell) for cell in cells) == {
+        None: 110,
+    }
+    assert (
+        REPORT_CATALOG.cell(
+            "matrix-recurrence-builtin-sm-full-n6-dd-3q-identical-lines-contracted"
+        ).process
+        == "d d~ > u u~ u u~ g g"
+    )
+
+
+def test_z_catalog_includes_recurrence_eager_and_on_the_fly() -> None:
+    variants = {variant.key: variant for variant in REPORT_CATALOG.z_variants}
+
+    assert variants["eager_jit_o2"].label == "eager-DAG JIT O2"
+    assert variants["recurrence_jit_o2"].label == "recurrence JIT O2"
+    assert variants["recurrence_jit_o2"].jit_optimization_level == 2
+    assert variants["on_the_fly_jit_o2"].label == "on-the-fly JIT O2"
+    assert (
+        variants["on_the_fly_jit_o2"].execution_mode
+        is ExecutionMode.ON_THE_FLY
+    )
+    assert (
+        len(
+            [
+                cell
+                for cell in REPORT_CATALOG.z_cells()
+                if cell.variant == "recurrence_jit_o2" and cell.n_final <= 4
+            ]
+        )
+        == 16
+    )
+    assert (
+        len(
+            [
+                cell
+                for cell in REPORT_CATALOG.z_cells()
+                if cell.variant == "on_the_fly_jit_o2" and cell.n_final <= 4
+            ]
+        )
+        == 16
+    )
+
+
+def test_scalar_ladders_are_canonical_resettable_cells() -> None:
+    assert tuple(dataset.dataset_id for dataset in REPORT_CATALOG.scalar_datasets) == (
+        "scalar_contact",
+        "scalar_gravity",
+    )
+    cells = REPORT_CATALOG.scalar_cells()
+    assert len(cells) == 10
+    assert all(cell.workload is Workload.CONTRACTED for cell in cells)
+    assert all(
+        cell.measurement.execution_mode is ExecutionMode.COMPILED for cell in cells
+    )
+    assert all(REPORT_CATALOG.baseline_cell(cell) is None for cell in cells)
+
+
+def test_baseline_dependencies_are_canonical_and_mode_ordered() -> None:
+    recurrence = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+    )
+    compiled = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode is ExecutionMode.COMPILED
+    )
+    eager = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode is ExecutionMode.EAGER
+    )
+
+    recurrence_baseline = REPORT_CATALOG.baseline_cell(recurrence)
+    compiled_baseline = REPORT_CATALOG.baseline_cell(compiled)
+    eager_baseline = REPORT_CATALOG.baseline_cell(eager)
+    assert recurrence_baseline is not None
+    assert recurrence_baseline.measurement.execution_mode is ExecutionMode.AMPLICOL
+    assert compiled_baseline is not None
+    assert compiled_baseline.measurement.execution_mode is ExecutionMode.RECURRENCE
+    assert eager_baseline is not None
+    assert eager_baseline.measurement.execution_mode is ExecutionMode.RECURRENCE
+    assert REPORT_CATALOG.cell(compiled.cell_id) == compiled
+
+
+def test_four_line_report_keeps_legacy_display_without_legacy_dependency() -> None:
+    recurrence = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.dataset_id == "matrix_recurrence_builtin_sm_lc"
+        and cell.process_key == "dd_4q_lines"
+        and cell.n_final == 6
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+    compiled = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.dataset_id == "matrix_compiled_builtin_sm_lc"
+        and cell.process_key == "dd_4q_lines"
+        and cell.n_final == 6
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+
+    display_baseline = REPORT_CATALOG.baseline_cell(recurrence)
+    assert display_baseline is not None
+    assert display_baseline.measurement.execution_mode is ExecutionMode.AMPLICOL
+    assert REPORT_CATALOG.legacy_reference_available(recurrence) is False
+    assert REPORT_CATALOG.static_na_reason(display_baseline) == (
+        "original-amplicol-open-quark-line-limit"
+    )
+    assert REPORT_CATALOG.validation_baseline_cell(recurrence) is None
+
+    compiled_baseline = REPORT_CATALOG.validation_baseline_cell(compiled)
+    assert compiled_baseline is not None
+    assert compiled_baseline.measurement.execution_mode is ExecutionMode.RECURRENCE
+
+    three_line_reference = REPORT_CATALOG.cell(
+        "reference-amplicol-full-n6-dd-3q-lines-contracted"
+    )
+    assert REPORT_CATALOG.legacy_reference_available(three_line_reference)
+    assert REPORT_CATALOG.static_na_reason(three_line_reference) is None
+
+
+def test_canonical_static_na_census_is_exact() -> None:
+    static_na = {
+        cell.cell_id: REPORT_CATALOG.static_na_reason(cell)
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is not None
+    }
+
+    expected = {
+        cell_id: STATIC_NA_ORIGINAL_AMPLICOL_OPEN_QUARK_LINE_LIMIT
+        for cell_id in {
+            "reference-amplicol-lc-n6-dd-4q-lines-selected-flow",
+            "reference-amplicol-lc-n6-dd-4q-lines-all-flow",
+            "reference-amplicol-lc-n7-dd-4q-lines-selected-flow",
+            "reference-amplicol-lc-n7-dd-4q-lines-all-flow",
+            "reference-amplicol-lc-n8-dd-4q-lines-selected-flow",
+            "reference-amplicol-lc-n8-dd-4q-lines-all-flow",
+            "reference-amplicol-lc-n9-dd-4q-lines-selected-flow",
+            "reference-amplicol-lc-n9-dd-4q-lines-all-flow",
+            "reference-amplicol-nlc-n6-dd-4q-lines-contracted",
+            "reference-amplicol-full-n6-dd-4q-lines-contracted",
+        }
+    }
+    expected.update(
+        {
+            (
+                f"z-{model}-n{n_final}-dd-z-jets-{variant}-{workload}"
+            ): STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6
+            for model in ("builtin-sm", "external-sm")
+            for n_final in (7, 8, 9)
+            for variant in ("asm-o3", "cpp-o3")
+            for workload in ("selected-flow", "all-flow")
+        }
+    )
+    assert static_na == expected
+    for cell_id, reason in expected.items():
+        if reason != STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6:
+            continue
+        cell = REPORT_CATALOG.cell(cell_id)
+        assert (
+            REPORT_CATALOG.static_na_description(cell)
+            == STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6_DESCRIPTION
+        )
+
+
+def test_z_variant_generation_cap_contract_is_paired_and_positive() -> None:
+    with pytest.raises(ValueError, match="positive integer"):
+        ZVariant(
+            "bad",
+            "bad",
+            ExecutionMode.COMPILED,
+            "asm",
+            maximum_generation_n_final=0,
+            static_na_reason_code="reason-v1",
+        )
+    with pytest.raises(ValueError, match="requires a static_na_reason_code"):
+        ZVariant(
+            "bad",
+            "bad",
+            ExecutionMode.COMPILED,
+            "asm",
+            maximum_generation_n_final=6,
+        )
+    with pytest.raises(ValueError, match="requires maximum_generation_n_final"):
+        ZVariant(
+            "bad",
+            "bad",
+            ExecutionMode.COMPILED,
+            "asm",
+            static_na_reason_code="reason-v1",
+        )
+
+
+def test_contracted_multi_quark_coverage_reaches_n6_in_every_mode() -> None:
+    process_keys = {
+        "dd_3q_lines",
+        "dd_3q_identical_lines",
+        "dd_4q_lines",
+    }
+    cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.process_key in process_keys
+        and cell.n_final == 6
+        and cell.measurement.accuracy in {Accuracy.NLC, Accuracy.FULL}
+    )
+
+    assert len(cells) == 48
+    assert {
+        (
+            cell.process_key,
+            cell.measurement.accuracy,
+            cell.measurement.execution_mode,
+            cell.measurement.model,
+        )
+        for cell in cells
+    } == {
+        (process_key, accuracy, mode, model)
+        for process_key in process_keys
+        for accuracy in {Accuracy.NLC, Accuracy.FULL}
+        for mode, model in {
+            (ExecutionMode.AMPLICOL, None),
+            (ExecutionMode.RECURRENCE, ModelKey.BUILTIN_SM),
+            (ExecutionMode.RECURRENCE, ModelKey.UFO_SM),
+            (ExecutionMode.COMPILED, ModelKey.BUILTIN_SM),
+            (ExecutionMode.EAGER, ModelKey.BUILTIN_SM),
+            (ExecutionMode.ON_THE_FLY, ModelKey.BUILTIN_SM),
+        }
+    } | {
+        (process_key, Accuracy.FULL, mode, model)
+        for process_key in process_keys
+        for mode, model in {
+            (ExecutionMode.MADGRAPH, ModelKey.UFO_SM),
+            (ExecutionMode.COMPILED, ModelKey.UFO_SM),
+            (ExecutionMode.EAGER, ModelKey.UFO_SM),
+            (ExecutionMode.ON_THE_FLY, ModelKey.UFO_SM),
+        }
+    }
+    assert (
+        REPORT_CATALOG.cell(
+            "matrix-recurrence-builtin-sm-full-n6-dd-3q-lines-contracted"
+        ).process
+        == "d d~ > u u~ s s~ g g"
+    )
+
+
+def test_contracted_n6_catalog_impact_is_scoped_to_multi_quark_families() -> None:
+    process_keys = {
+        "dd_3q_lines",
+        "dd_3q_identical_lines",
+        "dd_4q_lines",
+    }
+    cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.process_key in process_keys
+        and cell.n_final == 6
+        and cell.measurement.accuracy is not Accuracy.LC
+    )
+
+    assert len(REPORT_CATALOG.measurement_cells()) == 2198
+    assert len(REPORT_CATALOG.matrix_cells()) == 1572
+    assert len(REPORT_CATALOG.reference_cells()) == 364
+    assert len(cells) == 48
+    assert {cell.process_key for cell in cells} == process_keys
+
+
+def test_measurement_cells_reuses_one_immutable_catalog_materialization() -> None:
+    fresh = replace(REPORT_CATALOG)
+    cold_repr = repr(fresh)
+
+    assert fresh._measurement_cells_cache is None
+
+    first = fresh.measurement_cells()
+    second = fresh.measurement_cells()
+
+    assert second is first
+    assert fresh._measurement_cells_cache is first
+    assert isinstance(first, tuple)
+    assert repr(fresh) == cold_repr
+    assert "_measurement_cells_cache" not in repr(fresh)
+
+
+def test_contracted_n6_rows_are_canonical_reset_cache_entries() -> None:
+    caches = build_reset_caches()
+    payload = caches["matrix_recurrence_builtin_sm_full.json"]
+    expected = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == "matrix_recurrence_builtin_sm_full"
+    )
+
+    validate_cache(payload, expected_cells=expected)
+    entries = {
+        entry["cell_id"]: entry for entry in payload["entries"] if entry["n_final"] == 6
+    }
+    assert set(entries) == {
+        "matrix-recurrence-builtin-sm-full-n6-dd-3q-lines-contracted",
+        ("matrix-recurrence-builtin-sm-full-n6-dd-3q-identical-lines-contracted"),
+        "matrix-recurrence-builtin-sm-full-n6-dd-4q-lines-contracted",
+    }
+    assert all(
+        entry["measurement"] == empty_measurement() for entry in entries.values()
+    )
+
+
+@pytest.mark.parametrize(
+    "process_key",
+    ("dd_3q_lines", "dd_3q_identical_lines"),
+)
+def test_three_line_reports_retain_the_original_amplicol_oracle(
+    process_key: str,
+) -> None:
+    recurrence = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.dataset_id == "matrix_recurrence_builtin_sm_lc"
+        and cell.process_key == process_key
+        and cell.n_final == 4
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+
+    baseline = REPORT_CATALOG.validation_baseline_cell(recurrence)
+    assert REPORT_CATALOG.legacy_reference_available(recurrence) is True
+    assert baseline is not None
+    assert baseline.measurement.execution_mode is ExecutionMode.AMPLICOL
+
+
+def test_equivalent_cells_require_exact_generation_semantics() -> None:
+    selected_recurrence = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.dataset_id == "matrix_recurrence_builtin_sm_lc"
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 3
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+    equivalents = REPORT_CATALOG.equivalent_cells(selected_recurrence)
+
+    assert equivalents
+    assert all(
+        candidate.cell_id != selected_recurrence.cell_id for candidate in equivalents
+    )
+    assert all(
+        (
+            candidate.process,
+            candidate.n_final,
+            candidate.process_key,
+            candidate.measurement,
+            candidate.workload,
+        )
+        == (
+            selected_recurrence.process,
+            selected_recurrence.n_final,
+            selected_recurrence.process_key,
+            selected_recurrence.measurement,
+            selected_recurrence.workload,
+        )
+        for candidate in equivalents
+    )
+    assert {(candidate.dataset_id, candidate.variant) for candidate in equivalents} == {
+        ("z_builtin_sm", "recurrence_jit_o2")
+    }
+
+    same_process_cells = [
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.process == selected_recurrence.process
+        and cell.n_final == selected_recurrence.n_final
+        and cell.process_key == selected_recurrence.process_key
+    ]
+    assert not {
+        candidate.cell_id
+        for candidate in same_process_cells
+        if (
+            candidate.measurement.model is ModelKey.UFO_SM
+            or candidate.workload is Workload.ALL_FLOW
+            or candidate.measurement.backend != selected_recurrence.measurement.backend
+            or candidate.measurement.execution_mode
+            is not selected_recurrence.measurement.execution_mode
+        )
+    } & {candidate.cell_id for candidate in equivalents}
+
+
+def test_equivalent_cells_cover_matching_compiled_backend_but_never_amplicol() -> None:
+    compiled = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.dataset_id == "matrix_compiled_builtin_sm_lc"
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 2
+        and cell.workload is Workload.ALL_FLOW
+    )
+    equivalents = REPORT_CATALOG.equivalent_cells(compiled)
+
+    assert {(candidate.dataset_id, candidate.variant) for candidate in equivalents} == {
+        ("z_builtin_sm", "jit_o3")
+    }
+    assert all(candidate.measurement.backend == "jit" for candidate in equivalents)
+    assert all(
+        candidate.measurement.jit_optimization_level == 3 for candidate in equivalents
+    )
+
+    reference = next(
+        cell
+        for cell in REPORT_CATALOG.reference_cells()
+        if cell.process_key == "dd_z_jets"
+        and cell.n_final == 2
+        and cell.workload is Workload.ALL_FLOW
+    )
+    assert REPORT_CATALOG.equivalent_cells(reference) == ()
+
+
+def test_reset_caches_are_canonical_and_cover_every_measurement_cell() -> None:
+    caches = build_reset_caches()
+    cells_by_dataset: dict[str, list[object]] = {}
+    for cell in REPORT_CATALOG.measurement_cells():
+        cells_by_dataset.setdefault(cell.dataset_id, []).append(cell)
+
+    assert set(caches) == {f"{dataset_id}.json" for dataset_id in cells_by_dataset}
+    for name, payload in caches.items():
+        dataset_id = name.removesuffix(".json")
+        validate_cache(payload, expected_cells=cells_by_dataset[dataset_id])
+        assert all(
+            entry["measurement"] == empty_measurement() for entry in payload["entries"]
+        )
+
+
+def test_not_available_measurement_cannot_carry_stale_timing() -> None:
+    measurement = empty_measurement()
+    measurement["generation_seconds"] = 1.0
+
+    with pytest.raises(ValueError, match="canonical reset"):
+        validate_measurement(measurement)
+
+
+def test_successful_measurement_requires_successful_validation() -> None:
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": ResultStatus.OK.value,
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 8.0e-7,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "artifact": {},
+            "validation": {"status": ResultStatus.VALIDATION_FAILED.value},
+            "resources": {},
+            "provenance": {},
+        }
+    )
+
+    with pytest.raises(ValueError, match="validation status"):
+        validate_measurement(measurement)
+
+
+def _candidate_measurement_with_runtime_postflight() -> dict[str, object]:
+    observations = [
+        {
+            "module": "pyamplicol",
+            "kind": "package-member",
+            "root_index": 0,
+            "path": "__init__.py",
+            "size": 10,
+            "sha256": "1" * 64,
+        }
+    ]
+    policy = {
+        "kind": "pyamplicol-loaded-module-origin-policy-v1",
+        "all_loaded_origins_authenticated": True,
+        "native_image_origin_bound": True,
+        "loaded_bytecode_eligible": False,
+        "observed_module_count": len(observations),
+        "observations": observations,
+        "observations_sha256": digest_json(observations),
+    }
+    identity = {
+        "kind": "pyamplicol-report-runtime-identity-v1",
+        "loaded_module_origin_policy": policy,
+    }
+    stable_identity = deepcopy(identity)
+    stable_policy = stable_identity["loaded_module_origin_policy"]
+    assert isinstance(stable_policy, dict)
+    for field in (
+        "observed_module_count",
+        "observations",
+        "observations_sha256",
+    ):
+        stable_policy.pop(field)
+    stable_digest = digest_json(stable_identity)
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": ResultStatus.OK.value,
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 8.0e-7,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "artifact": {},
+            "validation": {
+                "status": ResultStatus.OK.value,
+                DIRECT_AGREEMENT_FIELD: [],
+            },
+            "resources": {},
+            "provenance": {
+                "runtime_identity": identity,
+                "runtime_identity_sha256": digest_json(identity),
+                "runtime_identity_stable_sha256": stable_digest,
+                "runtime_identity_postflight_stable_sha256": stable_digest,
+                "runtime_identity_postflight_loaded_module_origin_policy": deepcopy(
+                    policy
+                ),
+                "runtime_identity_postflight_match": True,
+            },
+        }
+    )
+    return measurement
+
+
+def _unverified_candidate_measurement(cell: CellSpec) -> dict[str, object]:
+    measurement = _candidate_measurement_with_runtime_postflight()
+    point_identity = "a" * 64
+    ordering = "b" * 64
+
+    def resolved_record(precision: int, source: str) -> dict[str, object]:
+        record = pointwise_validation(
+            1.0,
+            1.0,
+            candidate_scale=1.0,
+            baseline_scale=1.0,
+            comparison_binding={
+                "abi": "pyamplicol-report-resolved-component-scale-v1",
+                "point_digest": point_identity,
+                "helicity_ids": [],
+                "color_flow_ids": [],
+                "resolved_ordering_sha256": ordering,
+                "resolved_source_sha256": source,
+                "point_index": 0,
+            },
+        )
+        return {
+            "abi": "pyamplicol-report-resolved-sum-validation-v2",
+            "status": ResultStatus.OK.value,
+            "maximum_absolute_difference": 0.0,
+            "maximum_relative_difference": 0.0,
+            "maximum_conditioned_residual": 0.0,
+            "relative_tolerance": 1.0e-12,
+            "point_digest": point_identity,
+            "helicity_ids": [],
+            "color_flow_ids": [],
+            "resolved_ordering_sha256": ordering,
+            "resolved_source_sha256": source,
+            "scale_source": "resolved-component-l1",
+            "precision_digits": precision,
+            "points": [record],
+        }
+
+    binary64 = resolved_record(16, "c" * 64)
+    p32 = resolved_record(32, "d" * 64)
+    selector_identity = {
+        "cell_id": cell.cell_id,
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+        "selector_contract": None,
+        "value_kind": "matrix-element-p16-versus-p32",
+    }
+    high_precision = pointwise_validation(
+        1.0,
+        1.0,
+        candidate_scale=1.0,
+        baseline_scale=1.0,
+        candidate_scale_source="resolved-component-l1-binary64",
+        baseline_scale_source="resolved-component-l1-p32",
+        comparison_binding={
+            "point_digest": point_identity,
+            "selector_component_identity": selector_identity,
+            "selector_component_sha256": digest_json(selector_identity),
+            "candidate_source_sha256": "c" * 64,
+            "baseline_source_sha256": "d" * 64,
+        },
+    )
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+    validation.update(
+        {
+            "status": ResultStatus.UNVERIFIED.value,
+            "resolved_sum": binary64,
+            "high_precision_resolved_sum": p32,
+            "high_precision": high_precision,
+            "precision_diagnostic": {
+                "abi": ("pyamplicol-report-validation-failure-precision-diagnostic-v2"),
+                "status": "unavailable",
+                "promotes_measurement": False,
+                "error": {"kind": "FixtureUnavailable", "message": "fixture"},
+            },
+            INDEPENDENT_AUTHORITY_FIELD: {
+                "abi": INDEPENDENT_AUTHORITY_ABI,
+                "expected_cell_ids": [
+                    authority.cell_id
+                    for authority in independent_numerical_authorities(cell)
+                ],
+                "selected_cell_id": None,
+                "status": "unavailable",
+                "reason": "no-successful-independent-authority",
+                "same_artifact_diagnostics_are_authority": False,
+            },
+        }
+    )
+    measurement["status"] = ResultStatus.UNVERIFIED.value
+    measurement["failure"] = {
+        "kind": "IndependentAuthorityUnavailable",
+        "message": "no successful independent numerical authority is available",
+    }
+    return measurement
+
+
+def test_unverified_measurement_contract_is_strict_and_catalog_bound() -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n1-dd-z-jets-contracted"
+    )
+    measurement = _unverified_candidate_measurement(cell)
+    validate_measurement(measurement, expected_cell=cell)
+
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+    authority = validation[INDEPENDENT_AUTHORITY_FIELD]
+    assert isinstance(authority, dict)
+    canonical = list(authority["expected_cell_ids"])
+    malformed_chains = [
+        canonical[:-1],
+        [*canonical, "matrix-compiled-builtin-sm-full-n1-dd-z-jets-contracted"],
+    ]
+    if len(canonical) > 1:
+        malformed_chains.append(list(reversed(canonical)))
+    for malformed in malformed_chains:
+        tampered = deepcopy(measurement)
+        tampered["validation"][INDEPENDENT_AUTHORITY_FIELD][  # type: ignore[index]
+            "expected_cell_ids"
+        ] = malformed
+        with pytest.raises(ValueError, match="independent-authority"):
+            validate_measurement(tampered, expected_cell=cell)
+
+    tampered = deepcopy(measurement)
+    tampered["validation"]["precision_diagnostic"][  # type: ignore[index]
+        "promotes_measurement"
+    ] = True
+    with pytest.raises(ValueError, match="precision diagnostic"):
+        validate_measurement(tampered, expected_cell=cell)
+
+
+@pytest.mark.parametrize(
+    "cell_id",
+    (
+        "scalar-contact-n2-scalar-contact-contracted",
+        "scalar-gravity-n2-scalar-gravity-contracted",
+    ),
+)
+def test_standalone_scalar_cell_rejects_inapplicable_unverified_authority(
+    cell_id: str,
+) -> None:
+    cell = REPORT_CATALOG.cell(cell_id)
+    measurement = _unverified_candidate_measurement(cell)
+
+    with pytest.raises(ValueError, match="not applicable"):
+        validate_measurement(measurement, expected_cell=cell)
+
+
+@pytest.mark.parametrize(
+    "cell_id",
+    (
+        "scalar-contact-n2-scalar-contact-contracted",
+        "scalar-gravity-n2-scalar-gravity-contracted",
+    ),
+)
+def test_standalone_scalar_ok_requires_strict_internal_p32_contract(
+    cell_id: str,
+) -> None:
+    cell = REPORT_CATALOG.cell(cell_id)
+    measurement = _unverified_candidate_measurement(cell)
+    measurement["status"] = ResultStatus.OK.value
+    measurement["failure"] = None
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+    validation["status"] = ResultStatus.OK.value
+    validation.pop("precision_diagnostic")
+    validation.pop(INDEPENDENT_AUTHORITY_FIELD)
+
+    validate_measurement(measurement, expected_cell=cell)
+    validation.pop("high_precision")
+    with pytest.raises(ValueError, match="high_precision"):
+        validate_measurement(measurement, expected_cell=cell)
+
+
+def test_recurrence_ok_requires_p32_even_with_legacy_diagnostic_baseline() -> None:
+    cell = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-full-n1-dd-z-jets-contracted"
+    )
+    measurement = _unverified_candidate_measurement(cell)
+    measurement["status"] = ResultStatus.OK.value
+    measurement["failure"] = None
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+    validation["status"] = ResultStatus.OK.value
+    validation.pop("precision_diagnostic")
+    validation.pop(INDEPENDENT_AUTHORITY_FIELD)
+    validation["pointwise"] = deepcopy(validation["high_precision"])
+
+    validate_measurement(measurement, expected_cell=cell)
+    validation.pop("high_precision")
+    with pytest.raises(ValueError, match="high_precision"):
+        validate_measurement(measurement, expected_cell=cell)
+
+
+@pytest.mark.parametrize(
+    "mutation",
+    (
+        "point",
+        "ordering",
+        "binary-precision",
+        "matrix-value",
+        "p32-value",
+    ),
+)
+def test_standalone_scalar_ok_rejects_cross_record_p32_tampering(
+    mutation: str,
+) -> None:
+    cell = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    measurement = _unverified_candidate_measurement(cell)
+    measurement["status"] = ResultStatus.OK.value
+    measurement["failure"] = None
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+    validation["status"] = ResultStatus.OK.value
+    validation.pop("precision_diagnostic")
+    validation.pop(INDEPENDENT_AUTHORITY_FIELD)
+    resolved = validation["resolved_sum"]
+    high_resolved = validation["high_precision_resolved_sum"]
+    assert isinstance(resolved, dict)
+    assert isinstance(high_resolved, dict)
+    high_points = high_resolved["points"]
+    assert isinstance(high_points, list)
+    high_point = high_points[0]
+    assert isinstance(high_point, dict)
+    high_binding = high_point["comparison_binding"]
+    assert isinstance(high_binding, dict)
+
+    if mutation == "point":
+        high_resolved["point_digest"] = "e" * 64
+        high_binding["point_digest"] = "e" * 64
+    elif mutation == "ordering":
+        high_resolved["resolved_ordering_sha256"] = "e" * 64
+        high_binding["resolved_ordering_sha256"] = "e" * 64
+    elif mutation == "binary-precision":
+        resolved["precision_digits"] = 17
+    elif mutation == "matrix-value":
+        measurement["matrix_element"] = 2.0
+    else:
+        high_points[0] = pointwise_validation(
+            2.0,
+            2.0,
+            candidate_scale=2.0,
+            baseline_scale=2.0,
+            candidate_scale_source=str(high_point["candidate_scale_source"]),
+            baseline_scale_source=str(high_point["baseline_scale_source"]),
+            comparison_binding=high_binding,
+        )
+
+    with pytest.raises(ValueError, match="standalone"):
+        validate_measurement(measurement, expected_cell=cell)
+
+
+def test_unverified_presentation_overlay_is_attempt_bound_and_json_isolated(
+    tmp_path: Path,
+) -> None:
+    repo = tmp_path / "repo"
+    docs = repo / "docs" / "performance_reports" / "manual"
+    docs.mkdir(parents=True)
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo,
+            docs_dir=docs,
+            artifact_root=tmp_path / "campaign-artifacts",
+            coordination_root=tmp_path / "campaign-artifacts" / "coordination",
+        )
+    )
+    cell = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n1-dd-z-jets-contracted"
+    )
+    revision = "a" * 40
+    measurement = _unverified_candidate_measurement(cell)
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    provenance.update(
+        {
+            "report_source_revision": revision,
+            "manual_campaign": {
+                "cell_identity": {
+                    "cell_id": cell.cell_id,
+                    "dataset_id": cell.dataset_id,
+                    "process_key": cell.process_key,
+                    "process": cell.process,
+                    "n_final": cell.n_final,
+                    "workload": cell.workload.value,
+                    "execution_mode": cell.measurement.execution_mode.value,
+                    "model": cell.measurement.model.value,
+                    "accuracy": cell.measurement.accuracy.value,
+                    "backend": cell.measurement.backend,
+                    "variant": cell.variant,
+                }
+            },
+        }
+    )
+    validate_measurement(measurement, expected_cell=cell)
+
+    attempt = service.store.new_attempt(cell.cell_id, ArtifactPolicy.REGENERATE)
+    attempt.write_json("worker-result.json", measurement)
+    attempt.mark_failed(
+        "independent authority unavailable",
+        artifact_paths=("worker-result.json",),
+    )
+    outcome = manual_campaign.LightweightPresentationOutcome(
+        profile="campaign-local-v1",
+        cell_id=cell.cell_id,
+        source_revision=revision,
+        campaign_invocation_id="fixture",
+        attempt_id=attempt.attempt_id,
+        status=ResultStatus.UNVERIFIED.value,
+        label="unverified",
+        completed_at_ns=1,
+    )
+
+    publication_caches, publication_merged = (
+        manual_campaign._merge_lightweight_snapshot(service, {})
+    )
+    render_caches, render_merged = manual_campaign._merge_lightweight_snapshot(
+        service,
+        {},
+        {cell.cell_id: outcome},
+    )
+    assert publication_merged == 0
+    assert render_merged == 1
+
+    def cell_measurement(
+        caches: dict[str, dict[str, object]],
+    ) -> dict[str, object]:
+        payload = caches[f"{cell.dataset_id}.json"]
+        entries = payload["entries"]
+        assert isinstance(entries, list)
+        entry = next(
+            item
+            for item in entries
+            if isinstance(item, dict) and item.get("cell_id") == cell.cell_id
+        )
+        value = entry["measurement"]
+        assert isinstance(value, dict)
+        return value
+
+    assert cell_measurement(render_caches)["status"] == ResultStatus.UNVERIFIED.value
+    assert cell_measurement(render_caches)["generation_seconds"] == 1.0
+    assert cell_measurement(publication_caches)["status"] == (
+        ResultStatus.NOT_AVAILABLE.value
+    )
+
+    tables = service._render_tables(render_caches)
+    assert (
+        "unverified"
+        in tables["result_matrix_compiled_builtin_sm_full_table.tex"].lower()
+    )
+    service._snapshot_files(publication_caches, tables)
+    installed_payloads = tuple(
+        path
+        for path in service.paths.results_dir.glob("*.json")
+        if path.name != "report-cache.schema.json"
+    )
+    assert installed_payloads
+    assert all(
+        '"status":"unverified"'
+        not in json.dumps(
+            json.loads(path.read_text(encoding="ascii")),
+            separators=(",", ":"),
+        )
+        for path in installed_payloads
+    )
+
+    wrong_source = replace(outcome, source_revision="b" * 40)
+    wrong_attempt = replace(
+        outcome,
+        attempt_id="00000000-0000-4000-8000-000000000000",
+    )
+    wrong_identity_measurement = deepcopy(measurement)
+    wrong_identity_provenance = wrong_identity_measurement["provenance"]
+    assert isinstance(wrong_identity_provenance, dict)
+    wrong_identity_manual = wrong_identity_provenance["manual_campaign"]
+    assert isinstance(wrong_identity_manual, dict)
+    wrong_identity = wrong_identity_manual["cell_identity"]
+    assert isinstance(wrong_identity, dict)
+    wrong_identity["cell_id"] = "different-cell"
+    wrong_identity_attempt = service.store.new_attempt(
+        cell.cell_id,
+        ArtifactPolicy.REGENERATE,
+    )
+    wrong_identity_attempt.write_json(
+        "worker-result.json",
+        wrong_identity_measurement,
+    )
+    wrong_identity_attempt.mark_failed(
+        "independent authority unavailable",
+        artifact_paths=("worker-result.json",),
+    )
+    wrong_cell = replace(outcome, attempt_id=wrong_identity_attempt.attempt_id)
+    for malformed in (wrong_source, wrong_attempt, wrong_cell):
+        fallback = manual_campaign._presentation_measurement(
+            service,
+            cell,
+            malformed,
+        )
+        validate_measurement(fallback, expected_cell=cell)
+        assert fallback["status"] == ResultStatus.FAILED.value
+        assert fallback["generation_seconds"] is None
+        failure = fallback["failure"]
+        assert isinstance(failure, dict)
+        assert failure["kind"] == "ManualCampaignOutcome:unverified"
+
+
+def test_unverified_measurement_requires_every_hard_direct_agreement() -> None:
+    cell = REPORT_CATALOG.cell("matrix-compiled-builtin-sm-lc-n1-dd-z-jets-all-flow")
+    required = next(edge for edge in incoming_agreement_edges(cell) if edge.required)
+    legacy = next(
+        edge
+        for edge in incoming_agreement_edges(cell)
+        if edge.kind == LC_LEGACY_PYAMPLICOL_COMPONENT
+    )
+    with pytest.raises(ValueError, match="coverage is incomplete"):
+        _validate_unverified_direct_agreement_coverage(
+            {DIRECT_AGREEMENT_FIELD: []},
+            expected_cell=cell,
+            catalog=REPORT_CATALOG,
+        )
+    _validate_unverified_direct_agreement_coverage(
+        {
+            DIRECT_AGREEMENT_FIELD: [
+                {
+                    "edge_kind": required.kind,
+                    "baseline_cell_id": required.baseline.cell_id,
+                    "candidate_cell_id": cell.cell_id,
+                    "status": ResultStatus.OK.value,
+                },
+                {
+                    "edge_kind": legacy.kind,
+                    "baseline_cell_id": legacy.baseline.cell_id,
+                    "candidate_cell_id": cell.cell_id,
+                    "status": ResultStatus.VALIDATION_FAILED.value,
+                },
+            ]
+        },
+        expected_cell=cell,
+        catalog=REPORT_CATALOG,
+    )
+
+
+def _arena_unavailable_candidate_measurement() -> dict[str, object]:
+    measurement = _candidate_measurement_with_runtime_postflight()
+    measurement["execution_seconds_per_point"] = None
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    provenance["source_revision"] = "a" * 40
+    raw_profile = {
+        "execution_mode": "compiled",
+        "profile_boundary": ARENA_PROFILE_BOUNDARY,
+        "borrowed_flat_input": True,
+        "preallocated_output": True,
+        "phase_timing_scope": ARENA_PHASE_TIMING_SCOPE,
+        "evaluator_timing_available": False,
+        "points": 128,
+        "wall_time_s": 128 * 1.1e-6,
+        "orchestration_time_s": 128 * 1.1e-6,
+        **{field: 0 for field in ZERO_ARENA_COUNTER_FIELDS},
+        **{field: 0.0 for field in ZERO_ARENA_PHASE_TIME_FIELDS},
+        **{field: [] for field in EMPTY_ARENA_PHASE_VECTOR_FIELDS},
+        **{field: 0 for field in ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS},
+        "compiled_direct_arena_engine_count": 1,
+        "compiled_direct_arena_call_count": 128,
+        "evaluator_backend_call_count": 128,
+    }
+    arena_evidence = build_arena_profile_evidence(
+        [raw_profile] * 5,
+        execution_mode="compiled",
+        repetitions_per_profile=1,
+        batch_size=128,
+    )
+    provenance["arena_profile_evidence"] = arena_evidence
+    provenance["execution_timing"] = {
+        "abi": "pyamplicol-report-arena-execution-timing-v2",
+        "status": "unavailable",
+        "ratio_eligible": False,
+        "raw_seconds_per_point": None,
+        "sample_count": 5,
+        "native_profile_points_per_sample": 128,
+        "repetitions_per_sample": 1,
+        "batch_size": 128,
+        "sample_contract": ("paired_unprofiled_headline_profiled_attribution_v1"),
+        "profile_protocol": "arena",
+        "profile_sample_pass": "runtime._profile_arena_repeated",
+        "profile_boundary": (
+            "warmed-direct-arena-borrowed-input-preallocated-output-v1"
+        ),
+        "borrowed_flat_input": True,
+        "preallocated_output": True,
+        "phase_timing_scope": "coarse-arena-boundary-only-v1",
+        "evaluator_timing_available": False,
+        "paired_with_headline": True,
+        "identical_batch": True,
+        "identical_repetitions": True,
+        "execution_mode": "compiled",
+        "warmed_boundary_wall_seconds_per_point": 1.1e-6,
+        "arena_profile_evidence_sha256": digest_arena_profile_value(arena_evidence),
+    }
+    return measurement
+
+
+def test_candidate_null_execution_requires_authenticated_arena_provenance() -> None:
+    measurement = _arena_unavailable_candidate_measurement()
+    validate_measurement(measurement)
+
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    provenance.pop("execution_timing")
+    with pytest.raises(ValueError, match="authenticated Arena provenance"):
+        validate_measurement(measurement)
+
+
+def test_future_evaluator_total_provenance_is_optional_and_fail_closed() -> None:
+    measurement = _arena_unavailable_candidate_measurement()
+    validate_measurement(measurement)
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    provenance["evaluator_total_timing"] = {
+        "abi": "pyamplicol-report-evaluator-total-timing-v1",
+        "status": "measured",
+        "ratio_eligible": False,
+        "raw_seconds_per_point": 1.0e-6,
+        "source": "runtime._benchmark_f64_wall_time.accumulated",
+        "execution_mode": "compiled",
+        "sample_contract": ("accumulated-repeated-warmed-evaluator-total-v1"),
+        "sample_count": 5,
+        "repetitions_per_sample": 1,
+        "batch_size": 128,
+        "points_per_sample": 128,
+        "measured_point_count": 640,
+        "accumulated_seconds": 6.4e-4,
+    }
+    validate_measurement(measurement)
+
+    total = provenance["evaluator_total_timing"]
+    assert isinstance(total, dict)
+    total["accumulated_seconds"] = 1.0
+    with pytest.raises(ValueError, match="evaluator_total_timing"):
+        validate_measurement(measurement)
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("ratio_eligible", True),
+        ("raw_seconds_per_point", 0.0),
+        ("profile_protocol", "frozen-pre-arena"),
+        ("profile_sample_pass", "runtime.profile_repeated"),
+        ("borrowed_flat_input", False),
+        ("evaluator_timing_available", True),
+        ("native_profile_points_per_sample", None),
+        ("warmed_boundary_wall_seconds_per_point", 0.0),
+    ),
+)
+def test_arena_unavailable_execution_provenance_is_fail_closed(
+    field: str,
+    value: object,
+) -> None:
+    measurement = _arena_unavailable_candidate_measurement()
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    timing = provenance["execution_timing"]
+    assert isinstance(timing, dict)
+    timing[field] = value
+
+    with pytest.raises(ValueError, match="unavailable-attribution record"):
+        validate_measurement(measurement)
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "match"),
+    [
+        (
+            "runtime_identity",
+            None,
+            "requires runtime_identity",
+        ),
+        (
+            "runtime_identity_stable_sha256",
+            "0" * 64,
+            "runtime_identity_stable_sha256",
+        ),
+        (
+            "runtime_identity_postflight_stable_sha256",
+            "0" * 64,
+            "postflight stable SHA-256",
+        ),
+        (
+            "runtime_identity_postflight_loaded_module_origin_policy",
+            {},
+            "loaded-origin evidence",
+        ),
+        (
+            "runtime_identity_postflight_match",
+            False,
+            "runtime_identity_postflight_match",
+        ),
+    ],
+)
+def test_successful_candidate_measurement_requires_runtime_postflight(
+    field: str,
+    value: object,
+    match: str,
+) -> None:
+    measurement = _candidate_measurement_with_runtime_postflight()
+    validate_measurement(measurement)
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    provenance[field] = value
+    with pytest.raises(ValueError, match=match):
+        validate_measurement(measurement)
+
+
+def test_candidate_runtime_postflight_cannot_lose_initial_origin() -> None:
+    measurement = _candidate_measurement_with_runtime_postflight()
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    postflight = provenance["runtime_identity_postflight_loaded_module_origin_policy"]
+    assert isinstance(postflight, dict)
+    observations = postflight["observations"]
+    assert isinstance(observations, list)
+    observations[0] = {
+        "module": "pyamplicol.replaced",
+        "kind": "package-member",
+        "root_index": 0,
+        "path": "replaced.py",
+        "size": 10,
+        "sha256": "2" * 64,
+    }
+    postflight["observations_sha256"] = digest_json(observations)
+    with pytest.raises(ValueError, match="lost a loaded-module origin"):
+        validate_measurement(measurement)
diff --git a/pyamplicol/tests/unit/test_three_mode_report_legacy.py b/pyamplicol/tests/unit/test_three_mode_report_legacy.py
new file mode 100644
index 0000000000..a4233c31f1
--- /dev/null
+++ b/pyamplicol/tests/unit/test_three_mode_report_legacy.py
@@ -0,0 +1,2141 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tools.performance_report.cache import validate_measurement
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.legacy import (
+    LEGACY_IMODE2_DIAGNOSTIC_ABI,
+    LEGACY_IMODE2_DIAGNOSTIC_FIELD,
+    LEGACY_NUMERICAL_AUTHORITY_ABI,
+    LEGACY_NUMERICAL_AUTHORITY_FIELD,
+    CommandResult,
+    LegacyAdapterError,
+    LegacyMeasurementAdapter,
+    LegacySettings,
+    MaintainedLegacyApi,
+    TimingRow,
+    _canonical_mapped_color_word,
+    _canonical_process_entry,
+    _fixed_helicity,
+    _generation_lepton_pt_cut,
+    _helicity_id,
+    _parse_generated_library_color_probe_output,
+    adaptive_profile_points,
+)
+from tools.performance_report.models import Accuracy, ExecutionMode, Workload
+from tools.performance_report.runner import (
+    ProfilingTimeLimitError,
+    RunnerError,
+    SelectorContract,
+    point_digest,
+    validate_selector_contract,
+)
+
+
+@dataclass(frozen=True)
+class FakeEntry:
+    group: int = 1
+    integral: int = 2
+    process_pdgs: tuple[int, ...] = (1, -1, 23, 21)
+    color_order: tuple[int, ...] = (2, 4, 1, 3)
+
+
+class FakeApi:
+    default_repository = Path("/fake/legacy")
+
+    def __init__(self, pdgs: tuple[int, ...] = (1, -1, 23, 21)) -> None:
+        self.pdgs = pdgs
+        self.entry = FakeEntry(
+            process_pdgs=pdgs,
+            color_order=(
+                # Three open strings with any adjoints attached to the final
+                # string: [fundamental, adjoints..., antifundamental].
+                (2, 1, 3, 4, 5, *range(7, len(pdgs) + 1), 6)
+                if len(pdgs) >= 6
+                else (2, 4, 1, 3)
+            ),
+        )
+        self.selected_calls: list[tuple[int, tuple[int, ...]]] = []
+        self.color_calls: list[tuple[str, tuple[int, ...] | None]] = []
+        self.lc_probe_result: object | None = None
+        self.generated_library_probe_value = 9.75
+        self.direct_color_probe_value = 9.75
+        self.selected_flow_value = 3.25
+        self.selected_flow_fixed_helicity_value = 2.5
+        self.parsed_probe_count = 0
+
+    def expected_revision(self) -> str:
+        return "a" * 40
+
+    def validate_checkout(self, repository: Path) -> None:
+        pass
+
+    def compiler_provenance(self, repository: Path) -> object:
+        return {"identity": "gfortran", "version": "test"}
+
+    def process_pdgs(self, process: str) -> tuple[int, ...]:
+        return self.pdgs
+
+    def parse_process_file(self, path: Path) -> tuple[object, ...]:
+        return (self.entry,)
+
+    def select_generated_process_entry(
+        self,
+        entries: tuple[object, ...],
+        *,
+        generated_process: str,
+        wanted_pdgs: tuple[int, ...],
+    ) -> tuple[object, tuple[object, ...]]:
+        assert wanted_pdgs == self.pdgs
+        return entries[0], entries
+
+    def source_mapped_color_order(
+        self,
+        entry: object,
+        *,
+        source_pdgs: tuple[int, ...],
+    ) -> tuple[int, ...]:
+        return self.entry.color_order
+
+    def ordered_momenta(
+        self,
+        source_pdgs: tuple[int, ...],
+        target_pdgs: tuple[int, ...],
+        momenta: tuple[tuple[float, ...], ...],
+    ) -> tuple[tuple[float, ...], ...]:
+        return momenta
+
+    def source_to_row_permutation(
+        self,
+        source_pdgs: tuple[int, ...],
+        target_pdgs: tuple[int, ...],
+    ) -> tuple[int, ...]:
+        return tuple(range(len(source_pdgs)))
+
+    def parse_probe_output(self, output: str) -> object:
+        self.parsed_probe_count += 1
+        marker = "FAKE_PROBE_VALUE "
+        values = [
+            float(line.removeprefix(marker))
+            for line in output.splitlines()
+            if line.startswith(marker)
+        ]
+        assert len(values) == 1
+        return SimpleNamespace(value=values[0])
+
+    def run_selected_flow_probe(self, repository: Path, **kwargs: object) -> object:
+        self.selected_calls.append((int(kwargs["points"]), tuple(kwargs["helicities"])))
+        return SimpleNamespace(
+            value=self.selected_flow_value,
+            fixed_helicity_value=self.selected_flow_fixed_helicity_value,
+        )
+
+    def run_color_probe(self, repository: Path, **kwargs: object) -> object:
+        accuracy = str(kwargs["color_accuracy"])
+        helicities = kwargs["helicities"]
+        self.color_calls.append(
+            (accuracy, None if helicities is None else tuple(helicities))
+        )
+        if accuracy == Accuracy.LC.value and self.lc_probe_result is not None:
+            return self.lc_probe_result
+        aggregate = (
+            2.5
+            if accuracy == Accuracy.LC.value
+            else self.direct_color_probe_value
+        )
+        return SimpleNamespace(
+            value=aggregate,
+            lc_row_partitions=(
+                SimpleNamespace(row=1, value=2.5, permutation=(2, 4, 1)),
+            ),
+            lc_partition_sum=2.5,
+        )
+
+
+class EntryMappedFakeApi(FakeApi):
+    """Expose distinct generated entries so selector tests cannot use a stub row."""
+
+    def __init__(
+        self,
+        pdgs: tuple[int, ...],
+        entries: tuple[FakeEntry, ...],
+        *,
+        selected_entry: FakeEntry,
+    ) -> None:
+        super().__init__(pdgs)
+        self.entries = entries
+        self.selected_entry = selected_entry
+        self.mapped_entries: list[FakeEntry] = []
+        self.probed_entries: list[FakeEntry] = []
+
+    def parse_process_file(self, path: Path) -> tuple[object, ...]:
+        return self.entries
+
+    def select_generated_process_entry(
+        self,
+        entries: tuple[object, ...],
+        *,
+        generated_process: str,
+        wanted_pdgs: tuple[int, ...],
+    ) -> tuple[object, tuple[object, ...]]:
+        assert entries == self.entries
+        assert wanted_pdgs == self.pdgs
+        return self.selected_entry, self.entries
+
+    def source_mapped_color_order(
+        self,
+        entry: object,
+        *,
+        source_pdgs: tuple[int, ...],
+    ) -> tuple[int, ...]:
+        assert source_pdgs == self.pdgs
+        assert isinstance(entry, FakeEntry)
+        self.mapped_entries.append(entry)
+        return entry.color_order
+
+    def run_color_probe(self, repository: Path, **kwargs: object) -> object:
+        entry = kwargs["entry"]
+        assert isinstance(entry, FakeEntry)
+        self.probed_entries.append(entry)
+        return super().run_color_probe(repository, **kwargs)
+
+
+class FakeExecutor:
+    def __init__(
+        self,
+        api: FakeApi,
+        phase_reporter: FakePhaseReporter | None = None,
+    ) -> None:
+        self.api = api
+        self.commands: list[tuple[str, ...]] = []
+        self.command_generation_phase: list[bool] = []
+        self.profile_calls = 0
+        self.phase_reporter = phase_reporter
+
+    def run(
+        self,
+        args: object,
+        *,
+        cwd: Path,
+        environment: object = None,
+    ) -> CommandResult:
+        rendered = tuple(str(item) for item in args)
+        self.commands.append(rendered)
+        self.command_generation_phase.append(
+            bool(
+                self.phase_reporter is not None
+                and self.phase_reporter.active
+            )
+        )
+        if any(item.endswith("process_list.py") for item in rendered):
+            cwd.mkdir(parents=True, exist_ok=True)
+            (cwd / "processes.txt").write_text("fake\n", encoding="utf-8")
+        points = 1
+        is_profile = bool(
+            rendered
+            and (
+                rendered[0]
+                in {
+                    "./amplicol_library_benchmark",
+                    "./amplicol_color_library_probe",
+                }
+                or rendered[0].endswith("amplicol_color_probe")
+            )
+        )
+        if is_profile:
+            points = int(rendered[1])
+            rate_factors = (
+                1.0,
+                0.99999,
+                1.00001,
+                1.0,
+                1.000005,
+                0.999995,
+            )
+            if self.phase_reporter is not None and self.phase_reporter.active:
+                # A dedicated generation-only probe must not consume a sample
+                # from the subsequent adaptive runtime profile.
+                factor = 1.0
+            else:
+                factor = rate_factors[self.profile_calls % len(rate_factors)]
+                self.profile_calls += 1
+        else:
+            factor = 1.0
+        evaluation = points * 0.001 * factor
+        output = (
+            "Timing summary\n"
+            "generation setup 2.5\n"
+            f"amplitude evaluation {evaluation}\n"
+            f"total {evaluation * 1.1}\n"
+            "FAKE_PROBE_VALUE "
+            + (
+                f"{self.api.generated_library_probe_value}\n"
+                if rendered and rendered[0] == "./amplicol_color_library_probe"
+                else "12.5\n"
+            )
+        )
+        if rendered and rendered[0] == "./amplicol_color_library_probe":
+            accuracy = rendered[4]
+            value = self.api.generated_library_probe_value
+            output += (
+                f"AMPICOL_COLOR_PROBE_COMPONENTS {value} {value} {value}\n"
+                f"AMPICOL_COLOR_PROBE_VALUE {accuracy} {rendered[2]} "
+                f"{rendered[3]} {value}\n"
+            )
+        elapsed = 0.25 if rendered and rendered[0] != "make" else 0.1
+        return CommandResult(
+            args=rendered,
+            cwd=cwd,
+            elapsed_seconds=elapsed,
+            returncode=0,
+            stdout=output,
+            stderr="",
+            environment={} if environment is None else dict(environment),
+        )
+
+
+class FakeSnapshotter:
+    def snapshot(
+        self,
+        repository: Path,
+        destination: Path,
+        *,
+        executables: tuple[str, ...],
+        process_file: Path,
+    ) -> Path:
+        destination.mkdir(parents=True, exist_ok=True)
+        (destination / "Library").mkdir(exist_ok=True)
+        (destination / "processes.txt").write_text("fake\n", encoding="utf-8")
+        for executable in executables:
+            (destination / executable).touch()
+            (destination / executable).chmod(0o755)
+        return destination
+
+
+class FakePhaseReporter:
+    def __init__(self) -> None:
+        self.active = False
+        self.interval_count = 0
+        self.phase = "pre-generation"
+        self.transitions: list[str] = []
+
+    @contextmanager
+    def generation(self):
+        assert not self.active
+        assert self.phase == "pre-generation"
+        self.interval_count += 1
+        self.active = True
+        self.phase = "generation"
+        try:
+            yield
+        finally:
+            self.active = False
+            self.phase = "post-generation"
+
+    def profiling_started(self) -> None:
+        assert self.phase == "post-generation"
+        self.phase = "profiling"
+        self.transitions.append(self.phase)
+
+    def validation_started(self) -> None:
+        assert self.phase == "profiling"
+        self.phase = "validation"
+        self.transitions.append(self.phase)
+
+    def complete(self) -> None:
+        assert self.phase == "validation"
+        self.phase = "complete"
+        self.transitions.append(self.phase)
+
+
+def _cell(
+    accuracy: Accuracy,
+    workload: Workload,
+    *,
+    process_key: str = "dd_z_jets",
+    n_final: int | None = None,
+):
+    return next(
+        cell
+        for cell in REPORT_CATALOG.reference_cells()
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        and cell.measurement.accuracy is accuracy
+        and cell.workload is workload
+        and cell.process_key == process_key
+        and cell.n_final
+        == (
+            n_final
+            if n_final is not None
+            else 1
+            if process_key == "dd_z_jets"
+            else cell.n_final
+        )
+    )
+
+
+def _adapter(
+    api: FakeApi | None = None,
+    *,
+    phase_reporter: FakePhaseReporter | None = None,
+):
+    fake_api = FakeApi() if api is None else api
+    executor = FakeExecutor(fake_api, phase_reporter)
+    return (
+        LegacyMeasurementAdapter(
+            api=fake_api,
+            executor=executor,
+            snapshotter=FakeSnapshotter(),
+        ),
+        fake_api,
+        executor,
+    )
+
+
+def _settings(repository: Path) -> LegacySettings:
+    return LegacySettings(
+        target_runtime_seconds=1.0,
+        warmup_points=100,
+        minimum_points=100,
+        maximum_points=10_000,
+        repository=repository,
+    )
+
+
+def test_canonical_process_entry_retains_preferred_duplicate_word() -> None:
+    pdgs = (1, -1, 11, -11)
+    first = FakeEntry(group=1, integral=1, process_pdgs=pdgs, color_order=(2, 1, 3, 4))
+    preferred = FakeEntry(
+        group=2,
+        integral=1,
+        process_pdgs=pdgs,
+        color_order=(2, 1, 4, 3),
+    )
+    api = EntryMappedFakeApi(pdgs, (first, preferred), selected_entry=preferred)
+
+    entry, _mapped, word = _canonical_process_entry(
+        api,
+        (first, preferred),
+        preferred_entry=preferred,
+        source_pdgs=pdgs,
+        initial_state_count=2,
+    )
+
+    assert entry is preferred
+    assert word == (2, 1)
+
+
+@pytest.mark.parametrize(
+    "pdgs",
+    (
+        (1, -1, 2, -2, 3, -3, 21),
+        (1, -1, 2, -2, 2, -2, 21),
+    ),
+)
+def test_real_three_line_process_file_keeps_exact_source_carrier(
+    pdgs: tuple[int, ...],
+    tmp_path: Path,
+) -> None:
+    process_file = tmp_path / "processes.txt"
+    pdg_row = " ".join(str(pdg) for pdg in pdgs)
+    process_file.write_text(
+        "\n".join(
+            (
+                "7 1",
+                pdg_row,
+                "2",
+                "4 1 1 1 3 4 5 6 2 7",
+                f"1 4 {pdg_row} 2 7 1 3 4 5 6 0.5",
+                "5 1 1 1 3 4 5 6 7 2",
+                f"1 5 {pdg_row} 2 1 3 4 5 7 6 0.5",
+                "",
+            )
+        ),
+        encoding="utf-8",
+    )
+    api = MaintainedLegacyApi()
+    entries = api.parse_process_file(process_file)
+    preferred, matches = api.select_generated_process_entry(
+        entries,
+        generated_process="d d~ > three open lines plus g",
+        wanted_pdgs=pdgs,
+    )
+
+    entry, mapped, word = _canonical_process_entry(
+        api,
+        matches,
+        preferred_entry=preferred,
+        source_pdgs=pdgs,
+        initial_state_count=2,
+    )
+
+    assert int(entry.group) == 4
+    assert mapped == (2, 7, 1, 3, 4, 5, 6)
+    assert word == (2, 7, 1, 3, 4, 5, 6)
+
+
+def test_real_two_line_process_file_keeps_cross_paired_source_carrier(
+    tmp_path: Path,
+) -> None:
+    process_file = tmp_path / "processes.txt"
+    process_file.write_text(
+        """6 4
+1 6 -1 -6 21 21
+1 6 -6 -1 21 21
+6 1 -1 -6 21 21
+6 1 -6 -1 21 21
+
+
+2
+
+1   1   1   1 2 3 4 6 5
+1   1   1 -1 21 21 6 -6   5 1 2 3 4 6   2.0
+
+
+
+2   1   1   1 2 3 6 5 4
+1   2   1 -1 21 21 6 -6   5 4 1 2 3 6   2.0
+""",
+        encoding="utf-8",
+    )
+    pdgs = (1, -1, 6, -6, 21, 21)
+    api = MaintainedLegacyApi()
+    entries = api.parse_process_file(process_file)
+    preferred, matches = api.select_generated_process_entry(
+        entries,
+        generated_process="d d~ > t t~ g g",
+        wanted_pdgs=pdgs,
+    )
+
+    entry, mapped, word = _canonical_process_entry(
+        api,
+        matches,
+        preferred_entry=preferred,
+        source_pdgs=pdgs,
+        initial_state_count=2,
+    )
+
+    assert int(entry.group) == 1
+    assert mapped == (3, 1, 2, 5, 6, 4)
+    assert word == (2, 5, 6, 4, 3, 1)
+
+
+@pytest.mark.parametrize(
+    ("n_final", "pdgs", "selected_word", "other_word", "reverse_entries"),
+    (
+        (
+            4,
+            (1, -1, 2, -2, 2, -2),
+            (2, 1, 3, 4, 5, 6),
+            (2, 4, 3, 1, 5, 6),
+            False,
+        ),
+        (
+            4,
+            (1, -1, 2, -2, 2, -2),
+            (2, 1, 3, 4, 5, 6),
+            (2, 4, 3, 1, 5, 6),
+            True,
+        ),
+        (
+            5,
+            (1, -1, 2, -2, 2, -2, 21),
+            (2, 7, 1, 3, 4, 5, 6),
+            (2, 1, 3, 4, 5, 7, 6),
+            False,
+        ),
+        (
+            5,
+            (1, -1, 2, -2, 2, -2, 21),
+            (2, 7, 1, 3, 4, 5, 6),
+            (2, 1, 3, 4, 5, 7, 6),
+            True,
+        ),
+    ),
+)
+def test_identical_three_line_lc_uses_selected_entry_mapped_row(
+    n_final: int,
+    pdgs: tuple[int, ...],
+    selected_word: tuple[int, ...],
+    other_word: tuple[int, ...],
+    reverse_entries: bool,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    selected_entry = FakeEntry(group=2, process_pdgs=pdgs, color_order=selected_word)
+    other_entry = FakeEntry(group=1, process_pdgs=pdgs, color_order=other_word)
+    entries = (
+        (selected_entry, other_entry)
+        if reverse_entries
+        else (other_entry, selected_entry)
+    )
+    # The exact-source process-file row is the generated-library carrier.
+    # Reordering the surrounding candidate rows must not replace it.
+    api = EntryMappedFakeApi(pdgs, entries, selected_entry=selected_entry)
+    api.lc_probe_result = SimpleNamespace(
+        value=4.0,
+        lc_row_partitions=(
+            SimpleNamespace(row=1, value=1.5, permutation=other_word),
+            SimpleNamespace(row=2, value=2.5, permutation=selected_word),
+        ),
+        lc_partition_sum=4.0,
+    )
+    adapter, _api, _executor = _adapter(api)
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in pdgs),),
+        ),
+    )
+
+    measurement = adapter.measure(
+        _cell(
+            Accuracy.LC,
+            Workload.ALL_FLOW,
+            process_key="dd_3q_identical_lines",
+            n_final=n_final,
+        ),
+        artifact_path=tmp_path / f"identical-n{n_final}",
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    contract = SelectorContract.from_mapping(measurement["selector_contract"])
+    assert api.mapped_entries == [selected_entry]
+    assert api.probed_entries == [selected_entry]
+    assert contract.selected_color_flow_ids == (
+        "flow:" + ",".join(str(label) for label in selected_word),
+    )
+    assert contract.selected_color_words == (selected_word,)
+    assert measurement["validation"]["lc_common_component"]["value"] == 2.5
+
+
+@pytest.mark.parametrize(
+    (
+        "n_final",
+        "pdgs",
+        "selected_word",
+        "same_canonical_word",
+        "other_word",
+    ),
+    (
+        (
+            4,
+            (1, -1, 2, -2, 2, -2),
+            (2, 1, 3, 4, 5, 6),
+            (3, 4, 2, 1, 5, 6),
+            (2, 4, 3, 1, 5, 6),
+        ),
+        (
+            5,
+            (1, -1, 2, -2, 2, -2, 21),
+            (2, 7, 1, 3, 4, 5, 6),
+            (3, 4, 2, 7, 1, 5, 6),
+            (2, 1, 3, 4, 5, 7, 6),
+        ),
+    ),
+)
+def test_identical_three_line_lc_rejects_duplicate_canonical_probe_rows(
+    n_final: int,
+    pdgs: tuple[int, ...],
+    selected_word: tuple[int, ...],
+    same_canonical_word: tuple[int, ...],
+    other_word: tuple[int, ...],
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    selected_entry = FakeEntry(
+        group=2,
+        process_pdgs=pdgs,
+        color_order=selected_word,
+    )
+    api = EntryMappedFakeApi(
+        pdgs,
+        (
+            FakeEntry(group=1, process_pdgs=pdgs, color_order=other_word),
+            selected_entry,
+        ),
+        selected_entry=selected_entry,
+    )
+    api.lc_probe_result = SimpleNamespace(
+        value=3.0,
+        lc_row_partitions=(
+            SimpleNamespace(row=1, value=1.0, permutation=selected_word),
+            SimpleNamespace(row=2, value=2.0, permutation=same_canonical_word),
+        ),
+        lc_partition_sum=3.0,
+    )
+    adapter, _api, _executor = _adapter(api)
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in pdgs),),
+        ),
+    )
+
+    with pytest.raises(
+        LegacyAdapterError,
+        match="did not identify exactly one selected physical row",
+    ):
+        adapter.measure(
+            _cell(
+                Accuracy.LC,
+                Workload.ALL_FLOW,
+                process_key="dd_3q_identical_lines",
+                n_final=n_final,
+            ),
+            artifact_path=tmp_path / f"identical-duplicate-n{n_final}",
+            settings=_settings(tmp_path / "repository"),
+        )
+
+
+def test_generated_library_color_probe_parser_accepts_real_counterless_stdout() -> None:
+    stdout = "\n".join(
+        (
+            " Initialising amplitude for:",
+            "    - a single polarisation/helicity configuration",
+            "    - all colour orders",
+            "AmpliCol generated-library colour probe",
+            "points 100",
+            "group 1",
+            "integral 1",
+            "color_accuracy full",
+            "color_orders 2",
+            (
+                "AMPICOL_COLOR_PROBE_COMPONENTS   4.7180245588895062E-04"
+                "   3.6371847402940423E-04   3.6371847402940423E-04"
+            ),
+            (
+                "AMPICOL_COLOR_PROBE_RAW_COMPONENTS   8.1453155359829235E-02"
+                "   6.2793266551648116E-02   6.2793266551648116E-02"
+            ),
+            "AMPICOL_COLOR_PROBE_VALUE full 1 1   3.6371847402940423E-04",
+            "------------------------------------------------------------------------------",
+            "Timing summary                           seconds    percent  note",
+            "------------------------------------------------------------------------------",
+            (
+                "amplitude evaluation                    0.000056     56.57%  "
+                "outer-loop-diagnostic"
+            ),
+            (
+                "colour contraction                      0.000031     31.31%  "
+                "outer-loop-diagnostic"
+            ),
+            "total                                   0.000099    100.00%  ",
+            "------------------------------------------------------------------------------",
+        )
+    )
+
+    value = _parse_generated_library_color_probe_output(
+        stdout,
+        expected_accuracy="full",
+        expected_group=1,
+        expected_integral=1,
+    )
+
+    assert "AMPICOL_COLOR_PROBE_CURRENTS" not in stdout
+    assert value == 3.6371847402940423e-4
+
+
+@pytest.mark.parametrize(
+    "workload",
+    (Workload.SELECTED_FLOW, Workload.ALL_FLOW),
+)
+def test_legacy_generation_phase_excludes_adaptive_runtime_profile(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    workload: Workload,
+) -> None:
+    repository = tmp_path / "legacy"
+    repository.mkdir()
+    phase_reporter = FakePhaseReporter()
+    adapter, _api, executor = _adapter(
+        phase_reporter=phase_reporter,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            _api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in _api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in _api.pdgs),),
+        ),
+    )
+
+    result = adapter.measure(
+        _cell(Accuracy.LC, workload, n_final=2),
+        artifact_path=tmp_path / "artifact",
+        settings=_settings(repository),
+        phase_reporter=phase_reporter,  # type: ignore[arg-type]
+    )
+
+    assert result["status"] == "ok"
+    assert phase_reporter.interval_count == 1
+    assert not phase_reporter.active
+    assert phase_reporter.transitions == ["profiling", "validation"]
+    profiled = tuple(
+        in_generation
+        for command, in_generation in zip(
+            executor.commands,
+            executor.command_generation_phase,
+            strict=True,
+        )
+        if command
+        and (
+            command[0] == "./amplicol_library_benchmark"
+            or command[0].endswith("amplicol_color_probe")
+        )
+    )
+    assert profiled
+    if workload is Workload.SELECTED_FLOW:
+        assert not any(profiled)
+        generated = tuple(
+            in_generation
+            for command, in_generation in zip(
+                executor.commands,
+                executor.command_generation_phase,
+                strict=True,
+            )
+            if command and command[0] == "./amplicol_generate"
+        )
+        assert generated == (True,)
+    else:
+        # Direct all-flow generation is authenticated by one dedicated
+        # one-point probe.  Warm-up and every adaptive timing chunk follow it
+        # outside the generation interval.
+        assert profiled[0] is True
+        assert not any(profiled[1:])
+        assert result["generation_seconds"] == pytest.approx(2.5)
+
+
+def test_adaptive_profile_points_are_bounded() -> None:
+    assert adaptive_profile_points(
+        0.0, target_runtime_seconds=20.0, minimum_points=17
+    ) == 17
+    assert adaptive_profile_points(
+        10.0,
+        target_runtime_seconds=20.0,
+        warmup_points=100,
+        minimum_points=100,
+        maximum_points=1_000,
+    ) == 200
+    assert adaptive_profile_points(
+        0.001,
+        target_runtime_seconds=20.0,
+        warmup_points=100,
+        maximum_points=1_000,
+    ) == 1_000
+
+
+def test_legacy_command_is_flushed_before_launch(tmp_path: Path) -> None:
+    log_path = tmp_path / "legacy.log"
+    commands: list[dict[str, object]] = []
+
+    class InspectingExecutor:
+        def run(self, args, *, cwd: Path, environment=None) -> CommandResult:
+            assert cwd == tmp_path
+            assert environment is None
+            assert log_path.read_text(encoding="utf-8") == (
+                "$ probe 1\n[launch] intended_points=1\n"
+            )
+            assert commands == [
+                {
+                    "args": ["probe", "1"],
+                    "cwd": str(tmp_path.resolve()),
+                    "environment": {},
+                    "status": "launching",
+                    "intended_points": 1,
+                }
+            ]
+            return CommandResult(
+                args=tuple(args),
+                cwd=cwd,
+                elapsed_seconds=0.25,
+                returncode=0,
+                stdout="done\n",
+                stderr="",
+                environment={},
+            )
+
+    adapter = LegacyMeasurementAdapter(
+        api=FakeApi(),
+        executor=InspectingExecutor(),
+        snapshotter=FakeSnapshotter(),
+    )
+
+    adapter._run(
+        ("probe", "1"),
+        cwd=tmp_path,
+        commands=commands,
+        log_path=log_path,
+    )
+
+    assert commands[0]["returncode"] == 0
+    assert "status" not in commands[0]
+    assert log_path.read_text(encoding="utf-8").endswith("done\n")
+
+
+@pytest.mark.parametrize(
+    ("source_pdgs", "raw_word", "canonical_word"),
+    (
+        (
+            (1, -1, 6, -6),
+            (3, 1, 2, 4),
+            (2, 4, 3, 1),
+        ),
+        (
+            (1, -1, 6, -6, 21),
+            (3, 1, 2, 5, 4),
+            (2, 5, 4, 3, 1),
+        ),
+        (
+            (1, -1, 6, -6, 21, 21),
+            (3, 1, 2, 5, 6, 4),
+            (2, 5, 6, 4, 3, 1),
+        ),
+        (
+            (21, 21, 6, -6),
+            (3, 1, 2, 4),
+            (3, 1, 2, 4),
+        ),
+    ),
+)
+def test_legacy_open_string_blocks_match_canonical_public_selector_axis(
+    source_pdgs: tuple[int, ...],
+    raw_word: tuple[int, ...],
+    canonical_word: tuple[int, ...],
+) -> None:
+    word = _canonical_mapped_color_word(
+        source_pdgs,
+        raw_word,
+        initial_state_count=2,
+    )
+
+    assert word == canonical_word
+    helicities = tuple(-1 if label % 2 else 1 for label in range(1, len(word) + 1))
+    helicity_id = "h:" + ",".join(f"{value:+d}" for value in helicities)
+    source_helicities = tuple(enumerate(helicities, start=1))
+    legacy_contract = SelectorContract(
+        selected_color_flow_ids=("flow:" + ",".join(str(label) for label in word),),
+        selected_color_words=(word,),
+        all_flow_helicity_ids=(helicity_id,),
+        all_flow_source_helicities=source_helicities,
+        point_digest="a" * 64,
+    )
+    candidate_contract = SelectorContract(
+        selected_color_flow_ids=(
+            "flow:" + ",".join(str(label) for label in canonical_word),
+        ),
+        selected_color_words=(canonical_word,),
+        all_flow_helicity_ids=(helicity_id,),
+        all_flow_source_helicities=source_helicities,
+        point_digest="a" * 64,
+    )
+    assert legacy_contract == candidate_contract
+
+
+def test_legacy_closed_adjoint_word_keeps_generated_row_order() -> None:
+    assert _canonical_mapped_color_word(
+        (21, 21, 21, 21),
+        (1, 3, 2, 4),
+        initial_state_count=2,
+    ) == (1, 3, 2, 4)
+
+
+@pytest.mark.parametrize(
+    "raw_word",
+    (
+        (3, 2, 1, 4),
+        (1, 3, 2, 4),
+        (3, 1, 4, 2),
+        (3, 1, 2, 2),
+    ),
+)
+def test_legacy_selector_canonicalization_rejects_non_block_rows(
+    raw_word: tuple[int, ...],
+) -> None:
+    with pytest.raises(
+        LegacyAdapterError,
+        match=r"permutation|concatenation",
+    ):
+        _canonical_mapped_color_word(
+            (1, -1, 6, -6),
+            raw_word,
+            initial_state_count=2,
+        )
+
+
+def test_profile_rejects_exactly_identical_bounded_chunk_rates(
+    tmp_path: Path,
+) -> None:
+    adapter, _api, _executor = _adapter()
+    calls: list[int] = []
+
+    def invoke(points: int):
+        calls.append(points)
+        seconds = points * 1.0e-5
+        result = CommandResult(
+            args=("probe", str(points)),
+            cwd=tmp_path,
+            elapsed_seconds=seconds,
+            returncode=0,
+            stdout="",
+            stderr="",
+            environment={},
+        )
+        return (
+            result,
+            (TimingRow("amplitude evaluation", seconds),),
+            None,
+        )
+
+    with pytest.raises(
+        LegacyAdapterError,
+        match="positive measured uncertainty",
+    ):
+        adapter._profile(
+            invoke,
+            settings=LegacySettings(
+                target_runtime_seconds=0.005,
+                warmup_points=10,
+                minimum_points=10,
+                maximum_points=100,
+                maximum_profile_chunks=8,
+                repository=tmp_path,
+            ),
+            timing_labels=("amplitude evaluation",),
+        )
+
+    assert calls == [1, 100, 100, 100, 100, 100, 10, 10, 10]
+
+
+def test_profile_rejects_a_bound_below_five_timed_chunks(
+    tmp_path: Path,
+) -> None:
+    with pytest.raises(
+        ValueError,
+        match="maximum_profile_chunks must not be below",
+    ):
+        LegacySettings(
+            target_runtime_seconds=0.005,
+            warmup_points=10,
+            minimum_points=10,
+            maximum_points=100,
+            maximum_profile_chunks=2,
+            repository=tmp_path,
+        )
+
+
+def test_selected_flow_uses_generated_mode_one_and_compact_contract(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, api, executor = _adapter()
+    point = tuple(
+        (float(index), index + 0.25, index + 0.5, index + 0.75)
+        for index, _pdg in enumerate(api.pdgs, start=1)
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            point,
+            (point,),
+        ),
+    )
+    monkeypatch.setattr(
+        api,
+        "ordered_momenta",
+        lambda _source_pdgs, _target_pdgs, momenta: tuple(reversed(momenta)),
+    )
+    measurement = adapter.measure(
+        _cell(Accuracy.LC, Workload.SELECTED_FLOW, n_final=2),
+        artifact_path=tmp_path / "selected",
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    validate_measurement(measurement)
+    assert measurement["status"] == "ok"
+    assert measurement["matrix_element"] == 3.25
+    assert measurement["generation_seconds"] == pytest.approx(0.55)
+    # The fake driver reports amplitude evaluation at 1.0 ms and the complete
+    # observable, including squaring, at 1.1 ms. The headline must use total.
+    assert measurement["wall_seconds_per_point"] == pytest.approx(1.1e-3)
+    assert measurement["execution_seconds_per_point"] == pytest.approx(1.1e-3)
+    contract = SelectorContract.from_mapping(measurement["selector_contract"])
+    assert contract.selected_color_flow_ids == ("flow:2,4,1",)
+    assert contract.all_flow_helicity_ids == ("h:-1,+1,-1,+1",)
+    assert api.selected_calls == [(1, (-1, 1, -1, 1))]
+    assert api.color_calls == []
+    common = measurement["validation"]["lc_common_component"]
+    assert common["value"] == 2.5
+    assert measurement["validation"][LEGACY_NUMERICAL_AUTHORITY_FIELD] == {
+        "abi": LEGACY_NUMERICAL_AUTHORITY_ABI,
+        "source": "selected-flow-generated-library",
+    }
+    flattened = [" ".join(command) for command in executor.commands]
+    assert any("--library=create" in command for command in flattened)
+    assert any("--seed=101" in command for command in flattened)
+    assert not any("--phasespace=" in command for command in flattened)
+    assert not any("--amplicol_momenta_probe=10" in command for command in flattened)
+    assert not any("--library=create-raw" in command for command in flattened)
+    assert not any("amplicol_color_probe" in command for command in flattened)
+    momenta_file = (
+        tmp_path / "repository/Utilities/ME_checks/momenta_1_2.txt"
+    )
+    assert momenta_file.is_file()
+    assert len(momenta_file.read_text(encoding="utf-8").splitlines()) == 4
+    profiled = tuple(
+        command
+        for command in executor.commands
+        if command and command[0] == "./amplicol_library_benchmark"
+    )
+    assert profiled
+    assert all(command[4] == "profile-momenta.dat" for command in profiled)
+    retained_momenta = (
+        tmp_path
+        / "selected/selected-flow-generated-library/profile-momenta.dat"
+    )
+    assert retained_momenta.is_file()
+    assert retained_momenta.read_text(encoding="utf-8") == (
+        "\n".join(
+            " ".join(format(component, ".17g") for component in vector)
+            for vector in reversed(point)
+        )
+        + "\n"
+    )
+
+
+def test_selected_flow_excludes_cold_generator_bootstrap_from_generation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, api, executor = _adapter()
+    original_run = executor.run
+    generator_builds = 0
+
+    def run_with_cold_bootstrap(
+        args: object,
+        *,
+        cwd: Path,
+        environment: object = None,
+    ) -> CommandResult:
+        nonlocal generator_builds
+        result = original_run(args, cwd=cwd, environment=environment)
+        rendered = tuple(str(item) for item in args)
+        if (
+            rendered
+            and rendered[0] == "make"
+            and "amplicol_generate" in rendered
+        ):
+            generator_builds += 1
+            if generator_builds == 1:
+                return CommandResult(
+                    args=result.args,
+                    cwd=result.cwd,
+                    elapsed_seconds=17.0,
+                    returncode=result.returncode,
+                    stdout=result.stdout,
+                    stderr=result.stderr,
+                    environment=result.environment,
+                )
+        return result
+
+    monkeypatch.setattr(executor, "run", run_with_cold_bootstrap)
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+
+    measurement = adapter.measure(
+        _cell(Accuracy.LC, Workload.SELECTED_FLOW),
+        artifact_path=tmp_path / "selected",
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    assert generator_builds == 2
+    assert measurement["generation_seconds"] == pytest.approx(0.55)
+    commands = measurement["provenance"]["commands"]
+    assert commands[1]["args"] == ["make", "-j1", "amplicol_generate"]
+    assert commands[1]["elapsed_seconds"] == 17.0
+    make_commands = [command for command in commands if command["args"][0] == "make"]
+    assert make_commands
+    assert all(
+        command["environment"] == {"PDF_BACKEND": "internal"}
+        for command in make_commands
+    )
+
+
+@pytest.mark.parametrize("generation_fails", (False, True))
+@pytest.mark.parametrize("n_final", range(4, 8))
+def test_four_lepton_discovery_restores_cuts_before_benchmark(
+    generation_fails: bool,
+    n_final: int,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    pdgs = (1, -1, -11, 11, -11, 11, *(21 for _ in range(n_final - 4)))
+    adapter, api, executor = _adapter(FakeApi(pdgs))
+    api.entry = FakeEntry(
+        process_pdgs=pdgs,
+        color_order=(2, *range(7, len(pdgs) + 1), 1, 3, 4, 5, 6),
+    )
+    point = tuple((1.0, 0.0, 0.0, 0.0) for _ in pdgs)
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (api.pdgs, point, (point,)),
+    )
+    repository = tmp_path / "repository"
+    repository.mkdir()
+    common = repository / "common.f03"
+    original = "  real(kind=8),parameter :: pTl_min      = -1d0\n"
+    common.write_text(original, encoding="utf-8")
+    common_object = repository / "common.o"
+    common_object.write_bytes(b"stale")
+    original_run = executor.run
+
+    def check_configuration(args, *, cwd, environment=None):
+        if args[0] == "./amplicol_generate":
+            assert "pTl_min      = 30d0" in common.read_text(encoding="utf-8")
+            assert "--seed=101" in args
+            assert not common_object.exists()
+            common_object.write_bytes(b"generation cuts")
+            if generation_fails:
+                raise LegacyAdapterError("generation fixture failed")
+        if "amplicol_library_benchmark" in args:
+            assert common.read_text(encoding="utf-8") == original
+            assert not common_object.exists()
+        return original_run(args, cwd=cwd, environment=environment)
+
+    monkeypatch.setattr(executor, "run", check_configuration)
+
+    def measure():
+        return adapter.measure(
+            _cell(
+                Accuracy.LC,
+                Workload.SELECTED_FLOW,
+                process_key="dd_4l_jets",
+                n_final=n_final,
+            ),
+            artifact_path=tmp_path / "four-leptons",
+            settings=_settings(repository),
+        )
+
+    if generation_fails:
+        with pytest.raises(LegacyAdapterError, match="generation fixture failed"):
+            measure()
+    else:
+        validate_measurement(measure())
+    assert common.read_text(encoding="utf-8") == original
+    assert not common_object.exists()
+
+
+def test_generation_lepton_cut_requires_known_configuration(tmp_path: Path) -> None:
+    common = tmp_path / "common.f03"
+    common.write_text("unexpected configuration\n", encoding="utf-8")
+    with (
+        pytest.raises(LegacyAdapterError, match="could not configure"),
+        _generation_lepton_pt_cut(tmp_path),
+    ):
+        pytest.fail("unsupported configuration must not start generation")
+    assert common.read_text(encoding="utf-8") == "unexpected configuration\n"
+
+
+@pytest.mark.parametrize(
+    ("process_key", "base_pdgs"),
+    (
+        ("dd_epemzh_jets", (1, -1, -11, 11, 23, 25)),
+        ("ud_epve_jets", (2, -1, -11, 12)),
+    ),
+)
+@pytest.mark.parametrize(
+    ("accuracy", "workload", "n_final"),
+    (
+        *(
+            (Accuracy.LC, Workload.SELECTED_FLOW, n_final)
+            for n_final in range(4, 8)
+        ),
+        (Accuracy.NLC, Workload.CONTRACTED, 4),
+    ),
+)
+def test_multibody_lepton_library_uses_t_channel_only_for_seeded_discovery(
+    process_key: str,
+    base_pdgs: tuple[int, ...],
+    accuracy: Accuracy,
+    workload: Workload,
+    n_final: int,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    pdgs = (*base_pdgs, *(21 for _ in range(n_final + 2 - len(base_pdgs))))
+    adapter, api, executor = _adapter(FakeApi(pdgs))
+    api.entry = FakeEntry(
+        process_pdgs=pdgs,
+        color_order=(
+            2,
+            *range(len(base_pdgs) + 1, len(pdgs) + 1),
+            1,
+            *range(3, len(base_pdgs) + 1),
+        ),
+    )
+    point = tuple((1.0, 0.0, 0.0, 0.0) for _ in pdgs)
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (api.pdgs, point, (point,)),
+    )
+
+    measurement = adapter.measure(
+        _cell(
+            accuracy,
+            workload,
+            process_key=process_key,
+            n_final=n_final,
+        ),
+        artifact_path=tmp_path / process_key,
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    validate_measurement(measurement)
+    generation_command = next(
+        command
+        for command in executor.commands
+        if command[0] == "./amplicol_generate"
+    )
+    if workload is Workload.SELECTED_FLOW:
+        assert "--seed=101" in generation_command
+        assert "--phasespace=4" in generation_command
+        assert "--amplicol_momenta_probe=10" not in generation_command
+    else:
+        assert "--amplicol_momenta_probe=10" in generation_command
+        assert "--seed=101" not in generation_command
+        assert "--phasespace=4" not in generation_command
+
+
+@pytest.mark.parametrize(
+    ("process_key", "pdgs"),
+    (
+        ("dd_epem_jets", (1, -1, -11, 11)),
+        ("ud_epve_jets", (2, -1, -11, 12)),
+    ),
+)
+def test_massless_two_body_lepton_library_uses_supplied_physical_point(
+    process_key: str,
+    pdgs: tuple[int, ...],
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, api, executor = _adapter(FakeApi(pdgs))
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+
+    measurement = adapter.measure(
+        _cell(
+            Accuracy.LC,
+            Workload.SELECTED_FLOW,
+            process_key=process_key,
+            n_final=2,
+        ),
+        artifact_path=tmp_path / process_key,
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    validate_measurement(measurement)
+    flattened = [" ".join(command) for command in executor.commands]
+    assert any("--amplicol_momenta_probe=10" in command for command in flattened)
+    assert not any("--seed=101" in command for command in flattened)
+
+
+@pytest.mark.parametrize(
+    ("final_pdgs", "n_final", "expected_id"),
+    (
+        ((-11, 11, 23, 25), 4, "h:-1,+1,-1,+1,-1,+0"),
+        ((-11, 11, 23, 25), 5, "h:-1,+1,-1,+1,-1,+0,-1"),
+        ((-11, 11, 23, 25), 6, "h:-1,+1,-1,+1,-1,+0,-1,+1"),
+        ((-11, 11, 23, 25), 7, "h:-1,+1,-1,+1,-1,+0,-1,+1,-1"),
+        ((6, -6, 23, 25), 4, "h:-1,+1,-1,+1,-1,+0"),
+        ((6, -6, 23, 25), 5, "h:-1,+1,-1,+1,-1,+0,-1"),
+        ((6, -6, 23, 25), 6, "h:-1,+1,-1,+1,-1,+0,-1,+1"),
+        ((6, -6, 23, 25), 7, "h:-1,+1,-1,+1,-1,+0,-1,+1,-1"),
+    ),
+)
+def test_higgs_selector_ids_match_runtime_signed_zero_axis(
+    final_pdgs: tuple[int, ...],
+    n_final: int,
+    expected_id: str,
+) -> None:
+    pdgs = (1, -1, *final_pdgs, *(21 for _ in range(n_final - 4)))
+    helicities = _fixed_helicity(pdgs)
+    points = (((1.0, 0.0, 0.0, 1.0),),)
+    labels = tuple(range(1, len(pdgs) + 1))
+    flow_id = "flow:2,1"
+    runtime = SimpleNamespace(
+        physics=SimpleNamespace(
+            color_flows=(SimpleNamespace(id=flow_id, word=(2, 1)),),
+            helicities=(
+                SimpleNamespace(id=expected_id, values=helicities),
+            ),
+            external_particles=tuple(
+                SimpleNamespace(label=label) for label in labels
+            ),
+        )
+    )
+    contract = SelectorContract(
+        selected_color_flow_ids=(flow_id,),
+        selected_color_words=((2, 1),),
+        all_flow_helicity_ids=(_helicity_id(helicities),),
+        all_flow_source_helicities=tuple(
+            zip(labels, helicities, strict=True)
+        ),
+        point_digest=point_digest(points),
+    )
+
+    assert helicities[5] == 0
+    assert contract.all_flow_helicity_ids == (expected_id,)
+    validate_selector_contract(runtime, contract, points)
+
+
+def test_higgs_selector_keeps_nonzero_signs_fail_closed() -> None:
+    points = (((1.0, 0.0, 0.0, 1.0),),)
+    helicities = (-1, 1, -1, 1, -1, 0)
+    identifier = _helicity_id(helicities)
+    runtime = SimpleNamespace(
+        physics=SimpleNamespace(
+            color_flows=(SimpleNamespace(id="flow:2,1", word=(2, 1)),),
+            helicities=(
+                SimpleNamespace(
+                    id=identifier,
+                    values=(1, 1, -1, 1, -1, 0),
+                ),
+            ),
+            external_particles=tuple(
+                SimpleNamespace(label=label)
+                for label in range(1, len(helicities) + 1)
+            ),
+        )
+    )
+    contract = SelectorContract(
+        selected_color_flow_ids=("flow:2,1",),
+        selected_color_words=((2, 1),),
+        all_flow_helicity_ids=(identifier,),
+        all_flow_source_helicities=tuple(
+            enumerate(helicities, start=1)
+        ),
+        point_digest=point_digest(points),
+    )
+
+    with pytest.raises(RunnerError, match="selected physical helicity"):
+        validate_selector_contract(runtime, contract, points)
+
+
+def test_all_flow_uses_direct_fixed_helicity_and_its_own_generation_setup(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, api, executor = _adapter()
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+    measurement = adapter.measure(
+        _cell(Accuracy.LC, Workload.ALL_FLOW),
+        artifact_path=tmp_path / "all",
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    validate_measurement(measurement)
+    assert measurement["matrix_element"] == 12.5
+    assert measurement["generation_seconds"] == 2.5
+    assert measurement["wall_seconds_per_point"] == pytest.approx(1.0e-3)
+    common = measurement["validation"]["lc_common_component"]
+    assert common["value"] == 2.5
+    assert LEGACY_NUMERICAL_AUTHORITY_FIELD not in measurement["validation"]
+    provenance = measurement["provenance"]
+    assert provenance["generation_timing_is_workload_specific"] is True
+    assert provenance["row_selection_policy"] == (
+        "exact-external-pdg-order-then-process-file-order-v1"
+    )
+    assert provenance["raw_mapped_color_order"] == [2, 4, 1, 3]
+    assert (
+        provenance["selector_color_word_policy"]
+        == "outgoing-open-string-blocks-by-fundamental-source-label-v1"
+    )
+    assert (
+        provenance["generation_source"] == "direct-imode2-generation-setup"
+    )
+    flattened = [" ".join(command) for command in executor.commands]
+    assert not any("--library=create" in command for command in flattened)
+    assert any(command.endswith("amplicol_color_probe") for command in flattened)
+
+
+def test_all_flow_replays_selected_flow_provider_as_authoritative_component(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, api, _executor = _adapter()
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+    provider = adapter.measure(
+        _cell(Accuracy.LC, Workload.SELECTED_FLOW),
+        artifact_path=tmp_path / "selected",
+        settings=_settings(tmp_path / "repository"),
+    )
+    api.lc_probe_result = SimpleNamespace(
+        value=2.75,
+        lc_row_partitions=(
+            SimpleNamespace(row=1, value=2.75, permutation=(2, 4, 1)),
+        ),
+        lc_partition_sum=2.75,
+    )
+
+    measurement = adapter.measure(
+        _cell(Accuracy.LC, Workload.ALL_FLOW),
+        artifact_path=tmp_path / "all",
+        settings=_settings(tmp_path / "repository"),
+        selector_provider=provider,
+    )
+
+    validate_measurement(measurement)
+    assert measurement["status"] == "ok"
+    assert measurement["matrix_element"] == 12.5
+    assert measurement["validation"]["lc_common_component"]["value"] == 2.5
+    assert measurement["validation"][LEGACY_NUMERICAL_AUTHORITY_FIELD] == {
+        "abi": LEGACY_NUMERICAL_AUTHORITY_ABI,
+        "source": "all-flow-selected-provider-replay",
+    }
+    diagnostic = measurement["validation"][LEGACY_IMODE2_DIAGNOSTIC_FIELD]
+    assert diagnostic == {
+        "abi": LEGACY_IMODE2_DIAGNOSTIC_ABI,
+        "certifying": False,
+        "authoritative_source": "selected-flow-generated-library-component",
+        "authoritative_value": 2.5,
+        "imode2_value": 2.75,
+        "absolute_difference": 0.25,
+        "relative_difference": 0.1,
+    }
+    assert api.selected_calls == [
+        (1, (-1, 1, -1, 1)),
+        (1, (-1, 1, -1, 1)),
+    ]
+
+
+def test_high_flow_provider_omits_out_of_scope_imode2_component_diagnostic(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    pdgs = (1, -1, 2, -2, 3, -3, 21, 21, 21, 21, 21)
+    api = FakeApi(pdgs)
+    adapter, _api, _executor = _adapter(api)
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in pdgs),),
+        ),
+    )
+    provider = adapter.measure(
+        _cell(
+            Accuracy.LC,
+            Workload.SELECTED_FLOW,
+            process_key="dd_3q_lines",
+            n_final=9,
+        ),
+        artifact_path=tmp_path / "selected",
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    measurement = adapter.measure(
+        _cell(
+            Accuracy.LC,
+            Workload.ALL_FLOW,
+            process_key="dd_3q_lines",
+            n_final=9,
+        ),
+        artifact_path=tmp_path / "all",
+        settings=_settings(tmp_path / "repository"),
+        selector_provider=provider,
+    )
+
+    validate_measurement(measurement)
+    assert measurement["status"] == "ok"
+    assert measurement["validation"]["lc_common_component"]["value"] == 2.5
+    assert measurement["validation"][LEGACY_NUMERICAL_AUTHORITY_FIELD] == {
+        "abi": LEGACY_NUMERICAL_AUTHORITY_ABI,
+        "source": "all-flow-selected-provider-replay",
+    }
+    assert LEGACY_IMODE2_DIAGNOSTIC_FIELD not in measurement["validation"]
+    assert api.color_calls == []
+
+
+@pytest.mark.parametrize(
+    ("mutation", "match"),
+    (
+        ("status", "not a successful measurement"),
+        ("selector", "contract does not match"),
+        ("component", "invalid common component"),
+    ),
+)
+def test_all_flow_rejects_invalid_selected_flow_provider_before_measurement(
+    mutation: str,
+    match: str,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, api, executor = _adapter()
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+    provider = adapter.measure(
+        _cell(Accuracy.LC, Workload.SELECTED_FLOW),
+        artifact_path=tmp_path / "selected",
+        settings=_settings(tmp_path / "repository"),
+    )
+    provider = copy.deepcopy(provider)
+    if mutation == "status":
+        provider["status"] = "validation_failed"
+    elif mutation == "selector":
+        provider["selector_contract"]["point_digest"] = "b" * 64
+    else:
+        provider["validation"]["lc_common_component"]["value"] = float("nan")
+    commands_before = len(executor.commands)
+
+    with pytest.raises(LegacyAdapterError, match=match):
+        adapter.measure(
+            _cell(Accuracy.LC, Workload.ALL_FLOW),
+            artifact_path=tmp_path / "all",
+            settings=_settings(tmp_path / "repository"),
+            selector_provider=provider,
+        )
+
+    new_commands = executor.commands[commands_before:]
+    assert not any(
+        command and command[0].endswith("amplicol_color_probe")
+        for command in new_commands
+    )
+
+
+def test_all_flow_rejects_provider_replay_mismatch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, api, _executor = _adapter()
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+    provider = adapter.measure(
+        _cell(Accuracy.LC, Workload.SELECTED_FLOW),
+        artifact_path=tmp_path / "selected",
+        settings=_settings(tmp_path / "repository"),
+    )
+    api.selected_flow_fixed_helicity_value = 2.5001
+
+    with pytest.raises(LegacyAdapterError, match="replay disagrees"):
+        adapter.measure(
+            _cell(Accuracy.LC, Workload.ALL_FLOW),
+            artifact_path=tmp_path / "all",
+            settings=_settings(tmp_path / "repository"),
+            selector_provider=provider,
+        )
+
+
+@pytest.mark.parametrize(
+    ("pdgs", "expected", "expected_id"),
+    (
+        (
+            (2, -1, -11, 12),
+            (-1, 1, 1, -1),
+            "h:-1,+1,+1,-1",
+        ),
+        (
+            (2, -1, -11, 12, 21),
+            (-1, 1, 1, -1, -1),
+            "h:-1,+1,+1,-1,-1",
+        ),
+    ),
+)
+def test_fixed_helicity_uses_nonzero_chiral_charged_current(
+    pdgs: tuple[int, ...],
+    expected: tuple[int, ...],
+    expected_id: str,
+) -> None:
+    helicities = _fixed_helicity(pdgs)
+
+    assert helicities == expected
+    assert _helicity_id(helicities) == expected_id
+
+
+def test_all_flow_rejects_structural_zero_selector(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    api = FakeApi()
+    api.lc_probe_result = SimpleNamespace(
+        value=0.0,
+        lc_row_partitions=(
+            SimpleNamespace(row=1, value=0.0, permutation=(2, 4, 1)),
+        ),
+        lc_partition_sum=0.0,
+    )
+    adapter, _api, _executor = _adapter(api)
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+
+    with pytest.raises(LegacyAdapterError, match="structural-zero helicity"):
+        adapter.measure(
+            _cell(Accuracy.LC, Workload.ALL_FLOW),
+            artifact_path=tmp_path / "all",
+            settings=_settings(tmp_path / "repository"),
+        )
+
+
+def _measure_with_lc_probe(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    probe: object,
+) -> dict[str, object]:
+    api = FakeApi()
+    api.lc_probe_result = probe
+    adapter, _api, _executor = _adapter(api)
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+    return adapter.measure(
+        _cell(Accuracy.LC, Workload.ALL_FLOW),
+        artifact_path=tmp_path / "adversarial",
+        settings=_settings(tmp_path / "repository"),
+    )
+
+
+@pytest.mark.parametrize(
+    "permutation",
+    (
+        (2, 4),
+        (2, 4, 4),
+        (0, 4, 1),
+        (2, 5, 1),
+        (2, "4", 1),
+    ),
+)
+def test_lc_common_probe_rejects_malformed_row_permutations(
+    permutation: tuple[object, ...],
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    probe = SimpleNamespace(
+        value=2.5,
+        lc_row_partitions=(
+            SimpleNamespace(row=1, value=2.5, permutation=permutation),
+        ),
+        lc_partition_sum=2.5,
+    )
+
+    with pytest.raises(
+        LegacyAdapterError,
+        match=r"row permutation|every colored source label",
+    ):
+        _measure_with_lc_probe(tmp_path, monkeypatch, probe)
+
+
+@pytest.mark.parametrize(
+    "partitions",
+    (
+        (
+            SimpleNamespace(row=1, value=1.0, permutation=(2, 4, 1)),
+            SimpleNamespace(row=1, value=1.5, permutation=(2, 1, 4)),
+        ),
+        (
+            SimpleNamespace(row=1, value=1.0, permutation=(2, 4, 1)),
+            SimpleNamespace(row=2, value=1.5, permutation=(2, 4, 1)),
+        ),
+    ),
+)
+def test_lc_common_probe_rejects_duplicate_rows(
+    partitions: tuple[object, ...],
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    probe = SimpleNamespace(
+        value=2.5,
+        lc_row_partitions=partitions,
+        lc_partition_sum=2.5,
+    )
+
+    with pytest.raises(LegacyAdapterError, match=r"duplicate"):
+        _measure_with_lc_probe(tmp_path, monkeypatch, probe)
+
+
+@pytest.mark.parametrize(
+    ("partition_sum", "aggregate", "match"),
+    (
+        (3.0, 3.0, "resolved partitions do not match"),
+        (2.5, 3.0, "partition sum does not match"),
+        (float("nan"), 2.5, "aggregate evidence is not finite"),
+    ),
+)
+def test_lc_common_probe_authenticates_partition_sum_and_aggregate(
+    partition_sum: float,
+    aggregate: float,
+    match: str,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    probe = SimpleNamespace(
+        value=aggregate,
+        lc_row_partitions=(
+            SimpleNamespace(row=1, value=2.5, permutation=(2, 4, 1)),
+        ),
+        lc_partition_sum=partition_sum,
+    )
+
+    with pytest.raises(LegacyAdapterError, match=match):
+        _measure_with_lc_probe(tmp_path, monkeypatch, probe)
+
+
+@pytest.mark.parametrize("accuracy", [Accuracy.NLC, Accuracy.FULL])
+def test_contracted_publishes_dedicated_library_probe_with_imode2_diagnostic(
+    accuracy: Accuracy,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, api, executor = _adapter()
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+    measurement = adapter.measure(
+        _cell(accuracy, Workload.CONTRACTED),
+        artifact_path=tmp_path / accuracy.value,
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    validate_measurement(measurement)
+    assert measurement["status"] == "ok"
+    assert measurement["matrix_element"] == 9.75
+    assert measurement["selector_contract"] is None
+    assert api.color_calls == [(accuracy.value, None)]
+    flattened = [" ".join(command) for command in executor.commands]
+    assert any("--library=create-raw" in command for command in flattened)
+    assert any("--amplicol_momenta_probe=10" in command for command in flattened)
+    assert not any("--seed=101" in command for command in flattened)
+    probe_build = (
+        "make",
+        "-j1",
+        "amplicol_color_library_probe",
+        "amplicol_color_probe",
+    )
+    assert probe_build in executor.commands
+    assert executor.commands.index(probe_build) < next(
+        index
+        for index, command in enumerate(executor.commands)
+        if command[0] == "./amplicol_color_library_probe"
+    )
+    assert api.parsed_probe_count == 0
+    diagnostic = measurement["validation"][LEGACY_IMODE2_DIAGNOSTIC_FIELD]
+    assert diagnostic == {
+        "abi": LEGACY_IMODE2_DIAGNOSTIC_ABI,
+        "certifying": False,
+        "authoritative_source": "dedicated-generated-library-probe",
+        "authoritative_value": 9.75,
+        "imode2_value": 9.75,
+        "absolute_difference": 0.0,
+        "relative_difference": 0.0,
+    }
+    assert measurement["validation"][LEGACY_NUMERICAL_AUTHORITY_FIELD] == {
+        "abi": LEGACY_NUMERICAL_AUTHORITY_ABI,
+        "source": "contracted-generated-library",
+    }
+
+
+@pytest.mark.parametrize("accuracy", [Accuracy.NLC, Accuracy.FULL])
+def test_contracted_keeps_known_imode2_mismatch_non_certifying(
+    accuracy: Accuracy,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, api, _executor = _adapter()
+    api.direct_color_probe_value = 10.0
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+
+    measurement = adapter.measure(
+        _cell(accuracy, Workload.CONTRACTED),
+        artifact_path=tmp_path / accuracy.value,
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    validate_measurement(measurement)
+    assert measurement["status"] == "ok"
+    assert measurement["matrix_element"] == 9.75
+    assert measurement["failure"] is None
+    diagnostic = measurement["validation"][LEGACY_IMODE2_DIAGNOSTIC_FIELD]
+    assert diagnostic["certifying"] is False
+    assert diagnostic["authoritative_value"] == 9.75
+    assert diagnostic["imode2_value"] == 10.0
+    assert diagnostic["absolute_difference"] == 0.25
+    assert diagnostic["relative_difference"] == pytest.approx(0.25 / 9.75)
+
+
+@pytest.mark.parametrize("accuracy", (Accuracy.NLC, Accuracy.FULL))
+def test_three_quark_line_contracted_uses_exact_direct_probe(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    accuracy: Accuracy,
+) -> None:
+    api = FakeApi((1, -1, 2, -2, 3, -3, 21, 21))
+    api.entry = FakeEntry(
+        process_pdgs=api.pdgs,
+        color_order=(2, 7, 8, 1, 3, 4, 5, 6),
+    )
+    adapter, _api, executor = _adapter(api)
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+
+    measurement = adapter.measure(
+        _cell(
+            accuracy,
+            Workload.CONTRACTED,
+            process_key="dd_3q_lines",
+            n_final=6,
+        ),
+        artifact_path=tmp_path / accuracy.value,
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    validate_measurement(measurement)
+    assert measurement["matrix_element"] == 12.5
+    assert measurement["generation_seconds"] == 2.5
+    assert api.color_calls == []
+    assert (
+        measurement["provenance"]["generation_source"]
+        == "direct-imode2-three-quark-line-setup"
+    )
+    assert measurement["validation"][LEGACY_NUMERICAL_AUTHORITY_FIELD] == {
+        "abi": LEGACY_NUMERICAL_AUTHORITY_ABI,
+        "source": "direct-imode2-three-quark-line",
+    }
+    flattened = [" ".join(command) for command in executor.commands]
+    assert any("amplicol_color_probe" in command for command in flattened)
+    assert not any("amplicol_generate" in command for command in flattened)
+    assert not any("amplicol_color_library_probe" in command for command in flattened)
+
+
+def test_more_than_three_open_quark_lines_is_preserved_as_unsupported(
+    tmp_path: Path,
+) -> None:
+    api = FakeApi((1, -1, 2, -2, 3, -3, 4, -4))
+    adapter, _api, executor = _adapter(api)
+    cell = next(
+        item
+        for item in REPORT_CATALOG.reference_cells()
+        if item.process_key == "dd_4q_lines"
+        and item.measurement.accuracy is Accuracy.LC
+        and item.workload is Workload.SELECTED_FLOW
+    )
+    measurement = adapter.measure(
+        cell,
+        artifact_path=tmp_path / "unsupported",
+        settings=_settings(tmp_path / "repository"),
+    )
+
+    validate_measurement(measurement)
+    assert measurement["status"] == "unsupported"
+    assert "at most 3 open quark lines" in measurement["failure"]["message"]
+    assert executor.commands == []
+
+
+def test_profile_never_reuses_warmup_as_the_only_timed_sample(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, api, executor = _adapter()
+    monkeypatch.setattr(
+        "tools.performance_report.legacy._shared_point",
+        lambda _process: (
+            api.pdgs,
+            tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),
+            (tuple((1.0, 0.0, 0.0, 0.0) for _ in api.pdgs),),
+        ),
+    )
+    settings = LegacySettings(
+        target_runtime_seconds=0.05,
+        warmup_points=100,
+        minimum_points=10,
+        maximum_points=1_000,
+        repository=tmp_path / "repository",
+    )
+    measurement = adapter.measure(
+        _cell(Accuracy.LC, Workload.SELECTED_FLOW),
+        artifact_path=tmp_path / "reuse",
+        settings=settings,
+    )
+
+    benchmark_commands = [
+        command
+        for command in executor.commands
+        if command and command[0] == "./amplicol_library_benchmark"
+    ]
+    assert len(benchmark_commands) == 6
+    assert measurement["sample_count"] >= 50
+    assert (
+        measurement["provenance"]["runtime_profile"]["measurement"][
+            "profile_phase"
+        ]
+        == "measurement_chunks"
+    )
+    assert (
+        measurement["provenance"]["runtime_profile"]["measurement"][
+            "chunk_count"
+        ]
+        == 5
+    )
+
+
+def test_fast_warmup_still_produces_five_samples_and_measured_rse(
+    tmp_path: Path,
+) -> None:
+    adapter, _api, _executor = _adapter()
+    calls: list[int] = []
+    rates = iter((0.09, 0.11, 0.10, 0.105, 0.095))
+
+    def invoke(points: int):
+        calls.append(points)
+        seconds = 5.0 if len(calls) == 1 else points * next(rates)
+        result = CommandResult(
+            args=("probe", str(points)),
+            cwd=tmp_path,
+            elapsed_seconds=seconds,
+            returncode=0,
+            stdout="",
+            stderr="",
+            environment={},
+        )
+        return (
+            result,
+            (TimingRow("amplitude evaluation", seconds),),
+            None,
+        )
+
+    profile = adapter._profile(
+        invoke,
+        settings=LegacySettings(
+            target_runtime_seconds=5.0,
+            warmup_points=10,
+            minimum_points=10,
+            maximum_points=10,
+            repository=tmp_path,
+        ),
+        timing_labels=("amplitude evaluation",),
+    )
+
+    assert len(calls) == 6
+    assert profile.record["chunk_count"] == 5
+    assert profile.seconds == pytest.approx(5.0)
+    assert profile.standard_error_seconds_per_point > 0.0
+    assert profile.relative_standard_error > 0.0
+
+
+def test_legacy_profile_does_not_launch_chunk_larger_than_remaining_budget(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, _api, _executor = _adapter()
+    calls: list[int] = []
+    clock = iter((0.0, 0.0, 0.0))
+    monkeypatch.setattr(
+        "tools.performance_report.legacy.time.monotonic",
+        lambda: next(clock),
+    )
+
+    def invoke(points: int):
+        calls.append(points)
+        result = CommandResult(
+            args=("probe", str(points)),
+            cwd=tmp_path,
+            elapsed_seconds=0.2,
+            returncode=0,
+            stdout="",
+            stderr="",
+            environment={},
+        )
+        return result, (TimingRow("total", 0.2),), None
+
+    with pytest.raises(ProfilingTimeLimitError, match="legacy 10-point chunk"):
+        adapter._profile(
+            invoke,
+            settings=LegacySettings(
+                target_runtime_seconds=1.0,
+                minimum_points=10,
+                maximum_points=100,
+                profiling_time_limit_seconds=1.0,
+                repository=tmp_path,
+            ),
+            timing_labels=("total",),
+        )
+
+    assert calls == [1]
diff --git a/pyamplicol/tests/unit/test_three_mode_report_render.py b/pyamplicol/tests/unit/test_three_mode_report_render.py
new file mode 100644
index 0000000000..17c43c2014
--- /dev/null
+++ b/pyamplicol/tests/unit/test_three_mode_report_render.py
@@ -0,0 +1,4664 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+import re
+from pathlib import Path
+
+import pytest
+
+import tools.performance_report.render as report_render
+from tools.performance_report.agreements import (
+    DIRECT_AGREEMENT_ABI,
+    DIRECT_AGREEMENT_V2_ABI,
+    LC_COMMON_COMPONENT_ABI,
+    LC_COMMON_COMPONENT_FIELD,
+    LC_LEGACY_PYAMPLICOL_COMPONENT,
+    STRICT_ABSOLUTE_TOLERANCE,
+    incoming_agreement_edges,
+)
+from tools.performance_report.arena_profile import (
+    ARENA_PHASE_TIMING_SCOPE,
+    ARENA_PROFILE_BOUNDARY,
+    EMPTY_ARENA_PHASE_VECTOR_FIELDS,
+    ZERO_ARENA_COUNTER_FIELDS,
+    ZERO_ARENA_PHASE_TIME_FIELDS,
+    ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS,
+    build_arena_profile_evidence,
+    digest_arena_profile_value,
+)
+from tools.performance_report.cache import build_reset_caches, empty_measurement
+from tools.performance_report.campaign_policy import (
+    X86_EPYC_GENERATION_LIMIT_SECONDS,
+    X86_EPYC_MEMORY_LIMIT_BYTES,
+    X86_EPYC_POLICY,
+    PolicyCensorKind,
+    dependency_reference,
+    policy_censor_measurement,
+)
+from tools.performance_report.catalog import (
+    MADGRAPH_FULL_COMPARISON_VIEWS,
+    REPORT_CATALOG,
+)
+from tools.performance_report.models import (
+    Accuracy,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from tools.performance_report.render import (
+    BaselineCandidateAdapter,
+    _ratio_value,
+    render_all_best_mode_tables,
+    render_all_matrix_tables,
+    render_all_tables,
+    render_all_z_ladders,
+    render_best_mode_table,
+    render_matrix_comparison_table,
+    render_matrix_table,
+    render_scalar_ladder,
+    render_z_ladder,
+    summarize_visible_completeness,
+)
+from tools.performance_report.runner import (
+    OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD,
+    pointwise_validation,
+)
+from tools.performance_report.source_identity import ReportSourceIdentity
+from tools.performance_report.validation_summary import (
+    render_validation_summary,
+    summarize_validation,
+)
+
+
+def test_unavailable_execution_timing_is_never_ratioed() -> None:
+    baseline = {
+        "status": ResultStatus.OK.value,
+        "execution_seconds_per_point": 1.0e-6,
+    }
+    candidate = {
+        "status": ResultStatus.OK.value,
+        "execution_seconds_per_point": 1.0e-9,
+        "provenance": {
+            "execution_timing": {
+                "status": "unavailable",
+                "ratio_eligible": False,
+            }
+        },
+    }
+
+    assert _ratio_value(candidate, baseline, "execution_seconds_per_point") is None
+
+
+@pytest.fixture
+def reset_caches(
+    monkeypatch: pytest.MonkeyPatch,
+) -> dict[str, dict[str, object]]:
+    monkeypatch.setattr(
+        report_render,
+        "validate_on_the_fly_recurrence_authority_validation_record",
+        lambda *_args, **_kwargs: None,
+    )
+    return build_reset_caches()
+
+
+def test_packaged_blank_tables_match_canonical_reset_renderer(
+    reset_caches: dict[str, dict[str, object]],
+) -> None:
+    packaged_root = (
+        Path(__file__).resolve().parents[2] / "src/pyamplicol/_profiling_campaign"
+    )
+    rendered = render_all_tables(reset_caches, catalog=REPORT_CATALOG)
+    packaged = {
+        path.name: path.read_text(encoding="utf-8")
+        for path in packaged_root.glob("result_*.tex")
+    }
+
+    assert packaged == rendered
+
+
+def _cache_by_dataset(
+    caches: dict[str, dict[str, object]],
+    dataset_id: str,
+) -> dict[str, object]:
+    return next(
+        payload for payload in caches.values() if payload["dataset_id"] == dataset_id
+    )
+
+
+def _set_ok(
+    cache: dict[str, object],
+    *,
+    process_key: str,
+    n_final: int,
+    workload: Workload,
+    generation: float,
+    wall: float,
+    execution: float | None,
+    variant: str | None = None,
+) -> None:
+    entries = cache["entries"]
+    assert isinstance(entries, list)
+    entry = next(
+        item
+        for item in entries
+        if item["process_key"] == process_key
+        and item["n_final"] == n_final
+        and item["workload"] == workload.value
+        and item["variant"] == variant
+    )
+    cell = REPORT_CATALOG.cell(str(entry["cell_id"]))
+    entry["measurement"] = _ok_measurement(
+        cell,
+        generation=generation,
+        wall=wall,
+        execution=execution,
+    )
+
+
+_TEST_SELECTOR_CONTRACT = {
+    "all_flow_helicity_ids": ["h:test"],
+    "all_flow_source_helicities": {"1": 1},
+    "point_digest": "0" * 64,
+    "selected_color_flow_ids": ["flow:test"],
+    "selected_color_words": [[1]],
+}
+
+
+def _ok_measurement(
+    cell,
+    *,
+    generation: float,
+    wall: float,
+    execution: float | None,
+) -> dict[str, object]:
+    selector = (
+        copy.deepcopy(_TEST_SELECTOR_CONTRACT)
+        if cell.measurement.accuracy is Accuracy.LC
+        else None
+    )
+    direct_agreements = [
+        {
+            "abi": DIRECT_AGREEMENT_ABI,
+            "edge_kind": edge.kind,
+            "value_kind": edge.value_kind,
+            "baseline_cell_id": edge.baseline.cell_id,
+            "candidate_cell_id": cell.cell_id,
+            "status": ResultStatus.OK.value,
+            "candidate": 1.0,
+            "baseline": 1.0,
+            "absolute_difference": 0.0,
+            "relative_difference": 0.0,
+            "relative_tolerance": edge.relative_tolerance,
+            "absolute_tolerance": STRICT_ABSOLUTE_TOLERANCE,
+        }
+        for edge in incoming_agreement_edges(cell)
+    ]
+    validation: dict[str, object] = {
+        "status": ResultStatus.OK.value,
+        "pointwise": {
+            "status": ResultStatus.OK.value,
+            "candidate": 1.0,
+            "baseline": 1.0,
+            "absolute_difference": 0.0,
+            "relative_difference": 0.0,
+            "relative_tolerance": 1.0e-8,
+            "absolute_tolerance": 1.0e-15,
+        },
+        "high_precision": {
+            "status": ResultStatus.OK.value,
+            "candidate": 1.0,
+            "baseline": 1.0,
+            "absolute_difference": 0.0,
+            "relative_difference": 0.0,
+            "relative_tolerance": 1.0e-12,
+            "absolute_tolerance": 1.0e-15,
+        },
+        "direct_agreements": direct_agreements,
+    }
+    if selector is not None:
+        validation[LC_COMMON_COMPONENT_FIELD] = {
+            "abi": LC_COMMON_COMPONENT_ABI,
+            "cell_id": cell.cell_id,
+            "value": 1.0,
+            "point_digest": selector["point_digest"],
+            "helicity_ids": selector["all_flow_helicity_ids"],
+            "color_flow_ids": selector["selected_color_flow_ids"],
+        }
+    execution_mode = cell.measurement.execution_mode
+    artifact_id = (
+        "a" * 64
+        if execution_mode is ExecutionMode.ON_THE_FLY
+        else "b" * 64
+        if execution_mode is ExecutionMode.RECURRENCE
+        else "c" * 64
+    )
+    if (
+        execution_mode is ExecutionMode.ON_THE_FLY
+        and cell.measurement.accuracy is Accuracy.LC
+    ):
+        validation[OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD] = {
+            "authority": {"artifact_id": "b" * 64},
+        }
+    return {
+        "status": ResultStatus.OK.value,
+        "generation_seconds": generation,
+        "wall_seconds_per_point": wall,
+        "execution_seconds_per_point": execution,
+        "matrix_element": 1.0,
+        "sample_count": 5,
+        "standard_error_seconds_per_point": 1.0e-9,
+        "relative_standard_error": 0.01,
+        "artifact": {"digest": "artifact"},
+        "selector_contract": selector,
+        "validation": validation,
+        "resources": {"peak_rss_gib": 1.0},
+        "provenance": {
+            "source": "test",
+            "runtime_identity": {"artifact_id": artifact_id},
+            **(
+                {"runtime_profile": {"cold_warmup_elapsed_seconds": 0.25}}
+                if execution_mode is ExecutionMode.ON_THE_FLY
+                else {}
+            ),
+        },
+        "failure": None,
+    }
+
+
+def _set_status(
+    cache: dict[str, object],
+    *,
+    process_key: str,
+    n_final: int,
+    workload: Workload,
+    status: ResultStatus,
+) -> None:
+    entries = cache["entries"]
+    assert isinstance(entries, list)
+    entry = next(
+        item
+        for item in entries
+        if item["process_key"] == process_key
+        and item["n_final"] == n_final
+        and item["workload"] == workload.value
+        and item["variant"] is None
+    )
+    measurement = empty_measurement()
+    measurement["status"] = status.value
+    entry["measurement"] = measurement
+
+
+def _set_unverified(
+    cache: dict[str, object],
+    *,
+    process_key: str,
+    n_final: int,
+    workload: Workload,
+    generation: float,
+    wall: float,
+    evaluator_total: float,
+    variant: str | None = None,
+) -> None:
+    entry = _entry(
+        cache,
+        process_key=process_key,
+        n_final=n_final,
+        workload=workload,
+        variant=variant,
+    )
+    cell = REPORT_CATALOG.cell(str(entry["cell_id"]))
+    measurement = _ok_measurement(
+        cell,
+        generation=generation,
+        wall=wall,
+        execution=None,
+    )
+    _mark_evaluator_total(
+        measurement,
+        execution_mode=cell.measurement.execution_mode.value,
+        total=evaluator_total,
+    )
+    measurement["status"] = ResultStatus.UNVERIFIED.value
+    measurement["failure"] = {
+        "kind": "IndependentAuthorityUnavailable",
+        "message": "no successful independent authority",
+    }
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+    validation["status"] = ResultStatus.UNVERIFIED.value
+    entry["measurement"] = measurement
+
+
+def _set_presentation_outcome(
+    cache: dict[str, object],
+    *,
+    process_key: str,
+    n_final: int,
+    workload: Workload,
+    outcome: str,
+    label: str | None = None,
+    variant: str | None = None,
+) -> None:
+    labels = {
+        "error": (ResultStatus.ERROR, "error"),
+        "validation_failed": (
+            ResultStatus.VALIDATION_FAILED,
+            "validation failed",
+        ),
+        "blocked_dependency": (
+            ResultStatus.FAILED,
+            "blocked dependency",
+        ),
+    }
+    status, default_label = labels.get(
+        outcome,
+        (ResultStatus.FAILED, outcome.replace("_", " ")),
+    )
+    entry = _entry(
+        cache,
+        process_key=process_key,
+        n_final=n_final,
+        workload=workload,
+        variant=variant,
+    )
+    measurement = empty_measurement()
+    measurement["status"] = status.value
+    measurement["failure"] = {
+        "kind": f"ManualCampaignOutcome:{outcome}",
+        "message": default_label if label is None else label,
+    }
+    entry["measurement"] = measurement
+
+
+def _set_best_mode_nlc_reference(caches: dict[str, dict[str, object]]) -> None:
+    _set_ok(
+        _cache_by_dataset(caches, "reference_amplicol_nlc"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=10.0,
+        wall=10.0e-6,
+        execution=None,
+    )
+
+
+def _mark_arena_unavailable(
+    measurement: dict[str, object],
+    *,
+    execution_mode: str = "compiled",
+) -> None:
+    measurement["execution_seconds_per_point"] = None
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    raw_profile = {
+        "execution_mode": execution_mode,
+        "profile_boundary": ARENA_PROFILE_BOUNDARY,
+        "borrowed_flat_input": True,
+        "preallocated_output": True,
+        "phase_timing_scope": ARENA_PHASE_TIMING_SCOPE,
+        "evaluator_timing_available": False,
+        "points": 128,
+        "wall_time_s": 128 * 1.1e-6,
+        "orchestration_time_s": 128 * 1.1e-6,
+        **{field: 0 for field in ZERO_ARENA_COUNTER_FIELDS},
+        **{field: 0.0 for field in ZERO_ARENA_PHASE_TIME_FIELDS},
+        **{field: [] for field in EMPTY_ARENA_PHASE_VECTOR_FIELDS},
+        **{field: 0 for field in ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS},
+    }
+    if execution_mode == "compiled":
+        raw_profile.update(
+            {
+                "compiled_direct_arena_engine_count": 1,
+                "compiled_direct_arena_call_count": 128,
+                "evaluator_backend_call_count": 128,
+            }
+        )
+    arena_evidence = build_arena_profile_evidence(
+        [raw_profile] * 5,
+        execution_mode=execution_mode,
+        repetitions_per_profile=1,
+        batch_size=128,
+    )
+    provenance["arena_profile_evidence"] = arena_evidence
+    provenance["execution_timing"] = {
+        "abi": "pyamplicol-report-arena-execution-timing-v2",
+        "status": "unavailable",
+        "ratio_eligible": False,
+        "raw_seconds_per_point": None,
+        "sample_count": 5,
+        "native_profile_points_per_sample": 128,
+        "repetitions_per_sample": 1,
+        "batch_size": 128,
+        "sample_contract": ("paired_unprofiled_headline_profiled_attribution_v1"),
+        "profile_protocol": "arena",
+        "profile_sample_pass": "runtime._profile_arena_repeated",
+        "profile_boundary": (
+            "warmed-direct-arena-borrowed-input-preallocated-output-v1"
+        ),
+        "borrowed_flat_input": True,
+        "preallocated_output": True,
+        "phase_timing_scope": "coarse-arena-boundary-only-v1",
+        "evaluator_timing_available": False,
+        "paired_with_headline": True,
+        "identical_batch": True,
+        "identical_repetitions": True,
+        "execution_mode": execution_mode,
+        "warmed_boundary_wall_seconds_per_point": 1.1e-6,
+        "arena_profile_evidence_sha256": digest_arena_profile_value(arena_evidence),
+    }
+
+
+def _mark_evaluator_total(
+    measurement: dict[str, object],
+    *,
+    execution_mode: str = "compiled",
+    total: float | None = None,
+) -> None:
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    wall = measurement["wall_seconds_per_point"]
+    assert isinstance(wall, float)
+    raw_total = wall if total is None else total
+    provenance["evaluator_total_timing"] = {
+        "abi": "pyamplicol-report-evaluator-total-timing-v1",
+        "status": "measured",
+        "ratio_eligible": False,
+        "raw_seconds_per_point": raw_total,
+        "source": "runtime._benchmark_f64_wall_time.accumulated",
+        "execution_mode": execution_mode,
+        "sample_contract": ("accumulated-repeated-warmed-evaluator-total-v1"),
+        "sample_count": 5,
+        "repetitions_per_sample": 1,
+        "batch_size": 128,
+        "points_per_sample": 128,
+        "measured_point_count": 640,
+        "accumulated_seconds": raw_total * 640,
+    }
+
+
+def _mark_recurrence_core(measurement: dict[str, object]) -> None:
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    raw_core = measurement["execution_seconds_per_point"]
+    assert isinstance(raw_core, float)
+    provenance["execution_timing"] = {
+        "abi": "pyamplicol-report-execution-timing-v1",
+        "status": "measured",
+        "ratio_eligible": True,
+        "raw_seconds_per_point": raw_core,
+        "source": "runtime_profile_core_recurrence_schedule_time",
+        "compiled_direct_arena_active": False,
+        "sample_count": 5,
+        "native_profile_points_per_sample": 128,
+        "sample_contract": ("paired_unprofiled_headline_profiled_attribution_v1"),
+    }
+
+
+def _fill_visible_scope(
+    caches: dict[str, dict[str, object]],
+    *,
+    max_n_final: int = 4,
+) -> None:
+    for payload in caches.values():
+        entries = payload["entries"]
+        assert isinstance(entries, list)
+        for entry in entries:
+            if entry["n_final"] > max_n_final:
+                continue
+            cell = REPORT_CATALOG.cell(str(entry["cell_id"]))
+            if REPORT_CATALOG.static_na_reason(cell) is not None:
+                continue
+            entry["measurement"] = _ok_measurement(
+                cell,
+                generation=1.0,
+                wall=2.0e-6,
+                execution=1.0e-6,
+            )
+
+
+def _fill_visible_n4_scope(caches: dict[str, dict[str, object]]) -> None:
+    _fill_visible_scope(caches, max_n_final=4)
+
+
+_POLICY_IDENTITY = ReportSourceIdentity("1" * 40, "2" * 40, ())
+
+
+def _entry(
+    cache: dict[str, object],
+    *,
+    process_key: str,
+    n_final: int,
+    workload: Workload,
+    variant: str | None = None,
+) -> dict[str, object]:
+    entries = cache["entries"]
+    assert isinstance(entries, list)
+    return next(
+        item
+        for item in entries
+        if item["process_key"] == process_key
+        and item["n_final"] == n_final
+        and item["workload"] == workload.value
+        and item["variant"] == variant
+    )
+
+
+def _policy_resources(peak: int) -> dict[str, object]:
+    return {
+        "available": True,
+        "current_rss_bytes": peak,
+        "peak_rss_bytes": peak,
+        "child_count": 1,
+        "cpu_seconds": 1.0,
+        "wall_seconds": 2.0,
+        "probe_error": None,
+    }
+
+
+def _generation_censor(cell) -> dict[str, object]:
+    phase = {
+        "abi": "pyamplicol-report-generation-phase-evidence-v1",
+        "phase_state_abi": "pyamplicol-report-worker-phase-state-v1",
+        "configured_timeout_seconds": X86_EPYC_GENERATION_LIMIT_SECONDS,
+        "supervisor_reason": "generation_timeout",
+        "authenticated": True,
+        "run_id": "render-policy-test",
+        "worker_pid": 123,
+        "final_sequence": 1,
+        "final_phase": "generation",
+        "generation_started_monotonic_ns": 1,
+        "generation_finished_monotonic_ns": None,
+        "generation_elapsed_seconds": X86_EPYC_GENERATION_LIMIT_SECONDS,
+        "final_state_sha256": "3" * 64,
+        "error": None,
+    }
+    resources = _policy_resources(1_000_000)
+    resources["generation_phase"] = phase
+    return policy_censor_measurement(
+        X86_EPYC_POLICY,
+        "x86_EPYC",
+        cell,
+        kind=PolicyCensorKind.GENERATION_LIMIT,
+        source_identity=_POLICY_IDENTITY,
+        resources=resources,
+        observed_generation_seconds=X86_EPYC_GENERATION_LIMIT_SECONDS,
+        phase_evidence=phase,
+    )
+
+
+def _memory_censor(cell) -> dict[str, object]:
+    peak = X86_EPYC_MEMORY_LIMIT_BYTES + 1
+    return policy_censor_measurement(
+        X86_EPYC_POLICY,
+        "x86_EPYC",
+        cell,
+        kind=PolicyCensorKind.MEMORY_LIMIT,
+        source_identity=_POLICY_IDENTITY,
+        resources=_policy_resources(peak),
+        observed_rss_bytes=peak,
+    )
+
+
+def test_nineteen_matrices_render_in_catalog_and_comparison_order(
+    reset_caches,
+) -> None:
+    rendered = render_all_matrix_tables(reset_caches)
+    expected = [
+        dataset.table_name
+        for dataset in REPORT_CATALOG.matrix_datasets
+        if dataset.baseline.execution_mode is not ExecutionMode.MADGRAPH
+    ] + [view.table_name for view in MADGRAPH_FULL_COMPARISON_VIEWS]
+
+    assert len(rendered) == 19
+    assert list(rendered) == expected
+    assert not {
+        dataset.table_name
+        for dataset in REPORT_CATALOG.matrix_datasets
+        if dataset.baseline.execution_mode is ExecutionMode.MADGRAPH
+    } & set(rendered)
+    lc_tex = next(
+        rendered[dataset.table_name]
+        for dataset in REPORT_CATALOG.matrix_datasets
+        if dataset.candidate.accuracy is Accuracy.LC
+    )
+    contracted_tex = next(
+        rendered[dataset.table_name]
+        for dataset in REPORT_CATALOG.matrix_datasets
+        if dataset.candidate.accuracy is Accuracy.NLC
+    )
+    assert r"\textbf{ID} & \textbf{base process} & \textbf{metric}" in lc_tex
+    assert r"\multicolumn{8}{c}{\textbf{n=1}}" in lc_tex
+    assert r"\multicolumn{8}{c}{\textbf{n=2}}" in lc_tex
+    assert r"\multicolumn{3}{c}{\textbf{n=1}}" in contracted_tex
+    assert r"\multicolumn{3}{c}{\textbf{n=2}}" in contracted_tex
+    assert r"\matrixfitwidth{%" in lc_tex
+    assert r"\rowcolor{refblue}" in lc_tex
+    assert lc_tex.count(r"\multicolumn{8}{c}") >= 4
+    tabular_spec = next(
+        line for line in lc_tex.splitlines() if line.startswith(r"\begin{tabular}")
+    )
+    assert r"@{\hspace" not in tabular_spec
+    assert ":" not in tabular_spec
+    assert r"\dashlinedash" not in lc_tex
+    assert r"\dashlinegap" not in lc_tex
+    assert r"\texttt{abs }" not in lc_tex
+    assert r"\textcolor{ReportMuted}{\scriptsize gen. [s]}" in lc_tex
+    assert (
+        r"\textcolor{ReportMuted}{\scriptsize run "
+        r"[\(\mu\mathrm{s}/\mathrm{pt}\)]}"
+    ) in lc_tex
+    assert r"\matrixcolumnheading" not in lc_tex
+
+    obsolete_clock_macros = (
+        r"\matrixwallclock{",
+        r"\matrixwallabsolute{",
+        r"\matrixtotalevaluator{",
+        r"\matrixrecurrencecore{",
+        r"\matrixruntimepair{",
+        r"\matrixruntimetriple{",
+    )
+    best_mode_rendered = render_all_best_mode_tables(reset_caches)
+    for tex in (*rendered.values(), *best_mode_rendered.values()):
+        table_body = "\n".join(
+            line for line in tex.splitlines() if not line.startswith(r"\providecommand")
+        )
+        assert all(macro not in table_body for macro in obsolete_clock_macros)
+
+
+def test_madgraph_views_join_shared_reference_without_copying_measurements(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    view = next(
+        item
+        for item in MADGRAPH_FULL_COMPARISON_VIEWS
+        if item.candidate_dataset_id == "matrix_recurrence_ufo_sm_full"
+    )
+    baseline_cache = _cache_by_dataset(caches, view.baseline_dataset_id)
+    candidate_cache = _cache_by_dataset(caches, view.candidate_dataset_id)
+    _set_ok(
+        baseline_cache,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=8.0,
+        wall=4.0e-6,
+        execution=3.0e-6,
+    )
+    _set_ok(
+        candidate_cache,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+    baseline_measurement = next(
+        entry["measurement"]
+        for entry in baseline_cache["entries"]
+        if entry["process_key"] == "dd_z_jets" and entry["n_final"] == 1
+    )
+    candidate_measurement = next(
+        entry["measurement"]
+        for entry in candidate_cache["entries"]
+        if entry["process_key"] == "dd_z_jets" and entry["n_final"] == 1
+    )
+
+    dataset = REPORT_CATALOG.dataset(view.candidate_dataset_id)
+    joined = BaselineCandidateAdapter(caches).matrix_cell(
+        dataset,
+        REPORT_CATALOG.process_families[0],
+        1,
+        baseline_dataset_id=view.baseline_dataset_id,
+    )
+    tex = render_matrix_comparison_table(view, caches)
+
+    assert joined.workloads[0].baseline is baseline_measurement
+    assert joined.workloads[0].candidate is candidate_measurement
+    assert r"\subsection{UFO-SM recurrence JIT O2 versus MadGraph full-colour}" in tex
+    assert r"\texttt{8.00}" in tex
+    assert r"\bestmoderatio{ReportGreen}{0.500}" in tex
+    assert "MadGraph standalone is the authoritative full-colour" in tex
+
+
+def test_only_amplicol_generation_turns_red_for_legacy_mismatch(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "reference_amplicol_nlc")
+    candidate = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_nlc",
+    )
+    _set_ok(
+        baseline,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=100.0e-6,
+        execution=90.0e-6,
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=2.0,
+        wall=50.0e-6,
+        execution=40.0e-6,
+    )
+    measurement = next(
+        entry["measurement"]
+        for entry in candidate["entries"]
+        if entry["process_key"] == "dd_z_jets" and entry["n_final"] == 1
+    )
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+
+    dataset = REPORT_CATALOG.dataset("matrix_recurrence_builtin_sm_nlc")
+    before = render_matrix_table(dataset, caches)
+    assert r"\textcolor{ReportRed}{\texttt{4.00}}" not in before
+
+    validation["pointwise"]["status"] = ResultStatus.VALIDATION_FAILED.value
+    validation["legacy_amplicol_comparison"] = {
+        "status": "mismatch",
+        "pointwise": {"status": ResultStatus.VALIDATION_FAILED.value},
+    }
+    tex = render_matrix_table(dataset, caches)
+
+    assert r"\textcolor{ReportRed}{\texttt{4.00}}" in tex
+    assert r"\textcolor{ReportRed}{\texttt{100}}" not in tex
+    assert r"\matrixstatus{ReportRed}{validation failed}" not in tex
+    assert tex.replace(
+        r"\textcolor{ReportRed}{\texttt{4.00}}",
+        r"\texttt{4.00}",
+    ) == before
+
+
+def test_best_mode_inherits_legacy_mismatch_from_recurrence_bridge(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "reference_amplicol_nlc")
+    recurrence = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_nlc",
+    )
+    compiled = _cache_by_dataset(
+        caches,
+        "matrix_compiled_builtin_sm_nlc",
+    )
+    for cache, generation, wall in (
+        (baseline, 4.0, 100.0e-6),
+        (recurrence, 3.0, 60.0e-6),
+        (compiled, 2.0, 50.0e-6),
+    ):
+        _set_ok(
+            cache,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.CONTRACTED,
+            generation=generation,
+            wall=wall,
+            execution=0.8 * wall,
+        )
+
+    before = render_best_mode_table(Accuracy.NLC, caches)
+    recurrence_measurement = next(
+        entry["measurement"]
+        for entry in recurrence["entries"]
+        if entry["process_key"] == "dd_z_jets" and entry["n_final"] == 1
+    )
+    validation = recurrence_measurement["validation"]
+    validation["pointwise"]["status"] = ResultStatus.VALIDATION_FAILED.value
+    validation["legacy_amplicol_comparison"] = {"status": "mismatch"}
+
+    tex = render_best_mode_table(Accuracy.NLC, caches)
+
+    assert r"\textcolor{ReportRed}{\texttt{4.00}}" in tex
+    assert r"\textcolor{ReportRed}{\texttt{100}}" not in tex
+    assert tex.replace(
+        r"\textcolor{ReportRed}{\texttt{4.00}}",
+        r"\texttt{4.00}",
+    ) == before
+
+
+def test_identical_quark_line_family_renders_in_every_matrix_block(
+    reset_caches,
+) -> None:
+    rendered = render_all_matrix_tables(reset_caches)
+    best = render_all_best_mode_tables(reset_caches)
+    row = (
+        r"\texttt{15} & "
+        r"$d\bar d\to u\bar u\,u\bar u+(n-4)g$"
+    )
+
+    for name, expected_blocks in (
+        ("result_matrix_recurrence_builtin_sm_lc_table.tex", 3),
+        ("result_matrix_recurrence_builtin_sm_nlc_table.tex", 2),
+        ("result_matrix_recurrence_builtin_sm_full_table.tex", 2),
+    ):
+        assert rendered[name].count(row) == expected_blocks
+    assert best["result_matrix_best_builtin_sm_lc_table.tex"].count(row) == 3
+    assert best["result_matrix_best_builtin_sm_nlc_table.tex"].count(row) == 2
+    assert best["result_matrix_best_builtin_sm_full_table.tex"].count(row) == 2
+
+
+def test_matrix_summary_backgrounds_restart_for_each_multiplicity_block(
+    reset_caches,
+) -> None:
+    rendered = render_all_matrix_tables(reset_caches)
+
+    def summary_patterns(tex: str, span: int) -> list[list[bool]]:
+        rows = [line for line in tex.splitlines() if r"\textbf{summary:" in line]
+        return [
+            [
+                cell.startswith(rf"\multicolumn{{{span}}}{{c}}{{\cellcolor{{refblue}}")
+                for cell in row.split(" & ")[1:]
+            ]
+            for row in rows
+        ]
+
+    lc_tex = next(
+        rendered[dataset.table_name]
+        for dataset in REPORT_CATALOG.matrix_datasets
+        if dataset.candidate.accuracy is Accuracy.LC
+    )
+    contracted_tex = next(
+        rendered[dataset.table_name]
+        for dataset in REPORT_CATALOG.matrix_datasets
+        if dataset.candidate.accuracy is Accuracy.NLC
+    )
+
+    def assert_alternating(tex: str, span: int) -> None:
+        rows = [line for line in tex.splitlines() if r"\textbf{summary:" in line]
+        patterns = summary_patterns(tex, span)
+        for pattern in patterns:
+            assert pattern == [index % 2 == 0 for index in range(len(pattern))]
+        assert all(
+            not row.startswith(r"\multicolumn{3}{@{}l}{\cellcolor{refblue}")
+            for row in tex.splitlines()
+            if r"\textbf{summary:" in row
+        )
+        assert all(row.endswith(r" \\[0.08em]") for row in rows[::2])
+        assert all(row.endswith(" \\\\") for row in rows[1::2])
+        assert r"\addlinespace[0.08em]" not in tex
+
+        summary_headers = [
+            line
+            for line in tex.splitlines()
+            if line.startswith(r"\multicolumn{3}{@{}l}{} & ") and r"\textbf{n=" in line
+        ]
+        assert len(summary_headers) == len(rows) // 2
+        for header in summary_headers:
+            groups = header.count(r"\textbf{n=")
+            assert groups in (2, 3)
+            assert [
+                cell.startswith(rf"\multicolumn{{{span}}}{{c}}{{\cellcolor{{refblue}}")
+                for cell in header.split(" & ")[1:]
+            ] == [index % 2 == 0 for index in range(groups)]
+
+    assert_alternating(lc_tex, 8)
+    assert_alternating(contracted_tex, 3)
+
+    for accuracy, span in ((Accuracy.LC, 8), (Accuracy.NLC, 3)):
+        best_tex = render_best_mode_table(accuracy, reset_caches)
+        assert_alternating(best_tex, span)
+
+    fixed_block_two_header = next(
+        line
+        for line in lc_tex.splitlines()
+        if line.startswith(r"\multicolumn{3}{@{}l}{} & ") and r"\textbf{n=4}" in line
+    )
+    best_block_two_header = next(
+        line
+        for line in render_best_mode_table(Accuracy.LC, reset_caches).splitlines()
+        if line.startswith(r"\multicolumn{3}{@{}l}{} & ") and r"\textbf{n=4}" in line
+    )
+    expected_block_two_header = (
+        r"\multicolumn{3}{@{}l}{} & "
+        r"\multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=4}} & "
+        r"\multicolumn{8}{c}{\textbf{n=5}} & "
+        r"\multicolumn{8}{c}{\cellcolor{refblue}\textbf{n=6}} \\"
+    )
+    assert fixed_block_two_header == expected_block_two_header
+    assert best_block_two_header == expected_block_two_header
+
+    lc_runtime_summary_label = (
+        r"\matrixsummaryworkloads"
+        r"{\textbf{summary: run single-flow, hel. sum}}"
+        r"{\textbf{summary: run all-flows, single hel.}}"
+    )
+    best_lc_tex = render_best_mode_table(Accuracy.LC, reset_caches)
+    assert lc_runtime_summary_label in lc_tex
+    assert lc_runtime_summary_label in best_lc_tex
+    assert r"\textbf{summary: wall}" not in lc_tex
+    assert r"\textbf{summary: wall}" not in best_lc_tex
+    assert r"\textbf{summary: wall}" in contracted_tex
+
+    for tex in (lc_tex, contracted_tex, best_lc_tex):
+        table_body = "\n".join(
+            line for line in tex.splitlines() if not line.startswith(r"\providecommand")
+        )
+        assert r"\matrixtotalevaluator{" not in table_body
+        assert r"\matrixrecurrencecore{" not in table_body
+
+
+def test_best_mode_summary_selects_wall_winner_per_lc_workload(reset_caches) -> None:
+    caches = copy.deepcopy(reset_caches)
+    reference = _cache_by_dataset(caches, "reference_amplicol_lc")
+    candidates = {
+        mode: _cache_by_dataset(
+            caches,
+            f"matrix_{mode.value}_builtin_sm_lc",
+        )
+        for mode in (
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.COMPILED,
+            ExecutionMode.EAGER,
+        )
+    }
+    for workload in (Workload.SELECTED_FLOW, Workload.ALL_FLOW):
+        _set_ok(
+            reference,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            generation=10.0,
+            wall=10.0e-6,
+            execution=None,
+        )
+    timings = {
+        ExecutionMode.RECURRENCE: (3.0e-6, 4.0e-6),
+        ExecutionMode.COMPILED: (1.0e-6, 2.0e-6),
+        ExecutionMode.EAGER: (2.0e-6, 1.0e-6),
+    }
+    generations = {
+        ExecutionMode.RECURRENCE: 6.0,
+        ExecutionMode.COMPILED: 4.0,
+        ExecutionMode.EAGER: 5.0,
+    }
+    for mode, (selected_wall, all_flow_wall) in timings.items():
+        for workload, wall in (
+            (Workload.SELECTED_FLOW, selected_wall),
+            (Workload.ALL_FLOW, all_flow_wall),
+        ):
+            _set_ok(
+                candidates[mode],
+                process_key="dd_z_jets",
+                n_final=1,
+                workload=workload,
+                generation=generations[mode],
+                wall=wall,
+                execution=wall,
+            )
+
+    adapter = BaselineCandidateAdapter(caches)
+    view = adapter.best_mode_cell(
+        Accuracy.LC,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    assert view.workloads[0].mode is ExecutionMode.COMPILED
+    assert view.workloads[1].mode is ExecutionMode.EAGER
+
+    tex = render_best_mode_table(Accuracy.LC, caches)
+    row = next(line for line in tex.splitlines() if line.startswith(r"\texttt{1}"))
+    runtime_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r" &  & \textcolor{ReportMuted}{\scriptsize run")
+    )
+    assert (
+        r"\textcolor{ReportMuted}{\scriptsize gen. [s]}"
+        r" & \texttt{10.0} & \matrixpunct{|} & \texttt{10.0} & "
+        r"\bestmodecodeprefix{c} & "
+        r"\bestmoderatio{ReportGreen}{0.400} & "
+        r"\matrixpunct{|} & "
+        r"\bestmodeabsoluteprefix{\texttt{5.00}} & "
+        r"\bestmodecode{e}"
+    ) in row
+    assert runtime_row.count(r" &  & \bestmodewallratio{ReportGreen}{0.100}") == 2
+    assert r"\bestmodeopenprefix" not in runtime_row
+    assert r"\bestmodecode" not in runtime_row
+    assert (
+        r"\providecommand{\bestmodecompactprefix}[1]{"
+        r"\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}"
+        r"\hspace{0.04in}}"
+    ) in tex
+    assert (
+        r"\providecommand{\bestmodemix}[1]{"
+        r"\textcolor{ReportBlue}{\texttt{[#1]}}}"
+    ) in tex
+    assert (
+        r"\providecommand{\matrixsummaryfont}{"
+        r"\fontsize{6.2pt}{7.4pt}\selectfont}"
+    ) in tex
+    assert r"\setlength{\fboxsep}{0.9pt}" in tex
+    assert r"\setlength{\fboxrule}{0.35pt}" in tex
+    assert r"\usefont{T1}{lmtt}{b}{n}x#2" in tex
+    assert r">{\matrixentryfontlc}r@{}>{\matrixentryfontlc}l" in tex
+    assert (
+        r"\textbf{metric} & \multicolumn{8}"
+        r"{c}{\textbf{n=1}}"
+    ) in tex
+    assert r"\matrixcolumnheading" not in tex
+    assert r"\shortstack{\textbf{n=" not in tex
+    assert r"\bestmodecodeprefix{c}" in row
+    assert r"\bestmodecode{e}" in row
+    assert r"\matrixtotalevaluator{" not in row
+    assert r"\matrixrecurrencecore{" not in row
+    generation_summary = next(
+        line for line in tex.splitlines() if r"\textbf{summary: generation}" in line
+    )
+    summary_header = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r"\multicolumn{3}{@{}l}{} & ") and r"\bestmodemix{" in line
+    )
+    assert (
+        r"\textbf{n=1}\hspace{0.08in}\bestmodemix{r:0|c:1|e:0|o:0}"
+        in summary_header
+    )
+    assert summary_header.count(r"\bestmodemix{") == 1
+    assert r"r:0|c:0|e:1" not in summary_header
+    assert r"\bestmodemix{" not in generation_summary
+    assert r"\bestmodesummarystats" not in tex
+    assert generation_summary.count(r"\matrixsummaryratio{ReportGreen}{0.400}") == 4
+    assert (
+        generation_summary.count(r"\matrixsummaryratiohighlight{ReportGreen}{0.400}")
+        == 1
+    )
+    assert r"\texttt{10.0}" not in generation_summary
+    assert r"\texttt{5.00}" not in generation_summary
+
+
+@pytest.mark.parametrize(
+    ("accuracy", "expected_mode_counts"),
+    (
+        (
+            Accuracy.LC,
+            (
+                "r:2|c:0|e:0|o:0",
+                "r:8|c:0|e:0|o:0",
+                "r:9|c:0|e:0|o:0",
+                "r:14|c:0|e:0|o:0",
+                "r:14|c:0|e:0|o:0",
+                "r:14|c:0|e:0|o:0",
+                "r:14|c:0|e:0|o:0",
+                "r:14|c:0|e:0|o:0",
+                "r:14|c:0|e:0|o:0",
+            ),
+        ),
+        (
+            Accuracy.NLC,
+            (
+                "r:2|c:0|e:0|o:0",
+                "r:8|c:0|e:0|o:0",
+                "r:9|c:0|e:0|o:0",
+                "r:14|c:0|e:0|o:0",
+                "r:14|c:0|e:0|o:0",
+                "r:2|c:0|e:0|o:0",
+            ),
+        ),
+        (
+            Accuracy.FULL,
+            (
+                "r:2|c:0|e:0|o:0",
+                "r:8|c:0|e:0|o:0",
+                "r:9|c:0|e:0|o:0",
+                "r:14|c:0|e:0|o:0",
+                "r:14|c:0|e:0|o:0",
+                "r:2|c:0|e:0|o:0",
+            ),
+        ),
+    ),
+)
+def test_best_mode_summary_headers_hold_one_exact_mode_mix_per_populated_group(
+    reset_caches: dict[str, dict[str, object]],
+    accuracy: Accuracy,
+    expected_mode_counts: tuple[str, ...],
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _fill_visible_scope(caches, max_n_final=9)
+
+    populated_tex = render_best_mode_table(accuracy, caches)
+    populated_headers = tuple(
+        line
+        for line in populated_tex.splitlines()
+        if line.startswith(r"\multicolumn{3}{@{}l}{} & ") and r"\textbf{n=" in line
+    )
+    populated_body = "\n".join(
+        line
+        for line in populated_tex.splitlines()
+        if not line.startswith(r"\providecommand")
+    )
+    assert (
+        tuple(
+            token
+            for header in populated_headers
+            for token in re.findall(r"\\bestmodemix\{([^}]*)\}", header)
+        )
+        == expected_mode_counts
+    )
+    assert all(
+        header.count(r"\bestmodemix{") == header.count(r"\textbf{n=")
+        for header in populated_headers
+    )
+    assert populated_body.count(r"\bestmodemix{") == len(expected_mode_counts)
+    assert all(
+        r"\bestmodemix{" not in line
+        for line in populated_tex.splitlines()
+        if r"\textbf{summary:" in line
+    )
+    assert r"\bestmodesummarystats" not in populated_tex
+
+    blank_tex = render_best_mode_table(accuracy, reset_caches)
+    blank_headers = tuple(
+        line
+        for line in blank_tex.splitlines()
+        if line.startswith(r"\multicolumn{3}{@{}l}{} & ") and r"\textbf{n=" in line
+    )
+    blank_body = "\n".join(
+        line
+        for line in blank_tex.splitlines()
+        if not line.startswith(r"\providecommand")
+    )
+    assert sum(header.count(r"\textbf{n=") for header in blank_headers) == len(
+        expected_mode_counts
+    )
+    assert r"\bestmodemix{" not in blank_body
+    assert r"\bestmodesummarystats" not in blank_tex
+
+
+def test_ratio_summary_reports_five_exact_statistics_without_absolute_times() -> None:
+    summary = report_render._ratio_statistics_tex(((1.0, 1.0), (3.0, 9.0)))
+
+    assert summary == (
+        r"\matrixsummarystats{"
+        r"\matrixsummaryratio{ReportOrange}{1.00}}{"
+        r"\matrixsummaryratio{ReportRed}{3.00}}{"
+        r"\matrixsummaryratio{ReportRed}{2.00}}{"
+        r"\matrixsummaryratio{ReportRed}{2.00}}{"
+        r"\matrixsummaryratiohighlight{ReportRed}{2.50}}"
+    )
+    assert r"\texttt{" not in summary
+
+
+def test_summary_statistics_share_fixed_anchors_and_compact_notes(
+    reset_caches,
+) -> None:
+    fixed_tex = render_matrix_table(
+        next(
+            dataset
+            for dataset in REPORT_CATALOG.matrix_datasets
+            if dataset.candidate.accuracy is Accuracy.LC
+        ),
+        reset_caches,
+    )
+    best_tex = render_best_mode_table(Accuracy.LC, reset_caches)
+    summary_tables = tuple(
+        tex
+        for tex in render_all_tables(reset_caches).values()
+        if r"\providecommand{\matrixsummarystats}" in tex
+    )
+    separator = r"@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}"
+    summary_column_layout = (
+        r"\begin{tabular}[t]{@{}l"
+        + separator
+        + "l"
+        + separator
+        + "l"
+        + separator
+        + "l"
+        + separator
+        + r"l@{}}"
+    )
+    fixed_slot_layout = (
+        r"\makebox[3.6em][l]{#1}&"
+        r"\makebox[4.6em][l]{#2}&"
+        r"\makebox[3.6em][l]{#3}&"
+        r"\makebox[3.6em][l]{#4}&"
+        r"\makebox[4.2em][l]{#5}"
+    )
+
+    assert len(summary_tables) == 26
+    for tex in summary_tables:
+        assert summary_column_layout in tex
+        assert fixed_slot_layout in tex
+        assert r"\makebox[3.6em][r]" not in tex
+        assert r"\makebox[4.6em][r]" not in tex
+        assert r"\makebox[4.2em][r]" not in tex
+
+    for tex in (fixed_tex, best_tex):
+        assert r"\ReportTableNote{{\scriptsize " in tex
+        assert "Every displayed number uses exactly three significant digits" in tex
+        assert "weighted-average order" in tex
+        assert "weighted average" in tex
+        assert "framed bold entry" in tex
+
+    assert "Fixed-engine tables intentionally omit mode letters" in fixed_tex
+    assert "selected independently in each cell and workload" in best_tex
+    assert "Summary mode counts use r|c|e|o" in best_tex
+
+
+def test_lc_summaries_omit_union_generation_and_keep_both_wall_workloads(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_lc",
+    )
+    candidate = _cache_by_dataset(
+        caches,
+        "matrix_compiled_builtin_sm_lc",
+    )
+    selected_pairs = ((1.0, 1.0), (3.0, 9.0))
+    union_pairs = ((2.0, 20.0), (4.0, 80.0))
+    for process_key, selected, union in zip(
+        ("dd_z_jets", "ud_w_jets"),
+        selected_pairs,
+        union_pairs,
+        strict=True,
+    ):
+        for workload, (baseline_value, candidate_value) in (
+            (Workload.SELECTED_FLOW, selected),
+            (Workload.ALL_FLOW, union),
+        ):
+            _set_ok(
+                baseline,
+                process_key=process_key,
+                n_final=1,
+                workload=workload,
+                generation=baseline_value,
+                wall=baseline_value,
+                execution=baseline_value,
+            )
+            _set_ok(
+                candidate,
+                process_key=process_key,
+                n_final=1,
+                workload=workload,
+                generation=candidate_value,
+                wall=candidate_value,
+                execution=candidate_value,
+            )
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_compiled_builtin_sm_lc"),
+        caches,
+    )
+    generation_summary = next(
+        line for line in tex.splitlines() if r"\textbf{summary: generation}" in line
+    )
+    wall_summary = next(
+        line
+        for line in tex.splitlines()
+        if r"\textbf{summary: run single-flow, hel. sum}" in line
+    )
+    selected_stats = report_render._ratio_statistics_tex(selected_pairs)
+    union_stats = report_render._ratio_statistics_tex(union_pairs)
+
+    assert selected_stats in generation_summary
+    assert union_stats not in generation_summary
+    assert r"\matrixsummaryworkloads" not in generation_summary
+    assert rf"\matrixsummaryworkloads{{{selected_stats}}}{{{union_stats}}}" in (
+        wall_summary
+    )
+    assert (
+        r"\matrixsummaryworkloads"
+        r"{\textbf{summary: run single-flow, hel. sum}}"
+        r"{\textbf{summary: run all-flows, single hel.}}"
+    ) in wall_summary
+    assert r"\textbf{summary: wall}" not in tex
+    assert r"\matrixsummarypair" not in generation_summary
+    assert r"\matrixsummarypair" not in wall_summary
+
+
+def test_best_mode_summary_tie_breaks_in_documented_mode_order(reset_caches) -> None:
+    caches = copy.deepcopy(reset_caches)
+    for workload in (Workload.SELECTED_FLOW, Workload.ALL_FLOW):
+        _set_ok(
+            _cache_by_dataset(caches, "reference_amplicol_lc"),
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            generation=10.0,
+            wall=10.0e-6,
+            execution=None,
+        )
+        for mode in (
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.COMPILED,
+            ExecutionMode.EAGER,
+        ):
+            _set_ok(
+                _cache_by_dataset(
+                    caches,
+                    f"matrix_{mode.value}_builtin_sm_lc",
+                ),
+                process_key="dd_z_jets",
+                n_final=1,
+                workload=workload,
+                generation=5.0,
+                wall=1.0e-6,
+                execution=1.0e-6,
+            )
+
+    view = BaselineCandidateAdapter(caches).best_mode_cell(
+        Accuracy.LC,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    assert {item.mode for item in view.workloads} == {ExecutionMode.RECURRENCE}
+    rendered = render_all_best_mode_tables(caches)
+    assert list(rendered) == [
+        "result_matrix_best_builtin_sm_lc_table.tex",
+        "result_matrix_best_builtin_sm_nlc_table.tex",
+        "result_matrix_best_builtin_sm_full_table.tex",
+    ]
+
+
+@pytest.mark.parametrize(
+    ("outcome", "label"),
+    (
+        ("error", "error"),
+        ("validation_failed", "validation failed"),
+        ("blocked_dependency", "blocked dependency"),
+        ("dependency_backend_error", "dependency backend error"),
+    ),
+)
+def test_fixed_matrix_renders_generic_presentation_outcomes(
+    reset_caches,
+    outcome: str,
+    label: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _set_presentation_outcome(
+        _cache_by_dataset(caches, "matrix_compiled_builtin_sm_nlc"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        outcome=outcome,
+    )
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_compiled_builtin_sm_nlc"),
+        caches,
+    )
+    display = report_render._compact_terminal_display(
+        report_render._TerminalOutcome(
+            identity=f"presentation:{outcome}",
+            label=label,
+            color="ReportRed",
+        )
+    )
+    marker = rf"\matrixstatus{{ReportRed}}{{{display}}}"
+
+    assert tex.count(marker) == 2
+    assert "ManualCampaignOutcome" not in tex
+    if outcome == "blocked_dependency":
+        assert display == "blocked dep."
+        assert label not in tex
+    if outcome == "dependency_backend_error":
+        assert display == "depe back erro"
+        assert label not in tex
+    if "_" in outcome:
+        assert outcome not in tex
+
+
+def test_fixed_matrix_keeps_policy_like_presentation_outcomes_orange(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    candidate = _cache_by_dataset(caches, "matrix_compiled_builtin_sm_nlc")
+    _set_presentation_outcome(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        outcome="generation_limit",
+        label=">1h",
+    )
+    _set_presentation_outcome(
+        candidate,
+        process_key="ud_w_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        outcome="error",
+    )
+    _set_presentation_outcome(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=2,
+        workload=Workload.CONTRACTED,
+        outcome="resource_frontier",
+    )
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_compiled_builtin_sm_nlc"),
+        caches,
+    )
+
+    assert tex.count(r"\matrixstatus{ReportOrange}{>1h}") == 2
+    assert tex.count(r"\matrixstatus{ReportRed}{error}") == 2
+    assert tex.count(r"\matrixstatus{ReportOrange}{resource frontier}") == 2
+    assert r"\matrixstatus{ReportRed}{>1h}" not in tex
+    assert r"\matrixstatus{ReportOrange}{error}" not in tex
+
+
+@pytest.mark.parametrize(
+    "label",
+    (
+        "W" * 64,
+        "W" * 12,
+        "W" * 11 + " " + "W" * 11,
+        "w" * 12 + " " + "w" * 11,
+        "Q" * 12 + " " + "Q" * 11,
+        "O" * 12 + " " + "O" * 11,
+    ),
+)
+def test_fixed_matrix_compacts_one_worst_case_wide_future_label(
+    reset_caches,
+    label: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    candidate = _cache_by_dataset(caches, "matrix_compiled_builtin_sm_nlc")
+    _set_presentation_outcome(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        outcome="future_wide_status",
+        label=label,
+    )
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_compiled_builtin_sm_nlc"),
+        caches,
+    )
+    display = report_render._compact_terminal_display(
+        report_render._TerminalOutcome(
+            identity="presentation:future_wide_status",
+            label=label,
+            color="ReportRed",
+        )
+    )
+
+    assert display == "futu wide stat"
+    assert tex.count(rf"\matrixstatus{{ReportRed}}{{{display}}}") == 2
+    assert label not in tex
+
+
+def test_known_error_slug_does_not_exempt_a_wide_mismatched_label() -> None:
+    label = "W" * 64
+    display = report_render._compact_terminal_display(
+        report_render._TerminalOutcome(
+            identity="presentation:error",
+            label=label,
+            color="ReportRed",
+        )
+    )
+
+    assert display == "error"
+
+
+def test_policy_slug_does_not_exempt_an_unrealistically_wide_cap_label() -> None:
+    label = ">" + "9" * 60 + "GB"
+    display = report_render._compact_terminal_display(
+        report_render._TerminalOutcome(
+            identity="presentation:memory_limit",
+            label=label,
+            color="ReportOrange",
+        )
+    )
+
+    assert display == "memo limi"
+
+
+def test_policy_slug_compacts_a_too_wide_otherwise_valid_cap_label() -> None:
+    display = report_render._compact_terminal_display(
+        report_render._TerminalOutcome(
+            identity="presentation:dependency",
+            label="dependency >9999.9999s",
+            color="ReportOrange",
+        )
+    )
+
+    assert display == "dependency"
+
+
+def test_authenticated_policy_state_keeps_semantics_for_an_overwide_cap() -> None:
+    display = report_render._compact_terminal_display(
+        report_render._TerminalOutcome(
+            identity="policy:dependency",
+            label="dependency >9999.9999s",
+            color="ReportOrange",
+        )
+    )
+
+    assert display == "dependency"
+
+
+@pytest.mark.parametrize(
+    ("outcome", "label"),
+    (
+        ("error", "error"),
+        ("validation_failed", "validation failed"),
+        ("blocked_dependency", "blocked dependency"),
+        ("dependency_backend_error", "dependency backend error"),
+    ),
+)
+def test_best_mode_renders_failure_only_generic_presentation_outcomes(
+    reset_caches,
+    outcome: str,
+    label: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _set_best_mode_nlc_reference(caches)
+    for mode in ExecutionMode.RECURRENCE, ExecutionMode.COMPILED, ExecutionMode.EAGER:
+        _set_presentation_outcome(
+            _cache_by_dataset(
+                caches,
+                f"matrix_{mode.value}_builtin_sm_nlc",
+            ),
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.CONTRACTED,
+            outcome=outcome,
+        )
+
+    tex = render_best_mode_table(Accuracy.NLC, caches)
+    display = report_render._compact_terminal_display(
+        report_render._TerminalOutcome(
+            identity=f"presentation:{outcome}",
+            label=label,
+            color="ReportRed",
+        )
+    )
+    marker = rf"\matrixstatus{{ReportRed}}{{{display}}}"
+
+    assert tex.count(marker) == 4
+    table_body = "\n".join(
+        line for line in tex.splitlines() if not line.startswith(r"\providecommand")
+    )
+    assert r"\bestmodecode{" not in table_body
+
+
+def test_best_mode_mixed_generic_outcomes_have_deterministic_labels(
+    reset_caches,
+) -> None:
+    assignments = (
+        ("error", "validation_failed", "blocked_dependency"),
+        ("error", "blocked_dependency", "validation_failed"),
+    )
+    rendered_tables: list[str] = []
+    for outcomes in assignments:
+        caches = copy.deepcopy(reset_caches)
+        _set_best_mode_nlc_reference(caches)
+        for mode, outcome in zip(
+            (
+                ExecutionMode.RECURRENCE,
+                ExecutionMode.COMPILED,
+                ExecutionMode.EAGER,
+            ),
+            outcomes,
+            strict=True,
+        ):
+            _set_presentation_outcome(
+                _cache_by_dataset(
+                    caches,
+                    f"matrix_{mode.value.replace('-', '_')}_builtin_sm_nlc",
+                ),
+                process_key="dd_z_jets",
+                n_final=1,
+                workload=Workload.CONTRACTED,
+                outcome=outcome,
+            )
+
+        tex = render_best_mode_table(Accuracy.NLC, caches)
+        view = BaselineCandidateAdapter(caches).best_mode_cell(
+            Accuracy.NLC,
+            REPORT_CATALOG.process_families[0],
+            1,
+        )
+        joined = view.workloads[0]
+        marker = r"\matrixstatus{ReportRed}{error}"
+
+        assert tex.count(marker) == 4
+        assert joined.mode is ExecutionMode.RECURRENCE
+        assert joined.terminal_label is None
+        assert r"\bestmodecodeprefix{r}" in tex
+        assert r"\matrixstatus{ReportRed}{validation failed}" not in tex
+        assert r"\matrixstatus{ReportRed}{blocked dep.}" not in tex
+        rendered_tables.append(tex)
+
+    assert rendered_tables[0] == rendered_tables[1]
+
+
+def test_best_mode_compacts_three_maximum_length_future_outcomes(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _set_best_mode_nlc_reference(caches)
+    outcomes = (
+        ("future_alpha", "alpha_" + "a" * 58),
+        ("future_bravo", "bravo&" + "b" * 58),
+        ("future_charlie", "charl%" + "c" * 58),
+    )
+    assert all(len(label) == 64 for _outcome, label in outcomes)
+    for mode, (outcome, label) in zip(
+        (
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.COMPILED,
+            ExecutionMode.EAGER,
+        ),
+        outcomes,
+        strict=True,
+    ):
+        _set_presentation_outcome(
+            _cache_by_dataset(
+                caches,
+                f"matrix_{mode.value}_builtin_sm_nlc",
+            ),
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.CONTRACTED,
+            outcome=outcome,
+            label=label,
+        )
+
+    view = BaselineCandidateAdapter(caches).best_mode_cell(
+        Accuracy.NLC,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    joined = view.workloads[0]
+    assert joined.mode is ExecutionMode.RECURRENCE
+    assert joined.terminal_label is None
+
+    tex = render_best_mode_table(Accuracy.NLC, caches)
+    marker = r"\matrixstatus{ReportRed}{futu alph}"
+    assert tex.count(marker) == 4
+    assert r"\bestmodecodeprefix{r}" in tex
+    assert all(label not in tex for _outcome, label in outcomes)
+
+
+def test_best_mode_many_unique_outcomes_have_one_hard_bounded_identity() -> None:
+    outcomes = tuple(
+        report_render._TerminalOutcome(
+            identity=f"presentation:future_{index:02d}",
+            label=f"future outcome {index:02d}",
+            color="ReportRed",
+        )
+        for index in range(12)
+    )
+
+    summary = report_render._canonical_best_mode_terminal_label(outcomes)
+    reversed_summary = report_render._canonical_best_mode_terminal_label(
+        tuple(reversed(outcomes))
+    )
+
+    assert summary is not None
+    assert reversed_summary is not None
+    assert summary.outcomes == reversed_summary.outcomes
+    assert summary.label == reversed_summary.label
+    assert len(summary.label) <= 48
+    assert re.fullmatch(r"12 outcomes \[[0-9a-f]{6}\]", summary.label)
+    assert {item.identity for item in summary.outcomes} == {
+        item.identity for item in outcomes
+    }
+    assert re.fullmatch(
+        r"N out\.\[[0-9a-f]{6}\]",
+        report_render._compact_terminal_summary_display(summary),
+    )
+
+
+@pytest.mark.parametrize("count", (12, 1796))
+def test_best_mode_outcome_count_display_has_fixed_width(count: int) -> None:
+    outcome = report_render._TerminalOutcome(
+        identity="presentation:error",
+        label="error",
+        color="ReportRed",
+    )
+    summary = report_render._TerminalSummary(
+        outcomes=(outcome, outcome),
+        label=f"{count} outcomes [abcdef]",
+        color="ReportRed",
+    )
+
+    assert report_render._compact_terminal_summary_display(summary) == (
+        "N out.[abcdef]"
+    )
+
+
+def test_best_mode_success_wins_over_generic_presentation_outcomes(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _set_best_mode_nlc_reference(caches)
+    _set_presentation_outcome(
+        _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_nlc"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        outcome="error",
+    )
+    _set_ok(
+        _cache_by_dataset(caches, "matrix_compiled_builtin_sm_nlc"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=1.0e-6,
+        execution=1.0e-6,
+    )
+    _set_presentation_outcome(
+        _cache_by_dataset(caches, "matrix_eager_builtin_sm_nlc"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        outcome="blocked_dependency",
+    )
+
+    view = BaselineCandidateAdapter(caches).best_mode_cell(
+        Accuracy.NLC,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    assert view.workloads[0].mode is ExecutionMode.COMPILED
+
+    tex = render_best_mode_table(Accuracy.NLC, caches)
+    generation_row = next(
+        line for line in tex.splitlines() if line.startswith(r"\texttt{1}")
+    )
+    runtime_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r" &  & \textcolor{ReportMuted}{\scriptsize run")
+    )
+
+    assert r"\bestmodecode{c}" in generation_row
+    assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" in generation_row
+    assert r"\bestmodeabsoluteprefix{\texttt{1.00}}" in runtime_row
+    assert r"\bestmoderatio{" not in generation_row
+    assert r"\bestmodewallratio{" not in runtime_row
+    assert r"\bestmodemix{r:0|c:1|e:0}" not in tex
+    assert r"\matrixstatus{ReportRed}{error}" not in tex
+    assert r"\matrixstatus{ReportRed}{blocked dependency}" not in tex
+
+
+def test_best_mode_uses_an_exact_equivalent_z_success_over_a_matrix_cap(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _set_ok(
+        _cache_by_dataset(caches, "reference_amplicol_lc"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=10.0,
+        wall=10.0e-6,
+        execution=None,
+    )
+    for mode in (ExecutionMode.RECURRENCE, ExecutionMode.COMPILED):
+        entry = _entry(
+            _cache_by_dataset(caches, f"matrix_{mode.value}_builtin_sm_lc"),
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.SELECTED_FLOW,
+        )
+        entry["measurement"] = _memory_censor(
+            REPORT_CATALOG.cell(str(entry["cell_id"]))
+        )
+    _set_ok(
+        _cache_by_dataset(caches, "z_builtin_sm"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        variant="recurrence_jit_o2",
+        generation=7.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+    equivalent_terminal = _entry(
+        _cache_by_dataset(caches, "z_builtin_sm"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.ALL_FLOW,
+        variant="recurrence_jit_o2",
+    )
+    equivalent_terminal["measurement"] = _generation_censor(
+        REPORT_CATALOG.cell(str(equivalent_terminal["cell_id"]))
+    )
+
+    view = BaselineCandidateAdapter(caches).best_mode_cell(
+        Accuracy.LC,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    selected = view.workloads[0]
+    assert selected.mode is ExecutionMode.RECURRENCE
+    assert selected.candidate["status"] == ResultStatus.OK.value
+    assert selected.candidate["wall_seconds_per_point"] == 2.0e-6
+    assert selected.comparison_linked
+    all_flow = view.workloads[1]
+    assert all_flow.mode is ExecutionMode.RECURRENCE
+    assert all_flow.candidate["status"] == ResultStatus.TIMEOUT.value
+
+    tex = render_best_mode_table(Accuracy.LC, caches)
+    row = next(line for line in tex.splitlines() if line.startswith(r"\texttt{1}"))
+    assert row.count(r"\bestmodecodeprefix{r}") == 2
+    assert r"\matrixstatus{ReportOrange}{>2h}" in row
+    assert r"\matrixstatus{ReportOrange}{>80GB}" not in tex
+
+
+def test_best_mode_prefers_its_owned_success_before_equivalent_success(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _set_ok(
+        _cache_by_dataset(caches, "reference_amplicol_lc"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=10.0,
+        wall=10.0e-6,
+        execution=None,
+    )
+    _set_ok(
+        _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_lc"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=5.0,
+        wall=5.0e-6,
+        execution=4.0e-6,
+    )
+    _set_ok(
+        _cache_by_dataset(caches, "z_builtin_sm"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        variant="recurrence_jit_o2",
+        generation=1.0,
+        wall=0.5e-6,
+        execution=0.4e-6,
+    )
+    _set_ok(
+        _cache_by_dataset(caches, "matrix_compiled_builtin_sm_lc"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=2.0,
+        wall=2.0e-6,
+        execution=1.5e-6,
+    )
+
+    view = BaselineCandidateAdapter(caches).best_mode_cell(
+        Accuracy.LC,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    selected = view.workloads[0]
+    assert selected.mode is ExecutionMode.COMPILED
+    assert selected.candidate["wall_seconds_per_point"] == 2.0e-6
+
+
+def test_best_mode_mixed_policy_censors_fall_back_to_recurrence(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _set_ok(
+        _cache_by_dataset(caches, "reference_amplicol_nlc"),
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=10.0,
+        wall=10.0e-6,
+        execution=None,
+    )
+    candidate_entries = {
+        mode: _entry(
+            _cache_by_dataset(
+                caches,
+                f"matrix_{mode.value}_builtin_sm_nlc",
+            ),
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.CONTRACTED,
+        )
+        for mode in (
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.COMPILED,
+            ExecutionMode.EAGER,
+        )
+    }
+    recurrence_cell = REPORT_CATALOG.cell(
+        str(candidate_entries[ExecutionMode.RECURRENCE]["cell_id"])
+    )
+    recurrence_censor = _generation_censor(recurrence_cell)
+    candidate_entries[ExecutionMode.RECURRENCE]["measurement"] = recurrence_censor
+    compiled_cell = REPORT_CATALOG.cell(
+        str(candidate_entries[ExecutionMode.COMPILED]["cell_id"])
+    )
+    candidate_entries[ExecutionMode.COMPILED]["measurement"] = _memory_censor(
+        compiled_cell
+    )
+    eager_cell = REPORT_CATALOG.cell(
+        str(candidate_entries[ExecutionMode.EAGER]["cell_id"])
+    )
+    candidate_entries[ExecutionMode.EAGER]["measurement"] = policy_censor_measurement(
+        X86_EPYC_POLICY,
+        "x86_EPYC",
+        eager_cell,
+        kind=PolicyCensorKind.DEPENDENCY,
+        source_identity=_POLICY_IDENTITY,
+        resources=None,
+        dependencies=(
+            dependency_reference(
+                recurrence_cell.cell_id,
+                recurrence_censor,
+            ),
+        ),
+    )
+
+    tex = render_best_mode_table(Accuracy.NLC, caches)
+    row = next(line for line in tex.splitlines() if line.startswith(r"\texttt{1}"))
+    runtime_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r" &  & \textcolor{ReportMuted}{\scriptsize run")
+    )
+
+    marker = r"\matrixstatus{ReportOrange}{>2h}"
+    assert marker in row
+    assert marker in runtime_row
+    assert (
+        r">{\matrixentryfont}l"
+        r">{\matrixentryfont}r@{}"
+        r">{\matrixentryfont}l"
+    ) in tex
+    assert r"\bestmodecodeprefix{r}" in row
+    assert r"\matrixstatus{ReportOrange}{>80GB}" not in row
+    assert r"\matrixstatus{ReportOrange}{dependency}" not in row
+    assert r"\matrixna{ReportMuted}" not in row
+
+
+def test_best_mode_mixed_terminal_summaries_are_visibly_complete(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _fill_visible_n4_scope(caches)
+    recurrence = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_nlc",
+    )
+    compiled = _cache_by_dataset(
+        caches,
+        "matrix_compiled_builtin_sm_nlc",
+    )
+    eager = _cache_by_dataset(caches, "matrix_eager_builtin_sm_nlc")
+    on_the_fly = _cache_by_dataset(caches, "matrix_on_the_fly_builtin_sm_nlc")
+    recurrence_entries = recurrence["entries"]
+    assert isinstance(recurrence_entries, list)
+    for recurrence_entry in recurrence_entries:
+        if recurrence_entry["n_final"] != 1:
+            continue
+        process_key = str(recurrence_entry["process_key"])
+        recurrence_cell = REPORT_CATALOG.cell(str(recurrence_entry["cell_id"]))
+        recurrence_censor = _generation_censor(recurrence_cell)
+        recurrence_entry["measurement"] = recurrence_censor
+        compiled_entry = _entry(
+            compiled,
+            process_key=process_key,
+            n_final=1,
+            workload=Workload.CONTRACTED,
+        )
+        compiled_entry["measurement"] = _memory_censor(
+            REPORT_CATALOG.cell(str(compiled_entry["cell_id"]))
+        )
+        eager_entry = _entry(
+            eager,
+            process_key=process_key,
+            n_final=1,
+            workload=Workload.CONTRACTED,
+        )
+        eager_entry["measurement"] = policy_censor_measurement(
+            X86_EPYC_POLICY,
+            "x86_EPYC",
+            REPORT_CATALOG.cell(str(eager_entry["cell_id"])),
+            kind=PolicyCensorKind.DEPENDENCY,
+            source_identity=_POLICY_IDENTITY,
+            resources=None,
+            dependencies=(
+                dependency_reference(
+                    recurrence_cell.cell_id,
+                    recurrence_censor,
+                ),
+            ),
+        )
+        on_the_fly_entry = _entry(
+            on_the_fly,
+            process_key=process_key,
+            n_final=1,
+            workload=Workload.CONTRACTED,
+        )
+        on_the_fly_entry["measurement"] = policy_censor_measurement(
+            X86_EPYC_POLICY,
+            "x86_EPYC",
+            REPORT_CATALOG.cell(str(on_the_fly_entry["cell_id"])),
+            kind=PolicyCensorKind.DEPENDENCY,
+            source_identity=_POLICY_IDENTITY,
+            resources=None,
+            dependencies=(
+                dependency_reference(
+                    recurrence_cell.cell_id,
+                    recurrence_censor,
+                ),
+            ),
+        )
+
+    tex = render_best_mode_table(Accuracy.NLC, caches)
+    generation_summary = next(
+        line for line in tex.splitlines() if r"\textbf{summary: generation}" in line
+    )
+    wall_summary = next(
+        line for line in tex.splitlines() if r"\textbf{summary: wall}" in line
+    )
+    marker = r"\matrixstatus{ReportOrange}{>2h}"
+    assert generation_summary.count(marker) == 1
+    assert wall_summary.count(marker) == 1
+
+    completeness = summarize_visible_completeness(
+        caches,
+        max_n_final=4,
+        policy=X86_EPYC_POLICY,
+    )
+    assert completeness.complete
+    assert not completeness.applicable_na_display_slots
+
+
+def test_best_mode_terminal_baselines_stay_in_rows_but_not_summaries(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _fill_visible_n4_scope(caches)
+    reference = _cache_by_dataset(caches, "reference_amplicol_nlc")
+    entries = reference["entries"]
+    assert isinstance(entries, list)
+    for entry in entries:
+        if entry["n_final"] == 1:
+            entry["measurement"] = _memory_censor(
+                REPORT_CATALOG.cell(str(entry["cell_id"]))
+            )
+
+    tex = render_best_mode_table(Accuracy.NLC, caches)
+    lines = tex.splitlines()
+    row_index = next(
+        index for index, line in enumerate(lines) if line.startswith(r"\texttt{1}")
+    )
+    generation_row = lines[row_index]
+    runtime_row = lines[row_index + 2]
+    marker = r"\matrixstatus{ReportOrange}{>80GB}"
+    assert generation_row.count(marker) == 1
+    assert runtime_row.count(marker) == 1
+    assert r"\bestmodeabsoluteprefix{\texttt{1.00}}" in generation_row
+    assert r"\bestmodecode{r}" in generation_row
+    assert r"\bestmodeabsoluteprefix{\texttt{2.00}}" in runtime_row
+    generation_summary = next(
+        line for line in tex.splitlines() if r"\textbf{summary: generation}" in line
+    )
+    wall_summary = next(
+        line for line in tex.splitlines() if r"\textbf{summary: wall}" in line
+    )
+    assert marker not in generation_summary
+    assert marker not in wall_summary
+    assert r"\matrixna{ReportMuted}" not in generation_row
+    assert r"\matrixna{ReportMuted}" not in runtime_row
+    assert r"\matrixna{ReportMuted}" in generation_summary
+    assert r"\matrixna{ReportMuted}" in wall_summary
+
+
+@pytest.mark.parametrize(
+    ("accuracy", "workloads"),
+    (
+        (Accuracy.LC, (Workload.SELECTED_FLOW, Workload.ALL_FLOW)),
+        (Accuracy.NLC, (Workload.CONTRACTED,)),
+        (Accuracy.FULL, (Workload.CONTRACTED,)),
+    ),
+)
+def test_recurrence_renders_absolute_when_amplicol_baseline_is_terminal(
+    reset_caches,
+    accuracy: Accuracy,
+    workloads: tuple[Workload, ...],
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, f"reference_amplicol_{accuracy.value}")
+    candidate = _cache_by_dataset(
+        caches,
+        f"matrix_recurrence_builtin_sm_{accuracy.value}",
+    )
+    for index, workload in enumerate(workloads):
+        baseline_entry = _entry(
+            baseline,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+        )
+        baseline_entry["measurement"] = _memory_censor(
+            REPORT_CATALOG.cell(str(baseline_entry["cell_id"]))
+        )
+        _set_ok(
+            candidate,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            generation=4.0 + 6.0 * index,
+            wall=(2.0 + index) * 1.0e-6,
+            execution=(1.0 + 0.5 * index) * 1.0e-6,
+        )
+
+    dataset = next(
+        item
+        for item in REPORT_CATALOG.matrix_datasets
+        if item.dataset_id == f"matrix_recurrence_builtin_sm_{accuracy.value}"
+    )
+    marker = r"\matrixstatus{ReportOrange}{>80GB}"
+    for tex, best_mode in (
+        (render_matrix_table(dataset, caches), False),
+        (render_best_mode_table(accuracy, caches), True),
+    ):
+        lines = tex.splitlines()
+        row_index = next(
+            index for index, line in enumerate(lines) if line.startswith(r"\texttt{1}")
+        )
+        generation_row = lines[row_index]
+        runtime_row = lines[row_index + 2]
+        assert generation_row.count(marker) == len(workloads)
+        assert runtime_row.count(marker) == len(workloads)
+        assert generation_row.count(r"\bestmodeabsoluteprefix{") == len(workloads)
+        assert runtime_row.count(r"\bestmodeabsoluteprefix{") == len(workloads)
+        assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" in generation_row
+        assert r"\bestmodeabsoluteprefix{\texttt{2.00}}" in runtime_row
+        assert r"\bestmoderatio{" not in generation_row
+        assert r"\bestmodeprimaryratio{" not in runtime_row
+        if best_mode:
+            assert generation_row.count(r"\bestmodecode{r}") == len(workloads)
+
+    best_tex = render_best_mode_table(accuracy, caches)
+    generation_summary = next(
+        line
+        for line in best_tex.splitlines()
+        if r"\textbf{summary: generation}" in line
+    )
+    wall_summary = next(
+        line
+        for line in best_tex.splitlines()
+        if "summary: run" in line or r"\textbf{summary: wall}" in line
+    )
+    assert marker not in generation_summary
+    assert marker not in wall_summary
+    assert r"\matrixsummarystats{" not in generation_summary
+    assert r"\matrixsummarystats{" not in wall_summary
+    assert r"\matrixna{ReportMuted}" in generation_summary
+    assert r"\matrixna{ReportMuted}" in wall_summary
+
+
+def test_recurrence_renders_absolute_when_amplicol_was_not_run(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    candidate = _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_nlc")
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+    dataset = next(
+        item
+        for item in REPORT_CATALOG.matrix_datasets
+        if item.dataset_id == "matrix_recurrence_builtin_sm_nlc"
+    )
+
+    for tex in (
+        render_matrix_table(dataset, caches),
+        render_best_mode_table(Accuracy.NLC, caches),
+    ):
+        lines = tex.splitlines()
+        row_index = next(
+            index for index, line in enumerate(lines) if line.startswith(r"\texttt{1}")
+        )
+        generation_row = lines[row_index]
+        runtime_row = lines[row_index + 2]
+        assert r"\matrixstatus{ReportMuted}{N/A}" in generation_row
+        assert r"\matrixstatus{ReportMuted}{N/A}" in runtime_row
+        assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" in generation_row
+        assert r"\bestmodeabsoluteprefix{\texttt{2.00}}" in runtime_row
+        assert r"\bestmoderatio{" not in generation_row
+        assert r"\bestmodeprimaryratio{" not in runtime_row
+
+
+def test_later_amplicol_current_does_not_retroactively_link_recurrence(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    recurrence = _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_nlc")
+    reference = _cache_by_dataset(caches, "reference_amplicol_nlc")
+    _set_ok(
+        recurrence,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+    recurrence_measurement = _entry(
+        recurrence,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+    )["measurement"]
+    assert isinstance(recurrence_measurement, dict)
+    validation = recurrence_measurement["validation"]
+    assert isinstance(validation, dict)
+    validation.pop("pointwise")
+    _set_ok(
+        reference,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=10.0,
+        wall=10.0e-6,
+        execution=None,
+    )
+
+    dataset = REPORT_CATALOG.dataset("matrix_recurrence_builtin_sm_nlc")
+    view = BaselineCandidateAdapter(caches).matrix_cell(
+        dataset,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    assert not view.workloads[0].comparison_linked
+    tex = render_matrix_table(dataset, caches)
+    generation_row = next(
+        line for line in tex.splitlines() if line.startswith(r"\texttt{1}")
+    )
+    assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" in generation_row
+    assert r"\bestmoderatio{" not in generation_row
+    generation_summary = next(
+        line for line in tex.splitlines() if r"\textbf{summary: generation}" in line
+    )
+    assert r"\matrixsummarystats{" not in generation_summary
+    assert r"\matrixna{ReportMuted}" in generation_summary
+    assert "unlinked baselines keep their status" in tex
+
+
+@pytest.mark.parametrize("mode", (ExecutionMode.COMPILED, ExecutionMode.EAGER))
+@pytest.mark.parametrize("broken_chain", (False, True))
+def test_best_dag_ratio_requires_exact_transitive_amplicol_link(
+    reset_caches,
+    mode: ExecutionMode,
+    broken_chain: bool,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    reference = _cache_by_dataset(caches, "reference_amplicol_nlc")
+    recurrence = _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_nlc")
+    candidate = _cache_by_dataset(
+        caches,
+        f"matrix_{mode.value}_builtin_sm_nlc",
+    )
+    for cache, generation, wall in (
+        (reference, 10.0, 10.0e-6),
+        (recurrence, 6.0, 3.0e-6),
+        (candidate, 2.0, 1.0e-6),
+    ):
+        _set_ok(
+            cache,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.CONTRACTED,
+            generation=generation,
+            wall=wall,
+            execution=wall,
+        )
+    if broken_chain:
+        recurrence_measurement = _entry(
+            recurrence,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.CONTRACTED,
+        )["measurement"]
+        assert isinstance(recurrence_measurement, dict)
+        validation = recurrence_measurement["validation"]
+        assert isinstance(validation, dict)
+        pointwise = validation["pointwise"]
+        assert isinstance(pointwise, dict)
+        pointwise["baseline"] = 2.0
+
+    view = BaselineCandidateAdapter(caches).best_mode_cell(
+        Accuracy.NLC,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    assert view.workloads[0].mode is mode
+    assert view.workloads[0].comparison_linked is not broken_chain
+    generation_row = next(
+        line
+        for line in render_best_mode_table(Accuracy.NLC, caches).splitlines()
+        if line.startswith(r"\texttt{1}")
+    )
+    if broken_chain:
+        assert r"\bestmodeabsoluteprefix{\texttt{2.00}}" in generation_row
+        assert r"\bestmoderatio{" not in generation_row
+    else:
+        assert r"\bestmoderatio{ReportGreen}{0.200}" in generation_row
+        assert r"\bestmodeabsoluteprefix{\texttt{2.00}}" not in generation_row
+
+
+@pytest.mark.parametrize("broken_selector", (False, True))
+def test_direct_pointwise_link_requires_exact_selector(
+    reset_caches,
+    broken_selector: bool,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    reference = _cache_by_dataset(caches, "reference_amplicol_lc")
+    recurrence = _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_lc")
+    for cache, generation in ((reference, 10.0), (recurrence, 4.0)):
+        _set_ok(
+            cache,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.SELECTED_FLOW,
+            generation=generation,
+            wall=generation * 1.0e-6,
+            execution=1.0e-6,
+        )
+    if broken_selector:
+        measurement = _entry(
+            recurrence,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.SELECTED_FLOW,
+        )["measurement"]
+        assert isinstance(measurement, dict)
+        selector = measurement["selector_contract"]
+        assert isinstance(selector, dict)
+        selector["point_digest"] = "1" * 64
+
+    dataset = REPORT_CATALOG.dataset("matrix_recurrence_builtin_sm_lc")
+    view = BaselineCandidateAdapter(caches).matrix_cell(
+        dataset,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    assert view.workloads[0].comparison_linked is not broken_selector
+    generation_row = next(
+        line
+        for line in render_matrix_table(dataset, caches).splitlines()
+        if line.startswith(r"\texttt{1}")
+    )
+    if broken_selector:
+        assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" in generation_row
+        assert r"\bestmoderatio{" not in generation_row
+    else:
+        assert r"\bestmoderatio{ReportGreen}{0.400}" in generation_row
+
+
+@pytest.mark.parametrize("broken_component", (False, True))
+def test_direct_agreement_link_requires_exact_component_identity(
+    reset_caches,
+    broken_component: bool,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    reference = _cache_by_dataset(caches, "reference_amplicol_lc")
+    recurrence = _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_lc")
+    for cache, generation in ((reference, 10.0), (recurrence, 4.0)):
+        _set_ok(
+            cache,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.ALL_FLOW,
+            generation=generation,
+            wall=generation * 1.0e-6,
+            execution=1.0e-6,
+        )
+    if broken_component:
+        measurement = _entry(
+            recurrence,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.ALL_FLOW,
+        )["measurement"]
+        assert isinstance(measurement, dict)
+        validation = measurement["validation"]
+        assert isinstance(validation, dict)
+        component = validation[LC_COMMON_COMPONENT_FIELD]
+        assert isinstance(component, dict)
+        component["color_flow_ids"] = ["flow:other"]
+
+    dataset = REPORT_CATALOG.dataset("matrix_recurrence_builtin_sm_lc")
+    view = BaselineCandidateAdapter(caches).matrix_cell(
+        dataset,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    assert view.workloads[1].comparison_linked is not broken_component
+    lines = render_matrix_table(dataset, caches).splitlines()
+    row_index = next(
+        index for index, line in enumerate(lines) if line.startswith(r"\texttt{1}")
+    )
+    runtime_row = lines[row_index + 2]
+    if broken_component:
+        assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" in runtime_row
+        assert r"\bestmodeprimaryratio{" not in runtime_row
+    else:
+        assert r"\bestmodeprimaryratio{ReportGreen}{0.400}" in runtime_row
+
+
+def test_direct_agreement_v2_remains_comparison_linked(reset_caches) -> None:
+    caches = copy.deepcopy(reset_caches)
+    reference = _cache_by_dataset(caches, "reference_amplicol_lc")
+    recurrence = _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_lc")
+    for cache, generation in ((reference, 10.0), (recurrence, 4.0)):
+        _set_ok(
+            cache,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.ALL_FLOW,
+            generation=generation,
+            wall=generation * 1.0e-6,
+            execution=1.0e-6,
+        )
+    measurement = _entry(
+        recurrence,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.ALL_FLOW,
+    )["measurement"]
+    assert isinstance(measurement, dict)
+    validation = measurement["validation"]
+    assert isinstance(validation, dict)
+    records = validation["direct_agreements"]
+    assert isinstance(records, list) and records
+    for record in records:
+        assert isinstance(record, dict)
+        comparison = pointwise_validation(
+            float(record["candidate"]),
+            float(record["baseline"]),
+            relative_tolerance=float(record["relative_tolerance"]),
+            comparison_binding={"point_digest": "0" * 64},
+        )
+        comparison.pop("abi")
+        identity = {
+            field: record[field]
+            for field in (
+                "edge_kind",
+                "value_kind",
+                "baseline_cell_id",
+                "candidate_cell_id",
+            )
+        }
+        record.clear()
+        record.update({"abi": DIRECT_AGREEMENT_V2_ABI, **identity, **comparison})
+
+    dataset = REPORT_CATALOG.dataset("matrix_recurrence_builtin_sm_lc")
+    view = BaselineCandidateAdapter(caches).matrix_cell(
+        dataset,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    assert view.workloads[1].comparison_linked
+
+
+@pytest.mark.parametrize("mode", (ExecutionMode.COMPILED, ExecutionMode.EAGER))
+def test_fixed_compiled_and_eager_preserve_terminal_recurrence_baseline(
+    reset_caches,
+    mode: ExecutionMode,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_nlc")
+    candidate = _cache_by_dataset(
+        caches,
+        f"matrix_{mode.value}_builtin_sm_nlc",
+    )
+    baseline_entry = _entry(
+        baseline,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+    )
+    baseline_entry["measurement"] = _memory_censor(
+        REPORT_CATALOG.cell(str(baseline_entry["cell_id"]))
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+    dataset = next(
+        item
+        for item in REPORT_CATALOG.matrix_datasets
+        if item.dataset_id == f"matrix_{mode.value}_builtin_sm_nlc"
+    )
+
+    lines = render_matrix_table(dataset, caches).splitlines()
+    row_index = next(
+        index for index, line in enumerate(lines) if line.startswith(r"\texttt{1}")
+    )
+    marker = r"\matrixstatus{ReportOrange}{>80GB}"
+    assert lines[row_index].count(marker) == 1
+    assert lines[row_index + 2].count(marker) == 1
+    assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" in lines[row_index]
+    assert r"\bestmodeabsoluteprefix{\texttt{2.00}}" in lines[row_index + 2]
+
+
+@pytest.mark.parametrize("mode", (ExecutionMode.COMPILED, ExecutionMode.EAGER))
+def test_fixed_compiled_and_eager_show_unverified_absolute_diagnostic_clocks(
+    reset_caches,
+    mode: ExecutionMode,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_nlc")
+    candidate = _cache_by_dataset(
+        caches,
+        f"matrix_{mode.value}_builtin_sm_nlc",
+    )
+    baseline_entry = _entry(
+        baseline,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+    )
+    baseline_entry["measurement"] = _memory_censor(
+        REPORT_CATALOG.cell(str(baseline_entry["cell_id"]))
+    )
+    _set_unverified(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        evaluator_total=1.0e-6,
+    )
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset(f"matrix_{mode.value}_builtin_sm_nlc"),
+        caches,
+    )
+    lines = tex.splitlines()
+    row_index = next(
+        index for index, line in enumerate(lines) if line.startswith(r"\texttt{1}")
+    )
+    generation_row = lines[row_index]
+    runtime_row = lines[row_index + 2]
+    authority_marker = r"\matrixstatus{ReportOrange}{>80GB}"
+    unverified_marker = r"\matrixstatus{ReportOrange}{unverified}"
+
+    assert generation_row.count(authority_marker) == 1
+    assert runtime_row.count(authority_marker) == 1
+    assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" in generation_row
+    assert unverified_marker in generation_row
+    assert (
+        r"\bestmodeunverifiedclockprefix{\texttt{1.00}}{\texttt{2.00}}" in runtime_row
+    )
+    assert unverified_marker in runtime_row
+    assert "Unverified compiled or eager diagnostics show absolute generation" in tex
+    assert "never enter ratios or summaries" in tex
+
+
+def test_best_mode_never_selects_or_summarizes_unverified_diagnostics(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _set_best_mode_nlc_reference(caches)
+    for mode in ExecutionMode.COMPILED, ExecutionMode.EAGER:
+        _set_unverified(
+            _cache_by_dataset(
+                caches,
+                f"matrix_{mode.value}_builtin_sm_nlc",
+            ),
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.CONTRACTED,
+            generation=4.0,
+            wall=2.0e-6,
+            evaluator_total=1.0e-6,
+        )
+
+    view = BaselineCandidateAdapter(caches).best_mode_cell(
+        Accuracy.NLC,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+    assert view.workloads[0].mode is None
+    assert view.workloads[0].terminal_label is None
+
+    tex = render_best_mode_table(Accuracy.NLC, caches)
+    lines = tex.splitlines()
+    row_index = next(
+        index for index, line in enumerate(lines) if line.startswith(r"\texttt{1}")
+    )
+    marker = r"\matrixstatus{ReportOrange}{unverified}"
+    assert marker not in lines[row_index]
+    assert marker not in lines[row_index + 2]
+    assert r"\bestmodecodeprefix{r}" not in lines[row_index]
+    assert r"\matrixstatus{ReportMuted}{N/A}" in lines[row_index]
+    assert r"\matrixstatus{ReportMuted}{N/A}" in lines[row_index + 2]
+    assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" not in lines[row_index]
+
+    generation_summary = next(
+        line for line in lines if r"\textbf{summary: generation}" in line
+    )
+    wall_summary = next(line for line in lines if r"\textbf{summary: wall}" in line)
+    assert marker not in generation_summary
+    assert marker not in wall_summary
+    assert r"\matrixsummarystats{" not in generation_summary
+    assert r"\matrixsummarystats{" not in wall_summary
+    assert "never eligible for best-mode selection or summaries" in tex
+
+
+def test_presentation_only_unverified_is_fixed_only_and_not_a_best_mode(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    candidate = _cache_by_dataset(caches, "matrix_compiled_builtin_sm_nlc")
+    _set_presentation_outcome(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        outcome="unverified",
+    )
+
+    fixed = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_compiled_builtin_sm_nlc"),
+        caches,
+    )
+    best = render_best_mode_table(Accuracy.NLC, caches)
+    marker = r"\matrixstatus{ReportOrange}{unverified}"
+    red_marker = r"\matrixstatus{ReportRed}{unverified}"
+
+    assert marker in fixed
+    assert marker not in best
+    assert red_marker not in fixed
+    assert red_marker not in best
+
+
+@pytest.mark.parametrize(
+    ("mode", "code"),
+    ((ExecutionMode.COMPILED, "c"), (ExecutionMode.EAGER, "e")),
+)
+def test_best_compiled_and_eager_render_absolute_without_amplicol_baseline(
+    reset_caches,
+    mode: ExecutionMode,
+    code: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    candidate = _cache_by_dataset(
+        caches,
+        f"matrix_{mode.value}_builtin_sm_nlc",
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+
+    lines = render_best_mode_table(Accuracy.NLC, caches).splitlines()
+    row_index = next(
+        index for index, line in enumerate(lines) if line.startswith(r"\texttt{1}")
+    )
+    assert r"\matrixstatus{ReportMuted}{N/A}" in lines[row_index]
+    assert r"\matrixstatus{ReportMuted}{N/A}" in lines[row_index + 2]
+    assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" in lines[row_index]
+    assert rf"\bestmodecode{{{code}}}" in lines[row_index]
+    assert r"\bestmodeabsoluteprefix{\texttt{2.00}}" in lines[row_index + 2]
+    assert r"\bestmoderatio{" not in lines[row_index]
+    assert r"\bestmodeprimaryratio{" not in lines[row_index + 2]
+
+
+@pytest.mark.parametrize(
+    ("variant", "setup", "execution_mode"),
+    (
+        ("recurrence_jit_o2", "recurrence JIT O2", "recurrence"),
+        ("jit_o3", "compiled JIT O3", "compiled"),
+        ("eager_jit_o2", "eager-DAG JIT O2", "eager"),
+    ),
+)
+def test_z_pyamplicol_renders_all_clocks_absolute_without_amplicol_baseline(
+    reset_caches,
+    variant: str,
+    setup: str,
+    execution_mode: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "reference_amplicol_lc")
+    candidate = _cache_by_dataset(caches, "z_builtin_sm")
+    for index, workload in enumerate((Workload.SELECTED_FLOW, Workload.ALL_FLOW)):
+        baseline_entry = _entry(
+            baseline,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+        )
+        baseline_entry["measurement"] = _memory_censor(
+            REPORT_CATALOG.cell(str(baseline_entry["cell_id"]))
+        )
+        _set_ok(
+            candidate,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            generation=4.0 + 6.0 * index,
+            wall=(2.0 + index) * 1.0e-6,
+            execution=(1.0 + 0.5 * index) * 1.0e-6,
+            variant=variant,
+        )
+        candidate_entry = _entry(
+            candidate,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            variant=variant,
+        )
+        measurement = candidate_entry["measurement"]
+        assert isinstance(measurement, dict)
+        _mark_evaluator_total(
+            measurement,
+            execution_mode=execution_mode,
+            total=(1.7 + index) * 1.0e-6,
+        )
+
+    tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+    reference_row = next(
+        line for line in tex.splitlines() if line.startswith(r"1 & \AC{} reference")
+    )
+    candidate_row = next(
+        line for line in tex.splitlines() if line.startswith(f"1 & {setup}")
+    )
+    assert reference_row.count(r"\matrixstatus{ReportOrange}{>80GB}") == 4
+    assert candidate_row.count(r"\matrixncabsolute{") == 6
+    assert r"\matrixratio{" not in candidate_row
+    assert r"\matrixnaratio{" not in candidate_row
+    assert "successful pyAmpliCol values are absolute" in tex
+
+
+@pytest.mark.parametrize(
+    ("variant", "setup", "execution_mode"),
+    (
+        ("jit_o3", "compiled JIT O3", ExecutionMode.COMPILED),
+        ("eager_jit_o2", "eager-DAG JIT O2", ExecutionMode.EAGER),
+    ),
+)
+@pytest.mark.parametrize("broken_chain", (False, True))
+def test_z_dag_ratio_accepts_only_exact_recurrence_to_amplicol_chain(
+    reset_caches,
+    variant: str,
+    setup: str,
+    execution_mode: ExecutionMode,
+    broken_chain: bool,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    reference = _cache_by_dataset(caches, "reference_amplicol_lc")
+    z_cache = _cache_by_dataset(caches, "z_builtin_sm")
+    _set_ok(
+        reference,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=10.0,
+        wall=10.0e-6,
+        execution=None,
+    )
+    _set_ok(
+        z_cache,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=6.0,
+        wall=3.0e-6,
+        execution=2.0e-6,
+        variant="recurrence_jit_o2",
+    )
+    _set_ok(
+        z_cache,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=2.0,
+        wall=1.0e-6,
+        execution=0.8e-6,
+        variant=variant,
+    )
+    candidate = _entry(
+        z_cache,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        variant=variant,
+    )["measurement"]
+    recurrence = _entry(
+        z_cache,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        variant="recurrence_jit_o2",
+    )["measurement"]
+    assert isinstance(candidate, dict)
+    assert isinstance(recurrence, dict)
+    candidate_validation = candidate["validation"]
+    recurrence_validation = recurrence["validation"]
+    assert isinstance(candidate_validation, dict)
+    assert isinstance(recurrence_validation, dict)
+    assert isinstance(candidate_validation.get("pointwise"), dict)
+    if broken_chain:
+        recurrence_pointwise = recurrence_validation["pointwise"]
+        assert isinstance(recurrence_pointwise, dict)
+        recurrence_pointwise["baseline"] = 2.0
+
+    z_variant = next(item for item in REPORT_CATALOG.z_variants if item.key == variant)
+    joined = BaselineCandidateAdapter(caches).z_workload(
+        model=ModelKey.BUILTIN_SM,
+        n_final=1,
+        variant=z_variant,
+        workload=Workload.SELECTED_FLOW,
+    )
+    assert z_variant.execution_mode is execution_mode
+    assert joined.comparison_linked is not broken_chain
+    candidate_row = next(
+        line
+        for line in render_z_ladder(ModelKey.BUILTIN_SM, caches).splitlines()
+        if line.startswith(f"1 & {setup}")
+    )
+    if broken_chain:
+        assert candidate_row.startswith(
+            f"1 & {setup} & \\matrixncabsolute{{\\texttt{{2}}}}"
+        )
+        assert r"\matrixratio{" not in candidate_row
+    else:
+        assert r"\matrixratio{ReportGreen}{0.2}" in candidate_row
+
+
+def test_best_mode_missing_candidates_remain_incomplete_under_strict_policy(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _fill_visible_n4_scope(caches)
+    for mode in (
+        ExecutionMode.RECURRENCE,
+        ExecutionMode.COMPILED,
+        ExecutionMode.EAGER,
+        ExecutionMode.ON_THE_FLY,
+    ):
+        entry = _entry(
+            _cache_by_dataset(
+                caches,
+                f"matrix_{mode.value.replace('-', '_')}_builtin_sm_nlc",
+            ),
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.CONTRACTED,
+        )
+        entry["measurement"] = empty_measurement()
+
+    completeness = summarize_visible_completeness(
+        caches,
+        max_n_final=4,
+    )
+
+    assert not completeness.complete
+    assert any(
+        "result_matrix_best_builtin_sm_nlc_table.tex/n1/dd_z_jets/contracted" in slot
+        for slot in completeness.applicable_na_display_slots
+    )
+
+
+def test_matrix_baseline_labels_follow_dataset_contract(reset_caches) -> None:
+    rendered = render_all_matrix_tables(reset_caches)
+
+    for dataset in REPORT_CATALOG.matrix_datasets:
+        if dataset.table_name not in rendered:
+            continue
+        tex = rendered[dataset.table_name]
+        if dataset.candidate.execution_mode in {
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.ON_THE_FLY,
+        }:
+            assert "Baseline: original AmpliCol" in tex
+        else:
+            assert "Baseline: recurrence JIT O2" in tex
+        assert dataset.title in tex
+    for view in MADGRAPH_FULL_COMPARISON_VIEWS:
+        tex = rendered[view.table_name]
+        assert "Baseline: MadGraph standalone" in tex
+        assert view.title in tex
+
+
+def test_matrix_tables_are_fixed_nonsplittable_blocks(reset_caches) -> None:
+    rendered = render_all_matrix_tables(reset_caches)
+
+    for tex in rendered.values():
+        assert "longtable" not in tex
+        assert r"\begin{minipage}{\linewidth}" in tex
+        assert r"\end{minipage}" in tex
+        assert tex.count(r"\begin{minipage}{\linewidth}") == tex.count(
+            r"\end{minipage}"
+        )
+        assert tex.count(r"\clearpage") == tex.count(r"\begin{minipage}{\linewidth}")
+        assert r"\begin{tabular}" in tex
+        assert r"\ifdim\wd0>\linewidth" in tex
+        assert r"\resizebox{\linewidth}{!}{\usebox0}" in tex
+        assert tex.count(r"\matrixfitwidth{%") == tex.count(
+            r"\begin{minipage}{\linewidth}"
+        )
+        assert r"\makebox[\linewidth][c]{%" not in tex
+        assert r"\fontsize{6.5pt}{7.5pt}\selectfont" in tex
+        assert r"\begingroup\matrixsummaryfont" in tex
+        assert r"\hspace{0.014in}" in tex
+        assert tex.index(r"\clearpage") < tex.index(r"\subsection{")
+        assert tex.index(r"\subsection{") < tex.index(
+            r"\noindent\begin{minipage}{\linewidth}"
+        )
+
+
+def test_inapplicable_not_run_and_reset_cells_use_distinct_markers(
+    reset_caches,
+) -> None:
+    lc = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_recurrence_builtin_sm_lc"),
+        reset_caches,
+    )
+    assert r"\matrixnotapplicable{ReportMuted}" in lc
+    assert r"\matrixstatus{ReportMuted}{not run}" not in lc
+    assert r"\matrixstatus{ReportMuted}{N/A}" in lc
+
+    for accuracy in (Accuracy.NLC, Accuracy.FULL):
+        fixed = render_matrix_table(
+            REPORT_CATALOG.dataset(f"matrix_recurrence_builtin_sm_{accuracy.value}"),
+            reset_caches,
+        )
+        best = render_best_mode_table(accuracy, reset_caches)
+        for tex in (fixed, best):
+            assert tex.count(r"\matrixstatus{ReportMuted}{not run}") == 12
+            assert tex.count(r"\matrixnotapplicable{ReportMuted}") == 28
+        assert "Not run marks an otherwise defined process" in fixed
+
+        n6_family_one = next(
+            line
+            for line in fixed.splitlines()
+            if line.startswith(r"\texttt{1}")
+            and r"\matrixstatus{ReportMuted}{not run}" in line
+        )
+        assert r"\matrixnotapplicable{ReportMuted}" not in n6_family_one
+        family_fourteen = next(
+            line
+            for line in fixed.splitlines()
+            if line.startswith(r"\texttt{14}")
+            and line.count(r"\matrixnotapplicable{ReportMuted}") == 2
+        )
+        assert r"\matrixstatus{ReportMuted}{not run}" not in family_fourteen
+
+    assert "Fixed-engine tables intentionally omit mode letters" in lc
+
+
+def test_z_reference_execution_is_explicitly_not_exposed(reset_caches) -> None:
+    tex = render_z_ladder(ModelKey.BUILTIN_SM, reset_caches)
+    reference_rows = [line for line in tex.splitlines() if r"\AC{} reference" in line]
+
+    assert len(reference_rows) == 9
+    for row in reference_rows:
+        assert row.count(r"\matrixnotexposed{ReportMuted}") == 2
+        assert r"\matrixna{ReportMuted}" not in row
+    assert "not a missing measurement" in tex
+
+
+@pytest.mark.parametrize("model", (ModelKey.BUILTIN_SM, ModelKey.UFO_SM))
+def test_z_native_generation_cap_renders_static_na_in_both_models(
+    reset_caches,
+    model: ModelKey,
+) -> None:
+    tex = render_z_ladder(model, reset_caches)
+    capped_rows = [
+        line
+        for line in tex.splitlines()
+        if line.startswith(("7 & ", "8 & ", "9 & "))
+        and ("compiled ASM O3" in line or "compiled C++ O3" in line)
+    ]
+
+    assert len(capped_rows) == 6
+    assert all(row.count(r"\matrixstaticna{ReportMuted}") == 6 for row in capped_rows)
+    assert "user cap: native C++/ASM generation is not attempted above n=6" in tex
+    assert "native-backend-generation-cap-n6-v1" in tex
+
+
+def test_z_evaluator_total_is_mode_independent_and_not_execution_attribution(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "reference_amplicol_lc")
+    candidate = _cache_by_dataset(caches, "z_builtin_sm")
+    for workload in (Workload.SELECTED_FLOW, Workload.ALL_FLOW):
+        _set_ok(
+            baseline,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            generation=1.0,
+            wall=1.0e-6,
+            execution=9.0e-6,
+        )
+    modes = (
+        ("jit_o1", "compiled", "compiled JIT O1", 31.0, 41.0),
+        ("eager_jit_o2", "eager", "eager-DAG JIT O2", 32.0, 42.0),
+        (
+            "recurrence_jit_o2",
+            "recurrence",
+            "recurrence JIT O2",
+            33.0,
+            43.0,
+        ),
+    )
+    entries = candidate["entries"]
+    assert isinstance(entries, list)
+    for variant, execution_mode, _label, selected_total, all_total in modes:
+        for workload, total in (
+            (Workload.SELECTED_FLOW, selected_total),
+            (Workload.ALL_FLOW, all_total),
+        ):
+            _set_ok(
+                candidate,
+                process_key="dd_z_jets",
+                n_final=1,
+                workload=workload,
+                generation=2.0,
+                wall=(10.0 + total) * 1.0e-6,
+                execution=(70.0 + total) * 1.0e-6,
+                variant=variant,
+            )
+            measurement = next(
+                entry["measurement"]
+                for entry in entries
+                if entry["process_key"] == "dd_z_jets"
+                and entry["n_final"] == 1
+                and entry["workload"] == workload.value
+                and entry["variant"] == variant
+            )
+            assert isinstance(measurement, dict)
+            _mark_evaluator_total(
+                measurement,
+                execution_mode=execution_mode,
+                total=total * 1.0e-6,
+            )
+            if execution_mode == "recurrence":
+                _mark_recurrence_core(measurement)
+
+    tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+    for _variant, _mode, label, selected_total, all_total in modes:
+        row = next(
+            line
+            for line in tex.splitlines()
+            if line.startswith("1 & ") and label in line
+        )
+        assert (
+            rf"\texttt{{{selected_total:.0f}}}\,"
+            rf"\matrixratio{{ReportRed}}{{{selected_total:.0f}}}"
+        ) in row
+        assert (
+            rf"\texttt{{{all_total:.0f}}}\,"
+            rf"\matrixratio{{ReportRed}}{{{all_total:.0f}}}"
+        ) in row
+        assert r"\matrixzrecurrenceclocks" not in row
+        assert r"\matrixtotalevaluator" not in row
+        assert r"\matrixrecurrencecore" not in row
+    assert tex.count(r"\textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]}") == 6
+    assert r"\textbf{eval total T}" not in tex
+    assert r"\textbf{rec. core C}" not in tex
+    assert "original-AmpliCol wall measurement as denominator" in tex
+
+
+def test_z_unverified_retains_absolute_clocks_without_ratios(reset_caches) -> None:
+    caches = copy.deepcopy(reset_caches)
+    candidate = _cache_by_dataset(caches, "z_builtin_sm")
+    _set_unverified(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=4.0,
+        wall=2.0e-6,
+        evaluator_total=1.0e-6,
+        variant="jit_o3",
+    )
+
+    tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+    row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith("1 & compiled JIT O3")
+    )
+    marker = r"\matrixstatus{ReportOrange}{unverified}"
+
+    for value in ("4.00", "2.00", "1.00"):
+        assert (
+            rf"\matrixruntimepair{{\texttt{{{value}}}}}"
+            rf"{{{marker}}}"
+        ) in row
+    assert row.count(marker) == 3
+    assert r"\matrixratio{" not in row
+    assert "Unverified diagnostics retain absolute clocks" in tex
+
+
+def test_z_wall_and_evaluator_total_keep_distinct_six_digit_values(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "reference_amplicol_lc")
+    candidate = _cache_by_dataset(caches, "z_builtin_sm")
+    _set_ok(
+        baseline,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=1.0,
+        wall=100.0e-6,
+        execution=90.0e-6,
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=2.0,
+        wall=218.105e-6,
+        execution=183.456e-6,
+        variant="recurrence_jit_o2",
+    )
+    entries = candidate["entries"]
+    assert isinstance(entries, list)
+    measurement = next(
+        entry["measurement"]
+        for entry in entries
+        if entry["process_key"] == "dd_z_jets"
+        and entry["n_final"] == 1
+        and entry["workload"] == Workload.SELECTED_FLOW.value
+        and entry["variant"] == "recurrence_jit_o2"
+    )
+    assert isinstance(measurement, dict)
+    _mark_evaluator_total(
+        measurement,
+        execution_mode="recurrence",
+        total=217.812e-6,
+    )
+    _mark_recurrence_core(measurement)
+
+    tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+    row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith("1 & ") and "recurrence JIT O2" in line
+    )
+
+    assert r"\texttt{218.105}" in row
+    assert r"\texttt{217.812}\,\matrixratio{ReportRed}{2.18}" in row
+    assert r"\texttt{183.456}" not in row
+    assert r"\matrixrecurrencecore" not in row
+
+
+def test_z_historical_recurrence_without_dedicated_total_is_not_exposed(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    candidate = _cache_by_dataset(caches, "z_builtin_sm")
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=2.0,
+        wall=9.0e-6,
+        execution=7.0e-6,
+        variant="recurrence_jit_o2",
+    )
+    entries = candidate["entries"]
+    assert isinstance(entries, list)
+    measurement = next(
+        entry["measurement"]
+        for entry in entries
+        if entry["process_key"] == "dd_z_jets"
+        and entry["n_final"] == 1
+        and entry["workload"] == Workload.SELECTED_FLOW.value
+        and entry["variant"] == "recurrence_jit_o2"
+    )
+    assert isinstance(measurement, dict)
+    provenance = measurement["provenance"]
+    assert isinstance(provenance, dict)
+    provenance["runtime_profile"] = {
+        "achieved_runtime_seconds": 0.003,
+        "completed_sample_count": 5,
+        "interrupted": False,
+        "measured_point_count": 1000,
+        "planned_sample_count": 5,
+        "repetitions_per_sample": 1,
+        "target_runtime_achieved": True,
+        "target_runtime_seconds": 0.002,
+    }
+    provenance["execution_timing"] = {
+        "abi": "pyamplicol-report-execution-timing-v1",
+        "status": "measured",
+        "ratio_eligible": True,
+        "raw_seconds_per_point": 7.0e-6,
+        "source": "runtime_profile_core_recurrence_schedule_time",
+        "compiled_direct_arena_active": False,
+        "sample_count": 5,
+        "native_profile_points_per_sample": 200,
+        "sample_contract": ("paired_unprofiled_headline_profiled_attribution_v1"),
+    }
+
+    tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+    row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith("1 & ") and "recurrence JIT O2" in line
+    )
+
+    assert r"\matrixnotexposed{ReportMuted}" in row
+    assert r"\texttt{7}" not in row
+    assert r"\matrixzrecurrenceclocks" not in row
+
+    provenance["execution_timing"]["source"] = (
+        "runtime_profile_core_evaluator_call_time"
+    )
+    tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+    row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith("1 & ") and "recurrence JIT O2" in line
+    )
+    assert r"\matrixnotexposed{ReportMuted}" in row
+    assert r"\matrixzrecurrenceclocks" not in row
+
+
+def test_visible_completeness_accounts_for_every_n4_slot(reset_caches) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _fill_visible_n4_scope(caches)
+
+    summary = summarize_visible_completeness(caches, max_n_final=4)
+    evidence = summary.as_dict()
+
+    assert summary.complete
+    assert evidence["required_measurement_count"] == 1042
+    assert evidence["rendered_required_measurement_count"] == 1042
+    assert evidence["structurally_not_applicable_display_slot_count"] == 486
+    assert evidence["not_exposed_display_slot_count"] == 16
+    assert evidence["applicable_na_display_slot_count"] == 0
+    assert evidence["missing_rendered_cell_count"] == 0
+
+
+def test_visible_completeness_authenticates_catalog_static_na_slots(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _fill_visible_scope(caches, max_n_final=9)
+
+    summary = summarize_visible_completeness(caches, max_n_final=9)
+    evidence = summary.as_dict()
+
+    assert summary.complete
+    assert evidence["declared_measurement_cell_count"] == 2198
+    assert evidence["required_measurement_count"] == 2164
+    assert evidence["catalog_static_na_cell_count"] == 34
+    assert evidence["rendered_catalog_static_na_cell_count"] == 34
+    assert evidence["applicable_na_display_slot_count"] == 0
+    assert evidence["missing_rendered_cell_count"] == 0
+
+
+def test_visible_completeness_rejects_na_in_applicable_slot(reset_caches) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _fill_visible_n4_scope(caches)
+    cache = _cache_by_dataset(caches, "z_builtin_sm")
+    entries = cache["entries"]
+    assert isinstance(entries, list)
+    entry = next(
+        item
+        for item in entries
+        if item["n_final"] == 1
+        and item["variant"] == "jit_o3"
+        and item["workload"] == Workload.SELECTED_FLOW.value
+    )
+    measurement = entry["measurement"]
+    assert isinstance(measurement, dict)
+    measurement["generation_seconds"] = None
+
+    summary = summarize_visible_completeness(caches, max_n_final=4)
+
+    assert not summary.complete
+    assert any(entry["cell_id"] in slot for slot in summary.applicable_na_display_slots)
+
+
+def test_na_detector_recognizes_ratio_macro() -> None:
+    assert report_render._renders_na(r"\matrixnaratio{ReportMuted}")
+
+
+def test_visible_completeness_rejects_missing_candidate_generation_ratio(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _fill_visible_n4_scope(caches)
+    cache = _cache_by_dataset(caches, "matrix_compiled_builtin_sm_full")
+    entries = cache["entries"]
+    assert isinstance(entries, list)
+    entry = next(
+        item
+        for item in entries
+        if item["process_key"] == "dd_z_jets"
+        and item["n_final"] == 1
+        and item["workload"] == Workload.CONTRACTED.value
+    )
+    measurement = entry["measurement"]
+    assert isinstance(measurement, dict)
+    measurement["generation_seconds"] = None
+
+    summary = summarize_visible_completeness(caches, max_n_final=4)
+
+    assert not summary.complete
+    assert any(
+        entry["cell_id"] in slot and "/candidate" in slot
+        for slot in summary.applicable_na_display_slots
+    )
+
+
+def test_visible_completeness_rejects_non_ok_required_status(reset_caches) -> None:
+    caches = copy.deepcopy(reset_caches)
+    _fill_visible_n4_scope(caches)
+    cache = _cache_by_dataset(caches, "z_builtin_sm")
+    entries = cache["entries"]
+    assert isinstance(entries, list)
+    entry = next(
+        item
+        for item in entries
+        if item["n_final"] == 1
+        and item["variant"] == "jit_o3"
+        and item["workload"] == Workload.SELECTED_FLOW.value
+    )
+    measurement = entry["measurement"]
+    assert isinstance(measurement, dict)
+    measurement["status"] = ResultStatus.TIMEOUT.value
+
+    summary = summarize_visible_completeness(caches, max_n_final=4)
+
+    assert not summary.complete
+    assert not any(
+        entry["cell_id"] in slot for slot in summary.applicable_na_display_slots
+    )
+    assert any(
+        entry["cell_id"] in error
+        and repr(ResultStatus.TIMEOUT.value) in error
+        and repr(ResultStatus.OK.value) in error
+        for error in summary.contract_errors
+    )
+
+
+def test_adapter_joins_recurrence_baseline_without_copying_timing(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_nlc",
+    )
+    candidate = _cache_by_dataset(
+        caches,
+        "matrix_compiled_builtin_sm_nlc",
+    )
+    _set_ok(
+        baseline,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=1.5e-6,
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=2.0,
+        wall=1.0e-6,
+        execution=0.5e-6,
+    )
+
+    dataset = REPORT_CATALOG.dataset("matrix_compiled_builtin_sm_nlc")
+    family = REPORT_CATALOG.process_families[0]
+    joined = BaselineCandidateAdapter(caches).matrix_cell(dataset, family, 1)
+    tex = render_matrix_table(dataset, caches)
+
+    assert joined.workloads[0].baseline is not joined.workloads[0].candidate
+    assert joined.workloads[0].baseline["generation_seconds"] == 4.0
+    assert r"\texttt{4.00}" in tex
+    assert r"\bestmoderatio{ReportGreen}{0.500}" in tex
+
+
+def test_recurrence_matrix_cell_uses_compact_wall_and_core_ratios(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "reference_amplicol_nlc")
+    candidate = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_nlc",
+    )
+    _set_ok(
+        baseline,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=100.0e-6,
+        execution=90.0e-6,
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=2.0,
+        wall=218.105e-6,
+        execution=183.456e-6,
+    )
+    entries = candidate["entries"]
+    assert isinstance(entries, list)
+    measurement = next(
+        entry["measurement"]
+        for entry in entries
+        if entry["process_key"] == "dd_z_jets"
+        and entry["n_final"] == 1
+        and entry["workload"] == Workload.CONTRACTED.value
+    )
+    assert isinstance(measurement, dict)
+    _mark_evaluator_total(
+        measurement,
+        execution_mode="recurrence",
+        total=217.812e-6,
+    )
+    _mark_recurrence_core(measurement)
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_recurrence_builtin_sm_nlc"),
+        caches,
+    )
+
+    assert r"\bestmodecompactprefix{2.04}" in tex
+    assert r"\bestmodeprimaryratio{ReportRed}{2.18}" in tex
+    assert r"\texttt{217.812}" not in tex
+    assert r"\texttt{183.456}" not in tex
+    assert r"\matrixruntimetriple{" not in tex
+    assert "An evaluator total is never divided by a recurrence core" in tex
+
+
+def test_unavailable_execution_keeps_only_compact_wall_ratio(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_nlc",
+    )
+    candidate = _cache_by_dataset(
+        caches,
+        "matrix_compiled_builtin_sm_nlc",
+    )
+    _set_ok(
+        baseline,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=2.0,
+        wall=1.0e-6,
+        execution=None,
+    )
+    entries = candidate["entries"]
+    assert isinstance(entries, list)
+    measurement = next(
+        entry["measurement"]
+        for entry in entries
+        if entry["process_key"] == "dd_z_jets"
+        and entry["n_final"] == 1
+        and entry["workload"] == Workload.CONTRACTED.value
+    )
+    _mark_arena_unavailable(measurement)
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_compiled_builtin_sm_nlc"),
+        caches,
+    )
+
+    runtime_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r" &  & \textcolor{ReportMuted}{\scriptsize run")
+    )
+    assert r"\bestmodeopenprefix" not in runtime_row
+    assert r" &  & \bestmodewallratio{ReportGreen}{0.500}" in runtime_row
+    assert r"\matrixruntimepair{" not in tex
+    assert r"\matrixtotalevaluator{" not in tex
+    assert r"{x0}" not in tex
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+def test_dag_matrix_never_divides_evaluator_total_by_recurrence_core(
+    reset_caches,
+    execution_mode: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_nlc",
+    )
+    dataset_id = (
+        "matrix_compiled_builtin_sm_nlc"
+        if execution_mode == "compiled"
+        else "matrix_eager_builtin_sm_nlc"
+    )
+    candidate = _cache_by_dataset(caches, dataset_id)
+    _set_ok(
+        baseline,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=2.0,
+        wall=1.0e-6,
+        execution=None,
+    )
+    entries = candidate["entries"]
+    assert isinstance(entries, list)
+    measurement = next(
+        entry["measurement"]
+        for entry in entries
+        if entry["process_key"] == "dd_z_jets"
+        and entry["n_final"] == 1
+        and entry["workload"] == Workload.CONTRACTED.value
+    )
+    _mark_arena_unavailable(measurement, execution_mode=execution_mode)
+    _mark_evaluator_total(
+        measurement,
+        execution_mode=execution_mode,
+        total=0.9e-6,
+    )
+
+    tex = render_matrix_table(REPORT_CATALOG.dataset(dataset_id), caches)
+
+    runtime_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r" &  & \textcolor{ReportMuted}{\scriptsize run")
+    )
+    assert r"\bestmodeopenprefix" not in runtime_row
+    assert r" &  & \bestmodewallratio{ReportGreen}{0.500}" in runtime_row
+    assert r"\bestmodecompactprefix{0.900}" not in runtime_row
+    assert r"\texttt{0.900}" not in tex
+    assert r"\matrixtotalevaluator{" not in tex
+    assert r"\matrixruntimetriple{" not in tex
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+def test_dag_matrix_prefers_authenticated_evaluator_total_pair(
+    reset_caches,
+    execution_mode: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_nlc",
+    )
+    dataset_id = (
+        "matrix_compiled_builtin_sm_nlc"
+        if execution_mode == "compiled"
+        else "matrix_eager_builtin_sm_nlc"
+    )
+    candidate = _cache_by_dataset(caches, dataset_id)
+    _set_ok(
+        baseline,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=2.0,
+        wall=1.0e-6,
+        execution=None,
+    )
+    baseline_measurement = next(
+        entry["measurement"]
+        for entry in baseline["entries"]
+        if entry["process_key"] == "dd_z_jets"
+        and entry["n_final"] == 1
+        and entry["workload"] == Workload.CONTRACTED.value
+    )
+    candidate_measurement = next(
+        entry["measurement"]
+        for entry in candidate["entries"]
+        if entry["process_key"] == "dd_z_jets"
+        and entry["n_final"] == 1
+        and entry["workload"] == Workload.CONTRACTED.value
+    )
+    assert isinstance(baseline_measurement, dict)
+    assert isinstance(candidate_measurement, dict)
+    _mark_evaluator_total(
+        baseline_measurement,
+        execution_mode="recurrence",
+        total=1.8e-6,
+    )
+    _mark_arena_unavailable(
+        candidate_measurement,
+        execution_mode=execution_mode,
+    )
+    _mark_evaluator_total(
+        candidate_measurement,
+        execution_mode=execution_mode,
+        total=0.9e-6,
+    )
+
+    tex = render_matrix_table(REPORT_CATALOG.dataset(dataset_id), caches)
+    runtime_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r" &  & \textcolor{ReportMuted}{\scriptsize run")
+    )
+
+    assert r"\bestmodecompactprefix{0.500}" in runtime_row
+    assert r"\bestmodeprimaryratio{ReportGreen}{0.500}" in runtime_row
+    assert r"\bestmodecompactprefix{0.900}" not in runtime_row
+    assert "evaluator-total fallback is diagnostic only" in tex
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+@pytest.mark.parametrize(
+    ("legacy_execution", "expected_secondary"),
+    ((1.5e-6, "0.600"), (None, "0.450")),
+)
+def test_best_mode_uses_candidate_total_against_legacy_direct_or_wall(
+    reset_caches,
+    execution_mode: str,
+    legacy_execution: float | None,
+    expected_secondary: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    reference = _cache_by_dataset(caches, "reference_amplicol_nlc")
+    recurrence = _cache_by_dataset(caches, "matrix_recurrence_builtin_sm_nlc")
+    candidate = _cache_by_dataset(
+        caches,
+        f"matrix_{execution_mode}_builtin_sm_nlc",
+    )
+    _set_ok(
+        reference,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=legacy_execution,
+    )
+    _set_ok(
+        recurrence,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=3.0,
+        wall=1.5e-6,
+        execution=1.2e-6,
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.CONTRACTED,
+        generation=2.0,
+        wall=1.0e-6,
+        execution=None,
+    )
+    candidate_measurement = next(
+        entry["measurement"]
+        for entry in candidate["entries"]
+        if entry["process_key"] == "dd_z_jets"
+        and entry["n_final"] == 1
+        and entry["workload"] == Workload.CONTRACTED.value
+    )
+    assert isinstance(candidate_measurement, dict)
+    _mark_arena_unavailable(
+        candidate_measurement,
+        execution_mode=execution_mode,
+    )
+    _mark_evaluator_total(
+        candidate_measurement,
+        execution_mode=execution_mode,
+        total=0.9e-6,
+    )
+
+    tex = render_best_mode_table(Accuracy.NLC, caches)
+    runtime_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r" &  & \textcolor{ReportMuted}{\scriptsize run")
+    )
+
+    assert rf"\bestmodecompactprefix{{{expected_secondary}}}" in runtime_row
+    assert r"\bestmodeprimaryratio{ReportGreen}{0.500}" in runtime_row
+    assert "evaluator-total fallback is diagnostic only" in tex
+    assert "uses the AmpliCol direct execution clock" in tex
+
+
+@pytest.mark.parametrize(
+    "surface",
+    ("z_builtin_sm", "scalar_contact", "scalar_gravity"),
+)
+def test_ladders_render_generic_presentation_outcomes_through_shared_status_path(
+    reset_caches,
+    surface: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    cache = _cache_by_dataset(caches, surface)
+    if surface == "z_builtin_sm":
+        _set_presentation_outcome(
+            cache,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.SELECTED_FLOW,
+            outcome="dependency_backend_error",
+            variant="jit_o3",
+        )
+        tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+    else:
+        _set_presentation_outcome(
+            cache,
+            process_key=surface,
+            n_final=2,
+            workload=Workload.CONTRACTED,
+            outcome="dependency_backend_error",
+        )
+        dataset = next(
+            item
+            for item in REPORT_CATALOG.scalar_datasets
+            if item.dataset_id == surface
+        )
+        tex = render_scalar_ladder(dataset, caches)
+
+    display = report_render._compact_terminal_display(
+        report_render._TerminalOutcome(
+            identity="presentation:dependency_backend_error",
+            label="dependency backend error",
+            color="ReportRed",
+        )
+    )
+    marker = rf"\matrixstatus{{ReportRed}}{{{display}}}"
+    assert tex.count(marker) >= 3
+    assert "dependency backend error" not in tex
+    assert r"\matrixstatus{ReportOrange}{dependency backend error}" not in tex
+    assert "dependency_backend_error" not in tex
+
+
+def test_z_ladder_prints_not_exposed_instead_of_zero(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "reference_amplicol_lc")
+    candidate = _cache_by_dataset(caches, "z_builtin_sm")
+    _set_ok(
+        baseline,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=4.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_z_jets",
+        n_final=1,
+        workload=Workload.SELECTED_FLOW,
+        generation=2.0,
+        wall=1.0e-6,
+        execution=None,
+        variant="jit_o3",
+    )
+    entries = candidate["entries"]
+    assert isinstance(entries, list)
+    measurement = next(
+        entry["measurement"]
+        for entry in entries
+        if entry["process_key"] == "dd_z_jets"
+        and entry["n_final"] == 1
+        and entry["variant"] == "jit_o3"
+        and entry["workload"] == Workload.SELECTED_FLOW.value
+    )
+    _mark_arena_unavailable(measurement)
+
+    tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+
+    assert r"\matrixnotexposed{ReportMuted}" in tex
+    assert r"{x0}" not in tex
+
+
+def test_unavailable_execution_is_not_treated_as_a_summary_ratio(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_nlc",
+    )
+    candidate = _cache_by_dataset(
+        caches,
+        "matrix_compiled_builtin_sm_nlc",
+    )
+    for cache, execution in ((baseline, 4.0e-7), (candidate, None)):
+        _set_ok(
+            cache,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.CONTRACTED,
+            generation=1.0,
+            wall=1.0e-6,
+            execution=execution,
+        )
+    entries = candidate["entries"]
+    assert isinstance(entries, list)
+    measurement = next(
+        entry["measurement"]
+        for entry in entries
+        if entry["process_key"] == "dd_z_jets"
+        and entry["n_final"] == 1
+        and entry["workload"] == Workload.CONTRACTED.value
+    )
+    _mark_arena_unavailable(measurement)
+    dataset = REPORT_CATALOG.dataset("matrix_compiled_builtin_sm_nlc")
+    view = BaselineCandidateAdapter(caches).matrix_cell(
+        dataset,
+        REPORT_CATALOG.process_families[0],
+        1,
+    )
+
+    summary = report_render._summary_pair(
+        (view,),
+        Workload.CONTRACTED,
+        "execution_seconds_per_point",
+    )
+
+    assert summary == r"\matrixnotexposed{ReportMuted}"
+
+
+def test_adapter_joins_original_amplicol_for_primary_recurrence(
+    reset_caches,
+) -> None:
+    dataset = REPORT_CATALOG.dataset("matrix_recurrence_ufo_sm_full")
+    family = REPORT_CATALOG.process_families[0]
+    adapter = BaselineCandidateAdapter(reset_caches)
+    joined = adapter.matrix_cell(dataset, family, 1)
+    reference = adapter.index.get(
+        "reference_amplicol_full",
+        family.key,
+        1,
+        Workload.CONTRACTED,
+    )
+
+    assert joined.workloads[0].baseline is reference
+
+
+def test_lc_cells_join_two_layout_specific_baselines(reset_caches) -> None:
+    dataset = REPORT_CATALOG.dataset("matrix_eager_builtin_sm_lc")
+    family = REPORT_CATALOG.process_families[0]
+    joined = BaselineCandidateAdapter(reset_caches).matrix_cell(
+        dataset,
+        family,
+        1,
+    )
+
+    assert tuple(item.workload for item in joined.workloads) == (
+        Workload.SELECTED_FLOW,
+        Workload.ALL_FLOW,
+    )
+
+
+def test_amplicol_all_flow_setup_generation_ratio_is_not_comparable(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "reference_amplicol_lc")
+    candidate = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_lc",
+    )
+    for workload, baseline_generation, candidate_generation in (
+        (Workload.SELECTED_FLOW, 2.0, 4.0),
+        (Workload.ALL_FLOW, 1.0e-4, 10.0),
+    ):
+        _set_ok(
+            baseline,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            generation=baseline_generation,
+            wall=2.0e-6,
+            execution=1.0e-6,
+        )
+        _set_ok(
+            candidate,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            generation=candidate_generation,
+            wall=1.0e-6,
+            execution=0.5e-6,
+        )
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_recurrence_builtin_sm_lc"),
+        caches,
+    )
+
+    assert tex.count(r"\bestmodeabsoluteprefix{\texttt{10.0}}") == 1
+    generation_summary = next(
+        line for line in tex.splitlines() if r"\textbf{summary: generation}" in line
+    )
+    assert r"\texttt{10}" not in generation_summary
+    assert r"\matrixratio{ReportRed}{1e+05}" not in tex
+    assert "setup boundary differs from the reference" in tex
+    assert "n.c." not in tex
+
+
+def test_four_line_recurrence_renders_absolute_values_without_legacy_oracle(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    candidate = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_lc",
+    )
+    for workload, generation in (
+        (Workload.SELECTED_FLOW, 4.0),
+        (Workload.ALL_FLOW, 10.0),
+    ):
+        _set_ok(
+            candidate,
+            process_key="dd_4q_lines",
+            n_final=6,
+            workload=workload,
+            generation=generation,
+            wall=2.0e-6,
+            execution=1.0e-6,
+        )
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_recurrence_builtin_sm_lc"),
+        caches,
+    )
+
+    assert r"\bestmodeabsoluteprefix{\texttt{4.00}}" in tex
+    assert r"\bestmodeabsoluteprefix{\texttt{10.0}}" in tex
+    assert tex.count(r"\texttt{2.00}") >= 2
+    assert r"\matrixruntimetriple{" not in tex
+    assert tex.count(r"\matrixstaticna{ReportMuted}") >= 2
+    assert "static N/A beyond three open quark lines" in tex
+    assert "n.c." not in tex
+
+
+def test_four_line_contracted_n6_renders_without_legacy_dependency(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    candidate = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_full",
+    )
+    _set_ok(
+        candidate,
+        process_key="dd_4q_lines",
+        n_final=6,
+        workload=Workload.CONTRACTED,
+        generation=12.0,
+        wall=2.0e-6,
+        execution=1.0e-6,
+    )
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_recurrence_builtin_sm_full"),
+        caches,
+    )
+
+    assert r"\textbf{n=6}" in tex
+    fixed_generation_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r"\texttt{14}")
+        and r"\bestmodeabsoluteprefix{\texttt{12.0}}" in line
+    )
+    fixed_runtime_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r" &  & \textcolor{ReportMuted}{\scriptsize run")
+        and r"\bestmodeabsoluteprefix{\texttt{2.00}}" in line
+    )
+    assert (
+        r"\matrixstaticna{ReportMuted} & "
+        r"\bestmodeabsoluteprefix{\texttt{12.0}} & "
+    ) in fixed_generation_row
+    assert (
+        r"\matrixstaticna{ReportMuted} & "
+        r"\bestmodeabsoluteprefix{\texttt{2.00}} & "
+    ) in fixed_runtime_row
+    assert r"\matrixstaticna{ReportMuted}" in tex
+    assert "static N/A beyond three open quark lines" in tex
+    assert "n.c." not in tex
+
+    best_tex = render_best_mode_table(Accuracy.FULL, caches)
+    best_generation_row = next(
+        line
+        for line in best_tex.splitlines()
+        if line.startswith(r"\texttt{14}")
+        and r"\bestmodeabsoluteprefix{\texttt{12.0}}" in line
+    )
+    best_runtime_row = next(
+        line
+        for line in best_tex.splitlines()
+        if line.startswith(r" &  & \textcolor{ReportMuted}{\scriptsize run")
+        and r"\bestmodeabsoluteprefix{\texttt{2.00}}" in line
+    )
+    assert (
+        r"\matrixstaticna{ReportMuted} & "
+        r"\bestmodeabsoluteprefix{\texttt{12.0}} & \bestmodecode{r}"
+    ) in best_generation_row
+    assert (
+        r"\matrixstaticna{ReportMuted} & "
+        r"\bestmodeabsoluteprefix{\texttt{2.00}} & "
+    ) in best_runtime_row
+    assert r"\bestmodecode" not in best_runtime_row
+
+
+def test_z_all_flow_setup_generation_ratio_is_not_comparable(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(caches, "reference_amplicol_lc")
+    candidate = _cache_by_dataset(caches, "z_builtin_sm")
+    for workload, baseline_generation, candidate_generation in (
+        (Workload.SELECTED_FLOW, 2.0, 4.0),
+        (Workload.ALL_FLOW, 1.0e-4, 10.0),
+    ):
+        _set_ok(
+            baseline,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            generation=baseline_generation,
+            wall=2.0e-6,
+            execution=1.0e-6,
+        )
+        _set_ok(
+            candidate,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            generation=candidate_generation,
+            wall=1.0e-6,
+            execution=0.5e-6,
+            variant="jit_o3",
+        )
+
+    tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+
+    assert r"\matrixncabsolute{\texttt{10}}" in tex
+    assert r"\matrixratio{ReportRed}{1e+05}" not in tex
+    assert "setup boundary differs from the reference" in tex
+    assert "n.c." not in tex
+
+
+def test_cross_mode_all_flow_generation_ratio_remains_layout_matched(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    baseline = _cache_by_dataset(
+        caches,
+        "matrix_recurrence_builtin_sm_lc",
+    )
+    candidate = _cache_by_dataset(caches, "matrix_compiled_builtin_sm_lc")
+    for cache, generation in ((baseline, 4.0), (candidate, 2.0)):
+        _set_ok(
+            cache,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.ALL_FLOW,
+            generation=generation,
+            wall=2.0e-6,
+            execution=1.0e-6,
+        )
+
+    tex = render_matrix_table(
+        REPORT_CATALOG.dataset("matrix_compiled_builtin_sm_lc"),
+        caches,
+    )
+
+    assert r"\bestmoderatio{ReportGreen}{0.500}" in tex
+    assert r"\matrixncabsolute{\texttt" not in tex
+
+
+def test_two_z_ladders_use_single_line_mode_labels(reset_caches) -> None:
+    rendered = render_all_z_ladders(reset_caches)
+
+    assert list(rendered) == [
+        "result_z_builtin_sm_table.tex",
+        "result_z_external_sm_table.tex",
+    ]
+    for tex in rendered.values():
+        assert "longtable" not in tex
+        assert "eager-DAG JIT O2" in tex
+        assert "recurrence JIT O2" in tex
+        assert "on-the-fly JIT O2" in tex
+        assert "eager-DAG JIT O2\\\\" not in tex
+        assert "recurrence JIT O2\\\\" not in tex
+        assert "on-the-fly JIT O2\\\\" not in tex
+        assert r"\begin{minipage}{\linewidth}" in tex
+        assert tex.index(r"\clearpage") < tex.index(r"\subsection{")
+        assert tex.index(r"\subsection{") < tex.index(
+            r"\noindent\begin{minipage}{\linewidth}"
+        )
+
+
+def test_z_on_the_fly_row_keeps_cold_start_generation_pair(reset_caches) -> None:
+    caches = copy.deepcopy(reset_caches)
+    candidate = _cache_by_dataset(caches, "z_builtin_sm")
+    for workload in (Workload.SELECTED_FLOW, Workload.ALL_FLOW):
+        _set_ok(
+            candidate,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=workload,
+            generation=1.0,
+            wall=2.0e-6,
+            execution=1.0e-6,
+            variant="on_the_fly_jit_o2",
+        )
+
+    tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+    row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith("1 & on-the-fly JIT O2")
+    )
+
+    assert row.count(r"\bestmodecompactabsolute{1.00}{1.25}") == 2
+    assert r"\matrixstaticna{ReportMuted}" not in row
+    assert "one compact query-local process seed" in tex
+    assert r"absolute \texttt{[G] G+W} pair" in tex
+
+
+def test_dense_scalar_ladder_fits_narrower_columns(reset_caches) -> None:
+    dataset = next(
+        item
+        for item in REPORT_CATALOG.scalar_datasets
+        if item.dataset_id == "scalar_contact"
+    )
+
+    tex = render_scalar_ladder(dataset, reset_caches)
+
+    assert r"@{}L{1.00in}" in tex
+    assert tex.count(r"L{0.72in}") == len(dataset.multiplicities)
+    assert r"\setlength{\tabcolsep}{2.2pt}" in tex
+    assert (
+        r"{\fontsize{6.4pt}{7.4pt}\selectfont"
+        r"\mbox{evaluator total [\(\mu\mathrm{s}/\mathrm{pt}\)]}} & "
+        in tex
+    )
+    assert (
+        "\nevaluator total " r"[\(\mu\mathrm{s}/\mathrm{pt}\)] & "
+        not in tex
+    )
+
+
+@pytest.mark.parametrize("dataset_id", ("scalar_contact", "scalar_gravity"))
+def test_scalar_timing_marks_unavailable_arena_attribution_not_exposed(
+    reset_caches,
+    dataset_id: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    dataset = next(
+        item for item in REPORT_CATALOG.scalar_datasets if item.dataset_id == dataset_id
+    )
+    cache = _cache_by_dataset(caches, dataset_id)
+    _set_ok(
+        cache,
+        process_key=dataset_id,
+        n_final=2,
+        workload=Workload.CONTRACTED,
+        generation=1.0,
+        wall=1.0e-6,
+        execution=None,
+    )
+    entries = cache["entries"]
+    assert isinstance(entries, list)
+    measurement = next(
+        entry["measurement"] for entry in entries if entry["n_final"] == 2
+    )
+    _mark_arena_unavailable(measurement)
+
+    tex = render_scalar_ladder(dataset, caches)
+
+    assert (
+        r"{\fontsize{6.4pt}{7.4pt}\selectfont"
+        r"\mbox{evaluator total [\(\mu\mathrm{s}/\mathrm{pt}\)]}}"
+        in tex
+    )
+    assert r"\matrixnotexposed{ReportMuted}" in tex
+    assert "successful wall measurement" in tex
+
+
+def test_scalar_timing_uses_dedicated_evaluator_total_not_wall(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    dataset = next(
+        item
+        for item in REPORT_CATALOG.scalar_datasets
+        if item.dataset_id == "scalar_contact"
+    )
+    cache = _cache_by_dataset(caches, "scalar_contact")
+    _set_ok(
+        cache,
+        process_key="scalar_contact",
+        n_final=2,
+        workload=Workload.CONTRACTED,
+        generation=1.0,
+        wall=218.105e-6,
+        execution=None,
+    )
+    entries = cache["entries"]
+    assert isinstance(entries, list)
+    measurement = next(
+        entry["measurement"] for entry in entries if entry["n_final"] == 2
+    )
+    assert isinstance(measurement, dict)
+    _mark_arena_unavailable(measurement)
+    _mark_evaluator_total(
+        measurement,
+        execution_mode="compiled",
+        total=217.812e-6,
+    )
+
+    tex = render_scalar_ladder(dataset, caches)
+    wall_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(r"wall [\(\mu\mathrm{s}/\mathrm{pt}\)]")
+    )
+    total_row = next(
+        line
+        for line in tex.splitlines()
+        if line.startswith(
+            r"{\fontsize{6.4pt}{7.4pt}\selectfont"
+            r"\mbox{evaluator total [\(\mu\mathrm{s}/\mathrm{pt}\)]}}"
+        )
+    )
+
+    assert r"\texttt{218.105}" in wall_row
+    assert r"\texttt{217.812}" in total_row
+    assert r"\texttt{218.105}" not in total_row
+    assert r"execution [\(\mu\mathrm{s}/\mathrm{pt}\)]" not in tex
+    assert "never copied from or derived from wall time" in tex
+
+
+@pytest.mark.parametrize("dataset_id", ("scalar_contact", "scalar_gravity"))
+def test_scalar_unverified_retains_absolute_clocks_with_marker(
+    reset_caches,
+    dataset_id: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    dataset = next(
+        item for item in REPORT_CATALOG.scalar_datasets if item.dataset_id == dataset_id
+    )
+    cache = _cache_by_dataset(caches, dataset_id)
+    _set_unverified(
+        cache,
+        process_key=dataset_id,
+        n_final=2,
+        workload=Workload.CONTRACTED,
+        generation=4.0,
+        wall=2.0e-6,
+        evaluator_total=1.0e-6,
+    )
+
+    tex = render_scalar_ladder(dataset, caches)
+    marker = r"\matrixstatus{ReportOrange}{unverified}"
+    expected = {
+        "generation [s]": "4.00",
+        r"wall [\(\mu\mathrm{s}/\mathrm{pt}\)]": "2.00",
+        (
+            r"{\fontsize{6.4pt}{7.4pt}\selectfont"
+            r"\mbox{evaluator total [\(\mu\mathrm{s}/\mathrm{pt}\)]}}"
+        ): "1.00",
+    }
+    for prefix, value in expected.items():
+        row = next(line for line in tex.splitlines() if line.startswith(prefix))
+        assert (
+            rf"\matrixruntimepair{{\texttt{{{value}}}}}"
+            rf"{{{marker}}}"
+        ) in row
+    assert r"\matrixratio{" not in tex
+    assert "Unverified diagnostics retain absolute generation" in tex
+
+
+@pytest.mark.parametrize("surface", ("z_builtin_sm", "scalar_contact"))
+def test_ladder_presentation_only_unverified_is_orange(
+    reset_caches,
+    surface: str,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    cache = _cache_by_dataset(caches, surface)
+    if surface == "z_builtin_sm":
+        _set_presentation_outcome(
+            cache,
+            process_key="dd_z_jets",
+            n_final=1,
+            workload=Workload.SELECTED_FLOW,
+            outcome="unverified",
+            variant="jit_o3",
+        )
+        tex = render_z_ladder(ModelKey.BUILTIN_SM, caches)
+    else:
+        _set_presentation_outcome(
+            cache,
+            process_key=surface,
+            n_final=2,
+            workload=Workload.CONTRACTED,
+            outcome="unverified",
+        )
+        dataset = next(
+            item
+            for item in REPORT_CATALOG.scalar_datasets
+            if item.dataset_id == surface
+        )
+        tex = render_scalar_ladder(dataset, caches)
+
+    assert r"\matrixstatus{ReportOrange}{unverified}" in tex
+    assert r"\matrixstatus{ReportRed}{unverified}" not in tex
+
+
+def test_all_outputs_include_matrices_z_and_scalar_ladders(
+    reset_caches,
+) -> None:
+    rendered = render_all_tables(reset_caches)
+
+    assert len(rendered) == 27
+    assert "result_validation_summary.tex" in rendered
+    assert set(render_all_best_mode_tables(reset_caches)) < set(rendered)
+    assert set(render_all_matrix_tables(reset_caches)) < set(rendered)
+    assert set(render_all_z_ladders(reset_caches)) < set(rendered)
+    assert "result_scalar_contact_table.tex" in rendered
+    assert "result_scalar_gravity_table.tex" in rendered
+
+
+def test_validation_summary_counts_complete_scope_and_comparison_kinds(
+    reset_caches,
+) -> None:
+    caches = copy.deepcopy(reset_caches)
+    revision = "0123456789abcdef0123456789abcdef01234567"
+    records = (
+        (
+            "reference_amplicol_lc",
+            "dd_z_jets",
+            1,
+            Workload.SELECTED_FLOW,
+            {
+                "status": "ok",
+                "method": "independent-original-amplicol-oracle",
+            },
+        ),
+        (
+            "reference_amplicol_lc",
+            "dd_z_jets",
+            1,
+            Workload.ALL_FLOW,
+            {
+                "status": "ok",
+                "method": "independent-original-amplicol-oracle",
+            },
+        ),
+        (
+            "matrix_recurrence_builtin_sm_lc",
+            "dd_z_jets",
+            1,
+            Workload.SELECTED_FLOW,
+            {
+                "status": "ok",
+                "pointwise": {
+                    "status": "validation_failed",
+                    "relative_difference": 1.0e-5,
+                    "relative_tolerance": 1.0e-8,
+                },
+                "resolved_sum": {
+                    "status": "ok",
+                    "maximum_relative_difference": 2.0e-13,
+                },
+            },
+        ),
+        (
+            "matrix_recurrence_builtin_sm_lc",
+            "dd_z_jets",
+            1,
+            Workload.ALL_FLOW,
+            {
+                "status": "ok",
+                "direct_agreements": [
+                    {
+                        "edge_kind": LC_LEGACY_PYAMPLICOL_COMPONENT,
+                        "status": "ok",
+                        "relative_difference": 8.0e-9,
+                        "relative_tolerance": 1.0e-8,
+                    }
+                ],
+                "resolved_sum": {
+                    "status": "ok",
+                    "maximum_relative_difference": 1.0e-13,
+                },
+            },
+        ),
+        (
+            "matrix_compiled_builtin_sm_lc",
+            "dd_z_jets",
+            1,
+            Workload.SELECTED_FLOW,
+            {
+                "status": "ok",
+                "pointwise": {
+                    "status": "ok",
+                    "relative_difference": 3.0e-13,
+                },
+                "resolved_sum": {
+                    "status": "ok",
+                    "maximum_relative_difference": 4.0e-14,
+                },
+            },
+        ),
+        (
+            "reference_madgraph_full",
+            "dd_z_jets",
+            1,
+            Workload.CONTRACTED,
+            {
+                "status": "ok",
+                "method": "independent-madgraph-tree-level-oracle",
+            },
+        ),
+        (
+            "matrix_recurrence_ufo_sm_full",
+            "dd_z_jets",
+            1,
+            Workload.CONTRACTED,
+            {
+                "status": "ok",
+                "madgraph_comparison": {
+                    "status": "ok",
+                    "relative_difference": 7.0e-12,
+                    "relative_tolerance": 1.0e-10,
+                },
+                "high_precision": {
+                    "status": "ok",
+                    "relative_difference": 4.0e-14,
+                },
+                "resolved_sum": {
+                    "status": "ok",
+                    "maximum_relative_difference": 7.0e-14,
+                },
+            },
+        ),
+        (
+            "scalar_contact",
+            "scalar_contact",
+            2,
+            Workload.CONTRACTED,
+            {
+                "status": "ok",
+                "high_precision": {
+                    "status": "ok",
+                    "relative_difference": 5.0e-14,
+                },
+                "resolved_sum": {
+                    "status": "ok",
+                    "maximum_relative_difference": 6.0e-14,
+                },
+            },
+        ),
+    )
+    for dataset_id, process_key, n_final, workload, validation in records:
+        cache = _cache_by_dataset(caches, dataset_id)
+        _set_ok(
+            cache,
+            process_key=process_key,
+            n_final=n_final,
+            workload=workload,
+            generation=1.0,
+            wall=1.0e-6,
+            execution=5.0e-7,
+        )
+        entries = cache["entries"]
+        assert isinstance(entries, list)
+        measurement = next(
+            entry["measurement"]
+            for entry in entries
+            if entry["process_key"] == process_key
+            and entry["n_final"] == n_final
+            and entry["workload"] == workload.value
+        )
+        measurement["validation"] = validation
+        measurement["provenance"] = {
+            "report_measured_source_revision": revision,
+        }
+
+    summary = summarize_validation(caches)
+    tex = render_validation_summary(caches)
+
+    assert r"\begin{tabular}{@{}l r r r l@{}}" in tex
+    assert summary.expected_by_n == (
+        (1, 84),
+        (2, 254),
+        (3, 282),
+        (4, 422),
+        (5, 393),
+        (6, 223),
+        (7, 169),
+        (8, 169),
+        (9, 168),
+    )
+    assert summary.declared_total == 2198
+    assert summary.static_na_by_n == (
+        (1, 0),
+        (2, 0),
+        (3, 0),
+        (4, 0),
+        (5, 0),
+        (6, 4),
+        (7, 10),
+        (8, 10),
+        (9, 10),
+    )
+    assert summary.static_na_total == 34
+    assert summary.expected_total == 2164
+    assert summary.passed_total == 8
+    assert summary.status_counts == (
+        ("not_available", 2156),
+        ("ok", 8),
+        ("static-na", 34),
+    )
+    assert summary.madgraph_reference_count == 1
+    assert summary.madgraph_comparison_count == 1
+    assert summary.madgraph_comparison_maximum_relative_difference == 7.0e-12
+    assert summary.legacy_reference_count == 2
+    assert summary.legacy_comparison_pass_count == 1
+    assert summary.legacy_comparison_failure_count == 1
+    assert summary.legacy_comparison_maximum_relative_difference == 1.0e-5
+    assert summary.cross_mode_count == 1
+    assert summary.cross_mode_maximum_relative_difference == 3.0e-13
+    assert summary.resolved_count == 5
+    assert summary.resolved_maximum_relative_difference == 2.0e-13
+    assert summary.high_precision_count == 2
+    assert summary.high_precision_maximum_relative_difference == 5.0e-14
+    assert summary.uniform_source_revision == revision
+    assert "2198 & 34 & 8" in tex
+    assert "2198 declared cells" in tex
+    assert "2164 measurable cells" in tex
+    assert "34 catalog-authenticated static N/A" in tex
+    assert "659 matrix process/multiplicity positions" in tex
+    assert "36 reference execution fields" in tex
+    assert "MadGraph standalone tree-level reference records & 1" in tex
+    assert r"\PAC{} versus MadGraph binary64 (p200; OTF p16) & 1" in tex
+    assert r"original-\AC{} legacy diagnostic records & 2" in tex
+    assert r"\PAC{} versus original-\AC{} legacy diagnostic & 1 pass, 1 mismatch" in tex
+    assert r"relative tolerance of \(10^{-10}\)" in tex
+    assert "legacy mismatch does not invalidate a candidate" in tex
+    assert "independent original" not in tex
+    assert rf"\nolinkurl{{{revision}}}" in tex
diff --git a/pyamplicol/tests/unit/test_three_mode_report_runner.py b/pyamplicol/tests/unit/test_three_mode_report_runner.py
new file mode 100644
index 0000000000..0851e5f878
--- /dev/null
+++ b/pyamplicol/tests/unit/test_three_mode_report_runner.py
@@ -0,0 +1,3034 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.generation.artifact_writer import _evaluator as _serialize_evaluator
+from tools.performance_report.arena_profile import (
+    ARENA_PHASE_TIMING_SCOPE,
+    ARENA_PROFILE_BOUNDARY,
+    EMPTY_ARENA_PHASE_VECTOR_FIELDS,
+    ZERO_ARENA_COUNTER_FIELDS,
+    ZERO_ARENA_PHASE_TIME_FIELDS,
+    ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS,
+    ArenaProfileEvidenceError,
+    build_arena_profile_evidence,
+    digest_arena_profile_value,
+    validate_arena_profile_evidence,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import (
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    Workload,
+)
+from tools.performance_report.runner import (
+    LOADED_RUNTIME_PROFILE_COMMAND_PATH,
+    PAIRED_ARENA_PROFILE_COMMAND_PATH,
+    PRECOMPILED_GENERATION_COMMAND_PATH,
+    PUBLIC_CLI_COMMAND_PATH,
+    ProfilingTimeLimitError,
+    RunnerError,
+    RunnerSettings,
+    SelectorContract,
+    _artifact_numerical_relation_metadata,
+    _authenticated_direct_codegen_identity,
+    _authenticated_effective_config,
+    _authenticated_recurrence_source_identity,
+    _authenticated_symjit_plane_leaves,
+    _benchmark_measurement,
+    _calibrate_arena_repetitions,
+    _real_nonnegative,
+    _regular_file_identity,
+    _run_arena_benchmark,
+    _run_report_benchmark,
+    _selector_kwargs,
+    config_values,
+    derive_selector_contract,
+    generate_artifact,
+    point_digest,
+    pointwise_validation,
+    profiling_chunk_guard,
+    provenance_payload,
+    resolved_sum_validation,
+    runtime_identity_payload,
+    validate_artifact_contract,
+    validate_runtime_contract,
+    validate_selector_contract,
+)
+
+
+def test_provenance_payload_records_measurement_numpy(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class Numpy:
+        __version__ = "2.4.2-measurement"
+
+    monkeypatch.setattr(
+        "tools.performance_report.runner.importlib.import_module",
+        lambda name: Numpy() if name == "numpy" else None,
+    )
+
+    provenance = provenance_payload()
+
+    assert provenance["numpy"] == "2.4.2-measurement"
+    assert provenance["python_implementation"]
+
+
+def test_profiling_chunk_guard_rejects_only_chunks_larger_than_remaining() -> None:
+    guard = profiling_chunk_guard(10.0, clock=lambda: 9.0)
+
+    assert guard is not None
+    guard(None, "one-point probe")
+    guard(1.0, "exactly fitting chunk")
+    with pytest.raises(ProfilingTimeLimitError, match=r"estimated=1\.00001s"):
+        guard(1.00001, "oversized chunk")
+
+
+def test_profiling_chunk_guard_rejects_launch_after_deadline() -> None:
+    guard = profiling_chunk_guard(10.0, clock=lambda: 10.0)
+
+    assert guard is not None
+    with pytest.raises(ProfilingTimeLimitError, match="remaining=0s"):
+        guard(None, "one-point probe")
+
+
+def test_artifact_numerical_relation_metadata_preserves_fallback(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol.artifacts as artifacts
+    from pyamplicol.generation.recurrence_numerical_current_warmup import (
+        RecurrenceNumericalEvidenceGeometry,
+    )
+
+    geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+        current_count=4,
+        component_count=4,
+        candidate_probe_count=2,
+        verification_probe_count=2,
+        runtime_parameter_count=2,
+    )
+    relation_report = {
+        "requested_mode": "certified-reuse",
+        "effective_mode": "off",
+        "effective_reuse_state": "disabled",
+        "certified_relation_count": 0,
+        "applied_relation_count": 0,
+        "relation_correctness": {
+            "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+            "state": "no-applied-relations",
+            "applied_relation_count": 0,
+        },
+        "fallback": {
+            "reason": "evidence-envelope-fallback",
+            "memory_envelope_bytes": 1,
+            "spooled_producer_resident_bytes": (
+                geometry.spooled_producer_resident_upper_bound()
+            ),
+            "geometry": geometry.to_json_dict(),
+        },
+    }
+    manifest = SimpleNamespace(
+        extensions={
+            "generation": {
+                "concrete_processes": [
+                    {
+                        "id": "process",
+                        "filters": {"relation_discovery": relation_report},
+                    }
+                ]
+            }
+        }
+    )
+    loads: list[tuple[Path, bool]] = []
+
+    def load_manifest(path: Path, *, verify_payloads: bool) -> object:
+        loads.append((path, verify_payloads))
+        return manifest
+
+    monkeypatch.setattr(artifacts, "load_manifest", load_manifest)
+
+    correctness, fallback = _artifact_numerical_relation_metadata(
+        tmp_path / "artifact",
+        "process",
+    )
+
+    assert loads == [(tmp_path / "artifact", False)]
+    assert correctness["state"] == "no-applied-relations"
+    assert fallback == {
+        "abi": "pyamplicol-numerical-current-reuse-fallback-v1",
+        "requested_mode": "certified-reuse",
+        "effective_mode": "off",
+        "effective_reuse_state": "disabled",
+        "reason": "evidence-envelope-fallback",
+        "geometry": geometry.to_json_dict(),
+        "certified_relation_count": 0,
+        "applied_relation_count": 0,
+    }
+
+
+def _raw_arena_profile(
+    *,
+    execution_mode: str = "compiled",
+    points: int = 128,
+    wall_time: float = 1.1e-6 * 128,
+) -> dict[str, object]:
+    profile: dict[str, object] = {
+        "execution_mode": execution_mode,
+        "profile_boundary": ARENA_PROFILE_BOUNDARY,
+        "borrowed_flat_input": True,
+        "preallocated_output": True,
+        "phase_timing_scope": ARENA_PHASE_TIMING_SCOPE,
+        "evaluator_timing_available": False,
+        "points": points,
+        "wall_time_s": wall_time,
+        "orchestration_time_s": wall_time,
+        **{field: 0 for field in ZERO_ARENA_COUNTER_FIELDS},
+        **{field: 0.0 for field in ZERO_ARENA_PHASE_TIME_FIELDS},
+        **{field: [] for field in EMPTY_ARENA_PHASE_VECTOR_FIELDS},
+        **{field: 0 for field in ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS},
+        "state_component_count": 11,
+        "source_component_count": 7,
+    }
+    if execution_mode == "compiled":
+        profile.update(
+            {
+                "compiled_direct_arena_engine_count": 2,
+                "compiled_direct_arena_call_count": 3,
+                "evaluator_backend_call_count": 3,
+            }
+        )
+    return profile
+
+
+def _benchmark_fixture(
+    *,
+    arena_authenticated: bool = True,
+    execution_mode: str = "compiled",
+) -> SimpleNamespace:
+    evidence = build_arena_profile_evidence(
+        (_raw_arena_profile(execution_mode=execution_mode),) * 5,
+        execution_mode=execution_mode,
+        repetitions_per_profile=1,
+        batch_size=128,
+    )
+    return SimpleNamespace(
+        uncertainty=SimpleNamespace(
+            standard_error=1.0e-9,
+            relative_standard_error=0.01,
+        ),
+        wall_time_per_point=1.0e-6,
+        evaluator_time_per_point=None,
+        sample_count=5,
+        effective_config=SimpleNamespace(target_runtime=5.0),
+        timing_breakdown=SimpleNamespace(
+            wall_time=SimpleNamespace(
+                mean_seconds_per_point=evidence[
+                    "warmed_boundary_wall_seconds_per_point"
+                ]
+            ),
+            evaluator_call_time=None,
+        ),
+        arena_profile_evidence=evidence,
+        environment={
+            "evaluator_time_raw_seconds_per_point": None,
+            "evaluator_time_status": "unavailable",
+            "evaluator_time_ratio_eligible": False,
+            "evaluator_time_sample_pass": "runtime._profile_arena_repeated",
+            "timing_breakdown_sample_pass": "runtime._profile_arena_repeated",
+            "profile_protocol": "arena",
+            "report_command_path": PAIRED_ARENA_PROFILE_COMMAND_PATH,
+            "report_public_cli_path": None,
+            "profile_attribution_boundary": (
+                "warmed-direct-arena-borrowed-input-preallocated-output-v1"
+            ),
+            "profile_attribution_borrowed_flat_input": arena_authenticated,
+            "profile_attribution_preallocated_output": True,
+            "profile_attribution_phase_timing_scope": ("coarse-arena-boundary-only-v1"),
+            "profile_attribution_evaluator_timing_available": False,
+            "profile_attribution_paired_with_headline": True,
+            "profile_attribution_identical_batch": True,
+            "profile_attribution_identical_repetitions": True,
+            "execution_mode": execution_mode,
+            "evaluator_sample_count": 5,
+            "native_profile_points_per_sample": 128,
+            "native_profile_repetitions_per_sample": 1,
+            "native_profile_batch_size": 128,
+            "timing_sample_contract": (
+                "paired_unprofiled_headline_profiled_attribution_v1"
+            ),
+            "elapsed_seconds": 5.0,
+            "completed_sample_count": 5,
+            "planned_sample_count": 5,
+            "repetitions_per_sample": 128,
+            "measured_point_count": 640,
+            "interrupted": False,
+        },
+    )
+
+
+def test_benchmark_measurement_records_authenticated_arena_unavailable_timing() -> None:
+    measurement = _benchmark_measurement(
+        _benchmark_fixture(),
+        matrix_element=2.0,
+    )
+
+    assert measurement["execution_seconds_per_point"] is None
+    assert measurement["evaluator_total_timing"] is None
+    assert measurement["execution_timing"] == {
+        "abi": "pyamplicol-report-arena-execution-timing-v2",
+        "status": "unavailable",
+        "ratio_eligible": False,
+        "raw_seconds_per_point": None,
+        "sample_count": 5,
+        "native_profile_points_per_sample": 128,
+        "repetitions_per_sample": 1,
+        "batch_size": 128,
+        "sample_contract": ("paired_unprofiled_headline_profiled_attribution_v1"),
+        "profile_protocol": "arena",
+        "profile_sample_pass": "runtime._profile_arena_repeated",
+        "profile_boundary": (
+            "warmed-direct-arena-borrowed-input-preallocated-output-v1"
+        ),
+        "borrowed_flat_input": True,
+        "preallocated_output": True,
+        "phase_timing_scope": "coarse-arena-boundary-only-v1",
+        "evaluator_timing_available": False,
+        "paired_with_headline": True,
+        "identical_batch": True,
+        "identical_repetitions": True,
+        "execution_mode": "compiled",
+        "warmed_boundary_wall_seconds_per_point": 1.1e-6,
+        "arena_profile_evidence_sha256": digest_arena_profile_value(
+            measurement["arena_profile_evidence"]
+        ),
+    }
+    assert measurement["benchmark_evidence"] == {
+        "report_command_path": PAIRED_ARENA_PROFILE_COMMAND_PATH,
+        "report_public_cli_path": None,
+        "measurement_phase_elapsed_seconds": 5.0,
+        "target_runtime_seconds": 5.0,
+        "achieved_runtime_seconds": 5.0,
+        "target_runtime_achieved": True,
+        "completed_sample_count": 5,
+        "planned_sample_count": 5,
+        "repetitions_per_sample": 128,
+        "measured_point_count": 640,
+        "interrupted": False,
+    }
+
+
+def test_benchmark_measurement_rejects_unauthenticated_unavailable_timing() -> None:
+    with pytest.raises(RunnerError, match="warmed Arena profile boundary"):
+        _benchmark_measurement(
+            _benchmark_fixture(arena_authenticated=False),
+            matrix_element=2.0,
+        )
+
+
+@pytest.mark.parametrize("execution_mode", ("compiled", "eager"))
+def test_benchmark_measurement_authenticates_accumulated_evaluator_total(
+    execution_mode: str,
+) -> None:
+    benchmark = _benchmark_fixture(execution_mode=execution_mode)
+    benchmark.wall_time_per_point = 1.0e-6
+    benchmark.evaluator_total_time_per_point = 1.0e-6
+    benchmark.environment.update(
+        {
+            "evaluator_total_time_raw_seconds_per_point": 1.0e-6,
+            "evaluator_total_time_status": "measured",
+            "evaluator_total_time_ratio_eligible": False,
+            "evaluator_total_time_source": (
+                "runtime._benchmark_f64_wall_time.accumulated"
+            ),
+            "evaluator_total_time_sample_contract": (
+                "accumulated-repeated-warmed-evaluator-total-v1"
+            ),
+            "evaluator_total_accumulated_seconds": 6.4e-4,
+        }
+    )
+
+    measurement = _benchmark_measurement(benchmark, matrix_element=2.0)
+
+    assert measurement["execution_seconds_per_point"] is None
+    assert measurement["evaluator_total_timing"] == {
+        "abi": "pyamplicol-report-evaluator-total-timing-v1",
+        "status": "measured",
+        "ratio_eligible": False,
+        "raw_seconds_per_point": 1.0e-6,
+        "source": "runtime._benchmark_f64_wall_time.accumulated",
+        "execution_mode": execution_mode,
+        "sample_contract": ("accumulated-repeated-warmed-evaluator-total-v1"),
+        "sample_count": 5,
+        "repetitions_per_sample": 1,
+        "batch_size": 128,
+        "points_per_sample": 128,
+        "measured_point_count": 640,
+        "accumulated_seconds": 6.4e-4,
+    }
+
+
+def test_benchmark_measurement_rejects_inconsistent_accumulated_evaluator_total() -> (
+    None
+):
+    benchmark = _benchmark_fixture()
+    benchmark.evaluator_total_time_per_point = 1.0e-6
+    benchmark.environment.update(
+        {
+            "evaluator_total_time_raw_seconds_per_point": 1.0e-6,
+            "evaluator_total_time_status": "measured",
+            "evaluator_total_time_ratio_eligible": False,
+            "evaluator_total_time_source": (
+                "runtime._benchmark_f64_wall_time.accumulated"
+            ),
+            "evaluator_total_time_sample_contract": (
+                "accumulated-repeated-warmed-evaluator-total-v1"
+            ),
+            "evaluator_total_accumulated_seconds": 1.0,
+        }
+    )
+
+    with pytest.raises(RunnerError, match="accumulated evaluator-total"):
+        _benchmark_measurement(benchmark, matrix_element=2.0)
+
+
+def test_benchmark_measurement_rejects_synthetic_zero_execution() -> None:
+    benchmark = _benchmark_fixture()
+    benchmark.evaluator_time_per_point = 0.0
+    benchmark.environment.update(
+        {
+            "evaluator_time_status": "measured",
+            "evaluator_time_raw_seconds_per_point": 0.0,
+            "evaluator_time_ratio_eligible": False,
+            "evaluator_time_source": "runtime_profile_core_evaluator_call_time",
+            "compiled_direct_arena_active": False,
+        }
+    )
+
+    with pytest.raises(RunnerError, match="measured execution timing"):
+        _benchmark_measurement(benchmark, matrix_element=2.0)
+
+
+def test_benchmark_measurement_rejects_uncertainty_for_unexposed_execution() -> None:
+    benchmark = _benchmark_fixture()
+    benchmark.evaluator_uncertainty = SimpleNamespace(standard_error=0.0)
+
+    with pytest.raises(RunnerError, match="warmed Arena profile boundary"):
+        _benchmark_measurement(benchmark, matrix_element=2.0)
+
+
+def test_benchmark_measurement_retains_supported_recurrence_execution_timing() -> None:
+    benchmark = _benchmark_fixture()
+    benchmark.evaluator_time_per_point = 8.0e-7
+    benchmark.evaluator_total_time_per_point = 1.2e-6
+    benchmark.environment.update(
+        {
+            "evaluator_time_status": "measured",
+            "evaluator_time_raw_seconds_per_point": 8.0e-7,
+            "evaluator_time_ratio_eligible": True,
+            "evaluator_time_source": "runtime_profile_core_evaluator_call_time",
+            "compiled_direct_arena_active": False,
+            "execution_mode": "recurrence",
+            "timing_sample_contract": "paired-native-repeated-profile-v1",
+            "evaluator_total_time_raw_seconds_per_point": 1.2e-6,
+            "evaluator_total_time_status": "measured",
+            "evaluator_total_time_ratio_eligible": False,
+            "evaluator_total_time_source": (
+                "runtime._benchmark_f64_wall_time.accumulated"
+            ),
+            "evaluator_total_time_sample_contract": (
+                "accumulated-repeated-warmed-evaluator-total-v1"
+            ),
+            "evaluator_total_accumulated_seconds": 7.68e-4,
+        }
+    )
+
+    measurement = _benchmark_measurement(benchmark, matrix_element=2.0)
+
+    assert measurement["execution_seconds_per_point"] == 8.0e-7
+    assert measurement["arena_profile_evidence"] is None
+    assert measurement["evaluator_total_timing"] == {
+        "abi": "pyamplicol-report-evaluator-total-timing-v1",
+        "status": "measured",
+        "ratio_eligible": False,
+        "raw_seconds_per_point": 1.2e-6,
+        "source": "runtime._benchmark_f64_wall_time.accumulated",
+        "execution_mode": "recurrence",
+        "sample_contract": ("accumulated-repeated-warmed-evaluator-total-v1"),
+        "sample_count": 5,
+        "repetitions_per_sample": 1,
+        "batch_size": 128,
+        "points_per_sample": 128,
+        "measured_point_count": 640,
+        "accumulated_seconds": 7.68e-4,
+    }
+    assert measurement["execution_timing"] == {
+        "abi": "pyamplicol-report-execution-timing-v1",
+        "status": "measured",
+        "ratio_eligible": True,
+        "raw_seconds_per_point": 8.0e-7,
+        "source": "runtime_profile_core_evaluator_call_time",
+        "compiled_direct_arena_active": False,
+        "sample_count": 5,
+        "native_profile_points_per_sample": 128,
+        "sample_contract": "paired-native-repeated-profile-v1",
+    }
+
+
+@pytest.mark.parametrize(
+    "execution_mode",
+    (ExecutionMode.EAGER, ExecutionMode.COMPILED),
+)
+def test_report_arena_benchmark_uses_private_profiler_without_public_fallback(
+    execution_mode: ExecutionMode,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class Runtime:
+        def __init__(self) -> None:
+            self.wall_calls: list[tuple[object, int, dict[str, object]]] = []
+            self.arena_calls: list[tuple[object, int, dict[str, object]]] = []
+            self.public_profile_calls = 0
+
+        def _benchmark_f64_wall_time(
+            self,
+            batch: object,
+            repetitions: int,
+            **kwargs: object,
+        ) -> float:
+            self.wall_calls.append((batch, repetitions, dict(kwargs)))
+            return 1.0e-3
+
+        def _profile_arena_repeated(
+            self,
+            batch: object,
+            repetitions: int,
+            **kwargs: object,
+        ) -> dict[str, object]:
+            self.arena_calls.append((batch, repetitions, dict(kwargs)))
+            assert isinstance(batch, tuple)
+            return _raw_arena_profile(
+                execution_mode=execution_mode.value,
+                points=len(batch) * repetitions,
+                wall_time=2.0e-3,
+            )
+
+        def profile_repeated(self, *_args: object, **_kwargs: object) -> object:
+            self.public_profile_calls += 1
+            raise AssertionError("public profile_repeated must not be used")
+
+    backend = Runtime()
+    runtime = SimpleNamespace(_backend=backend)
+    clock_values = [0.0, 0.0, 0.2e-3, 0.2e-3, 0.4e-3, 0.4e-3]
+    clock = 0.4e-3
+    for _ in range(5):
+        clock_values.extend((clock, clock + 1.2e-3, clock + 1.2e-3, clock + 3.2e-3))
+        clock += 3.2e-3
+    clock_values.extend((clock, clock + 0.1e-3))
+    clock_iterator = iter(clock_values)
+    monkeypatch.setattr(
+        "tools.performance_report.runner.time.perf_counter",
+        lambda: next(clock_iterator),
+    )
+    result = _run_report_benchmark(
+        runtime,
+        (((1.0, 0.0, 0.0, 1.0),),),
+        execution_mode=execution_mode,
+        benchmark_config=SimpleNamespace(
+            target_runtime=5.0e-3,
+            batch_size=2,
+            warmup_runs=1,
+            minimum_samples=5,
+            precision=16,
+        ),
+        selectors={"helicities": None, "color_flows": ("flow:1",)},
+    )
+
+    assert result.sample_count == 5
+    assert result.evaluator_time_per_point is None
+    assert result.wall_time_per_point == pytest.approx(6.0e-4)
+    assert result.evaluator_total_time_per_point == pytest.approx(5.0e-4)
+    assert result.wall_time_per_point != result.evaluator_total_time_per_point
+    assert result.environment["elapsed_seconds"] == pytest.approx(6.0e-3)
+    assert result.environment["evaluator_total_accumulated_seconds"] == pytest.approx(
+        5.0e-3
+    )
+    assert result.environment["measured_point_count"] == 10
+    assert result.environment["warmup_elapsed_seconds"] == pytest.approx(0.2e-3)
+    assert result.environment["calibration_elapsed_seconds"] == pytest.approx(0.2e-3)
+    assert result.environment["calibration_outer_elapsed_seconds"] == pytest.approx(
+        0.2e-3
+    )
+    assert result.environment["measurement_phase_elapsed_seconds"] == pytest.approx(
+        16.0e-3
+    )
+    assert result.environment["profile_total_elapsed_seconds"] == pytest.approx(16.5e-3)
+    measurement = _benchmark_measurement(result, matrix_element=2.0)
+    total_timing = measurement["evaluator_total_timing"]
+    assert isinstance(total_timing, dict)
+    assert total_timing["execution_mode"] == execution_mode.value
+    assert total_timing["raw_seconds_per_point"] == pytest.approx(5.0e-4)
+    assert total_timing["accumulated_seconds"] == pytest.approx(5.0e-3)
+    assert total_timing["measured_point_count"] == 10
+    assert result.arena_profile_evidence["profile_count"] == 5
+    assert backend.public_profile_calls == 0
+    assert len(backend.arena_calls) == 6
+    for wall_call, arena_call in zip(
+        backend.wall_calls[-5:],
+        backend.arena_calls[-5:],
+        strict=True,
+    ):
+        wall_batch, wall_repetitions, wall_kwargs = wall_call
+        arena_batch, arena_repetitions, arena_kwargs = arena_call
+        assert arena_batch == wall_batch
+        assert arena_repetitions == wall_repetitions
+        assert arena_kwargs == {**wall_kwargs, "include_values": False}
+
+
+def test_report_arena_benchmark_recovers_from_busy_floor_calibration(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class Clock:
+        value = 0.0
+
+        def advance(self, duration: float) -> None:
+            self.value += duration
+
+    class Runtime:
+        def __init__(self, clock: Clock) -> None:
+            self.clock = clock
+            self.wall_repetitions: list[int] = []
+            self.profile_repetitions: list[int] = []
+
+        def _benchmark_f64_wall_time(
+            self,
+            batch: object,
+            repetitions: int,
+            **_kwargs: object,
+        ) -> float:
+            assert isinstance(batch, tuple)
+            self.wall_repetitions.append(repetitions)
+            duration = (
+                3.753739778
+                if len(self.wall_repetitions) == 1
+                else 0.0181 * repetitions
+            )
+            self.clock.advance(duration)
+            return duration
+
+        def _profile_arena_repeated(
+            self,
+            batch: object,
+            repetitions: int,
+            **_kwargs: object,
+        ) -> dict[str, object]:
+            assert isinstance(batch, tuple)
+            self.profile_repetitions.append(repetitions)
+            duration = 1.0e-3
+            self.clock.advance(duration)
+            return _raw_arena_profile(
+                execution_mode="compiled",
+                points=len(batch) * repetitions,
+                wall_time=duration,
+            )
+
+    clock = Clock()
+    runtime = Runtime(clock)
+    guarded_estimates: list[float | None] = []
+    monkeypatch.setattr(
+        "tools.performance_report.runner.time.perf_counter",
+        lambda: clock.value,
+    )
+
+    result = _run_arena_benchmark(
+        runtime,
+        (((1.0, 0.0, 0.0, 1.0),),),
+        execution_mode="compiled",
+        benchmark_config=SimpleNamespace(
+            target_runtime=5.0,
+            batch_size=2,
+            warmup_runs=0,
+            minimum_samples=5,
+            precision=16,
+        ),
+        selectors={"helicities": None, "color_flows": None},
+        chunk_guard=lambda estimate, _label: guarded_estimates.append(estimate),
+    )
+
+    assert result.sample_count == 5
+    assert result.environment["elapsed_seconds"] == pytest.approx(5.068)
+    assert result.environment["repetitions_per_sample"] == 56
+    assert result.environment["calibration"]["blocks"] == [
+        {"repetitions": 1, "duration_seconds": 3.753739778},
+        {"repetitions": 1, "duration_seconds": 0.0181},
+        {"repetitions": 56, "duration_seconds": pytest.approx(1.0136)},
+    ]
+    assert runtime.wall_repetitions == [1, 1, 56, 56, 56, 56, 56, 56]
+    assert runtime.profile_repetitions == [56] * 5
+    assert guarded_estimates[:3] == [
+        None,
+        pytest.approx(3.753739778),
+        pytest.approx(1.0136),
+    ]
+
+
+def test_report_arena_calibration_confirms_genuinely_slow_floor_once() -> None:
+    calls: list[int] = []
+
+    def timer(
+        _batch: object,
+        repetitions: int,
+        **_arguments: object,
+    ) -> float:
+        calls.append(repetitions)
+        return 2.0
+
+    repetitions, blocks = _calibrate_arena_repetitions(
+        timer,
+        (((1.0, 0.0, 0.0, 1.0),),),
+        target_runtime=5.0,
+        sample_count=5,
+        selector_arguments={},
+    )
+
+    assert repetitions == 1
+    assert calls == [1, 1]
+    assert blocks == [
+        {"repetitions": 1, "duration_seconds": 2.0},
+        {"repetitions": 1, "duration_seconds": 2.0},
+    ]
+
+
+def test_report_arena_benchmark_requires_private_profiler() -> None:
+    runtime = SimpleNamespace(
+        _benchmark_f64_wall_time=lambda *_args, **_kwargs: 1.0,
+        profile_repeated=lambda *_args, **_kwargs: {},
+    )
+
+    with pytest.raises(RunnerError, match=r"_profile_arena_repeated"):
+        _run_arena_benchmark(
+            runtime,
+            (((1.0, 0.0, 0.0, 1.0),),),
+            execution_mode="compiled",
+            benchmark_config=SimpleNamespace(
+                target_runtime=5.0,
+                batch_size=2,
+                warmup_runs=1,
+                minimum_samples=5,
+                precision=16,
+            ),
+            selectors={"helicities": None, "color_flows": None},
+        )
+
+
+def test_report_arena_benchmark_reports_typed_profile_stages(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pyamplicol.reporting import (
+        CallbackProgressSink,
+        ProgressEnd,
+        ProgressStart,
+        ProgressUpdate,
+    )
+
+    class Runtime:
+        def _benchmark_f64_wall_time(
+            self,
+            batch: object,
+            repetitions: int,
+            **_kwargs: object,
+        ) -> float:
+            del batch, repetitions
+            return 1.0e-3
+
+        def _profile_arena_repeated(
+            self,
+            batch: object,
+            repetitions: int,
+            **_kwargs: object,
+        ) -> dict[str, object]:
+            assert isinstance(batch, tuple)
+            return _raw_arena_profile(
+                points=len(batch) * repetitions,
+                wall_time=2.0e-3,
+            )
+
+    clock = -1.0e-3
+
+    def tick() -> float:
+        nonlocal clock
+        clock += 1.0e-3
+        return clock
+
+    monkeypatch.setattr(
+        "tools.performance_report.runner.time.perf_counter",
+        tick,
+    )
+    events: list[ProgressStart | ProgressUpdate | ProgressEnd] = []
+    _run_arena_benchmark(
+        Runtime(),
+        (((1.0, 0.0, 0.0, 1.0),),),
+        execution_mode="compiled",
+        benchmark_config=SimpleNamespace(
+            target_runtime=4.0e-3,
+            batch_size=2,
+            warmup_runs=1,
+            minimum_samples=5,
+            precision=16,
+        ),
+        selectors={"helicities": None, "color_flows": None},
+        progress=CallbackProgressSink(events.append),
+    )
+
+    starts = {event.task_id for event in events if isinstance(event, ProgressStart)}
+    updates = {event.task_id for event in events if isinstance(event, ProgressUpdate)}
+    assert starts == {
+        "report-profile",
+        "report-profile:warmup",
+        "report-profile:calibration",
+        "report-profile:samples",
+    }
+    assert updates == {
+        "report-profile:warmup",
+        "report-profile:calibration",
+        "report-profile:samples",
+    }
+    assert isinstance(events[-1], ProgressEnd)
+    assert events[-1].task_id == "report-profile"
+    assert events[-1].success is True
+
+
+def test_report_benchmark_keeps_recurrence_on_supported_public_runner(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol.cli
+
+    calls: list[tuple[object, object]] = []
+    parsed_argv: list[tuple[str, ...]] = []
+    real_parse_cli = pyamplicol.cli.parse_cli
+
+    def parse_cli(argv: tuple[str, ...]):
+        parsed_argv.append(tuple(argv))
+        return real_parse_cli(argv)
+
+    @dataclass(frozen=True)
+    class Result:
+        environment: dict[str, object]
+
+    expected = Result(environment={"existing": "evidence"})
+
+    class BenchmarkRunner:
+        def __init__(
+            self,
+            config: object,
+            *,
+            progress: object | None = None,
+        ) -> None:
+            self.config = config
+            assert progress is not None
+
+        def run(self, runtime: object, *, points: object) -> object:
+            calls.append((runtime, points))
+            return expected
+
+    monkeypatch.setattr("pyamplicol.api.BenchmarkRunner", BenchmarkRunner)
+    monkeypatch.setattr(pyamplicol.cli, "parse_cli", parse_cli)
+    runtime = SimpleNamespace(_backend=SimpleNamespace())
+    points = (((1.0, 0.0, 0.0, 1.0),),)
+    from pyamplicol.config import BenchmarkConfig
+
+    result = _run_report_benchmark(
+        runtime,
+        points,
+        execution_mode=ExecutionMode.RECURRENCE,
+        benchmark_config=BenchmarkConfig(),
+        selectors={"helicities": None, "color_flows": None},
+    )
+
+    assert result is not expected
+    assert result.environment["profile_total_elapsed_seconds"] >= 0.0
+    observed_environment = dict(result.environment)
+    observed_environment.pop("profile_total_elapsed_seconds")
+    assert observed_environment == {
+        "existing": "evidence",
+        "report_command_path": LOADED_RUNTIME_PROFILE_COMMAND_PATH,
+        "report_public_cli_path": PUBLIC_CLI_COMMAND_PATH,
+    }
+    assert calls == [(runtime, points)]
+    assert len(parsed_argv) == 1
+    assert parsed_argv[0][0] == "profile"
+    assert "--target-runtime" in parsed_argv[0]
+
+
+@pytest.mark.parametrize(
+    "field",
+    (
+        "native_input_container_allocation_count",
+        "native_input_pack_bytes",
+        "stage_evaluator_output_gather_component_count",
+        "selector_scatter_value_count",
+        "amplitude_output_remap_component_count",
+    ),
+)
+def test_arena_profile_evidence_rejects_warmed_boundary_traffic(
+    field: str,
+) -> None:
+    profile = _raw_arena_profile()
+    profile[field] = 1
+
+    with pytest.raises(ArenaProfileEvidenceError, match=field):
+        build_arena_profile_evidence(
+            (profile,),
+            execution_mode="compiled",
+            repetitions_per_profile=1,
+            batch_size=128,
+        )
+
+
+@pytest.mark.parametrize(
+    "field",
+    (
+        "compiled_direct_arena_engine_count",
+        "compiled_direct_arena_call_count",
+        "evaluator_backend_call_count",
+    ),
+)
+def test_arena_profile_evidence_keeps_compiled_activity_fail_closed(
+    field: str,
+) -> None:
+    profile = _raw_arena_profile()
+    profile[field] = 0
+
+    with pytest.raises(ArenaProfileEvidenceError, match="activity counters"):
+        build_arena_profile_evidence(
+            (profile,),
+            execution_mode="compiled",
+            repetitions_per_profile=1,
+            batch_size=128,
+        )
+
+
+def test_arena_profile_evidence_recomputes_all_native_counters() -> None:
+    evidence = build_arena_profile_evidence(
+        (_raw_arena_profile(),) * 5,
+        execution_mode="compiled",
+        repetitions_per_profile=1,
+        batch_size=128,
+    )
+
+    assert evidence["counter_totals"]["points"] == 640
+    assert evidence["counter_totals"]["state_component_count"] == 55
+    assert evidence["counter_totals"]["source_component_count"] == 35
+
+    evidence["counter_totals"]["state_component_count"] = 54
+    with pytest.raises(
+        ArenaProfileEvidenceError,
+        match="independently recomputed",
+    ):
+        validate_arena_profile_evidence(
+            evidence,
+            execution_mode="compiled",
+            sample_count=5,
+            native_profile_points_per_sample=128,
+        )
+
+
+def test_arena_profile_evidence_rejects_recurrence_protocol_claim() -> None:
+    with pytest.raises(ArenaProfileEvidenceError, match="unsupported"):
+        build_arena_profile_evidence(
+            (_raw_arena_profile(execution_mode="recurrence"),),
+            execution_mode="recurrence",
+            repetitions_per_profile=1,
+            batch_size=128,
+        )
+
+
+def _digest_json(value: object) -> str:
+    return hashlib.sha256(
+        json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+
+
+def _binding_digest(binding: dict[str, object]) -> str:
+    if binding["kind"] != "rusticol-intrinsic":
+        payload = dict(binding)
+        payload.pop("payload_digest", None)
+        return _digest_json(payload)
+    fields = (
+        "abi",
+        "contribution_parent_permutation",
+        "kind",
+        "runtime_template",
+    )
+    return _digest_json({field: binding.get(field) for field in fields})
+
+
+def _refresh_recurrence_catalog(
+    execution: dict[str, object],
+    pack: dict[str, object],
+    *,
+    refresh_binding_digests: bool = True,
+) -> None:
+    catalog = pack["recurrence_direct_template"]
+    assert isinstance(catalog, dict)
+    templates = catalog["templates"]
+    assert isinstance(templates, list)
+    for template in templates:
+        assert isinstance(template, dict)
+        binding = template["payload_binding"]
+        assert isinstance(binding, dict)
+        if refresh_binding_digests:
+            binding["payload_digest"] = _binding_digest(binding)
+        semantic = dict(template)
+        semantic.pop("semantic_digest", None)
+        template["semantic_digest"] = _digest_json(semantic)
+    semantic_catalog = dict(catalog)
+    semantic_catalog.pop("catalog_digest", None)
+    catalog["catalog_digest"] = _digest_json(semantic_catalog)
+    execution["direct_template_catalog_digest"] = catalog["catalog_digest"]
+    plan = execution["plan"]
+    assert isinstance(plan, dict)
+    plan["direct_template_catalog_digest"] = catalog["catalog_digest"]
+
+
+def _canonical_symjit_evaluator(
+    application_path: str,
+    plane_path: str,
+    *,
+    optimization_level: int,
+    input_len: int = 1,
+    output_len: int = 1,
+    source_digest: str = "1" * 64,
+) -> dict[str, object]:
+    return {
+        "kind": "symjit-application-evaluator",
+        "runtime_capability": "symjit.application.complex-f64.v1",
+        "input_len": input_len,
+        "output_len": output_len,
+        "application_path": application_path,
+        "application_abi": "symjit-application-storage-v3",
+        "element_layout": "complex-f64",
+        "batch_layout": "row-major",
+        "compiler_type": "native",
+        "translation_mode": "indirect",
+        "optimization_level": optimization_level,
+        "word_bits": 64,
+        "endianness": "little",
+        "required_defuns": [],
+        "evaluator_state_path": f"{application_path}.state",
+        "evaluator_state_runtime_capability": (
+            "symbolica.legacy-jit-container.complex-f64.v1"
+        ),
+        "plane_application": {
+            "application_path": plane_path,
+            "application_abi": "pyamplicol-symjit-plane-application-v2",
+            "storage_abi": "symjit-application-storage-v3",
+            "element_layout": "split-complex-plane-major",
+            "descriptor_order": "inputs-re-im-then-outputs-re-im",
+            "input_complex_count": input_len,
+            "output_complex_count": output_len,
+            "input_plane_count": 2 * input_len,
+            "output_plane_count": 2 * output_len,
+            "compiler_type": "native",
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": optimization_level,
+            "simd": True,
+            "complex": True,
+            "fast_math": True,
+            "fast_complex": False,
+            "compression": False,
+            "threading": False,
+            "direct_arena": True,
+            "source_digest": source_digest,
+            "target": {"word_bits": 64, "endianness": "little"},
+        },
+    }
+
+
+@pytest.mark.parametrize("optimization_level", (1, 3))
+@pytest.mark.parametrize("chunked", (False, True))
+def test_canonical_symjit_serializer_round_trips_into_report_authentication(
+    optimization_level: int,
+    chunked: bool,
+) -> None:
+    raw = _canonical_symjit_evaluator(
+        "evaluators/left.symjit",
+        "evaluators/left.plane.symjit",
+        optimization_level=optimization_level,
+    )
+    raw["backend"] = "jit"
+    if chunked:
+        right = _canonical_symjit_evaluator(
+            "evaluators/right.symjit",
+            "evaluators/right.plane.symjit",
+            optimization_level=optimization_level,
+        )
+        right["backend"] = "jit"
+        serialized = _serialize_evaluator(
+            {
+                "kind": "chunked-symbolica-evaluator",
+                "input_len": 2,
+                "chunk_input_indices": [[0], [1]],
+                "required_runtime_capabilities": ["symjit.application.complex-f64.v1"],
+                "chunks": [raw, right],
+            }
+        )
+    else:
+        serialized = _serialize_evaluator(raw)
+
+    leaves = _authenticated_symjit_plane_leaves(
+        serialized,
+        source_optimization_level=optimization_level,
+        context="serialized evaluator",
+    )
+
+    assert len(leaves) == (2 if chunked else 1)
+    for leaf in serialized["chunks"] if chunked else [serialized]:
+        assert "backend" not in leaf
+        assert leaf["compiler_type"] == "native"
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    (
+        ("backend", "native"),
+        ("backend", None),
+        ("compiler_type", "interpreter"),
+    ),
+)
+def test_symjit_report_authentication_rejects_contradictory_identity(
+    field: str,
+    value: object,
+) -> None:
+    evaluator = _canonical_symjit_evaluator(
+        "evaluators/stage.symjit",
+        "evaluators/stage.plane.symjit",
+        optimization_level=3,
+    )
+    evaluator[field] = value
+
+    with pytest.raises(RunnerError, match="leaf contract drifted"):
+        _authenticated_symjit_plane_leaves(
+            evaluator,
+            source_optimization_level=3,
+            context="corrupt evaluator",
+        )
+
+
+def test_symjit_report_authentication_accepts_fallback_free_portable_leaf() -> None:
+    evaluator = _canonical_symjit_evaluator(
+        "evaluators/stage.symjit",
+        "evaluators/stage.plane.symjit",
+        optimization_level=3,
+    )
+    evaluator["evaluator_state_path"] = None
+    evaluator["evaluator_state_runtime_capability"] = None
+
+    assert _authenticated_symjit_plane_leaves(
+        evaluator,
+        source_optimization_level=3,
+        context="portable evaluator",
+    ) == [("evaluators/stage.plane.symjit", "1" * 64)]
+
+
+@pytest.mark.parametrize(
+    ("state_path", "capability"),
+    (
+        (None, "symbolica.legacy-jit-container.complex-f64.v1"),
+        ("evaluators/stage.state", None),
+    ),
+)
+def test_symjit_report_authentication_rejects_partial_fallback_pair(
+    state_path: str | None,
+    capability: str | None,
+) -> None:
+    evaluator = _canonical_symjit_evaluator(
+        "evaluators/stage.symjit",
+        "evaluators/stage.plane.symjit",
+        optimization_level=3,
+    )
+    evaluator["evaluator_state_path"] = state_path
+    evaluator["evaluator_state_runtime_capability"] = capability
+
+    with pytest.raises(RunnerError, match="fallback contract drifted"):
+        _authenticated_symjit_plane_leaves(
+            evaluator,
+            source_optimization_level=3,
+            context="partial fallback evaluator",
+        )
+
+
+@pytest.mark.parametrize(
+    "target",
+    (
+        {"word_bits": 64.0, "endianness": "little"},
+        {
+            "word_bits": 64,
+            "endianness": "little",
+            "cpu_features": ["z", "a"],
+        },
+        {"word_bits": 64, "endianness": "little", "unknown": True},
+    ),
+)
+def test_symjit_report_authentication_rejects_noncanonical_target(
+    target: dict[str, object],
+) -> None:
+    evaluator = _canonical_symjit_evaluator(
+        "evaluators/stage.symjit",
+        "evaluators/stage.plane.symjit",
+        optimization_level=3,
+    )
+    plane = evaluator["plane_application"]
+    assert isinstance(plane, dict)
+    plane["target"] = target
+
+    with pytest.raises(RunnerError, match="plane application contract drifted"):
+        _authenticated_symjit_plane_leaves(
+            evaluator,
+            source_optimization_level=3,
+            context="noncanonical target evaluator",
+        )
+
+
+def _recurrence_source_fixture(
+    source_sha256: str,
+) -> tuple[dict[str, object], dict[str, object]]:
+    ordinary_source_path = "kernels/000000/application-0.symjit"
+    source_path = "kernels/000000/application-0.plane.symjit"
+    prepared_binding: dict[str, object] = {
+        "abi": "pyamplicol-recurrence-plane-binding-v2",
+        "contribution_parent_permutation": [0, 1],
+        "destination_operation": "finalize-in-place",
+        "direct_application_abi": "pyamplicol-symjit-plane-application-v2",
+        "exact_factor_scalar_slots": [0, 1],
+        "input_plane_count": 1,
+        "input_plane_projections": [{"kind": "destination-current"}],
+        "intrinsic_contract_digest": None,
+        "kind": "prepared-direct-call",
+        "output_alias_inputs": [0],
+        "parameter_bindings": [{"index": 0, "kind": "plane"}],
+        "payload_digest": "",
+        "payload_paths": [source_path],
+        "prepared_kernel_id": 0,
+        "prepared_template_semantic_digest": "d" * 64,
+        "role": "finalization",
+        "runtime_template": None,
+        "scalar_input_count": 2,
+        "scalar_projections": [
+            {"imaginary": False, "kind": "exact-factor"},
+            {"imaginary": True, "kind": "exact-factor"},
+        ],
+        "source_application_abi": "pyamplicol-symjit-plane-application-v2",
+        "source_application_path": source_path,
+        "source_application_sha256": source_sha256,
+        "state_plane_indices": [],
+    }
+    intrinsic_binding: dict[str, object] = {
+        "abi": "pyamplicol-recurrence-plane-binding-v2",
+        "contribution_parent_permutation": [0, 1],
+        "destination_operation": None,
+        "direct_application_abi": None,
+        "exact_factor_scalar_slots": [],
+        "input_plane_count": 0,
+        "input_plane_projections": [],
+        "intrinsic_contract_digest": None,
+        "kind": "rusticol-intrinsic",
+        "output_alias_inputs": [],
+        "parameter_bindings": [],
+        "payload_digest": "",
+        "payload_paths": [],
+        "prepared_kernel_id": None,
+        "prepared_template_semantic_digest": None,
+        "role": None,
+        "runtime_template": "source-current",
+        "scalar_input_count": 0,
+        "scalar_projections": [],
+        "source_application_abi": None,
+        "source_application_path": None,
+        "source_application_sha256": None,
+        "state_plane_indices": [],
+    }
+    templates: list[dict[str, object]] = [
+        {
+            "abi": "pyamplicol-recurrence-direct-template-v1",
+            "alignment_bytes": 64,
+            "backend": "jit",
+            "coupling_slot_count": 0,
+            "destination_aliasing": True,
+            "destination_component_count": 1,
+            "destination_operation": "finalize-in-place",
+            "direct_executor_id": 0,
+            "evaluator_binding_id": 0,
+            "evaluator_resolver_key": "prepared-kernel-0",
+            "exact_expression_digest": "e" * 64,
+            "momentum_operand_count": 0,
+            "optimization_level": 2,
+            "parameter_slot_count": 0,
+            "parent_arity": 1,
+            "parent_component_counts": [1],
+            "payload_binding": prepared_binding,
+            "portable": True,
+            "role": "finalization",
+            "semantic_digest": "",
+            "semantic_template_ids": ["prepared-finalization"],
+            "simd_axis": "points-contiguous",
+            "target_triple": "symjit-storage-v3-portable",
+            "template_id": "template-0",
+        },
+        {
+            "abi": "pyamplicol-recurrence-direct-template-v1",
+            "alignment_bytes": 64,
+            "backend": "jit",
+            "coupling_slot_count": 0,
+            "destination_aliasing": False,
+            "destination_component_count": 1,
+            "destination_operation": "initialize",
+            "direct_executor_id": 1,
+            "evaluator_binding_id": 1,
+            "evaluator_resolver_key": "source-current",
+            "exact_expression_digest": "f" * 64,
+            "momentum_operand_count": 0,
+            "optimization_level": 2,
+            "parameter_slot_count": 0,
+            "parent_arity": 0,
+            "parent_component_counts": [],
+            "payload_binding": intrinsic_binding,
+            "portable": True,
+            "role": "source",
+            "semantic_digest": "",
+            "semantic_template_ids": ["source-current"],
+            "simd_axis": "points-contiguous",
+            "target_triple": "symjit-storage-v3-portable",
+            "template_id": "template-1",
+        },
+    ]
+    prepared_digest = "a" * 64
+    catalog: dict[str, object] = {
+        "abi": "pyamplicol-recurrence-direct-template-v1",
+        "backend": "jit",
+        "backend_abi": "rusticol.recurrence-direct-backend.v1",
+        "canonicalization_abi": "pyamplicol-canonical-json-v1",
+        "catalog_digest": "",
+        "compiled_model_digest": "b" * 64,
+        "optimization_level": 2,
+        "optimization_settings_digest": "c" * 64,
+        "portable": True,
+        "prepared_kernel_contract_digest": "4" * 64,
+        "prepared_kernel_pack_digest": prepared_digest,
+        "prepared_kernel_payload_digest": "5" * 64,
+        "recurrence_template_catalog_digest": "6" * 64,
+        "target_triple": "symjit-storage-v3-portable",
+        "templates": templates,
+    }
+    execution: dict[str, object] = {
+        "kind": "pyamplicol-runtime-recurrence-execution",
+        "direct_template_abi": "pyamplicol-recurrence-direct-template-v1",
+        "direct_backend_abi": "rusticol.recurrence-direct-backend.v1",
+        "prepared_kernel_pack_digest": prepared_digest,
+        "direct_template_catalog_digest": "",
+        "kernel_pack": {
+            "manifest_path": "model/eager-kernel-pack.json",
+            "payload_root": "model/eager-kernels",
+        },
+        "plan": {
+            "direct_template_abi": "pyamplicol-recurrence-direct-template-v1",
+            "direct_backend_abi": "rusticol.recurrence-direct-backend.v1",
+            "prepared_kernel_pack_digest": prepared_digest,
+            "direct_template_catalog_digest": "",
+        },
+    }
+    pack: dict[str, object] = {
+        "backend": "jit",
+        "optimization_settings": {
+            "backend": "jit",
+            "jit_optimization_level": 2,
+        },
+        "recurrence_direct_template": catalog,
+        "kernel_variants": [],
+        "kernels": [
+            {
+                "kernel_id": 0,
+                "f64_evaluator_manifest": _canonical_symjit_evaluator(
+                    ordinary_source_path,
+                    source_path,
+                    optimization_level=2,
+                ),
+            }
+        ],
+    }
+    _refresh_recurrence_catalog(execution, pack)
+    return execution, pack
+
+
+def _write_json_payload(
+    root: Path,
+    relative: str,
+    value: object,
+    *,
+    process_id: str | None,
+) -> SimpleNamespace:
+    data = json.dumps(
+        value,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    path = root / relative
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(data)
+    return SimpleNamespace(
+        path=relative,
+        role="evaluator-manifest",
+        media_type="application/json",
+        size_bytes=len(data),
+        sha256=hashlib.sha256(data).hexdigest(),
+        executable=False,
+        process_id=process_id,
+    )
+
+
+def _runner_recurrence_artifact(
+    root: Path,
+) -> tuple[
+    SimpleNamespace,
+    dict[str, object],
+    dict[str, object],
+    SimpleNamespace,
+    SimpleNamespace,
+]:
+    process_id = "process-1"
+    index_relative = "processes/evaluators.json"
+    execution_relative = f"processes/{process_id}/execution.json"
+    pack_relative = "model/eager-kernel-pack.json"
+    source_relative = "model/eager-kernels/kernels/000000/application-0.plane.symjit"
+    source_data = b"authenticated-symjit-application"
+    source_sha256 = hashlib.sha256(source_data).hexdigest()
+    execution, pack = _recurrence_source_fixture(source_sha256)
+    index = {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-execution-set",
+        "processes": [
+            {
+                "process_id": process_id,
+                "manifest_path": f"{process_id}/execution.json",
+            }
+        ],
+    }
+    index_payload = _write_json_payload(
+        root,
+        index_relative,
+        index,
+        process_id=None,
+    )
+    execution_payload = _write_json_payload(
+        root,
+        execution_relative,
+        execution,
+        process_id=process_id,
+    )
+    pack_payload = _write_json_payload(
+        root,
+        pack_relative,
+        pack,
+        process_id=None,
+    )
+    source_path = root / source_relative
+    source_path.parent.mkdir(parents=True, exist_ok=True)
+    source_path.write_bytes(source_data)
+    source_payload = SimpleNamespace(
+        path=source_relative,
+        role="evaluator-state",
+        media_type="application/octet-stream",
+        size_bytes=len(source_data),
+        sha256=source_sha256,
+        executable=False,
+        process_id=None,
+    )
+    manifest = SimpleNamespace(
+        root=root,
+        runtime={"evaluator_manifest_path": index_relative},
+        payloads=(
+            index_payload,
+            execution_payload,
+            pack_payload,
+            source_payload,
+        ),
+        extensions={},
+    )
+    return manifest, execution, pack, execution_payload, pack_payload
+
+
+def _rewrite_json_payload(
+    root: Path,
+    record: SimpleNamespace,
+    value: object,
+) -> None:
+    data = json.dumps(
+        value,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    (root / record.path).write_bytes(data)
+    record.size_bytes = len(data)
+    record.sha256 = hashlib.sha256(data).hexdigest()
+
+
+def test_checked_runtime_identity_rejects_a_symlink(tmp_path: Path) -> None:
+    if not hasattr(os, "O_NOFOLLOW"):
+        pytest.skip("O_NOFOLLOW is unavailable")
+    target = tmp_path / "target.py"
+    target.write_text("VALUE = 1\n", encoding="utf-8")
+    link = tmp_path / "link.py"
+    link.symlink_to(target)
+    with pytest.raises(RunnerError, match="checked fd"):
+        _regular_file_identity(link)
+
+
+def test_effective_config_is_read_from_its_authenticated_artifact_payload(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    relative = "config/effective.toml"
+    data = b'[evaluator]\nbackend = "jit"\nexecution_mode = "compiled"\n'
+    path = tmp_path / relative
+    path.parent.mkdir(parents=True)
+    path.write_bytes(data)
+    manifest = SimpleNamespace(
+        root=tmp_path,
+        configuration={"effective_path": relative},
+        payloads=(
+            SimpleNamespace(
+                path=relative,
+                role="configuration-effective",
+                media_type="application/toml",
+                size_bytes=len(data),
+                sha256=hashlib.sha256(data).hexdigest(),
+                executable=False,
+                process_id=None,
+            ),
+        ),
+    )
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.load_manifest",
+        lambda _path, *, verify_payloads: manifest,
+    )
+
+    assert _authenticated_effective_config(tmp_path) == {
+        "evaluator": {
+            "backend": "jit",
+            "execution_mode": "compiled",
+        }
+    }
+
+    path.write_bytes(data.replace(b"compiled", b"eager   "))
+    with pytest.raises(RunnerError, match="artifact manifest"):
+        _authenticated_effective_config(tmp_path)
+
+
+@dataclass(frozen=True)
+class Flow:
+    id: str
+    word: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class Helicity:
+    id: str
+    values: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class Particle:
+    label: int
+    pdg_id: int = 1
+
+
+class Resolved:
+    def __init__(self, values: object, totals: tuple[complex, ...]) -> None:
+        self.values = values
+        self._totals = totals
+
+    def total(self) -> tuple[complex, ...]:
+        return self._totals
+
+
+class FakeRuntime:
+    def __init__(self) -> None:
+        self.physics = SimpleNamespace(
+            color_accuracy="lc",
+            selector_capabilities=("helicity", "color_flow"),
+            external_particles=(Particle(1), Particle(2), Particle(3)),
+            helicities=(
+                Helicity("h:-1,-1,-1", (-1, -1, -1)),
+                Helicity("h:-1,+1,-1", (-1, 1, -1)),
+            ),
+            color_flows=(
+                Flow("flow:2,1,3", (2, 1, 3)),
+                Flow("flow:1,2,3", (1, 2, 3)),
+            ),
+        )
+        self.optimized = (3.0 + 0.0j,)
+        self.resolved_total = (3.0 + 0.0j,)
+
+    def evaluate(self, _points: object, **_selectors: object) -> tuple[complex, ...]:
+        return self.optimized
+
+    def evaluate_resolved(
+        self,
+        _points: object,
+        **_selectors: object,
+    ) -> Resolved:
+        return Resolved(
+            (
+                (
+                    (0.0 + 0.0j,),
+                    (3.0 + 0.0j,),
+                ),
+            ),
+            self.resolved_total,
+        )
+
+
+def _cell(
+    mode: ExecutionMode,
+    accuracy: Accuracy,
+    workload: Workload,
+):
+    return next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode is mode
+        and cell.measurement.accuracy is accuracy
+        and cell.workload is workload
+    )
+
+
+def test_generation_phase_watchdog_covers_preparation_and_generator_call(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import pyamplicol.api
+    import pyamplicol.cli
+    import tools.performance_report.runner as report_runner
+
+    events: list[str] = []
+    parsed_argv: list[tuple[str, ...]] = []
+    real_parse_cli = pyamplicol.cli.parse_cli
+
+    def parse_cli(argv: tuple[str, ...]):
+        parsed_argv.append(tuple(argv))
+        return real_parse_cli(argv)
+
+    class FakeSource:
+        def compile(self, **_kwargs: object) -> object:
+            events.append("model-preparation")
+            return object()
+
+    class FakeModelSource:
+        @staticmethod
+        def built_in_sm() -> FakeSource:
+            return FakeSource()
+
+        @staticmethod
+        def from_path(_path: Path) -> FakeSource:
+            return FakeSource()
+
+    class FakeGenerator:
+        def __init__(
+            self,
+            _resolution: object,
+            *,
+            progress: object | None = None,
+        ) -> None:
+            assert progress is not None
+
+        def generate(self, *_args: object, **_kwargs: object) -> None:
+            events.append("Generator.generate")
+
+    class SpyReporter:
+        @contextmanager
+        def generation(self):
+            events.append("phase-enter")
+            try:
+                yield
+            finally:
+                events.append("phase-exit")
+
+    monkeypatch.setattr(pyamplicol.api, "Generator", FakeGenerator)
+    monkeypatch.setattr(pyamplicol.api, "ModelSource", FakeModelSource)
+    monkeypatch.setattr(pyamplicol.cli, "parse_cli", parse_cli)
+    monkeypatch.setattr(
+        report_runner,
+        "_authenticated_effective_config",
+        lambda _path: events.append("post-generation-validation") or {},
+    )
+    monkeypatch.setattr(
+        report_runner,
+        "_single_process_id",
+        lambda _path, fallback: fallback,
+    )
+    monkeypatch.setattr(
+        report_runner,
+        "_artifact_numerical_relation_metadata",
+        lambda _path, _process_id: (
+            {
+                "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+                "state": "no-applied-relations",
+                "applied_relation_count": 0,
+            },
+            None,
+        ),
+    )
+
+    generated = generate_artifact(
+        _cell(ExecutionMode.COMPILED, Accuracy.LC, Workload.SELECTED_FLOW),
+        tmp_path / "artifact",
+        settings=RunnerSettings(),
+        repo_root=tmp_path,
+        phase_reporter=SpyReporter(),  # type: ignore[arg-type]
+    )
+
+    assert events == [
+        "phase-enter",
+        "model-preparation",
+        "Generator.generate",
+        "phase-exit",
+        "post-generation-validation",
+    ]
+    assert len(parsed_argv) == 1
+    assert parsed_argv[0][0] == "generate"
+    assert generated.generation_command_path == PRECOMPILED_GENERATION_COMMAND_PATH
+
+
+@pytest.mark.parametrize(
+    "mode",
+    (ExecutionMode.EAGER, ExecutionMode.RECURRENCE),
+)
+def test_prepared_generation_uses_public_cli_parser_and_default_handler(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    mode: ExecutionMode,
+) -> None:
+    import pyamplicol.api
+    import pyamplicol.cli
+    import pyamplicol.cli.handlers
+    import tools.performance_report.runner as report_runner
+
+    parsed_argv: list[tuple[str, ...]] = []
+    handler_configs: list[object] = []
+    generated_models: list[object] = []
+    real_parse_cli = pyamplicol.cli.parse_cli
+    real_generate = pyamplicol.cli.handlers.DefaultCliServices.generate
+
+    def parse_cli(argv: tuple[str, ...]):
+        parsed_argv.append(tuple(argv))
+        return real_parse_cli(argv)
+
+    def public_generate(
+        self: object,
+        config: object,
+        progress: object,
+    ) -> object:
+        handler_configs.append(config)
+        return real_generate(self, config, progress)  # type: ignore[arg-type]
+
+    class FakeSource:
+        pass
+
+    class FakeModelSource:
+        @staticmethod
+        def built_in_sm() -> FakeSource:
+            return FakeSource()
+
+        @staticmethod
+        def from_config(_config: object) -> FakeSource:
+            return FakeSource()
+
+    class FakeGenerator:
+        def __init__(
+            self,
+            *,
+            config: object,
+            progress: object | None = None,
+        ) -> None:
+            assert progress is not None
+            self.config = config
+
+        def generate(
+            self,
+            _processes: object,
+            _output: Path,
+            *,
+            model: object,
+            mode: str,
+        ) -> None:
+            assert mode == "replace"
+            generated_models.append(model)
+
+    monkeypatch.setattr(pyamplicol.api, "Generator", FakeGenerator)
+    monkeypatch.setattr(pyamplicol.api, "ModelSource", FakeModelSource)
+    monkeypatch.setattr(pyamplicol.cli, "parse_cli", parse_cli)
+    monkeypatch.setattr(
+        pyamplicol.cli.handlers.DefaultCliServices,
+        "generate",
+        public_generate,
+    )
+    monkeypatch.setattr(
+        report_runner,
+        "_authenticated_effective_config",
+        lambda _path: {},
+    )
+    monkeypatch.setattr(
+        report_runner,
+        "_single_process_id",
+        lambda _path, fallback: fallback,
+    )
+    monkeypatch.setattr(
+        report_runner,
+        "_artifact_numerical_relation_metadata",
+        lambda _path, _process_id: (
+            {
+                "abi": "pyamplicol-numerical-current-relation-correctness-v1",
+                "state": "no-applied-relations",
+                "applied_relation_count": 0,
+            },
+            None,
+        ),
+    )
+    cell = REPORT_CATALOG.cell(
+        f"matrix-{mode.value}-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    )
+
+    generated = generate_artifact(
+        cell,
+        tmp_path / "artifact",
+        settings=RunnerSettings(),
+        repo_root=tmp_path,
+    )
+
+    assert len(parsed_argv) == 1
+    assert parsed_argv[0][:2] == ("generate", cell.process)
+    assert len(handler_configs) == 1
+    assert len(generated_models) == 1
+    assert generated.generation_command_path == PUBLIC_CLI_COMMAND_PATH
+
+
+@pytest.mark.parametrize(
+    ("mode", "workload", "expected_layout", "expected_level"),
+    (
+        (
+            ExecutionMode.RECURRENCE,
+            Workload.SELECTED_FLOW,
+            "topology-replay",
+            2,
+        ),
+        (
+            ExecutionMode.RECURRENCE,
+            Workload.ALL_FLOW,
+            "all-flow-union",
+            2,
+        ),
+        (
+            ExecutionMode.COMPILED,
+            Workload.SELECTED_FLOW,
+            "topology-replay",
+            3,
+        ),
+        (
+            ExecutionMode.EAGER,
+            Workload.ALL_FLOW,
+            "all-flow-union",
+            2,
+        ),
+    ),
+)
+def test_config_steers_complete_coverage_and_layout_only(
+    mode: ExecutionMode,
+    workload: Workload,
+    expected_layout: str,
+    expected_level: int,
+) -> None:
+    cell = _cell(mode, Accuracy.LC, workload)
+    values = config_values(
+        cell,
+        RunnerSettings(worker_cores=1),
+        repo_root=Path("/repo"),
+    )
+
+    assert values["color"]["lc_flow_layout"] == expected_layout  # type: ignore[index]
+    assert values["evaluator"]["execution_mode"] == mode.value  # type: ignore[index]
+    assert (
+        values["evaluator"]["jit"]["optimization_level"]  # type: ignore[index]
+        == expected_level
+    )
+    serialized = repr(values)
+    assert "selected_color_sector_ids" not in serialized
+    assert "selected_source_helicities" not in serialized
+    assert "reference_color_order" not in serialized
+
+
+def test_config_threads_manual_profile_sampling_settings() -> None:
+    values = config_values(
+        _cell(
+            ExecutionMode.RECURRENCE,
+            Accuracy.LC,
+            Workload.SELECTED_FLOW,
+        ),
+        RunnerSettings(warmup_runs=7, minimum_samples=11),
+        repo_root=Path("/repo"),
+    )
+
+    assert values["benchmark"]["warmup_runs"] == 7  # type: ignore[index]
+    assert values["benchmark"]["minimum_samples"] == 11  # type: ignore[index]
+    assert values["generation"]["validation"] == {  # type: ignore[index]
+        "enabled": True,
+        "samples": 1,
+        "seed": 12345,
+        "relative_tolerance": 1.0e-12,
+        "absolute_tolerance": 1.0e-300,
+        "post_build_validation": False,
+    }
+
+
+@pytest.mark.parametrize(
+    ("mode", "workspace_key"),
+    (
+        (ExecutionMode.RECURRENCE, "recurrence"),
+        (ExecutionMode.EAGER, "eager"),
+    ),
+)
+def test_config_derives_selected_engine_workspace_from_campaign_memory_cap(
+    mode: ExecutionMode,
+    workspace_key: str,
+) -> None:
+    values = config_values(
+        _cell(mode, Accuracy.LC, Workload.SELECTED_FLOW),
+        RunnerSettings(memory_limit_bytes=15_000_000_000),
+        repo_root=Path("/repo"),
+    )
+    evaluator = values["evaluator"]
+    assert isinstance(evaluator, dict)
+    assert evaluator[workspace_key] == {"workspace_mib": 14_305}
+    assert ({"eager", "recurrence"} - {workspace_key}).isdisjoint(evaluator)
+
+    compiled = config_values(
+        _cell(ExecutionMode.COMPILED, Accuracy.LC, Workload.SELECTED_FLOW),
+        RunnerSettings(memory_limit_bytes=15_000_000_000),
+        repo_root=Path("/repo"),
+    )["evaluator"]
+    assert isinstance(compiled, dict)
+    assert "eager" not in compiled
+    assert "recurrence" not in compiled
+
+
+def test_runner_rejects_sub_mib_workspace_budget() -> None:
+    with pytest.raises(ValueError, match="at least one MiB"):
+        RunnerSettings(memory_limit_bytes=1024 * 1024 - 1)
+
+
+def test_nlc_and_full_use_contracted_topology_replay_configuration() -> None:
+    for accuracy in (Accuracy.NLC, Accuracy.FULL):
+        cell = _cell(ExecutionMode.RECURRENCE, accuracy, Workload.CONTRACTED)
+        values = config_values(
+            cell,
+            RunnerSettings(),
+            repo_root=Path("/repo"),
+        )
+        assert values["color"] == {
+            "accuracy": accuracy.value,
+            "lc_flow_layout": "topology-replay",
+        }
+
+
+def test_selector_contract_uses_canonical_minimum_flow_and_fixed_helicity() -> None:
+    runtime = FakeRuntime()
+    points = (((1.0, 0.0, 0.0, 1.0),),)
+
+    contract = derive_selector_contract(runtime, points)
+
+    assert contract.selected_color_flow_ids == ("flow:1,2,3",)
+    assert contract.selected_color_words == ((1, 2, 3),)
+    assert contract.all_flow_helicity_ids == ("h:-1,+1,-1",)
+    assert contract.all_flow_source_helicities == ((1, -1), (2, 1), (3, -1))
+    assert contract.point_digest == point_digest(points)
+    assert SelectorContract.from_mapping(contract.as_dict()) == contract
+    validate_selector_contract(runtime, contract, points)
+
+
+def test_selector_contract_is_independent_of_runtime_flow_enumeration() -> None:
+    points = (((1.0, 0.0, 0.0, 1.0),),)
+    forward = FakeRuntime()
+    reverse = FakeRuntime()
+    reverse.physics.color_flows = tuple(reversed(forward.physics.color_flows))
+
+    assert derive_selector_contract(forward, points) == derive_selector_contract(
+        reverse,
+        points,
+    )
+
+
+def test_selector_contract_rejects_zero_canonical_minimum_flow() -> None:
+    class CanonicalMinimumZeroRuntime(FakeRuntime):
+        def evaluate_resolved(
+            self,
+            _points: object,
+            **selectors: object,
+        ) -> Resolved:
+            assert selectors.get("helicities") == ("h:-1,+1,-1",)
+            selected_flows = selectors.get("color_flows")
+            if selected_flows == ("flow:1,2,3",):
+                return Resolved(
+                    (
+                        (
+                            (0.0 + 0.0j,),
+                            (0.0 + 0.0j,),
+                        ),
+                    ),
+                    self.resolved_total,
+                )
+            pytest.fail("selector must not fall back to a noncanonical flow")
+
+    with pytest.raises(
+        RunnerError,
+        match="canonical fixed-helicity selector is zero",
+    ):
+        derive_selector_contract(
+            CanonicalMinimumZeroRuntime(),
+            (((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+
+def test_selector_contract_ignores_larger_noncanonical_flow_component() -> None:
+    class CanonicalMinimumRuntime(FakeRuntime):
+        def evaluate_resolved(
+            self,
+            _points: object,
+            **selectors: object,
+        ) -> Resolved:
+            selected_flows = selectors.get("color_flows")
+            if selected_flows == ("flow:1,2,3",):
+                return Resolved(
+                    (
+                        (
+                            (0.0 + 0.0j,),
+                            (1.0e-18 + 0.0j,),
+                        ),
+                    ),
+                    self.resolved_total,
+                )
+            pytest.fail("selector must not rank noncanonical flow components")
+
+    contract = derive_selector_contract(
+        CanonicalMinimumRuntime(),
+        (((1.0, 0.0, 0.0, 1.0),),),
+    )
+
+    assert contract.selected_color_flow_ids == ("flow:1,2,3",)
+    assert contract.all_flow_helicity_ids == ("h:-1,+1,-1",)
+
+
+def test_selector_contract_rejects_duplicate_physical_flow_words() -> None:
+    runtime = FakeRuntime()
+    runtime.physics.color_flows = (
+        Flow("flow:1,2,3", (1, 2, 3)),
+        Flow("flow:1,2,3", (1, 2, 3)),
+    )
+
+    with pytest.raises(RunnerError, match="color-flow words must be unique"):
+        derive_selector_contract(
+            runtime,
+            (((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+
+def test_selector_contract_rejects_noncanonical_physical_axis_ids() -> None:
+    runtime = FakeRuntime()
+    runtime.physics.color_flows = (
+        Flow("opaque", (1, 2, 3)),
+        Flow("flow:2,1,3", (2, 1, 3)),
+    )
+    with pytest.raises(RunnerError, match="flow ID does not encode"):
+        derive_selector_contract(
+            runtime,
+            (((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+    runtime = FakeRuntime()
+    runtime.physics.helicities = (
+        Helicity("opaque", (-1, 1, -1)),
+        Helicity("h:-1,-1,-1", (-1, -1, -1)),
+    )
+    with pytest.raises(RunnerError, match="helicity ID does not encode"):
+        derive_selector_contract(
+            runtime,
+            (((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+
+def test_selector_contract_rejects_nonfinite_canonical_component() -> None:
+    class NonfiniteRuntime(FakeRuntime):
+        def evaluate_resolved(
+            self,
+            _points: object,
+            **selectors: object,
+        ) -> Resolved:
+            assert selectors == {
+                "color_flows": ("flow:1,2,3",),
+                "helicities": ("h:-1,+1,-1",),
+            }
+            return Resolved(
+                ((((complex(float("nan"), 0.0),),),)),
+                self.resolved_total,
+            )
+
+    with pytest.raises(RunnerError, match="non-finite component"):
+        derive_selector_contract(
+            NonfiniteRuntime(),
+            (((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+
+def test_selector_contract_rejects_all_zero_canonical_components() -> None:
+    class ZeroRuntime(FakeRuntime):
+        def evaluate_resolved(
+            self,
+            _points: object,
+            **_selectors: object,
+        ) -> Resolved:
+            return Resolved(
+                (
+                    (
+                        (0.0 + 0.0j,),
+                        (0.0 + 0.0j,),
+                    ),
+                ),
+                self.resolved_total,
+            )
+
+    with pytest.raises(
+        RunnerError,
+        match="canonical fixed-helicity selector is zero",
+    ):
+        derive_selector_contract(
+            ZeroRuntime(),
+            (((1.0, 0.0, 0.0, 1.0),),),
+        )
+
+
+def test_selector_contract_rejects_changed_point_or_axis() -> None:
+    runtime = FakeRuntime()
+    points = (((1.0, 0.0, 0.0, 1.0),),)
+    contract = derive_selector_contract(runtime, points)
+
+    with pytest.raises(RunnerError, match="measurement point differ"):
+        validate_selector_contract(
+            runtime,
+            contract,
+            (((2.0, 0.0, 0.0, 2.0),),),
+        )
+
+    runtime.physics.color_flows = (Flow("different", (2, 1, 3)),)
+    with pytest.raises(RunnerError, match="selected physical flow"):
+        validate_selector_contract(runtime, contract, points)
+
+
+def test_selector_contract_maps_only_exact_signed_zero_runtime_alias() -> None:
+    runtime = FakeRuntime()
+    points = (((1.0, 0.0, 0.0, 1.0),),)
+    runtime.physics.external_particles = tuple(
+        Particle(label, 23 if label == 6 else 1)
+        for label in range(1, 7)
+    )
+    runtime.physics.helicities = (
+        Helicity(
+            "h:-1,+1,-1,+1,-1,+0",
+            (-1, 1, -1, 1, -1, 0),
+        ),
+    )
+    contract = SelectorContract(
+        selected_color_flow_ids=("flow:2,1,3",),
+        selected_color_words=((2, 1, 3),),
+        all_flow_helicity_ids=("h:-1,+1,-1,+1,-1,0",),
+        all_flow_source_helicities=(
+            (1, -1),
+            (2, 1),
+            (3, -1),
+            (4, 1),
+            (5, -1),
+            (6, 0),
+        ),
+        point_digest=point_digest(points),
+    )
+
+    assert contract.runtime_all_flow_helicity_ids == ("h:-1,+1,-1,+1,-1,+0",)
+    validate_selector_contract(runtime, contract, points)
+    assert _selector_kwargs(
+        _cell(ExecutionMode.RECURRENCE, Accuracy.LC, Workload.ALL_FLOW),
+        contract,
+    ) == {
+        "helicities": ("h:-1,+1,-1,+1,-1,+0",),
+        "color_flows": None,
+    }
+
+    changed = SelectorContract(
+        selected_color_flow_ids=contract.selected_color_flow_ids,
+        selected_color_words=contract.selected_color_words,
+        all_flow_helicity_ids=("h:+1,+1,-1,+1,-1,0",),
+        all_flow_source_helicities=contract.all_flow_source_helicities,
+        point_digest=contract.point_digest,
+    )
+    assert changed.runtime_all_flow_helicity_ids == changed.all_flow_helicity_ids
+    with pytest.raises(RunnerError, match="selected physical helicity"):
+        validate_selector_contract(runtime, changed, points)
+
+
+def test_runtime_contract_requires_both_lc_selector_axes() -> None:
+    runtime = FakeRuntime()
+    cell = _cell(
+        ExecutionMode.RECURRENCE,
+        Accuracy.LC,
+        Workload.SELECTED_FLOW,
+    )
+    validate_runtime_contract(cell, runtime)
+
+    runtime.physics.selector_capabilities = ("helicity",)
+    with pytest.raises(RunnerError, match="color_flow"):
+        validate_runtime_contract(cell, runtime)
+
+
+def test_artifact_contract_rejects_generation_specialization(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    cell = _cell(
+        ExecutionMode.RECURRENCE,
+        Accuracy.LC,
+        Workload.SELECTED_FLOW,
+    )
+    process = SimpleNamespace(
+        execution_mode="recurrence",
+        generation_specialized_axes=(),
+        selected_source_helicities=(),
+        selected_color_sector_ids=(),
+        lc_flow_layout="topology-replay",
+    )
+    inspection = SimpleNamespace(processes=(process,))
+    inspection.runtime_capabilities = (
+        "rusticol.recurrence-direct-arena.complex-f64.v1",
+    )
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.inspect_artifact",
+        lambda _path: inspection,
+    )
+    validate_artifact_contract(cell, Path("/artifact"))
+
+    process.generation_specialized_axes = ("color_flow",)
+    with pytest.raises(RunnerError, match="complete runtime coverage"):
+        validate_artifact_contract(cell, Path("/artifact"))
+
+
+@pytest.mark.parametrize(
+    ("cell", "capability", "expected_evaluator_abi", "optimization_identity"),
+    (
+        (
+            _cell(
+                ExecutionMode.RECURRENCE,
+                Accuracy.LC,
+                Workload.SELECTED_FLOW,
+            ),
+            "rusticol.recurrence-direct-arena.complex-f64.v1",
+            "pyamplicol-recurrence-runtime-layout-v2",
+            {"source_jit_optimization_level": 2},
+        ),
+        (
+            _cell(
+                ExecutionMode.EAGER,
+                Accuracy.LC,
+                Workload.SELECTED_FLOW,
+            ),
+            "eager-direct-arena-v1",
+            "pyamplicol-eager-plane-table-binding-v2",
+            {"source_jit_optimization_level": 2},
+        ),
+        (
+            next(
+                cell
+                for cell in REPORT_CATALOG.z_cells()
+                if cell.variant == "jit_o1" and cell.workload is Workload.SELECTED_FLOW
+            ),
+            "compiled-plane-arena-v1",
+            "pyamplicol-compiled-plane-kernel-v2",
+            {
+                "source_jit_optimization_level": 1,
+                "direct_codegen_optimization_level": 1,
+            },
+        ),
+        (
+            next(
+                cell
+                for cell in REPORT_CATALOG.z_cells()
+                if cell.variant == "cpp_o3" and cell.workload is Workload.SELECTED_FLOW
+            ),
+            "compiled-plane-arena-v1",
+            "pyamplicol-native-compiled-direct-application-v1",
+            {},
+        ),
+    ),
+)
+def test_runtime_identity_binds_native_artifact_and_arena(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    cell: CellSpec,
+    capability: str,
+    expected_evaluator_abi: str,
+    optimization_identity: dict[str, int],
+) -> None:
+    import pyamplicol
+
+    artifact_id = "a" * 64
+    manifest = SimpleNamespace(
+        artifact_id=artifact_id,
+        processes=(
+            {
+                "id": "process-1",
+                "required_runtime_capabilities": [capability],
+            },
+        ),
+        runtime={"engine_version": "0.1.0.test"},
+    )
+    candidate_source_revision = "d" * 40
+    measurement_source_revision = "e" * 40
+    package_root = tmp_path / "pyamplicol"
+    package_root.mkdir()
+    package_init = package_root / "__init__.py"
+    package_init.write_bytes(b"")
+    (package_root / "api.py").write_bytes(b"VALUE=1\n")
+    (package_root / "ignored.pyo").write_bytes(b"ignored")
+    cache = package_root / "__pycache__"
+    cache.mkdir()
+    (cache / "ignored.pyc").write_bytes(b"ignored")
+    native_path = package_root / "_rusticol.so"
+    native_path.write_bytes(b"native")
+    native = SimpleNamespace(
+        __file__=str(native_path),
+        package_version=lambda: pyamplicol.__version__,
+        native_build_inputs_sha256=lambda: "b" * 64,
+        target_info=lambda: SimpleNamespace(
+            triple="aarch64-apple-darwin",
+            cpu_features=("neon",),
+        ),
+    )
+    package_records = [
+        {
+            "root_index": 0,
+            "path": path.name,
+            "size": path.stat().st_size,
+            "sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
+        }
+        for path in (package_init, native_path, package_root / "api.py")
+    ]
+    bytecode_policy = {
+        "kind": "pyamplicol-source-only-bytecode-policy-v1",
+        "dont_write_bytecode": True,
+        "external_pycache_prefix": True,
+        "external_pycache_prefix_absent": True,
+        "package_local_bytecode_eligible": False,
+        "isolated_startup": True,
+        "site_initialization": False,
+        "python_environment_ignored_at_startup": True,
+    }
+    package_tree_identity = {
+        "kind": "pyamplicol-python-package-tree-v2",
+        "root": str(package_root.resolve()),
+        "roots": [str(package_root.resolve())],
+        "file_count": 3,
+        "total_bytes": sum(record["size"] for record in package_records),
+        "sha256": hashlib.sha256(
+            json.dumps(
+                package_records,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            ).encode("ascii")
+        ).hexdigest(),
+        "member_set_stable": True,
+        "namespace_bound_to_root_fd": True,
+        "bytecode_policy": bytecode_policy,
+    }
+    native_identity = {
+        "path": str(native_path.resolve()),
+        "size": native_path.stat().st_size,
+        "sha256": hashlib.sha256(native_path.read_bytes()).hexdigest(),
+    }
+    loaded_origin_policy = {
+        "kind": "pyamplicol-loaded-module-origin-policy-v1",
+        "all_loaded_origins_authenticated": True,
+        "native_image_origin_bound": True,
+        "loaded_bytecode_eligible": False,
+        "observed_module_count": 1,
+        "observations": [
+            {
+                "module": "pyamplicol",
+                "kind": "package-member",
+                "root_index": 0,
+                "path": "__init__.py",
+                "size": 0,
+                "sha256": hashlib.sha256(b"").hexdigest(),
+            }
+        ],
+    }
+    loaded_origin_policy["observations_sha256"] = _digest_json(
+        loaded_origin_policy["observations"]
+    )
+    monkeypatch.setattr(
+        "pyamplicol.artifacts.load_manifest",
+        lambda _path, *, verify_payloads: manifest,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.runner.importlib.import_module",
+        lambda name: native if name == "pyamplicol._rusticol" else None,
+    )
+    monkeypatch.setattr(
+        "pyamplicol._internal.versions._active_build_info",
+        lambda: {
+            "schema_version": 1,
+            "version": pyamplicol.__version__,
+            "candidate_fingerprint": "candidate",
+            "source_revision": candidate_source_revision,
+            "source_checkout": "/repo",
+            "native_build_inputs_sha256": "b" * 64,
+            "publishable": False,
+        },
+    )
+    monkeypatch.setattr(pyamplicol, "__file__", str(package_init))
+    monkeypatch.setattr(pyamplicol, "__path__", [str(package_root)])
+    monkeypatch.setattr(
+        "tools.performance_report.runner.established_preimport_runtime_identity",
+        lambda: {
+            "kind": "pyamplicol-preimport-runtime-identity-v1",
+            "python_package_tree": package_tree_identity,
+            "native_extension": native_identity,
+        },
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.runner.python_package_tree_identity",
+        lambda roots: (
+            package_tree_identity
+            if tuple(roots) == (package_root,)
+            else pytest.fail(f"unexpected package roots: {roots}")
+        ),
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.runner.loaded_pyamplicol_origin_policy",
+        lambda roots, **kwargs: (
+            loaded_origin_policy
+            if (
+                tuple(roots) == (package_root,)
+                and kwargs["native_extension"] == native_path
+                and kwargs["expected_package_identity"] == package_tree_identity
+                and kwargs["expected_native_identity"] == native_identity
+            )
+            else pytest.fail("unexpected loaded-origin evidence request")
+        ),
+    )
+
+    def direct_identity(
+        _manifest: object,
+        *,
+        process_id: str,
+        source_optimization_level: int,
+    ) -> dict[str, object]:
+        assert process_id == "process-1"
+        return {
+            "kind": "authenticated-compiled-plane-arena-direct-codegen-v1",
+            "optimization_level": source_optimization_level,
+            "source_optimization_level": source_optimization_level,
+            "leaf_count": 2,
+            "execution_manifest_path": "execution.json",
+            "execution_manifest_sha256": "e" * 64,
+        }
+
+    monkeypatch.setattr(
+        "tools.performance_report.runner._authenticated_direct_codegen_identity",
+        direct_identity,
+    )
+
+    recurrence_identity = {
+        "kind": "authenticated-recurrence-direct-template-source-v1",
+        "optimization_level": 2,
+        "direct_template_count": 5,
+        "prepared_direct_template_count": 3,
+        "source_evaluator_leaf_count": 4,
+        "source_application_abi": "pyamplicol-symjit-plane-application-v2",
+        "direct_application_abi": "pyamplicol-symjit-plane-application-v2",
+        "prepared_kernel_pack_digest": "7" * 64,
+        "direct_template_catalog_digest": "8" * 64,
+        "execution_manifest_path": "processes/process-1/execution.json",
+        "execution_manifest_sha256": "f" * 64,
+        "kernel_pack_path": "model/eager-kernel-pack.json",
+        "kernel_pack_sha256": "9" * 64,
+    }
+    monkeypatch.setattr(
+        "tools.performance_report.runner._authenticated_recurrence_source_identity",
+        lambda _manifest, *, process_id, source_optimization_level: (
+            recurrence_identity
+            if process_id == "process-1" and source_optimization_level == 2
+            else pytest.fail("unexpected recurrence identity request")
+        ),
+    )
+
+    identity = runtime_identity_payload(
+        cell,
+        SimpleNamespace(
+            artifact_id=artifact_id,
+            execution_mode=cell.measurement.execution_mode.value,
+        ),
+        Path("/artifact"),
+        "process-1",
+        expected_source_revision=measurement_source_revision,
+    )
+
+    assert identity["artifact_id"] == artifact_id
+    assert identity["loaded_artifact_id"] == artifact_id
+    assert identity["loaded_execution_mode"] == cell.measurement.execution_mode.value
+    assert identity["required_arena_capability"] == capability
+    assert identity["expected_evaluator_abi"] == expected_evaluator_abi
+    expected_source_abi = (
+        "pyamplicol-native-compiled-direct-application-v1"
+        if (
+            cell.measurement.execution_mode is ExecutionMode.COMPILED
+            and cell.measurement.backend != "jit"
+        )
+        else {
+            "jit": "pyamplicol-symjit-plane-application-v2",
+            "cpp": "symbolica.compiled-cpp.complex-f64.v1",
+            "asm": "symbolica.compiled-asm.complex-f64.v1",
+        }[cell.measurement.backend]
+    )
+    assert identity["expected_source_evaluator_abi"] == expected_source_abi
+    assert (
+        identity["expected_source_evaluator_runtime_capability"]
+        == {
+            "jit": "symjit.application.complex-f64.v1",
+            "cpp": "symbolica.compiled-cpp.complex-f64.v1",
+            "asm": "symbolica.compiled-asm.complex-f64.v1",
+        }[cell.measurement.backend]
+    )
+    assert identity["native_build_inputs_sha256"] == "b" * 64
+    assert identity["source_revision"] == measurement_source_revision
+    assert (
+        identity["candidate_build_identity"]["source_revision"]
+        == candidate_source_revision
+    )
+    package_tree = identity["python_package_tree"]
+    assert package_tree == package_tree_identity
+    assert identity["loaded_module_origin_policy"] == loaded_origin_policy
+    for field in (
+        "source_jit_optimization_level",
+        "direct_codegen_optimization_level",
+    ):
+        if field in optimization_identity:
+            assert identity[field] == optimization_identity[field]
+        else:
+            assert field not in identity
+    if cell.measurement.execution_mode is ExecutionMode.COMPILED and (
+        cell.measurement.backend == "jit"
+    ):
+        assert identity["direct_codegen_identity"] == {
+            "kind": "authenticated-compiled-plane-arena-direct-codegen-v1",
+            "optimization_level": cell.measurement.jit_optimization_level,
+            "source_optimization_level": cell.measurement.jit_optimization_level,
+            "leaf_count": 2,
+            "execution_manifest_path": "execution.json",
+            "execution_manifest_sha256": "e" * 64,
+        }
+    else:
+        assert "direct_codegen_identity" not in identity
+    if cell.measurement.execution_mode is ExecutionMode.RECURRENCE:
+        assert identity["source_jit_identity"] == recurrence_identity
+    else:
+        assert "source_jit_identity" not in identity
+
+    with pytest.raises(RunnerError, match="loaded artifact identity"):
+        runtime_identity_payload(
+            cell,
+            SimpleNamespace(
+                artifact_id="c" * 64,
+                execution_mode=cell.measurement.execution_mode.value,
+            ),
+            Path("/artifact"),
+            "process-1",
+            expected_source_revision=measurement_source_revision,
+        )
+
+    mismatched_mode = (
+        "compiled"
+        if cell.measurement.execution_mode is not ExecutionMode.COMPILED
+        else "eager"
+    )
+    with pytest.raises(RunnerError, match="loaded execution mode"):
+        runtime_identity_payload(
+            cell,
+            SimpleNamespace(
+                artifact_id=artifact_id,
+                execution_mode=mismatched_mode,
+            ),
+            Path("/artifact"),
+            "process-1",
+            expected_source_revision=measurement_source_revision,
+        )
+
+    with pytest.raises(RunnerError, match=r"does not expose.*execution mode"):
+        runtime_identity_payload(
+            cell,
+            SimpleNamespace(artifact_id=artifact_id),
+            Path("/artifact"),
+            "process-1",
+            expected_source_revision=measurement_source_revision,
+        )
+
+
+def test_direct_codegen_identity_follows_authenticated_process_index(
+    tmp_path: Path,
+) -> None:
+    process_id = "process-1"
+    index_relative = "processes/evaluators.json"
+    execution_entry_relative = f"{process_id}/execution.json"
+    execution_relative = f"processes/{execution_entry_relative}"
+    execution = {
+        "kind": "pyamplicol-runtime-execution",
+        "compiled": {
+            "stage_evaluators": {
+                "amplitude_stage": {
+                    "evaluator": _canonical_symjit_evaluator(
+                        "evaluators/amplitude.symjit",
+                        "evaluators/amplitude.plane.symjit",
+                        optimization_level=1,
+                    ),
+                    "compiled_plane_arena": {
+                        "leaves": [
+                            {
+                                "application_path": (
+                                    "evaluators/amplitude.plane.symjit"
+                                ),
+                                "source_application_abi": (
+                                    "pyamplicol-symjit-plane-application-v2"
+                                ),
+                                "optimization_level": 1,
+                                "direct_codegen_optimization_level": 1,
+                            }
+                        ]
+                    },
+                }
+            }
+        },
+    }
+    evaluator_index = {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-execution-set",
+        "processes": [
+            {
+                "process_id": process_id,
+                "manifest_path": execution_entry_relative,
+                "required_runtime_capabilities": ["compiled-plane-arena-v1"],
+            }
+        ],
+    }
+
+    def payload(
+        relative: str,
+        value: dict[str, object],
+        *,
+        payload_process_id: str | None,
+    ) -> SimpleNamespace:
+        data = json.dumps(
+            value,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+        path = tmp_path / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(data)
+        return SimpleNamespace(
+            path=relative,
+            role="evaluator-manifest",
+            media_type="application/json",
+            size_bytes=len(data),
+            sha256=hashlib.sha256(data).hexdigest(),
+            executable=False,
+            process_id=payload_process_id,
+        )
+
+    index_payload = payload(
+        index_relative,
+        evaluator_index,
+        payload_process_id=None,
+    )
+    execution_payload = payload(
+        execution_relative,
+        execution,
+        payload_process_id=process_id,
+    )
+    manifest = SimpleNamespace(
+        root=tmp_path,
+        runtime={"evaluator_manifest_path": index_relative},
+        payloads=(index_payload, execution_payload),
+    )
+
+    identity = _authenticated_direct_codegen_identity(
+        manifest,
+        process_id=process_id,
+        source_optimization_level=1,
+    )
+
+    assert identity == {
+        "kind": "authenticated-compiled-plane-arena-direct-codegen-v1",
+        "optimization_level": 1,
+        "source_optimization_level": 1,
+        "leaf_count": 1,
+        "execution_manifest_path": execution_relative,
+        "execution_manifest_sha256": execution_payload.sha256,
+    }
+
+
+def test_recurrence_source_identity_follows_authenticated_direct_template_pack(
+    tmp_path: Path,
+) -> None:
+    process_id = "process-1"
+    index_relative = "processes/evaluators.json"
+    execution_relative = f"processes/{process_id}/execution.json"
+    pack_relative = "model/eager-kernel-pack.json"
+    source_relative = "model/eager-kernels/kernels/000000/application-0.plane.symjit"
+    source_data = b"authenticated-symjit-application"
+    source_sha256 = hashlib.sha256(source_data).hexdigest()
+    execution, pack = _recurrence_source_fixture(source_sha256)
+    evaluator_index = {
+        "schema_version": 3,
+        "kind": "pyamplicol-runtime-execution-set",
+        "processes": [
+            {
+                "process_id": process_id,
+                "manifest_path": f"{process_id}/execution.json",
+            }
+        ],
+    }
+
+    def payload(
+        relative: str,
+        value: dict[str, object],
+        *,
+        payload_process_id: str | None,
+    ) -> SimpleNamespace:
+        data = json.dumps(
+            value,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+        path = tmp_path / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(data)
+        return SimpleNamespace(
+            path=relative,
+            role="evaluator-manifest",
+            media_type="application/json",
+            size_bytes=len(data),
+            sha256=hashlib.sha256(data).hexdigest(),
+            executable=False,
+            process_id=payload_process_id,
+        )
+
+    index_payload = payload(
+        index_relative,
+        evaluator_index,
+        payload_process_id=None,
+    )
+    execution_payload = payload(
+        execution_relative,
+        execution,
+        payload_process_id=process_id,
+    )
+    pack_payload = payload(
+        pack_relative,
+        pack,
+        payload_process_id=None,
+    )
+    source_path = tmp_path / source_relative
+    source_path.parent.mkdir(parents=True, exist_ok=True)
+    source_path.write_bytes(source_data)
+    source_payload = SimpleNamespace(
+        path=source_relative,
+        role="evaluator-state",
+        media_type="application/octet-stream",
+        size_bytes=len(source_data),
+        sha256=source_sha256,
+        executable=False,
+        process_id=None,
+    )
+    manifest = SimpleNamespace(
+        root=tmp_path,
+        runtime={"evaluator_manifest_path": index_relative},
+        payloads=(index_payload, execution_payload, pack_payload, source_payload),
+        extensions={},
+    )
+
+    identity = _authenticated_recurrence_source_identity(
+        manifest,
+        process_id=process_id,
+        source_optimization_level=2,
+    )
+
+    assert identity == {
+        "kind": "authenticated-recurrence-direct-template-source-v1",
+        "optimization_level": 2,
+        "direct_template_count": 2,
+        "prepared_direct_template_count": 1,
+        "source_evaluator_leaf_count": 1,
+        "source_application_abi": "pyamplicol-symjit-plane-application-v2",
+        "direct_application_abi": "pyamplicol-symjit-plane-application-v2",
+        "prepared_kernel_pack_digest": "a" * 64,
+        "direct_template_catalog_digest": execution["direct_template_catalog_digest"],
+        "execution_manifest_path": execution_relative,
+        "execution_manifest_sha256": execution_payload.sha256,
+        "kernel_pack_path": pack_relative,
+        "kernel_pack_sha256": pack_payload.sha256,
+    }
+
+    catalog = pack["recurrence_direct_template"]
+    assert isinstance(catalog, dict)
+    templates = catalog["templates"]
+    assert isinstance(templates, list)
+    template = templates[1]
+    assert isinstance(template, dict)
+    template["optimization_level"] = 1
+    _refresh_recurrence_catalog(execution, pack)
+    replacement = json.dumps(
+        pack,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    (tmp_path / pack_relative).write_bytes(replacement)
+    pack_payload.size_bytes = len(replacement)
+    pack_payload.sha256 = hashlib.sha256(replacement).hexdigest()
+    execution_replacement = json.dumps(
+        execution,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    (tmp_path / execution_relative).write_bytes(execution_replacement)
+    execution_payload.size_bytes = len(execution_replacement)
+    execution_payload.sha256 = hashlib.sha256(execution_replacement).hexdigest()
+    with pytest.raises(RunnerError, match="template 1 contract"):
+        _authenticated_recurrence_source_identity(
+            manifest,
+            process_id=process_id,
+            source_optimization_level=2,
+        )
+
+
+@pytest.mark.parametrize(
+    ("corruption", "message"),
+    (
+        ("execution_template_abi", "direct_template_abi"),
+        ("plan_template_abi", "direct_template_abi"),
+        ("execution_backend_abi", "direct_backend_abi"),
+        ("plan_backend_abi", "direct_backend_abi"),
+        ("plan_prepared_digest", "source digests"),
+        ("plan_catalog_digest", "source digests"),
+        ("pack_prepared_digest", "kernel-pack digests"),
+        ("execution_catalog_link", "kernel-pack digests"),
+        ("catalog_backend_abi", "optimization identity"),
+        ("catalog_canonicalization_abi", "optimization identity"),
+        ("catalog_digest", "catalog digest"),
+        ("template_portable", "template 0 contract"),
+        ("template_abi", "template 0 contract"),
+        ("binding_abi", "payload-binding contract"),
+        ("source_application_abi", "source application"),
+        ("direct_application_abi", "source application"),
+        ("payload_digest", "payload-binding contract"),
+        ("intrinsic_source_application_abi", "intrinsic source contract"),
+        ("intrinsic_direct_application_abi", "intrinsic source contract"),
+        ("source_leaf_runtime_capability", "source evaluator leaf contract"),
+        ("source_leaf_application_abi", "source evaluator leaf contract"),
+        ("source_leaf_optimization", "source evaluator leaf contract"),
+        ("source_leaf_path", "payload is missing"),
+        ("source_payload_digest_link", "not bound to its prepared kernel"),
+    ),
+)
+def test_recurrence_source_identity_rejects_every_broken_link(
+    tmp_path: Path,
+    corruption: str,
+    message: str,
+) -> None:
+    (
+        manifest,
+        execution,
+        pack,
+        execution_payload,
+        pack_payload,
+    ) = _runner_recurrence_artifact(tmp_path)
+    plan = execution["plan"]
+    assert isinstance(plan, dict)
+    catalog = pack["recurrence_direct_template"]
+    assert isinstance(catalog, dict)
+    templates = catalog["templates"]
+    assert isinstance(templates, list)
+    prepared = templates[0]
+    intrinsic = templates[1]
+    assert isinstance(prepared, dict)
+    assert isinstance(intrinsic, dict)
+    prepared_binding = prepared["payload_binding"]
+    intrinsic_binding = intrinsic["payload_binding"]
+    assert isinstance(prepared_binding, dict)
+    assert isinstance(intrinsic_binding, dict)
+    kernels = pack["kernels"]
+    assert isinstance(kernels, list)
+    kernel = kernels[0]
+    assert isinstance(kernel, dict)
+    source_leaf = kernel["f64_evaluator_manifest"]
+    assert isinstance(source_leaf, dict)
+    refresh_catalog: bool | None = None
+
+    if corruption == "execution_template_abi":
+        execution["direct_template_abi"] = "wrong"
+    elif corruption == "plan_template_abi":
+        plan["direct_template_abi"] = "wrong"
+    elif corruption == "execution_backend_abi":
+        execution["direct_backend_abi"] = "wrong"
+    elif corruption == "plan_backend_abi":
+        plan["direct_backend_abi"] = "wrong"
+    elif corruption == "plan_prepared_digest":
+        plan["prepared_kernel_pack_digest"] = "0" * 64
+    elif corruption == "plan_catalog_digest":
+        plan["direct_template_catalog_digest"] = "0" * 64
+    elif corruption == "pack_prepared_digest":
+        catalog["prepared_kernel_pack_digest"] = "0" * 64
+        refresh_catalog = True
+    elif corruption == "execution_catalog_link":
+        execution["direct_template_catalog_digest"] = "0" * 64
+        plan["direct_template_catalog_digest"] = "0" * 64
+    elif corruption == "catalog_backend_abi":
+        catalog["backend_abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "catalog_canonicalization_abi":
+        catalog["canonicalization_abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "catalog_digest":
+        catalog["compiled_model_digest"] = "0" * 64
+    elif corruption == "template_portable":
+        prepared["portable"] = False
+        refresh_catalog = True
+    elif corruption == "template_abi":
+        prepared["abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "binding_abi":
+        prepared_binding["abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "source_application_abi":
+        prepared_binding["source_application_abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "direct_application_abi":
+        prepared_binding["direct_application_abi"] = "wrong"
+        refresh_catalog = True
+    elif corruption == "payload_digest":
+        prepared_binding["payload_digest"] = "0" * 64
+        refresh_catalog = False
+    elif corruption == "intrinsic_source_application_abi":
+        intrinsic_binding["source_application_abi"] = "symjit-application-storage-v3"
+        refresh_catalog = True
+    elif corruption == "intrinsic_direct_application_abi":
+        intrinsic_binding["direct_application_abi"] = (
+            "pyamplicol-symjit-plane-application-v0"
+        )
+        refresh_catalog = True
+    elif corruption == "source_leaf_runtime_capability":
+        source_leaf["runtime_capability"] = "wrong"
+    elif corruption == "source_leaf_application_abi":
+        source_leaf["application_abi"] = "wrong"
+    elif corruption == "source_leaf_optimization":
+        source_leaf["optimization_level"] = 1
+    elif corruption == "source_leaf_path":
+        plane = source_leaf["plane_application"]
+        assert isinstance(plane, dict)
+        plane["application_path"] = "kernels/000000/missing.plane.symjit"
+    elif corruption == "source_payload_digest_link":
+        prepared_binding["source_application_sha256"] = "0" * 64
+        refresh_catalog = True
+    else:
+        pytest.fail(f"unknown corruption {corruption}")
+
+    if refresh_catalog is not None:
+        _refresh_recurrence_catalog(
+            execution,
+            pack,
+            refresh_binding_digests=refresh_catalog,
+        )
+    _rewrite_json_payload(tmp_path, execution_payload, execution)
+    _rewrite_json_payload(tmp_path, pack_payload, pack)
+    with pytest.raises(RunnerError, match=message):
+        _authenticated_recurrence_source_identity(
+            manifest,
+            process_id="process-1",
+            source_optimization_level=2,
+        )
+
+
+def test_resolved_sum_validation_and_pointwise_tolerances() -> None:
+    runtime = FakeRuntime()
+    points = (((1.0, 0.0, 0.0, 1.0),),)
+    contract = derive_selector_contract(runtime, points)
+    cell = _cell(
+        ExecutionMode.RECURRENCE,
+        Accuracy.LC,
+        Workload.SELECTED_FLOW,
+    )
+
+    assert (
+        resolved_sum_validation(
+            runtime,
+            points,
+            cell=cell,
+            selector_contract=contract,
+        )["status"]
+        == "ok"
+    )
+    runtime.resolved_total = (2.0 + 0.0j,)
+    assert (
+        resolved_sum_validation(
+            runtime,
+            points,
+            cell=cell,
+            selector_contract=contract,
+        )["status"]
+        == "validation_failed"
+    )
+
+    assert pointwise_validation(1.0 + 1.0e-13, 1.0)["status"] == "ok"
+    assert pointwise_validation(2.0, 1.0)["status"] == "validation_failed"
+
+
+def test_matrix_element_conversion_rejects_sign_and_complex_drift() -> None:
+    assert _real_nonnegative(2.0 + 0.0j) == 2.0
+    assert _real_nonnegative(-1.0e-16 + 0.0j) == 0.0
+    with pytest.raises(RunnerError, match="materially negative"):
+        _real_nonnegative(-1.0e-3 + 0.0j)
+    with pytest.raises(RunnerError, match="imaginary part"):
+        _real_nonnegative(1.0 + 1.0e-3j)
diff --git a/pyamplicol/tests/unit/test_three_mode_report_scheduler.py b/pyamplicol/tests/unit/test_three_mode_report_scheduler.py
new file mode 100644
index 0000000000..03fcf4950e
--- /dev/null
+++ b/pyamplicol/tests/unit/test_three_mode_report_scheduler.py
@@ -0,0 +1,3736 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import json
+import subprocess
+import threading
+from collections.abc import Mapping, Sequence
+from copy import deepcopy
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.agreements import (
+    DIRECT_AGREEMENT_FIELD,
+    INDEPENDENT_AUTHORITY_FIELD,
+    LC_COMMON_COMPONENT_ABI,
+    LC_COMMON_COMPONENT_FIELD,
+    independent_numerical_authorities,
+)
+from tools.performance_report.artifacts import (
+    ArtifactAttempt,
+    ArtifactStore,
+    CurrentRecord,
+    DiskFullError,
+)
+from tools.performance_report.cache import digest_json, empty_measurement
+from tools.performance_report.campaign_policy import (
+    MACBOOK_M3_MEMORY_LIMIT_BYTES,
+    MACBOOK_M3_Z_TABLE_F_POLICY,
+    X86_EPYC_MEMORY_LIMIT_BYTES,
+    X86_EPYC_NATIVE_COMPILER_SLOTS,
+    X86_EPYC_POLICY,
+    X86_EPYC_PROFILE,
+    X86_EPYC_WORKERS,
+    PolicyMeasurementState,
+    policy_status_label,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.measurement import failure_measurement
+from tools.performance_report.models import (
+    Accuracy,
+    ArtifactPolicy,
+    CellSpec,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from tools.performance_report.phase_state import WorkerPhaseChannel
+from tools.performance_report.resources import (
+    GenerationPhaseEvidence,
+    ResourceUsage,
+    SupervisedResult,
+    WorkerObservation,
+)
+from tools.performance_report.runner import pointwise_validation
+from tools.performance_report.scheduler import (
+    CampaignResult,
+    CampaignScheduler,
+    CampaignSettings,
+    CellOutcome,
+    CellSelection,
+    PlannedCell,
+    _CoordinationDeferred,
+    _fresh_equivalent_current,
+    _partition_dependency_records,
+    _PreparationFailed,
+    _symbolica_generation_lock_path,
+    _worker_environment_overrides,
+    plan_campaign,
+    select_cells,
+)
+from tools.performance_report.service import ReportPaths, ReportService
+from tools.performance_report.source_identity import ReportSourceIdentity
+
+
+def _store(tmp_path: Path) -> ArtifactStore:
+    return ArtifactStore(
+        artifact_root=tmp_path / "artifacts",
+        lock_root=tmp_path / "locks",
+    )
+
+
+def test_epyc_worker_environment_injects_shared_native_compiler_gate(
+    tmp_path: Path,
+) -> None:
+    settings = CampaignSettings(
+        workers=X86_EPYC_WORKERS,
+        cell_cores=1,
+        target_runtime_seconds=5.0,
+        max_rss_bytes=X86_EPYC_MEMORY_LIMIT_BYTES,
+        allow_symbolica_parallel=True,
+        campaign_policy=X86_EPYC_POLICY,
+        report_profile=X86_EPYC_PROFILE,
+    )
+
+    assert _worker_environment_overrides(settings, tmp_path / "coordination") == {
+        "PYAMPLICOL_NATIVE_COMPILER_GATE_DIR": str(
+            (tmp_path / "coordination" / "native-compiler-slots").resolve()
+        ),
+        "PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT": str(X86_EPYC_NATIVE_COMPILER_SLOTS),
+    }
+    assert (
+        _worker_environment_overrides(
+            CampaignSettings(),
+            tmp_path / "strict-coordination",
+        )
+        == {}
+    )
+
+    ufo_compiled = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.model is ModelKey.UFO_SM
+        and cell.measurement.execution_mode is ExecutionMode.COMPILED
+    )
+    strict_root = tmp_path / "strict-coordination"
+    assert (
+        _symbolica_generation_lock_path(
+            CampaignSettings(),
+            strict_root,
+            ufo_compiled,
+        )
+        == (strict_root / "symbolica-ufo-compiled-generation.lock").resolve()
+    )
+    assert (
+        _symbolica_generation_lock_path(
+            CampaignSettings(allow_symbolica_parallel=True),
+            strict_root,
+            ufo_compiled,
+        )
+        is None
+    )
+
+
+def _ok_measurement(
+    cell: CellSpec | None = None,
+    *,
+    revision: str | None = None,
+) -> dict[str, object]:
+    measurement = empty_measurement()
+    selector = (
+        None
+        if cell is None or cell.measurement.accuracy is not Accuracy.LC
+        else {
+            "selected_color_flow_ids": ["flow:2,1"],
+            "selected_color_words": [[2, 1]],
+            "all_flow_helicity_ids": ["h:-1,+1,-1"],
+            "all_flow_source_helicities": {"1": -1, "2": 1, "3": -1},
+            "point_digest": "a" * 64,
+        }
+    )
+    validation: dict[str, object] = {
+        "status": ResultStatus.OK.value,
+        DIRECT_AGREEMENT_FIELD: [],
+    }
+    if cell is not None and (
+        cell.dataset_id in {"scalar_contact", "scalar_gravity"}
+        or cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+    ):
+        point_identity = "a" * 64
+        ordering = "b" * 64
+
+        def resolved_record(precision: int, source: str) -> dict[str, object]:
+            point = pointwise_validation(
+                1.0,
+                1.0,
+                candidate_scale=1.0,
+                baseline_scale=1.0,
+                comparison_binding={
+                    "abi": "pyamplicol-report-resolved-component-scale-v1",
+                    "point_digest": point_identity,
+                    "helicity_ids": [],
+                    "color_flow_ids": [],
+                    "resolved_ordering_sha256": ordering,
+                    "resolved_source_sha256": source,
+                    "point_index": 0,
+                },
+            )
+            return {
+                "abi": "pyamplicol-report-resolved-sum-validation-v2",
+                "status": ResultStatus.OK.value,
+                "maximum_absolute_difference": 0.0,
+                "maximum_relative_difference": 0.0,
+                "maximum_conditioned_residual": 0.0,
+                "relative_tolerance": 1.0e-12,
+                "point_digest": point_identity,
+                "helicity_ids": [],
+                "color_flow_ids": [],
+                "resolved_ordering_sha256": ordering,
+                "resolved_source_sha256": source,
+                "scale_source": "resolved-component-l1",
+                "precision_digits": precision,
+                "points": [point],
+            }
+
+        binary64 = resolved_record(16, "c" * 64)
+        p32 = resolved_record(32, "d" * 64)
+        selector_identity = {
+            "cell_id": cell.cell_id,
+            "accuracy": cell.measurement.accuracy.value,
+            "workload": cell.workload.value,
+            "selector_contract": selector,
+            "value_kind": "matrix-element-p16-versus-p32",
+        }
+        validation.update(
+            {
+                "resolved_sum": binary64,
+                "high_precision_resolved_sum": p32,
+                "high_precision": pointwise_validation(
+                    1.0,
+                    1.0,
+                    candidate_scale=1.0,
+                    baseline_scale=1.0,
+                    candidate_scale_source="resolved-component-l1-binary64",
+                    baseline_scale_source="resolved-component-l1-p32",
+                    comparison_binding={
+                        "point_digest": point_identity,
+                        "selector_component_identity": selector_identity,
+                        "selector_component_sha256": digest_json(selector_identity),
+                        "candidate_source_sha256": "c" * 64,
+                        "baseline_source_sha256": "d" * 64,
+                    },
+                ),
+            }
+        )
+    if selector is not None:
+        assert cell is not None
+        validation[LC_COMMON_COMPONENT_FIELD] = {
+            "abi": LC_COMMON_COMPONENT_ABI,
+            "cell_id": cell.cell_id,
+            "value": 1.0,
+            "point_digest": selector["point_digest"],
+            "helicity_ids": selector["all_flow_helicity_ids"],
+            "color_flow_ids": selector["selected_color_flow_ids"],
+        }
+    measurement.update(
+        {
+            "status": ResultStatus.OK.value,
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 1.0e-6,
+            "execution_seconds_per_point": 8.0e-7,
+            "matrix_element": 1.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 0.0,
+            "relative_standard_error": 0.0,
+            "artifact": {},
+            "selector_contract": selector,
+            "validation": validation,
+            "resources": {},
+            "provenance": (
+                {} if revision is None else {"report_source_revision": revision}
+            ),
+        }
+    )
+    return measurement
+
+
+def test_selection_combines_all_supported_filter_axes() -> None:
+    selected = select_cells(
+        CellSelection(
+            datasets=frozenset({"matrix_eager_builtin_sm_lc"}),
+            modes=frozenset({ExecutionMode.EAGER}),
+            models=frozenset({ModelKey.BUILTIN_SM}),
+            accuracies=frozenset({Accuracy.LC}),
+            process_keys=frozenset({"dd_z_jets"}),
+            multiplicities=frozenset({3}),
+            workloads=frozenset({Workload.ALL_FLOW}),
+        )
+    )
+
+    assert len(selected) == 1
+    assert selected[0].cell_id.endswith("all-flow")
+
+
+def test_variant_selection_only_filters_cells_with_a_variant_dimension() -> None:
+    selected = select_cells(
+        CellSelection(
+            modes=frozenset({ExecutionMode.COMPILED}),
+            multiplicities=frozenset({8, 9}),
+            variants=frozenset({"jit_o3"}),
+        )
+    )
+
+    assert any(cell.dataset_id == "matrix_compiled_builtin_sm_lc" for cell in selected)
+    assert any(cell.dataset_id == "z_builtin_sm" for cell in selected)
+    assert all(cell.variant in {None, "jit_o3"} for cell in selected)
+    assert not any(cell.variant == "jit_o1" for cell in selected)
+
+
+def test_compiled_plan_can_opt_out_of_automatic_numerical_authorities(
+    tmp_path: Path,
+) -> None:
+    candidate = select_cells(
+        CellSelection(
+            datasets=frozenset({"matrix_compiled_builtin_sm_lc"}),
+            process_keys=frozenset({"dd_z_jets"}),
+            multiplicities=frozenset({1}),
+            workloads=frozenset({Workload.SELECTED_FLOW}),
+        )
+    )
+    planned = plan_campaign(
+        candidate,
+        store=_store(tmp_path),
+        settings=CampaignSettings(),
+    )
+
+    assert len(planned) == 1
+    target = planned[0]
+    assert target.cell.measurement.execution_mode is ExecutionMode.COMPILED
+    assert not target.dependency
+    assert target.baseline_cell_id is None
+    assert target.optional_baseline_cell_id == (
+        "matrix-recurrence-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    )
+    assert target.numerical_authority_cell_ids == (
+        "matrix-recurrence-builtin-sm-lc-n1-dd-z-jets-selected-flow",
+    )
+    assert target.prerequisite_cell_ids == ()
+
+
+@pytest.mark.parametrize(
+    "dataset_id",
+    ("matrix_compiled_builtin_sm_lc", "matrix_eager_builtin_sm_lc"),
+)
+def test_automatic_authority_closure_orders_amplicol_recurrence_then_candidate(
+    dataset_id: str,
+    tmp_path: Path,
+) -> None:
+    candidate = _matrix_cell(dataset_id)
+    recurrence = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert recurrence is not None
+    amplicol = REPORT_CATALOG.validation_baseline_cell(recurrence)
+    assert amplicol is not None
+
+    planned = plan_campaign(
+        (candidate,),
+        store=_store(tmp_path),
+        settings=CampaignSettings(
+            add_optional_dependencies=True,
+            original_amplicol_available=True,
+        ),
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+
+    assert set(by_id) == {candidate.cell_id, recurrence.cell_id, amplicol.cell_id}
+    assert not by_id[candidate.cell_id].dependency
+    assert by_id[recurrence.cell_id].dependency
+    assert by_id[amplicol.cell_id].dependency
+    assert by_id[amplicol.cell_id].prerequisite_cell_ids == ()
+    assert by_id[recurrence.cell_id].prerequisite_cell_ids == (amplicol.cell_id,)
+    assert recurrence.cell_id in by_id[candidate.cell_id].prerequisite_cell_ids
+    assert by_id[amplicol.cell_id].rank < by_id[recurrence.cell_id].rank
+    assert by_id[recurrence.cell_id].rank < by_id[candidate.cell_id].rank
+
+
+def test_automatic_authority_closure_without_legacy_adds_recurrence_only(
+    tmp_path: Path,
+) -> None:
+    candidate = _matrix_cell("matrix_compiled_builtin_sm_lc")
+    recurrence = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert recurrence is not None
+
+    planned = plan_campaign(
+        (candidate,),
+        store=_store(tmp_path),
+        settings=CampaignSettings(add_optional_dependencies=True),
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+
+    assert set(by_id) == {candidate.cell_id, recurrence.cell_id}
+    assert by_id[recurrence.cell_id].dependency
+    assert by_id[candidate.cell_id].prerequisite_cell_ids == (recurrence.cell_id,)
+
+
+def test_automatic_authority_closure_reuses_active_source_authorities(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    candidate = _matrix_cell("matrix_compiled_builtin_sm_lc")
+    recurrence = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert recurrence is not None
+    amplicol = REPORT_CATALOG.validation_baseline_cell(recurrence)
+    assert amplicol is not None
+    _publish_current(store, recurrence, revision="same")
+    _publish_current(store, amplicol, revision="same")
+
+    planned = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(
+            add_optional_dependencies=True,
+            original_amplicol_available=True,
+        ),
+        expected_revision="same",
+    )
+
+    assert tuple(item.cell for item in planned) == (candidate,)
+
+
+def test_automatic_authority_closure_replans_historical_authorities(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    candidate = _matrix_cell("matrix_compiled_builtin_sm_lc")
+    recurrence = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert recurrence is not None
+    amplicol = REPORT_CATALOG.validation_baseline_cell(recurrence)
+    assert amplicol is not None
+    _publish_current(store, recurrence, revision="old")
+    _publish_current(store, amplicol, revision="old")
+
+    planned = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(
+            add_optional_dependencies=True,
+            original_amplicol_available=True,
+        ),
+        expected_revision="new",
+    )
+
+    assert {item.cell.cell_id for item in planned} == {
+        candidate.cell_id,
+        recurrence.cell_id,
+        amplicol.cell_id,
+    }
+
+
+def test_automatic_authority_closure_reuses_terminal_active_authority(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    candidate = _matrix_cell("matrix_compiled_builtin_sm_lc")
+    recurrence = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert recurrence is not None
+    terminal = _publish_current(store, recurrence, revision="same")
+
+    def current(
+        cell: CellSpec,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+        if cell == recurrence:
+            return terminal, PolicyMeasurementState.GENERATION_LIMIT
+        return None
+
+    planned = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(add_optional_dependencies=True),
+        current_resolver=current,
+    )
+
+    assert tuple(item.cell for item in planned) == (candidate,)
+    assert planned[0].prerequisite_cell_ids == ()
+    assert recurrence.cell_id in planned[0].numerical_authority_cell_ids
+
+
+def test_no_dependencies_added_still_closes_hard_lc_provider_dependency(
+    tmp_path: Path,
+) -> None:
+    candidate = _matrix_cell(
+        "matrix_compiled_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+
+    planned = plan_campaign(
+        (candidate,),
+        store=_store(tmp_path),
+        settings=CampaignSettings(add_optional_dependencies=False),
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+
+    assert candidate.cell_id in by_id
+    hard_ids = set(by_id[candidate.cell_id].prerequisite_cell_ids)
+    assert hard_ids
+    assert all(by_id[cell_id].dependency for cell_id in hard_ids)
+    assert all(
+        by_id[cell_id].cell.measurement.execution_mode is ExecutionMode.COMPILED
+        for cell_id in hard_ids
+    )
+
+
+def test_automatic_authority_addition_recursively_closes_its_dependencies(
+    tmp_path: Path,
+) -> None:
+    candidate = _matrix_cell(
+        "matrix_compiled_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+    recurrence = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert recurrence is not None
+    recurrence_provider = REPORT_CATALOG.cell(
+        recurrence.cell_id.replace("all-flow", "selected-flow")
+    )
+
+    planned = plan_campaign(
+        (candidate,),
+        store=_store(tmp_path),
+        settings=CampaignSettings(add_optional_dependencies=True),
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+
+    assert recurrence.cell_id in by_id[candidate.cell_id].prerequisite_cell_ids
+    assert recurrence_provider.cell_id in by_id
+    assert by_id[recurrence_provider.cell_id].dependency
+    assert (
+        recurrence_provider.cell_id
+        in by_id[recurrence.cell_id].prerequisite_cell_ids
+    )
+    assert by_id[recurrence_provider.cell_id].rank < by_id[recurrence.cell_id].rank
+
+
+def test_catalog_wide_automatic_authority_closure_is_exact_and_acyclic(
+    tmp_path: Path,
+) -> None:
+    direct = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.execution_mode
+        in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+        and REPORT_CATALOG.static_na_reason(cell) is None
+    )
+    planned = plan_campaign(
+        direct,
+        store=_store(tmp_path),
+        settings=CampaignSettings(
+            add_optional_dependencies=True,
+            original_amplicol_available=True,
+        ),
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+
+    assert len(by_id) == len(planned)
+    for candidate in direct:
+        item = by_id[candidate.cell_id]
+        for authority in independent_numerical_authorities(candidate):
+            assert authority.cell_id in by_id
+            assert by_id[authority.cell_id].rank < item.rank
+            assert (
+                authority.process_key,
+                authority.n_final,
+                authority.measurement.accuracy,
+                authority.workload,
+            ) == (
+                candidate.process_key,
+                candidate.n_final,
+                candidate.measurement.accuracy,
+                candidate.workload,
+            )
+    for item in planned:
+        assert all(
+            by_id[prerequisite].rank < item.rank
+            for prerequisite in item.prerequisite_cell_ids
+        )
+
+
+def test_explicit_optional_amplicol_orders_recurrence_without_becoming_hard(
+    tmp_path: Path,
+) -> None:
+    recurrence = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    amplicol = REPORT_CATALOG.validation_baseline_cell(recurrence)
+    assert amplicol is not None
+
+    planned = plan_campaign(
+        (recurrence, amplicol),
+        store=_store(tmp_path),
+        settings=CampaignSettings(),
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+    target = by_id[recurrence.cell_id]
+
+    assert set(by_id) == {recurrence.cell_id, amplicol.cell_id}
+    assert target.baseline_cell_id is None
+    assert target.optional_baseline_cell_id == amplicol.cell_id
+    assert target.prerequisite_cell_ids == (amplicol.cell_id,)
+    assert by_id[amplicol.cell_id].rank < target.rank
+
+
+def test_selected_authority_chain_is_encoded_as_ordering_prerequisites(
+    tmp_path: Path,
+) -> None:
+    compiled = _matrix_cell("matrix_compiled_builtin_sm_lc")
+    recurrence = REPORT_CATALOG.validation_baseline_cell(compiled)
+    assert recurrence is not None
+    amplicol = REPORT_CATALOG.validation_baseline_cell(recurrence)
+    assert amplicol is not None
+    eager = _matrix_cell("matrix_eager_builtin_sm_lc")
+
+    planned = plan_campaign(
+        (compiled, eager, recurrence, amplicol),
+        store=_store(tmp_path),
+        settings=CampaignSettings(),
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+
+    assert by_id[amplicol.cell_id].prerequisite_cell_ids == ()
+    assert by_id[recurrence.cell_id].prerequisite_cell_ids == (amplicol.cell_id,)
+    for candidate in (compiled, eager):
+        assert by_id[candidate.cell_id].prerequisite_cell_ids == (recurrence.cell_id,)
+
+
+def test_optional_amplicol_current_is_forwarded_only_when_successful(
+    tmp_path: Path,
+) -> None:
+    recurrence = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    amplicol = REPORT_CATALOG.validation_baseline_cell(recurrence)
+    assert amplicol is not None
+    record = _publish_current(_store(tmp_path), amplicol, revision="same")
+
+    baseline, peers, blockers = _partition_dependency_records(
+        baseline_cell_id=None,
+        comparison_peer_ids=(),
+        optional_baseline_cell_id=amplicol.cell_id,
+        currents={
+            amplicol.cell_id: (record, PolicyMeasurementState.GENERATION_LIMIT)
+        },
+    )
+    assert baseline is None
+    assert peers == {}
+    assert blockers == ()
+
+    baseline, peers, blockers = _partition_dependency_records(
+        baseline_cell_id=None,
+        comparison_peer_ids=(),
+        optional_baseline_cell_id=amplicol.cell_id,
+        currents={amplicol.cell_id: (record, PolicyMeasurementState.SUCCESS)},
+    )
+    assert baseline is record
+    assert peers == {}
+    assert blockers == ()
+
+
+@pytest.mark.parametrize(
+    ("state", "expects_baseline"),
+    (
+        (PolicyMeasurementState.SUCCESS, True),
+        (PolicyMeasurementState.GENERATION_LIMIT, False),
+    ),
+)
+def test_scheduler_launches_recurrence_with_only_successful_optional_amplicol(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    state: PolicyMeasurementState,
+    expects_baseline: bool,
+) -> None:
+    service = _service(tmp_path)
+    recurrence = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    amplicol = REPORT_CATALOG.validation_baseline_cell(recurrence)
+    assert amplicol is not None
+    optional_record = _publish_current(
+        service.store,
+        amplicol,
+        revision="current-revision",
+    )
+    captured: list[str] = []
+
+    def current(
+        cell: CellSpec,
+        *,
+        comparison_dependency: bool = False,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+        assert comparison_dependency is (cell == amplicol)
+        return (optional_record, state) if cell == amplicol else None
+
+    def supervise(command: Sequence[str], **_kwargs: object) -> SupervisedResult:
+        captured.extend(command)
+        result_path = Path(command[command.index("--result-json") + 1])
+        result_path.write_text(
+            json.dumps(_ok_measurement(recurrence, revision="current-revision"))
+            + "\n",
+            encoding="ascii",
+        )
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(cell_cores=4, amplicol_build_jobs=1),
+    )
+    scheduler.source_revision = "current-revision"
+    monkeypatch.setattr(scheduler, "_current", current)
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        supervise,
+    )
+
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            recurrence,
+            dependency=False,
+            baseline_cell_id=None,
+            optional_baseline_cell_id=amplicol.cell_id,
+            rank=1,
+        )
+    )
+
+    assert outcome.status == ResultStatus.OK.value
+    assert ("--baseline-json" in captured) is expects_baseline
+    assert captured[captured.index("--cell-cores") + 1] == "4"
+    assert captured[captured.index("--amplicol-build-jobs") + 1] == "1"
+
+
+@pytest.mark.parametrize(
+    ("variant", "workload"),
+    (
+        ("jit_o1", Workload.SELECTED_FLOW),
+        ("jit_o1", Workload.ALL_FLOW),
+        ("eager_jit_o2", Workload.SELECTED_FLOW),
+        ("eager_jit_o2", Workload.ALL_FLOW),
+    ),
+)
+def test_z_compiled_and_eager_plan_recurrence_without_amplicol(
+    tmp_path: Path,
+    variant: str,
+    workload: Workload,
+) -> None:
+    candidate = _z_cell(variant=variant, workload=workload)
+    baseline = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert baseline is not None
+
+    planned = plan_campaign(
+        (candidate,),
+        store=_store(tmp_path),
+        settings=CampaignSettings(),
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+    target = by_id[candidate.cell_id]
+    recurrence_id = target.numerical_authority_cell_ids[0]
+
+    assert target.baseline_cell_id is None
+    assert target.optional_baseline_cell_id == baseline.cell_id
+    assert target.numerical_authority_cell_ids == (recurrence_id,)
+    assert recurrence_id in target.optional_comparison_peer_ids
+    assert recurrence_id not in by_id
+    assert recurrence_id not in target.prerequisite_cell_ids
+    assert all(
+        item.cell.measurement.execution_mode is not ExecutionMode.AMPLICOL
+        for item in planned
+    )
+
+
+@pytest.mark.parametrize(
+    ("variant", "workload"),
+    (
+        ("jit_o1", Workload.SELECTED_FLOW),
+        ("jit_o1", Workload.ALL_FLOW),
+        ("eager_jit_o2", Workload.SELECTED_FLOW),
+        ("eager_jit_o2", Workload.ALL_FLOW),
+    ),
+)
+@pytest.mark.parametrize(
+    "recurrence_state",
+    (
+        PolicyMeasurementState.SUCCESS,
+        PolicyMeasurementState.GENERATION_LIMIT,
+        None,
+    ),
+)
+def test_z_worker_uses_amplicol_only_as_optional_diagnostic(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    variant: str,
+    workload: Workload,
+    recurrence_state: PolicyMeasurementState | None,
+) -> None:
+    service = _service(tmp_path)
+    candidate = _z_cell(variant=variant, workload=workload)
+    baseline = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert baseline is not None
+    planned = plan_campaign(
+        (candidate,),
+        store=service.store,
+        settings=CampaignSettings(),
+    )
+    target = next(item for item in planned if item.cell == candidate)
+    recurrence = REPORT_CATALOG.cell(target.numerical_authority_cell_ids[0])
+    dependency_records = {
+        peer_id: _publish_current(
+            service.store,
+            REPORT_CATALOG.cell(peer_id),
+            revision="current-revision",
+        )
+        for peer_id in target.comparison_peer_ids
+    }
+    recurrence_record = _publish_current(
+        service.store,
+        recurrence,
+        revision="current-revision",
+    )
+    amplicol_record = _publish_current(
+        service.store,
+        baseline,
+        revision="current-revision",
+    )
+    captured: list[str] = []
+
+    def current(
+        cell: CellSpec,
+        *,
+        comparison_dependency: bool = False,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+        if cell == candidate:
+            assert comparison_dependency is False
+            return None
+        assert comparison_dependency is True
+        if cell == baseline:
+            return amplicol_record, PolicyMeasurementState.SUCCESS
+        if cell == recurrence:
+            return (
+                None
+                if recurrence_state is None
+                else (recurrence_record, recurrence_state)
+            )
+        record = dependency_records.get(cell.cell_id)
+        return None if record is None else (record, PolicyMeasurementState.SUCCESS)
+
+    def supervise(command: Sequence[str], **_kwargs: object) -> SupervisedResult:
+        captured.extend(command)
+        result_path = Path(command[command.index("--result-json") + 1])
+        result_path.write_text(
+            json.dumps(_ok_measurement(candidate, revision="current-revision"))
+            + "\n",
+            encoding="ascii",
+        )
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    scheduler = CampaignScheduler(service, settings=CampaignSettings())
+    scheduler.source_revision = "current-revision"
+    monkeypatch.setattr(scheduler, "_current", current)
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        supervise,
+    )
+
+    outcome = scheduler._run_cell(target)
+
+    expected_baseline = (
+        recurrence_record
+        if recurrence_state is PolicyMeasurementState.SUCCESS
+        else amplicol_record
+    )
+    assert outcome.status == ResultStatus.OK.value
+    assert captured[captured.index("--baseline-json") + 1] == str(
+        expected_baseline.result_path
+    )
+    assert (
+        tuple(
+            captured[index + 1]
+            for index, value in enumerate(captured)
+            if value == "--expected-authority-cell-id"
+        )
+        == target.numerical_authority_cell_ids
+    )
+    if recurrence_state is PolicyMeasurementState.SUCCESS:
+        assert captured[captured.index("--selected-authority-cell-id") + 1] == (
+            recurrence.cell_id
+        )
+    else:
+        assert "--selected-authority-cell-id" not in captured
+
+
+@pytest.mark.parametrize(
+    "recurrence_state",
+    (None, PolicyMeasurementState.GENERATION_LIMIT),
+)
+def test_z_worker_runs_when_every_numerical_authority_is_unavailable(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    recurrence_state: PolicyMeasurementState | None,
+) -> None:
+    service = _service(tmp_path)
+    candidate = _z_cell(
+        variant="jit_o1",
+        workload=Workload.SELECTED_FLOW,
+    )
+    baseline = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert baseline is not None
+    planned = plan_campaign(
+        (candidate,),
+        store=service.store,
+        settings=CampaignSettings(),
+    )
+    target = next(item for item in planned if item.cell == candidate)
+    recurrence = REPORT_CATALOG.cell(target.numerical_authority_cell_ids[0])
+    amplicol_record = _publish_current(
+        service.store,
+        baseline,
+        revision="current-revision",
+    )
+    terminal_recurrence = _ok_measurement(
+        recurrence,
+        revision="current-revision",
+    )
+    terminal_recurrence["status"] = ResultStatus.TIMEOUT.value
+    provenance = terminal_recurrence["provenance"]
+    assert isinstance(provenance, dict)
+    provenance["policy_censor_sha256"] = "f" * 64
+    recurrence_record = service.store.new_attempt(
+        recurrence.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(terminal_recurrence)
+
+    def current(
+        cell: CellSpec,
+        *,
+        comparison_dependency: bool = False,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+        if cell == candidate:
+            return None
+        assert comparison_dependency is True
+        if cell == baseline:
+            return amplicol_record, PolicyMeasurementState.GENERATION_LIMIT
+        if cell == recurrence:
+            return (
+                None
+                if recurrence_state is None
+                else (recurrence_record, recurrence_state)
+            )
+        pytest.fail(f"unexpected dependency query for {cell.cell_id}")
+
+    scheduler = CampaignScheduler(service, settings=CampaignSettings())
+    scheduler.source_revision = "current-revision"
+    monkeypatch.setattr(scheduler, "_current", current)
+    launched: list[Sequence[str]] = []
+
+    def supervise(command: Sequence[str], **_kwargs: object) -> SupervisedResult:
+        launched.append(command)
+        result_path = Path(command[command.index("--result-json") + 1])
+        result_path.write_text(
+            json.dumps(
+                failure_measurement(
+                    ResultStatus.ERROR,
+                    "synthetic worker reached without authority",
+                )
+            )
+            + "\n",
+            encoding="ascii",
+        )
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        supervise,
+    )
+
+    outcome = scheduler._run_cell(target)
+
+    assert outcome.status == ResultStatus.ERROR.value
+    assert len(launched) == 1
+    command = launched[0]
+    assert "--baseline-json" not in command
+    assert (
+        tuple(
+            command[index + 1]
+            for index, value in enumerate(command)
+            if value == "--expected-authority-cell-id"
+        )
+        == target.numerical_authority_cell_ids
+    )
+    assert "--selected-authority-cell-id" not in command
+
+
+def test_postworker_late_recurrence_certifies_legacy_diagnostic_run(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    candidate = _z_cell(variant="jit_o1", workload=Workload.SELECTED_FLOW)
+    target = plan_campaign(
+        (candidate,),
+        store=service.store,
+        settings=CampaignSettings(),
+    )[0]
+    recurrence = REPORT_CATALOG.cell(target.numerical_authority_cell_ids[0])
+    amplicol = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert amplicol is not None
+    recurrence_record = _publish_current(
+        service.store,
+        recurrence,
+        revision="current-revision",
+    )
+    amplicol_record = _publish_current(
+        service.store,
+        amplicol,
+        revision="current-revision",
+    )
+    worker_finished = False
+
+    def current(
+        cell: CellSpec,
+        *,
+        comparison_dependency: bool = False,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+        if cell == candidate:
+            return None
+        assert comparison_dependency is True
+        if cell == recurrence:
+            return (
+                (recurrence_record, PolicyMeasurementState.SUCCESS)
+                if worker_finished
+                else None
+            )
+        if cell == amplicol:
+            return amplicol_record, PolicyMeasurementState.SUCCESS
+        pytest.fail(f"unexpected dependency query for {cell.cell_id}")
+
+    captured: list[str] = []
+
+    def supervise(command: Sequence[str], **_kwargs: object) -> SupervisedResult:
+        nonlocal worker_finished
+        captured.extend(command)
+        result_path = Path(command[command.index("--result-json") + 1])
+        measurement = _ok_measurement(candidate, revision="current-revision")
+        measurement["status"] = ResultStatus.UNVERIFIED.value
+        validation = measurement["validation"]
+        assert isinstance(validation, dict)
+        validation["status"] = ResultStatus.UNVERIFIED.value
+        validation["independent_authority"] = {
+            "abi": "pyamplicol-report-independent-authority-v1",
+            "expected_cell_ids": list(target.numerical_authority_cell_ids),
+            "selected_cell_id": None,
+            "status": "unavailable",
+            "reason": "no-successful-independent-authority",
+            "same_artifact_diagnostics_are_authority": False,
+        }
+        result_path.write_text(json.dumps(measurement) + "\n", encoding="ascii")
+        worker_finished = True
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    reconciled: list[str] = []
+
+    def reconcile(
+        _cell: CellSpec,
+        measurement: Mapping[str, object],
+        _authority: Mapping[str, object],
+        *,
+        authority_cell_id: str,
+    ) -> dict[str, object]:
+        reconciled.append(authority_cell_id)
+        promoted = deepcopy(measurement)
+        promoted["status"] = ResultStatus.OK.value
+        promoted_validation = promoted["validation"]
+        assert isinstance(promoted_validation, dict)
+        promoted_validation["status"] = ResultStatus.OK.value
+        return promoted
+
+    scheduler = CampaignScheduler(service, settings=CampaignSettings())
+    scheduler.source_revision = "current-revision"
+    monkeypatch.setattr(scheduler, "_current", current)
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        supervise,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.validate_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.reconcile_independent_authority",
+        reconcile,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.attach_direct_agreements",
+        lambda *_args, **_kwargs: None,
+    )
+
+    outcome = scheduler._run_cell(target)
+
+    assert outcome.status == ResultStatus.OK.value
+    assert "--selected-authority-cell-id" not in captured
+    assert captured[captured.index("--baseline-json") + 1] == str(
+        amplicol_record.result_path
+    )
+    assert reconciled == [recurrence.cell_id]
+
+
+def test_postworker_tampered_unverified_is_rejected_before_reconciliation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    candidate = _z_cell(variant="jit_o1", workload=Workload.SELECTED_FLOW)
+    target = plan_campaign(
+        (candidate,),
+        store=service.store,
+        settings=CampaignSettings(),
+    )[0]
+    recurrence = REPORT_CATALOG.cell(target.numerical_authority_cell_ids[0])
+    recurrence_record = _publish_current(
+        service.store,
+        recurrence,
+        revision="current-revision",
+    )
+    worker_finished = False
+
+    def current(
+        cell: CellSpec,
+        *,
+        comparison_dependency: bool = False,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+        if cell == candidate:
+            return None
+        assert comparison_dependency is True
+        if cell == recurrence and worker_finished:
+            return recurrence_record, PolicyMeasurementState.SUCCESS
+        return None
+
+    def supervise(command: Sequence[str], **_kwargs: object) -> SupervisedResult:
+        nonlocal worker_finished
+        result_path = Path(command[command.index("--result-json") + 1])
+        result_path.write_text(
+            json.dumps(
+                failure_measurement(
+                    ResultStatus.UNVERIFIED,
+                    "tampered diagnostic fixture",
+                )
+            )
+            + "\n",
+            encoding="ascii",
+        )
+        worker_finished = True
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    scheduler = CampaignScheduler(service, settings=CampaignSettings())
+    scheduler.source_revision = "current-revision"
+    monkeypatch.setattr(scheduler, "_current", current)
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        supervise,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.reconcile_independent_authority",
+        lambda *_args, **_kwargs: pytest.fail(
+            "tampered diagnostic must be rejected before reconciliation"
+        ),
+    )
+
+    with pytest.raises(ValueError, match="measured result requires"):
+        scheduler._run_cell(target)
+
+
+def test_selected_authorities_finish_before_compiled_and_eager_work(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    scheduler = CampaignScheduler(
+        _service(tmp_path),
+        settings=CampaignSettings(workers=2),
+    )
+    candidate = _matrix_cell("matrix_compiled_builtin_sm_lc")
+    recurrence = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert recurrence is not None
+    amplicol = REPORT_CATALOG.validation_baseline_cell(recurrence)
+    assert amplicol is not None
+    eager = _matrix_cell("matrix_eager_builtin_sm_lc")
+    start_order: list[ExecutionMode] = []
+    order_guard = threading.Lock()
+
+    def run_in_lane(item: PlannedCell) -> CellOutcome:
+        with order_guard:
+            start_order.append(item.cell.measurement.execution_mode)
+        if item.cell == amplicol:
+            return CellOutcome(amplicol.cell_id, "ok", "authority complete")
+        if item.cell == recurrence:
+            assert start_order == [ExecutionMode.AMPLICOL, ExecutionMode.RECURRENCE]
+            return CellOutcome(recurrence.cell_id, "ok", "authority complete")
+        if item.cell == candidate:
+            assert ExecutionMode.RECURRENCE in start_order
+            return CellOutcome(candidate.cell_id, "ok", "verified")
+        assert item.cell == eager
+        assert ExecutionMode.RECURRENCE in start_order
+        return CellOutcome(eager.cell_id, "ok", "verified")
+
+    monkeypatch.setattr(scheduler, "_run_cell_in_lane", run_in_lane)
+    result = scheduler.run(
+        tuple(
+            reversed(
+                (
+                    PlannedCell(amplicol, False, None, 0),
+                    PlannedCell(
+                        recurrence,
+                        False,
+                        None,
+                        1,
+                        prerequisite_cell_ids=(amplicol.cell_id,),
+                    ),
+                    PlannedCell(
+                        candidate,
+                        False,
+                        None,
+                        2,
+                        numerical_authority_cell_ids=(
+                            recurrence.cell_id,
+                            amplicol.cell_id,
+                        ),
+                        prerequisite_cell_ids=(recurrence.cell_id,),
+                    ),
+                    PlannedCell(
+                        eager,
+                        False,
+                        None,
+                        3,
+                        numerical_authority_cell_ids=(
+                            recurrence.cell_id,
+                            amplicol.cell_id,
+                        ),
+                        prerequisite_cell_ids=(recurrence.cell_id,),
+                    ),
+                )
+            )
+        )
+    )
+
+    assert start_order[:2] == [ExecutionMode.AMPLICOL, ExecutionMode.RECURRENCE]
+    assert set(start_order[2:]) == {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+    assert {outcome.cell_id for outcome in result.outcomes} == {
+        recurrence.cell_id,
+        amplicol.cell_id,
+        candidate.cell_id,
+        eager.cell_id,
+    }
+
+
+@pytest.mark.parametrize(
+    "authority_status",
+    ("error", "generation_limit", "memory_limit", "worker_timeout"),
+)
+def test_terminal_optional_authority_releases_baseline_free_candidate(
+    authority_status: str,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    scheduler = CampaignScheduler(
+        _service(tmp_path),
+        settings=CampaignSettings(workers=2),
+    )
+    candidate = _matrix_cell("matrix_compiled_builtin_sm_lc")
+    recurrence = REPORT_CATALOG.validation_baseline_cell(candidate)
+    assert recurrence is not None
+    start_order: list[str] = []
+
+    def run_in_lane(item: PlannedCell) -> CellOutcome:
+        start_order.append(item.cell.cell_id)
+        if item.cell == recurrence:
+            return CellOutcome(recurrence.cell_id, authority_status, "terminal")
+        assert item.cell == candidate
+        return CellOutcome(candidate.cell_id, "unverified", "baseline-free")
+
+    monkeypatch.setattr(scheduler, "_run_cell_in_lane", run_in_lane)
+    result = scheduler.run(
+        (
+            PlannedCell(recurrence, False, None, 0),
+            PlannedCell(
+                candidate,
+                False,
+                None,
+                1,
+                numerical_authority_cell_ids=(recurrence.cell_id,),
+                prerequisite_cell_ids=(recurrence.cell_id,),
+            ),
+        )
+    )
+
+    assert start_order == [recurrence.cell_id, candidate.cell_id]
+    outcomes = {outcome.cell_id: outcome.status for outcome in result.outcomes}
+    assert outcomes == {
+        recurrence.cell_id: authority_status,
+        candidate.cell_id: "unverified",
+    }
+
+
+def test_plan_excludes_held_cell_without_suppressing_independent_work(
+    tmp_path: Path,
+) -> None:
+    requested = select_cells(
+        CellSelection(
+            datasets=frozenset({"matrix_compiled_builtin_sm_lc"}),
+            process_keys=frozenset({"dd_z_jets", "ud_w_jets"}),
+            multiplicities=frozenset({1}),
+            workloads=frozenset({Workload.SELECTED_FLOW}),
+        )
+    )
+    held = next(cell for cell in requested if cell.process_key == "dd_z_jets")
+
+    planned = plan_campaign(
+        requested,
+        store=_store(tmp_path),
+        settings=CampaignSettings(),
+        excluded_cell_ids=frozenset({held.cell_id}),
+    )
+
+    planned_ids = {item.cell.cell_id for item in planned}
+    assert held.cell_id not in planned_ids
+    assert any(item.cell.process_key == "ud_w_jets" for item in planned)
+
+
+def test_plan_does_not_exclude_candidate_for_held_optional_authority(
+    tmp_path: Path,
+) -> None:
+    candidate = _matrix_cell("matrix_compiled_builtin_sm_lc")
+    initial = plan_campaign(
+        (candidate,),
+        store=_store(tmp_path / "initial"),
+        settings=CampaignSettings(),
+    )
+    assert len(initial) == 1
+    held_authority = initial[0].numerical_authority_cell_ids[0]
+
+    planned = plan_campaign(
+        (candidate,),
+        store=_store(tmp_path / "excluded"),
+        settings=CampaignSettings(),
+        excluded_cell_ids=frozenset({held_authority}),
+    )
+
+    assert tuple(item.cell for item in planned) == (candidate,)
+
+
+def test_missing_only_reuses_valid_candidate_without_optional_authorities(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.dataset_id == "matrix_compiled_builtin_sm_lc"
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+    store.new_attempt(candidate.cell_id, ArtifactPolicy.REGENERATE).publish(
+        _ok_measurement(candidate)
+    )
+
+    planned = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(missing_only=True),
+    )
+
+    assert planned == ()
+
+
+def test_missing_only_skips_only_after_all_dependencies_are_fresh(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    candidate = _matrix_cell("matrix_compiled_builtin_sm_lc")
+    initial = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(),
+    )
+    for item in initial:
+        _publish_current(store, item.cell, revision="same")
+
+    planned = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(missing_only=True),
+        expected_revision="same",
+    )
+
+    assert planned == ()
+
+
+def test_four_line_candidates_never_plan_unsupported_legacy_dependencies(
+    tmp_path: Path,
+) -> None:
+    requested = tuple(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.process_key == "dd_4q_lines"
+        and cell.measurement.execution_mode is not ExecutionMode.AMPLICOL
+    )
+
+    planned = plan_campaign(
+        requested,
+        store=_store(tmp_path),
+        settings=CampaignSettings(),
+    )
+
+    assert len(requested) == 45
+    # Every candidate mode is measurable; the shared MadGraph full-colour
+    # reference is pulled in once as a real dependency.
+    assert len(planned) == len(requested) + 1
+    assert all(
+        item.cell.measurement.execution_mode is not ExecutionMode.AMPLICOL
+        for item in planned
+    )
+    recurrence = tuple(
+        item
+        for item in planned
+        if item.cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+    )
+    cross_mode = tuple(
+        item
+        for item in planned
+        if item.cell.measurement.execution_mode
+        in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+    )
+    assert recurrence
+    assert all(item.baseline_cell_id is None for item in recurrence)
+    assert cross_mode
+    assert all(item.baseline_cell_id is None for item in cross_mode)
+    assert all(
+        (
+            item.numerical_authority_cell_ids
+            and REPORT_CATALOG.cell(
+                item.numerical_authority_cell_ids[0]
+            ).measurement.execution_mode
+            is ExecutionMode.RECURRENCE
+        )
+        or (
+            not item.numerical_authority_cell_ids
+            and REPORT_CATALOG.dataset(
+                item.cell.dataset_id
+            ).baseline.execution_mode
+            is ExecutionMode.MADGRAPH
+        )
+        for item in cross_mode
+    )
+    unavailable_legacy = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if REPORT_CATALOG.static_na_reason(cell) is not None
+    )
+    legacy_plan = plan_campaign(
+        unavailable_legacy,
+        store=_store(tmp_path / "legacy"),
+        settings=CampaignSettings(),
+    )
+    assert len(unavailable_legacy) == 34
+    assert legacy_plan == ()
+
+
+def test_z_native_cap_is_resolved_before_any_attempt_is_planned(
+    tmp_path: Path,
+) -> None:
+    capped = tuple(
+        cell
+        for cell in REPORT_CATALOG.z_cells()
+        if cell.n_final == 7 and cell.variant in {"asm_o3", "cpp_o3"}
+    )
+
+    assert len(capped) == 8
+    assert {REPORT_CATALOG.static_na_reason(cell) for cell in capped} == {
+        "native-backend-generation-cap-n6-v1"
+    }
+    store_root = tmp_path / "native-cap"
+    planned = plan_campaign(
+        capped,
+        store=_store(store_root),
+        settings=CampaignSettings(),
+    )
+
+    assert planned == ()
+    assert not tuple(store_root.glob("cells/*/attempts/*"))
+
+
+def test_terminal_censor_rescan_cannot_reinsert_static_na_cell(
+    tmp_path: Path,
+) -> None:
+    lower = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == "reference_amplicol_lc"
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+    higher = next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == lower.dataset_id
+        and cell.process_key == lower.process_key
+        and cell.n_final == 2
+        and cell.workload is lower.workload
+    )
+
+    class StaticHigherCatalog:
+        def __getattr__(self, name: str) -> object:
+            return getattr(REPORT_CATALOG, name)
+
+        def static_na_reason(self, cell: CellSpec) -> str | None:
+            if cell == higher:
+                return "synthetic-static-na"
+            return REPORT_CATALOG.static_na_reason(cell)
+
+    settings = CampaignSettings(
+        workers=X86_EPYC_WORKERS,
+        cell_cores=1,
+        target_runtime_seconds=5.0,
+        max_rss_bytes=X86_EPYC_MEMORY_LIMIT_BYTES,
+        allow_symbolica_parallel=True,
+        campaign_policy=X86_EPYC_POLICY,
+        report_profile=X86_EPYC_PROFILE,
+    )
+    planned = plan_campaign(
+        (lower, higher),
+        store=_store(tmp_path),
+        settings=settings,
+        catalog=StaticHigherCatalog(),  # type: ignore[arg-type]
+    )
+
+    assert tuple(item.cell for item in planned) == (lower,)
+
+
+def test_campaign_run_rejects_forged_static_na_plan_before_worker_setup(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cell = REPORT_CATALOG.cell("reference-amplicol-full-n6-dd-4q-lines-contracted")
+    scheduler = CampaignScheduler(service, settings=CampaignSettings())
+    monkeypatch.setattr(
+        scheduler,
+        "_ensure_prepared_model",
+        lambda _planned: pytest.fail("static N/A plan reached prepared-model setup"),
+    )
+    monkeypatch.setattr(
+        scheduler,
+        "_run_cell",
+        lambda _planned: pytest.fail("static N/A plan reached a worker"),
+    )
+
+    with pytest.raises(
+        ValueError,
+        match=(
+            r"reference-amplicol-full-n6-dd-4q-lines-contracted.*"
+            "original-amplicol-open-quark-line-limit"
+        ),
+    ):
+        scheduler.run(
+            (
+                PlannedCell(
+                    cell,
+                    dependency=False,
+                    baseline_cell_id=None,
+                    rank=0,
+                ),
+            )
+        )
+
+    assert service.store.load_current(cell.cell_id, missing_ok=True) is None
+    assert tuple(service.paths.artifact_root.glob("cells/*/attempts/*")) == ()
+
+
+def test_campaign_cancelled_while_queued_starts_no_preflight_or_attempt(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cell = REPORT_CATALOG.cell(
+        "z-builtin-sm-n3-dd-z-jets-recurrence-jit-o2-selected-flow"
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(cancellation_requested=lambda: True),
+    )
+    monkeypatch.setattr(
+        scheduler,
+        "_ensure_prepared_model",
+        lambda _planned: pytest.fail("cancelled campaign reached model preflight"),
+    )
+    result = scheduler.run(
+        (
+            PlannedCell(
+                cell,
+                dependency=False,
+                baseline_cell_id=None,
+                rank=0,
+            ),
+        )
+    )
+
+    assert result.outcomes == ()
+    assert tuple(service.paths.artifact_root.glob("cells/*/attempts/*")) == ()
+
+
+@pytest.mark.parametrize(
+    ("reason", "returncode", "succeeds"),
+    (
+        ("completed", 0, True),
+        ("completed", 1, False),
+        ("cancelled", -15, False),
+    ),
+)
+def test_prepared_model_preflight_always_emits_transient_completion(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    reason: str,
+    returncode: int,
+    succeeds: bool,
+) -> None:
+    service = _service(tmp_path)
+    cell = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    planned = PlannedCell(
+        cell,
+        dependency=False,
+        baseline_cell_id=None,
+        rank=1,
+    )
+    prepared_model = tmp_path / "prepared-model.pyamplicol-model"
+    prepared_model.write_text("fixture\n", encoding="ascii")
+    events: list[dict[str, object]] = []
+    commands: list[tuple[str, ...]] = []
+
+    def observe(payload: Mapping[str, object]) -> None:
+        events.append(dict(payload))
+
+    def fake_supervise(
+        command: Sequence[str],
+        **arguments: object,
+    ) -> SupervisedResult:
+        commands.append(tuple(command))
+        observation_callback = arguments["observation_callback"]
+        assert callable(observation_callback)
+        observation_callback(
+            WorkerObservation(
+                pid=100,
+                usage=ResourceUsage(True, 0, 0, 0, 0.0, 0.1),
+                phase="waiting-for-reap",
+                phase_sequence=None,
+                member_pids=(100,),
+            )
+        )
+        if succeeds:
+            result_path = Path(command[command.index("--result-json") + 1])
+            result_path.parent.mkdir(parents=True, exist_ok=True)
+            result_path.write_text(
+                json.dumps({"path": str(prepared_model)}) + "\n",
+                encoding="ascii",
+            )
+        return SupervisedResult(
+            returncode,
+            reason,  # type: ignore[arg-type]
+            ResourceUsage(True, 0, 0, 0, 0.0, 0.1),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(progress_observer=observe),
+    )
+
+    if succeeds:
+        scheduler._ensure_prepared_model((planned,))
+    else:
+        with pytest.raises(RuntimeError, match="prepared-model preflight failed"):
+            scheduler._ensure_prepared_model((planned,))
+
+    attempt_id = "prepared-model-builtin_sm"
+    assert [event["event"] for event in events[:2]] == ["started", "worker"]
+    assert events[1]["attempt_id"] == attempt_id
+    assert commands[0][commands[0].index("--producer-revision") + 1] == (
+        scheduler.source_revision
+    )
+    assert any(
+        event.get("event") == "resource"
+        and event.get("phase") == "waiting-for-reap"
+        for event in events
+    )
+    assert events[-1] == {
+        "event": "preflight-finished",
+        "cell_id": cell.cell_id,
+        "attempt_id": attempt_id,
+    }
+
+
+@pytest.mark.parametrize(
+    "three_line_key",
+    ("dd_3q_lines", "dd_3q_identical_lines"),
+)
+def test_contracted_n6_multi_quark_plans_separate_legacy_capability(
+    tmp_path: Path,
+    three_line_key: str,
+) -> None:
+    three_line = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-full-n6-"
+        f"{three_line_key.replace('_', '-')}-contracted"
+    )
+    four_line = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-full-n6-dd-4q-lines-contracted"
+    )
+    four_line_compiled = REPORT_CATALOG.cell(
+        "matrix-compiled-builtin-sm-full-n6-dd-4q-lines-contracted"
+    )
+
+    three_line_plan = plan_campaign(
+        (three_line,),
+        store=_store(tmp_path / "three-line"),
+        settings=CampaignSettings(),
+    )
+    assert tuple(item.cell for item in three_line_plan) == (three_line,)
+    three_line_item = three_line_plan[0]
+    assert three_line_item.baseline_cell_id is None
+    assert three_line_item.optional_baseline_cell_id == (
+        f"reference-amplicol-full-n6-{three_line_key.replace('_', '-')}-contracted"
+    )
+
+    four_line_plan = plan_campaign(
+        (four_line,),
+        store=_store(tmp_path / "four-line"),
+        settings=CampaignSettings(),
+    )
+    assert tuple(item.cell for item in four_line_plan) == (four_line,)
+    assert four_line_plan[0].baseline_cell_id is None
+
+    compiled_plan = plan_campaign(
+        (four_line_compiled,),
+        store=_store(tmp_path / "compiled"),
+        settings=CampaignSettings(),
+    )
+    assert tuple(item.cell for item in compiled_plan) == (four_line_compiled,)
+    compiled_item = compiled_plan[0]
+    assert compiled_item.baseline_cell_id is None
+    assert compiled_item.numerical_authority_cell_ids == (four_line.cell_id,)
+
+
+def test_missing_only_schedules_stale_direct_peer_and_recomparison(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    candidate = _matrix_cell(
+        "matrix_compiled_builtin_sm_lc",
+        workload=Workload.ALL_FLOW,
+    )
+    initial = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(),
+    )
+    target = next(item for item in initial if item.cell == candidate)
+    baseline_id = target.baseline_cell_id
+    stale_peer_id = next(
+        peer_id for peer_id in target.comparison_peer_ids if peer_id != baseline_id
+    )
+    for item in initial:
+        _publish_current(
+            store,
+            item.cell,
+            revision=("old" if item.cell.cell_id == stale_peer_id else "new"),
+        )
+
+    repaired = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(missing_only=True),
+        expected_revision="new",
+    )
+    repaired_by_id = {item.cell.cell_id: item for item in repaired}
+
+    assert stale_peer_id in repaired_by_id
+    assert candidate.cell_id in repaired_by_id
+    assert repaired_by_id[candidate.cell_id].force_recompare is True
+    assert repaired_by_id[stale_peer_id].rank < repaired_by_id[candidate.cell_id].rank
+
+
+@pytest.mark.parametrize(
+    "execution_mode",
+    (ExecutionMode.COMPILED, ExecutionMode.EAGER),
+)
+def test_missing_only_reuses_recurrence_certified_current(
+    tmp_path: Path,
+    execution_mode: ExecutionMode,
+) -> None:
+    store = _store(tmp_path)
+    candidate = REPORT_CATALOG.cell(
+        f"matrix-{execution_mode.value}-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    )
+    authorities = independent_numerical_authorities(candidate)
+    assert len(authorities) == 1
+    (recurrence,) = authorities
+    candidate_measurement = _ok_measurement(candidate, revision="current")
+    validation = candidate_measurement["validation"]
+    assert isinstance(validation, dict)
+    validation[INDEPENDENT_AUTHORITY_FIELD] = {
+        "abi": "pyamplicol-report-independent-authority-v1",
+        "expected_cell_ids": [authority.cell_id for authority in authorities],
+        "selected_cell_id": recurrence.cell_id,
+        "status": "verified",
+        "reason": "independent-authority-agreement",
+        "same_artifact_diagnostics_are_authority": False,
+    }
+    candidate_current = store.new_attempt(
+        candidate.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(candidate_measurement)
+    recurrence_current = _publish_current(store, recurrence, revision="current")
+
+    def current(
+        cell: CellSpec,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+        if cell == candidate:
+            return candidate_current, PolicyMeasurementState.SUCCESS
+        if cell == recurrence:
+            return recurrence_current, PolicyMeasurementState.SUCCESS
+        return None
+
+    planned = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(missing_only=True),
+        current_resolver=current,
+    )
+
+    assert planned == ()
+
+
+@pytest.mark.parametrize("dataset_id", ("scalar_contact", "scalar_gravity"))
+def test_self_certified_scalar_compiled_current_is_reused(
+    tmp_path: Path,
+    dataset_id: str,
+) -> None:
+    cell = next(
+        candidate
+        for candidate in REPORT_CATALOG.measurement_cells()
+        if candidate.dataset_id == dataset_id
+    )
+    store = _store(tmp_path)
+    _publish_current(store, cell, revision="active")
+
+    planned = plan_campaign(
+        (cell,),
+        store=store,
+        settings=CampaignSettings(missing_only=True),
+        expected_revision="active",
+    )
+
+    assert planned == ()
+
+
+def test_z_cell_explicitly_reuses_valid_cross_source_comparisons(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    store = _store(tmp_path)
+    candidate = REPORT_CATALOG.cell(
+        "z-builtin-sm-n8-dd-z-jets-recurrence-jit-o2-all-flow"
+    )
+    initial = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(),
+    )
+    dependency_ids = {item.cell.cell_id for item in initial if item.cell != candidate}
+    for item in initial:
+        if item.cell == candidate:
+            continue
+        result = _ok_measurement(item.cell, revision="a" * 40)
+        result["provenance"]["report_source_tree"] = "b" * 40
+        store.new_attempt(
+            item.cell.cell_id,
+            ArtifactPolicy.REGENERATE,
+        ).publish(result)
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.validate_measurement",
+        lambda *_args, **_kwargs: None,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.validate_policy_measurement",
+        lambda *_args, **_kwargs: PolicyMeasurementState.SUCCESS,
+    )
+
+    planned = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(
+            workers=1,
+            cell_cores=1,
+            target_runtime_seconds=5.0,
+            max_rss_bytes=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+            campaign_policy=MACBOOK_M3_Z_TABLE_F_POLICY,
+            report_profile="macbook_M3",
+            study_contract_sha256="c" * 64,
+            reuse_cross_source_comparison_dependencies=True,
+        ),
+        expected_revision="d" * 40,
+        expected_tree="e" * 40,
+    )
+
+    assert dependency_ids
+    assert tuple(item.cell for item in planned) == (candidate,)
+
+
+def test_z_table_f_preflight_does_not_require_optional_amplicol(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    candidate = REPORT_CATALOG.cell(
+        "z-builtin-sm-n8-dd-z-jets-recurrence-jit-o2-all-flow"
+    )
+    settings = CampaignSettings(
+        workers=1,
+        cell_cores=1,
+        target_runtime_seconds=5.0,
+        max_rss_bytes=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        campaign_policy=MACBOOK_M3_Z_TABLE_F_POLICY,
+        report_profile="macbook_M3",
+        study_contract_sha256="c" * 64,
+    )
+    planned = plan_campaign(
+        (candidate,),
+        store=service.store,
+        settings=settings,
+    )
+    candidate_plan = next(item for item in planned if item.cell == candidate)
+    optional_ids = {
+        dependency_id
+        for dependency_id in (
+            candidate_plan.optional_baseline_cell_id,
+            *candidate_plan.optional_comparison_peer_ids,
+        )
+        if dependency_id is not None
+    }
+    required_ids = {
+        dependency_id
+        for dependency_id in (
+            candidate_plan.baseline_cell_id,
+            *candidate_plan.comparison_peer_ids,
+        )
+        if dependency_id is not None
+    }
+    queried: list[str] = []
+    scheduler = object.__new__(CampaignScheduler)
+    scheduler.settings = settings
+    scheduler.catalog = REPORT_CATALOG
+
+    def current(cell: CellSpec, **_kwargs: object) -> object:
+        queried.append(cell.cell_id)
+        return object()
+
+    monkeypatch.setattr(scheduler, "_current", current)
+
+    scheduler._validate_z_table_f_plan((candidate_plan,))
+
+    assert optional_ids
+    assert set(queried) == required_ids
+    assert set(queried).isdisjoint(optional_ids)
+
+
+def test_missing_only_rejects_stale_report_revision(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    candidate = next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.dataset_id == "matrix_compiled_builtin_sm_lc"
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+    store.new_attempt(candidate.cell_id, ArtifactPolicy.REGENERATE).publish(
+        _ok_measurement(candidate, revision="old")
+    )
+
+    planned = plan_campaign(
+        (candidate,),
+        store=store,
+        settings=CampaignSettings(missing_only=True),
+        expected_revision="new",
+    )
+
+    assert tuple(item.cell for item in planned) == (candidate,)
+
+
+def _matrix_cell(
+    dataset_id: str,
+    *,
+    workload: Workload = Workload.SELECTED_FLOW,
+) -> CellSpec:
+    return next(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.dataset_id == dataset_id
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is workload
+    )
+
+
+def _z_cell(*, variant: str, workload: Workload) -> CellSpec:
+    return next(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.dataset_id == "z_builtin_sm"
+        and cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.variant == variant
+        and cell.workload is workload
+    )
+
+
+def _service(tmp_path: Path) -> ReportService:
+    root = tmp_path / "repo"
+    (root / "src/pyamplicol/_profiling_campaign").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=root, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "report-tests@example.invalid"),
+        cwd=root,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Report Tests"),
+        cwd=root,
+        check=True,
+    )
+    (root / "README.md").write_text("# report fixture\n", encoding="ascii")
+    subprocess.run(("git", "add", "README.md"), cwd=root, check=True)
+    subprocess.run(
+        ("git", "commit", "-q", "-m", "Initialize fixture"),
+        cwd=root,
+        check=True,
+    )
+    return ReportService(
+        ReportPaths.from_repo(
+            root,
+            artifact_root=tmp_path / "artifacts",
+            coordination_root=tmp_path / "locks",
+        )
+    )
+
+
+def _publish_current(
+    store: ArtifactStore,
+    cell: CellSpec,
+    *,
+    revision: str,
+) -> CurrentRecord:
+    return store.new_attempt(cell.cell_id, ArtifactPolicy.REGENERATE).publish(
+        _ok_measurement(cell, revision=revision)
+    )
+
+
+def test_equivalent_reuse_requires_fresh_revision_and_never_uses_amplicol(
+    tmp_path: Path,
+) -> None:
+    store = _store(tmp_path)
+    candidate = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    equivalent = REPORT_CATALOG.equivalent_cells(candidate)[0]
+    stale = _publish_current(store, equivalent, revision="old")
+
+    assert (
+        _fresh_equivalent_current(
+            store,
+            candidate,
+            catalog=REPORT_CATALOG,
+            expected_revision="new",
+        )
+        is None
+    )
+
+    fresh = _publish_current(store, equivalent, revision="new")
+    selected = _fresh_equivalent_current(
+        store,
+        candidate,
+        catalog=REPORT_CATALOG,
+        expected_revision="new",
+    )
+    assert selected is not None
+    assert selected.attempt_id == fresh.attempt_id
+    assert selected.attempt_id != stale.attempt_id
+
+    reference = next(
+        cell
+        for cell in REPORT_CATALOG.reference_cells()
+        if cell.process_key == "dd_z_jets"
+        and cell.n_final == 1
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+    assert (
+        _fresh_equivalent_current(
+            store,
+            reference,
+            catalog=REPORT_CATALOG,
+            expected_revision="new",
+        )
+        is None
+    )
+
+
+def _run_with_captured_worker(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    policy: ArtifactPolicy,
+    rerun: bool = False,
+    target_current: bool = False,
+    madgraph_installation: Path | None = None,
+) -> tuple[list[str], CellOutcome, CurrentRecord, CurrentRecord]:
+    service = _service(tmp_path)
+    target = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    equivalent = REPORT_CATALOG.equivalent_cells(target)[0]
+    baseline = REPORT_CATALOG.baseline_cell(target)
+    assert baseline is not None
+    revision = "current-revision"
+    baseline_record = _publish_current(
+        service.store,
+        baseline,
+        revision=revision,
+    )
+    equivalent_record = _publish_current(
+        service.store,
+        equivalent,
+        revision=revision,
+    )
+    if target_current:
+        _publish_current(
+            service.store,
+            target,
+            revision=revision,
+        )
+    command_seen: list[str] = []
+
+    def fake_supervise(
+        command: Sequence[str],
+        **_kwargs: object,
+    ) -> SupervisedResult:
+        command_seen.extend(command)
+        result_path = Path(command_seen[command_seen.index("--result-json") + 1])
+        result_path.write_text(
+            json.dumps(_ok_measurement(target, revision=revision)) + "\n",
+            encoding="ascii",
+        )
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler._symbolica_generation_lock_path",
+        lambda *_arguments: tmp_path / "generation.lock",
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            artifact_policy=policy,
+            rerun=rerun,
+            target_runtime_seconds=1.0,
+            madgraph_installation=madgraph_installation,
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    scheduler.source_revision = revision
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            target,
+            dependency=False,
+            baseline_cell_id=baseline.cell_id,
+            rank=1,
+        )
+    )
+    return command_seen, outcome, equivalent_record, baseline_record
+
+
+@pytest.mark.parametrize("policy", (ArtifactPolicy.REUSE, ArtifactPolicy.RETIME))
+def test_reuse_and_retime_use_equivalent_artifact_but_target_baseline(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    policy: ArtifactPolicy,
+) -> None:
+    command, outcome, equivalent, baseline = _run_with_captured_worker(
+        tmp_path,
+        monkeypatch,
+        policy=policy,
+    )
+
+    assert outcome.status == "ok"
+    assert command[command.index("--reused-measurement-json") + 1] == str(
+        equivalent.result_path
+    )
+    assert command[command.index("--baseline-json") + 1] == str(baseline.result_path)
+    assert command[command.index("--cell-id") + 1] == (
+        "matrix-recurrence-builtin-sm-lc-n1-dd-z-jets-selected-flow"
+    )
+    assert command[command.index("--docs-dir") + 1].endswith(
+        "/repo/src/pyamplicol/_profiling_campaign"
+    )
+    assert command[command.index("--artifact-root") + 1].endswith("/artifacts")
+    assert command[command.index("--coordination-root") + 1].endswith("/locks")
+    assert "--generation-lock-path" not in command
+
+
+def test_scheduler_propagates_madgraph_installation_to_worker(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    installation = tmp_path / "madgraph"
+    command, outcome, _equivalent, _baseline = _run_with_captured_worker(
+        tmp_path,
+        monkeypatch,
+        policy=ArtifactPolicy.REUSE,
+        madgraph_installation=installation,
+    )
+
+    assert outcome.status == "ok"
+    assert command[command.index("--madgraph") + 1] == str(installation)
+
+
+@pytest.mark.parametrize(
+    ("policy", "rerun", "target_current"),
+    (
+        (ArtifactPolicy.REGENERATE, False, False),
+        (ArtifactPolicy.RETIME, True, True),
+        (ArtifactPolicy.REUSE, True, True),
+    ),
+)
+def test_explicit_regenerate_or_rerun_forces_generation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    policy: ArtifactPolicy,
+    rerun: bool,
+    target_current: bool,
+) -> None:
+    command, outcome, _equivalent, _baseline = _run_with_captured_worker(
+        tmp_path,
+        monkeypatch,
+        policy=policy,
+        rerun=rerun,
+        target_current=target_current,
+    )
+
+    assert outcome.status == "ok"
+    assert "--reused-measurement-json" not in command
+    assert command[command.index("--generation-lock-path") + 1].endswith(
+        "/generation.lock"
+    )
+
+
+def test_scheduler_never_publishes_first_failed_worker_result(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    target = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    baseline = REPORT_CATALOG.baseline_cell(target)
+    assert baseline is not None
+    revision = "current-revision"
+    _publish_current(service.store, baseline, revision=revision)
+
+    def fake_supervise(
+        command: Sequence[str],
+        **_arguments: object,
+    ) -> SupervisedResult:
+        result_path = Path(command[command.index("--result-json") + 1])
+        result_path.write_text(
+            json.dumps(
+                failure_measurement(
+                    ResultStatus.ERROR,
+                    "deterministic worker failure",
+                )
+            )
+            + "\n",
+            encoding="ascii",
+        )
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(artifact_policy=ArtifactPolicy.REGENERATE),
+    )
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    scheduler.source_revision = revision
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            target,
+            dependency=False,
+            baseline_cell_id=baseline.cell_id,
+            rank=1,
+        )
+    )
+
+    assert outcome.status == ResultStatus.ERROR.value
+    assert service.store.load_current(target.cell_id, missing_ok=True) is None
+    attempt_roots = (
+        *(
+            service.paths.artifact_root / "cells"
+        ).glob(f"*/attempts/{outcome.detail}"),
+        *(
+            service.paths.artifact_root / "attempt-history"
+        ).glob(f"*/{outcome.detail}"),
+    )
+    assert len(attempt_roots) == 1
+    manifest = json.loads(
+        (attempt_roots[0] / "manifest.json").read_text(encoding="ascii")
+    )
+    assert manifest["status"] == "failed"
+    assert manifest["result_path"] is None
+    assert not (attempt_roots[0] / "result.json").exists()
+    worker_result = json.loads(
+        (attempt_roots[0] / "worker-result.json").read_text(encoding="ascii")
+    )
+    assert worker_result["status"] == ResultStatus.ERROR.value
+
+
+def test_scheduler_result_rewrite_preserves_actionable_disk_full_error(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    target = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    baseline = REPORT_CATALOG.baseline_cell(target)
+    assert baseline is not None
+    revision = "current-revision"
+    _publish_current(service.store, baseline, revision=revision)
+
+    def fake_supervise(
+        command: Sequence[str],
+        **_arguments: object,
+    ) -> SupervisedResult:
+        result_path = Path(command[command.index("--result-json") + 1])
+        result_path.write_text(
+            json.dumps(_ok_measurement(target, revision=revision)) + "\n",
+            encoding="ascii",
+        )
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    original_write_json = ArtifactAttempt.write_json
+
+    def fail_result_rewrite(
+        attempt: ArtifactAttempt,
+        relative_path: str,
+        payload: Mapping[str, object],
+    ) -> Path:
+        if relative_path == "worker-result.json":
+            raise DiskFullError(
+                f"disk full while writing {attempt.root / relative_path}; "
+                "0 bytes available"
+            )
+        return original_write_json(attempt, relative_path, payload)
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    monkeypatch.setattr(ArtifactAttempt, "write_json", fail_result_rewrite)
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(artifact_policy=ArtifactPolicy.REGENERATE),
+    )
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    scheduler.source_revision = revision
+
+    with pytest.raises(
+        DiskFullError,
+        match=r"disk full while writing .*worker-result.json; 0 bytes available",
+    ):
+        scheduler._run_cell(
+            PlannedCell(
+                target,
+                dependency=False,
+                baseline_cell_id=baseline.cell_id,
+                rank=1,
+            )
+        )
+
+    assert service.store.load_current(target.cell_id, missing_ok=True) is None
+
+
+def test_scheduler_never_publishes_first_skip(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    cell = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    scheduler = CampaignScheduler(service, settings=CampaignSettings())
+
+    outcome = scheduler._publish_skip(
+        cell,
+        "required dependency is unavailable",
+        current=None,
+    )
+
+    assert outcome.status == ResultStatus.SKIP.value
+    assert service.store.load_current(cell.cell_id, missing_ok=True) is None
+    attempt_roots = tuple(
+        (service.paths.artifact_root / "cells").glob(f"*/attempts/{outcome.detail}")
+    )
+    assert len(attempt_roots) == 1
+    manifest = json.loads(
+        (attempt_roots[0] / "manifest.json").read_text(encoding="ascii")
+    )
+    assert manifest["status"] == "failed"
+    assert manifest["result_path"] is None
+
+
+def test_dependency_block_retains_exact_prerequisite_identity(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    cell = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    scheduler = CampaignScheduler(service, settings=CampaignSettings())
+    prerequisite = "reference-amplicol-lc-n1-dd-z-jets-selected-flow"
+
+    outcome = scheduler._publish_blocked_dependency(
+        cell,
+        prerequisite,
+        current=None,
+    )
+
+    assert outcome.status == "blocked_dependency"
+    assert outcome.prerequisite_cell_ids == (prerequisite,)
+    assert outcome.detail == (
+        f"blocked by dependency: required prerequisite {prerequisite!r} is unavailable"
+    )
+    assert service.store.load_current(cell.cell_id, missing_ok=True) is None
+    attempts = tuple((service.store._cell_root(cell.cell_id) / "attempts").iterdir())
+    assert len(attempts) == 1
+    result = json.loads(
+        (attempts[0] / "worker-result.json").read_text(encoding="utf-8")
+    )
+    assert result["blocked_dependency"] == {
+        "prerequisite_cell_ids": [prerequisite]
+    }
+
+
+def test_dag_terminal_direct_peer_blocks_dependent_before_worker_launch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    prerequisite = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    dependent = _matrix_cell("matrix_compiled_builtin_sm_lc")
+    observed: list[Mapping[str, object]] = []
+    launched: list[str] = []
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            workers=1,
+            max_rss_bytes=30_000_000_000,
+            manual_terminal_censors=True,
+            source_identity_override=ReportSourceIdentity(
+                "a" * 40,
+                "b" * 40,
+                (),
+            ),
+            progress_observer=lambda payload: observed.append(dict(payload)),
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    blocked_after_terminal: list[str] = []
+    publish_blocked = scheduler._publish_blocked_dependency
+
+    def assert_prerequisite_is_terminal_before_blocking(
+        cell: CellSpec,
+        prerequisite_cell_ids: str | Sequence[str],
+        *,
+        current: CurrentRecord | None,
+    ) -> CellOutcome:
+        prerequisite_current = service.store.load_current(prerequisite.cell_id)
+        assert prerequisite_current is not None
+        assert prerequisite_current.result["status"] == ResultStatus.MEMORY_LIMIT.value
+        blocked_after_terminal.append(cell.cell_id)
+        return publish_blocked(
+            cell,
+            prerequisite_cell_ids,
+            current=current,
+        )
+
+    monkeypatch.setattr(
+        scheduler,
+        "_publish_blocked_dependency",
+        assert_prerequisite_is_terminal_before_blocking,
+    )
+
+    def fake_supervise(
+        command: Sequence[str],
+        **_arguments: object,
+    ) -> SupervisedResult:
+        cell_id = str(command[command.index("--cell-id") + 1])
+        launched.append(cell_id)
+        if cell_id != prerequisite.cell_id:
+            pytest.fail("dependency-blocked worker was launched")
+        return SupervisedResult(
+            -9,
+            "memory_limit",
+            ResourceUsage(
+                True,
+                30_000_000_001,
+                30_000_000_001,
+                0,
+                0.1,
+                0.2,
+            ),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    planned = (
+        PlannedCell(prerequisite, dependency=True, baseline_cell_id=None, rank=0),
+        PlannedCell(
+            dependent,
+            dependency=False,
+            baseline_cell_id=None,
+            rank=1,
+            comparison_peer_ids=(prerequisite.cell_id,),
+            prerequisite_cell_ids=(prerequisite.cell_id,),
+        ),
+    )
+
+    result = scheduler.run(planned)
+
+    assert launched == [prerequisite.cell_id]
+    outcomes = {outcome.cell_id: outcome for outcome in result.outcomes}
+    assert outcomes[prerequisite.cell_id].status == "memory_limit"
+    blocked = outcomes[dependent.cell_id]
+    assert blocked.status == "blocked_dependency"
+    assert blocked.prerequisite_cell_ids == (prerequisite.cell_id,)
+    assert blocked_after_terminal == [dependent.cell_id]
+    finished = [
+        payload
+        for payload in observed
+        if payload.get("event") == "finished"
+        and payload.get("cell_id") == dependent.cell_id
+    ]
+    assert len(finished) == 1
+    assert finished[0]["prerequisite_cell_ids"] == (prerequisite.cell_id,)
+
+
+def test_scheduler_plumbs_authenticated_generation_only_limit(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    target = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    baseline = REPORT_CATALOG.baseline_cell(target)
+    assert baseline is not None
+    revision = "current-revision"
+    _publish_current(service.store, baseline, revision=revision)
+    captured: dict[str, object] = {}
+
+    def fake_supervise(
+        command: Sequence[str],
+        **arguments: object,
+    ) -> SupervisedResult:
+        captured["command"] = tuple(command)
+        captured.update(arguments)
+        result_path = Path(command[command.index("--result-json") + 1])
+        result_path.write_text(
+            json.dumps(_ok_measurement(target, revision=revision)) + "\n",
+            encoding="ascii",
+        )
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            timeout_seconds=90.0,
+            generation_time_limit_seconds=7200.0,
+            profiling_time_limit_seconds=60.0,
+            validation_time_limit_seconds=30.0,
+            max_rss_bytes=30_000_000_000,
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+    scheduler.source_revision = revision
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            target,
+            dependency=False,
+            baseline_cell_id=baseline.cell_id,
+            rank=1,
+        )
+    )
+
+    assert outcome.status == "ok"
+    assert captured["timeout_seconds"] == 90.0
+    assert captured["generation_timeout_seconds"] == 7200.0
+    assert captured["profiling_timeout_seconds"] == 60.0
+    assert captured["validation_timeout_seconds"] == 30.0
+    channel = captured["phase_channel"]
+    assert isinstance(channel, WorkerPhaseChannel)
+    command = captured["command"]
+    assert isinstance(command, tuple)
+    assert command[command.index("--phase-state-path") + 1] == str(channel.path)
+    assert command[command.index("--phase-state-run-id") + 1] == channel.run_id
+    assert (
+        command[command.index("--phase-state-authentication-key") + 1]
+        == channel.authentication_key
+    )
+    assert command[command.index("--worker-wall-limit") + 1] == "90.0"
+    assert command[command.index("--memory-limit-bytes") + 1] == "30000000000"
+    assert captured["max_rss_bytes"] == 30_000_000_000
+    output_limits = captured["output_file_limits"]
+    assert isinstance(output_limits, Mapping)
+    assert len(output_limits) == 4
+    assert set(output_limits.values()) == {64 * 1024 * 1024}
+    assert Path(command[command.index("--log-path") + 1]) in output_limits
+    assert Path(command[command.index("--progress-jsonl") + 1]) in output_limits
+    assert captured["minimum_free_disk_bytes"] == 5 * 1024 * 1024 * 1024
+    assert captured["disk_probe_path"] == service.paths.artifact_root
+    assert command[command.index("--profiling-time-limit") + 1] == "60.0"
+    assert command[command.index("--validation-time-limit") + 1] == "30.0"
+
+
+def test_scheduler_persists_abrupt_worker_exit_diagnostics_with_empty_worker_log(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cell = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    captured: dict[str, object] = {}
+
+    def crash(
+        command: Sequence[str],
+        **arguments: object,
+    ) -> SupervisedResult:
+        captured.update(arguments)
+        Path(command[command.index("--log-path") + 1]).touch()
+        phase_error = "worker exited before closing generation"
+        return SupervisedResult(
+            -11,
+            "worker_exit",
+            ResourceUsage(True, 0, 1234, 0, 0.2, 0.3),
+            generation_phase=GenerationPhaseEvidence(
+                configured_timeout_seconds=3600.0,
+                supervisor_reason="worker_exit",
+                authenticated=False,
+                run_id="phase-run-7",
+                worker_pid=4321,
+                final_sequence=1,
+                final_phase="generation",
+                generation_started_monotonic_ns=10,
+                generation_finished_monotonic_ns=None,
+                generation_elapsed_seconds=0.3,
+                final_state_sha256="c" * 64,
+                error=phase_error,
+            ),
+            pid=4321,
+            member_pids=(4321, 4322),
+            signal_number=11,
+            signal_name="SIGSEGV",
+            supervisor_stderr="native evaluator abort\n",
+            supervisor_stderr_limit_bytes=65536,
+            phase_state_error=phase_error,
+            started_at_utc="2026-08-02T00:00:00+00:00",
+            finished_at_utc="2026-08-02T00:00:01+00:00",
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        crash,
+    )
+    source_revision = "a" * 40
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            source_identity_override=ReportSourceIdentity(
+                source_revision,
+                "b" * 40,
+                (),
+            ),
+            campaign_invocation_id="manual-invocation-7",
+            remove_heavy_attempt_artifacts=False,
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+
+    outcome = scheduler._run_cell(
+        PlannedCell(cell, dependency=False, baseline_cell_id=None, rank=0)
+    )
+
+    assert outcome.status == "error"
+    assert captured["capture_stderr"] is True
+    attempt_roots = tuple(
+        (service.paths.artifact_root / "cells").glob(f"*/attempts/{outcome.detail}")
+    )
+    assert len(attempt_roots) == 1
+    attempt_root = attempt_roots[0]
+    assert (attempt_root / "worker.log").read_bytes() == b""
+    result = json.loads(
+        (attempt_root / "worker-result.json").read_text(encoding="ascii")
+    )
+    assert result["status"] == "error"
+    assert result["failure"] == {
+        "kind": "WorkerProcessExitError",
+        "message": "worker terminated by SIGSEGV (signal 11, return code -11)",
+    }
+    supervisor = result["resources"]["supervisor"]
+    assert supervisor == {
+        "abi": "pyamplicol-report-worker-supervisor-v1",
+        "campaign_invocation_id": "manual-invocation-7",
+        "finished_at_utc": "2026-08-02T00:00:01+00:00",
+        "member_pids": [4321, 4322],
+        "phase": "generation",
+        "phase_state_error": "worker exited before closing generation",
+        "pid": 4321,
+        "reason": "worker_exit",
+        "returncode": -11,
+        "signal_name": "SIGSEGV",
+        "signal_number": 11,
+        "source_revision": source_revision,
+        "started_at_utc": "2026-08-02T00:00:00+00:00",
+        "stderr": "native evaluator abort\n",
+        "stderr_limit_bytes": 65536,
+        "stderr_truncated": False,
+        "teardown_escalated": False,
+        "teardown_seconds": 0.0,
+    }
+    assert result["provenance"]["report_source_revision"] == source_revision
+
+
+def test_scheduler_persists_and_forwards_exact_phase_state_failure(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cell = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    phase_error = (
+        "worker phase-state transition timestamp is outside the supervised "
+        "process lifetime"
+    )
+
+    def invalid_phase(
+        command: Sequence[str],
+        **_arguments: object,
+    ) -> SupervisedResult:
+        Path(command[command.index("--log-path") + 1]).touch()
+        return SupervisedResult(
+            -15,
+            "phase_state_error",
+            ResourceUsage(True, 0, 1234, 0, 0.2, 0.3),
+            pid=4321,
+            member_pids=(4321,),
+            phase_state_error=phase_error,
+    )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        invalid_phase,
+    )
+    events: list[dict[str, object]] = []
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            source_identity_override=ReportSourceIdentity(
+                "a" * 40,
+                "b" * 40,
+                (),
+            ),
+            progress_observer=lambda payload: events.append(dict(payload)),
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+
+    outcome = scheduler._run_cell(
+        PlannedCell(cell, dependency=False, baseline_cell_id=None, rank=0)
+    )
+
+    assert outcome.status == ResultStatus.ERROR.value
+    assert outcome.terminal_detail == phase_error
+    attempt_roots = (
+        *(
+            service.paths.artifact_root / "cells"
+        ).glob(f"*/attempts/{outcome.detail}"),
+        *(
+            service.paths.artifact_root / "attempt-history"
+        ).glob(f"*/{outcome.detail}"),
+    )
+    assert len(attempt_roots) == 1
+    result = json.loads(
+        (attempt_roots[0] / "worker-result.json").read_text(encoding="ascii")
+    )
+    assert result["failure"]["message"] == phase_error
+    assert result["resources"]["supervisor"]["reason"] == "phase_state_error"
+    assert result["resources"]["supervisor"]["phase_state_error"] == phase_error
+    finished = [event for event in events if event["event"] == "finished"]
+    assert len(finished) == 1
+    assert finished[0]["terminal_detail"] == phase_error
+
+
+def test_prepared_model_worker_exit_persists_structured_failed_attempt(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    cell = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    source_revision = "a" * 40
+    phase_error = "worker exited before closing preparation"
+    supervised = SupervisedResult(
+        -6,
+        "worker_exit",
+        ResourceUsage(True, 0, 2048, 1, 0.4, 0.5),
+        pid=7654,
+        member_pids=(7654, 7655),
+        signal_number=6,
+        signal_name="SIGABRT",
+        supervisor_stderr="native model compiler abort\n",
+        supervisor_stderr_limit_bytes=65536,
+        phase_state_error=phase_error,
+        started_at_utc="2026-08-02T01:00:00+00:00",
+        finished_at_utc="2026-08-02T01:00:01+00:00",
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            source_identity_override=ReportSourceIdentity(
+                source_revision,
+                "b" * 40,
+                (),
+            ),
+            campaign_invocation_id="manual-preflight-9",
+        ),
+    )
+
+    outcome = scheduler._preparation_failure_outcome(
+        cell,
+        _PreparationFailed(
+            ModelKey.BUILTIN_SM,
+            "worker_exit",
+            "prepared-model worker aborted",
+            supervised,
+        ),
+    )
+
+    assert outcome.status == "error"
+    attempt_roots = tuple(
+        (service.paths.artifact_root / "cells").glob(f"*/attempts/{outcome.detail}")
+    )
+    assert len(attempt_roots) == 1
+    attempt_root = attempt_roots[0]
+    result = json.loads(
+        (attempt_root / "worker-result.json").read_text(encoding="ascii")
+    )
+    assert result["status"] == "error"
+    assert result["failure"] == {
+        "kind": "WorkerProcessExitError",
+        "message": "worker terminated by SIGABRT (signal 6, return code -6)",
+    }
+    assert result["resources"]["supervisor"] == {
+        "abi": "pyamplicol-report-worker-supervisor-v1",
+        "campaign_invocation_id": "manual-preflight-9",
+        "finished_at_utc": "2026-08-02T01:00:01+00:00",
+        "member_pids": [7654, 7655],
+        "phase": "preparation",
+        "phase_state_error": phase_error,
+        "pid": 7654,
+        "reason": "worker_exit",
+        "returncode": -6,
+        "signal_name": "SIGABRT",
+        "signal_number": 6,
+        "source_revision": source_revision,
+        "started_at_utc": "2026-08-02T01:00:00+00:00",
+        "stderr": "native model compiler abort\n",
+        "stderr_limit_bytes": 65536,
+        "stderr_truncated": False,
+        "teardown_escalated": False,
+        "teardown_seconds": 0.0,
+    }
+    assert result["provenance"]["report_source_revision"] == source_revision
+    manifest = json.loads((attempt_root / "manifest.json").read_text(encoding="utf-8"))
+    assert manifest["status"] == "failed"
+    assert [record["path"] for record in manifest["artifacts"]] == [
+        "worker-result.json"
+    ]
+
+
+@pytest.mark.parametrize(
+    ("reason", "state", "kind", "label"),
+    (
+        ("generation_timeout", "generation_limit", "generation_limit", ">7s"),
+        ("worker_timeout", "worker_timeout", "worker_timeout", "worker >11s"),
+        (
+            "profiling_timeout",
+            "profiling_timeout",
+            "profiling_timeout",
+            "profile >5s",
+        ),
+        (
+            "validation_timeout",
+            "validation_timeout",
+            "validation_timeout",
+            "validation >3s",
+        ),
+    ),
+)
+def test_manual_stage_timeout_is_published_as_distinct_addressed_current(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    reason: str,
+    state: str,
+    kind: str,
+    label: str,
+) -> None:
+    service = _service(tmp_path)
+    cell = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        lambda _command, **_arguments: SupervisedResult(
+            -15,
+            reason,
+            ResourceUsage(True, 0, 1, 0, 0.1, 11.0),
+        ),
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            timeout_seconds=11.0,
+            generation_time_limit_seconds=7.0,
+            profiling_time_limit_seconds=5.0,
+            validation_time_limit_seconds=3.0,
+            manual_terminal_censors=True,
+            source_identity_override=ReportSourceIdentity(
+                "a" * 40,
+                "b" * 40,
+                (),
+            ),
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+
+    outcome = scheduler._run_cell(
+        PlannedCell(cell, dependency=False, baseline_cell_id=None, rank=0)
+    )
+
+    assert outcome.status == state
+    assert not CampaignResult((PlannedCell(cell, False, None, 0),), (outcome,)).failed
+    current = service.store.load_current(cell.cell_id)
+    assert current is not None
+    assert current.result["status"] == ResultStatus.TIMEOUT.value
+    assert current.result["resources"]["terminal_reason"] == reason
+    assert current.result["provenance"]["policy_censor"]["kind"] == kind
+    assert policy_status_label(current.result) == label
+    resolved = scheduler._current(cell)
+    assert resolved is not None
+    assert resolved[1].value == state
+    for timing in (
+        "generation_seconds",
+        "wall_seconds_per_point",
+        "execution_seconds_per_point",
+        "sample_count",
+    ):
+        assert current.result[timing] is None
+
+
+def test_manual_clean_child_profiling_timeout_keeps_typed_reason(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cell = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+
+    class ProfilingTimeLimitError(RuntimeError):
+        pass
+
+    def fake_supervise(
+        command: Sequence[str],
+        **_arguments: object,
+    ) -> SupervisedResult:
+        result_path = Path(command[command.index("--result-json") + 1])
+        result = failure_measurement(
+            ResultStatus.TIMEOUT,
+            ProfilingTimeLimitError("profiling budget exhausted"),
+            resources={"terminal_reason": "profiling_timeout"},
+        )
+        result_path.write_text(json.dumps(result) + "\n", encoding="ascii")
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 0, 1, 0, 0.1, 5.0),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            timeout_seconds=11.0,
+            generation_time_limit_seconds=7.0,
+            profiling_time_limit_seconds=5.0,
+            validation_time_limit_seconds=3.0,
+            manual_terminal_censors=True,
+            source_identity_override=ReportSourceIdentity(
+                "a" * 40,
+                "b" * 40,
+                (),
+            ),
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_prepare_model_for", lambda _planned: None)
+
+    outcome = scheduler._run_cell(
+        PlannedCell(cell, dependency=False, baseline_cell_id=None, rank=0)
+    )
+
+    assert outcome.status == PolicyMeasurementState.PROFILING_TIMEOUT.value
+    current = service.store.load_current(cell.cell_id)
+    assert current is not None
+    assert current.result["failure"]["kind"] == "ProfilingTimeLimitError"
+    assert current.result["resources"]["terminal_reason"] == "profiling_timeout"
+
+
+def test_campaign_run_never_publishes_or_renders(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    target = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    scheduler = CampaignScheduler(service, settings=CampaignSettings())
+    planned = (
+        PlannedCell(
+            target,
+            dependency=False,
+            baseline_cell_id=None,
+            rank=0,
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_ensure_prepared_model", lambda _items: None)
+    monkeypatch.setattr(
+        scheduler,
+        "_run_cell",
+        lambda item: CellOutcome(item.cell.cell_id, "ok", "complete"),
+    )
+    monkeypatch.setattr(
+        service,
+        "publish",
+        lambda **_kwargs: pytest.fail("measurement waited on report publication"),
+    )
+
+    result = scheduler.run(planned)
+
+    assert result.failed == ()
+    assert result.outcomes[0].cell_id == target.cell_id
+
+
+def test_shared_model_preparation_does_not_hold_independent_ready_cell(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(workers=2),
+    )
+    recurrence = PlannedCell(
+        _matrix_cell("matrix_recurrence_builtin_sm_lc"),
+        dependency=False,
+        baseline_cell_id=None,
+        rank=0,
+    )
+    scalar = PlannedCell(
+        REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted"),
+        dependency=False,
+        baseline_cell_id=None,
+        rank=0,
+    )
+    preparation_started = threading.Event()
+    independent_started = threading.Event()
+
+    def prepare(_items: Sequence[PlannedCell]) -> None:
+        preparation_started.set()
+        assert independent_started.wait(timeout=1.0)
+        scheduler._prepared_model_paths[ModelKey.BUILTIN_SM] = (
+            tmp_path / "prepared-model.bin"
+        )
+
+    def run_cell(item: PlannedCell) -> CellOutcome:
+        if item.cell.cell_id == recurrence.cell.cell_id:
+            scheduler._prepare_model_for(item)
+        else:
+            assert preparation_started.wait(timeout=1.0)
+            independent_started.set()
+        return CellOutcome(item.cell.cell_id, "ok", "complete")
+
+    monkeypatch.setattr(scheduler, "_ensure_prepared_model", prepare)
+    monkeypatch.setattr(scheduler, "_run_cell", run_cell)
+
+    result = scheduler.run((recurrence, scalar))
+
+    assert {outcome.cell_id for outcome in result.outcomes} == {
+        recurrence.cell.cell_id,
+        scalar.cell.cell_id,
+    }
+
+
+def test_failed_shared_model_preparation_is_memoized(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    scheduler = CampaignScheduler(_service(tmp_path), settings=CampaignSettings())
+    planned = PlannedCell(
+        _matrix_cell("matrix_recurrence_builtin_sm_lc"),
+        dependency=False,
+        baseline_cell_id=None,
+        rank=0,
+    )
+    calls = 0
+    failure = _PreparationFailed(
+        ModelKey.BUILTIN_SM,
+        "worker_timeout",
+        "prepared model timed out",
+    )
+
+    def fail(_items: Sequence[PlannedCell]) -> None:
+        nonlocal calls
+        calls += 1
+        raise failure
+
+    monkeypatch.setattr(scheduler, "_ensure_prepared_model", fail)
+
+    with pytest.raises(_PreparationFailed):
+        scheduler._prepare_model_for(planned)
+    with pytest.raises(_PreparationFailed):
+        scheduler._prepare_model_for(planned)
+
+    assert calls == 1
+
+
+def test_preparation_failure_is_handled_while_cell_lock_is_held(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    scheduler = CampaignScheduler(service, settings=CampaignSettings())
+    cell = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    planned = PlannedCell(
+        cell,
+        dependency=False,
+        baseline_cell_id=None,
+        rank=0,
+    )
+    held: set[str] = set()
+
+    class Lock:
+        def __init__(self, name: str) -> None:
+            self.name = name
+
+        def __enter__(self) -> None:
+            held.add(self.name)
+
+        def __exit__(self, *_arguments: object) -> None:
+            held.remove(self.name)
+
+    monkeypatch.setattr(
+        service.store,
+        "named_lock",
+        lambda name, **_kwargs: Lock(name),
+    )
+
+    def fail(_planned: PlannedCell) -> None:
+        raise _PreparationFailed(
+            ModelKey.BUILTIN_SM,
+            "error",
+            "preparation failed",
+        )
+
+    monkeypatch.setattr(scheduler, "_prepare_model_for", fail)
+
+    def handle(
+        _cell: CellSpec,
+        _failure: _PreparationFailed,
+    ) -> CellOutcome:
+        assert f"campaign-cell-{cell.cell_id}" in held
+        return CellOutcome(cell.cell_id, "preparation_error", "handled")
+
+    monkeypatch.setattr(scheduler, "_preparation_failure_outcome", handle)
+
+    outcome = scheduler._run_cell(planned)
+
+    assert outcome.status == "preparation_error"
+    assert held == set()
+
+
+@pytest.mark.parametrize(
+    ("worker_limit", "generation_limit", "expected_reason"),
+    (
+        (11.0, 7.0, "generation_timeout"),
+        (5.0, 7.0, "worker_timeout"),
+    ),
+)
+def test_preparation_timeout_keeps_the_effective_limit_identity(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    worker_limit: float,
+    generation_limit: float,
+    expected_reason: str,
+) -> None:
+    scheduler = CampaignScheduler(
+        _service(tmp_path),
+        settings=CampaignSettings(
+            timeout_seconds=worker_limit,
+            generation_time_limit_seconds=generation_limit,
+        ),
+    )
+    planned = PlannedCell(
+        _matrix_cell("matrix_recurrence_builtin_sm_lc"),
+        dependency=False,
+        baseline_cell_id=None,
+        rank=0,
+    )
+    captured: dict[str, object] = {}
+
+    def timeout(_command: Sequence[str], **arguments: object) -> SupervisedResult:
+        captured.update(arguments)
+        return SupervisedResult(
+            -15,
+            "worker_timeout",
+            ResourceUsage(True, 0, 1, 0, 0.1, min(worker_limit, generation_limit)),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        timeout,
+    )
+
+    with pytest.raises(_PreparationFailed) as raised:
+        scheduler._ensure_prepared_model((planned,))
+
+    assert raised.value.reason == expected_reason
+    assert captured["timeout_seconds"] == min(worker_limit, generation_limit)
+
+
+def test_manual_preparation_wall_timeout_is_generation_terminal(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cell = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    supervised = SupervisedResult(
+        -15,
+        "worker_timeout",
+        ResourceUsage(True, 0, 1, 0, 0.1, 7.0),
+    )
+    failure = _PreparationFailed(
+        ModelKey.BUILTIN_SM,
+        "generation_timeout",
+        "prepared model timed out",
+        supervised,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            timeout_seconds=11.0,
+            generation_time_limit_seconds=7.0,
+            profiling_time_limit_seconds=5.0,
+            validation_time_limit_seconds=3.0,
+            manual_terminal_censors=True,
+            source_identity_override=ReportSourceIdentity(
+                "a" * 40,
+                "b" * 40,
+                (),
+            ),
+        ),
+    )
+
+    def fail(_planned: PlannedCell) -> None:
+        raise failure
+
+    monkeypatch.setattr(scheduler, "_prepare_model_for", fail)
+
+    outcome = scheduler._run_cell(
+        PlannedCell(cell, dependency=False, baseline_cell_id=None, rank=0)
+    )
+
+    assert outcome.status == PolicyMeasurementState.GENERATION_LIMIT.value
+    current = service.store.load_current(cell.cell_id)
+    assert current is not None
+    assert current.result["resources"]["terminal_reason"] == "generation_timeout"
+
+
+def test_ready_queue_admits_later_rank_while_an_earlier_cell_is_still_running(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cells = tuple(
+        sorted(
+            (
+                REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted"),
+                REPORT_CATALOG.cell("scalar-gravity-n2-scalar-gravity-contracted"),
+                REPORT_CATALOG.cell("scalar-contact-n3-scalar-contact-contracted"),
+            ),
+            key=lambda cell: cell.cell_id,
+        )
+    )
+    slow, quick, later = cells
+    release_slow = threading.Event()
+    later_started = threading.Event()
+    failures: list[BaseException] = []
+    results: list[object] = []
+
+    scheduler = CampaignScheduler(service, settings=CampaignSettings(workers=2))
+    monkeypatch.setattr(scheduler, "_ensure_prepared_model", lambda _items: None)
+
+    def run_cell(item: PlannedCell) -> CellOutcome:
+        if item.cell == slow:
+            assert release_slow.wait(2.0)
+        elif item.cell == later:
+            later_started.set()
+        return CellOutcome(item.cell.cell_id, "ok", "complete")
+
+    monkeypatch.setattr(scheduler, "_run_cell", run_cell)
+    planned = (
+        PlannedCell(slow, False, None, 0),
+        PlannedCell(quick, False, None, 0),
+        PlannedCell(later, False, None, 4),
+    )
+
+    def run() -> None:
+        try:
+            results.append(scheduler.run(planned))
+        except BaseException as error:  # pragma: no cover - asserted below.
+            failures.append(error)
+
+    thread = threading.Thread(target=run)
+    thread.start()
+    assert later_started.wait(1.0), "later ready work remained behind a rank wave"
+    release_slow.set()
+    thread.join(2.0)
+
+    assert not thread.is_alive()
+    assert failures == []
+    assert len(results) == 1
+
+
+def test_ready_queue_releases_dependents_without_waiting_for_unrelated_work(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    prerequisite = REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted")
+    unrelated = REPORT_CATALOG.cell("scalar-gravity-n2-scalar-gravity-contracted")
+    dependent = REPORT_CATALOG.cell("scalar-contact-n3-scalar-contact-contracted")
+    release_unrelated = threading.Event()
+    dependent_started = threading.Event()
+    failures: list[BaseException] = []
+
+    scheduler = CampaignScheduler(service, settings=CampaignSettings(workers=2))
+    monkeypatch.setattr(scheduler, "_ensure_prepared_model", lambda _items: None)
+
+    def run_cell(item: PlannedCell) -> CellOutcome:
+        if item.cell == unrelated:
+            assert release_unrelated.wait(2.0)
+        elif item.cell == dependent:
+            dependent_started.set()
+        return CellOutcome(item.cell.cell_id, "ok", "complete")
+
+    monkeypatch.setattr(scheduler, "_run_cell", run_cell)
+    planned = (
+        PlannedCell(prerequisite, False, None, 0),
+        PlannedCell(unrelated, False, None, 0),
+        PlannedCell(
+            dependent,
+            False,
+            None,
+            3,
+            prerequisite_cell_ids=(prerequisite.cell_id,),
+        ),
+    )
+
+    def run() -> None:
+        try:
+            scheduler.run(planned)
+        except BaseException as error:  # pragma: no cover - asserted below.
+            failures.append(error)
+
+    thread = threading.Thread(target=run)
+    thread.start()
+    assert dependent_started.wait(1.0)
+    release_unrelated.set()
+    thread.join(2.0)
+
+    assert not thread.is_alive()
+    assert failures == []
+
+
+def test_busy_cell_lock_is_deferred_without_consuming_the_only_worker_slot(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    cells = tuple(
+        sorted(
+            (
+                REPORT_CATALOG.cell("scalar-contact-n2-scalar-contact-contracted"),
+                REPORT_CATALOG.cell("scalar-gravity-n2-scalar-gravity-contracted"),
+            ),
+            key=lambda cell: cell.cell_id,
+        )
+    )
+    locked, available = cells
+    available_finished = threading.Event()
+    observed: list[str] = []
+    progress_events: list[Mapping[str, object]] = []
+    failures: list[BaseException] = []
+
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            workers=1,
+            progress_observer=lambda payload: progress_events.append(dict(payload)),
+        ),
+    )
+    monkeypatch.setattr(scheduler, "_ensure_prepared_model", lambda _items: None)
+
+    def run_in_lane(item: PlannedCell) -> CellOutcome:
+        observed.append(item.cell.cell_id)
+        if item.cell == available:
+            available_finished.set()
+        return CellOutcome(item.cell.cell_id, "ok", "complete")
+
+    monkeypatch.setattr(scheduler, "_run_cell_in_lane", run_in_lane)
+    planned = (
+        PlannedCell(locked, False, None, 0),
+        PlannedCell(available, False, None, 0),
+    )
+
+    def run() -> None:
+        try:
+            scheduler.run(planned)
+        except BaseException as error:  # pragma: no cover - asserted below.
+            failures.append(error)
+
+    with service.store.named_lock(f"campaign-cell-{locked.cell_id}"):
+        thread = threading.Thread(target=run)
+        thread.start()
+        assert available_finished.wait(1.0)
+    thread.join(2.0)
+
+    assert not thread.is_alive()
+    assert failures == []
+    assert observed == [available.cell_id, locked.cell_id]
+    assert not any(
+        payload.get("event") == "finished"
+        and payload.get("cell_id") == locked.cell_id
+        and payload.get("status") == "error"
+        for payload in progress_events
+    )
+
+
+def test_busy_equivalent_owner_lock_does_not_block_independent_ready_work(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    target = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    equivalent = REPORT_CATALOG.equivalent_cells(target)[0]
+    baseline = REPORT_CATALOG.baseline_cell(target)
+    assert baseline is not None
+    independent = REPORT_CATALOG.cell(
+        "matrix-recurrence-builtin-sm-nlc-n1-dd-z-jets-contracted"
+    )
+    revision = "current-revision"
+    owner = _publish_current(service.store, equivalent, revision=revision)
+    _publish_current(service.store, baseline, revision=revision)
+    _publish_current(service.store, independent, revision=revision)
+    independent_finished = threading.Event()
+    failures: list[BaseException] = []
+    results: list[CampaignResult] = []
+
+    def observe(payload: Mapping[str, object]) -> None:
+        if (
+            payload.get("event") == "finished"
+            and payload.get("cell_id") == independent.cell_id
+        ):
+            independent_finished.set()
+
+    def fake_supervise(
+        command: Sequence[str],
+        **_arguments: object,
+    ) -> SupervisedResult:
+        result_path = Path(command[command.index("--result-json") + 1])
+        result_path.write_text(
+            json.dumps(_ok_measurement(target, revision=revision)) + "\n",
+            encoding="ascii",
+        )
+        return SupervisedResult(
+            0,
+            "completed",
+            ResourceUsage(True, 1, 1, 0, 0.1, 0.1),
+        )
+
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        fake_supervise,
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(
+            workers=1,
+            artifact_policy=ArtifactPolicy.REUSE,
+            progress_observer=observe,
+        ),
+    )
+    scheduler.source_revision = revision
+    planned = (
+        PlannedCell(target, False, baseline.cell_id, 0),
+        PlannedCell(independent, False, None, 1),
+    )
+
+    def run() -> None:
+        try:
+            results.append(scheduler.run(planned))
+        except BaseException as error:  # pragma: no cover - asserted below.
+            failures.append(error)
+
+    with service.store.named_lock(f"campaign-artifact-use-{owner.attempt_id}"):
+        thread = threading.Thread(target=run)
+        thread.start()
+        assert independent_finished.wait(1.0)
+    thread.join(2.0)
+
+    assert not thread.is_alive()
+    assert failures == []
+    assert len(results) == 1
+    assert {outcome.cell_id for outcome in results[0].outcomes} == {
+        target.cell_id,
+        independent.cell_id,
+    }
+
+
+def test_ufo_compiled_cells_overlap_outside_the_worker_side_compiler_gate(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(workers=2),
+    )
+    ufo_compiled = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.measurement.model is ModelKey.UFO_SM
+        and cell.measurement.execution_mode is ExecutionMode.COMPILED
+    )[:2]
+    assert len(ufo_compiled) == 2
+    generating = threading.Event()
+    profiling = threading.Event()
+
+    def run_in_lane(item: PlannedCell) -> CellOutcome:
+        if item.cell == ufo_compiled[0]:
+            generating.set()
+            assert profiling.wait(1.0)
+        else:
+            assert generating.wait(1.0)
+            profiling.set()
+        return CellOutcome(item.cell.cell_id, "ok", "complete")
+
+    monkeypatch.setattr(scheduler, "_run_cell_in_lane", run_in_lane)
+    result = scheduler.run(
+        tuple(PlannedCell(cell, False, None, 0) for cell in ufo_compiled)
+    )
+
+    assert generating.is_set() and profiling.is_set()
+    assert not result.failed
+
+    # A reusable cell does not touch the worker-side compiler gate at all.
+    monkeypatch.setattr(
+        scheduler,
+        "_run_cell_in_lane",
+        lambda item: CellOutcome(item.cell.cell_id, "reused", "current"),
+    )
+    with service.store.named_lock("campaign-symbolica-compiled-capacity-1"):
+        outcome = scheduler._run_cell(PlannedCell(ufo_compiled[0], False, None, 0))
+
+    assert outcome.status == "reused"
+    assert "campaign-symbolica-compiled-capacity-1" not in (
+        scheduler._coordination_lock_names(ufo_compiled[0])
+    )
+
+
+def test_plan_campaign_builds_a_real_resource_predecessor_chain(
+    tmp_path: Path,
+) -> None:
+    lane = tuple(
+        sorted(
+            (
+                cell
+                for cell in REPORT_CATALOG.measurement_cells()
+                if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+                and cell.measurement.accuracy is Accuracy.LC
+                and cell.workload is Workload.SELECTED_FLOW
+                and cell.process_key == "dd_z_jets"
+                and cell.n_final in {1, 2, 3}
+            ),
+            key=lambda cell: cell.n_final,
+        )
+    )
+    assert tuple(cell.n_final for cell in lane) == (1, 2, 3)
+    settings = CampaignSettings(
+        campaign_policy=X86_EPYC_POLICY,
+        report_profile=X86_EPYC_PROFILE,
+        workers=X86_EPYC_WORKERS,
+        max_rss_bytes=X86_EPYC_MEMORY_LIMIT_BYTES,
+        allow_symbolica_parallel=True,
+    )
+    planned = plan_campaign(
+        lane,
+        store=_store(tmp_path),
+        settings=settings,
+    )
+    by_id = {item.cell.cell_id: item for item in planned}
+
+    assert by_id[lane[0].cell_id].resource_predecessor_ids == ()
+    assert by_id[lane[1].cell_id].resource_predecessor_ids == (lane[0].cell_id,)
+    assert by_id[lane[2].cell_id].resource_predecessor_ids == (lane[1].cell_id,)
+
+
+def test_same_model_preparation_lock_contention_is_deferred(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    scheduler = CampaignScheduler(_service(tmp_path), settings=CampaignSettings())
+    planned = PlannedCell(
+        _matrix_cell("matrix_recurrence_builtin_sm_lc"),
+        dependency=False,
+        baseline_cell_id=None,
+        rank=0,
+    )
+    started = threading.Event()
+    release = threading.Event()
+    failures: list[BaseException] = []
+
+    def prepare(_items: Sequence[PlannedCell]) -> None:
+        started.set()
+        assert release.wait(2.0)
+
+    monkeypatch.setattr(scheduler, "_ensure_prepared_model", prepare)
+
+    def first() -> None:
+        try:
+            scheduler._prepare_model_for(planned)
+        except BaseException as error:  # pragma: no cover - asserted below.
+            failures.append(error)
+
+    thread = threading.Thread(target=first)
+    thread.start()
+    assert started.wait(1.0)
+    with pytest.raises(_CoordinationDeferred):
+        scheduler._prepare_model_for(planned)
+    release.set()
+    thread.join(2.0)
+
+    assert not thread.is_alive()
+    assert failures == []
+
+
+def test_successful_current_resume_never_duplicates_post_populate_cell(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    target = _matrix_cell("matrix_recurrence_builtin_sm_lc")
+    baseline = REPORT_CATALOG.baseline_cell(target)
+    assert baseline is not None
+    revision = "measured-revision"
+    _publish_current(service.store, baseline, revision=revision)
+    published = _publish_current(service.store, target, revision=revision)
+    monkeypatch.setattr(
+        "tools.performance_report.scheduler.supervise_worker",
+        lambda *_args, **_kwargs: pytest.fail(
+            "authenticated post-populate current must not be rerun"
+        ),
+    )
+    scheduler = CampaignScheduler(
+        service,
+        settings=CampaignSettings(missing_only=True),
+    )
+    scheduler.source_revision = revision
+
+    outcome = scheduler._run_cell(
+        PlannedCell(
+            target,
+            dependency=False,
+            baseline_cell_id=baseline.cell_id,
+            rank=1,
+        )
+    )
+
+    current = service.store.load_current(target.cell_id)
+    assert outcome.status == "skipped-current"
+    assert outcome.detail == "already complete"
+    assert current.attempt_id == published.attempt_id
+
+
+@pytest.mark.parametrize("limit", (0.0, float("inf"), float("nan")))
+def test_campaign_rejects_invalid_generation_only_limit(limit: float) -> None:
+    with pytest.raises(ValueError, match="generation_time_limit_seconds"):
+        CampaignSettings(generation_time_limit_seconds=limit)
diff --git a/pyamplicol/tests/unit/test_three_mode_report_service.py b/pyamplicol/tests/unit/test_three_mode_report_service.py
new file mode 100644
index 0000000000..943260d94f
--- /dev/null
+++ b/pyamplicol/tests/unit/test_three_mode_report_service.py
@@ -0,0 +1,461 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import errno
+import hashlib
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from tools.performance_report.agreements import DIRECT_AGREEMENT_FIELD
+from tools.performance_report.cache import digest_json, empty_measurement, reset_entry
+from tools.performance_report.catalog import (
+    MADGRAPH_FULL_COMPARISON_VIEWS,
+    REPORT_CATALOG,
+)
+from tools.performance_report.measurement import failure_measurement
+from tools.performance_report.models import ArtifactPolicy, ResultStatus
+from tools.performance_report.publication import publication_absolute_paths
+from tools.performance_report.render import render_all_tables
+from tools.performance_report.runner import pointwise_validation
+from tools.performance_report.service import (
+    ReportPaths,
+    ReportService,
+    ReportServiceError,
+)
+from tools.performance_report.source_identity import require_eligible_report_source
+
+
+def _service(tmp_path: Path) -> ReportService:
+    repo = tmp_path / "repo"
+    (repo / "docs/arxiv/results").mkdir(parents=True)
+    subprocess.run(("git", "init", "-q"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "config", "user.email", "report-tests@example.invalid"),
+        cwd=repo,
+        check=True,
+    )
+    subprocess.run(
+        ("git", "config", "user.name", "Report Tests"),
+        cwd=repo,
+        check=True,
+    )
+    (repo / "README.md").write_text("# report fixture\n", encoding="ascii")
+    subprocess.run(("git", "add", "README.md"), cwd=repo, check=True)
+    subprocess.run(
+        ("git", "commit", "-q", "-m", "Initialize fixture"),
+        cwd=repo,
+        check=True,
+    )
+    return ReportService(
+        ReportPaths.from_repo(
+            repo,
+            artifact_root=tmp_path / "artifacts",
+        )
+    )
+
+
+def test_reset_publishes_only_canonical_na_caches_and_twenty_seven_tables(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+
+    paths = service.publish(reset=True, merge_artifacts=False)
+    result = service.validate()
+
+    assert result["table_count"] == 27
+    assert result["statuses"] == {
+        "not_available": len(REPORT_CATALOG.measurement_cells())
+    }
+    assert len([path for path in paths if path.suffix == ".tex"]) == 27
+    assert all(
+        (service.paths.docs_dir / view.table_name).is_file()
+        for view in MADGRAPH_FULL_COMPARISON_VIEWS
+    )
+    assert not (
+        service.paths.docs_dir / "result_matrix_compiled_ufo_sm_full_table.tex"
+    ).exists()
+    assert (service.paths.results_dir / "report-cache.schema.json").is_file()
+
+
+def test_static_na_cache_rejects_terminal_measurement(tmp_path: Path) -> None:
+    service = _service(tmp_path)
+    caches = service.reset_payloads()
+    cell = service.catalog.cell(
+        "reference-amplicol-full-n6-dd-4q-lines-contracted"
+    )
+    payload = caches[f"{cell.dataset_id}.json"]
+    entry = next(
+        item for item in payload["entries"] if item["cell_id"] == cell.cell_id
+    )
+    entry["measurement"] = failure_measurement(
+        ResultStatus.UNSUPPORTED,
+        "historical oracle scope",
+    )
+
+    with pytest.raises(
+        ReportServiceError,
+        match="catalog static N/A cache entry",
+    ):
+        service.validate_payloads(caches)
+
+
+def test_static_na_current_never_merges_into_publication_cache(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    cell = service.catalog.cell(
+        "reference-amplicol-full-n6-dd-4q-lines-contracted"
+    )
+    source = require_eligible_report_source(service.paths.repo_root)
+    measurement = failure_measurement(
+        ResultStatus.UNSUPPORTED,
+        "historical oracle scope",
+    )
+    measurement["provenance"] = {
+        "report_source_revision": source.revision,
+        "report_source_tree": source.tree,
+    }
+    published = service.store.new_attempt(
+        cell.cell_id,
+        ArtifactPolicy.REGENERATE,
+    ).publish(measurement)
+    caches = service.reset_payloads()
+    payload = caches[f"{cell.dataset_id}.json"]
+    entry = next(
+        item for item in payload["entries"] if item["cell_id"] == cell.cell_id
+    )
+    entry["measurement"] = failure_measurement(
+        ResultStatus.UNSUPPORTED,
+        "noncanonical cached terminal",
+    )
+
+    assert service.merge_current(caches) == 0
+    assert entry["measurement"] == reset_entry(cell)["measurement"]
+    assert service.store.load_current(cell.cell_id).attempt_id == published.attempt_id
+
+
+def test_merge_joins_immutable_current_record_by_cell_id(tmp_path: Path) -> None:
+    service = _service(tmp_path)
+    service.publish(reset=True, merge_artifacts=False)
+    source = require_eligible_report_source(service.paths.repo_root)
+    cell = next(
+        item
+        for item in service.catalog.measurement_cells()
+        if item.measurement.accuracy.value != "lc"
+    )
+    observations = [
+        {
+            "module": "pyamplicol",
+            "kind": "package-member",
+            "root_index": 0,
+            "path": "__init__.py",
+            "size": 1,
+            "sha256": "1" * 64,
+        }
+    ]
+    loaded_origin_policy = {
+        "kind": "pyamplicol-loaded-module-origin-policy-v1",
+        "all_loaded_origins_authenticated": True,
+        "native_image_origin_bound": True,
+        "loaded_bytecode_eligible": False,
+        "observed_module_count": 1,
+        "observations": observations,
+        "observations_sha256": hashlib.sha256(
+            json.dumps(
+                observations,
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            ).encode("ascii")
+        ).hexdigest(),
+    }
+    runtime_identity = {
+        "extension": {
+            "path": str(service.paths.repo_root / "native/_rusticol.so"),
+        },
+        "loaded_module_origin_policy": loaded_origin_policy,
+    }
+    runtime_identity_sha256 = hashlib.sha256(
+        json.dumps(
+            runtime_identity,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+    stable_runtime_identity = json.loads(json.dumps(runtime_identity))
+    stable_policy = stable_runtime_identity["loaded_module_origin_policy"]
+    for field in (
+        "observed_module_count",
+        "observations",
+        "observations_sha256",
+    ):
+        stable_policy.pop(field)
+    runtime_identity_stable_sha256 = hashlib.sha256(
+        json.dumps(
+            stable_runtime_identity,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": "ok",
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 2.0,
+            "execution_seconds_per_point": None,
+            "matrix_element": 3.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 0.0,
+            "relative_standard_error": 0.0,
+            "artifact": {
+                "path": str(service.paths.artifact_root / "cells/example/artifact"),
+                "log_path": str(
+                    service.paths.artifact_root / "cells/example/worker.log"
+                ),
+            },
+            "selector_contract": None,
+            "validation": {"status": "ok", DIRECT_AGREEMENT_FIELD: []},
+            "resources": {},
+            "provenance": {
+                "report_source_revision": source.revision,
+                "report_source_tree": source.tree,
+                "effective_config": {
+                    "model": {
+                        "cache_dir": str(service.paths.repo_root / ".cache/model"),
+                    }
+                },
+                "runtime_identity": runtime_identity,
+                "runtime_identity_sha256": runtime_identity_sha256,
+                "runtime_identity_stable_sha256": (
+                    runtime_identity_stable_sha256
+                ),
+                "runtime_identity_postflight_stable_sha256": (
+                    runtime_identity_stable_sha256
+                ),
+                "runtime_identity_postflight_loaded_module_origin_policy": (
+                    loaded_origin_policy
+                ),
+                "runtime_identity_postflight_match": True,
+            },
+        }
+    )
+    service.store.new_attempt(cell.cell_id, ArtifactPolicy.REGENERATE).publish(
+        measurement
+    )
+
+    service.publish()
+    cache_path = service.paths.results_dir / f"{cell.dataset_id}.json"
+    payload = json.loads(cache_path.read_text(encoding="ascii"))
+    entry = next(item for item in payload["entries"] if item["cell_id"] == cell.cell_id)
+    assert entry["measurement"]["matrix_element"] == 3.0
+    publication = entry["measurement"]
+    assert publication["artifact"]["path"].startswith(
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/"
+    )
+    assert publication["artifact"]["log_path"].startswith(
+        "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}/"
+    )
+    assert publication["provenance"]["effective_config"]["model"][
+        "cache_dir"
+    ].startswith("${PYAMPLICOL_SOURCE_ROOT}/")
+    assert publication["provenance"]["runtime_identity"] == runtime_identity
+    retained_identity = publication["provenance"]["runtime_identity"]
+    assert (
+        hashlib.sha256(
+            json.dumps(
+                retained_identity,
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            ).encode("ascii")
+        ).hexdigest()
+        == publication["provenance"]["runtime_identity_sha256"]
+    )
+    assert publication_absolute_paths(payload) == ()
+
+
+def test_failed_snapshot_publication_restores_previous_files(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    service.publish(reset=True, merge_artifacts=False)
+    table = service.paths.docs_dir / "result_scalar_contact_table.tex"
+    cache = service.paths.results_dir / "scalar_contact.json"
+    old_table = table.read_bytes()
+    old_cache = cache.read_bytes()
+
+    original_replace = Path.replace
+    original_copy2 = shutil.copy2
+    calls = 0
+    staging_sources: list[Path] = []
+
+    def observe_staging_copy(source: Path, destination: Path) -> Path:
+        if ".report-snapshot-" in str(source):
+            staging_sources.append(source)
+        return original_copy2(source, destination)
+
+    def fail_after_one_replace(source: Path, destination: Path) -> Path:
+        nonlocal calls
+        if ".report-install-" in source.name:
+            calls += 1
+            if calls == 3:
+                raise OSError("injected publication interruption")
+        return original_replace(source, destination)
+
+    monkeypatch.setattr(shutil, "copy2", observe_staging_copy)
+    monkeypatch.setattr(Path, "replace", fail_after_one_replace)
+    with pytest.raises(OSError, match="injected"):
+        service.publish(reset=True, merge_artifacts=False)
+
+    assert table.read_bytes() == old_table
+    assert cache.read_bytes() == old_cache
+    assert staging_sources
+    assert all(
+        source.is_relative_to(service.paths.artifact_root)
+        for source in staging_sources
+    )
+    assert not tuple(service.paths.docs_dir.glob(".report-snapshot-*"))
+    snapshot_root = service.paths.artifact_root / "report-snapshot-builds"
+    assert snapshot_root.is_dir()
+    assert not tuple(snapshot_root.iterdir())
+    assert not tuple(service.paths.docs_dir.glob(".*.report-*-*"))
+    assert not tuple(service.paths.results_dir.glob(".*.report-*-*"))
+
+
+def test_snapshot_install_remains_atomic_across_artifact_filesystems(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = _service(tmp_path)
+    service.publish(reset=True, merge_artifacts=False)
+    original_replace = Path.replace
+    installs: list[tuple[Path, Path]] = []
+
+    def reject_cross_directory_replace(source: Path, destination: Path) -> Path:
+        if source.parent != destination.parent:
+            raise OSError(errno.EXDEV, "injected cross-device replacement")
+        installs.append((source, destination))
+        return original_replace(source, destination)
+
+    monkeypatch.setattr(Path, "replace", reject_cross_directory_replace)
+    written = service.publish(reset=True, merge_artifacts=False)
+
+    assert written
+    assert installs
+    assert all(source.parent == destination.parent for source, destination in installs)
+    assert not tuple(service.paths.docs_dir.glob(".*.report-*-*"))
+    assert not tuple(service.paths.results_dir.glob(".*.report-*-*"))
+
+
+def test_audit_rejects_nonpublication_timing_and_source_evidence(
+    tmp_path: Path,
+) -> None:
+    service = _service(tmp_path)
+    caches = service.reset_payloads()
+    payload = caches["scalar_contact.json"]
+    entry = payload["entries"][0]
+    cell = service.catalog.cell(str(entry["cell_id"]))
+    point_digest = "a" * 64
+    ordering = "b" * 64
+
+    def resolved(precision: int, source: str) -> dict[str, object]:
+        point = pointwise_validation(
+            3.0,
+            3.0,
+            candidate_scale=3.0,
+            baseline_scale=3.0,
+            comparison_binding={
+                "abi": "pyamplicol-report-resolved-component-scale-v1",
+                "point_digest": point_digest,
+                "helicity_ids": [],
+                "color_flow_ids": [],
+                "resolved_ordering_sha256": ordering,
+                "resolved_source_sha256": source,
+                "point_index": 0,
+            },
+        )
+        return {
+            "abi": "pyamplicol-report-resolved-sum-validation-v2",
+            "status": "ok",
+            "maximum_absolute_difference": 0.0,
+            "maximum_relative_difference": 0.0,
+            "maximum_conditioned_residual": 0.0,
+            "relative_tolerance": 1.0e-12,
+            "point_digest": point_digest,
+            "helicity_ids": [],
+            "color_flow_ids": [],
+            "resolved_ordering_sha256": ordering,
+            "resolved_source_sha256": source,
+            "scale_source": "resolved-component-l1",
+            "precision_digits": precision,
+            "points": [point],
+        }
+
+    binary64 = resolved(16, "c" * 64)
+    precision32 = resolved(32, "d" * 64)
+    selector_identity = {
+        "cell_id": cell.cell_id,
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+        "selector_contract": None,
+        "value_kind": "matrix-element-p16-versus-p32",
+    }
+    measurement = empty_measurement()
+    measurement.update(
+        {
+            "status": "ok",
+            "generation_seconds": 1.0,
+            "wall_seconds_per_point": 2.0e-6,
+            "execution_seconds_per_point": 1.0e-6,
+            "matrix_element": 3.0,
+            "sample_count": 5,
+            "standard_error_seconds_per_point": 1.0e-9,
+            "relative_standard_error": 1.0e-3,
+            "artifact": {},
+            "selector_contract": None,
+            "validation": {
+                "status": "ok",
+                DIRECT_AGREEMENT_FIELD: [],
+                "resolved_sum": binary64,
+                "high_precision_resolved_sum": precision32,
+                "high_precision": pointwise_validation(
+                    3.0,
+                    3.0,
+                    candidate_scale=3.0,
+                    baseline_scale=3.0,
+                    candidate_scale_source="resolved-component-l1-binary64",
+                    baseline_scale_source="resolved-component-l1-p32",
+                    comparison_binding={
+                        "point_digest": point_digest,
+                        "selector_component_identity": selector_identity,
+                        "selector_component_sha256": digest_json(selector_identity),
+                        "candidate_source_sha256": "c" * 64,
+                        "baseline_source_sha256": "d" * 64,
+                    },
+                ),
+            },
+            "resources": {},
+            "provenance": {},
+            "failure": None,
+        }
+    )
+    entry["measurement"] = measurement
+    service._snapshot_files(
+        caches,
+        render_all_tables(caches, catalog=service.catalog),
+    )
+
+    with pytest.raises(ReportServiceError, match="publication policy"):
+        service.audit()
diff --git a/pyamplicol/tests/unit/test_tracked_reference_fixture_v2.py b/pyamplicol/tests/unit/test_tracked_reference_fixture_v2.py
new file mode 100644
index 0000000000..8b6a691fa1
--- /dev/null
+++ b/pyamplicol/tests/unit/test_tracked_reference_fixture_v2.py
@@ -0,0 +1,76 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from tools.developer.reference_fixture import ReferenceFixture, load_reference_fixture
+
+REFERENCE_ROOT = Path(__file__).resolve().parents[1] / "fixtures" / "reference"
+
+
+def _tracked_fixture() -> ReferenceFixture:
+    return load_reference_fixture(
+        REFERENCE_ROOT / "physics-v2.json",
+        (
+            REFERENCE_ROOT / "legacy-fortran-v2.json",
+            REFERENCE_ROOT / "analytic-oracles-v2.json",
+        ),
+    )
+
+
+def test_tracked_reference_bundle_is_complete_and_revision_bound() -> None:
+    fixture = _tracked_fixture()
+    sm_processes = {
+        "sm_ddbar_z",
+        "sm_udbar_wplus",
+        "sm_ddbar_zg",
+        "sm_ddbar_ee",
+        "sm_ddbar_uubar",
+        "sm_ddbar_ddbar",
+        "sm_gg_gg",
+        "sm_gg_ttbar",
+        "sm_ddbar_zgg",
+    }
+    expected_cases = {
+        *(
+            f"case:{process}:{accuracy}"
+            for process in sm_processes
+            for accuracy in ("lc", "nlc", "full")
+        ),
+        "case:scalars_2to2:lc",
+        "case:scalar_gravity_2to2:lc",
+    }
+
+    assert fixture.provenance.working_tree_clean
+    assert fixture.provenance.memory_watchdog_gb == 30
+    assert re.fullmatch(r"[0-9a-f]{40}", fixture.provenance.source_revision)
+    candidate = next(
+        dependency
+        for dependency in fixture.dependencies
+        if dependency.id == "dependency:pyamplicol-candidate"
+    )
+    assert candidate.revision == fixture.provenance.source_revision
+    assert {case.id for case in fixture.cases} == expected_cases
+    assert {evidence.id for evidence in fixture.evidence_sets} == {
+        "evidence-set:legacy-fortran-amplicol",
+        "evidence-set:analytic-oracles",
+    }
+
+    for case in fixture.cases:
+        assert tuple(
+            observation.point_id for observation in case.observations
+        ) == case.point_ids
+        assert all(observation.evidence_refs for observation in case.observations)
+
+
+def test_tracked_stress_points_retain_high_precision_inputs() -> None:
+    fixture = _tracked_fixture()
+    stress_points = tuple(
+        point for point in fixture.points if point.point_class == "stress"
+    )
+
+    assert stress_points
+    assert all(point.arithmetic_precision_bits >= 256 for point in stress_points)
+    assert all(point.certified_decimal_digits >= 80 for point in stress_points)
+    assert all(point.stress_metric is not None for point in stress_points)
diff --git a/pyamplicol/tests/unit/test_umami_example_environment.py b/pyamplicol/tests/unit/test_umami_example_environment.py
new file mode 100644
index 0000000000..1fe7f1e4f2
--- /dev/null
+++ b/pyamplicol/tests/unit/test_umami_example_environment.py
@@ -0,0 +1,244 @@
+# SPDX-License-Identifier: 0BSD
+"""Exercise example preflights without native or optional integration packages."""
+
+from __future__ import annotations
+
+import builtins
+import importlib.util
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+EXAMPLE = Path(__file__).resolve().parents[2] / "umami_example"
+
+
+@pytest.fixture
+def example_modules(monkeypatch):
+    def load(name, filename):
+        spec = importlib.util.spec_from_file_location(name, EXAMPLE / filename)
+        module = importlib.util.module_from_spec(spec)
+        monkeypatch.setitem(sys.modules, name, module)
+        spec.loader.exec_module(module)
+        return module
+
+    metadata = load("_metadata", "_metadata.py")
+    runner = load("_umami_example_run", "run.py")
+    return metadata, runner
+
+
+def install_exporter(monkeypatch, path, *, legacy=False):
+    """Model the imported package, not pytest's repository source path."""
+    package = ModuleType("pyamplicol")
+    package.__path__ = [str(path.parents[1])]
+    artifacts = ModuleType("pyamplicol.artifacts")
+    artifacts.__path__ = [str(path.parent)]
+    exporter = ModuleType("pyamplicol.artifacts.umami")
+    exporter.__file__ = str(path)
+
+    def old_exporter(*, processes, compiled_model, grouping="exact"):
+        raise AssertionError("preflight must not generate metadata")
+
+    def current_exporter(*, processes, compiled_model):
+        raise AssertionError("preflight must not generate metadata")
+
+    exporter.build_umami_metadata = old_exporter if legacy else current_exporter
+    package.artifacts = artifacts
+    artifacts.umami = exporter
+    for module in (package, artifacts, exporter):
+        monkeypatch.setitem(sys.modules, module.__name__, module)
+    return exporter
+
+
+def metadata_document(*, physical=24, exported=4):
+    entries = [
+        {"members": [{} for _ in range(physical // exported)]} for _ in range(exported)
+    ]
+    return {
+        "provider": {
+            "id": "lc",
+            "incoming_count": 2,
+            "color_accuracy": "lc",
+            "library": "libumami.so",
+        },
+        "channels": [
+            {"processes": entries[:2]},
+            {"processes": entries[2:3]},
+            {"processes": entries[3:]},
+        ],
+        "grouping": {
+            "physical_contributions": physical,
+            "exported_contributions": exported,
+        },
+    }
+
+
+def write_metadata(path, data):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data))
+    return path
+
+
+def forbid_expensive_work(monkeypatch, runner):
+    def forbidden(*args, **kwargs):
+        pytest.fail("preflight must finish before dependencies, generation or build")
+
+    monkeypatch.setattr(runner, "generate", forbidden)
+    monkeypatch.setattr(runner, "execute", forbidden)
+    monkeypatch.setattr(runner.shutil, "which", forbidden)
+    original_import = builtins.__import__
+
+    def import_without_optional(name, *args, **kwargs):
+        if name.split(".", 1)[0] in {"madspace", "madnis", "vegas", "torch"}:
+            forbidden()
+        return original_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", import_without_optional)
+
+
+def test_current_exporter_returns_the_imported_path(
+    example_modules, monkeypatch, tmp_path
+):
+    metadata, _ = example_modules
+    installed = tmp_path / "site-packages/pyamplicol/artifacts/umami.py"
+    install_exporter(monkeypatch, installed)
+
+    assert metadata.require_current_exporter() == installed.resolve()
+
+
+def test_stale_exporter_stops_runner_before_generation(
+    example_modules, monkeypatch, tmp_path
+):
+    _, runner = example_modules
+    installed = tmp_path / "site-packages/pyamplicol/artifacts/umami.py"
+    install_exporter(monkeypatch, installed, legacy=True)
+    output = tmp_path / "output"
+    monkeypatch.setattr(sys, "argv", ["run.py", "--output", str(output)])
+    forbid_expensive_work(monkeypatch, runner)
+
+    with pytest.raises(RuntimeError) as error:
+        runner.main()
+
+    message = str(error.value)
+    assert str(installed) in message
+    assert sys.executable in message
+    assert "reinstall" in message.lower()
+    assert "--output" in message
+    assert "--reuse" in message
+    assert not output.exists()
+
+
+@pytest.mark.parametrize("physical", [4, 24])
+def test_current_metadata_accepts_uncompressed_and_grouped_contributions(
+    example_modules, tmp_path, physical
+):
+    metadata, _ = example_modules
+    data = metadata_document(physical=physical)
+    path = write_metadata(tmp_path / "metadata.json", data)
+
+    assert metadata.load_metadata(path) == data
+    assert metadata.grouping_summary(data) == (
+        "3 integration channels, 4 representative contributions, "
+        f"{physical} physical contributions"
+    )
+
+
+def test_current_restricted_metadata_does_not_require_a_grouping_reduction(
+    example_modules, tmp_path
+):
+    metadata, _ = example_modules
+    data = metadata_document(physical=1, exported=1)
+    data["channels"] = data["channels"][:1]
+    path = write_metadata(tmp_path / "metadata.json", data)
+
+    assert metadata.load_metadata(path) == data
+
+
+@pytest.mark.parametrize(
+    "grouping",
+    [
+        None,
+        {},
+        {"physical_contributions": 24},
+        {"exported_contributions": 4},
+        {"mode": "exact", "physical_contributions": 24, "exported_contributions": 24},
+    ],
+)
+def test_legacy_metadata_is_rejected_with_recovery_instructions(
+    example_modules, tmp_path, grouping
+):
+    metadata, _ = example_modules
+    data = metadata_document()
+    if grouping is None:
+        del data["grouping"]
+    else:
+        data["grouping"] = grouping
+    path = write_metadata(tmp_path / "metadata.json", data)
+
+    with pytest.raises(ValueError) as error:
+        metadata.load_metadata(path)
+
+    message = str(error.value)
+    assert str(path) in message
+    assert "reinstall" in message.lower()
+    assert "--output" in message
+    assert "--reuse" in message
+
+
+def test_reuse_rejects_legacy_metadata_before_optional_dependencies_or_build(
+    example_modules, monkeypatch, tmp_path
+):
+    _, runner = example_modules
+    install_exporter(monkeypatch, tmp_path / "installed/pyamplicol/artifacts/umami.py")
+    data = metadata_document()
+    data["grouping"]["mode"] = "exact"
+    path = write_metadata(tmp_path / "output/lc/API/umami/metadata.json", data)
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        ["run.py", "--output", str(tmp_path / "output"), "--reuse", "--accuracy", "lc"],
+    )
+    forbid_expensive_work(monkeypatch, runner)
+
+    with pytest.raises(ValueError, match=r"metadata\.json"):
+        runner.main()
+
+    assert json.loads(path.read_text()) == data
+
+
+def test_script_detects_the_installed_exporter_from_an_unrelated_working_directory(
+    tmp_path,
+):
+    """The real script entry point must not depend on pytest's src path injection."""
+    site = tmp_path / "site-packages"
+    package = site / "pyamplicol"
+    artifacts = package / "artifacts"
+    artifacts.mkdir(parents=True)
+    (package / "__init__.py").write_text("")
+    (artifacts / "__init__.py").write_text("")
+    exporter = artifacts / "umami.py"
+    exporter.write_text(
+        "def build_umami_metadata(*, processes, compiled_model, grouping='exact'):\n"
+        "    raise AssertionError('generation must not start')\n"
+    )
+    output = tmp_path / "output"
+    result = subprocess.run(
+        [sys.executable, "-S", str(EXAMPLE / "run.py"), "--output", str(output)],
+        cwd=tmp_path,
+        env={**os.environ, "PYTHONPATH": str(site)},
+        capture_output=True,
+        text=True,
+        timeout=10,
+    )
+
+    assert result.returncode != 0
+    assert str(exporter) in result.stderr
+    assert sys.executable in result.stderr
+    assert "reinstall" in result.stderr.lower()
+    assert "--reuse" in result.stderr
+    assert "ModuleNotFoundError" not in result.stderr
+    assert not output.exists()
diff --git a/pyamplicol/tests/unit/test_umami_example_grouping.py b/pyamplicol/tests/unit/test_umami_example_grouping.py
new file mode 100644
index 0000000000..6d86be31b0
--- /dev/null
+++ b/pyamplicol/tests/unit/test_umami_example_grouping.py
@@ -0,0 +1,112 @@
+# SPDX-License-Identifier: 0BSD
+"""Check example bookkeeping without installing optional integration packages."""
+
+from __future__ import annotations
+
+import ast
+import math
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture(scope="module")
+def helpers():
+    directory = Path(__file__).resolve().parents[2] / "umami_example"
+    namespace = {
+        "__name__": __name__,
+        "dataclass": dataclass,
+        "field": field,
+        "math": math,
+        "Path": Path,
+    }
+    for filename, names in (
+        ("test_integrate.py", {"Channel", "Config", "Cuts", "build_ms_cuts"}),
+        ("test_grouping.py", {"physical_member_channels", "check_agreement"}),
+    ):
+        path = directory / filename
+        definitions = [
+            node
+            for node in ast.parse(path.read_text(), filename=str(path)).body
+            if isinstance(node, (ast.ClassDef, ast.FunctionDef)) and node.name in names
+        ]
+        assert len(definitions) == len(names)
+        exec(
+            compile(
+                ast.Module(body=definitions, type_ignores=[]),
+                str(path),
+                "exec",
+                dont_inherit=True,
+            ),
+            namespace,
+        )
+    return namespace
+
+
+def test_member_channels_compose_maps_and_keep_physical_weights(helpers):
+    representative = [0, 1, 4, 2, 3]
+    member_map = [0, 1, 3, 2, 4]
+    pdgs = [1, -1, 21, 21, 21]
+    member = {
+        "runtime": {"permutation": member_map},
+        "pdgs": pdgs,
+        "factor": 0.5,
+    }
+    entry = {
+        "runtime": {"permutation": representative},
+        "matrix_elements": [{"factor": 17.0}],
+        "members": [member, {**member, "factor": 1.0}],
+    }
+    data = {
+        "provider": {"particle_count": 5, "masses": [0.0] * 5},
+        "channels": [
+            {"processes": []},
+            {
+                "phasespace_order": [0, 2, 1, 3, 4],
+                "processes": [entry, {**entry, "members": [member]}],
+            },
+        ],
+    }
+    channels = helpers["physical_member_channels"](data)
+    assert [ch.index for ch in channels] == [0, 1, 2]
+    assert [ch.selector for ch in channels] == [(1, 0), (1, 0), (1, 1)]
+    assert [ch.processes[0][0][0] for ch in channels] == [0.5, 1.0, 0.5]
+    for channel in channels:
+        permutation = channel.momentum_permutation
+        assert permutation == [0, 1, 2, 4, 3]
+        assert [permutation[i] for i in representative] == member_map
+        assert permutation[:2] == [0, 1]
+        assert channel.color_order == [0, 2, 1, 4, 3]
+        assert channel.init_states == [(1, -1)]
+        assert channel.pdg_final == pdgs[2:]
+
+
+@pytest.mark.parametrize(
+    ("value", "error", "failure"),
+    [
+        (10.02, 0.1, None),
+        (12.0, 0.1, "differ"),
+        (10.0, 0.6, "inconclusive"),
+        (math.nan, 0.1, "positive finite"),
+        (10.0, 0.0, "positive finite"),
+    ],
+)
+def test_integral_agreement(helpers, value, error, failure):
+    results = {
+        "grouped": {"integral": value, "uncertainty": error},
+        "physical_members": {"integral": 10.0, "uncertainty": 0.1},
+    }
+    if failure:
+        with pytest.raises(AssertionError, match=failure):
+            helpers["check_agreement"](results)
+    else:
+        comparison = helpers["check_agreement"](results)
+        assert comparison["combined_error"] == pytest.approx(math.hypot(error, 0.1))
+        assert comparison["standard_errors"] < 6.0
+
+
+def test_species_selective_cuts_are_rejected(helpers):
+    cfg = helpers["Config"](cuts=helpers["Cuts"](pdgs=[21]))
+    with pytest.raises(ValueError, match="flavour-blind"):
+        helpers["build_ms_cuts"](cfg, None)
diff --git a/pyamplicol/tests/unit/test_umami_metadata.py b/pyamplicol/tests/unit/test_umami_metadata.py
new file mode 100644
index 0000000000..4a6dad5681
--- /dev/null
+++ b/pyamplicol/tests/unit/test_umami_metadata.py
@@ -0,0 +1,935 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import copy
+import json
+from dataclasses import replace
+from fractions import Fraction
+from itertools import permutations
+from types import SimpleNamespace
+
+import pytest
+
+from pyamplicol.artifacts.umami import (
+    FLAVOR_BLIND_ASSUMPTION,
+    UmamiProcessInput,
+    build_umami_metadata,
+    umami_bundle_payloads,
+)
+from pyamplicol.artifacts.umami_otf import (
+    build_umami_on_the_fly_physics,
+    restore_umami_on_the_fly_input,
+)
+from pyamplicol.generation.process_grouping import (
+    GroupingBasis,
+    GroupingProcess,
+    GroupMember,
+    ProcessGroupMap,
+)
+from pyamplicol.processes.ir import (
+    CanonicalProcessIR,
+    ColorEndpointSummary,
+    ProcessLegIR,
+)
+
+
+def model():
+    # Deliberately non-SM particle/parameter names and PDGs.
+    return {
+        "ir": {
+            "particles": [
+                {"pdg_code": 990, "color": 8, "mass": "ZERO"},
+                {"pdg_code": 991, "color": 3, "mass": "ZERO"},
+                {"pdg_code": -991, "color": -3, "mass": "ZERO"},
+                {"pdg_code": 992, "color": 3, "mass": "ZERO"},
+                {"pdg_code": -992, "color": -3, "mass": "ZERO"},
+                {"pdg_code": 995, "color": 1, "mass": "mass_s"},
+            ],
+            "parameters": [
+                {
+                    "name": "strong_input",
+                    "nature": "external",
+                    "parameter_type": "real",
+                    "lhablock": "SMINPUTS",
+                    "lhacode": [3],
+                    "value": [0.12, 0],
+                },
+                {"name": "mass_s", "nature": "external", "value": [7, 0]},
+            ],
+        },
+        "parameter_defaults": {"strong_input": [0.12, 0], "mass_s": [7, 0]},
+    }
+
+
+def process(
+    identifier="p", pdgs=(990, 990, 990, 990), accuracy="lc", words=((1, 2, 3, 4),)
+):
+    helicities = [
+        {
+            "id": "h:all-plus",
+            "values": [1] * len(pdgs),
+            "representative_id": "h:all-plus",
+            "coefficient": 1,
+            "structural_zero": False,
+        }
+    ]
+    colors = [
+        {
+            "id": "flow:" + ",".join(map(str, word)),
+            "word": list(word),
+            "representative_id": "flow:" + ",".join(map(str, word)),
+            "coefficient": 1,
+        }
+        for word in words
+    ]
+    if accuracy != "lc":
+        colors = [{"id": "color:contracted", "kind": "contracted-color"}]
+    physics = {
+        "external_particles": [
+            {
+                "pdg": pdg,
+                "label": i + 1,
+                "index": i,
+                "role": "initial" if i < 2 else "final",
+            }
+            for i, pdg in enumerate(pdgs)
+        ],
+        "helicities": helicities,
+        "color_components": colors,
+        "coverage": {
+            "helicities": "selected",
+            "color": "complete" if accuracy == "lc" else "contracted",
+        },
+        "model_parameters": [
+            {
+                "name": "strong_input",
+                "kind": "external",
+                "default_real": 0.12,
+                "default_imaginary": 0,
+                "mutable": True,
+            }
+        ],
+        "extensions": {},
+    }
+    return UmamiProcessInput(identifier, identifier, accuracy, tuple(pdgs), physics)
+
+
+def export(*processes, compiled_model=None):
+    return build_umami_metadata(
+        processes=processes, compiled_model=compiled_model or model()
+    )
+
+
+def entries(document):
+    return [p for channel in document["channels"] for p in channel["processes"]]
+
+
+def with_replay():
+    p = process(words=((1, 2, 3, 4), (1, 2, 4, 3)))
+    sectors = (
+        {"id": 0, "kind": "single-trace", "word_labels": [1, 2, 3, 4]},
+        {"id": 1, "kind": "single-trace", "word_labels": [1, 2, 4, 3]},
+    )
+    p.physics["extensions"]["lc_topology_replay"] = {
+        "partitions": [
+            {
+                "representative_sector_id": 0,
+                "active_sector_ids": [0, 1],
+                "label_permutations": [
+                    [[1, 1], [2, 2], [3, 3], [4, 4]],
+                    [[1, 1], [2, 2], [3, 4], [4, 3]],
+                ],
+                "replay_weights": [
+                    2,
+                    2,
+                ],  # Folded runtime weights are not physical-flow multiplicities.
+                "proof": {"status": "proven"},
+            }
+        ]
+    }
+    return replace(p, color_sectors=sectors)
+
+
+def test_generic_gluon_tables_have_physical_pdgs_and_complete_permutations():
+    (data,) = export(process())
+    assert data["pdg_ids"] == [[990, 990, 990, 990]]
+    assert data["provider"]["masses"] == [0] * 4
+    assert data["provider"]["alpha_s_parameter"] == "strong_input"
+    assert data["provider"]["supports_alpha_s"]
+    assert sorted(data["channels"][0]["phasespace_order"]) == list(range(4))
+    assert data["color_flows"][0] == [[504, 501], [501, 502], [503, 502], [504, 503]]
+    assert entries(data)[0]["matrix_elements"] == [{"pdg_ids": 0, "factor": 1}]
+    assert data["grouping"] == {
+        "assumptions": [
+            "identical-final-particle permutation-invariant observables and cuts",
+            "final-state flavour-blind observables and cuts",
+        ],
+        "physical_contributions": 1,
+        "exported_contributions": 1,
+    }
+
+
+def test_quark_chain_and_singlet_derive_from_model_not_particle_names():
+    (data,) = export(process(pdgs=(991, -991, 995, 990), words=((2, 4, 1),)))
+    assert data["provider"]["masses"] == [0, 0, 7, 0]
+    assert data["color_flows"] == [[[502, 0], [0, 501], [0, 0], [502, 501]]]
+    assert data["color_orders"] == [[1, 3, 0, 2]]
+
+
+def test_two_quark_pairs_use_supplied_sector_lines():
+    p = process(pdgs=(991, -991, 992, -992, 990), words=((2, 5, 4, 3, 1),))
+    sector = {
+        "id": 0,
+        "kind": "open-lines",
+        "word_labels": [2, 5, 4, 3, 1],
+        "open_color_lines": [
+            {"fundamental_label": 3, "adjoint_labels": [], "antifundamental_label": 1},
+            {"fundamental_label": 2, "adjoint_labels": [5], "antifundamental_label": 4},
+        ],
+    }
+    (data,) = export(replace(p, color_sectors=(sector,)))
+    assert data["color_flows"] == [[[501, 0], [0, 502], [501, 0], [0, 503], [503, 502]]]
+    sector["open_color_lines"][0]["antifundamental_label"] = 4
+    with pytest.raises(ValueError, match="cover"):
+        export(replace(p, color_sectors=(sector,)))
+
+
+@pytest.mark.parametrize("accuracy", ["nlc", "full"])
+def test_contracted_color_has_no_fake_flows(accuracy):
+    (data,) = export(process(accuracy=accuracy))
+    assert data["color_flows"] == []
+    assert entries(data)[0]["color_flows"] is None
+    assert entries(data)[0]["runtime"]["color_id"] is None
+    payloads = umami_bundle_payloads(
+        processes=[process(accuracy=accuracy)], compiled_model=model()
+    )
+    header = next(p for p in payloads if p.path.endswith("provider_p0.h"))
+    assert b"#define UMAMI_HAS_COLOR_FLOW 0" in header.content
+
+
+def test_fixed_metadata_and_overlapping_selections_split_providers():
+    docs = export(
+        process("a"),
+        process("b"),
+        process("c", accuracy="full"),
+        process("d", pdgs=(991, -991, 995, 990), words=((2, 4, 1),)),
+    )
+    assert len(docs) == 4
+    payloads = {
+        p.path: p
+        for p in umami_bundle_payloads(
+            processes=[process("a"), process("b")], compiled_model=model()
+        )
+    }
+    index = json.loads(payloads["API/umami/metadata.json"].content)
+    assert index["kind"] == "pyamplicol-umami-provider-index"
+    assert len(index["providers"]) == 2
+    assert b"UMAMI_SINGLE_PROVIDER := 0" in payloads["API/umami/providers.mk"].content
+
+
+def test_permuted_duplicate_final_states_are_not_summed_in_one_provider():
+    a = process("a", pdgs=(990, 990, 991, -991), words=((3, 1, 2, 4),))
+    b = process("b", pdgs=(990, 990, -991, 991), words=((4, 1, 2, 3),))
+    assert len(export(a, b)) == 2
+
+
+def test_distinct_restricted_helicity_domains_require_separate_providers():
+    a = process("a", pdgs=(991, -991, 990, 990), words=((2, 3, 4, 1),))
+    b = process("b", pdgs=(992, -992, 990, 990), words=((2, 3, 4, 1),))
+    b.physics["helicities"][0]["values"] = [-1, 1, 1, 1]
+    assert len(export(a, b)) == 2
+
+
+def test_groups_identical_legs_and_preserves_physical_runtime_mappings():
+    (data,) = export(with_replay())
+    (row,) = entries(data)
+    assert row["runtime"]["factor"] == 1
+    assert row["runtime"]["color_id"] == "flow:1,2,3,4"
+    assert row["runtime"]["permutation"] == [0, 1, 2, 3]
+    assert row["matrix_elements"] == [{"pdg_ids": 0, "factor": 2}]
+    assert len(row["members"]) == 2
+    assert row["members"][1]["runtime"]["permutation"] == [0, 1, 3, 2]
+    assert row["members"][1]["runtime"]["color_id"] == "flow:1,2,3,4"
+    assert {member["color_flows"] for member in row["members"]} == {0, 1}
+    assert data["grouping"]["physical_contributions"] == 2
+    assert data["grouping"]["exported_contributions"] == 1
+
+
+def test_incoming_replay_swap_is_not_used_for_identical_leg_grouping():
+    p = with_replay()
+    p.physics["extensions"]["lc_topology_replay"]["partitions"][0][
+        "label_permutations"
+    ][1] = [[1, 2], [2, 1], [3, 3], [4, 4]]
+    (data,) = export(p)
+    (row,) = entries(data)
+    assert row["matrix_elements"] == [{"pdg_ids": 0, "factor": 2}]
+    assert row["members"][1]["runtime"]["permutation"] == [0, 1, 3, 2]
+
+
+def test_noninvariant_restricted_helicity_is_not_grouped():
+    p = with_replay()
+    p.physics["helicities"][0]["values"] = [1, 1, -1, 1]
+    (data,) = export(p)
+    assert len(entries(data)) == 2
+    assert entries(data)[1]["runtime"]["color_id"] == "flow:1,2,4,3"
+    # Both orders share one channel, the second with its final legs relabelled.
+    assert len(data["channels"]) == 1
+    assert entries(data)[1]["runtime"]["permutation"] == [0, 1, 3, 2]
+    assert entries(data)[1]["members"][0]["runtime"]["permutation"] == [0, 1, 2, 3]
+
+
+def test_orders_differing_by_equal_mass_final_labels_share_a_channel():
+    """One phase-space map per cyclic pattern of incoming legs and final masses."""
+    extended = model()
+    extended["ir"]["particles"] += [
+        {"pdg_code": 993, "color": 8, "mass": "mass_s"},
+        {"pdg_code": 994, "color": 8, "mass": "ZERO"},
+    ]
+    words = ((1, 2, 3, 4), (1, 2, 4, 3))
+    (data,) = export(process(pdgs=(990, 990, 994, 990), words=words),
+                     compiled_model=extended)
+    assert len(data["channels"]) == 1
+    first, second = entries(data)
+    pdgs = [data["pdg_ids"][e["matrix_elements"][0]["pdg_ids"]] for e in (first, second)]
+    assert pdgs == [[990, 990, 994, 990], [990, 990, 990, 994]]
+    assert second["runtime"]["permutation"] == [0, 1, 3, 2]
+    assert data["color_orders"][second["color_order"]] == [0, 1, 2, 3]
+    # The member keeps the physical labels of its process.
+    assert second["members"][0]["pdgs"] == [990, 990, 994, 990]
+    assert second["members"][0]["runtime"]["permutation"] == [0, 1, 2, 3]
+    # Final legs of different masses are never exchanged.
+    (data,) = export(process(pdgs=(990, 990, 993, 990), words=words),
+                     compiled_model=extended)
+    assert len(data["channels"]) == 2
+
+
+def test_permutation_invariant_restricted_helicity_set_is_grouped():
+    p = with_replay()
+    p.physics["helicities"][0]["values"] = [1, 1, -1, 1]
+    opposite = copy.deepcopy(p.physics["helicities"][0])
+    opposite.update(
+        id="h:opposite", representative_id="h:opposite", values=[1, 1, 1, -1]
+    )
+    p.physics["helicities"].append(opposite)
+    (data,) = export(p)
+    (row,) = entries(data)
+    assert row["matrix_elements"] == [{"pdg_ids": 0, "factor": 2}]
+
+
+def test_unproven_replay_is_not_used():
+    p = with_replay()
+    p.physics["extensions"]["lc_topology_replay"]["partitions"][0]["proof"] = None
+    p.physics["extensions"]["lc_topology_replay"]["partitions"][0][
+        "label_permutations"
+    ][1] = [[1, 2], [2, 1], [3, 3], [4, 4]]
+    (data,) = export(p)
+    (row,) = entries(data)
+    assert row["matrix_elements"] == [{"pdg_ids": 0, "factor": 2}]
+    assert row["members"][1]["runtime"]["permutation"] == [0, 1, 3, 2]
+
+
+def test_identical_adjoint_finals_reduce_24_oriented_flows_to_four():
+    words = tuple((1, *tail) for tail in permutations((2, 3, 4, 5)))
+    p = process(pdgs=(990,) * 5, words=words)
+    (data,) = export(p)
+    rows = entries(data)
+    assert len(rows) == 4
+    assert data["grouping"]["physical_contributions"] == 24
+    assert data["grouping"]["exported_contributions"] == 4
+    assert len(data["color_flows"]) == 24
+    assert all(row["matrix_elements"] == [{"pdg_ids": 0, "factor": 6}] for row in rows)
+    assert all(len(row["members"]) == 6 for row in rows)
+    assert all(row["runtime"]["factor"] == 1 for row in rows)
+    assert {member["color_id"] for row in rows for member in row["members"]} == {
+        color["id"] for color in p.physics["color_components"]
+    }
+    assert {member["color_flows"] for row in rows for member in row["members"]} == set(
+        range(24)
+    )
+    assert all(
+        member["runtime"]["permutation"][:2] == [0, 1]
+        for row in rows
+        for member in row["members"]
+    )
+
+
+def test_identical_grouping_does_not_fold_trace_reflection_or_swap_beams():
+    p = process(pdgs=(990,) * 5, words=((1, 2, 3, 4, 5), (1, 5, 4, 3, 2)))
+    p.physics["color_components"][1]["representative_id"] = "flow:1,2,3,4,5"
+    (data,) = export(p)
+    assert len(entries(data)) == 2
+    assert all(
+        row["matrix_elements"] == [{"pdg_ids": 0, "factor": 1}] for row in entries(data)
+    )
+
+
+def test_identical_trace_grouping_allows_cyclic_reanchoring():
+    m = model()
+    m["ir"]["particles"].append({"pdg_code": 993, "color": 8, "mass": "ZERO"})
+    p = process(pdgs=(995, 995, 990, 993, 990), words=((3, 4, 5), (3, 5, 4)))
+    (data,) = export(p, compiled_model=m)
+    (row,) = entries(data)
+    assert row["matrix_elements"] == [{"pdg_ids": 0, "factor": 2}]
+    assert len(row["members"]) == 2
+    # Swap only the two identical adjoints, then re-anchor the directed trace.
+    assert row["members"][1]["runtime"]["permutation"] == [0, 1, 4, 3, 2]
+
+
+def test_identical_open_chains_allow_cyclic_block_rotation():
+    p = process(
+        pdgs=(991, 991, 991, 991, 990),
+        words=((3, 5, 1, 4, 2), (3, 2, 4, 5, 1)),
+    )
+    (data,) = export(p)
+    (row,) = entries(data)
+    assert row["matrix_elements"] == [{"pdg_ids": 0, "factor": 2}]
+    assert len(row["members"]) == 2
+    # The two outgoing quarks exchange; each directed chain and both beams
+    # remain intact, while the complete chain blocks rotate cyclically.
+    assert row["members"][1]["runtime"]["permutation"] == [0, 1, 3, 2, 4]
+
+
+def test_equal_mass_distinct_final_species_are_not_identical():
+    m = model()
+    m["ir"]["particles"].append({"pdg_code": 993, "color": 8, "mass": "ZERO"})
+    p = process(pdgs=(990, 990, 990, 993), words=((1, 2, 3, 4), (1, 2, 4, 3)))
+    (data,) = export(p, compiled_model=m)
+    assert len(entries(data)) == 2
+
+
+def test_identical_grouping_preserves_open_chain_topology():
+    p = process(
+        pdgs=(991, -991, 991, -991, 990),
+        words=((2, 5, 4, 3, 1), (2, 5, 1, 3, 4)),
+    )
+    sectors = (
+        {
+            "id": 0,
+            "kind": "open-lines",
+            "word_labels": [2, 5, 4, 3, 1],
+            "open_color_lines": [
+                {
+                    "fundamental_label": 2,
+                    "adjoint_labels": [5],
+                    "antifundamental_label": 4,
+                },
+                {
+                    "fundamental_label": 3,
+                    "adjoint_labels": [],
+                    "antifundamental_label": 1,
+                },
+            ],
+        },
+        {
+            "id": 1,
+            "kind": "open-lines",
+            "word_labels": [2, 5, 1, 3, 4],
+            "open_color_lines": [
+                {
+                    "fundamental_label": 2,
+                    "adjoint_labels": [5],
+                    "antifundamental_label": 1,
+                },
+                {
+                    "fundamental_label": 3,
+                    "adjoint_labels": [],
+                    "antifundamental_label": 4,
+                },
+            ],
+        },
+    )
+    (data,) = export(replace(p, color_sectors=sectors))
+    assert len(entries(data)) == 2
+
+
+def test_structural_crossflavour_equality_keeps_incoming_pdf_flavours():
+    a = replace(
+        process("a", pdgs=(991, -991, 990, 990), words=((2, 3, 4, 1),)),
+        structural_keys={"flow:2,3,4,1": "certified-key"},
+    )
+    b = replace(
+        process("b", pdgs=(992, -992, 990, 990), words=((2, 3, 4, 1),)),
+        structural_keys={"flow:2,3,4,1": "certified-key"},
+    )
+    (data,) = export(a, b)
+    rows = entries(data)
+    assert len(rows) == 2
+    assert rows[1]["runtime"]["process_id"] == "a"
+    assert data["pdg_ids"] == [[991, -991, 990, 990], [992, -992, 990, 990]]
+    assert [row["matrix_elements"] for row in rows] == [
+        [{"pdg_ids": 0, "factor": 1}],
+        [{"pdg_ids": 1, "factor": 1}],
+    ]
+
+
+def test_groups_certified_distinct_final_flavours():
+    a = replace(
+        process("a", pdgs=(990, 990, 991, -991), words=((3, 1, 2, 4),)),
+        structural_keys={"flow:3,1,2,4": "certified-key"},
+    )
+    b = replace(
+        process("b", pdgs=(990, 990, 992, -992), words=((3, 1, 2, 4),)),
+        structural_keys={"flow:3,1,2,4": "certified-key"},
+    )
+    (data,) = export(a, b)
+    assert len(entries(data)) == 1
+    assert sum(len(row["members"]) for row in entries(data)) == 2
+    assert entries(data)[0]["matrix_elements"] == [
+        {"pdg_ids": 0, "factor": 1},
+        {"pdg_ids": 1, "factor": 1},
+    ]
+
+
+def test_equal_defaults_are_not_an_equivalence_and_aliases_not_multiplicity():
+    a = process("a", pdgs=(991, -991, 990, 990), words=((2, 3, 4, 1),))
+    b = process("b", pdgs=(992, -992, 990, 990), words=((2, 3, 4, 1),))
+    a = replace(
+        a,
+        aliases=(
+            {
+                "id": "alias",
+                "external_pdgs": list(a.external_pdgs),
+                "external_permutation": [1, 0, 2, 3],
+            },
+        ),
+    )
+    (data,) = export(a, b)
+    assert len(entries(data)) == 2
+    assert entries(data)[1]["runtime"]["process_id"] == "b"
+    assert len(data["aliases"]) == 1
+    assert data["grouping"]["physical_contributions"] == 2
+
+
+def test_alpha_s_not_guessed_from_parameter_name():
+    m = model()
+    m["ir"]["parameters"][0]["lhablock"] = "UNRELATED"
+    (data,) = export(process(), compiled_model=m)
+    assert data["provider"]["alpha_s_parameter"] is None
+    assert not data["provider"]["supports_alpha_s"]
+
+
+def test_payloads_have_sdk_roles_and_generated_c_matches_json():
+    payloads = {
+        p.path: p
+        for p in umami_bundle_payloads(
+            processes=[with_replay()], compiled_model=model()
+        )
+    }
+    data = json.loads(payloads["API/umami/metadata.json"].content)
+    header = payloads["API/umami/provider_p0.h"].content.decode()
+    assert "#define UMAMI_HAS_ALPHA_S 1" in header
+    assert "static const UmamiProvider umami_provider" in header
+    assert "umami_c0_f0_permutation[] = {0, 1, 2, 3}" in header
+    assert "umami_c1_f0_permutation" not in header
+    assert entries(data)[0]["members"][1]["runtime"]["permutation"] == [0, 1, 3, 2]
+    assert data["provider"]["library"] == "libumami.so"
+    assert payloads["API/umami/metadata.json"].role == "sdk-metadata"
+
+
+def test_provider_reuses_existing_runtime_artifact_identity():
+    payloads = {
+        p.path: p
+        for p in umami_bundle_payloads(
+            processes=[process()],
+            compiled_model=model(),
+            artifact_id="existing-id",
+        )
+    }
+    data = json.loads(payloads["API/umami/metadata.json"].content)
+    assert data["provider"]["artifact_id"] == "existing-id"
+    assert (
+        b'#define UMAMI_ARTIFACT_ID "existing-id"'
+        in payloads["API/umami/provider_p0.h"].content
+    )
+
+
+def test_mass_parameter_semantics_not_only_current_value_split_providers():
+    m = model()
+    m["ir"]["particles"].append({"pdg_code": 996, "color": 1, "mass": "other_mass"})
+    m["ir"]["parameters"].append(
+        {"name": "other_mass", "nature": "external", "value": [7, 0]}
+    )
+    a = process("a", pdgs=(991, -991, 995, 990), words=((2, 4, 1),))
+    b = process("b", pdgs=(991, -991, 996, 990), words=((2, 4, 1),))
+    assert len(export(a, b, compiled_model=m)) == 2
+
+
+def test_derived_mass_uses_already_resolved_public_default():
+    m = model()
+    m["parameter_defaults"].pop("mass_s")
+    m["ir"]["parameters"][1] = {
+        "name": "mass_s",
+        "nature": "internal",
+        "parameter_type": "real",
+        "expression": "sqrt(strong_input)",
+        "resolved_expression": "sqrt(strong_input)",
+    }
+    p = process(pdgs=(991, -991, 995, 990), words=((2, 4, 1),))
+    p.physics["model_parameters"].append(
+        {
+            "name": "mass_s",
+            "kind": "derived",
+            "default_real": 0.12**0.5,
+            "default_imaginary": 0.0,
+            "mutable": False,
+        }
+    )
+    (data,) = export(p, compiled_model=m)
+    assert data["provider"]["masses"] == [0, 0, 0.12**0.5, 0]
+    assert data["provider"]["mass_parameters"][2] == "sqrt(strong_input)"
+
+
+@pytest.mark.parametrize("representative", ["h:all-plus", "h:all-minus"])
+def test_only_certified_helicity_equivalences_are_reused(representative):
+    p = process()
+    h = copy.deepcopy(p.physics["helicities"][0])
+    h.update(id="h:all-minus", values=[-1] * 4, representative_id=representative)
+    p.physics["helicities"].append(h)
+    (data,) = export(p)
+    assert entries(data)[0]["helicities"] == (
+        [[0, 1]] if representative == "h:all-plus" else [[0], [1]]
+    )
+    assert entries(data)[0]["helicity_mappings"] == [
+        {
+            "helicity": index,
+            "representative_id": "h:all-plus" if index == 0 else representative,
+            "coefficient": 1,
+            "structural_zero": False,
+        }
+        for index in range(2)
+    ]
+
+
+@pytest.mark.parametrize("accuracy,flows", [("lc", 6), ("full", 1)])
+@pytest.mark.parametrize("domain", [(-1, 1), (1, -1)])
+def test_otf_sdk_axes_do_not_change_compact_public_metadata(accuracy, flows, domain):
+    p = process(accuracy=accuracy)
+    compact = {
+        k: v
+        for k, v in p.physics.items()
+        if k not in {"helicities", "color_components", "coverage", "extensions"}
+    }
+    process_ir = CanonicalProcessIR(
+        process="x x > x x",
+        key="x",
+        color_accuracy=accuracy,
+        legs=tuple(
+            ProcessLegIR(
+                label=i + 1,
+                side="initial" if i < 2 else "final",
+                particle="x",
+                outgoing_particle="x",
+                pdg=990,
+                outgoing_pdg=990,
+                statistics="bosonic",
+                wavefunction_family="vector",
+                color_role="adjoint",
+                source_orientation="self-conjugate",
+            )
+            for i in range(4)
+        ),
+        color_endpoints=ColorEndpointSummary(0, 0, 0),
+    )
+    seed = SimpleNamespace(
+        external_sources=tuple(
+            SimpleNamespace(
+                public_label=i + 1,
+                source_states=tuple(SimpleNamespace(public_helicity=h) for h in domain),
+            )
+            for i in reversed(range(4))
+        )
+    )
+    resolved, sectors = build_umami_on_the_fly_physics(compact, process_ir, seed)
+    assert "helicities" not in compact
+    assert len(resolved["helicities"]) == 16
+    assert resolved["helicities"][0]["id"] == "h:" + ",".join([f"{domain[0]:+d}"] * 4)
+    assert resolved["helicities"][1]["values"] == [domain[0]] * 3 + [domain[1]]
+    assert len(resolved["color_components"]) == flows
+    (data,) = export(replace(p, physics=resolved, color_sectors=sectors))
+    assert len(entries(data)) == (3 if accuracy == "lc" else 1)
+    assert data["grouping"]["physical_contributions"] == flows
+    restored = restore_umami_on_the_fly_input(replace(p, physics=compact), [data])
+    assert export(restored) == (data,)
+    assert "helicities" not in compact
+
+
+def test_otf_append_recovers_grouped_physical_color_members():
+    p = with_replay()
+    p.physics["helicities"][0].update(
+        id="h:+1,+1,+1,+1", representative_id="h:+1,+1,+1,+1"
+    )
+    (data,) = export(p)
+    restored = restore_umami_on_the_fly_input(p, [data])
+    assert [color["id"] for color in restored.physics["color_components"]] == [
+        "flow:1,2,3,4",
+        "flow:1,2,4,3",
+    ]
+    assert restored.color_flows == {
+        member["color_id"]: data["color_flows"][member["color_flows"]]
+        for member in entries(data)[0]["members"]
+    }
+    assert export(restored) == (data,)
+
+
+def test_writer_append_recovers_old_compact_otf_sdk(tmp_path, monkeypatch):
+    from pyamplicol.generation.artifact_writer import _write_umami_bundle
+
+    p = process()
+    p.physics["helicities"][0]["id"] = "h:+1,+1,+1,+1"
+    (data,) = export(p)
+    compact = {
+        k: v
+        for k, v in p.physics.items()
+        if k not in {"helicities", "color_components"}
+    }
+    compact["kind"] = "pyamplicol-on-the-fly-public-metadata"
+    files = {"API/umami/metadata.json": data, "processes/p/physics.json": compact}
+    for path, value in files.items():
+        destination = tmp_path / path
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_text(json.dumps(value), encoding="utf-8")
+    written = {}
+    builder = SimpleNamespace(
+        staged_path=lambda path: tmp_path / path,
+        payload_records=lambda: [],
+        add_bytes=lambda path, content, **kwargs: written.setdefault(path, content),
+    )
+    _write_umami_bundle(
+        builder,
+        processes=(),
+        process_records=[
+            {
+                "id": "p",
+                "expression": "p",
+                "color_accuracy": "lc",
+                "external_pdgs": list(p.external_pdgs),
+                "physics_path": "processes/p/physics.json",
+            }
+        ],
+        compiled_model=SimpleNamespace(to_dict=model),
+    )
+    recovered = json.loads(written["API/umami/metadata.json"])
+    assert recovered["provider"]["helicity_count"] == 1
+    assert recovered["color_flows"] == data["color_flows"]
+    assert len(entries(recovered)) == 1
+
+
+def blind_member(identifier, pdgs, permutation=None, *, conjugated=False):
+    return GroupMember(
+        process_id=identifier,
+        expression=identifier,
+        pdgs=tuple(pdgs),
+        initial_count=2,
+        permutation=tuple(range(len(pdgs)) if permutation is None else permutation),
+        conjugated=conjugated,
+        basis=GroupingBasis.FLAVOR_BLIND,
+        generated=False,
+    )
+
+
+def physical_flows(data, process_id):
+    """Colour ID -> LHE tags, renumbered by first use, of one physical process."""
+
+    def canonical(flow):
+        names = {}
+        return [
+            [names.setdefault(tag, len(names) + 1) if tag else 0 for tag in pair]
+            for pair in flow
+        ]
+
+    return {
+        member["color_id"]: canonical(data["color_flows"][member["color_flows"]])
+        for entry in entries(data)
+        for member in entry["members"]
+        if member["process_id"] == process_id
+    }
+
+
+def quark_gluon(identifier="a", pdgs=(991, 990, 991, 990)):
+    # Every helicity of the incoming legs: a set invariant under their swap.
+    p = process(identifier, pdgs=pdgs, words=((3, 2, 4, 1), (3, 4, 2, 1)))
+    template = p.physics["helicities"][0]
+    p.physics["helicities"][:] = [
+        {**template, "id": f"h{i}", "representative_id": f"h{i}", "values": values}
+        for i, values in enumerate(
+            [[1, 1, 1, 1], [1, -1, 1, 1], [-1, 1, 1, 1], [-1, -1, 1, 1]]
+        )
+    ]
+    return p
+
+
+def test_flavor_blind_member_with_equal_incoming_flavours_is_an_extra_row():
+    a = process("a", pdgs=(990, 990, 991, -991), words=((3, 1, 2, 4),))
+    (data,) = export(
+        replace(a, group_members=(blind_member("m", (990, 990, 992, -992)),))
+    )
+    (row,) = entries(data)
+    assert [p["id"] for p in data["runtime_processes"]] == ["a"]
+    assert data["pdg_ids"] == [[990, 990, 991, -991], [990, 990, 992, -992]]
+    assert row["matrix_elements"] == [
+        {"pdg_ids": 0, "factor": 1},
+        {"pdg_ids": 1, "factor": 1},
+    ]
+    representative, member = row["members"]
+    assert member["process_id"] == "m"
+    assert member["pdgs"] == [990, 990, 992, -992]
+    assert member["color_id"] == "flow:3,1,2,4"
+    assert member["runtime"] == representative["runtime"]
+    assert data["grouping"]["physical_contributions"] == 2
+    assert data["grouping"]["exported_contributions"] == 1
+    assert data["grouping"]["assumptions"][-1] == FLAVOR_BLIND_ASSUMPTION
+    assert FLAVOR_BLIND_ASSUMPTION not in export(a)[0]["grouping"]["assumptions"]
+
+
+def test_flavor_blind_member_with_swapped_incoming_legs_maps_axes():
+    # "g u > u g" is "u g > u g" with the incoming legs exchanged.
+    a = quark_gluon()
+    member = blind_member("m", (990, 991, 991, 990), (1, 0, 2, 3))
+    (data,) = export(replace(a, group_members=(member,)))
+    assert [p["id"] for p in data["runtime_processes"]] == ["a"]
+    rows = entries(data)
+    # Different incoming flavours remain separate selectors.
+    assert all(
+        len({m["process_id"] for m in row["members"]}) == 1
+        and len(row["matrix_elements"]) == 1
+        for row in rows
+    )
+    members = [m for row in rows for m in row["members"] if m["process_id"] == "m"]
+    assert len(members) == 2
+    assert data["grouping"]["physical_contributions"] == 4
+    runtime_values = [h["values"] for h in a.physics["helicities"]]
+    for physical in members:
+        runtime = physical["runtime"]
+        assert runtime["process_id"] == "a" and runtime["process_index"] == 0
+        assert runtime["permutation"] == [1, 0, 2, 3]
+        assert [data["helicities"][i] for i in runtime["helicity_export"]] == [
+            [v[1], v[0], *v[2:]] for v in runtime_values
+        ]
+    # The relabelled tags are those of the member exported on its own.
+    reference = process("m", pdgs=member.pdgs, words=((3, 1, 4, 2), (3, 4, 1, 2)))
+    assert physical_flows(data, "m") == physical_flows(export(reference)[0], "m")
+
+
+def test_conjugated_flavor_blind_member_reverses_colour_flows():
+    a = quark_gluon()
+    member = blind_member("c", (-991, 990, -991, 990), conjugated=True)
+    (data,) = export(replace(a, group_members=(member,)))
+    members = [
+        m for row in entries(data) for m in row["members"] if m["process_id"] == "c"
+    ]
+    assert {m["color_id"]: m["runtime"]["color_id"] for m in members} == {
+        "flow:1,4,2,3": "flow:3,2,4,1",
+        "flow:1,2,4,3": "flow:3,4,2,1",
+    }
+    reference = process("c", pdgs=member.pdgs, words=((1, 4, 2, 3), (1, 2, 4, 3)))
+    assert physical_flows(data, "c") == physical_flows(export(reference)[0], "c")
+    assert all(m["runtime"]["permutation"] == [0, 1, 2, 3] for m in members)
+
+
+def test_member_moving_unequal_masses_reuses_runtime_in_its_own_provider():
+    a = process("a", pdgs=(995, 990, 995, 990), words=((2, 4),))
+    member = blind_member("m", (990, 995, 995, 990), (1, 0, 2, 3))
+    first, second = export(replace(a, group_members=(member,)))
+    assert first["provider"]["masses"] == [7, 0, 7, 0]
+    assert second["provider"]["masses"] == [0, 7, 7, 0]
+    assert FLAVOR_BLIND_ASSUMPTION not in first["grouping"]["assumptions"]
+    # No runtime row of its own: the second provider loads the representative.
+    assert [p["id"] for p in second["runtime_processes"]] == ["a"]
+    assert {m["process_id"] for row in entries(second) for m in row["members"]} == {
+        "m"
+    }
+    payloads = {
+        p.path: p.content
+        for p in umami_bundle_payloads(
+            processes=[replace(a, group_members=(member,))], compiled_model=model()
+        )
+    }
+    header = payloads["API/umami/provider_p1.h"].decode()
+    assert '"a"' in header and '"m"' not in header
+
+
+def test_otf_append_ignores_providers_loading_a_runtime_only_for_members():
+    a = process("a", pdgs=(995, 990, 995, 990), words=((2, 4),))
+    a.physics["helicities"][0].update(
+        id="h:+1,+1,+1,+1", representative_id="h:+1,+1,+1,+1"
+    )
+    member = blind_member("m", (990, 995, 995, 990), (1, 0, 2, 3))
+    a = replace(a, group_members=(member,))
+    documents = export(a)
+    assert len(documents) == 2
+    assert export(restore_umami_on_the_fly_input(a, documents)) == documents
+
+
+def test_flavours_with_different_runtime_permutations_are_not_merged():
+    a = process("a", pdgs=(990, 990, 991, -991), words=((3, 1, 2, 4),))
+    member = blind_member("m", (990, 990, 992, -992), (1, 0, 2, 3))
+    (data,) = export(replace(a, group_members=(member,)))
+    rows = entries(data)
+    assert len(rows) == 2
+    assert [len(row["matrix_elements"]) for row in rows] == [1, 1]
+    assert rows[0]["runtime"]["permutation"] != rows[1]["runtime"]["permutation"]
+
+
+def test_member_factor_multiplies_the_representative_runtime():
+    # ME_member(p) = factor * ME_representative(q): a selector of its own.
+    a = process("a", pdgs=(990, 990, 991, -991), words=((3, 1, 2, 4),))
+    member = replace(blind_member("m", (990, 990, 992, -992)), factor=Fraction(1, 2))
+    (data,) = export(replace(a, group_members=(member,)))
+    assert [row["runtime"]["factor"] for row in entries(data)] == [1, 0.5]
+    assert [row["matrix_elements"] for row in entries(data)] == [
+        [{"pdg_ids": 0, "factor": 1}],
+        [{"pdg_ids": 1, "factor": 1}],
+    ]
+
+
+def test_writer_exports_only_ungenerated_group_members(tmp_path):
+    from pyamplicol.generation.artifact_writer import _write_umami_bundle
+
+    a = process("a", pdgs=(990, 990, 991, -991), words=((3, 1, 2, 4),))
+    b = process("b", pdgs=(992, -992, 990, 990), words=((2, 3, 4, 1),))
+    groups = ProcessGroupMap()
+    groups.add_group(
+        [
+            GroupMember.identity(GroupingProcess("a", "a", a.external_pdgs, 2)),
+            replace(
+                GroupMember.identity(GroupingProcess("b", "b", b.external_pdgs, 2)),
+                basis=GroupingBasis.NUMERICAL,
+            ),
+            blind_member("m", (990, 990, 992, -992)),
+        ]
+    )
+    records = []
+    for p in (a, b):
+        path = f"processes/{p.process_id}/physics.json"
+        (tmp_path / path).parent.mkdir(parents=True)
+        (tmp_path / path).write_text(json.dumps(p.physics), encoding="utf-8")
+        records.append(
+            {
+                "id": p.process_id,
+                "expression": p.expression,
+                "color_accuracy": "lc",
+                "external_pdgs": list(p.external_pdgs),
+                "physics_path": path,
+            }
+        )
+    written = {}
+    builder = SimpleNamespace(
+        staged_path=lambda path: tmp_path / path,
+        payload_records=lambda: [],
+        add_bytes=lambda path, content, **kwargs: written.setdefault(path, content),
+    )
+    _write_umami_bundle(
+        builder,
+        processes=(),
+        process_records=records,
+        compiled_model=SimpleNamespace(to_dict=model),
+        process_groups=groups,
+    )
+    data = json.loads(written["API/umami/metadata.json"])
+    assert [p["id"] for p in data["runtime_processes"]] == ["a", "b"]
+    runtimes = {
+        m["process_id"]: m["runtime"]["process_id"]
+        for row in entries(data)
+        for m in row["members"]
+    }
+    assert runtimes == {"a": "a", "b": "b", "m": "a"}
diff --git a/pyamplicol/tests/unit/test_umami_reweight_validation.py b/pyamplicol/tests/unit/test_umami_reweight_validation.py
new file mode 100644
index 0000000000..5354c2a102
--- /dev/null
+++ b/pyamplicol/tests/unit/test_umami_reweight_validation.py
@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: 0BSD
+"""Crafted UMAMI metadata must not reach the generated reweight sources."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from pyamplicol.artifacts.umami_reweight import (
+    load_umami_metadata,
+    reweight_header,
+    write_reweight_provider,
+)
+
+
+def _process(identifier="proc"):
+    return {
+        "id": identifier,
+        "pdgs": [21, 21, 21, 21],
+        "alpha_s_parameter": "aS",
+        "helicity_ids": ["h0"],
+    }
+
+
+def _document(provider_id="p0", permutation=(0, 1, 2, 3), process_index=0):
+    return {
+        "kind": "pyamplicol-umami-metadata",
+        "provider": {
+            "id": provider_id,
+            "particle_count": 4,
+            "color_accuracy": "lc",
+            "artifact_id": "a",
+        },
+        "runtime_processes": [_process()],
+        "helicities": [[1, 1, 1, 1]],
+        "channels": [
+            {
+                "processes": [
+                    {
+                        "runtime": {
+                            "process_index": process_index,
+                            "permutation": list(permutation),
+                            "helicity_export": [0],
+                        }
+                    }
+                ]
+            }
+        ],
+    }
+
+
+def _write(artifact: Path, document) -> Path:
+    root = artifact / "API" / "umami"
+    root.mkdir(parents=True)
+    (root / "metadata.json").write_text(json.dumps(document), encoding="utf-8")
+    return artifact
+
+
+def test_valid_metadata_renders():
+    header = reweight_header(_document(), [_document()], "lc", "full")
+    assert "reweight_c0_f0_permutation[] = {0, 1, 2, 3};" in header
+
+
+@pytest.mark.parametrize(
+    "document",
+    [
+        _document(permutation=(0, 1, 2, "3}; void f(void) {}")),
+        _document(permutation=(0, 1, 2, True)),
+        _document(process_index="0"),
+    ],
+)
+def test_non_integer_metadata_is_rejected(document):
+    with pytest.raises(ValueError, match="integer"):
+        reweight_header(document, [_document()], "lc", "full")
+
+
+def test_provider_id_is_validated(tmp_path):
+    lc = _write(tmp_path / "lc", _document(provider_id="$(shell touch PWNED)"))
+    full = _write(tmp_path / "full", _document())
+    with pytest.raises(ValueError, match="provider id"):
+        write_reweight_provider(lc, full, tmp_path / "out")
+    assert not (tmp_path / "out" / "providers.mk").exists()
+
+
+def test_metadata_path_stays_in_artifact(tmp_path):
+    (tmp_path / "secret.json").write_text("{}", encoding="utf-8")
+    index = {
+        "kind": "pyamplicol-umami-provider-index",
+        "providers": [{"id": "p0", "metadata": "../../../secret.json"}],
+    }
+    artifact = _write(tmp_path / "lc", index)
+    with pytest.raises(ValueError, match="leaves"):
+        load_umami_metadata(artifact)
diff --git a/pyamplicol/tests/unit/test_umami_semantics.py b/pyamplicol/tests/unit/test_umami_semantics.py
new file mode 100644
index 0000000000..aac68728d8
--- /dev/null
+++ b/pyamplicol/tests/unit/test_umami_semantics.py
@@ -0,0 +1,402 @@
+# SPDX-License-Identifier: 0BSD
+"""Symbolic grouping proofs, with no numerical equivalence discovery."""
+
+from __future__ import annotations
+
+import copy
+from types import SimpleNamespace as NS
+
+import pytest
+
+from pyamplicol.generation.umami_semantics import (
+    ParameterSemantics,
+    recurrence_structural_keys,
+)
+
+
+def model_ir():
+    return {
+        "name": "unfamiliar_theory",
+        "parameters": [
+            {
+                "name": "base",
+                "nature": "external",
+                "parameter_type": "real",
+                "value": [2, 0],
+            },
+            {
+                "name": "independent",
+                "nature": "external",
+                "parameter_type": "real",
+                "value": [2, 0],
+            },
+            {
+                "name": "first",
+                "nature": "internal",
+                "parameter_type": "real",
+                "expression": "2*base",
+                "resolved_expression": "2*base",
+            },
+            {
+                "name": "second",
+                "nature": "internal",
+                "parameter_type": "real",
+                "expression": "2*base",
+                "resolved_expression": "2*base",
+            },
+        ],
+        "couplings": [],
+    }
+
+
+def circuit(parameter="first", pdg=900001):
+    kernel = NS(
+        kernel_id=0,
+        contract_kind="vertex",
+        output_layout=("component0",),
+        exact_expressions=("g0*left(0)*right(0)",),
+        input_contracts=(
+            {
+                "symbol": "g0",
+                "role": "model-parameter",
+                "component": 0,
+                "model_parameter_index": 0,
+            },
+            {"symbol": "left(0)", "role": "left-current", "component": 0},
+            {"symbol": "right(0)", "role": "right-current", "component": 0},
+        ),
+    )
+    direct = NS(
+        direct_executor_id=0,
+        role="contribution",
+        evaluator_binding_id=0,
+        evaluator_resolver_key="vertex",
+        semantic_template_ids=(),
+        payload_binding=NS(
+            prepared_kernel_id=0, contribution_parent_permutation=(0, 1)
+        ),
+    )
+    pack = NS(
+        kernels=(kernel,),
+        recurrence_template_catalog=NS(
+            parameters=(NS(prepared_parameter_id=0, name=parameter),),
+            evaluator_bindings=(
+                NS(
+                    callable_kind="prepared-kernel",
+                    prepared_kernel_id=0,
+                    resolver_key="vertex",
+                ),
+            ),
+            transitions=(),
+            closures=(),
+        ),
+        recurrence_direct_template_catalog=NS(templates=(direct,)),
+    )
+    source = {
+        "source_template_id": 0,
+        "dimension": 1,
+        "helicity": 0,
+        "chirality": 0,
+        "spin_state": 0,
+        "crossing": {"phase": [1, 0]},
+        "source_ir": {
+            "identity": {"pdg": pdg, "orientation": "self-conjugate"},
+            "wavefunction_family": "scalar",
+            "statistics": "boson",
+            "component_dimension": 1,
+            "basis": "scalar-unit",
+            "mass_parameter": None,
+            "width_parameter": None,
+        },
+    }
+    sections = {
+        "abi": "pyamplicol-recurrence-exact-sections-v1",
+        "strategy": "topology-replay",
+        "process_id": f"process_{pdg}",
+        "semantic_digest": str(pdg),
+        "runtime_layout_digest": str(pdg),
+        "counts": [3, 1, 1, 2],
+        "executors": [[0, "contribution", "accumulate", [1, 1], 1, 0, 0, None]],
+        "currents": [[pdg, 0, pdg, 0, 1, 0, 0, 0, 0, 1, 0, 0]],
+        "sources": [[0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0]],
+        "contributions": [[0, 1, 0, 1, 2, 0, 0, 0]],
+        "closures": [[2, 0, 0, 1, 0, 0, 0, 1, 0, 0]],
+        "row_groups": [[0, 1, 0, 0, 0, 1]],
+        "source_dispatch_variants": [],
+        "exact_factors": [[1, 1, 0, 1]],
+        "amplitude_destinations": [[0, 0, 0, 0, 1, 0]],
+    }
+    metadata = {
+        "source_templates": [source],
+        "normalization": {"average_factor": 1, "identical_factor": 1},
+        "external_legs": [
+            {"source_slot": 0, "is_initial": True},
+            {"source_slot": 1, "is_initial": False},
+        ],
+        "parameter_projection": [
+            {"runtime_slot": 0, "runtime_name": parameter, "component": 0}
+        ],
+    }
+    remap = NS(
+        source_slots=(0, 1),
+        source_momentum_signs=(1, 1),
+        source_helicity_signs=(1, 1),
+        source_state_offsets=(0, 1, 2),
+        source_state_indices=(0, 0),
+        state_template_changes=(),
+        source_template_changes=(),
+        direct_executor_changes=(),
+        parameter_slot_changes=(),
+        public_flow_ids=(0,),
+        physical_sector_ids=(0,),
+    )
+    return dict(
+        exact_sections=sections,
+        runtime_metadata=metadata,
+        kernel_pack=pack,
+        ir=model_ir(),
+        physics={
+            "color_accuracy": "full",
+            "helicities": [{"values": [0, 0]}],
+            "color_components": [{"id": "color:contracted", "index": 0}],
+        },
+        remap=remap,
+        color_contraction_payload=b"same exact color contraction",
+    )
+
+
+def key(**kwargs):
+    result = recurrence_structural_keys(**kwargs)
+    assert result, "supported proof fixture must not silently fall back"
+    return result
+
+
+def test_parameter_definitions_resolve_without_freezing_mutable_defaults():
+    semantics = ParameterSemantics(model_ir())
+    assert semantics.parameter("first") == semantics.parameter("second")
+    assert semantics.parameter("base") != semantics.parameter("independent")
+    changed = model_ir()
+    changed["parameters"][0]["value"] = [37, 0]
+    assert ParameterSemantics(changed).parameter("first") == semantics.parameter(
+        "first"
+    )
+
+
+def test_non_sm_flavours_with_equal_symbolic_circuits_share_keys():
+    assert key(**circuit("first", 900001)) == key(**circuit("second", 900002))
+
+
+def test_independent_inputs_with_equal_defaults_do_not_share_keys():
+    assert key(**circuit("base")) != key(**circuit("independent"))
+
+
+def test_complete_function_atom_input_contracts_are_bound():
+    semantics = ParameterSemantics(model_ir())
+    left = semantics.expression("f(0)*left(0)", {"left(0)": ("left", 0)})
+    renamed = semantics.expression("f(0)*right(0)", {"right(0)": ("left", 0)})
+    different = semantics.expression("f(0)*left(0)", {"left(0)": ("left", 1)})
+    assert left == renamed
+    assert left != different
+
+
+def test_derived_contact_couplings_use_catalog_expression_not_generated_names():
+    first = circuit("contact_coupling_one")
+    second = circuit("contact_coupling_two")
+    for data, name in (
+        (first, "contact_coupling_one"),
+        (second, "contact_coupling_two"),
+    ):
+        catalog = data["kernel_pack"].recurrence_template_catalog
+        catalog.parameters = (
+            NS(
+                name=name,
+                template_id="derived",
+                prepared_parameter_id=0,
+                parameter_kind="derived",
+                value_type="complex",
+                exact_expression_digest="same-symbolic-expression",
+                dependency_parameter_ids=("external",),
+            ),
+            NS(
+                name="base",
+                template_id="external",
+                prepared_parameter_id=1,
+                parameter_kind="external",
+            ),
+        )
+        data["kernel_pack"].kernels[0].output_layout = (f"auxiliary:{name}:c0",)
+    assert key(**first) == key(**second)
+    second["kernel_pack"].recurrence_template_catalog.parameters[
+        0
+    ].exact_expression_digest = "different-expression"
+    assert key(**first) != key(**second)
+
+
+def test_binding_couplings_keep_exact_rationals_beyond_decimal_precision():
+    first = circuit()
+    pack = first["kernel_pack"]
+    pack.kernels[0].input_contracts[0].update(role="coupling-real")
+    pack.recurrence_direct_template_catalog.templates[0].semantic_template_ids = (5,)
+    pack.recurrence_template_catalog.transitions = (
+        NS(
+            template_id=5,
+            binding_coupling=NS(
+                real_numerator=1,
+                real_denominator=3,
+                imag_numerator=0,
+                imag_denominator=1,
+            ),
+        ),
+    )
+    second = copy.deepcopy(first)
+    coupling = (
+        second["kernel_pack"]
+        .recurrence_template_catalog.transitions[0]
+        .binding_coupling
+    )
+    coupling.real_numerator = 10**35 + 1
+    coupling.real_denominator = 3 * 10**35
+    assert key(**first) != key(**second)
+
+
+@pytest.mark.parametrize(
+    "change",
+    [
+        "propagator",
+        "chirality",
+        "orientation",
+        "source_basis",
+        "width",
+        "fermion_sign",
+        "coherent_root",
+        "color_contraction",
+        "normalization",
+        "momentum_route",
+        "input_component",
+        "parent_permutation",
+    ],
+)
+def test_distinct_physics_never_shares_keys(change):
+    original = circuit()
+    modified = copy.deepcopy(original)
+    source = modified["runtime_metadata"]["source_templates"][0]
+    sections = modified["exact_sections"]
+    if change == "propagator":
+        modified["kernel_pack"].kernels[0].exact_expressions = (
+            "g0*left(0)*right(0)/(p2-m2)",
+        )
+    elif change == "chirality":
+        source["chirality"] = 1
+    elif change == "orientation":
+        source["source_ir"]["identity"]["orientation"] = "antiparticle"
+    elif change == "source_basis":
+        source["source_ir"]["basis"] = "different-basis"
+    elif change == "width":
+        source["source_ir"]["width_parameter"] = "base"
+    elif change == "fermion_sign":
+        sections["exact_factors"][0][0] = -1
+    elif change == "coherent_root":
+        sections["closures"].append(copy.deepcopy(sections["closures"][0]))
+    elif change == "color_contraction":
+        modified["color_contraction_payload"] = b"another exact contraction"
+    elif change == "normalization":
+        modified["runtime_metadata"]["normalization"]["identical_factor"] = 2
+    elif change == "momentum_route":
+        sections["contributions"][0][2] = 1
+    elif change == "input_component":
+        modified["kernel_pack"].kernels[0].input_contracts[1]["component"] = 1
+    else:
+        modified["kernel_pack"].recurrence_direct_template_catalog.templates[
+            0
+        ].payload_binding.contribution_parent_permutation = (1, 0)
+    assert key(**original) != key(**modified)
+
+
+def test_unknown_intrinsic_or_missing_data_falls_back_without_proof():
+    data = circuit()
+    data["runtime_metadata"].pop("source_templates")
+    assert recurrence_structural_keys(**data) == {}
+    data = circuit()
+    data["kernel_pack"].recurrence_direct_template_catalog.templates = ()
+    data["exact_sections"]["executors"][0][7] = "unknown-physics-intrinsic"
+    assert recurrence_structural_keys(**data) == {}
+
+
+@pytest.mark.parametrize("field", ["basis", "statistics", "component_dimension"])
+def test_missing_source_semantics_cannot_authorize_grouping(field):
+    data = circuit()
+    data["runtime_metadata"]["source_templates"][0]["source_ir"].pop(field)
+    assert recurrence_structural_keys(**data) == {}
+
+
+def test_missing_contracted_color_payload_cannot_authorize_grouping():
+    data = circuit()
+    data["color_contraction_payload"] = None
+    assert recurrence_structural_keys(**data) == {}
+
+
+def test_nonidentity_source_state_mapping_is_not_misinterpreted():
+    data = circuit()
+    data["remap"].source_state_offsets = (0, 2, 3)
+    data["remap"].source_state_indices = (1, 0, 0)
+    assert recurrence_structural_keys(**data) == {}
+
+
+def test_unreferenced_model_executors_do_not_block_process_proof():
+    data = circuit()
+    data["exact_sections"]["executors"].append(
+        [73, "finalization", "unused", [], 1, 0, None, "unknown-unused-intrinsic"]
+    )
+    assert key(**data) == key(**circuit())
+
+
+def test_source_record_digests_are_not_flavour_semantics():
+    data = circuit()
+    data["exact_sections"]["executors"].append(
+        [
+            1,
+            "source",
+            "initialize",
+            [],
+            1,
+            1,
+            None,
+            "rusticol.source-fill.scalar.v1:" + "a" * 24,
+        ]
+    )
+    data["exact_sections"]["row_groups"].append([0, 1, 0, 1, 0, 1])
+    changed = copy.deepcopy(data)
+    changed["exact_sections"]["executors"][1][7] = (
+        "rusticol.source-fill.scalar.v1:" + "b" * 24
+    )
+    assert key(**data) == key(**changed)
+    changed["exact_sections"]["executors"][1][7] = (
+        "rusticol.source-fill.scalar.v2:" + "b" * 24
+    )
+    assert recurrence_structural_keys(**changed) == {}
+
+
+def test_diagonal_closure_intrinsic_keeps_exact_coefficients():
+    data = circuit()
+    data["exact_sections"]["executors"].append(
+        [
+            1,
+            "closure",
+            "closure-add",
+            [1, 1],
+            1,
+            2,
+            None,
+            "rusticol.closure-reduce.v1:" + "a" * 24,
+        ]
+    )
+    data["exact_sections"]["row_groups"].append([0, 1, 0, 1, 0, 1])
+    changed = copy.deepcopy(data)
+    changed["exact_sections"]["exact_factors"][0][0] = -1
+    assert key(**data) != key(**changed)
+
+
+def test_parameter_cycles_do_not_authorize_grouping():
+    data = circuit()
+    data["ir"]["parameters"][2].update(expression="first", resolved_expression="first")
+    assert recurrence_structural_keys(**data) == {}
diff --git a/pyamplicol/tests/unit/test_wire_schemas.py b/pyamplicol/tests/unit/test_wire_schemas.py
new file mode 100644
index 0000000000..2aeb00934c
--- /dev/null
+++ b/pyamplicol/tests/unit/test_wire_schemas.py
@@ -0,0 +1,225 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import copy
+import json
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+import jsonschema
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def _schema(name: str) -> dict[str, object]:
+    return json.loads((ROOT / "schemas" / name).read_text(encoding="utf-8"))
+
+
+def test_wire_schemas_are_strict_and_versioned() -> None:
+    artifact = _schema("artifact-manifest-v3.schema.json")
+    physics = _schema("runtime-physics-v1.schema.json")
+
+    assert artifact["additionalProperties"] is False
+    assert artifact["properties"]["schema_version"]["const"] == 3
+    assert (
+        artifact["$defs"]["version_set"]["properties"]["runtime_physics"]["const"] == 1
+    )
+
+    assert physics["oneOf"] == [
+        {"$ref": "#/$defs/resolved_physics"},
+        {"$ref": "#/$defs/on_the_fly_public_metadata"},
+    ]
+    resolved = physics["$defs"]["resolved_physics"]
+    compact = physics["$defs"]["on_the_fly_public_metadata"]
+    assert resolved["additionalProperties"] is False
+    assert resolved["properties"]["schema_version"]["const"] == 1
+    assert resolved["properties"]["kind"]["const"] == (
+        "pyamplicol-resolved-physics"
+    )
+    assert compact["additionalProperties"] is False
+    assert compact["properties"]["kind"]["const"] == (
+        "pyamplicol-on-the-fly-public-metadata"
+    )
+    assert (
+        physics["$defs"]["selectors"]["properties"]["contracted_color"]["const"]
+        is False
+    )
+
+
+def test_runtime_physics_schema_accepts_only_strict_compact_otf_metadata() -> None:
+    physics = _schema("runtime-physics-v1.schema.json")
+    compact = {
+        "schema_version": 1,
+        "kind": "pyamplicol-on-the-fly-public-metadata",
+        "process_id": "six_fermions",
+        "process": "d d~ > u u~ u u~",
+        "color_accuracy": "lc",
+        "external_particles": [
+            {
+                "index": index,
+                "label": index + 1,
+                "particle": particle,
+                "pdg": pdg,
+                "role": "initial" if index < 2 else "final",
+                "momentum_slot": index,
+                "momentum_components": ["E", "px", "py", "pz"],
+            }
+            for index, (particle, pdg) in enumerate(
+                (
+                    ("d", 1),
+                    ("d~", -1),
+                    ("u", 2),
+                    ("u~", -2),
+                    ("u", 2),
+                    ("u~", -2),
+                )
+            )
+        ],
+        "model_parameters": [],
+    }
+    validator = jsonschema.Draft202012Validator(physics)
+    validator.validate(compact)
+
+    invented = copy.deepcopy(compact)
+    invented["helicities"] = []
+    assert list(validator.iter_errors(invented))
+
+
+def test_artifact_manifest_declares_security_critical_payload_fields() -> None:
+    artifact = _schema("artifact-manifest-v3.schema.json")
+    required = set(artifact["$defs"]["payload"]["required"])
+    assert {
+        "path",
+        "role",
+        "media_type",
+        "size_bytes",
+        "sha256",
+        "executable",
+    } <= required
+
+
+def _valid_manifest() -> dict[str, object]:
+    return {
+        "schema_version": 3,
+        "kind": "pyamplicol-process",
+        "artifact_id": "0" * 64,
+        "created_utc": "2026-07-15T14:43:42Z",
+        "producer": {
+            "distribution": "pyamplicol",
+            "version": "0.1.0",
+            "versions": {
+                "python_api": 1,
+                "toml": 1,
+                "compiled_model": 1,
+                "process_artifact": 3,
+                "runtime_physics": 1,
+                "symbolica_serialization": "test",
+                "c_abi": 1,
+            },
+            "target": {
+                "triple": "aarch64-apple-darwin",
+                "cpu_features": [],
+            },
+            "git_revision": "1" * 40,
+        },
+        "model": {
+            "name": "built-in-sm",
+            "source_kind": "built-in-sm",
+            "content_sha256": "2" * 64,
+            "compiled_schema_version": 1,
+        },
+        "configuration": {
+            "toml_schema_version": 1,
+            "requested_path": "config/requested.toml",
+            "effective_path": "config/effective.toml",
+            "adjustments": [],
+        },
+        "processes": [
+            {
+                "id": "dd_to_z",
+                "expression": "d d~ > z",
+                "color_accuracy": "lc",
+                "external_pdgs": [1, -1, 23],
+                "physics_path": "physics/dd_to_z.json",
+                "required_runtime_capabilities": ["symjit.application.complex-f64.v1"],
+                "aliases": [],
+            }
+        ],
+        "runtime": {
+            "engine": "rusticol",
+            "engine_version": "0.1.0",
+            "evaluator_manifest_path": "runtime/evaluators.json",
+            "api_bundle_path": None,
+            "required_runtime_capabilities": ["symjit.application.complex-f64.v1"],
+        },
+        "payloads": [
+            {
+                "path": "physics/dd_to_z.json",
+                "role": "runtime-physics",
+                "media_type": "application/json",
+                "size_bytes": 2,
+                "sha256": "3" * 64,
+                "executable": False,
+            },
+            {
+                "path": "process-groups.json",
+                "role": "process-groups",
+                "media_type": "application/json",
+                "size_bytes": 2,
+                "sha256": "4" * 64,
+                "executable": False,
+            },
+        ],
+        "dependencies": [],
+    }
+
+
+@pytest.mark.parametrize("source_kind", ("built-in-sm", "built-in-sm-heft"))
+def test_artifact_schema_accepts_a_positive_v3_manifest(source_kind: str) -> None:
+    manifest = _valid_manifest()
+    manifest["model"]["source_kind"] = source_kind
+    jsonschema.Draft202012Validator(
+        _schema("artifact-manifest-v3.schema.json")
+    ).validate(manifest)
+
+
+def test_artifact_schema_accepts_native_identity_without_git_revision() -> None:
+    manifest = _valid_manifest()
+    manifest["producer"].pop("git_revision")
+    manifest["producer"]["native_build_inputs_sha256"] = "3" * 64
+
+    jsonschema.Draft202012Validator(
+        _schema("artifact-manifest-v3.schema.json")
+    ).validate(manifest)
+
+
+@pytest.mark.parametrize(
+    "mutation",
+    (
+        lambda value: value["producer"].update(git_revision="4" * 64),
+        lambda value: value["producer"].update(
+            native_build_inputs_sha256="4" * 63 + "z"
+        ),
+        lambda value: value["payloads"][0].update(path="../escape"),
+        lambda value: value["payloads"][0].update(
+            role="configuration-requested",
+            executable=True,
+        ),
+        lambda value: value["payloads"][0].update(
+            role="evaluator-state",
+            executable=True,
+        ),
+    ),
+)
+def test_artifact_schema_rejects_security_contract_violations(
+    mutation: Callable[[dict[str, Any]], None],
+) -> None:
+    manifest = copy.deepcopy(_valid_manifest())
+    mutation(manifest)
+    validator = jsonschema.Draft202012Validator(
+        _schema("artifact-manifest-v3.schema.json")
+    )
+    assert list(validator.iter_errors(manifest))
diff --git a/pyamplicol/tests/unit/test_x86_performance_runtime_bundle.py b/pyamplicol/tests/unit/test_x86_performance_runtime_bundle.py
new file mode 100644
index 0000000000..da99c55fcb
--- /dev/null
+++ b/pyamplicol/tests/unit/test_x86_performance_runtime_bundle.py
@@ -0,0 +1,731 @@
+# SPDX-License-Identifier: 0BSD
+from __future__ import annotations
+
+import argparse
+import copy
+import hashlib
+import json
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+
+from tools.developer import compiled_mode_matrix as matrix
+from tools.developer import x86_performance_runtime_bundle as bundle
+
+
+def _write(path: Path, payload: object) -> Path:
+    path.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    return path
+
+
+def test_embedded_frozen_install_state_has_accepted_digest() -> None:
+    encoded = bundle.frozen_install_state_bytes()
+    assert hashlib.sha256(encoded).hexdigest() == (
+        bundle.FROZEN_INSTALL_STATE_SHA256
+    )
+    payload = json.loads(encoded)
+    assert payload["created_utc"] == "2026-07-24T16:52:37.275744+00:00"
+    assert payload["candidate_lock_sha256"] == (
+        bundle.FROZEN_CANDIDATE_LOCK_SHA256
+    )
+    assert payload["cargo_config_sha256"] == bundle.FROZEN_CARGO_CONFIG_SHA256
+    assert payload["sources"]["legacy-amplicol"]["revision"] == (
+        "79c96cecf2a722e50c3d2030b6894d755f96518a"
+    )
+
+
+def test_frozen_cargo_config_keeps_exact_path_dependent_digest() -> None:
+    assert Path("/private/tmp/pyamplicol-eager-compiled-arena-base-src") == (
+        bundle.FROZEN_SOURCE_ROOT
+    )
+    encoded = bundle.frozen_cargo_config_bytes()
+    assert hashlib.sha256(encoded).hexdigest() == (
+        bundle.FROZEN_CARGO_CONFIG_SHA256
+    )
+    assert encoded.count(bytes(bundle.FROZEN_SOURCE_ROOT)) == 4
+    relocated = encoded.replace(
+        bytes(bundle.FROZEN_SOURCE_ROOT),
+        b"/tmp/pyamplicol-eager-compiled-arena-base-src",
+    )
+    assert hashlib.sha256(relocated).hexdigest() == (
+        "f8aa48f1643251904cd1268d648a5741b4909f678fc4964e0538594165064d29"
+    )
+
+
+def test_freeze_baseline_requires_exact_path_revision_and_generated_inputs(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = tmp_path / "baseline"
+    dependencies = source / "dependencies"
+    dependencies.mkdir(parents=True)
+    lock = dependencies / "candidate-Cargo.lock"
+    config = dependencies / "candidate-cargo-config.toml"
+    lock.write_bytes(b"lock")
+    config.write_bytes(b"config")
+    for relative in bundle._BASELINE_BOOTSTRAP_ROOTS:
+        (source / relative).mkdir(parents=True)
+    (source / ".venv/bin").mkdir()
+    (source / ".venv/bin/python").write_bytes(b"python")
+    (source / "dependencies/checkouts/symbolica").mkdir(parents=True)
+    (source / "dependencies/checkouts/symbolica/file").write_bytes(b"checkout")
+    (source / "dependencies/wheelhouse/dependency.whl").write_bytes(b"wheel")
+    monkeypatch.setattr(bundle, "FROZEN_SOURCE_ROOT", source.resolve())
+    monkeypatch.setattr(
+        bundle,
+        "FROZEN_CANDIDATE_LOCK_SHA256",
+        hashlib.sha256(b"lock").hexdigest(),
+    )
+    monkeypatch.setattr(
+        bundle,
+        "FROZEN_CARGO_CONFIG_SHA256",
+        hashlib.sha256(b"config").hexdigest(),
+    )
+    monkeypatch.setattr(bundle, "frozen_cargo_config_bytes", lambda: b"config")
+    frozen = dict(bundle.FROZEN_INSTALL_STATE)
+    frozen["candidate_lock_sha256"] = bundle.FROZEN_CANDIDATE_LOCK_SHA256
+    frozen["cargo_config_sha256"] = bundle.FROZEN_CARGO_CONFIG_SHA256
+    monkeypatch.setattr(bundle, "FROZEN_INSTALL_STATE", frozen)
+    encoded = bundle.frozen_install_state_bytes()
+    (dependencies / "install-state.json").write_bytes(encoded)
+    monkeypatch.setattr(
+        bundle,
+        "FROZEN_INSTALL_STATE_SHA256",
+        hashlib.sha256(encoded).hexdigest(),
+    )
+    def git_output(_root: Path, *arguments: str) -> str:
+        if arguments[:2] == ("rev-parse", "--verify"):
+            return matrix.FROZEN_BASELINE_SOURCE_REVISION + "\n"
+        if arguments[:1] == ("status",):
+            return ""
+        if arguments[:1] == ("ls-files",):
+            return "\0".join(
+                (
+                    *bundle._BASELINE_GENERATED_FILES,
+                    ".venv/bin/python",
+                    "dependencies/checkouts/symbolica/file",
+                    "dependencies/wheelhouse/dependency.whl",
+                    "",
+                )
+            )
+        raise AssertionError(arguments)
+
+    monkeypatch.setattr(bundle, "_git_output", git_output)
+    result = bundle.freeze_baseline(source)
+    assert result["passes"] is True
+    bundle._require_content_identity(result)
+    assert (dependencies / "install-state.json").read_bytes() == encoded
+
+    config.write_bytes(b"changed")
+    with pytest.raises(bundle.BundleError, match="dependency inputs differ"):
+        bundle.freeze_baseline(source)
+
+
+def _installation(source: str, inputs: str, marker: str) -> dict[str, object]:
+    return {
+        "package_version": "0.1.0.dev0+candidate.test",
+        "build_info": {
+            "source_revision": source,
+            "native_build_inputs_sha256": inputs,
+            "publishable": False,
+        },
+        "build_info_sha256": marker * 64,
+        "distribution_content": {
+            "algorithm": "sha256-relative-path-size-content-v1",
+            "sha256": marker * 64,
+            "file_count": 10,
+            "size_bytes": 100,
+        },
+        "native_module": {
+            "relative_path": "pyamplicol/_rusticol.abi3.so",
+            "sha256": marker * 64,
+            "size_bytes": 50,
+        },
+    }
+
+
+def _baseline_attestation() -> dict[str, object]:
+    generated_sha256 = {
+        "dependencies/candidate-Cargo.lock": (
+            bundle.FROZEN_CANDIDATE_LOCK_SHA256
+        ),
+        "dependencies/candidate-cargo-config.toml": (
+            bundle.FROZEN_CARGO_CONFIG_SHA256
+        ),
+        "dependencies/install-state.json": bundle.FROZEN_INSTALL_STATE_SHA256,
+    }
+    ignored_paths = sorted(
+        (
+            *bundle._BASELINE_GENERATED_FILES,
+            ".venv/bin/python",
+            "dependencies/checkouts/symbolica/file",
+            "dependencies/wheelhouse/dependency.whl",
+        )
+    )
+    return bundle._attach_content_identity(
+        {
+            "kind": bundle.BASELINE_ATTESTATION_KIND,
+            "schema_version": bundle.SCHEMA_VERSION,
+            "source_root": str(bundle.FROZEN_SOURCE_ROOT),
+            "source_revision": matrix.FROZEN_BASELINE_SOURCE_REVISION,
+            "native_build_inputs_sha256": (
+                matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256
+            ),
+            "candidate_lock_sha256": bundle.FROZEN_CANDIDATE_LOCK_SHA256,
+            "cargo_config_sha256": bundle.FROZEN_CARGO_CONFIG_SHA256,
+            "install_state_sha256": bundle.FROZEN_INSTALL_STATE_SHA256,
+            "source_inventory": {
+                "tracked_and_untracked_status_clean": True,
+                "ignored_entry_count": len(ignored_paths),
+                "ignored_relative_paths": ignored_paths,
+                "ignored_paths_sha256": bundle._canonical_sha256(ignored_paths),
+                "ignored_entries_by_bootstrap_root": {
+                    relative.rstrip("/"): sum(
+                        path.startswith(relative) for path in ignored_paths
+                    )
+                    for relative in bundle._BASELINE_BOOTSTRAP_ROOTS
+                },
+                "allowed_generated_files": list(bundle._BASELINE_GENERATED_FILES),
+                "allowed_bootstrap_roots": list(bundle._BASELINE_BOOTSTRAP_ROOTS),
+                "unexpected_ignored_files": [],
+            },
+            "generated_identity": {
+                "generated_files": {
+                    relative: {
+                        "relative_path": relative,
+                        "size_bytes": 1,
+                        "sha256": generated_sha256[relative],
+                    }
+                    for relative in bundle._BASELINE_GENERATED_FILES
+                },
+                "bootstrap_trees": {
+                    relative.rstrip("/"): {
+                        "algorithm": "sha256-relative-path-size-content-v1",
+                        "relative_path": relative.rstrip("/"),
+                        "sha256": "a" * 64,
+                        "file_count": 1,
+                        "size_bytes": 1,
+                    }
+                    for relative in bundle._BASELINE_BOOTSTRAP_ROOTS
+                },
+            },
+            "passes": True,
+        }
+    )
+
+
+def _set_ignored_inventory(
+    body: dict[str, object],
+    paths: list[str],
+) -> None:
+    inventory = body["source_inventory"]
+    assert isinstance(inventory, dict)
+    inventory["ignored_entry_count"] = len(paths)
+    inventory["ignored_relative_paths"] = paths
+    inventory["ignored_paths_sha256"] = bundle._canonical_sha256(paths)
+    inventory["ignored_entries_by_bootstrap_root"] = {
+        relative.rstrip("/"): sum(path.startswith(relative) for path in paths)
+        for relative in bundle._BASELINE_BOOTSTRAP_ROOTS
+    }
+
+
+def _manifest_arguments(tmp_path: Path) -> argparse.Namespace:
+    root = tmp_path / "bundle"
+    for lane in ("baseline", "current"):
+        directory = root / "wheels" / lane
+        directory.mkdir(parents=True)
+        (directory / f"{lane}.whl").write_bytes(lane.encode())
+    prepared = root / "prepared-models" / "ufo-sm-jit-o2.pyamplicol-model"
+    prepared.parent.mkdir(parents=True)
+    prepared.write_bytes(b"prepared")
+    attestation = _baseline_attestation()
+    (root / "frozen-baseline-attestation.json").write_text(
+        json.dumps(attestation, sort_keys=True, allow_nan=False),
+        encoding="utf-8",
+    )
+    return argparse.Namespace(
+        bundle_root=root,
+        baseline_python=Path("/runtime/baseline/python"),
+        current_python=Path("/runtime/current/python"),
+        dependency_site=Path("/runtime/dependencies"),
+        workflow_run_id="4242",
+        expected_current_revision="a" * 40,
+        expected_current_native_inputs_sha256="b" * 64,
+        output=tmp_path / "manifest.json",
+    )
+
+
+def test_manifest_binds_binaries_dependencies_and_prepared_model(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    arguments = _manifest_arguments(tmp_path)
+    installations = {
+        str(arguments.baseline_python): _installation(
+            matrix.FROZEN_BASELINE_SOURCE_REVISION,
+            matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256,
+            "c",
+        ),
+        str(arguments.current_python): _installation(
+            arguments.expected_current_revision,
+            arguments.expected_current_native_inputs_sha256,
+            "d",
+        ),
+    }
+    monkeypatch.setattr(
+        bundle,
+        "_installation",
+        lambda path: installations[str(path)],
+    )
+    dependency = {
+        "algorithm": "deps-v1",
+        "sha256": "e" * 64,
+        "distributions": {},
+    }
+    monkeypatch.setattr(bundle, "_stable_dependency_site", lambda _path: dependency)
+    monkeypatch.setattr(bundle.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(bundle.platform, "machine", lambda: "x86_64")
+    payload = bundle.create_manifest(arguments)
+    assert payload["passes"] is True
+    assert payload["installations"]["baseline"] == installations[
+        str(arguments.baseline_python)
+    ]
+    assert payload["dependency_site"] == dependency
+    bundle._require_content_identity(payload)
+
+    verify = argparse.Namespace(
+        **{
+            key: value
+            for key, value in vars(arguments).items()
+            if key
+            not in {
+                "expected_current_native_inputs_sha256",
+                "output",
+            }
+        },
+        manifest=arguments.output,
+    )
+    result = bundle.verify_manifest(verify)
+    assert result["passes"] is True
+    assert result["manifest_content_sha256"] == payload["content_identity"]["sha256"]
+
+    wheel = arguments.bundle_root / "wheels" / "current" / "current.whl"
+    wheel.write_bytes(b"tampered")
+    with pytest.raises(bundle.BundleError, match="files differ"):
+        bundle.verify_manifest(verify)
+
+
+def test_manifest_rejects_wrong_frozen_or_current_source(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    arguments = _manifest_arguments(tmp_path)
+    monkeypatch.setattr(bundle.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(bundle.platform, "machine", lambda: "x86_64")
+    monkeypatch.setattr(
+        bundle,
+        "_installation",
+        lambda _path: _installation("f" * 40, "0" * 64, "1"),
+    )
+    with pytest.raises(bundle.BundleError, match="baseline installed build"):
+        bundle.create_manifest(arguments)
+
+
+def test_content_identity_rejects_manifest_tampering() -> None:
+    payload = bundle._attach_content_identity({"passes": True, "value": 1})
+    bundle._require_content_identity(payload)
+    payload["value"] = 2
+    with pytest.raises(bundle.BundleError, match="content identity"):
+        bundle._require_content_identity(payload)
+    payload = bundle._attach_content_identity({"passes": True, "value": 1})
+    payload["content_identity"]["unexpected"] = True
+    with pytest.raises(bundle.BundleError, match="content identity"):
+        bundle._require_content_identity(payload)
+
+
+def test_baseline_attestation_rejects_unknown_root_field(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "bundle"
+    root.mkdir()
+    payload = _baseline_attestation()
+    body = copy.deepcopy(payload)
+    body.pop("content_identity")
+    body["unexpected"] = True
+    _write(
+        root / "frozen-baseline-attestation.json",
+        bundle._attach_content_identity(body),
+    )
+    with pytest.raises(bundle.BundleError, match="attestation is invalid"):
+        bundle._baseline_attestation_inventory(root)
+
+
+@pytest.mark.parametrize(
+    ("field", "operation"),
+    [
+        ("allowed_generated_files", "missing"),
+        ("allowed_generated_files", "extra"),
+        ("allowed_generated_files", "wrong-type"),
+        ("allowed_bootstrap_roots", "missing"),
+        ("allowed_bootstrap_roots", "extra"),
+        ("allowed_bootstrap_roots", "wrong-type"),
+    ],
+)
+def test_baseline_attestation_rejects_inexact_allowed_inventories(
+    tmp_path: Path,
+    field: str,
+    operation: str,
+) -> None:
+    root = tmp_path / "bundle"
+    root.mkdir()
+    payload = _baseline_attestation()
+    body = copy.deepcopy(payload)
+    body.pop("content_identity")
+    inventory = body["source_inventory"]
+    assert isinstance(inventory, dict)
+    value = inventory[field]
+    assert isinstance(value, list)
+    if operation == "missing":
+        inventory[field] = value[:-1]
+    elif operation == "extra":
+        inventory[field] = [*value, "unexpected/"]
+    else:
+        inventory[field] = "not-a-list"
+    _write(
+        root / "frozen-baseline-attestation.json",
+        bundle._attach_content_identity(body),
+    )
+    with pytest.raises(bundle.BundleError, match="attestation is invalid"):
+        bundle._baseline_attestation_inventory(root)
+
+
+def test_baseline_attestation_rejects_wrong_ignored_entry_count(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "bundle"
+    root.mkdir()
+    payload = _baseline_attestation()
+    body = copy.deepcopy(payload)
+    body.pop("content_identity")
+    body["source_inventory"]["ignored_entry_count"] += 1
+    _write(
+        root / "frozen-baseline-attestation.json",
+        bundle._attach_content_identity(body),
+    )
+    with pytest.raises(bundle.BundleError, match="attestation is invalid"):
+        bundle._baseline_attestation_inventory(root)
+
+
+@pytest.mark.parametrize(
+    "mutation",
+    [
+        "digest",
+        "unsorted",
+        "duplicate",
+        "outside",
+        "missing-generated",
+        "root-count",
+    ],
+)
+def test_baseline_attestation_rejects_inexact_ignored_path_inventory(
+    tmp_path: Path,
+    mutation: str,
+) -> None:
+    root = tmp_path / "bundle"
+    root.mkdir()
+    payload = _baseline_attestation()
+    body = copy.deepcopy(payload)
+    body.pop("content_identity")
+    inventory = body["source_inventory"]
+    paths = list(inventory["ignored_relative_paths"])
+    if mutation == "digest":
+        inventory["ignored_paths_sha256"] = "0" * 64
+    elif mutation == "unsorted":
+        _set_ignored_inventory(body, list(reversed(paths)))
+    elif mutation == "duplicate":
+        _set_ignored_inventory(body, [*paths, paths[-1]])
+    elif mutation == "outside":
+        _set_ignored_inventory(body, sorted((*paths, "src/unexpected.py")))
+    elif mutation == "missing-generated":
+        _set_ignored_inventory(
+            body,
+            [path for path in paths if path != bundle._BASELINE_GENERATED_FILES[0]],
+        )
+    else:
+        counts = inventory["ignored_entries_by_bootstrap_root"]
+        first_root = next(iter(counts))
+        counts[first_root] += 1
+    _write(
+        root / "frozen-baseline-attestation.json",
+        bundle._attach_content_identity(body),
+    )
+    with pytest.raises(bundle.BundleError, match="attestation is invalid"):
+        bundle._baseline_attestation_inventory(root)
+
+
+def test_baseline_attestation_keeps_git_and_tree_counts_independent(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "bundle"
+    root.mkdir()
+    payload = _baseline_attestation()
+    body = copy.deepcopy(payload)
+    body.pop("content_identity")
+    ignored_paths = sorted(
+        (
+            *bundle._BASELINE_GENERATED_FILES,
+            ".venv/bin/python",
+            "dependencies/checkouts/gammaloop/",
+            *(
+                f"dependencies/checkouts/entry-{index:03d}"
+                for index in range(175)
+            ),
+            "dependencies/wheelhouse/dependency.whl",
+        )
+    )
+    _set_ignored_inventory(body, ignored_paths)
+    body["generated_identity"]["bootstrap_trees"][
+        "dependencies/checkouts"
+    ]["file_count"] = 6631
+    _write(
+        root / "frozen-baseline-attestation.json",
+        bundle._attach_content_identity(body),
+    )
+    result = bundle._baseline_attestation_inventory(root)
+    assert result["content_sha256"]
+
+
+def test_ignored_inventory_path_normalization_allows_directory_markers() -> None:
+    assert bundle._valid_ignored_relative_path(
+        "dependencies/checkouts/gammaloop/"
+    )
+    for invalid in (
+        "dependencies/checkouts/gammaloop//",
+        "dependencies/./checkouts/gammaloop/",
+        "dependencies/../checkouts/gammaloop/",
+        "/dependencies/checkouts/gammaloop/",
+        ".",
+        "../",
+    ):
+        assert not bundle._valid_ignored_relative_path(invalid)
+
+
+@pytest.mark.parametrize(
+    ("section", "operation"),
+    [
+        ("generated_files", "missing"),
+        ("generated_files", "extra"),
+        ("generated_files", "wrong-type"),
+        ("bootstrap_trees", "missing"),
+        ("bootstrap_trees", "extra"),
+        ("bootstrap_trees", "wrong-type"),
+    ],
+)
+def test_baseline_attestation_rejects_inexact_generated_identities(
+    tmp_path: Path,
+    section: str,
+    operation: str,
+) -> None:
+    root = tmp_path / "bundle"
+    root.mkdir()
+    payload = _baseline_attestation()
+    body = copy.deepcopy(payload)
+    body.pop("content_identity")
+    generated_identity = body["generated_identity"]
+    assert isinstance(generated_identity, dict)
+    identities = generated_identity[section]
+    assert isinstance(identities, dict)
+    first_key = next(iter(identities))
+    if operation == "missing":
+        identities.pop(first_key)
+    elif operation == "extra":
+        identities["unexpected"] = copy.deepcopy(identities[first_key])
+    else:
+        identities[first_key] = []
+    _write(
+        root / "frozen-baseline-attestation.json",
+        bundle._attach_content_identity(body),
+    )
+    with pytest.raises(bundle.BundleError, match="attestation is invalid"):
+        bundle._baseline_attestation_inventory(root)
+
+
+@pytest.mark.parametrize(
+    ("section", "field", "value"),
+    [
+        ("generated_files", "relative_path", "wrong/path"),
+        ("generated_files", "size_bytes", 0),
+        ("generated_files", "sha256", "0" * 64),
+        ("bootstrap_trees", "algorithm", "wrong-algorithm"),
+        ("bootstrap_trees", "relative_path", "wrong/path"),
+        ("bootstrap_trees", "sha256", "not-a-sha256"),
+        ("bootstrap_trees", "file_count", 0),
+        ("bootstrap_trees", "size_bytes", 0),
+    ],
+)
+def test_baseline_attestation_rejects_invalid_identity_fields(
+    tmp_path: Path,
+    section: str,
+    field: str,
+    value: object,
+) -> None:
+    root = tmp_path / "bundle"
+    root.mkdir()
+    payload = _baseline_attestation()
+    body = copy.deepcopy(payload)
+    body.pop("content_identity")
+    identities = body["generated_identity"][section]
+    first_key = next(iter(identities))
+    identities[first_key][field] = value
+    _write(
+        root / "frozen-baseline-attestation.json",
+        bundle._attach_content_identity(body),
+    )
+    with pytest.raises(bundle.BundleError, match="attestation is invalid"):
+        bundle._baseline_attestation_inventory(root)
+
+
+def test_file_identity_rejects_symlink(tmp_path: Path) -> None:
+    target = tmp_path / "target.whl"
+    target.write_bytes(b"wheel")
+    link = tmp_path / "link.whl"
+    link.symlink_to(target)
+    with pytest.raises(bundle.BundleError, match="non-symlink"):
+        bundle._file_identity(link)
+
+
+def test_checked_manifest_rejects_duplicate_and_nonfinite_json(
+    tmp_path: Path,
+) -> None:
+    duplicate = tmp_path / "duplicate.json"
+    duplicate.write_text('{"kind":"a","kind":"b"}', encoding="utf-8")
+    with pytest.raises(bundle.BundleError, match="duplicate JSON key"):
+        bundle._checked_manifest(duplicate)
+    nonfinite = tmp_path / "nonfinite.json"
+    nonfinite.write_text('{"value":NaN}', encoding="utf-8")
+    with pytest.raises(bundle.BundleError, match="non-finite"):
+        bundle._checked_manifest(nonfinite)
+
+
+def test_wheel_inventory_rejects_untracked_extra_file(tmp_path: Path) -> None:
+    root = tmp_path / "bundle"
+    for lane in ("baseline", "current"):
+        directory = root / "wheels" / lane
+        directory.mkdir(parents=True)
+        (directory / f"{lane}.whl").write_bytes(lane.encode())
+    (root / "wheels" / "current" / "unexpected.txt").write_text(
+        "unexpected\n",
+        encoding="utf-8",
+    )
+    with pytest.raises(bundle.BundleError, match="exactly one file"):
+        bundle._wheel_inventory(root)
+
+
+def test_freeze_baseline_rejects_dirty_source(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = tmp_path / "baseline"
+    source.mkdir()
+    monkeypatch.setattr(bundle, "FROZEN_SOURCE_ROOT", source.resolve())
+    monkeypatch.setattr(
+        bundle,
+        "FROZEN_CARGO_CONFIG_SHA256",
+        hashlib.sha256(bundle.frozen_cargo_config_bytes()).hexdigest(),
+    )
+
+    def git_output(_root: Path, *arguments: str) -> str:
+        if arguments[:2] == ("rev-parse", "--verify"):
+            return matrix.FROZEN_BASELINE_SOURCE_REVISION + "\n"
+        if arguments[:1] == ("status",):
+            return " M src/pyamplicol/runtime.py\n"
+        return ""
+
+    monkeypatch.setattr(bundle, "_git_output", git_output)
+    with pytest.raises(bundle.BundleError, match="source changes"):
+        bundle.freeze_baseline(source)
+
+
+def test_materialize_runtime_reconstructs_both_lanes_without_network(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    checkout = tmp_path / "logical-checkout"
+    checkout.mkdir()
+    monkeypatch.setattr(bundle, "ROOT", checkout)
+    bundle_root = tmp_path / "bundle"
+    dependencies = bundle_root / "dependency-site"
+    dependencies.mkdir(parents=True)
+    (dependencies / "dependency.py").write_text("VALUE = 1\n", encoding="utf-8")
+    for lane in ("baseline", "current"):
+        wheel = bundle_root / "wheels" / lane / f"{lane}.whl"
+        wheel.parent.mkdir(parents=True)
+        wheel.write_bytes(lane.encode())
+    runtime_root = tmp_path / "runtime"
+
+    class FakeBuilder:
+        def __init__(self, **_kwargs: Any) -> None:
+            pass
+
+        def create(self, path: Path) -> None:
+            (path / "bin").mkdir(parents=True)
+            (path / "bin" / "python").write_bytes(b"python")
+
+    def fake_purelib(python: Path) -> Path:
+        site = python.parents[1] / "site-packages"
+        site.mkdir()
+        return site
+
+    monkeypatch.setattr(bundle.venv, "EnvBuilder", FakeBuilder)
+    monkeypatch.setattr(bundle, "_venv_purelib", fake_purelib)
+    monkeypatch.setattr(
+        bundle,
+        "_stable_dependency_site",
+        lambda _path: {"sha256": "a" * 64},
+    )
+    monkeypatch.setattr(
+        bundle,
+        "_installation",
+        lambda python: {"python": str(python), "passes": True},
+    )
+    monkeypatch.setattr(
+        bundle.subprocess,
+        "run",
+        lambda *_args, **_kwargs: SimpleNamespace(
+            returncode=0,
+            stdout="",
+            stderr="",
+        ),
+    )
+    result = bundle.materialize_runtime(bundle_root, runtime_root)
+    assert result["passes"] is True
+    assert set(result["lanes"]) == {"baseline", "current"}
+    for lane in ("baseline", "current"):
+        site = runtime_root / lane / "site-packages"
+        assert (site / "dependency.py").read_text(encoding="utf-8") == "VALUE = 1\n"
+
+
+def test_materialize_runtime_rejects_nonempty_destination(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    checkout = tmp_path / "logical-checkout"
+    checkout.mkdir()
+    monkeypatch.setattr(bundle, "ROOT", checkout)
+    bundle_root = tmp_path / "bundle"
+    dependencies = bundle_root / "dependency-site"
+    dependencies.mkdir(parents=True)
+    for lane in ("baseline", "current"):
+        wheel = bundle_root / "wheels" / lane / f"{lane}.whl"
+        wheel.parent.mkdir(parents=True)
+        wheel.write_bytes(lane.encode())
+    runtime_root = tmp_path / "runtime"
+    runtime_root.mkdir()
+    (runtime_root / "stale").write_text("stale\n", encoding="utf-8")
+    with pytest.raises(bundle.BundleError, match="must be empty"):
+        bundle.materialize_runtime(bundle_root, runtime_root)
diff --git a/pyamplicol/tests/unit/test_x86_portable_performance_acceptance.py b/pyamplicol/tests/unit/test_x86_portable_performance_acceptance.py
new file mode 100644
index 0000000000..01e70a8fa2
--- /dev/null
+++ b/pyamplicol/tests/unit/test_x86_portable_performance_acceptance.py
@@ -0,0 +1,430 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import json
+import statistics
+from pathlib import Path
+
+import pytest
+
+from tools.developer import arena_native_x86_acceptance as native
+from tools.developer import compiled_mode_matrix as matrix
+from tools.developer import compiled_mode_matrix_x86 as matrix_x86
+from tools.developer import x86_portable_performance_acceptance as portable
+from tools.developer import x86_qq_recurrence_acceptance as qq
+
+REVISION = "a" * 40
+WORKFLOW_RUN_ID = "987654321"
+NATIVE_INPUTS = "b" * 64
+RUNTIME_BUNDLE = "c" * 64
+NATIVE_MODULE = "d" * 64
+
+
+def _write(path: Path, payload: object) -> Path:
+    path.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    return path
+
+
+def _native() -> dict[str, object]:
+    evidence = {
+        name: {"semantic_validation": {"passes": True}}
+        for name in (
+            "runtime_preflight",
+            "compiled_all_jit",
+            "four_quark",
+            "eager_compiled_color",
+        )
+    }
+    return native._attach_content_identity(
+        {
+            "kind": native.ACCEPTANCE_KIND,
+            "schema_version": native.SCHEMA_VERSION,
+            "status": "ok",
+            "passes": True,
+            "request": {
+                "expected_revision": REVISION,
+                "expected_target": native.EXPECTED_TARGET,
+                "point_count": native.EXPECTED_POINT_COUNT,
+            },
+            "source_identity": {
+                "all_match": True,
+                "audit": {"revision": REVISION, "dirty": False},
+            },
+            "runtime_identity": {
+                "all_match": True,
+                "audit": {
+                    "active_build_info": {
+                        "payload": {
+                            "source_revision": REVISION,
+                            "native_build_inputs_sha256": NATIVE_INPUTS,
+                            "publishable": False,
+                        }
+                    },
+                    "native_extension": {
+                        "target": native.EXPECTED_TARGET,
+                        "build_inputs_sha256": NATIVE_INPUTS,
+                        "sha256": NATIVE_MODULE,
+                    },
+                },
+            },
+            "evidence": evidence,
+            "validation": {
+                "exact_source_revision": True,
+                "source_clean_preflight_and_postflight": True,
+                "source_only_python_runtime": True,
+                "native_linux_x86_64_target": True,
+            },
+        }
+    )
+
+
+def _matrix() -> dict[str, object]:
+    passing_gate = {"passes": True}
+    return matrix_x86._attach_content_identity(
+        {
+            "kind": matrix_x86.AGGREGATE_KIND,
+            "schema_version": matrix_x86.SCHEMA_VERSION,
+            "matrix_contract": matrix.MATRIX_CONTRACT,
+            "workflow_run_id": WORKFLOW_RUN_ID,
+            "runtime_bundle_sha256": RUNTIME_BUNDLE,
+            "expected_current_source_revision": REVISION,
+            "expected_builds": {
+                "current": {
+                    "source_revision": REVISION,
+                    "native_build_inputs_sha256": NATIVE_INPUTS,
+                    "native_module_sha256": NATIVE_MODULE,
+                }
+            },
+            "shard_gate": {"errors": [], "passes": True},
+            "matrix_audit": {
+                "complete": True,
+                "passes": True,
+                "coverage": {
+                    "expected": 168,
+                    "observed": 168,
+                    "missing": [],
+                    "unexpected": [],
+                    "passes": True,
+                },
+                "cell_gate": dict(passing_gate),
+                "identity_gate": dict(passing_gate),
+                "gain_gate": {
+                    "required_relative_gain": 0.1,
+                    "passes": True,
+                },
+                "generation_gate": {
+                    "maximum_geometric_mean": 1.05,
+                    "geometric_mean_current_over_baseline": 1.01,
+                    "passes": True,
+                },
+            },
+            "complete": True,
+            "passes": True,
+        }
+    )
+
+
+def _qq() -> dict[str, object]:
+    captures = {}
+    for role in qq.CAPTURE_CONTRACTS:
+        cells = []
+        for batch_size in qq.PERFORMANCE_BATCH_SIZES:
+            recurrence = [0.001 for _ in range(7)]
+            ratios = [1.0 + index * 0.01 for index in range(7)]
+            compiled = [
+                denominator * ratio
+                for denominator, ratio in zip(
+                    recurrence,
+                    ratios,
+                    strict=True,
+                )
+            ]
+            median = statistics.median(ratios)
+            raw_mad = statistics.median(
+                abs(value - median) for value in ratios
+            )
+            cells.append(
+                {
+                    "batch_size": batch_size,
+                    "pairing": "same-interleaved-schedule-round-v1",
+                    "sample_count": 7,
+                    "compiled_wall_seconds_per_point_by_round": compiled,
+                    "recurrence_wall_seconds_per_point_by_round": recurrence,
+                    "compiled_over_recurrence_ratios_by_round": ratios,
+                    "ratio_statistics": {
+                        "contract": "median-and-raw-mad-v1",
+                        "median": median,
+                        "raw_mad": raw_mad,
+                        "upper_three_raw_mad": median + 3.0 * raw_mad,
+                    },
+                    "ceiling": 1.15,
+                    "passes": True,
+                }
+            )
+        contract = qq.CAPTURE_CONTRACTS[role]
+        captures[role] = {
+            "source_revision": REVISION,
+            "runtime_provenance_sha256": "e" * 64,
+            "model": {"kind": contract["model"]},
+            "layout": contract["layout"],
+            "workload": contract["workload"],
+            "numerical_validation": {
+                "contract": "recomputed-recurrence-z6g-pairwise-and-resolved-v1",
+                "passes": True,
+            },
+            "performance_cells": cells,
+            "passes": True,
+        }
+    return qq._attach_content_identity(
+        {
+            "kind": qq.RESULT_KIND,
+            "schema_version": qq.SCHEMA_VERSION,
+            "workflow_run_id": WORKFLOW_RUN_ID,
+            "target": native.EXPECTED_TARGET,
+            "expected_current_revision": REVISION,
+            "runtime_bundle": {"content_sha256": RUNTIME_BUNDLE},
+            "policy": {
+                "required_capture_roles": list(qq.CAPTURE_CONTRACTS),
+                "required_modes": list(qq.REQUIRED_MODES),
+                "required_batch_sizes": list(qq.REQUIRED_BATCH_SIZES),
+                "performance_batch_sizes": list(qq.PERFORMANCE_BATCH_SIZES),
+                "minimum_target_runtime_seconds_per_worker": 5.0,
+                "subprocess_samples_per_cell": 7,
+                "native_wall_blocks_per_worker": 7,
+                "warmup_runs": 2,
+                "numerical_validation_samples": 10,
+                "diagnostic_shortcuts_allowed": False,
+                "compiled_over_recurrence_ratio_ceiling": 1.15,
+                "ratio_gate": (
+                    "median-plus-three-raw-mad-at-or-below-ceiling-v1"
+                ),
+            },
+            "captures": captures,
+            "performance_cell_count": 8,
+            "passes": True,
+        }
+    )
+
+
+@pytest.fixture
+def inputs(tmp_path: Path) -> tuple[Path, Path, Path]:
+    return (
+        _write(tmp_path / "native.json", _native()),
+        _write(tmp_path / "matrix.json", _matrix()),
+        _write(tmp_path / "qq.json", _qq()),
+    )
+
+
+def _audit(inputs: tuple[Path, Path, Path]) -> dict[str, object]:
+    native_path, matrix_path, qq_path = inputs
+    return portable.audit(
+        native_acceptance=native_path,
+        matrix_acceptance=matrix_path,
+        qq_acceptance=qq_path,
+        workflow_run_id=WORKFLOW_RUN_ID,
+        expected_revision=REVISION,
+    )
+
+
+def test_combines_exact_content_addressed_inputs_portably(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    result = _audit(inputs)
+    assert result["passes"] is True
+    assert result["bindings"] == {
+        "same_source_revision": True,
+        "same_native_build_inputs": True,
+        "same_native_module": True,
+        "same_performance_runtime_bundle": True,
+    }
+    assert str(inputs[0].parent) not in json.dumps(result)
+    identity = result["content_identity"]
+    body = dict(result)
+    body.pop("content_identity")
+    assert identity["sha256"] == portable._canonical_sha256(body)
+
+
+def test_rejects_different_native_build_inputs(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = _matrix()
+    body = dict(payload)
+    body.pop("content_identity")
+    body["expected_builds"]["current"]["native_build_inputs_sha256"] = "0" * 64
+    _write(matrix_path, matrix_x86._attach_content_identity(body))
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="different native build inputs",
+    ):
+        _audit((native_path, matrix_path, qq_path))
+
+
+def test_rejects_missing_native_identity_digests(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = _native()
+    body = dict(payload)
+    body.pop("content_identity")
+    runtime = body["runtime_identity"]["audit"]
+    runtime["active_build_info"]["payload"].pop("native_build_inputs_sha256")
+    runtime["native_extension"].pop("build_inputs_sha256")
+    runtime["native_extension"].pop("sha256")
+    _write(native_path, native._attach_content_identity(body))
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="identity digests are invalid",
+    ):
+        _audit((native_path, matrix_path, qq_path))
+
+
+def test_rejects_missing_matrix_identity_digests(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = _matrix()
+    body = dict(payload)
+    body.pop("content_identity")
+    current = body["expected_builds"]["current"]
+    current.pop("native_build_inputs_sha256")
+    current.pop("native_module_sha256")
+    body.pop("runtime_bundle_sha256")
+    _write(matrix_path, matrix_x86._attach_content_identity(body))
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="matrix current build identity drifted",
+    ):
+        _audit((native_path, matrix_path, qq_path))
+
+
+def test_rejects_non_lowercase_identity_digest(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = _native()
+    body = dict(payload)
+    body.pop("content_identity")
+    runtime = body["runtime_identity"]["audit"]
+    runtime["native_extension"]["sha256"] = "A" * 64
+    _write(native_path, native._attach_content_identity(body))
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="identity digests are invalid",
+    ):
+        _audit((native_path, matrix_path, qq_path))
+
+
+def test_rejects_different_performance_runtime_bundles(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = _qq()
+    body = dict(payload)
+    body.pop("content_identity")
+    body["runtime_bundle"]["content_sha256"] = "0" * 64
+    _write(qq_path, qq._attach_content_identity(body))
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="different runtime bundles",
+    ):
+        _audit((native_path, matrix_path, qq_path))
+
+
+def test_rejects_missing_qq_runtime_bundle_digest(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = _qq()
+    body = dict(payload)
+    body.pop("content_identity")
+    body["runtime_bundle"].pop("content_sha256")
+    _write(qq_path, qq._attach_content_identity(body))
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="runtime bundle digest is absent",
+    ):
+        _audit((native_path, matrix_path, qq_path))
+
+
+def test_rejects_duplicate_qq_batch_and_missing_1024(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = _qq()
+    body = dict(payload)
+    body.pop("content_identity")
+    cells = body["captures"]["builtin-topology"]["performance_cells"]
+    cells[1] = dict(cells[0])
+    _write(qq_path, qq._attach_content_identity(body))
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="batch coverage is incomplete",
+    ):
+        _audit((native_path, matrix_path, qq_path))
+
+
+def test_rejects_malformed_qq_runtime_bundle(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = _qq()
+    body = dict(payload)
+    body.pop("content_identity")
+    body["runtime_bundle"] = []
+    _write(qq_path, qq._attach_content_identity(body))
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="runtime bundle identity is absent",
+    ):
+        _audit((native_path, matrix_path, qq_path))
+
+
+def test_rejects_different_native_module(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = _matrix()
+    body = dict(payload)
+    body.pop("content_identity")
+    body["expected_builds"]["current"]["native_module_sha256"] = "0" * 64
+    _write(matrix_path, matrix_x86._attach_content_identity(body))
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="different native modules",
+    ):
+        _audit((native_path, matrix_path, qq_path))
+
+
+def test_rejects_failed_or_incomplete_matrix_gate(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = _matrix()
+    body = dict(payload)
+    body.pop("content_identity")
+    body["matrix_audit"]["coverage"]["observed"] = 167
+    _write(matrix_path, matrix_x86._attach_content_identity(body))
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="matrix gates are incomplete",
+    ):
+        _audit((native_path, matrix_path, qq_path))
+
+
+def test_rejects_content_tampering(
+    inputs: tuple[Path, Path, Path],
+) -> None:
+    native_path, matrix_path, qq_path = inputs
+    payload = json.loads(qq_path.read_text(encoding="utf-8"))
+    payload["performance_cell_count"] = 7
+    _write(qq_path, payload)
+    with pytest.raises(
+        portable.PortableAcceptanceError,
+        match="content identity is invalid",
+    ):
+        _audit((native_path, matrix_path, qq_path))
diff --git a/pyamplicol/tests/unit/test_x86_qq_recurrence_acceptance.py b/pyamplicol/tests/unit/test_x86_qq_recurrence_acceptance.py
new file mode 100644
index 0000000000..af156c161a
--- /dev/null
+++ b/pyamplicol/tests/unit/test_x86_qq_recurrence_acceptance.py
@@ -0,0 +1,478 @@
+# SPDX-License-Identifier: 0BSD
+
+from __future__ import annotations
+
+import copy
+import json
+import statistics
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from tools.developer import x86_performance_runtime_bundle as bundle_tool
+from tools.developer import x86_qq_recurrence_acceptance as acceptance
+
+REVISION = "a" * 40
+WORKFLOW_RUN_ID = "123456789"
+BUILD_INFO_SHA256 = "b" * 64
+NATIVE_SHA256 = "c" * 64
+NATIVE_INPUTS_SHA256 = "d" * 64
+PREPARED_SHA256 = "e" * 64
+
+
+def _write(path: Path, value: object) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(value, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    return path
+
+
+def _current_installation() -> dict[str, object]:
+    return {
+        "package_version": "0.1.0.dev0+candidate.test",
+        "build_info": {
+            "schema_version": 1,
+            "version": "0.1.0.dev0+candidate.test",
+            "candidate_fingerprint": "0123456789ab",
+            "source_revision": REVISION,
+            "source_checkout": "/workspace/source",
+            "native_build_inputs_sha256": NATIVE_INPUTS_SHA256,
+            "publishable": False,
+        },
+        "build_info_sha256": BUILD_INFO_SHA256,
+        "distribution_content": {
+            "algorithm": "sha256-relative-path-size-content-v1",
+            "sha256": "f" * 64,
+            "file_count": 12,
+            "size_bytes": 3456,
+        },
+        "native_module": {
+            "relative_path": "pyamplicol/_rusticol.abi3.so",
+            "sha256": NATIVE_SHA256,
+            "size_bytes": 2345,
+        },
+    }
+
+
+def _bundle() -> dict[str, object]:
+    return bundle_tool._attach_content_identity(
+        {
+            "kind": bundle_tool.BUNDLE_KIND,
+            "schema_version": bundle_tool.SCHEMA_VERSION,
+            "target": "x86_64-unknown-linux-gnu",
+            "workflow_run_id": WORKFLOW_RUN_ID,
+            "expected_current_revision": REVISION,
+            "installations": {
+                "baseline": {"test": True},
+                "current": _current_installation(),
+            },
+            "dependency_site": {"test": True},
+            "wheels": {"test": True},
+            "prepared_models": {
+                "ufo-sm": {
+                    "relative_path": (
+                        "prepared-models/ufo-sm-jit-o2.pyamplicol-model"
+                    ),
+                    "sha256": PREPARED_SHA256,
+                    "size_bytes": 4567,
+                }
+            },
+            "frozen_baseline": {"test": True},
+            "passes": True,
+        }
+    )
+
+
+def _profile(batch_size: int, *, mode: str, slow: bool = False) -> dict[str, object]:
+    recurrence = [0.001 * (1.0 + index * 0.01) for index in range(7)]
+    ratios = (
+        [1.20 + index * 0.01 for index in range(7)]
+        if slow
+        else [1.00 + index * 0.01 for index in range(7)]
+    )
+    values = (
+        recurrence
+        if mode == "recurrence"
+        else [wall * ratio for wall, ratio in zip(recurrence, ratios, strict=True)]
+    )
+    median = statistics.median(values)
+    mad = statistics.median(abs(value - median) for value in values)
+    return {
+        "batch_size": batch_size,
+        "interrupted": False,
+        "sample_count": 7,
+        "subprocess_sample_count": 7,
+        "statistics_contract": "subprocess-median-and-raw-mad-v1",
+        "wall_seconds_per_point": median,
+        "wall_seconds_per_point_median": median,
+        "wall_seconds_per_point_mad": mad,
+        "subprocess_samples": [
+            {
+                "round": round_index,
+                "wall_seconds_per_point": value,
+            }
+            for round_index, value in enumerate(values)
+        ],
+    }
+
+
+def _models(role: str) -> dict[str, object]:
+    if role.startswith("builtin-"):
+        packaged = {
+            "kind": "packaged-prepared-model",
+            "resource_id": "built-in-sm-jit-o2",
+            "size_bytes": 1234,
+            "sha256": "1" * 64,
+            "compile_excluded_from_generation": True,
+        }
+        return {
+            "compiled": {
+                "kind": "built-in-sm-source",
+                "resource_id": None,
+                "source_revision": REVISION,
+                "compile_excluded_from_generation": False,
+            },
+            "eager": dict(packaged),
+            "recurrence": dict(packaged),
+        }
+    explicit = {
+        "kind": "explicit-prepared-model",
+        "resource_id": None,
+        "file": {
+            "path": "/runtime/ufo.pyamplicol-model",
+            "resolved_path": "/runtime/ufo.pyamplicol-model",
+            "sha256": PREPARED_SHA256,
+            "size_bytes": 4567,
+        },
+        "compile_excluded_from_generation": True,
+    }
+    return {mode: copy.deepcopy(explicit) for mode in acceptance.REQUIRED_MODES}
+
+
+def _runtime() -> dict[str, object]:
+    current = _current_installation()
+    return {
+        "active_build_info": {
+            "path": "/runtime/pyamplicol/_build_info.json",
+            "resolved_path": "/runtime/pyamplicol/_build_info.json",
+            "sha256": BUILD_INFO_SHA256,
+            "size_bytes": 400,
+            "payload": copy.deepcopy(current["build_info"]),
+        },
+        "installed_distribution": {
+            "package_version": current["package_version"],
+            "build_info_files": [
+                {
+                    "relative_path": "pyamplicol/_build_info.json",
+                    "sha256": BUILD_INFO_SHA256,
+                    "size_bytes": 400,
+                }
+            ],
+            "native_modules": [copy.deepcopy(current["native_module"])],
+            "distribution_content": copy.deepcopy(current["distribution_content"]),
+        },
+        "native_extension": {
+            "path": "/runtime/pyamplicol/_rusticol.abi3.so",
+            "resolved_path": "/runtime/pyamplicol/_rusticol.abi3.so",
+            "sha256": NATIVE_SHA256,
+            "size_bytes": 2345,
+            "build_inputs_sha256": NATIVE_INPUTS_SHA256,
+            "package_version": "0.1.0-dev.0+candidate.test",
+        },
+        "interpreter": {"test": True},
+        "dependencies": {"test": True},
+    }
+
+
+def _capture(role: str, *, slow: bool = False) -> dict[str, Any]:
+    contract = acceptance.CAPTURE_CONTRACTS[role]
+    return {
+        "kind": "pyamplicol-recurrence-z6g-benchmark",
+        "schema_version": acceptance.benchmark.RESULT_SCHEMA,
+        "complete": True,
+        "passes": True,
+        "capture_acceptance": {"test": "capture"},
+        "milestone0_acceptance": {"test": "milestone"},
+        "source": {
+            "checkout": "/workspace/source",
+            "revision": REVISION,
+            "dirty": False,
+            "untracked_files_checked": True,
+        },
+        "runtime_provenance": _runtime(),
+        "provenance": {
+            "host": {
+                "system": "Linux",
+                "machine": "x86_64",
+            }
+        },
+        "process": "u u~ > Z g g g g g g",
+        "process_name": "uubar_Z_6g",
+        "workload": contract["workload"],
+        "configuration": {
+            "batch_sizes": [1, 128, 1024],
+            "target_runtime_seconds": 5.0,
+            "minimum_samples": 7,
+            "subprocess_samples": 7,
+            "warmup_runs": 2,
+            "generation_timeout_seconds": 900.0,
+            "profile_timeout_seconds": 300.0,
+            "color_flow_request": contract["color_flow"],
+            "helicity_request": contract["helicity"],
+            "lc_flow_layout": contract["layout"],
+            "gluon_count": 6,
+            "validation_samples": 10,
+            "point_tile_size": 1024,
+            "jit_optimization_level": 3,
+            "generation_only": False,
+            "allow_diagnostic_incomplete_success": False,
+            "modes": ["compiled", "eager", "recurrence"],
+            "prepared_model_path": (
+                None
+                if role.startswith("builtin-")
+                else "/runtime/ufo.pyamplicol-model"
+            ),
+            "model_identities": _models(role),
+            "specialize_flow_at_generation": False,
+            "external_watchdog_required_for_long_runs": True,
+        },
+        "profile_schedule": {"test": True},
+        "profiles": {
+            "compiled": {
+                "profiles": [
+                    _profile(batch_size, mode="compiled", slow=slow)
+                    for batch_size in (1, 128, 1024)
+                ]
+            },
+            "eager": {"profiles": []},
+            "recurrence": {
+                "profiles": [
+                    _profile(batch_size, mode="recurrence")
+                    for batch_size in (1, 128, 1024)
+                ]
+            },
+        },
+        "validation_summary": {"test": "validation"},
+    }
+
+
+@pytest.fixture
+def evidence(tmp_path: Path) -> tuple[Path, dict[str, Path]]:
+    manifest = _write(tmp_path / "runtime-bundle.json", _bundle())
+    captures = {
+        role: _write(tmp_path / f"{role}.json", _capture(role))
+        for role in acceptance.CAPTURE_CONTRACTS
+    }
+    return manifest, captures
+
+
+def _audit(
+    evidence: tuple[Path, dict[str, Path]],
+    monkeypatch: pytest.MonkeyPatch,
+) -> dict[str, object]:
+    manifest, captures = evidence
+    monkeypatch.setattr(acceptance, "_recompute_harness_contracts", lambda _p: None)
+    return acceptance.audit(
+        capture_paths=captures,
+        runtime_bundle_manifest=manifest,
+        workflow_run_id=WORKFLOW_RUN_ID,
+        expected_current_revision=REVISION,
+    )
+
+
+def test_accepts_exact_four_capture_contract_and_is_portable(
+    evidence: tuple[Path, dict[str, Path]],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    result = _audit(evidence, monkeypatch)
+    assert result["passes"] is True
+    assert result["performance_cell_count"] == 8
+    assert set(result["captures"]) == set(acceptance.CAPTURE_CONTRACTS)
+    assert str(evidence[0].parent) not in json.dumps(result)
+    identity = result["content_identity"]
+    body = dict(result)
+    body.pop("content_identity")
+    assert identity["sha256"] == acceptance._canonical_sha256(body)
+
+
+def test_slow_compiled_capture_fails_performance_gate(
+    evidence: tuple[Path, dict[str, Path]],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    manifest, captures = evidence
+    _write(captures["ufo-union"], _capture("ufo-union", slow=True))
+    result = _audit((manifest, captures), monkeypatch)
+    assert result["passes"] is False
+    failed = result["captures"]["ufo-union"]
+    assert all(cell["passes"] is False for cell in failed["performance_cells"])
+
+
+def test_zero_paired_ratio_uncertainty_is_accepted_when_below_ceiling(
+    evidence: tuple[Path, dict[str, Path]],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    manifest, captures = evidence
+    payload = _capture("builtin-topology")
+    for batch_size in (128, 1024):
+        recurrence = acceptance._profile_for_batch(
+            payload, mode="recurrence", batch_size=batch_size
+        )
+        compiled = acceptance._profile_for_batch(
+            payload, mode="compiled", batch_size=batch_size
+        )
+        compiled["subprocess_samples"] = copy.deepcopy(
+            recurrence["subprocess_samples"]
+        )
+        compiled["wall_seconds_per_point"] = recurrence["wall_seconds_per_point"]
+        compiled["wall_seconds_per_point_median"] = recurrence[
+            "wall_seconds_per_point_median"
+        ]
+        compiled["wall_seconds_per_point_mad"] = recurrence[
+            "wall_seconds_per_point_mad"
+        ]
+    _write(captures["builtin-topology"], payload)
+    result = _audit((manifest, captures), monkeypatch)
+    cells = result["captures"]["builtin-topology"]["performance_cells"]
+    assert all(cell["ratio_statistics"]["raw_mad"] == 0.0 for cell in cells)
+    assert all(cell["ratio_statistics"]["median"] == 1.0 for cell in cells)
+    assert all(
+        cell["ratio_statistics"]["upper_three_raw_mad"] == 1.0 for cell in cells
+    )
+    assert all(cell["passes"] is True for cell in cells)
+
+
+@pytest.mark.parametrize(
+    ("mutation", "message"),
+    [
+        (
+            lambda payload: payload["configuration"].__setitem__(
+                "target_runtime_seconds", 4.999
+            ),
+            "authoritative benchmark policy",
+        ),
+        (
+            lambda payload: payload["configuration"].__setitem__(
+                "allow_diagnostic_incomplete_success", True
+            ),
+            "authoritative benchmark policy",
+        ),
+        (
+            lambda payload: payload["configuration"].__setitem__(
+                "specialize_flow_at_generation", True
+            ),
+            "authoritative benchmark policy",
+        ),
+        (
+            lambda payload: payload["configuration"].__setitem__(
+                "helicity_request", "1"
+            ),
+            "authoritative benchmark policy",
+        ),
+        (
+            lambda payload: payload["runtime_provenance"][
+                "native_extension"
+            ].__setitem__("sha256", "0" * 64),
+            "runtime does not match",
+        ),
+        (
+            lambda payload: payload.__setitem__("provenance", []),
+            "not measured from exact clean x86 source",
+        ),
+    ],
+)
+def test_rejects_policy_and_runtime_shortcuts(
+    evidence: tuple[Path, dict[str, Path]],
+    monkeypatch: pytest.MonkeyPatch,
+    mutation: Any,
+    message: str,
+) -> None:
+    manifest, captures = evidence
+    payload = _capture("builtin-union")
+    mutation(payload)
+    _write(captures["builtin-union"], payload)
+    with pytest.raises(acceptance.AcceptanceError, match=message):
+        _audit((manifest, captures), monkeypatch)
+
+
+def test_rejects_ufo_model_not_bound_to_bundle(
+    evidence: tuple[Path, dict[str, Path]],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    manifest, captures = evidence
+    payload = _capture("ufo-topology")
+    payload["configuration"]["model_identities"]["compiled"]["file"]["sha256"] = (
+        "0" * 64
+    )
+    _write(captures["ufo-topology"], payload)
+    with pytest.raises(acceptance.AcceptanceError, match="UFO model identity"):
+        _audit((manifest, captures), monkeypatch)
+
+
+def test_rejects_missing_or_duplicate_paired_round() -> None:
+    payload = _capture("builtin-topology")
+    profile = acceptance._profile_for_batch(
+        payload,
+        mode="compiled",
+        batch_size=128,
+    )
+    profile["subprocess_samples"][6]["round"] = 5
+    with pytest.raises(acceptance.AcceptanceError, match="invalid paired samples"):
+        acceptance._paired_cell_evidence(
+            payload,
+            batch_size=128,
+            ceiling=1.15,
+        )
+
+
+def test_runtime_bundle_content_tampering_is_rejected(
+    evidence: tuple[Path, dict[str, Path]],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    manifest, captures = evidence
+    payload = json.loads(manifest.read_text(encoding="utf-8"))
+    payload["prepared_models"]["ufo-sm"]["size_bytes"] += 1
+    _write(manifest, payload)
+    with pytest.raises(acceptance.AcceptanceError, match="content identity"):
+        _audit((manifest, captures), monkeypatch)
+
+
+def test_recompute_uses_authoritative_harness_contracts(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    validation = {"passes": True}
+    capture = {
+        "complete": True,
+        "evidence_complete": True,
+        "passes": True,
+        "authoritative_eligible": True,
+        "authoritative_ineligibility_reasons": [],
+        "generation_specialized_axes_by_mode": {},
+        "incomplete_physical_axes": [],
+    }
+    milestone = {"accepted": False}
+    payload = _capture("builtin-topology")
+    payload["validation_summary"] = validation
+    payload["capture_acceptance"] = capture
+    payload["milestone0_acceptance"] = milestone
+    monkeypatch.setattr(
+        acceptance.benchmark,
+        "_pairwise_profile_validation",
+        lambda _profiles: validation,
+    )
+    monkeypatch.setattr(
+        acceptance.benchmark,
+        "_capture_acceptance",
+        lambda *_args, **_kwargs: capture,
+    )
+    monkeypatch.setattr(
+        acceptance.benchmark,
+        "_milestone0_acceptance_manifest",
+        lambda *_args, **_kwargs: milestone,
+    )
+    acceptance._recompute_harness_contracts(payload)
+    payload["validation_summary"] = {"passes": False}
+    with pytest.raises(acceptance.AcceptanceError, match="not reproducible"):
+        acceptance._recompute_harness_contracts(payload)
diff --git a/pyamplicol/tools/ci/__init__.py b/pyamplicol/tools/ci/__init__.py
new file mode 100644
index 0000000000..7fd5195330
--- /dev/null
+++ b/pyamplicol/tools/ci/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: 0BSD
+"""Continuous-integration helpers that are not shipped in distributions."""
diff --git a/pyamplicol/tools/ci/eager_portability.py b/pyamplicol/tools/ci/eager_portability.py
new file mode 100644
index 0000000000..dac564a4c3
--- /dev/null
+++ b/pyamplicol/tools/ci/eager_portability.py
@@ -0,0 +1,1254 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Produce and consume a portable eager JIT model bundle.
+
+Heavy invocations of this script must be wrapped by::
+
+    python tools/ci/memory_watchdog.py --limit-gib 30 -- \
+      python tools/ci/eager_portability.py ...
+
+The producer writes portable JIT O2 bundles for the built-in SM and scalar-HEFT
+models, plus one SM numerical transfer fixture.  Consumers use that exact SM
+archive; they never prepare a model pack.  SymJIT application storage v3 at O2
+stores portable MIR and may cross the supported x86-64 and AArch64 host
+classes; each consumer recompiles that state for its own CPU when loading it.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import json
+import math
+import os
+import platform
+import shlex
+import subprocess
+import sys
+import tempfile
+import zipfile
+from collections.abc import Iterator, Mapping, Sequence
+from pathlib import Path, PurePosixPath
+
+if __package__:
+    from .eager_portability_contract import (
+        FORBIDDEN_SUFFIXES as _FORBIDDEN_SUFFIXES,
+    )
+    from .eager_portability_contract import (
+        PortabilityError,
+        RuntimeContracts,
+        architecture_class,
+        audit_architecture_jit_bundle,
+    )
+    from .eager_portability_contract import (
+        archive_manifest as _archive_manifest,
+    )
+    from .eager_portability_contract import (
+        array_value as _array,
+    )
+    from .eager_portability_contract import (
+        canonical_member_path as _canonical_member_path,
+    )
+    from .eager_portability_contract import (
+        integer_value as _integer,
+    )
+    from .eager_portability_contract import (
+        native_payload_kind as _native_payload_kind,
+    )
+    from .eager_portability_contract import (
+        object_value as _object,
+    )
+    from .eager_portability_contract import (
+        sha256_file as _sha256_file,
+    )
+    from .eager_portability_contract import (
+        string_value as _string,
+    )
+else:
+    from eager_portability_contract import (
+        FORBIDDEN_SUFFIXES as _FORBIDDEN_SUFFIXES,
+    )
+    from eager_portability_contract import (
+        PortabilityError,
+        RuntimeContracts,
+        architecture_class,
+        audit_architecture_jit_bundle,
+    )
+    from eager_portability_contract import (
+        archive_manifest as _archive_manifest,
+    )
+    from eager_portability_contract import (
+        array_value as _array,
+    )
+    from eager_portability_contract import (
+        canonical_member_path as _canonical_member_path,
+    )
+    from eager_portability_contract import (
+        integer_value as _integer,
+    )
+    from eager_portability_contract import (
+        native_payload_kind as _native_payload_kind,
+    )
+    from eager_portability_contract import (
+        object_value as _object,
+    )
+    from eager_portability_contract import (
+        sha256_file as _sha256_file,
+    )
+    from eager_portability_contract import (
+        string_value as _string,
+    )
+
+TRANSFER_KIND = "pyamplicol-eager-jit-portability-transfer"
+TRANSFER_SCHEMA_VERSION = 2
+CONSUMER_REPORT_KIND = "pyamplicol-eager-jit-portability-consumer-report"
+CONSUMER_REPORT_SCHEMA_VERSION = 2
+
+DEFAULT_PROCESS = "d d~ > z"
+DEFAULT_PROCESS_ID = "d_dbar_to_z"
+DEFAULT_RTOL = 1.0e-12
+DEFAULT_ATOL = 1.0e-15
+DEFAULT_BUNDLE_NAME = "builtin-sm-jit-o2.pyamplicol-model"
+HEFT_BUNDLE_NAME = "builtin-sm-heft-jit-o2.pyamplicol-model"
+HEFT_MODEL_SOURCE = "built-in-sm-heft"
+HEFT_PACKAGED_MODEL_ID = "built-in-sm-heft-jit-o2"
+DEFAULT_FIXTURE_NAME = "transfer.json"
+
+_ROOT = Path(__file__).resolve().parents[2]
+_COMPILER_COMMANDS = (
+    "ar",
+    "as",
+    "c++",
+    "cc",
+    "clang",
+    "clang++",
+    "g++",
+    "gcc",
+    "ld",
+    "nasm",
+)
+
+
+def _runtime_contracts() -> RuntimeContracts:
+    # Importing model contracts initializes Symbolica. Keep that import in a
+    # completed child so this driver does not hold a restricted-thread permit
+    # while later CLI children initialize their own Symbolica runtime.
+    script = (
+        "import json, sys\n"
+        "from dataclasses import asdict\n"
+        f"sys.path.insert(0, {str(Path(__file__).resolve().parent)!r})\n"
+        "from eager_portability import _runtime_contracts_in_process\n"
+        "print(json.dumps(asdict(_runtime_contracts_in_process())))\n"
+    )
+    try:
+        completed = subprocess.run(
+            [sys.executable, "-c", script],
+            cwd=_ROOT,
+            env=_command_environment(),
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except (OSError, subprocess.CalledProcessError) as error:
+        raise PortabilityError("could not read installed runtime contracts") from error
+    return RuntimeContracts(**json.loads(completed.stdout))
+
+
+def _runtime_contracts_in_process() -> RuntimeContracts:
+    # Keep imports lazy so clean-checkout release tests can exercise the archive
+    # auditor without installing pyAmpliCol or its native dependencies.
+    from pyamplicol._internal.versions import (
+        COMPILED_MODEL_SCHEMA_VERSION,
+        EAGER_RUNTIME_LAYOUT_F64_CAPABILITY,
+        SYMBOLICA_SERIALIZATION_ABI,
+        SYMJIT_APPLICATION_ABI,
+        SYMJIT_F64_RUNTIME_CAPABILITY,
+        SYMJIT_PLANE_APPLICATION_ABI,
+        package_version,
+    )
+    from pyamplicol.models.prepared import (
+        EAGER_KERNEL_ABI,
+        PREPARED_MODEL_BUNDLE_KIND,
+        PREPARED_MODEL_BUNDLE_SCHEMA_VERSION,
+    )
+
+    return RuntimeContracts(
+        bundle_kind=PREPARED_MODEL_BUNDLE_KIND,
+        bundle_schema_version=PREPARED_MODEL_BUNDLE_SCHEMA_VERSION,
+        eager_kernel_abi=EAGER_KERNEL_ABI,
+        compiled_model_schema_version=COMPILED_MODEL_SCHEMA_VERSION,
+        symbolica_serialization_abi=SYMBOLICA_SERIALIZATION_ABI,
+        symjit_application_abi=SYMJIT_APPLICATION_ABI,
+        symjit_plane_application_abi=SYMJIT_PLANE_APPLICATION_ABI,
+        symjit_runtime_capability=SYMJIT_F64_RUNTIME_CAPABILITY,
+        eager_runtime_capability=EAGER_RUNTIME_LAYOUT_F64_CAPABILITY,
+        package_version=package_version(),
+    )
+
+
+def _command_environment() -> dict[str, str]:
+    environment = os.environ.copy()
+    environment.setdefault("SYMBOLICA_HIDE_BANNER", "1")
+    environment.setdefault("PYTHONDONTWRITEBYTECODE", "1")
+    return environment
+
+
+def _python_executable(path: Path) -> Path:
+    """Return an absolute launcher path without dereferencing a venv symlink."""
+
+    expanded = path.expanduser()
+    absolute = Path(os.path.abspath(expanded))
+    if not absolute.is_file():
+        raise PortabilityError(f"Python executable does not exist: {absolute}")
+    if not os.access(absolute, os.X_OK):
+        raise PortabilityError(f"Python executable is not executable: {absolute}")
+    return absolute
+
+
+def _host_identity(
+    role: str,
+    *,
+    expected_system: str | None,
+    expected_machine: str | None,
+) -> tuple[str, str, str]:
+    actual_system = platform.system()
+    actual_machine = platform.machine()
+    actual_architecture = architecture_class(actual_machine)
+    if expected_system is not None and actual_system != expected_system:
+        raise PortabilityError(
+            f"{role} system is {actual_system!r}, expected {expected_system!r}"
+        )
+    if expected_machine is not None:
+        expected_architecture = architecture_class(expected_machine)
+        if actual_architecture != expected_architecture:
+            raise PortabilityError(
+                f"{role} architecture class is {actual_architecture!r}, "
+                f"expected {expected_architecture!r}"
+            )
+    return actual_system, actual_machine, actual_architecture
+
+
+def _run(
+    command: Sequence[str], *, environment: Mapping[str, str] | None = None
+) -> None:
+    print(f"+ {shlex.join(command)}", file=sys.stderr, flush=True)
+    try:
+        subprocess.run(
+            list(command),
+            cwd=_ROOT,
+            env=dict(environment) if environment is not None else None,
+            check=True,
+        )
+    except (OSError, subprocess.CalledProcessError) as error:
+        raise PortabilityError(f"command failed: {shlex.join(command)}") from error
+
+
+def _model_compile_command(
+    python: Path,
+    bundle: Path,
+    *,
+    model: str = "built-in-sm",
+) -> list[str]:
+    return [
+        str(python),
+        "-m",
+        "pyamplicol",
+        "model",
+        "compile",
+        model,
+        str(bundle),
+        "--backend",
+        "jit",
+        "--jit-optimization-level",
+        "3",
+        "--cores",
+        "1",
+        "--no-symbolica-suggestion",
+        "--progress",
+        "off",
+        "--json",
+    ]
+
+
+def _generation_command(
+    python: Path,
+    *,
+    model: str | Path,
+    output: Path,
+    execution_mode: str,
+) -> list[str]:
+    return [
+        str(python),
+        "-m",
+        "pyamplicol",
+        "generate",
+        DEFAULT_PROCESS,
+        str(output),
+        "--model",
+        str(model),
+        "--execution-mode",
+        execution_mode,
+        "--backend",
+        "jit",
+        "--jit-optimization-level",
+        "3",
+        "--color-accuracy",
+        "lc",
+        "--mode",
+        "replace",
+        "--workers",
+        "1",
+        "--validation",
+        "--validation-samples",
+        "1",
+        "--no-post-build-validation",
+        "--no-emit-api-bundle",
+        "--no-symbolica-suggestion",
+        "--progress",
+        "off",
+        "--json",
+    ]
+
+
+def _validation_momenta(artifact: Path) -> list[list[float]]:
+    path = artifact / "processes" / DEFAULT_PROCESS_ID / "validation-momenta.json"
+    try:
+        payload = _object(json.loads(path.read_text(encoding="utf-8")), "momenta")
+        points = _array(payload.get("points"), "momenta.points")
+        first = _array(points[0], "momenta.points[0]")
+        momenta = []
+        for index, raw_particle in enumerate(first):
+            particle = _object(raw_particle, f"momenta.points[0][{index}]")
+            components = _array(
+                particle.get("momentum"),
+                f"momenta.points[0][{index}].momentum",
+            )
+            if len(components) != 4:
+                raise PortabilityError("validation momentum must have four components")
+            momenta.append([float(value) for value in components])
+    except (OSError, IndexError, TypeError, ValueError, json.JSONDecodeError) as error:
+        if isinstance(error, PortabilityError):
+            raise
+        raise PortabilityError("could not read generated validation momenta") from error
+    return momenta
+
+
+def _evaluate_artifact(artifact: Path, momenta: Sequence[Sequence[float]]) -> complex:
+    from pyamplicol import Runtime
+
+    runtime = Runtime.load(artifact, process=DEFAULT_PROCESS_ID)
+    values = runtime.evaluate((momenta,), precision=16)
+    if len(values) != 1:
+        raise PortabilityError("runtime returned an unexpected number of values")
+    return complex(values[0])
+
+
+def _close(actual: complex, expected: complex, *, rtol: float, atol: float) -> bool:
+    return abs(actual - expected) <= atol + rtol * abs(expected)
+
+
+def _git_commit() -> str:
+    try:
+        completed = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            cwd=_ROOT,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except (OSError, subprocess.CalledProcessError) as error:
+        raise PortabilityError("could not identify the producer Git commit") from error
+    return completed.stdout.strip()
+
+
+def _write_json(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def _write_source_ready_candidate_asset(
+    bundle: Path,
+    output_directory: Path,
+    *,
+    architecture: str,
+    identifier: str = "built-in-sm-jit-o2",
+) -> tuple[Path, Path]:
+    build_backend = _ROOT / "build_backend"
+    inserted = False
+    if str(build_backend) not in sys.path:
+        sys.path.insert(0, str(build_backend))
+        inserted = True
+    try:
+        from prepared_models import write_candidate_packaged_prepared_model_asset
+
+        return write_candidate_packaged_prepared_model_asset(
+            _ROOT,
+            bundle,
+            output_directory,
+            architecture=architecture,
+            identifier=identifier,
+        )
+    finally:
+        if inserted:
+            sys.path.remove(str(build_backend))
+
+
+def _write_source_ready_asset(
+    bundle: Path,
+    output_directory: Path,
+    *,
+    architecture: str,
+    asset_mode: str,
+    identifier: str = "built-in-sm-jit-o2",
+) -> tuple[Path, Path]:
+    if asset_mode == "candidate":
+        return _write_source_ready_candidate_asset(
+            bundle,
+            output_directory,
+            architecture=architecture,
+            identifier=identifier,
+        )
+    if asset_mode != "release":
+        raise PortabilityError(f"unsupported prepared-model asset mode: {asset_mode}")
+    build_backend = _ROOT / "build_backend"
+    inserted = False
+    if str(build_backend) not in sys.path:
+        sys.path.insert(0, str(build_backend))
+        inserted = True
+    try:
+        from prepared_models import write_release_packaged_prepared_model_asset
+
+        return write_release_packaged_prepared_model_asset(
+            _ROOT,
+            bundle,
+            output_directory,
+            architecture=architecture,
+            identifier=identifier,
+        )
+    finally:
+        if inserted:
+            sys.path.remove(str(build_backend))
+
+
+def _source_ready_asset_directory(output: Path, asset_mode: str) -> Path:
+    if asset_mode == "candidate":
+        return output
+    if asset_mode == "release":
+        return output / "release_assets" / "prepared_models"
+    raise PortabilityError(f"unsupported prepared-model asset mode: {asset_mode}")
+
+
+def _transfer_bundle_member(value: object) -> PurePosixPath:
+    relative = PurePosixPath(_canonical_member_path(value, "bundle filename"))
+    parts = relative.parts
+    if len(parts) == 1:
+        return relative
+    if len(parts) == 3 and parts[:2] == (
+        "release_assets",
+        "prepared_models",
+    ):
+        return relative
+    raise PortabilityError(
+        "transferred bundle must be at the transfer root or in the exact "
+        "release prepared-model source store"
+    )
+
+
+def _preflight_all_prepared_applications(bundle: Path) -> int:
+    from pyamplicol import _rusticol
+
+    with zipfile.ZipFile(bundle) as archive:
+        try:
+            manifest = _object(
+                json.loads(archive.read("manifest.json")),
+                "prepared bundle manifest",
+            )
+        except (KeyError, UnicodeDecodeError, json.JSONDecodeError) as error:
+            raise PortabilityError("prepared bundle manifest is invalid") from error
+        kernel_pack = _object(
+            manifest.get("kernel_pack"),
+            "prepared bundle kernel_pack",
+        )
+        kernel_pack = dict(kernel_pack)
+        kernel_pack["eager_kernel_abi"] = _string(
+            manifest.get("eager_kernel_abi"),
+            "prepared bundle eager_kernel_abi",
+        )
+        members = _array(manifest.get("members"), "prepared bundle members")
+        with tempfile.TemporaryDirectory(
+            prefix="pyamplicol-eager-portability-preflight-"
+        ) as raw:
+            root = Path(raw)
+            pack_path = root / "kernel-pack.json"
+            pack_path.write_text(
+                json.dumps(kernel_pack, sort_keys=True, separators=(",", ":")) + "\n",
+                encoding="utf-8",
+            )
+            for index, raw_member in enumerate(members):
+                member = _object(raw_member, f"prepared bundle members[{index}]")
+                relative = _canonical_member_path(
+                    member.get("path"),
+                    f"prepared bundle members[{index}].path",
+                )
+                destination = root.joinpath(*PurePosixPath(relative).parts)
+                destination.parent.mkdir(parents=True, exist_ok=True)
+                destination.write_bytes(archive.read(relative))
+            loaded = _rusticol._preflight_eager_kernel_pack(pack_path, root)
+    expected = len(_array(kernel_pack.get("kernels"), "kernel_pack.kernels")) + len(
+        _array(kernel_pack.get("kernel_variants"), "kernel_pack.kernel_variants")
+    )
+    if loaded != expected:
+        raise PortabilityError(
+            "prepared application preflight loaded "
+            f"{loaded} evaluators, expected {expected}"
+        )
+    return loaded
+
+
+def produce_transfer(
+    output_directory: Path,
+    *,
+    python: Path,
+    expected_system: str | None = None,
+    expected_machine: str | None = None,
+    asset_mode: str = "candidate",
+) -> dict[str, object]:
+    actual_system, actual_machine, actual_architecture = _host_identity(
+        "producer",
+        expected_system=expected_system,
+        expected_machine=expected_machine,
+    )
+
+    output = output_directory.expanduser().resolve(strict=False)
+    if output.exists():
+        if not output.is_dir():
+            raise PortabilityError(f"producer output path is not a directory: {output}")
+        if any(output.iterdir()):
+            raise PortabilityError(f"producer output directory is not empty: {output}")
+    output.mkdir(parents=True, exist_ok=True)
+    contracts = _runtime_contracts()
+    environment = _command_environment()
+    asset_output = _source_ready_asset_directory(output, asset_mode)
+
+    with (
+        tempfile.TemporaryDirectory(
+            prefix="pyamplicol-eager-portability-pack-",
+            dir=output.parent,
+        ) as raw_bundle,
+        tempfile.TemporaryDirectory(
+            prefix="pyamplicol-eager-portability-producer-"
+        ) as raw,
+    ):
+        generated_bundle = Path(raw_bundle) / DEFAULT_BUNDLE_NAME
+        _run(
+            _model_compile_command(python, generated_bundle),
+            environment=environment,
+        )
+        audit = audit_architecture_jit_bundle(
+            generated_bundle,
+            contracts=contracts,
+            expected_architecture_class=actual_architecture,
+        )
+        if audit["producer_version"] != contracts.package_version:
+            raise PortabilityError(
+                "prepared bundle producer version differs from the installed package"
+            )
+        generated_heft_bundle = Path(raw_bundle) / HEFT_BUNDLE_NAME
+        _run(
+            _model_compile_command(
+                python,
+                generated_heft_bundle,
+                model=HEFT_MODEL_SOURCE,
+            ),
+            environment=environment,
+        )
+        heft_audit = audit_architecture_jit_bundle(
+            generated_heft_bundle,
+            contracts=contracts,
+            expected_architecture_class=actual_architecture,
+            expected_model_source=HEFT_MODEL_SOURCE,
+        )
+        if heft_audit["producer_version"] != contracts.package_version:
+            raise PortabilityError(
+                "prepared scalar-HEFT bundle producer version differs from the "
+                "installed package"
+            )
+        temporary = Path(raw)
+        eager_artifact = temporary / "eager"
+        compiled_artifact = temporary / "compiled"
+        _run(
+            _generation_command(
+                python,
+                model=generated_bundle,
+                output=eager_artifact,
+                execution_mode="eager",
+            ),
+            environment=environment,
+        )
+        _run(
+            _generation_command(
+                python,
+                model="built-in-sm",
+                output=compiled_artifact,
+                execution_mode="compiled",
+            ),
+            environment=environment,
+        )
+        # All CLI children have exited. Native preflight, asset writing, and
+        # evaluation may now initialize Symbolica in this parent process.
+        audit["preflight_evaluator_count"] = _preflight_all_prepared_applications(
+            generated_bundle
+        )
+        metadata_path, bundle = _write_source_ready_asset(
+            generated_bundle,
+            asset_output,
+            architecture=actual_architecture,
+            asset_mode=asset_mode,
+        )
+        heft_audit["preflight_evaluator_count"] = _preflight_all_prepared_applications(
+            generated_heft_bundle
+        )
+        heft_metadata_path, heft_bundle = _write_source_ready_asset(
+            generated_heft_bundle,
+            asset_output,
+            architecture=actual_architecture,
+            asset_mode=asset_mode,
+            identifier=HEFT_PACKAGED_MODEL_ID,
+        )
+        momenta = _validation_momenta(eager_artifact)
+        eager_value = _evaluate_artifact(eager_artifact, momenta)
+        expected_value = _evaluate_artifact(compiled_artifact, momenta)
+        if not _close(
+            eager_value,
+            expected_value,
+            rtol=DEFAULT_RTOL,
+            atol=DEFAULT_ATOL,
+        ):
+            raise PortabilityError(
+                "producer eager value does not match the compiled reference"
+            )
+
+    fixture: dict[str, object] = {
+        "bundle": {
+            "filename": bundle.relative_to(output).as_posix(),
+            **audit,
+        },
+        "expected": {
+            "atol": DEFAULT_ATOL,
+            "imaginary": expected_value.imag,
+            "real": expected_value.real,
+            "rtol": DEFAULT_RTOL,
+            "source": "compiled-jit-o3-f64",
+        },
+        "kind": TRANSFER_KIND,
+        "process": {
+            "expression": DEFAULT_PROCESS,
+            "id": DEFAULT_PROCESS_ID,
+            "momenta": momenta,
+        },
+        "producer": {
+            "architecture_class": actual_architecture,
+            "git_commit": _git_commit(),
+            "machine": actual_machine,
+            "package_version": contracts.package_version,
+            "python": platform.python_version(),
+            "system": actual_system,
+        },
+        "schema_version": TRANSFER_SCHEMA_VERSION,
+    }
+    fixture_path = output / DEFAULT_FIXTURE_NAME
+    _write_json(fixture_path, fixture)
+    return {
+        "bundle": str(bundle),
+        "bundle_sha256": audit["bundle_sha256"],
+        "expected": {"real": expected_value.real, "imaginary": expected_value.imag},
+        "fixture": str(fixture_path),
+        "kernel_count": audit["kernel_count"],
+        "metadata": str(metadata_path),
+        "packaged_models": {
+            "built-in-sm": {
+                "bundle": str(bundle),
+                "metadata": str(metadata_path),
+                "sha256": audit["bundle_sha256"],
+            },
+            HEFT_MODEL_SOURCE: {
+                "bundle": str(heft_bundle),
+                "kernel_count": heft_audit["kernel_count"],
+                "metadata": str(heft_metadata_path),
+                "sha256": heft_audit["bundle_sha256"],
+            },
+        },
+        "architecture_class": actual_architecture,
+    }
+
+
+@contextlib.contextmanager
+def compiler_guard() -> Iterator[tuple[dict[str, str], Path]]:
+    """Deny external compiler/linker execution during consumer generation."""
+
+    with tempfile.TemporaryDirectory(prefix="pyamplicol-compiler-guard-") as raw:
+        root = Path(raw)
+        marker = root / "invocations.log"
+        script = root / "deny-tool"
+        script.write_text(
+            "#!/bin/sh\n"
+            f"printf '%s\\n' \"$0 $*\" >> {shlex.quote(str(marker))}\n"
+            "exit 97\n",
+            encoding="ascii",
+        )
+        script.chmod(0o755)
+        for name in _COMPILER_COMMANDS:
+            shim = root / name
+            try:
+                shim.symlink_to(script.name)
+            except OSError:
+                shim.write_bytes(script.read_bytes())
+                shim.chmod(0o755)
+
+        environment = _command_environment()
+        environment["PATH"] = os.pathsep.join((str(root), environment.get("PATH", "")))
+        for variable, command in (
+            ("AR", "ar"),
+            ("AS", "as"),
+            ("CC", "cc"),
+            ("CXX", "c++"),
+            ("LD", "ld"),
+        ):
+            environment[variable] = str(root / command)
+        yield environment, marker
+
+
+@contextlib.contextmanager
+def _temporary_environment(environment: Mapping[str, str]) -> Iterator[None]:
+    previous = os.environ.copy()
+    os.environ.clear()
+    os.environ.update(environment)
+    try:
+        yield
+    finally:
+        os.environ.clear()
+        os.environ.update(previous)
+
+
+def _fixture(path: Path) -> dict[str, object]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise PortabilityError(f"could not read transfer fixture: {error}") from error
+    fixture = _object(payload, "transfer fixture")
+    if fixture.get("kind") != TRANSFER_KIND:
+        raise PortabilityError("invalid eager portability transfer kind")
+    if fixture.get("schema_version") != TRANSFER_SCHEMA_VERSION:
+        raise PortabilityError("unsupported eager portability transfer schema")
+    return fixture
+
+
+def _manifest_payloads(
+    artifact: Path,
+) -> tuple[dict[str, object], dict[str, dict[str, object]]]:
+    try:
+        manifest = _object(
+            json.loads((artifact / "artifact.json").read_text(encoding="utf-8")),
+            "artifact manifest",
+        )
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise PortabilityError("generated artifact manifest is invalid") from error
+    payloads: dict[str, dict[str, object]] = {}
+    for index, raw_payload in enumerate(
+        _array(manifest.get("payloads"), "artifact.payloads")
+    ):
+        record = _object(raw_payload, f"artifact.payloads[{index}]")
+        path = _canonical_member_path(record.get("path"), "artifact payload path")
+        source = artifact / PurePosixPath(path)
+        if not source.is_file() or source.is_symlink():
+            raise PortabilityError(f"generated artifact payload {path!r} is missing")
+        expected_size = _integer(record.get("size_bytes"), f"payload {path!r} size")
+        expected_sha = _string(record.get("sha256"), f"payload {path!r} sha256")
+        if (
+            source.stat().st_size != expected_size
+            or _sha256_file(source) != expected_sha
+        ):
+            raise PortabilityError(f"generated artifact payload {path!r} is modified")
+        payloads[path] = record
+    return manifest, payloads
+
+
+def verify_consumer_artifact(
+    artifact: Path,
+    bundle: Path,
+    *,
+    contracts: RuntimeContracts,
+    bundle_audit: Mapping[str, object],
+) -> dict[str, object]:
+    """Prove that eager generation copied, rather than rebuilt, JIT kernels."""
+
+    manifest, artifact_payloads = _manifest_payloads(artifact)
+    if (
+        manifest.get("kind") != "pyamplicol-process"
+        or manifest.get("schema_version") != 3
+    ):
+        raise PortabilityError("consumer did not generate a schema-v3 process artifact")
+    producer = _object(manifest.get("producer"), "artifact.producer")
+    if producer.get("version") != contracts.package_version:
+        raise PortabilityError("consumer artifact package version mismatch")
+    processes = _array(manifest.get("processes"), "artifact.processes")
+    if len(processes) != 1:
+        raise PortabilityError("consumer artifact must contain one concrete process")
+    process = _object(processes[0], "artifact.processes[0]")
+    if (
+        process.get("id") != DEFAULT_PROCESS_ID
+        or process.get("expression") != DEFAULT_PROCESS
+    ):
+        raise PortabilityError("consumer artifact process identity mismatch")
+    if contracts.eager_runtime_capability not in _array(
+        process.get("required_runtime_capabilities"),
+        "process.required_runtime_capabilities",
+    ):
+        raise PortabilityError("consumer artifact does not require the eager runtime")
+
+    execution_path = artifact / "processes" / DEFAULT_PROCESS_ID / "execution.json"
+    execution = _object(
+        json.loads(execution_path.read_text(encoding="utf-8")),
+        "eager execution manifest",
+    )
+    if execution.get("kind") != "pyamplicol-runtime-eager-execution":
+        raise PortabilityError("consumer generated the compiled execution lane")
+
+    extensions = _object(manifest.get("extensions"), "artifact.extensions")
+    identity = _object(
+        extensions.get("eager_prepared_pack"),
+        "artifact.extensions.eager_prepared_pack",
+    )
+    if (
+        identity.get("backend") != "jit"
+        or identity.get("eager_kernel_abi") != contracts.eager_kernel_abi
+    ):
+        raise PortabilityError("consumer artifact prepared-pack identity mismatch")
+    if identity.get("kernel_count") != bundle_audit.get("kernel_count"):
+        raise PortabilityError("consumer artifact records an unexpected source pack")
+
+    bundle_manifest, bundle_payloads = _archive_manifest(bundle)
+    bundle_pack = _object(bundle_manifest.get("kernel_pack"), "bundle kernel pack")
+    bundle_members = {
+        _canonical_member_path(
+            _object(record, "bundle member").get("path"),
+            "bundle member path",
+        ): _object(record, "bundle member")
+        for record in _array(bundle_manifest.get("members"), "bundle members")
+    }
+
+    eager_pack_path = artifact / "model" / "eager-kernel-pack.json"
+    filtered_pack = _object(
+        json.loads(eager_pack_path.read_text(encoding="utf-8")),
+        "filtered eager kernel pack",
+    )
+    if filtered_pack.get("backend") != "jit" or filtered_pack.get(
+        "target"
+    ) != bundle_pack.get("target"):
+        raise PortabilityError("consumer changed the portable JIT target")
+    filtered_kernels = _array(filtered_pack.get("kernels"), "filtered pack kernels")
+    filtered_variants = _array(
+        filtered_pack.get("kernel_variants", []),
+        "filtered pack kernel variants",
+    )
+    if not filtered_kernels:
+        raise PortabilityError("consumer artifact references no prepared kernels")
+
+    packed_reader = None
+    container_record = extensions.get("evaluator_payload_container")
+    with contextlib.ExitStack() as stack:
+        if container_record is not None:
+            from pyamplicol.generation.evaluator_container import (
+                PacbinMemberKind,
+                PacbinReader,
+            )
+
+            container = _object(
+                container_record,
+                "artifact.extensions.evaluator_payload_container",
+            )
+            container_path = _canonical_member_path(
+                container.get("path"),
+                "artifact evaluator container path",
+            )
+            if container_path not in artifact_payloads:
+                raise PortabilityError(
+                    "consumer evaluator container is absent from artifact payloads"
+                )
+            packed_reader = stack.enter_context(
+                PacbinReader.open(artifact / PurePosixPath(container_path))
+            )
+
+        copied_paths: set[str] = set()
+        filtered_records = [
+            (f"filtered kernel {index}", raw)
+            for index, raw in enumerate(filtered_kernels)
+        ]
+        filtered_records.extend(
+            (f"filtered kernel variant {index}", raw)
+            for index, raw in enumerate(filtered_variants)
+        )
+        for context, raw_kernel in filtered_records:
+            kernel = _object(raw_kernel, context)
+            f64 = _object(kernel.get("f64_evaluator_manifest"), f"{context} f64")
+            plane = _object(
+                f64.get("plane_application"),
+                f"{context} f64 plane_application",
+            )
+            if (
+                plane.get("application_abi") != contracts.symjit_plane_application_abi
+                or plane.get("storage_abi") != contracts.symjit_application_abi
+            ):
+                raise PortabilityError(
+                    f"{context} has an incompatible plane-application ABI"
+                )
+            referenced_payloads = (
+                (
+                    "application_path",
+                    f64.get("application_path"),
+                ),
+                (
+                    "evaluator_state_path",
+                    f64.get("evaluator_state_path"),
+                ),
+                (
+                    "plane_application.application_path",
+                    plane.get("application_path"),
+                ),
+            )
+            for field, raw_source_path in referenced_payloads:
+                source_path = _canonical_member_path(
+                    raw_source_path, f"{context} {field}"
+                )
+                if field == "plane_application.application_path" and not (
+                    source_path.endswith(".plane.symjit")
+                ):
+                    raise PortabilityError(
+                        f"{context} has a noncanonical plane-application path"
+                    )
+                destination_path = f"model/eager-kernels/{source_path}"
+                source_record = bundle_members.get(source_path)
+                destination_record = artifact_payloads.get(destination_path)
+                packed_member = None
+                if packed_reader is not None:
+                    with contextlib.suppress(KeyError):
+                        packed_member = packed_reader.member(destination_path)
+                if source_record is None or (
+                    destination_record is None and packed_member is None
+                ):
+                    raise PortabilityError(
+                        f"consumer omitted transferred kernel payload {source_path!r}"
+                    )
+                source_sha = _string(source_record.get("sha256"), "source payload SHA")
+                if packed_member is not None:
+                    destination_sha = packed_member.sha256
+                    destination_payload = packed_reader.read_member(
+                        destination_path,
+                        length=packed_member.length,
+                    )
+                else:
+                    assert destination_record is not None
+                    destination_sha = _string(
+                        destination_record.get("sha256"),
+                        "destination payload SHA",
+                    )
+                    destination_payload = (
+                        artifact / PurePosixPath(destination_path)
+                    ).read_bytes()
+                if destination_sha != source_sha:
+                    raise PortabilityError(
+                        f"consumer rebuilt or changed kernel payload {source_path!r}"
+                    )
+                if destination_payload != bundle_payloads[source_path]:
+                    raise PortabilityError(
+                        f"consumer kernel payload {source_path!r} is not byte-identical"
+                    )
+                copied_paths.add(source_path)
+
+        for path, record in artifact_payloads.items():
+            suffix = PurePosixPath(path).suffix.lower()
+            if suffix in _FORBIDDEN_SUFFIXES:
+                raise PortabilityError(
+                    f"consumer artifact contains native/source payload {path!r}"
+                )
+            if path.startswith("model/eager-kernels/"):
+                payload = (artifact / PurePosixPath(path)).read_bytes()
+                native_kind = _native_payload_kind(payload)
+                if native_kind is not None:
+                    raise PortabilityError(
+                        f"consumer kernel payload {path!r} contains {native_kind}"
+                    )
+                if record.get("executable") is not False:
+                    raise PortabilityError(
+                        f"consumer kernel payload {path!r} is executable"
+                    )
+
+        if packed_reader is not None:
+            for member in packed_reader.members:
+                suffix = PurePosixPath(member.logical_path).suffix.lower()
+                if suffix in _FORBIDDEN_SUFFIXES:
+                    raise PortabilityError(
+                        "consumer evaluator container contains native/source payload "
+                        f"{member.logical_path!r}"
+                    )
+                if member.kind is PacbinMemberKind.NATIVE_LIBRARY:
+                    raise PortabilityError(
+                        "consumer evaluator container contains a native library "
+                        f"{member.logical_path!r}"
+                    )
+                prefix = packed_reader.read_member(
+                    member.logical_path,
+                    length=min(member.length, 64),
+                )
+                native_kind = _native_payload_kind(prefix)
+                if native_kind is not None:
+                    raise PortabilityError(
+                        "consumer evaluator container payload "
+                        f"{member.logical_path!r} contains {native_kind}"
+                    )
+
+    return {
+        "artifact_id": manifest.get("artifact_id"),
+        "copied_kernel_payload_count": len(copied_paths),
+        "filtered_kernel_count": len(filtered_kernels),
+        "filtered_kernel_variant_count": len(filtered_variants),
+        "process_id": DEFAULT_PROCESS_ID,
+        "runtime_kind": execution.get("kind"),
+    }
+
+
+def consume_transfer(
+    transfer_directory: Path,
+    *,
+    python: Path,
+    report_path: Path,
+    expected_system: str | None,
+    expected_machine: str | None,
+) -> dict[str, object]:
+    actual_system, actual_machine, actual_architecture = _host_identity(
+        "consumer",
+        expected_system=expected_system,
+        expected_machine=expected_machine,
+    )
+    transfer = transfer_directory.expanduser().resolve(strict=True)
+    fixture = _fixture(transfer / DEFAULT_FIXTURE_NAME)
+    bundle_record = _object(fixture.get("bundle"), "transfer.bundle")
+    bundle = transfer / _transfer_bundle_member(bundle_record.get("filename"))
+    contracts = _runtime_contracts()
+    audit = audit_architecture_jit_bundle(
+        bundle,
+        contracts=contracts,
+        expected_sha256=_string(bundle_record.get("bundle_sha256"), "bundle sha256"),
+        expected_architecture_class=actual_architecture,
+    )
+    if bundle_record.get("architecture_class") != audit["architecture_class"]:
+        raise PortabilityError(
+            "transfer fixture architecture differs from the prepared bundle"
+        )
+    if audit["producer_version"] != contracts.package_version:
+        raise PortabilityError(
+            "transferred bundle producer version differs from the consumer package"
+        )
+    if fixture.get("producer") is None:
+        raise PortabilityError("transfer fixture omits producer provenance")
+    producer = _object(fixture.get("producer"), "transfer.producer")
+    producer_architecture = architecture_class(
+        _string(
+            producer.get("architecture_class"),
+            "transfer.producer.architecture_class",
+        )
+    )
+    producer_machine_architecture = architecture_class(
+        _string(producer.get("machine"), "transfer.producer.machine")
+    )
+    if producer_architecture != producer_machine_architecture:
+        raise PortabilityError(
+            "producer machine and architecture-class provenance differ"
+        )
+    if producer.get("git_commit") != _git_commit():
+        raise PortabilityError("producer and consumer source commits differ")
+
+    process = _object(fixture.get("process"), "transfer.process")
+    if (
+        process.get("expression") != DEFAULT_PROCESS
+        or process.get("id") != DEFAULT_PROCESS_ID
+    ):
+        raise PortabilityError(
+            "transfer process fixture differs from the harness contract"
+        )
+    momenta = _array(process.get("momenta"), "transfer.process.momenta")
+    expected_record = _object(fixture.get("expected"), "transfer.expected")
+    expected = complex(
+        float(expected_record.get("real")),
+        float(expected_record.get("imaginary")),
+    )
+    rtol = float(expected_record.get("rtol"))
+    atol = float(expected_record.get("atol"))
+    if not all(math.isfinite(value) and value >= 0 for value in (rtol, atol)):
+        raise PortabilityError("transfer tolerances must be finite and non-negative")
+
+    bundle_sha_before = _sha256_file(bundle)
+    with tempfile.TemporaryDirectory(
+        prefix="pyamplicol-eager-portability-consumer-"
+    ) as raw:
+        artifact = Path(raw) / "eager"
+        with compiler_guard() as (environment, marker):
+            command = _generation_command(
+                python,
+                model=bundle,
+                output=artifact,
+                execution_mode="eager",
+            )
+            _run(command, environment=environment)
+            if marker.exists() and marker.stat().st_size:
+                invocations = marker.read_text(encoding="utf-8", errors="replace")
+                raise PortabilityError(
+                    "consumer eager generation invoked an external compiler/linker:\n"
+                    + invocations
+                )
+            # The generation child must exit before parent-side native imports.
+            preflight_count = _preflight_all_prepared_applications(bundle)
+            if bundle_record.get("preflight_evaluator_count") != preflight_count:
+                raise PortabilityError(
+                    "consumer prepared-application preflight count differs "
+                    "from producer"
+                )
+            audit["preflight_evaluator_count"] = preflight_count
+            artifact_summary = verify_consumer_artifact(
+                artifact,
+                bundle,
+                contracts=contracts,
+                bundle_audit=audit,
+            )
+            with _temporary_environment(environment):
+                actual = _evaluate_artifact(artifact, momenta)
+            if marker.exists() and marker.stat().st_size:
+                invocations = marker.read_text(encoding="utf-8", errors="replace")
+                raise PortabilityError(
+                    "consumer eager load/evaluation invoked an external "
+                    "compiler/linker:\n" + invocations
+                )
+
+    if _sha256_file(bundle) != bundle_sha_before:
+        raise PortabilityError("consumer modified the transferred prepared bundle")
+    if not _close(actual, expected, rtol=rtol, atol=atol):
+        raise PortabilityError(
+            "consumer f64 result differs from the producer compiled reference: "
+            f"actual={actual!r}, expected={expected!r}, "
+            f"difference={abs(actual - expected):.17g}"
+        )
+
+    report: dict[str, object] = {
+        "artifact": artifact_summary,
+        "bundle": audit,
+        "consumer": {
+            "architecture_class": actual_architecture,
+            "git_commit": _git_commit(),
+            "machine": actual_machine,
+            "package_version": contracts.package_version,
+            "python": platform.python_version(),
+            "system": actual_system,
+        },
+        "kind": CONSUMER_REPORT_KIND,
+        "numerical_check": {
+            "absolute_difference": abs(actual - expected),
+            "actual": {"imaginary": actual.imag, "real": actual.real},
+            "atol": atol,
+            "expected": {"imaginary": expected.imag, "real": expected.real},
+            "rtol": rtol,
+        },
+        "producer": producer,
+        "schema_version": CONSUMER_REPORT_SCHEMA_VERSION,
+    }
+    _write_json(report_path.expanduser().resolve(strict=False), report)
+    return report
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=("Produce and transfer-test portable built-in JIT O2 models."),
+    )
+    subparsers = parser.add_subparsers(dest="action", required=True)
+
+    audit = subparsers.add_parser(
+        "audit",
+        help="Audit one prepared JIT bundle without generating a process.",
+    )
+    audit.add_argument("bundle", type=Path)
+    audit.add_argument("--expected-sha256")
+    audit.add_argument(
+        "--expected-machine",
+        help="Supported machine class on which the portable bundle will be loaded.",
+    )
+
+    produce = subparsers.add_parser(
+        "produce",
+        help="Create the one transferable bundle and compiled-reference fixture.",
+    )
+    produce.add_argument("output_directory", type=Path)
+    produce.add_argument("--python", type=Path, default=Path(sys.executable))
+    produce.add_argument("--expected-system")
+    produce.add_argument("--expected-machine")
+    produce.add_argument(
+        "--asset-mode",
+        choices=("candidate", "release"),
+        default="candidate",
+        help=(
+            "Dependency identity written into the source-ready pack; release "
+            "pairs are placed below release_assets/prepared_models."
+        ),
+    )
+
+    consume = subparsers.add_parser(
+        "consume",
+        help="Consume a transferred bundle without rebuilding its kernels.",
+    )
+    consume.add_argument("transfer_directory", type=Path)
+    consume.add_argument("--python", type=Path, default=Path(sys.executable))
+    consume.add_argument("--report", type=Path, required=True)
+    consume.add_argument("--expected-system")
+    consume.add_argument("--expected-machine")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = _parser().parse_args(argv)
+    try:
+        if arguments.action == "audit":
+            expected_machine = arguments.expected_machine or platform.machine()
+            result = audit_architecture_jit_bundle(
+                arguments.bundle,
+                contracts=_runtime_contracts(),
+                expected_sha256=arguments.expected_sha256,
+                expected_architecture_class=architecture_class(expected_machine),
+            )
+        elif arguments.action == "produce":
+            result = produce_transfer(
+                arguments.output_directory,
+                python=_python_executable(arguments.python),
+                expected_system=arguments.expected_system,
+                expected_machine=arguments.expected_machine,
+                asset_mode=arguments.asset_mode,
+            )
+        else:
+            result = consume_transfer(
+                arguments.transfer_directory,
+                python=_python_executable(arguments.python),
+                report_path=arguments.report,
+                expected_system=arguments.expected_system,
+                expected_machine=arguments.expected_machine,
+            )
+    except (PortabilityError, OSError, ValueError) as error:
+        print(f"eager-portability: {error}", file=sys.stderr)
+        return 1
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/ci/eager_portability_contract.py b/pyamplicol/tools/ci/eager_portability_contract.py
new file mode 100644
index 0000000000..c83770b9c9
--- /dev/null
+++ b/pyamplicol/tools/ci/eager_portability_contract.py
@@ -0,0 +1,650 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Cross-architecture prepared-JIT contracts for the CI transfer harness.
+
+SymJIT application storage v3 at optimization level 2 can be reloaded across
+the supported x86-64 and AArch64 hosts. These checks intentionally run before
+the consumer asks SymJIT to load an application.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import stat
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+
+FORBIDDEN_SUFFIXES = frozenset(
+    {
+        ".a",
+        ".asm",
+        ".c",
+        ".cc",
+        ".cpp",
+        ".cxx",
+        ".dll",
+        ".dylib",
+        ".exe",
+        ".lib",
+        ".o",
+        ".obj",
+        ".s",
+        ".so",
+    }
+)
+_FORBIDDEN_MANIFEST_PATH_FIELDS = frozenset(
+    {
+        "assembly_path",
+        "library_path",
+        "object_path",
+        "source_path",
+    }
+)
+_NATIVE_MAGICS = (
+    (b"\x7fELF", "ELF image"),
+    (b"!<arch>\n", "static archive"),
+    (b"BC\xc0\xde", "LLVM bitcode"),
+    (b"\x00asm", "WebAssembly image"),
+    (b"\xfe\xed\xfa\xce", "Mach-O image"),
+    (b"\xce\xfa\xed\xfe", "Mach-O image"),
+    (b"\xfe\xed\xfa\xcf", "Mach-O image"),
+    (b"\xcf\xfa\xed\xfe", "Mach-O image"),
+    (b"\xca\xfe\xba\xbe", "Mach-O universal image"),
+    (b"\xbe\xba\xfe\xca", "Mach-O universal image"),
+)
+_COFF_MACHINE_IDS = frozenset(
+    {
+        0x014C,  # i386
+        0x01C0,  # ARM
+        0x01C4,  # ARMv7
+        0x8664,  # x86-64
+        0xAA64,  # ARM64
+    }
+)
+SYMJIT_STORAGE_V3_APPLICATION_ABI = "symjit-application-storage-v3"
+SYMJIT_PLANE_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+SYMJIT_STORAGE_V3_ARCHITECTURES = ("aarch64", "x86_64")
+_MACHINE_ARCHITECTURE_ALIASES = {
+    "aarch64": "aarch64",
+    "amd64": "x86_64",
+    "arm64": "aarch64",
+    "x64": "x86_64",
+    "x86-64": "x86_64",
+    "x86_64": "x86_64",
+}
+
+
+class PortabilityError(RuntimeError):
+    """Raised when the transfer or portability contract is violated."""
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeContracts:
+    """Installed package contracts relevant to a transferred JIT pack."""
+
+    bundle_kind: str
+    bundle_schema_version: int
+    eager_kernel_abi: str
+    compiled_model_schema_version: int
+    symbolica_serialization_abi: str
+    symjit_application_abi: str
+    symjit_plane_application_abi: str
+    symjit_runtime_capability: str
+    eager_runtime_capability: str
+    package_version: str
+
+
+def architecture_class(machine: str) -> str:
+    """Normalize a host machine name to a supported storage-v3 class."""
+
+    normalized = machine.strip().lower()
+    architecture = _MACHINE_ARCHITECTURE_ALIASES.get(normalized)
+    if architecture is None:
+        supported = ", ".join(SYMJIT_STORAGE_V3_ARCHITECTURES)
+        raise PortabilityError(
+            f"unsupported SymJIT storage-v3 machine {machine!r}; "
+            f"supported architecture classes are {supported}"
+        )
+    return architecture
+
+
+def symjit_storage_v3_target(architecture: str) -> dict[str, object]:
+    """Return the canonical portable target after checking the host class."""
+
+    if architecture not in SYMJIT_STORAGE_V3_ARCHITECTURES:
+        supported = ", ".join(SYMJIT_STORAGE_V3_ARCHITECTURES)
+        raise PortabilityError(
+            f"unsupported SymJIT storage-v3 architecture class {architecture!r}; "
+            f"expected one of {supported}"
+        )
+    return {
+        "cpu_features": [],
+        "endianness": "little",
+        "portable": True,
+        "target_triple": "symjit-storage-v3-portable",
+        "word_bits": 64,
+    }
+
+
+def _target_architecture_class(target: dict[str, object]) -> str:
+    """Return the storage class encoded by a prepared target.
+
+    Storage-v3 O2 applications contain portable MIR rather than host machine
+    code.  The producing and consuming hosts must each be supported, but their
+    architecture classes need not match.
+    """
+
+    if target == symjit_storage_v3_target("x86_64"):
+        return "portable"
+    raise PortabilityError(
+        "prepared JIT target must be portable 64-bit little-endian SymJIT storage-v3"
+    )
+
+
+def object_value(value: object, context: str) -> dict[str, object]:
+    if not isinstance(value, dict) or not all(isinstance(key, str) for key in value):
+        raise PortabilityError(f"{context} must be an object with string keys")
+    return value
+
+
+def array_value(value: object, context: str) -> list[object]:
+    if not isinstance(value, list):
+        raise PortabilityError(f"{context} must be an array")
+    return value
+
+
+def string_value(value: object, context: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise PortabilityError(f"{context} must be a non-empty string")
+    return value
+
+
+def integer_value(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise PortabilityError(f"{context} must be an integer")
+    return value
+
+
+def _sha256_bytes(payload: bytes) -> str:
+    return hashlib.sha256(payload).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for chunk in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def canonical_member_path(value: object, context: str) -> str:
+    path = string_value(value, context)
+    pure = PurePosixPath(path)
+    if (
+        pure.is_absolute()
+        or not pure.parts
+        or any(part in {"", ".", ".."} for part in pure.parts)
+        or "\\" in path
+    ):
+        raise PortabilityError(f"{context} is not a normalized relative path")
+    return pure.as_posix()
+
+
+def native_payload_kind(payload: bytes) -> str | None:
+    for magic, description in _NATIVE_MAGICS:
+        if payload.startswith(magic):
+            return description
+
+    if len(payload) >= 64 and payload.startswith(b"MZ"):
+        pe_offset = int.from_bytes(payload[0x3C:0x40], "little")
+        if (
+            0 <= pe_offset <= len(payload) - 4
+            and payload[pe_offset : pe_offset + 4] == b"PE\0\0"
+        ):
+            return "PE image"
+
+    if len(payload) >= 20:
+        machine = int.from_bytes(payload[0:2], "little")
+        section_count = int.from_bytes(payload[2:4], "little")
+        optional_header_size = int.from_bytes(payload[16:18], "little")
+        if (
+            machine in _COFF_MACHINE_IDS
+            and 0 < section_count < 256
+            and optional_header_size <= len(payload)
+        ):
+            return "COFF object"
+    return None
+
+
+def archive_manifest(path: Path) -> tuple[dict[str, object], dict[str, bytes]]:
+    if not path.is_file() or path.is_symlink():
+        raise PortabilityError("prepared JIT bundle must be a regular file")
+    if not path.name.lower().endswith(".pyamplicol-model"):
+        raise PortabilityError("prepared JIT bundle must end with .pyamplicol-model")
+
+    try:
+        with zipfile.ZipFile(path) as archive:
+            infos = archive.infolist()
+            names = [info.filename for info in infos]
+            if len(names) != len(set(names)):
+                raise PortabilityError("prepared JIT bundle has duplicate members")
+            if "manifest.json" not in names:
+                raise PortabilityError("prepared JIT bundle is missing manifest.json")
+
+            payloads: dict[str, bytes] = {}
+            for info in infos:
+                member = canonical_member_path(info.filename, "archive member")
+                if info.is_dir():
+                    raise PortabilityError(
+                        f"prepared JIT bundle contains directory member {member!r}"
+                    )
+                mode = info.external_attr >> 16
+                file_type = stat.S_IFMT(mode)
+                if file_type not in {0, stat.S_IFREG}:
+                    raise PortabilityError(
+                        f"prepared JIT bundle member {member!r} is not regular"
+                    )
+                if mode & 0o111:
+                    raise PortabilityError(
+                        f"prepared JIT bundle member {member!r} is executable"
+                    )
+                payloads[member] = archive.read(info)
+    except (OSError, zipfile.BadZipFile) as error:
+        raise PortabilityError(
+            f"could not read prepared JIT bundle: {error}"
+        ) from error
+
+    try:
+        manifest = json.loads(payloads["manifest.json"])
+    except (KeyError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise PortabilityError(
+            "prepared JIT manifest is not valid UTF-8 JSON"
+        ) from error
+    return object_value(manifest, "manifest"), payloads
+
+
+def audit_architecture_jit_bundle(
+    path: Path,
+    *,
+    contracts: RuntimeContracts,
+    expected_sha256: str | None = None,
+    expected_architecture_class: str | None = None,
+    expected_model_source: str = "built-in-sm",
+) -> dict[str, object]:
+    """Validate archive integrity and the portable storage-v3 contract."""
+
+    bundle_path = path.expanduser().resolve(strict=True)
+    bundle_sha256 = sha256_file(bundle_path)
+    if expected_sha256 is not None and bundle_sha256 != expected_sha256:
+        raise PortabilityError("transferred prepared JIT bundle SHA-256 mismatch")
+
+    manifest, archive_payloads = archive_manifest(bundle_path)
+    if manifest.get("kind") != contracts.bundle_kind:
+        raise PortabilityError("invalid prepared JIT bundle kind")
+    if manifest.get("schema_version") != contracts.bundle_schema_version:
+        raise PortabilityError("unsupported prepared JIT bundle schema")
+    if manifest.get("eager_kernel_abi") != contracts.eager_kernel_abi:
+        raise PortabilityError("prepared JIT eager-kernel ABI mismatch")
+
+    member_records = array_value(manifest.get("members"), "manifest.members")
+    recorded_members: dict[str, dict[str, object]] = {}
+    for index, raw_record in enumerate(member_records):
+        record = object_value(raw_record, f"manifest.members[{index}]")
+        member_path = canonical_member_path(
+            record.get("path"), f"manifest.members[{index}].path"
+        )
+        if member_path in recorded_members:
+            raise PortabilityError(f"duplicate manifest member {member_path!r}")
+        payload = archive_payloads.get(member_path)
+        if payload is None:
+            raise PortabilityError(f"manifest member {member_path!r} is missing")
+        if integer_value(record.get("size"), f"member {member_path!r} size") != len(
+            payload
+        ):
+            raise PortabilityError(f"manifest member {member_path!r} size mismatch")
+        if string_value(
+            record.get("sha256"), f"member {member_path!r} sha256"
+        ) != _sha256_bytes(payload):
+            raise PortabilityError(f"manifest member {member_path!r} SHA-256 mismatch")
+        recorded_members[member_path] = record
+
+    expected_members = set(recorded_members) | {"manifest.json"}
+    if set(archive_payloads) != expected_members:
+        unexpected = sorted(set(archive_payloads) - expected_members)
+        missing = sorted(expected_members - set(archive_payloads))
+        raise PortabilityError(
+            "prepared JIT archive member set differs from its manifest "
+            f"(unexpected={unexpected}, missing={missing})"
+        )
+
+    for member_path, payload in archive_payloads.items():
+        if member_path == "manifest.json":
+            continue
+        if PurePosixPath(member_path).suffix.lower() in FORBIDDEN_SUFFIXES:
+            raise PortabilityError(
+                f"prepared JIT bundle contains native/source payload {member_path!r}"
+            )
+        native_kind = native_payload_kind(payload)
+        if native_kind is not None:
+            raise PortabilityError(
+                f"prepared JIT bundle member {member_path!r} contains {native_kind}"
+            )
+
+    kernel_pack = object_value(manifest.get("kernel_pack"), "manifest.kernel_pack")
+    if kernel_pack.get("backend") != "jit":
+        raise PortabilityError("prepared pack backend must be jit")
+    target = object_value(kernel_pack.get("target"), "kernel_pack.target")
+    bundle_architecture = _target_architecture_class(target)
+    if expected_architecture_class is not None:
+        # Validate that the consumer belongs to a supported host class.  There
+        # is deliberately no equality check against ``bundle_architecture``:
+        # portable storage-v3 O2 applications are recompiled when loaded.
+        architecture_class(expected_architecture_class)
+    expected_target = symjit_storage_v3_target("x86_64")
+
+    dependency_abis = object_value(
+        kernel_pack.get("dependency_abis"), "kernel_pack.dependency_abis"
+    )
+    if contracts.symjit_application_abi != SYMJIT_STORAGE_V3_APPLICATION_ABI:
+        raise PortabilityError(
+            "this architecture-class transfer harness applies only to "
+            "SymJIT application storage v3"
+        )
+    if (
+        dependency_abis.get("symbolica_serialization")
+        != contracts.symbolica_serialization_abi
+    ):
+        raise PortabilityError("prepared JIT Symbolica serialization ABI mismatch")
+    if dependency_abis.get("symjit_application") != contracts.symjit_application_abi:
+        raise PortabilityError("prepared JIT application storage ABI mismatch")
+    if (
+        dependency_abis.get("symjit_plane_application")
+        != contracts.symjit_plane_application_abi
+    ):
+        raise PortabilityError("prepared JIT plane-application ABI mismatch")
+
+    optimization = object_value(
+        kernel_pack.get("optimization_settings"),
+        "kernel_pack.optimization_settings",
+    )
+    if (
+        optimization.get("backend") != "jit"
+        or optimization.get("jit_optimization_level") != 2
+    ):
+        raise PortabilityError("prepared JIT pack must use portable JIT O2")
+    if optimization.get("compiled_native") is not False:
+        raise PortabilityError("prepared JIT pack requests final native compilation")
+    if optimization.get("compiled_inline_asm") not in {None, "none"}:
+        raise PortabilityError("prepared JIT pack requests inline assembly")
+    if optimization.get("compiler_path") is not None:
+        raise PortabilityError("prepared JIT pack records an external compiler")
+    effective_flags = optimization.get("effective_compiler_flags")
+    if effective_flags is not None and effective_flags != []:
+        raise PortabilityError("prepared JIT pack records target compiler flags")
+
+    provenance = object_value(kernel_pack.get("provenance"), "kernel_pack.provenance")
+    model_source = object_value(provenance.get("model_source"), "pack model source")
+    expected_model = string_value(expected_model_source, "expected model source")
+    if (
+        provenance.get("model_name") != expected_model
+        or model_source.get("kind") != expected_model
+    ):
+        raise PortabilityError(
+            f"portability transfer must contain model {expected_model!r}"
+        )
+    producer = object_value(kernel_pack.get("producer"), "kernel_pack.producer")
+    if producer.get("distribution") != "pyamplicol":
+        raise PortabilityError("prepared JIT producer distribution is not pyamplicol")
+    if producer.get("compiled_model_schema") != contracts.compiled_model_schema_version:
+        raise PortabilityError("prepared JIT compiled-model schema mismatch")
+    producer_version = string_value(
+        producer.get("version"), "kernel_pack.producer.version"
+    )
+
+    kernels = array_value(kernel_pack.get("kernels"), "kernel_pack.kernels")
+    if not kernels:
+        raise PortabilityError("prepared JIT pack contains no kernels")
+    variants = array_value(
+        kernel_pack.get("kernel_variants", []),
+        "kernel_pack.kernel_variants",
+    )
+    evaluator_records = [
+        (f"kernel {index}", object_value(raw, f"kernel_pack.kernels[{index}]"))
+        for index, raw in enumerate(kernels)
+    ]
+    evaluator_records.extend(
+        (
+            f"kernel variant {index}",
+            object_value(raw, f"kernel_pack.kernel_variants[{index}]"),
+        )
+        for index, raw in enumerate(variants)
+    )
+    application_paths: set[str] = set()
+    plane_application_paths: set[str] = set()
+    exact_state_paths: set[str] = set()
+    for context, kernel in evaluator_records:
+        f64 = object_value(
+            kernel.get("f64_evaluator_manifest"),
+            f"{context}.f64_evaluator_manifest",
+        )
+        required = {
+            "application_abi": contracts.symjit_application_abi,
+            "backend": "jit",
+            "batch_layout": "row-major",
+            "compiler_type": "native",
+            "element_layout": "complex-f64",
+            "endianness": "little",
+            "kind": "symjit-application-evaluator",
+            "optimization_level": 2,
+            "runtime_capability": contracts.symjit_runtime_capability,
+            "translation_mode": "indirect",
+            "word_bits": 64,
+        }
+        for key, expected in required.items():
+            if f64.get(key) != expected:
+                raise PortabilityError(f"prepared {context} has incompatible {key!r}")
+        if f64.get("required_defuns") != []:
+            raise PortabilityError(f"prepared {context} requires external functions")
+        kernel_settings = object_value(
+            f64.get("settings"),
+            f"{context}.f64_evaluator_manifest.settings",
+        )
+        if kernel_settings.get("backend") != "jit":
+            raise PortabilityError(
+                f"prepared {context} settings select a non-JIT backend"
+            )
+        if kernel_settings.get("jit_optimization_level") != 2:
+            raise PortabilityError(
+                f"prepared {context} settings do not select portable JIT O2"
+            )
+        if kernel_settings.get("compiled_native") is not False:
+            raise PortabilityError(f"prepared {context} settings request native code")
+        if kernel_settings.get("compiled_inline_asm") not in {None, "none"}:
+            raise PortabilityError(
+                f"prepared {context} settings request inline assembly"
+            )
+        if kernel_settings.get("compiler_path") is not None:
+            raise PortabilityError(
+                f"prepared {context} settings record an external compiler"
+            )
+        kernel_flags = kernel_settings.get("effective_compiler_flags")
+        if kernel_flags is not None and kernel_flags != []:
+            raise PortabilityError(f"prepared {context} settings record compiler flags")
+        for field in _FORBIDDEN_MANIFEST_PATH_FIELDS:
+            if f64.get(field) not in {None, ""}:
+                raise PortabilityError(f"prepared {context} records forbidden {field}")
+        application_path = canonical_member_path(
+            f64.get("application_path"),
+            f"{context} application_path",
+        )
+        if not application_path.endswith(".symjit"):
+            raise PortabilityError(
+                f"prepared {context} application is not SymJIT storage"
+            )
+        exact_state_path = canonical_member_path(
+            f64.get("evaluator_state_path"),
+            f"{context} evaluator_state_path",
+        )
+        if not exact_state_path.endswith(".evaluator.bin"):
+            raise PortabilityError(
+                f"prepared {context} exact state has an unexpected format"
+            )
+        if (
+            application_path not in recorded_members
+            or exact_state_path not in recorded_members
+        ):
+            raise PortabilityError(f"prepared {context} omits referenced payloads")
+
+        plane = object_value(
+            f64.get("plane_application"),
+            f"{context}.f64_evaluator_manifest.plane_application",
+        )
+        input_complex_count = integer_value(
+            f64.get("input_len"),
+            f"{context}.f64_evaluator_manifest.input_len",
+        )
+        output_complex_count = integer_value(
+            f64.get("output_len"),
+            f"{context}.f64_evaluator_manifest.output_len",
+        )
+        if input_complex_count < 0 or output_complex_count < 1:
+            raise PortabilityError(
+                f"prepared {context} has invalid evaluator input/output counts"
+            )
+        plane_required = {
+            "application_abi": contracts.symjit_plane_application_abi,
+            "storage_abi": contracts.symjit_application_abi,
+            "element_layout": "split-complex-plane-major",
+            "descriptor_order": "inputs-re-im-then-outputs-re-im",
+            "input_complex_count": input_complex_count,
+            "output_complex_count": output_complex_count,
+            "input_plane_count": 2 * input_complex_count,
+            "output_plane_count": 2 * output_complex_count,
+            "compiler_type": "native",
+            "translation_mode": "symbolica-structured-instructions",
+            "optimization_level": 2,
+            "simd": True,
+            "complex": True,
+            "fast_math": True,
+            "fast_complex": False,
+            "threading": False,
+            "direct_arena": True,
+        }
+        for key, expected in plane_required.items():
+            if plane.get(key) != expected:
+                raise PortabilityError(
+                    f"prepared {context} has incompatible plane-application {key!r}"
+                )
+        if not isinstance(plane.get("compression"), bool):
+            raise PortabilityError(
+                f"prepared {context} has invalid plane-application compression"
+            )
+        source_digest = plane.get("source_digest")
+        if (
+            not isinstance(source_digest, str)
+            or len(source_digest) != 64
+            or any(character not in "0123456789abcdef" for character in source_digest)
+        ):
+            raise PortabilityError(
+                f"prepared {context} has invalid plane-application source digest"
+            )
+        plane_target = object_value(
+            plane.get("target"),
+            f"{context}.f64_evaluator_manifest.plane_application.target",
+        )
+        if (
+            plane_target.get("word_bits") != 64
+            or plane_target.get("endianness") != "little"
+        ):
+            raise PortabilityError(
+                f"prepared {context} has incompatible plane-application target"
+            )
+        plane_application_path = canonical_member_path(
+            plane.get("application_path"),
+            f"{context} plane-application path",
+        )
+        if not plane_application_path.endswith(".plane.symjit"):
+            raise PortabilityError(
+                f"prepared {context} plane application is not canonical SymJIT storage"
+            )
+        if plane_application_path not in recorded_members:
+            raise PortabilityError(
+                f"prepared {context} omits referenced plane-application payload"
+            )
+        application_paths.add(application_path)
+        plane_application_paths.add(plane_application_path)
+        exact_state_paths.add(exact_state_path)
+
+    compiled_model_path = "model/model.pyAmplicol-model.json"
+    expected_payload_members = (
+        application_paths
+        | plane_application_paths
+        | exact_state_paths
+        | {compiled_model_path}
+    )
+    if set(recorded_members) != expected_payload_members:
+        unexpected = sorted(set(recorded_members) - expected_payload_members)
+        missing = sorted(expected_payload_members - set(recorded_members))
+        raise PortabilityError(
+            "prepared JIT payload set differs from canonical application/state "
+            "members "
+            f"(unexpected={unexpected}, missing={missing})"
+        )
+    try:
+        compiled_model = object_value(
+            json.loads(archive_payloads[compiled_model_path]),
+            "compiled model",
+        )
+    except (KeyError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise PortabilityError("prepared bundle compiled model is invalid") from error
+    if compiled_model.get("schema_version") != contracts.compiled_model_schema_version:
+        raise PortabilityError("prepared bundle compiled-model payload is incompatible")
+    compiled_source = object_value(
+        compiled_model.get("source"), "compiled model source"
+    )
+    if compiled_source.get("kind") != expected_model:
+        raise PortabilityError(
+            f"prepared bundle compiled model is not {expected_model!r}"
+        )
+
+    return {
+        "backend": "jit",
+        "architecture_class": bundle_architecture,
+        "bundle_sha256": bundle_sha256,
+        "bundle_size": bundle_path.stat().st_size,
+        "compiled_model_digest": provenance.get("compiled_model_digest"),
+        "eager_kernel_abi": contracts.eager_kernel_abi,
+        "exact_state_count": len(exact_state_paths),
+        "kernel_count": len(kernels),
+        "kernel_variant_count": len(variants),
+        "model_compiler_version": producer.get("model_compiler_version"),
+        "producer_version": producer_version,
+        "symjit_application_count": len(application_paths),
+        "symjit_application_abi": contracts.symjit_application_abi,
+        "symjit_plane_application_count": len(plane_application_paths),
+        "symjit_plane_application_abi": contracts.symjit_plane_application_abi,
+        "target": expected_target,
+    }
+
+
+__all__ = [
+    "FORBIDDEN_SUFFIXES",
+    "SYMJIT_PLANE_APPLICATION_ABI",
+    "SYMJIT_STORAGE_V3_APPLICATION_ABI",
+    "SYMJIT_STORAGE_V3_ARCHITECTURES",
+    "PortabilityError",
+    "RuntimeContracts",
+    "architecture_class",
+    "archive_manifest",
+    "array_value",
+    "audit_architecture_jit_bundle",
+    "canonical_member_path",
+    "integer_value",
+    "native_payload_kind",
+    "object_value",
+    "sha256_file",
+    "string_value",
+    "symjit_storage_v3_target",
+]
diff --git a/pyamplicol/tools/ci/memory_watchdog.py b/pyamplicol/tools/ci/memory_watchdog.py
new file mode 100644
index 0000000000..d68ed0f012
--- /dev/null
+++ b/pyamplicol/tools/ci/memory_watchdog.py
@@ -0,0 +1,1278 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run a command under a conservative aggregate process-tree memory limit.
+
+The implementation deliberately uses only the Python standard library. Linux
+RSS data comes from ``/proc``; macOS uses the platform ``ps`` command and
+``proc_pid_rusage`` physical-footprint data. The child starts in a new process
+session so the watchdog can terminate both its process group and descendants
+that create another process group.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ctypes
+import ctypes.util
+import datetime as dt
+import errno
+import hashlib
+import json
+import math
+import os
+import platform
+import shlex
+import signal
+import struct
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from collections import defaultdict
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from contextlib import suppress
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TextIO
+
+GIB = 1024**3
+MIB = 1024**2
+DEFAULT_LIMIT_GIB = 30.0
+DEFAULT_POLL_INTERVAL = 0.25
+DEFAULT_TERMINATE_GRACE = 5.0
+MEMORY_LIMIT_EXIT_CODE = 137
+WATCHDOG_ERROR_EXIT_CODE = 125
+RSS_LIMIT_REASON = "process-tree-rss-limit"
+MEMORY_PROBE_REASON = "process-tree-memory-probe-unavailable"
+DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON = (
+    "darwin-process-tree-physical-footprint-limit"
+)
+DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON = (
+    "darwin-process-tree-physical-footprint-probe-unavailable"
+)
+WATCHDOG_REPORT_KIND = "pyamplicol-memory-watchdog-execution-report"
+WATCHDOG_REPORT_SCHEMA = 2
+WATCHDOG_SCOPE = "complete-orchestrator-process-tree-v1"
+_RUSAGE_INFO_V0 = 0
+_RUSAGE_INFO_V0_BYTES = 96
+_RUSAGE_INFO_PHYS_FOOTPRINT_OFFSET = 72
+
+
+class ProbeError(RuntimeError):
+    """Raised when resident-memory information cannot be collected."""
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessInfo:
+    """One process record from a platform RSS probe."""
+
+    pid: int
+    ppid: int
+    pgid: int
+    rss_bytes: int
+    cpu_seconds: float | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class MemorySample:
+    """Aggregate memory and members belonging to the guarded command."""
+
+    rss_bytes: int
+    members: tuple[ProcessInfo, ...]
+    physical_footprint_bytes: int | None = None
+
+
+Snapshotter = Callable[[], dict[int, ProcessInfo]]
+PhysicalFootprintProbe = Callable[[Iterable[int]], dict[int, int]]
+PidExistsProbe = Callable[[int], bool]
+
+
+def _pid_exists(pid: int) -> bool:
+    """Return whether ``pid`` still exists without requiring signal authority."""
+
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+def _canonical_json_bytes(value: object) -> bytes:
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+def _sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_json_bytes(value)).hexdigest()
+
+
+def _utc_now() -> str:
+    return dt.datetime.now(dt.UTC).isoformat()
+
+
+def _result_identity(path: Path) -> dict[str, object]:
+    lexical = Path(os.path.abspath(path.expanduser()))
+    resolved = lexical.resolve(strict=True)
+    if not resolved.is_file():
+        raise OSError(f"bound result is not a regular file: {path}")
+    before = resolved.stat()
+    digest = hashlib.sha256()
+    with resolved.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    after = resolved.stat()
+    if (
+        before.st_dev,
+        before.st_ino,
+        before.st_size,
+        before.st_mtime_ns,
+    ) != (
+        after.st_dev,
+        after.st_ino,
+        after.st_size,
+        after.st_mtime_ns,
+    ):
+        raise OSError(f"bound result changed while it was hashed: {path}")
+    return {
+        "path": str(path),
+        "resolved_path": str(resolved),
+        "size_bytes": after.st_size,
+        "sha256": digest.hexdigest(),
+    }
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    destination = Path(os.path.abspath(path.expanduser()))
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if destination.exists():
+        raise OSError(f"watchdog report already exists: {destination}")
+    temporary: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="wb",
+            dir=destination.parent,
+            prefix=f".{destination.name}.",
+            suffix=".tmp",
+            delete=False,
+        ) as stream:
+            temporary = Path(stream.name)
+            stream.write(_canonical_json_bytes(payload) + b"\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, destination)
+        temporary = None
+    finally:
+        if temporary is not None and temporary.exists():
+            temporary.unlink()
+
+
+def _positive_finite(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return parsed
+
+
+def _nonnegative_finite(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed < 0:
+        raise argparse.ArgumentTypeError("must be a non-negative finite number")
+    return parsed
+
+
+def _parse_proc_stat(text: str) -> tuple[int, int]:
+    """Return ``(ppid, pgid)`` from Linux ``/proc/PID/stat`` text."""
+
+    closing_parenthesis = text.rfind(")")
+    if closing_parenthesis < 0:
+        raise ValueError("missing process-name terminator")
+    fields = text[closing_parenthesis + 1 :].split()
+    # fields starts at the kernel's field 3 (state).
+    if len(fields) < 3:
+        raise ValueError("incomplete /proc stat record")
+    return int(fields[1]), int(fields[2])
+
+
+def _parse_proc_status_rss(text: str) -> int:
+    """Return RSS bytes from Linux ``/proc/PID/status`` text."""
+
+    for line in text.splitlines():
+        if not line.startswith("VmRSS:"):
+            continue
+        fields = line.split()
+        if len(fields) != 3 or fields[2].lower() != "kb":
+            raise ValueError(f"invalid VmRSS record: {line!r}")
+        return int(fields[1]) * 1024
+    return 0
+
+
+def _parse_ps_output(text: str) -> dict[int, ProcessInfo]:
+    """Parse ``ps -axo pid=,ppid=,pgid=,rss=`` output."""
+
+    records: dict[int, ProcessInfo] = {}
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        if not line.strip():
+            continue
+        fields = line.split()
+        if len(fields) != 4:
+            raise ValueError(f"invalid ps row {line_number}: {line!r}")
+        pid, ppid, pgid, rss_kib = map(int, fields)
+        if min(pid, ppid, pgid, rss_kib) < 0:
+            raise ValueError(f"negative ps value on row {line_number}")
+        records[pid] = ProcessInfo(pid, ppid, pgid, rss_kib * 1024)
+    return records
+
+
+def _linux_proc_snapshot(proc_root: Path = Path("/proc")) -> dict[int, ProcessInfo]:
+    """Collect a Linux process snapshot directly from procfs."""
+
+    records: dict[int, ProcessInfo] = {}
+    try:
+        entries = tuple(proc_root.iterdir())
+    except OSError as error:
+        raise ProbeError(f"cannot enumerate {proc_root}: {error}") from error
+    for entry in entries:
+        if not entry.name.isdecimal():
+            continue
+        pid = int(entry.name)
+        try:
+            stat_text = (entry / "stat").read_text(encoding="utf-8", errors="replace")
+            status_text = (entry / "status").read_text(
+                encoding="utf-8", errors="replace"
+            )
+            ppid, pgid = _parse_proc_stat(stat_text)
+            rss_bytes = _parse_proc_status_rss(status_text)
+        except (OSError, ValueError):
+            # Processes can disappear or become inaccessible between directory
+            # enumeration and reading their records.
+            continue
+        records[pid] = ProcessInfo(pid, ppid, pgid, rss_bytes)
+    if not records:
+        raise ProbeError(f"{proc_root} yielded no readable process records")
+    return records
+
+
+def _ps_snapshot() -> dict[int, ProcessInfo]:
+    """Collect a portable BSD/POSIX ``ps`` process snapshot."""
+
+    environment = os.environ.copy()
+    environment["LC_ALL"] = "C"
+    try:
+        completed = subprocess.run(
+            ["ps", "-axo", "pid=,ppid=,pgid=,rss="],
+            check=False,
+            capture_output=True,
+            text=True,
+            env=environment,
+            timeout=10,
+        )
+    except (OSError, subprocess.SubprocessError) as error:
+        raise ProbeError(f"cannot execute ps: {error}") from error
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or f"exit code {completed.returncode}"
+        raise ProbeError(f"ps process probe failed: {detail}")
+    try:
+        records = _parse_ps_output(completed.stdout)
+    except ValueError as error:
+        raise ProbeError(str(error)) from error
+    if not records:
+        raise ProbeError("ps process probe yielded no records")
+    return records
+
+
+def _parse_darwin_bsdinfo(text: bytes) -> tuple[int, int, int]:
+    """Return ``(pid, ppid, pgid)`` from Darwin ``proc_bsdinfo`` bytes."""
+
+    # These stable fields precede variable-size names in libproc.h.  pbi_pgid
+    # follows pbi_nfiles after the two fixed 16/32-byte name buffers.
+    if len(text) < 104:
+        raise ValueError("incomplete Darwin proc_bsdinfo record")
+    pid = struct.unpack_from("=I", text, 12)[0]
+    ppid = struct.unpack_from("=I", text, 16)[0]
+    pgid = struct.unpack_from("=I", text, 100)[0]
+    return pid, ppid, pgid
+
+
+def _parse_darwin_taskinfo_rss(text: bytes) -> int:
+    """Return resident bytes from Darwin ``proc_taskinfo`` bytes."""
+
+    if len(text) < 16:
+        raise ValueError("incomplete Darwin proc_taskinfo record")
+    return struct.unpack_from("=Q", text, 8)[0]
+
+
+def _parse_darwin_taskinfo_cpu_seconds(
+    text: bytes,
+    *,
+    timebase_numer: int,
+    timebase_denom: int,
+) -> float:
+    """Return cumulative user and system CPU seconds from ``proc_taskinfo``."""
+
+    if len(text) < 32:
+        raise ValueError("incomplete Darwin proc_taskinfo CPU record")
+    if timebase_numer <= 0 or timebase_denom <= 0:
+        raise ValueError("invalid Darwin Mach timebase")
+    user_ticks = struct.unpack_from("=Q", text, 16)[0]
+    system_ticks = struct.unpack_from("=Q", text, 24)[0]
+    return (user_ticks + system_ticks) * timebase_numer / timebase_denom / 1e9
+
+
+class _MachTimebaseInfo(ctypes.Structure):
+    _fields_ = (("numer", ctypes.c_uint32), ("denom", ctypes.c_uint32))
+
+
+def _darwin_mach_timebase(library: object | None = None) -> tuple[int, int]:
+    """Return the Mach absolute-time nanosecond conversion ratio."""
+
+    if library is None:
+        try:
+            library = ctypes.CDLL(None)
+        except OSError as error:
+            raise ProbeError(f"cannot load Darwin Mach runtime: {error}") from error
+    try:
+        mach_timebase_info = library.mach_timebase_info  # type: ignore[attr-defined]
+    except AttributeError as error:
+        raise ProbeError(f"cannot load mach_timebase_info: {error}") from error
+    mach_timebase_info.argtypes = (ctypes.POINTER(_MachTimebaseInfo),)
+    mach_timebase_info.restype = ctypes.c_int
+    timebase = _MachTimebaseInfo()
+    result = mach_timebase_info(ctypes.byref(timebase))
+    if result != 0 or timebase.numer <= 0 or timebase.denom <= 0:
+        raise ProbeError(
+            "Darwin mach_timebase_info failed "
+            f"(result={result}, numer={timebase.numer}, denom={timebase.denom})"
+        )
+    return int(timebase.numer), int(timebase.denom)
+
+
+def _parse_darwin_rusage_phys_footprint(text: bytes) -> int:
+    """Return ``ri_phys_footprint`` from Darwin ``rusage_info_v0`` bytes."""
+
+    minimum_size = _RUSAGE_INFO_PHYS_FOOTPRINT_OFFSET + 8
+    if len(text) < minimum_size:
+        raise ValueError("incomplete Darwin rusage_info_v0 record")
+    return struct.unpack_from(
+        "=Q", text, _RUSAGE_INFO_PHYS_FOOTPRINT_OFFSET
+    )[0]
+
+
+class DarwinPhysicalFootprintProbe:
+    """Read per-process physical footprints through Darwin ``libproc``."""
+
+    def __init__(
+        self,
+        library: object | None = None,
+        *,
+        pid_exists: PidExistsProbe = _pid_exists,
+    ) -> None:
+        if library is None:
+            library_name = (
+                ctypes.util.find_library("proc") or "/usr/lib/libproc.dylib"
+            )
+            try:
+                library = ctypes.CDLL(library_name, use_errno=True)
+            except OSError as error:
+                raise ProbeError(
+                    f"cannot load Darwin proc_pid_rusage: {error}"
+                ) from error
+        try:
+            proc_pid_rusage = library.proc_pid_rusage  # type: ignore[attr-defined]
+        except AttributeError as error:
+            raise ProbeError(
+                f"cannot load Darwin proc_pid_rusage: {error}"
+            ) from error
+        proc_pid_rusage.argtypes = (
+            ctypes.c_int,
+            ctypes.c_int,
+            ctypes.c_void_p,
+        )
+        proc_pid_rusage.restype = ctypes.c_int
+        self._proc_pid_rusage = proc_pid_rusage
+        self._pid_exists = pid_exists
+
+    def __call__(self, pids: Iterable[int]) -> dict[int, int]:
+        footprints: dict[int, int] = {}
+        for pid in sorted(set(pids)):
+            error_number = 0
+            buffer = ctypes.create_string_buffer(_RUSAGE_INFO_V0_BYTES)
+            for attempt in range(3):
+                ctypes.set_errno(0)
+                result = self._proc_pid_rusage(
+                    pid,
+                    _RUSAGE_INFO_V0,
+                    buffer,
+                )
+                if result == 0:
+                    footprints[pid] = _parse_darwin_rusage_phys_footprint(
+                        buffer.raw
+                    )
+                    break
+                error_number = ctypes.get_errno()
+                if error_number in {errno.ENOENT, errno.ESRCH}:
+                    # The process exited between the process-tree and
+                    # footprint snapshots. Its prior RSS remains in this
+                    # sample.
+                    break
+                if error_number not in {errno.EACCES, errno.EPERM} or attempt == 2:
+                    break
+                # Darwin can transiently report EPERM while a short-lived
+                # descendant crosses exec/exit. Retry the same PID in-place;
+                # persistent access failures still fail closed below.
+            else:  # pragma: no cover - the bounded loop always breaks
+                result = -1
+            if result == 0 or error_number in {errno.ENOENT, errno.ESRCH}:
+                continue
+            if error_number in {errno.EACCES, errno.EPERM} and not self._pid_exists(
+                pid
+            ):
+                # A short-lived descendant can remain in the preceding ``ps``
+                # snapshot while Darwin reports EPERM as it exits.  Omitting it
+                # lets the sampler conservatively retain that member's last RSS
+                # instead of discarding the aggregate sample.
+                continue
+            detail = (
+                os.strerror(error_number) if error_number else "unknown error"
+            )
+            raise ProbeError(
+                f"proc_pid_rusage({pid}) failed: {detail}"
+            )
+        return footprints
+
+
+def _darwin_libproc_snapshot() -> dict[int, ProcessInfo]:
+    """Collect a Darwin snapshot through libproc when ``ps`` is unavailable."""
+
+    library_name = ctypes.util.find_library("proc") or "/usr/lib/libproc.dylib"
+    try:
+        library = ctypes.CDLL(library_name)
+    except OSError as error:
+        raise ProbeError(f"cannot load Darwin libproc: {error}") from error
+
+    library.proc_listallpids.argtypes = (ctypes.c_void_p, ctypes.c_int)
+    library.proc_listallpids.restype = ctypes.c_int
+    library.proc_pidinfo.argtypes = (
+        ctypes.c_int,
+        ctypes.c_int,
+        ctypes.c_uint64,
+        ctypes.c_void_p,
+        ctypes.c_int,
+    )
+    library.proc_pidinfo.restype = ctypes.c_int
+
+    try:
+        timebase = _darwin_mach_timebase()
+    except ProbeError:
+        # CPU time is optional telemetry. Process inventory and RSS remain
+        # authoritative when the host cannot expose the Mach timebase.
+        timebase = None
+
+    estimated_count = library.proc_listallpids(None, 0)
+    if estimated_count <= 0:
+        raise ProbeError("Darwin libproc process enumeration failed")
+    capacity = estimated_count + 1024
+    pid_buffer = (ctypes.c_int * capacity)()
+    listed_count = library.proc_listallpids(pid_buffer, ctypes.sizeof(pid_buffer))
+    if listed_count <= 0:
+        raise ProbeError("Darwin libproc process enumeration yielded no records")
+
+    # PROC_PIDTBSDINFO and PROC_PIDTASKINFO are stable public libproc flavours.
+    proc_pidtbsdinfo = 3
+    proc_pidtaskinfo = 4
+    bsd_buffer = ctypes.create_string_buffer(256)
+    task_buffer = ctypes.create_string_buffer(256)
+    records: dict[int, ProcessInfo] = {}
+    for raw_pid in pid_buffer[: min(listed_count, capacity)]:
+        pid = int(raw_pid)
+        if pid <= 0:
+            continue
+        bsd_size = library.proc_pidinfo(
+            pid,
+            proc_pidtbsdinfo,
+            0,
+            bsd_buffer,
+            len(bsd_buffer),
+        )
+        task_size = library.proc_pidinfo(
+            pid,
+            proc_pidtaskinfo,
+            0,
+            task_buffer,
+            len(task_buffer),
+        )
+        if bsd_size < 104 or task_size < 16:
+            continue
+        try:
+            record_pid, ppid, pgid = _parse_darwin_bsdinfo(
+                bsd_buffer.raw[:bsd_size]
+            )
+            rss_bytes = _parse_darwin_taskinfo_rss(task_buffer.raw[:task_size])
+        except ValueError:
+            continue
+        if record_pid != pid:
+            continue
+        cpu_seconds = None
+        if timebase is not None:
+            with suppress(ValueError):
+                cpu_seconds = _parse_darwin_taskinfo_cpu_seconds(
+                    task_buffer.raw[:task_size],
+                    timebase_numer=timebase[0],
+                    timebase_denom=timebase[1],
+                )
+        records[pid] = ProcessInfo(pid, ppid, pgid, rss_bytes, cpu_seconds)
+    if not records:
+        raise ProbeError("Darwin libproc process probe yielded no records")
+    return records
+
+
+def process_snapshot(system: str | None = None) -> dict[int, ProcessInfo]:
+    """Collect one process snapshot on supported macOS and Linux hosts."""
+
+    host = system or platform.system()
+    if host == "Linux":
+        try:
+            return _linux_proc_snapshot()
+        except ProbeError:
+            return _ps_snapshot()
+    if host == "Darwin":
+        try:
+            return _ps_snapshot()
+        except ProbeError:
+            return _darwin_libproc_snapshot()
+    raise ProbeError(f"unsupported host for RSS monitoring: {host or '<unknown>'}")
+
+
+class ProcessTreeSampler:
+    """Track one process tree while retaining descendants that re-parent."""
+
+    def __init__(self, root_pid: int, root_pgid: int) -> None:
+        self.root_pid = root_pid
+        self.root_pgid = root_pgid
+        self._known_pids = {root_pid}
+
+    def sample(
+        self,
+        records: dict[int, ProcessInfo],
+        physical_footprint_probe: PhysicalFootprintProbe | None = None,
+    ) -> MemorySample:
+        children: dict[int, list[int]] = defaultdict(list)
+        for record in records.values():
+            children[record.ppid].append(record.pid)
+
+        selected = {pid for pid in self._known_pids if pid in records} | {
+            record.pid for record in records.values() if record.pgid == self.root_pgid
+        }
+        if self.root_pid in records:
+            selected.add(self.root_pid)
+
+        pending = list(selected)
+        while pending:
+            parent = pending.pop()
+            for child in children.get(parent, ()):
+                if child not in selected:
+                    selected.add(child)
+                    pending.append(child)
+
+        self._known_pids = selected
+        members = tuple(records[pid] for pid in sorted(selected))
+        physical_footprint: int | None = None
+        if physical_footprint_probe is not None:
+            footprints = physical_footprint_probe(
+                member.pid for member in members
+            )
+            # A member can exit between probes. Falling back to the member's
+            # RSS for that one sample is conservative and avoids dropping its
+            # last observed memory from the aggregate.
+            physical_footprint = sum(
+                footprints.get(member.pid, member.rss_bytes)
+                for member in members
+            )
+        return MemorySample(
+            rss_bytes=sum(record.rss_bytes for record in members),
+            members=members,
+            physical_footprint_bytes=physical_footprint,
+        )
+
+
+def _format_bytes(value: int) -> str:
+    return f"{value / GIB:.3f} GiB"
+
+
+def _guard_observation(sample: MemorySample) -> tuple[int, str]:
+    """Return the conservative enforced byte count and stable reason code."""
+
+    physical = sample.physical_footprint_bytes
+    if physical is not None and physical >= sample.rss_bytes:
+        return physical, DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON
+    return sample.rss_bytes, RSS_LIMIT_REASON
+
+
+def _normalized_exit_code(returncode: int) -> int:
+    if returncode >= 0:
+        return returncode
+    return 128 + min(-returncode, 127)
+
+
+def _signal_members(
+    members: Iterable[ProcessInfo], root_pgid: int, selected_signal: int
+) -> None:
+    try:
+        os.killpg(root_pgid, selected_signal)
+    except ProcessLookupError:
+        pass
+    except PermissionError:
+        pass
+    for member in members:
+        if member.pgid == root_pgid:
+            continue
+        try:
+            os.kill(member.pid, selected_signal)
+        except ProcessLookupError:
+            pass
+        except PermissionError:
+            pass
+
+
+def _terminate_tree(
+    process: subprocess.Popen[bytes],
+    sampler: ProcessTreeSampler,
+    snapshotter: Snapshotter,
+    *,
+    grace_period: float,
+    poll_interval: float,
+) -> None:
+    try:
+        sample = sampler.sample(snapshotter())
+    except ProbeError:
+        sample = MemorySample(0, ())
+    _signal_members(sample.members, sampler.root_pgid, signal.SIGTERM)
+
+    deadline = time.monotonic() + grace_period
+    while time.monotonic() < deadline:
+        try:
+            sample = sampler.sample(snapshotter())
+        except ProbeError:
+            sample = MemorySample(0, ())
+        if process.poll() is not None and not sample.members:
+            return
+        time.sleep(min(poll_interval, max(deadline - time.monotonic(), 0.01)))
+
+    try:
+        sample = sampler.sample(snapshotter())
+    except ProbeError:
+        sample = MemorySample(0, ())
+    _signal_members(sample.members, sampler.root_pgid, signal.SIGKILL)
+    with suppress(subprocess.TimeoutExpired):
+        process.wait(timeout=max(grace_period, 1.0))
+
+
+def _emit_final_report(
+    *,
+    report_path: Path | None,
+    bound_result_path: Path | None,
+    command: Sequence[str],
+    working_directory: str,
+    started_at_utc: str,
+    started_monotonic: float,
+    child_pid: int | None,
+    child_exit_code: int | None,
+    watchdog_exit_code: int,
+    outcome: str,
+    reason: str | None,
+    limit_bytes: int,
+    poll_interval: float,
+    terminate_grace: float,
+    metric: str,
+    probe_sample_count: int,
+    probe_failure_count: int,
+    maximum_consecutive_probe_failures: int,
+    peak_rss_bytes: int,
+    peak_physical_footprint_bytes: int | None,
+    peak_guard_bytes: int,
+    peak_processes: int,
+    stderr: TextIO,
+) -> int:
+    """Write one terminal content-addressed report and return the final status."""
+
+    if report_path is None:
+        return watchdog_exit_code
+
+    binding_error: str | None = None
+    bound_result: dict[str, object] | None = None
+    if bound_result_path is not None:
+        try:
+            bound_result = _result_identity(bound_result_path)
+        except OSError as error:
+            binding_error = str(error)
+            if watchdog_exit_code == 0:
+                watchdog_exit_code = WATCHDOG_ERROR_EXIT_CODE
+                outcome = "result-binding-failed"
+                reason = "bound-result-unavailable"
+
+    enforcement_completed = (
+        watchdog_exit_code == 0
+        and child_exit_code == 0
+        and outcome == "command-finished"
+    )
+    payload: dict[str, object] = {
+        "kind": WATCHDOG_REPORT_KIND,
+        "schema_version": WATCHDOG_REPORT_SCHEMA,
+        "complete": True,
+        "passes": (
+            watchdog_exit_code == 0
+            and child_exit_code == 0
+            and enforcement_completed
+            and (bound_result_path is None or bound_result is not None)
+        ),
+        "watchdog": _result_identity(Path(__file__).resolve()),
+        "working_directory": working_directory,
+        "execution": {
+            "command": list(command),
+            "command_sha256": _sha256(list(command)),
+            "started_at_utc": started_at_utc,
+            "finished_at_utc": _utc_now(),
+            "elapsed_wall_seconds": max(time.monotonic() - started_monotonic, 0.0),
+            "child_pid": child_pid,
+            "child_exit_code": child_exit_code,
+            "watchdog_exit_code": watchdog_exit_code,
+            "outcome": outcome,
+            "reason": reason,
+        },
+        "enforcement": {
+            "scope": WATCHDOG_SCOPE,
+            "limit_bytes": limit_bytes,
+            "poll_interval_seconds": poll_interval,
+            "terminate_grace_seconds": terminate_grace,
+            "metric": metric,
+            "probe_sample_count": probe_sample_count,
+            "probe_failure_count": probe_failure_count,
+            "maximum_consecutive_probe_failures": (
+                maximum_consecutive_probe_failures
+            ),
+            "completed_under_retry_policy": enforcement_completed,
+            "peak_rss_bytes": peak_rss_bytes,
+            "peak_physical_footprint_bytes": peak_physical_footprint_bytes,
+            "peak_guard_bytes": peak_guard_bytes,
+            "peak_processes": peak_processes,
+        },
+        "result_binding": {
+            "requested": bound_result_path is not None,
+            "requested_path": (
+                None if bound_result_path is None else str(bound_result_path)
+            ),
+            "identity": bound_result,
+            "error": binding_error,
+        },
+    }
+    payload["content_sha256"] = _sha256(payload)
+    try:
+        _write_json_atomic(report_path, payload)
+    except OSError as error:
+        print(
+            f"memory-watchdog: cannot write final report: {error}",
+            file=stderr,
+            flush=True,
+        )
+        return WATCHDOG_ERROR_EXIT_CODE
+    return watchdog_exit_code
+
+
+def run_guarded(
+    command: Sequence[str],
+    *,
+    limit_bytes: int,
+    poll_interval: float = DEFAULT_POLL_INTERVAL,
+    terminate_grace: float = DEFAULT_TERMINATE_GRACE,
+    snapshotter: Snapshotter = process_snapshot,
+    physical_footprint_probe: PhysicalFootprintProbe | None = None,
+    stderr: TextIO = sys.stderr,
+    report_path: Path | None = None,
+    bound_result_path: Path | None = None,
+) -> int:
+    """Run ``command`` and return its shell-compatible exit status."""
+
+    if not command:
+        raise ValueError("command must not be empty")
+    if limit_bytes <= 0:
+        raise ValueError("limit_bytes must be positive")
+    if poll_interval <= 0:
+        raise ValueError("poll_interval must be positive")
+    if terminate_grace < 0:
+        raise ValueError("terminate_grace must be non-negative")
+
+    started_at_utc = _utc_now()
+    started_monotonic = time.monotonic()
+    working_directory = str(Path.cwd())
+    metric = (
+        "max(process-tree-rss,darwin-process-tree-physical-footprint)"
+        if physical_footprint_probe is not None
+        else "process-tree-rss"
+    )
+    child_pid: int | None = None
+    peak_rss = 0
+    peak_physical_footprint: int | None = (
+        0 if physical_footprint_probe is not None else None
+    )
+    peak_guard = 0
+    peak_processes = 0
+    probe_sample_count = 0
+    probe_failure_count = 0
+    maximum_consecutive_probe_failures = 0
+    report_emitted = False
+
+    def finish(
+        exit_code: int,
+        *,
+        child_exit_code: int | None,
+        outcome: str,
+        reason: str | None = None,
+    ) -> int:
+        nonlocal report_emitted
+        report_emitted = True
+        return _emit_final_report(
+            report_path=report_path,
+            bound_result_path=bound_result_path,
+            command=command,
+            working_directory=working_directory,
+            started_at_utc=started_at_utc,
+            started_monotonic=started_monotonic,
+            child_pid=child_pid,
+            child_exit_code=child_exit_code,
+            watchdog_exit_code=exit_code,
+            outcome=outcome,
+            reason=reason,
+            limit_bytes=limit_bytes,
+            poll_interval=poll_interval,
+            terminate_grace=terminate_grace,
+            metric=metric,
+            probe_sample_count=probe_sample_count,
+            probe_failure_count=probe_failure_count,
+            maximum_consecutive_probe_failures=(
+                maximum_consecutive_probe_failures
+            ),
+            peak_rss_bytes=peak_rss,
+            peak_physical_footprint_bytes=peak_physical_footprint,
+            peak_guard_bytes=peak_guard,
+            peak_processes=peak_processes,
+            stderr=stderr,
+        )
+
+    try:
+        process = subprocess.Popen(tuple(command), start_new_session=True)
+    except FileNotFoundError:
+        print(f"memory-watchdog: command not found: {command[0]}", file=stderr)
+        return finish(
+            127,
+            child_exit_code=None,
+            outcome="command-not-found",
+            reason="command-not-found",
+        )
+    except OSError as error:
+        print(f"memory-watchdog: cannot start command: {error}", file=stderr)
+        return finish(
+            126,
+            child_exit_code=None,
+            outcome="command-start-failed",
+            reason="command-start-failed",
+        )
+
+    child_pid = process.pid
+    sampler = ProcessTreeSampler(process.pid, process.pid)
+    print(
+        "memory-watchdog: guarding"
+        f" pid={process.pid} limit={_format_bytes(limit_bytes)}"
+        f" metric={metric}"
+        f" command={shlex.join(command)}",
+        file=stderr,
+        flush=True,
+    )
+
+    received_signal: int | None = None
+    previous_handlers: dict[int, signal.Handlers] = {}
+
+    def remember_signal(signum: int, _frame: object) -> None:
+        nonlocal received_signal
+        received_signal = signum
+
+    if threading.current_thread() is threading.main_thread():
+        for selected_signal in (signal.SIGINT, signal.SIGTERM, signal.SIGHUP):
+            previous_handlers[selected_signal] = signal.getsignal(selected_signal)
+            signal.signal(selected_signal, remember_signal)
+
+    consecutive_probe_failures = 0
+    pending_probe_reason: str | None = None
+    try:
+        while True:
+            if received_signal is not None:
+                _terminate_tree(
+                    process,
+                    sampler,
+                    snapshotter,
+                    grace_period=terminate_grace,
+                    poll_interval=poll_interval,
+                )
+                return finish(
+                    128 + received_signal,
+                    child_exit_code=(
+                        None
+                        if process.poll() is None
+                        else _normalized_exit_code(process.returncode)
+                    ),
+                    outcome="watchdog-signalled",
+                    reason=f"signal-{received_signal}",
+                )
+
+            if pending_probe_reason is not None:
+                returncode = process.poll()
+                if returncode is not None:
+                    print(
+                        "memory-watchdog: command exited while memory"
+                        " enforcement was unavailable"
+                        f" reason={pending_probe_reason}"
+                        f" child_exit={_normalized_exit_code(returncode)}",
+                        file=stderr,
+                        flush=True,
+                    )
+                    return finish(
+                        WATCHDOG_ERROR_EXIT_CODE,
+                        child_exit_code=_normalized_exit_code(returncode),
+                        outcome="memory-enforcement-unavailable",
+                        reason=pending_probe_reason,
+                    )
+
+            probe_reason = MEMORY_PROBE_REASON
+            try:
+                records = snapshotter()
+                if physical_footprint_probe is not None:
+                    probe_reason = DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON
+                sample = sampler.sample(
+                    records,
+                    physical_footprint_probe=physical_footprint_probe,
+                )
+            except ProbeError as error:
+                consecutive_probe_failures += 1
+                probe_failure_count += 1
+                maximum_consecutive_probe_failures = max(
+                    maximum_consecutive_probe_failures,
+                    consecutive_probe_failures,
+                )
+                pending_probe_reason = probe_reason
+                print(
+                    "memory-watchdog: memory probe failed"
+                    f" ({consecutive_probe_failures}/3)"
+                    f" reason={probe_reason}: {error}",
+                    file=stderr,
+                    flush=True,
+                )
+                returncode = process.poll()
+                if returncode is not None:
+                    print(
+                        "memory-watchdog: command exited while memory"
+                        " enforcement was unavailable"
+                        f" reason={probe_reason}"
+                        f" child_exit={_normalized_exit_code(returncode)}",
+                        file=stderr,
+                        flush=True,
+                    )
+                    return finish(
+                        WATCHDOG_ERROR_EXIT_CODE,
+                        child_exit_code=_normalized_exit_code(returncode),
+                        outcome="memory-enforcement-unavailable",
+                        reason=probe_reason,
+                    )
+                if consecutive_probe_failures >= 3:
+                    _terminate_tree(
+                        process,
+                        sampler,
+                        snapshotter,
+                        grace_period=terminate_grace,
+                        poll_interval=poll_interval,
+                    )
+                    print(
+                        "memory-watchdog: terminating after repeated memory"
+                        f" probe failures reason={probe_reason}",
+                        file=stderr,
+                        flush=True,
+                    )
+                    return finish(
+                        WATCHDOG_ERROR_EXIT_CODE,
+                        child_exit_code=(
+                            None
+                            if process.poll() is None
+                            else _normalized_exit_code(process.returncode)
+                        ),
+                        outcome="memory-probe-failed",
+                        reason=probe_reason,
+                    )
+            else:
+                probe_sample_count += 1
+                if pending_probe_reason is not None:
+                    returncode = process.poll()
+                    if returncode is not None:
+                        print(
+                            "memory-watchdog: command exited while memory"
+                            " enforcement was unavailable"
+                            f" reason={pending_probe_reason}"
+                            f" child_exit={_normalized_exit_code(returncode)}",
+                            file=stderr,
+                            flush=True,
+                        )
+                        return finish(
+                            WATCHDOG_ERROR_EXIT_CODE,
+                            child_exit_code=_normalized_exit_code(returncode),
+                            outcome="memory-enforcement-unavailable",
+                            reason=pending_probe_reason,
+                        )
+                consecutive_probe_failures = 0
+                pending_probe_reason = None
+                peak_rss = max(peak_rss, sample.rss_bytes)
+                if sample.physical_footprint_bytes is not None:
+                    peak_physical_footprint = max(
+                        peak_physical_footprint or 0,
+                        sample.physical_footprint_bytes,
+                    )
+                guard_bytes, limit_reason = _guard_observation(sample)
+                peak_guard = max(peak_guard, guard_bytes)
+                peak_processes = max(peak_processes, len(sample.members))
+                if guard_bytes > limit_bytes:
+                    physical_detail = (
+                        _format_bytes(sample.physical_footprint_bytes)
+                        if sample.physical_footprint_bytes is not None
+                        else "unavailable"
+                    )
+                    print(
+                        "memory-watchdog: memory limit exceeded"
+                        f" reason={limit_reason}"
+                        f" observed={_format_bytes(guard_bytes)}"
+                        f" limit={_format_bytes(limit_bytes)}"
+                        f" rss={_format_bytes(sample.rss_bytes)}"
+                        f" physical_footprint={physical_detail}"
+                        f" processes={len(sample.members)};"
+                        " terminating tree",
+                        file=stderr,
+                        flush=True,
+                    )
+                    _terminate_tree(
+                        process,
+                        sampler,
+                        snapshotter,
+                        grace_period=terminate_grace,
+                        poll_interval=poll_interval,
+                    )
+                    return finish(
+                        MEMORY_LIMIT_EXIT_CODE,
+                        child_exit_code=(
+                            None
+                            if process.poll() is None
+                            else _normalized_exit_code(process.returncode)
+                        ),
+                        outcome="memory-limit-exceeded",
+                        reason=limit_reason,
+                    )
+
+            returncode = process.poll()
+            if returncode is not None:
+                if consecutive_probe_failures:
+                    assert pending_probe_reason is not None
+                    print(
+                        "memory-watchdog: command exited while memory"
+                        " enforcement was unavailable"
+                        f" reason={pending_probe_reason}"
+                        f" child_exit={_normalized_exit_code(returncode)}",
+                        file=stderr,
+                        flush=True,
+                    )
+                    return finish(
+                        WATCHDOG_ERROR_EXIT_CODE,
+                        child_exit_code=_normalized_exit_code(returncode),
+                        outcome="memory-enforcement-unavailable",
+                        reason=pending_probe_reason,
+                    )
+                normalized = _normalized_exit_code(returncode)
+                footprint_detail = (
+                    _format_bytes(peak_physical_footprint)
+                    if peak_physical_footprint is not None
+                    else "unavailable"
+                )
+                print(
+                    "memory-watchdog: command finished"
+                    f" exit={normalized} peak_rss={_format_bytes(peak_rss)}"
+                    f" peak_physical_footprint={footprint_detail}"
+                    f" peak_guard={_format_bytes(peak_guard)}"
+                    f" peak_processes={peak_processes}",
+                    file=stderr,
+                    flush=True,
+                )
+                return finish(
+                    normalized,
+                    child_exit_code=normalized,
+                    outcome="command-finished",
+                    reason=None,
+                )
+            time.sleep(poll_interval)
+    finally:
+        for selected_signal, previous in previous_handlers.items():
+            signal.signal(selected_signal, previous)
+        if process.poll() is None:
+            _terminate_tree(
+                process,
+                sampler,
+                snapshotter,
+                grace_period=terminate_grace,
+                poll_interval=poll_interval,
+            )
+        if not report_emitted:
+            finish(
+                WATCHDOG_ERROR_EXIT_CODE,
+                child_exit_code=(
+                    None
+                    if process.poll() is None
+                    else _normalized_exit_code(process.returncode)
+                ),
+                outcome="watchdog-exception",
+                reason="watchdog-exception",
+            )
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "run a command and terminate its process tree when conservative "
+            "aggregate memory exceeds a limit"
+        )
+    )
+    limits = parser.add_mutually_exclusive_group()
+    limits.add_argument(
+        "--limit-gib",
+        type=_positive_finite,
+        help=f"memory limit in GiB (default: {DEFAULT_LIMIT_GIB:g})",
+    )
+    limits.add_argument(
+        "--limit-mib",
+        type=_positive_finite,
+        help="memory limit in MiB; useful for focused watchdog tests",
+    )
+    parser.add_argument(
+        "--poll-interval",
+        type=_positive_finite,
+        default=DEFAULT_POLL_INTERVAL,
+        help=f"seconds between probes (default: {DEFAULT_POLL_INTERVAL:g})",
+    )
+    parser.add_argument(
+        "--terminate-grace",
+        type=_nonnegative_finite,
+        default=DEFAULT_TERMINATE_GRACE,
+        help=(
+            "seconds between TERM and KILL when stopping a tree "
+            f"(default: {DEFAULT_TERMINATE_GRACE:g})"
+        ),
+    )
+    parser.add_argument(
+        "--report-json",
+        type=Path,
+        help=(
+            "write one terminal content-addressed execution report on success "
+            "or failure"
+        ),
+    )
+    parser.add_argument(
+        "--bind-result-json",
+        type=Path,
+        help=(
+            "content-address this command result in --report-json; the guarded "
+            "command must create it"
+        ),
+    )
+    parser.add_argument(
+        "command",
+        nargs=argparse.REMAINDER,
+        help="command to run, conventionally preceded by --",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _parser()
+    arguments = parser.parse_args(argv)
+    command = list(arguments.command)
+    if command and command[0] == "--":
+        command.pop(0)
+    if not command:
+        parser.error("a command is required after --")
+    if arguments.bind_result_json is not None and arguments.report_json is None:
+        parser.error("--bind-result-json requires --report-json")
+    if (
+        arguments.report_json is not None
+        and arguments.bind_result_json is not None
+        and Path(os.path.abspath(arguments.report_json.expanduser()))
+        == Path(os.path.abspath(arguments.bind_result_json.expanduser()))
+    ):
+        parser.error("--report-json and --bind-result-json must be different files")
+
+    if arguments.limit_mib is not None:
+        limit_bytes = int(arguments.limit_mib * MIB)
+    else:
+        limit_gib = arguments.limit_gib or DEFAULT_LIMIT_GIB
+        limit_bytes = int(limit_gib * GIB)
+    physical_footprint_probe: PhysicalFootprintProbe | None = None
+    if platform.system() == "Darwin":
+        try:
+            physical_footprint_probe = DarwinPhysicalFootprintProbe()
+        except ProbeError as error:
+            started_at_utc = _utc_now()
+            started_monotonic = time.monotonic()
+            print(
+                "memory-watchdog: Darwin physical-footprint probe unavailable"
+                f" reason={DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON}: {error}",
+                file=sys.stderr,
+                flush=True,
+            )
+            return _emit_final_report(
+                report_path=arguments.report_json,
+                bound_result_path=arguments.bind_result_json,
+                command=command,
+                working_directory=str(Path.cwd()),
+                started_at_utc=started_at_utc,
+                started_monotonic=started_monotonic,
+                child_pid=None,
+                child_exit_code=None,
+                watchdog_exit_code=WATCHDOG_ERROR_EXIT_CODE,
+                outcome="memory-probe-initialization-failed",
+                reason=DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON,
+                limit_bytes=limit_bytes,
+                poll_interval=arguments.poll_interval,
+                terminate_grace=arguments.terminate_grace,
+                metric=(
+                    "max(process-tree-rss,"
+                    "darwin-process-tree-physical-footprint)"
+                ),
+                probe_sample_count=0,
+                probe_failure_count=1,
+                maximum_consecutive_probe_failures=1,
+                peak_rss_bytes=0,
+                peak_physical_footprint_bytes=0,
+                peak_guard_bytes=0,
+                peak_processes=0,
+                stderr=sys.stderr,
+            )
+    return run_guarded(
+        command,
+        limit_bytes=limit_bytes,
+        poll_interval=arguments.poll_interval,
+        terminate_grace=arguments.terminate_grace,
+        physical_footprint_probe=physical_footprint_probe,
+        report_path=arguments.report_json,
+        bound_result_path=arguments.bind_result_json,
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/amplicol_z6g_m0_capture.py b/pyamplicol/tools/developer/amplicol_z6g_m0_capture.py
new file mode 100755
index 0000000000..4c0c7c35ac
--- /dev/null
+++ b/pyamplicol/tools/developer/amplicol_z6g_m0_capture.py
@@ -0,0 +1,1822 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Capture strict original-AmpliCol evidence for the qq_Z6g M0 gate.
+
+The public ``capture`` command validates the four pyAmpliCol inputs from an
+M0 request template, builds the pinned original-AmpliCol probes, and records
+seven paired selected/all-flow subprocess rounds.  The private ``_sample``
+command is the content-addressed executable retained in every timing record;
+it wraps ``amplicol_library_benchmark`` or ``amplicol_color_probe`` and emits
+one strict ``amplicol-m0-probe-result`` JSON object on stdout.
+
+This program intentionally has no synthetic or diagnostic-success mode.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import datetime as dt
+import hashlib
+import importlib.util
+import json
+import math
+import os
+import platform
+import shlex
+import shutil
+import statistics
+import subprocess
+import sys
+import tempfile
+from collections.abc import Iterator, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from types import ModuleType
+from typing import Any, NoReturn
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = Path(__file__).resolve()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.developer import legacy_amplicol  # noqa: E402
+
+PROCESS_EXPRESSION = "u u~ > Z g g g g g g"
+NORMALIZED_PROCESS = "u u~ > z g g g g g g"
+AMPLICOL_EXTERNAL_LEG_PERMUTATION = (0, 1, 3, 4, 5, 6, 7, 8, 2)
+SELECTED_ROLE = "selected-flow-helicity-sum"
+UNION_ROLE = "all-flow-single-helicity"
+ROLES = (SELECTED_ROLE, UNION_ROLE)
+SELECTED_WORKLOAD = "single-runtime-selected-flow/helicity-sum"
+UNION_WORKLOAD = "all-flows/runtime-selected-single-helicity"
+MIN_SAMPLES = 7
+RTOL = 1.0e-12
+ATOL = 1.0e-15
+DEFAULT_TARGET_SECONDS = 5.0
+DEFAULT_WARMUP_POINTS = 100
+DEFAULT_MINIMUM_POINTS = 100
+DEFAULT_MAXIMUM_POINTS = 100_000
+_SAMPLE_RUNTIME_RELATIVE_FILES = (
+    Path("tools/developer/amplicol_z6g_m0_capture.py"),
+    Path("tools/developer/legacy_amplicol.py"),
+    Path("tools/developer/legacy_oracle/__init__.py"),
+    Path("tools/developer/legacy_oracle/checkout.py"),
+    Path("tools/developer/legacy_oracle/evidence.py"),
+    Path("tools/developer/legacy_oracle/model.py"),
+    Path("tools/developer/legacy_oracle/probe.py"),
+    Path("tools/developer/legacy_oracle/processes.py"),
+    Path("dependencies/contributor-lock.toml"),
+)
+
+_M0_REQUEST_KEYS = {
+    "kind",
+    "schema_version",
+    "captures",
+    "amplicol_evidence",
+    "expected",
+}
+_PROBE_RESULT_KEYS = {
+    "kind",
+    "schema_version",
+    "role",
+    "sample_index",
+    "evaluated_point_count",
+    "elapsed_seconds",
+    "seconds_per_point",
+    "selected_totals",
+    "resolved_sums",
+}
+
+
+class CaptureError(RuntimeError):
+    """The authoritative original-AmpliCol capture could not be completed."""
+
+
+@dataclass(frozen=True, slots=True)
+class CaptureContract:
+    """Cross-validated physical and provenance contract from four M0 captures."""
+
+    expected: dict[str, Any]
+    input_files: tuple[dict[str, Any], ...]
+    host: dict[str, Any]
+    fixture: dict[str, Any]
+    color_axis: dict[str, Any]
+    helicity_axis: dict[str, Any]
+    color_flow_request: str
+    helicity_request: str
+    selected_values: tuple[complex, ...]
+    union_values: tuple[complex, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ProbeContext:
+    """Immutable original-AmpliCol row and snapshotted execution inputs."""
+
+    runtime: Path
+    worker_executable: Path
+    process_file: Path
+    selected_binary: Path
+    union_binary: Path
+    linked_files: tuple[Path, ...]
+    group: int
+    integral: int
+    source_pdgs: tuple[int, ...]
+    generated_pdgs: tuple[int, ...]
+    generated_color_order: tuple[int, ...]
+    permutation: tuple[int, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class SourceEvidence:
+    """Pinned original-AmpliCol source/compiler identity."""
+
+    source: dict[str, Any]
+    source_files: tuple[dict[str, Any], ...]
+
+
+def _die(message: str) -> NoReturn:
+    raise CaptureError(message)
+
+
+def _canonical_bytes(value: object) -> bytes:
+    return json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        allow_nan=False,
+    ).encode("utf-8")
+
+
+def _canonical_sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_bytes(value)).hexdigest()
+
+
+def _file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _file_ref(path: Path) -> dict[str, Any]:
+    resolved = path.resolve(strict=True)
+    if not resolved.is_file():
+        _die(f"evidence path is not a file: {resolved}")
+    return {
+        "path": str(resolved),
+        "size_bytes": resolved.stat().st_size,
+        "sha256": _file_sha256(resolved),
+    }
+
+
+def _write_json(path: Path, payload: Mapping[str, Any]) -> dict[str, Any]:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    raw = _canonical_bytes(payload) + b"\n"
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    temporary.write_bytes(raw)
+    os.replace(temporary, path)
+    return _file_ref(path)
+
+
+def _content_addressed(payload: Mapping[str, Any]) -> dict[str, Any]:
+    result = dict(payload)
+    if "content_sha256" in result:
+        _die("content-addressing input already contains content_sha256")
+    result["content_sha256"] = _canonical_sha256(result)
+    return result
+
+
+def _strict_json(raw: bytes, label: str) -> dict[str, Any]:
+    def reject_duplicate(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+        result: dict[str, Any] = {}
+        for key, value in pairs:
+            if key in result:
+                _die(f"{label} contains duplicate JSON key {key!r}")
+            result[key] = value
+        return result
+
+    try:
+        value = json.loads(
+            raw,
+            object_pairs_hook=reject_duplicate,
+            parse_constant=lambda token: _die(
+                f"{label} contains non-finite JSON number {token}"
+            ),
+        )
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise CaptureError(f"{label} is not strict JSON: {error}") from error
+    if not isinstance(value, dict):
+        _die(f"{label} must be a JSON object")
+    return value
+
+
+def _load_json(path: Path, label: str) -> dict[str, Any]:
+    try:
+        return _strict_json(path.read_bytes(), label)
+    except OSError as error:
+        raise CaptureError(f"cannot read {label} at {path}: {error}") from error
+
+
+def _load_m0() -> ModuleType:
+    path = SCRIPT.with_name("eager_compiled_arena_m0.py")
+    spec = importlib.util.spec_from_file_location("_amplicol_capture_m0", path)
+    if spec is None or spec.loader is None:
+        _die(f"cannot load M0 schema validator from {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    try:
+        spec.loader.exec_module(module)
+    except Exception as error:
+        raise CaptureError(f"cannot load M0 schema validator: {error}") from error
+    return module
+
+
+def _same_complex_values(
+    left: Sequence[complex],
+    right: Sequence[complex],
+) -> bool:
+    return len(left) == len(right) and all(
+        abs(lhs - rhs) <= ATOL + RTOL * abs(rhs)
+        for lhs, rhs in zip(left, right, strict=True)
+    )
+
+
+def _contract_from_request(path: Path) -> CaptureContract:
+    """Revalidate all four captures and extract their common M0 contract."""
+
+    m0 = _load_m0()
+    payload = _load_json(path, "M0 request template")
+    if set(payload) != _M0_REQUEST_KEYS:
+        _die("M0 request template has unknown or missing root keys")
+    if (
+        payload.get("kind") != m0.REQUEST_KIND
+        or payload.get("schema_version") != m0.REQUEST_SCHEMA
+    ):
+        _die("M0 request template has the wrong kind or schema")
+    amplicol = payload.get("amplicol_evidence")
+    if not isinstance(amplicol, Mapping) or set(amplicol) != set(ROLES):
+        _die("request template must reserve exactly both AmpliCol evidence roles")
+    expected = m0._validate_expected(payload.get("expected"))
+    if expected["amplicol_source_revision"] != legacy_amplicol.expected_revision():
+        _die(
+            "request AmpliCol revision differs from the contributor-lock pin: "
+            f"{expected['amplicol_source_revision']} != "
+            f"{legacy_amplicol.expected_revision()}"
+        )
+    if expected["external_leg_permutation"] != list(AMPLICOL_EXTERNAL_LEG_PERMUTATION):
+        _die(
+            "request AmpliCol source-to-generated permutation must be "
+            f"{list(AMPLICOL_EXTERNAL_LEG_PERMUTATION)}"
+        )
+
+    captures_raw = payload.get("captures")
+    if not isinstance(captures_raw, Mapping) or set(captures_raw) != set(m0.MODELS):
+        _die("request template must reference exactly both M0 model families")
+    benchmark = m0._load_benchmark_module()
+    captures: dict[tuple[str, str], Any] = {}
+    input_files: list[dict[str, Any]] = [_file_ref(path)]
+    for model in m0.MODELS:
+        layouts = captures_raw[model]
+        if not isinstance(layouts, Mapping) or set(layouts) != set(m0.LAYOUTS):
+            _die(f"request captures for {model} must contain both LC layouts")
+        for layout in m0.LAYOUTS:
+            ref = m0._file_ref(
+                layouts[layout],
+                base=path.resolve().parent,
+                label=f"request.captures.{model}.{layout}",
+            )
+            loaded = m0._load_json_ref(ref, f"{model}/{layout}")
+            input_files.append(
+                {
+                    "path": str(ref.path),
+                    "size_bytes": ref.size_bytes,
+                    "sha256": ref.sha256,
+                }
+            )
+            captures[(model, layout)] = m0._validate_capture(
+                loaded,
+                model=model,
+                layout=layout,
+                expected=expected,
+                benchmark=benchmark,
+            )
+
+    first = captures[("built-in-sm", "topology-replay")]
+    for key, current in captures.items():
+        if (
+            current.source_identity != first.source_identity
+            or current.runtime_identity != first.runtime_identity
+            or current.host != first.host
+            or current.fixture != first.fixture
+            or current.normalization_sha256 != first.normalization_sha256
+            or current.color_axis != first.color_axis
+            or current.helicity_axis != first.helicity_axis
+        ):
+            _die(f"capture {key} differs from the common M0 physical contract")
+    for layout in m0.LAYOUTS:
+        builtin = captures[("built-in-sm", layout)]
+        ufo = captures[("ufo-sm", layout)]
+        if not _same_complex_values(
+            builtin.validation_values,
+            ufo.validation_values,
+        ):
+            _die(f"built-in and UFO validation values differ for {layout}")
+
+    topology = captures[("built-in-sm", "topology-replay")]
+    union = captures[("built-in-sm", "all-flow-union")]
+    topology_payload = topology.loaded.payload
+    fixture_payload = topology_payload["profiles"]["compiled"]["validation"]["fixture"]
+    raw_file = fixture_payload["file"]
+    raw_path_value = raw_file.get("resolved_path", raw_file.get("path"))
+    if not isinstance(raw_path_value, str):
+        _die("topology capture has no absolute raw validation-momenta path")
+    fixture_path = Path(raw_path_value).resolve(strict=True)
+    fixture_ref = _file_ref(fixture_path)
+    if (
+        fixture_ref["sha256"] != first.fixture["file_sha256"]
+        or fixture_payload.get("point_count") != first.fixture["point_count"]
+        or fixture_payload.get("points_sha256") != first.fixture["points_sha256"]
+    ):
+        _die("topology raw fixture identity differs from its capture")
+
+    topology_selector = topology.selector
+    union_selector = union.selector
+    if topology_selector.get("color_flow_request") != union_selector.get(
+        "color_flow_request"
+    ) or topology_selector.get("helicity_request") != union_selector.get(
+        "helicity_request"
+    ):
+        _die("the two LC layouts used different runtime selector requests")
+    return CaptureContract(
+        expected=dict(expected),
+        input_files=tuple(input_files),
+        host=dict(first.host),
+        fixture={
+            "path": fixture_path,
+            "file": fixture_ref,
+            "point_count": first.fixture["point_count"],
+            "points_sha256": first.fixture["points_sha256"],
+        },
+        color_axis={
+            "count": first.color_axis["count"],
+            "ordered_ids_sha256": first.color_axis["ordered_ids_sha256"],
+        },
+        helicity_axis={
+            "count": first.helicity_axis["count"],
+            "ordered_ids_sha256": first.helicity_axis["ordered_ids_sha256"],
+        },
+        color_flow_request=str(topology_selector["color_flow_request"]),
+        helicity_request=str(topology_selector["helicity_request"]),
+        selected_values=tuple(topology.validation_values),
+        union_values=tuple(union.validation_values),
+    )
+
+
+def _host_identity() -> dict[str, Any]:
+    """Use the same host identity algorithm as the schema-6 harness."""
+
+    cpu_model = platform.processor().strip()
+    if not cpu_model and platform.system() == "Darwin":
+        completed = subprocess.run(
+            ("sysctl", "-n", "machdep.cpu.brand_string"),
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if completed.returncode == 0:
+            cpu_model = completed.stdout.strip()
+    if not cpu_model and platform.system() == "Linux":
+        try:
+            for line in Path("/proc/cpuinfo").read_text(encoding="utf-8").splitlines():
+                if line.casefold().startswith(("model name", "hardware")):
+                    cpu_model = line.partition(":")[2].strip()
+                    break
+        except OSError:
+            pass
+    uname = platform.uname()
+    return {
+        "platform": platform.platform(),
+        "system": uname.system,
+        "release": uname.release,
+        "version": uname.version,
+        "machine": uname.machine,
+        "processor": uname.processor,
+        "cpu_model": cpu_model or None,
+        "logical_cpu_count": os.cpu_count(),
+    }
+
+
+def _require_clean_revision(
+    repository: Path,
+    *,
+    expected_revision: str,
+    label: str,
+) -> None:
+    revision = _run(
+        ("git", "rev-parse", "--verify", "HEAD"),
+        cwd=repository,
+        label=f"{label} revision",
+    ).stdout.strip()
+    if revision != expected_revision:
+        _die(
+            f"{label} revision differs from the request pin: "
+            f"{revision} != {expected_revision}"
+        )
+    status = _run(
+        ("git", "status", "--porcelain=v1", "--untracked-files=all"),
+        cwd=repository,
+        label=f"{label} cleanliness",
+    ).stdout
+    if status:
+        _die(f"{label} has tracked or untracked pre-capture state:\n{status}")
+
+
+def _run(
+    command: Sequence[str | os.PathLike[str]],
+    *,
+    cwd: Path,
+    environment: Mapping[str, str] | None = None,
+    label: str,
+    log_path: Path | None = None,
+) -> subprocess.CompletedProcess[str]:
+    rendered = [os.fspath(item) for item in command]
+    completed = subprocess.run(
+        rendered,
+        cwd=cwd,
+        env=None if environment is None else {**os.environ, **environment},
+        capture_output=True,
+        check=False,
+        text=True,
+    )
+    if log_path is not None:
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        with log_path.open("a", encoding="utf-8") as stream:
+            stream.write(f"$ {' '.join(rendered)}\n")
+            stream.write(completed.stdout)
+            stream.write(completed.stderr)
+            if not completed.stdout.endswith("\n"):
+                stream.write("\n")
+    if completed.returncode != 0:
+        _die(
+            f"{label} exited with {completed.returncode}: {' '.join(rendered)}\n"
+            f"stdout:\n{completed.stdout}\nstderr:\n{completed.stderr}"
+        )
+    return completed
+
+
+@contextlib.contextmanager
+def _staged_process_file(repository: Path, process_file: Path) -> Iterator[str]:
+    target = repository / "processes.txt"
+    backup = repository / f".processes.txt.m0-backup-{os.getpid()}"
+    existed = target.is_file()
+    if backup.exists():
+        _die(f"stale process-file backup exists: {backup}")
+    if existed:
+        shutil.copy2(target, backup)
+    shutil.copy2(process_file, target)
+    try:
+        yield target.name
+    finally:
+        if existed:
+            shutil.move(backup, target)
+        else:
+            target.unlink(missing_ok=True)
+        backup.unlink(missing_ok=True)
+
+
+def _fixture_points(
+    path: Path,
+) -> tuple[tuple[int, ...], tuple[tuple[tuple[float, ...], ...], ...]]:
+    payload = _load_json(path, "validation-momenta fixture")
+    if (
+        payload.get("kind") != "pyamplicol-rusticol-validation-momenta"
+        or payload.get("schema_version") != 1
+        or "points" not in payload
+    ):
+        _die("validation-momenta fixture has the wrong schema")
+    raw_points = payload["points"]
+    if not isinstance(raw_points, list) or not raw_points:
+        _die("validation-momenta fixture has no points")
+    pdgs: tuple[int, ...] | None = None
+    points: list[tuple[tuple[float, ...], ...]] = []
+    for point_index, raw_point in enumerate(raw_points):
+        if not isinstance(raw_point, list) or len(raw_point) != 9:
+            _die(f"fixture point {point_index} does not have nine external legs")
+        point_pdgs: list[int] = []
+        momenta: list[tuple[float, ...]] = []
+        for particle in raw_point:
+            if not isinstance(particle, Mapping):
+                _die(f"fixture point {point_index} contains a non-object particle")
+            momentum = particle.get("momentum")
+            particle_pdg = particle.get("pdg")
+            if (
+                isinstance(particle_pdg, bool)
+                or not isinstance(particle_pdg, int)
+                or not isinstance(momentum, list)
+                or len(momentum) != 4
+            ):
+                _die(f"fixture point {point_index} contains an invalid particle")
+            converted = tuple(float(component) for component in momentum)
+            if not all(math.isfinite(component) for component in converted):
+                _die(f"fixture point {point_index} contains non-finite momentum")
+            point_pdgs.append(particle_pdg)
+            momenta.append(converted)
+        current_pdgs = tuple(point_pdgs)
+        if pdgs is None:
+            pdgs = current_pdgs
+        elif current_pdgs != pdgs:
+            _die("fixture external-particle order changes between points")
+        points.append(tuple(momenta))
+    assert pdgs is not None
+    normalized_process = " ".join(str(payload.get("process", "")).split()).casefold()
+    if normalized_process != NORMALIZED_PROCESS:
+        _die("validation-momenta fixture is not the qq_Z6g process")
+    if legacy_amplicol.process_pdgs(NORMALIZED_PROCESS) != pdgs:
+        _die("fixture external PDGs differ from the original-AmpliCol process parser")
+    return pdgs, tuple(points)
+
+
+def _write_ordered_momenta(
+    path: Path,
+    *,
+    source_pdgs: Sequence[int],
+    target_pdgs: Sequence[int],
+    momenta: Sequence[Sequence[float]],
+) -> None:
+    ordered = legacy_amplicol._ordered_binary64_momenta(
+        source_pdgs,
+        target_pdgs,
+        momenta,
+    )
+    path.write_text(
+        "\n".join(
+            " ".join(format(float(component), ".17g") for component in vector)
+            for vector in ordered
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def _generate_process_file(
+    *,
+    repository: Path,
+    setup: Path,
+    log_path: Path,
+) -> Path:
+    """Run the case-sensitive legacy generator with its lowercase spelling."""
+
+    _run(
+        (
+            sys.executable,
+            repository / "process_list.py",
+            "--serial",
+            NORMALIZED_PROCESS,
+        ),
+        cwd=setup,
+        label="original-AmpliCol process generation",
+        log_path=log_path,
+    )
+    process_file = setup / "processes.txt"
+    if not process_file.is_file():
+        _die("original-AmpliCol process_list.py did not write processes.txt")
+    return process_file
+
+
+def _copy_sample_runtime_sources(runtime: Path) -> tuple[Path, tuple[Path, ...]]:
+    bundle = runtime / "python-src"
+    copied: list[Path] = []
+    for relative in _SAMPLE_RUNTIME_RELATIVE_FILES:
+        source = (ROOT / relative).resolve(strict=True)
+        target = bundle / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target)
+        copied.append(target.resolve())
+    producer = (bundle / _SAMPLE_RUNTIME_RELATIVE_FILES[0]).resolve(strict=True)
+    return producer, tuple(copied)
+
+
+def _copy_generated_library_tree(
+    repository: Path,
+    runtime: Path,
+) -> tuple[Path, ...]:
+    source_root = repository / "Library"
+    if not source_root.is_dir():
+        _die(f"generated original-AmpliCol Library tree is absent: {source_root}")
+    amplitudes = source_root / "amplitudes.bin"
+    if not amplitudes.is_file():
+        _die(f"generated original-AmpliCol amplitudes payload is absent: {amplitudes}")
+    sources = tuple(sorted(path for path in source_root.rglob("*") if path.is_file()))
+    if not sources:
+        _die(f"generated original-AmpliCol Library tree is empty: {source_root}")
+    copied: list[Path] = []
+    for source in sources:
+        target = runtime / "Library" / source.relative_to(source_root)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target)
+        copied.append(target.resolve())
+    return tuple(copied)
+
+
+def _copy_runtime(repository: Path, output: Path, process_file: Path) -> ProbeContext:
+    runtime = output / "runtime"
+    runtime.mkdir(parents=True)
+    interpreter = Path(sys.executable).resolve(strict=True)
+    bundled_producer, bundled_sources = _copy_sample_runtime_sources(runtime)
+    worker_executable = runtime / "amplicol_z6g_m0_sample"
+    worker_executable.write_text(
+        "#!/bin/sh\n"
+        f"exec {shlex.quote(str(interpreter))} -I -S -B "
+        f'{shlex.quote(str(bundled_producer))} "$@"\n',
+        encoding="utf-8",
+    )
+    worker_executable.chmod(0o755)
+    selected_binary = runtime / "amplicol_library_benchmark"
+    union_binary = runtime / "amplicol_color_probe"
+    shutil.copy2(repository / selected_binary.name, selected_binary)
+    shutil.copy2(repository / union_binary.name, union_binary)
+    runtime_process = runtime / "processes.txt"
+    shutil.copy2(process_file, runtime_process)
+    generated_library_files = _copy_generated_library_tree(repository, runtime)
+    libraries: list[Path] = []
+    for pattern in ("libamp*.so", "libamp*.dylib", "libamp*.a"):
+        for source in sorted(repository.glob(pattern)):
+            target = runtime / source.name
+            if not target.exists():
+                shutil.copy2(source, target)
+                libraries.append(target)
+    if not libraries:
+        _die("generated selected-flow library produced no libamp library")
+    return ProbeContext(
+        runtime=runtime.resolve(),
+        worker_executable=worker_executable.resolve(),
+        process_file=runtime_process.resolve(),
+        selected_binary=selected_binary.resolve(),
+        union_binary=union_binary.resolve(),
+        linked_files=(
+            interpreter,
+            *bundled_sources,
+            selected_binary.resolve(),
+            union_binary.resolve(),
+            runtime_process.resolve(),
+            *generated_library_files,
+            *(path.resolve() for path in libraries),
+        ),
+        group=0,
+        integral=0,
+        source_pdgs=(),
+        generated_pdgs=(),
+        generated_color_order=(),
+        permutation=(),
+    )
+
+
+def _validated_executable_row(
+    *,
+    requested_entry: Any,
+    emitted_probe: Any,
+    source_pdgs: Sequence[int],
+    expected_flow_word: Sequence[int],
+    expected_permutation: Sequence[int],
+) -> tuple[Any, tuple[int, ...]]:
+    requested_identity = (int(requested_entry.group), int(requested_entry.integral))
+    emitted_identity = (int(emitted_probe.group), int(emitted_probe.integral))
+    if emitted_identity != requested_identity:
+        _die(
+            "generated-library selected-flow probe returned row "
+            f"{emitted_identity}, expected {requested_identity}"
+        )
+    emitted_pdgs = tuple(int(value) for value in emitted_probe.process_pdgs)
+    if sorted(emitted_pdgs) != sorted(
+        int(value) for value in requested_entry.process_pdgs
+    ):
+        _die(
+            "generated-library selected-flow PDG multiset differs from the "
+            "requested generated row"
+        )
+    executable_entry = legacy_amplicol.ProcessEntry(
+        group=emitted_identity[0],
+        integral=emitted_identity[1],
+        process_pdgs=emitted_pdgs,
+        color_order=tuple(int(value) for value in emitted_probe.color_order),
+    )
+    mapped = legacy_amplicol.source_mapped_color_order(
+        executable_entry,
+        source_pdgs=source_pdgs,
+    )
+    colored = {
+        index
+        for index, pdg in enumerate(source_pdgs, start=1)
+        if abs(int(pdg)) == 21 or 1 <= abs(int(pdg)) <= 6
+    }
+    color_word = tuple(label for label in mapped if label in colored)
+    if list(color_word) != list(expected_flow_word):
+        _die(
+            "selected original-AmpliCol executable row differs from the stable "
+            f"M0 flow word: {color_word} != {tuple(expected_flow_word)}"
+        )
+    permutation = tuple(
+        legacy_amplicol._permutation(source_pdgs, executable_entry.process_pdgs)
+    )
+    if list(permutation) != list(expected_permutation):
+        _die(
+            "executable source-to-generated external-leg permutation differs "
+            "from M0 request"
+        )
+    return executable_entry, permutation
+
+
+def _prepare_probes(
+    *,
+    repository: Path,
+    output: Path,
+    fixture_path: Path,
+    expected_flow_word: Sequence[int],
+    expected_permutation: Sequence[int],
+    jobs: int,
+) -> ProbeContext:
+    """Generate one LC row, build both probes, and snapshot execution inputs."""
+
+    legacy_amplicol.prepare_checkout(repository)
+    _require_clean_revision(
+        repository,
+        expected_revision=legacy_amplicol.expected_revision(),
+        label="original-AmpliCol checkout",
+    )
+    legacy_amplicol.validate_checkout(repository)
+    source_pdgs, points = _fixture_points(fixture_path)
+    setup = output / "setup"
+    setup.mkdir(parents=True)
+    log = setup / "build.log"
+    process_file = _generate_process_file(
+        repository=repository,
+        setup=setup,
+        log_path=log,
+    )
+    entries = legacy_amplicol.parse_process_file(process_file)
+    entry, _matches = legacy_amplicol.select_generated_process_entry(
+        entries,
+        generated_process=NORMALIZED_PROCESS,
+        wanted_pdgs=source_pdgs,
+    )
+
+    momenta_directory = repository / "Utilities" / "ME_checks"
+    momenta_directory.mkdir(parents=True, exist_ok=True)
+    for candidate in entries:
+        target = momenta_directory / (
+            f"momenta_{candidate.group}_{candidate.integral}.txt"
+        )
+        _write_ordered_momenta(
+            target,
+            source_pdgs=source_pdgs,
+            target_pdgs=candidate.process_pdgs,
+            momenta=points[0],
+        )
+    with _staged_process_file(repository, process_file) as process_argument:
+        commands: tuple[tuple[str, ...], ...] = (
+            ("make", "cleanlib"),
+            ("make", f"-j{jobs}", "amplicol_generate"),
+            (
+                "./amplicol_generate",
+                "--library=create",
+                f"--process={process_argument}",
+                "--amplicol_momenta_probe=10",
+                "--amplicol_probe_quiet",
+                "--timing=none",
+            ),
+            ("make", f"-j{jobs}", "amplicol_generate_library"),
+            ("make", f"-j{jobs}", "amplicol_library_benchmark"),
+            ("make", f"-j{jobs}", "amplicol_color_probe"),
+        )
+        for command in commands:
+            _run(
+                command,
+                cwd=repository,
+                label=f"original-AmpliCol build step {command[0]}",
+                log_path=log,
+            )
+    legacy_amplicol.validate_checkout(repository)
+    emitted_probe = legacy_amplicol.run_selected_flow_library_probe(
+        repository,
+        entry=entry,
+        source_pdgs=source_pdgs,
+        momenta=points[0],
+        points=1,
+    )
+    executable_entry, permutation = _validated_executable_row(
+        requested_entry=entry,
+        emitted_probe=emitted_probe,
+        source_pdgs=source_pdgs,
+        expected_flow_word=expected_flow_word,
+        expected_permutation=expected_permutation,
+    )
+    snapshot = _copy_runtime(repository, output, process_file)
+    return ProbeContext(
+        runtime=snapshot.runtime,
+        worker_executable=snapshot.worker_executable,
+        process_file=snapshot.process_file,
+        selected_binary=snapshot.selected_binary,
+        union_binary=snapshot.union_binary,
+        linked_files=snapshot.linked_files,
+        group=int(executable_entry.group),
+        integral=int(executable_entry.integral),
+        source_pdgs=tuple(source_pdgs),
+        generated_pdgs=tuple(executable_entry.process_pdgs),
+        generated_color_order=tuple(executable_entry.color_order),
+        permutation=permutation,
+    )
+
+
+def _source_tree_sha256(identities: Sequence[Mapping[str, Any]]) -> str:
+    members = sorted(
+        (
+            {
+                "size_bytes": identity["size_bytes"],
+                "sha256": identity["sha256"],
+            }
+            for identity in identities
+        ),
+        key=lambda identity: (identity["sha256"], identity["size_bytes"]),
+    )
+    return _canonical_sha256(
+        {
+            "kind": "amplicol-source-content-set",
+            "schema_version": 1,
+            "members": members,
+        }
+    )
+
+
+def _source_evidence(repository: Path) -> SourceEvidence:
+    legacy_amplicol.validate_checkout(repository)
+    completed = _run(
+        ("git", "ls-files", "-z"),
+        cwd=repository,
+        label="original-AmpliCol tracked-source inventory",
+    )
+    source_paths: list[Path] = []
+    seen: set[Path] = set()
+    for item in completed.stdout.split("\0"):
+        if not item:
+            continue
+        path = (repository / item).resolve(strict=True)
+        if not path.is_file():
+            _die(f"tracked original-AmpliCol source is not a file: {path}")
+        if path in seen:
+            _die(f"tracked original-AmpliCol sources resolve to duplicate path: {path}")
+        seen.add(path)
+        source_paths.append(path)
+    if not source_paths:
+        _die("original-AmpliCol tracked-source inventory is empty")
+    source_files = tuple(_file_ref(path) for path in sorted(source_paths))
+    compiler = legacy_amplicol._compiler_provenance(repository)
+    source = {
+        "revision": legacy_amplicol.expected_revision(),
+        "dirty": False,
+        "compiler": {
+            "id": compiler.identity,
+            "version": compiler.version,
+            "target": compiler.target,
+            "flags_sha256": _canonical_sha256(list(compiler.flags)),
+        },
+        "source_tree_sha256": _source_tree_sha256(source_files),
+    }
+    return SourceEvidence(source=source, source_files=source_files)
+
+
+def _csv_ints(values: Sequence[int]) -> str:
+    return ",".join(str(int(value)) for value in values)
+
+
+def _sample_command(
+    *,
+    role: str,
+    round_index: int,
+    points: int,
+    contract: CaptureContract,
+    context: ProbeContext,
+) -> list[str]:
+    expected = contract.expected
+    selector_argument = (
+        f"--color-flow-id={expected['color_flow']['id']}"
+        if role == SELECTED_ROLE
+        else f"--helicity-id={expected['helicity']['id']}"
+    )
+    return [
+        str(context.worker_executable),
+        "_sample",
+        f"--workload={role}",
+        f"--round={round_index}",
+        f"--momenta={contract.fixture['path']}",
+        f"--momenta-sha256={contract.fixture['file']['sha256']}",
+        f"--momenta-points-sha256={contract.fixture['points_sha256']}",
+        f"--source-revision={expected['amplicol_source_revision']}",
+        selector_argument,
+        f"--color-flow-word={_csv_ints(expected['color_flow']['word'])}",
+        f"--helicity-values={_csv_ints(expected['helicity']['values'])}",
+        f"--evaluated-points={points}",
+        f"--runtime={context.runtime}",
+        f"--selected-binary={context.selected_binary}",
+        f"--union-binary={context.union_binary}",
+        f"--process-file={context.process_file}",
+        f"--process-file-sha256={_file_sha256(context.process_file)}",
+        f"--group={context.group}",
+        f"--integral={context.integral}",
+        f"--source-pdgs={_csv_ints(context.source_pdgs)}",
+        f"--generated-pdgs={_csv_ints(context.generated_pdgs)}",
+        f"--generated-color-order={_csv_ints(context.generated_color_order)}",
+        f"--source-to-generated-permutation={_csv_ints(context.permutation)}",
+    ]
+
+
+def _parse_probe_stdout(
+    stdout: str,
+    *,
+    role: str,
+    sample_index: int,
+    evaluated_points: int,
+) -> dict[str, Any]:
+    payload = _strict_json(stdout.encode("utf-8"), "probe stdout")
+    if set(payload) != _PROBE_RESULT_KEYS:
+        _die("probe stdout has unknown or missing keys")
+    if (
+        payload.get("kind") != "amplicol-m0-probe-result"
+        or payload.get("schema_version") != 1
+        or payload.get("role") != role
+        or payload.get("sample_index") != sample_index
+        or payload.get("evaluated_point_count") != evaluated_points
+    ):
+        _die("probe stdout identity differs from its command")
+    elapsed = payload.get("elapsed_seconds")
+    seconds_per_point = payload.get("seconds_per_point")
+    if (
+        isinstance(elapsed, bool)
+        or not isinstance(elapsed, int | float)
+        or not math.isfinite(float(elapsed))
+        or float(elapsed) <= 0.0
+        or isinstance(seconds_per_point, bool)
+        or not isinstance(seconds_per_point, int | float)
+        or not math.isfinite(float(seconds_per_point))
+        or float(seconds_per_point) <= 0.0
+        or not math.isclose(
+            float(seconds_per_point),
+            float(elapsed) / evaluated_points,
+            rel_tol=0.0,
+            abs_tol=max(1.0e-18, abs(float(seconds_per_point)) * 1.0e-15),
+        )
+    ):
+        _die("probe stdout timing scalars are invalid or stale")
+    for field in ("selected_totals", "resolved_sums"):
+        rows = payload.get(field)
+        if not isinstance(rows, list) or not rows:
+            _die(f"probe stdout {field} is empty")
+        for row in rows:
+            if (
+                not isinstance(row, list)
+                or len(row) != 2
+                or any(
+                    isinstance(value, bool)
+                    or not isinstance(value, int | float)
+                    or not math.isfinite(float(value))
+                    for value in row
+                )
+            ):
+                _die(f"probe stdout {field} has an invalid complex pair")
+    return payload
+
+
+def _utc_now() -> str:
+    return dt.datetime.now(dt.UTC).isoformat()
+
+
+def _complex_pairs(values: Sequence[complex]) -> list[list[float]]:
+    return [[float(value.real), float(value.imag)] for value in values]
+
+
+def _pairs_as_complex(values: object, label: str) -> tuple[complex, ...]:
+    if not isinstance(values, list):
+        _die(f"{label} must be a list")
+    result: list[complex] = []
+    for row in values:
+        if not isinstance(row, list) or len(row) != 2:
+            _die(f"{label} has an invalid complex pair")
+        result.append(complex(float(row[0]), float(row[1])))
+    return tuple(result)
+
+
+def _timing_rows(output: str) -> dict[str, float]:
+    rows: dict[str, float] = {}
+    in_summary = False
+    for line in output.splitlines():
+        if "Timing summary" in line:
+            in_summary = True
+            continue
+        if not in_summary:
+            continue
+        tokens = line.strip().split()
+        for index in range(1, len(tokens)):
+            try:
+                value = float(tokens[index])
+            except ValueError:
+                continue
+            label = " ".join(tokens[:index]).casefold()
+            if label in rows:
+                _die(f"probe timing summary repeats row {label!r}")
+            if not math.isfinite(value) or value <= 0.0:
+                _die(f"probe timing row {label!r} is not finite and positive")
+            rows[label] = value
+            break
+    return rows
+
+
+def _timing_value(output: str, label: str) -> float:
+    rows = _timing_rows(output)
+    wanted = label.casefold()
+    exact = rows.get(wanted)
+    if exact is not None:
+        return exact
+    matches = [value for row, value in rows.items() if wanted in row]
+    if len(matches) != 1:
+        _die(f"probe output has no unique positive timing row for {label!r}")
+    return matches[0]
+
+
+def _library_environment(runtime: Path) -> dict[str, str]:
+    root = str(runtime.resolve())
+    result: dict[str, str] = {}
+    for name in ("LD_LIBRARY_PATH", "DYLD_LIBRARY_PATH"):
+        existing = os.environ.get(name)
+        result[name] = root if not existing else f"{root}{os.pathsep}{existing}"
+    return result
+
+
+@contextlib.contextmanager
+def _temporary_environment(values: Mapping[str, str]) -> Iterator[None]:
+    prior = {name: os.environ.get(name) for name in values}
+    os.environ.update(values)
+    try:
+        yield
+    finally:
+        for name, value in prior.items():
+            if value is None:
+                os.environ.pop(name, None)
+            else:
+                os.environ[name] = value
+
+
+def _entry(arguments: argparse.Namespace) -> Any:
+    return legacy_amplicol.ProcessEntry(
+        group=arguments.group,
+        integral=arguments.integral,
+        process_pdgs=tuple(arguments.generated_pdgs),
+        color_order=tuple(arguments.generated_color_order),
+    )
+
+
+def _timed_selected(
+    arguments: argparse.Namespace,
+    *,
+    source_pdgs: Sequence[int],
+    first_point: Sequence[Sequence[float]],
+) -> tuple[float, Any]:
+    with tempfile.TemporaryDirectory(prefix="pac-m0-selected-", dir="/tmp") as raw:
+        momentum_path = Path(raw) / "momenta.dat"
+        _write_ordered_momenta(
+            momentum_path,
+            source_pdgs=source_pdgs,
+            target_pdgs=arguments.generated_pdgs,
+            momenta=first_point,
+        )
+        completed = _run(
+            (
+                arguments.selected_binary,
+                str(arguments.evaluated_points),
+                str(arguments.group),
+                str(arguments.integral),
+                momentum_path,
+            ),
+            cwd=arguments.runtime,
+            environment=_library_environment(arguments.runtime),
+            label="selected-flow original-AmpliCol probe",
+        )
+    output = completed.stdout + "\n" + completed.stderr
+    return (
+        _timing_value(output, "amplitude evaluation"),
+        legacy_amplicol._parse_selected_flow_probe_output(output),
+    )
+
+
+def _timed_union(
+    arguments: argparse.Namespace,
+    *,
+    source_pdgs: Sequence[int],
+    first_point: Sequence[Sequence[float]],
+) -> tuple[float, Any]:
+    permutation = tuple(arguments.source_to_generated_permutation)
+    ordered_helicities = [arguments.helicity_values[index] for index in permutation]
+    with tempfile.TemporaryDirectory(prefix="pac-m0-union-", dir="/tmp") as raw:
+        work = Path(raw)
+        process_copy = work / "processes.txt"
+        momentum_path = work / "momenta.dat"
+        shutil.copy2(arguments.process_file, process_copy)
+        _write_ordered_momenta(
+            momentum_path,
+            source_pdgs=source_pdgs,
+            target_pdgs=arguments.generated_pdgs,
+            momenta=first_point,
+        )
+        completed = _run(
+            (
+                arguments.union_binary,
+                str(arguments.evaluated_points),
+                str(arguments.group),
+                str(arguments.integral),
+                "lc",
+                process_copy,
+                momentum_path,
+                *(str(value) for value in ordered_helicities),
+            ),
+            cwd=work,
+            label="all-flow original-AmpliCol probe",
+        )
+    output = completed.stdout + "\n" + completed.stderr
+    return (
+        _timing_value(output, "total"),
+        legacy_amplicol._parse_probe_output(output),
+    )
+
+
+def _sample_values(
+    arguments: argparse.Namespace,
+    *,
+    source_pdgs: Sequence[int],
+    points: Sequence[Sequence[Sequence[float]]],
+    timed_result: Any,
+) -> tuple[tuple[complex, ...], tuple[complex, ...]]:
+    entry = _entry(arguments)
+    if arguments.workload == SELECTED_ROLE and (
+        timed_result.group != arguments.group
+        or timed_result.integral != arguments.integral
+        or tuple(timed_result.process_pdgs) != tuple(arguments.generated_pdgs)
+        or tuple(timed_result.color_order) != tuple(arguments.generated_color_order)
+    ):
+        _die("selected-flow timing probe returned a different generated row")
+    selected: list[complex] = []
+    resolved: list[complex] = []
+    for index, momenta in enumerate(points):
+        if index == 0:
+            probe = timed_result
+        elif arguments.workload == SELECTED_ROLE:
+            with _temporary_environment(_library_environment(arguments.runtime)):
+                probe = legacy_amplicol.run_selected_flow_library_probe(
+                    arguments.runtime,
+                    entry=entry,
+                    source_pdgs=source_pdgs,
+                    momenta=momenta,
+                    points=1,
+                )
+        else:
+            probe = legacy_amplicol.run_color_probe(
+                arguments.runtime,
+                process_file=arguments.process_file,
+                entry=entry,
+                source_pdgs=source_pdgs,
+                momenta=momenta,
+                color_accuracy="lc",
+                helicities=arguments.helicity_values,
+            )
+        value = complex(float(probe.value), 0.0)
+        selected.append(value)
+        if arguments.workload == SELECTED_ROLE:
+            # The generated LC library's scalar is its internal resolved
+            # helicity sum after serialized hel_fac/normalization application.
+            resolved.append(value)
+        else:
+            partition_sum = probe.lc_partition_sum
+            if partition_sum is None or not probe.lc_row_partitions:
+                _die("all-flow color probe emitted no resolved LC-row partition")
+            resolved.append(complex(float(partition_sum), 0.0))
+    if not _same_complex_values(selected, resolved):
+        _die("original-AmpliCol selected total and resolved sum do not close")
+    return tuple(selected), tuple(resolved)
+
+
+def _sample_payload(arguments: argparse.Namespace) -> dict[str, Any]:
+    if arguments.source_revision != legacy_amplicol.expected_revision():
+        _die("sample source revision differs from the contributor-lock pin")
+    expected_flow_id = "flow:" + _csv_ints(arguments.color_flow_word)
+    expected_helicity_id = "h:" + ",".join(
+        f"{value:+d}" for value in arguments.helicity_values
+    )
+    if (
+        len(arguments.color_flow_word) != 8
+        or len(arguments.helicity_values) != 9
+        or any(value not in (-1, 1) for value in arguments.helicity_values)
+        or len(arguments.source_pdgs) != 9
+        or len(arguments.generated_pdgs) != 9
+        or len(arguments.source_to_generated_permutation) != 9
+    ):
+        _die("sample physical selector or external-leg dimensions are invalid")
+    if (
+        arguments.workload == SELECTED_ROLE
+        and arguments.color_flow_id != expected_flow_id
+    ) or (
+        arguments.workload == UNION_ROLE
+        and arguments.helicity_id != expected_helicity_id
+    ):
+        _die("sample stable selector ID differs from its explicit physical values")
+    for path, digest, label in (
+        (arguments.momenta, arguments.momenta_sha256, "momenta"),
+        (
+            arguments.process_file,
+            arguments.process_file_sha256,
+            "process file",
+        ),
+    ):
+        if _file_sha256(path.resolve(strict=True)) != digest:
+            _die(f"sample {label} content differs from its command digest")
+    if (
+        not arguments.selected_binary.is_file()
+        or not os.access(arguments.selected_binary, os.X_OK)
+        or not arguments.union_binary.is_file()
+        or not os.access(arguments.union_binary, os.X_OK)
+    ):
+        _die("sample probe binary is missing or non-executable")
+    source_pdgs, points = _fixture_points(arguments.momenta)
+    if tuple(arguments.source_pdgs) != source_pdgs:
+        _die("sample source PDGs differ from the momenta fixture")
+    if tuple(arguments.source_to_generated_permutation) != tuple(
+        legacy_amplicol._permutation(
+            arguments.source_pdgs,
+            arguments.generated_pdgs,
+        )
+    ):
+        _die("sample source-to-generated permutation is stale")
+    if _canonical_sha256(points) != arguments.momenta_points_sha256:
+        _die("sample momenta point digest differs from its command")
+    if arguments.workload == SELECTED_ROLE:
+        elapsed, timed_result = _timed_selected(
+            arguments,
+            source_pdgs=source_pdgs,
+            first_point=points[0],
+        )
+    else:
+        elapsed, timed_result = _timed_union(
+            arguments,
+            source_pdgs=source_pdgs,
+            first_point=points[0],
+        )
+    selected, resolved = _sample_values(
+        arguments,
+        source_pdgs=source_pdgs,
+        points=points,
+        timed_result=timed_result,
+    )
+    seconds_per_point = elapsed / arguments.evaluated_points
+    return {
+        "kind": "amplicol-m0-probe-result",
+        "schema_version": 1,
+        "role": arguments.workload,
+        "sample_index": arguments.round,
+        "evaluated_point_count": arguments.evaluated_points,
+        "elapsed_seconds": elapsed,
+        "seconds_per_point": seconds_per_point,
+        "selected_totals": _complex_pairs(selected),
+        "resolved_sums": _complex_pairs(resolved),
+    }
+
+
+def _interleave_group_sha256(records: Sequence[Mapping[str, Any]]) -> str:
+    return _canonical_sha256(
+        {
+            "kind": "pyamplicol-m0-paired-interleave",
+            "schema_version": 1,
+            "records": [dict(record) for record in records],
+        }
+    )
+
+
+def _comparison_payload(
+    selected: Sequence[complex],
+    resolved: Sequence[complex],
+) -> dict[str, Any]:
+    if not _same_complex_values(selected, resolved):
+        _die("cannot publish a non-closing validation comparison")
+    maximum_absolute = 0.0
+    maximum_relative = 0.0
+    rows: list[dict[str, Any]] = []
+    for index, (left, right) in enumerate(zip(selected, resolved, strict=True)):
+        difference = abs(left - right)
+        relative = difference / max(abs(right), ATOL)
+        maximum_absolute = max(maximum_absolute, difference)
+        maximum_relative = max(maximum_relative, relative)
+        rows.append({"point_index": index, "passes": True})
+    return {
+        "selected_totals": _complex_pairs(selected),
+        "resolved_sums": _complex_pairs(resolved),
+        "point_comparisons": rows,
+        "maximum_absolute_difference": maximum_absolute,
+        "maximum_relative_difference": maximum_relative,
+        "passes": True,
+    }
+
+
+def _manifest(
+    *,
+    role: str,
+    contract: CaptureContract,
+    context: ProbeContext,
+    source: SourceEvidence,
+    binary_evidence: Mapping[str, Any],
+    samples: Sequence[Mapping[str, Any]],
+    interleave_group_sha256: str,
+    selected: Sequence[complex],
+    resolved: Sequence[complex],
+) -> dict[str, Any]:
+    expected = contract.expected
+    timing_values = [float(sample["seconds_per_point"]) for sample in samples]
+    median = statistics.median(timing_values)
+    mad = statistics.median(abs(value - median) for value in timing_values)
+    union = role == UNION_ROLE
+    payload = {
+        "kind": "pyamplicol-amplicol-m0-raw-evidence",
+        "schema_version": 1,
+        "complete": True,
+        "evidence_scope": "authoritative-host-capture-v1",
+        "workload": UNION_WORKLOAD if union else SELECTED_WORKLOAD,
+        "source": source.source,
+        "host": contract.host,
+        "process": {
+            "expression": PROCESS_EXPRESSION,
+            "normalized_expression": NORMALIZED_PROCESS,
+        },
+        "physical_axes": {
+            "color_flow": contract.color_axis,
+            "helicity": contract.helicity_axis,
+        },
+        "selector": {
+            "color_flow_request": contract.color_flow_request,
+            "resolved_color_flow_id": (None if union else expected["color_flow"]["id"]),
+            "color_flow_word": expected["color_flow"]["word"],
+            "helicity_request": contract.helicity_request,
+            "resolved_helicity_id": (expected["helicity"]["id"] if union else None),
+            "helicity_values": expected["helicity"]["values"],
+            "sum_axis": "color_flow" if union else "helicity",
+            "source_to_generated_permutation": list(context.permutation),
+            "complete_physical_axes": True,
+            "generation_specialized_axes": [],
+        },
+        "momenta": {
+            "point_count": contract.fixture["point_count"],
+            "points_sha256": contract.fixture["points_sha256"],
+            "raw_file": contract.fixture["file"],
+        },
+        "normalization_sha256": expected["normalization_sha256"],
+        "timing": {
+            "boundary": "direct-library-total" if union else "amplitude-evaluation",
+            "batch_semantics": "scalar-normalized-per-point",
+            "statistics_contract": "subprocess-median-and-raw-mad-v1",
+            "interleave_group_sha256": interleave_group_sha256,
+            "sample_count": len(samples),
+            "median_seconds_per_point": median,
+            "mad_seconds_per_point": mad,
+            "samples": [dict(sample) for sample in samples],
+            "samples_sha256": _canonical_sha256(samples),
+        },
+        "validation": _comparison_payload(selected, resolved),
+        "binary_evidence": dict(binary_evidence),
+    }
+    return _content_addressed(payload)
+
+
+def _raw_sample(
+    *,
+    role: str,
+    sample_index: int,
+    command_sha256: str,
+    stdout: str,
+    parsed: Mapping[str, Any],
+) -> dict[str, Any]:
+    return _content_addressed(
+        {
+            "kind": "pyamplicol-amplicol-m0-raw-sample",
+            "schema_version": 1,
+            "role": role,
+            "sample_index": sample_index,
+            "command_sha256": command_sha256,
+            "evaluated_point_count": parsed["evaluated_point_count"],
+            "elapsed_seconds": parsed["elapsed_seconds"],
+            "seconds_per_point": parsed["seconds_per_point"],
+            "stdout": stdout,
+            "stdout_sha256": hashlib.sha256(stdout.encode("utf-8")).hexdigest(),
+        }
+    )
+
+
+def _adaptive_points(
+    elapsed: float,
+    *,
+    warmup_points: int,
+    target_seconds: float,
+    minimum_points: int,
+    maximum_points: int,
+) -> int:
+    if not math.isfinite(elapsed) or elapsed <= 0.0:
+        _die("probe calibration did not report a positive finite time")
+    estimate = math.ceil(target_seconds * warmup_points / elapsed)
+    return max(minimum_points, min(maximum_points, estimate))
+
+
+def _run_sample_command(
+    command: Sequence[str],
+    *,
+    role: str,
+    round_index: int,
+    points: int,
+) -> tuple[str, dict[str, Any], str, str]:
+    started = _utc_now()
+    completed = _run(
+        command,
+        cwd=ROOT,
+        label=f"{role} round {round_index}",
+    )
+    finished = _utc_now()
+    parsed = _parse_probe_stdout(
+        completed.stdout,
+        role=role,
+        sample_index=round_index,
+        evaluated_points=points,
+    )
+    if completed.stderr:
+        _die(f"{role} round {round_index} wrote unexpected stderr")
+    return completed.stdout, parsed, started, finished
+
+
+def _verify_immutable_files(identities: Sequence[Mapping[str, Any]]) -> None:
+    for identity in identities:
+        path = Path(str(identity["path"]))
+        if _file_ref(path) != dict(identity):
+            _die(f"content-addressed capture input drifted: {path}")
+
+
+def _capture(arguments: argparse.Namespace) -> dict[str, Any]:
+    request = arguments.request_template.resolve(strict=True)
+    repository = arguments.repository.resolve(strict=False)
+    output = arguments.output_directory.resolve(strict=False)
+    if output.exists() and any(output.iterdir()):
+        _die(f"output directory must not contain prior state: {output}")
+    output.mkdir(parents=True, exist_ok=True)
+    contract = _contract_from_request(request)
+    _require_clean_revision(
+        ROOT,
+        expected_revision=contract.expected["pyamplicol_source_revision"],
+        label="pyAmpliCol producer checkout",
+    )
+    host = _host_identity()
+    if host != contract.host:
+        _die("current host identity differs from the four pyAmpliCol captures")
+    context = _prepare_probes(
+        repository=repository,
+        output=output,
+        fixture_path=contract.fixture["path"],
+        expected_flow_word=contract.expected["color_flow"]["word"],
+        expected_permutation=contract.expected["external_leg_permutation"],
+        jobs=arguments.jobs,
+    )
+    source = _source_evidence(repository)
+    if source.source["revision"] != contract.expected["amplicol_source_revision"]:
+        _die("prepared original-AmpliCol source differs from the request pin")
+
+    executable_ref = _file_ref(context.worker_executable)
+    linked_refs = tuple(_file_ref(path) for path in context.linked_files)
+    binary_evidence = {
+        "executable": executable_ref,
+        "linked_libraries": list(linked_refs),
+        "source_files": list(source.source_files),
+    }
+
+    points_by_role: dict[str, int] = {}
+    explicit = {
+        SELECTED_ROLE: arguments.selected_points,
+        UNION_ROLE: arguments.union_points,
+    }
+    for role in ROLES:
+        if explicit[role] is not None:
+            points_by_role[role] = explicit[role]
+            continue
+        warmup_command = _sample_command(
+            role=role,
+            round_index=-1,
+            points=arguments.warmup_points,
+            contract=contract,
+            context=context,
+        )
+        _stdout, parsed, _started, _finished = _run_sample_command(
+            warmup_command,
+            role=role,
+            round_index=-1,
+            points=arguments.warmup_points,
+        )
+        points_by_role[role] = _adaptive_points(
+            float(parsed["elapsed_seconds"]),
+            warmup_points=arguments.warmup_points,
+            target_seconds=arguments.target_seconds,
+            minimum_points=arguments.minimum_points,
+            maximum_points=arguments.maximum_points,
+        )
+
+    samples: dict[str, list[dict[str, Any]]] = {role: [] for role in ROLES}
+    values: dict[str, tuple[tuple[complex, ...], tuple[complex, ...]]] = {}
+    interleave_records: list[dict[str, Any]] = []
+    raw_directory = output / "raw-samples"
+    for round_index in range(MIN_SAMPLES):
+        for offset, role in enumerate(ROLES):
+            position = 2 * round_index + offset
+            points = points_by_role[role]
+            command = _sample_command(
+                role=role,
+                round_index=round_index,
+                points=points,
+                contract=contract,
+                context=context,
+            )
+            command_sha256 = _canonical_sha256(command)
+            stdout, parsed, started, finished = _run_sample_command(
+                command,
+                role=role,
+                round_index=round_index,
+                points=points,
+            )
+            selected = _pairs_as_complex(
+                parsed["selected_totals"],
+                f"{role} selected totals",
+            )
+            resolved = _pairs_as_complex(
+                parsed["resolved_sums"],
+                f"{role} resolved sums",
+            )
+            expected_values = (
+                contract.selected_values
+                if role == SELECTED_ROLE
+                else contract.union_values
+            )
+            if not _same_complex_values(selected, expected_values):
+                _die(f"{role} original-AmpliCol values differ from pyAmpliCol")
+            prior = values.setdefault(role, (selected, resolved))
+            if not _same_complex_values(prior[0], selected) or not _same_complex_values(
+                prior[1],
+                resolved,
+            ):
+                _die(f"{role} validation values changed between subprocess rounds")
+            raw_payload = _raw_sample(
+                role=role,
+                sample_index=round_index,
+                command_sha256=command_sha256,
+                stdout=stdout,
+                parsed=parsed,
+            )
+            raw_ref = _write_json(
+                raw_directory / f"{position:02d}-{role}.json",
+                raw_payload,
+            )
+            sample = {
+                "sample_index": round_index,
+                "interleave_round": round_index,
+                "interleave_position": position,
+                "started_at_utc": started,
+                "finished_at_utc": finished,
+                "subprocess": True,
+                "command": command,
+                "command_sha256": command_sha256,
+                "evaluated_point_count": parsed["evaluated_point_count"],
+                "elapsed_seconds": parsed["elapsed_seconds"],
+                "seconds_per_point": parsed["seconds_per_point"],
+                "interrupted": False,
+                "raw_output_file": raw_ref,
+            }
+            samples[role].append(sample)
+            interleave_records.append(
+                {
+                    "role": role,
+                    "round": round_index,
+                    "position": position,
+                    "started_at_utc": started,
+                    "finished_at_utc": finished,
+                    "command_sha256": command_sha256,
+                }
+            )
+
+    interleave_sha256 = _interleave_group_sha256(interleave_records)
+    evidence_refs: dict[str, dict[str, Any]] = {}
+    for role in ROLES:
+        selected, resolved = values[role]
+        manifest = _manifest(
+            role=role,
+            contract=contract,
+            context=context,
+            source=source,
+            binary_evidence=binary_evidence,
+            samples=samples[role],
+            interleave_group_sha256=interleave_sha256,
+            selected=selected,
+            resolved=resolved,
+        )
+        evidence_refs[role] = _write_json(
+            output / f"{role}.json",
+            manifest,
+        )
+
+    legacy_amplicol.validate_checkout(repository)
+    _require_clean_revision(
+        ROOT,
+        expected_revision=contract.expected["pyamplicol_source_revision"],
+        label="pyAmpliCol producer checkout",
+    )
+    _verify_immutable_files(
+        (
+            *contract.input_files,
+            executable_ref,
+            contract.fixture["file"],
+            *linked_refs,
+            *source.source_files,
+            *(
+                sample["raw_output_file"]
+                for role_samples in samples.values()
+                for sample in role_samples
+            ),
+        )
+    )
+    index = _content_addressed(
+        {
+            "kind": "pyamplicol-amplicol-m0-capture-index",
+            "schema_version": 1,
+            "complete": True,
+            "request_template": contract.input_files[0],
+            "source": source.source,
+            "host": contract.host,
+            "process": NORMALIZED_PROCESS,
+            "paired_round_count": MIN_SAMPLES,
+            "evaluated_points": points_by_role,
+            "interleave_group_sha256": interleave_sha256,
+            "amplicol_evidence": evidence_refs,
+        }
+    )
+    _write_json(output / "capture-index.json", index)
+    return index
+
+
+def _comma_separated_ints(value: str) -> tuple[int, ...]:
+    try:
+        result = tuple(int(item) for item in value.split(","))
+    except ValueError as error:
+        raise argparse.ArgumentTypeError("must be comma-separated integers") from error
+    if not result:
+        raise argparse.ArgumentTypeError("must not be empty")
+    return result
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be positive")
+    return parsed
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0.0:
+        raise argparse.ArgumentTypeError("must be finite and positive")
+    return parsed
+
+
+def _sha256(value: str) -> str:
+    invalid = any(character not in "0123456789abcdef" for character in value)
+    if len(value) != 64 or invalid:
+        raise argparse.ArgumentTypeError("must be a lowercase SHA-256")
+    return value
+
+
+def _revision(value: str) -> str:
+    invalid = any(character not in "0123456789abcdef" for character in value)
+    if len(value) != 40 or invalid:
+        raise argparse.ArgumentTypeError("must be a full lowercase Git SHA")
+    return value
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    capture = subparsers.add_parser(
+        "capture",
+        help="build the pinned probes and capture two authoritative M0 manifests",
+    )
+    capture.add_argument("--request-template", type=Path, required=True)
+    capture.add_argument(
+        "--repository",
+        type=Path,
+        default=legacy_amplicol.DEFAULT_REPOSITORY,
+        help="clean original-AmpliCol checkout at the contributor-lock revision",
+    )
+    capture.add_argument("--output-directory", type=Path, required=True)
+    capture.add_argument("--jobs", type=_positive_int, default=1)
+    capture.add_argument(
+        "--target-seconds",
+        type=_positive_float,
+        default=DEFAULT_TARGET_SECONDS,
+    )
+    capture.add_argument(
+        "--warmup-points",
+        type=_positive_int,
+        default=DEFAULT_WARMUP_POINTS,
+    )
+    capture.add_argument(
+        "--minimum-points",
+        type=_positive_int,
+        default=DEFAULT_MINIMUM_POINTS,
+    )
+    capture.add_argument(
+        "--maximum-points",
+        type=_positive_int,
+        default=DEFAULT_MAXIMUM_POINTS,
+    )
+    capture.add_argument("--selected-points", type=_positive_int)
+    capture.add_argument("--union-points", type=_positive_int)
+
+    sample = subparsers.add_parser("_sample", help=argparse.SUPPRESS)
+    sample.add_argument("--workload", choices=ROLES, required=True)
+    sample.add_argument("--round", type=int, required=True)
+    sample.add_argument("--momenta", type=Path, required=True)
+    sample.add_argument("--momenta-sha256", type=_sha256, required=True)
+    sample.add_argument("--momenta-points-sha256", type=_sha256, required=True)
+    sample.add_argument("--source-revision", type=_revision, required=True)
+    selectors = sample.add_mutually_exclusive_group(required=True)
+    selectors.add_argument("--color-flow-id")
+    selectors.add_argument("--helicity-id")
+    sample.add_argument(
+        "--color-flow-word",
+        type=_comma_separated_ints,
+        required=True,
+    )
+    sample.add_argument(
+        "--helicity-values",
+        type=_comma_separated_ints,
+        required=True,
+    )
+    sample.add_argument("--evaluated-points", type=_positive_int, required=True)
+    sample.add_argument("--runtime", type=Path, required=True)
+    sample.add_argument("--selected-binary", type=Path, required=True)
+    sample.add_argument("--union-binary", type=Path, required=True)
+    sample.add_argument("--process-file", type=Path, required=True)
+    sample.add_argument("--process-file-sha256", type=_sha256, required=True)
+    sample.add_argument("--group", type=_positive_int, required=True)
+    sample.add_argument("--integral", type=_positive_int, required=True)
+    sample.add_argument(
+        "--source-pdgs",
+        type=_comma_separated_ints,
+        required=True,
+    )
+    sample.add_argument(
+        "--generated-pdgs",
+        type=_comma_separated_ints,
+        required=True,
+    )
+    sample.add_argument(
+        "--generated-color-order",
+        type=_comma_separated_ints,
+        required=True,
+    )
+    sample.add_argument(
+        "--source-to-generated-permutation",
+        type=_comma_separated_ints,
+        required=True,
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _parser()
+    arguments = parser.parse_args(argv)
+    try:
+        if arguments.command == "_sample":
+            if (
+                arguments.workload == SELECTED_ROLE and arguments.color_flow_id is None
+            ) or (arguments.workload == UNION_ROLE and arguments.helicity_id is None):
+                _die("sample selector kind does not match its workload")
+            payload = _sample_payload(arguments)
+            sys.stdout.write(_canonical_bytes(payload).decode("utf-8") + "\n")
+            return 0
+        if arguments.maximum_points < arguments.minimum_points:
+            _die("maximum-points must not be below minimum-points")
+        index = _capture(arguments)
+        sys.stdout.write(_canonical_bytes(index).decode("utf-8") + "\n")
+        return 0
+    except CaptureError as error:
+        print(f"amplicol Z+6g M0 capture failed: {error}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/analytic_oracles.py b/pyamplicol/tools/developer/analytic_oracles.py
new file mode 100644
index 0000000000..0d4b8c647e
--- /dev/null
+++ b/pyamplicol/tools/developer/analytic_oracles.py
@@ -0,0 +1,365 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Small independent closed-form oracles for developer physics fixtures."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from decimal import (
+    ROUND_HALF_EVEN,
+    Context,
+    Decimal,
+    DecimalException,
+    localcontext,
+)
+from typing import cast
+
+Momentum = tuple[Decimal, Decimal, Decimal, Decimal]
+
+_DEFAULT_PRECISION = 100
+_DEFAULT_CERTIFIED_ACCURACY = 12
+_MINIMUM_PRECISION = 32
+_ARITHMETIC_GUARD_DIGITS = 8
+_VALIDATION_GUARD_DIGITS = 3
+
+_ZERO = Decimal("0")
+_ONE = Decimal("1")
+_TWO = Decimal("2")
+_SIXTEEN = Decimal("16")
+
+
+class AnalyticOracleError(ValueError):
+    """The requested point is outside an analytic oracle's domain."""
+
+
+@dataclass(frozen=True, slots=True)
+class AnalyticOracleMetadata:
+    """Precision and accuracy claims attached to one oracle observation.
+
+    Arithmetic precision is the working ``Decimal`` context.  Certified accuracy
+    is the relative decimal accuracy requested by the caller and protected by
+    working guard digits.  It assumes the supplied decimal components themselves
+    carry that accuracy; the oracle checks only their on-shell and conservation
+    residuals.  Kinematic oracles report the stricter residual tolerance used for
+    those checks.
+    """
+
+    arithmetic_precision_decimal_digits: int
+    certified_accuracy_decimal_digits: int
+    kinematic_validation_relative_tolerance: Decimal | None
+
+
+@dataclass(frozen=True, slots=True)
+class AnalyticObservation:
+    total: Decimal
+    helicity_ids: tuple[str, ...]
+    resolved: tuple[Decimal, ...]
+    metadata: AnalyticOracleMetadata
+
+    @property
+    def resolved_by_helicity(self) -> tuple[tuple[str, Decimal], ...]:
+        return tuple(zip(self.helicity_ids, self.resolved, strict=True))
+
+
+def scalar_contact_2to2(
+    coupling: Decimal = _ONE,
+    *,
+    precision: int = _DEFAULT_PRECISION,
+    certified_accuracy_digits: int = _DEFAULT_CERTIFIED_ACCURACY,
+) -> AnalyticObservation:
+    """Return the minimal-order massless ``scalar_0^4`` contact result."""
+
+    _validate_numeric_policy(precision, certified_accuracy_digits)
+    coupling = _finite_decimal(coupling, "scalar contact coupling")
+    try:
+        with localcontext(_decimal_context(precision)):
+            total = +(coupling * coupling / _TWO)
+    except DecimalException as exc:
+        raise AnalyticOracleError("scalar contact Decimal arithmetic failed") from exc
+    return AnalyticObservation(
+        total=total,
+        helicity_ids=("h:+0,+0,+0,+0",),
+        resolved=(total,),
+        metadata=_metadata(precision, certified_accuracy_digits, None),
+    )
+
+
+def scalar_gravity_2to2(
+    momenta: Sequence[Sequence[Decimal]],
+    coupling: Decimal = _ONE,
+    *,
+    precision: int = _DEFAULT_PRECISION,
+    certified_accuracy_digits: int = _DEFAULT_CERTIFIED_ACCURACY,
+) -> AnalyticObservation:
+    """Return ``scalar_0 scalar_0 -> graviton graviton`` at tree level.
+
+    The physical momentum order is ``p1, p2, p3, p4`` with the first two
+    particles incoming.  For massless external states the shipped model gives
+    ``kappa^4 t^2 u^2 / (16 s^2)`` after its identical-particle factor.  In the
+    public helicity order ``(--), (-+), (+-), (++)``, only the two opposite
+    graviton helicities contribute and each carries half of the total.
+
+    ``u`` is constructed as ``-s-t`` after independently validating all four
+    momenta.  This enforces the exact massless invariant relation instead of
+    feeding a tolerated input residual into the closed-form result.
+    """
+
+    _validate_numeric_policy(precision, certified_accuracy_digits)
+    coupling = _finite_decimal(coupling, "scalar-gravity coupling")
+    try:
+        with localcontext(_decimal_context(precision)):
+            point = _point(momenta, expected_count=4, process="2->2")
+            relative_tolerance = _validate_kinematics(
+                point,
+                masses=(_ZERO, _ZERO, _ZERO, _ZERO),
+                initial_state_count=2,
+                certified_accuracy_digits=certified_accuracy_digits,
+            )
+            s = +_square(_add(point[0], point[1]))
+            if s <= 0:
+                raise AnalyticOracleError(
+                    "scalar-gravity oracle requires positive nonzero s"
+                )
+            t = +_square(_subtract(point[0], point[2]))
+            direct_u = +_square(_subtract(point[0], point[3]))
+            _validate_invariant_identity(s, t, direct_u, relative_tolerance)
+            u = +(-s - t)
+            total = +(coupling**4 * t**2 * u**2 / (_SIXTEEN * s**2))
+            half = +(total / _TWO)
+    except DecimalException as exc:
+        raise AnalyticOracleError("scalar-gravity Decimal arithmetic failed") from exc
+    return AnalyticObservation(
+        total=total,
+        helicity_ids=(
+            "h:+0,+0,-2,-2",
+            "h:+0,+0,-2,+2",
+            "h:+0,+0,+2,-2",
+            "h:+0,+0,+2,+2",
+        ),
+        resolved=(_ZERO, half, half, _ZERO),
+        metadata=_metadata(precision, certified_accuracy_digits, relative_tolerance),
+    )
+
+
+def chiral_current_2to1(
+    momenta: Sequence[Sequence[Decimal]],
+    *,
+    vector_mass: Decimal,
+    left_coupling: Decimal,
+    right_coupling: Decimal,
+    precision: int = _DEFAULT_PRECISION,
+    certified_accuracy_digits: int = _DEFAULT_CERTIFIED_ACCURACY,
+) -> AnalyticObservation:
+    """Return a massless chiral-current ``fermion antifermion -> vector`` probe.
+
+    For a vertex ``gamma^mu (g_L P_L + g_R P_R)``, the two nonzero resolved
+    members are ``2 s g_L^2`` and ``2 s g_R^2`` in the public helicity order
+    ``(-,+,-), (+,-,+)``.  Choosing unequal nonzero couplings makes leg or
+    helicity permutations observable, unlike the parity-even scalar-gravity
+    rows above.
+    """
+
+    _validate_numeric_policy(precision, certified_accuracy_digits)
+    vector_mass = _finite_decimal(vector_mass, "vector mass")
+    left_coupling = _finite_decimal(left_coupling, "left chiral coupling")
+    right_coupling = _finite_decimal(right_coupling, "right chiral coupling")
+    if vector_mass <= 0:
+        raise AnalyticOracleError("vector mass must be positive")
+    try:
+        with localcontext(_decimal_context(precision)):
+            point = _point(momenta, expected_count=3, process="2->1")
+            relative_tolerance = _validate_kinematics(
+                point,
+                masses=(_ZERO, _ZERO, vector_mass),
+                initial_state_count=2,
+                certified_accuracy_digits=certified_accuracy_digits,
+            )
+            s = +_square(_add(point[0], point[1]))
+            if s <= 0:
+                raise AnalyticOracleError(
+                    "chiral-current oracle requires positive nonzero s"
+                )
+            left = +(_TWO * s * left_coupling**2)
+            right = +(_TWO * s * right_coupling**2)
+            total = +(left + right)
+    except DecimalException as exc:
+        raise AnalyticOracleError("chiral-current Decimal arithmetic failed") from exc
+    return AnalyticObservation(
+        total=total,
+        helicity_ids=("h:-1,+1,-1", "h:+1,-1,+1"),
+        resolved=(left, right),
+        metadata=_metadata(precision, certified_accuracy_digits, relative_tolerance),
+    )
+
+
+def _decimal_context(precision: int) -> Context:
+    return Context(prec=precision, rounding=ROUND_HALF_EVEN)
+
+
+def _validate_numeric_policy(precision: int, certified_accuracy_digits: int) -> None:
+    if isinstance(precision, bool) or not isinstance(precision, int):
+        raise AnalyticOracleError("analytic precision must be an integer")
+    if precision < _MINIMUM_PRECISION:
+        raise AnalyticOracleError(
+            f"analytic precision must be at least {_MINIMUM_PRECISION} digits"
+        )
+    if isinstance(certified_accuracy_digits, bool) or not isinstance(
+        certified_accuracy_digits, int
+    ):
+        raise AnalyticOracleError("certified accuracy must be an integer")
+    if certified_accuracy_digits <= 0:
+        raise AnalyticOracleError("certified accuracy must be positive")
+    maximum_accuracy = precision - _ARITHMETIC_GUARD_DIGITS
+    if certified_accuracy_digits > maximum_accuracy:
+        raise AnalyticOracleError(
+            "certified accuracy must leave at least "
+            f"{_ARITHMETIC_GUARD_DIGITS} arithmetic guard digits"
+        )
+
+
+def _finite_decimal(value: object, label: str) -> Decimal:
+    if not isinstance(value, Decimal):
+        raise AnalyticOracleError(f"{label} must be a Decimal")
+    if not value.is_finite():
+        raise AnalyticOracleError(f"{label} must be finite")
+    return value
+
+
+def _metadata(
+    precision: int,
+    certified_accuracy_digits: int,
+    relative_tolerance: Decimal | None,
+) -> AnalyticOracleMetadata:
+    return AnalyticOracleMetadata(
+        arithmetic_precision_decimal_digits=precision,
+        certified_accuracy_decimal_digits=certified_accuracy_digits,
+        kinematic_validation_relative_tolerance=relative_tolerance,
+    )
+
+
+def _point(
+    momenta: Sequence[Sequence[Decimal]],
+    *,
+    expected_count: int,
+    process: str,
+) -> tuple[Momentum, ...]:
+    count_name = {3: "three", 4: "four"}.get(expected_count, str(expected_count))
+    if (
+        isinstance(momenta, str | bytes)
+        or not isinstance(momenta, Sequence)
+        or len(momenta) != expected_count
+    ):
+        raise AnalyticOracleError(
+            f"{process} oracle requires {count_name} external momenta"
+        )
+    point = []
+    for index, vector in enumerate(momenta):
+        if (
+            isinstance(vector, str | bytes)
+            or not isinstance(vector, Sequence)
+            or len(vector) != 4
+        ):
+            raise AnalyticOracleError(
+                f"momentum {index} must contain four Decimal components"
+            )
+        components = tuple(
+            _finite_decimal(value, f"momentum {index} component {component_index}")
+            for component_index, value in enumerate(vector)
+        )
+        point.append(cast(Momentum, components))
+    return tuple(point)
+
+
+def _add(left: Momentum, right: Momentum) -> Momentum:
+    return cast(Momentum, tuple(a + b for a, b in zip(left, right, strict=True)))
+
+
+def _subtract(left: Momentum, right: Momentum) -> Momentum:
+    return cast(Momentum, tuple(a - b for a, b in zip(left, right, strict=True)))
+
+
+def _square(momentum: Momentum) -> Decimal:
+    return momentum[0] ** 2 - sum((component**2 for component in momentum[1:]), _ZERO)
+
+
+def _validation_relative_tolerance(
+    certified_accuracy_digits: int,
+) -> Decimal:
+    return _ONE.scaleb(-(certified_accuracy_digits + _VALIDATION_GUARD_DIGITS))
+
+
+def _validate_kinematics(
+    point: tuple[Momentum, ...],
+    *,
+    masses: tuple[Decimal, ...],
+    initial_state_count: int,
+    certified_accuracy_digits: int,
+) -> Decimal:
+    relative_tolerance = _validation_relative_tolerance(certified_accuracy_digits)
+    scale = max(
+        max(
+            (abs(component) for momentum in point for component in momentum),
+            default=_ONE,
+        ),
+        _ONE,
+    )
+    momentum_tolerance = +(scale * relative_tolerance)
+    shell_tolerance = +(max(scale * scale, _ONE) * relative_tolerance)
+    for index, (momentum, mass) in enumerate(zip(point, masses, strict=True)):
+        if momentum[0] <= 0:
+            raise AnalyticOracleError(f"momentum {index} has non-positive energy")
+        residual = +(_square(momentum) - mass * mass)
+        if abs(residual) > shell_tolerance:
+            if mass == 0:
+                raise AnalyticOracleError(
+                    f"momentum {index} is not massless: residual {residual} "
+                    f"exceeds {shell_tolerance}"
+                )
+            raise AnalyticOracleError(
+                f"momentum {index} is off shell: residual {residual} "
+                f"exceeds {shell_tolerance}"
+            )
+    imbalance = tuple(
+        sum(
+            (momentum[component] for momentum in point[:initial_state_count]),
+            _ZERO,
+        )
+        - sum(
+            (momentum[component] for momentum in point[initial_state_count:]),
+            _ZERO,
+        )
+        for component in range(4)
+    )
+    if any(abs(component) > momentum_tolerance for component in imbalance):
+        raise AnalyticOracleError(
+            "momenta do not conserve four-momentum: "
+            f"residual {imbalance} exceeds {momentum_tolerance}"
+        )
+    return relative_tolerance
+
+
+def _validate_invariant_identity(
+    s: Decimal,
+    t: Decimal,
+    direct_u: Decimal,
+    relative_tolerance: Decimal,
+) -> None:
+    scale = max(abs(s), abs(t), abs(direct_u), _ONE)
+    tolerance = +(scale * relative_tolerance)
+    residual = +(s + t + direct_u)
+    if abs(residual) > tolerance:
+        raise AnalyticOracleError(
+            "massless invariants violate s+t+u=0: "
+            f"residual {residual} exceeds {tolerance}"
+        )
+
+
+__all__ = [
+    "AnalyticObservation",
+    "AnalyticOracleError",
+    "AnalyticOracleMetadata",
+    "chiral_current_2to1",
+    "scalar_contact_2to2",
+    "scalar_gravity_2to2",
+]
diff --git a/pyamplicol/tools/developer/arena_native_x86_acceptance.py b/pyamplicol/tools/developer/arena_native_x86_acceptance.py
new file mode 100644
index 0000000000..4fc333469e
--- /dev/null
+++ b/pyamplicol/tools/developer/arena_native_x86_acceptance.py
@@ -0,0 +1,1834 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Authenticate and bind the native-x86 Arena acceptance evidence.
+
+The ``preflight`` phase runs after the candidate wheel deployment check and
+authenticates the clean source checkout, installed Python package, native
+extension, build provenance, and candidate wheel before any ``pyamplicol``
+import.  The ``audit`` phase repeats that authentication after the Arena gates,
+validates their complete numerical contracts, and writes one content-addressed
+acceptance manifest that binds every input evidence file.
+
+Both phases re-exec with ``-I -S -B`` and an absent external bytecode-cache
+prefix.  This is the same source-only bootstrap policy used by the compiled
+Arena gate programs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib
+import importlib.machinery
+import io
+import json
+import math
+import os
+import platform
+import re
+import stat
+import subprocess
+import sys
+import sysconfig
+import tempfile
+import uuid
+import zipfile
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+_EXACT_REEXEC_MARKER = "PYAMPLICOL_X86_ACCEPTANCE_EXACT_REEXEC"
+_EXACT_IMPORT_PATHS = "PYAMPLICOL_X86_ACCEPTANCE_IMPORT_PATHS"
+
+
+def _bootstrap_source_only_python() -> None:
+    """Re-exec before importing repository or candidate runtime modules."""
+
+    if os.environ.get(_EXACT_REEXEC_MARKER) == "1":
+        if (
+            sys.flags.isolated != 1
+            or sys.flags.no_site != 1
+            or sys.flags.ignore_environment != 1
+            or sys.flags.dont_write_bytecode != 1
+            or not sys.dont_write_bytecode
+        ):
+            raise RuntimeError("exact Python re-exec flags are incomplete")
+        raw_paths = json.loads(os.environ[_EXACT_IMPORT_PATHS])
+        if not isinstance(raw_paths, list) or not all(
+            isinstance(path, str) and Path(path).is_absolute() for path in raw_paths
+        ):
+            raise RuntimeError("exact Python import paths are invalid")
+        cache_prefix = os.environ.get("PYTHONPYCACHEPREFIX")
+        if (
+            not isinstance(cache_prefix, str)
+            or not Path(cache_prefix).is_absolute()
+            or Path(cache_prefix).exists()
+        ):
+            raise RuntimeError("exact Python cache prefix is not absent")
+        for import_path in reversed(raw_paths):
+            if import_path not in sys.path:
+                sys.path.insert(0, import_path)
+        sys.pycache_prefix = cache_prefix
+        return
+
+    prefix = Path(tempfile.gettempdir()) / (
+        f".pyamplicol-x86-acceptance-no-bytecode-{os.getpid()}-{uuid.uuid4().hex}"
+    )
+    if prefix.exists():
+        raise RuntimeError(
+            f"isolated Python cache prefix unexpectedly exists: {prefix}"
+        )
+    import_paths: list[str] = []
+    native_root = next(
+        (
+            candidate
+            for entry in sys.path
+            if (candidate := Path(entry) / "pyamplicol").is_dir()
+            and any(
+                path.is_file()
+                and path.name.startswith("_rusticol")
+                and path.name.endswith(tuple(importlib.machinery.EXTENSION_SUFFIXES))
+                for path in candidate.iterdir()
+            )
+        ),
+        None,
+    )
+    if native_root is not None:
+        import_paths.append(str(native_root.parent.resolve(strict=True)))
+    for scheme_name in ("purelib", "platlib"):
+        scheme_path = sysconfig.get_path(scheme_name)
+        if not isinstance(scheme_path, str):
+            continue
+        try:
+            resolved = str(Path(scheme_path).resolve(strict=True))
+        except OSError:
+            continue
+        if resolved not in import_paths:
+            import_paths.append(resolved)
+    environment = os.environ.copy()
+    environment["PYTHONDONTWRITEBYTECODE"] = "1"
+    environment["PYTHONPYCACHEPREFIX"] = str(prefix)
+    environment[_EXACT_REEXEC_MARKER] = "1"
+    environment[_EXACT_IMPORT_PATHS] = json.dumps(import_paths)
+    os.execve(
+        sys.executable,
+        (
+            sys.executable,
+            "-I",
+            "-S",
+            "-B",
+            str(Path(__file__).resolve(strict=True)),
+            *sys.argv[1:],
+        ),
+        environment,
+    )
+    raise RuntimeError("exact Python re-exec returned unexpectedly")
+
+
+if __name__ == "__main__":
+    _bootstrap_source_only_python()
+
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.performance_report.runtime_evidence import (  # noqa: E402
+    RuntimeEvidenceError,
+    established_preimport_runtime_identity,
+    loaded_pyamplicol_origin_policy,
+    native_extension_in_package,
+    preimport_python_runtime_identity,
+    source_only_bytecode_policy,
+)
+
+PREFLIGHT_KIND = "pyamplicol-arena-native-x86-runtime-preflight"
+ACCEPTANCE_KIND = "pyamplicol-arena-native-x86-acceptance"
+ALL_JIT_KIND = "pyamplicol-compiled-all-jit-direct-arena-gate"
+FOUR_QUARK_KIND = "pyamplicol-four-quark-compiled-direct-arena-gate"
+COLOR_MATRIX_KIND = "pyamplicol-eager-benchmark-matrix"
+SCHEMA_VERSION = 1
+COLOR_MATRIX_SCHEMA_VERSION = 3
+EXPECTED_TARGET = "x86_64-unknown-linux-gnu"
+EXPECTED_POINT_COUNT = 3
+EXPECTED_MEMORY_LIMIT_GIB = 30
+REVISION_PATTERN = re.compile(r"[0-9a-f]{40}")
+SHA256_PATTERN = re.compile(r"[0-9a-f]{64}")
+HASH_CHUNK_BYTES = 1024 * 1024
+CONTENT_IDENTITY_ALGORITHM = "sha256-canonical-json-body-v1"
+PREFLIGHT_FILENAME = "runtime-identity-preflight.json"
+ACCEPTANCE_FILENAME = "arena-native-x86-acceptance.json"
+ALL_JIT_RELATIVE_PATH = Path(
+    "compiled-all-jit",
+    "compiled-all-jit-arena-gate.json",
+)
+FOUR_QUARK_RELATIVE_PATH = Path(
+    "four-quark",
+    "four-quark-compiled-gate.json",
+)
+COLOR_MATRIX_RELATIVE_PATH = Path("eager-compiled-color", "result.json")
+
+_ALL_JIT_LEVELS = {
+    "jit-o0": 0,
+    "jit-o1": 1,
+    "jit-o2": 2,
+    "jit-o3": 3,
+}
+_ALL_JIT_POINT_SEEDS = (846_731, 846_739, 846_763)
+_ALL_JIT_COMPARISONS = {
+    "f64_vs_precision32_total",
+    "f64_evaluate_vs_resolved_total",
+    "precision32_evaluate_vs_resolved_total",
+    "f64_vs_precision32_resolved_components",
+}
+_CROSS_LEVEL_COMPARISONS = {
+    "f64_totals",
+    "precision32_totals",
+    "f64_resolved_components",
+    "precision32_resolved_components",
+}
+_FOUR_QUARK_LANES = {
+    "lc-topology-replay": ("lc", "topology-replay", False),
+    "lc-all-flow-union": ("lc", "all-flow-union", False),
+    "nlc-contracted": ("nlc", "topology-replay", True),
+    "full-contracted": ("full", "topology-replay", True),
+}
+_FOUR_QUARK_POINT_SEEDS = (443_041, 443_099, 443_137)
+_FOUR_QUARK_BASE_COMPARISONS = {
+    "f64_vs_precision32_total",
+    "f64_vs_precision32_components",
+    "f64_evaluate_vs_resolved_total",
+    "precision32_evaluate_vs_resolved_total",
+    "helicity_selector_evaluate_vs_resolved_total",
+}
+_CROSS_LC_COMPARISONS = {
+    "f64_totals",
+    "precision32_totals",
+    "f64_resolved_components",
+    "precision32_resolved_components",
+    "color_selector",
+    "helicity_selector",
+}
+_SMOKE_CASES = {
+    "dd_z_3g": ("d d~ > z g g g", 4),
+    "dd_3q_1g": ("d d~ > u u~ s s~ g", 5),
+}
+_COLORS = ("lc", "nlc", "full")
+_COLOR_MATRIX_GATES = {
+    "matrix_scope_complete",
+    "correctness",
+    "per_point_selector_patterns",
+    "builtin_ufo_topology_parity",
+    "smoke_under_five_minutes",
+    "n4_n5_reusable_compiled_at_most_1_25x_specialized",
+    "nlc_full_each_at_least_7x",
+    "lc_no_generation_regression",
+    "per_process_geometric_mean_at_least_7x",
+}
+_CORRECTNESS_FIELDS = {
+    "total",
+    "resolved_f64",
+    "resolved_precision32",
+    "eager_resolved_sum",
+    "compiled_resolved_sum",
+    "passes",
+}
+_STABLE_STAT_FIELDS = (
+    "st_dev",
+    "st_ino",
+    "st_mode",
+    "st_size",
+    "st_mtime_ns",
+    "st_ctime_ns",
+)
+
+
+class AcceptanceError(RuntimeError):
+    """Raised when native-x86 acceptance evidence cannot be trusted."""
+
+
+def _canonical_json(value: object) -> bytes:
+    try:
+        return json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("utf-8")
+    except (TypeError, ValueError) as error:
+        raise AcceptanceError("evidence is not canonical JSON") from error
+
+
+def _canonical_sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_json(value)).hexdigest()
+
+
+def _attach_content_identity(body: Mapping[str, object]) -> dict[str, object]:
+    result = dict(body)
+    result["content_identity"] = {
+        "algorithm": CONTENT_IDENTITY_ALGORITHM,
+        "sha256": _canonical_sha256(body),
+    }
+    return result
+
+
+def _mapping(value: object, *, label: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise AcceptanceError(f"{label} must be an object")
+    return value
+
+
+def _list(value: object, *, label: str) -> list[Any]:
+    if not isinstance(value, list):
+        raise AcceptanceError(f"{label} must be an array")
+    return value
+
+
+def _require_true(value: object, *, label: str) -> None:
+    if value is not True:
+        raise AcceptanceError(f"{label} must be true")
+
+
+def _require_positive_int(value: object, *, label: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+        raise AcceptanceError(f"{label} must be a positive integer")
+    return value
+
+
+def _require_nonempty_string(value: object, *, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise AcceptanceError(f"{label} must be a non-empty string")
+    return value
+
+
+def _require_sha256(value: object, *, label: str) -> str:
+    if not isinstance(value, str) or SHA256_PATTERN.fullmatch(value) is None:
+        raise AcceptanceError(f"{label} must be a lowercase SHA-256 digest")
+    return value
+
+
+def _require_content_identity(payload: Mapping[str, object], *, label: str) -> None:
+    identity = _mapping(
+        payload.get("content_identity"),
+        label=f"{label}.content_identity",
+    )
+    if identity.get("algorithm") != CONTENT_IDENTITY_ALGORITHM:
+        raise AcceptanceError(f"{label} has the wrong content-identity algorithm")
+    body = dict(payload)
+    body.pop("content_identity")
+    if identity.get("sha256") != _canonical_sha256(body):
+        raise AcceptanceError(f"{label} content identity is invalid")
+
+
+def _same_stat(left: os.stat_result, right: os.stat_result) -> bool:
+    return all(
+        getattr(left, field) == getattr(right, field) for field in _STABLE_STAT_FIELDS
+    )
+
+
+def _checked_file_bytes(path: Path, *, label: str) -> tuple[bytes, dict[str, object]]:
+    """Read one stable regular file through a no-follow descriptor."""
+
+    try:
+        parent = path.parent.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise AcceptanceError(f"cannot resolve {label} parent: {path}") from error
+    flags = (
+        os.O_RDONLY
+        | getattr(os, "O_CLOEXEC", 0)
+        | getattr(os, "O_NOFOLLOW", 0)
+        | getattr(os, "O_BINARY", 0)
+    )
+    descriptor: int | None = None
+    parent_fd: int | None = None
+    try:
+        parent_fd = os.open(
+            parent,
+            os.O_RDONLY
+            | getattr(os, "O_CLOEXEC", 0)
+            | getattr(os, "O_DIRECTORY", 0)
+            | getattr(os, "O_NOFOLLOW", 0),
+        )
+        namespace_before = os.stat(
+            path.name,
+            dir_fd=parent_fd,
+            follow_symlinks=False,
+        )
+        if not stat.S_ISREG(namespace_before.st_mode):
+            raise AcceptanceError(f"{label} is not a regular file: {path}")
+        descriptor = os.open(path.name, flags, dir_fd=parent_fd)
+        opened_before = os.fstat(descriptor)
+        if not _same_stat(namespace_before, opened_before):
+            raise AcceptanceError(f"{label} changed while it was opened: {path}")
+        digest = hashlib.sha256()
+        blocks: list[bytes] = []
+        byte_count = 0
+        with os.fdopen(descriptor, "rb", closefd=True) as stream:
+            descriptor = None
+            while block := stream.read(HASH_CHUNK_BYTES):
+                digest.update(block)
+                blocks.append(block)
+                byte_count += len(block)
+            opened_after = os.fstat(stream.fileno())
+        namespace_after = os.stat(
+            path.name,
+            dir_fd=parent_fd,
+            follow_symlinks=False,
+        )
+    except OSError as error:
+        raise AcceptanceError(f"cannot authenticate {label}: {path}") from error
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+        if parent_fd is not None:
+            os.close(parent_fd)
+    if (
+        byte_count != opened_before.st_size
+        or not _same_stat(opened_before, opened_after)
+        or not _same_stat(opened_after, namespace_after)
+    ):
+        raise AcceptanceError(f"{label} changed while it was hashed: {path}")
+    return b"".join(blocks), {
+        "path": str(parent / path.name),
+        "size_bytes": byte_count,
+        "sha256": digest.hexdigest(),
+    }
+
+
+def _checked_file_identity(path: Path, *, label: str) -> dict[str, object]:
+    return _checked_file_bytes(path, label=label)[1]
+
+
+def _reject_json_constant(value: str) -> None:
+    raise AcceptanceError(f"JSON contains a non-finite number: {value}")
+
+
+def _reject_duplicate_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise AcceptanceError(f"JSON object contains duplicate key: {key!r}")
+        result[key] = value
+    return result
+
+
+def _checked_json(
+    path: Path,
+    *,
+    label: str,
+) -> tuple[dict[str, Any], dict[str, object]]:
+    encoded, identity = _checked_file_bytes(path, label=label)
+    try:
+        payload = json.loads(
+            encoded.decode("utf-8"),
+            object_pairs_hook=_reject_duplicate_keys,
+            parse_constant=_reject_json_constant,
+        )
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise AcceptanceError(f"{label} is not strict UTF-8 JSON: {path}") from error
+    if not isinstance(payload, dict):
+        raise AcceptanceError(f"{label} must contain a JSON object")
+    _canonical_json(payload)
+    return payload, identity
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    try:
+        temporary.write_text(
+            json.dumps(
+                payload,
+                allow_nan=False,
+                ensure_ascii=False,
+                indent=2,
+                sort_keys=True,
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, path)
+    except OSError as error:
+        temporary.unlink(missing_ok=True)
+        raise AcceptanceError(f"cannot write acceptance evidence: {path}") from error
+
+
+def _remove_stale_file(path: Path) -> None:
+    try:
+        metadata = path.lstat()
+    except FileNotFoundError:
+        return
+    except OSError as error:
+        raise AcceptanceError(f"cannot inspect stale evidence: {path}") from error
+    if not stat.S_ISREG(metadata.st_mode):
+        raise AcceptanceError(f"refusing non-regular stale evidence: {path}")
+    try:
+        path.unlink()
+    except OSError as error:
+        raise AcceptanceError(f"cannot remove stale evidence: {path}") from error
+
+
+def _evidence_root(path: Path) -> Path:
+    root = path.expanduser().resolve(strict=False)
+    checkout = ROOT.resolve(strict=True)
+    if root == Path(root.anchor) or root == checkout:
+        raise AcceptanceError("refusing a broad evidence root")
+    try:
+        root.relative_to(checkout)
+    except ValueError:
+        pass
+    else:
+        raise AcceptanceError("Arena evidence root must be outside the checkout")
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def _git_output(arguments: Sequence[str]) -> str:
+    completed = subprocess.run(
+        ("git", *arguments),
+        cwd=ROOT,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or completed.stdout.strip()
+        raise AcceptanceError(f"git {' '.join(arguments)} failed: {detail}")
+    return completed.stdout.strip()
+
+
+def _source_identity(
+    *,
+    expected_revision: str,
+    expected_workspace: Path,
+) -> dict[str, object]:
+    if REVISION_PATTERN.fullmatch(expected_revision) is None:
+        raise AcceptanceError("expected revision must be a full lowercase Git SHA")
+    try:
+        workspace = expected_workspace.expanduser().resolve(strict=True)
+        checkout = ROOT.resolve(strict=True)
+    except OSError as error:
+        raise AcceptanceError("expected source workspace is unavailable") from error
+    if workspace != checkout:
+        raise AcceptanceError("acceptance helper is executing from another workspace")
+    revision = _git_output(("rev-parse", "--verify", "HEAD"))
+    status = _git_output(("status", "--porcelain=v1", "--untracked-files=all"))
+    if revision != expected_revision or status:
+        raise AcceptanceError("candidate checkout is not the clean dispatched revision")
+    return {
+        "checkout": str(checkout),
+        "revision": revision,
+        "dirty": False,
+        "untracked_files_checked": True,
+    }
+
+
+def _ensure_source_only_python() -> None:
+    try:
+        source_only_bytecode_policy()
+    except RuntimeEvidenceError as error:
+        raise AcceptanceError(
+            "source-only Python bootstrap did not complete before authentication"
+        ) from error
+
+
+def _establish_preimport_runtime_identity() -> None:
+    candidates = []
+    for entry in sys.path:
+        package_root = Path(entry) / "pyamplicol"
+        if not package_root.is_dir():
+            continue
+        if any(
+            path.is_file()
+            and path.name.startswith("_rusticol")
+            and path.name.endswith(tuple(importlib.machinery.EXTENSION_SUFFIXES))
+            for path in package_root.iterdir()
+        ):
+            resolved = package_root.resolve(strict=True)
+            if resolved not in candidates:
+                candidates.append(resolved)
+    if len(candidates) != 1:
+        raise AcceptanceError(
+            "exactly one native pyamplicol package must be importable before audit"
+        )
+    try:
+        native = native_extension_in_package(candidates[0])
+        preimport_python_runtime_identity(
+            (candidates[0],),
+            native_extension=native,
+        )
+    except RuntimeEvidenceError as error:
+        raise AcceptanceError(str(error)) from error
+
+
+def _wheel_build_info(encoded: bytes) -> dict[str, Any]:
+    try:
+        with zipfile.ZipFile(io.BytesIO(encoded)) as archive:
+            matches = [
+                info
+                for info in archive.infolist()
+                if info.filename == "pyamplicol/_build_info.json"
+            ]
+            if len(matches) != 1:
+                raise AcceptanceError(
+                    "candidate wheel must contain one pyamplicol/_build_info.json"
+                )
+            raw = archive.read(matches[0])
+    except (OSError, zipfile.BadZipFile, KeyError) as error:
+        raise AcceptanceError("candidate wheel is not a valid wheel archive") from error
+    try:
+        value = json.loads(
+            raw.decode("utf-8"),
+            object_pairs_hook=_reject_duplicate_keys,
+            parse_constant=_reject_json_constant,
+        )
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise AcceptanceError("candidate wheel build info is invalid JSON") from error
+    if not isinstance(value, dict):
+        raise AcceptanceError("candidate wheel build info is not an object")
+    return value
+
+
+def _runtime_identity(
+    source: Mapping[str, object],
+) -> dict[str, object]:
+    try:
+        pyamplicol = importlib.import_module("pyamplicol")
+        native = importlib.import_module("pyamplicol._rusticol")
+        versions = importlib.import_module("pyamplicol._internal.versions")
+    except ImportError as error:
+        raise AcceptanceError("candidate native runtime is unavailable") from error
+    package_roots = tuple(
+        Path(str(path)).expanduser().resolve(strict=True)
+        for path in pyamplicol.__path__
+    )
+    candidate_root = (ROOT / ".venv").resolve(strict=True)
+    if len(package_roots) != 1 or not package_roots[0].is_relative_to(candidate_root):
+        raise AcceptanceError("pyamplicol was not imported from the candidate venv")
+    native_path_raw = getattr(native, "__file__", None)
+    if not isinstance(native_path_raw, str):
+        raise AcceptanceError("candidate native extension has no path")
+    native_path = Path(native_path_raw).expanduser().resolve(strict=True)
+    if native_path.parent != package_roots[0]:
+        raise AcceptanceError("native extension is outside the candidate package")
+    target = str(native.target_info().triple)
+    if (
+        platform.system() != "Linux"
+        or platform.machine() != "x86_64"
+        or "x86_64" not in sysconfig.get_platform()
+        or target != EXPECTED_TARGET
+    ):
+        raise AcceptanceError("Arena acceptance requires native Linux x86_64")
+    native_inputs = native.native_build_inputs_sha256()
+    _require_sha256(native_inputs, label="native build-input identity")
+    build_info = versions._active_build_info()
+    if not isinstance(build_info, Mapping):
+        raise AcceptanceError("candidate exposes no strict build provenance")
+    try:
+        build_checkout = (
+            Path(str(build_info.get("source_checkout")))
+            .expanduser()
+            .resolve(strict=True)
+        )
+    except OSError as error:
+        raise AcceptanceError("candidate build checkout is unavailable") from error
+    if (
+        build_info.get("source_revision") != source.get("revision")
+        or build_checkout != ROOT.resolve(strict=True)
+        or build_info.get("native_build_inputs_sha256") != native_inputs
+        or build_info.get("publishable") is not False
+        or build_info.get("selftest_fixture_bootstrap") is not False
+    ):
+        raise AcceptanceError("candidate build provenance is not exact")
+    artifact_directory = (ROOT / ".artifacts" / "candidate").resolve(strict=True)
+    wheels = tuple(sorted(artifact_directory.glob("*.whl")))
+    if len(wheels) != 1:
+        raise AcceptanceError("candidate build must produce exactly one wheel")
+    wheel_bytes, wheel_identity = _checked_file_bytes(
+        wheels[0],
+        label="candidate wheel",
+    )
+    wheel_build_info = _wheel_build_info(wheel_bytes)
+    if wheel_build_info != dict(build_info):
+        raise AcceptanceError(
+            "candidate wheel and installed runtime expose different build provenance"
+        )
+    preimport = established_preimport_runtime_identity()
+    try:
+        loaded_policy = loaded_pyamplicol_origin_policy(
+            package_roots,
+            native_extension=native_path,
+            expected_package_identity=preimport["python_package_tree"],
+            expected_native_identity=preimport["native_extension"],
+        )
+    except RuntimeEvidenceError as error:
+        raise AcceptanceError(str(error)) from error
+    interpreter_identity = _checked_file_identity(
+        Path(sys.executable).resolve(strict=True),
+        label="candidate interpreter",
+    )
+    return {
+        "kind": "pyamplicol-arena-native-x86-runtime-identity",
+        "schema_version": 1,
+        "interpreter": {
+            **interpreter_identity,
+            "python_version": platform.python_version(),
+            "implementation": platform.python_implementation(),
+        },
+        "platform": {
+            "system": platform.system(),
+            "machine": platform.machine(),
+            "python_platform": sysconfig.get_platform(),
+            "target": target,
+        },
+        "preimport_runtime_identity": preimport,
+        "package": {
+            "roots": [str(path) for path in package_roots],
+            "version": str(getattr(pyamplicol, "__version__", "")),
+        },
+        "loaded_module_origin_policy": loaded_policy,
+        "native_extension": {
+            **_checked_file_identity(native_path, label="candidate native extension"),
+            "target": target,
+            "build_inputs_sha256": native_inputs,
+        },
+        "active_build_info": {
+            "payload": dict(build_info),
+            "canonical_sha256": _canonical_sha256(build_info),
+        },
+        "candidate_wheel": {
+            **wheel_identity,
+            "build_info_canonical_sha256": _canonical_sha256(wheel_build_info),
+            "matches_active_build_info": True,
+        },
+        "passes": True,
+    }
+
+
+def _stable_runtime_identity(value: Mapping[str, object]) -> dict[str, object]:
+    stable = dict(value)
+    raw_policy = stable.get("loaded_module_origin_policy")
+    if isinstance(raw_policy, Mapping):
+        policy = dict(raw_policy)
+        for field in (
+            "observed_module_count",
+            "observations",
+            "observations_sha256",
+        ):
+            policy.pop(field, None)
+        stable["loaded_module_origin_policy"] = policy
+    return stable
+
+
+def _runtime_identity_sha256(value: Mapping[str, object]) -> str:
+    return _canonical_sha256(_stable_runtime_identity(value))
+
+
+def _cross_process_runtime_binding(
+    value: Mapping[str, object],
+    *,
+    label: str,
+) -> dict[str, object]:
+    """Normalize the byte identities shared by helper and gate processes."""
+
+    preimport = value.get("preimport_runtime_identity")
+    if isinstance(preimport, Mapping):
+        package_tree = _mapping(
+            preimport.get("python_package_tree"),
+            label=f"{label}.preimport_runtime_identity.python_package_tree",
+        )
+    else:
+        package_tree = _mapping(
+            value.get("python_package_tree"),
+            label=f"{label}.python_package_tree",
+        )
+    interpreter = _mapping(
+        value.get("interpreter"),
+        label=f"{label}.interpreter",
+    )
+    native = _mapping(
+        value.get("native_extension"),
+        label=f"{label}.native_extension",
+    )
+    active = _mapping(
+        value.get("active_build_info"),
+        label=f"{label}.active_build_info",
+    )
+    package = _mapping(value.get("package"), label=f"{label}.package")
+    return {
+        "interpreter": {
+            name: interpreter.get(name)
+            for name in (
+                "path",
+                "size_bytes",
+                "sha256",
+                "python_version",
+                "implementation",
+            )
+        },
+        "python_package_tree": dict(package_tree),
+        "native_extension": {
+            name: native.get(name)
+            for name in ("path", "size_bytes", "sha256", "build_inputs_sha256")
+        },
+        "active_build_info": dict(active),
+        "package_version": package.get("version"),
+    }
+
+
+def _require_gate_provenance(
+    payload: Mapping[str, object],
+    *,
+    label: str,
+    expected_revision: str,
+    expected_workspace: Path,
+    expected_runtime: Mapping[str, object] | None = None,
+) -> None:
+    source = _mapping(payload.get("source_identity"), label=f"{label}.source_identity")
+    source_postflight = _mapping(
+        payload.get("source_identity_postflight"),
+        label=f"{label}.source_identity_postflight",
+    )
+    _require_true(payload.get("source_identity_match"), label=f"{label}.source match")
+    expected_source = {
+        "checkout": str(expected_workspace.resolve(strict=True)),
+        "revision": expected_revision,
+        "dirty": False,
+        "untracked_files_checked": True,
+    }
+    if dict(source) != expected_source or dict(source_postflight) != expected_source:
+        raise AcceptanceError(f"{label} source identity is not exact")
+    runtime = _mapping(
+        payload.get("runtime_identity"),
+        label=f"{label}.runtime_identity",
+    )
+    runtime_postflight = _mapping(
+        payload.get("runtime_identity_postflight"),
+        label=f"{label}.runtime_identity_postflight",
+    )
+    _require_true(payload.get("runtime_identity_match"), label=f"{label}.runtime match")
+    if _stable_runtime_identity(runtime) != _stable_runtime_identity(
+        runtime_postflight
+    ):
+        raise AcceptanceError(f"{label} runtime identity changed")
+    if expected_runtime is not None and _cross_process_runtime_binding(
+        runtime,
+        label=f"{label}.runtime_identity",
+    ) != _cross_process_runtime_binding(
+        expected_runtime,
+        label="acceptance runtime identity",
+    ):
+        raise AcceptanceError(f"{label} did not use the preflight candidate runtime")
+    active = _mapping(
+        runtime.get("active_build_info"),
+        label=f"{label}.runtime_identity.active_build_info",
+    )
+    build_info = _mapping(
+        active.get("payload"),
+        label=f"{label}.runtime_identity.active_build_info.payload",
+    )
+    if build_info.get("source_revision") != expected_revision or active.get(
+        "canonical_sha256"
+    ) != _canonical_sha256(build_info):
+        raise AcceptanceError(f"{label} runtime build provenance is invalid")
+    script = _mapping(
+        payload.get("gate_script_identity"),
+        label=f"{label}.gate_script_identity",
+    )
+    script_postflight = _mapping(
+        payload.get("gate_script_identity_postflight"),
+        label=f"{label}.gate_script_identity_postflight",
+    )
+    _require_true(
+        payload.get("gate_script_identity_match"),
+        label=f"{label}.gate script match",
+    )
+    if dict(script) != dict(script_postflight):
+        raise AcceptanceError(f"{label} gate script identity changed")
+    _require_sha256(script.get("sha256"), label=f"{label}.gate script SHA-256")
+
+
+def _require_comparison(value: object, *, label: str) -> None:
+    comparison = _mapping(value, label=label)
+    _require_true(comparison.get("passes"), label=f"{label}.passes")
+    if (
+        "failing_value_count" in comparison
+        and comparison.get("failing_value_count") != 0
+    ):
+        raise AcceptanceError(f"{label} has failing numerical values")
+    counts = [
+        comparison.get(name)
+        for name in ("value_count", "component_count")
+        if name in comparison
+    ]
+    if counts and not any(
+        isinstance(count, int) and not isinstance(count, bool) and count > 0
+        for count in counts
+    ):
+        raise AcceptanceError(f"{label} comparison is empty")
+
+
+def _require_comparison_mapping(
+    value: object,
+    *,
+    label: str,
+    expected_names: set[str],
+) -> None:
+    comparisons = _mapping(value, label=label)
+    if set(comparisons) != expected_names:
+        raise AcceptanceError(f"{label} has incomplete comparison coverage")
+    for name, comparison in comparisons.items():
+        _require_comparison(comparison, label=f"{label}.{name}")
+
+
+def _validate_all_jit(
+    payload: Mapping[str, object],
+    *,
+    expected_revision: str,
+    expected_workspace: Path,
+    point_count: int,
+    expected_runtime: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    label = "all-JIT evidence"
+    _require_content_identity(payload, label=label)
+    if (
+        payload.get("kind") != ALL_JIT_KIND
+        or payload.get("schema_version") != SCHEMA_VERSION
+        or payload.get("status") != "ok"
+    ):
+        raise AcceptanceError(f"{label} has the wrong kind, schema, or status")
+    _require_true(payload.get("passes"), label=f"{label}.passes")
+    if payload.get("failures") != []:
+        raise AcceptanceError(f"{label} contains failures")
+    _require_gate_provenance(
+        payload,
+        label=label,
+        expected_revision=expected_revision,
+        expected_workspace=expected_workspace,
+        expected_runtime=expected_runtime,
+    )
+    request = _mapping(payload.get("request"), label=f"{label}.request")
+    if (
+        request.get("process") != "g g > g g"
+        or request.get("jit_optimization_levels") != [0, 1, 2, 3]
+        or request.get("point_count") != point_count
+        or request.get("point_seeds") != list(_ALL_JIT_POINT_SEEDS[:point_count])
+        or request.get("relative_tolerance") != 1.0e-12
+        or request.get("absolute_tolerance") != 1.0e-15
+        or request.get("memory_limit_gib") != EXPECTED_MEMORY_LIMIT_GIB
+    ):
+        raise AcceptanceError(f"{label} request is not the required request")
+    momenta = _mapping(
+        request.get("momenta_identity"),
+        label=f"{label}.request.momenta_identity",
+    )
+    if (
+        momenta.get("algorithm") != "sha256-float-hex-momenta-v1"
+        or momenta.get("point_count") != point_count
+        or momenta.get("external_particle_count") != 4
+    ):
+        raise AcceptanceError(f"{label} momenta identity is invalid")
+    _require_sha256(momenta.get("sha256"), label=f"{label}.momenta SHA-256")
+    _require_nonempty_string(
+        request.get("mandatory_watchdog_command"),
+        label=f"{label}.mandatory_watchdog_command",
+    )
+    levels = _mapping(payload.get("levels"), label=f"{label}.levels")
+    if set(levels) != set(_ALL_JIT_LEVELS):
+        raise AcceptanceError(f"{label} does not cover JIT O0 through O3")
+    for name, optimization_level in _ALL_JIT_LEVELS.items():
+        lane = _mapping(levels[name], label=f"{label}.levels.{name}")
+        _require_true(lane.get("passes"), label=f"{label}.levels.{name}.passes")
+        expected_configuration = {
+            "process": "g g > g g",
+            "color_accuracy": "lc",
+            "lc_flow_layout": "topology-replay",
+            "backend": "jit",
+            "execution_mode": "compiled",
+            "jit_optimization_level": optimization_level,
+        }
+        if lane.get("configuration") != expected_configuration:
+            raise AcceptanceError(f"{label}.{name} configuration drifted")
+        generation = _mapping(
+            lane.get("generation"),
+            label=f"{label}.{name}.generation",
+        )
+        worker = _mapping(
+            generation.get("worker_provenance"),
+            label=f"{label}.{name}.generation.worker_provenance",
+        )
+        if (
+            worker.get("source_revision") != expected_revision
+            or worker.get("postflight_identity_match") is not True
+        ):
+            raise AcceptanceError(f"{label}.{name} worker provenance drifted")
+        artifact = _mapping(
+            lane.get("artifact_identity"),
+            label=f"{label}.{name}.artifact_identity",
+        )
+        _require_positive_int(
+            artifact.get("payload_count"),
+            label=f"{label}.{name}.artifact payload count",
+        )
+        arena_audit = _mapping(
+            artifact.get("direct_arena_audit"),
+            label=f"{label}.{name}.artifact direct Arena audit",
+        )
+        _require_true(
+            arena_audit.get("passes"),
+            label=f"{label}.{name}.artifact direct Arena audit passes",
+        )
+        numerical = _mapping(
+            lane.get("numerical_validation"),
+            label=f"{label}.{name}.numerical_validation",
+        )
+        _require_true(
+            numerical.get("passes"),
+            label=f"{label}.{name}.numerical_validation.passes",
+        )
+        if (
+            numerical.get("execution_mode") != "compiled"
+            or numerical.get("point_count") != point_count
+            or numerical.get("point_seeds") != list(_ALL_JIT_POINT_SEEDS[:point_count])
+        ):
+            raise AcceptanceError(f"{label}.{name} numerical request drifted")
+        _require_comparison_mapping(
+            numerical.get("comparisons"),
+            label=f"{label}.{name}.comparisons",
+            expected_names=_ALL_JIT_COMPARISONS,
+        )
+        native_profile = _mapping(
+            numerical.get("native_profile"),
+            label=f"{label}.{name}.native_profile",
+        )
+        _require_true(
+            native_profile.get("passes"),
+            label=f"{label}.{name}.native_profile.passes",
+        )
+        if native_profile.get("execution_mode") != "compiled":
+            raise AcceptanceError(f"{label}.{name} did not profile compiled execution")
+        engine = _mapping(
+            native_profile.get("direct_arena_engine_counter"),
+            label=f"{label}.{name}.direct_arena_engine_counter",
+        )
+        calls = _mapping(
+            native_profile.get("direct_arena_call_counter"),
+            label=f"{label}.{name}.direct_arena_call_counter",
+        )
+        _require_positive_int(engine.get("value"), label=f"{label}.{name}.engines")
+        _require_positive_int(calls.get("value"), label=f"{label}.{name}.calls")
+    cross = _mapping(
+        payload.get("cross_level_numerical_parity"),
+        label=f"{label}.cross_level_numerical_parity",
+    )
+    _require_true(cross.get("passes"), label=f"{label}.cross-level passes")
+    if cross.get("baseline_optimization_level") != 3:
+        raise AcceptanceError(f"{label} cross-level baseline is not O3")
+    cross_comparisons = _mapping(
+        cross.get("comparisons"),
+        label=f"{label}.cross-level comparisons",
+    )
+    if set(cross_comparisons) != {"o0_vs_o3", "o1_vs_o3", "o2_vs_o3"}:
+        raise AcceptanceError(f"{label} cross-level coverage is incomplete")
+    for name, comparisons in cross_comparisons.items():
+        _require_comparison_mapping(
+            comparisons,
+            label=f"{label}.cross-level comparisons.{name}",
+            expected_names=_CROSS_LEVEL_COMPARISONS,
+        )
+    return {
+        "kind": ALL_JIT_KIND,
+        "schema_version": SCHEMA_VERSION,
+        "point_count": point_count,
+        "levels": sorted(levels),
+        "numerical_validation": True,
+        "passes": True,
+    }
+
+
+def _validate_four_quark(
+    payload: Mapping[str, object],
+    *,
+    expected_revision: str,
+    expected_workspace: Path,
+    point_count: int,
+    expected_runtime: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    label = "four-quark evidence"
+    _require_content_identity(payload, label=label)
+    if (
+        payload.get("kind") != FOUR_QUARK_KIND
+        or payload.get("schema_version") != SCHEMA_VERSION
+        or payload.get("status") != "ok"
+    ):
+        raise AcceptanceError(f"{label} has the wrong kind, schema, or status")
+    _require_true(payload.get("passes"), label=f"{label}.passes")
+    if payload.get("failures") != []:
+        raise AcceptanceError(f"{label} contains failures")
+    _require_gate_provenance(
+        payload,
+        label=label,
+        expected_revision=expected_revision,
+        expected_workspace=expected_workspace,
+        expected_runtime=expected_runtime,
+    )
+    request = _mapping(payload.get("request"), label=f"{label}.request")
+    if (
+        request.get("process") != "d d~ > u u~ s s~ c c~"
+        or request.get("independent_quark_line_count") != 4
+        or request.get("expected_external_pdgs") != [-4, -3, -2, -1, 1, 2, 3, 4]
+        or request.get("max_quark_lines") != 4
+        or request.get("point_count") != point_count
+        or request.get("point_seeds") != list(_FOUR_QUARK_POINT_SEEDS[:point_count])
+        or request.get("relative_tolerance") != 1.0e-12
+        or request.get("absolute_tolerance") != 1.0e-300
+        or request.get("memory_limit_gib") != EXPECTED_MEMORY_LIMIT_GIB
+    ):
+        raise AcceptanceError(f"{label} request is not the required request")
+    momenta = _mapping(
+        request.get("momenta_identity"),
+        label=f"{label}.request.momenta_identity",
+    )
+    if (
+        momenta.get("algorithm") != "sha256-float-hex-momenta-v1"
+        or momenta.get("point_count") != point_count
+        or momenta.get("external_particle_count") != 8
+    ):
+        raise AcceptanceError(f"{label} momenta identity is invalid")
+    _require_sha256(momenta.get("sha256"), label=f"{label}.momenta SHA-256")
+    _require_nonempty_string(
+        request.get("mandatory_watchdog_command"),
+        label=f"{label}.mandatory_watchdog_command",
+    )
+    rejections = _list(
+        payload.get("invalid_union_configurations"),
+        label=f"{label}.invalid_union_configurations",
+    )
+    rejected_colors: set[str] = set()
+    for index, raw in enumerate(rejections):
+        rejection = _mapping(
+            raw,
+            label=f"{label}.invalid_union_configurations[{index}]",
+        )
+        color = rejection.get("color_accuracy")
+        if (
+            color not in {"nlc", "full"}
+            or rejection.get("lc_flow_layout") != "all-flow-union"
+            or rejection.get("rejected") is not True
+            or not isinstance(rejection.get("message"), str)
+            or "all-flow-union" not in str(rejection.get("message"))
+        ):
+            raise AcceptanceError(f"{label} invalid-union rejection is incomplete")
+        rejected_colors.add(str(color))
+    if rejected_colors != {"nlc", "full"} or len(rejections) != 2:
+        raise AcceptanceError(f"{label} did not reject both invalid union requests")
+    lanes = _mapping(payload.get("lanes"), label=f"{label}.lanes")
+    if set(lanes) != set(_FOUR_QUARK_LANES):
+        raise AcceptanceError(f"{label} lane coverage is incomplete")
+    for name, (color, layout, contracted) in _FOUR_QUARK_LANES.items():
+        lane = _mapping(lanes[name], label=f"{label}.lanes.{name}")
+        _require_true(lane.get("passes"), label=f"{label}.{name}.passes")
+        expected_configuration = {
+            "process": "d d~ > u u~ s s~ c c~",
+            "max_quark_lines": 4,
+            "color_accuracy": color,
+            "lc_flow_layout": layout,
+            "contracted_color": contracted,
+            "backend": "jit",
+            "execution_mode": "compiled",
+            "jit_optimization_level": 3,
+        }
+        if lane.get("configuration") != expected_configuration:
+            raise AcceptanceError(f"{label}.{name} configuration drifted")
+        generation = _mapping(
+            lane.get("generation"),
+            label=f"{label}.{name}.generation",
+        )
+        worker = _mapping(
+            generation.get("worker_provenance"),
+            label=f"{label}.{name}.generation.worker_provenance",
+        )
+        if (
+            worker.get("source_revision") != expected_revision
+            or worker.get("postflight_identity_match") is not True
+        ):
+            raise AcceptanceError(f"{label}.{name} worker provenance drifted")
+        artifact = _mapping(
+            lane.get("artifact_identity"),
+            label=f"{label}.{name}.artifact_identity",
+        )
+        _require_positive_int(
+            artifact.get("payload_count"),
+            label=f"{label}.{name}.artifact payload count",
+        )
+        arena_audit = _mapping(
+            artifact.get("direct_arena_audit"),
+            label=f"{label}.{name}.artifact direct Arena audit",
+        )
+        _require_true(
+            arena_audit.get("passes"),
+            label=f"{label}.{name}.artifact direct Arena audit passes",
+        )
+        numerical = _mapping(
+            lane.get("numerical_validation"),
+            label=f"{label}.{name}.numerical_validation",
+        )
+        _require_true(
+            numerical.get("passes"),
+            label=f"{label}.{name}.numerical_validation.passes",
+        )
+        if numerical.get("point_count") != point_count or numerical.get(
+            "point_seeds"
+        ) != list(_FOUR_QUARK_POINT_SEEDS[:point_count]):
+            raise AcceptanceError(f"{label}.{name} numerical request drifted")
+        expected_comparisons = set(_FOUR_QUARK_BASE_COMPARISONS)
+        if not contracted:
+            expected_comparisons.add("color_selector_evaluate_vs_resolved_total")
+        _require_comparison_mapping(
+            numerical.get("comparisons"),
+            label=f"{label}.{name}.comparisons",
+            expected_names=expected_comparisons,
+        )
+        execution = _mapping(
+            numerical.get("runtime_execution"),
+            label=f"{label}.{name}.runtime_execution",
+        )
+        if execution.get("execution_mode") != "compiled":
+            raise AcceptanceError(f"{label}.{name} did not execute compiled mode")
+        profiles = _mapping(
+            execution.get("direct_arena_profiles"),
+            label=f"{label}.{name}.direct_arena_profiles",
+        )
+        expected_profiles = {"complete", "helicity_selector"}
+        if not contracted:
+            expected_profiles.update({"color_selector", "combined_selector"})
+        if set(profiles) != expected_profiles:
+            raise AcceptanceError(f"{label}.{name} profile coverage is incomplete")
+        for profile_name, raw_profile in profiles.items():
+            profile = _mapping(
+                raw_profile,
+                label=f"{label}.{name}.profiles.{profile_name}",
+            )
+            _require_true(
+                profile.get("passes"),
+                label=f"{label}.{name}.profiles.{profile_name}.passes",
+            )
+            _require_positive_int(
+                profile.get("compiled_direct_arena_engine_count"),
+                label=f"{label}.{name}.{profile_name}.engines",
+            )
+            _require_positive_int(
+                profile.get("compiled_direct_arena_call_count"),
+                label=f"{label}.{name}.{profile_name}.calls",
+            )
+            if profile.get("legacy_boundary_component_total") != 0:
+                raise AcceptanceError(
+                    f"{label}.{name}.{profile_name} used a legacy boundary"
+                )
+    cross = _mapping(
+        payload.get("lc_cross_layout_parity"),
+        label=f"{label}.lc_cross_layout_parity",
+    )
+    _require_true(cross.get("passes"), label=f"{label}.LC cross-layout passes")
+    _require_true(
+        cross.get("physical_axes_match"),
+        label=f"{label}.LC physical axes match",
+    )
+    _require_comparison_mapping(
+        cross.get("comparisons"),
+        label=f"{label}.LC cross-layout comparisons",
+        expected_names=_CROSS_LC_COMPARISONS,
+    )
+    return {
+        "kind": FOUR_QUARK_KIND,
+        "schema_version": SCHEMA_VERSION,
+        "point_count": point_count,
+        "independent_quark_line_count": 4,
+        "lanes": sorted(lanes),
+        "invalid_union_requests_rejected": sorted(rejected_colors),
+        "numerical_validation": True,
+        "passes": True,
+    }
+
+
+def _require_pointwise_items(value: object, *, label: str) -> None:
+    items = _list(value, label=label)
+    if not items:
+        raise AcceptanceError(f"{label} must not be empty")
+    for index, item in enumerate(items):
+        comparison = _mapping(item, label=f"{label}[{index}]")
+        _require_true(comparison.get("passes"), label=f"{label}[{index}].passes")
+
+
+def _validate_correctness(
+    value: object,
+    *,
+    label: str,
+    require_specialized: bool,
+) -> None:
+    correctness = _mapping(value, label=label)
+    expected_fields = set(_CORRECTNESS_FIELDS)
+    if require_specialized:
+        expected_fields.add("specialized_compiled")
+    if set(correctness) != expected_fields:
+        raise AcceptanceError(f"{label} has incomplete numerical fields")
+    _require_true(correctness.get("passes"), label=f"{label}.passes")
+    for name in ("total", "eager_resolved_sum", "compiled_resolved_sum"):
+        _require_pointwise_items(correctness.get(name), label=f"{label}.{name}")
+    for name in ("resolved_f64", "resolved_precision32"):
+        resolved = _mapping(correctness.get(name), label=f"{label}.{name}")
+        _require_true(resolved.get("passes"), label=f"{label}.{name}.passes")
+        _require_positive_int(
+            resolved.get("point_count"),
+            label=f"{label}.{name}.point_count",
+        )
+        _require_positive_int(
+            resolved.get("component_count"),
+            label=f"{label}.{name}.component_count",
+        )
+        for match_field in (
+            "helicity_ids_match",
+            "color_ids_match",
+            "shape_matches",
+        ):
+            _require_true(
+                resolved.get(match_field),
+                label=f"{label}.{name}.{match_field}",
+            )
+    if require_specialized:
+        _validate_correctness(
+            correctness.get("specialized_compiled"),
+            label=f"{label}.specialized_compiled",
+            require_specialized=False,
+        )
+
+
+def _validate_color_matrix(
+    payload: Mapping[str, object],
+    *,
+    expected_revision: str,
+    expected_runtime: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    label = "eager/compiled color matrix"
+    if (
+        payload.get("kind") != COLOR_MATRIX_KIND
+        or payload.get("schema_version") != COLOR_MATRIX_SCHEMA_VERSION
+        or payload.get("suite") != "smoke"
+    ):
+        raise AcceptanceError(f"{label} has the wrong kind, schema, or suite")
+    _require_true(payload.get("complete"), label=f"{label}.complete")
+    _require_true(payload.get("passes"), label=f"{label}.passes")
+    if payload.get("source_revision") != expected_revision:
+        raise AcceptanceError(f"{label} came from another source revision")
+    if expected_runtime is not None:
+        interpreter = _mapping(
+            expected_runtime.get("interpreter"),
+            label="acceptance runtime identity.interpreter",
+        )
+        observed_platform = payload.get("platform")
+        if (
+            payload.get("python") != interpreter.get("python_version")
+            or not isinstance(observed_platform, str)
+            or "Linux" not in observed_platform
+            or "x86_64" not in observed_platform
+        ):
+            raise AcceptanceError(f"{label} did not run on the candidate x86 host")
+    configuration = _mapping(
+        payload.get("configuration"),
+        label=f"{label}.configuration",
+    )
+    expected_configuration = {
+        "batch_sizes": [128, 1024],
+        "colors": ["lc", "nlc", "full"],
+        "generation_timeout": 300.0,
+        "memory_limit_gib": 30.0,
+        "minimum_samples": 5,
+        "target_runtime": 5.0,
+        "selector_target_runtime": 1.0,
+        "selector_seed": 0xC0FFEE,
+    }
+    if dict(configuration) != expected_configuration:
+        raise AcceptanceError(f"{label} request configuration drifted")
+    gates = _mapping(payload.get("gates"), label=f"{label}.gates")
+    if set(gates) != _COLOR_MATRIX_GATES:
+        raise AcceptanceError(f"{label} hard-gate coverage is incomplete")
+    for name, value in gates.items():
+        _require_true(value, label=f"{label}.gates.{name}")
+    records = _list(payload.get("records"), label=f"{label}.records")
+    expected_cells = {
+        (case, "built-in", color) for case in _SMOKE_CASES for color in _COLORS
+    }
+    observed_cells: set[tuple[str, str, str]] = set()
+    workload_count = 0
+    for index, raw_record in enumerate(records):
+        record_label = f"{label}.records[{index}]"
+        record = _mapping(raw_record, label=record_label)
+        case = _mapping(record.get("case"), label=f"{record_label}.case")
+        case_key = case.get("key")
+        model = record.get("model")
+        color = record.get("color")
+        if not all(isinstance(value, str) for value in (case_key, model, color)):
+            raise AcceptanceError(f"{record_label} cell identity is invalid")
+        cell = (str(case_key), str(model), str(color))
+        if cell not in expected_cells or cell in observed_cells:
+            raise AcceptanceError(f"{record_label} is unexpected or duplicated")
+        observed_cells.add(cell)
+        expected_process, expected_n_final = _SMOKE_CASES[str(case_key)]
+        if (
+            case.get("process") != expected_process
+            or case.get("n_final") != expected_n_final
+            or case.get("smoke") is not True
+        ):
+            raise AcceptanceError(f"{record_label} process metadata drifted")
+        _require_nonempty_string(
+            record.get("process_id"),
+            label=f"{record_label}.process_id",
+        )
+        _require_true(
+            record.get("compiled_generation_under_hard_limit"),
+            label=f"{record_label}.compiled_generation_under_hard_limit",
+        )
+        generation = _mapping(
+            record.get("generation"),
+            label=f"{record_label}.generation",
+        )
+        if set(generation) != {"compiled", "eager"}:
+            raise AcceptanceError(f"{record_label} generation coverage is incomplete")
+        for mode, raw_generation in generation.items():
+            mode_generation = _mapping(
+                raw_generation,
+                label=f"{record_label}.generation.{mode}",
+            )
+            core_seconds = mode_generation.get("core_phase_seconds")
+            if (
+                isinstance(core_seconds, bool)
+                or not isinstance(core_seconds, (int, float))
+                or float(core_seconds) <= 0
+            ):
+                raise AcceptanceError(
+                    f"{record_label}.generation.{mode} has no core timing"
+                )
+        workloads = _list(
+            record.get("workloads"),
+            label=f"{record_label}.workloads",
+        )
+        expected_workloads = (
+            {"single-flow-helicity-sum", "all-flow-single-helicity"}
+            if color == "lc"
+            else {"summed"}
+        )
+        if {workload.get("name") for workload in workloads} != expected_workloads:
+            raise AcceptanceError(f"{record_label} workload scope is incomplete")
+        if len(workloads) != len(expected_workloads):
+            raise AcceptanceError(f"{record_label} contains duplicate workloads")
+        for workload_index, raw_workload in enumerate(workloads):
+            workload_count += 1
+            workload_label = f"{record_label}.workloads[{workload_index}]"
+            workload = _mapping(raw_workload, label=workload_label)
+            _validate_correctness(
+                workload.get("correctness"),
+                label=f"{workload_label}.correctness",
+                require_specialized=color == "lc",
+            )
+            profiles = _list(
+                workload.get("profiles"),
+                label=f"{workload_label}.profiles",
+            )
+            if {profile.get("batch_size") for profile in profiles} != {128, 1024}:
+                raise AcceptanceError(f"{workload_label} batch coverage is incomplete")
+            if len(profiles) != 2:
+                raise AcceptanceError(f"{workload_label} contains duplicate batches")
+            expected_profile_modes = {"compiled_complete", "eager_complete"}
+            if color == "lc":
+                expected_profile_modes.add("compiled_specialized")
+            for profile_index, raw_profile in enumerate(profiles):
+                profile_label = f"{workload_label}.profiles[{profile_index}]"
+                profile = _mapping(raw_profile, label=profile_label)
+                batch_size = profile.get("batch_size")
+                for mode in expected_profile_modes:
+                    timing = _mapping(
+                        profile.get(mode),
+                        label=f"{profile_label}.{mode}",
+                    )
+                    result = _mapping(
+                        timing.get("result"),
+                        label=f"{profile_label}.{mode}.result",
+                    )
+                    sample_count = _require_positive_int(
+                        result.get("sample_count"),
+                        label=f"{profile_label}.{mode}.result.sample_count",
+                    )
+                    wall = result.get("wall_time_per_point")
+                    if (
+                        sample_count < 1
+                        or isinstance(wall, bool)
+                        or not isinstance(wall, (int, float))
+                        or not math.isfinite(float(wall))
+                        or float(wall) < 0
+                        or result.get("interrupted") is not False
+                    ):
+                        raise AcceptanceError(
+                            f"{profile_label}.{mode} runtime profile is invalid"
+                        )
+                    effective = _mapping(
+                        result.get("effective_config"),
+                        label=f"{profile_label}.{mode}.result.effective_config",
+                    )
+                    if effective.get("batch_size") != batch_size:
+                        raise AcceptanceError(
+                            f"{profile_label}.{mode} profiled another batch size"
+                        )
+        selector_profiles = record.get("selector_pattern_profiles")
+        if color == "lc":
+            selectors = _mapping(
+                selector_profiles,
+                label=f"{record_label}.selector_pattern_profiles",
+            )
+            if set(selectors) != {"compiled", "eager"}:
+                raise AcceptanceError(
+                    f"{record_label} selector-profile coverage is incomplete"
+                )
+            for mode, raw_profile in selectors.items():
+                profile = _mapping(
+                    raw_profile,
+                    label=f"{record_label}.selector_pattern_profiles.{mode}",
+                )
+                result = _mapping(
+                    profile.get("result"),
+                    label=f"{record_label}.selector_pattern_profiles.{mode}.result",
+                )
+                _require_true(
+                    result.get("passes"),
+                    label=(
+                        f"{record_label}.selector_pattern_profiles.{mode}.result.passes"
+                    ),
+                )
+        elif selector_profiles is not None:
+            raise AcceptanceError(
+                f"{record_label} contracted color has unexpected selector profiles"
+            )
+    if observed_cells != expected_cells or len(records) != len(expected_cells):
+        raise AcceptanceError(f"{label} matrix cell scope is incomplete")
+    return {
+        "kind": COLOR_MATRIX_KIND,
+        "schema_version": COLOR_MATRIX_SCHEMA_VERSION,
+        "suite": "smoke",
+        "cells": [
+            {"case": case, "model": model, "color": color}
+            for case, model, color in sorted(observed_cells)
+        ],
+        "cell_count": len(observed_cells),
+        "workload_count": workload_count,
+        "hard_gates": sorted(gates),
+        "numerical_validation": True,
+        "passes": True,
+    }
+
+
+def _validate_preflight(
+    payload: Mapping[str, object],
+    *,
+    expected_revision: str,
+    expected_workspace: Path,
+) -> tuple[Mapping[str, object], Mapping[str, object]]:
+    label = "runtime preflight"
+    _require_content_identity(payload, label=label)
+    if (
+        payload.get("kind") != PREFLIGHT_KIND
+        or payload.get("schema_version") != SCHEMA_VERSION
+        or payload.get("status") != "ok"
+    ):
+        raise AcceptanceError(f"{label} has the wrong kind, schema, or status")
+    _require_true(payload.get("passes"), label=f"{label}.passes")
+    if payload.get("failures") != []:
+        raise AcceptanceError(f"{label} contains failures")
+    request = _mapping(payload.get("request"), label=f"{label}.request")
+    expected_request = {
+        "expected_revision": expected_revision,
+        "expected_workspace": str(expected_workspace.resolve(strict=True)),
+        "expected_target": EXPECTED_TARGET,
+    }
+    if dict(request) != expected_request:
+        raise AcceptanceError(f"{label} request drifted")
+    source = _mapping(payload.get("source_identity"), label=f"{label}.source_identity")
+    source_postflight = _mapping(
+        payload.get("source_identity_postflight"),
+        label=f"{label}.source_identity_postflight",
+    )
+    _require_true(payload.get("source_identity_match"), label=f"{label}.source match")
+    if dict(source) != dict(source_postflight):
+        raise AcceptanceError(f"{label} source identity changed")
+    if (
+        source.get("revision") != expected_revision
+        or source.get("checkout") != str(expected_workspace.resolve(strict=True))
+        or source.get("dirty") is not False
+        or source.get("untracked_files_checked") is not True
+    ):
+        raise AcceptanceError(f"{label} source identity is not exact")
+    runtime = _mapping(
+        payload.get("runtime_identity"),
+        label=f"{label}.runtime_identity",
+    )
+    runtime_postflight = _mapping(
+        payload.get("runtime_identity_postflight"),
+        label=f"{label}.runtime_identity_postflight",
+    )
+    _require_true(payload.get("runtime_identity_match"), label=f"{label}.runtime match")
+    if _stable_runtime_identity(runtime) != _stable_runtime_identity(
+        runtime_postflight
+    ):
+        raise AcceptanceError(f"{label} runtime identity changed")
+    if payload.get("stable_runtime_identity_sha256") != _runtime_identity_sha256(
+        runtime
+    ):
+        raise AcceptanceError(f"{label} stable runtime identity digest is invalid")
+    platform_identity = _mapping(
+        runtime.get("platform"),
+        label=f"{label}.runtime_identity.platform",
+    )
+    if platform_identity.get("target") != EXPECTED_TARGET:
+        raise AcceptanceError(f"{label} has the wrong native target")
+    return source, runtime
+
+
+def _preflight(
+    *,
+    evidence_root: Path,
+    expected_revision: str,
+    expected_workspace: Path,
+) -> dict[str, object]:
+    root = _evidence_root(evidence_root)
+    destination = root / PREFLIGHT_FILENAME
+    _remove_stale_file(destination)
+    _remove_stale_file(root / ACCEPTANCE_FILENAME)
+    source = _source_identity(
+        expected_revision=expected_revision,
+        expected_workspace=expected_workspace,
+    )
+    runtime = _runtime_identity(source)
+    source_postflight = _source_identity(
+        expected_revision=expected_revision,
+        expected_workspace=expected_workspace,
+    )
+    runtime_postflight = _runtime_identity(source_postflight)
+    if source_postflight != source:
+        raise AcceptanceError("source identity changed during native-x86 preflight")
+    if _stable_runtime_identity(runtime_postflight) != _stable_runtime_identity(
+        runtime
+    ):
+        raise AcceptanceError("runtime identity changed during native-x86 preflight")
+    payload = _attach_content_identity(
+        {
+            "kind": PREFLIGHT_KIND,
+            "schema_version": SCHEMA_VERSION,
+            "status": "ok",
+            "passes": True,
+            "request": {
+                "expected_revision": expected_revision,
+                "expected_workspace": str(expected_workspace.resolve(strict=True)),
+                "expected_target": EXPECTED_TARGET,
+            },
+            "source_identity": source,
+            "source_identity_postflight": source_postflight,
+            "source_identity_match": True,
+            "runtime_identity": runtime,
+            "runtime_identity_postflight": runtime_postflight,
+            "runtime_identity_match": True,
+            "stable_runtime_identity_sha256": _runtime_identity_sha256(runtime),
+            "failures": [],
+        }
+    )
+    _write_json_atomic(destination, payload)
+    return payload
+
+
+def _audit(
+    *,
+    evidence_root: Path,
+    expected_revision: str,
+    expected_workspace: Path,
+    point_count: int,
+) -> dict[str, object]:
+    root = _evidence_root(evidence_root)
+    destination = root / ACCEPTANCE_FILENAME
+    _remove_stale_file(destination)
+    source = _source_identity(
+        expected_revision=expected_revision,
+        expected_workspace=expected_workspace,
+    )
+    runtime = _runtime_identity(source)
+
+    preflight, preflight_file = _checked_json(
+        root / PREFLIGHT_FILENAME,
+        label="runtime preflight evidence",
+    )
+    preflight_source, preflight_runtime = _validate_preflight(
+        preflight,
+        expected_revision=expected_revision,
+        expected_workspace=expected_workspace,
+    )
+    if dict(preflight_source) != source:
+        raise AcceptanceError("source identity differs from the preflight")
+    if _stable_runtime_identity(preflight_runtime) != _stable_runtime_identity(runtime):
+        raise AcceptanceError("runtime identity differs from the preflight")
+
+    all_jit, all_jit_file = _checked_json(
+        root / ALL_JIT_RELATIVE_PATH,
+        label="all-JIT evidence",
+    )
+    all_jit_summary = _validate_all_jit(
+        all_jit,
+        expected_revision=expected_revision,
+        expected_workspace=expected_workspace,
+        point_count=point_count,
+        expected_runtime=runtime,
+    )
+    four_quark, four_quark_file = _checked_json(
+        root / FOUR_QUARK_RELATIVE_PATH,
+        label="four-quark evidence",
+    )
+    four_quark_summary = _validate_four_quark(
+        four_quark,
+        expected_revision=expected_revision,
+        expected_workspace=expected_workspace,
+        point_count=point_count,
+        expected_runtime=runtime,
+    )
+    color_matrix, color_matrix_file = _checked_json(
+        root / COLOR_MATRIX_RELATIVE_PATH,
+        label="eager/compiled color matrix evidence",
+    )
+    color_matrix_summary = _validate_color_matrix(
+        color_matrix,
+        expected_revision=expected_revision,
+        expected_runtime=runtime,
+    )
+
+    source_postflight = _source_identity(
+        expected_revision=expected_revision,
+        expected_workspace=expected_workspace,
+    )
+    runtime_postflight = _runtime_identity(source_postflight)
+    if source_postflight != source:
+        raise AcceptanceError("source identity changed during final evidence audit")
+    if _stable_runtime_identity(runtime_postflight) != _stable_runtime_identity(
+        runtime
+    ):
+        raise AcceptanceError("runtime identity changed during final evidence audit")
+    payload = _attach_content_identity(
+        {
+            "kind": ACCEPTANCE_KIND,
+            "schema_version": SCHEMA_VERSION,
+            "status": "ok",
+            "passes": True,
+            "request": {
+                "expected_revision": expected_revision,
+                "expected_workspace": str(expected_workspace.resolve(strict=True)),
+                "expected_target": EXPECTED_TARGET,
+                "point_count": point_count,
+                "required_evidence": {
+                    "runtime_preflight": PREFLIGHT_FILENAME,
+                    "compiled_all_jit": ALL_JIT_RELATIVE_PATH.as_posix(),
+                    "four_quark": FOUR_QUARK_RELATIVE_PATH.as_posix(),
+                    "eager_compiled_color": COLOR_MATRIX_RELATIVE_PATH.as_posix(),
+                },
+            },
+            "source_identity": {
+                "preflight": dict(preflight_source),
+                "audit": source,
+                "postflight": source_postflight,
+                "all_match": True,
+            },
+            "runtime_identity": {
+                "stable_sha256": _runtime_identity_sha256(runtime),
+                "preflight_stable_sha256": _runtime_identity_sha256(preflight_runtime),
+                "audit": runtime,
+                "postflight": runtime_postflight,
+                "all_match": True,
+            },
+            "evidence": {
+                "runtime_preflight": {
+                    "file_identity": preflight_file,
+                    "semantic_validation": {
+                        "kind": PREFLIGHT_KIND,
+                        "schema_version": SCHEMA_VERSION,
+                        "passes": True,
+                    },
+                },
+                "compiled_all_jit": {
+                    "file_identity": all_jit_file,
+                    "semantic_validation": all_jit_summary,
+                },
+                "four_quark": {
+                    "file_identity": four_quark_file,
+                    "semantic_validation": four_quark_summary,
+                },
+                "eager_compiled_color": {
+                    "file_identity": color_matrix_file,
+                    "semantic_validation": color_matrix_summary,
+                },
+            },
+            "validation": {
+                "exact_source_revision": True,
+                "source_clean_preflight_and_postflight": True,
+                "source_only_python_runtime": True,
+                "native_linux_x86_64_target": True,
+                "runtime_preimport_bytes_unchanged": True,
+                "candidate_wheel_matches_loaded_runtime": True,
+                "compiled_all_jit_numerical_gate": True,
+                "four_quark_all_valid_color_lanes_numerical_gate": True,
+                "eager_compiled_full_smoke_color_matrix_numerical_gate": True,
+                "all_evidence_files_content_bound": True,
+            },
+            "failures": [],
+        }
+    )
+    _write_json_atomic(destination, payload)
+    return payload
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    subparsers = result.add_subparsers(dest="command", required=True)
+    for command in ("preflight", "audit"):
+        child = subparsers.add_parser(command)
+        child.add_argument("--evidence-root", type=Path, required=True)
+        child.add_argument("--expected-revision", required=True)
+        child.add_argument("--expected-workspace", type=Path, required=True)
+        if command == "audit":
+            child.add_argument(
+                "--point-count",
+                type=int,
+                choices=(2, 3),
+                default=EXPECTED_POINT_COUNT,
+            )
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    _ensure_source_only_python()
+    _establish_preimport_runtime_identity()
+    arguments = parser().parse_args(argv)
+    try:
+        if arguments.command == "preflight":
+            payload = _preflight(
+                evidence_root=arguments.evidence_root,
+                expected_revision=arguments.expected_revision,
+                expected_workspace=arguments.expected_workspace,
+            )
+        else:
+            payload = _audit(
+                evidence_root=arguments.evidence_root,
+                expected_revision=arguments.expected_revision,
+                expected_workspace=arguments.expected_workspace,
+                point_count=arguments.point_count,
+            )
+    except (AcceptanceError, OSError, RuntimeError, ValueError) as error:
+        print(f"arena-native-x86-acceptance: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(payload, allow_nan=False, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/capture_reference_fixture_v2.py b/pyamplicol/tools/developer/capture_reference_fixture_v2.py
new file mode 100644
index 0000000000..dfc5df31a5
--- /dev/null
+++ b/pyamplicol/tools/developer/capture_reference_fixture_v2.py
@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Capture strict fixture-v2 data from retained schema-v3 artifacts.
+
+Run this developer-only command through a repository-external 30 GB memory
+watchdog. The command deliberately contains no process killer or memory monitor.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import os
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+capture = importlib.import_module("tools.developer.reference_capture")
+common = importlib.import_module("tools.developer.reference_capture.common")
+provenance = importlib.import_module("tools.developer.reference_capture.provenance")
+
+
+def _portable_path(path: Path) -> str:
+    resolved = path.expanduser().resolve(strict=False)
+    try:
+        return resolved.relative_to(ROOT).as_posix()
+    except ValueError:
+        return f"<external:{resolved.name}>"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Capture the strict compact reference fixture v2 from retained "
+            "schema-v3 artifacts and independent oracles."
+        ),
+        epilog=(
+            "This command has no internal memory killer. Invoke it through a "
+            "repository-external watchdog limited to 30 GB, then pass "
+            "--external-watchdog-gb 30 to record that requirement."
+        ),
+    )
+    mode = parser.add_mutually_exclusive_group(required=True)
+    mode.add_argument(
+        "--generate",
+        dest="artifact_mode",
+        action="store_const",
+        const="generate",
+        help="generate new retained artifacts; fail if any destination exists",
+    )
+    mode.add_argument(
+        "--reuse-artifacts",
+        "--reuse",
+        dest="artifact_mode",
+        action="store_const",
+        const="reuse",
+        help="explicitly reuse the complete retained schema-v3 artifact set",
+    )
+    parser.add_argument(
+        "--output-directory",
+        "--output-dir",
+        type=Path,
+        default=ROOT / "tests" / "fixtures" / "reference",
+        help=(
+            "directory for the fixture, two evidence documents, and final "
+            "bundle manifest (default: %(default)s)"
+        ),
+    )
+    parser.add_argument(
+        "--artifact-root",
+        type=Path,
+        default=None,
+        help=(
+            "retained artifact directory; default is revision-scoped under "
+            ".artifacts/reference-fixture-v2"
+        ),
+    )
+    parser.add_argument(
+        "--legacy-repository",
+        type=Path,
+        default=common.DEPENDENCIES / "checkouts" / "legacy-amplicol",
+        help="pinned legacy AmpliCol checkout (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--legacy-jobs",
+        type=int,
+        default=max(1, os.cpu_count() or 1),
+        help="parallel build jobs for the legacy Fortran oracle (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--external-watchdog-gb",
+        type=int,
+        required=True,
+        help="confirm the repository-external watchdog limit; must be exactly 30",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = tuple(sys.argv[1:] if argv is None else argv)
+    parser = build_parser()
+    options = parser.parse_args(arguments)
+    try:
+        revision = provenance.require_clean_tracked_tree(ROOT)
+        artifact_root = (
+            provenance.default_artifact_root(revision)
+            if options.artifact_root is None
+            else options.artifact_root.expanduser().resolve(strict=False)
+        )
+        config = capture.CaptureConfig(
+            output_directory=options.output_directory.expanduser().resolve(
+                strict=False
+            ),
+            artifact_root=artifact_root,
+            legacy_repository=options.legacy_repository.expanduser().resolve(
+                strict=False
+            ),
+            legacy_jobs=options.legacy_jobs,
+            artifact_mode=options.artifact_mode,
+            capture_command=(
+                "python",
+                "tools/developer/capture_reference_fixture_v2.py",
+                (
+                    "--generate"
+                    if options.artifact_mode == "generate"
+                    else "--reuse-artifacts"
+                ),
+                "--output-directory",
+                _portable_path(options.output_directory),
+                "--artifact-root",
+                _portable_path(artifact_root),
+                "--legacy-repository",
+                _portable_path(options.legacy_repository),
+                "--legacy-jobs",
+                str(options.legacy_jobs),
+                "--external-watchdog-gb",
+                str(options.external_watchdog_gb),
+            ),
+            external_watchdog_gb=options.external_watchdog_gb,
+        )
+        result = capture.run_capture(config)
+    except (capture.CaptureError, OSError, ValueError) as error:
+        parser.exit(2, f"capture_reference_fixture_v2.py: error: {error}\n")
+    print(f"wrote {result.fixture_path}")
+    for path in result.evidence_paths:
+        print(f"wrote {path}")
+    print(f"wrote {result.bundle_manifest_path}")
+    for path in result.artifact_paths:
+        print(f"retained artifact {path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/catalog_final_source_structural_preflight.py b/pyamplicol/tools/developer/catalog_final_source_structural_preflight.py
new file mode 100644
index 0000000000..826e727396
--- /dev/null
+++ b/pyamplicol/tools/developer/catalog_final_source_structural_preflight.py
@@ -0,0 +1,477 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Assemble and authenticate the all-catalog final-source restart manifest.
+
+This producer is intentionally structural-only: it never benchmarks or derives
+proof claims from timings.  Each successful candidate artifact must contain a
+``structural-preflight-proof.json`` emitted by generation, and each comparable
+legacy artifact must contain ``legacy-structural-proof.json`` emitted by the
+legacy probe.  The producer authenticates those sidecars against their source
+revision and every persisted object before assembling the exact 1,356 rows
+consumed by :mod:`tools.developer.catalog_restart_parity_gate`.
+
+Missing sidecars are reported as missing producer hooks.  Counts or digests are
+never guessed from a summary.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.generation.structural_source_proof import (
+    ROLE as STRUCTURAL_SOURCE_PROOF_ROLE,
+)
+from pyamplicol.generation.structural_source_proof import (
+    validate_generation_structural_proof,
+)
+from tools.developer.catalog_restart_parity_gate import SCHEMA
+from tools.developer.catalog_structural_parity_audit import (
+    CatalogParityError,
+    _candidate_counts,
+    _load_currents,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import ExecutionMode, ResultStatus
+
+CELL_PROOF_SCHEMA = "pyamplicol-cell-final-source-structural-proof-v1"
+LEGACY_PROOF_SCHEMA = "pyamplicol-legacy-final-structural-proof-v1"
+_SHA256 = re.compile(r"[0-9a-f]{64}")
+_REVISION = re.compile(r"[0-9a-f]{40}")
+_MODES = {
+    ExecutionMode.RECURRENCE,
+    ExecutionMode.COMPILED,
+    ExecutionMode.EAGER,
+}
+
+
+class FinalSourceProducerError(RuntimeError):
+    """Exact restart evidence is absent, stale, or unauthenticated."""
+
+
+def _read(path: Path) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text())
+    except (OSError, json.JSONDecodeError) as error:
+        raise FinalSourceProducerError(f"cannot read {path}: {error}") from error
+    if not isinstance(value, dict):
+        raise FinalSourceProducerError(f"{path} must contain a JSON object")
+    return value
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _artifact(result: dict[str, Any], cell_id: str) -> Path:
+    artifact = result.get("artifact")
+    raw = artifact.get("path") if isinstance(artifact, dict) else None
+    if not isinstance(raw, str) or not raw:
+        raise FinalSourceProducerError(f"{cell_id}: result has no artifact path")
+    path = Path(raw)
+    if not path.is_dir():
+        raise FinalSourceProducerError(f"{cell_id}: artifact is absent: {path}")
+    return path
+
+
+def _counts(value: object, label: str) -> dict[str, int]:
+    if not isinstance(value, dict):
+        raise FinalSourceProducerError(f"{label} must be an object")
+    fields = (
+        "source_current_count",
+        "produced_current_count",
+        "kernel_evaluation_count",
+        "attachment_count",
+        "amplitude_destination_count",
+    )
+    output: dict[str, int] = {}
+    for field in fields:
+        item = value.get(field)
+        if not isinstance(item, int) or isinstance(item, bool) or item < 0:
+            raise FinalSourceProducerError(
+                f"{label}.{field} must be a non-negative integer"
+            )
+        output[field] = item
+    if output["source_current_count"] + output["produced_current_count"] <= 0:
+        raise FinalSourceProducerError(f"{label} has no logical currents")
+    return output
+
+
+def _proof_digest_fields(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise FinalSourceProducerError(f"{label} is absent")
+    output = dict(value)
+    for field in (
+        "current_member_map_sha256",
+        "interaction_row_map_sha256",
+        "closure_map_sha256",
+        "source_contract_sha256",
+    ):
+        item = output.get(field)
+        if not isinstance(item, str) or _SHA256.fullmatch(item) is None:
+            raise FinalSourceProducerError(f"{label}.{field} is not exact")
+    return output
+
+
+def _authenticate_evidence_files(
+    artifact: Path,
+    value: object,
+    *,
+    label: str,
+) -> None:
+    if not isinstance(value, list) or not value:
+        raise FinalSourceProducerError(f"{label} evidence-file inventory is absent")
+    root = artifact.resolve()
+    for index, raw in enumerate(value):
+        if not isinstance(raw, dict):
+            raise FinalSourceProducerError(
+                f"{label} evidence file {index} is malformed"
+            )
+        relative = raw.get("path")
+        expected = raw.get("sha256")
+        if (
+            not isinstance(relative, str)
+            or not relative
+            or not isinstance(expected, str)
+            or _SHA256.fullmatch(expected) is None
+        ):
+            raise FinalSourceProducerError(f"{label} evidence file {index} is invalid")
+        path = (artifact / relative).resolve()
+        try:
+            path.relative_to(root)
+        except ValueError as error:
+            raise FinalSourceProducerError(
+                f"{label} evidence file escapes artifact: {relative}"
+            ) from error
+        if not path.is_file() or _sha256(path) != expected:
+            raise FinalSourceProducerError(
+                f"{label} evidence file is absent or changed: {relative}"
+            )
+
+
+def _candidate_record(
+    cell: Any,
+    result: dict[str, Any],
+    revision: str,
+) -> dict[str, Any]:
+    if result.get("status") != ResultStatus.OK.value:
+        raise FinalSourceProducerError(f"{cell.cell_id}: candidate current is not ok")
+    artifact = _artifact(result, cell.cell_id)
+    proof_path = artifact / "structural-preflight-proof.json"
+    if not proof_path.is_file():
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: missing generation hook {proof_path.name}"
+        )
+    proof = _read(proof_path)
+    if (
+        proof.get("schema") != CELL_PROOF_SCHEMA
+        or proof.get("cell_id") != cell.cell_id
+        or proof.get("source_revision") != revision
+        or proof.get("color_accuracy") != cell.measurement.accuracy.value
+        or proof.get("workload") != cell.workload.value
+    ):
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: structural proof is stale or has wrong identity"
+        )
+    manifest = load_manifest(artifact)
+    artifact_identity = proof.get("artifact_identity")
+    if (
+        not isinstance(artifact_identity, dict)
+        or artifact_identity.get("artifact_id") != manifest.artifact_id
+    ):
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: cell proof artifact identity is stale"
+        )
+    structural_records = [
+        record
+        for record in manifest.payloads
+        if record.role == STRUCTURAL_SOURCE_PROOF_ROLE
+        and record.process_id == artifact_identity.get("process_id")
+    ]
+    if len(structural_records) != 1:
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: generation structural proof payload is ambiguous"
+        )
+    structural_record = structural_records[0]
+    if (
+        artifact_identity.get("structural_proof_path") != structural_record.path
+        or artifact_identity.get("structural_proof_sha256") != structural_record.sha256
+    ):
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: generation structural proof identity is stale"
+        )
+    generation_proof = _read(artifact / structural_record.path)
+    producer_native_inputs = manifest.producer.get("native_build_inputs_sha256")
+    if not isinstance(producer_native_inputs, str):
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: artifact native-input identity is absent"
+        )
+    try:
+        authenticated_generation_proof = validate_generation_structural_proof(
+            generation_proof,
+            artifact_root=artifact,
+            expected_process_id=str(artifact_identity["process_id"]),
+            expected_source_revision=revision,
+            expected_native_build_inputs_sha256=producer_native_inputs,
+        )
+    except ValueError as error:
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: generation structural proof does not recompute"
+        ) from error
+    if (
+        proof.get("persisted_lane_inventory")
+        != (authenticated_generation_proof["physical_lane_inventory"])
+    ):
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: cell proof changed the generation lane inventory"
+        )
+    candidate = _candidate_counts(result, workload=cell.workload)
+    if candidate.source_revision != revision:
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: measured source is not the final source revision"
+        )
+    phases = {
+        name: _counts(proof.get(name), f"{cell.cell_id} candidate.{name}")
+        for name in ("active", "final_materialized", "peak_materialized")
+    }
+    expected = {
+        "active": (candidate.active, candidate.active_closure_count),
+        "final_materialized": (
+            candidate.final_materialized,
+            candidate.final_materialized_closure_count,
+        ),
+        "peak_materialized": (
+            candidate.peak_materialized,
+            candidate.peak_materialized_closure_count,
+        ),
+    }
+    for name, (structural, closure_count) in expected.items():
+        phase = phases[name]
+        if (
+            phase["source_current_count"] + phase["produced_current_count"]
+            != structural.current_count
+            or phase["kernel_evaluation_count"] != structural.evaluation_count
+            or phase["attachment_count"] != structural.attachment_count
+            or (
+                closure_count is not None
+                and phase["amplitude_destination_count"] != closure_count
+            )
+        ):
+            raise FinalSourceProducerError(
+                f"{cell.cell_id}: {name} proof disagrees with runtime structure"
+            )
+    semantic = _proof_digest_fields(
+        proof.get("semantic_proof"),
+        f"{cell.cell_id} semantic proof",
+    )
+    if (
+        semantic.get("status") != "proven"
+        or semantic.get("strength") not in {"exact-symbolic", "exact-reconstructed"}
+        or semantic.get("source_revision") != revision
+    ):
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: semantic proof is not exact and source-bound"
+        )
+    numerical = proof.get("numerical_validation")
+    if (
+        not isinstance(numerical, dict)
+        or numerical.get("status") != "ok"
+        or not isinstance(numerical.get("precision_decimal_digits"), int)
+        or numerical["precision_decimal_digits"] < 50
+        or not isinstance(numerical.get("comparison_sha256"), str)
+        or _SHA256.fullmatch(numerical["comparison_sha256"]) is None
+    ):
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: precision>=50 numerical proof hook is missing"
+        )
+    return {
+        "source_revision": revision,
+        "evidence_root": str(artifact.resolve()),
+        "artifact_identity": artifact_identity,
+        **phases,
+        "semantic_proof": semantic,
+        "numerical_validation": numerical,
+        "generation_structural_proof": authenticated_generation_proof,
+        "persisted_lane_inventory": proof["persisted_lane_inventory"],
+    }
+
+
+def _legacy_record(cell: Any, result: dict[str, Any] | None) -> dict[str, Any]:
+    if not REPORT_CATALOG.legacy_reference_available(cell):
+        return {
+            "scope": "unavailable",
+            "reason": "original-amplicol-open-quark-line-limit",
+        }
+    if result is None or result.get("status") != ResultStatus.OK.value:
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: authenticated legacy current is absent"
+        )
+    artifact = _artifact(result, cell.cell_id)
+    path = artifact / "legacy-structural-proof.json"
+    if not path.is_file():
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: missing legacy probe hook {path.name}"
+        )
+    proof = _read(path)
+    if proof.get("schema") != LEGACY_PROOF_SCHEMA:
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: legacy structural proof schema is unsupported"
+        )
+    provenance = result.get("provenance")
+    result_revision = (
+        provenance.get("revision") if isinstance(provenance, dict) else None
+    )
+    if (
+        proof.get("cell_id") != cell.cell_id
+        or proof.get("accuracy") != cell.measurement.accuracy.value
+        or proof.get("workload") != cell.workload.value
+        or not isinstance(result_revision, str)
+        or _REVISION.fullmatch(result_revision) is None
+        or proof.get("source_revision") != result_revision
+    ):
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: legacy structural proof is stale or has wrong identity"
+        )
+    _authenticate_evidence_files(
+        artifact,
+        proof.get("evidence_files"),
+        label=f"{cell.cell_id} legacy",
+    )
+    active = _counts(proof.get("active"), f"{cell.cell_id} legacy.active")
+    static = _counts(proof.get("static"), f"{cell.cell_id} legacy.static")
+    mapping = proof.get("object_mapping")
+    multiplicity = proof.get("row_multiplicity")
+    if not isinstance(mapping, dict) or mapping.get("status") != "exact":
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: exact legacy object mapping is absent"
+        )
+    _proof_digest_fields(
+        {
+            "current_member_map_sha256": mapping.get("current_object_map_sha256"),
+            "interaction_row_map_sha256": mapping.get("kernel_term_map_sha256"),
+            "closure_map_sha256": mapping.get("combine_route_map_sha256"),
+            "source_contract_sha256": mapping.get("source_contract_sha256"),
+        },
+        f"{cell.cell_id} legacy mapping",
+    )
+    if (
+        not isinstance(multiplicity, dict)
+        or multiplicity.get("status") != "exact"
+        or not isinstance(multiplicity.get("histogram_sha256"), str)
+        or _SHA256.fullmatch(multiplicity["histogram_sha256"]) is None
+        or (
+            cell.workload.value == "contracted"
+            and (
+                not isinstance(multiplicity.get("call_count"), int)
+                or multiplicity["call_count"] < 0
+            )
+        )
+    ):
+        raise FinalSourceProducerError(
+            f"{cell.cell_id}: exact legacy row histogram is absent"
+        )
+    return {
+        "scope": "available",
+        "active": active,
+        "static": static,
+        "object_mapping": mapping,
+        "row_multiplicity": multiplicity,
+    }
+
+
+def produce(
+    artifact_root: Path,
+    *,
+    source_revision: str,
+) -> dict[str, Any]:
+    if _REVISION.fullmatch(source_revision) is None:
+        raise FinalSourceProducerError("source revision must be a full Git SHA")
+    try:
+        currents = _load_currents(artifact_root)
+    except CatalogParityError as error:
+        raise FinalSourceProducerError(str(error)) from error
+    references = {
+        (
+            cell.process_key,
+            cell.n_final,
+            cell.measurement.accuracy,
+            cell.workload,
+        ): cell
+        for cell in REPORT_CATALOG.reference_cells()
+    }
+    rows: list[dict[str, Any]] = []
+    for cell in REPORT_CATALOG.matrix_cells():
+        if cell.measurement.execution_mode not in _MODES:
+            continue
+        result = currents.get(cell.cell_id)
+        if result is None:
+            raise FinalSourceProducerError(
+                f"{cell.cell_id}: final-source candidate current is absent"
+            )
+        reference = references[
+            (
+                cell.process_key,
+                cell.n_final,
+                cell.measurement.accuracy,
+                cell.workload,
+            )
+        ]
+        comparable = REPORT_CATALOG.legacy_reference_available(cell)
+        rows.append(
+            {
+                "cell_id": cell.cell_id,
+                "process_key": cell.process_key,
+                "n_final": cell.n_final,
+                "mode": cell.measurement.execution_mode.value,
+                "model": cell.measurement.model.value,
+                "accuracy": cell.measurement.accuracy.value,
+                "workload": cell.workload.value,
+                "classification": (
+                    "certified-parity" if comparable else "legacy-scope-unavailable"
+                ),
+                "candidate": _candidate_record(cell, result, source_revision),
+                "legacy": _legacy_record(reference, currents.get(reference.cell_id)),
+            }
+        )
+    if len(rows) != 1356:
+        raise FinalSourceProducerError(
+            f"catalog producer expected 1356 rows, generated {len(rows)}"
+        )
+    return {"schema": SCHEMA, "source_revision": source_revision, "cells": rows}
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--artifact-root", type=Path, required=True)
+    parser.add_argument("--source-revision", required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    return parser
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    try:
+        payload = produce(
+            args.artifact_root,
+            source_revision=args.source_revision,
+        )
+    except FinalSourceProducerError as error:
+        print(f"final-source structural preflight unavailable: {error}")
+        return 2
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n")
+    print(f"wrote {len(payload['cells'])} authenticated catalog rows")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/catalog_restart_parity_gate.py b/pyamplicol/tools/developer/catalog_restart_parity_gate.py
new file mode 100644
index 0000000000..fdfa4d4c0e
--- /dev/null
+++ b/pyamplicol/tools/developer/catalog_restart_parity_gate.py
@@ -0,0 +1,665 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Fail-closed restart gate for a final-source structural parity preflight.
+
+This validator deliberately does not generate or optimize amplitudes.  It is an
+independent consumer of a final-source preflight manifest.  In particular, it
+does not trust a producer's summary boolean or precomputed ratios.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import re
+from collections import Counter
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from pyamplicol.artifacts import load_manifest
+from pyamplicol.generation.structural_source_proof import (
+    SEMANTIC_MAP_DOMAINS,
+    validate_generation_structural_proof,
+)
+from tools.developer.catalog_structural_scope_registry import (
+    validate_reviewed_matrix_scope,
+)
+from tools.developer.final_source_numerical_truth import (
+    TruthProducerError,
+    canonical_sha256,
+    validate_witness_payload,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import ExecutionMode, Workload
+
+SCHEMA = "pyamplicol-final-source-structural-preflight-v1"
+OUTPUT_SCHEMA = "pyamplicol-independent-restart-parity-gate-v1"
+MAX_RATIO = 1.05
+_SHA256 = re.compile(r"[0-9a-f]{64}")
+_REVISION = re.compile(r"[0-9a-f]{40}")
+_EXACT_PROOF_STRENGTHS = {"exact-symbolic", "exact-reconstructed"}
+_CANDIDATE_MODES = {
+    ExecutionMode.RECURRENCE,
+    ExecutionMode.COMPILED,
+    ExecutionMode.EAGER,
+}
+
+
+class RestartParityError(ValueError):
+    """The final-source preflight manifest is malformed."""
+
+
+@dataclass(frozen=True)
+class Counts:
+    source_current_count: int
+    produced_current_count: int
+    kernel_evaluation_count: int
+    attachment_count: int
+    amplitude_destination_count: int
+
+    @property
+    def logical_current_count(self) -> int:
+        return self.source_current_count + self.produced_current_count
+
+    def add(self, other: Counts) -> Counts:
+        return Counts(
+            self.source_current_count + other.source_current_count,
+            self.produced_current_count + other.produced_current_count,
+            self.kernel_evaluation_count + other.kernel_evaluation_count,
+            self.attachment_count + other.attachment_count,
+            self.amplitude_destination_count + other.amplitude_destination_count,
+        )
+
+
+def _mapping(value: object, label: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise RestartParityError(f"{label} must be an object")
+    return value
+
+
+def _array(value: object, label: str) -> list[Any]:
+    if not isinstance(value, list):
+        raise RestartParityError(f"{label} must be an array")
+    return value
+
+
+def _text(value: object, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise RestartParityError(f"{label} must be a non-empty string")
+    return value
+
+
+def _digest(value: object, label: str) -> str:
+    text = _text(value, label)
+    if _SHA256.fullmatch(text) is None:
+        raise RestartParityError(f"{label} must be a lowercase SHA-256")
+    return text
+
+
+def _revision(value: object, label: str) -> str:
+    text = _text(value, label)
+    if _REVISION.fullmatch(text) is None:
+        raise RestartParityError(f"{label} must be a full lowercase Git revision")
+    return text
+
+
+def _count(value: object, label: str) -> int:
+    if not isinstance(value, int) or isinstance(value, bool) or value < 0:
+        raise RestartParityError(f"{label} must be a non-negative integer")
+    return value
+
+
+def _counts(value: object, label: str) -> Counts:
+    payload = _mapping(value, label)
+    counts = Counts(
+        _count(payload.get("source_current_count"), f"{label}.source_current_count"),
+        _count(
+            payload.get("produced_current_count"),
+            f"{label}.produced_current_count",
+        ),
+        _count(
+            payload.get("kernel_evaluation_count"),
+            f"{label}.kernel_evaluation_count",
+        ),
+        _count(payload.get("attachment_count"), f"{label}.attachment_count"),
+        _count(
+            payload.get("amplitude_destination_count"),
+            f"{label}.amplitude_destination_count",
+        ),
+    )
+    if counts.logical_current_count == 0:
+        raise RestartParityError(f"{label} has no logical currents")
+    return counts
+
+
+def _candidate_cells() -> tuple[Any, ...]:
+    return tuple(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode in _CANDIDATE_MODES
+    )
+
+
+def _identity_reasons(cell: Any, record: Mapping[str, Any]) -> list[str]:
+    expected = {
+        "process_key": cell.process_key,
+        "n_final": cell.n_final,
+        "mode": cell.measurement.execution_mode.value,
+        "model": cell.measurement.model.value,
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+    }
+    return [
+        f"identity-{name}-mismatch"
+        for name, value in expected.items()
+        if record.get(name) != value
+    ]
+
+
+def _proof_reasons(
+    candidate: Mapping[str, Any],
+    revision: str,
+    *,
+    cell: Any,
+) -> list[str]:
+    reasons: list[str] = []
+    try:
+        proof = _mapping(candidate.get("semantic_proof"), "candidate.semantic_proof")
+        if proof.get("status") != "proven":
+            reasons.append("semantic-proof-not-proven")
+        if proof.get("strength") not in _EXACT_PROOF_STRENGTHS:
+            reasons.append("semantic-proof-not-exact")
+        if proof.get("source_revision") != revision:
+            reasons.append("semantic-proof-source-revision-mismatch")
+        for field in (
+            "current_member_map_sha256",
+            "interaction_row_map_sha256",
+            "closure_map_sha256",
+            "source_contract_sha256",
+        ):
+            _digest(proof.get(field), f"candidate.semantic_proof.{field}")
+        witnesses = _mapping(
+            proof.get("witnesses"),
+            "candidate.semantic_proof.witnesses",
+        )
+        semantic_fields = {
+            "current_member_map": "current_member_map_sha256",
+            "interaction_row_map": "interaction_row_map_sha256",
+            "closure_map": "closure_map_sha256",
+            "source_contract": "source_contract_sha256",
+        }
+        content_identities: set[str] = set()
+        for witness_name, digest_name in semantic_fields.items():
+            witness = witnesses.get(witness_name)
+            if not isinstance(witness, list) or not witness:
+                raise RestartParityError(
+                    f"candidate.semantic_proof.witnesses.{witness_name} "
+                    "must be a non-empty array"
+                )
+            recomputed = canonical_sha256(f"{witness_name}-v1", witness)
+            if recomputed != proof.get(digest_name):
+                reasons.append(f"semantic-{witness_name}-digest-mismatch")
+            if recomputed in content_identities:
+                reasons.append("semantic-witness-content-identity-duplicate")
+            content_identities.add(recomputed)
+    except RestartParityError:
+        reasons.append("semantic-proof-incomplete")
+
+    discovery = candidate.get("numerical_relation_discovery")
+    if discovery is not None:
+        try:
+            discovery_map = _mapping(
+                discovery,
+                "candidate.numerical_relation_discovery",
+            )
+            if discovery_map.get("used_for_generation") is True:
+                if discovery_map.get("reconstructed_exact") is not True:
+                    reasons.append("numerical-only-relation-used-for-generation")
+                else:
+                    _digest(
+                        discovery_map.get("exact_proof_sha256"),
+                        "candidate.numerical_relation_discovery.exact_proof_sha256",
+                    )
+        except RestartParityError:
+            reasons.append("numerical-relation-discovery-malformed")
+
+    try:
+        numerical = _mapping(
+            candidate.get("numerical_validation"),
+            "candidate.numerical_validation",
+        )
+        validate_witness_payload(
+            numerical,
+            expected_source_revision=revision,
+            expected_cell_id=cell.cell_id,
+            expected_mode=cell.measurement.execution_mode.value,
+            expected_accuracy=cell.measurement.accuracy.value,
+            expected_workload=cell.workload.value,
+        )
+    except (RestartParityError, TruthProducerError):
+        reasons.append("numerical-validation-incomplete")
+    return reasons
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _evidence_path(root: Path, relative: str) -> Path:
+    resolved_root = root.resolve()
+    path = (resolved_root / relative).resolve()
+    try:
+        path.relative_to(resolved_root)
+    except ValueError as error:
+        raise RestartParityError(
+            f"persisted object escapes evidence root: {relative}"
+        ) from error
+    return path
+
+
+def _candidate_counts_and_inventory(
+    candidate: Mapping[str, Any],
+) -> tuple[dict[str, Counts], list[str]]:
+    reasons: list[str] = []
+    phases: dict[str, Counts] = {}
+    try:
+        for phase in ("active", "final_materialized", "peak_materialized"):
+            phases[phase] = _counts(candidate.get(phase), f"candidate.{phase}")
+    except RestartParityError:
+        return {}, ["candidate-structural-counts-incomplete"]
+
+    try:
+        evidence_root = Path(
+            _text(candidate.get("evidence_root"), "candidate.evidence_root")
+        )
+        if not evidence_root.is_dir():
+            raise RestartParityError("candidate evidence root is absent")
+        artifact_identity = _mapping(
+            candidate.get("artifact_identity"),
+            "candidate.artifact_identity",
+        )
+        artifact_id = _digest(
+            artifact_identity.get("artifact_id"),
+            "candidate.artifact_identity.artifact_id",
+        )
+        process_id = _text(
+            artifact_identity.get("process_id"),
+            "candidate.artifact_identity.process_id",
+        )
+        structural_path = _text(
+            artifact_identity.get("structural_proof_path"),
+            "candidate.artifact_identity.structural_proof_path",
+        )
+        structural_sha = _digest(
+            artifact_identity.get("structural_proof_sha256"),
+            "candidate.artifact_identity.structural_proof_sha256",
+        )
+        manifest = load_manifest(evidence_root)
+        if manifest.artifact_id != artifact_id:
+            reasons.append("candidate-artifact-identity-mismatch")
+        records = [
+            record
+            for record in manifest.payloads
+            if record.path == structural_path and record.process_id == process_id
+        ]
+        if len(records) != 1 or records[0].sha256 != structural_sha:
+            reasons.append("generation-structural-proof-manifest-mismatch")
+        structural_file = _evidence_path(evidence_root, structural_path)
+        if not structural_file.is_file() or _sha256(structural_file) != structural_sha:
+            reasons.append("generation-structural-proof-content-mismatch")
+        generation_proof = _mapping(
+            candidate.get("generation_structural_proof"),
+            "candidate.generation_structural_proof",
+        )
+        if _mapping(
+            candidate.get("persisted_lane_inventory"),
+            "candidate.persisted_lane_inventory",
+        ) != generation_proof.get("physical_lane_inventory"):
+            reasons.append("persisted-lane-inventory-not-generation-bound")
+        native_inputs = manifest.producer.get("native_build_inputs_sha256")
+        if not isinstance(native_inputs, str):
+            raise RestartParityError("candidate native-input identity is absent")
+        authenticated = validate_generation_structural_proof(
+            generation_proof,
+            artifact_root=evidence_root,
+            expected_process_id=process_id,
+            expected_source_revision=str(manifest.producer.get("git_revision")),
+            expected_native_build_inputs_sha256=native_inputs,
+        )
+        generation_maps = _mapping(
+            authenticated.get("semantic_maps"),
+            "generation semantic maps",
+        )
+        semantic = candidate.get("semantic_proof")
+        if isinstance(semantic, Mapping):
+            witnesses = semantic.get("witnesses")
+            if isinstance(witnesses, Mapping):
+                for name in SEMANTIC_MAP_DOMAINS:
+                    generation_map = _mapping(
+                        generation_maps.get(name),
+                        f"generation semantic map {name}",
+                    )
+                    if witnesses.get(name) != generation_map.get("rows") or (
+                        semantic.get(f"{name}_sha256") != generation_map.get("sha256")
+                    ):
+                        reasons.append(f"semantic-{name}-not-generation-bound")
+        numerical = candidate.get("numerical_validation")
+        if isinstance(numerical, Mapping):
+            numerical_candidate = numerical.get("candidate_artifact")
+            if isinstance(numerical_candidate, Mapping) and (
+                numerical_candidate.get("artifact_id") != artifact_id
+                or numerical_candidate.get("structural_proof_sha256") != structural_sha
+            ):
+                reasons.append("numerical-validation-not-structural-proof-bound")
+    except (RestartParityError, ValueError, OSError):
+        reasons.append("persisted-lane-inventory-malformed")
+    return phases, reasons
+
+
+def _legacy_counts(
+    legacy: Mapping[str, Any],
+    *,
+    workload: Workload,
+) -> tuple[Counts, Counts, list[str]]:
+    reasons: list[str] = []
+    try:
+        active = _counts(legacy.get("active"), "legacy.active")
+        static = _counts(legacy.get("static"), "legacy.static")
+        mapping = _mapping(legacy.get("object_mapping"), "legacy.object_mapping")
+        if mapping.get("status") != "exact":
+            reasons.append("legacy-object-mapping-not-exact")
+        for field in (
+            "current_object_map_sha256",
+            "kernel_term_map_sha256",
+            "combine_route_map_sha256",
+        ):
+            _digest(mapping.get(field), f"legacy.object_mapping.{field}")
+        multiplicity = _mapping(
+            legacy.get("row_multiplicity"),
+            "legacy.row_multiplicity",
+        )
+        if multiplicity.get("status") != "exact":
+            reasons.append("legacy-row-multiplicity-not-exact")
+        _digest(
+            multiplicity.get("histogram_sha256"),
+            "legacy.row_multiplicity.histogram_sha256",
+        )
+        if workload is Workload.CONTRACTED and multiplicity.get("call_count") is None:
+            reasons.append("legacy-contracted-call-histogram-missing")
+        if workload is Workload.CONTRACTED:
+            _count(
+                multiplicity.get("call_count"),
+                "legacy.row_multiplicity.call_count",
+            )
+    except RestartParityError:
+        return (
+            Counts(0, 0, 0, 0, 0),
+            Counts(0, 0, 0, 0, 0),
+            ["legacy-structural-evidence-incomplete"],
+        )
+    return active, static, reasons
+
+
+def _phase_ratios(candidate: Counts, legacy: Counts) -> dict[str, float]:
+    values = {
+        "logical_current": (
+            candidate.logical_current_count,
+            legacy.logical_current_count,
+        ),
+        "kernel_evaluation": (
+            candidate.kernel_evaluation_count,
+            legacy.kernel_evaluation_count,
+        ),
+        "attachment": (candidate.attachment_count, legacy.attachment_count),
+    }
+    ratios: dict[str, float] = {}
+    for name, (numerator, denominator) in values.items():
+        if denominator <= 0:
+            raise RestartParityError(f"legacy {name} budget is not positive")
+        ratio = numerator / denominator
+        if not math.isfinite(ratio):
+            raise RestartParityError(f"{name} ratio is not finite")
+        ratios[name] = ratio
+    return ratios
+
+
+def _exception_reasons(record: Mapping[str, Any]) -> list[str]:
+    try:
+        exception = _mapping(
+            record.get("representation_exception"),
+            "representation_exception",
+        )
+        if exception.get("status") != "reviewed":
+            return ["representation-exception-not-reviewed"]
+        _revision(exception.get("review_revision"), "exception.review_revision")
+        _digest(exception.get("object_mapping_sha256"), "exception.object_mapping")
+        _text(exception.get("reason"), "exception.reason")
+        return []
+    except RestartParityError:
+        return ["representation-exception-incomplete"]
+
+
+def _validate_row(
+    cell: Any,
+    record: Mapping[str, Any],
+    revision: str,
+) -> dict[str, Any]:
+    reasons = _identity_reasons(cell, record)
+    classification = record.get("classification")
+    candidate = record.get("candidate")
+    if not isinstance(candidate, Mapping):
+        return {
+            "cell_id": cell.cell_id,
+            "classification": classification,
+            "status": "failed",
+            "reason_codes": sorted({*reasons, "candidate-evidence-missing"}),
+            "ratios": {},
+        }
+    if candidate.get("source_revision") != revision:
+        reasons.append("candidate-source-revision-mismatch")
+    reasons.extend(_proof_reasons(candidate, revision, cell=cell))
+    phases, inventory_reasons = _candidate_counts_and_inventory(candidate)
+    reasons.extend(inventory_reasons)
+
+    legacy_available = REPORT_CATALOG.legacy_reference_available(cell)
+    ratios: dict[str, dict[str, float]] = {}
+    if not legacy_available:
+        if classification != "legacy-scope-unavailable":
+            reasons.append("legacy-scope-classification-mismatch")
+        legacy = record.get("legacy")
+        if not isinstance(legacy, Mapping) or legacy.get("reason") != (
+            "original-amplicol-open-quark-line-limit"
+        ):
+            reasons.append("legacy-scope-unavailable-reason-missing")
+    else:
+        if classification not in {
+            "certified-parity",
+            "reviewed-representation-exception",
+        }:
+            reasons.append("comparable-row-not-classified")
+        legacy = record.get("legacy")
+        if not isinstance(legacy, Mapping) or legacy.get("scope") != "available":
+            reasons.append("legacy-evidence-missing")
+        else:
+            active, static, legacy_reasons = _legacy_counts(
+                legacy,
+                workload=cell.workload,
+            )
+            reasons.extend(legacy_reasons)
+            if phases and not legacy_reasons:
+                try:
+                    ratios = {
+                        "active": _phase_ratios(phases["active"], active),
+                        "final_materialized": _phase_ratios(
+                            phases["final_materialized"],
+                            static,
+                        ),
+                        "peak_materialized": _phase_ratios(
+                            phases["peak_materialized"],
+                            static,
+                        ),
+                    }
+                except RestartParityError:
+                    reasons.append("structural-ratio-unavailable")
+                violations = [
+                    f"{phase}-{metric}-exceeds-1.05"
+                    for phase, metrics in ratios.items()
+                    for metric, ratio in metrics.items()
+                    if ratio > MAX_RATIO
+                ]
+                if violations:
+                    if classification == "reviewed-representation-exception":
+                        reasons.extend(_exception_reasons(record))
+                    else:
+                        reasons.extend(violations)
+                elif classification == "reviewed-representation-exception":
+                    reasons.append("representation-exception-unnecessary")
+
+    reason_codes = sorted(set(reasons))
+    return {
+        "cell_id": cell.cell_id,
+        "classification": classification,
+        "status": "ok" if not reason_codes else "failed",
+        "reason_codes": reason_codes,
+        "ratios": ratios,
+    }
+
+
+def validate_manifest(
+    payload: Mapping[str, Any],
+    *,
+    expected_revision: str,
+) -> dict[str, Any]:
+    reviewed_scope = validate_reviewed_matrix_scope()
+    revision = _revision(expected_revision, "expected revision")
+    if payload.get("schema") != SCHEMA:
+        raise RestartParityError(f"manifest schema must be {SCHEMA!r}")
+    if payload.get("source_revision") != revision:
+        raise RestartParityError("manifest is not bound to the expected final revision")
+    records = _array(payload.get("cells"), "manifest cells")
+    by_id: dict[str, Mapping[str, Any]] = {}
+    duplicate_ids: set[str] = set()
+    for index, raw in enumerate(records):
+        record = _mapping(raw, f"manifest cell {index}")
+        cell_id = _text(record.get("cell_id"), f"manifest cell {index}.cell_id")
+        if cell_id in by_id:
+            duplicate_ids.add(cell_id)
+        by_id[cell_id] = record
+
+    rows: list[dict[str, Any]] = []
+    expected_ids: set[str] = set()
+    for cell in _candidate_cells():
+        expected_ids.add(cell.cell_id)
+        record = by_id.get(cell.cell_id)
+        if record is None:
+            rows.append(
+                {
+                    "cell_id": cell.cell_id,
+                    "classification": None,
+                    "status": "failed",
+                    "reason_codes": ["missing-record"],
+                    "ratios": {},
+                }
+            )
+            continue
+        row = _validate_row(cell, record, revision)
+        if cell.cell_id in duplicate_ids:
+            row["status"] = "failed"
+            row["reason_codes"] = sorted({*row["reason_codes"], "duplicate-record"})
+        rows.append(row)
+    for cell_id in sorted(set(by_id) - expected_ids):
+        rows.append(
+            {
+                "cell_id": cell_id,
+                "classification": by_id[cell_id].get("classification"),
+                "status": "failed",
+                "reason_codes": ["unexpected-record"],
+                "ratios": {},
+            }
+        )
+
+    rows_by_id = {str(row["cell_id"]): row for row in rows}
+    comparison_cells: dict[str, list[str]] = {}
+    for cell_id in expected_ids:
+        record = by_id.get(cell_id)
+        candidate = None if record is None else record.get("candidate")
+        numerical = (
+            candidate.get("numerical_validation")
+            if isinstance(candidate, Mapping)
+            else None
+        )
+        digest = (
+            numerical.get("comparison_sha256")
+            if isinstance(numerical, Mapping)
+            else None
+        )
+        if isinstance(digest, str) and _SHA256.fullmatch(digest) is not None:
+            comparison_cells.setdefault(digest, []).append(cell_id)
+    for duplicated in comparison_cells.values():
+        if len(duplicated) < 2:
+            continue
+        for cell_id in duplicated:
+            row = rows_by_id[cell_id]
+            row["status"] = "failed"
+            row["reason_codes"] = sorted(
+                {
+                    *row["reason_codes"],
+                    "numerical-comparison-content-identity-duplicate",
+                }
+            )
+
+    failures = [row for row in rows if row["status"] != "ok"]
+    classifications = Counter(
+        str(row["classification"]) for row in rows if row["status"] == "ok"
+    )
+    reason_counts = Counter(
+        reason for row in failures for reason in row["reason_codes"]
+    )
+    return {
+        "schema": OUTPUT_SCHEMA,
+        "source_revision": revision,
+        "reviewed_out_of_catalog_scope": reviewed_scope,
+        "summary": {
+            "expected_cell_count": len(_candidate_cells()),
+            "reported_row_count": len(rows),
+            "passed_row_count": len(rows) - len(failures),
+            "failed_row_count": len(failures),
+            "classification_counts": dict(sorted(classifications.items())),
+            "failure_reason_counts": dict(sorted(reason_counts.items())),
+            "restart_ready": not failures,
+        },
+        "rows": rows,
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--expected-source-revision", required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    return parser
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    payload = json.loads(args.manifest.read_text())
+    result = validate_manifest(
+        _mapping(payload, "manifest"),
+        expected_revision=args.expected_source_revision,
+    )
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    print(json.dumps(result["summary"], indent=2, sort_keys=True))
+    return 0 if result["summary"]["restart_ready"] is True else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/catalog_structural_parity_audit.py b/pyamplicol/tools/developer/catalog_structural_parity_audit.py
new file mode 100644
index 0000000000..9508800fce
--- /dev/null
+++ b/pyamplicol/tools/developer/catalog_structural_parity_audit.py
@@ -0,0 +1,1422 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Audit report-catalog structural work against original AmpliCol evidence.
+
+The performance report stores immutable per-cell artifacts.  This tool reads
+those artifacts without importing a native pyAmpliCol runtime and emits one
+machine-readable row for every matrix candidate cell.  It deliberately keeps
+two comparisons separate:
+
+* active/dynamic work per phase-space point;
+* final and peak static materialization during artifact generation.
+
+A candidate can beat AmpliCol dynamically while still materializing far more
+work.  Neither comparison is silently substituted for the other.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+from collections import Counter
+from dataclasses import asdict, dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import ExecutionMode, ResultStatus, Workload
+
+
+class CatalogParityError(RuntimeError):
+    """The artifact tree cannot produce an authenticated census."""
+
+
+_MODULE_CURRENT = re.compile(
+    r"dimension\s*\(\s*1\s*:\s*\d+\s*,\s*(\d+)\s*\)\s*::\s*val_c\b",
+    re.IGNORECASE,
+)
+_MODULE_INTERACTION = re.compile(
+    r"dimension\s*\(\s*1\s*:\s*\d+\s*,\s*(\d+)\s*\)\s*::\s*int_c\b",
+    re.IGNORECASE,
+)
+_AFTER_FILTER = re.compile(
+    r"Total number of currents, vertices and amplitudes after filter"
+    r"\s+(\d+)\s+(\d+)\s+(\d+)",
+)
+_DIRECT_CURRENT = re.compile(r"AMPICOL_COLOR_PROBE_CURRENTS\s+(\d+)")
+_DIRECT_INTERACTION = re.compile(r"AMPICOL_COLOR_PROBE_VERTICES\s+(\d+)")
+_DIRECT_AMPLITUDE = re.compile(r"AMPICOL_COLOR_PROBE_AMPLITUDES\s+(\d+)")
+_LIBRARY_CALL = re.compile(
+    r"AMPICOL_COLOR_PROBE_LIBRARY_CALLS\s+(\d+)\s+(\d+)\s+(\d+)"
+)
+_PROCESS_ROW = re.compile(r"group:(\d+):integral:(\d+)")
+_SUBROUTINE = re.compile(
+    r"^\s*subroutine\s+(\w+)\b(.*?)^\s*end\s+subroutine\s+\1\b",
+    re.IGNORECASE | re.MULTILINE | re.DOTALL,
+)
+_EXTERNAL_CURRENT = re.compile(
+    r"call\s+ext_\w+\s*\(.*?val_c\s*\(\s*1\s*,\s*(\d+)\s*\).*?\)",
+    re.IGNORECASE | re.DOTALL,
+)
+_INT1_ARRAY = re.compile(
+    r"integer\s*,\s*parameter\s*,\s*dimension\s*\(([^)]*)\)\s*::\s*"
+    r"int1\s*=\s*(?:reshape\s*\(\s*)?\[\s*&?(.*?)\]"
+    r"(?:\s*,\s*shape\s*=\s*\[[^]]*\]\s*\))?",
+    re.IGNORECASE | re.DOTALL,
+)
+_COMBINE_SHAPE = re.compile(r"0:(\d+),(\d+)")
+
+MAX_RATIO = 1.05
+_DYNAMIC_COLOR_PROJECTION_ABI = (
+    "pyamplicol-generic-dag-dynamic-color-projection-v2"
+)
+_PEAK_CONTRIBUTION_COUNT_SEMANTICS = "resident-pending-contributions-v1"
+
+
+@dataclass(frozen=True)
+class WorkCounts:
+    current_count: int
+    evaluation_count: int | None
+    attachment_count: int | None
+
+
+@dataclass(frozen=True)
+class LegacyObjectMapping:
+    """Exact generated-module mapping to the structural comparison objects."""
+
+    abi: str
+    declared_current_count: int
+    declared_interaction_count: int
+    source_current_count: int
+    produced_current_count: int
+    vertex_term_count: int
+    combine_route_count: int
+    current_ids_complete: bool
+    interaction_ids_complete: bool
+    contribution_references_complete: bool
+
+
+@dataclass(frozen=True)
+class LegacyCounts:
+    evidence_kind: str
+    active: WorkCounts | None
+    static: WorkCounts
+    generated_module_count: int
+    retained_amplitude_count: int | None
+    module_shapes: tuple[tuple[int, int], ...]
+    selected_module: str | None
+    selected_module_object_mapping: LegacyObjectMapping | None
+    limitation: str | None
+
+
+@dataclass(frozen=True)
+class CandidateCounts:
+    mode: str
+    active: WorkCounts
+    final_materialized: WorkCounts
+    peak_materialized: WorkCounts
+    active_evidence_kind: str
+    active_evidence_exact: bool
+    selector_certificate_available: bool
+    source_revision: str | None
+    active_closure_count: int | None
+    final_materialized_closure_count: int | None
+    peak_materialized_closure_count: int | None
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text())
+    except (OSError, json.JSONDecodeError) as error:
+        raise CatalogParityError(f"cannot read {path}: {error}") from error
+    if not isinstance(payload, dict):
+        raise CatalogParityError(f"JSON root is not an object: {path}")
+    return payload
+
+
+def _positive(value: Any, label: str) -> int:
+    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+        raise CatalogParityError(f"{label} must be a positive integer")
+    return value
+
+
+def _optional_positive(value: Any, label: str) -> int | None:
+    if value is None:
+        return None
+    return _positive(value, label)
+
+
+def _optional_nonnegative(value: Any, label: str) -> int | None:
+    if value is None:
+        return None
+    if not isinstance(value, int) or isinstance(value, bool) or value < 0:
+        raise CatalogParityError(f"{label} must be a nonnegative integer")
+    return value
+
+
+def _require_bool(value: Any, label: str) -> bool:
+    if not isinstance(value, bool):
+        raise CatalogParityError(f"{label} must be boolean")
+    return value
+
+
+def _compiled_execution_lanes(
+    execution: dict[str, Any],
+) -> tuple[tuple[str, dict[str, Any]], ...]:
+    """Enumerate every physically persisted compiled DAG lane exactly once."""
+
+    lanes: list[tuple[str, dict[str, Any]]] = []
+    seen: set[tuple[object, ...]] = set()
+
+    def payload_paths(value: object) -> tuple[str, ...]:
+        paths: list[str] = []
+
+        def visit(item: object, field: str | None = None) -> None:
+            if isinstance(item, dict):
+                for key, child in item.items():
+                    visit(child, str(key))
+            elif isinstance(item, list):
+                for child in item:
+                    visit(child, field)
+            elif (
+                isinstance(item, str)
+                and field is not None
+                and (field == "path" or field.endswith("_path"))
+            ):
+                paths.append(item)
+
+        visit(value)
+        return tuple(sorted(set(paths)))
+
+    def add(record: object, path: str) -> None:
+        if not isinstance(record, dict):
+            raise CatalogParityError(f"compiled execution lane {path} is malformed")
+        summary = record.get("dag_summary")
+        if not isinstance(summary, dict):
+            raise CatalogParityError(
+                f"compiled execution lane {path} lacks DAG summary"
+            )
+        physical_paths = payload_paths(record.get("compiled"))
+        identity: tuple[object, ...] = (
+            ("payloads", *physical_paths)
+            if physical_paths
+            else ("manifest-path", path)
+        )
+        if identity in seen:
+            return
+        seen.add(identity)
+        lanes.append((path, record))
+        helicity_sum = record.get("helicity_sum_execution")
+        if helicity_sum is not None:
+            add(helicity_sum, f"{path}.helicity_sum_execution")
+        for key in ("color_selector_executions", "helicity_selector_executions"):
+            raw = record.get(key, [])
+            if raw is None:
+                continue
+            if not isinstance(raw, list):
+                raise CatalogParityError(f"compiled {path}.{key} is malformed")
+            for index, wrapper in enumerate(raw):
+                if not isinstance(wrapper, dict):
+                    raise CatalogParityError(
+                        f"compiled {path}.{key}[{index}] is malformed"
+                    )
+                add(wrapper.get("execution"), f"{path}.{key}[{index}].execution")
+
+    add(execution, "primary")
+    return tuple(lanes)
+
+
+def _sum_compiled_materialization(
+    lanes: tuple[tuple[str, dict[str, Any]], ...],
+) -> tuple[WorkCounts, int | None]:
+    summaries = [record["dag_summary"] for _path, record in lanes]
+    evaluations = [
+        _optional_positive(
+            summary.get("interaction_evaluation_count"),
+            "compiled interaction evaluation count",
+        )
+        for summary in summaries
+    ]
+    closures = [
+        _optional_nonnegative(
+            summary.get("amplitude_root_count"),
+            "compiled amplitude-root count",
+        )
+        for summary in summaries
+    ]
+    return (
+        WorkCounts(
+            sum(
+                _positive(summary.get("current_count"), "compiled current count")
+                for summary in summaries
+            ),
+            (
+                None
+                if any(value is None for value in evaluations)
+                else sum(value for value in evaluations if value is not None)
+            ),
+            sum(
+                _positive(
+                    summary.get("interaction_count"),
+                    "compiled interaction attachment count",
+                )
+                for summary in summaries
+            ),
+        ),
+        (
+            None
+            if any(value is None for value in closures)
+            else sum(value for value in closures if value is not None)
+        ),
+    )
+
+
+def _single_execution(artifact: Path) -> Path:
+    executions = sorted((artifact / "processes").glob("*/execution.json"))
+    if len(executions) != 1:
+        raise CatalogParityError(
+            f"{artifact} must contain one process execution; found {len(executions)}"
+        )
+    return executions[0]
+
+
+def _module_shape(path: Path) -> tuple[int, int]:
+    text = path.read_text()
+    current = _MODULE_CURRENT.search(text)
+    interaction = _MODULE_INTERACTION.search(text)
+    if current is None or interaction is None:
+        raise CatalogParityError(f"legacy module lacks val_c/int_c dimensions: {path}")
+    return int(current.group(1)), int(interaction.group(1))
+
+
+def _module_object_mapping(path: Path) -> LegacyObjectMapping:
+    """Prove val_c/int_c are the same objects counted by candidate schedules.
+
+    Original AmpliCol's generated module stores external and produced currents
+    in ``val_c``.  Every vertex term is stored in ``int_c`` and then referenced
+    by a current-combination routine.  The proof below rejects sparse arrays or
+    dangling terms instead of treating a maximum array index as work.
+    """
+
+    text = path.read_text()
+    declared_currents, declared_interactions = _module_shape(path)
+    source_ids = {int(value) for value in _EXTERNAL_CURRENT.findall(text)}
+    produced_ids: set[int] = set()
+    vertex_term_ids: set[int] = set()
+    contribution_reference_ids: set[int] = set()
+    combine_route_count = 0
+
+    for match in _SUBROUTINE.finditer(text):
+        name = match.group(1).lower()
+        body = match.group(2)
+        array = _INT1_ARRAY.search(body)
+        if array is None:
+            continue
+        values = [int(value) for value in re.findall(r"\d+", array.group(2))]
+        if name.startswith("vertex_"):
+            vertex_term_ids.update(values)
+            continue
+        if not name.startswith("combine_currents"):
+            continue
+        shape = _COMBINE_SHAPE.fullmatch(array.group(1).replace(" ", ""))
+        if shape is None:
+            raise CatalogParityError(
+                f"legacy current-combination int1 shape is unsupported: {path}"
+            )
+        stride = int(shape.group(1)) + 1
+        column_count = int(shape.group(2))
+        if len(values) != stride * column_count:
+            raise CatalogParityError(
+                f"legacy current-combination int1 payload has the wrong size: {path}"
+            )
+        for start in range(0, len(values), stride):
+            produced_ids.add(values[start])
+            contribution_ids = values[start + 1 : start + stride]
+            contribution_reference_ids.update(contribution_ids)
+            combine_route_count += len(contribution_ids)
+
+    expected_currents = set(range(1, declared_currents + 1))
+    expected_interactions = set(range(1, declared_interactions + 1))
+    mapping = LegacyObjectMapping(
+        abi="pyamplicol-legacy-module-object-mapping-v1",
+        declared_current_count=declared_currents,
+        declared_interaction_count=declared_interactions,
+        source_current_count=len(source_ids),
+        produced_current_count=len(produced_ids),
+        vertex_term_count=len(vertex_term_ids),
+        combine_route_count=combine_route_count,
+        current_ids_complete=(source_ids | produced_ids) == expected_currents,
+        interaction_ids_complete=vertex_term_ids == expected_interactions,
+        contribution_references_complete=(
+            contribution_reference_ids == expected_interactions
+        ),
+    )
+    if not (
+        mapping.current_ids_complete
+        and mapping.interaction_ids_complete
+        and mapping.contribution_references_complete
+    ):
+        raise CatalogParityError(
+            f"legacy module has sparse or dangling current/interaction objects: {path}"
+        )
+    return mapping
+
+
+def _legacy_counts(
+    result: dict[str, Any],
+    *,
+    workload: Workload,
+) -> LegacyCounts:
+    artifact_payload = result.get("artifact")
+    if not isinstance(artifact_payload, dict):
+        raise CatalogParityError("legacy result has no artifact")
+    artifact_raw = artifact_payload.get("path")
+    if not isinstance(artifact_raw, str) or not artifact_raw:
+        raise CatalogParityError("legacy artifact path is absent")
+    artifact = Path(artifact_raw)
+    modules = sorted(artifact.rglob("amp*_lib.f03"))
+    shapes = tuple(_module_shape(module) for module in modules)
+    module_mappings = tuple(_module_object_mapping(module) for module in modules)
+
+    if workload is Workload.ALL_FLOW:
+        log = artifact / "legacy.log"
+        text = log.read_text()
+        current = _DIRECT_CURRENT.search(text)
+        interaction = _DIRECT_INTERACTION.search(text)
+        amplitude = _DIRECT_AMPLITUDE.search(text)
+        if current is None or interaction is None or amplitude is None:
+            raise CatalogParityError("all-flow legacy log lacks structural counters")
+        counts = WorkCounts(
+            int(current.group(1)),
+            int(interaction.group(1)),
+            None,
+        )
+        return LegacyCounts(
+            evidence_kind="direct-fixed-helicity-all-flow-probe",
+            active=counts,
+            static=counts,
+            generated_module_count=0,
+            retained_amplitude_count=int(amplitude.group(1)),
+            module_shapes=(),
+            selected_module=None,
+            selected_module_object_mapping=None,
+            limitation=None,
+        )
+
+    if not modules:
+        raise CatalogParityError("generated-library legacy artifact has no modules")
+
+    if workload is Workload.SELECTED_FLOW:
+        row = artifact_payload.get("process_row")
+        if not isinstance(row, str):
+            raise CatalogParityError("selected-flow legacy result lacks process row")
+        match = _PROCESS_ROW.fullmatch(row)
+        if match is None:
+            raise CatalogParityError(f"malformed selected-flow process row: {row!r}")
+        selected_name = f"amp{match.group(1)}_{match.group(2)}_lib.f03"
+        selected = [module for module in modules if module.name == selected_name]
+        if len(selected) != 1:
+            raise CatalogParityError(
+                f"selected-flow module {selected_name} occurs {len(selected)} times"
+            )
+        current, interaction = _module_shape(selected[0])
+        object_mapping = _module_object_mapping(selected[0])
+        active = WorkCounts(
+            current,
+            interaction,
+            object_mapping.combine_route_count,
+        )
+        static = WorkCounts(
+            sum(module_current for module_current, _ in shapes),
+            sum(module_interaction for _, module_interaction in shapes),
+            sum(mapping.combine_route_count for mapping in module_mappings),
+        )
+        return LegacyCounts(
+            evidence_kind="generated-library-selected-row",
+            active=active,
+            # The selected-flow timing executes one row, but original
+            # AmpliCol first materializes the complete generated library.
+            # Preserve that distinction when comparing generation work.
+            static=static,
+            generated_module_count=len(modules),
+            retained_amplitude_count=1,
+            module_shapes=shapes,
+            selected_module=selected_name,
+            selected_module_object_mapping=object_mapping,
+            limitation=None,
+        )
+
+    probes = sorted(artifact.rglob("amplicol_color_library_probe.output"))
+    if len(probes) != 1:
+        raise CatalogParityError(
+            "contracted legacy artifact must contain one color-library probe"
+        )
+    match = _AFTER_FILTER.search(probes[0].read_text())
+    if match is None:
+        raise CatalogParityError("contracted legacy probe lacks after-filter counts")
+    row = artifact_payload.get("process_row")
+    if not isinstance(row, str):
+        raise CatalogParityError("contracted legacy result lacks process row")
+    row_match = _PROCESS_ROW.fullmatch(row)
+    if row_match is None:
+        raise CatalogParityError(f"malformed contracted process row: {row!r}")
+    selected_name = f"amp{row_match.group(1)}_{row_match.group(2)}_lib.f03"
+    selected = [module for module in modules if module.name == selected_name]
+    if len(selected) != 1:
+        raise CatalogParityError(
+            f"contracted module {selected_name} occurs {len(selected)} times"
+        )
+    object_mapping = _module_object_mapping(selected[0])
+    retained = int(match.group(3))
+    static = WorkCounts(
+        sum(current for current, _ in shapes),
+        sum(interaction for _, interaction in shapes),
+        sum(mapping.combine_route_count for mapping in module_mappings),
+    )
+    calls = {
+        (int(group), int(integral)): int(count)
+        for group, integral, count in _LIBRARY_CALL.findall(probes[0].read_text())
+    }
+    active: WorkCounts | None = None
+    limitation = (
+        "contracted probe predates exact generated-library call histogram"
+    )
+    if calls:
+        by_name = {module.name: module for module in modules}
+        missing = [
+            f"amp{group}_{integral}_lib.f03"
+            for group, integral in calls
+            if f"amp{group}_{integral}_lib.f03" not in by_name
+        ]
+        if missing:
+            raise CatalogParityError(
+                "contracted probe call histogram references absent modules: "
+                + ", ".join(sorted(missing))
+            )
+        active = WorkCounts(
+            sum(
+                _module_shape(by_name[f"amp{group}_{integral}_lib.f03"])[0] * count
+                for (group, integral), count in calls.items()
+            ),
+            sum(
+                _module_shape(by_name[f"amp{group}_{integral}_lib.f03"])[1] * count
+                for (group, integral), count in calls.items()
+            ),
+            sum(
+                _module_object_mapping(
+                    by_name[f"amp{group}_{integral}_lib.f03"]
+                ).combine_route_count
+                * count
+                for (group, integral), count in calls.items()
+            ),
+        )
+        limitation = None
+    return LegacyCounts(
+        evidence_kind=(
+            "generated-library-contracted-exact-call-histogram"
+            if active is not None
+            else "generated-library-contracted-call-histogram-unavailable"
+        ),
+        active=active,
+        static=static,
+        generated_module_count=len(modules),
+        retained_amplitude_count=retained,
+        module_shapes=shapes,
+        selected_module=selected_name,
+        selected_module_object_mapping=object_mapping,
+        limitation=limitation,
+    )
+
+
+def _candidate_counts(
+    result: dict[str, Any],
+    *,
+    workload: Workload,
+) -> CandidateCounts:
+    artifact_payload = result.get("artifact")
+    if not isinstance(artifact_payload, dict):
+        raise CatalogParityError("candidate result has no artifact")
+    artifact_raw = artifact_payload.get("path")
+    if not isinstance(artifact_raw, str) or not artifact_raw:
+        raise CatalogParityError("candidate artifact path is absent")
+    execution = _read_json(_single_execution(Path(artifact_raw)))
+    kind = execution.get("kind")
+    selector_available = False
+    active_kind = "persisted-plan"
+    active_exact = workload is Workload.CONTRACTED
+    active_closures: int | None = None
+    final_closures: int | None = None
+    peak_closures: int | None = None
+
+    if kind == "pyamplicol-runtime-recurrence-execution":
+        mode = ExecutionMode.RECURRENCE.value
+        try:
+            inspection = execution["plan"]["inspection_summary"]
+            schedule = inspection["schedule"]
+            construction = inspection["construction"]
+        except (KeyError, TypeError) as error:
+            raise CatalogParityError(
+                "recurrence execution summary is incomplete"
+            ) from error
+        if (
+            construction.get("peak_contribution_count_semantics")
+            != _PEAK_CONTRIBUTION_COUNT_SEMANTICS
+        ):
+            raise CatalogParityError(
+                "recurrence construction lacks authenticated resident "
+                "peak-contribution semantics"
+            )
+        final = WorkCounts(
+            _positive(schedule.get("current_count"), "recurrence current count"),
+            _positive(
+                schedule.get("contribution_count"),
+                "recurrence contribution count",
+            ),
+            _positive(
+                schedule.get("contribution_count"),
+                "recurrence contribution count",
+            ),
+        )
+        peak = WorkCounts(
+            _positive(
+                construction.get("peak_current_count"),
+                "recurrence peak current count",
+            ),
+            _positive(
+                construction.get("peak_contribution_count"),
+                "recurrence peak contribution count",
+            ),
+            _positive(
+                construction.get("peak_contribution_count"),
+                "recurrence peak contribution count",
+            ),
+        )
+        active = final
+        final_closures = _optional_nonnegative(
+            schedule.get("closure_term_count"),
+            "recurrence closure-term count",
+        )
+        active_closures = final_closures
+        peak_closures = _optional_nonnegative(
+            construction.get("peak_closure_term_count"),
+            "recurrence peak closure-term count",
+        )
+        selector = inspection.get("selector_work_certificate")
+        if workload is Workload.SELECTED_FLOW and isinstance(selector, dict):
+            representatives = selector.get("representatives")
+            if isinstance(representatives, list) and representatives:
+                parsed = [
+                    WorkCounts(
+                        _positive(item.get("current_count"), "selector current count"),
+                        _positive(
+                            item.get("contribution_count"),
+                            "selector contribution count",
+                        ),
+                        _positive(
+                            item.get("contribution_count"),
+                            "selector contribution count",
+                        ),
+                    )
+                    for item in representatives
+                    if isinstance(item, dict)
+                ]
+                if parsed:
+                    # The report selector can target any physical flow.  The
+                    # worst representative is the fail-closed catalog gate.
+                    active = WorkCounts(
+                        max(item.current_count for item in parsed),
+                        max(
+                            item.evaluation_count
+                            for item in parsed
+                            if item.evaluation_count is not None
+                        ),
+                        max(
+                            item.attachment_count
+                            for item in parsed
+                            if item.attachment_count is not None
+                        ),
+                    )
+                    selector_available = True
+                    active_exact = True
+                    active_kind = "selector-active-worst-representative"
+                    active_closures = max(
+                        (
+                            _optional_nonnegative(
+                                item.get("closure_count"),
+                                "selector closure count",
+                            )
+                            or 0
+                        )
+                        for item in representatives
+                        if isinstance(item, dict)
+                    )
+    elif kind == "pyamplicol-runtime-execution":
+        mode = ExecutionMode.COMPILED.value
+        if workload is Workload.ALL_FLOW:
+            # The all-flow report workload fixes one physical helicity and
+            # sums color.  Its executed lane is the primary DAG.  Unlike the
+            # selected-flow (one color, helicity sum) and contracted lanes,
+            # it therefore need not expose an auxiliary helicity-sum DAG.
+            summary = execution.get("dag_summary")
+            active_kind = "compiled-primary-fixed-helicity-all-flow"
+            selector_records = execution.get("helicity_selector_executions")
+        else:
+            helicity_sum = execution.get("helicity_sum_execution")
+            if not isinstance(helicity_sum, dict):
+                raise CatalogParityError("compiled execution lacks helicity-sum lane")
+            summary = helicity_sum.get("dag_summary")
+            active_kind = "compiled-helicity-sum"
+            selector_records = (
+                helicity_sum.get("color_selector_executions")
+                if workload is Workload.SELECTED_FLOW
+                else None
+            )
+        if not isinstance(summary, dict):
+            raise CatalogParityError("compiled execution lacks DAG summary")
+        active = WorkCounts(
+            _positive(summary.get("current_count"), "compiled current count"),
+            _optional_positive(
+                summary.get("interaction_evaluation_count"),
+                "compiled interaction evaluation count",
+            ),
+            _positive(
+                summary.get("interaction_count"),
+                "compiled interaction attachment count",
+            ),
+        )
+        active_closures = _optional_nonnegative(
+            summary.get("amplitude_root_count"),
+            "compiled active amplitude-root count",
+        )
+        final, final_closures = _sum_compiled_materialization(
+            _compiled_execution_lanes(execution)
+        )
+        peak = final
+        peak_closures = final_closures
+        if isinstance(selector_records, list) and selector_records:
+            selector_counts: list[WorkCounts] = []
+            for record in selector_records:
+                if not isinstance(record, dict):
+                    continue
+                selector_execution = record.get("execution")
+                if not isinstance(selector_execution, dict):
+                    continue
+                selector_summary = selector_execution.get("dag_summary")
+                if not isinstance(selector_summary, dict):
+                    continue
+                selector_counts.append(
+                    WorkCounts(
+                        _positive(
+                            selector_summary.get("current_count"),
+                            "compiled selector current count",
+                        ),
+                        _optional_positive(
+                            selector_summary.get("interaction_evaluation_count"),
+                            "compiled selector interaction evaluation count",
+                        ),
+                        _positive(
+                            selector_summary.get("interaction_count"),
+                            "compiled selector interaction attachment count",
+                        ),
+                    )
+                )
+            if selector_counts:
+                active = WorkCounts(
+                    max(item.current_count for item in selector_counts),
+                    (
+                        None
+                        if any(
+                            item.evaluation_count is None for item in selector_counts
+                        )
+                        else max(
+                            item.evaluation_count
+                            for item in selector_counts
+                            if item.evaluation_count is not None
+                        )
+                    ),
+                    max(
+                        item.attachment_count
+                        for item in selector_counts
+                        if item.attachment_count is not None
+                    ),
+                )
+                selector_available = True
+                active_exact = True
+                active_kind = (
+                    "compiled-selected-color-worst-sector"
+                    if workload is Workload.SELECTED_FLOW
+                    else "compiled-fixed-helicity-worst-class"
+                )
+                active_closures = max(
+                    (
+                        _optional_nonnegative(
+                            record.get("execution", {})
+                            .get("dag_summary", {})
+                            .get("amplitude_root_count"),
+                            "compiled selector amplitude-root count",
+                        )
+                        or 0
+                    )
+                    for record in selector_records
+                    if isinstance(record, dict)
+                )
+    elif kind == "pyamplicol-runtime-eager-execution":
+        mode = ExecutionMode.EAGER.value
+        try:
+            inspection = execution["plan"]["inspection_summary"]
+        except (KeyError, TypeError) as error:
+            raise CatalogParityError(
+                "eager execution lacks inspection summary"
+            ) from error
+        final = WorkCounts(
+            _positive(inspection.get("current_count"), "eager current count"),
+            _optional_positive(
+                inspection.get("invocation_count"),
+                "eager invocation count",
+            ),
+            _positive(inspection.get("attachment_count"), "eager attachment count"),
+        )
+        peak = final
+        active = final
+        final_closures = _optional_nonnegative(
+            inspection.get("closure_count"),
+            "eager closure count",
+        )
+        active_closures = final_closures
+        peak_closures = final_closures
+        selector_work = inspection.get("selector_work")
+        if isinstance(selector_work, dict):
+            if selector_work.get("abi") != "pyamplicol-eager-selector-work-v1":
+                raise CatalogParityError("eager selector-work ABI is unsupported")
+            prefix = {
+                Workload.SELECTED_FLOW: "selected_flow",
+                Workload.ALL_FLOW: "all_flow",
+                Workload.CONTRACTED: "contracted",
+            }[workload]
+            active = WorkCounts(
+                _positive(
+                    selector_work.get(f"{prefix}_current_count"),
+                    f"eager {prefix} active current count",
+                ),
+                _positive(
+                    selector_work.get(f"{prefix}_evaluation_count"),
+                    f"eager {prefix} active evaluation count",
+                ),
+                _positive(
+                    selector_work.get(f"{prefix}_attachment_count"),
+                    f"eager {prefix} active attachment count",
+                ),
+            )
+            selector_available = True
+            active_exact = True
+            active_kind = f"eager-{prefix.replace('_', '-')}-selector-census"
+            active_closures = _optional_nonnegative(
+                selector_work.get(f"{prefix}_closure_count"),
+                f"eager {prefix} active closure count",
+            )
+    else:
+        raise CatalogParityError(f"unsupported candidate execution kind {kind!r}")
+
+    provenance = result.get("provenance")
+    source_revision = None
+    if isinstance(provenance, dict):
+        value = provenance.get("report_measured_source_revision")
+        if isinstance(value, str):
+            source_revision = value
+    return CandidateCounts(
+        mode=mode,
+        active=active,
+        final_materialized=final,
+        peak_materialized=peak,
+        active_evidence_kind=active_kind,
+        active_evidence_exact=active_exact,
+        selector_certificate_available=selector_available,
+        source_revision=source_revision,
+        active_closure_count=active_closures,
+        final_materialized_closure_count=final_closures,
+        peak_materialized_closure_count=peak_closures,
+    )
+
+
+def _ratio(candidate: int, legacy: int) -> float:
+    value = candidate / legacy
+    if not math.isfinite(value):
+        raise CatalogParityError("non-finite structural-work ratio")
+    return value
+
+
+def _load_currents(artifact_root: Path) -> dict[str, dict[str, Any]]:
+    results: dict[str, dict[str, Any]] = {}
+    for pointer_path in sorted((artifact_root / "cells").glob("*/current.json")):
+        pointer = _read_json(pointer_path)
+        cell_id = pointer.get("cell_id")
+        manifest_raw = pointer.get("manifest_path")
+        if not isinstance(cell_id, str) or not isinstance(manifest_raw, str):
+            raise CatalogParityError(f"malformed current pointer {pointer_path}")
+        manifest_path = pointer_path.parent / manifest_raw
+        manifest = _read_json(manifest_path)
+        result_raw = manifest.get("result_path")
+        if not isinstance(result_raw, str):
+            raise CatalogParityError(f"manifest lacks result path: {manifest_path}")
+        result_path = manifest_path.parent / result_raw
+        result = _read_json(result_path)
+        result["_audit_result_path"] = str(result_path)
+        results[cell_id] = result
+    return results
+
+
+def _cell_row(
+    cell: Any,
+    currents: dict[str, dict[str, Any]],
+) -> dict[str, Any]:
+    base = {
+        "cell_id": cell.cell_id,
+        "dataset_id": cell.dataset_id,
+        "process_key": cell.process_key,
+        "process": cell.process,
+        "n_final": cell.n_final,
+        "mode": cell.measurement.execution_mode.value,
+        "model": None
+        if cell.measurement.model is None
+        else cell.measurement.model.value,
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+        "limit": MAX_RATIO,
+    }
+    candidate_result = currents.get(cell.cell_id)
+    if candidate_result is None:
+        return base | {"status": "candidate-unavailable"}
+    candidate_status = candidate_result.get("status")
+    if candidate_status != ResultStatus.OK.value:
+        return base | {
+            "status": "candidate-non-ok",
+            "candidate_status": candidate_status,
+            "candidate_result_path": candidate_result.get("_audit_result_path"),
+        }
+
+    reference = next(
+        candidate
+        for candidate in REPORT_CATALOG.reference_cells()
+        if candidate.process_key == cell.process_key
+        and candidate.n_final == cell.n_final
+        and candidate.measurement.accuracy == cell.measurement.accuracy
+        and candidate.workload == cell.workload
+    )
+    if not REPORT_CATALOG.legacy_reference_available(cell):
+        return base | {
+            "status": "legacy-unsupported",
+            "candidate_result_path": candidate_result.get("_audit_result_path"),
+        }
+    legacy_result = currents.get(reference.cell_id)
+    if legacy_result is None:
+        return base | {
+            "status": "legacy-unavailable",
+            "legacy_cell_id": reference.cell_id,
+            "candidate_result_path": candidate_result.get("_audit_result_path"),
+        }
+    legacy_status = legacy_result.get("status")
+    if legacy_status != ResultStatus.OK.value:
+        return base | {
+            "status": "legacy-non-ok",
+            "legacy_cell_id": reference.cell_id,
+            "legacy_status": legacy_status,
+            "candidate_result_path": candidate_result.get("_audit_result_path"),
+            "legacy_result_path": legacy_result.get("_audit_result_path"),
+        }
+
+    try:
+        candidate_counts = _candidate_counts(
+            candidate_result,
+            workload=cell.workload,
+        )
+        legacy_counts = _legacy_counts(legacy_result, workload=cell.workload)
+    except CatalogParityError as error:
+        return base | {
+            "status": "evidence-unavailable",
+            "error": str(error),
+            "legacy_cell_id": reference.cell_id,
+            "candidate_result_path": candidate_result.get("_audit_result_path"),
+            "legacy_result_path": legacy_result.get("_audit_result_path"),
+        }
+
+    ratios: dict[str, float | None] = {
+        "active_current": None,
+        "active_evaluation": None,
+        "active_attachment": None,
+        "final_static_current": _ratio(
+            candidate_counts.final_materialized.current_count,
+            legacy_counts.static.current_count,
+        ),
+        "final_static_evaluation": None,
+        "final_static_attachment": None,
+        "peak_static_current": _ratio(
+            candidate_counts.peak_materialized.current_count,
+            legacy_counts.static.current_count,
+        ),
+        "peak_static_evaluation": None,
+        "peak_static_attachment": None,
+    }
+    if (
+        candidate_counts.final_materialized.evaluation_count is not None
+        and legacy_counts.static.evaluation_count is not None
+    ):
+        ratios["final_static_evaluation"] = _ratio(
+            candidate_counts.final_materialized.evaluation_count,
+            legacy_counts.static.evaluation_count,
+        )
+    if (
+        candidate_counts.final_materialized.attachment_count is not None
+        and legacy_counts.static.attachment_count is not None
+    ):
+        ratios["final_static_attachment"] = _ratio(
+            candidate_counts.final_materialized.attachment_count,
+            legacy_counts.static.attachment_count,
+        )
+    if (
+        candidate_counts.peak_materialized.evaluation_count is not None
+        and legacy_counts.static.evaluation_count is not None
+    ):
+        ratios["peak_static_evaluation"] = _ratio(
+            candidate_counts.peak_materialized.evaluation_count,
+            legacy_counts.static.evaluation_count,
+        )
+    if (
+        candidate_counts.peak_materialized.attachment_count is not None
+        and legacy_counts.static.attachment_count is not None
+    ):
+        ratios["peak_static_attachment"] = _ratio(
+            candidate_counts.peak_materialized.attachment_count,
+            legacy_counts.static.attachment_count,
+        )
+    if legacy_counts.active is not None and candidate_counts.active_evidence_exact:
+        ratios["active_current"] = _ratio(
+            candidate_counts.active.current_count,
+            legacy_counts.active.current_count,
+        )
+        if (
+            candidate_counts.active.evaluation_count is not None
+            and legacy_counts.active.evaluation_count is not None
+        ):
+            ratios["active_evaluation"] = _ratio(
+                candidate_counts.active.evaluation_count,
+                legacy_counts.active.evaluation_count,
+            )
+        if (
+            candidate_counts.active.attachment_count is not None
+            and legacy_counts.active.attachment_count is not None
+        ):
+            ratios["active_attachment"] = _ratio(
+                candidate_counts.active.attachment_count,
+                legacy_counts.active.attachment_count,
+            )
+    violations = tuple(
+        key for key, value in ratios.items() if value is not None and value > MAX_RATIO
+    )
+    unknown = tuple(key for key, value in ratios.items() if value is None)
+    status = (
+        "ok"
+        if not violations and not unknown
+        else ("exceeds-1.05" if violations else "active-parity-unresolved")
+    )
+    return base | {
+        "status": status,
+        "legacy_cell_id": reference.cell_id,
+        "candidate": asdict(candidate_counts),
+        "legacy": asdict(legacy_counts),
+        "ratios": ratios,
+        "violations": violations,
+        "unresolved_metrics": unknown,
+        "candidate_result_path": candidate_result.get("_audit_result_path"),
+        "legacy_result_path": legacy_result.get("_audit_result_path"),
+    }
+
+
+def audit(artifact_root: Path) -> dict[str, Any]:
+    currents = _load_currents(artifact_root)
+    cells = [
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode
+        in {ExecutionMode.RECURRENCE, ExecutionMode.COMPILED, ExecutionMode.EAGER}
+    ]
+    rows = [_cell_row(cell, currents) for cell in cells]
+    status_counts = Counter(row["status"] for row in rows)
+    comparable = [
+        row
+        for row in rows
+        if row["status"] in {"ok", "exceeds-1.05", "active-parity-unresolved"}
+    ]
+    violations = [row for row in comparable if row.get("violations")]
+    active_violations = [
+        row
+        for row in violations
+        if any(metric.startswith("active_") for metric in row["violations"])
+    ]
+    final_static_violations = [
+        row
+        for row in violations
+        if any(metric.startswith("final_static_") for metric in row["violations"])
+    ]
+    peak_static_violations = [
+        row
+        for row in violations
+        if any(metric.startswith("peak_static_") for metric in row["violations"])
+    ]
+    return {
+        "schema": "pyamplicol-catalog-structural-parity-census-v1",
+        "created_utc": datetime.now(UTC).isoformat(),
+        "artifact_root": str(artifact_root.resolve()),
+        "policy": {
+            "maximum_unreviewed_ratio_to_original_amplicol": MAX_RATIO,
+            "active_and_static_materialization_are_independent_gates": True,
+            "compiled_and_eager_peak_defaults_to_final_materialization": True,
+            "selected_recurrence_active_work_uses_worst_selector_representative": True,
+        },
+        "summary": {
+            "catalog_candidate_cell_count": len(rows),
+            "current_pointer_count": len(currents),
+            "status_counts": dict(sorted(status_counts.items())),
+            "comparable_cell_count": len(comparable),
+            "violation_cell_count": len(violations),
+            "active_violation_cell_count": len(active_violations),
+            "final_static_violation_cell_count": len(final_static_violations),
+            "peak_static_violation_cell_count": len(peak_static_violations),
+            "fully_certified_catalog_parity": (
+                len(comparable) == len(rows) and not violations
+            ),
+            "violation_by_metric": dict(
+                sorted(
+                    Counter(
+                        metric for row in violations for metric in row["violations"]
+                    ).items()
+                )
+            ),
+            "violation_by_mode": dict(
+                sorted(Counter(row["mode"] for row in violations).items())
+            ),
+            "violation_by_process": dict(
+                sorted(Counter(row["process_key"] for row in violations).items())
+            ),
+        },
+        "cells": rows,
+    }
+
+
+def _source_work_counts(value: object, label: str) -> WorkCounts:
+    if not isinstance(value, dict):
+        raise CatalogParityError(f"{label} must be an object")
+    return WorkCounts(
+        _positive(value.get("current_count"), f"{label} current count"),
+        _positive(value.get("evaluation_count"), f"{label} evaluation count"),
+        _positive(value.get("attachment_count"), f"{label} attachment count"),
+    )
+
+
+def _require_exact_projection_certificate(
+    value: object,
+    label: str,
+    *,
+    expected_source_revision: str,
+    projection_applied: bool,
+) -> None:
+    if value is None and not projection_applied:
+        return
+    if not isinstance(value, dict):
+        raise CatalogParityError(f"{label} projection certificate is malformed")
+    required_digests = (
+        "source_semantics_sha256",
+        "selector_domains_sha256",
+        "current_class_members_sha256",
+        "current_remap_sha256",
+        "interaction_groups_sha256",
+        "closure_groups_sha256",
+        "rectangle_cardinalities_sha256",
+        "row_identity_sha256",
+    )
+    remap = value.get("old_to_new_current_ids")
+    if (
+        value.get("abi") != _DYNAMIC_COLOR_PROJECTION_ABI
+        or value.get("source_revision") != expected_source_revision
+        or value.get("applied") is not projection_applied
+        or value.get("equality_check_status")
+        not in {
+            "passed-exact-cartesian-products-no-duplicates",
+            "passed-no-projectable-classes",
+        }
+        or not isinstance(remap, list)
+        or not remap
+        or any(not isinstance(item, int) or item < 0 for item in remap)
+        or any(
+            not isinstance(value.get(field), str)
+            or re.fullmatch(r"[0-9a-f]{64}", value[field]) is None
+            for field in required_digests
+        )
+    ):
+        raise CatalogParityError(
+            f"{label} lacks a complete exact rectangular projection proof"
+        )
+
+
+def audit_source_manifest(payload: dict[str, Any]) -> dict[str, Any]:
+    """Fail closed on a source-derived, timing-free all-catalog census."""
+
+    if payload.get("schema") != "pyamplicol-catalog-source-structural-evidence-v1":
+        raise CatalogParityError("source structural evidence schema is unsupported")
+    source_revision = payload.get("source_revision")
+    if (
+        not isinstance(source_revision, str)
+        or re.fullmatch(r"[0-9a-f]{40}", source_revision) is None
+    ):
+        raise CatalogParityError("source structural evidence revision is invalid")
+    raw_cells = payload.get("cells")
+    if not isinstance(raw_cells, list):
+        raise CatalogParityError("source structural evidence cells must be a list")
+    expected_cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode
+        in {ExecutionMode.RECURRENCE, ExecutionMode.COMPILED, ExecutionMode.EAGER}
+    )
+    expected_by_id = {cell.cell_id: cell for cell in expected_cells}
+    rows_by_id: dict[str, dict[str, Any]] = {}
+    for raw in raw_cells:
+        if not isinstance(raw, dict) or not isinstance(raw.get("cell_id"), str):
+            raise CatalogParityError("source structural evidence has malformed cell")
+        cell_id = raw["cell_id"]
+        if cell_id in rows_by_id:
+            raise CatalogParityError(
+                f"source structural evidence repeats cell {cell_id}"
+            )
+        rows_by_id[cell_id] = raw
+    missing = sorted(set(expected_by_id) - set(rows_by_id))
+    extra = sorted(set(rows_by_id) - set(expected_by_id))
+    if missing or extra:
+        raise CatalogParityError(
+            "source structural evidence does not cover the exact catalog "
+            f"(missing={missing[:5]}, extra={extra[:5]})"
+        )
+
+    audited: list[dict[str, Any]] = []
+    violation_count = 0
+    unresolved_count = 0
+    scope_unavailable_count = 0
+    for cell_id, cell in expected_by_id.items():
+        raw = rows_by_id[cell_id]
+        if raw.get("source_revision") != source_revision:
+            raise CatalogParityError(
+                f"source structural evidence {cell_id} revision mismatch"
+            )
+        if raw.get("proof_strength") != "exact-source-construction":
+            raise CatalogParityError(
+                f"source structural evidence {cell_id} is not an exact proof"
+            )
+        candidate = raw.get("candidate")
+        if not isinstance(candidate, dict):
+            raise CatalogParityError(f"{cell_id} candidate evidence is absent")
+        candidate_active = _source_work_counts(
+            candidate.get("active"),
+            f"{cell_id} candidate active",
+        )
+        candidate_final = _source_work_counts(
+            candidate.get("final_materialized"),
+            f"{cell_id} candidate final",
+        )
+        candidate_peak = _source_work_counts(
+            candidate.get("peak_materialized"),
+            f"{cell_id} candidate peak",
+        )
+        _optional_nonnegative(
+            candidate.get("active_closure_count"),
+            f"{cell_id} candidate active closure count",
+        )
+        _optional_nonnegative(
+            candidate.get("final_closure_count"),
+            f"{cell_id} candidate final closure count",
+        )
+        _optional_nonnegative(
+            candidate.get("peak_closure_count"),
+            f"{cell_id} candidate peak closure count",
+        )
+        _require_exact_projection_certificate(
+            candidate.get("dynamic_color_projection"),
+            cell_id,
+            expected_source_revision=source_revision,
+            projection_applied=_require_bool(
+                candidate.get("dynamic_color_projection_applied"),
+                f"{cell_id} candidate dynamic-color projection applied",
+            ),
+        )
+
+        if not REPORT_CATALOG.legacy_reference_available(cell):
+            if (
+                raw.get("status") != "legacy-scope-unavailable"
+                or not isinstance(raw.get("scope_reason"), str)
+                or raw.get("legacy") is not None
+            ):
+                raise CatalogParityError(
+                    f"{cell_id} must explicitly record legacy-scope-unavailable"
+                )
+            scope_unavailable_count += 1
+            audited.append(
+                {
+                    "cell_id": cell_id,
+                    "status": "legacy-scope-unavailable",
+                    "scope_reason": raw["scope_reason"],
+                    "candidate": {
+                        "active": asdict(candidate_active),
+                        "final_materialized": asdict(candidate_final),
+                        "peak_materialized": asdict(candidate_peak),
+                    },
+                    "ratios": None,
+                    "violations": (),
+                }
+            )
+            continue
+
+        if raw.get("status") != "ok":
+            raise CatalogParityError(
+                f"{cell_id} comparable source evidence status must be ok"
+            )
+        legacy = raw.get("legacy")
+        if not isinstance(legacy, dict):
+            raise CatalogParityError(f"{cell_id} legacy evidence is absent")
+        legacy_active = _source_work_counts(
+            legacy.get("active"),
+            f"{cell_id} legacy active",
+        )
+        legacy_static = _source_work_counts(
+            legacy.get("static"),
+            f"{cell_id} legacy static",
+        )
+        ratios = {
+            "active_current": _ratio(
+                candidate_active.current_count, legacy_active.current_count
+            ),
+            "active_evaluation": _ratio(
+                candidate_active.evaluation_count or 0,
+                legacy_active.evaluation_count or 0,
+            ),
+            "active_attachment": _ratio(
+                candidate_active.attachment_count or 0,
+                legacy_active.attachment_count or 0,
+            ),
+            "final_static_current": _ratio(
+                candidate_final.current_count, legacy_static.current_count
+            ),
+            "final_static_evaluation": _ratio(
+                candidate_final.evaluation_count or 0,
+                legacy_static.evaluation_count or 0,
+            ),
+            "final_static_attachment": _ratio(
+                candidate_final.attachment_count or 0,
+                legacy_static.attachment_count or 0,
+            ),
+            "peak_static_current": _ratio(
+                candidate_peak.current_count, legacy_static.current_count
+            ),
+            "peak_static_evaluation": _ratio(
+                candidate_peak.evaluation_count or 0,
+                legacy_static.evaluation_count or 0,
+            ),
+            "peak_static_attachment": _ratio(
+                candidate_peak.attachment_count or 0,
+                legacy_static.attachment_count or 0,
+            ),
+        }
+        violations = tuple(
+            name for name, ratio in ratios.items() if ratio > MAX_RATIO
+        )
+        violation_count += bool(violations)
+        audited.append(
+            {
+                "cell_id": cell_id,
+                "status": "ok" if not violations else "exceeds-1.05",
+                "candidate": {
+                    "active": asdict(candidate_active),
+                    "final_materialized": asdict(candidate_final),
+                    "peak_materialized": asdict(candidate_peak),
+                },
+                "legacy": {
+                    "active": asdict(legacy_active),
+                    "static": asdict(legacy_static),
+                },
+                "ratios": ratios,
+                "violations": violations,
+            }
+        )
+    comparable_count = len(audited) - scope_unavailable_count
+    return {
+        "schema": "pyamplicol-catalog-source-structural-parity-preflight-v1",
+        "created_utc": datetime.now(UTC).isoformat(),
+        "source_revision": source_revision,
+        "policy": {
+            "maximum_ratio_to_original_amplicol": MAX_RATIO,
+            "currents_evaluations_and_attachments_are_independent_gates": True,
+            "amplitude_roots_are_reported_but_not_conflated_with_int_c": True,
+            "legacy_scope_unavailable_is_explicit_and_has_no_fabricated_ratio": True,
+        },
+        "summary": {
+            "catalog_candidate_cell_count": len(expected_cells),
+            "comparable_cell_count": comparable_count,
+            "legacy_scope_unavailable_cell_count": scope_unavailable_count,
+            "violation_cell_count": violation_count,
+            "unresolved_cell_count": unresolved_count,
+            "complete_catalog_coverage": True,
+            "all_comparable_cells_within_limit": violation_count == 0,
+            "fully_certified_catalog_parity": violation_count == 0,
+        },
+        "cells": audited,
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    source = parser.add_mutually_exclusive_group(required=True)
+    source.add_argument("--artifact-root", type=Path)
+    source.add_argument(
+        "--source-manifest",
+        type=Path,
+        help=(
+            "timing-free source-construction evidence covering every matrix "
+            "candidate cell"
+        ),
+    )
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument(
+        "--require-complete-parity",
+        action="store_true",
+        help=(
+            "exit nonzero unless every catalog candidate has complete evidence "
+            "and all active/final/peak ratios are <=1.05"
+        ),
+    )
+    return parser
+
+
+def _parity_exit_code(payload: dict[str, Any], *, required: bool) -> int:
+    if not required:
+        return 0
+    summary = payload.get("summary")
+    if not isinstance(summary, dict):
+        return 2
+    return 0 if summary.get("fully_certified_catalog_parity") is True else 2
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    payload = (
+        audit_source_manifest(_read_json(args.source_manifest))
+        if args.source_manifest is not None
+        else audit(args.artifact_root)
+    )
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n")
+    print(json.dumps(payload["summary"], indent=2, sort_keys=True))
+    return _parity_exit_code(payload, required=args.require_complete_parity)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/catalog_structural_scope_registry.py b/pyamplicol/tools/developer/catalog_structural_scope_registry.py
new file mode 100644
index 0000000000..68645638f6
--- /dev/null
+++ b/pyamplicol/tools/developer/catalog_structural_scope_registry.py
@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Reviewed, fail-closed scope for matrix structural-parity coverage gaps.
+
+The 1,356-row restart gate covers every candidate cell that the canonical
+matrix catalog defines.  This registry makes the two intentionally absent
+classes explicit so that they cannot be mistaken for silently unproved rows.
+Any catalog change in these classes requires a review and registry update.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from tools.performance_report.catalog import PROCESS_FAMILIES, REPORT_CATALOG
+from tools.performance_report.models import (
+    Accuracy,
+    ExecutionMode,
+    ModelKey,
+    Workload,
+)
+
+SCHEMA = "pyamplicol-reviewed-matrix-structural-scope-v2"
+REVIEW_ID = "matrix-structural-scope-2026-08-21"
+
+_PROCESS_KEYS = (
+    "dd_z_jets",
+    "ud_w_jets",
+    "dd_epem_jets",
+    "ud_epve_jets",
+    "dd_zz_jets",
+    "gg_tt_jets",
+    "dd_tt_jets",
+    "gg_gluons",
+    "dd_zzz_jets",
+    "dd_epemzh_jets",
+    "dd_ttzh_jets",
+    "dd_4l_jets",
+    "dd_3q_lines",
+    "dd_4q_lines",
+    "dd_3q_identical_lines",
+)
+_CANDIDATE_MODES = {
+    ExecutionMode.RECURRENCE,
+    ExecutionMode.COMPILED,
+    ExecutionMode.EAGER,
+}
+_FOUR_QUARK_LC_PLANES = {
+    (ExecutionMode.RECURRENCE, ModelKey.BUILTIN_SM, Workload.SELECTED_FLOW),
+    (ExecutionMode.RECURRENCE, ModelKey.BUILTIN_SM, Workload.ALL_FLOW),
+    (ExecutionMode.RECURRENCE, ModelKey.UFO_SM, Workload.SELECTED_FLOW),
+    (ExecutionMode.RECURRENCE, ModelKey.UFO_SM, Workload.ALL_FLOW),
+    (ExecutionMode.COMPILED, ModelKey.BUILTIN_SM, Workload.SELECTED_FLOW),
+    (ExecutionMode.COMPILED, ModelKey.BUILTIN_SM, Workload.ALL_FLOW),
+    (ExecutionMode.EAGER, ModelKey.BUILTIN_SM, Workload.SELECTED_FLOW),
+    (ExecutionMode.EAGER, ModelKey.BUILTIN_SM, Workload.ALL_FLOW),
+}
+_FOUR_QUARK_CONTRACTED_PLANES = {
+    (ExecutionMode.RECURRENCE, ModelKey.BUILTIN_SM, Workload.CONTRACTED),
+    (ExecutionMode.RECURRENCE, ModelKey.UFO_SM, Workload.CONTRACTED),
+    (ExecutionMode.COMPILED, ModelKey.BUILTIN_SM, Workload.CONTRACTED),
+    (ExecutionMode.EAGER, ModelKey.BUILTIN_SM, Workload.CONTRACTED),
+}
+_FOUR_QUARK_UFO_FULL_PLANES = {
+    (ExecutionMode.COMPILED, ModelKey.UFO_SM, Workload.CONTRACTED),
+    (ExecutionMode.EAGER, ModelKey.UFO_SM, Workload.CONTRACTED),
+}
+
+REVIEWED_MATRIX_SCOPE: dict[str, Any] = {
+    "schema": SCHEMA,
+    "review": {
+        "status": "reviewed",
+        "review_id": REVIEW_ID,
+    },
+    "intentionally_out_of_catalog": [
+        {
+            "scope_id": "ufo-compiled-and-eager-lc-nlc",
+            "status": "reviewed-unavailable",
+            "process_keys": list(_PROCESS_KEYS),
+            "mode_model_pairs": [
+                {"mode": "compiled", "model": "ufo_sm"},
+                {"mode": "eager", "model": "ufo_sm"},
+            ],
+            "accuracies": ["lc", "nlc"],
+            "workload_by_accuracy": {
+                "lc": ["selected-flow", "all-flow"],
+                "nlc": ["contracted"],
+            },
+            "reason": (
+                "canonical-matrix-defines-ufo-compiled-and-eager-for-full-colour-only"
+            ),
+            "catalog_cell_count": 0,
+        },
+    ],
+    "candidate_only_requirements": [
+        {
+            "scope_id": "four-open-quark-lines-lc-candidate-proof",
+            "process_key": "dd_4q_lines",
+            "accuracy": "lc",
+            "n_final": [6, 7, 8, 9],
+            "mode_model_workload_plane_count": 8,
+            "catalog_cell_count": 32,
+            "legacy_comparison": {
+                "status": "unavailable",
+                "reason": "original-amplicol-open-quark-line-limit",
+            },
+            "proof_requirement": (
+                "candidate exact structural and precision-50 self-proof remains "
+                "mandatory in catalog_restart_parity_gate"
+            ),
+        },
+        {
+            "scope_id": "four-open-quark-lines-contracted-candidate-proof",
+            "process_key": "dd_4q_lines",
+            "accuracies": ["nlc", "full"],
+            "n_final": [6],
+            "mode_model_workload_plane_count_by_accuracy": {"nlc": 4, "full": 6},
+            "catalog_cell_count": 10,
+            "legacy_comparison": {
+                "status": "unavailable",
+                "reason": "original-amplicol-open-quark-line-limit",
+            },
+            "proof_requirement": (
+                "candidate exact structural and precision-50 self-proof remains "
+                "mandatory in catalog_restart_parity_gate"
+            ),
+        },
+    ],
+}
+
+
+class CatalogStructuralScopeError(RuntimeError):
+    """The canonical matrix drifted from its reviewed coverage scope."""
+
+
+def validate_reviewed_matrix_scope() -> dict[str, Any]:
+    """Validate and return the reviewed out-of-catalog scope declaration."""
+
+    process_keys = tuple(family.key for family in PROCESS_FAMILIES)
+    if process_keys != _PROCESS_KEYS:
+        raise CatalogStructuralScopeError(
+            "process catalog changed; reviewed matrix structural scope is stale"
+        )
+    candidates = tuple(
+        cell
+        for cell in REPORT_CATALOG.matrix_cells()
+        if cell.measurement.execution_mode in _CANDIDATE_MODES
+    )
+
+    ufo_compiled_or_eager = [
+        cell
+        for cell in candidates
+        if cell.measurement.model is ModelKey.UFO_SM
+        and cell.measurement.execution_mode
+        in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+    ]
+    if len(ufo_compiled_or_eager) != 100 or any(
+        cell.measurement.accuracy is not Accuracy.FULL
+        or cell.workload is not Workload.CONTRACTED
+        for cell in ufo_compiled_or_eager
+    ):
+        raise CatalogStructuralScopeError(
+            "UFO compiled/eager full-colour scope differs from the reviewed matrix"
+        )
+
+    four_quark = [
+        cell for cell in candidates if cell.process_key == "dd_4q_lines"
+    ]
+    non_lc = [
+        cell
+        for cell in four_quark
+        if cell.measurement.accuracy in {Accuracy.NLC, Accuracy.FULL}
+    ]
+    actual_non_lc = {
+        (
+            cell.measurement.accuracy,
+            cell.n_final,
+            cell.measurement.execution_mode,
+            cell.measurement.model,
+            cell.workload,
+        )
+        for cell in non_lc
+    }
+    expected_non_lc = {
+        (accuracy, 6, mode, model, workload)
+        for accuracy in {Accuracy.NLC, Accuracy.FULL}
+        for mode, model, workload in _FOUR_QUARK_CONTRACTED_PLANES
+    } | {
+        (Accuracy.FULL, 6, mode, model, workload)
+        for mode, model, workload in _FOUR_QUARK_UFO_FULL_PLANES
+    }
+    if actual_non_lc != expected_non_lc or len(non_lc) != 10:
+        raise CatalogStructuralScopeError(
+            "four-quark contracted candidate-only structural proof coverage "
+            "is incomplete"
+        )
+    lc = [
+        cell for cell in four_quark if cell.measurement.accuracy is Accuracy.LC
+    ]
+    actual_lc = {
+        (
+            cell.n_final,
+            cell.measurement.execution_mode,
+            cell.measurement.model,
+            cell.workload,
+        )
+        for cell in lc
+    }
+    expected_lc = {
+        (n_final, mode, model, workload)
+        for n_final in (6, 7, 8, 9)
+        for mode, model, workload in _FOUR_QUARK_LC_PLANES
+    }
+    if actual_lc != expected_lc or len(lc) != 32:
+        raise CatalogStructuralScopeError(
+            "four-quark LC candidate-only structural proof coverage is incomplete"
+        )
+    if any(REPORT_CATALOG.legacy_reference_available(cell) for cell in four_quark):
+        raise CatalogStructuralScopeError(
+            "four-quark candidate-only cells unexpectedly have a legacy reference"
+        )
+    unavailable = [
+        cell
+        for cell in candidates
+        if not REPORT_CATALOG.legacy_reference_available(cell)
+    ]
+    if {cell.cell_id for cell in unavailable} != {
+        cell.cell_id for cell in four_quark
+    }:
+        raise CatalogStructuralScopeError(
+            "an unreviewed legacy-unavailable matrix class is present"
+        )
+    return REVIEWED_MATRIX_SCOPE
+
+
+__all__ = [
+    "REVIEWED_MATRIX_SCOPE",
+    "REVIEW_ID",
+    "SCHEMA",
+    "CatalogStructuralScopeError",
+    "validate_reviewed_matrix_scope",
+]
diff --git a/pyamplicol/tools/developer/compiled_all_jit_arena_gate.py b/pyamplicol/tools/developer/compiled_all_jit_arena_gate.py
new file mode 100644
index 0000000000..a0fadf7ca0
--- /dev/null
+++ b/pyamplicol/tools/developer/compiled_all_jit_arena_gate.py
@@ -0,0 +1,1887 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""End-to-end compiled Direct-Arena gate for every JIT optimization level.
+
+The gate generates four independent ``g g > g g`` artifacts, one for each
+supported JIT source optimization level (O0, O1, O2, and O3).  Every artifact
+must be built and evaluated by a candidate installed from the exact clean
+source revision.  The gate then:
+
+* authenticates every artifact payload and the native loader's artifact ID;
+* recursively requires ``compiled-plane-arena-v1`` for every fused stage;
+* requires every source and Direct-Arena leaf to retain the requested JIT
+  optimization level;
+* rejects DirectApplication metadata below every model-parameter evaluator;
+* evaluates deterministic physical points through native f64 and retained
+  precision-32 execution;
+* compares ``evaluate()`` with ``evaluate_resolved().total()``;
+* compares totals and resolved components pointwise across O0/O1/O2/O3; and
+* when profiling is exposed, requires nonzero Direct-Arena backend calls and
+  zero legacy pack/gather/scatter/remap traffic.
+
+Run this only from a clean, exact-source candidate.  The outer 30 GiB watchdog
+is mandatory and covers this process plus every generation worker:
+
+```
+.venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 -- \
+  .venv/bin/python tools/developer/compiled_all_jit_arena_gate.py \
+  --output-root /private/tmp/pyamplicol-compiled-all-jit-arena-gate
+```
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib
+import importlib.machinery
+import json
+import math
+import os
+import platform
+import re
+import resource
+import shutil
+import stat
+import subprocess
+import sys
+import sysconfig
+import tempfile
+import time
+import tomllib
+import uuid
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+_EXACT_REEXEC_MARKER = "PYAMPLICOL_EXACT_PYTHON_REEXEC"
+_EXACT_IMPORT_PATHS = "PYAMPLICOL_EXACT_IMPORT_PATHS"
+
+
+def _bootstrap_source_only_python() -> None:
+    """Re-exec before importing any repository or candidate module."""
+
+    if os.environ.get(_EXACT_REEXEC_MARKER) == "1":
+        if (
+            sys.flags.isolated != 1
+            or sys.flags.no_site != 1
+            or sys.flags.ignore_environment != 1
+            or sys.flags.dont_write_bytecode != 1
+            or not sys.dont_write_bytecode
+        ):
+            raise RuntimeError("exact Python re-exec flags are incomplete")
+        raw_paths = json.loads(os.environ[_EXACT_IMPORT_PATHS])
+        if not isinstance(raw_paths, list) or not all(
+            isinstance(path, str) and Path(path).is_absolute() for path in raw_paths
+        ):
+            raise RuntimeError("exact Python import paths are invalid")
+        cache_prefix = os.environ.get("PYTHONPYCACHEPREFIX")
+        if (
+            not isinstance(cache_prefix, str)
+            or not Path(cache_prefix).is_absolute()
+            or Path(cache_prefix).exists()
+        ):
+            raise RuntimeError("exact Python cache prefix is not absent")
+        for import_path in reversed(raw_paths):
+            if import_path not in sys.path:
+                sys.path.insert(0, import_path)
+        sys.pycache_prefix = cache_prefix
+        return
+
+    prefix = Path(tempfile.gettempdir()) / (
+        f".pyamplicol-no-bytecode-{os.getpid()}-{uuid.uuid4().hex}"
+    )
+    if prefix.exists():
+        raise RuntimeError(
+            f"isolated Python cache prefix unexpectedly exists: {prefix}"
+        )
+    import_paths: list[str] = []
+    native_root = next(
+        (
+            candidate
+            for entry in sys.path
+            if (candidate := Path(entry) / "pyamplicol").is_dir()
+            and any(
+                path.is_file()
+                and path.name.startswith("_rusticol")
+                and path.name.endswith(tuple(importlib.machinery.EXTENSION_SUFFIXES))
+                for path in candidate.iterdir()
+            )
+        ),
+        None,
+    )
+    if native_root is not None:
+        import_paths.append(str(native_root.parent.resolve(strict=True)))
+    for scheme_name in ("purelib", "platlib"):
+        scheme_path = sysconfig.get_path(scheme_name)
+        if not isinstance(scheme_path, str):
+            continue
+        try:
+            resolved = str(Path(scheme_path).resolve(strict=True))
+        except OSError:
+            continue
+        if resolved not in import_paths:
+            import_paths.append(resolved)
+    environment = os.environ.copy()
+    environment["PYTHONDONTWRITEBYTECODE"] = "1"
+    environment["PYTHONPYCACHEPREFIX"] = str(prefix)
+    environment[_EXACT_REEXEC_MARKER] = "1"
+    environment[_EXACT_IMPORT_PATHS] = json.dumps(import_paths)
+    os.execve(
+        sys.executable,
+        (
+            sys.executable,
+            "-I",
+            "-S",
+            "-B",
+            str(Path(__file__).resolve(strict=True)),
+            *sys.argv[1:],
+        ),
+        environment,
+    )
+    raise RuntimeError("exact Python re-exec returned unexpectedly")
+
+
+if __name__ == "__main__":
+    _bootstrap_source_only_python()
+
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.performance_report.runtime_evidence import (  # noqa: E402
+    RuntimeEvidenceError,
+    established_preimport_runtime_identity,
+    loaded_pyamplicol_origin_policy,
+    native_extension_in_package,
+    preimport_python_runtime_identity,
+    python_package_tree_identity,
+    source_only_bytecode_policy,
+)
+
+PROCESS = "g g > g g"
+EXPECTED_EXTERNAL_PDGS = (21, 21, 21, 21)
+JIT_LEVELS = (0, 1, 2, 3)
+POINT_SEEDS = (846_731, 846_739, 846_763)
+VALIDATION_SEED = 20260725
+SQRT_S = 1_000.0
+RELATIVE_TOLERANCE = 1.0e-12
+ABSOLUTE_TOLERANCE = 1.0e-15
+COMPILED_PLANE_ARENA_CAPABILITY = "compiled-plane-arena-v1"
+COMPILED_PLANE_DIRECT_APPLICATION_ABI = "pyamplicol-compiled-plane-kernel-v2"
+NATIVE_COMPILED_DIRECT_APPLICATION_ABI = (
+    "pyamplicol-native-compiled-direct-application-v1"
+)
+SYMJIT_APPLICATION_ABI = "symjit-application-storage-v3"
+SYMJIT_PLANE_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+SYMJIT_RUNTIME_CAPABILITY = "symjit.application.complex-f64.v1"
+RESULT_KIND = "pyamplicol-compiled-all-jit-direct-arena-gate"
+SCHEMA_VERSION = 1
+HASH_CHUNK_BYTES = 1024 * 1024
+REVISION_PATTERN = re.compile(r"[0-9a-f]{40}")
+SHA256_PATTERN = re.compile(r"[0-9a-f]{64}")
+WATCHDOG_INVOCATION = (
+    ".venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 -- "
+    ".venv/bin/python tools/developer/compiled_all_jit_arena_gate.py "
+    "--output-root /private/tmp/pyamplicol-compiled-all-jit-arena-gate"
+)
+
+_ZERO_PROFILE_COUNTERS = (
+    "stage_input_copy_component_count",
+    "stage_leaf_input_copy_component_count",
+    "stage_evaluator_output_gather_component_count",
+    "stage_output_assign_component_count",
+    "amplitude_input_copy_component_count",
+    "amplitude_leaf_input_copy_component_count",
+    "amplitude_evaluator_output_gather_component_count",
+    "amplitude_output_remap_component_count",
+    "selector_gather_point_count",
+    "selector_gather_bytes",
+    "selector_scatter_value_count",
+    "compiled_direct_arena_boundary_input_bytes",
+    "compiled_direct_arena_boundary_current_output_bytes",
+    "compiled_direct_arena_boundary_amplitude_output_bytes",
+)
+_ZERO_PROFILE_TIMES = (
+    "stage_input_pack_time_s",
+    "stage_leaf_input_pack_time_s",
+    "stage_evaluator_output_gather_time_s",
+    "output_assign_time_s",
+    "amplitude_input_pack_time_s",
+    "amplitude_leaf_input_pack_time_s",
+    "amplitude_evaluator_output_gather_time_s",
+    "amplitude_output_remap_time_s",
+    "selector_gather_time_s",
+    "selector_scatter_time_s",
+)
+_DIRECT_ENGINE_COUNTER = "compiled_direct_arena_engine_count"
+_DIRECT_CALL_COUNTER = "compiled_direct_arena_call_count"
+
+
+class GateError(RuntimeError):
+    """Raised when all-JIT Direct-Arena evidence cannot be trusted."""
+
+
+@dataclass(slots=True)
+class EvaluationCapture:
+    """Non-serializable values retained for cross-level comparisons."""
+
+    physics_axes: dict[str, object]
+    f64_total: tuple[complex, ...]
+    precision32_total: tuple[complex, ...]
+    f64_components: tuple[complex, ...]
+    precision32_components: tuple[complex, ...]
+
+
+def _canonical_json(value: object) -> bytes:
+    try:
+        return json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("utf-8")
+    except (TypeError, ValueError) as error:
+        raise GateError("evidence is not canonical JSON") from error
+
+
+def _canonical_sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_json(value)).hexdigest()
+
+
+def _regular_file_identity(
+    path: Path,
+    *,
+    aggregate: Any | None = None,
+    tree_relative: bytes | None = None,
+) -> tuple[int, str]:
+    """Hash one stable regular file through one no-follow descriptor."""
+
+    flags = (
+        os.O_RDONLY
+        | getattr(os, "O_CLOEXEC", 0)
+        | getattr(os, "O_NOFOLLOW", 0)
+        | getattr(os, "O_BINARY", 0)
+    )
+    digest = hashlib.sha256()
+    descriptor: int | None = None
+    try:
+        descriptor = os.open(path, flags)
+        before = os.fstat(descriptor)
+        if not stat.S_ISREG(before.st_mode):
+            raise GateError(f"identity target is not a regular file: {path}")
+        if aggregate is not None:
+            if tree_relative is None:
+                raise GateError("tree hashing requires a relative path")
+            aggregate.update(len(tree_relative).to_bytes(8, "big"))
+            aggregate.update(tree_relative)
+            aggregate.update(before.st_size.to_bytes(8, "big"))
+        byte_count = 0
+        with os.fdopen(descriptor, "rb", closefd=True) as stream:
+            descriptor = None
+            while block := stream.read(HASH_CHUNK_BYTES):
+                digest.update(block)
+                if aggregate is not None:
+                    aggregate.update(block)
+                byte_count += len(block)
+            after = os.fstat(stream.fileno())
+    except OSError as error:
+        raise GateError(
+            f"cannot hash regular file through a checked fd: {path}"
+        ) from error
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+    stable_fields = (
+        "st_dev",
+        "st_ino",
+        "st_mode",
+        "st_size",
+        "st_mtime_ns",
+        "st_ctime_ns",
+    )
+    if byte_count != before.st_size or any(
+        getattr(before, name) != getattr(after, name) for name in stable_fields
+    ):
+        raise GateError(f"identity target changed while it was hashed: {path}")
+    return byte_count, digest.hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    return _regular_file_identity(path)[1]
+
+
+def _file_identity(path: Path) -> dict[str, object]:
+    try:
+        resolved = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise GateError(f"cannot identify file: {path}") from error
+    size, sha256 = _regular_file_identity(resolved)
+    return {
+        "path": str(resolved),
+        "size_bytes": size,
+        "sha256": sha256,
+    }
+
+
+def _tree_identity(path: Path) -> dict[str, object]:
+    """Hash relative names, sizes, and contents for a relocatable tree ID."""
+
+    try:
+        root = path.expanduser().resolve(strict=True)
+        candidates = list(root.rglob("*"))
+    except OSError as error:
+        raise GateError(f"cannot inspect identity tree: {path}") from error
+    if not root.is_dir():
+        raise GateError(f"identity target is not a directory: {root}")
+    for candidate in candidates:
+        if candidate.is_symlink():
+            raise GateError(
+                f"identity tree contains an unsupported symlink: {candidate}"
+            )
+    members = sorted(
+        (candidate for candidate in candidates if candidate.is_file()),
+        key=lambda candidate: candidate.relative_to(root).as_posix(),
+    )
+    digest = hashlib.sha256()
+    size_bytes = 0
+    try:
+        for member in members:
+            relative = member.relative_to(root).as_posix().encode("utf-8")
+            size, _ = _regular_file_identity(
+                member,
+                aggregate=digest,
+                tree_relative=relative,
+            )
+            size_bytes += size
+    except OSError as error:
+        raise GateError(f"cannot hash identity tree: {root}") from error
+    return {
+        "algorithm": "sha256-relative-path-size-content-v1",
+        "sha256": digest.hexdigest(),
+        "file_count": len(members),
+        "size_bytes": size_bytes,
+    }
+
+
+def _python_package_tree_identity(path: Path) -> dict[str, object]:
+    try:
+        return python_package_tree_identity(path)
+    except RuntimeEvidenceError as error:
+        raise GateError(str(error)) from error
+
+
+def _ensure_source_only_python() -> None:
+    """Verify the stdlib-only bootstrap completed before repository imports."""
+
+    try:
+        source_only_bytecode_policy()
+    except RuntimeEvidenceError as error:
+        raise GateError(
+            "source-only Python bootstrap did not complete before gate imports"
+        ) from error
+
+
+def _establish_preimport_runtime_identity() -> None:
+    native_root = next(
+        (
+            candidate
+            for entry in sys.path
+            if (candidate := Path(entry) / "pyamplicol").is_dir()
+            and any(
+                path.name.startswith("_rusticol")
+                and path.name.endswith(tuple(importlib.machinery.EXTENSION_SUFFIXES))
+                for path in candidate.iterdir()
+            )
+        ),
+        None,
+    )
+    if native_root is None:
+        raise GateError("candidate Python path has no native pyamplicol package")
+    native = native_extension_in_package(native_root)
+    preimport_python_runtime_identity((native_root,), native_extension=native)
+
+
+def _json_object(path: Path, *, label: str) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise GateError(f"cannot read {label}: {path}") from error
+    if not isinstance(value, dict):
+        raise GateError(f"{label} must be a JSON object: {path}")
+    return value
+
+
+def _mapping(value: object, *, label: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise GateError(f"{label} must be an object")
+    return value
+
+
+def _sequence(value: object, *, label: str) -> Sequence[Any]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise GateError(f"{label} must be an array")
+    return value
+
+
+def _safe_relative_path(value: object, *, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise GateError(f"{label} must be a non-empty path")
+    path = Path(value)
+    if path.is_absolute() or ".." in path.parts:
+        raise GateError(f"{label} must be artifact-relative")
+    return value
+
+
+def _git_output(arguments: Sequence[str]) -> str:
+    completed = subprocess.run(
+        ("git", *arguments),
+        cwd=ROOT,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or completed.stdout.strip()
+        raise GateError(f"git {' '.join(arguments)} failed: {detail}")
+    return completed.stdout.strip()
+
+
+def _source_identity() -> dict[str, object]:
+    revision = _git_output(("rev-parse", "--verify", "HEAD"))
+    if REVISION_PATTERN.fullmatch(revision) is None:
+        raise GateError("source checkout has no full Git revision")
+    status = _git_output(("status", "--porcelain=v1", "--untracked-files=all"))
+    if status:
+        raise GateError(
+            "source checkout is dirty; build and run the gate from one committed SHA"
+        )
+    return {
+        "checkout": str(ROOT.resolve(strict=True)),
+        "revision": revision,
+        "dirty": False,
+        "untracked_files_checked": True,
+    }
+
+
+def _runtime_identity(source: Mapping[str, object]) -> dict[str, object]:
+    try:
+        pyamplicol = importlib.import_module("pyamplicol")
+        native = importlib.import_module("pyamplicol._rusticol")
+        versions = importlib.import_module("pyamplicol._internal.versions")
+    except ImportError as error:
+        raise GateError(
+            "the candidate pyamplicol native runtime is unavailable"
+        ) from error
+    native_path_raw = getattr(native, "__file__", None)
+    if not isinstance(native_path_raw, str):
+        raise GateError("native extension has no filesystem path")
+    native_digest_function = getattr(native, "native_build_inputs_sha256", None)
+    if not callable(native_digest_function):
+        raise GateError("native extension exposes no build-input digest")
+    native_digest = native_digest_function()
+    if (
+        not isinstance(native_digest, str)
+        or SHA256_PATTERN.fullmatch(native_digest) is None
+    ):
+        raise GateError("native extension build-input digest is invalid")
+    build_info_function = getattr(versions, "_active_build_info", None)
+    build_info = build_info_function() if callable(build_info_function) else None
+    if not isinstance(build_info, Mapping):
+        raise GateError("candidate exposes no strict build provenance")
+    if build_info.get("source_revision") != source.get("revision"):
+        raise GateError(
+            "candidate native runtime was built from another source revision"
+        )
+    if build_info.get("native_build_inputs_sha256") != native_digest:
+        raise GateError("candidate build info and native build inputs disagree")
+    checkout = build_info.get("source_checkout")
+    if not isinstance(checkout, str):
+        raise GateError("candidate build info has no source checkout")
+    try:
+        bound_checkout = Path(checkout).expanduser().resolve(strict=True)
+    except OSError as error:
+        raise GateError("candidate source checkout is unavailable") from error
+    if bound_checkout != ROOT.resolve(strict=True):
+        raise GateError("candidate was built from another source checkout")
+    package_path_raw = getattr(pyamplicol, "__file__", None)
+    if not isinstance(package_path_raw, str):
+        raise GateError("pyamplicol package has no filesystem identity")
+    package_roots = tuple(Path(str(path)) for path in pyamplicol.__path__)
+    preimport_identity = established_preimport_runtime_identity()
+    return {
+        "interpreter": {
+            **_file_identity(Path(sys.executable)),
+            "python_version": platform.python_version(),
+            "implementation": platform.python_implementation(),
+        },
+        "package": {
+            **_file_identity(Path(package_path_raw)),
+            "version": str(getattr(pyamplicol, "__version__", "")),
+        },
+        "python_package_tree": _python_package_tree_identity(package_roots),
+        "loaded_module_origin_policy": loaded_pyamplicol_origin_policy(
+            package_roots,
+            native_extension=Path(native_path_raw),
+            expected_package_identity=preimport_identity["python_package_tree"],
+            expected_native_identity=preimport_identity["native_extension"],
+        ),
+        "native_extension": {
+            **_file_identity(Path(native_path_raw)),
+            "build_inputs_sha256": native_digest,
+        },
+        "active_build_info": {
+            "payload": dict(build_info),
+            "canonical_sha256": _canonical_sha256(build_info),
+        },
+    }
+
+
+def _stable_runtime_identity(value: Mapping[str, object]) -> dict[str, object]:
+    """Exclude only the monotonically growing loaded-module observation set."""
+
+    stable = dict(value)
+    raw_policy = stable.get("loaded_module_origin_policy")
+    if isinstance(raw_policy, Mapping):
+        policy = dict(raw_policy)
+        for field in (
+            "observed_module_count",
+            "observations",
+            "observations_sha256",
+        ):
+            policy.pop(field, None)
+        stable["loaded_module_origin_policy"] = policy
+    return stable
+
+
+def _runtime_identity_sha256(value: Mapping[str, object]) -> str:
+    return _canonical_sha256(_stable_runtime_identity(value))
+
+
+def _peak_rss_gib() -> float:
+    raw = float(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
+    divisor = float(1024**3 if platform.system() == "Darwin" else 1024**2)
+    return raw / divisor
+
+
+def _generation_worker(
+    artifact: Path,
+    optimization_level: int,
+    expected_revision: str,
+    expected_script_sha256: str,
+) -> dict[str, object]:
+    source = _source_identity()
+    if source["revision"] != expected_revision:
+        raise GateError("generation worker source revision changed")
+    script = _file_identity(Path(__file__))
+    if script["sha256"] != expected_script_sha256:
+        raise GateError("generation worker gate script identity changed")
+    runtime = _runtime_identity(source)
+
+    from pyamplicol import Generator
+    from pyamplicol.config import (
+        ColorConfig,
+        EvaluatorConfig,
+        EvaluatorOptimizationConfig,
+        GenerationConfig,
+        GenerationValidationConfig,
+        JITConfig,
+        OutputConfig,
+        RunConfig,
+    )
+
+    run = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc", lc_flow_layout="topology-replay"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=True,
+                samples=2,
+                seed=VALIDATION_SEED,
+                relative_tolerance=RELATIVE_TOLERANCE,
+                absolute_tolerance=ABSOLUTE_TOLERANCE,
+                post_build_validation=True,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            backend="jit",
+            execution_mode="compiled",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=optimization_level),
+        ),
+        output=OutputConfig(format="json", color="never", progress="off"),
+    )
+    started_wall = time.monotonic()
+    started_cpu = time.process_time()
+    result = Generator(run).generate(PROCESS, artifact, mode="error")
+    source_postflight = _source_identity()
+    runtime_postflight = _runtime_identity(source_postflight)
+    script_postflight = _file_identity(Path(__file__))
+    if source_postflight != source:
+        raise GateError("generation worker source identity changed during generation")
+    if _stable_runtime_identity(runtime_postflight) != _stable_runtime_identity(
+        runtime
+    ):
+        raise GateError("generation worker runtime identity changed during generation")
+    if script_postflight != script:
+        raise GateError("generation worker script identity changed during generation")
+    return {
+        "optimization_level": optimization_level,
+        "artifact": str(result.output),
+        "process_ids": [process.name for process in result.processes.requests],
+        "worker_provenance": {
+            "source_revision": source["revision"],
+            "runtime_identity_sha256": _runtime_identity_sha256(runtime),
+            "native_extension_sha256": runtime["native_extension"]["sha256"],
+            "native_build_inputs_sha256": runtime["native_extension"][
+                "build_inputs_sha256"
+            ],
+            "gate_script_sha256": script["sha256"],
+            "postflight_identity_match": True,
+        },
+        "generation": {
+            "wall_seconds": time.monotonic() - started_wall,
+            "process_cpu_seconds": time.process_time() - started_cpu,
+            "worker_peak_rss_gib": _peak_rss_gib(),
+            "workers": 1,
+            "validation_samples": 2,
+            "validation_seed": VALIDATION_SEED,
+            "post_build_validation": True,
+        },
+    }
+
+
+def _worker_command(
+    artifact: Path,
+    optimization_level: int,
+    expected_revision: str,
+    expected_script_sha256: str,
+) -> tuple[str, ...]:
+    return (
+        sys.executable,
+        "-I",
+        "-S",
+        "-B",
+        str(Path(__file__).resolve()),
+        "--_generate-one",
+        "--artifact",
+        str(artifact),
+        "--jit-level",
+        str(optimization_level),
+        "--expected-revision",
+        expected_revision,
+        "--expected-script-sha256",
+        expected_script_sha256,
+    )
+
+
+def _invoke_generation_worker(
+    artifact: Path,
+    optimization_level: int,
+    expected_revision: str,
+    expected_script_sha256: str,
+    *,
+    timeout: float,
+) -> dict[str, object]:
+    command = _worker_command(
+        artifact,
+        optimization_level,
+        expected_revision,
+        expected_script_sha256,
+    )
+    started = time.monotonic()
+    try:
+        completed = subprocess.run(
+            command,
+            cwd=ROOT,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired as error:
+        raise GateError(
+            f"JIT O{optimization_level} generation exceeded {timeout:.1f} seconds"
+        ) from error
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or completed.stdout.strip()
+        raise GateError(
+            f"JIT O{optimization_level} generation failed:\n{detail[-6000:]}"
+        )
+    try:
+        payload = json.loads(completed.stdout)
+    except json.JSONDecodeError as error:
+        raise GateError(
+            f"JIT O{optimization_level} worker emitted invalid JSON"
+        ) from error
+    if (
+        not isinstance(payload, dict)
+        or payload.get("optimization_level") != optimization_level
+    ):
+        raise GateError(f"JIT O{optimization_level} worker returned the wrong level")
+    payload["orchestration_wall_seconds"] = time.monotonic() - started
+    payload["command"] = {
+        "argv": list(command),
+        "canonical_sha256": _canonical_sha256(list(command)),
+    }
+    if completed.stderr.strip():
+        payload["worker_stderr_sha256"] = hashlib.sha256(
+            completed.stderr.encode()
+        ).hexdigest()
+    return payload
+
+
+def _walk_mappings(
+    value: object,
+    *,
+    path: tuple[str, ...] = (),
+) -> Iterable[tuple[tuple[str, ...], Mapping[str, Any]]]:
+    if isinstance(value, Mapping):
+        yield path, value
+        for name, child in value.items():
+            yield from _walk_mappings(child, path=(*path, str(name)))
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        for index, child in enumerate(value):
+            yield from _walk_mappings(child, path=(*path, str(index)))
+
+
+def _source_evaluator_leaves(
+    evaluator: Mapping[str, Any],
+    *,
+    label: str,
+) -> list[Mapping[str, Any]]:
+    kind = evaluator.get("kind")
+    if kind == "symjit-application-evaluator":
+        return [evaluator]
+    if kind != "chunked-symbolica-evaluator":
+        raise GateError(f"{label} has unsupported evaluator kind {kind!r}")
+    chunks = _sequence(evaluator.get("chunks"), label=f"{label}.chunks")
+    leaves: list[Mapping[str, Any]] = []
+    for index, raw_chunk in enumerate(chunks):
+        chunk = _mapping(raw_chunk, label=f"{label}.chunks[{index}]")
+        leaves.extend(
+            _source_evaluator_leaves(
+                chunk,
+                label=f"{label}.chunks[{index}]",
+            )
+        )
+    if not leaves:
+        raise GateError(f"{label} has no evaluator leaves")
+    return leaves
+
+
+def _assert_model_parameter_not_direct(value: object, *, label: str) -> None:
+    if isinstance(value, Mapping):
+        if value.get("kind") == "compiled-plane-arena-stage":
+            raise GateError(
+                f"{label} illegally uses a compiled plane DirectApplication"
+            )
+        if "compiled_plane_arena" in value or "native_direct_application" in value:
+            raise GateError(f"{label} illegally carries DirectApplication metadata")
+        if value.get("application_abi") in {
+            COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+            NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+        }:
+            raise GateError(f"{label} illegally uses the direct application ABI")
+        for name, child in value.items():
+            _assert_model_parameter_not_direct(child, label=f"{label}.{name}")
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        for index, child in enumerate(value):
+            _assert_model_parameter_not_direct(child, label=f"{label}[{index}]")
+
+
+def _audit_direct_descriptor(
+    descriptor: Mapping[str, Any],
+    *,
+    stage: Mapping[str, Any],
+    optimization_level: int,
+    label: str,
+) -> dict[str, int]:
+    if descriptor.get("kind") != "compiled-plane-arena-stage":
+        raise GateError(f"{label}.compiled_plane_arena has the wrong kind")
+    if descriptor.get("schema_version") != 1:
+        raise GateError(f"{label}.compiled_plane_arena has the wrong schema")
+    expected_scalars = {
+        "application_abi": COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+        "source_application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+        "element_layout": "split-complex-component-major",
+        "input_output_aliasing": "forbidden",
+        "output_output_aliasing": "forbidden",
+        "output_operation": "overwrite",
+        "output_factor": "identity",
+    }
+    for name, expected in expected_scalars.items():
+        if descriptor.get(name) != expected:
+            raise GateError(f"{label}.compiled_plane_arena.{name} is not {expected!r}")
+
+    inputs = _sequence(
+        descriptor.get("input_bindings"),
+        label=f"{label}.compiled_plane_arena.input_bindings",
+    )
+    if [
+        _mapping(item, label=f"{label}.input_bindings[{index}]").get("parameter_index")
+        for index, item in enumerate(inputs)
+    ] != list(range(len(inputs))):
+        raise GateError(f"{label} Direct-Arena input bindings are not contiguous")
+
+    outputs = _sequence(
+        descriptor.get("output_bindings"),
+        label=f"{label}.compiled_plane_arena.output_bindings",
+    )
+    if [
+        _mapping(item, label=f"{label}.output_bindings[{index}]").get("output_index")
+        for index, item in enumerate(outputs)
+    ] != list(range(len(outputs))):
+        raise GateError(f"{label} Direct-Arena output bindings are not contiguous")
+
+    evaluator = _mapping(stage.get("evaluator"), label=f"{label}.evaluator")
+    source_leaves = _source_evaluator_leaves(evaluator, label=f"{label}.evaluator")
+    direct_leaves = _sequence(
+        descriptor.get("leaves"),
+        label=f"{label}.compiled_plane_arena.leaves",
+    )
+    if len(direct_leaves) != len(source_leaves) or not direct_leaves:
+        raise GateError(f"{label} Direct-Arena/source leaf counts disagree")
+
+    output_cursor = 0
+    for index, (direct_raw, source) in enumerate(
+        zip(direct_leaves, source_leaves, strict=True)
+    ):
+        direct = _mapping(direct_raw, label=f"{label}.leaves[{index}]")
+        if (
+            source.get("application_abi") != SYMJIT_APPLICATION_ABI
+            or source.get("runtime_capability") != SYMJIT_RUNTIME_CAPABILITY
+        ):
+            raise GateError(
+                f"{label} ordinary SymJIT fallback leaf identity is inconsistent"
+            )
+        _safe_relative_path(
+            source.get("application_path"),
+            label=f"{label}.source_leaves[{index}].application_path",
+        )
+        plane = _mapping(
+            source.get("plane_application"),
+            label=f"{label}.source_leaves[{index}].plane_application",
+        )
+        source_path = _safe_relative_path(
+            plane.get("application_path"),
+            label=(
+                f"{label}.source_leaves[{index}].plane_application.application_path"
+            ),
+        )
+        if (
+            direct.get("application_path") != source_path
+            or direct.get("source_application_abi")
+            != SYMJIT_PLANE_APPLICATION_ABI
+            or plane.get("application_abi") != SYMJIT_PLANE_APPLICATION_ABI
+            or plane.get("storage_abi") != SYMJIT_APPLICATION_ABI
+            or plane.get("translation_mode")
+            != "symbolica-structured-instructions"
+            or plane.get("direct_arena") is not True
+            or not isinstance(plane.get("source_digest"), str)
+            or SHA256_PATTERN.fullmatch(str(plane.get("source_digest"))) is None
+        ):
+            raise GateError(f"{label} Direct-Arena leaf identity is inconsistent")
+        if (
+            direct.get("optimization_level") != optimization_level
+            or source.get("optimization_level") != optimization_level
+            or plane.get("optimization_level") != optimization_level
+        ):
+            raise GateError(
+                f"{label} Direct-Arena/source leaf does not retain JIT "
+                f"O{optimization_level}"
+            )
+        if direct.get("direct_codegen_optimization_level") != optimization_level:
+            raise GateError(
+                f"{label} Direct-Arena leaf direct codegen does not match its "
+                "plane application"
+            )
+        indices = _sequence(
+            direct.get("input_indices"),
+            label=f"{label}.leaves[{index}].input_indices",
+        )
+        if (
+            any(
+                isinstance(value, bool) or not isinstance(value, int) or value < 0
+                for value in indices
+            )
+            or len(indices) != direct.get("input_len")
+            or len(indices) != source.get("input_len")
+        ):
+            raise GateError(f"{label} Direct-Arena leaf inputs are invalid")
+        output_start = direct.get("output_start")
+        output_stop = direct.get("output_stop")
+        output_len = direct.get("output_len")
+        if (
+            output_start != output_cursor
+            or isinstance(output_stop, bool)
+            or not isinstance(output_stop, int)
+            or isinstance(output_len, bool)
+            or not isinstance(output_len, int)
+            or output_stop - output_start != output_len
+            or output_len != source.get("output_len")
+        ):
+            raise GateError(f"{label} Direct-Arena leaf outputs are invalid")
+        output_cursor = output_stop
+    if output_cursor != len(outputs) or output_cursor != stage.get("output_length"):
+        raise GateError(f"{label} Direct-Arena leaves do not cover stage outputs")
+    return {
+        "leaf_count": len(direct_leaves),
+        "input_binding_count": len(inputs),
+        "output_binding_count": len(outputs),
+    }
+
+
+def _audit_execution_payload(
+    payload: Mapping[str, Any],
+    optimization_level: int,
+) -> dict[str, object]:
+    capability_declarations = 0
+    stage_set_count = 0
+    stage_count = 0
+    descriptor_count = 0
+    leaf_count = 0
+    model_parameter_slot_count = 0
+    model_parameter_evaluator_count = 0
+    audited_stage_sets: list[dict[str, object]] = []
+    for path, record in _walk_mappings(payload):
+        label = ".".join(path) or "execution"
+        capabilities = record.get("required_runtime_capabilities")
+        if (
+            isinstance(capabilities, Sequence)
+            and not isinstance(capabilities, (str, bytes))
+            and COMPILED_PLANE_ARENA_CAPABILITY in capabilities
+        ):
+            capability_declarations += 1
+        if "model_parameter_evaluator" in record:
+            model_parameter_slot_count += 1
+            model_parameters = record["model_parameter_evaluator"]
+            if model_parameters is not None:
+                model_parameter_evaluator_count += 1
+                _assert_model_parameter_not_direct(
+                    model_parameters,
+                    label=f"{label}.model_parameter_evaluator",
+                )
+        if record.get("kind") != "generic-dag-stage-evaluator-artifacts":
+            continue
+
+        stage_set_count += 1
+        if record.get("runtime_available") is not True:
+            raise GateError(f"{label} compiled stage runtime is unavailable")
+        required = _sequence(
+            record.get("required_runtime_capabilities"),
+            label=f"{label}.required_runtime_capabilities",
+        )
+        if COMPILED_PLANE_ARENA_CAPABILITY not in required:
+            raise GateError(f"{label} does not require compiled-plane-arena-v1")
+        stages = list(_sequence(record.get("stages"), label=f"{label}.stages"))
+        amplitude = _mapping(
+            record.get("amplitude_stage"),
+            label=f"{label}.amplitude_stage",
+        )
+        all_stages = (*stages, amplitude)
+        if record.get("stage_count") != len(all_stages):
+            raise GateError(f"{label}.stage_count does not cover all stages")
+        set_leaf_count = 0
+        for index, raw_stage in enumerate(all_stages):
+            stage = _mapping(raw_stage, label=f"{label}.stages[{index}]")
+            descriptor = _mapping(
+                stage.get("compiled_plane_arena"),
+                label=f"{label}.stages[{index}].compiled_plane_arena",
+            )
+            counts = _audit_direct_descriptor(
+                descriptor,
+                stage=stage,
+                optimization_level=optimization_level,
+                label=f"{label}.stages[{index}]",
+            )
+            stage_count += 1
+            descriptor_count += 1
+            leaf_count += counts["leaf_count"]
+            set_leaf_count += counts["leaf_count"]
+        audited_stage_sets.append(
+            {
+                "path": label,
+                "stage_count": len(all_stages),
+                "leaf_count": set_leaf_count,
+                "source_optimization_level": optimization_level,
+            }
+        )
+    if capability_declarations < 1:
+        raise GateError("execution payload does not declare compiled-plane-arena-v1")
+    if stage_set_count < 1 or descriptor_count < 1 or leaf_count < 1:
+        raise GateError("execution payload has no complete Direct-Arena stage set")
+    if model_parameter_slot_count < 1:
+        raise GateError("execution payload has no model-parameter evaluator slot")
+    return {
+        "capability": COMPILED_PLANE_ARENA_CAPABILITY,
+        "source_optimization_level": optimization_level,
+        "capability_declaration_count": capability_declarations,
+        "stage_set_count": stage_set_count,
+        "stage_count": stage_count,
+        "descriptor_count": descriptor_count,
+        "leaf_count": leaf_count,
+        "model_parameter_slot_count": model_parameter_slot_count,
+        "model_parameter_evaluator_count": model_parameter_evaluator_count,
+        "model_parameter_direct_application_count": 0,
+        "stage_sets": audited_stage_sets,
+        "passes": True,
+    }
+
+
+def _artifact_identity_and_audit(
+    artifact: Path,
+    optimization_level: int,
+) -> tuple[dict[str, object], str]:
+    manifest_path = artifact / "artifact.json"
+    manifest = _json_object(manifest_path, label="artifact manifest")
+    artifact_id = manifest.get("artifact_id")
+    if (
+        not isinstance(artifact_id, str)
+        or SHA256_PATTERN.fullmatch(artifact_id) is None
+    ):
+        raise GateError(f"JIT O{optimization_level} artifact ID is invalid")
+    processes = _sequence(manifest.get("processes"), label="artifact.processes")
+    if len(processes) != 1:
+        raise GateError(
+            f"JIT O{optimization_level} artifact must contain exactly one process"
+        )
+    process = _mapping(processes[0], label="artifact.processes[0]")
+    if process.get("expression") != PROCESS:
+        raise GateError(f"JIT O{optimization_level} artifact has the wrong process")
+    if tuple(process.get("external_pdgs", ())) != EXPECTED_EXTERNAL_PDGS:
+        raise GateError(f"JIT O{optimization_level} external PDGs drifted")
+    if process.get("color_accuracy") != "lc":
+        raise GateError(f"JIT O{optimization_level} color accuracy drifted")
+    capabilities = _sequence(
+        process.get("required_runtime_capabilities"),
+        label="artifact.processes[0].required_runtime_capabilities",
+    )
+    if COMPILED_PLANE_ARENA_CAPABILITY not in capabilities:
+        raise GateError(
+            f"JIT O{optimization_level} artifact lacks compiled-plane-arena-v1"
+        )
+    process_id = process.get("id")
+    if not isinstance(process_id, str) or not process_id:
+        raise GateError(f"JIT O{optimization_level} process ID is invalid")
+
+    try:
+        effective = tomllib.loads(
+            (artifact / "config" / "effective.toml").read_text(encoding="utf-8")
+        )
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        raise GateError(
+            f"JIT O{optimization_level} effective configuration is invalid"
+        ) from error
+    expected_config = (
+        (effective.get("color", {}).get("accuracy"), "lc"),
+        (
+            effective.get("color", {}).get("lc_flow_layout"),
+            "topology-replay",
+        ),
+        (effective.get("evaluator", {}).get("backend"), "jit"),
+        (effective.get("evaluator", {}).get("execution_mode"), "compiled"),
+        (
+            effective.get("evaluator", {}).get("jit", {}).get("optimization_level"),
+            optimization_level,
+        ),
+    )
+    if any(observed != expected for observed, expected in expected_config):
+        raise GateError(
+            f"JIT O{optimization_level} effective compiled configuration drifted"
+        )
+
+    payloads = _sequence(manifest.get("payloads"), label="artifact.payloads")
+    payload_bytes = 0
+    for index, raw_payload in enumerate(payloads):
+        payload = _mapping(raw_payload, label=f"artifact.payloads[{index}]")
+        relative = _safe_relative_path(
+            payload.get("path"),
+            label=f"artifact.payloads[{index}].path",
+        )
+        expected_size = payload.get("size_bytes")
+        expected_digest = payload.get("sha256")
+        path = artifact / relative
+        try:
+            size = path.stat().st_size
+        except OSError as error:
+            raise GateError(
+                f"JIT O{optimization_level} payload is missing: {relative}"
+            ) from error
+        if (
+            isinstance(expected_size, bool)
+            or not isinstance(expected_size, int)
+            or size != expected_size
+            or not isinstance(expected_digest, str)
+            or _sha256_file(path) != expected_digest
+        ):
+            raise GateError(
+                f"JIT O{optimization_level} payload identity failed: {relative}"
+            )
+        payload_bytes += size
+
+    execution_path = artifact / "processes" / process_id / "execution.json"
+    execution = _json_object(execution_path, label="process execution")
+    if execution.get("color_accuracy") != "lc":
+        raise GateError(f"JIT O{optimization_level} execution color drifted")
+    arena_audit = _audit_execution_payload(execution, optimization_level)
+    return (
+        {
+            "path": str(artifact.resolve(strict=True)),
+            "artifact_id": artifact_id,
+            "manifest": _file_identity(manifest_path),
+            "tree": _tree_identity(artifact),
+            "payload_count": len(payloads),
+            "payload_bytes": payload_bytes,
+            "effective_configuration": {
+                "process": PROCESS,
+                "color_accuracy": "lc",
+                "lc_flow_layout": "topology-replay",
+                "backend": "jit",
+                "execution_mode": "compiled",
+                "jit_optimization_level": optimization_level,
+            },
+            "direct_arena_audit": arena_audit,
+        },
+        process_id,
+    )
+
+
+def _deterministic_points(
+    count: int,
+) -> tuple[tuple[tuple[float, ...], ...], ...]:
+    from pyamplicol.generation.phase_space import massive_rambo_final_state
+
+    if count not in (2, 3):
+        raise GateError("the numerical gate requires exactly two or three points")
+    incoming = (
+        (SQRT_S / 2.0, 0.0, 0.0, SQRT_S / 2.0),
+        (SQRT_S / 2.0, 0.0, 0.0, -SQRT_S / 2.0),
+    )
+    return tuple(
+        (
+            *incoming,
+            *massive_rambo_final_state(
+                2,
+                sqrt_s=SQRT_S,
+                masses=(0.0, 0.0),
+                seed=seed,
+            ),
+        )
+        for seed in POINT_SEEDS[:count]
+    )
+
+
+def _points_identity(
+    points: Sequence[Sequence[Sequence[float]]],
+) -> dict[str, object]:
+    hexadecimal = [
+        [[float(component).hex() for component in momentum] for momentum in point]
+        for point in points
+    ]
+    maximum_conservation_residual = 0.0
+    maximum_mass_squared = 0.0
+    for point in points:
+        incoming = point[:2]
+        outgoing = point[2:]
+        for component in range(4):
+            residual = sum(momentum[component] for momentum in incoming) - sum(
+                momentum[component] for momentum in outgoing
+            )
+            maximum_conservation_residual = max(
+                maximum_conservation_residual,
+                float(abs(residual)),
+            )
+        for momentum in point:
+            mass_squared = momentum[0] ** 2 - sum(value**2 for value in momentum[1:])
+            maximum_mass_squared = max(
+                maximum_mass_squared,
+                float(abs(mass_squared)),
+            )
+    if maximum_conservation_residual > 1.0e-9 or maximum_mass_squared > 1.0e-8:
+        raise GateError("deterministic validation momenta are not physical")
+    return {
+        "algorithm": "sha256-float-hex-momenta-v1",
+        "sha256": _canonical_sha256(hexadecimal),
+        "point_count": len(points),
+        "external_particle_count": len(points[0]) if points else 0,
+        "maximum_momentum_conservation_residual": (maximum_conservation_residual),
+        "maximum_abs_mass_squared": maximum_mass_squared,
+    }
+
+
+def _as_complex(value: object) -> complex:
+    try:
+        result = complex(value)
+    except (TypeError, ValueError, OverflowError) as error:
+        raise GateError(
+            f"evaluation returned a non-numeric value: {value!r}"
+        ) from error
+    if not math.isfinite(result.real) or not math.isfinite(result.imag):
+        raise GateError("evaluation returned a non-finite value")
+    return result
+
+
+def _flatten_resolved(resolved: object) -> tuple[complex, ...]:
+    return tuple(
+        _as_complex(value)
+        for point in resolved.values
+        for helicity in point
+        for value in helicity
+    )
+
+
+def _comparison(
+    left: Sequence[complex],
+    right: Sequence[complex],
+    *,
+    label: str,
+) -> dict[str, object]:
+    if len(left) != len(right) or not left:
+        raise GateError(f"{label} vectors have incompatible or empty shapes")
+    maximum_absolute = 0.0
+    maximum_relative = 0.0
+    failing = 0
+    for left_value, right_value in zip(left, right, strict=True):
+        absolute = abs(left_value - right_value)
+        relative = absolute / max(
+            abs(left_value),
+            abs(right_value),
+            ABSOLUTE_TOLERANCE,
+        )
+        maximum_absolute = max(maximum_absolute, absolute)
+        maximum_relative = max(maximum_relative, relative)
+        if absolute > ABSOLUTE_TOLERANCE and relative > RELATIVE_TOLERANCE:
+            failing += 1
+    result = {
+        "label": label,
+        "value_count": len(left),
+        "maximum_absolute_difference": maximum_absolute,
+        "maximum_relative_difference": maximum_relative,
+        "relative_tolerance": RELATIVE_TOLERANCE,
+        "absolute_tolerance": ABSOLUTE_TOLERANCE,
+        "failing_value_count": failing,
+        "passes": failing == 0,
+    }
+    if failing:
+        raise GateError(
+            f"{label} failed for {failing}/{len(left)} values "
+            f"(max relative {maximum_relative:.3e})"
+        )
+    return result
+
+
+def _complex_vector_digest(values: Sequence[complex]) -> str:
+    return _canonical_sha256([[value.real.hex(), value.imag.hex()] for value in values])
+
+
+def _physics_axes(physics: object) -> dict[str, object]:
+    return {
+        "process_id": physics.process_id,
+        "process": physics.process,
+        "color_accuracy": physics.color_accuracy,
+        "external_pdgs": [particle.pdg_id for particle in physics.external_particles],
+        "helicities": [
+            {
+                "id": item.id,
+                "values": list(item.values),
+                "computed": item.computed,
+                "representative_id": item.representative_id,
+                "coefficient": item.coefficient,
+            }
+            for item in physics.helicities
+        ],
+        "color_flows": [
+            {
+                "id": item.id,
+                "word": list(item.word),
+                "computed": item.computed,
+                "representative_id": item.representative_id,
+                "coefficient": item.coefficient,
+            }
+            for item in physics.color_flows
+        ],
+        "selector_capabilities": list(physics.selector_capabilities),
+        "reduction_kind": physics.reduction.kind,
+    }
+
+
+def _required_nonnegative_profile_integer(
+    profile: Mapping[str, object],
+    name: str,
+) -> int:
+    value = profile.get(name)
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise GateError(f"native profile field {name!r} is not a non-negative integer")
+    return value
+
+
+def _audit_profile(profile: Mapping[str, object]) -> dict[str, object]:
+    if profile.get("execution_mode") != "compiled":
+        raise GateError("native profile did not execute the compiled lane")
+    for name in _ZERO_PROFILE_COUNTERS:
+        value = _required_nonnegative_profile_integer(profile, name)
+        if value != 0:
+            raise GateError(f"compiled Direct-Arena profile observed {name}={value}")
+    for name in _ZERO_PROFILE_TIMES:
+        value = profile.get(name)
+        if (
+            isinstance(value, bool)
+            or not isinstance(value, (int, float))
+            or not math.isfinite(float(value))
+            or float(value) != 0.0
+        ):
+            raise GateError(
+                f"compiled Direct-Arena profile observed nonzero/invalid {name}"
+            )
+
+    engine_count = _required_nonnegative_profile_integer(
+        profile,
+        _DIRECT_ENGINE_COUNTER,
+    )
+    if engine_count < 1:
+        raise GateError("native profile reports no compiled Direct-Arena engines")
+    call_count = _required_nonnegative_profile_integer(
+        profile,
+        _DIRECT_CALL_COUNTER,
+    )
+    if call_count < 1:
+        raise GateError("native profile reports no compiled Direct-Arena calls")
+    backend_call_count = _required_nonnegative_profile_integer(
+        profile,
+        "evaluator_backend_call_count",
+    )
+    if backend_call_count != call_count:
+        raise GateError(
+            "compiled Direct-Arena call count does not cover every evaluator "
+            "backend call"
+        )
+
+    counters = {
+        name: _required_nonnegative_profile_integer(profile, name)
+        for name in (
+            *_ZERO_PROFILE_COUNTERS,
+            _DIRECT_ENGINE_COUNTER,
+            _DIRECT_CALL_COUNTER,
+            "evaluator_backend_call_count",
+        )
+    }
+    return {
+        "available": True,
+        "execution_mode": "compiled",
+        "direct_arena_engine_counter": {
+            "name": _DIRECT_ENGINE_COUNTER,
+            "value": engine_count,
+        },
+        "direct_arena_call_counter": {
+            "name": _DIRECT_CALL_COUNTER,
+            "value": call_count,
+        },
+        "zero_legacy_traffic_counters": counters,
+        "zero_legacy_traffic_times": {
+            name: float(profile[name]) for name in _ZERO_PROFILE_TIMES
+        },
+        "passes": True,
+    }
+
+
+def _runtime_execution_mode(runtime: object) -> tuple[str, str]:
+    value = getattr(runtime, "execution_mode", None)
+    if isinstance(value, str):
+        return value, "Runtime.execution_mode"
+    backend = getattr(runtime, "_backend", None)
+    value = getattr(backend, "execution_mode", None)
+    if isinstance(value, str):
+        return value, "native runtime adapter execution_mode"
+    raise GateError("loaded runtime exposes no execution-mode identity")
+
+
+def _profile_runtime(
+    runtime: object,
+    points: Sequence[Sequence[Sequence[float]]],
+) -> dict[str, object]:
+    profiler = getattr(runtime, "profile", None)
+    surface = "Runtime.profile"
+    if not callable(profiler):
+        backend = getattr(runtime, "_backend", None)
+        profiler = getattr(backend, "profile", None)
+        surface = "native runtime adapter profile"
+    if not callable(profiler):
+        raise GateError(
+            "installed public/runtime-adapter API exposes no profiler; "
+            "Direct-Arena activity cannot be proven"
+        )
+    payload = profiler(points, precision=16, include_values=False)
+    if not isinstance(payload, Mapping):
+        raise GateError("native runtime profile is not an object")
+    return {**_audit_profile(payload), "surface": surface}
+
+
+def _evaluate_artifact(
+    artifact: Path,
+    *,
+    process_id: str,
+    optimization_level: int,
+    points: tuple[tuple[tuple[float, ...], ...], ...],
+) -> tuple[dict[str, object], EvaluationCapture]:
+    from pyamplicol import Runtime
+
+    manifest_id = _json_object(
+        artifact / "artifact.json",
+        label="artifact manifest",
+    ).get("artifact_id")
+    runtime = Runtime.load(artifact, process=process_id)
+    if runtime.artifact_id != manifest_id:
+        raise GateError(
+            f"JIT O{optimization_level} native runtime authenticated another artifact"
+        )
+    execution_mode, execution_mode_surface = _runtime_execution_mode(runtime)
+    if execution_mode != "compiled":
+        raise GateError(f"JIT O{optimization_level} loaded a non-compiled runtime")
+    physics = runtime.physics
+    if physics.process != PROCESS:
+        raise GateError(f"JIT O{optimization_level} runtime process drifted")
+    if tuple(particle.pdg_id for particle in physics.external_particles) != (
+        EXPECTED_EXTERNAL_PDGS
+    ):
+        raise GateError(f"JIT O{optimization_level} runtime external PDGs drifted")
+    if physics.color_accuracy != "lc":
+        raise GateError(f"JIT O{optimization_level} runtime color accuracy drifted")
+
+    f64_total = tuple(_as_complex(value) for value in runtime.evaluate(points))
+    precision32_raw = runtime.evaluate(points, precision=32)
+    precision32_total = tuple(_as_complex(value) for value in precision32_raw)
+    f64_resolved = runtime.evaluate_resolved(points)
+    precision32_resolved = runtime.evaluate_resolved(points, precision=32)
+    if (
+        tuple(f64_resolved.helicity_ids) != physics.helicity_ids
+        or tuple(precision32_resolved.helicity_ids) != physics.helicity_ids
+        or tuple(f64_resolved.color_ids) != physics.color_ids
+        or tuple(precision32_resolved.color_ids) != physics.color_ids
+    ):
+        raise GateError(f"JIT O{optimization_level} resolved physical axes drifted")
+    f64_components = _flatten_resolved(f64_resolved)
+    precision32_components = _flatten_resolved(precision32_resolved)
+    comparisons = {
+        "f64_vs_precision32_total": _comparison(
+            f64_total,
+            precision32_total,
+            label=f"JIT O{optimization_level} f64/precision32 totals",
+        ),
+        "f64_evaluate_vs_resolved_total": _comparison(
+            f64_total,
+            tuple(_as_complex(value) for value in f64_resolved.total()),
+            label=f"JIT O{optimization_level} f64 evaluate/resolved total",
+        ),
+        "precision32_evaluate_vs_resolved_total": _comparison(
+            precision32_total,
+            tuple(_as_complex(value) for value in precision32_resolved.total()),
+            label=(f"JIT O{optimization_level} precision32 evaluate/resolved total"),
+        ),
+        "f64_vs_precision32_resolved_components": _comparison(
+            f64_components,
+            precision32_components,
+            label=f"JIT O{optimization_level} f64/precision32 components",
+        ),
+    }
+    axes = _physics_axes(physics)
+    capture = EvaluationCapture(
+        physics_axes=axes,
+        f64_total=f64_total,
+        precision32_total=precision32_total,
+        f64_components=f64_components,
+        precision32_components=precision32_components,
+    )
+    return (
+        {
+            "artifact_id": runtime.artifact_id,
+            "execution_mode": execution_mode,
+            "execution_mode_surface": execution_mode_surface,
+            "point_count": len(points),
+            "point_seeds": list(POINT_SEEDS[: len(points)]),
+            "physics_axes": {
+                **axes,
+                "canonical_sha256": _canonical_sha256(axes),
+            },
+            "f64_total": [[value.real, value.imag] for value in f64_total],
+            "precision32_total_decimal": [str(value) for value in precision32_raw],
+            "resolved": {
+                "shape": list(f64_resolved.shape),
+                "component_count": len(f64_components),
+                "f64_component_sha256": _complex_vector_digest(f64_components),
+                "precision32_component_sha256": _complex_vector_digest(
+                    precision32_components
+                ),
+            },
+            "comparisons": comparisons,
+            "native_profile": _profile_runtime(runtime, points),
+            "passes": True,
+        },
+        capture,
+    )
+
+
+def _cross_level_parity(
+    captures: Mapping[int, EvaluationCapture],
+) -> dict[str, object]:
+    if set(captures) != set(JIT_LEVELS):
+        raise GateError("cross-level parity requires O0, O1, O2, and O3")
+    baseline_level = 3
+    baseline = captures[baseline_level]
+    comparisons: dict[str, dict[str, object]] = {}
+    for optimization_level in JIT_LEVELS:
+        if optimization_level == baseline_level:
+            continue
+        candidate = captures[optimization_level]
+        if candidate.physics_axes != baseline.physics_axes:
+            raise GateError(
+                f"JIT O{optimization_level}/O{baseline_level} physical axes differ"
+            )
+        comparisons[f"o{optimization_level}_vs_o{baseline_level}"] = {
+            "f64_totals": _comparison(
+                candidate.f64_total,
+                baseline.f64_total,
+                label=f"JIT O{optimization_level}/O{baseline_level} f64 totals",
+            ),
+            "precision32_totals": _comparison(
+                candidate.precision32_total,
+                baseline.precision32_total,
+                label=(
+                    f"JIT O{optimization_level}/O{baseline_level} precision32 totals"
+                ),
+            ),
+            "f64_resolved_components": _comparison(
+                candidate.f64_components,
+                baseline.f64_components,
+                label=(
+                    f"JIT O{optimization_level}/O{baseline_level} "
+                    "f64 resolved components"
+                ),
+            ),
+            "precision32_resolved_components": _comparison(
+                candidate.precision32_components,
+                baseline.precision32_components,
+                label=(
+                    f"JIT O{optimization_level}/O{baseline_level} "
+                    "precision32 resolved components"
+                ),
+            ),
+        }
+    return {
+        "baseline_optimization_level": baseline_level,
+        "physical_axes_sha256": _canonical_sha256(baseline.physics_axes),
+        "comparisons": comparisons,
+        "passes": True,
+    }
+
+
+def _attach_content_identity(body: Mapping[str, object]) -> dict[str, object]:
+    result = dict(body)
+    result["content_identity"] = {
+        "algorithm": "sha256-canonical-json-body-v1",
+        "sha256": _canonical_sha256(body),
+    }
+    return result
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    encoded = json.dumps(
+        payload,
+        allow_nan=False,
+        ensure_ascii=False,
+        indent=2,
+        sort_keys=True,
+    )
+    try:
+        temporary.write_text(encoded + "\n", encoding="utf-8")
+        temporary.replace(path)
+    except OSError as error:
+        temporary.unlink(missing_ok=True)
+        raise GateError(f"cannot write evidence: {path}") from error
+
+
+def _lane_name(optimization_level: int) -> str:
+    return f"jit-o{optimization_level}"
+
+
+def _prepare_output_root(output_root: Path, *, replace: bool) -> Path:
+    root = output_root.expanduser().resolve(strict=False)
+    if root == ROOT or root == Path(root.anchor):
+        raise GateError("refusing a broad output root")
+    try:
+        root.relative_to(ROOT.resolve(strict=True))
+    except ValueError:
+        pass
+    else:
+        raise GateError(
+            "output root must be outside the source checkout so every isolated "
+            "generation worker can reauthenticate a clean revision"
+        )
+    if root.exists():
+        if not root.is_dir():
+            raise GateError(f"output root is not a directory: {root}")
+        occupied = [
+            _lane_name(level)
+            for level in JIT_LEVELS
+            if (root / _lane_name(level)).exists()
+        ]
+        if occupied and not replace:
+            raise GateError(
+                f"artifact lanes already exist ({', '.join(occupied)}); pass --replace"
+            )
+        if replace:
+            for level in JIT_LEVELS:
+                target = root / _lane_name(level)
+                if target.exists():
+                    shutil.rmtree(target)
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def run_gate(arguments: argparse.Namespace) -> dict[str, object]:
+    source = _source_identity()
+    runtime = _runtime_identity(source)
+    script = _file_identity(Path(__file__))
+    output_root = _prepare_output_root(
+        arguments.output_root,
+        replace=arguments.replace,
+    )
+    points = _deterministic_points(arguments.points)
+    points_identity = _points_identity(points)
+    levels: dict[str, dict[str, object]] = {}
+    captures: dict[int, EvaluationCapture] = {}
+    failures: list[dict[str, str]] = []
+    started = time.monotonic()
+    expected_revision = str(source["revision"])
+    expected_runtime_sha = _runtime_identity_sha256(runtime)
+
+    for optimization_level in JIT_LEVELS:
+        lane_name = _lane_name(optimization_level)
+        artifact = output_root / lane_name
+        try:
+            generation = _invoke_generation_worker(
+                artifact,
+                optimization_level,
+                expected_revision,
+                str(script["sha256"]),
+                timeout=arguments.generation_timeout,
+            )
+            worker = _mapping(
+                generation.get("worker_provenance"),
+                label=f"{lane_name}.worker_provenance",
+            )
+            if (
+                worker.get("source_revision") != expected_revision
+                or worker.get("runtime_identity_sha256") != expected_runtime_sha
+                or worker.get("gate_script_sha256") != script["sha256"]
+                or worker.get("postflight_identity_match") is not True
+            ):
+                raise GateError(f"{lane_name} worker provenance drifted")
+            identity, process_id = _artifact_identity_and_audit(
+                artifact,
+                optimization_level,
+            )
+            numerical, capture = _evaluate_artifact(
+                artifact,
+                process_id=process_id,
+                optimization_level=optimization_level,
+                points=points,
+            )
+            levels[lane_name] = {
+                "configuration": {
+                    "process": PROCESS,
+                    "color_accuracy": "lc",
+                    "lc_flow_layout": "topology-replay",
+                    "backend": "jit",
+                    "execution_mode": "compiled",
+                    "jit_optimization_level": optimization_level,
+                },
+                "generation": generation,
+                "artifact_identity": identity,
+                "numerical_validation": numerical,
+                "passes": True,
+            }
+            captures[optimization_level] = capture
+        except (GateError, OSError, RuntimeError, ValueError) as error:
+            failures.append(
+                {
+                    "lane": lane_name,
+                    "error_type": type(error).__name__,
+                    "message": str(error),
+                }
+            )
+            levels[lane_name] = {
+                "configuration": {
+                    "process": PROCESS,
+                    "backend": "jit",
+                    "execution_mode": "compiled",
+                    "jit_optimization_level": optimization_level,
+                },
+                "passes": False,
+            }
+
+    try:
+        cross_level = _cross_level_parity(captures)
+    except GateError as error:
+        failures.append(
+            {
+                "lane": "cross-level",
+                "error_type": type(error).__name__,
+                "message": str(error),
+            }
+        )
+        cross_level = {"passes": False, "message": str(error)}
+    source_postflight = _source_identity()
+    runtime_postflight = _runtime_identity(source_postflight)
+    script_postflight = _file_identity(Path(__file__))
+    if source_postflight != source:
+        raise GateError("source identity changed during the all-JIT gate")
+    if _stable_runtime_identity(runtime_postflight) != _stable_runtime_identity(
+        runtime
+    ):
+        raise GateError("candidate runtime identity changed during the all-JIT gate")
+    if script_postflight != script:
+        raise GateError("gate script identity changed during the all-JIT gate")
+    passed = (
+        not failures
+        and all(level.get("passes") is True for level in levels.values())
+        and cross_level.get("passes") is True
+    )
+    return _attach_content_identity(
+        {
+            "kind": RESULT_KIND,
+            "schema_version": SCHEMA_VERSION,
+            "status": "ok" if passed else "validation_failed",
+            "passes": passed,
+            "request": {
+                "process": PROCESS,
+                "jit_optimization_levels": list(JIT_LEVELS),
+                "point_count": arguments.points,
+                "point_seeds": list(POINT_SEEDS[: arguments.points]),
+                "momenta_identity": points_identity,
+                "relative_tolerance": RELATIVE_TOLERANCE,
+                "absolute_tolerance": ABSOLUTE_TOLERANCE,
+                "mandatory_watchdog_command": WATCHDOG_INVOCATION,
+                "memory_limit_gib": 30,
+            },
+            "source_identity": source,
+            "source_identity_postflight": source_postflight,
+            "source_identity_match": True,
+            "runtime_identity": runtime,
+            "runtime_identity_postflight": runtime_postflight,
+            "runtime_identity_match": True,
+            "gate_script_identity": script,
+            "gate_script_identity_postflight": script_postflight,
+            "gate_script_identity_match": True,
+            "levels": levels,
+            "cross_level_numerical_parity": cross_level,
+            "resources": {
+                "orchestration_wall_seconds": time.monotonic() - started,
+                "orchestrator_peak_rss_gib": _peak_rss_gib(),
+                "mandatory_process_tree_limit_gib": 30,
+            },
+            "failures": failures,
+        }
+    )
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(
+        description=__doc__,
+        epilog=f"Mandatory invocation: {WATCHDOG_INVOCATION}",
+    )
+    result.add_argument("--output-root", type=Path)
+    result.add_argument(
+        "--evidence",
+        type=Path,
+        help="default: OUTPUT_ROOT/compiled-all-jit-arena-gate.json",
+    )
+    result.add_argument(
+        "--points",
+        type=int,
+        choices=(2, 3),
+        default=2,
+        help="number of deterministic physical points (default: 2)",
+    )
+    result.add_argument(
+        "--generation-timeout",
+        type=float,
+        default=3_600.0,
+        help="per-level generation timeout in seconds",
+    )
+    result.add_argument(
+        "--replace",
+        action="store_true",
+        help="remove only the four named JIT-level directories before generation",
+    )
+    result.add_argument("--_generate-one", action="store_true", help=argparse.SUPPRESS)
+    result.add_argument("--artifact", type=Path, help=argparse.SUPPRESS)
+    result.add_argument(
+        "--jit-level",
+        type=int,
+        choices=JIT_LEVELS,
+        help=argparse.SUPPRESS,
+    )
+    result.add_argument("--expected-revision", help=argparse.SUPPRESS)
+    result.add_argument("--expected-script-sha256", help=argparse.SUPPRESS)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    _establish_preimport_runtime_identity()
+    if arguments._generate_one:
+        if (
+            arguments.artifact is None
+            or arguments.jit_level is None
+            or arguments.expected_revision is None
+            or arguments.expected_script_sha256 is None
+        ):
+            parser().error(
+                "--_generate-one requires --artifact, --jit-level, and "
+                "--expected-revision and --expected-script-sha256"
+            )
+        if SHA256_PATTERN.fullmatch(arguments.expected_script_sha256) is None:
+            parser().error("--expected-script-sha256 must be a SHA-256 digest")
+        try:
+            payload = _generation_worker(
+                arguments.artifact,
+                arguments.jit_level,
+                arguments.expected_revision,
+                arguments.expected_script_sha256,
+            )
+        except (GateError, OSError, RuntimeError, ValueError) as error:
+            print(f"compiled-all-jit-arena worker: {error}", file=sys.stderr)
+            return 2
+        print(json.dumps(payload, allow_nan=False, sort_keys=True))
+        return 0
+    if arguments.output_root is None:
+        parser().error("--output-root is required")
+    if arguments.generation_timeout <= 0 or not math.isfinite(
+        arguments.generation_timeout
+    ):
+        parser().error("--generation-timeout must be positive and finite")
+    evidence_path = (
+        arguments.evidence
+        if arguments.evidence is not None
+        else arguments.output_root / "compiled-all-jit-arena-gate.json"
+    )
+    try:
+        result = run_gate(arguments)
+        _write_json_atomic(evidence_path.expanduser().resolve(strict=False), result)
+    except (GateError, OSError, RuntimeError, ValueError) as error:
+        print(f"compiled-all-jit-arena: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, allow_nan=False, indent=2, sort_keys=True))
+    return 0 if result["passes"] else 1
+
+
+if __name__ == "__main__":
+    _ensure_source_only_python()
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/compiled_microkernel_acceptance.py b/pyamplicol/tools/developer/compiled_microkernel_acceptance.py
new file mode 100644
index 0000000000..9a4d8c8ceb
--- /dev/null
+++ b/pyamplicol/tools/developer/compiled_microkernel_acceptance.py
@@ -0,0 +1,2106 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Audit DirectTable microkernel evidence without importing production code.
+
+The input is a validated, normalized campaign document.  This tool is
+deliberately independent of the generator and loader that produce the
+evidence: declared counts, byte totals, ordering, coverage, numerical results,
+and timing gates are recomputed here.
+
+The normalized contract is intentionally strict.  Unknown or missing fields,
+compiled-stage-plan v1, incompatible direct ABIs, incomplete odd-tail data,
+and malformed islands raise :class:`AcceptanceError`; a well-formed campaign
+that misses a landing threshold returns ``passes: false``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import statistics
+import sys
+import tomllib
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+CAMPAIGN_KIND = "pyamplicol-compiled-microkernel-campaign"
+CAMPAIGN_SCHEMA_VERSION = 2
+RESULT_KIND = "pyamplicol-compiled-microkernel-acceptance"
+RESULT_SCHEMA_VERSION = 2
+STAGE_PLAN_KIND = "compiled-stage-plan"
+STAGE_PLAN_SCHEMA_VERSION = 2
+
+DIRECT_APPLICATION_ABI = "pyamplicol-compiled-plane-kernel-v2"
+SOURCE_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+DIRECT_TABLE_BINDING_ABI = "pyamplicol-eager-plane-table-binding-v2"
+DIRECT_TABLE_DESCRIPTOR_ABI = "pyamplicol-eager-plane-table-descriptor-v1"
+
+_ROOT = Path(__file__).resolve().parents[2]
+with (_ROOT / "dependencies" / "release-lock.toml").open("rb") as _stream:
+    _LOCKED_SYMJIT = tomllib.load(_stream)["symjit"]
+DEPENDENCY_SOURCE = "registry+https://github.com/rust-lang/crates.io-index"
+DEPENDENCY_VERSION = str(_LOCKED_SYMJIT["version"])
+
+TARGET_PROCESS = "u u~ > Z+6g"
+TARGET_FLOW = "flow:2,4,5,6,7,8,9,1"
+TARGET_LAYOUT = "topology-replay"
+TARGET_COLOR_ACCURACY = "lc"
+TARGET_HELICITY_MODE = "sum"
+
+REQUIRED_BATCHES = (1, 127, 128, 129, 1023, 1024, 1025)
+PRIMARY_BATCHES = (128, 1024)
+MIN_SAMPLE_PAIRS = 7
+MIN_SAMPLE_DURATION_SECONDS = 5.0
+MIN_PRIMARY_GAIN = 0.10
+MAX_BATCH_ONE_REGRESSION = 0.05
+MAX_RESOURCE_REGRESSION = 0.10
+MIN_CODE_SIZE_REDUCTION = 0.25
+MAX_NON_TARGET_REGRESSION = 0.02
+MAD_MULTIPLIER = 3.0
+RELATIVE_TOLERANCE = 1.0e-12
+ABSOLUTE_TOLERANCE = 1.0e-15
+
+MAX_KERNEL_IDENTITIES = 8
+MAX_COMPLEX_INPUTS = 16
+MAX_COMPLEX_OUTPUTS = 4
+VECTOR_WEYL_KERNEL_FAMILY = "vector-weyl"
+THREE_VECTOR_SINGLETON_KERNEL_FAMILY = "three-vector-singleton"
+EXACT_CODE_SIZE_METRIC = "executed-selected-machine-code-scalar-plus-simd-v1"
+MAX_KERNEL_SOURCE_BYTES = 64 * 1024
+MAX_SEMANTIC_ROW_BYTES = 4 * 1024 * 1024
+MIN_CENSUS_COVERAGE = 0.50
+MAX_PROJECTED_TEXT_FRACTION = 0.25
+
+CENSUS_DENOMINATOR_CONTRACT = (
+    "materialized-active-repeated-prepared-kernel-occurrences-v1"
+)
+TARGET_ACTIVE_NON_SOURCE_CURRENT_SLOTS = 55
+TARGET_MATERIALIZED_INTERACTIONS = 203
+TARGET_TWO_COMPONENT_CURRENT_SLOTS = 26
+TARGET_THREE_VECTOR_SINGLETON_CURRENT_SLOTS = 5
+TARGET_ELIGIBLE_PREPARED_KERNEL_OCCURRENCES = 103
+TARGET_ACTIVE_PREPARED_KERNEL_COUNTS = {
+    4: 35,
+    7: 49,
+    24: 49,
+    36: 40,
+    41: 30,
+}
+TARGET_ELIGIBLE_PREPARED_KERNEL_COUNTS = {
+    4: 5,
+    7: 49,
+    24: 49,
+}
+TARGET_PROOF_DAG_NON_SOURCE_CURRENT_SLOTS = 1425
+TARGET_PROOF_DAG_INTERACTIONS = 8338
+
+REQUIRED_REGRESSION_CASES = frozenset(
+    {
+        "z6g-lc-union",
+        "gg-ttbar-3g-nlc",
+        "gg-ttbar-3g-full-color",
+        "ddbar-z3g-residual-only",
+        "builtin-model",
+        "ufo-sm-model",
+        "four-quark-lines-lc",
+        "four-quark-lines-nlc",
+        "four-quark-lines-full-color",
+        "mutable-parameters",
+        "structural-zeros",
+        "global-selectors",
+        "per-point-selectors",
+        "malformed-plans",
+    }
+)
+REQUIRED_NON_TARGET_PERFORMANCE = frozenset({"z6g-lc-union", "eager"})
+
+_SHA256_LENGTH = 64
+_DIAGNOSTIC_KEYS = frozenset(
+    {
+        "island_count",
+        "kernel_count",
+        "invocation_count",
+        "attachment_count",
+        "table_machine_code_bytes",
+        "residual_machine_code_bytes",
+        "semantic_row_bytes",
+        "arena_bytes",
+        "warmed_allocation_count",
+    }
+)
+
+
+class AcceptanceError(RuntimeError):
+    """Raised when evidence is malformed or incomplete."""
+
+
+def _error(path: str, message: str) -> None:
+    raise AcceptanceError(f"{path}: {message}")
+
+
+def _mapping(value: object, path: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        _error(path, "expected an object")
+    if not all(isinstance(key, str) for key in value):
+        _error(path, "object keys must be strings")
+    return value
+
+
+def _sequence(value: object, path: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        _error(path, "expected an array")
+    return value
+
+
+def _exact_keys(
+    value: Mapping[str, object],
+    expected: frozenset[str] | set[str],
+    path: str,
+) -> None:
+    actual = set(value)
+    missing = sorted(expected - actual)
+    extra = sorted(actual - expected)
+    if missing or extra:
+        _error(path, f"field mismatch; missing={missing}, extra={extra}")
+
+
+def _integer(
+    value: object,
+    path: str,
+    *,
+    minimum: int | None = None,
+) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        _error(path, "expected an integer")
+    if minimum is not None and value < minimum:
+        _error(path, f"must be at least {minimum}")
+    return value
+
+
+def _number(
+    value: object,
+    path: str,
+    *,
+    minimum: float | None = None,
+) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        _error(path, "expected a finite number")
+    result = float(value)
+    if not math.isfinite(result):
+        _error(path, "expected a finite number")
+    if minimum is not None and result < minimum:
+        _error(path, f"must be at least {minimum}")
+    return result
+
+
+def _positive_number(value: object, path: str) -> float:
+    result = _number(value, path)
+    if result <= 0.0:
+        _error(path, "must be greater than zero")
+    return result
+
+
+def _string(value: object, path: str, *, nonempty: bool = True) -> str:
+    if not isinstance(value, str):
+        _error(path, "expected a string")
+    if nonempty and not value:
+        _error(path, "must not be empty")
+    return value
+
+
+def _sha256(value: object, path: str) -> str:
+    result = _string(value, path)
+    if len(result) != _SHA256_LENGTH:
+        _error(path, "expected a lowercase SHA-256 digest")
+    if any(character not in "0123456789abcdef" for character in result):
+        _error(path, "expected a lowercase SHA-256 digest")
+    return result
+
+
+def canonical_sha256(value: object) -> str:
+    """Return the canonical JSON SHA-256 used by evidence certificates."""
+
+    try:
+        payload = json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("utf-8")
+    except (TypeError, ValueError) as exc:
+        raise AcceptanceError(f"value is not canonical JSON: {exc}") from exc
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _authenticated_digest(value: Mapping[str, object], path: str) -> str:
+    declared = _sha256(value.get("sha256"), f"{path}.sha256")
+    payload = {key: item for key, item in value.items() if key != "sha256"}
+    actual = canonical_sha256(payload)
+    if declared != actual:
+        _error(path, f"SHA-256 mismatch: declared {declared}, computed {actual}")
+    return declared
+
+
+def _unique_integers(
+    value: object,
+    path: str,
+    *,
+    minimum: int | None = 0,
+) -> list[int]:
+    result = [
+        _integer(item, f"{path}[{index}]", minimum=minimum)
+        for index, item in enumerate(_sequence(value, path))
+    ]
+    if len(result) != len(set(result)):
+        _error(path, "values must be unique")
+    return result
+
+
+def _unique_strings(value: object, path: str) -> list[str]:
+    result = [
+        _string(item, f"{path}[{index}]")
+        for index, item in enumerate(_sequence(value, path))
+    ]
+    if len(result) != len(set(result)):
+        _error(path, "values must be unique")
+    return result
+
+
+def _dense_ids(values: Sequence[int], path: str) -> None:
+    if list(values) != list(range(len(values))):
+        _error(path, "IDs must be dense, ordered, and zero-based")
+
+
+def _validate_diagnostics(value: object, path: str) -> dict[str, int]:
+    diagnostics = _mapping(value, path)
+    _exact_keys(diagnostics, _DIAGNOSTIC_KEYS, path)
+    return {
+        key: _integer(diagnostics[key], f"{path}.{key}", minimum=0)
+        for key in sorted(_DIAGNOSTIC_KEYS)
+    }
+
+
+def _validate_residual_leaf(
+    value: object,
+    path: str,
+    residual_current_ids: set[int],
+) -> tuple[int, list[int]]:
+    leaf = _mapping(value, path)
+    _exact_keys(
+        leaf,
+        {
+            "leaf_id",
+            "current_ids",
+            "source_sha256",
+            "source_abi",
+            "source_bytes",
+            "machine_code_bytes",
+            "optimization_level",
+        },
+        path,
+    )
+    _integer(leaf["leaf_id"], f"{path}.leaf_id", minimum=0)
+    current_ids = _unique_integers(leaf["current_ids"], f"{path}.current_ids")
+    if not current_ids:
+        _error(f"{path}.current_ids", "must not be empty")
+    if not set(current_ids) <= residual_current_ids:
+        _error(f"{path}.current_ids", "contains a non-residual destination")
+    _sha256(leaf["source_sha256"], f"{path}.source_sha256")
+    if leaf["source_abi"] != DIRECT_APPLICATION_ABI:
+        _error(f"{path}.source_abi", "incompatible DirectApplication ABI")
+    _integer(leaf["source_bytes"], f"{path}.source_bytes", minimum=1)
+    machine_code_bytes = _integer(
+        leaf["machine_code_bytes"],
+        f"{path}.machine_code_bytes",
+        minimum=0,
+    )
+    if leaf["optimization_level"] != 3:
+        _error(f"{path}.optimization_level", "compiled residuals must use O3")
+    return machine_code_bytes, current_ids
+
+
+def _validate_kernel(value: object, path: str) -> dict[str, object]:
+    kernel = _mapping(value, path)
+    _exact_keys(
+        kernel,
+        {
+            "kernel_id",
+            "kernel_family",
+            "motif_sha256",
+            "source_sha256",
+            "descriptor_sha256",
+            "source_abi",
+            "binding_abi",
+            "descriptor_abi",
+            "canonical_input_order",
+            "input_permutation",
+            "result_signature",
+            "mutable_parameter_sha256",
+            "coupling_provenance_sha256",
+            "selector_domain_sha256",
+            "finalizer_sha256",
+            "input_complex_count",
+            "output_complex_count",
+            "source_bytes",
+            "machine_code_bytes",
+            "optimization_level",
+        },
+        path,
+    )
+    kernel_id = _integer(kernel["kernel_id"], f"{path}.kernel_id", minimum=0)
+    kernel_family = _string(kernel["kernel_family"], f"{path}.kernel_family")
+    if kernel_family not in {
+        VECTOR_WEYL_KERNEL_FAMILY,
+        THREE_VECTOR_SINGLETON_KERNEL_FAMILY,
+    }:
+        _error(
+            f"{path}.kernel_family",
+            "only vector-Weyl and singleton three-vector kernels are authorized",
+        )
+    for field in (
+        "motif_sha256",
+        "source_sha256",
+        "descriptor_sha256",
+        "mutable_parameter_sha256",
+        "coupling_provenance_sha256",
+        "selector_domain_sha256",
+        "finalizer_sha256",
+    ):
+        _sha256(kernel[field], f"{path}.{field}")
+    expected_abis = {
+        "source_abi": DIRECT_APPLICATION_ABI,
+        "binding_abi": DIRECT_TABLE_BINDING_ABI,
+        "descriptor_abi": DIRECT_TABLE_DESCRIPTOR_ABI,
+    }
+    for field, expected in expected_abis.items():
+        if kernel[field] != expected:
+            _error(f"{path}.{field}", f"expected {expected!r}")
+    canonical_order = _unique_strings(
+        kernel["canonical_input_order"],
+        f"{path}.canonical_input_order",
+    )
+    if not canonical_order:
+        _error(f"{path}.canonical_input_order", "must not be empty")
+    permutation = _unique_integers(
+        kernel["input_permutation"],
+        f"{path}.input_permutation",
+    )
+    if sorted(permutation) != list(range(len(canonical_order))):
+        _error(f"{path}.input_permutation", "must permute every canonical input")
+    result_signature = _string(
+        kernel["result_signature"],
+        f"{path}.result_signature",
+    )
+    input_count = _integer(
+        kernel["input_complex_count"],
+        f"{path}.input_complex_count",
+        minimum=1,
+    )
+    output_count = _integer(
+        kernel["output_complex_count"],
+        f"{path}.output_complex_count",
+        minimum=1,
+    )
+    if input_count > MAX_COMPLEX_INPUTS:
+        _error(f"{path}.input_complex_count", "exceeds the initial-slice bound")
+    if input_count != len(canonical_order):
+        _error(
+            f"{path}.input_complex_count",
+            "must match the canonical input descriptor count",
+        )
+    if (
+        kernel_family == THREE_VECTOR_SINGLETON_KERNEL_FAMILY
+        and input_count != MAX_COMPLEX_INPUTS
+    ):
+        _error(
+            f"{path}.input_complex_count",
+            "the authorized three-vector family requires exactly 16 inputs",
+        )
+    expected_result = {
+        VECTOR_WEYL_KERNEL_FAMILY: ("vector-weyl:2", 2),
+        THREE_VECTOR_SINGLETON_KERNEL_FAMILY: ("three-vector:4", 4),
+    }[kernel_family]
+    if (result_signature, output_count) != expected_result:
+        _error(
+            path,
+            f"{kernel_family!r} requires result signature/output {expected_result!r}",
+        )
+    source_bytes = _integer(
+        kernel["source_bytes"],
+        f"{path}.source_bytes",
+        minimum=1,
+    )
+    if source_bytes > MAX_KERNEL_SOURCE_BYTES:
+        _error(f"{path}.source_bytes", "exceeds 64 KiB")
+    machine_code_bytes = _integer(
+        kernel["machine_code_bytes"],
+        f"{path}.machine_code_bytes",
+        minimum=0,
+    )
+    if kernel["optimization_level"] != 3:
+        _error(f"{path}.optimization_level", "microkernels must use O3")
+    return {
+        "kernel_id": kernel_id,
+        "kernel_family": kernel_family,
+        "motif_sha256": kernel["motif_sha256"],
+        "output_complex_count": output_count,
+        "machine_code_bytes": machine_code_bytes,
+        "finalizer_sha256": kernel["finalizer_sha256"],
+    }
+
+
+def _validate_certificate(
+    value: object,
+    path: str,
+    *,
+    kind: str,
+    island_current_ids: list[int],
+    order: bool,
+) -> dict[int, list[int]]:
+    certificate = _mapping(value, path)
+    _exact_keys(certificate, {"kind", "rows", "sha256"}, path)
+    if certificate["kind"] != kind:
+        _error(f"{path}.kind", f"expected {kind!r}")
+    rows = _sequence(certificate["rows"], f"{path}.rows")
+    parsed: dict[int, list[int]] = {}
+    value_field = "evaluation_group_ids" if order else "predecessor_current_ids"
+    for index, raw_row in enumerate(rows):
+        row_path = f"{path}.rows[{index}]"
+        row = _mapping(raw_row, row_path)
+        _exact_keys(row, {"current_id", value_field}, row_path)
+        current_id = _integer(row["current_id"], f"{row_path}.current_id")
+        if current_id in parsed:
+            _error(f"{row_path}.current_id", "duplicate certificate current")
+        parsed[current_id] = _unique_integers(
+            row[value_field],
+            f"{row_path}.{value_field}",
+            minimum=None if order else 0,
+        )
+    if set(parsed) != set(island_current_ids):
+        _error(f"{path}.rows", "must cover exactly the island destinations")
+    if not order:
+        island_set = set(island_current_ids)
+        for current_id, predecessors in parsed.items():
+            conflict = (set(predecessors) & island_set) - {current_id}
+            if conflict:
+                _error(
+                    f"{path}.rows",
+                    "dependency certificate groups dependent destinations "
+                    f"{current_id} and {sorted(conflict)}",
+                )
+    _authenticated_digest(certificate, path)
+    return parsed
+
+
+def _validate_island(
+    value: object,
+    path: str,
+    kernels: Mapping[int, Mapping[str, object]],
+    table_current_ids: set[int],
+) -> dict[str, object]:
+    island = _mapping(value, path)
+    _exact_keys(
+        island,
+        {
+            "island_id",
+            "kernel_id",
+            "current_ids",
+            "selector_partition_sha256",
+            "invocations",
+            "attachments",
+            "factor_catalog",
+            "plane_bindings",
+            "dependency_certificate",
+            "order_certificate",
+            "semantic_row_bytes",
+            "arena_bytes",
+        },
+        path,
+    )
+    island_id = _integer(island["island_id"], f"{path}.island_id", minimum=0)
+    kernel_id = _integer(island["kernel_id"], f"{path}.kernel_id", minimum=0)
+    if kernel_id not in kernels:
+        _error(f"{path}.kernel_id", "references an unknown kernel")
+    kernel = kernels[kernel_id]
+    current_ids = _unique_integers(island["current_ids"], f"{path}.current_ids")
+    if not current_ids:
+        _error(f"{path}.current_ids", "must not be empty")
+    if not set(current_ids) <= table_current_ids:
+        _error(f"{path}.current_ids", "contains a non-table destination")
+    _sha256(
+        island["selector_partition_sha256"],
+        f"{path}.selector_partition_sha256",
+    )
+
+    factor_rows = _sequence(island["factor_catalog"], f"{path}.factor_catalog")
+    factor_ids: list[int] = []
+    for index, raw_factor in enumerate(factor_rows):
+        factor_path = f"{path}.factor_catalog[{index}]"
+        factor = _mapping(raw_factor, factor_path)
+        _exact_keys(factor, {"factor_id", "factor_sha256"}, factor_path)
+        factor_ids.append(
+            _integer(factor["factor_id"], f"{factor_path}.factor_id", minimum=0)
+        )
+        _sha256(factor["factor_sha256"], f"{factor_path}.factor_sha256")
+    _dense_ids(factor_ids, f"{path}.factor_catalog.factor_id")
+
+    binding_rows = _sequence(island["plane_bindings"], f"{path}.plane_bindings")
+    binding_ids: list[int] = []
+    binding_roles: set[str] = set()
+    for index, raw_binding in enumerate(binding_rows):
+        binding_path = f"{path}.plane_bindings[{index}]"
+        binding = _mapping(raw_binding, binding_path)
+        _exact_keys(
+            binding,
+            {"plane_id", "role", "canonical_index", "permutation_index"},
+            binding_path,
+        )
+        binding_ids.append(
+            _integer(binding["plane_id"], f"{binding_path}.plane_id", minimum=0)
+        )
+        role = _string(binding["role"], f"{binding_path}.role")
+        if role not in {"current", "momentum", "parameter", "factor"}:
+            _error(f"{binding_path}.role", "unknown plane role")
+        binding_roles.add(role)
+        _integer(
+            binding["canonical_index"],
+            f"{binding_path}.canonical_index",
+            minimum=0,
+        )
+        _integer(
+            binding["permutation_index"],
+            f"{binding_path}.permutation_index",
+            minimum=0,
+        )
+    _dense_ids(binding_ids, f"{path}.plane_bindings.plane_id")
+    if binding_roles != {"current", "momentum", "parameter", "factor"}:
+        _error(f"{path}.plane_bindings", "must bind all four plane roles")
+
+    invocation_rows = _sequence(island["invocations"], f"{path}.invocations")
+    invocation_ids: list[int] = []
+    invocations: dict[int, tuple[int, int, int]] = {}
+    for index, raw_invocation in enumerate(invocation_rows):
+        invocation_path = f"{path}.invocations[{index}]"
+        invocation = _mapping(raw_invocation, invocation_path)
+        _exact_keys(
+            invocation,
+            {
+                "invocation_id",
+                "evaluation_group_id",
+                "attachment_start",
+                "attachment_count",
+            },
+            invocation_path,
+        )
+        invocation_id = _integer(
+            invocation["invocation_id"],
+            f"{invocation_path}.invocation_id",
+            minimum=0,
+        )
+        invocation_ids.append(invocation_id)
+        invocations[invocation_id] = (
+            _integer(
+                invocation["evaluation_group_id"],
+                f"{invocation_path}.evaluation_group_id",
+            ),
+            _integer(
+                invocation["attachment_start"],
+                f"{invocation_path}.attachment_start",
+                minimum=0,
+            ),
+            _integer(
+                invocation["attachment_count"],
+                f"{invocation_path}.attachment_count",
+                minimum=1,
+            ),
+        )
+    if not invocation_ids:
+        _error(f"{path}.invocations", "must not be empty")
+    _dense_ids(invocation_ids, f"{path}.invocations.invocation_id")
+    invocation_group_ids = [values[0] for values in invocations.values()]
+    if len(invocation_group_ids) != len(set(invocation_group_ids)):
+        _error(
+            f"{path}.invocations",
+            "materialized occurrence IDs must be unique within an island",
+        )
+
+    attachment_rows = _sequence(island["attachments"], f"{path}.attachments")
+    attachment_ids: list[int] = []
+    actual_by_current: dict[int, list[tuple[int, str]]] = {
+        current_id: [] for current_id in current_ids
+    }
+    for index, raw_attachment in enumerate(attachment_rows):
+        attachment_path = f"{path}.attachments[{index}]"
+        attachment = _mapping(raw_attachment, attachment_path)
+        _exact_keys(
+            attachment,
+            {
+                "attachment_id",
+                "invocation_id",
+                "current_id",
+                "evaluation_group_id",
+                "operation",
+                "destination_complex_count",
+                "factor_id",
+            },
+            attachment_path,
+        )
+        attachment_id = _integer(
+            attachment["attachment_id"],
+            f"{attachment_path}.attachment_id",
+            minimum=0,
+        )
+        attachment_ids.append(attachment_id)
+        invocation_id = _integer(
+            attachment["invocation_id"],
+            f"{attachment_path}.invocation_id",
+            minimum=0,
+        )
+        if invocation_id not in invocations:
+            _error(f"{attachment_path}.invocation_id", "unknown invocation")
+        evaluation_group_id = _integer(
+            attachment["evaluation_group_id"],
+            f"{attachment_path}.evaluation_group_id",
+        )
+        invocation_group, start, count = invocations[invocation_id]
+        if evaluation_group_id != invocation_group:
+            _error(
+                f"{attachment_path}.evaluation_group_id",
+                "does not match its invocation",
+            )
+        if not start <= attachment_id < start + count:
+            _error(
+                f"{attachment_path}.attachment_id",
+                "lies outside its invocation range",
+            )
+        current_id = _integer(
+            attachment["current_id"],
+            f"{attachment_path}.current_id",
+            minimum=0,
+        )
+        if current_id not in actual_by_current:
+            _error(f"{attachment_path}.current_id", "unknown island destination")
+        operation = _string(
+            attachment["operation"],
+            f"{attachment_path}.operation",
+        )
+        if operation not in {"overwrite", "accumulate"}:
+            _error(f"{attachment_path}.operation", "unknown write operation")
+        destination_count = _integer(
+            attachment["destination_complex_count"],
+            f"{attachment_path}.destination_complex_count",
+            minimum=1,
+        )
+        if destination_count != kernel["output_complex_count"]:
+            _error(
+                f"{attachment_path}.destination_complex_count",
+                "attachment does not bind the complete kernel destination",
+            )
+        factor_id = _integer(
+            attachment["factor_id"],
+            f"{attachment_path}.factor_id",
+            minimum=0,
+        )
+        if factor_id not in set(factor_ids):
+            _error(f"{attachment_path}.factor_id", "unknown factor")
+        actual_by_current[current_id].append((evaluation_group_id, operation))
+    if not attachment_ids:
+        _error(f"{path}.attachments", "must not be empty")
+    _dense_ids(attachment_ids, f"{path}.attachments.attachment_id")
+
+    expected_start = 0
+    for invocation_id in invocation_ids:
+        _, start, count = invocations[invocation_id]
+        if start != expected_start:
+            _error(
+                f"{path}.invocations[{invocation_id}].attachment_start",
+                "invocation attachment ranges must be contiguous",
+            )
+        owned = [
+            index
+            for index, raw_attachment in enumerate(attachment_rows)
+            if _mapping(raw_attachment, path)["invocation_id"] == invocation_id
+        ]
+        if owned != list(range(start, start + count)):
+            _error(
+                f"{path}.invocations[{invocation_id}]",
+                "declared range does not exactly own its attachment rows",
+            )
+        expected_start += count
+    if expected_start != len(attachment_rows):
+        _error(f"{path}.invocations", "ranges do not cover every attachment")
+
+    dependency_rows = _validate_certificate(
+        island["dependency_certificate"],
+        f"{path}.dependency_certificate",
+        kind="complete-current-independence-v1",
+        island_current_ids=current_ids,
+        order=False,
+    )
+    if set(dependency_rows) != set(current_ids):
+        _error(f"{path}.dependency_certificate", "internal coverage mismatch")
+    order_rows = _validate_certificate(
+        island["order_certificate"],
+        f"{path}.order_certificate",
+        kind="evaluation-group-order-v1",
+        island_current_ids=current_ids,
+        order=True,
+    )
+    for current_id, actual_rows in actual_by_current.items():
+        if not actual_rows:
+            _error(f"{path}.attachments", f"current {current_id} is unwritten")
+        operations = [operation for _, operation in actual_rows]
+        if operations[0] != "overwrite":
+            _error(f"{path}.attachments", f"current {current_id} is not initialized")
+        if any(operation != "accumulate" for operation in operations[1:]):
+            _error(
+                f"{path}.attachments",
+                f"current {current_id} has an invalid later write",
+            )
+        groups = [group for group, _ in actual_rows]
+        if groups != order_rows[current_id]:
+            _error(
+                f"{path}.order_certificate",
+                f"current {current_id} attachment order differs",
+            )
+    if kernel["kernel_family"] == THREE_VECTOR_SINGLETON_KERNEL_FAMILY:
+        if any(len(rows) != 1 for rows in actual_by_current.values()):
+            _error(
+                f"{path}.attachments",
+                "three-vector islands may own only singleton currents",
+            )
+        if any(count != 1 for _, _, count in invocations.values()):
+            _error(
+                f"{path}.invocations",
+                "three-vector singleton invocations must attach exactly once",
+            )
+        if len(invocation_rows) != len(current_ids):
+            _error(
+                path,
+                "three-vector singleton islands require one invocation per current",
+            )
+
+    semantic_row_bytes = _integer(
+        island["semantic_row_bytes"],
+        f"{path}.semantic_row_bytes",
+        minimum=0,
+    )
+    arena_bytes = _integer(
+        island["arena_bytes"],
+        f"{path}.arena_bytes",
+        minimum=0,
+    )
+    return {
+        "island_id": island_id,
+        "kernel_id": kernel_id,
+        "kernel_family": kernel["kernel_family"],
+        "current_ids": current_ids,
+        "evaluation_group_ids": sorted({values[0] for values in invocations.values()}),
+        "invocation_count": len(invocation_rows),
+        "attachment_count": len(attachment_rows),
+        "semantic_row_bytes": semantic_row_bytes,
+        "arena_bytes": arena_bytes,
+    }
+
+
+def audit_stage_plan_v2(value: object, path: str = "stage_plan") -> dict[str, object]:
+    """Validate and independently summarize one normalized v2 stage plan."""
+
+    plan = _mapping(value, path)
+    _exact_keys(
+        plan,
+        {
+            "kind",
+            "schema_version",
+            "stage_id",
+            "direct_application_abi",
+            "direct_table_binding_abi",
+            "direct_table_descriptor_abi",
+            "output_current_ids",
+            "table_current_ids",
+            "residual_current_ids",
+            "residual_leaves",
+            "kernels",
+            "islands",
+            "finalizers",
+            "diagnostics",
+        },
+        path,
+    )
+    if plan["kind"] != STAGE_PLAN_KIND:
+        _error(f"{path}.kind", f"expected {STAGE_PLAN_KIND!r}")
+    if plan["schema_version"] != STAGE_PLAN_SCHEMA_VERSION:
+        _error(
+            f"{path}.schema_version",
+            "compiled-stage-plan v2 is required; regenerate the artifact",
+        )
+    stage_id = _string(plan["stage_id"], f"{path}.stage_id")
+    expected_abis = {
+        "direct_application_abi": DIRECT_APPLICATION_ABI,
+        "direct_table_binding_abi": DIRECT_TABLE_BINDING_ABI,
+        "direct_table_descriptor_abi": DIRECT_TABLE_DESCRIPTOR_ABI,
+    }
+    for field, expected in expected_abis.items():
+        if plan[field] != expected:
+            _error(f"{path}.{field}", f"expected {expected!r}; regenerate artifact")
+
+    output_ids = _unique_integers(
+        plan["output_current_ids"],
+        f"{path}.output_current_ids",
+    )
+    if not output_ids:
+        _error(f"{path}.output_current_ids", "must not be empty")
+    table_ids = _unique_integers(
+        plan["table_current_ids"],
+        f"{path}.table_current_ids",
+    )
+    residual_ids = _unique_integers(
+        plan["residual_current_ids"],
+        f"{path}.residual_current_ids",
+    )
+    if set(table_ids) & set(residual_ids):
+        _error(path, "a destination may not be split between table and residual")
+    if set(table_ids) | set(residual_ids) != set(output_ids):
+        _error(path, "table and residual destinations must partition all outputs")
+
+    residual_rows = _sequence(plan["residual_leaves"], f"{path}.residual_leaves")
+    residual_leaf_ids: list[int] = []
+    residual_machine_code_bytes = 0
+    residual_owned: list[int] = []
+    for index, raw_leaf in enumerate(residual_rows):
+        leaf_path = f"{path}.residual_leaves[{index}]"
+        leaf = _mapping(raw_leaf, leaf_path)
+        residual_leaf_ids.append(
+            _integer(leaf.get("leaf_id"), f"{leaf_path}.leaf_id", minimum=0)
+        )
+        machine_bytes, owned = _validate_residual_leaf(
+            raw_leaf,
+            leaf_path,
+            set(residual_ids),
+        )
+        residual_machine_code_bytes += machine_bytes
+        residual_owned.extend(owned)
+    _dense_ids(residual_leaf_ids, f"{path}.residual_leaves.leaf_id")
+    if len(residual_owned) != len(set(residual_owned)):
+        _error(f"{path}.residual_leaves", "residual destinations overlap")
+    if set(residual_owned) != set(residual_ids):
+        _error(f"{path}.residual_leaves", "must own every residual destination")
+
+    kernel_rows = _sequence(plan["kernels"], f"{path}.kernels")
+    if len(kernel_rows) > MAX_KERNEL_IDENTITIES:
+        _error(f"{path}.kernels", "exceeds eight kernel identities")
+    kernels: dict[int, Mapping[str, object]] = {}
+    motif_ids: set[object] = set()
+    kernel_machine_code_bytes = 0
+    kernel_ids: list[int] = []
+    for index, raw_kernel in enumerate(kernel_rows):
+        kernel_path = f"{path}.kernels[{index}]"
+        summary = _validate_kernel(raw_kernel, kernel_path)
+        kernel_id = int(summary["kernel_id"])
+        kernel_ids.append(kernel_id)
+        if summary["motif_sha256"] in motif_ids:
+            _error(f"{kernel_path}.motif_sha256", "duplicate canonical motif")
+        motif_ids.add(summary["motif_sha256"])
+        kernels[kernel_id] = summary
+        kernel_machine_code_bytes += int(summary["machine_code_bytes"])
+    _dense_ids(kernel_ids, f"{path}.kernels.kernel_id")
+
+    island_rows = _sequence(plan["islands"], f"{path}.islands")
+    island_ids: list[int] = []
+    island_summaries: list[dict[str, object]] = []
+    table_owned: list[int] = []
+    for index, raw_island in enumerate(island_rows):
+        island_path = f"{path}.islands[{index}]"
+        summary = _validate_island(
+            raw_island,
+            island_path,
+            kernels,
+            set(table_ids),
+        )
+        island_ids.append(int(summary["island_id"]))
+        island_summaries.append(summary)
+        table_owned.extend(summary["current_ids"])  # type: ignore[arg-type]
+    _dense_ids(island_ids, f"{path}.islands.island_id")
+    if len(table_owned) != len(set(table_owned)):
+        _error(f"{path}.islands", "table destinations overlap between islands")
+    if set(table_owned) != set(table_ids):
+        _error(f"{path}.islands", "must own every table destination")
+    if bool(kernel_rows) != bool(island_rows):
+        _error(path, "unused kernels and kernel-less islands are forbidden")
+
+    finalizer_rows = _sequence(plan["finalizers"], f"{path}.finalizers")
+    finalized: list[int] = []
+    island_by_current = {
+        current_id: summary
+        for summary in island_summaries
+        for current_id in summary["current_ids"]  # type: ignore[union-attr]
+    }
+    for index, raw_finalizer in enumerate(finalizer_rows):
+        finalizer_path = f"{path}.finalizers[{index}]"
+        finalizer = _mapping(raw_finalizer, finalizer_path)
+        _exact_keys(
+            finalizer,
+            {"current_id", "island_id", "identity_sha256"},
+            finalizer_path,
+        )
+        current_id = _integer(
+            finalizer["current_id"],
+            f"{finalizer_path}.current_id",
+            minimum=0,
+        )
+        finalized.append(current_id)
+        if current_id not in island_by_current:
+            _error(f"{finalizer_path}.current_id", "not a table destination")
+        expected_island = island_by_current[current_id]
+        if finalizer["island_id"] != expected_island["island_id"]:
+            _error(
+                f"{finalizer_path}.island_id",
+                "finalizer must run after its complete island",
+            )
+        kernel = kernels[int(expected_island["kernel_id"])]
+        identity = _sha256(
+            finalizer["identity_sha256"],
+            f"{finalizer_path}.identity_sha256",
+        )
+        if identity != kernel["finalizer_sha256"]:
+            _error(
+                f"{finalizer_path}.identity_sha256",
+                "does not match the canonical motif finalizer",
+            )
+    if len(finalized) != len(set(finalized)) or set(finalized) != set(table_ids):
+        _error(f"{path}.finalizers", "must finalize every table destination once")
+
+    declared = _validate_diagnostics(plan["diagnostics"], f"{path}.diagnostics")
+    recomputed = {
+        "island_count": len(island_rows),
+        "kernel_count": len(kernel_rows),
+        "invocation_count": sum(
+            int(summary["invocation_count"]) for summary in island_summaries
+        ),
+        "attachment_count": sum(
+            int(summary["attachment_count"]) for summary in island_summaries
+        ),
+        "table_machine_code_bytes": kernel_machine_code_bytes,
+        "residual_machine_code_bytes": residual_machine_code_bytes,
+        "semantic_row_bytes": sum(
+            int(summary["semantic_row_bytes"]) for summary in island_summaries
+        ),
+        "arena_bytes": sum(int(summary["arena_bytes"]) for summary in island_summaries),
+        # This counter comes from the runtime allocation probe, while every
+        # other field above is derivable from static plan rows.
+        "warmed_allocation_count": declared["warmed_allocation_count"],
+    }
+    if declared != recomputed:
+        _error(
+            f"{path}.diagnostics",
+            f"declared values differ from recomputed values: {recomputed}",
+        )
+    return {
+        "stage_id": stage_id,
+        "diagnostics": recomputed,
+        "table_occurrence_families": {
+            f"{stage_id}:{group_id}": str(summary["kernel_family"])
+            for summary in island_summaries
+            for group_id in summary["evaluation_group_ids"]  # type: ignore[union-attr]
+        },
+        "table_destination_family_counts": {
+            family: sum(
+                len(summary["current_ids"])  # type: ignore[arg-type]
+                for summary in island_summaries
+                if summary["kernel_family"] == family
+            )
+            for family in (
+                VECTOR_WEYL_KERNEL_FAMILY,
+                THREE_VECTOR_SINGLETON_KERNEL_FAMILY,
+            )
+        },
+        "residual_only": not table_ids,
+        "table_only": not residual_ids,
+    }
+
+
+def _sum_diagnostics(
+    summaries: Sequence[Mapping[str, object]],
+) -> dict[str, int]:
+    return {
+        key: sum(
+            int(_mapping(summary["diagnostics"], "summary.diagnostics")[key])
+            for summary in summaries
+        )
+        for key in sorted(_DIAGNOSTIC_KEYS)
+    }
+
+
+def _validate_census(
+    value: object,
+    path: str,
+    table_occurrence_families: Mapping[str, str],
+    table_destination_family_counts: Mapping[str, int],
+) -> dict[str, float | int]:
+    census = _mapping(value, path)
+    _exact_keys(
+        census,
+        {
+            "denominator_contract",
+            "active_non_source_current_slots",
+            "materialized_interaction_count",
+            "two_component_current_slots",
+            "four_component_three_vector_singleton_slots",
+            "active_prepared_kernel_occurrences",
+            "eligible_prepared_kernel_occurrence_ids",
+            "proof_dag_non_source_current_slots",
+            "proof_dag_interaction_count",
+            "projected_generated_text_bytes",
+            "projected_replaced_text_bytes",
+        },
+        path,
+    )
+    if census["denominator_contract"] != CENSUS_DENOMINATOR_CONTRACT:
+        _error(
+            f"{path}.denominator_contract",
+            "coverage denominator must be all repeated prepared-kernel "
+            "occurrences in the materialized executable schedule",
+        )
+    expected_counts = {
+        "active_non_source_current_slots": TARGET_ACTIVE_NON_SOURCE_CURRENT_SLOTS,
+        "materialized_interaction_count": TARGET_MATERIALIZED_INTERACTIONS,
+        "two_component_current_slots": TARGET_TWO_COMPONENT_CURRENT_SLOTS,
+        "four_component_three_vector_singleton_slots": (
+            TARGET_THREE_VECTOR_SINGLETON_CURRENT_SLOTS
+        ),
+        "proof_dag_non_source_current_slots": (
+            TARGET_PROOF_DAG_NON_SOURCE_CURRENT_SLOTS
+        ),
+        "proof_dag_interaction_count": TARGET_PROOF_DAG_INTERACTIONS,
+    }
+    for field, expected in expected_counts.items():
+        actual = _integer(census[field], f"{path}.{field}", minimum=0)
+        if actual != expected:
+            _error(
+                f"{path}.{field}",
+                f"expected frozen target census count {expected}, got {actual}",
+            )
+    if (
+        census["active_non_source_current_slots"]
+        == (census["proof_dag_non_source_current_slots"])
+        or census["materialized_interaction_count"]
+        == (census["proof_dag_interaction_count"])
+    ):
+        _error(path, "proof-DAG counts are mislabeled as active schedule counts")
+
+    active_rows = _sequence(
+        census["active_prepared_kernel_occurrences"],
+        f"{path}.active_prepared_kernel_occurrences",
+    )
+    active: dict[str, int] = {}
+    for index, raw_row in enumerate(active_rows):
+        row_path = f"{path}.active_prepared_kernel_occurrences[{index}]"
+        row = _mapping(raw_row, row_path)
+        _exact_keys(row, {"occurrence_id", "prepared_kernel_id"}, row_path)
+        occurrence_id = _string(row["occurrence_id"], f"{row_path}.occurrence_id")
+        if occurrence_id in active:
+            _error(f"{row_path}.occurrence_id", "duplicate occurrence")
+        active[occurrence_id] = _integer(
+            row["prepared_kernel_id"],
+            f"{row_path}.prepared_kernel_id",
+            minimum=0,
+        )
+    if len(active) != TARGET_MATERIALIZED_INTERACTIONS:
+        _error(
+            f"{path}.active_prepared_kernel_occurrences",
+            f"must enumerate all {TARGET_MATERIALIZED_INTERACTIONS} occurrences",
+        )
+    active_kernel_counts: dict[int, int] = {}
+    for prepared_kernel_id in active.values():
+        active_kernel_counts[prepared_kernel_id] = (
+            active_kernel_counts.get(prepared_kernel_id, 0) + 1
+        )
+    if active_kernel_counts != TARGET_ACTIVE_PREPARED_KERNEL_COUNTS:
+        _error(
+            f"{path}.active_prepared_kernel_occurrences",
+            "prepared-kernel distribution differs from the frozen census: "
+            f"{active_kernel_counts}",
+        )
+    if any(count < 2 for count in active_kernel_counts.values()):
+        _error(
+            f"{path}.active_prepared_kernel_occurrences",
+            "the denominator may contain only repeated prepared kernels",
+        )
+    eligible = set(
+        _unique_strings(
+            census["eligible_prepared_kernel_occurrence_ids"],
+            f"{path}.eligible_prepared_kernel_occurrence_ids",
+        )
+    )
+    if not eligible <= set(active):
+        _error(
+            f"{path}.eligible_prepared_kernel_occurrence_ids",
+            "must be an active subset",
+        )
+    if eligible != set(table_occurrence_families):
+        _error(
+            f"{path}.eligible_prepared_kernel_occurrence_ids",
+            "must exactly match occurrences covered by table invocations",
+        )
+    eligible_kernel_counts: dict[int, int] = {}
+    for occurrence_id in eligible:
+        prepared_kernel_id = active[occurrence_id]
+        eligible_kernel_counts[prepared_kernel_id] = (
+            eligible_kernel_counts.get(prepared_kernel_id, 0) + 1
+        )
+        expected_family = (
+            THREE_VECTOR_SINGLETON_KERNEL_FAMILY
+            if prepared_kernel_id == 4
+            else VECTOR_WEYL_KERNEL_FAMILY
+        )
+        if table_occurrence_families[occurrence_id] != expected_family:
+            _error(
+                f"{path}.eligible_prepared_kernel_occurrence_ids",
+                f"{occurrence_id} binds the wrong structural kernel family",
+            )
+    if eligible_kernel_counts != TARGET_ELIGIBLE_PREPARED_KERNEL_COUNTS:
+        _error(
+            f"{path}.eligible_prepared_kernel_occurrence_ids",
+            "eligible prepared-kernel distribution must be exactly "
+            f"{TARGET_ELIGIBLE_PREPARED_KERNEL_COUNTS}, got "
+            f"{eligible_kernel_counts}",
+        )
+    expected_destination_counts = {
+        VECTOR_WEYL_KERNEL_FAMILY: TARGET_TWO_COMPONENT_CURRENT_SLOTS,
+        THREE_VECTOR_SINGLETON_KERNEL_FAMILY: (
+            TARGET_THREE_VECTOR_SINGLETON_CURRENT_SLOTS
+        ),
+    }
+    if dict(table_destination_family_counts) != expected_destination_counts:
+        _error(
+            path,
+            "table destination family counts must match the authorized "
+            f"complete-current slice {expected_destination_counts}",
+        )
+    coverage = len(eligible) / len(active)
+    if len(eligible) != TARGET_ELIGIBLE_PREPARED_KERNEL_OCCURRENCES:
+        _error(
+            f"{path}.eligible_prepared_kernel_occurrence_ids",
+            f"expected {TARGET_ELIGIBLE_PREPARED_KERNEL_OCCURRENCES} occurrences",
+        )
+    if coverage < MIN_CENSUS_COVERAGE:
+        _error(
+            f"{path}.eligible_prepared_kernel_occurrence_ids",
+            "coverage is below 50%",
+        )
+
+    generated = _integer(
+        census["projected_generated_text_bytes"],
+        f"{path}.projected_generated_text_bytes",
+        minimum=0,
+    )
+    replaced = _integer(
+        census["projected_replaced_text_bytes"],
+        f"{path}.projected_replaced_text_bytes",
+        minimum=1,
+    )
+    fraction = generated / replaced
+    if fraction > MAX_PROJECTED_TEXT_FRACTION:
+        _error(
+            f"{path}.projected_generated_text_bytes",
+            "projected text exceeds 25% of replaced text",
+        )
+    return {
+        "active_prepared_kernel_occurrence_count": len(active),
+        "eligible_prepared_kernel_occurrence_count": len(eligible),
+        "coverage": coverage,
+        "projected_text_fraction": fraction,
+    }
+
+
+def _validate_artifact_metrics(
+    value: object,
+    path: str,
+) -> dict[str, object]:
+    artifact = _mapping(value, path)
+    _exact_keys(
+        artifact,
+        {
+            "artifact_sha256",
+            "build_identity_sha256",
+            "generation_seconds",
+            "artifact_bytes",
+            "load_seconds",
+            "peak_rss_bytes",
+            "code_size_metric_available",
+            "code_size_metric_kind",
+            "selected_machine_code_bytes",
+            "portable_source_applications",
+        },
+        path,
+    )
+    metric_available = artifact["code_size_metric_available"]
+    if not isinstance(metric_available, bool):
+        _error(f"{path}.code_size_metric_available", "expected a boolean")
+    metric_kind = artifact["code_size_metric_kind"]
+    selected_machine_code: int | None
+    if metric_available:
+        if metric_kind != EXACT_CODE_SIZE_METRIC:
+            _error(
+                f"{path}.code_size_metric_kind",
+                f"must identify exact executed code as {EXACT_CODE_SIZE_METRIC!r}",
+            )
+        selected_machine_code = _integer(
+            artifact["selected_machine_code_bytes"],
+            f"{path}.selected_machine_code_bytes",
+            minimum=1,
+        )
+    else:
+        if metric_kind is not None:
+            _error(
+                f"{path}.code_size_metric_kind",
+                "must be null when the exact metric is unavailable",
+            )
+        if artifact["selected_machine_code_bytes"] is not None:
+            _error(
+                f"{path}.selected_machine_code_bytes",
+                "must be null when the exact machine-code metric is unavailable",
+            )
+        selected_machine_code = None
+    applications = _sequence(
+        artifact["portable_source_applications"],
+        f"{path}.portable_source_applications",
+    )
+    portable_source_bytes = 0
+    portable_source_digests: list[str] = []
+    for index, raw_application in enumerate(applications):
+        application_path = f"{path}.portable_source_applications[{index}]"
+        application = _mapping(raw_application, application_path)
+        _exact_keys(
+            application,
+            {
+                "source_application_sha256",
+                "source_application_bytes",
+                "source_application_abi",
+            },
+            application_path,
+        )
+        digest = _sha256(
+            application["source_application_sha256"],
+            f"{application_path}.source_application_sha256",
+        )
+        if digest in portable_source_digests:
+            _error(application_path, "portable source payloads must be deduplicated")
+        portable_source_digests.append(digest)
+        portable_source_bytes += _integer(
+            application["source_application_bytes"],
+            f"{application_path}.source_application_bytes",
+            minimum=1,
+        )
+        if application["source_application_abi"] != SOURCE_APPLICATION_ABI:
+            _error(
+                f"{application_path}.source_application_abi",
+                f"expected {SOURCE_APPLICATION_ABI!r}",
+            )
+    if not applications:
+        _error(f"{path}.portable_source_applications", "must not be empty")
+    return {
+        "artifact_sha256": _sha256(
+            artifact["artifact_sha256"],
+            f"{path}.artifact_sha256",
+        ),
+        "build_identity_sha256": _sha256(
+            artifact["build_identity_sha256"],
+            f"{path}.build_identity_sha256",
+        ),
+        "generation_seconds": _positive_number(
+            artifact["generation_seconds"],
+            f"{path}.generation_seconds",
+        ),
+        "artifact_bytes": _integer(
+            artifact["artifact_bytes"],
+            f"{path}.artifact_bytes",
+            minimum=1,
+        ),
+        "load_seconds": _positive_number(
+            artifact["load_seconds"],
+            f"{path}.load_seconds",
+        ),
+        "peak_rss_bytes": _integer(
+            artifact["peak_rss_bytes"],
+            f"{path}.peak_rss_bytes",
+            minimum=1,
+        ),
+        "code_size_metric_available": metric_available,
+        "code_size_metric_kind": metric_kind,
+        "selected_machine_code_bytes": selected_machine_code,
+        "portable_source_application_bytes": portable_source_bytes,
+        "portable_source_application_set_sha256": canonical_sha256(
+            portable_source_digests
+        ),
+    }
+
+
+def _validate_candidate(
+    value: object,
+    path: str,
+) -> tuple[dict[str, object], dict[str, object]]:
+    candidate = _mapping(value, path)
+    _exact_keys(
+        candidate,
+        {
+            "metrics",
+            "stage_plans",
+            "diagnostics",
+            "census",
+        },
+        path,
+    )
+    metrics = _validate_artifact_metrics(candidate["metrics"], f"{path}.metrics")
+    stage_rows = _sequence(candidate["stage_plans"], f"{path}.stage_plans")
+    if not stage_rows:
+        _error(f"{path}.stage_plans", "must not be empty")
+    summaries = [
+        audit_stage_plan_v2(row, f"{path}.stage_plans[{index}]")
+        for index, row in enumerate(stage_rows)
+    ]
+    stage_ids = [str(summary["stage_id"]) for summary in summaries]
+    if len(stage_ids) != len(set(stage_ids)):
+        _error(f"{path}.stage_plans", "stage IDs must be unique")
+    diagnostics = _validate_diagnostics(
+        candidate["diagnostics"],
+        f"{path}.diagnostics",
+    )
+    recomputed = _sum_diagnostics(summaries)
+    if diagnostics != recomputed:
+        _error(
+            f"{path}.diagnostics",
+            f"artifact totals differ from stage totals: {recomputed}",
+        )
+    if diagnostics["semantic_row_bytes"] > MAX_SEMANTIC_ROW_BYTES:
+        _error(f"{path}.diagnostics.semantic_row_bytes", "exceeds 4 MiB")
+    if diagnostics["kernel_count"] > MAX_KERNEL_IDENTITIES:
+        _error(f"{path}.diagnostics.kernel_count", "exceeds eight identities")
+    concrete_machine_code_bytes = (
+        diagnostics["table_machine_code_bytes"]
+        + diagnostics["residual_machine_code_bytes"]
+    )
+    selected_machine_code_bytes = metrics["selected_machine_code_bytes"]
+    if (
+        metrics["code_size_metric_available"] is True
+        and isinstance(selected_machine_code_bytes, int)
+        and selected_machine_code_bytes < concrete_machine_code_bytes
+    ):
+        _error(
+            f"{path}.metrics.selected_machine_code_bytes",
+            "is smaller than concrete table plus residual machine code",
+        )
+    table_occurrence_families: dict[str, str] = {}
+    table_destination_family_counts = {
+        VECTOR_WEYL_KERNEL_FAMILY: 0,
+        THREE_VECTOR_SINGLETON_KERNEL_FAMILY: 0,
+    }
+    for summary in summaries:
+        occurrence_families = _mapping(
+            summary["table_occurrence_families"],
+            "summary.table_occurrence_families",
+        )
+        overlap = set(table_occurrence_families) & set(occurrence_families)
+        if overlap:
+            _error(
+                f"{path}.stage_plans",
+                f"table occurrence IDs overlap: {sorted(overlap)}",
+            )
+        table_occurrence_families.update(
+            {str(key): str(item) for key, item in occurrence_families.items()}
+        )
+        destination_counts = _mapping(
+            summary["table_destination_family_counts"],
+            "summary.table_destination_family_counts",
+        )
+        for family in table_destination_family_counts:
+            table_destination_family_counts[family] += int(destination_counts[family])
+    census = _validate_census(
+        candidate["census"],
+        f"{path}.census",
+        table_occurrence_families,
+        table_destination_family_counts,
+    )
+    return metrics, {
+        "diagnostics": diagnostics,
+        "census": census,
+        "stage_count": len(summaries),
+        "residual_only_stage_count": sum(
+            bool(summary["residual_only"]) for summary in summaries
+        ),
+        "table_only_stage_count": sum(
+            bool(summary["table_only"]) for summary in summaries
+        ),
+    }
+
+
+def _complex_array(value: object, path: str, expected_length: int) -> list[complex]:
+    rows = _sequence(value, path)
+    if len(rows) != expected_length:
+        _error(path, f"expected {expected_length} complex values")
+    result: list[complex] = []
+    for index, raw_pair in enumerate(rows):
+        pair_path = f"{path}[{index}]"
+        pair = _sequence(raw_pair, pair_path)
+        if len(pair) != 2:
+            _error(pair_path, "complex values must be [real, imag]")
+        result.append(
+            complex(
+                _number(pair[0], f"{pair_path}[0]"),
+                _number(pair[1], f"{pair_path}[1]"),
+            )
+        )
+    return result
+
+
+def _resolved_array(
+    value: object,
+    path: str,
+    expected_length: int,
+) -> list[list[complex]]:
+    rows = _sequence(value, path)
+    if len(rows) != expected_length:
+        _error(path, f"expected {expected_length} point rows")
+    result: list[list[complex]] = []
+    for index, raw_row in enumerate(rows):
+        row_path = f"{path}[{index}]"
+        entries = _sequence(raw_row, row_path)
+        if not entries:
+            _error(row_path, "resolved contributions must not be empty")
+        result.append(_complex_array(entries, row_path, len(entries)))
+    return result
+
+
+def _close(left: complex, right: complex) -> bool:
+    return abs(left - right) <= (ABSOLUTE_TOLERANCE + RELATIVE_TOLERANCE * abs(right))
+
+
+def _assert_close_arrays(
+    left: Sequence[complex],
+    right: Sequence[complex],
+    path: str,
+) -> float:
+    if len(left) != len(right):
+        _error(path, "array shapes differ")
+    maximum = 0.0
+    for index, (actual, expected) in enumerate(zip(left, right, strict=True)):
+        difference = abs(actual - expected)
+        maximum = max(maximum, difference)
+        if not _close(actual, expected):
+            _error(
+                f"{path}[{index}]",
+                f"{actual!r} differs from {expected!r}",
+            )
+    return maximum
+
+
+def _validate_correctness(
+    value: object,
+    path: str,
+    batch: int,
+) -> dict[str, float]:
+    correctness = _mapping(value, path)
+    _exact_keys(correctness, {"baseline", "candidate"}, path)
+    lanes: dict[str, dict[str, object]] = {}
+    for lane in ("baseline", "candidate"):
+        lane_path = f"{path}.{lane}"
+        raw_lane = _mapping(correctness[lane], lane_path)
+        _exact_keys(
+            raw_lane,
+            {"evaluate", "resolved_total", "resolved_contributions"},
+            lane_path,
+        )
+        evaluated = _complex_array(
+            raw_lane["evaluate"],
+            f"{lane_path}.evaluate",
+            batch,
+        )
+        total = _complex_array(
+            raw_lane["resolved_total"],
+            f"{lane_path}.resolved_total",
+            batch,
+        )
+        resolved = _resolved_array(
+            raw_lane["resolved_contributions"],
+            f"{lane_path}.resolved_contributions",
+            batch,
+        )
+        lanes[lane] = {
+            "evaluate": evaluated,
+            "resolved_total": total,
+            "resolved_contributions": resolved,
+        }
+        _assert_close_arrays(
+            evaluated,
+            total,
+            f"{lane_path}.evaluate_vs_resolved_total",
+        )
+        _assert_close_arrays(
+            [sum(row, start=0j) for row in resolved],
+            total,
+            f"{lane_path}.resolved_contributions_vs_total",
+        )
+
+    baseline = lanes["baseline"]
+    candidate = lanes["candidate"]
+    total_error = _assert_close_arrays(
+        candidate["evaluate"],  # type: ignore[arg-type]
+        baseline["evaluate"],  # type: ignore[arg-type]
+        f"{path}.candidate_vs_baseline_total",
+    )
+    baseline_resolved = baseline["resolved_contributions"]
+    candidate_resolved = candidate["resolved_contributions"]
+    if not isinstance(baseline_resolved, list) or not isinstance(
+        candidate_resolved,
+        list,
+    ):
+        _error(path, "internal resolved representation error")
+    resolved_error = 0.0
+    for point_index, (candidate_row, baseline_row) in enumerate(
+        zip(candidate_resolved, baseline_resolved, strict=True)
+    ):
+        resolved_error = max(
+            resolved_error,
+            _assert_close_arrays(
+                candidate_row,
+                baseline_row,
+                f"{path}.candidate_vs_baseline_resolved[{point_index}]",
+            ),
+        )
+    return {
+        "maximum_total_absolute_error": total_error,
+        "maximum_resolved_absolute_error": resolved_error,
+    }
+
+
+def _median_and_mad(values: Sequence[float]) -> tuple[float, float]:
+    median = statistics.median(values)
+    mad = statistics.median(abs(value - median) for value in values)
+    return median, mad
+
+
+def _validate_measurements(
+    value: object,
+    path: str,
+) -> dict[str, object]:
+    rows = _sequence(value, path)
+    if len(rows) < 2 * MIN_SAMPLE_PAIRS or len(rows) % 2:
+        _error(path, "requires at least seven complete subprocess pairs")
+    parsed: list[dict[str, float | int | str]] = []
+    for index, raw_row in enumerate(rows):
+        row_path = f"{path}[{index}]"
+        row = _mapping(raw_row, row_path)
+        _exact_keys(
+            row,
+            {
+                "pair_index",
+                "sequence_index",
+                "lane",
+                "duration_seconds",
+                "seconds_per_point",
+                "warmed_allocation_count",
+            },
+            row_path,
+        )
+        lane = _string(row["lane"], f"{row_path}.lane")
+        if lane not in {"baseline", "candidate"}:
+            _error(f"{row_path}.lane", "expected baseline or candidate")
+        duration = _number(
+            row["duration_seconds"],
+            f"{row_path}.duration_seconds",
+            minimum=0.0,
+        )
+        if duration < MIN_SAMPLE_DURATION_SECONDS:
+            _error(f"{row_path}.duration_seconds", "sample ran for under 5 s")
+        allocations = _integer(
+            row["warmed_allocation_count"],
+            f"{row_path}.warmed_allocation_count",
+            minimum=0,
+        )
+        parsed.append(
+            {
+                "pair_index": _integer(
+                    row["pair_index"],
+                    f"{row_path}.pair_index",
+                    minimum=0,
+                ),
+                "sequence_index": _integer(
+                    row["sequence_index"],
+                    f"{row_path}.sequence_index",
+                    minimum=0,
+                ),
+                "lane": lane,
+                "duration_seconds": duration,
+                "seconds_per_point": _positive_number(
+                    row["seconds_per_point"],
+                    f"{row_path}.seconds_per_point",
+                ),
+                "warmed_allocation_count": allocations,
+            }
+        )
+    if [row["sequence_index"] for row in parsed] != list(range(len(parsed))):
+        _error(path, "sequence indices must be ordered, dense, and zero-based")
+    pair_count = len(parsed) // 2
+    pairs: list[tuple[float, float]] = []
+    first_lane = str(parsed[0]["lane"])
+    second_lane = "candidate" if first_lane == "baseline" else "baseline"
+    for pair_index in range(pair_count):
+        first = parsed[2 * pair_index]
+        second = parsed[2 * pair_index + 1]
+        if first["pair_index"] != pair_index or second["pair_index"] != pair_index:
+            _error(path, "pair indices must be dense and align with sequence order")
+        expected_order = (
+            (first_lane, second_lane)
+            if pair_index % 2 == 0
+            else (second_lane, first_lane)
+        )
+        if (first["lane"], second["lane"]) != expected_order:
+            _error(path, "subprocess lane order must alternate between pairs")
+        by_lane = {str(first["lane"]): first, str(second["lane"]): second}
+        pairs.append(
+            (
+                float(by_lane["baseline"]["seconds_per_point"]),
+                float(by_lane["candidate"]["seconds_per_point"]),
+            )
+        )
+    baseline_values = [pair[0] for pair in pairs]
+    candidate_values = [pair[1] for pair in pairs]
+    changes = [baseline - candidate for baseline, candidate in pairs]
+    baseline_median, baseline_mad = _median_and_mad(baseline_values)
+    candidate_median, candidate_mad = _median_and_mad(candidate_values)
+    change_median, change_mad = _median_and_mad(changes)
+    return {
+        "pair_count": pair_count,
+        "baseline_median_seconds_per_point": baseline_median,
+        "baseline_mad_seconds_per_point": baseline_mad,
+        "candidate_median_seconds_per_point": candidate_median,
+        "candidate_mad_seconds_per_point": candidate_mad,
+        "paired_change_median_seconds_per_point": change_median,
+        "paired_change_mad_seconds_per_point": change_mad,
+        "relative_gain": (baseline_median - candidate_median) / baseline_median,
+        "paired_change_beyond_three_mad": (change_median > MAD_MULTIPLIER * change_mad),
+        "candidate_warmed_allocation_count": max(
+            int(row["warmed_allocation_count"])
+            for row in parsed
+            if row["lane"] == "candidate"
+        ),
+    }
+
+
+def _validate_workload(value: object, path: str) -> None:
+    workload = _mapping(value, path)
+    _exact_keys(
+        workload,
+        {
+            "process",
+            "color_accuracy",
+            "lc_flow_layout",
+            "selected_flow",
+            "helicity_mode",
+            "source_sha256",
+            "model_sha256",
+            "point_set_sha256",
+            "runtime_target_sha256",
+            "host_sha256",
+        },
+        path,
+    )
+    expected = {
+        "process": TARGET_PROCESS,
+        "color_accuracy": TARGET_COLOR_ACCURACY,
+        "lc_flow_layout": TARGET_LAYOUT,
+        "selected_flow": TARGET_FLOW,
+        "helicity_mode": TARGET_HELICITY_MODE,
+    }
+    for field, expected_value in expected.items():
+        if workload[field] != expected_value:
+            _error(f"{path}.{field}", f"expected {expected_value!r}")
+    for field in (
+        "source_sha256",
+        "model_sha256",
+        "point_set_sha256",
+        "runtime_target_sha256",
+        "host_sha256",
+    ):
+        _sha256(workload[field], f"{path}.{field}")
+
+
+def _validate_dependency(value: object, path: str) -> None:
+    dependency = _mapping(value, path)
+    _exact_keys(
+        dependency,
+        {
+            "source",
+            "version",
+            "local_patch_count",
+            "direct_application_abi",
+            "direct_table_binding_abi",
+            "direct_table_descriptor_abi",
+        },
+        path,
+    )
+    expected = {
+        "source": DEPENDENCY_SOURCE,
+        "version": DEPENDENCY_VERSION,
+        "local_patch_count": 0,
+        "direct_application_abi": DIRECT_APPLICATION_ABI,
+        "direct_table_binding_abi": DIRECT_TABLE_BINDING_ABI,
+        "direct_table_descriptor_abi": DIRECT_TABLE_DESCRIPTOR_ABI,
+    }
+    for field, expected_value in expected.items():
+        if dependency[field] != expected_value:
+            _error(f"{path}.{field}", f"expected {expected_value!r}")
+
+
+def _gate(
+    gates: dict[str, dict[str, object]],
+    name: str,
+    passed: bool,
+    **details: object,
+) -> None:
+    gates[name] = {"passes": bool(passed), **details}
+
+
+def _validate_regressions(
+    functional_value: object,
+    performance_value: object,
+    gates: dict[str, dict[str, object]],
+) -> None:
+    functional_rows = _sequence(functional_value, "campaign.regression_cases")
+    seen: set[str] = set()
+    for index, raw_case in enumerate(functional_rows):
+        path = f"campaign.regression_cases[{index}]"
+        case = _mapping(raw_case, path)
+        _exact_keys(case, {"name", "passed", "evidence_sha256"}, path)
+        name = _string(case["name"], f"{path}.name")
+        if name in seen:
+            _error(f"{path}.name", "duplicate regression case")
+        seen.add(name)
+        if not isinstance(case["passed"], bool):
+            _error(f"{path}.passed", "expected a boolean")
+        _sha256(case["evidence_sha256"], f"{path}.evidence_sha256")
+        _gate(gates, f"regression:{name}", bool(case["passed"]))
+    missing = sorted(REQUIRED_REGRESSION_CASES - seen)
+    if missing:
+        _error("campaign.regression_cases", f"missing required cases: {missing}")
+
+    performance_rows = _sequence(
+        performance_value,
+        "campaign.non_target_performance",
+    )
+    performance_seen: set[str] = set()
+    for index, raw_lane in enumerate(performance_rows):
+        path = f"campaign.non_target_performance[{index}]"
+        lane = _mapping(raw_lane, path)
+        _exact_keys(
+            lane,
+            {"name", "baseline_seconds_per_point", "candidate_seconds_per_point"},
+            path,
+        )
+        name = _string(lane["name"], f"{path}.name")
+        if name in performance_seen:
+            _error(f"{path}.name", "duplicate performance lane")
+        performance_seen.add(name)
+        baseline = [
+            _positive_number(
+                item,
+                f"{path}.baseline_seconds_per_point[{item_index}]",
+            )
+            for item_index, item in enumerate(
+                _sequence(
+                    lane["baseline_seconds_per_point"],
+                    f"{path}.baseline_seconds_per_point",
+                )
+            )
+        ]
+        candidate = [
+            _positive_number(
+                item,
+                f"{path}.candidate_seconds_per_point[{item_index}]",
+            )
+            for item_index, item in enumerate(
+                _sequence(
+                    lane["candidate_seconds_per_point"],
+                    f"{path}.candidate_seconds_per_point",
+                )
+            )
+        ]
+        if len(baseline) < MIN_SAMPLE_PAIRS or len(candidate) < MIN_SAMPLE_PAIRS:
+            _error(path, "requires at least seven samples in each lane")
+        baseline_median, baseline_mad = _median_and_mad(baseline)
+        candidate_median, _ = _median_and_mad(candidate)
+        relative_regression = (candidate_median - baseline_median) / baseline_median
+        absolute_regression = candidate_median - baseline_median
+        passed = (
+            relative_regression <= MAX_NON_TARGET_REGRESSION
+            or absolute_regression <= MAD_MULTIPLIER * baseline_mad
+        )
+        _gate(
+            gates,
+            f"non_target_performance:{name}",
+            passed,
+            relative_regression=relative_regression,
+            absolute_regression_seconds_per_point=absolute_regression,
+            baseline_mad_seconds_per_point=baseline_mad,
+        )
+    missing_performance = sorted(REQUIRED_NON_TARGET_PERFORMANCE - performance_seen)
+    if missing_performance:
+        _error(
+            "campaign.non_target_performance",
+            f"missing required lanes: {missing_performance}",
+        )
+
+
+def audit_campaign(value: object) -> dict[str, object]:
+    """Audit a complete baseline/candidate campaign."""
+
+    campaign = _mapping(value, "campaign")
+    _exact_keys(
+        campaign,
+        {
+            "kind",
+            "schema_version",
+            "content_sha256",
+            "dependency",
+            "workload",
+            "baseline",
+            "candidate",
+            "batches",
+            "regression_cases",
+            "non_target_performance",
+        },
+        "campaign",
+    )
+    if campaign["kind"] != CAMPAIGN_KIND:
+        _error("campaign.kind", f"expected {CAMPAIGN_KIND!r}")
+    if campaign["schema_version"] != CAMPAIGN_SCHEMA_VERSION:
+        _error("campaign.schema_version", "unsupported campaign schema")
+    declared_digest = _sha256(
+        campaign["content_sha256"],
+        "campaign.content_sha256",
+    )
+    actual_digest = canonical_sha256(
+        {key: item for key, item in campaign.items() if key != "content_sha256"}
+    )
+    if declared_digest != actual_digest:
+        _error(
+            "campaign.content_sha256",
+            f"declared {declared_digest}, computed {actual_digest}",
+        )
+    _validate_dependency(campaign["dependency"], "campaign.dependency")
+    _validate_workload(campaign["workload"], "campaign.workload")
+    baseline = _validate_artifact_metrics(campaign["baseline"], "campaign.baseline")
+    candidate, candidate_summary = _validate_candidate(
+        campaign["candidate"],
+        "campaign.candidate",
+    )
+
+    gates: dict[str, dict[str, object]] = {}
+    resource_fields = (
+        "generation_seconds",
+        "artifact_bytes",
+        "load_seconds",
+        "peak_rss_bytes",
+    )
+    for field in resource_fields:
+        baseline_value = float(baseline[field])
+        candidate_value = float(candidate[field])
+        ratio = candidate_value / baseline_value
+        _gate(
+            gates,
+            f"resource:{field}",
+            ratio <= 1.0 + MAX_RESOURCE_REGRESSION,
+            candidate_to_baseline_ratio=ratio,
+        )
+    code_size_available = (
+        baseline["code_size_metric_available"] is True
+        and candidate["code_size_metric_available"] is True
+    )
+    if code_size_available:
+        machine_code_ratio = float(candidate["selected_machine_code_bytes"]) / float(
+            baseline["selected_machine_code_bytes"]
+        )
+        _gate(
+            gates,
+            "selected_machine_code_reduction",
+            machine_code_ratio <= 1.0 - MIN_CODE_SIZE_REDUCTION,
+            metric_available=True,
+            candidate_to_baseline_ratio=machine_code_ratio,
+        )
+    else:
+        _gate(
+            gates,
+            "selected_machine_code_reduction",
+            False,
+            metric_available=False,
+            reason=(
+                "exact residual portable-source-application machine-code "
+                "shape is unavailable from the pinned SymJIT API"
+            ),
+        )
+    diagnostics = _mapping(
+        candidate_summary["diagnostics"],
+        "candidate_summary.diagnostics",
+    )
+    batches = _mapping(campaign["batches"], "campaign.batches")
+    if set(batches) != {str(batch) for batch in REQUIRED_BATCHES}:
+        _error(
+            "campaign.batches",
+            f"must contain exactly batches {list(REQUIRED_BATCHES)}",
+        )
+    batch_summaries: dict[str, object] = {}
+    measured_candidate_allocations = 0
+    workload = _mapping(campaign["workload"], "campaign.workload")
+    for batch in REQUIRED_BATCHES:
+        path = f"campaign.batches.{batch}"
+        batch_value = _mapping(batches[str(batch)], path)
+        _exact_keys(
+            batch_value,
+            {"point_set_sha256", "correctness", "measurements"},
+            path,
+        )
+        point_digest = _sha256(
+            batch_value["point_set_sha256"],
+            f"{path}.point_set_sha256",
+        )
+        if point_digest != workload["point_set_sha256"]:
+            _error(
+                f"{path}.point_set_sha256",
+                "must match the campaign point-set identity",
+            )
+        correctness = _validate_correctness(
+            batch_value["correctness"],
+            f"{path}.correctness",
+            batch,
+        )
+        measurements = _validate_measurements(
+            batch_value["measurements"],
+            f"{path}.measurements",
+        )
+        measured_candidate_allocations = max(
+            measured_candidate_allocations,
+            int(measurements["candidate_warmed_allocation_count"]),
+        )
+        batch_summaries[str(batch)] = {
+            "correctness": correctness,
+            "performance": measurements,
+        }
+        relative_gain = float(measurements["relative_gain"])
+        if batch in PRIMARY_BATCHES:
+            _gate(
+                gates,
+                f"primary_gain:batch_{batch}",
+                (
+                    relative_gain >= MIN_PRIMARY_GAIN
+                    and bool(measurements["paired_change_beyond_three_mad"])
+                ),
+                relative_gain=relative_gain,
+                paired_change_beyond_three_mad=measurements[
+                    "paired_change_beyond_three_mad"
+                ],
+            )
+        if batch == 1:
+            regression = -relative_gain
+            _gate(
+                gates,
+                "batch_1_regression",
+                regression <= MAX_BATCH_ONE_REGRESSION,
+                relative_regression=regression,
+            )
+    warmed_allocations = max(
+        int(diagnostics["warmed_allocation_count"]),
+        measured_candidate_allocations,
+    )
+    _gate(
+        gates,
+        "zero_warmed_allocations",
+        warmed_allocations == 0,
+        warmed_allocation_count=warmed_allocations,
+    )
+    _validate_regressions(
+        campaign["regression_cases"],
+        campaign["non_target_performance"],
+        gates,
+    )
+
+    return {
+        "kind": RESULT_KIND,
+        "schema_version": RESULT_SCHEMA_VERSION,
+        "campaign_sha256": declared_digest,
+        "passes": all(bool(gate["passes"]) for gate in gates.values()),
+        "gates": gates,
+        "candidate": candidate_summary,
+        "code_size_diagnostics": {
+            "baseline_metric_available": baseline["code_size_metric_available"],
+            "candidate_metric_available": candidate["code_size_metric_available"],
+            "baseline_metric_kind": baseline["code_size_metric_kind"],
+            "candidate_metric_kind": candidate["code_size_metric_kind"],
+            "baseline_portable_source_application_bytes": baseline[
+                "portable_source_application_bytes"
+            ],
+            "candidate_portable_source_application_bytes": candidate[
+                "portable_source_application_bytes"
+            ],
+            "portable_source_metric_is_machine_code": False,
+        },
+        "batches": batch_summaries,
+    }
+
+
+def _reject_duplicate_pairs(pairs: list[tuple[str, object]]) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in pairs:
+        if key in result:
+            raise AcceptanceError(f"duplicate JSON object key {key!r}")
+        result[key] = value
+    return result
+
+
+def load_campaign(path: Path) -> Mapping[str, object]:
+    """Load JSON while rejecting duplicate keys and non-finite constants."""
+
+    def reject_constant(value: str) -> object:
+        raise AcceptanceError(f"non-finite JSON constant {value!r}")
+
+    try:
+        value = json.loads(
+            path.read_text(encoding="utf-8"),
+            object_pairs_hook=_reject_duplicate_pairs,
+            parse_constant=reject_constant,
+        )
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise AcceptanceError(f"cannot load {path}: {exc}") from exc
+    return _mapping(value, str(path))
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("campaign", type=Path)
+    parser.add_argument(
+        "--output",
+        type=Path,
+        help="write the acceptance result as canonical JSON",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        result = audit_campaign(load_campaign(args.campaign))
+    except AcceptanceError as exc:
+        print(f"compiled-microkernel-acceptance: {exc}", file=sys.stderr)
+        return 2
+    rendered = json.dumps(result, indent=2, sort_keys=True) + "\n"
+    if args.output is None:
+        sys.stdout.write(rendered)
+    else:
+        args.output.write_text(rendered, encoding="utf-8")
+    return 0 if result["passes"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/compiled_mode_matrix.py b/pyamplicol/tools/developer/compiled_mode_matrix.py
new file mode 100644
index 0000000000..82aced6962
--- /dev/null
+++ b/pyamplicol/tools/developer/compiled_mode_matrix.py
@@ -0,0 +1,1640 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run and audit the frozen 168-cell Direct-Arena acceptance matrix.
+
+Each cell is measured by ``compiled_mode_regression.py``.  This outer driver
+adds the acceptance rules that cannot be established by one cell in isolation:
+exact matrix completeness, stable runtime/provenance identity, a measured
+10% gain beyond noise in each execution mode, and a generation-time geometric
+mean no more than 5% above the frozen baseline.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import platform
+import subprocess
+import sys
+from collections import Counter, defaultdict
+from collections.abc import Mapping, Sequence
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.developer import compiled_mode_regression as regression  # noqa: E402
+
+CELL_DRIVER = ROOT / "tools" / "developer" / "compiled_mode_regression.py"
+RESULT_KIND = "pyamplicol-compiled-mode-acceptance-matrix"
+SCHEMA_VERSION = 2
+MATRIX_CONTRACT = "eager-and-compiled-arena-plan-168-v2"
+BATCH_SIZES = (1, 128, 1024)
+EXECUTION_MODES = ("eager", "compiled")
+GENERATION_GEOMETRIC_MEAN_MAXIMUM = 1.05
+DEFAULT_MATRIX_GENERATION_TIMEOUT = 2400.0
+DEFAULT_MATRIX_PROFILE_TIMEOUT = 1200.0
+ACCEPTANCE_SAMPLE_COUNT = regression.DEFAULT_SAMPLE_COUNT
+ACCEPTANCE_TARGET_RUNTIME_SECONDS = regression.DEFAULT_TARGET_RUNTIME
+ACCEPTANCE_MINIMUM_TIMED_BLOCKS = regression.DEFAULT_SAMPLE_COUNT
+ACCEPTANCE_WARMUP_RUNS = regression.DEFAULT_WARMUP_RUNS
+FROZEN_BASELINE_SOURCE_REVISION = "443f354a467cdda187996bef1a41fbd5a00ae28d"
+FROZEN_BASELINE_NATIVE_INPUTS_SHA256 = (
+    "f91ebcc3eb431e3e1e72ac8a4e02dea194c17c2118f57a2742d0c8c5a73b3088"
+)
+FROZEN_BASELINE_DISTRIBUTION_SHA256 = (
+    "c615b3753eeedc427a03ff063804926be4d77994d4ab14579c8256dbd390d003"
+)
+FROZEN_BASELINE_NATIVE_MODULE_SHA256 = (
+    "055d28af8101603c3d0431fa6bfd288d9fb62fe8434201404a8c709f261c7349"
+)
+FROZEN_BASELINE_BINARY_IDENTITIES = {
+    ("Darwin", "arm64"): {
+        "distribution_content_sha256": FROZEN_BASELINE_DISTRIBUTION_SHA256,
+        "native_module_sha256": FROZEN_BASELINE_NATIVE_MODULE_SHA256,
+    }
+}
+_HEX_SHA256_LENGTH = 64
+_HEX_GIT_SHA_LENGTH = 40
+
+
+class MatrixError(RuntimeError):
+    """Raised when the matrix cannot be run or audited."""
+
+
+@dataclass(frozen=True, slots=True)
+class MatrixCell:
+    category: str
+    process_key: str
+    process: str
+    model_kind: str
+    execution_mode: str
+    workload_key: str
+    workload: str
+    color_accuracy: str
+    lc_flow_layout: str
+    jit_optimization_level: int
+    batch_size: int
+    helicities: tuple[str, ...] = ()
+    color_flows: tuple[str, ...] = ()
+
+    @property
+    def cell_id(self) -> str:
+        return "__".join(
+            (
+                self.category,
+                self.process_key,
+                self.model_kind,
+                self.execution_mode,
+                self.workload_key,
+                f"b{self.batch_size}",
+            )
+        )
+
+    @property
+    def artifact_group_id(self) -> str:
+        """Identify the generation inputs shared across timing-only batches."""
+
+        return "__".join(
+            (
+                self.category,
+                self.process_key,
+                self.model_kind,
+                self.execution_mode,
+                f"o{self.jit_optimization_level}",
+                self.color_accuracy,
+                self.lc_flow_layout,
+            )
+        )
+
+
+LC_WORKLOADS = (
+    {
+        "workload_key": "lc-topology",
+        "workload": "single-flow-helicity-sum",
+        "color_accuracy": "lc",
+        "lc_flow_layout": "topology-replay",
+        "helicities": (),
+        "color_flows": ("1",),
+    },
+    {
+        "workload_key": "lc-union",
+        "workload": "all-flow-single-helicity",
+        "color_accuracy": "lc",
+        "lc_flow_layout": "all-flow-union",
+        "helicities": ("1",),
+        "color_flows": (),
+    },
+)
+PRIMARY_LC_WORKLOADS = (
+    {
+        "workload_key": "lc-topology",
+        "workload": "single-flow-helicity-sum",
+        "color_accuracy": "lc",
+        "lc_flow_layout": "topology-replay",
+        "helicities": (),
+        "color_flows": ("flow:2,4,5,6,7,8,9,1",),
+    },
+    {
+        "workload_key": "lc-union",
+        "workload": "all-flow-single-helicity",
+        "color_accuracy": "lc",
+        "lc_flow_layout": "all-flow-union",
+        "helicities": ("h:-1,+1,-1,+1,-1,+1,-1,+1,-1",),
+        "color_flows": (),
+    },
+)
+SUMMED_WORKLOADS = (
+    {
+        "workload_key": "nlc-summed",
+        "workload": "summed",
+        "color_accuracy": "nlc",
+        "lc_flow_layout": "topology-replay",
+        "helicities": (),
+        "color_flows": (),
+    },
+    {
+        "workload_key": "full-summed",
+        "workload": "summed",
+        "color_accuracy": "full",
+        "lc_flow_layout": "topology-replay",
+        "helicities": (),
+        "color_flows": (),
+    },
+)
+MEDIUM_PROCESSES = (
+    ("dd_z_3g", "d d~ > z g g g"),
+    ("gg_tt_2g", "g g > t t~ g g"),
+    ("gg_4g", "g g > g g g g"),
+    ("dd_3q_1g", "d d~ > u u~ s s~ g"),
+    ("dd_tt_3g", "d d~ > t t~ g g g"),
+)
+COLOR_HEAVY_PROCESSES = (
+    ("gg_tt_3g", "g g > t t~ g g g"),
+    ("gg_tt_4g", "g g > t t~ g g g g"),
+)
+
+
+def _cells_for(
+    *,
+    category: str,
+    processes: Sequence[tuple[str, str]],
+    model_kinds: Sequence[str],
+    workloads: Sequence[Mapping[str, object]],
+) -> list[MatrixCell]:
+    return [
+        MatrixCell(
+            category=category,
+            process_key=process_key,
+            process=process,
+            model_kind=model_kind,
+            execution_mode=execution_mode,
+            jit_optimization_level=2 if execution_mode == "eager" else 3,
+            batch_size=batch_size,
+            **workload,
+        )
+        for process_key, process in processes
+        for model_kind in model_kinds
+        for execution_mode in EXECUTION_MODES
+        for workload in workloads
+        for batch_size in BATCH_SIZES
+    ]
+
+
+def canonical_cells() -> tuple[MatrixCell, ...]:
+    """Return the exact matrix documented in the Arena implementation plan."""
+
+    cells = [
+        *_cells_for(
+            category="primary",
+            processes=(("uu_z_6g", "u u~ > z g g g g g g"),),
+            model_kinds=("built-in", "ufo-sm"),
+            workloads=PRIMARY_LC_WORKLOADS,
+        ),
+        *_cells_for(
+            category="medium",
+            processes=MEDIUM_PROCESSES,
+            model_kinds=("built-in",),
+            workloads=(*LC_WORKLOADS, *SUMMED_WORKLOADS),
+        ),
+        *_cells_for(
+            category="color-heavy",
+            processes=COLOR_HEAVY_PROCESSES,
+            model_kinds=("built-in",),
+            workloads=SUMMED_WORKLOADS,
+        ),
+    ]
+    if len(cells) != 168 or len({cell.cell_id for cell in cells}) != 168:
+        raise AssertionError("the frozen Direct-Arena matrix must contain 168 cells")
+    return tuple(cells)
+
+
+CANONICAL_CELLS = canonical_cells()
+
+
+def _absolute(path: Path) -> Path:
+    return Path(os.path.abspath(path.expanduser()))
+
+
+def _canonical_sha256(value: object) -> str:
+    encoded = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp")
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    temporary.replace(path)
+
+
+def _json_object(path: Path) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise MatrixError(f"cannot read matrix cell result: {path}") from error
+    if not isinstance(payload, dict):
+        raise MatrixError(f"matrix cell result is not an object: {path}")
+    return payload
+
+
+def _model(cell: MatrixCell, ufo_sm_model: Path) -> tuple[str, str]:
+    if cell.model_kind == "built-in":
+        return "built-in-sm", "built-in"
+    return str(_absolute(ufo_sm_model)), "ufo-sm"
+
+
+def cell_command(
+    cell: MatrixCell,
+    *,
+    baseline_python: Path,
+    current_python: Path,
+    output_root: Path,
+    ufo_sm_model: Path,
+    baseline_dependency_site: Path | None = None,
+    current_dependency_site: Path | None = None,
+    samples: int = regression.DEFAULT_SAMPLE_COUNT,
+    target_runtime: float = regression.DEFAULT_TARGET_RUNTIME,
+    minimum_samples: int = regression.DEFAULT_SAMPLE_COUNT,
+    warmup_runs: int = regression.DEFAULT_WARMUP_RUNS,
+    generation_timeout: float = DEFAULT_MATRIX_GENERATION_TIMEOUT,
+    profile_timeout: float = DEFAULT_MATRIX_PROFILE_TIMEOUT,
+    regenerate_artifacts: bool = False,
+) -> tuple[str, ...]:
+    """Build the one-cell command without weakening the cell driver's gates."""
+
+    model, model_label = _model(cell, ufo_sm_model)
+    command = [
+        str(_absolute(current_python)),
+        str(CELL_DRIVER),
+        "--baseline-python",
+        str(_absolute(baseline_python)),
+        "--current-python",
+        str(_absolute(current_python)),
+        "--output-root",
+        str(_absolute(output_root) / "artifact-groups" / cell.artifact_group_id),
+        "--result-path",
+        str(_absolute(output_root) / "cells" / cell.cell_id / "result.json"),
+        "--process",
+        cell.process,
+        "--model",
+        model,
+        "--model-label",
+        model_label,
+        "--execution-mode",
+        cell.execution_mode,
+        "--jit-optimization-level",
+        str(cell.jit_optimization_level),
+        "--workload",
+        cell.workload,
+        "--color",
+        cell.color_accuracy,
+        "--lc-flow-layout",
+        cell.lc_flow_layout,
+        "--batch-size",
+        str(cell.batch_size),
+        "--samples",
+        str(samples),
+        "--target-runtime",
+        str(target_runtime),
+        "--minimum-samples",
+        str(minimum_samples),
+        "--warmup-runs",
+        str(warmup_runs),
+        "--generation-timeout",
+        str(generation_timeout),
+        "--profile-timeout",
+        str(profile_timeout),
+    ]
+    for helicity in cell.helicities:
+        command.extend(("--helicity", helicity))
+    for color_flow in cell.color_flows:
+        command.extend(("--color-flow", color_flow))
+    for option, site in (
+        ("--baseline-dependency-site", baseline_dependency_site),
+        ("--current-dependency-site", current_dependency_site),
+    ):
+        if site is not None:
+            command.extend((option, str(_absolute(site))))
+    if regenerate_artifacts:
+        command.append("--regenerate-artifacts")
+    return tuple(command)
+
+
+def _finite_positive(value: object) -> float | None:
+    if (
+        isinstance(value, (float, int))
+        and not isinstance(value, bool)
+        and math.isfinite(float(value))
+        and float(value) > 0.0
+    ):
+        return float(value)
+    return None
+
+
+def _is_sha256(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and len(value) == _HEX_SHA256_LENGTH
+        and all(character in "0123456789abcdef" for character in value)
+    )
+
+
+def _is_git_sha(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and len(value) == _HEX_GIT_SHA_LENGTH
+        and all(character in "0123456789abcdef" for character in value)
+    )
+
+
+def _mapping(value: object) -> Mapping[str, Any] | None:
+    return value if isinstance(value, Mapping) else None
+
+
+def _stable_file_identity_value(value: object) -> object:
+    """Remove observational mtimes but retain content and path identities.
+
+    Git checkout and artifact-extraction mtimes vary between independent x86
+    shard runners.  Resolved paths, sizes, and SHA-256 digests remain part of
+    the identity.  This projection is deliberately limited to ``mtime_ns``;
+    it does not rewrite paths or any digest-covered runtime object.
+    """
+
+    if isinstance(value, Mapping):
+        return {
+            key: _stable_file_identity_value(item)
+            for key, item in value.items()
+            if key != "mtime_ns"
+        }
+    if isinstance(value, list):
+        return [_stable_file_identity_value(item) for item in value]
+    if isinstance(value, tuple):
+        return tuple(_stable_file_identity_value(item) for item in value)
+    return value
+
+
+def _stable_runtime_identity_value(
+    value: object,
+    *,
+    _root: bool = True,
+) -> object:
+    """Project a runtime identity onto cross-runner immutable observations.
+
+    The top-level kernel/platform string and filesystem mtimes are host
+    observations.  Fixed paths, Python/package versions, sizes, every digest,
+    build provenance, native inputs, and dependency identities remain exact.
+    """
+
+    if isinstance(value, Mapping):
+        return {
+            key: _stable_runtime_identity_value(item, _root=False)
+            for key, item in value.items()
+            if key != "mtime_ns" and not (_root and key == "platform")
+        }
+    if isinstance(value, list):
+        return [_stable_runtime_identity_value(item, _root=False) for item in value]
+    if isinstance(value, tuple):
+        return tuple(
+            _stable_runtime_identity_value(item, _root=False) for item in value
+        )
+    return value
+
+
+def _installation_identity_errors(
+    identity: object,
+    *,
+    expected: Mapping[str, str] | None,
+    label: str,
+) -> list[str]:
+    errors: list[str] = []
+    record = _mapping(identity)
+    if record is None:
+        return [f"{label} installation identity is absent"]
+    if record.get("kind") != regression.INSTALLATION_IDENTITY_KIND:
+        errors.append(f"{label} installation identity kind is invalid")
+    if record.get("schema_version") != regression.INSTALLATION_IDENTITY_SCHEMA_VERSION:
+        errors.append(f"{label} installation identity schema is invalid")
+    distribution = _mapping(record.get("distribution_content"))
+    distribution_sha = distribution.get("sha256") if distribution is not None else None
+    native_modules = record.get("native_modules")
+    native_module = (
+        _mapping(native_modules[0])
+        if isinstance(native_modules, Sequence)
+        and not isinstance(native_modules, (str, bytes))
+        and len(native_modules) == 1
+        else None
+    )
+    native_sha = native_module.get("sha256") if native_module is not None else None
+    build_info_files = record.get("build_info_files")
+    build_info = (
+        _mapping(build_info_files[0])
+        if isinstance(build_info_files, Sequence)
+        and not isinstance(build_info_files, (str, bytes))
+        and len(build_info_files) == 1
+        else None
+    )
+    payload = _mapping(build_info.get("payload")) if build_info is not None else None
+    if expected is None:
+        return [*errors, f"{label} expected build identity is absent"]
+    expected_distribution = expected.get("distribution_content_sha256")
+    expected_native = expected.get("native_module_sha256")
+    expected_revision = expected.get("source_revision")
+    expected_native_inputs = expected.get("native_build_inputs_sha256")
+    if (
+        not _is_sha256(expected_distribution)
+        or distribution_sha != expected_distribution
+    ):
+        errors.append(f"{label} distribution content does not match its pin")
+    if not _is_sha256(expected_native) or native_sha != expected_native:
+        errors.append(f"{label} native module does not match its pin")
+    if payload is None:
+        errors.append(f"{label} installed build provenance is absent")
+    else:
+        if (
+            not _is_git_sha(expected_revision)
+            or payload.get("source_revision") != expected_revision
+        ):
+            errors.append(f"{label} source revision does not match its pin")
+        if (
+            not _is_sha256(expected_native_inputs)
+            or payload.get("native_build_inputs_sha256") != expected_native_inputs
+        ):
+            errors.append(f"{label} native build inputs do not match their pin")
+        if payload.get("publishable") is not False:
+            errors.append(f"{label} build is not a non-publishable candidate")
+        bootstrap = payload.get("selftest_fixture_bootstrap")
+        if (label == "current" and bootstrap is not False) or (
+            label != "current" and bootstrap is not None and bootstrap is not False
+        ):
+            errors.append(f"{label} build is a self-test bootstrap wheel")
+    return errors
+
+
+def _cell_evidence(
+    cell: MatrixCell,
+    result: Mapping[str, Any],
+    *,
+    baseline_python: Path,
+    current_python: Path,
+    ufo_sm_model: Path,
+    output_root: Path,
+    expected_platform: str,
+    expected_builds: Mapping[str, Mapping[str, str]],
+) -> dict[str, Any]:
+    errors: list[str] = []
+    model, model_label = _model(cell, ufo_sm_model)
+    expected_configuration = {
+        "baseline_python": str(_absolute(baseline_python)),
+        "current_python": str(_absolute(current_python)),
+        "output_root": str(
+            _absolute(output_root) / "artifact-groups" / cell.artifact_group_id
+        ),
+        "process": cell.process,
+        "model": model,
+        "model_label": model_label,
+        "execution_mode": cell.execution_mode,
+        "workload": cell.workload,
+        "jit_optimization_level": cell.jit_optimization_level,
+        "color_accuracy": cell.color_accuracy,
+        "lc_flow_layout": cell.lc_flow_layout,
+        "shared_artifact": None,
+        "batch_size": cell.batch_size,
+        "helicities": list(cell.helicities),
+        "color_flows": list(cell.color_flows),
+    }
+    if result.get("kind") != regression.RESULT_KIND:
+        errors.append("unexpected result kind")
+    if result.get("schema_version") != regression.SCHEMA_VERSION:
+        errors.append("unexpected result schema")
+    if result.get("platform") != expected_platform:
+        errors.append("result platform does not match the acceptance host")
+    for field in ("complete", "performance_result_authoritative", "passes"):
+        if result.get(field) is not True:
+            errors.append(f"{field} is not true")
+    configuration = _mapping(result.get("configuration"))
+    if configuration is None:
+        errors.append("configuration is absent")
+    else:
+        for key, expected in expected_configuration.items():
+            if configuration.get(key) != expected:
+                errors.append(f"configuration.{key} does not match the matrix")
+        methodology = {
+            "independent_samples_per_lane": ACCEPTANCE_SAMPLE_COUNT,
+            "target_runtime_per_native_sample_seconds": (
+                ACCEPTANCE_TARGET_RUNTIME_SECONDS
+            ),
+            "minimum_native_timed_blocks_per_profile": (
+                ACCEPTANCE_MINIMUM_TIMED_BLOCKS
+            ),
+            "warmup_runs_per_profile": ACCEPTANCE_WARMUP_RUNS,
+            "native_wall_time_source": regression.NATIVE_WALL_TIME_SOURCE,
+            "native_wall_time_sample_pass": regression.NATIVE_WALL_TIME_SAMPLE_PASS,
+            "required_current_profile_attribution_sample_pass": (
+                regression.PROFILE_ATTRIBUTION_SAMPLE_PASS
+            ),
+            "required_current_profile_attribution_boundary": (
+                regression.ARENA_PROFILE_BOUNDARY
+            ),
+            "required_current_profile_attribution_phase_timing_scope": (
+                regression.ARENA_PHASE_TIMING_SCOPE
+            ),
+            "required_current_profile_attribution_evaluator_timing_available": False,
+            "required_current_profile_protocol": regression.ARENA_PROFILE_PROTOCOL,
+            "timing_sample_contract": regression.PAIRED_TIMING_SAMPLE_CONTRACT,
+        }
+        numeric_minimums = {
+            "independent_samples_per_lane",
+            "minimum_native_timed_blocks_per_profile",
+            "warmup_runs_per_profile",
+            "target_runtime_per_native_sample_seconds",
+        }
+        for key, minimum_or_expected in methodology.items():
+            observed = configuration.get(key)
+            if key in numeric_minimums:
+                if (
+                    isinstance(observed, bool)
+                    or not isinstance(observed, (int, float))
+                    or float(observed) < float(minimum_or_expected)
+                ):
+                    errors.append(
+                        f"configuration.{key} is below the acceptance minimum"
+                    )
+            elif observed != minimum_or_expected:
+                errors.append(f"configuration.{key} violates the timing contract")
+    for gate_name in (
+        "gate",
+        "correctness_gate",
+        "arena_profile_gate",
+        "resource_gate",
+    ):
+        gate = _mapping(result.get(gate_name))
+        if gate is None or gate.get("passes") is not True:
+            errors.append(f"{gate_name}.passes is not true")
+
+    gain = _mapping(result.get("gain_gate"))
+    gain_passes = False
+    relative_gain: float | None = None
+    if gain is None:
+        errors.append("gain_gate is absent")
+    else:
+        raw_relative_gain = gain.get("relative_gain")
+        if (
+            isinstance(raw_relative_gain, (float, int))
+            and not isinstance(raw_relative_gain, bool)
+            and math.isfinite(float(raw_relative_gain))
+        ):
+            relative_gain = float(raw_relative_gain)
+        else:
+            errors.append("gain_gate.relative_gain is invalid")
+        gain_passes = (
+            gain.get("passes") is True
+            and gain.get("at_least_ten_percent") is True
+            and gain.get("beyond_measurement_noise") is True
+            and relative_gain is not None
+            and relative_gain >= regression.GAIN_RELATIVE_THRESHOLD
+        )
+
+    resource_gate = _mapping(result.get("resource_gate"))
+    generation = (
+        _mapping(resource_gate.get("generation")) if resource_gate is not None else None
+    )
+    generation_ratio = (
+        _finite_positive(generation.get("current_over_baseline"))
+        if generation is not None
+        else None
+    )
+    if generation_ratio is None:
+        errors.append("generation ratio is absent or invalid")
+    elif generation_ratio > 1.10 or generation.get("passes") is not True:
+        errors.append("per-cell generation ratio gate failed")
+
+    artifacts = _mapping(result.get("artifacts"))
+    artifact_digests: dict[str, str] = {}
+    if artifacts is None:
+        errors.append("artifacts are absent")
+    else:
+        for lane in ("baseline", "current"):
+            artifact = _mapping(artifacts.get(lane))
+            expected_path = (
+                _absolute(output_root)
+                / "artifact-groups"
+                / cell.artifact_group_id
+                / lane
+                / "artifact"
+            )
+            if artifact is None:
+                errors.append(f"{lane} artifact identity is absent")
+                continue
+            if artifact.get("path") != str(expected_path):
+                errors.append(f"{lane} artifact path does not match the matrix")
+            errors.extend(
+                _installation_identity_errors(
+                    artifact.get("installation_identity"),
+                    expected=expected_builds.get(lane),
+                    label=lane,
+                )
+            )
+            artifact_digests[lane] = _canonical_sha256(
+                {
+                    key: artifact.get(key)
+                    for key in (
+                        "path",
+                        "artifact_id",
+                        "manifest_sha256",
+                        "tree_identity",
+                        "payload_digests",
+                        "installation_identity",
+                    )
+                }
+            )
+
+    native_hashes = _mapping(result.get("native_module_sha256_by_lane"))
+    runtime_digests: dict[str, str] = {}
+    measurement_counts: Counter[str] = Counter()
+    measurement_runtime_digests: defaultdict[str, set[str]] = defaultdict(set)
+    selected_nonzero_by_lane = {"baseline": False, "current": False}
+    measurements = result.get("measurements")
+    if not isinstance(measurements, list):
+        errors.append("measurements are absent")
+        measurements = []
+    for measurement in measurements:
+        if not isinstance(measurement, Mapping):
+            errors.append("measurement is not an object")
+            continue
+        lane = measurement.get("lane")
+        runtime_identity = measurement.get("runtime_identity")
+        if lane not in {"baseline", "current"} or not isinstance(
+            runtime_identity, Mapping
+        ):
+            errors.append("measurement lane/runtime identity is invalid")
+            continue
+        measurement_counts[str(lane)] += 1
+        measurement_runtime_digests[str(lane)].add(
+            _canonical_sha256(_stable_runtime_identity_value(runtime_identity))
+        )
+        numerical = _mapping(measurement.get("warmed_numerical_result"))
+        numerical_values = (
+            numerical.get("values_f64") if numerical is not None else None
+        )
+        if (
+            isinstance(numerical_values, Sequence)
+            and not isinstance(numerical_values, (str, bytes))
+            and any(
+                isinstance(value, (int, float))
+                and not isinstance(value, bool)
+                and math.isfinite(float(value))
+                and float(value) != 0.0
+                for value in numerical_values
+            )
+        ):
+            selected_nonzero_by_lane[str(lane)] = True
+        native = _mapping(runtime_identity.get("native_module"))
+        if (
+            native_hashes is None
+            or native is None
+            or native.get("sha256") != native_hashes.get(lane)
+        ):
+            errors.append(f"{lane} runtime/native-module identity mismatch")
+        expected_build = expected_builds.get(str(lane))
+        build_info = _mapping(runtime_identity.get("build_info"))
+        build_payload = (
+            _mapping(build_info.get("payload")) if build_info is not None else None
+        )
+        if expected_build is None or build_payload is None:
+            errors.append(f"{lane} runtime has no pinned build identity")
+        else:
+            expected_revision = expected_build.get("source_revision")
+            expected_native_inputs = expected_build.get("native_build_inputs_sha256")
+            expected_native_module = expected_build.get("native_module_sha256")
+            if (
+                not _is_git_sha(expected_revision)
+                or build_payload.get("source_revision") != expected_revision
+            ):
+                errors.append(f"{lane} source revision does not match its pin")
+            if (
+                not _is_sha256(expected_native_inputs)
+                or build_payload.get("native_build_inputs_sha256")
+                != expected_native_inputs
+                or runtime_identity.get("native_build_inputs_sha256")
+                != expected_native_inputs
+            ):
+                errors.append(f"{lane} native build inputs do not match their pin")
+            if build_payload.get("publishable") is not False:
+                errors.append(f"{lane} build is not a non-publishable candidate")
+            bootstrap = build_payload.get("selftest_fixture_bootstrap")
+            if (lane == "current" and bootstrap is not False) or (
+                lane != "current" and bootstrap is not None and bootstrap is not False
+            ):
+                errors.append(f"{lane} build is a self-test bootstrap wheel")
+            if native is None or native.get("sha256") != expected_native_module:
+                errors.append(f"{lane} native module does not match its pin")
+    expected_samples = (
+        configuration.get("independent_samples_per_lane")
+        if configuration is not None
+        else None
+    )
+    expected_pair_orders = (
+        [
+            ["baseline", "current"] if pair_index % 2 == 0 else ["current", "baseline"]
+            for pair_index in range(expected_samples)
+        ]
+        if isinstance(expected_samples, int)
+        and not isinstance(expected_samples, bool)
+        and expected_samples >= ACCEPTANCE_SAMPLE_COUNT
+        else None
+    )
+    if result.get("pair_orders") != expected_pair_orders:
+        errors.append("paired subprocess order is incomplete or not interleaved")
+    for lane in ("baseline", "current"):
+        native_sha = native_hashes.get(lane) if native_hashes is not None else None
+        if not _is_sha256(native_sha):
+            errors.append(f"{lane} native-module SHA-256 is invalid")
+        expected_native_sha = expected_builds.get(lane, {}).get("native_module_sha256")
+        if native_sha != expected_native_sha:
+            errors.append(f"{lane} native-module SHA-256 does not match its pin")
+        if (
+            not isinstance(expected_samples, int)
+            or isinstance(expected_samples, bool)
+            or expected_samples < 5
+            or measurement_counts[lane] != expected_samples
+        ):
+            errors.append(f"{lane} measurement coverage is incomplete")
+        digests = measurement_runtime_digests[lane]
+        if len(digests) != 1:
+            errors.append(f"{lane} runtime identity is not stable within the cell")
+        else:
+            runtime_digests[lane] = next(iter(digests))
+        if cell.workload != "summed" and not selected_nonzero_by_lane[lane]:
+            errors.append(f"{lane} selected workload is identically zero")
+
+    if artifacts is not None:
+        try:
+            recomputed_arena_profile_gate = regression._arena_profile_gate(
+                measurements,
+                execution_mode=cell.execution_mode,
+                artifacts=artifacts,
+                minimum_profile_timed_blocks=ACCEPTANCE_MINIMUM_TIMED_BLOCKS,
+            )
+        except regression.RegressionError as error:
+            errors.append(f"arena profile evidence cannot be recomputed: {error}")
+        else:
+            if recomputed_arena_profile_gate.get("passes") is not True:
+                errors.append(
+                    "arena profile evidence fails independent matrix recomputation"
+                )
+
+    provenance = _mapping(result.get("provenance"))
+    provenance_digests: dict[str, str] = {}
+    if provenance is None:
+        errors.append("provenance is absent")
+    else:
+        current_tool_paths = {
+            "driver": CELL_DRIVER,
+            "watchdog": regression.WATCHDOG,
+            "native_sample_helper": regression.NATIVE_SAMPLE_HELPER,
+            "dependency_entry": regression.DEPENDENCY_ENTRY,
+        }
+        for key in (
+            "driver",
+            "watchdog",
+            "native_sample_helper",
+            "dependency_entry",
+            "interpreters",
+            "dependency_sites",
+            "model",
+        ):
+            value = provenance.get(key)
+            if value is None:
+                errors.append(f"provenance.{key} is absent")
+            else:
+                provenance_digests[key] = _canonical_sha256(
+                    _stable_file_identity_value(value)
+                )
+                if key in current_tool_paths:
+                    record = _mapping(value)
+                    expected_sha = _sha256_file(current_tool_paths[key])
+                    if record is None or record.get("sha256") != expected_sha:
+                        errors.append(
+                            f"provenance.{key} does not match the current source"
+                        )
+        if configuration is not None and configuration.get(
+            "dependency_sites"
+        ) != provenance.get("dependency_sites"):
+            errors.append("configuration/provenance dependency identities differ")
+    return {
+        "cell_id": cell.cell_id,
+        "configuration": asdict(cell),
+        "result_content_sha256": _canonical_sha256(result),
+        "errors": errors,
+        "passes": not errors,
+        "gain_gate_passes": gain_passes,
+        "relative_gain": relative_gain,
+        "generation_current_over_baseline": generation_ratio,
+        "runtime_identity_sha256_by_lane": runtime_digests,
+        "native_module_sha256_by_lane": (
+            dict(native_hashes) if native_hashes is not None else {}
+        ),
+        "artifact_identity_sha256_by_lane": artifact_digests,
+        "provenance_sha256": provenance_digests,
+    }
+
+
+def audit_results(
+    results: Mapping[str, Mapping[str, Any]],
+    *,
+    baseline_python: Path,
+    current_python: Path,
+    ufo_sm_model: Path,
+    output_root: Path,
+    expected_platform: str,
+    expected_builds: Mapping[str, Mapping[str, str]],
+) -> dict[str, Any]:
+    """Audit exactly the frozen cell set and return a machine-readable verdict."""
+
+    expected = {cell.cell_id: cell for cell in CANONICAL_CELLS}
+    observed_ids = set(results)
+    missing = sorted(set(expected) - observed_ids)
+    unexpected = sorted(observed_ids - set(expected))
+    evidence = [
+        _cell_evidence(
+            expected[cell_id],
+            results[cell_id],
+            baseline_python=baseline_python,
+            current_python=current_python,
+            ufo_sm_model=ufo_sm_model,
+            output_root=output_root,
+            expected_platform=expected_platform,
+            expected_builds=expected_builds,
+        )
+        for cell_id in sorted(set(expected) & observed_ids)
+    ]
+    return audit_cell_evidence(
+        evidence,
+        missing=missing,
+        unexpected=unexpected,
+        expected_builds=expected_builds,
+    )
+
+
+def audit_cell_evidence(
+    evidence: Sequence[Mapping[str, Any]],
+    *,
+    missing: Sequence[str],
+    unexpected: Sequence[str],
+    expected_builds: Mapping[str, Mapping[str, str]],
+) -> dict[str, Any]:
+    """Aggregate already authenticated cell evidence for the frozen matrix.
+
+    The regular single-host driver builds this evidence directly above.  The
+    x86 shard aggregator uses the same function after each shard has validated
+    its own host-local paths and artifact trees.  Keeping the global gates in
+    one function prevents the sharded path from weakening the 168-cell
+    acceptance contract.
+    """
+
+    identity_sets: defaultdict[str, set[str]] = defaultdict(set)
+    for record in evidence:
+        for lane, digest in record["runtime_identity_sha256_by_lane"].items():
+            identity_sets[f"runtime:{lane}"].add(digest)
+        for lane, digest in record["native_module_sha256_by_lane"].items():
+            if _is_sha256(digest):
+                identity_sets[f"native:{lane}"].add(digest)
+        artifact_group = MatrixCell(**record["configuration"]).artifact_group_id
+        for lane, digest in record["artifact_identity_sha256_by_lane"].items():
+            identity_sets[f"artifact:{artifact_group}:{lane}"].add(digest)
+        provenance = record["provenance_sha256"]
+        for key in (
+            "driver",
+            "watchdog",
+            "native_sample_helper",
+            "dependency_entry",
+            "interpreters",
+            "dependency_sites",
+        ):
+            if key in provenance:
+                identity_sets[f"provenance:{key}"].add(provenance[key])
+        if "model" in provenance:
+            model_kind = record["configuration"]["model_kind"]
+            identity_sets[f"model:{model_kind}"].add(provenance["model"])
+    required_identity_keys = (
+        *(f"runtime:{lane}" for lane in ("baseline", "current")),
+        *(f"native:{lane}" for lane in ("baseline", "current")),
+        *(
+            f"provenance:{key}"
+            for key in (
+                "driver",
+                "watchdog",
+                "native_sample_helper",
+                "dependency_entry",
+                "interpreters",
+                "dependency_sites",
+            )
+        ),
+        "model:built-in",
+        "model:ufo-sm",
+    )
+    identity_failures = {
+        key: sorted(identity_sets[key])
+        for key in required_identity_keys
+        if len(identity_sets[key]) != 1
+    }
+    for key, values in identity_sets.items():
+        if key.startswith("artifact:") and len(values) != 1:
+            identity_failures[key] = sorted(values)
+
+    gain_by_mode = {
+        mode: [
+            record["cell_id"]
+            for record in evidence
+            if record["configuration"]["execution_mode"] == mode
+            and record["gain_gate_passes"]
+        ]
+        for mode in EXECUTION_MODES
+    }
+    primary_gain_by_mode = {
+        mode: [
+            record["cell_id"]
+            for record in evidence
+            if record["configuration"]["category"] == "primary"
+            and record["configuration"]["execution_mode"] == mode
+            and record["gain_gate_passes"]
+        ]
+        for mode in EXECUTION_MODES
+    }
+    ratios = [
+        record["generation_current_over_baseline"]
+        for record in evidence
+        if record["generation_current_over_baseline"] is not None
+    ]
+    geometric_mean = (
+        math.exp(math.fsum(math.log(ratio) for ratio in ratios) / len(ratios))
+        if ratios
+        else None
+    )
+    cell_failures = {
+        record["cell_id"]: record["errors"] for record in evidence if record["errors"]
+    }
+    completeness_passes = (
+        not missing and not unexpected and len(evidence) == len(CANONICAL_CELLS)
+    )
+    gain_passes = all(primary_gain_by_mode[mode] for mode in EXECUTION_MODES)
+    generation_passes = (
+        len(ratios) == len(CANONICAL_CELLS)
+        and geometric_mean is not None
+        and geometric_mean <= GENERATION_GEOMETRIC_MEAN_MAXIMUM
+    )
+    passes = (
+        completeness_passes
+        and not cell_failures
+        and not identity_failures
+        and gain_passes
+        and generation_passes
+    )
+    return {
+        "kind": RESULT_KIND,
+        "schema_version": SCHEMA_VERSION,
+        "matrix_contract": MATRIX_CONTRACT,
+        "matrix_definition": {
+            "sha256": _canonical_sha256(
+                [asdict(cell) | {"cell_id": cell.cell_id} for cell in CANONICAL_CELLS]
+            ),
+            "category_counts": dict(
+                sorted(Counter(cell.category for cell in CANONICAL_CELLS).items())
+            ),
+            "execution_mode_counts": dict(
+                sorted(Counter(cell.execution_mode for cell in CANONICAL_CELLS).items())
+            ),
+            "expected_cell_ids": [cell.cell_id for cell in CANONICAL_CELLS],
+        },
+        "expected_builds": {
+            lane: dict(identity) for lane, identity in sorted(expected_builds.items())
+        },
+        "complete": completeness_passes,
+        "passes": passes,
+        "coverage": {
+            "expected": len(CANONICAL_CELLS),
+            "observed": len(evidence),
+            "missing": missing,
+            "unexpected": unexpected,
+            "passes": completeness_passes,
+        },
+        "cell_gate": {
+            "failure_count": len(cell_failures),
+            "failures": cell_failures,
+            "passes": not cell_failures and completeness_passes,
+        },
+        "identity_gate": {
+            "distinct_sha256": {
+                key: sorted(value) for key, value in sorted(identity_sets.items())
+            },
+            "failures": identity_failures,
+            "passes": not identity_failures and completeness_passes,
+        },
+        "gain_gate": {
+            "required_relative_gain": regression.GAIN_RELATIVE_THRESHOLD,
+            "requires_beyond_measurement_noise": True,
+            "requires_primary_workload": True,
+            "passing_cells_by_execution_mode": gain_by_mode,
+            "passing_primary_cells_by_execution_mode": primary_gain_by_mode,
+            "passes": gain_passes and completeness_passes,
+        },
+        "generation_gate": {
+            "cell_ratio_count": len(ratios),
+            "geometric_mean_current_over_baseline": geometric_mean,
+            "maximum_geometric_mean": GENERATION_GEOMETRIC_MEAN_MAXIMUM,
+            "passes": generation_passes and completeness_passes,
+        },
+        "cells": evidence,
+    }
+
+
+def _discover_results(output_root: Path) -> dict[str, dict[str, Any]]:
+    cells_root = output_root / "cells"
+    if not cells_root.is_dir():
+        return {}
+    results: dict[str, dict[str, Any]] = {}
+    for path in sorted(cells_root.glob("*/result.json")):
+        cell_id = path.parent.name
+        if cell_id in results:
+            raise MatrixError(f"duplicate matrix cell result: {cell_id}")
+        results[cell_id] = _json_object(path)
+    return results
+
+
+def _git_output(*arguments: str) -> str:
+    completed = subprocess.run(
+        ("git", *arguments),
+        cwd=ROOT,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        detail = completed.stderr.strip()
+        raise MatrixError(
+            f"cannot inspect acceptance source checkout with git: {detail}"
+        )
+    return completed.stdout
+
+
+def _repository_identity() -> dict[str, object]:
+    revision = _git_output("rev-parse", "--verify", "HEAD").strip()
+    if not _is_git_sha(revision):
+        raise MatrixError("acceptance source checkout has an invalid HEAD revision")
+    status = _git_output("status", "--porcelain=v1", "--untracked-files=all")
+    dirty_entries = [line for line in status.splitlines() if line]
+    return {
+        "root": str(ROOT),
+        "head_revision": revision,
+        "clean": not dirty_entries,
+        "dirty_entries": dirty_entries,
+    }
+
+
+def _acceptance_state(
+    *,
+    baseline_python: Path,
+    current_python: Path,
+    baseline_dependency_site: Path,
+    current_dependency_site: Path,
+    ufo_sm_model: Path,
+) -> dict[str, object]:
+    environment = regression._environment()
+    interpreters = {
+        "baseline": _absolute(baseline_python),
+        "current": _absolute(current_python),
+    }
+    dependency_sites = {
+        "baseline": _absolute(baseline_dependency_site).resolve(strict=True),
+        "current": _absolute(current_dependency_site).resolve(strict=True),
+    }
+    return {
+        "platform": platform.platform(),
+        "system": platform.system(),
+        "machine": platform.machine(),
+        "repository": _repository_identity(),
+        "tools": {
+            "matrix_driver": regression._path_identity(Path(__file__)),
+            "cell_driver": regression._path_identity(CELL_DRIVER),
+            "watchdog": regression._path_identity(regression.WATCHDOG),
+            "native_sample_helper": regression._path_identity(
+                regression.NATIVE_SAMPLE_HELPER
+            ),
+            "dependency_entry": regression._path_identity(regression.DEPENDENCY_ENTRY),
+        },
+        "interpreters": {
+            lane: regression._path_identity(interpreter)
+            for lane, interpreter in interpreters.items()
+        },
+        "installed_pyamplicol": {
+            lane: regression._installed_pyamplicol_identity(
+                interpreter,
+                environment=environment,
+            )
+            for lane, interpreter in interpreters.items()
+        },
+        "dependency_sites": {
+            lane: regression._dependency_site_identity(path)
+            for lane, path in dependency_sites.items()
+        },
+        "model": regression._model_identity(str(ufo_sm_model)),
+    }
+
+
+def _preflight(
+    arguments: argparse.Namespace,
+    *,
+    ufo_sm_model: Path,
+) -> tuple[dict[str, dict[str, str]], dict[str, object]]:
+    if (
+        arguments.expected_baseline_source_revision != FROZEN_BASELINE_SOURCE_REVISION
+        or arguments.expected_baseline_native_inputs_sha256
+        != FROZEN_BASELINE_NATIVE_INPUTS_SHA256
+    ):
+        raise MatrixError(
+            "baseline pins do not identify the frozen pre-Arena candidate"
+        )
+    expected_builds = {
+        "baseline": {
+            "source_revision": arguments.expected_baseline_source_revision,
+            "native_build_inputs_sha256": (
+                arguments.expected_baseline_native_inputs_sha256
+            ),
+            "distribution_content_sha256": (
+                arguments.expected_baseline_distribution_sha256
+            ),
+            "native_module_sha256": (arguments.expected_baseline_native_module_sha256),
+        },
+        "current": {
+            "source_revision": arguments.expected_current_source_revision,
+            "native_build_inputs_sha256": (
+                arguments.expected_current_native_inputs_sha256
+            ),
+            "distribution_content_sha256": (
+                arguments.expected_current_distribution_sha256
+            ),
+            "native_module_sha256": arguments.expected_current_native_module_sha256,
+        },
+    }
+    state = _acceptance_state(
+        baseline_python=arguments.baseline_python,
+        current_python=arguments.current_python,
+        baseline_dependency_site=arguments.baseline_dependency_site,
+        current_dependency_site=arguments.current_dependency_site,
+        ufo_sm_model=ufo_sm_model,
+    )
+    frozen_binary = FROZEN_BASELINE_BINARY_IDENTITIES.get(
+        (str(state["system"]), str(state["machine"]))
+    )
+    if frozen_binary is not None and (
+        arguments.expected_baseline_distribution_sha256
+        != frozen_binary["distribution_content_sha256"]
+        or arguments.expected_baseline_native_module_sha256
+        != frozen_binary["native_module_sha256"]
+    ):
+        raise MatrixError(
+            "baseline binary pins do not identify the frozen candidate on "
+            f"{state['system']}/{state['machine']}"
+        )
+    repository = _mapping(state.get("repository"))
+    if repository is None or repository.get("clean") is not True:
+        entries = repository.get("dirty_entries") if repository is not None else None
+        raise MatrixError(
+            "current acceptance source checkout is not clean: "
+            f"{entries if entries is not None else 'identity absent'}"
+        )
+    if repository.get("head_revision") != arguments.expected_current_source_revision:
+        raise MatrixError(
+            "expected current source revision does not match clean checkout HEAD"
+        )
+    installations = _mapping(state.get("installed_pyamplicol"))
+    errors: list[str] = []
+    for lane in ("baseline", "current"):
+        errors.extend(
+            _installation_identity_errors(
+                installations.get(lane) if installations is not None else None,
+                expected=expected_builds[lane],
+                label=lane,
+            )
+        )
+    if errors:
+        raise MatrixError("installation preflight failed: " + "; ".join(errors))
+    return expected_builds, state
+
+
+def _artifact_postflight_errors(
+    results: Mapping[str, Mapping[str, Any]],
+    *,
+    output_root: Path,
+) -> list[str]:
+    errors: list[str] = []
+    expected = {cell.cell_id: cell for cell in CANONICAL_CELLS}
+    checked: set[tuple[str, str]] = set()
+    for cell_id, result in sorted(results.items()):
+        cell = expected.get(cell_id)
+        if cell is None:
+            continue
+        artifacts = _mapping(result.get("artifacts"))
+        if artifacts is None:
+            continue
+        for lane in ("baseline", "current"):
+            key = (cell.artifact_group_id, lane)
+            if key in checked:
+                continue
+            checked.add(key)
+            record = _mapping(artifacts.get(lane))
+            expected_path = (
+                _absolute(output_root)
+                / "artifact-groups"
+                / cell.artifact_group_id
+                / lane
+                / "artifact"
+            )
+            if record is None or record.get("path") != str(expected_path):
+                errors.append(
+                    f"{cell.artifact_group_id}/{lane}: artifact path is not bound "
+                    "to the matrix output"
+                )
+                continue
+            try:
+                observed = regression._artifact_metadata(
+                    expected_path,
+                    expected_process=cell.process,
+                    expected_color=cell.color_accuracy,
+                    expected_execution_mode=cell.execution_mode,
+                    expected_lc_flow_layout=(
+                        cell.lc_flow_layout if cell.color_accuracy == "lc" else None
+                    ),
+                )
+            except (OSError, regression.RegressionError) as error:
+                errors.append(
+                    f"{cell.artifact_group_id}/{lane}: cannot reopen artifact: {error}"
+                )
+                continue
+            for field in (
+                "artifact_id",
+                "manifest_sha256",
+                "tree_identity",
+                "payload_digests",
+            ):
+                if observed.get(field) != record.get(field):
+                    errors.append(
+                        f"{cell.artifact_group_id}/{lane}: reopened artifact "
+                        f"{field} differs"
+                    )
+    return errors
+
+
+def _mark_in_progress(
+    audited: dict[str, Any],
+    *,
+    preflight_state: Mapping[str, object],
+    output_root: Path,
+) -> dict[str, Any]:
+    audited["run_complete"] = False
+    audited["passes"] = False
+    audited["provenance"] = {
+        "preflight": dict(preflight_state),
+        "postflight": None,
+        "output_root": str(_absolute(output_root)),
+    }
+    audited["outer_provenance_gate"] = {
+        "errors": ["matrix run/postflight is incomplete"],
+        "passes": False,
+    }
+    return audited
+
+
+def run_matrix(arguments: argparse.Namespace) -> dict[str, Any]:
+    output_root = _absolute(arguments.output_root)
+    ufo_sm_model = _absolute(arguments.ufo_sm_model)
+    if not ufo_sm_model.exists():
+        raise MatrixError(f"UFO-SM model does not exist: {ufo_sm_model}")
+    for label, interpreter in (
+        ("baseline", _absolute(arguments.baseline_python)),
+        ("current", _absolute(arguments.current_python)),
+    ):
+        if not interpreter.is_file() or not os.access(interpreter, os.X_OK):
+            raise MatrixError(f"{label} Python is not executable: {interpreter}")
+    expected_builds, preflight_state = _preflight(
+        arguments,
+        ufo_sm_model=ufo_sm_model,
+    )
+    expected_platform = str(preflight_state["platform"])
+    output_root.mkdir(parents=True, exist_ok=True)
+
+    if not arguments.audit_only:
+        initial_results = _discover_results(output_root)
+        initial = audit_results(
+            initial_results,
+            baseline_python=arguments.baseline_python,
+            current_python=arguments.current_python,
+            ufo_sm_model=ufo_sm_model,
+            output_root=output_root,
+            expected_platform=expected_platform,
+            expected_builds=expected_builds,
+        )
+        _mark_in_progress(
+            initial,
+            preflight_state=preflight_state,
+            output_root=output_root,
+        )
+        _write_json_atomic(output_root / "matrix-result.json", initial)
+        regenerated_groups: set[str] = set()
+        for index, cell in enumerate(CANONICAL_CELLS, start=1):
+            result_path = output_root / "cells" / cell.cell_id / "result.json"
+            if result_path.is_file() and not arguments.rerun_results:
+                existing = _cell_evidence(
+                    cell,
+                    _json_object(result_path),
+                    baseline_python=arguments.baseline_python,
+                    current_python=arguments.current_python,
+                    ufo_sm_model=ufo_sm_model,
+                    output_root=output_root,
+                    expected_platform=expected_platform,
+                    expected_builds=expected_builds,
+                )
+                if existing["passes"]:
+                    continue
+            command = cell_command(
+                cell,
+                baseline_python=arguments.baseline_python,
+                current_python=arguments.current_python,
+                output_root=output_root,
+                ufo_sm_model=ufo_sm_model,
+                baseline_dependency_site=arguments.baseline_dependency_site,
+                current_dependency_site=arguments.current_dependency_site,
+                samples=arguments.samples,
+                target_runtime=arguments.target_runtime,
+                minimum_samples=arguments.minimum_samples,
+                warmup_runs=arguments.warmup_runs,
+                generation_timeout=arguments.generation_timeout,
+                profile_timeout=arguments.profile_timeout,
+                regenerate_artifacts=(
+                    arguments.regenerate_artifacts
+                    and cell.artifact_group_id not in regenerated_groups
+                ),
+            )
+            print(
+                f"[{index:03d}/{len(CANONICAL_CELLS)}] {cell.cell_id}",
+                file=sys.stderr,
+                flush=True,
+            )
+            completed = subprocess.run(
+                command,
+                check=False,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            if completed.returncode not in {0, 1} or not result_path.is_file():
+                detail = completed.stderr.strip()
+                raise MatrixError(
+                    f"cell driver failed for {cell.cell_id} "
+                    f"(exit {completed.returncode}): {detail}"
+                )
+            if arguments.regenerate_artifacts:
+                regenerated_groups.add(cell.artifact_group_id)
+            partial_results = _discover_results(output_root)
+            partial = audit_results(
+                partial_results,
+                baseline_python=arguments.baseline_python,
+                current_python=arguments.current_python,
+                ufo_sm_model=ufo_sm_model,
+                output_root=output_root,
+                expected_platform=expected_platform,
+                expected_builds=expected_builds,
+            )
+            _mark_in_progress(
+                partial,
+                preflight_state=preflight_state,
+                output_root=output_root,
+            )
+            _write_json_atomic(output_root / "matrix-result.json", partial)
+
+    results = _discover_results(output_root)
+    # Unexpected result directories remain in ``results`` so stale output fails
+    # completeness instead of being silently ignored.
+    audited = audit_results(
+        results,
+        baseline_python=arguments.baseline_python,
+        current_python=arguments.current_python,
+        ufo_sm_model=ufo_sm_model,
+        output_root=output_root,
+        expected_platform=expected_platform,
+        expected_builds=expected_builds,
+    )
+    postflight_state = _acceptance_state(
+        baseline_python=arguments.baseline_python,
+        current_python=arguments.current_python,
+        baseline_dependency_site=arguments.baseline_dependency_site,
+        current_dependency_site=arguments.current_dependency_site,
+        ufo_sm_model=ufo_sm_model,
+    )
+    outer_errors = _artifact_postflight_errors(results, output_root=output_root)
+    if postflight_state != preflight_state:
+        outer_errors.append(
+            "acceptance host/source/interpreter/dependency/model state changed "
+            "between preflight and postflight"
+        )
+    outer_passes = not outer_errors and bool(audited["complete"])
+    audited["run_complete"] = bool(audited["complete"])
+    audited["provenance"] = {
+        "preflight": preflight_state,
+        "postflight": postflight_state,
+        "output_root": str(output_root),
+    }
+    audited["outer_provenance_gate"] = {
+        "errors": outer_errors,
+        "passes": outer_passes,
+    }
+    audited["passes"] = bool(audited["passes"] and outer_passes)
+    _write_json_atomic(output_root / "matrix-result.json", audited)
+    return audited
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0.0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return parsed
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return parsed
+
+
+def _at_least_five(value: str) -> int:
+    parsed = _positive_int(value)
+    if parsed < 5:
+        raise argparse.ArgumentTypeError("must be at least five")
+    return parsed
+
+
+def _git_sha(value: str) -> str:
+    if not _is_git_sha(value):
+        raise argparse.ArgumentTypeError("must be a lowercase 40-character Git SHA")
+    return value
+
+
+def _sha256(value: str) -> str:
+    if not _is_sha256(value):
+        raise argparse.ArgumentTypeError("must be a lowercase 64-character SHA-256")
+    return value
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--baseline-python", type=Path, required=True)
+    result.add_argument("--current-python", type=Path, required=True)
+    result.add_argument("--ufo-sm-model", type=Path, required=True)
+    result.add_argument("--output-root", type=Path, required=True)
+    result.add_argument(
+        "--expected-baseline-source-revision",
+        type=_git_sha,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-current-source-revision",
+        type=_git_sha,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-baseline-native-inputs-sha256",
+        type=_sha256,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-current-native-inputs-sha256",
+        type=_sha256,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-baseline-distribution-sha256",
+        type=_sha256,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-current-distribution-sha256",
+        type=_sha256,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-baseline-native-module-sha256",
+        type=_sha256,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-current-native-module-sha256",
+        type=_sha256,
+        required=True,
+    )
+    result.add_argument("--baseline-dependency-site", type=Path, required=True)
+    result.add_argument("--current-dependency-site", type=Path, required=True)
+    result.add_argument("--samples", type=_at_least_five, default=7)
+    result.add_argument("--target-runtime", type=_positive_float, default=5.0)
+    result.add_argument("--minimum-samples", type=_at_least_five, default=7)
+    result.add_argument("--warmup-runs", type=_positive_int, default=2)
+    result.add_argument(
+        "--generation-timeout",
+        type=_positive_float,
+        default=DEFAULT_MATRIX_GENERATION_TIMEOUT,
+    )
+    result.add_argument(
+        "--profile-timeout",
+        type=_positive_float,
+        default=DEFAULT_MATRIX_PROFILE_TIMEOUT,
+    )
+    result.add_argument(
+        "--audit-only",
+        action="store_true",
+        help="audit existing cell results without launching subprocesses",
+    )
+    result.add_argument(
+        "--rerun-results",
+        action="store_true",
+        help="rerun every cell even when a result.json exists",
+    )
+    result.add_argument(
+        "--regenerate-artifacts",
+        action="store_true",
+        help="pass --regenerate-artifacts to every cell driver",
+    )
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    if arguments.audit_only and (
+        arguments.rerun_results or arguments.regenerate_artifacts
+    ):
+        print(
+            "compiled-mode-matrix: --audit-only cannot rerun results or artifacts",
+            file=sys.stderr,
+        )
+        return 2
+    if arguments.regenerate_artifacts and not arguments.rerun_results:
+        print(
+            "compiled-mode-matrix: --regenerate-artifacts requires "
+            "--rerun-results so every shared group is refreshed coherently",
+            file=sys.stderr,
+        )
+        return 2
+    try:
+        result = run_matrix(arguments)
+    except (MatrixError, OSError, ValueError) as error:
+        print(f"compiled-mode-matrix: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, indent=2, sort_keys=True, allow_nan=False))
+    return 0 if result["passes"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/compiled_mode_matrix_x86.py b/pyamplicol/tools/developer/compiled_mode_matrix_x86.py
new file mode 100644
index 0000000000..9de1372c20
--- /dev/null
+++ b/pyamplicol/tools/developer/compiled_mode_matrix_x86.py
@@ -0,0 +1,805 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run and aggregate the frozen x86-64 Direct-Arena matrix in eight shards.
+
+The ordinary :mod:`compiled_mode_matrix` command remains the authoritative
+single-host implementation.  This companion exists only because a complete
+168-cell run exceeds the six-hour GitHub-hosted job limit.  It partitions
+whole artifact groups, validates every artifact tree on the shard host, and
+allows a later pure-JSON job to apply the unchanged global matrix gates.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import platform
+import re
+import stat
+import subprocess
+import sys
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.developer import compiled_mode_matrix as matrix  # noqa: E402
+from tools.developer import compiled_mode_regression as regression  # noqa: E402
+
+SHARD_KIND = "pyamplicol-compiled-mode-matrix-x86-shard"
+AGGREGATE_KIND = "pyamplicol-compiled-mode-matrix-x86-aggregate"
+SCHEMA_VERSION = 1
+SHARD_COUNT = 8
+PARTITION_CONTRACT = "arena-matrix-168-artifact-groups-eight-way-v1"
+CONTENT_IDENTITY_ALGORITHM = "sha256-canonical-json-body-v1"
+_SHA256 = re.compile(r"[0-9a-f]{64}")
+_GIT_SHA = re.compile(r"[0-9a-f]{40}")
+_JSON_LIMIT_BYTES = 512 * 1024 * 1024
+
+
+class ShardError(RuntimeError):
+    """Raised when x86 shard evidence cannot be trusted."""
+
+
+def _canonical_bytes(value: object) -> bytes:
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+
+
+def _canonical_sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_bytes(value)).hexdigest()
+
+
+def _attach_content_identity(body: Mapping[str, object]) -> dict[str, object]:
+    payload = dict(body)
+    payload["content_identity"] = {
+        "algorithm": CONTENT_IDENTITY_ALGORITHM,
+        "sha256": _canonical_sha256(body),
+    }
+    return payload
+
+
+def _require_content_identity(payload: Mapping[str, object], *, label: str) -> None:
+    identity = payload.get("content_identity")
+    if (
+        not isinstance(identity, Mapping)
+        or identity.get("algorithm") != CONTENT_IDENTITY_ALGORITHM
+        or not isinstance(identity.get("sha256"), str)
+    ):
+        raise ShardError(f"{label} has no valid content identity")
+    body = dict(payload)
+    body.pop("content_identity")
+    if identity["sha256"] != _canonical_sha256(body):
+        raise ShardError(f"{label} content identity does not match")
+
+
+def _reject_constant(value: str) -> None:
+    raise ShardError(f"non-finite JSON constant is forbidden: {value}")
+
+
+def _reject_duplicate_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise ShardError(f"duplicate JSON key is forbidden: {key}")
+        result[key] = value
+    return result
+
+
+def _checked_json(
+    path: Path,
+    *,
+    label: str,
+) -> tuple[dict[str, Any], dict[str, object]]:
+    try:
+        before = path.lstat()
+    except OSError as error:
+        raise ShardError(f"cannot inspect {label}: {path}") from error
+    if not stat.S_ISREG(before.st_mode) or path.is_symlink():
+        raise ShardError(f"{label} is not a regular non-symlink file: {path}")
+    if before.st_size <= 0 or before.st_size > _JSON_LIMIT_BYTES:
+        raise ShardError(f"{label} has an invalid size: {before.st_size}")
+    try:
+        encoded = path.read_bytes()
+        after = path.lstat()
+    except OSError as error:
+        raise ShardError(f"cannot read {label}: {path}") from error
+    stable_fields = ("st_dev", "st_ino", "st_mode", "st_size", "st_mtime_ns")
+    if any(getattr(before, field) != getattr(after, field) for field in stable_fields):
+        raise ShardError(f"{label} changed while it was read: {path}")
+    try:
+        payload = json.loads(
+            encoded,
+            parse_constant=_reject_constant,
+            object_pairs_hook=_reject_duplicate_keys,
+        )
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise ShardError(f"{label} is not strict JSON: {path}") from error
+    if not isinstance(payload, dict):
+        raise ShardError(f"{label} is not a JSON object: {path}")
+    return payload, {
+        "path": str(path.resolve(strict=True)),
+        "size_bytes": len(encoded),
+        "sha256": hashlib.sha256(encoded).hexdigest(),
+        "canonical_sha256": _canonical_sha256(payload),
+    }
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def _artifact_groups() -> tuple[tuple[matrix.MatrixCell, ...], ...]:
+    groups: dict[str, list[matrix.MatrixCell]] = {}
+    order: list[str] = []
+    for cell in matrix.CANONICAL_CELLS:
+        if cell.artifact_group_id not in groups:
+            groups[cell.artifact_group_id] = []
+            order.append(cell.artifact_group_id)
+        groups[cell.artifact_group_id].append(cell)
+    result = tuple(tuple(groups[group_id]) for group_id in order)
+    if len(result) != 56 or any(
+        tuple(cell.batch_size for cell in group) != matrix.BATCH_SIZES
+        for group in result
+    ):
+        raise AssertionError("the frozen matrix no longer has 56 batch-sharing groups")
+    return result
+
+
+ARTIFACT_GROUPS = _artifact_groups()
+
+
+def _medium_process_order() -> tuple[str, ...]:
+    return tuple(
+        dict.fromkeys(
+            group[0].process_key
+            for group in ARTIFACT_GROUPS
+            if group[0].category == "medium"
+        )
+    )
+
+
+def _color_process_order() -> tuple[str, ...]:
+    return tuple(
+        dict.fromkeys(
+            group[0].process_key
+            for group in ARTIFACT_GROUPS
+            if group[0].category == "color-heavy"
+        )
+    )
+
+
+_MEDIUM_PROCESSES = _medium_process_order()
+_COLOR_PROCESSES = _color_process_order()
+_PRIMARY_GROUP_IDS = tuple(
+    group[0].artifact_group_id
+    for group in ARTIFACT_GROUPS
+    if group[0].category == "primary"
+)
+_MEDIUM_ROLES = (
+    ("eager", "lc-topology"),
+    ("eager", "lc-union"),
+    ("eager", "nlc-summed"),
+    ("eager", "full-summed"),
+    ("compiled", "lc-topology"),
+    ("compiled", "lc-union"),
+    ("compiled", "nlc-summed"),
+    ("compiled", "full-summed"),
+)
+_COLOR_ROLES = (
+    ("eager", "nlc-summed"),
+    ("eager", "full-summed"),
+    ("compiled", "nlc-summed"),
+    ("compiled", "full-summed"),
+)
+
+
+def artifact_group_shard(group: Sequence[matrix.MatrixCell]) -> int:
+    """Return the frozen load-balanced shard for one whole artifact group."""
+
+    if not group:
+        raise ShardError("artifact group cannot be empty")
+    first = group[0]
+    if any(cell.artifact_group_id != first.artifact_group_id for cell in group):
+        raise ShardError("artifact group contains more than one identity")
+    if first.category == "primary":
+        try:
+            return _PRIMARY_GROUP_IDS.index(first.artifact_group_id)
+        except ValueError as error:
+            raise ShardError("unknown primary artifact group") from error
+    if first.category == "medium":
+        try:
+            process_index = _MEDIUM_PROCESSES.index(first.process_key)
+            role_index = _MEDIUM_ROLES.index(
+                (first.execution_mode, first.workload_key)
+            )
+        except ValueError as error:
+            raise ShardError("unknown medium artifact-group role") from error
+        return (role_index + 3 * process_index) % SHARD_COUNT
+    if first.category == "color-heavy":
+        try:
+            process_index = _COLOR_PROCESSES.index(first.process_key)
+            role_index = _COLOR_ROLES.index(
+                (first.execution_mode, first.workload_key)
+            )
+        except ValueError as error:
+            raise ShardError("unknown color-heavy artifact-group role") from error
+        return (role_index + 4 * process_index + 5) % SHARD_COUNT
+    raise ShardError(f"unknown matrix category: {first.category}")
+
+
+def shard_groups(shard_index: int) -> tuple[tuple[matrix.MatrixCell, ...], ...]:
+    if shard_index < 0 or shard_index >= SHARD_COUNT:
+        raise ShardError(f"shard index must be in [0,{SHARD_COUNT})")
+    groups = tuple(
+        group
+        for group in ARTIFACT_GROUPS
+        if artifact_group_shard(group) == shard_index
+    )
+    if len(groups) != 7:
+        raise AssertionError("each frozen x86 shard must contain seven groups")
+    return groups
+
+
+def shard_cells(shard_index: int) -> tuple[matrix.MatrixCell, ...]:
+    cells = tuple(cell for group in shard_groups(shard_index) for cell in group)
+    if len(cells) != 21:
+        raise AssertionError("each frozen x86 shard must contain 21 cells")
+    return cells
+
+
+def partition_definition() -> dict[str, object]:
+    assignments = {
+        str(index): {
+            "artifact_group_ids": [
+                group[0].artifact_group_id for group in shard_groups(index)
+            ],
+            "cell_ids": [cell.cell_id for cell in shard_cells(index)],
+        }
+        for index in range(SHARD_COUNT)
+    }
+    body = {
+        "contract": PARTITION_CONTRACT,
+        "shard_count": SHARD_COUNT,
+        "matrix_contract": matrix.MATRIX_CONTRACT,
+        "matrix_definition_sha256": _canonical_sha256(
+            [
+                {
+                    **matrix.asdict(cell),
+                    "cell_id": cell.cell_id,
+                }
+                for cell in matrix.CANONICAL_CELLS
+            ]
+        ),
+        "assignments": assignments,
+    }
+    return {**body, "sha256": _canonical_sha256(body)}
+
+
+PARTITION_DEFINITION = partition_definition()
+
+
+def _result_inventory(
+    output_root: Path,
+    cells: Sequence[matrix.MatrixCell],
+) -> tuple[list[dict[str, object]], list[dict[str, Any]]]:
+    files: list[dict[str, object]] = []
+    results: list[dict[str, Any]] = []
+    for cell in cells:
+        path = output_root / "cells" / cell.cell_id / "result.json"
+        result, identity = _checked_json(path, label=f"cell result {cell.cell_id}")
+        files.append({"cell_id": cell.cell_id, **identity})
+        results.append(result)
+    return files, results
+
+
+def _expected_builds(arguments: argparse.Namespace) -> dict[str, dict[str, str]]:
+    return {
+        "baseline": {
+            "source_revision": arguments.expected_baseline_source_revision,
+            "native_build_inputs_sha256": (
+                arguments.expected_baseline_native_inputs_sha256
+            ),
+            "distribution_content_sha256": (
+                arguments.expected_baseline_distribution_sha256
+            ),
+            "native_module_sha256": arguments.expected_baseline_native_module_sha256,
+        },
+        "current": {
+            "source_revision": arguments.expected_current_source_revision,
+            "native_build_inputs_sha256": (
+                arguments.expected_current_native_inputs_sha256
+            ),
+            "distribution_content_sha256": (
+                arguments.expected_current_distribution_sha256
+            ),
+            "native_module_sha256": arguments.expected_current_native_module_sha256,
+        },
+    }
+
+
+def _cell_evidence(
+    cells: Sequence[matrix.MatrixCell],
+    results: Sequence[Mapping[str, Any]],
+    *,
+    arguments: argparse.Namespace,
+    expected_platform: str,
+    expected_builds: Mapping[str, Mapping[str, str]],
+) -> list[dict[str, Any]]:
+    return [
+        matrix._cell_evidence(
+            cell,
+            result,
+            baseline_python=arguments.baseline_python,
+            current_python=arguments.current_python,
+            ufo_sm_model=arguments.ufo_sm_model,
+            output_root=arguments.output_root,
+            expected_platform=expected_platform,
+            expected_builds=expected_builds,
+        )
+        for cell, result in zip(cells, results, strict=True)
+    ]
+
+
+def _run_shard(arguments: argparse.Namespace) -> dict[str, object]:
+    if arguments.shard_count != SHARD_COUNT:
+        raise ShardError(
+            f"the acceptance contract requires exactly {SHARD_COUNT} shards"
+        )
+    if platform.system() != "Linux" or platform.machine() not in {"x86_64", "AMD64"}:
+        raise ShardError("x86 matrix shards require a Linux x86-64 host")
+    output_root = matrix._absolute(arguments.output_root)
+    ufo_model = matrix._absolute(arguments.ufo_sm_model)
+    output_root.mkdir(parents=True, exist_ok=True)
+    expected_builds, preflight = matrix._preflight(
+        arguments,
+        ufo_sm_model=ufo_model,
+    )
+    expected_platform = str(preflight["platform"])
+    cells = shard_cells(arguments.shard_index)
+    expected_ids = {cell.cell_id for cell in cells}
+    discovered = matrix._discover_results(output_root)
+    unexpected = sorted(set(discovered) - expected_ids)
+    if unexpected:
+        raise ShardError(f"shard output contains unexpected cell results: {unexpected}")
+
+    regenerated: set[str] = set()
+    for ordinal, cell in enumerate(cells, start=1):
+        path = output_root / "cells" / cell.cell_id / "result.json"
+        if path.is_file() and not arguments.rerun_results:
+            existing = matrix._cell_evidence(
+                cell,
+                matrix._json_object(path),
+                baseline_python=arguments.baseline_python,
+                current_python=arguments.current_python,
+                ufo_sm_model=ufo_model,
+                output_root=output_root,
+                expected_platform=expected_platform,
+                expected_builds=expected_builds,
+            )
+            if existing["passes"]:
+                continue
+        command = matrix.cell_command(
+            cell,
+            baseline_python=arguments.baseline_python,
+            current_python=arguments.current_python,
+            output_root=output_root,
+            ufo_sm_model=ufo_model,
+            baseline_dependency_site=arguments.baseline_dependency_site,
+            current_dependency_site=arguments.current_dependency_site,
+            samples=arguments.samples,
+            target_runtime=arguments.target_runtime,
+            minimum_samples=arguments.minimum_samples,
+            warmup_runs=arguments.warmup_runs,
+            generation_timeout=arguments.generation_timeout,
+            profile_timeout=arguments.profile_timeout,
+            regenerate_artifacts=(
+                arguments.regenerate_artifacts
+                and cell.artifact_group_id not in regenerated
+            ),
+        )
+        print(
+            f"[shard {arguments.shard_index} {ordinal:02d}/{len(cells)}] "
+            f"{cell.cell_id}",
+            file=sys.stderr,
+            flush=True,
+        )
+        completed = subprocess.run(
+            command,
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        if completed.returncode not in {0, 1} or not path.is_file():
+            raise ShardError(
+                f"cell driver failed for {cell.cell_id} "
+                f"(exit {completed.returncode}): {completed.stderr.strip()}"
+            )
+        if arguments.regenerate_artifacts:
+            regenerated.add(cell.artifact_group_id)
+
+    files, results = _result_inventory(output_root, cells)
+    evidence = _cell_evidence(
+        cells,
+        results,
+        arguments=arguments,
+        expected_platform=expected_platform,
+        expected_builds=expected_builds,
+    )
+    cell_failures = {
+        record["cell_id"]: record["errors"] for record in evidence if record["errors"]
+    }
+    indexed_results = {
+        cell.cell_id: result for cell, result in zip(cells, results, strict=True)
+    }
+    artifact_errors = matrix._artifact_postflight_errors(
+        indexed_results,
+        output_root=output_root,
+    )
+    postflight = matrix._acceptance_state(
+        baseline_python=arguments.baseline_python,
+        current_python=arguments.current_python,
+        baseline_dependency_site=arguments.baseline_dependency_site,
+        current_dependency_site=arguments.current_dependency_site,
+        ufo_sm_model=ufo_model,
+    )
+    if postflight != preflight:
+        artifact_errors.append(
+            "acceptance host/source/interpreter/dependency/model state changed "
+            "between shard preflight and postflight"
+        )
+    complete = len(results) == len(cells)
+    passes = complete and not cell_failures and not artifact_errors
+    payload = _attach_content_identity(
+        {
+            "kind": SHARD_KIND,
+            "schema_version": SCHEMA_VERSION,
+            "matrix_contract": matrix.MATRIX_CONTRACT,
+            "partition": PARTITION_DEFINITION,
+            "shard_count": SHARD_COUNT,
+            "shard_index": arguments.shard_index,
+            "workflow_run_id": arguments.workflow_run_id,
+            "runtime_bundle_sha256": arguments.runtime_bundle_sha256,
+            "output_root": str(output_root),
+            "expected_builds": expected_builds,
+            "platform": {
+                "platform": expected_platform,
+                "system": preflight["system"],
+                "machine": preflight["machine"],
+            },
+            "selected_artifact_group_ids": [
+                group[0].artifact_group_id
+                for group in shard_groups(arguments.shard_index)
+            ],
+            "selected_cell_ids": [cell.cell_id for cell in cells],
+            "result_files": files,
+            "cell_evidence": evidence,
+            "cell_gate": {
+                "failures": cell_failures,
+                "passes": not cell_failures and complete,
+            },
+            "artifact_postflight_gate": {
+                "errors": artifact_errors,
+                "passes": not artifact_errors and complete,
+            },
+            "provenance": {
+                "preflight": preflight,
+                "postflight": postflight,
+                "all_match": preflight == postflight,
+                "shard_driver": regression._path_identity(Path(__file__)),
+            },
+            "complete": complete,
+            "passes": passes,
+        }
+    )
+    destination = (
+        Path(arguments.shard_result)
+        if arguments.shard_result is not None
+        else output_root / "shards" / f"shard-{arguments.shard_index}.json"
+    )
+    _write_json_atomic(destination, payload)
+    return payload
+
+
+def _require_sha(value: object, *, label: str, git: bool = False) -> str:
+    pattern = _GIT_SHA if git else _SHA256
+    if not isinstance(value, str) or pattern.fullmatch(value) is None:
+        raise ShardError(f"{label} is not a valid {'Git ' if git else ''}SHA")
+    return value
+
+
+def _aggregate(arguments: argparse.Namespace) -> dict[str, object]:
+    if arguments.shard_count != SHARD_COUNT:
+        raise ShardError(
+            f"the acceptance contract requires exactly {SHARD_COUNT} shards"
+        )
+    repository = matrix._repository_identity()
+    if (
+        repository.get("clean") is not True
+        or repository.get("head_revision") != arguments.expected_current_source_revision
+    ):
+        raise ShardError("aggregate requires the exact clean current source revision")
+    output_root = matrix._absolute(arguments.output_root)
+    shard_root = matrix._absolute(arguments.shard_root)
+    expected_builds = _expected_builds(arguments)
+    result_map: dict[str, dict[str, Any]] = {}
+    evidence: list[dict[str, Any]] = []
+    manifest_files: list[dict[str, object]] = []
+    errors: list[str] = []
+    observed_manifest_paths = sorted(shard_root.glob("shard-*.json"))
+    expected_names = {f"shard-{index}.json" for index in range(SHARD_COUNT)}
+    observed_names = {path.name for path in observed_manifest_paths}
+    if observed_names != expected_names:
+        raise ShardError(
+            "aggregate shard manifest set is incomplete or unexpected: "
+            f"missing={sorted(expected_names - observed_names)}, "
+            f"unexpected={sorted(observed_names - expected_names)}"
+        )
+    for index in range(SHARD_COUNT):
+        path = shard_root / f"shard-{index}.json"
+        shard, file_identity = _checked_json(path, label=f"shard {index} manifest")
+        _require_content_identity(shard, label=f"shard {index} manifest")
+        manifest_files.append({"shard_index": index, **file_identity})
+        if (
+            shard.get("kind") != SHARD_KIND
+            or shard.get("schema_version") != SCHEMA_VERSION
+            or shard.get("matrix_contract") != matrix.MATRIX_CONTRACT
+            or _canonical_sha256(shard.get("partition"))
+            != _canonical_sha256(PARTITION_DEFINITION)
+            or shard.get("shard_count") != SHARD_COUNT
+            or shard.get("shard_index") != index
+            or shard.get("workflow_run_id") != arguments.workflow_run_id
+            or shard.get("runtime_bundle_sha256")
+            != arguments.runtime_bundle_sha256
+            or shard.get("output_root") != str(output_root)
+            or shard.get("expected_builds") != expected_builds
+            or shard.get("complete") is not True
+            or shard.get("passes") is not True
+        ):
+            errors.append(f"shard {index} top-level contract is invalid")
+        platform_record = shard.get("platform")
+        if (
+            not isinstance(platform_record, Mapping)
+            or platform_record.get("system") != "Linux"
+            or platform_record.get("machine") not in {"x86_64", "AMD64"}
+            or not isinstance(platform_record.get("platform"), str)
+        ):
+            errors.append(f"shard {index} is not authenticated Linux x86-64")
+            expected_platform = ""
+        else:
+            expected_platform = str(platform_record["platform"])
+        expected_cells = shard_cells(index)
+        if shard.get("selected_cell_ids") != [
+            cell.cell_id for cell in expected_cells
+        ] or shard.get("selected_artifact_group_ids") != [
+            group[0].artifact_group_id for group in shard_groups(index)
+        ]:
+            errors.append(f"shard {index} selected-cell partition is invalid")
+        artifact_gate = shard.get("artifact_postflight_gate")
+        provenance = shard.get("provenance")
+        if (
+            not isinstance(artifact_gate, Mapping)
+            or artifact_gate.get("passes") is not True
+            or artifact_gate.get("errors") != []
+            or not isinstance(provenance, Mapping)
+            or provenance.get("all_match") is not True
+            or provenance.get("preflight") != provenance.get("postflight")
+        ):
+            errors.append(f"shard {index} host-local postflight is invalid")
+        raw_files = shard.get("result_files")
+        raw_evidence = shard.get("cell_evidence")
+        if (
+            not isinstance(raw_files, list)
+            or not isinstance(raw_evidence, list)
+            or len(raw_files) != len(expected_cells)
+            or len(raw_evidence) != len(expected_cells)
+        ):
+            errors.append(f"shard {index} result inventory is incomplete")
+            continue
+        for cell, recorded_file, recorded_evidence in zip(
+            expected_cells,
+            raw_files,
+            raw_evidence,
+            strict=True,
+        ):
+            if not isinstance(recorded_file, Mapping):
+                errors.append(f"shard {index} has an invalid result-file record")
+                continue
+            result_path = output_root / "cells" / cell.cell_id / "result.json"
+            result, observed_file = _checked_json(
+                result_path,
+                label=f"aggregate cell result {cell.cell_id}",
+            )
+            expected_file = {"cell_id": cell.cell_id, **observed_file}
+            if dict(recorded_file) != expected_file:
+                errors.append(f"cell {cell.cell_id} result file identity changed")
+            if cell.cell_id in result_map:
+                errors.append(f"cell {cell.cell_id} appears in multiple shards")
+            result_map[cell.cell_id] = result
+            observed_evidence = matrix._cell_evidence(
+                cell,
+                result,
+                baseline_python=arguments.baseline_python,
+                current_python=arguments.current_python,
+                ufo_sm_model=arguments.ufo_sm_model,
+                output_root=output_root,
+                expected_platform=expected_platform,
+                expected_builds=expected_builds,
+            )
+            if _canonical_sha256(recorded_evidence) != _canonical_sha256(
+                observed_evidence
+            ):
+                errors.append(f"cell {cell.cell_id} semantic evidence changed")
+            evidence.append(observed_evidence)
+
+    expected_ids = {cell.cell_id for cell in matrix.CANONICAL_CELLS}
+    observed_ids = set(result_map)
+    global_audit = matrix.audit_cell_evidence(
+        evidence,
+        missing=sorted(expected_ids - observed_ids),
+        unexpected=sorted(observed_ids - expected_ids),
+        expected_builds=expected_builds,
+    )
+    shard_gate_passes = not errors and len(evidence) == len(matrix.CANONICAL_CELLS)
+    passes = shard_gate_passes and global_audit.get("passes") is True
+    payload = _attach_content_identity(
+        {
+            "kind": AGGREGATE_KIND,
+            "schema_version": SCHEMA_VERSION,
+            "matrix_contract": matrix.MATRIX_CONTRACT,
+            "partition": PARTITION_DEFINITION,
+            "workflow_run_id": arguments.workflow_run_id,
+            "runtime_bundle_sha256": arguments.runtime_bundle_sha256,
+            "expected_current_source_revision": (
+                arguments.expected_current_source_revision
+            ),
+            "expected_builds": expected_builds,
+            "repository": repository,
+            "output_root": str(output_root),
+            "shard_manifests": manifest_files,
+            "shard_gate": {
+                "errors": errors,
+                "passes": shard_gate_passes,
+            },
+            "matrix_audit": global_audit,
+            "complete": global_audit.get("complete") is True,
+            "passes": passes,
+        }
+    )
+    _write_json_atomic(arguments.aggregate_result, payload)
+    return payload
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be positive")
+    return parsed
+
+
+def _sha256_argument(value: str) -> str:
+    if _SHA256.fullmatch(value) is None:
+        raise argparse.ArgumentTypeError("must be a lowercase SHA-256")
+    return value
+
+
+def _git_sha_argument(value: str) -> str:
+    if _GIT_SHA.fullmatch(value) is None:
+        raise argparse.ArgumentTypeError("must be a lowercase Git SHA")
+    return value
+
+
+def _add_identity_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--baseline-python", type=Path, required=True)
+    parser.add_argument("--current-python", type=Path, required=True)
+    parser.add_argument("--baseline-dependency-site", type=Path, required=True)
+    parser.add_argument("--current-dependency-site", type=Path, required=True)
+    parser.add_argument("--ufo-sm-model", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument(
+        "--expected-baseline-source-revision",
+        type=_git_sha_argument,
+        required=True,
+    )
+    parser.add_argument(
+        "--expected-current-source-revision",
+        type=_git_sha_argument,
+        required=True,
+    )
+    parser.add_argument(
+        "--expected-baseline-native-inputs-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+    parser.add_argument(
+        "--expected-current-native-inputs-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+    parser.add_argument(
+        "--expected-baseline-distribution-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+    parser.add_argument(
+        "--expected-current-distribution-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+    parser.add_argument(
+        "--expected-baseline-native-module-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+    parser.add_argument(
+        "--expected-current-native-module-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+    parser.add_argument("--workflow-run-id", required=True)
+    parser.add_argument(
+        "--runtime-bundle-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    commands = result.add_subparsers(dest="command", required=True)
+    shard = commands.add_parser("shard")
+    _add_identity_arguments(shard)
+    shard.add_argument("--shard-count", type=_positive_int, required=True)
+    shard.add_argument("--shard-index", type=int, required=True)
+    shard.add_argument("--shard-result", type=Path)
+    shard.add_argument("--samples", type=_positive_int, default=7)
+    shard.add_argument("--target-runtime", type=float, default=5.0)
+    shard.add_argument("--minimum-samples", type=_positive_int, default=7)
+    shard.add_argument("--warmup-runs", type=_positive_int, default=2)
+    shard.add_argument("--generation-timeout", type=float, default=2400.0)
+    shard.add_argument("--profile-timeout", type=float, default=1200.0)
+    shard.add_argument("--rerun-results", action="store_true")
+    shard.add_argument("--regenerate-artifacts", action="store_true")
+
+    aggregate = commands.add_parser("aggregate")
+    _add_identity_arguments(aggregate)
+    aggregate.add_argument("--shard-count", type=_positive_int, required=True)
+    aggregate.add_argument("--shard-root", type=Path, required=True)
+    aggregate.add_argument("--aggregate-result", type=Path, required=True)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    try:
+        payload = (
+            _run_shard(arguments)
+            if arguments.command == "shard"
+            else _aggregate(arguments)
+        )
+    except (ShardError, matrix.MatrixError, regression.RegressionError) as error:
+        print(f"compiled-mode-matrix-x86: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(payload, sort_keys=True, allow_nan=False))
+    return 0 if payload.get("passes") is True else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/compiled_mode_regression.py b/pyamplicol/tools/developer/compiled_mode_regression.py
new file mode 100644
index 0000000000..2ff1798ace
--- /dev/null
+++ b/pyamplicol/tools/developer/compiled_mode_regression.py
@@ -0,0 +1,3654 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Compare one eager or compiled runtime against a frozen baseline interpreter.
+
+The driver generates one compiled JIT O3 artifact per interpreter and reuses
+it while its cache signature remains valid.  Each reported outer sample comes
+from a separate repository-owned sampling helper run by that interpreter. The
+accepted headline timing comes directly from the warmed, unprofiled
+``_benchmark_f64_wall_time`` pass, independent of the installed benchmark
+coordinator version. Native profile attribution is collected in a paired pass
+over the byte-identical batch and repetition count, and never substitutes for
+the headline. A performance gate is authoritative only for one shared artifact
+or byte-identical performance-relevant payloads, and warmed native values are
+an independent numerical-correctness gate.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.metadata
+import json
+import math
+import os
+import platform
+import re
+import signal
+import statistics
+import subprocess
+import sys
+import time
+import tomllib
+from collections.abc import Mapping, Sequence
+from contextlib import suppress
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+WATCHDOG = ROOT / "tools" / "ci" / "memory_watchdog.py"
+NATIVE_SAMPLE_HELPER = ROOT / "tools" / "developer" / "compiled_mode_sample.py"
+DEPENDENCY_ENTRY = ROOT / "tools" / "developer" / "python_dependency_entry.py"
+MEMORY_LIMIT_GIB = 30.0
+NATIVE_WALL_TIME_SOURCE = "runtime_core_repeated_wall_time"
+NATIVE_WALL_TIME_SAMPLE_PASS = "runtime._benchmark_f64_wall_time"
+PAIRED_TIMING_SAMPLE_CONTRACT = "paired_unprofiled_headline_profiled_attribution_v1"
+PROFILE_ATTRIBUTION_SAMPLE_PASS = "runtime._profile_arena_repeated"
+FROZEN_BASELINE_PROFILE_ATTRIBUTION_SAMPLE_PASS = "runtime.profile_repeated"
+ARENA_PROFILE_BOUNDARY = "warmed-direct-arena-borrowed-input-preallocated-output-v1"
+FROZEN_BASELINE_PROFILE_BOUNDARY = "materialized-native-profile-v1"
+ARENA_PHASE_TIMING_SCOPE = "coarse-arena-boundary-only-v1"
+FROZEN_BASELINE_PHASE_TIMING_SCOPE = "profiled-evaluator-phases-v1"
+ARENA_PROFILE_PROTOCOL = "arena"
+FROZEN_BASELINE_PROFILE_PROTOCOL = "frozen-pre-arena"
+NATIVE_SAMPLE_RESULT_KIND = "pyamplicol-compiled-mode-native-sample"
+NATIVE_SAMPLE_SCHEMA_VERSION = 5
+INSTALLATION_IDENTITY_KIND = "pyamplicol-installed-distribution-identity"
+INSTALLATION_IDENTITY_SCHEMA_VERSION = 2
+RESULT_KIND = "pyamplicol-compiled-mode-regression"
+CACHE_KIND = "pyamplicol-compiled-mode-regression-artifact-cache"
+CACHE_SCHEMA_VERSION = 4
+SCHEMA_VERSION = 6
+DEFAULT_GENERATION_TIMEOUT = 300.0
+DEFAULT_PROFILE_TIMEOUT = 120.0
+DEFAULT_TARGET_RUNTIME = 5.0
+DEFAULT_SAMPLE_COUNT = 7
+DEFAULT_BATCH_SIZE = 1024
+DEFAULT_WARMUP_RUNS = 2
+RELATIVE_TOLERANCE = 0.03
+MAD_MULTIPLIER = 3.0
+GAIN_RELATIVE_THRESHOLD = 0.10
+MATERIAL_RESOURCE_GROWTH_THRESHOLD = 0.03
+VALIDATION_SEED = 20260719
+VALIDATION_SAMPLE_COUNT = 8
+CORRECTNESS_POINT_DERIVATION_KIND = (
+    "pyamplicol-compiled-mode-correctness-point-derivation"
+)
+CORRECTNESS_POINT_DERIVATION_SCHEMA_VERSION = 1
+CORRECTNESS_POINT_DERIVATION_CONTRACT = (
+    "authenticated-first-validation-point-massive-rambo-v1"
+)
+CORRECTNESS_SEED_START = 20260726
+MAX_CORRECTNESS_SEED_ATTEMPTS = 256
+PRECISION32_CORRECTNESS_POLICY = "first-current-sample-exact-oracle-direct-all-f64-v1"
+DEFAULT_LC_FLOW_LAYOUT = "topology-replay"
+CORRECTNESS_RELATIVE_TOLERANCE = 1.0e-12
+CORRECTNESS_ABSOLUTE_TOLERANCE = 1.0e-15
+PERFORMANCE_RELEVANT_PAYLOAD_ROLES = frozenset(
+    {
+        "compiled-model",
+        "evaluator-manifest",
+        "evaluator-state",
+        "model-parameters",
+        "runtime-physics",
+    }
+)
+REQUIRED_PERFORMANCE_PAYLOAD_ROLES = frozenset({"evaluator-state"})
+_HASH_CHUNK_BYTES = 1024 * 1024
+EXECUTION_MODES = ("eager", "compiled")
+DEPENDENCY_DISTRIBUTIONS = (
+    ("numpy", "numpy"),
+    ("symbolica", "symbolica"),
+    ("ufo-model-loader", "ufo_model_loader"),
+)
+EAGER_DIRECT_ARENA_CAPABILITY = "eager-direct-arena-v1"
+COMPILED_DIRECT_ARENA_CAPABILITY = "compiled-plane-arena-v1"
+
+
+class RegressionError(RuntimeError):
+    """Raised when the regression measurement cannot be trusted."""
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0.0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return parsed
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return parsed
+
+
+def _at_least_five(value: str) -> int:
+    parsed = _positive_int(value)
+    if parsed < 5:
+        raise argparse.ArgumentTypeError("must be at least five")
+    return parsed
+
+
+def _absolute_path(path: Path) -> Path:
+    """Return an absolute invocation path without resolving venv symlinks."""
+
+    return Path(os.path.abspath(path.expanduser()))
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    try:
+        with path.open("rb") as stream:
+            while chunk := stream.read(_HASH_CHUNK_BYTES):
+                digest.update(chunk)
+    except OSError as error:
+        raise RegressionError(f"cannot hash file: {path}") from error
+    return digest.hexdigest()
+
+
+def _tree_identity(path: Path) -> dict[str, object]:
+    """Hash relative names and bytes for an exact, location-independent tree ID."""
+
+    try:
+        root = path.resolve(strict=True)
+    except OSError as error:
+        raise RegressionError(f"cannot resolve identity tree: {path}") from error
+    if not root.is_dir():
+        raise RegressionError(f"identity tree is not a directory: {path}")
+    digest = hashlib.sha256()
+    file_count = 0
+    size_bytes = 0
+    try:
+        members = sorted(
+            (candidate for candidate in root.rglob("*") if candidate.is_file()),
+            key=lambda candidate: candidate.relative_to(root).as_posix(),
+        )
+        for member in members:
+            relative = member.relative_to(root).as_posix().encode("utf-8")
+            size = member.stat().st_size
+            digest.update(len(relative).to_bytes(8, "big"))
+            digest.update(relative)
+            digest.update(size.to_bytes(8, "big"))
+            with member.open("rb") as stream:
+                while chunk := stream.read(_HASH_CHUNK_BYTES):
+                    digest.update(chunk)
+            file_count += 1
+            size_bytes += size
+    except OSError as error:
+        raise RegressionError(f"cannot hash identity tree: {path}") from error
+    return {
+        "algorithm": "sha256-relative-path-size-content-v1",
+        "sha256": digest.hexdigest(),
+        "file_count": file_count,
+        "size_bytes": size_bytes,
+    }
+
+
+def _normalized_distribution_name(value: str) -> str:
+    return re.sub(r"[-_.]+", "-", value).casefold()
+
+
+def _dependency_site_identity(path: Path) -> dict[str, object]:
+    """Hash every external distribution used by measured artifact generation."""
+
+    try:
+        root = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise RegressionError(f"cannot resolve dependency site: {path}") from error
+    if not root.is_dir():
+        raise RegressionError(f"dependency site is not a directory: {root}")
+    available: dict[str, list[importlib.metadata.Distribution]] = {}
+    for distribution in importlib.metadata.distributions(path=[str(root)]):
+        name = distribution.metadata.get("Name")
+        if isinstance(name, str):
+            available.setdefault(_normalized_distribution_name(name), []).append(
+                distribution
+            )
+    identities: dict[str, dict[str, object]] = {}
+    for distribution_name, import_name in DEPENDENCY_DISTRIBUTIONS:
+        normalized_name = _normalized_distribution_name(distribution_name)
+        matches = available.get(normalized_name, [])
+        if len(matches) != 1:
+            raise RegressionError(
+                "dependency site must contain exactly one "
+                f"{distribution_name} distribution, "
+                f"found {len(matches)}: {root}"
+            )
+        distribution = matches[0]
+        digest = hashlib.sha256()
+        file_count = 0
+        size_bytes = 0
+        package_origin: Path | None = None
+        entries = sorted(distribution.files or (), key=str)
+        for entry in entries:
+            relative = Path(str(entry))
+            if (
+                relative.is_absolute()
+                or ".." in relative.parts
+                or "__pycache__" in relative.parts
+                or relative.suffix == ".pyc"
+            ):
+                continue
+            candidate = root / relative
+            try:
+                resolved = candidate.resolve(strict=True)
+                resolved.relative_to(root)
+            except (OSError, ValueError) as error:
+                raise RegressionError(
+                    f"{distribution_name} dependency file escapes its "
+                    f"authenticated site: {entry}"
+                ) from error
+            if not resolved.is_file():
+                continue
+            encoded = relative.as_posix().encode("utf-8")
+            size = resolved.stat().st_size
+            digest.update(len(encoded).to_bytes(8, "big"))
+            digest.update(encoded)
+            digest.update(size.to_bytes(8, "big"))
+            with resolved.open("rb") as stream:
+                while chunk := stream.read(_HASH_CHUNK_BYTES):
+                    digest.update(chunk)
+            file_count += 1
+            size_bytes += size
+            if relative.as_posix() == f"{import_name}/__init__.py":
+                package_origin = resolved
+        if file_count == 0 or package_origin is None:
+            raise RegressionError(
+                f"dependency distribution {distribution_name!r} has no "
+                f"authenticated package content in {root}"
+            )
+        identities[distribution_name] = {
+            "name": str(distribution.metadata["Name"]),
+            "version": distribution.version,
+            "package_origin": str(package_origin),
+            "algorithm": "sha256-relative-path-size-content-v1",
+            "sha256": digest.hexdigest(),
+            "file_count": file_count,
+            "size_bytes": size_bytes,
+        }
+    digest_basis = {
+        package: {
+            key: value
+            for key, value in identity.items()
+            if key not in {"package_origin"}
+        }
+        for package, identity in identities.items()
+    }
+    return {
+        "path": str(path),
+        "resolved_path": str(root),
+        "algorithm": ("sha256-numpy-symbolica-ufo-model-loader-distributions-v1"),
+        "sha256": _canonical_sha256(digest_basis),
+        "distributions": identities,
+    }
+
+
+def _command_identity(command: Sequence[str]) -> dict[str, object]:
+    argv = [str(value) for value in command]
+    canonical = json.dumps(
+        argv,
+        ensure_ascii=False,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    return {
+        "argv": argv,
+        "argv_sha256": hashlib.sha256(canonical).hexdigest(),
+    }
+
+
+def _canonical_sha256(value: object) -> str:
+    encoded = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _model_argument(value: str) -> str:
+    candidate = Path(value).expanduser()
+    return str(_absolute_path(candidate)) if candidate.exists() else value
+
+
+def _require_interpreter(path: Path, *, lane: str) -> Path:
+    path = _absolute_path(path)
+    if not path.is_file():
+        raise RegressionError(f"{lane} Python does not exist: {path}")
+    if not os.access(path, os.X_OK):
+        raise RegressionError(f"{lane} Python is not executable: {path}")
+    return path
+
+
+def _guarded_command(command: Sequence[str]) -> tuple[str, ...]:
+    if not WATCHDOG.is_file():
+        raise RegressionError(f"memory watchdog does not exist: {WATCHDOG}")
+    if not NATIVE_SAMPLE_HELPER.is_file():
+        raise RegressionError(
+            f"native sampling helper does not exist: {NATIVE_SAMPLE_HELPER}"
+        )
+    if not DEPENDENCY_ENTRY.is_file():
+        raise RegressionError(
+            f"dependency entry helper does not exist: {DEPENDENCY_ENTRY}"
+        )
+    return (
+        sys.executable,
+        str(WATCHDOG),
+        "--limit-gib",
+        f"{MEMORY_LIMIT_GIB:g}",
+        "--",
+        *command,
+    )
+
+
+def _terminate_process_group(process: subprocess.Popen[str]) -> None:
+    if process.poll() is not None:
+        return
+    try:
+        os.killpg(process.pid, signal.SIGTERM)
+        process.wait(timeout=5.0)
+    except (ProcessLookupError, subprocess.TimeoutExpired):
+        with suppress(ProcessLookupError):
+            os.killpg(process.pid, signal.SIGKILL)
+        process.wait()
+
+
+def _run_json(
+    command: Sequence[str],
+    *,
+    timeout: float,
+    environment: Mapping[str, str],
+) -> tuple[dict[str, Any], float, str]:
+    """Run a JSON-producing generation/sample command under the watchdog."""
+
+    guarded = _guarded_command(command)
+    started = time.monotonic()
+    process = subprocess.Popen(
+        guarded,
+        cwd=ROOT,
+        env=dict(environment),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        start_new_session=True,
+    )
+    try:
+        stdout, stderr = process.communicate(timeout=timeout)
+    except subprocess.TimeoutExpired as error:
+        _terminate_process_group(process)
+        raise RegressionError(
+            f"command exceeded {timeout:.1f}s: {' '.join(command)}"
+        ) from error
+    elapsed = time.monotonic() - started
+    if process.returncode != 0:
+        detail = stderr.strip() or stdout.strip() or f"exit code {process.returncode}"
+        raise RegressionError(f"command failed: {' '.join(command)}\n{detail}")
+    try:
+        payload = json.loads(stdout)
+    except json.JSONDecodeError as error:
+        raise RegressionError(
+            f"command did not emit JSON: {' '.join(command)}\n{stdout[-2000:]}"
+        ) from error
+    if not isinstance(payload, dict):
+        raise RegressionError("command JSON result must be an object")
+    return payload, elapsed, stderr
+
+
+def _generation_command(
+    python: Path,
+    *,
+    process: str,
+    artifact: Path,
+    model: str,
+    color: str,
+    execution_mode: str = "compiled",
+    jit_optimization_level: int = 3,
+    lc_flow_layout: str = DEFAULT_LC_FLOW_LAYOUT,
+    dependency_site: Path | None = None,
+) -> tuple[str, ...]:
+    if execution_mode not in EXECUTION_MODES:
+        raise RegressionError(f"unsupported execution mode: {execution_mode!r}")
+    arguments = (
+        "generate",
+        process,
+        str(artifact),
+        "--model",
+        model,
+        "--backend",
+        "jit",
+        "--execution-mode",
+        execution_mode,
+        "--jit-optimization-level",
+        str(jit_optimization_level),
+        "--color-accuracy",
+        color,
+        "--lc-flow-layout",
+        lc_flow_layout,
+        "--mode",
+        "replace",
+        "--workers",
+        "1",
+        "--validation",
+        "--validation-samples",
+        str(VALIDATION_SAMPLE_COUNT),
+        "--validation-seed",
+        str(VALIDATION_SEED),
+        "--no-post-build-validation",
+        "--no-emit-api-bundle",
+        "--progress",
+        "off",
+        "--json",
+    )
+    if dependency_site is None:
+        return (str(python), "-m", "pyamplicol", *arguments)
+    return (
+        str(python),
+        str(DEPENDENCY_ENTRY),
+        "--dependency-site",
+        str(dependency_site),
+        "--module",
+        "pyamplicol",
+        "--",
+        *arguments,
+    )
+
+
+def _profile_command(
+    python: Path,
+    *,
+    artifact: Path,
+    process_id: str,
+    batch_size: int,
+    target_runtime: float,
+    minimum_samples: int,
+    warmup_runs: int,
+    helicities: Sequence[str],
+    color_flows: Sequence[str],
+    execution_mode: str = "compiled",
+    profile_protocol: str = ARENA_PROFILE_PROTOCOL,
+    dependency_site: Path | None = None,
+    include_precision32: bool = False,
+) -> tuple[str, ...]:
+    command = [
+        str(python),
+        str(NATIVE_SAMPLE_HELPER),
+        str(artifact),
+        "--process",
+        process_id,
+        "--execution-mode",
+        execution_mode,
+        "--profile-protocol",
+        profile_protocol,
+        "--target-runtime",
+        str(target_runtime),
+        "--batch-size",
+        str(batch_size),
+        "--warmup-runs",
+        str(warmup_runs),
+        "--minimum-samples",
+        str(minimum_samples),
+    ]
+    for helicity in helicities:
+        command.extend(("--helicity", helicity))
+    for color_flow in color_flows:
+        command.extend(("--color-flow", color_flow))
+    if dependency_site is not None:
+        command.extend(("--dependency-site", str(dependency_site)))
+    if include_precision32:
+        command.append("--include-precision32")
+    return tuple(command)
+
+
+def _watchdog_peak_gib(stderr: str) -> float | None:
+    matches = re.findall(r"peak_rss=([0-9]+(?:\.[0-9]+)?) GiB", stderr)
+    return float(matches[-1]) if matches else None
+
+
+def _watchdog_marker(stderr: str) -> str | None:
+    markers = [
+        line.strip()
+        for line in stderr.splitlines()
+        if line.startswith("memory-watchdog: command finished")
+    ]
+    return markers[-1] if markers else None
+
+
+def _json_object(path: Path, *, label: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise RegressionError(f"cannot read {label}: {path}") from error
+    if not isinstance(payload, dict):
+        raise RegressionError(f"{label} must be a JSON object: {path}")
+    return payload
+
+
+def _artifact_lc_flow_layout(
+    manifest: Mapping[str, Any],
+    *,
+    process_id: str,
+) -> str | None:
+    extensions = manifest.get("extensions")
+    if not isinstance(extensions, Mapping):
+        return None
+    generation = extensions.get("generation")
+    if not isinstance(generation, Mapping):
+        return None
+    processes = generation.get("concrete_processes")
+    if not isinstance(processes, list):
+        return None
+    for process in processes:
+        if not isinstance(process, Mapping) or process.get("id") != process_id:
+            continue
+        filters = process.get("filters")
+        if not isinstance(filters, Mapping):
+            return None
+        layout = filters.get("lc_flow_layout")
+        return layout if isinstance(layout, str) and layout else None
+    return None
+
+
+def _artifact_payload_digests(
+    manifest: Mapping[str, Any],
+    *,
+    artifact: Path,
+) -> list[dict[str, object]]:
+    payloads = manifest.get("payloads")
+    if payloads is None:
+        return []
+    if not isinstance(payloads, list):
+        raise RegressionError("artifact payload inventory must be a list")
+    try:
+        artifact_root = artifact.resolve(strict=True)
+    except OSError as error:
+        raise RegressionError(f"cannot resolve artifact root: {artifact}") from error
+    result: list[dict[str, object]] = []
+    for payload in payloads:
+        if not isinstance(payload, Mapping):
+            raise RegressionError("artifact payload inventory entry is invalid")
+        path = payload.get("path")
+        sha256 = payload.get("sha256")
+        size_bytes = payload.get("size_bytes")
+        if (
+            not isinstance(path, str)
+            or not path
+            or not isinstance(sha256, str)
+            or re.fullmatch(r"[0-9a-f]{64}", sha256) is None
+            or isinstance(size_bytes, bool)
+            or not isinstance(size_bytes, int)
+            or size_bytes < 0
+        ):
+            raise RegressionError("artifact payload digest entry is invalid")
+        try:
+            payload_path = (artifact / path).resolve(strict=True)
+            payload_path.relative_to(artifact_root)
+        except (OSError, ValueError) as error:
+            raise RegressionError(
+                f"artifact payload path is invalid: {path!r}"
+            ) from error
+        observed_size = payload_path.stat().st_size
+        observed_sha256 = _sha256_file(payload_path)
+        if observed_size != size_bytes or observed_sha256 != sha256:
+            raise RegressionError(
+                f"artifact payload does not match its declared digest: {path!r}"
+            )
+        identity: dict[str, object] = {
+            "path": path,
+            "sha256": observed_sha256,
+            "size_bytes": observed_size,
+            "role": payload.get("role"),
+        }
+        process_id = payload.get("process_id")
+        if process_id is not None:
+            identity["process_id"] = process_id
+        result.append(identity)
+    return sorted(result, key=lambda entry: str(entry["path"]))
+
+
+def _artifact_execution_mode(record: Mapping[str, Any]) -> str | None:
+    capabilities = record.get("required_runtime_capabilities")
+    if not isinstance(capabilities, list):
+        return None
+    normalized = tuple(str(capability) for capability in capabilities)
+    if any(
+        capability
+        in {
+            "eager-direct-arena-v1",
+            "rusticol.eager-runtime-layout.complex-f64.v1",
+        }
+        or "eager-dag" in capability
+        for capability in normalized
+    ):
+        return "eager"
+    if any(
+        capability == "compiled-plane-arena-v1"
+        or capability == "symjit.application.complex-f64.v1"
+        for capability in normalized
+    ):
+        return "compiled"
+    return None
+
+
+def _artifact_effective_contract(artifact: Path) -> dict[str, object] | None:
+    path = artifact / "config" / "effective.toml"
+    if not path.is_file():
+        return None
+    try:
+        payload = tomllib.loads(path.read_text(encoding="utf-8"))
+        evaluator = payload["evaluator"]
+        color = payload["color"]
+        jit = evaluator["jit"]
+    except (OSError, KeyError, TypeError, tomllib.TOMLDecodeError) as error:
+        raise RegressionError(
+            f"artifact has an invalid effective configuration: {path}"
+        ) from error
+    if not isinstance(evaluator, Mapping) or not isinstance(color, Mapping):
+        raise RegressionError(f"artifact effective configuration is invalid: {path}")
+    return {
+        "backend": evaluator.get("backend"),
+        "execution_mode": evaluator.get("execution_mode"),
+        "jit_optimization_level": (
+            jit.get("optimization_level") if isinstance(jit, Mapping) else None
+        ),
+        "lc_flow_layout": color.get("lc_flow_layout"),
+        "color_accuracy": color.get("accuracy"),
+    }
+
+
+def _artifact_semantic_identity(
+    manifest: Mapping[str, Any],
+    record: Mapping[str, Any],
+    *,
+    artifact: Path,
+    process_id: str,
+    execution_mode: str,
+    lc_flow_layout: str | None,
+) -> dict[str, object] | None:
+    """Build an ABI-neutral identity for the timed public physics workload."""
+
+    physics_relative = record.get("physics_path")
+    payloads = manifest.get("payloads")
+    if not isinstance(physics_relative, str) or not isinstance(payloads, list):
+        return None
+    validation_records = [
+        payload
+        for payload in payloads
+        if isinstance(payload, Mapping)
+        and payload.get("role") == "validation-momenta"
+        and payload.get("process_id") == process_id
+        and isinstance(payload.get("path"), str)
+    ]
+    if len(validation_records) != 1:
+        return None
+    physics = _json_object(
+        artifact / physics_relative,
+        label="runtime physics",
+    )
+    validation = _json_object(
+        artifact / str(validation_records[0]["path"]),
+        label="validation momenta",
+    )
+    model = manifest.get("model")
+    if not isinstance(model, Mapping):
+        return None
+    common_model = {
+        key: model.get(key)
+        for key in (
+            "name",
+            "restriction",
+            "compiled_schema_version",
+            "content_sha256",
+        )
+    }
+    effective_contract = _artifact_effective_contract(artifact)
+    if effective_contract is None:
+        return None
+    identity = {
+        "kind": "pyamplicol-abi-neutral-performance-workload",
+        "schema_version": 1,
+        "process": {
+            "id": process_id,
+            "expression": (
+                " ".join(str(record.get("expression", "")).split()).casefold()
+            ),
+            "external_pdgs": record.get("external_pdgs"),
+        },
+        "model_common_physics": common_model,
+        "color_accuracy": record.get("color_accuracy"),
+        "lc_flow_layout": lc_flow_layout,
+        "execution_mode": execution_mode,
+        "effective_contract": effective_contract,
+        "runtime_physics": physics,
+        "runtime_physics_sha256": _canonical_sha256(physics),
+        "validation_momenta": validation,
+        "validation_momenta_sha256": _canonical_sha256(validation),
+    }
+    return {
+        **identity,
+        "sha256": _canonical_sha256(identity),
+    }
+
+
+def _artifact_metadata(
+    artifact: Path,
+    *,
+    expected_process: str,
+    expected_color: str,
+    expected_execution_mode: str = "compiled",
+    expected_lc_flow_layout: str | None = None,
+) -> dict[str, Any]:
+    manifest_path = artifact / "artifact.json"
+    outer = _json_object(manifest_path, label="artifact manifest")
+    processes = outer.get("processes")
+    if not isinstance(processes, list) or len(processes) != 1:
+        raise RegressionError(
+            f"regression artifact must contain exactly one process: {artifact}"
+        )
+    record = processes[0]
+    if not isinstance(record, dict):
+        raise RegressionError(f"artifact process metadata is invalid: {artifact}")
+    process_id = record.get("id")
+    expression = record.get("expression")
+    color = record.get("color_accuracy")
+    if not isinstance(process_id, str) or not process_id:
+        raise RegressionError(f"artifact process ID is invalid: {artifact}")
+    if not isinstance(expression, str) or (
+        " ".join(expression.split()).casefold()
+        != " ".join(expected_process.split()).casefold()
+    ):
+        raise RegressionError(
+            f"artifact process does not match {expected_process!r}: {artifact}"
+        )
+    if color != expected_color:
+        raise RegressionError(
+            f"artifact color accuracy does not match {expected_color!r}: {artifact}"
+        )
+    execution_mode = _artifact_execution_mode(record)
+    if execution_mode != expected_execution_mode:
+        raise RegressionError(
+            f"artifact is not {expected_execution_mode} mode: {artifact}"
+        )
+    raw_capabilities = record.get("required_runtime_capabilities")
+    if not isinstance(raw_capabilities, list) or not all(
+        isinstance(value, str) for value in raw_capabilities
+    ):
+        raise RegressionError(
+            f"artifact runtime capability inventory is invalid: {artifact}"
+        )
+    artifact_id = outer.get("artifact_id")
+    if not isinstance(artifact_id, str) or not artifact_id:
+        raise RegressionError(f"artifact ID is invalid: {artifact}")
+    lc_flow_layout = _artifact_lc_flow_layout(outer, process_id=process_id)
+    if (
+        expected_lc_flow_layout is not None
+        and lc_flow_layout != expected_lc_flow_layout
+    ):
+        raise RegressionError(
+            "artifact LC flow layout does not match "
+            f"{expected_lc_flow_layout!r}: got {lc_flow_layout!r} in {artifact}"
+        )
+    tree_identity = _tree_identity(artifact)
+    payload_digests = _artifact_payload_digests(outer, artifact=artifact)
+    semantic_identity = _artifact_semantic_identity(
+        outer,
+        record,
+        artifact=artifact,
+        process_id=process_id,
+        execution_mode=execution_mode,
+        lc_flow_layout=lc_flow_layout,
+    )
+    extensions = outer.get("extensions")
+    generation = (
+        extensions.get("generation") if isinstance(extensions, Mapping) else None
+    )
+    raw_phases = (
+        generation.get("phase_timings_seconds")
+        if isinstance(generation, Mapping)
+        else None
+    )
+    phase_timings: dict[str, float] | None = None
+    core_generation_seconds: float | None = None
+    if isinstance(raw_phases, Mapping):
+        phase_timings = {}
+        for name, raw_value in raw_phases.items():
+            if (
+                not isinstance(name, str)
+                or isinstance(raw_value, bool)
+                or not isinstance(raw_value, (float, int))
+                or not math.isfinite(float(raw_value))
+                or float(raw_value) < 0.0
+            ):
+                raise RegressionError(
+                    f"artifact has an invalid generation phase: {artifact}"
+                )
+            phase_timings[name] = float(raw_value)
+        core_generation_seconds = sum(
+            value
+            for name, value in phase_timings.items()
+            if name not in {"model-loading", "process-expansion"}
+        )
+        if core_generation_seconds <= 0.0:
+            core_generation_seconds = None
+    material_payload_size_bytes = sum(
+        int(payload["size_bytes"])
+        for payload in payload_digests
+        if str(payload.get("role"))
+        not in {
+            "configuration-effective",
+            "configuration-requested",
+            "validation-momenta",
+        }
+    )
+    return {
+        "artifact_id": artifact_id,
+        "path": str(artifact),
+        "process_id": process_id,
+        "process_expression": expression,
+        "color_accuracy": color,
+        "execution_mode": execution_mode,
+        "required_runtime_capabilities": list(raw_capabilities),
+        "lc_flow_layout": lc_flow_layout,
+        "manifest_sha256": _sha256_file(manifest_path),
+        "tree_identity": tree_identity,
+        "payload_digests": payload_digests,
+        "payload_digest_count": len(payload_digests),
+        "material_payload_size_bytes": material_payload_size_bytes,
+        "size_bytes": tree_identity["size_bytes"],
+        "producer": outer.get("producer"),
+        "semantic_workload_identity": semantic_identity,
+        "semantic_workload_sha256": (
+            None if semantic_identity is None else semantic_identity["sha256"]
+        ),
+        "generation_phase_timings_seconds": phase_timings,
+        "core_generation_seconds": core_generation_seconds,
+    }
+
+
+def _path_identity(path: Path) -> dict[str, object]:
+    try:
+        stat = path.stat()
+        resolved = path.resolve(strict=True)
+    except OSError as error:
+        raise RegressionError(f"cannot inspect path identity: {path}") from error
+    return {
+        "path": str(path),
+        "resolved_path": str(resolved),
+        "size_bytes": stat.st_size,
+        "mtime_ns": stat.st_mtime_ns,
+        "sha256": _sha256_file(resolved),
+    }
+
+
+def _model_identity(model: str) -> dict[str, object]:
+    path = Path(model).expanduser()
+    if not path.exists():
+        return {"argument": model, "path_backed": False}
+    try:
+        absolute = _absolute_path(path)
+        resolved = absolute.resolve(strict=True)
+        stat = resolved.stat()
+    except OSError as error:
+        raise RegressionError(f"cannot inspect model identity: {model}") from error
+    result: dict[str, object] = {
+        "argument": model,
+        "path_backed": True,
+        "path": str(absolute),
+        "resolved_path": str(resolved),
+        "is_directory": resolved.is_dir(),
+        "mtime_ns": stat.st_mtime_ns,
+        "size_bytes": stat.st_size,
+    }
+    if resolved.is_dir():
+        tree = _tree_identity(resolved)
+        result["tree_identity"] = tree
+        result["size_bytes"] = tree["size_bytes"]
+    elif resolved.is_file():
+        result["sha256"] = _sha256_file(resolved)
+    else:
+        raise RegressionError(f"model path is not a file or directory: {model}")
+    return result
+
+
+def _generation_signature(
+    python: Path,
+    *,
+    installation_identity: Mapping[str, Any],
+    process: str,
+    model: str,
+    color: str,
+    execution_mode: str = "compiled",
+    jit_optimization_level: int = 3,
+    lc_flow_layout: str = DEFAULT_LC_FLOW_LAYOUT,
+    dependency_site: Path | None = None,
+    dependency_site_identity: Mapping[str, Any] | None = None,
+    artifact: Path | None = None,
+) -> dict[str, object]:
+    result: dict[str, object] = {
+        "generation_driver": _path_identity(Path(__file__)),
+        "dependency_entry": _path_identity(DEPENDENCY_ENTRY),
+        "python": _path_identity(python),
+        "installed_pyamplicol": dict(installation_identity),
+        "process": process,
+        "model": _model_identity(model),
+        "color_accuracy": color,
+        "lc_flow_layout": lc_flow_layout,
+        "execution_mode": execution_mode,
+        "backend": "jit",
+        "jit_optimization_level": jit_optimization_level,
+        "dependency_site": (
+            None
+            if dependency_site is None
+            else dict(
+                dependency_site_identity
+                if dependency_site_identity is not None
+                else _dependency_site_identity(dependency_site)
+            )
+        ),
+        "workers": 1,
+        "validation_samples": VALIDATION_SAMPLE_COUNT,
+        "validation_seed": VALIDATION_SEED,
+        "post_build_validation": False,
+        "emit_api_bundle": False,
+    }
+    if artifact is not None:
+        result["generation_command"] = _command_identity(
+            _generation_command(
+                python,
+                process=process,
+                artifact=artifact,
+                model=model,
+                color=color,
+                execution_mode=execution_mode,
+                jit_optimization_level=jit_optimization_level,
+                lc_flow_layout=lc_flow_layout,
+                dependency_site=dependency_site,
+            )
+        )
+    return result
+
+
+def _installed_pyamplicol_identity(
+    python: Path,
+    *,
+    environment: Mapping[str, str],
+) -> dict[str, Any]:
+    command = (str(python), str(NATIVE_SAMPLE_HELPER), "--installation-identity")
+    payload, _elapsed, _stderr = _run_json(
+        command,
+        timeout=DEFAULT_PROFILE_TIMEOUT,
+        environment=environment,
+    )
+    _require_equal(
+        payload,
+        "kind",
+        INSTALLATION_IDENTITY_KIND,
+        label="installed pyamplicol identity kind",
+    )
+    _require_equal(
+        payload,
+        "schema_version",
+        INSTALLATION_IDENTITY_SCHEMA_VERSION,
+        label="installed pyamplicol identity schema_version",
+    )
+    distribution_content = payload.get("distribution_content")
+    if not isinstance(distribution_content, Mapping):
+        raise RegressionError(
+            "installed pyamplicol identity has no distribution content identity"
+        )
+    digest = distribution_content.get("sha256")
+    if not isinstance(digest, str) or re.fullmatch(r"[0-9a-f]{64}", digest) is None:
+        raise RegressionError(
+            "installed pyamplicol identity has an invalid distribution SHA-256"
+        )
+    native_modules = payload.get("native_modules")
+    if (
+        not isinstance(native_modules, Sequence)
+        or isinstance(native_modules, (str, bytes))
+        or len(native_modules) != 1
+    ):
+        raise RegressionError(
+            "installed pyamplicol identity must contain one native module"
+        )
+    return dict(payload)
+
+
+def _read_cache(path: Path) -> dict[str, Any] | None:
+    if not path.is_file():
+        return None
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def _ensure_artifact(
+    lane: str,
+    python: Path,
+    *,
+    output_root: Path,
+    process: str,
+    model: str,
+    color: str,
+    execution_mode: str = "compiled",
+    jit_optimization_level: int = 3,
+    generation_timeout: float,
+    regenerate: bool,
+    environment: Mapping[str, str],
+    lc_flow_layout: str = DEFAULT_LC_FLOW_LAYOUT,
+    dependency_site: Path | None = None,
+    dependency_site_identity: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    lane_root = output_root / lane
+    artifact = lane_root / "artifact"
+    cache_path = lane_root / "artifact-cache.json"
+    expected_artifact_lc_flow_layout = lc_flow_layout if color == "lc" else None
+    generation_command = _generation_command(
+        python,
+        process=process,
+        artifact=artifact,
+        model=model,
+        color=color,
+        execution_mode=execution_mode,
+        jit_optimization_level=jit_optimization_level,
+        lc_flow_layout=lc_flow_layout,
+        dependency_site=dependency_site,
+    )
+    command_identity = _command_identity(generation_command)
+    installation_identity = _installed_pyamplicol_identity(
+        python,
+        environment=environment,
+    )
+    signature = _generation_signature(
+        python,
+        installation_identity=installation_identity,
+        process=process,
+        model=model,
+        color=color,
+        execution_mode=execution_mode,
+        jit_optimization_level=jit_optimization_level,
+        lc_flow_layout=lc_flow_layout,
+        dependency_site=dependency_site,
+        dependency_site_identity=dependency_site_identity,
+        artifact=artifact,
+    )
+    cache = None if regenerate else _read_cache(cache_path)
+    if (
+        cache is not None
+        and cache.get("kind") == CACHE_KIND
+        and cache.get("schema_version") == CACHE_SCHEMA_VERSION
+        and cache.get("signature") == signature
+    ):
+        try:
+            metadata = _artifact_metadata(
+                artifact,
+                expected_process=process,
+                expected_color=color,
+                expected_execution_mode=execution_mode,
+                expected_lc_flow_layout=expected_artifact_lc_flow_layout,
+            )
+        except RegressionError:
+            pass
+        else:
+            tree_identity = metadata["tree_identity"]
+            assert isinstance(tree_identity, Mapping)
+            if cache.get("artifact_id") == metadata["artifact_id"] and cache.get(
+                "artifact_tree_sha256"
+            ) == tree_identity.get("sha256"):
+                return {
+                    **metadata,
+                    "installation_identity": installation_identity,
+                    "reused": True,
+                    "generation": None,
+                    "generation_command": command_identity,
+                    "cache_path": str(cache_path),
+                }
+
+    lane_root.mkdir(parents=True, exist_ok=True)
+    payload, elapsed, stderr = _run_json(
+        generation_command,
+        timeout=generation_timeout,
+        environment=environment,
+    )
+    metadata = _artifact_metadata(
+        artifact,
+        expected_process=process,
+        expected_color=color,
+        expected_execution_mode=execution_mode,
+        expected_lc_flow_layout=expected_artifact_lc_flow_layout,
+    )
+    tree_identity = metadata["tree_identity"]
+    assert isinstance(tree_identity, Mapping)
+    _write_json_atomic(
+        cache_path,
+        {
+            "kind": CACHE_KIND,
+            "schema_version": CACHE_SCHEMA_VERSION,
+            "signature": signature,
+            "artifact_id": metadata["artifact_id"],
+            "artifact_tree_sha256": tree_identity["sha256"],
+        },
+    )
+    return {
+        **metadata,
+        "installation_identity": installation_identity,
+        "reused": False,
+        "generation": {
+            "command": command_identity,
+            "guarded_command": _command_identity(_guarded_command(generation_command)),
+            "command_elapsed_seconds": elapsed,
+            "peak_rss_gib": _watchdog_peak_gib(stderr),
+            "watchdog": _watchdog_marker(stderr),
+            "output": payload.get("output"),
+            "schema_version": payload.get("schema_version"),
+        },
+        "generation_command": command_identity,
+        "cache_path": str(cache_path),
+    }
+
+
+def _finite_positive(value: object, *, label: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise RegressionError(f"{label} must be numeric")
+    result = float(value)
+    if not math.isfinite(result) or result <= 0.0:
+        raise RegressionError(f"{label} must be positive and finite")
+    return result
+
+
+def _finite_nonnegative(value: object, *, label: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise RegressionError(f"{label} must be numeric")
+    result = float(value)
+    if not math.isfinite(result) or result < 0.0:
+        raise RegressionError(f"{label} must be finite and non-negative")
+    return result
+
+
+def _finite_number(value: object, *, label: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise RegressionError(f"{label} must be numeric")
+    result = float(value)
+    if not math.isfinite(result):
+        raise RegressionError(f"{label} must be finite")
+    return result
+
+
+def _positive_mapping_int(
+    mapping: Mapping[str, Any],
+    key: str,
+    *,
+    label: str,
+) -> int:
+    value = mapping.get(key)
+    if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+        raise RegressionError(f"{label} must be a positive integer")
+    return value
+
+
+def _require_equal(
+    mapping: Mapping[str, Any],
+    key: str,
+    expected: object,
+    *,
+    label: str,
+) -> None:
+    value = mapping.get(key)
+    if value != expected or type(value) is not type(expected):
+        raise RegressionError(f"{label} must be {expected!r}, got {value!r}")
+
+
+def _validated_complex_tree(value: object, *, label: str) -> object:
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        if len(value) == 2 and all(
+            not isinstance(component, (bool, Sequence))
+            and isinstance(component, (float, int))
+            for component in value
+        ):
+            return [
+                _finite_number(value[0], label=f"{label} real"),
+                _finite_number(value[1], label=f"{label} imaginary"),
+            ]
+        return [
+            _validated_complex_tree(entry, label=f"{label}[{index}]")
+            for index, entry in enumerate(value)
+        ]
+    raise RegressionError(f"{label} must be a nested complex-pair sequence")
+
+
+def _flatten_complex_tree(value: object) -> list[tuple[float, float]]:
+    if (
+        isinstance(value, Sequence)
+        and not isinstance(value, (str, bytes))
+        and len(value) == 2
+        and all(isinstance(component, (float, int)) for component in value)
+    ):
+        return [(float(value[0]), float(value[1]))]
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        return [pair for entry in value for pair in _flatten_complex_tree(entry)]
+    raise RegressionError("resolved complex value tree is invalid")
+
+
+def _validated_complex_array(
+    value: object,
+    *,
+    shape: Sequence[int],
+    label: str,
+) -> object:
+    if not shape:
+        return _validated_complex_tree(value, label=label)
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        raise RegressionError(f"{label} must be an exact nested complex array")
+    expected = shape[0]
+    if len(value) != expected:
+        raise RegressionError(
+            f"{label} axis length differs: {len(value)} != {expected}"
+        )
+    return [
+        _validated_complex_array(
+            entry,
+            shape=shape[1:],
+            label=f"{label}[{index}]",
+        )
+        for index, entry in enumerate(value)
+    ]
+
+
+def _validated_numerical_result(
+    value: object,
+    *,
+    precision: int,
+    helicities: Sequence[str],
+    color_flows: Sequence[str],
+    required: bool,
+) -> dict[str, Any] | None:
+    label = f"precision-{precision} numerical result"
+    if value is None and not required:
+        return None
+    if not isinstance(value, Mapping):
+        raise RegressionError(f"native sample has no {label}")
+    _require_equal(value, "precision", precision, label=f"{label} precision")
+    point_count = _positive_mapping_int(
+        value,
+        "point_count",
+        label=f"{label} point_count",
+    )
+    distinct_point_count = _positive_mapping_int(
+        value,
+        "distinct_point_count",
+        label=f"{label} distinct_point_count",
+    )
+    point_sha256 = value.get("point_sha256")
+    if (
+        point_count != VALIDATION_SAMPLE_COUNT
+        or distinct_point_count != point_count
+        or not isinstance(point_sha256, Sequence)
+        or isinstance(point_sha256, (str, bytes))
+        or len(point_sha256) != point_count
+        or any(
+            not isinstance(digest, str) or re.fullmatch(r"[0-9a-f]{64}", digest) is None
+            for digest in point_sha256
+        )
+        or len(set(point_sha256)) != point_count
+    ):
+        raise RegressionError(
+            f"{label} must contain {VALIDATION_SAMPLE_COUNT} distinct points"
+        )
+    batch_sha256 = value.get("batch_sha256")
+    if (
+        not isinstance(batch_sha256, str)
+        or re.fullmatch(r"[0-9a-f]{64}", batch_sha256) is None
+    ):
+        raise RegressionError(f"{label} has an invalid batch SHA-256")
+    numerical_values = value.get("values_f64")
+    numerical_hex = value.get("values_f64_hex")
+    if (
+        not isinstance(numerical_values, Sequence)
+        or isinstance(numerical_values, (str, bytes))
+        or not isinstance(numerical_hex, Sequence)
+        or isinstance(numerical_hex, (str, bytes))
+        or len(numerical_values) != point_count
+        or len(numerical_hex) != point_count
+    ):
+        raise RegressionError(f"{label} has invalid value vectors")
+    validated_values: list[float] = []
+    validated_hex: list[str] = []
+    for raw_value, raw_hex in zip(numerical_values, numerical_hex, strict=True):
+        converted = _finite_number(raw_value, label=f"{label} value")
+        if not isinstance(raw_hex, str) or raw_hex != converted.hex():
+            raise RegressionError(f"{label} has an invalid raw f64 representation")
+        validated_values.append(converted)
+        validated_hex.append(raw_hex)
+    for key, selector_expected in (
+        ("helicities", list(helicities)),
+        ("color_flows", list(color_flows)),
+    ):
+        if value.get(key) != selector_expected:
+            raise RegressionError(f"{label} {key} do not match timed selectors")
+    resolved = value.get("resolved")
+    if not isinstance(resolved, Mapping):
+        raise RegressionError(f"{label} has no resolved evidence")
+    resolved_shape = resolved.get("shape")
+    resolved_helicity_ids = resolved.get("helicity_ids")
+    resolved_color_ids = resolved.get("color_ids")
+    if (
+        not isinstance(resolved_shape, Sequence)
+        or isinstance(resolved_shape, (str, bytes))
+        or len(resolved_shape) != 3
+        or not all(
+            isinstance(axis, int) and not isinstance(axis, bool) and axis >= 0
+            for axis in resolved_shape
+        )
+        or not isinstance(resolved_helicity_ids, Sequence)
+        or isinstance(resolved_helicity_ids, (str, bytes))
+        or not all(isinstance(identifier, str) for identifier in resolved_helicity_ids)
+        or not isinstance(resolved_color_ids, Sequence)
+        or isinstance(resolved_color_ids, (str, bytes))
+        or not all(isinstance(identifier, str) for identifier in resolved_color_ids)
+    ):
+        raise RegressionError(f"{label} resolved metadata is invalid")
+    expected_shape = [
+        point_count,
+        len(resolved_helicity_ids),
+        len(resolved_color_ids),
+    ]
+    if list(resolved_shape) != expected_shape:
+        raise RegressionError(
+            f"{label} resolved shape differs: {list(resolved_shape)} "
+            f"!= {expected_shape}"
+        )
+    resolved_totals = _validated_complex_array(
+        resolved.get("totals_complex"),
+        shape=(point_count,),
+        label=f"{label} resolved totals",
+    )
+    resolved_values = _validated_complex_array(
+        resolved.get("values_complex"),
+        shape=tuple(expected_shape),
+        label=f"{label} resolved values",
+    )
+    assert isinstance(resolved_totals, list)
+    for scalar, pair in zip(validated_values, resolved_totals, strict=True):
+        if (
+            not isinstance(pair, Sequence)
+            or len(pair) != 2
+            or not math.isclose(
+                scalar,
+                float(pair[0]),
+                rel_tol=CORRECTNESS_RELATIVE_TOLERANCE,
+                abs_tol=CORRECTNESS_ABSOLUTE_TOLERANCE,
+            )
+            or not math.isclose(
+                float(pair[1]),
+                0.0,
+                rel_tol=0.0,
+                abs_tol=CORRECTNESS_ABSOLUTE_TOLERANCE,
+            )
+        ):
+            raise RegressionError(f"{label} evaluate() disagrees with resolved totals")
+    return {
+        "precision": precision,
+        "point_count": point_count,
+        "distinct_point_count": distinct_point_count,
+        "point_sha256": list(point_sha256),
+        "batch_sha256": batch_sha256,
+        "values_f64": validated_values,
+        "values_f64_hex": validated_hex,
+        "helicities": list(helicities),
+        "color_flows": list(color_flows),
+        "resolved": {
+            "shape": list(resolved_shape),
+            "helicity_ids": list(resolved_helicity_ids),
+            "color_ids": list(resolved_color_ids),
+            "totals_complex": resolved_totals,
+            "values_complex": resolved_values,
+        },
+    }
+
+
+def _validated_sha256(value: object, *, label: str) -> str:
+    if not isinstance(value, str) or re.fullmatch(r"[0-9a-f]{64}", value) is None:
+        raise RegressionError(f"{label} must be a lowercase SHA-256 digest")
+    return value
+
+
+def _validated_canonical_float_hex(
+    value: object,
+    *,
+    label: str,
+    positive: bool,
+) -> str:
+    if not isinstance(value, str):
+        raise RegressionError(f"{label} must be a canonical f64 hexadecimal value")
+    try:
+        converted = float.fromhex(value)
+    except ValueError as error:
+        raise RegressionError(
+            f"{label} must be a canonical f64 hexadecimal value"
+        ) from error
+    if (
+        not math.isfinite(converted)
+        or converted.hex() != value
+        or (converted <= 0.0 if positive else converted < 0.0)
+    ):
+        qualifier = "positive" if positive else "non-negative"
+        raise RegressionError(f"{label} must be canonical, finite, and {qualifier}")
+    return value
+
+
+def _require_exact_keys(
+    mapping: Mapping[str, Any],
+    expected: frozenset[str],
+    *,
+    label: str,
+) -> None:
+    observed = frozenset(str(key) for key in mapping)
+    if observed != expected or any(not isinstance(key, str) for key in mapping):
+        raise RegressionError(
+            f"{label} fields differ: "
+            f"missing={sorted(expected - observed)!r}, "
+            f"unexpected={sorted(observed - expected)!r}"
+        )
+
+
+def _validated_correctness_point_derivation(
+    value: object,
+    *,
+    precision16: Mapping[str, Any],
+    precision32: Mapping[str, Any] | None,
+) -> dict[str, Any]:
+    label = "correctness point derivation"
+    if not isinstance(value, Mapping):
+        raise RegressionError(f"native sample has no {label}")
+    _require_exact_keys(
+        value,
+        frozenset(
+            {
+                "kind",
+                "schema_version",
+                "contract",
+                "source_validation",
+                "numpy",
+                "sqrt_s_f64_hex",
+                "external_mass_f64_hex",
+                "final_state_mass_f64_hex",
+                "seed_start",
+                "seed_attempt_limit",
+                "attempt_count",
+                "selected_seeds",
+                "point_sha256",
+                "invariant_sha256",
+                "batch_sha256",
+                "sha256",
+            }
+        ),
+        label=label,
+    )
+    _require_equal(
+        value,
+        "kind",
+        CORRECTNESS_POINT_DERIVATION_KIND,
+        label=f"{label} kind",
+    )
+    _require_equal(
+        value,
+        "schema_version",
+        CORRECTNESS_POINT_DERIVATION_SCHEMA_VERSION,
+        label=f"{label} schema_version",
+    )
+    _require_equal(
+        value,
+        "contract",
+        CORRECTNESS_POINT_DERIVATION_CONTRACT,
+        label=f"{label} contract",
+    )
+
+    source = value.get("source_validation")
+    if not isinstance(source, Mapping):
+        raise RegressionError(f"{label} has no authenticated source identity")
+    _require_exact_keys(
+        source,
+        frozenset(
+            {
+                "file_sha256",
+                "canonical_sha256",
+                "size_bytes",
+                "process_id",
+                "process_expression",
+                "external_pdgs",
+                "point_count",
+                "selected_point_index",
+                "selected_point_sha256",
+            }
+        ),
+        label=f"{label} source_validation",
+    )
+    for key in ("file_sha256", "canonical_sha256", "selected_point_sha256"):
+        _validated_sha256(
+            source.get(key),
+            label=f"{label} source_validation {key}",
+        )
+    source_size = source.get("size_bytes")
+    if (
+        isinstance(source_size, bool)
+        or not isinstance(source_size, int)
+        or source_size <= 0
+    ):
+        raise RegressionError(f"{label} source_validation size_bytes must be positive")
+    for key in ("process_id", "process_expression"):
+        source_text = source.get(key)
+        if not isinstance(source_text, str) or not source_text.strip():
+            raise RegressionError(f"{label} source_validation {key} must be non-empty")
+    source_pdgs = source.get("external_pdgs")
+    if (
+        not isinstance(source_pdgs, Sequence)
+        or isinstance(source_pdgs, (str, bytes))
+        or len(source_pdgs) < 4
+        or any(isinstance(pdg, bool) or not isinstance(pdg, int) for pdg in source_pdgs)
+    ):
+        raise RegressionError(f"{label} source_validation external_pdgs are invalid")
+    source_point_count = source.get("point_count")
+    if (
+        isinstance(source_point_count, bool)
+        or not isinstance(source_point_count, int)
+        or source_point_count <= 0
+    ):
+        raise RegressionError(f"{label} source_validation point_count must be positive")
+    _require_equal(
+        source,
+        "selected_point_index",
+        0,
+        label=f"{label} source_validation selected_point_index",
+    )
+
+    numpy_identity = value.get("numpy")
+    if not isinstance(numpy_identity, Mapping):
+        raise RegressionError(f"{label} has no NumPy identity")
+    _require_exact_keys(
+        numpy_identity,
+        frozenset(
+            {
+                "module",
+                "version",
+                "origin_file_name",
+                "origin_size_bytes",
+                "origin_sha256",
+                "random_generator",
+                "bit_generator",
+            }
+        ),
+        label=f"{label} NumPy identity",
+    )
+    _require_equal(
+        numpy_identity,
+        "module",
+        "numpy",
+        label=f"{label} NumPy module",
+    )
+    _require_equal(
+        numpy_identity,
+        "random_generator",
+        "default_rng",
+        label=f"{label} NumPy random_generator",
+    )
+    _require_equal(
+        numpy_identity,
+        "bit_generator",
+        "PCG64",
+        label=f"{label} NumPy bit_generator",
+    )
+    numpy_version = numpy_identity.get("version")
+    origin_file_name = numpy_identity.get("origin_file_name")
+    if not isinstance(numpy_version, str) or not numpy_version:
+        raise RegressionError(f"{label} NumPy version is invalid")
+    if (
+        not isinstance(origin_file_name, str)
+        or not origin_file_name
+        or "/" in origin_file_name
+        or "\\" in origin_file_name
+    ):
+        raise RegressionError(f"{label} NumPy origin must be path-free")
+    origin_size = numpy_identity.get("origin_size_bytes")
+    if (
+        isinstance(origin_size, bool)
+        or not isinstance(origin_size, int)
+        or origin_size <= 0
+    ):
+        raise RegressionError(f"{label} NumPy origin size is invalid")
+    _validated_sha256(
+        numpy_identity.get("origin_sha256"),
+        label=f"{label} NumPy origin_sha256",
+    )
+
+    sqrt_s_hex = _validated_canonical_float_hex(
+        value.get("sqrt_s_f64_hex"),
+        label=f"{label} sqrt_s_f64_hex",
+        positive=True,
+    )
+    sqrt_s = float.fromhex(sqrt_s_hex)
+    external_mass_hex = value.get("external_mass_f64_hex")
+    final_mass_hex = value.get("final_state_mass_f64_hex")
+    if (
+        not isinstance(external_mass_hex, Sequence)
+        or isinstance(external_mass_hex, (str, bytes))
+        or len(external_mass_hex) != len(source_pdgs)
+        or not isinstance(final_mass_hex, Sequence)
+        or isinstance(final_mass_hex, (str, bytes))
+        or len(final_mass_hex) != len(source_pdgs) - 2
+    ):
+        raise RegressionError(f"{label} mass vectors have invalid lengths")
+    validated_external_masses = [
+        _validated_canonical_float_hex(
+            mass,
+            label=f"{label} external mass {index}",
+            positive=False,
+        )
+        for index, mass in enumerate(external_mass_hex)
+    ]
+    validated_final_masses = [
+        _validated_canonical_float_hex(
+            mass,
+            label=f"{label} final-state mass {index}",
+            positive=False,
+        )
+        for index, mass in enumerate(final_mass_hex)
+    ]
+    if validated_final_masses != validated_external_masses[2:]:
+        raise RegressionError(f"{label} final-state masses are inconsistent")
+    if math.fsum(float.fromhex(mass) for mass in validated_final_masses) >= sqrt_s:
+        raise RegressionError(f"{label} final-state masses are not below threshold")
+
+    _require_equal(
+        value,
+        "seed_start",
+        CORRECTNESS_SEED_START,
+        label=f"{label} seed_start",
+    )
+    _require_equal(
+        value,
+        "seed_attempt_limit",
+        MAX_CORRECTNESS_SEED_ATTEMPTS,
+        label=f"{label} seed_attempt_limit",
+    )
+    attempts = value.get("attempt_count")
+    if (
+        isinstance(attempts, bool)
+        or not isinstance(attempts, int)
+        or not VALIDATION_SAMPLE_COUNT <= attempts <= MAX_CORRECTNESS_SEED_ATTEMPTS
+    ):
+        raise RegressionError(f"{label} attempt_count is invalid")
+    selected_seeds = value.get("selected_seeds")
+    if (
+        not isinstance(selected_seeds, Sequence)
+        or isinstance(selected_seeds, (str, bytes))
+        or len(selected_seeds) != VALIDATION_SAMPLE_COUNT
+        or any(
+            isinstance(seed, bool) or not isinstance(seed, int)
+            for seed in selected_seeds
+        )
+        or list(selected_seeds) != sorted(set(selected_seeds))
+        or selected_seeds[0] < CORRECTNESS_SEED_START
+        or selected_seeds[-1] >= CORRECTNESS_SEED_START + MAX_CORRECTNESS_SEED_ATTEMPTS
+        or selected_seeds[-1] != CORRECTNESS_SEED_START + attempts - 1
+    ):
+        raise RegressionError(f"{label} selected_seeds are invalid")
+
+    hashes: dict[str, list[str]] = {}
+    for key in ("point_sha256", "invariant_sha256"):
+        raw_hashes = value.get(key)
+        if (
+            not isinstance(raw_hashes, Sequence)
+            or isinstance(raw_hashes, (str, bytes))
+            or len(raw_hashes) != VALIDATION_SAMPLE_COUNT
+        ):
+            raise RegressionError(f"{label} {key} has the wrong length")
+        validated_hashes = [
+            _validated_sha256(digest, label=f"{label} {key}[{index}]")
+            for index, digest in enumerate(raw_hashes)
+        ]
+        if len(set(validated_hashes)) != VALIDATION_SAMPLE_COUNT:
+            raise RegressionError(f"{label} {key} values are not distinct")
+        hashes[key] = validated_hashes
+    batch_sha256 = _validated_sha256(
+        value.get("batch_sha256"),
+        label=f"{label} batch_sha256",
+    )
+    for numerical_label, numerical in (
+        ("precision-16", precision16),
+        ("precision-32", precision32),
+    ):
+        if numerical is None:
+            continue
+        if numerical.get("point_sha256") != hashes["point_sha256"]:
+            raise RegressionError(
+                f"{label} point hashes differ from {numerical_label} evidence"
+            )
+        if numerical.get("batch_sha256") != batch_sha256:
+            raise RegressionError(
+                f"{label} batch digest differs from {numerical_label} evidence"
+            )
+    derivation_sha256 = _validated_sha256(
+        value.get("sha256"),
+        label=f"{label} sha256",
+    )
+    digest_basis = {key: entry for key, entry in value.items() if key != "sha256"}
+    if _canonical_sha256(digest_basis) != derivation_sha256:
+        raise RegressionError(f"{label} digest does not authenticate its metadata")
+    return {
+        **digest_basis,
+        "sha256": derivation_sha256,
+    }
+
+
+def _native_profile_sample(
+    payload: Mapping[str, Any],
+    *,
+    minimum_samples: int,
+    batch_size: int | None = None,
+    expected_execution_mode: str = "compiled",
+    require_precision32: bool = False,
+    require_arena_profile: bool = False,
+) -> dict[str, Any]:
+    _require_equal(
+        payload,
+        "kind",
+        NATIVE_SAMPLE_RESULT_KIND,
+        label="native sample kind",
+    )
+    _require_equal(
+        payload,
+        "schema_version",
+        NATIVE_SAMPLE_SCHEMA_VERSION,
+        label="native sample schema_version",
+    )
+    environment = payload.get("environment")
+    if not isinstance(environment, Mapping):
+        raise RegressionError("profile result has no environment metadata")
+    source = environment.get("wall_time_source")
+    if source != NATIVE_WALL_TIME_SOURCE:
+        raise RegressionError(
+            f"profile did not use the native Rusticol repeated wall timer: {source!r}"
+        )
+    _require_equal(
+        environment,
+        "wall_time_sample_pass",
+        NATIVE_WALL_TIME_SAMPLE_PASS,
+        label="profile wall_time_sample_pass",
+    )
+    _require_equal(
+        environment,
+        "timing_sample_contract",
+        PAIRED_TIMING_SAMPLE_CONTRACT,
+        label="profile timing_sample_contract",
+    )
+    evaluator_sample_pass = environment.get("evaluator_time_sample_pass")
+    timing_breakdown_sample_pass = environment.get("timing_breakdown_sample_pass")
+    if evaluator_sample_pass != timing_breakdown_sample_pass:
+        raise RegressionError(
+            "profile evaluator and timing-breakdown attribution passes differ"
+        )
+    allowed_profile_passes = (
+        {PROFILE_ATTRIBUTION_SAMPLE_PASS}
+        if require_arena_profile
+        else {
+            PROFILE_ATTRIBUTION_SAMPLE_PASS,
+            FROZEN_BASELINE_PROFILE_ATTRIBUTION_SAMPLE_PASS,
+        }
+    )
+    if evaluator_sample_pass not in allowed_profile_passes:
+        raise RegressionError(
+            "profile attribution did not use the required warmed Arena boundary: "
+            f"{evaluator_sample_pass!r}"
+        )
+    profile_attribution_boundary = environment.get("profile_attribution_boundary")
+    profile_attribution_borrowed_flat_input = environment.get(
+        "profile_attribution_borrowed_flat_input"
+    )
+    profile_attribution_preallocated_output = environment.get(
+        "profile_attribution_preallocated_output"
+    )
+    profile_attribution_phase_timing_scope = environment.get(
+        "profile_attribution_phase_timing_scope"
+    )
+    profile_attribution_evaluator_timing_available = environment.get(
+        "profile_attribution_evaluator_timing_available"
+    )
+    profile_protocol = environment.get("profile_protocol")
+    if evaluator_sample_pass == PROFILE_ATTRIBUTION_SAMPLE_PASS:
+        expected_profile_boundary = ARENA_PROFILE_BOUNDARY
+        expected_borrowed_input = True
+        expected_preallocated_output = True
+        expected_phase_timing_scope = ARENA_PHASE_TIMING_SCOPE
+        expected_evaluator_timing_available = False
+        expected_profile_protocol = ARENA_PROFILE_PROTOCOL
+    else:
+        expected_profile_boundary = FROZEN_BASELINE_PROFILE_BOUNDARY
+        expected_borrowed_input = False
+        expected_preallocated_output = False
+        expected_phase_timing_scope = FROZEN_BASELINE_PHASE_TIMING_SCOPE
+        expected_evaluator_timing_available = True
+        expected_profile_protocol = FROZEN_BASELINE_PROFILE_PROTOCOL
+    if (
+        profile_attribution_boundary != expected_profile_boundary
+        or profile_attribution_borrowed_flat_input is not expected_borrowed_input
+        or profile_attribution_preallocated_output is not expected_preallocated_output
+        or profile_attribution_phase_timing_scope != expected_phase_timing_scope
+        or profile_attribution_evaluator_timing_available
+        is not expected_evaluator_timing_available
+        or profile_protocol != expected_profile_protocol
+    ):
+        raise RegressionError(
+            "profile attribution boundary metadata does not match its sample pass"
+        )
+    for key in (
+        "profile_attribution_paired_with_headline",
+        "profile_attribution_identical_batch",
+        "profile_attribution_identical_repetitions",
+    ):
+        _require_equal(
+            environment,
+            key,
+            True,
+            label=f"profile {key}",
+        )
+    _require_equal(
+        environment,
+        "execution_mode",
+        expected_execution_mode,
+        label="profile execution_mode",
+    )
+    sample_count = payload.get("sample_count")
+    if (
+        isinstance(sample_count, bool)
+        or not isinstance(sample_count, int)
+        or sample_count < minimum_samples
+    ):
+        raise RegressionError(
+            "profile result contains fewer complete timing blocks than requested"
+        )
+    headline_samples = payload.get("wall_time_samples_seconds_per_point")
+    if not isinstance(headline_samples, Sequence) or isinstance(
+        headline_samples,
+        (str, bytes),
+    ):
+        raise RegressionError("native sample has no headline wall sample vector")
+    if len(headline_samples) != sample_count:
+        raise RegressionError(
+            "native headline wall sample vector does not match sample_count"
+        )
+    headline_values = [
+        _finite_positive(value, label="native headline wall sample")
+        for value in headline_samples
+    ]
+    _require_equal(
+        payload,
+        "interrupted",
+        False,
+        label="profile interrupted",
+    )
+    _require_equal(
+        environment,
+        "interrupted",
+        False,
+        label="profile environment interrupted",
+    )
+    repetitions = _positive_mapping_int(
+        payload,
+        "repetitions_per_sample",
+        label="profile repetitions_per_sample",
+    )
+    reported_batch_size = _positive_mapping_int(
+        environment,
+        "batch_size",
+        label="profile environment batch_size",
+    )
+    if batch_size is not None and reported_batch_size != batch_size:
+        raise RegressionError(
+            "profile environment batch_size does not match the requested batch: "
+            f"{reported_batch_size} != {batch_size}"
+        )
+    expected_evaluations = sample_count * repetitions
+    expected_points = expected_evaluations * reported_batch_size
+    expected_points_per_sample = repetitions * reported_batch_size
+    exact_counts = {
+        "completed_sample_count": sample_count,
+        "planned_sample_count": sample_count,
+        "measured_evaluation_count": expected_evaluations,
+        "measured_point_count": expected_points,
+        "native_profile_sample_count": sample_count,
+        "native_profile_sample_limit": sample_count,
+        "native_profile_repetitions_per_sample": repetitions,
+        "native_profile_points_per_sample": expected_points_per_sample,
+        "profile_attribution_evaluation_count": expected_evaluations,
+        "profile_attribution_point_count": expected_points,
+    }
+    for key, expected in exact_counts.items():
+        _require_equal(
+            environment,
+            key,
+            expected,
+            label=f"profile environment {key}",
+        )
+    calls_per_block = _finite_positive(
+        environment.get("native_profile_calls_per_block"),
+        label="profile environment native_profile_calls_per_block",
+    )
+    if calls_per_block != 1.0:
+        raise RegressionError(
+            "profile native attribution must contain exactly one paired call "
+            f"per headline block, got {calls_per_block!r}"
+        )
+    timing_breakdown = payload.get("timing_breakdown")
+    if not isinstance(timing_breakdown, Mapping):
+        raise RegressionError("profile result has no paired native timing breakdown")
+    _require_equal(
+        timing_breakdown,
+        "sample_count",
+        sample_count,
+        label="profile timing breakdown sample_count",
+    )
+    _require_equal(
+        timing_breakdown,
+        "execution_mode",
+        expected_execution_mode,
+        label="profile timing breakdown execution_mode",
+    )
+    profile_wall = timing_breakdown.get("wall_time")
+    if not isinstance(profile_wall, Mapping):
+        raise RegressionError("profile timing breakdown has no profiled wall component")
+    profile_wall_seconds_per_point = _finite_positive(
+        profile_wall.get("mean_seconds_per_point"),
+        label="paired profiled wall mean_seconds_per_point",
+    )
+    profile_evaluator_breakdown = timing_breakdown.get("evaluator_call_time")
+    if expected_evaluator_timing_available:
+        profile_evaluator_seconds_per_point: float | None = _finite_nonnegative(
+            payload.get("evaluator_time_per_point"),
+            label="paired profile evaluator_time_per_point",
+        )
+        if not isinstance(profile_evaluator_breakdown, Mapping):
+            raise RegressionError(
+                "legacy paired profile has no evaluator timing component"
+            )
+        if not isinstance(payload.get("evaluator_uncertainty"), Mapping):
+            raise RegressionError(
+                "legacy paired profile has no evaluator timing uncertainty"
+            )
+    else:
+        if (
+            payload.get("evaluator_time_per_point") is not None
+            or payload.get("evaluator_uncertainty") is not None
+            or profile_evaluator_breakdown is not None
+        ):
+            raise RegressionError(
+                "coarse Arena boundary must record evaluator phase timing "
+                "as unavailable"
+            )
+        profile_evaluator_seconds_per_point = None
+    cold_load_seconds = _finite_nonnegative(
+        payload.get("cold_load_seconds"),
+        label="native cold_load_seconds",
+    )
+    headline_mean = _finite_positive(
+        payload.get("wall_time_per_point"),
+        label="profile wall_time_per_point",
+    )
+    computed_headline_mean = float(statistics.fmean(headline_values))
+    if not math.isclose(
+        headline_mean,
+        computed_headline_mean,
+        rel_tol=1.0e-15,
+        abs_tol=0.0,
+    ):
+        raise RegressionError(
+            "native headline mean does not match its unprofiled sample vector"
+        )
+    raw_profiles = timing_breakdown.get("raw_profile_samples")
+    if not isinstance(raw_profiles, Sequence) or isinstance(raw_profiles, (str, bytes)):
+        raise RegressionError("paired timing breakdown has no raw profile samples")
+    if len(raw_profiles) != sample_count:
+        raise RegressionError(
+            "paired raw profile sample vector does not match sample_count"
+        )
+    if evaluator_sample_pass == PROFILE_ATTRIBUTION_SAMPLE_PASS:
+        for profile_index, raw_profile in enumerate(raw_profiles):
+            if not isinstance(raw_profile, Mapping):
+                raise RegressionError(
+                    f"paired raw Arena profile {profile_index} is invalid"
+                )
+            if (
+                raw_profile.get("profile_boundary") != ARENA_PROFILE_BOUNDARY
+                or raw_profile.get("borrowed_flat_input") is not True
+                or raw_profile.get("preallocated_output") is not True
+                or raw_profile.get("phase_timing_scope") != ARENA_PHASE_TIMING_SCOPE
+                or raw_profile.get("evaluator_timing_available") is not False
+            ):
+                raise RegressionError(
+                    "paired raw Arena profile does not authenticate its "
+                    "borrowed-input, preallocated-output, coarse-timing boundary"
+                )
+    runtime_identity = environment.get("runtime_identity")
+    if not isinstance(runtime_identity, Mapping):
+        raise RegressionError("native sample has no runtime identity")
+    native_module_identity = runtime_identity.get("native_module")
+    if not isinstance(native_module_identity, Mapping):
+        raise RegressionError("native sample has no native module identity")
+    native_module_sha256 = native_module_identity.get("sha256")
+    if (
+        not isinstance(native_module_sha256, str)
+        or re.fullmatch(r"[0-9a-f]{64}", native_module_sha256) is None
+    ):
+        raise RegressionError("native sample has an invalid native module SHA-256")
+    batch_sha256 = environment.get("batch_sha256")
+    if (
+        not isinstance(batch_sha256, str)
+        or re.fullmatch(r"[0-9a-f]{64}", batch_sha256) is None
+    ):
+        raise RegressionError("native sample has an invalid batch SHA-256")
+    helicities = environment.get("helicities")
+    color_flows = environment.get("color_flows")
+    if (
+        not isinstance(helicities, Sequence)
+        or isinstance(helicities, (str, bytes))
+        or not all(isinstance(value, str) for value in helicities)
+    ):
+        raise RegressionError("native sample has invalid helicity selectors")
+    if (
+        not isinstance(color_flows, Sequence)
+        or isinstance(color_flows, (str, bytes))
+        or not all(isinstance(value, str) for value in color_flows)
+    ):
+        raise RegressionError("native sample has invalid color-flow selectors")
+    warmed_numerical_result = _validated_numerical_result(
+        payload.get("warmed_numerical_result"),
+        precision=16,
+        helicities=helicities,
+        color_flows=color_flows,
+        required=True,
+    )
+    assert warmed_numerical_result is not None
+    precision32_numerical_result = _validated_numerical_result(
+        payload.get("precision32_numerical_result"),
+        precision=32,
+        helicities=helicities,
+        color_flows=color_flows,
+        required=require_precision32,
+    )
+    correctness_point_derivation = _validated_correctness_point_derivation(
+        payload.get("correctness_point_derivation"),
+        precision16=warmed_numerical_result,
+        precision32=precision32_numerical_result,
+    )
+    return {
+        "wall_seconds_per_point": headline_mean,
+        "wall_samples_seconds_per_point": headline_values,
+        "native_wall_time_source": source,
+        "native_wall_time_sample_pass": NATIVE_WALL_TIME_SAMPLE_PASS,
+        "profile_attribution_sample_pass": evaluator_sample_pass,
+        "profile_attribution_boundary": profile_attribution_boundary,
+        "profile_attribution_borrowed_flat_input": (
+            profile_attribution_borrowed_flat_input
+        ),
+        "profile_attribution_preallocated_output": (
+            profile_attribution_preallocated_output
+        ),
+        "profile_attribution_phase_timing_scope": (
+            profile_attribution_phase_timing_scope
+        ),
+        "profile_attribution_evaluator_timing_available": (
+            profile_attribution_evaluator_timing_available
+        ),
+        "profile_protocol": profile_protocol,
+        "timing_sample_contract": PAIRED_TIMING_SAMPLE_CONTRACT,
+        "profile_timed_block_count": sample_count,
+        "repetitions_per_timed_block": repetitions,
+        "batch_size": reported_batch_size,
+        "measured_evaluation_count": expected_evaluations,
+        "measured_point_count": expected_points,
+        "native_elapsed_seconds": environment.get("elapsed_seconds"),
+        "cold_load_seconds": cold_load_seconds,
+        "profile_uncertainty": payload.get("uncertainty"),
+        "paired_profile_wall_seconds_per_point": (profile_wall_seconds_per_point),
+        "paired_profile_evaluator_seconds_per_point": (
+            profile_evaluator_seconds_per_point
+        ),
+        "paired_profile_evaluator_uncertainty": payload.get("evaluator_uncertainty"),
+        "paired_profile_timing_breakdown": timing_breakdown,
+        "runtime_identity": runtime_identity,
+        "native_module_sha256": native_module_sha256,
+        "batch_sha256": batch_sha256,
+        "helicities": list(helicities),
+        "color_flows": list(color_flows),
+        "correctness_point_derivation": correctness_point_derivation,
+        "warmed_numerical_result": warmed_numerical_result,
+        "precision32_numerical_result": precision32_numerical_result,
+    }
+
+
+def _distribution(samples: Sequence[float]) -> dict[str, Any]:
+    if not samples:
+        raise RegressionError("timing distribution must contain samples")
+    values = tuple(_finite_positive(value, label="timing sample") for value in samples)
+    median = float(statistics.median(values))
+    mad = float(statistics.median(abs(value - median) for value in values))
+    return {
+        "sample_count": len(values),
+        "samples_seconds_per_point": list(values),
+        "median_seconds_per_point": median,
+        "mad_seconds_per_point": mad,
+        "minimum_seconds_per_point": min(values),
+        "maximum_seconds_per_point": max(values),
+    }
+
+
+def _regression_gate(
+    baseline: Mapping[str, Any],
+    current: Mapping[str, Any],
+) -> dict[str, Any]:
+    baseline_median = _finite_positive(
+        baseline.get("median_seconds_per_point"),
+        label="baseline median",
+    )
+    current_median = _finite_positive(
+        current.get("median_seconds_per_point"),
+        label="current median",
+    )
+    raw_mad = baseline.get("mad_seconds_per_point")
+    if isinstance(raw_mad, bool) or not isinstance(raw_mad, (float, int)):
+        raise RegressionError("baseline MAD must be numeric")
+    baseline_mad = float(raw_mad)
+    if not math.isfinite(baseline_mad) or baseline_mad < 0.0:
+        raise RegressionError("baseline MAD must be finite and non-negative")
+    relative_limit = baseline_median * (1.0 + RELATIVE_TOLERANCE)
+    mad_limit = baseline_median + MAD_MULTIPLIER * baseline_mad
+    within_relative = current_median <= relative_limit
+    within_mad = current_median <= mad_limit
+    return {
+        "relative_tolerance": RELATIVE_TOLERANCE,
+        "mad_multiplier": MAD_MULTIPLIER,
+        "baseline_median_seconds_per_point": baseline_median,
+        "baseline_mad_seconds_per_point": baseline_mad,
+        "current_median_seconds_per_point": current_median,
+        "current_over_baseline": current_median / baseline_median,
+        "relative_change": (current_median - baseline_median) / baseline_median,
+        "three_percent_upper_bound_seconds_per_point": relative_limit,
+        "three_baseline_mad_upper_bound_seconds_per_point": mad_limit,
+        "within_three_percent": within_relative,
+        "within_three_baseline_mad": within_mad,
+        "passes": within_relative and within_mad,
+    }
+
+
+def _paired_distribution(
+    measurements: Sequence[Mapping[str, Any]],
+) -> dict[str, Any]:
+    pairs: dict[int, dict[str, float]] = {}
+    for measurement in measurements:
+        pair_index = measurement.get("pair_index")
+        lane = measurement.get("lane")
+        if (
+            isinstance(pair_index, bool)
+            or not isinstance(pair_index, int)
+            or lane not in {"baseline", "current"}
+        ):
+            raise RegressionError("timing measurement has an invalid pair identity")
+        pairs.setdefault(pair_index, {})[str(lane)] = _finite_positive(
+            measurement.get("wall_seconds_per_point"),
+            label="paired wall time",
+        )
+    if not pairs or any(
+        set(pair) != {"baseline", "current"} for pair in pairs.values()
+    ):
+        raise RegressionError("timing measurements do not form complete lane pairs")
+    differences = [
+        pair["baseline"] - pair["current"] for _, pair in sorted(pairs.items())
+    ]
+    ratios = [pair["current"] / pair["baseline"] for _, pair in sorted(pairs.items())]
+    difference_median = float(statistics.median(differences))
+    difference_mad = float(
+        statistics.median(abs(value - difference_median) for value in differences)
+    )
+    return {
+        "pair_count": len(pairs),
+        "differences_seconds_per_point": differences,
+        "difference_median_seconds_per_point": difference_median,
+        "difference_mad_seconds_per_point": difference_mad,
+        "current_over_baseline_ratios": ratios,
+        "median_current_over_baseline": float(statistics.median(ratios)),
+    }
+
+
+def _gain_gate(
+    baseline: Mapping[str, Any],
+    current: Mapping[str, Any],
+    paired: Mapping[str, Any],
+) -> dict[str, Any]:
+    baseline_median = _finite_positive(
+        baseline.get("median_seconds_per_point"),
+        label="baseline median",
+    )
+    current_median = _finite_positive(
+        current.get("median_seconds_per_point"),
+        label="current median",
+    )
+    baseline_mad = _finite_nonnegative(
+        baseline.get("mad_seconds_per_point"),
+        label="baseline MAD",
+    )
+    paired_difference_median = _finite_number(
+        paired.get("difference_median_seconds_per_point"),
+        label="paired difference median",
+    )
+    paired_difference_mad = _finite_nonnegative(
+        paired.get("difference_mad_seconds_per_point"),
+        label="paired difference MAD",
+    )
+    relative_gain = 1.0 - current_median / baseline_median
+    noise_floor = MAD_MULTIPLIER * max(baseline_mad, paired_difference_mad)
+    beyond_noise = (
+        baseline_median - current_median >= noise_floor
+        and paired_difference_median >= MAD_MULTIPLIER * paired_difference_mad
+    )
+    return {
+        "required_relative_gain": GAIN_RELATIVE_THRESHOLD,
+        "relative_gain": relative_gain,
+        "baseline_minus_current_seconds_per_point": baseline_median - current_median,
+        "noise_floor_seconds_per_point": noise_floor,
+        "paired_difference_median_seconds_per_point": paired_difference_median,
+        "paired_difference_mad_seconds_per_point": paired_difference_mad,
+        "at_least_ten_percent": relative_gain >= GAIN_RELATIVE_THRESHOLD,
+        "beyond_measurement_noise": beyond_noise,
+        "passes": relative_gain >= GAIN_RELATIVE_THRESHOLD and beyond_noise,
+    }
+
+
+def _performance_payload_identity(
+    artifact: Mapping[str, Any],
+) -> dict[str, Any] | None:
+    payloads = artifact.get("payload_digests")
+    if not isinstance(payloads, Sequence) or isinstance(payloads, (str, bytes)):
+        return None
+    relevant: list[dict[str, object]] = []
+    observed_roles: set[str] = set()
+    for payload in payloads:
+        if not isinstance(payload, Mapping):
+            return None
+        role = payload.get("role")
+        if role not in PERFORMANCE_RELEVANT_PAYLOAD_ROLES:
+            continue
+        path = payload.get("path")
+        sha256 = payload.get("sha256")
+        size_bytes = payload.get("size_bytes")
+        if (
+            not isinstance(role, str)
+            or not isinstance(path, str)
+            or not isinstance(sha256, str)
+            or re.fullmatch(r"[0-9a-f]{64}", sha256) is None
+            or isinstance(size_bytes, bool)
+            or not isinstance(size_bytes, int)
+            or size_bytes < 0
+        ):
+            return None
+        observed_roles.add(role)
+        relevant.append(
+            {
+                "path": path,
+                "role": role,
+                "process_id": payload.get("process_id"),
+                "sha256": sha256,
+                "size_bytes": size_bytes,
+            }
+        )
+    if not REQUIRED_PERFORMANCE_PAYLOAD_ROLES.issubset(observed_roles):
+        return None
+    relevant.sort(key=lambda value: (str(value["role"]), str(value["path"])))
+    identity_basis = {
+        "process_id": artifact.get("process_id"),
+        "color_accuracy": artifact.get("color_accuracy"),
+        "lc_flow_layout": artifact.get("lc_flow_layout"),
+        "payloads": relevant,
+    }
+    return {
+        "algorithm": "sha256-performance-relevant-artifact-payloads-v1",
+        "sha256": _canonical_sha256(identity_basis),
+        "roles": sorted(observed_roles),
+        "payload_count": len(relevant),
+        "identity_basis": identity_basis,
+    }
+
+
+def _performance_authority(
+    artifacts: Mapping[str, Mapping[str, Any]],
+    *,
+    shared_artifact: bool,
+) -> dict[str, Any]:
+    if shared_artifact:
+        return {
+            "authoritative": True,
+            "basis": "single-read-only-shared-artifact",
+            "comparison_mode": "shared-artifact",
+            "payload_identities": None,
+            "semantic_identities": None,
+        }
+    semantic_identities = {
+        lane: artifact.get("semantic_workload_identity")
+        for lane, artifact in artifacts.items()
+    }
+    if all(
+        isinstance(identity, Mapping) and isinstance(identity.get("sha256"), str)
+        for identity in semantic_identities.values()
+    ):
+        semantic_digests = {
+            str(identity["sha256"])
+            for identity in semantic_identities.values()
+            if isinstance(identity, Mapping)
+        }
+        if len(semantic_digests) == 1:
+            return {
+                "authoritative": True,
+                "basis": "matching-abi-neutral-semantic-workload-identities",
+                "comparison_mode": "independently-generated-artifacts",
+                "payload_identities": None,
+                "semantic_identities": semantic_identities,
+            }
+    identities = {
+        lane: _performance_payload_identity(artifact)
+        for lane, artifact in artifacts.items()
+    }
+    if any(identity is None for identity in identities.values()):
+        return {
+            "authoritative": False,
+            "basis": "per-lane-artifact-performance-payload-identity-unproven",
+            "comparison_mode": "independently-generated-artifacts",
+            "payload_identities": identities,
+            "semantic_identities": semantic_identities,
+        }
+    digests = {
+        str(identity["sha256"])
+        for identity in identities.values()
+        if identity is not None
+    }
+    matches = len(digests) == 1
+    return {
+        "authoritative": matches,
+        "basis": (
+            "matching-performance-relevant-payload-identities"
+            if matches
+            else "per-lane-artifact-performance-payload-identities-differ"
+        ),
+        "comparison_mode": "independently-generated-artifacts",
+        "payload_identities": identities,
+        "semantic_identities": semantic_identities,
+    }
+
+
+def _numerical_comparison(
+    expected: Mapping[str, Any],
+    observed: Mapping[str, Any],
+    *,
+    kind: str,
+    lane: object,
+    pair_index: object,
+) -> dict[str, Any]:
+    for key in (
+        "point_count",
+        "distinct_point_count",
+        "point_sha256",
+        "batch_sha256",
+        "helicities",
+        "color_flows",
+    ):
+        if observed.get(key) != expected.get(key):
+            raise RegressionError(
+                f"{kind} numerical results do not share identical inputs: {key} differs"
+            )
+    expected_resolved = expected.get("resolved")
+    observed_resolved = observed.get("resolved")
+    if not isinstance(expected_resolved, Mapping) or not isinstance(
+        observed_resolved,
+        Mapping,
+    ):
+        raise RegressionError(f"{kind} numerical result has no resolved evidence")
+    for key in ("shape", "helicity_ids", "color_ids"):
+        if observed_resolved.get(key) != expected_resolved.get(key):
+            raise RegressionError(f"{kind} resolved evidence differs in {key}")
+    expected_values = expected.get("values_f64")
+    observed_values = observed.get("values_f64")
+    if (
+        not isinstance(expected_values, Sequence)
+        or isinstance(expected_values, (str, bytes))
+        or not isinstance(observed_values, Sequence)
+        or isinstance(observed_values, (str, bytes))
+        or len(expected_values) != len(observed_values)
+    ):
+        raise RegressionError(f"{kind} numerical scalar shape differs")
+    vector_groups = (
+        (
+            [(float(value), 0.0) for value in expected_values],
+            [(float(value), 0.0) for value in observed_values],
+        ),
+        (
+            _flatten_complex_tree(expected_resolved.get("totals_complex")),
+            _flatten_complex_tree(observed_resolved.get("totals_complex")),
+        ),
+        (
+            _flatten_complex_tree(expected_resolved.get("values_complex")),
+            _flatten_complex_tree(observed_resolved.get("values_complex")),
+        ),
+    )
+    passes = True
+    maximum_absolute = 0.0
+    maximum_relative = 0.0
+    for expected_vector, observed_vector in vector_groups:
+        if len(expected_vector) != len(observed_vector):
+            raise RegressionError(f"{kind} numerical evidence shape differs")
+        for expected_pair, observed_pair in zip(
+            expected_vector,
+            observed_vector,
+            strict=True,
+        ):
+            for expected_component, observed_component in zip(
+                expected_pair,
+                observed_pair,
+                strict=True,
+            ):
+                expected_number = _finite_number(
+                    expected_component,
+                    label=f"{kind} expected numerical component",
+                )
+                observed_number = _finite_number(
+                    observed_component,
+                    label=f"{kind} observed numerical component",
+                )
+                absolute_error = abs(observed_number - expected_number)
+                relative_error = absolute_error / max(
+                    abs(expected_number),
+                    CORRECTNESS_ABSOLUTE_TOLERANCE,
+                )
+                maximum_absolute = max(maximum_absolute, absolute_error)
+                maximum_relative = max(maximum_relative, relative_error)
+                passes &= math.isclose(
+                    observed_number,
+                    expected_number,
+                    rel_tol=CORRECTNESS_RELATIVE_TOLERANCE,
+                    abs_tol=CORRECTNESS_ABSOLUTE_TOLERANCE,
+                )
+    return {
+        "kind": kind,
+        "lane": lane,
+        "pair_index": pair_index,
+        "passes": passes,
+        "maximum_absolute_error": maximum_absolute,
+        "maximum_relative_error": maximum_relative,
+    }
+
+
+def _correctness_gate(
+    measurements: Sequence[Mapping[str, Any]],
+) -> dict[str, Any]:
+    baseline_reference = next(
+        (
+            measurement
+            for measurement in measurements
+            if measurement.get("lane") == "baseline"
+        ),
+        None,
+    )
+    if baseline_reference is None:
+        raise RegressionError("correctness comparison has no baseline measurement")
+    reference16 = baseline_reference.get("warmed_numerical_result")
+    if not isinstance(reference16, Mapping):
+        raise RegressionError("baseline measurement has no warmed numerical result")
+    reference_derivation = baseline_reference.get("correctness_point_derivation")
+    if not isinstance(reference_derivation, Mapping):
+        raise RegressionError(
+            "baseline measurement has no correctness point derivation"
+        )
+    comparisons: list[dict[str, Any]] = []
+    for measurement in measurements:
+        if measurement.get("correctness_point_derivation") != reference_derivation:
+            raise RegressionError(
+                "correctness measurements do not share a byte-identical "
+                "point derivation"
+            )
+        candidate16 = measurement.get("warmed_numerical_result")
+        if not isinstance(candidate16, Mapping):
+            raise RegressionError("measurement has no warmed numerical result")
+        comparisons.append(
+            _numerical_comparison(
+                reference16,
+                candidate16,
+                kind="precision16-cross-lane",
+                lane=measurement.get("lane"),
+                pair_index=measurement.get("pair_index"),
+            )
+        )
+    precision32_measurements = [
+        measurement
+        for measurement in measurements
+        if isinstance(measurement.get("precision32_numerical_result"), Mapping)
+    ]
+    if (
+        len(precision32_measurements) != 1
+        or precision32_measurements[0].get("lane") != "current"
+        or precision32_measurements[0].get("pair_index") != 1
+    ):
+        raise RegressionError(
+            "correctness comparison requires exactly one precision-32 "
+            "exact-oracle result from current pair 1 and none from baseline"
+        )
+    current32_measurement = precision32_measurements[0]
+    reference32 = current32_measurement["precision32_numerical_result"]
+    assert isinstance(reference32, Mapping)
+    direct_oracle_comparison_count = 0
+    for measurement in measurements:
+        candidate16 = measurement.get("warmed_numerical_result")
+        if not isinstance(candidate16, Mapping):
+            raise RegressionError("measurement has no warmed numerical result")
+        comparisons.append(
+            _numerical_comparison(
+                reference32,
+                candidate16,
+                kind="precision16-vs-current-exact-precision32",
+                lane=measurement.get("lane"),
+                pair_index=measurement.get("pair_index"),
+            )
+        )
+        direct_oracle_comparison_count += 1
+    return {
+        "relative_tolerance": CORRECTNESS_RELATIVE_TOLERANCE,
+        "absolute_tolerance": CORRECTNESS_ABSOLUTE_TOLERANCE,
+        "reference_lane": "baseline",
+        "reference_pair_index": baseline_reference.get("pair_index"),
+        "point_derivation_sha256": reference_derivation.get("sha256"),
+        "correctness_batch_sha256": reference_derivation.get("batch_sha256"),
+        "precision32_lane_count": 1,
+        "precision32_measurement_count": 1,
+        "precision32_policy": PRECISION32_CORRECTNESS_POLICY,
+        "precision32_authority_basis": (
+            "final-candidate-current-exact-oracle-directly-validates-every-"
+            "f64-measurement"
+        ),
+        "precision32_reference_lane": "current",
+        "precision32_reference_pair_index": current32_measurement.get("pair_index"),
+        "precision32_direct_oracle_scope": "every-f64-measurement",
+        "precision32_direct_oracle_comparison_count": (direct_oracle_comparison_count),
+        "comparison_count": len(comparisons),
+        "maximum_absolute_error": max(
+            (float(comparison["maximum_absolute_error"]) for comparison in comparisons),
+            default=0.0,
+        ),
+        "maximum_relative_error": max(
+            (float(comparison["maximum_relative_error"]) for comparison in comparisons),
+            default=0.0,
+        ),
+        "comparisons": comparisons,
+        "passes": all(bool(comparison["passes"]) for comparison in comparisons),
+    }
+
+
+_ZERO_ARENA_PROFILE_COUNTERS = (
+    "native_input_container_allocation_count",
+    "stage_input_copy_component_count",
+    "stage_leaf_input_copy_component_count",
+    "stage_evaluator_output_gather_component_count",
+    "stage_output_assign_component_count",
+    "amplitude_input_copy_component_count",
+    "amplitude_leaf_input_copy_component_count",
+    "amplitude_evaluator_output_gather_component_count",
+    "amplitude_output_remap_component_count",
+    "selector_gather_point_count",
+    "selector_gather_bytes",
+    "selector_scatter_value_count",
+    "observed_scratch_reallocation_count",
+    "native_output_allocation_count",
+)
+_ZERO_COMPILED_BOUNDARY_COUNTERS = (
+    "compiled_direct_arena_boundary_input_bytes",
+    "compiled_direct_arena_boundary_current_output_bytes",
+    "compiled_direct_arena_boundary_amplitude_output_bytes",
+)
+_ZERO_ARENA_PROFILE_TIMES = (
+    "native_input_pack_time_s",
+    "native_input_crossing_time_s",
+    "state_prepare_time_s",
+    "state_clear_time_s",
+    "source_fill_time_s",
+    "momentum_input_setup_time_s",
+    "momentum_setup_time_s",
+    "model_parameter_setup_time_s",
+    "stage_input_pack_time_s",
+    "stage_leaf_input_pack_time_s",
+    "stage_evaluator_call_time_s",
+    "stage_evaluator_time_s",
+    "stage_backend_call_time_s",
+    "stage_evaluator_output_gather_time_s",
+    "output_assign_time_s",
+    "amplitude_input_pack_time_s",
+    "amplitude_leaf_input_pack_time_s",
+    "amplitude_evaluator_call_time_s",
+    "amplitude_backend_call_time_s",
+    "amplitude_evaluator_output_gather_time_s",
+    "amplitude_output_remap_time_s",
+    "amplitude_evaluator_time_s",
+    "reduction_time_s",
+    "resolved_reduction_materialization_inclusive_time_s",
+    "total_materialization_time_s",
+    "final_output_copy_time_s",
+    "eager_initialize_time_s",
+    "eager_gather_time_s",
+    "eager_kernel_call_time_s",
+    "eager_invocation_scatter_time_s",
+    "eager_finalization_time_s",
+    "eager_scatter_finalization_time_s",
+    "eager_closure_time_s",
+    "eager_reduction_time_s",
+    "eager_copy_out_time_s",
+    "recurrence_momentum_fill_time_s",
+    "recurrence_union_source_fill_time_s",
+    "recurrence_schedule_time_s",
+    "recurrence_source_kernel_time_s",
+    "recurrence_contribution_kernel_time_s",
+    "recurrence_finalization_time_s",
+    "recurrence_closure_time_s",
+    "recurrence_replay_output_mapping_time_s",
+    "selector_planner_time_s",
+    "selector_gather_time_s",
+    "selector_scatter_time_s",
+)
+_EMPTY_ARENA_PROFILE_PHASE_VECTORS = (
+    "stage_input_pack_by_stage_time_s",
+    "stage_leaf_input_pack_by_stage_time_s",
+    "stage_evaluator_call_by_stage_time_s",
+    "stage_backend_call_by_stage_time_s",
+    "stage_evaluator_output_gather_by_stage_time_s",
+    "stage_output_assign_by_stage_time_s",
+)
+
+
+def _arena_profile_gate(
+    measurements: Sequence[Mapping[str, Any]],
+    *,
+    execution_mode: str,
+    artifacts: Mapping[str, Mapping[str, Any]],
+    minimum_profile_timed_blocks: int = 1,
+) -> dict[str, Any]:
+    if minimum_profile_timed_blocks <= 0:
+        raise RegressionError("minimum Arena profile timed blocks must be positive")
+    failures: list[dict[str, object]] = []
+    expected_capability = (
+        EAGER_DIRECT_ARENA_CAPABILITY
+        if execution_mode == "eager"
+        else COMPILED_DIRECT_ARENA_CAPABILITY
+    )
+    current_artifact = artifacts.get("current")
+    capabilities = (
+        current_artifact.get("required_runtime_capabilities")
+        if isinstance(current_artifact, Mapping)
+        else None
+    )
+    if (
+        not isinstance(capabilities, Sequence)
+        or isinstance(capabilities, (str, bytes))
+        or expected_capability not in capabilities
+    ):
+        failures.append(
+            {
+                "artifact": "current",
+                "counter": "required_runtime_capabilities",
+                "observed": capabilities,
+                "expected": expected_capability,
+            }
+        )
+    profile_count = 0
+    for measurement in measurements:
+        if measurement.get("lane") != "current":
+            continue
+        for key, expected in (
+            ("profile_attribution_sample_pass", PROFILE_ATTRIBUTION_SAMPLE_PASS),
+            ("profile_attribution_boundary", ARENA_PROFILE_BOUNDARY),
+            ("profile_attribution_borrowed_flat_input", True),
+            ("profile_attribution_preallocated_output", True),
+            ("profile_attribution_phase_timing_scope", ARENA_PHASE_TIMING_SCOPE),
+            ("profile_attribution_evaluator_timing_available", False),
+            ("profile_protocol", ARENA_PROFILE_PROTOCOL),
+            ("paired_profile_evaluator_seconds_per_point", None),
+            ("paired_profile_evaluator_uncertainty", None),
+        ):
+            if measurement.get(key) != expected:
+                failures.append(
+                    {
+                        "pair_index": measurement.get("pair_index"),
+                        "counter": key,
+                        "observed": measurement.get(key),
+                        "expected": expected,
+                    }
+                )
+        breakdown = measurement.get("paired_profile_timing_breakdown")
+        profile_timed_block_count = measurement.get("profile_timed_block_count")
+        if (
+            isinstance(profile_timed_block_count, bool)
+            or not isinstance(profile_timed_block_count, int)
+            or profile_timed_block_count < minimum_profile_timed_blocks
+        ):
+            failures.append(
+                {
+                    "pair_index": measurement.get("pair_index"),
+                    "counter": "profile_timed_block_count",
+                    "observed": profile_timed_block_count,
+                    "expected": f"integer >= {minimum_profile_timed_blocks}",
+                }
+            )
+        if (
+            not isinstance(breakdown, Mapping)
+            or "evaluator_call_time" not in breakdown
+            or breakdown.get("evaluator_call_time") is not None
+        ):
+            failures.append(
+                {
+                    "pair_index": measurement.get("pair_index"),
+                    "counter": ("paired_profile_timing_breakdown.evaluator_call_time"),
+                    "observed": (
+                        breakdown.get("evaluator_call_time")
+                        if isinstance(breakdown, Mapping)
+                        else breakdown
+                    ),
+                    "expected": None,
+                }
+            )
+        raw_profiles = (
+            breakdown.get("raw_profile_samples")
+            if isinstance(breakdown, Mapping)
+            else None
+        )
+        if not isinstance(raw_profiles, Sequence) or isinstance(
+            raw_profiles,
+            (str, bytes),
+        ):
+            raise RegressionError("current measurement has no raw arena profiles")
+        if (
+            isinstance(profile_timed_block_count, int)
+            and not isinstance(profile_timed_block_count, bool)
+            and (
+                breakdown.get("sample_count") != profile_timed_block_count
+                or len(raw_profiles) != profile_timed_block_count
+            )
+        ):
+            failures.append(
+                {
+                    "pair_index": measurement.get("pair_index"),
+                    "counter": "paired_profile_timed_block_coverage",
+                    "observed": {
+                        "measurement": profile_timed_block_count,
+                        "breakdown": breakdown.get("sample_count"),
+                        "raw_profiles": len(raw_profiles),
+                    },
+                    "expected": "equal positive counts",
+                }
+            )
+        for profile_index, profile in enumerate(raw_profiles):
+            if not isinstance(profile, Mapping):
+                raise RegressionError("current raw arena profile is invalid")
+            profile_count += 1
+            if profile.get("execution_mode") != execution_mode:
+                failures.append(
+                    {
+                        "pair_index": measurement.get("pair_index"),
+                        "profile_index": profile_index,
+                        "counter": "execution_mode",
+                        "observed": profile.get("execution_mode"),
+                        "expected": execution_mode,
+                    }
+                )
+            for key, expected in (
+                ("profile_boundary", ARENA_PROFILE_BOUNDARY),
+                ("borrowed_flat_input", True),
+                ("preallocated_output", True),
+                ("phase_timing_scope", ARENA_PHASE_TIMING_SCOPE),
+                ("evaluator_timing_available", False),
+            ):
+                if profile.get(key) != expected:
+                    failures.append(
+                        {
+                            "pair_index": measurement.get("pair_index"),
+                            "profile_index": profile_index,
+                            "counter": key,
+                            "observed": profile.get(key),
+                            "expected": expected,
+                        }
+                    )
+            required_zero = list(_ZERO_ARENA_PROFILE_COUNTERS)
+            if execution_mode == "compiled":
+                required_zero.extend(_ZERO_COMPILED_BOUNDARY_COUNTERS)
+            for key in required_zero:
+                value = profile.get(key)
+                if isinstance(value, bool) or not isinstance(value, int) or value != 0:
+                    failures.append(
+                        {
+                            "pair_index": measurement.get("pair_index"),
+                            "profile_index": profile_index,
+                            "counter": key,
+                            "observed": value,
+                            "expected": 0,
+                        }
+                    )
+            for key in _ZERO_ARENA_PROFILE_TIMES:
+                value = profile.get(key)
+                if (
+                    isinstance(value, bool)
+                    or not isinstance(value, (float, int))
+                    or not math.isfinite(float(value))
+                    or float(value) != 0.0
+                ):
+                    failures.append(
+                        {
+                            "pair_index": measurement.get("pair_index"),
+                            "profile_index": profile_index,
+                            "counter": key,
+                            "observed": value,
+                            "expected": 0.0,
+                        }
+                    )
+            for key in _EMPTY_ARENA_PROFILE_PHASE_VECTORS:
+                value = profile.get(key)
+                if value != []:
+                    failures.append(
+                        {
+                            "pair_index": measurement.get("pair_index"),
+                            "profile_index": profile_index,
+                            "counter": key,
+                            "observed": value,
+                            "expected": [],
+                        }
+                    )
+            wall_time = profile.get("wall_time_s")
+            orchestration_time = profile.get("orchestration_time_s")
+            if (
+                isinstance(wall_time, bool)
+                or not isinstance(wall_time, (float, int))
+                or not math.isfinite(float(wall_time))
+                or float(wall_time) <= 0.0
+                or orchestration_time != wall_time
+            ):
+                failures.append(
+                    {
+                        "pair_index": measurement.get("pair_index"),
+                        "profile_index": profile_index,
+                        "counter": "coarse_arena_boundary_wall_accounting",
+                        "observed": {
+                            "wall_time_s": wall_time,
+                            "orchestration_time_s": orchestration_time,
+                        },
+                        "expected": "equal finite positive values",
+                    }
+                )
+            if execution_mode == "compiled":
+                engine_count = profile.get("compiled_direct_arena_engine_count")
+                call_count = profile.get("compiled_direct_arena_call_count")
+                backend_call_count = profile.get("evaluator_backend_call_count")
+                for key, value in (
+                    ("compiled_direct_arena_engine_count", engine_count),
+                    ("compiled_direct_arena_call_count", call_count),
+                    ("evaluator_backend_call_count", backend_call_count),
+                ):
+                    if (
+                        isinstance(value, bool)
+                        or not isinstance(value, int)
+                        or value <= 0
+                    ):
+                        failures.append(
+                            {
+                                "pair_index": measurement.get("pair_index"),
+                                "profile_index": profile_index,
+                                "counter": key,
+                                "observed": value,
+                                "expected": "positive integer",
+                            }
+                        )
+                if call_count != backend_call_count:
+                    failures.append(
+                        {
+                            "pair_index": measurement.get("pair_index"),
+                            "profile_index": profile_index,
+                            "counter": "compiled_direct_arena_call_coverage",
+                            "observed": {
+                                "compiled": call_count,
+                                "backend": backend_call_count,
+                            },
+                            "expected": "equal",
+                        }
+                    )
+    return {
+        "execution_mode": execution_mode,
+        "required_current_artifact_capability": expected_capability,
+        "current_artifact_capabilities": capabilities,
+        "profile_count": profile_count,
+        "minimum_profile_timed_blocks": minimum_profile_timed_blocks,
+        "zero_counters": list(_ZERO_ARENA_PROFILE_COUNTERS),
+        "zero_compiled_boundary_counters": (
+            list(_ZERO_COMPILED_BOUNDARY_COUNTERS)
+            if execution_mode == "compiled"
+            else []
+        ),
+        "zero_non_orchestration_phase_times": list(_ZERO_ARENA_PROFILE_TIMES),
+        "failures": failures,
+        "passes": profile_count > 0 and not failures,
+    }
+
+
+def _resource_summary(
+    artifacts: Mapping[str, Mapping[str, Any]],
+    measurements: Sequence[Mapping[str, Any]],
+    *,
+    elapsed_seconds: float,
+) -> dict[str, Any]:
+    peaks: list[float] = []
+    for artifact in artifacts.values():
+        generation = artifact.get("generation")
+        if isinstance(generation, Mapping):
+            peak = generation.get("peak_rss_gib")
+            if isinstance(peak, (float, int)) and not isinstance(peak, bool):
+                peaks.append(float(peak))
+    for measurement in measurements:
+        peak = measurement.get("peak_rss_gib")
+        if isinstance(peak, (float, int)) and not isinstance(peak, bool):
+            peaks.append(float(peak))
+    return {
+        "memory_limit_gib": MEMORY_LIMIT_GIB,
+        "maximum_observed_peak_rss_gib": max(peaks, default=None),
+        "generation_subprocess_count": sum(
+            not bool(artifact.get("reused")) for artifact in artifacts.values()
+        ),
+        "sample_subprocess_count": len(measurements),
+        "profile_subprocess_count": len(measurements),
+        "elapsed_seconds": elapsed_seconds,
+    }
+
+
+def _median_measurement_metric(
+    measurements: Sequence[Mapping[str, Any]],
+    *,
+    lane: str,
+    key: str,
+) -> float | None:
+    values = [
+        float(value)
+        for measurement in measurements
+        if measurement.get("lane") == lane
+        for value in [measurement.get(key)]
+        if isinstance(value, (float, int))
+        and not isinstance(value, bool)
+        and math.isfinite(float(value))
+        and float(value) >= 0.0
+    ]
+    return float(statistics.median(values)) if values else None
+
+
+def _cell_resource_gate(
+    artifacts: Mapping[str, Mapping[str, Any]],
+    measurements: Sequence[Mapping[str, Any]],
+    *,
+    gain_gate: Mapping[str, Any],
+    shared_artifact: bool,
+) -> dict[str, Any]:
+    comparisons: dict[str, dict[str, object]] = {}
+
+    def compare(name: str, baseline: float | None, current: float | None) -> None:
+        if baseline is None or current is None or baseline <= 0.0:
+            comparisons[name] = {
+                "baseline": baseline,
+                "current": current,
+                "ratio": None,
+                "material_growth": None,
+                "offset_by_runtime_gain": False,
+                "passes": shared_artifact,
+            }
+            return
+        ratio = current / baseline
+        material = ratio > 1.0 + MATERIAL_RESOURCE_GROWTH_THRESHOLD
+        offset = not material or bool(gain_gate.get("passes"))
+        comparisons[name] = {
+            "baseline": baseline,
+            "current": current,
+            "ratio": ratio,
+            "material_growth": material,
+            "offset_by_runtime_gain": offset,
+            "passes": offset,
+        }
+
+    compare(
+        "material_payload_size_bytes",
+        float(artifacts["baseline"].get("material_payload_size_bytes", 0.0)),
+        float(artifacts["current"].get("material_payload_size_bytes", 0.0)),
+    )
+    compare(
+        "cold_load_seconds",
+        _median_measurement_metric(
+            measurements,
+            lane="baseline",
+            key="cold_load_seconds",
+        ),
+        _median_measurement_metric(
+            measurements,
+            lane="current",
+            key="cold_load_seconds",
+        ),
+    )
+    compare(
+        "peak_rss_gib",
+        _median_measurement_metric(
+            measurements,
+            lane="baseline",
+            key="peak_rss_gib",
+        ),
+        _median_measurement_metric(
+            measurements,
+            lane="current",
+            key="peak_rss_gib",
+        ),
+    )
+    baseline_generation = artifacts["baseline"].get("core_generation_seconds")
+    current_generation = artifacts["current"].get("core_generation_seconds")
+    generation_ratio = (
+        float(current_generation) / float(baseline_generation)
+        if isinstance(baseline_generation, (float, int))
+        and not isinstance(baseline_generation, bool)
+        and float(baseline_generation) > 0.0
+        and isinstance(current_generation, (float, int))
+        and not isinstance(current_generation, bool)
+        else None
+    )
+    generation_passes = shared_artifact or (
+        generation_ratio is not None and generation_ratio <= 1.10
+    )
+    return {
+        "material_growth_threshold": MATERIAL_RESOURCE_GROWTH_THRESHOLD,
+        "material_growth_requires_runtime_gain": True,
+        "comparisons": comparisons,
+        "generation": {
+            "baseline_core_seconds": baseline_generation,
+            "current_core_seconds": current_generation,
+            "current_over_baseline": generation_ratio,
+            "maximum_ratio": 1.10,
+            "passes": generation_passes,
+        },
+        "passes": generation_passes
+        and all(bool(value["passes"]) for value in comparisons.values()),
+    }
+
+
+def _environment() -> dict[str, str]:
+    environment = os.environ.copy()
+    environment.pop("PYTHONPATH", None)
+    environment["PYTHONHASHSEED"] = "0"
+    environment["PYTHONDONTWRITEBYTECODE"] = "1"
+    environment.setdefault("SYMBOLICA_HIDE_BANNER", "1")
+    return environment
+
+
+def _resolved_workload(arguments: argparse.Namespace, *, lc_flow_layout: str) -> str:
+    requested = getattr(arguments, "workload", "auto")
+    if arguments.color != "lc":
+        derived = "summed"
+        if arguments.helicity or arguments.color_flow:
+            raise RegressionError("NLC/full summed workloads cannot use LC selectors")
+    elif lc_flow_layout == "topology-replay":
+        if not arguments.color_flow and not arguments.helicity and requested == "auto":
+            return "summed"
+        if not arguments.color_flow or arguments.helicity:
+            raise RegressionError(
+                "topology-replay acceptance requires one runtime color-flow selector "
+                "and no helicity selector"
+            )
+        derived = "single-flow-helicity-sum"
+    else:
+        if not arguments.helicity and not arguments.color_flow and requested == "auto":
+            return "summed"
+        if not arguments.helicity or arguments.color_flow:
+            raise RegressionError(
+                "all-flow-union acceptance requires one runtime helicity selector "
+                "and no color-flow selector"
+            )
+        derived = "all-flow-single-helicity"
+    if requested not in {"auto", derived}:
+        raise RegressionError(
+            f"declared workload {requested!r} does not match "
+            f"selectors/layout {derived!r}"
+        )
+    return derived
+
+
+def run_regression(arguments: argparse.Namespace) -> dict[str, Any]:
+    baseline_python = _require_interpreter(
+        arguments.baseline_python,
+        lane="baseline",
+    )
+    current_python = _require_interpreter(arguments.current_python, lane="current")
+    output_root = _absolute_path(arguments.output_root)
+    output_root.mkdir(parents=True, exist_ok=True)
+    model = _model_argument(arguments.model)
+    execution_mode = getattr(arguments, "execution_mode", "compiled")
+    if execution_mode not in EXECUTION_MODES:
+        raise RegressionError(f"unsupported execution mode: {execution_mode!r}")
+    jit_optimization_level = getattr(arguments, "jit_optimization_level", 3)
+    dependency_sites = {
+        "baseline": getattr(arguments, "baseline_dependency_site", None),
+        "current": getattr(arguments, "current_dependency_site", None),
+    }
+    dependency_sites = {
+        lane: (None if path is None else _absolute_path(path).resolve(strict=True))
+        for lane, path in dependency_sites.items()
+    }
+    dependency_identity_cache: dict[str, dict[str, object]] = {}
+    dependency_site_identities: dict[str, dict[str, object] | None] = {}
+    for lane, path in dependency_sites.items():
+        if path is None:
+            dependency_site_identities[lane] = None
+            continue
+        key = str(path)
+        identity = dependency_identity_cache.get(key)
+        if identity is None:
+            identity = _dependency_site_identity(path)
+            dependency_identity_cache[key] = identity
+        dependency_site_identities[lane] = identity
+    lc_flow_layout = getattr(
+        arguments,
+        "lc_flow_layout",
+        DEFAULT_LC_FLOW_LAYOUT,
+    )
+    expected_artifact_lc_flow_layout = (
+        lc_flow_layout if arguments.color == "lc" else None
+    )
+    workload = _resolved_workload(arguments, lc_flow_layout=lc_flow_layout)
+    shared_artifact_argument = getattr(arguments, "shared_artifact", None)
+    if shared_artifact_argument is not None and arguments.regenerate_artifacts:
+        raise RegressionError(
+            "--shared-artifact and --regenerate-artifacts are mutually exclusive"
+        )
+    shared_artifact = (
+        None
+        if shared_artifact_argument is None
+        else _absolute_path(shared_artifact_argument)
+    )
+    environment = _environment()
+    started = time.monotonic()
+
+    interpreters = {
+        "baseline": baseline_python,
+        "current": current_python,
+    }
+    provenance = {
+        "driver": _path_identity(Path(__file__)),
+        "watchdog": _path_identity(WATCHDOG),
+        "native_sample_helper": _path_identity(NATIVE_SAMPLE_HELPER),
+        "dependency_entry": _path_identity(DEPENDENCY_ENTRY),
+        "interpreters": {
+            lane: _path_identity(python) for lane, python in interpreters.items()
+        },
+        "model": _model_identity(model),
+        "dependency_sites": dependency_site_identities,
+    }
+    if shared_artifact is None:
+        artifacts = {
+            lane: _ensure_artifact(
+                lane,
+                python,
+                output_root=output_root,
+                process=arguments.process,
+                model=model,
+                color=arguments.color,
+                execution_mode=execution_mode,
+                jit_optimization_level=jit_optimization_level,
+                generation_timeout=arguments.generation_timeout,
+                regenerate=arguments.regenerate_artifacts,
+                environment=environment,
+                lc_flow_layout=lc_flow_layout,
+                dependency_site=dependency_sites[lane],
+                dependency_site_identity=dependency_site_identities[lane],
+            )
+            for lane, python in interpreters.items()
+        }
+        for artifact in artifacts.values():
+            artifact["comparison_role"] = "independently-generated-lane-artifact"
+        shared_artifact_identity: dict[str, Any] | None = None
+    else:
+        shared_artifact_identity = _artifact_metadata(
+            shared_artifact,
+            expected_process=arguments.process,
+            expected_color=arguments.color,
+            expected_execution_mode=execution_mode,
+            expected_lc_flow_layout=expected_artifact_lc_flow_layout,
+        )
+        artifacts = {
+            lane: {
+                **shared_artifact_identity,
+                "shared": True,
+                "reused": True,
+                "generation": None,
+                "generation_command": None,
+                "cache_path": None,
+                "comparison_role": "shared-read-only-artifact",
+            }
+            for lane in interpreters
+        }
+    partial: dict[str, Any] = {
+        "kind": RESULT_KIND,
+        "schema_version": SCHEMA_VERSION,
+        "complete": False,
+        "provenance": provenance,
+        "artifacts": artifacts,
+        "measurements": [],
+    }
+    result_path_argument = getattr(arguments, "result_path", None)
+    result_path = (
+        output_root / "result.json"
+        if result_path_argument is None
+        else _absolute_path(result_path_argument)
+    )
+    _write_json_atomic(result_path, partial)
+
+    measurements: list[dict[str, Any]] = []
+    values: dict[str, list[float]] = {"baseline": [], "current": []}
+    native_module_sha256_by_lane: dict[str, str] = {}
+    pair_orders: list[list[str]] = []
+    for pair_index in range(arguments.samples):
+        order = (
+            ("baseline", "current") if pair_index % 2 == 0 else ("current", "baseline")
+        )
+        pair_orders.append(list(order))
+        for order_index, lane in enumerate(order):
+            artifact = artifacts[lane]
+            request_precision32 = pair_index == 0 and lane == "current"
+            profile_command = _profile_command(
+                interpreters[lane],
+                artifact=Path(str(artifact["path"])),
+                process_id=str(artifact["process_id"]),
+                batch_size=arguments.batch_size,
+                target_runtime=arguments.target_runtime,
+                minimum_samples=arguments.minimum_samples,
+                warmup_runs=arguments.warmup_runs,
+                helicities=arguments.helicity,
+                color_flows=arguments.color_flow,
+                execution_mode=execution_mode,
+                profile_protocol=(
+                    ARENA_PROFILE_PROTOCOL
+                    if lane == "current"
+                    else FROZEN_BASELINE_PROFILE_PROTOCOL
+                ),
+                dependency_site=dependency_sites[lane],
+                include_precision32=request_precision32,
+            )
+            payload, command_elapsed, stderr = _run_json(
+                profile_command,
+                timeout=arguments.profile_timeout,
+                environment=environment,
+            )
+            sample = _native_profile_sample(
+                payload,
+                minimum_samples=arguments.minimum_samples,
+                batch_size=arguments.batch_size,
+                expected_execution_mode=execution_mode,
+                require_precision32=request_precision32,
+                require_arena_profile=lane == "current",
+            )
+            observed_precision32 = isinstance(
+                sample.get("precision32_numerical_result"),
+                Mapping,
+            )
+            if observed_precision32 is not request_precision32:
+                raise RegressionError(
+                    "native sample precision-32 evidence does not match the "
+                    f"{PRECISION32_CORRECTNESS_POLICY} request policy for "
+                    f"{lane} pair {pair_index + 1}"
+                )
+            native_module_sha256 = str(sample["native_module_sha256"])
+            expected_native_module_sha256 = native_module_sha256_by_lane.setdefault(
+                lane,
+                native_module_sha256,
+            )
+            if native_module_sha256 != expected_native_module_sha256:
+                raise RegressionError(
+                    f"{lane} native module changed during sampling: "
+                    f"{native_module_sha256} != {expected_native_module_sha256}"
+                )
+            if measurements:
+                reference = measurements[0]
+                for key in (
+                    "batch_sha256",
+                    "helicities",
+                    "color_flows",
+                    "correctness_point_derivation",
+                ):
+                    if sample[key] != reference[key]:
+                        raise RegressionError(
+                            "native samples do not share byte-identical inputs: "
+                            f"{key} differs in {lane} pair {pair_index + 1}"
+                        )
+            wall = float(sample["wall_seconds_per_point"])
+            values[lane].append(wall)
+            measurements.append(
+                {
+                    "pair_index": pair_index + 1,
+                    "measurement_order": order_index + 1,
+                    "lane": lane,
+                    "command": _command_identity(profile_command),
+                    "guarded_command": _command_identity(
+                        _guarded_command(profile_command)
+                    ),
+                    **sample,
+                    "command_elapsed_seconds": command_elapsed,
+                    "peak_rss_gib": _watchdog_peak_gib(stderr),
+                    "watchdog": _watchdog_marker(stderr),
+                }
+            )
+        partial["measurements"] = measurements
+        partial["pair_orders"] = pair_orders
+        _write_json_atomic(result_path, partial)
+
+    if shared_artifact_identity is not None:
+        assert shared_artifact is not None
+        observed_identity = _artifact_metadata(
+            shared_artifact,
+            expected_process=arguments.process,
+            expected_color=arguments.color,
+            expected_execution_mode=execution_mode,
+            expected_lc_flow_layout=expected_artifact_lc_flow_layout,
+        )
+        for key in (
+            "artifact_id",
+            "manifest_sha256",
+            "tree_identity",
+            "payload_digests",
+        ):
+            if observed_identity[key] != shared_artifact_identity[key]:
+                raise RegressionError(
+                    f"shared artifact changed during sampling: {key} differs"
+                )
+    else:
+        for lane, initial_identity in artifacts.items():
+            observed_identity = _artifact_metadata(
+                Path(str(initial_identity["path"])),
+                expected_process=arguments.process,
+                expected_color=arguments.color,
+                expected_execution_mode=execution_mode,
+                expected_lc_flow_layout=expected_artifact_lc_flow_layout,
+            )
+            for key in (
+                "artifact_id",
+                "manifest_sha256",
+                "tree_identity",
+                "payload_digests",
+            ):
+                if observed_identity[key] != initial_identity[key]:
+                    raise RegressionError(
+                        f"{lane} artifact changed during sampling: {key} differs"
+                    )
+    for lane, path in dependency_sites.items():
+        if (
+            path is not None
+            and _dependency_site_identity(path) != (dependency_site_identities[lane])
+        ):
+            raise RegressionError(
+                f"{lane} dependency site changed during generation/sampling"
+            )
+    if _model_identity(model) != provenance["model"]:
+        raise RegressionError("model input changed during generation/sampling")
+    distributions = {
+        lane: _distribution(lane_values) for lane, lane_values in values.items()
+    }
+    authority = _performance_authority(
+        artifacts,
+        shared_artifact=shared_artifact_identity is not None,
+    )
+    measured_gate = _regression_gate(
+        distributions["baseline"],
+        distributions["current"],
+    )
+    measured_thresholds_pass = bool(measured_gate.pop("passes"))
+    paired_distribution = _paired_distribution(measurements)
+    gain_gate = _gain_gate(
+        distributions["baseline"],
+        distributions["current"],
+        paired_distribution,
+    )
+    gate = {
+        **measured_gate,
+        "measured_thresholds_pass": measured_thresholds_pass,
+        "authoritative": bool(authority["authoritative"]),
+        "authority_basis": authority["basis"],
+        "passes": (bool(authority["authoritative"]) and measured_thresholds_pass),
+    }
+    correctness_gate = _correctness_gate(measurements)
+    arena_profile_gate = _arena_profile_gate(
+        measurements,
+        execution_mode=execution_mode,
+        artifacts=artifacts,
+        minimum_profile_timed_blocks=arguments.minimum_samples,
+    )
+    resource_gate = _cell_resource_gate(
+        artifacts,
+        measurements,
+        gain_gate=gain_gate,
+        shared_artifact=shared_artifact_identity is not None,
+    )
+    elapsed = time.monotonic() - started
+    result = {
+        "kind": RESULT_KIND,
+        "schema_version": SCHEMA_VERSION,
+        "complete": True,
+        "performance_result_authoritative": bool(authority["authoritative"]),
+        "passes": bool(
+            gate["passes"]
+            and correctness_gate["passes"]
+            and arena_profile_gate["passes"]
+            and resource_gate["passes"]
+        ),
+        "platform": platform.platform(),
+        "provenance": provenance,
+        "configuration": {
+            "baseline_python": str(baseline_python),
+            "current_python": str(current_python),
+            "output_root": str(output_root),
+            "process": arguments.process,
+            "model": model,
+            "model_label": getattr(arguments, "model_label", "custom"),
+            "execution_mode": execution_mode,
+            "workload": workload,
+            "jit_optimization_level": jit_optimization_level,
+            "color_accuracy": arguments.color,
+            "lc_flow_layout": lc_flow_layout,
+            "shared_artifact": (
+                None if shared_artifact is None else str(shared_artifact)
+            ),
+            "batch_size": arguments.batch_size,
+            "independent_samples_per_lane": arguments.samples,
+            "target_runtime_per_profile_seconds": arguments.target_runtime,
+            "target_runtime_per_native_sample_seconds": arguments.target_runtime,
+            "minimum_native_timed_blocks_per_profile": arguments.minimum_samples,
+            "warmup_runs_per_profile": arguments.warmup_runs,
+            "generation_timeout_seconds": arguments.generation_timeout,
+            "profile_timeout_seconds": arguments.profile_timeout,
+            "native_sample_timeout_seconds": arguments.profile_timeout,
+            "helicities": list(arguments.helicity),
+            "color_flows": list(arguments.color_flow),
+            "native_wall_time_source": NATIVE_WALL_TIME_SOURCE,
+            "native_wall_time_sample_pass": NATIVE_WALL_TIME_SAMPLE_PASS,
+            "required_current_profile_attribution_sample_pass": (
+                PROFILE_ATTRIBUTION_SAMPLE_PASS
+            ),
+            "required_current_profile_attribution_boundary": (ARENA_PROFILE_BOUNDARY),
+            "required_current_profile_attribution_phase_timing_scope": (
+                ARENA_PHASE_TIMING_SCOPE
+            ),
+            "required_current_profile_attribution_evaluator_timing_available": False,
+            "required_current_profile_protocol": ARENA_PROFILE_PROTOCOL,
+            "timing_sample_contract": PAIRED_TIMING_SAMPLE_CONTRACT,
+            "precision32_correctness_policy": PRECISION32_CORRECTNESS_POLICY,
+            "dependency_sites": {
+                lane: dependency_site_identities[lane] for lane in dependency_sites
+            },
+        },
+        "artifacts": artifacts,
+        "pair_orders": pair_orders,
+        "measurements": measurements,
+        "native_module_sha256_by_lane": native_module_sha256_by_lane,
+        "distributions": distributions,
+        "paired_distribution": paired_distribution,
+        "performance_authority": authority,
+        "gate": gate,
+        "gain_gate": gain_gate,
+        "correctness_gate": correctness_gate,
+        "arena_profile_gate": arena_profile_gate,
+        "resource_gate": resource_gate,
+        "resources": _resource_summary(
+            artifacts,
+            measurements,
+            elapsed_seconds=elapsed,
+        ),
+    }
+    _write_json_atomic(result_path, result)
+    return result
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(
+        description=__doc__,
+        epilog=(
+            "The gate passes only when the current median is no more than 3% "
+            "above the baseline median and no more than three baseline MAD above it."
+        ),
+    )
+    result.add_argument("--baseline-python", type=Path, required=True)
+    result.add_argument("--current-python", type=Path, required=True)
+    result.add_argument("--output-root", type=Path, required=True)
+    result.add_argument(
+        "--result-path",
+        type=Path,
+        help=(
+            "write the result outside the artifact-cache root; this permits "
+            "multiple timing cells to reuse one exact generated artifact"
+        ),
+    )
+    result.add_argument(
+        "--shared-artifact",
+        type=Path,
+        help=(
+            "sample one existing read-only artifact in both lanes instead of "
+            "generating per-lane artifacts"
+        ),
+    )
+    result.add_argument("--process", required=True)
+    result.add_argument("--model", default="built-in-sm")
+    result.add_argument(
+        "--model-label",
+        choices=("built-in", "ufo-sm", "custom"),
+        default="custom",
+    )
+    result.add_argument(
+        "--execution-mode",
+        choices=EXECUTION_MODES,
+        default="compiled",
+    )
+    result.add_argument(
+        "--jit-optimization-level",
+        type=int,
+        choices=(0, 1, 2, 3),
+        default=3,
+    )
+    result.add_argument(
+        "--workload",
+        choices=(
+            "auto",
+            "single-flow-helicity-sum",
+            "all-flow-single-helicity",
+            "summed",
+        ),
+        default="auto",
+    )
+    result.add_argument("--baseline-dependency-site", type=Path)
+    result.add_argument("--current-dependency-site", type=Path)
+    result.add_argument(
+        "--color",
+        "--color-accuracy",
+        dest="color",
+        choices=("lc", "nlc", "full"),
+        default="lc",
+    )
+    result.add_argument(
+        "--lc-flow-layout",
+        choices=("topology-replay", "all-flow-union"),
+        default=DEFAULT_LC_FLOW_LAYOUT,
+        help="LC artifact layout generated identically in both lanes",
+    )
+    result.add_argument("--batch-size", type=_positive_int, default=DEFAULT_BATCH_SIZE)
+    result.add_argument(
+        "--samples",
+        type=_at_least_five,
+        default=DEFAULT_SAMPLE_COUNT,
+        help=(
+            "independent native sampling subprocesses per interpreter "
+            "(acceptance default: 7; diagnostic minimum: 5)"
+        ),
+    )
+    result.add_argument(
+        "--target-runtime",
+        type=_positive_float,
+        default=DEFAULT_TARGET_RUNTIME,
+        help="native headline timing target for each sampling subprocess",
+    )
+    result.add_argument(
+        "--minimum-samples",
+        type=_at_least_five,
+        default=DEFAULT_SAMPLE_COUNT,
+        help="minimum native timed blocks inside each sampling subprocess",
+    )
+    result.add_argument(
+        "--warmup-runs",
+        type=_positive_int,
+        default=DEFAULT_WARMUP_RUNS,
+    )
+    result.add_argument("--helicity", action="append", default=[])
+    result.add_argument("--color-flow", action="append", default=[])
+    result.add_argument(
+        "--generation-timeout",
+        type=_positive_float,
+        default=DEFAULT_GENERATION_TIMEOUT,
+    )
+    result.add_argument(
+        "--profile-timeout",
+        type=_positive_float,
+        default=DEFAULT_PROFILE_TIMEOUT,
+    )
+    result.add_argument(
+        "--regenerate-artifacts",
+        action="store_true",
+        help="replace both cached compiled artifacts before sampling",
+    )
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    try:
+        result = run_regression(arguments)
+    except (RegressionError, OSError, ValueError) as error:
+        print(f"compiled-mode-regression: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, indent=2, sort_keys=True, allow_nan=False))
+    return 0 if result["passes"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/compiled_mode_sample.py b/pyamplicol/tools/developer/compiled_mode_sample.py
new file mode 100644
index 0000000000..9c08e447b9
--- /dev/null
+++ b/pyamplicol/tools/developer/compiled_mode_sample.py
@@ -0,0 +1,1626 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Emit one version-independent eager/compiled runtime timing sample as JSON.
+
+The helper is executed by the interpreter being measured.  It deliberately
+does not use :class:`pyamplicol.benchmarking.BenchmarkBackend`, whose timing
+policy can differ between the frozen and current installations.  Every
+headline block calls the native ``_benchmark_f64_wall_time`` entry point, whose
+timer starts after it has packed the batch. A separate private warmed-Arena
+profile uses the same borrowed input, preallocated-output boundary, selector
+arguments, and repetition count solely for attribution. Frozen baseline
+runtimes are measured only through an explicit ``frozen-pre-arena`` protocol
+that invokes their historical ``profile_repeated`` operation. Automatic
+capability detection and fallback are forbidden.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib
+import importlib.metadata
+import importlib.util
+import json
+import math
+import platform
+import statistics
+import sys
+import time
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+RESULT_KIND = "pyamplicol-compiled-mode-native-sample"
+SCHEMA_VERSION = 5
+INSTALLATION_IDENTITY_KIND = "pyamplicol-installed-distribution-identity"
+INSTALLATION_IDENTITY_SCHEMA_VERSION = 2
+NATIVE_WALL_TIME_SOURCE = "runtime_core_repeated_wall_time"
+NATIVE_WALL_TIME_SAMPLE_PASS = "runtime._benchmark_f64_wall_time"
+ARENA_PROFILE_ATTRIBUTION_SAMPLE_PASS = "runtime._profile_arena_repeated"
+FROZEN_BASELINE_PROFILE_ATTRIBUTION_SAMPLE_PASS = "runtime.profile_repeated"
+ARENA_PROFILE_BOUNDARY = "warmed-direct-arena-borrowed-input-preallocated-output-v1"
+FROZEN_BASELINE_PROFILE_BOUNDARY = "materialized-native-profile-v1"
+ARENA_PHASE_TIMING_SCOPE = "coarse-arena-boundary-only-v1"
+FROZEN_BASELINE_PHASE_TIMING_SCOPE = "profiled-evaluator-phases-v1"
+ARENA_PROFILE_PROTOCOL = "arena"
+FROZEN_BASELINE_PROFILE_PROTOCOL = "frozen-pre-arena"
+PROFILE_PROTOCOLS = (ARENA_PROFILE_PROTOCOL, FROZEN_BASELINE_PROFILE_PROTOCOL)
+PAIRED_TIMING_SAMPLE_CONTRACT = "paired_unprofiled_headline_profiled_attribution_v1"
+MAX_CALIBRATION_BLOCKS = 4
+MAX_REPETITIONS = 1_000_000_000
+MAX_CORRECTNESS_POINTS = 8
+MIN_CORRECTNESS_POINTS = 8
+CORRECTNESS_POINT_DERIVATION_KIND = (
+    "pyamplicol-compiled-mode-correctness-point-derivation"
+)
+CORRECTNESS_POINT_DERIVATION_SCHEMA_VERSION = 1
+CORRECTNESS_POINT_DERIVATION_CONTRACT = (
+    "authenticated-first-validation-point-massive-rambo-v1"
+)
+CORRECTNESS_SEED_START = 20260726
+MAX_CORRECTNESS_SEED_ATTEMPTS = 256
+MIN_SCALED_PAIR_INVARIANT = 1.0e-10
+KINEMATIC_RELATIVE_TOLERANCE = 1.0e-10
+MASS_SQUARED_ROUNDOFF_ULPS = 512.0
+_HASH_CHUNK_BYTES = 1024 * 1024
+
+FourMomentum = tuple[float, float, float, float]
+
+
+@dataclass(frozen=True, slots=True)
+class ValidationMomentaSource:
+    """Authenticated artifact validation momenta and path-free provenance."""
+
+    points: tuple[tuple[FourMomentum, ...], ...]
+    identity: Mapping[str, object]
+
+
+@dataclass(frozen=True, slots=True)
+class ProfileOperation:
+    operation: Any
+    sample_pass: str
+    boundary: str
+    borrowed_flat_input: bool
+    preallocated_output: bool
+    phase_timing_scope: str
+    evaluator_timing_available: bool
+
+
+class SampleError(RuntimeError):
+    """Raised when a trustworthy paired native sample cannot be produced."""
+
+
+EXECUTION_MODES = ("eager", "compiled")
+DEPENDENCY_PACKAGES = ("numpy", "symbolica", "ufo_model_loader")
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0.0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return parsed
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return parsed
+
+
+def _at_least_five(value: str) -> int:
+    parsed = _positive_int(value)
+    if parsed < 5:
+        raise argparse.ArgumentTypeError("must be at least five")
+    return parsed
+
+
+def _finite_positive(value: object, *, label: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise SampleError(f"{label} must be numeric")
+    result = float(value)
+    if not math.isfinite(result) or result <= 0.0:
+        raise SampleError(f"{label} must be positive and finite")
+    return result
+
+
+def _finite_nonnegative(value: object, *, label: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise SampleError(f"{label} must be numeric")
+    result = float(value)
+    if not math.isfinite(result) or result < 0.0:
+        raise SampleError(f"{label} must be finite and non-negative")
+    return result
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(_HASH_CHUNK_BYTES):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _path_identity(path: Path) -> dict[str, object]:
+    resolved = path.resolve(strict=True)
+    stat = resolved.stat()
+    return {
+        "path": str(path),
+        "resolved_path": str(resolved),
+        "size_bytes": stat.st_size,
+        "sha256": _sha256_file(resolved),
+    }
+
+
+def _package_origin(package: str) -> Path | None:
+    specification = importlib.util.find_spec(package)
+    origin = None if specification is None else specification.origin
+    if origin is None:
+        return None
+    try:
+        return Path(origin).resolve(strict=True)
+    except OSError as error:
+        raise SampleError(
+            f"cannot resolve {package} package origin: {origin}"
+        ) from error
+
+
+def _activate_dependency_site(path: Path | None) -> dict[str, object] | None:
+    """Load exact dependencies without allowing them to shadow the measured wheel."""
+
+    if path is None:
+        return None
+    try:
+        dependency_site = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise SampleError(f"cannot resolve dependency site: {path}") from error
+    if not dependency_site.is_dir():
+        raise SampleError(f"dependency site is not a directory: {dependency_site}")
+    pyamplicol_before = _package_origin("pyamplicol")
+    if pyamplicol_before is None:
+        raise SampleError("the selected interpreter has no pyamplicol package")
+    original_path = list(sys.path)
+    try:
+        sys.path.insert(0, str(dependency_site))
+        for package in DEPENDENCY_PACKAGES:
+            importlib.import_module(package)
+    except ImportError as error:
+        raise SampleError(
+            f"dependency site does not provide required package {error.name!r}"
+        ) from error
+    finally:
+        sys.path[:] = original_path
+    if str(dependency_site) not in sys.path:
+        sys.path.append(str(dependency_site))
+    pyamplicol_after = _package_origin("pyamplicol")
+    if pyamplicol_after != pyamplicol_before:
+        raise SampleError(
+            "dependency-site activation changed the selected pyamplicol package "
+            f"origin: {pyamplicol_before} -> {pyamplicol_after}"
+        )
+    distribution = importlib.metadata.distribution("pyamplicol")
+    distribution_init = Path(
+        str(distribution.locate_file("pyamplicol/__init__.py"))
+    ).resolve(strict=True)
+    if distribution_init != pyamplicol_before:
+        raise SampleError(
+            "selected pyamplicol distribution and import package disagree: "
+            f"{distribution_init} != {pyamplicol_before}"
+        )
+    dependencies: dict[str, object] = {}
+    for package in DEPENDENCY_PACKAGES:
+        origin = _package_origin(package)
+        if origin is None:
+            raise SampleError(f"required dependency {package!r} has no import origin")
+        try:
+            origin.relative_to(dependency_site)
+        except ValueError as error:
+            raise SampleError(
+                f"required dependency {package!r} was not loaded from "
+                f"{dependency_site}: {origin}"
+            ) from error
+        dependencies[package] = _path_identity(origin)
+    return {
+        "path": str(path),
+        "resolved_path": str(dependency_site),
+        "pyamplicol_origin_before": _path_identity(pyamplicol_before),
+        "pyamplicol_origin_after": _path_identity(pyamplicol_after),
+        "dependencies": dependencies,
+    }
+
+
+def _canonical_sha256(value: object) -> str:
+    encoded = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _installed_distribution_identity() -> dict[str, object]:
+    """Return a content identity for the installed generator/runtime wheel."""
+
+    try:
+        distribution = importlib.metadata.distribution("pyamplicol")
+    except importlib.metadata.PackageNotFoundError as error:
+        raise SampleError(
+            "the selected interpreter has no pyamplicol installation"
+        ) from error
+    digest = hashlib.sha256()
+    file_count = 0
+    size_bytes = 0
+    native_modules: list[dict[str, object]] = []
+    build_info_files: list[dict[str, object]] = []
+    for entry in sorted(distribution.files or (), key=str):
+        relative = str(entry)
+        path = Path(str(distribution.locate_file(entry)))
+        if not path.is_file():
+            continue
+        resolved = path.resolve(strict=True)
+        size = resolved.stat().st_size
+        entry_bytes = relative.encode("utf-8")
+        digest.update(len(entry_bytes).to_bytes(8, "big"))
+        digest.update(entry_bytes)
+        digest.update(size.to_bytes(8, "big"))
+        with resolved.open("rb") as stream:
+            while chunk := stream.read(_HASH_CHUNK_BYTES):
+                digest.update(chunk)
+        file_count += 1
+        size_bytes += size
+        name = resolved.name
+        identity = {
+            "relative_path": relative,
+            **_path_identity(resolved),
+        }
+        if name.startswith("_rusticol.") and resolved.suffix in {
+            ".so",
+            ".pyd",
+            ".dylib",
+        }:
+            native_modules.append(identity)
+        if relative.endswith("pyamplicol/_build_info.json"):
+            try:
+                payload = json.loads(resolved.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError) as error:
+                raise SampleError(
+                    f"cannot read installed build provenance: {resolved}"
+                ) from error
+            if not isinstance(payload, dict):
+                raise SampleError(
+                    "installed pyamplicol build provenance is not an object"
+                )
+            build_info_files.append({**identity, "payload": payload})
+    if len(native_modules) != 1:
+        raise SampleError(
+            "the selected pyamplicol installation must contain exactly one "
+            f"native Rusticol module, found {len(native_modules)}"
+        )
+    return {
+        "kind": INSTALLATION_IDENTITY_KIND,
+        "schema_version": INSTALLATION_IDENTITY_SCHEMA_VERSION,
+        "package_version": distribution.version,
+        "distribution_content": {
+            "algorithm": "sha256-relative-path-size-content-v1",
+            "sha256": digest.hexdigest(),
+            "file_count": file_count,
+            "size_bytes": size_bytes,
+        },
+        "native_modules": native_modules,
+        "build_info_files": build_info_files,
+    }
+
+
+def _json_value(value: object) -> object:
+    if value is None or isinstance(value, (bool, int, str)):
+        return value
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            raise SampleError("native profile contains a non-finite float")
+        return value
+    if isinstance(value, Mapping):
+        return {str(key): _json_value(entry) for key, entry in value.items()}
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return [_json_value(entry) for entry in value]
+    raise SampleError(
+        f"native profile contains a non-JSON value of type {type(value).__name__}"
+    )
+
+
+def _statistics(values: Sequence[float]) -> dict[str, float]:
+    if not values:
+        raise SampleError("timing statistics require at least one sample")
+    mean = float(statistics.fmean(values))
+    deviation = float(statistics.stdev(values)) if len(values) > 1 else 0.0
+    error = deviation / math.sqrt(len(values))
+    return {
+        "standard_deviation": deviation,
+        "standard_error": error,
+        "relative_standard_error": error / mean if mean > 0.0 else 0.0,
+    }
+
+
+def _component(values: Sequence[float]) -> dict[str, object]:
+    return {
+        "mean_seconds_per_point": float(statistics.fmean(values)),
+        "uncertainty": _statistics(values),
+        "sample_count": len(values),
+        "samples_seconds_per_point": list(values),
+    }
+
+
+def _benchmark_batch(points: Sequence[object], batch_size: int) -> tuple[object, ...]:
+    source = tuple(points)
+    if not source:
+        raise SampleError("artifact has no deterministic validation point")
+    return tuple(source[index % len(source)] for index in range(batch_size))
+
+
+def _sum_momenta(momenta: Sequence[FourMomentum]) -> FourMomentum:
+    return tuple(
+        float(math.fsum(momentum[axis] for momentum in momenta)) for axis in range(4)
+    )  # type: ignore[return-value]
+
+
+def _minkowski_square(momentum: FourMomentum) -> float:
+    return (
+        momentum[0] * momentum[0]
+        - momentum[1] * momentum[1]
+        - momentum[2] * momentum[2]
+        - momentum[3] * momentum[3]
+    )
+
+
+def _minkowski_dot(left: FourMomentum, right: FourMomentum) -> float:
+    return (
+        left[0] * right[0]
+        - left[1] * right[1]
+        - left[2] * right[2]
+        - left[3] * right[3]
+    )
+
+
+def _kinematic_scale(*values: float) -> float:
+    return max(1.0, *(abs(value) for value in values))
+
+
+def _kinematically_close(left: float, right: float, *, scale: float) -> bool:
+    return math.isclose(
+        left,
+        right,
+        rel_tol=0.0,
+        abs_tol=KINEMATIC_RELATIVE_TOLERANCE * max(1.0, scale),
+    )
+
+
+def _validated_mass_squared(momentum: FourMomentum, *, label: str) -> float:
+    if momentum[0] <= 0.0:
+        raise SampleError(f"{label} energy must be positive")
+    spatial_squared = math.fsum(component * component for component in momentum[1:])
+    mass_squared = momentum[0] * momentum[0] - spatial_squared
+    roundoff_limit = (
+        MASS_SQUARED_ROUNDOFF_ULPS
+        * sys.float_info.epsilon
+        * _kinematic_scale(momentum[0] * momentum[0], spatial_squared)
+    )
+    if mass_squared < -roundoff_limit:
+        raise SampleError(f"{label} has a spacelike four-momentum")
+    if abs(mass_squared) <= roundoff_limit:
+        return 0.0
+    return mass_squared
+
+
+def _inferred_mass(momentum: FourMomentum, *, label: str) -> float:
+    return math.sqrt(_validated_mass_squared(momentum, label=label))
+
+
+def _boost_to_rest(
+    momentum: FourMomentum,
+    beta: tuple[float, float, float],
+) -> FourMomentum:
+    beta_squared = math.fsum(component * component for component in beta)
+    if beta_squared == 0.0:
+        return momentum
+    if not 0.0 < beta_squared < 1.0:
+        raise SampleError("RAMBO generated an invalid center-of-mass boost")
+    gamma = 1.0 / math.sqrt(1.0 - beta_squared)
+    beta_dot_momentum = math.fsum(beta[axis] * momentum[axis + 1] for axis in range(3))
+    spatial_factor = (
+        gamma - 1.0
+    ) * beta_dot_momentum / beta_squared + gamma * momentum[0]
+    return (
+        gamma * (momentum[0] + beta_dot_momentum),
+        momentum[1] + spatial_factor * beta[0],
+        momentum[2] + spatial_factor * beta[1],
+        momentum[3] + spatial_factor * beta[2],
+    )
+
+
+def _massive_rambo_final_state(
+    multiplicity: int,
+    *,
+    sqrt_s: float,
+    masses: Sequence[float],
+    seed: int,
+    numpy_module: Any,
+) -> tuple[FourMomentum, ...]:
+    """Standalone RAMBO using only the activated dependency-site NumPy."""
+
+    if multiplicity < 2 or multiplicity != len(masses):
+        raise SampleError("correctness RAMBO requires at least two final particles")
+    rng = numpy_module.random.default_rng(seed)
+    raw: list[FourMomentum] = []
+    for _ in range(multiplicity):
+        random_values = rng.random(4)
+        cosine = 2.0 * float(random_values[0]) - 1.0
+        sine = math.sqrt(max(0.0, 1.0 - cosine * cosine))
+        phi = 2.0 * math.pi * float(random_values[1])
+        logarithm_argument = max(
+            float(random_values[2]) * float(random_values[3]),
+            sys.float_info.min,
+        )
+        energy = -math.log(logarithm_argument)
+        raw.append(
+            (
+                energy,
+                energy * sine * math.cos(phi),
+                energy * sine * math.sin(phi),
+                energy * cosine,
+            )
+        )
+    total = _sum_momenta(raw)
+    invariant = _minkowski_square(total)
+    if not math.isfinite(invariant) or invariant <= 0.0 or total[0] <= 0.0:
+        raise SampleError("RAMBO generated a non-timelike total momentum")
+    massless_scale = sqrt_s / math.sqrt(invariant)
+    beta_to_rest = (
+        -total[1] / total[0],
+        -total[2] / total[0],
+        -total[3] / total[0],
+    )
+    massless = tuple(
+        tuple(massless_scale * component for component in boosted)
+        for boosted in (_boost_to_rest(momentum, beta_to_rest) for momentum in raw)
+    )
+    spatial_norms = tuple(
+        math.sqrt(math.fsum(component * component for component in momentum[1:]))
+        for momentum in massless
+    )
+
+    def energy_sum(scale: float) -> float:
+        return math.fsum(
+            math.sqrt(mass * mass + (scale * spatial_norm) ** 2)
+            for mass, spatial_norm in zip(masses, spatial_norms, strict=True)
+        )
+
+    low = 0.0
+    high = 1.0
+    while energy_sum(high) < sqrt_s:
+        high *= 2.0
+        if not math.isfinite(high):
+            raise SampleError("RAMBO massive spatial scale did not converge")
+    for _ in range(128):
+        middle = 0.5 * (low + high)
+        if energy_sum(middle) > sqrt_s:
+            high = middle
+        else:
+            low = middle
+    spatial_scale = 0.5 * (low + high)
+    return tuple(
+        (
+            math.sqrt(mass * mass + (spatial_scale * spatial_norm) ** 2),
+            spatial_scale * momentum[1],
+            spatial_scale * momentum[2],
+            spatial_scale * momentum[3],
+        )
+        for momentum, mass, spatial_norm in zip(
+            massless,
+            masses,
+            spatial_norms,
+            strict=True,
+        )
+    )
+
+
+def _validated_source_kinematics(
+    point: Sequence[FourMomentum],
+) -> tuple[tuple[FourMomentum, FourMomentum], float, tuple[float, ...]]:
+    if len(point) < 4:
+        raise SampleError(
+            "correctness derivation requires two incoming and at least two "
+            "final-state particles"
+        )
+    incoming = (point[0], point[1])
+    outgoing = tuple(point[2:])
+    initial_total = _sum_momenta(incoming)
+    final_total = _sum_momenta(outgoing)
+    sqrt_s = initial_total[0]
+    if not math.isfinite(sqrt_s) or sqrt_s <= 0.0:
+        raise SampleError("validation point has an invalid center-of-mass energy")
+    for axis in range(1, 4):
+        if not _kinematically_close(
+            initial_total[axis],
+            0.0,
+            scale=sqrt_s,
+        ):
+            raise SampleError(
+                "validation point initial state is not in the center-of-mass frame"
+            )
+    for axis, (initial, final) in enumerate(
+        zip(initial_total, final_total, strict=True)
+    ):
+        if not _kinematically_close(initial, final, scale=sqrt_s):
+            raise SampleError(
+                "validation point violates four-momentum conservation "
+                f"on component {axis}"
+            )
+    masses = tuple(
+        _inferred_mass(momentum, label=f"validation particle {index}")
+        for index, momentum in enumerate(point)
+    )
+    final_masses = masses[2:]
+    threshold = math.fsum(final_masses)
+    if not threshold < sqrt_s:
+        raise SampleError(
+            "validation point is not strictly above its final-state mass threshold"
+        )
+    return incoming, sqrt_s, masses
+
+
+def _validated_generated_point(
+    point: Sequence[FourMomentum],
+    *,
+    sqrt_s: float,
+    masses: Sequence[float],
+) -> tuple[str, ...]:
+    if len(point) != len(masses):
+        raise SampleError("generated correctness point has the wrong multiplicity")
+    incoming_total = _sum_momenta(point[:2])
+    outgoing_total = _sum_momenta(point[2:])
+    for axis, (initial, final) in enumerate(
+        zip(incoming_total, outgoing_total, strict=True)
+    ):
+        if not _kinematically_close(initial, final, scale=sqrt_s):
+            raise SampleError(
+                "generated correctness point violates four-momentum conservation "
+                f"on component {axis}"
+            )
+    for index, (momentum, expected_mass) in enumerate(zip(point, masses, strict=True)):
+        observed_mass_squared = _validated_mass_squared(
+            momentum,
+            label=f"generated correctness particle {index}",
+        )
+        expected_mass_squared = expected_mass * expected_mass
+        on_shell_tolerance = (
+            4.0
+            * MASS_SQUARED_ROUNDOFF_ULPS
+            * sys.float_info.epsilon
+            * _kinematic_scale(
+                momentum[0] * momentum[0],
+                math.fsum(component * component for component in momentum[1:]),
+                expected_mass_squared,
+            )
+        )
+        if abs(observed_mass_squared - expected_mass_squared) > on_shell_tolerance:
+            raise SampleError(f"generated correctness particle {index} is off shell")
+    invariant_values: list[str] = []
+    squared_energy = sqrt_s * sqrt_s
+    for left in range(len(point)):
+        for right in range(left + 1, len(point)):
+            scaled = 2.0 * _minkowski_dot(point[left], point[right]) / squared_energy
+            if ((left < 2 and right >= 2) or (left >= 2 and right >= 2)) and (
+                not math.isfinite(scaled) or scaled <= MIN_SCALED_PAIR_INVARIANT
+            ):
+                raise SampleError(
+                    "generated correctness point violates the pair-invariant safety cut"
+                )
+            invariant_values.append(float(scaled).hex())
+    return tuple(invariant_values)
+
+
+def _numpy_derivation_identity(numpy_module: Any) -> dict[str, object]:
+    version = getattr(numpy_module, "__version__", None)
+    origin_value = getattr(numpy_module, "__file__", None)
+    if not isinstance(version, str) or not version:
+        raise SampleError("activated NumPy has no version identity")
+    if not isinstance(origin_value, str) or not origin_value:
+        raise SampleError("activated NumPy has no module origin")
+    try:
+        origin = Path(origin_value).resolve(strict=True)
+    except OSError as error:
+        raise SampleError("cannot resolve activated NumPy module origin") from error
+    if not origin.is_file():
+        raise SampleError("activated NumPy module origin is not a file")
+    bit_generator = numpy_module.random.default_rng(
+        CORRECTNESS_SEED_START
+    ).bit_generator
+    bit_generator_name = type(bit_generator).__name__
+    if bit_generator_name != "PCG64":
+        raise SampleError(
+            "correctness derivation contract requires NumPy default_rng PCG64, "
+            f"got {bit_generator_name!r}"
+        )
+    return {
+        "module": "numpy",
+        "version": version,
+        "origin_file_name": origin.name,
+        "origin_size_bytes": origin.stat().st_size,
+        "origin_sha256": _sha256_file(origin),
+        "random_generator": "default_rng",
+        "bit_generator": bit_generator_name,
+    }
+
+
+def _correctness_batch(
+    source: ValidationMomentaSource,
+) -> tuple[tuple[tuple[FourMomentum, ...], ...], dict[str, object]]:
+    """Derive eight deterministic, distinct and invariant-varied RAMBO events."""
+
+    if not source.points:
+        raise SampleError("artifact has no authenticated validation point")
+    incoming, sqrt_s, masses = _validated_source_kinematics(source.points[0])
+    numpy_module = importlib.import_module("numpy")
+    numpy_identity = _numpy_derivation_identity(numpy_module)
+    selected_points: list[tuple[FourMomentum, ...]] = []
+    selected_seeds: list[int] = []
+    point_sha256: list[str] = []
+    invariant_sha256: list[str] = []
+    observed_points: set[str] = set()
+    observed_invariants: set[str] = set()
+    attempts = 0
+    for offset in range(MAX_CORRECTNESS_SEED_ATTEMPTS):
+        attempts = offset + 1
+        seed = CORRECTNESS_SEED_START + offset
+        try:
+            outgoing = _massive_rambo_final_state(
+                len(masses) - 2,
+                sqrt_s=sqrt_s,
+                masses=masses[2:],
+                seed=seed,
+                numpy_module=numpy_module,
+            )
+            point = (*incoming, *outgoing)
+            invariant_values = _validated_generated_point(
+                point,
+                sqrt_s=sqrt_s,
+                masses=masses,
+            )
+        except (ArithmeticError, SampleError, ValueError):
+            continue
+        point_digest = _canonical_sha256(point)
+        invariant_digest = _canonical_sha256(invariant_values)
+        if point_digest in observed_points or invariant_digest in observed_invariants:
+            continue
+        observed_points.add(point_digest)
+        observed_invariants.add(invariant_digest)
+        selected_points.append(point)
+        selected_seeds.append(seed)
+        point_sha256.append(point_digest)
+        invariant_sha256.append(invariant_digest)
+        if len(selected_points) == MAX_CORRECTNESS_POINTS:
+            break
+    if len(selected_points) != MIN_CORRECTNESS_POINTS:
+        raise SampleError(
+            "could not derive exactly "
+            f"{MIN_CORRECTNESS_POINTS} safe, distinct, invariant-varied "
+            "correctness points within "
+            f"{MAX_CORRECTNESS_SEED_ATTEMPTS} deterministic seeds"
+        )
+    batch = tuple(selected_points)
+    derivation: dict[str, object] = {
+        "kind": CORRECTNESS_POINT_DERIVATION_KIND,
+        "schema_version": CORRECTNESS_POINT_DERIVATION_SCHEMA_VERSION,
+        "contract": CORRECTNESS_POINT_DERIVATION_CONTRACT,
+        "source_validation": dict(source.identity),
+        "numpy": numpy_identity,
+        "sqrt_s_f64_hex": sqrt_s.hex(),
+        "external_mass_f64_hex": [mass.hex() for mass in masses],
+        "final_state_mass_f64_hex": [mass.hex() for mass in masses[2:]],
+        "seed_start": CORRECTNESS_SEED_START,
+        "seed_attempt_limit": MAX_CORRECTNESS_SEED_ATTEMPTS,
+        "attempt_count": attempts,
+        "selected_seeds": selected_seeds,
+        "point_sha256": point_sha256,
+        "invariant_sha256": invariant_sha256,
+        "batch_sha256": _canonical_sha256(batch),
+    }
+    derivation["sha256"] = _canonical_sha256(derivation)
+    return batch, derivation
+
+
+def _load_runtime(
+    artifact: Path,
+    *,
+    process: str,
+) -> tuple[object, dict[str, object]]:
+    try:
+        distribution = importlib.metadata.distribution("pyamplicol")
+    except importlib.metadata.PackageNotFoundError as error:
+        raise SampleError(
+            "the selected interpreter has no pyamplicol installation"
+        ) from error
+    native_paths = [
+        Path(str(distribution.locate_file(entry)))
+        for entry in distribution.files or ()
+        if Path(str(entry)).name.startswith("_rusticol.")
+        and Path(str(entry)).suffix in {".so", ".pyd", ".dylib"}
+    ]
+    if len(native_paths) != 1:
+        raise SampleError(
+            "the selected pyamplicol installation must contain exactly one "
+            f"native Rusticol module, found {len(native_paths)}"
+        )
+    native_path = native_paths[0].resolve(strict=True)
+    specification = importlib.util.spec_from_file_location("_rusticol", native_path)
+    if specification is None or specification.loader is None:
+        raise SampleError(f"cannot load native Rusticol module: {native_path}")
+    native_module = importlib.util.module_from_spec(specification)
+    specification.loader.exec_module(native_module)
+    runtime_type = getattr(native_module, "Runtime", None)
+    loader = getattr(runtime_type, "load", None)
+    if not callable(loader):
+        raise SampleError("native Rusticol module has no Runtime.load operation")
+    runtime = loader(
+        artifact,
+        process=process,
+        model_parameters=None,
+        mute_warnings=False,
+    )
+    result: dict[str, object] = {
+        "python": platform.python_version(),
+        "platform": platform.platform(),
+        "executable": _path_identity(Path(sys.executable)),
+        "package_version": distribution.version,
+        "native_module": _path_identity(native_path),
+    }
+    build_info_entries = [
+        Path(str(distribution.locate_file(entry)))
+        for entry in distribution.files or ()
+        if str(entry).endswith("pyamplicol/_build_info.json")
+    ]
+    if len(build_info_entries) == 1:
+        build_info_path = build_info_entries[0].resolve(strict=True)
+        build_info = json.loads(build_info_path.read_text(encoding="utf-8"))
+        if not isinstance(build_info, dict):
+            raise SampleError("installed pyamplicol build provenance is not an object")
+        result["build_info"] = {
+            **_path_identity(build_info_path),
+            "payload": build_info,
+        }
+        native_digest_operation = getattr(
+            native_module,
+            "native_build_inputs_sha256",
+            None,
+        )
+        if callable(native_digest_operation):
+            native_digest = native_digest_operation()
+            result["native_build_inputs_sha256"] = native_digest
+            expected_digest = build_info.get("native_build_inputs_sha256")
+            if isinstance(expected_digest, str) and native_digest != expected_digest:
+                raise SampleError(
+                    "installed native Rusticol module does not match build provenance"
+                )
+    native_version_operation = getattr(native_module, "package_version", None)
+    if callable(native_version_operation):
+        result["native_package_version"] = native_version_operation()
+    return runtime, result
+
+
+def _load_public_runtime(artifact: Path, *, process: str) -> object:
+    """Load the wheel's public facade for correctness-only exact evaluation."""
+
+    package = importlib.import_module("pyamplicol")
+    runtime_type = getattr(package, "Runtime", None)
+    loader = getattr(runtime_type, "load", None)
+    if not callable(loader):
+        raise SampleError("selected pyamplicol package has no public Runtime.load")
+    return loader(
+        artifact,
+        process=process,
+        model_parameters=None,
+        mute_warnings=False,
+    )
+
+
+def _json_object(path: Path, *, label: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise SampleError(f"cannot read {label}: {path}") from error
+    if not isinstance(payload, dict):
+        raise SampleError(f"{label} must be a JSON object: {path}")
+    return payload
+
+
+def _artifact_process(
+    manifest: Mapping[str, Any],
+    *,
+    process: str,
+) -> Mapping[str, Any]:
+    records = manifest.get("processes")
+    if not isinstance(records, list):
+        raise SampleError("artifact manifest has no process records")
+    normalized = " ".join(process.split())
+    matches = [
+        record
+        for record in records
+        if isinstance(record, Mapping)
+        and (
+            record.get("id") == process
+            or (
+                isinstance(record.get("expression"), str)
+                and " ".join(str(record["expression"]).split()) == normalized
+            )
+        )
+    ]
+    if len(matches) != 1:
+        raise SampleError(
+            f"artifact must contain exactly one process matching {process!r}"
+        )
+    return matches[0]
+
+
+def _validation_momenta(
+    artifact: Path,
+    *,
+    process: str,
+) -> ValidationMomentaSource:
+    try:
+        artifact_root = artifact.resolve(strict=True)
+    except OSError as error:
+        raise SampleError(f"cannot resolve artifact root: {artifact}") from error
+    manifest = _json_object(artifact_root / "artifact.json", label="artifact manifest")
+    process_record = _artifact_process(manifest, process=process)
+    process_id = process_record.get("id")
+    if not isinstance(process_id, str) or not process_id:
+        raise SampleError("artifact process has no stable ID")
+    process_expression = process_record.get("expression")
+    if not isinstance(process_expression, str) or not process_expression.strip():
+        raise SampleError("artifact process has no stable expression")
+    expected_pdgs = process_record.get("external_pdgs")
+    if (
+        not isinstance(expected_pdgs, list)
+        or len(expected_pdgs) < 4
+        or any(
+            isinstance(pdg, bool) or not isinstance(pdg, int) for pdg in expected_pdgs
+        )
+    ):
+        raise SampleError(
+            "artifact process must declare two incoming and at least two "
+            "final-state integer PDGs"
+        )
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise SampleError("artifact manifest has no payload inventory")
+    candidates = [
+        payload
+        for payload in payloads
+        if isinstance(payload, Mapping)
+        and payload.get("role") == "validation-momenta"
+        and payload.get("process_id") == process_id
+    ]
+    if len(candidates) != 1 or not isinstance(candidates[0].get("path"), str):
+        raise SampleError(
+            f"artifact process {process_id!r} has no unique validation momentum payload"
+        )
+    payload_record = candidates[0]
+    payload_path_value = payload_record["path"]
+    assert isinstance(payload_path_value, str)
+    declared_sha256 = payload_record.get("sha256")
+    declared_size = payload_record.get("size_bytes")
+    if (
+        not isinstance(declared_sha256, str)
+        or len(declared_sha256) != 64
+        or any(character not in "0123456789abcdef" for character in declared_sha256)
+        or isinstance(declared_size, bool)
+        or not isinstance(declared_size, int)
+        or declared_size < 0
+    ):
+        raise SampleError("validation momentum payload has no valid digest identity")
+    try:
+        validation_path = (artifact_root / payload_path_value).resolve(strict=True)
+        validation_path.relative_to(artifact_root)
+    except (OSError, ValueError) as error:
+        raise SampleError("validation momentum payload path is invalid") from error
+    if not validation_path.is_file():
+        raise SampleError("validation momentum payload is not a regular file")
+    observed_size = validation_path.stat().st_size
+    observed_sha256 = _sha256_file(validation_path)
+    if observed_size != declared_size or observed_sha256 != declared_sha256:
+        raise SampleError(
+            "validation momentum payload does not match its manifest digest"
+        )
+    validation = _json_object(
+        validation_path,
+        label="validation momenta",
+    )
+    if (
+        validation.get("kind") != "pyamplicol-rusticol-validation-momenta"
+        or validation.get("schema_version") != 1
+        or validation.get("process_id") != process_id
+        or not isinstance(validation.get("process"), str)
+        or " ".join(str(validation["process"]).split())
+        != " ".join(process_expression.split())
+    ):
+        raise SampleError("validation momentum payload identity is invalid")
+    points = validation.get("points")
+    if validation.get("available") is not True or not isinstance(points, list):
+        raise SampleError("artifact has no deterministic validation momenta")
+    result: list[tuple[FourMomentum, ...]] = []
+    for point in points:
+        if not isinstance(point, list):
+            raise SampleError("validation momentum point is invalid")
+        vectors: list[tuple[float, float, float, float]] = []
+        pdgs: list[int] = []
+        for particle in point:
+            if not isinstance(particle, Mapping):
+                raise SampleError("validation momentum particle is invalid")
+            raw_momentum = particle.get("momentum")
+            if not isinstance(raw_momentum, list) or len(raw_momentum) != 4:
+                raise SampleError("validation four-momentum is invalid")
+            raw_pdg = particle.get("pdg")
+            if isinstance(raw_pdg, bool) or not isinstance(raw_pdg, int):
+                raise SampleError("validation momentum PDG is invalid")
+            try:
+                vector = tuple(float(component) for component in raw_momentum)
+            except (TypeError, ValueError) as error:
+                raise SampleError("validation momentum particle is invalid") from error
+            if len(vector) != 4 or not all(math.isfinite(value) for value in vector):
+                raise SampleError("validation four-momentum is non-finite")
+            vectors.append((vector[0], vector[1], vector[2], vector[3]))
+            pdgs.append(raw_pdg)
+        if pdgs != expected_pdgs:
+            raise SampleError("validation momentum PDG order does not match artifact")
+        result.append(tuple(vectors))
+    if not result:
+        raise SampleError("artifact validation momentum payload is empty")
+    source_point_sha256 = _canonical_sha256(result[0])
+    return ValidationMomentaSource(
+        points=tuple(result),
+        identity={
+            "file_sha256": observed_sha256,
+            "canonical_sha256": _canonical_sha256(validation),
+            "size_bytes": observed_size,
+            "process_id": process_id,
+            "process_expression": " ".join(process_expression.split()),
+            "external_pdgs": list(expected_pdgs),
+            "point_count": len(result),
+            "selected_point_index": 0,
+            "selected_point_sha256": source_point_sha256,
+        },
+    )
+
+
+def _resolve_color_flows(
+    artifact: Path,
+    *,
+    process: str,
+    requested: Sequence[str],
+) -> tuple[str, ...]:
+    if not requested:
+        return ()
+    manifest = _json_object(artifact / "artifact.json", label="artifact manifest")
+    process_record = _artifact_process(manifest, process=process)
+    physics_path = process_record.get("physics_path")
+    if not isinstance(physics_path, str) or not physics_path:
+        raise SampleError("artifact process has no runtime physics payload")
+    physics = _json_object(
+        artifact / physics_path,
+        label="runtime physics",
+    )
+    components = physics.get("color_components")
+    if not isinstance(components, list):
+        raise SampleError("runtime physics has no color component inventory")
+    available = tuple(
+        str(component["id"])
+        for component in components
+        if isinstance(component, Mapping) and isinstance(component.get("id"), str)
+    )
+    resolved: list[str] = []
+    for value in requested:
+        if value in available:
+            resolved.append(value)
+            continue
+        try:
+            ordinal = int(value, 10)
+        except ValueError:
+            resolved.append(value)
+            continue
+        if str(ordinal) != value.strip() or ordinal < 1 or ordinal > len(available):
+            raise SampleError(
+                f"color-flow ordinal {value!r} is out of range; "
+                f"choose 1..{len(available)} or a stable color component ID"
+            )
+        resolved.append(available[ordinal - 1])
+    return tuple(resolved)
+
+
+def _resolve_helicities(
+    artifact: Path,
+    *,
+    process: str,
+    requested: Sequence[str],
+) -> tuple[str, ...]:
+    if not requested:
+        return ()
+    manifest = _json_object(artifact / "artifact.json", label="artifact manifest")
+    process_record = _artifact_process(manifest, process=process)
+    physics_path = process_record.get("physics_path")
+    if not isinstance(physics_path, str) or not physics_path:
+        raise SampleError("artifact process has no runtime physics payload")
+    physics = _json_object(artifact / physics_path, label="runtime physics")
+    helicities = physics.get("helicities")
+    if not isinstance(helicities, list):
+        raise SampleError("runtime physics has no helicity inventory")
+    available = tuple(
+        str(helicity["id"])
+        for helicity in helicities
+        if isinstance(helicity, Mapping)
+        and isinstance(helicity.get("id"), str)
+        and helicity.get("structural_zero") is not True
+    )
+    resolved: list[str] = []
+    for value in requested:
+        if value in available:
+            resolved.append(value)
+            continue
+        try:
+            ordinal = int(value, 10)
+        except ValueError:
+            resolved.append(value)
+            continue
+        if str(ordinal) != value.strip() or ordinal < 1 or ordinal > len(available):
+            raise SampleError(
+                f"non-structural-zero helicity ordinal {value!r} is out of range; "
+                f"choose 1..{len(available)} or a stable helicity ID"
+            )
+        resolved.append(available[ordinal - 1])
+    return tuple(resolved)
+
+
+def _execution_mode(runtime: object) -> str:
+    metadata_operation = getattr(runtime, "metadata_json", None)
+    if not callable(metadata_operation):
+        raise SampleError("native runtime has no metadata operation")
+    try:
+        metadata_payload = json.loads(metadata_operation())
+    except (TypeError, json.JSONDecodeError) as error:
+        raise SampleError("native runtime metadata is invalid") from error
+    if not isinstance(metadata_payload, Mapping):
+        raise SampleError("native runtime metadata is not an object")
+    mode = metadata_payload.get("execution_mode")
+    if not isinstance(mode, str):
+        raise SampleError("native runtime metadata has no execution mode")
+    return mode
+
+
+def _calibrate_repetitions(
+    timer: Any,
+    batch: tuple[object, ...],
+    *,
+    target_seconds: float,
+    sample_count: int,
+    selector_arguments: Mapping[str, object],
+) -> tuple[int, dict[str, object]]:
+    target_per_block = target_seconds / sample_count
+    repetitions = 1
+    observed = _finite_positive(
+        timer(batch, repetitions, **selector_arguments),
+        label="native wall calibration duration",
+    )
+    blocks = [(repetitions, observed)]
+    for _ in range(MAX_CALIBRATION_BLOCKS):
+        estimate = math.ceil(repetitions * target_per_block / observed)
+        candidate = min(max(estimate, 1), MAX_REPETITIONS)
+        if candidate == repetitions:
+            break
+        repetitions = candidate
+        observed = _finite_positive(
+            timer(batch, repetitions, **selector_arguments),
+            label="native wall calibration duration",
+        )
+        blocks.append((repetitions, observed))
+        ratio = observed / target_per_block
+        if 0.75 <= ratio <= 1.5:
+            break
+    return repetitions, {
+        "target_seconds_per_block": target_per_block,
+        "block_count": len(blocks),
+        "evaluation_count": sum(block_repetitions for block_repetitions, _ in blocks),
+        "blocks": [
+            {
+                "repetitions": block_repetitions,
+                "duration_seconds": duration,
+            }
+            for block_repetitions, duration in blocks
+        ],
+    }
+
+
+def _profile_components(
+    profile: Mapping[str, object],
+    *,
+    evaluated_points: int,
+    execution_mode: str,
+    evaluator_timing_available: bool,
+) -> tuple[float, float | None]:
+    observed_mode = profile.get("execution_mode")
+    if observed_mode not in (None, execution_mode):
+        raise SampleError(
+            "native repeated profile used execution mode "
+            f"{observed_mode!r}, expected {execution_mode!r}"
+        )
+    wall = _finite_positive(
+        profile.get("wall_time_s"),
+        label="native repeated profile wall_time_s",
+    )
+    if not evaluator_timing_available:
+        if (
+            profile.get("phase_timing_scope") != ARENA_PHASE_TIMING_SCOPE
+            or profile.get("evaluator_timing_available") is not False
+        ):
+            raise SampleError(
+                "warmed Arena profile did not authenticate coarse-boundary-only timing"
+            )
+        return wall / evaluated_points, None
+    stage = _finite_nonnegative(
+        profile.get("stage_evaluator_call_time_s"),
+        label="native repeated profile stage_evaluator_call_time_s",
+    )
+    if execution_mode == "eager":
+        evaluator = stage
+    else:
+        amplitude = _finite_nonnegative(
+            profile.get("amplitude_evaluator_call_time_s"),
+            label="native repeated profile amplitude_evaluator_call_time_s",
+        )
+        evaluator = stage + amplitude
+    return wall / evaluated_points, evaluator / evaluated_points
+
+
+def _profile_operation(runtime: object, *, protocol: str) -> ProfileOperation:
+    arena_profiler = getattr(runtime, "_profile_arena_repeated", None)
+    if protocol == ARENA_PROFILE_PROTOCOL:
+        if not callable(arena_profiler):
+            raise SampleError("Arena profile protocol requires _profile_arena_repeated")
+        return ProfileOperation(
+            operation=arena_profiler,
+            sample_pass=ARENA_PROFILE_ATTRIBUTION_SAMPLE_PASS,
+            boundary=ARENA_PROFILE_BOUNDARY,
+            borrowed_flat_input=True,
+            preallocated_output=True,
+            phase_timing_scope=ARENA_PHASE_TIMING_SCOPE,
+            evaluator_timing_available=False,
+        )
+    if protocol != FROZEN_BASELINE_PROFILE_PROTOCOL:
+        raise SampleError(f"unsupported profile protocol: {protocol!r}")
+    if callable(arena_profiler):
+        raise SampleError(
+            "frozen pre-Arena profile protocol refuses an Arena-capable runtime"
+        )
+    legacy_profiler = getattr(runtime, "profile_repeated", None)
+    if callable(legacy_profiler):
+        return ProfileOperation(
+            operation=legacy_profiler,
+            sample_pass=FROZEN_BASELINE_PROFILE_ATTRIBUTION_SAMPLE_PASS,
+            boundary=FROZEN_BASELINE_PROFILE_BOUNDARY,
+            borrowed_flat_input=False,
+            preallocated_output=False,
+            phase_timing_scope=FROZEN_BASELINE_PHASE_TIMING_SCOPE,
+            evaluator_timing_available=True,
+        )
+    raise SampleError("frozen pre-Arena profile protocol requires profile_repeated")
+
+
+def _complex_pair(value: object, *, label: str) -> list[float]:
+    if isinstance(value, bool):
+        raise SampleError(f"{label} must be numeric")
+    try:
+        converted = complex(value)
+    except (TypeError, ValueError, OverflowError) as error:
+        raise SampleError(f"{label} must be numeric") from error
+    if not math.isfinite(converted.real) or not math.isfinite(converted.imag):
+        raise SampleError(f"{label} must be finite")
+    return [float(converted.real), float(converted.imag)]
+
+
+def _resolved_values_json(value: object, *, label: str) -> object:
+    if isinstance(value, Sequence) and not isinstance(
+        value,
+        (str, bytes, bytearray),
+    ):
+        return [
+            _resolved_values_json(entry, label=f"{label}[{index}]")
+            for index, entry in enumerate(value)
+        ]
+    return _complex_pair(value, label=label)
+
+
+def _warmed_numerical_result(
+    evaluator: Any,
+    resolved_evaluator: Any,
+    validation_batch: tuple[object, ...],
+    *,
+    selector_arguments: Mapping[str, object],
+) -> dict[str, object]:
+    selector_values: dict[str, list[str]] = {}
+    for key in ("helicities", "color_flows"):
+        raw_selectors = selector_arguments.get(key)
+        if raw_selectors is None:
+            selector_values[key] = []
+        elif (
+            isinstance(raw_selectors, Sequence)
+            and not isinstance(
+                raw_selectors,
+                (str, bytes, bytearray),
+            )
+            and all(isinstance(value, str) for value in raw_selectors)
+        ):
+            selector_values[key] = list(raw_selectors)
+        else:
+            raise SampleError(f"native warmed evaluation has invalid {key}")
+    raw_values = evaluator(validation_batch, **selector_arguments)
+    if not isinstance(raw_values, Sequence) or isinstance(
+        raw_values,
+        (str, bytes, bytearray),
+    ):
+        raise SampleError("native warmed evaluation did not return a value sequence")
+    values: list[float] = []
+    for raw_value in raw_values:
+        real, imaginary = _complex_pair(
+            raw_value,
+            label="native warmed evaluation value",
+        )
+        if not math.isclose(imaginary, 0.0, rel_tol=0.0, abs_tol=1.0e-15):
+            raise SampleError("native warmed evaluation returned a complex total")
+        values.append(real)
+    if len(values) != len(validation_batch):
+        raise SampleError(
+            "native warmed evaluation returned an unexpected number of values"
+        )
+    resolved = resolved_evaluator(validation_batch, **selector_arguments)
+    resolved_total_operation = getattr(resolved, "total", None)
+    if not callable(resolved_total_operation):
+        raise SampleError("native resolved evaluation has no total operation")
+    raw_resolved_totals = resolved_total_operation()
+    if not isinstance(raw_resolved_totals, Sequence) or isinstance(
+        raw_resolved_totals,
+        (str, bytes, bytearray),
+    ):
+        raise SampleError("native resolved evaluation returned invalid totals")
+    resolved_totals = [
+        _complex_pair(value, label="native resolved total")
+        for value in raw_resolved_totals
+    ]
+    if len(resolved_totals) != len(values):
+        raise SampleError("native resolved total count differs from evaluate()")
+    for value, (resolved_real, resolved_imag) in zip(
+        values,
+        resolved_totals,
+        strict=True,
+    ):
+        if not math.isclose(
+            value,
+            resolved_real,
+            rel_tol=1.0e-12,
+            abs_tol=1.0e-15,
+        ) or not math.isclose(resolved_imag, 0.0, rel_tol=0.0, abs_tol=1.0e-15):
+            raise SampleError(
+                "native evaluate() result disagrees with evaluate_resolved().total()"
+            )
+    resolved_values = getattr(resolved, "values", None)
+    resolved_shape = getattr(resolved, "shape", None)
+    helicity_ids = getattr(resolved, "helicity_ids", None)
+    color_ids = getattr(resolved, "color_ids", None)
+    if (
+        not isinstance(resolved_shape, Sequence)
+        or isinstance(resolved_shape, (str, bytes, bytearray))
+        or not all(isinstance(value, int) and value >= 0 for value in resolved_shape)
+        or not isinstance(helicity_ids, Sequence)
+        or isinstance(helicity_ids, (str, bytes, bytearray))
+        or not all(isinstance(value, str) for value in helicity_ids)
+        or not isinstance(color_ids, Sequence)
+        or isinstance(color_ids, (str, bytes, bytearray))
+        or not all(isinstance(value, str) for value in color_ids)
+    ):
+        raise SampleError("native resolved evaluation metadata is invalid")
+    return {
+        "precision": selector_arguments.get("precision"),
+        "point_count": len(validation_batch),
+        "distinct_point_count": len(validation_batch),
+        "point_sha256": [_canonical_sha256(point) for point in validation_batch],
+        "batch_sha256": _canonical_sha256(validation_batch),
+        "values_f64": values,
+        "values_f64_hex": [value.hex() for value in values],
+        "helicities": selector_values["helicities"],
+        "color_flows": selector_values["color_flows"],
+        "resolved": {
+            "shape": list(resolved_shape),
+            "helicity_ids": list(helicity_ids),
+            "color_ids": list(color_ids),
+            "totals_complex": resolved_totals,
+            "values_complex": _resolved_values_json(
+                resolved_values,
+                label="native resolved value",
+            ),
+        },
+    }
+
+
+def sample(arguments: argparse.Namespace) -> dict[str, object]:
+    dependency_site_identity = _activate_dependency_site(
+        getattr(arguments, "dependency_site", None)
+    )
+    artifact = arguments.artifact.expanduser().resolve(strict=True)
+    load_started = time.perf_counter()
+    runtime, runtime_identity = _load_runtime(
+        artifact,
+        process=arguments.process,
+    )
+    cold_load_seconds = time.perf_counter() - load_started
+    execution_mode = getattr(arguments, "execution_mode", "compiled")
+    if execution_mode not in EXECUTION_MODES:
+        raise SampleError(f"unsupported execution mode: {execution_mode!r}")
+    observed_execution_mode = _execution_mode(runtime)
+    if observed_execution_mode != execution_mode:
+        raise SampleError(
+            "regression sampling requires a "
+            f"{execution_mode} runtime, got {observed_execution_mode!r}"
+        )
+    runtime_identity["dependency_site"] = dependency_site_identity
+    timer = getattr(runtime, "_benchmark_f64_wall_time", None)
+    profile_protocol = getattr(arguments, "profile_protocol", None)
+    profile_operation = _profile_operation(runtime, protocol=profile_protocol)
+    profiler = profile_operation.operation
+    evaluate_once = getattr(runtime, "evaluate", None)
+    evaluate_resolved_once = getattr(runtime, "evaluate_resolved", None)
+    if not callable(timer):
+        raise SampleError("native unprofiled wall timer is unavailable")
+    if not callable(evaluate_once):
+        raise SampleError("native f64 evaluator is unavailable")
+    if not callable(evaluate_resolved_once):
+        raise SampleError("native resolved f64 evaluator is unavailable")
+    validation_source = _validation_momenta(artifact, process=arguments.process)
+    batch = _benchmark_batch(validation_source.points, arguments.batch_size)
+    correctness_batch, correctness_point_derivation = _correctness_batch(
+        validation_source
+    )
+    resolved_helicities = _resolve_helicities(
+        artifact,
+        process=arguments.process,
+        requested=arguments.helicity,
+    )
+    helicities = resolved_helicities or None
+    resolved_color_flows = _resolve_color_flows(
+        artifact,
+        process=arguments.process,
+        requested=arguments.color_flow,
+    )
+    color_flows = resolved_color_flows or None
+    selector_arguments: dict[str, object] = {
+        "helicities": helicities,
+        "color_flows": color_flows,
+        "precision": 16,
+    }
+    profile_arguments = {**selector_arguments, "include_values": False}
+
+    for _ in range(arguments.warmup_runs):
+        _finite_positive(
+            timer(batch, 1, **selector_arguments),
+            label="native wall warmup duration",
+        )
+        warmup_profile = profiler(batch, 1, **profile_arguments)
+        if not isinstance(warmup_profile, Mapping):
+            raise SampleError("native repeated warmup profile is not a mapping")
+
+    repetitions, calibration = _calibrate_repetitions(
+        timer,
+        batch,
+        target_seconds=arguments.target_runtime,
+        sample_count=arguments.minimum_samples,
+        selector_arguments=selector_arguments,
+    )
+    evaluated_points_per_block = repetitions * len(batch)
+    headline_samples: list[float] = []
+    profiled_wall_samples: list[float] = []
+    evaluator_samples: list[float] = []
+    raw_profiles: list[object] = []
+    headline_durations: list[float] = []
+    attribution_elapsed = 0.0
+    for _ in range(arguments.minimum_samples):
+        duration = _finite_positive(
+            timer(batch, repetitions, **selector_arguments),
+            label="native headline wall duration",
+        )
+        headline_durations.append(duration)
+        headline_samples.append(duration / evaluated_points_per_block)
+
+        profile_started = time.perf_counter()
+        raw_profile = profiler(batch, repetitions, **profile_arguments)
+        attribution_elapsed += time.perf_counter() - profile_started
+        if not isinstance(raw_profile, Mapping):
+            raise SampleError("native repeated profile is not a mapping")
+        profile_wall, evaluator_time = _profile_components(
+            raw_profile,
+            evaluated_points=evaluated_points_per_block,
+            execution_mode=execution_mode,
+            evaluator_timing_available=profile_operation.evaluator_timing_available,
+        )
+        profiled_wall_samples.append(profile_wall)
+        if evaluator_time is not None:
+            evaluator_samples.append(evaluator_time)
+        raw_profiles.append(_json_value(raw_profile))
+
+    numerical_result = _warmed_numerical_result(
+        evaluate_once,
+        evaluate_resolved_once,
+        correctness_batch,
+        selector_arguments=selector_arguments,
+    )
+    precision32_result = None
+    if getattr(arguments, "include_precision32", False):
+        public_runtime = _load_public_runtime(
+            artifact,
+            process=arguments.process,
+        )
+        public_evaluate = getattr(public_runtime, "evaluate", None)
+        public_evaluate_resolved = getattr(public_runtime, "evaluate_resolved", None)
+        if not callable(public_evaluate) or not callable(public_evaluate_resolved):
+            raise SampleError(
+                "public runtime has no precision-32 evaluation operations"
+            )
+        precision32_result = _warmed_numerical_result(
+            public_evaluate,
+            public_evaluate_resolved,
+            correctness_batch,
+            selector_arguments={**selector_arguments, "precision": 32},
+        )
+    sample_count = len(headline_samples)
+    measured_evaluations = sample_count * repetitions
+    measured_points = measured_evaluations * len(batch)
+    headline_mean = float(statistics.fmean(headline_samples))
+    evaluator_mean = (
+        float(statistics.fmean(evaluator_samples)) if evaluator_samples else None
+    )
+    timing_breakdown = {
+        "sample_count": sample_count,
+        "execution_mode": execution_mode,
+        "wall_time": _component(profiled_wall_samples),
+        "evaluator_call_time": (
+            _component(evaluator_samples) if evaluator_samples else None
+        ),
+        "raw_profile_samples": raw_profiles,
+    }
+    return {
+        "kind": RESULT_KIND,
+        "schema_version": SCHEMA_VERSION,
+        "wall_time_per_point": headline_mean,
+        "wall_time_samples_seconds_per_point": headline_samples,
+        "sample_count": sample_count,
+        "repetitions_per_sample": repetitions,
+        "interrupted": False,
+        "uncertainty": _statistics(headline_samples),
+        "evaluator_time_per_point": evaluator_mean,
+        "evaluator_uncertainty": (
+            _statistics(evaluator_samples) if evaluator_samples else None
+        ),
+        "correctness_point_derivation": correctness_point_derivation,
+        "warmed_numerical_result": numerical_result,
+        "precision32_numerical_result": precision32_result,
+        "cold_load_seconds": cold_load_seconds,
+        "timing_breakdown": timing_breakdown,
+        "environment": {
+            "wall_time_source": NATIVE_WALL_TIME_SOURCE,
+            "wall_time_sample_pass": NATIVE_WALL_TIME_SAMPLE_PASS,
+            "evaluator_time_sample_pass": profile_operation.sample_pass,
+            "timing_breakdown_sample_pass": profile_operation.sample_pass,
+            "profile_attribution_boundary": profile_operation.boundary,
+            "profile_attribution_borrowed_flat_input": (
+                profile_operation.borrowed_flat_input
+            ),
+            "profile_attribution_preallocated_output": (
+                profile_operation.preallocated_output
+            ),
+            "profile_attribution_phase_timing_scope": (
+                profile_operation.phase_timing_scope
+            ),
+            "profile_attribution_evaluator_timing_available": (
+                profile_operation.evaluator_timing_available
+            ),
+            "profile_protocol": profile_protocol,
+            "timing_sample_contract": PAIRED_TIMING_SAMPLE_CONTRACT,
+            "profile_attribution_paired_with_headline": True,
+            "profile_attribution_identical_batch": True,
+            "profile_attribution_identical_repetitions": True,
+            "execution_mode": execution_mode,
+            "batch_size": len(batch),
+            "precision": 16,
+            "interrupted": False,
+            "completed_sample_count": sample_count,
+            "planned_sample_count": arguments.minimum_samples,
+            "measured_evaluation_count": measured_evaluations,
+            "measured_point_count": measured_points,
+            "native_profile_sample_count": len(raw_profiles),
+            "native_profile_sample_limit": arguments.minimum_samples,
+            "native_profile_repetitions_per_sample": repetitions,
+            "native_profile_points_per_sample": evaluated_points_per_block,
+            "native_profile_calls_per_block": 1.0,
+            "profile_attribution_evaluation_count": measured_evaluations,
+            "profile_attribution_point_count": measured_points,
+            "elapsed_seconds": sum(headline_durations),
+            "headline_block_durations_seconds": headline_durations,
+            "profile_attribution_elapsed_seconds": attribution_elapsed,
+            "batch_sha256": _canonical_sha256(batch),
+            "helicities": list(helicities or ()),
+            "color_flows": list(color_flows or ()),
+            "calibration": calibration,
+            "runtime_identity": runtime_identity,
+        },
+    }
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("artifact", type=Path)
+    result.add_argument("--process", required=True)
+    result.add_argument(
+        "--execution-mode",
+        choices=EXECUTION_MODES,
+        default="compiled",
+    )
+    result.add_argument(
+        "--profile-protocol",
+        choices=PROFILE_PROTOCOLS,
+        required=True,
+        help=(
+            "require the current Arena profiler or explicitly measure the "
+            "frozen pre-Arena baseline; no automatic fallback is allowed"
+        ),
+    )
+    result.add_argument(
+        "--dependency-site",
+        type=Path,
+        help=(
+            "append a dependency-only site after the measured installation; "
+            "the helper fails if this changes the pyamplicol package origin"
+        ),
+    )
+    result.add_argument("--target-runtime", type=_positive_float, required=True)
+    result.add_argument("--batch-size", type=_positive_int, required=True)
+    result.add_argument("--minimum-samples", type=_at_least_five, required=True)
+    result.add_argument("--warmup-runs", type=_positive_int, required=True)
+    result.add_argument(
+        "--include-precision32",
+        action="store_true",
+        help="capture one correctness-only precision-32 numerical result",
+    )
+    result.add_argument("--helicity", action="append", default=[])
+    result.add_argument("--color-flow", action="append", default=[])
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    if tuple(sys.argv[1:] if argv is None else argv) == ("--installation-identity",):
+        try:
+            identity = _installed_distribution_identity()
+        except (OSError, SampleError, ValueError) as error:
+            print(f"compiled-mode-sample: {error}", file=sys.stderr)
+            return 2
+        print(json.dumps(identity, indent=2, sort_keys=True, allow_nan=False))
+        return 0
+    arguments = parser().parse_args(argv)
+    try:
+        result = sample(arguments)
+    except (OSError, SampleError, ValueError) as error:
+        print(f"compiled-mode-sample: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, indent=2, sort_keys=True, allow_nan=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/eager_artifact_compare.py b/pyamplicol/tools/developer/eager_artifact_compare.py
new file mode 100644
index 0000000000..6cb9c1364c
--- /dev/null
+++ b/pyamplicol/tools/developer/eager_artifact_compare.py
@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Compare compiled and eager artifacts in an isolated Symbolica process."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+
+class ComparisonError(RuntimeError):
+    """Raised when comparison inputs or results are malformed."""
+
+
+def _validation_momenta(
+    artifact: Path, process_id: str
+) -> tuple[tuple[tuple[float, ...], ...], ...]:
+    path = artifact / "processes" / process_id / "validation-momenta.json"
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        points = payload["points"]
+        return tuple(
+            tuple(
+                tuple(float(component) for component in particle["momentum"])
+                for particle in point
+            )
+            for point in points
+        )
+    except (OSError, KeyError, TypeError, ValueError, json.JSONDecodeError) as error:
+        raise ComparisonError(f"invalid validation momenta at {path}") from error
+
+
+def _relative_difference(left: complex, right: complex) -> float:
+    return abs(left - right) / max(abs(left), abs(right), 1.0e-300)
+
+
+def _complex_comparison(left: object, right: object) -> dict[str, object]:
+    left_value = complex(left)
+    right_value = complex(right)
+    absolute = abs(left_value - right_value)
+    relative = _relative_difference(left_value, right_value)
+    return {
+        "left": [left_value.real, left_value.imag],
+        "right": [right_value.real, right_value.imag],
+        "absolute_difference": absolute,
+        "relative_difference": relative,
+        "passes": absolute <= 1.0e-15 or relative <= 1.0e-12,
+    }
+
+
+def _resolved_comparison(left: Any, right: Any) -> dict[str, object]:
+    left_helicities = tuple(left.helicity_ids)
+    right_helicities = tuple(right.helicity_ids)
+    left_colors = tuple(left.color_ids)
+    right_colors = tuple(right.color_ids)
+    left_values = tuple(left.values)
+    right_values = tuple(right.values)
+    identifiers_match = (
+        left_helicities == right_helicities and left_colors == right_colors
+    )
+    shape_matches = len(left_values) == len(right_values)
+    comparisons: list[dict[str, object]] = []
+    if shape_matches:
+        for left_point, right_point in zip(left_values, right_values, strict=True):
+            left_rows = tuple(left_point)
+            right_rows = tuple(right_point)
+            if len(left_rows) != len(right_rows):
+                shape_matches = False
+                break
+            for left_row, right_row in zip(left_rows, right_rows, strict=True):
+                left_components = tuple(left_row)
+                right_components = tuple(right_row)
+                if len(left_components) != len(right_components):
+                    shape_matches = False
+                    break
+                comparisons.extend(
+                    _complex_comparison(left_value, right_value)
+                    for left_value, right_value in zip(
+                        left_components,
+                        right_components,
+                        strict=True,
+                    )
+                )
+            if not shape_matches:
+                break
+    maximum_absolute = max(
+        (float(item["absolute_difference"]) for item in comparisons),
+        default=0.0,
+    )
+    maximum_relative = max(
+        (float(item["relative_difference"]) for item in comparisons),
+        default=0.0,
+    )
+    return {
+        "helicity_ids_match": left_helicities == right_helicities,
+        "color_ids_match": left_colors == right_colors,
+        "shape_matches": shape_matches,
+        "point_count": len(left_values),
+        "component_count": len(comparisons),
+        "maximum_absolute_difference": maximum_absolute,
+        "maximum_relative_difference": maximum_relative,
+        "passes": identifiers_match
+        and shape_matches
+        and bool(comparisons)
+        and all(bool(item["passes"]) for item in comparisons),
+    }
+
+
+def compare_artifacts(
+    eager_artifact: Path,
+    compiled_artifact: Path,
+    process_id: str,
+    eager_selectors: Mapping[str, str],
+    *,
+    compiled_selectors: Mapping[str, str] | None = None,
+) -> dict[str, Any]:
+    """Compare f64 and exact resolved results from two artifacts."""
+
+    from pyamplicol import Runtime
+
+    momenta = _validation_momenta(eager_artifact, process_id)
+
+    def selector_kwargs(selectors: Mapping[str, str]) -> dict[str, object]:
+        kwargs: dict[str, object] = {}
+        if "color_flow" in selectors:
+            kwargs["color_flows"] = (selectors["color_flow"],)
+        if "helicity" in selectors:
+            kwargs["helicities"] = (selectors["helicity"],)
+        return kwargs
+
+    eager_kwargs = selector_kwargs(eager_selectors)
+    compiled_kwargs = selector_kwargs(
+        eager_selectors if compiled_selectors is None else compiled_selectors
+    )
+    eager_runtime = Runtime.load(eager_artifact)
+    compiled_runtime = Runtime.load(compiled_artifact)
+    eager_total = eager_runtime.evaluate(momenta, **eager_kwargs)
+    compiled_total = compiled_runtime.evaluate(momenta, **compiled_kwargs)
+    total_comparisons = tuple(
+        _complex_comparison(eager_value, compiled_value)
+        for eager_value, compiled_value in zip(
+            eager_total,
+            compiled_total,
+            strict=True,
+        )
+    )
+    eager_resolved = eager_runtime.evaluate_resolved(momenta, **eager_kwargs)
+    compiled_resolved = compiled_runtime.evaluate_resolved(
+        momenta, **compiled_kwargs
+    )
+    resolved = _resolved_comparison(eager_resolved, compiled_resolved)
+    eager_exact = eager_runtime.evaluate_resolved(
+        momenta, precision=32, **eager_kwargs
+    )
+    compiled_exact = compiled_runtime.evaluate_resolved(
+        momenta,
+        precision=32,
+        **compiled_kwargs,
+    )
+    exact = _resolved_comparison(eager_exact, compiled_exact)
+    eager_reduction = tuple(
+        _complex_comparison(total, resolved_total)
+        for total, resolved_total in zip(
+            eager_total,
+            eager_resolved.total(),
+            strict=True,
+        )
+    )
+    compiled_reduction = tuple(
+        _complex_comparison(total, resolved_total)
+        for total, resolved_total in zip(
+            compiled_total,
+            compiled_resolved.total(),
+            strict=True,
+        )
+    )
+    return {
+        "total": total_comparisons,
+        "resolved_f64": resolved,
+        "resolved_precision32": exact,
+        "eager_resolved_sum": eager_reduction,
+        "compiled_resolved_sum": compiled_reduction,
+        "passes": bool(total_comparisons)
+        and all(bool(item["passes"]) for item in total_comparisons)
+        and bool(resolved["passes"])
+        and bool(exact["passes"])
+        and all(bool(item["passes"]) for item in eager_reduction)
+        and all(bool(item["passes"]) for item in compiled_reduction),
+    }
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--eager-artifact", type=Path, required=True)
+    result.add_argument("--compiled-artifact", type=Path, required=True)
+    result.add_argument("--process", required=True)
+    result.add_argument("--color-flow")
+    result.add_argument("--helicity")
+    result.add_argument(
+        "--compiled-selectors",
+        choices=("same", "none"),
+        default="same",
+        help="reuse eager selectors or leave a specialized artifact unselected",
+    )
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    selectors = {
+        name: value
+        for name, value in (
+            ("color_flow", arguments.color_flow),
+            ("helicity", arguments.helicity),
+        )
+        if value is not None
+    }
+    compiled_selectors = None if arguments.compiled_selectors == "same" else {}
+    try:
+        result = compare_artifacts(
+            arguments.eager_artifact,
+            arguments.compiled_artifact,
+            arguments.process,
+            selectors,
+            compiled_selectors=compiled_selectors,
+        )
+    except (ComparisonError, OSError, ValueError) as error:
+        print(f"eager-artifact-compare: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result["passes"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/eager_benchmark_matrix.py b/pyamplicol/tools/developer/eager_benchmark_matrix.py
new file mode 100644
index 0000000000..1bea39eab4
--- /dev/null
+++ b/pyamplicol/tools/developer/eager_benchmark_matrix.py
@@ -0,0 +1,1132 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run the bounded compiled-versus-eager acceptance matrix.
+
+This driver is intentionally independent of the publication-report tooling.
+It generates one complete compiled artifact
+and one complete eager artifact per cell, then records native Rusticol wall
+timings in one machine-readable result. LC workloads additionally generate the
+conventional specialized compiled references used by the report so reusable
+eager selection is not mistaken for a speedup over a differently specialized
+baseline.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import platform
+import re
+import signal
+import subprocess
+import sys
+import time
+from collections.abc import Mapping, Sequence
+from contextlib import suppress
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+WATCHDOG = ROOT / "tools" / "ci" / "memory_watchdog.py"
+COMPARISON_MODULE = "tools.developer.eager_artifact_compare"
+SELECTOR_PROFILE_MODULE = "tools.developer.runtime_selector_profile"
+DEFAULT_GENERATION_TIMEOUT = 300.0
+DEFAULT_SUITE_TIMEOUT = 300.0
+DEFAULT_MEMORY_LIMIT_GIB = 30.0
+DEFAULT_BATCH_SIZES = (1, 128, 1024)
+SMOKE_BATCH_SIZES = (128, 1024)
+DEFAULT_COLORS = ("lc", "nlc", "full")
+HARD_GENERATION_SPEEDUP = 7.0
+SOFT_GENERATION_SPEEDUP = 10.0
+SOFT_RUNTIME_RATIO = 1.5
+HARD_REUSABLE_RUNTIME_RATIO = 1.25
+_TOPOLOGY_FIELDS = (
+    "physical_helicities",
+    "computed_helicities",
+    "physical_color_components",
+    "computed_color_components",
+    "invocation_count",
+    "attachment_count",
+    "evaluation_alias_count",
+    "maximum_fanout",
+    "finalization_count",
+    "closure_count",
+)
+_OPTIONAL_TOPOLOGY_FIELDS = frozenset(("maximum_fanout",))
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessCase:
+    key: str
+    process: str
+    n_final: int
+    feature: str
+    compiled_limit_seconds: float
+    smoke: bool = False
+
+
+PROCESS_CASES = (
+    ProcessCase(
+        "dd_z_3g",
+        "d d~ > z g g g",
+        4,
+        "color singlet with mixed QCD/electroweak recursion",
+        3.3,
+        smoke=True,
+    ),
+    ProcessCase(
+        "gg_tt_2g",
+        "g g > t t~ g g",
+        4,
+        "gluon-initiated massive fermions and two adjoints",
+        20.6,
+    ),
+    ProcessCase(
+        "gg_4g",
+        "g g > g g g g",
+        4,
+        "pure Yang-Mills dense-color recursion",
+        128.3,
+    ),
+    ProcessCase(
+        "dd_3q_1g",
+        "d d~ > u u~ s s~ g",
+        5,
+        "three open quark lines and nontrivial color contraction",
+        8.4,
+        smoke=True,
+    ),
+    ProcessCase(
+        "dd_tt_3g",
+        "d d~ > t t~ g g g",
+        5,
+        "high-fanout massive-QCD recursion",
+        108.3,
+    ),
+)
+
+
+class MatrixError(RuntimeError):
+    """Raised when a benchmark command or acceptance invariant fails."""
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return parsed
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return parsed
+
+
+def _csv_values(value: str) -> tuple[str, ...]:
+    values = tuple(item.strip() for item in value.split(",") if item.strip())
+    if not values:
+        raise argparse.ArgumentTypeError("must contain at least one value")
+    return values
+
+
+def _csv_ints(value: str) -> tuple[int, ...]:
+    try:
+        values = tuple(int(item) for item in _csv_values(value))
+    except ValueError as error:
+        raise argparse.ArgumentTypeError(
+            "must be a comma-separated integer list"
+        ) from error
+    if any(item <= 0 for item in values):
+        raise argparse.ArgumentTypeError("batch sizes must be positive")
+    return values
+
+
+def _selected_cases(suite: str, requested: Sequence[str]) -> tuple[ProcessCase, ...]:
+    allowed = {case.key: case for case in PROCESS_CASES}
+    if requested:
+        unknown = sorted(set(requested) - allowed.keys())
+        if unknown:
+            raise MatrixError(f"unknown process case(s): {', '.join(unknown)}")
+        return tuple(allowed[key] for key in requested)
+    if suite == "smoke":
+        return tuple(case for case in PROCESS_CASES if case.smoke)
+    return PROCESS_CASES
+
+
+def _terminate_process_group(process: subprocess.Popen[str]) -> None:
+    if process.poll() is not None:
+        return
+    try:
+        os.killpg(process.pid, signal.SIGTERM)
+        process.wait(timeout=5)
+    except (ProcessLookupError, subprocess.TimeoutExpired):
+        with suppress(ProcessLookupError):
+            os.killpg(process.pid, signal.SIGKILL)
+        process.wait()
+
+
+def _run_json(
+    command: Sequence[str],
+    *,
+    timeout: float,
+    memory_limit_gib: float,
+    environment: Mapping[str, str],
+) -> tuple[dict[str, Any], float, str]:
+    guarded = (
+        sys.executable,
+        str(WATCHDOG),
+        "--limit-gib",
+        str(memory_limit_gib),
+        "--",
+        *command,
+    )
+    started = time.monotonic()
+    process = subprocess.Popen(
+        guarded,
+        cwd=ROOT,
+        env=dict(environment),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        start_new_session=True,
+    )
+    try:
+        stdout, stderr = process.communicate(timeout=timeout)
+    except subprocess.TimeoutExpired as error:
+        _terminate_process_group(process)
+        raise MatrixError(
+            f"command exceeded {timeout:.1f}s: {' '.join(command)}"
+        ) from error
+    elapsed = time.monotonic() - started
+    if process.returncode != 0:
+        output_sections: list[str] = []
+        if stdout.strip():
+            output_sections.append(f"stdout (tail):\n{stdout.strip()[-8000:]}")
+        if stderr.strip():
+            output_sections.append(f"stderr (tail):\n{stderr.strip()[-8000:]}")
+        detail = "\n".join(output_sections) or f"exit code {process.returncode}"
+        raise MatrixError(f"command failed: {' '.join(command)}\n{detail}")
+    try:
+        payload = json.loads(stdout)
+    except json.JSONDecodeError as error:
+        raise MatrixError(
+            f"command did not emit JSON: {' '.join(command)}\n{stdout[-2000:]}"
+        ) from error
+    if not isinstance(payload, dict):
+        raise MatrixError("command JSON result must be an object")
+    return payload, elapsed, stderr
+
+
+def _artifact_process(artifact: Path) -> tuple[str, dict[str, Any]]:
+    try:
+        outer = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+        processes = outer["processes"]
+        if not isinstance(processes, list) or len(processes) != 1:
+            raise TypeError
+        process_id = str(processes[0]["id"])
+        physics = json.loads(
+            (artifact / "processes" / process_id / "physics.json").read_text(
+                encoding="utf-8"
+            )
+        )
+    except (OSError, KeyError, TypeError, ValueError, json.JSONDecodeError) as error:
+        raise MatrixError(f"invalid generated artifact at {artifact}") from error
+    if not isinstance(physics, dict):
+        raise MatrixError(f"invalid physics payload in {artifact}")
+    return process_id, physics
+
+
+def _first_computed_record(records: object, *, label: str) -> dict[str, Any]:
+    if not isinstance(records, list):
+        raise MatrixError(f"physics {label} must be a list")
+    for record in records:
+        if not isinstance(record, dict):
+            continue
+        if record.get("computed") is True and record.get("structural_zero") is not True:
+            identifier = record.get("id")
+            if isinstance(identifier, str) and identifier:
+                return record
+    raise MatrixError(f"physics payload has no computed {label}")
+
+
+def _workloads(color: str, physics: Mapping[str, Any]) -> tuple[dict[str, Any], ...]:
+    if color != "lc":
+        return ({"name": "summed", "selectors": {}},)
+    color_record = _first_computed_record(
+        physics.get("color_components"), label="color flow"
+    )
+    helicity_record = _first_computed_record(
+        physics.get("helicities"), label="helicity"
+    )
+    color_id = str(color_record["id"])
+    helicity_id = str(helicity_record["id"])
+    color_word = color_record.get("word")
+    helicity_values = helicity_record.get("values")
+    external_particles = physics.get("external_particles")
+    if (
+        not isinstance(color_word, list)
+        or not color_word
+        or any(
+            isinstance(value, bool) or not isinstance(value, int)
+            for value in color_word
+        )
+    ):
+        raise MatrixError("computed LC flow has no valid source-label word")
+    if (
+        not isinstance(external_particles, list)
+        or not isinstance(helicity_values, list)
+        or len(external_particles) != len(helicity_values)
+    ):
+        raise MatrixError("computed helicity does not match external particles")
+    source_helicities: dict[int, int] = {}
+    for particle, helicity in zip(external_particles, helicity_values, strict=True):
+        if not isinstance(particle, dict):
+            raise MatrixError("external particle metadata must be an object")
+        label = particle.get("label")
+        if (
+            isinstance(label, bool)
+            or not isinstance(label, int)
+            or label < 1
+            or isinstance(helicity, bool)
+            or not isinstance(helicity, int)
+        ):
+            raise MatrixError("computed helicity has invalid source-label metadata")
+        source_helicities[label] = helicity
+    return (
+        {
+            "name": "single-flow-helicity-sum",
+            "selectors": {"color_flow": color_id},
+            "compiled_specialization": {
+                "reference_color_order": tuple(color_word),
+                "selected_color_sector_ids": (0,),
+            },
+        },
+        {
+            "name": "all-flow-single-helicity",
+            "selectors": {"helicity": helicity_id},
+            "compiled_specialization": {
+                "selected_source_helicities": source_helicities,
+            },
+        },
+    )
+
+
+def _toml_override_literal(value: object) -> str:
+    if isinstance(value, tuple):
+        if any(isinstance(item, bool) or not isinstance(item, int) for item in value):
+            raise MatrixError("process override tuples must contain integers")
+        return "[" + ",".join(str(item) for item in value) + "]"
+    if isinstance(value, Mapping):
+        entries: list[str] = []
+        for key, item in value.items():
+            if (
+                isinstance(key, bool)
+                or not isinstance(key, int)
+                or isinstance(item, bool)
+                or not isinstance(item, int)
+            ):
+                raise MatrixError("process override mappings must contain integers")
+            entries.append(f"{json.dumps(str(key))}={item}")
+        return "{" + ",".join(entries) + "}"
+    raise MatrixError(f"unsupported process override value: {value!r}")
+
+
+def _generation_command(
+    python: Path,
+    *,
+    process: str,
+    artifact: Path,
+    model: Path | str,
+    color: str,
+    execution_mode: str,
+    process_overrides: Mapping[str, object] | None = None,
+) -> tuple[str, ...]:
+    command = [
+        str(python),
+        "-m",
+        "pyamplicol",
+        "generate",
+        process,
+        str(artifact),
+        "--model",
+        str(model),
+        "--execution-mode",
+        execution_mode,
+        "--backend",
+        "jit",
+        "--jit-optimization-level",
+        "3",
+        "--color-accuracy",
+        color,
+        "--mode",
+        "replace",
+        "--validation",
+        "--validation-samples",
+        "1",
+        "--validation-seed",
+        "20260719",
+        "--no-post-build-validation",
+        "--no-emit-api-bundle",
+        "--progress",
+        "off",
+        "--json",
+    ]
+    for name, value in (process_overrides or {}).items():
+        command.extend(
+            ("--set", f"process.{name}={_toml_override_literal(value)}")
+        )
+    return tuple(command)
+
+
+def _profile_command(
+    python: Path,
+    *,
+    artifact: Path,
+    process_id: str,
+    batch_size: int,
+    target_runtime: float,
+    minimum_samples: int,
+    selectors: Mapping[str, str],
+) -> tuple[str, ...]:
+    command = [
+        str(python),
+        "-m",
+        "pyamplicol",
+        "profile",
+        str(artifact),
+        "--process",
+        process_id,
+        "--target-runtime",
+        str(target_runtime),
+        "--batch-size",
+        str(batch_size),
+        "--warmup-runs",
+        "2",
+        "--minimum-samples",
+        str(minimum_samples),
+        "--progress",
+        "off",
+        "--json",
+    ]
+    if "color_flow" in selectors:
+        command.extend(("--color-flow", selectors["color_flow"]))
+    if "helicity" in selectors:
+        command.extend(("--helicity", selectors["helicity"]))
+    return tuple(command)
+
+
+def _selector_profile_command(
+    python: Path,
+    *,
+    artifact: Path,
+    process_id: str,
+    batch_size: int,
+    target_runtime: float,
+    minimum_samples: int,
+    seed: int,
+) -> tuple[str, ...]:
+    return (
+        str(python),
+        "-m",
+        SELECTOR_PROFILE_MODULE,
+        str(artifact),
+        "--process",
+        process_id,
+        "--axis",
+        "both",
+        "--batch-size",
+        str(batch_size),
+        "--target-runtime",
+        str(target_runtime),
+        "--minimum-samples",
+        str(minimum_samples),
+        "--seed",
+        str(seed),
+    )
+
+
+def _comparison_command(
+    python: Path,
+    *,
+    eager_artifact: Path,
+    compiled_artifact: Path,
+    process_id: str,
+    selectors: Mapping[str, str],
+    compiled_selectors: str = "same",
+) -> tuple[str, ...]:
+    command = [
+        str(python),
+        "-m",
+        COMPARISON_MODULE,
+        "--eager-artifact",
+        str(eager_artifact),
+        "--compiled-artifact",
+        str(compiled_artifact),
+        "--process",
+        process_id,
+        "--compiled-selectors",
+        compiled_selectors,
+    ]
+    if "color_flow" in selectors:
+        command.extend(("--color-flow", selectors["color_flow"]))
+    if "helicity" in selectors:
+        command.extend(("--helicity", selectors["helicity"]))
+    return tuple(command)
+
+
+def _geometric_mean(values: Sequence[float]) -> float:
+    if not values or any(value <= 0 or not math.isfinite(value) for value in values):
+        raise MatrixError("geometric mean requires positive finite values")
+    return math.exp(sum(math.log(value) for value in values) / len(values))
+
+
+def _generation_assessment(
+    records: Sequence[Mapping[str, Any]],
+) -> tuple[dict[str, bool], dict[str, bool]]:
+    non_lc_speedups: list[float] = []
+    lc_speedups: list[float] = []
+    grouped: dict[tuple[str, str], dict[str, float]] = {}
+    for record in records:
+        ratio = float(record["compiled_over_eager_core_generation"])
+        color = str(record["color"])
+        case = record["case"]
+        if not isinstance(case, Mapping):
+            raise MatrixError("matrix record has invalid case metadata")
+        group = (str(case["key"]), str(record["model"]))
+        grouped.setdefault(group, {})[color] = ratio
+        if color == "lc":
+            lc_speedups.append(ratio)
+        else:
+            non_lc_speedups.append(ratio)
+    complete_groups = bool(grouped) and all(
+        set(colors) == set(DEFAULT_COLORS) for colors in grouped.values()
+    )
+    geometric_means = tuple(
+        _geometric_mean(tuple(colors.values())) for colors in grouped.values()
+    )
+    hard_gates = {
+        "nlc_full_each_at_least_7x": bool(non_lc_speedups)
+        and all(value >= HARD_GENERATION_SPEEDUP for value in non_lc_speedups),
+        "lc_no_generation_regression": bool(lc_speedups)
+        and all(value >= 1.0 for value in lc_speedups),
+        "per_process_geometric_mean_at_least_7x": complete_groups
+        and all(value >= HARD_GENERATION_SPEEDUP for value in geometric_means),
+    }
+    soft_targets = {
+        "nlc_full_each_at_least_10x": bool(non_lc_speedups)
+        and all(value >= SOFT_GENERATION_SPEEDUP for value in non_lc_speedups),
+        "per_process_geometric_mean_at_least_10x": complete_groups
+        and all(value >= SOFT_GENERATION_SPEEDUP for value in geometric_means),
+    }
+    return hard_gates, soft_targets
+
+
+def _reusable_runtime_gate(records: Sequence[Mapping[str, Any]]) -> bool:
+    """Apply the reusable/specialized bound only to n=4 and n=5 profiles."""
+
+    ratios = tuple(
+        float(ratio)
+        for record in records
+        if int(record["case"]["n_final"]) in {4, 5}
+        for workload in record["workloads"]
+        for profile in workload["profiles"]
+        if int(profile["batch_size"]) in {128, 1024}
+        for ratio in [profile["compiled_reusable_over_specialized_wall"]]
+        if ratio is not None
+    )
+    return bool(ratios) and all(
+        ratio <= HARD_REUSABLE_RUNTIME_RATIO for ratio in ratios
+    )
+
+
+def _scope_gate(arguments: argparse.Namespace, cases: Sequence[ProcessCase]) -> bool:
+    expected_cases = {
+        case.key
+        for case in PROCESS_CASES
+        if arguments.suite == "milestone" or case.smoke
+    }
+    expected_models = (
+        {"built-in", "ufo-sm"} if arguments.suite == "milestone" else {"built-in"}
+    )
+    expected_batch_sizes = (
+        DEFAULT_BATCH_SIZES
+        if arguments.suite == "milestone"
+        else SMOKE_BATCH_SIZES
+    )
+    return (
+        {case.key for case in cases} == expected_cases
+        and set(arguments.models) == expected_models
+        and set(arguments.colors) == set(DEFAULT_COLORS)
+        and set(arguments.batch_sizes) == set(expected_batch_sizes)
+    )
+
+
+def _eager_topology(artifact: Path) -> dict[str, int]:
+    from pyamplicol.artifacts import inspect_artifact
+
+    inspection = inspect_artifact(artifact)
+    if len(inspection.processes) != 1:
+        raise MatrixError("benchmark artifacts must contain exactly one process")
+    process = inspection.processes[0]
+    if getattr(process, "execution_mode", None) != "eager":
+        raise MatrixError(f"artifact is not eager: {artifact}")
+    result: dict[str, int] = {}
+    for field in _TOPOLOGY_FIELDS:
+        value = getattr(process, field, None)
+        if value is None and field in _OPTIONAL_TOPOLOGY_FIELDS:
+            continue
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise MatrixError(f"eager inspection has invalid {field}: {artifact}")
+        result[field] = value
+    return result
+
+
+def _topology_gate(records: Sequence[Mapping[str, Any]], *, require_ufo: bool) -> bool:
+    if not require_ufo:
+        return True
+    grouped: dict[tuple[str, str], dict[str, Mapping[str, int]]] = {}
+    for record in records:
+        case = record.get("case")
+        topology = record.get("eager_topology")
+        if not isinstance(case, Mapping) or not isinstance(topology, Mapping):
+            return False
+        key = (str(case.get("key")), str(record.get("color")))
+        grouped.setdefault(key, {})[str(record.get("model"))] = topology
+    return bool(grouped) and all(
+        set(models) == {"built-in", "ufo-sm"}
+        and dict(models["built-in"]) == dict(models["ufo-sm"])
+        for models in grouped.values()
+    )
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    os.replace(temporary, path)
+
+
+def _generation_phases(artifact: Path) -> dict[str, float]:
+    try:
+        outer = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+        raw = outer["extensions"]["generation"]["phase_timings_seconds"]
+    except (OSError, KeyError, TypeError, ValueError, json.JSONDecodeError) as error:
+        raise MatrixError(
+            f"artifact has no valid generation phases: {artifact}"
+        ) from error
+    if not isinstance(raw, dict):
+        raise MatrixError(f"artifact generation phases are not an object: {artifact}")
+    phases: dict[str, float] = {}
+    for name, value in raw.items():
+        if not isinstance(name, str) or isinstance(value, bool):
+            raise MatrixError(f"artifact has invalid generation phase: {artifact}")
+        seconds = float(value)
+        if not math.isfinite(seconds) or seconds < 0:
+            raise MatrixError(f"artifact has invalid generation phase time: {artifact}")
+        phases[name] = seconds
+    return phases
+
+
+def _core_generation_seconds(phases: Mapping[str, float]) -> float:
+    excluded = {"model-loading", "process-expansion"}
+    result = sum(value for name, value in phases.items() if name not in excluded)
+    if result <= 0 or not math.isfinite(result):
+        raise MatrixError("core generation phase total must be positive and finite")
+    return result
+
+
+def _artifact_size_bytes(artifact: Path) -> int:
+    return sum(path.stat().st_size for path in artifact.rglob("*") if path.is_file())
+
+
+def _watchdog_peak_gib(stderr: str) -> float | None:
+    matches = re.findall(r"peak_rss=([0-9]+(?:\.[0-9]+)?) GiB", stderr)
+    return float(matches[-1]) if matches else None
+
+
+def _git_head() -> str | None:
+    completed = subprocess.run(
+        ("git", "rev-parse", "HEAD"),
+        cwd=ROOT,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip() if completed.returncode == 0 else None
+
+
+def _model_specs(
+    arguments: argparse.Namespace,
+) -> tuple[tuple[str, str | Path, Path], ...]:
+    requested = set(arguments.models)
+    specs: list[tuple[str, str | Path, Path]] = []
+    if "built-in" in requested:
+        specs.append(("built-in", "built-in-sm", arguments.builtin_pack.resolve()))
+    if "ufo-sm" in requested:
+        if arguments.ufo_source is None or arguments.ufo_pack is None:
+            raise MatrixError("ufo-sm requires both --ufo-source and --ufo-pack")
+        specs.append(
+            ("ufo-sm", arguments.ufo_source.resolve(), arguments.ufo_pack.resolve())
+        )
+    return tuple(specs)
+
+
+def run_matrix(arguments: argparse.Namespace) -> dict[str, Any]:
+    cases = _selected_cases(arguments.suite, arguments.case)
+    colors = tuple(arguments.colors)
+    unknown_colors = sorted(set(colors) - set(DEFAULT_COLORS))
+    if unknown_colors:
+        raise MatrixError(f"unknown color accuracy: {', '.join(unknown_colors)}")
+    models = _model_specs(arguments)
+    for _, _, pack in models:
+        if not pack.is_file():
+            raise MatrixError(f"prepared model bundle does not exist: {pack}")
+
+    output_root = arguments.output_root.resolve()
+    output_root.mkdir(parents=True, exist_ok=True)
+    environment = os.environ.copy()
+    environment.setdefault("SYMBOLICA_HIDE_BANNER", "1")
+    environment.setdefault("PYTHONFAULTHANDLER", "1")
+    environment.setdefault("RUST_BACKTRACE", "full")
+    started = time.monotonic()
+    records: list[dict[str, Any]] = []
+
+    for case in cases:
+        for model_name, compiled_source, prepared_pack in models:
+            for color in colors:
+                cell_root = output_root / case.key / model_name / color
+                artifacts = {
+                    "compiled": cell_root / "compiled",
+                    "eager": cell_root / "eager",
+                }
+                generation: dict[str, dict[str, Any]] = {}
+                for mode, model_source in (
+                    ("compiled", compiled_source),
+                    ("eager", prepared_pack),
+                ):
+                    command = _generation_command(
+                        arguments.python,
+                        process=case.process,
+                        artifact=artifacts[mode],
+                        model=model_source,
+                        color=color,
+                        execution_mode=mode,
+                    )
+                    payload, elapsed, stderr = _run_json(
+                        command,
+                        timeout=arguments.generation_timeout,
+                        memory_limit_gib=arguments.memory_limit_gib,
+                        environment=environment,
+                    )
+                    generation[mode] = {
+                        "elapsed_seconds": elapsed,
+                        "output": payload.get("output"),
+                        "schema_version": payload.get("schema_version"),
+                        "peak_rss_gib": _watchdog_peak_gib(stderr),
+                        "watchdog": stderr.strip().splitlines()[-1]
+                        if stderr.strip()
+                        else None,
+                    }
+                process_id, eager_physics = _artifact_process(artifacts["eager"])
+                compiled_process_id, _ = _artifact_process(artifacts["compiled"])
+                if compiled_process_id != process_id:
+                    raise MatrixError(
+                        "compiled/eager process IDs differ: "
+                        f"{compiled_process_id!r} != {process_id!r}"
+                    )
+                for mode in ("compiled", "eager"):
+                    phases = _generation_phases(artifacts[mode])
+                    generation[mode]["phase_timings_seconds"] = phases
+                    generation[mode]["core_phase_seconds"] = _core_generation_seconds(
+                        phases
+                    )
+                    generation[mode]["artifact_size_bytes"] = _artifact_size_bytes(
+                        artifacts[mode]
+                    )
+                eager_topology = _eager_topology(artifacts["eager"])
+
+                workload_results: list[dict[str, Any]] = []
+                for workload in _workloads(color, eager_physics):
+                    selectors = workload["selectors"]
+                    assert isinstance(selectors, dict)
+                    specialized_artifact: Path | None = None
+                    specialized_generation: dict[str, Any] | None = None
+                    specialization = workload.get("compiled_specialization")
+                    if isinstance(specialization, Mapping):
+                        specialized_artifact = (
+                            cell_root
+                            / "compiled-specialized"
+                            / str(workload["name"])
+                        )
+                        payload, elapsed, stderr = _run_json(
+                            _generation_command(
+                                arguments.python,
+                                process=case.process,
+                                artifact=specialized_artifact,
+                                model=compiled_source,
+                                color=color,
+                                execution_mode="compiled",
+                                process_overrides=specialization,
+                            ),
+                            timeout=arguments.generation_timeout,
+                            memory_limit_gib=arguments.memory_limit_gib,
+                            environment=environment,
+                        )
+                        specialized_process_id, specialized_physics = (
+                            _artifact_process(specialized_artifact)
+                        )
+                        if specialized_process_id != process_id:
+                            raise MatrixError(
+                                "specialized/complete process IDs differ: "
+                                f"{specialized_process_id!r} != {process_id!r}"
+                            )
+                        coverage = specialized_physics.get("coverage")
+                        if not isinstance(coverage, Mapping):
+                            raise MatrixError(
+                                "specialized compiled artifact has no coverage metadata"
+                            )
+                        expected_selected_axis = (
+                            "color"
+                            if "reference_color_order" in specialization
+                            else "helicities"
+                        )
+                        if coverage.get(expected_selected_axis) != "selected":
+                            raise MatrixError(
+                                "specialized compiled artifact did not select "
+                                f"{expected_selected_axis} coverage"
+                            )
+                        phases = _generation_phases(specialized_artifact)
+                        specialized_generation = {
+                            "elapsed_seconds": elapsed,
+                            "output": payload.get("output"),
+                            "schema_version": payload.get("schema_version"),
+                            "peak_rss_gib": _watchdog_peak_gib(stderr),
+                            "phase_timings_seconds": phases,
+                            "core_phase_seconds": _core_generation_seconds(phases),
+                            "artifact_size_bytes": _artifact_size_bytes(
+                                specialized_artifact
+                            ),
+                            "coverage": dict(coverage),
+                        }
+                    correctness, _, _ = _run_json(
+                        _comparison_command(
+                            arguments.python,
+                            eager_artifact=artifacts["eager"],
+                            compiled_artifact=artifacts["compiled"],
+                            process_id=process_id,
+                            selectors=selectors,
+                        ),
+                        timeout=arguments.generation_timeout,
+                        memory_limit_gib=arguments.memory_limit_gib,
+                        environment=environment,
+                    )
+                    if specialized_artifact is not None:
+                        specialized_correctness, _, _ = _run_json(
+                            _comparison_command(
+                                arguments.python,
+                                eager_artifact=artifacts["eager"],
+                                compiled_artifact=specialized_artifact,
+                                process_id=process_id,
+                                selectors=selectors,
+                                compiled_selectors="none",
+                            ),
+                            timeout=arguments.generation_timeout,
+                            memory_limit_gib=arguments.memory_limit_gib,
+                            environment=environment,
+                        )
+                        correctness["specialized_compiled"] = (
+                            specialized_correctness
+                        )
+                        correctness["passes"] = bool(correctness["passes"]) and bool(
+                            specialized_correctness["passes"]
+                        )
+                    profiles: list[dict[str, Any]] = []
+                    for batch_size in arguments.batch_sizes:
+                        timings: dict[str, dict[str, Any]] = {}
+                        profile_targets: list[
+                            tuple[str, Path, Mapping[str, str]]
+                        ] = [
+                            ("compiled_complete", artifacts["compiled"], selectors),
+                            ("eager_complete", artifacts["eager"], selectors),
+                        ]
+                        if specialized_artifact is not None:
+                            profile_targets.append(
+                                ("compiled_specialized", specialized_artifact, {})
+                            )
+                        for (
+                            mode,
+                            profile_artifact,
+                            profile_selectors,
+                        ) in profile_targets:
+                            payload, elapsed, _ = _run_json(
+                                _profile_command(
+                                    arguments.python,
+                                    artifact=profile_artifact,
+                                    process_id=process_id,
+                                    batch_size=batch_size,
+                                    target_runtime=arguments.target_runtime,
+                                    minimum_samples=arguments.minimum_samples,
+                                    selectors=profile_selectors,
+                                ),
+                                timeout=max(60.0, arguments.target_runtime * 10.0),
+                                memory_limit_gib=arguments.memory_limit_gib,
+                                environment=environment,
+                            )
+                            timings[mode] = {
+                                "command_elapsed_seconds": elapsed,
+                                "wall_seconds_per_point": payload.get(
+                                    "wall_time_per_point"
+                                ),
+                                "evaluator_seconds_per_point": payload.get(
+                                    "evaluator_time_per_point"
+                                ),
+                                "result": payload,
+                            }
+                        compiled_complete_wall = float(
+                            timings["compiled_complete"]["wall_seconds_per_point"]
+                        )
+                        eager_wall = float(
+                            timings["eager_complete"]["wall_seconds_per_point"]
+                        )
+                        baseline_name = (
+                            "compiled_specialized"
+                            if "compiled_specialized" in timings
+                            else "compiled_complete"
+                        )
+                        baseline_wall = float(
+                            timings[baseline_name]["wall_seconds_per_point"]
+                        )
+                        profiles.append(
+                            {
+                                "batch_size": batch_size,
+                                **timings,
+                                "runtime_baseline": baseline_name,
+                                "eager_over_compiled_complete_wall": (
+                                    eager_wall / compiled_complete_wall
+                                ),
+                                "eager_over_compiled_specialized_wall": (
+                                    eager_wall / baseline_wall
+                                    if baseline_name == "compiled_specialized"
+                                    else None
+                                ),
+                                "compiled_reusable_over_specialized_wall": (
+                                    compiled_complete_wall / baseline_wall
+                                    if baseline_name == "compiled_specialized"
+                                    else None
+                                ),
+                                "batch_1024_soft_target_passes": (
+                                    batch_size != 1024
+                                    or eager_wall
+                                    <= SOFT_RUNTIME_RATIO * baseline_wall
+                                ),
+                            }
+                        )
+                    workload_results.append(
+                        {
+                            "name": workload["name"],
+                            "selectors": selectors,
+                            "compiled_specialization": specialization,
+                            "compiled_specialized_generation": (
+                                specialized_generation
+                            ),
+                            "correctness": correctness,
+                            "profiles": profiles,
+                        }
+                    )
+                selector_pattern_profiles: dict[str, Any] | None = None
+                if color == "lc" and 1024 in arguments.batch_sizes:
+                    selector_pattern_profiles = {}
+                    for mode in ("compiled", "eager"):
+                        payload, profile_elapsed, _ = _run_json(
+                            _selector_profile_command(
+                                arguments.python,
+                                artifact=artifacts[mode],
+                                process_id=process_id,
+                                batch_size=1024,
+                                target_runtime=arguments.selector_target_runtime,
+                                minimum_samples=arguments.minimum_samples,
+                                seed=arguments.selector_seed,
+                            ),
+                            timeout=max(
+                                120.0,
+                                arguments.selector_target_runtime * 40.0,
+                            ),
+                            memory_limit_gib=arguments.memory_limit_gib,
+                            environment=environment,
+                        )
+                        selector_pattern_profiles[mode] = {
+                            "command_elapsed_seconds": profile_elapsed,
+                            "result": payload,
+                        }
+                compiled_generation = generation["compiled"]["elapsed_seconds"]
+                eager_generation = generation["eager"]["elapsed_seconds"]
+                compiled_core = generation["compiled"]["core_phase_seconds"]
+                eager_core = generation["eager"]["core_phase_seconds"]
+                records.append(
+                    {
+                        "case": asdict(case),
+                        "model": model_name,
+                        "color": color,
+                        "process_id": process_id,
+                        "eager_topology": eager_topology,
+                        "generation": generation,
+                        "compiled_over_eager_command_elapsed": (
+                            compiled_generation / eager_generation
+                        ),
+                        "compiled_over_eager_core_generation": (
+                            compiled_core / eager_core
+                        ),
+                        "compiled_generation_under_hard_limit": (
+                            compiled_generation <= arguments.generation_timeout
+                        ),
+                        "workloads": workload_results,
+                        "selector_pattern_profiles": selector_pattern_profiles,
+                    }
+                )
+                partial = {
+                    "kind": "pyamplicol-eager-benchmark-matrix",
+                    "schema_version": 3,
+                    "complete": False,
+                    "records": records,
+                }
+                _write_json_atomic(output_root / "result.json", partial)
+
+    elapsed = time.monotonic() - started
+    generation_gates, generation_soft_targets = _generation_assessment(records)
+    runtime_soft_target = 1024 in arguments.batch_sizes and all(
+        profile["batch_1024_soft_target_passes"]
+        for record in records
+        for workload in record["workloads"]
+        for profile in workload["profiles"]
+    )
+    reusable_runtime_gate = _reusable_runtime_gate(records)
+    gates = {
+        "matrix_scope_complete": _scope_gate(arguments, cases),
+        "correctness": all(
+            workload["correctness"]["passes"]
+            for record in records
+            for workload in record["workloads"]
+        ),
+        "per_point_selector_patterns": all(
+            record["selector_pattern_profiles"] is None
+            or all(
+                bool(mode_profile["result"]["passes"])
+                for mode_profile in record["selector_pattern_profiles"].values()
+            )
+            for record in records
+        ),
+        "builtin_ufo_topology_parity": _topology_gate(
+            records, require_ufo=arguments.suite == "milestone"
+        ),
+        "smoke_under_five_minutes": (
+            arguments.suite != "smoke" or elapsed <= DEFAULT_SUITE_TIMEOUT
+        ),
+        "n4_n5_reusable_compiled_at_most_1_25x_specialized": (
+            reusable_runtime_gate
+        ),
+        **generation_gates,
+    }
+    result = {
+        "kind": "pyamplicol-eager-benchmark-matrix",
+        "schema_version": 3,
+        "complete": True,
+        "source_revision": _git_head(),
+        "platform": platform.platform(),
+        "python": sys.version.split()[0],
+        "suite": arguments.suite,
+        "elapsed_seconds": elapsed,
+        "configuration": {
+            "batch_sizes": list(arguments.batch_sizes),
+            "colors": list(colors),
+            "generation_timeout": arguments.generation_timeout,
+            "memory_limit_gib": arguments.memory_limit_gib,
+            "minimum_samples": arguments.minimum_samples,
+            "target_runtime": arguments.target_runtime,
+            "selector_target_runtime": arguments.selector_target_runtime,
+            "selector_seed": arguments.selector_seed,
+        },
+        "gates": gates,
+        "soft_targets": {
+            **generation_soft_targets,
+            "batch_1024_runtime_at_most_1_5x_specialized_compiled": (
+                runtime_soft_target
+            ),
+        },
+        "passes": all(gates.values()),
+        "records": records,
+    }
+    _write_json_atomic(output_root / "result.json", result)
+    return result
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--suite", choices=("smoke", "milestone"), default="smoke")
+    result.add_argument("--case", action="append", default=[], help="case key; repeat")
+    result.add_argument(
+        "--models",
+        type=_csv_values,
+        default=("built-in",),
+        help="comma-separated built-in,ufo-sm",
+    )
+    result.add_argument(
+        "--colors", type=_csv_values, default=DEFAULT_COLORS, help="lc,nlc,full"
+    )
+    result.add_argument(
+        "--batch-sizes",
+        type=_csv_ints,
+        default=None,
+        help=(
+            "comma-separated batch sizes; defaults to 128,1024 for smoke and "
+            "1,128,1024 for milestone"
+        ),
+    )
+    result.add_argument("--builtin-pack", type=Path, required=True)
+    result.add_argument("--ufo-source", type=Path)
+    result.add_argument("--ufo-pack", type=Path)
+    result.add_argument("--output-root", type=Path, required=True)
+    result.add_argument("--python", type=Path, default=Path(sys.executable))
+    result.add_argument(
+        "--generation-timeout", type=_positive_float, default=DEFAULT_GENERATION_TIMEOUT
+    )
+    result.add_argument("--target-runtime", type=_positive_float, default=5.0)
+    result.add_argument(
+        "--selector-target-runtime",
+        type=_positive_float,
+        default=1.0,
+        help="target time for each per-point selector-pattern profile",
+    )
+    result.add_argument("--selector-seed", type=int, default=0xC0FFEE)
+    result.add_argument("--minimum-samples", type=_positive_int, default=5)
+    result.add_argument(
+        "--memory-limit-gib", type=_positive_float, default=DEFAULT_MEMORY_LIMIT_GIB
+    )
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    if arguments.batch_sizes is None:
+        arguments.batch_sizes = (
+            DEFAULT_BATCH_SIZES
+            if arguments.suite == "milestone"
+            else SMOKE_BATCH_SIZES
+        )
+    try:
+        result = run_matrix(arguments)
+    except (MatrixError, OSError, ValueError) as error:
+        print(f"eager-benchmark-matrix: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result["passes"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/eager_compiled_arena_m0.py b/pyamplicol/tools/developer/eager_compiled_arena_m0.py
new file mode 100644
index 0000000000..5a2d584dce
--- /dev/null
+++ b/pyamplicol/tools/developer/eager_compiled_arena_m0.py
@@ -0,0 +1,2766 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Fail-closed Milestone-0 evidence combiner for the arena migration.
+
+This program does not run benchmarks and cannot turn a diagnostic capture into
+authoritative evidence.  It revalidates four schema-7 pyAmpliCol captures and
+two independently captured AmpliCol raw-evidence manifests, then emits one
+content-addressed accepted or rejected record.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import datetime as dt
+import hashlib
+import importlib.util
+import json
+import math
+import os
+import statistics
+import sys
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+from typing import Any, NoReturn
+
+REQUEST_KIND = "pyamplicol-eager-compiled-arena-m0-request"
+REQUEST_SCHEMA = 1
+AMPLICOL_KIND = "pyamplicol-amplicol-m0-raw-evidence"
+AMPLICOL_SCHEMA = 1
+OUTPUT_KIND = "pyamplicol-eager-compiled-arena-m0-acceptance"
+OUTPUT_SCHEMA = 1
+
+CAPTURE_KIND = "pyamplicol-recurrence-z6g-benchmark"
+CAPTURE_SCHEMA = 7
+CAPTURE_ACCEPTANCE_KIND = "pyamplicol-three-lane-layout-capture"
+CAPTURE_ACCEPTANCE_SCHEMA = 6
+PER_LAYOUT_M0_KIND = "pyamplicol-milestone-0-evidence-manifest"
+PER_LAYOUT_M0_SCHEMA = 4
+
+MODES = ("compiled", "eager", "recurrence")
+BATCHES = (1, 128, 1024)
+COMPILED_RECURRENCE_BATCHES = (128, 1024)
+MAX_COMPILED_OVER_RECURRENCE = 1.15
+COMPILED_RECURRENCE_STATISTIC = "ratio-of-recomputed-subprocess-medians-v1"
+LAYOUTS = ("topology-replay", "all-flow-union")
+MODELS = ("built-in-sm", "ufo-sm")
+MIN_SAMPLES = 7
+RTOL = 1.0e-12
+ATOL = 1.0e-15
+PROCESS = "u u~ > z g g g g g g"
+EXTERNAL_LEG_COUNT = 9
+LC_COLOR_WORD_LENGTH = 8
+BUILTIN_PACKAGED_MODEL_RESOURCE_ID = "built-in-sm-jit-o2"
+PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL = 2
+
+SELECTED_WORKLOAD = "single-runtime-selected-flow/helicity-sum"
+UNION_WORKLOAD = "all-flows/runtime-selected-single-helicity"
+AMPLICOL_SELECTED_ROLE = "selected-flow-helicity-sum"
+AMPLICOL_UNION_ROLE = "all-flow-single-helicity"
+
+_SHA256_LENGTH = 64
+_CAPTURE_ROOT_KEYS = {
+    "kind",
+    "schema_version",
+    "complete",
+    "passes",
+    "capture_acceptance",
+    "milestone0_acceptance",
+    "recurrence_runtime_acceptance",
+    "source",
+    "runtime_provenance",
+    "provenance",
+    "process",
+    "process_name",
+    "workload",
+    "configuration",
+    "generation",
+    "profile_schedule",
+    "validation_preflight",
+    "paired_profile_coordination",
+    "profiles",
+    "validation_summary",
+    "selector_contracts_match",
+    "validation_fixtures_match",
+    "lane_comparisons",
+    "result_json",
+}
+_REQUEST_KEYS = {
+    "kind",
+    "schema_version",
+    "captures",
+    "amplicol_evidence",
+    "expected",
+}
+_EXPECTED_KEYS = {
+    "pyamplicol_source_revision",
+    "amplicol_source_revision",
+    "process",
+    "runtime_provenance_sha256",
+    "host_sha256",
+    "momenta_points_sha256",
+    "normalization_sha256",
+    "model_common_physics_identity_sha256",
+    "generation_model_identities_sha256",
+    "color_flow",
+    "helicity",
+    "external_leg_permutation",
+}
+_FILE_REF_KEYS = {"path", "size_bytes", "sha256"}
+_AMPLICOL_ROOT_KEYS = {
+    "kind",
+    "schema_version",
+    "complete",
+    "evidence_scope",
+    "workload",
+    "source",
+    "host",
+    "process",
+    "physical_axes",
+    "selector",
+    "momenta",
+    "normalization_sha256",
+    "timing",
+    "validation",
+    "binary_evidence",
+    "content_sha256",
+}
+_HOST_KEYS = {
+    "platform",
+    "system",
+    "release",
+    "version",
+    "machine",
+    "processor",
+    "cpu_model",
+    "logical_cpu_count",
+}
+_RUNTIME_KEYS = {
+    "interpreter",
+    "installed_distribution",
+    "active_build_info",
+    "native_extension",
+    "dependencies",
+}
+_FILE_IDENTITY_KEYS = {"path", "resolved_path", "size_bytes", "sha256"}
+_RUNTIME_DEPENDENCIES = {
+    "Cargo.lock",
+    "Cargo.toml",
+    "pyproject.toml",
+    "rust-toolchain.toml",
+    "dependencies/candidate-Cargo.lock",
+    "dependencies/candidate-cargo-config.toml",
+    "dependencies/contributor-lock.toml",
+    "dependencies/install-state.json",
+    "dependencies/python-runtime-lock.toml",
+    "dependencies/release-lock.toml",
+}
+
+
+class EvidenceError(RuntimeError):
+    """Evidence is absent, malformed, inconsistent, or stale."""
+
+
+@dataclass(frozen=True)
+class FileRef:
+    """An expected raw file address from the request manifest."""
+
+    path: Path
+    stated_path: str
+    size_bytes: int
+    sha256: str
+
+
+@dataclass(frozen=True)
+class LoadedJson:
+    """Strictly parsed JSON together with both raw and canonical addresses."""
+
+    ref: FileRef
+    payload: dict[str, Any]
+    canonical_sha256: str
+
+
+@dataclass(frozen=True)
+class Capture:
+    """Validated schema-7 capture and extracted cross-capture contracts."""
+
+    model: str
+    layout: str
+    loaded: LoadedJson
+    source_identity: dict[str, Any]
+    runtime_identity: dict[str, Any]
+    host: dict[str, Any]
+    fixture: dict[str, Any]
+    normalization_sha256: str
+    model_common_sha256: str
+    generation_models_sha256: str
+    color_axis: dict[str, Any]
+    helicity_axis: dict[str, Any]
+    runtime_selector_semantics_sha256: str
+    reduction_ordering_sha256: str
+    execution_schedule_ordering_sha256_by_mode: dict[str, str]
+    selector: dict[str, Any]
+    timings: dict[str, Any]
+    validation_values: tuple[complex, ...]
+
+
+@dataclass(frozen=True)
+class AmpliColEvidence:
+    """Validated raw AmpliCol evidence for one selector workload."""
+
+    role: str
+    loaded: LoadedJson
+    source_identity: dict[str, Any]
+    host: dict[str, Any]
+    momenta_file_sha256: str
+    color_axis: dict[str, Any]
+    helicity_axis: dict[str, Any]
+    selector: dict[str, Any]
+    values: tuple[complex, ...]
+    timing: dict[str, Any]
+    interleave_group_sha256: str
+    interleave_records: tuple[dict[str, Any], ...]
+
+
+def _die(message: str) -> NoReturn:
+    raise EvidenceError(message)
+
+
+def _is_int(value: object) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool)
+
+
+def _is_number(value: object) -> bool:
+    return (
+        isinstance(value, (int, float))
+        and not isinstance(value, bool)
+        and math.isfinite(float(value))
+    )
+
+
+def _require_int(
+    value: object,
+    label: str,
+    *,
+    minimum: int | None = None,
+) -> int:
+    if not _is_int(value):
+        _die(f"{label} must be an integer")
+    assert isinstance(value, int)
+    if minimum is not None and value < minimum:
+        _die(f"{label} must be at least {minimum}")
+    return value
+
+
+def _require_mapping(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict) or any(not isinstance(key, str) for key in value):
+        _die(f"{label} must be a JSON object")
+    return value
+
+
+def _require_list(value: object, label: str) -> list[Any]:
+    if not isinstance(value, list):
+        _die(f"{label} must be a JSON array")
+    return value
+
+
+def _require_exact_keys(
+    value: Mapping[str, object],
+    expected: set[str],
+    label: str,
+) -> None:
+    observed = set(value)
+    if observed != expected:
+        missing = sorted(expected - observed)
+        unknown = sorted(observed - expected)
+        _die(f"{label} keys differ: missing={missing}, unknown={unknown}")
+
+
+def _require_sha256(value: object, label: str) -> str:
+    if (
+        not isinstance(value, str)
+        or len(value) != _SHA256_LENGTH
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        _die(f"{label} must be a lowercase SHA-256 digest")
+    return value
+
+
+def _canonical_bytes(value: object) -> bytes:
+    try:
+        text = json.dumps(
+            value,
+            sort_keys=True,
+            separators=(",", ":"),
+            ensure_ascii=False,
+            allow_nan=False,
+        )
+    except (TypeError, ValueError) as error:
+        raise EvidenceError("evidence is not canonical finite JSON") from error
+    return text.encode("utf-8")
+
+
+def _canonical_sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_bytes(value)).hexdigest()
+
+
+def _reject_constant(value: str) -> NoReturn:
+    raise ValueError(f"non-finite JSON constant {value}")
+
+
+def _reject_duplicate_pairs(pairs: list[tuple[str, object]]) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError(f"duplicate JSON key {key!r}")
+        result[key] = value
+    return result
+
+
+def _strict_json_bytes(raw: bytes, label: str) -> dict[str, Any]:
+    try:
+        text = raw.decode("utf-8", errors="strict")
+        value = json.loads(
+            text,
+            parse_constant=_reject_constant,
+            object_pairs_hook=_reject_duplicate_pairs,
+        )
+    except (UnicodeDecodeError, json.JSONDecodeError, ValueError) as error:
+        raise EvidenceError(f"{label} is not strict JSON: {error}") from error
+    return _require_mapping(value, label)
+
+
+def _file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _file_ref(value: object, *, base: Path, label: str) -> FileRef:
+    raw = _require_mapping(value, label)
+    _require_exact_keys(raw, _FILE_REF_KEYS, label)
+    stated_path = raw["path"]
+    size_bytes = raw["size_bytes"]
+    if not isinstance(stated_path, str) or not stated_path:
+        _die(f"{label}.path must be a non-empty string")
+    if not _is_int(size_bytes) or size_bytes < 0:
+        _die(f"{label}.size_bytes must be a non-negative integer")
+    digest = _require_sha256(raw["sha256"], f"{label}.sha256")
+    candidate = Path(stated_path)
+    path = candidate if candidate.is_absolute() else base / candidate
+    return FileRef(
+        path=path.resolve(strict=False),
+        stated_path=stated_path,
+        size_bytes=size_bytes,
+        sha256=digest,
+    )
+
+
+def _verify_file(ref: FileRef, label: str) -> bytes:
+    try:
+        if not ref.path.is_file():
+            _die(f"{label} does not exist as a regular file: {ref.path}")
+        observed_size = ref.path.stat().st_size
+        if observed_size != ref.size_bytes:
+            _die(
+                f"{label} size drifted: expected {ref.size_bytes}, "
+                f"observed {observed_size}"
+            )
+        raw = ref.path.read_bytes()
+    except OSError as error:
+        raise EvidenceError(f"cannot read {label}: {error}") from error
+    observed_sha256 = hashlib.sha256(raw).hexdigest()
+    if observed_sha256 != ref.sha256:
+        _die(
+            f"{label} content hash drifted: expected {ref.sha256}, "
+            f"observed {observed_sha256}"
+        )
+    return raw
+
+
+def _load_json_ref(ref: FileRef, label: str) -> LoadedJson:
+    raw = _verify_file(ref, label)
+    payload = _strict_json_bytes(raw, label)
+    return LoadedJson(
+        ref=ref,
+        payload=payload,
+        canonical_sha256=_canonical_sha256(payload),
+    )
+
+
+def _load_benchmark_module() -> ModuleType:
+    path = Path(__file__).with_name("recurrence_z6g_benchmark.py")
+    spec = importlib.util.spec_from_file_location(
+        "_arena_m0_recurrence_z6g_benchmark",
+        path,
+    )
+    if spec is None or spec.loader is None:
+        _die(f"cannot load schema-7 validator from {path}")
+    module = importlib.util.module_from_spec(spec)
+    try:
+        spec.loader.exec_module(module)
+    except Exception as error:
+        raise EvidenceError(f"cannot load schema-7 validator: {error}") from error
+    return module
+
+
+def _normalized_process(value: object) -> str:
+    if not isinstance(value, str):
+        _die("process expression must be a string")
+    return " ".join(value.split()).casefold()
+
+
+def _utc(value: object, label: str) -> dt.datetime:
+    if not isinstance(value, str):
+        _die(f"{label} must be an ISO-8601 UTC timestamp")
+    try:
+        parsed = dt.datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as error:
+        raise EvidenceError(f"{label} is not an ISO-8601 timestamp") from error
+    if parsed.tzinfo is None or parsed.utcoffset() != dt.timedelta(0):
+        _die(f"{label} must carry UTC timezone information")
+    return parsed
+
+
+def _complex_values(value: object, label: str) -> tuple[complex, ...]:
+    rows = _require_list(value, label)
+    result: list[complex] = []
+    for index, row in enumerate(rows):
+        pair = _require_list(row, f"{label}[{index}]")
+        if len(pair) != 2 or not all(_is_number(component) for component in pair):
+            _die(f"{label}[{index}] must be a finite [real, imag] pair")
+        result.append(complex(float(pair[0]), float(pair[1])))
+    if not result:
+        _die(f"{label} must not be empty")
+    return tuple(result)
+
+
+def _close(left: complex, right: complex) -> bool:
+    return abs(left - right) <= ATOL + RTOL * abs(right)
+
+
+def _assert_values_close(
+    left: Sequence[complex],
+    right: Sequence[complex],
+    label: str,
+) -> None:
+    if len(left) != len(right):
+        _die(f"{label} point counts differ: {len(left)} != {len(right)}")
+    for index, (lhs, rhs) in enumerate(zip(left, right, strict=True)):
+        if not _close(lhs, rhs):
+            _die(f"{label} differs at point {index}: {lhs!r} versus {rhs!r}")
+
+
+def _amplicol_interleave_group_sha256(
+    records: Sequence[Mapping[str, Any]],
+) -> str:
+    return _canonical_sha256(
+        {
+            "kind": "pyamplicol-m0-paired-interleave",
+            "schema_version": 1,
+            "records": [dict(record) for record in records],
+        }
+    )
+
+
+def _amplicol_source_tree_sha256(
+    identities: Sequence[Mapping[str, Any]],
+) -> str:
+    members = sorted(
+        (
+            {
+                "size_bytes": identity["size_bytes"],
+                "sha256": identity["sha256"],
+            }
+            for identity in identities
+        ),
+        key=lambda identity: (identity["sha256"], identity["size_bytes"]),
+    )
+    return _canonical_sha256(
+        {
+            "kind": "amplicol-source-content-set",
+            "schema_version": 1,
+            "members": members,
+        }
+    )
+
+
+def _path_stripped(value: object) -> object:
+    """Remove location-only fields while retaining all content identities."""
+
+    if isinstance(value, dict):
+        return {
+            key: _path_stripped(item)
+            for key, item in value.items()
+            if key
+            not in {
+                "path",
+                "resolved_path",
+                "checkout",
+                "working_directory",
+            }
+        }
+    if isinstance(value, list):
+        return [_path_stripped(item) for item in value]
+    return value
+
+
+def _validate_file_identity_shape(value: object, label: str) -> dict[str, Any]:
+    identity = _require_mapping(value, label)
+    if not _FILE_IDENTITY_KEYS.issubset(identity):
+        _die(f"{label} lacks path/size/content identity")
+    for key in ("path", "resolved_path"):
+        if not isinstance(identity.get(key), str) or not identity[key]:
+            _die(f"{label}.{key} must be a non-empty path")
+    _require_int(identity.get("size_bytes"), f"{label}.size_bytes", minimum=0)
+    _require_sha256(identity.get("sha256"), f"{label}.sha256")
+    return identity
+
+
+def _validate_host(value: object, label: str) -> dict[str, Any]:
+    host = _require_mapping(value, label)
+    _require_exact_keys(host, _HOST_KEYS, label)
+    for key in ("platform", "system", "release", "version", "machine", "processor"):
+        if not isinstance(host.get(key), str):
+            _die(f"{label}.{key} must be a string")
+    cpu_model = host.get("cpu_model")
+    if cpu_model is not None and (not isinstance(cpu_model, str) or not cpu_model):
+        _die(f"{label}.cpu_model must be null or a non-empty string")
+    _require_int(
+        host.get("logical_cpu_count"),
+        f"{label}.logical_cpu_count",
+        minimum=1,
+    )
+    return host
+
+
+def _runtime_semantics(
+    runtime: object,
+    *,
+    source_revision: str,
+) -> dict[str, Any]:
+    raw = _require_mapping(runtime, "capture.runtime_provenance")
+    _require_exact_keys(raw, _RUNTIME_KEYS, "capture.runtime_provenance")
+    interpreter = _validate_file_identity_shape(
+        raw.get("interpreter"),
+        "capture.runtime_provenance.interpreter",
+    )
+    for key in ("python_version", "implementation"):
+        if not isinstance(interpreter.get(key), str) or not interpreter[key]:
+            _die(f"capture.runtime_provenance.interpreter.{key} is missing")
+    native = _validate_file_identity_shape(
+        raw.get("native_extension"),
+        "capture.runtime_provenance.native_extension",
+    )
+    if (
+        not isinstance(native.get("package_version"), str)
+        or not native["package_version"]
+    ):
+        _die("capture runtime native extension has no package version")
+    native_build_inputs = _require_sha256(
+        native.get("build_inputs_sha256"),
+        "capture.runtime_provenance.native_extension.build_inputs_sha256",
+    )
+
+    distribution = _require_mapping(
+        raw.get("installed_distribution"),
+        "capture.runtime_provenance.installed_distribution",
+    )
+    _require_exact_keys(
+        distribution,
+        {
+            "package_version",
+            "distribution_content",
+            "native_modules",
+            "build_info_files",
+        },
+        "capture.runtime_provenance.installed_distribution",
+    )
+    distribution_version = distribution.get("package_version")
+    native_version = native["package_version"]
+    if (
+        not isinstance(distribution_version, str)
+        or not distribution_version
+        or not isinstance(native_version, str)
+        or native_version.replace("-dev.", ".dev") != distribution_version
+    ):
+        _die("capture runtime package versions are incomplete or inconsistent")
+    distribution_content = _require_mapping(
+        distribution.get("distribution_content"),
+        "capture runtime distribution content",
+    )
+    _require_exact_keys(
+        distribution_content,
+        {"algorithm", "sha256", "file_count", "size_bytes"},
+        "capture runtime distribution content",
+    )
+    if distribution_content.get("algorithm") != "sha256-relative-path-size-content-v1":
+        _die("capture runtime distribution content algorithm is unsupported")
+    _require_sha256(
+        distribution_content.get("sha256"),
+        "capture runtime distribution content SHA-256",
+    )
+    _require_int(
+        distribution_content.get("file_count"),
+        "capture runtime distribution file count",
+        minimum=1,
+    )
+    _require_int(
+        distribution_content.get("size_bytes"),
+        "capture runtime distribution size",
+        minimum=1,
+    )
+    for collection in ("native_modules", "build_info_files"):
+        identities = _require_list(
+            distribution.get(collection),
+            f"capture runtime distribution {collection}",
+        )
+        for index, identity in enumerate(identities):
+            _validate_file_identity_shape(
+                identity,
+                f"capture runtime distribution {collection}[{index}]",
+            )
+
+    build_info = _validate_file_identity_shape(
+        raw.get("active_build_info"),
+        "capture.runtime_provenance.active_build_info",
+    )
+    build_payload = _require_mapping(
+        build_info.get("payload"),
+        "capture.runtime_provenance.active_build_info.payload",
+    )
+    if (
+        build_payload.get("source_revision") != source_revision
+        or build_payload.get("native_build_inputs_sha256") != native_build_inputs
+    ):
+        _die("capture active build info is not bound to source/native inputs")
+
+    dependencies = _require_mapping(
+        raw.get("dependencies"),
+        "capture.runtime_provenance.dependencies",
+    )
+    if set(dependencies) != _RUNTIME_DEPENDENCIES:
+        _die("capture runtime dependency inventory is incomplete or has unknown keys")
+    for name, identity_value in dependencies.items():
+        identity = _require_mapping(
+            identity_value,
+            f"capture.runtime_provenance.dependencies.{name}",
+        )
+        present = identity.get("present")
+        if present is True:
+            _validate_file_identity_shape(
+                identity,
+                f"capture.runtime_provenance.dependencies.{name}",
+            )
+        elif present is False:
+            if not isinstance(identity.get("path"), str) or not isinstance(
+                identity.get("resolved_path"), str
+            ):
+                _die(f"capture absent dependency {name} has no path identity")
+        else:
+            _die(f"capture dependency {name} has no exact presence flag")
+    stripped = _path_stripped(raw)
+    return _require_mapping(stripped, "path-stripped runtime provenance")
+
+
+def _source_semantics(source: object) -> dict[str, Any]:
+    raw = _require_mapping(source, "capture.source")
+    revision = raw.get("revision")
+    if not isinstance(revision, str) or len(revision) != 40:
+        _die("capture source revision is not a full Git SHA")
+    if raw.get("dirty") is not False or raw.get("untracked_files_checked") is not True:
+        _die("capture source was not a clean, untracked-files-checked checkout")
+    return {
+        "revision": revision,
+        "dirty": False,
+        "untracked_files_checked": True,
+    }
+
+
+def _revalidation_arguments(configuration: Mapping[str, Any]) -> SimpleNamespace:
+    return SimpleNamespace(
+        modes=configuration.get("modes"),
+        batch_size=configuration.get("batch_sizes"),
+        subprocess_samples=configuration.get("subprocess_samples"),
+        minimum_samples=configuration.get("minimum_samples"),
+        warmup_runs=configuration.get("warmup_runs"),
+        target_runtime=configuration.get("target_runtime_seconds"),
+        color_flow=configuration.get("color_flow_request"),
+        helicity=configuration.get("helicity_request"),
+        lc_flow_layout=configuration.get("lc_flow_layout"),
+        jit_optimization_level=configuration.get("jit_optimization_level"),
+        prepared_model_path=configuration.get("prepared_model_path"),
+        process_expression=None,
+        gluon_count=configuration.get("gluon_count"),
+        specialize_flow_at_generation=configuration.get(
+            "specialize_flow_at_generation"
+        ),
+        generation_only=configuration.get("generation_only"),
+    )
+
+
+def _revalidate_capture(
+    loaded: LoadedJson,
+    *,
+    model: str,
+    layout: str,
+    benchmark: ModuleType,
+) -> None:
+    payload = loaded.payload
+    _require_exact_keys(payload, _CAPTURE_ROOT_KEYS, f"{model}/{layout} capture")
+    if (
+        payload.get("kind") != CAPTURE_KIND
+        or payload.get("schema_version") != CAPTURE_SCHEMA
+    ):
+        _die(f"{model}/{layout} is not an exact schema-7 capture")
+    if payload.get("complete") is not True or payload.get("passes") is not True:
+        _die(f"{model}/{layout} root is incomplete or non-passing")
+    configuration = _require_mapping(
+        payload.get("configuration"),
+        f"{model}/{layout}.configuration",
+    )
+    arguments = _revalidation_arguments(configuration)
+    profiles = _require_mapping(payload.get("profiles"), f"{model}/{layout}.profiles")
+    schedule = _require_mapping(
+        payload.get("profile_schedule"),
+        f"{model}/{layout}.profile_schedule",
+    )
+    try:
+        recomputed_summary = benchmark._pairwise_profile_validation(profiles)
+        recomputed_capture = benchmark._capture_acceptance(
+            arguments,
+            profiles,
+            recomputed_summary,
+            profile_schedule=schedule,
+        )
+        recomputed_m0 = benchmark._milestone0_acceptance_manifest(
+            arguments,
+            recomputed_capture,
+        )
+        recomputed_preflight = benchmark._validation_preflight_contract(
+            arguments,
+            {
+                mode: profiles[mode]
+                for mode in benchmark.AUTHORITATIVE_EXECUTION_MODES
+                if mode in profiles
+            },
+        )
+    except Exception as error:
+        raise EvidenceError(
+            f"{model}/{layout} raw schema-7 evidence failed revalidation: {error}"
+        ) from error
+    preflight = _require_mapping(
+        payload.get("validation_preflight"),
+        f"{model}/{layout}.validation_preflight",
+    )
+    stored_preflight_contract = {
+        key: value
+        for key, value in preflight.items()
+        if key != "worker_evidence"
+    }
+    if stored_preflight_contract != recomputed_preflight:
+        _die(f"{model}/{layout} stored validation preflight is stale or forged")
+    if payload.get("paired_profile_coordination") is not None:
+        _die(
+            f"{model}/{layout} portability capture unexpectedly uses paired "
+            "profile coordination"
+        )
+    if payload.get("validation_summary") != recomputed_summary:
+        _die(f"{model}/{layout} stored validation summary is stale or forged")
+    if payload.get("capture_acceptance") != recomputed_capture:
+        _die(f"{model}/{layout} stored capture acceptance is stale or forged")
+    if payload.get("milestone0_acceptance") != recomputed_m0:
+        _die(f"{model}/{layout} per-layout M0 record is stale or forged")
+    if payload.get("selector_contracts_match") is not True:
+        _die(f"{model}/{layout} selectors do not match across execution lanes")
+    if payload.get("validation_fixtures_match") is not True:
+        _die(f"{model}/{layout} validation fixtures do not match")
+    if payload.get("lane_comparisons") != recomputed_summary.get("comparisons"):
+        _die(f"{model}/{layout} lane comparisons are stale or forged")
+
+
+def _validate_root_worker_bindings(
+    payload: Mapping[str, Any],
+    *,
+    label: str,
+) -> None:
+    source_sha256 = _canonical_sha256(payload.get("source"))
+    runtime = _require_mapping(
+        payload.get("runtime_provenance"),
+        f"{label}.runtime_provenance",
+    )
+    runtime_sha256 = _canonical_sha256(runtime)
+    interpreter = _require_mapping(
+        runtime.get("interpreter"),
+        f"{label}.runtime_provenance.interpreter",
+    )
+    native = _require_mapping(
+        runtime.get("native_extension"),
+        f"{label}.runtime_provenance.native_extension",
+    )
+    expected_bindings = {
+        "source_identity_sha256": source_sha256,
+        "runtime_provenance_sha256": runtime_sha256,
+        "interpreter_sha256": _require_sha256(
+            interpreter.get("sha256"),
+            f"{label}.runtime interpreter SHA-256",
+        ),
+        "native_extension_sha256": _require_sha256(
+            native.get("sha256"),
+            f"{label}.runtime native extension SHA-256",
+        ),
+    }
+    schedule = _require_mapping(
+        payload.get("profile_schedule"),
+        f"{label}.profile_schedule",
+    )
+    entries = _require_list(
+        schedule.get("entries"),
+        f"{label}.profile_schedule.entries",
+    )
+    if not entries:
+        _die(f"{label} profile schedule is empty")
+    for index, entry_value in enumerate(entries):
+        entry = _require_mapping(
+            entry_value,
+            f"{label}.profile_schedule.entries[{index}]",
+        )
+        verification = _require_mapping(
+            entry.get("pre_timing_verification"),
+            f"{label}.profile_schedule.entries[{index}].pre_timing_verification",
+        )
+        for side in ("expected", "observed"):
+            identities = _require_mapping(
+                verification.get(side),
+                f"{label}.profile_schedule.entries[{index}].{side}",
+            )
+            for key, expected_digest in expected_bindings.items():
+                if identities.get(key) != expected_digest:
+                    _die(
+                        f"{label} worker {index} {side} {key} "
+                        "is not bound to the root capture"
+                    )
+
+
+def _axis_contract(
+    semantic: Mapping[str, Any],
+    key: str,
+    label: str,
+) -> dict[str, Any]:
+    axis = _require_mapping(semantic.get(key), f"{label}.{key}")
+    count = _require_int(axis.get("count"), f"{label}.{key}.count", minimum=1)
+    ids = _require_list(axis.get("ordered_ids"), f"{label}.{key}.ordered_ids")
+    entries = _require_list(
+        axis.get("ordered_entries"),
+        f"{label}.{key}.ordered_entries",
+    )
+    if count != len(ids) or count != len(entries):
+        _die(f"{label}.{key} count is incomplete")
+    if len(set(item for item in ids if isinstance(item, str))) != len(ids):
+        _die(f"{label}.{key} ordered IDs are invalid or duplicated")
+    if axis.get("ordered_ids_sha256") != _canonical_sha256(ids):
+        _die(f"{label}.{key} ordered ID digest is stale")
+    if axis.get("ordered_entries_sha256") != _canonical_sha256(entries):
+        _die(f"{label}.{key} ordered entry digest is stale")
+    return axis
+
+
+def _model_common_sha256(
+    semantic: Mapping[str, Any],
+    label: str,
+) -> str:
+    identity = _require_mapping(
+        semantic.get("manifest_model_identity"),
+        f"{label}.manifest_model_identity",
+    )
+    common = _require_mapping(
+        identity.get("common_physics_identity"),
+        f"{label}.model_common_physics_identity",
+    )
+    digest = _require_sha256(
+        identity.get("common_physics_identity_sha256"),
+        f"{label}.model_common_physics_identity_sha256",
+    )
+    if digest != _canonical_sha256(common):
+        _die(f"{label} model common-physics digest is stale")
+    return digest
+
+
+def _semantic_subcontract_sha256(
+    semantic: Mapping[str, Any],
+    *,
+    value_key: str,
+    digest_key: str,
+    label: str,
+) -> str:
+    value = semantic.get(value_key)
+    digest = _require_sha256(
+        semantic.get(digest_key),
+        f"{label}.{digest_key}",
+    )
+    if digest != _canonical_sha256(value):
+        _die(f"{label}.{value_key} digest is stale")
+    return digest
+
+
+def _validate_generation_model_identities(
+    value: object,
+    *,
+    model_family: str,
+    source_revision: str,
+    label: str,
+) -> dict[str, Any]:
+    identities = _require_mapping(value, label)
+    if set(identities) != set(MODES):
+        _die(f"{label} must contain exactly compiled/eager/recurrence")
+    for mode in MODES:
+        identity = _require_mapping(identities[mode], f"{label}.{mode}")
+        kind = identity.get("kind")
+        expected_kind = (
+            "built-in-sm-source"
+            if model_family == "built-in-sm" and mode == "compiled"
+            else (
+                "packaged-prepared-model"
+                if model_family == "built-in-sm"
+                else "explicit-prepared-model"
+            )
+        )
+        if kind != expected_kind:
+            _die(
+                f"{label}.{mode} must use {expected_kind} for "
+                f"the {model_family} capture role"
+            )
+        if not isinstance(identity.get("compile_excluded_from_generation"), bool):
+            _die(f"{label}.{mode} has no exact compile-exclusion flag")
+        if kind == "built-in-sm-source":
+            if (
+                identity.get("source_revision") != source_revision
+                or identity.get("compile_excluded_from_generation") is not False
+            ):
+                _die(f"{label}.{mode} built-in source identity is inconsistent")
+        elif kind == "packaged-prepared-model":
+            if (
+                identity.get("resource_id") != BUILTIN_PACKAGED_MODEL_RESOURCE_ID
+                or identity.get("compile_excluded_from_generation") is not True
+            ):
+                _die(f"{label}.{mode} packaged model identity is incomplete")
+            _require_int(
+                identity.get("size_bytes"),
+                f"{label}.{mode}.size_bytes",
+                minimum=1,
+            )
+            _require_sha256(identity.get("sha256"), f"{label}.{mode}.sha256")
+        else:
+            _validate_file_identity_shape(
+                identity.get("file"),
+                f"{label}.{mode}.file",
+            )
+            if identity.get("compile_excluded_from_generation") is not True:
+                _die(f"{label}.{mode} explicit model must be precompiled")
+            if identity.get("resource_id") is not None:
+                _die(f"{label}.{mode} explicit model resource ID must be null")
+    if model_family == "built-in-sm":
+        if identities["eager"] != identities["recurrence"]:
+            _die(f"{label} eager/recurrence packaged model identities differ")
+    elif model_family == "ufo-sm":
+        if any(identities[mode] != identities["compiled"] for mode in MODES[1:]):
+            _die(f"{label} UFO prepared-model identities differ across lanes")
+    else:
+        _die(f"{label} has an unsupported model-family role")
+    return identities
+
+
+def _expected_effective_jit_optimization_level(
+    model_identity: Mapping[str, Any],
+    *,
+    mode: str,
+) -> int:
+    kind = model_identity.get("kind")
+    if kind not in {
+        "built-in-sm-source",
+        "packaged-prepared-model",
+        "explicit-prepared-model",
+    }:
+        _die("generation model identity has an unsupported source kind")
+    if mode not in MODES:
+        _die(f"generation execution mode is unsupported: {mode!r}")
+    if mode == "compiled":
+        return 3
+    return PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL
+
+
+def _selector_entry(
+    axis: Mapping[str, Any],
+    *,
+    stable_id: str,
+    field: str,
+    expected_value: object,
+    label: str,
+) -> dict[str, Any]:
+    entries = _require_list(axis.get("ordered_entries"), f"{label}.ordered_entries")
+    matches = [
+        entry
+        for entry in entries
+        if isinstance(entry, dict) and entry.get("id") == stable_id
+    ]
+    if len(matches) != 1:
+        _die(f"{label} does not contain stable selector {stable_id!r} exactly once")
+    entry = matches[0]
+    if entry.get(field) != expected_value:
+        _die(f"{label} stable selector {stable_id!r} has the wrong {field}")
+    if entry.get("structural_zero") is True:
+        _die(f"{label} stable selector {stable_id!r} is structurally zero")
+    return entry
+
+
+def _capture_timings(payload: Mapping[str, Any], label: str) -> dict[str, Any]:
+    profiles = _require_mapping(payload.get("profiles"), f"{label}.profiles")
+    result: dict[str, Any] = {}
+    for mode in MODES:
+        profile = _require_mapping(profiles.get(mode), f"{label}.profiles.{mode}")
+        measurements = _require_list(
+            profile.get("profiles"),
+            f"{label}.profiles.{mode}.profiles",
+        )
+        by_batch: dict[str, Any] = {}
+        for measurement in measurements:
+            row = _require_mapping(measurement, f"{label} {mode} timing row")
+            batch = row.get("batch_size")
+            if batch not in BATCHES:
+                _die(f"{label} {mode} has an unexpected timing batch {batch!r}")
+            samples = _require_list(
+                row.get("subprocess_samples"),
+                f"{label} {mode} batch {batch} samples",
+            )
+            values = [
+                float(
+                    _require_number(
+                        sample,
+                        "wall_seconds_per_point",
+                        f"{label} {mode} batch {batch} sample",
+                        positive=True,
+                    )
+                )
+                for sample in samples
+                if isinstance(sample, dict)
+            ]
+            if len(values) != len(samples) or len(values) < MIN_SAMPLES:
+                _die(f"{label} {mode} batch {batch} lacks seven raw samples")
+            median = statistics.median(values)
+            mad = statistics.median(abs(value - median) for value in values)
+            if row.get("wall_seconds_per_point_median") != median:
+                _die(f"{label} {mode} batch {batch} median is stale")
+            if row.get("wall_seconds_per_point_mad") != mad:
+                _die(f"{label} {mode} batch {batch} MAD is stale")
+            by_batch[str(batch)] = {
+                "sample_count": len(values),
+                "median_seconds_per_point": median,
+                "mad_seconds_per_point": mad,
+                "raw_seconds_per_point": values,
+                "timing_boundary": "runtime_core_repeated_wall_time",
+            }
+        if set(by_batch) != {str(batch) for batch in BATCHES}:
+            _die(f"{label} {mode} does not cover batches 1/128/1024")
+        result[mode] = by_batch
+    return result
+
+
+def _require_number(
+    value: Mapping[str, Any],
+    key: str,
+    label: str,
+    *,
+    positive: bool = False,
+) -> float:
+    raw = value.get(key)
+    if not _is_number(raw):
+        _die(f"{label}.{key} must be a finite{' positive' if positive else ''} number")
+    assert isinstance(raw, (int, float)) and not isinstance(raw, bool)
+    if positive and float(raw) <= 0.0:
+        _die(f"{label}.{key} must be a finite positive number")
+    return float(raw)
+
+
+def _capture_fixture_and_values(
+    payload: Mapping[str, Any],
+    label: str,
+) -> tuple[dict[str, Any], tuple[complex, ...]]:
+    profiles = _require_mapping(payload.get("profiles"), f"{label}.profiles")
+    fixtures: list[dict[str, Any]] = []
+    values: list[tuple[complex, ...]] = []
+    for mode in MODES:
+        profile = _require_mapping(profiles.get(mode), f"{label}.profiles.{mode}")
+        validation = _require_mapping(
+            profile.get("validation"),
+            f"{label}.profiles.{mode}.validation",
+        )
+        fixture = _require_mapping(
+            validation.get("fixture"),
+            f"{label}.profiles.{mode}.validation.fixture",
+        )
+        point_count = _require_int(
+            fixture.get("point_count"),
+            f"{label}.{mode}.fixture.point_count",
+            minimum=1,
+        )
+        points_sha = _require_sha256(
+            fixture.get("points_sha256"),
+            f"{label}.{mode}.fixture.points_sha256",
+        )
+        selected = _complex_values(
+            validation.get("selected_totals"),
+            f"{label}.{mode}.selected_totals",
+        )
+        resolved = _complex_values(
+            validation.get("resolved_sums"),
+            f"{label}.{mode}.resolved_sums",
+        )
+        if len(selected) != point_count:
+            _die(f"{label}.{mode} validation point inventory is incomplete")
+        _assert_values_close(selected, resolved, f"{label}.{mode} resolved-sum closure")
+        file_identity = _require_mapping(
+            fixture.get("file"),
+            f"{label}.{mode}.fixture.file",
+        )
+        fixture_path = file_identity.get("resolved_path", file_identity.get("path"))
+        fixture_size = _require_int(
+            file_identity.get("size_bytes"),
+            f"{label}.{mode}.fixture.file.size_bytes",
+            minimum=0,
+        )
+        fixture_sha = _require_sha256(
+            file_identity.get("sha256"),
+            f"{label}.{mode}.fixture.file.sha256",
+        )
+        if not isinstance(fixture_path, str) or not Path(fixture_path).is_absolute():
+            _die(f"{label}.{mode} fixture file identity is invalid")
+        fixture_file = Path(fixture_path).resolve(strict=False)
+        if (
+            not fixture_file.is_file()
+            or fixture_file.stat().st_size != fixture_size
+            or _file_sha256(fixture_file) != fixture_sha
+        ):
+            _die(f"{label}.{mode} validation fixture file drifted")
+        fixtures.append(
+            {
+                "point_count": point_count,
+                "points_sha256": points_sha,
+                "file_sha256": fixture_sha,
+            }
+        )
+        values.append(selected)
+    if any(item != fixtures[0] for item in fixtures[1:]):
+        _die(f"{label} execution lanes use different validation fixtures")
+    for mode, mode_values in zip(MODES[1:], values[1:], strict=True):
+        _assert_values_close(values[0], mode_values, f"{label} compiled versus {mode}")
+    return fixtures[0], values[0]
+
+
+def _validate_capture(
+    loaded: LoadedJson,
+    *,
+    model: str,
+    layout: str,
+    expected: Mapping[str, Any],
+    benchmark: ModuleType,
+) -> Capture:
+    label = f"{model}/{layout}"
+    _revalidate_capture(loaded, model=model, layout=layout, benchmark=benchmark)
+    payload = loaded.payload
+    configuration = _require_mapping(payload["configuration"], f"{label}.configuration")
+    expected_workload = (
+        UNION_WORKLOAD if layout == "all-flow-union" else SELECTED_WORKLOAD
+    )
+    if payload.get("workload") != expected_workload:
+        _die(f"{label} has the wrong workload")
+    if _normalized_process(payload.get("process")) != PROCESS:
+        _die(f"{label} is not the uubar Z+6g standard candle")
+    if configuration.get("lc_flow_layout") != layout:
+        _die(f"{label} configuration layout does not match its request role")
+    if configuration.get("modes") != list(MODES):
+        _die(f"{label} must contain exactly compiled/eager/recurrence")
+    if configuration.get("batch_sizes") != list(BATCHES):
+        _die(f"{label} must contain exactly batches 1/128/1024")
+    _require_int(
+        configuration.get("minimum_samples"),
+        f"{label}.configuration.minimum_samples",
+        minimum=MIN_SAMPLES,
+    )
+    _require_int(
+        configuration.get("subprocess_samples"),
+        f"{label}.configuration.subprocess_samples",
+        minimum=MIN_SAMPLES,
+    )
+    if configuration.get("jit_optimization_level") != 3:
+        _die(f"{label} is not a JIT O3 capture")
+    if configuration.get("generation_only") is not False:
+        _die(f"{label} is generation-only")
+    if configuration.get("specialize_flow_at_generation") is not False:
+        _die(f"{label} is generation-fixed and cannot be a headline capture")
+    if configuration.get("external_watchdog_required_for_long_runs") is not True:
+        _die(f"{label} does not require the 30 GiB external watchdog")
+    capture_acceptance = _require_mapping(
+        payload["capture_acceptance"],
+        f"{label}.capture_acceptance",
+    )
+    if (
+        capture_acceptance.get("kind") != CAPTURE_ACCEPTANCE_KIND
+        or capture_acceptance.get("schema_version") != CAPTURE_ACCEPTANCE_SCHEMA
+        or capture_acceptance.get("complete") is not True
+        or capture_acceptance.get("passes") is not True
+        or capture_acceptance.get("authoritative_eligible") is not True
+    ):
+        _die(f"{label} is not an authoritative passing layout capture")
+    per_layout_m0 = _require_mapping(
+        payload["milestone0_acceptance"],
+        f"{label}.milestone0_acceptance",
+    )
+    if (
+        per_layout_m0.get("kind") != PER_LAYOUT_M0_KIND
+        or per_layout_m0.get("schema_version") != PER_LAYOUT_M0_SCHEMA
+        or per_layout_m0.get("accepted") is not False
+        or per_layout_m0.get("status") != "incomplete"
+    ):
+        _die(f"{label} improperly self-certifies its per-layout M0 evidence")
+
+    source_identity = _source_semantics(payload["source"])
+    if source_identity["revision"] != expected["pyamplicol_source_revision"]:
+        _die(f"{label} source revision differs from the request pin")
+    runtime_identity = _runtime_semantics(
+        payload["runtime_provenance"],
+        source_revision=source_identity["revision"],
+    )
+    if _canonical_sha256(runtime_identity) != expected["runtime_provenance_sha256"]:
+        _die(f"{label} runtime provenance differs from the request pin")
+    provenance = _require_mapping(payload["provenance"], f"{label}.provenance")
+    if provenance.get("external_watchdog_required_for_long_runs") is not True:
+        _die(f"{label} provenance does not record the required external watchdog")
+    host = _validate_host(provenance.get("host"), f"{label}.provenance.host")
+    if _canonical_sha256(host) != expected["host_sha256"]:
+        _die(f"{label} host identity differs from the request pin")
+    _validate_root_worker_bindings(payload, label=label)
+
+    profiles = _require_mapping(payload["profiles"], f"{label}.profiles")
+    compiled = _require_mapping(profiles.get("compiled"), f"{label}.profiles.compiled")
+    semantic = _require_mapping(
+        compiled.get("artifact_semantic_identity"),
+        f"{label}.compiled.artifact_semantic_identity",
+    )
+    coverage = _require_mapping(
+        semantic.get("coverage"),
+        f"{label}.compiled.artifact_semantic_identity.coverage",
+    )
+    if coverage.get("complete_physical_axes") is not True:
+        _die(f"{label} does not retain complete physical axes")
+    if semantic.get("generation_specialized_axes") != []:
+        _die(f"{label} has generation-specialized axes")
+    color_axis = _axis_contract(semantic, "physical_color_flows", label)
+    helicity_axis = _axis_contract(semantic, "physical_helicities", label)
+    runtime_selector_semantics_sha = _semantic_subcontract_sha256(
+        semantic,
+        value_key="runtime_selector_semantics",
+        digest_key="runtime_selector_semantics_sha256",
+        label=label,
+    )
+    reduction_ordering_sha = _semantic_subcontract_sha256(
+        semantic,
+        value_key="reduction_ordering",
+        digest_key="reduction_ordering_sha256",
+        label=label,
+    )
+    execution_schedule_ordering_by_mode: dict[str, str] = {}
+    for mode in MODES:
+        mode_profile = _require_mapping(
+            profiles.get(mode),
+            f"{label}.profiles.{mode}",
+        )
+        mode_semantic = _require_mapping(
+            mode_profile.get("artifact_semantic_identity"),
+            f"{label}.profiles.{mode}.artifact_semantic_identity",
+        )
+        execution_schedule_ordering_by_mode[mode] = _semantic_subcontract_sha256(
+            mode_semantic,
+            value_key="execution_schedule_ordering",
+            digest_key="execution_schedule_ordering_sha256",
+            label=f"{label}.{mode}",
+        )
+    normalization = _require_sha256(
+        semantic.get("normalization_sha256"),
+        f"{label}.normalization_sha256",
+    )
+    if normalization != expected["normalization_sha256"]:
+        _die(f"{label} normalization differs from the request pin")
+    model_common_sha = _model_common_sha256(semantic, label)
+    model_identity = _require_mapping(
+        semantic.get("manifest_model_identity"),
+        f"{label}.manifest_model_identity",
+    )
+    model_common = _require_mapping(
+        model_identity.get("common_physics_identity"),
+        f"{label}.model_common_physics_identity",
+    )
+    expected_model_name = "built-in-sm" if model == "built-in-sm" else "sm"
+    if model_common.get("name") != expected_model_name:
+        _die(f"{label} has the wrong model-family identity")
+    expected_model_sha = expected["model_common_physics_identity_sha256"][model]
+    if model_common_sha != expected_model_sha:
+        _die(f"{label} model identity differs from the request pin")
+
+    generation_model_identities = _validate_generation_model_identities(
+        configuration.get("model_identities"),
+        model_family=model,
+        source_revision=source_identity["revision"],
+        label=f"{label}.configuration.model_identities",
+    )
+    generation_models_sha = _canonical_sha256(
+        _path_stripped(generation_model_identities)
+    )
+    if generation_models_sha != expected["generation_model_identities_sha256"][model]:
+        _die(f"{label} generation model identities differ from the request pin")
+    prepared_model_path = configuration.get("prepared_model_path")
+    if model == "built-in-sm":
+        if prepared_model_path is not None:
+            _die(f"{label} built-in capture must not use an explicit prepared model")
+    else:
+        ufo_file = _require_mapping(
+            generation_model_identities["compiled"].get("file"),
+            f"{label}.configuration.model_identities.compiled.file",
+        )
+        if not isinstance(
+            prepared_model_path, str
+        ) or prepared_model_path != ufo_file.get("resolved_path"):
+            _die(f"{label} UFO prepared-model path is not identity-bound")
+
+    generation = _require_mapping(payload["generation"], f"{label}.generation")
+    if set(generation) != set(MODES):
+        _die(f"{label} generation inventory is incomplete")
+    for mode in MODES:
+        record = _require_mapping(generation[mode], f"{label}.generation.{mode}")
+        expected_mode_model = generation_model_identities[mode]
+        if record.get("model_source") != expected_mode_model:
+            _die(f"{label} generation lane {mode} model source is not bound")
+        contract = _require_mapping(
+            record.get("effective_contract"),
+            f"{label}.generation.{mode}.effective_contract",
+        )
+        expected_effective_jit_level = _expected_effective_jit_optimization_level(
+            expected_mode_model,
+            mode=mode,
+        )
+        if (
+            contract.get("execution_mode") != mode
+            or contract.get("backend") != "jit"
+            or contract.get("jit_optimization_level") != expected_effective_jit_level
+            or contract.get("color_accuracy") != "lc"
+            or contract.get("lc_flow_layout") != layout
+        ):
+            _die(
+                f"{label} generation lane {mode} has the wrong effective "
+                "JIT optimization level"
+            )
+        signature = _require_mapping(
+            record.get("semantic_generation_signature"),
+            f"{label}.generation.{mode}.semantic_generation_signature",
+        )
+        signature_digest = _require_sha256(
+            record.get("semantic_generation_signature_sha256"),
+            f"{label}.generation.{mode}.semantic_generation_signature_sha256",
+        )
+        if signature_digest != _canonical_sha256(signature):
+            _die(f"{label} generation lane {mode} signature digest is stale")
+        if (
+            signature.get("source_revision") != source_identity["revision"]
+            or signature.get("runtime_provenance_sha256")
+            != _canonical_sha256(payload["runtime_provenance"])
+            or signature.get("mode") != mode
+            or _normalized_process(signature.get("process")) != PROCESS
+            or signature.get("lc_flow_layout") != layout
+            or signature.get("jit_optimization_level") != 3
+            or signature.get("model") != expected_mode_model
+        ):
+            _die(f"{label} generation lane {mode} signature is not root-bound")
+        mode_profile = _require_mapping(
+            profiles.get(mode),
+            f"{label}.profiles.{mode}",
+        )
+        if record.get("artifact_semantic_identity") != mode_profile.get(
+            "artifact_semantic_identity"
+        ) or record.get("artifact_semantic_identity_sha256") != mode_profile.get(
+            "artifact_semantic_identity_sha256"
+        ):
+            _die(f"{label} generation lane {mode} artifact semantics are not bound")
+
+    expected_color = _require_mapping(expected["color_flow"], "expected.color_flow")
+    expected_helicity = _require_mapping(expected["helicity"], "expected.helicity")
+    color_id = expected_color["id"]
+    helicity_id = expected_helicity["id"]
+    _selector_entry(
+        color_axis,
+        stable_id=color_id,
+        field="word",
+        expected_value=expected_color["word"],
+        label=f"{label}.physical_color_flows",
+    )
+    _selector_entry(
+        helicity_axis,
+        stable_id=helicity_id,
+        field="values",
+        expected_value=expected_helicity["values"],
+        label=f"{label}.physical_helicities",
+    )
+    selector = _require_mapping(
+        compiled.get("selector_contract"),
+        f"{label}.compiled.selector_contract",
+    )
+    if layout == "topology-replay":
+        if (
+            selector.get("resolved_color_flow_id") != color_id
+            or selector.get("resolved_helicity_id") is not None
+        ):
+            _die(f"{label} does not runtime-select the pinned physical flow")
+    elif (
+        selector.get("resolved_color_flow_id") is not None
+        or selector.get("resolved_helicity_id") != helicity_id
+    ):
+        _die(f"{label} does not runtime-select the pinned source helicity")
+    for mode in MODES[1:]:
+        other = _require_mapping(profiles[mode], f"{label}.profiles.{mode}")
+        if other.get("selector_contract") != selector:
+            _die(f"{label} lane selectors differ")
+
+    fixture, values = _capture_fixture_and_values(payload, label)
+    if fixture["points_sha256"] != expected["momenta_points_sha256"]:
+        _die(f"{label} momenta fixture differs from the request pin")
+    return Capture(
+        model=model,
+        layout=layout,
+        loaded=loaded,
+        source_identity=source_identity,
+        runtime_identity=runtime_identity,
+        host=host,
+        fixture=fixture,
+        normalization_sha256=normalization,
+        model_common_sha256=model_common_sha,
+        generation_models_sha256=generation_models_sha,
+        color_axis=color_axis,
+        helicity_axis=helicity_axis,
+        runtime_selector_semantics_sha256=runtime_selector_semantics_sha,
+        reduction_ordering_sha256=reduction_ordering_sha,
+        execution_schedule_ordering_sha256_by_mode=(
+            execution_schedule_ordering_by_mode
+        ),
+        selector=selector,
+        timings=_capture_timings(payload, label),
+        validation_values=values,
+    )
+
+
+def _validate_embedded_file_ref(value: object, label: str) -> dict[str, Any]:
+    raw = _require_mapping(value, label)
+    _require_exact_keys(raw, _FILE_REF_KEYS, label)
+    path_value = raw["path"]
+    size = raw["size_bytes"]
+    digest = _require_sha256(raw["sha256"], f"{label}.sha256")
+    if not isinstance(path_value, str) or not Path(path_value).is_absolute():
+        _die(f"{label}.path must be an absolute path")
+    if not _is_int(size) or size < 0:
+        _die(f"{label}.size_bytes must be a non-negative integer")
+    path = Path(path_value).resolve(strict=False)
+    if not path.is_file():
+        _die(f"{label} file is missing: {path}")
+    if path.stat().st_size != size or _file_sha256(path) != digest:
+        _die(f"{label} file content drifted")
+    return {"path": str(path), "size_bytes": size, "sha256": digest}
+
+
+def _validate_amplicol_raw_sample(
+    identity: Mapping[str, Any],
+    *,
+    role: str,
+    sample_index: int,
+    command_sha256: str,
+    evaluated_point_count: int,
+    elapsed_seconds: float,
+    seconds_per_point: float,
+    selected_values: Sequence[complex],
+    resolved_values: Sequence[complex],
+    label: str,
+) -> None:
+    path = Path(identity["path"])
+    try:
+        payload = _strict_json_bytes(path.read_bytes(), label)
+    except OSError as error:
+        raise EvidenceError(f"cannot read {label}: {error}") from error
+    _require_exact_keys(
+        payload,
+        {
+            "kind",
+            "schema_version",
+            "role",
+            "sample_index",
+            "command_sha256",
+            "evaluated_point_count",
+            "elapsed_seconds",
+            "seconds_per_point",
+            "stdout",
+            "stdout_sha256",
+            "content_sha256",
+        },
+        label,
+    )
+    without_digest = dict(payload)
+    content_sha256 = without_digest.pop("content_sha256")
+    if (
+        payload.get("kind") != "pyamplicol-amplicol-m0-raw-sample"
+        or payload.get("schema_version") != 1
+        or _require_sha256(content_sha256, f"{label}.content_sha256")
+        != _canonical_sha256(without_digest)
+        or payload.get("role") != role
+        or payload.get("sample_index") != sample_index
+        or payload.get("command_sha256") != command_sha256
+        or payload.get("evaluated_point_count") != evaluated_point_count
+        or payload.get("elapsed_seconds") != elapsed_seconds
+        or payload.get("seconds_per_point") != seconds_per_point
+    ):
+        _die(f"{label} is not bound to its timing sample")
+    stdout = payload.get("stdout")
+    if not isinstance(stdout, str) or not stdout:
+        _die(f"{label}.stdout must retain non-empty raw probe output")
+    stdout_sha256 = _require_sha256(
+        payload.get("stdout_sha256"),
+        f"{label}.stdout_sha256",
+    )
+    if stdout_sha256 != hashlib.sha256(stdout.encode("utf-8")).hexdigest():
+        _die(f"{label}.stdout digest is stale")
+    stdout_payload = _strict_json_bytes(
+        stdout.encode("utf-8"),
+        f"{label}.stdout",
+    )
+    _require_exact_keys(
+        stdout_payload,
+        {
+            "kind",
+            "schema_version",
+            "role",
+            "sample_index",
+            "evaluated_point_count",
+            "elapsed_seconds",
+            "seconds_per_point",
+            "selected_totals",
+            "resolved_sums",
+        },
+        f"{label}.stdout",
+    )
+    if (
+        stdout_payload.get("kind") != "amplicol-m0-probe-result"
+        or stdout_payload.get("schema_version") != 1
+        or stdout_payload.get("role") != role
+        or stdout_payload.get("sample_index") != sample_index
+        or stdout_payload.get("evaluated_point_count") != evaluated_point_count
+        or stdout_payload.get("elapsed_seconds") != elapsed_seconds
+        or stdout_payload.get("seconds_per_point") != seconds_per_point
+    ):
+        _die(f"{label}.stdout probe fields are not bound to the sample")
+    stdout_selected = _complex_values(
+        stdout_payload.get("selected_totals"),
+        f"{label}.stdout.selected_totals",
+    )
+    stdout_resolved = _complex_values(
+        stdout_payload.get("resolved_sums"),
+        f"{label}.stdout.resolved_sums",
+    )
+    _assert_values_close(
+        selected_values,
+        stdout_selected,
+        f"{label}.stdout selected totals",
+    )
+    _assert_values_close(
+        resolved_values,
+        stdout_resolved,
+        f"{label}.stdout resolved sums",
+    )
+
+
+def _validate_amplicol(
+    loaded: LoadedJson,
+    *,
+    role: str,
+    expected: Mapping[str, Any],
+) -> AmpliColEvidence:
+    payload = loaded.payload
+    label = f"amplicol/{role}"
+    _require_exact_keys(payload, _AMPLICOL_ROOT_KEYS, label)
+    if payload.get("kind") != AMPLICOL_KIND or payload.get("schema_version") != 1:
+        _die(f"{label} has the wrong evidence schema")
+    without_digest = dict(payload)
+    content_sha = without_digest.pop("content_sha256")
+    if _require_sha256(content_sha, f"{label}.content_sha256") != _canonical_sha256(
+        without_digest
+    ):
+        _die(f"{label} canonical content digest is stale")
+    if payload.get("complete") is not True:
+        _die(f"{label} is incomplete")
+    if payload.get("evidence_scope") != "authoritative-host-capture-v1":
+        _die(
+            f"{label} is fixture, synthetic, diagnostic, or otherwise non-authoritative"
+        )
+    expected_workload = (
+        SELECTED_WORKLOAD if role == AMPLICOL_SELECTED_ROLE else UNION_WORKLOAD
+    )
+    if payload.get("workload") != expected_workload:
+        _die(f"{label} has the wrong workload")
+
+    source = _require_mapping(payload.get("source"), f"{label}.source")
+    _require_exact_keys(
+        source,
+        {"revision", "dirty", "compiler", "source_tree_sha256"},
+        f"{label}.source",
+    )
+    if (
+        source.get("revision") != expected["amplicol_source_revision"]
+        or source.get("dirty") is not False
+    ):
+        _die(f"{label} source revision/cleanliness differs from the request pin")
+    _require_sha256(source.get("source_tree_sha256"), f"{label}.source_tree_sha256")
+    compiler = _require_mapping(source.get("compiler"), f"{label}.source.compiler")
+    _require_exact_keys(
+        compiler,
+        {"id", "version", "target", "flags_sha256"},
+        f"{label}.source.compiler",
+    )
+    if any(
+        not isinstance(compiler.get(key), str) or not compiler[key]
+        for key in ("id", "version", "target")
+    ):
+        _die(f"{label} compiler identity is incomplete")
+    _require_sha256(
+        compiler.get("flags_sha256"),
+        f"{label}.source.compiler.flags_sha256",
+    )
+
+    host = _validate_host(payload.get("host"), f"{label}.host")
+    if _canonical_sha256(host) != expected["host_sha256"]:
+        _die(f"{label} host identity differs from the request pin")
+    process = _require_mapping(payload.get("process"), f"{label}.process")
+    _require_exact_keys(
+        process,
+        {"expression", "normalized_expression"},
+        f"{label}.process",
+    )
+    if (
+        _normalized_process(process.get("expression")) != PROCESS
+        or process.get("normalized_expression") != PROCESS
+    ):
+        _die(f"{label} is not the uubar Z+6g standard candle")
+
+    physical_axes = _require_mapping(
+        payload.get("physical_axes"),
+        f"{label}.physical_axes",
+    )
+    _require_exact_keys(
+        physical_axes,
+        {"color_flow", "helicity"},
+        f"{label}.physical_axes",
+    )
+    selector = _require_mapping(payload.get("selector"), f"{label}.selector")
+    _require_exact_keys(
+        selector,
+        {
+            "color_flow_request",
+            "resolved_color_flow_id",
+            "color_flow_word",
+            "helicity_request",
+            "resolved_helicity_id",
+            "helicity_values",
+            "sum_axis",
+            "source_to_generated_permutation",
+            "complete_physical_axes",
+            "generation_specialized_axes",
+        },
+        f"{label}.selector",
+    )
+    color_expected = _require_mapping(expected["color_flow"], "expected.color_flow")
+    helicity_expected = _require_mapping(expected["helicity"], "expected.helicity")
+    if selector.get("complete_physical_axes") is not True:
+        _die(f"{label} does not retain complete physical axes")
+    if selector.get("generation_specialized_axes") != []:
+        _die(f"{label} is a generation-fixed diagnostic")
+    permutation = _require_list(
+        selector.get("source_to_generated_permutation"),
+        f"{label}.selector.source_to_generated_permutation",
+    )
+    if (
+        len(permutation) != EXTERNAL_LEG_COUNT
+        or any(not _is_int(item) or item < 0 for item in permutation)
+        or sorted(permutation) != list(range(EXTERNAL_LEG_COUNT))
+    ):
+        _die(f"{label} source-to-generated permutation is invalid")
+    if permutation != expected["external_leg_permutation"]:
+        _die(f"{label} source-to-generated permutation differs from the request pin")
+    if any(
+        not isinstance(selector.get(key), str) or not selector[key]
+        for key in ("color_flow_request", "helicity_request")
+    ):
+        _die(f"{label} runtime selector requests are invalid")
+    if role == AMPLICOL_SELECTED_ROLE:
+        selector_ok = (
+            selector.get("resolved_color_flow_id") == color_expected["id"]
+            and selector.get("color_flow_word") == color_expected["word"]
+            and selector.get("resolved_helicity_id") is None
+            and selector.get("sum_axis") == "helicity"
+        )
+    else:
+        selector_ok = (
+            selector.get("resolved_color_flow_id") is None
+            and selector.get("resolved_helicity_id") == helicity_expected["id"]
+            and selector.get("helicity_values") == helicity_expected["values"]
+            and selector.get("sum_axis") == "color_flow"
+        )
+    if not selector_ok:
+        _die(f"{label} resolved selector does not match the request pin")
+
+    validated_axes: dict[str, dict[str, Any]] = {}
+    for axis_name in ("color_flow", "helicity"):
+        axis = _require_mapping(
+            physical_axes.get(axis_name),
+            f"{label}.physical_axes.{axis_name}",
+        )
+        _require_exact_keys(
+            axis,
+            {"count", "ordered_ids_sha256"},
+            f"{label}.physical_axes.{axis_name}",
+        )
+        if not _is_int(axis.get("count")) or axis["count"] <= 0:
+            _die(f"{label}.{axis_name} physical-axis count is invalid")
+        _require_sha256(
+            axis.get("ordered_ids_sha256"),
+            f"{label}.{axis_name}.ordered_ids_sha256",
+        )
+        validated_axes[axis_name] = axis
+
+    momenta = _require_mapping(payload.get("momenta"), f"{label}.momenta")
+    _require_exact_keys(
+        momenta,
+        {"point_count", "points_sha256", "raw_file"},
+        f"{label}.momenta",
+    )
+    point_count = _require_int(
+        momenta.get("point_count"),
+        f"{label}.momenta.point_count",
+        minimum=1,
+    )
+    if momenta.get("points_sha256") != expected["momenta_points_sha256"]:
+        _die(f"{label} momenta differ from the request pin")
+    momenta_file = _validate_embedded_file_ref(
+        momenta.get("raw_file"),
+        f"{label}.momenta.raw_file",
+    )
+    if payload.get("normalization_sha256") != expected["normalization_sha256"]:
+        _die(f"{label} normalization differs from the request pin")
+
+    binary = _require_mapping(
+        payload.get("binary_evidence"),
+        f"{label}.binary_evidence",
+    )
+    _require_exact_keys(
+        binary,
+        {"executable", "linked_libraries", "source_files"},
+        f"{label}.binary_evidence",
+    )
+    evidence_paths: list[str] = []
+    executable = _validate_embedded_file_ref(
+        binary.get("executable"),
+        f"{label}.binary_evidence.executable",
+    )
+    if not os.access(executable["path"], os.X_OK):
+        _die(f"{label} content-addressed executable is not executable")
+    evidence_paths.append(executable["path"])
+    source_file_identities: list[dict[str, Any]] = []
+    for collection in ("linked_libraries", "source_files"):
+        rows = _require_list(
+            binary.get(collection),
+            f"{label}.binary_evidence.{collection}",
+        )
+        if not rows:
+            _die(f"{label}.binary_evidence.{collection} must not be empty")
+        for index, row in enumerate(rows):
+            identity = _validate_embedded_file_ref(
+                row,
+                f"{label}.binary_evidence.{collection}[{index}]",
+            )
+            evidence_paths.append(identity["path"])
+            if collection == "source_files":
+                source_file_identities.append(identity)
+    if len(set(evidence_paths)) != len(evidence_paths):
+        _die(f"{label} binary/source evidence files are duplicated")
+    if source.get("source_tree_sha256") != _amplicol_source_tree_sha256(
+        source_file_identities
+    ):
+        _die(f"{label} source-tree digest is not bound to source files")
+
+    validation = _require_mapping(payload.get("validation"), f"{label}.validation")
+    _require_exact_keys(
+        validation,
+        {
+            "selected_totals",
+            "resolved_sums",
+            "point_comparisons",
+            "maximum_absolute_difference",
+            "maximum_relative_difference",
+            "passes",
+        },
+        f"{label}.validation",
+    )
+    selected = _complex_values(
+        validation.get("selected_totals"),
+        f"{label}.validation.selected_totals",
+    )
+    resolved = _complex_values(
+        validation.get("resolved_sums"),
+        f"{label}.validation.resolved_sums",
+    )
+    if len(selected) != point_count:
+        _die(f"{label} validation point inventory is incomplete")
+    _assert_values_close(selected, resolved, f"{label} resolved-sum closure")
+    comparisons = _require_list(
+        validation.get("point_comparisons"),
+        f"{label}.validation.point_comparisons",
+    )
+    if len(comparisons) != point_count:
+        _die(f"{label} point-comparison inventory is incomplete")
+    max_abs = 0.0
+    max_rel = 0.0
+    for index, (lhs, rhs, comparison) in enumerate(
+        zip(selected, resolved, comparisons, strict=True)
+    ):
+        row = _require_mapping(comparison, f"{label}.point_comparisons[{index}]")
+        if row.get("point_index") != index:
+            _die(f"{label} point-comparison indices are not source ordered")
+        difference = abs(lhs - rhs)
+        relative = difference / max(abs(rhs), ATOL)
+        max_abs = max(max_abs, difference)
+        max_rel = max(max_rel, relative)
+        if row.get("passes") is not _close(lhs, rhs):
+            _die(f"{label} point-comparison pass flag is stale")
+    if (
+        validation.get("passes") is not True
+        or validation.get("maximum_absolute_difference") != max_abs
+        or validation.get("maximum_relative_difference") != max_rel
+    ):
+        _die(f"{label} validation summary is stale or non-passing")
+
+    timing = _require_mapping(payload.get("timing"), f"{label}.timing")
+    _require_exact_keys(
+        timing,
+        {
+            "boundary",
+            "batch_semantics",
+            "statistics_contract",
+            "interleave_group_sha256",
+            "sample_count",
+            "median_seconds_per_point",
+            "mad_seconds_per_point",
+            "samples",
+            "samples_sha256",
+        },
+        f"{label}.timing",
+    )
+    expected_boundary = (
+        "amplitude-evaluation"
+        if role == AMPLICOL_SELECTED_ROLE
+        else "direct-library-total"
+    )
+    if (
+        timing.get("boundary") != expected_boundary
+        or timing.get("batch_semantics") != "scalar-normalized-per-point"
+        or timing.get("statistics_contract") != "subprocess-median-and-raw-mad-v1"
+    ):
+        _die(f"{label} timing boundary/statistics are not authoritative")
+    interleave_group_sha256 = _require_sha256(
+        timing.get("interleave_group_sha256"),
+        f"{label}.timing.interleave_group_sha256",
+    )
+    samples = _require_list(timing.get("samples"), f"{label}.timing.samples")
+    if len(samples) < MIN_SAMPLES or timing.get("sample_count") != len(samples):
+        _die(f"{label} has fewer than seven subprocess timing samples")
+    if timing.get("samples_sha256") != _canonical_sha256(samples):
+        _die(f"{label} raw timing sample digest is stale")
+    values: list[float] = []
+    raw_paths: list[str] = []
+    previous_finish: dt.datetime | None = None
+    rounds: list[int] = []
+    command_hashes: set[str] = set()
+    interleave_records: list[dict[str, Any]] = []
+    for index, sample in enumerate(samples):
+        row = _require_mapping(sample, f"{label}.timing.samples[{index}]")
+        _require_exact_keys(
+            row,
+            {
+                "sample_index",
+                "interleave_round",
+                "interleave_position",
+                "started_at_utc",
+                "finished_at_utc",
+                "subprocess",
+                "command",
+                "command_sha256",
+                "evaluated_point_count",
+                "elapsed_seconds",
+                "seconds_per_point",
+                "interrupted",
+                "raw_output_file",
+            },
+            f"{label}.timing.samples[{index}]",
+        )
+        if row.get("sample_index") != index or row.get("subprocess") is not True:
+            _die(f"{label} timing samples are not independent subprocess records")
+        round_index = _require_int(
+            row.get("interleave_round"),
+            f"{label} sample {index} interleave round",
+            minimum=0,
+        )
+        interleave_position = _require_int(
+            row.get("interleave_position"),
+            f"{label} sample {index} interleave position",
+            minimum=0,
+        )
+        rounds.append(round_index)
+        started = _utc(row.get("started_at_utc"), f"{label} sample {index} start")
+        finished = _utc(row.get("finished_at_utc"), f"{label} sample {index} finish")
+        if started >= finished or (
+            previous_finish is not None and started < previous_finish
+        ):
+            _die(f"{label} timing samples are overlapping or not chronological")
+        previous_finish = finished
+        command = _require_list(
+            row.get("command"),
+            f"{label} sample {index} command",
+        )
+        if not command or any(
+            not isinstance(item, str) or not item for item in command
+        ):
+            _die(f"{label} sample {index} command is invalid")
+        selector_argument = (
+            f"--color-flow-id={color_expected['id']}"
+            if role == AMPLICOL_SELECTED_ROLE
+            else f"--helicity-id={helicity_expected['id']}"
+        )
+        required_arguments = {
+            f"--workload={role}",
+            f"--round={index}",
+            f"--momenta={momenta_file['path']}",
+            f"--source-revision={source['revision']}",
+            selector_argument,
+        }
+        if command[0] != executable["path"] or not required_arguments.issubset(
+            command[1:]
+        ):
+            _die(f"{label} sample {index} command is not bound to its evidence")
+        command_sha = _require_sha256(
+            row.get("command_sha256"),
+            f"{label} sample {index} command SHA",
+        )
+        if command_sha != _canonical_sha256(command):
+            _die(f"{label} sample {index} command digest is stale")
+        if command_sha in command_hashes:
+            _die(f"{label} timing subprocess commands are not independently addressed")
+        command_hashes.add(command_sha)
+        evaluated = _require_int(
+            row.get("evaluated_point_count"),
+            f"{label} sample {index} evaluated-point count",
+            minimum=1,
+        )
+        elapsed = _require_number(
+            row,
+            "elapsed_seconds",
+            f"{label} sample {index}",
+            positive=True,
+        )
+        seconds_per_point = _require_number(
+            row,
+            "seconds_per_point",
+            f"{label} sample {index}",
+            positive=True,
+        )
+        process_envelope_seconds = (finished - started).total_seconds()
+        if elapsed > process_envelope_seconds + max(
+            1.0e-9,
+            process_envelope_seconds * 1.0e-9,
+        ):
+            _die(f"{label} sample {index} timing exceeds its subprocess envelope")
+        if not math.isclose(
+            seconds_per_point,
+            elapsed / evaluated,
+            rel_tol=0.0,
+            abs_tol=max(1.0e-18, abs(seconds_per_point) * 1.0e-15),
+        ):
+            _die(f"{label} sample {index} seconds/point is stale")
+        if row.get("interrupted") is not False:
+            _die(f"{label} sample {index} was interrupted")
+        raw_file = _validate_embedded_file_ref(
+            row.get("raw_output_file"),
+            f"{label}.timing.samples[{index}].raw_output_file",
+        )
+        _validate_amplicol_raw_sample(
+            raw_file,
+            role=role,
+            sample_index=index,
+            command_sha256=command_sha,
+            evaluated_point_count=evaluated,
+            elapsed_seconds=elapsed,
+            seconds_per_point=seconds_per_point,
+            selected_values=selected,
+            resolved_values=resolved,
+            label=f"{label}.timing.samples[{index}].raw_output",
+        )
+        raw_paths.append(raw_file["path"])
+        values.append(seconds_per_point)
+        interleave_records.append(
+            {
+                "role": role,
+                "round": round_index,
+                "position": interleave_position,
+                "started_at_utc": row["started_at_utc"],
+                "finished_at_utc": row["finished_at_utc"],
+                "command_sha256": command_sha,
+            }
+        )
+    if sorted(rounds) != list(range(len(samples))):
+        _die(f"{label} timing samples do not cover unique interleave rounds")
+    if len(set(raw_paths)) != len(raw_paths):
+        _die(f"{label} timing samples reuse raw-output files")
+    median = statistics.median(values)
+    mad = statistics.median(abs(value - median) for value in values)
+    if (
+        timing.get("median_seconds_per_point") != median
+        or timing.get("mad_seconds_per_point") != mad
+    ):
+        _die(f"{label} median/MAD is stale")
+    return AmpliColEvidence(
+        role=role,
+        loaded=loaded,
+        source_identity=source,
+        host=host,
+        momenta_file_sha256=momenta_file["sha256"],
+        color_axis=validated_axes["color_flow"],
+        helicity_axis=validated_axes["helicity"],
+        selector=selector,
+        values=selected,
+        timing={
+            "sample_count": len(values),
+            "median_seconds_per_point": median,
+            "mad_seconds_per_point": mad,
+            "raw_seconds_per_point": values,
+            "timing_boundary": expected_boundary,
+            "batch_semantics": "scalar-normalized-per-point",
+        },
+        interleave_group_sha256=interleave_group_sha256,
+        interleave_records=tuple(interleave_records),
+    )
+
+
+def _validate_expected(value: object) -> dict[str, Any]:
+    expected = _require_mapping(value, "request.expected")
+    _require_exact_keys(expected, _EXPECTED_KEYS, "request.expected")
+    for key in ("pyamplicol_source_revision", "amplicol_source_revision"):
+        revision = expected.get(key)
+        if (
+            not isinstance(revision, str)
+            or len(revision) != 40
+            or any(character not in "0123456789abcdef" for character in revision)
+        ):
+            _die(f"request.expected.{key} must be a full lowercase Git SHA")
+    if _normalized_process(expected.get("process")) != PROCESS:
+        _die("request.expected.process must be the uubar Z+6g standard candle")
+    for key in (
+        "runtime_provenance_sha256",
+        "host_sha256",
+        "momenta_points_sha256",
+        "normalization_sha256",
+    ):
+        _require_sha256(expected.get(key), f"request.expected.{key}")
+    for key in (
+        "model_common_physics_identity_sha256",
+        "generation_model_identities_sha256",
+    ):
+        mapping = _require_mapping(expected.get(key), f"request.expected.{key}")
+        if set(mapping) != set(MODELS):
+            _die(f"request.expected.{key} must pin built-in-sm and ufo-sm")
+        for model in MODELS:
+            _require_sha256(mapping[model], f"request.expected.{key}.{model}")
+    color = _require_mapping(expected.get("color_flow"), "request.expected.color_flow")
+    _require_exact_keys(color, {"id", "word"}, "request.expected.color_flow")
+    if not isinstance(color.get("id"), str) or not color["id"].startswith("flow:"):
+        _die("request expected color flow must use a stable flow ID")
+    word = _require_list(color.get("word"), "request.expected.color_flow.word")
+    if len(word) != LC_COLOR_WORD_LENGTH or any(not _is_int(item) for item in word):
+        _die("request expected color-flow word is invalid")
+    helicity = _require_mapping(expected.get("helicity"), "request.expected.helicity")
+    _require_exact_keys(helicity, {"id", "values"}, "request.expected.helicity")
+    if not isinstance(helicity.get("id"), str) or not helicity["id"].startswith("h:"):
+        _die("request expected helicity must use a stable helicity ID")
+    values = _require_list(helicity.get("values"), "request.expected.helicity.values")
+    if len(values) != EXTERNAL_LEG_COUNT or any(
+        item not in (-1, 1) or isinstance(item, bool) for item in values
+    ):
+        _die("request expected helicity values are invalid")
+    permutation = _require_list(
+        expected.get("external_leg_permutation"),
+        "request.expected.external_leg_permutation",
+    )
+    if (
+        len(permutation) != EXTERNAL_LEG_COUNT
+        or any(not _is_int(item) for item in permutation)
+        or sorted(permutation) != list(range(EXTERNAL_LEG_COUNT))
+    ):
+        _die("request expected external-leg permutation is invalid")
+    return expected
+
+
+def _request_refs(
+    request: Mapping[str, Any],
+    request_dir: Path,
+) -> tuple[dict[tuple[str, str], FileRef], dict[str, FileRef]]:
+    captures = _require_mapping(request.get("captures"), "request.captures")
+    if set(captures) != set(MODELS):
+        _die("request.captures must contain exactly built-in-sm and ufo-sm")
+    capture_refs: dict[tuple[str, str], FileRef] = {}
+    for model in MODELS:
+        layouts = _require_mapping(captures[model], f"request.captures.{model}")
+        if set(layouts) != set(LAYOUTS):
+            _die(f"request.captures.{model} must contain exactly both LC layouts")
+        for layout in LAYOUTS:
+            capture_refs[(model, layout)] = _file_ref(
+                layouts[layout],
+                base=request_dir,
+                label=f"request.captures.{model}.{layout}",
+            )
+    amplicol = _require_mapping(
+        request.get("amplicol_evidence"),
+        "request.amplicol_evidence",
+    )
+    roles = {AMPLICOL_SELECTED_ROLE, AMPLICOL_UNION_ROLE}
+    if set(amplicol) != roles:
+        _die("request.amplicol_evidence must contain exactly both selector workloads")
+    amplicol_refs = {
+        role: _file_ref(
+            amplicol[role],
+            base=request_dir,
+            label=f"request.amplicol_evidence.{role}",
+        )
+        for role in sorted(roles)
+    }
+    resolved_paths = [
+        ref.path for ref in (*capture_refs.values(), *amplicol_refs.values())
+    ]
+    if len(set(resolved_paths)) != len(resolved_paths):
+        _die("request evidence paths must be six distinct files")
+    return capture_refs, amplicol_refs
+
+
+def _cross_validate(
+    captures: Mapping[tuple[str, str], Capture],
+    amplicol: Mapping[str, AmpliColEvidence],
+) -> dict[str, Any]:
+    capture_values = list(captures.values())
+    first = capture_values[0]
+    for current in capture_values[1:]:
+        if current.source_identity != first.source_identity:
+            _die("pyAmpliCol source identities differ across captures")
+        if current.runtime_identity != first.runtime_identity:
+            _die("pyAmpliCol runtime identities differ across captures")
+        if current.host != first.host:
+            _die("host identities differ across pyAmpliCol captures")
+        if current.fixture != first.fixture:
+            _die("validation sample/momenta identities differ across captures")
+        if current.normalization_sha256 != first.normalization_sha256:
+            _die("normalization identities differ across captures")
+        if (
+            current.runtime_selector_semantics_sha256
+            != first.runtime_selector_semantics_sha256
+        ):
+            _die("runtime-selector semantics differ across captures")
+        if current.reduction_ordering_sha256 != first.reduction_ordering_sha256:
+            _die("logical reduction ordering differs across captures")
+        for axis_name in ("color_axis", "helicity_axis"):
+            if getattr(current, axis_name) != getattr(first, axis_name):
+                _die(f"ordered physical {axis_name} contracts differ across captures")
+    for layout in LAYOUTS:
+        if (
+            captures[("built-in-sm", layout)].execution_schedule_ordering_sha256_by_mode
+            != captures[("ufo-sm", layout)].execution_schedule_ordering_sha256_by_mode
+        ):
+            _die(f"execution schedule ordering differs across models for {layout}")
+        _assert_values_close(
+            captures[("built-in-sm", layout)].validation_values,
+            captures[("ufo-sm", layout)].validation_values,
+            f"built-in versus UFO pointwise values for {layout}",
+        )
+    for model in MODELS:
+        topology = captures[(model, "topology-replay")]
+        layout_union_capture = captures[(model, "all-flow-union")]
+        if topology.model_common_sha256 != layout_union_capture.model_common_sha256:
+            _die(f"{model} model identity differs between LC layouts")
+        if (
+            topology.generation_models_sha256
+            != layout_union_capture.generation_models_sha256
+        ):
+            _die(f"{model} generation model identities differ between LC layouts")
+    if (
+        captures[("built-in-sm", "topology-replay")].model_common_sha256
+        == captures[("ufo-sm", "topology-replay")].model_common_sha256
+    ):
+        _die("built-in and UFO captures unexpectedly share one model identity")
+    compiled_recurrence = _compiled_recurrence_acceptance(captures)
+
+    selected = amplicol[AMPLICOL_SELECTED_ROLE]
+    union_evidence = amplicol[AMPLICOL_UNION_ROLE]
+    if selected.source_identity != union_evidence.source_identity:
+        _die("AmpliCol workloads use different source/compiler identities")
+    if selected.host != first.host or union_evidence.host != first.host:
+        _die("AmpliCol and pyAmpliCol captures do not share one host identity")
+    if (
+        selected.momenta_file_sha256 != first.fixture["file_sha256"]
+        or union_evidence.momenta_file_sha256 != first.fixture["file_sha256"]
+    ):
+        _die("AmpliCol raw momenta file differs from the pyAmpliCol fixture")
+    expected_color_axis = {
+        "count": first.color_axis["count"],
+        "ordered_ids_sha256": first.color_axis["ordered_ids_sha256"],
+    }
+    expected_helicity_axis = {
+        "count": first.helicity_axis["count"],
+        "ordered_ids_sha256": first.helicity_axis["ordered_ids_sha256"],
+    }
+    for evidence in (selected, union_evidence):
+        if evidence.color_axis != expected_color_axis:
+            _die(f"AmpliCol {evidence.role} color-flow axis differs from pyAmpliCol")
+        if evidence.helicity_axis != expected_helicity_axis:
+            _die(f"AmpliCol {evidence.role} helicity axis differs from pyAmpliCol")
+    topology_selector = captures[("built-in-sm", "topology-replay")].selector
+    union_selector = captures[("built-in-sm", "all-flow-union")].selector
+    if (
+        selected.selector["color_flow_request"]
+        != topology_selector["color_flow_request"]
+        or selected.selector["helicity_request"]
+        != topology_selector["helicity_request"]
+        or union_evidence.selector["color_flow_request"]
+        != union_selector["color_flow_request"]
+        or union_evidence.selector["helicity_request"]
+        != union_selector["helicity_request"]
+    ):
+        _die("AmpliCol runtime selector requests differ from pyAmpliCol")
+    if selected.interleave_group_sha256 != union_evidence.interleave_group_sha256:
+        _die("AmpliCol workloads do not share one interleave schedule")
+    combined_interleave = sorted(
+        (*selected.interleave_records, *union_evidence.interleave_records),
+        key=lambda record: record["position"],
+    )
+    if [record["position"] for record in combined_interleave] != list(
+        range(len(combined_interleave))
+    ):
+        _die("AmpliCol interleave positions are incomplete or duplicated")
+    previous_finish: dt.datetime | None = None
+    command_hashes: set[str] = set()
+    roles_by_round: dict[int, list[str]] = {}
+    for expected_position, record in enumerate(combined_interleave):
+        expected_role = (
+            AMPLICOL_SELECTED_ROLE
+            if expected_position % 2 == 0
+            else AMPLICOL_UNION_ROLE
+        )
+        expected_round = expected_position // 2
+        if (
+            record["position"] != expected_position
+            or record["role"] != expected_role
+            or record["round"] != expected_round
+        ):
+            _die(
+                "AmpliCol combined schedule is not paired "
+                "selected/all-flow interleaving"
+            )
+        round_index = record["round"]
+        assert isinstance(round_index, int)
+        roles_by_round.setdefault(round_index, []).append(record["role"])
+        started = _utc(record["started_at_utc"], "AmpliCol interleave start")
+        finished = _utc(record["finished_at_utc"], "AmpliCol interleave finish")
+        if previous_finish is not None and started < previous_finish:
+            _die("AmpliCol workload subprocesses were not interleaved chronologically")
+        previous_finish = finished
+        command_sha = record["command_sha256"]
+        if command_sha in command_hashes:
+            _die("AmpliCol interleaved subprocess commands are duplicated")
+        command_hashes.add(command_sha)
+    if (
+        len(roles_by_round) < MIN_SAMPLES
+        or set(roles_by_round) != set(range(len(roles_by_round)))
+        or any(
+            roles
+            != [
+                AMPLICOL_SELECTED_ROLE,
+                AMPLICOL_UNION_ROLE,
+            ]
+            for roles in roles_by_round.values()
+        )
+    ):
+        _die("AmpliCol workloads lack seven paired interleaved rounds")
+    expected_interleave_sha256 = _amplicol_interleave_group_sha256(combined_interleave)
+    if selected.interleave_group_sha256 != expected_interleave_sha256:
+        _die("AmpliCol interleave-group content digest is stale")
+    _assert_values_close(
+        captures[("built-in-sm", "topology-replay")].validation_values,
+        selected.values,
+        "pyAmpliCol versus AmpliCol selected-flow values",
+    )
+    _assert_values_close(
+        captures[("built-in-sm", "all-flow-union")].validation_values,
+        union_evidence.values,
+        "pyAmpliCol versus AmpliCol all-flow values",
+    )
+    return {
+        "point_count": first.fixture["point_count"],
+        "pyamplicol_cross_model_and_layout_parity": True,
+        "amplicol_selected_flow_parity": True,
+        "amplicol_all_flow_parity": True,
+        "relative_tolerance": RTOL,
+        "absolute_tolerance": ATOL,
+        "compiled_recurrence_runtime_ceiling": compiled_recurrence,
+    }
+
+
+def _input_identity(loaded: LoadedJson) -> dict[str, Any]:
+    return {
+        "path": str(loaded.ref.path),
+        "size_bytes": loaded.ref.size_bytes,
+        "raw_sha256": loaded.ref.sha256,
+        "canonical_payload_sha256": loaded.canonical_sha256,
+    }
+
+
+def _compiled_recurrence_measurement(
+    timings: Mapping[str, Any],
+    *,
+    mode: str,
+    batch: int,
+    label: str,
+) -> dict[str, Any]:
+    """Recompute one ceiling-gate measurement from its retained raw samples."""
+
+    mode_timings = _require_mapping(timings.get(mode), f"{label}.{mode}")
+    measurement = _require_mapping(
+        mode_timings.get(str(batch)),
+        f"{label}.{mode}.batch-{batch}",
+    )
+    samples = _require_list(
+        measurement.get("raw_seconds_per_point"),
+        f"{label}.{mode}.batch-{batch}.raw_seconds_per_point",
+    )
+    values: list[float] = []
+    for index, sample in enumerate(samples):
+        if not _is_number(sample) or float(sample) <= 0.0:
+            _die(
+                f"{label}.{mode}.batch-{batch} raw sample {index} "
+                "must be a finite positive number"
+            )
+        values.append(float(sample))
+    sample_count = _require_int(
+        measurement.get("sample_count"),
+        f"{label}.{mode}.batch-{batch}.sample_count",
+        minimum=MIN_SAMPLES,
+    )
+    if sample_count != len(values):
+        _die(f"{label}.{mode}.batch-{batch} raw sample count is inconsistent")
+    median = statistics.median(values)
+    mad = statistics.median(abs(value - median) for value in values)
+    if measurement.get("median_seconds_per_point") != median:
+        _die(f"{label}.{mode}.batch-{batch} retained median is stale")
+    if measurement.get("mad_seconds_per_point") != mad:
+        _die(f"{label}.{mode}.batch-{batch} retained MAD is stale")
+    if measurement.get("timing_boundary") != "runtime_core_repeated_wall_time":
+        _die(f"{label}.{mode}.batch-{batch} timing boundary is invalid")
+    return {
+        "sample_count": sample_count,
+        "median_seconds_per_point": median,
+        "mad_seconds_per_point": mad,
+    }
+
+
+def _compiled_recurrence_acceptance(
+    captures: Mapping[tuple[str, str], Capture],
+) -> dict[str, Any]:
+    """Require compiled qq_Z6g to stay within 15% of recurrence."""
+
+    cells: dict[str, Any] = {}
+    for model in MODELS:
+        model_cells: dict[str, Any] = {}
+        for layout in LAYOUTS:
+            label = f"{model}/{layout}"
+            capture = captures.get((model, layout))
+            if capture is None:
+                _die(f"{label} capture is absent from the recurrence ceiling gate")
+            batch_cells: dict[str, Any] = {}
+            for batch in COMPILED_RECURRENCE_BATCHES:
+                compiled = _compiled_recurrence_measurement(
+                    capture.timings,
+                    mode="compiled",
+                    batch=batch,
+                    label=label,
+                )
+                recurrence = _compiled_recurrence_measurement(
+                    capture.timings,
+                    mode="recurrence",
+                    batch=batch,
+                    label=label,
+                )
+                compiled_median = compiled["median_seconds_per_point"]
+                recurrence_median = recurrence["median_seconds_per_point"]
+                assert isinstance(compiled_median, float)
+                assert isinstance(recurrence_median, float)
+                ratio = compiled_median / recurrence_median
+                passes = (
+                    compiled_median <= recurrence_median * MAX_COMPILED_OVER_RECURRENCE
+                )
+                if not passes:
+                    _die(
+                        f"{label} compiled qq_Z6g exceeds the recurrence ceiling "
+                        f"at batch {batch}: {ratio:.17g} > "
+                        f"{MAX_COMPILED_OVER_RECURRENCE:.17g} "
+                        f"(compiled median={compiled_median:.17g}, "
+                        f"compiled raw MAD="
+                        f"{compiled['mad_seconds_per_point']:.17g}, "
+                        f"recurrence median={recurrence_median:.17g}, "
+                        f"recurrence raw MAD="
+                        f"{recurrence['mad_seconds_per_point']:.17g})"
+                    )
+                batch_cells[str(batch)] = {
+                    "statistic": COMPILED_RECURRENCE_STATISTIC,
+                    "compiled": compiled,
+                    "recurrence": recurrence,
+                    "compiled_over_recurrence": ratio,
+                    "maximum_compiled_over_recurrence": (MAX_COMPILED_OVER_RECURRENCE),
+                    "passes": True,
+                }
+            model_cells[layout] = batch_cells
+        cells[model] = model_cells
+    return {
+        "statistic": COMPILED_RECURRENCE_STATISTIC,
+        "required_batches": list(COMPILED_RECURRENCE_BATCHES),
+        "maximum_compiled_over_recurrence": MAX_COMPILED_OVER_RECURRENCE,
+        "cells": cells,
+        "passes": True,
+    }
+
+
+def _accepted_manifest(
+    *,
+    request_loaded: LoadedJson,
+    captures: Mapping[tuple[str, str], Capture],
+    amplicol: Mapping[str, AmpliColEvidence],
+    validation: Mapping[str, Any],
+    expected: Mapping[str, Any],
+) -> dict[str, Any]:
+    capture_manifest: dict[str, Any] = {}
+    timings: dict[str, Any] = {
+        SELECTED_WORKLOAD: {},
+        UNION_WORKLOAD: {},
+    }
+    for model in MODELS:
+        capture_manifest[model] = {}
+        for layout in LAYOUTS:
+            capture = captures[(model, layout)]
+            capture_manifest[model][layout] = {
+                "input": _input_identity(capture.loaded),
+                "recomputed_complete": True,
+                "recomputed_passes": True,
+                "resolved_selector": capture.selector,
+                "model_common_physics_identity_sha256": capture.model_common_sha256,
+                "generation_model_identities_sha256": (
+                    capture.generation_models_sha256
+                ),
+            }
+            workload = (
+                UNION_WORKLOAD if layout == "all-flow-union" else SELECTED_WORKLOAD
+            )
+            timings[workload][model] = capture.timings
+    external: dict[str, Any] = {}
+    for role, evidence in amplicol.items():
+        external[role] = {
+            "input": _input_identity(evidence.loaded),
+            "timing": evidence.timing,
+        }
+        workload = (
+            SELECTED_WORKLOAD if role == AMPLICOL_SELECTED_ROLE else UNION_WORKLOAD
+        )
+        timings[workload]["amplicol"] = evidence.timing
+    comparisons: dict[str, Any] = {}
+    for workload in (SELECTED_WORKLOAD, UNION_WORKLOAD):
+        amplicol_timing = timings[workload]["amplicol"]
+        amplicol_median = amplicol_timing["median_seconds_per_point"]
+        model_comparisons: dict[str, Any] = {}
+        for model in MODELS:
+            lane_comparisons: dict[str, Any] = {}
+            for mode in MODES:
+                batch_comparisons: dict[str, Any] = {}
+                for batch in BATCHES:
+                    py_timing = timings[workload][model][mode][str(batch)]
+                    batch_comparisons[str(batch)] = {
+                        "pyamplicol_seconds_per_point": (
+                            py_timing["median_seconds_per_point"]
+                        ),
+                        "amplicol_seconds_per_point": amplicol_median,
+                        "pyamplicol_over_amplicol": (
+                            py_timing["median_seconds_per_point"] / amplicol_median
+                        ),
+                        "pyamplicol_boundary": (py_timing["timing_boundary"]),
+                        "amplicol_boundary": (amplicol_timing["timing_boundary"]),
+                        "amplicol_batch_semantics": (
+                            amplicol_timing["batch_semantics"]
+                        ),
+                    }
+                lane_comparisons[mode] = batch_comparisons
+            model_comparisons[model] = lane_comparisons
+        comparisons[workload] = model_comparisons
+    first = captures[("built-in-sm", "topology-replay")]
+    return {
+        "kind": OUTPUT_KIND,
+        "schema_version": OUTPUT_SCHEMA,
+        "accepted": True,
+        "status": "accepted",
+        "errors": [],
+        "policy": {
+            "required_models": list(MODELS),
+            "required_layouts": list(LAYOUTS),
+            "required_modes": list(MODES),
+            "required_batches": list(BATCHES),
+            "minimum_interleaved_subprocess_samples": MIN_SAMPLES,
+            "jit_optimization_level": 3,
+            "generation_specialized_axes_allowed": False,
+            "timing_statistics": "subprocess-median-and-raw-mad-v1",
+            "relative_tolerance": RTOL,
+            "absolute_tolerance": ATOL,
+            "compiled_recurrence_statistic": COMPILED_RECURRENCE_STATISTIC,
+            "compiled_recurrence_required_batches": list(COMPILED_RECURRENCE_BATCHES),
+            "maximum_compiled_over_recurrence": MAX_COMPILED_OVER_RECURRENCE,
+        },
+        "request_identity": _input_identity(request_loaded),
+        "common_contract": {
+            "process": PROCESS,
+            "source": first.source_identity,
+            "runtime_provenance_sha256": _canonical_sha256(first.runtime_identity),
+            "host_sha256": _canonical_sha256(first.host),
+            "fixture": first.fixture,
+            "normalization_sha256": first.normalization_sha256,
+            "physical_color_flows_sha256": _canonical_sha256(first.color_axis),
+            "physical_helicities_sha256": _canonical_sha256(first.helicity_axis),
+            "runtime_selector_semantics_sha256": (
+                first.runtime_selector_semantics_sha256
+            ),
+            "reduction_ordering_sha256": first.reduction_ordering_sha256,
+            "execution_schedule_ordering_sha256_by_layout": {
+                layout: captures[
+                    (
+                        "built-in-sm",
+                        layout,
+                    )
+                ].execution_schedule_ordering_sha256_by_mode
+                for layout in LAYOUTS
+            },
+            "color_flow": expected["color_flow"],
+            "helicity": expected["helicity"],
+        },
+        "layout_captures": capture_manifest,
+        "external_lanes": external,
+        "validation": dict(validation),
+        "timings": timings,
+        "comparisons": comparisons,
+        "created_at_utc": dt.datetime.now(dt.UTC).isoformat(),
+    }
+
+
+def _rejected_manifest(
+    *,
+    request_path: Path,
+    request_sha256: str,
+    error: str,
+) -> dict[str, Any]:
+    return {
+        "kind": OUTPUT_KIND,
+        "schema_version": OUTPUT_SCHEMA,
+        "accepted": False,
+        "status": "rejected",
+        "errors": [error],
+        "policy": {
+            "required_models": list(MODELS),
+            "required_layouts": list(LAYOUTS),
+            "required_modes": list(MODES),
+            "required_batches": list(BATCHES),
+            "minimum_interleaved_subprocess_samples": MIN_SAMPLES,
+            "jit_optimization_level": 3,
+            "generation_specialized_axes_allowed": False,
+            "compiled_recurrence_statistic": COMPILED_RECURRENCE_STATISTIC,
+            "compiled_recurrence_required_batches": list(COMPILED_RECURRENCE_BATCHES),
+            "maximum_compiled_over_recurrence": MAX_COMPILED_OVER_RECURRENCE,
+        },
+        "request_identity": {
+            "path": str(request_path.resolve(strict=False)),
+            "expected_raw_sha256": request_sha256,
+        },
+        "common_contract": None,
+        "layout_captures": None,
+        "external_lanes": None,
+        "validation": None,
+        "timings": None,
+        "comparisons": None,
+        "created_at_utc": dt.datetime.now(dt.UTC).isoformat(),
+    }
+
+
+def _write_manifest(path: Path, payload: Mapping[str, Any]) -> dict[str, Any]:
+    addressed = dict(payload)
+    addressed["content_sha256"] = _canonical_sha256(addressed)
+    encoded = json.dumps(
+        addressed,
+        indent=2,
+        sort_keys=True,
+        ensure_ascii=False,
+        allow_nan=False,
+    )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    try:
+        temporary.write_text(f"{encoded}\n", encoding="utf-8")
+        os.replace(temporary, path)
+    finally:
+        with contextlib.suppress(FileNotFoundError):
+            temporary.unlink()
+    return addressed
+
+
+def combine(
+    *,
+    request_path: Path,
+    request_sha256: str,
+    output_path: Path,
+) -> tuple[dict[str, Any], int]:
+    """Validate all evidence, always emitting a content-addressed decision."""
+
+    try:
+        _require_sha256(request_sha256, "--request-sha256")
+        request_ref = FileRef(
+            path=request_path.resolve(strict=False),
+            stated_path=str(request_path),
+            size_bytes=request_path.stat().st_size,
+            sha256=request_sha256,
+        )
+        request_loaded = _load_json_ref(request_ref, "request manifest")
+        request = request_loaded.payload
+        _require_exact_keys(request, _REQUEST_KEYS, "request manifest")
+        if (
+            request.get("kind") != REQUEST_KIND
+            or request.get("schema_version") != REQUEST_SCHEMA
+        ):
+            _die("request manifest kind/schema is unsupported")
+        expected = _validate_expected(request.get("expected"))
+        capture_refs, amplicol_refs = _request_refs(
+            request,
+            request_path.resolve(strict=False).parent,
+        )
+        benchmark = _load_benchmark_module()
+        captures = {
+            key: _validate_capture(
+                _load_json_ref(
+                    ref,
+                    f"{key[0]}/{key[1]} capture",
+                ),
+                model=key[0],
+                layout=key[1],
+                expected=expected,
+                benchmark=benchmark,
+            )
+            for key, ref in capture_refs.items()
+        }
+        amplicol = {
+            role: _validate_amplicol(
+                _load_json_ref(ref, f"amplicol/{role} evidence"),
+                role=role,
+                expected=expected,
+            )
+            for role, ref in amplicol_refs.items()
+        }
+        validation = _cross_validate(captures, amplicol)
+        payload = _accepted_manifest(
+            request_loaded=request_loaded,
+            captures=captures,
+            amplicol=amplicol,
+            validation=validation,
+            expected=expected,
+        )
+        return _write_manifest(output_path, payload), 0
+    except Exception as error:
+        message = (
+            str(error)
+            if isinstance(error, (EvidenceError, OSError))
+            else (
+                "internal fail-closed validation error "
+                f"({type(error).__name__}): {error}"
+            )
+        )
+        payload = _rejected_manifest(
+            request_path=request_path,
+            request_sha256=request_sha256,
+            error=message,
+        )
+        return _write_manifest(output_path, payload), 2
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument(
+        "--request",
+        type=Path,
+        required=True,
+        help="strict content-addressed M0 orchestrator request JSON",
+    )
+    result.add_argument(
+        "--request-sha256",
+        required=True,
+        help="expected raw SHA-256 of --request",
+    )
+    result.add_argument(
+        "--output",
+        type=Path,
+        required=True,
+        help="accepted/rejected content-addressed decision JSON",
+    )
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    manifest, exit_code = combine(
+        request_path=arguments.request,
+        request_sha256=arguments.request_sha256,
+        output_path=arguments.output,
+    )
+    print(
+        json.dumps(
+            {
+                "accepted": manifest["accepted"],
+                "status": manifest["status"],
+                "content_sha256": manifest["content_sha256"],
+                "output": str(arguments.output),
+                "errors": manifest["errors"],
+            },
+            sort_keys=True,
+        )
+    )
+    return exit_code
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/pyamplicol/tools/developer/emit_candidate_structural_preflight.py b/pyamplicol/tools/developer/emit_candidate_structural_preflight.py
new file mode 100644
index 0000000000..ae08351c08
--- /dev/null
+++ b/pyamplicol/tools/developer/emit_candidate_structural_preflight.py
@@ -0,0 +1,358 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Atomically attach exact structural restart evidence to one generated artifact."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from pyamplicol.artifacts.manifest import load_manifest
+from pyamplicol.generation.structural_source_proof import (
+    ROLE as STRUCTURAL_SOURCE_PROOF_ROLE,
+)
+from pyamplicol.generation.structural_source_proof import (
+    SEMANTIC_MAP_DOMAINS,
+    validate_generation_structural_proof,
+)
+from tools.developer.catalog_final_source_structural_preflight import (
+    CELL_PROOF_SCHEMA,
+    FinalSourceProducerError,
+)
+from tools.developer.catalog_structural_parity_audit import (
+    _candidate_counts,
+    _compiled_execution_lanes,
+)
+from tools.developer.final_source_numerical_truth import (
+    TruthProducerError,
+    validate_witness_payload,
+)
+from tools.performance_report.models import Workload
+
+PROOF_PATH = "structural-preflight-proof.json"
+_REVISION = re.compile(r"[0-9a-f]{40}")
+
+
+def _read(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text())
+    if not isinstance(value, dict):
+        raise FinalSourceProducerError(f"{path} must contain a JSON object")
+    return value
+
+
+def _execution(artifact: Path) -> tuple[Path, dict[str, Any]]:
+    paths = sorted((artifact / "processes").glob("*/execution.json"))
+    if len(paths) != 1:
+        raise FinalSourceProducerError(
+            "structural proof emission requires exactly one concrete process"
+        )
+    return paths[0], _read(paths[0])
+
+
+def _source_counts(
+    execution: dict[str, Any],
+    workload: Workload,
+) -> tuple[int, int, int]:
+    kind = execution.get("kind")
+    if kind == "pyamplicol-runtime-recurrence-execution":
+        schedule = execution["plan"]["inspection_summary"]["schedule"]
+        count = schedule.get("source_row_count")
+        if not isinstance(count, int) or count <= 0:
+            raise FinalSourceProducerError(
+                "recurrence inspection lacks exact source_row_count"
+            )
+        return count, count, count
+    if kind == "pyamplicol-runtime-eager-execution":
+        count = execution["plan"]["inspection_summary"].get("source_count")
+        if not isinstance(count, int) or count <= 0:
+            raise FinalSourceProducerError("eager inspection lacks exact source_count")
+        return count, count, count
+    if kind != "pyamplicol-runtime-execution":
+        raise FinalSourceProducerError(f"unsupported execution kind {kind!r}")
+    lanes = _compiled_execution_lanes(execution)
+    final = sum(int(record["dag_summary"]["source_count"]) for _, record in lanes)
+    if workload is Workload.ALL_FLOW:
+        active_summary = execution["dag_summary"]
+    else:
+        active_summary = execution["helicity_sum_execution"]["dag_summary"]
+    active = active_summary.get("source_count")
+    if not isinstance(active, int) or active <= 0 or final <= 0:
+        raise FinalSourceProducerError("compiled DAG summaries lack source_count")
+    return active, final, final
+
+
+def _phase(
+    total: Any,
+    source_count: int,
+    closure_count: int | None,
+) -> dict[str, int]:
+    if (
+        total.evaluation_count is None
+        or total.attachment_count is None
+        or closure_count is None
+        or source_count > total.current_count
+    ):
+        raise FinalSourceProducerError(
+            "runtime inspection lacks exact structural/evaluator/closure counts"
+        )
+    return {
+        "source_current_count": source_count,
+        "produced_current_count": total.current_count - source_count,
+        "kernel_evaluation_count": total.evaluation_count,
+        "attachment_count": total.attachment_count,
+        "amplitude_destination_count": closure_count,
+    }
+
+
+def _execution_mode(execution: dict[str, Any]) -> str:
+    try:
+        return {
+            "pyamplicol-runtime-recurrence-execution": "recurrence",
+            "pyamplicol-runtime-execution": "compiled",
+            "pyamplicol-runtime-eager-execution": "eager",
+        }[str(execution.get("kind"))]
+    except KeyError as error:
+        raise FinalSourceProducerError("execution mode is unsupported") from error
+
+
+def _numerical_proof(
+    path: Path,
+    revision: str,
+    *,
+    cell_id: str | None = None,
+    mode: str | None = None,
+    accuracy: str | None = None,
+    workload: str | None = None,
+    candidate_artifact_id: str | None = None,
+    structural_proof_sha256: str | None = None,
+) -> dict[str, Any]:
+    proof = _read(path)
+    try:
+        return validate_witness_payload(
+            proof,
+            expected_source_revision=revision,
+            expected_cell_id=cell_id,
+            expected_mode=mode,
+            expected_accuracy=accuracy,
+            expected_workload=workload,
+            expected_candidate_artifact_id=candidate_artifact_id,
+            expected_structural_proof_sha256=structural_proof_sha256,
+        )
+    except TruthProducerError as error:
+        raise FinalSourceProducerError(
+            "numerical proof is not a recomputable independent precision>=50 witness"
+        ) from error
+
+
+def build_proof(
+    artifact: Path,
+    *,
+    cell_id: str,
+    source_revision: str,
+    workload: Workload,
+    numerical_proof: Path,
+) -> dict[str, Any]:
+    if _REVISION.fullmatch(source_revision) is None:
+        raise FinalSourceProducerError("source revision must be a full Git SHA")
+    manifest = load_manifest(artifact)
+    if manifest.producer.get("git_revision") != source_revision:
+        raise FinalSourceProducerError(
+            "artifact producer revision does not equal the requested final source"
+        )
+    execution_path, execution = _execution(artifact)
+    fake_result = {
+        "artifact": {"path": str(artifact)},
+        "provenance": {"report_measured_source_revision": source_revision},
+    }
+    counts = _candidate_counts(fake_result, workload=workload)
+    active_source, final_source, peak_source = _source_counts(execution, workload)
+    active = _phase(counts.active, active_source, counts.active_closure_count)
+    final = _phase(
+        counts.final_materialized,
+        final_source,
+        counts.final_materialized_closure_count,
+    )
+    peak = _phase(
+        counts.peak_materialized,
+        peak_source,
+        counts.peak_materialized_closure_count,
+    )
+    relative_execution = execution_path.relative_to(artifact).as_posix()
+    execution_record = next(
+        record for record in manifest.payloads if record.path == relative_execution
+    )
+    structural_records = [
+        record
+        for record in manifest.payloads
+        if record.role == STRUCTURAL_SOURCE_PROOF_ROLE
+        and record.process_id == str(execution.get("key"))
+    ]
+    if len(structural_records) != 1:
+        raise FinalSourceProducerError(
+            "artifact must contain exactly one generation structural proof"
+        )
+    structural_record = structural_records[0]
+    structural_path = artifact / structural_record.path
+    structural = _read(structural_path)
+    native_inputs = manifest.producer.get("native_build_inputs_sha256")
+    if not isinstance(native_inputs, str):
+        raise FinalSourceProducerError(
+            "artifact producer native-input identity is absent"
+        )
+    try:
+        generation_proof = validate_generation_structural_proof(
+            structural,
+            artifact_root=artifact,
+            expected_process_id=str(execution.get("key")),
+            expected_source_revision=source_revision,
+            expected_native_build_inputs_sha256=native_inputs,
+            expected_execution_path=relative_execution,
+            expected_execution_sha256=execution_record.sha256,
+            execution=execution,
+        )
+    except ValueError as error:
+        raise FinalSourceProducerError(
+            "generation structural proof does not recompute"
+        ) from error
+    maps = generation_proof["semantic_maps"]
+    assert isinstance(maps, dict)
+    semantic_witnesses = {name: maps[name]["rows"] for name in SEMANTIC_MAP_DOMAINS}
+    semantic_digests = {name: maps[name]["sha256"] for name in SEMANTIC_MAP_DOMAINS}
+    process_id = str(execution.get("key"))
+    if process_id != structural_record.process_id:
+        raise FinalSourceProducerError(
+            "generation structural proof process identity changed"
+        )
+    physical_inventory = generation_proof["physical_lane_inventory"]
+    assert isinstance(physical_inventory, dict)
+    proof = {
+        "schema": CELL_PROOF_SCHEMA,
+        "cell_id": cell_id,
+        "source_revision": source_revision,
+        "artifact_identity": {
+            "artifact_id": manifest.artifact_id,
+            "process_id": process_id,
+            "structural_proof_path": structural_record.path,
+            "structural_proof_sha256": structural_record.sha256,
+        },
+        "color_accuracy": execution.get("color_accuracy"),
+        "workload": workload.value,
+        "active": active,
+        "final_materialized": final,
+        "peak_materialized": peak,
+        "semantic_proof": {
+            "status": "proven",
+            "strength": "exact-symbolic",
+            "source_revision": source_revision,
+            "current_member_map_sha256": semantic_digests["current_member_map"],
+            "interaction_row_map_sha256": semantic_digests["interaction_row_map"],
+            "closure_map_sha256": semantic_digests["closure_map"],
+            "source_contract_sha256": semantic_digests["source_contract"],
+            "witnesses": semantic_witnesses,
+        },
+        "numerical_validation": _numerical_proof(
+            numerical_proof,
+            source_revision,
+            cell_id=cell_id,
+            mode=_execution_mode(execution),
+            accuracy=str(execution.get("color_accuracy")),
+            workload=workload.value,
+            candidate_artifact_id=manifest.artifact_id,
+            structural_proof_sha256=structural_record.sha256,
+        ),
+        "persisted_lane_inventory": physical_inventory,
+    }
+    return proof
+
+
+def emit(
+    artifact: Path,
+    *,
+    cell_id: str,
+    source_revision: str,
+    workload: Workload,
+    numerical_proof: Path,
+    output: Path | None = None,
+) -> Path:
+    proof = build_proof(
+        artifact,
+        cell_id=cell_id,
+        source_revision=source_revision,
+        workload=workload,
+        numerical_proof=numerical_proof,
+    )
+    destination = artifact / PROOF_PATH if output is None else output
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{destination.name}.",
+        suffix=".tmp",
+        dir=destination.parent,
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "w", encoding="ascii") as stream:
+            json.dump(
+                proof,
+                stream,
+                ensure_ascii=True,
+                sort_keys=True,
+                separators=(",", ":"),
+                allow_nan=False,
+            )
+            stream.write("\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, destination)
+    finally:
+        temporary.unlink(missing_ok=True)
+    return destination
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--artifact", type=Path, required=True)
+    parser.add_argument("--cell-id", required=True)
+    parser.add_argument("--source-revision", required=True)
+    parser.add_argument(
+        "--workload",
+        choices=[item.value for item in Workload],
+        required=True,
+    )
+    parser.add_argument("--precision50-proof", type=Path, required=True)
+    parser.add_argument(
+        "--output",
+        type=Path,
+        help=(
+            "atomic per-cell sidecar destination; report workers should place "
+            "this beside the immutable attempt/result"
+        ),
+    )
+    args = parser.parse_args()
+    output = emit(
+        args.artifact,
+        cell_id=args.cell_id,
+        source_revision=args.source_revision,
+        workload=Workload(args.workload),
+        numerical_proof=args.precision50_proof,
+        output=args.output,
+    )
+    print(
+        json.dumps(
+            {
+                "cell_id": args.cell_id,
+                "output": str(output.resolve()),
+                "status": "ok",
+            },
+            sort_keys=True,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/fft_gluon_candidate_probe.cpp b/pyamplicol/tools/developer/fft_gluon_candidate_probe.cpp
new file mode 100644
index 0000000000..51f831306f
--- /dev/null
+++ b/pyamplicol/tools/developer/fft_gluon_candidate_probe.cpp
@@ -0,0 +1,811 @@
+// SPDX-License-Identifier: 0BSD
+
+#include <rusticol.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <sys/resource.h>
+#include <time.h>
+#include <utility>
+#include <vector>
+
+namespace {
+
+constexpr std::size_t kPointCount = 10;
+constexpr std::size_t kWarmSampleCount = 10;
+constexpr std::size_t kRepresentativePoint = 0;
+constexpr double kPi = 3.141592653589793238462643383279502884;
+constexpr double kUnitCouplingAlphaS = 1.0 / (4.0 * kPi);
+
+struct Event {
+    std::vector<double> momenta;
+    std::vector<std::int32_t> helicities;
+};
+
+double process_cpu_seconds() {
+    struct timespec value {};
+    if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &value) != 0) {
+        throw std::runtime_error("clock_gettime(CLOCK_PROCESS_CPUTIME_ID) failed");
+    }
+    return static_cast<double>(value.tv_sec) +
+           static_cast<double>(value.tv_nsec) * 1.0e-9;
+}
+
+double monotonic_wall_seconds() {
+    struct timespec value {};
+    if (clock_gettime(CLOCK_MONOTONIC, &value) != 0) {
+        throw std::runtime_error("clock_gettime(CLOCK_MONOTONIC) failed");
+    }
+    return static_cast<double>(value.tv_sec) +
+           static_cast<double>(value.tv_nsec) * 1.0e-9;
+}
+
+std::string last_rusticol_error() {
+    std::size_t required = 0;
+    (void)rusticol_last_error_message(nullptr, 0, &required);
+    if (required == 0) {
+        return "unknown Rusticol error";
+    }
+    std::vector<char> buffer(required);
+    (void)rusticol_last_error_message(buffer.data(), buffer.size(), &required);
+    return std::string(buffer.data());
+}
+
+void check_rusticol(const int status) {
+    if (status != RUSTICOL_STATUS_OK) {
+        throw std::runtime_error(last_rusticol_error());
+    }
+}
+
+class RuntimeHandle {
+  public:
+    RuntimeHandle(const std::string &artifact, const std::string &process) {
+        check_rusticol(rusticol_runtime_load(
+            artifact.c_str(), process.c_str(), nullptr, &handle_));
+        if (handle_ == nullptr) {
+            throw std::runtime_error("Rusticol returned a null runtime handle");
+        }
+    }
+
+    ~RuntimeHandle() {
+        if (handle_ != nullptr) {
+            (void)rusticol_runtime_free(handle_);
+        }
+    }
+
+    RuntimeHandle(const RuntimeHandle &) = delete;
+    RuntimeHandle &operator=(const RuntimeHandle &) = delete;
+
+    RusticolRuntimeHandle *get() const { return handle_; }
+
+  private:
+    RusticolRuntimeHandle *handle_ = nullptr;
+};
+
+using RuntimeStringGetter = int (*)(
+    const RusticolRuntimeHandle *, char *, std::size_t, std::size_t *);
+
+std::string runtime_string(
+    const RusticolRuntimeHandle *handle,
+    const RuntimeStringGetter getter) {
+    std::size_t required = 0;
+    check_rusticol(getter(handle, nullptr, 0, &required));
+    if (required == 0) {
+        throw std::runtime_error("Rusticol returned an empty string capacity");
+    }
+    std::vector<char> buffer(required);
+    check_rusticol(getter(handle, buffer.data(), buffer.size(), &required));
+    return std::string(buffer.data());
+}
+
+std::string runtime_helicity_id(
+    const RusticolRuntimeHandle *handle,
+    const std::size_t index) {
+    std::size_t required = 0;
+    check_rusticol(rusticol_runtime_helicity_id(
+        handle, index, nullptr, 0, &required));
+    if (required == 0) {
+        throw std::runtime_error("Rusticol returned an empty helicity ID capacity");
+    }
+    std::vector<char> buffer(required);
+    check_rusticol(rusticol_runtime_helicity_id(
+        handle, index, buffer.data(), buffer.size(), &required));
+    return std::string(buffer.data());
+}
+
+Event read_event(const std::string &path) {
+    std::ifstream stream(path);
+    if (!stream) {
+        throw std::runtime_error("cannot open event: " + path);
+    }
+    std::string line;
+    bool in_momenta = false;
+    bool in_helicities = false;
+    std::size_t declared_helicities = 0;
+    Event event;
+    while (std::getline(stream, line)) {
+        std::istringstream fields(line);
+        std::string tag;
+        fields >> tag;
+        if (tag.empty()) {
+            continue;
+        }
+        if (tag == "BEGIN_MOMENTA") {
+            in_momenta = true;
+            continue;
+        }
+        if (tag == "END_MOMENTA") {
+            in_momenta = false;
+            continue;
+        }
+        if (tag == "NHELICITIES") {
+            fields >> declared_helicities;
+            continue;
+        }
+        if (tag == "BEGIN_HELICITIES") {
+            in_helicities = true;
+            continue;
+        }
+        if (tag == "END_HELICITIES") {
+            in_helicities = false;
+            continue;
+        }
+        if (in_momenta) {
+            double energy = 0.0;
+            double px = 0.0;
+            double py = 0.0;
+            double pz = 0.0;
+            std::istringstream row(line);
+            if (!(row >> energy >> px >> py >> pz)) {
+                throw std::runtime_error("invalid momentum row in " + path);
+            }
+            event.momenta.insert(event.momenta.end(), {energy, px, py, pz});
+        } else if (in_helicities) {
+            std::istringstream row(line);
+            int value = 0;
+            while (row >> value) {
+                if (value != -1 && value != 1) {
+                    throw std::runtime_error("invalid helicity value in " + path);
+                }
+                event.helicities.push_back(static_cast<std::int32_t>(value));
+            }
+        }
+    }
+    if (event.momenta.empty() || event.momenta.size() % 4 != 0) {
+        throw std::runtime_error("event has no complete momenta: " + path);
+    }
+    if (declared_helicities != 1 ||
+        event.helicities.size() != event.momenta.size() / 4) {
+        throw std::runtime_error(
+            "candidate event must contain exactly one complete helicity: " + path);
+    }
+    return event;
+}
+
+std::uint64_t process_peak_rss_kib() {
+    struct rusage usage {};
+    if (getrusage(RUSAGE_SELF, &usage) != 0) {
+        throw std::runtime_error("getrusage(RUSAGE_SELF) failed");
+    }
+#if defined(__APPLE__)
+    return static_cast<std::uint64_t>(usage.ru_maxrss) / 1024U;
+#else
+    return static_cast<std::uint64_t>(usage.ru_maxrss);
+#endif
+}
+
+double evaluate_one(
+    RusticolRuntimeHandle *runtime,
+    const std::vector<double> &point,
+    const bool generation_specialized_total,
+    const std::uint32_t *selected_helicity_index,
+    const char *const *selected_color_ids,
+    const std::size_t selected_color_count,
+    double &minimum_absolute_value,
+    double &sink) {
+    double value = 0.0;
+    if (generation_specialized_total) {
+        check_rusticol(rusticol_runtime_evaluate_f64(
+            runtime, point.data(), point.size(), 1, &value, 1));
+    } else {
+        check_rusticol(rusticol_runtime_evaluate_selected_f64(
+            runtime,
+            point.data(),
+            point.size(),
+            1,
+            nullptr,
+            0,
+            selected_color_ids,
+            selected_color_count,
+            selected_helicity_index,
+            selected_helicity_index == nullptr ? 0 : 1,
+            nullptr,
+            0,
+            &value,
+            1));
+    }
+    if (!std::isfinite(value)) {
+        throw std::runtime_error("Rusticol returned an invalid scalar result");
+    }
+    const double absolute = std::abs(value);
+    minimum_absolute_value = std::min(minimum_absolute_value, absolute);
+    sink += value;
+    return value;
+}
+
+void evaluate_repeated_batch(
+    RusticolRuntimeHandle *runtime,
+    const std::vector<double> &momenta,
+    const bool generation_specialized_total,
+    const std::vector<std::uint32_t> &selected_helicity_indices,
+    const char *const *selected_color_ids,
+    const std::size_t selected_color_count,
+    std::vector<double> &values) {
+    const std::size_t point_count = values.size();
+    if (generation_specialized_total) {
+        check_rusticol(rusticol_runtime_evaluate_f64(
+            runtime,
+            momenta.data(),
+            momenta.size(),
+            point_count,
+            values.data(),
+            values.size()));
+    } else {
+        check_rusticol(rusticol_runtime_evaluate_selected_f64(
+            runtime,
+            momenta.data(),
+            momenta.size(),
+            point_count,
+            nullptr,
+            0,
+            selected_color_ids,
+            selected_color_count,
+            selected_helicity_indices.empty()
+                ? nullptr
+                : selected_helicity_indices.data(),
+            selected_helicity_indices.size(),
+            nullptr,
+            0,
+            values.data(),
+            values.size()));
+    }
+}
+
+void consume_batch_results(
+    const std::vector<double> &values,
+    double &minimum_absolute_value,
+    double &sink) {
+    for (const double value : values) {
+        if (!std::isfinite(value)) {
+            throw std::runtime_error("Rusticol returned an invalid batched result");
+        }
+        minimum_absolute_value = std::min(minimum_absolute_value, std::abs(value));
+        sink += value;
+    }
+}
+
+double authenticate_batch_results(
+    const std::vector<double> &values,
+    const std::array<double, kPointCount> &expected,
+    double &minimum_absolute_value,
+    double &sink) {
+    double maximum_relative_error = 0.0;
+    for (std::size_t index = 0; index < values.size(); ++index) {
+        const double value = values[index];
+        const double expected_value = expected[index % expected.size()];
+        if (!std::isfinite(value)) {
+            throw std::runtime_error("Rusticol returned an invalid batched result");
+        }
+        const double scale = std::max(
+            {std::abs(value), std::abs(expected_value), 1.0e-300});
+        maximum_relative_error = std::max(
+            maximum_relative_error, std::abs(value - expected_value) / scale);
+        minimum_absolute_value = std::min(minimum_absolute_value, std::abs(value));
+        sink += value;
+    }
+    if (maximum_relative_error > 1.0e-12) {
+        throw std::runtime_error(
+            "batched evaluation disagrees with the scalar representative point");
+    }
+    return maximum_relative_error;
+}
+
+struct Arguments {
+    std::string artifact;
+    std::string process;
+    double target_seconds = 0.25;
+    double alpha_s = kUnitCouplingAlphaS;
+    std::size_t samples = kWarmSampleCount;
+    std::size_t batch_size = 1;
+    bool first_ready_only = false;
+    bool report_start_to_first_warm_wall = false;
+    bool sum_helicities = false;
+    std::string color_id;
+    std::vector<std::string> event_paths;
+};
+
+Arguments parse_arguments(int argc, char **argv) {
+    if (argc < 3) {
+        throw std::runtime_error(
+            "usage: fft_gluon_candidate_probe ARTIFACT PROCESS "
+            "[--alpha-s A] [--target-seconds S --samples N "
+            "--batch-size N] [--color-id ID] [--sum-helicities] "
+            "[--first-ready-only] [--report-start-to-first-warm-wall] EVENT...]");
+    }
+    Arguments arguments;
+    arguments.artifact = argv[1];
+    arguments.process = argv[2];
+    for (int index = 3; index < argc; ++index) {
+        const std::string token = argv[index];
+        if (token == "--target-seconds") {
+            if (++index >= argc) {
+                throw std::runtime_error("--target-seconds requires a value");
+            }
+            arguments.target_seconds = std::stod(argv[index]);
+        } else if (token == "--alpha-s") {
+            if (++index >= argc) {
+                throw std::runtime_error("--alpha-s requires a value");
+            }
+            arguments.alpha_s = std::stod(argv[index]);
+        } else if (token == "--samples") {
+            if (++index >= argc) {
+                throw std::runtime_error("--samples requires a value");
+            }
+            arguments.samples = static_cast<std::size_t>(std::stoull(argv[index]));
+        } else if (token == "--batch-size") {
+            if (++index >= argc) {
+                throw std::runtime_error("--batch-size requires a value");
+            }
+            arguments.batch_size =
+                static_cast<std::size_t>(std::stoull(argv[index]));
+        } else if (token == "--first-ready-only") {
+            arguments.first_ready_only = true;
+        } else if (token == "--report-start-to-first-warm-wall") {
+            arguments.report_start_to_first_warm_wall = true;
+        } else if (token == "--sum-helicities") {
+            arguments.sum_helicities = true;
+        } else if (token == "--color-id") {
+            if (++index >= argc) {
+                throw std::runtime_error("--color-id requires a value");
+            }
+            const std::string value = argv[index];
+            if (value.empty() || value.front() == '-' ||
+                value.find_first_of(" \t\r\n") != std::string::npos) {
+                throw std::runtime_error("--color-id requires one nonempty ID token");
+            }
+            if (!arguments.color_id.empty()) {
+                throw std::runtime_error("--color-id may be supplied at most once");
+            }
+            arguments.color_id = value;
+        } else if (!token.empty() && token[0] == '-') {
+            throw std::runtime_error("unknown option: " + token);
+        } else {
+            arguments.event_paths.push_back(token);
+        }
+    }
+    if (!std::isfinite(arguments.alpha_s) || arguments.alpha_s <= 0.0) {
+        throw std::runtime_error("--alpha-s must be finite and positive");
+    }
+    if (!std::isfinite(arguments.target_seconds) ||
+        arguments.target_seconds < 0.25) {
+        throw std::runtime_error("calibration target must be at least 0.25 seconds");
+    }
+    if (arguments.samples != kWarmSampleCount) {
+        throw std::runtime_error("the acceptance probe requires exactly 10 samples");
+    }
+    if (arguments.batch_size == 0) {
+        throw std::runtime_error("--batch-size must be positive");
+    }
+    if (arguments.event_paths.size() != kPointCount) {
+        throw std::runtime_error("the acceptance probe requires exactly 10 events");
+    }
+    return arguments;
+}
+
+void write_first_ready(
+    const std::string &process,
+    const std::string &execution_mode,
+    const std::string &color_accuracy,
+    const std::string &selected_color_id,
+    const std::size_t helicity_count,
+    const std::string &selected_helicity_id,
+    const bool sum_helicities,
+    const double load_seconds,
+    const double first_warm_seconds,
+    const double warm_up_api_seconds,
+    const double minimum_absolute_value,
+    const std::uint64_t peak_rss_kib) {
+    std::cout << std::setprecision(17) << std::scientific
+              << "FFT_CANDIDATE_FIRST_READY_V1\n"
+              << "PROCESS " << process << "\n"
+              << "EXECUTION_MODE " << execution_mode << "\n";
+    if (!selected_color_id.empty()) {
+        std::cout << "COLOR_ACCURACY " << color_accuracy << "\n"
+                  << "SELECTED_COLOR_ID " << selected_color_id << "\n";
+    }
+    std::cout << "TIMER_SOURCE process-cpu-time\n"
+              << "HELICITY_COVERAGE_COUNT " << helicity_count << "\n"
+              << "SELECTED_HELICITY_ID "
+              << (sum_helicities ? "-" : selected_helicity_id) << "\n";
+    if (sum_helicities) {
+        // This is the complete physical axis requested through the null-selector
+        // C ABI. Backends may eliminate authenticated structural zeros internally.
+        std::cout << "HELICITY_WORKLOAD sum\n"
+                  << "TIMED_HELICITY_COUNT " << helicity_count << "\n";
+    }
+    std::cout << "POINT_COUNT " << kPointCount << "\n"
+              << "LOAD_SECONDS " << load_seconds << "\n"
+              << "FIRST_WARM_SECONDS " << first_warm_seconds << "\n"
+              << "WARM_UP_API_SECONDS " << warm_up_api_seconds << "\n"
+              << "MIN_ABSOLUTE_VALUE " << minimum_absolute_value << "\n"
+              << "MAX_RSS_KIB " << peak_rss_kib << "\n";
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+    try {
+        const double start_to_first_warm_wall_start = monotonic_wall_seconds();
+        const Arguments arguments = parse_arguments(argc, argv);
+        std::vector<Event> events;
+        events.reserve(arguments.event_paths.size());
+        for (const auto &path : arguments.event_paths) {
+            events.push_back(read_event(path));
+        }
+        const std::vector<std::int32_t> expected_helicity =
+            events.front().helicities;
+        const std::size_t point_size = events.front().momenta.size();
+        for (const auto &event : events) {
+            if (event.momenta.size() != point_size ||
+                event.helicities != expected_helicity) {
+                throw std::runtime_error(
+                    "all candidate events must share one multiplicity and helicity");
+            }
+        }
+
+        const double load_start = process_cpu_seconds();
+        if (rusticol_abi_version() != RUSTICOL_ABI_VERSION) {
+            throw std::runtime_error("Rusticol public C ABI version mismatch");
+        }
+        RuntimeHandle runtime(arguments.artifact, arguments.process);
+        RusticolRuntimeHandle *const handle = runtime.get();
+        check_rusticol(rusticol_runtime_set_model_parameter(
+            handle,
+            "normalization.alpha_s_me_check",
+            arguments.alpha_s,
+            0.0));
+        const std::string process = runtime_string(handle, rusticol_runtime_process_key);
+        const std::string execution_mode =
+            runtime_string(handle, rusticol_runtime_execution_mode);
+        const std::string color_accuracy =
+            runtime_string(handle, rusticol_runtime_color_accuracy);
+        if (arguments.color_id.empty()) {
+            if (color_accuracy != "full") {
+                throw std::runtime_error("candidate artifact is not full colour");
+            }
+        } else if (color_accuracy != "lc") {
+            throw std::runtime_error(
+                "a selected-color probe requires a leading-colour artifact");
+        }
+        if (execution_mode != "on-the-fly" && execution_mode != "recurrence" &&
+            execution_mode != "compiled") {
+            throw std::runtime_error("candidate artifact has an unsupported execution mode");
+        }
+        std::size_t external_count = 0;
+        check_rusticol(rusticol_runtime_external_count(handle, &external_count));
+        if (external_count * 4 != point_size) {
+            throw std::runtime_error("candidate event multiplicity does not match artifact");
+        }
+        if (arguments.batch_size >
+            std::numeric_limits<std::size_t>::max() / point_size) {
+            throw std::runtime_error("batch momentum size overflows size_t");
+        }
+        std::size_t runtime_helicity_count = 0;
+        check_rusticol(rusticol_runtime_helicity_count(
+            handle, &runtime_helicity_count));
+        std::string selected_helicity_id;
+        std::uint32_t selected_helicity_index = 0;
+        std::size_t matching_helicity_count = 0;
+        for (std::size_t index = 0; index < runtime_helicity_count; ++index) {
+            std::size_t required = 0;
+            check_rusticol(rusticol_runtime_helicity_vector(
+                handle, index, nullptr, 0, &required));
+            if (required != expected_helicity.size()) {
+                continue;
+            }
+            std::vector<std::int32_t> helicity(required);
+            check_rusticol(rusticol_runtime_helicity_vector(
+                handle, index, helicity.data(), helicity.size(), &required));
+            if (helicity == expected_helicity) {
+                ++matching_helicity_count;
+                selected_helicity_id = runtime_helicity_id(handle, index);
+                if (index > std::numeric_limits<std::uint32_t>::max()) {
+                    throw std::runtime_error(
+                        "selected helicity index exceeds the public C ABI");
+                }
+                selected_helicity_index = static_cast<std::uint32_t>(index);
+            }
+        }
+        if (matching_helicity_count != 1) {
+            throw std::runtime_error(
+                "candidate artifact does not expose one matching selected helicity");
+        }
+        const std::uint32_t *const evaluation_helicity_index =
+            arguments.sum_helicities ? nullptr : &selected_helicity_index;
+        const char *selected_helicity_ids[] = {selected_helicity_id.c_str()};
+        const char *selected_color_ids[] = {arguments.color_id.c_str()};
+        const char *const *const evaluation_color_ids =
+            arguments.color_id.empty() ? nullptr : selected_color_ids;
+        const std::size_t evaluation_color_count =
+            arguments.color_id.empty() ? 0 : 1;
+        // Full/NLC recurrence artifacts expose contracted colour, and the
+        // acceptance recurrence lane is generated with exactly one retained
+        // helicity.  Its unselected total is therefore exactly the same
+        // one-helicity matrix element as the selected query, without paying
+        // the selector C ABI and planner overhead.  OTF intentionally keeps
+        // complete helicity coverage and must continue through selection.
+        const bool generation_specialized_total =
+            execution_mode == "recurrence" && runtime_helicity_count == 1 &&
+            arguments.color_id.empty();
+        const double load_seconds = process_cpu_seconds() - load_start;
+
+        double minimum_absolute_value = std::numeric_limits<double>::infinity();
+        double sink = 0.0;
+        std::array<double, kPointCount> point_values {};
+        std::array<bool, kPointCount> point_value_recorded {};
+        std::vector<double> batch_momenta;
+        batch_momenta.reserve(point_size * arguments.batch_size);
+        for (std::size_t point = 0; point < arguments.batch_size; ++point) {
+            const Event &event = events[point % events.size()];
+            batch_momenta.insert(
+                batch_momenta.end(),
+                event.momenta.begin(),
+                event.momenta.end());
+        }
+        std::vector<std::uint32_t> batch_helicity_indices;
+        if (evaluation_helicity_index != nullptr) {
+            batch_helicity_indices.assign(
+                arguments.batch_size, *evaluation_helicity_index);
+        }
+        std::vector<double> batch_values(arguments.batch_size, 0.0);
+
+        const auto evaluate_representative = [&]() {
+            if (arguments.batch_size == 1) {
+                return evaluate_one(
+                    handle,
+                    events[kRepresentativePoint].momenta,
+                    generation_specialized_total,
+                    evaluation_helicity_index,
+                    evaluation_color_ids,
+                    evaluation_color_count,
+                    minimum_absolute_value,
+                    sink);
+            }
+            evaluate_repeated_batch(
+                handle,
+                batch_momenta,
+                generation_specialized_total,
+                batch_helicity_indices,
+                evaluation_color_ids,
+                evaluation_color_count,
+                batch_values);
+            return batch_values.front();
+        };
+        RusticolWarmUpResult warm_up {};
+        double warm_up_api_seconds = 0.0;
+        double batch_max_relative_error = 0.0;
+        double start_to_first_warm_wall_seconds = 0.0;
+        const double first_warm_start = process_cpu_seconds();
+        if (execution_mode == "on-the-fly") {
+            check_rusticol(rusticol_runtime_warm_up_f64_with_cores(
+                handle,
+                events.front().momenta.data(),
+                events.front().momenta.size(),
+                arguments.sum_helicities ? nullptr : selected_helicity_ids,
+                arguments.sum_helicities ? 0 : 1,
+                evaluation_color_ids,
+                evaluation_color_count,
+                0,
+                nullptr,
+                nullptr,
+                &warm_up));
+            if (warm_up.schema_version != 1 ||
+                warm_up.first_evaluation_completed == 0 ||
+                !std::isfinite(warm_up.elapsed_seconds) ||
+                !(warm_up.elapsed_seconds > 0.0)) {
+                throw std::runtime_error("Rusticol returned an invalid OTF warm-up result");
+            }
+            warm_up_api_seconds = warm_up.elapsed_seconds;
+        }
+        for (std::size_t point = 0; point < events.size(); ++point) {
+            point_values[point] = evaluate_one(
+                handle,
+                events[point].momenta,
+                generation_specialized_total,
+                evaluation_helicity_index,
+                evaluation_color_ids,
+                evaluation_color_count,
+                minimum_absolute_value,
+                sink);
+            point_value_recorded[point] = true;
+        }
+        if (arguments.batch_size > 1) {
+            if (!point_value_recorded[kRepresentativePoint]) {
+                point_values[kRepresentativePoint] = evaluate_one(
+                    handle,
+                    events[kRepresentativePoint].momenta,
+                    generation_specialized_total,
+                    evaluation_helicity_index,
+                    evaluation_color_ids,
+                    evaluation_color_count,
+                    minimum_absolute_value,
+                    sink);
+                point_value_recorded[kRepresentativePoint] = true;
+            }
+            (void)evaluate_representative();
+        }
+        start_to_first_warm_wall_seconds =
+            monotonic_wall_seconds() - start_to_first_warm_wall_start;
+        const double first_warm_seconds =
+            process_cpu_seconds() - first_warm_start;
+        if (arguments.batch_size > 1) {
+            batch_max_relative_error = authenticate_batch_results(
+                batch_values,
+                point_values,
+                minimum_absolute_value,
+                sink);
+        }
+
+        std::uint64_t peak_rss_kib = process_peak_rss_kib();
+        if (warm_up.peak_rss_available != 0) {
+            peak_rss_kib = std::max(
+                peak_rss_kib,
+                (warm_up.peak_rss_bytes + 1023U) / 1024U);
+        }
+        if (!std::isfinite(sink) || !std::isfinite(minimum_absolute_value)) {
+            throw std::runtime_error("candidate first-pass sink is invalid");
+        }
+        if (arguments.first_ready_only) {
+            write_first_ready(
+                process,
+                execution_mode,
+                color_accuracy,
+                arguments.color_id,
+                runtime_helicity_count,
+                selected_helicity_id,
+                arguments.sum_helicities,
+                load_seconds,
+                first_warm_seconds,
+                warm_up_api_seconds,
+                minimum_absolute_value,
+                peak_rss_kib);
+            return 0;
+        }
+
+        std::size_t calibration_calls = 0;
+        double calibration_seconds = 0.0;
+        std::size_t repetitions = 1;
+        for (;;) {
+            const double calibration_start = process_cpu_seconds();
+            double last_value = 0.0;
+            for (std::size_t repetition = 0;
+                 repetition < repetitions;
+                 ++repetition) {
+                last_value = evaluate_representative();
+            }
+            const double elapsed = process_cpu_seconds() - calibration_start;
+            if (arguments.batch_size > 1) {
+                consume_batch_results(batch_values, minimum_absolute_value, sink);
+            }
+            if (!point_value_recorded[kRepresentativePoint]) {
+                point_values[kRepresentativePoint] = last_value;
+                point_value_recorded[kRepresentativePoint] = true;
+            }
+            if (elapsed >= arguments.target_seconds) {
+                calibration_calls = repetitions;
+                calibration_seconds = elapsed;
+                break;
+            }
+            if (repetitions > std::numeric_limits<std::size_t>::max() / 2) {
+                throw std::runtime_error("calibration repetition count overflow");
+            }
+            repetitions *= 2;
+        }
+
+        std::array<double, kWarmSampleCount> warm_cells {};
+        for (std::size_t sample = 0; sample < arguments.samples; ++sample) {
+            const double cell_start = process_cpu_seconds();
+            for (std::size_t repetition = 0;
+                 repetition < calibration_calls;
+                 ++repetition) {
+                (void)evaluate_representative();
+            }
+            warm_cells[sample] =
+                (process_cpu_seconds() - cell_start) /
+                (static_cast<double>(calibration_calls) *
+                 static_cast<double>(arguments.batch_size));
+            if (arguments.batch_size > 1) {
+                consume_batch_results(batch_values, minimum_absolute_value, sink);
+            }
+        }
+
+        peak_rss_kib = std::max(peak_rss_kib, process_peak_rss_kib());
+        if (!std::isfinite(sink) || !std::isfinite(minimum_absolute_value)) {
+            throw std::runtime_error("candidate benchmark sink is invalid");
+        }
+        if (!std::all_of(
+                point_value_recorded.begin(),
+                point_value_recorded.end(),
+                [](const bool recorded) { return recorded; }) ||
+            !std::all_of(
+                point_values.begin(),
+                point_values.end(),
+                [](const double value) {
+                    return std::isfinite(value);
+                })) {
+            throw std::runtime_error("candidate point-value evidence is invalid");
+        }
+
+        std::cout << std::setprecision(17) << std::scientific
+                  << "FFT_CANDIDATE_PROBE_V4\n"
+                  << "PROCESS " << process << "\n"
+                  << "EXECUTION_MODE " << execution_mode << "\n";
+        if (!arguments.color_id.empty()) {
+            std::cout << "COLOR_ACCURACY " << color_accuracy << "\n"
+                      << "SELECTED_COLOR_ID " << arguments.color_id << "\n";
+        }
+        std::cout << "TIMER_SOURCE process-cpu-time\n"
+                  << "HELICITY_COVERAGE_COUNT " << runtime_helicity_count << "\n"
+                  << "SELECTED_HELICITY_ID "
+                  << (arguments.sum_helicities ? "-" : selected_helicity_id)
+                  << "\n";
+        if (arguments.sum_helicities) {
+            std::cout << "HELICITY_WORKLOAD sum\n"
+                      << "TIMED_HELICITY_COUNT " << runtime_helicity_count << "\n";
+        }
+        std::cout << "POINT_COUNT " << events.size() << "\n"
+                  << "LOAD_SECONDS " << load_seconds << "\n"
+                  << "FIRST_WARM_SECONDS " << first_warm_seconds << "\n"
+                  << "WARM_UP_API_SECONDS " << warm_up_api_seconds << "\n";
+        if (arguments.batch_size > 1) {
+            std::cout << "BENCHMARK_BATCH_SIZE " << arguments.batch_size << "\n"
+                      << "BATCH_INPUT_PATTERN cyclic-10-events\n"
+                      << "BATCH_AUTHENTICATED_POINT_COUNT "
+                      << arguments.batch_size << "\n"
+                      << "BATCH_MAX_RELATIVE_ERROR "
+                      << batch_max_relative_error << "\n";
+        }
+        if (arguments.batch_size > 1 ||
+            arguments.report_start_to_first_warm_wall) {
+            std::cout << "START_TO_FIRST_WARM_WALL_SECONDS "
+                      << start_to_first_warm_wall_seconds << "\n";
+        }
+        for (std::size_t point = 0; point < events.size(); ++point) {
+            std::cout << "POINT_VALUE " << (point + 1) << " "
+                      << point_values[point] << "\n";
+        }
+        std::cout << "CALIBRATION_CELL " << (kRepresentativePoint + 1) << " "
+                  << calibration_calls << " " << calibration_seconds << "\n";
+        for (std::size_t sample = 0; sample < arguments.samples; ++sample) {
+            std::cout << "WARM_CELL_SECONDS " << (sample + 1) << " "
+                      << (kRepresentativePoint + 1) << " "
+                      << warm_cells[sample] << "\n";
+        }
+        std::cout << "MIN_ABSOLUTE_VALUE " << minimum_absolute_value << "\n"
+                  << "MAX_RSS_KIB " << peak_rss_kib << "\n";
+        return 0;
+    } catch (const std::exception &error) {
+        std::cerr << "fft candidate probe: " << error.what() << "\n";
+        return 1;
+    }
+}
diff --git a/pyamplicol/tools/developer/fft_gluon_performance_acceptance.py b/pyamplicol/tools/developer/fft_gluon_performance_acceptance.py
new file mode 100644
index 0000000000..07a6675be8
--- /dev/null
+++ b/pyamplicol/tools/developer/fft_gluon_performance_acceptance.py
@@ -0,0 +1,2687 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Paired pure-gluon FFT performance, RSS, and cold-start acceptance.
+
+The authoritative reference implementation is loaded from the pinned
+developer checkout's ``Benchmark/run_benchmark.py`` and called directly; none
+of its implementation is copied here.  Candidate timing uses the public
+Rusticol C ABI probe in this directory.  Linux uses the reference driver's GNU
+process wrappers.  Darwin translates those wrappers to the study's getrusage
+worker; the common watchdog and subprocess timeout retain the same hard bounds.
+
+This file intentionally is not wired into a default target.  Use ``--dry-run``
+to inspect the complete bounded campaign without compiling or writing files.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import math
+import os
+import re
+import shlex
+import shutil
+import stat
+import statistics
+import subprocess
+import sys
+import time
+from collections.abc import Callable, Mapping, Sequence
+from contextlib import contextmanager
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.performance_report.source_identity import (  # noqa: E402
+    ReportSourceIdentity,
+    ReportSourceIdentityError,
+    require_eligible_report_source,
+)
+
+PERFORMANCE_ROOT = ROOT / ".artifacts" / "fft-performance"
+DEFAULT_REFERENCE_ROOT = ROOT / "dependencies" / "checkouts" / "reference-fft"
+REFERENCE_ROOT = DEFAULT_REFERENCE_ROOT
+REFERENCE_DRIVER = REFERENCE_ROOT / "Benchmark" / "run_benchmark.py"
+REFERENCE_REVISION = "9c3cb4fb4658200884553bab796e85bd5e7fe7a9"
+PROBE_SOURCE = ROOT / "tools" / "developer" / "fft_gluon_candidate_probe.cpp"
+SCALING_STUDY_DRIVER = ROOT / "tools" / "developer" / "fft_scaling_study.py"
+WATCHDOG = ROOT / "tools" / "ci" / "memory_watchdog.py"
+
+KIND = "pyamplicol-pure-gluon-fft-performance-acceptance"
+SCHEMA_VERSION = 8
+REFERENCE_BACKEND = "AmpliGluonTraceDefaultBG"
+REFERENCE_BUILD_PROGRAM = "benchmark_ampligluon_trace"
+REFERENCE_CLEAN_BUILD_SCOPE = "ampligluon-trace-backend-only"
+# Recurrence is generated for one known-nonzero helicity.  OTF retains complete
+# runtime-selector coverage and is measured through one fixed-helicity query.
+# Both are valid, lane-specific acceptance workloads.  Running recurrence first
+# prevents OTF from warming its cold path.
+LANES = ("recurrence", "on-the-fly")
+MANDATORY_MULTIPLICITIES = tuple(range(4, 10))
+OPTIONAL_MULTIPLICITIES = (10, 11)
+POINT_COUNT = 10
+REPRESENTATIVE_POINT = 1
+BASE_SEED = 1729
+WARM_SAMPLE_COUNT = 10
+MINIMUM_CALIBRATION_SECONDS = 0.25
+MEMORY_LIMIT_GIB = 30.0
+OPTIONAL_COLD_LIMIT_SECONDS = 15.0 * 60.0
+MANDATORY_LANE_TIMEOUT_SECONDS = 60.0 * 60.0
+WARM_RATIO_LIMIT = 1.25
+RSS_RATIO_LIMIT = 2.0
+COLD_RATIO_LIMIT = 5.0
+NUMERICAL_RELATIVE_TOLERANCE = 1.0e-10
+INITIAL_GLUON_AVERAGE_FACTOR = 256
+UNIT_COUPLING_ALPHA_S = 1.0 / (4.0 * math.pi)
+DARWIN_RSS_MARKER = "FFT_MAX_RSS_KIB"
+REFERENCE_RSS_MARKER = "BENCHMARK_MAX_RSS_KIB"
+WATCHDOG_CLEANUP_WAIT_SECONDS = 7.0
+SINGLE_THREAD_ENVIRONMENT = (
+    "OMP_NUM_THREADS",
+    "OPENBLAS_NUM_THREADS",
+    "MKL_NUM_THREADS",
+    "RAYON_NUM_THREADS",
+    "VECLIB_MAXIMUM_THREADS",
+    "ACCELERATE_MAX_THREADS",
+)
+_RUN_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]*")
+
+
+class AcceptanceError(RuntimeError):
+    """Raised when the paired campaign or its evidence is invalid."""
+
+
+def configure_reference_root(path: Path) -> None:
+    """Select the independent pinned Reference FFT checkout for this process."""
+
+    global REFERENCE_ROOT, REFERENCE_DRIVER
+    REFERENCE_ROOT = path.expanduser().resolve()
+    REFERENCE_DRIVER = REFERENCE_ROOT / "Benchmark" / "run_benchmark.py"
+
+
+class NumericalParityError(AcceptanceError):
+    """Raised when an evaluated candidate disagrees with the reference."""
+
+
+class ReferenceColdLimitError(AcceptanceError):
+    """Raised when Reference setup exhausts its aggregate cold-cell budget."""
+
+
+@dataclass(frozen=True)
+class ReferenceSourceIdentity:
+    """Pinned revision and deterministic identity of the reference inputs."""
+
+    revision: str
+    content_sha256: str
+    file_count: int
+
+    def provenance(self) -> dict[str, object]:
+        return {
+            "revision": self.revision,
+            "required_revision": REFERENCE_REVISION,
+            "content_sha256": self.content_sha256,
+            "tracked_and_nonignored_file_count": self.file_count,
+        }
+
+
+@dataclass(frozen=True)
+class CandidateProbeMetrics:
+    process: str
+    execution_mode: str
+    helicity_coverage_count: int
+    selected_helicity_id: str
+    point_count: int
+    point_values: tuple[float, ...]
+    load_seconds: float
+    first_warm_seconds: float
+    warm_up_api_seconds: float
+    calibration_calls: tuple[int, ...]
+    calibration_seconds: tuple[float, ...]
+    warm_cell_seconds: tuple[tuple[float, ...], ...]
+    warm_samples_seconds: tuple[float, ...]
+    warm_median_seconds: float
+    minimum_absolute_value: float
+    max_rss_kib: int
+
+
+@dataclass(frozen=True)
+class NumericalParityEvidence:
+    normalization_alpha_s_me_check: float
+    candidate_scale_factor: int
+    relative_tolerance: float
+    maximum_relative_error: float
+    maximum_relative_error_point: int
+    passes: bool
+
+
+@dataclass(frozen=True)
+class CandidateMetrics:
+    lane: str
+    total_gluons: int
+    generator_seed: int
+    generation_seconds: float
+    load_seconds: float
+    first_warm_seconds: float
+    max_rss_kib: int
+    probe: CandidateProbeMetrics
+    numerical_parity: NumericalParityEvidence
+
+    @property
+    def cold_to_ready_seconds(self) -> float:
+        return self.generation_seconds + self.load_seconds + self.first_warm_seconds
+
+
+@dataclass(frozen=True)
+class CandidateFirstReadyMetrics:
+    process: str
+    execution_mode: str
+    helicity_coverage_count: int
+    selected_helicity_id: str
+    point_count: int
+    load_seconds: float
+    first_warm_seconds: float
+    warm_up_api_seconds: float
+    minimum_absolute_value: float
+    max_rss_kib: int
+
+
+class WatchedCompletedProcess(subprocess.CompletedProcess[str]):
+    """Completed watchdog process with parent-side timing evidence."""
+
+    def __init__(
+        self,
+        args: Sequence[str],
+        returncode: int,
+        stdout: str,
+        stderr: str,
+        *,
+        elapsed_seconds: float,
+        log_write_seconds: float,
+        timed_out: bool,
+        timeout_cleanup: str,
+        peak_guard_kib: int | None = None,
+        peak_rss_kib: int | None = None,
+    ) -> None:
+        super().__init__(args, returncode, stdout, stderr)
+        self.elapsed_seconds = elapsed_seconds
+        self.log_write_seconds = log_write_seconds
+        self.peak_guard_kib = peak_guard_kib
+        self.peak_rss_kib = peak_rss_kib
+        self.timed_out = timed_out
+        self.timeout_cleanup = timeout_cleanup
+
+
+@dataclass(frozen=True)
+class ReferenceMetrics:
+    total_gluons: int
+    generator_seed: int
+    backend: str
+    clean_build_scope: str
+    clean_build_command_count: int
+    clean_build_seconds: float
+    setup_to_driver_seconds: float
+    initialization_seconds: float
+    first_pass_seconds: float
+    warm_samples_seconds: tuple[float, ...]
+    warm_median_seconds: float
+    max_rss_kib: int
+    selected_helicity: tuple[int, ...]
+    selected_path: str
+    event_paths: tuple[str, ...]
+    matrix_elements: tuple[float, ...]
+    driver_max_rss_kib: int | None = None
+    watchdog_max_rss_kib: int | None = None
+    direct_command_watchdog_max_rss_kib: int | None = None
+    translated_child_max_rss_kib: int | None = None
+    watchdog_max_peak_guard_kib: int | None = None
+    warm_repetitions: tuple[int, ...] = ()
+    warm_repetition_quantum: int | None = None
+    warm_calibration_seconds: tuple[float, ...] = ()
+    helicity_workload: str = "fixed"
+    helicity_coverage_count: int = 1
+    timed_helicity_count: int = 1
+    active_helicity_count: int = 1
+    exhaustive_event_paths: tuple[str, ...] = ()
+
+    @property
+    def cold_to_ready_seconds(self) -> float:
+        return (
+            self.clean_build_seconds
+            + self.initialization_seconds
+            + self.first_pass_seconds
+        )
+
+    @property
+    def setup_to_ready_seconds(self) -> float:
+        return (
+            self.setup_to_driver_seconds
+            + self.initialization_seconds
+            + self.first_pass_seconds
+        )
+
+
+@dataclass(frozen=True)
+class GateResult:
+    total_gluons: int
+    lane: str
+    warm_ratio: float
+    rss_ratio: float
+    cold_ratio: float
+    warm_passes: bool
+    rss_passes: bool
+    cold_passes: bool
+    numerical_passes: bool
+
+    @property
+    def passes(self) -> bool:
+        return (
+            self.warm_passes
+            and self.rss_passes
+            and self.cold_passes
+            and self.numerical_passes
+        )
+
+
+@dataclass(frozen=True)
+class _ReferenceRun:
+    metrics: ReferenceMetrics
+    event_paths: tuple[Path, ...]
+
+
+def generator_seed(total_gluons: int) -> int:
+    if total_gluons < 4:
+        raise AcceptanceError(f"unsupported total-gluon multiplicity {total_gluons}")
+    return BASE_SEED + total_gluons
+
+
+def _positive_finite(value: object) -> bool:
+    return (
+        isinstance(value, int | float)
+        and not isinstance(value, bool)
+        and math.isfinite(float(value))
+        and float(value) > 0.0
+    )
+
+
+def _finite_number(value: object) -> bool:
+    return (
+        isinstance(value, int | float)
+        and not isinstance(value, bool)
+        and math.isfinite(float(value))
+    )
+
+
+def candidate_reference_scale_factor(total_gluons: int) -> int:
+    """Undo pyAmpliCol's initial-state average and final-gluon symmetry factor."""
+
+    if total_gluons < 2:
+        raise AcceptanceError("total-gluon multiplicity must be at least two")
+    return INITIAL_GLUON_AVERAGE_FACTOR * math.factorial(total_gluons - 2)
+
+
+def compare_candidate_to_reference(
+    *,
+    total_gluons: int,
+    candidate_values: Sequence[float],
+    reference_values: Sequence[float],
+) -> NumericalParityEvidence:
+    """Compare the same ordered points after aligning public ME conventions."""
+
+    if len(candidate_values) != POINT_COUNT or len(reference_values) != POINT_COUNT:
+        raise AcceptanceError("numerical parity requires exactly 10 paired values")
+    if not all(_finite_number(value) for value in candidate_values):
+        raise AcceptanceError("candidate numerical parity values must be finite")
+    if not all(_positive_finite(value) for value in reference_values):
+        raise AcceptanceError("reference numerical parity values must be positive")
+    scale_factor = candidate_reference_scale_factor(total_gluons)
+    errors: list[float] = []
+    for candidate, reference in zip(candidate_values, reference_values, strict=True):
+        scaled_candidate = float(candidate) * scale_factor
+        scale = max(abs(scaled_candidate), abs(float(reference)))
+        errors.append(abs(scaled_candidate - float(reference)) / scale)
+    maximum = max(errors)
+    maximum_point = errors.index(maximum) + 1
+    return NumericalParityEvidence(
+        normalization_alpha_s_me_check=UNIT_COUPLING_ALPHA_S,
+        candidate_scale_factor=scale_factor,
+        relative_tolerance=NUMERICAL_RELATIVE_TOLERANCE,
+        maximum_relative_error=maximum,
+        maximum_relative_error_point=maximum_point,
+        passes=maximum <= NUMERICAL_RELATIVE_TOLERANCE,
+    )
+
+
+def parse_candidate_probe_output(output: str) -> CandidateProbeMetrics:
+    """Parse per-cell process-CPU evidence emitted by the public-C probe."""
+
+    lines = [line.strip() for line in output.splitlines() if line.strip()]
+    if not lines or lines[0] != "FFT_CANDIDATE_PROBE_V4":
+        raise AcceptanceError("candidate probe header is missing or invalid")
+    scalar: dict[str, str] = {}
+    point_values: dict[int, float] = {}
+    calibration: dict[int, tuple[int, float]] = {}
+    warm_cells: dict[tuple[int, int], float] = {}
+    for line in lines[1:]:
+        fields = line.split()
+        if fields[0] == "POINT_VALUE":
+            if len(fields) != 3:
+                raise AcceptanceError("candidate point-value row is malformed")
+            point = int(fields[1])
+            if point in point_values:
+                raise AcceptanceError("candidate point value is duplicated")
+            point_values[point] = float(fields[2])
+            continue
+        if fields[0] == "CALIBRATION_CELL":
+            if len(fields) != 4:
+                raise AcceptanceError("candidate calibration cell is malformed")
+            point = int(fields[1])
+            if point in calibration:
+                raise AcceptanceError("candidate calibration cell is duplicated")
+            calibration[point] = (int(fields[2]), float(fields[3]))
+            continue
+        if fields[0] == "WARM_CELL_SECONDS":
+            if len(fields) != 4:
+                raise AcceptanceError("candidate warm cell row is malformed")
+            key = (int(fields[1]), int(fields[2]))
+            if key in warm_cells:
+                raise AcceptanceError("candidate warm cell is duplicated")
+            warm_cells[key] = float(fields[3])
+            continue
+        if len(fields) < 2:
+            raise AcceptanceError("candidate scalar row is malformed")
+        key = fields[0]
+        if key in scalar:
+            raise AcceptanceError(f"candidate scalar {key} is duplicated")
+        scalar[key] = " ".join(fields[1:])
+    required = {
+        "PROCESS",
+        "EXECUTION_MODE",
+        "TIMER_SOURCE",
+        "HELICITY_COVERAGE_COUNT",
+        "SELECTED_HELICITY_ID",
+        "POINT_COUNT",
+        "LOAD_SECONDS",
+        "FIRST_WARM_SECONDS",
+        "WARM_UP_API_SECONDS",
+        "MIN_ABSOLUTE_VALUE",
+        "MAX_RSS_KIB",
+    }
+    if set(scalar) != required:
+        missing = sorted(required - set(scalar))
+        extra = sorted(set(scalar) - required)
+        raise AcceptanceError(
+            f"candidate probe scalar fields differ: missing={missing}, extra={extra}"
+        )
+    expected_points = set(range(1, POINT_COUNT + 1))
+    if set(point_values) != expected_points:
+        raise AcceptanceError("candidate probe must report all 10 point values")
+    if set(calibration) != {REPRESENTATIVE_POINT}:
+        raise AcceptanceError(
+            "candidate probe must calibrate only representative point 1"
+        )
+    expected_warm_cells = {
+        (sample, REPRESENTATIVE_POINT) for sample in range(1, WARM_SAMPLE_COUNT + 1)
+    }
+    if set(warm_cells) != expected_warm_cells:
+        raise AcceptanceError(
+            "candidate probe must contain one point-1 cell in each of 10 batches"
+        )
+    execution_mode = scalar["EXECUTION_MODE"]
+    if execution_mode not in LANES:
+        raise AcceptanceError("candidate probe reported an unknown execution mode")
+    if scalar["TIMER_SOURCE"] != "process-cpu-time":
+        raise AcceptanceError("candidate probe did not use process CPU time")
+    point_count = int(scalar["POINT_COUNT"])
+    helicity_coverage_count = int(scalar["HELICITY_COVERAGE_COUNT"])
+    max_rss_kib = int(scalar["MAX_RSS_KIB"])
+    numeric = {
+        key: float(scalar[key])
+        for key in (
+            "LOAD_SECONDS",
+            "FIRST_WARM_SECONDS",
+            "WARM_UP_API_SECONDS",
+            "MIN_ABSOLUTE_VALUE",
+        )
+    }
+    calibration_calls = (calibration[REPRESENTATIVE_POINT][0],)
+    calibration_seconds = (calibration[REPRESENTATIVE_POINT][1],)
+    ordered_point_values = tuple(
+        point_values[index] for index in range(1, POINT_COUNT + 1)
+    )
+    warm_cell_rows = tuple(
+        (warm_cells[(sample, REPRESENTATIVE_POINT)],)
+        for sample in range(1, WARM_SAMPLE_COUNT + 1)
+    )
+    warm_samples = tuple(row[0] for row in warm_cell_rows)
+    if point_count != POINT_COUNT:
+        raise AcceptanceError("candidate probe did not use 10 phase-space points")
+    if helicity_coverage_count < 1 or not scalar["SELECTED_HELICITY_ID"].startswith(
+        "h:"
+    ):
+        raise AcceptanceError("candidate selected-helicity metadata is invalid")
+    if any(value < 1 for value in calibration_calls):
+        raise AcceptanceError("candidate calibration call count is not positive")
+    if any(value < MINIMUM_CALIBRATION_SECONDS for value in calibration_seconds):
+        raise AcceptanceError(
+            "every candidate calibration cell must reach 0.25 seconds"
+        )
+    if max_rss_kib < 1:
+        raise AcceptanceError("candidate peak RSS is not positive")
+    warm_up_api_seconds = numeric["WARM_UP_API_SECONDS"]
+    if execution_mode == "recurrence":
+        if warm_up_api_seconds != 0.0:
+            raise AcceptanceError(
+                "recurrence candidate called the OTF-only warm-up API"
+            )
+    elif not _positive_finite(warm_up_api_seconds):
+        raise AcceptanceError("OTF candidate warm-up API timing is not positive")
+    positive_numeric = (
+        numeric["LOAD_SECONDS"],
+        numeric["FIRST_WARM_SECONDS"],
+        *calibration_seconds,
+        *(value for row in warm_cell_rows for value in row),
+    )
+    if not all(_positive_finite(value) for value in positive_numeric):
+        raise AcceptanceError("candidate probe contains a non-positive timing")
+    if (
+        not _finite_number(numeric["MIN_ABSOLUTE_VALUE"])
+        or numeric["MIN_ABSOLUTE_VALUE"] < 0.0
+        or not all(_finite_number(value) for value in ordered_point_values)
+    ):
+        raise AcceptanceError("candidate probe contains an invalid matrix element")
+    return CandidateProbeMetrics(
+        process=scalar["PROCESS"],
+        execution_mode=execution_mode,
+        helicity_coverage_count=helicity_coverage_count,
+        selected_helicity_id=scalar["SELECTED_HELICITY_ID"],
+        point_count=point_count,
+        point_values=ordered_point_values,
+        load_seconds=numeric["LOAD_SECONDS"],
+        first_warm_seconds=numeric["FIRST_WARM_SECONDS"],
+        warm_up_api_seconds=warm_up_api_seconds,
+        calibration_calls=calibration_calls,
+        calibration_seconds=calibration_seconds,
+        warm_cell_seconds=warm_cell_rows,
+        warm_samples_seconds=warm_samples,
+        warm_median_seconds=statistics.median(warm_samples),
+        minimum_absolute_value=numeric["MIN_ABSOLUTE_VALUE"],
+        max_rss_kib=max_rss_kib,
+    )
+
+
+def parse_candidate_first_ready_output(output: str) -> CandidateFirstReadyMetrics:
+    """Parse a cold-only probe that exits before calibration and warm batches."""
+
+    lines = [line.strip() for line in output.splitlines() if line.strip()]
+    if not lines or lines[0] != "FFT_CANDIDATE_FIRST_READY_V1":
+        raise AcceptanceError("candidate first-ready header is missing or invalid")
+    scalar: dict[str, str] = {}
+    for line in lines[1:]:
+        fields = line.split()
+        if len(fields) < 2 or fields[0] in scalar:
+            raise AcceptanceError("candidate first-ready scalar rows are malformed")
+        scalar[fields[0]] = " ".join(fields[1:])
+    required = {
+        "PROCESS",
+        "EXECUTION_MODE",
+        "TIMER_SOURCE",
+        "HELICITY_COVERAGE_COUNT",
+        "SELECTED_HELICITY_ID",
+        "POINT_COUNT",
+        "LOAD_SECONDS",
+        "FIRST_WARM_SECONDS",
+        "WARM_UP_API_SECONDS",
+        "MIN_ABSOLUTE_VALUE",
+        "MAX_RSS_KIB",
+    }
+    if set(scalar) != required:
+        raise AcceptanceError("candidate first-ready scalar fields differ")
+    execution_mode = scalar["EXECUTION_MODE"]
+    if execution_mode not in LANES or scalar["TIMER_SOURCE"] != "process-cpu-time":
+        raise AcceptanceError(
+            "candidate first-ready execution/timer metadata is invalid"
+        )
+    point_count = int(scalar["POINT_COUNT"])
+    coverage = int(scalar["HELICITY_COVERAGE_COUNT"])
+    max_rss_kib = int(scalar["MAX_RSS_KIB"])
+    load_seconds = float(scalar["LOAD_SECONDS"])
+    first_warm_seconds = float(scalar["FIRST_WARM_SECONDS"])
+    warm_up_api_seconds = float(scalar["WARM_UP_API_SECONDS"])
+    minimum_absolute_value = float(scalar["MIN_ABSOLUTE_VALUE"])
+    if (
+        point_count != POINT_COUNT
+        or coverage < 1
+        or not scalar["SELECTED_HELICITY_ID"].startswith("h:")
+        or max_rss_kib < 1
+        or not all(
+            _positive_finite(value) for value in (load_seconds, first_warm_seconds)
+        )
+        or not _finite_number(minimum_absolute_value)
+        or minimum_absolute_value < 0.0
+    ):
+        raise AcceptanceError("candidate first-ready evidence is invalid")
+    if execution_mode == "recurrence":
+        if warm_up_api_seconds != 0.0:
+            raise AcceptanceError(
+                "recurrence candidate called the OTF-only warm-up API"
+            )
+    elif not _positive_finite(warm_up_api_seconds):
+        raise AcceptanceError("OTF first-ready warm-up API timing is not positive")
+    return CandidateFirstReadyMetrics(
+        process=scalar["PROCESS"],
+        execution_mode=execution_mode,
+        helicity_coverage_count=coverage,
+        selected_helicity_id=scalar["SELECTED_HELICITY_ID"],
+        point_count=point_count,
+        load_seconds=load_seconds,
+        first_warm_seconds=first_warm_seconds,
+        warm_up_api_seconds=warm_up_api_seconds,
+        minimum_absolute_value=minimum_absolute_value,
+        max_rss_kib=max_rss_kib,
+    )
+
+
+def select_global_lane(
+    references: Mapping[int, ReferenceMetrics],
+    candidates: Mapping[str, Mapping[int, CandidateMetrics]],
+) -> str:
+    """Choose the fastest globally consistent lane that passes every gate."""
+
+    eligibility = lane_eligibility(candidates)
+    scores: list[tuple[float, str]] = []
+    for lane in LANES:
+        lane_policy = eligibility[lane]
+        if lane_policy["eligible"] and all(
+            gate.passes
+            for gate in _lane_gate_results(
+                lane,
+                references,
+                candidates[lane],
+                MANDATORY_MULTIPLICITIES,
+            )
+        ):
+            scores.append((float(lane_policy["warm_geometric_mean_seconds"]), lane))
+    if not scores:
+        raise AcceptanceError("no eligible lane passes every mandatory acceptance gate")
+    # The lane name is a stable tie-breaker; selection never changes per N.
+    return min(scores)[1]
+
+
+def lane_eligibility(
+    candidates: Mapping[str, Mapping[int, CandidateMetrics]],
+) -> dict[str, dict[str, object]]:
+    """Summarize mandatory evidence and acceptance eligibility per lane."""
+
+    result: dict[str, dict[str, object]] = {}
+    mandatory = set(MANDATORY_MULTIPLICITIES)
+    for lane in LANES:
+        lane_records = candidates.get(lane)
+        if lane_records is None or not mandatory <= set(lane_records):
+            raise AcceptanceError(
+                f"lane {lane} does not cover every mandatory multiplicity"
+            )
+        records = tuple(lane_records[total] for total in MANDATORY_MULTIPLICITIES)
+        if any(
+            record.lane != lane
+            or record.total_gluons != total
+            or record.probe.execution_mode != lane
+            for total, record in zip(MANDATORY_MULTIPLICITIES, records, strict=True)
+        ):
+            raise AcceptanceError(f"lane {lane} contains inconsistent evidence")
+        values = tuple(record.probe.warm_median_seconds for record in records)
+        if not all(_positive_finite(value) for value in values):
+            raise AcceptanceError(f"lane {lane} has an invalid warm measurement")
+        workload = _lane_workload_eligibility(lane, records)
+        result[lane] = {
+            **workload,
+            "mandatory_helicity_coverage_count": {
+                str(total): record.probe.helicity_coverage_count
+                for total, record in zip(MANDATORY_MULTIPLICITIES, records, strict=True)
+            },
+            "warm_geometric_mean_seconds": math.exp(
+                statistics.fmean(math.log(value) for value in values)
+            ),
+        }
+    return result
+
+
+def _lane_workload_eligibility(
+    lane: str,
+    records: Sequence[CandidateMetrics],
+) -> dict[str, object]:
+    """Apply the lane-specific helicity workload contract once."""
+
+    if lane not in LANES or not records:
+        raise AcceptanceError("lane workload evidence is invalid")
+    coverage = tuple(record.probe.helicity_coverage_count for record in records)
+    generation_specialized = all(count == 1 for count in coverage)
+    complete_helicity_coverage = all(count > 1 for count in coverage)
+    if lane == "recurrence":
+        eligible = generation_specialized
+        contract = "generation-specialized-known-nonzero"
+        reason = (
+            "eligible: one generation-selected known-nonzero helicity"
+            if eligible
+            else "ineligible: recurrence artifact is not generation-specialized"
+        )
+    else:
+        eligible = complete_helicity_coverage
+        contract = "complete-runtime-selector-fixed-helicity-query"
+        reason = (
+            "eligible: complete runtime-selector axis with one fixed query"
+            if eligible
+            else "ineligible: OTF artifact does not retain complete selector coverage"
+        )
+    return {
+        "eligible": eligible,
+        "reason": reason,
+        "coverage_contract": contract,
+        "generation_specialized": generation_specialized,
+        "complete_helicity_coverage": complete_helicity_coverage,
+    }
+
+
+def evaluate_gates(
+    winner: str,
+    references: Mapping[int, ReferenceMetrics],
+    candidates: Mapping[str, Mapping[int, CandidateMetrics]],
+    *,
+    multiplicities: Sequence[int] = MANDATORY_MULTIPLICITIES,
+) -> tuple[GateResult, ...]:
+    """Apply all ratios to the one global winner without lane mixing."""
+
+    if winner not in LANES or winner not in candidates:
+        raise AcceptanceError("global winning lane is unavailable")
+    if not lane_eligibility(candidates)[winner]["eligible"]:
+        raise AcceptanceError(
+            f"lane {winner} does not satisfy its helicity workload contract"
+        )
+    return _lane_gate_results(winner, references, candidates[winner], multiplicities)
+
+
+def _lane_gate_results(
+    lane: str,
+    references: Mapping[int, ReferenceMetrics],
+    records: Mapping[int, CandidateMetrics],
+    multiplicities: Sequence[int],
+) -> tuple[GateResult, ...]:
+    results: list[GateResult] = []
+    for total_gluons in multiplicities:
+        if total_gluons not in references or total_gluons not in records:
+            raise AcceptanceError(
+                f"paired winner/reference evidence is missing for N={total_gluons}"
+            )
+        results.append(
+            _paired_gate_result(
+                lane,
+                references[total_gluons],
+                records[total_gluons],
+            )
+        )
+    return tuple(results)
+
+
+def _paired_gate_result(
+    lane: str,
+    reference: ReferenceMetrics,
+    candidate: CandidateMetrics,
+) -> GateResult:
+    if candidate.lane != lane or candidate.total_gluons != reference.total_gluons:
+        raise AcceptanceError("paired acceptance evidence is inconsistent")
+    warm_ratio = candidate.probe.warm_median_seconds / reference.warm_median_seconds
+    rss_ratio = candidate.max_rss_kib / reference.max_rss_kib
+    cold_ratio = candidate.cold_to_ready_seconds / reference.cold_to_ready_seconds
+    if not all(
+        _positive_finite(value) for value in (warm_ratio, rss_ratio, cold_ratio)
+    ):
+        raise AcceptanceError("paired acceptance ratio is invalid")
+    return GateResult(
+        total_gluons=reference.total_gluons,
+        lane=lane,
+        warm_ratio=warm_ratio,
+        rss_ratio=rss_ratio,
+        cold_ratio=cold_ratio,
+        warm_passes=warm_ratio <= WARM_RATIO_LIMIT,
+        rss_passes=rss_ratio <= RSS_RATIO_LIMIT,
+        cold_passes=cold_ratio <= COLD_RATIO_LIMIT,
+        numerical_passes=candidate.numerical_parity.passes,
+    )
+
+
+def _observed_mandatory_gate_viability(
+    references: Mapping[int, ReferenceMetrics],
+    candidates: Mapping[str, Mapping[int, CandidateMetrics]],
+    *,
+    multiplicities: Sequence[int],
+) -> dict[str, object]:
+    """Report whether one lane can still pass every completed mandatory row."""
+
+    completed = tuple(multiplicities)
+    if not completed or any(total not in references for total in completed):
+        raise AcceptanceError("observed mandatory reference evidence is incomplete")
+    lanes: dict[str, object] = {}
+    viable_lanes: list[str] = []
+    for lane in LANES:
+        records = candidates.get(lane)
+        if records is None or any(total not in records for total in completed):
+            raise AcceptanceError(
+                f"observed mandatory candidate evidence is incomplete for {lane}"
+            )
+        selected = tuple(records[total] for total in completed)
+        if any(
+            record.lane != lane
+            or record.total_gluons != total
+            or record.probe.execution_mode != lane
+            for total, record in zip(completed, selected, strict=True)
+        ):
+            raise AcceptanceError(f"lane {lane} contains inconsistent evidence")
+        workload = _lane_workload_eligibility(lane, selected)
+        eligible = bool(workload["eligible"])
+        gates = _lane_gate_results(lane, references, records, completed)
+        viable = eligible and all(gate.passes for gate in gates)
+        if viable:
+            viable_lanes.append(lane)
+        lanes[lane] = {
+            **workload,
+            "viable": viable,
+            "gates": [_plain_gate(gate) for gate in gates],
+        }
+    return {
+        "completed_multiplicities": list(completed),
+        "lanes": lanes,
+        "viable_lanes": viable_lanes,
+    }
+
+
+def optional_candidate_is_feasible(candidate: CandidateMetrics) -> bool:
+    return (
+        candidate.generation_seconds < OPTIONAL_COLD_LIMIT_SECONDS
+        and candidate.first_warm_seconds < OPTIONAL_COLD_LIMIT_SECONDS
+        and candidate.max_rss_kib <= int(MEMORY_LIMIT_GIB * 1024**2)
+    )
+
+
+def process_expression(total_gluons: int) -> str:
+    return "g g > " + " ".join("g" for _ in range(total_gluons - 2))
+
+
+def process_name(total_gluons: int) -> str:
+    return f"gg_N{total_gluons}"
+
+
+def _toml_helicity_map(helicities: Sequence[int]) -> str:
+    if not helicities or any(value not in (-1, 1) for value in helicities):
+        raise AcceptanceError("generation-selected helicity must contain only +/-1")
+    return (
+        "{"
+        + ",".join(
+            f"{index}={value}" for index, value in enumerate(helicities, start=1)
+        )
+        + "}"
+    )
+
+
+def candidate_generation_command(
+    *,
+    python: str,
+    lane: str,
+    total_gluons: int,
+    helicities: Sequence[int],
+    artifact: Path,
+) -> tuple[str, ...]:
+    if lane not in LANES:
+        raise AcceptanceError(f"unknown candidate lane {lane}")
+    if len(helicities) != total_gluons:
+        raise AcceptanceError("candidate helicity multiplicity is inconsistent")
+    common = (
+        python,
+        "-m",
+        "pyamplicol",
+        "generate",
+        process_expression(total_gluons),
+        str(artifact),
+        "--name",
+        process_name(total_gluons),
+        "--model",
+        "built-in-sm",
+        "--color-accuracy",
+        "full",
+        "--color-contraction",
+        "symmetric-group-fft",
+        "--execution-mode",
+        lane,
+        "--workers",
+        "1",
+        "--mode",
+        "error",
+        "--no-emit-api-bundle",
+        "--set",
+        "generation.validation.enabled=false",
+        "--set",
+        "generation.validation.post_build_validation=false",
+        "--set",
+        "model.cache=false",
+        "--set",
+        "evaluator.batch_size=1",
+        "--set",
+        "evaluator.optimization.cores=1",
+        "--set",
+        "evaluator.jit.optimization_level=2",
+        "--progress",
+        "off",
+        "--color",
+        "never",
+        "--log-level",
+        "error",
+    )
+    if lane == "on-the-fly":
+        return common
+    insertion = common.index("--no-emit-api-bundle") + 1
+    return (
+        *common[:insertion],
+        "--set",
+        f"process.selected_source_helicities={_toml_helicity_map(helicities)}",
+        *common[insertion:],
+    )
+
+
+def _watchdog_command(
+    command: Sequence[str],
+    *,
+    python: str,
+    memory_limit_gib: float = MEMORY_LIMIT_GIB,
+    report_json: Path | None = None,
+) -> tuple[str, ...]:
+    command_prefix = (
+        python,
+        str(WATCHDOG),
+        "--limit-gib",
+        f"{memory_limit_gib:g}",
+    )
+    if report_json is not None:
+        command_prefix = (*command_prefix, "--report-json", str(report_json))
+    return (*command_prefix, "--", *command)
+
+
+def _read_watchdog_usage_kib(report_path: Path) -> tuple[int, int]:
+    """Read exact RSS and enforced-guard peaks from one successful report."""
+
+    try:
+        payload = json.loads(report_path.read_text(encoding="utf-8"))
+        enforcement = payload["enforcement"]
+        peak_rss_bytes = enforcement["peak_rss_bytes"]
+        peak_guard_bytes = enforcement["peak_guard_bytes"]
+    except (OSError, json.JSONDecodeError, KeyError, TypeError) as error:
+        raise AcceptanceError(
+            f"watchdog report is missing or malformed: {report_path}"
+        ) from error
+    if (
+        payload.get("complete") is not True
+        or payload.get("passes") is not True
+        or not isinstance(peak_rss_bytes, int)
+        or isinstance(peak_rss_bytes, bool)
+        or peak_rss_bytes < 0
+        or not isinstance(peak_guard_bytes, int)
+        or isinstance(peak_guard_bytes, bool)
+        or peak_guard_bytes < 0
+    ):
+        raise AcceptanceError(f"watchdog report is not successful: {report_path}")
+    return (
+        (peak_rss_bytes + 1023) // 1024,
+        (peak_guard_bytes + 1023) // 1024,
+    )
+
+
+def _workspace_environment(python: str) -> dict[str, str]:
+    cache_root = PERFORMANCE_ROOT / "cache"
+    environment = os.environ.copy()
+    environment.update(
+        {
+            "TMPDIR": str(PERFORMANCE_ROOT / "tmp"),
+            "CARGO_HOME": str(cache_root / "cargo-home"),
+            "CARGO_TARGET_DIR": str(cache_root / "cargo-target"),
+            "PIP_CACHE_DIR": str(cache_root / "pip-cache"),
+            "XDG_CACHE_HOME": str(cache_root / "xdg-cache"),
+            "PYTHONPYCACHEPREFIX": str(cache_root / "python-cache"),
+            "CARGO_NET_OFFLINE": "true",
+            "PIP_NO_INDEX": "1",
+            **{name: "1" for name in SINGLE_THREAD_ENVIRONMENT},
+            "PYTHONPATH": str(ROOT / "src"),
+            "PYTHONDONTWRITEBYTECODE": "1",
+            "SYMBOLICA_HIDE_BANNER": "1",
+            "FFT_ACCEPTANCE_PYTHON": python,
+        }
+    )
+    return environment
+
+
+def _create_workspace_directories(run_root: Path) -> None:
+    if run_root.exists():
+        raise AcceptanceError(
+            f"acceptance run already exists; choose another --run-id: {run_root}"
+        )
+    for path in (
+        PERFORMANCE_ROOT / "tmp",
+        PERFORMANCE_ROOT / "cache" / "cargo-home",
+        PERFORMANCE_ROOT / "cache" / "cargo-target",
+        PERFORMANCE_ROOT / "cache" / "pip-cache",
+        PERFORMANCE_ROOT / "cache" / "xdg-cache",
+        PERFORMANCE_ROOT / "cache" / "python-cache",
+        run_root / "logs",
+    ):
+        path.mkdir(parents=True, exist_ok=True)
+
+
+def _translate_darwin_reference_command(
+    command: Sequence[str],
+    *,
+    python: str = sys.executable,
+) -> tuple[tuple[str, ...], bool]:
+    """Use the study's getrusage wrapper instead of unavailable Darwin sysctls."""
+
+    original = tuple(str(item) for item in command)
+    if original[:2] == ("/usr/bin/time", "-l"):
+        payload = original[2:]
+        if not payload:
+            raise AcceptanceError("Darwin time wrapper has no payload")
+        return (python, str(SCALING_STUDY_DRIVER), "_time-rss", *payload), True
+    if not original or original[0] != "/usr/bin/timeout":
+        return original, False
+    if (
+        len(original) < 10
+        or original[1:3] != ("--signal=TERM", "--kill-after=5s")
+        or not original[3].endswith("s")
+        or original[4] != "/usr/bin/time"
+        or original[5] != f"--format={REFERENCE_RSS_MARKER} %M"
+        or original[6] != "/usr/bin/prlimit"
+        or not original[7].startswith("--as=")
+        or original[8] != "--"
+    ):
+        raise AcceptanceError("unrecognized GNU reference measurement wrapper")
+    try:
+        timeout_value = float(original[3][:-1])
+        memory_bytes = int(original[7].partition("=")[2])
+    except ValueError as error:
+        raise AcceptanceError("invalid GNU reference measurement bound") from error
+    if not _positive_finite(timeout_value) or memory_bytes < 1:
+        raise AcceptanceError("invalid GNU reference measurement bound")
+    payload = original[9:]
+    if not payload:
+        raise AcceptanceError("GNU reference measurement wrapper has no payload")
+    return (python, str(SCALING_STUDY_DRIVER), "_time-rss", *payload), True
+
+
+def _resolve_gnu_tool(name: str, fallback: str) -> str:
+    resolved = shutil.which(name)
+    if resolved is not None:
+        return resolved
+    if Path(fallback).is_file():
+        return fallback
+    raise AcceptanceError(
+        f"required GNU utility is unavailable: {name} "
+        f"(also checked {fallback})"
+    )
+
+
+def _translate_gnu_reference_command(
+    command: Sequence[str],
+    *,
+    python: str = sys.executable,
+) -> tuple[tuple[str, ...], bool]:
+    """Measure Linux reference commands with getrusage and resolved wrappers."""
+
+    original = tuple(str(item) for item in command)
+    if original[:2] == ("/usr/bin/time", "-l"):
+        payload = original[2:]
+        if not payload:
+            raise AcceptanceError("time wrapper has no payload")
+        return (python, str(SCALING_STUDY_DRIVER), "_time-rss", *payload), True
+    if not original or original[0] != "/usr/bin/timeout":
+        return original, False
+    if (
+        len(original) < 10
+        or original[1:3] != ("--signal=TERM", "--kill-after=5s")
+        or not original[3].endswith("s")
+        or original[4] != "/usr/bin/time"
+        or original[5] != f"--format={REFERENCE_RSS_MARKER} %M"
+        or original[6] != "/usr/bin/prlimit"
+        or not original[7].startswith("--as=")
+        or original[8] != "--"
+    ):
+        raise AcceptanceError("unrecognized GNU reference measurement wrapper")
+    try:
+        timeout_value = float(original[3][:-1])
+        memory_bytes = int(original[7].partition("=")[2])
+    except ValueError as error:
+        raise AcceptanceError("invalid GNU reference measurement bound") from error
+    if not _positive_finite(timeout_value) or memory_bytes < 1:
+        raise AcceptanceError("invalid GNU reference measurement bound")
+    return (
+        python,
+        str(SCALING_STUDY_DRIVER),
+        "_time-rss",
+        _resolve_gnu_tool("timeout", original[0]),
+        *original[1:4],
+        _resolve_gnu_tool("prlimit", original[6]),
+        *original[7:],
+    ), True
+
+
+def _synthesize_reference_rss_marker(
+    completed: subprocess.CompletedProcess[str],
+) -> subprocess.CompletedProcess[str]:
+    """Copy the getrusage wrapper's exact FFT RSS into the reference protocol."""
+
+    matches: list[int] = []
+    for line in completed.stderr.splitlines():
+        fields = line.split()
+        if len(fields) == 2 and fields[0] == DARWIN_RSS_MARKER:
+            matches.append(int(fields[1]))
+    if len(matches) != 1 or matches[0] < 1:
+        raise AcceptanceError("Darwin getrusage wrapper did not report exact RSS")
+    stderr = completed.stderr.rstrip("\n")
+    return subprocess.CompletedProcess(
+        args=completed.args,
+        returncode=completed.returncode,
+        stdout=completed.stdout,
+        stderr=f"{stderr}\n{REFERENCE_RSS_MARKER} {matches[0]}\n",
+    )
+
+
+def _parse_translated_reference_child_rss_kib(stderr: str) -> int:
+    markers: dict[str, list[int]] = {
+        DARWIN_RSS_MARKER: [],
+        REFERENCE_RSS_MARKER: [],
+    }
+    for line in stderr.splitlines():
+        fields = line.split()
+        if len(fields) == 2 and fields[0] in markers:
+            try:
+                markers[fields[0]].append(int(fields[1]))
+            except ValueError as error:
+                raise AcceptanceError(
+                    "translated Reference RSS marker is malformed"
+                ) from error
+    fft_values = markers[DARWIN_RSS_MARKER]
+    benchmark_values = markers[REFERENCE_RSS_MARKER]
+    if (
+        len(fft_values) != 1
+        or len(benchmark_values) != 1
+        or fft_values[0] < 1
+        or fft_values != benchmark_values
+    ):
+        raise AcceptanceError(
+            "translated Reference command lacks one matching exact child RSS marker"
+        )
+    return fft_values[0]
+
+
+def _formal_reference_evaluator_rss_kib(
+    driver_child_rss_kib: int,
+    direct_command_watchdog_rss_kib: int,
+    translated_child_rss_kib: int,
+) -> int:
+    values = (
+        driver_child_rss_kib,
+        direct_command_watchdog_rss_kib,
+        translated_child_rss_kib,
+    )
+    if (
+        any(
+            not isinstance(value, int) or isinstance(value, bool) or value < 0
+            for value in values
+        )
+        or driver_child_rss_kib < 1
+    ):
+        raise AcceptanceError("Reference evaluator RSS evidence is invalid")
+    # The formal ratio compares the two fresh evaluator processes.  Compiler
+    # and wrapper peaks remain watchdog/cap telemetry, not part of this value.
+    return driver_child_rss_kib
+
+
+def _run_watched(
+    command: Sequence[str],
+    *,
+    python: str,
+    environment: Mapping[str, str],
+    timeout_seconds: float,
+    log_path: Path,
+    memory_limit_gib: float = MEMORY_LIMIT_GIB,
+    watchdog_report_path: Path | None = None,
+    normalize_completed: (
+        Callable[[subprocess.CompletedProcess[str]], subprocess.CompletedProcess[str]]
+        | None
+    ) = None,
+) -> WatchedCompletedProcess:
+    """Run one watchdog and give it time to reap its separate-session child."""
+
+    if not _positive_finite(timeout_seconds):
+        raise AcceptanceError("watched command timeout must be positive")
+    if not _positive_finite(memory_limit_gib):
+        raise AcceptanceError("watched command memory limit must be positive")
+    if watchdog_report_path is not None:
+        watchdog_report_path.parent.mkdir(parents=True, exist_ok=True)
+        if watchdog_report_path.exists():
+            raise AcceptanceError(
+                f"watchdog report already exists: {watchdog_report_path}"
+            )
+    watched_command = _watchdog_command(
+        command,
+        python=python,
+        memory_limit_gib=memory_limit_gib,
+        report_json=watchdog_report_path,
+    )
+    started = time.perf_counter()
+    process = subprocess.Popen(
+        watched_command,
+        cwd=ROOT,
+        env=dict(environment),
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    timed_out = False
+    timeout_cleanup = "not-required"
+    try:
+        stdout, stderr = process.communicate(timeout=timeout_seconds)
+    except subprocess.TimeoutExpired:
+        timed_out = True
+        process.terminate()
+        timeout_cleanup = "sigterm-complete"
+        try:
+            stdout, stderr = process.communicate(timeout=WATCHDOG_CLEANUP_WAIT_SECONDS)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            stdout, stderr = process.communicate()
+            timeout_cleanup = "sigkill-fallback"
+    elapsed_seconds = time.perf_counter() - started
+    completed: subprocess.CompletedProcess[str] = subprocess.CompletedProcess(
+        args=watched_command,
+        returncode=process.returncode,
+        stdout=stdout,
+        stderr=stderr,
+    )
+    normalization_error: Exception | None = None
+    if normalize_completed is not None and not timed_out and completed.returncode == 0:
+        try:
+            completed = normalize_completed(completed)
+        except (
+            Exception
+        ) as error:  # Preserve the raw child evidence before surfacing it.
+            normalization_error = error
+    peak_guard_kib: int | None = None
+    peak_rss_kib: int | None = None
+    watchdog_report_error: Exception | None = None
+    if watchdog_report_path is not None and not timed_out and completed.returncode == 0:
+        try:
+            peak_rss_kib, peak_guard_kib = _read_watchdog_usage_kib(
+                watchdog_report_path
+            )
+        except Exception as error:
+            watchdog_report_error = error
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    log_started = time.perf_counter()
+    log_path.write_text(
+        json.dumps(
+            {
+                "command": list(command),
+                "watchdog_command": list(watched_command),
+                "elapsed_seconds": elapsed_seconds,
+                "elapsed_excludes_log_write": True,
+                "returncode": completed.returncode,
+                "stdout": completed.stdout,
+                "stderr": completed.stderr,
+                "timed_out": timed_out,
+                "timeout_cleanup": timeout_cleanup,
+                "normalization_error": (
+                    None
+                    if normalization_error is None
+                    else f"{type(normalization_error).__name__}: {normalization_error}"
+                ),
+                "watchdog_report": (
+                    None if watchdog_report_path is None else str(watchdog_report_path)
+                ),
+                "watchdog_peak_guard_kib": peak_guard_kib,
+                "watchdog_peak_rss_kib": peak_rss_kib,
+                "watchdog_report_error": (
+                    None
+                    if watchdog_report_error is None
+                    else f"{type(watchdog_report_error).__name__}: "
+                    f"{watchdog_report_error}"
+                ),
+            },
+            indent=2,
+            sort_keys=True,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    log_write_seconds = time.perf_counter() - log_started
+    result = WatchedCompletedProcess(
+        completed.args,
+        completed.returncode,
+        completed.stdout,
+        completed.stderr,
+        elapsed_seconds=elapsed_seconds,
+        log_write_seconds=log_write_seconds,
+        peak_guard_kib=peak_guard_kib,
+        peak_rss_kib=peak_rss_kib,
+        timed_out=timed_out,
+        timeout_cleanup=timeout_cleanup,
+    )
+    if timed_out:
+        raise AcceptanceError(
+            f"command timed out after {timeout_seconds:g}s "
+            f"(watchdog cleanup: {timeout_cleanup}): {shlex.join(command)}; "
+            f"see {log_path}"
+        )
+    if result.returncode != 0:
+        raise AcceptanceError(
+            f"command failed with status {result.returncode}: "
+            f"{shlex.join(command)}; see {log_path}"
+        )
+    if normalization_error is not None:
+        raise normalization_error
+    if watchdog_report_error is not None:
+        raise watchdog_report_error
+    return result
+
+
+def _load_reference_module() -> ModuleType:
+    if not REFERENCE_DRIVER.is_file():
+        raise AcceptanceError(f"reference driver is missing: {REFERENCE_DRIVER}")
+    name = "_pyamplicol_fft_reference_benchmark"
+    specification = importlib.util.spec_from_file_location(name, REFERENCE_DRIVER)
+    if specification is None or specification.loader is None:
+        raise AcceptanceError("cannot load bundled AmpliGluonTrace benchmark")
+    module = importlib.util.module_from_spec(specification)
+    sys.modules[name] = module
+    specification.loader.exec_module(module)
+    return module
+
+
+@contextmanager
+def _arguments(arguments: Sequence[str]):
+    previous = sys.argv
+    sys.argv = [str(REFERENCE_DRIVER), *arguments]
+    try:
+        yield
+    finally:
+        sys.argv = previous
+
+
+def _reference_arguments(
+    reference: ModuleType,
+    *,
+    total_gluons: int,
+    build_dir: Path,
+    fc: str,
+    target_seconds: float,
+    timeout_seconds: float,
+    memory_limit_gib: float = MEMORY_LIMIT_GIB,
+    repetition_quantum: int | None = None,
+    warm_sample_count: int = WARM_SAMPLE_COUNT,
+) -> argparse.Namespace:
+    if (
+        isinstance(warm_sample_count, bool)
+        or not isinstance(warm_sample_count, int)
+        or warm_sample_count < 1
+    ):
+        raise AcceptanceError("reference warm_sample_count must be positive")
+    argv = (
+        "--min-gluons",
+        str(total_gluons),
+        "--max-gluons",
+        str(total_gluons),
+        "--points",
+        str(POINT_COUNT),
+        "--seed",
+        str(BASE_SEED),
+        "--mhv-samples",
+        "1",
+        "--non-mhv-samples",
+        "1",
+        "--backend",
+        REFERENCE_BACKEND,
+        "--target-seconds",
+        f"{target_seconds:.17g}",
+        "--batches",
+        str(warm_sample_count),
+        "--initialization-runs",
+        "1",
+        "--skip-initialization-preflight",
+        "--max-memory-gib",
+        f"{memory_limit_gib:g}",
+        "--backend-timeout",
+        f"{timeout_seconds:g}",
+        "--build-dir",
+        str(build_dir),
+        "--fc",
+        fc,
+    )
+    if repetition_quantum is not None:
+        argv = (*argv, "--repetition-quantum", str(repetition_quantum))
+    with _arguments(argv):
+        parsed = reference.parse_arguments()
+    reference.validate_arguments(parsed)
+    return parsed
+
+
+def _reference_representative_warm_samples(
+    cell_timings: Mapping[tuple[int, int, int], float],
+    *,
+    warm_sample_count: int = WARM_SAMPLE_COUNT,
+) -> tuple[float, ...]:
+    """Validate DefaultBG's one representative event/configuration per batch."""
+
+    expected = {
+        (batch, REPRESENTATIVE_POINT, 1)
+        for batch in range(1, warm_sample_count + 1)
+    }
+    if set(cell_timings) != expected:
+        raise AcceptanceError(
+            "reference must report one point-1 cell in each requested batch"
+        )
+    values = tuple(
+        cell_timings[(batch, REPRESENTATIVE_POINT, 1)]
+        for batch in range(1, warm_sample_count + 1)
+    )
+    if not all(_positive_finite(value) for value in values):
+        raise AcceptanceError("reference representative timing cells are not positive")
+    return values
+
+
+def _bounded_reference_cold_timeout(
+    effective_timeout: float,
+    cold_limit_seconds: float | None,
+    cold_started: float,
+) -> float:
+    if cold_limit_seconds is None:
+        return effective_timeout
+    remaining_cold = cold_limit_seconds - (time.perf_counter() - cold_started)
+    if remaining_cold <= 0.0:
+        raise ReferenceColdLimitError(
+            "reference campaign exhausted its aggregate cold deadline"
+        )
+    return min(effective_timeout, remaining_cold)
+
+
+def _is_reference_backend_build_command(
+    command: Sequence[str],
+    *,
+    build_dir: Path,
+    build_phase_active: bool,
+) -> bool:
+    """Identify compiler/linker commands belonging only to AmpliGluonTrace."""
+
+    if not build_phase_active:
+        return False
+    backend_dir = (build_dir / REFERENCE_BUILD_PROGRAM).resolve()
+    backend_prefix = f"{backend_dir}{os.sep}"
+    include_prefixes = (
+        backend_prefix,
+        f"-I{backend_prefix}",
+        f"-J{backend_prefix}",
+    )
+    return any(
+        str(token) == str(backend_dir) or str(token).startswith(include_prefixes)
+        for token in command
+    )
+
+
+def _run_reference(
+    *,
+    reference: ModuleType,
+    total_gluons: int,
+    run_root: Path,
+    python: str,
+    environment: Mapping[str, str],
+    fc: str,
+    target_seconds: float,
+    timeout_seconds: float,
+    cold_limit_seconds: float | None = None,
+    memory_limit_gib: float = MEMORY_LIMIT_GIB,
+    repetition_quantum: int | None = None,
+    warm_sample_count: int = WARM_SAMPLE_COUNT,
+    sum_helicities: bool = False,
+) -> _ReferenceRun:
+    reference_root = run_root / "reference" / f"N{total_gluons}"
+    build_dir = reference_root / "build"
+    if build_dir.exists():
+        raise AcceptanceError("reference build directory is not clean")
+    effective_repetition_quantum = 1 if sum_helicities else repetition_quantum
+    arguments = _reference_arguments(
+        reference,
+        total_gluons=total_gluons,
+        build_dir=build_dir,
+        fc=fc,
+        target_seconds=target_seconds,
+        timeout_seconds=timeout_seconds,
+        memory_limit_gib=memory_limit_gib,
+        repetition_quantum=effective_repetition_quantum,
+        warm_sample_count=warm_sample_count,
+    )
+    command_index = 0
+    command_log_write_seconds = 0.0
+    watchdog_max_rss_kib = 0
+    direct_command_watchdog_max_rss_kib = 0
+    translated_child_max_rss_kib = 0
+    watchdog_max_peak_guard_kib = 0
+    clean_build_seconds = 0.0
+    clean_build_command_count = 0
+    build_phase_active = False
+    original_run_command = reference.run_command
+    campaign_timeout_seconds = timeout_seconds
+    cold_started = time.perf_counter()
+
+    def watched_reference_command(
+        command: Sequence[str],
+        description: str,
+        timeout_seconds: float | None = None,
+    ) -> subprocess.CompletedProcess[str]:
+        nonlocal command_index, command_log_write_seconds
+        nonlocal watchdog_max_peak_guard_kib, watchdog_max_rss_kib
+        nonlocal direct_command_watchdog_max_rss_kib
+        nonlocal translated_child_max_rss_kib
+        nonlocal clean_build_command_count, clean_build_seconds
+        command_index += 1
+        safe_description = re.sub(r"[^A-Za-z0-9._-]+", "-", description).strip("-")
+        translated = False
+        command_to_run = tuple(str(item) for item in command)
+        is_clean_backend_build = _is_reference_backend_build_command(
+            command_to_run,
+            build_dir=build_dir,
+            build_phase_active=build_phase_active,
+        )
+        if sys.platform == "darwin":
+            command_to_run, translated = _translate_darwin_reference_command(
+                command_to_run,
+                python=python,
+            )
+        else:
+            command_to_run, translated = _translate_gnu_reference_command(
+                command_to_run,
+                python=python,
+            )
+        effective_timeout = (
+            campaign_timeout_seconds + 30.0
+            if timeout_seconds is None
+            else timeout_seconds + 30.0
+        )
+        if translated and timeout_seconds is not None:
+            # run_driver already supplies backend_timeout + its cleanup grace.
+            effective_timeout = timeout_seconds
+        effective_timeout = _bounded_reference_cold_timeout(
+            effective_timeout, cold_limit_seconds, cold_started
+        )
+        log_path = reference_root / "logs" / f"{command_index:03d}-{safe_description}"
+        completed = _run_watched(
+            command_to_run,
+            python=python,
+            environment=environment,
+            timeout_seconds=effective_timeout,
+            log_path=log_path.with_suffix(".json"),
+            memory_limit_gib=memory_limit_gib,
+            watchdog_report_path=log_path.with_suffix(".watchdog.json"),
+            normalize_completed=(
+                _synthesize_reference_rss_marker if translated else None
+            ),
+        )
+        if completed.peak_rss_kib is None or completed.peak_guard_kib is None:
+            raise AcceptanceError("reference command has no watchdog RSS evidence")
+        watchdog_max_rss_kib = max(watchdog_max_rss_kib, completed.peak_rss_kib)
+        if translated:
+            translated_child_max_rss_kib = max(
+                translated_child_max_rss_kib,
+                _parse_translated_reference_child_rss_kib(completed.stderr),
+            )
+        else:
+            direct_command_watchdog_max_rss_kib = max(
+                direct_command_watchdog_max_rss_kib,
+                completed.peak_rss_kib,
+            )
+        watchdog_max_peak_guard_kib = max(
+            watchdog_max_peak_guard_kib, completed.peak_guard_kib
+        )
+        if is_clean_backend_build:
+            clean_build_seconds += completed.elapsed_seconds
+            clean_build_command_count += 1
+        command_log_write_seconds += completed.log_write_seconds
+        return completed
+
+    reference.run_command = watched_reference_command
+    try:
+        compiler = shlex.split(arguments.fc)
+        flags = shlex.split(arguments.fflags)
+        if not compiler:
+            raise AcceptanceError("reference Fortran compiler is empty")
+        compiler_identity = reference.compiler_version(compiler).strip()
+        build_phase_active = True
+        try:
+            rambo, proxy, executables = reference.build_executables(
+                arguments,
+                compiler,
+                compiler_identity,
+                flags,
+            )
+        finally:
+            build_phase_active = False
+        reference_executable = executables.get(REFERENCE_BACKEND)
+        expected_build_dir = (build_dir / REFERENCE_BUILD_PROGRAM).resolve()
+        if (
+            reference_executable is None
+            or expected_build_dir not in reference_executable.resolve().parents
+            or clean_build_command_count < 1
+            or not _positive_finite(clean_build_seconds)
+        ):
+            raise AcceptanceError(
+                "reference clean backend build boundary is incomplete"
+            )
+        events, _, exhaustive_helicities = reference.generate_events(
+            rambo,
+            total_gluons,
+            arguments,
+        )
+        weights, _, _, _ = reference.run_helicity_proxy(
+            proxy,
+            events,
+            exhaustive_helicities,
+            arguments,
+        )
+        _, _, selected = reference.select_helicity_samples(
+            events,
+            exhaustive_helicities,
+            weights,
+            total_gluons,
+            arguments,
+        )
+        representative = selected[0]
+        if representative.path == "zero" or representative.proxy_weight <= 0.0:
+            raise AcceptanceError("reference selected an analytically zero helicity")
+        uniform_events: list[Path] = []
+        event_dir = reference_root / "selected-helicity-events"
+        for point, source_event in enumerate(events, start=1):
+            destination = event_dir / f"N{total_gluons}-point-{point:02d}.event"
+            reference.write_single_helicity_event(
+                source_event,
+                destination,
+                representative.helicities,
+            )
+            uniform_events.append(destination)
+        setup_to_driver_seconds = (
+            time.perf_counter() - cold_started - command_log_write_seconds
+        )
+        if not _positive_finite(setup_to_driver_seconds):
+            raise AcceptanceError("reference setup timing is not positive")
+        if sum_helicities:
+            run = reference.run_driver(
+                REFERENCE_BACKEND,
+                reference_executable,
+                events,
+                arguments,
+                False,
+                sum_helicities=True,
+            )
+        else:
+            run = reference.run_driver(
+                REFERENCE_BACKEND,
+                reference_executable,
+                uniform_events,
+                arguments,
+                False,
+            )
+    finally:
+        reference.run_command = original_run_command
+
+    batch_values = _reference_representative_warm_samples(
+        run.cell_timings,
+        warm_sample_count=warm_sample_count,
+    )
+    warm_repetitions: tuple[int, ...] = ()
+    warm_calibration_seconds: tuple[float, ...] = ()
+    if effective_repetition_quantum is not None:
+        expected_repetition_keys = {
+            (batch, REPRESENTATIVE_POINT, 1)
+            for batch in range(1, warm_sample_count + 1)
+        }
+        if (
+            run.cell_repetitions is None
+            or set(run.cell_repetitions) != expected_repetition_keys
+            or any(
+                value < effective_repetition_quantum
+                or value % effective_repetition_quantum != 0
+                for value in run.cell_repetitions.values()
+            )
+        ):
+            raise AcceptanceError(
+                "reference did not use the requested repetition quantum"
+            )
+        warm_repetitions = tuple(
+            run.cell_repetitions[(batch, REPRESENTATIVE_POINT, 1)]
+            for batch in range(1, warm_sample_count + 1)
+        )
+        if len(set(warm_repetitions)) != 1:
+            raise AcceptanceError("reference changed repetitions after calibration")
+        expected_calibration_keys = {(REPRESENTATIVE_POINT, 1)}
+        if (
+            run.cell_calibration_seconds is None
+            or set(run.cell_calibration_seconds) != expected_calibration_keys
+            or any(
+                value < target_seconds
+                for value in run.cell_calibration_seconds.values()
+            )
+        ):
+            raise AcceptanceError(
+                "reference repetition calibration did not reach its timing target"
+            )
+        warm_calibration_seconds = tuple(run.cell_calibration_seconds.values())
+    if (
+        run.first_helicity_sweep is None
+        or not _positive_finite(run.first_helicity_sweep)
+        or run.peak_rss_kib is None
+        or run.peak_rss_kib < 1
+    ):
+        raise AcceptanceError("reference cold/RSS metrics are incomplete")
+    if sum_helicities:
+        exhaustive_keys = set(exhaustive_helicities)
+        if set(run.matrix_elements) != exhaustive_keys or any(
+            not math.isfinite(value) or value < 0.0
+            for value in run.matrix_elements.values()
+        ):
+            raise AcceptanceError(
+                "reference did not return the exhaustive helicity grid"
+            )
+        helicity_coverage_count = len(
+            [key for key in exhaustive_keys if key[0] == REPRESENTATIVE_POINT]
+        )
+        active_helicity_count = sum(
+            not reference.is_analytic_zero_helicity(helicities)
+            for (point, _), helicities in exhaustive_helicities.items()
+            if point == REPRESENTATIVE_POINT
+        )
+        if (
+            helicity_coverage_count < 1
+            or active_helicity_count < 1
+            or active_helicity_count > helicity_coverage_count
+        ):
+            raise AcceptanceError("reference exhaustive helicity census is invalid")
+        matrix_elements = tuple(
+            math.fsum(
+                run.matrix_elements[key]
+                for key in sorted(exhaustive_keys)
+                if key[0] == point
+            )
+            for point in range(1, POINT_COUNT + 1)
+        )
+        if any(not _positive_finite(value) for value in matrix_elements):
+            raise AcceptanceError("reference helicity sum is zero or non-finite")
+    else:
+        expected_matrix_element_keys = {
+            (point, 1) for point in range(1, POINT_COUNT + 1)
+        }
+        if set(run.matrix_elements) != expected_matrix_element_keys or any(
+            not _positive_finite(value) for value in run.matrix_elements.values()
+        ):
+            raise AcceptanceError(
+                "reference did not confirm the selected helicity at all 10 points"
+            )
+        matrix_elements = tuple(
+            run.matrix_elements[(point, 1)] for point in range(1, POINT_COUNT + 1)
+        )
+        helicity_coverage_count = 1
+        active_helicity_count = 1
+    if watchdog_max_peak_guard_kib > int(memory_limit_gib * 1024**2):
+        raise AcceptanceError("reference exceeded the watchdog peak-guard bound")
+    metrics = ReferenceMetrics(
+        total_gluons=total_gluons,
+        generator_seed=generator_seed(total_gluons),
+        backend=REFERENCE_BACKEND,
+        clean_build_scope=REFERENCE_CLEAN_BUILD_SCOPE,
+        clean_build_command_count=clean_build_command_count,
+        clean_build_seconds=clean_build_seconds,
+        setup_to_driver_seconds=setup_to_driver_seconds,
+        initialization_seconds=run.initialization,
+        first_pass_seconds=run.first_helicity_sweep,
+        warm_samples_seconds=batch_values,
+        warm_median_seconds=statistics.median(batch_values),
+        max_rss_kib=_formal_reference_evaluator_rss_kib(
+            run.peak_rss_kib,
+            direct_command_watchdog_max_rss_kib,
+            translated_child_max_rss_kib,
+        ),
+        selected_helicity=tuple(representative.helicities),
+        selected_path=representative.path,
+        event_paths=tuple(str(path) for path in uniform_events),
+        matrix_elements=matrix_elements,
+        driver_max_rss_kib=run.peak_rss_kib,
+        watchdog_max_rss_kib=watchdog_max_rss_kib,
+        direct_command_watchdog_max_rss_kib=(
+            direct_command_watchdog_max_rss_kib or None
+        ),
+        translated_child_max_rss_kib=translated_child_max_rss_kib or None,
+        watchdog_max_peak_guard_kib=watchdog_max_peak_guard_kib,
+        warm_repetitions=warm_repetitions,
+        warm_repetition_quantum=effective_repetition_quantum,
+        warm_calibration_seconds=warm_calibration_seconds,
+        helicity_workload="sum" if sum_helicities else "fixed",
+        helicity_coverage_count=helicity_coverage_count,
+        timed_helicity_count=active_helicity_count,
+        active_helicity_count=active_helicity_count,
+        exhaustive_event_paths=(
+            tuple(str(path) for path in events) if sum_helicities else ()
+        ),
+    )
+    if (
+        cold_limit_seconds is not None
+        and metrics.setup_to_ready_seconds > cold_limit_seconds
+    ):
+        raise ReferenceColdLimitError(
+            "reference setup/initialization/first pass exceeded its cold deadline"
+        )
+    return _ReferenceRun(metrics=metrics, event_paths=tuple(uniform_events))
+
+
+def _build_probe(
+    *,
+    run_root: Path,
+    python: str,
+    cxx: str,
+    environment: Mapping[str, str],
+    memory_limit_gib: float = MEMORY_LIMIT_GIB,
+) -> tuple[Path, dict[str, Any]]:
+    sdk = _run_watched(
+        (python, "-m", "rusticol_config", "--json"),
+        python=python,
+        environment=environment,
+        timeout_seconds=60.0,
+        log_path=run_root / "logs" / "sdk-config.json",
+        memory_limit_gib=memory_limit_gib,
+    )
+    try:
+        sdk_info = json.loads(sdk.stdout)
+    except json.JSONDecodeError as error:
+        raise AcceptanceError("Rusticol SDK query returned invalid JSON") from error
+    required = {"cflags", "link_flags", "target", "package_version"}
+    if not isinstance(sdk_info, dict) or not required <= set(sdk_info):
+        raise AcceptanceError("Rusticol SDK query is incomplete")
+    executable = run_root / "candidate-probe" / "fft-gluon-candidate-probe"
+    executable.parent.mkdir(parents=True, exist_ok=True)
+    compiler = shlex.split(cxx)
+    if not compiler:
+        raise AcceptanceError("C++ compiler command is empty")
+    command = (
+        *compiler,
+        "-std=c++17",
+        "-O3",
+        "-DNDEBUG",
+        *map(str, sdk_info["cflags"]),
+        str(PROBE_SOURCE),
+        "-o",
+        str(executable),
+        *map(str, sdk_info["link_flags"]),
+        *_candidate_probe_executable_link_flags(sys.platform),
+    )
+    _run_watched(
+        command,
+        python=python,
+        environment=environment,
+        timeout_seconds=600.0,
+        log_path=run_root / "logs" / "candidate-probe-build.json",
+        memory_limit_gib=memory_limit_gib,
+    )
+    return executable, sdk_info
+
+
+def _candidate_probe_executable_link_flags(platform_name: str) -> tuple[str, ...]:
+    """Discard SDK code that is unreachable from this standalone probe."""
+
+    if platform_name == "darwin":
+        # Apple ld keeps exported symbols as dead-strip roots.  A standalone
+        # benchmark executable has no plugin ABI, so retaining the static
+        # archive's thousands of Rust globals defeats ordinary link-time GC.
+        return ("-Wl,-dead_strip", "-Wl,-no_exported_symbols")
+    return ()
+
+
+def _candidate_probe_command(
+    *,
+    probe: Path,
+    artifact: Path,
+    total_gluons: int,
+    target_seconds: float,
+    event_paths: Sequence[Path],
+    first_ready_only: bool,
+) -> tuple[str, ...]:
+    return (
+        str(probe),
+        str(artifact),
+        process_name(total_gluons),
+        "--target-seconds",
+        f"{target_seconds:.17g}",
+        "--samples",
+        str(WARM_SAMPLE_COUNT),
+        *(("--first-ready-only",) if first_ready_only else ()),
+        *(str(path) for path in event_paths),
+    )
+
+
+def _validate_candidate_probe_identity(
+    metrics: CandidateProbeMetrics | CandidateFirstReadyMetrics,
+    *,
+    lane: str,
+    total_gluons: int,
+    expected_helicities: Sequence[int],
+) -> None:
+    if metrics.execution_mode != lane:
+        raise AcceptanceError("candidate probe execution mode differs from its lane")
+    if metrics.process != process_name(total_gluons):
+        raise AcceptanceError("candidate probe process differs from its paired process")
+    if lane == "recurrence" and metrics.helicity_coverage_count != 1:
+        raise AcceptanceError(
+            "recurrence candidate did not preserve generation helicity specialization"
+        )
+    if lane == "on-the-fly" and metrics.helicity_coverage_count <= 1:
+        raise AcceptanceError(
+            "on-the-fly candidate did not preserve complete runtime selector coverage"
+        )
+    expected_helicity_id = "h:" + ",".join(
+        f"{helicity:+d}" for helicity in expected_helicities
+    )
+    if metrics.selected_helicity_id != expected_helicity_id:
+        raise AcceptanceError(
+            "candidate probe helicity differs from the generation-selected "
+            "known-nonzero helicity"
+        )
+
+
+def _run_candidate(
+    *,
+    lane: str,
+    total_gluons: int,
+    reference: _ReferenceRun,
+    probe: Path,
+    run_root: Path,
+    python: str,
+    environment: Mapping[str, str],
+    target_seconds: float,
+    timeout_seconds: float,
+    continuation_stage_limit_seconds: float | None = None,
+) -> CandidateMetrics:
+    candidate_root = run_root / "candidate" / lane / f"N{total_gluons}"
+    artifact = candidate_root / "artifact"
+    candidate_environment = dict(environment)
+    candidate_environment["PYAMPLICOL_CACHE_DIR"] = str(
+        candidate_root / "disabled-model-cache"
+    )
+    command = candidate_generation_command(
+        python=python,
+        lane=lane,
+        total_gluons=total_gluons,
+        helicities=reference.metrics.selected_helicity,
+        artifact=artifact,
+    )
+    lane_wall_started = time.perf_counter()
+    generation_started = lane_wall_started
+    generation = _run_watched(
+        command,
+        python=python,
+        environment=candidate_environment,
+        timeout_seconds=(
+            min(timeout_seconds, continuation_stage_limit_seconds)
+            if continuation_stage_limit_seconds is not None
+            else timeout_seconds
+        ),
+        log_path=candidate_root / "generation.json",
+    )
+    generation_seconds = (
+        time.perf_counter() - generation_started - generation.log_write_seconds
+    )
+    if not _positive_finite(generation_seconds):
+        raise AcceptanceError("candidate generation timing is not positive")
+    if (
+        continuation_stage_limit_seconds is not None
+        and generation_seconds >= continuation_stage_limit_seconds
+    ):
+        raise AcceptanceError(
+            "candidate generation did not remain below the 15 minute continuation cap"
+        )
+
+    cold_metrics: CandidateFirstReadyMetrics | None = None
+    if continuation_stage_limit_seconds is not None:
+        first_ready = _run_watched(
+            _candidate_probe_command(
+                probe=probe,
+                artifact=artifact,
+                total_gluons=total_gluons,
+                target_seconds=target_seconds,
+                event_paths=reference.event_paths,
+                first_ready_only=True,
+            ),
+            python=python,
+            environment=candidate_environment,
+            # The continuation contract limits the reported first warm-up,
+            # independently of artifact load.  Give the fresh process the
+            # enclosing lane deadline so a valid sub-15-minute warm-up is not
+            # killed merely because loading preceded it.
+            timeout_seconds=timeout_seconds,
+            log_path=candidate_root / "probe-first-ready.json",
+        )
+        cold_metrics = parse_candidate_first_ready_output(first_ready.stdout)
+        _validate_candidate_probe_identity(
+            cold_metrics,
+            lane=lane,
+            total_gluons=total_gluons,
+            expected_helicities=reference.metrics.selected_helicity,
+        )
+        if cold_metrics.first_warm_seconds >= continuation_stage_limit_seconds:
+            raise AcceptanceError(
+                "candidate first warm-up did not remain below the 15 minute "
+                "continuation cap"
+            )
+        if cold_metrics.max_rss_kib > int(MEMORY_LIMIT_GIB * 1024**2):
+            raise AcceptanceError(
+                "candidate first-ready process exceeded the 30 GiB RSS cap"
+            )
+
+    if continuation_stage_limit_seconds is None:
+        remaining_warm = timeout_seconds - (time.perf_counter() - lane_wall_started)
+        if remaining_warm <= 0.0:
+            raise AcceptanceError("candidate generation exhausted its lane timeout")
+    else:
+        # Optional feasibility has already been decided by the fresh cold-only
+        # process.  The warmed campaign gets an independent bounded window.
+        remaining_warm = timeout_seconds
+    completed = _run_watched(
+        _candidate_probe_command(
+            probe=probe,
+            artifact=artifact,
+            total_gluons=total_gluons,
+            target_seconds=target_seconds,
+            event_paths=reference.event_paths,
+            first_ready_only=False,
+        ),
+        python=python,
+        environment=candidate_environment,
+        timeout_seconds=remaining_warm,
+        log_path=(
+            candidate_root / "probe-warm.json"
+            if cold_metrics is not None
+            else candidate_root / "probe.json"
+        ),
+    )
+    probe_metrics = parse_candidate_probe_output(completed.stdout)
+    _validate_candidate_probe_identity(
+        probe_metrics,
+        lane=lane,
+        total_gluons=total_gluons,
+        expected_helicities=reference.metrics.selected_helicity,
+    )
+    load_seconds = (
+        cold_metrics.load_seconds
+        if cold_metrics is not None
+        else probe_metrics.load_seconds
+    )
+    first_warm_seconds = (
+        cold_metrics.first_warm_seconds
+        if cold_metrics is not None
+        else probe_metrics.first_warm_seconds
+    )
+    max_rss_kib = max(
+        probe_metrics.max_rss_kib,
+        cold_metrics.max_rss_kib if cold_metrics is not None else 0,
+    )
+    numerical_parity = compare_candidate_to_reference(
+        total_gluons=total_gluons,
+        candidate_values=probe_metrics.point_values,
+        reference_values=reference.metrics.matrix_elements,
+    )
+    return CandidateMetrics(
+        lane=lane,
+        total_gluons=total_gluons,
+        generator_seed=generator_seed(total_gluons),
+        generation_seconds=generation_seconds,
+        load_seconds=load_seconds,
+        first_warm_seconds=first_warm_seconds,
+        max_rss_kib=max_rss_kib,
+        probe=probe_metrics,
+        numerical_parity=numerical_parity,
+    )
+
+
+def _cpu_policy(platform_name: str) -> dict[str, object]:
+    thread_environment = {name: "1" for name in SINGLE_THREAD_ENVIRONMENT}
+    if platform_name == "darwin":
+        return {
+            "requested_cpu_cores": 1,
+            "method": "single-thread-environment",
+            "thread_environment": thread_environment,
+            "affinity_available": False,
+            "affinity_enforced": False,
+            "cpu": None,
+        }
+    if platform_name.startswith("linux"):
+        return {
+            "requested_cpu_cores": 1,
+            "method": "sched-affinity-and-single-thread-environment",
+            "thread_environment": thread_environment,
+            "affinity_available": bool(
+                hasattr(os, "sched_getaffinity") and hasattr(os, "sched_setaffinity")
+            ),
+            "affinity_enforced": False,
+            "cpu": None,
+        }
+    raise AcceptanceError(f"unsupported performance host platform {platform_name!r}")
+
+
+def _enforce_one_core(platform_name: str) -> dict[str, object]:
+    policy = _cpu_policy(platform_name)
+    if platform_name == "darwin":
+        return policy
+    if not policy["affinity_available"]:
+        raise AcceptanceError("Linux host does not expose sched affinity")
+    try:
+        allowed = sorted(os.sched_getaffinity(0))
+        if not allowed:
+            raise AcceptanceError("the process has no allowed CPU")
+        core = allowed[0]
+        os.sched_setaffinity(0, {core})
+    except OSError as error:
+        raise AcceptanceError("could not enforce Linux CPU affinity") from error
+    return policy | {"affinity_enforced": True, "cpu": core}
+
+
+def _plain_candidate(candidate: CandidateMetrics) -> dict[str, object]:
+    payload = asdict(candidate)
+    payload["cold_to_ready_seconds"] = candidate.cold_to_ready_seconds
+    return payload
+
+
+def _plain_reference(reference: ReferenceMetrics) -> dict[str, object]:
+    payload = asdict(reference)
+    payload["cold_to_ready_seconds"] = reference.cold_to_ready_seconds
+    payload["setup_to_ready_seconds"] = reference.setup_to_ready_seconds
+    return payload
+
+
+def _plain_gate(gate: GateResult) -> dict[str, object]:
+    return asdict(gate) | {"passes": gate.passes}
+
+
+def _gate_report(gates: Sequence[GateResult]) -> dict[str, object]:
+    """Serialize every completed gate and aggregate its acceptance result."""
+
+    return {
+        "gates": [_plain_gate(gate) for gate in gates],
+        # Infeasible optional rows are skipped before producing a GateResult.
+        # Every row that was measured is therefore acceptance-authoritative.
+        "passes": all(gate.passes for gate in gates),
+    }
+
+
+def _write_report(path: Path, payload: Mapping[str, object]) -> None:
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    temporary.parent.mkdir(parents=True, exist_ok=True)
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def _reference_git_output(*arguments: str) -> bytes:
+    try:
+        completed = subprocess.run(
+            ("git", "-C", str(REFERENCE_ROOT), *arguments),
+            check=False,
+            capture_output=True,
+        )
+    except OSError as error:
+        raise AcceptanceError(
+            f"cannot inspect FFT reference source: {error}"
+        ) from error
+    if completed.returncode != 0:
+        detail = os.fsdecode(completed.stderr).strip()
+        raise AcceptanceError(
+            "cannot inspect FFT reference source" + (f": {detail}" if detail else "")
+        )
+    return completed.stdout
+
+
+def _hash_identity_field(digest: Any, value: bytes) -> None:
+    digest.update(len(value).to_bytes(8, "big"))
+    digest.update(value)
+
+
+def _reference_source_identity() -> ReferenceSourceIdentity:
+    """Hash every tracked or nonignored reference input at the pinned HEAD."""
+
+    repository_root = Path(
+        os.fsdecode(_reference_git_output("rev-parse", "--show-toplevel")).strip()
+    ).resolve()
+    if repository_root != REFERENCE_ROOT.resolve():
+        raise AcceptanceError(
+            f"FFT reference source is not an independent repository: {REFERENCE_ROOT}"
+        )
+    revision = os.fsdecode(
+        _reference_git_output("rev-parse", "--verify", "HEAD")
+    ).strip()
+    if revision != REFERENCE_REVISION:
+        raise AcceptanceError(
+            "FFT reference source is at the wrong revision: "
+            f"expected {REFERENCE_REVISION}, found {revision}"
+        )
+
+    raw_paths = _reference_git_output(
+        "ls-files", "-z", "--cached", "--others", "--exclude-standard", "--"
+    )
+    paths = sorted(path for path in raw_paths.split(b"\0") if path)
+    if not paths:
+        raise AcceptanceError("FFT reference source contains no authenticated inputs")
+
+    digest = hashlib.sha256()
+    _hash_identity_field(digest, b"pyamplicol-fft-reference-content-v1")
+    for raw_path in paths:
+        relative = Path(os.fsdecode(raw_path))
+        if relative.is_absolute() or ".." in relative.parts:
+            raise AcceptanceError("FFT reference source reported an unsafe path")
+        path = REFERENCE_ROOT / relative
+        try:
+            before = path.lstat()
+            if stat.S_ISREG(before.st_mode):
+                kind = b"file+x" if before.st_mode & 0o111 else b"file"
+                content = path.read_bytes()
+            elif stat.S_ISLNK(before.st_mode):
+                kind = b"symlink"
+                content = os.fsencode(os.readlink(path))
+            else:
+                raise AcceptanceError(
+                    f"FFT reference input has unsupported file type: {relative}"
+                )
+            after = path.lstat()
+        except OSError as error:
+            raise AcceptanceError(
+                f"cannot authenticate FFT reference input {relative}: {error}"
+            ) from error
+        before_identity = (
+            before.st_mode,
+            before.st_size,
+            before.st_mtime_ns,
+            before.st_ino,
+        )
+        after_identity = (
+            after.st_mode,
+            after.st_size,
+            after.st_mtime_ns,
+            after.st_ino,
+        )
+        if before_identity != after_identity:
+            raise AcceptanceError(
+                f"FFT reference input changed while being authenticated: {relative}"
+            )
+        _hash_identity_field(digest, raw_path)
+        _hash_identity_field(digest, kind)
+        _hash_identity_field(digest, content)
+    return ReferenceSourceIdentity(revision, digest.hexdigest(), len(paths))
+
+
+def _require_reference_source_identity(
+    expected: ReferenceSourceIdentity | None = None,
+) -> ReferenceSourceIdentity:
+    current = _reference_source_identity()
+    if expected is not None and current != expected:
+        raise AcceptanceError(
+            "FFT reference source identity changed during the campaign: "
+            f"started at {expected.revision}/{expected.content_sha256}, now "
+            f"{current.revision}/{current.content_sha256}"
+        )
+    return current
+
+
+def _require_campaign_source_identity(
+    expected: ReportSourceIdentity | None = None,
+) -> ReportSourceIdentity:
+    """Authenticate a clean HEAD before measuring or retaining any result."""
+
+    try:
+        current = require_eligible_report_source(ROOT)
+    except ReportSourceIdentityError as error:
+        raise AcceptanceError(
+            f"FFT performance source is ineligible: {error}"
+        ) from error
+    if expected is not None and current != expected:
+        raise AcceptanceError(
+            "FFT performance source identity changed during the campaign: "
+            f"started at {expected.revision}/{expected.tree}, now "
+            f"{current.revision}/{current.tree}"
+        )
+    return current
+
+
+def dry_run_plan(
+    *,
+    run_id: str,
+    python: str,
+    include_optional: bool,
+    platform_name: str | None = None,
+) -> dict[str, object]:
+    host_platform = sys.platform if platform_name is None else platform_name
+    cpu_policy = _cpu_policy(host_platform)
+    multiplicities = (
+        (*MANDATORY_MULTIPLICITIES, *OPTIONAL_MULTIPLICITIES)
+        if include_optional
+        else MANDATORY_MULTIPLICITIES
+    )
+    return {
+        "kind": KIND,
+        "schema_version": SCHEMA_VERSION,
+        "dry_run": True,
+        "host_platform": host_platform,
+        "run_root": str(PERFORMANCE_ROOT / "runs" / run_id),
+        "reference_driver": str(REFERENCE_DRIVER),
+        "reference": {
+            "backend": REFERENCE_BACKEND,
+            "source_revision": REFERENCE_REVISION,
+            "source_identity": (
+                "pinned-head-plus-tracked-and-nonignored-content-sha256"
+            ),
+            "color_contraction": "fft",
+            "kinematics": "default-bg",
+            "clean_build_per_multiplicity": True,
+            "clean_build_scope": REFERENCE_CLEAN_BUILD_SCOPE,
+            "clean_build_program": REFERENCE_BUILD_PROGRAM,
+            "clean_build_timing": (
+                "sum of watched compiler/linker wall times for the "
+                "AmpliGluonTrace backend; RAMBO and helicity-proxy builds excluded"
+            ),
+            "initialization_and_first_pass_separate": True,
+            "formal_cold_to_ready_metric": (
+                "clean AmpliGluonTrace backend build plus initialization plus "
+                "first complete pass"
+            ),
+            "scaling_setup_to_ready_metric": (
+                "all setup through driver plus initialization plus first complete pass"
+            ),
+            "process_measurement": (
+                "darwin-getrusage-child-plus-watchdog"
+                if host_platform == "darwin"
+                else "reference-gnu-time-timeout-prlimit-plus-watchdog"
+            ),
+            "rss_marker": DARWIN_RSS_MARKER,
+            "rss_metric": (
+                "fresh evaluator-process peak RSS from the reference driver; "
+                "compiler and wrapper RSS are excluded from the formal ratio"
+            ),
+            "memory_guard_metric": (
+                "max(process-tree RSS, Darwin physical footprint); enforcement only"
+            ),
+        },
+        "candidate_probe_source": str(PROBE_SOURCE),
+        "multiplicities": [
+            {
+                "total_gluons": total,
+                "generator_seed": generator_seed(total),
+                "required": total in MANDATORY_MULTIPLICITIES,
+                "point_count": POINT_COUNT,
+                "candidate_lanes": list(LANES if total <= 9 else ("global-winner",)),
+                "selected_helicity": "reference-proxy-selected-nonzero",
+            }
+            for total in multiplicities
+        ],
+        "measurement": {
+            "cpu_cores": 1,
+            "batch_size": 1,
+            "calibration_seconds_minimum": MINIMUM_CALIBRATION_SECONDS,
+            "calibration_scope": "representative-point-1-only",
+            "candidate_timer_source": "process-cpu-time",
+            "warm_batch_reduction": "point-1-cell-direct",
+            "timed_event_cells_per_batch": 1,
+            "warm_samples": WARM_SAMPLE_COUNT,
+            "warm_excludes_first_call": True,
+            "memory_limit_gib": MEMORY_LIMIT_GIB,
+            "fresh_process_same_os_rss": True,
+            "model_cache": "disabled-per-lane-and-multiplicity",
+            "mandatory_lane_order": list(LANES),
+            "optional_cold_and_warm_processes_separate": True,
+            "cpu_policy": cpu_policy,
+        },
+        "helicity_policy": {
+            "recurrence": "generation-specialized-known-nonzero",
+            "on-the-fly": "complete-runtime-selector-fixed-helicity-query",
+        },
+        "numerical_parity": {
+            "reference_values": "ordered-10-AmpliGluonTrace-matrix-elements",
+            "candidate_values": (
+                "recurrence-first-pass-all-10;"
+                "otf-first-pass-points-2-10-plus-point-1-calibration"
+            ),
+            "candidate_runtime_parameter": "normalization.alpha_s_me_check",
+            "candidate_runtime_parameter_value": UNIT_COUPLING_ALPHA_S,
+            "candidate_to_reference_scale": "256*factorial(N-2)",
+            "relative_error_scale": "max(abs(candidate),abs(reference))",
+            "relative_tolerance": NUMERICAL_RELATIVE_TOLERANCE,
+            "failure_is_fatal": True,
+            "extra_evaluations": 0,
+        },
+        "global_lane_policy": (
+            "recurrence and on-the-fly are eligible under their respective "
+            "helicity workloads; the fastest lane passing every mandatory gate "
+            "supplies every reported metric and optional continuation"
+        ),
+        "thresholds": {
+            "warm_ratio_maximum": WARM_RATIO_LIMIT,
+            "rss_ratio_maximum": RSS_RATIO_LIMIT,
+            "cold_to_ready_ratio_maximum": COLD_RATIO_LIMIT,
+            "optional_generation_seconds_maximum_exclusive": (
+                OPTIONAL_COLD_LIMIT_SECONDS
+            ),
+            "optional_first_warm_seconds_maximum_exclusive": (
+                OPTIONAL_COLD_LIMIT_SECONDS
+            ),
+            "optional_continuation_deadlines_are_independent": True,
+        },
+        "candidate_generation_template": list(
+            candidate_generation_command(
+                python=python,
+                lane="recurrence",
+                total_gluons=4,
+                helicities=(1, 1, 1, 1),
+                artifact=PERFORMANCE_ROOT
+                / "runs"
+                / run_id
+                / "candidate"
+                / "LANE"
+                / "N",
+            )
+        ),
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--include-optional", action="store_true")
+    parser.add_argument("--run-id", default="manual")
+    parser.add_argument("--python", default=sys.executable)
+    parser.add_argument("--cxx", default=os.environ.get("CXX", "c++"))
+    parser.add_argument("--fc", default=os.environ.get("FC", "gfortran"))
+    parser.add_argument(
+        "--reference-fft-root",
+        type=Path,
+        default=DEFAULT_REFERENCE_ROOT,
+        help=(
+            "pinned AllGluonsMultipletFFT checkout used by Reference FFT "
+            "(default path is populated by "
+            "dev-install --with-reference-fft)"
+        ),
+    )
+    parser.add_argument(
+        "--target-seconds",
+        type=float,
+        default=MINIMUM_CALIBRATION_SECONDS,
+    )
+    return parser
+
+
+def _validate_arguments(arguments: argparse.Namespace) -> None:
+    if _RUN_ID.fullmatch(arguments.run_id) is None or arguments.run_id in {".", ".."}:
+        raise AcceptanceError("--run-id is not a safe workspace-local name")
+    if (
+        not math.isfinite(arguments.target_seconds)
+        or arguments.target_seconds < MINIMUM_CALIBRATION_SECONDS
+    ):
+        raise AcceptanceError("--target-seconds must be at least 0.25")
+    if not arguments.python or not arguments.cxx or not arguments.fc:
+        raise AcceptanceError("compiler and Python commands must be nonempty")
+
+
+def _campaign(arguments: argparse.Namespace) -> dict[str, object]:
+    source_identity = _require_campaign_source_identity()
+    reference_source_identity = _require_reference_source_identity()
+    run_root = PERFORMANCE_ROOT / "runs" / arguments.run_id
+    _create_workspace_directories(run_root)
+    environment = _workspace_environment(arguments.python)
+    os.environ.update(environment)
+    cpu_policy = _enforce_one_core(sys.platform)
+    probe, sdk_info = _build_probe(
+        run_root=run_root,
+        python=arguments.python,
+        cxx=arguments.cxx,
+        environment=environment,
+    )
+    reference_module = _load_reference_module()
+    references: dict[int, ReferenceMetrics] = {}
+    candidates: dict[str, dict[int, CandidateMetrics]] = {lane: {} for lane in LANES}
+    optional_status: dict[str, object] = {}
+    report_path = run_root / "report.json"
+    execution_policy = dry_run_plan(
+        run_id=arguments.run_id,
+        python=arguments.python,
+        include_optional=arguments.include_optional,
+    )
+    execution_policy["dry_run"] = False
+
+    def partial(status: str) -> dict[str, object]:
+        payload: dict[str, object] = {
+            "kind": KIND,
+            "schema_version": SCHEMA_VERSION,
+            "dry_run": False,
+            "status": status,
+            "terminal": status != "running",
+            "source_identity": source_identity.provenance(),
+            "reference_source_identity": reference_source_identity.provenance(),
+            "policy": execution_policy,
+            "environment": {
+                "platform": sys.platform,
+                "threads": 1,
+                "cpu_policy": cpu_policy,
+                "sdk_target": sdk_info["target"],
+                "sdk_package_version": sdk_info["package_version"],
+            },
+            "reference": {
+                str(total): _plain_reference(record)
+                for total, record in sorted(references.items())
+            },
+            "candidates": {
+                lane: {
+                    str(total): _plain_candidate(record)
+                    for total, record in sorted(records.items())
+                }
+                for lane, records in candidates.items()
+            },
+            "optional": optional_status,
+        }
+        return payload
+
+    def require_numerical_parity(candidate: CandidateMetrics) -> None:
+        evidence = candidate.numerical_parity
+        if evidence.passes:
+            return
+        failed = partial("failed-numerical-parity")
+        failed.update(
+            {
+                "passes": False,
+                "failure": {
+                    "kind": "numerical-parity",
+                    "lane": candidate.lane,
+                    "total_gluons": candidate.total_gluons,
+                    "maximum_relative_error": evidence.maximum_relative_error,
+                    "relative_tolerance": evidence.relative_tolerance,
+                },
+            }
+        )
+        _write_report(report_path, failed)
+        raise NumericalParityError(
+            "candidate/reference matrix-element mismatch for "
+            f"{candidate.lane} N={candidate.total_gluons} at point "
+            f"{evidence.maximum_relative_error_point}: relative error "
+            f"{evidence.maximum_relative_error:.17g} exceeds "
+            f"{evidence.relative_tolerance:.17g}"
+        )
+
+    completed_mandatory: list[int] = []
+    for total_gluons in MANDATORY_MULTIPLICITIES:
+        reference = _run_reference(
+            reference=reference_module,
+            total_gluons=total_gluons,
+            run_root=run_root,
+            python=arguments.python,
+            environment=environment,
+            fc=arguments.fc,
+            target_seconds=arguments.target_seconds,
+            timeout_seconds=MANDATORY_LANE_TIMEOUT_SECONDS,
+        )
+        references[total_gluons] = reference.metrics
+        for lane in LANES:
+            candidate = _run_candidate(
+                lane=lane,
+                total_gluons=total_gluons,
+                reference=reference,
+                probe=probe,
+                run_root=run_root,
+                python=arguments.python,
+                environment=environment,
+                target_seconds=arguments.target_seconds,
+                timeout_seconds=MANDATORY_LANE_TIMEOUT_SECONDS,
+            )
+            candidates[lane][total_gluons] = candidate
+            require_numerical_parity(candidate)
+        completed_mandatory.append(total_gluons)
+        viability = _observed_mandatory_gate_viability(
+            references,
+            candidates,
+            multiplicities=completed_mandatory,
+        )
+        if not viability["viable_lanes"]:
+            failed = partial("failed-performance-gates")
+            failed.update(
+                {
+                    "passes": False,
+                    "failure": {
+                        "kind": "no-global-lane-remains",
+                        "message": (
+                            "no eligible lane can satisfy every completed "
+                            "mandatory warm-runtime, RSS, cold-to-ready, and "
+                            "numerical gate"
+                        ),
+                    },
+                    "observed_gate_viability": viability,
+                }
+            )
+            _write_report(report_path, failed)
+            return failed
+        running = partial("running")
+        running["observed_gate_viability"] = viability
+        _write_report(report_path, running)
+
+    winner = select_global_lane(references, candidates)
+    mandatory_gates = evaluate_gates(winner, references, candidates)
+    optional_gates: tuple[GateResult, ...] = ()
+    if arguments.include_optional:
+        optional_totals: list[int] = []
+        for total_gluons in OPTIONAL_MULTIPLICITIES:
+            try:
+                reference = _run_reference(
+                    reference=reference_module,
+                    total_gluons=total_gluons,
+                    run_root=run_root,
+                    python=arguments.python,
+                    environment=environment,
+                    fc=arguments.fc,
+                    target_seconds=arguments.target_seconds,
+                    timeout_seconds=OPTIONAL_COLD_LIMIT_SECONDS,
+                )
+                candidate = _run_candidate(
+                    lane=winner,
+                    total_gluons=total_gluons,
+                    reference=reference,
+                    probe=probe,
+                    run_root=run_root,
+                    python=arguments.python,
+                    environment=environment,
+                    target_seconds=arguments.target_seconds,
+                    timeout_seconds=MANDATORY_LANE_TIMEOUT_SECONDS,
+                    continuation_stage_limit_seconds=OPTIONAL_COLD_LIMIT_SECONDS,
+                )
+                if not candidate.numerical_parity.passes:
+                    references[total_gluons] = reference.metrics
+                    candidates[winner][total_gluons] = candidate
+                    optional_status[str(total_gluons)] = {
+                        "status": "failed-numerical-parity"
+                    }
+                    require_numerical_parity(candidate)
+                if not optional_candidate_is_feasible(candidate):
+                    optional_status[str(total_gluons)] = {
+                        "status": "skipped",
+                        "reason": "candidate exceeded the 15 minute or 30 GiB cap",
+                    }
+                    break
+                references[total_gluons] = reference.metrics
+                candidates[winner][total_gluons] = candidate
+                optional_totals.append(total_gluons)
+                optional_status[str(total_gluons)] = {"status": "measured"}
+                _write_report(report_path, partial("running"))
+            except NumericalParityError:
+                raise
+            except AcceptanceError as error:
+                optional_status[str(total_gluons)] = {
+                    "status": "skipped",
+                    "reason": str(error),
+                }
+                break
+        optional_gates = evaluate_gates(
+            winner,
+            references,
+            candidates,
+            multiplicities=optional_totals,
+        )
+
+    gates = (*mandatory_gates, *optional_gates)
+    final = partial("complete")
+    final.update(
+        {
+            "global_winning_lane": winner,
+            "lane_eligibility": lane_eligibility(candidates),
+            "optional": optional_status,
+        }
+    )
+    final.update(_gate_report(gates))
+    _write_report(report_path, final)
+    return final
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    try:
+        arguments = _parser().parse_args(argv)
+        configure_reference_root(arguments.reference_fft_root)
+        _validate_arguments(arguments)
+        if arguments.dry_run:
+            print(
+                json.dumps(
+                    dry_run_plan(
+                        run_id=arguments.run_id,
+                        python=arguments.python,
+                        include_optional=arguments.include_optional,
+                    ),
+                    indent=2,
+                    sort_keys=True,
+                )
+            )
+            return 0
+        result = _campaign(arguments)
+        print(json.dumps(result, indent=2, sort_keys=True))
+        return 0 if result["passes"] is True else 1
+    except (AcceptanceError, OSError, ValueError) as error:
+        print(f"fft performance acceptance: {error}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/fft_madgraph_selected_runtime.py b/pyamplicol/tools/developer/fft_madgraph_selected_runtime.py
new file mode 100755
index 0000000000..d9776acac2
--- /dev/null
+++ b/pyamplicol/tools/developer/fft_madgraph_selected_runtime.py
@@ -0,0 +1,3200 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Generate and benchmark MadGraph standalone FullColor processes.
+
+The campaign is deliberately process-by-process and resumable. For each
+selected process family and final-state multiplicity ``n>=2`` it asks the
+user's MadGraph installation to generate an ordinary, helicity-general
+standalone process under configured per-cell wall-time and process-tree memory
+guards. A generated check program then calls the
+direct ``MATRIX(P,NHEL,IC)`` kernel at ten authenticated phase-space points
+used by the pyAmpliCol campaign.  The default workload is one fixed selected
+helicity.  ``--compare-helicity-sums`` instead calls the generated
+``SMATRIX(P,ANS)`` with ``USERHEL=-1``.  MadGraph owns the complete helicity
+sum, its IDEN normalization, and the warmed ``GOODHEL`` pruning; summed runs
+never reuse fixed-helicity measurements.
+
+The final-plot protocol measures MadGraph only through family-specific
+multiplicity limits.  Requested higher multiplicities are retained as explicit
+not-applicable cells without loading their event data or invoking MadGraph.
+
+Each measured overlay cell contains cold-to-ready wall time, a conservative
+peak RSS across generation/build/runtime, and the median of ten warm point-01
+CPU-time samples. A resource/time failure is the honest frontier for that
+process family; higher multiplicities are recorded as skipped. Completed cells
+are checkpointed before campaign-owned generated intermediates are pruned, so
+interrupted campaigns resume cheaply.
+"""
+
+from __future__ import annotations
+
+import argparse
+import fcntl
+import hashlib
+import json
+import math
+import os
+import platform
+import re
+import shutil
+import signal
+import statistics
+import subprocess
+import sys
+import tempfile
+import time
+from collections import Counter
+from collections.abc import Mapping, Sequence
+from contextlib import suppress
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+WATCHDOG = ROOT / "tools" / "ci" / "memory_watchdog.py"
+
+KIND = "pyamplicol-fullcolor-selected-scalar-runtime-series-overlay"
+PROGRESS_KIND = "pyamplicol-fullcolor-selected-scalar-runtime-series-progress"
+SOURCE_KIND = "pyamplicol-fullcolor-selected-scalar-composite"
+SCALING_STUDY_KIND = "pyamplicol-fullcolor-fft-scaling-study"
+SCHEMA_VERSION = 1
+MEASUREMENT_HOST_SCHEMA_VERSION = 1
+CHECKPOINT_PROTOCOL = {
+    "kind": "pyamplicol-selected-madgraph-runtime-cell",
+    "schema_version": 1,
+}
+LEGACY_CHECKPOINT_PRODUCER_KEY = "producer_sha256"
+CHECKPOINT_RESOURCE_LIMIT_KEYS = frozenset(
+    {"generation_timeout_seconds", "memory_limit_gib"}
+)
+CHECKPOINT_TIMING_POLICY_KEYS = frozenset({"target_seconds", "warm_sample_count"})
+MEASUREMENT_HOST_KEYS = frozenset(
+    {"schema_version", "node_sha256", "system", "machine", "python"}
+)
+MODE = "madgraph-standalone"
+FIXED_LABEL = "MadGraph standalone (fixed h)"
+SUM_LABEL = "MadGraph standalone (helicity sum)"
+LABEL = FIXED_LABEL
+FAMILIES = ("gg", "ddbar")
+FINAL_MULTIPLICITIES = tuple(range(2, 10))
+MAX_PROTOCOL_MEASURED_MULTIPLICITY = 6
+FAMILY_MAX_PROTOCOL_MEASURED_MULTIPLICITY = {"gg": 5, "ddbar": 6}
+POINT_COUNT = 10
+WARM_SAMPLE_COUNT = 1
+TIMING_DRIVER_BATCH_COUNT = WARM_SAMPLE_COUNT + 1
+TARGET_SECONDS = 3.0 * 60.0
+RELATIVE_TOLERANCE = 1.0e-10
+MAX_GENERATION_SECONDS = 3600.0
+DEFAULT_GENERATION_TIMEOUT_SECONDS = 3595.0
+MAX_MEMORY_GIB = 30.0
+SOURCE_MODE = {"gg": "reference-fft", "ddbar": "recurrence-fft"}
+SUM_SOURCE_MODE = {"gg": "recurrence-fft", "ddbar": "recurrence-fft"}
+TIMEOUT_EXIT_CODE = 124
+TIMEOUT_MARKER = "madgraph-benchmark: bounded command reached its time limit"
+CACHE_LOCK_ROOT = (
+    Path(tempfile.gettempdir())
+    / f"pyamplicol-{os.getuid()}"
+    / "madgraph-cache-locks"
+)
+RESOURCE_FRONTIER_CATEGORIES = frozenset(
+    {
+        "dependency-unavailable",
+        "generation-memory-limit",
+        "generation-time-limit",
+        "memory-limit",
+        "resource-unavailable",
+        "runtime-time-limit",
+        "structural-memory-limit",
+        "structural-unavailable",
+    }
+)
+
+
+class SelectedMadGraphError(RuntimeError):
+    """The selected-event MadGraph campaign could not be authenticated."""
+
+
+class ResourceFrontierError(SelectedMadGraphError):
+    """A measured resource limit establishes an honest availability frontier."""
+
+    def __init__(self, category: str, reason: str) -> None:
+        if category not in RESOURCE_FRONTIER_CATEGORIES:
+            raise ValueError(f"non-resource frontier category: {category}")
+        super().__init__(reason)
+        self.category = category
+
+
+@dataclass(frozen=True, slots=True)
+class EventData:
+    path: Path
+    sha256: str
+    final_gluons: int
+    strong_coupling: float
+    helicity: tuple[int, ...]
+    momenta: tuple[tuple[float, float, float, float], ...]
+
+
+@dataclass(frozen=True, slots=True)
+class SelectedCell:
+    family: str
+    n: int
+    total_external: int
+    process: str
+    helicity: tuple[int, ...]
+    events: tuple[EventData, ...]
+    reference_point_values: tuple[float, ...]
+    source_mode: str
+    helicity_workload: str
+    source_alpha_s: float
+
+
+@dataclass(frozen=True, slots=True)
+class SourceUnavailable:
+    reason: str
+    censors_higher_multiplicities: bool
+
+
+@dataclass(frozen=True, slots=True)
+class SourceSelection:
+    path: Path
+    sha256: str
+    alpha_s: float
+    cells: Mapping[str, Mapping[int, SelectedCell]]
+    unavailable: Mapping[str, Mapping[int, SourceUnavailable]]
+    helicity_workload: str
+    measurement_host: Mapping[str, Any] | None
+
+
+@dataclass(frozen=True, slots=True)
+class DriverResult:
+    total_external: int
+    initialization_seconds: float
+    first_pass_seconds: float
+    point_values: tuple[float, ...]
+    cell_seconds: tuple[tuple[float, ...], ...]
+    checksum: float
+    evaluations_per_sweep: int
+    helicity_coverage_count: int
+
+
+def _workload_label(helicity_workload: str) -> str:
+    if helicity_workload == "fixed":
+        return FIXED_LABEL
+    if helicity_workload == "sum":
+        return SUM_LABEL
+    raise SelectedMadGraphError(
+        f"unsupported helicity workload {helicity_workload!r}"
+    )
+
+
+def source_mode(family: str, helicity_workload: str) -> str:
+    _workload_label(helicity_workload)
+    modes = SUM_SOURCE_MODE if helicity_workload == "sum" else SOURCE_MODE
+    try:
+        return modes[family]
+    except KeyError as error:
+        raise SelectedMadGraphError(f"unsupported family {family!r}") from error
+
+
+def _declared_helicity_workload(
+    policy: Mapping[str, Any], *, legacy_default: str = "fixed"
+) -> str:
+    measurement = _mapping(
+        policy.get("measurement", policy), context="helicity workload policy"
+    )
+    declared = measurement.get("helicity_workload")
+    warm_sum = measurement.get("warm_helicity_sum")
+    warm_fixed = measurement.get("warm_fixed_helicity")
+    markers: set[str] = set()
+    if declared is not None:
+        markers.add(str(declared))
+    if warm_sum is True:
+        markers.add("sum")
+    if warm_fixed is True:
+        markers.add("fixed")
+    if warm_sum is False and warm_fixed is False:
+        raise SelectedMadGraphError("helicity workload policy disables both workloads")
+    if len(markers) > 1 or any(value not in {"fixed", "sum"} for value in markers):
+        raise SelectedMadGraphError("helicity workload policy is contradictory")
+    return next(iter(markers), legacy_default)
+
+
+def process_expression(family: str, n: int) -> str:
+    if family not in FAMILIES:
+        raise SelectedMadGraphError(f"unsupported process family {family!r}")
+    if isinstance(n, bool) or not isinstance(n, int) or n < 2:
+        raise SelectedMadGraphError(f"unsupported final-state multiplicity {n}")
+    extra = " ".join("g" for _ in range(n - 2))
+    base = "g g > g g" if family == "gg" else "d d~ > d d~"
+    return base + (f" {extra}" if extra else "")
+
+
+def protocol_measured_multiplicity_limit(family: str) -> int:
+    if family not in FAMILIES:
+        raise SelectedMadGraphError(f"unsupported process family {family!r}")
+    return FAMILY_MAX_PROTOCOL_MEASURED_MULTIPLICITY.get(
+        family, MAX_PROTOCOL_MEASURED_MULTIPLICITY
+    )
+
+
+def protocol_measures_multiplicity(family: str, n: int) -> bool:
+    if isinstance(n, bool) or not isinstance(n, int) or n < 2:
+        raise SelectedMadGraphError(f"unsupported final-state multiplicity {n}")
+    return n <= protocol_measured_multiplicity_limit(family)
+
+
+def protocol_measured_multiplicity_limits() -> dict[str, int]:
+    return {
+        family: protocol_measured_multiplicity_limit(family)
+        for family in FAMILIES
+    }
+
+
+def _mapping(value: object, *, context: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise SelectedMadGraphError(f"{context} must be an object")
+    return value
+
+
+def validate_measurement_host(value: object, *, context: str) -> dict[str, Any]:
+    """Validate the stable, non-identifying host identity used by a campaign."""
+
+    host = _mapping(value, context=context)
+    if set(host) != MEASUREMENT_HOST_KEYS:
+        raise SelectedMadGraphError(f"{context} has the wrong fields")
+    schema_version = host.get("schema_version")
+    if (
+        isinstance(schema_version, bool)
+        or schema_version != MEASUREMENT_HOST_SCHEMA_VERSION
+    ):
+        raise SelectedMadGraphError(f"{context} has the wrong schema")
+    for key in ("system", "machine", "python"):
+        if not isinstance(host.get(key), str) or not host[key].strip():
+            raise SelectedMadGraphError(f"{context}.{key} must be nonempty")
+    node_sha256 = host.get("node_sha256")
+    if (
+        not isinstance(node_sha256, str)
+        or re.fullmatch(r"[0-9a-f]{64}", node_sha256) is None
+    ):
+        raise SelectedMadGraphError(
+            f"{context}.node_sha256 must be a lowercase SHA-256"
+        )
+    return {
+        "schema_version": MEASUREMENT_HOST_SCHEMA_VERSION,
+        "node_sha256": node_sha256,
+        "system": str(host["system"]),
+        "machine": str(host["machine"]),
+        "python": str(host["python"]),
+    }
+
+
+def measurement_host_identity() -> dict[str, Any]:
+    """Return the identity that binds performance measurements to one host."""
+
+    node = platform.node().strip()
+    if not node:
+        raise SelectedMadGraphError("cannot determine the measurement host name")
+    return validate_measurement_host(
+        {
+            "schema_version": MEASUREMENT_HOST_SCHEMA_VERSION,
+            "node_sha256": hashlib.sha256(node.encode("utf-8")).hexdigest(),
+            "system": platform.system(),
+            "machine": platform.machine(),
+            "python": platform.python_version(),
+        },
+        context="local measurement host",
+    )
+
+
+def _finite_number(value: object, *, context: str, nonnegative: bool = False) -> float:
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        raise SelectedMadGraphError(f"{context} must be a finite number")
+    result = float(value)
+    if not math.isfinite(result) or (nonnegative and result < 0.0):
+        raise SelectedMadGraphError(f"{context} must be a finite number")
+    return result
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _display_path(path: Path) -> str:
+    resolved = path.expanduser().resolve(strict=False)
+    try:
+        return str(resolved.relative_to(ROOT))
+    except ValueError:
+        return str(resolved)
+
+
+def _event_path(raw_path: object, *, context: str) -> Path:
+    if not isinstance(raw_path, str) or not raw_path:
+        raise SelectedMadGraphError(f"{context} must be a nonempty path string")
+    path = Path(raw_path).expanduser()
+    if not path.is_absolute():
+        path = ROOT / path
+    path = path.resolve(strict=False)
+    if not path.is_file() and "IMPLEMENTATION_DOCS" in path.parts:
+        marker = path.parts.index("IMPLEMENTATION_DOCS")
+        rebased = ROOT.joinpath(*path.parts[marker:]).resolve(strict=False)
+        if rebased.is_file():
+            path = rebased
+    if not path.is_file():
+        raise SelectedMadGraphError(f"selected event does not exist: {path}")
+    return path
+
+
+def _single_block(
+    lines: Sequence[str], begin_marker: str, end_marker: str, *, path: Path
+) -> list[str]:
+    if lines.count(begin_marker) != 1 or lines.count(end_marker) != 1:
+        raise SelectedMadGraphError(
+            f"{path} must contain one {begin_marker}/{end_marker} block"
+        )
+    begin = lines.index(begin_marker)
+    end = lines.index(end_marker)
+    if end <= begin:
+        raise SelectedMadGraphError(f"{path} has a malformed {begin_marker} block")
+    return list(lines[begin + 1 : end])
+
+
+def _read_event(
+    path: Path, *, expected_n: int, default_strong_coupling: float = 1.0
+) -> EventData:
+    try:
+        raw = path.read_bytes()
+        lines = [
+            line.strip() for line in raw.decode("utf-8").splitlines() if line.strip()
+        ]
+    except (OSError, UnicodeDecodeError) as error:
+        raise SelectedMadGraphError(
+            f"cannot read selected event {path}: {error}"
+        ) from error
+    if not lines or lines[0] not in {
+        "AMPLIGLUON_EVENT_V1",
+        "PYAMPLICOL_SCALING_EVENT_V1",
+    }:
+        raise SelectedMadGraphError(f"{path} has an unsupported event format")
+
+    strong_coupling = default_strong_coupling
+    if lines[0] == "AMPLIGLUON_EVENT_V1":
+        final_rows = [
+            line.split() for line in lines if line.startswith("FINAL_GLUONS ")
+        ]
+        coupling_rows = [
+            line.split() for line in lines if line.startswith("STRONG_COUPLING ")
+        ]
+        if len(final_rows) != 1 or final_rows[0] != [
+            "FINAL_GLUONS",
+            str(expected_n),
+        ]:
+            raise SelectedMadGraphError(f"{path} has the wrong FINAL_GLUONS")
+        if len(coupling_rows) != 1 or len(coupling_rows[0]) != 2:
+            raise SelectedMadGraphError(f"{path} has an invalid STRONG_COUPLING")
+        try:
+            strong_coupling = float(coupling_rows[0][1])
+        except ValueError as error:
+            raise SelectedMadGraphError(
+                f"{path} has an invalid STRONG_COUPLING"
+            ) from error
+    if not math.isfinite(strong_coupling) or strong_coupling <= 0.0:
+        raise SelectedMadGraphError(f"{path} has an invalid STRONG_COUPLING")
+
+    momentum_rows = _single_block(lines, "BEGIN_MOMENTA", "END_MOMENTA", path=path)
+    if len(momentum_rows) != expected_n + 2:
+        raise SelectedMadGraphError(f"{path} has the wrong number of momenta")
+    try:
+        momenta = tuple(
+            tuple(float(value) for value in row.split()) for row in momentum_rows
+        )
+    except ValueError as error:
+        raise SelectedMadGraphError(f"{path} has invalid momentum values") from error
+    if any(
+        len(momentum) != 4 or any(not math.isfinite(value) for value in momentum)
+        for momentum in momenta
+    ):
+        raise SelectedMadGraphError(f"{path} has invalid momentum rows")
+
+    count_rows = [line.split() for line in lines if line.startswith("NHELICITIES ")]
+    if len(count_rows) != 1 or count_rows[0] != ["NHELICITIES", "1"]:
+        raise SelectedMadGraphError(f"{path} must contain exactly one helicity")
+    helicity_rows = _single_block(
+        lines, "BEGIN_HELICITIES", "END_HELICITIES", path=path
+    )
+    if len(helicity_rows) != 1:
+        raise SelectedMadGraphError(f"{path} must contain one helicity row")
+    try:
+        helicity = tuple(int(value) for value in helicity_rows[0].split())
+    except ValueError as error:
+        raise SelectedMadGraphError(f"{path} has an invalid helicity row") from error
+    if len(helicity) != expected_n + 2 or any(
+        value not in (-1, 1) for value in helicity
+    ):
+        raise SelectedMadGraphError(f"{path} has an invalid helicity row")
+    return EventData(
+        path=path,
+        sha256=hashlib.sha256(raw).hexdigest(),
+        final_gluons=expected_n,
+        strong_coupling=strong_coupling,
+        helicity=helicity,
+        momenta=momenta,  # type: ignore[arg-type]
+    )
+
+
+def load_source_selection(
+    path: Path,
+    *,
+    multiplicities: Sequence[int] | Mapping[str, Sequence[int]] = FINAL_MULTIPLICITIES,
+    families: Sequence[str] = FAMILIES,
+    helicity_workload: str = "fixed",
+) -> SourceSelection:
+    _workload_label(helicity_workload)
+    if not families or any(family not in FAMILIES for family in families):
+        raise SelectedMadGraphError("source selection families are unsupported")
+    path = path.expanduser().resolve(strict=False)
+    try:
+        raw = path.read_bytes()
+        payload = json.loads(raw)
+    except (OSError, json.JSONDecodeError) as error:
+        raise SelectedMadGraphError(
+            f"cannot read source report {path}: {error}"
+        ) from error
+    if not isinstance(payload, dict) or payload.get("kind") not in {
+        SOURCE_KIND,
+        SCALING_STUDY_KIND,
+    }:
+        raise SelectedMadGraphError("source report has the wrong kind")
+    raw_measurement_host = payload.get("measurement_host")
+    measurement_host = (
+        validate_measurement_host(
+            raw_measurement_host, context="source report measurement_host"
+        )
+        if raw_measurement_host is not None
+        else None
+    )
+    policy = _mapping(payload.get("policy"), context="source report policy")
+    observed_workload = _declared_helicity_workload(policy)
+    if observed_workload != helicity_workload:
+        raise SelectedMadGraphError(
+            "source report helicity workload differs from the requested "
+            f"MadGraph workload: {observed_workload!r} != {helicity_workload!r}"
+        )
+    measurement = _mapping(
+        policy.get("measurement"), context="source report policy.measurement"
+    )
+    alpha_s = _finite_number(
+        measurement.get("alpha_s"),
+        context="source report policy.measurement.alpha_s",
+    )
+    if alpha_s <= 0.0:
+        raise SelectedMadGraphError("source report alpha_s must be positive")
+    default_strong_coupling = math.sqrt(4.0 * math.pi * alpha_s)
+    cells = _mapping(payload.get("cells"), context="source report cells")
+    selected: dict[str, dict[int, SelectedCell]] = {}
+    unavailable: dict[str, dict[int, SourceUnavailable]] = {}
+    selected_families = tuple(family for family in FAMILIES if family in set(families))
+    for family in selected_families:
+        mode = source_mode(family, helicity_workload)
+        raw_family = _mapping(
+            cells.get(family), context=f"source report cells.{family}"
+        )
+        raw_mode = _mapping(
+            raw_family.get(mode), context=f"source report cells.{family}.{mode}"
+        )
+        selected[family] = {}
+        unavailable[family] = {}
+        family_multiplicities = (
+            multiplicities.get(family, ())
+            if isinstance(multiplicities, Mapping)
+            else multiplicities
+        )
+        if isinstance(family_multiplicities, str):
+            raise SelectedMadGraphError(
+                "source selection multiplicities must be integer sequences"
+            )
+        for n in family_multiplicities:
+            context = f"source report cells.{family}.{mode}.{n}"
+            cell = _mapping(raw_mode.get(str(n)), context=context)
+            expected_process = process_expression(family, n)
+            for key, expected in (
+                ("family", family),
+                ("mode", mode),
+                ("n", n),
+                ("total_external", n + 2),
+                ("process", expected_process),
+            ):
+                if cell.get(key) != expected:
+                    raise SelectedMadGraphError(
+                        f"{context}.{key} has the wrong identity"
+                    )
+            if cell.get("status") != "measured":
+                if (
+                    cell.get("status") in {"failed", "skipped"}
+                    and isinstance(cell.get("failure_reason"), str)
+                    and cell["failure_reason"].strip()
+                ):
+                    unavailable[family][n] = SourceUnavailable(
+                        reason=str(cell["failure_reason"]),
+                        censors_higher_multiplicities=(
+                            cell.get("censors_higher_multiplicities") is True
+                        ),
+                    )
+                    continue
+                raise SelectedMadGraphError(
+                    f"{context}.status is not a measured or unavailable cell"
+                )
+            cell_workload = _declared_helicity_workload(cell)
+            if cell_workload != helicity_workload:
+                raise SelectedMadGraphError(
+                    f"{context} helicity workload differs from the source policy"
+                )
+            raw_helicity = cell.get("helicity")
+            if (
+                not isinstance(raw_helicity, Sequence)
+                or isinstance(raw_helicity, str)
+                or len(raw_helicity) != n + 2
+                or any(
+                    isinstance(value, bool)
+                    or not isinstance(value, int)
+                    or value not in (-1, 1)
+                    for value in raw_helicity
+                )
+            ):
+                raise SelectedMadGraphError(f"{context}.helicity is invalid")
+            helicity = tuple(int(value) for value in raw_helicity)
+            raw_paths = cell.get("event_paths")
+            if not isinstance(raw_paths, Sequence) or isinstance(raw_paths, str):
+                raise SelectedMadGraphError(f"{context}.event_paths is invalid")
+            paths = tuple(
+                _event_path(value, context=f"{context}.event_paths")
+                for value in raw_paths
+            )
+            if len(paths) != POINT_COUNT or len(set(paths)) != POINT_COUNT:
+                raise SelectedMadGraphError(
+                    f"{context}.event_paths must contain ten unique paths"
+                )
+            events = tuple(
+                _read_event(
+                    event,
+                    expected_n=n,
+                    default_strong_coupling=default_strong_coupling,
+                )
+                for event in paths
+            )
+            if len({event.sha256 for event in events}) != POINT_COUNT:
+                raise SelectedMadGraphError(
+                    f"{context}.event_paths must contain ten unique event payloads"
+                )
+            if any(event.helicity != helicity for event in events):
+                raise SelectedMadGraphError(f"{context} event helicities differ")
+            raw_points = cell.get("point_values")
+            if not isinstance(raw_points, Sequence) or isinstance(raw_points, str):
+                raise SelectedMadGraphError(f"{context}.point_values is invalid")
+            points = tuple(
+                _finite_number(
+                    value, context=f"{context}.point_values", nonnegative=True
+                )
+                for value in raw_points
+            )
+            if len(points) != POINT_COUNT or not any(value > 0.0 for value in points):
+                raise SelectedMadGraphError(
+                    f"{context}.point_values must contain ten nonzero data"
+                )
+            selected[family][n] = SelectedCell(
+                family=family,
+                n=n,
+                total_external=n + 2,
+                process=expected_process,
+                helicity=helicity,
+                events=events,
+                reference_point_values=points,
+                source_mode=mode,
+                helicity_workload=helicity_workload,
+                source_alpha_s=alpha_s,
+            )
+    return SourceSelection(
+        path=path,
+        sha256=hashlib.sha256(raw).hexdigest(),
+        alpha_s=alpha_s,
+        cells=selected,
+        unavailable=unavailable,
+        helicity_workload=helicity_workload,
+        measurement_host=measurement_host,
+    )
+
+
+def parse_driver_output(
+    output: str,
+    *,
+    batches: int,
+    expected_total_external: int,
+    expected_events: int,
+    helicity_workload: str = "fixed",
+    expected_helicity_coverage_count: int | None = None,
+) -> DriverResult:
+    _workload_label(helicity_workload)
+    scalar: dict[str, str] = {}
+    points: dict[int, float] = {}
+    cells: dict[tuple[int, int], float] = {}
+    allowed_scalars = {
+        "BACKEND",
+        "HELICITY_EVALUATOR",
+        "TOTAL_EXTERNAL",
+        "INITIALIZATION_SECONDS",
+        "FIRST_SAMPLE_PASS_SECONDS",
+        "EVALUATIONS_PER_SWEEP",
+        "HELICITY_COVERAGE_COUNT",
+        "CHECKSUM",
+    }
+    try:
+        for line in output.splitlines():
+            fields = line.split()
+            if not fields:
+                continue
+            key = fields[0]
+            if key == "MATRIX_ELEMENT":
+                if len(fields) != 4 or fields[2] != "1":
+                    raise SelectedMadGraphError("malformed MadGraph matrix-element row")
+                index = int(fields[1])
+                if index in points:
+                    raise SelectedMadGraphError("duplicate MadGraph matrix-element row")
+                points[index] = float(fields[3].replace("D", "E").replace("d", "e"))
+            elif key == "EVALUATION_CELL_SECONDS":
+                if len(fields) != 5 or fields[2:4] != ["1", "1"]:
+                    raise SelectedMadGraphError("malformed MadGraph timing-cell row")
+                index = (int(fields[1]), 1)
+                if index in cells:
+                    raise SelectedMadGraphError("duplicate MadGraph timing-cell row")
+                cells[index] = float(fields[4].replace("D", "E").replace("d", "e"))
+            elif key == "EVALUATION_SWEEP_SECONDS":
+                continue
+            elif key in allowed_scalars:
+                if len(fields) != 2 or key in scalar:
+                    raise SelectedMadGraphError(
+                        f"malformed or duplicate MadGraph {key}"
+                    )
+                scalar[key] = fields[1]
+            else:
+                raise SelectedMadGraphError(f"unexpected MadGraph output row: {line!r}")
+    except ValueError as error:
+        raise SelectedMadGraphError(
+            "invalid numeric value in MadGraph output"
+        ) from error
+    if set(scalar) != allowed_scalars:
+        raise SelectedMadGraphError("MadGraph output has incomplete scalar metadata")
+    expected_backend = (
+        "MadGraph5_aMCatNLOFixedHelicity"
+        if helicity_workload == "fixed"
+        else "MadGraph5_aMCatNLOHelicitySum"
+    )
+    expected_evaluator = (
+        "MATRIX_DIRECT_VECTOR"
+        if helicity_workload == "fixed"
+        else "SMATRIX_GENERATED_COMPLETE_HELICITY_SUM"
+    )
+    if scalar["BACKEND"] != expected_backend:
+        raise SelectedMadGraphError("unexpected MadGraph backend identity")
+    if scalar["HELICITY_EVALUATOR"] != expected_evaluator:
+        raise SelectedMadGraphError(
+            "MadGraph used the wrong workload-specific evaluator"
+        )
+    total_external = int(scalar["TOTAL_EXTERNAL"])
+    initialization = float(scalar["INITIALIZATION_SECONDS"].replace("D", "E"))
+    first_pass = float(scalar["FIRST_SAMPLE_PASS_SECONDS"].replace("D", "E"))
+    checksum = float(scalar["CHECKSUM"].replace("D", "E"))
+    expected_evaluations = 1
+    if helicity_workload == "sum":
+        if (
+            isinstance(expected_helicity_coverage_count, bool)
+            or not isinstance(expected_helicity_coverage_count, int)
+            or expected_helicity_coverage_count < 1
+        ):
+            raise SelectedMadGraphError(
+                "summed output validation requires generated NCOMB coverage"
+            )
+        expected_coverage = expected_helicity_coverage_count
+    else:
+        expected_coverage = 1
+    evaluations_per_sweep = int(scalar["EVALUATIONS_PER_SWEEP"])
+    helicity_coverage_count = int(scalar["HELICITY_COVERAGE_COUNT"])
+    if (
+        total_external != expected_total_external
+        or evaluations_per_sweep != expected_evaluations
+        or helicity_coverage_count != expected_coverage
+    ):
+        raise SelectedMadGraphError("MadGraph output has the wrong process dimensions")
+    if set(points) != set(range(1, expected_events + 1)):
+        raise SelectedMadGraphError(
+            "MadGraph output did not report every validation point"
+        )
+    if set(cells) != {(batch, 1) for batch in range(1, batches + 1)}:
+        raise SelectedMadGraphError("MadGraph output has incomplete timing cells")
+    values = (initialization, first_pass, checksum, *points.values(), *cells.values())
+    if any(not math.isfinite(value) or value < 0.0 for value in values):
+        raise SelectedMadGraphError("MadGraph output contains invalid numeric data")
+    if checksum <= 0.0:
+        raise SelectedMadGraphError("MadGraph checksum must be positive")
+    return DriverResult(
+        total_external=total_external,
+        initialization_seconds=initialization,
+        first_pass_seconds=first_pass,
+        point_values=tuple(points[index] for index in range(1, expected_events + 1)),
+        cell_seconds=tuple((cells[(batch, 1)],) for batch in range(1, batches + 1)),
+        checksum=checksum,
+        evaluations_per_sweep=evaluations_per_sweep,
+        helicity_coverage_count=helicity_coverage_count,
+    )
+
+
+def _fortran_double(value: float) -> str:
+    return format(value, ".17e").replace("e", "D")
+
+
+def render_check_source(
+    selected: SelectedCell,
+    *,
+    summed_helicity_coverage_count: int | None = None,
+    target_seconds: float = TARGET_SECONDS,
+    warm_sample_count: int = WARM_SAMPLE_COUNT,
+) -> str:
+    """Render a check driver; the generated MATRIX remains helicity-general."""
+
+    n_external = selected.total_external
+    summed = selected.helicity_workload == "sum"
+    _workload_label(selected.helicity_workload)
+    backend_identity = (
+        "MadGraph5_aMCatNLOHelicitySum"
+        if summed
+        else "MadGraph5_aMCatNLOFixedHelicity"
+    )
+    evaluator_identity = (
+        "SMATRIX_GENERATED_COMPLETE_HELICITY_SUM"
+        if summed
+        else "MATRIX_DIRECT_VECTOR"
+    )
+    if summed:
+        if (
+            isinstance(summed_helicity_coverage_count, bool)
+            or not isinstance(summed_helicity_coverage_count, int)
+            or summed_helicity_coverage_count < 1
+        ):
+            raise SelectedMadGraphError(
+                "summed driver requires generated NCOMB helicity coverage"
+            )
+        helicity_coverage_count = summed_helicity_coverage_count
+    else:
+        helicity_coverage_count = 1
+    if (
+        isinstance(target_seconds, bool)
+        or not math.isfinite(target_seconds)
+        or target_seconds <= 0.0
+    ):
+        raise SelectedMadGraphError("target_seconds must be positive and finite")
+    if (
+        isinstance(warm_sample_count, bool)
+        or not isinstance(warm_sample_count, int)
+        or warm_sample_count < 1
+    ):
+        raise SelectedMadGraphError("warm_sample_count must be positive")
+    timing_driver_batch_count = warm_sample_count + 1
+    lines = [
+        "      PROGRAM DRIVER",
+        "      IMPLICIT NONE",
+        "      INTEGER NEXTERNAL,NEVENTS,NSAMPLES",
+        f"      PARAMETER (NEXTERNAL={n_external},NEVENTS={POINT_COUNT})",
+        f"      PARAMETER (NSAMPLES={timing_driver_batch_count})",
+        "      INTEGER E,B,R,NREP,CLOCK0,CLOCK1,CLOCKRATE",
+        "      INTEGER HEL(NEXTERNAL),IC(NEXTERNAL)",
+        "      DOUBLE PRECISION P(0:3,NEXTERNAL,NEVENTS)",
+        (
+            "      DOUBLE PRECISION V(NEVENTS),VALUE,BEFORE,AFTER"
+            if summed
+            else "      DOUBLE PRECISION V(NEVENTS),MATRIX,BEFORE,AFTER"
+        ),
+        "      DOUBLE PRECISION TARGET,ELAPSED,CHECKSUM,FIRST0,FIRST1",
+        "      DOUBLE PRECISION PI,ASVALUE",
+        "      PARAMETER (PI=3.141592653589793D0)",
+    ]
+    if summed:
+        lines.extend(
+            [
+                "      INTEGER USERHEL",
+                "      COMMON/HELUSERCHOICE/USERHEL",
+            ]
+        )
+    else:
+        lines.append("      EXTERNAL MATRIX")
+    lines.extend(
+        [
+            f"      DATA HEL /{','.join(str(value) for value in selected.helicity)}/",
+            f"      DATA IC /{n_external}*1/",
+        ]
+    )
+    for event_index, event in enumerate(selected.events, start=1):
+        for leg_index, momentum in enumerate(event.momenta, start=1):
+            for component, value in enumerate(momentum):
+                lines.append(
+                    f"      P({component},{leg_index},{event_index})="
+                    f"{_fortran_double(value)}"
+                )
+    if summed:
+        as_value = _fortran_double(selected.source_alpha_s)
+    else:
+        coupling = selected.events[0].strong_coupling
+        if any(
+            not math.isclose(
+                event.strong_coupling, coupling, rel_tol=1.0e-14, abs_tol=0.0
+            )
+            for event in selected.events[1:]
+        ):
+            raise SelectedMadGraphError(
+                "selected events use different strong couplings"
+            )
+        as_value = f"{_fortran_double(coupling * coupling)}/(4D0*PI)"
+    validation_evaluation = (
+        "        CALL SMATRIX(P(0,1,E),V(E))"
+        if summed
+        else "        V(E)=MATRIX(P(0,1,E),HEL,IC)"
+    )
+    timed_evaluation = (
+        (
+            "        CALL SMATRIX(P(0,1,1),VALUE)",
+            "        CHECKSUM=CHECKSUM+VALUE",
+        )
+        if summed
+        else ("        CHECKSUM=CHECKSUM+MATRIX(P(0,1,1),HEL,IC)",)
+    )
+    repeated_evaluation = tuple(f"  {line}" for line in timed_evaluation)
+    lines.extend(
+        [
+            f"      TARGET={_fortran_double(target_seconds)}",
+            f"      ASVALUE={as_value}",
+            *(("      USERHEL=-1",) if summed else ()),
+            "      CALL SYSTEM_CLOCK(CLOCK0,CLOCKRATE)",
+            "      CALL SETPARA('../../Cards/param_card.dat')",
+            "      CALL UPDATE_AS_PARAM2(1D0,ASVALUE)",
+            "      CALL SYSTEM_CLOCK(CLOCK1)",
+            "      WRITE(*,'(A,1X,A)') 'BACKEND',",
+            f"     $ '{backend_identity}'",
+            "      WRITE(*,'(A,1X,A)') 'HELICITY_EVALUATOR',",
+            f"     $ '{evaluator_identity}'",
+            "      WRITE(*,'(A,1X,I0)') 'TOTAL_EXTERNAL',NEXTERNAL",
+            "      WRITE(*,'(A,1X,ES24.16)') 'INITIALIZATION_SECONDS',",
+            "     $ DBLE(CLOCK1-CLOCK0)/DBLE(CLOCKRATE)",
+            "      CALL CPU_TIME(FIRST0)",
+            "      DO E=1,NEVENTS",
+            validation_evaluation,
+            "      ENDDO",
+            "      CALL CPU_TIME(FIRST1)",
+            "      WRITE(*,'(A,1X,ES24.16)') 'FIRST_SAMPLE_PASS_SECONDS',",
+            "     $ FIRST1-FIRST0",
+            "      DO E=1,NEVENTS",
+            "        WRITE(*,'(A,2(1X,I0),1X,ES24.16)')",
+            "     $   'MATRIX_ELEMENT',E,1,V(E)",
+            "      ENDDO",
+            "      WRITE(*,'(A,1X,I0)') 'EVALUATIONS_PER_SWEEP',",
+            "     $ 1",
+            "      WRITE(*,'(A,1X,I0)') 'HELICITY_COVERAGE_COUNT',",
+            f"     $ {helicity_coverage_count}",
+            "      NREP=1",
+            "      CHECKSUM=0D0",
+            " 10   CONTINUE",
+            "      CALL CPU_TIME(BEFORE)",
+            "      DO R=1,NREP",
+            *timed_evaluation,
+            "      ENDDO",
+            "      CALL CPU_TIME(AFTER)",
+            "      ELAPSED=AFTER-BEFORE",
+            "      IF (ELAPSED.LT.TARGET) THEN",
+            "        IF (NREP.GT.1000000000) STOP 91",
+            "        NREP=2*NREP",
+            "        GOTO 10",
+            "      ENDIF",
+            "      WRITE(*,'(A,1X,I0,1X,ES24.16)')",
+            "     $ 'EVALUATION_SWEEP_SECONDS',1,ELAPSED/DBLE(NREP)",
+            "      WRITE(*,'(A,3(1X,I0),1X,ES24.16)')",
+            "     $ 'EVALUATION_CELL_SECONDS',1,1,1,ELAPSED/DBLE(NREP)",
+            "      DO B=2,NSAMPLES",
+            "        CHECKSUM=0D0",
+            "        CALL CPU_TIME(BEFORE)",
+            "        DO R=1,NREP",
+            *repeated_evaluation,
+            "        ENDDO",
+            "        CALL CPU_TIME(AFTER)",
+            "        ELAPSED=(AFTER-BEFORE)/DBLE(NREP)",
+            "        WRITE(*,'(A,1X,I0,1X,ES24.16)')",
+            "     $   'EVALUATION_SWEEP_SECONDS',B,ELAPSED",
+            "        WRITE(*,'(A,3(1X,I0),1X,ES24.16)')",
+            "     $   'EVALUATION_CELL_SECONDS',B,1,1,ELAPSED",
+            "      ENDDO",
+            "      WRITE(*,'(A,1X,ES24.16)') 'CHECKSUM',CHECKSUM",
+            "      END",
+        ]
+    )
+    if any(len(line) > 132 for line in lines):
+        raise SelectedMadGraphError(
+            "generated fixed-form check source exceeds 132 columns"
+        )
+    body = "\n".join(lines) + "\n"
+    if summed:
+        if body.count("CALL SMATRIX(") != 3 or re.search(
+            r"(?<!S)\bMATRIX\s*\(", body, re.IGNORECASE
+        ):
+            raise SelectedMadGraphError(
+                "summed check source must call generated SMATRIX only"
+            )
+    elif re.search(r"\bSMATRIX(?:HEL)?\b", body, re.IGNORECASE):
+        raise SelectedMadGraphError("fixed check source must call direct MATRIX only")
+    return body
+
+
+def _json_atomic(
+    path: Path, payload: Mapping[str, Any], *, replace: bool = True
+) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + f".{os.getpid()}.tmp")
+    serialized = json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n"
+    temporary.write_text(serialized, encoding="utf-8")
+    if not replace and path.exists():
+        temporary.unlink()
+        raise SelectedMadGraphError(f"refusing to replace {path}")
+    temporary.replace(path)
+
+
+def _cache_lock_path(cache_dir: Path) -> Path:
+    resolved = cache_dir.expanduser().resolve(strict=False)
+    digest = hashlib.sha256(os.fsencode(resolved)).hexdigest()
+    return CACHE_LOCK_ROOT / f"{digest}.lock"
+
+
+def _acquire_cache_lock(cache_dir: Path) -> Any:
+    """Reject overlapping writers even if the cache tree is replaced."""
+
+    path = _cache_lock_path(cache_dir)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    handle = path.open("a+b")
+    try:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError as error:
+        handle.close()
+        raise SelectedMadGraphError(
+            f"another MadGraph profiler holds cache lock {path}"
+        ) from error
+    return handle
+
+
+def _terminate_process(process: subprocess.Popen[Any]) -> None:
+    if process.poll() is not None:
+        return
+    try:
+        os.killpg(process.pid, signal.SIGTERM)
+    except ProcessLookupError:
+        return
+    try:
+        process.wait(timeout=5.0)
+    except subprocess.TimeoutExpired:
+        with suppress(ProcessLookupError):
+            os.killpg(process.pid, signal.SIGKILL)
+        process.wait()
+
+
+def _python_script_command(script: Path, *arguments: str) -> list[str]:
+    return [str(sys.executable), str(script), *arguments]
+
+
+def _generation_worker(arguments: argparse.Namespace) -> int:
+    output = arguments.generated_output.resolve(strict=False)
+    result_path = arguments.worker_result.resolve(strict=False)
+    cell_root = result_path.parent.parent.parent.resolve(strict=False)
+    if output.parent != cell_root:
+        raise SelectedMadGraphError(
+            "generation output is outside its dedicated cell directory"
+        )
+    if output.exists():
+        shutil.rmtree(output)
+    disk_free_before = shutil.disk_usage(cell_root).free
+    card = result_path.parent / "generate.mg5"
+    card.write_text(
+        "\n".join(
+            (
+                "set automatic_html_opening False",
+                "import model sm-default",
+                f"generate {arguments.process} QED=0",
+                f"output standalone {output} -f",
+                "",
+            )
+        ),
+        encoding="utf-8",
+    )
+    stdout_path = result_path.parent / "mg5.stdout.log"
+    stderr_path = result_path.parent / "mg5.stderr.log"
+    started = time.monotonic()
+    timed_out = False
+    returncode: int | None = None
+    error_text: str | None = None
+    with stdout_path.open("wb") as stdout, stderr_path.open("wb") as stderr:
+        try:
+            process = subprocess.Popen(
+                _python_script_command(
+                    arguments.mg5_root / "bin" / "mg5_aMC", str(card)
+                ),
+                cwd=arguments.mg5_root,
+                stdout=stdout,
+                stderr=stderr,
+                start_new_session=True,
+            )
+            try:
+                returncode = process.wait(timeout=arguments.generation_timeout_seconds)
+            except subprocess.TimeoutExpired:
+                timed_out = True
+                _terminate_process(process)
+                returncode = process.returncode
+        except OSError as error:
+            error_text = str(error)
+    elapsed = time.monotonic() - started
+    process_dirs = sorted(
+        str(path)
+        for path in (output / "SubProcesses").glob("P*")
+        if (path / "matrix.f").is_file()
+    )
+    status = "measured" if returncode == 0 and len(process_dirs) == 1 else "failed"
+    reason = None
+    category = None
+    if timed_out:
+        category = "generation-time-limit"
+        reason = (
+            "MadGraph generation exceeded "
+            f"{arguments.generation_timeout_seconds:g} seconds"
+        )
+    elif error_text is not None:
+        category = "generation-launch-error"
+        reason = error_text
+    elif returncode != 0:
+        log_tail = ""
+        with suppress(OSError):
+            log_tail = (
+                stdout_path.read_text(encoding="utf-8", errors="replace")[-4000:]
+                + stderr_path.read_text(encoding="utf-8", errors="replace")[-4000:]
+            )
+        if "No space left on device" in log_tail:
+            category = "infrastructure-disk-exhaustion"
+            reason = "campaign filesystem ran out of space during MadGraph generation"
+        else:
+            category = "generation-error"
+            reason = f"MadGraph exited with status {returncode}"
+    elif len(process_dirs) != 1:
+        category = "generation-structure-error"
+        reason = f"expected one standalone subprocess, found {len(process_dirs)}"
+    _json_atomic(
+        result_path,
+        {
+            "status": status,
+            "failure_category": category,
+            "failure_reason": reason,
+            "elapsed_wall_seconds": elapsed,
+            "returncode": returncode,
+            "timed_out": timed_out,
+            "process": arguments.process,
+            "output": str(output),
+            "process_dirs": process_dirs,
+            "card": str(card),
+            "stdout": str(stdout_path),
+            "stderr": str(stderr_path),
+            "disk_free_bytes_before": disk_free_before,
+            "disk_free_bytes_after": shutil.disk_usage(cell_root).free,
+        },
+    )
+    return 0
+
+
+def _timeout_worker(arguments: argparse.Namespace) -> int:
+    if not math.isfinite(arguments.timeout_seconds) or arguments.timeout_seconds <= 0.0:
+        raise SelectedMadGraphError("timeout must be a positive finite number")
+    command = list(arguments.command)
+    if command and command[0] == "--":
+        command.pop(0)
+    if not command:
+        raise SelectedMadGraphError("timeout worker requires a command")
+    try:
+        process = subprocess.Popen(command, start_new_session=True)
+    except OSError as error:
+        raise SelectedMadGraphError(
+            f"bounded command could not start: {error}"
+        ) from error
+    try:
+        return process.wait(timeout=arguments.timeout_seconds)
+    except subprocess.TimeoutExpired:
+        _terminate_process(process)
+        print(TIMEOUT_MARKER, file=sys.stderr, flush=True)
+        return TIMEOUT_EXIT_CODE
+
+
+def _run_watchdog(
+    command: Sequence[str], *, cwd: Path, report: Path, limit_gib: float
+) -> subprocess.CompletedProcess[str]:
+    if report.exists():
+        raise SelectedMadGraphError(f"watchdog report already exists: {report}")
+    return subprocess.run(
+        [
+            str(sys.executable),
+            str(WATCHDOG),
+            "--limit-gib",
+            format(limit_gib, ".17g"),
+            "--report-json",
+            str(report),
+            "--",
+            *command,
+        ],
+        cwd=cwd,
+        text=True,
+        capture_output=True,
+        check=False,
+        env={**os.environ, "LC_ALL": "C"},
+    )
+
+
+def _read_json(path: Path, *, context: str) -> Mapping[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise SelectedMadGraphError(f"cannot read {context} {path}: {error}") from error
+    return _mapping(value, context=context)
+
+
+def _new_attempt_directory(cell_dir: Path, stage: str) -> Path:
+    if stage not in {"generation", "measurement"}:
+        raise SelectedMadGraphError(f"unsupported attempt stage {stage!r}")
+    attempts = cell_dir / f"{stage}-attempts"
+    attempts.mkdir(parents=True, exist_ok=True)
+    indices = [
+        int(match.group(1))
+        for path in attempts.iterdir()
+        if path.is_dir()
+        and (match := re.fullmatch(r"attempt-(\d+)", path.name)) is not None
+    ]
+    index = max(indices, default=0) + 1
+    while True:
+        attempt = attempts / f"attempt-{index:03d}"
+        try:
+            attempt.mkdir()
+        except FileExistsError:
+            index += 1
+            continue
+        return attempt
+
+
+def _prune_cell_generated(cell_dir: Path) -> bool:
+    cell_root = cell_dir.resolve(strict=True)
+    generated = cell_root / "generated"
+    if not os.path.lexists(generated):
+        return False
+    if generated.is_symlink():
+        raise SelectedMadGraphError(
+            f"refusing generated-output symlink during cleanup: {generated}"
+        )
+    target = generated.resolve(strict=True)
+    if target != generated or target.parent != cell_root or target.name != "generated":
+        raise SelectedMadGraphError(
+            f"refusing unexpected generated-output cleanup target: {target}"
+        )
+    if not target.is_dir():
+        raise SelectedMadGraphError(
+            f"generated-output cleanup target is not a directory: {target}"
+        )
+    try:
+        shutil.rmtree(target)
+    except OSError as error:
+        raise SelectedMadGraphError(
+            f"cannot prune campaign-owned generated output {target}: {error}"
+        ) from error
+    return True
+
+
+def _load_checkpoint_cell(
+    checkpoint: Path,
+    *,
+    identity: Mapping[str, Any],
+    cell_dir: Path,
+    keep_generated: bool,
+) -> dict[str, Any] | None:
+    saved = _read_json(checkpoint, context="MadGraph cell checkpoint")
+    saved_identity = saved.get("checkpoint_identity")
+    cell = dict(_mapping(saved.get("cell"), context="checkpoint.cell"))
+    status = cell.get("status")
+    if status == "failed":
+        category = str(cell.get("failure_category"))
+        if category not in RESOURCE_FRONTIER_CATEGORIES:
+            raise SelectedMadGraphError(
+                f"checkpoint contains a non-resource failed frontier: {category}"
+            )
+    elif status != "measured":
+        raise SelectedMadGraphError(
+            f"checkpoint contains unsupported cell status {status!r}"
+        )
+    identity_matches = saved_identity == identity
+    if not identity_matches and isinstance(saved_identity, Mapping):
+        compatible, expected = _checkpoint_identity_comparison(
+            saved_identity, identity, cell_status=str(status)
+        )
+        if compatible != expected and status == "failed":
+            reusable_failure = dict(compatible)
+            requested_failure = dict(expected)
+            resource_limit_changed = any(
+                reusable_failure.get(key) != requested_failure.get(key)
+                for key in CHECKPOINT_RESOURCE_LIMIT_KEYS
+            )
+            timing_policy_changed = any(
+                reusable_failure.get(key) != requested_failure.get(key)
+                for key in CHECKPOINT_TIMING_POLICY_KEYS
+            )
+            for key in CHECKPOINT_RESOURCE_LIMIT_KEYS | CHECKPOINT_TIMING_POLICY_KEYS:
+                reusable_failure.pop(key, None)
+                requested_failure.pop(key, None)
+            if (
+                (resource_limit_changed or timing_policy_changed)
+                and reusable_failure == requested_failure
+            ):
+                if not keep_generated:
+                    _prune_cell_generated(cell_dir)
+                return None
+        identity_matches = compatible == expected
+    if not identity_matches:
+        raise SelectedMadGraphError(
+            f"checkpoint identity changed at {cell_dir.parent.name}/{cell_dir.name}; "
+            "use a fresh cache directory"
+        )
+    if not keep_generated:
+        _prune_cell_generated(cell_dir)
+    return cell
+
+
+def _checkpoint_identity_comparison(
+    saved_identity: Mapping[str, Any],
+    identity: Mapping[str, Any],
+    *,
+    cell_status: str,
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    compatible = dict(saved_identity)
+    expected = dict(identity)
+    same_source_cell = compatible.get("source_cell_sha256") == expected.get(
+        "source_cell_sha256"
+    ) and isinstance(compatible.get("source_cell_sha256"), str)
+    if not same_source_cell:
+        return compatible, expected
+    # Expanding a sparse source report does not change this cell's inputs.
+    compatible.pop("source_report_sha256", None)
+    expected.pop("source_report_sha256", None)
+    if (
+        LEGACY_CHECKPOINT_PRODUCER_KEY in compatible
+        and "checkpoint_protocol" in expected
+        and "checkpoint_protocol" not in compatible
+    ):
+        compatible.pop(LEGACY_CHECKPOINT_PRODUCER_KEY, None)
+        expected.pop("checkpoint_protocol", None)
+    if cell_status == "measured":
+        # Successful timings remain usable if only retry caps or the sampling
+        # target changed; new/retried cells record the current policy.
+        for key in CHECKPOINT_RESOURCE_LIMIT_KEYS | CHECKPOINT_TIMING_POLICY_KEYS:
+            compatible.pop(key, None)
+            expected.pop(key, None)
+    return compatible, expected
+
+
+def _generation_attempt(
+    *,
+    selected: SelectedCell,
+    cell_dir: Path,
+    mg5_root: Path,
+    timeout: float,
+    limit_gib: float,
+) -> tuple[Mapping[str, Any], Mapping[str, Any]]:
+    attempt = _new_attempt_directory(cell_dir, "generation")
+    worker_result = attempt / "result.json"
+    watchdog_report = attempt / "watchdog.json"
+    command = [
+        *_python_script_command(Path(__file__).resolve()),
+        "_generate-cell",
+        "--mg5-root",
+        str(mg5_root),
+        "--generated-output",
+        str(cell_dir / "generated"),
+        "--worker-result",
+        str(worker_result),
+        "--process",
+        selected.process,
+        "--generation-timeout-seconds",
+        format(timeout, ".17g"),
+    ]
+    completed = _run_watchdog(
+        command, cwd=ROOT, report=watchdog_report, limit_gib=limit_gib
+    )
+    watchdog = _read_json(watchdog_report, context="generation watchdog")
+    if worker_result.is_file():
+        generation = _read_json(worker_result, context="generation worker result")
+    else:
+        enforcement = _mapping(
+            watchdog.get("enforcement"), context="watchdog.enforcement"
+        )
+        execution = _mapping(watchdog.get("execution"), context="watchdog.execution")
+        generation = {
+            "status": "failed",
+            "failure_category": (
+                "infrastructure-disk-exhaustion"
+                if _is_disk_exhaustion(completed.stderr)
+                else (
+                    "generation-memory-limit"
+                    if execution.get("outcome") == "memory-limit-exceeded"
+                    else "generation-watchdog-error"
+                )
+            ),
+            "failure_reason": (
+                "campaign filesystem ran out of space during MadGraph generation"
+                if _is_disk_exhaustion(completed.stderr)
+                else (
+                    "MadGraph generation reached the "
+                    f"{limit_gib:g}-GiB process-tree memory limit"
+                    if execution.get("outcome") == "memory-limit-exceeded"
+                    else f"generation watchdog failed: {execution.get('outcome')}"
+                )
+            ),
+            "elapsed_wall_seconds": execution.get("elapsed_wall_seconds"),
+            "returncode": completed.returncode,
+            "process_dirs": [],
+            "output": str(cell_dir / "generated"),
+            "watchdog_peak_guard_bytes": enforcement.get("peak_guard_bytes"),
+        }
+    return generation, watchdog
+
+
+def _extract_integer(source: str, name: str) -> int:
+    match = re.search(rf"\b{name}\s*=\s*(\d+)\b", source, re.IGNORECASE)
+    if match is None or int(match.group(1)) < 1:
+        raise SelectedMadGraphError(f"generated MATRIX source lacks positive {name}")
+    return int(match.group(1))
+
+
+def _expected_smatrix_iden(family: str, final_multiplicity: int) -> int:
+    if family == "gg":
+        return 256 * math.factorial(final_multiplicity)
+    if family == "ddbar":
+        return 36 * math.factorial(final_multiplicity - 2)
+    raise SelectedMadGraphError(f"unsupported family {family!r}")
+
+
+def _validate_matrix_source(
+    path: Path,
+    *,
+    family: str,
+    final_multiplicity: int,
+) -> dict[str, Any]:
+    expected_external = final_multiplicity + 2
+    text = path.read_text(encoding="utf-8", errors="strict")
+    match = re.search(r"(?ims)^\s*REAL\*8 FUNCTION MATRIX\b(.*?)(?=^\s*END\s*$)", text)
+    if match is None:
+        raise SelectedMadGraphError("generated source has no direct MATRIX function")
+    body = match.group(1)
+    if re.search(r"\bSMATRIX(?:HEL)?\b|\bIHEL\b|\bNCOMB\b", body, re.IGNORECASE):
+        raise SelectedMadGraphError("generated MATRIX is not a direct-helicity kernel")
+    if not re.search(r"INTEGER\s+NHEL\s*\(\s*NEXTERNAL\s*\)", body, re.IGNORECASE):
+        raise SelectedMadGraphError("generated MATRIX lacks its NHEL vector")
+    n_external = _extract_integer(text, "NEXTERNAL")
+    if n_external != expected_external:
+        raise SelectedMadGraphError(
+            "generated MATRIX has the wrong external multiplicity"
+        )
+    smatrix = re.search(r"(?ims)^\s*SUBROUTINE SMATRIX\b(.*?)(?=^\s*END\s*$)", text)
+    if smatrix is None:
+        raise SelectedMadGraphError(
+            "generated standalone source is not helicity-general"
+        )
+    smatrix_body = smatrix.group(1)
+    ncomb = _extract_integer(smatrix_body, "NCOMB")
+    expected_ncomb = 2**expected_external
+    if ncomb != expected_ncomb:
+        raise SelectedMadGraphError(
+            "generated SMATRIX has the wrong complete-helicity coverage: "
+            f"expected NCOMB={expected_ncomb}, observed {ncomb}"
+        )
+    if re.search(
+        r"INTEGER\s+NHEL\s*\(\s*NEXTERNAL\s*,\s*NCOMB\s*\)",
+        smatrix_body,
+        re.IGNORECASE,
+    ) is None:
+        raise SelectedMadGraphError(
+            "generated SMATRIX lacks its NHEL(NEXTERNAL,NCOMB) table"
+        )
+    iden_matches = re.findall(
+        r"^[ \t]{6,}DATA[ \t]+IDEN[ \t]*/[ \t]*(\d+)[ \t]*/[ \t]*$",
+        smatrix.group(1),
+        re.IGNORECASE | re.MULTILINE,
+    )
+    if len(iden_matches) != 1 or int(iden_matches[0]) < 1:
+        raise SelectedMadGraphError(
+            "generated SMATRIX lacks one positive IDEN denominator"
+        )
+    iden_uses = re.findall(
+        r"^[ \t]{6,}ANS[ \t]*=[ \t]*ANS[ \t]*/[ \t]*"
+        r"DBLE[ \t]*\([ \t]*IDEN[ \t]*\)[ \t]*$",
+        smatrix.group(1),
+        re.IGNORECASE | re.MULTILINE,
+    )
+    if len(iden_uses) != 1:
+        raise SelectedMadGraphError(
+            "generated SMATRIX does not apply its IDEN denominator exactly once"
+        )
+    smatrix_iden = int(iden_matches[0])
+    expected_iden = _expected_smatrix_iden(family, final_multiplicity)
+    if smatrix_iden != expected_iden:
+        raise SelectedMadGraphError(
+            "generated SMATRIX has the wrong IDEN denominator: "
+            f"expected {expected_iden}, observed {smatrix_iden}"
+        )
+    return {
+        "matrix_sha256": hashlib.sha256(text.encode("utf-8")).hexdigest(),
+        "generated_matrix_graphs": _extract_integer(body, "NGRAPHS"),
+        "colour_flows": _extract_integer(body, "NCOLOR"),
+        "smatrix_iden": smatrix_iden,
+        "generation_helicity_coverage": "all",
+        "generated_helicity_coverage_count": ncomb,
+    }
+
+
+def _parse_time_max_rss(stderr: str) -> int | None:
+    system = platform.system()
+    if system == "Darwin":
+        matches = re.findall(
+            r"^\s*(\d+)\s+maximum resident set size\s*$", stderr, re.MULTILINE
+        )
+        if len(matches) != 1:
+            return None
+        return math.ceil(int(matches[0]) / 1024)
+    if system == "Linux":
+        matches = re.findall(
+            r"^\s*Maximum resident set size \(kbytes\):\s*(\d+)\s*$",
+            stderr,
+            re.MULTILINE,
+        )
+        if len(matches) != 1:
+            return None
+        return int(matches[0])
+    return None
+
+
+def _external_time_command(command: Sequence[str]) -> list[str]:
+    """Add the host's external time utility when its dialect is known."""
+
+    system = platform.system()
+    if system == "Darwin":
+        time_path = Path("/usr/bin/time")
+        prefix = [str(time_path), "-l"] if time_path.is_file() else []
+    elif system == "Linux":
+        located = shutil.which("time")
+        prefix = [located, "-v"] if located is not None else []
+    else:
+        prefix = []
+    return [*prefix, *command]
+
+
+def _watchdog_resource(report: Mapping[str, Any]) -> dict[str, Any]:
+    enforcement = _mapping(report.get("enforcement"), context="watchdog.enforcement")
+    execution = _mapping(report.get("execution"), context="watchdog.execution")
+    peak_guard = int(enforcement.get("peak_guard_bytes", 0))
+    return {
+        "elapsed_wall_seconds": _finite_number(
+            execution.get("elapsed_wall_seconds"),
+            context="watchdog elapsed",
+            nonnegative=True,
+        ),
+        "peak_guard_bytes": peak_guard,
+        "peak_guard_kib": math.ceil(peak_guard / 1024),
+        "peak_rss_bytes": int(enforcement.get("peak_rss_bytes", 0)),
+        "peak_physical_footprint_bytes": enforcement.get(
+            "peak_physical_footprint_bytes"
+        ),
+        "metric": enforcement.get("metric"),
+        "limit_bytes": enforcement.get("limit_bytes"),
+        "outcome": execution.get("outcome"),
+        "passes": report.get("passes") is True,
+    }
+
+
+def _run_bounded_command(
+    command: Sequence[str],
+    *,
+    cwd: Path,
+    report: Path,
+    limit_gib: float,
+    timeout_seconds: float | None = None,
+) -> tuple[subprocess.CompletedProcess[str], Mapping[str, Any]]:
+    bounded = list(command)
+    if timeout_seconds is not None:
+        if not math.isfinite(timeout_seconds) or timeout_seconds <= 0.0:
+            raise SelectedMadGraphError("cold-to-ready time budget is exhausted")
+        bounded = [
+            *_python_script_command(Path(__file__).resolve()),
+            "_run-with-timeout",
+            "--timeout-seconds",
+            format(timeout_seconds, ".17g"),
+            "--",
+            *bounded,
+        ]
+    completed = _run_watchdog(
+        _external_time_command(bounded),
+        cwd=cwd,
+        report=report,
+        limit_gib=limit_gib,
+    )
+    report.with_name(f"{report.stem}.stdout.log").write_text(
+        completed.stdout, encoding="utf-8"
+    )
+    report.with_name(f"{report.stem}.stderr.log").write_text(
+        completed.stderr, encoding="utf-8"
+    )
+    return completed, _read_json(report, context="bounded command watchdog")
+
+
+def _bounded_command_timed_out(
+    completed: subprocess.CompletedProcess[str],
+) -> bool:
+    return (
+        completed.returncode == TIMEOUT_EXIT_CODE and TIMEOUT_MARKER in completed.stderr
+    )
+
+
+def _remaining_cold_to_ready_budget(
+    limit_seconds: float, *resources: Mapping[str, Any]
+) -> float:
+    used = sum(float(resource["elapsed_wall_seconds"]) for resource in resources)
+    remaining = limit_seconds - used
+    if not math.isfinite(remaining) or remaining <= 0.0:
+        raise ResourceFrontierError(
+            "generation-time-limit",
+            "cold-to-ready generation reached the strict time limit",
+        )
+    return remaining
+
+
+def _relative_error(observed: float, reference: float) -> float:
+    if observed == reference:
+        return 0.0
+    return abs(observed - reference) / max(abs(observed), abs(reference), 1.0e-300)
+
+
+def _numerical_normalization_factor(
+    family: str, *, smatrix_iden: int, helicity_workload: str = "fixed"
+) -> float:
+    if family not in FAMILIES:
+        raise SelectedMadGraphError(f"unsupported family {family!r}")
+    if smatrix_iden < 1:
+        raise SelectedMadGraphError("SMATRIX IDEN denominator must be positive")
+    _workload_label(helicity_workload)
+    if helicity_workload == "sum":
+        return 1.0
+    return 1.0 if family == "gg" else 1.0 / float(smatrix_iden)
+
+
+def _is_disk_exhaustion(error: BaseException | str) -> bool:
+    text = str(error)
+    return "No space left on device" in text or "[Errno 28]" in text
+
+
+def _directory_size(path: Path) -> int:
+    return sum(
+        entry.stat().st_size
+        for entry in path.rglob("*")
+        if entry.is_file() and not entry.is_symlink()
+    )
+
+
+def _measure_generated_cell(
+    *,
+    source: SourceSelection,
+    selected: SelectedCell,
+    generation: Mapping[str, Any],
+    generation_watchdog: Mapping[str, Any],
+    cell_dir: Path,
+    fc: str,
+    fflags: str,
+    make: str,
+    limit_gib: float,
+    mg5_root: Path,
+    cold_to_ready_limit_seconds: float,
+    target_seconds: float = TARGET_SECONDS,
+    warm_sample_count: int = WARM_SAMPLE_COUNT,
+) -> dict[str, Any]:
+    process_dirs = generation.get("process_dirs")
+    if (
+        not isinstance(process_dirs, Sequence)
+        or isinstance(process_dirs, str)
+        or len(process_dirs) != 1
+    ):
+        raise SelectedMadGraphError(
+            "generation result has the wrong subprocess inventory"
+        )
+    generated_root = Path(str(generation.get("output"))).resolve(strict=True)
+    process_dir = Path(str(process_dirs[0])).resolve(strict=True)
+    matrix_source = process_dir / "matrix.f"
+    matrix = _validate_matrix_source(
+        matrix_source,
+        family=selected.family,
+        final_multiplicity=selected.n,
+    )
+    generation_resource = _watchdog_resource(generation_watchdog)
+    if not generation_resource["passes"]:
+        if generation_resource["outcome"] == "memory-limit-exceeded":
+            raise ResourceFrontierError(
+                "memory-limit",
+                f"MadGraph generation reached the strict {limit_gib:g}-GiB "
+                "memory limit",
+            )
+        raise SelectedMadGraphError(
+            "generation memory enforcement did not pass: "
+            f"{generation_resource['outcome']}"
+        )
+    build_budget_seconds = _remaining_cold_to_ready_budget(
+        cold_to_ready_limit_seconds, generation_resource
+    )
+    check_source = process_dir.parent / "check_sa.f"
+    check_body = render_check_source(
+        selected,
+        summed_helicity_coverage_count=(
+            matrix["generated_helicity_coverage_count"]
+            if selected.helicity_workload == "sum"
+            else None
+        ),
+        target_seconds=target_seconds,
+        warm_sample_count=warm_sample_count,
+    )
+    check_source.write_text(check_body, encoding="ascii")
+
+    makefile = process_dir / "makefile"
+    if not makefile.exists():
+        raise SelectedMadGraphError("generated subprocess has no makefile")
+    measurement_attempt = _new_attempt_directory(cell_dir, "measurement")
+    build_report = measurement_attempt / "build-watchdog.json"
+    retained = measurement_attempt / "retained"
+    retained.mkdir()
+    retained_matrix = retained / "matrix.f"
+    retained_check = retained / "check_sa.f"
+    retained_executable = retained / "check"
+    shutil.copy2(matrix_source, retained_matrix)
+    shutil.copy2(check_source, retained_check)
+    build_command = [make, "check", f"FC={fc}", f"FFLAGS={fflags}"]
+    build, build_watchdog = _run_bounded_command(
+        build_command,
+        cwd=process_dir,
+        report=build_report,
+        limit_gib=limit_gib,
+        timeout_seconds=build_budget_seconds,
+    )
+    build_resource = _watchdog_resource(build_watchdog)
+    if build.returncode != 0:
+        detail = (build.stdout + "\n" + build.stderr)[-8000:]
+        if build_resource["outcome"] == "memory-limit-exceeded":
+            raise ResourceFrontierError(
+                "memory-limit",
+                f"cold-to-ready generation reached the strict {limit_gib:g}-GiB "
+                "memory limit",
+            )
+        if _bounded_command_timed_out(build):
+            raise ResourceFrontierError(
+                "generation-time-limit",
+                "cold-to-ready generation reached the strict time limit",
+            )
+        raise SelectedMadGraphError(f"generated standalone build failed:\n{detail}")
+    if not build_resource["passes"]:
+        raise SelectedMadGraphError(
+            f"build memory enforcement did not pass: {build_resource['outcome']}"
+        )
+    executable = process_dir / "check"
+    if not executable.is_file():
+        raise SelectedMadGraphError(
+            "generated standalone build produced no check executable"
+        )
+    generated_size_bytes = _directory_size(generated_root)
+
+    shutil.copy2(executable, retained_executable)
+
+    runtime_budget_seconds = _remaining_cold_to_ready_budget(
+        cold_to_ready_limit_seconds, generation_resource, build_resource
+    )
+    runtime_report = measurement_attempt / "runtime-watchdog.json"
+    runtime, runtime_watchdog = _run_bounded_command(
+        [str(executable)],
+        cwd=process_dir,
+        report=runtime_report,
+        limit_gib=limit_gib,
+        timeout_seconds=runtime_budget_seconds,
+    )
+    runtime_resource = _watchdog_resource(runtime_watchdog)
+    if runtime.returncode != 0:
+        detail = (runtime.stdout + "\n" + runtime.stderr)[-8000:]
+        if runtime_resource["outcome"] == "memory-limit-exceeded":
+            raise ResourceFrontierError(
+                "memory-limit",
+                f"initialized runtime reached the strict {limit_gib:g}-GiB "
+                "memory limit",
+            )
+        if _bounded_command_timed_out(runtime):
+            raise ResourceFrontierError(
+                "generation-time-limit",
+                "initialization/check execution exhausted the remaining "
+                "cold-to-ready time budget",
+            )
+        raise SelectedMadGraphError(f"generated standalone runtime failed:\n{detail}")
+    if not runtime_resource["passes"]:
+        raise SelectedMadGraphError(
+            f"runtime memory enforcement did not pass: {runtime_resource['outcome']}"
+        )
+    parsed = parse_driver_output(
+        runtime.stdout,
+        batches=warm_sample_count + 1,
+        expected_total_external=selected.total_external,
+        expected_events=POINT_COUNT,
+        helicity_workload=selected.helicity_workload,
+        expected_helicity_coverage_count=(
+            int(matrix["generated_helicity_coverage_count"])
+            if selected.helicity_workload == "sum"
+            else None
+        ),
+    )
+    # Fixed MATRIX is deliberately unaveraged and retains the historical
+    # family-specific reference convention.  Summed mode calls SMATRIX, which
+    # already applies IDEN exactly once, so its normalized source points need
+    # no further factor.
+    normalization_factor = _numerical_normalization_factor(
+        selected.family,
+        smatrix_iden=int(matrix["smatrix_iden"]),
+        helicity_workload=selected.helicity_workload,
+    )
+    relative_errors = tuple(
+        _relative_error(observed * normalization_factor, reference)
+        for observed, reference in zip(
+            parsed.point_values, selected.reference_point_values, strict=True
+        )
+    )
+    maximum_error = max(relative_errors)
+    if maximum_error > RELATIVE_TOLERANCE:
+        raise SelectedMadGraphError(
+            f"MadGraph points disagree with {selected.source_mode} "
+            f"(maximum relative error {maximum_error:.6e})"
+    )
+    calibration = parsed.cell_seconds[0][0]
+    warm_samples = tuple(row[0] for row in parsed.cell_seconds[1:])
+    if len(warm_samples) != warm_sample_count or any(
+        value <= 0.0 for value in warm_samples
+    ):
+        raise SelectedMadGraphError(
+            "MadGraph did not provide the requested positive warm samples"
+        )
+    warm = statistics.median(warm_samples)
+    cold_to_ready_seconds = (
+        generation_resource["elapsed_wall_seconds"]
+        + build_resource["elapsed_wall_seconds"]
+        + parsed.initialization_seconds
+    )
+    cold_to_ready_peak_kib = max(
+        generation_resource["peak_guard_kib"],
+        build_resource["peak_guard_kib"],
+        runtime_resource["peak_guard_kib"],
+    )
+    if cold_to_ready_seconds >= cold_to_ready_limit_seconds:
+        raise ResourceFrontierError(
+            "generation-time-limit",
+            "cold-to-ready generation reached the strict time limit",
+        )
+    runtime_self_rss = _parse_time_max_rss(runtime.stderr)
+    event_paths = [str(event.path) for event in selected.events]
+    event_hashes = [event.sha256 for event in selected.events]
+    mg_version = (mg5_root / "VERSION").read_text(encoding="utf-8").strip()
+    summed = selected.helicity_workload == "sum"
+    label = _workload_label(selected.helicity_workload)
+    timed_helicity_count = parsed.helicity_coverage_count
+    if summed and timed_helicity_count != matrix["generated_helicity_coverage_count"]:
+        raise SelectedMadGraphError(
+            "MadGraph output helicity coverage differs from generated NCOMB"
+        )
+    return {
+        "status": "measured",
+        "family": selected.family,
+        "mode": MODE,
+        "label": label,
+        "n": selected.n,
+        "total_external": selected.total_external,
+        "process": selected.process,
+        "alpha_s": (
+            selected.source_alpha_s
+            if summed
+            else selected.events[0].strong_coupling ** 2 / (4.0 * math.pi)
+        ),
+        "helicity": list(selected.helicity),
+        "helicity_workload": selected.helicity_workload,
+        "warm_fixed_helicity": not summed,
+        "warm_helicity_sum": summed,
+        "timed_helicity_count": timed_helicity_count,
+        "event_paths": event_paths,
+        "event_sha256": event_hashes,
+        "point_values": list(parsed.point_values),
+        "matrix_element": parsed.point_values[0],
+        "generation_seconds": cold_to_ready_seconds,
+        "warm_seconds_per_point": warm,
+        "max_rss_kib": cold_to_ready_peak_kib,
+        "warm_samples_seconds": list(warm_samples),
+        "metrics": {
+            "generation_seconds": cold_to_ready_seconds,
+            "warm_seconds_per_point": warm,
+            "max_rss_kib": cold_to_ready_peak_kib,
+        },
+        "probe": {
+            "timer_source": "process-cpu-time",
+            "warm_median_seconds": warm,
+            "warm_samples_seconds": list(warm_samples),
+            "warm_sample_count": warm_sample_count,
+            "calibration_target_seconds": target_seconds,
+            "calibration_sample_seconds": calibration,
+            "published_driver_batches": list(range(2, warm_sample_count + 2)),
+            "timed_event_index": 1,
+            "validation_event_count": POINT_COUNT,
+            "validation_first_pass_seconds": parsed.first_pass_seconds,
+            "runtime_self_max_rss_kib": runtime_self_rss,
+            "runtime_process_tree_peak_guard_kib": runtime_resource["peak_guard_kib"],
+        },
+        "numerical": {
+            "reference_mode": selected.source_mode,
+            "relative_tolerance": RELATIVE_TOLERANCE,
+            "normalization_factor_reference_per_madgraph": normalization_factor,
+            "normalization_contract": (
+                (
+                    "generated SMATRIX applies its IDEN denominator exactly once; "
+                    "no additional normalization"
+                )
+                if summed
+                else "identity"
+                if selected.family == "gg"
+                else (
+                    "generated SMATRIX IDEN denominator applied to unaveraged "
+                    "direct MATRIX; includes incoming spin/colour averaging "
+                    "and identical-final-state symmetry"
+                )
+            ),
+            "maximum_relative_error": maximum_error,
+            "relative_errors": list(relative_errors),
+            "passes": True,
+        },
+        "protocol": {
+            "evaluator": (
+                "SMATRIX(P,ANS)-generated-complete-helicity-sum"
+                if summed
+                else "MATRIX(P,NHEL,IC)-direct"
+            ),
+            "generation_helicity_coverage": "all",
+            "helicity_workload": selected.helicity_workload,
+            "warm_fixed_helicity": not summed,
+            "warm_helicity_sum": summed,
+            "helicity_summed": summed,
+            "timed_helicity_count": timed_helicity_count,
+            "helicity_sum_implementation": (
+                "generated-SMATRIX-with-USERHEL-minus-one"
+                if summed
+                else "not-applicable"
+            ),
+            "warmed_native_call_pruning": (
+                "generated GOODHEL cache may skip structurally zero helicities"
+                if summed
+                else "not-applicable"
+            ),
+            "color_sum": (
+                "generated-SMATRIX-summed-and-averaged"
+                if summed
+                else "full-unaveraged"
+            ),
+            "incoming_color_average": summed,
+            "incoming_helicity_average": summed,
+            "final_state_symmetry_factor": summed,
+            "timer_source": "process-cpu-time",
+            "batch_size": 1,
+            "warm_sample_count": warm_sample_count,
+            "validated_point_count": POINT_COUNT,
+            "timed_point_index": 1,
+            "calibration_target_seconds": target_seconds,
+            "fixed_repetitions_after_calibration": True,
+            "calibration_sample_included": False,
+            "initialization_included": False,
+            "first_pass_included": False,
+            "build_included": False,
+        },
+        "runtime_refresh": {
+            "accepted": True,
+            "fresh_process": True,
+            "scope": "generation-resource-and-warm-runtime",
+        },
+        "provenance": {
+            "source_report": {
+                "path": _display_path(source.path),
+                "sha256": source.sha256,
+                "cell": (
+                    f"cells.{selected.family}.{selected.source_mode}.{selected.n}"
+                ),
+            },
+            "source_alpha_s": source.alpha_s,
+            "runtime_alpha_s": (
+                source.alpha_s
+                if summed
+                else selected.events[0].strong_coupling ** 2 / (4.0 * math.pi)
+            ),
+            "madgraph_root": str(mg5_root),
+            "madgraph_version": mg_version,
+            "matrix_sha256": matrix["matrix_sha256"],
+            "generated_matrix_graphs": matrix["generated_matrix_graphs"],
+            "colour_flows": matrix["colour_flows"],
+            "smatrix_iden": matrix["smatrix_iden"],
+            "generation_helicity_coverage": "all",
+            "helicity_workload": selected.helicity_workload,
+            "warm_fixed_helicity": not summed,
+            "warm_helicity_sum": summed,
+            "timed_helicity_count": timed_helicity_count,
+            "compiler": fc,
+            "fflags": fflags,
+            "check_source_sha256": hashlib.sha256(
+                check_body.encode("ascii")
+            ).hexdigest(),
+            "generated_output_size_bytes": generated_size_bytes,
+            "cold_to_ready": {
+                "elapsed_wall_seconds": cold_to_ready_seconds,
+                "peak_guard_kib": cold_to_ready_peak_kib,
+                "included_stages": [
+                    "mg5-output",
+                    "standalone-check-build",
+                    "required-model-initialization",
+                ],
+                "initialization_seconds": parsed.initialization_seconds,
+            },
+            "measurement_attempt": str(measurement_attempt),
+            "build_watchdog_report": str(build_report),
+            "build_stdout_log": str(
+                build_report.with_name(f"{build_report.stem}.stdout.log")
+            ),
+            "build_stderr_log": str(
+                build_report.with_name(f"{build_report.stem}.stderr.log")
+            ),
+            "runtime_watchdog_report": str(runtime_report),
+            "runtime_stdout_log": str(
+                runtime_report.with_name(f"{runtime_report.stem}.stdout.log")
+            ),
+            "runtime_stderr_log": str(
+                runtime_report.with_name(f"{runtime_report.stem}.stderr.log")
+            ),
+            "retained": {
+                "matrix_source": str(retained_matrix),
+                "matrix_sha256": _sha256(retained_matrix),
+                "check_source": str(retained_check),
+                "check_source_sha256": _sha256(retained_check),
+                "executable": str(retained_executable),
+                "executable_sha256": _sha256(retained_executable),
+            },
+            "generation": generation_resource,
+            "build": build_resource,
+            "runtime": runtime_resource,
+            "runtime_self_max_rss_kib": runtime_self_rss,
+        },
+    }
+
+
+def _failure_cell(selected: SelectedCell, category: str, reason: str) -> dict[str, Any]:
+    if category not in RESOURCE_FRONTIER_CATEGORIES:
+        raise SelectedMadGraphError(
+            f"refusing non-resource failure as a physics frontier: {category}"
+        )
+    return {
+        "status": "failed",
+        "family": selected.family,
+        "mode": MODE,
+        "label": _workload_label(selected.helicity_workload),
+        "n": selected.n,
+        "total_external": selected.total_external,
+        "process": selected.process,
+        "helicity_workload": selected.helicity_workload,
+        "failure_category": category,
+        "failure_reason": reason,
+        "censors_higher_multiplicities": True,
+        "availability_frontier_n": selected.n - 1,
+    }
+
+
+def _dependency_failure_cell(
+    family: str,
+    n: int,
+    reason: str,
+    *,
+    helicity_workload: str = "fixed",
+    censors_higher_multiplicities: bool = True,
+) -> dict[str, Any]:
+    cell: dict[str, Any] = {
+        "status": "failed",
+        "family": family,
+        "mode": MODE,
+        "label": _workload_label(helicity_workload),
+        "n": n,
+        "total_external": n + 2,
+        "process": process_expression(family, n),
+        "helicity_workload": helicity_workload,
+        "failure_category": "dependency-unavailable",
+        "failure_reason": (
+            f"source {source_mode(family, helicity_workload)} cell is unavailable: "
+            f"{reason}"
+        ),
+        "censors_higher_multiplicities": censors_higher_multiplicities,
+    }
+    if censors_higher_multiplicities:
+        cell["availability_frontier_n"] = n - 1
+    return cell
+
+
+def _frontier_cell(
+    family: str,
+    n: int,
+    *,
+    failure_n: int,
+    reason: str,
+    helicity_workload: str = "fixed",
+) -> dict[str, Any]:
+    return {
+        "status": "skipped",
+        "family": family,
+        "mode": MODE,
+        "label": _workload_label(helicity_workload),
+        "n": n,
+        "total_external": n + 2,
+        "process": process_expression(family, n),
+        "helicity_workload": helicity_workload,
+        "failure_category": "skipped-after-frontier",
+        "failure_reason": reason,
+        "censors_higher_multiplicities": True,
+        "availability_frontier_n": failure_n - 1,
+        "skipped_after_frontier": True,
+    }
+
+
+def _diagnostic_skip_cell(
+    family: str, n: int, reason: str, *, helicity_workload: str = "fixed"
+) -> dict[str, Any]:
+    return {
+        "status": "skipped",
+        "family": family,
+        "mode": MODE,
+        "label": _workload_label(helicity_workload),
+        "n": n,
+        "total_external": n + 2,
+        "process": process_expression(family, n),
+        "helicity_workload": helicity_workload,
+        "failure_category": "diagnostic-selection-omitted",
+        "failure_reason": reason,
+        "censors_higher_multiplicities": False,
+        "skipped_after_frontier": False,
+    }
+
+
+def _protocol_scope_cell(
+    family: str, n: int, *, helicity_workload: str = "fixed"
+) -> dict[str, Any]:
+    limit = protocol_measured_multiplicity_limit(family)
+    if protocol_measures_multiplicity(family, n):
+        raise SelectedMadGraphError(
+            f"MadGraph protocol scope does not apply at n={n}"
+        )
+    if family == "gg" and n == 6:
+        category = "protocol-scope-pure-gluon-n6"
+        reason = (
+            "final-plot protocol skips pure-gluon MadGraph standalone n=6: "
+            "the generated 116 MiB matrix.f source triggered a deterministic "
+            "gfortran -O3 f951 internal compiler error after a 6h41m build "
+            "attempt; higher candidate and reference frontiers are profiled "
+            "independently"
+        )
+    else:
+        category = f"protocol-scope-n>{limit}"
+        reason = (
+            f"final-plot protocol measures {family} MadGraph standalone only "
+            f"through n={limit}; higher candidate and reference frontiers are "
+            "profiled independently"
+        )
+    return {
+        "status": "not-applicable",
+        "family": family,
+        "mode": MODE,
+        "label": _workload_label(helicity_workload),
+        "n": n,
+        "total_external": n + 2,
+        "process": process_expression(family, n),
+        "helicity_workload": helicity_workload,
+        "failure_category": category,
+        "failure_reason": reason,
+        "censors_higher_multiplicities": False,
+        "protocol_scope": {
+            "maximum_measured_multiplicity": limit,
+            "disposition": "not-applicable",
+        },
+    }
+
+
+def _checkpoint_identity(
+    source: SourceSelection,
+    selected: SelectedCell,
+    mg5_root: Path,
+    fc: str,
+    fflags: str,
+    make: str,
+    timeout_seconds: float,
+    memory_limit_gib: float,
+    target_seconds: float,
+    warm_sample_count: int,
+) -> dict[str, Any]:
+    source_cell_payload = {
+        "schema_version": 1,
+        "alpha_s": source.alpha_s,
+        "family": selected.family,
+        "n": selected.n,
+        "process": selected.process,
+        "source_mode": selected.source_mode,
+        "helicity_workload": selected.helicity_workload,
+        "helicity": list(selected.helicity),
+        "event_sha256": [event.sha256 for event in selected.events],
+        "reference_point_values": list(selected.reference_point_values),
+    }
+    source_cell_sha256 = hashlib.sha256(
+        json.dumps(
+            source_cell_payload,
+            sort_keys=True,
+            separators=(",", ":"),
+            allow_nan=False,
+        ).encode("utf-8")
+    ).hexdigest()
+    return {
+        "checkpoint_protocol": CHECKPOINT_PROTOCOL,
+        "measurement_host": measurement_host_identity(),
+        "source_report_sha256": source.sha256,
+        "source_cell_sha256": source_cell_sha256,
+        "family": selected.family,
+        "n": selected.n,
+        "process": selected.process,
+        "helicity_workload": selected.helicity_workload,
+        "helicity": list(selected.helicity),
+        "event_sha256": [event.sha256 for event in selected.events],
+        "mg5_root": str(mg5_root),
+        "mg5_version_sha256": _sha256(mg5_root / "VERSION"),
+        "fc": fc,
+        "fflags": fflags,
+        "make": make,
+        "generation_timeout_seconds": timeout_seconds,
+        "memory_limit_gib": memory_limit_gib,
+        "target_seconds": target_seconds,
+        "warm_sample_count": warm_sample_count,
+    }
+
+
+def _rebind_source_provenance(
+    cell: Mapping[str, Any], *, source: SourceSelection, selected: SelectedCell
+) -> tuple[dict[str, Any], bool]:
+    copied = dict(cell)
+    if copied.get("status") != "measured":
+        return copied, False
+    raw_provenance = _mapping(
+        copied.get("provenance"), context="checkpoint cell provenance"
+    )
+    provenance = dict(raw_provenance)
+    expected_source = {
+        "path": _display_path(source.path),
+        "sha256": source.sha256,
+        "cell": f"cells.{selected.family}.{selected.source_mode}.{selected.n}",
+    }
+    changed = provenance.get("source_report") != expected_source
+    provenance["source_report"] = expected_source
+    copied["provenance"] = provenance
+    return copied, changed
+
+
+def _runtime_policy(
+    multiplicities: Sequence[int],
+    *,
+    timeout_seconds: float,
+    memory_limit_gib: float,
+    target_seconds: float = TARGET_SECONDS,
+    warm_sample_count: int = WARM_SAMPLE_COUNT,
+    helicity_workload: str = "fixed",
+) -> dict[str, Any]:
+    summed = helicity_workload == "sum"
+    _workload_label(helicity_workload)
+    return {
+        "final_state_multiplicities": list(multiplicities),
+        "process_families": list(FAMILIES),
+        "point_validation_count": POINT_COUNT,
+        "warm_timed_point_index": 1,
+        "warm_sample_count": warm_sample_count,
+        "calibration_target_seconds": target_seconds,
+        "generation_timeout_seconds": timeout_seconds,
+        "outer_memory_watchdog_gib": memory_limit_gib,
+        "watchdog_enforced_per_generation_build_and_runtime": True,
+        "standalone_source": "fresh helicity-general MadGraph standalone",
+        "evaluator": (
+            "generated SMATRIX(P,ANS) with USERHEL=-1 and warmed GOODHEL pruning"
+            if summed
+            else "direct MATRIX(P,NHEL,IC)"
+        ),
+        "generation_helicity_coverage": "all",
+        "helicity_workload": helicity_workload,
+        "warm_fixed_helicity": not summed,
+        "warm_helicity_sum": summed,
+        "maximum_measured_multiplicity": MAX_PROTOCOL_MEASURED_MULTIPLICITY,
+        "family_maximum_measured_multiplicity": (
+            protocol_measured_multiplicity_limits()
+        ),
+        "higher_multiplicity_policy": "not-applicable-protocol-scope",
+        "metric_scope": {
+            "generation_seconds": (
+                "cold-to-ready MG5 generation, check build, and required "
+                "model initialization"
+            ),
+            "max_rss_kib": (
+                "maximum conservative process-tree peak guard across "
+                "generation, build, and initialized runtime"
+            ),
+            "warm_seconds_per_point": (
+                f"median of {warm_sample_count} post-calibration point-01 CPU "
+                "sample(s) of one "
+                + (
+                    "complete physical-helicity sum"
+                    if summed
+                    else "fixed-helicity evaluation"
+                )
+            ),
+        },
+    }
+
+
+def _progress_cell_identity(
+    family: str, n: int, *, helicity_workload: str = "fixed"
+) -> dict[str, Any]:
+    return {
+        "family": family,
+        "mode": MODE,
+        "n": n,
+        "total_external": n + 2,
+        "process": process_expression(family, n),
+        "helicity_workload": helicity_workload,
+    }
+
+
+def _runtime_progress_report(
+    *,
+    source: SourceSelection,
+    runtime_series: Mapping[str, Mapping[str, Mapping[str, Mapping[str, Any]]]],
+    selected_multiplicities: Sequence[int],
+    selected_families: Sequence[str],
+    timeout_seconds: float,
+    memory_limit_gib: float,
+    target_seconds: float,
+    warm_sample_count: int,
+    started_at_utc: str,
+    current_cell: Mapping[str, Any] | None,
+) -> dict[str, Any]:
+    counts = Counter(
+        str(cell.get("status"))
+        for family_series in runtime_series.values()
+        for mode_cells in family_series.values()
+        for cell in mode_cells.values()
+    )
+    completed = sum(counts.values())
+    total = len(FAMILIES) * len(selected_multiplicities)
+    pending = [
+        _progress_cell_identity(
+            family, n, helicity_workload=source.helicity_workload
+        )
+        for family in FAMILIES
+        for n in selected_multiplicities
+        if str(n) not in runtime_series[family][MODE]
+    ]
+    if completed == total:
+        status = "complete-with-failures" if counts["failed"] else "complete"
+        current: Mapping[str, Any] | None = None
+    else:
+        status = "running"
+        current = current_cell
+    return {
+        "kind": PROGRESS_KIND,
+        "schema_version": SCHEMA_VERSION,
+        "status": status,
+        "started_at_utc": started_at_utc,
+        "updated_at_utc": datetime.now(UTC).isoformat(),
+        "source_report": {
+            "path": _display_path(source.path),
+            "sha256": source.sha256,
+        },
+        "producer": {
+            "path": _display_path(Path(__file__).resolve()),
+            "sha256": _sha256(Path(__file__).resolve()),
+        },
+        "host": measurement_host_identity(),
+        "policy": _runtime_policy(
+            selected_multiplicities,
+            timeout_seconds=timeout_seconds,
+            memory_limit_gib=memory_limit_gib,
+            target_seconds=target_seconds,
+            warm_sample_count=warm_sample_count,
+            helicity_workload=source.helicity_workload,
+        )
+        | {"selected_process_families": list(selected_families)},
+        "current_cell": dict(current) if current is not None else None,
+        "pending_cells": pending,
+        "summary": {
+            "completed_cell_count": completed,
+            "pending_cell_count": len(pending),
+            "total_cell_count": total,
+            "runtime_series_status_counts": dict(sorted(counts.items())),
+        },
+        "runtime_series": runtime_series,
+    }
+
+
+def load_runtime_progress(path: Path) -> dict[str, Any]:
+    """Read and authenticate one atomically published sparse progress report."""
+
+    payload = _read_json(path, context="MadGraph runtime progress")
+    if (
+        payload.get("kind") != PROGRESS_KIND
+        or payload.get("schema_version") != SCHEMA_VERSION
+    ):
+        raise SelectedMadGraphError("MadGraph runtime progress has the wrong schema")
+    validate_measurement_host(
+        payload.get("host"), context="MadGraph runtime progress host"
+    )
+    status = payload.get("status")
+    if status not in {"running", "complete", "complete-with-failures"}:
+        raise SelectedMadGraphError("MadGraph runtime progress has an invalid status")
+    source = _mapping(
+        payload.get("source_report"), context="MadGraph runtime progress source"
+    )
+    source_path = source.get("path")
+    source_sha256 = source.get("sha256")
+    if (
+        not isinstance(source_path, str)
+        or not source_path
+        or not isinstance(source_sha256, str)
+        or re.fullmatch(r"[0-9a-f]{64}", source_sha256) is None
+    ):
+        raise SelectedMadGraphError(
+            "MadGraph runtime progress has invalid source-report provenance"
+        )
+    policy = _mapping(
+        payload.get("policy"), context="MadGraph runtime progress policy"
+    )
+    helicity_workload = _declared_helicity_workload(policy)
+    raw_multiplicities = policy.get("final_state_multiplicities")
+    if (
+        not isinstance(raw_multiplicities, Sequence)
+        or isinstance(raw_multiplicities, str)
+        or not raw_multiplicities
+        or any(
+            isinstance(n, bool) or not isinstance(n, int) or n < 2
+            for n in raw_multiplicities
+        )
+    ):
+        raise SelectedMadGraphError(
+            "MadGraph runtime progress has invalid multiplicities"
+        )
+    multiplicities = tuple(int(n) for n in raw_multiplicities)
+    if tuple(sorted(set(multiplicities))) != multiplicities:
+        raise SelectedMadGraphError(
+            "MadGraph runtime progress multiplicities are not sorted and unique"
+        )
+    if policy.get("process_families") != list(FAMILIES):
+        raise SelectedMadGraphError(
+            "MadGraph runtime progress has invalid process families"
+        )
+    if (
+        policy.get("maximum_measured_multiplicity")
+        != MAX_PROTOCOL_MEASURED_MULTIPLICITY
+        or policy.get("family_maximum_measured_multiplicity")
+        != protocol_measured_multiplicity_limits()
+        or policy.get("higher_multiplicity_policy")
+        != "not-applicable-protocol-scope"
+    ):
+        raise SelectedMadGraphError(
+            "MadGraph runtime progress has invalid multiplicity scope"
+        )
+    raw_series = _mapping(
+        payload.get("runtime_series"), context="MadGraph runtime progress series"
+    )
+    if set(raw_series) != set(FAMILIES):
+        raise SelectedMadGraphError(
+            "MadGraph runtime progress series has invalid process families"
+        )
+    completed_identities: set[tuple[str, int]] = set()
+    counts: Counter[str] = Counter()
+    for family in FAMILIES:
+        family_series = _mapping(
+            raw_series.get(family),
+            context=f"MadGraph runtime progress series.{family}",
+        )
+        if set(family_series) != {MODE}:
+            raise SelectedMadGraphError(
+                f"MadGraph runtime progress series.{family} has invalid modes"
+            )
+        mode_cells = _mapping(
+            family_series.get(MODE),
+            context=f"MadGraph runtime progress series.{family}.{MODE}",
+        )
+        for raw_n, raw_cell in mode_cells.items():
+            try:
+                n = int(raw_n)
+            except (TypeError, ValueError) as error:
+                raise SelectedMadGraphError(
+                    "MadGraph runtime progress has an invalid cell key"
+                ) from error
+            if str(n) != raw_n or n not in multiplicities:
+                raise SelectedMadGraphError(
+                    "MadGraph runtime progress has an out-of-policy cell"
+                )
+            cell = _mapping(
+                raw_cell,
+                context=f"MadGraph runtime progress series.{family}.{MODE}.{n}",
+            )
+            expected = _progress_cell_identity(
+                family, n, helicity_workload=helicity_workload
+            )
+            if any(cell.get(key) != value for key, value in expected.items()):
+                raise SelectedMadGraphError(
+                    "MadGraph runtime progress cell identity is invalid"
+                )
+            cell_status = cell.get("status")
+            if cell_status not in {
+                "measured",
+                "failed",
+                "skipped",
+                "not-applicable",
+            }:
+                raise SelectedMadGraphError(
+                    "MadGraph runtime progress cell status is invalid"
+                )
+            is_protocol_scoped = not protocol_measures_multiplicity(family, n)
+            if (cell_status == "not-applicable") != is_protocol_scoped:
+                raise SelectedMadGraphError(
+                    "MadGraph runtime progress protocol scope is invalid"
+                )
+            completed_identities.add((family, n))
+            counts[str(cell_status)] += 1
+    raw_pending = payload.get("pending_cells")
+    if not isinstance(raw_pending, Sequence) or isinstance(raw_pending, str):
+        raise SelectedMadGraphError(
+            "MadGraph runtime progress pending_cells is invalid"
+        )
+    pending_identities: set[tuple[str, int]] = set()
+    for raw_pending_cell in raw_pending:
+        pending_cell = _mapping(
+            raw_pending_cell, context="MadGraph runtime progress pending cell"
+        )
+        family = pending_cell.get("family")
+        n = pending_cell.get("n")
+        if (
+            family not in FAMILIES
+            or isinstance(n, bool)
+            or not isinstance(n, int)
+            or n not in multiplicities
+            or any(
+                pending_cell.get(key) != value
+                for key, value in _progress_cell_identity(
+                    str(family), n, helicity_workload=helicity_workload
+                ).items()
+            )
+        ):
+            raise SelectedMadGraphError(
+                "MadGraph runtime progress pending cell identity is invalid"
+            )
+        pending_identities.add((str(family), n))
+    all_identities = {
+        (family, n) for family in FAMILIES for n in multiplicities
+    }
+    if (
+        len(pending_identities) != len(raw_pending)
+        or completed_identities & pending_identities
+        or completed_identities | pending_identities != all_identities
+    ):
+        raise SelectedMadGraphError(
+            "MadGraph runtime progress completed/pending partition is invalid"
+        )
+    summary = _mapping(
+        payload.get("summary"), context="MadGraph runtime progress summary"
+    )
+    expected_summary = {
+        "completed_cell_count": len(completed_identities),
+        "pending_cell_count": len(pending_identities),
+        "total_cell_count": len(all_identities),
+        "runtime_series_status_counts": dict(sorted(counts.items())),
+    }
+    if dict(summary) != expected_summary:
+        raise SelectedMadGraphError("MadGraph runtime progress summary is invalid")
+    current = payload.get("current_cell")
+    if current is not None:
+        current_cell = _mapping(
+            current, context="MadGraph runtime progress current_cell"
+        )
+        family = current_cell.get("family")
+        n = current_cell.get("n")
+        if (
+            family not in FAMILIES
+            or isinstance(n, bool)
+            or not isinstance(n, int)
+            or (str(family), n) not in pending_identities
+            or any(
+                current_cell.get(key) != value
+                for key, value in _progress_cell_identity(
+                    str(family), n, helicity_workload=helicity_workload
+                ).items()
+            )
+            or not isinstance(current_cell.get("stage"), str)
+            or not current_cell["stage"]
+        ):
+            raise SelectedMadGraphError(
+                "MadGraph runtime progress current_cell is invalid"
+            )
+    if status == "running" and not pending_identities:
+        raise SelectedMadGraphError(
+            "running MadGraph runtime progress has no pending cells"
+        )
+    if status != "running" and (pending_identities or current is not None):
+        raise SelectedMadGraphError(
+            "terminal MadGraph runtime progress still has pending work"
+        )
+    expected_status = "complete-with-failures" if counts["failed"] else "complete"
+    if status != "running" and status != expected_status:
+        raise SelectedMadGraphError(
+            "terminal MadGraph runtime progress status disagrees with its cells"
+        )
+    return payload
+
+
+def _default_progress_output(output: Path) -> Path:
+    return output.with_name(f"{output.stem}.progress.json")
+
+
+def build_runtime_report(
+    *,
+    source_report: Path,
+    cache_dir: Path,
+    fc: str,
+    fflags: str,
+    make: str = os.environ.get("MAKE", "make"),
+    timeout_seconds: float,
+    mg5_root: Path,
+    family: str | None = None,
+    min_n: int = 2,
+    max_n: int = 9,
+    multiplicities: Sequence[int] | None = None,
+    memory_limit_gib: float = MAX_MEMORY_GIB,
+    target_seconds: float = TARGET_SECONDS,
+    warm_sample_count: int = WARM_SAMPLE_COUNT,
+    keep_generated: bool = False,
+    progress_output: Path | None = None,
+    helicity_workload: str = "fixed",
+) -> dict[str, Any]:
+    resolved_cache = cache_dir.expanduser().resolve(strict=False)
+    lock = _acquire_cache_lock(resolved_cache)
+    try:
+        return _build_runtime_report_locked(
+            source_report=source_report,
+            cache_dir=resolved_cache,
+            fc=fc,
+            fflags=fflags,
+            make=make,
+            timeout_seconds=timeout_seconds,
+            mg5_root=mg5_root,
+            family=family,
+            min_n=min_n,
+            max_n=max_n,
+            multiplicities=multiplicities,
+            memory_limit_gib=memory_limit_gib,
+            target_seconds=target_seconds,
+            warm_sample_count=warm_sample_count,
+            keep_generated=keep_generated,
+            progress_output=progress_output,
+            helicity_workload=helicity_workload,
+        )
+    finally:
+        lock.close()
+
+
+def _build_runtime_report_locked(
+    *,
+    source_report: Path,
+    cache_dir: Path,
+    fc: str,
+    fflags: str,
+    make: str,
+    timeout_seconds: float,
+    mg5_root: Path,
+    family: str | None = None,
+    min_n: int = 2,
+    max_n: int = 9,
+    multiplicities: Sequence[int] | None = None,
+    memory_limit_gib: float = MAX_MEMORY_GIB,
+    target_seconds: float = TARGET_SECONDS,
+    warm_sample_count: int = WARM_SAMPLE_COUNT,
+    keep_generated: bool = False,
+    progress_output: Path | None = None,
+    helicity_workload: str = "fixed",
+) -> dict[str, Any]:
+    _workload_label(helicity_workload)
+    if family is not None and family not in FAMILIES:
+        raise SelectedMadGraphError(f"unsupported family {family!r}")
+    raw_multiplicities: Sequence[int] = (
+        multiplicities if multiplicities is not None else range(min_n, max_n + 1)
+    )
+    if not raw_multiplicities or any(
+        isinstance(n, bool) or not isinstance(n, int) or n < 2
+        for n in raw_multiplicities
+    ):
+        raise SelectedMadGraphError("multiplicities must be integers >=2")
+    selected_multiplicities = tuple(sorted(set(raw_multiplicities)))
+    if (
+        isinstance(timeout_seconds, bool)
+        or not math.isfinite(timeout_seconds)
+        or timeout_seconds <= 0.0
+    ):
+        raise SelectedMadGraphError("generation timeout must be positive and finite")
+    if (
+        isinstance(memory_limit_gib, bool)
+        or not math.isfinite(memory_limit_gib)
+        or memory_limit_gib <= 0.0
+    ):
+        raise SelectedMadGraphError("memory limit must be positive and finite")
+    if (
+        isinstance(target_seconds, bool)
+        or not math.isfinite(target_seconds)
+        or target_seconds <= 0.0
+    ):
+        raise SelectedMadGraphError("target seconds must be positive and finite")
+    if (
+        isinstance(warm_sample_count, bool)
+        or not isinstance(warm_sample_count, int)
+        or warm_sample_count < 1
+    ):
+        raise SelectedMadGraphError("warm sample count must be positive")
+    mg5_root = mg5_root.expanduser().resolve(strict=True)
+    if (
+        not (mg5_root / "bin" / "mg5_aMC").is_file()
+        or not (mg5_root / "VERSION").is_file()
+    ):
+        raise SelectedMadGraphError(f"invalid MadGraph installation: {mg5_root}")
+    if not WATCHDOG.is_file():
+        raise SelectedMadGraphError(f"memory watchdog is missing: {WATCHDOG}")
+    cache_dir = cache_dir.expanduser().resolve(strict=False)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    selected_families = FAMILIES if family is None else (family,)
+    measured_multiplicities = {
+        name: tuple(
+            n
+            for n in selected_multiplicities
+            if protocol_measures_multiplicity(name, n)
+        )
+        for name in selected_families
+    }
+    runtime_series: dict[str, dict[str, dict[str, Any]]] = {
+        name: {MODE: {}} for name in FAMILIES
+    }
+    source = load_source_selection(
+        source_report,
+        multiplicities=measured_multiplicities,
+        families=selected_families,
+        helicity_workload=helicity_workload,
+    )
+    local_host = measurement_host_identity()
+    if source.measurement_host is not None and source.measurement_host != local_host:
+        raise SelectedMadGraphError(
+            "source campaign and MadGraph runtime must use the same measurement host"
+        )
+    started_at_utc = datetime.now(UTC).isoformat()
+    progress_path = (
+        progress_output.expanduser().resolve(strict=False)
+        if progress_output is not None
+        else None
+    )
+
+    def load_reusable_checkpoint(name: str, n: int) -> dict[str, Any] | None:
+        if (
+            name not in selected_families
+            or not protocol_measures_multiplicity(name, n)
+            or n in source.unavailable[name]
+        ):
+            return None
+        selected = source.cells[name][n]
+        cell_dir = cache_dir / name / f"n{n}"
+        checkpoint = cell_dir / "cell.json"
+        if not checkpoint.is_file():
+            return None
+        identity = _checkpoint_identity(
+            source,
+            selected,
+            mg5_root,
+            fc,
+            fflags,
+            make,
+            timeout_seconds,
+            memory_limit_gib,
+            target_seconds,
+            warm_sample_count,
+        )
+        cell = _load_checkpoint_cell(
+            checkpoint,
+            identity=identity,
+            cell_dir=cell_dir,
+            keep_generated=keep_generated,
+        )
+        if cell is None:
+            return None
+        cell, provenance_changed = _rebind_source_provenance(
+            cell, source=source, selected=selected
+        )
+        if provenance_changed:
+            _json_atomic(checkpoint, {"checkpoint_identity": identity, "cell": cell})
+        return cell
+
+    # Make a resumed/expanded run's first atomic progress snapshot at least as
+    # informative as its reusable cache.  Otherwise the initial empty running
+    # snapshot temporarily hides a previously published terminal prefix.
+    for name in selected_families:
+        for n in selected_multiplicities:
+            reusable = load_reusable_checkpoint(name, n)
+            if reusable is not None:
+                runtime_series[name][MODE][str(n)] = reusable
+
+    def publish_progress(current_cell: Mapping[str, Any] | None) -> None:
+        if progress_path is None:
+            return
+        progress = _runtime_progress_report(
+            source=source,
+            runtime_series=runtime_series,
+            selected_multiplicities=selected_multiplicities,
+            selected_families=selected_families,
+            timeout_seconds=timeout_seconds,
+            memory_limit_gib=memory_limit_gib,
+            target_seconds=target_seconds,
+            warm_sample_count=warm_sample_count,
+            started_at_utc=started_at_utc,
+            current_cell=current_cell,
+        )
+        _json_atomic(progress_path, progress)
+
+    publish_progress(None)
+    for name in FAMILIES:
+        if name not in selected_families:
+            for n in selected_multiplicities:
+                if not protocol_measures_multiplicity(name, n):
+                    publish_progress(
+                        _progress_cell_identity(
+                            name, n, helicity_workload=helicity_workload
+                        )
+                        | {"stage": "protocol-scope-not-applicable"}
+                    )
+                    runtime_series[name][MODE][str(n)] = _protocol_scope_cell(
+                        name, n, helicity_workload=helicity_workload
+                    )
+                    publish_progress(None)
+                    continue
+                publish_progress(
+                    _progress_cell_identity(
+                        name, n, helicity_workload=helicity_workload
+                    )
+                    | {"stage": "diagnostic-family-omission"}
+                )
+                runtime_series[name][MODE][str(n)] = _diagnostic_skip_cell(
+                    name,
+                    n,
+                    "family omitted by diagnostic selection",
+                    helicity_workload=helicity_workload,
+                )
+                publish_progress(None)
+            continue
+        failure_n: int | None = None
+        failure_reason = ""
+        for n in selected_multiplicities:
+            if not protocol_measures_multiplicity(name, n):
+                publish_progress(
+                    _progress_cell_identity(
+                        name, n, helicity_workload=helicity_workload
+                    )
+                    | {"stage": "protocol-scope-not-applicable"}
+                )
+                runtime_series[name][MODE][str(n)] = _protocol_scope_cell(
+                    name, n, helicity_workload=helicity_workload
+                )
+                publish_progress(None)
+                continue
+            if failure_n is not None:
+                publish_progress(
+                    _progress_cell_identity(
+                        name, n, helicity_workload=helicity_workload
+                    )
+                    | {"stage": "frontier-skip"}
+                )
+                runtime_series[name][MODE][str(n)] = _frontier_cell(
+                    name,
+                    n,
+                    failure_n=failure_n,
+                    reason=failure_reason,
+                    helicity_workload=helicity_workload,
+                )
+                publish_progress(None)
+                continue
+            reusable = runtime_series[name][MODE].get(str(n))
+            if reusable is not None:
+                if (
+                    reusable.get("status") == "failed"
+                    and reusable.get("censors_higher_multiplicities") is True
+                ):
+                    failure_n = n
+                    failure_reason = str(reusable.get("failure_reason"))
+                continue
+            unavailable = source.unavailable[name].get(n)
+            if unavailable is not None:
+                publish_progress(
+                    _progress_cell_identity(
+                        name, n, helicity_workload=helicity_workload
+                    )
+                    | {
+                        "stage": (
+                            "source-dependency-frontier"
+                            if unavailable.censors_higher_multiplicities
+                            else "source-dependency-unavailable"
+                        )
+                    }
+                )
+                cell = _dependency_failure_cell(
+                    name,
+                    n,
+                    unavailable.reason,
+                    helicity_workload=helicity_workload,
+                    censors_higher_multiplicities=(
+                        unavailable.censors_higher_multiplicities
+                    ),
+                )
+                runtime_series[name][MODE][str(n)] = cell
+                if unavailable.censors_higher_multiplicities:
+                    failure_n = n
+                    failure_reason = str(cell["failure_reason"])
+                publish_progress(None)
+                continue
+            selected = source.cells[name][n]
+            cell_dir = cache_dir / name / f"n{n}"
+            cell_dir.mkdir(parents=True, exist_ok=True)
+            checkpoint = cell_dir / "cell.json"
+            publish_progress(
+                _progress_cell_identity(
+                    name, n, helicity_workload=helicity_workload
+                )
+                | {
+                    "stage": (
+                        "checkpoint-reuse"
+                        if checkpoint.is_file()
+                        else "generate-build-benchmark"
+                    )
+                }
+            )
+            identity = _checkpoint_identity(
+                source,
+                selected,
+                mg5_root,
+                fc,
+                fflags,
+                make,
+                timeout_seconds,
+                memory_limit_gib,
+                target_seconds,
+                warm_sample_count,
+            )
+            cell: dict[str, Any] | None = None
+            if checkpoint.is_file():
+                cell = _load_checkpoint_cell(
+                    checkpoint,
+                    identity=identity,
+                    cell_dir=cell_dir,
+                    keep_generated=keep_generated,
+                )
+                if cell is not None:
+                    cell, provenance_changed = _rebind_source_provenance(
+                        cell, source=source, selected=selected
+                    )
+                    if provenance_changed:
+                        _json_atomic(
+                            checkpoint,
+                            {"checkpoint_identity": identity, "cell": cell},
+                        )
+            if cell is None:
+                generation, generation_watchdog = _generation_attempt(
+                    selected=selected,
+                    cell_dir=cell_dir,
+                    mg5_root=mg5_root,
+                    timeout=timeout_seconds,
+                    limit_gib=memory_limit_gib,
+                )
+                if generation.get("status") != "measured":
+                    category = str(
+                        generation.get("failure_category") or "generation-error"
+                    )
+                    reason = str(
+                        generation.get("failure_reason") or "MadGraph generation failed"
+                    )
+                    if category not in RESOURCE_FRONTIER_CATEGORIES:
+                        if not keep_generated:
+                            _prune_cell_generated(cell_dir)
+                        raise SelectedMadGraphError(
+                            f"{name}/n{n} generation diagnostic ({category}): {reason}"
+                        )
+                    cell = _failure_cell(selected, category, reason)
+                else:
+                    try:
+                        cell = _measure_generated_cell(
+                            source=source,
+                            selected=selected,
+                            generation=generation,
+                            generation_watchdog=generation_watchdog,
+                            cell_dir=cell_dir,
+                            fc=fc,
+                            fflags=fflags,
+                            make=make,
+                            limit_gib=memory_limit_gib,
+                            mg5_root=mg5_root,
+                            cold_to_ready_limit_seconds=timeout_seconds,
+                            target_seconds=target_seconds,
+                            warm_sample_count=warm_sample_count,
+                        )
+                    except ResourceFrontierError as error:
+                        cell = _failure_cell(selected, error.category, str(error))
+                    except (OSError, SelectedMadGraphError) as error:
+                        if not keep_generated:
+                            _prune_cell_generated(cell_dir)
+                        context = (
+                            "campaign filesystem ran out of space"
+                            if _is_disk_exhaustion(error)
+                            else "MadGraph build/runtime diagnostic failed"
+                        )
+                        raise SelectedMadGraphError(
+                            f"{name}/n{n}: {context}: {error}"
+                        ) from error
+                _json_atomic(
+                    checkpoint, {"checkpoint_identity": identity, "cell": cell}
+                )
+                if not keep_generated:
+                    _prune_cell_generated(cell_dir)
+            runtime_series[name][MODE][str(n)] = cell
+            if (
+                cell.get("status") == "failed"
+                and cell.get("censors_higher_multiplicities") is True
+            ):
+                failure_n = n
+                failure_reason = str(cell.get("failure_reason"))
+            publish_progress(None)
+
+    counts = Counter(
+        str(cell.get("status"))
+        for family_series in runtime_series.values()
+        for mode_cells in family_series.values()
+        for cell in mode_cells.values()
+    )
+    return {
+        "kind": KIND,
+        "schema_version": SCHEMA_VERSION,
+        "status": (
+            "complete" if counts.get("failed", 0) == 0 else "complete-with-failures"
+        ),
+        "failure_count": counts.get("failed", 0),
+        "created_at_utc": datetime.now(UTC).isoformat(),
+        "policy": _runtime_policy(
+            selected_multiplicities,
+            timeout_seconds=timeout_seconds,
+            memory_limit_gib=memory_limit_gib,
+            target_seconds=target_seconds,
+            warm_sample_count=warm_sample_count,
+            helicity_workload=helicity_workload,
+        ),
+        "host": local_host,
+        "summary": {"runtime_series_status_counts": dict(sorted(counts.items()))},
+        "runtime_series": runtime_series,
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--source-report",
+        type=Path,
+        required=True,
+        help="authenticated campaign report supplying event and helicity selections",
+    )
+    parser.add_argument("--cache-dir", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument(
+        "--progress-output",
+        type=Path,
+        help=(
+            "atomic sparse progress JSON (default: <output-stem>.progress.json)"
+        ),
+    )
+    parser.add_argument("--mg5-root", type=Path, required=True)
+    parser.add_argument("--fc", default=os.environ.get("FC", "gfortran"))
+    parser.add_argument("--fflags", default="-O3")
+    parser.add_argument("--make", default=os.environ.get("MAKE", "make"))
+    parser.add_argument(
+        "--generation-timeout-seconds",
+        "--timeout-seconds",
+        dest="timeout_seconds",
+        type=float,
+        default=DEFAULT_GENERATION_TIMEOUT_SECONDS,
+    )
+    parser.add_argument("--memory-limit-gib", type=float, default=MAX_MEMORY_GIB)
+    parser.add_argument(
+        "--target-seconds",
+        type=float,
+        default=TARGET_SECONDS,
+        help="target post-calibration runtime for the timed MadGraph sample",
+    )
+    parser.add_argument("--family", choices=FAMILIES)
+    parser.add_argument("--min-n", type=int, default=2)
+    parser.add_argument("--max-n", type=int, default=9)
+    parser.add_argument(
+        "--multiplicity",
+        dest="multiplicities",
+        action="append",
+        type=int,
+        help="exact final-state multiplicity; repeat for a sparse scan",
+    )
+    parser.add_argument(
+        "--protocol-scope-multiplicity",
+        dest="protocol_scope_multiplicities",
+        action="append",
+        type=int,
+        help=(
+            "requested multiplicity recorded as not-applicable without "
+            "measurement when outside the selected family protocol scope; "
+            "repeat for a sparse final-plot scan"
+        ),
+    )
+    parser.add_argument("--keep-generated", action="store_true")
+    parser.add_argument(
+        "--compare-helicity-sums",
+        action="store_true",
+        help=(
+            "benchmark generated SMATRIX(P,ANS) with USERHEL=-1 and warmed "
+            "GOODHEL pruning instead of one fixed direct-MATRIX helicity"
+        ),
+    )
+    return parser
+
+
+def _worker_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--mg5-root", type=Path, required=True)
+    parser.add_argument("--generated-output", type=Path, required=True)
+    parser.add_argument("--worker-result", type=Path, required=True)
+    parser.add_argument("--process", required=True)
+    parser.add_argument("--generation-timeout-seconds", type=float, required=True)
+    return parser
+
+
+def _timeout_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--timeout-seconds", type=float, required=True)
+    parser.add_argument("command", nargs=argparse.REMAINDER)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    raw = list(sys.argv[1:] if argv is None else argv)
+    if raw and raw[0] == "_run-with-timeout":
+        try:
+            return _timeout_worker(_timeout_parser().parse_args(raw[1:]))
+        except SelectedMadGraphError as error:
+            print(f"MadGraph benchmark error: {error}", file=sys.stderr)
+            return 2
+    if raw and raw[0] == "_generate-cell":
+        try:
+            return _generation_worker(_worker_parser().parse_args(raw[1:]))
+        except SelectedMadGraphError as error:
+            print(f"MadGraph benchmark error: {error}", file=sys.stderr)
+            return 2
+    arguments = _parser().parse_args(raw)
+    try:
+        measured = tuple(arguments.multiplicities or ())
+        scoped = tuple(arguments.protocol_scope_multiplicities or ())
+        selected_families = (
+            FAMILIES if arguments.family is None else (arguments.family,)
+        )
+        if scoped and any(
+            any(
+                protocol_measures_multiplicity(family, n)
+                for family in selected_families
+            )
+            for n in scoped
+        ):
+            raise SelectedMadGraphError(
+                "--protocol-scope-multiplicity accepts only multiplicities outside "
+                "the selected family protocol scope"
+            )
+        if measured and any(
+            not any(
+                protocol_measures_multiplicity(family, n)
+                for family in selected_families
+            )
+            for n in measured
+        ):
+            raise SelectedMadGraphError(
+                "--multiplicity must measure at least one selected family; use "
+                "--protocol-scope-multiplicity for pure protocol-scope cells"
+            )
+        if set(measured) & set(scoped):
+            raise SelectedMadGraphError(
+                "measured and protocol-scoped multiplicities must be disjoint"
+            )
+        selected_multiplicities = (
+            tuple(sorted(set(measured) | set(scoped)))
+            if measured or scoped
+            else None
+        )
+        output = arguments.output.expanduser().resolve(strict=False)
+        progress_output = (
+            arguments.progress_output.expanduser().resolve(strict=False)
+            if arguments.progress_output is not None
+            else _default_progress_output(output)
+        )
+        report = build_runtime_report(
+            source_report=arguments.source_report,
+            cache_dir=arguments.cache_dir,
+            fc=arguments.fc,
+            fflags=arguments.fflags,
+            make=arguments.make,
+            timeout_seconds=arguments.timeout_seconds,
+            family=arguments.family,
+            min_n=arguments.min_n,
+            max_n=arguments.max_n,
+            multiplicities=selected_multiplicities,
+            mg5_root=arguments.mg5_root,
+            memory_limit_gib=arguments.memory_limit_gib,
+            target_seconds=arguments.target_seconds,
+            keep_generated=arguments.keep_generated,
+            progress_output=progress_output,
+            helicity_workload=(
+                "sum" if arguments.compare_helicity_sums else "fixed"
+            ),
+        )
+        _json_atomic(output, report)
+    except SelectedMadGraphError as error:
+        print(f"MadGraph benchmark error: {error}", file=sys.stderr)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/fft_numerical_acceptance.py b/pyamplicol/tools/developer/fft_numerical_acceptance.py
new file mode 100644
index 0000000000..00a7dc3313
--- /dev/null
+++ b/pyamplicol/tools/developer/fft_numerical_acceptance.py
@@ -0,0 +1,2062 @@
+# SPDX-License-Identifier: 0BSD
+"""Opt-in process-table numerical acceptance for FFT colour contraction.
+
+This gate is deliberately separate from the ordinary numerical-acceptance
+campaign.  It constructs its process surface from the performance catalog,
+discovers one nonzero helicity with a cached direct oracle, and compares direct
+and symmetric-group-FFT colour contraction without ever generating an artifact
+per process.  Recurrence artifacts specialize that tuple at generation time;
+on-the-fly artifacts retain complete helicity coverage and apply the identical
+recorded tuple through the runtime selector API.
+
+The real campaign is intentionally entered only through
+``just fft-numerical-acceptance``.  ``--dry-run`` authenticates the frozen
+MadGraph fixture and prints the complete planned comparison surface without
+loading the native runtime or writing files.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import re
+import sys
+import tomllib
+import uuid
+from collections import OrderedDict
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from decimal import Decimal, localcontext
+from pathlib import Path
+from typing import Generic, Literal, TypeVar, cast
+
+ROOT = Path(__file__).resolve().parents[2]
+if __package__ in {None, ""}:
+    sys.path.insert(0, str(ROOT))
+
+from tools.developer.numerical_acceptance import (  # noqa: E402
+    DEFAULT_FIXTURE,
+    POINT_SEED,
+    RELATIVE_TOLERANCE,
+    current_model_identity,
+    prepare_ufo_sm_model,
+    validation_momenta,
+)
+from tools.developer.reference_capture.common import canonical_decimal  # noqa: E402
+from tools.performance_report.catalog import PROCESS_FAMILIES  # noqa: E402
+from tools.performance_report.models import (  # noqa: E402
+    Accuracy,
+    open_quark_line_count,
+)
+from tools.performance_report.selector_policy import (  # noqa: E402
+    _preferred_helicities,
+    fixed_selector_helicity,
+    selector_helicity_id,
+)
+
+GATE_KIND = "pyamplicol-fft-numerical-acceptance"
+GATE_SCHEMA_VERSION = 1
+SELECTED_MAX_N_FINAL = 5
+TOTAL_MAX_N_FINAL = 4
+SELECTED_CASE_COUNT = 47
+TOTAL_CASE_COUNT = 33
+
+MethodName = Literal["direct", "symmetric-group-fft"]
+ModelName = Literal["built-in-sm", "ufo-sm"]
+ModeName = Literal["recurrence", "on-the-fly"]
+AccuracyName = Literal["full", "nlc"]
+SelectionExecution = Literal[
+    "generation-specialized",
+    "runtime-query-complete-coverage",
+]
+
+METHODS: tuple[MethodName, ...] = ("direct", "symmetric-group-fft")
+MODELS: tuple[ModelName, ...] = ("built-in-sm", "ufo-sm")
+MODES: tuple[ModeName, ...] = ("recurrence", "on-the-fly")
+ACCURACIES: tuple[AccuracyName, ...] = ("full", "nlc")
+
+_PURE_ADJOINT_REFLECTION_CASE_ID = "catalog:gg_gluons:n2"
+_OPEN_LINE_REFLECTION_CASE_ID = "catalog:gg_tt_jets:n2"
+# Query-family closures retain one amplitude destination per requested colour;
+# the certified reflection fold is visible in the shared current finalizations.
+_REFLECTION_CENSUS_FIELDS = (
+    "union_unique_current_count",
+    "union_contribution_rows",
+    "union_finalization_rows",
+)
+_EXPECTED_PURE_ADJOINT_REFLECTION_CENSUS = {
+    "direct": (22, 36, 6),
+    "symmetric-group-fft": (13, 18, 3),
+}
+
+
+class FFTAcceptanceError(RuntimeError):
+    """The FFT acceptance contract could not be executed or authenticated."""
+
+
+class FFTAcceptanceMismatch(AssertionError):
+    """At least one strict numerical or nonzero assertion failed."""
+
+
+@dataclass(frozen=True, slots=True)
+class CatalogCase:
+    case_id: str
+    family_id: int
+    family_key: str
+    n_final: int
+    process: str
+
+    @property
+    def artifact_name(self) -> str:
+        return self.case_id.replace(":", "_").replace("-", "_")
+
+
+def _symmetric_group_degree(case: CatalogCase) -> int:
+    """Return the nontrivial group degree implied by one catalog process."""
+
+    initial, separator, final = case.process.partition(">")
+    if not separator:
+        raise FFTAcceptanceError(
+            f"catalog case {case.case_id} has no initial/final separator"
+        )
+    tokens = (*initial.split(), *final.split())
+    adjoint_count = sum(token == "g" for token in tokens)
+    try:
+        open_line_count = open_quark_line_count(case.process)
+    except ValueError as error:
+        raise FFTAcceptanceError(
+            f"catalog case {case.case_id} has invalid open-line content"
+        ) from error
+    return adjoint_count if open_line_count else max(adjoint_count - 1, 0)
+
+
+def _expected_inspection_method(
+    request_method: MethodName,
+    case: CatalogCase,
+) -> str | None:
+    if request_method == "direct":
+        return None
+    return "symmetric-group-fourier" if _symmetric_group_degree(case) >= 2 else None
+
+
+def catalog_cases(max_n_final: int = SELECTED_MAX_N_FINAL) -> tuple[CatalogCase, ...]:
+    """Derive the contracted-colour process surface from the live catalog."""
+
+    if max_n_final < 1:
+        raise ValueError("max_n_final must be positive")
+    cases: list[CatalogCase] = []
+    for n_final in range(1, max_n_final + 1):
+        for family in sorted(PROCESS_FAMILIES, key=lambda item: item.identifier):
+            process = family.process(n_final)
+            if process is None or n_final > family.maximum_n(Accuracy.FULL):
+                continue
+            cases.append(
+                CatalogCase(
+                    case_id=f"catalog:{family.key}:n{n_final}",
+                    family_id=family.identifier,
+                    family_key=family.key,
+                    n_final=n_final,
+                    process=process,
+                )
+            )
+    result = tuple(cases)
+    expected = {
+        TOTAL_MAX_N_FINAL: TOTAL_CASE_COUNT,
+        SELECTED_MAX_N_FINAL: SELECTED_CASE_COUNT,
+    }.get(max_n_final)
+    if expected is not None and len(result) != expected:
+        raise FFTAcceptanceError(
+            f"the performance catalog through n_final={max_n_final} must contain "
+            f"{expected} contracted-colour cases; observed {len(result)}"
+        )
+    return result
+
+
+@dataclass(frozen=True, slots=True)
+class FrozenFullCase:
+    case: CatalogCase
+    momenta: tuple[tuple[Decimal, ...], ...]
+    expected_full: Decimal
+
+
+@dataclass(frozen=True, slots=True)
+class FrozenFullEvidence:
+    """The immutable FullColour subset of the tracked MadGraph capture."""
+
+    path: Path
+    madgraph_version: str
+    model_source_sha256: str
+    driver_sha256: str
+    cases: tuple[FrozenFullCase, ...]
+
+    def case(self, case_id: str) -> FrozenFullCase:
+        for case in self.cases:
+            if case.case.case_id == case_id:
+                return case
+        raise KeyError(case_id)
+
+
+def _mapping(value: object, where: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise FFTAcceptanceError(f"{where} must be an object")
+    return cast(Mapping[str, object], value)
+
+
+def _reflection_census_triplet(
+    census: Mapping[str, object],
+    *,
+    label: str,
+) -> tuple[int, int, int]:
+    if (
+        census.get("basis") != "shared-query-family-union-v1"
+        or census.get("scope") != "active-family-union"
+    ):
+        raise FFTAcceptanceError(
+            f"{label} has the wrong active-family census identity: "
+            f"basis={census.get('basis')!r}, scope={census.get('scope')!r}"
+        )
+    values: list[int] = []
+    for field in _REFLECTION_CENSUS_FIELDS:
+        value = census.get(field)
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise FFTAcceptanceError(
+                f"{label} has invalid {field}: {value!r}"
+            )
+        values.append(value)
+    return cast(tuple[int, int, int], tuple(values))
+
+
+def validate_on_the_fly_reflection_census(
+    *,
+    pure_adjoint_direct: Mapping[str, object],
+    pure_adjoint_fft: Mapping[str, object],
+    open_line_direct: Mapping[str, object],
+    open_line_fft: Mapping[str, object],
+) -> dict[str, object]:
+    """Lock the demonstrated n=2 production reflection boundary."""
+
+    pure = {
+        "direct": _reflection_census_triplet(
+            pure_adjoint_direct,
+            label=f"{_PURE_ADJOINT_REFLECTION_CASE_ID} direct",
+        ),
+        "symmetric-group-fft": _reflection_census_triplet(
+            pure_adjoint_fft,
+            label=f"{_PURE_ADJOINT_REFLECTION_CASE_ID} symmetric-group-fft",
+        ),
+    }
+    for method, expected in _EXPECTED_PURE_ADJOINT_REFLECTION_CENSUS.items():
+        observed = pure[method]
+        if observed != expected:
+            raise FFTAcceptanceError(
+                f"{_PURE_ADJOINT_REFLECTION_CASE_ID} {method} active-family census "
+                f"{_REFLECTION_CENSUS_FIELDS!r} is {observed!r}; expected {expected!r}"
+            )
+
+    open_direct = dict(open_line_direct)
+    open_fft = dict(open_line_fft)
+    open_triplets = {
+        "direct": _reflection_census_triplet(
+            open_direct,
+            label=f"{_OPEN_LINE_REFLECTION_CASE_ID} direct",
+        ),
+        "symmetric-group-fft": _reflection_census_triplet(
+            open_fft,
+            label=f"{_OPEN_LINE_REFLECTION_CASE_ID} symmetric-group-fft",
+        ),
+    }
+    if open_direct != open_fft:
+        differences = {
+            field: {
+                "direct": open_direct.get(field),
+                "symmetric-group-fft": open_fft.get(field),
+            }
+            for field in sorted(open_direct.keys() | open_fft.keys())
+            if open_direct.get(field) != open_fft.get(field)
+        }
+        raise FFTAcceptanceError(
+            f"{_OPEN_LINE_REFLECTION_CASE_ID} has a nontrivial FFT workspace but "
+            "an open color line, so its direct and FFT active-family censuses "
+            f"must be identical; differences={differences!r}"
+        )
+
+    return {
+        "basis": "selected-helicity-production-active-family-census-v1",
+        "source": "Runtime.inspect().on_the_fly_state.active_family_union_census",
+        "pure_adjoint": {
+            "case_id": _PURE_ADJOINT_REFLECTION_CASE_ID,
+            "fields": list(_REFLECTION_CENSUS_FIELDS),
+            "direct": list(pure["direct"]),
+            "symmetric_group_fft": list(pure["symmetric-group-fft"]),
+        },
+        "open_line": {
+            "case_id": _OPEN_LINE_REFLECTION_CASE_ID,
+            "direct_equals_symmetric_group_fft": True,
+            "fields": list(_REFLECTION_CENSUS_FIELDS),
+            "shared": list(open_triplets["direct"]),
+        },
+    }
+
+
+def _sequence(value: object, where: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise FFTAcceptanceError(f"{where} must be an array")
+    return cast(Sequence[object], value)
+
+
+def _canonical_fixture_decimal(value: object, where: str) -> Decimal:
+    if not isinstance(value, str):
+        raise FFTAcceptanceError(f"{where} must be a canonical decimal string")
+    try:
+        parsed = Decimal(value)
+    except ArithmeticError as error:
+        raise FFTAcceptanceError(f"{where} is not a decimal") from error
+    if not parsed.is_finite() or canonical_decimal(parsed) != value:
+        raise FFTAcceptanceError(f"{where} must be a canonical finite decimal")
+    return parsed
+
+
+def _duplicate_rejecting_object(
+    pairs: list[tuple[str, object]],
+) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in pairs:
+        if key in result:
+            raise FFTAcceptanceError(f"frozen fixture repeats JSON key {key!r}")
+        result[key] = value
+    return result
+
+
+def load_frozen_full_evidence(path: Path = DEFAULT_FIXTURE) -> FrozenFullEvidence:
+    """Authenticate and load only the immutable independent FullColour evidence.
+
+    The capture records the exact MadGraph driver digest used to produce it.
+    Replaying immutable values must not require that today's capture adapter has
+    the same digest: doing so would turn harmless adapter maintenance into a
+    demand to rerun the explicitly frozen independent oracle.
+    """
+
+    source = path.expanduser().resolve(strict=True)
+    try:
+        payload = json.loads(
+            source.read_text(encoding="ascii"),
+            object_pairs_hook=_duplicate_rejecting_object,
+            parse_constant=lambda token: (_ for _ in ()).throw(
+                FFTAcceptanceError(f"frozen fixture has non-finite token {token!r}")
+            ),
+        )
+    except FFTAcceptanceError:
+        raise
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise FFTAcceptanceError(
+            f"cannot read frozen fixture {source}: {error}"
+        ) from error
+    root = _mapping(payload, "frozen fixture")
+    if (
+        root.get("kind") != "pyamplicol-ufo-sm-numerical-acceptance"
+        or root.get("schema_version") != 1
+        or root.get("catalog_max_n_final") != TOTAL_MAX_N_FINAL
+    ):
+        raise FFTAcceptanceError("frozen fixture has the wrong identity or bounds")
+    point_policy = _mapping(root.get("point_policy"), "point_policy")
+    if dict(point_policy) != {
+        "generator": "generic_validation_point",
+        "seed": POINT_SEED,
+        "stored_components": "canonical-binary64-decimal",
+    }:
+        raise FFTAcceptanceError(
+            "frozen fixture does not use the seed-101 point policy"
+        )
+    comparison = _mapping(root.get("comparison"), "comparison")
+    if (
+        _canonical_fixture_decimal(
+            comparison.get("relative_tolerance"), "comparison.relative_tolerance"
+        )
+        != RELATIVE_TOLERANCE
+        or comparison.get("absolute_tolerance") is not None
+    ):
+        raise FFTAcceptanceError(
+            "frozen fixture does not use strict relative-only tolerance 1e-10"
+        )
+    model = _mapping(root.get("model"), "model")
+    if dict(model) != current_model_identity().as_payload():
+        raise FFTAcceptanceError(
+            "frozen fixture model identity differs from the packaged UFO-SM"
+        )
+    references = _mapping(root.get("references"), "references")
+    full_reference = _mapping(references.get("full"), "references.full")
+    if (
+        full_reference.get("kind") != "madgraph-standalone-ufo-sm"
+        or full_reference.get("precision") != "binary64"
+        or full_reference.get("command_protocol")
+        != "generate-output-standalone-launch-force"
+        or full_reference.get("external_parameters_sha256")
+        != model.get("external_parameters_sha256")
+    ):
+        raise FFTAcceptanceError("frozen FullColour reference identity is invalid")
+    madgraph_version = full_reference.get("madgraph_version")
+    model_source_sha256 = full_reference.get("model_source_sha256")
+    driver_sha256 = full_reference.get("driver_sha256")
+    if not isinstance(madgraph_version, str) or not madgraph_version:
+        raise FFTAcceptanceError("frozen MadGraph version is invalid")
+    for label, digest in (
+        ("model source", model_source_sha256),
+        ("driver", driver_sha256),
+    ):
+        if not isinstance(digest, str) or re.fullmatch(r"[0-9a-f]{64}", digest) is None:
+            raise FFTAcceptanceError(f"frozen MadGraph {label} digest is invalid")
+
+    specs = catalog_cases(TOTAL_MAX_N_FINAL)
+    raw_cases = _sequence(root.get("catalog_cases"), "catalog_cases")
+    if len(raw_cases) != len(specs):
+        raise FFTAcceptanceError(
+            f"frozen fixture must contain {len(specs)} catalog cases"
+        )
+    cases: list[FrozenFullCase] = []
+    for spec, raw_case in zip(specs, raw_cases, strict=True):
+        record = _mapping(raw_case, f"frozen case {spec.case_id}")
+        observed_identity = (
+            record.get("id"),
+            record.get("family_id"),
+            record.get("family_key"),
+            record.get("n_final"),
+            record.get("process"),
+        )
+        expected_identity = (
+            spec.case_id,
+            spec.family_id,
+            spec.family_key,
+            spec.n_final,
+            spec.process,
+        )
+        if observed_identity != expected_identity:
+            raise FFTAcceptanceError(
+                f"frozen case {spec.case_id} differs from the live catalog"
+            )
+        raw_momenta = _sequence(record.get("momenta"), f"{spec.case_id}.momenta")
+        momenta = tuple(
+            tuple(
+                _canonical_fixture_decimal(
+                    component,
+                    f"{spec.case_id}.momenta[{row_index}][{component_index}]",
+                )
+                for component_index, component in enumerate(
+                    _sequence(row, f"{spec.case_id}.momenta[{row_index}]")
+                )
+            )
+            for row_index, row in enumerate(raw_momenta)
+        )
+        if len(momenta) != spec.n_final + 2 or any(
+            len(momentum) != 4 for momentum in momenta
+        ):
+            raise FFTAcceptanceError(
+                f"frozen case {spec.case_id} has malformed momentum dimensions"
+            )
+        expected = _mapping(record.get("expected"), f"{spec.case_id}.expected")
+        expected_full = _canonical_fixture_decimal(
+            expected.get("full"), f"{spec.case_id}.expected.full"
+        )
+        if expected_full < 0:
+            raise FFTAcceptanceError(
+                f"frozen case {spec.case_id} has a negative FullColour value"
+            )
+        cases.append(FrozenFullCase(spec, momenta, expected_full))
+    return FrozenFullEvidence(
+        source,
+        madgraph_version,
+        cast(str, model_source_sha256),
+        cast(str, driver_sha256),
+        tuple(cases),
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class ComparisonSpec:
+    authority: Literal["direct-vs-fft", "frozen-madgraph"]
+    model: ModelName
+    mode: ModeName
+    accuracy: AccuracyName
+    helicity_scope: Literal["selected", "total"]
+    case_id: str
+
+    def as_payload(self) -> dict[str, object]:
+        return {
+            "authority": self.authority,
+            "model": self.model,
+            "mode": self.mode,
+            "accuracy": self.accuracy,
+            "helicity_scope": self.helicity_scope,
+            "case_id": self.case_id,
+            "selection_execution": (
+                None
+                if self.helicity_scope == "total"
+                else selection_execution(self.mode)
+            ),
+        }
+
+
+def selection_execution(mode: ModeName) -> SelectionExecution:
+    """Describe how one recorded helicity is applied in an execution mode."""
+
+    if mode == "recurrence":
+        return "generation-specialized"
+    return "runtime-query-complete-coverage"
+
+
+def comparison_specs() -> tuple[ComparisonSpec, ...]:
+    """Return the complete required parity and independent-oracle matrix."""
+
+    selected = catalog_cases(SELECTED_MAX_N_FINAL)
+    totals = catalog_cases(TOTAL_MAX_N_FINAL)
+    specs: list[ComparisonSpec] = []
+    for model in MODELS:
+        for mode in MODES:
+            for accuracy in ACCURACIES:
+                specs.extend(
+                    ComparisonSpec(
+                        "direct-vs-fft",
+                        model,
+                        mode,
+                        accuracy,
+                        "selected",
+                        case.case_id,
+                    )
+                    for case in selected
+                )
+            specs.extend(
+                ComparisonSpec(
+                    "direct-vs-fft",
+                    model,
+                    mode,
+                    "full",
+                    "total",
+                    case.case_id,
+                )
+                for case in totals
+            )
+    for mode in MODES:
+        specs.extend(
+            ComparisonSpec(
+                "frozen-madgraph",
+                "ufo-sm",
+                mode,
+                "full",
+                "total",
+                case.case_id,
+            )
+            for case in totals
+        )
+    return tuple(specs)
+
+
+def _fixture_case_ids(fixture: FrozenFullEvidence) -> tuple[str, ...]:
+    return tuple(case.case.case_id for case in fixture.cases)
+
+
+def dry_run_payload(
+    fixture_path: Path = DEFAULT_FIXTURE,
+) -> dict[str, object]:
+    """Authenticate all static inputs and describe the non-mutating campaign."""
+
+    fixture = load_frozen_full_evidence(fixture_path)
+    selected = catalog_cases(SELECTED_MAX_N_FINAL)
+    totals = catalog_cases(TOTAL_MAX_N_FINAL)
+    expected_fixture_ids = tuple(case.case_id for case in totals)
+    if _fixture_case_ids(fixture) != expected_fixture_ids:
+        raise FFTAcceptanceError(
+            "the frozen UFO-SM fixture no longer matches the live n_final<=4 catalog"
+        )
+    specs = comparison_specs()
+    direct_fft = sum(spec.authority == "direct-vs-fft" for spec in specs)
+    frozen = sum(spec.authority == "frozen-madgraph" for spec in specs)
+    return {
+        "kind": GATE_KIND,
+        "schema_version": GATE_SCHEMA_VERSION,
+        "dry_run": True,
+        "point_policy": {
+            "generator": "generic_validation_point",
+            "seed": POINT_SEED,
+        },
+        "comparison_policy": {
+            "relative_tolerance": canonical_decimal(RELATIVE_TOLERANCE),
+            "absolute_tolerance": None,
+        },
+        "catalog": {
+            "source": "tools/performance_report/catalog.py:PROCESS_FAMILIES",
+            "selected_max_n_final": SELECTED_MAX_N_FINAL,
+            "selected_case_count_per_model": len(selected),
+            "total_max_n_final": TOTAL_MAX_N_FINAL,
+            "total_case_count_per_model": len(totals),
+            "cases": [
+                {
+                    "id": case.case_id,
+                    "family_id": case.family_id,
+                    "family_key": case.family_key,
+                    "n_final": case.n_final,
+                    "process": case.process,
+                }
+                for case in selected
+            ],
+        },
+        "process_set_cache_policy": {
+            "base_key_axes": [
+                "method",
+                "model",
+                "mode",
+                "accuracy",
+                "helicity_scope",
+            ],
+            "selected_partition": (
+                "recurrence only: canonical external-helicity-domain signature "
+                "plus exact discovered tuple"
+            ),
+            "selected_execution": {
+                "recurrence": "generation-specialized",
+                "on-the-fly": "runtime-query-complete-coverage",
+            },
+            "on_the_fly_complete_coverage": (
+                "one ProcessSet per method/model/accuracy, shared by selected "
+                "runtime queries and FullColour totals"
+            ),
+            "discovery": (
+                "grouped direct recurrence preferred-selector probes; at most "
+                "one all-helicity fallback ProcessSet per model/accuracy, only "
+                "for observed zero rows"
+            ),
+            "per_process_generation": False,
+        },
+        "frozen_authority": {
+            "fixture": str(fixture_path.resolve(strict=True)),
+            "model": "ufo-sm",
+            "accuracy": "full",
+            "max_n_final": TOTAL_MAX_N_FINAL,
+            "case_count_per_mode": len(fixture.cases),
+            "madgraph_version": fixture.madgraph_version,
+            "captured_model_source_sha256": fixture.model_source_sha256,
+            "captured_driver_sha256": fixture.driver_sha256,
+            "madgraph_rerun": False,
+        },
+        "comparison_counts": {
+            "direct_vs_fft": direct_fft,
+            "frozen_madgraph": frozen,
+            "total": len(specs),
+        },
+        "comparisons": [spec.as_payload() for spec in specs],
+    }
+
+
+def _decimal_component(value: object, where: str) -> tuple[Decimal, Decimal]:
+    if isinstance(value, bool):
+        raise FFTAcceptanceError(f"{where} must be numeric")
+    if isinstance(value, Decimal):
+        real, imaginary = value, Decimal(0)
+    elif isinstance(value, int):
+        real, imaginary = Decimal(value), Decimal(0)
+    else:
+        try:
+            number = complex(value)  # type: ignore[arg-type]
+        except (OverflowError, TypeError, ValueError) as error:
+            raise FFTAcceptanceError(f"{where} must be numeric") from error
+        if not math.isfinite(number.real) or not math.isfinite(number.imag):
+            raise FFTAcceptanceError(f"{where} must be finite")
+        real = Decimal(canonical_decimal(number.real))
+        imaginary = Decimal(canonical_decimal(number.imag))
+    if not real.is_finite() or not imaginary.is_finite():
+        raise FFTAcceptanceError(f"{where} must be finite")
+    return real, imaginary
+
+
+@dataclass(frozen=True, slots=True)
+class StrictRelativeComparison:
+    candidate_real: Decimal
+    candidate_imaginary: Decimal
+    reference_real: Decimal
+    reference_imaginary: Decimal
+    difference: Decimal
+    scale: Decimal
+    bound: Decimal
+    passed: bool
+
+    def as_payload(self) -> dict[str, object]:
+        return {
+            "candidate": [
+                canonical_decimal(self.candidate_real),
+                canonical_decimal(self.candidate_imaginary),
+            ],
+            "reference": [
+                canonical_decimal(self.reference_real),
+                canonical_decimal(self.reference_imaginary),
+            ],
+            "difference": canonical_decimal(self.difference),
+            "scale": canonical_decimal(self.scale),
+            "bound": canonical_decimal(self.bound),
+            "passed": self.passed,
+        }
+
+
+def strict_relative_compare(
+    candidate: object,
+    reference: object,
+    *,
+    tolerance: Decimal = RELATIVE_TOLERANCE,
+) -> StrictRelativeComparison:
+    """Apply the established scale-relative comparison with no absolute floor."""
+
+    candidate_real, candidate_imaginary = _decimal_component(
+        candidate, "candidate matrix element"
+    )
+    reference_real, reference_imaginary = _decimal_component(
+        reference, "reference matrix element"
+    )
+    if tolerance < 0 or not tolerance.is_finite():
+        raise FFTAcceptanceError("relative tolerance must be finite and non-negative")
+    precision = max(
+        80,
+        *(
+            len(value.as_tuple().digits) + 20
+            for value in (
+                candidate_real,
+                candidate_imaginary,
+                reference_real,
+                reference_imaginary,
+            )
+        ),
+    )
+    with localcontext() as context:
+        context.prec = precision
+        candidate_magnitude = (
+            candidate_real * candidate_real + candidate_imaginary * candidate_imaginary
+        ).sqrt()
+        reference_magnitude = (
+            reference_real * reference_real + reference_imaginary * reference_imaginary
+        ).sqrt()
+        difference = (
+            (candidate_real - reference_real) ** 2
+            + (candidate_imaginary - reference_imaginary) ** 2
+        ).sqrt()
+        scale = max(candidate_magnitude, reference_magnitude)
+        bound = tolerance * scale
+    passed = difference == 0 if scale == 0 else difference <= bound
+    return StrictRelativeComparison(
+        candidate_real=candidate_real,
+        candidate_imaginary=candidate_imaginary,
+        reference_real=reference_real,
+        reference_imaginary=reference_imaginary,
+        difference=difference,
+        scale=scale,
+        bound=bound,
+        passed=passed,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class HelicityObservation:
+    helicity_id: str
+    values: tuple[int, ...]
+    structural_zero: bool
+    matrix_element: object
+
+
+@dataclass(frozen=True, slots=True)
+class ChosenHelicity:
+    observation: HelicityObservation
+    domains: tuple[tuple[int, ...], ...]
+    source: Literal["preferred-structural-selector", "largest-nonzero-fallback"]
+
+    @property
+    def signature(self) -> tuple[tuple[tuple[int, ...], ...], tuple[int, ...]]:
+        return self.domains, self.observation.values
+
+
+def choose_nonzero_helicity(
+    observations: Sequence[HelicityObservation],
+    *,
+    preferred: Sequence[int],
+) -> ChosenHelicity:
+    """Choose a stable nonzero row, preferring the report selector policy."""
+
+    rows = tuple(observations)
+    if not rows:
+        raise FFTAcceptanceError("helicity discovery returned no physical rows")
+    width = len(rows[0].values)
+    if width == 0 or any(len(row.values) != width for row in rows):
+        raise FFTAcceptanceError("helicity discovery rows have inconsistent width")
+    if len({row.helicity_id for row in rows}) != len(rows):
+        raise FFTAcceptanceError("helicity discovery rows have duplicate IDs")
+    domains = tuple(
+        tuple(sorted({row.values[index] for row in rows})) for index in range(width)
+    )
+    nonzero = tuple(
+        row
+        for row in rows
+        if not row.structural_zero
+        and strict_relative_compare(row.matrix_element, 0).scale > 0
+    )
+    preferred_tuple = tuple(int(value) for value in preferred)
+    preferred_rows = tuple(row for row in nonzero if row.values == preferred_tuple)
+    if len(preferred_rows) == 1:
+        return ChosenHelicity(
+            preferred_rows[0], domains, "preferred-structural-selector"
+        )
+    if not nonzero:
+        raise FFTAcceptanceError(
+            "direct all-helicity oracle found no nonzero physical helicity"
+        )
+    ordered = sorted(nonzero, key=lambda row: (row.values, row.helicity_id))
+    selected = max(
+        ordered,
+        key=lambda row: strict_relative_compare(row.matrix_element, 0).scale,
+    )
+    return ChosenHelicity(selected, domains, "largest-nonzero-fallback")
+
+
+@dataclass(frozen=True, slots=True)
+class SelectionRecord:
+    model: ModelName
+    accuracy: AccuracyName
+    case: CatalogCase
+    helicity_id: str
+    values: tuple[int, ...]
+    domains: tuple[tuple[int, ...], ...]
+    source: str
+    discovery_value: object
+
+    @property
+    def signature(self) -> tuple[tuple[tuple[int, ...], ...], tuple[int, ...]]:
+        return self.domains, self.values
+
+    @property
+    def source_mapping(self) -> tuple[tuple[int, int], ...]:
+        return tuple(enumerate(self.values, start=1))
+
+    def as_payload(self) -> dict[str, object]:
+        value_real, value_imaginary = _decimal_component(
+            self.discovery_value, "discovery matrix element"
+        )
+        return {
+            "model": self.model,
+            "accuracy": self.accuracy,
+            "case_id": self.case.case_id,
+            "process": self.case.process,
+            "n_final": self.case.n_final,
+            "helicity_id": self.helicity_id,
+            "source_helicities": [list(item) for item in self.source_mapping],
+            "external_helicity_domains": [list(domain) for domain in self.domains],
+            "selection_source": self.source,
+            "discovery_oracle": {
+                "method": "direct",
+                "mode": "recurrence",
+                "value": [
+                    canonical_decimal(value_real),
+                    canonical_decimal(value_imaginary),
+                ],
+                "nonzero": strict_relative_compare(self.discovery_value, 0).scale > 0,
+            },
+        }
+
+
+def _signature_digest(
+    signature: tuple[tuple[tuple[int, ...], ...], tuple[int, ...]],
+) -> str:
+    domains, values = signature
+    encoded = json.dumps(
+        {"domains": domains, "values": values},
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()[:16]
+
+
+@dataclass(frozen=True, slots=True)
+class SelectedGroup:
+    signature: tuple[tuple[tuple[int, ...], ...], tuple[int, ...]]
+    cases: tuple[CatalogCase, ...]
+
+    @property
+    def scope(self) -> str:
+        return f"selected-{_signature_digest(self.signature)}"
+
+    @property
+    def source_mapping(self) -> tuple[tuple[int, int], ...]:
+        return tuple(enumerate(self.signature[1], start=1))
+
+
+def group_selected_cases(
+    cases: Sequence[CatalogCase],
+    selections: Mapping[str, SelectionRecord],
+) -> tuple[SelectedGroup, ...]:
+    """Partition a selected scope by domain and exact discovered tuple."""
+
+    grouped: OrderedDict[
+        tuple[tuple[tuple[int, ...], ...], tuple[int, ...]], list[CatalogCase]
+    ] = OrderedDict()
+    for case in cases:
+        try:
+            selection = selections[case.case_id]
+        except KeyError as error:
+            raise FFTAcceptanceError(
+                f"missing discovered helicity for {case.case_id}"
+            ) from error
+        if selection.case != case:
+            raise FFTAcceptanceError(
+                f"discovered helicity identity differs for {case.case_id}"
+            )
+        grouped.setdefault(selection.signature, []).append(case)
+    return tuple(
+        SelectedGroup(signature, tuple(group_cases))
+        for signature, group_cases in grouped.items()
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactKey:
+    method: MethodName
+    model: ModelName
+    mode: ModeName
+    accuracy: AccuracyName
+    helicity_scope: str
+
+    @property
+    def slug(self) -> str:
+        method = "fft" if self.method == "symmetric-group-fft" else "direct"
+        mode = self.mode.replace("-", "_")
+        return "-".join((method, self.model, mode, self.accuracy, self.helicity_scope))
+
+    def as_payload(self) -> dict[str, str]:
+        return {
+            "method": self.method,
+            "model": self.model,
+            "mode": self.mode,
+            "accuracy": self.accuracy,
+            "helicity_scope": self.helicity_scope,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class GroupRequest:
+    key: ArtifactKey
+    cases: tuple[CatalogCase, ...]
+    selected_source_helicities: tuple[tuple[int, int], ...] | None = None
+    external_helicity_domains: tuple[tuple[int, ...], ...] | None = None
+
+    def __post_init__(self) -> None:
+        if not self.cases:
+            raise ValueError("a ProcessSet group must not be empty")
+        if len({case.case_id for case in self.cases}) != len(self.cases):
+            raise ValueError("a ProcessSet group contains duplicate cases")
+        selected = self.selected_source_helicities
+        domains = self.external_helicity_domains
+        if (selected is None) != (domains is None):
+            raise ValueError("selected source tuples and domains must be paired")
+        if selected is not None:
+            if self.key.mode == "on-the-fly":
+                raise ValueError(
+                    "on-the-fly ProcessSets must retain complete helicity coverage"
+                )
+            if tuple(label for label, _value in selected) != tuple(
+                range(1, len(selected) + 1)
+            ):
+                raise ValueError("selected source labels must be dense and one-based")
+            if domains is None or len(domains) != len(selected):
+                raise ValueError("selected source tuple and domain widths differ")
+            for (label, value), domain in zip(selected, domains, strict=True):
+                if value not in domain:
+                    raise ValueError(
+                        f"selected helicity {value} for label {label} is outside "
+                        f"its domain {domain!r}"
+                    )
+
+    def as_payload(self) -> dict[str, object]:
+        return {
+            "boundary": self.key.as_payload(),
+            "helicity_generation_contract": (
+                "complete-coverage"
+                if self.selected_source_helicities is None
+                else "generation-specialized"
+            ),
+            "case_count": len(self.cases),
+            "case_ids": [case.case_id for case in self.cases],
+            "selected_source_helicities": (
+                None
+                if self.selected_source_helicities is None
+                else [list(item) for item in self.selected_source_helicities]
+            ),
+            "external_helicity_domains": (
+                None
+                if self.external_helicity_domains is None
+                else [list(item) for item in self.external_helicity_domains]
+            ),
+        }
+
+
+def otf_complete_group_request(
+    *,
+    method: MethodName,
+    model: ModelName,
+    accuracy: AccuracyName,
+    cases: Sequence[CatalogCase],
+) -> GroupRequest:
+    """Build the single reusable OTF helicity-coverage boundary for one lane."""
+
+    return GroupRequest(
+        ArtifactKey(
+            method,
+            model,
+            "on-the-fly",
+            accuracy,
+            "complete-helicity-runtime-query-and-total",
+        ),
+        tuple(cases),
+    )
+
+
+RecordT = TypeVar("RecordT")
+
+
+class ProcessSetCache(Generic[RecordT]):
+    """Memoize one builder call per exact method/model/mode/scope boundary."""
+
+    def __init__(self, builder: Callable[[GroupRequest], RecordT]) -> None:
+        self._builder = builder
+        self._requests: dict[ArtifactKey, GroupRequest] = {}
+        self._records: dict[ArtifactKey, RecordT] = {}
+        self._generation_order: list[ArtifactKey] = []
+
+    def get(self, request: GroupRequest) -> RecordT:
+        previous = self._requests.get(request.key)
+        if previous is not None:
+            if previous != request:
+                raise FFTAcceptanceError(
+                    "a ProcessSet cache boundary was reused with a different case "
+                    f"or helicity scope: {request.key.slug}"
+                )
+            return self._records[request.key]
+        record = self._builder(request)
+        self._requests[request.key] = request
+        self._records[request.key] = record
+        self._generation_order.append(request.key)
+        return record
+
+    @property
+    def generation_count(self) -> int:
+        return len(self._generation_order)
+
+    @property
+    def entries(self) -> tuple[tuple[GroupRequest, RecordT], ...]:
+        return tuple(
+            (self._requests[key], self._records[key]) for key in self._generation_order
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactRecord:
+    request: GroupRequest
+    path: Path
+
+
+def _run_config(request: GroupRequest) -> object:
+    from pyamplicol.config import (
+        Action,
+        ColorAccuracy,
+        ColorConfig,
+        ColorContraction,
+        EvaluatorConfig,
+        EvaluatorExecutionMode,
+        EvaluatorOptimizationConfig,
+        GenerationConfig,
+        GenerationRelationDiscoveryConfig,
+        GenerationValidationConfig,
+        JITConfig,
+        ProcessConfig,
+        RelationDiscoveryMode,
+        RunConfig,
+    )
+
+    selected = request.selected_source_helicities or ()
+    return RunConfig(
+        action=Action.GENERATE,
+        process=ProcessConfig(
+            selected_source_helicities={str(label): value for label, value in selected}
+        ),
+        color=ColorConfig(
+            accuracy=ColorAccuracy(request.key.accuracy),
+            contraction=ColorContraction(request.key.method),
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+            relation_discovery=GenerationRelationDiscoveryConfig(
+                mode=RelationDiscoveryMode.OFF
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=EvaluatorExecutionMode(request.key.mode),
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+class NativeArtifactBuilder:
+    """Generate and authenticate one grouped native ProcessSet artifact."""
+
+    def __init__(
+        self,
+        artifact_root: Path,
+        *,
+        models: Mapping[ModelName, object | None],
+    ) -> None:
+        self.artifact_root = artifact_root
+        self.models = models
+        self.artifact_root.mkdir(parents=True, exist_ok=False)
+
+    def __call__(self, request: GroupRequest) -> ArtifactRecord:
+        from pyamplicol import Generator, ProcessSet
+
+        path = self.artifact_root / request.key.slug
+        process_set = ProcessSet.from_expressions(
+            (case.process for case in request.cases),
+            names=tuple(case.artifact_name for case in request.cases),
+        )
+        Generator(_run_config(request)).generate(
+            process_set,
+            path,
+            model=self.models[request.key.model],  # type: ignore[arg-type]
+        )
+        self._validate(path, request)
+        return ArtifactRecord(request=request, path=path)
+
+    @staticmethod
+    def _validate(path: Path, request: GroupRequest) -> None:
+        from pyamplicol.artifacts import inspect_artifact
+
+        try:
+            effective = tomllib.loads(
+                (path / "config" / "effective.toml").read_text(encoding="utf-8")
+            )
+            observed_lane = (
+                str(cast(Mapping[str, object], effective["color"])["accuracy"]),
+                str(cast(Mapping[str, object], effective["color"])["contraction"]),
+                str(
+                    cast(Mapping[str, object], effective["evaluator"])["execution_mode"]
+                ),
+            )
+        except (KeyError, OSError, TypeError, tomllib.TOMLDecodeError) as error:
+            raise FFTAcceptanceError(
+                f"artifact {request.key.slug} has no valid effective config"
+            ) from error
+        expected_lane = (
+            request.key.accuracy,
+            request.key.method,
+            request.key.mode,
+        )
+        if observed_lane != expected_lane:
+            raise FFTAcceptanceError(
+                f"artifact {request.key.slug} effective lane is {observed_lane!r}; "
+                f"expected {expected_lane!r}"
+            )
+
+        inspection = inspect_artifact(path)
+        cases_by_name = {case.artifact_name: case for case in request.cases}
+        public_names: set[str] = set()
+        for process in inspection.processes:
+            process_names = (process.id, *(alias.id for alias in process.aliases))
+            public_names.update(process_names)
+            unknown_names = tuple(
+                name for name in process_names if name not in cases_by_name
+            )
+            if unknown_names:
+                raise FFTAcceptanceError(
+                    f"artifact {request.key.slug} contains unknown public process "
+                    f"names {unknown_names!r}"
+                )
+            if process.color_accuracy != request.key.accuracy:
+                raise FFTAcceptanceError(
+                    f"artifact {request.key.slug} contains the wrong color accuracy"
+                )
+            if process.execution_mode != request.key.mode:
+                raise FFTAcceptanceError(
+                    f"artifact {request.key.slug} contains the wrong execution mode"
+                )
+            expected_methods = {
+                _expected_inspection_method(request.key.method, cases_by_name[name])
+                for name in process_names
+            }
+            if len(expected_methods) != 1:
+                raise FFTAcceptanceError(
+                    f"artifact {request.key.slug} aliases processes with different "
+                    "symmetric-group eligibility"
+                )
+            expected_method = expected_methods.pop()
+            method = process.recurrence_color_contraction_method
+            if method != expected_method:
+                raise FFTAcceptanceError(
+                    f"artifact {request.key.slug} carries inspection method "
+                    f"{method!r}; expected {expected_method!r} for public "
+                    f"processes {process_names!r}"
+                )
+            if request.selected_source_helicities is None:
+                if process.selected_source_helicities:
+                    raise FFTAcceptanceError(
+                        f"all-helicity artifact {request.key.slug} is specialized"
+                    )
+                if (
+                    process.helicity_coverage != "complete"
+                    or "helicity" in process.generation_specialized_axes
+                ):
+                    raise FFTAcceptanceError(
+                        f"all-helicity artifact {request.key.slug} does not retain "
+                        "complete reusable helicity coverage"
+                    )
+            elif (
+                process.helicity_coverage != "selected"
+                or "helicity" not in process.generation_specialized_axes
+            ):
+                raise FFTAcceptanceError(
+                    f"selected artifact {request.key.slug} is not "
+                    "generation-specialized"
+                )
+        expected_names = {case.artifact_name for case in request.cases}
+        if public_names != expected_names:
+            raise FFTAcceptanceError(
+                f"artifact {request.key.slug} public process names differ: "
+                f"missing={sorted(expected_names - public_names)!r}, "
+                f"extra={sorted(public_names - expected_names)!r}"
+            )
+
+
+def _runtime_points(case: CatalogCase) -> tuple[tuple[tuple[float, ...], ...], ...]:
+    return (
+        tuple(
+            tuple(float(component) for component in momentum)
+            for momentum in validation_momenta(case.process)
+        ),
+    )
+
+
+def _preferred_structural_selection(
+    case: CatalogCase,
+    *,
+    model: ModelName,
+    accuracy: AccuracyName,
+) -> SelectionRecord:
+    """Build the existing deterministic selector without all-helicity generation."""
+
+    from pyamplicol.models.builtin.process_ir import build_process_ir
+
+    process = build_process_ir(case.process, color_accuracy=accuracy)
+    pdgs = tuple(int(leg.pdg) for leg in process.legs if leg.pdg is not None)
+    if len(pdgs) != case.n_final + 2:
+        raise FFTAcceptanceError(
+            f"{case.case_id} structural selector has the wrong external width"
+        )
+    values = fixed_selector_helicity(pdgs)
+    domains = tuple(_preferred_helicities(pdg) for pdg in pdgs)
+    if any(value not in domain for value, domain in zip(values, domains, strict=True)):
+        raise FFTAcceptanceError(
+            f"{case.case_id} structural selector is outside its physical domain"
+        )
+    return SelectionRecord(
+        model=model,
+        accuracy=accuracy,
+        case=case,
+        helicity_id=selector_helicity_id(values),
+        values=values,
+        domains=domains,
+        source="preferred-structural-selector",
+        discovery_value=0,
+    )
+
+
+def _validate_runtime_lane(runtime: object, key: ArtifactKey) -> None:
+    if getattr(runtime, "execution_mode", None) != key.mode:
+        raise FFTAcceptanceError(
+            f"runtime {key.slug} loaded with the wrong execution mode"
+        )
+    physics = getattr(runtime, "physics", None)
+    if getattr(physics, "color_accuracy", None) != key.accuracy:
+        raise FFTAcceptanceError(f"runtime {key.slug} loaded with the wrong accuracy")
+
+
+def _discover_case_selection(
+    record: ArtifactRecord,
+    case: CatalogCase,
+) -> SelectionRecord:
+    from pyamplicol import Runtime
+
+    runtime = Runtime.load(record.path, process=case.artifact_name)
+    try:
+        _validate_runtime_lane(runtime, record.request.key)
+        resolved = runtime.evaluate_resolved(_runtime_points(case))
+        physics = runtime.physics
+        helicities = tuple(physics.helicities)
+        if resolved.helicity_ids != tuple(item.id for item in helicities):
+            raise FFTAcceptanceError(
+                f"{case.case_id} discovery resolved helicity order is inconsistent"
+            )
+        if resolved.color_accuracy != record.request.key.accuracy:
+            raise FFTAcceptanceError(
+                f"{case.case_id} discovery resolved the wrong color accuracy"
+            )
+        if len(resolved.values) != 1 or any(
+            len(color_values) != 1 for color_values in resolved.values[0]
+        ):
+            raise FFTAcceptanceError(
+                f"{case.case_id} discovery did not return one contracted color value"
+            )
+        particles = tuple(physics.external_particles)
+        preferred = fixed_selector_helicity(
+            tuple(int(particle.pdg_id) for particle in particles)
+        )
+        chosen = choose_nonzero_helicity(
+            tuple(
+                HelicityObservation(
+                    helicity_id=helicity.helicity_id
+                    if hasattr(helicity, "helicity_id")
+                    else helicity.id,
+                    values=tuple(int(value) for value in helicity.values),
+                    structural_zero=bool(helicity.structural_zero),
+                    matrix_element=resolved.values[0][index][0],
+                )
+                for index, helicity in enumerate(helicities)
+            ),
+            preferred=preferred,
+        )
+        return SelectionRecord(
+            model=record.request.key.model,
+            accuracy=record.request.key.accuracy,
+            case=case,
+            helicity_id=chosen.observation.helicity_id,
+            values=chosen.observation.values,
+            domains=chosen.domains,
+            source=chosen.source,
+            discovery_value=chosen.observation.matrix_element,
+        )
+    finally:
+        runtime.clear()
+
+
+def _evaluate_scalar(
+    record: ArtifactRecord,
+    case: CatalogCase,
+    *,
+    selection: SelectionRecord | None,
+    active_family_census: dict[str, object] | None = None,
+) -> object:
+    from pyamplicol import Runtime
+
+    runtime = Runtime.load(record.path, process=case.artifact_name)
+    try:
+        _validate_runtime_lane(runtime, record.request.key)
+        selected_helicity_ids: tuple[str, ...] | None = None
+        if selection is not None:
+            if selection.case != case:
+                raise FFTAcceptanceError(
+                    f"{case.case_id}/{record.request.key.slug} received a selection "
+                    "for a different process"
+                )
+            if (
+                selection.model != record.request.key.model
+                or selection.accuracy != record.request.key.accuracy
+            ):
+                raise FFTAcceptanceError(
+                    f"{case.case_id}/{record.request.key.slug} received a selection "
+                    "from a different model or accuracy lane"
+                )
+            physical = tuple(runtime.physics.helicities)
+            observed = tuple(
+                tuple(int(value) for value in item.values) for item in physical
+            )
+            if record.request.key.mode == "recurrence":
+                if observed != (selection.values,):
+                    raise FFTAcceptanceError(
+                        f"{case.case_id}/{record.request.key.slug} exposes selected "
+                        f"helicities {observed!r}; expected {(selection.values,)!r}"
+                    )
+                if runtime.physics.helicity_coverage != "selected":
+                    raise FFTAcceptanceError(
+                        f"{case.case_id}/{record.request.key.slug} is not "
+                        "generation-selected"
+                    )
+            else:
+                if (
+                    record.request.selected_source_helicities is not None
+                    or runtime.physics.helicity_coverage != "complete"
+                ):
+                    raise FFTAcceptanceError(
+                        f"{case.case_id}/{record.request.key.slug} is not a "
+                        "complete-coverage on-the-fly runtime"
+                    )
+                matches = tuple(
+                    item for item in physical if tuple(item.values) == selection.values
+                )
+                if len(matches) != 1:
+                    raise FFTAcceptanceError(
+                        f"{case.case_id}/{record.request.key.slug} exposes "
+                        f"{len(matches)} rows for recorded tuple {selection.values!r}"
+                    )
+                observed_id = str(matches[0].id)
+                if observed_id != selection.helicity_id:
+                    raise FFTAcceptanceError(
+                        f"{case.case_id}/{record.request.key.slug} maps recorded "
+                        f"tuple to {observed_id!r}; expected {selection.helicity_id!r}"
+                    )
+                selected_helicity_ids = (observed_id,)
+        values = runtime.evaluate(
+            _runtime_points(case),
+            helicities=selected_helicity_ids,
+        )
+        if len(values) != 1:
+            raise FFTAcceptanceError(
+                f"{case.case_id}/{record.request.key.slug} returned {len(values)} "
+                "matrix elements for one point"
+            )
+        if active_family_census is not None:
+            if record.request.key.mode != "on-the-fly":
+                raise FFTAcceptanceError(
+                    "active-family census capture requires an on-the-fly runtime"
+                )
+            if active_family_census:
+                raise FFTAcceptanceError(
+                    "active-family census capture destination must start empty"
+                )
+            inspect = getattr(runtime, "inspect", None)
+            if not callable(inspect):
+                raise FFTAcceptanceError(
+                    f"{case.case_id}/{record.request.key.slug} has no runtime "
+                    "inspection"
+                )
+            inspection = _mapping(
+                inspect(),
+                f"{case.case_id}/{record.request.key.slug} runtime inspection",
+            )
+            state = _mapping(
+                inspection.get("on_the_fly_state"),
+                f"{case.case_id}/{record.request.key.slug} on-the-fly state",
+            )
+            active = _mapping(
+                state.get("active_family_union_census"),
+                f"{case.case_id}/{record.request.key.slug} active-family census",
+            )
+            active_family_census.update(active)
+        return values[0]
+    finally:
+        runtime.clear()
+
+
+class NativeAcceptanceHarness:
+    """Run the complete opt-in matrix with grouped ProcessSet generation."""
+
+    def __init__(
+        self,
+        run_root: Path,
+        *,
+        fixture: FrozenFullEvidence,
+        fixture_path: Path,
+    ) -> None:
+        self.run_root = run_root
+        self.fixture = fixture
+        self.fixture_path = fixture_path
+        self.selected_cases = catalog_cases(SELECTED_MAX_N_FINAL)
+        self.total_cases = catalog_cases(TOTAL_MAX_N_FINAL)
+        self.comparisons: list[dict[str, object]] = []
+        self.selections: dict[tuple[ModelName, AccuracyName, str], SelectionRecord] = {}
+        self._values: dict[
+            tuple[Path, str, tuple[str, tuple[int, ...]] | None], object
+        ] = {}
+        self._reflection_censuses: dict[
+            tuple[str, MethodName], dict[str, object]
+        ] = {}
+
+        for frozen in fixture.cases:
+            if frozen.momenta != validation_momenta(frozen.case.process):
+                raise FFTAcceptanceError(
+                    f"frozen case {frozen.case.case_id} differs from its current "
+                    "generic_validation_point(seed=101)"
+                )
+
+        models: dict[ModelName, object | None] = {
+            "built-in-sm": None,
+            "ufo-sm": prepare_ufo_sm_model(run_root / "prepared-ufo-sm"),
+        }
+        builder = NativeArtifactBuilder(run_root / "artifacts", models=models)
+        self.cache: ProcessSetCache[ArtifactRecord] = ProcessSetCache(builder)
+
+    def _discover_selections(
+        self,
+    ) -> tuple[
+        dict[tuple[ModelName, AccuracyName, str], ArtifactRecord],
+        frozenset[tuple[ModelName, AccuracyName]],
+    ]:
+        """Probe the cheap structural tuple and expand only observed zeros."""
+
+        probe_records: dict[tuple[ModelName, AccuracyName, str], ArtifactRecord] = {}
+        fallback_scopes: set[tuple[ModelName, AccuracyName]] = set()
+        for model in MODELS:
+            for accuracy in ACCURACIES:
+                preferred = {
+                    case.case_id: _preferred_structural_selection(
+                        case,
+                        model=model,
+                        accuracy=accuracy,
+                    )
+                    for case in self.selected_cases
+                }
+                zero_cases: list[CatalogCase] = []
+                for group in group_selected_cases(self.selected_cases, preferred):
+                    request = GroupRequest(
+                        ArtifactKey(
+                            "direct",
+                            model,
+                            "recurrence",
+                            accuracy,
+                            f"preferred-probe-{_signature_digest(group.signature)}",
+                        ),
+                        group.cases,
+                        selected_source_helicities=group.source_mapping,
+                        external_helicity_domains=group.signature[0],
+                    )
+                    record = self.cache.get(request)
+                    for case in group.cases:
+                        candidate = preferred[case.case_id]
+                        value = self._value(record, case, selection=candidate)
+                        probe_records[(model, accuracy, case.case_id)] = record
+                        if strict_relative_compare(value, 0).scale == 0:
+                            zero_cases.append(case)
+                            continue
+                        self.selections[(model, accuracy, case.case_id)] = (
+                            SelectionRecord(
+                                model=model,
+                                accuracy=accuracy,
+                                case=case,
+                                helicity_id=candidate.helicity_id,
+                                values=candidate.values,
+                                domains=candidate.domains,
+                                source="preferred-structural-selector",
+                                discovery_value=value,
+                            )
+                        )
+                if not zero_cases:
+                    continue
+                fallback_scopes.add((model, accuracy))
+                fallback_request = GroupRequest(
+                    ArtifactKey(
+                        "direct",
+                        model,
+                        "recurrence",
+                        accuracy,
+                        "all-helicity-fallback-discovery",
+                    ),
+                    tuple(zero_cases),
+                )
+                fallback_record = self.cache.get(fallback_request)
+                for case in zero_cases:
+                    selection = _discover_case_selection(fallback_record, case)
+                    if selection.values == preferred[case.case_id].values:
+                        raise FFTAcceptanceError(
+                            f"{case.case_id} fallback discovery retained the zero "
+                            "preferred tuple"
+                        )
+                    self.selections[(model, accuracy, case.case_id)] = selection
+        return probe_records, frozenset(fallback_scopes)
+
+    def _selected_artifacts(
+        self,
+        probe_records: Mapping[tuple[ModelName, AccuracyName, str], ArtifactRecord],
+        fallback_scopes: frozenset[tuple[ModelName, AccuracyName]],
+    ) -> dict[
+        tuple[ModelName, ModeName, AccuracyName, MethodName, str], ArtifactRecord
+    ]:
+        records: dict[
+            tuple[ModelName, ModeName, AccuracyName, MethodName, str], ArtifactRecord
+        ] = {}
+        for model in MODELS:
+            for accuracy in ACCURACIES:
+                selections = {
+                    case.case_id: self.selections[(model, accuracy, case.case_id)]
+                    for case in self.selected_cases
+                }
+                groups = group_selected_cases(self.selected_cases, selections)
+                for method in METHODS:
+                    for group in groups:
+                        if (
+                            method == "direct"
+                            and (model, accuracy) not in fallback_scopes
+                        ):
+                            for case in group.cases:
+                                records[
+                                    (
+                                        model,
+                                        "recurrence",
+                                        accuracy,
+                                        method,
+                                        case.case_id,
+                                    )
+                                ] = probe_records[(model, accuracy, case.case_id)]
+                            continue
+                        request = GroupRequest(
+                            ArtifactKey(
+                                method,
+                                model,
+                                "recurrence",
+                                accuracy,
+                                group.scope,
+                            ),
+                            group.cases,
+                            selected_source_helicities=group.source_mapping,
+                            external_helicity_domains=group.signature[0],
+                        )
+                        record = self.cache.get(request)
+                        for case in group.cases:
+                            records[
+                                (
+                                    model,
+                                    "recurrence",
+                                    accuracy,
+                                    method,
+                                    case.case_id,
+                                )
+                            ] = record
+
+                    otf_record = self.cache.get(
+                        otf_complete_group_request(
+                            method=method,
+                            model=model,
+                            accuracy=accuracy,
+                            cases=self.selected_cases,
+                        )
+                    )
+                    for case in self.selected_cases:
+                        records[
+                            (
+                                model,
+                                "on-the-fly",
+                                accuracy,
+                                method,
+                                case.case_id,
+                            )
+                        ] = otf_record
+        return records
+
+    def _total_artifacts(
+        self,
+        selected: Mapping[
+            tuple[ModelName, ModeName, AccuracyName, MethodName, str],
+            ArtifactRecord,
+        ],
+    ) -> dict[tuple[ModelName, ModeName, MethodName], ArtifactRecord]:
+        records: dict[tuple[ModelName, ModeName, MethodName], ArtifactRecord] = {}
+        for model in MODELS:
+            for mode in MODES:
+                for method in METHODS:
+                    if mode == "on-the-fly":
+                        otf_records = tuple(
+                            selected[(model, mode, "full", method, case.case_id)]
+                            for case in self.selected_cases
+                        )
+                        if len({record.path for record in otf_records}) != 1:
+                            raise FFTAcceptanceError(
+                                "on-the-fly selected queries do not share one "
+                                "complete-coverage ProcessSet"
+                            )
+                        record = otf_records[0]
+                        if (
+                            record.request.selected_source_helicities is not None
+                            or not {case.case_id for case in self.total_cases}
+                            <= {case.case_id for case in record.request.cases}
+                        ):
+                            raise FFTAcceptanceError(
+                                "on-the-fly FullColour totals cannot reuse the "
+                                "complete selected-query ProcessSet"
+                            )
+                        records[(model, mode, method)] = record
+                        continue
+                    request = GroupRequest(
+                        ArtifactKey(
+                            method,
+                            model,
+                            mode,
+                            "full",
+                            "all-helicity-total",
+                        ),
+                        self.total_cases,
+                    )
+                    records[(model, mode, method)] = self.cache.get(request)
+        return records
+
+    def _value(
+        self,
+        record: ArtifactRecord,
+        case: CatalogCase,
+        *,
+        selection: SelectionRecord | None,
+    ) -> object:
+        selection_key = (
+            None if selection is None else (selection.helicity_id, selection.values)
+        )
+        key = (record.path, case.case_id, selection_key)
+        existing = self._values.get(key)
+        if existing is not None:
+            return existing
+        artifact_key = record.request.key
+        census_key = (
+            (case.case_id, artifact_key.method)
+            if (
+                selection is not None
+                and case.case_id
+                in {
+                    _PURE_ADJOINT_REFLECTION_CASE_ID,
+                    _OPEN_LINE_REFLECTION_CASE_ID,
+                }
+                and artifact_key.model == "built-in-sm"
+                and artifact_key.mode == "on-the-fly"
+                and artifact_key.accuracy == "full"
+                and artifact_key.helicity_scope
+                == "complete-helicity-runtime-query-and-total"
+                and record.request.selected_source_helicities is None
+            )
+            else None
+        )
+        active_family_census: dict[str, object] | None = (
+            {} if census_key is not None else None
+        )
+        if active_family_census is None:
+            value = _evaluate_scalar(record, case, selection=selection)
+        else:
+            value = _evaluate_scalar(
+                record,
+                case,
+                selection=selection,
+                active_family_census=active_family_census,
+            )
+        if census_key is not None:
+            if active_family_census is None:
+                raise FFTAcceptanceError(
+                    f"production census capture was not initialized for {census_key!r}"
+                )
+            previous = self._reflection_censuses.setdefault(
+                census_key,
+                active_family_census,
+            )
+            if previous != active_family_census:
+                raise FFTAcceptanceError(
+                    f"production active-family census changed for {census_key!r}"
+                )
+        self._values[key] = value
+        return value
+
+    def _validated_reflection_census(self) -> dict[str, object]:
+        def required(case_id: str, method: MethodName) -> Mapping[str, object]:
+            try:
+                return self._reflection_censuses[(case_id, method)]
+            except KeyError as error:
+                raise FFTAcceptanceError(
+                    "the 574-comparison campaign did not evaluate the required "
+                    f"built-in-SM/full/on-the-fly selected census {case_id}/{method}"
+                ) from error
+
+        return validate_on_the_fly_reflection_census(
+            pure_adjoint_direct=required(
+                _PURE_ADJOINT_REFLECTION_CASE_ID,
+                "direct",
+            ),
+            pure_adjoint_fft=required(
+                _PURE_ADJOINT_REFLECTION_CASE_ID,
+                "symmetric-group-fft",
+            ),
+            open_line_direct=required(
+                _OPEN_LINE_REFLECTION_CASE_ID,
+                "direct",
+            ),
+            open_line_fft=required(
+                _OPEN_LINE_REFLECTION_CASE_ID,
+                "symmetric-group-fft",
+            ),
+        )
+
+    def _record_direct_fft(
+        self,
+        *,
+        model: ModelName,
+        mode: ModeName,
+        accuracy: AccuracyName,
+        scope: Literal["selected", "total"],
+        case: CatalogCase,
+        direct_record: ArtifactRecord,
+        fft_record: ArtifactRecord,
+        selection: SelectionRecord | None,
+    ) -> None:
+        direct = self._value(direct_record, case, selection=selection)
+        fft = self._value(fft_record, case, selection=selection)
+        comparison = strict_relative_compare(fft, direct)
+        direct_nonzero = (
+            strict_relative_compare(direct, 0).scale > 0
+            if selection is not None
+            else None
+        )
+        self.comparisons.append(
+            {
+                "authority": "direct-vs-fft",
+                "model": model,
+                "mode": mode,
+                "accuracy": accuracy,
+                "helicity_scope": scope,
+                "case_id": case.case_id,
+                "n_final": case.n_final,
+                "selection": (
+                    None
+                    if selection is None
+                    else {
+                        "helicity_id": selection.helicity_id,
+                        "source_helicities": [
+                            list(item) for item in selection.source_mapping
+                        ],
+                        "execution": selection_execution(mode),
+                        "artifact_helicity_coverage": (
+                            "selected" if mode == "recurrence" else "complete"
+                        ),
+                        "direct_nonzero": direct_nonzero,
+                    }
+                ),
+                "comparison": comparison.as_payload(),
+                "passed": comparison.passed and direct_nonzero is not False,
+            }
+        )
+
+    def _record_frozen(
+        self,
+        *,
+        mode: ModeName,
+        case: CatalogCase,
+        fft_record: ArtifactRecord,
+    ) -> None:
+        frozen = self.fixture.case(case.case_id)
+        candidate = self._value(fft_record, case, selection=None)
+        comparison = strict_relative_compare(candidate, frozen.expected_full)
+        self.comparisons.append(
+            {
+                "authority": "frozen-madgraph",
+                "model": "ufo-sm",
+                "mode": mode,
+                "accuracy": "full",
+                "helicity_scope": "total",
+                "case_id": case.case_id,
+                "n_final": case.n_final,
+                "fixture": str(self.fixture_path),
+                "comparison": comparison.as_payload(),
+                "passed": comparison.passed,
+            }
+        )
+
+    def run(self) -> dict[str, object]:
+        probe_records, fallback_scopes = self._discover_selections()
+        selected = self._selected_artifacts(probe_records, fallback_scopes)
+        totals = self._total_artifacts(selected)
+
+        for model in MODELS:
+            for mode in MODES:
+                for accuracy in ACCURACIES:
+                    for case in self.selected_cases:
+                        selection = self.selections[(model, accuracy, case.case_id)]
+                        self._record_direct_fft(
+                            model=model,
+                            mode=mode,
+                            accuracy=accuracy,
+                            scope="selected",
+                            case=case,
+                            direct_record=selected[
+                                (model, mode, accuracy, "direct", case.case_id)
+                            ],
+                            fft_record=selected[
+                                (
+                                    model,
+                                    mode,
+                                    accuracy,
+                                    "symmetric-group-fft",
+                                    case.case_id,
+                                )
+                            ],
+                            selection=selection,
+                        )
+                for case in self.total_cases:
+                    self._record_direct_fft(
+                        model=model,
+                        mode=mode,
+                        accuracy="full",
+                        scope="total",
+                        case=case,
+                        direct_record=totals[(model, mode, "direct")],
+                        fft_record=totals[(model, mode, "symmetric-group-fft")],
+                        selection=None,
+                    )
+
+        for mode in MODES:
+            for case in self.total_cases:
+                self._record_frozen(
+                    mode=mode,
+                    case=case,
+                    fft_record=totals[("ufo-sm", mode, "symmetric-group-fft")],
+                )
+
+        expected = comparison_specs()
+        if len(self.comparisons) != len(expected):
+            raise FFTAcceptanceError(
+                f"campaign produced {len(self.comparisons)} comparisons; "
+                f"expected {len(expected)}"
+            )
+        reflection_census = self._validated_reflection_census()
+        accepted = all(bool(item["passed"]) for item in self.comparisons)
+        cache_payload: list[dict[str, object]] = []
+        for request, record in self.cache.entries:
+            entry = request.as_payload()
+            entry["artifact"] = str(record.path.relative_to(self.run_root))
+            entry["generation_count"] = 1
+            cache_payload.append(entry)
+        return {
+            "kind": GATE_KIND,
+            "schema_version": GATE_SCHEMA_VERSION,
+            "accepted": accepted,
+            "point_policy": {
+                "generator": "generic_validation_point",
+                "seed": POINT_SEED,
+            },
+            "comparison_policy": {
+                "relative_tolerance": canonical_decimal(RELATIVE_TOLERANCE),
+                "absolute_tolerance": None,
+            },
+            "on_the_fly_reflection_census": reflection_census,
+            "catalog": {
+                "source": "tools/performance_report/catalog.py:PROCESS_FAMILIES",
+                "selected_max_n_final": SELECTED_MAX_N_FINAL,
+                "selected_case_count_per_model": len(self.selected_cases),
+                "total_max_n_final": TOTAL_MAX_N_FINAL,
+                "total_case_count_per_model": len(self.total_cases),
+            },
+            "frozen_authority": {
+                "fixture": str(self.fixture_path),
+                "madgraph_version": self.fixture.madgraph_version,
+                "captured_model_source_sha256": (self.fixture.model_source_sha256),
+                "captured_driver_sha256": self.fixture.driver_sha256,
+                "madgraph_rerun": False,
+            },
+            "process_set_cache": {
+                "generation_count": self.cache.generation_count,
+                "per_process_generation": False,
+                "selected_execution": {
+                    "recurrence": "generation-specialized",
+                    "on-the-fly": "runtime-query-complete-coverage",
+                },
+                "on_the_fly_total_reuses_complete_selected_query_artifact": True,
+                "entries": cache_payload,
+            },
+            "selections": [
+                self.selections[key].as_payload() for key in sorted(self.selections)
+            ],
+            "comparisons": self.comparisons,
+            "comparison_counts": {
+                "direct_vs_fft": sum(
+                    item["authority"] == "direct-vs-fft" for item in self.comparisons
+                ),
+                "frozen_madgraph": sum(
+                    item["authority"] == "frozen-madgraph" for item in self.comparisons
+                ),
+                "total": len(self.comparisons),
+            },
+        }
+
+
+def _fresh_run_root(output_root: Path) -> Path:
+    resolved = output_root.expanduser().resolve(strict=False)
+    if not resolved.is_relative_to(ROOT):
+        raise FFTAcceptanceError("acceptance output must remain inside the workspace")
+    resolved.mkdir(parents=True, exist_ok=True)
+    stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+    run_root = resolved / f"run-{stamp}-{uuid.uuid4().hex[:10]}"
+    run_root.mkdir()
+    return run_root
+
+
+def _write_report(payload: Mapping[str, object], path: Path) -> None:
+    encoded = (
+        json.dumps(
+            payload,
+            ensure_ascii=True,
+            indent=2,
+            sort_keys=False,
+            allow_nan=False,
+        )
+        + "\n"
+    )
+    with path.open("x", encoding="ascii", newline="\n") as stream:
+        stream.write(encoded)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--fixture",
+        type=Path,
+        default=DEFAULT_FIXTURE,
+        help="tracked UFO-SM seed-101 numerical fixture",
+    )
+    parser.add_argument(
+        "--output-root",
+        type=Path,
+        default=ROOT / ".artifacts" / "fft-numerical-acceptance",
+        help="workspace-local parent for one fresh campaign directory",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="authenticate inputs and print the comparison plan without writes",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    fixture_path = args.fixture.expanduser().resolve(strict=True)
+    if args.dry_run:
+        print(
+            json.dumps(
+                dry_run_payload(fixture_path),
+                ensure_ascii=True,
+                indent=2,
+                allow_nan=False,
+            )
+        )
+        return 0
+
+    fixture = load_frozen_full_evidence(fixture_path)
+    if _fixture_case_ids(fixture) != tuple(
+        case.case_id for case in catalog_cases(TOTAL_MAX_N_FINAL)
+    ):
+        raise FFTAcceptanceError(
+            "the frozen UFO-SM fixture no longer matches the live n_final<=4 catalog"
+        )
+    run_root = _fresh_run_root(args.output_root)
+    payload = NativeAcceptanceHarness(
+        run_root,
+        fixture=fixture,
+        fixture_path=fixture_path,
+    ).run()
+    report = run_root / "report.json"
+    _write_report(payload, report)
+    print(report)
+    if not payload["accepted"]:
+        raise FFTAcceptanceMismatch(
+            f"FFT numerical acceptance failed; complete report: {report}"
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/fft_results_summary_pdf.py b/pyamplicol/tools/developer/fft_results_summary_pdf.py
new file mode 100644
index 0000000000..88909c8083
--- /dev/null
+++ b/pyamplicol/tools/developer/fft_results_summary_pdf.py
@@ -0,0 +1,557 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Assemble the published FullColor scaling plots into one summary PDF."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+try:
+    from reportlab.lib.pagesizes import A4, landscape
+    from reportlab.lib.utils import ImageReader
+    from reportlab.pdfbase import pdfmetrics
+    from reportlab.pdfgen import canvas
+except ModuleNotFoundError as error:  # pragma: no cover - environment dependent
+    raise SystemExit(
+        "fft_results_summary_pdf.py requires reportlab; use the bundled "
+        "Codex PDF runtime or install reportlab"
+    ) from error
+
+
+ROOT = Path(__file__).resolve().parents[2]
+RESULTS = ROOT / "IMPLEMENTATION_DOCS" / "RESULTS"
+FINAL_REPORT = (
+    RESULTS
+    / "fft-scaling-study"
+    / "data"
+    / "campaign-report-scalar-selected-n2-n9-final.json"
+)
+PLOT_MANIFEST_NAME = "plot-manifest.json"
+PLOT_DATA_NAME = "plot-data.json"
+PLOT_FILENAMES = (
+    "fullcolor-gg-generation.png",
+    "fullcolor-gg-warm-runtime.png",
+    "fullcolor-gg-rss.png",
+    "fullcolor-ddbar-generation.png",
+    "fullcolor-ddbar-warm-runtime.png",
+    "fullcolor-ddbar-rss.png",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class PlotPage:
+    section: str
+    path: Path
+
+
+def _plot_pages(
+    plot_directory: Path | None = None,
+    *,
+    helicity_workload: str = "fixed",
+) -> tuple[PlotPage, ...]:
+    if helicity_workload not in {"fixed", "sum"}:
+        raise ValueError("helicity_workload must be 'fixed' or 'sum'")
+    plot_root = RESULTS / "fft-scaling-study" / "plots"
+    return tuple(
+        PlotPage(
+            (
+                "Current-host fixed-helicity comparison (n=2..9)"
+                if helicity_workload == "fixed"
+                else "Current-host helicity-summed comparison (n=2..9)"
+            ),
+            (
+                plot_root
+                / (
+                    "scalar-selected-n2-n9-final"
+                    if helicity_workload == "fixed"
+                    else "scalar-helicity-sum-n2-n9-final"
+                )
+                if plot_directory is None
+                else plot_directory
+            )
+            / name,
+        )
+        for name in PLOT_FILENAMES
+    )
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=RESULTS / "summary_plots_final.pdf",
+        help=(
+            "output PDF (default: IMPLEMENTATION_DOCS/RESULTS/summary_plots_final.pdf)"
+        ),
+    )
+    parser.add_argument(
+        "--campaign-report",
+        type=Path,
+        default=FINAL_REPORT,
+        help=(
+            "report supplying FFT and helicity-coverage provenance for the PDF header"
+        ),
+    )
+    parser.add_argument(
+        "--plot-directory",
+        type=Path,
+        help=(
+            "directory containing the six plot PNGs (default: published final "
+            "plot directory)"
+        ),
+    )
+    return parser
+
+
+def _mapping(value: object, *, context: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise ValueError(f"{context} must be an object")
+    return value
+
+
+def _campaign_note(report: Mapping[str, Any]) -> str:
+    policy = _mapping(report.get("policy"), context="campaign policy")
+    if policy.get("fft_enabled") is not True:
+        raise ValueError("campaign policy must record fft_enabled=true")
+    contractions = _mapping(
+        policy.get("selected_pyamplicol_color_contractions"),
+        context="selected pyAmpliCol color contractions",
+    )
+    expected_contractions = {"direct", "symmetric-group-fft"}
+    for execution_mode in ("recurrence", "on-the-fly"):
+        raw = contractions.get(execution_mode)
+        selected = (
+            {str(contraction) for contraction in raw}
+            if isinstance(raw, Sequence) and not isinstance(raw, str)
+            else set()
+        )
+        if selected != expected_contractions:
+            raise ValueError(
+                "campaign policy must select direct and symmetric-group FFT for "
+                f"{execution_mode}"
+            )
+    measurement = _mapping(
+        policy.get("measurement"), context="campaign measurement policy"
+    )
+    if measurement.get("generation_helicity_coverage") != "all":
+        raise ValueError(
+            "campaign policy must record generation_helicity_coverage='all'"
+        )
+    helicity_workload = _campaign_helicity_workload(policy, measurement)
+    batch_size = measurement.get("warm_benchmark_batch_size")
+    if (
+        not isinstance(batch_size, int)
+        or isinstance(batch_size, bool)
+        or batch_size < 1
+    ):
+        raise ValueError(
+            "campaign policy must record a positive warm_benchmark_batch_size"
+        )
+    _validate_campaign_cell_workloads(report, helicity_workload)
+    if measurement.get("compiled_fft_enabled") is not False:
+        raise ValueError("campaign policy must record compiled_fft_enabled=false")
+    if helicity_workload == "fixed":
+        note = (
+            "--fft | recurrence: persisted all-helicity physical schedule | "
+            "OTF compact artifact: all runtime helicities\n"
+            "pyAmpliCol setup: generation + fresh load + first fixed-helicity "
+            "evaluation; OTF includes family warm-up\n"
+            "Reference setup: build/init/first pass | AmpliCol setup: "
+            "process/color-object generation\n"
+            "Warmed runtime measured separately | compiled FFT disabled\n"
+            f"pyAmpliCol CLI profile: batch {batch_size} (cyclic 10 points) | "
+            "Reference/AmpliCol: scalar aggregates normalized per point"
+        )
+    else:
+        note = (
+            "--fft | recurrence: persisted all-helicity physical schedule | "
+            "OTF compact artifact: all runtime helicities\n"
+            "pyAmpliCol setup: generation + fresh load + first complete helicity "
+            "sum; OTF includes family warm-up\n"
+            "Reference setup: build/init/first pass | AmpliCol setup: process/raw-"
+            "library generation/build + immutable snapshot\n"
+            "Warmed runtime measured separately | compiled FFT disabled\n"
+            f"pyAmpliCol CLI profile: batch {batch_size} (cyclic 10 points) | "
+            "Reference/AmpliCol: scalar aggregates normalized per point\n"
+            "AmpliCol: create-raw bulk H family + probe-local zero pruning | "
+            "Reference FFT: analytic-nonzero H sweep"
+        )
+    status = report.get("status")
+    if not isinstance(status, str) or not status.startswith("complete"):
+        return "IN PROGRESS SNAPSHOT | absent cells are unattempted\n" + note
+    memory_limit = measurement.get("memory_watchdog_gib")
+    generation_limit = measurement.get("generation_timeout_seconds")
+    runtime_limit = measurement.get("runtime_timeout_seconds")
+    if (memory_limit, generation_limit, runtime_limit) != (30.0, 3600.0, 3600.0):
+        return "CLUSTER SCAN | configured per-cell resource caps\n" + note
+    return note
+
+
+def _campaign_helicity_workload(
+    policy: Mapping[str, Any], measurement: Mapping[str, Any]
+) -> str:
+    measurement_declared = measurement.get("helicity_workload")
+    policy_declared = policy.get("helicity_workload")
+    if (
+        measurement_declared is not None
+        and policy_declared is not None
+        and str(measurement_declared) != str(policy_declared)
+    ):
+        raise ValueError(
+            "policy and measurement helicity_workload declarations disagree"
+        )
+    declared = (
+        measurement_declared
+        if measurement_declared is not None
+        else policy_declared
+    )
+    if declared is not None:
+        workload = str(declared)
+        if workload not in {"fixed", "sum"}:
+            raise ValueError("campaign helicity_workload must be 'fixed' or 'sum'")
+        if workload == "sum" and (
+            measurement.get("warm_fixed_helicity") is not False
+            or measurement.get("warm_helicity_sum") is not True
+        ):
+            raise ValueError(
+                "summed campaign must record warm_fixed_helicity=false and "
+                "warm_helicity_sum=true"
+            )
+        if workload == "fixed" and (
+            measurement.get("warm_fixed_helicity") is not True
+            or measurement.get("warm_helicity_sum") is True
+        ):
+            raise ValueError(
+                "fixed campaign must record warm_fixed_helicity=true without "
+                "warm_helicity_sum=true"
+            )
+    elif measurement.get("warm_helicity_sum") is True:
+        if measurement.get("warm_fixed_helicity") is True:
+            raise ValueError("campaign helicity workload markers are contradictory")
+        workload = "sum"
+    elif measurement.get("warm_fixed_helicity") is True:
+        workload = "fixed"
+    else:
+        raise ValueError(
+            "campaign policy must identify a fixed or summed warm-helicity workload"
+        )
+    if workload == "fixed" and measurement.get("warm_fixed_helicity") is not True:
+        raise ValueError("fixed campaign must record warm_fixed_helicity=true")
+    if workload == "sum" and measurement.get("warm_fixed_helicity") is True:
+        raise ValueError("summed campaign cannot record warm_fixed_helicity=true")
+    return workload
+
+
+def _cell_helicity_workload(cell: Mapping[str, Any]) -> str | None:
+    markers: set[str] = set()
+    declared = cell.get("helicity_workload")
+    if declared is not None:
+        workload = str(declared)
+        if workload not in {"fixed", "sum"}:
+            raise ValueError("measured cell helicity_workload must be 'fixed' or 'sum'")
+        markers.add(workload)
+    if cell.get("warm_helicity_sum") is True:
+        markers.add("sum")
+    if cell.get("warm_fixed_helicity") is True:
+        markers.add("fixed")
+    protocol = cell.get("protocol")
+    if isinstance(protocol, Mapping):
+        if protocol.get("helicity_summed") is True:
+            markers.add("sum")
+        if (
+            protocol.get("helicity_summed") is False
+            or protocol.get("warm_fixed_helicity") is True
+        ):
+            markers.add("fixed")
+    if len(markers) > 1:
+        raise ValueError("measured cell helicity workload markers are contradictory")
+    return next(iter(markers), None)
+
+
+def _validate_campaign_cell_workloads(
+    report: Mapping[str, Any], expected: str
+) -> None:
+    for section_name in ("cells", "runtime_series"):
+        section = report.get(section_name)
+        if not isinstance(section, Mapping):
+            continue
+        for family, raw_modes in section.items():
+            if not isinstance(raw_modes, Mapping):
+                continue
+            for mode, raw_cells in raw_modes.items():
+                if not isinstance(raw_cells, Mapping):
+                    continue
+                for raw_n, raw_cell in raw_cells.items():
+                    if not isinstance(raw_cell, Mapping):
+                        continue
+                    if raw_cell.get("status") != "measured":
+                        continue
+                    observed = _cell_helicity_workload(raw_cell)
+                    context = f"{section_name}.{family}.{mode}.n={raw_n}"
+                    if expected == "sum" and observed != "sum":
+                        raise ValueError(
+                            f"{context} is not authenticated as helicity-summed"
+                        )
+                    if expected == "fixed" and observed == "sum":
+                        raise ValueError(
+                            f"{context} is summed data in a fixed-helicity campaign"
+                        )
+
+
+def _load_campaign_note(path: Path) -> str:
+    report = _load_campaign(path)
+    return _campaign_note(report)
+
+
+def _load_campaign(path: Path) -> Mapping[str, Any]:
+    try:
+        report = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise ValueError(f"cannot read campaign report {path}: {error}") from error
+    if not isinstance(report, Mapping):
+        raise ValueError("campaign report must be a JSON object")
+    return report
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for chunk in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _validate_plot_manifest(
+    plot_directory: Path,
+    campaign_report: Path,
+    helicity_workload: str,
+) -> None:
+    manifest_path = plot_directory / PLOT_MANIFEST_NAME
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise ValueError(
+            f"cannot read plot manifest {manifest_path}: {error}"
+        ) from error
+    if not isinstance(manifest, Mapping):
+        raise ValueError("plot manifest must be a JSON object")
+    if (
+        manifest.get("kind") != "pyamplicol-fft-scaling-plots"
+        or manifest.get("schema_version") != 1
+    ):
+        raise ValueError("plot manifest has an unsupported identity or schema")
+    if manifest.get("report_sha256") != _sha256(campaign_report):
+        raise ValueError("plot manifest was rendered from a different campaign report")
+    if manifest.get("helicity_workload") != helicity_workload:
+        raise ValueError("plot manifest helicity workload does not match the campaign")
+    raw_plots = manifest.get("plots")
+    if not isinstance(raw_plots, Mapping) or set(raw_plots) != set(PLOT_FILENAMES):
+        raise ValueError("plot manifest does not name the exact published plot set")
+    for filename in PLOT_FILENAMES:
+        plot_path = plot_directory / filename
+        if raw_plots.get(filename) != _sha256(plot_path):
+            raise ValueError(f"plot manifest hash does not match {filename}")
+
+
+def _validated_plot_data_bytes(
+    plot_directory: Path,
+    campaign_report: Path,
+    helicity_workload: str,
+) -> bytes:
+    data_path = plot_directory / PLOT_DATA_NAME
+    try:
+        raw = data_path.read_bytes()
+        payload = json.loads(raw)
+    except (OSError, json.JSONDecodeError) as error:
+        raise ValueError(f"cannot read plot data {data_path}: {error}") from error
+    if not isinstance(payload, Mapping):
+        raise ValueError("plot data must be a JSON object")
+    if (
+        payload.get("kind") != "pyamplicol-fft-scaling-plot-data"
+        or payload.get("schema_version") != 1
+    ):
+        raise ValueError("plot data has an unsupported identity or schema")
+    if payload.get("report_sha256") != _sha256(campaign_report):
+        raise ValueError("plot data was rendered from a different campaign report")
+    if payload.get("helicity_workload") != helicity_workload:
+        raise ValueError("plot data helicity workload does not match the campaign")
+    families = payload.get("families")
+    if not isinstance(families, Mapping) or set(families) != {"gg", "ddbar"}:
+        raise ValueError("plot data must contain gg and ddbar families")
+    return raw
+
+
+def _publish_plot_data_sidecar(raw: bytes, output: Path) -> Path:
+    destination = output.with_suffix(".json")
+    temporary = destination.with_suffix(destination.suffix + ".tmp")
+    temporary.write_bytes(raw)
+    temporary.replace(destination)
+    return destination
+
+
+def _campaign_note_lines(
+    campaign_note: str,
+    *,
+    available_width: float,
+    font_name: str = "Helvetica",
+    font_size: float = 6.6,
+) -> tuple[str, ...]:
+    """Preserve authored line breaks and wrap any line to the page width."""
+
+    wrapped: list[str] = []
+    for source_line in campaign_note.splitlines():
+        words = source_line.split()
+        if not words:
+            wrapped.append("")
+            continue
+        current = words[0]
+        for word in words[1:]:
+            candidate = f"{current} {word}"
+            candidate_width = pdfmetrics.stringWidth(
+                candidate, font_name, font_size
+            )
+            if candidate_width <= available_width:
+                current = candidate
+            else:
+                wrapped.append(current)
+                current = word
+        wrapped.append(current)
+    return tuple(wrapped)
+
+
+def _campaign_header_height(note_lines: Sequence[str]) -> float:
+    """Reserve a title band plus one eight-point row for every note line."""
+
+    return max(31.0, 15.0 + 8.0 * len(note_lines))
+
+
+def _draw_page(
+    document: canvas.Canvas,
+    page: PlotPage,
+    *,
+    page_number: int,
+    page_count: int,
+    campaign_note: str,
+) -> None:
+    width, height = landscape(A4)
+    margin = 18.0
+    footer_height = 13.0
+    available_width = width - 2 * margin
+    note_lines = _campaign_note_lines(
+        campaign_note,
+        available_width=available_width,
+    )
+    header_height = _campaign_header_height(note_lines)
+    available_height = height - 2 * margin - header_height - footer_height
+
+    image_width, image_height = ImageReader(page.path).getSize()
+    scale = min(available_width / image_width, available_height / image_height)
+    drawn_width = image_width * scale
+    drawn_height = image_height * scale
+    x = (width - drawn_width) / 2
+    y = margin + footer_height + (available_height - drawn_height) / 2
+
+    document.setFillColorRGB(1, 1, 1)
+    document.rect(0, 0, width, height, fill=1, stroke=0)
+    document.setFillColorRGB(0.14, 0.17, 0.20)
+    document.setFont("Helvetica-Bold", 9)
+    document.drawString(margin, height - margin - 7, page.section)
+    document.setFont("Helvetica", 6.6)
+    document.setFillColorRGB(0.35, 0.39, 0.43)
+    for line_index, line in enumerate(note_lines):
+        document.drawString(
+            margin,
+            height - margin - 15.5 - 8.0 * line_index,
+            line,
+        )
+    document.drawImage(
+        str(page.path),
+        x,
+        y,
+        width=drawn_width,
+        height=drawn_height,
+        preserveAspectRatio=True,
+        anchor="c",
+    )
+    document.setFillColorRGB(0.35, 0.39, 0.43)
+    document.setFont("Helvetica", 7.5)
+    document.drawRightString(
+        width - margin,
+        margin - 1,
+        f"pyAmpliCol FullColor scaling results - page {page_number}/{page_count}",
+    )
+    document.showPage()
+
+
+def main() -> int:
+    arguments = _parser().parse_args()
+    try:
+        campaign_report = _load_campaign(arguments.campaign_report)
+        campaign_note = _campaign_note(campaign_report)
+        policy = _mapping(campaign_report.get("policy"), context="campaign policy")
+        measurement = _mapping(
+            policy.get("measurement"), context="campaign measurement policy"
+        )
+        helicity_workload = _campaign_helicity_workload(policy, measurement)
+    except ValueError as error:
+        raise SystemExit(f"invalid campaign provenance: {error}") from error
+    pages = _plot_pages(
+        arguments.plot_directory,
+        helicity_workload=helicity_workload,
+    )
+    missing = [page.path for page in pages if not page.path.is_file()]
+    if missing:
+        raise SystemExit("missing published plot(s): " + ", ".join(map(str, missing)))
+    try:
+        _validate_plot_manifest(
+            pages[0].path.parent,
+            arguments.campaign_report,
+            helicity_workload,
+        )
+        plot_data = _validated_plot_data_bytes(
+            pages[0].path.parent,
+            arguments.campaign_report,
+            helicity_workload,
+        )
+    except ValueError as error:
+        raise SystemExit(f"invalid plot provenance: {error}") from error
+
+    output = arguments.output.expanduser().resolve(strict=False)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    temporary = output.with_suffix(output.suffix + ".tmp")
+    document = canvas.Canvas(
+        str(temporary),
+        pagesize=landscape(A4),
+        pageCompression=1,
+        invariant=1,
+    )
+    document.setTitle(
+        "pyAmpliCol FullColor scaling summary plots"
+        if helicity_workload == "fixed"
+        else "pyAmpliCol FullColor helicity-summed scaling summary plots"
+    )
+    document.setAuthor("pyAmpliCol")
+    for index, page in enumerate(pages, start=1):
+        _draw_page(
+            document,
+            page,
+            page_number=index,
+            page_count=len(pages),
+            campaign_note=campaign_note,
+        )
+    document.save()
+    temporary.replace(output)
+    _publish_plot_data_sidecar(plot_data, output)
+    print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/fft_scaling_final_publication_report.py b/pyamplicol/tools/developer/fft_scaling_final_publication_report.py
new file mode 100644
index 0000000000..35930e35f2
--- /dev/null
+++ b/pyamplicol/tools/developer/fft_scaling_final_publication_report.py
@@ -0,0 +1,1275 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Merge the fresh n=2..9 scaling campaign with its MadGraph series.
+
+This is intentionally a narrow publication boundary.  It does not splice old
+pyAmpliCol measurements into the fresh campaign: the campaign cells and policy
+are retained as one source, while the independently measured MadGraph cells are
+attached as an external series after their resource, event, and numerical
+provenance has been authenticated.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import re
+import sys
+from collections import Counter
+from collections.abc import Mapping, Sequence
+from copy import deepcopy
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.developer import fft_madgraph_selected_runtime as madgraph  # noqa: E402
+from tools.developer import fft_scaling_selected_scalar_report as selected  # noqa: E402
+
+RESULTS = ROOT / "IMPLEMENTATION_DOCS" / "RESULTS" / "fft-scaling-study"
+DATA = RESULTS / "data"
+
+CAMPAIGN_KIND = "pyamplicol-fullcolor-fft-scaling-study"
+FINAL_KIND = "pyamplicol-fullcolor-fft-scaling-final-publication"
+SCHEMA_VERSION = 1
+FINAL_MULTIPLICITIES = tuple(range(2, 10))
+MADGRAPH_MAX_MEASURED_MULTIPLICITY = 6
+FAMILY_MODES = {
+    "gg": (
+        "reference-fft",
+        "amplicol",
+        "recurrence-direct",
+        "recurrence-fft",
+        "otf-direct",
+        "otf-fft",
+    ),
+    "ddbar": (
+        "amplicol",
+        "recurrence-direct",
+        "recurrence-fft",
+        "otf-direct",
+        "otf-fft",
+    ),
+}
+MADGRAPH_FAMILY_MAX_MEASURED_MULTIPLICITY = (
+    madgraph.protocol_measured_multiplicity_limits()
+)
+SOURCE_MODE = {"gg": "reference-fft", "ddbar": "recurrence-fft"}
+SUM_SOURCE_MODE = {"gg": "recurrence-fft", "ddbar": "recurrence-fft"}
+CANDIDATE_MODE_CONTRACT = {
+    "recurrence-direct": ("recurrence", "direct"),
+    "recurrence-fft": ("recurrence", "symmetric-group-fft"),
+    "otf-direct": ("on-the-fly", "direct"),
+    "otf-fft": ("on-the-fly", "symmetric-group-fft"),
+}
+METRIC_KEYS = (
+    "generation_seconds",
+    "warm_seconds_per_point",
+    "max_rss_kib",
+)
+EXPECTED_EXPRESSIONS = {
+    "gg": "g g > g g + (n-2)*g",
+    "ddbar": "d d~ > d d~ + (n-2)*g",
+}
+EXPECTED_RATIO_REFERENCES = {"gg": "reference-fft", "ddbar": "amplicol"}
+MAX_GENERATION_SECONDS = 3600.0
+MAX_RUNTIME_SECONDS = 3600.0
+MAX_RSS_GIB = 30.0
+MAX_RSS_KIB = MAX_RSS_GIB * 1024**2
+POINT_COUNT = 10
+WARM_SAMPLE_COUNT = madgraph.WARM_SAMPLE_COUNT
+
+
+class PublicationMergeError(RuntimeError):
+    """The two inputs cannot be merged without weakening their contracts."""
+
+
+def _expected_madgraph_iden(family: str, n: int) -> int:
+    if family == "gg":
+        return 256 * math.factorial(n)
+    if family == "ddbar":
+        return 36 * math.factorial(n - 2)
+    raise PublicationMergeError(f"unsupported MadGraph family {family!r}")
+
+
+def _source_mode(family: str, helicity_workload: str) -> str:
+    modes = SUM_SOURCE_MODE if helicity_workload == "sum" else SOURCE_MODE
+    try:
+        return modes[family]
+    except KeyError as error:
+        raise PublicationMergeError(
+            f"unsupported MadGraph family {family!r}"
+        ) from error
+
+
+def _madgraph_normalization_factor(
+    family: str, n: int, *, helicity_workload: str = "fixed"
+) -> float:
+    if helicity_workload == "sum":
+        return 1.0
+    if helicity_workload != "fixed":
+        raise PublicationMergeError(
+            f"unsupported helicity workload {helicity_workload!r}"
+        )
+    return 1.0 if family == "gg" else 1.0 / _expected_madgraph_iden(family, n)
+
+
+def _helicity_workload(policy: Mapping[str, Any]) -> str:
+    measurement = _mapping(
+        policy.get("measurement"), context="campaign measurement policy"
+    )
+    declared = measurement.get("helicity_workload")
+    if declared is None:
+        workload = "sum" if measurement.get("warm_helicity_sum") is True else "fixed"
+    else:
+        workload = str(declared)
+    if workload not in {"fixed", "sum"}:
+        raise PublicationMergeError("campaign helicity workload is unsupported")
+    if workload == "sum" and (
+        measurement.get("warm_fixed_helicity") is not False
+        or measurement.get("warm_helicity_sum") is not True
+    ):
+        raise PublicationMergeError("summed campaign helicity markers are incompatible")
+    if workload == "fixed" and (
+        measurement.get("warm_fixed_helicity") is not True
+        or measurement.get("warm_helicity_sum") is True
+    ):
+        raise PublicationMergeError("fixed campaign helicity markers are incompatible")
+    return workload
+
+
+def _overlay_helicity_workload(policy: Mapping[str, Any]) -> str:
+    declared = policy.get("helicity_workload")
+    if declared is None:
+        workload = "sum" if policy.get("warm_helicity_sum") is True else "fixed"
+    else:
+        workload = str(declared)
+    if workload not in {"fixed", "sum"}:
+        raise PublicationMergeError("MadGraph helicity workload is unsupported")
+    if workload == "sum" and (
+        policy.get("warm_fixed_helicity") is not False
+        or policy.get("warm_helicity_sum") is not True
+    ):
+        raise PublicationMergeError("summed MadGraph helicity markers are incompatible")
+    if workload == "fixed" and (
+        policy.get("warm_fixed_helicity") is not True
+        or policy.get("warm_helicity_sum") is True
+    ):
+        raise PublicationMergeError("fixed MadGraph helicity markers are incompatible")
+    return workload
+
+
+@dataclass(frozen=True, slots=True)
+class Document:
+    key: str
+    path: Path
+    sha256: str
+    payload: dict[str, Any]
+
+    @property
+    def display_path(self) -> str:
+        try:
+            return str(self.path.relative_to(ROOT))
+        except ValueError:
+            return str(self.path)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--campaign-report",
+        type=Path,
+        default=(
+            RESULTS / "raw" / "runs" / "final-publication-scalar-n2-n9" / "report.json"
+        ),
+        help="fresh all-helicity pyAmpliCol/Reference/AmpliCol report",
+    )
+    parser.add_argument(
+        "--madgraph-overlay",
+        type=Path,
+        required=True,
+        help="completed live MadGraph runtime-series overlay",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=DATA / "campaign-report-scalar-selected-n2-n9-final.json",
+        help="final publication report",
+    )
+    return parser
+
+
+def _sha256_bytes(raw: bytes) -> str:
+    return hashlib.sha256(raw).hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    try:
+        with path.open("rb") as stream:
+            for block in iter(lambda: stream.read(1024 * 1024), b""):
+                digest.update(block)
+    except OSError as error:
+        raise PublicationMergeError(f"cannot hash {path}: {error}") from error
+    return digest.hexdigest()
+
+
+def _load_document(key: str, path: Path) -> Document:
+    path = path.expanduser().resolve(strict=False)
+    try:
+        raw = path.read_bytes()
+        payload = json.loads(raw)
+    except (OSError, json.JSONDecodeError) as error:
+        raise PublicationMergeError(f"cannot read {key} {path}: {error}") from error
+    if not isinstance(payload, dict):
+        raise PublicationMergeError(f"{key} must be a JSON object")
+    return Document(key=key, path=path, sha256=_sha256_bytes(raw), payload=payload)
+
+
+def _mapping(value: object, *, context: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise PublicationMergeError(f"{context} must be an object")
+    return value
+
+
+def _measurement_host(value: object, *, context: str) -> dict[str, Any]:
+    try:
+        return madgraph.validate_measurement_host(value, context=context)
+    except madgraph.SelectedMadGraphError as error:
+        raise PublicationMergeError(str(error)) from error
+
+
+def _sequence(value: object, *, context: str) -> Sequence[Any]:
+    if not isinstance(value, Sequence) or isinstance(value, str):
+        raise PublicationMergeError(f"{context} must be an array")
+    return value
+
+
+def _finite_number(value: object, *, context: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        raise PublicationMergeError(f"{context} must be a finite number")
+    result = float(value)
+    if not math.isfinite(result):
+        raise PublicationMergeError(f"{context} must be a finite number")
+    return result
+
+
+def _positive_number(value: object, *, context: str) -> float:
+    result = _finite_number(value, context=context)
+    if result <= 0.0:
+        raise PublicationMergeError(f"{context} must be positive")
+    return result
+
+
+def _process_expression(family: str, n: int) -> str:
+    extra = " ".join("g" for _ in range(n - 2))
+    base = "g g > g g" if family == "gg" else "d d~ > d d~"
+    return base + (f" {extra}" if extra else "")
+
+
+def _relative_error(left: float, right: float) -> float:
+    if left == right:
+        return 0.0
+    return abs(left - right) / max(abs(left), abs(right), 1.0e-300)
+
+
+def _validate_limit(
+    raw_limits: Mapping[str, Any], key: str, expected_limit: float
+) -> None:
+    limit = _mapping(raw_limits.get(key), context=f"cell_admission_limits.{key}")
+    if (
+        limit.get("operator") != "<"
+        or _finite_number(
+            limit.get("limit"), context=f"cell_admission_limits.{key}.limit"
+        )
+        != expected_limit
+    ):
+        raise PublicationMergeError(
+            f"cell_admission_limits.{key} must be strictly < {expected_limit:g}"
+        )
+
+
+def _validate_campaign_policy(document: Document) -> Mapping[str, Any]:
+    report = document.payload
+    if report.get("kind") != CAMPAIGN_KIND or report.get("schema_version") != 1:
+        raise PublicationMergeError("campaign report has the wrong kind or schema")
+    policy = _mapping(report.get("policy"), context="campaign policy")
+    if policy.get("kind") != CAMPAIGN_KIND or policy.get("schema_version") != 1:
+        raise PublicationMergeError("campaign policy has the wrong kind or schema")
+    if policy.get("final_state_multiplicities") != list(FINAL_MULTIPLICITIES):
+        raise PublicationMergeError("campaign must physically cover only n=2..9")
+    if policy.get("total_external_particles") != [n + 2 for n in FINAL_MULTIPLICITIES]:
+        raise PublicationMergeError("campaign total-external-particle range is wrong")
+    if policy.get("fft_enabled") is not True:
+        raise PublicationMergeError("campaign policy must record --fft")
+    contractions = _mapping(
+        policy.get("selected_pyamplicol_color_contractions"),
+        context="selected pyAmpliCol contractions",
+    )
+    expected_contractions = {
+        "recurrence": ["direct", "symmetric-group-fft"],
+        "on-the-fly": ["direct", "symmetric-group-fft"],
+    }
+    if dict(contractions) != expected_contractions:
+        raise PublicationMergeError(
+            "campaign must select direct and symmetric-group FFT for recurrence "
+            "and on-the-fly only"
+        )
+
+    raw_families = _mapping(
+        policy.get("process_families"), context="campaign process families"
+    )
+    if set(raw_families) != set(FAMILY_MODES):
+        raise PublicationMergeError("campaign must contain exactly gg and ddbar")
+    for family, expected_modes in FAMILY_MODES.items():
+        family_policy = _mapping(
+            raw_families.get(family), context=f"campaign process family {family}"
+        )
+        if family_policy.get("expression") != EXPECTED_EXPRESSIONS[family]:
+            raise PublicationMergeError(f"campaign {family} expression is wrong")
+        if family_policy.get("ratio_reference") != EXPECTED_RATIO_REFERENCES[family]:
+            raise PublicationMergeError(f"campaign {family} ratio baseline is wrong")
+        if family_policy.get("modes") != list(expected_modes):
+            raise PublicationMergeError(
+                f"campaign {family} must select exactly {list(expected_modes)}"
+            )
+
+    measurement = _mapping(
+        policy.get("measurement"), context="campaign measurement policy"
+    )
+    helicity_workload = _helicity_workload(policy)
+    expected_measurement = {
+        "color_accuracy": "full",
+        "n_definition": "final-state-particle-count",
+        "generation_helicity_coverage": "all",
+        "warm_fixed_helicity": helicity_workload == "fixed",
+        "warm_benchmark_batch_size": 128,
+        "warm_sample_count": WARM_SAMPLE_COUNT,
+        "compiled_fft_enabled": False,
+        "memory_policy": "per-cell-strictly-below-publication-ceiling",
+    }
+    for key, expected in expected_measurement.items():
+        if measurement.get(key) != expected:
+            raise PublicationMergeError(
+                f"campaign measurement policy has incompatible {key}"
+            )
+    if (
+        _finite_number(
+            measurement.get("requested_memory_ceiling_gib"),
+            context="requested memory ceiling",
+        )
+        != MAX_RSS_GIB
+        or _finite_number(
+            measurement.get("memory_watchdog_gib"), context="memory watchdog"
+        )
+        != MAX_RSS_GIB
+    ):
+        raise PublicationMergeError("campaign memory policy must use the 30-GiB cap")
+    limits = _mapping(
+        measurement.get("cell_admission_limits"), context="cell admission limits"
+    )
+    _validate_limit(limits, "generation_seconds", MAX_GENERATION_SECONDS)
+    _validate_limit(limits, "runtime_seconds", MAX_RUNTIME_SECONDS)
+    _validate_limit(limits, "peak_rss_gib", MAX_RSS_GIB)
+
+    run_root_raw = policy.get("run_root")
+    if not isinstance(run_root_raw, str) or not run_root_raw:
+        raise PublicationMergeError("campaign policy.run_root is required")
+    if Path(run_root_raw).expanduser().resolve(strict=False) != document.path.parent:
+        raise PublicationMergeError("campaign report is outside its recorded run_root")
+    return policy
+
+
+def campaign_policy_is_publication_profile(report: Mapping[str, Any]) -> bool:
+    """Return whether a report declares the exact canonical publication policy.
+
+    Cell and overlay authentication deliberately remain in the strict merger;
+    callers use this only to decide whether that merger is the required render
+    boundary.
+    """
+
+    try:
+        payload = dict(report)
+        policy = payload.get("policy")
+        run_root = policy.get("run_root") if isinstance(policy, Mapping) else None
+        if not isinstance(run_root, str) or not run_root:
+            return False
+        _validate_campaign_policy(
+            Document(
+                key="campaign policy probe",
+                path=Path(run_root) / "report.json",
+                sha256="0" * 64,
+                payload=payload,
+            )
+        )
+    except PublicationMergeError:
+        return False
+    return True
+
+
+def _validate_helicity(value: object, *, n: int, context: str) -> tuple[int, ...]:
+    raw = _sequence(value, context=context)
+    if len(raw) != n + 2 or any(
+        not isinstance(item, int) or isinstance(item, bool) or item not in (-1, 1)
+        for item in raw
+    ):
+        raise PublicationMergeError(f"{context} is invalid")
+    return tuple(int(item) for item in raw)
+
+
+def _validate_points(
+    value: object,
+    *,
+    context: str,
+    expected_count: int = POINT_COUNT,
+) -> tuple[float, ...]:
+    raw = _sequence(value, context=context)
+    points = tuple(_finite_number(item, context=context) for item in raw)
+    if len(points) != expected_count or not any(point != 0.0 for point in points):
+        raise PublicationMergeError(
+            f"{context} must contain exactly {expected_count} values with a "
+            "nonzero result"
+        )
+    return points
+
+
+def _validate_campaign_cells(
+    document: Document, *, helicity_workload: str = "fixed"
+) -> Counter[str]:
+    raw_cells = _mapping(document.payload.get("cells"), context="campaign cells")
+    if set(raw_cells) != set(FAMILY_MODES):
+        raise PublicationMergeError("campaign cells must contain exactly gg and ddbar")
+    status_counts: Counter[str] = Counter()
+    for family, expected_modes in FAMILY_MODES.items():
+        family_cells = _mapping(
+            raw_cells.get(family), context=f"campaign cells.{family}"
+        )
+        if set(family_cells) != set(expected_modes):
+            raise PublicationMergeError(
+                f"campaign cells.{family} has an unexpected mode set"
+            )
+        for mode in expected_modes:
+            mode_cells = _mapping(
+                family_cells.get(mode), context=f"campaign cells.{family}.{mode}"
+            )
+            if set(mode_cells) != {str(n) for n in FINAL_MULTIPLICITIES}:
+                raise PublicationMergeError(
+                    f"campaign cells.{family}.{mode} must describe n=2..9"
+                )
+            frontier_seen = False
+            for n in FINAL_MULTIPLICITIES:
+                context = f"campaign cells.{family}.{mode}.{n}"
+                cell = _mapping(mode_cells.get(str(n)), context=context)
+                status = cell.get("status")
+                if status not in {"measured", "failed", "skipped"}:
+                    raise PublicationMergeError(f"{context}.status is unsupported")
+                if status == "measured" and frontier_seen:
+                    raise PublicationMergeError(
+                        f"{context} resumes measurement after its availability frontier"
+                    )
+                if status == "failed" and frontier_seen:
+                    raise PublicationMergeError(
+                        f"{context} repeats a failure after its availability frontier"
+                    )
+                if (
+                    status == "failed"
+                    and cell.get("censors_higher_multiplicities") is not True
+                ):
+                    raise PublicationMergeError(
+                        f"{context} records a non-censoring failure in a "
+                        "completed campaign"
+                    )
+                if status == "skipped" and not isinstance(
+                    cell.get("censors_higher_multiplicities"), bool
+                ):
+                    raise PublicationMergeError(
+                        f"{context} must state whether its skip censors higher n"
+                    )
+                if status != "measured" and not frontier_seen:
+                    frontier_seen = True
+                for key, expected in (
+                    ("family", family),
+                    ("mode", mode),
+                    ("n", n),
+                    ("total_external", n + 2),
+                    ("process", _process_expression(family, n)),
+                    ("color_accuracy", "full"),
+                ):
+                    if cell.get(key) != expected:
+                        raise PublicationMergeError(f"{context}.{key} is wrong")
+                label = cell.get("label")
+                if not isinstance(label, str) or not label.strip():
+                    raise PublicationMergeError(f"{context}.label is required")
+                candidate_contract = CANDIDATE_MODE_CONTRACT.get(mode)
+                if candidate_contract is not None:
+                    expected_execution, expected_contraction = candidate_contract
+                    for key, expected in (
+                        ("execution_mode", expected_execution),
+                        ("color_contraction", expected_contraction),
+                        ("generation_helicity_coverage", "all"),
+                        ("warm_fixed_helicity", helicity_workload == "fixed"),
+                    ):
+                        if cell.get(key) != expected:
+                            raise PublicationMergeError(f"{context}.{key} is wrong")
+                    if helicity_workload == "sum" and cell.get(
+                        "warm_helicity_sum"
+                    ) is not True:
+                        raise PublicationMergeError(
+                            f"{context}.warm_helicity_sum is wrong"
+                        )
+                if status == "measured":
+                    metrics = _mapping(
+                        cell.get("metrics"), context=f"{context}.metrics"
+                    )
+                    values = {
+                        key: _positive_number(
+                            metrics.get(key), context=f"{context}.metrics.{key}"
+                        )
+                        for key in METRIC_KEYS
+                    }
+                    if values["generation_seconds"] >= MAX_GENERATION_SECONDS:
+                        raise PublicationMergeError(
+                            f"{context} violates the strict one-hour generation cap"
+                        )
+                    if values["max_rss_kib"] >= MAX_RSS_KIB:
+                        raise PublicationMergeError(
+                            f"{context} violates the strict 30-GiB RSS cap"
+                        )
+                    _validate_helicity(cell.get("helicity"), n=n, context=context)
+                    _validate_points(
+                        cell.get("point_values"),
+                        context=context,
+                        expected_count=1 if mode == "amplicol" else POINT_COUNT,
+                    )
+                    event_paths = _sequence(
+                        cell.get("event_paths"), context=f"{context}.event_paths"
+                    )
+                    if len(event_paths) != POINT_COUNT or any(
+                        not isinstance(path, str) or not path for path in event_paths
+                    ):
+                        raise PublicationMergeError(
+                            f"{context}.event_paths must contain ten paths"
+                        )
+                    numerical = cell.get("numerical")
+                    if isinstance(numerical, Mapping):
+                        available = numerical.get("available")
+                        if available is True and numerical.get("passes") is not True:
+                            raise PublicationMergeError(
+                                f"{context} failed its numerical comparison"
+                            )
+                else:
+                    reason = cell.get("failure_reason")
+                    if not isinstance(reason, str) or not reason.strip():
+                        raise PublicationMergeError(
+                            f"{context}.failure_reason is required"
+                        )
+                status_counts[str(status)] += 1
+
+    expected_status = (
+        "complete-with-failures" if status_counts["failed"] else "complete"
+    )
+    if document.payload.get("status") != expected_status:
+        raise PublicationMergeError("campaign status disagrees with its cells")
+    if document.payload.get("failure_count") != status_counts["failed"]:
+        raise PublicationMergeError("campaign failure_count disagrees with its cells")
+    return status_counts
+
+
+def _validate_madgraph_policy(
+    document: Document, *, helicity_workload: str = "fixed"
+) -> None:
+    report = document.payload
+    if (
+        report.get("kind") != selected.RUNTIME_SERIES_OVERLAY_KIND
+        or report.get("schema_version") != SCHEMA_VERSION
+    ):
+        raise PublicationMergeError("MadGraph overlay has the wrong kind or schema")
+    policy = _mapping(report.get("policy"), context="MadGraph policy")
+    if _overlay_helicity_workload(policy) != helicity_workload:
+        raise PublicationMergeError(
+            "MadGraph overlay helicity workload differs from the campaign"
+        )
+    expected = {
+        "final_state_multiplicities": list(FINAL_MULTIPLICITIES),
+        "process_families": list(FAMILY_MODES),
+        "point_validation_count": POINT_COUNT,
+        "warm_timed_point_index": 1,
+        "warm_sample_count": WARM_SAMPLE_COUNT,
+        "watchdog_enforced_per_generation_build_and_runtime": True,
+        "generation_helicity_coverage": "all",
+        "warm_fixed_helicity": helicity_workload == "fixed",
+        "maximum_measured_multiplicity": MADGRAPH_MAX_MEASURED_MULTIPLICITY,
+        "family_maximum_measured_multiplicity": (
+            MADGRAPH_FAMILY_MAX_MEASURED_MULTIPLICITY
+        ),
+        "higher_multiplicity_policy": "not-applicable-protocol-scope",
+    }
+    for key, value in expected.items():
+        if policy.get(key) != value:
+            raise PublicationMergeError(f"MadGraph policy has incompatible {key}")
+    timeout = _positive_number(
+        policy.get("generation_timeout_seconds"),
+        context="MadGraph generation timeout",
+    )
+    if timeout >= MAX_GENERATION_SECONDS:
+        raise PublicationMergeError(
+            "MadGraph generation timeout must be below one hour"
+        )
+    memory = _positive_number(
+        policy.get("outer_memory_watchdog_gib"), context="MadGraph memory watchdog"
+    )
+    if memory > MAX_RSS_GIB:
+        raise PublicationMergeError("MadGraph memory watchdog exceeds 30 GiB")
+    metric_scope = _mapping(policy.get("metric_scope"), context="MadGraph metric scope")
+    if set(metric_scope) != set(METRIC_KEYS) or any(
+        not isinstance(value, str) or not value.strip()
+        for value in metric_scope.values()
+    ):
+        raise PublicationMergeError(
+            "MadGraph metric scope must define all three metrics"
+        )
+
+
+def _madgraph_protocol_scope_categories(family: str, n: int, limit: int) -> set[str]:
+    categories = {f"protocol-scope-n>{limit}"}
+    if family == "gg" and n == 6:
+        categories.add("protocol-scope-pure-gluon-n6")
+    return categories
+
+
+def _resolve_recorded_path(raw: object, *, context: str) -> Path:
+    if not isinstance(raw, str) or not raw:
+        raise PublicationMergeError(f"{context} must be a nonempty path")
+    path = Path(raw).expanduser()
+    if not path.is_absolute():
+        path = ROOT / path
+    return path.resolve(strict=False)
+
+
+def _event_identity(cell: Mapping[str, Any], *, context: str) -> tuple[Path, ...]:
+    raw_paths = _sequence(cell.get("event_paths"), context=f"{context}.event_paths")
+    raw_hashes = _sequence(cell.get("event_sha256"), context=f"{context}.event_sha256")
+    if len(raw_paths) != POINT_COUNT or len(raw_hashes) != POINT_COUNT:
+        raise PublicationMergeError(f"{context} must identify ten events")
+    paths = tuple(
+        _resolve_recorded_path(path, context=f"{context}.event_paths")
+        for path in raw_paths
+    )
+    for path, expected_hash in zip(paths, raw_hashes, strict=True):
+        if (
+            not isinstance(expected_hash, str)
+            or len(expected_hash) != 64
+            or _sha256_file(path) != expected_hash
+        ):
+            raise PublicationMergeError(f"{context} event SHA-256 provenance differs")
+    return paths
+
+
+def _source_cell(
+    report: Mapping[str, Any], family: str, mode: str, n: int, *, context: str
+) -> Mapping[str, Any]:
+    cells = _mapping(report.get("cells"), context=f"{context}.cells")
+    family_cells = _mapping(cells.get(family), context=f"{context}.cells.{family}")
+    mode_cells = _mapping(
+        family_cells.get(mode), context=f"{context}.cells.{family}.{mode}"
+    )
+    return _mapping(
+        mode_cells.get(str(n)), context=f"{context}.cells.{family}.{mode}.{n}"
+    )
+
+
+def _cell_event_hashes(cell: Mapping[str, Any], *, context: str) -> tuple[str, ...]:
+    raw_paths = _sequence(cell.get("event_paths"), context=f"{context}.event_paths")
+    if len(raw_paths) != POINT_COUNT:
+        raise PublicationMergeError(f"{context}.event_paths must contain ten paths")
+    return tuple(
+        _sha256_file(_resolve_recorded_path(path, context=f"{context}.event_paths"))
+        for path in raw_paths
+    )
+
+
+def _validate_summed_retained_sources(
+    provenance: Mapping[str, Any], *, n: int, context: str
+) -> None:
+    retained = _mapping(
+        provenance.get("retained"), context=f"{context}.provenance.retained"
+    )
+    matrix_path = _resolve_recorded_path(
+        retained.get("matrix_source"), context=f"{context}.retained.matrix_source"
+    )
+    check_path = _resolve_recorded_path(
+        retained.get("check_source"), context=f"{context}.retained.check_source"
+    )
+    matrix_sha = _sha256_file(matrix_path)
+    check_sha = _sha256_file(check_path)
+    if (
+        retained.get("matrix_sha256") != matrix_sha
+        or provenance.get("matrix_sha256") != matrix_sha
+        or retained.get("check_source_sha256") != check_sha
+        or provenance.get("check_source_sha256") != check_sha
+    ):
+        raise PublicationMergeError(f"{context} retained source SHA-256 differs")
+    try:
+        matrix_source = matrix_path.read_text(encoding="utf-8")
+        check_source = check_path.read_text(encoding="ascii")
+    except (OSError, UnicodeError) as error:
+        raise PublicationMergeError(
+            f"{context} cannot read retained generated sources: {error}"
+        ) from error
+    expected_ncomb = 2 ** (n + 2)
+    ncomb_values = {
+        int(value)
+        for value in re.findall(r"\bNCOMB\s*=\s*(\d+)\b", matrix_source, re.I)
+    }
+    if expected_ncomb not in ncomb_values or re.search(
+        r"INTEGER\s+NHEL\s*\(\s*NEXTERNAL\s*,\s*NCOMB\s*\)",
+        matrix_source,
+        re.I,
+    ) is None:
+        raise PublicationMergeError(f"{context} has incompatible NCOMB/NHEL source")
+    iden = provenance.get("smatrix_iden")
+    if (
+        not isinstance(iden, int)
+        or len(
+            re.findall(
+                rf"^[ \t]{{6,}}DATA[ \t]+IDEN[ \t]*/[ \t]*{iden}[ \t]*/",
+                matrix_source,
+                re.I | re.M,
+            )
+        )
+        != 1
+        or len(
+            re.findall(
+                r"^[ \t]{6,}ANS[ \t]*=[ \t]*ANS[ \t]*/[ \t]*"
+                r"DBLE[ \t]*\([ \t]*IDEN[ \t]*\)",
+                matrix_source,
+                re.I | re.M,
+            )
+        )
+        != 1
+    ):
+        raise PublicationMergeError(f"{context} has incompatible SMATRIX IDEN use")
+    if (
+        "USERHEL=-1" not in check_source.replace(" ", "")
+        or check_source.count("CALL SMATRIX(") != 3
+        or re.search(r"(?<!S)\bMATRIX\s*\(", check_source, re.I)
+    ):
+        raise PublicationMergeError(
+            f"{context} retained driver is not a native SMATRIX helicity sum"
+        )
+
+
+def _validate_madgraph_provenance(
+    campaign: Document,
+    overlay: Document,
+    *,
+    helicity_workload: str = "fixed",
+    measurement_host: Mapping[str, Any],
+) -> Document:
+    campaign_policy = _mapping(
+        campaign.payload.get("policy"), context="campaign policy"
+    )
+    campaign_measurement = _mapping(
+        campaign_policy.get("measurement"), context="campaign measurement policy"
+    )
+    campaign_alpha_s = (
+        _positive_number(
+            campaign_measurement.get("alpha_s"), context="campaign alpha_s"
+        )
+        if helicity_workload == "sum"
+        else None
+    )
+    raw_series = _mapping(
+        overlay.payload.get("runtime_series"), context="MadGraph runtime_series"
+    )
+    source_identity: tuple[str, str] | None = None
+    measured_count_by_family: Counter[str] = Counter()
+    status_counts: Counter[str] = Counter()
+    for family in FAMILY_MODES:
+        measured_limit = MADGRAPH_FAMILY_MAX_MEASURED_MULTIPLICITY[family]
+        family_series = _mapping(
+            raw_series.get(family), context=f"MadGraph runtime_series.{family}"
+        )
+        mode_cells = _mapping(
+            family_series.get("madgraph-standalone"),
+            context=f"MadGraph runtime_series.{family}.madgraph-standalone",
+        )
+        for n in FINAL_MULTIPLICITIES:
+            context = f"MadGraph runtime_series.{family}.madgraph-standalone.{n}"
+            cell = _mapping(mode_cells.get(str(n)), context=context)
+            status = str(cell.get("status"))
+            if status not in {
+                "measured",
+                "failed",
+                "skipped",
+                "not-applicable",
+            }:
+                raise PublicationMergeError(f"{context}.status is unsupported")
+            if n > measured_limit:
+                if status != "not-applicable":
+                    raise PublicationMergeError(
+                        f"{context} must be protocol-scoped not-applicable"
+                    )
+                scope = _mapping(
+                    cell.get("protocol_scope"),
+                    context=f"{context}.protocol_scope",
+                )
+                if (
+                    cell.get("failure_category")
+                    not in _madgraph_protocol_scope_categories(
+                        family, n, measured_limit
+                    )
+                    or cell.get("censors_higher_multiplicities") is not False
+                    or scope.get("maximum_measured_multiplicity")
+                    != measured_limit
+                    or scope.get("disposition") != "not-applicable"
+                    or not isinstance(cell.get("failure_reason"), str)
+                    or not cell["failure_reason"].strip()
+                ):
+                    raise PublicationMergeError(
+                        f"{context} has incompatible protocol-scope metadata"
+                    )
+            elif status == "not-applicable":
+                raise PublicationMergeError(
+                    f"{context} cannot be not-applicable at n<={measured_limit}"
+                )
+            status_counts[status] += 1
+            if status != "measured":
+                continue
+            measured_count_by_family[family] += 1
+            metrics = _mapping(cell.get("metrics"), context=f"{context}.metrics")
+            values = {
+                key: _positive_number(metrics.get(key), context=f"{context}.{key}")
+                for key in METRIC_KEYS
+            }
+            for key, value in values.items():
+                if _finite_number(cell.get(key), context=f"{context}.{key}") != value:
+                    raise PublicationMergeError(
+                        f"{context}.{key} disagrees with the metrics object"
+                    )
+            if values["generation_seconds"] >= MAX_GENERATION_SECONDS:
+                raise PublicationMergeError(f"{context} exceeds one hour")
+            if values["max_rss_kib"] >= MAX_RSS_KIB:
+                raise PublicationMergeError(f"{context} reaches 30 GiB RSS")
+            protocol = _mapping(cell.get("protocol"), context=f"{context}.protocol")
+            expected_evaluator = (
+                "SMATRIX(P,ANS)-generated-complete-helicity-sum"
+                if helicity_workload == "sum"
+                else "MATRIX(P,NHEL,IC)-direct"
+            )
+            expected_color_sum = (
+                "generated-SMATRIX-summed-and-averaged"
+                if helicity_workload == "sum"
+                else "full-unaveraged"
+            )
+            if (
+                protocol.get("generation_helicity_coverage") != "all"
+                or protocol.get("warm_fixed_helicity")
+                is not (helicity_workload == "fixed")
+                or protocol.get("helicity_summed")
+                is not (helicity_workload == "sum")
+                or protocol.get("evaluator") != expected_evaluator
+                or protocol.get("color_sum") != expected_color_sum
+            ):
+                raise PublicationMergeError(
+                    f"{context} has the wrong helicity protocol"
+                )
+            if helicity_workload == "sum" and (
+                protocol.get("warm_helicity_sum") is not True
+                or protocol.get("timed_helicity_count") != 2 ** (n + 2)
+                or protocol.get("helicity_sum_implementation")
+                != "generated-SMATRIX-with-USERHEL-minus-one"
+                or protocol.get("warmed_native_call_pruning")
+                != "generated GOODHEL cache may skip structurally zero helicities"
+                or _finite_number(cell.get("alpha_s"), context=f"{context}.alpha_s")
+                != campaign_alpha_s
+            ):
+                raise PublicationMergeError(
+                    f"{context} has incompatible summed-helicity metadata"
+                )
+            refresh = _mapping(
+                cell.get("runtime_refresh"), context=f"{context}.runtime_refresh"
+            )
+            if (
+                refresh.get("accepted") is not True
+                or refresh.get("fresh_process") is not True
+                or refresh.get("scope") != "generation-resource-and-warm-runtime"
+            ):
+                raise PublicationMergeError(f"{context} is not a fresh accepted cell")
+            numerical = _mapping(cell.get("numerical"), context=f"{context}.numerical")
+            expected_factor = _madgraph_normalization_factor(
+                family, n, helicity_workload=helicity_workload
+            )
+            if (
+                numerical.get("reference_mode")
+                != _source_mode(family, helicity_workload)
+                or numerical.get("passes") is not True
+                or not math.isclose(
+                    _positive_number(
+                        numerical.get("normalization_factor_reference_per_madgraph"),
+                        context=f"{context}.normalization_factor",
+                    ),
+                    expected_factor,
+                    rel_tol=0.0,
+                    abs_tol=1.0e-16,
+                )
+            ):
+                raise PublicationMergeError(f"{context} has incompatible normalization")
+            provenance = _mapping(
+                cell.get("provenance"), context=f"{context}.provenance"
+            )
+            if provenance.get("smatrix_iden") != _expected_madgraph_iden(family, n):
+                raise PublicationMergeError(
+                    f"{context} has the wrong generated SMATRIX denominator"
+                )
+            if helicity_workload == "sum":
+                if (
+                    _finite_number(
+                        provenance.get("source_alpha_s"),
+                        context=f"{context}.provenance.source_alpha_s",
+                    )
+                    != campaign_alpha_s
+                    or _finite_number(
+                        provenance.get("runtime_alpha_s"),
+                        context=f"{context}.provenance.runtime_alpha_s",
+                    )
+                    != campaign_alpha_s
+                    or provenance.get("timed_helicity_count") != 2 ** (n + 2)
+                ):
+                    raise PublicationMergeError(
+                        f"{context} has incompatible summed runtime provenance"
+                    )
+                _validate_summed_retained_sources(
+                    provenance, n=n, context=context
+                )
+            source = _mapping(
+                provenance.get("source_report"),
+                context=f"{context}.provenance.source_report",
+            )
+            path = source.get("path")
+            sha256 = source.get("sha256")
+            expected_pointer = (
+                f"cells.{family}.{_source_mode(family, helicity_workload)}.{n}"
+            )
+            if source.get("cell") != expected_pointer:
+                raise PublicationMergeError(f"{context} has the wrong source cell")
+            if not isinstance(path, str) or not isinstance(sha256, str):
+                raise PublicationMergeError(f"{context} lacks source-report identity")
+            identity = (path, sha256)
+            if source_identity is None:
+                source_identity = identity
+            elif source_identity != identity:
+                raise PublicationMergeError(
+                    "measured MadGraph cells use different source reports"
+                )
+
+    if any(measured_count_by_family[family] < 1 for family in FAMILY_MODES):
+        raise PublicationMergeError(
+            "MadGraph must measure at least one cell per family"
+        )
+    expected_status = (
+        "complete-with-failures" if status_counts["failed"] else "complete"
+    )
+    if overlay.payload.get("status") != expected_status:
+        raise PublicationMergeError("MadGraph status disagrees with its cells")
+    if overlay.payload.get("failure_count") != status_counts["failed"]:
+        raise PublicationMergeError("MadGraph failure_count disagrees with its cells")
+    summary = _mapping(overlay.payload.get("summary"), context="MadGraph summary")
+    if summary.get("runtime_series_status_counts") != dict(
+        sorted(status_counts.items())
+    ):
+        raise PublicationMergeError("MadGraph summary disagrees with its cells")
+    if source_identity is None:
+        raise PublicationMergeError("MadGraph overlay has no measured provenance")
+
+    source_path = _resolve_recorded_path(
+        source_identity[0], context="MadGraph source report path"
+    )
+    source_document = _load_document("MadGraph source report", source_path)
+    if source_document.sha256 != source_identity[1]:
+        raise PublicationMergeError("MadGraph source-report SHA-256 differs")
+    if source_document.payload.get("schema_version") != SCHEMA_VERSION:
+        raise PublicationMergeError("MadGraph source report has the wrong schema")
+    source_host = _measurement_host(
+        source_document.payload.get("measurement_host"),
+        context="MadGraph source report measurement_host",
+    )
+    if source_host != measurement_host:
+        raise PublicationMergeError(
+            "campaign and MadGraph source report use different measurement hosts"
+        )
+    if helicity_workload == "sum":
+        source_policy = _mapping(
+            source_document.payload.get("policy"), context="MadGraph source policy"
+        )
+        if _helicity_workload(source_policy) != "sum":
+            raise PublicationMergeError(
+                "MadGraph summed overlay points to a non-summed source report"
+            )
+        source_measurement = _mapping(
+            source_policy.get("measurement"),
+            context="MadGraph source measurement policy",
+        )
+        if (
+            _positive_number(
+                source_measurement.get("alpha_s"), context="MadGraph source alpha_s"
+            )
+            != campaign_alpha_s
+        ):
+            raise PublicationMergeError("MadGraph source alpha_s differs")
+
+    campaign_cells = _mapping(campaign.payload.get("cells"), context="campaign cells")
+    for family in FAMILY_MODES:
+        mode = _source_mode(family, helicity_workload)
+        mode_cells = _mapping(
+            _mapping(
+                campaign_cells.get(family), context=f"campaign cells.{family}"
+            ).get(mode),
+            context=f"campaign cells.{family}.{mode}",
+        )
+        overlay_cells = _mapping(
+            _mapping(
+                raw_series.get(family), context=f"MadGraph runtime_series.{family}"
+            ).get("madgraph-standalone"),
+            context=f"MadGraph runtime_series.{family}.madgraph-standalone",
+        )
+        for n in FINAL_MULTIPLICITIES:
+            context = f"MadGraph runtime_series.{family}.madgraph-standalone.{n}"
+            madgraph_cell = _mapping(overlay_cells.get(str(n)), context=context)
+            if madgraph_cell.get("status") != "measured":
+                continue
+            source_cell = _source_cell(
+                source_document.payload,
+                family,
+                mode,
+                n,
+                context="MadGraph source report",
+            )
+            if source_cell.get("status") != "measured":
+                raise PublicationMergeError(f"{context} points to an unmeasured source")
+            helicity = _validate_helicity(
+                madgraph_cell.get("helicity"), n=n, context=f"{context}.helicity"
+            )
+            if helicity != _validate_helicity(
+                source_cell.get("helicity"),
+                n=n,
+                context=f"MadGraph source cells.{family}.{mode}.{n}.helicity",
+            ):
+                raise PublicationMergeError(
+                    f"{context} helicity differs from its source"
+                )
+            madgraph_paths = _event_identity(madgraph_cell, context=context)
+            source_paths = tuple(
+                _resolve_recorded_path(path, context="MadGraph source event path")
+                for path in _sequence(
+                    source_cell.get("event_paths"),
+                    context="MadGraph source event paths",
+                )
+            )
+            if madgraph_paths != source_paths:
+                raise PublicationMergeError(
+                    f"{context} event paths differ from its source"
+                )
+            factor = _madgraph_normalization_factor(
+                family, n, helicity_workload=helicity_workload
+            )
+            source_points = _validate_points(
+                source_cell.get("point_values"), context="MadGraph source point values"
+            )
+            madgraph_points = _validate_points(
+                madgraph_cell.get("point_values"), context=f"{context}.point_values"
+            )
+            if (
+                max(
+                    _relative_error(observed * factor, reference)
+                    for observed, reference in zip(
+                        madgraph_points, source_points, strict=True
+                    )
+                )
+                > 1.0e-10
+            ):
+                raise PublicationMergeError(
+                    f"{context} numerically differs from its source"
+                )
+
+            fresh_cell = _mapping(mode_cells.get(str(n)), context="fresh source cell")
+            if fresh_cell.get("status") != "measured":
+                continue
+            if helicity != _validate_helicity(
+                fresh_cell.get("helicity"), n=n, context="fresh source helicity"
+            ):
+                raise PublicationMergeError(f"{context} differs from fresh helicity")
+            if tuple(madgraph_cell["event_sha256"]) != _cell_event_hashes(
+                fresh_cell, context=f"fresh campaign cells.{family}.{mode}.{n}"
+            ):
+                raise PublicationMergeError(f"{context} differs from fresh events")
+            fresh_points = _validate_points(
+                fresh_cell.get("point_values"), context="fresh source point values"
+            )
+            if (
+                max(
+                    _relative_error(observed * factor, reference)
+                    for observed, reference in zip(
+                        madgraph_points, fresh_points, strict=True
+                    )
+                )
+                > 1.0e-10
+            ):
+                raise PublicationMergeError(
+                    f"{context} numerically differs from the fresh campaign"
+                )
+    return source_document
+
+
+def build_final_report(
+    *, campaign_path: Path, madgraph_overlay_path: Path
+) -> dict[str, Any]:
+    campaign = _load_document("campaign report", campaign_path)
+    overlay = _load_document("MadGraph overlay", madgraph_overlay_path)
+    campaign_host = _measurement_host(
+        campaign.payload.get("measurement_host"),
+        context="campaign measurement_host",
+    )
+    overlay_host = _measurement_host(
+        overlay.payload.get("host"), context="MadGraph overlay host"
+    )
+    if campaign_host != overlay_host:
+        raise PublicationMergeError(
+            "campaign and MadGraph overlay use different measurement hosts"
+        )
+    campaign_policy = _validate_campaign_policy(campaign)
+    helicity_workload = _helicity_workload(campaign_policy)
+    campaign_counts = _validate_campaign_cells(
+        campaign, helicity_workload=helicity_workload
+    )
+    _validate_madgraph_policy(
+        overlay, helicity_workload=helicity_workload
+    )
+    source_document = _validate_madgraph_provenance(
+        campaign,
+        overlay,
+        helicity_workload=helicity_workload,
+        measurement_host=campaign_host,
+    )
+
+    report = deepcopy(campaign.payload)
+    report_measurement = _mapping(
+        _mapping(report.get("policy"), context="final report policy").get(
+            "measurement"
+        ),
+        context="final report measurement policy",
+    )
+    report_measurement.pop("fixed_helicity", None)
+    if helicity_workload == "sum":
+        report_policy = _mapping(report.get("policy"), context="final report policy")
+        plot = report_policy.get("plot")
+        if isinstance(plot, dict):
+            raw_notes = plot.get("notes")
+            notes = (
+                [str(note) for note in raw_notes]
+                if isinstance(raw_notes, list)
+                else []
+            )
+            notes = [
+                note
+                for note in notes
+                if not (
+                    "MadGraph" in note
+                    and (
+                        "omitted" in note.lower()
+                        or "fixed-helicity" in note.lower()
+                    )
+                )
+            ]
+            replacement = (
+                "MadGraph standalone uses generated SMATRIX with USERHEL=-1; "
+                "warmed GOODHEL pruning remains enabled."
+            )
+            if replacement not in notes:
+                notes.append(replacement)
+            plot["notes"] = notes
+    report["kind"] = FINAL_KIND
+    report["summary"] = {
+        "cell_status_counts": dict(sorted(campaign_counts.items())),
+    }
+    try:
+        selected._apply_runtime_series_overlay(
+            report,
+            selected.SourceReport(
+                key="madgraph-overlay",
+                path=overlay.path,
+                sha256=overlay.sha256,
+                payload=overlay.payload,
+            ),
+        )
+    except selected.CompositeError as error:
+        raise PublicationMergeError(str(error)) from error
+    external_counts = Counter(
+        str(cell.get("status"))
+        for family_series in report["runtime_series"].values()
+        for mode_cells in family_series.values()
+        for cell in mode_cells.values()
+    )
+    total_failures = campaign_counts["failed"] + external_counts["failed"]
+    report["status"] = "complete-with-failures" if total_failures else "complete"
+    report["failure_count"] = total_failures
+    report["summary"]["total_failure_count"] = total_failures
+    report["publication_provenance"] = {
+        "campaign_report": {
+            "path": campaign.display_path,
+            "sha256": campaign.sha256,
+            "kind": CAMPAIGN_KIND,
+            "status": campaign.payload["status"],
+            "failure_count": campaign_counts["failed"],
+        },
+        "madgraph_overlay": {
+            "path": overlay.display_path,
+            "sha256": overlay.sha256,
+            "kind": selected.RUNTIME_SERIES_OVERLAY_KIND,
+            "status": overlay.payload["status"],
+            "failure_count": external_counts["failed"],
+        },
+        "madgraph_source_report": {
+            "path": source_document.display_path,
+            "sha256": source_document.sha256,
+            "kind": source_document.payload.get("kind"),
+        },
+        "measurement_host": dict(campaign_host),
+        "same_host_authenticated": True,
+        "final_state_multiplicities": list(FINAL_MULTIPLICITIES),
+        "merge_policy": "fresh-campaign-cells-plus-authenticated-external-series",
+    }
+    return report
+
+
+def _write_report(path: Path, report: Mapping[str, Any]) -> None:
+    output = path.expanduser().resolve(strict=False)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    temporary = output.with_suffix(output.suffix + ".tmp")
+    temporary.write_text(
+        json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    temporary.replace(output)
+
+
+def main() -> int:
+    arguments = _parser().parse_args()
+    try:
+        report = build_final_report(
+            campaign_path=arguments.campaign_report,
+            madgraph_overlay_path=arguments.madgraph_overlay,
+        )
+        _write_report(arguments.output, report)
+    except PublicationMergeError as error:
+        raise SystemExit(f"error: {error}") from error
+    print(arguments.output.expanduser().resolve(strict=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/fft_scaling_selected_scalar_report.py b/pyamplicol/tools/developer/fft_scaling_selected_scalar_report.py
new file mode 100644
index 0000000000..3d0b0664cf
--- /dev/null
+++ b/pyamplicol/tools/developer/fft_scaling_selected_scalar_report.py
@@ -0,0 +1,1341 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Build the selected-mode scalar FullColor report for final-state n=2..9."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import statistics
+from collections import Counter
+from collections.abc import Mapping, Sequence
+from copy import deepcopy
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+RESULTS = ROOT / "IMPLEMENTATION_DOCS" / "RESULTS" / "fft-scaling-study"
+DATA = RESULTS / "data"
+
+KIND = "pyamplicol-fullcolor-selected-scalar-composite"
+OVERLAY_KIND = "pyamplicol-fullcolor-selected-scalar-runtime-overlay"
+CLEAN_RUNTIME_OVERLAY_KIND = (
+    "pyamplicol-fullcolor-selected-scalar-clean-runtime-overlay"
+)
+RUNTIME_SERIES_OVERLAY_KIND = (
+    "pyamplicol-fullcolor-selected-scalar-runtime-series-overlay"
+)
+RUNTIME_SERIES_PROGRESS_KIND = (
+    "pyamplicol-fullcolor-selected-scalar-runtime-series-progress"
+)
+SCHEMA_VERSION = 1
+LOW_MULTIPLICITIES = tuple(range(2, 7))
+HIGH_MULTIPLICITIES = tuple(range(7, 10))
+FINAL_MULTIPLICITIES = (*LOW_MULTIPLICITIES, *HIGH_MULTIPLICITIES)
+SOURCE_BOUNDARY_AFTER_N = 6
+FAMILY_MODES = {
+    "gg": (
+        "reference-fft",
+        "amplicol",
+        "recurrence-direct",
+        "recurrence-fft",
+    ),
+    "ddbar": ("amplicol", "recurrence-direct", "recurrence-fft"),
+}
+HIGH_MODES = {
+    "gg": ("reference-fft", "amplicol", "recurrence-fft"),
+    "ddbar": ("amplicol", "recurrence-fft"),
+}
+CANDIDATE_MODES = frozenset(("recurrence-direct", "recurrence-fft"))
+METRIC_KEYS = (
+    "generation_seconds",
+    "warm_seconds_per_point",
+    "max_rss_kib",
+)
+OVERLAY_MULTIPLICITIES = frozenset((7, 8))
+DIRECT_LABEL = "pyAmpliCol - recurrence (n≤6)"
+SCALAR_KIND = "pyamplicol-fullcolor-fft-scaling-study"
+CANONICAL_KIND = "pyamplicol-fullcolor-fft-scaling-batch128-composite"
+RUNTIME_TARGETS = {
+    "gg": {
+        "reference-fft": tuple(range(2, 10)),
+        "amplicol": tuple(range(2, 8)),
+        "recurrence-direct": tuple(range(2, 7)),
+        "recurrence-fft": tuple(range(2, 9)),
+    },
+    "ddbar": {
+        "amplicol": tuple(range(2, 9)),
+        "recurrence-direct": tuple(range(2, 7)),
+        "recurrence-fft": tuple(range(2, 10)),
+    },
+}
+RUNTIME_TARGET_COUNT = sum(
+    len(multiplicities)
+    for family_modes in RUNTIME_TARGETS.values()
+    for multiplicities in family_modes.values()
+)
+EXPECTED_CENSORED_CELLS = {
+    ("gg", "amplicol", 8): "skipped",
+    ("gg", "amplicol", 9): "skipped",
+    ("gg", "recurrence-fft", 9): "failed",
+    ("ddbar", "amplicol", 9): "failed",
+}
+RUNTIME_SERIES_MODES = frozenset(("madgraph-standalone",))
+MADGRAPH_MAX_MEASURED_MULTIPLICITY = 6
+MADGRAPH_FAMILY_MAX_MEASURED_MULTIPLICITY = {"gg": 5, "ddbar": 6}
+LEGACY_MADGRAPH_WARM_SAMPLE_COUNT = 10
+
+
+class CompositeError(RuntimeError):
+    """The source reports cannot form the requested composite without guessing."""
+
+
+@dataclass(frozen=True, slots=True)
+class SourceReport:
+    key: str
+    path: Path
+    sha256: str
+    payload: dict[str, Any]
+
+    @property
+    def display_path(self) -> str:
+        resolved = self.path.expanduser().resolve(strict=False)
+        try:
+            return str(resolved.relative_to(ROOT))
+        except ValueError:
+            return str(resolved)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--scalar-report",
+        type=Path,
+        default=DATA / "campaign-report-scalar-latency-current.json",
+        help="scalar warm-runtime source report",
+    )
+    parser.add_argument(
+        "--canonical-report",
+        type=Path,
+        default=DATA / "campaign-report-final.json",
+        help="canonical low-n cold/resource source report",
+    )
+    parser.add_argument(
+        "--high-report",
+        type=Path,
+        default=DATA / "campaign-report-high-n-scalar.json",
+        help="scalar high-n source report",
+    )
+    parser.add_argument(
+        "--runtime-overlay",
+        type=Path,
+        help=(
+            "optional accepted warm-runtime overlay; supports the historical "
+            "gg recurrence-FFT n=7/n=8 refresh and the complete clean-runtime "
+            "refresh"
+        ),
+    )
+    parser.add_argument(
+        "--runtime-series-overlay",
+        type=Path,
+        help=(
+            "optional sparse runtime-only comparison series, such as MadGraph "
+            "standalone"
+        ),
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=DATA / "campaign-report-scalar-selected-n2-n9.json",
+        help="output composite report",
+    )
+    return parser
+
+
+def _load_source(key: str, path: Path, *, require_cells: bool = True) -> SourceReport:
+    try:
+        raw = path.read_bytes()
+        payload = json.loads(raw)
+    except (OSError, json.JSONDecodeError) as error:
+        raise CompositeError(f"cannot read {key} report {path}: {error}") from error
+    if not isinstance(payload, dict):
+        raise CompositeError(f"{key} report must be a JSON object")
+    if require_cells and not isinstance(payload.get("cells"), dict):
+        raise CompositeError(f"{key} report must contain a cells object")
+    return SourceReport(
+        key=key,
+        path=path,
+        sha256=hashlib.sha256(raw).hexdigest(),
+        payload=payload,
+    )
+
+
+def _mapping(value: object, *, context: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise CompositeError(f"{context} must be an object")
+    return value
+
+
+def _validate_source_contract(
+    source: SourceReport,
+    *,
+    expected_kind: str,
+    expected_multiplicities: Sequence[int],
+) -> None:
+    if source.payload.get("kind") != expected_kind:
+        raise CompositeError(f"{source.key} report kind must be {expected_kind!r}")
+    if source.payload.get("schema_version") != SCHEMA_VERSION:
+        raise CompositeError(f"{source.key} report schema_version must be 1")
+    policy = _mapping(source.payload.get("policy"), context=f"{source.key} policy")
+    raw_multiplicities = policy.get("final_state_multiplicities")
+    if not isinstance(raw_multiplicities, Sequence) or isinstance(
+        raw_multiplicities, str
+    ):
+        raise CompositeError(
+            f"{source.key} policy.final_state_multiplicities must be an array"
+        )
+    if tuple(raw_multiplicities) != tuple(expected_multiplicities):
+        raise CompositeError(
+            f"{source.key} report multiplicities must be "
+            f"{list(expected_multiplicities)}"
+        )
+
+
+def _cell(source: SourceReport, family: str, mode: str, n: int) -> dict[str, Any]:
+    context = f"{source.key} cells.{family}.{mode}.{n}"
+    cells = _mapping(source.payload["cells"], context=f"{source.key} cells")
+    family_cells = _mapping(cells.get(family), context=f"{source.key} cells.{family}")
+    mode_cells = _mapping(
+        family_cells.get(mode), context=f"{source.key} cells.{family}.{mode}"
+    )
+    raw_cell = _mapping(mode_cells.get(str(n)), context=context)
+    return deepcopy(dict(raw_cell))
+
+
+def _positive_number(value: object, *, context: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        raise CompositeError(f"{context} must be a positive finite number")
+    result = float(value)
+    if not math.isfinite(result) or result <= 0.0:
+        raise CompositeError(f"{context} must be a positive finite number")
+    return result
+
+
+def _finite_number(value: object, *, context: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        raise CompositeError(f"{context} must be a finite number")
+    result = float(value)
+    if not math.isfinite(result):
+        raise CompositeError(f"{context} must be a finite number")
+    return result
+
+
+def _metric(cell: Mapping[str, Any], key: str, *, context: str) -> float:
+    metrics = _mapping(cell.get("metrics"), context=f"{context}.metrics")
+    return _positive_number(metrics.get(key), context=f"{context}.metrics.{key}")
+
+
+def _source_pointer(source: SourceReport, family: str, mode: str, n: int) -> str:
+    return f"{source.key}:cells.{family}.{mode}.{n}"
+
+
+def _measured_cell(
+    source: SourceReport, family: str, mode: str, n: int
+) -> dict[str, Any]:
+    cell = _cell(source, family, mode, n)
+    if cell.get("status") != "measured":
+        raise CompositeError(
+            f"{_source_pointer(source, family, mode, n)} must be measured"
+        )
+    return cell
+
+
+def _low_cell(
+    scalar: SourceReport,
+    canonical: SourceReport,
+    family: str,
+    mode: str,
+    n: int,
+) -> dict[str, Any]:
+    scalar_cell = _measured_cell(scalar, family, mode, n)
+    canonical_cell = _measured_cell(canonical, family, mode, n)
+    rss_source = canonical if mode in CANDIDATE_MODES else scalar
+    rss_cell = canonical_cell if mode in CANDIDATE_MODES else scalar_cell
+
+    result = scalar_cell
+    result["metrics"] = {
+        "generation_seconds": _metric(
+            canonical_cell,
+            "generation_seconds",
+            context=_source_pointer(canonical, family, mode, n),
+        ),
+        "warm_seconds_per_point": _metric(
+            scalar_cell,
+            "warm_seconds_per_point",
+            context=_source_pointer(scalar, family, mode, n),
+        ),
+        "max_rss_kib": _metric(
+            rss_cell,
+            "max_rss_kib",
+            context=_source_pointer(rss_source, family, mode, n),
+        ),
+    }
+    if mode == "recurrence-direct":
+        result["label"] = DIRECT_LABEL
+    result["plot_provenance"] = {
+        "status": _source_pointer(scalar, family, mode, n),
+        "metrics": {
+            "generation_seconds": _source_pointer(canonical, family, mode, n),
+            "warm_seconds_per_point": _source_pointer(scalar, family, mode, n),
+            "max_rss_kib": _source_pointer(rss_source, family, mode, n),
+        },
+    }
+    return result
+
+
+def _high_cell(high: SourceReport, family: str, mode: str, n: int) -> dict[str, Any]:
+    result = _cell(high, family, mode, n)
+    status = result.get("status")
+    if status not in {"measured", "failed", "skipped"}:
+        raise CompositeError(
+            f"{_source_pointer(high, family, mode, n)} has unsupported status "
+            f"{status!r}"
+        )
+    provenance: dict[str, Any] = {"status": _source_pointer(high, family, mode, n)}
+    if status == "measured":
+        for metric in METRIC_KEYS:
+            _metric(
+                result,
+                metric,
+                context=_source_pointer(high, family, mode, n),
+            )
+        provenance["metrics"] = {
+            metric: _source_pointer(high, family, mode, n) for metric in METRIC_KEYS
+        }
+    result["plot_provenance"] = provenance
+    return result
+
+
+def _policy(high: SourceReport) -> dict[str, Any]:
+    high_policy = _mapping(high.payload.get("policy"), context="high policy")
+    high_families = _mapping(
+        high_policy.get("process_families"), context="high policy.process_families"
+    )
+    process_families: dict[str, Any] = {}
+    for family, modes in FAMILY_MODES.items():
+        source_family = _mapping(
+            high_families.get(family),
+            context=f"high policy.process_families.{family}",
+        )
+        expression = source_family.get("expression")
+        ratio_reference = source_family.get("ratio_reference")
+        if not isinstance(expression, str) or not isinstance(ratio_reference, str):
+            raise CompositeError(f"high policy for {family} lacks plot metadata")
+        process_families[family] = {
+            "expression": expression,
+            "modes": list(modes),
+            "ratio_reference": ratio_reference,
+        }
+    return {
+        "final_state_multiplicities": list(FINAL_MULTIPLICITIES),
+        "measurement": {
+            "alpha_s": 0.118,
+            "color_accuracy": "full",
+            "fixed_helicity": True,
+            "n_definition": "final-state-particle-count",
+            "warm_benchmark_batch_size": 1,
+            "warm_samples": 10,
+            "source_boundary_after_n": SOURCE_BOUNDARY_AFTER_N,
+            "warm_timing_metric": (
+                "scalar latency: n=2..6 from scalar-latency-current and "
+                "n=7..9 from high-n-scalar"
+            ),
+            "generation_metric": (
+                "cold-to-ready telemetry: n=2..6 from canonical-final and "
+                "n=7..9 from high-n-scalar"
+            ),
+            "rss_metric": (
+                "implementation RSS: Reference FFT and AmpliCol n=2..6 use "
+                "scalar implementation-self RSS; pyAmpliCol n=2..6 uses the "
+                "canonical max of generation-child and runtime-self RSS; "
+                "n=7..9 retains high-n-scalar definitions"
+            ),
+        },
+        "plot": {
+            "source_boundary_after_n": SOURCE_BOUNDARY_AFTER_N,
+            "source_boundary_label": "n=2..6 / n=7..9 source boundary",
+            "metric_source_boundaries": {
+                metric: {
+                    "source_boundary_after_n": SOURCE_BOUNDARY_AFTER_N,
+                    "source_boundary_label": "n=2..6 / n=7..9 source boundary",
+                }
+                for metric in METRIC_KEYS
+            },
+        },
+        "process_families": process_families,
+    }
+
+
+def _relative_error(left: float, right: float) -> float:
+    if left == right:
+        return 0.0
+    return abs(left - right) / max(abs(left), abs(right), 1.0e-300)
+
+
+def _load_overlay(path: Path) -> SourceReport:
+    source = _load_source("runtime-overlay", path)
+    if source.payload.get("schema_version") != SCHEMA_VERSION:
+        raise CompositeError("runtime overlay schema_version must be 1")
+    return source
+
+
+def _apply_runtime_overlay(report: dict[str, Any], overlay: SourceReport) -> None:
+    if overlay.payload.get("kind") != OVERLAY_KIND:
+        raise CompositeError(f"runtime overlay kind must be {OVERLAY_KIND!r}")
+    raw_cells = _mapping(overlay.payload.get("cells"), context="runtime-overlay cells")
+    if not raw_cells:
+        raise CompositeError("runtime overlay cells must not be empty")
+    unexpected = set(raw_cells) - {str(n) for n in OVERLAY_MULTIPLICITIES}
+    if unexpected:
+        raise CompositeError(
+            "runtime overlay may target only gg recurrence-fft n=7 or n=8; "
+            f"got {sorted(unexpected)}"
+        )
+
+    for raw_n, raw_overlay_cell in raw_cells.items():
+        n = int(raw_n)
+        overlay_cell = _mapping(
+            raw_overlay_cell, context=f"runtime-overlay cells.{raw_n}"
+        )
+        warm = _positive_number(
+            overlay_cell.get("warm_seconds_per_point"),
+            context=f"runtime-overlay cells.{raw_n}.warm_seconds_per_point",
+        )
+        samples_raw = overlay_cell.get("warm_samples_seconds")
+        if not isinstance(samples_raw, Sequence) or isinstance(samples_raw, str):
+            raise CompositeError(
+                f"runtime-overlay cells.{raw_n}.warm_samples_seconds "
+                "must contain ten samples"
+            )
+        samples = [
+            _positive_number(
+                value,
+                context=f"runtime-overlay cells.{raw_n}.warm_samples_seconds",
+            )
+            for value in samples_raw
+        ]
+        if len(samples) != 10:
+            raise CompositeError(
+                f"runtime-overlay cells.{raw_n}.warm_samples_seconds "
+                "must contain ten samples"
+            )
+        if not math.isclose(statistics.median(samples), warm, rel_tol=1e-12):
+            raise CompositeError(
+                f"runtime-overlay cells.{raw_n} warm value is not the sample median"
+            )
+
+        refresh = deepcopy(
+            dict(
+                _mapping(
+                    overlay_cell.get("runtime_refresh"),
+                    context=f"runtime-overlay cells.{raw_n}.runtime_refresh",
+                )
+            )
+        )
+        if refresh.get("accepted") is not True:
+            raise CompositeError(
+                f"runtime-overlay cells.{raw_n}.runtime_refresh.accepted must be true"
+            )
+        points_raw = overlay_cell.get("point_values")
+        if not isinstance(points_raw, Sequence) or isinstance(points_raw, str):
+            raise CompositeError(
+                f"runtime-overlay cells.{raw_n}.point_values must be an array"
+            )
+        points = [
+            _finite_number(value, context=f"runtime-overlay cells.{raw_n}.point_values")
+            for value in points_raw
+        ]
+
+        cell = report["cells"]["gg"]["recurrence-fft"][raw_n]
+        base_points_raw = cell.get("point_values")
+        if not isinstance(base_points_raw, Sequence) or isinstance(
+            base_points_raw, str
+        ):
+            raise CompositeError(f"composite gg recurrence-fft n={n} lacks points")
+        base_points = [float(value) for value in base_points_raw]
+        if len(points) != len(base_points):
+            raise CompositeError(
+                f"runtime-overlay cells.{raw_n}.point_values has the wrong length"
+            )
+        maximum_error = max(
+            (
+                _relative_error(left, right)
+                for left, right in zip(points, base_points, strict=True)
+            ),
+            default=0.0,
+        )
+        if maximum_error > 1.0e-10:
+            raise CompositeError(
+                f"runtime-overlay cells.{raw_n} point values disagree "
+                f"(maximum relative error {maximum_error:.3e})"
+            )
+
+        cell["metrics"]["warm_seconds_per_point"] = warm
+        probe = _mapping(cell.get("probe"), context=f"composite gg recurrence n={n}")
+        updated_probe = deepcopy(dict(probe))
+        updated_probe["warm_median_seconds"] = warm
+        updated_probe["warm_samples_seconds"] = samples
+        updated_probe["point_values"] = points
+        cell["probe"] = updated_probe
+        cell["point_values"] = points
+        previous_refresh = cell.get("runtime_refresh")
+        refresh["overlay_source"] = f"runtime-overlay:cells.{raw_n}"
+        refresh["maximum_relative_point_error_against_high_report"] = maximum_error
+        if isinstance(previous_refresh, Mapping):
+            refresh["supersedes"] = deepcopy(dict(previous_refresh))
+        cell["runtime_refresh"] = refresh
+        cell["plot_provenance"]["metrics"]["warm_seconds_per_point"] = (
+            f"runtime-overlay:cells.{raw_n}"
+        )
+
+
+def _runtime_target_keys() -> set[tuple[str, str, int]]:
+    return {
+        (family, mode, n)
+        for family, family_modes in RUNTIME_TARGETS.items()
+        for mode, multiplicities in family_modes.items()
+        for n in multiplicities
+    }
+
+
+def _overlay_samples(
+    raw_cell: Mapping[str, Any], *, context: str, expected_count: int | Sequence[int]
+) -> tuple[float, list[float]]:
+    if isinstance(expected_count, int) and not isinstance(expected_count, bool):
+        expected_counts = {expected_count}
+    elif isinstance(expected_count, Sequence) and not isinstance(expected_count, str):
+        expected_counts = {
+            value
+            for value in expected_count
+            if isinstance(value, int) and not isinstance(value, bool)
+        }
+    else:
+        expected_counts = set()
+    if not expected_counts:
+        raise CompositeError(f"{context} has no valid expected warm sample count")
+    warm = _positive_number(
+        raw_cell.get("warm_seconds_per_point"),
+        context=f"{context}.warm_seconds_per_point",
+    )
+    raw_samples = raw_cell.get("warm_samples_seconds")
+    if not isinstance(raw_samples, Sequence) or isinstance(raw_samples, str):
+        raise CompositeError(f"{context}.warm_samples_seconds must be an array")
+    samples = [
+        _positive_number(value, context=f"{context}.warm_samples_seconds")
+        for value in raw_samples
+    ]
+    if len(samples) not in expected_counts:
+        expected = " or ".join(str(value) for value in sorted(expected_counts))
+        raise CompositeError(
+            f"{context}.warm_samples_seconds must contain {expected} samples"
+        )
+    if not math.isclose(statistics.median(samples), warm, rel_tol=1e-12):
+        raise CompositeError(f"{context} warm value is not the sample median")
+    return warm, samples
+
+
+def _overlay_points(
+    raw_cell: Mapping[str, Any],
+    base_cell: Mapping[str, Any],
+    *,
+    context: str,
+) -> tuple[list[float], float]:
+    raw_points = raw_cell.get("point_values")
+    if not isinstance(raw_points, Sequence) or isinstance(raw_points, str):
+        raise CompositeError(f"{context}.point_values must be an array")
+    points = [
+        _finite_number(value, context=f"{context}.point_values") for value in raw_points
+    ]
+    base_points_raw = base_cell.get("point_values")
+    if not isinstance(base_points_raw, Sequence) or isinstance(base_points_raw, str):
+        raise CompositeError(f"{context} base cell lacks point values")
+    base_points = [
+        _finite_number(value, context=f"{context} base point values")
+        for value in base_points_raw
+    ]
+    if len(points) != len(base_points) or not points:
+        raise CompositeError(f"{context}.point_values has the wrong length")
+    maximum_error = max(
+        _relative_error(left, right)
+        for left, right in zip(points, base_points, strict=True)
+    )
+    if maximum_error > 1.0e-10:
+        raise CompositeError(
+            f"{context}.point_values disagree with the retained inputs "
+            f"(maximum relative error {maximum_error:.3e})"
+        )
+    return points, maximum_error
+
+
+def _apply_clean_runtime_overlay(report: dict[str, Any], overlay: SourceReport) -> None:
+    if overlay.payload.get("kind") != CLEAN_RUNTIME_OVERLAY_KIND:
+        raise CompositeError(
+            f"clean runtime overlay kind must be {CLEAN_RUNTIME_OVERLAY_KIND!r}"
+        )
+    if overlay.payload.get("status") != "complete":
+        raise CompositeError("clean runtime overlay status must be 'complete'")
+    raw_cells = _mapping(
+        overlay.payload.get("cells"), context="clean-runtime-overlay cells"
+    )
+    observed: dict[tuple[str, str, int], Mapping[str, Any]] = {}
+    for family, raw_family_cells in raw_cells.items():
+        family_cells = _mapping(
+            raw_family_cells, context=f"clean-runtime-overlay cells.{family}"
+        )
+        for mode, raw_mode_cells in family_cells.items():
+            mode_cells = _mapping(
+                raw_mode_cells,
+                context=f"clean-runtime-overlay cells.{family}.{mode}",
+            )
+            for raw_n, raw_cell in mode_cells.items():
+                try:
+                    n = int(raw_n)
+                except (TypeError, ValueError) as error:
+                    raise CompositeError(
+                        "clean runtime overlay multiplicities must be integers"
+                    ) from error
+                key = (str(family), str(mode), n)
+                if key in observed:
+                    raise CompositeError(f"clean runtime overlay repeats {key}")
+                observed[key] = _mapping(
+                    raw_cell,
+                    context=(f"clean-runtime-overlay cells.{family}.{mode}.{raw_n}"),
+                )
+    expected = _runtime_target_keys()
+    if set(observed) != expected:
+        missing = sorted(expected - set(observed))
+        extra = sorted(set(observed) - expected)
+        raise CompositeError(
+            "clean runtime overlay must contain exactly "
+            f"{RUNTIME_TARGET_COUNT} measurable cells; missing={missing}, "
+            f"extra={extra}"
+        )
+
+    raw_censored = _mapping(
+        overlay.payload.get("censored_cells"),
+        context="clean-runtime-overlay censored_cells",
+    )
+    observed_censored: dict[tuple[str, str, int], Mapping[str, Any]] = {}
+    for family, raw_family_cells in raw_censored.items():
+        for mode, raw_mode_cells in _mapping(
+            raw_family_cells,
+            context=f"clean-runtime-overlay censored_cells.{family}",
+        ).items():
+            for raw_n, raw_cell in _mapping(
+                raw_mode_cells,
+                context=(f"clean-runtime-overlay censored_cells.{family}.{mode}"),
+            ).items():
+                try:
+                    n = int(raw_n)
+                except (TypeError, ValueError) as error:
+                    raise CompositeError(
+                        "clean runtime overlay censored multiplicities must be integers"
+                    ) from error
+                key = (str(family), str(mode), n)
+                if key in observed_censored:
+                    raise CompositeError(
+                        f"clean runtime overlay repeats censored cell {key}"
+                    )
+                observed_censored[key] = _mapping(
+                    raw_cell,
+                    context=(
+                        f"clean-runtime-overlay censored_cells.{family}.{mode}.{raw_n}"
+                    ),
+                )
+    if set(observed_censored) != set(EXPECTED_CENSORED_CELLS):
+        raise CompositeError(
+            "clean runtime overlay must preserve exactly the four resource-"
+            "censored cells"
+        )
+    for key, expected_status in EXPECTED_CENSORED_CELLS.items():
+        if observed_censored[key].get("status") != expected_status:
+            raise CompositeError(
+                f"clean runtime overlay censored cell {key} changed status"
+            )
+        family, mode, n = key
+        if report["cells"][family][mode][str(n)].get("status") != expected_status:
+            raise CompositeError(f"composite censored cell {key} changed status")
+
+    for family, mode, n in sorted(
+        expected, key=lambda value: (value[2], value[0], value[1])
+    ):
+        context = f"clean-runtime-overlay cells.{family}.{mode}.{n}"
+        raw_cell = observed[(family, mode, n)]
+        if raw_cell.get("status") != "measured":
+            raise CompositeError(f"{context}.status must be 'measured'")
+        base_cell = report["cells"][family][mode][str(n)]
+        if base_cell.get("status") != "measured":
+            raise CompositeError(f"{context} targets a non-measured base cell")
+        for key, expected_value in (
+            ("family", family),
+            ("mode", mode),
+            ("n", n),
+            ("process", base_cell.get("process")),
+            ("total_external", n + 2),
+            ("helicity", base_cell.get("helicity")),
+            ("event_paths", base_cell.get("event_paths")),
+        ):
+            if raw_cell.get(key) != expected_value:
+                raise CompositeError(f"{context}.{key} has the wrong identity")
+        event_sha256 = raw_cell.get("event_sha256")
+        if (
+            not isinstance(event_sha256, Sequence)
+            or isinstance(event_sha256, str)
+            or len(event_sha256) != 10
+            or any(
+                not isinstance(value, str)
+                or len(value) != 64
+                or any(character not in "0123456789abcdef" for character in value)
+                for value in event_sha256
+            )
+        ):
+            raise CompositeError(
+                f"{context}.event_sha256 must contain ten lowercase SHA-256 values"
+            )
+        expected_samples = 1 if mode == "amplicol" else 10
+        warm, samples = _overlay_samples(
+            raw_cell, context=context, expected_count=expected_samples
+        )
+        points, maximum_error = _overlay_points(raw_cell, base_cell, context=context)
+        refresh = deepcopy(
+            dict(
+                _mapping(
+                    raw_cell.get("runtime_refresh"),
+                    context=f"{context}.runtime_refresh",
+                )
+            )
+        )
+        if (
+            refresh.get("accepted") is not True
+            or refresh.get("fresh_process") is not True
+            or refresh.get("scope") != "warm-runtime-only"
+        ):
+            raise CompositeError(
+                f"{context}.runtime_refresh must describe one accepted fresh "
+                "warm-runtime-only process"
+            )
+        refresh["overlay_source"] = f"clean-runtime-overlay:cells.{family}.{mode}.{n}"
+        refresh["maximum_relative_point_error_against_retained_input"] = maximum_error
+        refresh["event_sha256"] = deepcopy(list(event_sha256))
+        previous_refresh = base_cell.get("runtime_refresh")
+        if isinstance(previous_refresh, Mapping):
+            refresh["supersedes"] = deepcopy(dict(previous_refresh))
+        base_cell["metrics"]["warm_seconds_per_point"] = warm
+        base_cell["point_values"] = points
+        base_cell["runtime_refresh"] = refresh
+        base_cell["plot_provenance"]["metrics"]["warm_seconds_per_point"] = (
+            f"clean-runtime-overlay:cells.{family}.{mode}.{n}"
+        )
+        probe = base_cell.get("probe")
+        if isinstance(probe, Mapping):
+            updated_probe = deepcopy(dict(probe))
+            updated_probe["warm_median_seconds"] = warm
+            updated_probe["warm_samples_seconds"] = samples
+            updated_probe["point_values"] = points
+            base_cell["probe"] = updated_probe
+        reference = base_cell.get("reference")
+        if isinstance(reference, Mapping):
+            updated_reference = deepcopy(dict(reference))
+            updated_reference["warm_median_seconds"] = warm
+            updated_reference["warm_samples_seconds"] = samples
+            updated_reference["matrix_elements"] = points
+            base_cell["reference"] = updated_reference
+        adaptive_points = raw_cell.get("adaptive_runtime_points")
+        if mode == "amplicol":
+            if (
+                not isinstance(adaptive_points, int)
+                or isinstance(adaptive_points, bool)
+                or adaptive_points < 1
+            ):
+                raise CompositeError(
+                    f"{context}.adaptive_runtime_points must be positive"
+                )
+            base_cell["adaptive_runtime_points"] = adaptive_points
+
+    measurement = report["policy"]["measurement"]
+    measurement["warm_timing_metric"] = (
+        "clean warmed-runtime refresh: all 46 measurable selected cells use "
+        "fresh processes on retained deterministic inputs"
+    )
+    measurement["warm_samples"] = {
+        "reference-fft": 10,
+        "pyamplicol": 10,
+        "amplicol": 1,
+    }
+    measurement["warm_timer_source"] = "process-cpu-time"
+    measurement["warm_target_seconds"] = 0.25
+    measurement["warm_runtime_artifact_policy"] = (
+        "runtime-compatible generated artifacts and external standalone inputs "
+        "are retained; generation and RSS metrics remain historical"
+    )
+    plot = report["policy"]["plot"]
+    boundaries = plot.get("metric_source_boundaries")
+    if not isinstance(boundaries, dict):
+        raise CompositeError("composite plot metric boundaries are malformed")
+    boundaries["warm_seconds_per_point"] = None
+    report["runtime_refresh"] = {
+        "scope": "warm-runtime-only",
+        "coverage": "complete",
+        "fresh_measured_cell_count": RUNTIME_TARGET_COUNT,
+        "preserved_resource_censored_cell_count": len(EXPECTED_CENSORED_CELLS),
+    }
+
+
+def _process_expression(family: str, n: int) -> str:
+    extra = " ".join("g" for _ in range(n - 2))
+    if family == "gg":
+        return "g g > g g" + (f" {extra}" if extra else "")
+    return "d d~ > d d~" + (f" {extra}" if extra else "")
+
+
+def _helicity_workload_from_policy(
+    policy: Mapping[str, Any], *, legacy_default: str = "fixed"
+) -> str:
+    measurement = _mapping(
+        policy.get("measurement", policy), context="helicity workload policy"
+    )
+    markers: set[str] = set()
+    declared = measurement.get("helicity_workload")
+    if declared is not None:
+        markers.add(str(declared))
+    if measurement.get("warm_fixed_helicity") is True:
+        markers.add("fixed")
+    if measurement.get("warm_helicity_sum") is True:
+        markers.add("sum")
+    if len(markers) > 1 or any(value not in {"fixed", "sum"} for value in markers):
+        raise CompositeError("helicity workload policy is contradictory")
+    return next(iter(markers), legacy_default)
+
+
+def _madgraph_family_measured_limits(
+    policy: Mapping[str, Any] | None,
+) -> dict[str, int]:
+    if policy is None:
+        return {
+            family: MADGRAPH_MAX_MEASURED_MULTIPLICITY for family in FAMILY_MODES
+        }
+    raw_limits = policy.get("family_maximum_measured_multiplicity")
+    if raw_limits is None:
+        return {
+            family: MADGRAPH_MAX_MEASURED_MULTIPLICITY for family in FAMILY_MODES
+        }
+    if not isinstance(raw_limits, Mapping):
+        raise CompositeError(
+            "runtime series overlay has invalid family multiplicity limits"
+        )
+    limits: dict[str, int] = {}
+    for family in FAMILY_MODES:
+        value = raw_limits.get(family)
+        if (
+            isinstance(value, bool)
+            or not isinstance(value, int)
+            or value < 2
+            or value > MADGRAPH_MAX_MEASURED_MULTIPLICITY
+        ):
+            raise CompositeError(
+                "runtime series overlay has invalid family multiplicity limits"
+            )
+        limits[family] = int(value)
+    if set(raw_limits) != set(FAMILY_MODES):
+        raise CompositeError(
+            "runtime series overlay has invalid family multiplicity limits"
+        )
+    return limits
+
+
+def _madgraph_protocol_scope_categories(family: str, n: int, limit: int) -> set[str]:
+    categories = {f"protocol-scope-n>{limit}"}
+    if family == "gg" and n == 6:
+        categories.add("protocol-scope-pure-gluon-n6")
+    return categories
+
+
+def _madgraph_warm_sample_count(policy: Mapping[str, Any] | None) -> int:
+    if policy is None:
+        return LEGACY_MADGRAPH_WARM_SAMPLE_COUNT
+    raw_count = policy.get("warm_sample_count")
+    if raw_count is None:
+        return LEGACY_MADGRAPH_WARM_SAMPLE_COUNT
+    if isinstance(raw_count, bool) or not isinstance(raw_count, int) or raw_count < 1:
+        raise CompositeError("runtime series overlay has invalid warm_sample_count")
+    return raw_count
+
+
+def _apply_runtime_series_overlay(
+    report: dict[str, Any], overlay: SourceReport
+) -> None:
+    overlay_kind = overlay.payload.get("kind")
+    if overlay_kind not in {
+        RUNTIME_SERIES_OVERLAY_KIND,
+        RUNTIME_SERIES_PROGRESS_KIND,
+    }:
+        raise CompositeError(
+            "runtime series source must be a terminal overlay or authenticated "
+            "sparse progress snapshot"
+        )
+    sparse_progress = overlay_kind == RUNTIME_SERIES_PROGRESS_KIND
+    raw_series = _mapping(
+        overlay.payload.get("runtime_series"), context="runtime-series-overlay"
+    )
+    report_policy = _mapping(report.get("policy"), context="report policy")
+    report_workload = _helicity_workload_from_policy(report_policy)
+    raw_multiplicities = report_policy.get("final_state_multiplicities")
+    if (
+        not isinstance(raw_multiplicities, Sequence)
+        or isinstance(raw_multiplicities, str)
+        or not raw_multiplicities
+        or any(
+            not isinstance(value, int) or isinstance(value, bool) or value < 2
+            for value in raw_multiplicities
+        )
+    ):
+        raise CompositeError("report has invalid final-state multiplicities")
+    multiplicities = tuple(int(value) for value in raw_multiplicities)
+    raw_overlay_policy = overlay.payload.get("policy")
+    overlay_policy: Mapping[str, Any] | None = None
+    if raw_overlay_policy is None and not sparse_progress:
+        # Historical terminal overlays predate their explicit policy block and
+        # cover the report's complete multiplicity set by contract.
+        raw_overlay_multiplicities: object = list(multiplicities)
+    else:
+        overlay_policy = _mapping(
+            raw_overlay_policy, context="runtime-series-overlay policy"
+        )
+        raw_overlay_multiplicities = overlay_policy.get("final_state_multiplicities")
+        overlay_workload = _helicity_workload_from_policy(overlay_policy)
+        if overlay_workload != report_workload:
+            raise CompositeError(
+                "runtime series overlay helicity workload differs from the report"
+            )
+    family_limits = _madgraph_family_measured_limits(overlay_policy)
+    expected_warm_samples = _madgraph_warm_sample_count(overlay_policy)
+    if (
+        not isinstance(raw_overlay_multiplicities, Sequence)
+        or isinstance(raw_overlay_multiplicities, str)
+        or not raw_overlay_multiplicities
+        or any(
+            not isinstance(value, int) or isinstance(value, bool)
+            for value in raw_overlay_multiplicities
+        )
+    ):
+        raise CompositeError("runtime series overlay has invalid multiplicities")
+    overlay_multiplicities = tuple(int(value) for value in raw_overlay_multiplicities)
+    if overlay_multiplicities != tuple(
+        value for value in multiplicities if value in set(overlay_multiplicities)
+    ):
+        raise CompositeError(
+            "runtime series overlay multiplicities must be an ordered subset "
+            "of the report"
+        )
+    if set(raw_series) != set(FAMILY_MODES):
+        raise CompositeError("runtime series overlay must contain gg and ddbar")
+    copied: dict[str, dict[str, dict[str, Any]]] = {}
+    status_counts: Counter[str] = Counter()
+    for family, raw_family_series in raw_series.items():
+        family_series = _mapping(
+            raw_family_series, context=f"runtime-series-overlay.{family}"
+        )
+        if set(family_series) != RUNTIME_SERIES_MODES:
+            raise CompositeError(
+                f"runtime-series-overlay.{family} must contain only MadGraph standalone"
+            )
+        copied[family] = {}
+        for mode, raw_mode_cells in family_series.items():
+            mode_cells = _mapping(
+                raw_mode_cells,
+                context=f"runtime-series-overlay.{family}.{mode}",
+            )
+            expected_ns = {str(n) for n in overlay_multiplicities}
+            observed_ns = set(mode_cells)
+            if observed_ns - expected_ns or (
+                not sparse_progress and observed_ns != expected_ns
+            ):
+                raise CompositeError(
+                    f"runtime-series-overlay.{family}.{mode} must describe exactly "
+                    f"n={list(overlay_multiplicities)}"
+                )
+            frontier_seen = False
+            copied_cells: dict[str, Any] = {}
+            for n in (
+                value for value in overlay_multiplicities if str(value) in mode_cells
+            ):
+                context = f"runtime-series-overlay.{family}.{mode}.{n}"
+                cell = deepcopy(dict(_mapping(mode_cells[str(n)], context=context)))
+                status = cell.get("status")
+                if status not in {
+                    "measured",
+                    "failed",
+                    "skipped",
+                    "not-applicable",
+                }:
+                    raise CompositeError(f"{context}.status is unsupported")
+                measured_limit = family_limits[family]
+                if n > measured_limit:
+                    if status != "not-applicable":
+                        raise CompositeError(
+                            f"{context} must be protocol-scoped not-applicable"
+                        )
+                elif status == "not-applicable":
+                    raise CompositeError(
+                        f"{context} cannot be not-applicable at n<={measured_limit}"
+                    )
+                if status == "measured" and frontier_seen:
+                    raise CompositeError(
+                        f"{context} resumes measurement after the series frontier"
+                    )
+                if (
+                    status == "failed"
+                    and cell.get("censors_higher_multiplicities") is True
+                ):
+                    if frontier_seen:
+                        raise CompositeError(
+                            f"{context} repeats the series failure frontier"
+                        )
+                    frontier_seen = True
+                if (
+                    status == "skipped"
+                    and cell.get("censors_higher_multiplicities") is True
+                    and not frontier_seen
+                ):
+                    raise CompositeError(
+                        f"{context} skips before a recorded failure frontier"
+                    )
+                for key, expected_value in (
+                    ("family", family),
+                    ("mode", mode),
+                    ("n", n),
+                    ("process", _process_expression(family, n)),
+                    ("total_external", n + 2),
+                ):
+                    if cell.get(key) != expected_value:
+                        raise CompositeError(f"{context}.{key} has the wrong identity")
+                label = cell.get("label")
+                if not isinstance(label, str) or not label.strip():
+                    raise CompositeError(f"{context}.label is required")
+                if status == "not-applicable":
+                    scope = _mapping(
+                        cell.get("protocol_scope"),
+                        context=f"{context}.protocol_scope",
+                    )
+                    if (
+                        cell.get("failure_category")
+                        not in _madgraph_protocol_scope_categories(
+                            family, n, measured_limit
+                        )
+                        or cell.get("censors_higher_multiplicities") is not False
+                        or scope.get("maximum_measured_multiplicity")
+                        != measured_limit
+                        or scope.get("disposition") != "not-applicable"
+                    ):
+                        raise CompositeError(
+                            f"{context} has incompatible protocol-scope metadata"
+                        )
+                if status == "measured":
+                    _overlay_samples(
+                        cell,
+                        context=context,
+                        expected_count=(
+                            expected_warm_samples,
+                            LEGACY_MADGRAPH_WARM_SAMPLE_COUNT,
+                        ),
+                    )
+                    metrics = _mapping(
+                        cell.get("metrics"), context=f"{context}.metrics"
+                    )
+                    measured_metrics = {
+                        key: _finite_number(
+                            metrics.get(key), context=f"{context}.metrics.{key}"
+                        )
+                        for key in METRIC_KEYS
+                    }
+                    if any(value <= 0.0 for value in measured_metrics.values()):
+                        raise CompositeError(
+                            f"{context}.metrics must contain three positive values"
+                        )
+                    if not math.isclose(
+                        measured_metrics["warm_seconds_per_point"],
+                        _finite_number(
+                            cell.get("warm_seconds_per_point"),
+                            context=f"{context}.warm_seconds_per_point",
+                        ),
+                        rel_tol=0.0,
+                        abs_tol=0.0,
+                    ):
+                        raise CompositeError(
+                            f"{context} warm metric and timing median disagree"
+                        )
+                    helicity = cell.get("helicity")
+                    if (
+                        not isinstance(helicity, Sequence)
+                        or isinstance(helicity, str)
+                        or len(helicity) != n + 2
+                        or any(
+                            not isinstance(value, int)
+                            or isinstance(value, bool)
+                            or value not in (-1, 1)
+                            for value in helicity
+                        )
+                    ):
+                        raise CompositeError(f"{context}.helicity is invalid")
+                    matrix_element = _finite_number(
+                        cell.get("matrix_element"),
+                        context=f"{context}.matrix_element",
+                    )
+                    point_values_raw = cell.get("point_values")
+                    if not isinstance(point_values_raw, Sequence) or isinstance(
+                        point_values_raw, str
+                    ):
+                        raise CompositeError(
+                            f"{context}.point_values must contain ten values"
+                        )
+                    point_values = [
+                        _finite_number(value, context=f"{context}.point_values")
+                        for value in point_values_raw
+                    ]
+                    if (
+                        len(point_values) != 10
+                        or _relative_error(matrix_element, point_values[0]) > 1.0e-12
+                    ):
+                        raise CompositeError(
+                            f"{context}.matrix_element must match point_values[0]"
+                        )
+                    event_paths = cell.get("event_paths")
+                    event_sha256 = cell.get("event_sha256")
+                    if (
+                        not isinstance(event_paths, Sequence)
+                        or isinstance(event_paths, str)
+                        or len(event_paths) != 10
+                        or any(not isinstance(value, str) for value in event_paths)
+                        or not isinstance(event_sha256, Sequence)
+                        or isinstance(event_sha256, str)
+                        or len(event_sha256) != 10
+                        or any(
+                            not isinstance(value, str)
+                            or len(value) != 64
+                            or any(
+                                character not in "0123456789abcdef"
+                                for character in value
+                            )
+                            for value in event_sha256
+                        )
+                    ):
+                        raise CompositeError(
+                            f"{context} event identity must contain ten paths and "
+                            "SHA-256 values"
+                        )
+                    protocol = _mapping(
+                        cell.get("protocol"), context=f"{context}.protocol"
+                    )
+                    expected_protocol = {
+                        "evaluator": (
+                            "SMATRIX(P,ANS)-generated-complete-helicity-sum"
+                            if report_workload == "sum"
+                            else "MATRIX(P,NHEL,IC)-direct"
+                        ),
+                        "helicity_summed": report_workload == "sum",
+                        "color_sum": (
+                            "generated-SMATRIX-summed-and-averaged"
+                            if report_workload == "sum"
+                            else "full-unaveraged"
+                        ),
+                        "batch_size": 1,
+                        "initialization_included": False,
+                    }
+                    if report_workload == "sum":
+                        expected_protocol.update(
+                            {
+                                "helicity_workload": "sum",
+                                "warm_fixed_helicity": False,
+                                "warm_helicity_sum": True,
+                                "timed_helicity_count": 2 ** (n + 2),
+                            }
+                        )
+                        if (
+                            cell.get("helicity_workload") != "sum"
+                            or cell.get("warm_fixed_helicity") is not False
+                            or cell.get("warm_helicity_sum") is not True
+                            or cell.get("timed_helicity_count") != 2 ** (n + 2)
+                        ):
+                            raise CompositeError(
+                                f"{context} summed workload metadata is incompatible"
+                            )
+                    if any(
+                        protocol.get(key) != value
+                        for key, value in expected_protocol.items()
+                    ):
+                        raise CompositeError(f"{context}.protocol is incompatible")
+                else:
+                    if (
+                        not isinstance(cell.get("failure_reason"), str)
+                        or not cell["failure_reason"].strip()
+                    ):
+                        raise CompositeError(f"{context}.failure_reason is required")
+                status_counts[str(status)] += 1
+                copied_cells[str(n)] = cell
+            copied[family][mode] = copied_cells
+    report["runtime_series"] = copied
+    report["summary"]["runtime_series_status_counts"] = dict(
+        sorted(status_counts.items())
+    )
+
+
+def apply_runtime_series_source(report: dict[str, Any], overlay: SourceReport) -> None:
+    """Validate, attach, and provenance-record one immutable runtime series."""
+
+    _apply_runtime_series_overlay(report, overlay)
+    plot_provenance = report.setdefault("plot_provenance", {})
+    if not isinstance(plot_provenance, dict):
+        raise CompositeError("report plot_provenance must be an object")
+    source_reports = plot_provenance.setdefault("source_reports", {})
+    if not isinstance(source_reports, dict):
+        raise CompositeError("report source-report provenance must be an object")
+    source_reports[overlay.key] = {
+        "path": overlay.display_path,
+        "sha256": overlay.sha256,
+    }
+
+
+def build_selected_report(
+    *,
+    scalar_path: Path,
+    canonical_path: Path,
+    high_path: Path,
+    runtime_overlay_path: Path | None = None,
+    runtime_series_overlay_path: Path | None = None,
+) -> dict[str, Any]:
+    scalar = _load_source("scalar-current", scalar_path)
+    canonical = _load_source("canonical-final", canonical_path)
+    high = _load_source("high-n-scalar", high_path)
+    _validate_source_contract(
+        scalar,
+        expected_kind=SCALAR_KIND,
+        expected_multiplicities=range(2, 8),
+    )
+    _validate_source_contract(
+        canonical,
+        expected_kind=CANONICAL_KIND,
+        expected_multiplicities=range(2, 8),
+    )
+    _validate_source_contract(
+        high,
+        expected_kind=SCALAR_KIND,
+        expected_multiplicities=range(7, 11),
+    )
+    sources = (scalar, canonical, high)
+
+    cells: dict[str, dict[str, dict[str, dict[str, Any]]]] = {}
+    for family, modes in FAMILY_MODES.items():
+        family_cells: dict[str, dict[str, dict[str, Any]]] = {}
+        for mode in modes:
+            mode_cells = {
+                str(n): _low_cell(scalar, canonical, family, mode, n)
+                for n in LOW_MULTIPLICITIES
+            }
+            if mode in HIGH_MODES[family]:
+                mode_cells.update(
+                    {
+                        str(n): _high_cell(high, family, mode, n)
+                        for n in HIGH_MULTIPLICITIES
+                    }
+                )
+            family_cells[mode] = mode_cells
+        cells[family] = family_cells
+
+    status_counts = Counter(
+        str(cell.get("status"))
+        for family_cells in cells.values()
+        for mode_cells in family_cells.values()
+        for cell in mode_cells.values()
+    )
+    report: dict[str, Any] = {
+        "kind": KIND,
+        "schema_version": SCHEMA_VERSION,
+        "status": "complete-with-failures" if status_counts["failed"] else "complete",
+        "failure_count": status_counts["failed"],
+        "policy": _policy(high),
+        "plot_provenance": {
+            "source_reports": {
+                source.key: {
+                    "path": source.display_path,
+                    "sha256": source.sha256,
+                }
+                for source in sources
+            },
+            "low_n": list(LOW_MULTIPLICITIES),
+            "high_n": list(HIGH_MULTIPLICITIES),
+            "recurrence_direct_max_n": max(LOW_MULTIPLICITIES),
+            "excluded_n": [10],
+        },
+        "summary": {"cell_status_counts": dict(sorted(status_counts.items()))},
+        "cells": cells,
+    }
+
+    if runtime_overlay_path is not None:
+        overlay = _load_overlay(runtime_overlay_path)
+        if overlay.payload.get("kind") == OVERLAY_KIND:
+            _apply_runtime_overlay(report, overlay)
+        elif overlay.payload.get("kind") == CLEAN_RUNTIME_OVERLAY_KIND:
+            _apply_clean_runtime_overlay(report, overlay)
+        else:
+            raise CompositeError(
+                "runtime overlay kind must be either the historical or clean "
+                "runtime overlay kind"
+            )
+        report["plot_provenance"]["source_reports"][overlay.key] = {
+            "path": overlay.display_path,
+            "sha256": overlay.sha256,
+        }
+    if runtime_series_overlay_path is not None:
+        series_overlay = _load_source(
+            "runtime-series-overlay",
+            runtime_series_overlay_path,
+            require_cells=False,
+        )
+        if series_overlay.payload.get("schema_version") != SCHEMA_VERSION:
+            raise CompositeError("runtime series overlay schema_version must be 1")
+        apply_runtime_series_source(report, series_overlay)
+    return report
+
+
+def _write_report(path: Path, report: Mapping[str, Any]) -> None:
+    path = path.expanduser().resolve(strict=False)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(
+        json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    temporary.replace(path)
+
+
+def main() -> int:
+    arguments = _parser().parse_args()
+    try:
+        report = build_selected_report(
+            scalar_path=arguments.scalar_report,
+            canonical_path=arguments.canonical_report,
+            high_path=arguments.high_report,
+            runtime_overlay_path=arguments.runtime_overlay,
+            runtime_series_overlay_path=arguments.runtime_series_overlay,
+        )
+        _write_report(arguments.output, report)
+    except CompositeError as error:
+        raise SystemExit(f"error: {error}") from error
+    print(arguments.output.expanduser().resolve(strict=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/fft_scaling_study.py b/pyamplicol/tools/developer/fft_scaling_study.py
new file mode 100644
index 0000000000..3093e9b22b
--- /dev/null
+++ b/pyamplicol/tools/developer/fft_scaling_study.py
@@ -0,0 +1,3943 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Resumable FullColor scaling study for direct and FFT contractions.
+
+Every pyAmpliCol artifact retains complete helicity coverage.  By default the
+warm runtime query fixes the same nonzero helicity used by the comparison
+curves; ``--compare-helicity-sums`` instead times the complete physical sum.
+Every external command that can grow with multiplicity is run through the
+repository memory watchdog.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import copy
+import fcntl
+import hashlib
+import json
+import math
+import os
+import re
+import resource
+import shutil
+import statistics
+import subprocess
+import sys
+import tempfile
+import time
+from collections.abc import Callable, Iterator, Mapping, Sequence
+from dataclasses import asdict, dataclass, replace
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+SOURCE_ROOT = ROOT / "src"
+if str(SOURCE_ROOT) not in sys.path:
+    sys.path.insert(0, str(SOURCE_ROOT))
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.ci import memory_watchdog  # noqa: E402
+from tools.developer import (  # noqa: E402
+    fft_gluon_performance_acceptance as performance,
+)
+from tools.developer import legacy_amplicol  # noqa: E402
+from tools.performance_report import legacy as legacy_report  # noqa: E402
+from tools.performance_report import (  # noqa: E402
+    legacy_structure as legacy_structure_tools,
+)
+from tools.performance_report.legacy_structure import (  # noqa: E402
+    legacy_structural_probe_lock,
+)
+from tools.performance_report.models import (  # noqa: E402
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    MeasurementSpec,
+    Workload,
+)
+
+KIND = "pyamplicol-fullcolor-fft-scaling-study"
+SCHEMA_VERSION = 1
+STUDY_ROOT = ROOT / "IMPLEMENTATION_DOCS" / "RESULTS" / "fft-scaling-study" / "raw"
+FINAL_MULTIPLICITIES = tuple(range(2, 8))
+POINT_COUNT = performance.POINT_COUNT
+BENCHMARK_BATCH_SIZE = 128
+DEFAULT_PROFILE_TARGET_SECONDS = 3.0 * 60.0
+PROFILE_SAMPLE_COUNT = 1
+PROFILE_WARMUP_RUNS = 0
+PROFILE_PRECISION = 16
+REQUESTED_MEMORY_LIMIT_GIB = 30.0
+MAX_MEMORY_LIMIT_GIB = REQUESTED_MEMORY_LIMIT_GIB
+DEFAULT_TIME_LIMIT_SECONDS = 60.0 * 60.0
+MAX_TIME_LIMIT_SECONDS = 60.0 * 60.0
+DEFAULT_ALPHA_S = 0.118
+DEFAULT_OTF_MAX_MULTIPLICITY = 6
+NUMERICAL_RELATIVE_TOLERANCE = 1.0e-10
+AMPLI_COL_MAX_POINTS = 1_000_000_000
+AMPLI_COL_CALIBRATION_HEADROOM = 1.05
+FORTRAN_FLOAT = r"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[EeDd][+-]?[0-9]+)?"
+AMPLI_COL_TIMING_ROW = re.compile(
+    rf"^\s*(generation setup|total)\s+({FORTRAN_FLOAT})\s+",
+    re.MULTILINE,
+)
+RSS_MARKER = performance.DARWIN_RSS_MARKER
+WATCHDOG_PEAK_GUARD = re.compile(r"peak_guard=([0-9]+(?:\.[0-9]+)?) GiB")
+WATCHDOG_PEAK_RSS = re.compile(r"peak_rss=([0-9]+(?:\.[0-9]+)?) GiB")
+JSON_PATH_REFERENCE = re.compile(
+    r"(?P<path>(?:/|\.{1,2}/)[^\s'\"<>]+?\.json)(?=$|[\s,;:)])"
+)
+SYMBOLICA_LICENSE_BUSY_FRAGMENT = (
+    "cannot start new unlicensed symbolica instance since there is already another "
+    "one running on the machine"
+)
+SYMBOLICA_GENERATION_LOCK_ENV = "PYAMPICOL_FFT_SYMBOLICA_GENERATION_LOCK"
+SYMBOLICA_BUSY_RETRY_SECONDS = 5.0
+SYMBOLICA_LOCK_POLL_SECONDS = 0.25
+LEGACY_AMPLICOL_STRUCTURAL_LIMIT_CATEGORY = "legacy-amplicol-structural-limit"
+_LEGACY_AMPLICOL_PROBE_NAMES = frozenset(
+    {"amplicol_color_probe", "amplicol_color_library_probe"}
+)
+
+
+class StudyError(RuntimeError):
+    """The bounded scaling-study contract could not be satisfied."""
+
+
+_RESOURCE_FAILURE_CATEGORIES = frozenset(
+    {
+        "generation-time-limit",
+        "memory-limit",
+        "runtime-time-limit",
+        "setup-or-runtime-time-limit",
+    }
+)
+_CENSORING_FAILURE_CATEGORIES = _RESOURCE_FAILURE_CATEGORIES | frozenset(
+    {LEGACY_AMPLICOL_STRUCTURAL_LIMIT_CATEGORY}
+)
+MUTABLE_RESUME_MEASUREMENT_POLICY_KEYS = frozenset(
+    {
+        "calibration_target_seconds",
+        "candidate_profile_minimum_samples",
+        "candidate_profile_target_runtime_seconds",
+        "candidate_profile_warmup_runs",
+        "cell_admission_limits",
+        "generation_timeout_seconds",
+        "memory_policy",
+        "memory_watchdog_gib",
+        "requested_memory_ceiling_gib",
+        "runtime_timeout_seconds",
+        "warm_sample_count",
+        "warm_samples",
+        "warm_timing_metric",
+    }
+)
+
+
+class _CellResourceLimitError(StudyError):
+    """A cell reached one explicitly enforced time or memory limit."""
+
+    def __init__(self, message: str, *, category: str) -> None:
+        if category not in _RESOURCE_FAILURE_CATEGORIES:
+            raise ValueError(f"invalid cell resource-limit category {category!r}")
+        super().__init__(message)
+        self.category = category
+
+
+class _CellCommandError(StudyError):
+    """A watched command failed in a stage with a known timeout category."""
+
+    def __init__(self, message: str, *, timeout_category: str) -> None:
+        if timeout_category not in {
+            "generation-time-limit",
+            "runtime-time-limit",
+            "setup-or-runtime-time-limit",
+        }:
+            raise ValueError(f"invalid command timeout category {timeout_category!r}")
+        super().__init__(message)
+        self.timeout_category = timeout_category
+
+
+def report_helicity_workload(report: Mapping[str, Any]) -> str:
+    """Return the strictly declared fixed or summed report workload."""
+
+    policy = report.get("policy")
+    if not isinstance(policy, Mapping):
+        raise StudyError("campaign report has no policy object")
+    measurement = policy.get("measurement")
+    if not isinstance(measurement, Mapping):
+        raise StudyError("campaign report has no measurement policy")
+    policy_declared = policy.get("helicity_workload")
+    measurement_declared = measurement.get("helicity_workload")
+    if (
+        policy_declared is not None
+        and measurement_declared is not None
+        and str(policy_declared) != str(measurement_declared)
+    ):
+        raise StudyError(
+            "policy and measurement helicity_workload declarations disagree"
+        )
+    declared = (
+        measurement_declared
+        if measurement_declared is not None
+        else policy_declared
+    )
+    if declared is None:
+        if (
+            measurement.get("warm_fixed_helicity") is True
+            and measurement.get("warm_helicity_sum") is True
+        ):
+            raise StudyError("campaign helicity workload markers are contradictory")
+        if measurement.get("warm_helicity_sum") is True:
+            declared = "sum"
+        elif measurement.get("warm_fixed_helicity") is True:
+            declared = "fixed"
+        else:
+            raise StudyError("campaign report does not declare its helicity workload")
+    workload = str(declared)
+    if workload not in {"fixed", "sum"}:
+        raise StudyError("campaign helicity_workload must be 'fixed' or 'sum'")
+    if workload == "sum" and (
+        measurement.get("warm_fixed_helicity") is not False
+        or measurement.get("warm_helicity_sum") is not True
+    ):
+        raise StudyError(
+            "summed campaign must record warm_fixed_helicity=false and "
+            "warm_helicity_sum=true"
+        )
+    if workload == "fixed" and (
+        measurement.get("warm_fixed_helicity") is not True
+        or measurement.get("warm_helicity_sum") is True
+    ):
+        raise StudyError(
+            "fixed campaign must record warm_fixed_helicity=true without "
+            "warm_helicity_sum=true"
+        )
+    return workload
+
+
+@dataclass(frozen=True, slots=True)
+class Mode:
+    key: str
+    label: str
+    kind: str
+    execution_mode: str | None = None
+    contraction: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class AmpliColWarmSamples:
+    repetitions: int
+    samples_seconds: tuple[float, ...]
+    sample_totals_seconds: tuple[float, ...]
+    sample_set_attempts: int
+
+
+MODES = (
+    Mode("reference-fft", "Reference FFT", "reference"),
+    Mode("amplicol", "AmpliCol", "amplicol"),
+    Mode(
+        "recurrence-direct",
+        "pyAmpliCol - recurrence",
+        "candidate",
+        "recurrence",
+        "direct",
+    ),
+    Mode(
+        "recurrence-fft",
+        "pyAmpliCol - recurrence - FFT",
+        "candidate",
+        "recurrence",
+        "symmetric-group-fft",
+    ),
+    Mode("otf-direct", "pyAmpliCol - OTF", "candidate", "on-the-fly", "direct"),
+    Mode(
+        "otf-fft",
+        "pyAmpliCol - OTF - FFT",
+        "candidate",
+        "on-the-fly",
+        "symmetric-group-fft",
+    ),
+    Mode("compiled-direct", "pyAmpliCol - Compiled", "candidate", "compiled", "direct"),
+    Mode(
+        "compiled-fft",
+        "pyAmpliCol - Compiled - FFT",
+        "candidate",
+        "compiled",
+        "symmetric-group-fft",
+    ),
+)
+MODE_BY_KEY = {mode.key: mode for mode in MODES}
+FAMILIES = ("gg", "ddbar")
+_CANDIDATE_MODE_BY_EXECUTION_AND_CONTRACTION = {
+    (mode.execution_mode, mode.contraction): mode
+    for mode in MODES
+    if mode.kind == "candidate"
+}
+
+
+def process_expression(family: str, final_multiplicity: int) -> str:
+    if final_multiplicity < 2:
+        raise StudyError(f"unsupported final-state multiplicity {final_multiplicity}")
+    extra = " ".join("g" for _ in range(final_multiplicity - 2))
+    if family == "gg":
+        return "g g > g g" + (f" {extra}" if extra else "")
+    if family == "ddbar":
+        return "d d~ > d d~" + (f" {extra}" if extra else "")
+    raise StudyError(f"unknown process family {family!r}")
+
+
+def process_key(family: str, final_multiplicity: int) -> str:
+    return f"{family}_n{final_multiplicity}"
+
+
+def fixed_ddbar_helicity(final_multiplicity: int) -> tuple[int, ...]:
+    return tuple(-1 if index % 2 == 0 else 1 for index in range(final_multiplicity + 2))
+
+
+def _multiplicities(arguments: argparse.Namespace) -> tuple[int, ...]:
+    if arguments.multiplicities is not None:
+        return tuple(sorted(set(arguments.multiplicities)))
+    return tuple(range(arguments.min_n, arguments.max_n + 1))
+
+
+def _fill_multiplicities(arguments: argparse.Namespace) -> tuple[int, ...]:
+    """Return the policy multiplicities selected for this campaign invocation.
+
+    ``--multiplicity`` remains part of the persisted measurement policy.  The
+    separate fill selector lets an orchestrator populate that fixed policy in
+    bounded slices without changing resume identity.
+    """
+
+    policy = _multiplicities(arguments)
+    requested = arguments.fill_multiplicities
+    if requested is None:
+        return policy
+    return tuple(sorted(set(requested)))
+
+
+def _fill_modes(arguments: argparse.Namespace, family: str) -> tuple[Mode, ...]:
+    """Return policy modes selected for this fill without changing identity."""
+
+    policy = _selected_modes(arguments, family)
+    requested = arguments.fill_modes
+    if requested is None:
+        return policy
+    requested_set = set(requested)
+    return tuple(mode for mode in policy if mode.key in requested_set)
+
+
+def _study_root(arguments: argparse.Namespace) -> Path:
+    return arguments.study_root.expanduser().resolve(strict=False)
+
+
+def _selected_families(arguments: argparse.Namespace) -> tuple[str, ...]:
+    requested = set(arguments.families or FAMILIES)
+    return tuple(family for family in FAMILIES if family in requested)
+
+
+def _selected_modes(arguments: argparse.Namespace, family: str) -> tuple[Mode, ...]:
+    requested = (
+        set(MODE_BY_KEY) - {"compiled-fft"}
+        if arguments.modes is None
+        else set(arguments.modes)
+    )
+    if arguments.fft_enabled and not getattr(arguments, "explicit_modes", False):
+        selected_execution_modes = {
+            MODE_BY_KEY[key].execution_mode
+            for key in requested
+            if MODE_BY_KEY[key].kind == "candidate"
+        }
+        for execution_mode in selected_execution_modes:
+            direct = _CANDIDATE_MODE_BY_EXECUTION_AND_CONTRACTION.get(
+                (execution_mode, "direct")
+            )
+            if direct is not None:
+                requested.add(direct.key)
+            # Compiled FFT is presently a selected-helicity diagnostic lane,
+            # so it is not auto-added to this helicity-general campaign.
+            if execution_mode == "compiled":
+                continue
+            fft = _CANDIDATE_MODE_BY_EXECUTION_AND_CONTRACTION.get(
+                (execution_mode, "symmetric-group-fft")
+            )
+            if fft is not None:
+                requested.add(fft.key)
+    return tuple(
+        mode
+        for mode in MODES
+        if mode.key in requested
+        and not (family == "ddbar" and mode.kind == "reference")
+    )
+
+
+def _positive_finite(value: object) -> bool:
+    return (
+        isinstance(value, int | float)
+        and not isinstance(value, bool)
+        and math.isfinite(float(value))
+        and float(value) > 0.0
+    )
+
+
+def _write_event(
+    path: Path,
+    momenta: Sequence[Sequence[float]],
+    helicity: Sequence[int],
+) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    rows = [
+        "PYAMPLICOL_SCALING_EVENT_V1",
+        "BEGIN_MOMENTA",
+        *(" ".join(format(float(value), ".17e") for value in row) for row in momenta),
+        "END_MOMENTA",
+        "NHELICITIES 1",
+        "BEGIN_HELICITIES",
+        " ".join(f"{int(value):+d}" for value in helicity),
+        "END_HELICITIES",
+    ]
+    path.write_text("\n".join(rows) + "\n", encoding="utf-8")
+
+
+def _read_event(path: Path) -> tuple[tuple[tuple[float, ...], ...], tuple[int, ...]]:
+    momenta: list[tuple[float, ...]] = []
+    helicity: list[int] = []
+    in_momenta = False
+    in_helicities = False
+    for line in path.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if stripped == "BEGIN_MOMENTA":
+            in_momenta = True
+        elif stripped == "END_MOMENTA":
+            in_momenta = False
+        elif stripped == "BEGIN_HELICITIES":
+            in_helicities = True
+        elif stripped == "END_HELICITIES":
+            in_helicities = False
+        elif in_momenta:
+            row = tuple(float(value) for value in stripped.split())
+            if len(row) != 4:
+                raise StudyError(f"invalid momentum row in {path}")
+            momenta.append(row)
+        elif in_helicities:
+            helicity.extend(int(value) for value in stripped.split())
+    if len(momenta) != len(helicity) or any(value not in (-1, 1) for value in helicity):
+        raise StudyError(f"invalid fixed-helicity event {path}")
+    return tuple(momenta), tuple(helicity)
+
+
+def _ddbar_events(run_root: Path, final_multiplicity: int) -> tuple[Path, ...]:
+    from pyamplicol.generation.phase_space import massive_rambo_final_state
+
+    helicity = fixed_ddbar_helicity(final_multiplicity)
+    incoming = (
+        (500.0, 0.0, 0.0, 500.0),
+        (500.0, 0.0, 0.0, -500.0),
+    )
+    result: list[Path] = []
+    for point in range(1, POINT_COUNT + 1):
+        path = (
+            run_root
+            / "events"
+            / "ddbar"
+            / f"n{final_multiplicity}"
+            / f"point-{point:02d}.event"
+        )
+        if not path.is_file():
+            outgoing = massive_rambo_final_state(
+                final_multiplicity,
+                sqrt_s=1000.0,
+                masses=(0.0,) * final_multiplicity,
+                seed=91_000 + 100 * final_multiplicity + point,
+            )
+            _write_event(path, (*incoming, *outgoing), helicity)
+        result.append(path)
+    return tuple(result)
+
+
+def _candidate_generation_command(
+    *,
+    python: str,
+    family: str,
+    final_multiplicity: int,
+    mode: Mode,
+    artifact: Path,
+    batch_size: int,
+    optimization_cores: int | None = None,
+) -> tuple[str, ...]:
+    assert mode.execution_mode is not None and mode.contraction is not None
+    command = (
+        python,
+        "-m",
+        "pyamplicol",
+        "generate",
+        process_expression(family, final_multiplicity),
+        str(artifact),
+        "--name",
+        process_key(family, final_multiplicity),
+        "--model",
+        "built-in-sm",
+        "--color-accuracy",
+        "full",
+        "--color-contraction",
+        mode.contraction,
+        "--execution-mode",
+        mode.execution_mode,
+        "--set",
+        f"evaluator.batch_size={batch_size}",
+    )
+    if optimization_cores is not None:
+        command += (
+            "--set",
+            f"evaluator.optimization.cores={optimization_cores}",
+        )
+    return command
+
+
+def _helicity_identifier(helicity: Sequence[int]) -> str:
+    values = tuple(int(value) for value in helicity)
+    if not values or any(value not in (-1, 1) for value in values):
+        raise StudyError("candidate fixed helicity is invalid")
+    return "h:" + ",".join(f"{value:+d}" for value in values)
+
+
+def _write_candidate_cli_inputs(
+    *,
+    cell_root: Path,
+    events: Sequence[Path],
+    alpha_s: float,
+) -> tuple[Path, Path]:
+    momenta = [_read_event(path)[0] for path in events]
+    if len(momenta) != POINT_COUNT:
+        raise StudyError("candidate CLI evaluation requires exactly ten shared points")
+    momenta_path = cell_root / "cli-momenta.json"
+    parameters_path = cell_root / "cli-model-parameters.json"
+    momenta_path.write_text(
+        json.dumps(momenta, indent=2, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    parameters_path.write_text(
+        json.dumps(
+            {"normalization.alpha_s_me_check": alpha_s},
+            indent=2,
+            sort_keys=True,
+            allow_nan=False,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    return momenta_path, parameters_path
+
+
+def _candidate_evaluate_command(
+    *,
+    python: str,
+    artifact: Path,
+    process: str,
+    momenta: Path,
+    model_parameters: Path,
+    helicity: Sequence[int],
+    sum_helicities: bool,
+) -> tuple[str, ...]:
+    command = (
+        python,
+        "-m",
+        "pyamplicol",
+        "evaluate",
+        str(artifact),
+        "--process",
+        process,
+        "--momenta",
+        str(momenta),
+        "--model-parameters",
+        str(model_parameters),
+        "--precision",
+        str(PROFILE_PRECISION),
+    )
+    if not sum_helicities:
+        command += ("--helicity", _helicity_identifier(helicity))
+    return (
+        *command,
+        "--json",
+        "--progress",
+        "off",
+        "--color",
+        "never",
+        "--log-level",
+        "error",
+    )
+
+
+def _candidate_profile_command(
+    *,
+    python: str,
+    artifact: Path,
+    process: str,
+    momenta: Path,
+    helicity: Sequence[int],
+    sum_helicities: bool,
+    target_seconds: float,
+    batch_size: int,
+    minimum_samples: int = PROFILE_SAMPLE_COUNT,
+) -> tuple[str, ...]:
+    command = (
+        python,
+        "-m",
+        "pyamplicol",
+        "profile",
+        str(artifact),
+        "--process",
+        process,
+        "--momenta",
+        str(momenta),
+        "--target-runtime",
+        f"{target_seconds:.17g}",
+        "--batch-size",
+        str(batch_size),
+        "--precision",
+        str(PROFILE_PRECISION),
+        "--warmup-runs",
+        str(PROFILE_WARMUP_RUNS),
+        "--minimum-samples",
+        str(minimum_samples),
+    )
+    if not sum_helicities:
+        command += ("--helicity", _helicity_identifier(helicity))
+    return (
+        *command,
+        "--json",
+        "--progress",
+        "off",
+        "--color",
+        "never",
+        "--log-level",
+        "error",
+    )
+
+
+def _parse_candidate_evaluate_json(output: str) -> list[float]:
+    try:
+        payload = json.loads(output)
+    except json.JSONDecodeError as error:
+        raise StudyError("candidate CLI evaluate output is not JSON") from error
+    if not isinstance(payload, list) or len(payload) != POINT_COUNT:
+        raise StudyError("candidate CLI evaluate did not return ten point values")
+    values: list[float] = []
+    for entry in payload:
+        if not isinstance(entry, Mapping) or set(entry) != {"real", "imag"}:
+            raise StudyError(
+                "candidate CLI evaluate value is not a complex JSON scalar"
+            )
+        try:
+            real = float(entry["real"])
+            imaginary = float(entry["imag"])
+        except (TypeError, ValueError) as error:
+            raise StudyError("candidate CLI evaluate value is not numeric") from error
+        if (
+            not math.isfinite(real)
+            or not math.isfinite(imaginary)
+            or abs(imaginary) > 1.0e-12 * max(abs(real), 1.0e-300)
+        ):
+            raise StudyError("candidate CLI evaluate value is not finite and real")
+        values.append(real)
+    return values
+
+
+def _parse_candidate_profile_json(
+    output: str,
+    *,
+    artifact: Path,
+    family: str,
+    final_multiplicity: int,
+    execution_mode: str,
+    helicity: Sequence[int],
+    sum_helicities: bool,
+    target_seconds: float,
+    batch_size: int,
+    minimum_samples: int = PROFILE_SAMPLE_COUNT,
+) -> dict[str, object]:
+    try:
+        payload = json.loads(output)
+    except json.JSONDecodeError as error:
+        raise StudyError("candidate CLI profile output is not JSON") from error
+    if not isinstance(payload, dict):
+        raise StudyError("candidate CLI profile output is not an object")
+    expected_helicities = [] if sum_helicities else [_helicity_identifier(helicity)]
+    expected_config = {
+        "batch_size": batch_size,
+        "color_flow_ids": [],
+        "helicity_ids": expected_helicities,
+        "minimum_samples": minimum_samples,
+        "precision": PROFILE_PRECISION,
+        "target_runtime": target_seconds,
+        "warmup_runs": PROFILE_WARMUP_RUNS,
+    }
+    requested = payload.get("requested_config")
+    effective = payload.get("effective_config")
+    environment = payload.get("environment")
+    if requested != expected_config or effective != expected_config:
+        raise StudyError("candidate CLI profile configuration differs from the request")
+    if not isinstance(environment, Mapping):
+        raise StudyError("candidate CLI profile has no environment evidence")
+    try:
+        wall_time = float(payload["wall_time_per_point"])
+        sample_count = int(payload["sample_count"])
+        repetitions = int(payload["repetitions_per_sample"])
+        completed_samples = int(environment["completed_sample_count"])
+        measured_points = int(environment["measured_point_count"])
+    except (KeyError, TypeError, ValueError) as error:
+        raise StudyError("candidate CLI profile timing fields are malformed") from error
+    target = environment.get("target")
+    if (
+        payload.get("process_id") != process_key(family, final_multiplicity)
+        or payload.get("process_expression")
+        != process_expression(family, final_multiplicity)
+        or environment.get("execution_mode") != execution_mode
+        or environment.get("color_accuracy") != "full"
+        or environment.get("batch_size") != batch_size
+        or environment.get("precision") != PROFILE_PRECISION
+        or environment.get("selected_color_ids") != []
+        or environment.get("selected_helicity_ids") != expected_helicities
+        or not isinstance(target, str)
+        or Path(target).expanduser().resolve(strict=False)
+        != artifact.expanduser().resolve(strict=False)
+        or payload.get("interrupted") is not False
+        or environment.get("interrupted") is not False
+        or sample_count < minimum_samples
+        or completed_samples != sample_count
+        or repetitions < 1
+        or measured_points != sample_count * repetitions * batch_size
+        or not _positive_finite(wall_time)
+    ):
+        raise StudyError("candidate CLI profile provenance is inconsistent")
+    if execution_mode == "on-the-fly" and (
+        not _positive_finite(environment.get("cold_warmup_elapsed_seconds"))
+        or environment.get("cold_warmup_runtime_cold_before_first_evaluation")
+        is not True
+        or environment.get("cold_warmup_runtime_retained_after_first_evaluation")
+        is not True
+    ):
+        raise StudyError("OTF CLI profile lacks authenticated cold warm-up evidence")
+    return payload
+
+
+def _relative_error(observed: float, expected: float) -> float:
+    return abs(observed - expected) / max(abs(observed), abs(expected), 1.0e-300)
+
+
+def _require_bounded_rss(max_rss_kib: int, memory_limit_gib: float) -> int:
+    if max_rss_kib < 1:
+        raise StudyError("runtime RSS evidence is not positive")
+    if max_rss_kib >= int(memory_limit_gib * 1024**2):
+        raise _CellResourceLimitError(
+            f"runtime RSS reached the strict <{memory_limit_gib:g} GiB bound",
+            category="memory-limit",
+        )
+    return max_rss_kib
+
+
+def _numerical_evidence(
+    *,
+    family: str,
+    final_multiplicity: int,
+    alpha_s: float,
+    observed: Sequence[float],
+    baseline: Mapping[str, object] | None,
+) -> dict[str, object]:
+    if baseline is None or baseline.get("status") != "measured":
+        return {"available": False, "passes": None, "reason": "baseline unavailable"}
+    baseline_values = baseline.get("point_values")
+    if not isinstance(baseline_values, list) or not baseline_values:
+        raise StudyError("baseline cell has no numerical values")
+    if family == "gg":
+        if len(observed) not in {1, len(baseline_values)}:
+            raise StudyError("reference/candidate point counts differ")
+        exponent = final_multiplicity
+        factor = (
+            performance.INITIAL_GLUON_AVERAGE_FACTOR
+            * math.factorial(exponent)
+            / (4.0 * math.pi * alpha_s) ** exponent
+        )
+        errors = [
+            _relative_error(float(value) * factor, float(reference))
+            for value, reference in zip(
+                observed, baseline_values[: len(observed)], strict=True
+            )
+        ]
+    else:
+        errors = [_relative_error(float(observed[0]), float(baseline_values[0]))]
+        factor = 1.0
+    maximum = max(errors)
+    return {
+        "available": True,
+        "normalization_factor": factor,
+        "maximum_relative_error": maximum,
+        "relative_tolerance": NUMERICAL_RELATIVE_TOLERANCE,
+        "passes": maximum <= NUMERICAL_RELATIVE_TOLERANCE,
+    }
+
+
+def _timed_command(
+    command: Sequence[str], *, python: str
+) -> tuple[tuple[str, ...], Any]:
+    return (python, str(Path(__file__).resolve()), "_time-rss", *command), None
+
+
+def _parse_rss_marker(stderr: str) -> int:
+    matches = re.findall(rf"^{re.escape(RSS_MARKER)}\s+(\d+)\s*$", stderr, re.MULTILINE)
+    if len(matches) != 1 or int(matches[0]) < 1:
+        raise StudyError("timed process did not report one positive RSS marker")
+    return int(matches[0])
+
+
+def _parse_watchdog_peak_guard_kib(stderr: str) -> int:
+    matches = WATCHDOG_PEAK_GUARD.findall(stderr)
+    if len(matches) != 1:
+        raise StudyError("watched process did not report one peak_guard value")
+    value = float(matches[0])
+    if not math.isfinite(value) or value < 0.0:
+        raise StudyError("watched process peak_guard is invalid")
+    return round(value * 1024**2)
+
+
+def _parse_watchdog_peak_rss_kib(stderr: str) -> int:
+    matches = WATCHDOG_PEAK_RSS.findall(stderr)
+    if len(matches) != 1:
+        raise StudyError("watched process did not report one peak_rss value")
+    value = float(matches[0])
+    # Very short children can finish before the watchdog's first full sample;
+    # its GiB-formatted diagnostic then rounds a sub-MiB observation to 0.000.
+    if not math.isfinite(value) or value < 0.0:
+        raise StudyError("watched process peak_rss is invalid")
+    return round(value * 1024**2)
+
+
+def _exec_in_command(
+    python: str, directory: Path, command: Sequence[str]
+) -> tuple[str, ...]:
+    return (python, str(Path(__file__).resolve()), "_exec-in", str(directory), *command)
+
+
+def _parse_amplicol_timing_aggregate(output: str) -> tuple[float, float, int]:
+    rows: dict[str, float] = {}
+    for label, raw_value in AMPLI_COL_TIMING_ROW.findall(output):
+        if label in rows:
+            raise StudyError(f"AmpliCol timing row {label!r} is duplicated")
+        rows[label] = float(raw_value.replace("D", "E").replace("d", "e"))
+    point_matches = re.findall(r"^points\s+(\d+)\s*$", output, re.MULTILINE)
+    if set(rows) != {"generation setup", "total"} or len(point_matches) != 1:
+        raise StudyError("AmpliCol timing output is incomplete")
+    points = int(point_matches[0])
+    if (
+        points < 1
+        or rows["generation setup"] < 0.0
+        or not _positive_finite(rows["total"])
+    ):
+        raise StudyError("AmpliCol timing output contains invalid values")
+    return rows["generation setup"], rows["total"], points
+
+
+def _parse_amplicol_timing(output: str) -> tuple[float, float, int]:
+    generation_setup, total, points = _parse_amplicol_timing_aggregate(output)
+    return generation_setup, total / points, points
+
+
+def _amplicol_fixed_repetitions(
+    points: int, total_seconds: float, target_seconds: float
+) -> int:
+    if points < 1 or points > AMPLI_COL_MAX_POINTS:
+        raise StudyError("AmpliCol calibration point count is outside its bound")
+    if not _positive_finite(total_seconds) or not _positive_finite(target_seconds):
+        raise StudyError("AmpliCol calibration timing is invalid")
+    if total_seconds >= target_seconds:
+        return points
+    required = max(
+        points + 1,
+        math.ceil(
+            points * target_seconds / total_seconds * AMPLI_COL_CALIBRATION_HEADROOM
+        ),
+    )
+    if required > AMPLI_COL_MAX_POINTS:
+        raise StudyError(
+            "AmpliCol requires more than its bounded point count to reach the "
+            "warm calibration target"
+        )
+    return required
+
+
+def _collect_amplicol_warm_samples(
+    *,
+    seed_points: int,
+    seed_total_seconds: float,
+    target_seconds: float,
+    run_sample: Callable[[int, int, int], str],
+) -> AmpliColWarmSamples:
+    """Collect equal-repetition profiling aggregates that meet the time floor."""
+
+    repetitions = _amplicol_fixed_repetitions(
+        seed_points, seed_total_seconds, target_seconds
+    )
+    sample_set_attempt = 0
+    while True:
+        sample_set_attempt += 1
+        samples: list[float] = []
+        totals: list[float] = []
+        for sample_index in range(1, PROFILE_SAMPLE_COUNT + 1):
+            output = run_sample(sample_set_attempt, sample_index, repetitions)
+            _, total, observed_points = _parse_amplicol_timing_aggregate(output)
+            if observed_points != repetitions:
+                raise StudyError(
+                    "AmpliCol fixed-repetition probe reported a different point count"
+                )
+            if total < target_seconds:
+                repetitions = _amplicol_fixed_repetitions(
+                    repetitions, total, target_seconds
+                )
+                break
+            totals.append(total)
+            samples.append(total / repetitions)
+        else:
+            return AmpliColWarmSamples(
+                repetitions=repetitions,
+                samples_seconds=tuple(samples),
+                sample_totals_seconds=tuple(totals),
+                sample_set_attempts=sample_set_attempt,
+            )
+
+
+def _empty_report(arguments: argparse.Namespace) -> dict[str, object]:
+    return {
+        "kind": KIND,
+        "schema_version": SCHEMA_VERSION,
+        "status": "running",
+        "policy": dry_run_plan(arguments),
+        "cells": {
+            family: {mode.key: {} for mode in _selected_modes(arguments, family)}
+            for family in _selected_families(arguments)
+        },
+    }
+
+
+def _load_report(path: Path, arguments: argparse.Namespace) -> dict[str, object]:
+    if not path.is_file():
+        return _empty_report(arguments)
+    if not arguments.resume:
+        raise StudyError(f"study report already exists; pass --resume: {path}")
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if payload.get("kind") != KIND or payload.get("schema_version") != SCHEMA_VERSION:
+        raise StudyError("existing scaling-study report has the wrong schema")
+    if not isinstance(payload.get("cells"), dict):
+        raise StudyError("existing scaling-study report has no cells")
+    requested_policy = dry_run_plan(arguments)
+    if payload.get("policy") != requested_policy:
+        stored_comparison = _resume_policy_comparison(payload.get("policy"))
+        requested_comparison = _resume_policy_comparison(requested_policy)
+        if stored_comparison != requested_comparison:
+            raise StudyError("resume arguments differ from the stored study policy")
+        payload["policy"] = requested_policy
+    normalize_loaded_failure_cells(payload, path.parent)
+    payload["status"] = "running"
+    return payload
+
+
+def _resume_policy_comparison(policy: object) -> object:
+    if not isinstance(policy, Mapping):
+        return policy
+    normalized = copy.deepcopy(dict(policy))
+    normalized.pop("run_root", None)
+    measurement = normalized.get("measurement")
+    if isinstance(measurement, dict):
+        for key in MUTABLE_RESUME_MEASUREMENT_POLICY_KEYS:
+            measurement.pop(key, None)
+    return normalized
+
+
+def _record(
+    report: dict[str, object],
+    report_path: Path,
+    family: str,
+    mode: str,
+    final_multiplicity: int,
+    cell: Mapping[str, object],
+) -> None:
+    cells = report["cells"]
+    assert isinstance(cells, dict)
+    family_cells = cells[family]
+    assert isinstance(family_cells, dict)
+    curve = family_cells[mode]
+    assert isinstance(curve, dict)
+    curve[str(final_multiplicity)] = dict(cell)
+    performance._write_report(report_path, report)
+
+
+def _curve(report: Mapping[str, object], family: str, mode: str) -> dict[str, object]:
+    cells = report["cells"]
+    assert isinstance(cells, dict)
+    family_cells = cells[family]
+    assert isinstance(family_cells, dict)
+    result = family_cells[mode]
+    assert isinstance(result, dict)
+    return result
+
+
+def _failure_count(report: Mapping[str, object]) -> int:
+    cells = report.get("cells")
+    if not isinstance(cells, Mapping):
+        return 0
+    return sum(
+        cell.get("status") == "failed"
+        for family_cells in cells.values()
+        if isinstance(family_cells, Mapping)
+        for curve in family_cells.values()
+        if isinstance(curve, Mapping)
+        for cell in curve.values()
+        if isinstance(cell, Mapping)
+    )
+
+
+def selected_cells_complete(
+    report: Mapping[str, object],
+    *,
+    family: str,
+    modes: Sequence[str],
+    multiplicities: Sequence[int],
+) -> bool:
+    """Return whether the requested cells have authoritative terminal records."""
+
+    cells = report.get("cells")
+    if not isinstance(cells, Mapping):
+        return False
+    family_cells = cells.get(family)
+    if not isinstance(family_cells, Mapping):
+        return False
+    for mode in modes:
+        curve = family_cells.get(mode)
+        if not isinstance(curve, Mapping):
+            return False
+        for final_multiplicity in multiplicities:
+            cell = curve.get(str(final_multiplicity))
+            if not isinstance(cell, Mapping):
+                return False
+            status = cell.get("status")
+            if status in {"measured", "skipped"}:
+                continue
+            if status == "failed" and cell.get("censors_higher_multiplicities") is True:
+                continue
+            return False
+    return True
+
+
+def resource_frontier_inversions(
+    report: Mapping[str, object],
+) -> tuple[tuple[str, str, int, int], ...]:
+    """Find measured cells retained above an earlier resource frontier."""
+
+    cells = report.get("cells")
+    if not isinstance(cells, Mapping):
+        return ()
+    inversions: list[tuple[str, str, int, int]] = []
+    for family, family_cells in cells.items():
+        if not isinstance(family, str) or not isinstance(family_cells, Mapping):
+            continue
+        for mode, curve in family_cells.items():
+            if not isinstance(mode, str) or not isinstance(curve, Mapping):
+                continue
+            frontier: int | None = None
+            for raw_n, cell in sorted(
+                curve.items(),
+                key=lambda item: int(item[0]) if str(item[0]).isdigit() else 10**9,
+            ):
+                if not str(raw_n).isdigit() or not isinstance(cell, Mapping):
+                    continue
+                final_multiplicity = int(raw_n)
+                if cell.get("censors_higher_multiplicities") is True and cell.get(
+                    "status"
+                ) in {"failed", "skipped"}:
+                    failed_at = cell.get("failed_at_n")
+                    frontier = min(
+                        frontier if frontier is not None else final_multiplicity,
+                        int(failed_at)
+                        if isinstance(failed_at, int)
+                        else final_multiplicity,
+                    )
+                elif cell.get("status") == "measured" and frontier is not None:
+                    inversions.append((family, mode, frontier, final_multiplicity))
+    return tuple(inversions)
+
+
+def compose_report(
+    arguments: argparse.Namespace,
+    curve_sources: Mapping[str, Mapping[str, Mapping[str, object]]],
+    *,
+    halt_reason: str | None = None,
+) -> dict[str, object]:
+    """Compose one canonical study report from already-authenticated curves.
+
+    The orchestration layer may schedule isolated curve shards, but report
+    shape, completeness, failure accounting, and terminal status remain owned
+    here at the scaling-study boundary.
+    """
+
+    report = _empty_report(arguments)
+    cells = report["cells"]
+    assert isinstance(cells, dict)
+    policy_multiplicities = set(_multiplicities(arguments))
+    for family in _selected_families(arguments):
+        source_family = curve_sources.get(family, {})
+        target_family = cells[family]
+        assert isinstance(target_family, dict)
+        for mode in _selected_modes(arguments, family):
+            source_curve = source_family.get(mode.key, {})
+            if not isinstance(source_curve, Mapping):
+                raise StudyError(
+                    f"composed {family}/{mode.key} curve must be an object"
+                )
+            malformed = [
+                raw_n
+                for raw_n in source_curve
+                if not isinstance(raw_n, str) or not raw_n.isdigit()
+            ]
+            unexpected = sorted(
+                int(raw_n)
+                for raw_n in source_curve
+                if isinstance(raw_n, str)
+                and raw_n.isdigit()
+                and int(raw_n) not in policy_multiplicities
+            )
+            if unexpected or malformed:
+                raise StudyError(
+                    f"composed {family}/{mode.key} curve is outside its policy"
+                )
+            target_family[mode.key] = copy.deepcopy(dict(source_curve))
+
+    failures = _failure_count(report)
+    complete = all(
+        selected_cells_complete(
+            report,
+            family=family,
+            modes=tuple(mode.key for mode in _selected_modes(arguments, family)),
+            multiplicities=_multiplicities(arguments),
+        )
+        for family in _selected_families(arguments)
+    )
+    inversions = resource_frontier_inversions(report)
+    if inversions:
+        report["resource_frontier_inversions"] = [list(item) for item in inversions]
+    else:
+        report.pop("resource_frontier_inversions", None)
+    if halt_reason is not None:
+        report["status"] = "stopped-correctness-failure"
+        report["status_reason"] = halt_reason
+    elif complete:
+        report["status"] = "complete-with-failures" if failures else "complete"
+        report.pop("status_reason", None)
+    else:
+        report["status"] = "running"
+        report.pop("status_reason", None)
+    report["failure_count"] = failures
+    return report
+
+
+def _gg_reference_dependency_skip(
+    report: Mapping[str, object], final_multiplicity: int
+) -> dict[str, object] | None:
+    reference = _curve(report, "gg", "reference-fft").get(str(final_multiplicity))
+    if not isinstance(reference, Mapping):
+        return None
+    status = reference.get("status")
+    if status == "failed":
+        if reference.get("censors_higher_multiplicities") is not True:
+            return None
+        failed_at = final_multiplicity
+    elif status == "skipped" and isinstance(reference.get("failed_at_n"), int):
+        failed_at = int(reference["failed_at_n"])
+    else:
+        return None
+    return {
+        "status": "skipped",
+        "failure_category": "dependency-unavailable",
+        "failure_reason": (
+            "Reference FFT baseline/input unavailable because its curve was "
+            f"resource-censored at n={failed_at}"
+        ),
+        "censors_higher_multiplicities": False,
+        "dependency": {
+            "family": "gg",
+            "mode": "reference-fft",
+            "n": final_multiplicity,
+            "status": status,
+            "resource_failure_at_n": failed_at,
+        },
+    }
+
+
+def _amplicol_gg_dense_index_preflight(
+    final_multiplicity: int, memory_limit_gib: float
+) -> dict[str, object]:
+    total_external = final_multiplicity + 2
+    color_orders = math.factorial(total_external - 1)
+    lower_bound_bytes = 2 * color_orders**2
+    memory_limit_bytes = int(memory_limit_gib * 1024**3)
+    return {
+        "formula": "2*((total_external-1)!)^2 bytes",
+        "color_orders": color_orders,
+        "lower_bound_bytes": lower_bound_bytes,
+        "memory_limit_bytes": memory_limit_bytes,
+        "feasible": lower_bound_bytes < memory_limit_bytes,
+    }
+
+
+def _cell_base(
+    family: str,
+    mode: Mode,
+    final_multiplicity: int,
+    *,
+    sum_helicities: bool = False,
+) -> dict[str, object]:
+    result: dict[str, object] = {
+        "family": family,
+        "mode": mode.key,
+        "label": mode.label,
+        "n": final_multiplicity,
+        "total_external": final_multiplicity + 2,
+        "process": process_expression(family, final_multiplicity),
+        "color_accuracy": "full",
+    }
+    if sum_helicities:
+        result.update(
+            {
+                "helicity_workload": "sum",
+                "warm_fixed_helicity": False,
+                "warm_helicity_sum": True,
+            }
+        )
+    if mode.kind == "candidate":
+        result["execution_mode"] = mode.execution_mode
+        result["color_contraction"] = mode.contraction
+        result["generation_helicity_coverage"] = "all"
+        if not sum_helicities:
+            result["warm_fixed_helicity"] = True
+    return result
+
+
+def _compiled_fft_not_applicable_cell(
+    *,
+    family: str,
+    mode: Mode,
+    final_multiplicity: int,
+    sum_helicities: bool = False,
+) -> dict[str, object] | None:
+    """Exclude the selected-helicity-only compiled FFT diagnostic lane."""
+
+    if mode.key != "compiled-fft":
+        return None
+    return _cell_base(
+        family,
+        mode,
+        final_multiplicity,
+        sum_helicities=sum_helicities,
+    ) | {
+        "status": "not-applicable",
+        "failure_category": "publication-requires-helicity-general-artifact",
+        "failure_reason": (
+            "compiled FFT is disabled in this publication campaign because its "
+            "current backend supports only a generation-selected diagnostic "
+            "helicity, while publication artifacts must support all runtime "
+            "helicities; compiled-direct remains supported"
+        ),
+        "failure_reason_short": (
+            "selected-helicity diagnostic only; compiled-direct remains supported"
+        ),
+        "censors_higher_multiplicities": False,
+        "applicability": {
+            "compiled_direct": True,
+            "compiled_fft": False,
+            "reason_code": "publication-requires-all-runtime-helicities",
+        },
+    }
+
+
+def otf_protocol_scope_cell(
+    *,
+    family: str,
+    mode: Mode,
+    final_multiplicity: int,
+    sum_helicities: bool = False,
+    maximum_multiplicity: int = DEFAULT_OTF_MAX_MULTIPLICITY,
+) -> dict[str, object] | None:
+    """Apply the workload-specific OTF publication frontier."""
+
+    if (
+        mode.execution_mode != "on-the-fly"
+        or final_multiplicity <= maximum_multiplicity
+    ):
+        return None
+    return _cell_base(
+        family,
+        mode,
+        final_multiplicity,
+        sum_helicities=sum_helicities,
+    ) | {
+        "status": "skipped",
+        "failure_category": "publication-protocol-scope",
+        "failure_reason": (
+            "the final scaling scan deliberately limits on-the-fly curves to "
+            f"n<={maximum_multiplicity} for this helicity workload; beyond that "
+            "it retains recurrence, AmpliCol, and Reference FFT where applicable"
+        ),
+        "censors_higher_multiplicities": True,
+        "failed_at_n": maximum_multiplicity + 1,
+    }
+
+
+def apply_protocol_scope_cells(
+    report: dict[str, object],
+    *,
+    family: str,
+    modes: Sequence[str],
+    multiplicities: Sequence[int],
+    maximum_multiplicity: int = DEFAULT_OTF_MAX_MULTIPLICITY,
+) -> bool:
+    """Populate deliberate non-measurement OTF cells for an orchestrated shard."""
+
+    sum_helicities = report_helicity_workload(report) == "sum"
+    changed = False
+    for mode_key in modes:
+        mode = MODE_BY_KEY[mode_key]
+        curve = _curve(report, family, mode_key)
+        for final_multiplicity in multiplicities:
+            cell = otf_protocol_scope_cell(
+                family=family,
+                mode=mode,
+                final_multiplicity=final_multiplicity,
+                sum_helicities=sum_helicities,
+                maximum_multiplicity=maximum_multiplicity,
+            )
+            if cell is not None and str(final_multiplicity) not in curve:
+                curve[str(final_multiplicity)] = cell
+                changed = True
+    return changed
+
+
+def _referenced_command_records(
+    detail: str, cell_root: Path
+) -> tuple[tuple[Path, Mapping[str, object]], ...]:
+    """Load only watched-command records explicitly cited by the exception."""
+
+    candidate_paths: dict[str, Path] = {}
+    for match in JSON_PATH_REFERENCE.finditer(detail):
+        raw_path = Path(match.group("path"))
+        path = raw_path if raw_path.is_absolute() else cell_root / raw_path
+        candidate_paths[str(path.resolve(strict=False))] = path
+    records: list[tuple[Path, Mapping[str, object]]] = []
+    try:
+        local_paths = sorted(cell_root.rglob("*.json"))
+    except OSError:
+        local_paths = []
+    for path in local_paths:
+        rendered_paths = {str(path)}
+        with contextlib.suppress(OSError):
+            rendered_paths.add(str(path.resolve()))
+        if not any(rendered in detail for rendered in rendered_paths):
+            continue
+        candidate_paths[str(path.resolve(strict=False))] = path
+    for path in sorted(candidate_paths.values(), key=str):
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError, TypeError):
+            continue
+        if not isinstance(payload, Mapping):
+            continue
+        command = payload.get("command")
+        watchdog_command = payload.get("watchdog_command")
+        timed_out = payload.get("timed_out")
+        returncode = payload.get("returncode")
+        if (
+            not isinstance(command, list)
+            or not command
+            or not all(isinstance(value, str) for value in command)
+            or not isinstance(watchdog_command, list)
+            or not watchdog_command
+            or not all(isinstance(value, str) for value in watchdog_command)
+            or not isinstance(timed_out, bool)
+            or not isinstance(returncode, int)
+            or isinstance(returncode, bool)
+        ):
+            continue
+        records.append((path, payload))
+    return tuple(records)
+
+
+def _legacy_amplicol_probe_command(record: Mapping[str, object]) -> bool:
+    command = record.get("command")
+    if not isinstance(command, list):
+        return False
+    return any(
+        isinstance(value, str) and Path(value).name in _LEGACY_AMPLICOL_PROBE_NAMES
+        for value in command
+    )
+
+
+def _legacy_amplicol_structural_crash(record: Mapping[str, object]) -> bool:
+    if not _legacy_amplicol_probe_command(record):
+        return False
+    output = "\n".join(
+        str(record.get(field, "")) for field in ("stdout", "stderr")
+    ).lower()
+    return (
+        ("program received signal sigsegv" in output or "segmentation fault" in output)
+        and "init_col" in output
+    )
+
+
+def _mark_legacy_amplicol_structural_limit(cell: dict[str, object]) -> None:
+    cell["failure_category"] = LEGACY_AMPLICOL_STRUCTURAL_LIMIT_CATEGORY
+    cell["failure_reason_short"] = "legacy AmpliCol structural colour-init limit"
+    cell["censors_higher_multiplicities"] = True
+
+
+def normalize_loaded_failure_cells(
+    report: dict[str, object], run_root: Path
+) -> bool:
+    """Upgrade historical legacy-probe colour-init crashes to censoring cells."""
+
+    cells = report.get("cells")
+    if not isinstance(cells, dict):
+        return False
+    changed = False
+    for family, family_cells in cells.items():
+        if not isinstance(family, str) or not isinstance(family_cells, dict):
+            continue
+        curve = family_cells.get("amplicol")
+        if not isinstance(curve, dict):
+            continue
+        for raw_n, cell in curve.items():
+            if (
+                not isinstance(raw_n, str)
+                or not raw_n.isdigit()
+                or not isinstance(cell, dict)
+                or cell.get("status") != "failed"
+                or cell.get("failure_category")
+                == LEGACY_AMPLICOL_STRUCTURAL_LIMIT_CATEGORY
+            ):
+                continue
+            reason = cell.get("failure_reason")
+            if not isinstance(reason, str):
+                continue
+            cell_root = run_root / "amplicol" / family / f"n{raw_n}"
+            if any(
+                _legacy_amplicol_structural_crash(record)
+                for _, record in _referenced_command_records(reason, cell_root)
+            ):
+                _mark_legacy_amplicol_structural_limit(cell)
+                changed = True
+    return changed
+
+
+def _is_memory_watchdog_record(record: Mapping[str, object]) -> bool:
+    command = record["command"]
+    watchdog_command = record["watchdog_command"]
+    assert isinstance(command, list)
+    assert isinstance(watchdog_command, list)
+    try:
+        separator = watchdog_command.index("--")
+    except ValueError:
+        return False
+    return (
+        str(performance.WATCHDOG) in watchdog_command[:separator]
+        and watchdog_command[separator + 1 :] == command
+    )
+
+
+def _watchdog_outcome(
+    record: Mapping[str, object], cell_root: Path
+) -> str | None:
+    raw_report_path = record.get("watchdog_report")
+    if not isinstance(raw_report_path, str) or not raw_report_path:
+        return None
+    report_path = Path(raw_report_path)
+    if not report_path.is_absolute():
+        report_path = ROOT / report_path
+    try:
+        resolved_report = report_path.resolve(strict=True)
+        resolved_report.relative_to(cell_root.resolve(strict=False))
+        payload = json.loads(resolved_report.read_text(encoding="utf-8"))
+        execution = payload["execution"]
+    except (
+        OSError,
+        ValueError,
+        json.JSONDecodeError,
+        KeyError,
+        TypeError,
+    ):
+        return None
+    if (
+        not isinstance(payload, Mapping)
+        or payload.get("kind") != memory_watchdog.WATCHDOG_REPORT_KIND
+        or payload.get("schema_version") != memory_watchdog.WATCHDOG_REPORT_SCHEMA
+        or payload.get("complete") is not True
+        or not isinstance(execution, Mapping)
+        or not isinstance(execution.get("outcome"), str)
+    ):
+        return None
+    return str(execution["outcome"])
+
+
+def _typed_command_failure_category(
+    error: Exception,
+    cell_root: Path,
+    records: Sequence[tuple[Path, Mapping[str, object]]],
+) -> str:
+    timeout_category = (
+        error.timeout_category
+        if isinstance(error, _CellCommandError)
+        else "generation-time-limit"
+    )
+    if any(record["timed_out"] is True for _, record in records):
+        return timeout_category
+    for _, record in records:
+        watchdog_outcome = _watchdog_outcome(record, cell_root)
+        if watchdog_outcome == "memory-limit-exceeded":
+            return "memory-limit"
+        if watchdog_outcome is not None:
+            continue
+        if (
+            record["returncode"] == memory_watchdog.MEMORY_LIMIT_EXIT_CODE
+            and _is_memory_watchdog_record(record)
+        ):
+            return "memory-limit"
+    if any(_legacy_amplicol_structural_crash(record) for _, record in records):
+        return LEGACY_AMPLICOL_STRUCTURAL_LIMIT_CATEGORY
+    return "error"
+
+
+def _failure_cell(
+    base: Mapping[str, object], error: Exception, cell_root: Path
+) -> dict[str, object]:
+    detail = str(error)
+    command_records = _referenced_command_records(detail, cell_root)
+    disk_evidence = "\n".join(
+        (
+            detail,
+            *(
+                str(record.get(field, ""))
+                for _, record in command_records
+                for field in ("stdout", "stderr")
+            ),
+        )
+    ).lower()
+    category = "error"
+    if getattr(error, "errno", None) == 28 or any(
+        marker in disk_evidence
+        for marker in ("no space left on device", "errno 28", "enospc")
+    ):
+        category = "disk-infrastructure-failure"
+    elif isinstance(error, _CellResourceLimitError):
+        category = error.category
+    elif isinstance(error, legacy_report.ProfilingTimeLimitError):
+        category = "runtime-time-limit"
+    else:
+        category = _typed_command_failure_category(
+            error, cell_root, command_records
+        )
+    censors_higher_multiplicities = category in _CENSORING_FAILURE_CATEGORIES
+    cell = dict(base) | {
+        "status": "failed",
+        "censors_higher_multiplicities": censors_higher_multiplicities,
+        "failure_category": category,
+        "failure_reason": detail,
+    }
+    if category == LEGACY_AMPLICOL_STRUCTURAL_LIMIT_CATEGORY:
+        _mark_legacy_amplicol_structural_limit(cell)
+    return cell
+
+
+def _reference_cell(
+    *,
+    arguments: argparse.Namespace,
+    reference: Any,
+    run_root: Path,
+    environment: Mapping[str, str],
+    final_multiplicity: int,
+) -> dict[str, object]:
+    try:
+        result = performance._run_reference(
+            reference=reference,
+            total_gluons=final_multiplicity + 2,
+            run_root=run_root,
+            python=arguments.python,
+            environment=environment,
+            fc=arguments.fc,
+            target_seconds=arguments.target_seconds,
+            timeout_seconds=arguments.runtime_timeout,
+            cold_limit_seconds=arguments.generation_timeout,
+            memory_limit_gib=arguments.memory_limit_gib,
+            repetition_quantum=arguments.batch_size,
+            warm_sample_count=PROFILE_SAMPLE_COUNT,
+            sum_helicities=arguments.compare_helicity_sums,
+        )
+    except performance.ReferenceColdLimitError as error:
+        raise _CellResourceLimitError(
+            str(error), category="generation-time-limit"
+        ) from error
+    metrics = result.metrics
+    if metrics.setup_to_ready_seconds >= arguments.generation_timeout:
+        raise _CellResourceLimitError(
+            "reference generation reached the strict generation cap",
+            category="generation-time-limit",
+        )
+    shared_event_paths = tuple(str(path) for path in result.event_paths)
+    if tuple(metrics.event_paths) != shared_event_paths:
+        raise StudyError("reference shared event-path provenance is inconsistent")
+    timed_event_paths = (
+        tuple(str(path) for path in metrics.exhaustive_event_paths)
+        if arguments.compare_helicity_sums
+        else shared_event_paths
+    )
+    if (
+        len(shared_event_paths) != POINT_COUNT
+        or len(timed_event_paths) != POINT_COUNT
+    ):
+        raise StudyError("reference event-path provenance must contain ten points")
+    return _cell_base(
+        "gg",
+        MODE_BY_KEY["reference-fft"],
+        final_multiplicity,
+        sum_helicities=arguments.compare_helicity_sums,
+    ) | {
+        "status": "measured",
+        "helicity": list(metrics.selected_helicity),
+        # Compatibility: candidate/shared kinematics continue to consume
+        # event_paths.  The explicit aliases prevent a summed Reference timing
+        # run from falsely claiming that those fixed-H files were timed.
+        "event_paths": list(shared_event_paths),
+        "shared_event_paths": list(shared_event_paths),
+        "timed_event_paths": list(timed_event_paths),
+        "event_path_semantics": {
+            "shared": "fixed-helicity event files reused by comparison curves",
+            "timed": (
+                "exhaustive-helicity Reference input files"
+                if arguments.compare_helicity_sums
+                else "same fixed-helicity event files as shared"
+            ),
+            "event_paths_compatibility_alias": "shared_event_paths",
+        },
+        "point_values": list(metrics.matrix_elements),
+        "metrics": {
+            "generation_seconds": metrics.setup_to_ready_seconds,
+            "warm_seconds_per_point": metrics.warm_median_seconds,
+            "max_rss_kib": _require_bounded_rss(
+                metrics.max_rss_kib, arguments.memory_limit_gib
+            ),
+        },
+        "reference": asdict(metrics),
+        **(
+            {
+                "helicity_workload": "sum",
+                "warm_fixed_helicity": False,
+                "warm_helicity_sum": True,
+                "helicity_coverage_count": metrics.helicity_coverage_count,
+                "timed_helicity_count": metrics.timed_helicity_count,
+                "active_helicity_count": metrics.active_helicity_count,
+                "helicity_count_semantics": {
+                    "coverage": "complete physical input-helicity axis",
+                    "active": "analytic-nonzero configurations",
+                    "timed": "analytic-nonzero configurations evaluated per sum",
+                },
+            }
+            if arguments.compare_helicity_sums
+            else {}
+        ),
+    }
+
+
+class _WatchedLegacyExecutor:
+    """Route the authoritative legacy-library workflow through cell limits."""
+
+    def __init__(
+        self,
+        *,
+        arguments: argparse.Namespace,
+        environment: Mapping[str, str],
+        log_root: Path,
+    ) -> None:
+        self.arguments = arguments
+        self.environment = dict(environment)
+        self.log_root = log_root
+        self.command_index = 0
+        self.generation_deadline = time.monotonic() + arguments.generation_timeout
+        self.runtime_deadline: float | None = None
+        self.maximum_rss_kib = 0
+        self.maximum_guard_kib = 0
+
+    def run(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+        environment: Mapping[str, str] | None = None,
+    ) -> legacy_report.CommandResult:
+        rendered = tuple(os.fspath(item) for item in args)
+        if not rendered:
+            raise StudyError("legacy AmpliCol requested an empty command")
+        executable = Path(rendered[0]).name
+        if (
+            executable == "amplicol_color_library_probe"
+            and self.runtime_deadline is None
+        ):
+            self.runtime_deadline = time.monotonic() + self.arguments.runtime_timeout
+        deadline = (
+            self.runtime_deadline
+            if self.runtime_deadline is not None
+            else self.generation_deadline
+        )
+        remaining = deadline - time.monotonic()
+        if remaining <= 0.0:
+            stage = "runtime" if self.runtime_deadline is not None else "generation"
+            raise _CellResourceLimitError(
+                f"AmpliCol generated-library {stage} deadline expired",
+                category=f"{stage}-time-limit",
+            )
+        self.command_index += 1
+        command_environment = {
+            **self.environment,
+            **({} if environment is None else dict(environment)),
+        }
+        log_path = self.log_root / f"{self.command_index:03d}-{executable}.json"
+        try:
+            completed = performance._run_watched(
+                _exec_in_command(
+                    self.arguments.python,
+                    cwd,
+                    rendered,
+                ),
+                python=self.arguments.python,
+                environment=command_environment,
+                timeout_seconds=remaining,
+                log_path=log_path,
+                memory_limit_gib=self.arguments.memory_limit_gib,
+                watchdog_report_path=log_path.with_suffix(".watchdog.json"),
+            )
+        except performance.AcceptanceError as error:
+            stage = "runtime" if self.runtime_deadline is not None else "generation"
+            raise _CellCommandError(
+                f"AmpliCol generated-library {stage} command failed: {error}",
+                timeout_category=f"{stage}-time-limit",
+            ) from error
+        if completed.peak_rss_kib is None or completed.peak_guard_kib is None:
+            raise StudyError("AmpliCol generated-library RSS evidence is missing")
+        self.maximum_rss_kib = max(self.maximum_rss_kib, completed.peak_rss_kib)
+        self.maximum_guard_kib = max(self.maximum_guard_kib, completed.peak_guard_kib)
+        return legacy_report.CommandResult(
+            args=rendered,
+            cwd=cwd,
+            elapsed_seconds=completed.elapsed_seconds,
+            returncode=completed.returncode,
+            stdout=completed.stdout,
+            stderr=completed.stderr,
+            environment={} if environment is None else dict(environment),
+        )
+
+
+_SUMMED_AMPLICOL_PROBE_OVERLAY_ABI = (
+    "pyamplicol-summed-amplicol-probe-source-overlay-v1"
+)
+_SUMMED_AMPLICOL_FERMION_GUARD = (
+    "          ! No fermion permutation sign is represented here.  Keep fermions\n"
+    "          ! fixed and use this fallback only for identical bosonic legs.\n"
+    "          if (label.ne.local_label .and. &\n"
+    "               phys_model%is_fermion(pgl(jgroup)%processes(label,jint))) then\n"
+)
+_SUMMED_AMPLICOL_UNIQUE_FERMION_GUARD = (
+    "          ! Relabelling a fermion is sign-free only when its exact PDG is\n"
+    "          ! unique on this side. Repeated identical fermions remain fixed.\n"
+    "          if (.not.fermion_relabel_is_unique("
+    "jgroup,jint,label,local_label)) then\n"
+)
+_SUMMED_AMPLICOL_FALLBACK_GUARD = """             if (pos.ne.local_label .and. &
+                  phys_model%is_fermion(pgl(jgroup)%processes(pos,jint))) cycle
+"""
+_SUMMED_AMPLICOL_UNIQUE_FALLBACK_GUARD = (
+    "             if (.not.fermion_relabel_is_unique("
+    "jgroup,jint,pos,local_label)) cycle\n"
+)
+_SUMMED_AMPLICOL_HELPER_ANCHOR = (
+    "  logical function is_pure_gluon_word(jgroup,jint,word,nord)\n"
+)
+_SUMMED_AMPLICOL_HELPER = """  logical function fermion_relabel_is_unique( &
+       jgroup,jint,label,local_label)
+    implicit none
+    integer,intent(in) :: jgroup,jint,label,local_label
+    integer :: position, generated_count, local_count, particle
+    fermion_relabel_is_unique = .true.
+    if (label.eq.local_label) return
+    particle = pgl(jgroup)%processes(label,jint)
+    if (.not.phys_model%is_fermion(particle)) return
+    generated_count = 0
+    local_count = 0
+    do position=1,n
+       if ((position.le.2).eqv.(label.le.2)) then
+          if (pgl(jgroup)%processes(position,jint).eq.particle) &
+               generated_count = generated_count + 1
+       endif
+       if ((position.le.2).eqv.(local_label.le.2)) then
+          if (local_part(position,1).eq.local_part(local_label,1)) &
+               local_count = local_count + 1
+       endif
+    enddo
+    fermion_relabel_is_unique = generated_count.eq.1 .and. local_count.eq.1
+  end function fermion_relabel_is_unique
+
+"""
+
+
+def _replace_summed_amplicol_probe_anchor(
+    source: str, old: str, new: str, *, label: str
+) -> str:
+    count = source.count(old)
+    if count != 1:
+        raise StudyError(
+            f"pinned summed AmpliCol probe anchor {label!r} occurs {count} times, "
+            "expected exactly once"
+        )
+    return source.replace(old, new, 1)
+
+
+def _transform_summed_amplicol_probe_source(payload: bytes) -> bytes:
+    """Apply the exact unique-same-side-fermion row-map fix to pinned source."""
+
+    try:
+        source = payload.decode("utf-8")
+    except UnicodeDecodeError as error:
+        raise StudyError("pinned AmpliCol library probe source is not UTF-8") from error
+    source = _replace_summed_amplicol_probe_anchor(
+        source,
+        _SUMMED_AMPLICOL_FERMION_GUARD,
+        _SUMMED_AMPLICOL_UNIQUE_FERMION_GUARD,
+        label="colour-row fermion guard",
+    )
+    source = _replace_summed_amplicol_probe_anchor(
+        source,
+        _SUMMED_AMPLICOL_FALLBACK_GUARD,
+        _SUMMED_AMPLICOL_UNIQUE_FALLBACK_GUARD,
+        label="singlet-row fermion guard",
+    )
+    source = _replace_summed_amplicol_probe_anchor(
+        source,
+        _SUMMED_AMPLICOL_HELPER_ANCHOR,
+        _SUMMED_AMPLICOL_HELPER + _SUMMED_AMPLICOL_HELPER_ANCHOR,
+        label="unique-fermion helper insertion",
+    )
+    return source.encode("utf-8")
+
+
+def _summed_amplicol_source_stat(value: os.stat_result) -> dict[str, int]:
+    return {
+        "mode": value.st_mode,
+        "size": value.st_size,
+        "uid": value.st_uid,
+        "gid": value.st_gid,
+        "atime_ns": value.st_atime_ns,
+        "mtime_ns": value.st_mtime_ns,
+    }
+
+
+@contextlib.contextmanager
+def _summed_amplicol_probe_source_overlay(
+    repository: Path,
+    artifact_root: Path,
+) -> Any:
+    """Temporarily install the summed-probe fix into one clean pinned checkout."""
+
+    repository = repository.expanduser().resolve()
+    source = repository / "amplicol_color_library_probe.f03"
+    with legacy_structural_probe_lock(repository):
+        # Validate under the same lock as the temporary edit. This rejects a
+        # modified checkout rather than treating arbitrary source as an overlay input.
+        legacy_amplicol.validate_checkout(repository)
+        if not source.is_file():
+            raise StudyError(
+                f"pinned AmpliCol library probe source is absent: {source}"
+            )
+        original_stat = source.stat()
+        original = source.read_bytes()
+        patched = _transform_summed_amplicol_probe_source(original)
+        if patched == original:
+            raise StudyError("summed AmpliCol probe overlay made no source change")
+        snapshot = artifact_root / "amplicol_color_library_probe.f03"
+        manifest = artifact_root / "provenance.json"
+        record: dict[str, object] = {
+            "abi": _SUMMED_AMPLICOL_PROBE_OVERLAY_ABI,
+            "scope": "summed-generated-library-amplicol-cells-only",
+            "checkout_validation": "clean-pinned-revision-under-structural-probe-lock",
+            "revision": legacy_amplicol.expected_revision(),
+            "repository": str(repository),
+            "source": source.name,
+            "original_sha256": hashlib.sha256(original).hexdigest(),
+            "patched_sha256": hashlib.sha256(patched).hexdigest(),
+            "patched_source_snapshot": str(snapshot),
+            "manifest": str(manifest),
+            "source_stat_before": _summed_amplicol_source_stat(original_stat),
+            "restoration": {"status": "pending"},
+        }
+        completed = False
+        try:
+            legacy_structure_tools._atomic_write(snapshot, patched)
+            legacy_structure_tools._atomic_json(manifest, record)
+            legacy_structure_tools._atomic_write(source, patched)
+            os.chmod(source, original_stat.st_mode)
+            yield record
+            completed = True
+        finally:
+            legacy_structure_tools._atomic_write(source, original)
+            os.chmod(source, original_stat.st_mode)
+            os.utime(
+                source,
+                ns=(original_stat.st_atime_ns, original_stat.st_mtime_ns),
+            )
+            restored = source.read_bytes()
+            # Undo any atime update caused by the byte-for-byte verification.
+            os.utime(
+                source,
+                ns=(original_stat.st_atime_ns, original_stat.st_mtime_ns),
+            )
+            restored_stat = source.stat()
+            stat_after = _summed_amplicol_source_stat(restored_stat)
+            stat_before = _summed_amplicol_source_stat(original_stat)
+            if restored != original or stat_after != stat_before:
+                raise StudyError(
+                    "summed AmpliCol probe overlay failed to restore its source"
+                )
+            record["restoration"] = {
+                "status": "restored",
+                "body_exit": "success" if completed else "exception",
+                "sha256": hashlib.sha256(restored).hexdigest(),
+                "source_stat_after": stat_after,
+            }
+            legacy_structure_tools._atomic_json(manifest, record)
+
+
+def _amplicol_summed_cell(
+    *,
+    arguments: argparse.Namespace,
+    family: str,
+    final_multiplicity: int,
+    events: Sequence[Path],
+    helicity: Sequence[int],
+    baseline: Mapping[str, object] | None,
+    run_root: Path,
+    environment: Mapping[str, str],
+) -> dict[str, object]:
+    """Measure the create-raw bulk-family complete helicity sum."""
+
+    base = _cell_base(
+        family,
+        MODE_BY_KEY["amplicol"],
+        final_multiplicity,
+        sum_helicities=True,
+    )
+    cell_root = run_root / "amplicol" / family / f"n{final_multiplicity}"
+    setup = cell_root / "setup"
+    setup.mkdir(parents=True, exist_ok=True)
+    momenta, event_helicity = _read_event(events[0])
+    if tuple(helicity) != event_helicity:
+        raise StudyError("AmpliCol event helicity differs from the shared input")
+
+    cell = CellSpec(
+        dataset_id="fft-scaling-helicity-sum",
+        process=process_expression(family, final_multiplicity),
+        n_final=final_multiplicity,
+        process_key=family,
+        measurement=MeasurementSpec(
+            execution_mode=ExecutionMode.AMPLICOL,
+            model=None,
+            accuracy=Accuracy.FULL,
+            backend="original-amplicol-generated-library",
+            jit_optimization_level=None,
+        ),
+        workload=Workload.CONTRACTED,
+    )
+    executor = _WatchedLegacyExecutor(
+        arguments=arguments,
+        environment=environment,
+        log_root=cell_root / "commands",
+    )
+    adapter = legacy_report.LegacyMeasurementAdapter(
+        executor=executor,
+        structural_proof=False,
+    )
+    settings = legacy_report.LegacySettings(
+        target_runtime_seconds=arguments.target_seconds,
+        warmup_points=1,
+        minimum_points=1,
+        maximum_points=AMPLI_COL_MAX_POINTS,
+        minimum_profile_chunks=PROFILE_SAMPLE_COUNT,
+        maximum_profile_chunks=PROFILE_SAMPLE_COUNT + 1,
+        jobs=1,
+        repository=arguments.amplicol_repository,
+        validate_checkout=False,
+        profiling_time_limit_seconds=arguments.runtime_timeout,
+    )
+    commands: list[dict[str, object]] = []
+    log_path = cell_root / "legacy-generated-library.log"
+    generation_started = time.perf_counter()
+    with _summed_amplicol_probe_source_overlay(
+        arguments.amplicol_repository,
+        cell_root / "summed-probe-source-overlay",
+    ) as probe_source_overlay:
+        context = adapter._prepare_process(
+            cell,
+            repository=arguments.amplicol_repository,
+            artifact_path=setup,
+            commands=commands,
+            log_path=log_path,
+        )
+        context = replace(
+            context,
+            momenta=tuple(tuple(float(value) for value in row) for row in momenta),
+            points=(tuple(tuple(float(value) for value in row) for row in momenta),),
+        )
+        adapter._generate_library(
+            context=context,
+            repository=arguments.amplicol_repository,
+            raw_color=True,
+            n_final=final_multiplicity,
+            settings=settings,
+            commands=commands,
+            log_path=log_path,
+        )
+        adapter._run(
+            ("make", "-j1", "amplicol_color_library_probe"),
+            cwd=arguments.amplicol_repository,
+            commands=commands,
+            log_path=log_path,
+        )
+        generated = adapter.snapshotter.snapshot(
+            arguments.amplicol_repository,
+            cell_root / "contracted-generated-library",
+            executables=("amplicol_color_library_probe",),
+            process_file=context.process_file,
+        )
+        ordered = adapter.api.ordered_momenta(
+            context.source_pdgs,
+            context.entry.process_pdgs,
+            context.momenta,
+        )
+        momentum_path = generated / "momenta.dat"
+        momentum_path.write_text(
+            "\n".join(
+                " ".join(format(component, ".17g") for component in vector)
+                for vector in ordered
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        generation_seconds = time.perf_counter() - generation_started
+        if generation_seconds >= arguments.generation_timeout:
+            raise _CellResourceLimitError(
+                "AmpliCol generated-library generation reached its cap",
+                category="generation-time-limit",
+            )
+        library_environment = legacy_report._library_environment(generated)
+        profile = adapter._profile(
+            lambda count: adapter._invoke_command(
+                (
+                    "./amplicol_color_library_probe",
+                    str(count),
+                    str(context.entry.group),
+                    str(context.entry.integral),
+                    Accuracy.FULL.value,
+                    momentum_path.name,
+                ),
+                cwd=generated,
+                environment=library_environment,
+                commands=commands,
+                log_path=log_path,
+            ),
+            settings=settings,
+            timing_labels=("total",),
+        )
+        validation_result, _, _ = adapter._invoke_command(
+            (
+                "./amplicol_color_library_probe",
+                "1",
+                str(context.entry.group),
+                str(context.entry.integral),
+                Accuracy.FULL.value,
+                momentum_path.name,
+            ),
+            cwd=generated,
+            environment=library_environment,
+            commands=commands,
+            log_path=log_path,
+        )
+    matrix_element = legacy_report._parse_generated_library_color_probe_output(
+        validation_result.stdout + "\n" + validation_result.stderr,
+        expected_accuracy=Accuracy.FULL.value,
+        expected_group=int(context.entry.group),
+        expected_integral=int(context.entry.integral),
+    )
+    if not _positive_finite(matrix_element):
+        raise StudyError("AmpliCol generated library returned a zero/non-finite sum")
+    numerical = _numerical_evidence(
+        family=family,
+        final_multiplicity=final_multiplicity,
+        alpha_s=arguments.alpha_s,
+        observed=(matrix_element,),
+        baseline=baseline,
+    )
+    if numerical["passes"] is False:
+        raise StudyError(
+            "AmpliCol generated-library numerical comparison failed: relative "
+            f"error {numerical['maximum_relative_error']:.6g}"
+        )
+    helicity_coverage_count = 2 ** len(context.source_pdgs)
+    warm_seconds_per_point = profile.seconds / profile.points
+    return base | {
+        "status": "measured",
+        "helicity": list(helicity),
+        "event_paths": [str(path) for path in events],
+        "point_values": [matrix_element],
+        "metrics": {
+            "generation_seconds": generation_seconds,
+            "warm_seconds_per_point": warm_seconds_per_point,
+            "max_rss_kib": _require_bounded_rss(
+                executor.maximum_rss_kib,
+                arguments.memory_limit_gib,
+            ),
+        },
+        "helicity_workload": "sum",
+        "warm_fixed_helicity": False,
+        "warm_helicity_sum": True,
+        "helicity_coverage_count": helicity_coverage_count,
+        "helicity_count_semantics": {
+            "coverage": "complete physical input-helicity axis",
+            "timed": None,
+            "timed_unavailable_reason": (
+                "the create-raw probe prunes combinations with no mapped colour-"
+                "row amplitude but does not expose its retained count"
+            ),
+        },
+        "helicity_compaction": (
+            "probe-local no-mapped-amplitude pruning only; create-raw does not "
+            "apply the generated library's hel_fac filter"
+        ),
+        "generated_library": str(generated),
+        "runtime_profile": {
+            "points": profile.points,
+            "seconds": profile.seconds,
+            "standard_error_seconds_per_point": (
+                profile.standard_error_seconds_per_point
+            ),
+            "relative_standard_error": profile.relative_standard_error,
+            "record": dict(profile.record),
+            "warmup": dict(profile.warmup_record),
+        },
+        "resource_peaks_kib": {
+            "maximum_child_rss": executor.maximum_rss_kib,
+            "maximum_child_guard": executor.maximum_guard_kib,
+        },
+        "process_entry": asdict(context.entry)
+        | {"matching_row_count": context.matching_rows},
+        "numerical": numerical,
+        "provenance": {
+            "implementation": (
+                "original-amplicol-create-raw-bulk-family-complete-helicity-sum"
+            ),
+            "helicity_selector": None,
+            "probe_source_overlay": probe_source_overlay,
+            "commands": commands,
+        },
+    }
+
+
+def _amplicol_cell(
+    *,
+    arguments: argparse.Namespace,
+    family: str,
+    final_multiplicity: int,
+    events: Sequence[Path],
+    helicity: Sequence[int],
+    baseline: Mapping[str, object] | None,
+    run_root: Path,
+    environment: Mapping[str, str],
+) -> dict[str, object]:
+    if arguments.compare_helicity_sums:
+        return _amplicol_summed_cell(
+            arguments=arguments,
+            family=family,
+            final_multiplicity=final_multiplicity,
+            events=events,
+            helicity=helicity,
+            baseline=baseline,
+            run_root=run_root,
+            environment=environment,
+        )
+    base = _cell_base(
+        family,
+        MODE_BY_KEY["amplicol"],
+        final_multiplicity,
+        sum_helicities=arguments.compare_helicity_sums,
+    )
+    cell_root = run_root / "amplicol" / family / f"n{final_multiplicity}"
+    setup = cell_root / "setup"
+    setup.mkdir(parents=True, exist_ok=True)
+    generation = performance._run_watched(
+        _exec_in_command(
+            arguments.python,
+            setup,
+            (
+                arguments.python,
+                str(arguments.amplicol_repository / "process_list.py"),
+                "--serial",
+                process_expression(family, final_multiplicity),
+            ),
+        ),
+        python=arguments.python,
+        environment=environment,
+        timeout_seconds=arguments.generation_timeout,
+        log_path=cell_root / "process-generation.json",
+        memory_limit_gib=arguments.memory_limit_gib,
+        watchdog_report_path=cell_root / "process-generation-watchdog.json",
+    )
+    process_file = setup / "processes.txt"
+    entries = legacy_amplicol.parse_process_file(process_file)
+    source_pdgs = legacy_amplicol.process_pdgs(
+        process_expression(family, final_multiplicity)
+    )
+    entry, matches = legacy_amplicol.select_generated_process_entry(
+        entries,
+        generated_process=process_expression(family, final_multiplicity),
+        wanted_pdgs=source_pdgs,
+    )
+    momenta, event_helicity = _read_event(events[0])
+    if tuple(helicity) != event_helicity:
+        raise StudyError(
+            "AmpliCol event helicity differs from the frozen cell helicity"
+        )
+    permutation = legacy_amplicol._permutation(source_pdgs, entry.process_pdgs)
+    ordered_momenta = legacy_amplicol._ordered_binary64_momenta(
+        source_pdgs, entry.process_pdgs, momenta
+    )
+    ordered_helicity = tuple(int(helicity[index]) for index in permutation)
+    momentum_path = setup / "momenta.dat"
+    momentum_path.write_text(
+        "\n".join(
+            " ".join(format(float(component), ".17g") for component in row)
+            for row in ordered_momenta
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+    def probe_command(points: int) -> tuple[str, ...]:
+        return _exec_in_command(
+            arguments.python,
+            setup,
+            (
+                str((arguments.amplicol_repository / "amplicol_color_probe").resolve()),
+                str(points),
+                str(entry.group),
+                str(entry.integral),
+                "full",
+                str(process_file),
+                str(momentum_path),
+                *(str(value) for value in ordered_helicity),
+            ),
+        )
+
+    probe_wall_budget = min(
+        arguments.runtime_timeout,
+        arguments.generation_timeout - generation.elapsed_seconds,
+    )
+    if probe_wall_budget <= 0.0:
+        raise _CellResourceLimitError(
+            "AmpliCol process generation exhausted the generation cap",
+            category="generation-time-limit",
+        )
+    probe_wall_elapsed = 0.0
+    runtime_self_rss_kib = 0
+    runtime_watchdog_rss_kib = 0
+    runtime_guard_rss_kib = 0
+
+    def run_probe(
+        points: int, probe_environment: Mapping[str, str], log_path: Path
+    ) -> performance.WatchedCompletedProcess:
+        nonlocal probe_wall_elapsed
+        nonlocal runtime_guard_rss_kib
+        nonlocal runtime_self_rss_kib
+        nonlocal runtime_watchdog_rss_kib
+        remaining = probe_wall_budget - probe_wall_elapsed
+        if remaining <= 0.0:
+            raise _CellResourceLimitError(
+                "AmpliCol warm sampling exhausted the per-cell time cap",
+                category="setup-or-runtime-time-limit",
+            )
+        timed_command, normalizer = _timed_command(
+            probe_command(points), python=arguments.python
+        )
+        try:
+            completed = performance._run_watched(
+                timed_command,
+                python=arguments.python,
+                environment=probe_environment,
+                timeout_seconds=remaining,
+                log_path=log_path,
+                memory_limit_gib=arguments.memory_limit_gib,
+                watchdog_report_path=log_path.with_suffix(".watchdog.json"),
+                normalize_completed=normalizer,
+            )
+        except performance.AcceptanceError as error:
+            raise _CellCommandError(
+                f"AmpliCol setup/runtime probe failed: {error}",
+                timeout_category="setup-or-runtime-time-limit",
+            ) from error
+        probe_wall_elapsed += completed.elapsed_seconds
+        if completed.peak_rss_kib is None or completed.peak_guard_kib is None:
+            raise StudyError("AmpliCol runtime watchdog peak evidence is missing")
+        runtime_self_rss_kib = max(
+            runtime_self_rss_kib, _parse_rss_marker(completed.stderr)
+        )
+        runtime_watchdog_rss_kib = max(runtime_watchdog_rss_kib, completed.peak_rss_kib)
+        runtime_guard_rss_kib = max(runtime_guard_rss_kib, completed.peak_guard_kib)
+        return completed
+
+    adaptive_environment = dict(environment)
+    adaptive_environment["AMPICOL_COLOR_PROBE_TARGET_RUNTIME_S"] = (
+        f"{arguments.target_seconds:.17g}"
+    )
+    completed = run_probe(
+        AMPLI_COL_MAX_POINTS, adaptive_environment, cell_root / "probe.json"
+    )
+    generation_setup, seed_total_seconds, adaptive_points = (
+        _parse_amplicol_timing_aggregate(completed.stdout)
+    )
+    generation_seconds = generation.elapsed_seconds + generation_setup
+    if generation_seconds >= arguments.generation_timeout:
+        raise _CellResourceLimitError(
+            "AmpliCol generation reached the strict generation cap",
+            category="generation-time-limit",
+        )
+
+    fixed_environment = dict(environment)
+    fixed_environment.pop("AMPICOL_COLOR_PROBE_TARGET_RUNTIME_S", None)
+
+    def run_sample(sample_set: int, sample: int, repetitions: int) -> str:
+        return run_probe(
+            repetitions,
+            fixed_environment,
+            cell_root / f"warm-sample-set-{sample_set:02d}-sample-{sample:02d}.json",
+        ).stdout
+
+    warm = _collect_amplicol_warm_samples(
+        seed_points=adaptive_points,
+        seed_total_seconds=seed_total_seconds,
+        target_seconds=arguments.target_seconds,
+        run_sample=run_sample,
+    )
+    warm_per_point = statistics.median(warm.samples_seconds)
+    probe = legacy_amplicol._parse_probe_output(completed.stdout)
+    if not math.isfinite(probe.value) or abs(probe.value) <= 1.0e-300:
+        raise StudyError("AmpliCol frozen helicity is zero or non-finite")
+    numerical = _numerical_evidence(
+        family=family,
+        final_multiplicity=final_multiplicity,
+        alpha_s=arguments.alpha_s,
+        observed=(probe.value,),
+        baseline=baseline,
+    )
+    if numerical["passes"] is False:
+        raise StudyError(
+            "AmpliCol numerical comparison failed: relative error "
+            f"{numerical['maximum_relative_error']:.6g}"
+        )
+    if generation.peak_rss_kib is None or generation.peak_guard_kib is None:
+        raise StudyError("AmpliCol generation watchdog peak evidence is missing")
+    generation_rss_kib = generation.peak_rss_kib
+    generation_guard_rss_kib = generation.peak_guard_kib
+    max_rss_kib = _require_bounded_rss(
+        max(runtime_self_rss_kib, generation_rss_kib), arguments.memory_limit_gib
+    )
+    return base | {
+        "status": "measured",
+        "helicity": list(helicity),
+        "event_paths": [str(path) for path in events],
+        "point_values": [probe.value],
+        "metrics": {
+            "generation_seconds": generation_seconds,
+            "warm_seconds_per_point": warm_per_point,
+            "max_rss_kib": max_rss_kib,
+        },
+        "adaptive_runtime_points": adaptive_points,
+        "warm_repetitions": [warm.repetitions] * len(warm.samples_seconds),
+        "warm_samples_seconds": list(warm.samples_seconds),
+        "warm_sample_totals_seconds": list(warm.sample_totals_seconds),
+        "warm_sample_set_attempts": warm.sample_set_attempts,
+        "warm_calibration_seed": {
+            "points": adaptive_points,
+            "total_seconds": seed_total_seconds,
+            "seconds_per_point": seed_total_seconds / adaptive_points,
+        },
+        "resource_peaks_kib": {
+            "generation": generation_rss_kib,
+            "generation_guard": generation_guard_rss_kib,
+            "runtime_self": runtime_self_rss_kib,
+            "runtime_watchdog": runtime_watchdog_rss_kib,
+            "runtime_guard": runtime_guard_rss_kib,
+            "runtime_watchdog_included_in_plotted_rss": False,
+        },
+        "process_entry": asdict(entry) | {"matching_row_count": len(matches)},
+        "numerical": numerical,
+    }
+
+
+def _load_successful_candidate_generation(
+    cell_root: Path,
+) -> performance.WatchedCompletedProcess | None:
+    """Reuse one completed generation phase after a later probe failure."""
+
+    log_path = cell_root / "generation.json"
+    if not (cell_root / "artifact" / "artifact.json").is_file():
+        return None
+    try:
+        payload = json.loads(log_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return None
+    if not isinstance(payload, Mapping):
+        return None
+    command = payload.get("command")
+    elapsed_seconds = payload.get("elapsed_seconds")
+    stdout = payload.get("stdout")
+    stderr = payload.get("stderr")
+    timeout_cleanup = payload.get("timeout_cleanup")
+    if (
+        payload.get("returncode") != 0
+        or payload.get("timed_out") is not False
+        or not isinstance(command, list)
+        or not all(isinstance(item, str) for item in command)
+        or not _positive_finite(elapsed_seconds)
+        or not isinstance(stdout, str)
+        or not isinstance(stderr, str)
+        or not isinstance(timeout_cleanup, str)
+    ):
+        return None
+    return performance.WatchedCompletedProcess(
+        command,
+        0,
+        stdout,
+        stderr,
+        elapsed_seconds=float(elapsed_seconds),
+        log_write_seconds=0.0,
+        timed_out=False,
+        timeout_cleanup=timeout_cleanup,
+    )
+
+
+def _candidate_cli_failure_allows_generation_reuse(
+    cell: Mapping[str, object],
+) -> bool:
+    reason = cell.get("failure_reason")
+    return isinstance(reason, str) and reason.startswith(
+        ("candidate CLI evaluate", "candidate CLI profile", "OTF CLI profile")
+    )
+
+
+def _symbolica_generation_lock_path(
+    environment: Mapping[str, str], *, force: bool = False
+) -> Path | None:
+    configured = environment.get(SYMBOLICA_GENERATION_LOCK_ENV)
+    if configured is not None:
+        if configured.strip().lower() in {"", "0", "false", "no", "off", "none"}:
+            return None
+        return Path(configured).expanduser().resolve(strict=False)
+    if not force and environment.get("SYMBOLICA_LICENSE", "").strip():
+        return None
+    uid = str(os.getuid()) if hasattr(os, "getuid") else "unknown"
+    root = Path("/tmp") if os.name == "posix" else Path(tempfile.gettempdir())
+    return root / f"pyamplicol-symbolica-generation-{uid}.lock"
+
+
+@contextlib.contextmanager
+def _bounded_symbolica_generation_lock(
+    lock_path: Path | None, timeout_seconds: float
+) -> Iterator[None]:
+    if lock_path is None:
+        yield
+        return
+    deadline = time.monotonic() + timeout_seconds
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with lock_path.open("a+", encoding="utf-8") as handle:
+        while True:
+            try:
+                fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+                break
+            except BlockingIOError as error:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0.0:
+                    raise _CellResourceLimitError(
+                        "candidate artifact generation waited for the Symbolica "
+                        "generation lock until the strict generation cap",
+                        category="generation-time-limit",
+                    ) from error
+                time.sleep(min(SYMBOLICA_LOCK_POLL_SECONDS, remaining))
+        try:
+            yield
+        finally:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
+def _symbolica_license_busy_log(log_path: Path) -> bool:
+    try:
+        payload = json.loads(log_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return False
+    if not isinstance(payload, Mapping):
+        return False
+    output = "\n".join(
+        str(payload.get(field, "")) for field in ("stdout", "stderr")
+    ).lower()
+    return SYMBOLICA_LICENSE_BUSY_FRAGMENT in output
+
+
+def _candidate_generation_time_exhausted() -> _CellResourceLimitError:
+    return _CellResourceLimitError(
+        "candidate artifact generation exhausted the strict generation cap",
+        category="generation-time-limit",
+    )
+
+
+def _run_candidate_generation(
+    *,
+    arguments: argparse.Namespace,
+    family: str,
+    final_multiplicity: int,
+    mode: Mode,
+    artifact: Path,
+    cell_root: Path,
+    environment: Mapping[str, str],
+) -> performance.WatchedCompletedProcess:
+    command = _candidate_generation_command(
+        python=arguments.python,
+        family=family,
+        final_multiplicity=final_multiplicity,
+        mode=mode,
+        artifact=artifact,
+        batch_size=arguments.batch_size,
+        optimization_cores=arguments.optimization_cores,
+    )
+    log_path = cell_root / "generation.json"
+    started = time.monotonic()
+    lock_path = _symbolica_generation_lock_path(environment)
+    attempts = 0
+    maximum_attempts = (
+        max(2, math.ceil(arguments.generation_timeout / SYMBOLICA_BUSY_RETRY_SECONDS))
+        + 1
+    )
+    while True:
+        attempts += 1
+        remaining = arguments.generation_timeout - (time.monotonic() - started)
+        if remaining <= 0.0:
+            raise _candidate_generation_time_exhausted()
+        try:
+            with _bounded_symbolica_generation_lock(lock_path, remaining):
+                remaining = arguments.generation_timeout - (time.monotonic() - started)
+                if remaining <= 0.0:
+                    raise _candidate_generation_time_exhausted()
+                return performance._run_watched(
+                    command,
+                    python=arguments.python,
+                    environment=environment,
+                    timeout_seconds=remaining,
+                    log_path=log_path,
+                    memory_limit_gib=arguments.memory_limit_gib,
+                )
+        except performance.AcceptanceError as error:
+            if not _symbolica_license_busy_log(log_path):
+                raise
+            if attempts >= maximum_attempts:
+                raise _candidate_generation_time_exhausted() from error
+            lock_path = lock_path or _symbolica_generation_lock_path(
+                environment, force=True
+            )
+            remaining = arguments.generation_timeout - (time.monotonic() - started)
+            if remaining <= SYMBOLICA_BUSY_RETRY_SECONDS:
+                raise _candidate_generation_time_exhausted() from error
+            time.sleep(min(SYMBOLICA_BUSY_RETRY_SECONDS, remaining))
+
+
+def _validate_publication_candidate_artifact(
+    artifact: Path,
+    process: str,
+) -> int:
+    """Require an authoritative all-runtime-helicity artifact contract."""
+
+    execution_path = artifact / "processes" / process / "execution.json"
+    try:
+        execution = json.loads(execution_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, TypeError):
+        execution = None
+    on_the_fly_kind = "pyamplicol-runtime-on-the-fly-execution"
+    if isinstance(execution, Mapping) and execution.get("kind") == on_the_fly_kind:
+        try:
+            selector_policy = execution["selector_policy"]
+            selector_census = selector_policy["selector_census"]
+            physical_helicity_count = selector_census["physical_helicity_count"]
+            runtime_metadata = execution["runtime_metadata"]
+            process_seed_identity = runtime_metadata["process_seed_identity"]
+            external_sources = process_seed_identity["external_sources"]
+        except (KeyError, TypeError) as error:
+            raise StudyError(
+                "candidate on-the-fly artifact has a malformed helicity contract"
+            ) from error
+        if (
+            not isinstance(execution.get("schema_version"), int)
+            or isinstance(execution.get("schema_version"), bool)
+            or execution.get("schema_version") != 3
+            or execution.get("kind") != on_the_fly_kind
+            or not isinstance(selector_policy, Mapping)
+            or selector_policy.get("color_coverage") != "contracted"
+            or not isinstance(selector_census, Mapping)
+            or not isinstance(physical_helicity_count, int)
+            or isinstance(physical_helicity_count, bool)
+            or physical_helicity_count <= 1
+            or not isinstance(runtime_metadata, Mapping)
+            or not isinstance(process_seed_identity, Mapping)
+            or not isinstance(external_sources, list)
+            or not external_sources
+        ):
+            raise StudyError(
+                "candidate on-the-fly artifact has an invalid helicity contract"
+            )
+
+        derived_helicity_count = 1
+        source_slots: set[int] = set()
+        for source_index, source in enumerate(external_sources):
+            if not isinstance(source, Mapping):
+                raise StudyError(
+                    "candidate on-the-fly artifact has a malformed source identity"
+                )
+            source_slot = source.get("source_slot")
+            states = source.get("states")
+            if (
+                not isinstance(source_slot, int)
+                or isinstance(source_slot, bool)
+                or source_slot != source_index
+                or source_slot in source_slots
+                or not isinstance(states, list)
+                or not states
+            ):
+                raise StudyError(
+                    "candidate on-the-fly artifact has an invalid source identity"
+                )
+            source_slots.add(source_slot)
+            state_indices: set[int] = set()
+            public_helicities: set[int] = set()
+            for state in states:
+                if not isinstance(state, Mapping):
+                    raise StudyError(
+                        "candidate on-the-fly artifact has a malformed source state"
+                    )
+                state_index = state.get("state_index")
+                public_helicity = state.get("public_helicity")
+                if (
+                    not isinstance(state_index, int)
+                    or isinstance(state_index, bool)
+                    or state_index < 0
+                    or state_index in state_indices
+                    or not isinstance(public_helicity, int)
+                    or isinstance(public_helicity, bool)
+                    or public_helicity in public_helicities
+                ):
+                    raise StudyError(
+                        "candidate on-the-fly artifact has an invalid source state"
+                    )
+                state_indices.add(state_index)
+                public_helicities.add(public_helicity)
+            derived_helicity_count *= len(states)
+        if derived_helicity_count != physical_helicity_count:
+            raise StudyError(
+                "candidate on-the-fly artifact helicity census disagrees with "
+                "its process seed"
+            )
+        return physical_helicity_count
+
+    physics_path = artifact / "processes" / process / "physics.json"
+    try:
+        physics = json.loads(physics_path.read_text(encoding="utf-8"))
+        coverage = physics["coverage"]
+        selectors = physics["extensions"]["runtime_selectors"]
+        helicity_axis = selectors["axes"]["helicity"]
+        specialized_axes = selectors["generation_specialized_axes"]
+        helicities = physics["helicities"]
+    except (OSError, json.JSONDecodeError, KeyError, TypeError) as error:
+        raise StudyError(
+            "candidate artifact has no readable helicity-coverage contract"
+        ) from error
+    if (
+        not isinstance(physics, Mapping)
+        or not isinstance(coverage, Mapping)
+        or not isinstance(selectors, Mapping)
+        or not isinstance(helicity_axis, Mapping)
+        or not isinstance(specialized_axes, list)
+        or not isinstance(helicities, list)
+        or len(helicities) <= 1
+        or coverage.get("helicities") != "complete"
+        or helicity_axis.get("generation_coverage") != "complete"
+        or helicity_axis.get("generation_selection") != {}
+        or helicity_axis.get("runtime_contract") != "complete-reusable"
+        or "helicity" in specialized_axes
+    ):
+        raise StudyError(
+            "candidate artifact is not reusable for all runtime helicities"
+        )
+    return len(helicities)
+
+
+def _candidate_cell(
+    *,
+    arguments: argparse.Namespace,
+    family: str,
+    final_multiplicity: int,
+    mode: Mode,
+    events: Sequence[Path],
+    helicity: Sequence[int],
+    baseline: Mapping[str, object] | None,
+    cell_root: Path,
+    environment: Mapping[str, str],
+) -> dict[str, object]:
+    assert mode.execution_mode is not None
+    base = _cell_base(
+        family,
+        mode,
+        final_multiplicity,
+        sum_helicities=arguments.compare_helicity_sums,
+    )
+    artifact = cell_root / "artifact"
+    generation = _load_successful_candidate_generation(cell_root)
+    if generation is None:
+        generation = _run_candidate_generation(
+            arguments=arguments,
+            family=family,
+            final_multiplicity=final_multiplicity,
+            mode=mode,
+            artifact=artifact,
+            cell_root=cell_root,
+            environment=environment,
+        )
+    generation_helicity_count = _validate_publication_candidate_artifact(
+        artifact,
+        process_key(family, final_multiplicity),
+    )
+    momenta_path, parameters_path = _write_candidate_cli_inputs(
+        cell_root=cell_root,
+        events=events,
+        alpha_s=arguments.alpha_s,
+    )
+    evaluate_command = _candidate_evaluate_command(
+        python=arguments.python,
+        artifact=artifact,
+        process=process_key(family, final_multiplicity),
+        momenta=momenta_path,
+        model_parameters=parameters_path,
+        helicity=helicity,
+        sum_helicities=arguments.compare_helicity_sums,
+    )
+    evaluate_timeout = arguments.generation_timeout - generation.elapsed_seconds
+    if evaluate_timeout <= 0.0:
+        raise _CellResourceLimitError(
+            "candidate artifact generation exhausted the strict generation cap",
+            category="generation-time-limit",
+        )
+    try:
+        evaluated = performance._run_watched(
+            evaluate_command,
+            python=arguments.python,
+            environment=environment,
+            timeout_seconds=evaluate_timeout,
+            log_path=cell_root / "evaluate.json",
+            memory_limit_gib=arguments.memory_limit_gib,
+        )
+    except performance.AcceptanceError as error:
+        raise _CellCommandError(
+            f"candidate CLI evaluate failed: {error}",
+            timeout_category="generation-time-limit",
+        ) from error
+    values = _parse_candidate_evaluate_json(evaluated.stdout)
+    generation_seconds = generation.elapsed_seconds + evaluated.elapsed_seconds
+    if generation_seconds >= arguments.generation_timeout:
+        raise _CellResourceLimitError(
+            "candidate generation/fresh CLI evaluation reached the strict "
+            "generation cap",
+            category="generation-time-limit",
+        )
+    generation_rss_kib = _parse_watchdog_peak_rss_kib(generation.stderr)
+    generation_guard_rss_kib = _parse_watchdog_peak_guard_kib(generation.stderr)
+    evaluate_rss_kib = _parse_watchdog_peak_rss_kib(evaluated.stderr)
+    evaluate_guard_rss_kib = _parse_watchdog_peak_guard_kib(evaluated.stderr)
+    if not any(abs(float(value)) > 1.0e-300 for value in values):
+        raise StudyError("candidate CLI evaluation is structurally zero")
+    numerical = _numerical_evidence(
+        family=family,
+        final_multiplicity=final_multiplicity,
+        alpha_s=arguments.alpha_s,
+        observed=[float(value) for value in values],
+        baseline=baseline,
+    )
+    if numerical["passes"] is False:
+        raise StudyError(
+            "candidate numerical comparison failed: relative error "
+            f"{numerical['maximum_relative_error']:.6g}"
+        )
+    profile_command = _candidate_profile_command(
+        python=arguments.python,
+        artifact=artifact,
+        process=process_key(family, final_multiplicity),
+        momenta=momenta_path,
+        helicity=helicity,
+        sum_helicities=arguments.compare_helicity_sums,
+        target_seconds=arguments.target_seconds,
+        batch_size=arguments.batch_size,
+    )
+    try:
+        profiled = performance._run_watched(
+            profile_command,
+            python=arguments.python,
+            environment=environment,
+            timeout_seconds=arguments.runtime_timeout,
+            log_path=cell_root / "profile.json",
+            memory_limit_gib=arguments.memory_limit_gib,
+        )
+    except performance.AcceptanceError as error:
+        raise _CellCommandError(
+            f"candidate CLI profile failed: {error}",
+            timeout_category="runtime-time-limit",
+        ) from error
+    profile = _parse_candidate_profile_json(
+        profiled.stdout,
+        artifact=artifact,
+        family=family,
+        final_multiplicity=final_multiplicity,
+        execution_mode=mode.execution_mode,
+        helicity=helicity,
+        sum_helicities=arguments.compare_helicity_sums,
+        target_seconds=arguments.target_seconds,
+        batch_size=arguments.batch_size,
+    )
+    profile_rss_kib = _parse_watchdog_peak_rss_kib(profiled.stderr)
+    profile_guard_rss_kib = _parse_watchdog_peak_guard_kib(profiled.stderr)
+    measured_rss_kib = max(
+        generation_rss_kib,
+        evaluate_rss_kib,
+        profile_rss_kib,
+    )
+    return base | {
+        "status": "measured",
+        "helicity": list(helicity),
+        "event_paths": [str(path) for path in events],
+        "artifact": str(artifact),
+        "point_values": values,
+        "metrics": {
+            "generation_seconds": generation_seconds,
+            "warm_seconds_per_point": profile["wall_time_per_point"],
+            "max_rss_kib": _require_bounded_rss(
+                measured_rss_kib,
+                arguments.memory_limit_gib,
+            ),
+        },
+        "cli_evaluate": {
+            "command": list(evaluate_command),
+            "elapsed_seconds": evaluated.elapsed_seconds,
+            "result": json.loads(evaluated.stdout),
+            "model_parameters": {
+                "normalization.alpha_s_me_check": arguments.alpha_s
+            },
+        },
+        "runtime_profile_command": list(profile_command),
+        "runtime_profile": profile,
+        "resource_peaks_kib": {
+            "generation": generation_rss_kib,
+            "generation_guard": generation_guard_rss_kib,
+            "evaluate_watchdog": evaluate_rss_kib,
+            "evaluate_guard": evaluate_guard_rss_kib,
+            "profile_watchdog": profile_rss_kib,
+            "profile_guard": profile_guard_rss_kib,
+            "all_process_tree_peaks_included_in_plotted_rss": True,
+        },
+        "numerical": numerical,
+        "generation_helicity_coverage": "all",
+        "generation_helicity_count": generation_helicity_count,
+        **(
+            {
+                "helicity_workload": "sum",
+                "warm_fixed_helicity": False,
+                "warm_helicity_sum": True,
+                "timed_helicity_count": generation_helicity_count,
+                "helicity_count_semantics": {
+                    "coverage": "complete physical runtime input-helicity axis",
+                    "timed": (
+                        "complete physical axis requested once through the null "
+                        "helicity selector; internal structural-zero elimination "
+                        "does not change the API workload"
+                    ),
+                },
+            }
+            if arguments.compare_helicity_sums
+            else {"warm_fixed_helicity": True}
+        ),
+    }
+
+
+def _inputs(
+    report: Mapping[str, object], run_root: Path, family: str, final_multiplicity: int
+) -> tuple[tuple[Path, ...], tuple[int, ...]]:
+    if family == "ddbar":
+        return _ddbar_events(run_root, final_multiplicity), fixed_ddbar_helicity(
+            final_multiplicity
+        )
+    reference = _curve(report, "gg", "reference-fft").get(str(final_multiplicity))
+    if not isinstance(reference, dict) or reference.get("status") != "measured":
+        raise StudyError("shared FFT reference cell is unavailable")
+    raw_events = reference.get("shared_event_paths", reference.get("event_paths"))
+    legacy_events = reference.get("event_paths")
+    raw_helicity = reference.get("helicity")
+    if (
+        not isinstance(raw_events, list)
+        or not isinstance(legacy_events, list)
+        or raw_events != legacy_events
+        or not isinstance(raw_helicity, list)
+    ):
+        raise StudyError("shared FFT reference cell has incomplete inputs")
+    events = tuple(Path(str(path)) for path in raw_events)
+    if len(events) != POINT_COUNT or not all(path.is_file() for path in events):
+        raise StudyError("shared FFT reference events are unavailable")
+    return events, tuple(int(value) for value in raw_helicity)
+
+
+def _baseline(
+    report: Mapping[str, object], family: str, final_multiplicity: int
+) -> Mapping[str, object] | None:
+    key = "reference-fft" if family == "gg" else "amplicol"
+    value = _curve(report, family, key).get(str(final_multiplicity))
+    return value if isinstance(value, dict) else None
+
+
+def _prepare_support_directories(study_root: Path | None = None) -> None:
+    study_root = STUDY_ROOT if study_root is None else study_root
+    cache_root = study_root / "cache"
+    for path in (
+        study_root / "tmp",
+        cache_root / "cargo-home",
+        cache_root / "cargo-target",
+        cache_root / "pip-cache",
+        cache_root / "xdg-cache",
+        cache_root / "python-cache",
+    ):
+        path.mkdir(parents=True, exist_ok=True)
+
+
+def _study_environment(python: str, study_root: Path | None = None) -> dict[str, str]:
+    study_root = STUDY_ROOT if study_root is None else study_root
+    environment = performance._workspace_environment(python)
+    cache_root = study_root / "cache"
+    environment.update(
+        {
+            "TMPDIR": str(study_root / "tmp"),
+            "CARGO_HOME": str(cache_root / "cargo-home"),
+            "CARGO_TARGET_DIR": str(cache_root / "cargo-target"),
+            "PIP_CACHE_DIR": str(cache_root / "pip-cache"),
+            "XDG_CACHE_HOME": str(cache_root / "xdg-cache"),
+            "PYTHONPYCACHEPREFIX": str(cache_root / "python-cache"),
+        }
+    )
+    return environment
+
+
+def _clear_campaign_cell(path: Path) -> None:
+    """Remove only this campaign's exact stale cell/staging path."""
+
+    if path.is_dir():
+        shutil.rmtree(path)
+    elif path.exists():
+        path.unlink()
+
+
+def _candidate_staging_root(cell_root: Path) -> Path:
+    return cell_root.with_name(f".{cell_root.name}.staging")
+
+
+def _adopt_interrupted_candidate_generation(
+    *,
+    staging_root: Path,
+    cell_root: Path,
+    expected_command: Sequence[str],
+    process: str,
+) -> bool:
+    """Atomically retain an interrupted cell's verified generation phase."""
+
+    if cell_root.exists() or not staging_root.is_dir():
+        return False
+    generation = _load_successful_candidate_generation(staging_root)
+    if generation is None or tuple(generation.args) != tuple(expected_command):
+        return False
+    try:
+        _validate_publication_candidate_artifact(staging_root / "artifact", process)
+    except StudyError:
+        return False
+    staging_root.replace(cell_root)
+    return True
+
+
+def _discard_candidate_artifact(cell_root: Path) -> None:
+    """Keep bounded failure logs but not an unpublishable artifact payload."""
+
+    artifact = cell_root / "artifact"
+    if artifact.is_dir():
+        shutil.rmtree(artifact)
+    elif artifact.exists():
+        artifact.unlink()
+
+
+def _promote_candidate_cell(
+    staging_root: Path,
+    cell_root: Path,
+    cell: dict[str, object],
+) -> None:
+    """Atomically publish one completed cell and normalize its artifact path."""
+
+    if not staging_root.is_dir() or cell_root.exists():
+        raise StudyError("candidate cell staging cannot be promoted atomically")
+    artifact = cell.get("artifact")
+    if isinstance(artifact, str):
+        expected = staging_root / "artifact"
+        if Path(artifact) != expected:
+            raise StudyError("candidate cell recorded an unexpected staged artifact")
+    staging_root.replace(cell_root)
+    if isinstance(artifact, str):
+        cell["artifact"] = str(cell_root / "artifact")
+
+
+def _acquire_campaign_lock(lock_root: Path | None = None) -> Any:
+    """Prevent two scaling-study campaign drivers from overlapping."""
+
+    lock_root = STUDY_ROOT if lock_root is None else lock_root
+    lock_path = lock_root / ".campaign.lock"
+    handle = lock_path.open("a+", encoding="utf-8")
+    try:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError as error:
+        handle.close()
+        raise StudyError(f"another campaign driver holds {lock_path}") from error
+    return handle
+
+
+def _campaign(arguments: argparse.Namespace) -> dict[str, object]:
+    global STUDY_ROOT
+    study_root = _study_root(arguments)
+    # A driver process owns one campaign.  Resolve the selected root once so
+    # all legacy no-argument helper seams and their lock agree with --study-root.
+    STUDY_ROOT = study_root
+    run_root = study_root / "runs" / arguments.run_id
+    report_path = run_root / "report.json"
+    run_root.mkdir(parents=True, exist_ok=True)
+    campaign_lock = _acquire_campaign_lock()
+    report = _load_report(report_path, arguments)
+    performance._write_report(report_path, report)
+    _prepare_support_directories()
+    environment = _study_environment(arguments.python)
+    os.environ.update(environment)
+    multiplicities = _multiplicities(arguments)
+    fill_multiplicities = _fill_multiplicities(arguments)
+    families = _selected_families(arguments)
+    modes_by_family = {
+        family: _selected_modes(arguments, family) for family in families
+    }
+    fill_modes_by_family = {
+        family: _fill_modes(arguments, family) for family in families
+    }
+    selected_modes = {
+        mode.key: mode for modes in fill_modes_by_family.values() for mode in modes
+    }
+
+    # Summed AmpliCol cells patch the generated-library probe source under
+    # legacy_structural_probe_lock(); validating here would race with peer cells.
+    if (
+        any(mode.kind == "amplicol" for mode in selected_modes.values())
+        and not arguments.compare_helicity_sums
+    ):
+        legacy_amplicol.validate_checkout(arguments.amplicol_repository)
+        amplicol_probe = arguments.amplicol_repository / "amplicol_color_probe"
+        if not amplicol_probe.is_file():
+            if not arguments.build_amplicol:
+                raise StudyError(
+                    "AmpliCol probe is missing; rerun with --build-amplicol: "
+                    f"{amplicol_probe}"
+                )
+            performance._run_watched(
+                (
+                    "make",
+                    "-C",
+                    str(arguments.amplicol_repository),
+                    "-j1",
+                    "PDF_BACKEND=internal",
+                    "amplicol_color_probe",
+                ),
+                python=arguments.python,
+                environment=environment,
+                timeout_seconds=arguments.generation_timeout,
+                log_path=run_root / "logs" / "amplicol-probe-build.json",
+                memory_limit_gib=arguments.memory_limit_gib,
+            )
+
+    reference_module = (
+        performance._load_reference_module()
+        if any(mode.kind == "reference" for mode in selected_modes.values())
+        else None
+    )
+    for final_multiplicity in fill_multiplicities:
+        for family in families:
+            for mode in fill_modes_by_family[family]:
+                curve = _curve(report, family, mode.key)
+                candidate_cell_root = (
+                    run_root
+                    / "candidate"
+                    / mode.key
+                    / family
+                    / f"n{final_multiplicity}"
+                    if mode.kind == "candidate"
+                    else None
+                )
+                reuse_candidate_generation = False
+                existing = curve.get(str(final_multiplicity))
+                if isinstance(existing, dict):
+                    obsolete_protocol_scope = (
+                        existing.get("failure_category")
+                        == "publication-protocol-scope"
+                        and mode.execution_mode == "on-the-fly"
+                        and final_multiplicity <= arguments.otf_max_multiplicity
+                    )
+                    if obsolete_protocol_scope:
+                        del curve[str(final_multiplicity)]
+                        performance._write_report(report_path, report)
+                        existing = None
+                if isinstance(existing, dict):
+                    higher_measurement_exists = any(
+                        isinstance(other, dict)
+                        and other.get("status") == "measured"
+                        and int(other_n) > final_multiplicity
+                        for other_n, other in curve.items()
+                        if str(other_n).isdigit()
+                    )
+                    retry_lower_resource_frontier = (
+                        existing.get("status") == "failed"
+                        and existing.get("censors_higher_multiplicities") is True
+                        and higher_measurement_exists
+                    )
+                    if (
+                        existing.get("status") == "failed"
+                        and (
+                            existing.get("censors_higher_multiplicities") is False
+                            or retry_lower_resource_frontier
+                        )
+                    ):
+                        reuse_candidate_generation = (
+                            not retry_lower_resource_frontier
+                            and candidate_cell_root is not None
+                            and _candidate_cli_failure_allows_generation_reuse(
+                                existing
+                            )
+                            and _load_successful_candidate_generation(
+                                candidate_cell_root
+                            )
+                            is not None
+                        )
+                        del curve[str(final_multiplicity)]
+                        performance._write_report(report_path, report)
+                    else:
+                        continue
+                censored_at: int | None = next(
+                    (
+                        n
+                        for n in multiplicities
+                        if isinstance(curve.get(str(n)), dict)
+                        and curve[str(n)].get("censors_higher_multiplicities") is True
+                    ),
+                    None,
+                )
+                base = _cell_base(
+                    family,
+                    mode,
+                    final_multiplicity,
+                    sum_helicities=arguments.compare_helicity_sums,
+                )
+                if censored_at is not None and final_multiplicity > censored_at:
+                    _record(
+                        report,
+                        report_path,
+                        family,
+                        mode.key,
+                        final_multiplicity,
+                        base
+                        | {
+                            "status": "skipped",
+                            "failure_reason": (
+                                "curve censored after resource limit at "
+                                f"n={censored_at}"
+                            ),
+                            "failed_at_n": censored_at,
+                            "censors_higher_multiplicities": True,
+                        },
+                    )
+                    continue
+                compiled_fft_na = _compiled_fft_not_applicable_cell(
+                    family=family,
+                    mode=mode,
+                    final_multiplicity=final_multiplicity,
+                    sum_helicities=arguments.compare_helicity_sums,
+                )
+                if compiled_fft_na is not None:
+                    _record(
+                        report,
+                        report_path,
+                        family,
+                        mode.key,
+                        final_multiplicity,
+                        compiled_fft_na,
+                    )
+                    continue
+                otf_scope = otf_protocol_scope_cell(
+                    family=family,
+                    mode=mode,
+                    final_multiplicity=final_multiplicity,
+                    sum_helicities=arguments.compare_helicity_sums,
+                    maximum_multiplicity=arguments.otf_max_multiplicity,
+                )
+                if otf_scope is not None:
+                    _record(
+                        report,
+                        report_path,
+                        family,
+                        mode.key,
+                        final_multiplicity,
+                        otf_scope,
+                    )
+                    continue
+                if family == "gg" and mode.kind != "reference":
+                    dependency_skip = _gg_reference_dependency_skip(
+                        report, final_multiplicity
+                    )
+                    if dependency_skip is not None:
+                        _record(
+                            report,
+                            report_path,
+                            family,
+                            mode.key,
+                            final_multiplicity,
+                            base | dependency_skip,
+                        )
+                        continue
+                if family == "gg" and mode.kind == "amplicol":
+                    preflight = _amplicol_gg_dense_index_preflight(
+                        final_multiplicity, arguments.memory_limit_gib
+                    )
+                    if preflight["feasible"] is False:
+                        lower_bound_gib = int(preflight["lower_bound_bytes"]) / 1024**3
+                        _record(
+                            report,
+                            report_path,
+                            family,
+                            mode.key,
+                            final_multiplicity,
+                            base
+                            | {
+                                "status": "skipped",
+                                "failure_category": "structural-memory-limit",
+                                "failure_reason": (
+                                    "AmpliCol dense symmetric color-index lower bound "
+                                    f"is {lower_bound_gib:.3f} GiB, above the "
+                                    f"{arguments.memory_limit_gib:g} GiB cap"
+                                ),
+                                "censors_higher_multiplicities": True,
+                                "preflight": preflight,
+                            },
+                        )
+                        continue
+                if mode.kind == "reference":
+                    cell_root = run_root / "reference" / f"N{final_multiplicity + 2}"
+                    candidate_staging_root = None
+                elif mode.kind == "amplicol":
+                    cell_root = (
+                        run_root / "amplicol" / family / f"n{final_multiplicity}"
+                    )
+                    candidate_staging_root = None
+                else:
+                    assert candidate_cell_root is not None
+                    interrupted_staging_root = _candidate_staging_root(
+                        candidate_cell_root
+                    )
+                    if not reuse_candidate_generation and arguments.resume:
+                        reuse_candidate_generation = (
+                            _adopt_interrupted_candidate_generation(
+                                staging_root=interrupted_staging_root,
+                                cell_root=candidate_cell_root,
+                                expected_command=_candidate_generation_command(
+                                    python=arguments.python,
+                                    family=family,
+                                    final_multiplicity=final_multiplicity,
+                                    mode=mode,
+                                    artifact=interrupted_staging_root / "artifact",
+                                    batch_size=arguments.batch_size,
+                                    optimization_cores=arguments.optimization_cores,
+                                ),
+                                process=process_key(family, final_multiplicity),
+                            )
+                        )
+                    candidate_staging_root = (
+                        None if reuse_candidate_generation else interrupted_staging_root
+                    )
+                    cell_root = candidate_staging_root or candidate_cell_root
+                try:
+                    if not reuse_candidate_generation:
+                        if candidate_cell_root is not None:
+                            _clear_campaign_cell(candidate_cell_root)
+                            assert candidate_staging_root is not None
+                            _clear_campaign_cell(candidate_staging_root)
+                            candidate_staging_root.mkdir(parents=True)
+                        else:
+                            _clear_campaign_cell(cell_root)
+                    if mode.kind == "reference":
+                        assert reference_module is not None
+                        cell = _reference_cell(
+                            arguments=arguments,
+                            reference=reference_module,
+                            run_root=run_root,
+                            environment=environment,
+                            final_multiplicity=final_multiplicity,
+                        )
+                    else:
+                        events, helicity = _inputs(
+                            report, run_root, family, final_multiplicity
+                        )
+                        baseline = _baseline(report, family, final_multiplicity)
+                        if mode.kind == "amplicol":
+                            cell = _amplicol_cell(
+                                arguments=arguments,
+                                family=family,
+                                final_multiplicity=final_multiplicity,
+                                events=events,
+                                helicity=helicity,
+                                baseline=baseline if family == "gg" else None,
+                                run_root=run_root,
+                                environment=environment,
+                            )
+                        else:
+                            cell = _candidate_cell(
+                                arguments=arguments,
+                                family=family,
+                                final_multiplicity=final_multiplicity,
+                                mode=mode,
+                                events=events,
+                                helicity=helicity,
+                                baseline=baseline,
+                                cell_root=cell_root,
+                                environment=environment,
+                            )
+                    if candidate_staging_root is not None:
+                        assert candidate_cell_root is not None
+                        _promote_candidate_cell(
+                            candidate_staging_root,
+                            candidate_cell_root,
+                            cell,
+                        )
+                except (
+                    StudyError,
+                    performance.AcceptanceError,
+                    legacy_amplicol.LegacyOracleError,
+                    legacy_report.LegacyAdapterError,
+                    legacy_report.ProfilingTimeLimitError,
+                    OSError,
+                    ValueError,
+                ) as error:
+                    cell = _failure_cell(base, error, cell_root)
+                    if candidate_staging_root is not None:
+                        assert candidate_cell_root is not None
+                        if (
+                            cell["censors_higher_multiplicities"] is True
+                            or not _candidate_cli_failure_allows_generation_reuse(
+                                cell
+                            )
+                        ):
+                            _discard_candidate_artifact(candidate_staging_root)
+                        if candidate_staging_root.is_dir():
+                            _promote_candidate_cell(
+                                candidate_staging_root,
+                                candidate_cell_root,
+                                cell,
+                            )
+                    if cell["censors_higher_multiplicities"] is False:
+                        report["status"] = "stopped-correctness-failure"
+                        report["failure_count"] = _failure_count(report) + 1
+                        _record(
+                            report,
+                            report_path,
+                            family,
+                            mode.key,
+                            final_multiplicity,
+                            cell,
+                        )
+                        raise StudyError(
+                            "non-resource failure recorded at "
+                            f"{family}/{mode.key}/n{final_multiplicity}; "
+                            "repair it, then resume to retry that cell"
+                        ) from error
+                _record(
+                    report,
+                    report_path,
+                    family,
+                    mode.key,
+                    final_multiplicity,
+                    cell,
+                )
+
+    failures = _failure_count(report)
+    inversions = resource_frontier_inversions(report)
+    if inversions:
+        report["resource_frontier_inversions"] = [list(item) for item in inversions]
+    else:
+        report.pop("resource_frontier_inversions", None)
+    policy_complete = all(
+        str(final_multiplicity) in _curve(report, family, mode.key)
+        for final_multiplicity in multiplicities
+        for family in families
+        for mode in modes_by_family[family]
+    )
+    report["status"] = (
+        ("complete-with-failures" if failures else "complete")
+        if policy_complete
+        else "running"
+    )
+    report.pop("status_reason", None)
+    report["failure_count"] = failures
+    performance._write_report(report_path, report)
+    campaign_lock.close()
+    return report
+
+
+def dry_run_plan(arguments: argparse.Namespace) -> dict[str, object]:
+    multiplicities = _multiplicities(arguments)
+    families = _selected_families(arguments)
+    modes_by_family = {
+        family: _selected_modes(arguments, family) for family in families
+    }
+    selected_candidate_modes = {
+        mode.key: mode
+        for modes in modes_by_family.values()
+        for mode in modes
+        if mode.kind == "candidate" and mode.key != "compiled-fft"
+    }
+    contractions_by_execution_mode = {
+        execution_mode: [
+            contraction
+            for contraction in ("direct", "symmetric-group-fft")
+            if any(
+                mode.execution_mode == execution_mode
+                and mode.contraction == contraction
+                for mode in selected_candidate_modes.values()
+            )
+        ]
+        for execution_mode in ("recurrence", "on-the-fly", "compiled")
+        if any(
+            mode.execution_mode == execution_mode
+            for mode in selected_candidate_modes.values()
+        )
+    }
+    candidate_generation_metric = (
+        "artifact-generation wall time plus a fresh public `pyamplicol evaluate` "
+        "process loading the artifact and evaluating the ten shared points, "
+        "including OTF selected-family warm-up when applicable"
+    )
+    candidate_warm_metric = (
+        "public `pyamplicol profile --json` wall_time_per_point from true "
+        f"{arguments.batch_size}-point calls cycling the ten shared points; two "
+        f"warm-up calls, at least {PROFILE_SAMPLE_COUNT} independent timed block, and "
+        f"{arguments.target_seconds:g}s cumulative target runtime"
+    )
+    plan = {
+        "kind": KIND,
+        "schema_version": SCHEMA_VERSION,
+        "run_root": str(_study_root(arguments) / "runs" / arguments.run_id),
+        "fft_enabled": bool(arguments.fft_enabled),
+        "selected_pyamplicol_color_contractions": contractions_by_execution_mode,
+        "tools": {
+            "python": arguments.python,
+            "cxx": arguments.cxx,
+            "fc": arguments.fc,
+            "amplicol_repository": str(arguments.amplicol_repository.resolve()),
+            "reference_fft_root": str(arguments.reference_fft_root.resolve()),
+        },
+        "process_families": {
+            family: {
+                "expression": (
+                    "g g > g g + (n-2)*g" if family == "gg" else "d d~ > d d~ + (n-2)*g"
+                ),
+                "ratio_reference": ("reference-fft" if family == "gg" else "amplicol"),
+                "modes": [mode.key for mode in modes_by_family[family]],
+            }
+            for family in families
+        },
+        "final_state_multiplicities": list(multiplicities),
+        "total_external_particles": [n + 2 for n in multiplicities],
+        "measurement": {
+            "color_accuracy": "full",
+            "n_definition": "final-state-particle-count",
+            "generation_helicity_coverage": "all",
+            "warm_fixed_helicity": True,
+            "warm_samples": PROFILE_SAMPLE_COUNT,
+            "calibration_target_seconds": arguments.target_seconds,
+            "candidate_profile_target_runtime_seconds": arguments.target_seconds,
+            "candidate_profile_warmup_runs": PROFILE_WARMUP_RUNS,
+            "candidate_profile_minimum_samples": PROFILE_SAMPLE_COUNT,
+            "warm_benchmark_batch_size": arguments.batch_size,
+            "warm_sample_count": PROFILE_SAMPLE_COUNT,
+            "candidate_optimization_cores": (
+                arguments.optimization_cores
+                if arguments.optimization_cores is not None
+                else "configured-default"
+            ),
+            "generation_timeout_seconds": arguments.generation_timeout,
+            "runtime_timeout_seconds": arguments.runtime_timeout,
+            "requested_memory_ceiling_gib": arguments.memory_limit_gib,
+            "memory_watchdog_gib": arguments.memory_limit_gib,
+            "memory_policy": (
+                "per-cell-strictly-below-publication-ceiling"
+                if arguments.memory_limit_gib == REQUESTED_MEMORY_LIMIT_GIB
+                else "per-cell-strictly-below-configured-ceiling"
+            ),
+            "cell_admission_limits": {
+                "generation_seconds": {
+                    "operator": "<",
+                    "limit": arguments.generation_timeout,
+                },
+                "runtime_seconds": {
+                    "operator": "<",
+                    "limit": arguments.runtime_timeout,
+                },
+                "peak_rss_gib": {
+                    "operator": "<",
+                    "limit": arguments.memory_limit_gib,
+                },
+            },
+            "schedule_order": "multiplicity-then-family-then-mode",
+            "alpha_s": arguments.alpha_s,
+            "resource_failure_censors_higher_n_in_same_curve": True,
+            "non_resource_failure_policy": "record-and-abort-for-repair",
+            "amplicol_gg_dense_index_preflight": (
+                "skip and censor only AmpliCol gg when "
+                "2*((total_external-1)!)^2 bytes exceeds the memory watchdog cap"
+            ),
+            "compiled_fft_applicability": (
+                "not applicable to this helicity-general publication campaign: "
+                "the current compiled FFT backend is a generation-selected "
+                "diagnostic lane; compiled-direct remains supported"
+            ),
+            "compiled_fft_enabled": False,
+            "generation_metric": {
+                "reference-fft": (
+                    "compiler identity/build, event generation, helicity proxy/"
+                    "selection, selected-event writing, initialization, and first pass"
+                ),
+                "amplicol": (
+                    "process-list wall time plus Fortran CPU-time color-object setup"
+                ),
+                "pyamplicol": candidate_generation_metric,
+            },
+            "candidate_rss_metric": (
+                "maximum process-tree peak RSS across public generation, fresh "
+                "CLI evaluate, and fresh CLI profile children"
+            ),
+            "candidate_numerical_metric": (
+                "ten-point public `pyamplicol evaluate --json` with the study "
+                "alpha_s runtime parameter; fixed-H passes one stable selector and "
+                "the summed workload omits the selector"
+            ),
+            "candidate_profile_model_parameters": (
+                "artifact defaults; the profile CLI has no model-parameter option "
+                "and timing control flow is value-independent at alpha_s=0.118"
+            ),
+            "amplicol_rss_metric": (
+                "maximum of process-generation actual peak RSS and Fortran runtime "
+                "child peak RSS; watchdog process-tree RSS/guard are cap telemetry"
+            ),
+            "warm_timing_metric": {
+                "reference-fft": (
+                    f"median of {PROFILE_SAMPLE_COUNT} process-CPU sample(s) "
+                    "after calibrating whole "
+                    f"{arguments.batch_size}-call scalar repetition groups; "
+                    "normalized per evaluation "
+                    "(not a vectorized batch API)"
+                ),
+                "amplicol": (
+                    f"median of {PROFILE_SAMPLE_COUNT} independent process-CPU "
+                    "aggregate(s) with one fixed scalar repetition count; every "
+                    "retained aggregate meets the calibration target and is "
+                    "normalized per evaluation"
+                ),
+                "pyamplicol": candidate_warm_metric,
+            },
+        },
+    }
+    if arguments.compare_helicity_sums:
+        measurement = plan["measurement"]
+        assert isinstance(measurement, dict)
+        measurement.update(
+            {
+                "helicity_workload": "sum",
+                "warm_fixed_helicity": False,
+                "warm_helicity_sum": True,
+                "candidate_timed_helicity_contract": (
+                    "complete null-selector physical-helicity axis; authenticated "
+                    "structural zeros may be eliminated internally"
+                ),
+                "helicity_count_semantics": {
+                    "candidate": (
+                        "coverage and timed count are the complete physical API "
+                        "axis requested by a null helicity selector"
+                    ),
+                    "reference_fft": (
+                        "coverage is the complete physical axis; active/timed is "
+                        "the exact analytic-nonzero subset evaluated per sum"
+                    ),
+                    "amplicol": (
+                        "coverage is the complete physical axis; create-raw "
+                        "evaluates the all-helicity amplitude family in bulk and "
+                        "the probe prunes no-row combinations, but it does not "
+                        "expose that retained count or apply the hel_fac filter"
+                    ),
+                },
+            }
+        )
+        generation_metric = measurement["generation_metric"]
+        assert isinstance(generation_metric, dict)
+        generation_metric["reference-fft"] = (
+            "compiler identity/build, exhaustive event generation, exact "
+            "nonzero-helicity sweep initialization, and first complete sum"
+        )
+        generation_metric["amplicol"] = (
+            "process-list generation, raw contracted-library generation/build, "
+            "and immutable generated-library snapshot"
+        )
+        warm_metric = measurement["warm_timing_metric"]
+        assert isinstance(warm_metric, dict)
+        warm_metric["reference-fft"] = (
+            f"median of {PROFILE_SAMPLE_COUNT} calibrated process-CPU sample(s) "
+            "of one complete analytic-nonzero helicity sum at the "
+            "representative point"
+        )
+        warm_metric["amplicol"] = (
+            f"adaptive aggregate of at least {PROFILE_SAMPLE_COUNT} independently "
+            "timed create-raw bulk-family evaluations followed by a complete "
+            "physical-helicity sum with probe-local no-row pruning, normalized "
+            "per point"
+        )
+    return plan
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--resume", action="store_true")
+    parser.add_argument(
+        "--compare-helicity-sums",
+        action="store_true",
+        help=(
+            "measure the complete physical-helicity sum instead of the fixed "
+            "selected-helicity workload; this is part of report/cache identity"
+        ),
+    )
+    parser.add_argument("--run-id", default="fullcolor-n2-n7")
+    parser.add_argument(
+        "--study-root",
+        type=Path,
+        default=STUDY_ROOT,
+        help=(
+            "isolated cache/run root (default: repository FFT scaling raw root); "
+            "use distinct roots for deliberately parallel campaign shards"
+        ),
+    )
+    parser.add_argument(
+        "--min-n",
+        type=int,
+        default=min(FINAL_MULTIPLICITIES),
+        help="first plotted final-state multiplicity (default: 2)",
+    )
+    parser.add_argument(
+        "--max-n",
+        type=int,
+        default=max(FINAL_MULTIPLICITIES),
+        help="last plotted final-state multiplicity (default: 7)",
+    )
+    parser.add_argument(
+        "--multiplicity",
+        dest="multiplicities",
+        action="append",
+        type=int,
+        help=(
+            "exact final-state multiplicity to run; repeat for a sparse scan "
+            "(overrides --min-n/--max-n)"
+        ),
+    )
+    parser.add_argument(
+        "--fill-multiplicity",
+        dest="fill_multiplicities",
+        action="append",
+        type=int,
+        help=(
+            "populate only this multiplicity in the fixed --multiplicity policy; "
+            "repeat for a bounded resumable fill (not part of report identity)"
+        ),
+    )
+    parser.add_argument(
+        "--fill-mode",
+        dest="fill_modes",
+        action="append",
+        choices=tuple(MODE_BY_KEY),
+        help=(
+            "populate only this mode in the fixed --mode policy; repeat for a "
+            "bounded resumable fill (not part of report identity)"
+        ),
+    )
+    parser.add_argument(
+        "--family",
+        dest="families",
+        action="append",
+        choices=FAMILIES,
+        help="process family to run; repeat to select both (default: all)",
+    )
+    parser.add_argument(
+        "--mode",
+        dest="modes",
+        action="append",
+        choices=tuple(MODE_BY_KEY),
+        help="curve to run; repeat as needed (default: all applicable curves)",
+    )
+    parser.add_argument(
+        "--fft",
+        dest="fft_enabled",
+        action="store_true",
+        help=(
+            "for every selected applicable pyAmpliCol execution mode, retain "
+            "its direct curve and add its symmetric-group FFT curve"
+        ),
+    )
+    parser.add_argument(
+        "--explicit-modes",
+        action="store_true",
+        help="honor repeated --mode values exactly without FFT companion expansion",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=BENCHMARK_BATCH_SIZE,
+        help=(
+            "candidate public CLI profile batch size and Reference scalar "
+            "repetition quantum (default: 128)"
+        ),
+    )
+    parser.add_argument(
+        "--optimization-cores",
+        type=int,
+        help=(
+            "explicit evaluator.optimization.cores for candidate generation; "
+            "the configured default is retained when omitted"
+        ),
+    )
+    parser.add_argument("--python", default=sys.executable)
+    parser.add_argument("--cxx", default=os.environ.get("CXX", "c++"))
+    parser.add_argument("--fc", default=os.environ.get("FC", "gfortran"))
+    parser.add_argument("--alpha-s", type=float, default=DEFAULT_ALPHA_S)
+    parser.add_argument(
+        "--target-seconds",
+        type=float,
+        default=DEFAULT_PROFILE_TARGET_SECONDS,
+        help=(
+            "target cumulative runtime for each timed profiling cell after the "
+            "first calibration/probe evaluation (default: 180)"
+        ),
+    )
+    parser.add_argument(
+        "--generation-timeout", type=float, default=DEFAULT_TIME_LIMIT_SECONDS
+    )
+    parser.add_argument(
+        "--runtime-timeout", type=float, default=DEFAULT_TIME_LIMIT_SECONDS
+    )
+    parser.add_argument("--memory-limit-gib", type=float, default=MAX_MEMORY_LIMIT_GIB)
+    parser.add_argument(
+        "--otf-max-multiplicity",
+        type=int,
+        default=DEFAULT_OTF_MAX_MULTIPLICITY,
+        help=(
+            "largest final-state multiplicity admitted for on-the-fly modes "
+            f"(default publication frontier: {DEFAULT_OTF_MAX_MULTIPLICITY})"
+        ),
+    )
+    parser.add_argument(
+        "--amplicol-repository",
+        type=Path,
+        default=legacy_amplicol.DEFAULT_REPOSITORY,
+    )
+    parser.add_argument(
+        "--reference-fft-root",
+        type=Path,
+        default=performance.DEFAULT_REFERENCE_ROOT,
+    )
+    parser.add_argument("--build-amplicol", action="store_true")
+    return parser
+
+
+def _validate_arguments(arguments: argparse.Namespace) -> None:
+    if performance._RUN_ID.fullmatch(arguments.run_id) is None or arguments.run_id in {
+        ".",
+        "..",
+    }:
+        raise StudyError("--run-id is not a safe workspace-local name")
+    if arguments.alpha_s != DEFAULT_ALPHA_S:
+        raise StudyError(
+            "this FullColor study requires --alpha-s 0.118 to match pinned AmpliCol"
+        )
+    if arguments.multiplicities is not None and (
+        not arguments.multiplicities or min(arguments.multiplicities) < 2
+    ):
+        raise StudyError("--multiplicity values must be integers >=2")
+    if arguments.multiplicities is None and (
+        arguments.min_n < 2 or arguments.max_n < arguments.min_n
+    ):
+        raise StudyError(
+            "--min-n/--max-n must define a nonempty range starting at n>=2"
+        )
+    if arguments.fill_multiplicities is not None:
+        if min(arguments.fill_multiplicities, default=1) < 2:
+            raise StudyError("--fill-multiplicity values must be integers >=2")
+        outside_policy = sorted(
+            set(arguments.fill_multiplicities) - set(_multiplicities(arguments))
+        )
+        if outside_policy:
+            raise StudyError(
+                "--fill-multiplicity values must belong to the fixed policy: "
+                + ", ".join(str(value) for value in outside_policy)
+            )
+    if arguments.batch_size < 1:
+        raise StudyError("--batch-size must be positive")
+    if (
+        not _positive_finite(arguments.target_seconds)
+        or arguments.target_seconds < 0.25
+    ):
+        raise StudyError("--target-seconds must be at least 0.25")
+    if not _positive_finite(arguments.generation_timeout):
+        raise StudyError("--generation-timeout must be positive and finite")
+    if not _positive_finite(arguments.runtime_timeout):
+        raise StudyError("--runtime-timeout must be positive and finite")
+    if not _positive_finite(arguments.memory_limit_gib):
+        raise StudyError("--memory-limit-gib must be positive and finite")
+    if arguments.otf_max_multiplicity < 2:
+        raise StudyError("--otf-max-multiplicity must be at least 2")
+    if arguments.optimization_cores is not None and arguments.optimization_cores < 1:
+        raise StudyError("--optimization-cores must be positive")
+    families = _selected_families(arguments)
+    if not families:
+        raise StudyError("at least one --family is required")
+    modes_by_family = {
+        family: _selected_modes(arguments, family) for family in families
+    }
+    if any(not modes for modes in modes_by_family.values()):
+        raise StudyError("the selected --mode values leave a family with no curves")
+    if arguments.fill_modes is not None:
+        policy_modes = {
+            mode.key for modes in modes_by_family.values() for mode in modes
+        }
+        outside_policy = sorted(set(arguments.fill_modes) - policy_modes)
+        if outside_policy:
+            raise StudyError(
+                "--fill-mode values must belong to the fixed --mode policy: "
+                + ", ".join(outside_policy)
+            )
+        if not any(_fill_modes(arguments, family) for family in families):
+            raise StudyError("--fill-mode leaves no selected curves to populate")
+    gg_modes = {mode.key for mode in modes_by_family.get("gg", ())}
+    if gg_modes - {"reference-fft"} and "reference-fft" not in gg_modes:
+        raise StudyError("gg candidate/AmpliCol curves require --mode reference-fft")
+    ddbar_modes = {mode.key for mode in modes_by_family.get("ddbar", ())}
+    if any(MODE_BY_KEY[key].kind == "candidate" for key in ddbar_modes) and (
+        "amplicol" not in ddbar_modes
+    ):
+        raise StudyError("ddbar candidate curves require --mode amplicol")
+    selected_modes = {
+        mode.key: mode for modes in modes_by_family.values() for mode in modes
+    }
+    if arguments.batch_size == 1 and any(
+        mode.execution_mode == "compiled" and mode.key != "compiled-fft"
+        for mode in selected_modes.values()
+    ):
+        raise StudyError("--batch-size 1 is not supported for compiled curves")
+
+
+def _exec_in(argv: Sequence[str]) -> int:
+    if len(argv) < 2:
+        raise StudyError("_exec-in requires a directory and command")
+    directory = Path(argv[0])
+    directory.mkdir(parents=True, exist_ok=True)
+    os.chdir(directory)
+    command = list(argv[1:])
+    os.execvpe(command[0], command, os.environ)
+    raise AssertionError("os.execvpe returned")
+
+
+def _time_rss(argv: Sequence[str]) -> int:
+    """Run one child and report its getrusage high-water mark."""
+
+    if not argv:
+        raise StudyError("_time-rss requires a command")
+    completed = subprocess.run(tuple(argv), check=False)
+    maximum_rss = int(resource.getrusage(resource.RUSAGE_CHILDREN).ru_maxrss)
+    maximum_rss_kib = maximum_rss // 1024 if sys.platform == "darwin" else maximum_rss
+    if maximum_rss_kib < 1:
+        raise StudyError("_time-rss child did not report a positive RSS")
+    print(f"{RSS_MARKER} {maximum_rss_kib}", file=sys.stderr)
+    return completed.returncode
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    raw = list(sys.argv[1:] if argv is None else argv)
+    try:
+        if raw and raw[0] == "_exec-in":
+            return _exec_in(raw[1:])
+        if raw and raw[0] == "_time-rss":
+            return _time_rss(raw[1:])
+        arguments = _parser().parse_args(raw)
+        performance.configure_reference_root(arguments.reference_fft_root)
+        _validate_arguments(arguments)
+        if arguments.dry_run:
+            print(json.dumps(dry_run_plan(arguments), indent=2, sort_keys=True))
+            return 0
+        result = _campaign(arguments)
+        print(
+            json.dumps(
+                {"status": result["status"], "failure_count": result["failure_count"]},
+                indent=2,
+            )
+        )
+        return 0
+    except (
+        StudyError,
+        performance.AcceptanceError,
+        legacy_report.LegacyAdapterError,
+        legacy_report.ProfilingTimeLimitError,
+        OSError,
+        ValueError,
+    ) as error:
+        print(f"FFT scaling study: {error}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/fft_scaling_study_plots.py b/pyamplicol/tools/developer/fft_scaling_study_plots.py
new file mode 100644
index 0000000000..827c1ea9fa
--- /dev/null
+++ b/pyamplicol/tools/developer/fft_scaling_study_plots.py
@@ -0,0 +1,1701 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Render the FullColor scaling-study report as six publication-style PNGs.
+
+The input report may be complete or still in progress.  Positive measured
+values are plotted; failed, not-applicable, and skipped cells are summarized
+below each relevant figure.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import re
+import sys
+import textwrap
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+try:
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    from matplotlib.axes import Axes
+    from matplotlib.lines import Line2D
+except ModuleNotFoundError as error:  # pragma: no cover - environment dependent
+    raise SystemExit(
+        "fft_scaling_study_plots.py requires matplotlib; run it with a Python "
+        "environment that provides matplotlib"
+    ) from error
+
+
+@dataclass(frozen=True, slots=True)
+class Metric:
+    key: str
+    slug: str
+    title: str
+    axis_label: str
+    scale: float = 1.0
+
+
+@dataclass(frozen=True, slots=True)
+class AxisOptions:
+    main_y_range: tuple[float, float] | None = None
+    ratio_y_range: tuple[float, float] | None = None
+    ratio_y_scale: str = "log"
+
+
+@dataclass(frozen=True, slots=True)
+class LineFilterOptions:
+    main_include_lines: tuple[str, ...] | None = None
+    main_veto_lines: tuple[str, ...] = ()
+    ratio_include_lines: tuple[str, ...] | None = None
+    ratio_veto_lines: tuple[str, ...] = ()
+
+
+METRICS = (
+    Metric(
+        "generation_seconds",
+        "generation",
+        "Setup time",
+        "Time [s]",
+    ),
+    Metric(
+        "warm_seconds_per_point",
+        "warm-runtime",
+        "Warmed runtime per point",
+        "Time per point [s]",
+    ),
+    Metric("max_rss_kib", "rss", "Peak RSS", "Peak RSS [MiB]", 1 / 1024),
+)
+FAMILIES = ("gg", "ddbar")
+FAMILY_TITLES = {
+    "gg": r"$g g \;\to\; g g + (n-2)g$",
+    "ddbar": r"$d \bar{d} \;\to\; d \bar{d} + (n-2)g$",
+}
+FAMILY_BASELINES = {"gg": "reference-fft", "ddbar": "amplicol"}
+RECOLA_MODE = "recola"
+RECOLA_LABEL = "Recola"
+RECOLA_FAMILY_MAP = {
+    "all_gluon": "gg",
+    "down_quark_qcd": "ddbar",
+}
+MODE_LABELS = {
+    "reference-fft": "Reference FFT",
+    "amplicol": "AmpliCol",
+    "recurrence-direct": "pyAmpliCol - recurrence",
+    "recurrence-fft": "pyAmpliCol - recurrence - FFT",
+    "otf-direct": "pyAmpliCol - OTF",
+    "otf-fft": "pyAmpliCol - OTF - FFT",
+    "compiled-direct": "pyAmpliCol - Compiled",
+    "compiled-fft": "pyAmpliCol - Compiled - FFT",
+    "madgraph-standalone": "MadGraph standalone (fixed h)",
+    RECOLA_MODE: RECOLA_LABEL,
+}
+MODE_STYLES = {
+    "reference-fft": ("#000000", "o", "-"),
+    "amplicol": ("#F0E442", "D", "-"),
+    "recurrence-direct": ("#009E73", "o", "--"),
+    "recurrence-fft": ("#009E73", "s", "-"),
+    "otf-direct": ("#0072B2", "^", "--"),
+    "otf-fft": ("#0072B2", "v", "-"),
+    "compiled-direct": ("#D55E00", "P", "--"),
+    "compiled-fft": ("#7A3E9D", "X", "-"),
+    "madgraph-standalone": ("#CC3311", "*", "-"),
+    RECOLA_MODE: ("#AA4499", "h", "-"),
+}
+PLOT_LINE_SELECTOR_MODES = {
+    "reference-fft": ("reference-fft",),
+    "amplicol": ("amplicol",),
+    "pyamplicol-recurrence": ("recurrence-direct", "recurrence-fft"),
+    "pyamplicol-otf": ("otf-direct", "otf-fft"),
+    "madgraph": ("madgraph-standalone",),
+    "recurrence-direct": ("recurrence-direct",),
+    "recurrence-fft": ("recurrence-fft",),
+    "otf-direct": ("otf-direct",),
+    "otf-fft": ("otf-fft",),
+    "madgraph-standalone": ("madgraph-standalone",),
+    "recola": (RECOLA_MODE,),
+    "compiled-direct": ("compiled-direct",),
+    "compiled-fft": ("compiled-fft",),
+}
+PLOT_LINE_CHOICES = tuple(PLOT_LINE_SELECTOR_MODES)
+LEGEND_MODE_ORDER = {
+    # Matplotlib fills a multi-column legend down each column.  Keep each
+    # Direct/FFT strategy pair together, with FFT (solid) above Direct
+    # (dashed), so the encoding can be read at a glance.
+    "gg": (
+        "reference-fft",
+        "amplicol",
+        "recurrence-fft",
+        "recurrence-direct",
+        "otf-fft",
+        "otf-direct",
+        "madgraph-standalone",
+        RECOLA_MODE,
+    ),
+    "ddbar": (
+        "amplicol",
+        "madgraph-standalone",
+        "recurrence-fft",
+        "recurrence-direct",
+        "otf-fft",
+        "otf-direct",
+        RECOLA_MODE,
+    ),
+}
+STATUS_ORDER = {"failed": 0, "not-applicable": 1, "skipped": 2}
+PROVISIONAL_WARM_STATUS = "excluded-provisional-warm-quality"
+EXIT_STATUS = re.compile(r"command failed with status\s+(-?\d+)")
+PLOT_MANIFEST_NAME = "plot-manifest.json"
+PLOT_DATA_NAME = "plot-data.json"
+PLOT_FILENAMES = tuple(
+    f"fullcolor-{family}-{metric.slug}.png"
+    for family in FAMILIES
+    for metric in METRICS
+)
+DEFAULT_AXIS_OPTIONS = AxisOptions()
+DEFAULT_LINE_FILTER_OPTIONS = LineFilterOptions()
+
+
+class PlotError(RuntimeError):
+    """The report cannot be rendered without guessing its meaning."""
+
+
+def _finite_float(raw: str) -> float:
+    value = float(raw)
+    if not math.isfinite(value):
+        raise argparse.ArgumentTypeError("must be finite")
+    return value
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("report", type=Path, help="scaling-study report.json")
+    parser.add_argument("output_directory", type=Path, help="directory for six PNGs")
+    parser.add_argument(
+        "--dpi",
+        type=int,
+        default=160,
+        help="PNG resolution in dots per inch (default: 160)",
+    )
+    parser.add_argument(
+        "--recola-results",
+        type=Path,
+        help="overlay a Recola profiling JSON as an external Recola series",
+    )
+    parser.add_argument(
+        "--main-y-range",
+        type=_finite_float,
+        nargs=2,
+        metavar=("MIN", "MAX"),
+        help="force the main-panel log y-range for every plot",
+    )
+    parser.add_argument(
+        "--ratio-y-range",
+        type=_finite_float,
+        nargs=2,
+        metavar=("MIN", "MAX"),
+        help="force the ratio-panel y-range for every plot",
+    )
+    parser.add_argument(
+        "--ratio-y-scale",
+        choices=("log", "linear"),
+        default="log",
+        help="ratio-panel y-axis scale (default: log)",
+    )
+    parser.add_argument(
+        "--main-include-lines",
+        nargs="+",
+        choices=PLOT_LINE_CHOICES,
+        metavar="LINE",
+        help="main-panel line ids to include; overrides --main-veto-lines",
+    )
+    parser.add_argument(
+        "--main-veto-lines",
+        nargs="+",
+        choices=PLOT_LINE_CHOICES,
+        metavar="LINE",
+        help="main-panel line ids to hide when --main-include-lines is absent",
+    )
+    parser.add_argument(
+        "--ratio-include-lines",
+        nargs="+",
+        choices=PLOT_LINE_CHOICES,
+        metavar="LINE",
+        help="ratio-panel line ids to include; overrides --ratio-veto-lines",
+    )
+    parser.add_argument(
+        "--ratio-veto-lines",
+        nargs="+",
+        choices=PLOT_LINE_CHOICES,
+        metavar="LINE",
+        help="ratio-panel line ids to hide when --ratio-include-lines is absent",
+    )
+    return parser
+
+
+def _validate_y_range(
+    values: Sequence[float] | None,
+    *,
+    option: str,
+    positive: bool,
+) -> tuple[float, float] | None:
+    if values is None:
+        return None
+    if len(values) != 2:
+        raise PlotError(f"{option} requires exactly two values")
+    low, high = (float(values[0]), float(values[1]))
+    if not math.isfinite(low) or not math.isfinite(high):
+        raise PlotError(f"{option} values must be finite")
+    if high <= low:
+        raise PlotError(f"{option} requires MIN < MAX")
+    if positive and low <= 0.0:
+        raise PlotError(f"{option} must be positive for a logarithmic y-axis")
+    return low, high
+
+
+def _axis_options_from_arguments(arguments: argparse.Namespace) -> AxisOptions:
+    ratio_y_scale = str(arguments.ratio_y_scale)
+    if ratio_y_scale not in {"log", "linear"}:
+        raise PlotError("--ratio-y-scale must be 'log' or 'linear'")
+    return AxisOptions(
+        main_y_range=_validate_y_range(
+            arguments.main_y_range,
+            option="--main-y-range",
+            positive=True,
+        ),
+        ratio_y_range=_validate_y_range(
+            arguments.ratio_y_range,
+            option="--ratio-y-range",
+            positive=ratio_y_scale == "log",
+        ),
+        ratio_y_scale=ratio_y_scale,
+    )
+
+
+def _validated_line_names(
+    values: Sequence[str] | None,
+    *,
+    option: str,
+    default: tuple[str, ...] | None,
+) -> tuple[str, ...] | None:
+    if values is None:
+        return default
+    selected = tuple(str(value) for value in values)
+    if len(set(selected)) != len(selected):
+        raise PlotError(f"{option} must not contain duplicates")
+    invalid = sorted(set(selected) - set(PLOT_LINE_CHOICES))
+    if invalid:
+        raise PlotError(f"{option} has unknown line id(s): {', '.join(invalid)}")
+    return selected
+
+
+def _line_filter_options_from_arguments(
+    arguments: argparse.Namespace,
+) -> LineFilterOptions:
+    return LineFilterOptions(
+        main_include_lines=_validated_line_names(
+            arguments.main_include_lines,
+            option="--main-include-lines",
+            default=None,
+        ),
+        main_veto_lines=_validated_line_names(
+            arguments.main_veto_lines,
+            option="--main-veto-lines",
+            default=(),
+        )
+        or (),
+        ratio_include_lines=_validated_line_names(
+            arguments.ratio_include_lines,
+            option="--ratio-include-lines",
+            default=None,
+        ),
+        ratio_veto_lines=_validated_line_names(
+            arguments.ratio_veto_lines,
+            option="--ratio-veto-lines",
+            default=(),
+        )
+        or (),
+    )
+
+
+def _load_report_snapshot(path: Path) -> tuple[dict[str, Any], str]:
+    try:
+        raw = path.read_bytes()
+        payload = json.loads(raw)
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise PlotError(f"cannot read {path}: {error}") from error
+    if not isinstance(payload, dict) or not isinstance(payload.get("cells"), dict):
+        raise PlotError("report must be a JSON object containing a cells object")
+    return payload, hashlib.sha256(raw).hexdigest()
+
+
+def _load_report(path: Path) -> dict[str, Any]:
+    return _load_report_snapshot(path)[0]
+
+
+def _mapping(value: object) -> Mapping[str, Any]:
+    return value if isinstance(value, Mapping) else {}
+
+
+def _mode_order(report: Mapping[str, Any], family: str) -> tuple[str, ...]:
+    policy = _mapping(report.get("policy"))
+    family_policy = _mapping(_mapping(policy.get("process_families")).get(family))
+    requested = family_policy.get("modes")
+    if isinstance(requested, Sequence) and not isinstance(requested, str):
+        modes = tuple(str(mode) for mode in requested)
+        if modes:
+            return modes
+    family_cells = _mapping(_mapping(report.get("cells")).get(family))
+    return tuple(family_cells)
+
+
+def _multiplicities(report: Mapping[str, Any]) -> tuple[int, ...]:
+    policy = _mapping(report.get("policy"))
+    requested = policy.get("final_state_multiplicities")
+    if isinstance(requested, Sequence) and not isinstance(requested, str):
+        values = tuple(sorted({int(value) for value in requested}))
+        if values:
+            return values
+    observed: set[int] = set()
+    for family in FAMILIES:
+        for cells in _mapping(_mapping(report.get("cells")).get(family)).values():
+            observed.update(int(value) for value in _mapping(cells))
+    if not observed:
+        raise PlotError("report has no requested or observed multiplicities")
+    return tuple(sorted(observed))
+
+
+def _source_boundary(
+    report: Mapping[str, Any], metric_key: str | None = None
+) -> tuple[float, str] | None:
+    policy = _mapping(report.get("policy"))
+    plot = _mapping(policy.get("plot"))
+    metric_boundaries = _mapping(plot.get("metric_source_boundaries"))
+    if metric_key is not None and metric_key in metric_boundaries:
+        metric_boundary = metric_boundaries[metric_key]
+        if metric_boundary is None:
+            return None
+        boundary_policy = _mapping(metric_boundary)
+    else:
+        boundary_policy = plot
+    raw_boundary = boundary_policy.get("source_boundary_after_n")
+    if raw_boundary is None:
+        return None
+    if isinstance(raw_boundary, bool) or not isinstance(raw_boundary, int):
+        raise PlotError("policy.plot.source_boundary_after_n must be an integer")
+    multiplicities = _multiplicities(report)
+    if raw_boundary not in multiplicities or raw_boundary + 1 not in multiplicities:
+        raise PlotError(
+            "policy.plot.source_boundary_after_n must separate two plotted "
+            "multiplicities"
+        )
+    raw_label = boundary_policy.get("source_boundary_label")
+    label = (
+        raw_label
+        if isinstance(raw_label, str) and raw_label.strip()
+        else f"source boundary after n={raw_boundary}"
+    )
+    return raw_boundary + 0.5, label
+
+
+def _protocol_summary(
+    report: Mapping[str, Any], *, ratio_y_scale: str = "log"
+) -> str:
+    policy = _mapping(report.get("policy"))
+    measurement = _mapping(policy.get("measurement"))
+    if policy.get("fft_enabled") is not True:
+        return f"main Y log; ratio Y {ratio_y_scale}"
+    details = ["Campaign --fft enabled"]
+    if measurement.get("generation_helicity_coverage") == "all":
+        details.append("artifacts: all runtime helicities")
+    workload = _helicity_workload(report)
+    if workload == "fixed":
+        details.append("setup/warm workload: one fixed helicity")
+    elif workload == "sum":
+        details.append("setup/warm workload: complete helicity sum")
+        details.append("AmpliCol: create-raw bulk H family")
+    batch_size = measurement.get("warm_benchmark_batch_size")
+    if (
+        not isinstance(batch_size, int)
+        or isinstance(batch_size, bool)
+        or batch_size < 1
+    ):
+        raise PlotError("measurement warm_benchmark_batch_size must be positive")
+    details.append(f"pyAmpliCol CLI profile: batch {batch_size} (cyclic 10 points)")
+    details.append("Reference/AmpliCol: scalar aggregates normalized per point")
+    if measurement.get("compiled_fft_enabled") is False:
+        details.append("compiled FFT disabled")
+    details.append(f"main Y log; ratio Y {ratio_y_scale}")
+    return " | ".join(details)
+
+
+def _protocol_summary_lines(
+    report: Mapping[str, Any],
+    *,
+    max_line_length: int = 110,
+    ratio_y_scale: str = "log",
+) -> tuple[str, ...]:
+    """Wrap the protocol at semantic separators for a stable plot header."""
+
+    if max_line_length < 1:
+        raise ValueError("max_line_length must be positive")
+    sections = _protocol_summary(report, ratio_y_scale=ratio_y_scale).split(" | ")
+    lines: list[str] = []
+    current = ""
+    for section in sections:
+        candidate = section if not current else f"{current} | {section}"
+        if current and len(candidate) > max_line_length:
+            lines.append(current)
+            current = section
+        else:
+            current = candidate
+    if current:
+        lines.append(current)
+    return tuple(lines)
+
+
+def _helicity_workload(report: Mapping[str, Any]) -> str:
+    """Return the explicitly measured warm-helicity workload.
+
+    Older selected-scalar reports predate ``helicity_workload`` and are
+    identified by their existing ``warm_fixed_helicity`` contract.
+    """
+
+    policy = _mapping(report.get("policy"))
+    measurement = _mapping(policy.get("measurement"))
+    measurement_declared = measurement.get("helicity_workload")
+    policy_declared = policy.get("helicity_workload")
+    if (
+        measurement_declared is not None
+        and policy_declared is not None
+        and str(measurement_declared) != str(policy_declared)
+    ):
+        raise PlotError(
+            "policy and measurement helicity_workload declarations disagree"
+        )
+    declared = (
+        measurement_declared
+        if measurement_declared is not None
+        else policy_declared
+    )
+    if declared is not None:
+        value = str(declared)
+        if value not in {"fixed", "sum"}:
+            raise PlotError("policy helicity_workload must be 'fixed' or 'sum'")
+        if value == "sum" and (
+            measurement.get("warm_fixed_helicity") is not False
+            or measurement.get("warm_helicity_sum") is not True
+        ):
+            raise PlotError(
+                "summed policy must record warm_fixed_helicity=false and "
+                "warm_helicity_sum=true"
+            )
+        if value == "fixed" and (
+            measurement.get("warm_fixed_helicity") is not True
+            or measurement.get("warm_helicity_sum") is True
+        ):
+            raise PlotError(
+                "fixed policy must record warm_fixed_helicity=true without "
+                "warm_helicity_sum=true"
+            )
+        return value
+    if (
+        measurement.get("warm_helicity_sum") is True
+        and measurement.get("warm_fixed_helicity") is True
+    ):
+        raise PlotError("campaign helicity workload markers are contradictory")
+    if measurement.get("warm_helicity_sum") is True:
+        return "sum"
+    if measurement.get("warm_fixed_helicity") is True:
+        return "fixed"
+    return "fixed"
+
+
+def _metric_title(report: Mapping[str, Any], metric: Metric) -> str:
+    if metric.key == "warm_seconds_per_point" and _helicity_workload(report) == "sum":
+        return "Warmed helicity-summed runtime per point"
+    return metric.title
+
+
+def _metric_axis_label(report: Mapping[str, Any], metric: Metric) -> str:
+    if metric.key == "warm_seconds_per_point" and _helicity_workload(report) == "sum":
+        return "Time per helicity-summed point [s]"
+    return metric.axis_label
+
+
+def _label(family_cells: Mapping[str, Any], mode: str) -> str:
+    for cell in _mapping(family_cells.get(mode)).values():
+        label = _mapping(cell).get("label")
+        if isinstance(label, str) and label:
+            return label
+    return MODE_LABELS.get(mode, mode)
+
+
+def _positive_number(value: object) -> float | None:
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        return None
+    result = float(value)
+    if not math.isfinite(result) or result <= 0.0:
+        return None
+    return result
+
+
+def _load_recola_results(path: Path) -> tuple[Mapping[str, Any], str]:
+    try:
+        raw = path.read_bytes()
+        payload = json.loads(raw)
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise PlotError(f"cannot read Recola results {path}: {error}") from error
+    if not isinstance(payload, Mapping):
+        raise PlotError("Recola results must be a JSON object")
+    return payload, hashlib.sha256(raw).hexdigest()
+
+
+def _recola_cell_workload(
+    cell: Mapping[str, Any],
+    config: Mapping[str, Any],
+    *,
+    context: str,
+) -> str:
+    polarized = cell.get("polarized")
+    if not isinstance(polarized, bool):
+        polarized = config.get("polarized")
+    if not isinstance(polarized, bool):
+        raise PlotError(f"{context} lacks a boolean Recola polarized marker")
+    return "fixed" if polarized else "sum"
+
+
+def _recola_metrics(cell: Mapping[str, Any]) -> dict[str, float]:
+    metrics: dict[str, float] = {}
+    generation_seconds = _positive_number(cell.get("gen_time_s"))
+    if generation_seconds is not None:
+        metrics["generation_seconds"] = generation_seconds
+    warm_seconds = _positive_number(cell.get("run_time_s"))
+    if warm_seconds is not None:
+        metrics["warm_seconds_per_point"] = warm_seconds
+    rss_values = [
+        value
+        for field in (
+            "peak_generation_rss_mib",
+            "ram_after_generation_mib",
+            "ram_after_profile_mib",
+        )
+        if (value := _positive_number(cell.get(field))) is not None
+    ]
+    if rss_values:
+        metrics["max_rss_kib"] = max(rss_values) * 1024.0
+    return metrics
+
+
+def _recola_failure_category(reason: str) -> str:
+    if "RSS" in reason or "MAX_RSS" in reason:
+        return "memory-limit"
+    if "generation time" in reason or "MAX_GEN_T" in reason:
+        return "generation-time-limit"
+    return "generation-timeout"
+
+
+def _recola_source_metadata(
+    path: Path,
+    digest: str,
+    cells_by_family: Mapping[str, Sequence[int]],
+) -> dict[str, Any]:
+    return {
+        "kind": "recola-profile-results",
+        "path": str(path.expanduser().resolve(strict=False)),
+        "sha256": digest,
+        "mode": RECOLA_MODE,
+        "label": RECOLA_LABEL,
+        "family_map": dict(RECOLA_FAMILY_MAP),
+        "metrics": {
+            "generation_seconds": "gen_time_s",
+            "warm_seconds_per_point": "run_time_s",
+            "max_rss_kib": (
+                "max(peak_generation_rss_mib, ram_after_generation_mib, "
+                "ram_after_profile_mib) * 1024"
+            ),
+        },
+        "multiplicities": {
+            family: list(multiplicities)
+            for family, multiplicities in cells_by_family.items()
+        },
+    }
+
+
+def _attach_recola_results(report: dict[str, Any], path: Path) -> dict[str, Any]:
+    payload, digest = _load_recola_results(path)
+    results = payload.get("results")
+    if not isinstance(results, Mapping):
+        raise PlotError("Recola results must contain a results object")
+    config = _mapping(payload.get("config"))
+    expected_workload = _helicity_workload(report)
+    config_polarized = config.get("polarized")
+    if isinstance(config_polarized, bool):
+        config_workload = "fixed" if config_polarized else "sum"
+        if config_workload != expected_workload:
+            raise PlotError(
+                f"Recola results are {config_workload} workload but the campaign "
+                f"report is {expected_workload}"
+            )
+    series: dict[str, dict[str, dict[str, Any]]] = {}
+    multiplicities_by_family: dict[str, list[int]] = {family: [] for family in FAMILIES}
+    measured_count = 0
+
+    for raw_family, raw_family_results in results.items():
+        if not isinstance(raw_family_results, Mapping):
+            raise PlotError(f"Recola results family {raw_family!r} must be an object")
+        for raw_n, raw_cell in raw_family_results.items():
+            if raw_cell is None:
+                continue
+            if not isinstance(raw_cell, Mapping):
+                raise PlotError(f"Recola {raw_family}/n={raw_n} must be an object")
+            try:
+                multiplicity = int(raw_n)
+            except (TypeError, ValueError) as error:
+                raise PlotError(
+                    f"Recola multiplicity {raw_family}/n={raw_n!r} is not an integer"
+                ) from error
+            source_family = str(raw_cell.get("family") or raw_family)
+            target_family = RECOLA_FAMILY_MAP.get(source_family)
+            if target_family is None:
+                continue
+            context = f"Recola {source_family}/n={multiplicity}"
+            status = raw_cell.get("status")
+            if status == "limit_reached":
+                reason = raw_cell.get("error")
+                reason_text = (
+                    reason
+                    if isinstance(reason, str) and reason.strip()
+                    else "Recola generation limit reached"
+                )
+                cell_payload = {
+                    "status": "failed",
+                    "label": RECOLA_LABEL,
+                    "failure_category": _recola_failure_category(reason_text),
+                    "failure_reason": reason_text,
+                }
+            else:
+                metrics = _recola_metrics(raw_cell)
+                if not metrics:
+                    continue
+                observed_workload = _recola_cell_workload(
+                    raw_cell,
+                    config,
+                    context=context,
+                )
+                if observed_workload != expected_workload:
+                    raise PlotError(
+                        f"{context} is {observed_workload} workload but the "
+                        f"campaign report is {expected_workload}"
+                    )
+                cell_payload = {
+                    "status": "measured",
+                    "label": RECOLA_LABEL,
+                    "metrics": metrics,
+                    "helicity_workload": observed_workload,
+                    "warm_fixed_helicity": observed_workload == "fixed",
+                    "warm_helicity_sum": observed_workload == "sum",
+                    "process": raw_cell.get("process"),
+                    "helicity": raw_cell.get("helicity"),
+                    "profiled_call": raw_cell.get("profiled_call"),
+                }
+                measured_count += 1
+            series.setdefault(target_family, {})[str(multiplicity)] = cell_payload
+            multiplicities_by_family[target_family].append(multiplicity)
+
+    if measured_count == 0:
+        raise PlotError("Recola results contain no measured cells")
+
+    runtime_series = report.setdefault("runtime_series", {})
+    if not isinstance(runtime_series, dict):
+        raise PlotError("report runtime_series must be an object when present")
+    for family, cells in series.items():
+        family_runtime = runtime_series.setdefault(family, {})
+        if not isinstance(family_runtime, dict):
+            raise PlotError(f"report runtime_series.{family} must be an object")
+        family_cells = _mapping(_mapping(report.get("cells")).get(family))
+        if RECOLA_MODE in family_runtime or RECOLA_MODE in family_cells:
+            raise PlotError(f"external series duplicates {family}/{RECOLA_MODE}")
+        family_runtime[RECOLA_MODE] = {
+            raw_n: cells[raw_n] for raw_n in sorted(cells, key=int)
+        }
+
+    return _recola_source_metadata(
+        path,
+        digest,
+        {
+            family: sorted(set(multiplicities))
+            for family, multiplicities in multiplicities_by_family.items()
+            if multiplicities
+        },
+    )
+
+
+def _series(
+    family_cells: Mapping[str, Any], mode: str, metric: Metric
+) -> list[tuple[int, float]]:
+    values: list[tuple[int, float]] = []
+    for raw_n, raw_cell in _mapping(family_cells.get(mode)).items():
+        multiplicity = int(raw_n)
+        cell = _mapping(raw_cell)
+        if cell.get("status") != "measured":
+            continue
+        exclusion = _mapping(_mapping(cell.get("excluded_metrics")).get(metric.key))
+        exclusion_status = exclusion.get("status")
+        if isinstance(exclusion_status, str) and exclusion_status.startswith(
+            "excluded-"
+        ):
+            # Compatibility with already-written rolling snapshots: the
+            # superseded 3% advisory gate moved otherwise valid measurements
+            # under excluded_metrics.  Plot those values exactly like any
+            # other measured warm point so curves and ratios stay continuous.
+            if (
+                metric.key == "warm_seconds_per_point"
+                and exclusion_status == PROVISIONAL_WARM_STATUS
+            ):
+                value = _positive_number(exclusion.get("value"))
+            else:
+                continue
+        else:
+            value = _positive_number(_mapping(cell.get("metrics")).get(metric.key))
+        if value is not None:
+            values.append((multiplicity, value * metric.scale))
+    return sorted(values)
+
+
+def _family_cells_for_metric(
+    report: Mapping[str, Any], family: str, metric: Metric
+) -> tuple[dict[str, Any], tuple[str, ...]]:
+    family_cells = dict(_mapping(_mapping(report.get("cells")).get(family)))
+    modes = _mode_order(report, family)
+    runtime_series = _mapping(_mapping(report.get("runtime_series")).get(family))
+    for mode, raw_cells in runtime_series.items():
+        mode = str(mode)
+        if mode in family_cells or mode in modes:
+            raise PlotError(f"external series duplicates {family}/{mode}")
+        cells = _mapping(raw_cells)
+        family_cells[mode] = {
+            str(raw_n): dict(_mapping(raw_cell)) for raw_n, raw_cell in cells.items()
+        }
+        modes = (*modes, mode)
+    _validate_cell_workloads(report, family, family_cells)
+    excluded_modes = _metric_series_exclusions(report, family, metric)
+    if excluded_modes:
+        modes = tuple(mode for mode in modes if mode not in excluded_modes)
+        for mode in excluded_modes:
+            family_cells.pop(mode, None)
+    return family_cells, modes
+
+
+def _declared_cell_workload(cell: Mapping[str, Any]) -> str | None:
+    markers: set[str] = set()
+    declared = cell.get("helicity_workload")
+    if declared is not None:
+        workload = str(declared)
+        if workload not in {"fixed", "sum"}:
+            raise PlotError("measured cell helicity_workload must be 'fixed' or 'sum'")
+        markers.add(workload)
+    if cell.get("warm_helicity_sum") is True:
+        markers.add("sum")
+    if cell.get("warm_fixed_helicity") is True:
+        markers.add("fixed")
+    protocol = _mapping(cell.get("protocol"))
+    helicity_summed = protocol.get("helicity_summed")
+    if helicity_summed is True:
+        markers.add("sum")
+    if helicity_summed is False or protocol.get("warm_fixed_helicity") is True:
+        markers.add("fixed")
+    if len(markers) > 1:
+        raise PlotError("measured cell helicity workload markers are contradictory")
+    return next(iter(markers), None)
+
+
+def _validate_cell_workloads(
+    report: Mapping[str, Any],
+    family: str,
+    family_cells: Mapping[str, Any],
+) -> None:
+    expected = _helicity_workload(report)
+    for mode, raw_cells in family_cells.items():
+        for raw_n, raw_cell in _mapping(raw_cells).items():
+            cell = _mapping(raw_cell)
+            if cell.get("status") != "measured":
+                continue
+            observed = _declared_cell_workload(cell)
+            context = f"{family}/{mode}/n={raw_n}"
+            if expected == "sum" and observed != "sum":
+                raise PlotError(
+                    f"{context} is not authenticated as a helicity-summed cell"
+                )
+            if expected == "fixed" and observed == "sum":
+                raise PlotError(
+                    f"{context} is summed data in a fixed-helicity campaign"
+                )
+
+
+def _metric_series_exclusions(
+    report: Mapping[str, Any], family: str, metric: Metric
+) -> Mapping[str, Any]:
+    plot = _mapping(_mapping(report.get("policy")).get("plot"))
+    metric_exclusions = _mapping(plot.get("metric_series_exclusions"))
+    family_exclusions = _mapping(
+        _mapping(metric_exclusions.get(metric.key)).get(family)
+    )
+    return {str(mode): reason for mode, reason in family_exclusions.items()}
+
+
+def _plot_policy_notes(
+    report: Mapping[str, Any],
+    family: str,
+    metric: Metric,
+    original_family_cells: Mapping[str, Any],
+    *,
+    visible_modes: Sequence[str] | None = None,
+) -> list[str]:
+    visible_mode_set = set(visible_modes) if visible_modes is not None else None
+    plot = _mapping(_mapping(report.get("policy")).get("plot"))
+    notes: list[str] = []
+    raw_notes = plot.get("notes")
+    if isinstance(raw_notes, Sequence) and not isinstance(raw_notes, str):
+        notes.extend(
+            note.strip()
+            for raw_note in raw_notes
+            if isinstance(raw_note, str) and (note := raw_note.strip())
+        )
+
+    grouped: dict[str, list[str]] = {}
+    for mode, raw_reason in _metric_series_exclusions(report, family, metric).items():
+        if visible_mode_set is not None and mode not in visible_mode_set:
+            continue
+        reason = (
+            raw_reason.strip()
+            if isinstance(raw_reason, str) and raw_reason.strip()
+            else "excluded by the report's metric protocol policy"
+        )
+        grouped.setdefault(reason, []).append(_label(original_family_cells, mode))
+    for reason, labels in grouped.items():
+        notes.append(f"{', '.join(labels)}: {metric.title.lower()} omitted ({reason}).")
+    return notes
+
+
+def _consecutive_runs(
+    values: Sequence[tuple[int, float]],
+) -> Iterable[list[tuple[int, float]]]:
+    run: list[tuple[int, float]] = []
+    for point in values:
+        if run and point[0] != run[-1][0] + 1:
+            yield run
+            run = []
+        run.append(point)
+    if run:
+        yield run
+
+
+def _line_selector_modes(lines: Sequence[str]) -> set[str]:
+    modes: set[str] = set()
+    for line in lines:
+        modes.update(PLOT_LINE_SELECTOR_MODES[line])
+    return modes
+
+
+def _filtered_modes(
+    modes: Sequence[str],
+    *,
+    include_lines: Sequence[str] | None,
+    veto_lines: Sequence[str],
+) -> tuple[str, ...]:
+    if include_lines is not None:
+        selected = _line_selector_modes(include_lines)
+        return tuple(mode for mode in modes if mode in selected)
+    vetoed = _line_selector_modes(veto_lines)
+    return tuple(mode for mode in modes if mode not in vetoed)
+
+
+def _visible_modes(
+    modes: Sequence[str],
+    *,
+    line_filters: LineFilterOptions,
+) -> tuple[tuple[str, ...], tuple[str, ...], tuple[str, ...]]:
+    main_modes = _filtered_modes(
+        modes,
+        include_lines=line_filters.main_include_lines,
+        veto_lines=line_filters.main_veto_lines,
+    )
+    ratio_modes = _filtered_modes(
+        modes,
+        include_lines=line_filters.ratio_include_lines,
+        veto_lines=line_filters.ratio_veto_lines,
+    )
+    visible = tuple(
+        mode for mode in modes if mode in set(main_modes) or mode in set(ratio_modes)
+    )
+    return main_modes, ratio_modes, visible
+
+
+def _line_filter_payload(line_filters: LineFilterOptions) -> dict[str, Any]:
+    return {
+        "main": {
+            "include_lines": (
+                None
+                if line_filters.main_include_lines is None
+                else list(line_filters.main_include_lines)
+            ),
+            "veto_lines": list(line_filters.main_veto_lines),
+        },
+        "ratio": {
+            "include_lines": (
+                None
+                if line_filters.ratio_include_lines is None
+                else list(line_filters.ratio_include_lines)
+            ),
+            "veto_lines": list(line_filters.ratio_veto_lines),
+        },
+        "precedence": "include-lines override veto-lines per panel",
+    }
+
+
+def _log_limits(values: Sequence[float]) -> tuple[float, float]:
+    low = min(values)
+    high = max(values)
+    if low == high:
+        return low / 2.0, high * 2.0
+    span = math.log10(high) - math.log10(low)
+    padding = max(0.10, span * 0.06)
+    return 10 ** (math.log10(low) - padding), 10 ** (math.log10(high) + padding)
+
+
+def _linear_limits(values: Sequence[float]) -> tuple[float, float]:
+    low = min(values)
+    high = max(values)
+    if low == high:
+        padding = max(abs(low) * 0.5, 0.5)
+    else:
+        padding = max((high - low) * 0.08, 0.05)
+    return low - padding, high + padding
+
+
+def _main_y_limits(
+    values: Sequence[float], axis_options: AxisOptions
+) -> tuple[float, float]:
+    if axis_options.main_y_range is not None:
+        return axis_options.main_y_range
+    if values:
+        return _log_limits(values)
+    return 0.5, 2.0
+
+
+def _ratio_y_limits(
+    values: Sequence[float], axis_options: AxisOptions
+) -> tuple[float, float]:
+    if axis_options.ratio_y_range is not None:
+        return axis_options.ratio_y_range
+    scale_values = [*values, 1.0]
+    if axis_options.ratio_y_scale == "linear":
+        return _linear_limits(scale_values)
+    return _log_limits(scale_values)
+
+
+def _axis_payload(
+    *,
+    scale: str,
+    limits: tuple[float, float],
+) -> dict[str, Any]:
+    return {"scale": scale, "range": [limits[0], limits[1]]}
+
+
+def _format_n(values: Sequence[int]) -> str:
+    ordered = sorted(set(values))
+    ranges: list[str] = []
+    start = previous = ordered[0]
+    for value in ordered[1:]:
+        if value == previous + 1:
+            previous = value
+            continue
+        ranges.append(str(start) if start == previous else f"{start}-{previous}")
+        start = previous = value
+    ranges.append(str(start) if start == previous else f"{start}-{previous}")
+    return ", ".join(ranges)
+
+
+def _timeout_label(report: Mapping[str, Any], policy_key: str) -> str:
+    policy = _mapping(report.get("policy"))
+    measurement = _mapping(policy.get("measurement"))
+    seconds = _positive_number(measurement.get(policy_key))
+    return "configured" if seconds is None else f"{seconds / 60:g} min"
+
+
+def _failure_detail(report: Mapping[str, Any], cell: Mapping[str, Any]) -> str:
+    short = cell.get("failure_reason_short")
+    if isinstance(short, str) and short.strip():
+        return short.strip()
+    category = cell.get("failure_category")
+    reason = cell.get("failure_reason")
+    reason_text = reason if isinstance(reason, str) else ""
+    if category == "memory-limit":
+        return "memory watchdog limit"
+    if category == "legacy-amplicol-structural-limit":
+        return "legacy AmpliCol structural limit"
+    if category in {"runtime-time-limit", "runtime-timeout"}:
+        return f"{_timeout_label(report, 'runtime_timeout_seconds')} runtime limit"
+    if category == "setup-or-runtime-time-limit":
+        return (
+            f"{_timeout_label(report, 'generation_timeout_seconds')} "
+            "setup/runtime limit"
+        )
+    if category in {"generation-time-limit", "generation-timeout", "timeout"}:
+        return (
+            f"{_timeout_label(report, 'generation_timeout_seconds')} "
+            "setup-time limit"
+        )
+    match = EXIT_STATUS.search(reason_text)
+    if match:
+        return f"generation error (exit {match.group(1)})"
+    if reason_text and len(reason_text) <= 90:
+        return reason_text.rstrip(".")
+    return str(category or "generation error")
+
+
+def _status_notes(
+    report: Mapping[str, Any],
+    family: str,
+    modes: Sequence[str],
+    *,
+    family_cells: Mapping[str, Any] | None = None,
+) -> list[str]:
+    if family_cells is None:
+        family_cells = _mapping(_mapping(report.get("cells")).get(family))
+    notes: list[str] = []
+    for mode in modes:
+        grouped: dict[tuple[str, str], list[int]] = {}
+        for raw_n, raw_cell in _mapping(family_cells.get(mode)).items():
+            multiplicity = int(raw_n)
+            cell = _mapping(raw_cell)
+            status = cell.get("status")
+            if status not in STATUS_ORDER:
+                continue
+            if status == "failed":
+                detail = _failure_detail(report, cell)
+            else:
+                reason = cell.get("failure_reason")
+                detail = reason.rstrip(".") if isinstance(reason, str) else status
+            grouped.setdefault((str(status), detail), []).append(multiplicity)
+        if not grouped:
+            continue
+        fragments = []
+        for (status, detail), values in sorted(
+            grouped.items(), key=lambda item: (STATUS_ORDER[item[0][0]], item[1])
+        ):
+            display_status = "N/A" if status == "not-applicable" else status
+            fragments.append(f"n={_format_n(values)} {display_status} ({detail})")
+        notes.append(f"{_label(family_cells, mode)}: " + "; ".join(fragments) + ".")
+    report_status = report.get("status")
+    if not isinstance(report_status, str) or not report_status.startswith("complete"):
+        status_reason = report.get("status_reason")
+        if report_status == "stopped-protocol-investigation":
+            reason = (
+                status_reason.strip()
+                if isinstance(status_reason, str) and status_reason.strip()
+                else "measurement protocol under investigation"
+            )
+            notes.append(
+                f"Campaign stopped: {reason}. Absent cells are unattempted and omitted."
+            )
+        else:
+            notes.append(
+                "Campaign is still running; absent cells are unattempted and omitted."
+            )
+    return notes
+
+
+def _wrapped_notes(notes: Sequence[str], width: int = 138) -> list[str]:
+    lines: list[str] = []
+    for note in notes:
+        wrapped = textwrap.wrap(
+            note,
+            width=width,
+            break_long_words=False,
+            break_on_hyphens=False,
+            subsequent_indent="   ",
+        )
+        if wrapped:
+            lines.extend(("• " + wrapped[0], *wrapped[1:]))
+    return lines
+
+
+def _style_axes(axis: Axes) -> None:
+    axis.grid(True, which="major", color="#D7DCE2", linewidth=0.7, alpha=0.85)
+    axis.grid(True, which="minor", axis="y", color="#E9ECF0", linewidth=0.5, alpha=0.7)
+    for spine in axis.spines.values():
+        spine.set_color("#75808C")
+        spine.set_linewidth(0.8)
+    axis.tick_params(colors="#20262D", labelsize=9)
+
+
+def _draw_run(
+    axis: Axes,
+    run: Sequence[tuple[int, float]],
+    *,
+    color: str,
+    marker: str,
+    linestyle: str,
+) -> None:
+    x_values = [point[0] for point in run]
+    y_values = [point[1] for point in run]
+    axis.plot(
+        x_values,
+        y_values,
+        color=color,
+        marker=marker,
+        linestyle=linestyle,
+        linewidth=1.7,
+        markersize=5.3,
+        markeredgewidth=0.8,
+        markeredgecolor="white" if marker not in {"+", "x"} else color,
+        zorder=3,
+    )
+
+
+def _plot_metric(
+    report: Mapping[str, Any],
+    family: str,
+    metric: Metric,
+    output_path: Path,
+    *,
+    dpi: int,
+    axis_options: AxisOptions = DEFAULT_AXIS_OPTIONS,
+    line_filters: LineFilterOptions = DEFAULT_LINE_FILTER_OPTIONS,
+) -> None:
+    original_family_cells = _mapping(_mapping(report.get("cells")).get(family))
+    family_cells, modes = _family_cells_for_metric(report, family, metric)
+    main_modes, ratio_modes, visible_modes = _visible_modes(
+        modes,
+        line_filters=line_filters,
+    )
+    multiplicities = _multiplicities(report)
+    baseline = FAMILY_BASELINES[family]
+    report_status = report.get("status")
+    allow_empty = not (
+        isinstance(report_status, str) and report_status.startswith("complete")
+    )
+    if baseline not in modes and not allow_empty:
+        raise PlotError(
+            f"{family} mode list does not contain ratio baseline {baseline!r}"
+        )
+
+    series = {mode: _series(family_cells, mode, metric) for mode in modes}
+    all_main_values = [value for values in series.values() for _, value in values]
+    main_values = [
+        value for mode in main_modes for _, value in series.get(mode, ())
+    ]
+    if not all_main_values and not allow_empty:
+        raise PlotError(f"no measured positive {metric.key} values for {family}")
+    baseline_values = dict(series.get(baseline, ()))
+    ratios: dict[str, list[tuple[int, float]]] = {}
+    for mode, values in series.items():
+        ratios[mode] = [
+            (n, value / baseline_values[n])
+            for n, value in values
+            if n in baseline_values and baseline_values[n] > 0.0
+        ]
+    all_ratio_values = [value for values in ratios.values() for _, value in values]
+    ratio_values = [
+        value for mode in ratio_modes for _, value in ratios.get(mode, ())
+    ]
+    if not all_ratio_values and not allow_empty:
+        raise PlotError(f"no ratios can be formed for {family} {metric.key}")
+
+    notes = _wrapped_notes(
+        [
+            *_status_notes(report, family, visible_modes, family_cells=family_cells),
+            *_plot_policy_notes(
+                report,
+                family,
+                metric,
+                original_family_cells,
+                visible_modes=visible_modes,
+            ),
+        ]
+    )
+    # Reserve enough space below the ratio axes for its tick labels and x-axis
+    # title before the failure-note block begins.  Keeping these as separate
+    # vertical bands avoids collisions in partial campaigns with several notes.
+    notes_height = 1.15 + 0.20 * max(1, len(notes))
+    figure_height = 8.07 + 0.20 * max(0, len(notes) - 1)
+    bottom = notes_height / figure_height
+    figure = plt.figure(figsize=(12.2, figure_height), facecolor="white")
+    grid = figure.add_gridspec(
+        2,
+        1,
+        height_ratios=(3.0, 1.35),
+        hspace=0.08,
+        left=0.105,
+        right=0.975,
+        top=0.765,
+        bottom=bottom,
+    )
+    main_axis = figure.add_subplot(grid[0])
+    ratio_axis = figure.add_subplot(grid[1], sharex=main_axis)
+
+    legend_entries: dict[str, tuple[Line2D, str]] = {}
+    for mode in modes:
+        color, marker, linestyle = MODE_STYLES.get(mode, ("#59636E", "o", "-"))
+        if mode in visible_modes and (series[mode] or ratios[mode]):
+            legend_entries[mode] = (
+                Line2D(
+                    [0],
+                    [0],
+                    color=color,
+                    marker=marker,
+                    linestyle=linestyle,
+                    linewidth=1.7,
+                    markersize=5.3,
+                    markeredgewidth=0.8,
+                ),
+                _label(family_cells, mode),
+            )
+        if mode in main_modes:
+            for run in _consecutive_runs(series[mode]):
+                _draw_run(
+                    main_axis,
+                    run,
+                    color=color,
+                    marker=marker,
+                    linestyle=linestyle,
+                )
+        if mode in ratio_modes:
+            for run in _consecutive_runs(ratios[mode]):
+                _draw_run(
+                    ratio_axis,
+                    run,
+                    color=color,
+                    marker=marker,
+                    linestyle=linestyle,
+                )
+
+    main_axis.set_yscale("log")
+    main_axis.set_ylim(*_main_y_limits(main_values, axis_options))
+    if not main_values:
+        main_axis.set_yticks([])
+        main_axis.text(
+            0.5,
+            0.5,
+            "No protocol-valid measurements are currently available\n"
+            "for this process and metric.",
+            transform=main_axis.transAxes,
+            ha="center",
+            va="center",
+            fontsize=11,
+            color="#4B5560",
+        )
+    main_axis.set_ylabel(_metric_axis_label(report, metric), fontsize=10)
+    main_axis.tick_params(axis="x", labelbottom=False)
+    ratio_axis.set_yscale(axis_options.ratio_y_scale)
+    ratio_axis.axhline(1.0, color="#59636E", linewidth=0.9, linestyle=":", zorder=1)
+    ratio_axis.set_ylim(*_ratio_y_limits(ratio_values, axis_options))
+    ratio_axis.set_ylabel(
+        f"Ratio to\n{_label(original_family_cells, baseline)}", fontsize=9
+    )
+    if not ratio_values:
+        ratio_axis.text(
+            0.5,
+            0.5,
+            "Ratios unavailable until the baseline is remeasured.",
+            transform=ratio_axis.transAxes,
+            ha="center",
+            va="center",
+            fontsize=9.5,
+            color="#4B5560",
+        )
+    ratio_axis.set_xlabel("Final-state multiplicity n", fontsize=10)
+    ratio_axis.set_xticks(multiplicities)
+    ratio_axis.set_xlim(min(multiplicities) - 0.25, max(multiplicities) + 0.25)
+    _style_axes(main_axis)
+    _style_axes(ratio_axis)
+
+    source_boundary = _source_boundary(report, metric.key)
+    if source_boundary is not None:
+        boundary_x, boundary_label = source_boundary
+        for axis in (main_axis, ratio_axis):
+            axis.axvline(
+                boundary_x,
+                color="#75808C",
+                linewidth=1.0,
+                linestyle=(0, (2.5, 2.5)),
+                zorder=2,
+            )
+        main_axis.text(
+            boundary_x,
+            0.975,
+            boundary_label,
+            transform=main_axis.get_xaxis_transform(),
+            ha="center",
+            va="top",
+            fontsize=7.8,
+            color="#59636E",
+            bbox={
+                "boxstyle": "round,pad=0.18",
+                "facecolor": "white",
+                "edgecolor": "none",
+                "alpha": 0.88,
+            },
+            zorder=4,
+        )
+
+    figure.suptitle(
+        f"FullColor {_metric_title(report, metric)}: {FAMILY_TITLES[family]}",
+        x=0.54,
+        y=0.975,
+        fontsize=15,
+        fontweight="semibold",
+    )
+    protocol_lines = _protocol_summary_lines(
+        report,
+        ratio_y_scale=axis_options.ratio_y_scale,
+    )
+    figure.text(
+        0.54,
+        0.945,
+        "\n".join(protocol_lines),
+        ha="center",
+        va="top",
+        fontsize=8.7,
+        color="#59636E",
+        linespacing=1.15,
+    )
+    if legend_entries:
+        preferred_modes = LEGEND_MODE_ORDER[family]
+        legend_modes = [mode for mode in preferred_modes if mode in legend_entries]
+        legend_modes.extend(
+            mode
+            for mode in modes
+            if mode in legend_entries and mode not in preferred_modes
+        )
+        handles = [legend_entries[mode][0] for mode in legend_modes]
+        labels = [legend_entries[mode][1] for mode in legend_modes]
+        figure.legend(
+            handles,
+            labels,
+            loc="upper center",
+            bbox_to_anchor=(0.54, 0.91 - 0.011 * len(protocol_lines)),
+            ncol=4 if family == "gg" or len(labels) > 6 else 3,
+            frameon=False,
+            fontsize=8.8,
+            handlelength=2.5,
+            columnspacing=1.35,
+        )
+
+    if notes:
+        figure.text(
+            0.105,
+            (notes_height - 0.68) / figure_height,
+            "Failures and omitted points",
+            ha="left",
+            va="top",
+            fontsize=9.2,
+            fontweight="semibold",
+            color="#20262D",
+        )
+        line_step = 0.20 / figure_height
+        y = (notes_height - 0.96) / figure_height
+        for line in notes:
+            figure.text(
+                0.105,
+                y,
+                line,
+                ha="left",
+                va="top",
+                fontsize=8.2,
+                color="#4B5560",
+            )
+            y -= line_step
+
+    temporary_path = output_path.with_suffix(output_path.suffix + ".tmp")
+    figure.savefig(
+        temporary_path,
+        format="png",
+        dpi=dpi,
+        facecolor="white",
+        metadata={"Software": "pyAmpliCol fft_scaling_study_plots.py"},
+    )
+    plt.close(figure)
+    temporary_path.replace(output_path)
+
+
+def _point_payload(point: tuple[int, float]) -> dict[str, float | int]:
+    return {"n": point[0], "value": point[1]}
+
+
+def _source_boundary_payload(
+    report: Mapping[str, Any], metric: Metric
+) -> dict[str, float | str] | None:
+    boundary = _source_boundary(report, metric.key)
+    if boundary is None:
+        return None
+    x_position, label = boundary
+    return {"x": x_position, "label": label}
+
+
+def _metric_data_payload(
+    report: Mapping[str, Any],
+    family: str,
+    metric: Metric,
+    *,
+    axis_options: AxisOptions = DEFAULT_AXIS_OPTIONS,
+    line_filters: LineFilterOptions = DEFAULT_LINE_FILTER_OPTIONS,
+) -> dict[str, Any]:
+    family_cells, modes = _family_cells_for_metric(report, family, metric)
+    main_modes, ratio_modes, visible_modes = _visible_modes(
+        modes,
+        line_filters=line_filters,
+    )
+    series = {mode: _series(family_cells, mode, metric) for mode in modes}
+    main_values = [
+        value for mode in main_modes for _, value in series.get(mode, ())
+    ]
+    baseline = FAMILY_BASELINES[family]
+    baseline_values = dict(series.get(baseline, ()))
+    mode_payloads: dict[str, Any] = {}
+    ratio_values: list[float] = []
+    for mode in visible_modes:
+        values = series[mode]
+        ratios = [
+            (n, value / baseline_values[n])
+            for n, value in values
+            if n in baseline_values and baseline_values[n] > 0.0
+        ]
+        if mode in ratio_modes:
+            ratio_values.extend(value for _, value in ratios)
+        mode_payloads[mode] = {
+            "label": _label(family_cells, mode),
+            "visible_in_main": mode in main_modes,
+            "visible_in_ratio": mode in ratio_modes,
+            "series": (
+                [_point_payload(point) for point in values]
+                if mode in main_modes
+                else []
+            ),
+            "ratio_to_baseline": (
+                [_point_payload(point) for point in ratios]
+                if mode in ratio_modes
+                else []
+            ),
+        }
+    return {
+        "source_metric_key": metric.key,
+        "slug": metric.slug,
+        "title": _metric_title(report, metric),
+        "axis_label": _metric_axis_label(report, metric),
+        "scale_from_report": metric.scale,
+        "source_boundary": _source_boundary_payload(report, metric),
+        "baseline_mode": baseline,
+        "main_axis": _axis_payload(
+            scale="log",
+            limits=_main_y_limits(main_values, axis_options),
+        ),
+        "ratio_axis": _axis_payload(
+            scale=axis_options.ratio_y_scale,
+            limits=_ratio_y_limits(ratio_values, axis_options),
+        ),
+        "modes": mode_payloads,
+    }
+
+
+def _plot_data_payload(
+    report_sha256: str,
+    report: Mapping[str, Any],
+    *,
+    axis_options: AxisOptions = DEFAULT_AXIS_OPTIONS,
+    line_filters: LineFilterOptions = DEFAULT_LINE_FILTER_OPTIONS,
+    external_sources: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    payload = {
+        "kind": "pyamplicol-fft-scaling-plot-data",
+        "schema_version": 1,
+        "report_sha256": report_sha256,
+        "helicity_workload": _helicity_workload(report),
+        "line_filters": _line_filter_payload(line_filters),
+        "families": {
+            family: {
+                "title": FAMILY_TITLES[family],
+                "metrics": {
+                    metric.slug: _metric_data_payload(
+                        report,
+                        family,
+                        metric,
+                        axis_options=axis_options,
+                        line_filters=line_filters,
+                    )
+                    for metric in METRICS
+                },
+            }
+            for family in FAMILIES
+        },
+    }
+    if external_sources:
+        payload["external_sources"] = dict(external_sources)
+    return payload
+
+
+def _write_plot_data(
+    report_sha256: str,
+    report: Mapping[str, Any],
+    output_directory: Path,
+    *,
+    axis_options: AxisOptions = DEFAULT_AXIS_OPTIONS,
+    line_filters: LineFilterOptions = DEFAULT_LINE_FILTER_OPTIONS,
+    external_sources: Mapping[str, Any] | None = None,
+) -> Path:
+    data_path = output_directory / PLOT_DATA_NAME
+    temporary_path = data_path.with_suffix(data_path.suffix + ".tmp")
+    temporary_path.write_text(
+        json.dumps(
+            _plot_data_payload(
+                report_sha256,
+                report,
+                axis_options=axis_options,
+                line_filters=line_filters,
+                external_sources=external_sources,
+            ),
+            indent=2,
+            sort_keys=True,
+            allow_nan=False,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    temporary_path.replace(data_path)
+    return data_path
+
+
+def _configure_matplotlib() -> None:
+    plt.rcParams.update(
+        {
+            "font.family": "DejaVu Sans",
+            "axes.facecolor": "white",
+            "axes.labelcolor": "#20262D",
+            "figure.facecolor": "white",
+            "savefig.facecolor": "white",
+            "text.color": "#20262D",
+        }
+    )
+
+
+def _render(
+    report: Mapping[str, Any],
+    output_directory: Path,
+    *,
+    dpi: int,
+    axis_options: AxisOptions = DEFAULT_AXIS_OPTIONS,
+    line_filters: LineFilterOptions = DEFAULT_LINE_FILTER_OPTIONS,
+) -> None:
+    if dpi < 72 or dpi > 600:
+        raise PlotError("--dpi must be between 72 and 600")
+    output_directory.mkdir(parents=True, exist_ok=True)
+    _configure_matplotlib()
+    for family in FAMILIES:
+        for metric in METRICS:
+            output_path = output_directory / f"fullcolor-{family}-{metric.slug}.png"
+            _plot_metric(
+                report,
+                family,
+                metric,
+                output_path,
+                dpi=dpi,
+                axis_options=axis_options,
+                line_filters=line_filters,
+            )
+            print(output_path)
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for chunk in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _write_plot_manifest(
+    report_sha256: str,
+    report: Mapping[str, Any],
+    output_directory: Path,
+    *,
+    external_sources: Mapping[str, Any] | None = None,
+) -> Path:
+    """Bind a rendered plot set to its exact source report and workload."""
+
+    plot_hashes: dict[str, str] = {}
+    for filename in PLOT_FILENAMES:
+        plot_path = output_directory / filename
+        if not plot_path.is_file():
+            raise PlotError(f"rendered plot is missing: {plot_path}")
+        plot_hashes[filename] = _sha256(plot_path)
+    manifest = {
+        "kind": "pyamplicol-fft-scaling-plots",
+        "schema_version": 1,
+        "report_sha256": report_sha256,
+        "helicity_workload": _helicity_workload(report),
+        "plots": plot_hashes,
+    }
+    if external_sources:
+        manifest["external_sources"] = dict(external_sources)
+    manifest_path = output_directory / PLOT_MANIFEST_NAME
+    temporary_path = manifest_path.with_suffix(manifest_path.suffix + ".tmp")
+    temporary_path.write_text(
+        json.dumps(manifest, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    temporary_path.replace(manifest_path)
+    print(manifest_path)
+    return manifest_path
+
+
+def main() -> int:
+    arguments = _parser().parse_args()
+    try:
+        axis_options = _axis_options_from_arguments(arguments)
+        line_filters = _line_filter_options_from_arguments(arguments)
+        report, report_sha256 = _load_report_snapshot(arguments.report)
+        external_sources: dict[str, Any] = {}
+        if arguments.recola_results is not None:
+            external_sources["recola_results"] = _attach_recola_results(
+                report,
+                arguments.recola_results,
+            )
+        _render(
+            report,
+            arguments.output_directory,
+            dpi=arguments.dpi,
+            axis_options=axis_options,
+            line_filters=line_filters,
+        )
+        _write_plot_manifest(
+            report_sha256,
+            report,
+            arguments.output_directory,
+            external_sources=external_sources,
+        )
+        _write_plot_data(
+            report_sha256,
+            report,
+            arguments.output_directory,
+            axis_options=axis_options,
+            line_filters=line_filters,
+            external_sources=external_sources,
+        )
+    except PlotError as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/final_source_numerical_truth.py b/pyamplicol/tools/developer/final_source_numerical_truth.py
new file mode 100644
index 0000000000..e517fd2933
--- /dev/null
+++ b/pyamplicol/tools/developer/final_source_numerical_truth.py
@@ -0,0 +1,1315 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Produce a source-bound, independent numerical truth witness for one cell.
+
+The producer is deliberately not a benchmark.  It evaluates one retained
+validation point and records no wall-clock measurements.  The candidate's
+native lane is checked against two precision>=50 executions:
+
+* the candidate artifact's retained exact evaluator, and
+* a distinct reference artifact carrying an authenticated pre-optimization or
+  independent-oracle semantics contract.
+
+The second artifact is mandatory.  A candidate exact evaluator is useful, but
+is not accepted as its own independent reference.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import re
+import tempfile
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation, localcontext
+from pathlib import Path
+from typing import Any, Protocol
+
+from pyamplicol.generation.structural_source_proof import (
+    ROLE as STRUCTURAL_SOURCE_PROOF_ROLE,
+)
+from pyamplicol.generation.structural_source_proof import (
+    validate_generation_structural_proof,
+)
+from tools.performance_report.models import Accuracy, ExecutionMode, Workload
+
+SCHEMA = "pyamplicol-final-source-numerical-truth-v1"
+REFERENCE_SCHEMA = "pyamplicol-independent-reference-semantics-v1"
+REFERENCE_ROLES = {
+    "independent-oracle",
+    "pre-optimization-reference",
+}
+MINIMUM_PRECISION = 50
+DEFAULT_PRECISION = 80
+DEFAULT_EXACT_AGREEMENT_DIGITS = 50
+DEFAULT_NATIVE_RELATIVE_TOLERANCE = Decimal("1e-10")
+DEFAULT_NATIVE_ABSOLUTE_TOLERANCE = Decimal("1e-14")
+_REVISION = re.compile(r"[0-9a-f]{40}")
+_SHA256 = re.compile(r"[0-9a-f]{64}")
+
+
+class TruthProducerError(RuntimeError):
+    """Independent final-source numerical truth could not be established."""
+
+
+class _Resolved(Protocol):
+    values: Sequence[Sequence[Sequence[complex | Decimal]]]
+    helicity_ids: Sequence[str]
+    color_ids: Sequence[str]
+    color_accuracy: str
+
+
+class _Runtime(Protocol):
+    artifact_id: str
+    execution_mode: str
+
+    def evaluate_resolved(
+        self,
+        momenta: object,
+        *,
+        helicities: Sequence[str] | None,
+        color_flows: Sequence[str] | None,
+        precision: int,
+    ) -> _Resolved: ...
+
+
+@dataclass(frozen=True)
+class _Artifact:
+    root: Path
+    manifest: Mapping[str, Any]
+    artifact_id: str
+    process_id: str
+    source_revision: str
+    color_accuracy: str
+    execution_path: str
+    execution_sha256: str
+    validation_path: str
+    validation_sha256: str
+    structural_proof_path: str | None
+    structural_proof_sha256: str | None
+
+
+def canonical_sha256(domain: str, value: object) -> str:
+    encoded = json.dumps(
+        {"domain": domain, "value": value},
+        ensure_ascii=True,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def comparison_sha256(payload: Mapping[str, Any]) -> str:
+    value = dict(payload)
+    value.pop("comparison_sha256", None)
+    return canonical_sha256("final-source-numerical-truth-v1", value)
+
+
+def _read_json(path: Path, label: str) -> Mapping[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise TruthProducerError(f"cannot read {label} {path}: {error}") from error
+    if not isinstance(value, Mapping):
+        raise TruthProducerError(f"{label} {path} must contain a JSON object")
+    return value
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _required_text(value: object, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise TruthProducerError(f"{label} must be a non-empty string")
+    return value
+
+
+def _required_sha(value: object, label: str) -> str:
+    text = _required_text(value, label)
+    if _SHA256.fullmatch(text) is None:
+        raise TruthProducerError(f"{label} must be a lowercase SHA-256")
+    return text
+
+
+def _required_revision(value: object, label: str) -> str:
+    text = _required_text(value, label)
+    if _REVISION.fullmatch(text) is None:
+        raise TruthProducerError(f"{label} must be a full lowercase Git revision")
+    return text
+
+
+def _required_int(value: object, label: str, *, minimum: int = 0) -> int:
+    if not isinstance(value, int) or isinstance(value, bool) or value < minimum:
+        raise TruthProducerError(f"{label} must be an integer >= {minimum}")
+    return value
+
+
+def _confined(root: Path, relative: str, label: str) -> Path:
+    if not relative:
+        raise TruthProducerError(f"{label} path is empty")
+    resolved_root = root.resolve()
+    path = (resolved_root / relative).resolve()
+    try:
+        path.relative_to(resolved_root)
+    except ValueError as error:
+        raise TruthProducerError(f"{label} escapes its artifact: {relative}") from error
+    return path
+
+
+def _payload_record(
+    manifest: Mapping[str, Any],
+    *,
+    path: str | None = None,
+    role: str | None = None,
+    process_id: str | None = None,
+) -> Mapping[str, Any]:
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise TruthProducerError("artifact manifest has no payload inventory")
+    matches = [
+        record
+        for record in payloads
+        if isinstance(record, Mapping)
+        and (path is None or record.get("path") == path)
+        and (role is None or record.get("role") == role)
+        and (process_id is None or record.get("process_id") == process_id)
+    ]
+    if len(matches) != 1:
+        description = path or f"role={role!r}, process={process_id!r}"
+        raise TruthProducerError(
+            f"artifact must declare exactly one payload for {description}"
+        )
+    return matches[0]
+
+
+def _artifact(
+    root: Path,
+    *,
+    source_revision: str,
+    process_id: str | None,
+    label: str,
+    require_structural_proof: bool,
+) -> _Artifact:
+    resolved = root.resolve()
+    manifest = _read_json(resolved / "artifact.json", f"{label} manifest")
+    artifact_id = _required_sha(manifest.get("artifact_id"), f"{label} artifact_id")
+    producer = manifest.get("producer")
+    if not isinstance(producer, Mapping):
+        raise TruthProducerError(f"{label} producer identity is absent")
+    actual_revision = _required_revision(
+        producer.get("git_revision"),
+        f"{label} producer.git_revision",
+    )
+    if actual_revision != source_revision:
+        raise TruthProducerError(
+            f"{label} source revision {actual_revision} does not equal "
+            f"{source_revision}"
+        )
+    selected = (
+        process_id
+        if process_id is not None
+        else _required_text(
+            manifest.get("default_process_id"),
+            f"{label} default_process_id",
+        )
+    )
+    processes = manifest.get("processes")
+    if not isinstance(processes, list):
+        raise TruthProducerError(f"{label} manifest has no process inventory")
+    process = next(
+        (
+            record
+            for record in processes
+            if isinstance(record, Mapping) and record.get("id") == selected
+        ),
+        None,
+    )
+    if process is None:
+        raise TruthProducerError(f"{label} process {selected!r} is absent")
+    accuracy = _required_text(
+        process.get("color_accuracy"),
+        f"{label} process color_accuracy",
+    )
+    execution = _payload_record(
+        manifest,
+        role="evaluator-manifest",
+        process_id=selected,
+    )
+    execution_path = _required_text(
+        execution.get("path"),
+        f"{label} execution path",
+    )
+    execution_sha = _required_sha(
+        execution.get("sha256"),
+        f"{label} execution digest",
+    )
+    validation = _payload_record(
+        manifest,
+        role="validation-momenta",
+        process_id=selected,
+    )
+    validation_path = _required_text(
+        validation.get("path"),
+        f"{label} validation path",
+    )
+    validation_sha = _required_sha(
+        validation.get("sha256"),
+        f"{label} validation digest",
+    )
+    for path, expected, name in (
+        (execution_path, execution_sha, "execution"),
+        (validation_path, validation_sha, "validation momenta"),
+    ):
+        concrete = _confined(resolved, path, f"{label} {name}")
+        if not concrete.is_file() or _sha256_file(concrete) != expected:
+            raise TruthProducerError(f"{label} {name} payload is absent or changed")
+    structural_path: str | None = None
+    structural_sha: str | None = None
+    if require_structural_proof:
+        structural = _payload_record(
+            manifest,
+            role=STRUCTURAL_SOURCE_PROOF_ROLE,
+            process_id=selected,
+        )
+        structural_path = _required_text(
+            structural.get("path"),
+            f"{label} structural proof path",
+        )
+        structural_sha = _required_sha(
+            structural.get("sha256"),
+            f"{label} structural proof digest",
+        )
+        concrete = _confined(
+            resolved,
+            structural_path,
+            f"{label} structural proof",
+        )
+        if not concrete.is_file() or _sha256_file(concrete) != structural_sha:
+            raise TruthProducerError(
+                f"{label} structural proof payload is absent or changed"
+            )
+        native_inputs = _required_sha(
+            producer.get("native_build_inputs_sha256"),
+            f"{label} producer.native_build_inputs_sha256",
+        )
+        execution_payload = _read_json(
+            _confined(resolved, execution_path, f"{label} execution"),
+            f"{label} execution",
+        )
+        try:
+            validate_generation_structural_proof(
+                _read_json(concrete, f"{label} structural proof"),
+                artifact_root=resolved,
+                expected_process_id=selected,
+                expected_source_revision=actual_revision,
+                expected_native_build_inputs_sha256=native_inputs,
+                expected_execution_path=execution_path,
+                expected_execution_sha256=execution_sha,
+                execution=execution_payload,
+            )
+        except ValueError as error:
+            raise TruthProducerError(
+                f"{label} generation structural proof does not recompute"
+            ) from error
+    return _Artifact(
+        root=resolved,
+        manifest=manifest,
+        artifact_id=artifact_id,
+        process_id=selected,
+        source_revision=actual_revision,
+        color_accuracy=accuracy,
+        execution_path=execution_path,
+        execution_sha256=execution_sha,
+        validation_path=validation_path,
+        validation_sha256=validation_sha,
+        structural_proof_path=structural_path,
+        structural_proof_sha256=structural_sha,
+    )
+
+
+def _canonical_decimal(value: object, label: str) -> str:
+    if isinstance(value, bool):
+        raise TruthProducerError(f"{label} cannot be boolean")
+    try:
+        if isinstance(value, Decimal):
+            decimal = value
+        elif isinstance(value, float):
+            if not math.isfinite(value):
+                raise TruthProducerError(f"{label} is not finite")
+            decimal = Decimal(format(value, ".17g"))
+        elif isinstance(value, (int, str)):
+            decimal = Decimal(value)
+        else:
+            raise TruthProducerError(f"{label} is not a decimal scalar")
+    except InvalidOperation as error:
+        raise TruthProducerError(f"{label} is not a valid decimal") from error
+    if not decimal.is_finite():
+        raise TruthProducerError(f"{label} is not finite")
+    if decimal == 0:
+        return "0"
+    rendered = format(decimal, "f")
+    if "." in rendered:
+        rendered = rendered.rstrip("0").rstrip(".")
+    return rendered
+
+
+def _validation_payload(artifact: _Artifact, label: str) -> dict[str, Any]:
+    raw = _read_json(
+        _confined(artifact.root, artifact.validation_path, f"{label} validation"),
+        f"{label} validation",
+    )
+    points = raw.get("points")
+    if (
+        raw.get("available") is not True
+        or not isinstance(points, list)
+        or len(points) != 1
+    ):
+        raise TruthProducerError(
+            f"{label} must retain exactly one available validation point"
+        )
+    particles = points[0]
+    if not isinstance(particles, list) or not particles:
+        raise TruthProducerError(f"{label} validation point is empty")
+    canonical_particles: list[dict[str, Any]] = []
+    for particle_index, particle in enumerate(particles):
+        if not isinstance(particle, Mapping):
+            raise TruthProducerError(
+                f"{label} validation particle {particle_index} is malformed"
+            )
+        pdg = particle.get("pdg")
+        momentum = particle.get("momentum")
+        if (
+            not isinstance(pdg, int)
+            or isinstance(pdg, bool)
+            or not isinstance(momentum, list)
+            or len(momentum) != 4
+        ):
+            raise TruthProducerError(
+                f"{label} validation particle {particle_index} is malformed"
+            )
+        canonical_particles.append(
+            {
+                "pdg": pdg,
+                "momentum": [
+                    _canonical_decimal(
+                        component,
+                        f"{label} validation particle {particle_index} component",
+                    )
+                    for component in momentum
+                ],
+            }
+        )
+    return {"points": [canonical_particles]}
+
+
+def _momenta(payload: Mapping[str, Any]) -> tuple[tuple[tuple[str, ...], ...], ...]:
+    points = payload["points"]
+    assert isinstance(points, list)
+    return tuple(
+        tuple(tuple(str(value) for value in particle["momentum"]) for particle in point)
+        for point in points
+    )
+
+
+def _reference_contract(
+    reference: _Artifact,
+    contract_relative_path: str,
+) -> dict[str, Any]:
+    record = _payload_record(reference.manifest, path=contract_relative_path)
+    if record.get("role") != "independent-reference-semantics":
+        raise TruthProducerError(
+            "reference contract must use role 'independent-reference-semantics'"
+        )
+    expected_contract_sha = _required_sha(
+        record.get("sha256"),
+        "reference contract payload digest",
+    )
+    contract_path = _confined(
+        reference.root,
+        contract_relative_path,
+        "reference contract",
+    )
+    if (
+        not contract_path.is_file()
+        or _sha256_file(contract_path) != expected_contract_sha
+    ):
+        raise TruthProducerError("reference contract is absent or changed")
+    raw = _read_json(contract_path, "reference contract")
+    semantics = raw.get("semantics")
+    if (
+        raw.get("schema") != REFERENCE_SCHEMA
+        or raw.get("status") != "materialized"
+        or raw.get("source_revision") != reference.source_revision
+        or raw.get("artifact_id") != reference.artifact_id
+        or raw.get("process_id") != reference.process_id
+        or semantics not in REFERENCE_ROLES
+    ):
+        raise TruthProducerError(
+            "reference contract is stale or does not certify independent semantics"
+        )
+    payloads = raw.get("semantic_payloads")
+    if not isinstance(payloads, list) or not payloads:
+        raise TruthProducerError("reference contract has no semantic payloads")
+    normalized_payloads: list[dict[str, str]] = []
+    content_ids: set[str] = set()
+    for index, item in enumerate(payloads):
+        if not isinstance(item, Mapping):
+            raise TruthProducerError(f"reference semantic payload {index} is malformed")
+        relative = _required_text(
+            item.get("path"),
+            f"reference semantic payload {index} path",
+        )
+        expected = _required_sha(
+            item.get("sha256"),
+            f"reference semantic payload {index} digest",
+        )
+        declared = _payload_record(reference.manifest, path=relative)
+        if declared.get("sha256") != expected:
+            raise TruthProducerError(
+                f"reference semantic payload {relative} disagrees with manifest"
+            )
+        concrete = _confined(reference.root, relative, "reference semantic payload")
+        if not concrete.is_file() or _sha256_file(concrete) != expected:
+            raise TruthProducerError(
+                f"reference semantic payload {relative} is absent or changed"
+            )
+        if expected in content_ids:
+            raise TruthProducerError(
+                "reference semantic payload inventory repeats a content identity"
+            )
+        content_ids.add(expected)
+        normalized_payloads.append({"path": relative, "sha256": expected})
+    normalized = {
+        "schema": REFERENCE_SCHEMA,
+        "status": "materialized",
+        "semantics": semantics,
+        "source_revision": reference.source_revision,
+        "artifact_id": reference.artifact_id,
+        "process_id": reference.process_id,
+        "contract_sha256": expected_contract_sha,
+        "semantic_payloads": normalized_payloads,
+    }
+    normalized["semantic_identity_sha256"] = canonical_sha256(
+        "independent-reference-semantics-v1",
+        normalized,
+    )
+    return normalized
+
+
+def _selector_payload(
+    *,
+    workload: Workload,
+    helicity_ids: Sequence[str],
+    color_ids: Sequence[str],
+) -> dict[str, Any]:
+    helicities = list(helicity_ids)
+    colors = list(color_ids)
+    if (
+        len(set(helicities)) != len(helicities)
+        or len(set(colors)) != len(colors)
+        or any(not value for value in (*helicities, *colors))
+    ):
+        raise TruthProducerError("selector IDs must be non-empty and unique")
+    if workload is Workload.SELECTED_FLOW:
+        if len(helicities) != 1 or len(colors) != 1:
+            raise TruthProducerError(
+                "selected-flow truth requires exactly one helicity and color selector"
+            )
+    elif helicities or colors:
+        raise TruthProducerError(
+            f"{workload.value} truth must not apply resolved-axis selectors"
+        )
+    payload: dict[str, Any] = {
+        "workload": workload.value,
+        "helicity_ids": helicities,
+        "color_ids": colors,
+    }
+    payload["selector_sha256"] = canonical_sha256(
+        "final-source-selectors-v1",
+        payload,
+    )
+    return payload
+
+
+def _axes(resolved: _Resolved) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "color_accuracy": str(resolved.color_accuracy),
+        "helicity_ids": [str(value) for value in resolved.helicity_ids],
+        "color_ids": [str(value) for value in resolved.color_ids],
+    }
+    payload["resolved_axes_sha256"] = canonical_sha256(
+        "final-source-resolved-axes-v1",
+        payload,
+    )
+    return payload
+
+
+def _exact_values(resolved: _Resolved, label: str) -> list[list[list[str]]]:
+    output: list[list[list[str]]] = []
+    for point_index, point in enumerate(resolved.values):
+        rows: list[list[str]] = []
+        for helicity_index, row in enumerate(point):
+            values: list[str] = []
+            for color_index, value in enumerate(row):
+                if not isinstance(value, Decimal):
+                    raise TruthProducerError(
+                        f"{label}[{point_index},{helicity_index},{color_index}] "
+                        "is not independently materialized Decimal output"
+                    )
+                values.append(
+                    _canonical_decimal(
+                        value,
+                        f"{label}[{point_index},{helicity_index},{color_index}]",
+                    )
+                )
+            rows.append(values)
+        output.append(rows)
+    return output
+
+
+def _native_values(
+    resolved: _Resolved,
+    label: str,
+) -> list[list[list[list[str]]]]:
+    output: list[list[list[list[str]]]] = []
+    for point_index, point in enumerate(resolved.values):
+        rows: list[list[list[str]]] = []
+        for helicity_index, row in enumerate(point):
+            values: list[list[str]] = []
+            for color_index, value in enumerate(row):
+                complex_value = complex(value)
+                if not math.isfinite(complex_value.real) or not math.isfinite(
+                    complex_value.imag
+                ):
+                    raise TruthProducerError(
+                        f"{label}[{point_index},{helicity_index},{color_index}] "
+                        "is not finite"
+                    )
+                values.append(
+                    [
+                        _canonical_decimal(complex_value.real, f"{label} real"),
+                        _canonical_decimal(complex_value.imag, f"{label} imaginary"),
+                    ]
+                )
+            rows.append(values)
+        output.append(rows)
+    return output
+
+
+def _flatten_exact(values: object, label: str) -> list[Decimal]:
+    if not isinstance(values, list) or not values:
+        raise TruthProducerError(f"{label} must contain at least one point")
+    flattened: list[Decimal] = []
+    try:
+        for point in values:
+            if not isinstance(point, list) or not point:
+                raise TruthProducerError(f"{label} has an empty helicity axis")
+            for row in point:
+                if not isinstance(row, list) or not row:
+                    raise TruthProducerError(f"{label} has an empty color axis")
+                for value in row:
+                    if not isinstance(value, str):
+                        raise TruthProducerError(
+                            f"{label} exact values must be decimal strings"
+                        )
+                    decimal = Decimal(value)
+                    if not decimal.is_finite():
+                        raise TruthProducerError(f"{label} contains non-finite values")
+                    flattened.append(decimal)
+    except InvalidOperation as error:
+        raise TruthProducerError(f"{label} contains invalid decimals") from error
+    return flattened
+
+
+def _flatten_native(values: object, label: str) -> list[tuple[Decimal, Decimal]]:
+    if not isinstance(values, list) or not values:
+        raise TruthProducerError(f"{label} must contain at least one point")
+    flattened: list[tuple[Decimal, Decimal]] = []
+    try:
+        for point in values:
+            if not isinstance(point, list) or not point:
+                raise TruthProducerError(f"{label} has an empty helicity axis")
+            for row in point:
+                if not isinstance(row, list) or not row:
+                    raise TruthProducerError(f"{label} has an empty color axis")
+                for value in row:
+                    if (
+                        not isinstance(value, list)
+                        or len(value) != 2
+                        or not all(isinstance(item, str) for item in value)
+                    ):
+                        raise TruthProducerError(
+                            f"{label} native values must be [real, imaginary] strings"
+                        )
+                    pair = (Decimal(value[0]), Decimal(value[1]))
+                    if not all(item.is_finite() for item in pair):
+                        raise TruthProducerError(f"{label} contains non-finite values")
+                    flattened.append(pair)
+    except InvalidOperation as error:
+        raise TruthProducerError(f"{label} contains invalid decimals") from error
+    return flattened
+
+
+def _agreement(
+    candidate_exact: object,
+    candidate_native: object,
+    reference_exact: object,
+    *,
+    precision: int,
+    exact_agreement_digits: int,
+    native_relative_tolerance: Decimal,
+    native_absolute_tolerance: Decimal,
+) -> dict[str, Any]:
+    candidate = _flatten_exact(candidate_exact, "candidate_exact.values")
+    native = _flatten_native(candidate_native, "candidate_native.values")
+    reference = _flatten_exact(reference_exact, "reference_exact.values")
+    if len(candidate) != len(reference) or len(native) != len(reference):
+        raise TruthProducerError("candidate/reference resolved value shapes differ")
+    if exact_agreement_digits > precision - 5:
+        raise TruthProducerError(
+            "exact agreement digits must leave at least five guard digits"
+        )
+    exact_tolerance = Decimal(1).scaleb(-exact_agreement_digits)
+    exact_max_absolute = Decimal(0)
+    exact_max_relative = Decimal(0)
+    native_max_absolute = Decimal(0)
+    native_max_relative = Decimal(0)
+    native_max_imaginary = Decimal(0)
+    exact_passes = True
+    native_passes = True
+    with localcontext() as context:
+        context.prec = max(precision + 20, 100)
+        for exact_value, (native_real, native_imaginary), reference_value in zip(
+            candidate,
+            native,
+            reference,
+            strict=True,
+        ):
+            exact_absolute = abs(exact_value - reference_value)
+            exact_relative = exact_absolute / max(
+                abs(exact_value),
+                abs(reference_value),
+                Decimal(1).scaleb(-precision),
+            )
+            native_absolute = abs(native_real - reference_value)
+            native_relative = native_absolute / max(
+                abs(native_real),
+                abs(reference_value),
+                Decimal("1e-300"),
+            )
+            exact_max_absolute = max(exact_max_absolute, exact_absolute)
+            exact_max_relative = max(exact_max_relative, exact_relative)
+            native_max_absolute = max(native_max_absolute, native_absolute)
+            native_max_relative = max(native_max_relative, native_relative)
+            native_max_imaginary = max(
+                native_max_imaginary,
+                abs(native_imaginary),
+            )
+            exact_passes = exact_passes and (
+                exact_absolute <= exact_tolerance or exact_relative <= exact_tolerance
+            )
+            native_passes = (
+                native_passes
+                and (
+                    native_absolute <= native_absolute_tolerance
+                    or native_relative <= native_relative_tolerance
+                )
+                and abs(native_imaginary) <= native_absolute_tolerance
+            )
+    return {
+        "component_count": len(reference),
+        "exact_agreement_decimal_digits": exact_agreement_digits,
+        "exact_absolute_tolerance": _canonical_decimal(
+            exact_tolerance,
+            "exact tolerance",
+        ),
+        "native_relative_tolerance": _canonical_decimal(
+            native_relative_tolerance,
+            "native relative tolerance",
+        ),
+        "native_absolute_tolerance": _canonical_decimal(
+            native_absolute_tolerance,
+            "native absolute tolerance",
+        ),
+        "candidate_exact_vs_reference": {
+            "maximum_absolute_difference": _canonical_decimal(
+                exact_max_absolute,
+                "exact maximum absolute difference",
+            ),
+            "maximum_relative_difference": _canonical_decimal(
+                exact_max_relative,
+                "exact maximum relative difference",
+            ),
+            "passes": exact_passes,
+        },
+        "candidate_native_vs_reference": {
+            "maximum_absolute_difference": _canonical_decimal(
+                native_max_absolute,
+                "native maximum absolute difference",
+            ),
+            "maximum_relative_difference": _canonical_decimal(
+                native_max_relative,
+                "native maximum relative difference",
+            ),
+            "maximum_imaginary_magnitude": _canonical_decimal(
+                native_max_imaginary,
+                "native maximum imaginary magnitude",
+            ),
+            "passes": native_passes,
+        },
+        "passes": exact_passes and native_passes,
+    }
+
+
+def _value_record(
+    *,
+    precision: int,
+    executor: str,
+    values: object,
+    domain: str,
+) -> dict[str, Any]:
+    record: dict[str, Any] = {
+        "precision_decimal_digits": precision,
+        "executor": executor,
+        "values": values,
+    }
+    record["values_sha256"] = canonical_sha256(domain, values)
+    return record
+
+
+def validate_witness_payload(
+    raw: Mapping[str, Any],
+    *,
+    expected_source_revision: str | None = None,
+    expected_cell_id: str | None = None,
+    expected_mode: str | None = None,
+    expected_accuracy: str | None = None,
+    expected_workload: str | None = None,
+    expected_candidate_artifact_id: str | None = None,
+    expected_structural_proof_sha256: str | None = None,
+) -> dict[str, Any]:
+    """Recompute every numerical digest and agreement in a serialized witness."""
+
+    payload = dict(raw)
+    if payload.get("schema") != SCHEMA or payload.get("status") != "ok":
+        raise TruthProducerError("numerical truth witness schema/status is invalid")
+    revision = _required_revision(payload.get("source_revision"), "source_revision")
+    if expected_source_revision is not None and revision != expected_source_revision:
+        raise TruthProducerError("numerical truth source revision mismatch")
+    for name, expected in (
+        ("cell_id", expected_cell_id),
+        ("mode", expected_mode),
+        ("accuracy", expected_accuracy),
+        ("workload", expected_workload),
+    ):
+        actual = _required_text(payload.get(name), name)
+        if expected is not None and actual != expected:
+            raise TruthProducerError(f"numerical truth {name} mismatch")
+    precision = _required_int(
+        payload.get("precision_decimal_digits"),
+        "precision_decimal_digits",
+        minimum=MINIMUM_PRECISION,
+    )
+    candidate_artifact = payload.get("candidate_artifact")
+    reference_artifact = payload.get("reference_artifact")
+    if not isinstance(candidate_artifact, Mapping) or not isinstance(
+        reference_artifact,
+        Mapping,
+    ):
+        raise TruthProducerError("candidate/reference artifact identity is absent")
+    candidate_id = _required_sha(
+        candidate_artifact.get("artifact_id"),
+        "candidate artifact_id",
+    )
+    reference_id = _required_sha(
+        reference_artifact.get("artifact_id"),
+        "reference artifact_id",
+    )
+    if candidate_id == reference_id:
+        raise TruthProducerError(
+            "candidate and independent reference repeat one content identity"
+        )
+    if (
+        expected_candidate_artifact_id is not None
+        and candidate_id != expected_candidate_artifact_id
+    ):
+        raise TruthProducerError("candidate artifact identity mismatch")
+    structural_proof_sha256 = _required_sha(
+        candidate_artifact.get("structural_proof_sha256"),
+        "candidate structural proof digest",
+    )
+    _required_text(
+        candidate_artifact.get("structural_proof_path"),
+        "candidate structural proof path",
+    )
+    if (
+        expected_structural_proof_sha256 is not None
+        and structural_proof_sha256 != expected_structural_proof_sha256
+    ):
+        raise TruthProducerError("candidate structural proof identity mismatch")
+    if candidate_artifact.get("source_revision") != revision or (
+        reference_artifact.get("source_revision") != revision
+    ):
+        raise TruthProducerError("artifact identity is not source-bound")
+    contract = reference_artifact.get("semantics_contract")
+    if (
+        not isinstance(contract, Mapping)
+        or contract.get("schema") != REFERENCE_SCHEMA
+        or contract.get("status") != "materialized"
+        or contract.get("semantics") not in REFERENCE_ROLES
+        or contract.get("source_revision") != revision
+        or contract.get("artifact_id") != reference_id
+    ):
+        raise TruthProducerError("independent reference semantics are not materialized")
+    semantic_payloads = contract.get("semantic_payloads")
+    if not isinstance(semantic_payloads, list) or not semantic_payloads:
+        raise TruthProducerError("independent reference semantic payloads are absent")
+    content_ids: set[str] = set()
+    for index, item in enumerate(semantic_payloads):
+        if not isinstance(item, Mapping):
+            raise TruthProducerError(f"reference semantic payload {index} is malformed")
+        _required_text(item.get("path"), f"semantic payload {index} path")
+        content_id = _required_sha(
+            item.get("sha256"),
+            f"semantic payload {index} digest",
+        )
+        if content_id in content_ids:
+            raise TruthProducerError(
+                "reference semantic payloads repeat one content identity"
+            )
+        content_ids.add(content_id)
+    semantic_normalized = dict(contract)
+    declared_semantic_identity = _required_sha(
+        semantic_normalized.pop("semantic_identity_sha256", None),
+        "reference semantic identity",
+    )
+    if declared_semantic_identity != canonical_sha256(
+        "independent-reference-semantics-v1",
+        semantic_normalized,
+    ):
+        raise TruthProducerError("reference semantic identity digest mismatch")
+
+    momenta = payload.get("validation_momenta")
+    selectors = payload.get("selectors")
+    axes = payload.get("resolved_axes")
+    if not all(isinstance(value, Mapping) for value in (momenta, selectors, axes)):
+        raise TruthProducerError("momenta/selectors/resolved axes are absent")
+    momenta_map = dict(momenta)
+    declared_momenta = _required_sha(
+        momenta_map.pop("validation_momenta_sha256", None),
+        "validation momenta digest",
+    )
+    if declared_momenta != canonical_sha256(
+        "final-source-validation-momenta-v1",
+        momenta_map,
+    ):
+        raise TruthProducerError("validation momenta digest mismatch")
+    selector_map = dict(selectors)
+    declared_selectors = _required_sha(
+        selector_map.pop("selector_sha256", None),
+        "selector digest",
+    )
+    if declared_selectors != canonical_sha256(
+        "final-source-selectors-v1",
+        selector_map,
+    ):
+        raise TruthProducerError("selector digest mismatch")
+    axes_map = dict(axes)
+    declared_axes = _required_sha(
+        axes_map.pop("resolved_axes_sha256", None),
+        "resolved axes digest",
+    )
+    if declared_axes != canonical_sha256(
+        "final-source-resolved-axes-v1",
+        axes_map,
+    ):
+        raise TruthProducerError("resolved axes digest mismatch")
+    if axes_map.get("color_accuracy") != payload.get("accuracy"):
+        raise TruthProducerError("resolved axes accuracy mismatch")
+
+    records: dict[str, Mapping[str, Any]] = {}
+    for name, domain in (
+        ("candidate_native", "final-source-candidate-native-values-v1"),
+        ("candidate_exact", "final-source-candidate-exact-values-v1"),
+        ("reference_exact", "final-source-reference-exact-values-v1"),
+    ):
+        record = payload.get(name)
+        if not isinstance(record, Mapping):
+            raise TruthProducerError(f"{name} record is absent")
+        record_precision = _required_int(
+            record.get("precision_decimal_digits"),
+            f"{name} precision",
+            minimum=16,
+        )
+        if name == "candidate_native":
+            if record_precision != 16:
+                raise TruthProducerError("candidate native precision must be 16")
+        elif record_precision != precision:
+            raise TruthProducerError(f"{name} precision mismatch")
+        values = record.get("values")
+        declared = _required_sha(record.get("values_sha256"), f"{name} values digest")
+        if declared != canonical_sha256(domain, values):
+            raise TruthProducerError(f"{name} values digest mismatch")
+        records[name] = record
+
+    agreement = payload.get("agreement")
+    if not isinstance(agreement, Mapping):
+        raise TruthProducerError("numerical agreement payload is absent")
+    exact_digits = _required_int(
+        agreement.get("exact_agreement_decimal_digits"),
+        "exact agreement digits",
+        minimum=1,
+    )
+    try:
+        native_relative = Decimal(
+            _required_text(
+                agreement.get("native_relative_tolerance"),
+                "native relative tolerance",
+            )
+        )
+        native_absolute = Decimal(
+            _required_text(
+                agreement.get("native_absolute_tolerance"),
+                "native absolute tolerance",
+            )
+        )
+    except InvalidOperation as error:
+        raise TruthProducerError("native tolerance is not decimal") from error
+    recomputed = _agreement(
+        records["candidate_exact"].get("values"),
+        records["candidate_native"].get("values"),
+        records["reference_exact"].get("values"),
+        precision=precision,
+        exact_agreement_digits=exact_digits,
+        native_relative_tolerance=native_relative,
+        native_absolute_tolerance=native_absolute,
+    )
+    if dict(agreement) != recomputed or recomputed["passes"] is not True:
+        raise TruthProducerError("numerical agreement payload does not recompute")
+    declared_comparison = _required_sha(
+        payload.get("comparison_sha256"),
+        "comparison_sha256",
+    )
+    if declared_comparison != comparison_sha256(payload):
+        raise TruthProducerError("comparison_sha256 does not authenticate the witness")
+    return payload
+
+
+def build_witness(
+    candidate_root: Path,
+    reference_root: Path,
+    *,
+    reference_contract_path: str,
+    cell_id: str,
+    source_revision: str,
+    mode: ExecutionMode,
+    accuracy: Accuracy,
+    workload: Workload,
+    helicity_ids: Sequence[str] = (),
+    color_ids: Sequence[str] = (),
+    candidate_process_id: str | None = None,
+    reference_process_id: str | None = None,
+    precision: int = DEFAULT_PRECISION,
+    exact_agreement_digits: int = DEFAULT_EXACT_AGREEMENT_DIGITS,
+    native_relative_tolerance: Decimal = DEFAULT_NATIVE_RELATIVE_TOLERANCE,
+    native_absolute_tolerance: Decimal = DEFAULT_NATIVE_ABSOLUTE_TOLERANCE,
+    runtime_loader: Callable[..., _Runtime] | None = None,
+) -> dict[str, Any]:
+    """Materialize and authenticate one structural-only comparison witness."""
+
+    revision = _required_revision(source_revision, "source_revision")
+    if precision < MINIMUM_PRECISION:
+        raise TruthProducerError(
+            f"comparison precision must be >= {MINIMUM_PRECISION} decimal digits"
+        )
+    candidate = _artifact(
+        candidate_root,
+        source_revision=revision,
+        process_id=candidate_process_id,
+        label="candidate",
+        require_structural_proof=True,
+    )
+    reference = _artifact(
+        reference_root,
+        source_revision=revision,
+        process_id=reference_process_id,
+        label="reference",
+        require_structural_proof=False,
+    )
+    if candidate.artifact_id == reference.artifact_id:
+        raise TruthProducerError(
+            "candidate and independent reference artifacts have one content identity"
+        )
+    if candidate.color_accuracy != accuracy.value or (
+        reference.color_accuracy != accuracy.value
+    ):
+        raise TruthProducerError("candidate/reference color accuracy mismatch")
+    reference_contract = _reference_contract(reference, reference_contract_path)
+    candidate_momenta = _validation_payload(candidate, "candidate")
+    reference_momenta = _validation_payload(reference, "reference")
+    if candidate_momenta != reference_momenta:
+        raise TruthProducerError(
+            "candidate/reference validation momenta or external PDG order differ"
+        )
+    selector_payload = _selector_payload(
+        workload=workload,
+        helicity_ids=helicity_ids,
+        color_ids=color_ids,
+    )
+    if runtime_loader is None:
+        from pyamplicol import Runtime
+
+        runtime_loader = Runtime.load
+    candidate_runtime = runtime_loader(
+        candidate.root,
+        process=candidate.process_id,
+    )
+    reference_runtime = runtime_loader(
+        reference.root,
+        process=reference.process_id,
+    )
+    if candidate_runtime.artifact_id != candidate.artifact_id or (
+        reference_runtime.artifact_id != reference.artifact_id
+    ):
+        raise TruthProducerError("loaded runtime artifact identity mismatch")
+    if candidate_runtime.execution_mode != mode.value:
+        raise TruthProducerError("candidate runtime execution mode mismatch")
+    selectors = {
+        "helicities": tuple(helicity_ids) or None,
+        "color_flows": tuple(color_ids) or None,
+    }
+    points = _momenta(candidate_momenta)
+    try:
+        candidate_native_resolved = candidate_runtime.evaluate_resolved(
+            points,
+            precision=16,
+            **selectors,
+        )
+        candidate_exact_resolved = candidate_runtime.evaluate_resolved(
+            points,
+            precision=precision,
+            **selectors,
+        )
+        reference_exact_resolved = reference_runtime.evaluate_resolved(
+            points,
+            precision=precision,
+            **selectors,
+        )
+    except Exception as error:
+        raise TruthProducerError(
+            "independent precision comparison could not be materialized"
+        ) from error
+    candidate_axes = _axes(candidate_exact_resolved)
+    if _axes(candidate_native_resolved) != candidate_axes or (
+        _axes(reference_exact_resolved) != candidate_axes
+    ):
+        raise TruthProducerError("candidate/reference resolved axes differ")
+    candidate_native_values = _native_values(
+        candidate_native_resolved,
+        "candidate native",
+    )
+    candidate_exact_values = _exact_values(
+        candidate_exact_resolved,
+        "candidate exact",
+    )
+    reference_exact_values = _exact_values(
+        reference_exact_resolved,
+        "reference exact",
+    )
+    agreement = _agreement(
+        candidate_exact_values,
+        candidate_native_values,
+        reference_exact_values,
+        precision=precision,
+        exact_agreement_digits=exact_agreement_digits,
+        native_relative_tolerance=native_relative_tolerance,
+        native_absolute_tolerance=native_absolute_tolerance,
+    )
+    if agreement["passes"] is not True:
+        raise TruthProducerError(
+            "candidate does not agree with the independent reference"
+        )
+    momenta_record: dict[str, Any] = {
+        "candidate_payload_sha256": candidate.validation_sha256,
+        "reference_payload_sha256": reference.validation_sha256,
+        **candidate_momenta,
+    }
+    momenta_record["validation_momenta_sha256"] = canonical_sha256(
+        "final-source-validation-momenta-v1",
+        momenta_record,
+    )
+    payload: dict[str, Any] = {
+        "schema": SCHEMA,
+        "status": "ok",
+        "cell_id": cell_id,
+        "source_revision": revision,
+        "mode": mode.value,
+        "accuracy": accuracy.value,
+        "workload": workload.value,
+        "precision_decimal_digits": precision,
+        "validation_momenta": momenta_record,
+        "selectors": selector_payload,
+        "resolved_axes": candidate_axes,
+        "candidate_artifact": {
+            "artifact_id": candidate.artifact_id,
+            "source_revision": revision,
+            "process_id": candidate.process_id,
+            "execution_mode": candidate_runtime.execution_mode,
+            "execution_payload_path": candidate.execution_path,
+            "execution_payload_sha256": candidate.execution_sha256,
+            "structural_proof_path": candidate.structural_proof_path,
+            "structural_proof_sha256": candidate.structural_proof_sha256,
+        },
+        "reference_artifact": {
+            "artifact_id": reference.artifact_id,
+            "source_revision": revision,
+            "process_id": reference.process_id,
+            "execution_mode": reference_runtime.execution_mode,
+            "execution_payload_path": reference.execution_path,
+            "execution_payload_sha256": reference.execution_sha256,
+            "semantics_contract": reference_contract,
+        },
+        "candidate_native": _value_record(
+            precision=16,
+            executor=f"native-{mode.value}",
+            values=candidate_native_values,
+            domain="final-source-candidate-native-values-v1",
+        ),
+        "candidate_exact": _value_record(
+            precision=precision,
+            executor=f"retained-exact-{mode.value}",
+            values=candidate_exact_values,
+            domain="final-source-candidate-exact-values-v1",
+        ),
+        "reference_exact": _value_record(
+            precision=precision,
+            executor=str(reference_contract["semantics"]),
+            values=reference_exact_values,
+            domain="final-source-reference-exact-values-v1",
+        ),
+        "agreement": agreement,
+    }
+    payload["comparison_sha256"] = comparison_sha256(payload)
+    return validate_witness_payload(
+        payload,
+        expected_source_revision=revision,
+        expected_cell_id=cell_id,
+        expected_mode=mode.value,
+        expected_accuracy=accuracy.value,
+        expected_workload=workload.value,
+        expected_candidate_artifact_id=candidate.artifact_id,
+        expected_structural_proof_sha256=candidate.structural_proof_sha256,
+    )
+
+
+def _atomic_write(path: Path, payload: Mapping[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+        dir=path.parent,
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "w", encoding="ascii") as stream:
+            json.dump(
+                payload,
+                stream,
+                ensure_ascii=True,
+                indent=2,
+                sort_keys=True,
+                allow_nan=False,
+            )
+            stream.write("\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--candidate-artifact", type=Path, required=True)
+    parser.add_argument("--reference-artifact", type=Path, required=True)
+    parser.add_argument("--reference-contract-path", required=True)
+    parser.add_argument("--cell-id", required=True)
+    parser.add_argument("--source-revision", required=True)
+    parser.add_argument(
+        "--mode",
+        choices=[item.value for item in ExecutionMode],
+        required=True,
+    )
+    parser.add_argument(
+        "--accuracy",
+        choices=[item.value for item in Accuracy],
+        required=True,
+    )
+    parser.add_argument(
+        "--workload",
+        choices=[item.value for item in Workload],
+        required=True,
+    )
+    parser.add_argument("--helicity-id", action="append", default=[])
+    parser.add_argument("--color-id", action="append", default=[])
+    parser.add_argument("--candidate-process-id")
+    parser.add_argument("--reference-process-id")
+    parser.add_argument("--precision", type=int, default=DEFAULT_PRECISION)
+    parser.add_argument(
+        "--exact-agreement-digits",
+        type=int,
+        default=DEFAULT_EXACT_AGREEMENT_DIGITS,
+    )
+    parser.add_argument("--output", type=Path, required=True)
+    return parser
+
+
+def main() -> int:
+    arguments = _parser().parse_args()
+    try:
+        payload = build_witness(
+            arguments.candidate_artifact,
+            arguments.reference_artifact,
+            reference_contract_path=arguments.reference_contract_path,
+            cell_id=arguments.cell_id,
+            source_revision=arguments.source_revision,
+            mode=ExecutionMode(arguments.mode),
+            accuracy=Accuracy(arguments.accuracy),
+            workload=Workload(arguments.workload),
+            helicity_ids=arguments.helicity_id,
+            color_ids=arguments.color_id,
+            candidate_process_id=arguments.candidate_process_id,
+            reference_process_id=arguments.reference_process_id,
+            precision=arguments.precision,
+            exact_agreement_digits=arguments.exact_agreement_digits,
+        )
+    except TruthProducerError as error:
+        print(f"final-source numerical truth unavailable: {error}")
+        return 2
+    _atomic_write(arguments.output, payload)
+    print(
+        json.dumps(
+            {
+                "cell_id": payload["cell_id"],
+                "comparison_sha256": payload["comparison_sha256"],
+                "precision_decimal_digits": payload["precision_decimal_digits"],
+                "status": payload["status"],
+            },
+            sort_keys=True,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/four_quark_compiled_gate.py b/pyamplicol/tools/developer/four_quark_compiled_gate.py
new file mode 100644
index 0000000000..5409d1181d
--- /dev/null
+++ b/pyamplicol/tools/developer/four_quark_compiled_gate.py
@@ -0,0 +1,2491 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Validate compiled Direct-Arena execution for four independent quark lines.
+
+The physical process is fixed to ``d d~ > u u~ s s~ c c~``.  A successful
+run generates exactly these compiled/JIT/O3 artifacts:
+
+* LC topology replay;
+* LC all-flow union;
+* NLC contracted color;
+* full contracted color.
+
+The gate also proves that NLC/full all-flow-union configurations fail closed,
+evaluates two or three deterministic phase-space points in f64 and precision
+32, checks resolved sums, compares the two LC layouts component by component
+and through runtime selectors, and recursively authenticates every
+compiled-stage-plan v2 residual/table ownership descriptor.
+
+Run the complete gate from a clean, exact-source candidate:
+
+```
+.venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 -- \
+  .venv/bin/python tools/developer/four_quark_compiled_gate.py \
+  --output-root /private/tmp/pyamplicol-four-quark-compiled-gate
+```
+
+The outer watchdog is mandatory.  Generation workers are descendants of the
+guarded process and intentionally do not start nested watchdogs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib
+import importlib.machinery
+import json
+import math
+import os
+import platform
+import re
+import resource
+import shutil
+import stat
+import subprocess
+import sys
+import sysconfig
+import tempfile
+import time
+import tomllib
+import uuid
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+_EXACT_REEXEC_MARKER = "PYAMPLICOL_EXACT_PYTHON_REEXEC"
+_EXACT_IMPORT_PATHS = "PYAMPLICOL_EXACT_IMPORT_PATHS"
+
+
+def _bootstrap_source_only_python() -> None:
+    """Re-exec before importing any repository or candidate module."""
+
+    if os.environ.get(_EXACT_REEXEC_MARKER) == "1":
+        if (
+            sys.flags.isolated != 1
+            or sys.flags.no_site != 1
+            or sys.flags.ignore_environment != 1
+            or sys.flags.dont_write_bytecode != 1
+            or not sys.dont_write_bytecode
+        ):
+            raise RuntimeError("exact Python re-exec flags are incomplete")
+        raw_paths = json.loads(os.environ[_EXACT_IMPORT_PATHS])
+        if not isinstance(raw_paths, list) or not all(
+            isinstance(path, str) and Path(path).is_absolute() for path in raw_paths
+        ):
+            raise RuntimeError("exact Python import paths are invalid")
+        cache_prefix = os.environ.get("PYTHONPYCACHEPREFIX")
+        if (
+            not isinstance(cache_prefix, str)
+            or not Path(cache_prefix).is_absolute()
+            or Path(cache_prefix).exists()
+        ):
+            raise RuntimeError("exact Python cache prefix is not absent")
+        for import_path in reversed(raw_paths):
+            if import_path not in sys.path:
+                sys.path.insert(0, import_path)
+        sys.pycache_prefix = cache_prefix
+        return
+
+    prefix = Path(tempfile.gettempdir()) / (
+        f".pyamplicol-no-bytecode-{os.getpid()}-{uuid.uuid4().hex}"
+    )
+    if prefix.exists():
+        raise RuntimeError(
+            f"isolated Python cache prefix unexpectedly exists: {prefix}"
+        )
+    import_paths: list[str] = []
+    native_root = next(
+        (
+            candidate
+            for entry in sys.path
+            if (candidate := Path(entry) / "pyamplicol").is_dir()
+            and any(
+                path.is_file()
+                and path.name.startswith("_rusticol")
+                and path.name.endswith(tuple(importlib.machinery.EXTENSION_SUFFIXES))
+                for path in candidate.iterdir()
+            )
+        ),
+        None,
+    )
+    if native_root is not None:
+        import_paths.append(str(native_root.parent.resolve(strict=True)))
+    for scheme_name in ("purelib", "platlib"):
+        scheme_path = sysconfig.get_path(scheme_name)
+        if not isinstance(scheme_path, str):
+            continue
+        try:
+            resolved = str(Path(scheme_path).resolve(strict=True))
+        except OSError:
+            continue
+        if resolved not in import_paths:
+            import_paths.append(resolved)
+    environment = os.environ.copy()
+    environment["PYTHONDONTWRITEBYTECODE"] = "1"
+    environment["PYTHONPYCACHEPREFIX"] = str(prefix)
+    environment[_EXACT_REEXEC_MARKER] = "1"
+    environment[_EXACT_IMPORT_PATHS] = json.dumps(import_paths)
+    os.execve(
+        sys.executable,
+        (
+            sys.executable,
+            "-I",
+            "-S",
+            "-B",
+            str(Path(__file__).resolve(strict=True)),
+            *sys.argv[1:],
+        ),
+        environment,
+    )
+    raise RuntimeError("exact Python re-exec returned unexpectedly")
+
+
+if __name__ == "__main__":
+    _bootstrap_source_only_python()
+
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.performance_report.runtime_evidence import (  # noqa: E402
+    RuntimeEvidenceError,
+    established_preimport_runtime_identity,
+    loaded_pyamplicol_origin_policy,
+    native_extension_in_package,
+    preimport_python_runtime_identity,
+    python_package_tree_identity,
+    source_only_bytecode_policy,
+)
+
+PROCESS = "d d~ > u u~ s s~ c c~"
+EXPECTED_EXTERNAL_PDGS = (-4, -3, -2, -1, 1, 2, 3, 4)
+MAX_QUARK_LINES = 4
+VALIDATION_SEED = 20260725
+POINT_SEEDS = (443_041, 443_099, 443_137)
+SQRT_S = 2_000.0
+RELATIVE_TOLERANCE = 1.0e-12
+ABSOLUTE_TOLERANCE = 1.0e-300
+COMPILED_PLANE_ARENA_CAPABILITY = "compiled-plane-arena-v2"
+COMPILED_PLANE_DIRECT_APPLICATION_ABI = "pyamplicol-compiled-plane-kernel-v2"
+COMPILED_DIRECT_TABLE_BINDING_ABI = "pyamplicol-eager-plane-table-binding-v2"
+COMPILED_DIRECT_TABLE_DESCRIPTOR_ABI = "pyamplicol-eager-plane-table-descriptor-v1"
+NATIVE_COMPILED_DIRECT_APPLICATION_ABI = (
+    "pyamplicol-native-compiled-direct-application-v1"
+)
+SYMJIT_APPLICATION_ABI = "symjit-application-storage-v3"
+SYMJIT_PLANE_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+SYMJIT_RUNTIME_CAPABILITY = "symjit.application.complex-f64.v1"
+RESULT_KIND = "pyamplicol-four-quark-compiled-direct-arena-gate"
+SCHEMA_VERSION = 1
+COMPILED_STAGE_PLAN_KIND = "compiled-plane-arena-stage-v2"
+COMPILED_STAGE_PLAN_SCHEMA_VERSION = 2
+COMPILED_RESIDUAL_LEAF_KIND = "compiled-plane-arena-residual-direct-application-v2"
+HASH_CHUNK_BYTES = 1024 * 1024
+REVISION_PATTERN = re.compile(r"[0-9a-f]{40}")
+SHA256_PATTERN = re.compile(r"[0-9a-f]{64}")
+WATCHDOG_INVOCATION = (
+    ".venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 -- "
+    ".venv/bin/python tools/developer/four_quark_compiled_gate.py "
+    "--output-root /private/tmp/pyamplicol-four-quark-compiled-gate"
+)
+_ZERO_PROFILE_COUNTERS = (
+    "stage_input_copy_component_count",
+    "stage_leaf_input_copy_component_count",
+    "stage_evaluator_output_gather_component_count",
+    "stage_output_assign_component_count",
+    "amplitude_input_copy_component_count",
+    "amplitude_leaf_input_copy_component_count",
+    "amplitude_evaluator_output_gather_component_count",
+    "amplitude_output_remap_component_count",
+    "selector_gather_point_count",
+    "selector_gather_bytes",
+    "selector_scatter_value_count",
+    "compiled_direct_arena_boundary_input_bytes",
+    "compiled_direct_arena_boundary_current_output_bytes",
+    "compiled_direct_arena_boundary_amplitude_output_bytes",
+)
+_ZERO_PROFILE_TIMES = (
+    "stage_input_pack_time_s",
+    "stage_leaf_input_pack_time_s",
+    "stage_evaluator_output_gather_time_s",
+    "output_assign_time_s",
+    "amplitude_input_pack_time_s",
+    "amplitude_leaf_input_pack_time_s",
+    "amplitude_evaluator_output_gather_time_s",
+    "amplitude_output_remap_time_s",
+    "selector_gather_time_s",
+    "selector_scatter_time_s",
+)
+
+
+class GateError(RuntimeError):
+    """Raised when four-quark evidence cannot be trusted."""
+
+
+@dataclass(frozen=True, slots=True)
+class Lane:
+    name: str
+    color_accuracy: str
+    lc_flow_layout: str
+    contracted: bool
+
+
+LANES = (
+    Lane("lc-topology-replay", "lc", "topology-replay", False),
+    Lane("lc-all-flow-union", "lc", "all-flow-union", False),
+    Lane("nlc-contracted", "nlc", "topology-replay", True),
+    Lane("full-contracted", "full", "topology-replay", True),
+)
+
+
+@dataclass(slots=True)
+class EvaluationCapture:
+    """Non-serializable values retained only for cross-lane comparisons."""
+
+    physics_axes: dict[str, object]
+    f64_total: tuple[complex, ...]
+    exact_total: tuple[complex, ...]
+    f64_components: tuple[complex, ...]
+    exact_components: tuple[complex, ...]
+    color_probe: tuple[complex, ...] | None
+    helicity_probe: tuple[complex, ...]
+
+
+def _canonical_json(value: object) -> bytes:
+    try:
+        return json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("utf-8")
+    except (TypeError, ValueError) as error:
+        raise GateError("evidence is not canonical JSON") from error
+
+
+def _canonical_sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_json(value)).hexdigest()
+
+
+def _regular_file_identity(
+    path: Path,
+    *,
+    aggregate: Any | None = None,
+    tree_relative: bytes | None = None,
+) -> tuple[int, str]:
+    """Hash one stable regular file through one no-follow descriptor."""
+
+    flags = (
+        os.O_RDONLY
+        | getattr(os, "O_CLOEXEC", 0)
+        | getattr(os, "O_NOFOLLOW", 0)
+        | getattr(os, "O_BINARY", 0)
+    )
+    digest = hashlib.sha256()
+    descriptor: int | None = None
+    try:
+        descriptor = os.open(path, flags)
+        before = os.fstat(descriptor)
+        if not stat.S_ISREG(before.st_mode):
+            raise GateError(f"identity target is not a regular file: {path}")
+        if aggregate is not None:
+            if tree_relative is None:
+                raise GateError("tree hashing requires a relative path")
+            aggregate.update(len(tree_relative).to_bytes(8, "big"))
+            aggregate.update(tree_relative)
+            aggregate.update(before.st_size.to_bytes(8, "big"))
+        byte_count = 0
+        with os.fdopen(descriptor, "rb", closefd=True) as stream:
+            descriptor = None
+            while block := stream.read(HASH_CHUNK_BYTES):
+                digest.update(block)
+                if aggregate is not None:
+                    aggregate.update(block)
+                byte_count += len(block)
+            after = os.fstat(stream.fileno())
+    except OSError as error:
+        raise GateError(
+            f"cannot hash regular file through a checked fd: {path}"
+        ) from error
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+    stable_fields = (
+        "st_dev",
+        "st_ino",
+        "st_mode",
+        "st_size",
+        "st_mtime_ns",
+        "st_ctime_ns",
+    )
+    if byte_count != before.st_size or any(
+        getattr(before, name) != getattr(after, name) for name in stable_fields
+    ):
+        raise GateError(f"identity target changed while it was hashed: {path}")
+    return byte_count, digest.hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    return _regular_file_identity(path)[1]
+
+
+def _file_identity(path: Path) -> dict[str, object]:
+    try:
+        resolved = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise GateError(f"cannot identify file: {path}") from error
+    size, sha256 = _regular_file_identity(resolved)
+    return {
+        "path": str(resolved),
+        "size_bytes": size,
+        "sha256": sha256,
+    }
+
+
+def _tree_identity(path: Path) -> dict[str, object]:
+    """Hash relative names, sizes, and contents for a relocatable tree ID."""
+
+    try:
+        root = path.expanduser().resolve(strict=True)
+        candidates = list(root.rglob("*"))
+    except OSError as error:
+        raise GateError(f"cannot inspect identity tree: {path}") from error
+    if not root.is_dir():
+        raise GateError(f"identity target is not a directory: {root}")
+    for candidate in candidates:
+        if candidate.is_symlink():
+            raise GateError(
+                f"identity tree contains an unsupported symlink: {candidate}"
+            )
+    members = sorted(
+        (candidate for candidate in candidates if candidate.is_file()),
+        key=lambda candidate: candidate.relative_to(root).as_posix(),
+    )
+    digest = hashlib.sha256()
+    size_bytes = 0
+    try:
+        for member in members:
+            relative = member.relative_to(root).as_posix().encode("utf-8")
+            size, _ = _regular_file_identity(
+                member,
+                aggregate=digest,
+                tree_relative=relative,
+            )
+            size_bytes += size
+    except OSError as error:
+        raise GateError(f"cannot hash identity tree: {root}") from error
+    return {
+        "algorithm": "sha256-relative-path-size-content-v1",
+        "sha256": digest.hexdigest(),
+        "file_count": len(members),
+        "size_bytes": size_bytes,
+    }
+
+
+def _python_package_tree_identity(path: Path) -> dict[str, object]:
+    try:
+        return python_package_tree_identity(path)
+    except RuntimeEvidenceError as error:
+        raise GateError(str(error)) from error
+
+
+def _ensure_source_only_python() -> None:
+    """Verify the stdlib-only bootstrap completed before repository imports."""
+
+    try:
+        source_only_bytecode_policy()
+    except RuntimeEvidenceError as error:
+        raise GateError(
+            "source-only Python bootstrap did not complete before gate imports"
+        ) from error
+
+
+def _establish_preimport_runtime_identity() -> None:
+    native_root = next(
+        (
+            candidate
+            for entry in sys.path
+            if (candidate := Path(entry) / "pyamplicol").is_dir()
+            and any(
+                path.name.startswith("_rusticol")
+                and path.name.endswith(tuple(importlib.machinery.EXTENSION_SUFFIXES))
+                for path in candidate.iterdir()
+            )
+        ),
+        None,
+    )
+    if native_root is None:
+        raise GateError("candidate Python path has no native pyamplicol package")
+    native = native_extension_in_package(native_root)
+    preimport_python_runtime_identity((native_root,), native_extension=native)
+
+
+def _json_object(path: Path, *, label: str) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise GateError(f"cannot read {label}: {path}") from error
+    if not isinstance(value, dict):
+        raise GateError(f"{label} must be a JSON object: {path}")
+    return value
+
+
+def _mapping(value: object, *, label: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise GateError(f"{label} must be an object")
+    return value
+
+
+def _sequence(value: object, *, label: str) -> Sequence[Any]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise GateError(f"{label} must be an array")
+    return value
+
+
+def _git_output(arguments: Sequence[str]) -> str:
+    completed = subprocess.run(
+        ("git", *arguments),
+        cwd=ROOT,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or completed.stdout.strip()
+        raise GateError(f"git {' '.join(arguments)} failed: {detail}")
+    return completed.stdout.strip()
+
+
+def _source_identity() -> dict[str, object]:
+    revision = _git_output(("rev-parse", "--verify", "HEAD"))
+    if REVISION_PATTERN.fullmatch(revision) is None:
+        raise GateError("source checkout has no full Git revision")
+    status = _git_output(("status", "--porcelain=v1", "--untracked-files=all"))
+    if status:
+        raise GateError(
+            "source checkout is dirty; build and run the gate from one committed SHA"
+        )
+    return {
+        "checkout": str(ROOT.resolve(strict=True)),
+        "revision": revision,
+        "dirty": False,
+        "untracked_files_checked": True,
+    }
+
+
+def _runtime_identity(source: Mapping[str, object]) -> dict[str, object]:
+    try:
+        pyamplicol = importlib.import_module("pyamplicol")
+        native = importlib.import_module("pyamplicol._rusticol")
+        versions = importlib.import_module("pyamplicol._internal.versions")
+    except ImportError as error:
+        raise GateError(
+            "the candidate pyamplicol native runtime is unavailable"
+        ) from error
+    native_path_raw = getattr(native, "__file__", None)
+    if not isinstance(native_path_raw, str):
+        raise GateError("native extension has no filesystem path")
+    native_digest_function = getattr(native, "native_build_inputs_sha256", None)
+    if not callable(native_digest_function):
+        raise GateError("native extension exposes no build-input digest")
+    native_digest = native_digest_function()
+    if (
+        not isinstance(native_digest, str)
+        or SHA256_PATTERN.fullmatch(native_digest) is None
+    ):
+        raise GateError("native extension build-input digest is invalid")
+    build_info_function = getattr(versions, "_active_build_info", None)
+    build_info = build_info_function() if callable(build_info_function) else None
+    if not isinstance(build_info, Mapping):
+        raise GateError("candidate exposes no strict build provenance")
+    if build_info.get("source_revision") != source.get("revision"):
+        raise GateError(
+            "candidate native runtime was built from another source revision"
+        )
+    if build_info.get("native_build_inputs_sha256") != native_digest:
+        raise GateError("candidate build info and native build inputs disagree")
+    checkout = build_info.get("source_checkout")
+    if not isinstance(checkout, str):
+        raise GateError("candidate build info has no source checkout")
+    try:
+        bound_checkout = Path(checkout).expanduser().resolve(strict=True)
+    except OSError as error:
+        raise GateError("candidate source checkout is unavailable") from error
+    if bound_checkout != ROOT.resolve(strict=True):
+        raise GateError("candidate was built from another source checkout")
+    package_path_raw = getattr(pyamplicol, "__file__", None)
+    if not isinstance(package_path_raw, str):
+        raise GateError("pyamplicol package has no filesystem identity")
+    package_roots = tuple(Path(str(path)) for path in pyamplicol.__path__)
+    preimport_identity = established_preimport_runtime_identity()
+    return {
+        "interpreter": {
+            **_file_identity(Path(sys.executable)),
+            "python_version": platform.python_version(),
+            "implementation": platform.python_implementation(),
+        },
+        "package": {
+            **_file_identity(Path(package_path_raw)),
+            "version": str(getattr(pyamplicol, "__version__", "")),
+        },
+        "python_package_tree": _python_package_tree_identity(package_roots),
+        "loaded_module_origin_policy": loaded_pyamplicol_origin_policy(
+            package_roots,
+            native_extension=Path(native_path_raw),
+            expected_package_identity=preimport_identity["python_package_tree"],
+            expected_native_identity=preimport_identity["native_extension"],
+        ),
+        "native_extension": {
+            **_file_identity(Path(native_path_raw)),
+            "build_inputs_sha256": native_digest,
+        },
+        "active_build_info": {
+            "payload": dict(build_info),
+            "canonical_sha256": _canonical_sha256(build_info),
+        },
+    }
+
+
+def _stable_runtime_identity(value: Mapping[str, object]) -> dict[str, object]:
+    """Exclude only the monotonically growing loaded-module observation set."""
+
+    stable = dict(value)
+    raw_policy = stable.get("loaded_module_origin_policy")
+    if isinstance(raw_policy, Mapping):
+        policy = dict(raw_policy)
+        for field in (
+            "observed_module_count",
+            "observations",
+            "observations_sha256",
+        ):
+            policy.pop(field, None)
+        stable["loaded_module_origin_policy"] = policy
+    return stable
+
+
+def _runtime_identity_sha256(value: Mapping[str, object]) -> str:
+    return _canonical_sha256(_stable_runtime_identity(value))
+
+
+def _peak_rss_gib() -> float:
+    raw = float(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
+    # Darwin reports bytes; Linux and the other supported Unix platforms use KiB.
+    divisor = float(1024**3 if platform.system() == "Darwin" else 1024**2)
+    return raw / divisor
+
+
+def _generation_worker(
+    artifact: Path,
+    lane: Lane,
+    *,
+    expected_revision: str,
+    expected_runtime_sha256: str,
+    expected_script_sha256: str,
+) -> dict[str, object]:
+    source = _source_identity()
+    if source["revision"] != expected_revision:
+        raise GateError("generation worker source revision changed")
+    runtime = _runtime_identity(source)
+    if _runtime_identity_sha256(runtime) != expected_runtime_sha256:
+        raise GateError("generation worker candidate runtime identity changed")
+    script = _file_identity(Path(__file__))
+    if script["sha256"] != expected_script_sha256:
+        raise GateError("generation worker gate script identity changed")
+
+    from pyamplicol import Generator
+    from pyamplicol.config import (
+        ColorConfig,
+        EvaluatorConfig,
+        EvaluatorOptimizationConfig,
+        GenerationConfig,
+        GenerationValidationConfig,
+        JITConfig,
+        OutputConfig,
+        ProcessConfig,
+        RunConfig,
+    )
+
+    run = RunConfig(
+        action="generate",
+        process=ProcessConfig(max_quark_lines=MAX_QUARK_LINES),
+        color=ColorConfig(
+            accuracy=lane.color_accuracy,
+            lc_flow_layout=lane.lc_flow_layout,
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=True,
+                samples=2,
+                seed=VALIDATION_SEED,
+                relative_tolerance=RELATIVE_TOLERANCE,
+                absolute_tolerance=ABSOLUTE_TOLERANCE,
+                post_build_validation=True,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            backend="jit",
+            execution_mode="compiled",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=3),
+        ),
+        output=OutputConfig(format="json", color="never", progress="off"),
+    )
+    started_wall = time.monotonic()
+    started_cpu = time.process_time()
+    result = Generator(run).generate(PROCESS, artifact, mode="error")
+    elapsed_wall = time.monotonic() - started_wall
+    elapsed_cpu = time.process_time() - started_cpu
+    source_postflight = _source_identity()
+    runtime_postflight = _runtime_identity(source_postflight)
+    script_postflight = _file_identity(Path(__file__))
+    if source_postflight != source:
+        raise GateError("generation worker source identity changed during generation")
+    if _stable_runtime_identity(runtime_postflight) != _stable_runtime_identity(
+        runtime
+    ):
+        raise GateError("generation worker runtime identity changed during generation")
+    if script_postflight != script:
+        raise GateError("generation worker script identity changed during generation")
+    return {
+        "lane": lane.name,
+        "artifact": str(result.output),
+        "worker_script": script,
+        "worker_provenance": {
+            "source_revision": source["revision"],
+            "runtime_identity_sha256": _runtime_identity_sha256(runtime),
+            "gate_script_sha256": script["sha256"],
+            "postflight_identity_match": True,
+        },
+        "process_ids": [process.name for process in result.processes.requests],
+        "generation": {
+            "wall_seconds": elapsed_wall,
+            "process_cpu_seconds": elapsed_cpu,
+            "worker_peak_rss_gib": _peak_rss_gib(),
+            "workers": 1,
+            "validation_samples": 2,
+            "validation_seed": VALIDATION_SEED,
+            "post_build_validation": True,
+        },
+    }
+
+
+def _worker_command(
+    artifact: Path,
+    lane: Lane,
+    *,
+    expected_revision: str,
+    expected_runtime_sha256: str,
+    expected_script_sha256: str,
+) -> tuple[str, ...]:
+    return (
+        sys.executable,
+        "-I",
+        "-S",
+        "-B",
+        str(Path(__file__).resolve()),
+        "--_generate-one",
+        "--artifact",
+        str(artifact),
+        "--lane",
+        lane.name,
+        "--expected-revision",
+        expected_revision,
+        "--expected-runtime-sha256",
+        expected_runtime_sha256,
+        "--expected-script-sha256",
+        expected_script_sha256,
+    )
+
+
+def _invoke_generation_worker(
+    artifact: Path,
+    lane: Lane,
+    *,
+    timeout: float,
+    expected_revision: str,
+    expected_runtime_sha256: str,
+    expected_script_sha256: str,
+) -> dict[str, object]:
+    command = _worker_command(
+        artifact,
+        lane,
+        expected_revision=expected_revision,
+        expected_runtime_sha256=expected_runtime_sha256,
+        expected_script_sha256=expected_script_sha256,
+    )
+    started = time.monotonic()
+    try:
+        completed = subprocess.run(
+            command,
+            cwd=ROOT,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired as error:
+        raise GateError(
+            f"{lane.name} generation exceeded {timeout:.1f} seconds"
+        ) from error
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or completed.stdout.strip()
+        raise GateError(f"{lane.name} generation failed:\n{detail[-6000:]}")
+    try:
+        payload = json.loads(completed.stdout)
+    except json.JSONDecodeError as error:
+        raise GateError(f"{lane.name} worker emitted invalid JSON") from error
+    if not isinstance(payload, dict) or payload.get("lane") != lane.name:
+        raise GateError(f"{lane.name} worker returned the wrong lane")
+    worker_script = _mapping(
+        payload.get("worker_script"),
+        label=f"{lane.name} worker script identity",
+    )
+    if worker_script.get("sha256") != expected_script_sha256:
+        raise GateError(f"{lane.name} worker executed another gate script")
+    worker_provenance = _mapping(
+        payload.get("worker_provenance"),
+        label=f"{lane.name} worker provenance",
+    )
+    if (
+        worker_provenance.get("source_revision") != expected_revision
+        or worker_provenance.get("runtime_identity_sha256") != expected_runtime_sha256
+        or worker_provenance.get("gate_script_sha256") != expected_script_sha256
+        or worker_provenance.get("postflight_identity_match") is not True
+    ):
+        raise GateError(f"{lane.name} worker provenance drifted")
+    payload["orchestration_wall_seconds"] = time.monotonic() - started
+    payload["command"] = {
+        "argv": list(command),
+        "canonical_sha256": _canonical_sha256(list(command)),
+    }
+    if completed.stderr.strip():
+        payload["worker_stderr_sha256"] = hashlib.sha256(
+            completed.stderr.encode()
+        ).hexdigest()
+    return payload
+
+
+def _assert_union_rejections() -> list[dict[str, object]]:
+    from pyamplicol.config import ColorConfig, ConfigurationError
+
+    result: list[dict[str, object]] = []
+    for accuracy in ("nlc", "full"):
+        try:
+            ColorConfig(accuracy=accuracy, lc_flow_layout="all-flow-union")
+        except ConfigurationError as error:
+            message = str(error)
+            if "all-flow-union" not in message or "requires" not in message:
+                raise GateError(
+                    f"{accuracy} union rejection was not actionable: {message}"
+                ) from error
+            result.append(
+                {
+                    "color_accuracy": accuracy,
+                    "lc_flow_layout": "all-flow-union",
+                    "rejected": True,
+                    "error_type": type(error).__name__,
+                    "message": message,
+                }
+            )
+        else:
+            raise GateError(f"{accuracy} all-flow-union did not fail closed")
+    return result
+
+
+def _safe_relative_path(value: object, *, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise GateError(f"{label} must be a non-empty path")
+    path = Path(value)
+    if path.is_absolute() or ".." in path.parts:
+        raise GateError(f"{label} must be artifact-relative")
+    return value
+
+
+def _source_evaluator_leaves(
+    evaluator: Mapping[str, Any],
+    *,
+    label: str,
+) -> list[Mapping[str, Any]]:
+    kind = evaluator.get("kind")
+    if kind == "symjit-application-evaluator":
+        return [evaluator]
+    if kind != "chunked-symbolica-evaluator":
+        raise GateError(f"{label} has unsupported evaluator kind {kind!r}")
+    chunks = _sequence(evaluator.get("chunks"), label=f"{label}.chunks")
+    if not chunks:
+        raise GateError(f"{label} has no evaluator leaves")
+    leaves: list[Mapping[str, Any]] = []
+    for index, chunk in enumerate(chunks):
+        leaves.extend(
+            _source_evaluator_leaves(
+                _mapping(chunk, label=f"{label}.chunks[{index}]"),
+                label=f"{label}.chunks[{index}]",
+            )
+        )
+    return leaves
+
+
+def _nonnegative_int(value: object, *, label: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise GateError(f"{label} must be a nonnegative integer")
+    return value
+
+
+def _int_list(value: object, *, label: str) -> list[int]:
+    return [
+        _nonnegative_int(item, label=f"{label}[{index}]")
+        for index, item in enumerate(_sequence(value, label=label))
+    ]
+
+
+def _authenticated_certificate(
+    value: object,
+    *,
+    label: str,
+) -> Mapping[str, Any]:
+    certificate = _mapping(value, label=label)
+    digest = certificate.get("digest")
+    if not isinstance(digest, str) or SHA256_PATTERN.fullmatch(digest) is None:
+        raise GateError(f"{label}.digest is not a SHA-256")
+    subject = {name: item for name, item in certificate.items() if name != "digest"}
+    if _canonical_sha256(subject) != digest:
+        raise GateError(f"{label}.digest does not authenticate the certificate")
+    return certificate
+
+
+def _audit_stage_order_certificate(
+    descriptor: Mapping[str, Any],
+    *,
+    stage: Mapping[str, Any],
+    label: str,
+) -> dict[str, object]:
+    certificate = _authenticated_certificate(
+        descriptor.get("order_certificate"),
+        label=f"{label}.compiled_plane_arena.order_certificate",
+    )
+    if certificate.get("kind") != "whole-current-canonical-order-v1":
+        raise GateError(f"{label} has an incompatible order certificate")
+    output_length = _nonnegative_int(
+        stage.get("output_length"),
+        label=f"{label}.output_length",
+    )
+    slots = [
+        _mapping(item, label=f"{label}.output_slots[{index}]")
+        for index, item in enumerate(
+            _sequence(stage.get("output_slots"), label=f"{label}.output_slots")
+        )
+    ]
+    destinations = [
+        _mapping(item, label=f"{label}.destinations[{index}]")
+        for index, item in enumerate(
+            _sequence(
+                certificate.get("destinations"),
+                label=f"{label}.order_certificate.destinations",
+            )
+        )
+    ]
+    if len(destinations) != len(slots):
+        raise GateError(f"{label} order certificate does not cover output slots")
+    is_amplitude = str(stage.get("stage_kind", "")).startswith("amplitude")
+    output_cursor = 0
+    current_ids: list[int] = []
+    residual_ranges: list[tuple[int, int]] = []
+    table_owners: dict[int, tuple[int, int]] = {}
+    ordered_interactions: list[int] = []
+    ordered_groups: list[int] = []
+    for index, (destination, slot) in enumerate(zip(destinations, slots, strict=True)):
+        destination_label = f"{label}.order_certificate.destinations[{index}]"
+        output_start = _nonnegative_int(
+            destination.get("output_start"),
+            label=f"{destination_label}.output_start",
+        )
+        output_stop = _nonnegative_int(
+            destination.get("output_stop"),
+            label=f"{destination_label}.output_stop",
+        )
+        slot_start = _nonnegative_int(
+            slot.get("output_start"),
+            label=f"{label}.output_slots[{index}].output_start",
+        )
+        slot_stop = _nonnegative_int(
+            slot.get("output_stop"),
+            label=f"{label}.output_slots[{index}].output_stop",
+        )
+        expected_owner_kind = "amplitude" if is_amplitude else "current"
+        owner_id = _nonnegative_int(
+            destination.get("owner_id"),
+            label=f"{destination_label}.owner_id",
+        )
+        if (
+            destination.get("destination_id") != index
+            or destination.get("owner_kind") != expected_owner_kind
+            or output_start != output_cursor
+            or output_start >= output_stop
+            or output_stop > output_length
+            or (output_start, output_stop) != (slot_start, slot_stop)
+        ):
+            raise GateError(f"{destination_label} is not canonical")
+        if is_amplitude:
+            if slot.get("current_id") != -1:
+                raise GateError(f"{destination_label} misidentifies an amplitude")
+        else:
+            current_id = _nonnegative_int(
+                slot.get("current_id"),
+                label=f"{label}.output_slots[{index}].current_id",
+            )
+            if owner_id != current_id or current_id in current_ids:
+                raise GateError(f"{destination_label} repeats a current")
+            current_ids.append(current_id)
+        interactions = _int_list(
+            destination.get("interaction_ids"),
+            label=f"{destination_label}.interaction_ids",
+        )
+        groups = _int_list(
+            destination.get("evaluation_group_ids"),
+            label=f"{destination_label}.evaluation_group_ids",
+        )
+        ordered_interactions.extend(interactions)
+        ordered_groups.extend(groups)
+        ownership = _mapping(
+            destination.get("ownership"),
+            label=f"{destination_label}.ownership",
+        )
+        ownership_kind = ownership.get("kind")
+        if ownership_kind == "residual":
+            if set(ownership) != {"kind"}:
+                raise GateError(f"{destination_label} residual ownership is malformed")
+            residual_ranges.append((output_start, output_stop))
+        elif ownership_kind == "table" and not is_amplitude:
+            if set(ownership) != {"kind", "island_id", "row_index"}:
+                raise GateError(f"{destination_label} table ownership is malformed")
+            island_id = _nonnegative_int(
+                ownership.get("island_id"),
+                label=f"{destination_label}.ownership.island_id",
+            )
+            row_index = _nonnegative_int(
+                ownership.get("row_index"),
+                label=f"{destination_label}.ownership.row_index",
+            )
+            table_owners[owner_id] = (island_id, row_index)
+        else:
+            raise GateError(f"{destination_label} has invalid ownership")
+        output_cursor = output_stop
+    if output_cursor != output_length:
+        raise GateError(f"{label} order certificate does not cover stage outputs")
+    if (
+        _int_list(
+            certificate.get("current_ids"),
+            label=f"{label}.order_certificate.current_ids",
+        )
+        != current_ids
+    ):
+        raise GateError(f"{label} order certificate current order is inconsistent")
+    source_interactions = _int_list(
+        certificate.get("source_stage_interaction_ids"),
+        label=f"{label}.order_certificate.source_stage_interaction_ids",
+    )
+    stage_interactions = _int_list(
+        stage.get("interaction_ids"),
+        label=f"{label}.interaction_ids",
+    )
+    execution_interactions = _int_list(
+        certificate.get("interaction_ids"),
+        label=f"{label}.order_certificate.interaction_ids",
+    )
+    execution_groups = _int_list(
+        certificate.get("evaluation_group_ids"),
+        label=f"{label}.order_certificate.evaluation_group_ids",
+    )
+    if (
+        source_interactions != stage_interactions
+        or execution_interactions != ordered_interactions
+        or execution_groups != ordered_groups
+        or len(execution_interactions) != len(set(execution_interactions))
+        or set(execution_interactions) != set(source_interactions)
+    ):
+        raise GateError(f"{label} order certificate changes contribution order")
+    return {
+        "destinations": destinations,
+        "residual_ranges": residual_ranges,
+        "table_owners": table_owners,
+    }
+
+
+def _audit_direct_descriptor(
+    descriptor: Mapping[str, Any],
+    *,
+    stage: Mapping[str, Any],
+    label: str,
+) -> dict[str, int]:
+    if descriptor.get("kind") != COMPILED_STAGE_PLAN_KIND:
+        raise GateError(f"{label}.compiled_plane_arena has the wrong kind")
+    if descriptor.get("schema_version") != COMPILED_STAGE_PLAN_SCHEMA_VERSION:
+        raise GateError(f"{label}.compiled_plane_arena has the wrong schema")
+    expected_scalars = {
+        "application_abi": COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+        "source_application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+        "element_layout": "split-complex-component-major",
+        "input_output_aliasing": "forbidden",
+        "output_output_aliasing": "forbidden",
+        "output_operation": "overwrite",
+        "output_factor": "identity",
+    }
+    for name, expected in expected_scalars.items():
+        if descriptor.get(name) != expected:
+            raise GateError(f"{label}.compiled_plane_arena.{name} is not {expected!r}")
+    inputs = _sequence(
+        descriptor.get("input_bindings"),
+        label=f"{label}.compiled_plane_arena.input_bindings",
+    )
+    input_indices = [
+        _mapping(item, label=f"{label}.input_bindings[{index}]").get("parameter_index")
+        for index, item in enumerate(inputs)
+    ]
+    if input_indices != list(range(len(inputs))):
+        raise GateError(f"{label} Direct-Arena input bindings are not contiguous")
+    outputs = _sequence(
+        descriptor.get("output_bindings"),
+        label=f"{label}.compiled_plane_arena.output_bindings",
+    )
+    output_indices = [
+        _mapping(item, label=f"{label}.output_bindings[{index}]").get("output_index")
+        for index, item in enumerate(outputs)
+    ]
+    if output_indices != list(range(len(outputs))):
+        raise GateError(f"{label} Direct-Arena output bindings are not contiguous")
+    if len(outputs) != stage.get("output_length"):
+        raise GateError(f"{label} Direct-Arena outputs do not cover the stage")
+    order = _audit_stage_order_certificate(
+        descriptor,
+        stage=stage,
+        label=label,
+    )
+    residual_ranges = list(order["residual_ranges"])
+    table_owners = dict(order["table_owners"])
+
+    evaluator_raw = stage.get("evaluator")
+    source_leaves = (
+        []
+        if evaluator_raw is None
+        else _source_evaluator_leaves(
+            _mapping(evaluator_raw, label=f"{label}.evaluator"),
+            label=f"{label}.evaluator",
+        )
+    )
+    direct_leaves = list(
+        _sequence(
+            descriptor.get("residual_leaves"),
+            label=f"{label}.compiled_plane_arena.residual_leaves",
+        )
+    )
+    if len(direct_leaves) != len(source_leaves):
+        raise GateError(f"{label} residual/source leaf counts disagree")
+    residual_outputs: list[int] = []
+    owned_residual_ranges: list[tuple[int, int]] = []
+    for index, (direct_raw, source) in enumerate(
+        zip(direct_leaves, source_leaves, strict=True)
+    ):
+        direct = _mapping(direct_raw, label=f"{label}.residual_leaves[{index}]")
+        if (
+            direct.get("kind") != COMPILED_RESIDUAL_LEAF_KIND
+            or direct.get("leaf_id") != index
+        ):
+            raise GateError(f"{label} residual leaf identity is incompatible")
+        if (
+            source.get("application_abi") != SYMJIT_APPLICATION_ABI
+            or source.get("runtime_capability") != SYMJIT_RUNTIME_CAPABILITY
+        ):
+            raise GateError(
+                f"{label} ordinary SymJIT fallback leaf identity is inconsistent"
+            )
+        _safe_relative_path(
+            source.get("application_path"),
+            label=f"{label}.source_leaves[{index}].application_path",
+        )
+        plane = _mapping(
+            source.get("plane_application"),
+            label=f"{label}.source_leaves[{index}].plane_application",
+        )
+        source_path = _safe_relative_path(
+            plane.get("application_path"),
+            label=(
+                f"{label}.source_leaves[{index}].plane_application.application_path"
+            ),
+        )
+        if (
+            direct.get("application_path") != source_path
+            or direct.get("source_application_abi")
+            != SYMJIT_PLANE_APPLICATION_ABI
+            or plane.get("application_abi") != SYMJIT_PLANE_APPLICATION_ABI
+            or plane.get("storage_abi") != SYMJIT_APPLICATION_ABI
+            or plane.get("translation_mode")
+            != "symbolica-structured-instructions"
+            or plane.get("direct_arena") is not True
+            or not isinstance(plane.get("source_digest"), str)
+            or SHA256_PATTERN.fullmatch(str(plane.get("source_digest"))) is None
+        ):
+            raise GateError(f"{label} Direct-Arena leaf identity is inconsistent")
+        if (
+            direct.get("optimization_level") != 3
+            or source.get("optimization_level") != 3
+            or plane.get("optimization_level") != 3
+        ):
+            raise GateError(f"{label} Direct-Arena leaf is not JIT O3")
+        if direct.get("direct_codegen_optimization_level") != 3:
+            raise GateError(
+                f"{label} Direct-Arena leaf direct codegen does not match its "
+                "plane application"
+            )
+        indices = _sequence(
+            direct.get("input_indices"),
+            label=f"{label}.leaves[{index}].input_indices",
+        )
+        if (
+            any(
+                isinstance(value, bool) or not isinstance(value, int) or value < 0
+                for value in indices
+            )
+            or len(indices) != direct.get("input_len")
+            or len(indices) != source.get("input_len")
+        ):
+            raise GateError(f"{label} Direct-Arena leaf inputs are invalid")
+        output_len = _nonnegative_int(
+            direct.get("output_len"),
+            label=f"{label}.residual_leaves[{index}].output_len",
+        )
+        direct_output_indices = _int_list(
+            direct.get("output_indices"),
+            label=f"{label}.residual_leaves[{index}].output_indices",
+        )
+        if (
+            output_len != source.get("output_len")
+            or len(direct_output_indices) != output_len
+            or len(direct_output_indices) != len(set(direct_output_indices))
+        ):
+            raise GateError(f"{label} Direct-Arena leaf outputs are invalid")
+        leaf_ranges = []
+        for range_index, raw_range in enumerate(
+            _sequence(
+                direct.get("output_ranges"),
+                label=f"{label}.residual_leaves[{index}].output_ranges",
+            )
+        ):
+            output_range = _mapping(
+                raw_range,
+                label=(
+                    f"{label}.residual_leaves[{index}].output_ranges[{range_index}]"
+                ),
+            )
+            start = _nonnegative_int(
+                output_range.get("output_start"),
+                label=f"{label}.residual_range.output_start",
+            )
+            stop = _nonnegative_int(
+                output_range.get("output_stop"),
+                label=f"{label}.residual_range.output_stop",
+            )
+            if start >= stop:
+                raise GateError(f"{label} residual range is empty")
+            leaf_ranges.append((start, stop))
+        expanded = [
+            output for start, stop in leaf_ranges for output in range(start, stop)
+        ]
+        if expanded != direct_output_indices:
+            raise GateError(f"{label} residual leaf splits or reorders destinations")
+        residual_outputs.extend(direct_output_indices)
+        owned_residual_ranges.extend(leaf_ranges)
+
+    declared_residual_ranges = [
+        (
+            _nonnegative_int(
+                _mapping(item, label=f"{label}.residual_output_ranges[{index}]").get(
+                    "output_start"
+                ),
+                label=f"{label}.residual_output_ranges[{index}].output_start",
+            ),
+            _nonnegative_int(
+                _mapping(item, label=f"{label}.residual_output_ranges[{index}]").get(
+                    "output_stop"
+                ),
+                label=f"{label}.residual_output_ranges[{index}].output_stop",
+            ),
+        )
+        for index, item in enumerate(
+            _sequence(
+                descriptor.get("residual_output_ranges"),
+                label=f"{label}.compiled_plane_arena.residual_output_ranges",
+            )
+        )
+    ]
+    if (
+        declared_residual_ranges != residual_ranges
+        or owned_residual_ranges != residual_ranges
+        or residual_outputs
+        != [output for start, stop in residual_ranges for output in range(start, stop)]
+    ):
+        raise GateError(f"{label} residual ownership is not exact")
+
+    kernels = [
+        _mapping(item, label=f"{label}.kernels[{index}]")
+        for index, item in enumerate(
+            _sequence(
+                descriptor.get("kernels"),
+                label=f"{label}.compiled_plane_arena.kernels",
+            )
+        )
+    ]
+    if len(kernels) > 8:
+        raise GateError(f"{label} exceeds eight DirectTable kernels")
+    for index, kernel in enumerate(kernels):
+        if (
+            kernel.get("kernel_id") != index
+            or kernel.get("source_application_abi")
+            != SYMJIT_PLANE_APPLICATION_ABI
+            or kernel.get("application_abi") != COMPILED_PLANE_DIRECT_APPLICATION_ABI
+            or kernel.get("binding_abi") != COMPILED_DIRECT_TABLE_BINDING_ABI
+            or kernel.get("descriptor_abi") != COMPILED_DIRECT_TABLE_DESCRIPTOR_ABI
+            or kernel.get("optimization_level") != 3
+        ):
+            raise GateError(f"{label} DirectTable kernel contract is incompatible")
+        for field in (
+            "motif_digest",
+            "exact_source_digest",
+            "application_sha256",
+            "descriptor_sha256",
+        ):
+            value = kernel.get(field)
+            if not isinstance(value, str) or SHA256_PATTERN.fullmatch(value) is None:
+                raise GateError(f"{label}.kernels[{index}].{field} is invalid")
+        _safe_relative_path(
+            kernel.get("application_path"),
+            label=f"{label}.kernels[{index}].application_path",
+        )
+        _safe_relative_path(
+            kernel.get("descriptor_path"),
+            label=f"{label}.kernels[{index}].descriptor_path",
+        )
+        source_size = _nonnegative_int(
+            kernel.get("application_size_bytes"),
+            label=f"{label}.kernels[{index}].application_size_bytes",
+        )
+        input_count = _nonnegative_int(
+            kernel.get("input_complex_count"),
+            label=f"{label}.kernels[{index}].input_complex_count",
+        )
+        output_count = _nonnegative_int(
+            kernel.get("output_complex_count"),
+            label=f"{label}.kernels[{index}].output_complex_count",
+        )
+        if (
+            source_size == 0
+            or source_size > 64 * 1024
+            or not 1 <= input_count <= 16
+            or not 1 <= output_count <= 2
+        ):
+            raise GateError(f"{label} DirectTable kernel exceeds slice bounds")
+
+    islands = [
+        _mapping(item, label=f"{label}.islands[{index}]")
+        for index, item in enumerate(
+            _sequence(
+                descriptor.get("islands"),
+                label=f"{label}.compiled_plane_arena.islands",
+            )
+        )
+    ]
+    island_currents: dict[int, tuple[int, int]] = {}
+    invocation_count = 0
+    attachment_count = 0
+    for index, island in enumerate(islands):
+        kernel_id = _nonnegative_int(
+            island.get("kernel_id"),
+            label=f"{label}.islands[{index}].kernel_id",
+        )
+        if island.get("island_id") != index or kernel_id >= len(kernels):
+            raise GateError(f"{label} DirectTable island identity is invalid")
+        current_ids = _int_list(
+            island.get("current_ids"),
+            label=f"{label}.islands[{index}].current_ids",
+        )
+        if not current_ids or len(current_ids) != len(set(current_ids)):
+            raise GateError(f"{label} DirectTable island destinations are invalid")
+        invocations = [
+            _mapping(item, label=f"{label}.islands[{index}].invocations[{row}]")
+            for row, item in enumerate(
+                _sequence(
+                    island.get("invocation_rows"),
+                    label=f"{label}.islands[{index}].invocation_rows",
+                )
+            )
+        ]
+        attachments = [
+            _mapping(item, label=f"{label}.islands[{index}].attachments[{row}]")
+            for row, item in enumerate(
+                _sequence(
+                    island.get("attachment_rows"),
+                    label=f"{label}.islands[{index}].attachment_rows",
+                )
+            )
+        ]
+        if len(invocations) != len(current_ids) or len(attachments) != len(current_ids):
+            raise GateError(f"{label} DirectTable rows do not match destinations")
+        for row_index, invocation in enumerate(invocations):
+            if (
+                invocation.get("attachment_start") != row_index
+                or invocation.get("attachment_count") != 1
+            ):
+                raise GateError(f"{label} DirectTable attachment ranges are invalid")
+            owner = table_owners.get(current_ids[row_index])
+            if owner != (index, row_index):
+                raise GateError(f"{label} table ownership certificate is inconsistent")
+            island_currents[current_ids[row_index]] = (index, row_index)
+        for attachment in attachments:
+            if attachment.get("operation") not in {"overwrite", "accumulate"}:
+                raise GateError(f"{label} DirectTable write operation is invalid")
+        dependency = _authenticated_certificate(
+            island.get("dependency_certificate"),
+            label=f"{label}.islands[{index}].dependency_certificate",
+        )
+        if (
+            dependency.get("kind") != "independent-whole-current-group-v1"
+            or _int_list(
+                dependency.get("current_ids"),
+                label=f"{label}.islands[{index}].dependency.current_ids",
+            )
+            != current_ids
+        ):
+            raise GateError(f"{label} dependency certificate is incompatible")
+        rows = [
+            _mapping(item, label=f"{label}.islands[{index}].dependency.rows[{row}]")
+            for row, item in enumerate(
+                _sequence(
+                    dependency.get("rows"),
+                    label=f"{label}.islands[{index}].dependency.rows",
+                )
+            )
+        ]
+        if len(rows) != len(current_ids):
+            raise GateError(f"{label} dependency certificate is incomplete")
+        grouped = set(current_ids)
+        for row_index, row in enumerate(rows):
+            predecessors = set(
+                _int_list(
+                    row.get("predecessor_current_ids"),
+                    label=f"{label}.islands[{index}].predecessors[{row_index}]",
+                )
+            )
+            if row.get("current_id") != current_ids[row_index] or (
+                predecessors & grouped
+            ) - {current_ids[row_index]}:
+                raise GateError(f"{label} groups dependent current destinations")
+        invocation_count += len(invocations)
+        attachment_count += len(attachments)
+    if island_currents != table_owners:
+        raise GateError(f"{label} table ownership is not exhaustive")
+    if stage.get("stage_kind", "").startswith("amplitude") and islands:
+        raise GateError(f"{label} amplitude stage illegally contains table islands")
+    if evaluator_raw is None and (direct_leaves or not islands):
+        raise GateError(f"{label} evaluator omission is not a table-only stage")
+
+    census = _mapping(
+        descriptor.get("census"),
+        label=f"{label}.compiled_plane_arena.census",
+    )
+    expected_census = {
+        "stage_kernel_count": len(kernels),
+        "stage_island_count": len(islands),
+        "stage_invocation_count": invocation_count,
+        "stage_attachment_count": attachment_count,
+        "stage_residual_leaf_count": len(direct_leaves),
+        "stage_table_destination_count": len(table_owners),
+        "stage_residual_destination_count": len(residual_ranges),
+    }
+    if census.get("schema_version") != 1:
+        raise GateError(f"{label} compiled-stage census has the wrong schema")
+    for field, expected in expected_census.items():
+        if census.get(field) != expected:
+            raise GateError(f"{label} compiled-stage census {field} is inconsistent")
+    return {
+        "leaf_count": len(direct_leaves),
+        "input_binding_count": len(inputs),
+        "output_binding_count": len(outputs),
+        "kernel_count": len(kernels),
+        "island_count": len(islands),
+        "invocation_count": invocation_count,
+        "attachment_count": attachment_count,
+        "residual_destination_count": len(residual_ranges),
+        "table_destination_count": len(table_owners),
+    }
+
+
+def _assert_model_parameter_not_direct(value: object, *, label: str) -> None:
+    if isinstance(value, Mapping):
+        if value.get("kind") in {
+            "compiled-plane-arena-stage",
+            COMPILED_STAGE_PLAN_KIND,
+        }:
+            raise GateError(
+                f"{label} illegally uses a compiled plane DirectApplication"
+            )
+        if "compiled_plane_arena" in value or "native_direct_application" in value:
+            raise GateError(f"{label} illegally carries DirectApplication metadata")
+        if value.get("application_abi") in {
+            COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+            NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+        }:
+            raise GateError(f"{label} illegally uses the direct application ABI")
+        for name, child in value.items():
+            _assert_model_parameter_not_direct(child, label=f"{label}.{name}")
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        for index, child in enumerate(value):
+            _assert_model_parameter_not_direct(child, label=f"{label}[{index}]")
+
+
+def _walk_mappings(
+    value: object,
+    *,
+    path: tuple[str, ...] = (),
+) -> Iterable[tuple[tuple[str, ...], Mapping[str, Any]]]:
+    if isinstance(value, Mapping):
+        yield path, value
+        for name, child in value.items():
+            yield from _walk_mappings(child, path=(*path, str(name)))
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        for index, child in enumerate(value):
+            yield from _walk_mappings(child, path=(*path, str(index)))
+
+
+def _audit_execution_payload(payload: Mapping[str, Any]) -> dict[str, object]:
+    capability_declarations = 0
+    stage_set_count = 0
+    stage_count = 0
+    descriptor_count = 0
+    leaf_count = 0
+    kernel_count = 0
+    island_count = 0
+    invocation_count = 0
+    attachment_count = 0
+    residual_destination_count = 0
+    table_destination_count = 0
+    model_parameter_slot_count = 0
+    model_parameter_evaluator_count = 0
+    for path, record in _walk_mappings(payload):
+        label = ".".join(path) or "execution"
+        capabilities = record.get("required_runtime_capabilities")
+        if (
+            isinstance(capabilities, Sequence)
+            and not isinstance(capabilities, (str, bytes))
+            and COMPILED_PLANE_ARENA_CAPABILITY in capabilities
+        ):
+            capability_declarations += 1
+        if "model_parameter_evaluator" in record:
+            model_parameter_slot_count += 1
+            model_parameters = record["model_parameter_evaluator"]
+            if model_parameters is not None:
+                model_parameter_evaluator_count += 1
+                _assert_model_parameter_not_direct(
+                    model_parameters,
+                    label=f"{label}.model_parameter_evaluator",
+                )
+        if record.get("kind") != "generic-dag-stage-evaluator-artifacts":
+            continue
+        stage_set_count += 1
+        if record.get("runtime_available") is not True:
+            raise GateError(f"{label} compiled stage runtime is unavailable")
+        capabilities = _sequence(
+            record.get("required_runtime_capabilities"),
+            label=f"{label}.required_runtime_capabilities",
+        )
+        if COMPILED_PLANE_ARENA_CAPABILITY not in capabilities:
+            raise GateError(
+                f"{label} does not require {COMPILED_PLANE_ARENA_CAPABILITY}"
+            )
+        stages = list(_sequence(record.get("stages"), label=f"{label}.stages"))
+        amplitude = _mapping(
+            record.get("amplitude_stage"),
+            label=f"{label}.amplitude_stage",
+        )
+        all_stages = (*stages, amplitude)
+        if record.get("stage_count") != len(all_stages):
+            raise GateError(f"{label}.stage_count does not cover all stages")
+        for index, raw_stage in enumerate(all_stages):
+            stage = _mapping(raw_stage, label=f"{label}.stages[{index}]")
+            descriptor = _mapping(
+                stage.get("compiled_plane_arena"),
+                label=f"{label}.stages[{index}].compiled_plane_arena",
+            )
+            counts = _audit_direct_descriptor(
+                descriptor,
+                stage=stage,
+                label=f"{label}.stages[{index}]",
+            )
+            stage_count += 1
+            descriptor_count += 1
+            leaf_count += counts["leaf_count"]
+            kernel_count += counts["kernel_count"]
+            island_count += counts["island_count"]
+            invocation_count += counts["invocation_count"]
+            attachment_count += counts["attachment_count"]
+            residual_destination_count += counts["residual_destination_count"]
+            table_destination_count += counts["table_destination_count"]
+    if capability_declarations < 1:
+        raise GateError(
+            f"execution payload does not declare {COMPILED_PLANE_ARENA_CAPABILITY}"
+        )
+    if stage_set_count < 1 or descriptor_count < 1 or leaf_count < 1:
+        raise GateError("execution payload has no complete Direct-Arena stage set")
+    if model_parameter_slot_count < 1:
+        raise GateError("execution payload has no model-parameter evaluator slot")
+    return {
+        "capability": COMPILED_PLANE_ARENA_CAPABILITY,
+        "capability_declaration_count": capability_declarations,
+        "stage_set_count": stage_set_count,
+        "stage_count": stage_count,
+        "descriptor_count": descriptor_count,
+        "leaf_count": leaf_count,
+        "kernel_count": kernel_count,
+        "island_count": island_count,
+        "invocation_count": invocation_count,
+        "attachment_count": attachment_count,
+        "residual_destination_count": residual_destination_count,
+        "table_destination_count": table_destination_count,
+        "model_parameter_slot_count": model_parameter_slot_count,
+        "model_parameter_evaluator_count": model_parameter_evaluator_count,
+        "model_parameter_direct_application_count": 0,
+        "passes": True,
+    }
+
+
+def _artifact_identity_and_audit(
+    artifact: Path,
+    lane: Lane,
+) -> tuple[dict[str, object], str]:
+    manifest_path = artifact / "artifact.json"
+    manifest = _json_object(manifest_path, label="artifact manifest")
+    artifact_id = manifest.get("artifact_id")
+    if (
+        not isinstance(artifact_id, str)
+        or SHA256_PATTERN.fullmatch(artifact_id) is None
+    ):
+        raise GateError(f"{lane.name} artifact ID is invalid")
+    processes = _sequence(manifest.get("processes"), label="artifact.processes")
+    if len(processes) != 1:
+        raise GateError(f"{lane.name} artifact must contain exactly one process")
+    process = _mapping(processes[0], label="artifact.processes[0]")
+    if process.get("expression") != PROCESS:
+        raise GateError(f"{lane.name} artifact contains the wrong process")
+    if sorted(process.get("external_pdgs", ())) != list(EXPECTED_EXTERNAL_PDGS):
+        raise GateError(f"{lane.name} does not contain four quark/antiquark pairs")
+    if process.get("color_accuracy") != lane.color_accuracy:
+        raise GateError(f"{lane.name} artifact color accuracy is wrong")
+    capabilities = _sequence(
+        process.get("required_runtime_capabilities"),
+        label="artifact.processes[0].required_runtime_capabilities",
+    )
+    if COMPILED_PLANE_ARENA_CAPABILITY not in capabilities:
+        raise GateError(f"{lane.name} artifact lacks {COMPILED_PLANE_ARENA_CAPABILITY}")
+    process_id = process.get("id")
+    if not isinstance(process_id, str) or not process_id:
+        raise GateError(f"{lane.name} artifact process ID is invalid")
+
+    generation = _mapping(
+        _mapping(manifest.get("extensions"), label="artifact.extensions").get(
+            "generation"
+        ),
+        label="artifact.extensions.generation",
+    )
+    concrete = _sequence(
+        generation.get("concrete_processes"),
+        label="artifact.extensions.generation.concrete_processes",
+    )
+    if len(concrete) != 1:
+        raise GateError(f"{lane.name} generation metadata is ambiguous")
+    filters = _mapping(
+        _mapping(concrete[0], label="concrete process").get("filters"),
+        label="concrete process filters",
+    )
+    if lane.color_accuracy == "lc":
+        if filters.get("lc_flow_layout") != lane.lc_flow_layout:
+            raise GateError(f"{lane.name} generation layout metadata is wrong")
+    elif "lc_flow_layout" in filters:
+        raise GateError(
+            f"{lane.name} generation metadata illegally carries an LC layout"
+        )
+
+    try:
+        effective = tomllib.loads(
+            (artifact / "config" / "effective.toml").read_text(encoding="utf-8")
+        )
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        raise GateError(f"{lane.name} effective configuration is invalid") from error
+    expected_config = (
+        (effective.get("process", {}).get("max_quark_lines"), MAX_QUARK_LINES),
+        (effective.get("color", {}).get("accuracy"), lane.color_accuracy),
+        (effective.get("color", {}).get("lc_flow_layout"), lane.lc_flow_layout),
+        (effective.get("evaluator", {}).get("backend"), "jit"),
+        (effective.get("evaluator", {}).get("execution_mode"), "compiled"),
+        (
+            effective.get("evaluator", {}).get("jit", {}).get("optimization_level"),
+            3,
+        ),
+    )
+    if any(observed != expected for observed, expected in expected_config):
+        raise GateError(f"{lane.name} effective compiled/JIT/O3 configuration drifted")
+
+    payloads = _sequence(manifest.get("payloads"), label="artifact.payloads")
+    payload_bytes = 0
+    for index, raw_payload in enumerate(payloads):
+        payload = _mapping(raw_payload, label=f"artifact.payloads[{index}]")
+        relative = _safe_relative_path(
+            payload.get("path"),
+            label=f"artifact.payloads[{index}].path",
+        )
+        expected_size = payload.get("size_bytes")
+        expected_digest = payload.get("sha256")
+        path = artifact / relative
+        try:
+            size = path.stat().st_size
+        except OSError as error:
+            raise GateError(f"{lane.name} payload is missing: {relative}") from error
+        if (
+            isinstance(expected_size, bool)
+            or not isinstance(expected_size, int)
+            or size != expected_size
+            or not isinstance(expected_digest, str)
+            or _sha256_file(path) != expected_digest
+        ):
+            raise GateError(f"{lane.name} payload identity failed: {relative}")
+        payload_bytes += size
+
+    execution_path = artifact / "processes" / process_id / "execution.json"
+    execution = _json_object(execution_path, label="process execution")
+    if execution.get("color_accuracy") != lane.color_accuracy:
+        raise GateError(f"{lane.name} execution color accuracy is wrong")
+    arena_audit = _audit_execution_payload(execution)
+    identity = {
+        "path": str(artifact.resolve(strict=True)),
+        "artifact_id": artifact_id,
+        "manifest": _file_identity(manifest_path),
+        "tree": _tree_identity(artifact),
+        "payload_count": len(payloads),
+        "payload_bytes": payload_bytes,
+        "effective_configuration": {
+            "max_quark_lines": MAX_QUARK_LINES,
+            "color_accuracy": lane.color_accuracy,
+            "lc_flow_layout": lane.lc_flow_layout,
+            "backend": "jit",
+            "execution_mode": "compiled",
+            "jit_optimization_level": 3,
+        },
+        "direct_arena_audit": arena_audit,
+    }
+    return identity, process_id
+
+
+def _deterministic_points(count: int) -> tuple[tuple[tuple[float, ...], ...], ...]:
+    from pyamplicol.generation.phase_space import massive_rambo_final_state
+
+    if count not in (2, 3):
+        raise GateError("the numerical gate requires exactly two or three points")
+    incoming = (
+        (SQRT_S / 2.0, 0.0, 0.0, SQRT_S / 2.0),
+        (SQRT_S / 2.0, 0.0, 0.0, -SQRT_S / 2.0),
+    )
+    return tuple(
+        (
+            *incoming,
+            *massive_rambo_final_state(
+                6,
+                sqrt_s=SQRT_S,
+                masses=(0.0,) * 6,
+                seed=seed,
+            ),
+        )
+        for seed in POINT_SEEDS[:count]
+    )
+
+
+def _as_complex(value: object) -> complex:
+    try:
+        result = complex(value)
+    except (TypeError, ValueError, OverflowError) as error:
+        raise GateError(
+            f"evaluation returned a non-numeric value: {value!r}"
+        ) from error
+    if not math.isfinite(result.real) or not math.isfinite(result.imag):
+        raise GateError("evaluation returned a non-finite value")
+    return result
+
+
+def _flatten_resolved(resolved: object) -> tuple[complex, ...]:
+    return tuple(
+        _as_complex(value)
+        for point in resolved.values
+        for helicity in point
+        for value in helicity
+    )
+
+
+def _resolved_value_digest(resolved: object) -> str:
+    return _canonical_sha256(
+        [
+            [[str(value) for value in helicity] for helicity in point]
+            for point in resolved.values
+        ]
+    )
+
+
+def _points_identity(
+    points: Sequence[Sequence[Sequence[float]]],
+) -> dict[str, object]:
+    hexadecimal = [
+        [[float(component).hex() for component in momentum] for momentum in point]
+        for point in points
+    ]
+    maximum_conservation_residual = 0.0
+    maximum_mass_squared = 0.0
+    for point in points:
+        incoming = point[:2]
+        outgoing = point[2:]
+        for component in range(4):
+            residual = sum(momentum[component] for momentum in incoming) - sum(
+                momentum[component] for momentum in outgoing
+            )
+            maximum_conservation_residual = max(
+                maximum_conservation_residual,
+                float(abs(residual)),
+            )
+        for momentum in point:
+            mass_squared = momentum[0] ** 2 - sum(value**2 for value in momentum[1:])
+            maximum_mass_squared = max(
+                maximum_mass_squared,
+                float(abs(mass_squared)),
+            )
+    if maximum_conservation_residual > 1.0e-9 or maximum_mass_squared > 1.0e-8:
+        raise GateError("deterministic validation momenta are not physical")
+    return {
+        "algorithm": "sha256-float-hex-momenta-v1",
+        "sha256": _canonical_sha256(hexadecimal),
+        "point_count": len(points),
+        "external_particle_count": len(points[0]) if points else 0,
+        "maximum_momentum_conservation_residual": maximum_conservation_residual,
+        "maximum_abs_mass_squared": maximum_mass_squared,
+    }
+
+
+def _comparison(
+    left: Sequence[complex],
+    right: Sequence[complex],
+    *,
+    label: str,
+) -> dict[str, object]:
+    if len(left) != len(right) or not left:
+        raise GateError(f"{label} vectors have incompatible or empty shapes")
+    maximum_absolute = 0.0
+    maximum_relative = 0.0
+    failing = 0
+    for left_value, right_value in zip(left, right, strict=True):
+        absolute = abs(left_value - right_value)
+        relative = absolute / max(abs(left_value), abs(right_value), ABSOLUTE_TOLERANCE)
+        maximum_absolute = max(maximum_absolute, absolute)
+        maximum_relative = max(maximum_relative, relative)
+        if absolute > ABSOLUTE_TOLERANCE and relative > RELATIVE_TOLERANCE:
+            failing += 1
+    result = {
+        "label": label,
+        "value_count": len(left),
+        "maximum_absolute_difference": maximum_absolute,
+        "maximum_relative_difference": maximum_relative,
+        "relative_tolerance": RELATIVE_TOLERANCE,
+        "absolute_tolerance": ABSOLUTE_TOLERANCE,
+        "failing_value_count": failing,
+        "passes": failing == 0,
+    }
+    if failing:
+        raise GateError(
+            f"{label} failed for {failing}/{len(left)} values "
+            f"(max relative {maximum_relative:.3e})"
+        )
+    return result
+
+
+def _complex_vector_digest(values: Sequence[complex]) -> str:
+    return _canonical_sha256([[value.real.hex(), value.imag.hex()] for value in values])
+
+
+def _physics_axes(physics: object) -> dict[str, object]:
+    return {
+        "process_id": physics.process_id,
+        "process": physics.process,
+        "color_accuracy": physics.color_accuracy,
+        "external_pdgs": [particle.pdg_id for particle in physics.external_particles],
+        "helicities": [
+            {
+                "id": item.id,
+                "values": list(item.values),
+                "computed": item.computed,
+                "representative_id": item.representative_id,
+                "coefficient": item.coefficient,
+            }
+            for item in physics.helicities
+        ],
+        "color_flows": [
+            {
+                "id": item.id,
+                "word": list(item.word),
+                "computed": item.computed,
+                "representative_id": item.representative_id,
+                "coefficient": item.coefficient,
+            }
+            for item in physics.color_flows
+        ],
+        "contracted_color_ids": [
+            item.id for item in physics.contracted_color_components
+        ],
+        "selector_capabilities": list(physics.selector_capabilities),
+        "reduction_kind": physics.reduction.kind,
+    }
+
+
+def _select_helicity_probe(physics: Any, *, lane_name: str) -> tuple[Any, int]:
+    eligible = tuple(
+        helicity
+        for helicity in physics.helicities
+        if helicity.computed
+        and not helicity.structural_zero
+        and helicity.coefficient != 0.0
+        and helicity.representative_id == helicity.id
+    )
+    if not eligible:
+        raise GateError(f"{lane_name} has no executable helicity selector probe")
+    return eligible[len(eligible) // 2], len(eligible)
+
+
+def _evaluate_artifact(
+    artifact: Path,
+    *,
+    process_id: str,
+    lane: Lane,
+    points: tuple[tuple[tuple[float, ...], ...], ...],
+) -> tuple[dict[str, object], EvaluationCapture]:
+    from pyamplicol import Runtime
+
+    runtime = Runtime.load(artifact, process=process_id)
+    if runtime.execution_mode != "compiled":
+        raise GateError(f"{lane.name} runtime did not load the compiled lane")
+    if runtime.artifact_id != _json_object(
+        artifact / "artifact.json", label="artifact manifest"
+    ).get("artifact_id"):
+        raise GateError(f"{lane.name} native runtime authenticated another artifact")
+    physics = runtime.physics
+    observed_pdgs = sorted(particle.pdg_id for particle in physics.external_particles)
+    if observed_pdgs != list(EXPECTED_EXTERNAL_PDGS):
+        raise GateError(f"{lane.name} runtime does not expose four quark lines")
+    if physics.color_accuracy != lane.color_accuracy:
+        raise GateError(f"{lane.name} runtime color accuracy is wrong")
+    if lane.contracted:
+        if (
+            physics.color_flows
+            or len(physics.contracted_color_components) != 1
+            or physics.reduction.kind != "contracted-color"
+        ):
+            raise GateError(f"{lane.name} did not expose contracted color")
+    elif (
+        not physics.color_flows
+        or physics.contracted_color_components
+        or physics.reduction.kind != "lc-diagonal"
+    ):
+        raise GateError(f"{lane.name} did not expose physical LC flows")
+
+    direct_profiles = {
+        "complete": _profile_compiled_runtime(runtime, points),
+    }
+    f64_total = tuple(_as_complex(value) for value in runtime.evaluate(points))
+    exact_total_raw = runtime.evaluate(points, precision=32)
+    exact_total = tuple(_as_complex(value) for value in exact_total_raw)
+    f64_resolved = runtime.evaluate_resolved(points)
+    exact_resolved = runtime.evaluate_resolved(points, precision=32)
+    if (
+        tuple(f64_resolved.helicity_ids) != physics.helicity_ids
+        or tuple(exact_resolved.helicity_ids) != physics.helicity_ids
+        or tuple(f64_resolved.color_ids) != physics.color_ids
+        or tuple(exact_resolved.color_ids) != physics.color_ids
+    ):
+        raise GateError(f"{lane.name} resolved physical axes drifted")
+    f64_components = _flatten_resolved(f64_resolved)
+    exact_components = _flatten_resolved(exact_resolved)
+    f64_resolved_total = tuple(_as_complex(value) for value in f64_resolved.total())
+    exact_resolved_total = tuple(_as_complex(value) for value in exact_resolved.total())
+
+    comparisons = {
+        "f64_vs_precision32_total": _comparison(
+            f64_total, exact_total, label=f"{lane.name} f64/precision32 totals"
+        ),
+        "f64_vs_precision32_components": _comparison(
+            f64_components,
+            exact_components,
+            label=f"{lane.name} f64/precision32 resolved components",
+        ),
+        "f64_evaluate_vs_resolved_total": _comparison(
+            f64_total,
+            f64_resolved_total,
+            label=f"{lane.name} f64 evaluate/resolved total",
+        ),
+        "precision32_evaluate_vs_resolved_total": _comparison(
+            exact_total,
+            exact_resolved_total,
+            label=f"{lane.name} precision32 evaluate/resolved total",
+        ),
+    }
+
+    helicity, eligible_helicity_count = _select_helicity_probe(
+        physics, lane_name=lane.name
+    )
+    helicity_id = helicity.id
+    helicity_probe = tuple(
+        _as_complex(value)
+        for value in runtime.evaluate(points, helicities=(helicity_id,))
+    )
+    helicity_resolved = runtime.evaluate_resolved(points, helicities=(helicity_id,))
+    comparisons["helicity_selector_evaluate_vs_resolved_total"] = _comparison(
+        helicity_probe,
+        tuple(_as_complex(value) for value in helicity_resolved.total()),
+        label=f"{lane.name} helicity selector evaluate/resolved total",
+    )
+    direct_profiles["helicity_selector"] = _profile_compiled_runtime(
+        runtime,
+        points,
+        helicities=(helicity_id,),
+    )
+    color_id: str | None = None
+    color_probe: tuple[complex, ...] | None = None
+    if physics.color_flow_ids:
+        color_id = physics.color_flow_ids[len(physics.color_flow_ids) // 2]
+        color_probe = tuple(
+            _as_complex(value)
+            for value in runtime.evaluate(points, color_flows=(color_id,))
+        )
+        color_resolved = runtime.evaluate_resolved(points, color_flows=(color_id,))
+        comparisons["color_selector_evaluate_vs_resolved_total"] = _comparison(
+            color_probe,
+            tuple(_as_complex(value) for value in color_resolved.total()),
+            label=f"{lane.name} color selector evaluate/resolved total",
+        )
+        direct_profiles["color_selector"] = _profile_compiled_runtime(
+            runtime,
+            points,
+            color_flows=(color_id,),
+        )
+        direct_profiles["combined_selector"] = _profile_compiled_runtime(
+            runtime,
+            points,
+            helicities=(helicity_id,),
+            color_flows=(color_id,),
+        )
+
+    axes = _physics_axes(physics)
+    capture = EvaluationCapture(
+        physics_axes=axes,
+        f64_total=f64_total,
+        exact_total=exact_total,
+        f64_components=f64_components,
+        exact_components=exact_components,
+        color_probe=color_probe,
+        helicity_probe=helicity_probe,
+    )
+    evidence = {
+        "point_count": len(points),
+        "point_seeds": list(POINT_SEEDS[: len(points)]),
+        "sqrt_s": SQRT_S,
+        "physics_axes": {
+            **axes,
+            "canonical_sha256": _canonical_sha256(axes),
+        },
+        "f64_total": [[value.real, value.imag] for value in f64_total],
+        "precision32_total_decimal": [str(value) for value in exact_total_raw],
+        "resolved": {
+            "shape": list(f64_resolved.shape),
+            "component_count": len(f64_components),
+            "f64_component_digest": _complex_vector_digest(f64_components),
+            "precision32_component_decimal_digest": _resolved_value_digest(
+                exact_resolved
+            ),
+            "precision32_decimal_digits": 32,
+        },
+        "selector_probes": {
+            "helicity_id": helicity_id,
+            "helicity": {
+                "id": helicity.id,
+                "index": helicity.index,
+                "values": list(helicity.values),
+                "computed": helicity.computed,
+                "structural_zero": helicity.structural_zero,
+                "representative_id": helicity.representative_id,
+                "coefficient": helicity.coefficient,
+            },
+            "eligible_helicity_count": eligible_helicity_count,
+            "color_flow_id": color_id,
+        },
+        "runtime_execution": {
+            "execution_mode": runtime.execution_mode,
+            "direct_arena_profiles": direct_profiles,
+        },
+        "comparisons": comparisons,
+        "finite_value_count": (
+            len(f64_total)
+            + len(exact_total)
+            + len(f64_components)
+            + len(exact_components)
+            + len(helicity_probe)
+            + (0 if color_probe is None else len(color_probe))
+        ),
+        "passes": True,
+    }
+    return evidence, capture
+
+
+def _profile_compiled_runtime(
+    runtime: object,
+    points: object,
+    *,
+    helicities: tuple[str, ...] | None = None,
+    color_flows: tuple[str, ...] | None = None,
+) -> dict[str, object]:
+    profiler = getattr(runtime, "profile", None)
+    surface = "Runtime.profile"
+    if not callable(profiler):
+        backend = getattr(runtime, "_backend", None)
+        profiler = getattr(backend, "profile", None)
+        surface = "native runtime adapter profile"
+    if not callable(profiler):
+        raise GateError(
+            "installed public/runtime-adapter API exposes no profiler; "
+            "compiled Direct-Arena activity cannot be proven"
+        )
+    payload = profiler(
+        points,
+        helicities=helicities,
+        color_flows=color_flows,
+        precision=16,
+        include_values=False,
+    )
+    return {
+        **_audit_compiled_direct_profile(payload),
+        "surface": surface,
+        "helicity_selector_count": 0 if helicities is None else len(helicities),
+        "color_selector_count": 0 if color_flows is None else len(color_flows),
+    }
+
+
+def _audit_compiled_direct_profile(profile: object) -> dict[str, object]:
+    """Require observed Direct-Arena work and no legacy evaluator boundaries."""
+
+    payload = _mapping(profile, label="compiled runtime profile")
+    if payload.get("execution_mode") != "compiled":
+        raise GateError("compiled runtime profile reports another execution mode")
+    engines = payload.get("compiled_direct_arena_engine_count")
+    if isinstance(engines, bool) or not isinstance(engines, int) or engines <= 0:
+        raise GateError("compiled Direct-Arena profile observed no Arena engines")
+    calls = payload.get("compiled_direct_arena_call_count")
+    if isinstance(calls, bool) or not isinstance(calls, int) or calls <= 0:
+        raise GateError("compiled Direct-Arena profile observed no backend calls")
+    backend_calls = payload.get("evaluator_backend_call_count")
+    if (
+        isinstance(backend_calls, bool)
+        or not isinstance(backend_calls, int)
+        or backend_calls <= 0
+        or backend_calls != calls
+    ):
+        raise GateError(
+            "compiled Direct-Arena calls do not cover every evaluator backend call"
+        )
+    boundary_counts: dict[str, int] = {}
+    for field in _ZERO_PROFILE_COUNTERS:
+        value = payload.get(field)
+        if isinstance(value, bool) or not isinstance(value, int) or value != 0:
+            raise GateError(
+                "compiled Direct-Arena profile observed legacy boundary traffic: "
+                f"{field}={value!r}"
+            )
+        boundary_counts[field] = value
+    boundary_times: dict[str, float] = {}
+    for field in _ZERO_PROFILE_TIMES:
+        value = payload.get(field)
+        if (
+            isinstance(value, bool)
+            or not isinstance(value, (int, float))
+            or not math.isfinite(float(value))
+            or float(value) != 0.0
+        ):
+            raise GateError(
+                "compiled Direct-Arena profile observed legacy boundary timing: "
+                f"{field}={value!r}"
+            )
+        boundary_times[field] = float(value)
+    return {
+        "compiled_direct_arena_engine_count": engines,
+        "compiled_direct_arena_call_count": calls,
+        "evaluator_backend_call_count": backend_calls,
+        "legacy_boundary_component_counts": boundary_counts,
+        "legacy_boundary_component_total": sum(boundary_counts.values()),
+        "legacy_boundary_times_seconds": boundary_times,
+        "passes": True,
+    }
+
+
+def _cross_lc_parity(
+    topology: EvaluationCapture,
+    union: EvaluationCapture,
+) -> dict[str, object]:
+    axes_match = topology.physics_axes == union.physics_axes
+    if not axes_match:
+        raise GateError("LC topology-replay and union physical axes differ")
+    if topology.color_probe is None or union.color_probe is None:
+        raise GateError("LC selector comparison has no physical color probe")
+    comparisons = {
+        "f64_totals": _comparison(
+            topology.f64_total,
+            union.f64_total,
+            label="LC topology/union f64 totals",
+        ),
+        "precision32_totals": _comparison(
+            topology.exact_total,
+            union.exact_total,
+            label="LC topology/union precision32 totals",
+        ),
+        "f64_resolved_components": _comparison(
+            topology.f64_components,
+            union.f64_components,
+            label="LC topology/union f64 resolved components",
+        ),
+        "precision32_resolved_components": _comparison(
+            topology.exact_components,
+            union.exact_components,
+            label="LC topology/union precision32 resolved components",
+        ),
+        "color_selector": _comparison(
+            topology.color_probe,
+            union.color_probe,
+            label="LC topology/union color selector",
+        ),
+        "helicity_selector": _comparison(
+            topology.helicity_probe,
+            union.helicity_probe,
+            label="LC topology/union helicity selector",
+        ),
+    }
+    return {
+        "physical_axes_match": axes_match,
+        "physical_axes_sha256": _canonical_sha256(topology.physics_axes),
+        "comparisons": comparisons,
+        "passes": True,
+    }
+
+
+def _attach_content_identity(body: Mapping[str, object]) -> dict[str, object]:
+    result = dict(body)
+    result["content_identity"] = {
+        "algorithm": "sha256-canonical-json-body-v1",
+        "sha256": _canonical_sha256(body),
+    }
+    return result
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    encoded = json.dumps(
+        payload,
+        allow_nan=False,
+        ensure_ascii=False,
+        indent=2,
+        sort_keys=True,
+    )
+    try:
+        temporary.write_text(encoded + "\n", encoding="utf-8")
+        temporary.replace(path)
+    except OSError as error:
+        temporary.unlink(missing_ok=True)
+        raise GateError(f"cannot write evidence: {path}") from error
+
+
+def _prepare_output_root(output_root: Path, *, replace: bool) -> Path:
+    root = output_root.expanduser().resolve(strict=False)
+    if root == ROOT or root == Path(root.anchor):
+        raise GateError("refusing a broad output root")
+    if root.exists():
+        if not root.is_dir():
+            raise GateError(f"output root is not a directory: {root}")
+        occupied = [lane for lane in LANES if (root / lane.name).exists()]
+        if occupied and not replace:
+            names = ", ".join(lane.name for lane in occupied)
+            raise GateError(f"artifact lanes already exist ({names}); pass --replace")
+        if replace:
+            for lane in LANES:
+                target = root / lane.name
+                if target.exists():
+                    shutil.rmtree(target)
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def run_gate(arguments: argparse.Namespace) -> dict[str, object]:
+    source = _source_identity()
+    runtime = _runtime_identity(source)
+    script = _file_identity(Path(__file__))
+    runtime_sha256 = _runtime_identity_sha256(runtime)
+    union_rejections = _assert_union_rejections()
+    output_root = _prepare_output_root(
+        arguments.output_root,
+        replace=arguments.replace,
+    )
+    points = _deterministic_points(arguments.points)
+    points_identity = _points_identity(points)
+    lanes: dict[str, dict[str, object]] = {}
+    captures: dict[str, EvaluationCapture] = {}
+    failures: list[dict[str, str]] = []
+    started = time.monotonic()
+    for lane in LANES:
+        artifact = output_root / lane.name
+        try:
+            generation = _invoke_generation_worker(
+                artifact,
+                lane,
+                timeout=arguments.generation_timeout,
+                expected_revision=str(source["revision"]),
+                expected_runtime_sha256=runtime_sha256,
+                expected_script_sha256=str(script["sha256"]),
+            )
+            identity, process_id = _artifact_identity_and_audit(artifact, lane)
+            numerical, capture = _evaluate_artifact(
+                artifact,
+                process_id=process_id,
+                lane=lane,
+                points=points,
+            )
+            lanes[lane.name] = {
+                "configuration": {
+                    "process": PROCESS,
+                    "max_quark_lines": MAX_QUARK_LINES,
+                    "color_accuracy": lane.color_accuracy,
+                    "lc_flow_layout": lane.lc_flow_layout,
+                    "contracted_color": lane.contracted,
+                    "backend": "jit",
+                    "execution_mode": "compiled",
+                    "jit_optimization_level": 3,
+                },
+                "generation": generation,
+                "artifact_identity": identity,
+                "numerical_validation": numerical,
+                "passes": True,
+            }
+            captures[lane.name] = capture
+        except (GateError, OSError, RuntimeError, ValueError) as error:
+            failures.append(
+                {
+                    "lane": lane.name,
+                    "error_type": type(error).__name__,
+                    "message": str(error),
+                }
+            )
+            lanes[lane.name] = {
+                "configuration": {
+                    "process": PROCESS,
+                    "max_quark_lines": MAX_QUARK_LINES,
+                    "color_accuracy": lane.color_accuracy,
+                    "lc_flow_layout": lane.lc_flow_layout,
+                    "contracted_color": lane.contracted,
+                    "backend": "jit",
+                    "execution_mode": "compiled",
+                    "jit_optimization_level": 3,
+                },
+                "passes": False,
+            }
+    cross_lc: dict[str, object] | None = None
+    if {"lc-topology-replay", "lc-all-flow-union"} <= captures.keys():
+        try:
+            cross_lc = _cross_lc_parity(
+                captures["lc-topology-replay"],
+                captures["lc-all-flow-union"],
+            )
+        except GateError as error:
+            failures.append(
+                {
+                    "lane": "lc-cross-layout",
+                    "error_type": type(error).__name__,
+                    "message": str(error),
+                }
+            )
+            cross_lc = {"passes": False, "message": str(error)}
+    else:
+        cross_lc = {
+            "passes": False,
+            "message": "both LC captures are required",
+        }
+    source_postflight = _source_identity()
+    runtime_postflight = _runtime_identity(source_postflight)
+    script_postflight = _file_identity(Path(__file__))
+    if source_postflight != source:
+        raise GateError("source identity changed during the four-quark gate")
+    if _stable_runtime_identity(runtime_postflight) != _stable_runtime_identity(
+        runtime
+    ):
+        raise GateError("candidate runtime identity changed during the four-quark gate")
+    if script_postflight != script:
+        raise GateError("gate script identity changed during the four-quark gate")
+    passed = (
+        not failures
+        and all(lane.get("passes") is True for lane in lanes.values())
+        and cross_lc.get("passes") is True
+    )
+    body = {
+        "kind": RESULT_KIND,
+        "schema_version": SCHEMA_VERSION,
+        "status": "ok" if passed else "validation_failed",
+        "passes": passed,
+        "request": {
+            "process": PROCESS,
+            "independent_quark_line_count": 4,
+            "expected_external_pdgs": list(EXPECTED_EXTERNAL_PDGS),
+            "max_quark_lines": MAX_QUARK_LINES,
+            "point_count": arguments.points,
+            "point_seeds": list(POINT_SEEDS[: arguments.points]),
+            "momenta_identity": points_identity,
+            "relative_tolerance": RELATIVE_TOLERANCE,
+            "absolute_tolerance": ABSOLUTE_TOLERANCE,
+            "mandatory_watchdog_command": WATCHDOG_INVOCATION,
+            "memory_limit_gib": 30,
+        },
+        "source_identity": source,
+        "source_identity_postflight": source_postflight,
+        "source_identity_match": True,
+        "runtime_identity": runtime,
+        "runtime_identity_postflight": runtime_postflight,
+        "runtime_identity_match": True,
+        "gate_script_identity": script,
+        "gate_script_identity_postflight": script_postflight,
+        "gate_script_identity_match": True,
+        "invalid_union_configurations": union_rejections,
+        "lanes": lanes,
+        "lc_cross_layout_parity": cross_lc,
+        "resources": {
+            "orchestration_wall_seconds": time.monotonic() - started,
+            "orchestrator_peak_rss_gib": _peak_rss_gib(),
+            "mandatory_process_tree_limit_gib": 30,
+        },
+        "failures": failures,
+    }
+    return _attach_content_identity(body)
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(
+        description=__doc__,
+        epilog=f"Mandatory invocation: {WATCHDOG_INVOCATION}",
+    )
+    result.add_argument("--output-root", type=Path)
+    result.add_argument(
+        "--evidence",
+        type=Path,
+        help="default: OUTPUT_ROOT/four-quark-compiled-gate.json",
+    )
+    result.add_argument(
+        "--points",
+        type=int,
+        choices=(2, 3),
+        default=2,
+        help="number of deterministic physical points (default: 2)",
+    )
+    result.add_argument(
+        "--generation-timeout",
+        type=float,
+        default=10_800.0,
+        help="per-lane generation timeout in seconds",
+    )
+    result.add_argument(
+        "--replace",
+        action="store_true",
+        help="remove only the four named lane directories before generation",
+    )
+    result.add_argument("--_generate-one", action="store_true", help=argparse.SUPPRESS)
+    result.add_argument("--artifact", type=Path, help=argparse.SUPPRESS)
+    result.add_argument(
+        "--lane",
+        choices=tuple(lane.name for lane in LANES),
+        help=argparse.SUPPRESS,
+    )
+    result.add_argument(
+        "--expected-script-sha256",
+        help=argparse.SUPPRESS,
+    )
+    result.add_argument("--expected-revision", help=argparse.SUPPRESS)
+    result.add_argument("--expected-runtime-sha256", help=argparse.SUPPRESS)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    _establish_preimport_runtime_identity()
+    if arguments._generate_one:
+        if arguments.artifact is None or arguments.lane is None:
+            parser().error("--_generate-one requires --artifact and --lane")
+        if (
+            not isinstance(arguments.expected_script_sha256, str)
+            or SHA256_PATTERN.fullmatch(arguments.expected_script_sha256) is None
+            or not isinstance(arguments.expected_revision, str)
+            or REVISION_PATTERN.fullmatch(arguments.expected_revision) is None
+            or not isinstance(arguments.expected_runtime_sha256, str)
+            or SHA256_PATTERN.fullmatch(arguments.expected_runtime_sha256) is None
+        ):
+            parser().error(
+                "--_generate-one requires full source/runtime/script identities"
+            )
+        if _sha256_file(Path(__file__)) != arguments.expected_script_sha256:
+            print(
+                "four-quark-compiled-gate worker: gate script identity mismatch",
+                file=sys.stderr,
+            )
+            return 2
+        lane = next(item for item in LANES if item.name == arguments.lane)
+        try:
+            payload = _generation_worker(
+                arguments.artifact,
+                lane,
+                expected_revision=arguments.expected_revision,
+                expected_runtime_sha256=arguments.expected_runtime_sha256,
+                expected_script_sha256=arguments.expected_script_sha256,
+            )
+        except (GateError, OSError, RuntimeError, ValueError) as error:
+            print(f"four-quark-compiled-gate worker: {error}", file=sys.stderr)
+            return 2
+        print(json.dumps(payload, allow_nan=False, sort_keys=True))
+        return 0
+    if arguments.output_root is None:
+        parser().error("--output-root is required")
+    if arguments.generation_timeout <= 0 or not math.isfinite(
+        arguments.generation_timeout
+    ):
+        parser().error("--generation-timeout must be positive and finite")
+    evidence_path = (
+        arguments.evidence
+        if arguments.evidence is not None
+        else arguments.output_root / "four-quark-compiled-gate.json"
+    )
+    try:
+        result = run_gate(arguments)
+        _write_json_atomic(evidence_path.expanduser().resolve(strict=False), result)
+    except (GateError, OSError, RuntimeError, ValueError) as error:
+        print(f"four-quark-compiled-gate: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, allow_nan=False, indent=2, sort_keys=True))
+    return 0 if result["passes"] else 1
+
+
+if __name__ == "__main__":
+    _ensure_source_only_python()
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/generation_slice.py b/pyamplicol/tools/developer/generation_slice.py
new file mode 100644
index 0000000000..543ab0aea4
--- /dev/null
+++ b/pyamplicol/tools/developer/generation_slice.py
@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Developer-only generation of deliberately specialized process artifacts.
+
+Production generation always targets complete physical coverage. Performance
+campaigns occasionally need an artifact specialized to one LC flow or one
+source-helicity configuration so it can be compared with an equally
+specialized reference implementation. This module keeps those unstable
+topology controls out of the public TOML, CLI, and Python API.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+import pyamplicol as _pyamplicol
+from pyamplicol.api.requests import (
+    ModelSource,
+    ProcessRequest,
+    ProcessSet,
+)
+from pyamplicol.api.results import GenerationResult
+from pyamplicol.api.services import _generation_resource_resolution
+from pyamplicol.config import ConfigResolution, GenerationConfig, RunConfig
+from pyamplicol.generation.service import GenerationBackend, _ProcessSelection
+from pyamplicol.reporting import ProgressSink
+
+
+def _positive_unique(values: Iterable[int], name: str) -> tuple[int, ...]:
+    result = tuple(values)
+    if any(
+        isinstance(value, bool) or not isinstance(value, int) or value < 1
+        for value in result
+    ):
+        raise ValueError(f"{name} must contain positive integer labels")
+    if len(set(result)) != len(result):
+        raise ValueError(f"{name} must contain unique labels")
+    return result
+
+
+def _nonnegative_unique(values: Iterable[int], name: str) -> frozenset[int]:
+    result = tuple(values)
+    if any(
+        isinstance(value, bool) or not isinstance(value, int) or value < 0
+        for value in result
+    ):
+        raise ValueError(f"{name} must contain non-negative integer IDs")
+    if len(set(result)) != len(result):
+        raise ValueError(f"{name} must contain unique IDs")
+    return frozenset(result)
+
+
+@dataclass(frozen=True, slots=True)
+class GenerationSlice:
+    """Unstable developer selection for one specialized generation run."""
+
+    reference_color_order: tuple[int, ...] = ()
+    selected_color_sector_ids: tuple[int, ...] = ()
+    selected_source_helicities: Mapping[int, int] | None = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "reference_color_order",
+            _positive_unique(
+                self.reference_color_order,
+                "reference_color_order",
+            ),
+        )
+        selected_ids = _nonnegative_unique(
+            self.selected_color_sector_ids,
+            "selected_color_sector_ids",
+        )
+        object.__setattr__(
+            self,
+            "selected_color_sector_ids",
+            tuple(sorted(selected_ids)),
+        )
+        raw_helicities = self.selected_source_helicities or {}
+        normalized_helicities: dict[int, int] = {}
+        for label, helicity in raw_helicities.items():
+            if isinstance(label, bool) or not isinstance(label, int) or label < 1:
+                raise ValueError(
+                    "selected_source_helicities keys must be positive integer labels"
+                )
+            if isinstance(helicity, bool) or not isinstance(helicity, int):
+                raise ValueError(
+                    "selected_source_helicities values must be integer helicities"
+                )
+            normalized_helicities[label] = helicity
+        object.__setattr__(
+            self,
+            "selected_source_helicities",
+            normalized_helicities or None,
+        )
+
+    def _selection(self) -> _ProcessSelection:
+        return _ProcessSelection(
+            reference_color_order=self.reference_color_order or None,
+            selected_color_sector_ids=(
+                frozenset(self.selected_color_sector_ids)
+                if self.selected_color_sector_ids
+                else None
+            ),
+            selected_source_helicities=self.selected_source_helicities,
+        )
+
+
+def _process_set(
+    processes: ProcessSet | ProcessRequest | str | Iterable[ProcessRequest | str],
+) -> ProcessSet:
+    if isinstance(processes, ProcessSet):
+        return processes
+    if isinstance(processes, ProcessRequest):
+        return ProcessSet((processes,))
+    if isinstance(processes, str):
+        return ProcessSet((ProcessRequest.parse(processes),))
+    return ProcessSet(
+        tuple(
+            process
+            if isinstance(process, ProcessRequest)
+            else ProcessRequest.parse(process)
+            for process in processes
+        )
+    )
+
+
+def generate_slice(
+    processes: ProcessSet | ProcessRequest | str | Iterable[ProcessRequest | str],
+    output: os.PathLike[str] | str,
+    *,
+    selection: GenerationSlice,
+    model: ModelSource | _pyamplicol.CompiledModel | None = None,
+    mode: Literal["error", "append", "replace"] = "error",
+    config: GenerationConfig | RunConfig | ConfigResolution | None = None,
+    progress: ProgressSink | None = None,
+) -> GenerationResult:
+    """Generate one benchmark-only artifact with an explicit topology slice."""
+
+    if not isinstance(selection, GenerationSlice):
+        raise TypeError("selection must be a GenerationSlice")
+    resolved = _generation_resource_resolution(config)
+    backend = GenerationBackend(
+        resolved,
+        progress,
+        process_selection=selection._selection(),
+    )
+    return backend.generate(
+        _process_set(processes),
+        Path(os.fspath(output)).expanduser().resolve(strict=False),
+        model=model,
+        mode=mode,
+    )
+
+
+__all__ = ["GenerationSlice", "generate_slice"]
diff --git a/pyamplicol/tools/developer/heft_madgraph_acceptance.py b/pyamplicol/tools/developer/heft_madgraph_acceptance.py
new file mode 100644
index 0000000000..ed1f7e41d7
--- /dev/null
+++ b/pyamplicol/tools/developer/heft_madgraph_acceptance.py
@@ -0,0 +1,313 @@
+# SPDX-License-Identifier: 0BSD
+"""Compare scalar HEFT matrix elements with MadGraph standalone ``smatrix``.
+
+This developer command prepares the authenticated upstream UFO locally for
+MadGraph and evaluates pyAmpliCol's independently packaged ``built-in-sm-heft``
+model. The UFO and generated artifacts remain under ignored developer
+directories.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import sys
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from pyamplicol import (  # noqa: E402
+    Generator,
+    ModelSource,
+    ProcessRequest,
+    ProcessSet,
+    Runtime,
+)
+from pyamplicol.config import (  # noqa: E402
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    OutputConfig,
+    ProcessConfig,
+    RunConfig,
+)
+from tools.developer.heft_ufo import (  # noqa: E402
+    DEFAULT_HEFT_UFO_ROOT,
+    prepare_heft_ufo,
+)
+from tools.developer.madgraph_correctness import (  # noqa: E402
+    StandaloneMadGraphRunner,
+    set_parameter_card_values,
+)
+
+DEFAULT_OUTPUT_ROOT = ROOT / ".artifacts" / "heft-madgraph-acceptance"
+RELATIVE_TOLERANCE = 1.0e-10
+ABSOLUTE_TOLERANCE = 1.0e-300
+VALIDATION_SEED = 101
+_HEFT_INPUTS = ("aEWM1", "Gf", "aS", "MZ", "MT", "MH")
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessSpec:
+    process_id: str
+    expression: str
+
+
+PROCESSES = (
+    ProcessSpec("gg_h", "g g > H"),
+    ProcessSpec("gg_hg", "g g > H g"),
+    ProcessSpec("gg_hgg", "g g > H g g"),
+    ProcessSpec("gg_hggg", "g g > H g g g"),
+)
+
+
+class HEFTAcceptanceError(RuntimeError):
+    """The scalar HEFT correctness gate could not be established."""
+
+
+def _validation_momenta(
+    artifact: Path,
+    process_id: str,
+) -> tuple[tuple[float, float, float, float], ...]:
+    path = artifact / "processes" / process_id / "validation-momenta.json"
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        if (
+            payload.get("kind") != "pyamplicol-rusticol-validation-momenta"
+            or payload.get("process_id") != process_id
+            or len(payload.get("points", ())) != 1
+        ):
+            raise ValueError("wrong validation metadata")
+        point = payload["points"][0]
+        rows = tuple(
+            tuple(float(component) for component in particle["momentum"])
+            for particle in point
+        )
+    except (KeyError, OSError, TypeError, ValueError, json.JSONDecodeError) as error:
+        raise HEFTAcceptanceError(
+            f"invalid validation point for seed-{VALIDATION_SEED} process set "
+            f"member {process_id}"
+        ) from error
+    if any(
+        len(row) != 4 or any(not math.isfinite(component) for component in row)
+        for row in rows
+    ):
+        raise HEFTAcceptanceError(f"non-finite validation momentum for {process_id}")
+    return rows  # type: ignore[return-value]
+
+
+def _pyamplicol_value(
+    artifact: Path,
+    process_id: str,
+    momenta: tuple[tuple[float, float, float, float], ...],
+) -> float:
+    value = complex(
+        Runtime.load(artifact, process=process_id).evaluate(
+            (momenta,),
+            precision=16,
+        )[0]
+    )
+    if not math.isfinite(value.real) or not math.isfinite(value.imag):
+        raise HEFTAcceptanceError(
+            f"pyAmpliCol returned a non-finite {process_id} value"
+        )
+    if abs(value.imag) > max(ABSOLUTE_TOLERANCE, abs(value.real) * 1.0e-12):
+        raise HEFTAcceptanceError(
+            f"pyAmpliCol returned a non-real {process_id} matrix element"
+        )
+    if value.real == 0.0:
+        raise HEFTAcceptanceError(f"pyAmpliCol returned zero for {process_id}")
+    return value.real
+
+
+def _madgraph_version(installation: Path) -> str | None:
+    path = installation / "VERSION"
+    return (
+        path.read_text(encoding="utf-8", errors="replace").strip()
+        if path.is_file()
+        else None
+    )
+
+
+def run_acceptance(
+    madgraph: Path,
+    *,
+    model_root: Path = DEFAULT_HEFT_UFO_ROOT,
+    output_root: Path = DEFAULT_OUTPUT_ROOT,
+    runner: StandaloneMadGraphRunner | None = None,
+) -> dict[str, object]:
+    """Run the four-process scalar HEFT acceptance gate."""
+
+    model_root = prepare_heft_ufo(model_root)
+    output_root = output_root.expanduser().resolve(strict=False)
+    if output_root.exists():
+        raise HEFTAcceptanceError(
+            f"acceptance output already exists; choose a clean root: {output_root}"
+        )
+    output_root.mkdir(parents=True)
+
+    compiled_model = ModelSource.built_in_sm_heft().compile(
+        use_cache=False,
+        require_supported=True,
+    )
+    parameters = {parameter.name: parameter for parameter in compiled_model.parameters}
+    missing_inputs = sorted(set(_HEFT_INPUTS).difference(parameters))
+    if missing_inputs:
+        raise HEFTAcceptanceError(
+            f"packaged scalar HEFT model lacks inputs: {missing_inputs!r}"
+        )
+    madgraph_inputs = {}
+    for name in _HEFT_INPUTS:
+        parameter = parameters[name]
+        if parameter.default_imaginary != 0.0:
+            raise HEFTAcceptanceError(
+                f"packaged scalar HEFT input {name} is unexpectedly complex"
+            )
+        madgraph_inputs[name] = parameter.default_real
+    process_set = ProcessSet(
+        requests=tuple(
+            ProcessRequest.parse(spec.expression, name=spec.process_id)
+            for spec in PROCESSES
+        )
+    )
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="full"),
+        process=ProcessConfig(
+            coupling_order_policy="explicit",
+            max_coupling_orders={"HIG": 1},
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=True,
+                samples=1,
+                seed=VALIDATION_SEED,
+                relative_tolerance=1.0e-12,
+                absolute_tolerance=ABSOLUTE_TOLERANCE,
+                post_build_validation=True,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            backend="jit",
+            execution_mode="compiled",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+        output=OutputConfig(format="json", color="never", progress="off"),
+    )
+    artifact = output_root / "pyamplicol"
+    Generator(config).generate(
+        process_set,
+        artifact,
+        model=compiled_model,
+        mode="error",
+    )
+
+    madgraph = madgraph.expanduser().resolve(strict=True)
+    standalone_runner = StandaloneMadGraphRunner() if runner is None else runner
+    results: dict[str, dict[str, object]] = {}
+    for spec in PROCESSES:
+        momenta = _validation_momenta(artifact, spec.process_id)
+        pyamplicol_value = _pyamplicol_value(artifact, spec.process_id, momenta)
+        standalone = standalone_runner.generate(
+            installation=madgraph,
+            artifact=output_root / "madgraph" / spec.process_id,
+            process=spec.expression,
+            model_import=os.fspath(model_root),
+            coupling_orders={"HIG": 1},
+        )
+        set_parameter_card_values(
+            standalone.standalone / "Cards" / "param_card.dat",
+            madgraph_inputs,
+        )
+        madgraph_value = standalone_runner.evaluate(
+            standalone,
+            momenta,
+            repetitions=1,
+            warmup_calls=20,
+        ).value
+        if not math.isfinite(madgraph_value) or madgraph_value == 0.0:
+            raise HEFTAcceptanceError(
+                f"MadGraph returned a non-finite or zero {spec.process_id} value"
+            )
+        absolute_deviation = abs(pyamplicol_value - madgraph_value)
+        relative_deviation = absolute_deviation / abs(madgraph_value)
+        if not math.isclose(
+            pyamplicol_value,
+            madgraph_value,
+            rel_tol=RELATIVE_TOLERANCE,
+            abs_tol=ABSOLUTE_TOLERANCE,
+        ):
+            raise HEFTAcceptanceError(
+                f"{spec.process_id} differs from MadGraph: "
+                f"relative deviation {relative_deviation:.17g}"
+            )
+        results[spec.process_id] = {
+            "expression": spec.expression,
+            "pyamplicol": pyamplicol_value,
+            "madgraph": madgraph_value,
+            "relative_deviation": relative_deviation,
+        }
+
+    return {
+        "kind": "pyamplicol-heft-madgraph-acceptance",
+        "model": "built-in-sm-heft",
+        "effective_coupling_momentum_dependent": False,
+        "madgraph_version": _madgraph_version(madgraph),
+        "precision": 16,
+        "validation_seed": VALIDATION_SEED,
+        "relative_tolerance": RELATIVE_TOLERANCE,
+        "absolute_tolerance": ABSOLUTE_TOLERANCE,
+        "processes": results,
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "madgraph",
+        type=Path,
+        help="MadGraph5_aMC installation containing bin/mg5_aMC",
+    )
+    parser.add_argument(
+        "--model-root",
+        type=Path,
+        default=DEFAULT_HEFT_UFO_ROOT,
+        help="ignored destination for the authenticated prepared UFO",
+    )
+    parser.add_argument(
+        "--output-root",
+        type=Path,
+        default=DEFAULT_OUTPUT_ROOT,
+        help="clean ignored destination for generated artifacts",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = _parser().parse_args(argv)
+    try:
+        result = run_acceptance(
+            arguments.madgraph,
+            model_root=arguments.model_root,
+            output_root=arguments.output_root,
+        )
+    except (HEFTAcceptanceError, OSError, RuntimeError, ValueError) as error:
+        raise SystemExit(f"heft-madgraph-acceptance: {error}") from error
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/heft_ufo.py b/pyamplicol/tools/developer/heft_ufo.py
new file mode 100644
index 0000000000..b73db98546
--- /dev/null
+++ b/pyamplicol/tools/developer/heft_ufo.py
@@ -0,0 +1,365 @@
+# SPDX-License-Identifier: 0BSD
+"""Prepare the developer-only scalar Higgs Effective Theory UFO model.
+
+The upstream attachment has no package-manager identity and no explicit
+redistribution terms were found.  This module therefore downloads and checks
+the attachment in place for developer workflows; neither the archive nor the
+prepared UFO belongs in a pyAmpliCol distribution.
+"""
+
+from __future__ import annotations
+
+import ast
+import hashlib
+import io
+import shutil
+import tarfile
+import tempfile
+import urllib.request
+from collections.abc import Callable, Iterable
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+HEFT_UFO_URL = (
+    "https://feynrules.irmp.ucl.ac.be/raw-attachment/wiki/"
+    "HiggsEffectiveTheory/Higgs_Effective_Couplings_UFO.tgz"
+)
+HEFT_UFO_SHA256 = "c7492a8933c01482781936d5e07c64e4e72a2a78af026b6000084b64ec022356"
+HEFT_UFO_ARCHIVE_ROOT = "Higgs_Effective_Couplings_UFO"
+DEFAULT_HEFT_UFO_ROOT = ROOT / "dependencies" / "checkouts" / "heft-ufo"
+
+_UPSTREAM_FILES = frozenset(
+    {
+        "Higgs_Effective_Couplings_UFO.log",
+        "__init__.py",
+        "couplings.py",
+        "function_library.py",
+        "lorentz.py",
+        "object_library.py",
+        "parameters.py",
+        "particles.py",
+        "vertices.py",
+        "write_param_card.py",
+    }
+)
+_PREPARED_FILES = _UPSTREAM_FILES | {"coupling_orders.py"}
+
+
+class HEFTUFOPreparationError(RuntimeError):
+    """The authenticated HEFT UFO could not be prepared safely."""
+
+
+def _download(url: str) -> bytes:
+    try:
+        with urllib.request.urlopen(url, timeout=60) as response:
+            return response.read()
+    except OSError as error:
+        raise HEFTUFOPreparationError(f"cannot download HEFT UFO from {url}") from error
+
+
+def _authenticated_archive(
+    *,
+    downloader: Callable[[str], bytes] = _download,
+) -> bytes:
+    payload = downloader(HEFT_UFO_URL)
+    if not isinstance(payload, bytes):
+        raise HEFTUFOPreparationError("HEFT UFO downloader returned non-byte content")
+    actual = hashlib.sha256(payload).hexdigest()
+    if actual != HEFT_UFO_SHA256:
+        raise HEFTUFOPreparationError(
+            "HEFT UFO archive SHA-256 mismatch: "
+            f"expected {HEFT_UFO_SHA256}, got {actual}"
+        )
+    return payload
+
+
+def _archive_files(archive: tarfile.TarFile) -> dict[str, tarfile.TarInfo]:
+    files: dict[str, tarfile.TarInfo] = {}
+    root = HEFT_UFO_ARCHIVE_ROOT + "/"
+    for member in archive.getmembers():
+        name = member.name.rstrip("/")
+        if name == HEFT_UFO_ARCHIVE_ROOT and member.isdir():
+            continue
+        if not member.name.startswith(root):
+            raise HEFTUFOPreparationError(
+                f"HEFT UFO archive member escapes its model root: {member.name!r}"
+            )
+        relative = member.name[len(root) :]
+        if not relative or "/" in relative or member.issym() or member.islnk():
+            raise HEFTUFOPreparationError(
+                f"unexpected HEFT UFO archive member: {member.name!r}"
+            )
+        if not member.isfile() or relative in files:
+            raise HEFTUFOPreparationError(
+                f"unexpected HEFT UFO archive member: {member.name!r}"
+            )
+        files[relative] = member
+    if set(files) != _UPSTREAM_FILES:
+        missing = sorted(_UPSTREAM_FILES.difference(files))
+        extra = sorted(set(files).difference(_UPSTREAM_FILES))
+        raise HEFTUFOPreparationError(
+            "unexpected HEFT UFO archive contents: "
+            f"missing={missing!r}, extra={extra!r}"
+        )
+    return files
+
+
+def _extract_authenticated_archive(payload: bytes, destination: Path) -> None:
+    try:
+        with tarfile.open(fileobj=io.BytesIO(payload), mode="r:gz") as archive:
+            members = _archive_files(archive)
+            for name, member in members.items():
+                source = archive.extractfile(member)
+                if source is None:
+                    raise HEFTUFOPreparationError(
+                        f"cannot read HEFT UFO archive member {member.name!r}"
+                    )
+                (destination / name).write_bytes(source.read())
+    except (OSError, tarfile.TarError) as error:
+        raise HEFTUFOPreparationError(
+            "HEFT UFO attachment is not a valid tar.gz"
+        ) from error
+
+
+def _replace_exact(text: str, old: str, new: str, *, path: str) -> str:
+    count = text.count(old)
+    if count != 1:
+        raise HEFTUFOPreparationError(
+            f"expected one {old!r} occurrence in upstream {path}, found {count}"
+        )
+    return text.replace(old, new)
+
+
+def _assignment_ranges(
+    source: str, names: Iterable[str], *, path: str
+) -> tuple[tuple[int, int], ...]:
+    requested = set(names)
+    try:
+        tree = ast.parse(source, filename=path)
+    except SyntaxError as error:
+        raise HEFTUFOPreparationError(
+            f"upstream {path} is not valid Python 3"
+        ) from error
+    ranges: dict[str, tuple[int, int]] = {}
+    for node in tree.body:
+        if not isinstance(node, ast.Assign) or len(node.targets) != 1:
+            continue
+        target = node.targets[0]
+        if not isinstance(target, ast.Name) or target.id not in requested:
+            continue
+        if node.end_lineno is None:
+            raise HEFTUFOPreparationError(
+                f"cannot locate assignment {target.id} in {path}"
+            )
+        ranges[target.id] = (node.lineno, node.end_lineno)
+    if set(ranges) != requested:
+        missing = sorted(requested.difference(ranges))
+        raise HEFTUFOPreparationError(
+            f"upstream {path} lacks expected assignments: {missing!r}"
+        )
+    return tuple(sorted(ranges.values()))
+
+
+def _remove_assignments(source: str, names: Iterable[str], *, path: str) -> str:
+    lines = source.splitlines(keepends=True)
+    for start, end in reversed(_assignment_ranges(source, names, path=path)):
+        while end < len(lines) and not lines[end].strip():
+            end += 1
+        del lines[start - 1 : end]
+    return "".join(lines)
+
+
+_COUPLING_ORDER_LIBRARY = """\
+
+all_orders = []
+
+
+class CouplingOrder(UFOBaseClass):
+    require_args = ['name', 'expansion_order', 'hierarchy']
+
+    def __init__(self, name, expansion_order, hierarchy, **options):
+        UFOBaseClass.__init__(
+            self, name, expansion_order, hierarchy, **options
+        )
+        all_orders.append(self)
+"""
+
+_COUPLING_ORDERS = """\
+# Scalar HEFT coupling orders required by modern UFO consumers.
+from object_library import all_orders, CouplingOrder
+
+
+QCD = CouplingOrder(name='QCD', expansion_order=99, hierarchy=1)
+QED = CouplingOrder(name='QED', expansion_order=99, hierarchy=2)
+HIG = CouplingOrder(name='HIG', expansion_order=1, hierarchy=1)
+HIW = CouplingOrder(name='HIW', expansion_order=1, hierarchy=1)
+"""
+
+
+def _prepare_sources(root: Path) -> None:
+    object_library = (root / "object_library.py").read_text(encoding="utf-8")
+    object_library = _replace_exact(
+        object_library,
+        "self.__dict__.iteritems()",
+        "self.__dict__.items()",
+        path="object_library.py",
+    )
+    if "all_orders = []" in object_library or "class CouplingOrder" in object_library:
+        raise HEFTUFOPreparationError(
+            "upstream object_library.py unexpectedly has coupling orders"
+        )
+    (root / "object_library.py").write_text(
+        object_library.rstrip() + "\n" + _COUPLING_ORDER_LIBRARY,
+        encoding="utf-8",
+    )
+
+    writer = (root / "write_param_card.py").read_text(encoding="utf-8")
+    writer = _replace_exact(
+        writer,
+        "print 'write ./param_card.dat'",
+        "print('write ./param_card.dat')",
+        path="write_param_card.py",
+    )
+    (root / "write_param_card.py").write_text(writer, encoding="utf-8")
+
+    parameters = (root / "parameters.py").read_text(encoding="utf-8")
+    parameters = _replace_exact(
+        parameters,
+        "2.634632e7",
+        "26346320",
+        path="parameters.py",
+    )
+    parameters = _remove_assignments(
+        parameters,
+        ("MP", "WH1", "Gphi"),
+        path="parameters.py",
+    )
+    (root / "parameters.py").write_text(parameters, encoding="utf-8")
+
+    removals = {
+        "particles.py": ("h1",),
+        "vertices.py": ("V_19", "V_20"),
+        "lorentz.py": ("VVS1", "VVVS1"),
+        "couplings.py": ("GC_11", "GC_12"),
+    }
+    for name, assignments in removals.items():
+        path = root / name
+        path.write_text(
+            _remove_assignments(
+                path.read_text(encoding="utf-8"), assignments, path=name
+            ),
+            encoding="utf-8",
+        )
+
+    initializer = (root / "__init__.py").read_text(encoding="utf-8")
+    initializer = _replace_exact(
+        initializer,
+        "import couplings\n",
+        "import couplings\nimport coupling_orders\nimport function_library\n",
+        path="__init__.py",
+    )
+    initializer = _replace_exact(
+        initializer,
+        "all_couplings = couplings.all_couplings\n",
+        (
+            "all_couplings = couplings.all_couplings\n"
+            "all_orders = coupling_orders.all_orders\n"
+        ),
+        path="__init__.py",
+    )
+    (root / "__init__.py").write_text(initializer, encoding="utf-8")
+    (root / "coupling_orders.py").write_text(_COUPLING_ORDERS, encoding="utf-8")
+
+
+def validate_prepared_heft_ufo(root: Path) -> Path:
+    """Validate the narrow scalar-only postconditions and return ``root``."""
+
+    root = root.expanduser().resolve(strict=True)
+    if not root.is_dir() or root.is_symlink():
+        raise HEFTUFOPreparationError(f"prepared HEFT UFO is not a directory: {root}")
+    files = {
+        path.name for path in root.iterdir() if path.is_file() and not path.is_symlink()
+    }
+    if files != _PREPARED_FILES or any(
+        path.is_dir() or path.is_symlink() for path in root.iterdir()
+    ):
+        raise HEFTUFOPreparationError("prepared HEFT UFO file inventory is invalid")
+
+    for name in sorted(file for file in files if file.endswith(".py")):
+        try:
+            ast.parse((root / name).read_text(encoding="utf-8"), filename=name)
+        except (OSError, SyntaxError) as error:
+            raise HEFTUFOPreparationError(
+                f"prepared HEFT UFO source is invalid: {name}"
+            ) from error
+
+    combined = "\n".join(
+        (root / name).read_text(encoding="utf-8")
+        for name in sorted(file for file in files if file.endswith(".py"))
+    )
+    forbidden = ("P.h1", "Gphi", "GC_11", "GC_12", "Epsilon(", "2.634632e7")
+    observed = tuple(token for token in forbidden if token in combined)
+    if observed:
+        raise HEFTUFOPreparationError(
+            f"prepared HEFT UFO retains excluded source content: {observed!r}"
+        )
+    if "26346320" not in combined:
+        raise HEFTUFOPreparationError("prepared HEFT UFO lost the exact AH integer")
+
+    particles = (root / "particles.py").read_text(encoding="utf-8")
+    vertices = (root / "vertices.py").read_text(encoding="utf-8")
+    lorentz = (root / "lorentz.py").read_text(encoding="utf-8")
+    orders = (root / "coupling_orders.py").read_text(encoding="utf-8")
+    for required in ("H = Particle", "G = Particle"):
+        if required not in particles:
+            raise HEFTUFOPreparationError(f"prepared HEFT UFO lacks {required}")
+    for required in ("V_16 = Vertex", "V_17 = Vertex", "V_18 = Vertex"):
+        if required not in vertices:
+            raise HEFTUFOPreparationError(f"prepared HEFT UFO lacks {required}")
+    for required in ("VVS3 = Lorentz", "VVVS2 = Lorentz", "VVVVS1 = Lorentz"):
+        if required not in lorentz:
+            raise HEFTUFOPreparationError(f"prepared HEFT UFO lacks {required}")
+    for name in ("QCD", "QED", "HIG", "HIW"):
+        if f"{name} = CouplingOrder" not in orders:
+            raise HEFTUFOPreparationError(f"prepared HEFT UFO lacks {name} order")
+    return root
+
+
+def prepare_heft_ufo(
+    destination: Path = DEFAULT_HEFT_UFO_ROOT,
+    *,
+    downloader: Callable[[str], bytes] = _download,
+) -> Path:
+    """Download, authenticate, scalarize, and install the HEFT UFO."""
+
+    destination = destination.expanduser().resolve(strict=False)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    payload = _authenticated_archive(downloader=downloader)
+    with tempfile.TemporaryDirectory(
+        prefix=".heft-ufo-prepare-", dir=destination.parent
+    ) as temporary:
+        prepared = Path(temporary) / "prepared"
+        prepared.mkdir()
+        _extract_authenticated_archive(payload, prepared)
+        _prepare_sources(prepared)
+        validate_prepared_heft_ufo(prepared)
+        if destination.exists():
+            if destination.is_symlink() or not destination.is_dir():
+                raise HEFTUFOPreparationError(
+                    "HEFT UFO destination is not a replaceable directory: "
+                    f"{destination}"
+                )
+            shutil.rmtree(destination)
+        prepared.replace(destination)
+    return validate_prepared_heft_ufo(destination)
+
+
+__all__ = [
+    "DEFAULT_HEFT_UFO_ROOT",
+    "HEFT_UFO_ARCHIVE_ROOT",
+    "HEFT_UFO_SHA256",
+    "HEFT_UFO_URL",
+    "HEFTUFOPreparationError",
+    "prepare_heft_ufo",
+    "validate_prepared_heft_ufo",
+]
diff --git a/pyamplicol/tools/developer/legacy_amplicol.py b/pyamplicol/tools/developer/legacy_amplicol.py
new file mode 100644
index 0000000000..9fdbe168ce
--- /dev/null
+++ b/pyamplicol/tools/developer/legacy_amplicol.py
@@ -0,0 +1,966 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run the pinned Fortran AmpliCol as a developer-only physics oracle."""
+
+from __future__ import annotations
+
+import argparse
+import difflib
+import hashlib
+import importlib
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from collections import defaultdict
+from collections.abc import Mapping, Sequence
+from dataclasses import asdict
+from decimal import Decimal
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+_DEVELOPER_DIRECTORY = Path(__file__).resolve().parent
+if not __package__ and str(_DEVELOPER_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_DEVELOPER_DIRECTORY))
+if TYPE_CHECKING:
+    from tools.developer.legacy_oracle import checkout as _checkout
+    from tools.developer.legacy_oracle import evidence as _evidence
+    from tools.developer.legacy_oracle import model as _model
+    from tools.developer.legacy_oracle import probe as _probe
+    from tools.developer.legacy_oracle import processes as _processes
+else:
+    _ORACLE_PACKAGE = f"{__package__}.legacy_oracle" if __package__ else "legacy_oracle"
+    _checkout = importlib.import_module(f"{_ORACLE_PACKAGE}.checkout")
+    _evidence = importlib.import_module(f"{_ORACLE_PACKAGE}.evidence")
+    _model = importlib.import_module(f"{_ORACLE_PACKAGE}.model")
+    _probe = importlib.import_module(f"{_ORACLE_PACKAGE}.probe")
+    _processes = importlib.import_module(f"{_ORACLE_PACKAGE}.processes")
+
+ROOT = _model.ROOT
+LOCK = _model.LOCK
+DEFAULT_REPOSITORY = _model.DEFAULT_REPOSITORY
+DEFAULT_FIXTURE = _model.DEFAULT_FIXTURE
+FORTRAN_RTOL = _model.FORTRAN_RTOL
+FORTRAN_ATOL = _model.FORTRAN_ATOL
+FORTRAN_EVIDENCE_RTOL_DECIMAL = _model.FORTRAN_EVIDENCE_RTOL_DECIMAL
+FORTRAN_EVIDENCE_ATOL_DECIMAL = _model.FORTRAN_EVIDENCE_ATOL_DECIMAL
+FORTRAN_CERTIFIED_DECIMAL_DIGITS = _model.FORTRAN_CERTIFIED_DECIMAL_DIGITS
+_MAX_SUPPORTED_QUARK_LINES = _model.MAX_SUPPORTED_QUARK_LINES
+
+LegacyOracleError = _model.LegacyOracleError
+ProcessEntry = _model.ProcessEntry
+LcRowPartition = _model.LcRowPartition
+CompilerProvenance = _model.CompilerProvenance
+ProbeResult = _model.ProbeResult
+SelectedFlowProbeResult = _model.SelectedFlowProbeResult
+
+
+def _run(
+    command: Sequence[str],
+    *,
+    cwd: Path,
+    capture: bool = True,
+) -> subprocess.CompletedProcess[str]:
+    return _checkout._run(
+        command,
+        cwd=cwd,
+        capture=capture,
+        subprocess_module=subprocess,
+    )
+
+
+def _contributor_lock() -> dict[str, Any]:
+    return _checkout._contributor_lock(lock_path=LOCK)
+
+
+def expected_revision() -> str:
+    return _checkout.expected_revision(lock=_contributor_lock())
+
+
+def checkout_branch() -> str:
+    return _checkout.checkout_branch(lock=_contributor_lock())
+
+
+def checkout_url() -> str:
+    return _checkout.checkout_url(lock=_contributor_lock())
+
+
+def prepare_checkout(repository: Path) -> None:
+    _checkout.prepare_checkout(
+        repository,
+        run=_run,
+        validate=validate_checkout,
+        url=checkout_url,
+        branch=checkout_branch,
+        revision=expected_revision,
+    )
+
+
+def validate_checkout(repository: Path) -> None:
+    _checkout.validate_checkout(
+        repository,
+        run=_run,
+        revision=expected_revision,
+    )
+
+
+def build_color_probe(repository: Path, *, jobs: int) -> None:
+    validate_checkout(repository)
+    _run(
+        [
+            "make",
+            f"-j{max(1, jobs)}",
+            "PDF_BACKEND=internal",
+            "amplicol_color_probe",
+        ],
+        cwd=repository,
+        capture=False,
+    )
+
+
+def build_selected_flow_library_probe(repository: Path, *, jobs: int) -> None:
+    """Build the indexed scalar driver for an already generated LC library."""
+
+    validate_checkout(repository)
+    _run(
+        [
+            "make",
+            f"-j{max(1, jobs)}",
+            "PDF_BACKEND=internal",
+            "amplicol_library_benchmark",
+        ],
+        cwd=repository,
+        capture=False,
+    )
+
+
+def _make_database_variable(database: str, name: str) -> str:
+    return _checkout._make_database_variable(database, name)
+
+
+def _compiler_provenance(repository: Path) -> CompilerProvenance:
+    return _checkout._compiler_provenance(
+        repository,
+        run=_run,
+        shutil_module=shutil,
+    )
+
+
+_PDG_BY_NAME = _processes._PDG_BY_NAME
+GENERATED_PROCESS_ROW_SELECTION_POLICY = (
+    _processes.GENERATED_PROCESS_ROW_SELECTION_POLICY
+)
+EXPECTED_FORTRAN_PROCESS_ROWS = _processes.EXPECTED_FORTRAN_PROCESS_ROWS
+EXPECTED_FORTRAN_PDG_MATCH_COUNTS = _processes.EXPECTED_FORTRAN_PDG_MATCH_COUNTS
+EXPECTED_FORTRAN_COLOR_ORDER_COUNTS = _processes.EXPECTED_FORTRAN_COLOR_ORDER_COUNTS
+parse_process_file = _processes.parse_process_file
+process_pdgs = _processes.process_pdgs
+_normalized_process_expression = _processes._normalized_process_expression
+_validate_supported_quark_line_scope = _processes._validate_supported_quark_line_scope
+validate_selected_flow_quark_line_scope = (
+    _processes.validate_selected_flow_quark_line_scope
+)
+validate_direct_color_probe_quark_line_scope = (
+    _processes.validate_direct_color_probe_quark_line_scope
+)
+expected_process_entry = _processes.expected_process_entry
+expected_process_match_count = _processes.expected_process_match_count
+expected_color_order_count = _processes.expected_color_order_count
+select_process_entry = _processes.select_process_entry
+_select_declared_process_entry = _processes._select_declared_process_entry
+select_generated_process_entry = _processes.select_generated_process_entry
+matching_process_entries = _processes.matching_process_entries
+matching_process_entries_for_pdgs = _processes.matching_process_entries_for_pdgs
+_permutation = _processes._permutation
+source_mapped_color_order = _processes.source_mapped_color_order
+_concrete_process_id = _processes._concrete_process_id
+_ordered_leg_ids = _processes._ordered_leg_ids
+
+_VALUE_RE = _probe._VALUE_RE
+_COMPONENT_RE = _probe._COMPONENT_RE
+_LC_ROW_VALUE_RE = _probe._LC_ROW_VALUE_RE
+_LC_ROW_PERMUTATION_RE = _probe._LC_ROW_PERMUTATION_RE
+_LC_ROW_SUM_RE = _probe._LC_ROW_SUM_RE
+_INTEGER_LABELS = _probe._INTEGER_LABELS
+_parse_probe_output = _probe._parse_probe_output
+_parse_selected_flow_probe_output = _probe._parse_selected_flow_probe_output
+_probe_number = _probe._probe_number
+_ordered_binary64_momenta = _probe._ordered_binary64_momenta
+_binary64_input_sha256 = _probe._binary64_input_sha256
+
+
+def run_color_probe(
+    repository: Path,
+    *,
+    process_file: Path,
+    entry: ProcessEntry,
+    source_pdgs: Sequence[int],
+    momenta: Sequence[Sequence[float]],
+    color_accuracy: str,
+    helicities: Sequence[int] | None = None,
+) -> ProbeResult:
+    validate_direct_color_probe_quark_line_scope(
+        entry.process_pdgs,
+        color_accuracy=color_accuracy,
+        context=(
+            "direct all-flow color probe "
+            f"group {entry.group}, integral {entry.integral}"
+        ),
+    )
+    permutation = _permutation(source_pdgs, entry.process_pdgs)
+    ordered_momenta = _ordered_binary64_momenta(
+        source_pdgs,
+        entry.process_pdgs,
+        momenta,
+    )
+    ordered_helicities = (
+        [int(helicities[index]) for index in permutation]
+        if helicities is not None
+        else []
+    )
+    # The pinned Fortran probe copies this path into a fixed 80-character
+    # buffer, so use the deliberately short system-temporary spelling.
+    with tempfile.TemporaryDirectory(prefix="pac-", dir="/tmp") as raw:
+        work = Path(raw)
+        process_copy = work / "processes.txt"
+        momentum_path = work / "momenta.dat"
+        shutil.copy2(process_file, process_copy)
+        momentum_path.write_text(
+            "\n".join(
+                " ".join(format(float(component), ".17g") for component in vector)
+                for vector in ordered_momenta
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        command = [
+            str((repository / "amplicol_color_probe").resolve()),
+            "1",
+            str(entry.group),
+            str(entry.integral),
+            color_accuracy,
+            str(process_copy),
+            str(momentum_path),
+            *(str(value) for value in ordered_helicities),
+        ]
+        completed = _run(command, cwd=work)
+    return _parse_probe_output(completed.stdout + "\n" + completed.stderr)
+
+
+def run_selected_flow_library_probe(
+    repository: Path,
+    *,
+    entry: ProcessEntry,
+    source_pdgs: Sequence[int],
+    momenta: Sequence[Sequence[float]],
+    helicities: Sequence[int] | None = None,
+    points: int = 1,
+) -> SelectedFlowProbeResult:
+    """Evaluate one indexed LC row through the generated-library interface.
+
+    Unlike ``run_color_probe``, this path does not construct the all-flow color
+    matrix. The generated library's serialized ``col_fac``, ``hel_fac``,
+    coupling-power, and averaging metadata define the returned scalar.
+    """
+
+    validate_selected_flow_quark_line_scope(
+        entry.process_pdgs,
+        context=(
+            "generated-library selected-flow row "
+            f"group {entry.group}, integral {entry.integral}"
+        ),
+    )
+    probe_points = int(points)
+    if probe_points < 1:
+        raise LegacyOracleError("selected-flow probe points must be positive")
+    ordered_momenta = _ordered_binary64_momenta(
+        source_pdgs,
+        entry.process_pdgs,
+        momenta,
+    )
+    permutation = _permutation(source_pdgs, entry.process_pdgs)
+    if helicities is not None and len(helicities) != len(source_pdgs):
+        raise LegacyOracleError(
+            "selected-flow fixed-helicity probe requires one helicity per "
+            "external source leg"
+        )
+    ordered_helicities = (
+        ()
+        if helicities is None
+        else tuple(int(helicities[index]) for index in permutation)
+    )
+    with tempfile.TemporaryDirectory(prefix="pac-selected-flow-", dir="/tmp") as raw:
+        momentum_path = Path(raw) / "momenta.dat"
+        momentum_path.write_text(
+            "\n".join(
+                " ".join(format(float(component), ".17g") for component in vector)
+                for vector in ordered_momenta
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        command = [
+            str((repository / "amplicol_library_benchmark").resolve()),
+            str(probe_points),
+            str(entry.group),
+            str(entry.integral),
+            str(momentum_path),
+            *(str(value) for value in ordered_helicities),
+        ]
+        completed = _run(command, cwd=repository)
+    result = _parse_selected_flow_probe_output(
+        completed.stdout + "\n" + completed.stderr
+    )
+    emitted_identity = (result.group, result.integral)
+    expected_identity = (entry.group, entry.integral)
+    if emitted_identity != expected_identity:
+        raise LegacyOracleError(
+            "generated-library selected-flow probe returned row "
+            f"{emitted_identity}, expected {expected_identity}"
+        )
+    if sorted(result.process_pdgs) != sorted(entry.process_pdgs):
+        raise LegacyOracleError(
+            "generated-library selected-flow PDG multiset "
+            f"{result.process_pdgs} does not match selected row {entry.process_pdgs}"
+        )
+    if helicities is not None and result.helicities != ordered_helicities:
+        raise LegacyOracleError(
+            "generated-library selected-flow probe returned helicities "
+            f"{result.helicities}, expected {ordered_helicities}"
+        )
+    return result
+
+
+_resolved_case_value = _probe._resolved_case_value
+_momenta_case_value = _probe._momenta_case_value
+_helicities = _probe._helicities
+_close = _probe._close
+
+
+def _verify_fixture_v1(
+    repository: Path,
+    fixture_path: Path,
+    fixture: Mapping[str, Any],
+) -> dict[str, Any]:
+    cases: dict[str, Any] = fixture["cases"]
+    selected = {
+        name: case
+        for name, case in cases.items()
+        if name.startswith("builtin_sm_")
+        and case["process"]
+        in {
+            "d d~ > z",
+            "d d~ > z g",
+        }
+    }
+    report_cases: dict[str, Any] = {}
+    with tempfile.TemporaryDirectory(prefix="pyamplicol-fortran-process-") as raw:
+        work = Path(raw)
+        for process in sorted({case["process"] for case in selected.values()}):
+            _run(
+                [
+                    sys.executable,
+                    str(repository / "process_list.py"),
+                    "--serial",
+                    process,
+                ],
+                cwd=work,
+            )
+            process_file = work / "processes.txt"
+            entries = parse_process_file(process_file)
+            source_pdgs = process_pdgs(process)
+            entry, matching_entries = _select_declared_process_entry(
+                entries,
+                generated_process=process,
+                wanted_pdgs=source_pdgs,
+            )
+
+            for name, case in selected.items():
+                if case["process"] != process:
+                    continue
+                momenta = _momenta_case_value(cases, case)[0]
+                summed = run_color_probe(
+                    repository,
+                    process_file=process_file,
+                    entry=entry,
+                    source_pdgs=source_pdgs,
+                    momenta=momenta,
+                    color_accuracy=case["color_accuracy"],
+                )
+                expected_total = float(case["total"])
+                if not _close(summed.value, expected_total):
+                    raise LegacyOracleError(
+                        f"{name}: Fortran total {summed.value:.17g} does not match "
+                        f"fixture {expected_total:.17g}"
+                    )
+
+                maximum_relative_difference = 0.0
+                resolved = _resolved_case_value(cases, case)
+                for helicity_id, colors in resolved.items():
+                    if len(colors) != 1:
+                        raise LegacyOracleError(
+                            f"{name}: low-multiplicity oracle expects one "
+                            "color component"
+                        )
+                    expected = float(next(iter(colors.values())))
+                    probe = run_color_probe(
+                        repository,
+                        process_file=process_file,
+                        entry=entry,
+                        source_pdgs=source_pdgs,
+                        momenta=momenta,
+                        color_accuracy=case["color_accuracy"],
+                        helicities=_helicities(helicity_id),
+                    )
+                    if not _close(probe.value, expected):
+                        raise LegacyOracleError(
+                            f"{name} {helicity_id}: Fortran value "
+                            f"{probe.value:.17g} does not match fixture {expected:.17g}"
+                        )
+                    denominator = max(abs(expected), 1.0e-300)
+                    maximum_relative_difference = max(
+                        maximum_relative_difference,
+                        abs(probe.value - expected) / denominator,
+                    )
+
+                report_cases[name] = {
+                    "process": process,
+                    "color_accuracy": case["color_accuracy"],
+                    "total": summed.value,
+                    "max_resolved_relative_difference": maximum_relative_difference,
+                    "fortran_process_entry": {
+                        **asdict(entry),
+                        "exact_external_order": entry.process_pdgs == source_pdgs,
+                        "matching_row_count": len(matching_entries),
+                        "source_to_row_permutation": _permutation(
+                            source_pdgs, entry.process_pdgs
+                        ),
+                    },
+                    "fortran_topology": {
+                        key: value
+                        for key, value in asdict(summed).items()
+                        if key
+                        not in {
+                            "value",
+                            "components",
+                            "lc_row_partitions",
+                            "lc_partition_sum",
+                            "value_decimal",
+                            "component_decimals",
+                            "lc_partition_sum_decimal",
+                        }
+                    },
+                }
+
+    return {
+        "schema_version": 1,
+        "oracle": "legacy-fortran-amplicol-color-probe",
+        "revision": expected_revision(),
+        "fixture": fixture_path.name,
+        "fixture_sha256": hashlib.sha256(fixture_path.read_bytes()).hexdigest(),
+        "patches": [],
+        "tolerances": {
+            "relative": FORTRAN_RTOL,
+            "absolute": FORTRAN_ATOL,
+        },
+        "cases": report_cases,
+    }
+
+
+_decimal_value = _probe._decimal_value
+_canonical_decimal = _probe._canonical_decimal
+_probe_value_decimal = _probe._probe_value_decimal
+_lc_row_value_decimal = _probe._lc_row_value_decimal
+_decimal_close = _probe._decimal_close
+_canonical_structural_zero = _probe._canonical_structural_zero
+_canonical_physics_output_sha256 = _probe._canonical_physics_output_sha256
+_resolved_single_lc_row = _probe._resolved_single_lc_row
+
+_reference_fixture_v2_module = _evidence._reference_fixture_v2_module
+_load_fixture = _evidence.load_fixture
+_fortran_evidence_set_id = _evidence._fortran_evidence_set_id
+_stable_command_description = _evidence._stable_command_description
+_evidence_id = _evidence._evidence_id
+
+
+def _fortran_dependency_ids(fixture: Mapping[str, Any]) -> tuple[str, ...]:
+    return _evidence._fortran_dependency_ids(fixture)
+
+
+def _oracle_content_sha256() -> str:
+    return _evidence._oracle_content_sha256(
+        lock=_contributor_lock(),
+        revision=expected_revision(),
+    )
+
+
+def _verify_fixture_v2(
+    repository: Path,
+    fixture_path: Path,
+    fixture: Mapping[str, Any],
+) -> dict[str, Any]:
+    reference = _reference_fixture_v2_module()
+    reference._validate_wire(
+        fixture,
+        "reference-physics-v2.schema.json",
+        str(fixture_path),
+    )
+    reference._validate_physics_case_hashes(fixture)
+
+    models = {str(model["id"]): model for model in fixture["models"]}
+    processes = {str(process["id"]): process for process in fixture["processes"]}
+    points = {str(point["id"]): point for point in fixture["points"]}
+    selected_cases = tuple(
+        case
+        for case in fixture["cases"]
+        if models[str(case["model_id"])]["source_kind"] == "built-in-sm"
+    )
+    if not selected_cases:
+        raise LegacyOracleError("fixture-v2 contains no built-in-SM cases")
+
+    compiler = _compiler_provenance(repository)
+    evidence_set_id = _fortran_evidence_set_id(fixture)
+    records: list[dict[str, Any]] = []
+    cases_by_process: dict[str, list[Mapping[str, Any]]] = defaultdict(list)
+    for case in selected_cases:
+        process = processes[str(case["process_id"])]
+        _validate_supported_quark_line_scope(
+            tuple(int(value) for value in process["external_pdgs"]),
+            context=f"case {case['id']}",
+        )
+        concrete_id = _concrete_process_id(
+            processes,
+            str(case["process_id"]),
+        )
+        cases_by_process[concrete_id].append(case)
+
+    with tempfile.TemporaryDirectory(prefix="pyamplicol-fortran-process-") as raw:
+        work = Path(raw)
+        ordered_process_ids = sorted(
+            cases_by_process,
+            key=lambda process_id: (
+                str(processes[process_id]["expression"]),
+                process_id,
+            ),
+        )
+        for concrete_id in ordered_process_ids:
+            concrete_process = processes[concrete_id]
+            generation_expression = str(concrete_process["expression"])
+            _run(
+                [
+                    sys.executable,
+                    str(repository / "process_list.py"),
+                    "--serial",
+                    generation_expression,
+                ],
+                cwd=work,
+            )
+            process_file = work / "processes.txt"
+            entries = parse_process_file(process_file)
+
+            ordered_cases = sorted(
+                cases_by_process[concrete_id],
+                key=lambda item: item["id"],
+            )
+            for case in ordered_cases:
+                case_id = str(case["id"])
+                process = processes[str(case["process_id"])]
+                expression = str(process["expression"])
+                source_pdgs = tuple(int(value) for value in process["external_pdgs"])
+                source_leg_ids = tuple(
+                    str(value) for value in process["external_leg_ids"]
+                )
+                entry, matching_entries = _select_declared_process_entry(
+                    entries,
+                    generated_process=generation_expression,
+                    wanted_pdgs=source_pdgs,
+                )
+                expected_matches = expected_process_match_count(generation_expression)
+                if len(matching_entries) != expected_matches:
+                    raise LegacyOracleError(
+                        f"{case_id}: Fortran process-list row multiplicity "
+                        f"{len(matching_entries)} differs from declared "
+                        f"{expected_matches} for {generation_expression!r}"
+                    )
+                permutation = _permutation(source_pdgs, entry.process_pdgs)
+                row_leg_ids = tuple(source_leg_ids[index] for index in permutation)
+                ordered_color_legs = _ordered_leg_ids(
+                    row_leg_ids,
+                    entry.color_order,
+                    context=f"Fortran process row for {expression}",
+                )
+                color_accuracy = str(case["color_accuracy"])
+                helicities = tuple(case["axes"]["helicities"])
+                colors = tuple(case["axes"]["colors"])
+                observations = {
+                    str(observation["point_id"]): observation
+                    for observation in case["observations"]
+                }
+                for point_id_value in case["point_ids"]:
+                    point_id = str(point_id_value)
+                    point = points[point_id]
+                    observation = observations[point_id]
+                    observation_certified_digits = int(
+                        observation["certified_decimal_digits"]
+                    )
+                    if observation_certified_digits > FORTRAN_CERTIFIED_DECIMAL_DIGITS:
+                        raise LegacyOracleError(
+                            f"{case_id}/{point_id}: observation certifies "
+                            f"{observation_certified_digits} digits, beyond the "
+                            f"binary64 Fortran oracle's "
+                            f"{FORTRAN_CERTIFIED_DECIMAL_DIGITS}-digit scope"
+                        )
+                    expected_evidence_id = _evidence_id(case_id, point_id)
+                    if expected_evidence_id not in observation["evidence_refs"]:
+                        raise LegacyOracleError(
+                            f"{case_id}/{point_id} does not reference generated "
+                            f"evidence {expected_evidence_id}"
+                        )
+                    momenta = tuple(
+                        tuple(float(component) for component in row)
+                        for row in point["momenta"]
+                    )
+                    binary64_input_sha256 = _binary64_input_sha256(
+                        source_pdgs,
+                        entry.process_pdgs,
+                        momenta,
+                    )
+                    summed = run_color_probe(
+                        repository,
+                        process_file=process_file,
+                        entry=entry,
+                        source_pdgs=source_pdgs,
+                        momenta=momenta,
+                        color_accuracy=color_accuracy,
+                    )
+                    expected_orders = expected_color_order_count(generation_expression)
+                    if summed.color_orders != expected_orders:
+                        raise LegacyOracleError(
+                            f"{case_id}/{point_id}: Fortran color-order count "
+                            f"{summed.color_orders} differs from declared "
+                            f"{expected_orders} for {generation_expression!r}"
+                        )
+                    observed_total = _probe_value_decimal(summed)
+                    expected_total = Decimal(str(observation["total"]))
+                    if not _decimal_close(observed_total, expected_total):
+                        raise LegacyOracleError(
+                            f"{case_id}/{point_id}: Fortran total {observed_total} "
+                            f"does not match fixture {expected_total}"
+                        )
+
+                    multi_flow_lc = color_accuracy == "lc" and len(colors) > 1
+                    coverage = "helicity-aggregate" if multi_flow_lc else "resolved"
+                    resolved_values: list[list[str]] = []
+                    helicity_totals: list[str] = []
+                    helicity_results: list[ProbeResult] = []
+                    helicity_sum = Decimal(0)
+                    for row_index, helicity in enumerate(helicities):
+                        expected_row = tuple(
+                            Decimal(str(value))
+                            for value in observation["values"][row_index]
+                        )
+                        probe = run_color_probe(
+                            repository,
+                            process_file=process_file,
+                            entry=entry,
+                            source_pdgs=source_pdgs,
+                            momenta=momenta,
+                            color_accuracy=color_accuracy,
+                            helicities=tuple(
+                                int(value) for value in helicity["values"]
+                            ),
+                        )
+                        context = f"{case_id}/{point_id} {helicity['id']}"
+                        aggregate = _probe_value_decimal(probe)
+                        helicity_sum += aggregate
+                        if multi_flow_lc:
+                            expected_aggregate = sum(expected_row, Decimal(0))
+                            normalized_aggregate = aggregate
+                            if bool(helicity["structural_zero"]):
+                                normalized_aggregate = _canonical_structural_zero(
+                                    aggregate,
+                                    context=f"{context} aggregate",
+                                )
+                            if not _decimal_close(aggregate, expected_aggregate):
+                                raise LegacyOracleError(
+                                    f"{context}: Fortran helicity aggregate "
+                                    f"{aggregate} does not match fixture sum "
+                                    f"{expected_aggregate}"
+                                )
+                            helicity_totals.append(
+                                _canonical_decimal(normalized_aggregate)
+                            )
+                            helicity_results.append(probe)
+                            continue
+
+                        if color_accuracy == "lc":
+                            observed_row = _resolved_single_lc_row(
+                                probe,
+                                colors=colors,
+                                source_to_row_permutation=permutation,
+                                context=context,
+                            )
+                        else:
+                            if len(colors) != 1:
+                                raise LegacyOracleError(
+                                    f"{context}: contracted color case must have one "
+                                    "component"
+                                )
+                            observed_row = [
+                                _canonical_decimal(_probe_value_decimal(probe))
+                            ]
+                        observed_decimals = tuple(
+                            Decimal(value) for value in observed_row
+                        )
+                        normalized_aggregate = aggregate
+                        if bool(helicity["structural_zero"]):
+                            observed_decimals = tuple(
+                                _canonical_structural_zero(
+                                    value,
+                                    context=f"{context} color component {index}",
+                                )
+                                for index, value in enumerate(observed_decimals)
+                            )
+                            normalized_aggregate = _canonical_structural_zero(
+                                aggregate,
+                                context=f"{context} aggregate",
+                            )
+                        if len(observed_decimals) != len(expected_row) or any(
+                            not _decimal_close(observed, expected)
+                            for observed, expected in zip(
+                                observed_decimals,
+                                expected_row,
+                                strict=True,
+                            )
+                        ):
+                            raise LegacyOracleError(
+                                f"{context}: Fortran resolved values {observed_row} "
+                                f"do not match fixture {list(expected_row)}"
+                            )
+                        resolved_sum = sum(observed_decimals, Decimal(0))
+                        if not _decimal_close(normalized_aggregate, resolved_sum):
+                            raise LegacyOracleError(
+                                f"{context}: resolved Fortran values do not sum to "
+                                f"aggregate {aggregate}"
+                            )
+                        resolved_values.append(
+                            [_canonical_decimal(value) for value in observed_decimals]
+                        )
+                        helicity_results.append(probe)
+
+                    if not _decimal_close(helicity_sum, observed_total):
+                        raise LegacyOracleError(
+                            f"{case_id}/{point_id}: fixed-helicity Fortran sum "
+                            f"{helicity_sum} does not match summed probe "
+                            f"{observed_total}"
+                        )
+
+                    evidence_record: dict[str, object] = {
+                        "id": expected_evidence_id,
+                        "case_id": case_id,
+                        "point_id": point_id,
+                        "independent_of_pyamplicol": True,
+                        "arithmetic_precision_bits": 53,
+                        "round_trip_decimal_digits": 17,
+                        "certified_decimal_digits": (FORTRAN_CERTIFIED_DECIMAL_DIGITS),
+                        "arithmetic": "binary64",
+                        "coverage": coverage,
+                        "helicity_ids": [
+                            str(helicity["id"]) for helicity in helicities
+                        ],
+                        "color_ids": [str(color["id"]) for color in colors],
+                        "observed_total": _canonical_decimal(
+                            _probe_value_decimal(summed)
+                        ),
+                        "observed_helicity_totals": (
+                            helicity_totals if multi_flow_lc else None
+                        ),
+                        "observed_values": (None if multi_flow_lc else resolved_values),
+                        "process_identity": {
+                            "expression": expression,
+                            "ordered_external_pdgs": list(entry.process_pdgs),
+                            "ordered_external_leg_ids": list(row_leg_ids),
+                            "source_to_row_permutation": list(permutation),
+                            "row_id": (
+                                f"group:{entry.group}:integral:{entry.integral}"
+                            ),
+                            "color_order_count": summed.color_orders,
+                            "ordered_color_legs": list(ordered_color_legs),
+                        },
+                        "input_sha256": reference._parse_point(
+                            point,
+                            0,
+                        ).input_sha256(),
+                        "physics_case_sha256": str(case["physics_case_sha256"]),
+                        "oracle_output_sha256": _canonical_physics_output_sha256(
+                            summed,
+                            helicity_results,
+                        ),
+                        "command": _stable_command_description(
+                            process=expression,
+                            case_id=case_id,
+                            point_id=point_id,
+                            color_accuracy=color_accuracy,
+                            entry=entry,
+                            pdg_match_count=len(matching_entries),
+                            compiler=compiler,
+                            binary64_input_sha256=binary64_input_sha256,
+                        ),
+                        "tolerances": {
+                            "relative": "0.0000000001",
+                            "absolute": "0.000000000001",
+                        },
+                    }
+                    evidence_record["evidence_record_sha256"] = (
+                        reference.evidence_record_sha256(evidence_record)
+                    )
+                    records.append(evidence_record)
+
+    evidence = {
+        "evidence_schema_version": 2,
+        "kind": "pyamplicol-reference-oracle-evidence",
+        "evidence_set_id": evidence_set_id,
+        "captured_at": str(fixture["provenance"]["captured_at"]),
+        "oracle": {
+            "id": "oracle:legacy-fortran-amplicol",
+            "name": "Pinned legacy Fortran AmpliCol",
+            "implementation": "independent amplicol_color_probe executable",
+            "revision": expected_revision(),
+            "content_sha256": _oracle_content_sha256(),
+            "independence_statement": (
+                "The pinned Fortran implementation is built and executed outside "
+                "the pyAmpliCol generation and Rusticol runtime code paths."
+            ),
+            "validation_profile": "binary64",
+            "tolerance_ceiling": {
+                "relative": "0.0000000001",
+                "absolute": "0.000000000001",
+            },
+        },
+        "dependency_ids": list(_fortran_dependency_ids(fixture)),
+        "records": records,
+    }
+
+    reference._validate_wire(
+        evidence,
+        "reference-oracle-evidence-v2.schema.json",
+        "generated Fortran evidence",
+    )
+    return evidence
+
+
+def verify_fixture(
+    repository: Path,
+    fixture_path: Path,
+    *,
+    jobs: int,
+    build: bool,
+) -> dict[str, Any]:
+    repository = repository.resolve()
+    validate_checkout(repository)
+    if build:
+        build_color_probe(repository, jobs=jobs)
+    elif not (repository / "amplicol_color_probe").is_file():
+        raise LegacyOracleError("amplicol_color_probe has not been built")
+
+    fixture = _load_fixture(fixture_path)
+    version = fixture.get("fixture_schema_version")
+    if version == 1:
+        return _verify_fixture_v1(repository, fixture_path, fixture)
+    if version == 2:
+        return _verify_fixture_v2(repository, fixture_path, fixture)
+    raise LegacyOracleError(f"unsupported reference fixture schema version {version!r}")
+
+
+_COMPILER_VARIANT_COMMAND_KEYS = _evidence._COMPILER_VARIANT_COMMAND_KEYS
+_REQUIRED_PROVENANCE_COMMAND_KEYS = _evidence._REQUIRED_PROVENANCE_COMMAND_KEYS
+_semantic_replay_command = _evidence._semantic_replay_command
+
+
+def _assert_v2_reports_semantically_equal(
+    expected: Mapping[str, Any],
+    actual: Mapping[str, Any],
+) -> None:
+    _evidence._assert_v2_reports_semantically_equal(
+        expected,
+        actual,
+        reference_loader=_reference_fixture_v2_module,
+        semantic_replay=_semantic_replay_command,
+    )
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repository", type=Path, default=DEFAULT_REPOSITORY)
+    parser.add_argument("--fixture", type=Path, default=DEFAULT_FIXTURE)
+    parser.add_argument("--jobs", type=int, default=5)
+    parser.add_argument("--no-build", action="store_true")
+    parser.add_argument(
+        "--prepare-checkout",
+        action="store_true",
+        help="clone the pinned public oracle branch when absent",
+    )
+    output = parser.add_mutually_exclusive_group()
+    output.add_argument("--output", type=Path)
+    output.add_argument(
+        "--check-output",
+        type=Path,
+        help="fail unless the generated report exactly matches this tracked file",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    if args.prepare_checkout:
+        prepare_checkout(args.repository)
+    report = verify_fixture(
+        args.repository,
+        args.fixture,
+        jobs=max(1, args.jobs),
+        build=not args.no_build,
+    )
+    rendered = json.dumps(report, indent=2, sort_keys=True) + "\n"
+    if args.output is not None:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        args.output.write_text(rendered, encoding="utf-8")
+    if args.check_output is not None:
+        expected = args.check_output.read_text(encoding="utf-8")
+        fixture_version = json.loads(args.fixture.read_text(encoding="utf-8")).get(
+            "fixture_schema_version"
+        )
+        if fixture_version == 2:
+            try:
+                expected_payload = json.loads(expected)
+            except json.JSONDecodeError as error:
+                raise LegacyOracleError(
+                    f"tracked Fortran evidence is not valid JSON: {error}"
+                ) from error
+            _assert_v2_reports_semantically_equal(expected_payload, report)
+        elif rendered != expected:
+            difference = "".join(
+                difflib.unified_diff(
+                    expected.splitlines(keepends=True),
+                    rendered.splitlines(keepends=True),
+                    fromfile=str(args.check_output),
+                    tofile="fresh legacy AmpliCol report",
+                )
+            )
+            raise LegacyOracleError(
+                "tracked legacy AmpliCol report is stale\n" + difference
+            )
+    print(rendered, end="")
+    return 0
+
+
+def _entrypoint(argv: Sequence[str] | None = None) -> int:
+    try:
+        return main(argv)
+    except (LegacyOracleError, OSError, ValueError) as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(_entrypoint())
diff --git a/pyamplicol/tools/developer/legacy_oracle/__init__.py b/pyamplicol/tools/developer/legacy_oracle/__init__.py
new file mode 100644
index 0000000000..14ccb5ed13
--- /dev/null
+++ b/pyamplicol/tools/developer/legacy_oracle/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: 0BSD
+"""Implementation helpers for the developer-only legacy Fortran oracle."""
diff --git a/pyamplicol/tools/developer/legacy_oracle/checkout.py b/pyamplicol/tools/developer/legacy_oracle/checkout.py
new file mode 100644
index 0000000000..fa94f3dfb5
--- /dev/null
+++ b/pyamplicol/tools/developer/legacy_oracle/checkout.py
@@ -0,0 +1,197 @@
+# SPDX-License-Identifier: 0BSD
+"""Contributor-lock, Git checkout, and compiler provenance helpers."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+import shlex
+import shutil
+import subprocess
+import tomllib
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any, cast
+
+from .model import (
+    LOCK,
+    PINNED_REFERENCE_BRANCH,
+    PINNED_REFERENCE_REVISION,
+    PINNED_SOURCE_URL,
+    CompilerProvenance,
+    LegacyOracleError,
+)
+
+
+def _run(
+    command: Sequence[str],
+    *,
+    cwd: Path,
+    capture: bool = True,
+    subprocess_module: Any = subprocess,
+) -> subprocess.CompletedProcess[str]:
+    completed = subprocess_module.run(
+        command,
+        cwd=cwd,
+        text=True,
+        capture_output=capture,
+    )
+    if completed.returncode != 0:
+        detail = "\n".join(
+            part for part in (completed.stdout, completed.stderr) if part
+        )
+        raise LegacyOracleError(
+            f"command exited with {completed.returncode}: {' '.join(command)}"
+            + (f"\n{detail}" if detail else "")
+        )
+    return cast(subprocess.CompletedProcess[str], completed)
+
+
+def _contributor_lock(*, lock_path: Path = LOCK) -> dict[str, Any]:
+    try:
+        with lock_path.open("rb") as stream:
+            return tomllib.load(stream)
+    except FileNotFoundError:
+        # Published profiling runtimes do not redistribute contributor locks.
+        # Manual campaigns inject the capability checkout's actual revision;
+        # this record retains a usable reference for standalone oracle helpers.
+        return {
+            "legacy_amplicol": {
+                "branch": PINNED_REFERENCE_BRANCH,
+                "revision": PINNED_REFERENCE_REVISION,
+                "source_url": PINNED_SOURCE_URL,
+            }
+        }
+
+
+def expected_revision(*, lock: Mapping[str, Any] | None = None) -> str:
+    contributor = _contributor_lock() if lock is None else lock
+    return str(contributor["legacy_amplicol"]["revision"])
+
+
+def checkout_branch(*, lock: Mapping[str, Any] | None = None) -> str:
+    contributor = _contributor_lock() if lock is None else lock
+    return str(contributor["legacy_amplicol"]["branch"])
+
+
+def checkout_url(*, lock: Mapping[str, Any] | None = None) -> str:
+    contributor = _contributor_lock() if lock is None else lock
+    source = str(contributor["legacy_amplicol"]["source_url"])
+    prefix = "git@github.com:"
+    if source.startswith(prefix):
+        return "https://github.com/" + source.removeprefix(prefix)
+    return source
+
+
+def validate_checkout(
+    repository: Path,
+    *,
+    run: Any = _run,
+    revision: Any = expected_revision,
+) -> None:
+    repository = repository.resolve()
+    if not (repository / ".git").exists():
+        raise LegacyOracleError(
+            f"legacy AmpliCol checkout is absent: {repository}; run "
+            "`just dev-install --with-legacy-amplicol`"
+        )
+    actual_revision = run(["git", "rev-parse", "HEAD"], cwd=repository).stdout.strip()
+    if actual_revision != revision():
+        raise LegacyOracleError(
+            f"legacy AmpliCol is at {actual_revision}, expected {revision()}"
+        )
+    tracked_changes = run(
+        ["git", "status", "--porcelain=v1", "--untracked-files=no"],
+        cwd=repository,
+    ).stdout.strip()
+    if tracked_changes:
+        raise LegacyOracleError(
+            "legacy AmpliCol checkout contains tracked edits; the developer "
+            "oracle must use the clean pinned branch revision"
+        )
+
+
+def prepare_checkout(
+    repository: Path,
+    *,
+    run: Any = _run,
+    validate: Any = validate_checkout,
+    url: Any = checkout_url,
+    branch: Any = checkout_branch,
+    revision: Any = expected_revision,
+) -> None:
+    repository = repository.resolve()
+    if repository.exists():
+        validate(repository)
+        return
+    repository.parent.mkdir(parents=True, exist_ok=True)
+    run(["git", "init", str(repository)], cwd=repository.parent)
+    run(["git", "remote", "add", "origin", url()], cwd=repository)
+    run(
+        ["git", "fetch", "--depth=1", "origin", branch()],
+        cwd=repository,
+        capture=False,
+    )
+    run(["git", "checkout", "--detach", "FETCH_HEAD"], cwd=repository)
+    validate(repository)
+
+
+def _make_database_variable(database: str, name: str) -> str:
+    matches = re.findall(rf"^{re.escape(name)}\s*[:?+]?=\s*(.*?)\s*$", database, re.M)
+    if not matches or not matches[-1]:
+        raise LegacyOracleError(f"legacy makefile does not define {name}")
+    return cast(str, matches[-1])
+
+
+def _compiler_provenance(
+    repository: Path,
+    *,
+    run: Any = _run,
+    shutil_module: Any = shutil,
+) -> CompilerProvenance:
+    database = run(
+        [
+            "make",
+            "-f",
+            "makefile",
+            "PDF_BACKEND=internal",
+            "-pn",
+            "amplicol_color_probe",
+        ],
+        cwd=repository,
+    ).stdout
+    compiler_tokens = shlex.split(_make_database_variable(database, "FC"))
+    if not compiler_tokens:
+        raise LegacyOracleError("legacy makefile defines an empty Fortran compiler")
+    compiler = shutil_module.which(compiler_tokens[0])
+    if compiler is None:
+        candidate = repository / compiler_tokens[0]
+        if candidate.is_file():
+            compiler = str(candidate.resolve())
+    if compiler is None:
+        raise LegacyOracleError(
+            f"cannot resolve legacy Fortran compiler {compiler_tokens[0]!r}"
+        )
+    compiler_command = [compiler, *compiler_tokens[1:]]
+    version_result = run([*compiler_command, "--version"], cwd=repository)
+    version_lines = tuple(
+        line.strip()
+        for line in (version_result.stdout + "\n" + version_result.stderr).splitlines()
+        if line.strip()
+    )
+    if not version_lines:
+        raise LegacyOracleError("Fortran compiler emitted no version identity")
+    target_result = run([*compiler_command, "-dumpmachine"], cwd=repository)
+    target = target_result.stdout.strip()
+    if not target:
+        raise LegacyOracleError("Fortran compiler emitted no target triple")
+    executable = repository / "amplicol_color_probe"
+    if not executable.is_file():
+        raise LegacyOracleError("amplicol_color_probe has not been built")
+    return CompilerProvenance(
+        identity=Path(compiler).name,
+        version=version_lines[0],
+        flags=tuple(shlex.split(_make_database_variable(database, "FFLAGS"))),
+        target=target,
+        executable_sha256=hashlib.sha256(executable.read_bytes()).hexdigest(),
+    )
diff --git a/pyamplicol/tools/developer/legacy_oracle/evidence.py b/pyamplicol/tools/developer/legacy_oracle/evidence.py
new file mode 100644
index 0000000000..37779be857
--- /dev/null
+++ b/pyamplicol/tools/developer/legacy_oracle/evidence.py
@@ -0,0 +1,315 @@
+# SPDX-License-Identifier: 0BSD
+"""Fixture loading, evidence identities, and semantic replay helpers."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import re
+import sys
+from collections.abc import Mapping, Sequence
+from decimal import Decimal
+from pathlib import Path
+from typing import Any, cast
+
+from .checkout import (
+    _contributor_lock,
+    checkout_branch,
+    expected_revision,
+)
+from .model import ROOT, CompilerProvenance, LegacyOracleError, ProcessEntry
+
+
+def load_fixture(path: Path) -> dict[str, Any]:
+    return cast(dict[str, Any], json.loads(path.read_text(encoding="utf-8")))
+
+
+def _reference_fixture_v2_module() -> Any:
+    name = "_pyamplicol_reference_fixture_v2"
+    existing = sys.modules.get(name)
+    if existing is not None:
+        return existing
+    path = ROOT / "tools" / "developer" / "reference_fixture_v2.py"
+    spec = importlib.util.spec_from_file_location(name, path)
+    if spec is None or spec.loader is None:
+        raise LegacyOracleError(f"cannot import strict fixture-v2 parser from {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _fortran_evidence_set_id(fixture: Mapping[str, Any]) -> str:
+    identifiers = tuple(str(value) for value in fixture["evidence_sets"])
+    candidates = tuple(
+        identifier
+        for identifier in identifiers
+        if "fortran" in identifier.lower() or "amplicol" in identifier.lower()
+    )
+    if len(candidates) == 1:
+        return candidates[0]
+    if len(identifiers) == 1:
+        return identifiers[0]
+    raise LegacyOracleError(
+        "fixture-v2 must identify one unambiguous Fortran AmpliCol evidence set"
+    )
+
+
+def _fortran_dependency_ids(
+    fixture: Mapping[str, Any],
+) -> tuple[str, ...]:
+    identifiers = tuple(
+        str(dependency["id"])
+        for dependency in fixture["dependencies"]
+        if "legacy" in str(dependency["name"]).lower()
+        and "amplicol" in str(dependency["name"]).lower()
+    )
+    if not identifiers:
+        raise LegacyOracleError(
+            "fixture-v2 does not contain a legacy AmpliCol dependency"
+        )
+    if len(identifiers) != 1:
+        raise LegacyOracleError(
+            "fixture-v2 contains ambiguous legacy AmpliCol dependencies"
+        )
+    return identifiers
+
+
+def _oracle_content_sha256(
+    *,
+    lock: Mapping[str, Any] | None = None,
+    revision: str | None = None,
+) -> str:
+    contributor = _contributor_lock() if lock is None else lock
+    pinned_revision = expected_revision() if revision is None else revision
+    payload = {
+        "branch": checkout_branch(lock=contributor),
+        "revision": pinned_revision,
+        "source_url": str(contributor["legacy_amplicol"]["source_url"]),
+    }
+    encoded = json.dumps(
+        payload,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _stable_command_description(
+    *,
+    process: str,
+    case_id: str,
+    point_id: str,
+    color_accuracy: str,
+    entry: ProcessEntry,
+    pdg_match_count: int,
+    compiler: CompilerProvenance,
+    binary64_input_sha256: str,
+) -> list[str]:
+    return [
+        "amplicol_color_probe",
+        "build_target=amplicol_color_probe",
+        f"compiler_identity={compiler.identity}",
+        f"compiler_version={compiler.version}",
+        "compiler_flags="
+        + json.dumps(list(compiler.flags), ensure_ascii=True, separators=(",", ":")),
+        f"compiler_target={compiler.target}",
+        f"oracle_executable_sha256={compiler.executable_sha256}",
+        f"binary64_input_sha256={binary64_input_sha256}",
+        "mode=1",
+        f"group={entry.group}",
+        f"integral={entry.integral}",
+        f"pdg_match_count={pdg_match_count}",
+        f"color_accuracy={color_accuracy}",
+        f"process={process}",
+        f"case={case_id}",
+        f"point={point_id}",
+        "helicities=summed-then-each-physical",
+    ]
+
+
+def _evidence_id(case_id: str, point_id: str) -> str:
+    return f"evidence:fortran:{case_id}:{point_id}"
+
+
+_COMPILER_VARIANT_COMMAND_KEYS = frozenset(
+    {
+        "compiler_identity",
+        "compiler_version",
+        "compiler_flags",
+        "compiler_target",
+        "oracle_executable_sha256",
+    }
+)
+_REQUIRED_PROVENANCE_COMMAND_KEYS = _COMPILER_VARIANT_COMMAND_KEYS | {
+    "binary64_input_sha256"
+}
+
+
+def _semantic_replay_command(command: Sequence[object], *, context: str) -> list[str]:
+    seen: dict[str, str] = {}
+    semantic: list[str] = []
+    for raw_argument in command:
+        argument = str(raw_argument)
+        key, separator, value = argument.partition("=")
+        if key in _REQUIRED_PROVENANCE_COMMAND_KEYS:
+            if not separator or not value or key in seen:
+                raise LegacyOracleError(
+                    f"{context} has invalid or duplicate command provenance {key!r}"
+                )
+            seen[key] = value
+            if key not in _COMPILER_VARIANT_COMMAND_KEYS:
+                semantic.append(argument)
+        else:
+            semantic.append(argument)
+    missing = sorted(_REQUIRED_PROVENANCE_COMMAND_KEYS - seen.keys())
+    if missing:
+        raise LegacyOracleError(f"{context} lacks command provenance fields {missing}")
+    for key in ("oracle_executable_sha256", "binary64_input_sha256"):
+        if re.fullmatch(r"[a-f0-9]{64}", seen[key]) is None:
+            raise LegacyOracleError(f"{context} has invalid {key}")
+    try:
+        compiler_flags = json.loads(seen["compiler_flags"])
+    except json.JSONDecodeError as error:
+        raise LegacyOracleError(f"{context} has invalid compiler_flags") from error
+    if not isinstance(compiler_flags, list) or any(
+        not isinstance(flag, str) or not flag for flag in compiler_flags
+    ):
+        raise LegacyOracleError(f"{context} has invalid compiler_flags")
+    return semantic
+
+
+def _assert_v2_reports_semantically_equal(
+    expected: Mapping[str, Any],
+    actual: Mapping[str, Any],
+    *,
+    reference_loader: Any = _reference_fixture_v2_module,
+    semantic_replay: Any = _semantic_replay_command,
+) -> None:
+    reference = reference_loader()
+    for label, payload in (("tracked", expected), ("fresh", actual)):
+        reference._validate_wire(
+            payload,
+            "reference-oracle-evidence-v2.schema.json",
+            f"{label} Fortran evidence",
+        )
+        reference._validate_evidence_record_hashes(payload)
+
+    expected_header = dict(expected)
+    actual_header = dict(actual)
+    expected_records = expected_header.pop("records")
+    actual_records = actual_header.pop("records")
+    if expected_header != actual_header:
+        raise LegacyOracleError(
+            "fresh Fortran evidence provenance differs from the tracked record"
+        )
+
+    def by_id(records: Sequence[object], label: str) -> dict[str, Mapping[str, Any]]:
+        result: dict[str, Mapping[str, Any]] = {}
+        for raw in records:
+            record = cast(Mapping[str, Any], raw)
+            identifier = str(record["id"])
+            if identifier in result:
+                raise LegacyOracleError(
+                    f"{label} Fortran evidence repeats record {identifier}"
+                )
+            result[identifier] = record
+        return result
+
+    expected_by_id = by_id(expected_records, "tracked")
+    actual_by_id = by_id(actual_records, "fresh")
+    if expected_by_id.keys() != actual_by_id.keys():
+        raise LegacyOracleError(
+            "fresh Fortran evidence record identities differ from the tracked record"
+        )
+
+    def compare_numeric(
+        expected_value: object,
+        actual_value: object,
+        *,
+        tolerances: Mapping[str, Any],
+        context: str,
+    ) -> None:
+        if expected_value is None or actual_value is None:
+            if expected_value is not actual_value:
+                raise LegacyOracleError(f"{context} has a different null shape")
+            return
+        if isinstance(expected_value, list) or isinstance(actual_value, list):
+            if (
+                not isinstance(expected_value, list)
+                or not isinstance(actual_value, list)
+                or len(expected_value) != len(actual_value)
+            ):
+                raise LegacyOracleError(f"{context} has a different numeric shape")
+            for index, (expected_item, actual_item) in enumerate(
+                zip(expected_value, actual_value, strict=True)
+            ):
+                compare_numeric(
+                    expected_item,
+                    actual_item,
+                    tolerances=tolerances,
+                    context=f"{context}[{index}]",
+                )
+            return
+        expected_decimal = Decimal(str(expected_value))
+        actual_decimal = Decimal(str(actual_value))
+        if expected_decimal == 0:
+            if actual_decimal != 0:
+                raise LegacyOracleError(f"{context} no longer preserves an exact zero")
+            return
+        declared = reference.Tolerances(
+            relative=Decimal(str(tolerances["relative"])),
+            absolute=Decimal(str(tolerances["absolute"])),
+        )
+        if not reference._within_tolerance(
+            expected_decimal,
+            actual_decimal,
+            declared,
+        ):
+            raise LegacyOracleError(
+                f"{context} changed from {expected_decimal} to {actual_decimal} "
+                "outside the tracked tolerance"
+            )
+
+    numeric_fields = (
+        "observed_total",
+        "observed_helicity_totals",
+        "observed_values",
+    )
+    for identifier in expected_by_id:
+        expected_record = dict(expected_by_id[identifier])
+        actual_record = dict(actual_by_id[identifier])
+        expected_digest = str(expected_record.pop("oracle_output_sha256"))
+        actual_digest = str(actual_record.pop("oracle_output_sha256"))
+        expected_record.pop("evidence_record_sha256")
+        actual_record.pop("evidence_record_sha256")
+        if expected_digest == "0" * 64 or actual_digest == "0" * 64:
+            raise LegacyOracleError(
+                f"Fortran evidence {identifier} contains an invalid output digest"
+            )
+        expected_values = {
+            field: expected_record.pop(field) for field in numeric_fields
+        }
+        actual_values = {field: actual_record.pop(field) for field in numeric_fields}
+        expected_record["command"] = semantic_replay(
+            cast(Sequence[object], expected_record["command"]),
+            context=f"tracked Fortran evidence {identifier}",
+        )
+        actual_record["command"] = semantic_replay(
+            cast(Sequence[object], actual_record["command"]),
+            context=f"fresh Fortran evidence {identifier}",
+        )
+        if expected_record != actual_record:
+            raise LegacyOracleError(
+                f"fresh Fortran evidence identity differs for {identifier}"
+            )
+        tolerances = cast(Mapping[str, Any], expected_record["tolerances"])
+        for field_name in numeric_fields:
+            compare_numeric(
+                expected_values[field_name],
+                actual_values[field_name],
+                tolerances=tolerances,
+                context=f"Fortran evidence {identifier}.{field_name}",
+            )
diff --git a/pyamplicol/tools/developer/legacy_oracle/model.py b/pyamplicol/tools/developer/legacy_oracle/model.py
new file mode 100644
index 0000000000..f42145d8c6
--- /dev/null
+++ b/pyamplicol/tools/developer/legacy_oracle/model.py
@@ -0,0 +1,94 @@
+# SPDX-License-Identifier: 0BSD
+"""Shared paths, constants, and value objects for the legacy oracle."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[3]
+LOCK = ROOT / "dependencies" / "contributor-lock.toml"
+DEFAULT_REPOSITORY = ROOT / "dependencies" / "checkouts" / "legacy-amplicol"
+DEFAULT_FIXTURE = ROOT / "tests" / "fixtures" / "reference" / "physics-v2.json"
+PINNED_REFERENCE_REVISION = "dcb3efbcbe89c51969818cddf48113fba19ad763"
+PINNED_REFERENCE_BRANCH = "amplicol_with_patches"
+PINNED_SOURCE_URL = "https://github.com/rikkert-frederix/AmpliCol.git"
+
+FORTRAN_RTOL = 1.0e-8
+FORTRAN_ATOL = 1.0e-15
+FORTRAN_EVIDENCE_RTOL_DECIMAL = Decimal("0.0000000001")
+FORTRAN_EVIDENCE_ATOL_DECIMAL = Decimal("0.000000000001")
+FORTRAN_CERTIFIED_DECIMAL_DIGITS = 10
+
+MAX_SUPPORTED_QUARK_LINES = 2
+MAX_DIRECT_COLOR_PROBE_QUARK_LINES = 3
+MAX_DIRECT_COLOR_PROBE_COLOR_ORDERS = 5_000
+
+
+class LegacyOracleError(RuntimeError):
+    """The independent Fortran oracle could not be prepared or evaluated."""
+
+
+@dataclass(frozen=True)
+class ProcessEntry:
+    group: int
+    integral: int
+    process_pdgs: tuple[int, ...]
+    color_order: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class LcRowPartition:
+    row: int
+    value: float
+    permutation: tuple[int, ...]
+    decimal_value: Decimal | None = field(default=None, compare=False)
+
+
+@dataclass(frozen=True)
+class CompilerProvenance:
+    identity: str
+    version: str
+    flags: tuple[str, ...]
+    target: str
+    executable_sha256: str
+
+
+@dataclass(frozen=True)
+class ProbeResult:
+    value: float
+    components: tuple[float, float, float]
+    currents: int
+    vertices: int
+    amplitudes: int
+    color_orders: int
+    lc_row_partitions: tuple[LcRowPartition, ...] = ()
+    lc_partition_sum: float | None = None
+    value_decimal: Decimal | None = field(default=None, compare=False)
+    component_decimals: tuple[Decimal, ...] = field(default=(), compare=False)
+    lc_partition_sum_decimal: Decimal | None = field(default=None, compare=False)
+
+
+@dataclass(frozen=True)
+class SelectedFlowProbeResult:
+    """Normalized scalar and row metadata from a generated LC library."""
+
+    value: float
+    group: int
+    integral: int
+    process_pdgs: tuple[int, ...]
+    color_order: tuple[int, ...]
+    amplitudes: int
+    color_factor: int
+    identical_factor: int
+    singlet_vertices: int
+    normalization: float
+    value_decimal: Decimal = field(compare=False)
+    normalization_decimal: Decimal = field(compare=False)
+    helicities: tuple[int, ...] = ()
+    fixed_helicity_value: float | None = None
+    fixed_helicity_value_decimal: Decimal | None = field(
+        default=None,
+        compare=False,
+    )
diff --git a/pyamplicol/tools/developer/legacy_oracle/probe.py b/pyamplicol/tools/developer/legacy_oracle/probe.py
new file mode 100644
index 0000000000..fb4b57f371
--- /dev/null
+++ b/pyamplicol/tools/developer/legacy_oracle/probe.py
@@ -0,0 +1,556 @@
+# SPDX-License-Identifier: 0BSD
+"""Probe output parsing, momentum ordering, and resolved-row helpers."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+import struct
+from collections.abc import Mapping, Sequence
+from decimal import Decimal, InvalidOperation
+from typing import Any, cast
+
+from .model import (
+    FORTRAN_ATOL,
+    FORTRAN_EVIDENCE_ATOL_DECIMAL,
+    FORTRAN_EVIDENCE_RTOL_DECIMAL,
+    FORTRAN_RTOL,
+    LcRowPartition,
+    LegacyOracleError,
+    ProbeResult,
+    SelectedFlowProbeResult,
+)
+from .processes import _permutation
+
+_VALUE_RE = re.compile(
+    r"^AMPICOL_COLOR_PROBE_VALUE\s+\S+\s+\d+\s+\d+\s+([+\-0-9.Ee]+)$",
+    re.MULTILINE,
+)
+_COMPONENT_RE = re.compile(
+    r"^AMPICOL_COLOR_PROBE_COMPONENTS\s+"
+    r"([+\-0-9.Ee]+)\s+([+\-0-9.Ee]+)\s+([+\-0-9.Ee]+)$",
+    re.MULTILINE,
+)
+# The pinned probe calls these "flows", but each value is an algebraic row
+# partition of the LC contraction. Only the one-row case identifies a physical
+# LC cell without additional information from the generator.
+_LC_ROW_VALUE_RE = re.compile(
+    r"^AMPICOL_COLOR_PROBE_FLOW_VALUE\s+(\d+)\s+([+\-0-9.Ee]+)$",
+    re.MULTILINE,
+)
+_LC_ROW_PERMUTATION_RE = re.compile(
+    r"^AMPICOL_COLOR_PROBE_FLOW_PERM\s+(\d+)\s+([0-9 ]+?)\s*$",
+    re.MULTILINE,
+)
+_LC_ROW_SUM_RE = re.compile(
+    r"^AMPICOL_COLOR_PROBE_FLOW_SUM\s+([+\-0-9.Ee]+)$",
+    re.MULTILINE,
+)
+_INTEGER_LABELS = {
+    "currents": "AMPICOL_COLOR_PROBE_CURRENTS",
+    "vertices": "AMPICOL_COLOR_PROBE_VERTICES",
+    "amplitudes": "AMPICOL_COLOR_PROBE_AMPLITUDES",
+    "color_orders": "AMPICOL_COLOR_PROBE_COLOR_ORDERS",
+}
+_SELECTED_FLOW_VALUE_RE = re.compile(
+    r"^AMPICOL_SELECTED_FLOW_PROBE_VALUE\s+(\d+)\s+(\d+)\s+"
+    r"([+\-0-9.Ee]+)$",
+    re.MULTILINE,
+)
+_SELECTED_FLOW_NORMALIZATION_RE = re.compile(
+    r"^AMPICOL_SELECTED_FLOW_PROBE_NORMALIZATION\s+([+\-0-9.Ee]+)$",
+    re.MULTILINE,
+)
+_SELECTED_FLOW_FIXED_VALUE_RE = re.compile(
+    r"^AMPICOL_SELECTED_FLOW_PROBE_FIXED_HELICITY_VALUE\s+([+\-0-9.Ee]+)$",
+    re.MULTILINE,
+)
+_SELECTED_FLOW_INTEGER_LABELS = {
+    "amplitudes": "AMPICOL_SELECTED_FLOW_PROBE_AMPLITUDES",
+    "color_factor": "AMPICOL_SELECTED_FLOW_PROBE_COLOR_FACTOR",
+    "identical_factor": "AMPICOL_SELECTED_FLOW_PROBE_IDENTICAL_FACTOR",
+    "singlet_vertices": "AMPICOL_SELECTED_FLOW_PROBE_SINGLET_VERTICES",
+}
+
+
+def _parse_probe_output(output: str) -> ProbeResult:
+    value_matches = _VALUE_RE.findall(output)
+    component_matches = _COMPONENT_RE.findall(output)
+    if len(value_matches) != 1 or len(component_matches) != 1:
+        raise LegacyOracleError(
+            "Fortran color probe must emit exactly one matrix-element value and "
+            "component record"
+        )
+    integers: dict[str, int] = {}
+    for name, label in _INTEGER_LABELS.items():
+        matches = re.findall(rf"^{label}\s+(\d+)$", output, re.MULTILINE)
+        if len(matches) != 1:
+            raise LegacyOracleError(
+                f"Fortran color probe must emit exactly one {label} record"
+            )
+        integers[name] = int(matches[0])
+    row_value_matches = _LC_ROW_VALUE_RE.findall(output)
+    row_permutation_matches = _LC_ROW_PERMUTATION_RE.findall(output)
+    row_sum_matches = _LC_ROW_SUM_RE.findall(output)
+    row_value_text = {int(row): value for row, value in row_value_matches}
+    row_permutations = {
+        int(row): tuple(int(value) for value in permutation.split())
+        for row, permutation in row_permutation_matches
+    }
+    try:
+        value_float, value_decimal = _probe_number(
+            value_matches[0], "matrix-element value"
+        )
+        component_pairs = tuple(
+            _probe_number(value, "matrix-element component")
+            for value in component_matches[0]
+        )
+    except (InvalidOperation, ValueError, OverflowError) as error:
+        raise LegacyOracleError(
+            "Fortran color probe emitted a malformed matrix-element number"
+        ) from error
+    if row_value_text or row_permutations or row_sum_matches:
+        if (
+            len(row_value_text) != len(row_value_matches)
+            or len(row_permutations) != len(row_permutation_matches)
+            or len(row_sum_matches) != 1
+            or set(row_value_text) != set(row_permutations)
+            or sorted(row_value_text) != list(range(1, len(row_value_text) + 1))
+        ):
+            raise LegacyOracleError(
+                "Fortran color probe emitted incomplete LC row partitions"
+            )
+        try:
+            row_numbers = {
+                row: _probe_number(value, f"LC row {row} value")
+                for row, value in row_value_text.items()
+            }
+            sum_number = _probe_number(row_sum_matches[0], "LC partition sum")
+        except (InvalidOperation, ValueError, OverflowError) as error:
+            raise LegacyOracleError(
+                "Fortran color probe emitted a malformed LC partition number"
+            ) from error
+        lc_row_partitions = tuple(
+            LcRowPartition(
+                row,
+                row_numbers[row][0],
+                row_permutations[row],
+                row_numbers[row][1],
+            )
+            for row in sorted(row_value_text)
+        )
+        lc_partition_sum, lc_partition_sum_decimal = sum_number
+    else:
+        lc_row_partitions = ()
+        lc_partition_sum = None
+        lc_partition_sum_decimal = None
+    return ProbeResult(
+        value=value_float,
+        components=cast(
+            tuple[float, float, float],
+            tuple(value[0] for value in component_pairs),
+        ),
+        lc_row_partitions=lc_row_partitions,
+        lc_partition_sum=lc_partition_sum,
+        value_decimal=value_decimal,
+        component_decimals=tuple(value[1] for value in component_pairs),
+        lc_partition_sum_decimal=lc_partition_sum_decimal,
+        **integers,
+    )
+
+
+def _parse_selected_flow_probe_output(output: str) -> SelectedFlowProbeResult:
+    """Parse the indexed scalar emitted by the generated-library driver."""
+
+    value_matches = _SELECTED_FLOW_VALUE_RE.findall(output)
+    normalization_matches = _SELECTED_FLOW_NORMALIZATION_RE.findall(output)
+    fixed_value_matches = _SELECTED_FLOW_FIXED_VALUE_RE.findall(output)
+    if len(value_matches) != 1 or len(normalization_matches) != 1:
+        raise LegacyOracleError(
+            "Fortran selected-flow probe must emit exactly one value and "
+            "normalization record"
+        )
+    if len(fixed_value_matches) > 1:
+        raise LegacyOracleError(
+            "Fortran selected-flow probe emitted duplicate fixed-helicity values"
+        )
+    group = int(value_matches[0][0])
+    integral = int(value_matches[0][1])
+    if group < 1 or integral < 1:
+        raise LegacyOracleError(
+            "Fortran selected-flow probe emitted a non-positive row identity"
+        )
+
+    process_pdgs = _parse_counted_integer_vector(
+        output,
+        "AMPICOL_SELECTED_FLOW_PROBE_PDGS",
+    )
+    color_order = _parse_counted_integer_vector(
+        output,
+        "AMPICOL_SELECTED_FLOW_PROBE_COLOR_ORDER",
+    )
+    has_helicity_record = "AMPICOL_SELECTED_FLOW_PROBE_HELICITIES" in output
+    if bool(fixed_value_matches) != has_helicity_record:
+        raise LegacyOracleError(
+            "Fortran selected-flow probe emitted incomplete fixed-helicity evidence"
+        )
+    helicities = (
+        _parse_counted_integer_vector(
+            output,
+            "AMPICOL_SELECTED_FLOW_PROBE_HELICITIES",
+        )
+        if has_helicity_record
+        else ()
+    )
+    if len(process_pdgs) != len(color_order):
+        raise LegacyOracleError(
+            "Fortran selected-flow probe emitted inconsistent external metadata"
+        )
+    if helicities and len(helicities) != len(process_pdgs):
+        raise LegacyOracleError(
+            "Fortran selected-flow probe emitted a helicity vector with the "
+            "wrong external width"
+        )
+    expected_order = tuple(range(1, len(process_pdgs) + 1))
+    if tuple(sorted(color_order)) != expected_order:
+        raise LegacyOracleError(
+            "Fortran selected-flow probe color order is not a permutation of "
+            f"1..{len(process_pdgs)}"
+        )
+
+    integers: dict[str, int] = {}
+    for name, label in _SELECTED_FLOW_INTEGER_LABELS.items():
+        matches = re.findall(rf"^{re.escape(label)}\s+(\d+)$", output, re.MULTILINE)
+        if len(matches) != 1:
+            raise LegacyOracleError(
+                f"Fortran selected-flow probe must emit exactly one {label} record"
+            )
+        integers[name] = int(matches[0])
+    if integers["amplitudes"] < 1:
+        raise LegacyOracleError(
+            "Fortran selected-flow probe emitted no generated amplitudes"
+        )
+    if integers["color_factor"] < 1 or integers["identical_factor"] < 1:
+        raise LegacyOracleError(
+            "Fortran selected-flow probe emitted a non-positive normalization factor"
+        )
+
+    try:
+        value, value_decimal = _probe_number(
+            value_matches[0][2],
+            "selected-flow matrix-element value",
+        )
+        normalization, normalization_decimal = _probe_number(
+            normalization_matches[0],
+            "selected-flow normalization",
+        )
+        if fixed_value_matches:
+            fixed_helicity_value, fixed_helicity_value_decimal = _probe_number(
+                fixed_value_matches[0],
+                "selected-flow fixed-helicity matrix-element value",
+            )
+        else:
+            fixed_helicity_value = None
+            fixed_helicity_value_decimal = None
+    except (InvalidOperation, ValueError, OverflowError) as error:
+        raise LegacyOracleError(
+            "Fortran selected-flow probe emitted a malformed number"
+        ) from error
+    if normalization <= 0.0:
+        raise LegacyOracleError(
+            "Fortran selected-flow probe emitted a non-positive normalization"
+        )
+
+    return SelectedFlowProbeResult(
+        value=value,
+        group=group,
+        integral=integral,
+        process_pdgs=process_pdgs,
+        color_order=color_order,
+        normalization=normalization,
+        helicities=helicities,
+        fixed_helicity_value=fixed_helicity_value,
+        value_decimal=value_decimal,
+        normalization_decimal=normalization_decimal,
+        fixed_helicity_value_decimal=fixed_helicity_value_decimal,
+        **integers,
+    )
+
+
+def _parse_counted_integer_vector(output: str, label: str) -> tuple[int, ...]:
+    matches = re.findall(
+        rf"^{re.escape(label)}\s+(\d+)\s+([+\-0-9 ]+?)\s*$",
+        output,
+        re.MULTILINE,
+    )
+    if len(matches) != 1:
+        raise LegacyOracleError(
+            f"Fortran selected-flow probe must emit exactly one {label} record"
+        )
+    declared_count = int(matches[0][0])
+    values = tuple(int(value) for value in matches[0][1].split())
+    if declared_count < 1 or len(values) != declared_count:
+        raise LegacyOracleError(
+            f"Fortran selected-flow probe emitted an invalid {label} width"
+        )
+    return values
+
+
+def _probe_number(value: str, context: str) -> tuple[float, Decimal]:
+    decimal_value = Decimal(value)
+    float_value = float(value)
+    if not decimal_value.is_finite() or not math.isfinite(float_value):
+        raise ValueError(f"{context} must be finite")
+    return float_value, decimal_value
+
+
+def _ordered_binary64_momenta(
+    source_pdgs: Sequence[int],
+    target_pdgs: Sequence[int],
+    momenta: Sequence[Sequence[float]],
+) -> tuple[tuple[float, float, float, float], ...]:
+    if len(momenta) != len(source_pdgs):
+        raise LegacyOracleError(
+            f"received {len(momenta)} momentum rows for {len(source_pdgs)} external "
+            "particles"
+        )
+    permutation = _permutation(source_pdgs, target_pdgs)
+    ordered: list[tuple[float, float, float, float]] = []
+    for source_index in permutation:
+        vector = tuple(float(component) for component in momenta[source_index])
+        if len(vector) != 4:
+            raise LegacyOracleError("external momentum must contain four components")
+        if not all(math.isfinite(component) for component in vector):
+            raise LegacyOracleError("external momentum contains a non-finite binary64")
+        ordered.append((vector[0], vector[1], vector[2], vector[3]))
+    return tuple(ordered)
+
+
+def _binary64_input_sha256(
+    source_pdgs: Sequence[int],
+    target_pdgs: Sequence[int],
+    momenta: Sequence[Sequence[float]],
+) -> str:
+    """Hash post-permutation IEEE-754 values in canonical big-endian order."""
+
+    ordered = _ordered_binary64_momenta(source_pdgs, target_pdgs, momenta)
+    values = tuple(component for vector in ordered for component in vector)
+    return hashlib.sha256(struct.pack(f">{len(values)}d", *values)).hexdigest()
+
+
+def _resolved_case_value(cases: Mapping[str, Any], case: Mapping[str, Any]) -> Any:
+    return (
+        cases[str(case["resolved_from"])]["resolved"]
+        if "resolved_from" in case
+        else case["resolved"]
+    )
+
+
+def _momenta_case_value(cases: Mapping[str, Any], case: Mapping[str, Any]) -> Any:
+    return (
+        cases[str(case["momenta_from"])]["momenta"]
+        if "momenta_from" in case
+        else case["momenta"]
+    )
+
+
+def _helicities(identifier: str) -> tuple[int, ...]:
+    if not identifier.startswith("h:"):
+        raise LegacyOracleError(f"invalid physical helicity ID: {identifier!r}")
+    return tuple(int(value) for value in identifier[2:].split(","))
+
+
+def _close(actual: float, expected: float) -> bool:
+    return math.isclose(
+        actual,
+        expected,
+        rel_tol=FORTRAN_RTOL,
+        abs_tol=FORTRAN_ATOL,
+    )
+
+
+def _decimal_value(value: float | Decimal) -> Decimal:
+    decimal = value if isinstance(value, Decimal) else Decimal(str(value))
+    if not decimal.is_finite():
+        raise LegacyOracleError(f"Fortran oracle emitted non-finite value {value!r}")
+    return decimal
+
+
+def _canonical_decimal(value: float | Decimal) -> str:
+    decimal = _decimal_value(value)
+    if decimal == 0:
+        return "0"
+    rendered = format(decimal, "f")
+    if "." in rendered:
+        rendered = rendered.rstrip("0").rstrip(".")
+    return rendered
+
+
+def _probe_value_decimal(probe: ProbeResult) -> Decimal:
+    return (
+        probe.value_decimal
+        if probe.value_decimal is not None
+        else _decimal_value(probe.value)
+    )
+
+
+def _lc_row_value_decimal(partition: LcRowPartition) -> Decimal:
+    return (
+        partition.decimal_value
+        if partition.decimal_value is not None
+        else _decimal_value(partition.value)
+    )
+
+
+def _decimal_close(actual: Decimal, expected: Decimal) -> bool:
+    scale = max(abs(actual), abs(expected))
+    allowed = max(
+        FORTRAN_EVIDENCE_ATOL_DECIMAL,
+        FORTRAN_EVIDENCE_RTOL_DECIMAL * scale,
+    )
+    return abs(actual - expected) <= allowed
+
+
+def _canonical_structural_zero(value: Decimal, *, context: str) -> Decimal:
+    """Validate binary64 residue, then preserve an exact zero in evidence."""
+
+    if not _decimal_close(value, Decimal(0)):
+        raise LegacyOracleError(
+            f"{context}: Fortran did not preserve structural zero ({value})"
+        )
+    return Decimal(0)
+
+
+def _canonical_physics_output_sha256(
+    summed: ProbeResult,
+    helicity_results: Sequence[ProbeResult],
+) -> str:
+    """Hash deterministic physics output, excluding raw timer/logging text."""
+
+    def stable_probe(probe: ProbeResult) -> dict[str, Any]:
+        components = (
+            probe.component_decimals
+            if probe.component_decimals
+            else tuple(_decimal_value(value) for value in probe.components)
+        )
+        return {
+            "amplitudes": probe.amplitudes,
+            "color_orders": probe.color_orders,
+            "components": [_canonical_decimal(component) for component in components],
+            "currents": probe.currents,
+            "lc_partition_sum": (
+                None
+                if probe.lc_partition_sum is None
+                else _canonical_decimal(
+                    probe.lc_partition_sum_decimal
+                    if probe.lc_partition_sum_decimal is not None
+                    else probe.lc_partition_sum
+                )
+            ),
+            "lc_row_partitions": [
+                {
+                    "permutation": list(partition.permutation),
+                    "row": partition.row,
+                    "value": _canonical_decimal(_lc_row_value_decimal(partition)),
+                }
+                for partition in probe.lc_row_partitions
+            ],
+            "value": _canonical_decimal(_probe_value_decimal(probe)),
+            "vertices": probe.vertices,
+        }
+
+    payload = {
+        "helicity_probes": [stable_probe(probe) for probe in helicity_results],
+        "summed_probe": stable_probe(summed),
+    }
+    encoded = json.dumps(
+        payload,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _resolved_single_lc_row(
+    probe: ProbeResult,
+    *,
+    colors: Sequence[Mapping[str, Any]],
+    source_to_row_permutation: Sequence[int],
+    context: str,
+) -> list[str]:
+    if len(colors) != 1:
+        raise LegacyOracleError(
+            f"{context}: LC row partitions cannot resolve multiple physical flows"
+        )
+    if probe.lc_partition_sum is None or not probe.lc_row_partitions:
+        raise LegacyOracleError(
+            f"{context}: Fortran LC probe did not emit its row partition"
+        )
+    if probe.color_orders != 1 or len(probe.lc_row_partitions) != 1:
+        raise LegacyOracleError(
+            f"{context}: single-flow LC resolution requires exactly one Fortran "
+            "color-order row"
+        )
+    partition_sum = (
+        probe.lc_partition_sum_decimal
+        if probe.lc_partition_sum_decimal is not None
+        else _decimal_value(probe.lc_partition_sum)
+    )
+    aggregate = _probe_value_decimal(probe)
+    row_sum = sum(
+        (_lc_row_value_decimal(partition) for partition in probe.lc_row_partitions),
+        Decimal(0),
+    )
+    if not _decimal_close(partition_sum, row_sum):
+        raise LegacyOracleError(
+            f"{context}: Fortran LC row value is {row_sum}, but the reported row "
+            f"sum is {partition_sum}"
+        )
+    if not _decimal_close(partition_sum, aggregate):
+        raise LegacyOracleError(
+            f"{context}: Fortran LC row sum {partition_sum} does not match "
+            f"aggregate {aggregate}"
+        )
+
+    colors_by_word = {
+        tuple(int(position) for position in color["word"]): color for color in colors
+    }
+    if len(colors_by_word) != len(colors):
+        raise LegacyOracleError(f"{context}: fixture contains duplicate LC words")
+    values_by_id: dict[str, str] = {}
+    for partition in probe.lc_row_partitions:
+        try:
+            source_word = tuple(
+                source_to_row_permutation[position - 1] + 1
+                for position in partition.permutation
+            )
+        except IndexError as error:
+            raise LegacyOracleError(
+                f"{context}: Fortran row {partition.row} contains an invalid position"
+            ) from error
+        if any(position < 1 for position in partition.permutation):
+            raise LegacyOracleError(
+                f"{context}: Fortran row {partition.row} contains an invalid position"
+            )
+        color = colors_by_word.get(source_word)
+        if color is None:
+            raise LegacyOracleError(
+                f"{context}: Fortran row {partition.row} maps to unknown fixture word "
+                f"{source_word}"
+            )
+        color_id = str(color["id"])
+        if color_id in values_by_id:
+            raise LegacyOracleError(
+                f"{context}: several Fortran rows map to color {color_id}"
+            )
+        values_by_id[color_id] = _canonical_decimal(_lc_row_value_decimal(partition))
+    expected_ids = {str(color["id"]) for color in colors}
+    if set(values_by_id) != expected_ids:
+        missing = sorted(expected_ids - values_by_id.keys())
+        raise LegacyOracleError(
+            f"{context}: Fortran probe did not cover LC colors {missing}"
+        )
+    return [values_by_id[str(color["id"])] for color in colors]
diff --git a/pyamplicol/tools/developer/legacy_oracle/processes.py b/pyamplicol/tools/developer/legacy_oracle/processes.py
new file mode 100644
index 0000000000..25c0679e17
--- /dev/null
+++ b/pyamplicol/tools/developer/legacy_oracle/processes.py
@@ -0,0 +1,444 @@
+# SPDX-License-Identifier: 0BSD
+"""Legacy process-file parsing, PDG mapping, and row selection."""
+
+from __future__ import annotations
+
+from collections import defaultdict, deque
+from collections.abc import Mapping, Sequence
+from math import factorial
+from pathlib import Path
+
+from .model import (
+    MAX_DIRECT_COLOR_PROBE_COLOR_ORDERS,
+    MAX_DIRECT_COLOR_PROBE_QUARK_LINES,
+    MAX_SUPPORTED_QUARK_LINES,
+    LegacyOracleError,
+    ProcessEntry,
+)
+
+_PDG_BY_NAME = {
+    "g": 21,
+    "d": 1,
+    "u": 2,
+    "s": 3,
+    "c": 4,
+    "b": 5,
+    "t": 6,
+    "d~": -1,
+    "u~": -2,
+    "s~": -3,
+    "c~": -4,
+    "b~": -5,
+    "t~": -6,
+    "a": 22,
+    "z": 23,
+    "w+": 24,
+    "w-": -24,
+    "e+": -11,
+    "e-": 11,
+    "mu+": -13,
+    "mu-": 13,
+    "ta+": -15,
+    "ta-": 15,
+    "ve": 12,
+    "ve~": -12,
+    "vm": 14,
+    "vm~": -14,
+    "vt": 16,
+    "vt~": -16,
+    "h": 25,
+}
+
+# These rows were inspected at the pinned revision after applying the managed
+# patch series. PDG multiset matching alone is not authoritative: several
+# generated processes contain multiple rows with the same external PDGs.
+EXPECTED_FORTRAN_PROCESS_ROWS: Mapping[str, ProcessEntry] = {
+    "d d~ > z": ProcessEntry(1, 1, (1, -1, 23), (2, 1, 3)),
+    "d d~ > z g": ProcessEntry(1, 1, (1, -1, 21, 23), (2, 3, 1, 4)),
+    "d d~ > z g g": ProcessEntry(
+        1,
+        1,
+        (1, -1, 21, 21, 23),
+        (2, 3, 4, 1, 5),
+    ),
+    "u d~ > w+": ProcessEntry(1, 1, (2, -1, 24), (2, 1, 3)),
+    "d d~ > e- e+": ProcessEntry(1, 1, (1, -1, 11, -11), (2, 1, 3, 4)),
+    "d d~ > u u~": ProcessEntry(2, 1, (1, -1, 2, -2), (2, 1, 3, 4)),
+    "d d~ > d d~": ProcessEntry(2, 1, (1, -1, 1, -1), (2, 1, 3, 4)),
+    "g g > g g": ProcessEntry(1, 1, (21, 21, 21, 21), (1, 2, 3, 4)),
+    "g g > t t~": ProcessEntry(1, 1, (21, 21, 6, -6), (3, 1, 2, 4)),
+}
+EXPECTED_FORTRAN_PDG_MATCH_COUNTS: Mapping[str, int] = {
+    "d d~ > z": 1,
+    "d d~ > z g": 1,
+    "d d~ > z g g": 1,
+    "u d~ > w+": 1,
+    "d d~ > e- e+": 2,
+    "d d~ > u u~": 2,
+    "d d~ > d d~": 2,
+    "g g > g g": 3,
+    "g g > t t~": 2,
+}
+EXPECTED_FORTRAN_COLOR_ORDER_COUNTS: Mapping[str, int] = {
+    "d d~ > z": 1,
+    "d d~ > z g": 1,
+    "d d~ > z g g": 2,
+    "u d~ > w+": 1,
+    "d d~ > e- e+": 1,
+    "d d~ > u u~": 2,
+    "d d~ > d d~": 2,
+    "g g > g g": 6,
+    "g g > t t~": 2,
+}
+
+GENERATED_PROCESS_ROW_SELECTION_POLICY = (
+    "exact-external-pdg-order-then-process-file-order-v1"
+)
+
+
+def parse_process_file(path: Path) -> tuple[ProcessEntry, ...]:
+    lines = path.read_text(encoding="utf-8").splitlines()
+    if not lines:
+        raise LegacyOracleError(f"empty process file: {path}")
+    try:
+        n_external, n_unique = (int(value) for value in lines[0].split())
+    except (ValueError, TypeError) as error:
+        raise LegacyOracleError(f"invalid process header in {path}") from error
+    cursor = 1 + n_unique
+
+    def next_nonempty() -> str:
+        nonlocal cursor
+        while cursor < len(lines) and not lines[cursor].strip():
+            cursor += 1
+        if cursor >= len(lines):
+            raise LegacyOracleError(f"truncated process file: {path}")
+        value = lines[cursor].strip()
+        cursor += 1
+        return value
+
+    try:
+        n_groups = int(next_nonempty())
+        entries: list[ProcessEntry] = []
+        for _ in range(n_groups):
+            header = [int(value) for value in next_nonempty().split()]
+            if len(header) != 3 + n_external:
+                raise ValueError("invalid group header width")
+            group, n_integrals, _max_channels = header[:3]
+            for integral in range(1, n_integrals + 1):
+                tokens = next_nonempty().split()
+                n_channels = int(tokens[0])
+                process_start = 1 + n_channels
+                process_end = process_start + n_external
+                order_end = process_end + n_external
+                if len(tokens) != order_end + 1:
+                    raise ValueError("invalid process row width")
+                entries.append(
+                    ProcessEntry(
+                        group=group,
+                        integral=integral,
+                        process_pdgs=tuple(
+                            int(value) for value in tokens[process_start:process_end]
+                        ),
+                        color_order=tuple(
+                            int(value) for value in tokens[process_end:order_end]
+                        ),
+                    )
+                )
+    except ValueError as error:
+        raise LegacyOracleError(f"invalid process file {path}: {error}") from error
+    return tuple(entries)
+
+
+def _normalized_process_expression(process: str) -> str:
+    return " ".join(process.lower().replace("bar", "~").split())
+
+
+def process_pdgs(process: str) -> tuple[int, ...]:
+    parts = _normalized_process_expression(process).split(">")
+    if len(parts) != 2:
+        raise LegacyOracleError(f"invalid concrete process: {process!r}")
+    names = (*parts[0].split(), *parts[1].split())
+    try:
+        return tuple(_PDG_BY_NAME[name] for name in names)
+    except KeyError as error:
+        raise LegacyOracleError(
+            f"legacy built-in-SM oracle does not recognize {error.args[0]!r}"
+        ) from error
+
+
+def validate_selected_flow_quark_line_scope(
+    pdgs: Sequence[int],
+    *,
+    context: str,
+) -> int:
+    """Validate complete quark lines without imposing the all-flow limit."""
+
+    quark_legs = sum(1 for pdg in pdgs if 1 <= abs(int(pdg)) <= 6)
+    if quark_legs % 2:
+        raise LegacyOracleError(
+            f"{context}: legacy Fortran oracle cannot identify complete quark lines "
+            f"from {quark_legs} external quark legs"
+        )
+    return quark_legs // 2
+
+
+def validate_direct_color_probe_quark_line_scope(
+    pdgs: Sequence[int],
+    *,
+    color_accuracy: str,
+    context: str,
+) -> int:
+    """Validate the direct imode-2 probe's generic open-line color basis."""
+
+    quark_lines = validate_selected_flow_quark_line_scope(pdgs, context=context)
+    if quark_lines > MAX_DIRECT_COLOR_PROBE_QUARK_LINES:
+        raise LegacyOracleError(
+            f"{context}: {quark_lines} quark lines exceed the direct legacy "
+            "Fortran color-probe scope of "
+            f"{MAX_DIRECT_COLOR_PROBE_QUARK_LINES}"
+        )
+    if quark_lines == MAX_DIRECT_COLOR_PROBE_QUARK_LINES:
+        singlets = sum(
+            not (1 <= abs(int(pdg)) <= 6 or abs(int(pdg)) == 21) for pdg in pdgs
+        )
+        if singlets:
+            raise LegacyOracleError(
+                f"{context}: the direct legacy Fortran color probe does not "
+                "support color singlets together with three quark lines"
+            )
+        gluons = sum(abs(int(pdg)) == 21 for pdg in pdgs)
+        color_orders = 3 * factorial(gluons) * (gluons + 1) * (gluons + 2)
+        if (
+            color_accuracy.strip().lower() != "lc"
+            and color_orders > MAX_DIRECT_COLOR_PROBE_COLOR_ORDERS
+        ):
+            raise LegacyOracleError(
+                f"{context}: {color_orders} three-line color flows exceed the "
+                "direct legacy Fortran color-probe limit of "
+                f"{MAX_DIRECT_COLOR_PROBE_COLOR_ORDERS}"
+            )
+    return quark_lines
+
+
+def _validate_supported_quark_line_scope(
+    pdgs: Sequence[int],
+    *,
+    context: str,
+) -> int:
+    """Apply the strict two-line scope used by frozen/all-flow evidence."""
+
+    quark_lines = validate_selected_flow_quark_line_scope(pdgs, context=context)
+    if quark_lines > MAX_SUPPORTED_QUARK_LINES:
+        raise LegacyOracleError(
+            f"{context}: {quark_lines} quark lines exceed the legacy Fortran "
+            f"oracle scope of {MAX_SUPPORTED_QUARK_LINES}"
+        )
+    return quark_lines
+
+
+def expected_process_entry(process: str) -> ProcessEntry:
+    normalized = _normalized_process_expression(process)
+    try:
+        return EXPECTED_FORTRAN_PROCESS_ROWS[normalized]
+    except KeyError as error:
+        raise LegacyOracleError(
+            f"no expected Fortran process row is declared for {process!r}"
+        ) from error
+
+
+def expected_process_match_count(process: str) -> int:
+    normalized = _normalized_process_expression(process)
+    try:
+        return EXPECTED_FORTRAN_PDG_MATCH_COUNTS[normalized]
+    except KeyError as error:
+        raise LegacyOracleError(
+            f"no expected Fortran PDG-match count is declared for {process!r}"
+        ) from error
+
+
+def expected_color_order_count(process: str) -> int:
+    normalized = _normalized_process_expression(process)
+    try:
+        return EXPECTED_FORTRAN_COLOR_ORDER_COUNTS[normalized]
+    except KeyError as error:
+        raise LegacyOracleError(
+            f"no expected Fortran color-order count is declared for {process!r}"
+        ) from error
+
+
+def select_process_entry(entries: Sequence[ProcessEntry], process: str) -> ProcessEntry:
+    selected, _matches = _select_declared_process_entry(
+        entries,
+        generated_process=process,
+        wanted_pdgs=process_pdgs(process),
+    )
+    return selected
+
+
+def _select_declared_process_entry(
+    entries: Sequence[ProcessEntry],
+    *,
+    generated_process: str,
+    wanted_pdgs: Sequence[int],
+) -> tuple[ProcessEntry, tuple[ProcessEntry, ...]]:
+    _validate_supported_quark_line_scope(
+        wanted_pdgs,
+        context=f"process {generated_process!r}",
+    )
+    expected = expected_process_entry(generated_process)
+    if sorted(expected.process_pdgs) != sorted(int(pdg) for pdg in wanted_pdgs):
+        raise LegacyOracleError(
+            f"declared Fortran process row for {generated_process!r} has PDGs "
+            f"{expected.process_pdgs}, incompatible with {tuple(wanted_pdgs)}"
+        )
+    matches = matching_process_entries_for_pdgs(entries, wanted_pdgs)
+    if not matches:
+        raise LegacyOracleError(f"no Fortran process row matches {generated_process!r}")
+    declared_matches = tuple(entry for entry in matches if entry == expected)
+    if len(declared_matches) > 1:
+        raise LegacyOracleError(
+            f"ambiguous duplicate expected Fortran rows for {generated_process!r}"
+        )
+    if not declared_matches:
+        if len(matches) > 1:
+            raise LegacyOracleError(
+                f"ambiguous PDG-only Fortran rows for {generated_process!r}; "
+                f"none matches declared row {expected}"
+            )
+        raise LegacyOracleError(
+            f"Fortran row for {generated_process!r} is {matches[0]}, expected "
+            f"declared row {expected}"
+        )
+    return declared_matches[0], matches
+
+
+def select_generated_process_entry(
+    entries: Sequence[ProcessEntry],
+    *,
+    generated_process: str,
+    wanted_pdgs: Sequence[int],
+) -> tuple[ProcessEntry, tuple[ProcessEntry, ...]]:
+    """Select a deterministic row from a freshly generated process file.
+
+    Performance campaigns generate the process file for the concrete process
+    immediately before selection, so they must not depend on the small frozen
+    row inventory used to certify independent reference fixtures.  Exact
+    external PDG order is preferred; ties retain process-file order.  The
+    complete matching set is returned so callers can record the selection
+    context in their provenance.
+    """
+
+    normalized_pdgs = tuple(int(pdg) for pdg in wanted_pdgs)
+    validate_selected_flow_quark_line_scope(
+        normalized_pdgs,
+        context=f"process {generated_process!r}",
+    )
+    matches = matching_process_entries_for_pdgs(entries, normalized_pdgs)
+    if not matches:
+        raise LegacyOracleError(f"no Fortran process row matches {generated_process!r}")
+    return matches[0], matches
+
+
+def matching_process_entries(
+    entries: Sequence[ProcessEntry], process: str
+) -> tuple[ProcessEntry, ...]:
+    """Prefer the exact requested external order before multiset fallbacks."""
+
+    return matching_process_entries_for_pdgs(entries, process_pdgs(process))
+
+
+def matching_process_entries_for_pdgs(
+    entries: Sequence[ProcessEntry],
+    wanted: Sequence[int],
+) -> tuple[ProcessEntry, ...]:
+    """Match rows using an authoritative ordered external PDG sequence."""
+
+    wanted = tuple(int(value) for value in wanted)
+    wanted_multiset = sorted(wanted)
+    matches = tuple(
+        entry for entry in entries if sorted(entry.process_pdgs) == wanted_multiset
+    )
+    return tuple(entry for entry in matches if entry.process_pdgs == wanted) + tuple(
+        entry for entry in matches if entry.process_pdgs != wanted
+    )
+
+
+def _permutation(
+    source_pdgs: Sequence[int], target_pdgs: Sequence[int]
+) -> tuple[int, ...]:
+    positions: dict[int, deque[int]] = defaultdict(deque)
+    for index, pdg in enumerate(source_pdgs):
+        positions[int(pdg)].append(index)
+    result: list[int] = []
+    for pdg in target_pdgs:
+        queue = positions[int(pdg)]
+        if not queue:
+            raise LegacyOracleError(
+                "cannot map external ordering "
+                f"{tuple(source_pdgs)} to {tuple(target_pdgs)}"
+            )
+        result.append(queue.popleft())
+    if any(positions.values()):
+        raise LegacyOracleError(
+            f"cannot map external ordering {tuple(source_pdgs)} to {tuple(target_pdgs)}"
+        )
+    return tuple(result)
+
+
+def source_mapped_color_order(
+    entry: ProcessEntry,
+    *,
+    source_pdgs: Sequence[int],
+) -> tuple[int, ...]:
+    """Map a raw one-based Fortran color order onto source-leg labels."""
+
+    external_count = len(entry.process_pdgs)
+    expected_positions = tuple(range(1, external_count + 1))
+    actual_positions = tuple(sorted(int(position) for position in entry.color_order))
+    if actual_positions != expected_positions:
+        raise LegacyOracleError(
+            "Fortran color order must be a permutation of external positions "
+            f"1..{external_count}, got {entry.color_order}"
+        )
+    row_to_source = _permutation(source_pdgs, entry.process_pdgs)
+    return tuple(
+        row_to_source[int(row_position) - 1] + 1
+        for row_position in entry.color_order
+    )
+
+
+def _concrete_process_id(
+    processes: Mapping[str, Mapping[str, object]],
+    process_id: str,
+) -> str:
+    seen: set[str] = set()
+    current_id = process_id
+    while processes[current_id]["alias_of"] is not None:
+        if current_id in seen:
+            raise LegacyOracleError(f"process alias cycle includes {current_id}")
+        seen.add(current_id)
+        current_id = str(processes[current_id]["alias_of"])
+        if current_id not in processes:
+            raise LegacyOracleError(
+                f"process {process_id} aliases unknown process {current_id}"
+            )
+    return current_id
+
+
+def _ordered_leg_ids(
+    leg_ids: Sequence[str],
+    positions: Sequence[int],
+    *,
+    context: str,
+) -> tuple[str, ...]:
+    try:
+        result = tuple(leg_ids[position - 1] for position in positions)
+    except IndexError as error:
+        raise LegacyOracleError(
+            f"{context} references an external position outside 1..{len(leg_ids)}"
+        ) from error
+    if any(position < 1 for position in positions):
+        raise LegacyOracleError(
+            f"{context} references an external position outside 1..{len(leg_ids)}"
+        )
+    return result
diff --git a/pyamplicol/tools/developer/madgraph_correctness.py b/pyamplicol/tools/developer/madgraph_correctness.py
new file mode 100644
index 0000000000..198c21a021
--- /dev/null
+++ b/pyamplicol/tools/developer/madgraph_correctness.py
@@ -0,0 +1,626 @@
+# SPDX-License-Identifier: 0BSD
+"""Reusable MadGraph standalone ``smatrix`` correctness driver.
+
+This module owns only standalone generation, process-card binding, compilation
+of the tiny Fortran driver, and deterministic evaluation.  Model-specific
+authentication and performance calibration remain with their callers.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import os
+import re
+import shutil
+import subprocess
+import time
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+
+_DRIVER_OUTPUT_RE = re.compile(
+    r"^PYAMPLICOL_MG_(VALUE|POINTS|SECONDS|CHECKSUM)\s+(\S+)\s*$",
+    re.MULTILINE,
+)
+_IMPORT_FAILURE_RE = re.compile(
+    r"Traceback \(most recent call last\)|UFOImportError|"
+    r"Error detected in .*import model|Failed to load.*model",
+    re.IGNORECASE,
+)
+_PARAMETER_VALUE_RE = re.compile(
+    r"^(?P<prefix>.*\s)(?P<value>[+-]?(?:\d+(?:\.\d*)?|\.\d+)"
+    r"(?:[EeDd][+-]?\d+)?)(?P<trailing>\s*)$"
+)
+
+
+class MadGraphAdapterError(RuntimeError):
+    """The MadGraph standalone correctness contract could not be satisfied."""
+
+
+@dataclass(frozen=True, slots=True)
+class CommandResult:
+    args: tuple[str, ...]
+    cwd: Path
+    elapsed_seconds: float
+    returncode: int
+    stdout: str
+    stderr: str
+
+    def record(self) -> dict[str, object]:
+        return {
+            "args": list(self.args),
+            "cwd": os.fspath(self.cwd.resolve(strict=False)),
+            "elapsed_seconds": self.elapsed_seconds,
+            "returncode": self.returncode,
+        }
+
+
+class CommandExecutor(Protocol):
+    def run(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+    ) -> CommandResult:
+        raise NotImplementedError
+
+
+class SubprocessExecutor:
+    """Small command seam used by unit tests and worker supervision."""
+
+    def run(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+    ) -> CommandResult:
+        rendered = tuple(os.fspath(item) for item in args)
+        started = time.perf_counter()
+        completed = subprocess.run(
+            rendered,
+            cwd=cwd,
+            capture_output=True,
+            check=False,
+            text=True,
+        )
+        return CommandResult(
+            args=rendered,
+            cwd=cwd,
+            elapsed_seconds=time.perf_counter() - started,
+            returncode=completed.returncode,
+            stdout=completed.stdout,
+            stderr=completed.stderr,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class DriverResult:
+    value: float
+    points: int
+    seconds: float
+    checksum: float
+    command: CommandResult
+
+
+@dataclass(frozen=True, slots=True)
+class StandaloneProcess:
+    installation: Path
+    launcher: Path
+    artifact: Path
+    standalone: Path
+    subprocess: Path
+    executable: Path
+    log_path: Path
+    command_card: str
+    generation: CommandResult
+    compilation: CommandResult
+    driver_sha256: str
+
+
+_DRIVER_SOURCE = """\
+program pyamplicol_madgraph_driver
+  use, intrinsic :: iso_fortran_env, only: int64
+  implicit none
+  include 'nexternal.inc'
+  integer :: i, ios, momentum_unit, repetitions, warmup_calls
+  integer(kind=int64) :: clock_start, clock_end, clock_rate
+  real(kind=8) :: p(0:3,nexternal), answer, reference, checksum, seconds
+  character(len=4096) :: momenta_path, param_card_path, raw_argument
+
+  call get_command_argument(1, momenta_path)
+  call get_command_argument(2, param_card_path)
+  call get_command_argument(3, raw_argument)
+  read(raw_argument, *, iostat=ios) repetitions
+  if (ios /= 0 .or. repetitions < 1) error stop 11
+  call get_command_argument(4, raw_argument)
+  read(raw_argument, *, iostat=ios) warmup_calls
+  if (ios /= 0 .or. warmup_calls < 20) error stop 12
+
+  open(newunit=momentum_unit, file=trim(momenta_path), status='old', &
+       action='read', iostat=ios)
+  if (ios /= 0) error stop 13
+  do i = 1, nexternal
+    read(momentum_unit, *, iostat=ios) p(0,i), p(1,i), p(2,i), p(3,i)
+    if (ios /= 0) error stop 14
+  end do
+  close(momentum_unit)
+
+  call setpara(trim(param_card_path))
+  do i = 1, warmup_calls
+    call smatrix(p, answer)
+  end do
+  call smatrix(p, reference)
+
+  checksum = 0.0d0
+  call system_clock(clock_start, clock_rate)
+  do i = 1, repetitions
+    call smatrix(p, answer)
+    if (answer /= reference) error stop 16
+    checksum = checksum + answer
+  end do
+  call system_clock(clock_end)
+  if (clock_rate <= 0) error stop 15
+  seconds = real(clock_end - clock_start, kind=8) / real(clock_rate, kind=8)
+
+  write(*,'(A,1X,ES25.17E3)') 'PYAMPLICOL_MG_VALUE', reference
+  write(*,'(A,1X,I0)') 'PYAMPLICOL_MG_POINTS', repetitions
+  write(*,'(A,1X,ES25.17E3)') 'PYAMPLICOL_MG_SECONDS', seconds
+  write(*,'(A,1X,ES25.17E3)') 'PYAMPLICOL_MG_CHECKSUM', checksum
+end program pyamplicol_madgraph_driver
+"""
+MADGRAPH_DRIVER_SOURCE_SHA256 = hashlib.sha256(
+    _DRIVER_SOURCE.encode("utf-8")
+).hexdigest()
+
+
+def validate_installation(path: Path) -> tuple[Path, Path]:
+    installation = path.expanduser().resolve(strict=True)
+    if not installation.is_dir():
+        raise MadGraphAdapterError(
+            f"MadGraph installation is not a directory: {installation}"
+        )
+    launcher = installation / "bin" / "mg5_aMC"
+    if (
+        not launcher.is_file()
+        or launcher.is_symlink()
+        or not os.access(launcher, os.X_OK)
+    ):
+        raise MadGraphAdapterError(
+            "MadGraph installation must contain a regular executable bin/mg5_aMC"
+        )
+    return installation, launcher
+
+
+def madgraph_command_card(
+    process: str,
+    *,
+    model_import: str = "sm",
+    coupling_orders: Mapping[str, int] | None = None,
+) -> str:
+    if "\n" in process or "\r" in process or not process.strip():
+        raise ValueError("MadGraph process must be one non-empty line")
+    if (
+        "\n" in model_import
+        or "\r" in model_import
+        or not model_import.strip()
+        or any(character.isspace() for character in model_import)
+    ):
+        raise ValueError("MadGraph model import must be one non-empty token")
+    orders = coupling_orders or {}
+    if any(
+        not isinstance(name, str)
+        or not name
+        or not name.isidentifier()
+        or isinstance(value, bool)
+        or not isinstance(value, int)
+        or value < 0
+        for name, value in orders.items()
+    ):
+        raise ValueError("MadGraph coupling orders must be non-negative integers")
+    order_suffix = "".join(f" {name}={orders[name]}" for name in sorted(orders))
+    return "\n".join(
+        (
+            f"import model {model_import}",
+            f"generate {process}{order_suffix}",
+            "output standalone standalone -f",
+            "launch -f",
+            "",
+        )
+    )
+
+
+def reject_failed_generation(
+    result: CommandResult,
+    standalone: Path,
+    *,
+    expected_model_import: str,
+) -> None:
+    output = result.stdout + "\n" + result.stderr
+    if result.returncode != 0:
+        raise MadGraphAdapterError(
+            f"MadGraph exited with {result.returncode}; see madgraph.log"
+        )
+    if _IMPORT_FAILURE_RE.search(output):
+        raise MadGraphAdapterError(
+            "MadGraph reported a UFO import failure; refusing a possible model fallback"
+        )
+    process_card = standalone / "Cards" / "proc_card_mg5.dat"
+    if not process_card.is_file():
+        raise MadGraphAdapterError("MadGraph produced no standalone process card")
+    recorded = process_card.read_text(encoding="utf-8", errors="replace")
+    recorded = re.sub(r"\\\r?\n", "", recorded)
+    import_lines = re.findall(r"(?m)^import model\s+(\S+)(?:\s+.*)?$", recorded)
+    if not import_lines or set(import_lines) != {expected_model_import}:
+        raise MadGraphAdapterError(
+            "standalone process card is not bound exclusively to the requested UFO"
+        )
+
+
+def discover_subprocess(standalone: Path) -> Path:
+    matches = tuple(
+        sorted(
+            path.parent
+            for path in (standalone / "SubProcesses").glob("P*/matrix.f")
+            if path.is_file()
+        )
+    )
+    if len(matches) != 1:
+        raise MadGraphAdapterError(
+            "MadGraph authority requires exactly one generated subprocess; "
+            f"found {len(matches)}"
+        )
+    subprocess_dir = matches[0]
+    required = (
+        subprocess_dir / "matrix.o",
+        standalone / "lib" / "libdhelas.a",
+        standalone / "lib" / "libmodel.a",
+        standalone / "Cards" / "param_card.dat",
+    )
+    missing = tuple(path for path in required if not path.is_file())
+    if missing:
+        raise MadGraphAdapterError(
+            "MadGraph launch did not compile the standalone tree: "
+            + ", ".join(os.fspath(path) for path in missing)
+        )
+    return subprocess_dir
+
+
+def fortran_compiler(standalone: Path) -> str:
+    make_options = standalone / "Source" / "make_opts"
+    source = make_options.read_text(encoding="utf-8", errors="replace")
+    match = re.search(r"(?m)^DEFAULT_F_COMPILER\s*=\s*(\S+)\s*$", source)
+    configured = match.group(1) if match is not None else "gfortran"
+    compiler = shutil.which(configured)
+    if compiler is None:
+        raise MadGraphAdapterError(
+            f"MadGraph's configured Fortran compiler is unavailable: {configured}"
+        )
+    return compiler
+
+
+def parse_driver_output(result: CommandResult, expected_points: int) -> DriverResult:
+    if result.returncode != 0:
+        raise MadGraphAdapterError(
+            f"MadGraph driver exited with {result.returncode}; see madgraph.log"
+        )
+    fields: dict[str, str] = {}
+    for field, raw in _DRIVER_OUTPUT_RE.findall(result.stdout + "\n" + result.stderr):
+        if field in fields:
+            raise MadGraphAdapterError(f"MadGraph driver repeated {field}")
+        fields[field] = raw
+    if set(fields) != {"VALUE", "POINTS", "SECONDS", "CHECKSUM"}:
+        raise MadGraphAdapterError(
+            "MadGraph driver output is incomplete: " + ", ".join(sorted(fields))
+        )
+    try:
+        value = float(fields["VALUE"].replace("D", "E").replace("d", "e"))
+        points = int(fields["POINTS"])
+        seconds = float(fields["SECONDS"].replace("D", "E").replace("d", "e"))
+        checksum = float(fields["CHECKSUM"].replace("D", "E").replace("d", "e"))
+    except ValueError as error:
+        raise MadGraphAdapterError(
+            "MadGraph driver emitted malformed numbers"
+        ) from error
+    if (
+        points != expected_points
+        or not math.isfinite(value)
+        or value < 0.0
+        or not math.isfinite(seconds)
+        or seconds < 0.0
+        or not math.isfinite(checksum)
+    ):
+        raise MadGraphAdapterError(
+            "MadGraph driver emitted invalid timing or value data"
+        )
+    expected_checksum = points * value
+    unit_roundoff = math.ulp(1.0) / 2.0
+    accumulated_roundoff = points * unit_roundoff
+    checksum_rel_tol = max(
+        5.0e-13,
+        accumulated_roundoff / (1.0 - accumulated_roundoff),
+    )
+    if not math.isclose(
+        checksum,
+        expected_checksum,
+        rel_tol=checksum_rel_tol,
+        abs_tol=1.0e-300,
+    ):
+        raise MadGraphAdapterError("MadGraph repeated evaluations changed their value")
+    return DriverResult(value, points, seconds, checksum, result)
+
+
+def momenta_rows(
+    points: object,
+) -> tuple[tuple[float, float, float, float], ...]:
+    if not isinstance(points, tuple) or len(points) != 1:
+        raise MadGraphAdapterError("MadGraph authority requires one validation point")
+    raw_point = points[0]
+    if not isinstance(raw_point, tuple):
+        raise MadGraphAdapterError("MadGraph validation point is malformed")
+    rows: list[tuple[float, float, float, float]] = []
+    for raw_row in raw_point:
+        if not isinstance(raw_row, tuple) or len(raw_row) != 4:
+            raise MadGraphAdapterError("MadGraph validation momentum is malformed")
+        row = tuple(float(component) for component in raw_row)
+        if any(not math.isfinite(component) for component in row):
+            raise MadGraphAdapterError("MadGraph validation momentum is not finite")
+        rows.append(row)  # type: ignore[arg-type]
+    return tuple(rows)
+
+
+def set_parameter_card_values(
+    path: Path,
+    values: Mapping[str, float],
+) -> tuple[str, ...]:
+    """Set named real LHA inputs in an existing MadGraph parameter card."""
+
+    if not values or any(
+        not isinstance(name, str)
+        or not name.isidentifier()
+        or isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(float(value))
+        for name, value in values.items()
+    ):
+        raise ValueError("parameter-card values must be finite named real numbers")
+    try:
+        lines = path.read_text(encoding="ascii").splitlines(keepends=True)
+    except OSError as error:
+        raise MadGraphAdapterError(
+            f"cannot read MadGraph parameter card: {path}"
+        ) from error
+
+    observed: set[str] = set()
+    rewritten: list[str] = []
+    for line in lines:
+        body, marker, comment = line.partition("#")
+        name = (
+            comment.strip().split(maxsplit=1)[0] if marker and comment.strip() else ""
+        )
+        if name not in values:
+            rewritten.append(line)
+            continue
+        if name in observed:
+            raise MadGraphAdapterError(
+                f"MadGraph parameter card repeats external parameter {name}"
+            )
+        newline = "\n" if line.endswith("\n") else ""
+        content = body[:-1] if newline and body.endswith("\n") else body
+        match = _PARAMETER_VALUE_RE.fullmatch(content)
+        if match is None:
+            raise MadGraphAdapterError(
+                f"MadGraph parameter card has a malformed value for {name}"
+            )
+        rendered = f"{float(values[name]):.14e}"
+        rewritten.append(
+            match.group("prefix")
+            + rendered
+            + match.group("trailing")
+            + marker
+            + comment.removesuffix("\n")
+            + newline
+        )
+        observed.add(name)
+
+    missing = sorted(set(values).difference(observed))
+    if missing:
+        raise MadGraphAdapterError(
+            f"MadGraph parameter card lacks required external parameters: {missing!r}"
+        )
+    try:
+        path.write_text("".join(rewritten), encoding="ascii")
+    except OSError as error:
+        raise MadGraphAdapterError(
+            f"cannot update MadGraph parameter card: {path}"
+        ) from error
+    return tuple(sorted(observed))
+
+
+class StandaloneMadGraphRunner:
+    """Generate and drive standalone tree matrix elements."""
+
+    def __init__(self, *, executor: CommandExecutor | None = None) -> None:
+        self.executor = SubprocessExecutor() if executor is None else executor
+
+    @staticmethod
+    def _run_logged(
+        executor: CommandExecutor,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+        log_path: Path,
+    ) -> CommandResult:
+        result = executor.run(args, cwd=cwd)
+        with log_path.open("a", encoding="utf-8") as stream:
+            stream.write("$ " + " ".join(os.fspath(item) for item in args) + "\n")
+            stream.write(result.stdout)
+            if result.stdout and not result.stdout.endswith("\n"):
+                stream.write("\n")
+            stream.write(result.stderr)
+            if result.stderr and not result.stderr.endswith("\n"):
+                stream.write("\n")
+        return result
+
+    def _compile_driver(
+        self,
+        standalone: Path,
+        subprocess_dir: Path,
+        *,
+        log_path: Path,
+    ) -> tuple[Path, CommandResult, str]:
+        source_path = subprocess_dir / "pyamplicol_madgraph_driver.f90"
+        executable = subprocess_dir / "pyamplicol_madgraph_driver"
+        source_path.write_text(_DRIVER_SOURCE, encoding="utf-8")
+        compiler = fortran_compiler(standalone)
+        command = (
+            compiler,
+            "-O3",
+            "-I.",
+            "-I../../Source",
+            "-I../../Source/MODEL",
+            source_path.name,
+            "matrix.o",
+            "-L../../lib",
+            "-ldhelas",
+            "-lmodel",
+            "-o",
+            executable.name,
+        )
+        result = self._run_logged(
+            self.executor,
+            command,
+            cwd=subprocess_dir,
+            log_path=log_path,
+        )
+        if result.returncode != 0 or not executable.is_file():
+            raise MadGraphAdapterError(
+                "custom MadGraph Fortran driver failed to compile; see madgraph.log"
+            )
+        return executable, result, MADGRAPH_DRIVER_SOURCE_SHA256
+
+    def _run_driver(
+        self,
+        executable: Path,
+        *,
+        subprocess_dir: Path,
+        momenta_path: Path,
+        points: int,
+        warmup_calls: int,
+        log_path: Path,
+    ) -> DriverResult:
+        result = self._run_logged(
+            self.executor,
+            (
+                executable,
+                momenta_path,
+                "../../Cards/param_card.dat",
+                str(points),
+                str(warmup_calls),
+            ),
+            cwd=subprocess_dir,
+            log_path=log_path,
+        )
+        return parse_driver_output(result, points)
+
+    def generate(
+        self,
+        *,
+        installation: Path,
+        artifact: Path,
+        process: str,
+        model_import: str,
+        coupling_orders: Mapping[str, int] | None = None,
+    ) -> StandaloneProcess:
+        installation, launcher = validate_installation(installation)
+        artifact = artifact.expanduser().resolve(strict=False)
+        artifact.mkdir(parents=True, exist_ok=True)
+        log_path = artifact / "madgraph.log"
+        standalone = artifact / "standalone"
+        command_card = madgraph_command_card(
+            process,
+            model_import=model_import,
+            coupling_orders=coupling_orders,
+        )
+        command_card_path = artifact / "madgraph_command_card.dat"
+        command_card_path.write_text(command_card, encoding="utf-8")
+        generation = self._run_logged(
+            self.executor,
+            (launcher, command_card_path),
+            cwd=artifact,
+            log_path=log_path,
+        )
+        reject_failed_generation(
+            generation,
+            standalone,
+            expected_model_import=model_import,
+        )
+        subprocess_dir = discover_subprocess(standalone)
+        executable, compilation, driver_sha256 = self._compile_driver(
+            standalone,
+            subprocess_dir,
+            log_path=log_path,
+        )
+        return StandaloneProcess(
+            installation=installation,
+            launcher=launcher,
+            artifact=artifact,
+            standalone=standalone,
+            subprocess=subprocess_dir,
+            executable=executable,
+            log_path=log_path,
+            command_card=command_card,
+            generation=generation,
+            compilation=compilation,
+            driver_sha256=driver_sha256,
+        )
+
+    def evaluate(
+        self,
+        standalone: StandaloneProcess,
+        momenta: Sequence[Sequence[float]],
+        *,
+        repetitions: int = 1,
+        warmup_calls: int = 20,
+    ) -> DriverResult:
+        rows = tuple(tuple(float(component) for component in row) for row in momenta)
+        if any(
+            len(row) != 4 or any(not math.isfinite(component) for component in row)
+            for row in rows
+        ):
+            raise MadGraphAdapterError("MadGraph momenta must be finite four-vectors")
+        momenta_path = standalone.subprocess / "pyamplicol_momenta.dat"
+        momenta_path.write_text(
+            "".join(
+                " ".join(format(component, ".17e") for component in row) + "\n"
+                for row in rows
+            ),
+            encoding="ascii",
+        )
+        return self._run_driver(
+            standalone.executable,
+            subprocess_dir=standalone.subprocess,
+            momenta_path=momenta_path,
+            points=repetitions,
+            warmup_calls=warmup_calls,
+            log_path=standalone.log_path,
+        )
+
+
+__all__ = [
+    "MADGRAPH_DRIVER_SOURCE_SHA256",
+    "CommandExecutor",
+    "CommandResult",
+    "DriverResult",
+    "MadGraphAdapterError",
+    "StandaloneMadGraphRunner",
+    "StandaloneProcess",
+    "SubprocessExecutor",
+    "madgraph_command_card",
+    "momenta_rows",
+    "parse_driver_output",
+    "reject_failed_generation",
+    "set_parameter_card_values",
+    "validate_installation",
+]
diff --git a/pyamplicol/tools/developer/native_direct_cpp_probe.py b/pyamplicol/tools/developer/native_direct_cpp_probe.py
new file mode 100644
index 0000000000..6056788269
--- /dev/null
+++ b/pyamplicol/tools/developer/native_direct_cpp_probe.py
@@ -0,0 +1,805 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Build and measure one genuine compiled-C++ DirectApplication leaf.
+
+The input must be a real schema-v3 compiled-C++ process artifact.  The probe
+loads its retained Symbolica evaluator state, selects the largest compatible
+leaf that consumes a model scalar, emits the optimized instruction stream
+directly against split planes, and compiles a direct-only native library.  The
+original dense library is loaded separately as a parity/timing oracle.
+
+Run this script under ``tools/ci/memory_watchdog.py --limit-gib 30``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ctypes
+import json
+import platform
+import statistics
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from symbolica import CompiledComplexEvaluator, Evaluator
+
+from pyamplicol.evaluators.native_direct_cpp import (
+    NativeDirectCppCompiler,
+    NativeDirectCppParameterKind,
+    NativeDirectCppSpec,
+    compile_native_direct_cpp,
+    render_native_direct_cpp,
+)
+from pyamplicol.generation.evaluator_container import PacbinReader
+
+
+@dataclass(frozen=True, slots=True)
+class RetainedLeaf:
+    process_id: str
+    stage_index: int
+    chunk_index: int
+    function_name: str
+    input_len: int
+    output_len: int
+    parameter_kinds: tuple[NativeDirectCppParameterKind, ...]
+    source_path: Path
+    library_path: Path
+    evaluator: Any
+    instruction_count: int
+
+
+class InputPlane(ctypes.Structure):
+    _fields_ = [("values", ctypes.POINTER(ctypes.c_double))]
+
+
+class OutputPlane(ctypes.Structure):
+    _fields_ = [("values", ctypes.POINTER(ctypes.c_double))]
+
+
+class Scalar(ctypes.Structure):
+    _fields_ = [("value", ctypes.POINTER(ctypes.c_double))]
+
+
+class Metadata(ctypes.Structure):
+    _fields_ = [
+        ("abi_version", ctypes.c_uint32),
+        ("struct_size", ctypes.c_uint32),
+        ("flags", ctypes.c_uint32),
+        ("input_plane_count", ctypes.c_uint32),
+        ("scalar_input_count", ctypes.c_uint32),
+        ("output_plane_count", ctypes.c_uint32),
+        ("simd_lane_width", ctypes.c_uint32),
+        ("reserved", ctypes.c_uint32),
+    ]
+
+
+@dataclass(slots=True)
+class BoundDirectCall:
+    function: Any
+    input_descriptors: Any
+    scalar_descriptors: Any
+    output_descriptors: Any
+    input_planes: list[np.ndarray]
+    scalar_values: list[ctypes.c_double]
+    output_planes: list[np.ndarray]
+    input_count: int
+    scalar_count: int
+    output_count: int
+
+    def evaluate(self, point_start: int, point_count: int) -> int:
+        return int(
+            self.function(
+                self.input_descriptors,
+                self.input_count,
+                self.scalar_descriptors,
+                self.scalar_count,
+                self.output_descriptors,
+                self.output_count,
+                point_start,
+                point_count,
+            )
+        )
+
+
+def _arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("artifact", type=Path)
+    parser.add_argument(
+        "--process",
+        help="stable process id; defaults to the artifact default process",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("/private/tmp/pyamplicol-native-direct-cpp-probe"),
+    )
+    parser.add_argument("--compiler", default="c++")
+    parser.add_argument("--optimization-level", type=int, default=3)
+    parser.add_argument("--simd-lane-width", type=int, default=2)
+    parser.add_argument("--points", type=int, default=129)
+    parser.add_argument("--stride", type=int, default=136)
+    parser.add_argument("--samples", type=int, default=7)
+    parser.add_argument("--repeats", type=int, default=2_000)
+    parser.add_argument("--json-out", type=Path)
+    return parser.parse_args()
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise RuntimeError(f"could not read JSON document {path}") from error
+    if not isinstance(value, dict):
+        raise RuntimeError(f"JSON document is not an object: {path}")
+    return value
+
+
+def _process_id(outer: dict[str, Any], requested: str | None) -> str:
+    if requested is not None:
+        return requested
+    default = outer.get("default_process_id")
+    if not isinstance(default, str) or not default:
+        raise RuntimeError("artifact has no default process id")
+    return default
+
+
+def _parameter_kind(component: dict[str, Any]) -> NativeDirectCppParameterKind:
+    storage_is_scalar = component.get("kind") == "model_parameter"
+    real_valued = component.get("real_valued") is True
+    if storage_is_scalar:
+        return (
+            NativeDirectCppParameterKind.REAL_SCALAR
+            if real_valued
+            else NativeDirectCppParameterKind.COMPLEX_SCALAR
+        )
+    return (
+        NativeDirectCppParameterKind.REAL_PLANE
+        if real_valued
+        else NativeDirectCppParameterKind.COMPLEX_PLANE
+    )
+
+
+def _load_evaluator_state(
+    reader: PacbinReader,
+    logical_path: str,
+) -> Any:
+    member = reader.member(logical_path)
+    payload = reader.read_member(logical_path, length=member.length)
+    return Evaluator.load(payload)
+
+
+def _select_retained_leaf(
+    artifact: Path,
+    process_id: str,
+    target_triple: str,
+    cpu_features: tuple[str, ...],
+    lane_width: int,
+) -> RetainedLeaf:
+    process_root = artifact / "processes" / process_id
+    execution = _read_json(process_root / "execution.json")
+    compiled = execution.get("compiled")
+    if not isinstance(compiled, dict):
+        raise RuntimeError("process has no compiled execution blueprint")
+    stage_evaluators = compiled.get("stage_evaluators")
+    if not isinstance(stage_evaluators, dict):
+        raise RuntimeError("process has no compiled stage evaluators")
+    stages = stage_evaluators.get("stages")
+    if not isinstance(stages, list):
+        raise RuntimeError("compiled stage evaluator list is absent")
+
+    candidates: list[RetainedLeaf] = []
+    with PacbinReader.open(
+        artifact / "evaluators.pacbin",
+        verify_payloads=True,
+    ) as reader:
+        for stage_ordinal, raw_stage in enumerate(stages):
+            if not isinstance(raw_stage, dict):
+                continue
+            raw_components = raw_stage.get("input_components")
+            evaluator = raw_stage.get("evaluator")
+            if not isinstance(raw_components, list) or not isinstance(evaluator, dict):
+                continue
+            components: dict[int, dict[str, Any]] = {}
+            for raw_component in raw_components:
+                if not isinstance(raw_component, dict):
+                    continue
+                parameter_index = raw_component.get("parameter_index")
+                if isinstance(parameter_index, int) and not isinstance(
+                    parameter_index, bool
+                ):
+                    components[parameter_index] = raw_component
+            chunks = evaluator.get("chunks")
+            maps = evaluator.get("chunk_input_indices")
+            if not isinstance(chunks, list) or not isinstance(maps, list):
+                continue
+            for chunk_index, (raw_chunk, raw_map) in enumerate(
+                zip(chunks, maps, strict=True)
+            ):
+                if not isinstance(raw_chunk, dict) or not isinstance(raw_map, list):
+                    continue
+                try:
+                    parent_indices = tuple(int(index) for index in raw_map)
+                    kinds = tuple(
+                        _parameter_kind(components[index]) for index in parent_indices
+                    )
+                except (KeyError, TypeError, ValueError):
+                    continue
+                if not any(
+                    kind
+                    in {
+                        NativeDirectCppParameterKind.REAL_SCALAR,
+                        NativeDirectCppParameterKind.COMPLEX_SCALAR,
+                    }
+                    for kind in kinds
+                ):
+                    continue
+                function_name = raw_chunk.get("function_name")
+                state_path = raw_chunk.get("evaluator_state_path")
+                source_path = raw_chunk.get("source_path")
+                library_path = raw_chunk.get("library_path")
+                input_len = raw_chunk.get("input_len")
+                output_len = raw_chunk.get("output_len")
+                if not isinstance(source_path, str) and isinstance(library_path, str):
+                    # Repackaged manifests deliberately omit the source path
+                    # key, but retain it beside the native library.
+                    source_path = str(
+                        Path(library_path).parent
+                        / (
+                            f"{function_name}.cpp"
+                            if isinstance(function_name, str)
+                            else ""
+                        )
+                    )
+                if (
+                    not isinstance(function_name, str)
+                    or not isinstance(state_path, str)
+                    or not isinstance(source_path, str)
+                    or not isinstance(library_path, str)
+                    or not isinstance(input_len, int)
+                    or not isinstance(output_len, int)
+                    or len(kinds) != input_len
+                ):
+                    continue
+                logical_state_path = f"processes/{process_id}/{state_path}"
+                try:
+                    source_evaluator = _load_evaluator_state(
+                        reader,
+                        logical_state_path,
+                    )
+                    spec = NativeDirectCppSpec(
+                        function_name=function_name,
+                        parameter_kinds=kinds,
+                        output_count=output_len,
+                        target_triple=target_triple,
+                        cpu_features=cpu_features,
+                        simd_lane_width=lane_width,
+                    )
+                    rendered = render_native_direct_cpp(source_evaluator, spec)
+                except Exception:
+                    continue
+                candidates.append(
+                    RetainedLeaf(
+                        process_id=process_id,
+                        stage_index=int(raw_stage.get("stage_index", stage_ordinal)),
+                        chunk_index=chunk_index,
+                        function_name=function_name,
+                        input_len=input_len,
+                        output_len=output_len,
+                        parameter_kinds=kinds,
+                        source_path=process_root / Path(source_path),
+                        library_path=process_root / Path(library_path),
+                        evaluator=source_evaluator,
+                        instruction_count=rendered.instruction_count,
+                    )
+                )
+    if not candidates:
+        raise RuntimeError(
+            "no genuine compiled leaf with a model scalar fits the fail-closed "
+            "native DirectApplication instruction subset"
+        )
+    return max(
+        candidates,
+        key=lambda candidate: (
+            candidate.instruction_count,
+            candidate.output_len,
+            -candidate.stage_index,
+            -candidate.chunk_index,
+        ),
+    )
+
+
+def _pointer(array: np.ndarray) -> ctypes.POINTER(ctypes.c_double):
+    if array.dtype != np.float64 or not array.flags.c_contiguous:
+        raise RuntimeError("direct plane is not contiguous float64")
+    return array.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
+
+
+def _bind_direct(
+    library: Any,
+    leaf: RetainedLeaf,
+    dense_inputs: np.ndarray,
+    stride: int,
+) -> BoundDirectCall:
+    input_planes: list[np.ndarray] = []
+    scalar_values: list[ctypes.c_double] = []
+    for parameter, kind in enumerate(leaf.parameter_kinds):
+        values = dense_inputs[:, parameter]
+        if kind is NativeDirectCppParameterKind.COMPLEX_PLANE:
+            input_planes.append(np.ascontiguousarray(values.real))
+            input_planes.append(np.ascontiguousarray(values.imag))
+        elif kind is NativeDirectCppParameterKind.REAL_PLANE:
+            input_planes.append(np.ascontiguousarray(values.real))
+        elif kind is NativeDirectCppParameterKind.COMPLEX_SCALAR:
+            scalar_values.append(ctypes.c_double(float(values[0].real)))
+            scalar_values.append(ctypes.c_double(float(values[0].imag)))
+        else:
+            scalar_values.append(ctypes.c_double(float(values[0].real)))
+    input_descriptors = (InputPlane * len(input_planes))(
+        *(InputPlane(_pointer(values)) for values in input_planes)
+    )
+    scalar_descriptors = (Scalar * len(scalar_values))(
+        *(Scalar(ctypes.pointer(value)) for value in scalar_values)
+    )
+    output_planes = [
+        np.full(stride, np.nan, dtype=np.float64) for _ in range(2 * leaf.output_len)
+    ]
+    output_descriptors = (OutputPlane * len(output_planes))(
+        *(OutputPlane(_pointer(values)) for values in output_planes)
+    )
+    symbol = getattr(library, f"{leaf.function_name}_direct_application_v1")
+    symbol.argtypes = [
+        ctypes.POINTER(InputPlane),
+        ctypes.c_uint32,
+        ctypes.POINTER(Scalar),
+        ctypes.c_uint32,
+        ctypes.POINTER(OutputPlane),
+        ctypes.c_uint32,
+        ctypes.c_uint32,
+        ctypes.c_uint32,
+    ]
+    symbol.restype = ctypes.c_int
+    return BoundDirectCall(
+        function=symbol,
+        input_descriptors=input_descriptors,
+        scalar_descriptors=scalar_descriptors,
+        output_descriptors=output_descriptors,
+        input_planes=input_planes,
+        scalar_values=scalar_values,
+        output_planes=output_planes,
+        input_count=len(input_planes),
+        scalar_count=len(scalar_values),
+        output_count=len(output_planes),
+    )
+
+
+def _metadata(
+    library: Any,
+    leaf: RetainedLeaf,
+) -> tuple[Metadata, dict[str, object]]:
+    prefix = f"{leaf.function_name}_direct_application_v1"
+    metadata_function = getattr(library, f"{prefix}_metadata")
+    metadata_function.argtypes = []
+    metadata_function.restype = Metadata
+    metadata = metadata_function()
+    strings: dict[str, object] = {}
+    for suffix in ("target_triple", "cpu_features", "source_sha256"):
+        function = getattr(library, f"{prefix}_{suffix}")
+        function.argtypes = []
+        function.restype = ctypes.c_char_p
+        raw = function()
+        if raw is None:
+            raise RuntimeError(f"direct metadata string {suffix} is null")
+        strings[suffix] = raw.decode("ascii")
+    stack_function = getattr(library, f"{prefix}_logical_stack_bytes")
+    stack_function.argtypes = []
+    stack_function.restype = ctypes.c_uint32
+    strings["logical_stack_bytes"] = int(stack_function())
+    return metadata, strings
+
+
+def _deterministic_inputs(
+    leaf: RetainedLeaf,
+    stride: int,
+) -> np.ndarray:
+    rng = np.random.default_rng(0xD1EC7A)
+    values = (
+        rng.normal(0.0, 0.25, size=(stride, leaf.input_len))
+        + 1j * rng.normal(0.0, 0.25, size=(stride, leaf.input_len))
+    ).astype(np.complex128)
+    for parameter, kind in enumerate(leaf.parameter_kinds):
+        if kind in {
+            NativeDirectCppParameterKind.REAL_PLANE,
+            NativeDirectCppParameterKind.REAL_SCALAR,
+        }:
+            values[:, parameter].imag = 0.0
+        if kind in {
+            NativeDirectCppParameterKind.REAL_SCALAR,
+            NativeDirectCppParameterKind.COMPLEX_SCALAR,
+        }:
+            scalar = complex(values[0, parameter])
+            if kind is NativeDirectCppParameterKind.REAL_SCALAR:
+                scalar = complex(0.375, 0.0)
+            values[:, parameter] = scalar
+    values[0, 0] = complex(values[0, 0].real, -0.0)
+    return values
+
+
+def _resolved_direct_outputs(
+    bound: BoundDirectCall,
+    start: int,
+    count: int,
+    output_len: int,
+) -> np.ndarray:
+    stop = start + count
+    return np.column_stack(
+        [
+            bound.output_planes[2 * output][start:stop]
+            + 1j * bound.output_planes[2 * output + 1][start:stop]
+            for output in range(output_len)
+        ]
+    )
+
+
+def _test_parity_and_tails(
+    dense: Any,
+    dense_inputs: np.ndarray,
+    bound: BoundDirectCall,
+    leaf: RetainedLeaf,
+    points: int,
+    stride: int,
+) -> dict[str, object]:
+    expected = np.asarray(dense.evaluate(dense_inputs), dtype=np.complex128)
+    if expected.shape != (stride, leaf.output_len):
+        raise RuntimeError(f"dense oracle returned unexpected shape {expected.shape}")
+    tail_ranges = (
+        (0, 1),
+        (0, 2),
+        (0, 3),
+        (0, min(127, points)),
+        (1, min(127, points - 1)),
+        (0, min(128, points)),
+        (0, points),
+    )
+    maximum_error = 0.0
+    for start, count in tail_ranges:
+        if count < 1:
+            continue
+        for plane in bound.output_planes:
+            plane.fill(np.nan)
+        status = bound.evaluate(start, count)
+        if status != 0:
+            raise RuntimeError(
+                f"direct leaf returned status {status} for range {start}+{count}"
+            )
+        actual = _resolved_direct_outputs(
+            bound,
+            start,
+            count,
+            leaf.output_len,
+        )
+        reference = expected[start : start + count]
+        np.testing.assert_allclose(actual, reference, rtol=1e-12, atol=1e-15)
+        maximum_error = max(
+            maximum_error,
+            float(np.max(np.abs(actual - reference), initial=0.0)),
+        )
+        for plane in bound.output_planes:
+            if (
+                not np.isnan(plane[:start]).all()
+                or not np.isnan(plane[start + count :]).all()
+            ):
+                raise RuntimeError(
+                    "direct odd-tail call overwrote an inactive sentinel"
+                )
+
+    bound.output_descriptors[0].values = bound.input_descriptors[0].values
+    alias_status = bound.evaluate(0, 1)
+    bound.output_descriptors[0].values = _pointer(bound.output_planes[0])
+    if alias_status != 4:
+        raise RuntimeError(
+            f"native direct input/output alias returned {alias_status}, expected 4"
+        )
+    count_status = int(
+        bound.function(
+            bound.input_descriptors,
+            bound.input_count - 1,
+            bound.scalar_descriptors,
+            bound.scalar_count,
+            bound.output_descriptors,
+            bound.output_count,
+            0,
+            1,
+        )
+    )
+    if count_status != 2:
+        raise RuntimeError(
+            f"native direct descriptor mismatch returned {count_status}, expected 2"
+        )
+    return {
+        "ranges": [list(item) for item in tail_ranges],
+        "maximum_absolute_error": maximum_error,
+        "rtol": 1e-12,
+        "atol": 1e-15,
+        "alias_status": alias_status,
+        "descriptor_count_status": count_status,
+    }
+
+
+def _median_mad(values: list[int]) -> tuple[float, float]:
+    median = float(statistics.median(values))
+    mad = float(statistics.median(abs(value - median) for value in values))
+    return median, mad
+
+
+def _sample(
+    function: Any,
+    *,
+    samples: int,
+    repeats: int,
+) -> list[int]:
+    output: list[int] = []
+    for _sample in range(samples):
+        started = time.perf_counter_ns()
+        for _repeat in range(repeats):
+            function()
+        output.append((time.perf_counter_ns() - started) // repeats)
+    return output
+
+
+def _timings(
+    dense: Any,
+    dense_inputs: np.ndarray,
+    bound: BoundDirectCall,
+    leaf: RetainedLeaf,
+    points: int,
+    samples: int,
+    repeats: int,
+) -> dict[str, object]:
+    packed = np.empty((points, leaf.input_len), dtype=np.complex128)
+    scattered = np.empty((points, leaf.output_len), dtype=np.complex128)
+    dense_view = dense_inputs[:points]
+
+    def direct_call() -> None:
+        status = bound.evaluate(0, points)
+        if status != 0:
+            raise RuntimeError(f"timed direct leaf returned status {status}")
+
+    def dense_prepacked() -> None:
+        result = dense.evaluate(dense_view)
+        if np.asarray(result).shape != scattered.shape:
+            raise RuntimeError("timed dense oracle changed shape")
+
+    def dense_gather_call_scatter() -> None:
+        packed[:, :] = dense_view
+        result = np.asarray(dense.evaluate(packed), dtype=np.complex128)
+        scattered[:, :] = result
+
+    direct_call()
+    dense_prepacked()
+    dense_gather_call_scatter()
+    direct_samples: list[int] = []
+    raw_samples: list[int] = []
+    full_samples: list[int] = []
+    for sample in range(samples):
+        paths = (
+            (
+                ("direct", direct_call),
+                ("raw_dense", dense_prepacked),
+                ("full_dense", dense_gather_call_scatter),
+            )
+            if sample % 2 == 0
+            else (
+                ("full_dense", dense_gather_call_scatter),
+                ("raw_dense", dense_prepacked),
+                ("direct", direct_call),
+            )
+        )
+        for label, function in paths:
+            values = _sample(function, samples=1, repeats=repeats)
+            {
+                "direct": direct_samples,
+                "raw_dense": raw_samples,
+                "full_dense": full_samples,
+            }[label].extend(values)
+    direct_median, direct_mad = _median_mad(direct_samples)
+    raw_median, raw_mad = _median_mad(raw_samples)
+    full_median, full_mad = _median_mad(full_samples)
+    return {
+        "boundary": (
+            "Python FFI probe: raw_dense is prepacked CompiledComplexEvaluator; "
+            "full_dense adds NumPy gather/scatter; direct is one prebound native call"
+        ),
+        "points": points,
+        "samples": samples,
+        "repeats": repeats,
+        "direct_ns_per_call": direct_samples,
+        "raw_dense_ns_per_call": raw_samples,
+        "full_dense_ns_per_call": full_samples,
+        "direct_median_ns_per_call": direct_median,
+        "direct_mad_ns_per_call": direct_mad,
+        "raw_dense_median_ns_per_call": raw_median,
+        "raw_dense_mad_ns_per_call": raw_mad,
+        "full_dense_median_ns_per_call": full_median,
+        "full_dense_mad_ns_per_call": full_mad,
+        "direct_ns_per_point": direct_median / points,
+        "raw_dense_ns_per_point": raw_median / points,
+        "full_dense_ns_per_point": full_median / points,
+        "raw_dense_over_direct": raw_median / direct_median,
+        "full_dense_over_direct": full_median / direct_median,
+    }
+
+
+def main() -> int:
+    args = _arguments()
+    if args.points < 3 or args.stride < args.points:
+        raise RuntimeError("probe stride must cover at least three active points")
+    if args.samples < 3 or args.samples % 2 == 0 or args.repeats < 1:
+        raise RuntimeError("probe needs an odd sample count >= 3 and positive repeats")
+    artifact = args.artifact.resolve()
+    outer = _read_json(artifact / "artifact.json")
+    process_id = _process_id(outer, args.process)
+    producer = outer.get("producer")
+    target = producer.get("target") if isinstance(producer, dict) else None
+    if not isinstance(target, dict):
+        raise RuntimeError("artifact producer target metadata is absent")
+    target_triple = target.get("triple")
+    raw_cpu_features = target.get("cpu_features")
+    if not isinstance(target_triple, str) or not isinstance(raw_cpu_features, list):
+        raise RuntimeError("artifact producer target metadata is invalid")
+    cpu_features = tuple(str(feature) for feature in raw_cpu_features)
+    leaf = _select_retained_leaf(
+        artifact,
+        process_id,
+        target_triple,
+        cpu_features,
+        args.simd_lane_width,
+    )
+    spec = NativeDirectCppSpec(
+        function_name=leaf.function_name,
+        parameter_kinds=leaf.parameter_kinds,
+        output_count=leaf.output_len,
+        target_triple=target_triple,
+        cpu_features=cpu_features,
+        simd_lane_width=args.simd_lane_width,
+    )
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    direct_source = args.output_dir / f"{leaf.function_name}.direct.cpp"
+    direct_library = args.output_dir / f"lib{leaf.function_name}.direct"
+    compiler = NativeDirectCppCompiler(
+        executable=args.compiler,
+        optimization_level=args.optimization_level,
+        native_arch=bool(cpu_features),
+        extra_flags=(),
+    )
+    built = compile_native_direct_cpp(
+        leaf.evaluator,
+        spec=spec,
+        compiler=compiler,
+        output_source_path=direct_source,
+        output_library_path=direct_library,
+    )
+    library = ctypes.CDLL(str(built.library_path))
+    metadata, auxiliary_metadata = _metadata(library, leaf)
+    if metadata.abi_version != 1 or metadata.struct_size != ctypes.sizeof(Metadata):
+        raise RuntimeError("native direct primary metadata is incompatible")
+    if metadata.flags != 0x3F or metadata.reserved != 0:
+        raise RuntimeError("native direct primary metadata flags are incompatible")
+    if auxiliary_metadata["target_triple"] != target_triple:
+        raise RuntimeError("native direct target triple metadata changed")
+    if auxiliary_metadata["cpu_features"] != ",".join(cpu_features):
+        raise RuntimeError("native direct CPU feature metadata changed")
+    if auxiliary_metadata["source_sha256"] != built.source.evaluator_state_sha256:
+        raise RuntimeError("native direct source-state digest metadata changed")
+
+    dense_inputs = _deterministic_inputs(leaf, args.stride)
+    dense = CompiledComplexEvaluator.load(
+        str(leaf.library_path),
+        leaf.function_name,
+        leaf.input_len,
+        leaf.output_len,
+    )
+    bound = _bind_direct(library, leaf, dense_inputs, args.stride)
+    if (
+        metadata.input_plane_count != bound.input_count
+        or metadata.scalar_input_count != bound.scalar_count
+        or metadata.output_plane_count != bound.output_count
+        or metadata.simd_lane_width != args.simd_lane_width
+    ):
+        raise RuntimeError("native direct descriptor metadata disagrees with bindings")
+    parity = _test_parity_and_tails(
+        dense,
+        dense_inputs,
+        bound,
+        leaf,
+        args.points,
+        args.stride,
+    )
+    timings = _timings(
+        dense,
+        dense_inputs,
+        bound,
+        leaf,
+        args.points,
+        args.samples,
+        args.repeats,
+    )
+    dense_source_bytes = leaf.source_path.stat().st_size
+    dense_library_bytes = leaf.library_path.stat().st_size
+    direct_source_bytes = built.source_path.stat().st_size
+    direct_library_bytes = built.library_path.stat().st_size
+    artifact_bytes = sum(
+        path.stat().st_size for path in artifact.rglob("*") if path.is_file()
+    )
+    payload_delta = (
+        direct_source_bytes
+        - dense_source_bytes
+        + direct_library_bytes
+        - dense_library_bytes
+    )
+    result = {
+        "schema_version": 1,
+        "status": "pass",
+        "artifact": str(artifact),
+        "artifact_id": outer.get("artifact_id"),
+        "process_id": process_id,
+        "host": {
+            "platform": platform.platform(),
+            "machine": platform.machine(),
+            "python": sys.version.split()[0],
+        },
+        "leaf": {
+            "stage_index": leaf.stage_index,
+            "chunk_index": leaf.chunk_index,
+            "function_name": leaf.function_name,
+            "input_len": leaf.input_len,
+            "output_len": leaf.output_len,
+            "parameter_kinds": [kind.value for kind in leaf.parameter_kinds],
+            "instruction_count": built.source.instruction_count,
+            "temporary_count": built.source.temporary_count,
+            "input_plane_count": built.source.input_plane_count,
+            "scalar_input_count": built.source.scalar_input_count,
+            "output_plane_count": built.source.output_plane_count,
+            "logical_stack_bytes": built.source.logical_stack_bytes,
+            "evaluator_state_sha256": built.source.evaluator_state_sha256,
+        },
+        "producer": {
+            "abi": "pyamplicol-native-compiled-direct-application-v1",
+            "target_triple": target_triple,
+            "cpu_features": list(cpu_features),
+            "simd_lane_width": args.simd_lane_width,
+            "source_path": str(built.source_path),
+            "library_path": str(built.library_path),
+            "compiler_command": list(built.compiler_command),
+            "compile_seconds": built.compile_seconds,
+            "direct_source_calls_dense_symbol": (
+                f"{leaf.function_name}_complexf64(" in built.source.source
+            ),
+        },
+        "parity": parity,
+        "timings": timings,
+        "payload": {
+            "original_artifact_bytes": artifact_bytes,
+            "dense_source_bytes": dense_source_bytes,
+            "direct_source_bytes": direct_source_bytes,
+            "dense_library_bytes": dense_library_bytes,
+            "direct_library_bytes": direct_library_bytes,
+            "replacement_delta_bytes": payload_delta,
+            "replacement_delta_fraction_of_artifact": payload_delta / artifact_bytes,
+        },
+    }
+    if result["producer"]["direct_source_calls_dense_symbol"]:
+        raise RuntimeError("generated direct entry contains a forbidden dense call")
+    serialized = json.dumps(result, indent=2, sort_keys=True)
+    print(serialized)
+    if args.json_out is not None:
+        args.json_out.parent.mkdir(parents=True, exist_ok=True)
+        args.json_out.write_text(f"{serialized}\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/numerical_acceptance.py b/pyamplicol/tools/developer/numerical_acceptance.py
new file mode 100644
index 0000000000..6127ef622b
--- /dev/null
+++ b/pyamplicol/tools/developer/numerical_acceptance.py
@@ -0,0 +1,2005 @@
+# SPDX-License-Identifier: 0BSD
+"""Durable UFO-SM numerical acceptance capture and replay.
+
+The fixture written by this module deliberately contains one deterministic
+point and one fully summed matrix element per process.  Full-colour values are
+independent MadGraph standalone results.  LC and NLC values are high-precision
+recurrence regression references captured only after the full-colour gate has
+passed.
+
+Normal unit tests exercise the wire contract with synthetic values.  Real
+generation is entered either through :class:`NumericalAcceptanceHarness` or
+the ``capture`` command and is intentionally not part of the default test run.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.metadata
+import json
+import math
+import re
+import sys
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation, localcontext
+from pathlib import Path
+from typing import Literal, cast
+
+ROOT = Path(__file__).resolve().parents[2]
+if __package__ in {None, ""}:
+    sys.path.insert(0, str(ROOT))
+
+from tools.developer.reference_capture.common import canonical_decimal  # noqa: E402
+from tools.performance_report.catalog import PROCESS_FAMILIES  # noqa: E402
+
+MODEL_ROOT = ROOT / "src" / "pyamplicol" / "assets" / "models" / "json" / "sm"
+MODEL_SOURCE = MODEL_ROOT / "sm.json"
+MODEL_RESTRICTION = MODEL_ROOT / "restrict_default.json"
+DEFAULT_FIXTURE = (
+    ROOT / "tests" / "fixtures" / "numerical_acceptance" / "ufo-sm-seed101-v1.json"
+)
+
+FIXTURE_KIND = "pyamplicol-ufo-sm-numerical-acceptance"
+FIXTURE_SCHEMA_VERSION = 1
+CATALOG_MAX_N_FINAL = 4
+CATALOG_CASE_COUNT = 33
+POINT_SEED = 101
+RELATIVE_TOLERANCE = Decimal("0.0000000001")
+FULL_CANDIDATE_PRECISION_DIGITS = 200
+NATIVE_PRECISION_DIGITS = 16
+
+AccuracyName = Literal["full", "lc", "nlc"]
+ModeName = Literal["recurrence", "eager", "compiled", "on-the-fly"]
+LCFlowLayoutName = Literal["topology-replay", "all-flow-union"]
+ArtifactGroup = Literal["catalog", "extra"]
+
+_SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
+_REVISION_RE = re.compile(r"^[0-9a-f]{40}$")
+
+
+class NumericalAcceptanceError(RuntimeError):
+    """The acceptance fixture or capture contract is invalid."""
+
+
+class NumericalAcceptanceMismatch(AssertionError):
+    """A matrix element failed the strict scale-conditioned comparison."""
+
+
+@dataclass(frozen=True, slots=True)
+class AcceptanceCaseSpec:
+    """One catalog or deliberately separate full-colour stress process."""
+
+    case_id: str
+    process: str
+    n_final: int
+    family_id: int | None = None
+    family_key: str | None = None
+
+    @property
+    def is_catalog(self) -> bool:
+        return self.family_id is not None
+
+    @property
+    def artifact_name(self) -> str:
+        """Return a stable public ProcessSet name accepted by pyAmpliCol."""
+
+        return self.case_id.replace(":", "_").replace("-", "_")
+
+
+def catalog_cases() -> tuple[AcceptanceCaseSpec, ...]:
+    """Derive the complete 33-process n=1..4 catalog surface."""
+
+    cases: list[AcceptanceCaseSpec] = []
+    for n_final in range(1, CATALOG_MAX_N_FINAL + 1):
+        for family in sorted(PROCESS_FAMILIES, key=lambda item: item.identifier):
+            process = family.process(n_final)
+            if process is None:
+                continue
+            cases.append(
+                AcceptanceCaseSpec(
+                    case_id=f"catalog:{family.key}:n{n_final}",
+                    process=process,
+                    n_final=n_final,
+                    family_id=family.identifier,
+                    family_key=family.key,
+                )
+            )
+    result = tuple(cases)
+    if len(result) != CATALOG_CASE_COUNT:
+        raise NumericalAcceptanceError(
+            "the n=1..4 performance catalog no longer contains exactly "
+            f"{CATALOG_CASE_COUNT} processes (observed {len(result)})"
+        )
+    return result
+
+
+EXTRA_FULL_COLOUR_CASES = (
+    AcceptanceCaseSpec(
+        case_id="extra:identical-u-four-lines",
+        process="u u~ > u u~ u u~ u u~",
+        n_final=6,
+    ),
+    AcceptanceCaseSpec(
+        case_id="extra:identical-electron-three-pair",
+        process="e+ e- > e+ e- e+ e- e+ e-",
+        n_final=6,
+    ),
+)
+
+
+@dataclass(frozen=True, slots=True)
+class AcceptanceLane:
+    """One native generation/evaluation lane in the acceptance matrix."""
+
+    accuracy: AccuracyName
+    mode: ModeName
+    jit_optimization_level: int
+    lc_flow_layout: LCFlowLayoutName = "topology-replay"
+
+    def __post_init__(self) -> None:
+        if self.lc_flow_layout == "all-flow-union" and self.accuracy != "lc":
+            raise ValueError("all-flow-union acceptance is available only for LC")
+        if self.lc_flow_layout == "all-flow-union" and self.mode == "on-the-fly":
+            raise ValueError(
+                "on-the-fly acceptance uses its compact query-local LC artifact"
+            )
+
+    @property
+    def lane_id(self) -> str:
+        if self.lc_flow_layout == "all-flow-union":
+            return f"lc-all-flow-union-{self.mode}"
+        return f"{self.accuracy}-{self.mode}"
+
+    @property
+    def includes_extra_cases(self) -> bool:
+        return self.accuracy == "full"
+
+    @property
+    def evaluation_precisions(self) -> tuple[int, ...]:
+        """Return the supported acceptance precisions for this lane."""
+
+        if self.accuracy == "full" and self.mode != "on-the-fly":
+            return (NATIVE_PRECISION_DIGITS, FULL_CANDIDATE_PRECISION_DIGITS)
+        return (NATIVE_PRECISION_DIGITS,)
+
+    def evaluation_precisions_for(
+        self,
+        group: ArtifactGroup,
+    ) -> tuple[int, ...]:
+        """Return the minimal precision replay for one artifact group."""
+
+        if group == "extra":
+            return (NATIVE_PRECISION_DIGITS,)
+        return self.evaluation_precisions
+
+
+ACCEPTANCE_LANES = (
+    AcceptanceLane("full", "recurrence", 2),
+    AcceptanceLane("full", "eager", 2),
+    AcceptanceLane("full", "compiled", 3),
+    AcceptanceLane("full", "on-the-fly", 2),
+    AcceptanceLane("lc", "recurrence", 2),
+    AcceptanceLane("lc", "eager", 2),
+    AcceptanceLane("lc", "compiled", 3),
+    AcceptanceLane("lc", "on-the-fly", 2),
+    AcceptanceLane("lc", "recurrence", 2, "all-flow-union"),
+    AcceptanceLane("lc", "eager", 2, "all-flow-union"),
+    AcceptanceLane("lc", "compiled", 3, "all-flow-union"),
+    AcceptanceLane("nlc", "recurrence", 2),
+    AcceptanceLane("nlc", "eager", 2),
+    AcceptanceLane("nlc", "compiled", 3),
+    AcceptanceLane("nlc", "on-the-fly", 2),
+)
+FULL_LANES = tuple(lane for lane in ACCEPTANCE_LANES if lane.accuracy == "full")
+LC_ALL_FLOW_UNION_LANES = tuple(
+    lane for lane in ACCEPTANCE_LANES if lane.lc_flow_layout == "all-flow-union"
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ModelIdentity:
+    source_sha256: str
+    restriction_sha256: str
+    external_parameters_sha256: str
+
+    def as_payload(self) -> dict[str, object]:
+        return {
+            "kind": "ufo-sm-json-default-restriction",
+            "source_sha256": self.source_sha256,
+            "restriction_sha256": self.restriction_sha256,
+            "external_parameters_sha256": self.external_parameters_sha256,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class MadGraphReferenceIdentity:
+    madgraph_version: str
+    model_source_sha256: str
+    driver_sha256: str
+    external_parameters_sha256: str
+
+    def as_payload(self) -> dict[str, object]:
+        return {
+            "kind": "madgraph-standalone-ufo-sm",
+            "precision": "binary64",
+            "command_protocol": "generate-output-standalone-launch-force",
+            "madgraph_version": self.madgraph_version,
+            "model_source_sha256": self.model_source_sha256,
+            "driver_sha256": self.driver_sha256,
+            "external_parameters_sha256": self.external_parameters_sha256,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class AcceptanceCase:
+    spec: AcceptanceCaseSpec
+    momenta: tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]
+    expected: tuple[tuple[AccuracyName, Decimal], ...]
+
+    def expected_for(self, accuracy: AccuracyName) -> Decimal:
+        for key, value in self.expected:
+            if key == accuracy:
+                return value
+        raise NumericalAcceptanceError(
+            f"case {self.spec.case_id!r} has no {accuracy} reference"
+        )
+
+    def runtime_momenta(self) -> tuple[tuple[tuple[float, ...], ...], ...]:
+        return (
+            tuple(
+                tuple(float(component) for component in momentum)
+                for momentum in self.momenta
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class AcceptanceFixture:
+    model: ModelIdentity
+    full_reference: MadGraphReferenceIdentity
+    captured_source_revision: str
+    catalog: tuple[AcceptanceCase, ...]
+    extra_full_colour: tuple[AcceptanceCase, ...]
+
+    def case(self, case_id: str) -> AcceptanceCase:
+        for case in (*self.catalog, *self.extra_full_colour):
+            if case.spec.case_id == case_id:
+                return case
+        raise KeyError(case_id)
+
+
+@dataclass(frozen=True, slots=True)
+class RelativeComparison:
+    actual_real: Decimal
+    actual_imaginary: Decimal
+    expected: Decimal
+    difference: Decimal
+    scale: Decimal
+    bound: Decimal
+    passed: bool
+
+
+@dataclass(frozen=True, slots=True)
+class MadGraphIngest:
+    values: Mapping[str, Decimal]
+    identity: MadGraphReferenceIdentity
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def current_model_identity() -> ModelIdentity:
+    """Return the material identity shared by pyAmpliCol and MadGraph."""
+
+    try:
+        model = json.loads(MODEL_SOURCE.read_text(encoding="utf-8"))
+        restriction = json.loads(MODEL_RESTRICTION.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise NumericalAcceptanceError(
+            "cannot read the packaged UFO-SM model"
+        ) from error
+    if not isinstance(model, Mapping) or not isinstance(restriction, Mapping):
+        raise NumericalAcceptanceError("the packaged UFO-SM model is malformed")
+    parameters = model.get("parameters")
+    if not isinstance(parameters, list):
+        raise NumericalAcceptanceError("the packaged UFO-SM model has no parameters")
+    externals: dict[str, list[float]] = {}
+    for raw_parameter in parameters:
+        if not isinstance(raw_parameter, Mapping):
+            raise NumericalAcceptanceError("the UFO-SM parameter list is malformed")
+        if raw_parameter.get("nature") != "external":
+            continue
+        name = raw_parameter.get("name")
+        restricted = restriction.get(name) if isinstance(name, str) else None
+        if (
+            not isinstance(name, str)
+            or not isinstance(restricted, list)
+            or len(restricted) != 2
+            or isinstance(restricted[0], bool)
+            or not isinstance(restricted[0], (int, float))
+            or isinstance(restricted[1], bool)
+            or not isinstance(restricted[1], (int, float))
+            or float(restricted[1]) != 0.0
+        ):
+            raise NumericalAcceptanceError(
+                "the UFO-SM default restriction does not bind every external "
+                "parameter to a real value"
+            )
+        if name in externals:
+            raise NumericalAcceptanceError(f"duplicate UFO-SM external {name!r}")
+        externals[name] = [float(restricted[0]), 0.0]
+    if not externals or set(externals) != set(restriction):
+        raise NumericalAcceptanceError(
+            "the UFO-SM default restriction and external parameter set differ"
+        )
+    canonical = json.dumps(
+        externals,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return ModelIdentity(
+        source_sha256=_sha256_file(MODEL_SOURCE),
+        restriction_sha256=_sha256_file(MODEL_RESTRICTION),
+        external_parameters_sha256=hashlib.sha256(canonical).hexdigest(),
+    )
+
+
+def validation_momenta(
+    process: str,
+) -> tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]:
+    """Materialize the exact decimal spelling of the seed-101 binary64 point."""
+
+    from pyamplicol.models.builtin.validation import generic_validation_point
+
+    point = generic_validation_point(process, seed=POINT_SEED)
+    rows: list[tuple[Decimal, Decimal, Decimal, Decimal]] = []
+    for particle in point:
+        values = tuple(
+            Decimal(canonical_decimal(float(component)))
+            for component in particle.momentum
+        )
+        if len(values) != 4:
+            raise NumericalAcceptanceError(
+                f"validation point for {process!r} has a malformed momentum"
+            )
+        rows.append(cast(tuple[Decimal, Decimal, Decimal, Decimal], values))
+    return tuple(rows)
+
+
+def _momenta_payload(
+    momenta: tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...],
+) -> list[list[str]]:
+    return [
+        [canonical_decimal(component) for component in momentum] for momentum in momenta
+    ]
+
+
+def _decimal_from_number(value: object, where: str) -> Decimal:
+    if isinstance(value, bool):
+        raise NumericalAcceptanceError(f"{where} must be a finite real number")
+    if isinstance(value, Decimal):
+        result = value
+    elif isinstance(value, int):
+        result = Decimal(value)
+    elif isinstance(value, float):
+        if not math.isfinite(value):
+            raise NumericalAcceptanceError(f"{where} must be finite")
+        result = Decimal(canonical_decimal(value))
+    elif isinstance(value, str):
+        try:
+            result = Decimal(value)
+        except InvalidOperation as error:
+            raise NumericalAcceptanceError(f"{where} is not a decimal") from error
+    else:
+        raise NumericalAcceptanceError(f"{where} must be a finite real number")
+    if not result.is_finite():
+        raise NumericalAcceptanceError(f"{where} must be finite")
+    return result
+
+
+def _complex_decimal(value: object) -> tuple[Decimal, Decimal]:
+    if isinstance(value, Decimal):
+        if not value.is_finite():
+            raise NumericalAcceptanceError("matrix element is not finite")
+        return value, Decimal(0)
+    if isinstance(value, bool):
+        raise NumericalAcceptanceError("matrix element must be numeric")
+    try:
+        number = complex(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError, OverflowError) as error:
+        raise NumericalAcceptanceError("matrix element must be numeric") from error
+    if not math.isfinite(number.real) or not math.isfinite(number.imag):
+        raise NumericalAcceptanceError("matrix element is not finite")
+    return (
+        Decimal(canonical_decimal(number.real)),
+        Decimal(canonical_decimal(number.imag)),
+    )
+
+
+def compare_relative(
+    actual: object,
+    expected: Decimal,
+    *,
+    tolerance: Decimal = RELATIVE_TOLERANCE,
+) -> RelativeComparison:
+    """Compare a real reference without an absolute-tolerance escape hatch."""
+
+    expected = _decimal_from_number(expected, "expected matrix element")
+    tolerance = _decimal_from_number(tolerance, "relative tolerance")
+    if tolerance < 0:
+        raise NumericalAcceptanceError("relative tolerance must be non-negative")
+    actual_real, actual_imaginary = _complex_decimal(actual)
+    precision = max(
+        80,
+        len(actual_real.as_tuple().digits) + 20,
+        len(actual_imaginary.as_tuple().digits) + 20,
+        len(expected.as_tuple().digits) + 20,
+    )
+    with localcontext() as context:
+        context.prec = precision
+        actual_magnitude = (
+            actual_real * actual_real + actual_imaginary * actual_imaginary
+        ).sqrt()
+        delta_real = actual_real - expected
+        difference = (
+            delta_real * delta_real + actual_imaginary * actual_imaginary
+        ).sqrt()
+        scale = max(actual_magnitude, abs(expected))
+        bound = tolerance * scale
+    passed = difference == 0 if scale == 0 else difference <= bound
+    return RelativeComparison(
+        actual_real=actual_real,
+        actual_imaginary=actual_imaginary,
+        expected=expected,
+        difference=difference,
+        scale=scale,
+        bound=bound,
+        passed=passed,
+    )
+
+
+def assert_relative_match(
+    actual: object,
+    expected: Decimal,
+    *,
+    context: str,
+    tolerance: Decimal = RELATIVE_TOLERANCE,
+) -> None:
+    comparison = compare_relative(actual, expected, tolerance=tolerance)
+    if comparison.passed:
+        return
+    raise NumericalAcceptanceMismatch(
+        f"{context}: actual={comparison.actual_real}"
+        f"{comparison.actual_imaginary:+}i, expected={comparison.expected}, "
+        f"difference={comparison.difference}, scale={comparison.scale}, "
+        f"strict relative bound={comparison.bound}"
+    )
+
+
+def _mapping(value: object, where: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise NumericalAcceptanceError(f"{where} must be an object")
+    return cast(Mapping[str, object], value)
+
+
+def _sequence(value: object, where: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise NumericalAcceptanceError(f"{where} must be an array")
+    return cast(Sequence[object], value)
+
+
+def _exact_keys(
+    value: Mapping[str, object], expected: Iterable[str], where: str
+) -> None:
+    expected_set = set(expected)
+    observed = set(value)
+    if observed != expected_set:
+        raise NumericalAcceptanceError(
+            f"{where} fields differ: missing={sorted(expected_set - observed)}, "
+            f"extra={sorted(observed - expected_set)}"
+        )
+
+
+def _string(value: object, where: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise NumericalAcceptanceError(f"{where} must be a non-empty string")
+    return value
+
+
+def _integer(value: object, where: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise NumericalAcceptanceError(f"{where} must be an integer")
+    return value
+
+
+def _sha256(value: object, where: str) -> str:
+    text = _string(value, where)
+    if _SHA256_RE.fullmatch(text) is None:
+        raise NumericalAcceptanceError(f"{where} must be a lowercase SHA-256")
+    return text
+
+
+def _revision(value: object, where: str) -> str:
+    text = _string(value, where)
+    if _REVISION_RE.fullmatch(text) is None or text == "0" * 40:
+        raise NumericalAcceptanceError(f"{where} must be a real lowercase Git SHA")
+    return text
+
+
+def _canonical_decimal(value: object, where: str) -> Decimal:
+    if not isinstance(value, str):
+        raise NumericalAcceptanceError(
+            f"{where} must be a canonical fixed-point decimal string"
+        )
+    try:
+        parsed = Decimal(value)
+        normalized = canonical_decimal(parsed)
+    except (InvalidOperation, RuntimeError) as error:
+        raise NumericalAcceptanceError(f"{where} is not a finite decimal") from error
+    if not parsed.is_finite() or normalized != value:
+        raise NumericalAcceptanceError(
+            f"{where} must be a canonical fixed-point decimal string"
+        )
+    return parsed
+
+
+def _duplicate_rejecting_object(pairs: list[tuple[str, object]]) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in pairs:
+        if key in result:
+            raise NumericalAcceptanceError(f"duplicate JSON field {key!r}")
+        result[key] = value
+    return result
+
+
+def _read_json(path: Path) -> object:
+    try:
+        return json.loads(
+            path.read_text(encoding="ascii"),
+            object_pairs_hook=_duplicate_rejecting_object,
+            parse_constant=lambda token: (_ for _ in ()).throw(
+                NumericalAcceptanceError(f"non-finite JSON token {token!r}")
+            ),
+        )
+    except NumericalAcceptanceError:
+        raise
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise NumericalAcceptanceError(
+            f"cannot read JSON document {path}: {error}"
+        ) from error
+
+
+def _parse_model(value: object) -> ModelIdentity:
+    record = _mapping(value, "model")
+    _exact_keys(
+        record,
+        {
+            "kind",
+            "source_sha256",
+            "restriction_sha256",
+            "external_parameters_sha256",
+        },
+        "model",
+    )
+    if record.get("kind") != "ufo-sm-json-default-restriction":
+        raise NumericalAcceptanceError("model.kind is unsupported")
+    return ModelIdentity(
+        source_sha256=_sha256(record["source_sha256"], "model.source_sha256"),
+        restriction_sha256=_sha256(
+            record["restriction_sha256"], "model.restriction_sha256"
+        ),
+        external_parameters_sha256=_sha256(
+            record["external_parameters_sha256"],
+            "model.external_parameters_sha256",
+        ),
+    )
+
+
+def _parse_full_reference(value: object) -> MadGraphReferenceIdentity:
+    from tools.performance_report.madgraph import MADGRAPH_DRIVER_SOURCE_SHA256
+
+    record = _mapping(value, "references.full")
+    _exact_keys(
+        record,
+        {
+            "kind",
+            "precision",
+            "command_protocol",
+            "madgraph_version",
+            "model_source_sha256",
+            "driver_sha256",
+            "external_parameters_sha256",
+        },
+        "references.full",
+    )
+    fixed = {
+        "kind": "madgraph-standalone-ufo-sm",
+        "precision": "binary64",
+        "command_protocol": "generate-output-standalone-launch-force",
+    }
+    for key, expected in fixed.items():
+        if record.get(key) != expected:
+            raise NumericalAcceptanceError(
+                f"references.full.{key} must equal {expected!r}"
+            )
+    driver_sha256 = _sha256(record["driver_sha256"], "references.full.driver_sha256")
+    if driver_sha256 != MADGRAPH_DRIVER_SOURCE_SHA256:
+        raise NumericalAcceptanceError(
+            "references.full.driver_sha256 differs from the canonical adapter driver"
+        )
+    return MadGraphReferenceIdentity(
+        madgraph_version=_string(
+            record["madgraph_version"], "references.full.madgraph_version"
+        ),
+        model_source_sha256=_sha256(
+            record["model_source_sha256"],
+            "references.full.model_source_sha256",
+        ),
+        driver_sha256=driver_sha256,
+        external_parameters_sha256=_sha256(
+            record["external_parameters_sha256"],
+            "references.full.external_parameters_sha256",
+        ),
+    )
+
+
+def _parse_regression_reference(value: object, accuracy: str) -> str:
+    where = f"references.{accuracy}"
+    record = _mapping(value, where)
+    _exact_keys(
+        record,
+        {"kind", "precision_digits", "captured_source_revision"},
+        where,
+    )
+    if record.get("kind") != "pyamplicol-recurrence-regression":
+        raise NumericalAcceptanceError(f"{where}.kind is unsupported")
+    if _integer(record.get("precision_digits"), f"{where}.precision_digits") != (
+        FULL_CANDIDATE_PRECISION_DIGITS
+    ):
+        raise NumericalAcceptanceError(
+            f"{where}.precision_digits must be {FULL_CANDIDATE_PRECISION_DIGITS}"
+        )
+    return _revision(
+        record.get("captured_source_revision"),
+        f"{where}.captured_source_revision",
+    )
+
+
+def _parse_momenta(
+    value: object, where: str
+) -> tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]:
+    rows: list[tuple[Decimal, Decimal, Decimal, Decimal]] = []
+    for row_index, raw_row in enumerate(_sequence(value, where)):
+        components = _sequence(raw_row, f"{where}[{row_index}]")
+        if len(components) != 4:
+            raise NumericalAcceptanceError(
+                f"{where}[{row_index}] must contain four components"
+            )
+        parsed = tuple(
+            _canonical_decimal(component, f"{where}[{row_index}][{index}]")
+            for index, component in enumerate(components)
+        )
+        rows.append(cast(tuple[Decimal, Decimal, Decimal, Decimal], parsed))
+    if not rows:
+        raise NumericalAcceptanceError(f"{where} must not be empty")
+    return tuple(rows)
+
+
+def _parse_case(
+    raw: object,
+    spec: AcceptanceCaseSpec,
+    *,
+    catalog: bool,
+) -> AcceptanceCase:
+    where = f"case {spec.case_id}"
+    record = _mapping(raw, where)
+    catalog_fields = {
+        "id",
+        "family_id",
+        "family_key",
+        "n_final",
+        "process",
+        "momenta",
+        "expected",
+    }
+    extra_fields = {"id", "process", "momenta", "expected"}
+    _exact_keys(record, catalog_fields if catalog else extra_fields, where)
+    if record.get("id") != spec.case_id or record.get("process") != spec.process:
+        raise NumericalAcceptanceError(f"{where} identity differs from the catalog")
+    if catalog and (
+        _integer(record.get("family_id"), f"{where}.family_id") != spec.family_id
+        or record.get("family_key") != spec.family_key
+        or _integer(record.get("n_final"), f"{where}.n_final") != spec.n_final
+    ):
+        raise NumericalAcceptanceError(f"{where} metadata differs from the catalog")
+    momenta = _parse_momenta(record.get("momenta"), f"{where}.momenta")
+    expected_momenta = validation_momenta(spec.process)
+    if momenta != expected_momenta:
+        raise NumericalAcceptanceError(
+            f"{where}.momenta differ from generic_validation_point(seed={POINT_SEED})"
+        )
+    expected_record = _mapping(record.get("expected"), f"{where}.expected")
+    expected_accuracies: tuple[AccuracyName, ...] = (
+        ("full", "lc", "nlc") if catalog else ("full",)
+    )
+    _exact_keys(expected_record, expected_accuracies, f"{where}.expected")
+    expected: list[tuple[AccuracyName, Decimal]] = []
+    for accuracy in expected_accuracies:
+        parsed = _canonical_decimal(
+            expected_record.get(accuracy), f"{where}.expected.{accuracy}"
+        )
+        if parsed < 0:
+            raise NumericalAcceptanceError(
+                f"{where}.expected.{accuracy} must be non-negative"
+            )
+        expected.append((accuracy, parsed))
+    return AcceptanceCase(spec=spec, momenta=momenta, expected=tuple(expected))
+
+
+def parse_acceptance_fixture(
+    payload: object,
+    *,
+    validate_current_model: bool = True,
+) -> AcceptanceFixture:
+    """Strictly parse and semantically bind a numerical acceptance payload."""
+
+    root = _mapping(payload, "fixture")
+    _exact_keys(
+        root,
+        {
+            "kind",
+            "schema_version",
+            "model",
+            "point_policy",
+            "comparison",
+            "references",
+            "catalog_max_n_final",
+            "catalog_cases",
+            "extra_full_colour_cases",
+        },
+        "fixture",
+    )
+    if root.get("kind") != FIXTURE_KIND:
+        raise NumericalAcceptanceError("fixture.kind is unsupported")
+    if _integer(root.get("schema_version"), "fixture.schema_version") != (
+        FIXTURE_SCHEMA_VERSION
+    ):
+        raise NumericalAcceptanceError("fixture.schema_version is unsupported")
+    if _integer(root.get("catalog_max_n_final"), "catalog_max_n_final") != (
+        CATALOG_MAX_N_FINAL
+    ):
+        raise NumericalAcceptanceError(
+            f"catalog_max_n_final must be {CATALOG_MAX_N_FINAL}"
+        )
+
+    model = _parse_model(root.get("model"))
+    if validate_current_model and model != current_model_identity():
+        raise NumericalAcceptanceError(
+            "fixture UFO-SM model identity differs from the current packaged model"
+        )
+
+    point_policy = _mapping(root.get("point_policy"), "point_policy")
+    _exact_keys(
+        point_policy, {"generator", "seed", "stored_components"}, "point_policy"
+    )
+    expected_point_policy = {
+        "generator": "generic_validation_point",
+        "seed": POINT_SEED,
+        "stored_components": "canonical-binary64-decimal",
+    }
+    if dict(point_policy) != expected_point_policy:
+        raise NumericalAcceptanceError(
+            f"point_policy must equal {expected_point_policy!r}"
+        )
+
+    comparison = _mapping(root.get("comparison"), "comparison")
+    _exact_keys(
+        comparison,
+        {
+            "relative_tolerance",
+            "absolute_tolerance",
+            "full_candidate_precision_digits",
+            "native_precision",
+        },
+        "comparison",
+    )
+    if (
+        _canonical_decimal(
+            comparison.get("relative_tolerance"), "comparison.relative_tolerance"
+        )
+        != RELATIVE_TOLERANCE
+        or comparison.get("absolute_tolerance") is not None
+        or _integer(
+            comparison.get("full_candidate_precision_digits"),
+            "comparison.full_candidate_precision_digits",
+        )
+        != FULL_CANDIDATE_PRECISION_DIGITS
+        or comparison.get("native_precision") != "binary64"
+    ):
+        raise NumericalAcceptanceError(
+            "comparison must use strict relative-only 1e-10, p200, and binary64"
+        )
+
+    references = _mapping(root.get("references"), "references")
+    _exact_keys(references, {"full", "lc", "nlc"}, "references")
+    full_reference = _parse_full_reference(references.get("full"))
+    lc_revision = _parse_regression_reference(references.get("lc"), "lc")
+    nlc_revision = _parse_regression_reference(references.get("nlc"), "nlc")
+    if lc_revision != nlc_revision:
+        raise NumericalAcceptanceError(
+            "LC and NLC regression references must come from one source revision"
+        )
+    if full_reference.external_parameters_sha256 != model.external_parameters_sha256:
+        raise NumericalAcceptanceError(
+            "MadGraph and pyAmpliCol external-parameter identities differ"
+        )
+
+    catalog_specs = catalog_cases()
+    raw_catalog = _sequence(root.get("catalog_cases"), "catalog_cases")
+    raw_extra = _sequence(
+        root.get("extra_full_colour_cases"), "extra_full_colour_cases"
+    )
+    if len(raw_catalog) != len(catalog_specs):
+        raise NumericalAcceptanceError(
+            f"catalog_cases must contain exactly {len(catalog_specs)} records"
+        )
+    if len(raw_extra) != len(EXTRA_FULL_COLOUR_CASES):
+        raise NumericalAcceptanceError(
+            "extra_full_colour_cases must contain exactly the two declared "
+            "non-catalog benchmarks"
+        )
+    catalog = tuple(
+        _parse_case(raw, spec, catalog=True)
+        for raw, spec in zip(raw_catalog, catalog_specs, strict=True)
+    )
+    extra = tuple(
+        _parse_case(raw, spec, catalog=False)
+        for raw, spec in zip(raw_extra, EXTRA_FULL_COLOUR_CASES, strict=True)
+    )
+    ids = tuple(case.spec.case_id for case in (*catalog, *extra))
+    if len(ids) != len(set(ids)):
+        raise NumericalAcceptanceError("fixture case IDs are not unique")
+    return AcceptanceFixture(
+        model=model,
+        full_reference=full_reference,
+        captured_source_revision=lc_revision,
+        catalog=catalog,
+        extra_full_colour=extra,
+    )
+
+
+def load_acceptance_fixture(path: Path = DEFAULT_FIXTURE) -> AcceptanceFixture:
+    """Load the tracked acceptance fixture with full semantic validation."""
+
+    return parse_acceptance_fixture(_read_json(path))
+
+
+def _serialized_value(value: object, where: str) -> str:
+    decimal = _decimal_from_number(value, where)
+    if decimal < 0:
+        raise NumericalAcceptanceError(f"{where} must be non-negative")
+    return canonical_decimal(decimal)
+
+
+def build_fixture_payload(
+    *,
+    full_values: Mapping[str, object],
+    lc_values: Mapping[str, object],
+    nlc_values: Mapping[str, object],
+    full_reference: MadGraphReferenceIdentity,
+    captured_source_revision: str,
+) -> dict[str, object]:
+    """Build, then strictly re-parse, a complete fixture payload.
+
+    Callers must provide every value; this function never substitutes or
+    invents a numerical result.
+    """
+
+    catalog_specs = catalog_cases()
+    catalog_ids = {case.case_id for case in catalog_specs}
+    extra_ids = {case.case_id for case in EXTRA_FULL_COLOUR_CASES}
+    if set(full_values) != catalog_ids | extra_ids:
+        raise NumericalAcceptanceError(
+            "full_values must cover exactly all catalog and extra cases"
+        )
+    if set(lc_values) != catalog_ids or set(nlc_values) != catalog_ids:
+        raise NumericalAcceptanceError(
+            "LC and NLC values must each cover exactly the 33 catalog cases"
+        )
+    revision = _revision(captured_source_revision, "captured_source_revision")
+
+    catalog_payload: list[dict[str, object]] = []
+    for spec in catalog_specs:
+        catalog_payload.append(
+            {
+                "id": spec.case_id,
+                "family_id": spec.family_id,
+                "family_key": spec.family_key,
+                "n_final": spec.n_final,
+                "process": spec.process,
+                "momenta": _momenta_payload(validation_momenta(spec.process)),
+                "expected": {
+                    "full": _serialized_value(
+                        full_values[spec.case_id], f"full_values[{spec.case_id}]"
+                    ),
+                    "lc": _serialized_value(
+                        lc_values[spec.case_id], f"lc_values[{spec.case_id}]"
+                    ),
+                    "nlc": _serialized_value(
+                        nlc_values[spec.case_id], f"nlc_values[{spec.case_id}]"
+                    ),
+                },
+            }
+        )
+    extra_payload = [
+        {
+            "id": spec.case_id,
+            "process": spec.process,
+            "momenta": _momenta_payload(validation_momenta(spec.process)),
+            "expected": {
+                "full": _serialized_value(
+                    full_values[spec.case_id], f"full_values[{spec.case_id}]"
+                )
+            },
+        }
+        for spec in EXTRA_FULL_COLOUR_CASES
+    ]
+    regression_reference = {
+        "kind": "pyamplicol-recurrence-regression",
+        "precision_digits": FULL_CANDIDATE_PRECISION_DIGITS,
+        "captured_source_revision": revision,
+    }
+    payload: dict[str, object] = {
+        "kind": FIXTURE_KIND,
+        "schema_version": FIXTURE_SCHEMA_VERSION,
+        "model": current_model_identity().as_payload(),
+        "point_policy": {
+            "generator": "generic_validation_point",
+            "seed": POINT_SEED,
+            "stored_components": "canonical-binary64-decimal",
+        },
+        "comparison": {
+            "relative_tolerance": canonical_decimal(RELATIVE_TOLERANCE),
+            "absolute_tolerance": None,
+            "full_candidate_precision_digits": FULL_CANDIDATE_PRECISION_DIGITS,
+            "native_precision": "binary64",
+        },
+        "references": {
+            "full": full_reference.as_payload(),
+            "lc": dict(regression_reference),
+            "nlc": dict(regression_reference),
+        },
+        "catalog_max_n_final": CATALOG_MAX_N_FINAL,
+        "catalog_cases": catalog_payload,
+        "extra_full_colour_cases": extra_payload,
+    }
+    parse_acceptance_fixture(payload)
+    return payload
+
+
+def write_acceptance_fixture(payload: object, path: Path) -> AcceptanceFixture:
+    """Validate and exclusively create a fixture; never overwrite one."""
+
+    fixture = parse_acceptance_fixture(payload)
+    destination = path.expanduser().resolve(strict=False)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    encoded = (
+        json.dumps(
+            payload,
+            ensure_ascii=True,
+            indent=2,
+            sort_keys=False,
+            allow_nan=False,
+        )
+        + "\n"
+    )
+    try:
+        with destination.open("x", encoding="ascii", newline="\n") as stream:
+            stream.write(encoded)
+    except FileExistsError as error:
+        raise NumericalAcceptanceError(
+            f"refusing to overwrite existing fixture {destination}"
+        ) from error
+    return fixture
+
+
+def lane_run_config(lane: AcceptanceLane) -> object:
+    """Return the lean, deterministic generation config for one lane."""
+
+    from pyamplicol.config import (
+        Action,
+        ColorAccuracy,
+        ColorConfig,
+        EvaluatorConfig,
+        EvaluatorExecutionMode,
+        EvaluatorOptimizationConfig,
+        GenerationConfig,
+        GenerationRelationDiscoveryConfig,
+        GenerationValidationConfig,
+        JITConfig,
+        LCFlowLayout,
+        RelationDiscoveryMode,
+        RunConfig,
+    )
+
+    return RunConfig(
+        action=Action.GENERATE,
+        color=ColorConfig(
+            accuracy=ColorAccuracy(lane.accuracy),
+            lc_flow_layout=LCFlowLayout(lane.lc_flow_layout),
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+            relation_discovery=GenerationRelationDiscoveryConfig(
+                mode=RelationDiscoveryMode.OFF
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=EvaluatorExecutionMode(lane.mode),
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=lane.jit_optimization_level),
+        ),
+    )
+
+
+def lane_case_specs(
+    lane: AcceptanceLane,
+    *,
+    group: ArtifactGroup = "catalog",
+) -> tuple[AcceptanceCaseSpec, ...]:
+    """Return the static process order without pulling n=6 into catalog builds."""
+
+    if group == "catalog":
+        return catalog_cases()
+    if group == "extra" and lane.includes_extra_cases:
+        return EXTRA_FULL_COLOUR_CASES
+    raise NumericalAcceptanceError(
+        f"{lane.lane_id} has no {group!r} acceptance artifact"
+    )
+
+
+def lane_process_set(
+    lane: AcceptanceLane,
+    *,
+    group: ArtifactGroup = "catalog",
+) -> object:
+    """Return one ordered ProcessSet for a lane's catalog or extra group."""
+
+    from pyamplicol import ProcessSet
+
+    cases = lane_case_specs(lane, group=group)
+    return ProcessSet.from_expressions(
+        (case.process for case in cases),
+        names=tuple(case.artifact_name for case in cases),
+    )
+
+
+def prepare_ufo_sm_model(work_root: Path) -> object:
+    """Prepare one recurrence JIT-O2 UFO-SM bundle reusable by all lanes."""
+
+    from pyamplicol import ModelSource
+
+    root = work_root.expanduser().resolve(strict=False)
+    root.mkdir(parents=True, exist_ok=True)
+    recurrence_lane = AcceptanceLane("full", "recurrence", 2)
+    evaluator = lane_run_config(recurrence_lane).evaluator  # type: ignore[attr-defined]
+    model = ModelSource.from_path(
+        MODEL_SOURCE,
+        restriction=MODEL_RESTRICTION,
+    ).compile(
+        cache_dir=root / "model-cache",
+        use_cache=True,
+        prepared_output=root / "ufo-sm-jit-o2.pyamplicol-model",
+        evaluator=evaluator,
+    )
+    if not getattr(model, "is_prepared", False):
+        raise NumericalAcceptanceError("UFO-SM preparation returned no prepared model")
+    return model
+
+
+def generate_lane_artifact(
+    lane: AcceptanceLane,
+    *,
+    artifact_path: Path,
+    model: object,
+    group: ArtifactGroup = "catalog",
+) -> Path:
+    """Generate exactly one ProcessSet artifact for one lane/group pair."""
+
+    from pyamplicol import Generator
+
+    destination = artifact_path.expanduser().resolve(strict=False)
+    Generator(lane_run_config(lane)).generate(
+        lane_process_set(lane, group=group),
+        destination,
+        model=model,  # type: ignore[arg-type]
+    )
+    _validate_artifact_lane(destination, lane)
+    return destination
+
+
+def _validate_artifact_lane(
+    artifact: Path,
+    lane: AcceptanceLane,
+) -> None:
+    """Bind a generated lane to its exact effective mode, accuracy, and layout."""
+
+    import tomllib
+
+    effective_path = artifact / "config" / "effective.toml"
+    try:
+        effective = tomllib.loads(effective_path.read_text(encoding="utf-8"))
+        color = effective["color"]
+        evaluator = effective["evaluator"]
+        observed = (
+            str(color["accuracy"]),
+            str(evaluator["execution_mode"]),
+            str(color["lc_flow_layout"]),
+        )
+    except (KeyError, OSError, TypeError, tomllib.TOMLDecodeError) as exc:
+        raise NumericalAcceptanceError(
+            f"{lane.lane_id} has no valid effective lane configuration"
+        ) from exc
+    expected = (lane.accuracy, lane.mode, lane.lc_flow_layout)
+    if observed != expected:
+        raise NumericalAcceptanceError(
+            f"{lane.lane_id} effective lane is {observed!r}; expected {expected!r}"
+        )
+
+
+def _validate_runtime_lane(
+    runtime: object,
+    lane: AcceptanceLane,
+    *,
+    context: str,
+) -> None:
+    observed_mode = getattr(runtime, "execution_mode", None)
+    physics = getattr(runtime, "physics", None)
+    observed_accuracy = getattr(physics, "color_accuracy", None)
+    if observed_mode != lane.mode or observed_accuracy != lane.accuracy:
+        raise NumericalAcceptanceError(
+            f"{context} loaded as mode={observed_mode!r}, "
+            f"color_accuracy={observed_accuracy!r}; expected "
+            f"{lane.mode!r}/{lane.accuracy!r}"
+        )
+
+
+class NumericalAcceptanceHarness:
+    """Generate each lane once and fail fast through its ordered processes."""
+
+    def __init__(
+        self,
+        fixture: AcceptanceFixture,
+        *,
+        artifact_root: Path,
+        model: object,
+    ) -> None:
+        self.fixture = fixture
+        self.artifact_root = artifact_root.expanduser().resolve(strict=False)
+        self.artifact_root.mkdir(parents=True, exist_ok=True)
+        self.model = model
+        self._artifacts: dict[tuple[str, ArtifactGroup], Path] = {}
+
+    @classmethod
+    def prepare(
+        cls,
+        fixture_path: Path,
+        *,
+        work_root: Path,
+    ) -> NumericalAcceptanceHarness:
+        root = work_root.expanduser().resolve(strict=False)
+        fixture = load_acceptance_fixture(fixture_path)
+        model = prepare_ufo_sm_model(root / "prepared-model")
+        return cls(fixture, artifact_root=root / "artifacts", model=model)
+
+    def _artifact(self, lane: AcceptanceLane, *, group: ArtifactGroup) -> Path:
+        key = (lane.lane_id, group)
+        existing = self._artifacts.get(key)
+        if existing is not None:
+            return existing
+        artifact_name = lane.lane_id if group == "catalog" else f"{lane.lane_id}-extra"
+        artifact = generate_lane_artifact(
+            lane,
+            artifact_path=self.artifact_root / artifact_name,
+            model=self.model,
+            group=group,
+        )
+        self._artifacts[key] = artifact
+        return artifact
+
+    def _assert_case(self, case: AcceptanceCase, lane: AcceptanceLane) -> None:
+        from pyamplicol import Runtime
+
+        group: ArtifactGroup = "catalog" if case.spec.is_catalog else "extra"
+        runtime = Runtime.load(
+            self._artifact(lane, group=group),
+            process=case.spec.artifact_name,
+        )
+        try:
+            _validate_runtime_lane(runtime, lane, context=lane.lane_id)
+            expected = case.expected_for(lane.accuracy)
+            for precision in lane.evaluation_precisions_for(group):
+                actual = runtime.evaluate(
+                    case.runtime_momenta(),
+                    precision=precision,
+                )[0]
+                assert_relative_match(
+                    actual,
+                    expected,
+                    context=f"{case.spec.case_id}/{lane.lane_id}/p{precision}",
+                )
+        finally:
+            runtime.clear()
+
+    def assert_catalog_lane(self, lane: AcceptanceLane) -> None:
+        for case in self.fixture.catalog:
+            self._assert_case(case, lane)
+
+    def assert_catalog_case(self, case_id: str) -> None:
+        case = self.fixture.case(case_id)
+        if not case.spec.is_catalog:
+            raise NumericalAcceptanceError(
+                "assert_catalog_case requires a catalog case"
+            )
+        for lane in ACCEPTANCE_LANES:
+            self._assert_case(case, lane)
+
+    def assert_full_extra(self, case_id: str) -> None:
+        case = self.fixture.case(case_id)
+        if case.spec.is_catalog:
+            raise NumericalAcceptanceError(
+                "assert_full_extra requires a deliberately non-catalog case"
+            )
+        for lane in FULL_LANES:
+            self._assert_case(case, lane)
+
+
+def _normalized_report_momenta(
+    value: object,
+) -> tuple[tuple[tuple[float, ...], ...], ...]:
+    points: list[tuple[tuple[float, ...], ...]] = []
+    for raw_point in _sequence(value, "MadGraph provenance.report_momenta"):
+        rows: list[tuple[float, ...]] = []
+        for raw_row in _sequence(raw_point, "MadGraph report point"):
+            components = _sequence(raw_row, "MadGraph report momentum")
+            if len(components) != 4:
+                raise NumericalAcceptanceError(
+                    "MadGraph report momentum must have four components"
+                )
+            row = tuple(float(component) for component in components)
+            if any(not math.isfinite(component) for component in row):
+                raise NumericalAcceptanceError("MadGraph report momentum is not finite")
+            rows.append(row)
+        points.append(tuple(rows))
+    return tuple(points)
+
+
+def _madgraph_measurement(
+    measurement_value: object,
+    spec: AcceptanceCaseSpec,
+) -> tuple[Decimal, MadGraphReferenceIdentity]:
+    from tools.performance_report.madgraph import (
+        MADGRAPH_DRIVER_SOURCE_SHA256,
+        madgraph_command_card,
+    )
+    from tools.performance_report.runner import point_digest
+
+    measurement = _mapping(measurement_value, f"MadGraph measurement {spec.case_id}")
+    if measurement.get("status") != "ok":
+        raise NumericalAcceptanceError(
+            f"MadGraph measurement {spec.case_id} is not successful"
+        )
+    matrix_element = _decimal_from_number(
+        measurement.get("matrix_element"),
+        f"MadGraph measurement {spec.case_id}.matrix_element",
+    )
+    if matrix_element < 0:
+        raise NumericalAcceptanceError(
+            f"MadGraph measurement {spec.case_id} is negative"
+        )
+    expected_point = (
+        tuple(
+            tuple(float(component) for component in row)
+            for row in validation_momenta(spec.process)
+        ),
+    )
+    validation = _mapping(measurement.get("validation"), "MadGraph validation")
+    if (
+        validation.get("status") != "ok"
+        or validation.get("method") != "independent-madgraph-tree-level-oracle"
+        or validation.get("point_digest") != point_digest(expected_point)
+    ):
+        raise NumericalAcceptanceError(
+            f"MadGraph measurement {spec.case_id} has invalid point evidence"
+        )
+    provenance = _mapping(measurement.get("provenance"), "MadGraph provenance")
+    model = _mapping(provenance.get("model"), "MadGraph provenance.model")
+    exact_card = _mapping(
+        provenance.get("exact_param_card"),
+        "MadGraph provenance.exact_param_card",
+    )
+    restriction_card = _mapping(
+        provenance.get("default_restriction"),
+        "MadGraph provenance.default_restriction",
+    )
+    external_sha = current_model_identity().external_parameters_sha256
+    expected_command_card = madgraph_command_card(spec.process)
+    expected_command_sha = hashlib.sha256(
+        expected_command_card.encode("utf-8")
+    ).hexdigest()
+    driver_sha256 = _sha256(
+        provenance.get("driver_sha256"), "MadGraph provenance.driver_sha256"
+    )
+    if (
+        provenance.get("method") != "madgraph-standalone-custom-fortran-driver"
+        or provenance.get("command_card") != expected_command_card
+        or provenance.get("command_card_sha256") != expected_command_sha
+        or _normalized_report_momenta(provenance.get("report_momenta"))
+        != expected_point
+        or model.get("name") != "sm"
+        or driver_sha256 != MADGRAPH_DRIVER_SOURCE_SHA256
+        or exact_card.get("binary64_exact_match") is not True
+        or restriction_card.get("binary64_exact_match") is not True
+        or exact_card.get("external_parameters_sha256") != external_sha
+        or restriction_card.get("external_parameters_sha256") != external_sha
+        or exact_card.get("format") != "%.14e"
+        or restriction_card.get("format") != "%.14e"
+    ):
+        raise NumericalAcceptanceError(
+            f"MadGraph measurement {spec.case_id} violates the standalone/model "
+            "authority contract"
+        )
+    for label, card in (
+        ("exact_param_card", exact_card),
+        ("default_restriction", restriction_card),
+    ):
+        count = card.get("external_parameter_count")
+        if isinstance(count, bool) or not isinstance(count, int) or count < 1:
+            raise NumericalAcceptanceError(
+                f"MadGraph measurement {spec.case_id} has invalid {label} coverage"
+            )
+    identity = MadGraphReferenceIdentity(
+        madgraph_version=_string(
+            provenance.get("version"), "MadGraph provenance.version"
+        ),
+        model_source_sha256=_sha256(
+            model.get("source_sha256"), "MadGraph provenance.model.source_sha256"
+        ),
+        driver_sha256=driver_sha256,
+        external_parameters_sha256=external_sha,
+    )
+    return matrix_element, identity
+
+
+def _one_madgraph_identity(
+    identities: Iterable[MadGraphReferenceIdentity],
+) -> MadGraphReferenceIdentity:
+    unique = set(identities)
+    if len(unique) != 1:
+        raise NumericalAcceptanceError(
+            "MadGraph records do not share one version/model/driver identity"
+        )
+    return next(iter(unique))
+
+
+def ingest_authenticated_madgraph_cache(path: Path) -> MadGraphIngest:
+    """Load catalog values only after existing campaign-cache validation."""
+
+    from tools.performance_report.cache import validate_cache
+    from tools.performance_report.catalog import REPORT_CATALOG
+
+    payload = _read_json(path)
+    cache = _mapping(payload, "MadGraph cache")
+    if cache.get("dataset_id") != "reference_madgraph_full":
+        raise NumericalAcceptanceError(
+            "MadGraph cache must be the reference_madgraph_full dataset"
+        )
+    entries = _sequence(cache.get("entries"), "MadGraph cache.entries")
+    expected_cells = {
+        cell.cell_id: cell
+        for cell in REPORT_CATALOG.reference_cells()
+        if cell.dataset_id == "reference_madgraph_full"
+    }
+    observed_cell_ids: list[str] = []
+    for index, raw_entry in enumerate(entries):
+        entry = _mapping(raw_entry, f"MadGraph cache.entries[{index}]")
+        cell_id = entry.get("cell_id")
+        if not isinstance(cell_id, str) or cell_id not in expected_cells:
+            raise NumericalAcceptanceError(
+                f"MadGraph cache contains unknown cell {cell_id!r}"
+            )
+        observed_cell_ids.append(cell_id)
+    if set(observed_cell_ids) != set(expected_cells):
+        raise NumericalAcceptanceError(
+            "MadGraph cache does not cover the complete authenticated "
+            "reference_madgraph_full dataset"
+        )
+    try:
+        validate_cache(
+            payload,
+            expected_cells=expected_cells.values(),
+            catalog=REPORT_CATALOG,
+        )
+    except (TypeError, ValueError) as error:
+        raise NumericalAcceptanceError(
+            f"MadGraph campaign cache authentication failed: {error}"
+        ) from error
+    entries_by_process = {
+        (entry.get("process_key"), entry.get("n_final")): entry
+        for entry in (_mapping(raw, "MadGraph cache entry") for raw in entries)
+    }
+    values: dict[str, Decimal] = {}
+    identities: list[MadGraphReferenceIdentity] = []
+    for spec in catalog_cases():
+        entry = entries_by_process.get((spec.family_key, spec.n_final))
+        if entry is None or entry.get("process") != spec.process:
+            raise NumericalAcceptanceError(
+                f"MadGraph cache lacks catalog record {spec.case_id}"
+            )
+        value, identity = _madgraph_measurement(entry.get("measurement"), spec)
+        values[spec.case_id] = value
+        identities.append(identity)
+    return MadGraphIngest(values=values, identity=_one_madgraph_identity(identities))
+
+
+def _gate_point(path: Path, spec: AcceptanceCaseSpec) -> None:
+    raw_rows = _sequence(_read_json(path), f"gate point {path}")
+    observed: list[tuple[float, ...]] = []
+    for index, raw_row in enumerate(raw_rows):
+        components = _sequence(raw_row, f"gate point {path}[{index}]")
+        if len(components) != 4:
+            raise NumericalAcceptanceError(
+                f"gate point {path} contains a malformed momentum"
+            )
+        try:
+            row = tuple(float(component) for component in components)
+        except (TypeError, ValueError, OverflowError) as error:
+            raise NumericalAcceptanceError(
+                f"gate point {path} contains a non-numeric momentum"
+            ) from error
+        if any(not math.isfinite(component) for component in row):
+            raise NumericalAcceptanceError(f"gate point {path} is not finite")
+        observed.append(row)
+    expected = tuple(
+        tuple(float(component) for component in row)
+        for row in validation_momenta(spec.process)
+    )
+    if tuple(observed) != expected:
+        raise NumericalAcceptanceError(
+            f"gate point {path} differs from {spec.case_id} seed-{POINT_SEED}"
+        )
+
+
+def ingest_authenticated_madgraph_wave_root(root: Path) -> MadGraphIngest:
+    """Reuse the complete n=1..4 MadGraph authority prefix from a wave."""
+
+    gate_root = root.expanduser().resolve(strict=True)
+    manifest = _mapping(_read_json(gate_root / "manifest.json"), "wave manifest")
+    if (
+        manifest.get("kind") != "pyamplicol-madgraph-ufo-sm-full-p200-wave-gate-v1"
+        or manifest.get("status") not in {"running", "ok"}
+        or _integer(manifest.get("seed"), "wave seed") != POINT_SEED
+        or _integer(manifest.get("max_n"), "wave max_n") < CATALOG_MAX_N_FINAL
+        or manifest.get("ordering") != "n-final-then-family-id-then-mode"
+    ):
+        raise NumericalAcceptanceError(
+            "wave root cannot supply the ordered n=1..4 MadGraph authority prefix"
+        )
+
+    specs = catalog_cases()
+    plan = _sequence(manifest.get("plan"), "wave plan")
+    if len(plan) < len(specs):
+        raise NumericalAcceptanceError("wave plan does not contain all 33 cases")
+    for ordinal, (raw_plan, spec) in enumerate(
+        zip(plan[: len(specs)], specs, strict=True)
+    ):
+        record = _mapping(raw_plan, f"wave plan[{ordinal}]")
+        if (
+            record.get("cell_ordinal") != ordinal
+            or record.get("n_final") != spec.n_final
+            or record.get("family_id") != spec.family_id
+            or record.get("process_key") != spec.family_key
+            or record.get("process") != spec.process
+        ):
+            raise NumericalAcceptanceError(
+                f"wave plan[{ordinal}] differs from {spec.case_id}"
+            )
+
+    values: dict[str, Decimal] = {}
+    identities: list[MadGraphReferenceIdentity] = []
+    for spec in specs:
+        case_root = gate_root / f"n{spec.n_final}" / f"family-{spec.family_id:02d}"
+        _gate_point(case_root / "point-seed-101.json", spec)
+        value, identity = _madgraph_measurement(
+            _read_json(case_root / "madgraph-measurement.json"),
+            spec,
+        )
+        authority = _mapping(
+            _read_json(case_root / "madgraph-authority.json"),
+            f"wave authority {spec.case_id}",
+        )
+        if (
+            authority.get("process") != spec.process
+            or authority.get("n_final") != spec.n_final
+            or authority.get("seed") != POINT_SEED
+            or _decimal_from_number(
+                authority.get("madgraph_value"),
+                f"wave authority {spec.case_id}.madgraph_value",
+            )
+            != value
+        ):
+            raise NumericalAcceptanceError(
+                f"wave authority for {spec.case_id} is inconsistent"
+            )
+        values[spec.case_id] = value
+        identities.append(identity)
+    return MadGraphIngest(values=values, identity=_one_madgraph_identity(identities))
+
+
+def ingest_authenticated_extra_madgraph_root(root: Path) -> MadGraphIngest:
+    """Reuse the two MadGraph authority records from the successful n=6 gate."""
+
+    gate_root = root.expanduser().resolve(strict=True)
+    manifest = _mapping(_read_json(gate_root / "manifest.json"), "stress manifest")
+    process_keys = ("uu_four_identical_lines", "ee_four_identical_lines")
+    expected_process_order = [
+        {"key": key, "process": spec.process, "n_final": spec.n_final}
+        for key, spec in zip(process_keys, EXTRA_FULL_COLOUR_CASES, strict=True)
+    ]
+    if (
+        manifest.get("kind")
+        != "pyamplicol-authenticated-noncatalog-n6-madgraph-stress-v1"
+        or manifest.get("status") != "ok"
+        or manifest.get("stage") != "complete"
+        or _integer(manifest.get("seed"), "stress seed") != POINT_SEED
+        or manifest.get("process_order") != expected_process_order
+        or manifest.get("catalog_policy")
+        != "direct synthetic CellSpec; REPORT_CATALOG not modified"
+    ):
+        raise NumericalAcceptanceError(
+            "extra root cannot supply the authenticated n=6 MadGraph authority"
+        )
+
+    required_checks = (
+        "status",
+        "exact_seed_101_point",
+        "exact_command_card",
+        "custom_fortran_method",
+        "custom_driver_digest",
+        "exact_generated_process",
+    )
+    values: dict[str, Decimal] = {}
+    identities: list[MadGraphReferenceIdentity] = []
+    for case_ordinal, (key, spec) in enumerate(
+        zip(process_keys, EXTRA_FULL_COLOUR_CASES, strict=True)
+    ):
+        case_root = gate_root / f"case-{case_ordinal + 1:02d}-{key}"
+        _gate_point(case_root / "point-seed-101.json", spec)
+        value, identity = _madgraph_measurement(
+            _read_json(case_root / "madgraph-measurement.json"),
+            spec,
+        )
+        authority = _mapping(
+            _read_json(case_root / "madgraph-authority-verification.json"),
+            f"stress authority {spec.case_id}",
+        )
+        checks = _mapping(
+            authority.get("checks"), f"stress authority {spec.case_id}.checks"
+        )
+        expected_point = (
+            tuple(
+                tuple(float(component) for component in row)
+                for row in validation_momenta(spec.process)
+            ),
+        )
+        if (
+            authority.get("process") != spec.process
+            or authority.get("seed") != POINT_SEED
+            or _normalized_report_momenta((authority.get("point"),)) != expected_point
+            or _decimal_from_number(
+                authority.get("matrix_element_binary64"),
+                f"stress authority {spec.case_id}.matrix_element_binary64",
+            )
+            != value
+            or any(checks.get(name) is not True for name in required_checks)
+        ):
+            raise NumericalAcceptanceError(
+                f"stress MadGraph authority for {spec.case_id} is inconsistent"
+            )
+        values[spec.case_id] = value
+        identities.append(identity)
+    return MadGraphIngest(values=values, identity=_one_madgraph_identity(identities))
+
+
+def capture_extra_madgraph_values(
+    *,
+    installation: Path,
+    artifact_root: Path,
+) -> MadGraphIngest:
+    """Capture the two non-catalog MadGraph benchmarks with the shared adapter."""
+
+    from tools.performance_report.madgraph import (
+        MadGraphMeasurementAdapter,
+        MadGraphSettings,
+    )
+    from tools.performance_report.models import (
+        Accuracy,
+        CellSpec,
+        ExecutionMode,
+        MeasurementSpec,
+        ModelKey,
+        Workload,
+    )
+
+    settings = MadGraphSettings(
+        installation=installation,
+        json_model_path=MODEL_SOURCE,
+        restriction_json_path=MODEL_RESTRICTION,
+    )
+    adapter = MadGraphMeasurementAdapter()
+    values: dict[str, Decimal] = {}
+    identities: list[MadGraphReferenceIdentity] = []
+    for spec in EXTRA_FULL_COLOUR_CASES:
+        cell = CellSpec(
+            dataset_id="numerical_acceptance_extra_full",
+            process=spec.process,
+            n_final=spec.n_final,
+            process_key=spec.case_id,
+            measurement=MeasurementSpec(
+                ExecutionMode.MADGRAPH,
+                ModelKey.UFO_SM,
+                Accuracy.FULL,
+                "fortran",
+                None,
+            ),
+            workload=Workload.CONTRACTED,
+        )
+        measurement = adapter.measure(
+            cell,
+            artifact_path=artifact_root / spec.artifact_name,
+            settings=settings,
+        )
+        value, identity = _madgraph_measurement(measurement, spec)
+        values[spec.case_id] = value
+        identities.append(identity)
+    return MadGraphIngest(values=values, identity=_one_madgraph_identity(identities))
+
+
+@dataclass(frozen=True, slots=True)
+class _RuntimeBuildIdentity:
+    source_revision: str
+    native_build_inputs_sha256: str
+    version: str
+
+
+def _current_runtime_identity() -> _RuntimeBuildIdentity:
+    """Authenticate the installed runtime without consulting the dirty checkout."""
+
+    try:
+        import pyamplicol
+        from pyamplicol._internal.versions import active_native_source_identity
+
+        expected_prefix = (ROOT / ".venv").resolve(strict=True)
+        observed_prefix = Path(sys.prefix).resolve(strict=True)
+        package_raw = getattr(pyamplicol, "__file__", None)
+        if not isinstance(package_raw, str):
+            raise NumericalAcceptanceError(
+                "the active pyamplicol package has no filesystem origin"
+            )
+        package_path = Path(package_raw).resolve(strict=True)
+        if (
+            observed_prefix != expected_prefix
+            or not package_path.is_relative_to(expected_prefix)
+            or "site-packages" not in package_path.relative_to(expected_prefix).parts
+        ):
+            raise NumericalAcceptanceError(
+                "capture must import pyamplicol from this repository's .venv "
+                "site-packages"
+            )
+        revision, native_digest = active_native_source_identity()
+        return _RuntimeBuildIdentity(
+            source_revision=_revision(revision, "active runtime source revision"),
+            native_build_inputs_sha256=_sha256(
+                native_digest, "active runtime native build inputs"
+            ),
+            version=_string(
+                importlib.metadata.version("pyamplicol"),
+                "active runtime package version",
+            ),
+        )
+    except NumericalAcceptanceError:
+        raise
+    except (ImportError, OSError, RuntimeError, ValueError) as error:
+        raise NumericalAcceptanceError(
+            f"could not authenticate the active pyamplicol runtime: {error}"
+        ) from error
+
+
+def _capture_recurrence_references(
+    *,
+    model: object,
+    artifact_root: Path,
+    full_values: Mapping[str, Decimal],
+) -> tuple[dict[str, Decimal], dict[str, Decimal]]:
+    """Recheck current recurrence p200/p16 and capture LC/NLC references."""
+
+    from pyamplicol import Runtime
+
+    artifact_root.mkdir(parents=True, exist_ok=True)
+    captured: dict[str, dict[str, Decimal]] = {"lc": {}, "nlc": {}}
+
+    for group in cast(tuple[ArtifactGroup, ArtifactGroup], ("catalog", "extra")):
+        lane = AcceptanceLane("full", "recurrence", 2)
+        artifact = generate_lane_artifact(
+            lane,
+            artifact_path=artifact_root / f"capture-{lane.lane_id}-{group}",
+            model=model,
+            group=group,
+        )
+        for spec in lane_case_specs(lane, group=group):
+            momenta = (
+                tuple(
+                    tuple(float(component) for component in row)
+                    for row in validation_momenta(spec.process)
+                ),
+            )
+            runtime = Runtime.load(artifact, process=spec.artifact_name)
+            try:
+                _validate_runtime_lane(
+                    runtime,
+                    lane,
+                    context=f"capture/{spec.case_id}",
+                )
+                precise = runtime.evaluate(
+                    momenta, precision=FULL_CANDIDATE_PRECISION_DIGITS
+                )[0]
+                assert_relative_match(
+                    precise,
+                    full_values[spec.case_id],
+                    context=f"capture/{spec.case_id}/full-recurrence/p200",
+                )
+                native = runtime.evaluate(momenta, precision=NATIVE_PRECISION_DIGITS)[0]
+                assert_relative_match(
+                    native,
+                    full_values[spec.case_id],
+                    context=f"capture/{spec.case_id}/full-recurrence/p16",
+                )
+            finally:
+                runtime.clear()
+
+    for accuracy in cast(tuple[AccuracyName, AccuracyName], ("lc", "nlc")):
+        lane = AcceptanceLane(accuracy, "recurrence", 2)
+        artifact = generate_lane_artifact(
+            lane,
+            artifact_path=artifact_root / f"capture-{lane.lane_id}",
+            model=model,
+        )
+        for spec in lane_case_specs(lane):
+            momenta = (
+                tuple(
+                    tuple(float(component) for component in row)
+                    for row in validation_momenta(spec.process)
+                ),
+            )
+            runtime = Runtime.load(artifact, process=spec.artifact_name)
+            try:
+                _validate_runtime_lane(
+                    runtime,
+                    lane,
+                    context=f"capture/{spec.case_id}",
+                )
+                precise = runtime.evaluate(
+                    momenta, precision=FULL_CANDIDATE_PRECISION_DIGITS
+                )[0]
+                precise_decimal = _decimal_from_number(
+                    precise, f"captured {spec.case_id}/{accuracy}/p200"
+                )
+                native = runtime.evaluate(momenta, precision=NATIVE_PRECISION_DIGITS)[0]
+                assert_relative_match(
+                    native,
+                    precise_decimal,
+                    context=f"capture/{spec.case_id}/{accuracy}/p16",
+                )
+                captured[accuracy][spec.case_id] = precise_decimal
+            finally:
+                runtime.clear()
+    return captured["lc"], captured["nlc"]
+
+
+def _paths_overlap(left: Path, right: Path) -> bool:
+    return left == right or left.is_relative_to(right) or right.is_relative_to(left)
+
+
+def capture_acceptance_fixture(
+    *,
+    madgraph_cache: Path | None = None,
+    madgraph_wave_root: Path | None = None,
+    madgraph_installation: Path | None = None,
+    extra_madgraph_root: Path | None = None,
+    work_root: Path,
+    output: Path,
+) -> AcceptanceFixture:
+    """Capture a fixture, refusing to publish until all strict gates pass."""
+
+    if (madgraph_cache is None) == (madgraph_wave_root is None):
+        raise NumericalAcceptanceError(
+            "provide exactly one of madgraph_cache or madgraph_wave_root"
+        )
+    if extra_madgraph_root is None and madgraph_installation is None:
+        raise NumericalAcceptanceError(
+            "madgraph_installation is required when extra_madgraph_root is absent"
+        )
+    destination = output.expanduser().resolve(strict=False)
+    root = work_root.expanduser().resolve(strict=False)
+    if destination.exists():
+        raise NumericalAcceptanceError(
+            f"refusing to overwrite existing fixture {destination}"
+        )
+    if root.exists():
+        raise NumericalAcceptanceError(f"capture work root already exists: {root}")
+    if _paths_overlap(destination, root):
+        raise NumericalAcceptanceError(
+            "fixture output must be outside the disposable capture work root"
+        )
+    for source in (
+        madgraph_cache,
+        madgraph_wave_root,
+        extra_madgraph_root,
+        madgraph_installation,
+    ):
+        if source is None:
+            continue
+        resolved_source = source.expanduser().resolve(strict=False)
+        if _paths_overlap(destination, resolved_source) or _paths_overlap(
+            root, resolved_source
+        ):
+            raise NumericalAcceptanceError(
+                "fixture output and work root must not overlap a MadGraph input"
+            )
+
+    runtime_identity = _current_runtime_identity()
+    try:
+        root.mkdir(parents=True, exist_ok=False)
+    except FileExistsError as error:
+        raise NumericalAcceptanceError(
+            f"capture work root already exists: {root}"
+        ) from error
+
+    catalog_madgraph = (
+        ingest_authenticated_madgraph_cache(madgraph_cache)
+        if madgraph_cache is not None
+        else ingest_authenticated_madgraph_wave_root(cast(Path, madgraph_wave_root))
+    )
+    if extra_madgraph_root is not None:
+        extra_madgraph = ingest_authenticated_extra_madgraph_root(extra_madgraph_root)
+    else:
+        extra_madgraph = capture_extra_madgraph_values(
+            installation=cast(Path, madgraph_installation),
+            artifact_root=root / "madgraph-extra",
+        )
+    if catalog_madgraph.identity != extra_madgraph.identity:
+        raise NumericalAcceptanceError(
+            "catalog and extra MadGraph records have different authority identities"
+        )
+    full_values = {**catalog_madgraph.values, **extra_madgraph.values}
+    model = prepare_ufo_sm_model(root / "prepared-model")
+    lc_values, nlc_values = _capture_recurrence_references(
+        model=model,
+        artifact_root=root / "pyamplicol",
+        full_values=full_values,
+    )
+    payload = build_fixture_payload(
+        full_values=full_values,
+        lc_values=lc_values,
+        nlc_values=nlc_values,
+        full_reference=catalog_madgraph.identity,
+        captured_source_revision=runtime_identity.source_revision,
+    )
+    return write_acceptance_fixture(payload, destination)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    validate = subparsers.add_parser("validate", help="validate an existing fixture")
+    validate.add_argument("fixture", type=Path)
+    capture = subparsers.add_parser(
+        "capture",
+        help="capture strict full-colour controls and p200 regression references",
+    )
+    catalog_source = capture.add_mutually_exclusive_group(required=True)
+    catalog_source.add_argument("--madgraph-cache", type=Path)
+    catalog_source.add_argument("--madgraph-wave-root", type=Path)
+    capture.add_argument("--madgraph-installation", type=Path)
+    capture.add_argument(
+        "--extra-madgraph-root",
+        type=Path,
+        help="reuse a successful authenticated non-catalog n=6 stress gate",
+    )
+    capture.add_argument("--work-root", type=Path, required=True)
+    capture.add_argument("--output", type=Path, required=True)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = _parser().parse_args(argv)
+    if arguments.command == "validate":
+        fixture = load_acceptance_fixture(arguments.fixture)
+        print(
+            f"validated {len(fixture.catalog)} catalog and "
+            f"{len(fixture.extra_full_colour)} extra cases"
+        )
+        return 0
+    if arguments.command == "capture":
+        fixture = capture_acceptance_fixture(
+            madgraph_cache=arguments.madgraph_cache,
+            madgraph_wave_root=arguments.madgraph_wave_root,
+            madgraph_installation=arguments.madgraph_installation,
+            extra_madgraph_root=arguments.extra_madgraph_root,
+            work_root=arguments.work_root,
+            output=arguments.output,
+        )
+        print(
+            f"captured {len(fixture.catalog)} catalog and "
+            f"{len(fixture.extra_full_colour)} extra cases to "
+            f"{arguments.output}"
+        )
+        return 0
+    raise NumericalAcceptanceError(f"unsupported command {arguments.command!r}")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+
+
+__all__ = [
+    "ACCEPTANCE_LANES",
+    "CATALOG_CASE_COUNT",
+    "CATALOG_MAX_N_FINAL",
+    "DEFAULT_FIXTURE",
+    "EXTRA_FULL_COLOUR_CASES",
+    "FULL_CANDIDATE_PRECISION_DIGITS",
+    "FULL_LANES",
+    "LC_ALL_FLOW_UNION_LANES",
+    "NATIVE_PRECISION_DIGITS",
+    "POINT_SEED",
+    "RELATIVE_TOLERANCE",
+    "AcceptanceCase",
+    "AcceptanceCaseSpec",
+    "AcceptanceFixture",
+    "AcceptanceLane",
+    "MadGraphReferenceIdentity",
+    "NumericalAcceptanceError",
+    "NumericalAcceptanceHarness",
+    "NumericalAcceptanceMismatch",
+    "build_fixture_payload",
+    "capture_acceptance_fixture",
+    "catalog_cases",
+    "compare_relative",
+    "current_model_identity",
+    "ingest_authenticated_extra_madgraph_root",
+    "ingest_authenticated_madgraph_cache",
+    "ingest_authenticated_madgraph_wave_root",
+    "lane_case_specs",
+    "lane_process_set",
+    "lane_run_config",
+    "load_acceptance_fixture",
+    "main",
+    "parse_acceptance_fixture",
+    "prepare_ufo_sm_model",
+    "validation_momenta",
+    "write_acceptance_fixture",
+]
diff --git a/pyamplicol/tools/developer/on_the_fly_high_multiplicity.py b/pyamplicol/tools/developer/on_the_fly_high_multiplicity.py
new file mode 100644
index 0000000000..60ed89aff4
--- /dev/null
+++ b/pyamplicol/tools/developer/on_the_fly_high_multiplicity.py
@@ -0,0 +1,2834 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Guarded, process-parametric high-multiplicity LC study for on-the-fly mode.
+
+Run ``selected`` first: it creates the multiplicity's sole fresh OTF artifact.
+Run ``all-flow`` separately with ``--candidate-artifact`` pointing at that
+artifact.  Selected n=5/6/7 cells use exactly one independent authority:
+authenticated original AmpliCol where supported, otherwise recurrence for the
+four-open-quark-line family.  Selected n=8/9 and every all-flow invocation are
+intentionally OTF-only feasibility probes.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import re
+import sys
+import time
+from collections.abc import Callable, Mapping, Sequence
+from contextlib import ExitStack
+from dataclasses import dataclass, replace
+from pathlib import Path
+from typing import Any
+from unittest import mock
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import pyamplicol.generation.service as generation_service  # noqa: E402
+from pyamplicol import (  # noqa: E402
+    BenchmarkRunner,
+    Generator,
+    ModelSource,
+    ProcessRequest,
+    Runtime,
+)
+from pyamplicol.api.errors import ArtifactError, EvaluationError  # noqa: E402
+from pyamplicol.artifacts import load_manifest  # noqa: E402
+from pyamplicol.config import (  # noqa: E402
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+from pyamplicol.models.builtin.validation import generic_validation_point  # noqa: E402
+from tools.ci.memory_watchdog import GIB, run_guarded  # noqa: E402
+from tools.developer import legacy_amplicol  # noqa: E402
+from tools.developer import on_the_fly_lc_gate as n4  # noqa: E402
+from tools.developer.legacy_oracle.model import (  # noqa: E402
+    PINNED_REFERENCE_REVISION,
+)
+from tools.performance_report.artifacts import (  # noqa: E402
+    ArtifactStore,
+    ArtifactStoreError,
+)
+from tools.performance_report.cache import validate_measurement  # noqa: E402
+from tools.performance_report.catalog import REPORT_CATALOG  # noqa: E402
+from tools.performance_report.legacy import (  # noqa: E402
+    LegacyAdapterError,
+    _canonical_mapped_color_word,
+    _initial_state_count,
+)
+from tools.performance_report.models import Accuracy, Workload  # noqa: E402
+from tools.performance_report.runner import (  # noqa: E402
+    RunnerError,
+    SelectorContract,
+    derive_selector_contract,
+    point_digest,
+    validate_selector_contract,
+)
+from tools.performance_report.selector_policy import (  # noqa: E402
+    SelectorPolicyError,
+    canonical_lc_flow_word,
+    fixed_selector_helicity,
+    selector_color_flow_id,
+    selector_helicity_id,
+)
+from tools.performance_report.service import (  # noqa: E402
+    ReportPaths,
+    validate_profile_name,
+)
+from tools.performance_report.source_identity import (  # noqa: E402
+    ReportSourceIdentity,
+    ReportSourceIdentityError,
+    require_eligible_report_source,
+)
+
+KIND = "pyamplicol-on-the-fly-high-multiplicity-study"
+SCHEMA_VERSION = 6
+SUPPORTED_PROCESS_IDS = (7, 8, 11, 13, 14, 15)
+SUPPORTED_MULTIPLICITIES = (5, 6, 7, 8, 9)
+SUPPORTED_PROCESS_MULTIPLICITIES = {
+    7: (5, 6, 7, 8, 9),
+    8: (5, 6, 7, 8, 9),
+    11: (5, 6, 7),
+    13: (5, 6, 7),
+    14: (6, 7),
+    15: (5, 6, 7),
+}
+AMPLI_COL_AUTHORITY_IDS = frozenset({7, 8, 11, 13, 15})
+AUTHORITY_AMPLICOL = "amplicol"
+AUTHORITY_RECURRENCE = "recurrence"
+AUTHORITY_OTF_ONLY = "otf-only"
+LIFECYCLE_EXHAUSTIVE = "exhaustive-clear-rebuild"
+LIFECYCLE_LEAN = "lean-retained-requested-family"
+REQUESTED_COLD_WARMUP_KIND = "on-the-fly-requested-workload-cold-warmup-v2"
+SEEDS = n4.SEEDS
+BATCH_SIZE = 128
+WARMUP_RUNS = 2
+MINIMUM_SAMPLES = 5
+OTF_QUERY_CONSTRUCTION_THREADS = 4
+RECURRENCE_GENERATION_THREADS = 1
+WATCHDOG_BYTES = 30 * GIB
+STATE_KIND = "rusticol-on-the-fly-runtime-state-census-v1"
+STATE_INSPECTION_KEY = "on_the_fly_state"
+STATE_FAMILY_CACHE_POLICY = "last-family-only"
+STATE_FAMILY_CACHE_LIMIT = 1
+STATE_COUNTS = (
+    "process_preparation_count",
+    "retained_family_count",
+    "pending_family_count",
+    "retained_selection_count",
+    "retained_request_count",
+    "retained_amplitude_destination_count",
+    "retained_executor_handle_count",
+    "retained_query_local_trace_count",
+    "retained_embedded_lookup_key_count",
+    "semantic_executor_binding_count",
+)
+COMPACT_ZERO_COUNTS = (
+    "pending_family_count",
+    "retained_query_local_trace_count",
+    "retained_embedded_lookup_key_count",
+)
+ACTIVE_COUNT_FIELDS = (
+    "query_count",
+    "union_unique_current_count",
+    "union_unique_current_component_count",
+    "union_source_rows",
+    "union_contribution_rows",
+    "union_finalization_rows",
+    "union_closure_rows",
+    "union_amplitude_destination_count",
+    "union_source_executor_call_groups",
+    "union_contribution_executor_call_groups",
+    "union_finalization_executor_call_groups",
+    "union_closure_executor_call_groups",
+)
+OPERATION_ROLES = ("source", "contribution", "finalization", "closure")
+STATE_FIELDS = frozenset(
+    {
+        "kind",
+        "process_id",
+        "family_cache_policy",
+        "family_cache_limit",
+        *STATE_COUNTS,
+        "active_family_union_census",
+    }
+)
+
+Point = tuple[tuple[float, ...], ...]
+Points = tuple[Point, ...]
+
+
+class StudyError(RuntimeError):
+    """The bounded study contract was not satisfied."""
+
+
+@dataclass(frozen=True, slots=True)
+class Case:
+    process_table_id: int
+    process_key: str
+    multiplicity: int
+    process: str
+    process_id: str
+    pdgs: tuple[int, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class Selector:
+    flow_word: tuple[int, ...]
+    flow_id: str
+    helicities: tuple[int, ...]
+    helicity_id: str
+
+    def mapping(self, points: Points) -> dict[str, object]:
+        return {
+            "selected_color_flow_ids": [self.flow_id],
+            "selected_color_words": [list(self.flow_word)],
+            "all_flow_helicity_ids": [self.helicity_id],
+            "all_flow_source_helicities": {
+                str(index): value
+                for index, value in enumerate(self.helicities, start=1)
+            },
+            "point_digest": point_digest(points),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class Evaluation:
+    total: tuple[object, ...]
+    resolved: object | None
+    total_vs_resolved: dict[str, object] | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class AmplicolReference:
+    selector: Selector
+    contract: SelectorContract
+    selector_contract: dict[str, object]
+    matrix_element: float
+    timing: dict[str, object]
+    lineage: dict[str, object]
+    library_path: Path | None = None
+    process_row: tuple[int, int] | None = None
+
+
+def _positive_float(text: str) -> float:
+    value = float(text)
+    if not math.isfinite(value) or value <= 0.0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return value
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument(
+        "--process-id", required=True, type=int, choices=SUPPORTED_PROCESS_IDS
+    )
+    parser.add_argument(
+        "--multiplicity", required=True, type=int, choices=SUPPORTED_MULTIPLICITIES
+    )
+    parser.add_argument(
+        "--workload", choices=("selected", "all-flow"), default="selected"
+    )
+    parser.add_argument("--prepared-model", type=Path)
+    parser.add_argument(
+        "--reference-repo-root",
+        type=Path,
+        help="repository root owning the authenticated AmpliCol profile; "
+        "required only for AmpliCol-authority selected cells",
+    )
+    parser.add_argument(
+        "--reference-profile",
+        help="ReportPaths profile containing authenticated AmpliCol currents; "
+        "required only for AmpliCol-authority selected cells",
+    )
+    parser.add_argument(
+        "--candidate-artifact",
+        type=Path,
+        help="sole OTF artifact created by the selected invocation",
+    )
+    parser.add_argument(
+        "--selected-report",
+        type=Path,
+        help="passed selected-workload report that created the OTF candidate",
+    )
+    parser.add_argument("--target-runtime", type=_positive_float, default=5.0)
+    parser.add_argument("--worker", action="store_true", help=argparse.SUPPRESS)
+    return parser
+
+
+def _case(process_table_id: int, multiplicity: int) -> Case:
+    if process_table_id not in SUPPORTED_PROCESS_IDS:
+        raise StudyError(f"unsupported process-table ID {process_table_id}")
+    if multiplicity not in SUPPORTED_MULTIPLICITIES:
+        raise StudyError(f"unsupported multiplicity n={multiplicity}")
+    if multiplicity not in SUPPORTED_PROCESS_MULTIPLICITIES[process_table_id]:
+        raise StudyError(
+            f"process-table ID {process_table_id} does not define a planned "
+            f"high-multiplicity cell at n={multiplicity}"
+        )
+    family = next(
+        (
+            candidate
+            for candidate in REPORT_CATALOG.process_families
+            if candidate.identifier == process_table_id
+        ),
+        None,
+    )
+    expected_keys = {
+        7: "dd_tt_jets",
+        8: "gg_gluons",
+        11: "dd_ttzh_jets",
+        13: "dd_3q_lines",
+        14: "dd_4q_lines",
+        15: "dd_3q_identical_lines",
+    }
+    if family is None or family.key != expected_keys[process_table_id]:
+        raise StudyError("process-table catalog identity changed")
+    process = family.process(multiplicity)
+    if process is None:
+        raise StudyError("process-table family does not define this multiplicity")
+    bases = {
+        7: (1, -1, 6, -6),
+        8: (21, 21, 21, 21),
+        11: (1, -1, 6, -6, 23, 25),
+        13: (1, -1, 2, -2, 3, -3),
+        14: (1, -1, 2, -2, 3, -3, 4, -4),
+        15: (1, -1, 2, -2, 2, -2),
+    }
+    base_final_count = len(bases[process_table_id]) - 2
+    pdgs = (
+        *bases[process_table_id],
+        *(21 for _ in range(multiplicity - base_final_count)),
+    )
+    return Case(
+        process_table_id,
+        family.key,
+        multiplicity,
+        process,
+        f"otf_p{process_table_id}_{family.key}_n{multiplicity}",
+        pdgs,
+    )
+
+
+def _lifecycle_policy(case: Case, workload: str) -> dict[str, object]:
+    if workload not in {"selected", "all-flow"}:
+        raise StudyError(f"unsupported lifecycle workload {workload!r}")
+    lean = case.multiplicity >= 7 or (
+        case.process_table_id == 8 and case.multiplicity >= 6
+    )
+    if not lean:
+        return {
+            "mode": LIFECYCLE_EXHAUSTIVE,
+            "retain_requested_family_after_cold_warmup": False,
+            "clear_rebuild": "required",
+            "reason": "lower-cost cell provides the exhaustive lifecycle proof",
+            "expected_prior_campaign_prerequisite": None,
+        }
+    baselines = tuple(
+        multiplicity
+        for multiplicity in SUPPORTED_PROCESS_MULTIPLICITIES[case.process_table_id]
+        if multiplicity < case.multiplicity
+        and not (
+            multiplicity >= 7 or (case.process_table_id == 8 and multiplicity >= 6)
+        )
+    )
+    if not baselines:
+        raise StudyError("lean lifecycle has no exhaustive lower-cost baseline")
+    baseline = max(baselines)
+    return {
+        "mode": LIFECYCLE_LEAN,
+        "retain_requested_family_after_cold_warmup": True,
+        "clear_rebuild": "omitted",
+        "reason": (
+            "the requested family is high-cost; same-workload clear/rebuild at "
+            "the recorded lower multiplicity is an expected prior campaign "
+            "prerequisite not authenticated by this report"
+        ),
+        "expected_prior_campaign_prerequisite": {
+            "evidence_status": "expected-not-authenticated-by-this-report",
+            "process_table_id": case.process_table_id,
+            "multiplicity": baseline,
+            "workload": workload,
+            "policy": LIFECYCLE_EXHAUSTIVE,
+        },
+    }
+
+
+def _clear_rebuild_evidence(policy: Mapping[str, object]) -> dict[str, object]:
+    omitted = policy.get("mode") == LIFECYCLE_LEAN
+    return {
+        "status": "omitted" if omitted else "performed",
+        "reason": policy["reason"],
+        "expected_prior_campaign_prerequisite": policy[
+            "expected_prior_campaign_prerequisite"
+        ],
+    }
+
+
+def _authority_kind(case: Case, workload: str) -> str:
+    if workload == "all-flow":
+        return AUTHORITY_OTF_ONLY
+    if workload != "selected":
+        raise StudyError(f"unsupported workload {workload!r}")
+    if case.process_table_id == 14:
+        return AUTHORITY_RECURRENCE
+    if case.multiplicity >= 8:
+        return AUTHORITY_OTF_ONLY
+    if case.process_table_id in AMPLI_COL_AUTHORITY_IDS:
+        return AUTHORITY_AMPLICOL
+    raise StudyError("selected cell has no declared authority policy")
+
+
+def _validate_arguments(args: argparse.Namespace) -> None:
+    case = _case(args.process_id, args.multiplicity)
+    authority = _authority_kind(case, args.workload)
+    has_reference_root = args.reference_repo_root is not None
+    has_reference_profile = args.reference_profile is not None
+    if has_reference_root != has_reference_profile:
+        raise StudyError(
+            "--reference-repo-root and --reference-profile must be supplied together"
+        )
+    if authority == AUTHORITY_AMPLICOL:
+        if not has_reference_root:
+            raise StudyError("AmpliCol-authority selected cells require reference args")
+        if (
+            not isinstance(args.reference_profile, str)
+            or not args.reference_profile.strip()
+        ):
+            raise StudyError("--reference-profile must be non-empty")
+    elif has_reference_root:
+        raise StudyError("reference args are only valid for AmpliCol-authority cells")
+    if args.workload == "selected":
+        if args.prepared_model is None:
+            raise StudyError("selected requires --prepared-model")
+        if args.candidate_artifact is not None:
+            raise StudyError("selected creates the candidate artifact")
+        if args.selected_report is not None:
+            raise StudyError("selected creates, rather than consumes, its report")
+    elif args.candidate_artifact is None:
+        raise StudyError("all-flow requires --candidate-artifact")
+    elif args.selected_report is None:
+        raise StudyError("all-flow requires --selected-report")
+    elif args.prepared_model is not None:
+        raise StudyError(
+            "all-flow reuses the selected artifact without --prepared-model"
+        )
+
+
+def _existing(path: Path, *, directory: bool, label: str) -> Path:
+    result = Path(os.path.abspath(path.expanduser()))
+    if not (result.is_dir() if directory else result.is_file()):
+        raise StudyError(f"{label} does not exist: {result}")
+    return result
+
+
+def _points(case: Case) -> Points:
+    return tuple(
+        tuple(tuple(map(float, particle.momentum)) for particle in point)
+        for point in (
+            generic_validation_point(case.process, sqrt_s=1000.0, seed=seed)
+            for seed in SEEDS
+        )
+    )
+
+
+def _timing_points(points: Points) -> Points:
+    if not points:
+        raise StudyError("benchmark requires the seed-101 correctness point")
+    return (points[0],) * BATCH_SIZE
+
+
+def _colored_source_labels(case: Case) -> tuple[int, ...]:
+    """Return the exact public source labels carried by an LC flow word."""
+
+    labels = tuple(
+        label
+        for label, pdg in enumerate(case.pdgs, start=1)
+        if abs(pdg) in {1, 2, 3, 4, 5, 6, 21}
+    )
+    if not labels:
+        raise StudyError("LC selector process has no colored external sources")
+    return labels
+
+
+def _selector_from_contract(case: Case, contract: SelectorContract) -> Selector:
+    expected_helicities = fixed_selector_helicity(case.pdgs)
+    expected_helicity_id = selector_helicity_id(expected_helicities)
+    expected_sources = tuple(enumerate(expected_helicities, start=1))
+    if (
+        len(contract.selected_color_words) != 1
+        or len(contract.selected_color_flow_ids) != 1
+        or contract.runtime_all_flow_helicity_ids != (expected_helicity_id,)
+        or contract.all_flow_source_helicities != expected_sources
+    ):
+        raise StudyError("AmpliCol selector contract has the wrong process axis")
+    word = contract.selected_color_words[0]
+    flow_id = contract.selected_color_flow_ids[0]
+    if (
+        len(word) != len(_colored_source_labels(case))
+        or set(word) != set(_colored_source_labels(case))
+        or selector_color_flow_id(word) != flow_id
+    ):
+        raise StudyError("AmpliCol selector flow does not round-trip")
+    return Selector(word, flow_id, expected_helicities, expected_helicity_id)
+
+
+def _compact_selector_context(
+    runtime: object,
+    case: Case,
+    requested: tuple[str, ...],
+) -> dict[str, object]:
+    backend = getattr(runtime, "_backend", None)
+    operation = getattr(backend, "_on_the_fly_benchmark_context", None)
+    if not callable(operation):
+        raise StudyError("candidate has no compact on-the-fly selector context")
+    raw = operation(requested)
+    if not isinstance(raw, Mapping):
+        raise StudyError("candidate compact selector context is unavailable")
+    selected = raw.get("selected_color_ids")
+    if (
+        raw.get("process_id") != case.process_id
+        or raw.get("process_expression") != case.process
+        or raw.get("color_accuracy") != "lc"
+        or isinstance(raw.get("helicity_count"), bool)
+        or not isinstance(raw.get("helicity_count"), int)
+        or int(raw["helicity_count"]) < 1
+        or isinstance(raw.get("color_count"), bool)
+        or not isinstance(raw.get("color_count"), int)
+        or int(raw["color_count"]) < 1
+        or not isinstance(selected, Sequence)
+        or isinstance(selected, (str, bytes))
+        or len(selected) != len(requested)
+        or any(not isinstance(value, str) or not value for value in selected)
+    ):
+        raise StudyError("candidate compact selector context has the wrong identity")
+    return {
+        "process_id": case.process_id,
+        "process_expression": case.process,
+        "color_accuracy": "lc",
+        "helicity_count": raw["helicity_count"],
+        "color_count": raw["color_count"],
+        "requested_color_ids": list(requested),
+        "selected_color_ids": list(selected),
+    }
+
+
+def _flow_word(flow_id: str) -> tuple[int, ...]:
+    if not flow_id.startswith("flow:"):
+        raise StudyError("compact selector did not return a semantic flow ID")
+    try:
+        word = canonical_lc_flow_word(
+            tuple(int(token) for token in flow_id.removeprefix("flow:").split(","))
+        )
+    except (SelectorPolicyError, ValueError) as error:
+        raise StudyError(
+            "compact selector returned an invalid semantic flow ID"
+        ) from error
+    if selector_color_flow_id(word) != flow_id:
+        raise StudyError("compact selector flow ID does not round-trip")
+    return word
+
+
+def _selector_from_compact_ordinal_one(
+    runtime: object,
+    case: Case,
+    points: Points,
+) -> tuple[Selector, SelectorContract, dict[str, object]]:
+    """Derive the first labelled flow through the compact seed axis only."""
+
+    context = _compact_selector_context(runtime, case, ("1",))
+    selected = context["selected_color_ids"]
+    if not isinstance(selected, list) or len(selected) != 1:
+        raise StudyError("compact ordinal 1 did not resolve exactly one flow")
+    flow_id = selected[0]
+    if not isinstance(flow_id, str):
+        raise StudyError("compact ordinal 1 did not resolve a semantic flow ID")
+    flow_word = _flow_word(flow_id)
+    if len(flow_word) != len(_colored_source_labels(case)) or set(flow_word) != set(
+        _colored_source_labels(case)
+    ):
+        raise StudyError("compact ordinal-1 flow has the wrong external axis")
+    helicities = fixed_selector_helicity(case.pdgs)
+    selector = Selector(
+        flow_word=flow_word,
+        flow_id=flow_id,
+        helicities=helicities,
+        helicity_id=selector_helicity_id(helicities),
+    )
+    contract = SelectorContract(
+        selected_color_flow_ids=(selector.flow_id,),
+        selected_color_words=(selector.flow_word,),
+        all_flow_helicity_ids=(selector.helicity_id,),
+        all_flow_source_helicities=tuple(enumerate(selector.helicities, start=1)),
+        point_digest=point_digest(points),
+    )
+    context["selector_source"] = "compact-seed-one-based-color-ordinal-1"
+    context["resolved_semantic_flow_id"] = flow_id
+    return selector, contract, context
+
+
+def _reference_cell(case: Case, workload: str) -> object:
+    expected_workload = (
+        Workload.SELECTED_FLOW if workload == "selected" else Workload.ALL_FLOW
+    )
+    matches = tuple(
+        cell
+        for cell in REPORT_CATALOG.reference_cells()
+        if cell.process_key == case.process_key
+        and cell.n_final == case.multiplicity
+        and cell.measurement.accuracy is Accuracy.LC
+        and cell.workload is expected_workload
+    )
+    if len(matches) != 1:
+        raise StudyError("AmpliCol reference catalog cell is not unique")
+    cell = matches[0]
+    if cell.process != case.process:
+        raise StudyError("AmpliCol reference process differs from the process table")
+    return cell
+
+
+def _required_reference_number(
+    measurement: Mapping[str, object], field: str, *, allow_zero: bool = False
+) -> float:
+    value = measurement.get(field)
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise StudyError(f"AmpliCol reference omitted {field}")
+    result = float(value)
+    if not math.isfinite(result) or result < 0.0 or (result == 0.0 and not allow_zero):
+        raise StudyError(f"AmpliCol reference has invalid {field}")
+    return result
+
+
+def _required_reference_sample_count(measurement: Mapping[str, object]) -> int:
+    value = measurement.get("sample_count")
+    if isinstance(value, bool) or not isinstance(value, int) or value < MINIMUM_SAMPLES:
+        raise StudyError("AmpliCol reference has insufficient actual samples")
+    return value
+
+
+def _active_report_source() -> ReportSourceIdentity:
+    try:
+        return require_eligible_report_source(ROOT)
+    except ReportSourceIdentityError as error:
+        raise StudyError(f"active report source is ineligible: {error}") from error
+
+
+def _authenticate_reference_source(
+    provenance: Mapping[str, object], active_source: ReportSourceIdentity
+) -> None:
+    """Keep the current exact source-lineage policy isolated for later audit."""
+
+    source_fields = {
+        "revision": PINNED_REFERENCE_REVISION,
+        "report_source_revision": active_source.revision,
+        "report_measured_source_revision": active_source.revision,
+        "report_source_tree": active_source.tree,
+        "report_measured_source_tree": active_source.tree,
+        "report_source_clean": True,
+    }
+    if any(
+        provenance.get(field) != expected for field, expected in source_fields.items()
+    ):
+        raise StudyError("AmpliCol reference source differs from the active source")
+
+
+def _reference_timing_contract(
+    provenance: Mapping[str, object],
+    case: Case,
+    workload: str,
+    target_runtime: float,
+) -> dict[str, object]:
+    manual = provenance.get("manual_campaign")
+    if not isinstance(manual, Mapping):
+        raise StudyError("AmpliCol reference omitted manual-campaign timing evidence")
+    expected_workload = (
+        Workload.SELECTED_FLOW if workload == "selected" else Workload.ALL_FLOW
+    )
+    expected_cell = _reference_cell(case, workload)
+    expected_identity = {
+        "accuracy": "lc",
+        "backend": "fortran",
+        "cell_id": expected_cell.cell_id,
+        "dataset_id": "reference_amplicol_lc",
+        "execution_mode": "amplicol",
+        "model": None,
+        "n_final": case.multiplicity,
+        "process": case.process,
+        "process_key": case.process_key,
+        "variant": None,
+        "workload": expected_workload.value,
+    }
+    identity = manual.get("cell_identity")
+    batch_size = manual.get("batch_size")
+    warmup_runs = manual.get("warmup_runs")
+    minimum_samples = manual.get("minimum_samples")
+    recorded_target = manual.get("target_runtime_seconds")
+    if not isinstance(identity, Mapping) or dict(identity) != expected_identity:
+        raise StudyError("AmpliCol manual-campaign cell identity is mismatched")
+    if batch_size != BATCH_SIZE:
+        raise StudyError("AmpliCol manual-campaign batch size is mismatched")
+    if warmup_runs != WARMUP_RUNS:
+        raise StudyError("AmpliCol manual-campaign warm-up count is mismatched")
+    if (
+        isinstance(minimum_samples, bool)
+        or not isinstance(minimum_samples, int)
+        or minimum_samples < MINIMUM_SAMPLES
+    ):
+        raise StudyError("AmpliCol manual-campaign sample minimum is insufficient")
+    if (
+        isinstance(recorded_target, bool)
+        or not isinstance(recorded_target, (int, float))
+        or float(recorded_target) != target_runtime
+    ):
+        raise StudyError("AmpliCol manual-campaign target runtime is mismatched")
+    if provenance.get("generation_timing_is_workload_specific") is not True:
+        raise StudyError("AmpliCol generation timing is not workload-specific")
+    return {
+        "batch_size": BATCH_SIZE,
+        "warmup_runs": WARMUP_RUNS,
+        "minimum_samples": int(minimum_samples),
+        "target_runtime_seconds": target_runtime,
+        "cell_identity": expected_identity,
+        "generation_timing_is_workload_specific": True,
+    }
+
+
+def _rebind_reference_selector(
+    raw_contract: Mapping[str, object], case: Case, points: Points
+) -> tuple[SelectorContract, SelectorContract, Selector]:
+    try:
+        stored_contract = SelectorContract.from_mapping(raw_contract)
+    except (TypeError, ValueError) as error:
+        raise StudyError("AmpliCol reference selector contract is invalid") from error
+    singleton_digest = point_digest((points[0],))
+    if stored_contract.point_digest != singleton_digest:
+        raise StudyError("AmpliCol selector digest is not the seed-101 singleton")
+    rebound_contract = replace(stored_contract, point_digest=point_digest(points))
+    if {
+        field: value
+        for field, value in rebound_contract.as_dict().items()
+        if field != "point_digest"
+    } != {
+        field: value
+        for field, value in stored_contract.as_dict().items()
+        if field != "point_digest"
+    }:
+        raise StudyError("AmpliCol selector rebinding changed a physical axis")
+    return (
+        stored_contract,
+        rebound_contract,
+        _selector_from_contract(case, rebound_contract),
+    )
+
+
+def _load_amplicol_reference(
+    repo_root: Path,
+    profile: str,
+    case: Case,
+    workload: str,
+    points: Points,
+    target_runtime: float,
+    active_source: ReportSourceIdentity,
+) -> AmplicolReference:
+    root = _existing(repo_root, directory=True, label="reference repository root")
+    try:
+        validated_profile = validate_profile_name(profile)
+        docs = root / "docs" / "performance_reports" / validated_profile
+        artifacts = docs / "campaign_artifacts"
+        paths = ReportPaths.from_repo(
+            root,
+            docs_dir=docs,
+            artifact_root=artifacts,
+            coordination_root=artifacts / "coordination",
+        )
+    except ValueError as error:
+        raise StudyError(f"invalid AmpliCol reference profile: {profile!r}") from error
+    for path, label in (
+        (paths.docs_dir, "reference report profile"),
+        (paths.artifact_root, "reference artifact root"),
+        (paths.coordination_root, "reference coordination root"),
+    ):
+        _existing(path, directory=True, label=label)
+    cell = _reference_cell(case, workload)
+    store = ArtifactStore(
+        artifact_root=paths.artifact_root,
+        lock_root=paths.coordination_root,
+        current_publication_paths=paths,
+    )
+    try:
+        current = store.load_current(cell.cell_id)
+        assert current is not None
+        validate_measurement(current.result, expected_cell=cell)
+    except (ArtifactStoreError, FileNotFoundError, ValueError) as error:
+        raise StudyError(
+            f"AmpliCol reference current is not authenticated: {cell.cell_id}"
+        ) from error
+    if current.cell_id != cell.cell_id or current.result.get("status") != "ok":
+        raise StudyError("AmpliCol reference current has the wrong workload identity")
+
+    raw_contract = current.result.get("selector_contract")
+    if not isinstance(raw_contract, Mapping):
+        raise StudyError("AmpliCol reference omitted its selector contract")
+    stored_contract, rebound_contract, selector = _rebind_reference_selector(
+        raw_contract, case, points
+    )
+
+    measurement = current.result
+    timing = {
+        "execution_mode": "amplicol",
+        "cell_id": cell.cell_id,
+        "generation_seconds": _required_reference_number(
+            measurement, "generation_seconds"
+        ),
+        "wall_seconds_per_point": _required_reference_number(
+            measurement, "wall_seconds_per_point"
+        ),
+        "evaluator_seconds_per_point": _required_reference_number(
+            measurement, "execution_seconds_per_point"
+        ),
+        "relative_standard_error": _required_reference_number(
+            measurement, "relative_standard_error", allow_zero=True
+        ),
+        "sample_count": _required_reference_sample_count(measurement),
+    }
+    matrix_element = _required_reference_number(
+        measurement, "matrix_element", allow_zero=True
+    )
+    raw_artifact = measurement.get("artifact")
+    artifact_path = (
+        raw_artifact.get("path") if isinstance(raw_artifact, Mapping) else None
+    )
+    process_row = (
+        raw_artifact.get("process_row") if isinstance(raw_artifact, Mapping) else None
+    )
+    row_match = (
+        re.fullmatch(r"group:([1-9][0-9]*):integral:([1-9][0-9]*)", process_row)
+        if isinstance(process_row, str)
+        else None
+    )
+    if not isinstance(artifact_path, str) or row_match is None:
+        raise StudyError("AmpliCol reference omitted its generated-library row")
+    recorded_artifact_path = _existing(
+        Path(artifact_path),
+        directory=True,
+        label="AmpliCol current-owned artifact",
+    )
+    expected_artifact_path = _existing(
+        current.result_path.parent / "artifact",
+        directory=True,
+        label="AmpliCol authenticated attempt artifact",
+    )
+    if recorded_artifact_path != expected_artifact_path:
+        raise StudyError("AmpliCol reference artifact is outside its current attempt")
+    library_path = _existing(
+        recorded_artifact_path / "selected-flow-generated-library",
+        directory=True,
+        label="AmpliCol selected-flow generated-library snapshot",
+    )
+    executable = _existing(
+        library_path / "amplicol_library_benchmark",
+        directory=False,
+        label="AmpliCol selected-flow replay executable",
+    )
+    if not os.access(executable, os.X_OK):
+        raise StudyError("AmpliCol selected-flow replay executable is not executable")
+    _existing(
+        library_path / "processes.txt",
+        directory=False,
+        label="AmpliCol selected-flow process table",
+    )
+    _existing(
+        library_path / "Library",
+        directory=True,
+        label="AmpliCol selected-flow serialized library",
+    )
+    if not tuple(library_path.glob("libamp*.so")):
+        raise StudyError("AmpliCol selected-flow snapshot has no shared libraries")
+    parsed_process_row = (int(row_match.group(1)), int(row_match.group(2)))
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        raise StudyError("AmpliCol reference omitted source provenance")
+    _authenticate_reference_source(provenance, active_source)
+    timing_contract = _reference_timing_contract(
+        provenance, case, workload, target_runtime
+    )
+    return AmplicolReference(
+        selector=selector,
+        contract=rebound_contract,
+        selector_contract=rebound_contract.as_dict(),
+        matrix_element=matrix_element,
+        timing=timing,
+        lineage={
+            "profile": profile,
+            "repo_root": str(paths.repo_root),
+            "artifact_root": str(paths.artifact_root),
+            "cell_id": cell.cell_id,
+            "attempt_id": current.attempt_id,
+            "manifest_sha256": current.manifest_sha256,
+            "result_path": str(current.result_path),
+            "process_table_id": case.process_table_id,
+            "process_key": case.process_key,
+            "process": case.process,
+            "multiplicity": case.multiplicity,
+            "workload": workload,
+            "source_revision": active_source.revision,
+            "source_tree": active_source.tree,
+            "original_amplicol_revision": PINNED_REFERENCE_REVISION,
+            "timing_contract": timing_contract,
+            "stored_selector_point_digest": stored_contract.point_digest,
+            "correctness_selector_point_digest": rebound_contract.point_digest,
+            "selector_rebinding": "point-digest-only",
+            "stored_matrix_element": matrix_element,
+            "selected_flow_generated_library": str(library_path),
+            "process_row": {
+                "group": parsed_process_row[0],
+                "integral": parsed_process_row[1],
+            },
+        },
+        library_path=library_path,
+        process_row=parsed_process_row,
+    )
+
+
+def _lower_hex(value: object, length: int, label: str) -> str:
+    if (
+        not isinstance(value, str)
+        or len(value) != length
+        or value != value.lower()
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise StudyError(f"{label} is not a lowercase hexadecimal identity")
+    return value
+
+
+def _artifact_identity(
+    path: Path,
+    runtime: object,
+    case: Case,
+    expected_mode: str,
+) -> dict[str, object]:
+    try:
+        manifest = load_manifest(path, verify_payloads=False)
+    except (ArtifactError, OSError) as error:
+        raise StudyError(f"cannot load artifact manifest: {path}") from error
+    records = tuple(manifest.processes)
+    if len(records) != 1:
+        raise StudyError("study artifacts must contain exactly one process")
+    process = records[0]
+    if (
+        process.get("id") != case.process_id
+        or process.get("expression") != case.process
+        or tuple(process.get("external_pdgs", ())) != case.pdgs
+        or process.get("color_accuracy") != "lc"
+    ):
+        raise StudyError("artifact manifest has the wrong process identity")
+
+    artifact_id = _lower_hex(manifest.artifact_id, 64, "manifest artifact ID")
+    if (
+        getattr(runtime, "artifact_id", None) != artifact_id
+        or getattr(runtime, "execution_mode", None) != expected_mode
+        or getattr(runtime, "representative_process_key", None) != case.process_id
+    ):
+        raise StudyError("runtime identity differs from its artifact manifest")
+    backend = getattr(runtime, "_backend", None)
+    native = getattr(backend, "_runtime", None)
+    native_artifact_id = getattr(native, "artifact_id", None)
+    metadata = getattr(backend, "_native_metadata", None)
+    if native_artifact_id != artifact_id or not isinstance(metadata, Mapping):
+        raise StudyError("native runtime omitted its authenticated artifact identity")
+    if (
+        metadata.get("execution_mode") != expected_mode
+        or metadata.get("process") != case.process
+        or metadata.get("process_key") != case.process_id
+        or metadata.get("representative_process") != case.process
+        or metadata.get("representative_process_key") != case.process_id
+        or metadata.get("color_accuracy") != "lc"
+        or tuple(metadata.get("external_pdg_order", ())) != case.pdgs
+        or metadata.get("external_count") != len(case.pdgs)
+    ):
+        raise StudyError("native runtime metadata has the wrong process identity")
+
+    producer = manifest.producer
+    source_revision = _lower_hex(
+        producer.get("git_revision"), 40, "producer source revision"
+    )
+    native_digest = _lower_hex(
+        producer.get("native_build_inputs_sha256"),
+        64,
+        "producer native-input digest",
+    )
+    model_identity = dict(manifest.model)
+    return {
+        "path": str(manifest.root),
+        "artifact_id": artifact_id,
+        "native_authenticated_artifact_id": native_artifact_id,
+        "execution_mode": expected_mode,
+        "process_id": case.process_id,
+        "process_expression": case.process,
+        "external_pdgs": list(case.pdgs),
+        "producer_identity": {
+            "source_revision": source_revision,
+            "native_build_inputs_sha256": native_digest,
+        },
+        "model_identity": model_identity,
+    }
+
+
+def _common_producer_identity(
+    artifacts: Mapping[str, Mapping[str, object]],
+) -> dict[str, object]:
+    identities = tuple(record.get("producer_identity") for record in artifacts.values())
+    if not identities or any(not isinstance(value, Mapping) for value in identities):
+        raise StudyError("artifact producer identity evidence is incomplete")
+    first = dict(identities[0])  # type: ignore[arg-type]
+    if any(dict(value) != first for value in identities[1:]):  # type: ignore[arg-type]
+        raise StudyError("study artifacts were produced by different native sources")
+    return first
+
+
+def _common_model_identity(
+    artifacts: Mapping[str, Mapping[str, object]],
+) -> dict[str, object]:
+    identities = tuple(record.get("model_identity") for record in artifacts.values())
+    if not identities or any(not isinstance(value, Mapping) for value in identities):
+        raise StudyError("artifact model identity evidence is incomplete")
+    first = dict(identities[0])  # type: ignore[arg-type]
+    if any(dict(value) != first for value in identities[1:]):  # type: ignore[arg-type]
+        raise StudyError("study artifacts were generated from different models")
+    return first
+
+
+def _candidate_source_binding(
+    active: ReportSourceIdentity, producer: Mapping[str, object]
+) -> dict[str, object]:
+    producer_revision = _lower_hex(
+        producer.get("source_revision"), 40, "candidate producer source revision"
+    )
+    if active.revision != producer_revision:
+        raise StudyError("generated candidate differs from the active source")
+    return {
+        "status": "passed",
+        "policy": "exact-source-revision",
+        "source_revision": producer_revision,
+        "source_tree": active.tree,
+    }
+
+
+def _config(mode: str, layout: str) -> RunConfig:
+    if mode not in {"on-the-fly", "recurrence"}:
+        raise StudyError(f"high-multiplicity harness forbids execution mode {mode!r}")
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc", lc_flow_layout=layout),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            backend="jit",
+            execution_mode=mode,
+            optimization=EvaluatorOptimizationConfig(
+                cores=(
+                    OTF_QUERY_CONSTRUCTION_THREADS
+                    if mode == "on-the-fly"
+                    else RECURRENCE_GENERATION_THREADS
+                )
+            ),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+def _generate_otf(case: Case, path: Path, model: object) -> dict[str, object]:
+    original = generation_service._invoke_rust_on_the_fly_seed_batch_builder_v1
+    seed_calls = seed_count = materialized_calls = 0
+
+    def capture(*args: object, **kwargs: object) -> object:
+        nonlocal seed_calls, seed_count
+        seed_calls += 1
+        projections = n4._on_the_fly_source_projections(args, kwargs)
+        result = original(*args, **kwargs)
+        if not isinstance(result, tuple) or len(result) != len(projections):
+            raise StudyError("OTF seed binding changed the process batch")
+        seed_count += len(result)
+        return result
+
+    def reject(name: str) -> Callable[..., object]:
+        def operation(*_args: object, **_kwargs: object) -> object:
+            nonlocal materialized_calls
+            materialized_calls += 1
+            raise StudyError(f"OTF generation entered materialized lane {name}")
+
+        return operation
+
+    started = time.perf_counter()
+    with ExitStack() as patches:
+        patches.enter_context(
+            mock.patch.object(
+                generation_service,
+                "_invoke_rust_on_the_fly_seed_batch_builder_v1",
+                capture,
+            )
+        )
+        for name, owner, attribute in n4._materialized_process_lane_patch_targets():
+            patches.enter_context(mock.patch.object(owner, attribute, reject(name)))
+        Generator(_config("on-the-fly", "topology-replay")).generate(
+            ProcessRequest.parse(case.process, name=case.process_id), path, model=model
+        )
+    elapsed_seconds = time.perf_counter() - started
+    if (seed_calls, seed_count, materialized_calls) != (1, 1, 0):
+        raise StudyError("OTF generation did not create exactly one compact seed")
+    execution = _read(path / "processes" / case.process_id / "execution.json")
+    runtime_options = execution.get("runtime_options")
+    if (
+        not isinstance(runtime_options, Mapping)
+        or set(runtime_options) != {"point_tile_size", "query_construction_threads"}
+        or runtime_options.get("query_construction_threads")
+        != OTF_QUERY_CONSTRUCTION_THREADS
+    ):
+        raise StudyError("OTF artifact did not authenticate its four-thread budget")
+    return {
+        "seconds": elapsed_seconds,
+        "seed_binding_calls": seed_calls,
+        "seed_count": seed_count,
+        "materialized_lane_calls": materialized_calls,
+        "query_construction_threads": OTF_QUERY_CONSTRUCTION_THREADS,
+        "query_construction_threads_source": (
+            "resolved evaluator.optimization.cores in execution.runtime_options"
+        ),
+    }
+
+
+def _generate_recurrence(case: Case, path: Path, model: object) -> dict[str, object]:
+    started = time.perf_counter()
+    Generator(_config("recurrence", "topology-replay")).generate(
+        ProcessRequest.parse(case.process, name=case.process_id), path, model=model
+    )
+    return {
+        "execution_mode": "recurrence",
+        "layout": "topology-replay",
+        "seconds": time.perf_counter() - started,
+        "generation_threads": RECURRENCE_GENERATION_THREADS,
+        "generation_threads_source": "evaluator.optimization.cores",
+    }
+
+
+def _census(runtime: object, process_id: str) -> dict[str, Any]:
+    inspect_runtime = getattr(runtime, "inspect", None)
+    if not callable(inspect_runtime):
+        raise StudyError("OTF runtime does not expose public inspect()")
+    inspection = inspect_runtime()
+    value = (
+        inspection.get(STATE_INSPECTION_KEY)
+        if isinstance(inspection, Mapping)
+        else None
+    )
+    if not isinstance(value, Mapping):
+        raise StudyError("OTF runtime census is unavailable")
+    result = dict(value)
+    _assert_state_contract(result, "OTF runtime census", process_id=process_id)
+    return result
+
+
+def _assert_cache_contract(value: Mapping[str, object], label: str) -> None:
+    limit = value.get("family_cache_limit")
+    if (
+        value.get("family_cache_policy") != STATE_FAMILY_CACHE_POLICY
+        or isinstance(limit, bool)
+        or not isinstance(limit, int)
+        or limit != STATE_FAMILY_CACHE_LIMIT
+    ):
+        raise StudyError(f"{label} has the wrong last-family-only cache contract")
+
+
+def _assert_state_contract(
+    value: Mapping[str, object],
+    label: str,
+    *,
+    process_id: str | None = None,
+) -> None:
+    if set(value) != STATE_FIELDS:
+        raise StudyError(f"{label} has the wrong field set")
+    actual_process_id = value.get("process_id")
+    if (
+        value.get("kind") != STATE_KIND
+        or not isinstance(actual_process_id, str)
+        or not actual_process_id
+        or (process_id is not None and actual_process_id != process_id)
+    ):
+        raise StudyError(f"{label} has the wrong identity")
+    _assert_cache_contract(value, label)
+    for field in STATE_COUNTS:
+        count = value.get(field)
+        if isinstance(count, bool) or not isinstance(count, int) or count < 0:
+            raise StudyError(f"{label} has invalid {field}")
+    active = value.get("active_family_union_census")
+    if active is not None and not isinstance(active, Mapping):
+        raise StudyError(f"{label} has an invalid active-family census")
+
+
+def _assert_cold(
+    value: Mapping[str, object],
+    label: str,
+    *,
+    process_id: str | None = None,
+) -> None:
+    _assert_state_contract(value, label, process_id=process_id)
+    if (
+        any(value[field] != 0 for field in STATE_COUNTS)
+        or value.get("active_family_union_census") is not None
+    ):
+        raise StudyError(f"{label} retained mutable OTF state")
+
+
+def _active_family_census(value: object, label: str) -> dict[str, object]:
+    if not isinstance(value, Mapping):
+        raise StudyError(f"{label} has no active family-union census")
+    expected_fields = {"basis", "scope", *ACTIVE_COUNT_FIELDS}
+    if set(value) != expected_fields:
+        raise StudyError(f"{label} has the wrong active family-union field set")
+    if (
+        value.get("basis") != "shared-query-family-union-v1"
+        or value.get("scope") != "active-family-union"
+    ):
+        raise StudyError(f"{label} has the wrong active family-union identity")
+    result = dict(value)
+    for field in ACTIVE_COUNT_FIELDS:
+        count = result.get(field)
+        if isinstance(count, bool) or not isinstance(count, int) or count < 0:
+            raise StudyError(f"{label} has invalid active-family {field}")
+    if (
+        result["query_count"] < 1
+        or result["union_unique_current_count"]
+        > result["union_unique_current_component_count"]
+        or result["union_amplitude_destination_count"] < 1
+        or result["union_amplitude_destination_count"] > result["query_count"]
+    ):
+        raise StudyError(f"{label} has inconsistent active-family dimensions")
+    for role in OPERATION_ROLES:
+        if result[f"union_{role}_executor_call_groups"] > result[f"union_{role}_rows"]:
+            raise StudyError(f"{label} has more {role} call groups than rows")
+    return result
+
+
+def _assert_family_state(
+    value: Mapping[str, object],
+    label: str,
+    *,
+    process_id: str | None = None,
+) -> dict[str, object]:
+    _assert_state_contract(value, label, process_id=process_id)
+    if (
+        value["process_preparation_count"] != 1
+        or value["retained_family_count"] != STATE_FAMILY_CACHE_LIMIT
+        or value["retained_selection_count"] != STATE_FAMILY_CACHE_LIMIT
+        or value["retained_executor_handle_count"] != STATE_FAMILY_CACHE_LIMIT
+        or value["semantic_executor_binding_count"] < 1
+        or any(value[field] != 0 for field in COMPACT_ZERO_COUNTS)
+        or value["retained_request_count"] < 1
+        or value["retained_amplitude_destination_count"] < 1
+        or value["retained_amplitude_destination_count"]
+        > value["retained_request_count"]
+    ):
+        raise StudyError(f"{label} has an invalid compact retained-state census")
+    active = _active_family_census(value.get("active_family_union_census"), label)
+    if (
+        active["query_count"] > value["retained_request_count"]
+        or active["union_amplitude_destination_count"]
+        > value["retained_amplitude_destination_count"]
+    ):
+        raise StudyError(f"{label} active family exceeds retained requests")
+    return active
+
+
+def _failed_candidate_preserves_retained_family(
+    runtime: object,
+    case: Case,
+    selector: Selector,
+    candidate_workload: str,
+    retained: Mapping[str, object],
+) -> dict[str, object]:
+    """Prove a zero-point cold candidate cannot evict the retained family."""
+
+    kwargs = _selector_kwargs(candidate_workload, selector)
+    message: str
+    try:
+        runtime.evaluate((), **kwargs)
+    except EvaluationError as error:
+        message = str(error)
+        if "requires at least one point" not in message:
+            raise StudyError(
+                "failed OTF candidate did not reach zero-point execution"
+            ) from error
+    else:
+        raise StudyError("zero-point OTF candidate unexpectedly succeeded")
+    after = _census(runtime, case.process_id)
+    if after != retained:
+        raise StudyError("failed OTF candidate changed the retained family")
+    return {
+        "status": "passed",
+        "candidate_workload": candidate_workload,
+        "point_count": 0,
+        "failure": message,
+        "retained_family_after_failure": after,
+    }
+
+
+def _selector_kwargs(workload: str, selector: Selector) -> dict[str, tuple[str, ...]]:
+    if workload == "selected":
+        return {"color_flows": (selector.flow_id,)}
+    if workload == "all-flow":
+        return {"helicities": (selector.helicity_id,)}
+    if workload == "exact":
+        return {
+            "color_flows": (selector.flow_id,),
+            "helicities": (selector.helicity_id,),
+        }
+    raise StudyError(f"unknown study workload {workload!r}")
+
+
+def _evaluate(
+    runtime: object,
+    points: Points,
+    workload: str,
+    selector: Selector,
+    *,
+    resolved: bool,
+    _precomputed_total: tuple[object, ...] | None = None,
+) -> Evaluation:
+    kwargs = _selector_kwargs(workload, selector)
+    total = (
+        tuple(runtime.evaluate(points, **kwargs))
+        if _precomputed_total is None
+        else _precomputed_total
+    )
+    detail = runtime.evaluate_resolved(points, **kwargs) if resolved else None
+    total_vs_resolved = None
+    if len(total) != len(points):
+        raise StudyError("runtime returned the wrong point count")
+    if detail is not None:
+        axes = (
+            (("color_ids", (selector.flow_id,)),)
+            if workload == "selected"
+            else (("helicity_ids", (selector.helicity_id,)),)
+            if workload == "all-flow"
+            else (
+                ("color_ids", (selector.flow_id,)),
+                ("helicity_ids", (selector.helicity_id,)),
+            )
+        )
+        if any(tuple(getattr(detail, axis, ())) != expected for axis, expected in axes):
+            raise StudyError("resolved output changed the public selector ID")
+        resolved_total = getattr(detail, "total", None)
+        if not callable(resolved_total):
+            raise StudyError("resolved output omitted its public total")
+        try:
+            total_vs_resolved = n4._series(
+                total,
+                tuple(resolved_total()),
+                f"{workload} public total/resolved total",
+            )
+        except n4.GateError as error:
+            raise StudyError(str(error)) from error
+    return Evaluation(total, detail, total_vs_resolved)
+
+
+def _first_selected_evaluation(
+    runtime: object,
+    points: Points,
+    selector: Selector,
+    requested_workload: str,
+    *,
+    resolved: bool,
+) -> Evaluation:
+    """Build selected family A for lifecycle checks without timing it."""
+
+    if not points:
+        raise StudyError("selected lifecycle evaluation requires at least one point")
+    kwargs = _selector_kwargs("selected", selector)
+    total = tuple(runtime.evaluate(points, **kwargs))
+    return _evaluate(
+        runtime,
+        points,
+        "selected",
+        selector,
+        resolved=resolved and requested_workload == "selected",
+        _precomputed_total=total,
+    )
+
+
+def _requested_workload_cold_warmup(
+    runtime: object,
+    case: Case,
+    selector: Selector,
+    points: Points,
+    workload: str,
+    *,
+    ratio_eligible: bool,
+    retain_family: bool = False,
+) -> dict[str, object]:
+    """Time one requested-workload call on a cold 128xseed-101 batch."""
+
+    cold = _census(runtime, case.process_id)
+    _assert_cold(cold, "requested-workload warm-up cold runtime")
+    batch = _timing_points(points)
+    kwargs = _selector_kwargs(workload, selector)
+    started_ns = time.perf_counter_ns()
+    total = tuple(runtime.evaluate(batch, **kwargs))
+    elapsed_ns = time.perf_counter_ns() - started_ns
+    if elapsed_ns < 0 or len(total) != BATCH_SIZE:
+        raise StudyError("requested-workload cold warm-up returned invalid evidence")
+    warmed = _census(runtime, case.process_id)
+    active = _assert_family_state(warmed, f"cold {workload} warm-up")
+    cleared = None
+    if not retain_family:
+        runtime.clear()
+        cleared = _census(runtime, case.process_id)
+        _assert_cold(cleared, "requested-workload warm-up clear")
+    seconds = elapsed_ns / 1_000_000_000.0
+    return {
+        "kind": REQUESTED_COLD_WARMUP_KIND,
+        "timer": "time.perf_counter_ns",
+        "runtime_state": "census-proven-cold",
+        "requested_workload": workload,
+        "batch_size": BATCH_SIZE,
+        "point_count": len(batch),
+        "seed": SEEDS[0],
+        "singleton_seed_point_digest": point_digest((points[0],)),
+        "batch_point_policy": "seed-101 correctness point 0 repeated 128 times",
+        "elapsed_nanoseconds": elapsed_ns,
+        "seconds": seconds,
+        "seconds_per_point": seconds / BATCH_SIZE,
+        "output_count": len(total),
+        "before": cold,
+        "after_first_evaluation": warmed,
+        "active_family_union_census": active,
+        "after_clear": cleared,
+        "clear_call_status": (
+            "omitted-retained-for-lean-lifecycle"
+            if retain_family
+            else "performed-for-exhaustive-lifecycle"
+        ),
+        "clear_restored_cold_state": None if retain_family else True,
+        "retained_for_followup": retain_family,
+        "excluded_from_elapsed": [
+            "Runtime.load",
+            "artifact generation",
+            "resolved-output follow-up",
+            "correctness lifecycle",
+            "warmed BenchmarkRunner",
+        ],
+        "ratio_eligible": ratio_eligible,
+        "generation_pair_eligible": True,
+        "acceptance_eligible": False,
+        "query_construction_threads": OTF_QUERY_CONSTRUCTION_THREADS,
+        "query_construction_threads_source": (
+            "authenticated execution.runtime_options"
+        ),
+    }
+
+
+def _compare(left: Evaluation, right: Evaluation, label: str) -> dict[str, object]:
+    try:
+        return {
+            "total": n4._series(left.total, right.total, f"{label} total"),
+            "resolved": (
+                None
+                if left.resolved is None or right.resolved is None
+                else n4._resolved_component_checks(
+                    left.resolved, right.resolved, f"{label} resolved"
+                )
+            ),
+        }
+    except n4.GateError as error:
+        raise StudyError(str(error)) from error
+
+
+def _amplicol_singleton_check(
+    evaluation: Evaluation,
+    reference: AmplicolReference,
+    points: Points,
+) -> dict[str, object]:
+    if not evaluation.total or not points:
+        raise StudyError("AmpliCol singleton comparison has no seed-101 result")
+    try:
+        comparison = n4._series(
+            (evaluation.total[0],),
+            (reference.matrix_element,),
+            "OTF seed-101/AmpliCol stored matrix_element",
+            n4.AMPICOL_REL_TOL,
+        )
+    except n4.GateError as error:
+        raise StudyError(str(error)) from error
+    return {
+        "status": "passed",
+        "seed": SEEDS[0],
+        "point_count": 1,
+        "point_digest": point_digest((points[0],)),
+        "stored_amplicol_matrix_element": reference.matrix_element,
+        "otf_matrix_element": float(complex(evaluation.total[0]).real),
+        "comparison": comparison,
+    }
+
+
+def _amplicol_series(
+    candidate: Sequence[object],
+    reference: Sequence[object],
+    label: str,
+) -> dict[str, object]:
+    try:
+        return n4._series(candidate, reference, label, n4.AMPICOL_REL_TOL)
+    except n4.GateError as error:
+        raise StudyError(str(error)) from error
+
+
+def _replay_amplicol(
+    reference: AmplicolReference,
+    case: Case,
+    points: Points,
+) -> tuple[tuple[float, ...], dict[str, object]]:
+    """Replay the immutable selected-flow library at every correctness point."""
+
+    library = reference.library_path
+    process_row = reference.process_row
+    if library is None or process_row is None:
+        raise StudyError("AmpliCol reference omitted replayable library evidence")
+    try:
+        entries = legacy_amplicol.parse_process_file(library / "processes.txt")
+        matches = tuple(
+            entry
+            for entry in entries
+            if (int(entry.group), int(entry.integral)) == process_row
+        )
+        if len(matches) != 1:
+            raise StudyError("AmpliCol generated-library process row is not unique")
+        entry = matches[0]
+        mapped = legacy_amplicol.source_mapped_color_order(
+            entry,
+            source_pdgs=case.pdgs,
+        )
+        replay_word = _canonical_mapped_color_word(
+            case.pdgs,
+            mapped,
+            initial_state_count=_initial_state_count(case.process),
+        )
+        if replay_word != reference.selector.flow_word:
+            raise StudyError("AmpliCol replay row differs from its selector contract")
+        root = str(library.resolve(strict=True))
+        environment: dict[str, str] = {}
+        for name in ("LD_LIBRARY_PATH", "DYLD_LIBRARY_PATH"):
+            existing = os.environ.get(name)
+            environment[name] = (
+                root if not existing else f"{root}{os.pathsep}{existing}"
+            )
+        values: list[float] = []
+        with mock.patch.dict(os.environ, environment):
+            for point in points:
+                probe = legacy_amplicol.run_selected_flow_library_probe(
+                    library,
+                    entry=entry,
+                    source_pdgs=case.pdgs,
+                    momenta=point,
+                    helicities=None,
+                    points=1,
+                )
+                emitted_entry = replace(
+                    entry,
+                    process_pdgs=tuple(probe.process_pdgs),
+                    color_order=tuple(probe.color_order),
+                )
+                emitted_mapped = legacy_amplicol.source_mapped_color_order(
+                    emitted_entry,
+                    source_pdgs=case.pdgs,
+                )
+                emitted_word = _canonical_mapped_color_word(
+                    case.pdgs,
+                    emitted_mapped,
+                    initial_state_count=_initial_state_count(case.process),
+                )
+                if emitted_word != reference.selector.flow_word:
+                    raise StudyError(
+                        "AmpliCol replay emitted a different semantic selector flow"
+                    )
+                values.append(float(probe.value))
+    except (LegacyAdapterError, legacy_amplicol.LegacyOracleError, OSError) as error:
+        raise StudyError(
+            f"AmpliCol generated-library replay failed: {error}"
+        ) from error
+    replayed = tuple(values)
+    if len(replayed) != len(points):
+        raise StudyError("AmpliCol generated-library replay has the wrong point axis")
+    stored_check = _amplicol_series(
+        replayed[:1],
+        (reference.matrix_element,),
+        "AmpliCol replay seed-101/stored matrix_element",
+    )
+    return replayed, {
+        "status": "passed",
+        "source": "authenticated-selected-flow-generated-library-snapshot",
+        "library_path": str(library),
+        "process_row": {"group": process_row[0], "integral": process_row[1]},
+        "selector_flow_id": reference.selector.flow_id,
+        "point_count": len(points),
+        "point_digest": point_digest(points),
+        "seeds": list(SEEDS),
+        "helicity_policy": "sum-all-helicities",
+        "subprocess_launches": len(points),
+        "seed101_replay_vs_stored_matrix_element": stored_check,
+    }
+
+
+def _lifecycle(
+    runtime: object,
+    case: Case,
+    selector: Selector,
+    points: Points,
+    workload: str,
+    resolved: bool,
+) -> tuple[Evaluation, Evaluation, dict[str, object]]:
+    policy = _lifecycle_policy(case, workload)
+    if policy["mode"] == LIFECYCLE_LEAN:
+        retained = _census(runtime, case.process_id)
+        _assert_family_state(retained, "retained requested family")
+        headline = _evaluate(runtime, points, workload, selector, resolved=resolved)
+        headline_census = _census(runtime, case.process_id)
+        if headline_census != retained:
+            raise StudyError(
+                "8-point headline evaluation did not reuse retained family"
+            )
+        repeat_points = points[:1]
+        repeated = _evaluate(runtime, repeat_points, workload, selector, resolved=False)
+        repeated_census = _census(runtime, case.process_id)
+        if repeated_census != headline_census:
+            raise StudyError("retained-family seed-101 repeat did not plateau")
+        repeat_comparison = _compare(
+            repeated,
+            Evaluation(headline.total[:1], None),
+            "retained-family seed-101 repeat",
+        )
+        return (
+            headline,
+            headline,
+            {
+                "policy": policy,
+                "retained_requested_family": retained,
+                "requested_family": headline_census,
+                "requested_repeat": repeated_census,
+                "headline_point_count": len(points),
+                "headline_seeds": list(SEEDS),
+                "plateau_repeat_point_count": len(repeat_points),
+                "plateau_repeat_seed": SEEDS[0],
+                "plateau_repeat_self_consistency": repeat_comparison,
+                "clear_rebuild": _clear_rebuild_evidence(policy),
+                "final_plateau": repeated_census,
+                "sequence": (
+                    "retained requested family; 8-point headline; "
+                    "seed-101 plateau repeat"
+                ),
+            },
+        )
+
+    cold = _census(runtime, case.process_id)
+    _assert_cold(cold, "cold runtime")
+    selected_a = _first_selected_evaluation(
+        runtime,
+        points,
+        selector,
+        workload,
+        resolved=resolved,
+    )
+    census_a = _census(runtime, case.process_id)
+    _assert_family_state(census_a, "selected A")
+    if workload == "selected":
+        exact_c = _evaluate(runtime, points, "exact", selector, resolved=False)
+        census_c = _census(runtime, case.process_id)
+        _assert_family_state(census_c, "exact-selector C")
+        repeated = _evaluate(runtime, points, "exact", selector, resolved=False)
+        repeated_census = _census(runtime, case.process_id)
+        if repeated_census != census_c:
+            raise StudyError("repeated exact-selector C did not plateau")
+        _compare(repeated, exact_c, "exact-selector C repeat")
+        failed_candidate = _failed_candidate_preserves_retained_family(
+            runtime,
+            case,
+            selector,
+            "selected",
+            census_c,
+        )
+        selected_revisit = _evaluate(
+            runtime, points, "selected", selector, resolved=False
+        )
+        revisit = _census(runtime, case.process_id)
+        _assert_family_state(revisit, "selected A cold rebuild")
+        if revisit != census_a:
+            raise StudyError("selected A cold rebuild did not evict C exactly")
+        _compare(selected_revisit, selected_a, "selected A revisit")
+        selected_revisit_repeat = _evaluate(
+            runtime, points, "selected", selector, resolved=False
+        )
+        revisit_repeat = _census(runtime, case.process_id)
+        if revisit_repeat != revisit:
+            raise StudyError("immediate selected A repeat was not warm")
+        _compare(
+            selected_revisit_repeat,
+            selected_revisit,
+            "selected A immediate warm repeat",
+        )
+
+        runtime.clear()
+        cleared = _census(runtime, case.process_id)
+        _assert_cold(cleared, "Runtime.clear()")
+        rebuilt = _evaluate(runtime, points, "selected", selector, resolved=resolved)
+        rebuilt_a_census = _census(runtime, case.process_id)
+        if rebuilt_a_census != census_a:
+            raise StudyError("post-clear selected A did not rebuild exactly")
+        _evaluate(runtime, points, "exact", selector, resolved=False)
+        rebuilt_c_census = _census(runtime, case.process_id)
+        if rebuilt_c_census != census_c:
+            raise StudyError("post-clear exact-selector C did not rebuild exactly")
+        rebuilt_revisit = _evaluate(
+            runtime, points, "selected", selector, resolved=False
+        )
+        rebuilt_revisit_census = _census(runtime, case.process_id)
+        if rebuilt_revisit_census != census_a:
+            raise StudyError("post-clear selected A revisit did not evict C exactly")
+        _compare(rebuilt_revisit, rebuilt, "post-clear selected A revisit")
+        rebuilt_repeat = _evaluate(
+            runtime, points, "selected", selector, resolved=False
+        )
+        rebuilt_census = _census(runtime, case.process_id)
+        if rebuilt_census != rebuilt_revisit_census:
+            raise StudyError("post-clear selected A immediate repeat was not warm")
+        _compare(
+            rebuilt_repeat,
+            rebuilt_revisit,
+            "post-clear selected A immediate warm repeat",
+        )
+        _compare(rebuilt, selected_a, "post-clear selected A headline")
+        return (
+            selected_a,
+            rebuilt,
+            {
+                "cold": cold,
+                "selected_a": census_a,
+                "requested_family": census_c,
+                "requested_repeat": repeated_census,
+                "failed_selected_a_candidate": failed_candidate,
+                "selected_a_revisit": revisit,
+                "selected_a_revisit_repeat": revisit_repeat,
+                "after_clear": cleared,
+                "after_rebuild_selected_a": rebuilt_a_census,
+                "after_rebuild_exact_c": rebuilt_c_census,
+                "after_rebuild_selected_a_revisit": rebuilt_revisit_census,
+                "after_rebuild_selected_a_repeat": rebuilt_census,
+                "after_rebuild": rebuilt_census,
+                "final_plateau": rebuilt_census,
+                "policy": policy,
+                "clear_rebuild": _clear_rebuild_evidence(policy),
+                "sequence": "A,C,C,failed-A,C,A,A; clear; A,C,A,A",
+            },
+        )
+
+    first = _evaluate(runtime, points, "all-flow", selector, resolved=resolved)
+    target_census = _census(runtime, case.process_id)
+    _assert_family_state(target_census, "all-flow B")
+    repeated = _evaluate(runtime, points, "all-flow", selector, resolved=resolved)
+    repeated_census = _census(runtime, case.process_id)
+    if repeated_census != target_census:
+        raise StudyError("repeated all-flow B did not plateau")
+    _compare(repeated, first, "all-flow B repeat")
+    failed_candidate = _failed_candidate_preserves_retained_family(
+        runtime,
+        case,
+        selector,
+        "selected",
+        target_census,
+    )
+    selected_revisit = _evaluate(runtime, points, "selected", selector, resolved=False)
+    revisit = _census(runtime, case.process_id)
+    _assert_family_state(revisit, "selected A cold rebuild")
+    if revisit != census_a:
+        raise StudyError("selected A cold rebuild did not evict B exactly")
+    _compare(selected_revisit, selected_a, "selected A revisit")
+    selected_revisit_repeat = _evaluate(
+        runtime, points, "selected", selector, resolved=False
+    )
+    revisit_repeat = _census(runtime, case.process_id)
+    if revisit_repeat != revisit:
+        raise StudyError("immediate selected A repeat was not warm")
+    _compare(
+        selected_revisit_repeat,
+        selected_revisit,
+        "selected A immediate warm repeat",
+    )
+
+    runtime.clear()
+    cleared = _census(runtime, case.process_id)
+    _assert_cold(cleared, "Runtime.clear()")
+    _evaluate(runtime, points, "selected", selector, resolved=False)
+    rebuilt = _evaluate(runtime, points, "all-flow", selector, resolved=resolved)
+    rebuilt_census = _census(runtime, case.process_id)
+    if rebuilt_census != target_census:
+        raise StudyError("post-clear all-flow B did not rebuild exactly")
+    _compare(rebuilt, first, "post-clear all-flow B")
+    return (
+        first,
+        rebuilt,
+        {
+            "cold": cold,
+            "selected_a": census_a,
+            "requested_family": target_census,
+            "requested_repeat": repeated_census,
+            "failed_selected_a_candidate": failed_candidate,
+            "selected_a_revisit": revisit,
+            "selected_a_revisit_repeat": revisit_repeat,
+            "after_clear": cleared,
+            "after_rebuild": rebuilt_census,
+            "final_plateau": rebuilt_census,
+            "policy": policy,
+            "clear_rebuild": _clear_rebuild_evidence(policy),
+            "sequence": "A,B,B,failed-A,B,A,A; clear; A,B",
+        },
+    )
+
+
+def _recurrence_authority_contract(
+    case: Case,
+    recurrence: object,
+    points: Points,
+) -> tuple[Selector, SelectorContract, dict[str, object]]:
+    if getattr(recurrence, "execution_mode", None) != "recurrence":
+        raise StudyError("recurrence authority has the wrong execution mode")
+    try:
+        contract = derive_selector_contract(recurrence, points)
+        validate_selector_contract(recurrence, contract, points)
+    except RunnerError as error:
+        raise StudyError(str(error)) from error
+    return _selector_from_contract(case, contract), contract, contract.as_dict()
+
+
+def _cross_check_compact_selector(
+    runtime: object,
+    case: Case,
+    selector: Selector,
+    *,
+    require_ordinal_one: bool,
+) -> dict[str, object]:
+    requested = (selector.flow_id, "1") if require_ordinal_one else (selector.flow_id,)
+    context = _compact_selector_context(runtime, case, requested)
+    selected = context["selected_color_ids"]
+    if (
+        selected != [selector.flow_id] * len(requested)
+        or _flow_word(selector.flow_id) != selector.flow_word
+    ):
+        source = " and compact ordinal 1" if require_ordinal_one else ""
+        raise StudyError(f"candidate compact selector differs from authority{source}")
+    context["semantic_authority_flow_id"] = selector.flow_id
+    context["ordinal_one_required"] = require_ordinal_one
+    context["ordinal_one_matches_authority"] = True if require_ordinal_one else None
+    return context
+
+
+def _benchmark(
+    runtime: object,
+    mode: str,
+    points: Points,
+    workload: str,
+    selector: Selector,
+    target: float,
+) -> dict[str, object]:
+    kwargs = _selector_kwargs(workload, selector)
+    config = n4._benchmark_config(
+        target,
+        BATCH_SIZE,
+        helicities=kwargs.get("helicities", ()),
+        flows=kwargs.get("color_flows", ()),
+    )
+    result = BenchmarkRunner(config).run(runtime, points=_timing_points(points))
+    effective = result.effective_config
+    if result.interrupted:
+        raise StudyError("benchmark was interrupted")
+    if (
+        effective.target_runtime != target
+        or effective.precision != 16
+        or effective.batch_size != BATCH_SIZE
+        or effective.warmup_runs != WARMUP_RUNS
+        or effective.minimum_samples < MINIMUM_SAMPLES
+        or result.sample_count < MINIMUM_SAMPLES
+        or tuple(effective.helicity_ids) != tuple(config.helicity_ids)
+        or tuple(effective.color_flow_ids) != tuple(config.color_flow_ids)
+    ):
+        raise StudyError("benchmark did not satisfy the effective timing contract")
+    try:
+        timing = n4._public_timing(result, mode)
+    except n4.GateError as error:
+        raise StudyError(str(error)) from error
+    timing["simd"] = {
+        "status": "not-proven",
+        "reason": "native executed-block telemetry is absent",
+    }
+    return timing
+
+
+def _selected_report_lineage(
+    path: Path,
+    case: Case,
+    candidate: Mapping[str, object],
+    active_source: ReportSourceIdentity,
+) -> dict[str, object]:
+    outer = _read(path)
+    selected = outer.get("study")
+    if (
+        outer.get("kind") != f"{KIND}-run"
+        or outer.get("schema_version") != SCHEMA_VERSION
+        or outer.get("status") != "passed"
+        or not isinstance(selected, Mapping)
+        or selected.get("kind") != KIND
+        or selected.get("schema_version") != SCHEMA_VERSION
+        or selected.get("status") != "passed"
+        or selected.get("workload") != "selected"
+        or selected.get("process") != dataclass_payload(case)
+    ):
+        raise StudyError("selected report has the wrong study identity")
+    expected_authority = _authority_kind(case, "selected")
+    authority = selected.get("authority")
+    correctness = selected.get("correctness")
+    compact = selected.get("compact_selector_context")
+    lifecycle_policy = selected.get("lifecycle_policy")
+    cache_lifecycle = selected.get("cache_lifecycle")
+    requested_cold_warmup = selected.get("requested_workload_cold_warmup")
+    expected_lifecycle_policy = _lifecycle_policy(case, "selected")
+    candidate_source_binding = selected.get("candidate_source_binding")
+    expected_producer = candidate.get("producer_identity")
+    expected_model = candidate.get("model_identity")
+    if (
+        not isinstance(authority, Mapping)
+        or authority.get("kind") != expected_authority
+        or not isinstance(correctness, Mapping)
+        or not isinstance(compact, Mapping)
+        or lifecycle_policy != expected_lifecycle_policy
+        or not isinstance(cache_lifecycle, Mapping)
+        or cache_lifecycle.get("policy") != expected_lifecycle_policy
+        or not isinstance(candidate_source_binding, Mapping)
+        or not isinstance(expected_producer, Mapping)
+        or not isinstance(expected_model, Mapping)
+        or selected.get("producer_identity") != dict(expected_producer)
+        or selected.get("model_identity") != dict(expected_model)
+        or selected.get("active_source") != active_source.provenance()
+        or candidate_source_binding
+        != _candidate_source_binding(active_source, expected_producer)
+    ):
+        raise StudyError("selected report omitted its authority/source lineage")
+    if (
+        not isinstance(requested_cold_warmup, Mapping)
+        or requested_cold_warmup.get("query_construction_threads")
+        != OTF_QUERY_CONSTRUCTION_THREADS
+    ):
+        raise StudyError("selected report omitted its warm-up thread contract")
+    lean_lifecycle = expected_lifecycle_policy["mode"] == LIFECYCLE_LEAN
+    self_consistency_key = (
+        "retained_family_plateau_self_consistency"
+        if lean_lifecycle
+        else "pre_post_clear_self_consistency"
+    )
+    self_consistency = correctness.get(self_consistency_key)
+    expected_self_consistency_checks = 1 if lean_lifecycle else len(SEEDS)
+    self_consistency_valid = (
+        isinstance(self_consistency, Mapping)
+        and isinstance(self_consistency.get("total"), Mapping)
+        and self_consistency["total"].get("checks") == expected_self_consistency_checks
+    )
+    if lean_lifecycle:
+        retained_requested_family = cache_lifecycle.get("retained_requested_family")
+        retained_state_valid = False
+        if isinstance(retained_requested_family, Mapping):
+            try:
+                _assert_family_state(
+                    retained_requested_family,
+                    "selected report retained requested family",
+                    process_id=case.process_id,
+                )
+            except StudyError:
+                pass
+            else:
+                retained_state_valid = True
+        lifecycle_valid = (
+            cache_lifecycle.get("headline_point_count") == len(SEEDS)
+            and cache_lifecycle.get("headline_seeds") == list(SEEDS)
+            and cache_lifecycle.get("plateau_repeat_point_count") == 1
+            and cache_lifecycle.get("final_plateau") == retained_requested_family
+            and cache_lifecycle.get("clear_rebuild")
+            == _clear_rebuild_evidence(expected_lifecycle_policy)
+            and retained_state_valid
+            and isinstance(requested_cold_warmup, Mapping)
+            and requested_cold_warmup.get("kind") == REQUESTED_COLD_WARMUP_KIND
+            and requested_cold_warmup.get("requested_workload") == "selected"
+            and requested_cold_warmup.get("batch_size") == BATCH_SIZE
+            and requested_cold_warmup.get("point_count") == BATCH_SIZE
+            and requested_cold_warmup.get("query_construction_threads")
+            == OTF_QUERY_CONSTRUCTION_THREADS
+            and requested_cold_warmup.get("retained_for_followup") is True
+            and requested_cold_warmup.get("clear_call_status")
+            == "omitted-retained-for-lean-lifecycle"
+            and requested_cold_warmup.get("after_clear") is None
+            and requested_cold_warmup.get("after_first_evaluation")
+            == retained_requested_family
+        )
+    else:
+        final_plateau = cache_lifecycle.get("final_plateau")
+        after_clear = cache_lifecycle.get("after_clear")
+        selected_a_state = cache_lifecycle.get("selected_a")
+        requested_family = cache_lifecycle.get("requested_family")
+        lifecycle_state_valid = False
+        if (
+            isinstance(final_plateau, Mapping)
+            and isinstance(after_clear, Mapping)
+            and isinstance(selected_a_state, Mapping)
+            and isinstance(requested_family, Mapping)
+        ):
+            try:
+                _assert_family_state(
+                    final_plateau,
+                    "selected report final family plateau",
+                    process_id=case.process_id,
+                )
+                _assert_family_state(
+                    selected_a_state,
+                    "selected report selected A family",
+                    process_id=case.process_id,
+                )
+                _assert_family_state(
+                    requested_family,
+                    "selected report exact-selector C family",
+                    process_id=case.process_id,
+                )
+                _assert_cold(
+                    after_clear,
+                    "selected report post-clear state",
+                    process_id=case.process_id,
+                )
+            except StudyError:
+                pass
+            else:
+                lifecycle_state_valid = True
+        failed_candidate = cache_lifecycle.get("failed_selected_a_candidate")
+        lifecycle_valid = (
+            lifecycle_state_valid
+            and cache_lifecycle.get("clear_rebuild")
+            == _clear_rebuild_evidence(expected_lifecycle_policy)
+            and cache_lifecycle.get("sequence")
+            == "A,C,C,failed-A,C,A,A; clear; A,C,A,A"
+            and cache_lifecycle.get("requested_repeat") == requested_family
+            and cache_lifecycle.get("selected_a_revisit") == selected_a_state
+            and cache_lifecycle.get("selected_a_revisit_repeat") == selected_a_state
+            and cache_lifecycle.get("after_rebuild_selected_a") == selected_a_state
+            and cache_lifecycle.get("after_rebuild_exact_c") == requested_family
+            and cache_lifecycle.get("after_rebuild_selected_a_revisit")
+            == selected_a_state
+            and cache_lifecycle.get("after_rebuild_selected_a_repeat")
+            == selected_a_state
+            and final_plateau == selected_a_state
+            and isinstance(failed_candidate, Mapping)
+            and failed_candidate.get("status") == "passed"
+            and failed_candidate.get("candidate_workload") == "selected"
+            and failed_candidate.get("point_count") == 0
+            and failed_candidate.get("retained_family_after_failure")
+            == requested_family
+        )
+    if expected_authority == AUTHORITY_OTF_ONLY:
+        correctness_valid = (
+            correctness.get("status") == "not-claimed"
+            and self_consistency_valid
+            and lifecycle_valid
+        )
+        compact_valid = compact.get(
+            "selector_source"
+        ) == "compact-seed-one-based-color-ordinal-1" and compact.get(
+            "requested_color_ids"
+        ) == ["1"]
+    else:
+        if lean_lifecycle:
+            before_key = (
+                "otf_retained_vs_amplicol_replay"
+                if expected_authority == AUTHORITY_AMPLICOL
+                else "otf_retained_vs_recurrence"
+            )
+            after_key = None
+        else:
+            before_key, after_key = (
+                ("otf_before_vs_amplicol_replay", "otf_after_vs_amplicol_replay")
+                if expected_authority == AUTHORITY_AMPLICOL
+                else ("otf_before_vs_recurrence", "otf_after_vs_recurrence")
+            )
+        before_comparison = correctness.get(before_key)
+        after_comparison = None if after_key is None else correctness.get(after_key)
+        if expected_authority == AUTHORITY_AMPLICOL:
+            authority_checks_valid = (
+                isinstance(before_comparison, Mapping)
+                and before_comparison.get("checks") == len(SEEDS)
+                and (
+                    lean_lifecycle
+                    or (
+                        isinstance(after_comparison, Mapping)
+                        and after_comparison.get("checks") == len(SEEDS)
+                    )
+                )
+            )
+        else:
+            authority_checks_valid = (
+                isinstance(before_comparison, Mapping)
+                and isinstance(before_comparison.get("total"), Mapping)
+                and before_comparison["total"].get("checks") == len(SEEDS)
+                and (
+                    lean_lifecycle
+                    or (
+                        isinstance(after_comparison, Mapping)
+                        and isinstance(after_comparison.get("total"), Mapping)
+                        and after_comparison["total"].get("checks") == len(SEEDS)
+                    )
+                )
+            )
+        correctness_valid = (
+            correctness.get("status") == "passed"
+            and authority_checks_valid
+            and self_consistency_valid
+            and lifecycle_valid
+        )
+        compact_valid = (
+            compact.get("ordinal_one_required") is False
+            and compact.get("ordinal_one_matches_authority") is None
+        )
+    if not correctness_valid or not compact_valid:
+        raise StudyError("selected report omitted its correctness/selector proof")
+    watchdog = outer.get("watchdog")
+    if (
+        not isinstance(watchdog, Mapping)
+        or watchdog.get("passes") is not True
+        or watchdog.get("limit_bytes") != WATCHDOG_BYTES
+    ):
+        raise StudyError("selected report omitted its 30 GiB watchdog proof")
+    generation = selected.get("generation")
+    on_the_fly = (
+        generation.get("on_the_fly") if isinstance(generation, Mapping) else None
+    )
+    if (
+        not isinstance(on_the_fly, Mapping)
+        or on_the_fly.get("seed_binding_calls") != 1
+        or on_the_fly.get("seed_count") != 1
+        or on_the_fly.get("materialized_lane_calls") != 0
+        or on_the_fly.get("query_construction_threads")
+        != OTF_QUERY_CONSTRUCTION_THREADS
+    ):
+        raise StudyError("selected report does not prove one compact OTF seed")
+    timing_contract = selected.get("timing_contract")
+    if (
+        not isinstance(timing_contract, Mapping)
+        or timing_contract.get("on_the_fly_query_construction_threads")
+        != OTF_QUERY_CONSTRUCTION_THREADS
+        or timing_contract.get("recurrence_generation_threads")
+        != RECURRENCE_GENERATION_THREADS
+    ):
+        raise StudyError("selected report omitted its bounded thread contract")
+    raw_contract = selected.get("selector_contract")
+    if not isinstance(raw_contract, Mapping):
+        raise StudyError("selected report omitted its selector contract")
+    try:
+        selected_contract = SelectorContract.from_mapping(raw_contract).as_dict()
+    except (TypeError, ValueError) as error:
+        raise StudyError("selected report selector contract is invalid") from error
+    selected_flow_ids = selected_contract["selected_color_flow_ids"]
+    if not isinstance(selected_flow_ids, list) or len(selected_flow_ids) != 1:
+        raise StudyError("selected report selector contract has the wrong flow axis")
+    selected_flow_id = selected_flow_ids[0]
+    if expected_authority == AUTHORITY_OTF_ONLY:
+        compact_contract_valid = (
+            compact.get("requested_color_ids") == ["1"]
+            and compact.get("selected_color_ids") == [selected_flow_id]
+            and compact.get("resolved_semantic_flow_id") == selected_flow_id
+        )
+    else:
+        compact_contract_valid = (
+            compact.get("requested_color_ids") == [selected_flow_id]
+            and compact.get("selected_color_ids") == [selected_flow_id]
+            and compact.get("semantic_authority_flow_id") == selected_flow_id
+        )
+    if not compact_contract_valid:
+        raise StudyError("selected report selector contract and compact proof disagree")
+    artifacts = selected.get("artifacts")
+    recorded = artifacts.get("candidate") if isinstance(artifacts, Mapping) else None
+    recorded_path = recorded.get("path") if isinstance(recorded, Mapping) else None
+    current_path = candidate.get("path")
+    if not isinstance(recorded_path, str) or not isinstance(current_path, str):
+        raise StudyError("selected report omitted the candidate artifact path")
+    try:
+        canonical = str(Path(recorded_path).expanduser().resolve(strict=True))
+    except OSError as error:
+        raise StudyError("selected report candidate artifact is unavailable") from error
+    if (
+        recorded_path != canonical
+        or current_path != canonical
+        or recorded.get("artifact_id") != candidate.get("artifact_id")
+    ):
+        raise StudyError("selected report and --candidate-artifact disagree")
+    generation_seconds = on_the_fly.get("seconds")
+    if (
+        isinstance(generation_seconds, bool)
+        or not isinstance(generation_seconds, (int, float))
+        or not math.isfinite(float(generation_seconds))
+        or float(generation_seconds) <= 0.0
+    ):
+        raise StudyError("selected report omitted OTF generation timing")
+    return {
+        "path": str(path.expanduser().resolve(strict=True)),
+        "kind": outer["kind"],
+        "status": "passed",
+        "candidate_path": canonical,
+        "candidate_artifact_id": candidate["artifact_id"],
+        "selected_authority_kind": expected_authority,
+        "producer_identity": dict(expected_producer),
+        "model_identity": dict(expected_model),
+        "active_source": active_source.provenance(),
+        "correctness_status": correctness["status"],
+        "compact_selector_proof": dict(compact),
+        "watchdog": dict(watchdog),
+        "seed_binding_calls": 1,
+        "seed_count": 1,
+        "on_the_fly_query_construction_threads": OTF_QUERY_CONSTRUCTION_THREADS,
+        "on_the_fly_generation_seconds": float(generation_seconds),
+        "selector_contract": selected_contract,
+    }
+
+
+def _generation_reporting(
+    workload: str,
+    *,
+    generation_seconds: float,
+    warmup_seconds: float,
+    amplicol_generation_seconds: float | None,
+    source: str,
+) -> tuple[dict[str, object], dict[str, float]]:
+    if workload not in {"selected", "all-flow"}:
+        raise StudyError(f"unknown generation-report workload {workload!r}")
+    if (
+        not math.isfinite(generation_seconds)
+        or generation_seconds <= 0.0
+        or not math.isfinite(warmup_seconds)
+        or warmup_seconds < 0.0
+    ):
+        raise StudyError("OTF generation/warm-up comparison timing is invalid")
+    has_amplicol = amplicol_generation_seconds is not None
+    comparison: dict[str, object] = {
+        "notation": "([xG] x(G+W))" if has_amplicol else "[G] G+W",
+        "reporting": (
+            "ratios-to-amplicol" if has_amplicol else "absolute-on-the-fly-seconds"
+        ),
+        "source": source,
+        "warmup_source": f"this-{workload}-cold-batch128-run",
+        "on_the_fly_generation_seconds": generation_seconds,
+        "on_the_fly_warmup_seconds": warmup_seconds,
+        "on_the_fly_generation_plus_warmup_seconds": (
+            generation_seconds + warmup_seconds
+        ),
+    }
+    if not has_amplicol:
+        return comparison, {}
+    assert amplicol_generation_seconds is not None
+    if (
+        not math.isfinite(amplicol_generation_seconds)
+        or amplicol_generation_seconds <= 0.0
+    ):
+        raise StudyError("AmpliCol generation comparison timing is invalid")
+    generation_ratios = {
+        "generation_only": generation_seconds / amplicol_generation_seconds,
+        "generation_plus_warmup": (generation_seconds + warmup_seconds)
+        / amplicol_generation_seconds,
+    }
+    comparison.update(
+        {
+            "amplicol_generation_seconds": amplicol_generation_seconds,
+            "generation_only_over_amplicol": generation_ratios["generation_only"],
+            "generation_plus_warmup_over_amplicol": generation_ratios[
+                "generation_plus_warmup"
+            ],
+        }
+    )
+    return comparison, generation_ratios
+
+
+def _run_worker(args: argparse.Namespace) -> dict[str, object]:
+    _validate_arguments(args)
+    case = _case(args.process_id, args.multiplicity)
+    authority_kind = _authority_kind(case, args.workload)
+    points = _points(case)
+    active_source = _active_report_source()
+    reference: AmplicolReference | None = None
+    if authority_kind == AUTHORITY_AMPLICOL:
+        assert args.reference_repo_root is not None
+        assert isinstance(args.reference_profile, str)
+        reference = _load_amplicol_reference(
+            args.reference_repo_root,
+            args.reference_profile,
+            case,
+            "selected",
+            points,
+            args.target_runtime,
+            active_source,
+        )
+    output = Path(os.path.abspath(args.output.expanduser()))
+    generation: dict[str, object] = {}
+    model = None
+    if args.workload == "selected":
+        prepared = _existing(
+            args.prepared_model, directory=False, label="prepared model"
+        )
+        model = ModelSource.from_path(prepared).compile()
+        candidate_path = output / "candidate-artifact"
+        generation["on_the_fly"] = _generate_otf(case, candidate_path, model)
+    else:
+        candidate_path = _existing(
+            args.candidate_artifact, directory=True, label="candidate artifact"
+        )
+    candidate = Runtime.load(candidate_path, process=case.process_id)
+    artifacts: dict[str, dict[str, object]] = {
+        "candidate": _artifact_identity(candidate_path, candidate, case, "on-the-fly")
+    }
+    candidate_producer_identity = artifacts["candidate"].get("producer_identity")
+    if not isinstance(candidate_producer_identity, Mapping):
+        raise StudyError("candidate artifact producer identity evidence is incomplete")
+    candidate_source_binding = _candidate_source_binding(
+        active_source, candidate_producer_identity
+    )
+    selected_report_lineage = None
+    selector: Selector
+    selector_contract: SelectorContract
+    contract: dict[str, object]
+    compact_selector_context: dict[str, object]
+    recurrence = None
+    if args.workload == "all-flow":
+        selected_report_path = _existing(
+            args.selected_report, directory=False, label="selected report"
+        )
+        selected_report_lineage = _selected_report_lineage(
+            selected_report_path, case, artifacts["candidate"], active_source
+        )
+        raw_contract = selected_report_lineage.get("selector_contract")
+        if not isinstance(raw_contract, Mapping):
+            raise StudyError("selected-report lineage omitted its selector contract")
+        try:
+            selector_contract = SelectorContract.from_mapping(raw_contract)
+        except (TypeError, ValueError) as error:
+            raise StudyError("selected-report selector contract is invalid") from error
+        if selector_contract.point_digest != point_digest(points):
+            raise StudyError("selected-report selector points differ from all-flow")
+        selector = _selector_from_contract(case, selector_contract)
+        contract = selector_contract.as_dict()
+        compact_selector_context = _cross_check_compact_selector(
+            candidate, case, selector, require_ordinal_one=False
+        )
+    elif authority_kind == AUTHORITY_AMPLICOL:
+        assert reference is not None
+        selector = reference.selector
+        selector_contract = reference.contract
+        contract = reference.selector_contract
+        compact_selector_context = _cross_check_compact_selector(
+            candidate, case, selector, require_ordinal_one=False
+        )
+    elif authority_kind == AUTHORITY_RECURRENCE:
+        assert model is not None
+        recurrence_path = output / "recurrence-authority"
+        generation["recurrence"] = _generate_recurrence(case, recurrence_path, model)
+        recurrence = Runtime.load(recurrence_path, process=case.process_id)
+        artifacts["recurrence_authority"] = _artifact_identity(
+            recurrence_path, recurrence, case, "recurrence"
+        )
+        selector, selector_contract, contract = _recurrence_authority_contract(
+            case, recurrence, points
+        )
+        compact_selector_context = _cross_check_compact_selector(
+            candidate, case, selector, require_ordinal_one=False
+        )
+    else:
+        selector, selector_contract, compact_selector_context = (
+            _selector_from_compact_ordinal_one(candidate, case, points)
+        )
+        contract = selector_contract.as_dict()
+
+    producer_identity = _common_producer_identity(artifacts)
+    model_identity = _common_model_identity(artifacts)
+
+    lifecycle_policy = _lifecycle_policy(case, args.workload)
+    lean_lifecycle = lifecycle_policy["mode"] == LIFECYCLE_LEAN
+    requested_cold_warmup = _requested_workload_cold_warmup(
+        candidate,
+        case,
+        selector,
+        points,
+        args.workload,
+        ratio_eligible=reference is not None or recurrence is not None,
+        retain_family=lean_lifecycle,
+    )
+    before, after, lifecycle = _lifecycle(
+        candidate,
+        case,
+        selector,
+        points,
+        args.workload,
+        authority_kind in {AUTHORITY_AMPLICOL, AUTHORITY_RECURRENCE},
+    )
+    if lean_lifecycle:
+        otf_self_consistency = lifecycle["plateau_repeat_self_consistency"]
+        self_consistency_key = "retained_family_plateau_self_consistency"
+    else:
+        otf_self_consistency = _compare(before, after, "OTF pre/post clear")
+        self_consistency_key = "pre_post_clear_self_consistency"
+    if reference is not None:
+        amplicol_values, amplicol_replay = _replay_amplicol(reference, case, points)
+        correctness = {
+            "status": "passed",
+            "authority": "authenticated-amplicol-generated-library-replay",
+            "claim_scope": {
+                "external_amplicol_point_count": len(points),
+                "external_amplicol_seeds": list(SEEDS),
+                "otf_lifecycle_point_count": len(points),
+                "otf_lifecycle_seeds": list(SEEDS),
+            },
+            "amplicol_replay": amplicol_replay,
+            "otf_seed101_vs_amplicol_matrix_element": _amplicol_singleton_check(
+                before, reference, points
+            ),
+            (
+                "otf_retained_vs_amplicol_replay"
+                if lean_lifecycle
+                else "otf_before_vs_amplicol_replay"
+            ): _amplicol_series(
+                before.total,
+                amplicol_values,
+                (
+                    "OTF retained/AmpliCol generated-library replay"
+                    if lean_lifecycle
+                    else "OTF before/AmpliCol generated-library replay"
+                ),
+            ),
+            self_consistency_key: otf_self_consistency,
+            "within_runtime_total_vs_resolved": {
+                "on_the_fly_before": before.total_vs_resolved,
+                **(
+                    {}
+                    if lean_lifecycle
+                    else {"on_the_fly_after": after.total_vs_resolved}
+                ),
+            },
+        }
+        if not lean_lifecycle:
+            correctness["otf_after_vs_amplicol_replay"] = _amplicol_series(
+                after.total,
+                amplicol_values,
+                "OTF after/AmpliCol generated-library replay",
+            )
+    elif recurrence is not None:
+        rec = _evaluate(recurrence, points, args.workload, selector, resolved=True)
+        correctness = {
+            "status": "passed",
+            "authority": "fresh-recurrence",
+            self_consistency_key: otf_self_consistency,
+            "within_runtime_total_vs_resolved": {
+                "on_the_fly_before": before.total_vs_resolved,
+                **(
+                    {}
+                    if lean_lifecycle
+                    else {"on_the_fly_after": after.total_vs_resolved}
+                ),
+                "recurrence": rec.total_vs_resolved,
+            },
+            (
+                "otf_retained_vs_recurrence"
+                if lean_lifecycle
+                else "otf_before_vs_recurrence"
+            ): _compare(
+                before,
+                rec,
+                (
+                    "OTF retained/recurrence"
+                    if lean_lifecycle
+                    else "OTF before/recurrence"
+                ),
+            ),
+        }
+        if not lean_lifecycle:
+            correctness["otf_after_vs_recurrence"] = _compare(
+                after, rec, "OTF after/recurrence"
+            )
+    else:
+        correctness = {
+            "status": "not-claimed",
+            "reason": (
+                "all-flow is an OTF-only feasibility workload"
+                if args.workload == "all-flow"
+                else "n=8/9 is OTF-only; numerical parity is not claimed"
+            ),
+            self_consistency_key: otf_self_consistency,
+        }
+
+    timings = {
+        "on_the_fly": _benchmark(
+            candidate,
+            "on-the-fly",
+            points,
+            args.workload,
+            selector,
+            args.target_runtime,
+        ),
+    }
+    if reference is not None:
+        timings["amplicol"] = reference.timing
+    if _census(candidate, case.process_id) != lifecycle["final_plateau"]:
+        raise StudyError("timed requested family did not plateau")
+    if recurrence is not None:
+        timings["recurrence"] = _benchmark(
+            recurrence,
+            "recurrence",
+            points,
+            args.workload,
+            selector,
+            args.target_runtime,
+        )
+    candidate_timing = timings["on_the_fly"]
+    candidate_wall = float(candidate_timing["wall_seconds_per_point"])
+    candidate_evaluator = float(candidate_timing["evaluator_seconds_per_point"])
+
+    generation_warmup_seconds = float(requested_cold_warmup.get("seconds", -1.0))
+    if args.workload == "selected":
+        on_the_fly_generation = generation.get("on_the_fly")
+        if not isinstance(on_the_fly_generation, Mapping):
+            raise StudyError("selected study omitted OTF generation timing")
+        generation_seconds = float(on_the_fly_generation.get("seconds", -1.0))
+        generation_source = "this-selected-run"
+    else:
+        if not isinstance(selected_report_lineage, Mapping):
+            raise StudyError("all-flow study omitted selected-report lineage")
+        generation_seconds = float(
+            selected_report_lineage.get("on_the_fly_generation_seconds", -1.0)
+        )
+        generation_source = "reused-selected-artifact-generation"
+    generation_comparison, generation_ratios = _generation_reporting(
+        args.workload,
+        generation_seconds=generation_seconds,
+        warmup_seconds=generation_warmup_seconds,
+        amplicol_generation_seconds=(
+            None if reference is None else float(reference.timing["generation_seconds"])
+        ),
+        source=generation_source,
+    )
+    ratios: dict[str, object] = {}
+    if reference is not None:
+        runtime_ratio: dict[str, object] = {
+            "wall_seconds_per_point": candidate_wall
+            / float(reference.timing["wall_seconds_per_point"]),
+            "evaluator_seconds_per_point": candidate_evaluator
+            / float(reference.timing["evaluator_seconds_per_point"]),
+        }
+        runtime_ratio.update(generation_ratios)
+        ratios["on_the_fly_over_amplicol"] = runtime_ratio
+    if recurrence is not None:
+        recurrence_timing = timings["recurrence"]
+        ratios["on_the_fly_over_recurrence"] = {
+            "wall_seconds_per_point": candidate_wall
+            / float(recurrence_timing["wall_seconds_per_point"]),
+            "evaluator_seconds_per_point": candidate_evaluator
+            / float(recurrence_timing["evaluator_seconds_per_point"]),
+        }
+        recurrence_generation = generation.get("recurrence")
+        if not isinstance(recurrence_generation, Mapping):
+            raise StudyError("recurrence authority omitted generation timing")
+        recurrence_generation_seconds = float(recurrence_generation["seconds"])
+        if (
+            not math.isfinite(recurrence_generation_seconds)
+            or recurrence_generation_seconds <= 0.0
+        ):
+            raise StudyError("recurrence authority generation timing is invalid")
+        recurrence_generation_ratios = {
+            "generation_only": generation_seconds / recurrence_generation_seconds,
+            "generation_plus_warmup": (generation_seconds + generation_warmup_seconds)
+            / recurrence_generation_seconds,
+        }
+        generation_comparison.update(
+            {
+                "recurrence_notation": "([xG] x(G+W))",
+                "recurrence_generation_seconds": recurrence_generation_seconds,
+                "generation_only_over_recurrence": recurrence_generation_ratios[
+                    "generation_only"
+                ],
+                "generation_plus_warmup_over_recurrence": (
+                    recurrence_generation_ratios["generation_plus_warmup"]
+                ),
+            }
+        )
+        recurrence_ratio = ratios["on_the_fly_over_recurrence"]
+        assert isinstance(recurrence_ratio, dict)
+        recurrence_ratio.update(recurrence_generation_ratios)
+    return {
+        "kind": KIND,
+        "schema_version": SCHEMA_VERSION,
+        "status": "passed",
+        "scope": (
+            "otf-only-feasibility"
+            if authority_kind == AUTHORITY_OTF_ONLY
+            else f"{authority_kind}-authority"
+        ),
+        "authority": {
+            "kind": authority_kind,
+            "workload_policy": (
+                "all-flow-reuses-selected-artifact-without-comparator"
+                if args.workload == "all-flow"
+                else "selected-cell-authority"
+            ),
+        },
+        "process": dataclass_payload(case),
+        "workload": args.workload,
+        "artifacts": artifacts,
+        "producer_identity": producer_identity,
+        "model_identity": model_identity,
+        "amplicol_reference": None if reference is None else reference.lineage,
+        "active_source": active_source.provenance(),
+        "candidate_source_binding": candidate_source_binding,
+        "lifecycle_policy": lifecycle_policy,
+        "selected_report_lineage": selected_report_lineage,
+        "candidate_reuse": (
+            {
+                "status": "contract",
+                "selected_created_candidate": True,
+                "all_flow_must_reuse_this_artifact": True,
+            }
+            if args.workload == "selected"
+            else {
+                "status": "actual-reuse",
+                "selected_created_candidate": False,
+                "all_flow_reused_candidate": True,
+            }
+        ),
+        "selector_contract": contract,
+        "compact_selector_context": compact_selector_context,
+        "points": {
+            "seeds": list(SEEDS),
+            "sqrt_s": 1000.0,
+            "count": len(points),
+            "digest": point_digest(points),
+        },
+        "generation": generation,
+        "correctness": correctness,
+        "requested_workload_cold_warmup": requested_cold_warmup,
+        "cache_lifecycle": lifecycle,
+        "timing_contract": {
+            "batch_size": BATCH_SIZE,
+            "batch_point_source": "seed-101 correctness point 0 repeated 128 times",
+            "correctness_point_count": len(points),
+            "correctness_seeds": list(SEEDS),
+            "warmup_runs": WARMUP_RUNS,
+            "minimum_samples": MINIMUM_SAMPLES,
+            "target_runtime_seconds": args.target_runtime,
+            "on_the_fly_query_construction_threads": (OTF_QUERY_CONSTRUCTION_THREADS),
+            "recurrence_generation_threads": RECURRENCE_GENERATION_THREADS,
+            "thread_budget_source": (
+                "resolved evaluator.optimization.cores authenticated in the "
+                "OTF execution manifest"
+            ),
+            "runtime_notation": "([evaluator] wall)",
+            "performance_is_acceptance_gate": False,
+        },
+        "timings": timings,
+        "generation_comparison": generation_comparison,
+        "descriptive_ratios": ratios,
+        "forbidden_paths": {
+            "compiled_generation": "not-called",
+            "recurrence_generation": (
+                "authority" if recurrence is not None else "not-called"
+            ),
+            "amplicol_reference": (
+                "authority" if reference is not None else "not-loaded"
+            ),
+            "external_comparator": (
+                authority_kind
+                if authority_kind != AUTHORITY_OTF_ONLY
+                else "not-created"
+            ),
+            "physics_enumeration": (
+                "recurrence-authority-only" if recurrence is not None else "not-called"
+            ),
+            "resolved_output": (
+                "authority-cells-only"
+                if authority_kind != AUTHORITY_OTF_ONLY
+                else "not-called"
+            ),
+            "prepared_model_on_all_flow": (
+                "forbidden" if args.workload == "all-flow" else "not-applicable"
+            ),
+            "materialized_process_lanes": "OTF-generation-poisoned",
+        },
+    }
+
+
+def dataclass_payload(case: Case) -> dict[str, object]:
+    return {
+        "process_table_id": case.process_table_id,
+        "process_key": case.process_key,
+        "multiplicity": case.multiplicity,
+        "expression": case.process,
+        "process_id": case.process_id,
+        "external_pdgs": list(case.pdgs),
+    }
+
+
+def _write(path: Path, value: object) -> None:
+    if path.exists() or path.is_symlink():
+        raise StudyError(f"refusing to replace evidence: {path}")
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    try:
+        temporary.write_text(
+            json.dumps(value, allow_nan=False, indent=2, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, path)
+    except (OSError, TypeError, ValueError) as error:
+        temporary.unlink(missing_ok=True)
+        raise StudyError(f"cannot write evidence: {path}") from error
+
+
+def _read(path: Path) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise StudyError(f"cannot read evidence: {path}") from error
+    if not isinstance(value, dict):
+        raise StudyError(f"evidence is not an object: {path}")
+    return value
+
+
+def _worker_command(args: argparse.Namespace, output: Path) -> list[str]:
+    _validate_arguments(args)
+    command = [
+        sys.executable,
+        str(Path(__file__).resolve()),
+        "--worker",
+        "--output",
+        str(output),
+        "--process-id",
+        str(args.process_id),
+        "--multiplicity",
+        str(args.multiplicity),
+        "--workload",
+        args.workload,
+        "--target-runtime",
+        str(args.target_runtime),
+    ]
+    if args.reference_repo_root is not None:
+        command.extend(
+            (
+                "--reference-repo-root",
+                str(
+                    _existing(
+                        args.reference_repo_root,
+                        directory=True,
+                        label="reference repository root",
+                    )
+                ),
+                "--reference-profile",
+                args.reference_profile,
+            )
+        )
+    for option, value, directory, label in (
+        ("--prepared-model", args.prepared_model, False, "prepared model"),
+        ("--candidate-artifact", args.candidate_artifact, True, "candidate artifact"),
+        ("--selected-report", args.selected_report, False, "selected report"),
+    ):
+        if value is not None:
+            command.extend(
+                (option, str(_existing(value, directory=directory, label=label)))
+            )
+    return command
+
+
+def _worker_main(args: argparse.Namespace) -> int:
+    try:
+        result = _run_worker(args)
+    except Exception as error:
+        _write(
+            args.output / "worker.json",
+            {
+                "kind": KIND,
+                "schema_version": SCHEMA_VERSION,
+                "status": "failed",
+                "error": str(error),
+            },
+        )
+        return 1
+    _write(args.output / "worker.json", result)
+    return 0
+
+
+def _driver_main(args: argparse.Namespace) -> int:
+    _validate_arguments(args)
+    output = Path(os.path.abspath(args.output.expanduser()))
+    if output.exists() or output.is_symlink():
+        raise StudyError(f"output already exists: {output}")
+    output.mkdir(parents=True)
+    watchdog_path = output / "watchdog.json"
+    exit_code = run_guarded(
+        _worker_command(args, output),
+        limit_bytes=WATCHDOG_BYTES,
+        report_path=watchdog_path,
+        physical_footprint_probe=n4._physical_footprint_probe(),
+    )
+    try:
+        watchdog = n4._watchdog_summary(_read(watchdog_path))
+    except n4.GateError as error:
+        raise StudyError(str(error)) from error
+    worker_path = output / "worker.json"
+    worker = _read(worker_path) if worker_path.is_file() else None
+    if (
+        exit_code
+        or watchdog["passes"] is not True
+        or not worker
+        or worker.get("status") != "passed"
+    ):
+        detail = None if worker is None else worker.get("error")
+        raise StudyError(f"guarded worker failed: {watchdog['outcome']!r}, {detail!r}")
+    report = {
+        "kind": f"{KIND}-run",
+        "schema_version": SCHEMA_VERSION,
+        "status": "passed",
+        "study": worker,
+        "watchdog": watchdog,
+    }
+    _write(output / "report.json", report)
+    print(f"On-the-fly high-multiplicity study passed: {output / 'report.json'}")
+    return 0
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        return _worker_main(args) if args.worker else _driver_main(args)
+    except StudyError as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/on_the_fly_lc_gate.py b/pyamplicol/tools/developer/on_the_fly_lc_gate.py
new file mode 100644
index 0000000000..a9bfd5f2a7
--- /dev/null
+++ b/pyamplicol/tools/developer/on_the_fly_lc_gate.py
@@ -0,0 +1,3679 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Developer-only first real LC gate for the on-the-fly evaluator.
+
+One topology-replay ``d d~ > t t~ g g`` artifact must serve both intended
+workloads: selected-flow/helicity-sum and all-flow/single-helicity.  Dense
+correctness against one production recurrence :class:`pyamplicol.Runtime` per
+workload is mandatory; the timing comparison that follows is diagnostic only.
+"""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import importlib
+import json
+import math
+import os
+import platform
+import statistics
+import sys
+import tempfile
+import time
+from collections.abc import Callable, Mapping, Sequence
+from contextlib import ExitStack
+from dataclasses import dataclass
+from functools import partial
+from pathlib import Path
+from typing import Any
+from unittest import mock
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import pyamplicol.generation.service as generation_service  # noqa: E402
+from pyamplicol import (  # noqa: E402
+    BenchmarkRunner,
+    CompiledModel,
+    Generator,
+    ModelSource,
+    ProcessRequest,
+    Runtime,
+)
+from pyamplicol._internal.versions import (  # noqa: E402
+    ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+    ON_THE_FLY_RUNTIME_CAPABILITY,
+)
+from pyamplicol.api.errors import ArtifactError  # noqa: E402
+from pyamplicol.artifacts import confined_path, load_manifest  # noqa: E402
+from pyamplicol.config import (  # noqa: E402
+    BenchmarkConfig,
+    ColorConfig,
+    EvaluatorConfig,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationRelationDiscoveryConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+)
+from pyamplicol.generation.evaluator_container import (  # noqa: E402
+    PacbinError,
+    PacbinMemberKind,
+    PacbinReader,
+)
+from pyamplicol.models.builtin.validation import generic_validation_point  # noqa: E402
+from pyamplicol.processes import canonical_process_key  # noqa: E402
+from tools.ci.memory_watchdog import (  # noqa: E402
+    GIB,
+    DarwinPhysicalFootprintProbe,
+    PhysicalFootprintProbe,
+    run_guarded,
+)
+from tools.performance_report.runner import (  # noqa: E402
+    point_digest,
+    pointwise_validation,
+)
+
+PROCESS = "d d~ > t t~ g g"
+PROCESS_KEY = canonical_process_key(PROCESS)
+PROCESS_ID = "otf_dd_tt_gg"
+EXTERNAL_PDGS = (1, -1, 6, -6, 21, 21)
+ON_THE_FLY_CAPABILITIES = tuple(
+    sorted(
+        (
+            ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+        )
+    )
+)
+ON_THE_FLY_SEED_MEMBER_PATH = "on-the-fly/process-seed-v1.bin"
+FLOW_ID = "flow:2,5,6,4,3,1"
+FLOW_WORD = (2, 5, 6, 4, 3, 1)
+HELICITY_ID = "h:-1,+1,-1,+1,-1,+1"
+HELICITY_VALUES = (-1, 1, -1, 1, -1, 1)
+AMPICOL_CELL_ID = "reference-amplicol-lc-n4-dd-tt-jets-selected-flow"
+SEEDS = (101, 211, 307, 401, 503, 607, 709, 811)
+REL_TOL = 1.0e-12
+AMPICOL_REL_TOL = 1.0e-8
+WATCHDOG_BYTES = 30 * GIB
+WARMUPS = 2
+MINIMUM_SAMPLES = 5
+CORRECTNESS_AUTHORITY_CONTRACT = "recurrence-only-v1"
+WORK_CENSUS_BASIS = "fully-resident-query-local-trace-v1"
+FAMILY_WORK_CENSUS_BASIS = "shared-query-family-union-v1"
+OPERATION_COUNT_FIELDS = (
+    "source_operation_count",
+    "contribution_operation_count",
+    "finalization_operation_count",
+    "closure_operation_count",
+)
+WORK_CENSUS_COUNT_FIELDS = (
+    "logical_current_count",
+    "resident_current_count",
+    "resident_current_component_count",
+    *OPERATION_COUNT_FIELDS,
+    "total_kernel_application_count",
+    "semantic_executor_binding_count",
+    "distinct_prepared_executor_count",
+)
+PUBLIC_PROFILE_WORK_FIELDS = tuple(
+    f"recurrence_{role}_{unit}_count"
+    for role in ("source", "contribution", "finalization", "closure")
+    for unit in ("call", "row")
+)
+FAMILY_CENSUS_COUNT_FIELDS = (
+    "query_count",
+    "source_frame_partition_count",
+    "projection_applied_query_count",
+    "projection_pre_current_count",
+    "projection_pre_contribution_count",
+    "projection_pre_closure_count",
+    "projection_post_current_count",
+    "projection_post_contribution_count",
+    "projection_post_closure_count",
+    "dynamic_current_occurrence_count",
+    "dynamic_current_component_occurrence_count",
+    "dynamic_source_rows",
+    "dynamic_contribution_rows",
+    "dynamic_finalization_rows",
+    "dynamic_closure_rows",
+    "dynamic_source_calls",
+    "dynamic_contribution_calls",
+    "dynamic_finalization_calls",
+    "dynamic_closure_calls",
+    "union_unique_current_count",
+    "union_unique_current_component_count",
+    "union_source_rows",
+    "union_contribution_rows",
+    "union_finalization_rows",
+    "union_closure_rows",
+    "union_amplitude_destination_count",
+    "union_source_executor_call_groups",
+    "union_contribution_executor_call_groups",
+    "union_finalization_executor_call_groups",
+    "union_closure_executor_call_groups",
+)
+MATERIALIZED_PROCESS_LANE_SYMBOLS = (
+    "GenerationBackend._prepare_process_construction",
+    "build_color_plan",
+    "compile_generic_dag",
+    "_invoke_rust_eager_lowering_v1",
+    "_invoke_rust_recurrence_lowering_v2",
+    "run_generic_dag_numerical_current_warmup",
+    "run_recurrence_numerical_current_warmup",
+)
+_FORBIDDEN_MATERIALIZATION_FIELDS = frozenset(
+    {
+        "color_components",
+        "color_plan",
+        "compiled",
+        "compiled_execution",
+        "compiled_plan",
+        "dag",
+        "dag_summary",
+        "direct_plan",
+        "direct_recurrence_plan",
+        "eager",
+        "eager_plan",
+        "eager_runtime",
+        "generic_dag",
+        "helicity_components",
+        "lc_topology_replay",
+        "recurrence",
+        "recurrence_plan",
+        "recurrence_runtime",
+        "runtime_schema",
+        "stages",
+        "structural",
+        "structural_proof",
+        "structural_source_proof",
+    }
+)
+Point = tuple[tuple[float, ...], ...]
+Points = tuple[Point, ...]
+
+
+class GateError(RuntimeError):
+    """The fixed gate could not produce valid evidence."""
+
+
+@dataclass(frozen=True, slots=True)
+class RetainedInputs:
+    builder: object
+    template: object
+    direct_json: bytes
+    pack_digest: str
+
+
+@dataclass(frozen=True, slots=True)
+class Query:
+    flow_id: str
+    flow_index: int
+    helicity_id: str
+    helicities: tuple[int, ...]
+
+    @property
+    def label(self) -> str:
+        return f"{self.flow_id}|{self.helicity_id}"
+
+
+@dataclass(frozen=True, slots=True)
+class PublicEvaluation:
+    total: tuple[object, ...]
+    resolved: object
+
+
+@dataclass(frozen=True, slots=True)
+class RecurrenceAuthorityCorrectness:
+    recurrence_selected: PublicEvaluation
+    recurrence_all_flow: PublicEvaluation
+    on_the_fly_selected: PublicEvaluation
+    on_the_fly_all_flow: PublicEvaluation
+    public_correctness: dict[str, object]
+    clear_checks: dict[str, object]
+
+
+@dataclass(frozen=True, slots=True)
+class PublicGatePhase:
+    runtime: object
+    selected_recurrence_runtime: object
+    all_flow_recurrence_runtime: object
+    comparator_selectors: tuple[tuple[str, tuple[object, object]], ...]
+    points: Points
+    timing_points: Points
+    correctness: RecurrenceAuthorityCorrectness
+    artifact_contract: dict[str, object]
+    load_seconds: float
+    public_profiles: dict[str, object]
+    timings: dict[str, dict[str, dict[str, object]]]
+
+
+def _positive_float(text: str) -> float:
+    value = float(text)
+    if not math.isfinite(value) or value <= 0.0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return value
+
+
+def _positive_int(text: str) -> int:
+    value = int(text)
+    if value <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return value
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", required=True, type=Path)
+    candidate_source = parser.add_mutually_exclusive_group(required=True)
+    candidate_source.add_argument(
+        "--prepared-model",
+        type=Path,
+        help="explicit prepared built-in-SM .pyamplicol-model bundle",
+    )
+    candidate_source.add_argument(
+        "--candidate-artifact",
+        type=Path,
+        help=(
+            "reuse an existing compact on-the-fly artifact; valid only with "
+            "--public-correctness-only"
+        ),
+    )
+    parser.add_argument(
+        "--amplicol-result",
+        type=Path,
+        help="stored successful AmpliCol worker-result.json (optional sanity point)",
+    )
+    parser.add_argument(
+        "--recurrence-selected-artifact",
+        required=True,
+        type=Path,
+        help=(
+            "explicit LC topology-replay recurrence comparator for the "
+            "selected-flow/helicity-sum workload"
+        ),
+    )
+    parser.add_argument(
+        "--recurrence-all-flow-artifact",
+        required=True,
+        type=Path,
+        help=(
+            "explicit LC all-flow-union recurrence comparator for the "
+            "all-flow/single-helicity workload"
+        ),
+    )
+    parser.add_argument("--target-runtime", type=_positive_float, default=1.0)
+    parser.add_argument("--batch-size", type=_positive_int, default=128)
+    parser.add_argument(
+        "--public-correctness-only",
+        action="store_true",
+        help=(
+            "provisional developer lane: public recurrence-authority correctness, "
+            "profiles, and BenchmarkRunner timings only; never creates a private "
+            "probe carrier or private census"
+        ),
+    )
+    parser.add_argument(
+        "--bypass-color-projection",
+        action="store_true",
+        help=(
+            "diagnostic: execute the selected graph before late color-alias projection"
+        ),
+    )
+    parser.add_argument("--worker", action="store_true", help=argparse.SUPPRESS)
+    return parser
+
+
+def _on_the_fly_config() -> RunConfig:
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc", lc_flow_layout="topology-replay"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=True, post_build_validation=True
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            backend="jit",
+            execution_mode="on-the-fly",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+def _recurrence_probe_config() -> RunConfig:
+    return RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc", lc_flow_layout="topology-replay"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            relation_discovery=GenerationRelationDiscoveryConfig(mode="off"),
+            validation=GenerationValidationConfig(
+                enabled=False, post_build_validation=False
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            backend="jit",
+            execution_mode="recurrence",
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+def _points() -> Points:
+    return tuple(
+        tuple(tuple(map(float, particle.momentum)) for particle in point)
+        for point in (
+            generic_validation_point(PROCESS, sqrt_s=1000.0, seed=seed)
+            for seed in SEEDS
+        )
+    )
+
+
+def _repeat(points: Points, count: int) -> Points:
+    if not points or count <= 0:
+        raise GateError("point repetition needs non-empty points and a positive count")
+    return tuple(points[index % len(points)] for index in range(count))
+
+
+def _flatten(points: Points) -> list[float]:
+    return [x for point in points for momentum in point for x in momentum]
+
+
+def _real(value: object, label: str) -> float:
+    try:
+        result = complex(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError, OverflowError) as error:
+        raise GateError(f"{label} is not numeric") from error
+    if not math.isfinite(result.real) or not math.isfinite(result.imag):
+        raise GateError(f"{label} is not finite")
+    if result.imag != 0.0:
+        raise GateError(f"{label} is not real")
+    return result.real
+
+
+def _series(
+    candidate: Sequence[object],
+    reference: Sequence[object],
+    label: str,
+    tolerance: float = REL_TOL,
+) -> dict[str, object]:
+    if not candidate or len(candidate) != len(reference):
+        raise GateError(f"{label} has incompatible or empty point axes")
+    rows = tuple(
+        pointwise_validation(
+            _real(left, "candidate"),
+            _real(right, "reference"),
+            relative_tolerance=tolerance,
+        )
+        for left, right in zip(candidate, reference, strict=True)
+    )
+    failed = next(
+        (index for index, row in enumerate(rows) if row["status"] != "ok"), None
+    )
+    if failed is not None:
+        raise GateError(
+            f"{label} disagrees at point {failed}: "
+            f"residual={rows[failed]['conditioned_residual']!r}"
+        )
+    worst = max(
+        range(len(rows)), key=lambda index: float(rows[index]["conditioned_residual"])
+    )
+    return {
+        "checks": len(rows),
+        "maximum_conditioned_residual": rows[worst]["conditioned_residual"],
+        "maximum_absolute_difference": max(
+            float(row["absolute_difference"]) for row in rows
+        ),
+        "worst_point_index": worst,
+        "worst": rows[worst],
+    }
+
+
+def _summaries(rows: Sequence[Mapping[str, object]]) -> dict[str, object]:
+    if not rows:
+        raise GateError("component comparison set is empty")
+    worst = max(
+        range(len(rows)),
+        key=lambda index: float(rows[index]["maximum_conditioned_residual"]),
+    )
+    return {
+        "component_count": len(rows),
+        "checks": sum(int(row["checks"]) for row in rows),
+        "maximum_conditioned_residual": rows[worst]["maximum_conditioned_residual"],
+        "maximum_absolute_difference": max(
+            float(row["maximum_absolute_difference"]) for row in rows
+        ),
+        "worst_component_index": worst,
+        "worst": rows[worst],
+    }
+
+
+def _sum(rows: Sequence[Sequence[object]], point_count: int) -> tuple[float, ...]:
+    parsed = tuple(tuple(_real(value, "component") for value in row) for row in rows)
+    if not parsed or point_count <= 0 or any(len(row) != point_count for row in parsed):
+        raise GateError("component rows do not match the point count")
+    return tuple(
+        math.fsum(row[point] for row in parsed) for point in range(point_count)
+    )
+
+
+def _calibrate(pilot_seconds: float, target_seconds: float) -> int:
+    if (
+        not math.isfinite(pilot_seconds)
+        or pilot_seconds <= 0.0
+        or not math.isfinite(target_seconds)
+        or target_seconds <= 0.0
+    ):
+        raise GateError("benchmark pilot and target must be positive and finite")
+    repetitions = max(1, math.ceil(target_seconds / pilot_seconds))
+    if repetitions >= 1 << 32:
+        raise GateError("benchmark repetitions exceed the native u32 domain")
+    return repetitions
+
+
+def _canonical_direct(value: object) -> bytes:
+    to_dict = getattr(value, "to_dict", None)
+    if not callable(to_dict):
+        raise GateError("captured direct catalog has no mapping")
+    return json.dumps(
+        to_dict(),
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+def _prepared_model_path(path: Path) -> Path:
+    try:
+        resolved = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise GateError(f"prepared model does not exist: {path}") from error
+    if not resolved.is_file():
+        raise GateError(f"prepared model is not a regular file: {resolved}")
+    if not resolved.name.lower().endswith(".pyamplicol-model"):
+        raise GateError("prepared model must end with '.pyamplicol-model'")
+    return resolved
+
+
+def _candidate_artifact_path(path: Path) -> Path:
+    try:
+        resolved = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise GateError(f"candidate artifact does not exist: {path}") from error
+    if not resolved.is_dir():
+        raise GateError(f"candidate artifact is not a directory: {resolved}")
+    return resolved
+
+
+def _validate_mode_arguments(arguments: argparse.Namespace) -> None:
+    prepared_model = getattr(arguments, "prepared_model", None)
+    candidate_artifact = getattr(arguments, "candidate_artifact", None)
+    public_only = bool(getattr(arguments, "public_correctness_only", False))
+    if public_only:
+        if getattr(arguments, "bypass_color_projection", False):
+            raise GateError(
+                "--bypass-color-projection is unavailable with "
+                "--public-correctness-only"
+            )
+        if getattr(arguments, "amplicol_result", None) is not None:
+            raise GateError(
+                "--amplicol-result needs the full private gate and is unavailable "
+                "with --public-correctness-only"
+            )
+        return
+    if prepared_model is None:
+        raise GateError("the full gate requires --prepared-model")
+    if candidate_artifact is not None:
+        raise GateError(
+            "--candidate-artifact is valid only with --public-correctness-only"
+        )
+
+
+def _reject_materialization_fields(value: object, label: str) -> None:
+    if isinstance(value, Mapping):
+        for raw_name, nested in value.items():
+            name = str(raw_name).lower().replace("-", "_")
+            path = f"{label}.{raw_name}"
+            if name in _FORBIDDEN_MATERIALIZATION_FIELDS:
+                raise GateError(
+                    f"{label} contains forbidden materialization field {path!r}"
+                )
+            _reject_materialization_fields(nested, path)
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        for index, nested in enumerate(value):
+            _reject_materialization_fields(nested, f"{label}[{index}]")
+
+
+def _on_the_fly_source_projections(
+    args: tuple[object, ...], kwargs: Mapping[str, object]
+) -> tuple[Mapping[str, object], ...]:
+    raw = args[0] if args else kwargs.get("ordered_source_projection_jsons")
+    if not isinstance(raw, Sequence) or isinstance(raw, (str, bytes)) or not raw:
+        raise GateError("on-the-fly batch seed binding omitted its source projections")
+    result: list[Mapping[str, object]] = []
+    for index, encoded in enumerate(raw):
+        if not isinstance(encoded, bytes):
+            raise GateError(
+                f"on-the-fly source projection {index} is not encoded bytes"
+            )
+        try:
+            projection = json.loads(encoded)
+        except (UnicodeDecodeError, json.JSONDecodeError) as error:
+            raise GateError(
+                f"on-the-fly source projection {index} is not valid JSON"
+            ) from error
+        record = _mapping(projection, f"on-the-fly source projection {index}")
+        _reject_materialization_fields(record, f"on-the-fly source projection {index}")
+        result.append(record)
+    return tuple(result)
+
+
+def _materialized_process_lane_patch_targets() -> tuple[tuple[str, object, str], ...]:
+    return (
+        (
+            "GenerationBackend._prepare_process_construction",
+            generation_service.GenerationBackend,
+            "_prepare_process_construction",
+        ),
+        ("build_color_plan", generation_service, "build_color_plan"),
+        ("compile_generic_dag", generation_service, "compile_generic_dag"),
+        (
+            "_invoke_rust_eager_lowering_v1",
+            generation_service,
+            "_invoke_rust_eager_lowering_v1",
+        ),
+        (
+            "_invoke_rust_recurrence_lowering_v2",
+            generation_service,
+            "_invoke_rust_recurrence_lowering_v2",
+        ),
+        (
+            "run_generic_dag_numerical_current_warmup",
+            generation_service,
+            "run_generic_dag_numerical_current_warmup",
+        ),
+        (
+            "run_recurrence_numerical_current_warmup",
+            generation_service,
+            "run_recurrence_numerical_current_warmup",
+        ),
+    )
+
+
+def _generate_on_the_fly(
+    artifact: Path, model: CompiledModel
+) -> tuple[float, dict[str, int]]:
+    seed_batch_binding_call_count = 0
+    seed_build_count = 0
+    original_seed_builder = (
+        generation_service._invoke_rust_on_the_fly_seed_batch_builder_v1
+    )
+
+    def capture_seed_batch(*args: object, **kwargs: object) -> object:
+        nonlocal seed_batch_binding_call_count, seed_build_count
+        seed_batch_binding_call_count += 1
+        projections = _on_the_fly_source_projections(args, kwargs)
+        result = original_seed_builder(*args, **kwargs)
+        if not isinstance(result, tuple):
+            raise GateError("on-the-fly batch seed binding returned a non-tuple")
+        if len(result) != len(projections):
+            raise GateError(
+                "on-the-fly batch seed binding changed the process count: "
+                f"{len(projections)} projection(s), {len(result)} seed(s)"
+            )
+        seed_build_count += len(result)
+        return result
+
+    materialized_lane_call_counts = {
+        name: 0 for name in MATERIALIZED_PROCESS_LANE_SYMBOLS
+    }
+
+    def reject_materialized_lane(
+        name: str,
+    ) -> Callable[..., object]:
+        def reject(*_args: object, **_kwargs: object) -> object:
+            materialized_lane_call_counts[name] += 1
+            raise GateError(
+                f"on-the-fly generation entered materialized process lane {name}"
+            )
+
+        return reject
+
+    started = time.perf_counter()
+    with ExitStack() as patches:
+        patches.enter_context(
+            mock.patch.object(
+                generation_service,
+                "_invoke_rust_on_the_fly_seed_batch_builder_v1",
+                capture_seed_batch,
+            )
+        )
+        for name, owner, attribute in _materialized_process_lane_patch_targets():
+            patches.enter_context(
+                mock.patch.object(
+                    owner,
+                    attribute,
+                    reject_materialized_lane(name),
+                )
+            )
+        Generator(_on_the_fly_config()).generate(
+            ProcessRequest.parse(PROCESS, name=PROCESS_ID), artifact, model=model
+        )
+    if seed_batch_binding_call_count != 1 or seed_build_count != 1:
+        raise GateError(
+            "expected one on-the-fly batch binding call producing one seed, "
+            f"observed {seed_batch_binding_call_count} call(s) and "
+            f"{seed_build_count} seed(s)"
+        )
+    return time.perf_counter() - started, {
+        "expanded_process_count": 1,
+        "on_the_fly_seed_batch_binding_call_count": (seed_batch_binding_call_count),
+        "on_the_fly_seed_build_count": seed_build_count,
+        "recurrence_lowering_call_count": materialized_lane_call_counts[
+            "_invoke_rust_recurrence_lowering_v2"
+        ],
+        "materialized_process_lane_count": sum(materialized_lane_call_counts.values()),
+    }
+
+
+def _generate_probe_carrier(artifact: Path, model: CompiledModel) -> RetainedInputs:
+    captured: list[RetainedInputs] = []
+    original = generation_service._invoke_rust_recurrence_lowering_v2
+
+    def capture(*args: object, **kwargs: object) -> object:
+        if len(args) < 4:
+            raise GateError("lowering call omitted its canonical inputs")
+        direct = _canonical_direct(args[2])
+        supplied = kwargs.get("direct_template_catalog_json")
+        if supplied is not None and supplied != direct:
+            raise GateError("lowering direct-catalog bytes are not canonical")
+        captured.append(RetainedInputs(args[0], args[1], direct, str(args[3])))
+        return original(*args, **kwargs)
+
+    with mock.patch.object(
+        generation_service, "_invoke_rust_recurrence_lowering_v2", capture
+    ):
+        Generator(_recurrence_probe_config()).generate(
+            ProcessRequest.parse(PROCESS, name=PROCESS_ID), artifact, model=model
+        )
+    if len(captured) != 1:
+        raise GateError(f"expected one lowering call, observed {len(captured)}")
+    return captured[0]
+
+
+def _generate_candidate_with_prepared_model(
+    artifact: Path, prepared_model: Path
+) -> tuple[float, dict[str, int], CompiledModel, Path, float]:
+    resolved = _prepared_model_path(prepared_model)
+    started = time.perf_counter()
+    model = ModelSource.from_path(resolved).compile()
+    load_seconds = time.perf_counter() - started
+    generation_seconds, generation_census = _generate_on_the_fly(artifact, model)
+    return generation_seconds, generation_census, model, resolved, load_seconds
+
+
+def _selectors(physics: object) -> tuple[object, object]:
+    flows = tuple(
+        flow
+        for flow in getattr(physics, "color_flows", ())
+        if flow.id == FLOW_ID and tuple(flow.word) == FLOW_WORD
+    )
+    helicities = tuple(
+        helicity
+        for helicity in getattr(physics, "helicities", ())
+        if helicity.id == HELICITY_ID and tuple(helicity.values) == HELICITY_VALUES
+    )
+    if len(flows) != 1 or len(helicities) != 1:
+        raise GateError("artifact does not expose the exact fixed flow and helicity")
+    if helicities[0].structural_zero:
+        raise GateError("fixed all-flow helicity is structurally zero")
+    return flows[0], helicities[0]
+
+
+def _query(flow: object, helicity: object) -> Query:
+    index = flow.index
+    values = tuple(helicity.values)
+    if isinstance(index, bool) or not isinstance(index, int) or index < 0:
+        raise GateError("color-flow native index is invalid")
+    if not values or any(
+        isinstance(value, bool) or not isinstance(value, int) for value in values
+    ):
+        raise GateError("helicity values are invalid")
+    return Query(flow.id, index, helicity.id, values)
+
+
+def _probe() -> Callable[..., dict[str, Any]]:
+    candidate = getattr(
+        importlib.import_module("pyamplicol._rusticol"),
+        "_on_the_fly_artifact_probe_v1",
+        None,
+    )
+    if not callable(candidate):
+        raise GateError("native extension lacks on-the-fly benchmark test support")
+    return candidate
+
+
+def _family_probe() -> Callable[..., dict[str, Any]]:
+    candidate = getattr(
+        importlib.import_module("pyamplicol._rusticol"),
+        "_on_the_fly_query_family_census_v1",
+        None,
+    )
+    if not callable(candidate):
+        raise GateError("native extension lacks on-the-fly family-census support")
+    return candidate
+
+
+def _invoke(
+    probe: Callable[..., dict[str, Any]],
+    artifact: Path,
+    retained: RetainedInputs,
+    query: Query,
+    points: Points,
+    *,
+    repetitions: int = 0,
+    enable_color_projection: bool = True,
+    query_family: Sequence[Query] | None = None,
+) -> dict[str, Any]:
+    benchmark = repetitions > 0
+    return probe(
+        str(artifact),
+        PROCESS_ID,
+        retained.builder,
+        retained.template,
+        retained.direct_json,
+        retained.pack_digest,
+        query.flow_index,
+        list(query.helicities),
+        _flatten(points),
+        len(points),
+        benchmark=benchmark,
+        benchmark_warmup_repetitions=WARMUPS if benchmark else 0,
+        benchmark_repetitions=repetitions,
+        collect_current_diagnostics=False,
+        enable_color_projection=enable_color_projection,
+        query_family=(
+            None
+            if query_family is None
+            else [
+                (member.flow_index, list(member.helicities)) for member in query_family
+            ]
+        ),
+    )
+
+
+def _probe_values(
+    report: Mapping[str, object], point_count: int, repetitions: int = 0
+) -> tuple[float, ...]:
+    poison = (
+        "direct_plan_load_attempts",
+        "direct_plan_decode_attempts",
+        "direct_plan_materialization_attempts",
+        "established_builder_attempts",
+    )
+    benchmark = repetitions > 0
+    cycles = WARMUPS + repetitions if benchmark else 1
+    hits = cycles if benchmark else 0
+    if (
+        report.get("process_id") != PROCESS_ID
+        or report.get("point_count") != point_count
+        or report.get("trace_build_count") != 1
+        or report.get("trace_cache_hit_count") != hits
+        or report.get("momentum_fill_count") != cycles
+        or report.get("currents") != []
+        or any(report.get(name) != 0 for name in poison)
+    ):
+        raise GateError("hidden query violated its build/cache/fill/poison contract")
+    _work_census(report)
+    values = report.get("normalized_values")
+    if not isinstance(values, Sequence) or isinstance(values, (str, bytes)):
+        raise GateError("hidden query has no normalized values")
+    parsed = tuple(_real(value, "hidden value") for value in values)
+    if len(parsed) != point_count:
+        raise GateError("hidden query returned the wrong point count")
+    elapsed = report.get("benchmark_elapsed_seconds")
+    per_point = report.get("benchmark_seconds_per_point")
+    if benchmark:
+        if not isinstance(elapsed, (int, float)) or not isinstance(
+            per_point, (int, float)
+        ):
+            raise GateError("hidden benchmark omitted timings")
+        expected = float(elapsed) / (repetitions * point_count)
+        valid_timing = (
+            math.isfinite(float(elapsed))
+            and float(elapsed) >= 0.0
+            and math.isclose(float(per_point), expected, rel_tol=1.0e-15, abs_tol=0.0)
+        )
+        if not valid_timing:
+            raise GateError("hidden benchmark timings are inconsistent")
+    elif elapsed is not None or per_point is not None:
+        raise GateError("untimed hidden query returned timings")
+    return parsed
+
+
+def _work_census(report: Mapping[str, object]) -> dict[str, object]:
+    if report.get("work_census_basis") != WORK_CENSUS_BASIS:
+        raise GateError("hidden query has an unknown work-census basis")
+    counts: dict[str, int] = {}
+    for name in WORK_CENSUS_COUNT_FIELDS:
+        value = report.get(name)
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise GateError(f"hidden query work census has invalid {name}")
+        counts[name] = value
+    if counts["resident_current_count"] != counts["logical_current_count"]:
+        raise GateError("hidden query does not use a fully resident current arena")
+    if counts["resident_current_component_count"] < counts["resident_current_count"]:
+        raise GateError("hidden query resident current components are inconsistent")
+    if counts["total_kernel_application_count"] != sum(
+        counts[name] for name in OPERATION_COUNT_FIELDS
+    ):
+        raise GateError("hidden query kernel and operation counts disagree")
+    semantic = counts["semantic_executor_binding_count"]
+    prepared = counts["distinct_prepared_executor_count"]
+    total = counts["total_kernel_application_count"]
+    if not 0 < prepared <= semantic <= total:
+        raise GateError("hidden query prepared-executor counts are inconsistent")
+    return {"work_census_basis": WORK_CENSUS_BASIS, **counts}
+
+
+def _family_probe_result(
+    report: Mapping[str, object],
+    queries: Sequence[Query],
+    point_count: int,
+    repetitions: int = 0,
+) -> dict[str, object]:
+    if not queries:
+        raise GateError("hidden family report has no requested queries")
+    benchmark = repetitions > 0
+    cycles = WARMUPS + repetitions if benchmark else 1
+    poison = (
+        "direct_plan_load_attempts",
+        "direct_plan_decode_attempts",
+        "direct_plan_materialization_attempts",
+        "established_builder_attempts",
+    )
+    if (
+        report.get("process_id") != PROCESS_ID
+        or report.get("point_count") != point_count
+        or report.get("work_census_basis") != FAMILY_WORK_CENSUS_BASIS
+        or report.get("trace_build_count") != len(queries)
+        or report.get("trace_cache_hit_count") != 0
+        or report.get("momentum_fill_count") != cycles
+        or report.get("currents") != []
+        or any(report.get(name) != 0 for name in poison)
+    ):
+        raise GateError("hidden family violated its build/cache/fill/poison contract")
+    family = report.get("query_family")
+    if not isinstance(family, Mapping):
+        raise GateError("hidden family report is absent")
+    raw_census = family.get("census")
+    if not isinstance(raw_census, Mapping):
+        raise GateError("hidden family census is absent")
+    census: dict[str, int] = {}
+    for name in FAMILY_CENSUS_COUNT_FIELDS:
+        value = raw_census.get(name)
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise GateError(f"hidden family census has invalid {name}")
+        census[name] = value
+    if (
+        census["query_count"] != len(queries)
+        or census["source_frame_partition_count"] != 1
+        or census["union_amplitude_destination_count"] != len(queries)
+    ):
+        raise GateError("hidden family census has the wrong query/source shape")
+    for role in ("source", "contribution", "finalization", "closure"):
+        if (
+            family.get(f"execution_{role}_rows") != census[f"union_{role}_rows"]
+            or family.get(f"execution_{role}_calls")
+            != census[f"union_{role}_executor_call_groups"]
+        ):
+            raise GateError(f"hidden family execution disagrees for {role}")
+    union_total = sum(
+        census[f"union_{role}_rows"]
+        for role in ("source", "contribution", "finalization", "closure")
+    )
+    if (
+        report.get("source_operation_count") != census["union_source_rows"]
+        or report.get("contribution_operation_count")
+        != census["union_contribution_rows"]
+        or report.get("finalization_operation_count")
+        != census["union_finalization_rows"]
+        or report.get("closure_operation_count") != census["union_closure_rows"]
+        or report.get("total_kernel_application_count") != union_total
+        or family.get("execution_cache_hit") is not benchmark
+        or family.get("private_timing_excludes_source_crossing") is not True
+    ):
+        raise GateError("hidden family top-level execution census is inconsistent")
+    cold_prepare = family.get("cold_prepare_seconds")
+    if (
+        isinstance(cold_prepare, bool)
+        or not isinstance(cold_prepare, (int, float))
+        or not math.isfinite(float(cold_prepare))
+        or float(cold_prepare) < 0.0
+    ):
+        raise GateError("hidden family cold preparation timing is invalid")
+
+    raw_queries = family.get("queries")
+    if not isinstance(raw_queries, Sequence) or isinstance(raw_queries, (str, bytes)):
+        raise GateError("hidden family query outputs are absent")
+    if len(raw_queries) != len(queries):
+        raise GateError("hidden family returned the wrong query count")
+    rows: list[dict[str, object]] = []
+    for expected, raw in zip(queries, raw_queries, strict=True):
+        if not isinstance(raw, Mapping):
+            raise GateError("hidden family query output is not a mapping")
+        if (
+            raw.get("selected_public_flow_id") != expected.flow_index
+            or tuple(raw.get("public_helicities", ())) != expected.helicities
+            or not isinstance(raw.get("query_digest"), str)
+        ):
+            raise GateError("hidden family query identity/order changed")
+        raw_amplitudes = raw.get("raw_amplitudes")
+        normalized_values = raw.get("normalized_values")
+        if (
+            not isinstance(raw_amplitudes, Sequence)
+            or isinstance(raw_amplitudes, (str, bytes))
+            or not isinstance(normalized_values, Sequence)
+            or isinstance(normalized_values, (str, bytes))
+            or len(raw_amplitudes) != point_count
+            or len(normalized_values) != point_count
+        ):
+            raise GateError("hidden family query returned the wrong point axis")
+        parsed_raw = tuple(
+            complex(
+                _real(pair[0], "family raw real"),
+                _real(pair[1], "family raw imag"),
+            )
+            for pair in raw_amplitudes
+            if isinstance(pair, Sequence)
+            and not isinstance(pair, (str, bytes))
+            and len(pair) == 2
+        )
+        if len(parsed_raw) != point_count:
+            raise GateError("hidden family query has malformed raw amplitudes")
+        parsed_normalized = tuple(
+            _real(value, "family normalized value") for value in normalized_values
+        )
+        rows.append(
+            {
+                "query": expected.label,
+                "query_digest": raw["query_digest"],
+                "raw_amplitudes": parsed_raw,
+                "normalized_values": parsed_normalized,
+            }
+        )
+
+    elapsed = family.get("private_warmed_elapsed_seconds")
+    per_point = family.get("private_warmed_seconds_per_point")
+    if benchmark:
+        if not isinstance(elapsed, (int, float)) or not isinstance(
+            per_point, (int, float)
+        ):
+            raise GateError("hidden family benchmark omitted timings")
+        expected = float(elapsed) / (repetitions * point_count)
+        if (
+            not math.isfinite(float(elapsed))
+            or float(elapsed) < 0.0
+            or not math.isclose(float(per_point), expected, rel_tol=1.0e-15)
+        ):
+            raise GateError("hidden family benchmark timings are inconsistent")
+    elif elapsed is not None or per_point is not None:
+        raise GateError("untimed hidden family returned timings")
+    return {
+        "queries": rows,
+        "census": census,
+        "union_total_kernel_application_count": union_total,
+        "cold_prepare_seconds": float(cold_prepare),
+        "private_warmed_elapsed_seconds": elapsed,
+        "private_warmed_seconds_per_point": per_point,
+        "private_timing_excludes_source_crossing": True,
+    }
+
+
+def _axes(resolved: object) -> tuple[dict[str, int], dict[str, int]]:
+    helicities = tuple(resolved.helicity_ids)
+    colors = tuple(resolved.color_ids)
+    if (
+        not helicities
+        or not colors
+        or len(set(helicities)) != len(helicities)
+        or len(set(colors)) != len(colors)
+    ):
+        raise GateError("resolved axes are empty or ambiguous")
+    return (
+        {value: index for index, value in enumerate(helicities)},
+        {value: index for index, value in enumerate(colors)},
+    )
+
+
+def _resolved_component_checks(
+    candidate: object, reference: object, label: str
+) -> dict[str, object]:
+    candidate_helicities = tuple(candidate.helicity_ids)
+    candidate_colors = tuple(candidate.color_ids)
+    reference_helicities = tuple(reference.helicity_ids)
+    reference_colors = tuple(reference.color_ids)
+    candidate_helicity_axis, candidate_color_axis = _axes(candidate)
+    reference_helicity_axis, reference_color_axis = _axes(reference)
+    if set(candidate_helicities) != set(reference_helicities) or set(
+        candidate_colors
+    ) != set(reference_colors):
+        raise GateError(f"{label} resolved selector axes differ")
+    candidate_values = tuple(candidate.values)
+    reference_values = tuple(reference.values)
+    if not candidate_values or len(candidate_values) != len(reference_values):
+        raise GateError(f"{label} resolved point axes differ or are empty")
+    rows: list[dict[str, object]] = []
+    try:
+        for helicity_id in candidate_helicities:
+            candidate_helicity_index = candidate_helicity_axis[helicity_id]
+            reference_helicity_index = reference_helicity_axis[helicity_id]
+            for color_id in candidate_colors:
+                candidate_color_index = candidate_color_axis[color_id]
+                reference_color_index = reference_color_axis[color_id]
+                rows.append(
+                    _series(
+                        tuple(
+                            point[candidate_helicity_index][candidate_color_index]
+                            for point in candidate_values
+                        ),
+                        tuple(
+                            point[reference_helicity_index][reference_color_index]
+                            for point in reference_values
+                        ),
+                        f"{label} {helicity_id}/{color_id}",
+                    )
+                )
+    except (IndexError, TypeError) as error:
+        raise GateError(f"{label} resolved values have an invalid shape") from error
+    return _summaries(rows)
+
+
+def _public_evaluation(
+    runtime: object,
+    points: Points,
+    workload: str,
+    label: str,
+) -> PublicEvaluation:
+    if workload == "selected_flow_helicity_sum":
+        selectors = {"color_flows": (FLOW_ID,)}
+        expected_axis = "color_ids"
+        expected_ids = (FLOW_ID,)
+    elif workload == "all_flow_single_helicity":
+        selectors = {"helicities": (HELICITY_ID,)}
+        expected_axis = "helicity_ids"
+        expected_ids = (HELICITY_ID,)
+    else:
+        raise GateError(f"unknown public correctness workload: {workload}")
+    total = tuple(runtime.evaluate(points, **selectors))
+    resolved = runtime.evaluate_resolved(points, **selectors)
+    if tuple(getattr(resolved, expected_axis, ())) != expected_ids:
+        raise GateError(f"{label} did not resolve the exact public selector ID")
+    if len(total) != len(points):
+        raise GateError(f"{label} returned the wrong point count")
+    return PublicEvaluation(total=total, resolved=resolved)
+
+
+def _recurrence_authority_correctness(
+    runtime: object,
+    selected_recurrence_runtime: object,
+    all_flow_recurrence_runtime: object,
+    points: Points,
+) -> RecurrenceAuthorityCorrectness:
+    recurrence_selected = _public_evaluation(
+        selected_recurrence_runtime,
+        points,
+        "selected_flow_helicity_sum",
+        "selected recurrence authority",
+    )
+    recurrence_all_flow = _public_evaluation(
+        all_flow_recurrence_runtime,
+        points,
+        "all_flow_single_helicity",
+        "all-flow recurrence authority",
+    )
+    on_the_fly_selected = _public_evaluation(
+        runtime,
+        points,
+        "selected_flow_helicity_sum",
+        "on-the-fly selected candidate",
+    )
+    on_the_fly_all_flow = _public_evaluation(
+        runtime,
+        points,
+        "all_flow_single_helicity",
+        "on-the-fly all-flow candidate",
+    )
+    public_correctness = {
+        "selected_flow_helicity_sum": {
+            "total_authority": _series(
+                on_the_fly_selected.total,
+                recurrence_selected.total,
+                "on-the-fly selected total/recurrence authority",
+            ),
+            "resolved_authority": _resolved_component_checks(
+                on_the_fly_selected.resolved,
+                recurrence_selected.resolved,
+                "on-the-fly selected resolved/recurrence authority",
+            ),
+            "total_resolved_identity": _series(
+                on_the_fly_selected.total,
+                on_the_fly_selected.resolved.total(),
+                "on-the-fly selected total/resolved",
+            ),
+        },
+        "all_flow_single_helicity": {
+            "total_authority": _series(
+                on_the_fly_all_flow.total,
+                recurrence_all_flow.total,
+                "on-the-fly all-flow total/recurrence authority",
+            ),
+            "resolved_authority": _resolved_component_checks(
+                on_the_fly_all_flow.resolved,
+                recurrence_all_flow.resolved,
+                "on-the-fly all-flow resolved/recurrence authority",
+            ),
+            "total_resolved_identity": _series(
+                on_the_fly_all_flow.total,
+                on_the_fly_all_flow.resolved.total(),
+                "on-the-fly all-flow total/resolved",
+            ),
+        },
+    }
+
+    runtime.clear()
+    selected_after_clear = _public_evaluation(
+        runtime,
+        points,
+        "selected_flow_helicity_sum",
+        "on-the-fly selected candidate after clear",
+    )
+    all_flow_after_clear = _public_evaluation(
+        runtime,
+        points,
+        "all_flow_single_helicity",
+        "on-the-fly all-flow candidate after clear",
+    )
+    clear_checks = {
+        "selected_total": _series(
+            selected_after_clear.total,
+            recurrence_selected.total,
+            "on-the-fly selected total/recurrence authority after clear",
+        ),
+        "selected_resolved": _resolved_component_checks(
+            selected_after_clear.resolved,
+            recurrence_selected.resolved,
+            "on-the-fly selected resolved/recurrence authority after clear",
+        ),
+        "all_flow_total": _series(
+            all_flow_after_clear.total,
+            recurrence_all_flow.total,
+            "on-the-fly all-flow total/recurrence authority after clear",
+        ),
+        "all_flow_resolved": _resolved_component_checks(
+            all_flow_after_clear.resolved,
+            recurrence_all_flow.resolved,
+            "on-the-fly all-flow resolved/recurrence authority after clear",
+        ),
+    }
+    return RecurrenceAuthorityCorrectness(
+        recurrence_selected=recurrence_selected,
+        recurrence_all_flow=recurrence_all_flow,
+        on_the_fly_selected=on_the_fly_selected,
+        on_the_fly_all_flow=on_the_fly_all_flow,
+        public_correctness=public_correctness,
+        clear_checks=clear_checks,
+    )
+
+
+def _dense_authority(
+    selected_runtime: object,
+    all_flow_runtime: object,
+    point_count: int,
+) -> dict[str, object]:
+    return {
+        "authority_kind": "validated_recurrence",
+        "authority_execution_mode": "recurrence",
+        "runtime_api": "Runtime.evaluate_resolved",
+        "selected_flow_artifact_id": selected_runtime.artifact_id,
+        "all_flow_artifact_id": all_flow_runtime.artifact_id,
+        "point_count": point_count,
+        "certifies": (
+            "selected_flow_helicity_sum",
+            "all_flow_single_helicity",
+        ),
+    }
+
+
+def _benchmark_config(
+    target: float,
+    batch: int,
+    *,
+    helicities: tuple[str, ...] = (),
+    flows: tuple[str, ...] = (),
+) -> BenchmarkConfig:
+    return BenchmarkConfig(
+        target_runtime=target,
+        batch_size=batch,
+        precision=16,
+        warmup_runs=WARMUPS,
+        minimum_samples=MINIMUM_SAMPLES,
+        helicity_ids=helicities,
+        color_flow_ids=flows,
+    )
+
+
+def _public_recurrence_work(result: object) -> dict[str, object] | None:
+    breakdown = result.timing_breakdown
+    counters = None if breakdown is None else breakdown.counters
+    if counters is None:
+        return None
+    role_counts = {
+        "source_calls_per_runtime_call": counters.recurrence_source_calls_per_call,
+        "source_rows_per_runtime_call": counters.recurrence_source_rows_per_call,
+        "contribution_calls_per_runtime_call": (
+            counters.recurrence_contribution_calls_per_call
+        ),
+        "contribution_rows_per_runtime_call": (
+            counters.recurrence_contribution_rows_per_call
+        ),
+        "finalization_calls_per_runtime_call": (
+            counters.recurrence_finalization_calls_per_call
+        ),
+        "finalization_rows_per_runtime_call": (
+            counters.recurrence_finalization_rows_per_call
+        ),
+        "closure_calls_per_runtime_call": counters.recurrence_closure_calls_per_call,
+        "closure_rows_per_runtime_call": counters.recurrence_closure_rows_per_call,
+    }
+    if not any(value is not None for value in role_counts.values()):
+        return None
+    return {
+        "basis": counters.normalization,
+        "semantics": (
+            "rows are logical DirectPlan applications; calls are grouped "
+            "prepared-backend invocations"
+        ),
+        **role_counts,
+    }
+
+
+def _public_timing(result: object, execution_mode: str) -> dict[str, object]:
+    breakdown = result.timing_breakdown
+    if breakdown is None or breakdown.execution_mode != execution_mode:
+        raise GateError(
+            f"public {execution_mode} benchmark has no matching timing breakdown"
+        )
+    evaluator_label = (
+        "recurrence core"
+        if execution_mode == "recurrence"
+        else "warmed evaluator envelope"
+    )
+    return {
+        "execution_mode": execution_mode,
+        "sample_count": result.sample_count,
+        "repetitions_per_sample": result.repetitions_per_sample,
+        "wall_seconds_per_point": result.wall_time_per_point,
+        "evaluator_seconds_per_point": result.evaluator_time_per_point,
+        "evaluator_total_seconds_per_point": result.evaluator_total_time_per_point,
+        "clock_attribution": {
+            "wall_seconds_per_point": "BenchmarkRunner outer wall clock",
+            "evaluator_seconds_per_point": evaluator_label,
+            "evaluator_total_seconds_per_point": (
+                "independently accumulated warmed evaluator-total clock"
+            ),
+            "relationship": (
+                "all reported clocks are independent; equality is neither assumed "
+                "nor asserted"
+            ),
+        },
+        "interrupted": result.interrupted,
+        "effective_config": dataclasses.asdict(result.effective_config),
+        "uncertainty": dataclasses.asdict(result.uncertainty),
+        "recurrence_runtime_work": (
+            None if execution_mode == "compiled" else _public_recurrence_work(result)
+        ),
+    }
+
+
+def _exact_on_the_fly_capabilities(value: object, label: str) -> None:
+    capabilities = _items(value, label)
+    if capabilities != ON_THE_FLY_CAPABILITIES:
+        raise GateError(
+            f"{label} must contain exactly the two LC on-the-fly capabilities"
+        )
+
+
+def _manifest_payload_record(
+    manifest: Any,
+    relative: str,
+    *,
+    role: str,
+    process_id: str | None,
+) -> object:
+    records = tuple(
+        record
+        for record in getattr(manifest, "payloads", ())
+        if record.path == relative
+    )
+    if len(records) != 1:
+        raise GateError(
+            f"on-the-fly artifact must authenticate exactly one {relative!r} payload"
+        )
+    record = records[0]
+    if record.role != role or record.process_id != process_id or record.executable:
+        raise GateError(
+            f"authenticated on-the-fly payload {relative!r} has wrong ownership, "
+            "role, or executable state"
+        )
+    return record
+
+
+def _authenticated_json_payload(
+    manifest: Any,
+    relative: str,
+    *,
+    role: str,
+    process_id: str | None,
+    label: str,
+) -> Mapping[str, object]:
+    _manifest_payload_record(
+        manifest,
+        relative,
+        role=role,
+        process_id=process_id,
+    )
+    try:
+        path = confined_path(manifest.root, relative)
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (ArtifactError, OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise GateError(f"cannot read authenticated {label}: {relative}") from error
+    return _mapping(payload, label)
+
+
+def _resolved_artifact_relative(
+    manifest: Any, base: Path, relative: object, label: str
+) -> str:
+    if not isinstance(relative, str) or not relative:
+        raise GateError(f"{label} is not a non-empty relative path")
+    joined = (base / relative).as_posix()
+    try:
+        path = confined_path(manifest.root, joined)
+    except ArtifactError as error:
+        raise GateError(f"{label} is not confined to the artifact") from error
+    return path.relative_to(manifest.root).as_posix()
+
+
+def _on_the_fly_artifact_contract(artifact: Path, runtime: object) -> dict[str, object]:
+    try:
+        manifest = load_manifest(artifact, verify_payloads=True)
+    except (ArtifactError, OSError) as error:
+        raise GateError(
+            f"cannot authenticate generated on-the-fly artifact: {artifact}"
+        ) from error
+
+    _exact_on_the_fly_capabilities(
+        manifest.runtime.get("required_runtime_capabilities"),
+        "artifact runtime capabilities",
+    )
+    processes = tuple(manifest.processes)
+    if len(processes) != 1 or processes[0].get("id") != PROCESS_ID:
+        raise GateError(
+            "generated on-the-fly artifact must contain exactly the fixed process"
+        )
+    process = processes[0]
+    expression = process.get("expression")
+    if (
+        not isinstance(expression, str)
+        or canonical_process_key(expression) != PROCESS_KEY
+        or process.get("color_accuracy") != "lc"
+    ):
+        raise GateError("generated on-the-fly artifact has wrong process identity")
+    _exact_on_the_fly_capabilities(
+        process.get("required_runtime_capabilities"),
+        "process runtime capabilities",
+    )
+
+    evaluator_relative = str(manifest.runtime["evaluator_manifest_path"])
+    evaluator_set = _authenticated_json_payload(
+        manifest,
+        evaluator_relative,
+        role="evaluator-manifest",
+        process_id=None,
+        label="on-the-fly evaluator set",
+    )
+    if set(evaluator_set) != {
+        "schema_version",
+        "kind",
+        "required_runtime_capabilities",
+        "processes",
+    } or (
+        evaluator_set.get("schema_version") != 3
+        or evaluator_set.get("kind") != "pyamplicol-runtime-execution-set"
+    ):
+        raise GateError("generated on-the-fly evaluator set is not compact v3")
+    _exact_on_the_fly_capabilities(
+        evaluator_set.get("required_runtime_capabilities"),
+        "evaluator-set runtime capabilities",
+    )
+    entries = _records(evaluator_set.get("processes"), "evaluator-set processes")
+    if len(entries) != 1:
+        raise GateError("on-the-fly evaluator set must select exactly one process")
+    entry = entries[0]
+    if (
+        set(entry)
+        != {
+            "process_id",
+            "manifest_path",
+            "required_runtime_capabilities",
+        }
+        or entry.get("process_id") != PROCESS_ID
+    ):
+        raise GateError("on-the-fly evaluator-set process entry is invalid")
+    _exact_on_the_fly_capabilities(
+        entry.get("required_runtime_capabilities"),
+        "evaluator-set process capabilities",
+    )
+    execution_relative = _resolved_artifact_relative(
+        manifest,
+        Path(evaluator_relative).parent,
+        entry.get("manifest_path"),
+        "on-the-fly execution path",
+    )
+    record = _authenticated_json_payload(
+        manifest,
+        execution_relative,
+        role="evaluator-manifest",
+        process_id=PROCESS_ID,
+        label="on-the-fly execution",
+    )
+    _reject_materialization_fields(record, "on-the-fly execution")
+    if set(record) != {
+        "schema_version",
+        "kind",
+        "required_runtime_capabilities",
+        "process",
+        "key",
+        "color_accuracy",
+        "external_pdg_order",
+        "kernel_pack",
+        "runtime_options",
+        "selector_policy",
+        "runtime_metadata",
+        "runtime_container",
+    }:
+        raise GateError("generated on-the-fly execution has non-compact fields")
+    _exact_on_the_fly_capabilities(
+        record.get("required_runtime_capabilities"),
+        "execution runtime capabilities",
+    )
+    container = _mapping(
+        record.get("runtime_container"), "on-the-fly runtime container"
+    )
+    if (
+        record.get("schema_version") != 3
+        or record.get("kind") != "pyamplicol-runtime-on-the-fly-execution"
+        or record.get("process") != expression
+        or record.get("key") != PROCESS_ID
+        or record.get("color_accuracy") != "lc"
+        or tuple(_items(record.get("external_pdg_order"), "external PDG order"))
+        != tuple(process["external_pdgs"])
+        or set(container)
+        != {
+            "kind",
+            "schema_version",
+            "storage_abi",
+            "path",
+            "seed_member_path",
+        }
+        or container.get("kind") != "pyamplicol-on-the-fly-runtime-container"
+        or container.get("schema_version") != 1
+        or container.get("storage_abi") != "pacbin-v1"
+        or container.get("path") != "on-the-fly-runtime.pacbin"
+        or container.get("seed_member_path") != ON_THE_FLY_SEED_MEMBER_PATH
+    ):
+        raise GateError("generated on-the-fly artifact has the wrong compact contract")
+    kernel_pack = _mapping(record.get("kernel_pack"), "on-the-fly kernel pack")
+    if kernel_pack != {
+        "manifest_path": "model/eager-kernel-pack.json",
+        "payload_root": "model/eager-kernels",
+    }:
+        raise GateError("generated on-the-fly kernel-pack paths are not canonical")
+    runtime_options = _mapping(
+        record.get("runtime_options"), "on-the-fly runtime options"
+    )
+    if (
+        set(runtime_options) != {"point_tile_size", "query_construction_threads"}
+        or runtime_options.get("query_construction_threads") != 1
+    ):
+        raise GateError("generated on-the-fly runtime options differ")
+    selector_policy = _mapping(
+        record.get("selector_policy"),
+        "on-the-fly selector policy",
+    )
+    if selector_policy != {
+        "color_coverage": "complete",
+        "reference_color_word": None,
+        "trace_reflections_folded": False,
+        "selector_census": {
+            "physical_helicity_count": 64,
+            "physical_color_flow_count": 12,
+        },
+    }:
+        raise GateError("generated on-the-fly selector census is invalid")
+
+    physics_relative = str(process["physics_path"])
+    public = _authenticated_json_payload(
+        manifest,
+        physics_relative,
+        role="runtime-physics",
+        process_id=PROCESS_ID,
+        label="on-the-fly public metadata",
+    )
+    _reject_materialization_fields(public, "on-the-fly public metadata")
+    if set(public) != {
+        "schema_version",
+        "kind",
+        "process_id",
+        "process",
+        "color_accuracy",
+        "external_particles",
+        "model_parameters",
+    } or (
+        public.get("schema_version") != 1
+        or public.get("kind") != "pyamplicol-on-the-fly-public-metadata"
+        or public.get("process_id") != PROCESS_ID
+        or public.get("process") != expression
+        or public.get("color_accuracy") != "lc"
+    ):
+        raise GateError("generated on-the-fly public metadata is not compact LC")
+
+    validation_relative = f"processes/{PROCESS_ID}/validation-momenta.json"
+    _manifest_payload_record(
+        manifest,
+        validation_relative,
+        role="validation-momenta",
+        process_id=PROCESS_ID,
+    )
+    runtime_relative = _resolved_artifact_relative(
+        manifest,
+        Path(execution_relative).parent,
+        container.get("path"),
+        "on-the-fly runtime container path",
+    )
+    runtime_record = _manifest_payload_record(
+        manifest,
+        runtime_relative,
+        role="evaluator-state",
+        process_id=PROCESS_ID,
+    )
+    process_evaluator_state = tuple(
+        payload
+        for payload in manifest.payloads
+        if payload.role == "evaluator-state" and payload.process_id == PROCESS_ID
+    )
+    if process_evaluator_state != (runtime_record,):
+        raise GateError(
+            "runtime PACBIN must be the sole process-owned evaluator-state payload"
+        )
+
+    expected_inventory = {
+        execution_relative,
+        physics_relative,
+        runtime_relative,
+        validation_relative,
+    }
+    process_prefix = f"processes/{PROCESS_ID}/"
+    authenticated_inventory = {
+        payload.path
+        for payload in manifest.payloads
+        if payload.process_id == PROCESS_ID or payload.path.startswith(process_prefix)
+    }
+    process_root = manifest.root / "processes" / PROCESS_ID
+    try:
+        physical_inventory = {
+            path.relative_to(manifest.root).as_posix()
+            for path in process_root.rglob("*")
+            if path.is_file()
+        }
+    except OSError as error:
+        raise GateError(
+            "cannot inventory generated on-the-fly process files"
+        ) from error
+    if (
+        authenticated_inventory != expected_inventory
+        or physical_inventory != expected_inventory
+    ):
+        unexpected = sorted(
+            (authenticated_inventory | physical_inventory) - expected_inventory
+        )
+        missing = sorted(
+            expected_inventory - (authenticated_inventory & physical_inventory)
+        )
+        raise GateError(
+            "generated on-the-fly process inventory contains materialized sidecars "
+            f"or omissions; unexpected={unexpected!r}, missing={missing!r}"
+        )
+
+    try:
+        runtime_path = confined_path(manifest.root, runtime_relative)
+        with PacbinReader.open(runtime_path, verify_payloads=True) as reader:
+            members = reader.members
+    except (ArtifactError, OSError, PacbinError) as error:
+        raise GateError("cannot authenticate on-the-fly runtime PACBIN") from error
+    if (
+        len(members) != 1
+        or members[0].logical_path != ON_THE_FLY_SEED_MEMBER_PATH
+        or members[0].kind is not PacbinMemberKind.ON_THE_FLY_PROCESS_SEED
+        or members[0].length <= 0
+    ):
+        raise GateError(
+            "on-the-fly runtime PACBIN must contain exactly one process seed"
+        )
+    if (
+        runtime.execution_mode != "on-the-fly"
+        or runtime.representative_process_key != PROCESS_ID
+        or runtime.artifact_id != manifest.artifact_id
+    ):
+        raise GateError("Runtime.load did not select the generated on-the-fly process")
+    return {
+        "artifact": str(manifest.root),
+        "artifact_id": runtime.artifact_id,
+        "execution_mode": runtime.execution_mode,
+        "representative_process_key": runtime.representative_process_key,
+        "execution_kind": record["kind"],
+        "required_runtime_capabilities": ON_THE_FLY_CAPABILITIES,
+        "selector_census": selector_policy["selector_census"],
+        "process_file_inventory": tuple(sorted(expected_inventory)),
+        "process_evaluator_state_payload_count": len(process_evaluator_state),
+        "runtime_container_kind": container["kind"],
+        "runtime_container_authenticated": True,
+        "runtime_container_member_count": len(members),
+        "seed_member_path": container["seed_member_path"],
+        "seed_member_kind": members[0].kind.name,
+        "dense_physics_accessed": False,
+        "validation_boundary": (
+            "authenticated manifest/public/execution metadata and PACBIN followed "
+            "by compact post-build Runtime.load; candidate dense physics metadata "
+            "is never opened"
+        ),
+    }
+
+
+def _on_the_fly_public_profile(
+    runtime: object,
+    points: Points,
+    expected: Sequence[object],
+    *,
+    helicities: tuple[str, ...] = (),
+    flows: tuple[str, ...] = (),
+) -> dict[str, object]:
+    backend = getattr(runtime, "_backend", None)
+    profiler = getattr(backend, "profile", None)
+    if not callable(profiler):
+        raise GateError("public Runtime backend has no existing profile API")
+    payload = profiler(
+        points,
+        helicities=helicities or None,
+        color_flows=flows or None,
+        precision=16,
+        include_values=True,
+    )
+    if (
+        not isinstance(payload, Mapping)
+        or payload.get("execution_mode") != "on-the-fly"
+    ):
+        raise GateError("on-the-fly profile did not report its execution lane")
+    values = payload.get("values")
+    if not isinstance(values, Sequence) or isinstance(values, (str, bytes)):
+        raise GateError("on-the-fly profile omitted requested values")
+    value_check = _series(tuple(values), expected, "on-the-fly profile values")
+    counts: dict[str, int] = {}
+    for name in PUBLIC_PROFILE_WORK_FIELDS:
+        counts[name] = _count(payload.get(name), f"on-the-fly profile {name}")
+    if any(
+        counts[f"recurrence_{role}_call_count"] > counts[f"recurrence_{role}_row_count"]
+        for role in ("source", "contribution", "finalization", "closure")
+    ):
+        raise GateError("on-the-fly profile has more grouped calls than rows")
+    wall = payload.get("wall_time_s")
+    if (
+        isinstance(wall, bool)
+        or not isinstance(wall, (int, float))
+        or not math.isfinite(float(wall))
+        or float(wall) < 0.0
+    ):
+        raise GateError("on-the-fly profile wall clock is invalid")
+    return {
+        "api": "existing Runtime backend profile",
+        "execution_mode": "on-the-fly",
+        "point_count": len(points),
+        "selectors": {"helicities": helicities, "color_flows": flows},
+        "value_check": value_check,
+        "wall_seconds": float(wall),
+        "work": {
+            "basis": "one warmed public profile call",
+            "semantics": (
+                "rows are executed recurrence-style transitions; calls are grouped "
+                "prepared-executor invocations and are not current counts"
+            ),
+            **counts,
+        },
+    }
+
+
+def _workload_operation_census(
+    rows: Sequence[Mapping[str, object]],
+) -> dict[str, object]:
+    sums = {name: 0 for name in OPERATION_COUNT_FIELDS}
+    total = 0
+    for row in rows:
+        census = row.get("work_census")
+        if (
+            not isinstance(census, Mapping)
+            or census.get("work_census_basis") != WORK_CENSUS_BASIS
+        ):
+            raise GateError("timed query has no valid work census")
+        for name in OPERATION_COUNT_FIELDS:
+            value = census.get(name)
+            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                raise GateError("timed query operation census is invalid")
+            sums[name] += value
+        kernel_count = census.get("total_kernel_application_count")
+        if (
+            isinstance(kernel_count, bool)
+            or not isinstance(kernel_count, int)
+            or kernel_count < 0
+        ):
+            raise GateError("timed query kernel-application census is invalid")
+        total += kernel_count
+    if total != sum(sums.values()):
+        raise GateError("workload kernel and operation sums disagree")
+    return {
+        "aggregation_basis": "sum-one-execution-per-serialized-query-v1",
+        "query_census_basis": WORK_CENSUS_BASIS,
+        "query_count": len(rows),
+        **sums,
+        "total_kernel_application_count": total,
+    }
+
+
+def _query_family_census(
+    probe: Callable[..., dict[str, Any]],
+    retained: RetainedInputs,
+    queries: Sequence[Query],
+    hidden_timing: Mapping[str, object],
+    enable_color_projection: bool,
+) -> dict[str, object]:
+    if not queries:
+        raise GateError("query-family census needs at least one query")
+    raw = probe(
+        retained.builder,
+        retained.template,
+        retained.direct_json,
+        retained.pack_digest,
+        [query.flow_index for query in queries],
+        [list(query.helicities) for query in queries],
+        enable_color_projection=enable_color_projection,
+    )
+    if not isinstance(raw, Mapping):
+        raise GateError("native query-family census is not a mapping")
+    counts: dict[str, int] = {}
+    for name in FAMILY_CENSUS_COUNT_FIELDS:
+        value = raw.get(name)
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise GateError(f"native query-family census has invalid {name}")
+        counts[name] = value
+    if counts["query_count"] != len(queries):
+        raise GateError("native query-family census has the wrong query count")
+    if not 0 < counts["source_frame_partition_count"] <= len(queries):
+        raise GateError(
+            "native query-family census has invalid source-frame partitions"
+        )
+
+    rows = hidden_timing.get("queries")
+    operation_census = hidden_timing.get("workload_operation_census")
+    if (
+        not isinstance(rows, Sequence)
+        or isinstance(rows, (str, bytes))
+        or not isinstance(operation_census, Mapping)
+    ):
+        raise GateError("timed workload has no query-local census")
+    current_occurrences = 0
+    component_occurrences = 0
+    for row in rows:
+        if not isinstance(row, Mapping) or not isinstance(
+            row.get("work_census"), Mapping
+        ):
+            raise GateError("timed workload query has no work census")
+        work = row["work_census"]
+        for name, target in (
+            ("logical_current_count", "current"),
+            ("resident_current_component_count", "component"),
+        ):
+            value = work.get(name)
+            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                raise GateError(f"timed workload has invalid {target} census")
+            if name == "logical_current_count":
+                current_occurrences += value
+            else:
+                component_occurrences += value
+    expected_rows = {
+        "dynamic_source_rows": "source_operation_count",
+        "dynamic_contribution_rows": "contribution_operation_count",
+        "dynamic_finalization_rows": "finalization_operation_count",
+        "dynamic_closure_rows": "closure_operation_count",
+    }
+    if (
+        counts["dynamic_current_occurrence_count"] != current_occurrences
+        or counts["dynamic_current_component_occurrence_count"] != component_occurrences
+        or any(
+            counts[native] != operation_census.get(query_local)
+            for native, query_local in expected_rows.items()
+        )
+        or counts["projection_post_current_count"] != current_occurrences
+        or counts["projection_post_contribution_count"]
+        != counts["dynamic_contribution_rows"]
+        or counts["projection_post_closure_count"] != counts["dynamic_closure_rows"]
+    ):
+        raise GateError(
+            "native query-family census disagrees with independently timed query traces"
+        )
+    for role in ("source", "contribution", "finalization", "closure"):
+        if counts[f"dynamic_{role}_calls"] != counts[f"dynamic_{role}_rows"]:
+            raise GateError("query-local dynamic call census is inconsistent")
+        if counts[f"union_{role}_executor_call_groups"] > counts[f"union_{role}_rows"]:
+            raise GateError("query-family executor groups outnumber union rows")
+    if (
+        counts["union_amplitude_destination_count"] != len(queries)
+        or counts["union_unique_current_count"] > current_occurrences
+        or counts["union_unique_current_component_count"] > component_occurrences
+        or any(
+            counts[f"union_{role}_rows"] > counts[f"dynamic_{role}_rows"]
+            for role in ("source", "contribution", "finalization", "closure")
+        )
+    ):
+        raise GateError("query-family union census does not bound query-local work")
+    return {
+        "basis": "exact-current-core-key-query-family-union-v1",
+        "semantics": (
+            "dynamic counts sum today's independently executed query-local traces; "
+            "union counts intern exact semantic currents/interactions within each "
+            "authenticated source-frame partition while retaining one amplitude "
+            "destination per requested query"
+        ),
+        **counts,
+    }
+
+
+def _assert_executable_family_matches_structural_census(
+    executable: Mapping[str, object], structural: Mapping[str, object]
+) -> None:
+    for name in FAMILY_CENSUS_COUNT_FIELDS:
+        if executable.get(name) != structural.get(name):
+            raise GateError(
+                f"executable family census disagrees with the independent structural "
+                f"census for {name}"
+            )
+
+
+def _mapping(value: object, label: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise GateError(f"{label} is not a mapping")
+    return value
+
+
+def _items(value: object, label: str) -> tuple[object, ...]:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        raise GateError(f"{label} is not a sequence")
+    return tuple(value)
+
+
+def _records(value: object, label: str) -> tuple[Mapping[str, object], ...]:
+    return tuple(
+        _mapping(item, f"{label}[{index}]")
+        for index, item in enumerate(_items(value, label))
+    )
+
+
+def _count(value: object, label: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise GateError(f"{label} is not a non-negative integer")
+    return value
+
+
+def _field(value: object, name: str) -> object:
+    if isinstance(value, Mapping):
+        return value.get(name)
+    return getattr(value, name, None)
+
+
+def _artifact_execution(
+    artifact: Path,
+    execution_mode: str,
+    runtime: object | None = None,
+) -> tuple[object, Mapping[str, object], Path]:
+    try:
+        root = artifact.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise GateError(f"comparator artifact does not exist: {artifact}") from error
+    if not root.is_dir():
+        raise GateError(f"comparator artifact is not a directory: {root}")
+    if runtime is None:
+        runtime = Runtime.load(root)
+    physics = _validate_comparator_physics(runtime, execution_mode, str(root))
+    process_id = physics.process_id
+    path = root / "processes" / process_id / "execution.json"
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (
+        OSError,
+        UnicodeDecodeError,
+        json.JSONDecodeError,
+    ) as error:
+        raise GateError(f"cannot read comparator execution record: {path}") from error
+    return runtime, _mapping(payload, "comparator execution record"), root
+
+
+def _validate_comparator_physics(
+    runtime: object, execution_mode: str, label: str
+) -> object:
+    physics = runtime.physics
+    process = getattr(physics, "process", None)
+    process_id = getattr(physics, "process_id", None)
+    color_accuracy = getattr(physics, "color_accuracy", None)
+    external_pdgs: list[int] = []
+    for index, particle in enumerate(getattr(physics, "external_particles", ())):
+        pdg_id = _field(particle, "pdg_id")
+        if isinstance(pdg_id, bool) or not isinstance(pdg_id, int):
+            raise GateError(
+                f"{label} external particle {index} has an invalid PDG ID: {pdg_id!r}"
+            )
+        external_pdgs.append(pdg_id)
+    if runtime.execution_mode != execution_mode or color_accuracy != "lc":
+        raise GateError(f"{label} is not an LC {execution_mode} authority")
+    if (
+        not isinstance(process, str)
+        or process != PROCESS
+        or canonical_process_key(process) != PROCESS_KEY
+        or process_id != PROCESS_ID
+    ):
+        raise GateError(
+            f"{label} has the wrong canonical process identity: {process!r}"
+        )
+    if tuple(external_pdgs) != EXTERNAL_PDGS:
+        raise GateError(
+            f"{label} has the wrong external PDG ordering: {tuple(external_pdgs)!r}"
+        )
+    return physics
+
+
+def _recurrence_counts(
+    record: Mapping[str, object],
+    *,
+    components: object | None = None,
+    destinations: object | None = None,
+    certificate: bool = False,
+) -> dict[str, int]:
+    closure_key = "closure_count" if certificate else "closure_term_count"
+    result = {
+        "source_row_count": _count(
+            record.get("source_row_count"), "recurrence source-row count"
+        ),
+        "current_count": _count(
+            record.get("current_count"), "recurrence current count"
+        ),
+        "semantic_current_component_count": _count(
+            (
+                record.get("semantic_component_count")
+                if components is None
+                else components
+            ),
+            "recurrence semantic-component count",
+        ),
+        "contribution_count": _count(
+            record.get("contribution_count"), "recurrence contribution count"
+        ),
+        "finalization_count": _count(
+            record.get("finalization_count"), "recurrence finalization count"
+        ),
+        "closure_count": _count(record.get(closure_key), "recurrence closure count"),
+        "amplitude_destination_count": _count(
+            (
+                record.get("amplitude_destination_count")
+                if destinations is None
+                else destinations
+            ),
+            "recurrence amplitude-destination count",
+        ),
+    }
+    if result["semantic_current_component_count"] < result["current_count"]:
+        raise GateError("recurrence has fewer components than currents")
+    result["kernel_row_count"] = sum(
+        result[name]
+        for name in (
+            "source_row_count",
+            "contribution_count",
+            "finalization_count",
+            "closure_count",
+        )
+    )
+    if certificate and result["kernel_row_count"] != _count(
+        record.get("row_count"), "recurrence certificate row count"
+    ):
+        raise GateError("recurrence certificate row count is inconsistent")
+    return result
+
+
+def _exact_public_index(records: object, selector_id: str, label: str) -> int:
+    matches = [
+        record for record in records if getattr(record, "id", None) == selector_id
+    ]
+    if len(matches) != 1:
+        raise GateError(f"{label} selector {selector_id!r} is absent or ambiguous")
+    index = getattr(matches[0], "index", None)
+    if isinstance(index, bool) or not isinstance(index, int) or index < 0:
+        raise GateError(f"{label} selector {selector_id!r} has an invalid public index")
+    return index
+
+
+def _recurrence_artifact_census(
+    artifact: Path, *, layout: str, runtime: object | None = None
+) -> dict[str, object]:
+    runtime, payload, root = _artifact_execution(artifact, "recurrence", runtime)
+    if payload.get("kind") != "pyamplicol-runtime-recurrence-execution":
+        raise GateError("recurrence comparator has the wrong execution kind")
+    summary = _mapping(payload.get("recurrence_summary"), "recurrence summary")
+    plan = _mapping(payload.get("plan"), "recurrence plan")
+    inspection = _mapping(plan.get("inspection_summary"), "recurrence inspection")
+    if inspection.get("lc_flow_layout") != layout:
+        raise GateError(f"recurrence comparator is not {layout!r}")
+    schedule = _mapping(inspection.get("schedule"), "recurrence schedule")
+    arena = _mapping(inspection.get("direct_arena"), "recurrence direct arena")
+    whole = _recurrence_counts(
+        schedule, components=arena.get("semantic_component_count")
+    )
+    if (
+        summary.get("current_count") != whole["current_count"]
+        or summary.get("contribution_count") != whole["contribution_count"]
+        or summary.get("closure_term_count") != whole["closure_count"]
+    ):
+        raise GateError("recurrence schedule summaries disagree")
+    certificate = _mapping(
+        inspection.get("selector_work_certificate"),
+        "recurrence selector-work certificate",
+    )
+    union = _recurrence_counts(
+        _mapping(certificate.get("persisted_union"), "recurrence persisted union"),
+        destinations=whole["amplitude_destination_count"],
+        certificate=True,
+    )
+    if union != whole:
+        raise GateError("recurrence whole schedule and persisted union disagree")
+
+    physics = runtime.physics
+    if layout == "topology-replay":
+        public_index = _exact_public_index(
+            physics.color_flows, FLOW_ID, "recurrence color-flow"
+        )
+        metadata = _mapping(payload.get("runtime_metadata"), "recurrence metadata")
+        public_flows = _records(
+            metadata.get("public_color_flows"), "recurrence public color flows"
+        )
+        bindings = [
+            record for record in public_flows if record.get("public_id") == FLOW_ID
+        ]
+        if len(bindings) != 1:
+            raise GateError("recurrence color-flow binding is absent or ambiguous")
+        target_sector = _count(
+            bindings[0].get("target_sector_id"), "recurrence target sector"
+        )
+        if target_sector != public_index:
+            raise GateError(
+                "recurrence public color-flow index and target sector differ"
+            )
+        representatives = _records(
+            certificate.get("representatives"), "recurrence representatives"
+        )
+        selected = [
+            record
+            for record in representatives
+            if record.get("representative_sector_id") == target_sector
+        ]
+        if len(selected) != 1:
+            raise GateError(
+                "recurrence selected-flow certificate is absent or ambiguous"
+            )
+        live = _recurrence_counts(selected[0], certificate=True)
+        selector = {
+            "kind": "exact_public_color_flow_index",
+            "id": FLOW_ID,
+            "public_index": public_index,
+            "representative_sector_id": target_sector,
+        }
+    else:
+        public_index = _exact_public_index(
+            physics.helicities, HELICITY_ID, "recurrence helicity"
+        )
+        representatives = _records(
+            certificate.get("representatives"), "recurrence representatives"
+        )
+        if representatives:
+            raise GateError("all-flow-union recurrence certificate has alternatives")
+        live = union
+        selector = {
+            "kind": "exact_public_helicity_index",
+            "id": HELICITY_ID,
+            "public_index": public_index,
+        }
+    return {
+        "artifact": str(root),
+        "artifact_id": runtime.artifact_id,
+        "layout": layout,
+        "basis": "authenticated-persisted-recurrence-selector-certificate-v1",
+        "selector": selector,
+        "whole": whole,
+        "selector_live": live,
+        "semantics": (
+            "whole is the persisted recurrence DirectPlan; selector_live is the "
+            "authenticated exact-selector certificate and is not inferred from "
+            "runtime timing counters"
+        ),
+    }
+
+
+def _compiled_execution_counts(
+    execution: Mapping[str, object], label: str
+) -> dict[str, int]:
+    if execution.get("kind") != "pyamplicol-runtime-execution":
+        raise GateError(f"{label} has the wrong execution kind")
+    summary = _mapping(execution.get("dag_summary"), f"{label} DAG summary")
+    schema = _mapping(execution.get("runtime_schema"), f"{label} runtime schema")
+    storage = _mapping(schema.get("current_storage"), f"{label} current storage")
+    result = {
+        "source_count": _count(summary.get("source_count"), f"{label} source count"),
+        "current_count": _count(summary.get("current_count"), f"{label} current count"),
+        "current_component_count": _count(
+            storage.get("component_count"), f"{label} component count"
+        ),
+        "interaction_attachment_count": _count(
+            summary.get("interaction_count"), f"{label} interaction count"
+        ),
+        "interaction_evaluation_count": _count(
+            summary.get("interaction_evaluation_count"),
+            f"{label} interaction-evaluation count",
+        ),
+        "amplitude_root_count": _count(
+            summary.get("amplitude_root_count"), f"{label} amplitude-root count"
+        ),
+    }
+    if result["current_component_count"] < result["current_count"]:
+        raise GateError(f"{label} has fewer components than currents")
+    if result["interaction_evaluation_count"] > result["interaction_attachment_count"]:
+        raise GateError(f"{label} evaluates more interactions than it attaches")
+    return result
+
+
+def _compiled_artifact_census(
+    artifact: Path, *, workload: str, runtime: object | None = None
+) -> dict[str, object]:
+    runtime, payload, root = _artifact_execution(artifact, "compiled", runtime)
+    primary = _compiled_execution_counts(payload, "compiled primary")
+    physics = runtime.physics
+    if workload == "selected_flow_helicity_sum":
+        public_index = _exact_public_index(
+            physics.color_flows, FLOW_ID, "compiled color-flow"
+        )
+        compiled = _mapping(payload.get("compiled"), "compiled metadata")
+        topology = _mapping(
+            compiled.get("lc_topology_replay"), "compiled topology replay"
+        )
+        matches = [
+            record
+            for record in _records(topology.get("groups"), "compiled topology groups")
+            if public_index
+            in tuple(
+                _count(value, "compiled active sector")
+                for value in _items(record.get("active_sector_ids"), "active sectors")
+            )
+        ]
+        if len(matches) != 1:
+            raise GateError("compiled color-flow topology group is absent or ambiguous")
+        materialized_sector = _count(
+            matches[0].get("materialized_sector_id"),
+            "compiled materialized sector",
+        )
+        program_record = _mapping(
+            payload.get("helicity_sum_execution"), "compiled helicity-sum program"
+        )
+        reductions = _mapping(
+            program_record.get("physics_reduction"),
+            "compiled helicity-sum physics reduction",
+        )
+        reduction_groups = _records(
+            reductions.get("groups"), "compiled physics-reduction groups"
+        )
+        if not any(
+            FLOW_ID in tuple(record.get("physical_color_ids", ()))
+            for record in reduction_groups
+        ):
+            raise GateError(
+                "compiled helicity-sum program does not bind the exact flow"
+            )
+        children = _records(
+            program_record.get("color_selector_executions"),
+            "compiled color-selector executions",
+        )
+        selected = [
+            record
+            for record in children
+            if record.get("materialized_sector_id") == materialized_sector
+        ]
+        if len(selected) != 1:
+            raise GateError("compiled selected-flow child is absent or ambiguous")
+        leaf_record = _mapping(selected[0].get("execution"), "compiled selected leaf")
+        levels: dict[str, object] = {
+            "primary": primary,
+            "program": _compiled_execution_counts(
+                program_record, "compiled helicity-sum program"
+            ),
+            "executed_leaf": _compiled_execution_counts(
+                leaf_record, "compiled selected-flow leaf"
+            ),
+        }
+        selector = {
+            "kind": "exact_public_color_flow_index",
+            "id": FLOW_ID,
+            "public_index": public_index,
+            "materialized_sector_id": materialized_sector,
+        }
+    elif workload == "all_flow_single_helicity":
+        public_index = _exact_public_index(
+            physics.helicities, HELICITY_ID, "compiled helicity"
+        )
+        current = payload
+        depth = 0
+        while "helicity_selector_executions" in current:
+            children = _records(
+                current.get("helicity_selector_executions"),
+                "compiled helicity-selector executions",
+            )
+            matching = [
+                record
+                for record in children
+                if public_index
+                in tuple(
+                    _count(value, "compiled selector-domain index")
+                    for value in _items(
+                        record.get("selector_domain_ids"),
+                        "compiled selector-domain indices",
+                    )
+                )
+            ]
+            if len(matching) != 1:
+                raise GateError(
+                    "compiled helicity-selector child is absent or ambiguous"
+                )
+            current = _mapping(
+                matching[0].get("execution"), "compiled helicity-selector child"
+            )
+            depth += 1
+        if depth == 0:
+            raise GateError("compiled all-flow artifact has no selector execution")
+        levels = {
+            "primary": primary,
+            "executed_leaf": _compiled_execution_counts(
+                current, "compiled all-flow executed leaf"
+            ),
+        }
+        selector = {
+            "kind": "exact_public_helicity_index",
+            "id": HELICITY_ID,
+            "public_index": public_index,
+            "selector_depth": depth,
+        }
+    else:
+        raise GateError(f"unknown compiled census workload: {workload}")
+    return {
+        "artifact": str(root),
+        "artifact_id": runtime.artifact_id,
+        "basis": "authenticated-exact-child-compiled-generic-dag-v1",
+        "workload": workload,
+        "selector": selector,
+        "levels": levels,
+        "semantics": (
+            "GenericDAG counts are reported independently for the outer primary, "
+            "an enclosing program where present, and the one exact executed leaf; "
+            "alternative compiled nodes are never summed, and these attachment/"
+            "evaluation counts are not asserted equal to recurrence or on-the-fly rows"
+        ),
+    }
+
+
+def _hidden_timing(
+    probe: Callable[..., dict[str, Any]],
+    artifact: Path,
+    retained: RetainedInputs,
+    queries: Sequence[Query],
+    points: Points,
+    target: float,
+    enable_color_projection: bool = True,
+) -> dict[str, object]:
+    if not queries:
+        raise GateError("workload has no physical queries")
+    invoke = partial(
+        _invoke,
+        probe,
+        artifact,
+        retained,
+        points=points,
+        enable_color_projection=enable_color_projection,
+    )
+    pilot_seconds = 0.0
+    pilot_census: dict[Query, dict[str, object]] = {}
+    for query in queries:
+        report = invoke(query, repetitions=1)
+        _probe_values(report, len(points), 1)
+        pilot_census[query] = _work_census(report)
+        pilot_seconds += float(report["benchmark_elapsed_seconds"])
+    repetitions = _calibrate(pilot_seconds, target)
+    rows = []
+    for query in queries:
+        report = invoke(query, repetitions=repetitions)
+        _probe_values(report, len(points), repetitions)
+        work_census = _work_census(report)
+        if work_census != pilot_census[query]:
+            raise GateError("query work census changed between benchmark passes")
+        rows.append(
+            {
+                "query": query.label,
+                "trace_digest": report.get("trace_digest"),
+                "elapsed_seconds": report["benchmark_elapsed_seconds"],
+                "seconds_per_point": report["benchmark_seconds_per_point"],
+                "trace_build_count": 1,
+                "trace_cache_hit_count": WARMUPS + repetitions,
+                "momentum_fill_count": WARMUPS + repetitions,
+                "work_census": work_census,
+            }
+        )
+    return {
+        "query_count": len(rows),
+        "pilot_aggregate_seconds": pilot_seconds,
+        "warmups": WARMUPS,
+        "repetitions": repetitions,
+        "aggregate_elapsed_seconds": math.fsum(
+            float(row["elapsed_seconds"]) for row in rows
+        ),
+        "additive_seconds_per_point": math.fsum(
+            float(row["seconds_per_point"]) for row in rows
+        ),
+        "queries": rows,
+        "workload_operation_census": _workload_operation_census(rows),
+        "timer_includes": (
+            "trace-cache lookup",
+            "momentum fill",
+            "structural-trace execution",
+        ),
+        "timer_excludes": (
+            "artifact/pack load",
+            "trace construction",
+            "parameter/workspace setup",
+            "source-major conversion",
+            "normalization/output/Python conversion",
+        ),
+        "acceptance_gate": False,
+    }
+
+
+def _hidden_family_timing(
+    probe: Callable[..., dict[str, Any]],
+    artifact: Path,
+    retained: RetainedInputs,
+    queries: Sequence[Query],
+    points: Points,
+    target: float,
+    enable_color_projection: bool = True,
+) -> tuple[dict[str, object], dict[str, object]]:
+    if not queries:
+        raise GateError("family workload has no physical queries")
+    invoke = partial(
+        _invoke,
+        probe,
+        artifact,
+        retained,
+        queries[0],
+        points,
+        enable_color_projection=enable_color_projection,
+        query_family=queries,
+    )
+    pilot = _family_probe_result(invoke(repetitions=1), queries, len(points), 1)
+    pilot_elapsed = pilot.get("private_warmed_elapsed_seconds")
+    if not isinstance(pilot_elapsed, (int, float)):
+        raise GateError("family pilot omitted its warmed elapsed time")
+    repetitions = _calibrate(float(pilot_elapsed), target)
+    measured = _family_probe_result(
+        invoke(repetitions=repetitions), queries, len(points), repetitions
+    )
+    if measured["census"] != pilot["census"]:
+        raise GateError("family union census changed between benchmark passes")
+    return measured, {
+        "query_count": len(queries),
+        "pilot_seconds": float(pilot_elapsed),
+        "warmups": WARMUPS,
+        "repetitions": repetitions,
+        "cold_prepare_seconds": measured["cold_prepare_seconds"],
+        "private_warmed_elapsed_seconds": measured["private_warmed_elapsed_seconds"],
+        "private_warmed_seconds_per_point": measured[
+            "private_warmed_seconds_per_point"
+        ],
+        "clock_attribution": {
+            "private_warmed_seconds_per_point": (
+                "on-the-fly private query-family execution clock"
+            ),
+            "relationship": (
+                "independent of recurrence core, recurrence wall, and AmpliCol wall"
+            ),
+        },
+        "private_timing_excludes_source_crossing": True,
+        "work_census_basis": FAMILY_WORK_CENSUS_BASIS,
+        "work_census": measured["census"],
+        "total_kernel_application_count": measured[
+            "union_total_kernel_application_count"
+        ],
+        "timer_includes": (
+            "shared source fill",
+            "one grouped union execution",
+            "flat caller-output write",
+        ),
+        "timer_excludes": (
+            "artifact/pack load",
+            "query construction",
+            "family preparation",
+            "parameter/workspace setup",
+            "source-major crossing",
+            "normalization/Python conversion",
+        ),
+        "timing_status": "private-provisional",
+        "acceptance_gate": False,
+    }
+
+
+def _hidden_family_correctness(
+    probe: Callable[..., dict[str, Any]],
+    artifact: Path,
+    retained: RetainedInputs,
+    queries: Sequence[Query],
+    points: Points,
+    normalized_authority: Sequence[Sequence[object]],
+    query_local_reports: Sequence[Mapping[str, object]],
+    enable_color_projection: bool = True,
+) -> tuple[tuple[tuple[float, ...], ...], dict[str, object]]:
+    if (
+        not queries
+        or len(queries) != len(normalized_authority)
+        or len(queries) != len(query_local_reports)
+    ):
+        raise GateError("family correctness inputs have incompatible query axes")
+    report = _invoke(
+        probe,
+        artifact,
+        retained,
+        queries[0],
+        points,
+        enable_color_projection=enable_color_projection,
+        query_family=queries,
+    )
+    parsed = _family_probe_result(report, queries, len(points))
+    parsed_rows = parsed["queries"]
+    if not isinstance(parsed_rows, Sequence):
+        raise GateError("family correctness report lost its query rows")
+    normalized_checks: list[dict[str, object]] = []
+    raw_real_checks: list[dict[str, object]] = []
+    raw_imag_checks: list[dict[str, object]] = []
+    normalized_rows: list[tuple[float, ...]] = []
+    for query, row, authority, query_local in zip(
+        queries,
+        parsed_rows,
+        normalized_authority,
+        query_local_reports,
+        strict=True,
+    ):
+        if not isinstance(row, Mapping):
+            raise GateError("family correctness row is malformed")
+        normalized = row.get("normalized_values")
+        raw = row.get("raw_amplitudes")
+        local_raw = query_local.get("raw_amplitudes")
+        if (
+            not isinstance(normalized, Sequence)
+            or not isinstance(raw, Sequence)
+            or not isinstance(local_raw, Sequence)
+            or len(raw) != len(local_raw)
+        ):
+            raise GateError("family correctness row is incomplete")
+        normalized_tuple = tuple(_real(value, "family value") for value in normalized)
+        normalized_rows.append(normalized_tuple)
+        normalized_checks.append(
+            _series(normalized_tuple, authority, f"{query.label} family/public")
+        )
+        family_complex = tuple(complex(value) for value in raw)
+        local_complex = tuple(
+            complex(
+                _real(value[0], "local raw real"),
+                _real(value[1], "local raw imag"),
+            )
+            for value in local_raw
+            if isinstance(value, Sequence)
+            and not isinstance(value, (str, bytes))
+            and len(value) == 2
+        )
+        if len(local_complex) != len(family_complex):
+            raise GateError("query-local raw amplitude row is malformed")
+        raw_real_checks.append(
+            _series(
+                tuple(value.real for value in family_complex),
+                tuple(value.real for value in local_complex),
+                f"{query.label} family/query-local raw real",
+            )
+        )
+        raw_imag_checks.append(
+            _series(
+                tuple(value.imag for value in family_complex),
+                tuple(value.imag for value in local_complex),
+                f"{query.label} family/query-local raw imaginary",
+            )
+        )
+    return tuple(normalized_rows), {
+        "normalized_component_checks": _summaries(normalized_checks),
+        "raw_real_component_checks": _summaries(raw_real_checks),
+        "raw_imaginary_component_checks": _summaries(raw_imag_checks),
+        "work_census_basis": FAMILY_WORK_CENSUS_BASIS,
+        "work_census": parsed["census"],
+        "total_kernel_application_count": parsed[
+            "union_total_kernel_application_count"
+        ],
+    }
+
+
+def _anchor(path: Path | None) -> dict[str, object]:
+    if path is None:
+        return {"available": False, "comparison_performed": False}
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        validation = payload["validation"]
+        selector = payload["selector_contract"]
+        common = validation["lc_common_component"]
+    except (
+        OSError,
+        UnicodeDecodeError,
+        json.JSONDecodeError,
+        KeyError,
+        TypeError,
+    ) as error:
+        raise GateError(f"cannot read AmpliCol context record: {path}") from error
+    if payload.get("status") != "ok":
+        raise GateError("AmpliCol context is not a successful record")
+    try:
+        selector_matches = (
+            tuple(selector.get("selected_color_flow_ids", ())) == (FLOW_ID,)
+            and tuple(map(tuple, selector.get("selected_color_words", ())))
+            == (FLOW_WORD,)
+            and tuple(common.get("helicity_ids", ())) == (HELICITY_ID,)
+            and tuple(common.get("color_flow_ids", ())) == (FLOW_ID,)
+        )
+    except TypeError:
+        selector_matches = False
+    return {
+        "available": True,
+        "path": str(path.resolve(strict=True)),
+        "cell_id": common.get("cell_id"),
+        "point_digest": common.get("point_digest"),
+        "component": common.get("value"),
+        "selected_flow_sum": payload.get("matrix_element"),
+        "execution_seconds_per_point": payload.get("execution_seconds_per_point"),
+        "wall_seconds_per_point": payload.get("wall_seconds_per_point"),
+        "clock_attribution": {
+            "execution_seconds_per_point": (
+                "stored original-AmpliCol direct execution clock"
+            ),
+            "wall_seconds_per_point": "stored original-AmpliCol worker wall clock",
+            "relationship": (
+                "independent clocks; equality is neither assumed nor asserted, and "
+                "both are independent of pyAmpliCol/on-the-fly clocks"
+            ),
+        },
+        "selector_matches": selector_matches,
+        "comparison_performed": False,
+    }
+
+
+def _anchor_checks(
+    context: Mapping[str, object],
+    digest: str,
+    *,
+    public_component: object,
+    hidden_component: object,
+    public_sum: object,
+    hidden_sum: object,
+) -> dict[str, object]:
+    result = dict(context)
+    result["generated_point_digest"] = digest
+    if not context.get("available"):
+        return result
+    if context.get("cell_id") != AMPICOL_CELL_ID:
+        result["reason"] = "cell identity differs; historical result is context only"
+        return result
+    if context.get("selector_matches") is not True:
+        result["reason"] = (
+            "selector identity differs; historical result is context only"
+        )
+        return result
+    if context.get("point_digest") != digest:
+        result["reason"] = "point digest differs; historical result is context only"
+        return result
+    result.update(
+        {
+            "comparison_performed": True,
+            "public_component": _series(
+                (public_component,),
+                (context["component"],),
+                "public/AmpliCol component",
+                AMPICOL_REL_TOL,
+            ),
+            "hidden_component": _series(
+                (hidden_component,),
+                (context["component"],),
+                "on-the-fly/AmpliCol component",
+                AMPICOL_REL_TOL,
+            ),
+            "public_selected_flow_sum": _series(
+                (public_sum,),
+                (context["selected_flow_sum"],),
+                "public/AmpliCol selected-flow sum",
+                AMPICOL_REL_TOL,
+            ),
+            "hidden_selected_flow_sum": _series(
+                (hidden_sum,),
+                (context["selected_flow_sum"],),
+                "on-the-fly/AmpliCol selected-flow sum",
+                AMPICOL_REL_TOL,
+            ),
+        }
+    )
+    return result
+
+
+def _benchmark_runtime(
+    runtime: object,
+    execution_mode: str,
+    points: Points,
+    target: float,
+    batch: int,
+    *,
+    helicities: tuple[str, ...] = (),
+    flows: tuple[str, ...] = (),
+) -> dict[str, object]:
+    result = BenchmarkRunner(
+        _benchmark_config(target, batch, helicities=helicities, flows=flows)
+    ).run(runtime, points=points)
+    timing = _public_timing(result, execution_mode)
+    wall = float(timing["wall_seconds_per_point"])
+    if not math.isfinite(wall) or wall <= 0.0:
+        raise GateError(f"public {execution_mode} benchmark has non-positive wall time")
+    return timing
+
+
+def _run_public_gate_phase(
+    artifact: Path,
+    recurrence_selected_artifact: Path,
+    recurrence_all_flow_artifact: Path,
+    target: float,
+    batch: int,
+) -> PublicGatePhase:
+    started = time.perf_counter()
+    runtime = Runtime.load(artifact, process=PROCESS_ID)
+    load_seconds = time.perf_counter() - started
+    artifact_contract = _on_the_fly_artifact_contract(artifact, runtime)
+
+    selected_recurrence_runtime = Runtime.load(recurrence_selected_artifact)
+    all_flow_recurrence_runtime = Runtime.load(recurrence_all_flow_artifact)
+    authorities = (
+        ("selected recurrence", selected_recurrence_runtime, "recurrence"),
+        ("all-flow recurrence", all_flow_recurrence_runtime, "recurrence"),
+    )
+    comparator_selectors: list[tuple[str, tuple[object, object]]] = []
+    for label, authority, expected_mode in authorities:
+        physics = _validate_comparator_physics(authority, expected_mode, label)
+        comparator_selectors.append((label, _selectors(physics)))
+
+    points = _points()
+    correctness = _recurrence_authority_correctness(
+        runtime,
+        selected_recurrence_runtime,
+        all_flow_recurrence_runtime,
+        points,
+    )
+
+    # This block is deliberately after the complete before/after-clear public
+    # authority gate.  A mismatch must not produce profile or timing evidence.
+    public_profiles = {
+        "selected_flow_helicity_sum": _on_the_fly_public_profile(
+            runtime,
+            points,
+            correctness.on_the_fly_selected.total,
+            flows=(FLOW_ID,),
+        ),
+        "all_flow_single_helicity": _on_the_fly_public_profile(
+            runtime,
+            points,
+            correctness.on_the_fly_all_flow.total,
+            helicities=(HELICITY_ID,),
+        ),
+    }
+    timing_points = _repeat(points, batch)
+    timings = {
+        "on_the_fly": {
+            "selected_flow_helicity_sum": _benchmark_runtime(
+                runtime,
+                "on-the-fly",
+                timing_points,
+                target,
+                batch,
+                flows=(FLOW_ID,),
+            ),
+            "all_flow_single_helicity": _benchmark_runtime(
+                runtime,
+                "on-the-fly",
+                timing_points,
+                target,
+                batch,
+                helicities=(HELICITY_ID,),
+            ),
+        },
+        "recurrence": {
+            "selected_flow_helicity_sum": _benchmark_runtime(
+                selected_recurrence_runtime,
+                "recurrence",
+                timing_points,
+                target,
+                batch,
+                flows=(FLOW_ID,),
+            ),
+            "all_flow_single_helicity": _benchmark_runtime(
+                all_flow_recurrence_runtime,
+                "recurrence",
+                timing_points,
+                target,
+                batch,
+                helicities=(HELICITY_ID,),
+            ),
+        },
+    }
+    return PublicGatePhase(
+        runtime=runtime,
+        selected_recurrence_runtime=selected_recurrence_runtime,
+        all_flow_recurrence_runtime=all_flow_recurrence_runtime,
+        comparator_selectors=tuple(comparator_selectors),
+        points=points,
+        timing_points=timing_points,
+        correctness=correctness,
+        artifact_contract=artifact_contract,
+        load_seconds=load_seconds,
+        public_profiles=public_profiles,
+        timings=timings,
+    )
+
+
+def _run(
+    output: Path,
+    prepared_model: Path,
+    amplicol: Path | None,
+    recurrence_selected_artifact: Path,
+    recurrence_all_flow_artifact: Path,
+    target: float,
+    batch: int,
+    enable_color_projection: bool = True,
+) -> dict[str, object]:
+    artifact = output / "artifact"
+    with tempfile.TemporaryDirectory(
+        prefix=".on-the-fly-private-probe-", dir=output
+    ) as probe_directory:
+        probe_carrier = Path(probe_directory) / "recurrence-artifact"
+        (
+            generation_seconds,
+            generation_census,
+            model,
+            prepared_path,
+            prepared_load_seconds,
+        ) = _generate_candidate_with_prepared_model(artifact, prepared_model)
+        public = _run_public_gate_phase(
+            artifact,
+            recurrence_selected_artifact,
+            recurrence_all_flow_artifact,
+            target,
+            batch,
+        )
+        runtime = public.runtime
+        selected_recurrence_runtime = public.selected_recurrence_runtime
+        all_flow_recurrence_runtime = public.all_flow_recurrence_runtime
+        points = public.points
+        timing_points = public.timing_points
+        correctness = public.correctness
+        artifact_contract = public.artifact_contract
+        load_seconds = public.load_seconds
+        public_profiles = public.public_profiles
+        timings = public.timings
+
+        # The default lane creates its private carrier only after the complete
+        # public correctness/profile/timing phase has passed.  The provisional
+        # public-only lane never reaches this call.
+        retained = _generate_probe_carrier(probe_carrier, model)
+        probe_runtime = Runtime.load(probe_carrier, process=PROCESS_ID)
+        if probe_runtime.execution_mode != "recurrence":
+            raise GateError("private probe carrier is not a recurrence artifact")
+        fixed_flow, fixed_helicity = _selectors(probe_runtime.physics)
+        for label, (flow, helicity) in public.comparator_selectors:
+            if flow.id != fixed_flow.id or helicity.id != fixed_helicity.id:
+                raise GateError(
+                    f"probe carrier and {label} authority disagree on public IDs"
+                )
+        selected_authority = correctness.recurrence_selected.total
+        all_authority = correctness.recurrence_all_flow.total
+        selected_resolved = correctness.recurrence_selected.resolved
+        all_resolved = correctness.recurrence_all_flow.resolved
+        selected_public = correctness.on_the_fly_selected.total
+        selected_public_resolved = correctness.on_the_fly_selected.resolved
+        public_correctness = correctness.public_correctness
+        clear_checks = correctness.clear_checks
+
+        selected_helicity_axis, selected_color_axis = _axes(selected_resolved)
+        selected_fixed_c = selected_color_axis[FLOW_ID]
+        all_helicity_axis, all_color_axis = _axes(all_resolved)
+        all_fixed_h = all_helicity_axis[HELICITY_ID]
+
+        recurrence_selected_census = _recurrence_artifact_census(
+            recurrence_selected_artifact,
+            layout="topology-replay",
+            runtime=selected_recurrence_runtime,
+        )
+        recurrence_all_flow_census = _recurrence_artifact_census(
+            recurrence_all_flow_artifact,
+            layout="all-flow-union",
+            runtime=all_flow_recurrence_runtime,
+        )
+        probe = _probe()
+        family_probe = _family_probe()
+        cache: dict[Query, tuple[tuple[float, ...], float, dict[str, Any]]] = {}
+
+        def hidden(flow: object, helicity: object) -> tuple[float, ...]:
+            query = _query(flow, helicity)
+            if query not in cache:
+                before = time.perf_counter()
+                report = _invoke(
+                    probe,
+                    probe_carrier,
+                    retained,
+                    query,
+                    points,
+                    enable_color_projection=enable_color_projection,
+                )
+                cache[query] = (
+                    _probe_values(report, len(points)),
+                    time.perf_counter() - before,
+                    report,
+                )
+            return cache[query][0]
+
+        selected_hidden: list[tuple[float, ...]] = []
+        selected_reference: list[tuple[complex, ...]] = []
+        selected_queries: list[Query] = []
+        selected_checks: list[dict[str, object]] = []
+        for helicity in probe_runtime.physics.helicities:
+            if helicity.id not in selected_helicity_axis:
+                raise GateError("probe carrier helicity is absent from authority")
+            row = tuple(
+                complex(point[selected_helicity_axis[helicity.id]][selected_fixed_c])
+                for point in selected_resolved.values
+            )
+            if helicity.structural_zero:
+                selected_checks.append(_series((0.0,) * len(points), row, helicity.id))
+                continue
+            candidate = hidden(fixed_flow, helicity)
+            selected_hidden.append(candidate)
+            selected_reference.append(row)
+            selected_queries.append(_query(fixed_flow, helicity))
+            selected_checks.append(_series(candidate, row, helicity.id))
+
+        flow_hidden: list[tuple[float, ...]] = []
+        flow_reference: list[tuple[complex, ...]] = []
+        flow_queries: list[Query] = []
+        flow_checks: list[dict[str, object]] = []
+        for flow in probe_runtime.physics.color_flows:
+            if flow.id not in all_color_axis:
+                raise GateError("probe carrier color flow is absent from authority")
+            row = tuple(
+                complex(point[all_fixed_h][all_color_axis[flow.id]])
+                for point in all_resolved.values
+            )
+            try:
+                candidate = hidden(flow, fixed_helicity)
+            except Exception as error:
+                raise GateError(
+                    "the private topology carrier cannot serve the all-flow "
+                    f"single-helicity query {flow.id}; this is a design finding"
+                ) from error
+            flow_hidden.append(candidate)
+            flow_reference.append(row)
+            flow_queries.append(_query(flow, fixed_helicity))
+            flow_checks.append(_series(candidate, row, flow.id))
+
+        selected_hidden_sum = _sum(selected_hidden, len(points))
+        flow_hidden_sum = _sum(flow_hidden, len(points))
+        selected_family_rows, selected_family_correctness = _hidden_family_correctness(
+            probe,
+            probe_carrier,
+            retained,
+            selected_queries,
+            points,
+            selected_reference,
+            [cache[query][2] for query in selected_queries],
+            enable_color_projection,
+        )
+        flow_family_rows, flow_family_correctness = _hidden_family_correctness(
+            probe,
+            probe_carrier,
+            retained,
+            flow_queries,
+            points,
+            flow_reference,
+            [cache[query][2] for query in flow_queries],
+            enable_color_projection,
+        )
+        selected_family_sum = _sum(selected_family_rows, len(points))
+        flow_family_sum = _sum(flow_family_rows, len(points))
+
+        fixed_hidden = hidden(fixed_flow, fixed_helicity)
+        public_helicity_axis, public_color_axis = _axes(selected_public_resolved)
+        fixed_public = tuple(
+            complex(
+                point[public_helicity_axis[HELICITY_ID]][public_color_axis[FLOW_ID]]
+            )
+            for point in selected_public_resolved.values
+        )
+        digest = point_digest((points[0],))
+        sanity = _anchor_checks(
+            _anchor(amplicol),
+            digest,
+            public_component=fixed_public[0],
+            hidden_component=fixed_hidden[0],
+            public_sum=selected_public[0],
+            hidden_sum=selected_hidden_sum[0],
+        )
+
+        selected_hidden_timing = _hidden_timing(
+            probe,
+            probe_carrier,
+            retained,
+            selected_queries,
+            timing_points,
+            target,
+            enable_color_projection,
+        )
+        flow_hidden_timing = _hidden_timing(
+            probe,
+            probe_carrier,
+            retained,
+            flow_queries,
+            timing_points,
+            target,
+            enable_color_projection,
+        )
+        selected_structural = _query_family_census(
+            family_probe,
+            retained,
+            selected_queries,
+            selected_hidden_timing,
+            enable_color_projection,
+        )
+        flow_structural = _query_family_census(
+            family_probe,
+            retained,
+            flow_queries,
+            flow_hidden_timing,
+            enable_color_projection,
+        )
+        _, selected_family_timing = _hidden_family_timing(
+            probe,
+            probe_carrier,
+            retained,
+            selected_queries,
+            timing_points,
+            target,
+            enable_color_projection,
+        )
+        _, flow_family_timing = _hidden_family_timing(
+            probe,
+            probe_carrier,
+            retained,
+            flow_queries,
+            timing_points,
+            target,
+            enable_color_projection,
+        )
+        selected_family_census = _mapping(
+            selected_family_timing.get("work_census"),
+            "selected on-the-fly family census",
+        )
+        flow_family_census = _mapping(
+            flow_family_timing.get("work_census"),
+            "all-flow on-the-fly family census",
+        )
+        _assert_executable_family_matches_structural_census(
+            selected_family_census, selected_structural
+        )
+        _assert_executable_family_matches_structural_census(
+            flow_family_census, flow_structural
+        )
+
+        for workload, private in (
+            ("selected_flow_helicity_sum", selected_family_timing),
+            ("all_flow_single_helicity", flow_family_timing),
+        ):
+            private["diagnostic_ratio_to_recurrence_outer_wall"] = float(
+                private["private_warmed_seconds_per_point"]
+            ) / float(timings["recurrence"][workload]["wall_seconds_per_point"])
+            private["ratio_is_acceptance_gate"] = False
+
+        def comparison(
+            workload: str,
+            family_census: Mapping[str, object],
+            recurrence_census: Mapping[str, object],
+        ) -> dict[str, object]:
+            recurrence_live = _mapping(
+                recurrence_census.get("selector_live"),
+                "recurrence selector-live census",
+            )
+            return {
+                "logical_current_counts": {
+                    "on_the_fly_warmed_family_unique": family_census[
+                        "union_unique_current_count"
+                    ],
+                    "recurrence_selector_live": recurrence_live["current_count"],
+                },
+                "current_component_counts": {
+                    "on_the_fly_warmed_family_unique": family_census[
+                        "union_unique_current_component_count"
+                    ],
+                    "recurrence_selector_live": recurrence_live[
+                        "semantic_current_component_count"
+                    ],
+                },
+                "role_native_operation_counts": {
+                    "on_the_fly_transition_rows": {
+                        role: family_census[f"union_{role}_rows"]
+                        for role in (
+                            "source",
+                            "contribution",
+                            "finalization",
+                            "closure",
+                        )
+                    },
+                    "recurrence_selector_live_rows": {
+                        "source": recurrence_live["source_row_count"],
+                        "contribution": recurrence_live["contribution_count"],
+                        "finalization": recurrence_live["finalization_count"],
+                        "closure": recurrence_live["closure_count"],
+                    },
+                },
+                "on_the_fly_private_warmed_unique_currents_and_rows": family_census,
+                "on_the_fly_public_warmed_rows_and_grouped_calls": (
+                    public_profiles[workload]["work"]
+                ),
+                "recurrence_public_warmed_rows_and_grouped_calls": timings[
+                    "recurrence"
+                ][workload]["recurrence_runtime_work"],
+                "recurrence_persisted_and_selector_live_plan": recurrence_census,
+                "counter_warning": (
+                    "on-the-fly/recurrence rows are transitions and grouped executor "
+                    "calls. Unlike counters are not equated."
+                ),
+            }
+
+        cold = tuple(value[1] for value in cache.values())
+        return {
+            "kind": "pyamplicol-on-the-fly-lc-gate",
+            "status": "passed",
+            "correctness_authority_contract": CORRECTNESS_AUTHORITY_CONTRACT,
+            "process": PROCESS,
+            "process_id": PROCESS_ID,
+            "artifact": str(artifact),
+            "artifact_id": runtime.artifact_id,
+            "on_the_fly_artifact": artifact_contract,
+            "private_probe_carrier": {
+                "execution_mode": "recurrence",
+                "artifact_id": probe_runtime.artifact_id,
+                "role": (
+                    "ephemeral topology carrier for private Rust diagnostics only; "
+                    "not the candidate, not an authority, and excluded from candidate "
+                    "generation/load timing"
+                ),
+                "retained_after_gate": False,
+            },
+            "layout": "topology-replay",
+            "color_projection": {
+                "query": _query(fixed_flow, fixed_helicity).label,
+                **{
+                    name: value
+                    for name, value in cache[_query(fixed_flow, fixed_helicity)][
+                        2
+                    ].items()
+                    if "projection_" in name
+                },
+            },
+            "public_correctness": public_correctness,
+            "public_profiles": public_profiles,
+            "clear_and_rebuild": clear_checks,
+            "dense_correctness_authority": _dense_authority(
+                selected_recurrence_runtime,
+                all_flow_recurrence_runtime,
+                len(points),
+            ),
+            "prepared_model": {
+                "path": str(prepared_path),
+                "load_seconds": prepared_load_seconds,
+            },
+            "cold_boundaries": {
+                "on_the_fly_generation_seconds": generation_seconds,
+                "on_the_fly_runtime_load_seconds": load_seconds,
+                "generation_census": generation_census,
+                "semantics": (
+                    "cold service generation and Runtime.load/post-build work are not "
+                    "warmed work; the recurrence probe carrier is excluded"
+                ),
+            },
+            "explicit_artifact_roots": {
+                "on_the_fly_candidate": str(artifact),
+                "recurrence_selected": str(recurrence_selected_artifact),
+                "recurrence_all_flow": str(recurrence_all_flow_artifact),
+            },
+            "comparator_artifacts": {
+                "recurrence_selected_flow_helicity_sum": (recurrence_selected_census),
+                "recurrence_all_flow_single_helicity": recurrence_all_flow_census,
+            },
+            "points": {
+                "seeds": SEEDS,
+                "seed_101_digest": digest,
+                "dense": len(points),
+            },
+            "cold_private_query_outer_seconds": {
+                "queries": len(cold),
+                "minimum": min(cold),
+                "median": statistics.median(cold),
+                "maximum": max(cold),
+                "total": math.fsum(cold),
+                "not_warmed_work": True,
+            },
+            "selected_flow_helicity_sum": {
+                "private_component_checks": _summaries(selected_checks),
+                "private_probe_aggregate": _series(
+                    selected_hidden_sum,
+                    selected_authority,
+                    "selected-flow private probe/recurrence authority",
+                ),
+                "private_family_correctness": selected_family_correctness,
+                "private_family_aggregate": _series(
+                    selected_family_sum,
+                    selected_authority,
+                    "selected-flow private family/recurrence authority",
+                ),
+                "private_query_local_warm": selected_hidden_timing,
+                "private_family_warm": selected_family_timing,
+                "public_timings": {
+                    lane: value["selected_flow_helicity_sum"]
+                    for lane, value in timings.items()
+                },
+                "descriptive_work_comparison": comparison(
+                    "selected_flow_helicity_sum",
+                    selected_family_census,
+                    recurrence_selected_census,
+                ),
+            },
+            "all_flow_single_helicity": {
+                "private_component_checks": _summaries(flow_checks),
+                "private_probe_aggregate": _series(
+                    flow_hidden_sum,
+                    all_authority,
+                    "all-flow private probe/recurrence authority",
+                ),
+                "private_family_correctness": flow_family_correctness,
+                "private_family_aggregate": _series(
+                    flow_family_sum,
+                    all_authority,
+                    "all-flow private family/recurrence authority",
+                ),
+                "private_query_local_warm": flow_hidden_timing,
+                "private_family_warm": flow_family_timing,
+                "public_timings": {
+                    lane: value["all_flow_single_helicity"]
+                    for lane, value in timings.items()
+                },
+                "descriptive_work_comparison": comparison(
+                    "all_flow_single_helicity",
+                    flow_family_census,
+                    recurrence_all_flow_census,
+                ),
+            },
+            "amplicol_sanity": sanity,
+            "clock_contract": {
+                "on_the_fly_private_warmed": (
+                    "private Rust family clock excluding source crossing and Python"
+                ),
+                "on_the_fly_public": (
+                    "BenchmarkRunner evaluator/evaluator-total and outer wall clocks"
+                ),
+                "recurrence": ("recurrence core/evaluator-total and outer wall clocks"),
+                "amplicol": ("direct execution and worker wall clocks when supplied"),
+                "relationship": (
+                    "all scopes are independent; no equality or interchangeability "
+                    "is assumed"
+                ),
+            },
+            "integration_contract": {
+                "python_api": (
+                    "existing Generator, Runtime.load/evaluate/evaluate_resolved/"
+                    "clear, existing runtime profile backend, and BenchmarkRunner"
+                ),
+                "rust_lane": "separate native on-the-fly execution lane",
+                "new_public_evaluation_api": False,
+            },
+            "performance_is_acceptance_gate": False,
+        }
+
+
+def _run_public_correctness_only(
+    output: Path,
+    prepared_model: Path | None,
+    candidate_artifact: Path | None,
+    recurrence_selected_artifact: Path,
+    recurrence_all_flow_artifact: Path,
+    target: float,
+    batch: int,
+) -> dict[str, object]:
+    if (prepared_model is None) == (candidate_artifact is None):
+        raise GateError(
+            "public correctness-only mode needs exactly one candidate source"
+        )
+
+    generation_seconds: float | None
+    generation_census: dict[str, int] | None
+    prepared_record: dict[str, object]
+    if candidate_artifact is None:
+        if prepared_model is None:  # guarded by the exclusive candidate-source check
+            raise GateError("public correctness-only generation needs a prepared model")
+        artifact = output / "artifact"
+        (
+            generation_seconds,
+            generation_census,
+            _model,
+            prepared_path,
+            prepared_load_seconds,
+        ) = _generate_candidate_with_prepared_model(artifact, prepared_model)
+        candidate_source = "generated-in-guarded-worker"
+        prepared_record = {
+            "status": "loaded",
+            "path": str(prepared_path),
+            "load_seconds": prepared_load_seconds,
+        }
+    else:
+        artifact = _candidate_artifact_path(candidate_artifact)
+        generation_seconds = None
+        generation_census = None
+        candidate_source = "reused-existing-artifact"
+        prepared_record = {
+            "status": "not-loaded",
+            "path": None,
+            "load_seconds": None,
+        }
+
+    public = _run_public_gate_phase(
+        artifact,
+        recurrence_selected_artifact,
+        recurrence_all_flow_artifact,
+        target,
+        batch,
+    )
+    correctness = public.correctness
+    public_timings = {
+        workload: {
+            lane: public.timings[lane][workload]
+            for lane in ("on_the_fly", "recurrence")
+        }
+        for workload in (
+            "selected_flow_helicity_sum",
+            "all_flow_single_helicity",
+        )
+    }
+
+    def comparator(path: Path, runtime: object, role: str) -> dict[str, object]:
+        return {
+            "artifact": str(Path(os.path.abspath(path.expanduser()))),
+            "artifact_id": runtime.artifact_id,
+            "execution_mode": runtime.execution_mode,
+            "role": role,
+        }
+
+    skipped_reason = (
+        "the explicit --public-correctness-only developer lane forbids private "
+        "carrier generation, hidden probes, private census, and private timing"
+    )
+    return {
+        "kind": "pyamplicol-on-the-fly-lc-public-correctness-only",
+        "status": "passed",
+        "correctness_authority_contract": CORRECTNESS_AUTHORITY_CONTRACT,
+        "scope": "provisional-public-correctness-only",
+        "provisional": True,
+        "public_only": True,
+        "full_gate_status": "not-run",
+        "source_bound": False,
+        "source_binding": "not-asserted",
+        "process": PROCESS,
+        "process_id": PROCESS_ID,
+        "artifact": str(artifact),
+        "artifact_id": public.runtime.artifact_id,
+        "candidate_source": candidate_source,
+        "on_the_fly_artifact": public.artifact_contract,
+        "layout": "topology-replay",
+        "public_correctness": correctness.public_correctness,
+        "clear_and_rebuild": correctness.clear_checks,
+        "public_profiles": public.public_profiles,
+        "public_timings": public_timings,
+        "dense_correctness_authority": _dense_authority(
+            public.selected_recurrence_runtime,
+            public.all_flow_recurrence_runtime,
+            len(public.points),
+        ),
+        "prepared_model": prepared_record,
+        "cold_boundaries": {
+            "on_the_fly_generation_seconds": generation_seconds,
+            "on_the_fly_runtime_load_seconds": public.load_seconds,
+            "generation_census": generation_census,
+            "generation_reused": candidate_artifact is not None,
+        },
+        "explicit_artifact_roots": {
+            "on_the_fly_candidate": str(artifact),
+            "recurrence_selected": str(recurrence_selected_artifact),
+            "recurrence_all_flow": str(recurrence_all_flow_artifact),
+        },
+        "comparator_artifacts": {
+            "recurrence_selected_flow_helicity_sum": comparator(
+                recurrence_selected_artifact,
+                public.selected_recurrence_runtime,
+                "selected-flow/helicity-sum recurrence authority",
+            ),
+            "recurrence_all_flow_single_helicity": comparator(
+                recurrence_all_flow_artifact,
+                public.all_flow_recurrence_runtime,
+                "all-flow/single-helicity recurrence authority",
+            ),
+        },
+        "points": {
+            "seeds": SEEDS,
+            "seed_101_digest": point_digest((public.points[0],)),
+            "dense": len(public.points),
+        },
+        "private_probe_carrier": {
+            "status": "skipped",
+            "available": False,
+            "reason": skipped_reason,
+            "retained_after_gate": False,
+        },
+        "private_census": {
+            "status": "unavailable",
+            "query_local": "unavailable",
+            "query_family": "unavailable",
+            "reason": skipped_reason,
+        },
+        "private_timing": {
+            "status": "unavailable",
+            "query_local": "unavailable",
+            "query_family": "unavailable",
+            "reason": skipped_reason,
+        },
+        "clock_contract": {
+            "on_the_fly_public": (
+                "BenchmarkRunner evaluator/evaluator-total and outer wall clocks"
+            ),
+            "recurrence": "recurrence core/evaluator-total and outer wall clocks",
+            "private": "unavailable in provisional public-only mode",
+            "relationship": (
+                "all public clock scopes are independent; no equality or "
+                "interchangeability is assumed"
+            ),
+        },
+        "integration_contract": {
+            "python_api": (
+                "existing Runtime.load/evaluate/evaluate_resolved/clear, existing "
+                "runtime profile backend, and BenchmarkRunner"
+            ),
+            "new_public_evaluation_api": False,
+            "private_native_diagnostics_invoked": False,
+        },
+        "performance_is_acceptance_gate": False,
+    }
+
+
+def _write(path: Path, value: object) -> None:
+    if path.exists() or path.is_symlink():
+        raise GateError(f"refusing to replace evidence: {path}")
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    try:
+        temporary.write_text(
+            json.dumps(value, allow_nan=False, indent=2, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, path)
+    except (OSError, TypeError, ValueError) as error:
+        temporary.unlink(missing_ok=True)
+        raise GateError(f"cannot write evidence: {path}") from error
+
+
+def _read(path: Path) -> dict[str, Any]:
+    try:
+        result = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise GateError(f"cannot read evidence: {path}") from error
+    if not isinstance(result, dict):
+        raise GateError(f"evidence is not an object: {path}")
+    return result
+
+
+def _watchdog_summary(report: Mapping[str, object]) -> dict[str, object]:
+    execution = report.get("execution")
+    enforcement = report.get("enforcement")
+    if not isinstance(execution, Mapping) or not isinstance(enforcement, Mapping):
+        raise GateError("watchdog report is incomplete")
+    return {
+        "passes": report.get("passes"),
+        "outcome": execution.get("outcome"),
+        "reason": execution.get("reason"),
+        "elapsed_wall_seconds": execution.get("elapsed_wall_seconds"),
+        "limit_bytes": enforcement.get("limit_bytes"),
+        "peak_rss_bytes": enforcement.get("peak_rss_bytes"),
+        "peak_physical_footprint_bytes": enforcement.get(
+            "peak_physical_footprint_bytes"
+        ),
+        "peak_guard_bytes": enforcement.get("peak_guard_bytes"),
+        "peak_processes": enforcement.get("peak_processes"),
+    }
+
+
+def _physical_footprint_probe() -> PhysicalFootprintProbe | None:
+    if platform.system() != "Darwin":
+        return None
+    try:
+        return DarwinPhysicalFootprintProbe()
+    except Exception as error:
+        raise GateError("Darwin physical-footprint guard is unavailable") from error
+
+
+def _worker_command(arguments: argparse.Namespace, output: Path) -> list[str]:
+    _validate_mode_arguments(arguments)
+    command = [
+        sys.executable,
+        str(Path(__file__).resolve()),
+        "--worker",
+        "--output",
+        str(output),
+        "--target-runtime",
+        str(arguments.target_runtime),
+        "--batch-size",
+        str(arguments.batch_size),
+    ]
+    if arguments.prepared_model is not None:
+        command.extend(
+            ("--prepared-model", str(_prepared_model_path(arguments.prepared_model)))
+        )
+    else:
+        command.extend(
+            (
+                "--candidate-artifact",
+                str(_candidate_artifact_path(arguments.candidate_artifact)),
+            )
+        )
+    if arguments.public_correctness_only:
+        command.append("--public-correctness-only")
+    if arguments.amplicol_result is not None:
+        amplicol = Path(os.path.abspath(arguments.amplicol_result.expanduser()))
+        command.extend(("--amplicol-result", str(amplicol)))
+    for option, value in (
+        ("--recurrence-selected-artifact", arguments.recurrence_selected_artifact),
+        ("--recurrence-all-flow-artifact", arguments.recurrence_all_flow_artifact),
+    ):
+        command.extend((option, os.path.abspath(value.expanduser())))
+    if arguments.bypass_color_projection:
+        command.append("--bypass-color-projection")
+    return command
+
+
+def _worker_main(arguments: argparse.Namespace) -> int:
+    _validate_mode_arguments(arguments)
+    destination = arguments.output / "worker.json"
+    try:
+        if arguments.public_correctness_only:
+            result = _run_public_correctness_only(
+                arguments.output,
+                arguments.prepared_model,
+                arguments.candidate_artifact,
+                arguments.recurrence_selected_artifact,
+                arguments.recurrence_all_flow_artifact,
+                arguments.target_runtime,
+                arguments.batch_size,
+            )
+        else:
+            result = _run(
+                arguments.output,
+                arguments.prepared_model,
+                arguments.amplicol_result,
+                arguments.recurrence_selected_artifact,
+                arguments.recurrence_all_flow_artifact,
+                arguments.target_runtime,
+                arguments.batch_size,
+                not arguments.bypass_color_projection,
+            )
+    except Exception as error:
+        _write(
+            destination,
+            {
+                "kind": (
+                    "pyamplicol-on-the-fly-lc-public-correctness-only"
+                    if arguments.public_correctness_only
+                    else "pyamplicol-on-the-fly-lc-gate"
+                ),
+                "status": "failed",
+                "correctness_authority_contract": CORRECTNESS_AUTHORITY_CONTRACT,
+                "scope": (
+                    "provisional-public-correctness-only"
+                    if arguments.public_correctness_only
+                    else "full"
+                ),
+                "error": str(error),
+            },
+        )
+        print(f"on-the-fly LC gate failed: {error}", file=sys.stderr)
+        return 1
+    _write(destination, result)
+    return 0
+
+
+def _driver_report(
+    worker: Mapping[str, object], watchdog: Mapping[str, object]
+) -> dict[str, object]:
+    public_only = worker.get("public_only") is True
+    result: dict[str, object] = {
+        "kind": (
+            "pyamplicol-on-the-fly-lc-public-correctness-only-run"
+            if public_only
+            else "pyamplicol-on-the-fly-lc-gate-run"
+        ),
+        "status": "passed",
+        "scope": ("provisional-public-correctness-only" if public_only else "full"),
+        "provisional": public_only,
+        "worker": worker,
+        "watchdog": watchdog,
+    }
+    if public_only:
+        result.update({"source_bound": False, "source_binding": "not-asserted"})
+    return result
+
+
+def _driver_main(arguments: argparse.Namespace) -> int:
+    output = Path(os.path.abspath(arguments.output.expanduser()))
+    if output.exists() or output.is_symlink():
+        raise GateError(f"output already exists: {output}")
+    output.mkdir(parents=True)
+    watchdog_path = output / "watchdog.json"
+    exit_code = run_guarded(
+        _worker_command(arguments, output),
+        limit_bytes=WATCHDOG_BYTES,
+        report_path=watchdog_path,
+        physical_footprint_probe=_physical_footprint_probe(),
+    )
+    watchdog = _watchdog_summary(_read(watchdog_path))
+    worker_path = output / "worker.json"
+    worker = _read(worker_path) if worker_path.is_file() else None
+    if exit_code != 0 or watchdog["passes"] is not True:
+        detail = None if worker is None else worker.get("error")
+        raise GateError(
+            f"guarded worker failed: {watchdog['outcome']!r}, {detail!r}; {output}"
+        )
+    if worker is None or worker.get("status") != "passed":
+        raise GateError("guarded worker omitted its successful result")
+    public_only = worker.get("public_only") is True
+    destination = output / "report.json"
+    _write(destination, _driver_report(worker, watchdog))
+    label = "public correctness-only lane" if public_only else "LC gate"
+    print(f"On-the-fly {label} passed: {destination}")
+    return 0
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = _parser().parse_args(argv)
+    try:
+        return _worker_main(arguments) if arguments.worker else _driver_main(arguments)
+    except GateError as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/otf_contracted_parity_gate.py b/pyamplicol/tools/developer/otf_contracted_parity_gate.py
new file mode 100644
index 0000000000..18ed36d48f
--- /dev/null
+++ b/pyamplicol/tools/developer/otf_contracted_parity_gate.py
@@ -0,0 +1,812 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run one bounded OTF-contracted numerical parity cell.
+
+The caller is responsible for placing each invocation under the repository
+memory watchdog.  A recurrence/NLC/p16-or-p200 invocation creates a local
+authority; an OTF/NLC/p16 invocation authenticates that result, while OTF/full/p16
+authenticates either a retained MadGraph wave record or the frozen acceptance
+fixture.  Every invocation generates exactly one process, evaluates one point
+once, and refuses to replace evidence.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.metadata
+import json
+import math
+import os
+import subprocess
+import tempfile
+import time
+import tomllib
+from collections.abc import Mapping, Sequence
+from contextlib import suppress
+from decimal import Decimal, InvalidOperation, localcontext
+from pathlib import Path
+from typing import Any
+
+KIND = "pyamplicol-otf-contracted-parity-cell-v1"
+SEED = 101
+TOLERANCE = Decimal("1e-10")
+
+
+class GateError(RuntimeError):
+    """The bounded parity cell was malformed or failed."""
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument("--artifact", required=True, type=Path)
+    parser.add_argument("--prepared-model", required=True, type=Path)
+    parser.add_argument("--process", required=True)
+    parser.add_argument("--process-name", required=True)
+    parser.add_argument("--n-final", required=True, type=int)
+    parser.add_argument("--family-id", type=int)
+    parser.add_argument("--point", type=Path)
+    parser.add_argument("--accuracy", required=True, choices=("nlc", "full"))
+    parser.add_argument(
+        "--mode", required=True, choices=("recurrence", "on-the-fly")
+    )
+    parser.add_argument("--precision", required=True, type=int, choices=(16, 200))
+    parser.add_argument(
+        "--query-construction-cores",
+        type=int,
+        choices=(1, 4),
+        default=1,
+    )
+    authority = parser.add_mutually_exclusive_group()
+    authority.add_argument("--recurrence-authority", type=Path)
+    authority.add_argument("--madgraph-authority", type=Path)
+    authority.add_argument("--acceptance-fixture", type=Path)
+    parser.add_argument("--fixture-case-id")
+    return parser
+
+
+def _read_json(path: Path) -> Any:
+    try:
+        return json.loads(
+            path.read_text(encoding="ascii"),
+            parse_float=Decimal,
+            parse_int=Decimal,
+            parse_constant=lambda value: (_ for _ in ()).throw(
+                GateError(f"non-finite JSON token {value!r} in {path}")
+            ),
+        )
+    except GateError:
+        raise
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise GateError(f"cannot read JSON document {path}: {error}") from error
+
+
+def _object(value: Any, where: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise GateError(f"{where} must be a JSON object")
+    return value
+
+
+def _sequence(value: Any, where: str) -> Sequence[Any]:
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise GateError(f"{where} must be a JSON array")
+    return value
+
+
+def _decimal(value: Any, where: str) -> Decimal:
+    if isinstance(value, bool):
+        raise GateError(f"{where} must be a finite number")
+    try:
+        result = value if isinstance(value, Decimal) else Decimal(str(value))
+    except (InvalidOperation, ValueError) as error:
+        raise GateError(f"{where} must be a finite number") from error
+    if not result.is_finite():
+        raise GateError(f"{where} must be finite")
+    return result
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _lower_hex(value: Any, length: int, where: str) -> str:
+    if (
+        not isinstance(value, str)
+        or len(value) != length
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise GateError(f"{where} must be {length} lowercase hexadecimal digits")
+    return value
+
+
+def _candidate_identity(package: Any, distribution_version: str) -> dict[str, Any]:
+    """Authenticate a contributor build without requiring a clean revision."""
+
+    package_root = Path(package.__file__).resolve().parent
+    installed_info_path = package_root / "_build_info.json"
+    installed = _object(_read_json(installed_info_path), "installed build-info")
+    version = installed.get("version")
+    if not isinstance(version, str) or not version or version != distribution_version:
+        raise GateError("installed build-info version differs from the distribution")
+    native_digest = _lower_hex(
+        installed.get("native_build_inputs_sha256"),
+        64,
+        "installed native build-input digest",
+    )
+    source_revision = installed.get("source_revision")
+    if source_revision is not None:
+        source_revision = _lower_hex(source_revision, 40, "installed source revision")
+    source_checkout = installed.get("source_checkout")
+    if not isinstance(source_checkout, str) or not source_checkout:
+        raise GateError("installed build-info has no source checkout")
+    source_root = Path(source_checkout).expanduser().resolve(strict=True)
+    if source_root != Path(__file__).resolve().parents[2]:
+        raise GateError("installed candidate belongs to a different source checkout")
+    source_info_path = (
+        source_root / ".artifacts" / "source-runtime" / "_build_info.json"
+    )
+    source = _object(_read_json(source_info_path), "source-runtime build-info")
+    if (
+        source.get("version") != version
+        or source.get("source_revision") != source_revision
+        or source.get("native_build_inputs_sha256") != native_digest
+    ):
+        raise GateError("installed and source-runtime build-info identities differ")
+    runtime = _object(source.get("source_runtime"), "source-runtime contract")
+    extension_sha256 = _lower_hex(
+        runtime.get("extension_sha256"), 64, "source-runtime extension digest"
+    )
+    if (
+        runtime.get("mode") != "candidate"
+        or runtime.get("native_build_inputs_sha256") != native_digest
+    ):
+        raise GateError("source-runtime native identity differs from build-info")
+
+    from pyamplicol import _rusticol as native
+
+    extension_path = Path(native.__file__).resolve(strict=True)
+    if runtime.get("extension_name") != extension_path.name:
+        raise GateError(
+            "source-runtime extension name differs from the installed module"
+        )
+    if _sha256(extension_path) != extension_sha256:
+        raise GateError("installed native extension digest differs from build-info")
+    native_version_operation = getattr(native, "package_version", None)
+    native_digest_operation = getattr(native, "native_build_inputs_sha256", None)
+    if not callable(native_version_operation) or not callable(native_digest_operation):
+        raise GateError("native extension has no version/build-input identity")
+    native_version = native_version_operation()
+    if (
+        not isinstance(native_version, str)
+        or native_version.replace("-dev.", ".dev") != version
+    ):
+        raise GateError("native extension version differs from build-info")
+    if native_digest_operation() != native_digest:
+        raise GateError("native extension build-input digest differs from build-info")
+
+    completed = subprocess.run(
+        ("git", "-C", os.fspath(source_root), "rev-parse", "HEAD"),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        raise GateError("cannot record current Git HEAD provenance")
+    git_head = _lower_hex(completed.stdout.strip(), 40, "current Git HEAD")
+    return {
+        "kind": "installed-contributor-native-candidate-v1",
+        "version": version,
+        "native_build_inputs_sha256": native_digest,
+        "native_extension_sha256": extension_sha256,
+        "source_revision": source_revision,
+        "current_git_head_provenance_only": git_head,
+        "installed_build_info": {
+            "path": os.fspath(installed_info_path),
+            "sha256": _sha256(installed_info_path),
+        },
+        "source_runtime_build_info": {
+            "path": os.fspath(source_info_path),
+            "sha256": _sha256(source_info_path),
+        },
+        "native_extension": {
+            "path": os.fspath(extension_path),
+            "sha256": extension_sha256,
+        },
+    }
+
+
+def _point_rows(value: Any, where: str) -> tuple[tuple[float, ...], ...]:
+    rows: list[tuple[float, ...]] = []
+    for index, raw_row in enumerate(_sequence(value, where)):
+        row = _sequence(raw_row, f"{where}[{index}]")
+        if len(row) != 4:
+            raise GateError(f"{where}[{index}] must contain four components")
+        try:
+            values = tuple(float(component) for component in row)
+        except (TypeError, ValueError, OverflowError) as error:
+            raise GateError(f"{where}[{index}] contains a non-number") from error
+        if any(not math.isfinite(component) for component in values):
+            raise GateError(f"{where}[{index}] contains a non-finite number")
+        rows.append(values)
+    if not rows:
+        raise GateError(f"{where} must not be empty")
+    return tuple(rows)
+
+
+def _point_digest(point: tuple[tuple[float, ...], ...]) -> str:
+    canonical = json.dumps(
+        [[repr(component) for component in row] for row in point],
+        ensure_ascii=True,
+        separators=(",", ":"),
+    ).encode("ascii")
+    return hashlib.sha256(canonical).hexdigest()
+
+
+def _same_point(
+    left: tuple[tuple[float, ...], ...], right: tuple[tuple[float, ...], ...]
+) -> bool:
+    return left == right
+
+
+def _fixture_case(
+    path: Path, case_id: str, process: str
+) -> tuple[tuple[tuple[float, ...], ...], Decimal, dict[str, Any]]:
+    fixture = _object(_read_json(path), "acceptance fixture")
+    if (
+        fixture.get("kind") != "pyamplicol-ufo-sm-numerical-acceptance"
+        or fixture.get("schema_version") != Decimal(1)
+    ):
+        raise GateError("acceptance fixture identity is unsupported")
+    comparison = _object(fixture.get("comparison"), "fixture comparison")
+    if (
+        comparison.get("relative_tolerance") != "0.0000000001"
+        or comparison.get("absolute_tolerance") is not None
+        or comparison.get("full_candidate_precision_digits") != Decimal(200)
+    ):
+        raise GateError("acceptance fixture does not carry the strict p200 contract")
+    cases = _sequence(
+        fixture.get("extra_full_colour_cases"), "fixture extra_full_colour_cases"
+    )
+    matches = [
+        _object(raw, "fixture extra case")
+        for raw in cases
+        if isinstance(raw, Mapping) and raw.get("id") == case_id
+    ]
+    if len(matches) != 1 or matches[0].get("process") != process:
+        raise GateError(f"fixture case {case_id!r} does not match {process!r}")
+    case = matches[0]
+    expected = _decimal(
+        _object(case.get("expected"), "fixture expected").get("full"),
+        "fixture full target",
+    )
+    point = _point_rows(case.get("momenta"), "fixture momenta")
+    return point, expected, {
+        "kind": "frozen-madgraph-acceptance-fixture",
+        "path": os.fspath(path),
+        "sha256": _sha256(path),
+        "case_id": case_id,
+    }
+
+
+def _point_from_path(path: Path) -> tuple[tuple[float, ...], ...]:
+    return _point_rows(_read_json(path), f"point {path}")
+
+
+def _madgraph_target(
+    path: Path,
+    *,
+    process: str,
+    n_final: int,
+    point: tuple[tuple[float, ...], ...],
+) -> tuple[Decimal, dict[str, Any]]:
+    authority = _object(_read_json(path), "MadGraph authority")
+    if (
+        authority.get("process") != process
+        or authority.get("n_final") != Decimal(n_final)
+        or authority.get("seed") != Decimal(SEED)
+    ):
+        raise GateError("retained MadGraph authority identity differs from this cell")
+    declared_point = authority.get("point_path")
+    if not isinstance(declared_point, str):
+        raise GateError("retained MadGraph authority has no point_path")
+    authority_point_path = Path(declared_point).expanduser().resolve(strict=True)
+    authority_point = _point_from_path(authority_point_path)
+    if not _same_point(point, authority_point):
+        raise GateError("worker point differs from the retained MadGraph point")
+    expected = _decimal(authority.get("madgraph_value"), "MadGraph value")
+    measurement_path = path.parent / "madgraph-measurement.json"
+    measurement = _object(_read_json(measurement_path), "MadGraph measurement")
+    validation = _object(measurement.get("validation"), "MadGraph validation")
+    if (
+        measurement.get("status") != "ok"
+        or validation.get("status") != "ok"
+        or validation.get("method")
+        != "independent-madgraph-tree-level-oracle"
+        or _decimal(measurement.get("matrix_element"), "MadGraph measurement value")
+        != expected
+    ):
+        raise GateError("retained MadGraph measurement is not a successful authority")
+    return expected, {
+        "kind": "retained-authenticated-madgraph-wave",
+        "path": os.fspath(path),
+        "sha256": _sha256(path),
+        "measurement_path": os.fspath(measurement_path),
+        "measurement_sha256": _sha256(measurement_path),
+        "point_path": os.fspath(authority_point_path),
+        "point_sha256": _sha256(authority_point_path),
+    }
+
+
+def _recurrence_target(
+    path: Path,
+    *,
+    process: str,
+    point_digest: str,
+    producer_version: str,
+) -> tuple[Decimal, dict[str, Any]]:
+    record = _object(_read_json(path), "recurrence authority")
+    lane = _object(record.get("lane"), "recurrence authority lane")
+    actual = _object(record.get("actual"), "recurrence authority actual")
+    producer = _object(record.get("producer"), "recurrence authority producer")
+    authority_precision = lane.get("precision")
+    if (
+        record.get("kind") != KIND
+        or record.get("status") != "anchor"
+        or record.get("process") != process
+        or record.get("point_digest") != point_digest
+        or lane.get("accuracy") != "nlc"
+        or lane.get("mode") != "recurrence"
+        or authority_precision not in {Decimal(16), Decimal(200)}
+        or producer.get("version") != producer_version
+    ):
+        raise GateError("recurrence authority does not match this OTF/NLC cell")
+    imaginary = _decimal(actual.get("imaginary"), "recurrence imaginary part")
+    if imaginary != 0:
+        raise GateError("recurrence authority is not exactly real")
+    return _decimal(actual.get("real"), "recurrence real part"), {
+        "kind": f"same-candidate-recurrence-p{authority_precision}",
+        "precision": int(authority_precision),
+        "path": os.fspath(path),
+        "sha256": _sha256(path),
+    }
+
+
+def _actual(value: Any) -> tuple[Decimal, Decimal, str]:
+    if isinstance(value, Decimal):
+        if not value.is_finite():
+            raise GateError("matrix element is non-finite")
+        return value, Decimal(0), str(value)
+    try:
+        number = complex(value)
+    except (TypeError, ValueError, OverflowError) as error:
+        raise GateError("matrix element is not numeric") from error
+    if not math.isfinite(number.real) or not math.isfinite(number.imag):
+        raise GateError("matrix element is non-finite")
+    return Decimal(repr(number.real)), Decimal(repr(number.imag)), repr(value)
+
+
+def _comparison(real: Decimal, imaginary: Decimal, expected: Decimal) -> dict[str, Any]:
+    with localcontext() as context:
+        context.prec = 512
+        magnitude = (real * real + imaginary * imaginary).sqrt()
+        difference = ((real - expected) ** 2 + imaginary**2).sqrt()
+        scale = max(magnitude, abs(expected))
+        bound = TOLERANCE * scale
+        passed = difference == 0 if scale == 0 else difference <= bound
+        residual = Decimal(0) if scale == 0 else difference / scale
+    return {
+        "expected": str(expected),
+        "absolute_difference": str(difference),
+        "scale": str(scale),
+        "conditioned_residual": str(residual),
+        "relative_tolerance": str(TOLERANCE),
+        "bound": str(bound),
+        "passed": passed,
+    }
+
+
+def _run_config(accuracy: str, mode: str, cores: int) -> Any:
+    from pyamplicol.config import (
+        Action,
+        ColorAccuracy,
+        ColorConfig,
+        EvaluatorConfig,
+        EvaluatorExecutionMode,
+        EvaluatorOptimizationConfig,
+        GenerationConfig,
+        GenerationRelationDiscoveryConfig,
+        GenerationValidationConfig,
+        JITConfig,
+        LCFlowLayout,
+        RelationDiscoveryMode,
+        RunConfig,
+    )
+
+    return RunConfig(
+        action=Action.GENERATE,
+        color=ColorConfig(
+            accuracy=ColorAccuracy(accuracy),
+            lc_flow_layout=LCFlowLayout.TOPOLOGY_REPLAY,
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=False,
+                post_build_validation=False,
+            ),
+            relation_discovery=GenerationRelationDiscoveryConfig(
+                mode=RelationDiscoveryMode.OFF
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            execution_mode=EvaluatorExecutionMode(mode),
+            optimization=EvaluatorOptimizationConfig(cores=cores),
+            jit=JITConfig(optimization_level=2),
+        ),
+    )
+
+
+def _atomic_json(path: Path, payload: Mapping[str, Any]) -> None:
+    if path.exists() or path.is_symlink():
+        raise GateError(f"refusing to replace evidence: {path}")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary = tempfile.mkstemp(
+        prefix=f".{path.name}.", suffix=".tmp", dir=path.parent
+    )
+    try:
+        with os.fdopen(descriptor, "w", encoding="ascii") as stream:
+            json.dump(payload, stream, ensure_ascii=True, separators=(",", ":"))
+            stream.write("\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+    finally:
+        with suppress(FileNotFoundError):
+            os.unlink(temporary)
+
+
+def _validate_arguments(args: argparse.Namespace) -> None:
+    expected_lane = {
+        ("nlc", "recurrence", 16): "anchor",
+        ("nlc", "recurrence", 200): "anchor",
+        ("nlc", "on-the-fly", 16): "recurrence",
+        ("full", "on-the-fly", 16): "full",
+    }.get((args.accuracy, args.mode, args.precision))
+    if expected_lane is None:
+        raise GateError(
+            "unsupported gate lane; only NLC recurrence-p16/p200 and OTF-p16"
+        )
+    has_recurrence = args.recurrence_authority is not None
+    has_full = (
+        args.madgraph_authority is not None
+        or args.acceptance_fixture is not None
+    )
+    if expected_lane == "anchor" and (has_recurrence or has_full):
+        raise GateError("recurrence-p200 anchor must not declare an authority")
+    if expected_lane == "recurrence" and not has_recurrence:
+        raise GateError("OTF/NLC requires --recurrence-authority")
+    if expected_lane == "full" and not has_full:
+        raise GateError("OTF/full requires a MadGraph authority")
+    if (args.acceptance_fixture is None) != (args.fixture_case_id is None):
+        raise GateError("--acceptance-fixture and --fixture-case-id are paired")
+    if args.acceptance_fixture is None and args.point is None:
+        raise GateError("non-fixture cells require --point")
+    if args.n_final < 1 or args.n_final > 6:
+        raise GateError("n_final must be in 1..6")
+    if args.mode == "recurrence" and args.query_construction_cores != 1:
+        raise GateError("recurrence authorities use exactly one core")
+
+
+def _authenticate_artifact(
+    artifact: Path,
+    *,
+    process_name: str,
+    mode: str,
+    query_construction_cores: int,
+    candidate_identity: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Authenticate cheap persisted boundaries before any runtime evaluation."""
+
+    manifest_path = artifact / "artifact.json"
+    manifest = _object(_read_json(manifest_path), "artifact manifest")
+    manifest_producer = _object(manifest.get("producer"), "artifact producer")
+    artifact_producer_version = manifest_producer.get("version")
+    artifact_source_revision = manifest_producer.get("git_revision")
+    artifact_native_digest = manifest_producer.get(
+        "native_build_inputs_sha256"
+    )
+    if (
+        manifest_producer.get("distribution") != "pyamplicol"
+        or artifact_producer_version != candidate_identity["version"]
+        or artifact_source_revision != candidate_identity["source_revision"]
+        or artifact_native_digest
+        != candidate_identity["native_build_inputs_sha256"]
+    ):
+        raise GateError("artifact producer differs from installed candidate")
+    effective_path = artifact / "config" / "effective.toml"
+    try:
+        effective = tomllib.loads(effective_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, tomllib.TOMLDecodeError) as error:
+        raise GateError(f"cannot read effective configuration: {error}") from error
+    effective_cores = (
+        effective.get("evaluator", {}).get("optimization", {}).get("cores")
+    )
+    if effective_cores != query_construction_cores:
+        raise GateError(
+            "effective configuration does not authenticate the requested core budget"
+        )
+    query_construction_threads = None
+    if mode == "on-the-fly":
+        execution_path = artifact / "processes" / process_name / "execution.json"
+        execution = _object(_read_json(execution_path), "OTF execution manifest")
+        runtime_options = _object(
+            execution.get("runtime_options"), "OTF runtime options"
+        )
+        query_construction_threads = runtime_options.get(
+            "query_construction_threads"
+        )
+        if query_construction_threads != Decimal(query_construction_cores):
+            raise GateError(
+                "OTF execution manifest does not authenticate the requested "
+                "query-construction thread budget"
+            )
+    return {
+        "producer": {
+            "version": artifact_producer_version,
+            "source_revision_provenance": artifact_source_revision,
+            "native_build_inputs_sha256": artifact_native_digest,
+            "artifact_id": manifest.get("artifact_id"),
+            "artifact_manifest_sha256": _sha256(manifest_path),
+        },
+        "effective_config": {
+            "path": os.fspath(effective_path),
+            "sha256": _sha256(effective_path),
+            "evaluator_optimization_cores": effective_cores,
+        },
+        "runtime_options": {
+            "query_construction_threads": (
+                None
+                if query_construction_threads is None
+                else int(query_construction_threads)
+            ),
+        },
+    }
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    _validate_arguments(args)
+    output = args.output.expanduser().resolve(strict=False)
+    preflight_path = output.with_name(f"{output.stem}.preflight.json")
+    artifact = args.artifact.expanduser().resolve(strict=False)
+    prepared = args.prepared_model.expanduser().resolve(strict=True)
+    if not prepared.is_file():
+        raise GateError(f"prepared model is not a regular file: {prepared}")
+    if output.exists() or output.is_symlink():
+        raise GateError(f"result already exists: {output}")
+    if preflight_path.exists() or preflight_path.is_symlink():
+        raise GateError(f"preflight evidence already exists: {preflight_path}")
+    if artifact.exists() or artifact.is_symlink():
+        raise GateError(f"artifact already exists: {artifact}")
+
+    fixture_target: Decimal | None = None
+    fixture_lineage: dict[str, Any] | None = None
+    if args.acceptance_fixture is not None:
+        fixture_path = args.acceptance_fixture.expanduser().resolve(strict=True)
+        point, fixture_target, fixture_lineage = _fixture_case(
+            fixture_path, args.fixture_case_id, args.process
+        )
+    else:
+        point_path = args.point.expanduser().resolve(strict=True)
+        point = _point_from_path(point_path)
+    digest = _point_digest(point)
+
+    import pyamplicol
+    from pyamplicol import Generator, ModelSource, ProcessSet, Runtime
+
+    producer_version = importlib.metadata.version("pyamplicol")
+    candidate_identity = _candidate_identity(pyamplicol, producer_version)
+    expected: Decimal | None = None
+    authority: dict[str, Any] | None = None
+    if args.recurrence_authority is not None:
+        authority_path = args.recurrence_authority.expanduser().resolve(strict=True)
+        expected, authority = _recurrence_target(
+            authority_path,
+            process=args.process,
+            point_digest=digest,
+            producer_version=producer_version,
+        )
+    elif args.madgraph_authority is not None:
+        authority_path = args.madgraph_authority.expanduser().resolve(strict=True)
+        expected, authority = _madgraph_target(
+            authority_path,
+            process=args.process,
+            n_final=args.n_final,
+            point=point,
+        )
+    elif fixture_target is not None:
+        expected, authority = fixture_target, fixture_lineage
+
+    model_started = time.perf_counter()
+    model = ModelSource.from_path(prepared).compile()
+    model_seconds = time.perf_counter() - model_started
+    artifact.parent.mkdir(parents=True, exist_ok=True)
+    generation_started = time.perf_counter()
+    Generator(
+        _run_config(
+            args.accuracy,
+            args.mode,
+            args.query_construction_cores,
+        )
+    ).generate(
+        ProcessSet.from_expressions(
+            (args.process,),
+            names=(args.process_name,),
+        ),
+        artifact,
+        model=model,
+    )
+    generation_seconds = time.perf_counter() - generation_started
+    preflight_common = {
+        "kind": "pyamplicol-otf-contracted-parity-preflight-v1",
+        "schema_version": 1,
+        "artifact": os.fspath(artifact),
+        "candidate_identity": candidate_identity,
+        "process": args.process,
+        "point_digest": digest,
+        "authority": authority,
+        "requested_lane": {
+            "accuracy": args.accuracy,
+            "mode": args.mode,
+            "precision": args.precision,
+            "workers": 1,
+            "cores": args.query_construction_cores,
+        },
+        "generation_seconds": generation_seconds,
+        "evaluation_state": "not-started",
+    }
+    try:
+        artifact_identity = _authenticate_artifact(
+            artifact,
+            process_name=args.process_name,
+            mode=args.mode,
+            query_construction_cores=args.query_construction_cores,
+            candidate_identity=candidate_identity,
+        )
+    except Exception as error:
+        _atomic_json(
+            preflight_path,
+            {
+                **preflight_common,
+                "status": "failed",
+                "error": {
+                    "type": type(error).__name__,
+                    "message": str(error),
+                },
+            },
+        )
+        raise
+    _atomic_json(
+        preflight_path,
+        {
+            **preflight_common,
+            "status": "passed",
+            "artifact_identity": artifact_identity,
+        },
+    )
+    producer = artifact_identity["producer"]
+    effective_config = artifact_identity["effective_config"]
+    query_construction_threads = artifact_identity["runtime_options"][
+        "query_construction_threads"
+    ]
+
+    load_started = time.perf_counter()
+    runtime = Runtime.load(artifact, process=args.process_name)
+    load_seconds = time.perf_counter() - load_started
+    try:
+        inspection = _object(runtime.inspect(), "compact runtime inspection")
+        runtime_metadata = _object(
+            inspection.get("runtime_metadata"),
+            "compact runtime metadata",
+        )
+        observed_mode = runtime_metadata.get("execution_mode")
+        observed_accuracy = runtime_metadata.get("color_accuracy")
+        if (
+            runtime.execution_mode != args.mode
+            or observed_mode != args.mode
+            or observed_accuracy != args.accuracy
+        ):
+            raise GateError(
+                "runtime lane differs from requested "
+                f"{args.mode}/{args.accuracy}: "
+                f"{runtime.execution_mode}/{observed_mode}/{observed_accuracy}"
+            )
+        evaluation_started = time.perf_counter()
+        values = runtime.evaluate((point,), precision=args.precision)
+        evaluation_seconds = time.perf_counter() - evaluation_started
+    finally:
+        runtime.clear()
+    if len(values) != 1:
+        raise GateError(f"single-point evaluation returned {len(values)} values")
+    real, imaginary, exact = _actual(values[0])
+    if real < 0:
+        raise GateError("matrix element is negative")
+
+    comparison = None if expected is None else _comparison(real, imaginary, expected)
+    status = (
+        "anchor"
+        if comparison is None
+        else ("passed" if comparison["passed"] is True else "mismatch")
+    )
+    record: dict[str, Any] = {
+        "kind": KIND,
+        "schema_version": 1,
+        "status": status,
+        "seed": SEED,
+        "process": args.process,
+        "process_name": args.process_name,
+        "n_final": args.n_final,
+        "family_id": args.family_id,
+        "point_digest": digest,
+        "point_count": 1,
+        "selector_policy": "none-contracted-singleton",
+        "warmup_count": 0,
+        "repetition_count": 0,
+        "lane": {
+            "accuracy": args.accuracy,
+            "mode": args.mode,
+            "precision": args.precision,
+            "workers": 1,
+            "cores": args.query_construction_cores,
+            "query_construction_threads": (
+                None
+                if query_construction_threads is None
+                else int(query_construction_threads)
+            ),
+            "relation_discovery": "off",
+        },
+        "actual": {
+            "real": str(real),
+            "imaginary": str(imaginary),
+            "exact_runtime_string": exact,
+        },
+        "authority": authority,
+        "comparison": comparison,
+        "timings_seconds": {
+            "prepared_model_load": model_seconds,
+            "generation": generation_seconds,
+            "runtime_load": load_seconds,
+            "single_evaluation": evaluation_seconds,
+        },
+        "prepared_model": {
+            "path": os.fspath(prepared),
+            "sha256": _sha256(prepared),
+        },
+        "artifact": os.fspath(artifact),
+        "preflight": {
+            "path": os.fspath(preflight_path),
+            "sha256": _sha256(preflight_path),
+        },
+        "effective_config": effective_config,
+        "candidate_identity": candidate_identity,
+        "producer": producer,
+        "python_package": os.fspath(Path(pyamplicol.__file__).resolve()),
+    }
+    _atomic_json(output, record)
+    if comparison is not None and comparison["passed"] is not True:
+        raise GateError(
+            f"strict parity failed for {args.process}/{args.accuracy}: "
+            f"residual={comparison['conditioned_residual']}"
+        )
+    print(json.dumps(record, ensure_ascii=True, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/otf_wave1_runtime_benchmark.py b/pyamplicol/tools/developer/otf_wave1_runtime_benchmark.py
new file mode 100644
index 0000000000..ad8303d3cc
--- /dev/null
+++ b/pyamplicol/tools/developer/otf_wave1_runtime_benchmark.py
@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Measure the two fixed warmed OTF LC Wave-1 workloads with the native timer."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import platform
+import statistics
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+ARTIFACT_ID = "81de5672cafb4cedd4a8cb4064e4b5e6caefb25f031e6b5fbb22990f82a073fc"
+PROCESS_ID = "catalog_dd_tt_jets_n4"
+PROCESS = "d d~ > t t~ g g"
+CASE_ID = "catalog:dd_tt_jets:n4"
+FLOW_ID = "flow:2,5,6,4,3,1"
+HELICITY_ID = "h:-1,+1,-1,+1,-1,+1"
+POINT_SHA256 = "111d277e8eb86e8d183adba74c0c83a3e4d20a6317a10bdb7c63893f5e5017c0"
+BATCH_SHA256 = "a875706b2f87d9105b483b2d5d33285005902ed29485a8934601598852016c71"
+BATCH_SIZE = 128
+REPETITIONS = 4
+WARMUPS = 3
+SAMPLES = 11
+
+
+def _canonical_sha256(value: object) -> str:
+    payload = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _point(fixture: Path) -> tuple[tuple[float, ...], ...]:
+    payload = json.loads(fixture.read_text(encoding="utf-8"))
+    case = next(
+        (
+            item
+            for item in payload.get("catalog_cases", ())
+            if item.get("id") == CASE_ID
+        ),
+        None,
+    )
+    if not isinstance(case, dict) or case.get("process") != PROCESS:
+        raise RuntimeError(f"fixture omits the fixed case {CASE_ID!r}")
+    point = tuple(tuple(float(value) for value in row) for row in case["momenta"])
+    if _canonical_sha256((point,)) != POINT_SHA256:
+        raise RuntimeError("fixed acceptance point identity changed")
+    return point
+
+
+def _installed_identity(package_root: Path, version: str) -> dict[str, object]:
+    build_info_path = package_root / "_build_info.json"
+    build_info = json.loads(build_info_path.read_text(encoding="utf-8"))
+    extensions = tuple(package_root.glob("_rusticol*.so"))
+    if len(extensions) != 1:
+        raise RuntimeError("installed native extension is absent or ambiguous")
+    return {
+        "package_root": str(package_root),
+        "package_version": version,
+        "source_revision": build_info.get("source_revision"),
+        "native_build_inputs_sha256": build_info.get("native_build_inputs_sha256"),
+        "native_extension_sha256": _file_sha256(extensions[0]),
+    }
+
+
+def _value_record(value: object) -> dict[str, object]:
+    resolved = complex(value)  # type: ignore[arg-type]
+    if not math.isfinite(resolved.real) or not math.isfinite(resolved.imag):
+        raise RuntimeError("selector smoke evaluation is not finite")
+    return {
+        "real": resolved.real,
+        "imag": resolved.imag,
+        "real_hex": resolved.real.hex(),
+        "imag_hex": resolved.imag.hex(),
+    }
+
+
+def _summary(samples: list[float]) -> dict[str, object]:
+    median = statistics.median(samples)
+    return {
+        "seconds_per_point": samples,
+        "median_seconds_per_point": median,
+        "mad_seconds_per_point": statistics.median(
+            abs(value - median) for value in samples
+        ),
+        "minimum_seconds_per_point": min(samples),
+        "maximum_seconds_per_point": max(samples),
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--artifact", required=True, type=Path)
+    parser.add_argument("--fixture", required=True, type=Path)
+    parser.add_argument("--label", required=True)
+    parser.add_argument("--output", required=True, type=Path)
+    return parser
+
+
+def main() -> int:
+    arguments = _parser().parse_args()
+    artifact = arguments.artifact.resolve(strict=True)
+    fixture = arguments.fixture.resolve(strict=True)
+    destination = arguments.output.resolve()
+    if destination.exists() or destination.is_symlink():
+        raise RuntimeError(f"refusing to replace benchmark evidence: {destination}")
+
+    import pyamplicol
+    from pyamplicol import Runtime
+
+    point = _point(fixture)
+    batch = tuple(point for _ in range(BATCH_SIZE))
+    if _canonical_sha256(batch) != BATCH_SHA256:
+        raise RuntimeError("fixed benchmark batch identity changed")
+
+    runtime = Runtime.load(artifact, process=PROCESS_ID)
+    if runtime.artifact_id != ARTIFACT_ID:
+        raise RuntimeError("benchmark artifact identity changed")
+    if runtime.execution_mode != "on-the-fly":
+        raise RuntimeError(
+            f"expected on-the-fly runtime, got {runtime.execution_mode!r}"
+        )
+    backend = getattr(runtime, "_backend", None)
+    timer = getattr(backend, "_benchmark_f64_wall_time", None)
+    if not callable(timer):
+        raise RuntimeError("native f64 wall timer is unavailable")
+
+    workloads: tuple[tuple[str, dict[str, tuple[str, ...]]], ...] = (
+        ("selected_flow_helicity_sum", {"color_flows": (FLOW_ID,)}),
+        ("all_flow_single_helicity", {"helicities": (HELICITY_ID,)}),
+    )
+    smoke_values = {
+        name: _value_record(runtime.evaluate((point,), precision=16, **selectors)[0])
+        for name, selectors in workloads
+    }
+    for warmup in range(WARMUPS):
+        ordered = workloads if warmup % 2 == 0 else tuple(reversed(workloads))
+        for _, selectors in ordered:
+            elapsed = float(timer(batch, 1, precision=16, **selectors))
+            if not math.isfinite(elapsed) or elapsed <= 0.0:
+                raise RuntimeError("native wall warmup returned an invalid duration")
+
+    raw: dict[str, list[float]] = {name: [] for name, _ in workloads}
+    divisor = REPETITIONS * BATCH_SIZE
+    for sample in range(SAMPLES):
+        ordered = workloads if sample % 2 == 0 else tuple(reversed(workloads))
+        for name, selectors in ordered:
+            # Only the last selector family is retained. Prime the exact route
+            # after every order switch so the measured block is wholly warm.
+            prime_elapsed = float(timer(batch, 1, precision=16, **selectors))
+            if not math.isfinite(prime_elapsed) or prime_elapsed <= 0.0:
+                raise RuntimeError("native selector prime returned an invalid duration")
+            elapsed = float(timer(batch, REPETITIONS, precision=16, **selectors))
+            if not math.isfinite(elapsed) or elapsed <= 0.0:
+                raise RuntimeError("native wall sample returned an invalid duration")
+            raw[name].append(elapsed / divisor)
+
+    package_root = Path(pyamplicol.__file__).resolve().parent
+    result: dict[str, Any] = {
+        "kind": "pyamplicol-otf-wave1-native-wall-benchmark",
+        "schema_version": 1,
+        "label": arguments.label,
+        "created_at_utc": datetime.now(UTC).isoformat(),
+        "driver_sha256": _file_sha256(Path(__file__).resolve()),
+        "installation": _installed_identity(package_root, pyamplicol.__version__),
+        "environment": {
+            "python": sys.version,
+            "platform": platform.platform(),
+            "machine": platform.machine(),
+        },
+        "contract": {
+            "timer": "Runtime._benchmark_f64_wall_time",
+            "artifact": str(artifact),
+            "artifact_id": ARTIFACT_ID,
+            "process_id": PROCESS_ID,
+            "process": PROCESS,
+            "point_case_id": CASE_ID,
+            "point_sha256": POINT_SHA256,
+            "batch_sha256": BATCH_SHA256,
+            "batch_size": BATCH_SIZE,
+            "repetitions": REPETITIONS,
+            "warmups": WARMUPS,
+            "samples": SAMPLES,
+            "precision": 16,
+            "per_sample_selector_prime_repetitions": 1,
+            "selector_prime_timing": "excluded",
+            "sample_order": "ABBA",
+            "selectors": {
+                "selected_flow_helicity_sum": {"color_flows": [FLOW_ID]},
+                "all_flow_single_helicity": {"helicities": [HELICITY_ID]},
+            },
+        },
+        "smoke_values": smoke_values,
+        "workloads": {name: _summary(raw[name]) for name, _ in workloads},
+    }
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with destination.open("x", encoding="utf-8") as stream:
+        json.dump(result, stream, allow_nan=False, indent=2, sort_keys=True)
+        stream.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/prepare_builtin_without_auxiliary_qcd.py b/pyamplicol/tools/developer/prepare_builtin_without_auxiliary_qcd.py
new file mode 100644
index 0000000000..f3bb7249db
--- /dev/null
+++ b/pyamplicol/tools/developer/prepare_builtin_without_auxiliary_qcd.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Prepare a diagnostic built-in model without auxiliary four-gluon kernels.
+
+This intentionally incomplete model is useful only for locating recurrence
+parity failures. It removes the trivalent auxiliary-tensor decomposition of the
+four-gluon interaction while retaining the rest of the built-in model.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from recurrence_z6g_benchmark import _generation_config
+
+from pyamplicol import ModelSource
+from pyamplicol.models.builtin.definitions import BuiltinSMDefinitionMixin
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("output", type=Path)
+    arguments = parser.parse_args()
+    output = arguments.output.expanduser().resolve()
+
+    original = BuiltinSMDefinitionMixin._build_vertices
+
+    def without_auxiliary_vertices(
+        model: BuiltinSMDefinitionMixin,
+    ) -> list[object]:
+        return [
+            vertex
+            for vertex in original(model)
+            if int(vertex.kind) not in {1, 2, 3}
+        ]
+
+    BuiltinSMDefinitionMixin._build_vertices = without_auxiliary_vertices
+    try:
+        ModelSource.built_in_sm().compile(
+            use_cache=False,
+            prepared_output=output,
+            evaluator=_generation_config(
+                "recurrence",
+                validation_samples=1,
+            ).evaluator,
+        )
+    finally:
+        BuiltinSMDefinitionMixin._build_vertices = original
+    print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/prepare_class_c_bridge.py b/pyamplicol/tools/developer/prepare_class_c_bridge.py
new file mode 100644
index 0000000000..f6224b6209
--- /dev/null
+++ b/pyamplicol/tools/developer/prepare_class_c_bridge.py
@@ -0,0 +1,559 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Prepare a Class-C bridge with descendant tools and the staged ancestor runtime.
+
+The live checkout must already be at the reviewed descendant while its source
+runtime and report environment still authenticate the measured ancestor.  This
+helper materializes a temporary, tracked ancestor worktree, binds only the
+ignored files that make up the retained source runtime, and invokes the
+descendant report controller against that authenticated package.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import inspect
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+_PROFILE_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,63}")
+_NATIVE_EXTENSION_SUFFIXES = (".dylib", ".pyd", ".so")
+_LEGACY_NATIVE_BUILD_INPUT_FILES = (
+    Path("Cargo.lock"),
+    Path("Cargo.toml"),
+    Path("pyproject.toml"),
+    Path("rust-toolchain.toml"),
+    Path("dependencies/candidate-Cargo.lock"),
+    Path("dependencies/candidate-cargo-config.toml"),
+    Path("dependencies/contributor-lock.toml"),
+    Path("dependencies/install-state.json"),
+    Path("dependencies/release-lock.toml"),
+)
+_LEGACY_NATIVE_BUILD_INPUT_TREES = (
+    Path("build_backend"),
+    Path("dependencies/patches"),
+    Path("rust"),
+)
+_LEGACY_NATIVE_BUILD_INPUT_SUFFIXES = {
+    ".f90",
+    ".h",
+    ".hpp",
+    ".json",
+    ".patch",
+    ".py",
+    ".pyi",
+    ".rs",
+    ".toml",
+}
+_IGNORED_NATIVE_INPUTS = (
+    Path("dependencies/candidate-Cargo.lock"),
+    Path("dependencies/candidate-cargo-config.toml"),
+    Path("dependencies/install-state.json"),
+)
+_STAGED_SDK_DIRECTORIES = (
+    Path("_sdk/fortran"),
+    Path("_sdk/include"),
+    Path("_sdk/lib"),
+)
+_STAGED_SDK_FILES = (
+    Path("_sdk/link.json"),
+    Path("_sdk/metadata.json"),
+)
+
+
+class ClassCPrepareBootstrapError(RuntimeError):
+    """The ancestor source runtime could not be materialized exactly."""
+
+
+def _run_git(root: Path, *arguments: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ("git", "-C", str(root), *arguments),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _git_commit(root: Path, revision: str) -> str:
+    completed = _run_git(root, "rev-parse", "--verify", f"{revision}^{{commit}}")
+    value = completed.stdout.strip()
+    if (
+        completed.returncode != 0
+        or len(value) != 40
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise ClassCPrepareBootstrapError(
+            f"cannot resolve Git revision {revision!r}"
+        )
+    return value
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _native_build_inputs_digest(
+    root: Path,
+    *,
+    normalize_release_cargo_lock: bool = False,
+) -> str:
+    identity_path = root / "build_backend/native_build_identity.py"
+    if identity_path.is_file():
+        identity_name = hashlib.sha256(
+            str(root.resolve()).encode("utf-8")
+        ).hexdigest()[:12]
+        spec = importlib.util.spec_from_file_location(
+            f"_pyamplicol_ancestor_native_identity_{identity_name}",
+            identity_path,
+        )
+        if spec is None or spec.loader is None:
+            raise ClassCPrepareBootstrapError(
+                "ancestor native-build identity module is unavailable"
+            )
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        digest = getattr(module, "native_build_inputs_digest", None)
+        if not callable(digest):
+            raise ClassCPrepareBootstrapError(
+                "ancestor native-build identity module has no digest callable"
+            )
+        try:
+            parameters = inspect.signature(digest).parameters.values()
+        except (TypeError, ValueError) as error:
+            raise ClassCPrepareBootstrapError(
+                "ancestor native-build identity callable cannot be inspected"
+            ) from error
+        supports_release_projection = any(
+            parameter.name == "normalize_release_cargo_lock"
+            or parameter.kind is inspect.Parameter.VAR_KEYWORD
+            for parameter in parameters
+        )
+        if normalize_release_cargo_lock and not supports_release_projection:
+            raise ClassCPrepareBootstrapError(
+                "ancestor native-build identity cannot verify a release-mode "
+                "source runtime"
+            )
+        if supports_release_projection:
+            return str(
+                digest(
+                    root,
+                    normalize_release_cargo_lock=normalize_release_cargo_lock,
+                )
+            )
+        return str(digest(root))
+
+    if normalize_release_cargo_lock:
+        raise ClassCPrepareBootstrapError(
+            "legacy ancestor native-build identity cannot verify a release-mode "
+            "source runtime"
+        )
+    paths = [
+        root / relative for relative in _LEGACY_NATIVE_BUILD_INPUT_FILES
+    ]
+    for relative in _LEGACY_NATIVE_BUILD_INPUT_TREES:
+        tree = root / relative
+        if not tree.is_dir():
+            continue
+        paths.extend(
+            path
+            for path in tree.rglob("*")
+            if path.is_file()
+            and not {"__pycache__", "target"}.intersection(
+                path.relative_to(tree).parts
+            )
+            and path.suffix in _LEGACY_NATIVE_BUILD_INPUT_SUFFIXES
+        )
+    digest = hashlib.sha256()
+    for path in sorted(set(paths)):
+        if not path.is_file():
+            continue
+        relative = path.relative_to(root).as_posix().encode("utf-8")
+        data = path.read_bytes()
+        digest.update(len(relative).to_bytes(8, "little"))
+        digest.update(relative)
+        digest.update(len(data).to_bytes(8, "little"))
+        digest.update(data)
+    return digest.hexdigest()
+
+
+def _regular_file(path: Path, description: str) -> Path:
+    try:
+        resolved = path.resolve(strict=True)
+    except OSError as error:
+        raise ClassCPrepareBootstrapError(f"{description} is unavailable") from error
+    if path.is_symlink() or not resolved.is_file():
+        raise ClassCPrepareBootstrapError(
+            f"{description} must be one regular file"
+        )
+    return resolved
+
+
+def _hardlink(source: Path, destination: Path, description: str) -> None:
+    source = _regular_file(source, description)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if destination.exists() or destination.is_symlink():
+        raise ClassCPrepareBootstrapError(
+            f"ancestor runtime destination already exists: {destination}"
+        )
+    os.link(source, destination)
+    if destination.is_symlink() or not destination.is_file():
+        raise ClassCPrepareBootstrapError(
+            f"ancestor runtime member is not regular: {destination}"
+        )
+
+
+def _hardlink_tree(source: Path, destination: Path, description: str) -> None:
+    try:
+        root = source.resolve(strict=True)
+    except OSError as error:
+        raise ClassCPrepareBootstrapError(f"{description} is unavailable") from error
+    if source.is_symlink() or not root.is_dir():
+        raise ClassCPrepareBootstrapError(
+            f"{description} must be one regular directory tree"
+        )
+    for member in sorted(root.rglob("*")):
+        relative = member.relative_to(root)
+        if member.is_symlink():
+            raise ClassCPrepareBootstrapError(
+                f"{description} contains a symlink: {relative}"
+            )
+        if member.is_dir():
+            (destination / relative).mkdir(parents=True, exist_ok=True)
+        elif member.is_file():
+            _hardlink(member, destination / relative, description)
+        else:
+            raise ClassCPrepareBootstrapError(
+                f"{description} contains a non-file member: {relative}"
+            )
+
+
+def _read_build_info(path: Path) -> dict[str, object]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise ClassCPrepareBootstrapError(
+            "retained source-runtime build info is unreadable"
+        ) from error
+    if not isinstance(value, dict):
+        raise ClassCPrepareBootstrapError(
+            "retained source-runtime build info is invalid"
+        )
+    return value
+
+
+def _bind_ancestor_runtime(
+    live_root: Path,
+    ancestor_root: Path,
+) -> dict[str, object]:
+    """Bind the exact ignored source-runtime inputs into a tracked A worktree."""
+
+    live_package = live_root / "src/pyamplicol"
+    ancestor_package = ancestor_root / "src/pyamplicol"
+    extensions = tuple(
+        path
+        for path in live_package.glob("_rusticol.*")
+        if path.is_file()
+        and not path.is_symlink()
+        and path.name.endswith(_NATIVE_EXTENSION_SUFFIXES)
+    )
+    if len(extensions) != 1:
+        raise ClassCPrepareBootstrapError(
+            "live staged runtime must expose exactly one regular native extension"
+        )
+    extension = extensions[0]
+
+    source_runtime = live_root / ".artifacts/source-runtime"
+    try:
+        source_runtime_target = source_runtime.resolve(strict=True)
+    except OSError as error:
+        raise ClassCPrepareBootstrapError(
+            "retained source-runtime directory is unavailable"
+        ) from error
+    if not source_runtime_target.is_dir():
+        raise ClassCPrepareBootstrapError(
+            "retained source-runtime path is not a directory"
+        )
+    build_info = _read_build_info(source_runtime_target / "_build_info.json")
+    contract = build_info.get("source_runtime")
+    if not isinstance(contract, Mapping):
+        raise ClassCPrepareBootstrapError(
+            "retained source-runtime contract is missing"
+        )
+    raw_mode = contract.get("mode")
+    if raw_mode is None:
+        # Historical source-runtime markers predate the explicit identity mode
+        # and always used the raw candidate/source-checkout projection.
+        runtime_mode = "candidate"
+    elif raw_mode in {"candidate", "release"}:
+        runtime_mode = str(raw_mode)
+        valid_build_mode = (
+            runtime_mode == "candidate"
+            and build_info.get("publishable") is False
+        ) or (
+            runtime_mode == "release"
+            and (
+                build_info.get("publishable") is True
+                or (
+                    build_info.get("publishable") is False
+                    and build_info.get("release_prepared_model_bootstrap") is True
+                )
+            )
+        )
+        if not valid_build_mode:
+            raise ClassCPrepareBootstrapError(
+                "retained source-runtime identity mode conflicts with build info"
+            )
+    else:
+        raise ClassCPrepareBootstrapError(
+            "retained source-runtime identity mode is invalid"
+        )
+    extension_sha256 = _sha256(extension)
+    if (
+        contract.get("extension_name") != extension.name
+        or contract.get("extension_sha256") != extension_sha256
+    ):
+        raise ClassCPrepareBootstrapError(
+            "retained native extension differs from source-runtime build info"
+        )
+
+    _hardlink(
+        extension,
+        ancestor_package / extension.name,
+        "retained native extension",
+    )
+    for relative in _STAGED_SDK_DIRECTORIES:
+        _hardlink_tree(
+            live_package / relative,
+            ancestor_package / relative,
+            f"retained SDK tree {relative}",
+        )
+    for relative in _STAGED_SDK_FILES:
+        _hardlink(
+            live_package / relative,
+            ancestor_package / relative,
+            f"retained SDK member {relative}",
+        )
+    try:
+        metadata = json.loads(
+            (live_package / "_sdk/metadata.json").read_text(encoding="utf-8")
+        )
+        target = str(metadata["target"])
+    except (OSError, KeyError, TypeError, ValueError, json.JSONDecodeError) as error:
+        raise ClassCPrepareBootstrapError(
+            "retained SDK target metadata is invalid"
+        ) from error
+    if not target or target in {".", ".."} or "/" in target or "\\" in target:
+        raise ClassCPrepareBootstrapError(
+            f"retained SDK target is unsafe: {target!r}"
+        )
+    _hardlink_tree(
+        live_package / "assets/selftest" / target,
+        ancestor_package / "assets/selftest" / target,
+        "retained target self-test fixture",
+    )
+
+    ancestor_artifacts = ancestor_root / ".artifacts"
+    ancestor_artifacts.mkdir()
+    os.symlink(
+        source_runtime_target,
+        ancestor_artifacts / "source-runtime",
+        target_is_directory=True,
+    )
+    if runtime_mode == "candidate":
+        dependencies = ancestor_root / "dependencies"
+        checkouts = (live_root / "dependencies/checkouts").resolve(strict=True)
+        if not checkouts.is_dir():
+            raise ClassCPrepareBootstrapError(
+                "retained managed dependency checkout root is unavailable"
+            )
+        os.symlink(checkouts, dependencies / "checkouts", target_is_directory=True)
+        for relative in _IGNORED_NATIVE_INPUTS:
+            source = (live_root / relative).resolve(strict=True)
+            if not source.is_file():
+                raise ClassCPrepareBootstrapError(
+                    f"retained native input is unavailable: {relative}"
+                )
+            destination = ancestor_root / relative
+            if destination.exists() or destination.is_symlink():
+                raise ClassCPrepareBootstrapError(
+                    f"ancestor native input unexpectedly exists: {relative}"
+                )
+            os.symlink(source, destination)
+
+    observed_native_digest = _native_build_inputs_digest(
+        ancestor_root,
+        normalize_release_cargo_lock=runtime_mode == "release",
+    )
+    expected_native_digest = contract.get("native_build_inputs_sha256")
+    if (
+        not isinstance(expected_native_digest, str)
+        or observed_native_digest != expected_native_digest
+    ):
+        raise ClassCPrepareBootstrapError(
+            "materialized ancestor native inputs differ from retained build info"
+        )
+    return {
+        "candidate_fingerprint": build_info.get("candidate_fingerprint"),
+        "extension_name": extension.name,
+        "extension_sha256": extension_sha256,
+        "native_build_inputs_sha256": observed_native_digest,
+        "package_version": build_info.get("version"),
+        "target": target,
+    }
+
+
+def _profile(value: str) -> str:
+    if _PROFILE_RE.fullmatch(value) is None or ".." in value:
+        raise argparse.ArgumentTypeError("invalid performance-report profile")
+    return value
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repo-root", type=Path, default=ROOT)
+    parser.add_argument("--report-profile", type=_profile, required=True)
+    parser.add_argument("--artifact-root", type=Path)
+    parser.add_argument("--coordination-root", type=Path)
+    parser.add_argument("--ancestor-revision", required=True)
+    parser.add_argument("--descendant-revision", required=True)
+    parser.add_argument(
+        "--impact",
+        choices=("hzz-orientation-v1", "recurrence-summary-cap-v1"),
+        required=True,
+    )
+    return parser
+
+
+def _cleanup_worktree(repo_root: Path, worktree: Path) -> None:
+    completed = _run_git(repo_root, "worktree", "remove", "--force", str(worktree))
+    if completed.returncode != 0:
+        _run_git(repo_root, "worktree", "prune")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        repo_root = args.repo_root.expanduser().resolve(strict=True)
+        ancestor = _git_commit(repo_root, args.ancestor_revision)
+        descendant = _git_commit(repo_root, args.descendant_revision)
+        if ancestor == descendant or _git_commit(repo_root, "HEAD") != descendant:
+            raise ClassCPrepareBootstrapError(
+                "live checkout must be at the distinct requested descendant"
+            )
+        ancestry = _run_git(
+            repo_root,
+            "merge-base",
+            "--is-ancestor",
+            ancestor,
+            descendant,
+        )
+        if ancestry.returncode != 0:
+            raise ClassCPrepareBootstrapError(
+                "Class-C descendant is not a Git descendant of its ancestor"
+            )
+        entrypoint = (
+            repo_root
+            / "docs/performance_reports"
+            / args.report_profile
+            / "result_tables.py"
+        )
+        if not entrypoint.is_file() or entrypoint.is_symlink():
+            raise ClassCPrepareBootstrapError(
+                "descendant report entrypoint is unavailable"
+            )
+
+        temporary_parent = Path(
+            tempfile.mkdtemp(
+                prefix=".pyamplicol-class-c-ancestor-runtime-",
+                dir=repo_root.parent,
+            )
+        )
+        ancestor_root = temporary_parent / "worktree"
+        try:
+            added = _run_git(
+                repo_root,
+                "worktree",
+                "add",
+                "--detach",
+                str(ancestor_root),
+                ancestor,
+            )
+            if added.returncode != 0:
+                raise ClassCPrepareBootstrapError(
+                    "cannot materialize the tracked ancestor worktree: "
+                    f"{added.stderr.strip()}"
+                )
+            runtime = _bind_ancestor_runtime(repo_root, ancestor_root)
+            print(
+                json.dumps(
+                    {
+                        "ancestor_revision": ancestor,
+                        "ancestor_runtime_root": str(ancestor_root),
+                        "descendant_revision": descendant,
+                        "descendant_tools_root": str(repo_root),
+                        **runtime,
+                    },
+                    allow_nan=False,
+                    sort_keys=True,
+                ),
+                flush=True,
+            )
+            command = [
+                sys.executable,
+                str(entrypoint),
+                "--repo-root",
+                str(repo_root),
+                "--report-profile",
+                args.report_profile,
+                "--class-c-ancestor-runtime-root",
+                str(ancestor_root),
+            ]
+            if args.artifact_root is not None:
+                command.extend(("--artifact-root", str(args.artifact_root)))
+            if args.coordination_root is not None:
+                command.extend(
+                    ("--coordination-root", str(args.coordination_root))
+                )
+            command.extend(
+                (
+                    "prepare-class-c-bridge",
+                    "--ancestor-revision",
+                    ancestor,
+                    "--descendant-revision",
+                    descendant,
+                    "--impact",
+                    args.impact,
+                )
+            )
+            completed = subprocess.run(command, check=False)
+            if completed.returncode != 0:
+                raise ClassCPrepareBootstrapError(
+                    "descendant Class-C prepare controller failed "
+                    f"with exit code {completed.returncode}"
+                )
+        finally:
+            if ancestor_root.exists():
+                _cleanup_worktree(repo_root, ancestor_root)
+            shutil.rmtree(temporary_parent, ignore_errors=True)
+        return 0
+    except (ClassCPrepareBootstrapError, OSError) as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/prepare_source_runtime.py b/pyamplicol/tools/developer/prepare_source_runtime.py
new file mode 100644
index 0000000000..2784046411
--- /dev/null
+++ b/pyamplicol/tools/developer/prepare_source_runtime.py
@@ -0,0 +1,502 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Stage a freshly built wheel's native resources for source-tree tests."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import os
+import platform
+import shutil
+import sys
+import zipfile
+from collections.abc import Mapping, Sequence
+from contextlib import contextmanager
+from email import policy
+from email.parser import BytesParser
+from pathlib import Path, PurePosixPath
+
+ROOT = Path(__file__).resolve().parents[2]
+RELEASE_TOOLS = ROOT / "tools" / "release"
+sys.path.insert(0, str(RELEASE_TOOLS))
+
+from _artifacts import audit_wheel  # noqa: E402
+from _common import (  # noqa: E402
+    ReleaseError,
+    build_mode,
+    clean_environment,
+    exactly_one,
+    external_temporary_directory,
+    is_relative_to,
+    run,
+)
+
+SOURCE_PACKAGE = ROOT / "src" / "pyamplicol"
+SOURCE_RUNTIME_ROOT = ROOT / ".artifacts" / "source-runtime"
+SOURCE_BUILD_INFO = SOURCE_RUNTIME_ROOT / "_build_info.json"
+SOURCE_RUNTIME_STAGING = SOURCE_RUNTIME_ROOT / ".staging"
+_SDK_PREFIXES = (
+    "pyamplicol/_sdk/fortran/",
+    "pyamplicol/_sdk/include/",
+    "pyamplicol/_sdk/lib/",
+)
+_SDK_FILES = {
+    "pyamplicol/_sdk/link.json",
+    "pyamplicol/_sdk/metadata.json",
+}
+_NATIVE_EXTENSION_SUFFIXES = (".dylib", ".pyd", ".so")
+
+sys.path.insert(0, str(ROOT / "build_backend"))
+from native_build_identity import native_build_inputs_digest  # noqa: E402
+
+sys.path.pop(0)
+
+
+def _host_target() -> str | None:
+    machine = platform.machine().lower()
+    if machine in {"arm64", "aarch64"} and sys.platform == "darwin":
+        return "aarch64-apple-darwin"
+    if machine in {"amd64", "x86_64"} and sys.platform == "darwin":
+        return "x86_64-apple-darwin"
+    if machine in {"amd64", "x86_64"} and sys.platform.startswith("linux"):
+        return "x86_64-unknown-linux-gnu"
+    return None
+
+
+@contextmanager
+def _publication_lock(directory: Path):
+    """Serialize the developer-only publication of source runtime files."""
+
+    try:
+        import fcntl
+    except ImportError as error:  # pragma: no cover - unsupported build host
+        raise ReleaseError(
+            "source runtime publication requires a POSIX advisory lock"
+        ) from error
+    directory.mkdir(parents=True, exist_ok=True)
+    with (directory / ".publication.lock").open("a+b") as stream:
+        fcntl.flock(stream.fileno(), fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            fcntl.flock(stream.fileno(), fcntl.LOCK_UN)
+
+
+def _native_build_inputs_digest(
+    root: Path,
+    *,
+    normalize_release_cargo_lock: bool = False,
+) -> str:
+    return native_build_inputs_digest(
+        root,
+        normalize_release_cargo_lock=normalize_release_cargo_lock,
+    )
+
+
+def _wheel_identity(members: Mapping[str, bytes]) -> tuple[str, str]:
+    metadata_names = [name for name in members if name.endswith(".dist-info/METADATA")]
+    if len(metadata_names) != 1:
+        raise ReleaseError("source runtime wheel must contain one METADATA file")
+    metadata = BytesParser(policy=policy.default).parsebytes(members[metadata_names[0]])
+    name = str(metadata.get("Name", ""))
+    version = str(metadata.get("Version", ""))
+    if name != "pyamplicol" or not version:
+        raise ReleaseError("source runtime wheel has an invalid distribution identity")
+    return name, version
+
+
+def _safe_destination(source_package: Path, member: str) -> Path:
+    relative = PurePosixPath(member).relative_to("pyamplicol")
+    if relative.is_absolute() or any(
+        part in {"", ".", ".."} for part in relative.parts
+    ):
+        raise ReleaseError(f"unsafe source runtime wheel member: {member}")
+    destination = source_package.joinpath(*relative.parts).resolve()
+    if not is_relative_to(destination, source_package.resolve()):
+        raise ReleaseError(f"source runtime wheel member escapes package: {member}")
+    return destination
+
+
+def _write_atomic(path: Path, data: bytes, *, mode: int = 0o644) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.staging-{os.getpid()}")
+    temporary.write_bytes(data)
+    temporary.chmod(mode)
+    os.replace(temporary, path)
+
+
+def _native_extension_inventory(source_package: Path) -> tuple[Path, ...]:
+    return tuple(
+        sorted(
+            (
+                path
+                for path in source_package.glob("_rusticol.*")
+                if path.is_file() and path.name.endswith(_NATIVE_EXTENSION_SUFFIXES)
+            ),
+            key=lambda path: path.name,
+        )
+    )
+
+
+def _stage_selftest_tree(
+    source_package: Path,
+    members: Mapping[str, bytes],
+    member_modes: Mapping[str, int],
+    *,
+    prefix: str,
+    target: str,
+) -> None:
+    root = source_package / "assets" / "selftest"
+    root.mkdir(parents=True, exist_ok=True)
+    destination = root / target
+    staging = root / f".{target}.staging-{os.getpid()}"
+    previous = root / f".{target}.previous-{os.getpid()}"
+    if staging.exists() or previous.exists():
+        raise ReleaseError("stale source-runtime self-test staging directory exists")
+
+    staging.mkdir()
+    try:
+        for member in sorted(name for name in members if name.startswith(prefix)):
+            relative = PurePosixPath(member).relative_to(prefix)
+            if (
+                relative.is_absolute()
+                or not relative.parts
+                or any(part in {"", ".", ".."} for part in relative.parts)
+            ):
+                raise ReleaseError(f"unsafe source-runtime self-test member: {member}")
+            _write_atomic(
+                staging.joinpath(*relative.parts),
+                members[member],
+                mode=member_modes[member] or 0o644,
+            )
+
+        moved_previous = False
+        if destination.exists():
+            if destination.is_symlink() or not destination.is_dir():
+                raise ReleaseError(
+                    "source-runtime self-test destination is not a plain directory"
+                )
+            os.replace(destination, previous)
+            moved_previous = True
+        try:
+            os.replace(staging, destination)
+        except BaseException:
+            if moved_previous:
+                os.replace(previous, destination)
+            raise
+        if moved_previous:
+            shutil.rmtree(previous)
+    except BaseException:
+        if staging.exists():
+            shutil.rmtree(staging)
+        raise
+
+
+def _stage_runtime_locked(
+    wheel: Path,
+    *,
+    source_package: Path = SOURCE_PACKAGE,
+    source_build_info: Path = SOURCE_BUILD_INFO,
+    source_root: Path = ROOT,
+    mode: str,
+    audit: bool = True,
+) -> dict[str, object]:
+    """Stage one wheel and publish its provenance only after all payloads."""
+
+    if mode not in {"candidate", "release"}:
+        raise ReleaseError(f"unsupported source runtime mode: {mode}")
+    marker = source_build_info.parent / ".staging"
+    _write_atomic(marker, b"incomplete\n", mode=0o600)
+    wheel = wheel.resolve(strict=True)
+    if audit:
+        audit_wheel(wheel, mode=mode)
+    with zipfile.ZipFile(wheel) as archive:
+        member_modes = {
+            info.filename: (info.external_attr >> 16) & 0o777
+            for info in archive.infolist()
+            if not info.is_dir()
+        }
+        members = {
+            info.filename: archive.read(info)
+            for info in archive.infolist()
+            if not info.is_dir()
+        }
+    _, version = _wheel_identity(members)
+
+    extension_names = [
+        name
+        for name in members
+        if name.startswith("pyamplicol/_rusticol.")
+        and name.rsplit(".", 1)[-1] in {"dylib", "pyd", "so"}
+    ]
+    if len(extension_names) != 1:
+        raise ReleaseError(
+            "source runtime wheel must contain one Rusticol extension, found "
+            f"{len(extension_names)}"
+        )
+    sdk_metadata_name = "pyamplicol/_sdk/metadata.json"
+    try:
+        sdk_metadata = json.loads(members[sdk_metadata_name])
+        target = str(sdk_metadata["target"])
+    except (KeyError, TypeError, ValueError, json.JSONDecodeError) as error:
+        raise ReleaseError("source runtime wheel has invalid SDK metadata") from error
+    if not target or target in {".", ".."} or "/" in target or "\\" in target:
+        raise ReleaseError(f"source runtime wheel has an unsafe target: {target!r}")
+    host_target = _host_target()
+    if host_target is not None and target != host_target:
+        raise ReleaseError(
+            f"source runtime wheel targets {target}, but this host requires "
+            f"{host_target}"
+        )
+
+    build_info_name = "pyamplicol/_build_info.json"
+    if build_info_name in members:
+        try:
+            build_info = json.loads(members[build_info_name])
+        except (TypeError, ValueError) as error:
+            raise ReleaseError(
+                "source runtime wheel has invalid build metadata"
+            ) from error
+        if not isinstance(build_info, dict):
+            raise ReleaseError("source runtime wheel build metadata must be an object")
+    else:
+        build_info = {
+            "schema_version": 1,
+            "publishable": mode == "release",
+            "version": version,
+        }
+    if build_info.get("version") != version:
+        raise ReleaseError(
+            "source runtime wheel build metadata and METADATA versions differ"
+        )
+    native_digest = _native_build_inputs_digest(
+        source_root,
+        normalize_release_cargo_lock=mode == "release",
+    )
+    if mode == "candidate":
+        if build_info.get("publishable") is not False:
+            raise ReleaseError("candidate source runtime wheel is not marked candidate")
+        if build_info.get("native_build_inputs_sha256") != native_digest:
+            raise ReleaseError(
+                "candidate source runtime wheel was built from different native "
+                "sources; rerun `just dev-install`"
+            )
+    elif not (
+        build_info.get("publishable") is True
+        or (
+            build_info.get("publishable") is False
+            and build_info.get("release_prepared_model_bootstrap") is True
+        )
+    ):
+        raise ReleaseError(
+            "release source runtime wheel has an inconsistent release marker"
+        )
+
+    selftest_prefix = f"pyamplicol/assets/selftest/{target}/"
+    selected = {
+        name
+        for name in members
+        if name in extension_names
+        or name in _SDK_FILES
+        or name.startswith(_SDK_PREFIXES)
+        or name.startswith(selftest_prefix)
+    }
+    has_selftest = any(name.startswith(selftest_prefix) for name in selected)
+    fixture_bootstrap = (
+        build_info.get("publishable") is False
+        and build_info.get("selftest_fixture_bootstrap") is True
+    )
+    if not has_selftest and not fixture_bootstrap:
+        raise ReleaseError(
+            f"source runtime wheel has no self-test fixture for {target}"
+        )
+    for member in sorted(
+        name for name in selected if not name.startswith(selftest_prefix)
+    ):
+        _write_atomic(
+            _safe_destination(source_package, member),
+            members[member],
+            mode=member_modes[member] or 0o644,
+        )
+    if has_selftest:
+        _stage_selftest_tree(
+            source_package,
+            members,
+            member_modes,
+            prefix=selftest_prefix,
+            target=target,
+        )
+
+    expected_extension = PurePosixPath(extension_names[0]).name
+    for path in _native_extension_inventory(source_package):
+        if path.name != expected_extension:
+            path.unlink()
+    final_extensions = _native_extension_inventory(source_package)
+    if len(final_extensions) != 1 or final_extensions[0].name != expected_extension:
+        raise ReleaseError("source runtime extension publication was not exact")
+
+    build_info["native_build_inputs_sha256"] = native_digest
+    build_info["source_runtime"] = {
+        "extension_name": expected_extension,
+        "extension_sha256": hashlib.sha256(members[extension_names[0]]).hexdigest(),
+        "mode": mode,
+        "native_build_inputs_sha256": native_digest,
+    }
+    _write_atomic(
+        source_build_info,
+        (json.dumps(build_info, indent=2, sort_keys=True) + "\n").encode("utf-8"),
+    )
+    marker.unlink()
+    return {
+        "mode": mode,
+        "target": target,
+        "version": version,
+        "wheel": wheel.name,
+        "staged_file_count": len(selected) + 1,
+    }
+
+
+def stage_runtime(
+    wheel: Path,
+    *,
+    source_package: Path = SOURCE_PACKAGE,
+    source_build_info: Path = SOURCE_BUILD_INFO,
+    source_root: Path = ROOT,
+    mode: str,
+    audit: bool = True,
+) -> dict[str, object]:
+    """Stage one wheel while excluding concurrent developer publications."""
+
+    with _publication_lock(source_build_info.parent):
+        return _stage_runtime_locked(
+            wheel,
+            source_package=source_package,
+            source_build_info=source_build_info,
+            source_root=source_root,
+            mode=mode,
+            audit=audit,
+        )
+
+
+def build_and_stage(*, python: Path, mode: str) -> dict[str, object]:
+    with external_temporary_directory("pyamplicol-source-runtime-") as temporary:
+        run(
+            [
+                python,
+                "-m",
+                "build",
+                "--wheel",
+                "--outdir",
+                temporary,
+                *(
+                    ["--config-setting", "pyamplicol.host-wheel=true"]
+                    if sys.platform == "linux"
+                    else []
+                ),
+            ],
+            cwd=ROOT,
+            env=clean_environment(mode=mode),
+        )
+        wheel = exactly_one(
+            list(temporary.glob("pyamplicol-*.whl")),
+            "fresh source-test wheel",
+        )
+        # Source staging consumes the backend's unrepaired local wheel. Release
+        # artifact auditing, including final manylinux tags, runs separately.
+        return stage_runtime(wheel, mode=mode, audit=False)
+
+
+def stage_from_directory(directory: Path, *, mode: str) -> dict[str, object]:
+    """Stage the one candidate wheel already retained in ``directory``."""
+
+    directory = directory.expanduser().resolve(strict=True)
+    if not directory.is_dir():
+        raise ReleaseError(
+            f"source runtime wheel directory is not a directory: {directory}"
+        )
+    wheel = exactly_one(
+        list(directory.glob("pyamplicol-*.whl")),
+        "existing source-test wheel",
+    )
+    return stage_runtime(wheel, mode=mode, audit=False)
+
+
+def _runtime_versions():
+    # Import the lightweight verifier directly: importing pyamplicol would
+    # itself reject a stale runtime before we can rebuild it.
+    spec = importlib.util.spec_from_file_location(
+        "_source_runtime_versions", SOURCE_PACKAGE / "_internal" / "versions.py"
+    )
+    if spec is None or spec.loader is None:
+        raise ReleaseError("cannot load the source runtime identity verifier")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def reuse_current_runtime(*, mode: str) -> dict[str, object] | None:
+    """Reuse only the current, completely staged runtime in the requested mode."""
+
+    with _publication_lock(SOURCE_RUNTIME_ROOT):
+        if SOURCE_RUNTIME_STAGING.exists() or not SOURCE_BUILD_INFO.is_file():
+            return None
+        versions = _runtime_versions()
+        try:
+            payload = versions._read_build_info(
+                SOURCE_BUILD_INFO, "source runtime provenance"
+            )
+            contract = payload.get("source_runtime")
+            if not isinstance(contract, dict) or contract.get("mode") != mode:
+                return None
+            version = payload.get("version")
+            if not isinstance(version, str) or not version:
+                return None
+            versions._verify_source_runtime(
+                payload, package_root=SOURCE_PACKAGE, source_root=ROOT
+            )
+        except (OSError, RuntimeError):
+            return None
+        return {"mode": mode, "version": version, "reused": True}
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--candidate", action="store_true")
+    parser.add_argument("--python", type=Path, default=Path(sys.executable))
+    source = parser.add_mutually_exclusive_group()
+    source.add_argument(
+        "--wheel-directory",
+        type=Path,
+        help="stage an already built local wheel instead of rebuilding it",
+    )
+    source.add_argument(
+        "--reuse-current",
+        action="store_true",
+        help="reuse a matching staged runtime; otherwise build and stage normally",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    mode = build_mode(candidate=args.candidate)
+    report = reuse_current_runtime(mode=mode) if args.reuse_current else None
+    if report is None:
+        report = (
+            stage_from_directory(args.wheel_directory, mode=mode)
+            if args.wheel_directory is not None
+            else build_and_stage(python=args.python, mode=mode)
+        )
+    print(json.dumps(report, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except ReleaseError as error:
+        print(f"error: {error}", file=sys.stderr)
+        raise SystemExit(2) from error
diff --git a/pyamplicol/tools/developer/python_dependency_entry.py b/pyamplicol/tools/developer/python_dependency_entry.py
new file mode 100644
index 0000000000..7aca4b6eab
--- /dev/null
+++ b/pyamplicol/tools/developer/python_dependency_entry.py
@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run a module with appended dependencies and fail closed on package shadowing."""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import importlib.metadata
+import importlib.util
+import runpy
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+
+class EntryError(RuntimeError):
+    """Raised when dependency activation would change the measured package."""
+
+
+def _pyamplicol_origin() -> Path:
+    specification = importlib.util.find_spec("pyamplicol")
+    origin = None if specification is None else specification.origin
+    if origin is None:
+        raise EntryError("the selected interpreter has no pyamplicol package")
+    return Path(origin).resolve(strict=True)
+
+
+def activate(path: Path) -> dict[str, str]:
+    dependency_site = path.expanduser().resolve(strict=True)
+    if not dependency_site.is_dir():
+        raise EntryError(f"dependency site is not a directory: {dependency_site}")
+    before = _pyamplicol_origin()
+    original_path = list(sys.path)
+    try:
+        sys.path.insert(0, str(dependency_site))
+        for package in ("numpy", "symbolica", "ufo_model_loader"):
+            importlib.import_module(package)
+    except ImportError as error:
+        raise EntryError(
+            f"dependency site does not provide required package {error.name!r}"
+        ) from error
+    finally:
+        sys.path[:] = original_path
+    if str(dependency_site) not in sys.path:
+        sys.path.append(str(dependency_site))
+    after = _pyamplicol_origin()
+    distribution = importlib.metadata.distribution("pyamplicol")
+    distribution_origin = Path(
+        str(distribution.locate_file("pyamplicol/__init__.py"))
+    ).resolve(strict=True)
+    if before != after or after != distribution_origin:
+        raise EntryError(
+            "dependency activation changed the measured pyamplicol origin: "
+            f"before={before}, after={after}, distribution={distribution_origin}"
+        )
+    for package in ("numpy", "symbolica", "ufo_model_loader"):
+        specification = importlib.util.find_spec(package)
+        origin = None if specification is None else specification.origin
+        if origin is None:
+            raise EntryError(f"required dependency {package!r} has no import origin")
+        resolved_origin = Path(origin).resolve(strict=True)
+        try:
+            resolved_origin.relative_to(dependency_site)
+        except ValueError as error:
+            raise EntryError(
+                f"required dependency {package!r} was not loaded from "
+                f"{dependency_site}: {resolved_origin}"
+            ) from error
+    return {
+        "dependency_site": str(dependency_site),
+        "pyamplicol_origin": str(after),
+    }
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--dependency-site", type=Path, required=True)
+    result.add_argument("--module", required=True)
+    result.add_argument("arguments", nargs=argparse.REMAINDER)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    try:
+        activate(arguments.dependency_site)
+    except (EntryError, OSError) as error:
+        print(f"python-dependency-entry: {error}", file=sys.stderr)
+        return 2
+    target_arguments = list(arguments.arguments)
+    if target_arguments[:1] == ["--"]:
+        target_arguments.pop(0)
+    sys.argv = [arguments.module, *target_arguments]
+    runpy.run_module(arguments.module, run_name="__main__", alter_sys=False)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/qq_z6g_final_comparison.py b/pyamplicol/tools/developer/qq_z6g_final_comparison.py
new file mode 100644
index 0000000000..ca015e342f
--- /dev/null
+++ b/pyamplicol/tools/developer/qq_z6g_final_comparison.py
@@ -0,0 +1,2209 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Render the authenticated final qq -> Z+6g Arena comparison as Markdown.
+
+The tool accepts only a content-addressed M0 request and its accepted combined
+decision.  It re-runs the strict M0 validators over all four pyAmpliCol
+captures and both original-AmpliCol workloads, checks that the stored decision
+is exactly the recomputed decision apart from its creation timestamp/digest,
+and then renders deterministic Markdown from the validated evidence.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import hashlib
+import importlib.util
+import json
+import math
+import os
+import statistics
+import sys
+from collections.abc import Mapping, Sequence
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from types import ModuleType
+from typing import Any, NoReturn
+
+SCRIPT = Path(__file__).resolve()
+DEFAULT_OUTPUT = Path(
+    ".artifacts/developer/qq-z6g-arena-comparison.md"
+)
+PRE_ARENA_REQUEST_KIND = "pyamplicol-qq-z6g-pre-arena-evidence-request"
+PRE_ARENA_REQUEST_SCHEMA = 1
+_PRE_ARENA_REQUEST_KEYS = {
+    "kind",
+    "schema_version",
+    "matrix_aggregate",
+    "primary_results",
+}
+RATIO_PAIRS = (
+    ("compiled", "eager"),
+    ("compiled", "recurrence"),
+    ("eager", "recurrence"),
+)
+
+
+class ComparisonError(RuntimeError):
+    """The accepted evidence cannot support the requested comparison."""
+
+
+@dataclass(frozen=True)
+class Evidence:
+    """Strictly revalidated M0 inputs used to render one document."""
+
+    m0: ModuleType
+    expected: dict[str, Any]
+    captures: dict[tuple[str, str], Any]
+    amplicol: dict[str, Any]
+    validation: dict[str, Any]
+    acceptance: dict[str, Any]
+    request_raw_sha256: str
+    request_canonical_sha256: str
+    acceptance_raw_sha256: str
+    acceptance_content_sha256: str
+    pre_arena: PreArenaEvidence
+
+
+@dataclass(frozen=True)
+class PreArenaEvidence:
+    """Authenticated frozen AArch64 matrix evidence for the primary workload."""
+
+    matrix: ModuleType
+    manifest: Any
+    aggregate: Any
+    results: dict[str, Any]
+    timings: dict[tuple[str, str, str, int], dict[str, Any]]
+    baseline_build: dict[str, Any]
+    current_build: dict[str, Any]
+    baseline_runtime_sha256: str
+    platform: dict[str, Any]
+
+
+def _die(message: str) -> NoReturn:
+    raise ComparisonError(message)
+
+
+def _canonical_bytes(value: object) -> bytes:
+    return json.dumps(
+        value,
+        ensure_ascii=True,
+        allow_nan=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+def _canonical_sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_bytes(value)).hexdigest()
+
+
+def _file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _load_m0() -> ModuleType:
+    path = SCRIPT.with_name("eager_compiled_arena_m0.py")
+    spec = importlib.util.spec_from_file_location("_qq_z6g_comparison_m0", path)
+    if spec is None or spec.loader is None:
+        _die(f"cannot load M0 validator from {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    try:
+        spec.loader.exec_module(module)
+    except Exception as error:
+        raise ComparisonError(f"cannot load M0 validator: {error}") from error
+    return module
+
+
+def _load_matrix() -> ModuleType:
+    path = SCRIPT.with_name("compiled_mode_matrix.py")
+    spec = importlib.util.spec_from_file_location("_qq_z6g_comparison_matrix", path)
+    if spec is None or spec.loader is None:
+        _die(f"cannot load frozen matrix contract from {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    try:
+        spec.loader.exec_module(module)
+    except Exception as error:
+        raise ComparisonError(f"cannot load frozen matrix contract: {error}") from error
+    return module
+
+
+def _mapping(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        _die(f"{label} must be an object")
+    return value
+
+
+def _list(value: object, label: str) -> list[Any]:
+    if not isinstance(value, list):
+        _die(f"{label} must be a list")
+    return value
+
+
+def _text(value: object, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        _die(f"{label} must be a non-empty string")
+    return value
+
+
+def _integer(value: object, label: str, *, minimum: int = 0) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < minimum:
+        _die(f"{label} must be an integer >= {minimum}")
+    return value
+
+
+def _number(
+    value: object,
+    label: str,
+    *,
+    positive: bool = False,
+    nonnegative: bool = False,
+) -> float:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, int | float)
+        or not math.isfinite(float(value))
+    ):
+        _die(f"{label} must be finite")
+    result = float(value)
+    if positive and result <= 0.0:
+        _die(f"{label} must be positive")
+    if nonnegative and result < 0.0:
+        _die(f"{label} must be nonnegative")
+    return result
+
+
+def _sha256(value: object, label: str) -> str:
+    result = _text(value, label)
+    if len(result) != 64 or any(
+        character not in "0123456789abcdef" for character in result
+    ):
+        _die(f"{label} must be a lowercase SHA-256")
+    return result
+
+
+def _revision(value: object, label: str) -> str:
+    result = _text(value, label)
+    if len(result) != 40 or any(
+        character not in "0123456789abcdef" for character in result
+    ):
+        _die(f"{label} must be a full lowercase Git revision")
+    return result
+
+
+def _load_json_ref(
+    m0: ModuleType,
+    path: Path,
+    expected_sha256: str,
+    label: str,
+) -> Any:
+    m0._require_sha256(expected_sha256, f"{label} raw SHA-256")
+    resolved = path.resolve(strict=True)
+    reference = m0.FileRef(
+        path=resolved,
+        stated_path=str(path),
+        size_bytes=resolved.stat().st_size,
+        sha256=expected_sha256,
+    )
+    return m0._load_json_ref(reference, label)
+
+
+def _decision_semantics(
+    *,
+    acceptance: Mapping[str, Any],
+    recomputed: Mapping[str, Any],
+    m0: ModuleType,
+) -> dict[str, Any]:
+    expected_keys = set(recomputed) | {"content_sha256"}
+    if set(acceptance) != expected_keys:
+        _die("M0 acceptance has unknown or missing root keys")
+    without_digest = dict(acceptance)
+    content_sha256 = without_digest.pop("content_sha256")
+    if _sha256(content_sha256, "M0 acceptance content digest") != _canonical_sha256(
+        without_digest
+    ):
+        _die("M0 acceptance content digest is stale")
+    m0._utc(acceptance.get("created_at_utc"), "M0 acceptance creation time")
+    accepted_semantics = dict(without_digest)
+    recomputed_semantics = dict(recomputed)
+    accepted_semantics.pop("created_at_utc")
+    recomputed_semantics.pop("created_at_utc")
+    if accepted_semantics != recomputed_semantics:
+        _die("stored M0 acceptance differs from a fresh strict recomputation")
+    return accepted_semantics
+
+
+def _manifest_ref(
+    *,
+    m0: ModuleType,
+    value: object,
+    base: Path,
+    label: str,
+) -> Any:
+    try:
+        reference = m0._file_ref(value, base=base, label=label)
+        return m0._load_json_ref(reference, label)
+    except Exception as error:
+        raise ComparisonError(f"{label} is invalid: {error}") from error
+
+
+def _matrix_primary_cells(matrix: ModuleType) -> dict[str, Any]:
+    primary = {
+        cell.cell_id: cell
+        for cell in matrix.CANONICAL_CELLS
+        if cell.category == "primary"
+    }
+    if len(primary) != 24:
+        _die("frozen matrix no longer contains exactly 24 primary qq_Z6g cells")
+    expected_axes = {
+        (model, mode, workload, batch)
+        for model in ("built-in", "ufo-sm")
+        for mode in ("eager", "compiled")
+        for workload in ("lc-topology", "lc-union")
+        for batch in (1, 128, 1024)
+    }
+    observed_axes = {
+        (
+            cell.model_kind,
+            cell.execution_mode,
+            cell.workload_key,
+            cell.batch_size,
+        )
+        for cell in primary.values()
+    }
+    if observed_axes != expected_axes:
+        _die("frozen matrix primary qq_Z6g axes have drifted")
+    return primary
+
+
+def _validate_matrix_aggregate(
+    *,
+    matrix: ModuleType,
+    loaded: Any,
+    expected_pre_arena_source_revision: str,
+    expected_pre_arena_build_sha256: str,
+    expected_pre_arena_runtime_sha256: str,
+) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any], dict[str, Any]]:
+    payload = loaded.payload
+    if (
+        payload.get("kind") != matrix.RESULT_KIND
+        or payload.get("schema_version") != matrix.SCHEMA_VERSION
+        or payload.get("matrix_contract") != matrix.MATRIX_CONTRACT
+        or payload.get("complete") is not True
+        or payload.get("run_complete") is not True
+        or payload.get("passes") is not True
+    ):
+        _die("pre-Arena 168-cell matrix aggregate is not a complete acceptance")
+
+    definition = _mapping(payload.get("matrix_definition"), "matrix definition")
+    canonical_definition = [
+        asdict(cell) | {"cell_id": cell.cell_id} for cell in matrix.CANONICAL_CELLS
+    ]
+    if definition.get("sha256") != matrix._canonical_sha256(canonical_definition):
+        _die("pre-Arena matrix definition digest differs from the frozen 168 cells")
+    coverage = _mapping(payload.get("coverage"), "matrix coverage")
+    if (
+        coverage.get("expected") != 168
+        or coverage.get("observed") != 168
+        or coverage.get("missing") != []
+        or coverage.get("unexpected") != []
+        or coverage.get("passes") is not True
+    ):
+        _die("pre-Arena matrix does not cover exactly 168 cells")
+    for gate_name in (
+        "cell_gate",
+        "identity_gate",
+        "gain_gate",
+        "generation_gate",
+        "outer_provenance_gate",
+    ):
+        gate = _mapping(payload.get(gate_name), f"matrix {gate_name}")
+        if gate.get("passes") is not True:
+            _die(f"pre-Arena matrix {gate_name} did not pass")
+
+    expected_builds = _mapping(payload.get("expected_builds"), "matrix builds")
+    if set(expected_builds) != {"baseline", "current"}:
+        _die("pre-Arena matrix build inventory is incomplete")
+    baseline_build = _mapping(expected_builds["baseline"], "baseline build")
+    current_build = _mapping(expected_builds["current"], "matrix current build")
+    for lane, build in (
+        ("baseline", baseline_build),
+        ("current", current_build),
+    ):
+        if set(build) != {
+            "source_revision",
+            "native_build_inputs_sha256",
+            "distribution_content_sha256",
+            "native_module_sha256",
+        }:
+            _die(f"matrix {lane} build identity has unknown or missing fields")
+        _revision(build["source_revision"], f"matrix {lane} source revision")
+        for field in (
+            "native_build_inputs_sha256",
+            "distribution_content_sha256",
+            "native_module_sha256",
+        ):
+            _sha256(build[field], f"matrix {lane} {field}")
+    if (
+        baseline_build["source_revision"] != expected_pre_arena_source_revision
+        or baseline_build["source_revision"] != matrix.FROZEN_BASELINE_SOURCE_REVISION
+    ):
+        _die("matrix baseline is not the explicitly pinned frozen pre-Arena source")
+    if _canonical_sha256(baseline_build) != expected_pre_arena_build_sha256:
+        _die("matrix baseline build identity differs from its explicit digest pin")
+
+    identity_gate = _mapping(payload["identity_gate"], "matrix identity gate")
+    distinct = _mapping(
+        identity_gate.get("distinct_sha256"),
+        "matrix distinct identities",
+    )
+    baseline_runtimes = _list(
+        distinct.get("runtime:baseline"),
+        "matrix baseline runtime identities",
+    )
+    if baseline_runtimes != [expected_pre_arena_runtime_sha256]:
+        _die("matrix baseline runtime identity differs from its explicit digest pin")
+    _sha256(baseline_runtimes[0], "matrix baseline runtime identity")
+
+    provenance = _mapping(payload.get("provenance"), "matrix provenance")
+    preflight = _mapping(provenance.get("preflight"), "matrix preflight")
+    postflight = _mapping(provenance.get("postflight"), "matrix postflight")
+    if preflight != postflight:
+        _die("matrix host/runtime state changed between preflight and postflight")
+    if preflight.get("system") != "Darwin" or preflight.get("machine") != "arm64":
+        _die("pre-Arena matrix is not the required Darwin AArch64 campaign")
+    repository = _mapping(preflight.get("repository"), "matrix repository")
+    if (
+        repository.get("clean") is not True
+        or repository.get("head_revision") != current_build["source_revision"]
+    ):
+        _die("matrix current source was not its exact clean measured revision")
+    platform_record = {
+        key: preflight.get(key) for key in ("platform", "system", "machine")
+    }
+
+    cells = _list(payload.get("cells"), "matrix cell audit")
+    if len(cells) != 168:
+        _die("matrix aggregate does not retain all 168 cell audit records")
+    audits: dict[str, Any] = {}
+    for raw in cells:
+        audit = _mapping(raw, "matrix cell audit record")
+        cell_id = _text(audit.get("cell_id"), "matrix cell id")
+        if cell_id in audits:
+            _die(f"matrix aggregate repeats cell {cell_id}")
+        if audit.get("passes") is not True or audit.get("errors") != []:
+            _die(f"matrix aggregate cell {cell_id} did not pass")
+        audits[cell_id] = audit
+    expected_cell_ids = {cell.cell_id for cell in matrix.CANONICAL_CELLS}
+    if set(audits) != expected_cell_ids:
+        _die("matrix aggregate cell audit inventory differs from the frozen matrix")
+    return audits, baseline_build, current_build, platform_record
+
+
+def _matrix_result_distributions(
+    *,
+    matrix: ModuleType,
+    cell: Any,
+    result: Mapping[str, Any],
+    audit: Mapping[str, Any],
+    baseline_runtime_sha256: str,
+) -> dict[str, Any]:
+    regression = matrix.regression
+    if (
+        result.get("kind") != regression.RESULT_KIND
+        or result.get("schema_version") != regression.SCHEMA_VERSION
+        or result.get("complete") is not True
+        or result.get("performance_result_authoritative") is not True
+        or result.get("passes") is not True
+    ):
+        _die(f"pre-Arena primary result {cell.cell_id} is not authoritative")
+    if matrix._canonical_sha256(result) != audit.get("result_content_sha256"):
+        _die(f"pre-Arena primary result {cell.cell_id} differs from its aggregate")
+    if matrix._canonical_sha256(audit.get("configuration")) != matrix._canonical_sha256(
+        asdict(cell)
+    ):
+        _die(f"pre-Arena aggregate cell {cell.cell_id} configuration drifted")
+    for gate_name in (
+        "gate",
+        "correctness_gate",
+        "arena_profile_gate",
+        "resource_gate",
+    ):
+        gate = _mapping(result.get(gate_name), f"{cell.cell_id} {gate_name}")
+        if gate.get("passes") is not True:
+            _die(f"pre-Arena primary result {cell.cell_id} {gate_name} failed")
+
+    configuration = _mapping(
+        result.get("configuration"),
+        f"{cell.cell_id} configuration",
+    )
+    expected_fields = {
+        "process": cell.process,
+        "model_label": cell.model_kind,
+        "execution_mode": cell.execution_mode,
+        "workload": cell.workload,
+        "jit_optimization_level": cell.jit_optimization_level,
+        "color_accuracy": cell.color_accuracy,
+        "lc_flow_layout": cell.lc_flow_layout,
+        "batch_size": cell.batch_size,
+        "helicities": list(cell.helicities),
+        "color_flows": list(cell.color_flows),
+        "native_wall_time_source": regression.NATIVE_WALL_TIME_SOURCE,
+        "native_wall_time_sample_pass": regression.NATIVE_WALL_TIME_SAMPLE_PASS,
+        "timing_sample_contract": regression.PAIRED_TIMING_SAMPLE_CONTRACT,
+    }
+    for field, expected in expected_fields.items():
+        if configuration.get(field) != expected:
+            _die(f"pre-Arena primary {cell.cell_id} configuration.{field} drifted")
+    sample_count = _integer(
+        configuration.get("independent_samples_per_lane"),
+        f"{cell.cell_id} sample count",
+        minimum=matrix.ACCEPTANCE_SAMPLE_COUNT,
+    )
+    measurements = _list(
+        result.get("measurements"),
+        f"{cell.cell_id} measurements",
+    )
+    if len(measurements) != sample_count * 2:
+        _die(f"pre-Arena primary result {cell.cell_id} sample inventory is incomplete")
+
+    values: dict[str, list[float]] = {"baseline": [], "current": []}
+    runtime_digests: dict[str, set[str]] = {
+        "baseline": set(),
+        "current": set(),
+    }
+    observed_orders: dict[int, list[str]] = {}
+    for raw in measurements:
+        measurement = _mapping(raw, f"{cell.cell_id} measurement")
+        lane = measurement.get("lane")
+        if lane not in values:
+            _die(f"pre-Arena primary result {cell.cell_id} has an unknown lane")
+        pair_index = _integer(
+            measurement.get("pair_index"),
+            f"{cell.cell_id} pair index",
+            minimum=1,
+        )
+        order = _integer(
+            measurement.get("measurement_order"),
+            f"{cell.cell_id} measurement order",
+            minimum=1,
+        )
+        if order not in (1, 2):
+            _die(f"pre-Arena primary result {cell.cell_id} has invalid pair order")
+        pair = observed_orders.setdefault(pair_index, ["", ""])
+        if pair[order - 1]:
+            _die(f"pre-Arena primary result {cell.cell_id} repeats a pair position")
+        pair[order - 1] = str(lane)
+        values[str(lane)].append(
+            _number(
+                measurement.get("wall_seconds_per_point"),
+                f"{cell.cell_id}/{lane} wall time",
+                positive=True,
+            )
+        )
+        runtime = _mapping(
+            measurement.get("runtime_identity"),
+            f"{cell.cell_id}/{lane} runtime identity",
+        )
+        runtime_digests[str(lane)].add(
+            matrix._canonical_sha256(matrix._stable_runtime_identity_value(runtime))
+        )
+    expected_orders = {
+        pair_index: (
+            ["baseline", "current"]
+            if (pair_index - 1) % 2 == 0
+            else ["current", "baseline"]
+        )
+        for pair_index in range(1, sample_count + 1)
+    }
+    if observed_orders != expected_orders or result.get("pair_orders") != list(
+        expected_orders.values()
+    ):
+        _die(f"pre-Arena primary result {cell.cell_id} is not paired/interleaved")
+    if runtime_digests["baseline"] != {baseline_runtime_sha256}:
+        _die(f"pre-Arena primary result {cell.cell_id} baseline runtime drifted")
+    aggregate_runtime_digests = _mapping(
+        audit.get("runtime_identity_sha256_by_lane"),
+        f"{cell.cell_id} aggregate runtime identities",
+    )
+    if {
+        lane: next(iter(digests)) for lane, digests in runtime_digests.items()
+    } != aggregate_runtime_digests:
+        _die(f"pre-Arena primary result {cell.cell_id} runtime audit is stale")
+
+    recomputed = {
+        lane: regression._distribution(lane_values)
+        for lane, lane_values in values.items()
+    }
+    if result.get("distributions") != recomputed:
+        _die(f"pre-Arena primary result {cell.cell_id} distributions are stale")
+    paired = regression._paired_distribution(measurements)
+    if result.get("paired_distribution") != paired:
+        _die(f"pre-Arena primary result {cell.cell_id} paired statistics are stale")
+    correctness = regression._correctness_gate(measurements)
+    if result.get("correctness_gate") != correctness:
+        _die(f"pre-Arena primary result {cell.cell_id} correctness gate is stale")
+    return recomputed
+
+
+def validate_pre_arena_evidence(
+    *,
+    m0: ModuleType,
+    manifest_path: Path,
+    manifest_sha256: str,
+    expected_pre_arena_source_revision: str,
+    expected_pre_arena_build_sha256: str,
+    expected_pre_arena_runtime_sha256: str,
+) -> PreArenaEvidence:
+    """Authenticate the frozen AArch64 matrix and all 24 primary result files."""
+
+    matrix = _load_matrix()
+    manifest_loaded = _load_json_ref(
+        m0,
+        manifest_path,
+        manifest_sha256,
+        "pre-Arena evidence request",
+    )
+    manifest = manifest_loaded.payload
+    if set(manifest) != _PRE_ARENA_REQUEST_KEYS:
+        _die("pre-Arena evidence request has unknown or missing root keys")
+    if (
+        manifest.get("kind") != PRE_ARENA_REQUEST_KIND
+        or manifest.get("schema_version") != PRE_ARENA_REQUEST_SCHEMA
+    ):
+        _die("pre-Arena evidence request kind/schema is unsupported")
+    base = manifest_loaded.ref.path.parent
+    aggregate_loaded = _manifest_ref(
+        m0=m0,
+        value=manifest.get("matrix_aggregate"),
+        base=base,
+        label="pre-Arena matrix aggregate",
+    )
+    audits, baseline_build, current_build, platform_record = _validate_matrix_aggregate(
+        matrix=matrix,
+        loaded=aggregate_loaded,
+        expected_pre_arena_source_revision=expected_pre_arena_source_revision,
+        expected_pre_arena_build_sha256=expected_pre_arena_build_sha256,
+        expected_pre_arena_runtime_sha256=expected_pre_arena_runtime_sha256,
+    )
+    primary = _matrix_primary_cells(matrix)
+    refs = _list(manifest.get("primary_results"), "pre-Arena primary results")
+    if len(refs) != len(primary):
+        _die("pre-Arena evidence request must contain exactly 24 primary results")
+    results: dict[str, Any] = {}
+    timings: dict[tuple[str, str, str, int], dict[str, Any]] = {}
+    for index, value in enumerate(refs):
+        record = _mapping(value, f"pre-Arena primary result ref {index}")
+        if set(record) != {"cell_id", "path", "size_bytes", "sha256"}:
+            _die(f"pre-Arena primary result ref {index} has unknown/missing fields")
+        cell_id = _text(record["cell_id"], f"pre-Arena primary result {index} id")
+        cell = primary.get(cell_id)
+        if cell is None or cell_id in results:
+            _die(f"pre-Arena primary result inventory has invalid cell {cell_id}")
+        loaded = _manifest_ref(
+            m0=m0,
+            value={key: record[key] for key in ("path", "size_bytes", "sha256")},
+            base=base,
+            label=f"pre-Arena primary result {cell_id}",
+        )
+        distributions = _matrix_result_distributions(
+            matrix=matrix,
+            cell=cell,
+            result=loaded.payload,
+            audit=audits[cell_id],
+            baseline_runtime_sha256=expected_pre_arena_runtime_sha256,
+        )
+        results[cell_id] = loaded
+        model = "built-in-sm" if cell.model_kind == "built-in" else "ufo-sm"
+        layout = (
+            "topology-replay"
+            if cell.workload_key == "lc-topology"
+            else "all-flow-union"
+        )
+        key = (model, layout, cell.execution_mode, cell.batch_size)
+        if key in timings:
+            _die(f"pre-Arena primary timing key is duplicated: {key}")
+        timings[key] = distributions
+    if set(results) != set(primary) or len(timings) != 24:
+        _die("pre-Arena primary result inventory is incomplete")
+    return PreArenaEvidence(
+        matrix=matrix,
+        manifest=manifest_loaded,
+        aggregate=aggregate_loaded,
+        results=results,
+        timings=timings,
+        baseline_build=baseline_build,
+        current_build=current_build,
+        baseline_runtime_sha256=expected_pre_arena_runtime_sha256,
+        platform=platform_record,
+    )
+
+
+def _bind_matrix_current_to_final(
+    *,
+    pre_arena: PreArenaEvidence,
+    final_capture: Any,
+    expected_source_revision: str,
+) -> None:
+    current = pre_arena.current_build
+    runtime = _mapping(final_capture.runtime_identity, "final Arena runtime identity")
+    native = _mapping(runtime.get("native_extension"), "final native extension")
+    distribution = _mapping(
+        runtime.get("installed_distribution"),
+        "final installed distribution",
+    )
+    distribution_content = _mapping(
+        distribution.get("distribution_content"),
+        "final distribution content",
+    )
+    expected = {
+        "source_revision": expected_source_revision,
+        "native_build_inputs_sha256": _sha256(
+            native.get("build_inputs_sha256"),
+            "final native build-input digest",
+        ),
+        "distribution_content_sha256": _sha256(
+            distribution_content.get("sha256"),
+            "final distribution-content digest",
+        ),
+        "native_module_sha256": _sha256(
+            native.get("sha256"),
+            "final native-module digest",
+        ),
+    }
+    if current != expected:
+        _die(
+            "168-cell matrix current build does not equal the final M0 "
+            "source/native runtime"
+        )
+
+
+def validate_evidence(
+    *,
+    request_path: Path,
+    request_sha256: str,
+    acceptance_path: Path,
+    acceptance_sha256: str,
+    expected_source_revision: str,
+    expected_runtime_provenance_sha256: str,
+    pre_arena_manifest_path: Path,
+    pre_arena_manifest_sha256: str,
+    expected_pre_arena_source_revision: str,
+    expected_pre_arena_build_sha256: str,
+    expected_pre_arena_runtime_sha256: str,
+) -> Evidence:
+    """Re-run the complete M0 decision and bind it to explicit final identities."""
+
+    m0 = _load_m0()
+    expected_source_revision = _revision(
+        expected_source_revision,
+        "--expected-source-revision",
+    )
+    expected_runtime_provenance_sha256 = _sha256(
+        expected_runtime_provenance_sha256,
+        "--expected-runtime-provenance-sha256",
+    )
+    expected_pre_arena_source_revision = _revision(
+        expected_pre_arena_source_revision,
+        "--expected-pre-arena-source-revision",
+    )
+    expected_pre_arena_build_sha256 = _sha256(
+        expected_pre_arena_build_sha256,
+        "--expected-pre-arena-build-sha256",
+    )
+    expected_pre_arena_runtime_sha256 = _sha256(
+        expected_pre_arena_runtime_sha256,
+        "--expected-pre-arena-runtime-sha256",
+    )
+    request_loaded = _load_json_ref(
+        m0,
+        request_path,
+        request_sha256,
+        "M0 request",
+    )
+    request = request_loaded.payload
+    m0._require_exact_keys(request, m0._REQUEST_KEYS, "M0 request")
+    if (
+        request.get("kind") != m0.REQUEST_KIND
+        or request.get("schema_version") != m0.REQUEST_SCHEMA
+    ):
+        _die("M0 request kind/schema is unsupported")
+    expected = m0._validate_expected(request.get("expected"))
+    if expected["pyamplicol_source_revision"] != expected_source_revision:
+        _die("M0 request does not pin the explicitly requested final source revision")
+    if expected["runtime_provenance_sha256"] != expected_runtime_provenance_sha256:
+        _die("M0 request does not pin the explicitly requested final runtime identity")
+
+    capture_refs, amplicol_refs = m0._request_refs(
+        request,
+        request_loaded.ref.path.parent,
+    )
+    benchmark = m0._load_benchmark_module()
+    captures = {
+        key: m0._validate_capture(
+            m0._load_json_ref(ref, f"{key[0]}/{key[1]} capture"),
+            model=key[0],
+            layout=key[1],
+            expected=expected,
+            benchmark=benchmark,
+        )
+        for key, ref in capture_refs.items()
+    }
+    amplicol = {
+        role: m0._validate_amplicol(
+            m0._load_json_ref(ref, f"amplicol/{role}"),
+            role=role,
+            expected=expected,
+        )
+        for role, ref in amplicol_refs.items()
+    }
+    validation = m0._cross_validate(captures, amplicol)
+    recomputed = m0._accepted_manifest(
+        request_loaded=request_loaded,
+        captures=captures,
+        amplicol=amplicol,
+        validation=validation,
+        expected=expected,
+    )
+
+    acceptance_loaded = _load_json_ref(
+        m0,
+        acceptance_path,
+        acceptance_sha256,
+        "M0 acceptance",
+    )
+    acceptance = acceptance_loaded.payload
+    _decision_semantics(
+        acceptance=acceptance,
+        recomputed=recomputed,
+        m0=m0,
+    )
+    if (
+        acceptance.get("accepted") is not True
+        or acceptance.get("status") != "accepted"
+        or acceptance.get("errors") != []
+    ):
+        _die("M0 decision is not an error-free acceptance")
+    common = _mapping(acceptance.get("common_contract"), "acceptance.common_contract")
+    source = _mapping(common.get("source"), "acceptance.common_contract.source")
+    if source.get("revision") != expected_source_revision:
+        _die("accepted source identity differs from the explicit final revision")
+    if common.get("runtime_provenance_sha256") != expected_runtime_provenance_sha256:
+        _die("accepted runtime identity differs from the explicit final digest")
+    pre_arena = validate_pre_arena_evidence(
+        m0=m0,
+        manifest_path=pre_arena_manifest_path,
+        manifest_sha256=pre_arena_manifest_sha256,
+        expected_pre_arena_source_revision=expected_pre_arena_source_revision,
+        expected_pre_arena_build_sha256=expected_pre_arena_build_sha256,
+        expected_pre_arena_runtime_sha256=expected_pre_arena_runtime_sha256,
+    )
+    primary = _matrix_primary_cells(pre_arena.matrix)
+    topology_cell = next(
+        cell for cell in primary.values() if cell.workload_key == "lc-topology"
+    )
+    union_cell = next(
+        cell for cell in primary.values() if cell.workload_key == "lc-union"
+    )
+    if tuple(topology_cell.color_flows) != (expected["color_flow"]["id"],) or tuple(
+        union_cell.helicities
+    ) != (expected["helicity"]["id"],):
+        _die("pre-Arena and final Arena captures use different runtime selectors")
+    first_capture = captures[("built-in-sm", "topology-replay")]
+    if (
+        pre_arena.platform["system"] != first_capture.host["system"]
+        or pre_arena.platform["machine"] != first_capture.host["machine"]
+    ):
+        _die("pre-Arena and final Arena evidence are not from one architecture")
+    _bind_matrix_current_to_final(
+        pre_arena=pre_arena,
+        final_capture=first_capture,
+        expected_source_revision=expected_source_revision,
+    )
+    return Evidence(
+        m0=m0,
+        expected=expected,
+        captures=captures,
+        amplicol=amplicol,
+        validation=validation,
+        acceptance=acceptance,
+        request_raw_sha256=request_sha256,
+        request_canonical_sha256=request_loaded.canonical_sha256,
+        acceptance_raw_sha256=acceptance_sha256,
+        acceptance_content_sha256=_sha256(
+            acceptance["content_sha256"],
+            "M0 acceptance content digest",
+        ),
+        pre_arena=pre_arena,
+    )
+
+
+def _escape(value: object) -> str:
+    return str(value).replace("|", "\\|").replace("\n", " ")
+
+
+def _table(headers: Sequence[str], rows: Sequence[Sequence[object]]) -> list[str]:
+    if any(len(row) != len(headers) for row in rows):
+        _die("internal Markdown table width mismatch")
+    result = [
+        "| " + " | ".join(_escape(header) for header in headers) + " |",
+        "| " + " | ".join("---" for _ in headers) + " |",
+    ]
+    result.extend(
+        "| " + " | ".join(_escape(value) for value in row) + " |" for row in rows
+    )
+    return result
+
+
+def _model_label(model: str) -> str:
+    return {"built-in-sm": "Built-in SM", "ufo-sm": "UFO SM"}[model]
+
+
+def _layout_label(layout: str) -> str:
+    return {
+        "topology-replay": "Selected LC flow / helicity sum",
+        "all-flow-union": "All LC flows / one helicity",
+    }[layout]
+
+
+def _mode_label(mode: str) -> str:
+    return {
+        "compiled": "Compiled DAG (JIT O3)",
+        "eager": "Eager DAG",
+        "recurrence": "Recurrence",
+    }[mode]
+
+
+def _seconds(value: float) -> str:
+    return f"{value:.9g} s"
+
+
+def _microseconds(value: float) -> str:
+    return f"{value * 1.0e6:.9g} µs/point"
+
+
+def _ratio(value: float) -> str:
+    return f"{value:.9g}x"
+
+
+def _digest(value: str) -> str:
+    return f"`{value}`"
+
+
+def _bytes(value: int) -> str:
+    return f"{value:,} B ({value / (1024 * 1024):.3f} MiB)"
+
+
+def _complex(value: complex) -> str:
+    return f"`{value.real:.17g}{value.imag:+.17g}i`"
+
+
+def _comparison_stats(
+    left: Sequence[complex],
+    right: Sequence[complex],
+    *,
+    absolute_floor: float,
+) -> tuple[float, float]:
+    if len(left) != len(right) or not left:
+        _die("numerical comparison has mismatched or empty point inventories")
+    maximum_absolute = 0.0
+    maximum_relative = 0.0
+    for lhs, rhs in zip(left, right, strict=True):
+        difference = abs(lhs - rhs)
+        relative = difference / max(abs(rhs), absolute_floor)
+        maximum_absolute = max(maximum_absolute, difference)
+        maximum_relative = max(maximum_relative, relative)
+    return maximum_absolute, maximum_relative
+
+
+def _capture_input_rows(evidence: Evidence) -> list[list[object]]:
+    rows: list[list[object]] = [
+        [
+            "Combined request",
+            _digest(evidence.request_raw_sha256),
+            _digest(evidence.request_canonical_sha256),
+        ],
+        [
+            "Combined acceptance",
+            _digest(evidence.acceptance_raw_sha256),
+            _digest(evidence.acceptance_content_sha256),
+        ],
+    ]
+    for model in evidence.m0.MODELS:
+        for layout in evidence.m0.LAYOUTS:
+            loaded = evidence.captures[(model, layout)].loaded
+            rows.append(
+                [
+                    f"{_model_label(model)} — {_layout_label(layout)}",
+                    _digest(loaded.ref.sha256),
+                    _digest(loaded.canonical_sha256),
+                ]
+            )
+    for role in (
+        evidence.m0.AMPLICOL_SELECTED_ROLE,
+        evidence.m0.AMPLICOL_UNION_ROLE,
+    ):
+        loaded = evidence.amplicol[role].loaded
+        rows.append(
+            [
+                f"Original AmpliCol — {role}",
+                _digest(loaded.ref.sha256),
+                _digest(loaded.canonical_sha256),
+            ]
+        )
+    for label, loaded in (
+        ("Pre-Arena evidence request", evidence.pre_arena.manifest),
+        ("Pre-Arena 168-cell aggregate", evidence.pre_arena.aggregate),
+    ):
+        rows.append(
+            [
+                label,
+                _digest(loaded.ref.sha256),
+                _digest(loaded.canonical_sha256),
+            ]
+        )
+    for cell_id, loaded in sorted(evidence.pre_arena.results.items()):
+        rows.append(
+            [
+                f"Pre-Arena primary — {cell_id}",
+                _digest(loaded.ref.sha256),
+                _digest(loaded.canonical_sha256),
+            ]
+        )
+    return rows
+
+
+def _runtime_identity_rows(evidence: Evidence) -> list[list[object]]:
+    first = evidence.captures[("built-in-sm", "topology-replay")]
+    runtime = _mapping(first.runtime_identity, "runtime identity")
+    interpreter = _mapping(runtime.get("interpreter"), "runtime interpreter")
+    native = _mapping(runtime.get("native_extension"), "native extension")
+    distribution = _mapping(
+        runtime.get("installed_distribution"),
+        "installed distribution",
+    )
+    distribution_content = _mapping(
+        distribution.get("distribution_content"),
+        "distribution content",
+    )
+    build_info = _mapping(runtime.get("active_build_info"), "active build info")
+    build_payload = _mapping(build_info.get("payload"), "active build payload")
+    source_revision = evidence.expected["pyamplicol_source_revision"]
+    if build_payload.get("source_revision") != source_revision:
+        _die("active build info source revision is stale")
+    distribution_file_count = _integer(
+        distribution_content.get("file_count"),
+        "distribution file count",
+        minimum=1,
+    )
+    distribution_size = _integer(
+        distribution_content.get("size_bytes"),
+        "distribution size",
+        minimum=1,
+    )
+    distribution_sha256 = _sha256(
+        distribution_content.get("sha256"),
+        "distribution digest",
+    )
+    return [
+        ["pyAmpliCol source revision", _digest(source_revision)],
+        [
+            "Runtime-provenance digest",
+            _digest(evidence.expected["runtime_provenance_sha256"]),
+        ],
+        [
+            "Candidate/package version",
+            _text(distribution.get("package_version"), "distribution package version"),
+        ],
+        [
+            "Candidate fingerprint",
+            _text(build_payload.get("candidate_fingerprint"), "candidate fingerprint"),
+        ],
+        [
+            "Native extension SHA-256",
+            _digest(_sha256(native.get("sha256"), "native extension digest")),
+        ],
+        [
+            "Native build-input SHA-256",
+            _digest(
+                _sha256(
+                    native.get("build_inputs_sha256"),
+                    "native build-input digest",
+                )
+            ),
+        ],
+        [
+            "Installed distribution",
+            (
+                f"{distribution_file_count} files, "
+                f"{_bytes(distribution_size)}; "
+                f"{_digest(distribution_sha256)}"
+            ),
+        ],
+        [
+            "Python interpreter",
+            (
+                f"{_text(interpreter.get('implementation'), 'interpreter')} "
+                f"{_text(interpreter.get('python_version'), 'Python version')}; "
+                f"{_digest(_sha256(interpreter.get('sha256'), 'interpreter digest'))}"
+            ),
+        ],
+    ]
+
+
+def _original_identity_rows(evidence: Evidence) -> list[list[object]]:
+    selected = evidence.amplicol[evidence.m0.AMPLICOL_SELECTED_ROLE]
+    source = _mapping(selected.source_identity, "original AmpliCol source")
+    compiler = _mapping(source.get("compiler"), "original AmpliCol compiler")
+    return [
+        [
+            "Original AmpliCol revision",
+            _digest(_revision(source.get("revision"), "AmpliCol revision")),
+        ],
+        [
+            "Tracked source-tree SHA-256",
+            _digest(_sha256(source.get("source_tree_sha256"), "AmpliCol source tree")),
+        ],
+        [
+            "Fortran compiler",
+            (
+                f"{_text(compiler.get('id'), 'compiler id')} — "
+                f"{_text(compiler.get('version'), 'compiler version')}"
+            ),
+        ],
+        ["Compiler target", _text(compiler.get("target"), "compiler target")],
+        [
+            "Compiler-flags SHA-256",
+            _digest(_sha256(compiler.get("flags_sha256"), "compiler flags")),
+        ],
+    ]
+
+
+def _pre_arena_identity_rows(evidence: Evidence) -> list[list[object]]:
+    baseline = evidence.pre_arena.baseline_build
+    current = evidence.pre_arena.current_build
+    platform_record = evidence.pre_arena.platform
+    return [
+        [
+            "Frozen pre-Arena source revision",
+            _digest(
+                _revision(
+                    baseline["source_revision"],
+                    "pre-Arena source revision",
+                )
+            ),
+        ],
+        [
+            "Frozen pre-Arena build identity SHA-256",
+            _digest(_canonical_sha256(baseline)),
+        ],
+        [
+            "Frozen pre-Arena runtime identity SHA-256",
+            _digest(evidence.pre_arena.baseline_runtime_sha256),
+        ],
+        [
+            "Frozen pre-Arena native build-input SHA-256",
+            _digest(baseline["native_build_inputs_sha256"]),
+        ],
+        [
+            "Frozen pre-Arena distribution SHA-256",
+            _digest(baseline["distribution_content_sha256"]),
+        ],
+        [
+            "Frozen pre-Arena native module SHA-256",
+            _digest(baseline["native_module_sha256"]),
+        ],
+        [
+            "168-cell matrix Arena source revision",
+            _digest(
+                _revision(
+                    current["source_revision"],
+                    "matrix Arena source revision",
+                )
+            ),
+        ],
+        [
+            "168-cell matrix Arena native module SHA-256",
+            _digest(current["native_module_sha256"]),
+        ],
+        [
+            "Matrix platform",
+            (
+                f"{_text(platform_record['system'], 'matrix system')} "
+                f"{_text(platform_record['machine'], 'matrix machine')} — "
+                f"{_text(platform_record['platform'], 'matrix platform')}"
+            ),
+        ],
+    ]
+
+
+def _numerical_sections(evidence: Evidence) -> list[str]:
+    lines: list[str] = [
+        "## Numerical agreement",
+        "",
+        (
+            "The combined M0 validator re-evaluated every retained point, required "
+            "selected totals to close against resolved sums, required all three "
+            "pyAmpliCol lanes to agree, required built-in and UFO models to agree, "
+            "and required both original-AmpliCol workloads to agree with their "
+            "built-in pyAmpliCol counterparts."
+        ),
+        "",
+        "### Pointwise values across model implementations and original AmpliCol",
+        "",
+    ]
+    point_rows: list[list[object]] = []
+    for layout in evidence.m0.LAYOUTS:
+        builtin = evidence.captures[("built-in-sm", layout)].validation_values
+        ufo = evidence.captures[("ufo-sm", layout)].validation_values
+        role = (
+            evidence.m0.AMPLICOL_UNION_ROLE
+            if layout == "all-flow-union"
+            else evidence.m0.AMPLICOL_SELECTED_ROLE
+        )
+        original = evidence.amplicol[role].values
+        if len(builtin) != len(ufo) or len(builtin) != len(original):
+            _die(f"{layout} pointwise inventories differ after M0 validation")
+        for index, (built, external, independent) in enumerate(
+            zip(builtin, ufo, original, strict=True)
+        ):
+            maximum_absolute, maximum_relative = _comparison_stats(
+                (built, built),
+                (external, independent),
+                absolute_floor=evidence.m0.ATOL,
+            )
+            point_rows.append(
+                [
+                    _layout_label(layout),
+                    index,
+                    _complex(built),
+                    _complex(external),
+                    _complex(independent),
+                    f"{maximum_absolute:.9g}",
+                    f"{maximum_relative:.9g}",
+                    "yes",
+                ]
+            )
+    lines.extend(
+        _table(
+            (
+                "Workload",
+                "Point",
+                "Built-in SM",
+                "UFO SM",
+                "Original AmpliCol",
+                "Max |Δ|",
+                "Max relative Δ",
+                "Pass",
+            ),
+            point_rows,
+        )
+    )
+    lines.extend(["", "### Selected-total versus resolved-sum closure", ""])
+    closure_rows: list[list[object]] = []
+    lane_rows: list[list[object]] = []
+    component_rows: list[list[object]] = []
+    for model in evidence.m0.MODELS:
+        for layout in evidence.m0.LAYOUTS:
+            capture = evidence.captures[(model, layout)]
+            payload = capture.loaded.payload
+            profiles = _mapping(payload.get("profiles"), "capture profiles")
+            for mode in evidence.m0.MODES:
+                profile = _mapping(profiles.get(mode), f"{model}/{layout}/{mode}")
+                validation = _mapping(
+                    profile.get("validation"),
+                    f"{model}/{layout}/{mode} validation",
+                )
+                if validation.get("passes") is not True:
+                    _die(f"{model}/{layout}/{mode} validation is not passing")
+                closure_absolute = _number(
+                    validation.get("maximum_absolute_difference"),
+                    "closure max abs",
+                    nonnegative=True,
+                )
+                closure_relative = _number(
+                    validation.get("maximum_relative_difference"),
+                    "closure max rel",
+                    nonnegative=True,
+                )
+                closure_rows.append(
+                    [
+                        _model_label(model),
+                        _layout_label(layout),
+                        _mode_label(mode),
+                        f"{closure_absolute:.9g}",
+                        f"{closure_relative:.9g}",
+                        "yes",
+                    ]
+                )
+            comparisons = _mapping(
+                payload.get("lane_comparisons"),
+                f"{model}/{layout} lane comparisons",
+            )
+            summary = _mapping(
+                payload.get("validation_summary"),
+                f"{model}/{layout} validation summary",
+            )
+            resolved = _mapping(
+                summary.get("resolved_component_comparisons"),
+                f"{model}/{layout} component comparisons",
+            )
+            for left, right in RATIO_PAIRS:
+                key = f"{left}__{right}"
+                comparison = _mapping(comparisons.get(key), f"{model}/{layout}/{key}")
+                if comparison.get("passes") is not True:
+                    _die(f"{model}/{layout}/{key} total comparison failed")
+                lane_absolute = _number(
+                    comparison.get("maximum_absolute_difference"),
+                    "lane max abs",
+                    nonnegative=True,
+                )
+                lane_relative = _number(
+                    comparison.get("maximum_relative_difference"),
+                    "lane max rel",
+                    nonnegative=True,
+                )
+                lane_rows.append(
+                    [
+                        _model_label(model),
+                        _layout_label(layout),
+                        f"{left} vs {right}",
+                        f"{lane_absolute:.9g}",
+                        f"{lane_relative:.9g}",
+                        "yes",
+                    ]
+                )
+                component = _mapping(
+                    resolved.get(key),
+                    f"{model}/{layout}/{key} component comparison",
+                )
+                if component.get("passes") is not True:
+                    _die(f"{model}/{layout}/{key} component comparison failed")
+                component_absolute = _number(
+                    component.get("maximum_absolute_difference"),
+                    "component max abs",
+                    nonnegative=True,
+                )
+                component_relative = _number(
+                    component.get("maximum_relative_difference"),
+                    "component max rel",
+                    nonnegative=True,
+                )
+                component_rows.append(
+                    [
+                        _model_label(model),
+                        _layout_label(layout),
+                        f"{left} vs {right}",
+                        _integer(
+                            component.get("compared_component_count"),
+                            "compared component count",
+                            minimum=1,
+                        ),
+                        f"{component_absolute:.9g}",
+                        f"{component_relative:.9g}",
+                        "yes",
+                    ]
+                )
+    lines.extend(
+        _table(
+            (
+                "Model",
+                "Workload",
+                "Mode",
+                "Max |selected - resolved|",
+                "Max relative Δ",
+                "Pass",
+            ),
+            closure_rows,
+        )
+    )
+    lines.extend(["", "### Cross-lane total agreement", ""])
+    lines.extend(
+        _table(
+            ("Model", "Workload", "Lane pair", "Max |Δ|", "Max relative Δ", "Pass"),
+            lane_rows,
+        )
+    )
+    lines.extend(["", "### Cross-lane resolved-component agreement", ""])
+    lines.extend(
+        _table(
+            (
+                "Model",
+                "Workload",
+                "Lane pair",
+                "Components",
+                "Max |Δ|",
+                "Max relative Δ",
+                "Pass",
+            ),
+            component_rows,
+        )
+    )
+    return lines
+
+
+def _generation_sections(evidence: Evidence) -> list[str]:
+    lines = [
+        "## Generation, artifact, and memory evidence",
+        "",
+        (
+            "Generation wall time and RSS are single worker observations, not "
+            "multi-sample runtime statistics. RSS is the retained high-water-mark "
+            "lower bound described by each capture."
+        ),
+        "",
+    ]
+    rows: list[list[object]] = []
+    phase_rows: list[list[object]] = []
+    for model in evidence.m0.MODELS:
+        for layout in evidence.m0.LAYOUTS:
+            payload = evidence.captures[(model, layout)].loaded.payload
+            generation = _mapping(
+                payload.get("generation"),
+                f"{model}/{layout} generation",
+            )
+            if set(generation) != set(evidence.m0.MODES):
+                _die(f"{model}/{layout} generation inventory is incomplete")
+            for mode in evidence.m0.MODES:
+                record = _mapping(
+                    generation[mode],
+                    f"{model}/{layout}/{mode} generation",
+                )
+                reused = record.get("generation_reused")
+                if not isinstance(reused, bool):
+                    _die(f"{model}/{layout}/{mode} reuse flag is invalid")
+                raw_wall = record.get("generation_wall_seconds")
+                wall = (
+                    "Unavailable (artifact reused)"
+                    if raw_wall is None and reused
+                    else _seconds(
+                        _number(
+                            raw_wall,
+                            f"{model}/{layout}/{mode} generation wall",
+                            positive=True,
+                        )
+                    )
+                )
+                stats = _mapping(
+                    record.get("artifact_stats"),
+                    f"{model}/{layout}/{mode} artifact stats",
+                )
+                files = _integer(
+                    stats.get("file_count"),
+                    "artifact file count",
+                    minimum=1,
+                )
+                size = _integer(
+                    stats.get("size_bytes"),
+                    "artifact size",
+                    minimum=1,
+                )
+                peak = record.get("peak_rss")
+                if peak is None and reused:
+                    rss = "Unavailable (artifact reused)"
+                else:
+                    peak_map = _mapping(peak, "generation peak RSS")
+                    rss = _bytes(
+                        _integer(
+                            peak_map.get("observed_lower_bound_bytes"),
+                            "generation RSS lower bound",
+                            minimum=1,
+                        )
+                    )
+                phases = _mapping(
+                    record.get("phase_timings_seconds"),
+                    f"{model}/{layout}/{mode} phase timings",
+                )
+                phase_values = {
+                    str(name): _number(
+                        value,
+                        f"{model}/{layout}/{mode}/{name}",
+                        nonnegative=True,
+                    )
+                    for name, value in phases.items()
+                }
+                if not phase_values:
+                    _die(f"{model}/{layout}/{mode} has no phase timings")
+                model_load = (
+                    _seconds(phase_values["model-loading"])
+                    if "model-loading" in phase_values
+                    else "Unavailable"
+                )
+                semantic_sha = _sha256(
+                    record.get("artifact_semantic_identity_sha256"),
+                    "artifact semantic identity",
+                )
+                rows.append(
+                    [
+                        _model_label(model),
+                        _layout_label(layout),
+                        _mode_label(mode),
+                        wall,
+                        model_load,
+                        files,
+                        _bytes(size),
+                        rss,
+                        _digest(semantic_sha),
+                    ]
+                )
+                for phase_name in sorted(phase_values):
+                    phase_rows.append(
+                        [
+                            _model_label(model),
+                            _layout_label(layout),
+                            _mode_label(mode),
+                            phase_name,
+                            _seconds(phase_values[phase_name]),
+                        ]
+                    )
+    lines.extend(
+        _table(
+            (
+                "Model",
+                "Workload",
+                "Mode",
+                "Generation wall",
+                "Model-load phase",
+                "Files",
+                "Artifact bytes",
+                "Generation peak RSS lower bound",
+                "Artifact semantic SHA-256",
+            ),
+            rows,
+        )
+    )
+    lines.extend(["", "### Retained generation phase breakdown", ""])
+    lines.extend(
+        _table(
+            ("Model", "Workload", "Mode", "Phase", "Seconds"),
+            phase_rows,
+        )
+    )
+    lines.extend(
+        [
+            "",
+            "### Metrics not retained by the authenticated capture",
+            "",
+        ]
+    )
+    lines.extend(
+        _table(
+            ("Metric", "Status", "Reason"),
+            (
+                (
+                    "Cold artifact load time",
+                    "Unavailable",
+                    "Not retained in the final schema-6 aggregate.",
+                ),
+                (
+                    "Profile-worker RSS",
+                    "Unavailable",
+                    (
+                        "Not retained in the final schema-6 aggregate; only "
+                        "generation RSS is reported above."
+                    ),
+                ),
+                (
+                    "Memory traffic",
+                    "Unavailable",
+                    "No authenticated byte/counter measurement is present.",
+                ),
+                (
+                    "Allocation counts/bytes",
+                    "Unavailable",
+                    "No authenticated allocator measurement is present.",
+                ),
+            ),
+        )
+    )
+    return lines
+
+
+def _raw_round_values(
+    capture: Any,
+    *,
+    mode: str,
+    batch: int,
+) -> dict[int, float]:
+    payload = capture.loaded.payload
+    profiles = _mapping(payload.get("profiles"), "capture profiles")
+    profile = _mapping(profiles.get(mode), f"profile {mode}")
+    measurements = _list(profile.get("profiles"), f"profile {mode} measurements")
+    matches = [
+        _mapping(row, f"{mode}/{batch} measurement")
+        for row in measurements
+        if isinstance(row, dict) and row.get("batch_size") == batch
+    ]
+    if len(matches) != 1:
+        _die(f"{mode}/batch-{batch} does not have exactly one measurement")
+    samples = _list(
+        matches[0].get("subprocess_samples"),
+        f"{mode}/batch-{batch} subprocess samples",
+    )
+    result: dict[int, float] = {}
+    ordered: list[float] = []
+    for sample in samples:
+        row = _mapping(sample, f"{mode}/batch-{batch} sample")
+        round_index = _integer(row.get("round"), "schedule round")
+        if round_index in result:
+            _die(f"{mode}/batch-{batch} repeats schedule round {round_index}")
+        value = _number(
+            row.get("wall_seconds_per_point"),
+            f"{mode}/batch-{batch}/round-{round_index} wall time",
+            positive=True,
+        )
+        if row.get("interrupted") is not False:
+            _die(f"{mode}/batch-{batch}/round-{round_index} was interrupted")
+        result[round_index] = value
+        ordered.append(value)
+    retained = capture.timings[mode][str(batch)]
+    if ordered != retained["raw_seconds_per_point"]:
+        _die(f"{mode}/batch-{batch} raw samples differ from validated M0 timings")
+    return result
+
+
+def _runtime_sections(evidence: Evidence) -> list[str]:
+    lines = [
+        "## Runtime performance",
+        "",
+        (
+            "Values are subprocess medians with raw MAD, normalized to one physical "
+            "phase-space point. The headline source is "
+            "`runtime_core_repeated_wall_time`."
+        ),
+        "",
+        "### Median ± raw MAD",
+        "",
+    ]
+    timing_rows: list[list[object]] = []
+    ratio_rows: list[list[object]] = []
+    for model in evidence.m0.MODELS:
+        for layout in evidence.m0.LAYOUTS:
+            capture = evidence.captures[(model, layout)]
+            for mode in evidence.m0.MODES:
+                for batch in evidence.m0.BATCHES:
+                    timing = _mapping(
+                        capture.timings[mode][str(batch)],
+                        f"{model}/{layout}/{mode}/{batch} timing",
+                    )
+                    median = _number(
+                        timing.get("median_seconds_per_point"),
+                        "runtime median",
+                        positive=True,
+                    )
+                    mad = _number(
+                        timing.get("mad_seconds_per_point"),
+                        "runtime MAD",
+                        nonnegative=True,
+                    )
+                    count = _integer(
+                        timing.get("sample_count"),
+                        "runtime sample count",
+                        minimum=evidence.m0.MIN_SAMPLES,
+                    )
+                    timing_rows.append(
+                        [
+                            _model_label(model),
+                            _layout_label(layout),
+                            _mode_label(mode),
+                            batch,
+                            _microseconds(median),
+                            _microseconds(mad),
+                            count,
+                        ]
+                    )
+            for batch in evidence.m0.BATCHES:
+                by_mode = {
+                    mode: _raw_round_values(capture, mode=mode, batch=batch)
+                    for mode in evidence.m0.MODES
+                }
+                round_sets = {tuple(sorted(values)) for values in by_mode.values()}
+                if len(round_sets) != 1:
+                    _die(f"{model}/{layout}/batch-{batch} round sets differ by mode")
+                rounds = next(iter(round_sets))
+                if len(rounds) < evidence.m0.MIN_SAMPLES:
+                    _die(f"{model}/{layout}/batch-{batch} lacks seven paired rounds")
+                ratios: list[str] = []
+                for left, right in RATIO_PAIRS:
+                    values = [
+                        by_mode[left][round_index] / by_mode[right][round_index]
+                        for round_index in rounds
+                    ]
+                    median = statistics.median(values)
+                    mad = statistics.median(abs(value - median) for value in values)
+                    ratios.append(f"{_ratio(median)} ± {_ratio(mad)}")
+                ratio_rows.append(
+                    [
+                        _model_label(model),
+                        _layout_label(layout),
+                        batch,
+                        len(rounds),
+                        *ratios,
+                    ]
+                )
+    lines.extend(
+        _table(
+            ("Model", "Workload", "Mode", "Batch", "Median", "Raw MAD", "Subprocesses"),
+            timing_rows,
+        )
+    )
+    lines.extend(["", "### Same-round runtime ratios", ""])
+    lines.append(
+        "Each ratio is formed within the same scheduler round before taking "
+        "its median and raw MAD."
+    )
+    lines.append("")
+    lines.extend(
+        _table(
+            (
+                "Model",
+                "Workload",
+                "Batch",
+                "Paired rounds",
+                "Compiled / eager",
+                "Compiled / recurrence",
+                "Eager / recurrence",
+            ),
+            ratio_rows,
+        )
+    )
+    return lines
+
+
+def _pre_arena_comparison_sections(evidence: Evidence) -> list[str]:
+    lines = [
+        "## Frozen pre-Arena comparison",
+        "",
+        (
+            "The baseline and matrix-Arena columns come from the authenticated "
+            "AArch64 168-cell campaign. The final-Arena column comes from the "
+            "strict M0 campaign. All use the same physical process, model family, "
+            "LC selector, execution mode, batch, and runtime-core wall-time "
+            "boundary. These campaigns were not scheduler-round paired, so the "
+            "cross-campaign ratios below are ratios of independently computed "
+            "medians; no paired uncertainty is claimed."
+        ),
+        "",
+    ]
+    rows: list[list[object]] = []
+    for model in evidence.m0.MODELS:
+        for layout in evidence.m0.LAYOUTS:
+            capture = evidence.captures[(model, layout)]
+            for mode in ("compiled", "eager"):
+                for batch in evidence.m0.BATCHES:
+                    distributions = evidence.pre_arena.timings[
+                        (model, layout, mode, batch)
+                    ]
+                    baseline = _mapping(
+                        distributions.get("baseline"),
+                        "pre-Arena timing distribution",
+                    )
+                    matrix_current = _mapping(
+                        distributions.get("current"),
+                        "matrix Arena timing distribution",
+                    )
+                    final_current = _mapping(
+                        capture.timings[mode][str(batch)],
+                        "final Arena timing distribution",
+                    )
+                    baseline_median = _number(
+                        baseline.get("median_seconds_per_point"),
+                        "pre-Arena median",
+                        positive=True,
+                    )
+                    baseline_mad = _number(
+                        baseline.get("mad_seconds_per_point"),
+                        "pre-Arena MAD",
+                        nonnegative=True,
+                    )
+                    matrix_median = _number(
+                        matrix_current.get("median_seconds_per_point"),
+                        "matrix Arena median",
+                        positive=True,
+                    )
+                    matrix_mad = _number(
+                        matrix_current.get("mad_seconds_per_point"),
+                        "matrix Arena MAD",
+                        nonnegative=True,
+                    )
+                    final_median = _number(
+                        final_current.get("median_seconds_per_point"),
+                        "final Arena median",
+                        positive=True,
+                    )
+                    final_mad = _number(
+                        final_current.get("mad_seconds_per_point"),
+                        "final Arena MAD",
+                        nonnegative=True,
+                    )
+                    final_ratio = final_median / baseline_median
+                    rows.append(
+                        [
+                            _model_label(model),
+                            _layout_label(layout),
+                            _mode_label(mode),
+                            batch,
+                            (
+                                f"{_microseconds(baseline_median)} ± "
+                                f"{_microseconds(baseline_mad)}"
+                            ),
+                            (
+                                f"{_microseconds(matrix_median)} ± "
+                                f"{_microseconds(matrix_mad)}"
+                            ),
+                            (
+                                f"{_microseconds(final_median)} ± "
+                                f"{_microseconds(final_mad)}"
+                            ),
+                            _ratio(matrix_median / baseline_median),
+                            _ratio(final_ratio),
+                            f"{(1.0 - final_ratio) * 100.0:.6g}%",
+                        ]
+                    )
+    lines.extend(
+        _table(
+            (
+                "Model",
+                "Workload",
+                "Mode",
+                "Batch",
+                "Frozen pre-Arena median ± MAD",
+                "168-cell Arena median ± MAD",
+                "Final M0 Arena median ± MAD",
+                "Matrix Arena / pre-Arena",
+                "Final Arena / pre-Arena",
+                "Final relative gain",
+            ),
+            rows,
+        )
+    )
+    lines.extend(
+        [
+            "",
+            (
+                "A final relative gain is positive when the final Arena runtime is "
+                "faster than the frozen pre-Arena baseline."
+            ),
+        ]
+    )
+    return lines
+
+
+def _amplicol_round_values(evidence: Any) -> dict[int, float]:
+    timing = _mapping(evidence.timing, "AmpliCol timing")
+    values = _list(
+        timing.get("raw_seconds_per_point"),
+        "AmpliCol raw seconds per point",
+    )
+    records = list(evidence.interleave_records)
+    if len(values) != len(records):
+        _die("AmpliCol timing values and interleave records differ in length")
+    result: dict[int, float] = {}
+    for value, record in zip(values, records, strict=True):
+        round_index = _integer(record.get("round"), "AmpliCol interleave round")
+        if round_index in result:
+            _die(f"AmpliCol workload repeats round {round_index}")
+        result[round_index] = _number(
+            value,
+            f"AmpliCol round {round_index} timing",
+            positive=True,
+        )
+    return result
+
+
+def _amplicol_sections(evidence: Evidence) -> list[str]:
+    lines = [
+        "## Original AmpliCol comparison",
+        "",
+        (
+            "The original-AmpliCol selected-flow and all-flow measurements were "
+            "captured as seven chronological selected-then-union subprocess pairs. "
+            "They use different internal timing boundaries from pyAmpliCol, shown "
+            "explicitly below."
+        ),
+        "",
+    ]
+    external_rows: list[list[object]] = []
+    role_order = (
+        evidence.m0.AMPLICOL_SELECTED_ROLE,
+        evidence.m0.AMPLICOL_UNION_ROLE,
+    )
+    for role in role_order:
+        timing = _mapping(evidence.amplicol[role].timing, f"AmpliCol {role} timing")
+        external_rows.append(
+            [
+                role,
+                timing.get("timing_boundary"),
+                _microseconds(
+                    _number(
+                        timing.get("median_seconds_per_point"),
+                        f"AmpliCol {role} median",
+                        positive=True,
+                    )
+                ),
+                _microseconds(
+                    _number(
+                        timing.get("mad_seconds_per_point"),
+                        f"AmpliCol {role} MAD",
+                        nonnegative=True,
+                    )
+                ),
+                _integer(
+                    timing.get("sample_count"),
+                    f"AmpliCol {role} samples",
+                    minimum=evidence.m0.MIN_SAMPLES,
+                ),
+            ]
+        )
+    lines.extend(
+        _table(
+            ("Workload", "Timing boundary", "Median", "Raw MAD", "Subprocesses"),
+            external_rows,
+        )
+    )
+    selected_rounds = _amplicol_round_values(evidence.amplicol[role_order[0]])
+    union_rounds = _amplicol_round_values(evidence.amplicol[role_order[1]])
+    if set(selected_rounds) != set(union_rounds):
+        _die("original-AmpliCol selected/union paired rounds differ")
+    selected_over_union = [
+        selected_rounds[index] / union_rounds[index]
+        for index in sorted(selected_rounds)
+    ]
+    ratio_median = statistics.median(selected_over_union)
+    ratio_mad = statistics.median(
+        abs(value - ratio_median) for value in selected_over_union
+    )
+    lines.extend(
+        [
+            "",
+            (
+                f"Same-round original selected/union ratio: "
+                f"**{_ratio(ratio_median)} ± {_ratio(ratio_mad)} raw MAD** "
+                f"across {len(selected_over_union)} paired rounds."
+            ),
+            "",
+            "### pyAmpliCol median / original-AmpliCol median",
+            "",
+        ]
+    )
+    comparison_rows: list[list[object]] = []
+    for layout, role in (
+        ("topology-replay", role_order[0]),
+        ("all-flow-union", role_order[1]),
+    ):
+        amplicol_median = _number(
+            evidence.amplicol[role].timing["median_seconds_per_point"],
+            "AmpliCol comparison median",
+            positive=True,
+        )
+        for model in evidence.m0.MODELS:
+            capture = evidence.captures[(model, layout)]
+            for mode in evidence.m0.MODES:
+                for batch in evidence.m0.BATCHES:
+                    py_median = _number(
+                        capture.timings[mode][str(batch)]["median_seconds_per_point"],
+                        "pyAmpliCol comparison median",
+                        positive=True,
+                    )
+                    comparison_rows.append(
+                        [
+                            _layout_label(layout),
+                            _model_label(model),
+                            _mode_label(mode),
+                            batch,
+                            _ratio(py_median / amplicol_median),
+                            "runtime-core wall / "
+                            + evidence.amplicol[role].timing["timing_boundary"],
+                        ]
+                    )
+    lines.extend(
+        _table(
+            (
+                "Workload",
+                "Model",
+                "Mode",
+                "Batch",
+                "pyAmpliCol / AmpliCol",
+                "Boundary pairing",
+            ),
+            comparison_rows,
+        )
+    )
+    return lines
+
+
+def render_markdown(evidence: Evidence) -> str:
+    """Render deterministic Markdown from already revalidated evidence."""
+
+    first = evidence.captures[("built-in-sm", "topology-replay")]
+    host = _mapping(first.host, "capture host")
+    color_axis = first.color_axis
+    helicity_axis = first.helicity_axis
+    lines: list[str] = [
+        (
+            "<!-- Generated by tools/developer/qq_z6g_final_comparison.py; "
+            "do not edit. -->"
+        ),
+        "",
+        "# Final qq → Z + 6g Arena comparison",
+        "",
+        (
+            "Status: **accepted** by the strict combined M0 gate. This document "
+            "contains no benchmark values that were not present in the authenticated "
+            "capture set or deterministically recomputed from its raw samples."
+        ),
+        "",
+        "## Scope and workload semantics",
+        "",
+        f"- Process: `{evidence.m0.PROCESS}`.",
+        (
+            f"- Physical axes retained in every artifact: "
+            f"{_integer(color_axis.get('count'), 'color-flow count', minimum=1)} "
+            f"LC flows and "
+            f"{_integer(helicity_axis.get('count'), 'helicity count', minimum=1)} "
+            "helicity configurations."
+        ),
+        (
+            f"- Selected-flow workload: runtime flow "
+            f"`{evidence.expected['color_flow']['id']}` with a complete helicity sum."
+        ),
+        (
+            f"- Union workload: all physical LC flows with runtime helicity "
+            f"`{evidence.expected['helicity']['id']}`."
+        ),
+        (
+            "- All four captures retain complete flow/helicity axes and have no "
+            "generation-specialized axes."
+        ),
+        (
+            "- Compiled means the compiled DAG with effective JIT O3. Eager and "
+            "recurrence are separate runtime engines over the same authenticated "
+            "physics/model contracts."
+        ),
+        "",
+        "### LC/NLC/full-color boundary",
+        "",
+        (
+            "**The all-flow union evidence here is LC-only.** It sums all physical "
+            "LC flows for one runtime-selected helicity. NLC and full-color modes use "
+            "contracted color evaluation and are outside this M0 capture set; no "
+            "NLC/full runtime number or union equivalence is inferred from these LC "
+            "measurements."
+        ),
+        "",
+        "## Evidence and identities",
+        "",
+        "### Content-addressed inputs",
+        "",
+    ]
+    lines.extend(
+        _table(
+            ("Logical evidence", "Raw file SHA-256", "Canonical/content SHA-256"),
+            _capture_input_rows(evidence),
+        )
+    )
+    lines.extend(["", "### pyAmpliCol source and runtime", ""])
+    lines.extend(_table(("Identity", "Value"), _runtime_identity_rows(evidence)))
+    lines.extend(["", "### Frozen pre-Arena matrix and runtime", ""])
+    lines.extend(_table(("Identity", "Value"), _pre_arena_identity_rows(evidence)))
+    lines.extend(["", "### Original AmpliCol source and compiler", ""])
+    lines.extend(_table(("Identity", "Value"), _original_identity_rows(evidence)))
+    lines.extend(["", "### Host", ""])
+    lines.extend(
+        _table(
+            ("Field", "Value"),
+            (
+                ("Platform", host.get("platform")),
+                ("System/release", f"{host.get('system')} {host.get('release')}"),
+                ("Machine", host.get("machine")),
+                ("CPU model", host.get("cpu_model")),
+                ("Logical CPUs", host.get("logical_cpu_count")),
+            ),
+        )
+    )
+    lines.extend(["", "### Model identities", ""])
+    lines.extend(
+        _table(
+            ("Model", "Common physics SHA-256", "Generation-model SHA-256"),
+            [
+                [
+                    _model_label(model),
+                    _digest(
+                        evidence.expected["model_common_physics_identity_sha256"][model]
+                    ),
+                    _digest(
+                        evidence.expected["generation_model_identities_sha256"][model]
+                    ),
+                ]
+                for model in evidence.m0.MODELS
+            ],
+        )
+    )
+    lines.extend(["", *_numerical_sections(evidence)])
+    lines.extend(["", *_generation_sections(evidence)])
+    lines.extend(["", *_runtime_sections(evidence)])
+    lines.extend(["", *_pre_arena_comparison_sections(evidence)])
+    lines.extend(["", *_amplicol_sections(evidence)])
+    lines.extend(
+        [
+            "",
+            "## Methodology and interpretation caveats",
+            "",
+            (
+                "- Runtime cells use at least seven independent worker subprocesses. "
+                "Each worker retains native wall blocks; the headline statistic is "
+                "the median of subprocess wall-seconds-per-point values and its raw "
+                "MAD."
+            ),
+            (
+                "- Same-round ratios divide paired subprocess measurements before "
+                "taking the ratio median/MAD. A ratio below one favors the numerator."
+            ),
+            (
+                "- Frozen pre-Arena comparisons are cross-campaign median ratios, "
+                "not same-round ratios; the table retains the raw MAD for every "
+                "campaign instead of constructing a synthetic paired uncertainty."
+            ),
+            (
+                "- Batch sizes 1, 128, and 1024 are API/runtime batching choices; all "
+                "reported values remain normalized per evaluated physical point."
+            ),
+            (
+                "- Generation timings, artifact sizes, and generation RSS are not "
+                "steady-state runtime measurements. Generation RSS is a high-water "
+                "lower bound, not an aggregate process-tree sample."
+            ),
+            (
+                "- Original-AmpliCol and pyAmpliCol timing boundaries differ. Their "
+                "ratios are reported for transparency, not presented as identical "
+                "microbenchmark boundaries."
+            ),
+            (
+                "- Zero or unavailable evaluator-attribution, cold-load, traffic, or "
+                "allocation fields are not substituted with estimates. The headline "
+                "runtime tables use retained wall-time evidence only."
+            ),
+            (
+                f"- Numerical acceptance used relative tolerance "
+                f"`{evidence.m0.RTOL:.17g}` and absolute tolerance "
+                f"`{evidence.m0.ATOL:.17g}`."
+            ),
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def _write_atomic(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    try:
+        temporary.write_text(text, encoding="utf-8")
+        os.replace(temporary, path)
+    finally:
+        with contextlib.suppress(FileNotFoundError):
+            temporary.unlink()
+
+
+def generate(
+    *,
+    request_path: Path,
+    request_sha256: str,
+    acceptance_path: Path,
+    acceptance_sha256: str,
+    expected_source_revision: str,
+    expected_runtime_provenance_sha256: str,
+    pre_arena_manifest_path: Path,
+    pre_arena_manifest_sha256: str,
+    expected_pre_arena_source_revision: str,
+    expected_pre_arena_build_sha256: str,
+    expected_pre_arena_runtime_sha256: str,
+    output_path: Path,
+) -> str:
+    evidence = validate_evidence(
+        request_path=request_path,
+        request_sha256=request_sha256,
+        acceptance_path=acceptance_path,
+        acceptance_sha256=acceptance_sha256,
+        expected_source_revision=expected_source_revision,
+        expected_runtime_provenance_sha256=expected_runtime_provenance_sha256,
+        pre_arena_manifest_path=pre_arena_manifest_path,
+        pre_arena_manifest_sha256=pre_arena_manifest_sha256,
+        expected_pre_arena_source_revision=expected_pre_arena_source_revision,
+        expected_pre_arena_build_sha256=expected_pre_arena_build_sha256,
+        expected_pre_arena_runtime_sha256=expected_pre_arena_runtime_sha256,
+    )
+    markdown = render_markdown(evidence)
+    _write_atomic(output_path, markdown)
+    return hashlib.sha256(markdown.encode("utf-8")).hexdigest()
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--request", type=Path, required=True)
+    result.add_argument("--request-sha256", required=True)
+    result.add_argument("--acceptance", type=Path, required=True)
+    result.add_argument("--acceptance-sha256", required=True)
+    result.add_argument("--expected-source-revision", required=True)
+    result.add_argument("--expected-runtime-provenance-sha256", required=True)
+    result.add_argument("--pre-arena-manifest", type=Path, required=True)
+    result.add_argument("--pre-arena-manifest-sha256", required=True)
+    result.add_argument("--expected-pre-arena-source-revision", required=True)
+    result.add_argument("--expected-pre-arena-build-sha256", required=True)
+    result.add_argument("--expected-pre-arena-runtime-sha256", required=True)
+    result.add_argument(
+        "--output",
+        type=Path,
+        default=DEFAULT_OUTPUT,
+        help=f"Markdown output (default: {DEFAULT_OUTPUT})",
+    )
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    try:
+        markdown_sha256 = generate(
+            request_path=arguments.request,
+            request_sha256=arguments.request_sha256,
+            acceptance_path=arguments.acceptance,
+            acceptance_sha256=arguments.acceptance_sha256,
+            expected_source_revision=arguments.expected_source_revision,
+            expected_runtime_provenance_sha256=(
+                arguments.expected_runtime_provenance_sha256
+            ),
+            pre_arena_manifest_path=arguments.pre_arena_manifest,
+            pre_arena_manifest_sha256=arguments.pre_arena_manifest_sha256,
+            expected_pre_arena_source_revision=(
+                arguments.expected_pre_arena_source_revision
+            ),
+            expected_pre_arena_build_sha256=(arguments.expected_pre_arena_build_sha256),
+            expected_pre_arena_runtime_sha256=(
+                arguments.expected_pre_arena_runtime_sha256
+            ),
+            output_path=arguments.output,
+        )
+    except Exception as error:
+        print(f"qq_Z6g comparison rejected: {error}", file=sys.stderr)
+        return 2
+    print(
+        json.dumps(
+            {
+                "output": str(arguments.output),
+                "markdown_sha256": markdown_sha256,
+            },
+            sort_keys=True,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/pyamplicol/tools/developer/rebuild_rusticol.py b/pyamplicol/tools/developer/rebuild_rusticol.py
new file mode 100644
index 0000000000..7e17c0c7f2
--- /dev/null
+++ b/pyamplicol/tools/developer/rebuild_rusticol.py
@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Rebuild and restage only Rusticol for a candidate source checkout."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+SOURCE_PACKAGE = ROOT / "src" / "pyamplicol"
+SOURCE_RUNTIME_INFO = ROOT / ".artifacts" / "source-runtime" / "_build_info.json"
+RUSTICOL_MANIFEST = Path("rust/crates/rusticol-python/Cargo.toml")
+NATIVE_SUFFIXES = (".dylib", ".pyd", ".so")
+
+sys.path.insert(0, str(ROOT))
+sys.path.insert(0, str(ROOT / "build_backend"))
+import _pyamplicol_build as build_backend  # noqa: E402
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--python",
+        type=Path,
+        default=ROOT / ".venv" / "bin" / "python",
+    )
+    parser.add_argument(
+        "--maturin",
+        type=Path,
+        default=ROOT / ".venv" / "bin" / "maturin",
+    )
+    parser.add_argument(
+        "--cargo-test",
+        action="append",
+        default=[],
+        metavar="FILTER",
+        help="run a rusticol-core test filter in the contributor overlay",
+    )
+    parser.add_argument(
+        "--test-only",
+        action="store_true",
+        help="run requested cargo tests without rebuilding the extension",
+    )
+    return parser
+
+
+def _read_candidate_info() -> dict[str, object]:
+    try:
+        payload = json.loads(SOURCE_RUNTIME_INFO.read_text(encoding="utf-8"))
+    except (OSError, TypeError, ValueError) as error:
+        raise RuntimeError(
+            "candidate source-runtime metadata is unavailable; "
+            "run `just dev-install` once"
+        ) from error
+    if not isinstance(payload, dict) or payload.get("publishable") is not False:
+        raise RuntimeError("Rusticol-only rebuilds require a staged candidate runtime")
+    version = payload.get("version")
+    if not isinstance(version, str) or not version:
+        raise RuntimeError("candidate source-runtime metadata has no package version")
+    return payload
+
+
+def _native_extension() -> Path:
+    extensions = sorted(
+        path
+        for path in SOURCE_PACKAGE.glob("_rusticol.*")
+        if path.is_file() and path.name.endswith(NATIVE_SUFFIXES)
+    )
+    if len(extensions) != 1:
+        raise RuntimeError(
+            f"expected one staged Rusticol extension, found {len(extensions)}"
+        )
+    return extensions[0]
+
+
+def _wheel_extension(wheel: Path) -> tuple[str, bytes, int]:
+    with zipfile.ZipFile(wheel) as archive:
+        candidates = [
+            info
+            for info in archive.infolist()
+            if info.filename.startswith("pyamplicol/_rusticol.")
+            and info.filename.endswith(NATIVE_SUFFIXES)
+        ]
+        if len(candidates) != 1:
+            raise RuntimeError(
+                f"expected one Rusticol extension in {wheel}, found {len(candidates)}"
+            )
+        info = candidates[0]
+        return Path(info.filename).name, archive.read(info), info.external_attr >> 16
+
+
+def _install_extension(wheel: Path) -> Path:
+    name, payload, mode = _wheel_extension(wheel)
+    destination = SOURCE_PACKAGE / name
+    with tempfile.NamedTemporaryFile(
+        dir=SOURCE_PACKAGE,
+        prefix=f".{name}.",
+        delete=False,
+    ) as stream:
+        temporary = Path(stream.name)
+        stream.write(payload)
+    try:
+        temporary.chmod(mode or 0o755)
+        os.replace(temporary, destination)
+    finally:
+        temporary.unlink(missing_ok=True)
+    for stale in SOURCE_PACKAGE.glob("_rusticol.*"):
+        if stale != destination and stale.name.endswith(NATIVE_SUFFIXES):
+            stale.unlink()
+    return destination
+
+
+def _stage_untracked_source(overlay: Path) -> None:
+    completed = subprocess.run(
+        [
+            "git",
+            "ls-files",
+            "--others",
+            "--exclude-standard",
+            "-z",
+            "--",
+        ],
+        cwd=ROOT,
+        check=True,
+        capture_output=True,
+    )
+    for raw in completed.stdout.split(b"\0"):
+        if not raw:
+            continue
+        relative = Path(os.fsdecode(raw))
+        if (
+            relative.is_absolute()
+            or ".." in relative.parts
+            or not build_backend._is_allowlisted(relative)
+            or build_backend._is_excluded(relative)
+        ):
+            continue
+        source = ROOT / relative
+        mode = source.lstat().st_mode
+        if not stat.S_ISREG(mode):
+            raise RuntimeError(f"untracked build input is not a regular file: {source}")
+        target = overlay / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target, follow_symlinks=False)
+
+
+def _publish_info(
+    payload: dict[str, object],
+    *,
+    extension: Path,
+    native_digest: str,
+) -> None:
+    payload["native_build_inputs_sha256"] = native_digest
+    payload["source_runtime"] = {
+        "extension_name": extension.name,
+        "extension_sha256": hashlib.sha256(extension.read_bytes()).hexdigest(),
+        "mode": "candidate",
+        "native_build_inputs_sha256": native_digest,
+    }
+    SOURCE_RUNTIME_INFO.parent.mkdir(parents=True, exist_ok=True)
+    temporary = SOURCE_RUNTIME_INFO.with_name(
+        f".{SOURCE_RUNTIME_INFO.name}.rusticol-{os.getpid()}"
+    )
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, SOURCE_RUNTIME_INFO)
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    _read_candidate_info()
+    with build_backend._overlay("candidate") as (overlay, _):
+        _stage_untracked_source(overlay)
+        target = ROOT / ".artifacts" / "rusticol-rebuild" / "target"
+        payload = json.loads(
+            (overlay / "src" / "pyamplicol" / "_build_info.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        native_digest = str(payload["native_build_inputs_sha256"])
+        environment = build_backend._clean_environment(
+            {
+                "CARGO_TARGET_DIR": str(target),
+                "PYAMPLICOL_NATIVE_BUILD_INPUTS_SHA256": native_digest,
+                "PYAMPLICOL_PACKAGE_VERSION": str(payload["version"]),
+            }
+        )
+        for test_filter in args.cargo_test:
+            subprocess.run(
+                [
+                    "cargo",
+                    "test",
+                    "--release",
+                    "--locked",
+                    "--offline",
+                    "--manifest-path",
+                    str(overlay / "rust" / "crates" / "rusticol-core" / "Cargo.toml"),
+                    test_filter,
+                ],
+                cwd=overlay,
+                env=environment,
+                check=True,
+            )
+        if args.test_only:
+            if not args.cargo_test:
+                raise RuntimeError("--test-only requires at least one --cargo-test")
+            return 0
+        with tempfile.TemporaryDirectory(prefix="pyamplicol-rusticol-wheel-") as raw:
+            wheel_directory = Path(raw)
+            subprocess.run(
+                [
+                    str(args.maturin),
+                    "build",
+                    "--release",
+                    "--locked",
+                    "--offline",
+                    "--manifest-path",
+                    str(overlay / RUSTICOL_MANIFEST),
+                    "--features",
+                    "extension-module,numpy",
+                    "--interpreter",
+                    str(args.python),
+                    "--out",
+                    str(wheel_directory),
+                ],
+                cwd=overlay,
+                env=environment,
+                check=True,
+            )
+            wheels = sorted(wheel_directory.glob("*.whl"))
+            if len(wheels) != 1:
+                raise RuntimeError(f"expected one Rusticol wheel, found {len(wheels)}")
+            extension = _install_extension(wheels[0])
+            subprocess.run(
+                [
+                    str(args.python),
+                    "-m",
+                    "pip",
+                    "install",
+                    "--force-reinstall",
+                    "--no-deps",
+                    str(wheels[0]),
+                ],
+                cwd=ROOT,
+                check=True,
+            )
+    _publish_info(payload, extension=extension, native_digest=native_digest)
+    subprocess.run(
+        [
+            str(args.python),
+            "-c",
+            (
+                "from pyamplicol import _rusticol; "
+                "from pyamplicol._internal.versions import verify_native_module; "
+                "verify_native_module(_rusticol); "
+                "print(_rusticol.package_version(), "
+                "_rusticol.native_build_inputs_sha256())"
+            ),
+        ],
+        cwd=ROOT,
+        check=True,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/recurrence_artifact_compare.py b/pyamplicol/tools/developer/recurrence_artifact_compare.py
new file mode 100644
index 0000000000..1ca453ddd9
--- /dev/null
+++ b/pyamplicol/tools/developer/recurrence_artifact_compare.py
@@ -0,0 +1,3122 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Fail-closed comparison of baseline and candidate recurrence artifacts.
+
+This is a developer tool, not a public pyAmpliCol CLI command.  Runtime plan,
+projection certificate, binding, evaluator, and model bytes must be exact.
+Only explicitly permitted metadata differences are normalized.
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import datetime as dt
+import hashlib
+import json
+import math
+import re
+import struct
+import sys
+import unicodedata
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Any, BinaryIO
+
+COMPARISON_KIND = "pyamplicol-recurrence-artifact-exact-comparison"
+COMPARISON_SCHEMA_VERSION = 1
+MAX_REPORTED_UNKNOWN_DIFFERENCES = 256
+
+ARTIFACT_ALLOWED_METADATA_PATHS = (
+    "/artifact_id",
+    "/created_utc",
+    "/producer/git_revision",
+    "/producer/native_build_inputs_sha256",
+    "/producer/version",
+    "/extensions/generation/phase_timings_seconds",
+    "/extensions/generation/recurrence_schedule_profiles",
+    "/extensions/generation/concrete_processes/*/execution_manifest_sha256",
+    "/payloads/*[execution.json]/sha256",
+    "/payloads/*[execution.json]/size_bytes",
+    "/payloads/*[structural-source-proof.json]/sha256",
+    "/payloads/*[structural-source-proof.json]/size_bytes",
+)
+EXECUTION_ALLOWED_METADATA_PATHS = (
+    "/plan/inspection_summary/generation_timings_seconds",
+)
+STRUCTURAL_PROOF_ALLOWED_METADATA_PATHS = (
+    "/source_identity/git_revision",
+    "/source_identity/native_build_inputs_sha256",
+    "/execution/sha256",
+    "/physical_lane_inventory/loose_payloads[path=processes/*/execution.json]/sha256",
+    "/physical_lane_inventory/loose_payloads[path=processes/*/execution.json]/size_bytes",
+    "/physical_lane_inventory/lanes[id=primary]/subtree_sha256",
+    "/physical_lane_inventory/inventory_sha256",
+    "/proof_content_sha256",
+)
+
+_SHA256_RE = re.compile(r"[0-9a-f]{64}")
+_GIT_REVISION_RE = re.compile(r"[0-9a-f]{40}")
+_RUNTIME_ARTIFACT_ID_PAYLOAD_ROLES = frozenset(
+    {
+        "compiled-model",
+        "evaluator-manifest",
+        "evaluator-state",
+        "model-parameters",
+        "runtime-physics",
+    }
+)
+_EXECUTION_PATH_RE = re.compile(r"processes/([^/]+)/execution[.]json")
+_STRUCTURAL_PROOF_PATH_RE = re.compile(
+    r"processes/([^/]+)/structural-source-proof[.]json"
+)
+_BINDING_PATH_RE = re.compile(r"processes/([^/]+)/recurrence-binding[.]bin")
+_RUNTIME_SCHEDULE_RE = re.compile(
+    r"recurrence/schedules/([0-9a-f]{64})/recurrence-runtime[.]pacbin"
+)
+_SCHEDULE_INDEX_PATH = "recurrence/schedule-index.json"
+_PLAN_MEMBER_PATH = "schedule/recurrence-direct-schedule-v2.bin"
+_CERTIFICATE_MEMBER_PATH = "proof/recurrence-color-projection-v1.bin"
+_PLAN_MEMBER_KIND = 7
+_CERTIFICATE_MEMBER_KIND = 8
+_PACBIN_MEMBER_KIND_NAMES = {
+    1: "symjit_application",
+    2: "symbolica_exact_state",
+    3: "native_library",
+    4: "eager_runtime_metadata",
+    5: "eager_runtime_table",
+    7: "recurrence_direct_plan",
+    8: "recurrence_color_projection_certificate",
+}
+_STRUCTURAL_SEMANTIC_MAP_DOMAINS = {
+    "current_member_map": "current_member_map-v1",
+    "interaction_row_map": "interaction_row_map-v1",
+    "closure_map": "closure_map-v1",
+    "source_contract": "source_contract-v1",
+}
+
+_PACBIN_VERSION = 1
+_PACBIN_ALIGNMENT = 64
+_PACBIN_INDEX_ALIGNMENT = 8
+_PACBIN_HEADER = struct.Struct("<8sHHIIIQQ24s")
+_PACBIN_INDEX_HEADER = struct.Struct("<8sHHIQQ")
+_PACBIN_INDEX_ENTRY = struct.Struct("<IHHQQ32s")
+_PACBIN_FOOTER = struct.Struct("<8sHHIQQ32s")
+_PACBIN_HEADER_MAGIC = b"PACBIN\x00\x00"
+_PACBIN_INDEX_MAGIC = b"PACIDX\x00\x00"
+_PACBIN_FOOTER_MAGIC = b"PACEND\x00\x00"
+
+_CERTIFICATE_BODY_MAGIC = b"PYAMP-COLOR-PROJECTION-BODY-V1\0\0"
+_GENERATION_PROFILE_TIMINGS = frozenset(
+    {
+        "transition-catalog",
+        "structural-feasibility",
+        "color-target-index",
+        "structural-demand",
+        "support-indexing",
+        "candidate-processing",
+        "closure-processing",
+        "canonical-emission",
+        "python-extraction",
+        "catalog-authentication",
+        "semantic-construction-total",
+        "direct-lowering",
+        "serialization",
+        "native-total",
+    }
+)
+_GENERATION_PROFILE_COUNTERS = frozenset(
+    {
+        "support_bucket_count",
+        "support_bucket_probe_count",
+        "support_bucket_cache_hit_count",
+        "support_bucket_cache_miss_count",
+        "candidate_parent_pair_theoretical_count",
+        "candidate_parent_pair_visited_count",
+        "structural_feasible_support_count",
+        "structural_decomposition_count",
+        "structural_forward_transition_probe_count",
+        "structural_demand_support_count",
+        "structural_demand_state_count",
+        "structural_reject_count",
+        "transition_index_hit_count",
+        "transition_index_miss_count",
+        "transition_candidate_count",
+        "quantum_match_count",
+        "coupling_match_count",
+        "transition_accept_count",
+        "color_shape_match_count",
+        "color_result_count",
+        "color_target_accept_count",
+        "color_target_reject_count",
+        "color_acceptance_cache_hit_count",
+        "color_acceptance_cache_miss_count",
+        "color_fragment_bucket_count",
+        "color_fragment_hash_lookup_count",
+        "color_posting_incidence_count",
+        "color_sparse_posting_bucket_count",
+        "color_dense_posting_bucket_count",
+        "color_sparse_posting_bytes",
+        "color_dense_posting_bytes",
+        "accepted_parent_key_clone_count",
+        "current_key_lookup_count",
+        "current_key_hit_count",
+        "current_insert_count",
+        "current_key_clone_count",
+        "indexed_hash_lookup_count",
+        "contribution_attempt_count",
+        "contribution_insert_count",
+        "contribution_merge_count",
+        "closure_candidate_theoretical_count",
+        "closure_candidate_count",
+        "closure_support_lookup_count",
+        "closure_state_match_count",
+        "closure_color_attempt_count",
+        "closure_group_count",
+        "closure_proof_contribution_count",
+        "constructed_current_count",
+        "constructed_contribution_count",
+        "constructed_interaction_count",
+        "constructed_dynamic_color_state_count",
+        "emitted_current_count",
+        "emitted_contribution_count",
+        "emitted_interaction_count",
+        "emitted_finalization_count",
+        "emitted_closure_count",
+    }
+)
+_GENERATION_PROFILE_SERIALIZED_BYTES = frozenset(
+    {"plan_payload", "container", "unpacked_container"}
+)
+_NORMALIZED = "<allowed-metadata-difference>"
+_MISSING = object()
+
+
+class ComparisonError(RuntimeError):
+    """Raised when either comparison input violates the artifact contract."""
+
+
+@dataclass(frozen=True)
+class PayloadSnapshot:
+    """Authenticated payload metadata without retaining payload bytes."""
+
+    relative_path: str
+    path: Path
+    role: str
+    size_bytes: int
+    sha256: str
+    record: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class PacbinMemberSnapshot:
+    """One authenticated member in a canonical recurrence PACBIN."""
+
+    logical_path: str
+    kind: int
+    offset: int
+    length: int
+    sha256: str
+
+
+@dataclass(frozen=True)
+class ProjectionCertificateSnapshot:
+    """Authenticated byte range for one structural projection certificate."""
+
+    body_offset: int
+    body_length: int
+    sha256: str
+
+
+@dataclass(frozen=True)
+class RecurrencePacbinSnapshot:
+    """Authenticated direct-plan container and optional projection proof."""
+
+    path: Path
+    file_size: int
+    index_sha256: str
+    unpacked_size_bytes: int
+    members: dict[str, PacbinMemberSnapshot]
+    projection_certificate: ProjectionCertificateSnapshot | None
+
+
+@dataclass(frozen=True)
+class RecurrencePacbinComparison:
+    """Exact and policy-normalized comparison result for one runtime container."""
+
+    exact_bytes_match: bool
+    policy_match: bool
+    plan_bytes_match: bool
+    projection_certificate_bodies_match: bool
+
+
+@dataclass(frozen=True)
+class ArtifactSnapshot:
+    """One independently authenticated recurrence artifact."""
+
+    root: Path
+    manifest_path: Path
+    manifest: dict[str, Any]
+    manifest_sha256: str
+    payloads: dict[str, PayloadSnapshot]
+    executions: dict[str, dict[str, Any]]
+    schedule_index: dict[str, Any]
+    recurrence_schedules: dict[str, RecurrencePacbinSnapshot]
+
+
+def _unique_object(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError(f"duplicate JSON object key: {key!r}")
+        result[key] = value
+    return result
+
+
+def _reject_nonfinite_json(value: str) -> None:
+    raise ValueError(f"non-finite JSON number: {value}")
+
+
+def _canonical_json_bytes(value: object) -> bytes:
+    return (
+        json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        + "\n"
+    ).encode("utf-8")
+
+
+def _runtime_artifact_id(manifest: Mapping[str, Any]) -> str:
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise ComparisonError("artifact payload inventory is invalid")
+    records = [
+        dict(payload)
+        for payload in payloads
+        if isinstance(payload, Mapping)
+        and payload.get("role") in _RUNTIME_ARTIFACT_ID_PAYLOAD_ROLES
+    ]
+    records.sort(key=lambda payload: str(payload.get("path", "")))
+    return hashlib.sha256(
+        _canonical_json_bytes(
+            {
+                "kind": "pyamplicol-runtime-payload-identity",
+                "schema_version": 1,
+                "payloads": records,
+            }
+        )
+    ).hexdigest()
+
+
+def _json_object(path: Path, *, description: str) -> dict[str, Any]:
+    try:
+        raw = path.read_bytes()
+        value = json.loads(
+            raw.decode("utf-8"),
+            object_pairs_hook=_unique_object,
+            parse_constant=_reject_nonfinite_json,
+        )
+    except (OSError, UnicodeDecodeError, ValueError, json.JSONDecodeError) as error:
+        raise ComparisonError(f"invalid {description}: {path}") from error
+    if not isinstance(value, dict):
+        raise ComparisonError(f"{description} must be a JSON object: {path}")
+    if raw != _canonical_json_bytes(value):
+        raise ComparisonError(f"{description} is not canonical compact JSON: {path}")
+    return value
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    try:
+        with path.open("rb") as stream:
+            for block in iter(lambda: stream.read(1024 * 1024), b""):
+                digest.update(block)
+    except OSError as error:
+        raise ComparisonError(f"cannot hash artifact file: {path}") from error
+    return digest.hexdigest()
+
+
+def _files_equal(left: Path, right: Path) -> bool:
+    try:
+        if left.stat().st_size != right.stat().st_size:
+            return False
+        with left.open("rb") as left_stream, right.open("rb") as right_stream:
+            while True:
+                left_block = left_stream.read(1024 * 1024)
+                right_block = right_stream.read(1024 * 1024)
+                if left_block != right_block:
+                    return False
+                if not left_block:
+                    return True
+    except OSError as error:
+        raise ComparisonError(
+            f"cannot compare payload bytes: {left} and {right}"
+        ) from error
+
+
+def _read_exact(
+    stream: BinaryIO,
+    length: int,
+    *,
+    description: str,
+) -> bytes:
+    if length < 0:
+        raise ComparisonError(f"{description} has a negative read length")
+    chunks: list[bytes] = []
+    remaining = length
+    while remaining:
+        chunk = stream.read(remaining)
+        if not chunk:
+            raise ComparisonError(f"{description} is truncated")
+        if not isinstance(chunk, bytes | bytearray | memoryview):
+            raise ComparisonError(f"{description} did not return bytes")
+        if len(chunk) > remaining:
+            raise ComparisonError(f"{description} returned an oversized read")
+        chunks.append(bytes(chunk))
+        remaining -= len(chunk)
+    return b"".join(chunks)
+
+
+def _read_exact_at(
+    stream: BinaryIO,
+    offset: int,
+    length: int,
+    *,
+    description: str,
+) -> bytes:
+    try:
+        stream.seek(offset)
+    except (OSError, ValueError) as error:
+        raise ComparisonError(f"cannot seek while reading {description}") from error
+    return _read_exact(stream, length, description=description)
+
+
+def _hash_stream_range(
+    stream: BinaryIO,
+    *,
+    offset: int,
+    length: int,
+    description: str,
+) -> str:
+    digest = hashlib.sha256()
+    try:
+        stream.seek(offset)
+        remaining = length
+        while remaining:
+            block = stream.read(min(1024 * 1024, remaining))
+            if not block:
+                raise ComparisonError(f"{description} is truncated")
+            if not isinstance(block, bytes | bytearray | memoryview):
+                raise ComparisonError(f"{description} did not return bytes")
+            if len(block) > remaining:
+                raise ComparisonError(f"{description} returned an oversized read")
+            digest.update(block)
+            remaining -= len(block)
+    except OSError as error:
+        raise ComparisonError(f"cannot hash {description}") from error
+    return digest.hexdigest()
+
+
+def _file_ranges_equal(
+    left: Path,
+    right: Path,
+    *,
+    left_offset: int,
+    right_offset: int,
+    length: int,
+) -> bool:
+    try:
+        with left.open("rb") as left_stream, right.open("rb") as right_stream:
+            left_stream.seek(left_offset)
+            right_stream.seek(right_offset)
+            remaining = length
+            while remaining:
+                requested = min(1024 * 1024, remaining)
+                left_block = _read_exact(
+                    left_stream,
+                    requested,
+                    description=f"PACBIN member range in {left}",
+                )
+                right_block = _read_exact(
+                    right_stream,
+                    requested,
+                    description=f"PACBIN member range in {right}",
+                )
+                if left_block != right_block:
+                    return False
+                remaining -= requested
+    except OSError as error:
+        raise ComparisonError(
+            f"cannot compare PACBIN member ranges: {left} and {right}"
+        ) from error
+    return True
+
+
+def _sha256_file_range(path: Path, *, offset: int, length: int) -> str:
+    try:
+        with path.open("rb") as stream:
+            return _hash_stream_range(
+                stream,
+                offset=offset,
+                length=length,
+                description=f"file range in {path}",
+            )
+    except OSError as error:
+        raise ComparisonError(f"cannot hash file range in {path}") from error
+
+
+def _alignment_padding(position: int, alignment: int) -> int:
+    return (-position) % alignment
+
+
+def _canonical_pacbin_member_path(value: bytes) -> str:
+    try:
+        text = value.decode("utf-8")
+    except UnicodeDecodeError as error:
+        raise ComparisonError("recurrence PACBIN member path is not UTF-8") from error
+    if not text or "\\" in text or text.startswith("/") or "\x00" in text:
+        raise ComparisonError("recurrence PACBIN member path is not canonical")
+    parts = text.split("/")
+    if any(part in {"", ".", ".."} for part in parts):
+        raise ComparisonError("recurrence PACBIN member path is not canonical")
+    if "/".join(unicodedata.normalize("NFC", part) for part in parts) != text:
+        raise ComparisonError("recurrence PACBIN member path is not NFC")
+    return text
+
+
+def _validate_pacbin_version_size_flags(
+    *,
+    description: str,
+    version: int,
+    encoded_size: int,
+    expected_size: int,
+    flags: int,
+) -> None:
+    if version != _PACBIN_VERSION or encoded_size != expected_size or flags != 0:
+        raise ComparisonError(
+            f"recurrence PACBIN has incompatible {description} framing"
+        )
+
+
+def _parse_projection_certificate(
+    stream: BinaryIO,
+    *,
+    member: PacbinMemberSnapshot,
+    description: str,
+) -> ProjectionCertificateSnapshot:
+    minimum_size = len(_CERTIFICATE_BODY_MAGIC) + 4 + 32
+    if member.length < minimum_size:
+        raise ComparisonError(f"{description} is too short")
+    member_end = member.offset + member.length
+    prefix = _read_exact_at(
+        stream,
+        member.offset,
+        len(_CERTIFICATE_BODY_MAGIC) + 4,
+        description=f"{description} prefix",
+    )
+    if not prefix.startswith(_CERTIFICATE_BODY_MAGIC) or prefix[
+        len(_CERTIFICATE_BODY_MAGIC) :
+    ] != (1).to_bytes(4, "little"):
+        raise ComparisonError(f"{description} has invalid framing")
+    expected_body_digest = _read_exact_at(
+        stream,
+        member_end - 32,
+        32,
+        description=f"{description} structural-body digest",
+    ).hex()
+    actual_body_digest = _hash_stream_range(
+        stream,
+        offset=member.offset,
+        length=member.length - 32,
+        description=f"{description} structural body",
+    )
+    if actual_body_digest != expected_body_digest:
+        raise ComparisonError(f"{description} structural-body digest mismatch")
+    return ProjectionCertificateSnapshot(
+        body_offset=member.offset,
+        body_length=member.length,
+        sha256=member.sha256,
+    )
+
+
+def _load_recurrence_pacbin(
+    path: Path,
+    *,
+    description: str,
+    recurrence_contract: bool = True,
+) -> RecurrencePacbinSnapshot:
+    try:
+        file_size = path.stat().st_size
+        stream = path.open("rb")
+    except OSError as error:
+        raise ComparisonError(f"cannot open {description}: {path}") from error
+    with stream:
+        minimum_size = (
+            _PACBIN_HEADER.size + _PACBIN_INDEX_HEADER.size + _PACBIN_FOOTER.size
+        )
+        if file_size < minimum_size:
+            raise ComparisonError(f"{description} is truncated")
+        header = _PACBIN_HEADER.unpack(
+            _read_exact_at(
+                stream,
+                0,
+                _PACBIN_HEADER.size,
+                description=f"{description} header",
+            )
+        )
+        (
+            magic,
+            version,
+            header_size,
+            flags,
+            alignment,
+            reserved,
+            index_offset,
+            member_count,
+            reserved_bytes,
+        ) = header
+        if magic != _PACBIN_HEADER_MAGIC:
+            raise ComparisonError(f"{description} has invalid header magic")
+        _validate_pacbin_version_size_flags(
+            description="header",
+            version=version,
+            encoded_size=header_size,
+            expected_size=_PACBIN_HEADER.size,
+            flags=flags,
+        )
+        if (
+            alignment != _PACBIN_ALIGNMENT
+            or reserved != 0
+            or reserved_bytes != b"\0" * 24
+            or index_offset % _PACBIN_ALIGNMENT
+        ):
+            raise ComparisonError(f"{description} has non-canonical header fields")
+        footer_offset = file_size - _PACBIN_FOOTER.size
+        if index_offset < _PACBIN_HEADER.size or index_offset >= footer_offset:
+            raise ComparisonError(f"{description} has invalid index bounds")
+        footer = _PACBIN_FOOTER.unpack(
+            _read_exact_at(
+                stream,
+                footer_offset,
+                _PACBIN_FOOTER.size,
+                description=f"{description} footer",
+            )
+        )
+        (
+            footer_magic,
+            footer_version,
+            footer_size,
+            footer_flags,
+            footer_index_offset,
+            footer_member_count,
+            expected_index_digest,
+        ) = footer
+        if footer_magic != _PACBIN_FOOTER_MAGIC:
+            raise ComparisonError(f"{description} has invalid footer magic")
+        _validate_pacbin_version_size_flags(
+            description="footer",
+            version=footer_version,
+            encoded_size=footer_size,
+            expected_size=_PACBIN_FOOTER.size,
+            flags=footer_flags,
+        )
+        if footer_index_offset != index_offset or footer_member_count != member_count:
+            raise ComparisonError(f"{description} header and footer disagree")
+        available_index_bytes = footer_offset - index_offset
+
+        stream.seek(index_offset)
+        index_digest = hashlib.sha256()
+
+        def read_index(length: int, label: str) -> bytes:
+            if length < 0 or stream.tell() > footer_offset - length:
+                raise ComparisonError(f"{description} {label} is truncated")
+            value = _read_exact(
+                stream,
+                length,
+                description=f"{description} {label}",
+            )
+            index_digest.update(value)
+            return value
+
+        index_header = _PACBIN_INDEX_HEADER.unpack(
+            read_index(_PACBIN_INDEX_HEADER.size, "index header")
+        )
+        (
+            index_magic,
+            index_version,
+            index_header_size,
+            index_flags,
+            index_member_count,
+            index_reserved,
+        ) = index_header
+        if index_magic != _PACBIN_INDEX_MAGIC:
+            raise ComparisonError(f"{description} has invalid index magic")
+        _validate_pacbin_version_size_flags(
+            description="index",
+            version=index_version,
+            encoded_size=index_header_size,
+            expected_size=_PACBIN_INDEX_HEADER.size,
+            flags=index_flags,
+        )
+        if index_member_count != member_count or index_reserved != 0:
+            raise ComparisonError(f"{description} has inconsistent index metadata")
+        if member_count > available_index_bytes // (_PACBIN_INDEX_ENTRY.size + 8):
+            raise ComparisonError(f"{description} member count cannot fit in index")
+
+        members: dict[str, PacbinMemberSnapshot] = {}
+        folded_paths: set[str] = set()
+        previous_path_bytes: bytes | None = None
+        for _ in range(member_count):
+            (
+                path_length,
+                kind,
+                entry_flags,
+                offset,
+                length,
+                digest,
+            ) = _PACBIN_INDEX_ENTRY.unpack(
+                read_index(_PACBIN_INDEX_ENTRY.size, "index entry")
+            )
+            if entry_flags != 0:
+                raise ComparisonError(f"{description} has unknown member flags")
+            path_bytes = read_index(path_length, "member path")
+            logical_path = _canonical_pacbin_member_path(path_bytes)
+            folded = logical_path.casefold()
+            if (
+                logical_path in members
+                or folded in folded_paths
+                or (
+                    previous_path_bytes is not None
+                    and path_bytes <= previous_path_bytes
+                )
+            ):
+                raise ComparisonError(
+                    f"{description} member paths are not unique and sorted"
+                )
+            previous_path_bytes = path_bytes
+            folded_paths.add(folded)
+            padding = _alignment_padding(
+                _PACBIN_INDEX_ENTRY.size + path_length,
+                _PACBIN_INDEX_ALIGNMENT,
+            )
+            if read_index(padding, "index padding") != b"\0" * padding:
+                raise ComparisonError(f"{description} index padding is nonzero")
+            members[logical_path] = PacbinMemberSnapshot(
+                logical_path=logical_path,
+                kind=kind,
+                offset=offset,
+                length=length,
+                sha256=digest.hex(),
+            )
+        if stream.tell() != footer_offset:
+            raise ComparisonError(f"{description} index has trailing bytes")
+        if index_digest.digest() != expected_index_digest:
+            raise ComparisonError(f"{description} index digest mismatch")
+
+        expected_offset = _PACBIN_HEADER.size
+        for member in members.values():
+            aligned_offset = expected_offset + _alignment_padding(
+                expected_offset, _PACBIN_ALIGNMENT
+            )
+            if (
+                member.offset != aligned_offset
+                or member.offset % _PACBIN_ALIGNMENT
+                or member.length > (1 << 64) - 1 - member.offset
+                or member.offset + member.length > index_offset
+            ):
+                raise ComparisonError(f"{description} member layout is non-canonical")
+            padding = member.offset - expected_offset
+            if (
+                _read_exact_at(
+                    stream,
+                    expected_offset,
+                    padding,
+                    description=f"{description} payload padding",
+                )
+                != b"\0" * padding
+            ):
+                raise ComparisonError(f"{description} payload padding is nonzero")
+            actual_sha = _hash_stream_range(
+                stream,
+                offset=member.offset,
+                length=member.length,
+                description=f"{description} member {member.logical_path}",
+            )
+            if actual_sha != member.sha256:
+                raise ComparisonError(
+                    f"{description} member digest mismatch: {member.logical_path}"
+                )
+            expected_offset = member.offset + member.length
+        canonical_index_offset = expected_offset + _alignment_padding(
+            expected_offset, _PACBIN_ALIGNMENT
+        )
+        if canonical_index_offset != index_offset:
+            raise ComparisonError(f"{description} payload layout has a gap")
+        trailing_padding = index_offset - expected_offset
+        if (
+            _read_exact_at(
+                stream,
+                expected_offset,
+                trailing_padding,
+                description=f"{description} trailing payload padding",
+            )
+            != b"\0" * trailing_padding
+        ):
+            raise ComparisonError(f"{description} trailing padding is nonzero")
+
+        snapshot = RecurrencePacbinSnapshot(
+            path=path,
+            file_size=file_size,
+            index_sha256=index_digest.hexdigest(),
+            unpacked_size_bytes=sum(member.length for member in members.values()),
+            members=members,
+            projection_certificate=None,
+        )
+        if not recurrence_contract:
+            return snapshot
+
+        expected_members = {_PLAN_MEMBER_PATH}
+        if _CERTIFICATE_MEMBER_PATH in members:
+            expected_members.add(_CERTIFICATE_MEMBER_PATH)
+        if set(members) != expected_members:
+            raise ComparisonError(
+                f"{description} must contain one plan and at most one projection "
+                "certificate"
+            )
+        plan = members[_PLAN_MEMBER_PATH]
+        if plan.kind != _PLAN_MEMBER_KIND:
+            raise ComparisonError(f"{description} plan member kind is incompatible")
+        certificate_member = members.get(_CERTIFICATE_MEMBER_PATH)
+        certificate = None
+        if certificate_member is not None:
+            if certificate_member.kind != _CERTIFICATE_MEMBER_KIND:
+                raise ComparisonError(
+                    f"{description} projection-certificate kind is incompatible"
+                )
+            certificate = _parse_projection_certificate(
+                stream,
+                member=certificate_member,
+                description=f"{description} projection certificate",
+            )
+        return RecurrencePacbinSnapshot(
+            path=snapshot.path,
+            file_size=snapshot.file_size,
+            index_sha256=snapshot.index_sha256,
+            unpacked_size_bytes=snapshot.unpacked_size_bytes,
+            members=snapshot.members,
+            projection_certificate=certificate,
+        )
+
+
+def _payload_relative_path(value: object, *, description: str) -> str:
+    if not isinstance(value, str) or not value or "\\" in value:
+        raise ComparisonError(f"{description} has an invalid payload path")
+    relative = PurePosixPath(value)
+    if (
+        relative.is_absolute()
+        or relative.as_posix() != value
+        or any(part in {"", ".", ".."} for part in relative.parts)
+    ):
+        raise ComparisonError(
+            f"{description} payload path is not normalized relative POSIX: {value!r}"
+        )
+    return value
+
+
+def _mapping(value: object, *, description: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise ComparisonError(f"{description} must be an object")
+    return value
+
+
+def _sequence(value: object, *, description: str) -> Sequence[Any]:
+    if not isinstance(value, list):
+        raise ComparisonError(f"{description} must be an array")
+    return value
+
+
+def _sha256(value: object, *, description: str) -> str:
+    if not isinstance(value, str) or _SHA256_RE.fullmatch(value) is None:
+        raise ComparisonError(f"{description} must be a lowercase SHA-256")
+    return value
+
+
+def _nonnegative_int(value: object, *, description: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise ComparisonError(f"{description} must be a non-negative integer")
+    return value
+
+
+def _nonempty_string(value: object, *, description: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise ComparisonError(f"{description} must be a non-empty string")
+    return value
+
+
+def _utc_timestamp(value: object, *, description: str) -> str:
+    text = _nonempty_string(value, description=description)
+    try:
+        parsed = dt.datetime.fromisoformat(text.replace("Z", "+00:00"))
+    except ValueError as error:
+        raise ComparisonError(f"{description} must be an ISO-8601 timestamp") from error
+    if parsed.tzinfo is None or parsed.utcoffset() != dt.timedelta(0):
+        raise ComparisonError(f"{description} must have an explicit UTC offset")
+    return text
+
+
+def _timings(value: object, *, description: str) -> Mapping[str, Any]:
+    timings = _mapping(value, description=description)
+    for key, seconds in timings.items():
+        if not isinstance(key, str) or not key:
+            raise ComparisonError(f"{description} has an invalid phase name")
+        if (
+            isinstance(seconds, bool)
+            or not isinstance(seconds, (int, float))
+            or not math.isfinite(float(seconds))
+            or float(seconds) < 0.0
+        ):
+            raise ComparisonError(
+                f"{description}.{key} must be a non-negative finite number"
+            )
+    return timings
+
+
+def _strict_mapping(
+    value: object,
+    *,
+    description: str,
+    expected_fields: frozenset[str],
+) -> Mapping[str, Any]:
+    result = _mapping(value, description=description)
+    if set(result) != expected_fields:
+        missing = sorted(expected_fields - set(result))
+        extra = sorted(set(result) - expected_fields)
+        details = []
+        if missing:
+            details.append("missing=" + ",".join(missing))
+        if extra:
+            details.append("extra=" + ",".join(extra))
+        raise ComparisonError(f"{description} fields are invalid: {'; '.join(details)}")
+    return result
+
+
+def _validate_native_generation_profile(
+    value: object,
+    *,
+    description: str,
+    expected_serialized_bytes: Mapping[str, int] | None,
+) -> None:
+    profile = _strict_mapping(
+        value,
+        description=description,
+        expected_fields=frozenset(
+            {
+                "schema_version",
+                "scope",
+                "timings_seconds",
+                "operation_counters",
+                "serialized_bytes",
+            }
+        ),
+    )
+    if profile.get("schema_version") != 1 or profile.get("scope") != "generation-only":
+        raise ComparisonError(f"{description} has an incompatible contract")
+    timings = _strict_mapping(
+        profile.get("timings_seconds"),
+        description=f"{description}.timings_seconds",
+        expected_fields=_GENERATION_PROFILE_TIMINGS,
+    )
+    _timings(timings, description=f"{description}.timings_seconds")
+    counters = _strict_mapping(
+        profile.get("operation_counters"),
+        description=f"{description}.operation_counters",
+        expected_fields=_GENERATION_PROFILE_COUNTERS,
+    )
+    for name, value in counters.items():
+        _nonnegative_int(value, description=f"{description}.{name}")
+    serialized = _strict_mapping(
+        profile.get("serialized_bytes"),
+        description=f"{description}.serialized_bytes",
+        expected_fields=_GENERATION_PROFILE_SERIALIZED_BYTES,
+    )
+    normalized_serialized = {
+        name: _nonnegative_int(value, description=f"{description}.{name}")
+        for name, value in serialized.items()
+    }
+    if expected_serialized_bytes is not None and normalized_serialized != dict(
+        expected_serialized_bytes
+    ):
+        raise ComparisonError(
+            f"{description} serialized-byte telemetry is not linked to its "
+            "authenticated runtime schedule"
+        )
+
+
+def _validate_recurrence_schedule_profiles(
+    manifest: Mapping[str, Any],
+    *,
+    label: str,
+    schedule_records: Mapping[str, Mapping[str, Any]],
+    schedules: Mapping[str, RecurrencePacbinSnapshot],
+) -> None:
+    generation = _manifest_generation(manifest)
+    raw_profiles = generation.get("recurrence_schedule_profiles", _MISSING)
+    if raw_profiles is _MISSING:
+        return
+    profiles = _mapping(
+        raw_profiles,
+        description=f"{label} recurrence schedule generation profiles",
+    )
+    schedule_path_by_digest = {
+        _sha256(
+            record.get("digest"),
+            description=f"{label} recurrence schedule digest",
+        ): path
+        for path, record in schedule_records.items()
+    }
+    if set(profiles) != set(schedule_path_by_digest):
+        raise ComparisonError(
+            f"{label} recurrence schedule generation-profile inventory is stale"
+        )
+    for schedule_digest, raw_profile in profiles.items():
+        profile = _strict_mapping(
+            raw_profile,
+            description=(f"{label} recurrence schedule profile {schedule_digest}"),
+            expected_fields=frozenset({"schema_version", "native_passes"}),
+        )
+        if profile.get("schema_version") != 1:
+            raise ComparisonError(
+                f"{label} recurrence schedule profile {schedule_digest} "
+                "has an incompatible schema"
+            )
+        native_passes = _mapping(
+            profile.get("native_passes"),
+            description=(
+                f"{label} recurrence schedule profile {schedule_digest} native_passes"
+            ),
+        )
+        if "final" not in native_passes or not set(native_passes) <= {
+            "baseline",
+            "final",
+        }:
+            raise ComparisonError(
+                f"{label} recurrence schedule profile {schedule_digest} "
+                "has invalid native-pass names"
+            )
+        schedule_path = schedule_path_by_digest[schedule_digest]
+        schedule = schedules[schedule_path]
+        final_serialized = {
+            "plan_payload": schedule.members[_PLAN_MEMBER_PATH].length,
+            "container": schedule.file_size,
+            "unpacked_container": schedule.unpacked_size_bytes,
+        }
+        for pass_name, native_profile in native_passes.items():
+            _validate_native_generation_profile(
+                native_profile,
+                description=(
+                    f"{label} recurrence schedule profile {schedule_digest} "
+                    f"native_passes.{pass_name}"
+                ),
+                expected_serialized_bytes=(
+                    final_serialized if pass_name == "final" else None
+                ),
+            )
+
+
+def _manifest_generation(manifest: Mapping[str, Any]) -> Mapping[str, Any]:
+    extensions = _mapping(manifest.get("extensions"), description="artifact extensions")
+    return _mapping(
+        extensions.get("generation"), description="artifact generation extension"
+    )
+
+
+def _validate_manifest_metadata(manifest: Mapping[str, Any]) -> None:
+    if manifest.get("kind") != "pyamplicol-process":
+        raise ComparisonError("artifact manifest is not a pyAmplicol process artifact")
+    if manifest.get("schema_version") != 3:
+        raise ComparisonError("artifact manifest does not use schema version 3")
+    artifact_id = _sha256(manifest.get("artifact_id"), description="artifact_id")
+    expected_artifact_id = _runtime_artifact_id(manifest)
+    if artifact_id != expected_artifact_id:
+        raise ComparisonError("artifact_id does not authenticate the manifest")
+    _utc_timestamp(manifest.get("created_utc"), description="created_utc")
+    producer = _mapping(manifest.get("producer"), description="artifact producer")
+    revision = producer.get("git_revision")
+    if not isinstance(revision, str) or _GIT_REVISION_RE.fullmatch(revision) is None:
+        raise ComparisonError("artifact producer.git_revision is invalid")
+    _sha256(
+        producer.get("native_build_inputs_sha256"),
+        description="artifact producer.native_build_inputs_sha256",
+    )
+    _nonempty_string(producer.get("version"), description="artifact producer.version")
+    generation = _manifest_generation(manifest)
+    _timings(
+        generation.get("phase_timings_seconds"),
+        description="artifact generation phase timings",
+    )
+
+
+def _validate_recurrence_inventory(
+    payloads: Mapping[str, PayloadSnapshot],
+    executions: Mapping[str, dict[str, Any]],
+    manifest: Mapping[str, Any],
+) -> None:
+    required = {"evaluators.pacbin", "recurrence/schedule-index.json"}
+    missing = sorted(required - payloads.keys())
+    if missing:
+        raise ComparisonError(
+            "recurrence artifact is missing required payloads: " + ", ".join(missing)
+        )
+    schedules = [path for path in payloads if _RUNTIME_SCHEDULE_RE.fullmatch(path)]
+    if not schedules:
+        raise ComparisonError("recurrence artifact has no runtime schedule payload")
+
+    execution_ids = {
+        match.group(1)
+        for path in executions
+        if (match := _EXECUTION_PATH_RE.fullmatch(path)) is not None
+    }
+    binding_ids = {
+        match.group(1)
+        for path in payloads
+        if (match := _BINDING_PATH_RE.fullmatch(path)) is not None
+    }
+    if not execution_ids or binding_ids != execution_ids:
+        raise ComparisonError(
+            "recurrence execution manifests and process bindings do not match"
+        )
+
+    generation = _manifest_generation(manifest)
+    concrete = _sequence(
+        generation.get("concrete_processes"),
+        description="artifact concrete processes",
+    )
+    concrete_by_id: dict[str, Mapping[str, Any]] = {}
+    for index, raw_record in enumerate(concrete):
+        record = _mapping(raw_record, description=f"artifact concrete process {index}")
+        process_id = _nonempty_string(
+            record.get("id"), description=f"artifact concrete process {index}.id"
+        )
+        if process_id in concrete_by_id:
+            raise ComparisonError(f"duplicate concrete process id: {process_id}")
+        concrete_by_id[process_id] = record
+    if set(concrete_by_id) != execution_ids:
+        raise ComparisonError(
+            "artifact concrete-process inventory does not match executions"
+        )
+    for process_id, record in concrete_by_id.items():
+        execution_path = f"processes/{process_id}/execution.json"
+        expected = payloads[execution_path].sha256
+        observed = _sha256(
+            record.get("execution_manifest_sha256"),
+            description=(
+                f"artifact concrete process {process_id} execution manifest digest"
+            ),
+        )
+        if observed != expected:
+            raise ComparisonError(
+                f"concrete process {process_id} execution digest is stale"
+            )
+
+
+def _validate_linked_recurrence_metadata(
+    *,
+    label: str,
+    payloads: Mapping[str, PayloadSnapshot],
+    executions: Mapping[str, dict[str, Any]],
+    manifest: Mapping[str, Any],
+) -> tuple[dict[str, Any], dict[str, RecurrencePacbinSnapshot]]:
+    schedule_index_payload = payloads[_SCHEDULE_INDEX_PATH]
+    schedule_index = _json_object(
+        schedule_index_payload.path,
+        description=f"{label} recurrence schedule index",
+    )
+    if (
+        schedule_index.get("kind") != "pyamplicol-recurrence-schedule-sharing"
+        or schedule_index.get("schema_version") != 3
+        or schedule_index.get("runtime_ownership")
+        != "root-schedule-plus-process-binding"
+        or schedule_index.get("interning_phase") != "before-direct-lowering"
+    ):
+        raise ComparisonError(
+            f"{label} recurrence schedule index has an incompatible contract"
+        )
+    raw_schedule_records = _sequence(
+        schedule_index.get("schedules"),
+        description=f"{label} recurrence schedule-index schedules",
+    )
+    schedule_records: dict[str, Mapping[str, Any]] = {}
+    for index, raw_record in enumerate(raw_schedule_records):
+        record = _mapping(
+            raw_record,
+            description=f"{label} recurrence schedule record {index}",
+        )
+        path = _payload_relative_path(
+            record.get("path"),
+            description=f"{label} recurrence schedule record {index}",
+        )
+        if path in schedule_records:
+            raise ComparisonError(f"{label} recurrence schedule path is duplicated")
+        schedule_records[path] = record
+    runtime_paths = {path for path in payloads if _RUNTIME_SCHEDULE_RE.fullmatch(path)}
+    if set(schedule_records) != runtime_paths:
+        raise ComparisonError(
+            f"{label} schedule-index inventory does not match runtime PACBINs"
+        )
+
+    schedules: dict[str, RecurrencePacbinSnapshot] = {}
+    for path, record in schedule_records.items():
+        payload = payloads[path]
+        match = _RUNTIME_SCHEDULE_RE.fullmatch(path)
+        assert match is not None
+        schedule_digest = _sha256(
+            record.get("digest"),
+            description=f"{label} schedule {path}.digest",
+        )
+        if schedule_digest != match.group(1):
+            raise ComparisonError(
+                f"{label} schedule digest does not match its artifact path: {path}"
+            )
+        pacbin = _load_recurrence_pacbin(
+            payload.path,
+            description=f"{label} recurrence runtime PACBIN {path}",
+        )
+        linked_values = (
+            (
+                "sha256",
+                _sha256(
+                    record.get("sha256"),
+                    description=f"{label} schedule {path}.sha256",
+                ),
+                payload.sha256,
+            ),
+            (
+                "size_bytes",
+                _nonnegative_int(
+                    record.get("size_bytes"),
+                    description=f"{label} schedule {path}.size_bytes",
+                ),
+                payload.size_bytes,
+            ),
+            (
+                "member_count",
+                _nonnegative_int(
+                    record.get("member_count"),
+                    description=f"{label} schedule {path}.member_count",
+                ),
+                len(pacbin.members),
+            ),
+            (
+                "unpacked_size_bytes",
+                _nonnegative_int(
+                    record.get("unpacked_size_bytes"),
+                    description=f"{label} schedule {path}.unpacked_size_bytes",
+                ),
+                pacbin.unpacked_size_bytes,
+            ),
+            (
+                "index_sha256",
+                _sha256(
+                    record.get("index_sha256"),
+                    description=f"{label} schedule {path}.index_sha256",
+                ),
+                pacbin.index_sha256,
+            ),
+        )
+        stale_fields = [
+            name for name, observed, expected in linked_values if observed != expected
+        ]
+        if stale_fields:
+            raise ComparisonError(
+                f"{label} schedule record has stale linked fields for {path}: "
+                + ", ".join(stale_fields)
+            )
+        schedules[path] = pacbin
+
+    extension = _mapping(
+        _mapping(
+            manifest.get("extensions"),
+            description=f"{label} artifact extensions",
+        ).get("recurrence_schedule_sharing"),
+        description=f"{label} recurrence schedule-sharing extension",
+    )
+    if (
+        extension.get("kind") != schedule_index.get("kind")
+        or extension.get("schema_version") != schedule_index.get("schema_version")
+        or extension.get("index_path") != _SCHEDULE_INDEX_PATH
+        or extension.get("index_sha256") != schedule_index_payload.sha256
+        or extension.get("runtime_ownership") != schedule_index.get("runtime_ownership")
+        or extension.get("interning_phase") != schedule_index.get("interning_phase")
+    ):
+        raise ComparisonError(f"{label} recurrence schedule-sharing extension is stale")
+    for field, expected in (
+        ("schedule_count", len(schedule_records)),
+        (
+            "binding_count",
+            len(
+                _sequence(
+                    schedule_index.get("bindings"),
+                    description=f"{label} recurrence schedule-index bindings",
+                )
+            ),
+        ),
+    ):
+        observed = _nonnegative_int(
+            extension.get(field),
+            description=f"{label} recurrence sharing {field}",
+        )
+        if observed != expected or schedule_index.get(field) != expected:
+            raise ComparisonError(f"{label} recurrence sharing {field} is stale")
+    expected_alias_count = int(extension["binding_count"]) - int(
+        extension["schedule_count"]
+    )
+    if (
+        extension.get("schedule_alias_count") != expected_alias_count
+        or schedule_index.get("schedule_alias_count") != expected_alias_count
+    ):
+        raise ComparisonError(f"{label} recurrence sharing alias count is stale")
+
+    for execution_path, execution in executions.items():
+        plan = _mapping(
+            execution.get("plan"),
+            description=f"{label} execution {execution_path}.plan",
+        )
+        runtime = _mapping(
+            plan.get("runtime_schedule"),
+            description=f"{label} execution {execution_path}.runtime_schedule",
+        )
+        schedule_path = _payload_relative_path(
+            runtime.get("path"),
+            description=f"{label} execution {execution_path}.runtime_schedule",
+        )
+        if schedule_path not in schedules:
+            raise ComparisonError(
+                f"{label} execution {execution_path} names an unknown schedule"
+            )
+        pacbin = schedules[schedule_path]
+        schedule_payload = payloads[schedule_path]
+        expected_runtime_values = {
+            "kind": "pyamplicol-recurrence-runtime-container",
+            "schema_version": 1,
+            "storage_abi": "pacbin-v1",
+            "plan_member_path": _PLAN_MEMBER_PATH,
+            "sha256": schedule_payload.sha256,
+            "size_bytes": schedule_payload.size_bytes,
+            "member_count": len(pacbin.members),
+            "unpacked_size_bytes": pacbin.unpacked_size_bytes,
+            "index_sha256": pacbin.index_sha256,
+        }
+        stale_runtime = [
+            field
+            for field, expected in expected_runtime_values.items()
+            if runtime.get(field) != expected
+        ]
+        if stale_runtime:
+            raise ComparisonError(
+                f"{label} execution {execution_path} has stale runtime-schedule "
+                "metadata: " + ", ".join(stale_runtime)
+            )
+        inspection = _mapping(
+            plan.get("inspection_summary"),
+            description=f"{label} execution {execution_path}.inspection_summary",
+        )
+        certificate_record = inspection.get("color_projection_certificate")
+        certificate = pacbin.projection_certificate
+        if certificate is None:
+            if certificate_record is not None:
+                raise ComparisonError(
+                    f"{label} execution {execution_path} declares an absent "
+                    "projection certificate"
+                )
+        else:
+            record = _mapping(
+                certificate_record,
+                description=(
+                    f"{label} execution {execution_path} projection certificate"
+                ),
+            )
+            expected_certificate_values = {
+                "path": _CERTIFICATE_MEMBER_PATH,
+                "schema_version": 1,
+                "proof_kind": "exact-rectangular-sum-projection",
+                "publishable": True,
+                "size_bytes": pacbin.members[_CERTIFICATE_MEMBER_PATH].length,
+                "sha256": certificate.sha256,
+            }
+            stale_certificate = [
+                field
+                for field, expected in expected_certificate_values.items()
+                if record.get(field) != expected
+            ]
+            if stale_certificate:
+                raise ComparisonError(
+                    f"{label} execution {execution_path} has stale projection-"
+                    "certificate metadata: " + ", ".join(stale_certificate)
+                )
+    _validate_recurrence_schedule_profiles(
+        manifest,
+        label=label,
+        schedule_records=schedule_records,
+        schedules=schedules,
+    )
+    return schedule_index, schedules
+
+
+def _load_artifact(path: Path, *, label: str) -> ArtifactSnapshot:
+    raw_root = path.expanduser()
+    if raw_root.is_symlink():
+        raise ComparisonError(f"{label} artifact root may not be a symlink")
+    try:
+        root = raw_root.resolve(strict=True)
+    except OSError as error:
+        raise ComparisonError(f"{label} artifact does not exist: {path}") from error
+    if not root.is_dir():
+        raise ComparisonError(f"{label} artifact is not a directory: {root}")
+
+    actual_files: set[str] = set()
+    try:
+        for candidate in root.rglob("*"):
+            if candidate.is_symlink():
+                raise ComparisonError(
+                    f"{label} artifact contains a symlink: {candidate}"
+                )
+            if candidate.is_file():
+                actual_files.add(candidate.relative_to(root).as_posix())
+    except OSError as error:
+        raise ComparisonError(f"cannot inspect {label} artifact: {root}") from error
+
+    manifest_path = root / "artifact.json"
+    manifest = _json_object(manifest_path, description=f"{label} artifact manifest")
+    _validate_manifest_metadata(manifest)
+    raw_payloads = _sequence(
+        manifest.get("payloads"), description=f"{label} artifact payloads"
+    )
+    payloads: dict[str, PayloadSnapshot] = {}
+    executions: dict[str, dict[str, Any]] = {}
+    for index, raw_record in enumerate(raw_payloads):
+        record = dict(
+            _mapping(raw_record, description=f"{label} payload record {index}")
+        )
+        relative = _payload_relative_path(
+            record.get("path"), description=f"{label} payload record {index}"
+        )
+        if relative in payloads:
+            raise ComparisonError(f"{label} artifact has duplicate payload {relative}")
+        role = _nonempty_string(
+            record.get("role"), description=f"{label} payload {relative}.role"
+        )
+        declared_size = _nonnegative_int(
+            record.get("size_bytes"),
+            description=f"{label} payload {relative}.size_bytes",
+        )
+        declared_sha = _sha256(
+            record.get("sha256"),
+            description=f"{label} payload {relative}.sha256",
+        )
+        payload_path = root.joinpath(*PurePosixPath(relative).parts)
+        if (
+            not payload_path.is_file()
+            or payload_path.is_symlink()
+            or payload_path.resolve().parent == root.parent
+        ):
+            raise ComparisonError(
+                f"{label} payload is missing or not a regular file: {relative}"
+            )
+        actual_size = payload_path.stat().st_size
+        actual_sha = _sha256_file(payload_path)
+        if declared_size != actual_size or declared_sha != actual_sha:
+            raise ComparisonError(
+                f"{label} payload metadata does not authenticate {relative}"
+            )
+        snapshot = PayloadSnapshot(
+            relative_path=relative,
+            path=payload_path,
+            role=role,
+            size_bytes=actual_size,
+            sha256=actual_sha,
+            record=record,
+        )
+        payloads[relative] = snapshot
+        if _EXECUTION_PATH_RE.fullmatch(relative):
+            execution = _json_object(
+                payload_path, description=f"{label} recurrence execution manifest"
+            )
+            if execution.get("kind") != "pyamplicol-runtime-recurrence-execution":
+                raise ComparisonError(
+                    f"{label} execution payload is not recurrence mode: {relative}"
+                )
+            plan = _mapping(
+                execution.get("plan"),
+                description=f"{label} execution {relative}.plan",
+            )
+            inspection = _mapping(
+                plan.get("inspection_summary"),
+                description=f"{label} execution {relative}.inspection_summary",
+            )
+            _timings(
+                inspection.get("generation_timings_seconds"),
+                description=f"{label} execution {relative} generation timings",
+            )
+            executions[relative] = execution
+
+    expected_files = {"artifact.json", *payloads}
+    if actual_files != expected_files:
+        extra = sorted(actual_files - expected_files)
+        missing = sorted(expected_files - actual_files)
+        details = []
+        if extra:
+            details.append("unlisted=" + ",".join(extra))
+        if missing:
+            details.append("missing=" + ",".join(missing))
+        raise ComparisonError(
+            f"{label} artifact file inventory is not exact: {'; '.join(details)}"
+        )
+    _validate_recurrence_inventory(payloads, executions, manifest)
+    schedule_index, recurrence_schedules = _validate_linked_recurrence_metadata(
+        label=label,
+        payloads=payloads,
+        executions=executions,
+        manifest=manifest,
+    )
+    return ArtifactSnapshot(
+        root=root,
+        manifest_path=manifest_path,
+        manifest=manifest,
+        manifest_sha256=_sha256_file(manifest_path),
+        payloads=payloads,
+        executions=executions,
+        schedule_index=schedule_index,
+        recurrence_schedules=recurrence_schedules,
+    )
+
+
+def _canonical_sha256(value: object) -> str:
+    encoded = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _canonical_domain_sha256(domain: str, value: object) -> str:
+    return _canonical_sha256({"domain": domain, "value": value})
+
+
+def _structural_semantic_map_witnesses(
+    execution: Mapping[str, Any],
+) -> dict[str, object]:
+    predicates = {
+        "current_member_map": lambda key: (
+            "current" in key
+            or key
+            in {
+                "source_count",
+                "source_fill",
+                "source_row_count",
+                "sources",
+                "value_storage",
+            }
+        ),
+        "interaction_row_map": lambda key: (
+            "interaction" in key
+            or "contribution" in key
+            or key in {"stages", "schedule"}
+        ),
+        "closure_map": lambda key: (
+            "closure" in key
+            or "amplitude" in key
+            or "destination" in key
+            or "reduction" in key
+        ),
+        "source_contract": lambda key: (
+            key
+            in {
+                "color_accuracy",
+                "external_particles",
+                "external_pdg_order",
+                "kind",
+                "model",
+                "normalization",
+                "parameter_layout",
+                "process",
+                "process_key",
+                "runtime_metadata",
+                "schema_version",
+            }
+        ),
+    }
+
+    def project(predicate: Callable[[str], bool]) -> list[dict[str, object]]:
+        rows: list[dict[str, object]] = []
+
+        def visit(value: object, path: str) -> None:
+            if isinstance(value, Mapping):
+                for raw_key in sorted(value, key=str):
+                    key = str(raw_key)
+                    child = value[raw_key]
+                    child_path = f"{path}.{key}" if path else key
+                    if predicate(key):
+                        rows.append({"path": child_path, "value": child})
+                    else:
+                        visit(child, child_path)
+            elif isinstance(value, Sequence) and not isinstance(value, str | bytes):
+                for index, child in enumerate(value):
+                    visit(child, f"{path}[{index}]")
+
+        visit(execution, "")
+        if not rows:
+            raise ComparisonError(
+                "structural proof execution lacks a semantic-map witness"
+            )
+        return rows
+
+    result: dict[str, object] = {}
+    identities: set[str] = set()
+    for name, predicate in predicates.items():
+        rows = project(predicate)
+        digest = _canonical_domain_sha256(
+            _STRUCTURAL_SEMANTIC_MAP_DOMAINS[name],
+            rows,
+        )
+        if digest in identities:
+            raise ComparisonError("structural proof semantic-map identities repeat")
+        identities.add(digest)
+        result[name] = {"sha256": digest, "rows": rows}
+    return result
+
+
+def _structural_metrics(value: object) -> list[dict[str, object]]:
+    rows: list[dict[str, object]] = []
+
+    def visit(item: object, path: str) -> None:
+        if isinstance(item, Mapping):
+            for raw_key in sorted(item, key=str):
+                key = str(raw_key)
+                child = item[raw_key]
+                child_path = f"{path}.{key}" if path else key
+                if (
+                    isinstance(child, int)
+                    and not isinstance(child, bool)
+                    and (
+                        key.endswith("_count")
+                        or key.endswith("_size")
+                        or key.endswith("_size_bytes")
+                    )
+                ):
+                    if child < 0:
+                        raise ComparisonError(
+                            f"structural metric {child_path} must be non-negative"
+                        )
+                    rows.append({"path": child_path, "value": child})
+                else:
+                    visit(child, child_path)
+        elif isinstance(item, Sequence) and not isinstance(item, str | bytes):
+            for index, child in enumerate(item):
+                visit(child, f"{path}[{index}]")
+
+    visit(value, "")
+    if not rows:
+        raise ComparisonError("structural proof execution has no structural metrics")
+    return rows
+
+
+def _describe(value: object) -> object:
+    if value is _MISSING:
+        return {"kind": "missing"}
+    if value is None or isinstance(value, (bool, int, float)):
+        return value
+    if isinstance(value, str):
+        if len(value) <= 160:
+            return value
+        return {
+            "kind": "string",
+            "length": len(value),
+            "preview": value[:157] + "...",
+            "sha256": hashlib.sha256(value.encode("utf-8")).hexdigest(),
+        }
+    if isinstance(value, Mapping):
+        return {
+            "kind": "object",
+            "key_count": len(value),
+            "sha256": _canonical_sha256(value),
+        }
+    if isinstance(value, list):
+        return {
+            "kind": "array",
+            "length": len(value),
+            "sha256": _canonical_sha256(value),
+        }
+    return {"kind": type(value).__name__, "repr": repr(value)}
+
+
+def _pointer(path: Sequence[str | int]) -> str:
+    if not path:
+        return ""
+    return "/" + "/".join(
+        str(part).replace("~", "~0").replace("/", "~1") for part in path
+    )
+
+
+def _json_differences(
+    left: object,
+    right: object,
+    *,
+    file: str,
+    path: tuple[str | int, ...] = (),
+) -> list[dict[str, object]]:
+    if type(left) is not type(right):
+        return [
+            {
+                "kind": "json-value",
+                "file": file,
+                "json_pointer": _pointer(path),
+                "baseline": _describe(left),
+                "candidate": _describe(right),
+            }
+        ]
+    if isinstance(left, dict):
+        assert isinstance(right, dict)
+        differences: list[dict[str, object]] = []
+        for key in sorted(set(left) | set(right)):
+            if key not in left or key not in right:
+                differences.append(
+                    {
+                        "kind": "json-value",
+                        "file": file,
+                        "json_pointer": _pointer((*path, key)),
+                        "baseline": _describe(left.get(key, _MISSING)),
+                        "candidate": _describe(right.get(key, _MISSING)),
+                    }
+                )
+                continue
+            differences.extend(
+                _json_differences(
+                    left[key],
+                    right[key],
+                    file=file,
+                    path=(*path, key),
+                )
+            )
+        return differences
+    if isinstance(left, list):
+        assert isinstance(right, list)
+        if len(left) != len(right):
+            return [
+                {
+                    "kind": "json-value",
+                    "file": file,
+                    "json_pointer": _pointer(path),
+                    "baseline": _describe(left),
+                    "candidate": _describe(right),
+                }
+            ]
+        differences = []
+        for index, (left_item, right_item) in enumerate(zip(left, right, strict=True)):
+            differences.extend(
+                _json_differences(
+                    left_item,
+                    right_item,
+                    file=file,
+                    path=(*path, index),
+                )
+            )
+        return differences
+    if left == right:
+        return []
+    return [
+        {
+            "kind": "json-value",
+            "file": file,
+            "json_pointer": _pointer(path),
+            "baseline": _describe(left),
+            "candidate": _describe(right),
+        }
+    ]
+
+
+def _record_allowed(
+    records: list[dict[str, object]],
+    *,
+    file: str,
+    json_path: str,
+    category: str,
+    baseline: object,
+    candidate: object,
+) -> None:
+    if baseline == candidate:
+        return
+    records.append(
+        {
+            "file": file,
+            "json_path": json_path,
+            "category": category,
+            "baseline": _describe(baseline),
+            "candidate": _describe(candidate),
+        }
+    )
+
+
+def _compare_recurrence_pacbins(
+    baseline: RecurrencePacbinSnapshot,
+    candidate: RecurrencePacbinSnapshot,
+    *,
+    relative_path: str,
+    unknown: list[dict[str, object]],
+) -> RecurrencePacbinComparison:
+    exact_bytes_match = _files_equal(baseline.path, candidate.path)
+    baseline_paths = set(baseline.members)
+    candidate_paths = set(candidate.members)
+    if baseline_paths != candidate_paths:
+        unknown.append(
+            {
+                "kind": "pacbin-member-inventory",
+                "path": relative_path,
+                "baseline": sorted(baseline_paths),
+                "candidate": sorted(candidate_paths),
+            }
+        )
+        return RecurrencePacbinComparison(
+            exact_bytes_match=exact_bytes_match,
+            policy_match=False,
+            plan_bytes_match=False,
+            projection_certificate_bodies_match=False,
+        )
+
+    structural_member_mismatch = False
+    for member_path in sorted(baseline_paths):
+        left = baseline.members[member_path]
+        right = candidate.members[member_path]
+        left_shape = (left.kind, left.offset, left.length)
+        right_shape = (right.kind, right.offset, right.length)
+        if left_shape != right_shape:
+            structural_member_mismatch = True
+            unknown.append(
+                {
+                    "kind": "pacbin-member-layout",
+                    "path": relative_path,
+                    "member": member_path,
+                    "baseline": {
+                        "kind": left.kind,
+                        "offset": left.offset,
+                        "length": left.length,
+                    },
+                    "candidate": {
+                        "kind": right.kind,
+                        "offset": right.offset,
+                        "length": right.length,
+                    },
+                }
+            )
+    if baseline.file_size != candidate.file_size:
+        structural_member_mismatch = True
+        unknown.append(
+            {
+                "kind": "pacbin-container-size",
+                "path": relative_path,
+                "baseline": baseline.file_size,
+                "candidate": candidate.file_size,
+            }
+        )
+
+    left_plan = baseline.members[_PLAN_MEMBER_PATH]
+    right_plan = candidate.members[_PLAN_MEMBER_PATH]
+    plan_bytes_match = (
+        left_plan.kind == right_plan.kind
+        and left_plan.length == right_plan.length
+        and left_plan.sha256 == right_plan.sha256
+        and _file_ranges_equal(
+            baseline.path,
+            candidate.path,
+            left_offset=left_plan.offset,
+            right_offset=right_plan.offset,
+            length=left_plan.length,
+        )
+    )
+    if not plan_bytes_match:
+        unknown.append(
+            {
+                "kind": "pacbin-runtime-plan-bytes",
+                "path": relative_path,
+                "member": _PLAN_MEMBER_PATH,
+                "baseline": {
+                    "sha256": left_plan.sha256,
+                    "size_bytes": left_plan.length,
+                },
+                "candidate": {
+                    "sha256": right_plan.sha256,
+                    "size_bytes": right_plan.length,
+                },
+            }
+        )
+
+    left_certificate = baseline.projection_certificate
+    right_certificate = candidate.projection_certificate
+    if (left_certificate is None) != (right_certificate is None):
+        unknown.append(
+            {
+                "kind": "projection-certificate-presence",
+                "path": relative_path,
+                "baseline": left_certificate is not None,
+                "candidate": right_certificate is not None,
+            }
+        )
+        return RecurrencePacbinComparison(
+            exact_bytes_match=exact_bytes_match,
+            policy_match=False,
+            plan_bytes_match=plan_bytes_match,
+            projection_certificate_bodies_match=False,
+        )
+    if left_certificate is None:
+        if not exact_bytes_match:
+            unknown.append(
+                {
+                    "kind": "pacbin-container-bytes",
+                    "path": relative_path,
+                    "baseline": {
+                        "sha256": _sha256_file(baseline.path),
+                        "size_bytes": baseline.file_size,
+                    },
+                    "candidate": {
+                        "sha256": _sha256_file(candidate.path),
+                        "size_bytes": candidate.file_size,
+                    },
+                }
+            )
+        return RecurrencePacbinComparison(
+            exact_bytes_match=exact_bytes_match,
+            policy_match=exact_bytes_match and plan_bytes_match,
+            plan_bytes_match=plan_bytes_match,
+            projection_certificate_bodies_match=True,
+        )
+
+    assert right_certificate is not None
+    certificate_bodies_match = (
+        left_certificate.body_length == right_certificate.body_length
+        and _file_ranges_equal(
+            baseline.path,
+            candidate.path,
+            left_offset=left_certificate.body_offset,
+            right_offset=right_certificate.body_offset,
+            length=left_certificate.body_length,
+        )
+    )
+    if not certificate_bodies_match:
+        unknown.append(
+            {
+                "kind": "projection-certificate-structural-body",
+                "path": relative_path,
+                "member": _CERTIFICATE_MEMBER_PATH,
+                "baseline": {
+                    "length": left_certificate.body_length,
+                    "sha256": _sha256_file_range(
+                        baseline.path,
+                        offset=left_certificate.body_offset,
+                        length=left_certificate.body_length,
+                    ),
+                },
+                "candidate": {
+                    "length": right_certificate.body_length,
+                    "sha256": _sha256_file_range(
+                        candidate.path,
+                        offset=right_certificate.body_offset,
+                        length=right_certificate.body_length,
+                    ),
+                },
+            }
+        )
+    policy_match = (
+        not structural_member_mismatch
+        and plan_bytes_match
+        and certificate_bodies_match
+        and exact_bytes_match
+    )
+    if not exact_bytes_match:
+        unknown.append(
+            {
+                "kind": "pacbin-unexplained-container-difference",
+                "path": relative_path,
+                "baseline": {
+                    "sha256": _sha256_file(baseline.path),
+                    "index_sha256": baseline.index_sha256,
+                },
+                "candidate": {
+                    "sha256": _sha256_file(candidate.path),
+                    "index_sha256": candidate.index_sha256,
+                },
+            }
+        )
+    return RecurrencePacbinComparison(
+        exact_bytes_match=exact_bytes_match,
+        policy_match=policy_match,
+        plan_bytes_match=plan_bytes_match,
+        projection_certificate_bodies_match=certificate_bodies_match,
+    )
+
+
+def _replace_pair(
+    left: dict[str, Any],
+    right: dict[str, Any],
+    path: tuple[str, ...],
+    *,
+    file: str,
+    json_path: str,
+    category: str,
+    validate: Callable[[object], object],
+    allowed: list[dict[str, object]],
+) -> None:
+    left_parent = left
+    right_parent = right
+    for key in path[:-1]:
+        left_child = left_parent.get(key)
+        right_child = right_parent.get(key)
+        if not isinstance(left_child, dict) or not isinstance(right_child, dict):
+            raise ComparisonError(
+                f"required allowed metadata parent is missing: {file}{json_path}"
+            )
+        left_parent = left_child
+        right_parent = right_child
+    key = path[-1]
+    if key not in left_parent or key not in right_parent:
+        raise ComparisonError(f"required allowed metadata path is missing: {json_path}")
+    left_value = validate(left_parent[key])
+    right_value = validate(right_parent[key])
+    _record_allowed(
+        allowed,
+        file=file,
+        json_path=json_path,
+        category=category,
+        baseline=left_value,
+        candidate=right_value,
+    )
+    left_parent[key] = _NORMALIZED
+    right_parent[key] = _NORMALIZED
+
+
+def _validate_structural_proof(
+    artifact: ArtifactSnapshot,
+    proof: Mapping[str, Any],
+    *,
+    relative_path: str,
+    label: str,
+) -> tuple[str, str]:
+    match = _STRUCTURAL_PROOF_PATH_RE.fullmatch(relative_path)
+    if match is None:
+        raise ComparisonError(f"{label} structural-proof path is invalid")
+    process_id = match.group(1)
+    expected_execution_path = f"processes/{process_id}/execution.json"
+    if (
+        proof.get("schema") != "pyamplicol-generation-structural-source-proof-v1"
+        or proof.get("status") != "complete"
+        or proof.get("process_id") != process_id
+    ):
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} has an incompatible contract"
+        )
+    payload = artifact.payloads[relative_path]
+    if payload.role != "structural-source-proof":
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} has an invalid payload role"
+        )
+
+    producer = _mapping(
+        artifact.manifest.get("producer"),
+        description=f"{label} artifact producer",
+    )
+    source_identity = _mapping(
+        proof.get("source_identity"),
+        description=f"{label} structural proof source identity",
+    )
+    source_revision = source_identity.get("git_revision")
+    native_build_inputs = source_identity.get("native_build_inputs_sha256")
+    if source_revision != producer.get(
+        "git_revision"
+    ) or native_build_inputs != producer.get("native_build_inputs_sha256"):
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} is not bound to its producer"
+        )
+
+    execution_payload = artifact.payloads.get(expected_execution_path)
+    execution = artifact.executions.get(expected_execution_path)
+    if execution_payload is None or execution is None:
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} lacks its execution payload"
+        )
+    execution_identity = _mapping(
+        proof.get("execution"),
+        description=f"{label} structural proof execution identity",
+    )
+    if (
+        execution_identity.get("path") != expected_execution_path
+        or execution_identity.get("sha256") != execution_payload.sha256
+        or execution_identity.get("kind") != execution.get("kind")
+        or execution_identity.get("color_accuracy") != execution.get("color_accuracy")
+    ):
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} has a stale execution identity"
+        )
+
+    semantic_maps = _mapping(
+        proof.get("semantic_maps"),
+        description=f"{label} structural proof semantic maps",
+    )
+    if dict(semantic_maps) != _structural_semantic_map_witnesses(execution):
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} semantic maps are stale"
+        )
+
+    inventory = _mapping(
+        proof.get("physical_lane_inventory"),
+        description=f"{label} structural proof physical inventory",
+    )
+    if inventory.get("status") != "complete":
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} inventory is incomplete"
+        )
+    inventory_body = dict(inventory)
+    declared_inventory_digest = _sha256(
+        inventory_body.pop("inventory_sha256", None),
+        description=f"{label} structural proof inventory digest",
+    )
+    if declared_inventory_digest != _canonical_domain_sha256(
+        "physical-lane-inventory-v1",
+        inventory_body,
+    ):
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} inventory digest is stale"
+        )
+
+    loose_records = _sequence(
+        inventory.get("loose_payloads"),
+        description=f"{label} structural proof loose payloads",
+    )
+    loose_paths: set[str] = set()
+    for index, raw_record in enumerate(loose_records):
+        record = _mapping(
+            raw_record,
+            description=f"{label} structural proof loose payload {index}",
+        )
+        record_path = _payload_relative_path(
+            record.get("path"),
+            description=f"{label} structural proof loose payload {index}",
+        )
+        if record_path in loose_paths or record_path not in artifact.payloads:
+            raise ComparisonError(
+                f"{label} structural proof {relative_path} has an invalid loose payload"
+            )
+        loose_paths.add(record_path)
+        concrete = artifact.payloads[record_path]
+        if (
+            record.get("sha256") != concrete.sha256
+            or record.get("size_bytes") != concrete.size_bytes
+        ):
+            raise ComparisonError(
+                f"{label} structural proof {relative_path} has stale loose payload "
+                f"metadata for {record_path}"
+            )
+    if expected_execution_path not in loose_paths:
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} omits its execution payload"
+        )
+
+    raw_members = _sequence(
+        inventory.get("pacbin_members"),
+        description=f"{label} structural proof PACBIN members",
+    )
+    raw_container = inventory.get("pacbin_container")
+    actual_members: dict[str, dict[str, object]] = {}
+    if raw_container is not None:
+        container = _mapping(
+            raw_container,
+            description=f"{label} structural proof PACBIN container",
+        )
+        container_path = _payload_relative_path(
+            container.get("path"),
+            description=f"{label} structural proof PACBIN container",
+        )
+        container_payload = artifact.payloads.get(container_path)
+        if (
+            container_payload is None
+            or container.get("sha256") != container_payload.sha256
+            or container.get("size_bytes") != container_payload.size_bytes
+        ):
+            raise ComparisonError(
+                f"{label} structural proof {relative_path} PACBIN container is stale"
+            )
+        parsed_container = _load_recurrence_pacbin(
+            container_payload.path,
+            description=f"{label} structural proof evaluator container",
+            recurrence_contract=False,
+        )
+        if container.get(
+            "index_sha256"
+        ) != parsed_container.index_sha256 or container.get("member_count") != len(
+            parsed_container.members
+        ):
+            raise ComparisonError(
+                f"{label} structural proof {relative_path} PACBIN index is stale"
+            )
+        for member_path, member in parsed_container.members.items():
+            kind_name = _PACBIN_MEMBER_KIND_NAMES.get(member.kind)
+            if kind_name is None:
+                raise ComparisonError(
+                    f"{label} structural proof {relative_path} PACBIN member kind "
+                    "is unknown"
+                )
+            actual_members[member_path] = {
+                "logical_path": member_path,
+                "kind": kind_name,
+                "length": member.length,
+                "sha256": member.sha256,
+            }
+    elif raw_members:
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} members lack a container"
+        )
+
+    declared_member_paths: set[str] = set()
+    for index, raw_member in enumerate(raw_members):
+        member = _mapping(
+            raw_member,
+            description=f"{label} structural proof PACBIN member {index}",
+        )
+        member_path = _nonempty_string(
+            member.get("logical_path"),
+            description=f"{label} structural proof PACBIN member {index}.logical_path",
+        )
+        if member_path in declared_member_paths or actual_members.get(
+            member_path
+        ) != dict(member):
+            raise ComparisonError(
+                f"{label} structural proof {relative_path} PACBIN member is stale"
+            )
+        declared_member_paths.add(member_path)
+
+    lanes = _sequence(
+        inventory.get("lanes"),
+        description=f"{label} structural proof execution lanes",
+    )
+    if len(lanes) != 1:
+        raise ComparisonError(
+            f"{label} recurrence structural proof {relative_path} must have one lane"
+        )
+    lane = _mapping(
+        lanes[0],
+        description=f"{label} structural proof primary lane",
+    )
+    metrics = _structural_metrics(execution)
+    if (
+        lane.get("lane_id") != "primary"
+        or lane.get("subtree_sha256")
+        != _canonical_domain_sha256("execution-lane-subtree-v1", execution)
+        or lane.get("structural_metrics") != metrics
+        or lane.get("structural_metrics_sha256")
+        != _canonical_domain_sha256("execution-lane-structural-metrics-v1", metrics)
+    ):
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} lane evidence is stale"
+        )
+    lane_loose = _sequence(
+        lane.get("loose_payload_paths"),
+        description=f"{label} structural proof lane loose paths",
+    )
+    lane_members = _sequence(
+        lane.get("pacbin_member_paths"),
+        description=f"{label} structural proof lane member paths",
+    )
+    if (
+        any(not isinstance(path, str) for path in lane_loose)
+        or len(set(lane_loose)) != len(lane_loose)
+        or not set(lane_loose) <= loose_paths
+        or any(not isinstance(path, str) for path in lane_members)
+        or len(set(lane_members)) != len(lane_members)
+        or not set(lane_members) <= declared_member_paths
+    ):
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} lane references are invalid"
+        )
+
+    expected_roles = {
+        ("primary", "loose-payload", str(path)) for path in lane_loose
+    } | {("primary", "pacbin-member", str(path)) for path in lane_members}
+    raw_roles = _sequence(
+        inventory.get("roles"),
+        description=f"{label} structural proof roles",
+    )
+    actual_roles: set[tuple[str, str, str]] = set()
+    for index, raw_role in enumerate(raw_roles):
+        role = _mapping(
+            raw_role,
+            description=f"{label} structural proof role {index}",
+        )
+        actual_roles.add(
+            (
+                str(role.get("lane_id")),
+                str(role.get("object_kind")),
+                str(role.get("object_path")),
+            )
+        )
+    if actual_roles != expected_roles or len(actual_roles) != len(raw_roles):
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} role coverage is invalid"
+        )
+
+    proof_body = dict(proof)
+    declared_proof_digest = _sha256(
+        proof_body.pop("proof_content_sha256", None),
+        description=f"{label} structural proof content digest",
+    )
+    if declared_proof_digest != _canonical_domain_sha256(
+        "generation-structural-source-proof-v1",
+        proof_body,
+    ):
+        raise ComparisonError(
+            f"{label} structural proof {relative_path} content digest is stale"
+        )
+    return expected_execution_path, process_id
+
+
+def _normalize_structural_proof_pair(
+    baseline_artifact: ArtifactSnapshot,
+    candidate_artifact: ArtifactSnapshot,
+    baseline: Mapping[str, Any],
+    candidate: Mapping[str, Any],
+    *,
+    relative_path: str,
+    baseline_execution: Mapping[str, Any],
+    candidate_execution: Mapping[str, Any],
+    allowed: list[dict[str, object]],
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    left_execution_path, _ = _validate_structural_proof(
+        baseline_artifact,
+        baseline,
+        relative_path=relative_path,
+        label="baseline",
+    )
+    right_execution_path, _ = _validate_structural_proof(
+        candidate_artifact,
+        candidate,
+        relative_path=relative_path,
+        label="candidate",
+    )
+    if (
+        left_execution_path != right_execution_path
+        or baseline_execution != candidate_execution
+    ):
+        raise ComparisonError(
+            f"structural proof {relative_path} does not have matched "
+            "execution semantics"
+        )
+
+    left = copy.deepcopy(dict(baseline))
+    right = copy.deepcopy(dict(candidate))
+    for path, json_path, category, validate in (
+        (
+            ("source_identity", "git_revision"),
+            "/source_identity/git_revision",
+            "provenance",
+            lambda value: (
+                value
+                if isinstance(value, str)
+                and _GIT_REVISION_RE.fullmatch(value) is not None
+                else _raise_invalid("structural-proof source revision")
+            ),
+        ),
+        (
+            ("source_identity", "native_build_inputs_sha256"),
+            "/source_identity/native_build_inputs_sha256",
+            "provenance",
+            lambda value: _sha256(
+                value,
+                description="structural-proof native-build identity",
+            ),
+        ),
+        (
+            ("execution", "sha256"),
+            "/execution/sha256",
+            "derived-execution-metadata",
+            lambda value: _sha256(
+                value,
+                description="structural-proof execution digest",
+            ),
+        ),
+    ):
+        _replace_pair(
+            left,
+            right,
+            path,
+            file=relative_path,
+            json_path=json_path,
+            category=category,
+            validate=validate,
+            allowed=allowed,
+        )
+
+    def mutable_execution_loose_record(
+        proof: dict[str, Any],
+        *,
+        label: str,
+    ) -> dict[str, Any]:
+        inventory = proof["physical_lane_inventory"]
+        if not isinstance(inventory, dict):
+            raise ComparisonError(
+                f"{label} structural proof {relative_path} inventory is invalid"
+            )
+        matches = [
+            record
+            for record in inventory.get("loose_payloads", ())
+            if isinstance(record, dict) and record.get("path") == left_execution_path
+        ]
+        if len(matches) != 1:
+            raise ComparisonError(
+                f"{label} structural proof {relative_path} execution inventory "
+                "is ambiguous"
+            )
+        return matches[0]
+
+    left_loose = mutable_execution_loose_record(left, label="baseline")
+    right_loose = mutable_execution_loose_record(right, label="candidate")
+    for key, validator in (
+        (
+            "sha256",
+            lambda value: _sha256(
+                value,
+                description="structural-proof loose execution digest",
+            ),
+        ),
+        (
+            "size_bytes",
+            lambda value: _nonnegative_int(
+                value,
+                description="structural-proof loose execution size",
+            ),
+        ),
+    ):
+        left_value = validator(left_loose.get(key))
+        right_value = validator(right_loose.get(key))
+        _record_allowed(
+            allowed,
+            file=relative_path,
+            json_path=(
+                "/physical_lane_inventory/loose_payloads"
+                f"[path={left_execution_path}]/{key}"
+            ),
+            category="derived-execution-metadata",
+            baseline=left_value,
+            candidate=right_value,
+        )
+        left_loose[key] = _NORMALIZED
+        right_loose[key] = _NORMALIZED
+
+    def mutable_primary_lane(
+        proof: dict[str, Any],
+        *,
+        label: str,
+    ) -> dict[str, Any]:
+        inventory = proof["physical_lane_inventory"]
+        if not isinstance(inventory, dict):
+            raise ComparisonError(
+                f"{label} structural proof {relative_path} inventory is invalid"
+            )
+        matches = [
+            lane
+            for lane in inventory.get("lanes", ())
+            if isinstance(lane, dict) and lane.get("lane_id") == "primary"
+        ]
+        if len(matches) != 1:
+            raise ComparisonError(
+                f"{label} structural proof {relative_path} primary lane is ambiguous"
+            )
+        return matches[0]
+
+    left_lane = mutable_primary_lane(left, label="baseline")
+    right_lane = mutable_primary_lane(right, label="candidate")
+    left_lane_digest = _sha256(
+        left_lane.get("subtree_sha256"),
+        description="baseline structural-proof lane digest",
+    )
+    right_lane_digest = _sha256(
+        right_lane.get("subtree_sha256"),
+        description="candidate structural-proof lane digest",
+    )
+    _record_allowed(
+        allowed,
+        file=relative_path,
+        json_path="/physical_lane_inventory/lanes[id=primary]/subtree_sha256",
+        category="derived-execution-metadata",
+        baseline=left_lane_digest,
+        candidate=right_lane_digest,
+    )
+    left_lane["subtree_sha256"] = _NORMALIZED
+    right_lane["subtree_sha256"] = _NORMALIZED
+
+    for path, json_path, domain in (
+        (
+            ("physical_lane_inventory", "inventory_sha256"),
+            "/physical_lane_inventory/inventory_sha256",
+            "derived-execution-metadata",
+        ),
+        (
+            ("proof_content_sha256",),
+            "/proof_content_sha256",
+            "derived-execution-and-provenance-metadata",
+        ),
+    ):
+        _replace_pair(
+            left,
+            right,
+            path,
+            file=relative_path,
+            json_path=json_path,
+            category=domain,
+            validate=lambda value, field=json_path: _sha256(
+                value,
+                description=f"structural-proof derived digest {field}",
+            ),
+            allowed=allowed,
+        )
+    return left, right
+
+
+def _normalize_manifest_pair(
+    baseline: Mapping[str, Any],
+    candidate: Mapping[str, Any],
+    *,
+    matched_execution_paths: set[str],
+    matched_structural_proof_paths: set[str],
+    allowed: list[dict[str, object]],
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    left = copy.deepcopy(dict(baseline))
+    right = copy.deepcopy(dict(candidate))
+    scalar_fields: tuple[
+        tuple[tuple[str, ...], str, str, Callable[[object], object]], ...
+    ] = (
+        (
+            ("artifact_id",),
+            "/artifact_id",
+            "derived-identity",
+            lambda value: _sha256(value, description="artifact_id"),
+        ),
+        (
+            ("created_utc",),
+            "/created_utc",
+            "timing",
+            lambda value: _utc_timestamp(value, description="created_utc"),
+        ),
+        (
+            ("producer", "git_revision"),
+            "/producer/git_revision",
+            "provenance",
+            lambda value: (
+                value
+                if isinstance(value, str)
+                and _GIT_REVISION_RE.fullmatch(value) is not None
+                else (_raise_invalid("producer.git_revision"))
+            ),
+        ),
+        (
+            ("producer", "native_build_inputs_sha256"),
+            "/producer/native_build_inputs_sha256",
+            "provenance",
+            lambda value: _sha256(
+                value, description="producer.native_build_inputs_sha256"
+            ),
+        ),
+        (
+            ("producer", "version"),
+            "/producer/version",
+            "provenance",
+            lambda value: _nonempty_string(value, description="producer.version"),
+        ),
+        (
+            ("extensions", "generation", "phase_timings_seconds"),
+            "/extensions/generation/phase_timings_seconds",
+            "timing",
+            lambda value: dict(_timings(value, description="generation phase timings")),
+        ),
+    )
+    for path, json_path, category, validate in scalar_fields:
+        _replace_pair(
+            left,
+            right,
+            path,
+            file="artifact.json",
+            json_path=json_path,
+            category=category,
+            validate=validate,
+            allowed=allowed,
+        )
+
+    left_generation = left["extensions"]["generation"]
+    right_generation = right["extensions"]["generation"]
+    left_profiles = left_generation.get(
+        "recurrence_schedule_profiles",
+        _MISSING,
+    )
+    right_profiles = right_generation.get(
+        "recurrence_schedule_profiles",
+        _MISSING,
+    )
+    _record_allowed(
+        allowed,
+        file="artifact.json",
+        json_path="/extensions/generation/recurrence_schedule_profiles",
+        category="generation-only-telemetry",
+        baseline=left_profiles,
+        candidate=right_profiles,
+    )
+    left_generation["recurrence_schedule_profiles"] = _NORMALIZED
+    right_generation["recurrence_schedule_profiles"] = _NORMALIZED
+    left_concrete = _records_by_id(
+        left_generation.get("concrete_processes"),
+        description="baseline concrete processes",
+    )
+    right_concrete = _records_by_id(
+        right_generation.get("concrete_processes"),
+        description="candidate concrete processes",
+    )
+    for process_id in sorted(set(left_concrete) & set(right_concrete)):
+        execution_path = f"processes/{process_id}/execution.json"
+        if execution_path not in matched_execution_paths:
+            continue
+        left_record = left_concrete[process_id]
+        right_record = right_concrete[process_id]
+        left_digest = _sha256(
+            left_record.get("execution_manifest_sha256"),
+            description=f"concrete process {process_id} execution digest",
+        )
+        right_digest = _sha256(
+            right_record.get("execution_manifest_sha256"),
+            description=f"concrete process {process_id} execution digest",
+        )
+        _record_allowed(
+            allowed,
+            file="artifact.json",
+            json_path=(
+                "/extensions/generation/concrete_processes"
+                f"[id={process_id}]/execution_manifest_sha256"
+            ),
+            category="derived-execution-metadata",
+            baseline=left_digest,
+            candidate=right_digest,
+        )
+        left_record["execution_manifest_sha256"] = _NORMALIZED
+        right_record["execution_manifest_sha256"] = _NORMALIZED
+
+    left_payloads = _payload_records_by_path(left.get("payloads"), "baseline")
+    right_payloads = _payload_records_by_path(right.get("payloads"), "candidate")
+    for path in sorted(
+        matched_execution_paths & set(left_payloads) & set(right_payloads)
+    ):
+        left_record = left_payloads[path]
+        right_record = right_payloads[path]
+        for key, validator in (
+            (
+                "sha256",
+                lambda value, payload_path=path: _sha256(
+                    value, description=f"payload {payload_path}.sha256"
+                ),
+            ),
+            (
+                "size_bytes",
+                lambda value, payload_path=path: _nonnegative_int(
+                    value, description=f"payload {payload_path}.size_bytes"
+                ),
+            ),
+        ):
+            left_value = validator(left_record.get(key))
+            right_value = validator(right_record.get(key))
+            _record_allowed(
+                allowed,
+                file="artifact.json",
+                json_path=f"/payloads[path={path}]/{key}",
+                category="derived-execution-metadata",
+                baseline=left_value,
+                candidate=right_value,
+            )
+            left_record[key] = _NORMALIZED
+            right_record[key] = _NORMALIZED
+
+    for path in sorted(
+        matched_structural_proof_paths & set(left_payloads) & set(right_payloads)
+    ):
+        left_record = left_payloads[path]
+        right_record = right_payloads[path]
+        for key, validator in (
+            (
+                "sha256",
+                lambda value, payload_path=path: _sha256(
+                    value,
+                    description=f"payload {payload_path}.sha256",
+                ),
+            ),
+            (
+                "size_bytes",
+                lambda value, payload_path=path: _nonnegative_int(
+                    value,
+                    description=f"payload {payload_path}.size_bytes",
+                ),
+            ),
+        ):
+            left_value = validator(left_record.get(key))
+            right_value = validator(right_record.get(key))
+            _record_allowed(
+                allowed,
+                file="artifact.json",
+                json_path=f"/payloads[path={path}]/{key}",
+                category="derived-structural-proof-metadata",
+                baseline=left_value,
+                candidate=right_value,
+            )
+            left_record[key] = _NORMALIZED
+            right_record[key] = _NORMALIZED
+
+    return left, right
+
+
+def _raise_invalid(description: str) -> None:
+    raise ComparisonError(f"{description} is invalid")
+
+
+def _records_by_id(value: object, *, description: str) -> dict[str, dict[str, Any]]:
+    records: dict[str, dict[str, Any]] = {}
+    for index, raw_record in enumerate(_sequence(value, description=description)):
+        if not isinstance(raw_record, dict):
+            raise ComparisonError(f"{description}[{index}] must be an object")
+        process_id = _nonempty_string(
+            raw_record.get("id"), description=f"{description}[{index}].id"
+        )
+        if process_id in records:
+            raise ComparisonError(f"{description} has duplicate id {process_id}")
+        records[process_id] = raw_record
+    return records
+
+
+def _payload_records_by_path(value: object, label: str) -> dict[str, dict[str, Any]]:
+    records: dict[str, dict[str, Any]] = {}
+    description = f"{label} manifest payloads"
+    for index, raw_record in enumerate(_sequence(value, description=description)):
+        if not isinstance(raw_record, dict):
+            raise ComparisonError(f"{description}[{index}] must be an object")
+        path = _payload_relative_path(
+            raw_record.get("path"), description=f"{description}[{index}]"
+        )
+        if path in records:
+            raise ComparisonError(f"{description} has duplicate path {path}")
+        records[path] = raw_record
+    return records
+
+
+def _normalize_execution_pair(
+    baseline: Mapping[str, Any],
+    candidate: Mapping[str, Any],
+    *,
+    path: str,
+    allowed: list[dict[str, object]],
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    left = copy.deepcopy(dict(baseline))
+    right = copy.deepcopy(dict(candidate))
+    _replace_pair(
+        left,
+        right,
+        ("plan", "inspection_summary", "generation_timings_seconds"),
+        file=path,
+        json_path="/plan/inspection_summary/generation_timings_seconds",
+        category="timing",
+        validate=lambda value: dict(
+            _timings(value, description=f"{path} generation timings")
+        ),
+        allowed=allowed,
+    )
+    return left, right
+
+
+def compare_artifacts(
+    baseline_artifact: Path, candidate_artifact: Path
+) -> dict[str, object]:
+    """Authenticate and compare two recurrence artifacts."""
+
+    baseline = _load_artifact(baseline_artifact, label="baseline")
+    candidate = _load_artifact(candidate_artifact, label="candidate")
+    unknown: list[dict[str, object]] = []
+    allowed: list[dict[str, object]] = []
+    payload_comparisons: list[dict[str, object]] = []
+
+    baseline_paths = set(baseline.payloads)
+    candidate_paths = set(candidate.payloads)
+    inventories_match = baseline_paths == candidate_paths
+    for path in sorted(baseline_paths - candidate_paths):
+        unknown.append(
+            {
+                "kind": "payload-inventory",
+                "path": path,
+                "baseline": "present",
+                "candidate": "missing",
+            }
+        )
+    for path in sorted(candidate_paths - baseline_paths):
+        unknown.append(
+            {
+                "kind": "payload-inventory",
+                "path": path,
+                "baseline": "missing",
+                "candidate": "present",
+            }
+        )
+
+    common_paths = baseline_paths & candidate_paths
+    exact_payload_bytes_match = inventories_match
+    payloads_match_policy = inventories_match
+    pacbin_comparisons: dict[str, RecurrencePacbinComparison] = {}
+
+    for path in sorted(
+        set(baseline.recurrence_schedules) & set(candidate.recurrence_schedules)
+    ):
+        left = baseline.payloads[path]
+        right = candidate.payloads[path]
+        comparison = _compare_recurrence_pacbins(
+            baseline.recurrence_schedules[path],
+            candidate.recurrence_schedules[path],
+            relative_path=path,
+            unknown=unknown,
+        )
+        pacbin_comparisons[path] = comparison
+        exact_payload_bytes_match = (
+            exact_payload_bytes_match and comparison.exact_bytes_match
+        )
+        payloads_match_policy = payloads_match_policy and comparison.policy_match
+        payload_comparisons.append(
+            {
+                "path": path,
+                "comparison": "recurrence-pacbin-exact-plan-and-projection-body",
+                "baseline_sha256": left.sha256,
+                "candidate_sha256": right.sha256,
+                "byte_for_byte_match": comparison.exact_bytes_match,
+                "runtime_plan_bytes_match": comparison.plan_bytes_match,
+                "projection_certificate_body_match": (
+                    comparison.projection_certificate_bodies_match
+                ),
+                "matches_policy": comparison.policy_match,
+            }
+        )
+
+    schedule_index_differences = _json_differences(
+        baseline.schedule_index,
+        candidate.schedule_index,
+        file=_SCHEDULE_INDEX_PATH,
+    )
+    unknown.extend(schedule_index_differences)
+    left_schedule_index_payload = baseline.payloads[_SCHEDULE_INDEX_PATH]
+    right_schedule_index_payload = candidate.payloads[_SCHEDULE_INDEX_PATH]
+    schedule_index_bytes_match = (
+        left_schedule_index_payload.sha256 == right_schedule_index_payload.sha256
+        and left_schedule_index_payload.size_bytes
+        == right_schedule_index_payload.size_bytes
+        and _files_equal(
+            left_schedule_index_payload.path,
+            right_schedule_index_payload.path,
+        )
+    )
+    if not schedule_index_bytes_match:
+        unknown.append(
+            {
+                "kind": "payload-bytes",
+                "path": _SCHEDULE_INDEX_PATH,
+                "baseline": {
+                    "sha256": left_schedule_index_payload.sha256,
+                    "size_bytes": left_schedule_index_payload.size_bytes,
+                },
+                "candidate": {
+                    "sha256": right_schedule_index_payload.sha256,
+                    "size_bytes": right_schedule_index_payload.size_bytes,
+                },
+            }
+        )
+    schedule_index_matches = (
+        schedule_index_bytes_match and not schedule_index_differences
+    )
+    exact_payload_bytes_match = exact_payload_bytes_match and schedule_index_bytes_match
+    payloads_match_policy = payloads_match_policy and schedule_index_matches
+    payload_comparisons.append(
+        {
+            "path": _SCHEDULE_INDEX_PATH,
+            "comparison": "byte-for-byte",
+            "baseline_sha256": left_schedule_index_payload.sha256,
+            "candidate_sha256": right_schedule_index_payload.sha256,
+            "byte_for_byte_match": schedule_index_bytes_match,
+            "matches": schedule_index_matches,
+        }
+    )
+
+    matched_execution_paths: set[str] = set()
+    normalized_execution_pairs: dict[str, tuple[dict[str, Any], dict[str, Any]]] = {}
+    for path in sorted(set(baseline.executions) & set(candidate.executions)):
+        left_payload = baseline.payloads[path]
+        right_payload = candidate.payloads[path]
+        execution_bytes_match = (
+            left_payload.sha256 == right_payload.sha256
+            and left_payload.size_bytes == right_payload.size_bytes
+            and _files_equal(left_payload.path, right_payload.path)
+        )
+        exact_payload_bytes_match = exact_payload_bytes_match and execution_bytes_match
+        left_json, right_json = _normalize_execution_pair(
+            baseline.executions[path],
+            candidate.executions[path],
+            path=path,
+            allowed=allowed,
+        )
+        differences = _json_differences(left_json, right_json, file=path)
+        unknown.extend(differences)
+        execution_matches = not differences
+        payloads_match_policy = payloads_match_policy and execution_matches
+        if execution_matches:
+            matched_execution_paths.add(path)
+            normalized_execution_pairs[path] = (left_json, right_json)
+        payload_comparisons.append(
+            {
+                "path": path,
+                "comparison": "json-exact-except-timing",
+                "baseline_sha256": left_payload.sha256,
+                "candidate_sha256": right_payload.sha256,
+                "byte_for_byte_match": execution_bytes_match,
+                "normalized_match": execution_matches,
+            }
+        )
+
+    matched_structural_proof_paths: set[str] = set()
+    baseline_structural_proofs = {
+        path for path in baseline.payloads if _STRUCTURAL_PROOF_PATH_RE.fullmatch(path)
+    }
+    candidate_structural_proofs = {
+        path for path in candidate.payloads if _STRUCTURAL_PROOF_PATH_RE.fullmatch(path)
+    }
+    for path in sorted(baseline_structural_proofs & candidate_structural_proofs):
+        left_payload = baseline.payloads[path]
+        right_payload = candidate.payloads[path]
+        proof_bytes_match = (
+            left_payload.sha256 == right_payload.sha256
+            and left_payload.size_bytes == right_payload.size_bytes
+            and _files_equal(left_payload.path, right_payload.path)
+        )
+        exact_payload_bytes_match = exact_payload_bytes_match and proof_bytes_match
+        left_proof = _json_object(
+            left_payload.path,
+            description="baseline recurrence structural source proof",
+        )
+        right_proof = _json_object(
+            right_payload.path,
+            description="candidate recurrence structural source proof",
+        )
+        left_execution_path, _ = _validate_structural_proof(
+            baseline,
+            left_proof,
+            relative_path=path,
+            label="baseline",
+        )
+        right_execution_path, _ = _validate_structural_proof(
+            candidate,
+            right_proof,
+            relative_path=path,
+            label="candidate",
+        )
+        execution_pair = normalized_execution_pairs.get(left_execution_path)
+        if left_execution_path == right_execution_path and execution_pair is not None:
+            left_normalized, right_normalized = _normalize_structural_proof_pair(
+                baseline,
+                candidate,
+                left_proof,
+                right_proof,
+                relative_path=path,
+                baseline_execution=execution_pair[0],
+                candidate_execution=execution_pair[1],
+                allowed=allowed,
+            )
+        else:
+            left_normalized = left_proof
+            right_normalized = right_proof
+        differences = _json_differences(
+            left_normalized,
+            right_normalized,
+            file=path,
+        )
+        unknown.extend(differences)
+        proof_matches = not differences
+        payloads_match_policy = payloads_match_policy and proof_matches
+        if proof_matches:
+            matched_structural_proof_paths.add(path)
+        payload_comparisons.append(
+            {
+                "path": path,
+                "comparison": (
+                    "json-exact-except-authenticated-provenance-and-"
+                    "derived-execution-metadata"
+                ),
+                "baseline_sha256": left_payload.sha256,
+                "candidate_sha256": right_payload.sha256,
+                "byte_for_byte_match": proof_bytes_match,
+                "normalized_match": proof_matches,
+            }
+        )
+
+    special_paths = {
+        *baseline.recurrence_schedules,
+        *candidate.recurrence_schedules,
+        _SCHEDULE_INDEX_PATH,
+        *baseline.executions,
+        *candidate.executions,
+        *baseline_structural_proofs,
+        *candidate_structural_proofs,
+    }
+    for path in sorted(common_paths - special_paths):
+        left = baseline.payloads[path]
+        right = candidate.payloads[path]
+        bytes_match = (
+            left.sha256 == right.sha256
+            and left.size_bytes == right.size_bytes
+            and _files_equal(left.path, right.path)
+        )
+        exact_payload_bytes_match = exact_payload_bytes_match and bytes_match
+        payloads_match_policy = payloads_match_policy and bytes_match
+        if not bytes_match:
+            unknown.append(
+                {
+                    "kind": "payload-bytes",
+                    "path": path,
+                    "baseline": {
+                        "sha256": left.sha256,
+                        "size_bytes": left.size_bytes,
+                    },
+                    "candidate": {
+                        "sha256": right.sha256,
+                        "size_bytes": right.size_bytes,
+                    },
+                }
+            )
+        payload_comparisons.append(
+            {
+                "path": path,
+                "comparison": "byte-for-byte",
+                "baseline_sha256": left.sha256,
+                "candidate_sha256": right.sha256,
+                "size_bytes": left.size_bytes if bytes_match else None,
+                "matches": bytes_match,
+            }
+        )
+
+    left_manifest, right_manifest = _normalize_manifest_pair(
+        baseline.manifest,
+        candidate.manifest,
+        matched_execution_paths=matched_execution_paths,
+        matched_structural_proof_paths=matched_structural_proof_paths,
+        allowed=allowed,
+    )
+    manifest_differences = _json_differences(
+        left_manifest, right_manifest, file="artifact.json"
+    )
+    unknown.extend(manifest_differences)
+
+    unknown_count = len(unknown)
+    report_unknown = unknown[:MAX_REPORTED_UNKNOWN_DIFFERENCES]
+    execution_metadata_match = not any(
+        difference.get("file", "").startswith("processes/")
+        for difference in unknown
+        if isinstance(difference.get("file"), str)
+    )
+    manifest_metadata_match = not manifest_differences
+    runtime_plans_match = set(baseline.recurrence_schedules) == set(
+        candidate.recurrence_schedules
+    ) and all(item.plan_bytes_match for item in pacbin_comparisons.values())
+    projection_certificate_bodies_match = set(baseline.recurrence_schedules) == set(
+        candidate.recurrence_schedules
+    ) and all(
+        item.projection_certificate_bodies_match for item in pacbin_comparisons.values()
+    )
+    passes = (
+        inventories_match
+        and payloads_match_policy
+        and execution_metadata_match
+        and manifest_metadata_match
+        and runtime_plans_match
+        and projection_certificate_bodies_match
+        and unknown_count == 0
+    )
+    return {
+        "kind": COMPARISON_KIND,
+        "schema_version": COMPARISON_SCHEMA_VERSION,
+        "passes": passes,
+        "baseline": {
+            "path": str(baseline.root),
+            "artifact_id": baseline.manifest["artifact_id"],
+            "manifest_sha256": baseline.manifest_sha256,
+            "payload_count": len(baseline.payloads),
+        },
+        "candidate": {
+            "path": str(candidate.root),
+            "artifact_id": candidate.manifest["artifact_id"],
+            "manifest_sha256": candidate.manifest_sha256,
+            "payload_count": len(candidate.payloads),
+        },
+        "policy": {
+            "ordinary_payloads": "byte-for-byte-and-sha256-v1",
+            "recurrence_runtime_pacbins": "exact-plan-and-projection-body-v1",
+            "schedule_index": "exact-v1",
+            "artifact_manifest": "exact-except-enumerated-metadata-v2",
+            "execution_manifests": "exact-except-generation-timings-v2",
+            "structural_source_proofs": (
+                "exact-except-authenticated-provenance-and-derived-execution-"
+                "metadata-v1"
+            ),
+            "artifact_allowed_metadata_paths": list(ARTIFACT_ALLOWED_METADATA_PATHS),
+            "execution_allowed_metadata_paths": list(EXECUTION_ALLOWED_METADATA_PATHS),
+            "structural_proof_allowed_metadata_paths": list(
+                STRUCTURAL_PROOF_ALLOWED_METADATA_PATHS
+            ),
+        },
+        "summary": {
+            "payload_inventories_match": inventories_match,
+            "exact_payload_bytes_match": exact_payload_bytes_match,
+            "payloads_match_policy": payloads_match_policy,
+            "execution_semantics_match": execution_metadata_match,
+            "manifest_semantics_match": manifest_metadata_match,
+            "runtime_schedule_plan_bytes_match": runtime_plans_match,
+            "projection_certificate_semantic_bodies_match": (
+                projection_certificate_bodies_match
+            ),
+            "runtime_bearing_payloads_match": passes,
+        },
+        "payload_comparisons": payload_comparisons,
+        "allowed_metadata_difference_count": len(allowed),
+        "allowed_metadata_differences": allowed,
+        "unknown_difference_count": unknown_count,
+        "unknown_differences_truncated": unknown_count > len(report_unknown),
+        "unknown_differences": report_unknown,
+    }
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--baseline", type=Path, required=True)
+    result.add_argument("--candidate", type=Path, required=True)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    try:
+        report = compare_artifacts(arguments.baseline, arguments.candidate)
+    except ComparisonError as error:
+        print(f"recurrence-artifact-compare: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(report, indent=2, sort_keys=True, allow_nan=False))
+    return 0 if report["passes"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/recurrence_generation_ab_ladder.py b/pyamplicol/tools/developer/recurrence_generation_ab_ladder.py
new file mode 100644
index 0000000000..4e2c532ddc
--- /dev/null
+++ b/pyamplicol/tools/developer/recurrence_generation_ab_ladder.py
@@ -0,0 +1,1855 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run the guarded recurrence-generation baseline/candidate ladder.
+
+This developer-only orchestrator deliberately delegates artifact generation
+and runtime validation to ``recurrence_z6g_benchmark.py``.  Every scheduled
+baseline/candidate capture is a separate process-tree invocation of
+``memory_watchdog.py --limit-gib 30`` with unique output, temporary, bytecode,
+and XDG cache roots.
+
+The default generation ladder covers n=2 through n=9 for both LC layouts with
+three repetitions.  Baseline-first and candidate-first pairs alternate.  Add
+``--runtime-n 6 --runtime-n 7`` to perform the approved runtime validation
+cells with the harness defaults made explicit here: batches 1/128/1024,
+seven subprocesses, seven native blocks, two warm-ups, and a five-second
+measurement target.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import hashlib
+import json
+import math
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+ALLOWED_OUTPUT_PARENT = ROOT / ".artifacts" / "recurrence-generation-opt"
+CAMPAIGN_PARENT = ALLOWED_OUTPUT_PARENT / "benchmark-campaigns"
+HARNESS_RELATIVE_PATH = Path("tools/developer/recurrence_z6g_benchmark.py")
+WATCHDOG_RELATIVE_PATH = Path("tools/ci/memory_watchdog.py")
+HARNESS_SOURCE_CHECKOUT_ENV = "PYAMPLICOL_RECURRENCE_Z6G_SOURCE_CHECKOUT"
+
+CAMPAIGN_KIND = "pyamplicol-recurrence-generation-ab-ladder"
+CAMPAIGN_SCHEMA_VERSION = 1
+HARNESS_KIND = "pyamplicol-recurrence-z6g-benchmark"
+HARNESS_SCHEMA_VERSION = 6
+EXECUTION_KIND = "pyamplicol-runtime-recurrence-execution"
+EXECUTION_SCHEMA_VERSION = 3
+RUNTIME_ACCEPTANCE_KIND = "pyamplicol-recurrence-runtime-acceptance"
+RUNTIME_ACCEPTANCE_SCHEMA_VERSION = 1
+
+LAYOUTS = ("topology-replay", "all-flow-union")
+DEFAULT_MULTIPLICITIES = tuple(range(2, 10))
+DEFAULT_BATCH_SIZES = (1, 128, 1024)
+WATCHDOG_LIMIT_GIB = 30.0
+GIB = 1024**3
+
+_CAMPAIGN_ID_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}")
+_SHA256_RE = re.compile(r"[0-9a-f]{64}")
+_WATCHDOG_FINISHED_RE = re.compile(
+    r"memory-watchdog: command finished"
+    r" exit=(?P<exit>\d+)"
+    r" peak_rss=(?P<rss>\d+(?:[.]\d+)?) GiB"
+    r" peak_physical_footprint="
+    r"(?P<physical>unavailable|\d+(?:[.]\d+)? GiB)"
+    r" peak_guard=(?P<guard>\d+(?:[.]\d+)?) GiB"
+    r" peak_processes=(?P<processes>\d+)"
+)
+_WATCHDOG_LIMIT_RE = re.compile(
+    r"memory-watchdog: memory limit exceeded"
+    r" reason=(?P<reason>[^ ]+)"
+    r" observed=(?P<observed>\d+(?:[.]\d+)?) GiB"
+    r" limit=(?P<limit>\d+(?:[.]\d+)?) GiB"
+    r" rss=(?P<rss>\d+(?:[.]\d+)?) GiB"
+    r" physical_footprint="
+    r"(?P<physical>unavailable|\d+(?:[.]\d+)? GiB)"
+    r" processes=(?P<processes>\d+);"
+)
+_HARNESS_GENERATION_TIMEOUT_RE = re.compile(
+    r"^recurrence-z6g-benchmark: recurrence generation worker exceeded "
+    r"(?P<seconds>\d+(?:[.]\d+)?) seconds$",
+    re.MULTILINE,
+)
+
+
+class LadderError(RuntimeError):
+    """Raised when a campaign or one of its captured results is invalid."""
+
+
+@dataclass(frozen=True, slots=True)
+class Variant:
+    """One independently installed baseline or candidate environment."""
+
+    name: str
+    checkout: Path
+    python: Path
+    pythonpath: Path | None = None
+    prepared_model: Path | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class SampleSpec:
+    """One outer watchdog-guarded harness capture."""
+
+    sequence_index: int
+    pair_index: int
+    order_in_pair: int
+    repetition: int
+    multiplicity: int
+    layout: str
+    variant_name: str
+    runtime_enabled: bool
+
+    @property
+    def process_expression(self) -> str:
+        return process_expression(self.multiplicity)
+
+    @property
+    def sample_id(self) -> str:
+        layout = self.layout.replace("-", "_")
+        return (
+            f"{self.sequence_index:04d}-p{self.pair_index:03d}"
+            f"-r{self.repetition + 1:02d}-{self.variant_name}"
+            f"-n{self.multiplicity:02d}-{layout}"
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class RunnerSettings:
+    """Stable harness settings shared by every campaign sample."""
+
+    validation_samples: int = 10
+    point_tile_size: int = 1024
+    jit_optimization_level: int = 2
+    profile_timeout_seconds: float = 300.0
+    minimum_samples: int = 7
+    subprocess_samples: int = 7
+    warmup_runs: int = 2
+    target_runtime_seconds: float = 5.0
+    batch_sizes: tuple[int, ...] = DEFAULT_BATCH_SIZES
+    allow_diagnostic_incomplete_success: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessOutcome:
+    """Minimal outcome of an outer watchdog process."""
+
+    exit_code: int | None
+    timed_out: bool
+    wall_seconds: float
+    error: str | None
+
+
+def _utc_now() -> str:
+    return dt.datetime.now(dt.UTC).isoformat().replace("+00:00", "Z")
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return parsed
+
+
+def _nonnegative_int(value: str) -> int:
+    parsed = int(value)
+    if parsed < 0:
+        raise argparse.ArgumentTypeError("must be a nonnegative integer")
+    return parsed
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0.0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return parsed
+
+
+def process_expression(multiplicity: int) -> str:
+    """Return exactly ``d d~ > Z + (n-1)*g`` in CLI process syntax."""
+
+    if isinstance(multiplicity, bool) or multiplicity < 1:
+        raise LadderError("process multiplicity n must be a positive integer")
+    return " ".join(("d", "d~", ">", "Z", *(("g",) * (multiplicity - 1))))
+
+
+def generation_timeout_seconds(multiplicity: int, layout: str) -> float:
+    """Return the approved per-cell generation timeout."""
+
+    if layout not in LAYOUTS:
+        raise LadderError(f"unsupported LC flow layout: {layout}")
+    if multiplicity < 1:
+        raise LadderError("process multiplicity n must be positive")
+    if multiplicity <= 4:
+        return 5.0 * 60.0
+    if multiplicity <= 7:
+        return 15.0 * 60.0
+    if multiplicity == 8:
+        return (1.0 if layout == "topology-replay" else 2.0) * 60.0 * 60.0
+    if multiplicity == 9:
+        return (2.0 if layout == "topology-replay" else 6.0) * 60.0 * 60.0
+    raise LadderError(
+        "the approved timeout policy covers only process multiplicities n=1..9"
+    )
+
+
+def _outer_timeout_seconds(
+    spec: SampleSpec,
+    settings: RunnerSettings,
+) -> float:
+    generation = generation_timeout_seconds(spec.multiplicity, spec.layout)
+    if not spec.runtime_enabled:
+        return generation + 120.0
+    profile_budget = (
+        settings.profile_timeout_seconds
+        * settings.subprocess_samples
+        * len(settings.batch_sizes)
+    )
+    return generation + profile_budget + 300.0
+
+
+def build_schedule(
+    multiplicities: Sequence[int],
+    layouts: Sequence[str],
+    repetitions: int,
+    runtime_multiplicities: frozenset[int],
+) -> list[SampleSpec]:
+    """Build deterministic pairs with alternating A/B order."""
+
+    if repetitions <= 0:
+        raise LadderError("repetitions must be positive")
+    normalized_multiplicities = tuple(dict.fromkeys(multiplicities))
+    normalized_layouts = tuple(dict.fromkeys(layouts))
+    if not normalized_multiplicities:
+        raise LadderError("at least one process multiplicity is required")
+    if not normalized_layouts:
+        raise LadderError("at least one flow layout is required")
+    for multiplicity in normalized_multiplicities:
+        generation_timeout_seconds(multiplicity, "topology-replay")
+    for layout in normalized_layouts:
+        if layout not in LAYOUTS:
+            raise LadderError(f"unsupported LC flow layout: {layout}")
+    if not runtime_multiplicities.issubset(normalized_multiplicities):
+        raise LadderError("--runtime-n values must also be selected with --n")
+
+    schedule: list[SampleSpec] = []
+    pair_index = 0
+    sequence_index = 0
+    for multiplicity in normalized_multiplicities:
+        for layout in normalized_layouts:
+            for repetition in range(repetitions):
+                order = (
+                    ("baseline", "candidate")
+                    if pair_index % 2 == 0
+                    else ("candidate", "baseline")
+                )
+                for order_in_pair, variant_name in enumerate(order):
+                    schedule.append(
+                        SampleSpec(
+                            sequence_index=sequence_index,
+                            pair_index=pair_index,
+                            order_in_pair=order_in_pair,
+                            repetition=repetition,
+                            multiplicity=multiplicity,
+                            layout=layout,
+                            variant_name=variant_name,
+                            runtime_enabled=(multiplicity in runtime_multiplicities),
+                        )
+                    )
+                    sequence_index += 1
+                pair_index += 1
+    return schedule
+
+
+def build_sample_command(
+    spec: SampleSpec,
+    variant: Variant,
+    sample_root: Path,
+    settings: RunnerSettings,
+) -> list[str]:
+    """Construct the exact watchdog and harness command for one sample."""
+
+    # The guard is measurement infrastructure, not part of either measured
+    # runtime.  Use the audited watchdog from the campaign checkout for both
+    # variants so a frozen baseline remains pristine and benefits from
+    # fail-closed platform fixes made after that baseline was captured.
+    watchdog = ROOT / WATCHDOG_RELATIVE_PATH
+    harness = ROOT / HARNESS_RELATIVE_PATH
+    harness_output = sample_root / "harness"
+    result_json = sample_root / "harness-result.json"
+    generation_timeout = generation_timeout_seconds(
+        spec.multiplicity,
+        spec.layout,
+    )
+    harness_command = [
+        str(variant.python),
+        str(harness),
+        "--output-root",
+        str(harness_output),
+        "--result-json",
+        str(result_json),
+        "--gluon-count",
+        str(max(1, spec.multiplicity - 1)),
+        "--process-expression",
+        spec.process_expression,
+        "--validation-samples",
+        str(settings.validation_samples),
+        "--point-tile-size",
+        str(settings.point_tile_size),
+        "--jit-optimization-level",
+        str(settings.jit_optimization_level),
+        "--mode",
+        "recurrence",
+        "--lc-flow-layout",
+        spec.layout,
+        "--generation-timeout",
+        f"{generation_timeout:g}",
+        "--profile-timeout",
+        f"{settings.profile_timeout_seconds:g}",
+        "--minimum-samples",
+        str(settings.minimum_samples),
+        "--subprocess-samples",
+        str(settings.subprocess_samples),
+        "--warmup-runs",
+        str(settings.warmup_runs),
+        "--target-runtime",
+        f"{settings.target_runtime_seconds:g}",
+    ]
+    if settings.allow_diagnostic_incomplete_success:
+        harness_command.append("--allow-diagnostic-incomplete-success")
+    if variant.prepared_model is not None:
+        harness_command.extend(("--prepared-model", str(variant.prepared_model)))
+    if spec.runtime_enabled:
+        for batch_size in settings.batch_sizes:
+            harness_command.extend(("--batch-size", str(batch_size)))
+    else:
+        harness_command.append("--generation-only")
+
+    return [
+        str(variant.python),
+        str(watchdog),
+        "--limit-gib",
+        f"{WATCHDOG_LIMIT_GIB:g}",
+        "--",
+        *harness_command,
+    ]
+
+
+def _sample_environment(
+    variant: Variant,
+    sample_root: Path,
+) -> tuple[dict[str, str], dict[str, str]]:
+    cache_root = sample_root / "cold-cache"
+    temporary_root = sample_root / "tmp"
+    pycache_root = sample_root / "pycache"
+    matplotlib_root = cache_root / "matplotlib"
+    for path in (cache_root, temporary_root, pycache_root, matplotlib_root):
+        path.mkdir(parents=True, exist_ok=False)
+
+    overrides = {
+        HARNESS_SOURCE_CHECKOUT_ENV: str(variant.checkout),
+        "MPLCONFIGDIR": str(matplotlib_root),
+        "PYTHONHASHSEED": "0",
+        "PYTHONNOUSERSITE": "1",
+        "PYTHONPYCACHEPREFIX": str(pycache_root),
+        "SYMBOLICA_HIDE_BANNER": "1",
+        "TEMP": str(temporary_root),
+        "TMP": str(temporary_root),
+        "TMPDIR": str(temporary_root),
+        "XDG_CACHE_HOME": str(cache_root),
+    }
+    environment = os.environ.copy()
+    environment.update(overrides)
+    if variant.pythonpath is None:
+        environment.pop("PYTHONPATH", None)
+    else:
+        overrides["PYTHONPATH"] = str(variant.pythonpath)
+        environment["PYTHONPATH"] = str(variant.pythonpath)
+    return environment, overrides
+
+
+def _terminate_process_tree(process: subprocess.Popen[bytes]) -> None:
+    if process.poll() is not None:
+        return
+    if os.name == "posix":
+        try:
+            os.killpg(process.pid, signal.SIGTERM)
+        except ProcessLookupError:
+            return
+    else:
+        process.terminate()
+    try:
+        process.wait(timeout=5.0)
+        return
+    except subprocess.TimeoutExpired:
+        pass
+    if os.name == "posix":
+        try:
+            os.killpg(process.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            return
+    else:
+        process.kill()
+    process.wait()
+
+
+def _run_process(
+    command: Sequence[str],
+    *,
+    cwd: Path,
+    environment: Mapping[str, str],
+    stdout_path: Path,
+    stderr_path: Path,
+    timeout_seconds: float,
+) -> ProcessOutcome:
+    started = time.perf_counter()
+    process: subprocess.Popen[bytes] | None = None
+    try:
+        with stdout_path.open("wb") as stdout, stderr_path.open("wb") as stderr:
+            process = subprocess.Popen(
+                list(command),
+                cwd=cwd,
+                env=dict(environment),
+                stdout=stdout,
+                stderr=stderr,
+                start_new_session=(os.name == "posix"),
+            )
+            try:
+                exit_code = process.wait(timeout=timeout_seconds)
+            except subprocess.TimeoutExpired:
+                _terminate_process_tree(process)
+                return ProcessOutcome(
+                    exit_code=None,
+                    timed_out=True,
+                    wall_seconds=time.perf_counter() - started,
+                    error=f"outer sample timeout after {timeout_seconds:g} seconds",
+                )
+    except OSError as error:
+        if process is not None:
+            _terminate_process_tree(process)
+        return ProcessOutcome(
+            exit_code=None,
+            timed_out=False,
+            wall_seconds=time.perf_counter() - started,
+            error=f"{type(error).__name__}: {error}",
+        )
+    return ProcessOutcome(
+        exit_code=exit_code,
+        timed_out=False,
+        wall_seconds=time.perf_counter() - started,
+        error=None,
+    )
+
+
+def _gib_value(text: str) -> dict[str, float | int]:
+    gib = float(text.removesuffix(" GiB"))
+    return {
+        "gib": gib,
+        "bytes_rounded_from_watchdog": round(gib * GIB),
+    }
+
+
+def parse_watchdog_text(text: str) -> dict[str, Any]:
+    """Extract the watchdog's terminal process-tree memory observation."""
+
+    finished = list(_WATCHDOG_FINISHED_RE.finditer(text))
+    exceeded = list(_WATCHDOG_LIMIT_RE.finditer(text))
+    if finished:
+        match = finished[-1]
+        physical = match.group("physical")
+        return {
+            "terminal_record": "command-finished",
+            "limit_gib": WATCHDOG_LIMIT_GIB,
+            "limit_exceeded": False,
+            "child_exit_code": int(match.group("exit")),
+            "peak_rss": _gib_value(match.group("rss")),
+            "peak_physical_footprint": (
+                None if physical == "unavailable" else _gib_value(physical)
+            ),
+            "peak_guard": _gib_value(match.group("guard")),
+            "peak_process_count": int(match.group("processes")),
+        }
+    if exceeded:
+        match = exceeded[-1]
+        physical = match.group("physical")
+        return {
+            "terminal_record": "memory-limit-exceeded",
+            "limit_gib": float(match.group("limit")),
+            "limit_exceeded": True,
+            "reason": match.group("reason"),
+            "observed_guard": _gib_value(match.group("observed")),
+            "rss_at_limit": _gib_value(match.group("rss")),
+            "physical_footprint_at_limit": (
+                None if physical == "unavailable" else _gib_value(physical)
+            ),
+            "process_count_at_limit": int(match.group("processes")),
+        }
+    return {
+        "terminal_record": None,
+        "limit_gib": WATCHDOG_LIMIT_GIB,
+        "limit_exceeded": None,
+    }
+
+
+def parse_watchdog_log(path: Path) -> dict[str, Any]:
+    """Parse at most the final MiB of a potentially large stderr log."""
+
+    try:
+        with path.open("rb") as stream:
+            size = path.stat().st_size
+            stream.seek(max(0, size - 1024 * 1024))
+            raw = stream.read()
+    except OSError as error:
+        raise LadderError(f"cannot read watchdog stderr log: {path}") from error
+    return parse_watchdog_text(raw.decode("utf-8", errors="replace"))
+
+
+def parse_harness_generation_timeout(path: Path) -> dict[str, float] | None:
+    """Return an exact inner generation-timeout record, if present."""
+
+    try:
+        with path.open("rb") as stream:
+            size = path.stat().st_size
+            stream.seek(max(0, size - 1024 * 1024))
+            raw = stream.read()
+    except OSError as error:
+        raise LadderError(f"cannot read harness stderr log: {path}") from error
+    text = raw.decode("utf-8", errors="replace")
+    matches = tuple(_HARNESS_GENERATION_TIMEOUT_RE.finditer(text))
+    if not matches:
+        return None
+    if len(matches) != 1:
+        raise LadderError("harness stderr contains multiple generation timeouts")
+    return {"configured_seconds": float(matches[0].group("seconds"))}
+
+
+def _json_object(path: Path, *, description: str) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise LadderError(f"invalid {description}: {path}") from error
+    if not isinstance(value, dict):
+        raise LadderError(f"{description} must be a JSON object: {path}")
+    return value
+
+
+def _required_mapping(
+    value: object,
+    *,
+    description: str,
+) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise LadderError(f"{description} must be a JSON object")
+    return value
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    try:
+        with path.open("rb") as stream:
+            for block in iter(lambda: stream.read(1024 * 1024), b""):
+                digest.update(block)
+    except OSError as error:
+        raise LadderError(f"cannot hash result file: {path}") from error
+    return digest.hexdigest()
+
+
+def _canonical_sha256(value: object) -> str:
+    encoded = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _positive_finite_number(value: object) -> bool:
+    return (
+        not isinstance(value, bool)
+        and isinstance(value, (float, int))
+        and math.isfinite(float(value))
+        and float(value) > 0.0
+    )
+
+
+def _verify_artifact_payload_inventory(
+    artifact: Path,
+    artifact_identity: Mapping[str, Any],
+) -> dict[str, int]:
+    """Authenticate every payload used by a generation-only capture."""
+
+    identity_path = artifact_identity.get("path")
+    if not isinstance(identity_path, str) or Path(identity_path).resolve() != artifact:
+        raise LadderError("generation artifact identity path does not match")
+    manifest_identity = _required_mapping(
+        artifact_identity.get("manifest"),
+        description="generation artifact manifest identity",
+    )
+    manifest_path = artifact / "artifact.json"
+    recorded_manifest_path = manifest_identity.get("resolved_path")
+    if (
+        not isinstance(recorded_manifest_path, str)
+        or Path(recorded_manifest_path).resolve() != manifest_path
+        or manifest_identity.get("sha256") != _sha256_file(manifest_path)
+        or manifest_identity.get("size_bytes") != manifest_path.stat().st_size
+    ):
+        raise LadderError("generation artifact manifest identity does not match")
+    manifest = _json_object(
+        manifest_path,
+        description="generation artifact manifest",
+    )
+    if manifest.get("artifact_id") != artifact_identity.get("artifact_id"):
+        raise LadderError("generation artifact ID does not match its manifest")
+    raw_payloads = manifest.get("payloads")
+    identity_payloads = artifact_identity.get("payloads")
+    if not isinstance(raw_payloads, list) or not isinstance(identity_payloads, list):
+        raise LadderError("generation artifact payload inventories do not match")
+    identity_by_path: dict[str, Mapping[str, Any]] = {}
+    for raw_identity_entry in identity_payloads:
+        identity_entry = _required_mapping(
+            raw_identity_entry,
+            description="generation artifact identity payload entry",
+        )
+        identity_relative = identity_entry.get("path")
+        if (
+            not isinstance(identity_relative, str)
+            or not identity_relative
+            or identity_relative in identity_by_path
+        ):
+            raise LadderError("generation artifact identity payload entry is invalid")
+        identity_by_path[identity_relative] = identity_entry
+    if len(identity_by_path) != len(raw_payloads):
+        raise LadderError("generation artifact payload inventories do not match")
+    root = artifact.resolve()
+    total_bytes = 0
+    seen_paths: set[str] = set()
+    for raw_entry in raw_payloads:
+        entry = _required_mapping(
+            raw_entry,
+            description="generation artifact payload entry",
+        )
+        relative = entry.get("path")
+        expected_sha256 = entry.get("sha256")
+        expected_size = entry.get("size_bytes")
+        if (
+            not isinstance(relative, str)
+            or not relative
+            or relative in seen_paths
+            or not isinstance(expected_sha256, str)
+            or _SHA256_RE.fullmatch(expected_sha256) is None
+            or isinstance(expected_size, bool)
+            or not isinstance(expected_size, int)
+            or expected_size < 0
+        ):
+            raise LadderError("generation artifact payload entry is invalid")
+        seen_paths.add(relative)
+        identity_entry = identity_by_path.get(relative)
+        if identity_entry is None or any(
+            identity_entry.get(key) != entry.get(key)
+            for key in ("path", "role", "sha256", "size_bytes")
+        ):
+            raise LadderError("generation artifact payload inventories do not match")
+        if identity_entry.get("process_id") != entry.get("process_id"):
+            raise LadderError("generation artifact payload inventories do not match")
+        try:
+            payload_path = (artifact / relative).resolve(strict=True)
+            payload_path.relative_to(root)
+        except (OSError, ValueError) as error:
+            raise LadderError(
+                f"generation artifact payload escapes or is missing: {relative!r}"
+            ) from error
+        if (
+            not payload_path.is_file()
+            or payload_path.stat().st_size != expected_size
+            or _sha256_file(payload_path) != expected_sha256
+        ):
+            raise LadderError(
+                f"generation artifact payload identity differs: {relative!r}"
+            )
+        total_bytes += expected_size
+    return {
+        "payload_count": len(raw_payloads),
+        "payload_bytes": total_bytes,
+    }
+
+
+def _generation_only_acceptance(
+    result: Mapping[str, Any],
+    recurrence: Mapping[str, Any],
+    *,
+    artifact: Path,
+) -> dict[str, Any] | None:
+    """Validate a recurrence generation capture independently of runtime lanes."""
+
+    configuration = _required_mapping(
+        result.get("configuration"),
+        description="benchmark configuration",
+    )
+    if configuration.get("generation_only") is not True:
+        return None
+    if result.get("profiles") != {}:
+        raise LadderError("generation-only benchmark unexpectedly contains profiles")
+    if recurrence.get("mode") != "recurrence":
+        raise LadderError("generation-only capture is not recurrence mode")
+    if recurrence.get("generation_reused") is not False:
+        raise LadderError("generation-only capture did not use a cold generation")
+    if not _positive_finite_number(recurrence.get("generation_wall_seconds")):
+        raise LadderError("generation-only capture has invalid wall timing")
+
+    signature = _required_mapping(
+        recurrence.get("semantic_generation_signature"),
+        description="semantic generation signature",
+    )
+    signature_sha256 = recurrence.get("semantic_generation_signature_sha256")
+    validation = _required_mapping(
+        signature.get("validation"),
+        description="generation validation contract",
+    )
+    configured_samples = configuration.get("validation_samples")
+    if (
+        signature.get("kind") != "pyamplicol-benchmark-generation-signature"
+        or signature.get("schema_version") != 1
+        or signature.get("mode") != "recurrence"
+        or signature.get("lc_flow_layout") != configuration.get("lc_flow_layout")
+        or signature_sha256 != _canonical_sha256(signature)
+        or validation.get("enabled") is not True
+        or validation.get("post_build_validation") is not True
+        or isinstance(configured_samples, bool)
+        or not isinstance(configured_samples, int)
+        or configured_samples <= 0
+        or validation.get("samples") != configured_samples
+    ):
+        raise LadderError("generation validation signature is incomplete")
+
+    semantic_identity = _required_mapping(
+        recurrence.get("artifact_semantic_identity"),
+        description="artifact semantic identity",
+    )
+    coverage = _required_mapping(
+        semantic_identity.get("coverage"),
+        description="artifact semantic coverage",
+    )
+    reduction_coverage = _required_mapping(
+        semantic_identity.get("execution_reduction_coverage"),
+        description="artifact reduction coverage",
+    )
+    if (
+        recurrence.get("artifact_semantic_identity_sha256")
+        != _canonical_sha256(semantic_identity)
+        or coverage.get("complete_physical_axes") is not True
+        or coverage.get("color") != "complete"
+        or coverage.get("helicities") != "complete"
+        or reduction_coverage.get("complete") is not True
+        or reduction_coverage.get("errors") != []
+    ):
+        raise LadderError("generation artifact semantic coverage is incomplete")
+
+    worker_evidence = _required_mapping(
+        recurrence.get("generation_worker_result_evidence"),
+        description="generation worker evidence",
+    )
+    evidence_without_digest = dict(worker_evidence)
+    evidence_sha256 = evidence_without_digest.pop("content_sha256", None)
+    worker_payload = _required_mapping(
+        worker_evidence.get("payload"),
+        description="generation worker evidence payload",
+    )
+    if (
+        worker_evidence.get("kind") != "pyamplicol-preserved-worker-result-evidence"
+        or worker_evidence.get("schema_version") != 1
+        or evidence_sha256 != _canonical_sha256(evidence_without_digest)
+        or worker_payload.get("mode") != "recurrence"
+        or worker_payload.get("generation_reused") is not False
+        or worker_payload.get("generation_wall_seconds")
+        != recurrence.get("generation_wall_seconds")
+    ):
+        raise LadderError("generation worker evidence failed authentication")
+
+    artifact_identity = _required_mapping(
+        recurrence.get("artifact_identity"),
+        description="generation artifact identity",
+    )
+    inventory = _verify_artifact_payload_inventory(artifact, artifact_identity)
+    return {
+        "kind": "pyamplicol-recurrence-generation-only-acceptance",
+        "schema_version": 1,
+        "passes": True,
+        "post_build_validation_samples": configured_samples,
+        "semantic_generation_signature_sha256": signature_sha256,
+        "artifact_semantic_identity_sha256": recurrence.get(
+            "artifact_semantic_identity_sha256"
+        ),
+        **inventory,
+    }
+
+
+def _recurrence_runtime_acceptance(
+    result: Mapping[str, Any],
+    recurrence: Mapping[str, Any],
+    *,
+    artifact: Path,
+) -> dict[str, Any] | None:
+    """Authenticate the harness's recurrence-only runtime acceptance record."""
+
+    configuration = _required_mapping(
+        result.get("configuration"),
+        description="benchmark configuration",
+    )
+    raw_acceptance = result.get("recurrence_runtime_acceptance")
+    if raw_acceptance is None:
+        return None
+    acceptance = _required_mapping(
+        raw_acceptance,
+        description="recurrence runtime acceptance",
+    )
+    without_digest = dict(acceptance)
+    content_sha256 = without_digest.pop("content_sha256", None)
+    if (
+        acceptance.get("kind") != RUNTIME_ACCEPTANCE_KIND
+        or acceptance.get("schema_version") != RUNTIME_ACCEPTANCE_SCHEMA_VERSION
+        or content_sha256 != _canonical_sha256(without_digest)
+    ):
+        raise LadderError("recurrence runtime acceptance address is invalid")
+    if (
+        acceptance.get("accepted") is not True
+        or acceptance.get("status") != "accepted"
+        or acceptance.get("errors") != []
+    ):
+        return None
+
+    required = _required_mapping(
+        acceptance.get("required"),
+        description="recurrence runtime requirements",
+    )
+    required_exact = {
+        "modes": ["recurrence"],
+        "generation_only": False,
+        "batch_sizes": list(DEFAULT_BATCH_SIZES),
+        "target_runtime_seconds": 5.0,
+        "warmup_runs": 2,
+        "minimum_internal_samples": 7,
+        "subprocess_samples_minimum": 7,
+        "subprocess_samples_maximum": 21,
+        "process_family": "d d~ > Z + (n-1)*g",
+        "accepted_n_values": [6, 7],
+        "generation_specialized_axes_allowed": False,
+        "complete_physical_axes_required": True,
+    }
+    if any(required.get(key) != value for key, value in required_exact.items()):
+        raise LadderError("recurrence runtime requirements are incomplete")
+
+    modes = configuration.get("modes")
+    batches = configuration.get("batch_sizes")
+    minimum_samples = configuration.get("minimum_samples")
+    subprocess_samples = configuration.get("subprocess_samples")
+    gluon_count = configuration.get("gluon_count")
+    normalized_process = (
+        " ".join(result["process"].split()).casefold()
+        if isinstance(result.get("process"), str)
+        else None
+    )
+    expected_process = (
+        "d d~ > z" + " g" * gluon_count
+        if (
+            not isinstance(gluon_count, bool)
+            and isinstance(gluon_count, int)
+            and gluon_count in (5, 6)
+        )
+        else None
+    )
+    if (
+        modes != ["recurrence"]
+        or configuration.get("generation_only") is not False
+        or batches != list(DEFAULT_BATCH_SIZES)
+        or configuration.get("target_runtime_seconds") != 5.0
+        or configuration.get("warmup_runs") != 2
+        or isinstance(minimum_samples, bool)
+        or not isinstance(minimum_samples, int)
+        or minimum_samples < 7
+        or isinstance(subprocess_samples, bool)
+        or not isinstance(subprocess_samples, int)
+        or not 7 <= subprocess_samples <= 21
+        or expected_process is None
+        or normalized_process != expected_process
+        or configuration.get("lc_flow_layout") not in LAYOUTS
+        or configuration.get("specialize_flow_at_generation") is not False
+    ):
+        raise LadderError("recurrence runtime configuration is not authoritative")
+
+    contracts = _required_mapping(
+        acceptance.get("contracts"),
+        description="recurrence runtime contracts",
+    )
+    measurement = _required_mapping(
+        contracts.get("measurement"),
+        description="recurrence runtime measurement contract",
+    )
+    artifact_semantics = _required_mapping(
+        contracts.get("artifact_semantics"),
+        description="recurrence runtime artifact semantic contract",
+    )
+    lane_validation = _required_mapping(
+        contracts.get("lane_validation"),
+        description="recurrence runtime lane validation",
+    )
+    worker_rss = _required_mapping(
+        contracts.get("worker_rss"),
+        description="recurrence runtime worker RSS contract",
+    )
+    expected_worker_count = subprocess_samples * len(DEFAULT_BATCH_SIZES)
+    cold_peak = worker_rss.get("maximum_cold_load_observed_lower_bound_bytes")
+    post_peak = worker_rss.get("maximum_post_profile_observed_lower_bound_bytes")
+    if (
+        measurement.get("passes") is not True
+        or artifact_semantics.get("passes") is not True
+        or lane_validation.get("passes") is not True
+        or lane_validation.get("lane_validation_passes") is not True
+        or lane_validation.get("selectors_match") is not True
+        or lane_validation.get("fixtures_match") is not True
+        or lane_validation.get("pairwise_validation_passes") is not None
+        or not isinstance(lane_validation.get("summary_sha256"), str)
+        or _SHA256_RE.fullmatch(lane_validation["summary_sha256"]) is None
+        or worker_rss.get("passes") is not True
+        or worker_rss.get("errors") != []
+        or worker_rss.get("worker_count") != expected_worker_count
+        or isinstance(cold_peak, bool)
+        or not isinstance(cold_peak, int)
+        or cold_peak < 0
+        or isinstance(post_peak, bool)
+        or not isinstance(post_peak, int)
+        or post_peak < cold_peak
+    ):
+        raise LadderError("recurrence runtime contracts are incomplete")
+
+    profiles = _required_mapping(
+        result.get("profiles"),
+        description="benchmark profiles",
+    )
+    if set(profiles) != {"recurrence"}:
+        raise LadderError("recurrence runtime profile inventory is invalid")
+    recurrence_profile = _required_mapping(
+        profiles.get("recurrence"),
+        description="recurrence runtime profile",
+    )
+    profile_schedule = _required_mapping(
+        result.get("profile_schedule"),
+        description="recurrence runtime profile schedule",
+    )
+    bindings = _required_mapping(
+        acceptance.get("bindings"),
+        description="recurrence runtime bindings",
+    )
+    source = _required_mapping(
+        result.get("source"),
+        description="benchmark source identity",
+    )
+    runtime_provenance = _required_mapping(
+        result.get("runtime_provenance"),
+        description="benchmark runtime provenance",
+    )
+    selector_contract = _required_mapping(
+        bindings.get("selector_contract"),
+        description="recurrence runtime selector contract",
+    )
+    validation_fixture = _required_mapping(
+        bindings.get("validation_fixture"),
+        description="recurrence runtime validation fixture",
+    )
+    observed_configuration = {
+        "modes": configuration.get("modes"),
+        "generation_only": configuration.get("generation_only"),
+        "batch_sizes": configuration.get("batch_sizes"),
+        "target_runtime_seconds": configuration.get("target_runtime_seconds"),
+        "warmup_runs": configuration.get("warmup_runs"),
+        "minimum_internal_samples": configuration.get("minimum_samples"),
+        "subprocess_samples": configuration.get("subprocess_samples"),
+        "gluon_count": configuration.get("gluon_count"),
+        "process_expression_override": result.get("process"),
+        "lc_flow_layout": configuration.get("lc_flow_layout"),
+        "color_flow_request": configuration.get("color_flow_request"),
+        "helicity_request": configuration.get("helicity_request"),
+        "validation_samples": configuration.get("validation_samples"),
+        "point_tile_size": configuration.get("point_tile_size"),
+        "jit_optimization_level": configuration.get("jit_optimization_level"),
+        "specialize_flow_at_generation": configuration.get(
+            "specialize_flow_at_generation"
+        ),
+        "prepared_model_path": configuration.get("prepared_model_path"),
+    }
+    bound_configuration = _required_mapping(
+        bindings.get("configuration"),
+        description="recurrence runtime bound configuration",
+    )
+    profile_selector = _required_mapping(
+        recurrence_profile.get("selector_contract"),
+        description="recurrence profile selector contract",
+    )
+    validation = _required_mapping(
+        recurrence_profile.get("validation"),
+        description="recurrence profile validation",
+    )
+    fixture = _required_mapping(
+        validation.get("fixture"),
+        description="recurrence profile validation fixture",
+    )
+    fixture_file = _required_mapping(
+        fixture.get("file"),
+        description="recurrence profile validation fixture file",
+    )
+    expected_fixture = {
+        "point_count": fixture.get("point_count"),
+        "points_sha256": fixture.get("points_sha256"),
+        "file_sha256": fixture_file.get("sha256"),
+    }
+    if (
+        bindings.get("source_identity_sha256") != _canonical_sha256(source)
+        or bindings.get("runtime_provenance_sha256")
+        != _canonical_sha256(runtime_provenance)
+        or bindings.get("profile_schedule_sha256")
+        != _canonical_sha256(profile_schedule)
+        or bindings.get("recurrence_profile_sha256")
+        != _canonical_sha256(recurrence_profile)
+        or bindings.get("selector_contract_sha256")
+        != _canonical_sha256(selector_contract)
+        or dict(selector_contract) != dict(profile_selector)
+        or bindings.get("validation_fixture_sha256")
+        != _canonical_sha256(validation_fixture)
+        or dict(validation_fixture) != expected_fixture
+        or bindings.get("process_id") != recurrence_profile.get("process_id")
+        or bindings.get("process_expression") != normalized_process
+        or bindings.get("lc_flow_layout") != configuration.get("lc_flow_layout")
+        or dict(bound_configuration) != observed_configuration
+        or bindings.get("configuration_sha256")
+        != _canonical_sha256(bound_configuration)
+    ):
+        raise LadderError("recurrence runtime bindings failed authentication")
+
+    artifact_identity = _required_mapping(
+        recurrence.get("artifact_identity"),
+        description="recurrence runtime artifact identity",
+    )
+    artifact_id = artifact_identity.get("artifact_id")
+    semantic_sha256 = recurrence.get("artifact_semantic_identity_sha256")
+    if (
+        recurrence.get("mode") != "recurrence"
+        or recurrence.get("generation_reused") is not False
+        or bindings.get("generation_artifact_id") != artifact_id
+        or bindings.get("generation_artifact_semantic_identity_sha256")
+        != semantic_sha256
+        or recurrence_profile.get("artifact_semantic_identity_sha256")
+        != semantic_sha256
+    ):
+        raise LadderError("recurrence runtime generation binding is invalid")
+    inventory = _verify_artifact_payload_inventory(artifact, artifact_identity)
+    return {
+        "kind": RUNTIME_ACCEPTANCE_KIND,
+        "schema_version": RUNTIME_ACCEPTANCE_SCHEMA_VERSION,
+        "passes": True,
+        "content_sha256": content_sha256,
+        "configuration_sha256": bindings.get("configuration_sha256"),
+        "profile_schedule_sha256": bindings.get("profile_schedule_sha256"),
+        "recurrence_profile_sha256": bindings.get("recurrence_profile_sha256"),
+        "selector_contract_sha256": bindings.get("selector_contract_sha256"),
+        "validation_fixture_sha256": bindings.get("validation_fixture_sha256"),
+        "worker_count": expected_worker_count,
+        "maximum_cold_load_observed_lower_bound_bytes": cold_peak,
+        "maximum_post_profile_observed_lower_bound_bytes": post_peak,
+        **inventory,
+    }
+
+
+def _runtime_profile_summary(value: object) -> dict[str, Any] | None:
+    if value is None:
+        return None
+    profile = _required_mapping(value, description="recurrence runtime profile")
+    raw_measurements = profile.get("profiles")
+    if not isinstance(raw_measurements, list):
+        raise LadderError("recurrence runtime profile has no measurement list")
+    measurements: list[dict[str, Any]] = []
+    for raw_measurement in raw_measurements:
+        measurement = _required_mapping(
+            raw_measurement,
+            description="runtime batch measurement",
+        )
+        raw_samples = measurement.get("subprocess_samples")
+        if not isinstance(raw_samples, list):
+            raise LadderError("runtime batch measurement has no subprocess samples")
+        subprocess_samples = []
+        for raw_sample in raw_samples:
+            sample = _required_mapping(
+                raw_sample,
+                description="runtime subprocess sample",
+            )
+            process_record = sample.get("worker_process_record")
+            worker_wall = (
+                process_record.get("wall_seconds")
+                if isinstance(process_record, Mapping)
+                else None
+            )
+            subprocess_samples.append(
+                {
+                    "schedule_index": sample.get("schedule_index"),
+                    "round": sample.get("round"),
+                    "wall_seconds_per_point": sample.get("wall_seconds_per_point"),
+                    "internal_sample_count": sample.get("internal_sample_count"),
+                    "repetitions_per_sample": sample.get("repetitions_per_sample"),
+                    "evaluation_count": sample.get("evaluation_count"),
+                    "evaluated_point_count": sample.get("evaluated_point_count"),
+                    "interrupted": sample.get("interrupted"),
+                    "worker_wall_seconds": worker_wall,
+                    "peak_rss_after_cold_load": sample.get("peak_rss_after_cold_load"),
+                    "peak_rss_after_profile": sample.get("peak_rss_after_profile"),
+                }
+            )
+        measurements.append(
+            {
+                "batch_size": measurement.get("batch_size"),
+                "sample_count": measurement.get("sample_count"),
+                "wall_seconds_per_point": measurement.get("wall_seconds_per_point"),
+                "wall_seconds_per_point_median": measurement.get(
+                    "wall_seconds_per_point_median"
+                ),
+                "wall_seconds_per_point_mad": measurement.get(
+                    "wall_seconds_per_point_mad"
+                ),
+                "interrupted": measurement.get("interrupted"),
+                "subprocess_samples": subprocess_samples,
+            }
+        )
+    return {
+        "process_id": profile.get("process_id"),
+        "process_expression": profile.get("process_expression"),
+        "measurements": measurements,
+    }
+
+
+def parse_harness_result(path: Path) -> dict[str, Any]:
+    """Extract compact generation/native/runtime evidence from a harness result."""
+
+    result = _json_object(path, description="recurrence benchmark result")
+    if (
+        result.get("kind") != HARNESS_KIND
+        or result.get("schema_version") != HARNESS_SCHEMA_VERSION
+    ):
+        raise LadderError(
+            "recurrence benchmark result kind/schema does not match this runner"
+        )
+    generation = _required_mapping(
+        result.get("generation"),
+        description="benchmark generation",
+    )
+    recurrence = _required_mapping(
+        generation.get("recurrence"),
+        description="recurrence generation record",
+    )
+    artifact_raw = recurrence.get("artifact")
+    if not isinstance(artifact_raw, str):
+        raise LadderError("recurrence generation record has no artifact path")
+    artifact = Path(artifact_raw).expanduser().resolve(strict=True)
+    execution_paths = sorted(artifact.glob("processes/*/execution.json"))
+    if len(execution_paths) != 1:
+        raise LadderError(
+            "exact-process recurrence artifact must have one execution manifest"
+        )
+    execution = _json_object(
+        execution_paths[0],
+        description="recurrence execution manifest",
+    )
+    if (
+        execution.get("kind") != EXECUTION_KIND
+        or execution.get("schema_version") != EXECUTION_SCHEMA_VERSION
+    ):
+        raise LadderError("recurrence execution manifest kind/schema mismatch")
+    plan = _required_mapping(
+        execution.get("plan"),
+        description="recurrence execution plan",
+    )
+    inspection = _required_mapping(
+        plan.get("inspection_summary"),
+        description="native recurrence inspection summary",
+    )
+    native_timings = _required_mapping(
+        inspection.get("generation_timings_seconds"),
+        description="native generation timings",
+    )
+    phases = _required_mapping(
+        recurrence.get("phase_timings_seconds"),
+        description="generation phase timings",
+    )
+    profiles = _required_mapping(
+        result.get("profiles"),
+        description="benchmark profiles",
+    )
+    artifact_identity = _required_mapping(
+        recurrence.get("artifact_identity"),
+        description="artifact identity",
+    )
+    process_record = recurrence.get("worker_process_record")
+    worker_wall_seconds = (
+        process_record.get("wall_seconds")
+        if isinstance(process_record, Mapping)
+        else None
+    )
+    provenance = result.get("provenance")
+    driver_wall_seconds = (
+        provenance.get("wall_seconds") if isinstance(provenance, Mapping) else None
+    )
+    generation_only_acceptance = _generation_only_acceptance(
+        result,
+        recurrence,
+        artifact=artifact,
+    )
+    recurrence_runtime_acceptance = _recurrence_runtime_acceptance(
+        result,
+        recurrence,
+        artifact=artifact,
+    )
+    return {
+        "harness_result_sha256": _sha256_file(path),
+        "process": result.get("process"),
+        "layout": (
+            result.get("configuration", {}).get("lc_flow_layout")
+            if isinstance(result.get("configuration"), Mapping)
+            else None
+        ),
+        "source": result.get("source"),
+        "runtime_provenance": result.get("runtime_provenance"),
+        "artifact": str(artifact),
+        "artifact_id": artifact_identity.get("artifact_id"),
+        "artifact_semantic_identity_sha256": recurrence.get(
+            "artifact_semantic_identity_sha256"
+        ),
+        "generation_wall_seconds": recurrence.get("generation_wall_seconds"),
+        "generation_worker_wall_seconds": worker_wall_seconds,
+        "harness_driver_wall_seconds": driver_wall_seconds,
+        "generation_peak_rss": recurrence.get("peak_rss"),
+        "generation_phase_timings_seconds": dict(phases),
+        "generation_phase_total_seconds": recurrence.get("phase_total_seconds"),
+        "native_generation_timings_seconds": dict(native_timings),
+        "native_inspection_summary": dict(inspection),
+        "runtime_profile": _runtime_profile_summary(profiles.get("recurrence")),
+        "generation_only_acceptance": generation_only_acceptance,
+        "recurrence_runtime_acceptance": recurrence_runtime_acceptance,
+        "complete": result.get("complete"),
+        "passes": result.get("passes"),
+    }
+
+
+def _atomic_write_json(path: Path, value: object) -> None:
+    temporary = path.with_name(f".{path.name}.tmp")
+    try:
+        temporary.write_text(
+            json.dumps(
+                value,
+                allow_nan=False,
+                indent=2,
+                sort_keys=True,
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, path)
+    except (OSError, TypeError, ValueError) as error:
+        raise LadderError(f"cannot write campaign result: {path}") from error
+
+
+def _variant_payload(variant: Variant) -> dict[str, str | None]:
+    return {
+        "checkout": str(variant.checkout),
+        "python": str(variant.python),
+        "pythonpath": (None if variant.pythonpath is None else str(variant.pythonpath)),
+        "prepared_model": (
+            None if variant.prepared_model is None else str(variant.prepared_model)
+        ),
+    }
+
+
+def _measurement_driver_payload() -> dict[str, Any]:
+    files = {}
+    for relative in (
+        Path(__file__).resolve().relative_to(ROOT),
+        HARNESS_RELATIVE_PATH,
+        WATCHDOG_RELATIVE_PATH,
+    ):
+        path = ROOT / relative
+        files[relative.as_posix()] = {
+            "sha256": _sha256_file(path),
+            "size_bytes": path.stat().st_size,
+        }
+    return {
+        "root": str(ROOT.resolve()),
+        "files": files,
+        "source_checkout_override_environment": HARNESS_SOURCE_CHECKOUT_ENV,
+        "shared_driver_policy": (
+            "one-content-hashed-driver-with-variant-source-runtime-binding-v1"
+        ),
+    }
+
+
+def _sample_plan_payload(
+    spec: SampleSpec,
+    *,
+    variant: Variant,
+    campaign_root: Path,
+    settings: RunnerSettings,
+) -> dict[str, Any]:
+    sample_root = campaign_root / "samples" / spec.sample_id
+    return {
+        "sample_id": spec.sample_id,
+        "sequence_index": spec.sequence_index,
+        "pair_index": spec.pair_index,
+        "order_in_pair": spec.order_in_pair,
+        "repetition": spec.repetition + 1,
+        "variant": spec.variant_name,
+        "multiplicity": spec.multiplicity,
+        "process_expression": spec.process_expression,
+        "layout": spec.layout,
+        "runtime_enabled": spec.runtime_enabled,
+        "generation_timeout_seconds": generation_timeout_seconds(
+            spec.multiplicity,
+            spec.layout,
+        ),
+        "outer_timeout_seconds": _outer_timeout_seconds(spec, settings),
+        "sample_root": str(sample_root),
+        "command": build_sample_command(
+            spec,
+            variant,
+            sample_root,
+            settings,
+        ),
+    }
+
+
+def _execute_sample(
+    spec: SampleSpec,
+    *,
+    variant: Variant,
+    campaign_root: Path,
+    settings: RunnerSettings,
+) -> dict[str, Any]:
+    sample_root = campaign_root / "samples" / spec.sample_id
+    sample_root.mkdir(parents=True, exist_ok=False)
+    environment, environment_overrides = _sample_environment(
+        variant,
+        sample_root,
+    )
+    command = build_sample_command(spec, variant, sample_root, settings)
+    stdout_path = sample_root / "stdout.log"
+    stderr_path = sample_root / "stderr.log"
+    result_path = sample_root / "harness-result.json"
+    outer_timeout = _outer_timeout_seconds(spec, settings)
+    started_at = _utc_now()
+    outcome = _run_process(
+        command,
+        cwd=variant.checkout,
+        environment=environment,
+        stdout_path=stdout_path,
+        stderr_path=stderr_path,
+        timeout_seconds=outer_timeout,
+    )
+    finished_at = _utc_now()
+    watchdog = parse_watchdog_log(stderr_path)
+    harness_generation_timeout = parse_harness_generation_timeout(stderr_path)
+    harness_summary: dict[str, Any] | None = None
+    result_error: str | None = None
+    if result_path.is_file():
+        try:
+            harness_summary = parse_harness_result(result_path)
+        except LadderError as error:
+            result_error = str(error)
+    elif outcome.exit_code == 0 and not outcome.timed_out:
+        result_error = "watchdog exited successfully without a harness result"
+
+    status = _sample_status(
+        outcome,
+        watchdog=watchdog,
+        result_error=result_error,
+        harness_summary=harness_summary,
+        harness_generation_timeout=harness_generation_timeout,
+        allow_diagnostic_incomplete_success=(
+            settings.allow_diagnostic_incomplete_success
+        ),
+    )
+    return {
+        **_sample_plan_payload(
+            spec,
+            variant=variant,
+            campaign_root=campaign_root,
+            settings=settings,
+        ),
+        "status": status,
+        "started_at_utc": started_at,
+        "finished_at_utc": finished_at,
+        "wall_seconds": outcome.wall_seconds,
+        "exit_code": outcome.exit_code,
+        "timed_out": outcome.timed_out,
+        "process_error": outcome.error,
+        "result_error": result_error,
+        "environment_overrides": environment_overrides,
+        "stdout_log": str(stdout_path),
+        "stderr_log": str(stderr_path),
+        "harness_result": str(result_path),
+        "watchdog": watchdog,
+        "harness_generation_timeout": harness_generation_timeout,
+        "telemetry": harness_summary,
+    }
+
+
+def _sample_status(
+    outcome: ProcessOutcome,
+    *,
+    watchdog: Mapping[str, object],
+    result_error: str | None,
+    harness_summary: Mapping[str, object] | None,
+    harness_generation_timeout: Mapping[str, object] | None = None,
+    allow_diagnostic_incomplete_success: bool,
+) -> str:
+    """Classify authoritative success separately from censored diagnostics."""
+
+    if outcome.timed_out:
+        return "censored" if allow_diagnostic_incomplete_success else "timeout"
+    if outcome.error is not None:
+        return "launch-error"
+    if harness_generation_timeout is not None:
+        if watchdog.get("terminal_record") != "command-finished":
+            return "invalid-watchdog-evidence"
+        return "censored" if allow_diagnostic_incomplete_success else "timeout"
+    if outcome.exit_code != 0:
+        return "failed"
+    if result_error is not None or harness_summary is None:
+        return "invalid-result"
+    if watchdog.get("terminal_record") != "command-finished":
+        return "invalid-watchdog-evidence"
+    complete = harness_summary.get("complete")
+    passes = harness_summary.get("passes")
+    if complete is True and passes is True:
+        return "passed"
+    generation_acceptance = harness_summary.get("generation_only_acceptance")
+    if (
+        isinstance(generation_acceptance, Mapping)
+        and generation_acceptance.get("passes") is True
+    ):
+        return "passed"
+    runtime_acceptance = harness_summary.get("recurrence_runtime_acceptance")
+    if (
+        isinstance(runtime_acceptance, Mapping)
+        and runtime_acceptance.get("passes") is True
+    ):
+        return "passed"
+    if allow_diagnostic_incomplete_success and complete is not True and passes is None:
+        return "censored"
+    return "failed-validation"
+
+
+def _resolve_existing_path(path: Path, *, description: str) -> Path:
+    try:
+        result = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise LadderError(f"{description} does not exist: {path}") from error
+    return result
+
+
+def _resolve_python(path: Path, *, description: str) -> Path:
+    """Validate while preserving a virtual-environment interpreter symlink."""
+
+    expanded = path.expanduser()
+    absolute = expanded if expanded.is_absolute() else Path.cwd() / expanded
+    if not absolute.exists():
+        raise LadderError(f"{description} does not exist: {path}")
+    if not absolute.is_file():
+        raise LadderError(f"{description} is not a regular file")
+    return absolute.absolute()
+
+
+def _resolve_variant(
+    name: str,
+    *,
+    checkout: Path,
+    python: Path,
+    pythonpath: Path | None,
+    prepared_model: Path | None,
+) -> Variant:
+    resolved_checkout = _resolve_existing_path(
+        checkout,
+        description=f"{name} checkout",
+    )
+    if not resolved_checkout.is_dir():
+        raise LadderError(f"{name} checkout is not a directory")
+    resolved_python = _resolve_python(
+        python,
+        description=f"{name} Python",
+    )
+    resolved_pythonpath = (
+        None
+        if pythonpath is None
+        else _resolve_existing_path(
+            pythonpath,
+            description=f"{name} Python path",
+        )
+    )
+    resolved_model = (
+        None
+        if prepared_model is None
+        else _resolve_existing_path(
+            prepared_model,
+            description=f"{name} prepared model",
+        )
+    )
+    for relative, description in (
+        (WATCHDOG_RELATIVE_PATH, "memory watchdog"),
+        (HARNESS_RELATIVE_PATH, "recurrence benchmark harness"),
+    ):
+        path = resolved_checkout / relative
+        if not path.is_file():
+            raise LadderError(f"{name} checkout has no {description}: {path}")
+    return Variant(
+        name=name,
+        checkout=resolved_checkout,
+        python=resolved_python,
+        pythonpath=resolved_pythonpath,
+        prepared_model=resolved_model,
+    )
+
+
+def _campaign_root(output_root: Path, campaign_id: str) -> Path:
+    if _CAMPAIGN_ID_RE.fullmatch(campaign_id) is None or campaign_id in {".", ".."}:
+        raise LadderError(
+            "campaign ID must contain only letters, digits, '.', '_', and '-'"
+        )
+    allowed_parent = ALLOWED_OUTPUT_PARENT.resolve()
+    requested_parent = output_root.expanduser().resolve()
+    try:
+        requested_parent.relative_to(allowed_parent)
+    except ValueError as error:
+        raise LadderError(
+            f"campaign output must remain under {ALLOWED_OUTPUT_PARENT}"
+        ) from error
+    return requested_parent / campaign_id
+
+
+def _default_campaign_id() -> str:
+    timestamp = dt.datetime.now(dt.UTC).strftime("%Y%m%dT%H%M%SZ")
+    return f"{timestamp}-pid{os.getpid()}"
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--baseline-python", type=Path, required=True)
+    result.add_argument("--candidate-python", type=Path, required=True)
+    result.add_argument("--baseline-checkout", type=Path, default=ROOT)
+    result.add_argument("--candidate-checkout", type=Path, default=ROOT)
+    result.add_argument("--baseline-pythonpath", type=Path)
+    result.add_argument("--candidate-pythonpath", type=Path)
+    result.add_argument("--baseline-prepared-model", type=Path)
+    result.add_argument("--candidate-prepared-model", type=Path)
+    result.add_argument(
+        "--output-root",
+        type=Path,
+        default=CAMPAIGN_PARENT,
+        help=f"campaign parent below {CAMPAIGN_PARENT}",
+    )
+    result.add_argument("--campaign-id", default=None)
+    result.add_argument(
+        "--n",
+        dest="multiplicities",
+        action="append",
+        type=_positive_int,
+        help="process multiplicity; repeat (default: n=2 through n=9)",
+    )
+    result.add_argument(
+        "--layout",
+        dest="layouts",
+        action="append",
+        choices=LAYOUTS,
+        help="LC flow layout; repeat (default: both layouts)",
+    )
+    result.add_argument(
+        "--repetitions",
+        type=_positive_int,
+        default=3,
+        help="paired baseline/candidate repetitions per cell (default: 3)",
+    )
+    result.add_argument(
+        "--runtime-n",
+        action="append",
+        type=_positive_int,
+        default=None,
+        help=(
+            "enable runtime profiling for this selected n; repeat "
+            "(approved validation: 6 and 7)"
+        ),
+    )
+    result.add_argument(
+        "--batch-size",
+        action="append",
+        type=_positive_int,
+        default=None,
+    )
+    result.add_argument(
+        "--validation-samples",
+        type=_positive_int,
+        default=10,
+    )
+    result.add_argument(
+        "--point-tile-size",
+        type=_positive_int,
+        default=1024,
+    )
+    result.add_argument(
+        "--jit-optimization-level",
+        type=int,
+        choices=(0, 1, 2, 3),
+        default=2,
+    )
+    result.add_argument(
+        "--profile-timeout",
+        type=_positive_float,
+        default=300.0,
+    )
+    result.add_argument(
+        "--minimum-samples",
+        type=_positive_int,
+        default=7,
+    )
+    result.add_argument(
+        "--subprocess-samples",
+        type=_positive_int,
+        default=7,
+    )
+    result.add_argument(
+        "--warmup-runs",
+        type=_nonnegative_int,
+        default=2,
+    )
+    result.add_argument(
+        "--target-runtime",
+        type=_positive_float,
+        default=5.0,
+    )
+    result.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="write the complete campaign plan without starting subprocesses",
+    )
+    result.add_argument(
+        "--stop-on-failure",
+        action="store_true",
+        help="stop after the first failed or timed-out sample",
+    )
+    result.add_argument(
+        "--allow-diagnostic-incomplete-success",
+        action="store_true",
+        help=(
+            "retain explicitly censored diagnostic captures without counting "
+            "them as passing acceptance samples"
+        ),
+    )
+    return result
+
+
+def run(arguments: argparse.Namespace) -> dict[str, Any]:
+    multiplicities = tuple(
+        dict.fromkeys(
+            DEFAULT_MULTIPLICITIES
+            if arguments.multiplicities is None
+            else arguments.multiplicities
+        )
+    )
+    layouts = tuple(
+        dict.fromkeys(LAYOUTS if arguments.layouts is None else arguments.layouts)
+    )
+    runtime_multiplicities = frozenset(arguments.runtime_n or ())
+    batch_sizes = tuple(
+        DEFAULT_BATCH_SIZES
+        if arguments.batch_size is None
+        else dict.fromkeys(arguments.batch_size)
+    )
+    settings = RunnerSettings(
+        validation_samples=arguments.validation_samples,
+        point_tile_size=arguments.point_tile_size,
+        jit_optimization_level=arguments.jit_optimization_level,
+        profile_timeout_seconds=arguments.profile_timeout,
+        minimum_samples=arguments.minimum_samples,
+        subprocess_samples=arguments.subprocess_samples,
+        warmup_runs=arguments.warmup_runs,
+        target_runtime_seconds=arguments.target_runtime,
+        batch_sizes=batch_sizes,
+        allow_diagnostic_incomplete_success=(
+            arguments.allow_diagnostic_incomplete_success
+        ),
+    )
+    variants = {
+        "baseline": _resolve_variant(
+            "baseline",
+            checkout=arguments.baseline_checkout,
+            python=arguments.baseline_python,
+            pythonpath=arguments.baseline_pythonpath,
+            prepared_model=arguments.baseline_prepared_model,
+        ),
+        "candidate": _resolve_variant(
+            "candidate",
+            checkout=arguments.candidate_checkout,
+            python=arguments.candidate_python,
+            pythonpath=arguments.candidate_pythonpath,
+            prepared_model=arguments.candidate_prepared_model,
+        ),
+    }
+    schedule = build_schedule(
+        multiplicities,
+        layouts,
+        arguments.repetitions,
+        runtime_multiplicities,
+    )
+    campaign_id = arguments.campaign_id or _default_campaign_id()
+    campaign_root = _campaign_root(arguments.output_root, campaign_id)
+    try:
+        campaign_root.mkdir(parents=True, exist_ok=False)
+        (campaign_root / "samples").mkdir()
+    except FileExistsError as error:
+        raise LadderError(
+            f"campaign directory already exists; choose a new ID: {campaign_root}"
+        ) from error
+    campaign_path = campaign_root / "campaign.json"
+    plan_payloads = [
+        _sample_plan_payload(
+            spec,
+            variant=variants[spec.variant_name],
+            campaign_root=campaign_root,
+            settings=settings,
+        )
+        for spec in schedule
+    ]
+    started_at = _utc_now()
+    campaign: dict[str, Any] = {
+        "kind": CAMPAIGN_KIND,
+        "schema_version": CAMPAIGN_SCHEMA_VERSION,
+        "campaign_id": campaign_id,
+        "status": "planned" if arguments.dry_run else "running",
+        "started_at_utc": started_at,
+        "finished_at_utc": None,
+        "campaign_root": str(campaign_root),
+        "configuration": {
+            "multiplicities": list(multiplicities),
+            "layouts": list(layouts),
+            "repetitions": arguments.repetitions,
+            "runtime_multiplicities": sorted(runtime_multiplicities),
+            "watchdog_limit_gib": WATCHDOG_LIMIT_GIB,
+            "validation_samples": settings.validation_samples,
+            "point_tile_size": settings.point_tile_size,
+            "jit_optimization_level": settings.jit_optimization_level,
+            "profile_timeout_seconds": settings.profile_timeout_seconds,
+            "minimum_samples": settings.minimum_samples,
+            "subprocess_samples": settings.subprocess_samples,
+            "warmup_runs": settings.warmup_runs,
+            "target_runtime_seconds": settings.target_runtime_seconds,
+            "batch_sizes": list(settings.batch_sizes),
+            "stop_on_failure": arguments.stop_on_failure,
+            "allow_diagnostic_incomplete_success": (
+                settings.allow_diagnostic_incomplete_success
+            ),
+            "cold_cache_policy": "unique-roots-per-outer-sample-v1",
+            "ordering_policy": "alternating-baseline-candidate-pairs-v1",
+            "watchdog_policy": "outer-process-tree-guard-covers-all-workers-v1",
+            "measurement_driver": _measurement_driver_payload(),
+        },
+        "variants": {
+            name: _variant_payload(variant) for name, variant in variants.items()
+        },
+        "schedule": plan_payloads,
+        "samples": [],
+        "summary": None,
+    }
+    _atomic_write_json(campaign_path, campaign)
+    if arguments.dry_run:
+        campaign["finished_at_utc"] = _utc_now()
+        _atomic_write_json(campaign_path, campaign)
+        return campaign
+
+    campaign_started = time.perf_counter()
+    for spec in schedule:
+        sample = _execute_sample(
+            spec,
+            variant=variants[spec.variant_name],
+            campaign_root=campaign_root,
+            settings=settings,
+        )
+        campaign["samples"].append(sample)
+        _atomic_write_json(campaign_path, campaign)
+        acceptable_statuses = (
+            {"passed", "censored"}
+            if settings.allow_diagnostic_incomplete_success
+            else {"passed"}
+        )
+        if arguments.stop_on_failure and sample["status"] not in acceptable_statuses:
+            break
+
+    statuses = [
+        sample["status"]
+        for sample in campaign["samples"]
+        if isinstance(sample, Mapping)
+    ]
+    completed = len(campaign["samples"])
+    scheduled = len(schedule)
+    passed = sum(status == "passed" for status in statuses)
+    censored = sum(status == "censored" for status in statuses)
+    failed = completed - passed - censored
+    campaign["finished_at_utc"] = _utc_now()
+    if completed != scheduled or failed != 0:
+        campaign["status"] = "failed"
+    elif censored:
+        campaign["status"] = "completed-with-censoring"
+    else:
+        campaign["status"] = "passed"
+    campaign["summary"] = {
+        "scheduled_sample_count": scheduled,
+        "completed_sample_count": completed,
+        "passed_sample_count": passed,
+        "censored_sample_count": censored,
+        "failed_sample_count": failed,
+        "campaign_wall_seconds": time.perf_counter() - campaign_started,
+    }
+    _atomic_write_json(campaign_path, campaign)
+    return campaign
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    try:
+        arguments = parser().parse_args(argv)
+        result = run(arguments)
+    except LadderError as error:
+        print(f"recurrence-generation-ab-ladder: {error}", file=sys.stderr)
+        return 2
+    print(
+        json.dumps(
+            {
+                "campaign_root": result["campaign_root"],
+                "status": result["status"],
+                "summary": result["summary"],
+            },
+            allow_nan=False,
+            sort_keys=True,
+        )
+    )
+    return (
+        0
+        if result["status"] in {"planned", "passed", "completed-with-censoring"}
+        else 1
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/recurrence_numerical_ab_parity.py b/pyamplicol/tools/developer/recurrence_numerical_ab_parity.py
new file mode 100644
index 0000000000..ed8adc0d42
--- /dev/null
+++ b/pyamplicol/tools/developer/recurrence_numerical_ab_parity.py
@@ -0,0 +1,2144 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Validate recurrence numerical parity across a frozen baseline and candidate.
+
+The acceptance matrix is deliberately fixed:
+
+* ``d d~ > Z g g g g``;
+* ``d d~ > t t~ g g g``;
+* ``g g > g g g g``;
+* LC ``topology-replay`` and ``all-flow-union`` for every process.
+
+Each baseline/candidate capture runs in its own process tree under the audited
+30 GiB watchdog.  The worker reuses the recurrence benchmark's source/runtime
+provenance, generation configuration, artifact semantic identity, deterministic
+validation fixture, and loaded-artifact verification.  It does not run timing
+loops: it loads the generated artifact once and records selected totals plus
+every selected resolved component through the public runtime API.
+
+This is developer-only validation tooling.  It does not alter a public API,
+CLI, artifact schema, or recurrence ABI.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import hashlib
+import json
+import math
+import os
+import signal
+import subprocess
+import sys
+import time
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+DRIVER_PATH = Path(__file__).resolve()
+DRIVER_ROOT = DRIVER_PATH.parents[2]
+if str(DRIVER_ROOT) not in sys.path:
+    sys.path.insert(0, str(DRIVER_ROOT))
+
+from tools.developer import recurrence_generation_ab_ladder as ladder  # noqa: E402
+from tools.developer import recurrence_z6g_benchmark as harness  # noqa: E402
+
+RESULT_KIND = "pyamplicol-recurrence-numerical-ab-parity"
+RESULT_SCHEMA = 1
+CAPTURE_KIND = "pyamplicol-recurrence-numerical-parity-capture"
+CAPTURE_SCHEMA = 1
+COMPARISON_KIND = "pyamplicol-recurrence-numerical-parity-comparison"
+COMPARISON_SCHEMA = 1
+ALLOWED_OUTPUT_PARENT = (
+    DRIVER_ROOT / ".artifacts" / "recurrence-generation-opt"
+).resolve()
+WATCHDOG_PATH = DRIVER_ROOT / "tools" / "ci" / "memory_watchdog.py"
+SOURCE_CHECKOUT_ENV = "PYAMPLICOL_RECURRENCE_Z6G_SOURCE_CHECKOUT"
+WATCHDOG_LIMIT_GIB = 30.0
+ABSOLUTE_TOLERANCE = 1.0e-15
+RELATIVE_TOLERANCE = 1.0e-12
+DEFAULT_VALIDATION_SAMPLES = 10
+DEFAULT_POINT_TILE_SIZE = 1024
+DEFAULT_JIT_OPTIMIZATION_LEVEL = 2
+DEFAULT_WORKER_TIMEOUT_SECONDS = 2.0 * 60.0 * 60.0
+LAYOUTS = ("topology-replay", "all-flow-union")
+PROCESS_CASES = (
+    ("dd_z_4g", "d d~ > Z g g g g"),
+    ("dd_tt_3g", "d d~ > t t~ g g g"),
+    ("gg_4g", "g g > g g g g"),
+)
+EXPECTED_SOURCE_REVISIONS = {
+    "baseline": "172e58fd33a3c65563866c50cfbb5e1ddcd7b302",
+    "candidate": "4e2b1e02dddde2d55b7250cbd52a93001f09b2c2",
+}
+_SHA256_LENGTH = 64
+_SHA256_DIGITS = frozenset("0123456789abcdef")
+
+
+class ParityError(RuntimeError):
+    """Raised when numerical parity evidence is incomplete or invalid."""
+
+
+@dataclass(frozen=True, slots=True)
+class Variant:
+    """One source-bound installed pyAmpliCol runtime."""
+
+    name: str
+    python: Path
+    checkout: Path
+    pythonpath: Path
+    prepared_model: Path
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessOutcome:
+    """One watchdog-guarded capture process outcome."""
+
+    exit_code: int | None
+    timed_out: bool
+    wall_seconds: float
+    error: str | None
+
+
+def _utc_now() -> str:
+    return dt.datetime.now(dt.UTC).isoformat().replace("+00:00", "Z")
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+
+
+def _canonical_sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_json(value)).hexdigest()
+
+
+def _is_sha256(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and len(value) == _SHA256_LENGTH
+        and all(character in _SHA256_DIGITS for character in value)
+    )
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _path_identity(path: Path) -> dict[str, object]:
+    resolved = path.resolve(strict=True)
+    return {
+        "path": str(resolved),
+        "resolved_path": str(resolved),
+        "size_bytes": resolved.stat().st_size,
+        "sha256": _sha256_file(resolved),
+    }
+
+
+def _content_address(value: Mapping[str, object]) -> dict[str, object]:
+    result = dict(value)
+    if "content_sha256" in result:
+        raise ParityError("content-addressed record already contains a digest")
+    result["content_sha256"] = _canonical_sha256(result)
+    return result
+
+
+def _validate_content_address(
+    value: object,
+    *,
+    kind: str,
+    schema_version: int,
+    label: str,
+) -> dict[str, Any]:
+    if not isinstance(value, Mapping):
+        raise ParityError(f"{label} is not an object")
+    result = dict(value)
+    digest = result.pop("content_sha256", None)
+    if (
+        value.get("kind") != kind
+        or isinstance(value.get("schema_version"), bool)
+        or not isinstance(value.get("schema_version"), int)
+        or value.get("schema_version") != schema_version
+        or not _is_sha256(digest)
+        or digest != _canonical_sha256(result)
+    ):
+        raise ParityError(f"{label} failed its content-address contract")
+    return dict(value)
+
+
+def _atomic_write_json(path: Path, value: object) -> None:
+    if path.exists():
+        raise ParityError(f"refusing to replace existing evidence: {path}")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    try:
+        temporary.write_text(
+            json.dumps(value, allow_nan=False, indent=2, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, path)
+    except (OSError, TypeError, ValueError) as error:
+        temporary.unlink(missing_ok=True)
+        raise ParityError(f"cannot write evidence JSON: {path}") from error
+
+
+def _json_object(path: Path, *, label: str) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise ParityError(f"cannot read {label}: {path}") from error
+    if not isinstance(value, dict):
+        raise ParityError(f"{label} must contain one object")
+    return value
+
+
+def _normalized_process(value: str) -> str:
+    return " ".join(value.split()).casefold()
+
+
+def _validate_process_case(process_key: str, process_expression: str) -> None:
+    if not any(
+        process_key == expected_key
+        and _normalized_process(process_expression)
+        == _normalized_process(expected_expression)
+        for expected_key, expected_expression in PROCESS_CASES
+    ):
+        raise ParityError("process is outside the fixed numerical-parity matrix")
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return parsed
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0.0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return parsed
+
+
+def _resolve_inside_workspace(
+    path: Path,
+    *,
+    label: str,
+    regular_file: bool | None = None,
+) -> Path:
+    try:
+        resolved = path.expanduser().resolve(strict=True)
+        resolved.relative_to(DRIVER_ROOT.resolve())
+    except (OSError, ValueError) as error:
+        raise ParityError(f"{label} must exist inside the workspace: {path}") from error
+    if regular_file is True and not resolved.is_file():
+        raise ParityError(f"{label} is not a regular file: {resolved}")
+    if regular_file is False and not resolved.is_dir():
+        raise ParityError(f"{label} is not a directory: {resolved}")
+    return resolved
+
+
+def _resolve_python_inside_workspace(path: Path, *, label: str) -> Path:
+    """Retain a workspace interpreter symlink whose target may be external."""
+
+    absolute = Path(os.path.abspath(path.expanduser()))
+    try:
+        absolute.relative_to(DRIVER_ROOT.resolve())
+        absolute.parent.resolve(strict=True).relative_to(DRIVER_ROOT.resolve())
+    except (OSError, ValueError) as error:
+        raise ParityError(f"{label} must exist inside the workspace: {path}") from error
+    if not absolute.is_file():
+        raise ParityError(f"{label} is not a regular file: {absolute}")
+    return absolute
+
+
+def _resolve_output_root(path: Path) -> Path:
+    requested = path.expanduser().resolve()
+    try:
+        requested.relative_to(ALLOWED_OUTPUT_PARENT)
+    except ValueError as error:
+        raise ParityError(
+            f"output root must remain below {ALLOWED_OUTPUT_PARENT}"
+        ) from error
+    if requested == ALLOWED_OUTPUT_PARENT:
+        raise ParityError("output root must be a child of the artifact parent")
+    if requested.exists():
+        raise ParityError(f"output root already exists: {requested}")
+    return requested
+
+
+def _variant(
+    name: str,
+    *,
+    python: Path,
+    checkout: Path,
+    pythonpath: Path,
+    prepared_model: Path,
+) -> Variant:
+    return Variant(
+        name=name,
+        python=_resolve_python_inside_workspace(python, label=f"{name} Python"),
+        checkout=_resolve_inside_workspace(
+            checkout,
+            label=f"{name} checkout",
+            regular_file=False,
+        ),
+        pythonpath=_resolve_inside_workspace(
+            pythonpath,
+            label=f"{name} Python path",
+            regular_file=False,
+        ),
+        prepared_model=_resolve_inside_workspace(
+            prepared_model,
+            label=f"{name} prepared model",
+            regular_file=True,
+        ),
+    )
+
+
+def _git_stdout(checkout: Path, *arguments: str, label: str) -> str:
+    environment = os.environ.copy()
+    environment["GIT_OPTIONAL_LOCKS"] = "0"
+    completed = subprocess.run(
+        ("git", *arguments),
+        cwd=checkout,
+        env=environment,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        detail = completed.stderr.strip()
+        raise ParityError(
+            f"cannot inspect {label} checkout" + ("" if not detail else f": {detail}")
+        )
+    return completed.stdout.strip()
+
+
+def _preflight_variant_source(variant: Variant) -> dict[str, object]:
+    expected_revision = EXPECTED_SOURCE_REVISIONS.get(variant.name)
+    if expected_revision is None:
+        raise ParityError(f"no expected revision is pinned for {variant.name}")
+    checkout = variant.checkout.resolve()
+    top_level = _git_stdout(
+        checkout,
+        "rev-parse",
+        "--show-toplevel",
+        label=variant.name,
+    )
+    revision = _git_stdout(
+        checkout,
+        "rev-parse",
+        "--verify",
+        "HEAD",
+        label=variant.name,
+    )
+    status = _git_stdout(
+        checkout,
+        "status",
+        "--porcelain=v1",
+        "--untracked-files=all",
+        label=variant.name,
+    )
+    if Path(top_level).resolve() != checkout:
+        raise ParityError(f"{variant.name} checkout is not its Git worktree root")
+    if revision != expected_revision:
+        raise ParityError(
+            f"{variant.name} revision is {revision}, expected {expected_revision}"
+        )
+    if status:
+        raise ParityError(f"{variant.name} checkout is dirty before the campaign")
+    return {
+        "checkout": str(checkout),
+        "revision": revision,
+        "dirty": False,
+        "untracked_files_checked": True,
+    }
+
+
+def _complex_payload(value: complex) -> list[float]:
+    if not math.isfinite(value.real) or not math.isfinite(value.imag):
+        raise ParityError("runtime returned a non-finite complex value")
+    return [float(value.real), float(value.imag)]
+
+
+def _complex_value(value: object, *, label: str) -> complex:
+    if (
+        not isinstance(value, list)
+        or len(value) != 2
+        or any(
+            isinstance(component, bool)
+            or not isinstance(component, (float, int))
+            or not math.isfinite(float(component))
+            for component in value
+        )
+    ):
+        raise ParityError(f"{label} is not a finite complex pair")
+    return complex(float(value[0]), float(value[1]))
+
+
+def _value_comparison(
+    baseline: object,
+    candidate: object,
+    *,
+    absolute_tolerance: float = ABSOLUTE_TOLERANCE,
+    relative_tolerance: float = RELATIVE_TOLERANCE,
+) -> dict[str, object]:
+    baseline_value = _complex_value(baseline, label="baseline value")
+    candidate_value = _complex_value(candidate, label="candidate value")
+    absolute = abs(candidate_value - baseline_value)
+    relative = absolute / max(
+        abs(baseline_value),
+        abs(candidate_value),
+        1.0e-300,
+    )
+    return {
+        "baseline": _complex_payload(baseline_value),
+        "candidate": _complex_payload(candidate_value),
+        "absolute_difference": absolute,
+        "relative_difference": relative,
+        "absolute_tolerance": absolute_tolerance,
+        "relative_tolerance": relative_tolerance,
+        "passes": (absolute <= absolute_tolerance or relative <= relative_tolerance),
+    }
+
+
+def _axis_ids(values: Sequence[object], *, label: str) -> list[str]:
+    result = [getattr(value, "id", None) for value in values]
+    if (
+        not result
+        or any(not isinstance(value, str) or not value for value in result)
+        or len(set(result)) != len(result)
+    ):
+        raise ParityError(f"runtime exposes an invalid {label} axis")
+    return [str(value) for value in result]
+
+
+def _select_workload(
+    physics: object,
+    *,
+    layout: str,
+) -> tuple[dict[str, tuple[str, ...]], dict[str, object]]:
+    color_flows = tuple(getattr(physics, "color_flows", ()))
+    helicities = tuple(getattr(physics, "helicities", ()))
+    color_ids = _axis_ids(color_flows, label="color-flow")
+    helicity_ids = _axis_ids(helicities, label="helicity")
+    structural_zero_ids = [
+        str(helicity.id)
+        for helicity in helicities
+        if getattr(helicity, "structural_zero", False) is True
+    ]
+    if layout == "topology-replay":
+        selected_color_id = color_ids[0]
+        selectors = {"color_flows": (selected_color_id,)}
+        contract = {
+            "workload": "single-runtime-selected-flow/helicity-sum",
+            "physical_color_ids": color_ids,
+            "physical_helicity_ids": helicity_ids,
+            "structural_zero_helicity_ids": structural_zero_ids,
+            "selected_color_flow_ids": [selected_color_id],
+            "selected_helicity_ids": [],
+        }
+    elif layout == "all-flow-union":
+        selected_helicity_id = next(
+            (
+                helicity_id
+                for helicity_id in helicity_ids
+                if helicity_id not in set(structural_zero_ids)
+            ),
+            None,
+        )
+        if selected_helicity_id is None:
+            raise ParityError("runtime exposes no non-structural-zero helicity")
+        selectors = {"helicities": (selected_helicity_id,)}
+        contract = {
+            "workload": "all-flows/runtime-selected-single-helicity",
+            "physical_color_ids": color_ids,
+            "physical_helicity_ids": helicity_ids,
+            "structural_zero_helicity_ids": structural_zero_ids,
+            "selected_color_flow_ids": [],
+            "selected_helicity_ids": [selected_helicity_id],
+        }
+    else:
+        raise ParityError(f"unsupported LC flow layout: {layout}")
+    contract["contract_sha256"] = _canonical_sha256(contract)
+    return selectors, contract
+
+
+def _parameters_identity(artifact: Path) -> dict[str, object]:
+    path = artifact / "model" / "parameters.json"
+    payload = _json_object(path, label="artifact parameter payload")
+    return {
+        "file": _path_identity(path),
+        "payload": payload,
+        "payload_sha256": _canonical_sha256(payload),
+    }
+
+
+def _generation_arguments(arguments: argparse.Namespace) -> argparse.Namespace:
+    return argparse.Namespace(
+        mode="recurrence",
+        artifact=arguments.artifact,
+        prepared_model=arguments.prepared_model,
+        process_expression=arguments.process_expression,
+        gluon_count=1,
+        validation_samples=arguments.validation_samples,
+        point_tile_size=arguments.point_tile_size,
+        jit_optimization_level=arguments.jit_optimization_level,
+        lc_flow_layout=arguments.layout,
+        specialize_flow_at_generation=False,
+        color_flow="1",
+        helicity="1",
+        write_mode="error",
+    )
+
+
+def _generation_request(
+    *,
+    validation_samples: int,
+    point_tile_size: int,
+    jit_optimization_level: int,
+) -> dict[str, object]:
+    return {
+        "validation_samples": validation_samples,
+        "validation_seed": harness.VALIDATION_SEED,
+        "point_tile_size": point_tile_size,
+        "jit_optimization_level": jit_optimization_level,
+        "specialize_flow_at_generation": False,
+    }
+
+
+def _capture_validation(
+    runtime: object,
+    *,
+    artifact: Path,
+    process_id: str,
+    layout: str,
+) -> dict[str, object]:
+    points, fixture = harness._validation_fixture(artifact, process_id)
+    if not points:
+        raise ParityError("generated artifact contains no validation points")
+    selectors, selector_contract = _select_workload(
+        runtime.physics,
+        layout=layout,
+    )
+    selected = tuple(complex(value) for value in runtime.evaluate(points, **selectors))
+    resolved = runtime.evaluate_resolved(points, **selectors)
+    resolved_sums = tuple(complex(value) for value in resolved.total())
+    if len(selected) != len(points) or len(resolved_sums) != len(points):
+        raise ParityError("runtime result count disagrees with validation fixture")
+    point_comparisons: list[dict[str, object]] = []
+    for point_index, (selected_value, resolved_value) in enumerate(
+        zip(selected, resolved_sums, strict=True)
+    ):
+        comparison = _value_comparison(
+            _complex_payload(selected_value),
+            _complex_payload(resolved_value),
+        )
+        point_comparisons.append(
+            {
+                "point_index": point_index,
+                "selected_total": comparison["baseline"],
+                "resolved_sum": comparison["candidate"],
+                "absolute_difference": comparison["absolute_difference"],
+                "relative_difference": comparison["relative_difference"],
+                "passes": comparison["passes"],
+            }
+        )
+    resolved_components = [
+        [
+            _complex_payload(complex(value))
+            for helicity_row in point_values
+            for value in helicity_row
+        ]
+        for point_values in resolved.values
+    ]
+    validation: dict[str, object] = {
+        "fixture": {
+            **fixture,
+            "points": [[list(momentum) for momentum in point] for point in points],
+        },
+        "selector_contract": selector_contract,
+        "selected_totals": [_complex_payload(value) for value in selected],
+        "resolved_sums": [_complex_payload(value) for value in resolved_sums],
+        "resolved_helicity_ids": list(resolved.helicity_ids),
+        "resolved_color_ids": list(resolved.color_ids),
+        "resolved_components": resolved_components,
+        "point_comparisons": point_comparisons,
+        "maximum_absolute_difference": max(
+            float(item["absolute_difference"]) for item in point_comparisons
+        ),
+        "maximum_relative_difference": max(
+            float(item["relative_difference"]) for item in point_comparisons
+        ),
+        "passes": all(bool(item["passes"]) for item in point_comparisons),
+    }
+    harness._validated_lane_validation_values(
+        validation,
+        fixture,
+        mode="recurrence",
+    )
+    return validation
+
+
+def _run_capture_worker(arguments: argparse.Namespace) -> dict[str, object]:
+    from pyamplicol import Runtime
+
+    artifact = arguments.artifact.resolve()
+    capture_path = arguments.capture_json.resolve()
+    prepared_model_path = arguments.prepared_model.resolve(strict=True)
+    try:
+        artifact.relative_to(ALLOWED_OUTPUT_PARENT)
+        capture_path.relative_to(ALLOWED_OUTPUT_PARENT)
+        prepared_model_path.relative_to(DRIVER_ROOT.resolve())
+    except ValueError as error:
+        raise ParityError(
+            "capture worker inputs and outputs must remain inside the workspace"
+        ) from error
+    if artifact.parent != capture_path.parent:
+        raise ParityError("capture worker artifact and evidence must share one root")
+    if artifact.exists() or capture_path.exists():
+        raise ParityError("capture worker refuses to replace existing output")
+    if arguments.layout not in LAYOUTS:
+        raise ParityError(f"unsupported LC flow layout: {arguments.layout}")
+    _validate_process_case(arguments.process_key, arguments.process_expression)
+
+    source_before = harness._git_source_identity()
+    runtime_before = harness._runtime_provenance(source_before)
+    prepared_model = _path_identity(prepared_model_path)
+    arguments.prepared_model = prepared_model_path
+    generation_arguments = _generation_arguments(arguments)
+    generation = harness._generate_worker(generation_arguments)
+    artifact_identity_before = harness._artifact_identity(artifact)
+    effective_contract = harness._validate_artifact_contract(
+        artifact,
+        artifact_identity_before,
+        arguments=generation_arguments,
+        mode="recurrence",
+    )
+
+    process_id = artifact_identity_before.get("process_id")
+    if not isinstance(process_id, str) or not process_id:
+        raise ParityError("generated artifact has no process identity")
+    runtime = Runtime.load(artifact, process=arguments.process_expression)
+    loaded_before = harness._loaded_runtime_artifact_verification(
+        runtime,
+        expected_artifact_id=artifact_identity_before.get("artifact_id"),
+        phase="before-numerical-parity-evaluation",
+    )
+    physics = runtime.physics
+    observed_process = getattr(physics, "process", None)
+    if not isinstance(observed_process, str) or _normalized_process(
+        observed_process
+    ) != _normalized_process(arguments.process_expression):
+        raise ParityError("loaded runtime process disagrees with the request")
+    if getattr(physics, "color_accuracy", None) != "lc":
+        raise ParityError("loaded runtime does not expose LC physics")
+
+    validation = _capture_validation(
+        runtime,
+        artifact=artifact,
+        process_id=process_id,
+        layout=arguments.layout,
+    )
+    loaded_after = harness._loaded_runtime_artifact_verification(
+        runtime,
+        expected_artifact_id=artifact_identity_before.get("artifact_id"),
+        phase="after-numerical-parity-evaluation",
+    )
+    artifact_identity_after = harness._artifact_identity(artifact)
+    source_after = harness._git_source_identity()
+    runtime_after = harness._runtime_provenance(source_after)
+    if artifact_identity_after != artifact_identity_before:
+        raise ParityError("artifact changed while numerical parity was evaluated")
+    if source_after != source_before:
+        raise ParityError("source checkout changed while capture was running")
+    if runtime_after != runtime_before:
+        raise ParityError("installed runtime changed while capture was running")
+
+    capture = _content_address(
+        {
+            "kind": CAPTURE_KIND,
+            "schema_version": CAPTURE_SCHEMA,
+            "variant": arguments.variant,
+            "process_key": arguments.process_key,
+            "requested_process": arguments.process_expression,
+            "observed_process": observed_process,
+            "layout": arguments.layout,
+            "generation_request": _generation_request(
+                validation_samples=arguments.validation_samples,
+                point_tile_size=arguments.point_tile_size,
+                jit_optimization_level=arguments.jit_optimization_level,
+            ),
+            "captured_at_utc": _utc_now(),
+            "source": source_before,
+            "runtime_provenance": runtime_before,
+            "prepared_model": prepared_model,
+            "generation": generation,
+            "artifact": artifact_identity_before,
+            "effective_contract": effective_contract,
+            "parameters": _parameters_identity(artifact),
+            "loaded_artifact_verification": {
+                "before_evaluation": loaded_before,
+                "after_evaluation": loaded_after,
+            },
+            "validation": validation,
+            "peak_rss_after_evaluation": harness._resource_peak(),
+            "tolerances": {
+                "absolute": ABSOLUTE_TOLERANCE,
+                "relative": RELATIVE_TOLERANCE,
+            },
+        }
+    )
+    capture = _validate_capture(
+        capture,
+        expected_variant=arguments.variant,
+        expected_process_key=arguments.process_key,
+        expected_process=arguments.process_expression,
+        expected_layout=arguments.layout,
+        expected_checkout=Path(str(source_before["checkout"])),
+        expected_artifact_root=artifact.parent,
+        expected_generation_request=_generation_request(
+            validation_samples=arguments.validation_samples,
+            point_tile_size=arguments.point_tile_size,
+            jit_optimization_level=arguments.jit_optimization_level,
+        ),
+    )
+    _atomic_write_json(capture_path, capture)
+    return capture
+
+
+def _validate_file_identity(value: object, *, label: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise ParityError(f"{label} file identity is missing")
+    path = value.get("path")
+    size_bytes = value.get("size_bytes")
+    if (
+        not isinstance(path, str)
+        or not path
+        or isinstance(size_bytes, bool)
+        or not isinstance(size_bytes, int)
+        or size_bytes < 0
+        or not _is_sha256(value.get("sha256"))
+    ):
+        raise ParityError(f"{label} file identity is invalid")
+    resolved_path = value.get("resolved_path")
+    if resolved_path is not None and (
+        not isinstance(resolved_path, str) or not Path(resolved_path).is_absolute()
+    ):
+        raise ParityError(f"{label} resolved file identity is invalid")
+    return value
+
+
+def _file_identity_paths(
+    value: Mapping[str, Any],
+    *,
+    label: str,
+) -> tuple[Path, ...]:
+    raw_paths = [value.get("path")]
+    if "resolved_path" in value:
+        raw_paths.append(value.get("resolved_path"))
+    if any(
+        not isinstance(raw, str) or not Path(raw).is_absolute() for raw in raw_paths
+    ):
+        raise ParityError(f"{label} path is not absolute")
+    return tuple(Path(str(raw)).resolve(strict=False) for raw in raw_paths)
+
+
+def _validate_tree_identity(value: object, *, label: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise ParityError(f"{label} tree identity is missing")
+    file_count = value.get("file_count")
+    size_bytes = value.get("size_bytes")
+    if (
+        value.get("algorithm") != "sha256-relative-path-size-content-v1"
+        or isinstance(file_count, bool)
+        or not isinstance(file_count, int)
+        or file_count <= 0
+        or isinstance(size_bytes, bool)
+        or not isinstance(size_bytes, int)
+        or size_bytes <= 0
+        or not _is_sha256(value.get("sha256"))
+    ):
+        raise ParityError(f"{label} tree identity is invalid")
+    return value
+
+
+def _validate_runtime_provenance_record(
+    value: Mapping[str, Any],
+    *,
+    source: Mapping[str, Any],
+) -> None:
+    required = {
+        "interpreter",
+        "installed_distribution",
+        "active_build_info",
+        "native_extension",
+        "dependencies",
+    }
+    if not required.issubset(value):
+        raise ParityError("runtime provenance is incomplete")
+    interpreter = _validate_file_identity(
+        value["interpreter"],
+        label="runtime interpreter",
+    )
+    native = _validate_file_identity(
+        value["native_extension"],
+        label="native extension",
+    )
+    active = _validate_file_identity(
+        value["active_build_info"],
+        label="active build info",
+    )
+    if (
+        not isinstance(interpreter.get("python_version"), str)
+        or not isinstance(interpreter.get("implementation"), str)
+        or not isinstance(native.get("package_version"), str)
+        or not _is_sha256(native.get("build_inputs_sha256"))
+        or not isinstance(active.get("payload"), Mapping)
+    ):
+        raise ParityError("runtime executable provenance is invalid")
+    build_payload = active["payload"]
+    if (
+        build_payload.get("source_checkout") != source.get("checkout")
+        or build_payload.get("source_revision") != source.get("revision")
+        or build_payload.get("native_build_inputs_sha256")
+        != native.get("build_inputs_sha256")
+    ):
+        raise ParityError("runtime build provenance is not source-bound")
+
+    distribution = value["installed_distribution"]
+    if not isinstance(distribution, Mapping):
+        raise ParityError("installed distribution provenance is missing")
+    _validate_tree_identity(
+        distribution.get("distribution_content"),
+        label="installed distribution",
+    )
+    native_modules = distribution.get("native_modules")
+    build_info_files = distribution.get("build_info_files")
+    if (
+        not isinstance(distribution.get("package_version"), str)
+        or not isinstance(native_modules, list)
+        or not native_modules
+        or not isinstance(build_info_files, list)
+        or not build_info_files
+    ):
+        raise ParityError("installed distribution provenance is incomplete")
+    validated_native_modules = [
+        _validate_file_identity(entry, label="installed native module")
+        for entry in native_modules
+    ]
+    validated_build_info = [
+        _validate_file_identity(entry, label="installed build-info")
+        for entry in build_info_files
+    ]
+    if native.get("sha256") not in {
+        entry.get("sha256") for entry in validated_native_modules
+    } or active.get("sha256") not in {
+        entry.get("sha256") for entry in validated_build_info
+    }:
+        raise ParityError("active runtime files are absent from its distribution")
+
+    dependencies = value["dependencies"]
+    if not isinstance(dependencies, Mapping) or not dependencies:
+        raise ParityError("runtime dependency provenance is missing")
+    for name, dependency in dependencies.items():
+        if (
+            not isinstance(name, str)
+            or not name
+            or not isinstance(dependency, Mapping)
+            or not isinstance(dependency.get("present"), bool)
+            or not isinstance(dependency.get("path"), str)
+            or not isinstance(dependency.get("resolved_path"), str)
+        ):
+            raise ParityError("runtime dependency provenance is invalid")
+        if dependency["present"] is True:
+            _validate_file_identity(
+                dependency,
+                label=f"runtime dependency {name}",
+            )
+
+
+def _validate_artifact_identity_record(
+    value: Mapping[str, Any],
+) -> dict[str, Mapping[str, Any]]:
+    if (
+        not isinstance(value.get("path"), str)
+        or not Path(str(value["path"])).is_absolute()
+        or not isinstance(value.get("process_id"), str)
+        or not value["process_id"]
+        or value["process_id"] in {".", ".."}
+        or Path(str(value["process_id"])).name != value["process_id"]
+        or not isinstance(value.get("producer"), Mapping)
+    ):
+        raise ParityError("artifact provenance is incomplete")
+    artifact_root = Path(str(value["path"])).resolve(strict=False)
+    manifest = _validate_file_identity(
+        value.get("manifest"),
+        label="artifact manifest",
+    )
+    expected_manifest_path = artifact_root / "artifact.json"
+    if any(
+        path != expected_manifest_path
+        for path in _file_identity_paths(manifest, label="artifact manifest")
+    ):
+        raise ParityError("artifact manifest path is not bound to the artifact")
+    tree = _validate_tree_identity(value.get("tree"), label="artifact")
+    payloads = value.get("payloads")
+    if not isinstance(payloads, list) or not payloads:
+        raise ParityError("artifact payload provenance is missing")
+    payload_inventory: dict[str, Mapping[str, Any]] = {}
+    for payload in payloads:
+        if not isinstance(payload, Mapping):
+            raise ParityError("artifact payload provenance is invalid")
+        path = payload.get("path")
+        size_bytes = payload.get("size_bytes")
+        if (
+            not isinstance(path, str)
+            or not path
+            or Path(path).is_absolute()
+            or ".." in Path(path).parts
+            or not isinstance(payload.get("role"), str)
+            or isinstance(size_bytes, bool)
+            or not isinstance(size_bytes, int)
+            or size_bytes < 0
+            or not _is_sha256(payload.get("sha256"))
+        ):
+            raise ParityError("artifact payload provenance is invalid")
+        if path in payload_inventory:
+            raise ParityError("artifact payload provenance contains duplicate paths")
+        payload_inventory[path] = payload
+    if tree.get("file_count") != len(payload_inventory) + 1 or tree.get(
+        "size_bytes"
+    ) != int(manifest["size_bytes"]) + sum(
+        int(payload["size_bytes"]) for payload in payload_inventory.values()
+    ):
+        raise ParityError(
+            "artifact tree is not bound to manifest and payload inventory"
+        )
+
+    model_identity = value.get("model_identity")
+    if not isinstance(model_identity, Mapping):
+        raise ParityError("artifact model identity is missing")
+    for field, digest_field in (
+        ("manifest", "manifest_sha256"),
+        ("common_physics_identity", "common_physics_identity_sha256"),
+    ):
+        body = model_identity.get(field)
+        if not isinstance(body, Mapping) or model_identity.get(
+            digest_field
+        ) != _canonical_sha256(body):
+            raise ParityError("artifact model identity is invalid")
+    return payload_inventory
+
+
+def _validate_artifact_payload_link(
+    artifact: Mapping[str, Any],
+    payload_inventory: Mapping[str, Mapping[str, Any]],
+    file_identity: object,
+    *,
+    relative_path: str,
+    role: str,
+    process_id: str | None,
+    label: str,
+) -> None:
+    identity = _validate_file_identity(file_identity, label=label)
+    artifact_root = Path(str(artifact["path"])).resolve(strict=False)
+    expected_path = (artifact_root / relative_path).resolve(strict=False)
+    payload = payload_inventory.get(relative_path)
+    if (
+        any(
+            path != expected_path
+            for path in _file_identity_paths(identity, label=label)
+        )
+        or not isinstance(payload, Mapping)
+        or payload.get("role") != role
+        or payload.get("process_id") != process_id
+        or payload.get("sha256") != identity.get("sha256")
+        or payload.get("size_bytes") != identity.get("size_bytes")
+    ):
+        raise ParityError(f"{label} is not bound to the artifact payload inventory")
+
+
+def _validate_capture(
+    value: object,
+    *,
+    expected_variant: str,
+    expected_process_key: str,
+    expected_process: str,
+    expected_layout: str,
+    expected_checkout: Path | None = None,
+    expected_artifact_root: Path | None = None,
+    expected_generation_request: Mapping[str, object] | None = None,
+) -> dict[str, Any]:
+    capture = _validate_content_address(
+        value,
+        kind=CAPTURE_KIND,
+        schema_version=CAPTURE_SCHEMA,
+        label=f"{expected_variant} numerical capture",
+    )
+    source = capture.get("source")
+    artifact = capture.get("artifact")
+    effective = capture.get("effective_contract")
+    validation = capture.get("validation")
+    parameters = capture.get("parameters")
+    prepared = capture.get("prepared_model")
+    generation_request = capture.get("generation_request")
+    generation = capture.get("generation")
+    runtime_provenance = capture.get("runtime_provenance")
+    loaded = capture.get("loaded_artifact_verification")
+    semantic = (
+        artifact.get("semantic_identity") if isinstance(artifact, Mapping) else None
+    )
+    coverage = semantic.get("coverage") if isinstance(semantic, Mapping) else None
+    reduction_coverage = (
+        semantic.get("execution_reduction_coverage")
+        if isinstance(semantic, Mapping)
+        else None
+    )
+    model_source = (
+        generation.get("model_source") if isinstance(generation, Mapping) else None
+    )
+    if (
+        capture.get("variant") != expected_variant
+        or capture.get("process_key") != expected_process_key
+        or not isinstance(capture.get("requested_process"), str)
+        or _normalized_process(str(capture["requested_process"]))
+        != _normalized_process(expected_process)
+        or not isinstance(capture.get("observed_process"), str)
+        or _normalized_process(str(capture["observed_process"]))
+        != _normalized_process(expected_process)
+        or capture.get("layout") != expected_layout
+        or not isinstance(generation_request, Mapping)
+        or set(generation_request)
+        != {
+            "validation_samples",
+            "validation_seed",
+            "point_tile_size",
+            "jit_optimization_level",
+            "specialize_flow_at_generation",
+        }
+        or isinstance(generation_request.get("validation_samples"), bool)
+        or not isinstance(generation_request.get("validation_samples"), int)
+        or int(generation_request["validation_samples"]) <= 0
+        or isinstance(generation_request.get("validation_seed"), bool)
+        or not isinstance(generation_request.get("validation_seed"), int)
+        or generation_request.get("validation_seed") != harness.VALIDATION_SEED
+        or isinstance(generation_request.get("point_tile_size"), bool)
+        or not isinstance(generation_request.get("point_tile_size"), int)
+        or int(generation_request["point_tile_size"]) <= 0
+        or isinstance(generation_request.get("jit_optimization_level"), bool)
+        or not isinstance(generation_request.get("jit_optimization_level"), int)
+        or generation_request.get("jit_optimization_level") not in {0, 1, 2, 3}
+        or generation_request.get("specialize_flow_at_generation") is not False
+        or capture.get("tolerances")
+        != {
+            "absolute": ABSOLUTE_TOLERANCE,
+            "relative": RELATIVE_TOLERANCE,
+        }
+        or not isinstance(source, Mapping)
+        or source.get("dirty") is not False
+        or source.get("untracked_files_checked") is not True
+        or not isinstance(source.get("checkout"), str)
+        or not Path(str(source["checkout"])).is_absolute()
+        or not isinstance(source.get("revision"), str)
+        or len(str(source["revision"])) != 40
+        or any(character not in _SHA256_DIGITS for character in str(source["revision"]))
+        or source.get("revision") != EXPECTED_SOURCE_REVISIONS.get(expected_variant)
+        or not isinstance(runtime_provenance, Mapping)
+        or not isinstance(artifact, Mapping)
+        or not _is_sha256(artifact.get("artifact_id"))
+        or artifact.get("color_accuracy") != "lc"
+        or not isinstance(artifact.get("process_expression"), str)
+        or _normalized_process(str(artifact["process_expression"]))
+        != _normalized_process(expected_process)
+        or not isinstance(semantic, Mapping)
+        or artifact.get("semantic_identity_sha256") != _canonical_sha256(semantic)
+        or not isinstance(coverage, Mapping)
+        or coverage.get("complete_physical_axes") is not True
+        or coverage.get("color") != "complete"
+        or coverage.get("helicities") != "complete"
+        or not isinstance(reduction_coverage, Mapping)
+        or reduction_coverage.get("complete") is not True
+        or reduction_coverage.get("errors") != []
+        or semantic.get("generation_specialized_axes") != []
+        or not isinstance(semantic.get("runtime_selector_semantics"), Mapping)
+        or semantic["runtime_selector_semantics"].get("generation_specialized_axes")
+        != []
+        or semantic["runtime_selector_semantics"]["generation_specialized_axes"]
+        != semantic["generation_specialized_axes"]
+        or not isinstance(effective, Mapping)
+        or effective.get("execution_mode") != "recurrence"
+        or effective.get("backend") != "jit"
+        or isinstance(effective.get("jit_optimization_level"), bool)
+        or effective.get("jit_optimization_level")
+        != harness.PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL
+        or effective.get("color_accuracy") != "lc"
+        or effective.get("lc_flow_layout") != expected_layout
+        or not isinstance(validation, Mapping)
+        or validation.get("passes") is not True
+        or not isinstance(parameters, Mapping)
+        or not isinstance(parameters.get("payload"), Mapping)
+        or parameters.get("payload_sha256") != _canonical_sha256(parameters["payload"])
+        or not isinstance(prepared, Mapping)
+        or not _is_sha256(prepared.get("sha256"))
+        or not isinstance(generation, Mapping)
+        or generation.get("mode") != "recurrence"
+        or generation.get("generation_reused") is not False
+        or generation.get("specialized_flow_word") is not None
+        or not isinstance(model_source, Mapping)
+        or model_source.get("kind") != "explicit-prepared-model"
+        or model_source.get("file") != prepared
+        or model_source.get("compile_excluded_from_generation") is not True
+        or not isinstance(loaded, Mapping)
+    ):
+        raise ParityError(f"{expected_variant} numerical capture is inconsistent")
+    _validate_runtime_provenance_record(runtime_provenance, source=source)
+    payload_inventory = _validate_artifact_identity_record(artifact)
+    _validate_file_identity(prepared, label="prepared model")
+    _validate_artifact_payload_link(
+        artifact,
+        payload_inventory,
+        parameters.get("file"),
+        relative_path="model/parameters.json",
+        role="model-parameters",
+        process_id=None,
+        label="artifact parameters",
+    )
+    if expected_checkout is not None and source.get("checkout") != str(
+        expected_checkout.resolve()
+    ):
+        raise ParityError(f"{expected_variant} capture used the wrong checkout")
+    if expected_generation_request is not None and _canonical_sha256(
+        generation_request
+    ) != _canonical_sha256(expected_generation_request):
+        raise ParityError(
+            f"{expected_variant} capture used the wrong generation request"
+        )
+    if expected_artifact_root is not None:
+        raw_artifact_path = artifact.get("path")
+        if not isinstance(raw_artifact_path, str):
+            raise ParityError(f"{expected_variant} capture has no artifact path")
+        if Path(raw_artifact_path).resolve() != (
+            expected_artifact_root.resolve() / "artifact"
+        ):
+            raise ParityError(
+                f"{expected_variant} artifact is outside its assigned location"
+            )
+    fixture = validation.get("fixture")
+    selector = validation.get("selector_contract")
+    try:
+        normalized_points = (
+            tuple(
+                tuple(
+                    tuple(float(component) for component in momentum)
+                    for momentum in point
+                )
+                for point in fixture.get("points", ())
+            )
+            if isinstance(fixture, Mapping)
+            else ()
+        )
+    except (TypeError, ValueError) as error:
+        raise ParityError(
+            f"{expected_variant} validation fixture is not numerical"
+        ) from error
+    if (
+        not isinstance(fixture, Mapping)
+        or not isinstance(fixture.get("points"), list)
+        or isinstance(fixture.get("point_count"), bool)
+        or not isinstance(fixture.get("point_count"), int)
+        or fixture.get("point_count") != len(fixture["points"])
+        or not fixture["points"]
+        or fixture.get("points_sha256") != _canonical_sha256(normalized_points)
+        or fixture.get("points_sha256") != _canonical_sha256(fixture.get("points"))
+        or not isinstance(selector, Mapping)
+        or selector.get("contract_sha256")
+        != _canonical_sha256(
+            {key: entry for key, entry in selector.items() if key != "contract_sha256"}
+        )
+    ):
+        raise ParityError(f"{expected_variant} fixture or selector is invalid")
+    _validate_artifact_payload_link(
+        artifact,
+        payload_inventory,
+        fixture.get("file"),
+        relative_path=(f"processes/{artifact['process_id']}/validation-momenta.json"),
+        role="validation-momenta",
+        process_id=str(artifact["process_id"]),
+        label="validation fixture",
+    )
+    harness._validated_lane_validation_values(
+        validation,
+        {key: entry for key, entry in fixture.items() if key != "points"},
+        mode=expected_variant,
+    )
+    harness._validate_loaded_runtime_artifact_verification(
+        loaded.get("before_evaluation"),
+        expected_artifact_id=artifact["artifact_id"],
+        phase="before-numerical-parity-evaluation",
+    )
+    harness._validate_loaded_runtime_artifact_verification(
+        loaded.get("after_evaluation"),
+        expected_artifact_id=artifact["artifact_id"],
+        phase="after-numerical-parity-evaluation",
+    )
+    _semantic_selector_body(capture)
+    _validate_selector_semantics(capture, layout=expected_layout)
+    return capture
+
+
+def _semantic_selector_body(capture: Mapping[str, Any]) -> dict[str, object]:
+    try:
+        artifact = capture["artifact"]
+        validation = capture["validation"]
+        semantic = artifact["semantic_identity"]
+        body = {
+            "artifact_physical_color_flows": semantic["physical_color_flows"],
+            "artifact_physical_helicities": semantic["physical_helicities"],
+            "artifact_normalization": semantic["normalization"],
+            "artifact_manifest_model_identity": semantic["manifest_model_identity"],
+            "artifact_runtime_selector_semantics": semantic[
+                "runtime_selector_semantics"
+            ],
+            "artifact_reduction_ordering": semantic["reduction_ordering"],
+            "artifact_execution_reduction_identity": semantic[
+                "execution_reduction_identity"
+            ],
+            "artifact_generation_specialized_axes": semantic[
+                "generation_specialized_axes"
+            ],
+            "runtime_selector_contract": validation["selector_contract"],
+            "resolved_helicity_ids": validation["resolved_helicity_ids"],
+            "resolved_color_ids": validation["resolved_color_ids"],
+        }
+    except (KeyError, TypeError) as error:
+        raise ParityError("capture has incomplete selector semantics") from error
+    if any(value is None for value in body.values()):
+        raise ParityError("capture has incomplete selector semantics")
+    return body
+
+
+def _ordered_semantic_axis(
+    value: object,
+    *,
+    label: str,
+) -> tuple[list[str], list[Mapping[str, Any]]]:
+    if not isinstance(value, Mapping):
+        raise ParityError(f"capture has no {label} semantic axis")
+    count = value.get("count")
+    ordered_ids = value.get("ordered_ids")
+    ordered_entries = value.get("ordered_entries")
+    if (
+        isinstance(count, bool)
+        or not isinstance(count, int)
+        or count <= 0
+        or not isinstance(ordered_ids, list)
+        or len(ordered_ids) != count
+        or any(not isinstance(entry, str) or not entry for entry in ordered_ids)
+        or len(set(ordered_ids)) != count
+        or not isinstance(ordered_entries, list)
+        or len(ordered_entries) != count
+        or any(not isinstance(entry, Mapping) for entry in ordered_entries)
+        or [entry.get("id") for entry in ordered_entries if isinstance(entry, Mapping)]
+        != ordered_ids
+    ):
+        raise ParityError(f"capture has an invalid {label} semantic axis")
+    return list(ordered_ids), list(ordered_entries)
+
+
+def _validate_selector_semantics(
+    capture: Mapping[str, Any],
+    *,
+    layout: str,
+) -> None:
+    semantic = capture["artifact"]["semantic_identity"]
+    validation = capture["validation"]
+    selector = validation["selector_contract"]
+    if set(selector) != {
+        "workload",
+        "physical_color_ids",
+        "physical_helicity_ids",
+        "structural_zero_helicity_ids",
+        "selected_color_flow_ids",
+        "selected_helicity_ids",
+        "contract_sha256",
+    }:
+        raise ParityError("capture selector contract has an invalid schema")
+    color_ids, _color_entries = _ordered_semantic_axis(
+        semantic.get("physical_color_flows"),
+        label="color-flow",
+    )
+    helicity_ids, helicity_entries = _ordered_semantic_axis(
+        semantic.get("physical_helicities"),
+        label="helicity",
+    )
+    structural_zero_ids = [
+        str(entry["id"])
+        for entry in helicity_entries
+        if entry.get("structural_zero") is True
+    ]
+    common_matches = (
+        selector.get("physical_color_ids") == color_ids
+        and selector.get("physical_helicity_ids") == helicity_ids
+        and selector.get("structural_zero_helicity_ids") == structural_zero_ids
+    )
+    if layout == "topology-replay":
+        layout_matches = (
+            selector.get("workload") == "single-runtime-selected-flow/helicity-sum"
+            and selector.get("selected_color_flow_ids") == color_ids[:1]
+            and selector.get("selected_helicity_ids") == []
+            and validation.get("resolved_color_ids") == color_ids[:1]
+            and validation.get("resolved_helicity_ids") == helicity_ids
+        )
+    elif layout == "all-flow-union":
+        selected_helicity = next(
+            (
+                helicity_id
+                for helicity_id in helicity_ids
+                if helicity_id not in set(structural_zero_ids)
+            ),
+            None,
+        )
+        layout_matches = (
+            selected_helicity is not None
+            and selector.get("workload") == "all-flows/runtime-selected-single-helicity"
+            and selector.get("selected_color_flow_ids") == []
+            and selector.get("selected_helicity_ids") == [selected_helicity]
+            and validation.get("resolved_color_ids") == color_ids
+            and validation.get("resolved_helicity_ids") == [selected_helicity]
+        )
+    else:
+        layout_matches = False
+    if not common_matches or not layout_matches:
+        raise ParityError("capture selector contract disagrees with physical axes")
+
+
+def _comparison_errors(
+    baseline: Mapping[str, Any],
+    candidate: Mapping[str, Any],
+) -> list[str]:
+    errors: list[str] = []
+    baseline_validation = baseline["validation"]
+    candidate_validation = candidate["validation"]
+    if baseline["prepared_model"]["sha256"] != candidate["prepared_model"]["sha256"]:
+        errors.append("prepared model bytes differ")
+    if _canonical_sha256(baseline["generation_request"]) != _canonical_sha256(
+        candidate["generation_request"]
+    ):
+        errors.append("generation requests differ")
+    if (
+        baseline["parameters"]["payload_sha256"]
+        != candidate["parameters"]["payload_sha256"]
+    ):
+        errors.append("default model parameters differ")
+    if (
+        baseline_validation["fixture"]["points_sha256"]
+        != candidate_validation["fixture"]["points_sha256"]
+    ):
+        errors.append("deterministic phase-space fixtures differ")
+    if _canonical_sha256(_semantic_selector_body(baseline)) != _canonical_sha256(
+        _semantic_selector_body(candidate)
+    ):
+        errors.append("physical axes, selectors, normalization, or reduction differ")
+    if baseline_validation.get("passes") is not True:
+        errors.append("baseline selected/resolved self-comparison failed")
+    if candidate_validation.get("passes") is not True:
+        errors.append("candidate selected/resolved self-comparison failed")
+    return errors
+
+
+def _compare_captures(
+    baseline_value: object,
+    candidate_value: object,
+    *,
+    process_key: str,
+    process_expression: str,
+    layout: str,
+) -> dict[str, object]:
+    _validate_process_case(process_key, process_expression)
+    if layout not in LAYOUTS:
+        raise ParityError(f"unsupported LC flow layout: {layout}")
+    baseline = _validate_capture(
+        baseline_value,
+        expected_variant="baseline",
+        expected_process_key=process_key,
+        expected_process=process_expression,
+        expected_layout=layout,
+    )
+    candidate = _validate_capture(
+        candidate_value,
+        expected_variant="candidate",
+        expected_process_key=process_key,
+        expected_process=process_expression,
+        expected_layout=layout,
+    )
+    errors = _comparison_errors(baseline, candidate)
+    baseline_validation = baseline["validation"]
+    candidate_validation = candidate["validation"]
+    fixtures_match = (
+        baseline_validation["fixture"]["points_sha256"]
+        == candidate_validation["fixture"]["points_sha256"]
+    )
+    baseline_selector_sha256 = _canonical_sha256(_semantic_selector_body(baseline))
+    candidate_selector_sha256 = _canonical_sha256(_semantic_selector_body(candidate))
+    selectors_match = baseline_selector_sha256 == candidate_selector_sha256
+
+    pointwise: list[dict[str, object]] = []
+    baseline_totals = baseline_validation["selected_totals"]
+    candidate_totals = candidate_validation["selected_totals"]
+    if (
+        fixtures_match
+        and selectors_match
+        and len(baseline_totals) == len(candidate_totals)
+    ):
+        for point_index, (baseline_total, candidate_total) in enumerate(
+            zip(baseline_totals, candidate_totals, strict=True)
+        ):
+            pointwise.append(
+                _content_address(
+                    {
+                        "kind": "pyamplicol-recurrence-numerical-point-comparison",
+                        "schema_version": 1,
+                        "point_index": point_index,
+                        **_value_comparison(baseline_total, candidate_total),
+                    }
+                )
+            )
+    else:
+        errors.append("selected-total inventories cannot be paired")
+
+    componentwise: list[dict[str, object]] = []
+    baseline_components = baseline_validation["resolved_components"]
+    candidate_components = candidate_validation["resolved_components"]
+    helicity_ids = baseline_validation["resolved_helicity_ids"]
+    color_ids = baseline_validation["resolved_color_ids"]
+    component_count = len(helicity_ids) * len(color_ids)
+    components_pairable = (
+        fixtures_match
+        and selectors_match
+        and len(baseline_components) == len(candidate_components)
+        and all(
+            len(point) == component_count
+            for point in (*baseline_components, *candidate_components)
+        )
+    )
+    if components_pairable:
+        for point_index, (baseline_point, candidate_point) in enumerate(
+            zip(baseline_components, candidate_components, strict=True)
+        ):
+            for component_index, (baseline_component, candidate_component) in enumerate(
+                zip(baseline_point, candidate_point, strict=True)
+            ):
+                helicity_index, color_index = divmod(
+                    component_index,
+                    len(color_ids),
+                )
+                componentwise.append(
+                    _content_address(
+                        {
+                            "kind": (
+                                "pyamplicol-recurrence-numerical-"
+                                "resolved-component-comparison"
+                            ),
+                            "schema_version": 1,
+                            "point_index": point_index,
+                            "component_index": component_index,
+                            "helicity_id": helicity_ids[helicity_index],
+                            "color_id": color_ids[color_index],
+                            **_value_comparison(
+                                baseline_component,
+                                candidate_component,
+                            ),
+                        }
+                    )
+                )
+    else:
+        errors.append("resolved-component inventories cannot be paired")
+
+    selector_comparison = _content_address(
+        {
+            "kind": "pyamplicol-recurrence-numerical-selector-comparison",
+            "schema_version": 1,
+            "baseline_sha256": baseline_selector_sha256,
+            "candidate_sha256": candidate_selector_sha256,
+            "passes": selectors_match,
+        }
+    )
+    fixture_comparison = _content_address(
+        {
+            "kind": "pyamplicol-recurrence-numerical-fixture-comparison",
+            "schema_version": 1,
+            "baseline_points_sha256": baseline_validation["fixture"]["points_sha256"],
+            "candidate_points_sha256": candidate_validation["fixture"]["points_sha256"],
+            "point_count": len(baseline_validation["fixture"]["points"]),
+            "passes": fixtures_match,
+        }
+    )
+    passes = (
+        not errors
+        and fixture_comparison["passes"] is True
+        and selector_comparison["passes"] is True
+        and bool(pointwise)
+        and bool(componentwise)
+        and all(bool(item["passes"]) for item in pointwise)
+        and all(bool(item["passes"]) for item in componentwise)
+    )
+    return _content_address(
+        {
+            "kind": COMPARISON_KIND,
+            "schema_version": COMPARISON_SCHEMA,
+            "process_key": process_key,
+            "process_expression": process_expression,
+            "layout": layout,
+            "baseline_capture_sha256": baseline["content_sha256"],
+            "candidate_capture_sha256": candidate["content_sha256"],
+            "tolerances": {
+                "absolute": ABSOLUTE_TOLERANCE,
+                "relative": RELATIVE_TOLERANCE,
+            },
+            "fixture_comparison": fixture_comparison,
+            "selector_comparison": selector_comparison,
+            "parameter_comparison": _content_address(
+                {
+                    "kind": ("pyamplicol-recurrence-numerical-parameter-comparison"),
+                    "schema_version": 1,
+                    "baseline_sha256": baseline["parameters"]["payload_sha256"],
+                    "candidate_sha256": candidate["parameters"]["payload_sha256"],
+                    "passes": (
+                        baseline["parameters"]["payload_sha256"]
+                        == candidate["parameters"]["payload_sha256"]
+                    ),
+                }
+            ),
+            "pointwise_comparisons": pointwise,
+            "resolved_component_comparisons": componentwise,
+            "summary": {
+                "point_count": len(pointwise),
+                "resolved_component_count": len(componentwise),
+                "maximum_absolute_point_difference": max(
+                    (float(item["absolute_difference"]) for item in pointwise),
+                    default=None,
+                ),
+                "maximum_relative_point_difference": max(
+                    (float(item["relative_difference"]) for item in pointwise),
+                    default=None,
+                ),
+                "maximum_absolute_component_difference": max(
+                    (float(item["absolute_difference"]) for item in componentwise),
+                    default=None,
+                ),
+                "maximum_relative_component_difference": max(
+                    (float(item["relative_difference"]) for item in componentwise),
+                    default=None,
+                ),
+            },
+            "errors": errors,
+            "passes": passes,
+        }
+    )
+
+
+def _worker_environment(
+    variant: Variant,
+    capture_root: Path,
+) -> tuple[dict[str, str], dict[str, str]]:
+    temporary = capture_root / "tmp"
+    cache = capture_root / "cache"
+    pycache = capture_root / "pycache"
+    matplotlib = cache / "matplotlib"
+    for path in (temporary, cache, pycache, matplotlib):
+        path.mkdir(parents=True, exist_ok=False)
+    overrides = {
+        SOURCE_CHECKOUT_ENV: str(variant.checkout),
+        "MPLCONFIGDIR": str(matplotlib),
+        "PYTHONHASHSEED": "0",
+        "PYTHONNOUSERSITE": "1",
+        "PYTHONDONTWRITEBYTECODE": "1",
+        "PYTHONPYCACHEPREFIX": str(pycache),
+        "PYTHONPATH": str(variant.pythonpath),
+        "SYMBOLICA_HIDE_BANNER": "1",
+        "TEMP": str(temporary),
+        "TMP": str(temporary),
+        "TMPDIR": str(temporary),
+        "XDG_CACHE_HOME": str(cache),
+    }
+    environment = os.environ.copy()
+    environment.update(overrides)
+    return environment, overrides
+
+
+def _worker_command(
+    variant: Variant,
+    *,
+    capture_root: Path,
+    process_key: str,
+    process_expression: str,
+    layout: str,
+    validation_samples: int,
+    point_tile_size: int,
+    jit_optimization_level: int,
+) -> list[str]:
+    artifact = capture_root / "artifact"
+    capture_json = capture_root / "capture.json"
+    return [
+        str(variant.python),
+        str(WATCHDOG_PATH),
+        "--limit-gib",
+        f"{WATCHDOG_LIMIT_GIB:g}",
+        "--",
+        str(variant.python),
+        str(DRIVER_PATH),
+        "_worker",
+        "--variant",
+        variant.name,
+        "--process-key",
+        process_key,
+        "--process-expression",
+        process_expression,
+        "--layout",
+        layout,
+        "--prepared-model",
+        str(variant.prepared_model),
+        "--artifact",
+        str(artifact),
+        "--capture-json",
+        str(capture_json),
+        "--validation-samples",
+        str(validation_samples),
+        "--point-tile-size",
+        str(point_tile_size),
+        "--jit-optimization-level",
+        str(jit_optimization_level),
+    ]
+
+
+def _terminate_process_tree(process: subprocess.Popen[bytes]) -> None:
+    if process.poll() is not None:
+        return
+    if os.name == "posix":
+        try:
+            os.killpg(process.pid, signal.SIGTERM)
+        except ProcessLookupError:
+            return
+    else:
+        process.terminate()
+    try:
+        process.wait(timeout=5.0)
+        return
+    except subprocess.TimeoutExpired:
+        pass
+    if os.name == "posix":
+        try:
+            os.killpg(process.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            return
+    else:
+        process.kill()
+    process.wait()
+
+
+def _run_process(
+    command: Sequence[str],
+    *,
+    cwd: Path,
+    environment: Mapping[str, str],
+    stdout_path: Path,
+    stderr_path: Path,
+    timeout_seconds: float,
+) -> ProcessOutcome:
+    started = time.perf_counter()
+    process: subprocess.Popen[bytes] | None = None
+    try:
+        with stdout_path.open("wb") as stdout, stderr_path.open("wb") as stderr:
+            process = subprocess.Popen(
+                list(command),
+                cwd=cwd,
+                env=dict(environment),
+                stdout=stdout,
+                stderr=stderr,
+                start_new_session=(os.name == "posix"),
+            )
+            try:
+                exit_code = process.wait(timeout=timeout_seconds)
+            except subprocess.TimeoutExpired:
+                _terminate_process_tree(process)
+                return ProcessOutcome(
+                    exit_code=None,
+                    timed_out=True,
+                    wall_seconds=time.perf_counter() - started,
+                    error=f"capture timeout after {timeout_seconds:g} seconds",
+                )
+    except OSError as error:
+        if process is not None:
+            _terminate_process_tree(process)
+        return ProcessOutcome(
+            exit_code=None,
+            timed_out=False,
+            wall_seconds=time.perf_counter() - started,
+            error=f"{type(error).__name__}: {error}",
+        )
+    return ProcessOutcome(
+        exit_code=exit_code,
+        timed_out=False,
+        wall_seconds=time.perf_counter() - started,
+        error=None,
+    )
+
+
+def _capture_variant(
+    variant: Variant,
+    *,
+    capture_root: Path,
+    process_key: str,
+    process_expression: str,
+    layout: str,
+    validation_samples: int,
+    point_tile_size: int,
+    jit_optimization_level: int,
+    worker_timeout_seconds: float,
+) -> tuple[dict[str, Any], dict[str, object]]:
+    capture_root.mkdir(parents=True, exist_ok=False)
+    environment, overrides = _worker_environment(variant, capture_root)
+    stdout_path = capture_root / "stdout.log"
+    stderr_path = capture_root / "stderr.log"
+    command = _worker_command(
+        variant,
+        capture_root=capture_root,
+        process_key=process_key,
+        process_expression=process_expression,
+        layout=layout,
+        validation_samples=validation_samples,
+        point_tile_size=point_tile_size,
+        jit_optimization_level=jit_optimization_level,
+    )
+    started_at = _utc_now()
+    outcome = _run_process(
+        command,
+        cwd=variant.checkout,
+        environment=environment,
+        stdout_path=stdout_path,
+        stderr_path=stderr_path,
+        timeout_seconds=worker_timeout_seconds,
+    )
+    finished_at = _utc_now()
+    watchdog = ladder.parse_watchdog_log(stderr_path)
+    capture_path = capture_root / "capture.json"
+    if (
+        outcome.timed_out
+        or outcome.error is not None
+        or outcome.exit_code != 0
+        or watchdog.get("terminal_record") != "command-finished"
+        or watchdog.get("limit_gib") != WATCHDOG_LIMIT_GIB
+        or watchdog.get("limit_exceeded") is not False
+        or watchdog.get("child_exit_code") != 0
+        or not capture_path.is_file()
+    ):
+        raise ParityError(
+            f"{variant.name}/{process_key}/{layout} capture failed; "
+            f"exit={outcome.exit_code}, timed_out={outcome.timed_out}, "
+            f"error={outcome.error}, watchdog={watchdog.get('terminal_record')}"
+        )
+    capture = _validate_capture(
+        _json_object(capture_path, label="numerical capture"),
+        expected_variant=variant.name,
+        expected_process_key=process_key,
+        expected_process=process_expression,
+        expected_layout=layout,
+        expected_checkout=variant.checkout,
+        expected_artifact_root=capture_root,
+        expected_generation_request=_generation_request(
+            validation_samples=validation_samples,
+            point_tile_size=point_tile_size,
+            jit_optimization_level=jit_optimization_level,
+        ),
+    )
+    invocation = _content_address(
+        {
+            "kind": "pyamplicol-recurrence-numerical-capture-invocation",
+            "schema_version": 1,
+            "variant": variant.name,
+            "process_key": process_key,
+            "layout": layout,
+            "started_at_utc": started_at,
+            "finished_at_utc": finished_at,
+            "wall_seconds": outcome.wall_seconds,
+            "command": {
+                "argv": command,
+                "argv_sha256": _canonical_sha256(command),
+            },
+            "environment_overrides": overrides,
+            "stdout": _path_identity(stdout_path),
+            "stderr": _path_identity(stderr_path),
+            "capture_file": _path_identity(capture_path),
+            "watchdog": watchdog,
+        }
+    )
+    _atomic_write_json(capture_root / "invocation.json", invocation)
+    return capture, invocation
+
+
+def _comparison_file_name(process_key: str, layout: str) -> str:
+    return f"{process_key}__{layout.replace('-', '_')}.json"
+
+
+def _tooling_identity() -> dict[str, object]:
+    return {
+        "driver": _path_identity(DRIVER_PATH),
+        "watchdog": _path_identity(WATCHDOG_PATH),
+        "recurrence_harness": _path_identity(
+            DRIVER_ROOT / "tools" / "developer" / "recurrence_z6g_benchmark.py"
+        ),
+        "campaign_ladder": _path_identity(
+            DRIVER_ROOT / "tools" / "developer" / "recurrence_generation_ab_ladder.py"
+        ),
+    }
+
+
+def _pin_variant_binding(
+    bindings: dict[str, dict[str, object]],
+    *,
+    variant: Variant,
+    capture: Mapping[str, Any],
+    expected_model: Mapping[str, object],
+    expected_generation_request: Mapping[str, object],
+    expected_source: Mapping[str, object],
+) -> None:
+    if (
+        _canonical_sha256(capture["prepared_model"])
+        != _canonical_sha256(expected_model)
+        or _canonical_sha256(capture["source"]) != _canonical_sha256(expected_source)
+        or _canonical_sha256(capture["generation_request"])
+        != _canonical_sha256(expected_generation_request)
+    ):
+        raise ParityError(
+            f"{variant.name} capture escaped its configured source binding"
+        )
+    observed_binding = {
+        "source": capture["source"],
+        "runtime_provenance": capture["runtime_provenance"],
+        "prepared_model": capture["prepared_model"],
+    }
+    expected_binding = bindings.setdefault(variant.name, observed_binding)
+    if _canonical_sha256(observed_binding) != _canonical_sha256(expected_binding):
+        raise ParityError(
+            f"{variant.name} source or runtime changed during the campaign"
+        )
+
+
+def run(arguments: argparse.Namespace) -> dict[str, object]:
+    output_root = _resolve_output_root(arguments.output_root)
+    baseline = _variant(
+        "baseline",
+        python=arguments.baseline_python,
+        checkout=arguments.baseline_checkout,
+        pythonpath=arguments.baseline_pythonpath,
+        prepared_model=arguments.baseline_prepared_model,
+    )
+    candidate = _variant(
+        "candidate",
+        python=arguments.candidate_python,
+        checkout=arguments.candidate_checkout,
+        pythonpath=arguments.candidate_pythonpath,
+        prepared_model=arguments.candidate_prepared_model,
+    )
+    preflight_sources = {
+        "baseline": _preflight_variant_source(baseline),
+        "candidate": _preflight_variant_source(candidate),
+    }
+    baseline_model = _path_identity(baseline.prepared_model)
+    candidate_model = _path_identity(candidate.prepared_model)
+    if baseline_model["sha256"] != candidate_model["sha256"]:
+        raise ParityError("baseline and candidate prepared-model bytes differ")
+    if baseline.checkout == candidate.checkout:
+        raise ParityError("baseline and candidate checkouts must be distinct")
+    if not WATCHDOG_PATH.is_file():
+        raise ParityError(f"audited memory watchdog is missing: {WATCHDOG_PATH}")
+
+    tooling_before = _tooling_identity()
+    expected_generation_request = _generation_request(
+        validation_samples=arguments.validation_samples,
+        point_tile_size=arguments.point_tile_size,
+        jit_optimization_level=arguments.jit_optimization_level,
+    )
+    output_root.mkdir(parents=True, exist_ok=False)
+    started_at = _utc_now()
+    started = time.perf_counter()
+    comparisons: list[dict[str, object]] = []
+    capture_records: list[dict[str, object]] = []
+    variant_bindings: dict[str, dict[str, object]] = {}
+    sequence_index = 0
+    for case_index, (process_key, process_expression) in enumerate(PROCESS_CASES):
+        for layout in LAYOUTS:
+            variants = (
+                (baseline, candidate)
+                if (case_index + LAYOUTS.index(layout)) % 2 == 0
+                else (candidate, baseline)
+            )
+            captures: dict[str, dict[str, Any]] = {}
+            invocations: dict[str, dict[str, object]] = {}
+            for variant in variants:
+                capture_root = (
+                    output_root
+                    / "captures"
+                    / f"{sequence_index:02d}-{process_key}-{layout}"
+                    / variant.name
+                )
+                capture, invocation = _capture_variant(
+                    variant,
+                    capture_root=capture_root,
+                    process_key=process_key,
+                    process_expression=process_expression,
+                    layout=layout,
+                    validation_samples=arguments.validation_samples,
+                    point_tile_size=arguments.point_tile_size,
+                    jit_optimization_level=arguments.jit_optimization_level,
+                    worker_timeout_seconds=arguments.worker_timeout,
+                )
+                captures[variant.name] = capture
+                invocations[variant.name] = invocation
+                expected_model = (
+                    baseline_model if variant.name == "baseline" else candidate_model
+                )
+                _pin_variant_binding(
+                    variant_bindings,
+                    variant=variant,
+                    capture=capture,
+                    expected_model=expected_model,
+                    expected_generation_request=expected_generation_request,
+                    expected_source=preflight_sources[variant.name],
+                )
+            comparison = _compare_captures(
+                captures["baseline"],
+                captures["candidate"],
+                process_key=process_key,
+                process_expression=process_expression,
+                layout=layout,
+            )
+            comparison_path = (
+                output_root / "comparisons" / _comparison_file_name(process_key, layout)
+            )
+            _atomic_write_json(comparison_path, comparison)
+            comparisons.append(
+                {
+                    "process_key": process_key,
+                    "process_expression": process_expression,
+                    "layout": layout,
+                    "passes": comparison["passes"],
+                    "comparison_file": _path_identity(comparison_path),
+                    "comparison_content_sha256": comparison["content_sha256"],
+                }
+            )
+            capture_records.append(
+                {
+                    "process_key": process_key,
+                    "layout": layout,
+                    "order": [variant.name for variant in variants],
+                    "baseline_capture_sha256": captures["baseline"]["content_sha256"],
+                    "candidate_capture_sha256": captures["candidate"]["content_sha256"],
+                    "baseline_invocation_sha256": invocations["baseline"][
+                        "content_sha256"
+                    ],
+                    "candidate_invocation_sha256": invocations["candidate"][
+                        "content_sha256"
+                    ],
+                }
+            )
+            sequence_index += 1
+    tooling_after = _tooling_identity()
+    if _canonical_sha256(tooling_after) != _canonical_sha256(tooling_before):
+        raise ParityError("validator tooling changed during the campaign")
+    final_sources = {
+        "baseline": _preflight_variant_source(baseline),
+        "candidate": _preflight_variant_source(candidate),
+    }
+    if _canonical_sha256(final_sources) != _canonical_sha256(preflight_sources):
+        raise ParityError("baseline or candidate source changed during the campaign")
+    finished_at = _utc_now()
+    result = _content_address(
+        {
+            "kind": RESULT_KIND,
+            "schema_version": RESULT_SCHEMA,
+            "status": (
+                "passed"
+                if all(item["passes"] is True for item in comparisons)
+                else "failed"
+            ),
+            "passes": all(item["passes"] is True for item in comparisons),
+            "started_at_utc": started_at,
+            "finished_at_utc": finished_at,
+            "wall_seconds": time.perf_counter() - started,
+            "configuration": {
+                "processes": [
+                    {
+                        "key": process_key,
+                        "expression": process_expression,
+                    }
+                    for process_key, process_expression in PROCESS_CASES
+                ],
+                "layouts": list(LAYOUTS),
+                "validation_samples": arguments.validation_samples,
+                "validation_seed": harness.VALIDATION_SEED,
+                "point_tile_size": arguments.point_tile_size,
+                "jit_optimization_level": arguments.jit_optimization_level,
+                "worker_timeout_seconds": arguments.worker_timeout,
+                "absolute_tolerance": ABSOLUTE_TOLERANCE,
+                "relative_tolerance": RELATIVE_TOLERANCE,
+                "watchdog_limit_gib": WATCHDOG_LIMIT_GIB,
+                "generation_request_sha256": _canonical_sha256(
+                    expected_generation_request
+                ),
+            },
+            "tooling": tooling_before,
+            "variants": {
+                "baseline": {
+                    "python": str(baseline.python),
+                    "checkout": str(baseline.checkout),
+                    "source": preflight_sources["baseline"],
+                    "pythonpath": str(baseline.pythonpath),
+                    "prepared_model": baseline_model,
+                },
+                "candidate": {
+                    "python": str(candidate.python),
+                    "checkout": str(candidate.checkout),
+                    "source": preflight_sources["candidate"],
+                    "pythonpath": str(candidate.pythonpath),
+                    "prepared_model": candidate_model,
+                },
+            },
+            "capture_records": capture_records,
+            "variant_bindings": {
+                name: {
+                    **binding,
+                    "binding_sha256": _canonical_sha256(binding),
+                }
+                for name, binding in sorted(variant_bindings.items())
+            },
+            "comparisons": comparisons,
+            "comparison_count": len(comparisons),
+            "passing_comparison_count": sum(
+                item["passes"] is True for item in comparisons
+            ),
+        }
+    )
+    _atomic_write_json(output_root / "result.json", result)
+    return result
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--baseline-python", type=Path, required=True)
+    result.add_argument("--candidate-python", type=Path, required=True)
+    result.add_argument("--baseline-checkout", type=Path, required=True)
+    result.add_argument("--candidate-checkout", type=Path, required=True)
+    result.add_argument("--baseline-pythonpath", type=Path, required=True)
+    result.add_argument("--candidate-pythonpath", type=Path, required=True)
+    result.add_argument("--baseline-prepared-model", type=Path, required=True)
+    result.add_argument("--candidate-prepared-model", type=Path, required=True)
+    result.add_argument("--output-root", type=Path, required=True)
+    result.add_argument(
+        "--validation-samples",
+        type=_positive_int,
+        default=DEFAULT_VALIDATION_SAMPLES,
+    )
+    result.add_argument(
+        "--point-tile-size",
+        type=_positive_int,
+        default=DEFAULT_POINT_TILE_SIZE,
+    )
+    result.add_argument(
+        "--jit-optimization-level",
+        type=int,
+        choices=(0, 1, 2, 3),
+        default=DEFAULT_JIT_OPTIMIZATION_LEVEL,
+    )
+    result.add_argument(
+        "--worker-timeout",
+        type=_positive_float,
+        default=DEFAULT_WORKER_TIMEOUT_SECONDS,
+    )
+    return result
+
+
+def _worker_parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(add_help=False)
+    result.add_argument("--variant", choices=("baseline", "candidate"), required=True)
+    result.add_argument("--process-key", required=True)
+    result.add_argument("--process-expression", required=True)
+    result.add_argument("--layout", choices=LAYOUTS, required=True)
+    result.add_argument("--prepared-model", type=Path, required=True)
+    result.add_argument("--artifact", type=Path, required=True)
+    result.add_argument("--capture-json", type=Path, required=True)
+    result.add_argument("--validation-samples", type=_positive_int, required=True)
+    result.add_argument("--point-tile-size", type=_positive_int, required=True)
+    result.add_argument(
+        "--jit-optimization-level",
+        type=int,
+        choices=(0, 1, 2, 3),
+        required=True,
+    )
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    values = list(sys.argv[1:] if argv is None else argv)
+    try:
+        if values[:1] == ["_worker"]:
+            arguments = _worker_parser().parse_args(values[1:])
+            capture = _run_capture_worker(arguments)
+            print(
+                json.dumps(
+                    {
+                        "kind": capture["kind"],
+                        "content_sha256": capture["content_sha256"],
+                        "passes": capture["validation"]["passes"],
+                    },
+                    allow_nan=False,
+                    sort_keys=True,
+                )
+            )
+            return 0
+        arguments = parser().parse_args(values)
+        result = run(arguments)
+    except (
+        ParityError,
+        harness.HarnessError,
+        ImportError,
+        OSError,
+        RuntimeError,
+        ValueError,
+        json.JSONDecodeError,
+    ) as error:
+        print(f"recurrence-numerical-ab-parity: {error}", file=sys.stderr)
+        return 2
+    print(
+        json.dumps(
+            {
+                "kind": result["kind"],
+                "result_json": str(
+                    arguments.output_root.expanduser().resolve() / "result.json"
+                ),
+                "status": result["status"],
+                "passes": result["passes"],
+                "content_sha256": result["content_sha256"],
+            },
+            allow_nan=False,
+            sort_keys=True,
+        )
+    )
+    return 0 if result["passes"] is True else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/recurrence_runtime_ab_analyzer.py b/pyamplicol/tools/developer/recurrence_runtime_ab_analyzer.py
new file mode 100644
index 0000000000..1f88069c48
--- /dev/null
+++ b/pyamplicol/tools/developer/recurrence_runtime_ab_analyzer.py
@@ -0,0 +1,802 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Analyze the recurrence runtime no-regression A/B gate.
+
+The input is a ``recurrence_generation_ab_ladder.py`` campaign.  Timing
+observations are paired by outer A/B pair and inner subprocess round, so host
+drift is not silently treated as independent noise.  The candidate/baseline
+ratio is analyzed in log space with a one-sided 95% Student-t bound.
+
+This analyzer deliberately accepts only runtime-worker RSS evidence.  The
+generation worker and outer watchdog both cover artifact generation and cannot
+establish runtime-only memory use.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import statistics
+import sys
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+ALLOWED_OUTPUT_PARENT = ROOT / ".artifacts" / "recurrence-generation-opt"
+
+CAMPAIGN_KIND = "pyamplicol-recurrence-generation-ab-ladder"
+CAMPAIGN_SCHEMA_VERSION = 1
+RESULT_KIND = "pyamplicol-recurrence-runtime-ab-analysis"
+RESULT_SCHEMA_VERSION = 1
+LAYOUTS = ("topology-replay", "all-flow-union")
+DEFAULT_MULTIPLICITIES = (6, 7)
+DEFAULT_BATCH_SIZES = (1, 128, 1024)
+MINIMUM_PAIRED_SAMPLES = 7
+MAXIMUM_PAIRED_SAMPLES = 21
+CONFIDENCE_LEVEL = 0.95
+NO_SLOWDOWN_RATIO = 1.0
+DEFAULT_MATERIAL_RSS_RATIO = 1.10
+
+# One-sided 95% Student-t quantiles.  The gate admits 7..21 paired
+# observations, so only df=6..20 are reachable.  Values are fixed here to
+# avoid introducing a scientific-library dependency into the developer tool.
+_ONE_SIDED_T_95 = {
+    6: 1.9431802805153022,
+    7: 1.894578605061305,
+    8: 1.8595480375228424,
+    9: 1.8331129326536337,
+    10: 1.8124611228107335,
+    11: 1.7958848187036691,
+    12: 1.782287555649159,
+    13: 1.7709333959867988,
+    14: 1.7613101357748562,
+    15: 1.7530503556925547,
+    16: 1.74588367627624,
+    17: 1.7396067260750672,
+    18: 1.734063606617536,
+    19: 1.729132811521367,
+    20: 1.7247182429207863,
+}
+
+
+class RuntimeABError(RuntimeError):
+    """Raised when runtime A/B evidence violates its contract."""
+
+
+@dataclass(frozen=True, slots=True)
+class WorkerObservation:
+    """One baseline/candidate worker pair from the same schedule round."""
+
+    pair_index: int
+    round_index: int
+    baseline_order_in_pair: int
+    candidate_order_in_pair: int
+    baseline_seconds_per_point: float
+    candidate_seconds_per_point: float
+    baseline_runtime_peak_rss_bytes: int | None
+    candidate_runtime_peak_rss_bytes: int | None
+
+
+def _mapping(value: object, *, description: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise RuntimeABError(f"{description} must be a JSON object")
+    return value
+
+
+def _list(value: object, *, description: str) -> list[Any]:
+    if not isinstance(value, list):
+        raise RuntimeABError(f"{description} must be a JSON array")
+    return value
+
+
+def _positive_int(value: object, *, description: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+        raise RuntimeABError(f"{description} must be a positive integer")
+    return value
+
+
+def _nonnegative_int(value: object, *, description: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise RuntimeABError(f"{description} must be a nonnegative integer")
+    return value
+
+
+def _positive_float(value: object, *, description: str) -> float:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (float, int))
+        or not math.isfinite(float(value))
+        or float(value) <= 0.0
+    ):
+        raise RuntimeABError(f"{description} must be a positive finite number")
+    return float(value)
+
+
+def _runtime_peak_rss_bytes(sample: Mapping[str, Any]) -> int | None:
+    """Return only the profile worker's post-runtime high-water evidence."""
+
+    normalized = sample.get("runtime_peak_rss_bytes")
+    peak = sample.get("peak_rss_after_profile")
+    observed: int | None = None
+    if normalized is not None:
+        observed = _positive_int(
+            normalized,
+            description="runtime_peak_rss_bytes",
+        )
+    if peak is not None:
+        record = _mapping(
+            peak,
+            description="profile worker peak_rss_after_profile",
+        )
+        source = record.get("source")
+        if source != "resource.getrusage":
+            raise RuntimeABError("profile worker RSS must come from resource.getrusage")
+        record_observed = _positive_int(
+            record.get("observed_lower_bound_bytes"),
+            description=("profile worker peak_rss_after_profile observed lower bound"),
+        )
+        if observed is not None and observed != record_observed:
+            raise RuntimeABError("normalized and structured runtime RSS disagree")
+        observed = record_observed
+    return observed
+
+
+def paired_log_ratio_interval(
+    baseline: Sequence[float | int],
+    candidate: Sequence[float | int],
+) -> dict[str, float | int | str]:
+    """Return a deterministic paired one-sided 95% log-ratio interval."""
+
+    if len(baseline) != len(candidate):
+        raise RuntimeABError("baseline and candidate sample counts differ")
+    sample_count = len(baseline)
+    if not MINIMUM_PAIRED_SAMPLES <= sample_count <= MAXIMUM_PAIRED_SAMPLES:
+        raise RuntimeABError(
+            "paired sample count must remain between 7 and 21 inclusive"
+        )
+    log_ratios: list[float] = []
+    baseline_values: list[float] = []
+    candidate_values: list[float] = []
+    for index, (baseline_value, candidate_value) in enumerate(
+        zip(baseline, candidate, strict=True)
+    ):
+        baseline_float = _positive_float(
+            baseline_value,
+            description=f"baseline observation {index}",
+        )
+        candidate_float = _positive_float(
+            candidate_value,
+            description=f"candidate observation {index}",
+        )
+        baseline_values.append(baseline_float)
+        candidate_values.append(candidate_float)
+        log_ratios.append(math.log(candidate_float / baseline_float))
+
+    mean_log_ratio = statistics.fmean(log_ratios)
+    standard_deviation = statistics.stdev(log_ratios)
+    standard_error = standard_deviation / math.sqrt(sample_count)
+    critical = _ONE_SIDED_T_95[sample_count - 1]
+    half_width = critical * standard_error
+    return {
+        "statistics_contract": ("paired-log-ratio-student-t-one-sided-95-v1"),
+        "confidence_level": CONFIDENCE_LEVEL,
+        "sample_count": sample_count,
+        "degrees_of_freedom": sample_count - 1,
+        "student_t_critical": critical,
+        "candidate_over_baseline_geometric_mean": math.exp(mean_log_ratio),
+        "candidate_over_baseline_lower_confidence_bound": math.exp(
+            mean_log_ratio - half_width
+        ),
+        "candidate_over_baseline_upper_confidence_bound": math.exp(
+            mean_log_ratio + half_width
+        ),
+        "baseline_median": statistics.median(baseline_values),
+        "candidate_median": statistics.median(candidate_values),
+        "candidate_over_baseline_median_ratio": (
+            statistics.median(candidate_values) / statistics.median(baseline_values)
+        ),
+        "log_ratio_sample_standard_deviation": standard_deviation,
+        "log_ratio_standard_error": standard_error,
+    }
+
+
+def _gate_decision(
+    interval: Mapping[str, object],
+    *,
+    allowed_ratio: float,
+    failure_label: str,
+) -> dict[str, object]:
+    sample_count = _positive_int(
+        interval.get("sample_count"),
+        description="confidence interval sample count",
+    )
+    upper = _positive_float(
+        interval.get("candidate_over_baseline_upper_confidence_bound"),
+        description="candidate/baseline upper confidence bound",
+    )
+    lower = _positive_float(
+        interval.get("candidate_over_baseline_lower_confidence_bound"),
+        description="candidate/baseline lower confidence bound",
+    )
+    if upper <= allowed_ratio:
+        status = "passed"
+    elif lower > allowed_ratio:
+        status = failure_label
+    elif sample_count < MAXIMUM_PAIRED_SAMPLES:
+        status = "needs-more-samples"
+    else:
+        status = "rejected-inconclusive"
+    return {
+        "status": status,
+        "passes": status == "passed",
+        "allowed_candidate_over_baseline_ratio": allowed_ratio,
+        "additional_paired_samples_allowed": max(
+            0,
+            MAXIMUM_PAIRED_SAMPLES - sample_count,
+        ),
+    }
+
+
+def _measurement(
+    sample: Mapping[str, Any],
+    *,
+    batch_size: int,
+) -> Mapping[str, Any]:
+    telemetry = _mapping(sample.get("telemetry"), description="sample telemetry")
+    profile = _mapping(
+        telemetry.get("runtime_profile"),
+        description="sample recurrence runtime profile",
+    )
+    measurements = _list(
+        profile.get("measurements"),
+        description="runtime profile measurements",
+    )
+    matches = [
+        _mapping(item, description="runtime profile measurement")
+        for item in measurements
+        if isinstance(item, Mapping) and item.get("batch_size") == batch_size
+    ]
+    if len(matches) != 1:
+        raise RuntimeABError(
+            f"runtime profile must contain exactly one batch {batch_size} measurement"
+        )
+    measurement = matches[0]
+    subprocess_samples = _list(
+        measurement.get("subprocess_samples"),
+        description=f"batch {batch_size} subprocess samples",
+    )
+    sample_count = _positive_int(
+        measurement.get("sample_count"),
+        description=f"batch {batch_size} sample count",
+    )
+    if sample_count != len(subprocess_samples):
+        raise RuntimeABError(
+            f"batch {batch_size} sample count does not match its worker list"
+        )
+    if measurement.get("interrupted") is not False:
+        raise RuntimeABError(f"batch {batch_size} measurement was interrupted")
+    return measurement
+
+
+def _worker_rounds(
+    measurement: Mapping[str, Any],
+    *,
+    batch_size: int,
+) -> dict[int, Mapping[str, Any]]:
+    raw_samples = _list(
+        measurement.get("subprocess_samples"),
+        description=f"batch {batch_size} subprocess samples",
+    )
+    rounds: dict[int, Mapping[str, Any]] = {}
+    schedule_indices: set[int] = set()
+    for raw in raw_samples:
+        sample = _mapping(raw, description="runtime worker sample")
+        round_index = _nonnegative_int(
+            sample.get("round"),
+            description="runtime worker round",
+        )
+        schedule_index = _nonnegative_int(
+            sample.get("schedule_index"),
+            description="runtime worker schedule index",
+        )
+        if round_index in rounds:
+            raise RuntimeABError(
+                f"batch {batch_size} duplicates worker round {round_index}"
+            )
+        if schedule_index in schedule_indices:
+            raise RuntimeABError(
+                f"batch {batch_size} reuses worker schedule index {schedule_index}"
+            )
+        _positive_float(
+            sample.get("wall_seconds_per_point"),
+            description="runtime worker wall seconds per point",
+        )
+        if sample.get("interrupted") is not False:
+            raise RuntimeABError("runtime worker sample was interrupted")
+        rounds[round_index] = sample
+        schedule_indices.add(schedule_index)
+    if set(rounds) != set(range(len(raw_samples))):
+        raise RuntimeABError(
+            f"batch {batch_size} worker rounds are not contiguous from zero"
+        )
+    return rounds
+
+
+def _sample_variant(sample: Mapping[str, Any]) -> str:
+    variant = sample.get("variant")
+    if variant not in {"baseline", "candidate"}:
+        raise RuntimeABError("campaign sample has an invalid A/B variant")
+    return str(variant)
+
+
+def _cell_observations(
+    samples: Sequence[Mapping[str, Any]],
+    *,
+    multiplicity: int,
+    layout: str,
+    batch_size: int,
+) -> list[WorkerObservation]:
+    pair_members: dict[int, dict[str, Mapping[str, Any]]] = {}
+    for sample in samples:
+        if sample.get("multiplicity") != multiplicity or sample.get("layout") != layout:
+            continue
+        if sample.get("runtime_enabled") is not True:
+            raise RuntimeABError(
+                f"n={multiplicity}/{layout} sample did not enable runtime profiling"
+            )
+        if sample.get("status") != "passed":
+            raise RuntimeABError(
+                f"n={multiplicity}/{layout} has a non-passing runtime sample"
+            )
+        pair_index = _nonnegative_int(
+            sample.get("pair_index"),
+            description="outer A/B pair index",
+        )
+        variant = _sample_variant(sample)
+        members = pair_members.setdefault(pair_index, {})
+        if variant in members:
+            raise RuntimeABError(
+                f"outer pair {pair_index} duplicates the {variant} sample"
+            )
+        members[variant] = sample
+
+    observations: list[WorkerObservation] = []
+    previous_first_variant: str | None = None
+    for pair_index, members in sorted(pair_members.items()):
+        if set(members) != {"baseline", "candidate"}:
+            raise RuntimeABError(
+                f"outer pair {pair_index} is missing a baseline or candidate"
+            )
+        baseline_sample = members["baseline"]
+        candidate_sample = members["candidate"]
+        baseline_order = _nonnegative_int(
+            baseline_sample.get("order_in_pair"),
+            description="baseline order in outer pair",
+        )
+        candidate_order = _nonnegative_int(
+            candidate_sample.get("order_in_pair"),
+            description="candidate order in outer pair",
+        )
+        if {baseline_order, candidate_order} != {0, 1}:
+            raise RuntimeABError(
+                f"outer pair {pair_index} does not contain positions zero and one"
+            )
+        first_variant = "baseline" if baseline_order == 0 else "candidate"
+        if previous_first_variant == first_variant:
+            raise RuntimeABError(
+                "outer baseline/candidate order did not alternate between pairs"
+            )
+        previous_first_variant = first_variant
+
+        baseline_rounds = _worker_rounds(
+            _measurement(baseline_sample, batch_size=batch_size),
+            batch_size=batch_size,
+        )
+        candidate_rounds = _worker_rounds(
+            _measurement(candidate_sample, batch_size=batch_size),
+            batch_size=batch_size,
+        )
+        if set(baseline_rounds) != set(candidate_rounds):
+            raise RuntimeABError(f"outer pair {pair_index} has unmatched worker rounds")
+        for round_index in sorted(baseline_rounds):
+            baseline_worker = baseline_rounds[round_index]
+            candidate_worker = candidate_rounds[round_index]
+            observations.append(
+                WorkerObservation(
+                    pair_index=pair_index,
+                    round_index=round_index,
+                    baseline_order_in_pair=baseline_order,
+                    candidate_order_in_pair=candidate_order,
+                    baseline_seconds_per_point=_positive_float(
+                        baseline_worker.get("wall_seconds_per_point"),
+                        description="baseline runtime wall seconds per point",
+                    ),
+                    candidate_seconds_per_point=_positive_float(
+                        candidate_worker.get("wall_seconds_per_point"),
+                        description="candidate runtime wall seconds per point",
+                    ),
+                    baseline_runtime_peak_rss_bytes=_runtime_peak_rss_bytes(
+                        baseline_worker
+                    ),
+                    candidate_runtime_peak_rss_bytes=_runtime_peak_rss_bytes(
+                        candidate_worker
+                    ),
+                )
+            )
+    return observations
+
+
+def _cell_result(
+    observations: Sequence[WorkerObservation],
+    *,
+    multiplicity: int,
+    layout: str,
+    batch_size: int,
+    material_rss_ratio: float,
+) -> dict[str, object]:
+    if not observations:
+        return {
+            "multiplicity": multiplicity,
+            "layout": layout,
+            "batch_size": batch_size,
+            "status": "missing",
+            "passes": False,
+            "paired_sample_count": 0,
+        }
+    if len(observations) > MAXIMUM_PAIRED_SAMPLES:
+        raise RuntimeABError(
+            f"n={multiplicity}/{layout}/batch={batch_size} exceeds the 21-pair cap"
+        )
+    baseline_timing = [
+        observation.baseline_seconds_per_point for observation in observations
+    ]
+    candidate_timing = [
+        observation.candidate_seconds_per_point for observation in observations
+    ]
+    timing_interval = paired_log_ratio_interval(
+        baseline_timing,
+        candidate_timing,
+    )
+    timing_gate = _gate_decision(
+        timing_interval,
+        allowed_ratio=NO_SLOWDOWN_RATIO,
+        failure_label="rejected-supported-slowdown",
+    )
+
+    rss_complete = all(
+        observation.baseline_runtime_peak_rss_bytes is not None
+        and observation.candidate_runtime_peak_rss_bytes is not None
+        for observation in observations
+    )
+    if rss_complete:
+        baseline_rss = [
+            int(observation.baseline_runtime_peak_rss_bytes)
+            for observation in observations
+        ]
+        candidate_rss = [
+            int(observation.candidate_runtime_peak_rss_bytes)
+            for observation in observations
+        ]
+        rss_interval: dict[str, object] | None = paired_log_ratio_interval(
+            baseline_rss,
+            candidate_rss,
+        )
+        rss_gate: dict[str, object] = _gate_decision(
+            rss_interval,
+            allowed_ratio=material_rss_ratio,
+            failure_label="rejected-supported-material-rss-increase",
+        )
+    else:
+        rss_interval = None
+        rss_gate = {
+            "status": "missing-runtime-only-rss",
+            "passes": False,
+            "allowed_candidate_over_baseline_ratio": material_rss_ratio,
+            "missing_paired_observation_count": sum(
+                observation.baseline_runtime_peak_rss_bytes is None
+                or observation.candidate_runtime_peak_rss_bytes is None
+                for observation in observations
+            ),
+        }
+
+    statuses = {str(timing_gate["status"]), str(rss_gate["status"])}
+    if any(status.startswith("rejected") for status in statuses):
+        status = "rejected"
+    elif "missing-runtime-only-rss" in statuses:
+        status = "incomplete-runtime-rss"
+    elif "needs-more-samples" in statuses:
+        status = "needs-more-samples"
+    else:
+        status = "passed"
+    return {
+        "multiplicity": multiplicity,
+        "layout": layout,
+        "batch_size": batch_size,
+        "status": status,
+        "passes": status == "passed",
+        "paired_sample_count": len(observations),
+        "pairing_contract": "outer-pair-index-and-inner-round-v1",
+        "observations": [
+            {
+                "pair_index": observation.pair_index,
+                "round": observation.round_index,
+                "baseline_order_in_pair": observation.baseline_order_in_pair,
+                "candidate_order_in_pair": observation.candidate_order_in_pair,
+                "baseline_seconds_per_point": (observation.baseline_seconds_per_point),
+                "candidate_seconds_per_point": (
+                    observation.candidate_seconds_per_point
+                ),
+                "baseline_runtime_peak_rss_bytes": (
+                    observation.baseline_runtime_peak_rss_bytes
+                ),
+                "candidate_runtime_peak_rss_bytes": (
+                    observation.candidate_runtime_peak_rss_bytes
+                ),
+            }
+            for observation in observations
+        ],
+        "timing": {
+            "interval": timing_interval,
+            "gate": timing_gate,
+        },
+        "runtime_rss": {
+            "evidence_contract": ("profile-worker-post-runtime-resource-high-water-v1"),
+            "interval": rss_interval,
+            "gate": rss_gate,
+        },
+    }
+
+
+def analyze_campaign(
+    campaign: Mapping[str, Any],
+    *,
+    multiplicities: Sequence[int] = DEFAULT_MULTIPLICITIES,
+    layouts: Sequence[str] = LAYOUTS,
+    batch_sizes: Sequence[int] = DEFAULT_BATCH_SIZES,
+    material_rss_ratio: float = DEFAULT_MATERIAL_RSS_RATIO,
+) -> dict[str, object]:
+    """Analyze every requested runtime cell and fail closed on missing evidence."""
+
+    if (
+        campaign.get("kind") != CAMPAIGN_KIND
+        or campaign.get("schema_version") != CAMPAIGN_SCHEMA_VERSION
+    ):
+        raise RuntimeABError("input is not a supported recurrence A/B campaign")
+    if not math.isfinite(material_rss_ratio) or material_rss_ratio < 1.0:
+        raise RuntimeABError("material RSS ratio must be finite and at least one")
+
+    requested_multiplicities = tuple(dict.fromkeys(multiplicities))
+    requested_layouts = tuple(dict.fromkeys(layouts))
+    requested_batches = tuple(dict.fromkeys(batch_sizes))
+    if not requested_multiplicities or not requested_layouts or not requested_batches:
+        raise RuntimeABError("the requested runtime matrix must be non-empty")
+    if any(
+        isinstance(value, bool) or not isinstance(value, int) or value <= 0
+        for value in (*requested_multiplicities, *requested_batches)
+    ):
+        raise RuntimeABError("multiplicities and batch sizes must be positive")
+    if any(layout not in LAYOUTS for layout in requested_layouts):
+        raise RuntimeABError("the runtime matrix contains an unsupported LC layout")
+
+    configuration = _mapping(
+        campaign.get("configuration"),
+        description="campaign configuration",
+    )
+    configuration_errors: list[str] = []
+    if configuration.get("warmup_runs") != 2:
+        configuration_errors.append("warmup_runs must equal 2")
+    if configuration.get("target_runtime_seconds") != 5.0:
+        configuration_errors.append("target_runtime_seconds must equal 5")
+    minimum_samples = configuration.get("minimum_samples")
+    if (
+        isinstance(minimum_samples, bool)
+        or not isinstance(minimum_samples, int)
+        or minimum_samples < 7
+    ):
+        configuration_errors.append("minimum_samples must be at least 7")
+    subprocess_samples = configuration.get("subprocess_samples")
+    if (
+        isinstance(subprocess_samples, bool)
+        or not isinstance(subprocess_samples, int)
+        or not 7 <= subprocess_samples <= 21
+    ):
+        configuration_errors.append("subprocess_samples must be between 7 and 21")
+    if (
+        configuration.get("ordering_policy")
+        != "alternating-baseline-candidate-pairs-v1"
+    ):
+        configuration_errors.append("outer A/B ordering policy is not alternating")
+    if configuration.get("cold_cache_policy") != "unique-roots-per-outer-sample-v1":
+        configuration_errors.append("outer samples do not use isolated cache roots")
+    configured_batches = configuration.get("batch_sizes")
+    if not isinstance(configured_batches, list) or not set(requested_batches).issubset(
+        configured_batches
+    ):
+        configuration_errors.append("campaign does not configure every batch size")
+    configured_runtime_n = configuration.get("runtime_multiplicities")
+    if not isinstance(configured_runtime_n, list) or not set(
+        requested_multiplicities
+    ).issubset(configured_runtime_n):
+        configuration_errors.append(
+            "campaign does not runtime-profile every multiplicity"
+        )
+    configured_layouts = configuration.get("layouts")
+    if not isinstance(configured_layouts, list) or not set(requested_layouts).issubset(
+        configured_layouts
+    ):
+        configuration_errors.append("campaign does not include every LC layout")
+    if configuration_errors:
+        raise RuntimeABError(
+            "campaign configuration violates the runtime gate: "
+            + "; ".join(configuration_errors)
+        )
+
+    raw_samples = _list(campaign.get("samples"), description="campaign samples")
+    samples = [
+        _mapping(sample, description="campaign sample") for sample in raw_samples
+    ]
+    cell_results = []
+    for multiplicity in requested_multiplicities:
+        for layout in requested_layouts:
+            for batch_size in requested_batches:
+                observations = _cell_observations(
+                    samples,
+                    multiplicity=multiplicity,
+                    layout=layout,
+                    batch_size=batch_size,
+                )
+                cell_results.append(
+                    _cell_result(
+                        observations,
+                        multiplicity=multiplicity,
+                        layout=layout,
+                        batch_size=batch_size,
+                        material_rss_ratio=material_rss_ratio,
+                    )
+                )
+
+    statuses = {str(cell["status"]) for cell in cell_results}
+    if "rejected" in statuses:
+        status = "rejected"
+    elif "missing" in statuses:
+        status = "incomplete-matrix"
+    elif "incomplete-runtime-rss" in statuses:
+        status = "incomplete-runtime-rss"
+    elif "needs-more-samples" in statuses:
+        status = "needs-more-samples"
+    else:
+        status = "passed"
+    return {
+        "kind": RESULT_KIND,
+        "schema_version": RESULT_SCHEMA_VERSION,
+        "status": status,
+        "passes": status == "passed",
+        "source_campaign_id": campaign.get("campaign_id"),
+        "gate_contract": {
+            "multiplicities": list(requested_multiplicities),
+            "layouts": list(requested_layouts),
+            "batch_sizes": list(requested_batches),
+            "minimum_paired_samples": MINIMUM_PAIRED_SAMPLES,
+            "maximum_paired_samples": MAXIMUM_PAIRED_SAMPLES,
+            "confidence_level": CONFIDENCE_LEVEL,
+            "timing_allowed_candidate_over_baseline_ratio": NO_SLOWDOWN_RATIO,
+            "material_rss_candidate_over_baseline_ratio": material_rss_ratio,
+            "warmup_runs": 2,
+            "target_runtime_seconds": 5.0,
+        },
+        "cell_count": len(cell_results),
+        "passing_cell_count": sum(cell.get("passes") is True for cell in cell_results),
+        "cells": cell_results,
+    }
+
+
+def _json_object(path: Path) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise RuntimeABError(f"cannot read campaign JSON: {path}") from error
+    if not isinstance(value, dict):
+        raise RuntimeABError("campaign JSON must contain one object")
+    return value
+
+
+def _positive_cli_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return parsed
+
+
+def _material_rss_ratio(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed < 1.0:
+        raise argparse.ArgumentTypeError("must be finite and at least 1.0")
+    return parsed
+
+
+def _write_json(path: Path, value: object, *, replace: bool) -> None:
+    allowed = ALLOWED_OUTPUT_PARENT.resolve()
+    destination = path.expanduser().resolve()
+    try:
+        destination.relative_to(allowed)
+    except ValueError as error:
+        raise RuntimeABError(
+            f"output must remain under {ALLOWED_OUTPUT_PARENT}"
+        ) from error
+    if destination.exists() and not replace:
+        raise RuntimeABError(
+            f"output already exists; pass --replace to overwrite: {destination}"
+        )
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = destination.with_name(f".{destination.name}.tmp-{os.getpid()}")
+    try:
+        temporary.write_text(
+            json.dumps(value, allow_nan=False, indent=2, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, destination)
+    except (OSError, TypeError, ValueError) as error:
+        temporary.unlink(missing_ok=True)
+        raise RuntimeABError(f"cannot write analysis JSON: {destination}") from error
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--campaign", type=Path, required=True)
+    result.add_argument("--output-json", type=Path)
+    result.add_argument("--replace", action="store_true")
+    result.add_argument(
+        "--n",
+        dest="multiplicities",
+        action="append",
+        type=_positive_cli_int,
+    )
+    result.add_argument("--layout", action="append", choices=LAYOUTS)
+    result.add_argument(
+        "--batch-size",
+        action="append",
+        type=_positive_cli_int,
+    )
+    result.add_argument(
+        "--material-rss-ratio",
+        type=_material_rss_ratio,
+        default=DEFAULT_MATERIAL_RSS_RATIO,
+        help="largest candidate/baseline runtime RSS ratio accepted (default: 1.10)",
+    )
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    try:
+        arguments = parser().parse_args(argv)
+        campaign = _json_object(arguments.campaign)
+        analysis = analyze_campaign(
+            campaign,
+            multiplicities=(
+                DEFAULT_MULTIPLICITIES
+                if arguments.multiplicities is None
+                else arguments.multiplicities
+            ),
+            layouts=LAYOUTS if arguments.layout is None else arguments.layout,
+            batch_sizes=(
+                DEFAULT_BATCH_SIZES
+                if arguments.batch_size is None
+                else arguments.batch_size
+            ),
+            material_rss_ratio=arguments.material_rss_ratio,
+        )
+        if arguments.output_json is not None:
+            _write_json(arguments.output_json, analysis, replace=arguments.replace)
+    except RuntimeABError as error:
+        print(f"recurrence-runtime-ab-analyzer: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(analysis, allow_nan=False, sort_keys=True))
+    return 0 if analysis["passes"] is True else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/recurrence_semantic_census.py b/pyamplicol/tools/developer/recurrence_semantic_census.py
new file mode 100644
index 0000000000..5494c1e254
--- /dev/null
+++ b/pyamplicol/tools/developer/recurrence_semantic_census.py
@@ -0,0 +1,1211 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Fail-closed semantic census comparison for recurrence artifacts.
+
+This developer-only tool deliberately reuses pyAmpliCol's authenticated
+artifact inventory, prepared-kernel-pack decoders, and native recurrence exact
+section loader.  It does not decode ``recurrence-runtime.pacbin`` or
+``recurrence-binding.bin`` independently.
+
+The persisted exact sections enumerate current support/state projections,
+runtime interactions, closures, selector axes, and layout.  Some pre-lowering
+``CurrentCoreKey`` fields—notably dynamic LC color-state and local helicity
+identities—are intentionally absent from the runtime ABI.  Those fields are
+therefore authenticated transitively by the process/native semantic digests
+and the exact selector/catalog projections; this tool never claims to
+reconstruct them.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import sys
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import astuple, dataclass
+from pathlib import Path
+from typing import Any
+
+from pyamplicol.models.prepared import EAGER_KERNEL_ABI, PreparedKernelPack
+from pyamplicol.models.recurrence_direct_template import (
+    RECURRENCE_DIRECT_IDENTITY_FINALIZER,
+)
+from pyamplicol.runtime.recurrence_exact._execution import _role_index
+from pyamplicol.runtime.recurrence_exact._plan_v2 import (
+    DIRECT_NONE_U32,
+    _load_recurrence_exact_sections_v1,
+    _RecurrenceExactSectionsV1,
+)
+from tools.developer.recurrence_artifact_compare import (
+    ArtifactSnapshot,
+    _json_object,
+    _load_artifact,
+)
+from tools.developer.recurrence_artifact_compare import (
+    ComparisonError as ArtifactComparisonError,
+)
+
+CENSUS_KIND = "pyamplicol-recurrence-semantic-census"
+CENSUS_SCHEMA_VERSION = 1
+COMPARISON_KIND = "pyamplicol-recurrence-semantic-census-comparison"
+COMPARISON_SCHEMA_VERSION = 1
+MAX_REPORTED_DIFFERENCES = 256
+_UNASSIGNED_ROW = object()
+
+_SHA256_RE = re.compile(r"[0-9a-f]{64}")
+_EXECUTION_PATH_RE = re.compile(r"processes/([^/]+)/execution[.]json")
+_REQUIRED_DOMAINS = frozenset(
+    {
+        "digests",
+        "currents",
+        "sources",
+        "contribution_multisets",
+        "closures",
+        "selectors",
+        "normalization_and_parameters",
+        "semantic_catalog_bindings",
+        "runtime_layout",
+    }
+)
+_CATALOG_SECTION_NAMES = (
+    "parameters",
+    "current_states",
+    "sources",
+    "quantum_flows",
+    "transitions",
+    "propagators",
+    "closures",
+    "color_contractions",
+    "symmetry_proofs",
+    "runtime_helicity_contracts",
+    "evaluator_bindings",
+)
+_STORAGE_AUTHENTICATION_DIGEST_FIELDS = frozenset(
+    {
+        "runtime_container_index_sha256",
+        "runtime_container_sha256",
+        "runtime_plan_member_sha256",
+        "process_binding_sha256",
+    }
+)
+
+
+class SemanticCensusError(RuntimeError):
+    """Raised when an input cannot produce an authenticated exact census."""
+
+
+@dataclass(frozen=True, slots=True)
+class ExecutorSemanticBinding:
+    """Authenticated semantic context for one exact runtime executor."""
+
+    executor_id: int
+    role: str
+    semantic_digest: str
+    semantic_template_ids: tuple[str, ...]
+    direct_template: Mapping[str, object]
+    referenced_semantic_records: tuple[Mapping[str, object], ...]
+
+
+def _mapping(value: object, context: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):
+        raise SemanticCensusError(f"{context} must be an object with string keys")
+    return value
+
+
+def _sequence(value: object, context: str) -> Sequence[Any]:
+    if isinstance(value, str | bytes | bytearray) or not isinstance(value, Sequence):
+        raise SemanticCensusError(f"{context} must be an array")
+    return value
+
+
+def _sha256(value: object, context: str) -> str:
+    if not isinstance(value, str) or _SHA256_RE.fullmatch(value) is None:
+        raise SemanticCensusError(f"{context} must be a lowercase SHA-256")
+    return value
+
+
+def _nonnegative_int(value: object, context: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise SemanticCensusError(f"{context} must be a non-negative integer")
+    return value
+
+
+def _canonical_bytes(value: object) -> bytes:
+    try:
+        return json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    except (TypeError, ValueError) as error:
+        raise SemanticCensusError(
+            "semantic census value is not canonical JSON"
+        ) from error
+
+
+def _domain_census(name: str, records: Iterable[object]) -> dict[str, object]:
+    digest = hashlib.sha256()
+    domain = name.encode("ascii")
+    digest.update(len(domain).to_bytes(8, "little"))
+    digest.update(domain)
+    _count = 0
+    for _count, record in enumerate(records, start=1):
+        encoded = _canonical_bytes(record)
+        digest.update(len(encoded).to_bytes(8, "little"))
+        digest.update(encoded)
+    return {
+        "record_count": _count,
+        "sha256": digest.hexdigest(),
+    }
+
+
+def _exact_factor(
+    sections: _RecurrenceExactSectionsV1,
+    factor_id: int,
+    context: str,
+) -> tuple[int, int, int, int]:
+    if factor_id < 0 or factor_id >= len(sections.exact_factors):
+        raise SemanticCensusError(f"{context} references an absent exact factor")
+    return astuple(sections.exact_factors[factor_id])
+
+
+def _momentum(
+    sections: _RecurrenceExactSectionsV1,
+    form_id: int,
+    context: str,
+) -> tuple[tuple[int, int], ...]:
+    if form_id < 0 or form_id >= len(sections.momentum_forms):
+        raise SemanticCensusError(f"{context} references an absent momentum form")
+    form = sections.momentum_forms[form_id]
+    stop = form.term_start + form.term_count
+    if form.term_start < 0 or stop > len(sections.momentum_terms):
+        raise SemanticCensusError(f"{context} momentum form is out of bounds")
+    terms = tuple(
+        (term.source_slot, term.coefficient)
+        for term in sections.momentum_terms[form.term_start : stop]
+    )
+    if any(
+        slot >= sections.external_source_count or coefficient == 0
+        for slot, coefficient in terms
+    ) or tuple(slot for slot, _ in terms) != tuple(sorted({slot for slot, _ in terms})):
+        raise SemanticCensusError(f"{context} momentum form is not canonical")
+    return terms
+
+
+def _executor_rows(
+    sections: _RecurrenceExactSectionsV1,
+    role: str,
+    row_count: int,
+    bindings: Mapping[int, ExecutorSemanticBinding],
+    *,
+    allow_unbound: bool = False,
+) -> tuple[ExecutorSemanticBinding | None, ...]:
+    expected_role = _role_index(role)
+    result: list[ExecutorSemanticBinding | object | None] = [
+        _UNASSIGNED_ROW
+    ] * row_count
+    for group_index, group in enumerate(sections.row_groups):
+        if group.role != expected_role:
+            continue
+        binding = (
+            None
+            if allow_unbound and group.executor_id == DIRECT_NONE_U32
+            else bindings.get(group.executor_id)
+        )
+        if binding is None and not (
+            allow_unbound and group.executor_id == DIRECT_NONE_U32
+        ):
+            raise SemanticCensusError(
+                f"{role} row group {group_index} has no matching semantic executor"
+            )
+        if binding is not None and binding.role != role:
+            raise SemanticCensusError(
+                f"{role} row group {group_index} has no matching semantic executor"
+            )
+        stop = group.row_start + group.row_count
+        if group.row_start < 0 or stop > row_count:
+            raise SemanticCensusError(
+                f"{role} row group {group_index} is out of bounds"
+            )
+        for row_id in range(group.row_start, stop):
+            if result[row_id] is not _UNASSIGNED_ROW:
+                raise SemanticCensusError(
+                    f"{role} runtime row {row_id} belongs to multiple row groups"
+                )
+            result[row_id] = binding
+    if any(binding is _UNASSIGNED_ROW for binding in result):
+        missing = next(
+            index for index, binding in enumerate(result) if binding is _UNASSIGNED_ROW
+        )
+        raise SemanticCensusError(
+            f"{role} runtime row {missing} has no exact row-group owner"
+        )
+    return tuple(
+        binding if isinstance(binding, ExecutorSemanticBinding) else None
+        for binding in result
+    )
+
+
+def _executor_reference(binding: ExecutorSemanticBinding) -> dict[str, object]:
+    return {
+        "direct_executor_id": binding.executor_id,
+        "direct_semantic_digest": binding.semantic_digest,
+        "semantic_template_ids": list(binding.semantic_template_ids),
+    }
+
+
+def _current_records(
+    sections: _RecurrenceExactSectionsV1,
+    state_templates: Sequence[Mapping[str, object]],
+) -> Iterable[dict[str, object]]:
+    for current in sections.currents:
+        if current.state_template_id >= len(state_templates):
+            raise SemanticCensusError(
+                f"current {current.semantic_id} references an absent state template"
+            )
+        state = state_templates[current.state_template_id]
+        state_identity = {
+            "template_id": state.get("template_id"),
+            "semantic_digest": state.get("semantic_digest"),
+        }
+        if not isinstance(state_identity["template_id"], str):
+            raise SemanticCensusError(
+                f"current {current.semantic_id} state template has no identity"
+            )
+        _sha256(
+            state_identity["semantic_digest"],
+            f"current {current.semantic_id} state semantic digest",
+        )
+        momentum = _momentum(
+            sections,
+            current.momentum_form_id,
+            f"current {current.semantic_id}",
+        )
+        source: object = None
+        if current.source_row != DIRECT_NONE_U32:
+            if current.source_row >= len(sections.sources):
+                raise SemanticCensusError(
+                    f"current {current.semantic_id} references an absent source row"
+                )
+            source_row = sections.sources[current.source_row]
+            source = {
+                "row_id": current.source_row,
+                "source_slot": source_row.source_slot,
+                "spin_state_class": source_row.spin_state_class,
+                "source_template_or_dispatch_domain": (
+                    source_row.source_template_or_dispatch_domain
+                ),
+            }
+        yield {
+            "semantic_id": current.semantic_id,
+            "node_kind": current.node_kind,
+            "state_template_id": current.state_template_id,
+            "state_template": state_identity,
+            "component_count": current.component_count,
+            "momentum": momentum,
+            "support_source_slots": [slot for slot, _ in momentum],
+            "stage": current.stage,
+            # The runtime ABI persists selector domains, not the discarded
+            # dynamic color/local-helicity CurrentCoreKey fields.
+            "color_selector_domain_id": current.selector_domain_id,
+            "helicity_selector_domain_id": current.selector_domain_id,
+            "source": source,
+            "finalization_row": (
+                None
+                if current.finalization_row == DIRECT_NONE_U32
+                else current.finalization_row
+            ),
+        }
+
+
+def _source_records(
+    sections: _RecurrenceExactSectionsV1,
+    bindings: Mapping[int, ExecutorSemanticBinding],
+    source_metadata: Mapping[str, object],
+) -> Iterable[dict[str, object]]:
+    yield {"runtime_source_metadata": source_metadata}
+    executor_rows = _executor_rows(
+        sections,
+        "source",
+        len(sections.sources),
+        bindings,
+        allow_unbound=True,
+    )
+    for row_id, (source, binding) in enumerate(
+        zip(sections.sources, executor_rows, strict=True)
+    ):
+        yield {
+            "row_id": row_id,
+            "source_slot": source.source_slot,
+            "destination_component_base": source.destination_base,
+            "momentum": _momentum(
+                sections, source.momentum_form_id, f"source row {row_id}"
+            ),
+            "source_template_or_dispatch_domain": (
+                source.source_template_or_dispatch_domain
+            ),
+            "spin_state_class": source.spin_state_class,
+            "exact_factor": _exact_factor(
+                sections, source.exact_factor_id, f"source row {row_id}"
+            ),
+            "selector_domain_id": source.selector_domain_id,
+            "executor": (None if binding is None else _executor_reference(binding)),
+        }
+
+
+def _contribution_records(
+    sections: _RecurrenceExactSectionsV1,
+    bindings: Mapping[int, ExecutorSemanticBinding],
+) -> Iterable[dict[str, object]]:
+    executor_rows = _executor_rows(
+        sections,
+        "contribution",
+        len(sections.contributions),
+        bindings,
+    )
+    for row_id, (row, binding) in enumerate(
+        zip(sections.contributions, executor_rows, strict=True)
+    ):
+        parent1 = (
+            None
+            if row.parent1_base == DIRECT_NONE_U32
+            else {
+                "component_base": row.parent1_base,
+                "momentum": _momentum(
+                    sections,
+                    row.parent1_momentum,
+                    f"contribution {row_id} parent 1",
+                ),
+            }
+        )
+        yield {
+            # The native constructor emits this table in canonical key order,
+            # so hashing persisted order is also a canonical multiset census,
+            # independent of transient candidate-enumeration order.
+            "canonical_row_id": row_id,
+            "parents": [
+                {
+                    "component_base": row.parent0_base,
+                    "momentum": _momentum(
+                        sections,
+                        row.parent0_momentum,
+                        f"contribution {row_id} parent 0",
+                    ),
+                },
+                parent1,
+            ],
+            "destination_component_base": row.destination_base,
+            "exact_factor": _exact_factor(
+                sections, row.exact_factor_id, f"contribution {row_id}"
+            ),
+            "selector_domain_id": row.selector_domain_id,
+            "flags": row.flags,
+            "executor": _executor_reference(binding),
+        }
+
+
+def _closure_records(
+    sections: _RecurrenceExactSectionsV1,
+    bindings: Mapping[int, ExecutorSemanticBinding],
+) -> Iterable[dict[str, object]]:
+    executor_rows = _executor_rows(
+        sections, "closure", len(sections.closures), bindings
+    )
+    for row_id, (row, binding) in enumerate(
+        zip(sections.closures, executor_rows, strict=True)
+    ):
+        parent1 = (
+            None
+            if row.parent1_base == DIRECT_NONE_U32
+            else {
+                "component_base": row.parent1_base,
+                "momentum": _momentum(
+                    sections,
+                    row.parent1_momentum,
+                    f"closure {row_id} parent 1",
+                ),
+            }
+        )
+        yield {
+            "canonical_row_id": row_id,
+            "parents": [
+                {
+                    "component_base": row.parent0_base,
+                    "momentum": _momentum(
+                        sections,
+                        row.parent0_momentum,
+                        f"closure {row_id} parent 0",
+                    ),
+                },
+                parent1,
+            ],
+            "amplitude_destination_id": row.amplitude_destination_id,
+            "exact_factor": _exact_factor(
+                sections, row.exact_factor_id, f"closure {row_id}"
+            ),
+            "component_factor_start": row.component_factor_start,
+            "component_count": row.component_count,
+            "selector_domain_id": row.selector_domain_id,
+            "flags": row.flags,
+            "executor": _executor_reference(binding),
+        }
+
+
+def _selector_records(
+    sections: _RecurrenceExactSectionsV1,
+    selector_metadata: Mapping[str, object],
+) -> Iterable[dict[str, object]]:
+    yield {"runtime_selector_metadata": selector_metadata}
+    tables = (
+        ("replay_targets", sections.replay_targets),
+        ("source_permutations", sections.source_permutations),
+        ("replay_momentum_signs", sections.replay_momentum_signs),
+        ("replay_helicity_map", sections.replay_helicity_map),
+        ("amplitude_destinations", sections.amplitude_destinations),
+        ("resolved_helicities", sections.resolved_helicities),
+        ("source_state_assignments", sections.source_state_assignments),
+        ("source_dispatch_variants", sections.source_dispatch_variants),
+        ("source_embeddings", sections.source_embeddings),
+        ("source_projections", sections.source_projections),
+        ("resolved_source_selections", sections.resolved_source_selections),
+        ("public_helicities", sections.public_helicities),
+        ("public_flow_ids", sections.public_flow_ids),
+    )
+    for name, rows in tables:
+        yield {"table": name, "row_count": len(rows)}
+        for row_id, row in enumerate(rows):
+            yield {
+                "table": name,
+                "row_id": row_id,
+                "row": (astuple(row) if hasattr(row, "__dataclass_fields__") else row),
+            }
+
+
+def _semantic_catalog_records(
+    bindings: Mapping[int, ExecutorSemanticBinding],
+    sections: _RecurrenceExactSectionsV1,
+) -> Iterable[dict[str, object]]:
+    used_executor_ids = sorted(
+        {
+            group.executor_id
+            for group in sections.row_groups
+            if group.executor_id != DIRECT_NONE_U32
+        }
+    )
+    for executor_id in used_executor_ids:
+        binding = bindings.get(executor_id)
+        if binding is None:
+            raise SemanticCensusError(
+                f"runtime schedule references absent direct executor {executor_id}"
+            )
+        yield {
+            "direct_executor_id": executor_id,
+            "direct_template": binding.direct_template,
+            "referenced_semantic_records": list(binding.referenced_semantic_records),
+        }
+
+
+def _runtime_layout_records(
+    sections: _RecurrenceExactSectionsV1,
+) -> Iterable[dict[str, object]]:
+    yield {
+        "counts": {
+            "current_arena_components": sections.current_arena_components,
+            "amplitude_destination_count": sections.amplitude_destination_count,
+            "parameter_value_count": sections.parameter_value_count,
+            "external_source_count": sections.external_source_count,
+        }
+    }
+    for name, rows in (
+        ("currents", sections.currents),
+        ("sources", sections.sources),
+        ("contributions", sections.contributions),
+        ("finalizations", sections.finalizations),
+        ("closures", sections.closures),
+        ("row_groups", sections.row_groups),
+        ("momentum_forms", sections.momentum_forms),
+        ("momentum_terms", sections.momentum_terms),
+        ("exact_factors", sections.exact_factors),
+        ("executors", sections.executors),
+    ):
+        yield {"table": name, "row_count": len(rows)}
+        for row_id, row in enumerate(rows):
+            yield {"table": name, "row_id": row_id, "row": astuple(row)}
+
+
+def build_semantic_census(
+    *,
+    sections: _RecurrenceExactSectionsV1,
+    process_metadata: Mapping[str, object],
+    executor_bindings: Mapping[int, ExecutorSemanticBinding],
+    state_templates: Sequence[Mapping[str, object]],
+) -> dict[str, object]:
+    """Build one timing-free census from already authenticated typed inputs."""
+
+    raw_digests = _mapping(process_metadata.get("digests"), "process metadata digests")
+    digests = {
+        key: value
+        for key, value in raw_digests.items()
+        if key not in _STORAGE_AUTHENTICATION_DIGEST_FIELDS
+    }
+    normalization = _mapping(
+        process_metadata.get("normalization_and_parameters"),
+        "process normalization/parameters",
+    )
+    selector_metadata = _mapping(
+        process_metadata.get("selectors"), "process selector metadata"
+    )
+    source_metadata = _mapping(
+        process_metadata.get("sources"), "process source metadata"
+    )
+    if digests.get("process_semantic_digest") != sections.semantic_digest:
+        raise SemanticCensusError(
+            "process metadata semantic digest does not match exact sections"
+        )
+    if digests.get("runtime_layout_digest") != sections.runtime_layout_digest:
+        raise SemanticCensusError(
+            "process metadata runtime-layout digest does not match exact sections"
+        )
+
+    domains = {
+        "digests": _domain_census("digests", (digests,)),
+        "currents": _domain_census(
+            "currents", _current_records(sections, state_templates)
+        ),
+        "sources": _domain_census(
+            "sources",
+            _source_records(sections, executor_bindings, source_metadata),
+        ),
+        "contribution_multisets": _domain_census(
+            "contribution_multisets",
+            _contribution_records(sections, executor_bindings),
+        ),
+        "closures": _domain_census(
+            "closures", _closure_records(sections, executor_bindings)
+        ),
+        "selectors": _domain_census(
+            "selectors", _selector_records(sections, selector_metadata)
+        ),
+        "normalization_and_parameters": _domain_census(
+            "normalization_and_parameters", (normalization,)
+        ),
+        "semantic_catalog_bindings": _domain_census(
+            "semantic_catalog_bindings",
+            _semantic_catalog_records(executor_bindings, sections),
+        ),
+        "runtime_layout": _domain_census(
+            "runtime_layout", _runtime_layout_records(sections)
+        ),
+    }
+    if set(domains) != _REQUIRED_DOMAINS:  # pragma: no cover - construction invariant
+        raise SemanticCensusError("semantic census domain coverage is incomplete")
+    content = {
+        "kind": CENSUS_KIND,
+        "schema_version": CENSUS_SCHEMA_VERSION,
+        "process_id": sections.process_id,
+        "strategy": sections.strategy,
+        "coverage": {
+            "exact_sections_decoder": (
+                "pyamplicol.runtime.recurrence_exact._plan_v2."
+                "_load_recurrence_exact_sections_v1"
+            ),
+            "prepared_catalog_decoder": (
+                "pyamplicol.models.prepared.PreparedKernelPack.from_dict"
+            ),
+            "directly_enumerated": [
+                "current semantic IDs, node kinds, state templates, momentum support",
+                "source rows and spin-state classes",
+                "canonical contribution rows, signs, and runtime endpoints",
+                "closures and amplitude destinations",
+                "flow/helicity/source-dispatch selector axes",
+                "normalization, parameter projection, and runtime layout",
+            ],
+            "transitively_authenticated_not_reconstructed": [
+                "pre-lowering dynamic LC color-state IDs",
+                "pre-lowering local current-helicity identities",
+                "discarded construction-only flavour/quantum/coupling key fields",
+            ],
+            "canonical_contribution_policy": (
+                "persisted-native-canonical-emission-is-the-multiset-order-v1"
+            ),
+        },
+        "domains": domains,
+    }
+    content["census_sha256"] = hashlib.sha256(_canonical_bytes(content)).hexdigest()
+    return content
+
+
+def _semantic_record_index(
+    catalog_payload: Mapping[str, object],
+) -> tuple[dict[str, Mapping[str, object]], tuple[Mapping[str, object], ...]]:
+    by_id: dict[str, Mapping[str, object]] = {}
+    state_templates: tuple[Mapping[str, object], ...] = ()
+    for section_name in _CATALOG_SECTION_NAMES:
+        rows = _sequence(
+            catalog_payload.get(section_name),
+            f"recurrence catalog {section_name}",
+        )
+        parsed_rows: list[Mapping[str, object]] = []
+        for index, raw in enumerate(rows):
+            row = _mapping(raw, f"recurrence catalog {section_name}[{index}]")
+            identity = row.get("template_id", row.get("resolver_key"))
+            if not isinstance(identity, str) or not identity:
+                raise SemanticCensusError(
+                    f"recurrence catalog {section_name}[{index}] lacks an identity"
+                )
+            if identity in by_id:
+                raise SemanticCensusError(
+                    f"recurrence catalog repeats semantic identity {identity!r}"
+                )
+            by_id[identity] = row
+            parsed_rows.append(row)
+        if section_name == "current_states":
+            state_templates = tuple(parsed_rows)
+    if not state_templates:
+        raise SemanticCensusError("recurrence catalog has no current-state templates")
+    return by_id, state_templates
+
+
+def _referenced_record_closure(
+    roots: Iterable[str],
+    records: Mapping[str, Mapping[str, object]],
+) -> tuple[Mapping[str, object], ...]:
+    pending = list(roots)
+    visited: set[str] = set()
+
+    def references(value: object) -> Iterable[str]:
+        if isinstance(value, str):
+            if value in records:
+                yield value
+        elif isinstance(value, Mapping):
+            for child in value.values():
+                yield from references(child)
+        elif isinstance(value, Sequence) and not isinstance(
+            value, str | bytes | bytearray
+        ):
+            for child in value:
+                yield from references(child)
+
+    while pending:
+        identity = pending.pop()
+        if identity in visited:
+            continue
+        record = records.get(identity)
+        if record is None:
+            raise SemanticCensusError(
+                f"direct executor references absent semantic record {identity!r}"
+            )
+        visited.add(identity)
+        pending.extend(
+            reference for reference in references(record) if reference not in visited
+        )
+    return tuple(records[identity] for identity in sorted(visited))
+
+
+def _executor_bindings(
+    pack: PreparedKernelPack,
+    sections: _RecurrenceExactSectionsV1,
+) -> tuple[
+    dict[int, ExecutorSemanticBinding],
+    tuple[Mapping[str, object], ...],
+]:
+    semantic_catalog = pack.recurrence_template_catalog
+    direct_catalog = pack.recurrence_direct_template_catalog
+    if semantic_catalog is None or direct_catalog is None:
+        raise SemanticCensusError(
+            "prepared kernel pack lacks authenticated recurrence catalogs"
+        )
+    semantic_payload = semantic_catalog.to_dict()
+    record_by_id, state_templates = _semantic_record_index(semantic_payload)
+    bindings: dict[int, ExecutorSemanticBinding] = {}
+    for template in direct_catalog.templates:
+        roots = template.semantic_template_ids
+        if template.evaluator_resolver_key != RECURRENCE_DIRECT_IDENTITY_FINALIZER:
+            roots = (*roots, template.evaluator_resolver_key)
+        binding = ExecutorSemanticBinding(
+            executor_id=template.direct_executor_id,
+            role=template.role,
+            semantic_digest=template.semantic_digest,
+            semantic_template_ids=template.semantic_template_ids,
+            direct_template=template.to_dict(),
+            referenced_semantic_records=_referenced_record_closure(roots, record_by_id),
+        )
+        if binding.executor_id in bindings:
+            raise SemanticCensusError(
+                f"direct catalog repeats executor {binding.executor_id}"
+            )
+        bindings[binding.executor_id] = binding
+
+    if len(sections.executors) != len(bindings):
+        raise SemanticCensusError(
+            "exact executor inventory differs from the authenticated direct catalog"
+        )
+    for executor in sections.executors:
+        binding = bindings.get(executor.executor_id)
+        if binding is None:
+            raise SemanticCensusError(
+                f"exact sections reference absent executor {executor.executor_id}"
+            )
+        template = binding.direct_template
+        expected = (
+            binding.role,
+            template.get("destination_operation"),
+            tuple(_sequence(template.get("parent_component_counts"), "parent counts")),
+            template.get("destination_component_count"),
+            template.get("momentum_operand_count"),
+            _mapping(template.get("payload_binding"), "direct payload binding").get(
+                "prepared_kernel_id"
+            ),
+            _mapping(template.get("payload_binding"), "direct payload binding").get(
+                "runtime_template"
+            ),
+        )
+        actual = (
+            executor.role,
+            executor.destination_operation,
+            executor.parent_component_counts,
+            executor.destination_component_count,
+            executor.momentum_operand_count,
+            executor.prepared_kernel_id,
+            executor.runtime_template,
+        )
+        if actual != expected:
+            raise SemanticCensusError(
+                "exact executor "
+                f"{executor.executor_id} differs from its direct template"
+            )
+    return bindings, state_templates
+
+
+def _schedule_summary_counts(
+    sections: _RecurrenceExactSectionsV1,
+) -> dict[str, int]:
+    return {
+        "amplitude_destination_count": len(sections.amplitude_destinations),
+        "closure_term_count": len(sections.closures),
+        "contribution_count": len(sections.contributions),
+        "current_count": len(sections.currents),
+        "exact_factor_count": len(sections.exact_factors),
+        "finalization_count": len(sections.finalizations),
+        "replay_target_count": len(sections.replay_targets),
+        "resolved_helicity_count": len(sections.resolved_helicities),
+        "source_row_count": len(sections.sources),
+    }
+
+
+def _process_metadata(
+    *,
+    snapshot: ArtifactSnapshot,
+    process_id: str,
+    execution: Mapping[str, object],
+    sections: _RecurrenceExactSectionsV1,
+    pack: PreparedKernelPack,
+) -> dict[str, object]:
+    if execution.get("key") != process_id:
+        raise SemanticCensusError("execution key does not match its process path")
+    plan = _mapping(execution.get("plan"), "recurrence execution plan")
+    inspection = _mapping(
+        plan.get("inspection_summary"), "recurrence inspection summary"
+    )
+    binding = _mapping(plan.get("process_binding"), "recurrence process binding")
+    runtime_schedule = _mapping(
+        plan.get("runtime_schedule"), "recurrence runtime schedule"
+    )
+    runtime_metadata = _mapping(
+        execution.get("runtime_metadata"), "recurrence runtime metadata"
+    )
+    schedule_summary = _mapping(
+        inspection.get("schedule"), "recurrence schedule summary"
+    )
+    expected_counts = _schedule_summary_counts(sections)
+    for name, expected in expected_counts.items():
+        if schedule_summary.get(name) != expected:
+            raise SemanticCensusError(
+                f"inspection schedule count {name} differs from exact sections"
+            )
+
+    direct_catalog = pack.recurrence_direct_template_catalog
+    semantic_catalog = pack.recurrence_template_catalog
+    assert direct_catalog is not None and semantic_catalog is not None
+    schedule_digest = _sha256(
+        inspection.get("schedule_digest"), "inspection schedule digest"
+    )
+    schedule_path = runtime_schedule.get("path")
+    if not isinstance(schedule_path, str) or schedule_path not in snapshot.payloads:
+        raise SemanticCensusError(
+            "runtime schedule path is absent from the authenticated artifact"
+        )
+    schedule_payload = snapshot.payloads[schedule_path]
+    if (
+        _sha256(
+            runtime_schedule.get("sha256"),
+            "runtime container digest",
+        )
+        != schedule_payload.sha256
+        or _nonnegative_int(
+            runtime_schedule.get("size_bytes"),
+            "runtime container size",
+        )
+        != schedule_payload.size_bytes
+    ):
+        raise SemanticCensusError(
+            "runtime schedule metadata does not authenticate its payload"
+        )
+    path_parts = Path(schedule_path).parts
+    if len(path_parts) < 3 or path_parts[-2] != schedule_digest:
+        raise SemanticCensusError(
+            "runtime schedule path does not embed the inspection schedule digest"
+        )
+
+    semantic_digest = _sha256(
+        binding.get("process_semantic_digest"), "process semantic digest"
+    )
+    runtime_layout_digest = _sha256(
+        inspection.get("runtime_layout_digest"), "runtime-layout digest"
+    )
+    _sha256(
+        runtime_schedule.get("index_sha256"),
+        "runtime container index digest",
+    )
+    _sha256(
+        _mapping(
+            inspection.get("runtime_container_member"),
+            "runtime container member",
+        ).get("sha256"),
+        "runtime plan member digest",
+    )
+    binding_path = binding.get("path")
+    if not isinstance(binding_path, str) or not binding_path:
+        raise SemanticCensusError("process binding path is invalid")
+    binding_payload = snapshot.payloads.get(f"processes/{process_id}/{binding_path}")
+    if binding_payload is None or (
+        _sha256(binding.get("sha256"), "process binding digest")
+        != binding_payload.sha256
+        or _nonnegative_int(binding.get("size_bytes"), "process binding size")
+        != binding_payload.size_bytes
+    ):
+        raise SemanticCensusError(
+            "process binding metadata does not authenticate its payload"
+        )
+    equalities = (
+        (sections.process_id, process_id, "exact process identity"),
+        (sections.strategy, inspection.get("lc_flow_layout"), "recurrence strategy"),
+        (sections.semantic_digest, semantic_digest, "exact semantic digest"),
+        (
+            plan.get("builder_input_sha256"),
+            semantic_digest,
+            "builder-input semantic digest",
+        ),
+        (
+            inspection.get("semantic_digest"),
+            semantic_digest,
+            "inspection semantic digest",
+        ),
+        (
+            sections.runtime_layout_digest,
+            runtime_layout_digest,
+            "exact runtime-layout digest",
+        ),
+        (
+            binding.get("schedule_digest"),
+            schedule_digest,
+            "process-binding schedule digest",
+        ),
+        (
+            execution.get("direct_template_catalog_digest"),
+            direct_catalog.catalog_digest,
+            "execution direct-template digest",
+        ),
+        (
+            plan.get("direct_template_catalog_digest"),
+            direct_catalog.catalog_digest,
+            "plan direct-template digest",
+        ),
+        (
+            execution.get("prepared_kernel_pack_digest"),
+            direct_catalog.prepared_kernel_pack_digest,
+            "execution prepared-pack digest",
+        ),
+        (
+            plan.get("prepared_kernel_pack_digest"),
+            direct_catalog.prepared_kernel_pack_digest,
+            "plan prepared-pack digest",
+        ),
+        (
+            direct_catalog.recurrence_template_catalog_digest,
+            semantic_catalog.header.catalog_digest,
+            "semantic/direct recurrence catalog digest",
+        ),
+    )
+    for actual, expected, context in equalities:
+        if actual != expected:
+            raise SemanticCensusError(f"{context} is inconsistent")
+
+    digests = {
+        "process_semantic_digest": semantic_digest,
+        "native_schedule_semantic_digest": _sha256(
+            binding.get("native_schedule_semantic_digest"),
+            "native schedule semantic digest",
+        ),
+        "runtime_layout_digest": runtime_layout_digest,
+        "schedule_digest": schedule_digest,
+        "builder_input_sha256": _sha256(
+            plan.get("builder_input_sha256"), "builder input digest"
+        ),
+        "direct_template_catalog_digest": direct_catalog.catalog_digest,
+        "recurrence_template_catalog_digest": (semantic_catalog.header.catalog_digest),
+        "prepared_kernel_pack_digest": direct_catalog.prepared_kernel_pack_digest,
+        "process_binding_remap": binding.get("remap"),
+        "process_support_words": binding.get("process_support_words"),
+        "abis": {
+            "builder_input": execution.get("builder_input_abi"),
+            "direct_backend": execution.get("direct_backend_abi"),
+            "direct_template": execution.get("direct_template_abi"),
+            "recurrence_plan": execution.get("recurrence_plan_abi"),
+            "runtime_layout": execution.get("runtime_layout_abi"),
+            "process_binding": binding.get("abi"),
+        },
+    }
+    return {
+        "digests": digests,
+        "normalization_and_parameters": {
+            "normalization": runtime_metadata.get("normalization"),
+            "parameter_projection": runtime_metadata.get("parameter_projection"),
+            "prepared_parameter_defaults": runtime_metadata.get(
+                "prepared_parameter_defaults"
+            ),
+            "runtime_parameters": runtime_metadata.get("runtime_parameters"),
+            "parameter_value_count": sections.parameter_value_count,
+        },
+        "selectors": {
+            "color_accuracy": execution.get("color_accuracy"),
+            "color_contraction": runtime_metadata.get("color_contraction"),
+            "public_color_flows": runtime_metadata.get("public_color_flows"),
+            "runtime_options": execution.get("runtime_options"),
+        },
+        "sources": {
+            "process": execution.get("process"),
+            "external_pdg_order": execution.get("external_pdg_order"),
+            "external_legs": runtime_metadata.get("external_legs"),
+            "particle_masses": runtime_metadata.get("particle_masses"),
+            "source_templates": runtime_metadata.get("source_templates"),
+        },
+    }
+
+
+def _load_pack(snapshot: ArtifactSnapshot) -> PreparedKernelPack:
+    relative = "model/eager-kernel-pack.json"
+    payload = snapshot.payloads.get(relative)
+    if payload is None:
+        raise SemanticCensusError(
+            "recurrence artifact lacks the prepared kernel-pack manifest"
+        )
+    raw = _json_object(payload.path, description="prepared kernel pack")
+    kernel_abi = raw.pop("eager_kernel_abi", None)
+    if kernel_abi != EAGER_KERNEL_ABI:
+        raise SemanticCensusError(
+            f"prepared kernel pack has unsupported eager ABI {kernel_abi!r}"
+        )
+    try:
+        return PreparedKernelPack.from_dict(raw)
+    except ValueError as error:
+        raise SemanticCensusError(
+            "prepared kernel pack failed authoritative decoding"
+        ) from error
+
+
+def _artifact_censuses(snapshot: ArtifactSnapshot) -> dict[str, dict[str, object]]:
+    pack = _load_pack(snapshot)
+    result: dict[str, dict[str, object]] = {}
+    for execution_path in sorted(snapshot.executions):
+        match = _EXECUTION_PATH_RE.fullmatch(execution_path)
+        if match is None:  # pragma: no cover - authenticated by artifact loader
+            raise SemanticCensusError(
+                f"unexpected recurrence execution path {execution_path!r}"
+            )
+        process_id = match.group(1)
+        try:
+            sections = _load_recurrence_exact_sections_v1(snapshot.root, process_id)
+        except Exception as error:
+            raise SemanticCensusError(
+                f"native exact-section loading failed for process {process_id!r}"
+            ) from error
+        bindings, state_templates = _executor_bindings(pack, sections)
+        execution = snapshot.executions[execution_path]
+        metadata = _process_metadata(
+            snapshot=snapshot,
+            process_id=process_id,
+            execution=execution,
+            sections=sections,
+            pack=pack,
+        )
+        result[process_id] = build_semantic_census(
+            sections=sections,
+            process_metadata=metadata,
+            executor_bindings=bindings,
+            state_templates=state_templates,
+        )
+    if not result:
+        raise SemanticCensusError("recurrence artifact has no process census")
+    return result
+
+
+def compare_census_sets(
+    baseline: Mapping[str, Mapping[str, object]],
+    candidate: Mapping[str, Mapping[str, object]],
+) -> dict[str, object]:
+    """Compare two already-built process-census sets without an allowlist."""
+
+    differences: list[dict[str, object]] = []
+    baseline_ids = set(baseline)
+    candidate_ids = set(candidate)
+    for process_id in sorted(baseline_ids - candidate_ids):
+        differences.append(
+            {
+                "kind": "process-inventory",
+                "process_id": process_id,
+                "baseline": "present",
+                "candidate": "missing",
+            }
+        )
+    for process_id in sorted(candidate_ids - baseline_ids):
+        differences.append(
+            {
+                "kind": "process-inventory",
+                "process_id": process_id,
+                "baseline": "missing",
+                "candidate": "present",
+            }
+        )
+    process_reports: list[dict[str, object]] = []
+    for process_id in sorted(baseline_ids & candidate_ids):
+        left = baseline[process_id]
+        right = candidate[process_id]
+        for field in ("kind", "schema_version", "process_id", "strategy", "coverage"):
+            if left.get(field) != right.get(field):
+                differences.append(
+                    {
+                        "kind": "census-contract",
+                        "process_id": process_id,
+                        "field": field,
+                        "baseline": left.get(field),
+                        "candidate": right.get(field),
+                    }
+                )
+        left_domains = _mapping(left.get("domains"), "baseline census domains")
+        right_domains = _mapping(right.get("domains"), "candidate census domains")
+        if (
+            set(left_domains) != _REQUIRED_DOMAINS
+            or set(right_domains) != _REQUIRED_DOMAINS
+        ):
+            raise SemanticCensusError(
+                f"process {process_id!r} has incomplete census domains"
+            )
+        matched: list[str] = []
+        changed: list[str] = []
+        for domain in sorted(_REQUIRED_DOMAINS):
+            left_domain = _mapping(
+                left_domains[domain], f"baseline {process_id} {domain}"
+            )
+            right_domain = _mapping(
+                right_domains[domain], f"candidate {process_id} {domain}"
+            )
+            if left_domain == right_domain:
+                matched.append(domain)
+                continue
+            changed.append(domain)
+            differences.append(
+                {
+                    "kind": "semantic-domain",
+                    "process_id": process_id,
+                    "domain": domain,
+                    "baseline": dict(left_domain),
+                    "candidate": dict(right_domain),
+                }
+            )
+        process_reports.append(
+            {
+                "process_id": process_id,
+                "strategy": left.get("strategy"),
+                "matched_domains": matched,
+                "changed_domains": changed,
+                "baseline_census_sha256": left.get("census_sha256"),
+                "candidate_census_sha256": right.get("census_sha256"),
+                "passes": not changed
+                and all(
+                    difference.get("process_id") != process_id
+                    for difference in differences
+                ),
+            }
+        )
+    difference_count = len(differences)
+    return {
+        "kind": COMPARISON_KIND,
+        "schema_version": COMPARISON_SCHEMA_VERSION,
+        "passes": difference_count == 0,
+        "policy": {
+            "allowlisted_differences": [],
+            "domain_set": sorted(_REQUIRED_DOMAINS),
+            "unknown_or_missing_domains": "reject",
+            "nonpersisted_pre_lowering_keys": (
+                "authenticate-transitively-never-reconstruct-v1"
+            ),
+        },
+        "processes": process_reports,
+        "difference_count": difference_count,
+        "differences_truncated": difference_count > MAX_REPORTED_DIFFERENCES,
+        "differences": differences[:MAX_REPORTED_DIFFERENCES],
+    }
+
+
+def compare_artifact_censuses(
+    baseline_artifact: Path,
+    candidate_artifact: Path,
+) -> dict[str, object]:
+    """Authenticate, decode, census, and compare two recurrence artifacts."""
+
+    try:
+        baseline_snapshot = _load_artifact(baseline_artifact, label="baseline")
+        candidate_snapshot = _load_artifact(candidate_artifact, label="candidate")
+    except ArtifactComparisonError as error:
+        raise SemanticCensusError(str(error)) from error
+    baseline = _artifact_censuses(baseline_snapshot)
+    candidate = _artifact_censuses(candidate_snapshot)
+    report = compare_census_sets(baseline, candidate)
+    report["baseline"] = {
+        "path": str(baseline_snapshot.root),
+        "artifact_id": baseline_snapshot.manifest["artifact_id"],
+        "process_count": len(baseline),
+    }
+    report["candidate"] = {
+        "path": str(candidate_snapshot.root),
+        "artifact_id": candidate_snapshot.manifest["artifact_id"],
+        "process_count": len(candidate),
+    }
+    return report
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--baseline", type=Path, required=True)
+    result.add_argument("--candidate", type=Path, required=True)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    try:
+        report = compare_artifact_censuses(arguments.baseline, arguments.candidate)
+    except SemanticCensusError as error:
+        print(f"recurrence-semantic-census: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(report, indent=2, sort_keys=True, allow_nan=False))
+    return 0 if report["passes"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/recurrence_z6g_benchmark.py b/pyamplicol/tools/developer/recurrence_z6g_benchmark.py
new file mode 100644
index 0000000000..e74a7fb3cd
--- /dev/null
+++ b/pyamplicol/tools/developer/recurrence_z6g_benchmark.py
@@ -0,0 +1,8767 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Benchmark compiled, eager, and recurrence execution for qq_Zng.
+
+This is a developer harness, independent of the publication-report tooling.
+Run the whole command behind
+``tools/ci/memory_watchdog.py`` when generating the large artifacts.
+Generation and profiling run in isolated worker processes so each phase has a
+meaningful process-level ``resource.getrusage`` peak-RSS record.
+
+One invocation captures one LC layout. Its result embeds a fail-closed
+milestone-0 evidence manifest, but cannot certify milestone 0 by itself: a
+separate orchestrator must combine content-hashed topology-replay and
+all-flow-union captures with pinned legacy AmpliCol evidence.
+Authoritative lane timing is the median and raw MAD of seven independently
+warmed, identity-verified subprocess measurements per mode/batch cell.
+
+For a developer-only comparison, set
+``PYAMPLICOL_RECURRENCE_Z6G_SOURCE_CHECKOUT`` to an absolute clean worktree
+inside this driver's workspace. The frozen driver remains the executable
+script while source and installed-runtime provenance bind to that worktree.
+
+For an immutable baseline recapture, the harness itself may live outside the
+source tree under test. Set ``PYAMPLICOL_BENCHMARK_SOURCE_ROOT`` to the
+absolute path of that clean checkout; command provenance still authenticates
+the external harness while source/build provenance is read from the selected
+checkout.
+
+Example::
+
+    .venv/bin/python tools/ci/memory_watchdog.py --limit-gib 30 -- \
+      .venv/bin/python tools/developer/recurrence_z6g_benchmark.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import dataclasses
+import datetime as dt
+import hashlib
+import importlib
+import importlib.metadata
+import json
+import math
+import os
+import platform
+import re
+import resource
+import statistics
+import subprocess
+import sys
+import time
+import tomllib
+from collections.abc import Mapping, Sequence
+from itertools import pairwise
+from pathlib import Path
+from typing import Any, Literal, cast
+
+
+class HarnessError(RuntimeError):
+    """Raised when the benchmark contract cannot be completed."""
+
+
+SOURCE_CHECKOUT_OVERRIDE_ENV = "PYAMPLICOL_RECURRENCE_Z6G_SOURCE_CHECKOUT"
+BENCHMARK_SOURCE_ROOT_ENV = "PYAMPLICOL_BENCHMARK_SOURCE_ROOT"
+DRIVER_PATH = Path(__file__).resolve()
+DRIVER_ROOT = DRIVER_PATH.parents[2]
+_SOURCE_CHECKOUT_FILE_MARKERS = (
+    Path("Cargo.toml"),
+    Path("pyproject.toml"),
+    Path("src/pyamplicol/__init__.py"),
+    Path("tools/developer/recurrence_z6g_benchmark.py"),
+)
+
+
+def _resolve_source_checkout_root(
+    *,
+    driver_root: Path = DRIVER_ROOT,
+    environment: Mapping[str, str] = os.environ,
+) -> Path:
+    """Resolve the optional measured-checkout override, failing closed."""
+
+    workspace_root = driver_root.resolve(strict=True)
+    raw_override = environment.get(SOURCE_CHECKOUT_OVERRIDE_ENV)
+    if raw_override is None:
+        return workspace_root
+    if not raw_override:
+        raise HarnessError(
+            f"{SOURCE_CHECKOUT_OVERRIDE_ENV} must name an absolute source checkout"
+        )
+    override = Path(raw_override)
+    if not override.is_absolute():
+        raise HarnessError(f"{SOURCE_CHECKOUT_OVERRIDE_ENV} must be an absolute path")
+    try:
+        checkout = override.resolve(strict=True)
+    except OSError as error:
+        raise HarnessError(
+            f"{SOURCE_CHECKOUT_OVERRIDE_ENV} source checkout is unavailable"
+        ) from error
+    if not checkout.is_dir():
+        raise HarnessError(f"{SOURCE_CHECKOUT_OVERRIDE_ENV} does not name a directory")
+    if checkout != workspace_root and workspace_root not in checkout.parents:
+        raise HarnessError(
+            f"{SOURCE_CHECKOUT_OVERRIDE_ENV} must stay inside the driver workspace"
+        )
+    git_marker = checkout / ".git"
+    missing = [
+        marker.as_posix()
+        for marker in _SOURCE_CHECKOUT_FILE_MARKERS
+        if not (checkout / marker).is_file()
+    ]
+    if not git_marker.exists() or missing:
+        if not git_marker.exists():
+            missing.insert(0, ".git")
+        raise HarnessError(
+            f"{SOURCE_CHECKOUT_OVERRIDE_ENV} is not a pyAmpliCol source checkout; "
+            f"missing {', '.join(missing)}"
+        )
+    return checkout
+
+
+def _resolve_benchmark_source_root(
+    requested: str | None,
+    *,
+    script_path: Path = Path(__file__),
+) -> Path:
+    default = script_path.resolve().parents[2]
+    if requested is None or not requested.strip():
+        return default
+    candidate = Path(requested)
+    if not candidate.is_absolute():
+        raise RuntimeError("PYAMPLICOL_BENCHMARK_SOURCE_ROOT must be an absolute path")
+    try:
+        resolved = candidate.resolve(strict=True)
+    except OSError as error:
+        raise RuntimeError(
+            "PYAMPLICOL_BENCHMARK_SOURCE_ROOT does not resolve to a source checkout"
+        ) from error
+    required = ("Cargo.toml", "pyproject.toml")
+    if not resolved.is_dir() or any(
+        not (resolved / relative).is_file() for relative in required
+    ):
+        raise RuntimeError(
+            "PYAMPLICOL_BENCHMARK_SOURCE_ROOT is not a pyAmpliCol source checkout"
+        )
+    return resolved
+
+
+ROOT = _resolve_source_checkout_root(
+    driver_root=_resolve_benchmark_source_root(
+        os.environ.get(BENCHMARK_SOURCE_ROOT_ENV)
+    )
+)
+PREPARED_MODEL_ID = "built-in-sm-jit-o2"
+PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL = 2
+DEFAULT_BATCH_SIZES = (1, 128, 1024)
+MIN_AUTHORITATIVE_SAMPLES = 7
+AUTHORITATIVE_EXECUTION_MODES = ("compiled", "recurrence")
+DIAGNOSTIC_EXECUTION_MODES = ("eager",)
+EXECUTION_MODES = ("compiled", "eager", "recurrence")
+LC_FLOW_LAYOUTS = ("topology-replay", "all-flow-union")
+VALIDATION_SEED = 12345
+RTOL = 1.0e-12
+ATOL = 1.0e-15
+RESULT_KIND = "pyamplicol-recurrence-z6g-benchmark"
+RESULT_SCHEMA = 7
+RAW_NATIVE_WALL_BLOCK_KIND = "pyamplicol-raw-native-wall-blocks"
+RAW_NATIVE_WALL_BLOCK_SCHEMA = 2
+RAW_NATIVE_WALL_MEASUREMENT_CONTRACT = (
+    "warmed-native-wall-minimum-duration-v1"
+)
+ARTIFACT_SEMANTIC_IDENTITY_SCHEMA = 3
+LOGICAL_REDUCTION_ORDER_ABI = "helicity-major-color-minor-v1"
+REUSE_SIGNATURE_KIND = "pyamplicol-benchmark-artifact-reuse-signature"
+REUSE_SIGNATURE_SCHEMA = 3
+PROFILE_SCHEDULE_KIND = "pyamplicol-interleaved-subprocess-profile-schedule"
+PROFILE_SCHEDULE_SCHEMA = 2
+RECURRENCE_RUNTIME_ACCEPTANCE_KIND = "pyamplicol-recurrence-runtime-acceptance"
+RECURRENCE_RUNTIME_ACCEPTANCE_SCHEMA = 1
+PAIRED_PROFILE_READY_KIND = "pyamplicol-paired-profile-ready"
+PAIRED_PROFILE_TOKEN_KIND = "pyamplicol-paired-profile-token"
+PAIRED_PROFILE_COMPLETION_KIND = "pyamplicol-paired-profile-completion"
+PAIRED_PROFILE_COORDINATION_KIND = "pyamplicol-paired-profile-coordination"
+PAIRED_PROFILE_COORDINATION_SCHEMA = 1
+WORKER_VERIFICATION_KIND = "pyamplicol-profile-worker-pre-timing-verification"
+WORKER_VERIFICATION_SCHEMA = 1
+RETAINED_WORKER_RESULT_KIND = "pyamplicol-retained-profile-worker-result"
+RETAINED_WORKER_RESULT_SCHEMA = 1
+PRESERVED_WORKER_RESULT_KIND = "pyamplicol-preserved-worker-result-evidence"
+PRESERVED_WORKER_RESULT_SCHEMA = 1
+CAPTURE_ACCEPTANCE_SCHEMA = 6
+M0_ACCEPTANCE_KIND = "pyamplicol-milestone-0-evidence-manifest"
+M0_ACCEPTANCE_SCHEMA = 4
+_WORKER_MARKER = "PYAMPLICOL_RECURRENCE_Z6G_WORKER_RESULT="
+_SHA256_PATTERN = re.compile(r"[0-9a-f]{64}")
+_REVISION_PATTERN = re.compile(r"[0-9a-f]{40}")
+_RESOURCE_PEAK_SEMANTICS = (
+    "self high-water mark and maximum completed-child high-water mark; "
+    "not an aggregate process-tree sample"
+)
+_RESOURCE_PEAK_KEYS = frozenset(
+    {
+        "source",
+        "self_peak_bytes",
+        "maximum_child_peak_bytes",
+        "observed_lower_bound_bytes",
+        "semantics",
+    }
+)
+MIGRATION_PROCESS_REQUEST = "d d~ > z + 6*g"
+MIGRATION_PROCESS_CANONICAL = "d d~ > Z g g g g g g"
+MIGRATION_PROCESS_NAME = "ddbar_Z_6g"
+MIGRATION_UNION_SELECTED_HELICITY_ID = "h:-1,+1,-1,+1,-1,+1,-1,+1,-1"
+MIGRATION_UNION_SELECTED_HELICITY_VALUES = (-1, 1, -1, 1, -1, 1, -1, 1, -1)
+MIGRATION_UNION_PHYSICAL_COLOR_COUNT = 720
+
+
+def _within_numerical_tolerance(
+    actual: complex | float,
+    expected: complex | float,
+) -> bool:
+    return abs(actual - expected) <= ATOL + RTOL * abs(expected)
+
+
+def _process(gluon_count: int) -> str:
+    return "u u~ > Z" + " g" * gluon_count
+
+
+def _process_name(gluon_count: int) -> str:
+    return f"uubar_Z_{gluon_count}g"
+
+
+def _canonical_process_expression(expression: str) -> str:
+    normalized = " ".join(expression.split())
+    if normalized.casefold() == MIGRATION_PROCESS_REQUEST.casefold():
+        return MIGRATION_PROCESS_CANONICAL
+    return normalized
+
+
+def _selected_process(arguments: argparse.Namespace) -> str:
+    return (
+        _process(arguments.gluon_count)
+        if arguments.process_expression is None
+        else _canonical_process_expression(arguments.process_expression)
+    )
+
+
+def _selected_process_name(arguments: argparse.Namespace) -> str:
+    if arguments.process_expression is None:
+        return _process_name(arguments.gluon_count)
+    if _selected_process(arguments) == MIGRATION_PROCESS_CANONICAL:
+        return MIGRATION_PROCESS_NAME
+    return "custom_process"
+
+
+def _authoritative_process_family(arguments: argparse.Namespace) -> bool:
+    """Return whether the selected process belongs to an acceptance campaign."""
+
+    return (
+        arguments.process_expression is None
+        or _selected_process(arguments) == MIGRATION_PROCESS_CANONICAL
+    )
+
+
+def _selected_union_semantic_exception_enabled(
+    arguments: argparse.Namespace | None,
+) -> bool:
+    """Return whether the one audited union-workload projection is applicable."""
+
+    return bool(
+        arguments is not None
+        and arguments.lc_flow_layout == "all-flow-union"
+        and _selected_process(arguments) == MIGRATION_PROCESS_CANONICAL
+        and arguments.helicity == MIGRATION_UNION_SELECTED_HELICITY_ID
+        and arguments.specialize_flow_at_generation is False
+    )
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return parsed
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return parsed
+
+
+def _rss_bytes(usage: resource.struct_rusage) -> int:
+    """Normalize ru_maxrss (bytes on macOS, KiB on Linux) to bytes."""
+
+    raw = float(usage.ru_maxrss)
+    if platform.system() == "Darwin":
+        return int(raw)
+    return int(raw * 1024.0)
+
+
+def _resource_peak() -> dict[str, object]:
+    self_bytes = _rss_bytes(resource.getrusage(resource.RUSAGE_SELF))
+    children_bytes = _rss_bytes(resource.getrusage(resource.RUSAGE_CHILDREN))
+    return {
+        "source": "resource.getrusage",
+        "self_peak_bytes": self_bytes,
+        "maximum_child_peak_bytes": children_bytes,
+        "observed_lower_bound_bytes": max(self_bytes, children_bytes),
+        "semantics": _RESOURCE_PEAK_SEMANTICS,
+    }
+
+
+def _valid_resource_peak(value: object) -> bool:
+    if not isinstance(value, Mapping):
+        return False
+    self_bytes = value.get("self_peak_bytes")
+    child_bytes = value.get("maximum_child_peak_bytes")
+    observed_bytes = value.get("observed_lower_bound_bytes")
+    return (
+        value.get("source") == "resource.getrusage"
+        and not isinstance(self_bytes, bool)
+        and isinstance(self_bytes, int)
+        and self_bytes >= 0
+        and not isinstance(child_bytes, bool)
+        and isinstance(child_bytes, int)
+        and child_bytes >= 0
+        and not isinstance(observed_bytes, bool)
+        and isinstance(observed_bytes, int)
+        and observed_bytes == max(self_bytes, child_bytes)
+        and isinstance(value.get("semantics"), str)
+        and bool(value["semantics"])
+    )
+
+
+def _artifact_stats(path: Path) -> dict[str, int]:
+    file_count = 0
+    size_bytes = 0
+    for root, _directories, files in os.walk(path):
+        directory = Path(root)
+        for name in files:
+            candidate = directory / name
+            if candidate.is_file():
+                file_count += 1
+                size_bytes += candidate.stat().st_size
+    return {"file_count": file_count, "size_bytes": size_bytes}
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _path_identity(path: Path) -> dict[str, object]:
+    try:
+        resolved = path.expanduser().resolve(strict=True)
+        stat = resolved.stat()
+    except OSError as error:
+        raise HarnessError(f"cannot inspect file identity: {path}") from error
+    if not resolved.is_file():
+        raise HarnessError(f"identity path is not a regular file: {path}")
+    return {
+        "path": str(path),
+        "resolved_path": str(resolved),
+        "size_bytes": stat.st_size,
+        "sha256": _sha256_file(resolved),
+    }
+
+
+def _path_state_identity(path: Path) -> dict[str, object]:
+    """Record both present and legitimately absent provenance inputs."""
+
+    if path.exists():
+        if not path.is_file():
+            raise HarnessError(f"provenance path is not a regular file: {path}")
+        return {
+            "present": True,
+            **_path_identity(path),
+        }
+    return {
+        "present": False,
+        "path": str(path),
+        "resolved_path": str(path.expanduser().resolve(strict=False)),
+    }
+
+
+def _tree_identity(path: Path) -> dict[str, object]:
+    """Hash relative names and contents for a location-independent tree ID."""
+
+    try:
+        root = path.resolve(strict=True)
+    except OSError as error:
+        raise HarnessError(f"cannot resolve identity tree: {path}") from error
+    if not root.is_dir():
+        raise HarnessError(f"identity tree is not a directory: {path}")
+    digest = hashlib.sha256()
+    file_count = 0
+    size_bytes = 0
+    try:
+        candidates = list(root.rglob("*"))
+        for candidate in candidates:
+            if candidate.is_symlink():
+                raise HarnessError(
+                    f"identity tree contains an unsupported symlink: {candidate}"
+                )
+        members = sorted(
+            (candidate for candidate in candidates if candidate.is_file()),
+            key=lambda candidate: candidate.relative_to(root).as_posix(),
+        )
+        for member in members:
+            relative_text = member.relative_to(root).as_posix()
+            relative = relative_text.encode("utf-8")
+            size = member.stat().st_size
+            digest.update(len(relative).to_bytes(8, "big"))
+            digest.update(relative)
+            digest.update(size.to_bytes(8, "big"))
+            with member.open("rb") as stream:
+                for block in iter(lambda: stream.read(1024 * 1024), b""):
+                    digest.update(block)
+            file_count += 1
+            size_bytes += size
+    except OSError as error:
+        raise HarnessError(f"cannot hash identity tree: {path}") from error
+    return {
+        "algorithm": "sha256-relative-path-size-content-v1",
+        "sha256": digest.hexdigest(),
+        "file_count": file_count,
+        "size_bytes": size_bytes,
+    }
+
+
+def _canonical_sha256(value: object) -> str:
+    encoded = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _command_identity(command: Sequence[object]) -> dict[str, object]:
+    argv = [str(value) for value in command]
+    return {
+        "argv": argv,
+        "argv_sha256": _canonical_sha256(argv),
+    }
+
+
+def _json_object(path: Path, *, label: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise HarnessError(f"cannot read {label}: {path}") from error
+    if not isinstance(payload, dict):
+        raise HarnessError(f"{label} must be a JSON object: {path}")
+    return payload
+
+
+def _utc_now() -> str:
+    return dt.datetime.now(dt.UTC).isoformat()
+
+
+def _parse_utc_timestamp(value: object) -> dt.datetime | None:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        parsed = dt.datetime.fromisoformat(value)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None or parsed.utcoffset() != dt.timedelta(0):
+        return None
+    return parsed
+
+
+def _is_utc_timestamp(value: object) -> bool:
+    return _parse_utc_timestamp(value) is not None
+
+
+def _utc_timestamps_nondecreasing(*values: object) -> bool:
+    parsed: list[dt.datetime] = []
+    for value in values:
+        timestamp = _parse_utc_timestamp(value)
+        if timestamp is None:
+            return False
+        parsed.append(timestamp)
+    return all(left <= right for left, right in pairwise(parsed))
+
+
+def _is_exact_int(value: object, expected: int) -> bool:
+    return not isinstance(value, bool) and isinstance(value, int) and value == expected
+
+
+def _host_identity() -> dict[str, object]:
+    cpu_model = platform.processor().strip()
+    if not cpu_model and platform.system() == "Darwin":
+        completed = subprocess.run(
+            ("sysctl", "-n", "machdep.cpu.brand_string"),
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if completed.returncode == 0:
+            cpu_model = completed.stdout.strip()
+    if not cpu_model and platform.system() == "Linux":
+        try:
+            for line in Path("/proc/cpuinfo").read_text(encoding="utf-8").splitlines():
+                if line.casefold().startswith(("model name", "hardware")):
+                    cpu_model = line.partition(":")[2].strip()
+                    break
+        except OSError:
+            pass
+    uname = platform.uname()
+    return {
+        "platform": platform.platform(),
+        "system": uname.system,
+        "release": uname.release,
+        "version": uname.version,
+        "machine": uname.machine,
+        "processor": uname.processor,
+        "cpu_model": cpu_model or None,
+        "logical_cpu_count": os.cpu_count(),
+    }
+
+
+def _git_source_identity() -> dict[str, object]:
+    revision = subprocess.run(
+        ("git", "rev-parse", "--verify", "HEAD"),
+        cwd=ROOT,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    head = revision.stdout.strip()
+    if revision.returncode != 0 or _REVISION_PATTERN.fullmatch(head) is None:
+        raise HarnessError("benchmark source has no Git revision")
+    status = subprocess.run(
+        ("git", "status", "--porcelain=v1", "--untracked-files=all"),
+        cwd=ROOT,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if status.returncode != 0:
+        raise HarnessError("could not determine benchmark source cleanliness")
+    if status.stdout.strip():
+        raise HarnessError(
+            "benchmark source is dirty; commit or discard tracked and "
+            "untracked changes before measuring"
+        )
+    return {
+        "checkout": str(ROOT.resolve()),
+        "revision": head,
+        "dirty": False,
+        "untracked_files_checked": True,
+    }
+
+
+def _installed_distribution_identity() -> dict[str, object]:
+    try:
+        distribution = importlib.metadata.distribution("pyamplicol")
+    except importlib.metadata.PackageNotFoundError as error:
+        raise HarnessError(
+            "benchmark interpreter has no installed pyamplicol distribution"
+        ) from error
+    digest = hashlib.sha256()
+    file_count = 0
+    size_bytes = 0
+    native_modules: list[dict[str, object]] = []
+    build_info_files: list[dict[str, object]] = []
+    for entry in sorted(distribution.files or (), key=str):
+        relative_text = str(entry)
+        path = Path(str(distribution.locate_file(entry)))
+        if not path.is_file():
+            continue
+        resolved = path.resolve(strict=True)
+        relative = relative_text.encode("utf-8")
+        size = resolved.stat().st_size
+        digest.update(len(relative).to_bytes(8, "big"))
+        digest.update(relative)
+        digest.update(size.to_bytes(8, "big"))
+        with resolved.open("rb") as stream:
+            for block in iter(lambda: stream.read(1024 * 1024), b""):
+                digest.update(block)
+        file_count += 1
+        size_bytes += size
+        identity = {
+            "relative_path": relative_text,
+            **_path_identity(resolved),
+        }
+        if resolved.name.startswith("_rusticol.") and resolved.suffix in {
+            ".so",
+            ".pyd",
+            ".dylib",
+        }:
+            native_modules.append(identity)
+        if relative_text.endswith("pyamplicol/_build_info.json"):
+            build_info_files.append(identity)
+    return {
+        "package_version": distribution.version,
+        "distribution_content": {
+            "algorithm": "sha256-relative-path-size-content-v1",
+            "sha256": digest.hexdigest(),
+            "file_count": file_count,
+            "size_bytes": size_bytes,
+        },
+        "native_modules": native_modules,
+        "build_info_files": build_info_files,
+    }
+
+
+def _active_build_info_identity() -> dict[str, object]:
+    try:
+        versions = importlib.import_module("pyamplicol._internal.versions")
+        payload = versions._active_build_info()
+    except (AttributeError, ImportError, RuntimeError) as error:
+        raise HarnessError(
+            "cannot resolve active pyamplicol build provenance"
+        ) from error
+    if not isinstance(payload, dict):
+        raise HarnessError(
+            "active pyamplicol runtime has no strict build-provenance record"
+        )
+    candidate_paths = (
+        getattr(versions, "_SOURCE_BUILD_INFO_PATH", None),
+        getattr(versions, "_PACKAGE_BUILD_INFO_PATH", None),
+    )
+    matching: list[Path] = []
+    for raw_path in candidate_paths:
+        if not isinstance(raw_path, Path) or not raw_path.is_file():
+            continue
+        try:
+            candidate = json.loads(raw_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        if candidate == payload:
+            matching.append(raw_path)
+    if not matching:
+        raise HarnessError("active pyamplicol build provenance has no file identity")
+    path = matching[0]
+    return {
+        **_path_identity(path),
+        "payload": payload,
+    }
+
+
+def _validate_runtime_binding(
+    source_identity: Mapping[str, object],
+    build_info: Mapping[str, object],
+    *,
+    native_build_inputs_sha256: str,
+) -> None:
+    revision = source_identity.get("revision")
+    checkout = source_identity.get("checkout")
+    build_revision = build_info.get("source_revision")
+    build_checkout = build_info.get("source_checkout")
+    build_digest = build_info.get("native_build_inputs_sha256")
+    if (
+        not isinstance(revision, str)
+        or _REVISION_PATTERN.fullmatch(revision) is None
+        or not isinstance(checkout, str)
+    ):
+        raise HarnessError("benchmark source identity is incomplete")
+    if (
+        not isinstance(build_revision, str)
+        or _REVISION_PATTERN.fullmatch(build_revision) is None
+    ):
+        raise HarnessError(
+            "installed runtime has no clean source revision; rebuild from this checkout"
+        )
+    if build_revision != revision:
+        raise HarnessError(
+            "installed runtime source revision does not match benchmark HEAD"
+        )
+    if not isinstance(build_checkout, str) or not build_checkout:
+        raise HarnessError("installed runtime has no source-checkout identity")
+    try:
+        bound_checkout = Path(build_checkout).expanduser().resolve(strict=True)
+        source_checkout = Path(checkout).expanduser().resolve(strict=True)
+    except OSError as error:
+        raise HarnessError(
+            "installed runtime source checkout is unavailable"
+        ) from error
+    if bound_checkout != source_checkout:
+        raise HarnessError(
+            "installed runtime was built from a different source checkout"
+        )
+    if (
+        not isinstance(build_digest, str)
+        or _SHA256_PATTERN.fullmatch(build_digest) is None
+        or build_digest != native_build_inputs_sha256
+    ):
+        raise HarnessError(
+            "installed runtime native build inputs do not match its build provenance"
+        )
+
+
+def _runtime_provenance(
+    source_identity: Mapping[str, object],
+) -> dict[str, object]:
+    try:
+        native = importlib.import_module("pyamplicol._rusticol")
+    except ImportError as error:
+        raise HarnessError(
+            "benchmark provenance requires the pyamplicol._rusticol extension"
+        ) from error
+    native_path_raw = getattr(native, "__file__", None)
+    if not isinstance(native_path_raw, str):
+        raise HarnessError("native runtime extension has no filesystem identity")
+    native_path = Path(native_path_raw).resolve()
+    native_digest = getattr(native, "native_build_inputs_sha256", None)
+    if not callable(native_digest):
+        raise HarnessError("native runtime exposes no build-input digest")
+    build_inputs_sha256 = native_digest()
+    if (
+        not isinstance(build_inputs_sha256, str)
+        or _SHA256_PATTERN.fullmatch(build_inputs_sha256) is None
+    ):
+        raise HarnessError("native runtime build-input digest is invalid")
+    build_info_identity = _active_build_info_identity()
+    raw_build_info = build_info_identity.get("payload")
+    if not isinstance(raw_build_info, Mapping):
+        raise HarnessError("active pyamplicol build provenance is invalid")
+    _validate_runtime_binding(
+        source_identity,
+        raw_build_info,
+        native_build_inputs_sha256=build_inputs_sha256,
+    )
+    dependency_paths = (
+        ROOT / "Cargo.lock",
+        ROOT / "Cargo.toml",
+        ROOT / "pyproject.toml",
+        ROOT / "rust-toolchain.toml",
+        ROOT / "dependencies" / "candidate-Cargo.lock",
+        ROOT / "dependencies" / "candidate-cargo-config.toml",
+        ROOT / "dependencies" / "contributor-lock.toml",
+        ROOT / "dependencies" / "install-state.json",
+        ROOT / "dependencies" / "python-runtime-lock.toml",
+        ROOT / "dependencies" / "release-lock.toml",
+    )
+    native_identity = _path_identity(native_path)
+    native_version = getattr(native, "package_version", None)
+    native_package_version = native_version() if callable(native_version) else None
+    distribution_identity = _installed_distribution_identity()
+    if (
+        isinstance(native_package_version, str)
+        and native_package_version.replace("-dev.", ".dev")
+        != distribution_identity["package_version"]
+    ):
+        raise HarnessError(
+            "native runtime package version does not match installed distribution"
+        )
+    return {
+        "interpreter": {
+            **_path_identity(Path(sys.executable)),
+            "python_version": platform.python_version(),
+            "implementation": platform.python_implementation(),
+        },
+        "installed_distribution": distribution_identity,
+        "active_build_info": build_info_identity,
+        "native_extension": {
+            **native_identity,
+            "package_version": native_package_version,
+            "build_inputs_sha256": build_inputs_sha256,
+        },
+        "dependencies": {
+            str(path.relative_to(ROOT)): _path_state_identity(path)
+            for path in dependency_paths
+        },
+    }
+
+
+def _validate_expected_runtime_identity(
+    source_identity: Mapping[str, object],
+    runtime_provenance: Mapping[str, object],
+    *,
+    expected_source_revision: str | None,
+    expected_native_build_inputs_sha256: str | None,
+) -> None:
+    if (expected_source_revision is None) != (
+        expected_native_build_inputs_sha256 is None
+    ):
+        raise HarnessError(
+            "expected source revision and native-build-input digest must be "
+            "provided together"
+        )
+    if expected_source_revision is None:
+        return
+    if _REVISION_PATTERN.fullmatch(expected_source_revision) is None:
+        raise HarnessError("expected source revision is not a full Git revision")
+    if (
+        expected_native_build_inputs_sha256 is None
+        or _SHA256_PATTERN.fullmatch(expected_native_build_inputs_sha256) is None
+    ):
+        raise HarnessError(
+            "expected native-build-input digest is not a SHA-256 value"
+        )
+    native_extension = runtime_provenance.get("native_extension")
+    if not isinstance(native_extension, Mapping):
+        raise HarnessError("active runtime provenance has no native extension")
+    if source_identity.get("revision") != expected_source_revision:
+        raise HarnessError(
+            "benchmark source revision does not match the externally pinned "
+            "revision"
+        )
+    if (
+        native_extension.get("build_inputs_sha256")
+        != expected_native_build_inputs_sha256
+    ):
+        raise HarnessError(
+            "benchmark native build does not match the externally pinned "
+            "build-input digest"
+        )
+
+
+def _selected_model_identity(
+    arguments: argparse.Namespace,
+    *,
+    mode: str,
+    source_identity: Mapping[str, object],
+) -> dict[str, object]:
+    if arguments.prepared_model is not None:
+        path = arguments.prepared_model.expanduser().resolve(strict=True)
+        if not path.is_file():
+            raise HarnessError(f"prepared model does not exist: {path}")
+        return {
+            "kind": "explicit-prepared-model",
+            "resource_id": None,
+            "file": _path_identity(path),
+            "compile_excluded_from_generation": True,
+        }
+    if mode == "compiled":
+        return {
+            "kind": "built-in-sm-source",
+            "resource_id": None,
+            "source_revision": source_identity["revision"],
+            "compile_excluded_from_generation": False,
+        }
+    try:
+        from pyamplicol.assets.prepared_models import (
+            BUILTIN_SM_JIT_O2,
+            packaged_prepared_model_path,
+        )
+
+        with packaged_prepared_model_path(BUILTIN_SM_JIT_O2) as path:
+            identity = _path_identity(path)
+    except (ImportError, OSError, RuntimeError) as error:
+        raise HarnessError(
+            "cannot resolve the packaged built-in prepared model"
+        ) from error
+    return {
+        "kind": "packaged-prepared-model",
+        "resource_id": PREPARED_MODEL_ID,
+        "size_bytes": identity["size_bytes"],
+        "sha256": identity["sha256"],
+        "compile_excluded_from_generation": True,
+    }
+
+
+def _validate_worker_model_identity(
+    expected: Mapping[str, object],
+    observed: object,
+) -> None:
+    if not isinstance(observed, Mapping):
+        raise HarnessError("generation worker returned no model identity")
+    for key in ("kind", "resource_id", "compile_excluded_from_generation"):
+        if observed.get(key) != expected.get(key):
+            raise HarnessError(f"generation worker model identity disagrees on {key}")
+    expected_file = expected.get("file")
+    observed_file = observed.get("file")
+    if isinstance(expected_file, Mapping):
+        if not isinstance(observed_file, Mapping):
+            raise HarnessError(
+                "generation worker returned no explicit model file identity"
+            )
+        for key in ("resolved_path", "size_bytes", "sha256"):
+            if observed_file.get(key) != expected_file.get(key):
+                raise HarnessError(
+                    f"generation worker explicit model disagrees on {key}"
+                )
+    elif expected.get("kind") == "packaged-prepared-model":
+        for key in ("size_bytes", "sha256"):
+            if observed.get(key) != expected.get(key):
+                raise HarnessError(
+                    f"generation worker packaged model disagrees on {key}"
+                )
+
+
+def _semantic_generation_signature(
+    arguments: argparse.Namespace,
+    *,
+    mode: str,
+    source_identity: Mapping[str, object],
+    runtime_provenance: Mapping[str, object],
+    model_identity: Mapping[str, object],
+) -> dict[str, object]:
+    selected_flow_word = _generation_selected_flow_word(arguments)
+    return {
+        "kind": "pyamplicol-benchmark-generation-signature",
+        "schema_version": 1,
+        "source_revision": source_identity["revision"],
+        "runtime_provenance_sha256": _canonical_sha256(runtime_provenance),
+        "mode": mode,
+        "process": " ".join(_selected_process(arguments).split()).casefold(),
+        "model": dict(model_identity),
+        "color_accuracy": "lc",
+        "lc_flow_layout": arguments.lc_flow_layout,
+        "jit_optimization_level": arguments.jit_optimization_level,
+        "point_tile_size": arguments.point_tile_size,
+        "validation": {
+            "enabled": True,
+            "samples": arguments.validation_samples,
+            "seed": VALIDATION_SEED,
+            "relative_tolerance": RTOL,
+            "absolute_tolerance": ATOL,
+            "post_build_validation": True,
+        },
+        "generation": {
+            "workers": 1,
+            "emit_api_bundle": False,
+            "specialize_flow_at_generation": (arguments.specialize_flow_at_generation),
+            "selected_flow_word": (
+                None
+                if selected_flow_word is None
+                else [int(label) for label in selected_flow_word]
+            ),
+        },
+    }
+
+
+def _artifact_payload_digests(
+    manifest: Mapping[str, object],
+    *,
+    artifact: Path,
+) -> list[dict[str, object]]:
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise HarnessError(f"artifact has no payload digest inventory: {artifact}")
+    root = artifact.resolve(strict=True)
+    result: list[dict[str, object]] = []
+    for entry in payloads:
+        if not isinstance(entry, Mapping):
+            raise HarnessError(f"artifact payload entry is invalid: {artifact}")
+        relative = entry.get("path")
+        expected_sha256 = entry.get("sha256")
+        expected_size = entry.get("size_bytes")
+        if (
+            not isinstance(relative, str)
+            or not relative
+            or not isinstance(expected_sha256, str)
+            or _SHA256_PATTERN.fullmatch(expected_sha256) is None
+            or isinstance(expected_size, bool)
+            or not isinstance(expected_size, int)
+            or expected_size < 0
+        ):
+            raise HarnessError(f"artifact payload identity is invalid: {artifact}")
+        try:
+            path = (artifact / relative).resolve(strict=True)
+            path.relative_to(root)
+        except (OSError, ValueError) as error:
+            raise HarnessError(
+                f"artifact payload escapes or is missing: {relative!r}"
+            ) from error
+        observed = _path_identity(path)
+        if (
+            observed["size_bytes"] != expected_size
+            or observed["sha256"] != expected_sha256
+        ):
+            raise HarnessError(
+                f"artifact payload does not match its manifest: {relative!r}"
+            )
+        result.append(
+            {
+                "path": relative,
+                "size_bytes": expected_size,
+                "sha256": expected_sha256,
+                "role": entry.get("role"),
+                "process_id": entry.get("process_id"),
+            }
+        )
+    return sorted(result, key=lambda item: str(item["path"]))
+
+
+def _artifact_member(
+    artifact: Path,
+    relative: object,
+    *,
+    label: str,
+) -> Path:
+    if not isinstance(relative, str) or not relative:
+        raise HarnessError(f"artifact has no {label} path: {artifact}")
+    try:
+        root = artifact.resolve(strict=True)
+        member = (artifact / relative).resolve(strict=True)
+        member.relative_to(root)
+    except (OSError, ValueError) as error:
+        raise HarnessError(
+            f"artifact {label} escapes or is missing: {relative!r}"
+        ) from error
+    if not member.is_file():
+        raise HarnessError(f"artifact {label} is not a regular file: {member}")
+    return member
+
+
+def _ordered_physical_axis(
+    raw_entries: object,
+    *,
+    label: str,
+    require_structural_zero: bool,
+) -> dict[str, object]:
+    if not isinstance(raw_entries, list) or not raw_entries:
+        raise HarnessError(f"artifact physical {label} axis is missing")
+    identifiers: list[str] = []
+    entries: list[dict[str, object]] = []
+    for expected_index, raw_entry in enumerate(raw_entries):
+        if not isinstance(raw_entry, Mapping):
+            raise HarnessError(f"artifact physical {label} entry is invalid")
+        index = raw_entry.get("index")
+        identifier = raw_entry.get("id")
+        representative_id = raw_entry.get("representative_id")
+        computed = raw_entry.get("computed")
+        structural_zero = raw_entry.get("structural_zero")
+        coefficient = raw_entry.get("coefficient")
+        color_kind = raw_entry.get("kind")
+        color_word = raw_entry.get("word")
+        helicity_values = raw_entry.get("values")
+        if (
+            isinstance(index, bool)
+            or not isinstance(index, int)
+            or index != expected_index
+            or not isinstance(identifier, str)
+            or not identifier
+            or identifier in identifiers
+            or not isinstance(representative_id, str)
+            or not representative_id
+            or not isinstance(computed, bool)
+            or (require_structural_zero and not isinstance(structural_zero, bool))
+            or isinstance(coefficient, bool)
+            or not isinstance(coefficient, (float, int))
+            or not math.isfinite(float(coefficient))
+            or (
+                require_structural_zero
+                and (
+                    not isinstance(helicity_values, list)
+                    or not helicity_values
+                    or any(
+                        isinstance(value, bool) or not isinstance(value, int)
+                        for value in helicity_values
+                    )
+                )
+            )
+            or (
+                not require_structural_zero
+                and (
+                    color_kind != "lc-flow"
+                    or not isinstance(color_word, list)
+                    or not color_word
+                    or structural_zero is not None
+                    or any(
+                        isinstance(value, bool)
+                        or not isinstance(value, int)
+                        or value <= 0
+                        for value in color_word
+                    )
+                )
+            )
+        ):
+            raise HarnessError(
+                f"artifact physical {label} axis is not complete and ordered"
+            )
+        if require_structural_zero:
+            assert isinstance(helicity_values, list)
+            axis_details: dict[str, object] = {"values": list(helicity_values)}
+        else:
+            assert isinstance(color_word, list)
+            axis_details = {
+                "kind": color_kind,
+                "word": list(color_word),
+            }
+        identifiers.append(identifier)
+        entries.append(
+            {
+                "index": index,
+                "id": identifier,
+                "representative_id": representative_id,
+                "computed": computed,
+                "coefficient": float(coefficient),
+                "structural_zero": (
+                    structural_zero if require_structural_zero else None
+                ),
+                **axis_details,
+            }
+        )
+    by_identifier = {str(entry["id"]): entry for entry in entries}
+    for entry in entries:
+        representative_id = str(entry["representative_id"])
+        representative = by_identifier.get(representative_id)
+        computed = entry["computed"] is True
+        structural_zero = entry["structural_zero"] is True
+        if (
+            representative is None
+            or (computed and representative_id != entry["id"])
+            or (structural_zero and (computed or representative_id != entry["id"]))
+            or (structural_zero and entry["coefficient"] != 0.0)
+            or (
+                require_structural_zero
+                and not structural_zero
+                and entry["coefficient"] == 0.0
+            )
+            or (not structural_zero and representative.get("computed") is not True)
+        ):
+            raise HarnessError(
+                f"artifact physical {label} representative mapping is not closed"
+            )
+    return {
+        "count": len(identifiers),
+        "ordered_ids": identifiers,
+        "ordered_ids_sha256": _canonical_sha256(identifiers),
+        "ordered_entries": entries,
+        "ordered_entries_sha256": _canonical_sha256(entries),
+    }
+
+
+def _logical_physical_axis(
+    validated_axis: Mapping[str, object],
+    *,
+    require_structural_zero: bool,
+) -> dict[str, object]:
+    """Project a validated axis onto lane-independent physical fields."""
+
+    raw_entries = validated_axis.get("ordered_entries")
+    if not isinstance(raw_entries, list) or not raw_entries:
+        raise HarnessError("validated physical axis has no ordered entries")
+    entries: list[dict[str, object]] = []
+    for raw_entry in raw_entries:
+        if not isinstance(raw_entry, Mapping):
+            raise HarnessError("validated physical axis entry is invalid")
+        if require_structural_zero:
+            entry = {
+                "index": raw_entry["index"],
+                "id": raw_entry["id"],
+                "values": list(cast(list[int], raw_entry["values"])),
+                "coefficient": raw_entry["coefficient"],
+                "structural_zero": raw_entry["structural_zero"],
+            }
+        else:
+            entry = {
+                "index": raw_entry["index"],
+                "id": raw_entry["id"],
+                "kind": raw_entry["kind"],
+                "word": list(cast(list[int], raw_entry["word"])),
+                "coefficient": raw_entry["coefficient"],
+            }
+        entries.append(entry)
+    identifiers = [str(entry["id"]) for entry in entries]
+    return {
+        "count": len(identifiers),
+        "ordered_ids": identifiers,
+        "ordered_ids_sha256": _canonical_sha256(identifiers),
+        "ordered_entries": entries,
+        "ordered_entries_sha256": _canonical_sha256(entries),
+    }
+
+
+def _validated_logical_physical_axis(
+    axis: Mapping[str, object],
+    *,
+    label: str,
+    require_structural_zero: bool,
+) -> dict[str, object]:
+    """Revalidate a stored lane-independent physical-axis projection."""
+
+    raw_entries = axis.get("ordered_entries")
+    if not isinstance(raw_entries, list) or not raw_entries:
+        raise HarnessError(f"logical physical {label} axis is missing")
+    expanded: list[dict[str, object]] = []
+    expected_keys = (
+        {"index", "id", "values", "coefficient", "structural_zero"}
+        if require_structural_zero
+        else {"index", "id", "kind", "word", "coefficient"}
+    )
+    for raw_entry in raw_entries:
+        if not isinstance(raw_entry, Mapping) or set(raw_entry) != expected_keys:
+            raise HarnessError(f"logical physical {label} axis is invalid")
+        identifier = raw_entry.get("id")
+        structural_zero = (
+            raw_entry.get("structural_zero") if require_structural_zero else False
+        )
+        expanded.append(
+            {
+                **dict(raw_entry),
+                "representative_id": identifier,
+                "computed": not bool(structural_zero),
+            }
+        )
+    validated = _logical_physical_axis(
+        _ordered_physical_axis(
+            expanded,
+            label=label,
+            require_structural_zero=require_structural_zero,
+        ),
+        require_structural_zero=require_structural_zero,
+    )
+    if set(axis) != {
+        "count",
+        "ordered_ids",
+        "ordered_ids_sha256",
+        "ordered_entries",
+        "ordered_entries_sha256",
+    } or any(
+        (
+            not _is_exact_int(axis.get(field), cast(int, validated[field]))
+            if field == "count"
+            else _canonical_sha256(axis.get(field))
+            != _canonical_sha256(validated[field])
+        )
+        for field in (
+            "count",
+            "ordered_ids",
+            "ordered_ids_sha256",
+            "ordered_entries",
+            "ordered_entries_sha256",
+        )
+    ):
+        raise HarnessError(f"logical physical {label} axis is invalid")
+    return validated
+
+
+def _manifest_model_identity(manifest: Mapping[str, object]) -> dict[str, object]:
+    model = manifest.get("model")
+    if not isinstance(model, Mapping):
+        raise HarnessError("artifact manifest has no model identity")
+    name = model.get("name")
+    content_sha256 = model.get("content_sha256")
+    compiled_schema_version = model.get("compiled_schema_version")
+    restriction = model.get("restriction")
+    source_kind = model.get("source_kind")
+    if (
+        not isinstance(name, str)
+        or not name
+        or not isinstance(content_sha256, str)
+        or _SHA256_PATTERN.fullmatch(content_sha256) is None
+        or isinstance(compiled_schema_version, bool)
+        or not isinstance(compiled_schema_version, int)
+        or compiled_schema_version <= 0
+        or (restriction is not None and not isinstance(restriction, str))
+        or not isinstance(source_kind, str)
+        or not source_kind
+    ):
+        raise HarnessError("artifact manifest model identity is incomplete")
+    common_identity = {
+        "name": name,
+        "content_sha256": content_sha256,
+        "compiled_schema_version": compiled_schema_version,
+        "restriction": restriction,
+    }
+    full_identity = {
+        **common_identity,
+        "source_kind": source_kind,
+    }
+    return {
+        "manifest": full_identity,
+        "manifest_sha256": _canonical_sha256(full_identity),
+        "common_physics_identity": common_identity,
+        "common_physics_identity_sha256": _canonical_sha256(common_identity),
+    }
+
+
+def _runtime_selector_semantic_identity(
+    runtime_selectors: Mapping[str, object],
+    *,
+    color_coverage: str,
+    helicity_coverage: str,
+    artifact: Path,
+) -> dict[str, object]:
+    axes = runtime_selectors.get("axes")
+    specialized_axes = runtime_selectors.get("generation_specialized_axes")
+    if (
+        runtime_selectors.get("kind") != "pyamplicol-runtime-selectors"
+        or not _is_exact_int(runtime_selectors.get("contract_version"), 1)
+        or not isinstance(axes, Mapping)
+        or set(axes) != {"color_flow", "helicity"}
+        or not isinstance(specialized_axes, list)
+        or any(axis not in {"helicity", "color_flow"} for axis in specialized_axes)
+        or len(set(specialized_axes)) != len(specialized_axes)
+    ):
+        raise HarnessError(
+            f"artifact runtime-selector semantics are incomplete: {artifact}"
+        )
+    color_axis = axes.get("color_flow")
+    helicity_axis = axes.get("helicity")
+    if not isinstance(color_axis, Mapping) or not isinstance(
+        helicity_axis,
+        Mapping,
+    ):
+        raise HarnessError(f"artifact runtime-selector axes are incomplete: {artifact}")
+    if set(color_axis) != {
+        "generation_coverage",
+        "generation_selection",
+        "runtime_contract",
+    } or set(helicity_axis) != {
+        "generation_coverage",
+        "generation_selection",
+        "runtime_contract",
+    }:
+        raise HarnessError(
+            f"artifact runtime-selector axis fields are incomplete: {artifact}"
+        )
+    color_selection = color_axis.get("generation_selection")
+    helicity_selection = helicity_axis.get("generation_selection")
+    if (
+        not isinstance(color_selection, list)
+        or any(
+            isinstance(value, bool) or not isinstance(value, int) or value < 0
+            for value in color_selection
+        )
+        or len(set(color_selection)) != len(color_selection)
+        or not isinstance(helicity_selection, Mapping)
+        or any(
+            not isinstance(label, str)
+            or not label
+            or isinstance(value, bool)
+            or not isinstance(value, int)
+            for label, value in helicity_selection.items()
+        )
+    ):
+        raise HarnessError(
+            f"artifact runtime-selector generation selection is invalid: {artifact}"
+        )
+    color_complete = color_coverage == "complete" and not color_selection
+    helicity_complete = helicity_coverage == "complete" and not helicity_selection
+    expected_specialized_axes = [
+        *(["helicity"] if not helicity_complete else []),
+        *(["color_flow"] if not color_complete else []),
+    ]
+    if (
+        color_axis.get("generation_coverage") != color_coverage
+        or helicity_axis.get("generation_coverage") != helicity_coverage
+        or color_axis.get("runtime_contract")
+        != ("complete-reusable" if color_complete else "generation-specialized")
+        or helicity_axis.get("runtime_contract")
+        != ("complete-reusable" if helicity_complete else "generation-specialized")
+        or (
+            not color_complete and (color_coverage != "selected" or not color_selection)
+        )
+        or (
+            not helicity_complete
+            and (helicity_coverage != "selected" or not helicity_selection)
+        )
+        or specialized_axes != expected_specialized_axes
+    ):
+        raise HarnessError(
+            "artifact runtime-selector axes disagree with physical coverage: "
+            f"{artifact}"
+        )
+    return {
+        "kind": "pyamplicol-runtime-selectors",
+        "contract_version": 1,
+        "axes": {
+            "color_flow": dict(color_axis),
+            "helicity": dict(helicity_axis),
+        },
+        "generation_specialized_axes": list(specialized_axes),
+    }
+
+
+def _reduction_ordering_identity(
+    reduction: Mapping[str, object],
+    *,
+    color_axis: Mapping[str, object],
+    helicity_axis: Mapping[str, object],
+    artifact: Path,
+) -> dict[str, object]:
+    reduction_kind = reduction.get("kind")
+    raw_groups = reduction.get("groups")
+    if (
+        not isinstance(reduction_kind, str)
+        or not reduction_kind
+        or not isinstance(raw_groups, list)
+    ):
+        raise HarnessError(f"artifact ordered reduction groups are missing: {artifact}")
+    raw_color_entries = color_axis.get("ordered_entries")
+    raw_helicity_entries = helicity_axis.get("ordered_entries")
+    if not isinstance(raw_color_entries, list) or not isinstance(
+        raw_helicity_entries,
+        list,
+    ):
+        raise HarnessError(f"artifact physical axes cannot bind reduction: {artifact}")
+    color_entries = {
+        str(entry["id"]): entry
+        for entry in raw_color_entries
+        if isinstance(entry, Mapping)
+    }
+    helicity_entries = {
+        str(entry["id"]): entry
+        for entry in raw_helicity_entries
+        if isinstance(entry, Mapping)
+    }
+    color_ids = set(color_entries)
+    computed_color_ids = {
+        identifier
+        for identifier, entry in color_entries.items()
+        if entry.get("computed") is True
+    }
+    live_helicity_ids = {
+        identifier
+        for identifier, entry in helicity_entries.items()
+        if entry.get("structural_zero") is False
+    }
+    reduction_groups: list[dict[str, object]] = []
+    group_ids: list[str] = []
+    observed_pairs: set[tuple[str, str]] = set()
+    coverage_errors: list[str] = []
+    for raw_group in raw_groups:
+        if not isinstance(raw_group, Mapping):
+            raise HarnessError(
+                f"artifact ordered reduction group is invalid: {artifact}"
+            )
+        group_id = raw_group.get("id")
+        group_color_ids = raw_group.get("physical_color_ids")
+        group_helicity_ids = raw_group.get("physical_helicity_ids")
+        representative_color_id = raw_group.get("representative_color_id")
+        representative_helicity_id = raw_group.get("representative_helicity_id")
+        if (
+            not isinstance(group_id, str)
+            or not group_id
+            or group_id in group_ids
+            or not isinstance(group_color_ids, list)
+            or not group_color_ids
+            or not isinstance(group_helicity_ids, list)
+            or not group_helicity_ids
+            or any(not isinstance(value, str) or not value for value in group_color_ids)
+            or any(
+                not isinstance(value, str) or not value for value in group_helicity_ids
+            )
+            or len(set(group_color_ids)) != len(group_color_ids)
+            or len(set(group_helicity_ids)) != len(group_helicity_ids)
+            or not isinstance(representative_color_id, str)
+            or not isinstance(representative_helicity_id, str)
+        ):
+            raise HarnessError(
+                f"artifact ordered reduction group is incomplete: {artifact}"
+            )
+        group_ids.append(group_id)
+        if (
+            not set(group_color_ids) <= color_ids
+            or not set(group_helicity_ids) <= live_helicity_ids
+            or representative_color_id not in group_color_ids
+            or representative_helicity_id not in group_helicity_ids
+            or color_entries[representative_color_id].get("computed") is not True
+            or helicity_entries[representative_helicity_id].get("computed") is not True
+            or any(
+                color_entries[identifier].get("representative_id")
+                != representative_color_id
+                for identifier in group_color_ids
+            )
+            or any(
+                helicity_entries[identifier].get("representative_id")
+                != representative_helicity_id
+                for identifier in group_helicity_ids
+            )
+        ):
+            raise HarnessError(
+                f"artifact reduction group is not closed over physical axes: {artifact}"
+            )
+        for color_id in group_color_ids:
+            for helicity_id in group_helicity_ids:
+                pair = (color_id, helicity_id)
+                if pair in observed_pairs:
+                    coverage_errors.append(f"duplicate pair {color_id}/{helicity_id}")
+                observed_pairs.add(pair)
+        reduction_groups.append(
+            {
+                "id": group_id,
+                "physical_color_ids": list(group_color_ids),
+                "physical_helicity_ids": list(group_helicity_ids),
+                "representative_color_id": representative_color_id,
+                "representative_helicity_id": representative_helicity_id,
+            }
+        )
+    required_pairs = {
+        (color_id, helicity_id)
+        for color_id in computed_color_ids
+        for helicity_id in live_helicity_ids
+    }
+    missing_pairs = required_pairs.difference(observed_pairs)
+    expected_pair_count = len(required_pairs)
+    if not computed_color_ids:
+        coverage_errors.append("physical color axis has no computed representatives")
+    if not live_helicity_ids:
+        coverage_errors.append("physical helicity axis has no live entries")
+    if missing_pairs:
+        coverage_errors.append(
+            f"covered {expected_pair_count - len(missing_pairs)} of "
+            f"{expected_pair_count} required physical pairs"
+        )
+    ordering = {
+        "kind": reduction_kind,
+        "ordered_groups": reduction_groups,
+    }
+    return {
+        "ordering": ordering,
+        "ordering_sha256": _canonical_sha256(ordering),
+        "coverage": {
+            "complete": not coverage_errors,
+            "expected_physical_pair_count": expected_pair_count,
+            "observed_physical_pair_count": len(observed_pairs),
+            "errors": coverage_errors,
+        },
+    }
+
+
+def _logical_reduction_ordering_identity(
+    reduction_kind: object,
+    *,
+    color_axis: Mapping[str, object],
+    helicity_axis: Mapping[str, object],
+    artifact: Path,
+) -> dict[str, object]:
+    """Describe public reduction order without encoding lane materialization."""
+
+    if not isinstance(reduction_kind, str) or not reduction_kind:
+        raise HarnessError(f"artifact logical reduction kind is invalid: {artifact}")
+    raw_color_ids = color_axis.get("ordered_ids")
+    raw_helicity_entries = helicity_axis.get("ordered_entries")
+    if not isinstance(raw_color_ids, list) or not isinstance(
+        raw_helicity_entries, list
+    ):
+        raise HarnessError(
+            f"artifact logical reduction has incomplete physical axes: {artifact}"
+        )
+    color_ids = [
+        str(identifier)
+        for identifier in raw_color_ids
+        if isinstance(identifier, str) and identifier
+    ]
+    live_helicity_ids = [
+        str(entry["id"])
+        for entry in raw_helicity_entries
+        if isinstance(entry, Mapping) and entry.get("structural_zero") is False
+    ]
+    coverage_errors: list[str] = []
+    if len(color_ids) != len(raw_color_ids) or len(set(color_ids)) != len(color_ids):
+        coverage_errors.append("physical color IDs are invalid")
+    if not live_helicity_ids or len(set(live_helicity_ids)) != len(live_helicity_ids):
+        coverage_errors.append("live physical helicity IDs are invalid")
+    pair_count = len(color_ids) * len(live_helicity_ids)
+    ordering = {
+        "kind": reduction_kind,
+        "pair_order_abi": LOGICAL_REDUCTION_ORDER_ABI,
+        "physical_color_count": len(color_ids),
+        "physical_color_ids_sha256": _canonical_sha256(color_ids),
+        "live_physical_helicity_count": len(live_helicity_ids),
+        "live_physical_helicity_ids_sha256": _canonical_sha256(live_helicity_ids),
+        "physical_pair_count": pair_count,
+    }
+    return {
+        "ordering": ordering,
+        "ordering_sha256": _canonical_sha256(ordering),
+        "coverage": {
+            "complete": not coverage_errors and pair_count > 0,
+            "expected_physical_pair_count": pair_count,
+            "observed_physical_pair_count": (pair_count if not coverage_errors else 0),
+            "errors": coverage_errors,
+        },
+    }
+
+
+def _load_compact_eager_reduction_groups(
+    artifact: Path,
+    process_id: str,
+) -> list[dict[str, object]]:
+    try:
+        from pyamplicol.runtime.eager_exact._plan_v3 import (
+            _load_eager_reduction_groups_v1,
+        )
+
+        groups = _load_eager_reduction_groups_v1(artifact, process_id)
+    except Exception as error:
+        raise HarnessError(
+            f"could not authenticate compact eager reduction: {artifact}"
+        ) from error
+    return [dict(group) for group in groups]
+
+
+def _load_compact_recurrence_reduction(
+    artifact: Path,
+    process_id: str,
+) -> Any:
+    try:
+        from pyamplicol.runtime.recurrence_exact._plan_v2 import (
+            _load_recurrence_exact_sections_v1,
+        )
+
+        return _load_recurrence_exact_sections_v1(artifact, process_id)
+    except Exception as error:
+        raise HarnessError(
+            f"could not authenticate compact recurrence reduction: {artifact}"
+        ) from error
+
+
+def _execution_reduction_identity(
+    reduction: Mapping[str, object],
+    *,
+    extensions: Mapping[str, object],
+    color_axis: Mapping[str, object],
+    helicity_axis: Mapping[str, object],
+    logical_color_axis: Mapping[str, object],
+    logical_helicity_axis: Mapping[str, object],
+    artifact: Path,
+    process_id: str,
+) -> dict[str, object]:
+    """Authenticate expanded or native lane-local reduction materialization."""
+
+    reduction_kind = reduction.get("kind")
+    raw_groups = reduction.get("groups")
+    if (
+        not isinstance(reduction_kind, str)
+        or not reduction_kind
+        or not isinstance(raw_groups, list)
+    ):
+        raise HarnessError(f"artifact execution reduction is invalid: {artifact}")
+    color_entries = color_axis.get("ordered_entries")
+    helicity_entries = helicity_axis.get("ordered_entries")
+    if not isinstance(color_entries, list) or not isinstance(
+        helicity_entries,
+        list,
+    ):
+        raise HarnessError(f"artifact execution reduction axes are invalid: {artifact}")
+    computed_color_count = sum(
+        isinstance(entry, Mapping) and entry.get("computed") is True
+        for entry in color_entries
+    )
+    live_helicity_count = sum(
+        isinstance(entry, Mapping) and entry.get("structural_zero") is False
+        for entry in helicity_entries
+    )
+    if computed_color_count <= 0 or live_helicity_count <= 0:
+        raise HarnessError(
+            f"artifact execution reduction axes are incomplete: {artifact}"
+        )
+    has_eager_descriptor = "native_reduction_groups" in extensions
+    has_recurrence_descriptor = "recurrence_runtime_reduction" in extensions
+    eager_descriptor = extensions.get("native_reduction_groups")
+    recurrence_descriptor = extensions.get("recurrence_runtime_reduction")
+    if raw_groups:
+        if has_eager_descriptor or has_recurrence_descriptor:
+            raise HarnessError(
+                f"expanded reduction duplicates a native descriptor: {artifact}"
+            )
+        expanded = _reduction_ordering_identity(
+            reduction,
+            color_axis=color_axis,
+            helicity_axis=helicity_axis,
+            artifact=artifact,
+        )
+        return {
+            "identity": {
+                "kind": "expanded-json-reduction-v1",
+                "reduction_kind": reduction_kind,
+                "group_count": len(raw_groups),
+                "computed_physical_color_count": computed_color_count,
+                "live_physical_helicity_count": live_helicity_count,
+                "materialized_ordering_sha256": expanded["ordering_sha256"],
+            },
+            "coverage": expanded["coverage"],
+        }
+
+    if has_eager_descriptor:
+        expected_keys = {
+            "kind",
+            "schema_version",
+            "storage_abi",
+            "runtime_layout_abi",
+            "container_path",
+            "group_member",
+            "entry_member",
+            "group_count",
+        }
+        group_count = (
+            eager_descriptor.get("group_count")
+            if isinstance(eager_descriptor, Mapping)
+            else None
+        )
+        if (
+            has_recurrence_descriptor
+            or not isinstance(eager_descriptor, Mapping)
+            or set(eager_descriptor) != expected_keys
+            or eager_descriptor.get("kind")
+            != "pyamplicol-eager-plan-v3-reduction-groups"
+            or not _is_exact_int(eager_descriptor.get("schema_version"), 1)
+            or eager_descriptor.get("storage_abi") != "pacbin-v1"
+            or eager_descriptor.get("runtime_layout_abi")
+            != "pyamplicol-eager-runtime-layout-v1"
+            or eager_descriptor.get("container_path") != "eager-runtime.pacbin"
+            or eager_descriptor.get("group_member") != "reductions/groups.bin"
+            or eager_descriptor.get("entry_member") != "reductions/entries.bin"
+            or isinstance(group_count, bool)
+            or not isinstance(group_count, int)
+            or group_count <= 0
+        ):
+            raise HarnessError(
+                f"compact eager reduction descriptor is invalid: {artifact}"
+            )
+        groups = _load_compact_eager_reduction_groups(artifact, process_id)
+        if len(groups) != group_count:
+            raise HarnessError(
+                f"compact eager reduction count is inconsistent: {artifact}"
+            )
+        hydrated = _reduction_ordering_identity(
+            {"kind": reduction_kind, "groups": groups},
+            color_axis=color_axis,
+            helicity_axis=helicity_axis,
+            artifact=artifact,
+        )
+        return {
+            "identity": {
+                "kind": "eager-plan-v3-pacbin-reduction-v1",
+                "reduction_kind": reduction_kind,
+                "descriptor": dict(eager_descriptor),
+                "group_count": len(groups),
+                "computed_physical_color_count": computed_color_count,
+                "live_physical_helicity_count": live_helicity_count,
+                "materialized_ordering_sha256": hydrated["ordering_sha256"],
+            },
+            "coverage": hydrated["coverage"],
+        }
+
+    if has_recurrence_descriptor:
+        expected_keys = {
+            "kind",
+            "runtime_layout_abi",
+            "container_path",
+            "plan_member_path",
+        }
+        if (
+            has_eager_descriptor
+            or not isinstance(recurrence_descriptor, Mapping)
+            or set(recurrence_descriptor) != expected_keys
+            or recurrence_descriptor.get("kind")
+            != "pyamplicol-recurrence-native-reduction-v2"
+            or recurrence_descriptor.get("runtime_layout_abi")
+            != "pyamplicol-recurrence-runtime-layout-v2"
+            or recurrence_descriptor.get("container_path")
+            != "recurrence-runtime.pacbin"
+            or recurrence_descriptor.get("plan_member_path")
+            != "schedule/recurrence-direct-schedule-v2.bin"
+        ):
+            raise HarnessError(
+                f"compact recurrence reduction descriptor is invalid: {artifact}"
+            )
+        sections = _load_compact_recurrence_reduction(artifact, process_id)
+        color_ids = cast(list[str], logical_color_axis["ordered_ids"])
+        live_entries = [
+            entry
+            for entry in cast(
+                list[Mapping[str, object]],
+                logical_helicity_axis["ordered_entries"],
+            )
+            if entry.get("structural_zero") is False
+        ]
+        live_values = [
+            tuple(cast(list[int], entry["values"])) for entry in live_entries
+        ]
+        resolved_helicities = tuple(sections.resolved_helicities)
+        public_helicities = tuple(sections.public_helicities)
+        section_values = [
+            tuple(
+                public_helicities[
+                    row.public_helicity_start : row.public_helicity_start
+                    + row.public_helicity_count
+                ]
+            )
+            for row in resolved_helicities
+        ]
+        public_flow_ids = tuple(sections.public_flow_ids)
+        strategy = sections.strategy
+        pair_count = len(color_ids) * len(live_values)
+        complete = (
+            len(public_flow_ids) == len(color_ids) and section_values == live_values
+        )
+        if strategy == "topology-replay":
+            replay_targets = tuple(sections.replay_targets)
+            complete = (
+                complete
+                and public_flow_ids == tuple(range(len(color_ids)))
+                and tuple(row.public_flow_id for row in replay_targets)
+                == public_flow_ids
+                and sections.amplitude_destination_count == len(live_values)
+                and len(sections.replay_helicity_map) == pair_count
+            )
+        elif strategy == "all-flow-union":
+            destination_sectors = {
+                row.target_sector_id for row in sections.amplitude_destinations
+            }
+            complete = (
+                complete
+                and destination_sectors == set(public_flow_ids)
+                and len(sections.amplitude_destinations) == len(destination_sectors)
+                and sections.amplitude_destination_count
+                == len(sections.amplitude_destinations)
+            )
+        else:
+            complete = False
+        if not complete or pair_count <= 0:
+            raise HarnessError(
+                f"compact recurrence reduction coverage is incomplete: {artifact}"
+            )
+        destination_rows = [
+            [row.target_sector_id, row.target_helicity_id]
+            for row in sections.amplitude_destinations
+        ]
+        replay_map = list(sections.replay_helicity_map)
+        return {
+            "identity": {
+                "kind": "recurrence-plan-v2-pacbin-reduction-v1",
+                "reduction_kind": reduction_kind,
+                "descriptor": dict(recurrence_descriptor),
+                "strategy": strategy,
+                "semantic_digest": sections.semantic_digest,
+                "runtime_layout_digest": sections.runtime_layout_digest,
+                "physical_color_count": len(color_ids),
+                "live_physical_helicity_count": len(live_values),
+                "public_flow_binding_count": len(public_flow_ids),
+                "public_flow_bindings": list(public_flow_ids),
+                "public_flow_bindings_sha256": _canonical_sha256(list(public_flow_ids)),
+                "construction_sector_count": len(set(public_flow_ids)),
+                "amplitude_destination_count": (sections.amplitude_destination_count),
+                "destination_row_count": len(destination_rows),
+                "destination_rows": destination_rows,
+                "destination_rows_sha256": _canonical_sha256(destination_rows),
+                "replay_helicity_map_count": len(replay_map),
+                "replay_helicity_map_sha256": _canonical_sha256(replay_map),
+            },
+            "coverage": {
+                "complete": True,
+                "expected_physical_pair_count": pair_count,
+                "observed_physical_pair_count": pair_count,
+                "errors": [],
+            },
+        }
+
+    raise HarnessError(
+        f"empty reduction groups have no authenticated native descriptor: {artifact}"
+    )
+
+
+def _validate_execution_reduction_summary(
+    identity: Mapping[str, object],
+    coverage: Mapping[str, object],
+    *,
+    logical_reduction: Mapping[str, object],
+    artifact: Path,
+) -> None:
+    """Revalidate the stored lane-local summary without reopening its artifact."""
+
+    logical_kind = logical_reduction.get("kind")
+    logical_pair_count = logical_reduction.get("physical_pair_count")
+    physical_color_count = logical_reduction.get("physical_color_count")
+    live_helicity_count = logical_reduction.get("live_physical_helicity_count")
+    expected_pair_count = coverage.get("expected_physical_pair_count")
+    observed_pair_count = coverage.get("observed_physical_pair_count")
+    if (
+        not isinstance(logical_kind, str)
+        or not logical_kind
+        or isinstance(logical_pair_count, bool)
+        or not isinstance(logical_pair_count, int)
+        or logical_pair_count <= 0
+        or isinstance(physical_color_count, bool)
+        or not isinstance(physical_color_count, int)
+        or physical_color_count <= 0
+        or isinstance(live_helicity_count, bool)
+        or not isinstance(live_helicity_count, int)
+        or live_helicity_count <= 0
+        or set(coverage)
+        != {
+            "complete",
+            "expected_physical_pair_count",
+            "observed_physical_pair_count",
+            "errors",
+        }
+        or coverage.get("complete") is not True
+        or isinstance(expected_pair_count, bool)
+        or not isinstance(expected_pair_count, int)
+        or expected_pair_count <= 0
+        or expected_pair_count > logical_pair_count
+        or not _is_exact_int(observed_pair_count, expected_pair_count)
+        or coverage.get("errors") != []
+    ):
+        raise HarnessError(
+            f"artifact execution reduction coverage is invalid: {artifact}"
+        )
+
+    kind = identity.get("kind")
+    if kind == "expanded-json-reduction-v1":
+        group_count = identity.get("group_count")
+        computed_color_count = identity.get("computed_physical_color_count")
+        materialized_sha256 = identity.get("materialized_ordering_sha256")
+        if (
+            set(identity)
+            != {
+                "kind",
+                "reduction_kind",
+                "group_count",
+                "computed_physical_color_count",
+                "live_physical_helicity_count",
+                "materialized_ordering_sha256",
+            }
+            or identity.get("reduction_kind") != logical_kind
+            or isinstance(group_count, bool)
+            or not isinstance(group_count, int)
+            or group_count <= 0
+            or group_count > observed_pair_count
+            or isinstance(computed_color_count, bool)
+            or not isinstance(computed_color_count, int)
+            or computed_color_count <= 0
+            or computed_color_count > physical_color_count
+            or not _is_exact_int(
+                identity.get("live_physical_helicity_count"),
+                live_helicity_count,
+            )
+            or expected_pair_count != computed_color_count * live_helicity_count
+            or not isinstance(materialized_sha256, str)
+            or _SHA256_PATTERN.fullmatch(materialized_sha256) is None
+        ):
+            raise HarnessError(
+                f"expanded execution reduction summary is invalid: {artifact}"
+            )
+        return
+
+    if kind == "eager-plan-v3-pacbin-reduction-v1":
+        descriptor = identity.get("descriptor")
+        group_count = identity.get("group_count")
+        computed_color_count = identity.get("computed_physical_color_count")
+        materialized_sha256 = identity.get("materialized_ordering_sha256")
+        if (
+            set(identity)
+            != {
+                "kind",
+                "reduction_kind",
+                "descriptor",
+                "group_count",
+                "computed_physical_color_count",
+                "live_physical_helicity_count",
+                "materialized_ordering_sha256",
+            }
+            or identity.get("reduction_kind") != logical_kind
+            or not isinstance(descriptor, Mapping)
+            or set(descriptor)
+            != {
+                "kind",
+                "schema_version",
+                "storage_abi",
+                "runtime_layout_abi",
+                "container_path",
+                "group_member",
+                "entry_member",
+                "group_count",
+            }
+            or descriptor.get("kind") != "pyamplicol-eager-plan-v3-reduction-groups"
+            or not _is_exact_int(descriptor.get("schema_version"), 1)
+            or descriptor.get("storage_abi") != "pacbin-v1"
+            or descriptor.get("runtime_layout_abi")
+            != "pyamplicol-eager-runtime-layout-v1"
+            or descriptor.get("container_path") != "eager-runtime.pacbin"
+            or descriptor.get("group_member") != "reductions/groups.bin"
+            or descriptor.get("entry_member") != "reductions/entries.bin"
+            or isinstance(group_count, bool)
+            or not isinstance(group_count, int)
+            or group_count <= 0
+            or group_count > observed_pair_count
+            or not _is_exact_int(descriptor.get("group_count"), group_count)
+            or isinstance(computed_color_count, bool)
+            or not isinstance(computed_color_count, int)
+            or computed_color_count <= 0
+            or computed_color_count > physical_color_count
+            or not _is_exact_int(
+                identity.get("live_physical_helicity_count"),
+                live_helicity_count,
+            )
+            or expected_pair_count != computed_color_count * live_helicity_count
+            or not isinstance(materialized_sha256, str)
+            or _SHA256_PATTERN.fullmatch(materialized_sha256) is None
+        ):
+            raise HarnessError(
+                f"compact eager execution reduction summary is invalid: {artifact}"
+            )
+        return
+
+    if kind == "recurrence-plan-v2-pacbin-reduction-v1":
+        descriptor = identity.get("descriptor")
+        strategy = identity.get("strategy")
+        semantic_digest = identity.get("semantic_digest")
+        runtime_layout_digest = identity.get("runtime_layout_digest")
+        public_flow_binding_count = identity.get("public_flow_binding_count")
+        public_flow_bindings = identity.get("public_flow_bindings")
+        public_flow_bindings_sha256 = identity.get("public_flow_bindings_sha256")
+        construction_sector_count = identity.get("construction_sector_count")
+        amplitude_destination_count = identity.get("amplitude_destination_count")
+        destination_row_count = identity.get("destination_row_count")
+        destination_rows = identity.get("destination_rows")
+        destination_rows_sha256 = identity.get("destination_rows_sha256")
+        replay_map_count = identity.get("replay_helicity_map_count")
+        replay_map_sha256 = identity.get("replay_helicity_map_sha256")
+        public_flow_bindings_are_valid = isinstance(
+            public_flow_bindings,
+            list,
+        ) and all(
+            not isinstance(value, bool) and isinstance(value, int) and value >= 0
+            for value in public_flow_bindings
+        )
+        destination_rows_are_valid = isinstance(destination_rows, list) and all(
+            isinstance(row, list)
+            and len(row) == 2
+            and all(
+                not isinstance(value, bool)
+                and isinstance(value, int)
+                and 0 <= value < 2**32
+                for value in row
+            )
+            for row in destination_rows
+        )
+        construction_sector_ids = (
+            set(public_flow_bindings) if public_flow_bindings_are_valid else set()
+        )
+        destination_sector_ids = (
+            [row[0] for row in destination_rows] if destination_rows_are_valid else []
+        )
+        destination_helicity_ids = (
+            [row[1] for row in destination_rows] if destination_rows_are_valid else []
+        )
+        if (
+            set(identity)
+            != {
+                "kind",
+                "reduction_kind",
+                "descriptor",
+                "strategy",
+                "semantic_digest",
+                "runtime_layout_digest",
+                "physical_color_count",
+                "live_physical_helicity_count",
+                "public_flow_binding_count",
+                "public_flow_bindings",
+                "public_flow_bindings_sha256",
+                "construction_sector_count",
+                "amplitude_destination_count",
+                "destination_row_count",
+                "destination_rows",
+                "destination_rows_sha256",
+                "replay_helicity_map_count",
+                "replay_helicity_map_sha256",
+            }
+            or identity.get("reduction_kind") != logical_kind
+            or not isinstance(descriptor, Mapping)
+            or set(descriptor)
+            != {
+                "kind",
+                "runtime_layout_abi",
+                "container_path",
+                "plan_member_path",
+            }
+            or descriptor.get("kind") != "pyamplicol-recurrence-native-reduction-v2"
+            or descriptor.get("runtime_layout_abi")
+            != "pyamplicol-recurrence-runtime-layout-v2"
+            or descriptor.get("container_path") != "recurrence-runtime.pacbin"
+            or descriptor.get("plan_member_path")
+            != "schedule/recurrence-direct-schedule-v2.bin"
+            or strategy not in {"topology-replay", "all-flow-union"}
+            or not isinstance(semantic_digest, str)
+            or _SHA256_PATTERN.fullmatch(semantic_digest) is None
+            or not isinstance(runtime_layout_digest, str)
+            or _SHA256_PATTERN.fullmatch(runtime_layout_digest) is None
+            or not _is_exact_int(
+                identity.get("physical_color_count"),
+                physical_color_count,
+            )
+            or not _is_exact_int(
+                identity.get("live_physical_helicity_count"),
+                live_helicity_count,
+            )
+            or not _is_exact_int(public_flow_binding_count, physical_color_count)
+            or not public_flow_bindings_are_valid
+            or len(public_flow_bindings) != physical_color_count
+            or not isinstance(public_flow_bindings_sha256, str)
+            or _SHA256_PATTERN.fullmatch(public_flow_bindings_sha256) is None
+            or public_flow_bindings_sha256 != _canonical_sha256(public_flow_bindings)
+            or isinstance(construction_sector_count, bool)
+            or not isinstance(construction_sector_count, int)
+            or construction_sector_count <= 0
+            or construction_sector_count > physical_color_count
+            or len(construction_sector_ids) != construction_sector_count
+            or construction_sector_ids != set(range(construction_sector_count))
+            or isinstance(amplitude_destination_count, bool)
+            or not isinstance(amplitude_destination_count, int)
+            or amplitude_destination_count <= 0
+            or not _is_exact_int(destination_row_count, amplitude_destination_count)
+            or not destination_rows_are_valid
+            or len(destination_rows) != amplitude_destination_count
+            or len({tuple(row) for row in destination_rows})
+            != amplitude_destination_count
+            or not isinstance(destination_rows_sha256, str)
+            or _SHA256_PATTERN.fullmatch(destination_rows_sha256) is None
+            or destination_rows_sha256 != _canonical_sha256(destination_rows)
+            or isinstance(replay_map_count, bool)
+            or not isinstance(replay_map_count, int)
+            or replay_map_count < 0
+            or not isinstance(replay_map_sha256, str)
+            or _SHA256_PATTERN.fullmatch(replay_map_sha256) is None
+            or expected_pair_count != logical_pair_count
+            or (
+                strategy == "topology-replay"
+                and (
+                    construction_sector_count != physical_color_count
+                    or public_flow_bindings != list(range(physical_color_count))
+                    or amplitude_destination_count != live_helicity_count
+                    or destination_helicity_ids != list(range(live_helicity_count))
+                    or not set(destination_sector_ids) <= construction_sector_ids
+                    or replay_map_count != logical_pair_count
+                )
+            )
+            or (
+                strategy == "all-flow-union"
+                and (
+                    amplitude_destination_count != construction_sector_count
+                    or set(destination_sector_ids) != construction_sector_ids
+                    or any(value != 2**32 - 1 for value in destination_helicity_ids)
+                    or replay_map_count != 0
+                    or replay_map_sha256 != _canonical_sha256([])
+                )
+            )
+        ):
+            raise HarnessError(
+                f"compact recurrence execution reduction summary is invalid: {artifact}"
+            )
+        return
+
+    raise HarnessError(f"artifact execution reduction summary is invalid: {artifact}")
+
+
+def _artifact_semantic_identity(
+    artifact: Path,
+    manifest: Mapping[str, object],
+    process: Mapping[str, object],
+) -> dict[str, object]:
+    """Bind physical axes, normalization, and ordered execution reductions."""
+
+    physics_path = _artifact_member(
+        artifact,
+        process.get("physics_path"),
+        label="resolved physics",
+    )
+    physics = _json_object(physics_path, label="artifact resolved physics")
+    coverage = physics.get("coverage")
+    extensions = physics.get("extensions")
+    reduction = physics.get("reduction")
+    if (
+        not isinstance(coverage, Mapping)
+        or not isinstance(extensions, Mapping)
+        or not isinstance(reduction, Mapping)
+    ):
+        raise HarnessError(
+            f"artifact semantic physics contract is incomplete: {artifact}"
+        )
+    color_coverage = coverage.get("color")
+    helicity_coverage = coverage.get("helicities")
+    if not isinstance(color_coverage, str) or not isinstance(
+        helicity_coverage,
+        str,
+    ):
+        raise HarnessError(f"artifact physical-axis coverage is invalid: {artifact}")
+    execution_color_axis = _ordered_physical_axis(
+        physics.get("color_components"),
+        label="color-flow",
+        require_structural_zero=False,
+    )
+    execution_helicity_axis = _ordered_physical_axis(
+        physics.get("helicities"),
+        label="helicity",
+        require_structural_zero=True,
+    )
+    color_axis = _logical_physical_axis(
+        execution_color_axis,
+        require_structural_zero=False,
+    )
+    helicity_axis = _logical_physical_axis(
+        execution_helicity_axis,
+        require_structural_zero=True,
+    )
+    normalization = extensions.get("normalization")
+    runtime_selectors = extensions.get("runtime_selectors")
+    if not isinstance(normalization, Mapping) or not normalization:
+        raise HarnessError(f"artifact normalization contract is missing: {artifact}")
+    if not isinstance(runtime_selectors, Mapping):
+        raise HarnessError(f"artifact runtime-selector contract is missing: {artifact}")
+    runtime_selector_semantics = _runtime_selector_semantic_identity(
+        runtime_selectors,
+        color_coverage=color_coverage,
+        helicity_coverage=helicity_coverage,
+        artifact=artifact,
+    )
+    specialized_axes = runtime_selector_semantics["generation_specialized_axes"]
+    assert isinstance(specialized_axes, list)
+    process_id = process.get("id")
+    if not isinstance(process_id, str) or not process_id:
+        raise HarnessError(f"artifact process ID is invalid: {artifact}")
+    reduction_identity = _logical_reduction_ordering_identity(
+        reduction.get("kind"),
+        color_axis=color_axis,
+        helicity_axis=helicity_axis,
+        artifact=artifact,
+    )
+    execution_reduction = _execution_reduction_identity(
+        reduction,
+        extensions=extensions,
+        color_axis=execution_color_axis,
+        helicity_axis=execution_helicity_axis,
+        logical_color_axis=color_axis,
+        logical_helicity_axis=helicity_axis,
+        artifact=artifact,
+        process_id=process_id,
+    )
+    model_identity = _manifest_model_identity(manifest)
+    manifest_extensions = manifest.get("extensions")
+    generation = (
+        manifest_extensions.get("generation")
+        if isinstance(manifest_extensions, Mapping)
+        else None
+    )
+    concrete_processes = (
+        generation.get("concrete_processes")
+        if isinstance(generation, Mapping)
+        else None
+    )
+    matching_processes = (
+        [
+            dict(entry)
+            for entry in concrete_processes
+            if isinstance(entry, Mapping) and entry.get("id") == process_id
+        ]
+        if isinstance(concrete_processes, list)
+        else []
+    )
+    if len(matching_processes) != 1:
+        raise HarnessError(
+            f"artifact runtime schedule identity is missing or ambiguous: {artifact}"
+        )
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise HarnessError(f"artifact payload ordering is missing: {artifact}")
+    payload_order: list[dict[str, object]] = []
+    for entry in payloads:
+        if not isinstance(entry, Mapping) or not isinstance(entry.get("path"), str):
+            raise HarnessError(f"artifact payload ordering is invalid: {artifact}")
+        payload_order.append(
+            {
+                "path": entry["path"],
+                "role": entry.get("role"),
+                "process_id": entry.get("process_id"),
+            }
+        )
+    normalization_record = dict(normalization)
+    execution_schedule_ordering = {
+        "runtime_process_contract": matching_processes[0],
+        "manifest_payload_order": payload_order,
+    }
+    complete_physical_axes = (
+        color_coverage == "complete" and helicity_coverage == "complete"
+    )
+    physics_file_identity = _path_identity(physics_path)
+    return {
+        "kind": "pyamplicol-benchmark-artifact-semantic-identity",
+        "schema_version": ARTIFACT_SEMANTIC_IDENTITY_SCHEMA,
+        "physics_file": {
+            "relative_path": process["physics_path"],
+            "size_bytes": physics_file_identity["size_bytes"],
+            "sha256": physics_file_identity["sha256"],
+        },
+        "coverage": {
+            "color": color_coverage,
+            "helicities": helicity_coverage,
+            "complete_physical_axes": complete_physical_axes,
+        },
+        "physical_color_flows": color_axis,
+        "physical_helicities": helicity_axis,
+        "normalization": normalization_record,
+        "normalization_sha256": _canonical_sha256(normalization_record),
+        "manifest_model_identity": model_identity,
+        "reduction_ordering": reduction_identity["ordering"],
+        "reduction_ordering_sha256": reduction_identity["ordering_sha256"],
+        "reduction_coverage": reduction_identity["coverage"],
+        "execution_reduction_identity": execution_reduction["identity"],
+        "execution_reduction_identity_sha256": _canonical_sha256(
+            execution_reduction["identity"]
+        ),
+        "execution_reduction_coverage": execution_reduction["coverage"],
+        "execution_schedule_ordering": execution_schedule_ordering,
+        "execution_schedule_ordering_sha256": _canonical_sha256(
+            execution_schedule_ordering
+        ),
+        "generation_specialized_axes": list(specialized_axes),
+        "runtime_selector_semantics": runtime_selector_semantics,
+        "runtime_selector_semantics_sha256": _canonical_sha256(
+            runtime_selector_semantics
+        ),
+        "runtime_selectors": dict(runtime_selectors),
+        "runtime_selectors_sha256": _canonical_sha256(runtime_selectors),
+    }
+
+
+def _artifact_identity(path: Path) -> dict[str, object]:
+    manifest_path = path / "artifact.json"
+    manifest = _json_object(manifest_path, label="artifact manifest")
+    processes = manifest.get("processes")
+    if not isinstance(processes, list) or len(processes) != 1:
+        raise HarnessError(f"benchmark artifact must contain one process: {path}")
+    process = processes[0]
+    if not isinstance(process, Mapping):
+        raise HarnessError(f"artifact process record is invalid: {path}")
+    expression = process.get("expression")
+    process_id = process.get("id")
+    color_accuracy = process.get("color_accuracy")
+    if not isinstance(expression, str) or not expression:
+        raise HarnessError(f"artifact process expression is invalid: {path}")
+    if not isinstance(process_id, str) or not process_id:
+        raise HarnessError(f"artifact process ID is invalid: {path}")
+    semantic_identity = _artifact_semantic_identity(path, manifest, process)
+    model_identity = _manifest_model_identity(manifest)
+    return {
+        "path": str(path.resolve()),
+        "artifact_id": manifest.get("artifact_id"),
+        "manifest": _path_identity(manifest_path),
+        "tree": _tree_identity(path),
+        "payloads": _artifact_payload_digests(manifest, artifact=path),
+        "process_id": process_id,
+        "process_expression": expression,
+        "color_accuracy": color_accuracy,
+        "producer": manifest.get("producer"),
+        "model_identity": model_identity,
+        "semantic_identity": semantic_identity,
+        "semantic_identity_sha256": _canonical_sha256(semantic_identity),
+    }
+
+
+def _validate_artifact_contract(
+    artifact: Path,
+    identity: Mapping[str, object],
+    *,
+    arguments: argparse.Namespace,
+    mode: str,
+) -> dict[str, object]:
+    expected_process = " ".join(_selected_process(arguments).split()).casefold()
+    observed_process = identity.get("process_expression")
+    if (
+        not isinstance(observed_process, str)
+        or " ".join(observed_process.split()).casefold() != expected_process
+    ):
+        raise HarnessError(f"reused artifact process does not match: {artifact}")
+    if identity.get("color_accuracy") != "lc":
+        raise HarnessError(f"benchmark artifact is not LC: {artifact}")
+    effective = _effective_contract(artifact)
+    expected = {
+        "execution_mode": mode,
+        "backend": "jit",
+        "jit_optimization_level": _expected_effective_jit_optimization_level(
+            arguments,
+            mode=mode,
+        ),
+        "color_accuracy": "lc",
+        "lc_flow_layout": arguments.lc_flow_layout,
+    }
+    for key, value in expected.items():
+        if effective.get(key) != value:
+            raise HarnessError(
+                f"artifact effective {key} does not match {value!r}: {artifact}"
+            )
+    return effective
+
+
+def _expected_effective_jit_optimization_level(
+    arguments: argparse.Namespace,
+    *,
+    mode: str,
+) -> int:
+    """Return the executable optimization level, not merely the request.
+
+    Process-local compiled DAGs honor the requested JIT level, including when
+    their model source is an explicit prepared-model bundle.  Eager and
+    recurrence lanes execute that bundle's immutable portable applications,
+    which are deliberately stored at O2 even when process generation requests
+    O3.
+    """
+
+    if mode != "compiled":
+        return PREPARED_JIT_PORTABLE_OPTIMIZATION_LEVEL
+    return int(arguments.jit_optimization_level)
+
+
+def _reuse_signature_path(artifact: Path) -> Path:
+    return artifact.with_name(f"{artifact.name}.benchmark-reuse.json")
+
+
+def _validated_command_identity(value: object) -> dict[str, object]:
+    if not isinstance(value, Mapping):
+        raise HarnessError("command identity is missing")
+    argv = value.get("argv")
+    digest = value.get("argv_sha256")
+    if (
+        not isinstance(argv, list)
+        or not argv
+        or any(not isinstance(entry, str) for entry in argv)
+        or not isinstance(digest, str)
+        or digest != _canonical_sha256(argv)
+    ):
+        raise HarnessError("command identity is invalid")
+    return {
+        "argv": list(argv),
+        "argv_sha256": digest,
+    }
+
+
+def _write_reuse_signature(
+    artifact: Path,
+    *,
+    signature: Mapping[str, object],
+    artifact_identity: Mapping[str, object],
+    generation_command: object,
+) -> None:
+    artifact_semantic_identity = artifact_identity.get("semantic_identity")
+    if not isinstance(artifact_semantic_identity, Mapping):
+        raise HarnessError("artifact has no semantic identity for its reuse signature")
+    combined_signature = {
+        "generation_request": dict(signature),
+        "artifact_semantic_identity": dict(artifact_semantic_identity),
+    }
+    payload = {
+        "kind": REUSE_SIGNATURE_KIND,
+        "schema_version": REUSE_SIGNATURE_SCHEMA,
+        "created_at_utc": _utc_now(),
+        "generation_command": _validated_command_identity(generation_command),
+        "semantic_signature": combined_signature,
+        "semantic_signature_sha256": _canonical_sha256(combined_signature),
+        "generation_request_sha256": _canonical_sha256(signature),
+        "artifact_semantic_identity_sha256": _canonical_sha256(
+            artifact_semantic_identity
+        ),
+        "artifact_tree": artifact_identity["tree"],
+    }
+    _write_json_atomic(_reuse_signature_path(artifact), payload)
+
+
+def _validated_reuse_signature(
+    artifact: Path,
+    *,
+    artifact_identity: Mapping[str, object],
+    expected_signature: Mapping[str, object] | None,
+) -> dict[str, object]:
+    sidecar_path = _reuse_signature_path(artifact)
+    if not sidecar_path.is_file():
+        raise HarnessError(
+            f"artifact reuse signature is missing; rerun with --force: {artifact}"
+        )
+    sidecar = _json_object(sidecar_path, label="artifact reuse signature")
+    if sidecar.get("kind") != REUSE_SIGNATURE_KIND or not _is_exact_int(
+        sidecar.get("schema_version"),
+        REUSE_SIGNATURE_SCHEMA,
+    ):
+        raise HarnessError(
+            f"artifact reuse signature has an unsupported schema: {sidecar_path}"
+        )
+    _validated_command_identity(sidecar.get("generation_command"))
+    created_at = sidecar.get("created_at_utc")
+    if not isinstance(created_at, str) or not created_at:
+        raise HarnessError(f"artifact reuse signature has no timestamp: {sidecar_path}")
+    try:
+        parsed_created_at = dt.datetime.fromisoformat(created_at)
+    except ValueError as error:
+        raise HarnessError(
+            f"artifact reuse signature has an invalid timestamp: {sidecar_path}"
+        ) from error
+    if parsed_created_at.tzinfo is None:
+        raise HarnessError(
+            f"artifact reuse signature timestamp is not UTC-bound: {sidecar_path}"
+        )
+    observed_signature = sidecar.get("semantic_signature")
+    if not isinstance(observed_signature, Mapping):
+        raise HarnessError(f"artifact reuse signature is invalid: {sidecar_path}")
+    generation_request = observed_signature.get("generation_request")
+    artifact_semantic_identity = observed_signature.get("artifact_semantic_identity")
+    observed_artifact_semantics = artifact_identity.get("semantic_identity")
+    if not isinstance(generation_request, Mapping) or not isinstance(
+        artifact_semantic_identity,
+        Mapping,
+    ):
+        raise HarnessError(f"artifact reuse signature is incomplete: {sidecar_path}")
+    observed_digest = sidecar.get("semantic_signature_sha256")
+    if (
+        not isinstance(observed_digest, str)
+        or observed_digest != _canonical_sha256(observed_signature)
+        or sidecar.get("generation_request_sha256")
+        != _canonical_sha256(generation_request)
+        or sidecar.get("artifact_semantic_identity_sha256")
+        != _canonical_sha256(artifact_semantic_identity)
+        or not isinstance(observed_artifact_semantics, Mapping)
+        or dict(artifact_semantic_identity) != dict(observed_artifact_semantics)
+        or sidecar.get("artifact_tree") != artifact_identity.get("tree")
+    ):
+        raise HarnessError(
+            "artifact semantic identity or tree changed after generation; rerun "
+            f"with --force: {artifact}"
+        )
+    if expected_signature is not None and (
+        dict(generation_request) != dict(expected_signature)
+        or sidecar.get("generation_request_sha256")
+        != _canonical_sha256(expected_signature)
+    ):
+        raise HarnessError(
+            "artifact semantic generation request changed; rerun with --force: "
+            f"{artifact}"
+        )
+    return sidecar
+
+
+def _require_reusable_artifact(
+    artifact: Path,
+    *,
+    expected_signature: Mapping[str, object],
+) -> tuple[dict[str, object], dict[str, object]]:
+    identity = _artifact_identity(artifact)
+    sidecar = _validated_reuse_signature(
+        artifact,
+        artifact_identity=identity,
+        expected_signature=expected_signature,
+    )
+    return identity, sidecar
+
+
+def _artifact_identity_from_bound_semantics(
+    artifact: Path,
+    *,
+    tree: Mapping[str, object],
+    semantic_identity: Mapping[str, object],
+) -> dict[str, object]:
+    """Recover cheap identity fields after exact tree/sidecar authentication.
+
+    The initial artifact bind validates every manifest payload and reconstructs
+    the lane-local semantic identity.  Its sibling reuse sidecar content
+    addresses that semantic identity and the complete artifact tree.  Once both
+    byte identities have been pinned, later subprocesses can recover the
+    immutable semantic body without hydrating a multi-gigabyte native plan.
+    """
+
+    manifest_path = artifact / "artifact.json"
+    manifest = _json_object(manifest_path, label="artifact manifest")
+    processes = manifest.get("processes")
+    if not isinstance(processes, list) or len(processes) != 1:
+        raise HarnessError(f"benchmark artifact must contain one process: {artifact}")
+    process = processes[0]
+    if not isinstance(process, Mapping):
+        raise HarnessError(f"artifact process record is invalid: {artifact}")
+    expression = process.get("expression")
+    process_id = process.get("id")
+    color_accuracy = process.get("color_accuracy")
+    if not isinstance(expression, str) or not expression:
+        raise HarnessError(f"artifact process expression is invalid: {artifact}")
+    if not isinstance(process_id, str) or not process_id:
+        raise HarnessError(f"artifact process ID is invalid: {artifact}")
+    model_identity = _manifest_model_identity(manifest)
+    bound_model_identity = semantic_identity.get("manifest_model_identity")
+    if (
+        not isinstance(bound_model_identity, Mapping)
+        or dict(bound_model_identity) != model_identity
+    ):
+        raise HarnessError(
+            f"artifact semantic model identity disagrees with its manifest: {artifact}"
+        )
+    semantic_identity_sha256 = _canonical_sha256(semantic_identity)
+    return {
+        "path": str(artifact.resolve()),
+        "artifact_id": manifest.get("artifact_id"),
+        "manifest": _path_identity(manifest_path),
+        "tree": dict(tree),
+        "process_id": process_id,
+        "process_expression": expression,
+        "color_accuracy": color_accuracy,
+        "producer": manifest.get("producer"),
+        "model_identity": model_identity,
+        "semantic_identity": dict(semantic_identity),
+        "semantic_identity_sha256": semantic_identity_sha256,
+    }
+
+
+def _require_bound_reusable_artifact(
+    artifact: Path,
+    *,
+    expected_tree_sha256: str,
+    expected_semantic_identity_sha256: str,
+    expected_reuse_semantic_signature_sha256: str,
+    expected_sidecar_sha256: str,
+    expected_signature: Mapping[str, object] | None,
+) -> tuple[dict[str, object], dict[str, object], dict[str, object]]:
+    """Rebind an already authenticated artifact through exact byte identities.
+
+    This is deliberately not the initial reuse path.  The caller must supply
+    digests retained from a prior full semantic bind.  We hash the complete
+    artifact tree and the sibling reuse sidecar again, validate the sidecar's
+    self-addressed semantic/generation payload, and only then recover the
+    semantic body stored in that sidecar.
+    """
+
+    expected_tree_sha256 = _required_sha256(
+        expected_tree_sha256,
+        label="expected bound artifact tree",
+    )
+    expected_semantic_identity_sha256 = _required_sha256(
+        expected_semantic_identity_sha256,
+        label="expected bound artifact semantic identity",
+    )
+    expected_reuse_semantic_signature_sha256 = _required_sha256(
+        expected_reuse_semantic_signature_sha256,
+        label="expected bound reuse semantic signature",
+    )
+    expected_sidecar_sha256 = _required_sha256(
+        expected_sidecar_sha256,
+        label="expected bound reuse sidecar",
+    )
+    sidecar_path = _reuse_signature_path(artifact)
+    sidecar_identity_before = _path_identity(sidecar_path)
+    if sidecar_identity_before.get("sha256") != expected_sidecar_sha256:
+        raise HarnessError(
+            f"artifact reuse sidecar changed after semantic binding: {artifact}"
+        )
+    sidecar_payload = _json_object(
+        sidecar_path,
+        label="artifact reuse signature",
+    )
+    raw_signature = sidecar_payload.get("semantic_signature")
+    semantic_identity = (
+        raw_signature.get("artifact_semantic_identity")
+        if isinstance(raw_signature, Mapping)
+        else None
+    )
+    if not isinstance(semantic_identity, Mapping):
+        raise HarnessError(
+            f"artifact reuse signature has no bound semantic identity: {sidecar_path}"
+        )
+    tree = _tree_identity(artifact)
+    if tree.get("sha256") != expected_tree_sha256:
+        raise HarnessError(f"artifact tree changed after semantic binding: {artifact}")
+    identity = _artifact_identity_from_bound_semantics(
+        artifact,
+        tree=tree,
+        semantic_identity=semantic_identity,
+    )
+    sidecar = _validated_reuse_signature(
+        artifact,
+        artifact_identity=identity,
+        expected_signature=expected_signature,
+    )
+    if identity.get("semantic_identity_sha256") != expected_semantic_identity_sha256:
+        raise HarnessError(
+            f"artifact semantic identity changed after semantic binding: {artifact}"
+        )
+    if (
+        sidecar.get("semantic_signature_sha256")
+        != expected_reuse_semantic_signature_sha256
+    ):
+        raise HarnessError(
+            f"artifact reuse semantics changed after semantic binding: {artifact}"
+        )
+    sidecar_identity_after = _path_identity(sidecar_path)
+    if (
+        sidecar_identity_after != sidecar_identity_before
+        or sidecar_identity_after.get("sha256") != expected_sidecar_sha256
+    ):
+        raise HarnessError(
+            f"artifact reuse sidecar drifted during semantic binding: {artifact}"
+        )
+    return identity, sidecar, sidecar_identity_after
+
+
+_PROFILE_EXPECTATION_FIELDS = (
+    "source_identity_sha256",
+    "runtime_provenance_sha256",
+    "interpreter_sha256",
+    "native_extension_sha256",
+    "artifact_id",
+    "artifact_tree_sha256",
+    "artifact_semantic_identity_sha256",
+    "reuse_semantic_signature_sha256",
+    "reuse_sidecar_sha256",
+)
+
+
+def _required_sha256(value: object, *, label: str) -> str:
+    if not isinstance(value, str) or _SHA256_PATTERN.fullmatch(value) is None:
+        raise HarnessError(f"{label} is not a SHA-256 identity")
+    return value
+
+
+def _profile_identity_expectations(
+    source_identity: Mapping[str, object],
+    runtime_provenance: Mapping[str, object],
+    artifact_identity: Mapping[str, object],
+    reuse_signature: Mapping[str, object],
+    *,
+    reuse_sidecar: Path,
+) -> dict[str, str]:
+    interpreter = runtime_provenance.get("interpreter")
+    native = runtime_provenance.get("native_extension")
+    tree = artifact_identity.get("tree")
+    if (
+        not isinstance(interpreter, Mapping)
+        or not isinstance(native, Mapping)
+        or not isinstance(tree, Mapping)
+    ):
+        raise HarnessError("driver cannot construct complete worker expectations")
+    return {
+        "source_identity_sha256": _canonical_sha256(source_identity),
+        "runtime_provenance_sha256": _canonical_sha256(runtime_provenance),
+        "interpreter_sha256": _required_sha256(
+            interpreter.get("sha256"),
+            label="interpreter identity",
+        ),
+        "native_extension_sha256": _required_sha256(
+            native.get("sha256"),
+            label="native extension identity",
+        ),
+        "artifact_id": _required_sha256(
+            artifact_identity.get("artifact_id"),
+            label="artifact manifest identity",
+        ),
+        "artifact_tree_sha256": _required_sha256(
+            tree.get("sha256"),
+            label="artifact tree identity",
+        ),
+        "artifact_semantic_identity_sha256": _required_sha256(
+            artifact_identity.get("semantic_identity_sha256"),
+            label="artifact semantic identity",
+        ),
+        "reuse_semantic_signature_sha256": _required_sha256(
+            reuse_signature.get("semantic_signature_sha256"),
+            label="artifact reuse semantic signature",
+        ),
+        "reuse_sidecar_sha256": _required_sha256(
+            _path_identity(reuse_sidecar).get("sha256"),
+            label="artifact reuse sidecar",
+        ),
+    }
+
+
+def _validate_profile_worker_expectations(
+    expected: Mapping[str, object],
+    observed: Mapping[str, object],
+) -> None:
+    for field in _PROFILE_EXPECTATION_FIELDS:
+        expected_value = _required_sha256(
+            expected.get(field),
+            label=f"expected {field}",
+        )
+        observed_value = _required_sha256(
+            observed.get(field),
+            label=f"observed {field}",
+        )
+        if observed_value != expected_value:
+            raise HarnessError(
+                f"profile worker {field.replace('_', ' ')} drifted before timing"
+            )
+
+
+def _profile_expectation_arguments(
+    expectations: Mapping[str, object],
+) -> tuple[str, ...]:
+    result: list[str] = []
+    for field in _PROFILE_EXPECTATION_FIELDS:
+        value = _required_sha256(
+            expectations.get(field),
+            label=f"expected {field}",
+        )
+        result.extend((f"--expected-{field.replace('_', '-')}", value))
+    return tuple(result)
+
+
+def _profile_worker_expectations_from_arguments(
+    arguments: argparse.Namespace,
+) -> dict[str, str]:
+    return {
+        field: _required_sha256(
+            getattr(arguments, f"expected_{field}", None),
+            label=f"profile worker expected {field}",
+        )
+        for field in _PROFILE_EXPECTATION_FIELDS
+    }
+
+
+def _verify_profile_worker_environment(
+    arguments: argparse.Namespace,
+) -> dict[str, object]:
+    """Recompute every byte identity inside the worker before loading.
+
+    Native artifact semantics were fully authenticated by the driver before it
+    scheduled any timing worker.  The worker rebinds that semantic body through
+    the exact artifact-tree and reuse-sidecar digests supplied by the driver,
+    avoiding a redundant native-plan hydration before every timed load.
+    """
+
+    expected = _profile_worker_expectations_from_arguments(arguments)
+    source_identity = _git_source_identity()
+    runtime_provenance = _runtime_provenance(source_identity)
+    artifact = arguments.artifact.resolve(strict=True)
+    artifact_identity, reuse_signature, reuse_sidecar_identity = (
+        _require_bound_reusable_artifact(
+            artifact,
+            expected_tree_sha256=expected["artifact_tree_sha256"],
+            expected_semantic_identity_sha256=expected[
+                "artifact_semantic_identity_sha256"
+            ],
+            expected_reuse_semantic_signature_sha256=expected[
+                "reuse_semantic_signature_sha256"
+            ],
+            expected_sidecar_sha256=expected["reuse_sidecar_sha256"],
+            expected_signature=None,
+        )
+    )
+    interpreter = runtime_provenance.get("interpreter")
+    native = runtime_provenance.get("native_extension")
+    tree = artifact_identity.get("tree")
+    if (
+        not isinstance(interpreter, Mapping)
+        or not isinstance(native, Mapping)
+        or not isinstance(tree, Mapping)
+    ):
+        raise HarnessError("profile worker observed incomplete runtime identities")
+    observed = {
+        "source_identity_sha256": _canonical_sha256(source_identity),
+        "runtime_provenance_sha256": _canonical_sha256(runtime_provenance),
+        "interpreter_sha256": interpreter.get("sha256"),
+        "native_extension_sha256": native.get("sha256"),
+        "artifact_id": artifact_identity.get("artifact_id"),
+        "artifact_tree_sha256": tree.get("sha256"),
+        "artifact_semantic_identity_sha256": artifact_identity.get(
+            "semantic_identity_sha256"
+        ),
+        "reuse_semantic_signature_sha256": reuse_signature.get(
+            "semantic_signature_sha256"
+        ),
+        "reuse_sidecar_sha256": reuse_sidecar_identity.get("sha256"),
+    }
+    _validate_profile_worker_expectations(expected, observed)
+    effective_contract = _validate_artifact_contract(
+        artifact,
+        artifact_identity,
+        arguments=arguments,
+        mode=arguments.mode,
+    )
+    return {
+        "kind": WORKER_VERIFICATION_KIND,
+        "schema_version": WORKER_VERIFICATION_SCHEMA,
+        "verified_at_utc": _utc_now(),
+        "expected": expected,
+        "observed": observed,
+        "artifact_semantic_identity": artifact_identity["semantic_identity"],
+        "artifact_semantic_identity_sha256": artifact_identity[
+            "semantic_identity_sha256"
+        ],
+        "effective_contract": effective_contract,
+    }
+
+
+def _loaded_runtime_artifact_verification(
+    runtime: object,
+    *,
+    expected_artifact_id: object,
+    phase: str,
+) -> dict[str, object]:
+    """Bind an in-memory runtime to the manifest identity it authenticated.
+
+    The native loader validates the manifest identity, the exact declared tree,
+    and every payload before it publishes the runtime.  Comparing that retained
+    identity closes the path replacement window between the worker's fast tree
+    rebind and ``Runtime.load`` without rehydrating the eager semantic plan.
+    """
+
+    expected = _required_sha256(
+        expected_artifact_id,
+        label="expected loaded artifact identity",
+    )
+    observed = _required_sha256(
+        getattr(runtime, "artifact_id", None),
+        label="native loaded artifact identity",
+    )
+    if observed != expected:
+        raise HarnessError(
+            "profile worker loaded a different artifact after its pre-load "
+            "identity check"
+        )
+    return {
+        "kind": "pyamplicol-loaded-runtime-artifact-verification",
+        "schema_version": 1,
+        "phase": phase,
+        "checked_at_utc": _utc_now(),
+        "expected_artifact_id": expected,
+        "loaded_artifact_id": observed,
+        "passes": True,
+    }
+
+
+def _validate_loaded_runtime_artifact_verification(
+    value: object,
+    *,
+    expected_artifact_id: object,
+    phase: str,
+) -> None:
+    expected = _required_sha256(
+        expected_artifact_id,
+        label="expected retained loaded artifact identity",
+    )
+    if not isinstance(value, Mapping):
+        raise HarnessError("loaded runtime artifact verification is missing")
+    if (
+        value.get("kind") != "pyamplicol-loaded-runtime-artifact-verification"
+        or not _is_exact_int(value.get("schema_version"), 1)
+        or value.get("phase") != phase
+        or not _is_utc_timestamp(value.get("checked_at_utc"))
+        or value.get("expected_artifact_id") != expected
+        or value.get("loaded_artifact_id") != expected
+        or value.get("passes") is not True
+    ):
+        raise HarnessError("loaded runtime artifact verification is invalid")
+
+
+def _artifact_phases(path: Path) -> dict[str, float]:
+    try:
+        artifact = json.loads((path / "artifact.json").read_text(encoding="utf-8"))
+        raw = artifact["extensions"]["generation"]["phase_timings_seconds"]
+    except (OSError, KeyError, TypeError, json.JSONDecodeError) as error:
+        raise HarnessError(
+            f"artifact has no valid generation timings: {path}"
+        ) from error
+    if not isinstance(raw, Mapping):
+        raise HarnessError(f"artifact generation timings are not an object: {path}")
+    result: dict[str, float] = {}
+    for name, value in raw.items():
+        if not isinstance(name, str) or isinstance(value, bool):
+            raise HarnessError(f"artifact has an invalid generation phase: {path}")
+        seconds = float(value)
+        if not math.isfinite(seconds) or seconds < 0:
+            raise HarnessError(f"artifact has an invalid phase duration: {path}")
+        result[name] = seconds
+    return result
+
+
+def _effective_contract(path: Path) -> dict[str, object]:
+    try:
+        payload = tomllib.loads(
+            (path / "config" / "effective.toml").read_text(encoding="utf-8")
+        )
+        color = payload["color"]
+        evaluator = payload["evaluator"]
+        jit = evaluator["jit"]
+    except (OSError, KeyError, TypeError, tomllib.TOMLDecodeError) as error:
+        raise HarnessError(
+            f"artifact has no valid effective configuration: {path}"
+        ) from error
+    return {
+        "execution_mode": str(evaluator["execution_mode"]),
+        "backend": str(evaluator["backend"]),
+        "jit_optimization_level": int(jit["optimization_level"]),
+        "color_accuracy": str(color["accuracy"]),
+        "lc_flow_layout": str(color["lc_flow_layout"]),
+    }
+
+
+def _validation_fixture(
+    artifact: Path,
+    process_id: str,
+) -> tuple[
+    tuple[tuple[tuple[float, ...], ...], ...],
+    dict[str, object],
+]:
+    path = artifact / "processes" / process_id / "validation-momenta.json"
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        points = payload["points"]
+        converted = tuple(
+            tuple(
+                tuple(float(component) for component in particle["momentum"])
+                for particle in point
+            )
+            for point in points
+        )
+    except (OSError, KeyError, TypeError, ValueError, json.JSONDecodeError) as error:
+        raise HarnessError(f"invalid validation momenta at {path}") from error
+    return (
+        converted,
+        {
+            "file": _path_identity(path),
+            "point_count": len(converted),
+            "points_sha256": _canonical_sha256(converted),
+        },
+    )
+
+
+def _complex_payload(value: complex) -> list[float]:
+    return [value.real, value.imag]
+
+
+def _plain(value: object) -> object:
+    if isinstance(value, Mapping):
+        return {str(key): _plain(entry) for key, entry in value.items()}
+    if isinstance(value, tuple | list):
+        return [_plain(entry) for entry in value]
+    return value
+
+
+def _statistics_payload(value: Any) -> dict[str, float]:
+    return {
+        "standard_deviation_seconds_per_point": float(value.standard_deviation),
+        "standard_error_seconds_per_point": float(value.standard_error),
+        "relative_standard_error": float(value.relative_standard_error),
+    }
+
+
+def _benchmark_payload(result: Any) -> dict[str, object]:
+    evaluator_uncertainty = result.evaluator_uncertainty
+    timing_breakdown = getattr(result, "timing_breakdown", None)
+    return {
+        "batch_size": int(result.effective_config.batch_size),
+        "sample_count": int(result.sample_count),
+        "repetitions_per_sample": int(result.repetitions_per_sample),
+        "evaluation_count": int(result.evaluation_count),
+        "evaluated_point_count": int(result.evaluated_point_count),
+        "wall_seconds_per_point": float(result.wall_time_per_point),
+        "evaluator_seconds_per_point": (
+            None
+            if result.evaluator_time_per_point is None
+            else float(result.evaluator_time_per_point)
+        ),
+        "wall_uncertainty": _statistics_payload(result.uncertainty),
+        "evaluator_uncertainty": (
+            None
+            if evaluator_uncertainty is None
+            else _statistics_payload(evaluator_uncertainty)
+        ),
+        "timing_breakdown": (
+            None
+            if timing_breakdown is None
+            else _plain(dataclasses.asdict(timing_breakdown))
+        ),
+        "timing_sources": {
+            "wall": result.environment.get("wall_time_source"),
+            "evaluator": result.environment.get("evaluator_time_source"),
+        },
+        "environment": _plain(result.environment),
+        "interrupted": bool(result.interrupted),
+    }
+
+
+def _native_wall_block_payload(
+    runtime: object,
+    validation_points: Sequence[object],
+    *,
+    batch_size: int,
+    repetitions_per_block: int,
+    block_count: int,
+    minimum_native_wall_seconds: float,
+    calibration: Mapping[str, object],
+    selectors: Mapping[str, object],
+    fixture_points_sha256: str,
+) -> dict[str, object]:
+    if (
+        isinstance(repetitions_per_block, bool)
+        or not isinstance(repetitions_per_block, int)
+        or repetitions_per_block <= 0
+        or isinstance(block_count, bool)
+        or not isinstance(block_count, int)
+        or block_count < MIN_AUTHORITATIVE_SAMPLES
+        or isinstance(batch_size, bool)
+        or not isinstance(batch_size, int)
+        or batch_size <= 0
+        or not validation_points
+        or _SHA256_PATTERN.fullmatch(fixture_points_sha256) is None
+        or isinstance(minimum_native_wall_seconds, bool)
+        or not isinstance(minimum_native_wall_seconds, (float, int))
+        or not math.isfinite(float(minimum_native_wall_seconds))
+        or float(minimum_native_wall_seconds) <= 0.0
+    ):
+        raise HarnessError("raw native-wall block configuration is invalid")
+    backend = getattr(runtime, "_backend", None)
+    timer = getattr(backend, "_benchmark_f64_wall_time", None)
+    if not callable(timer):
+        raise HarnessError("runtime exposes no raw native-wall block timer")
+    batch = tuple(
+        validation_points[index % len(validation_points)] for index in range(batch_size)
+    )
+    blocks: list[dict[str, object]] = []
+    seconds_per_point: list[float] = []
+    observed_native_wall_seconds = 0.0
+    observed_caller_elapsed_seconds = 0.0
+    maximum_block_count = max(block_count * 4, block_count + 16)
+    while (
+        len(blocks) < block_count
+        or observed_native_wall_seconds < float(minimum_native_wall_seconds)
+    ):
+        if len(blocks) >= maximum_block_count:
+            raise HarnessError(
+                "raw native-wall calibration could not satisfy the configured "
+                "minimum duration"
+            )
+        block_index = len(blocks)
+        started_at = _utc_now()
+        started = time.perf_counter()
+        duration = timer(
+            batch,
+            repetitions_per_block,
+            precision=16,
+            **dict(selectors),
+        )
+        finished_at = _utc_now()
+        elapsed = time.perf_counter() - started
+        if (
+            isinstance(duration, bool)
+            or not isinstance(duration, (float, int))
+            or not math.isfinite(float(duration))
+            or float(duration) <= 0.0
+        ):
+            raise HarnessError("native-wall timer returned an invalid raw block")
+        per_point = float(duration) / (repetitions_per_block * batch_size)
+        record = {
+            "block_index": block_index,
+            "started_at_utc": started_at,
+            "finished_at_utc": finished_at,
+            "caller_elapsed_seconds": elapsed,
+            "native_wall_seconds": float(duration),
+            "wall_seconds_per_point": per_point,
+            "repetitions": repetitions_per_block,
+            "batch_size": batch_size,
+            "evaluation_count": repetitions_per_block,
+            "evaluated_point_count": repetitions_per_block * batch_size,
+        }
+        record["content_sha256"] = _canonical_sha256(record)
+        blocks.append(record)
+        seconds_per_point.append(per_point)
+        observed_native_wall_seconds += float(duration)
+        observed_caller_elapsed_seconds += elapsed
+    median = statistics.median(seconds_per_point)
+    mad = statistics.median(abs(value - median) for value in seconds_per_point)
+    return {
+        "kind": RAW_NATIVE_WALL_BLOCK_KIND,
+        "schema_version": RAW_NATIVE_WALL_BLOCK_SCHEMA,
+        "measurement_contract": RAW_NATIVE_WALL_MEASUREMENT_CONTRACT,
+        "source": "runtime._benchmark_f64_wall_time",
+        "fixture_points_sha256": fixture_points_sha256,
+        "minimum_native_wall_seconds": float(minimum_native_wall_seconds),
+        "observed_native_wall_seconds": observed_native_wall_seconds,
+        "observed_caller_elapsed_seconds": observed_caller_elapsed_seconds,
+        "minimum_duration_satisfied": (
+            observed_native_wall_seconds >= float(minimum_native_wall_seconds)
+        ),
+        "calibration": dict(calibration),
+        "block_count": len(blocks),
+        "repetitions_per_block": repetitions_per_block,
+        "evaluation_count": len(blocks) * repetitions_per_block,
+        "evaluated_point_count": (len(blocks) * repetitions_per_block * batch_size),
+        "wall_seconds_per_point_median": median,
+        "wall_seconds_per_point_mad": mad,
+        "blocks": blocks,
+        "blocks_sha256": _canonical_sha256(blocks),
+    }
+
+
+def _reference_color_order(gluon_count: int) -> tuple[int, ...]:
+    return (2, *range(4, 4 + gluon_count), 1, 3)
+
+
+def _parse_flow_word(requested: str) -> tuple[int, ...] | None:
+    if not requested.startswith("flow:"):
+        return None
+    raw = requested.removeprefix("flow:")
+    if not raw:
+        raise HarnessError("flow ID must contain at least one label")
+    try:
+        word = tuple(int(label) for label in raw.split(","))
+    except ValueError as error:
+        raise HarnessError(f"invalid flow ID {requested!r}") from error
+    if not word or any(label <= 0 for label in word):
+        raise HarnessError(f"invalid flow ID {requested!r}")
+    return word
+
+
+def _generation_selected_flow_word(
+    arguments: argparse.Namespace,
+) -> tuple[int, ...] | None:
+    if not arguments.specialize_flow_at_generation:
+        return None
+    if arguments.lc_flow_layout != "topology-replay":
+        raise HarnessError(
+            "generation-time flow specialization is available only for topology-replay"
+        )
+    parsed = _parse_flow_word(arguments.color_flow)
+    if parsed is not None:
+        return parsed
+    try:
+        ordinal = int(arguments.color_flow, 10)
+    except ValueError as error:
+        raise HarnessError(
+            "generation-time flow specialization requires a stable flow ID or "
+            "the first flow ordinal"
+        ) from error
+    if ordinal != 1:
+        raise HarnessError(
+            "generation-time flow specialization currently supports ordinal 1 "
+            "or an explicit stable flow ID"
+        )
+    if arguments.process_expression is not None:
+        raise HarnessError(
+            "generation-time flow specialization for custom processes requires "
+            "an explicit stable flow ID"
+        )
+    return _reference_color_order(arguments.gluon_count)
+
+
+def _generation_config(
+    execution_mode: str,
+    *,
+    validation_samples: int,
+    lc_flow_layout: str,
+    point_tile_size: int,
+    jit_optimization_level: int,
+    gluon_count: int | None = None,
+) -> Any:
+    from pyamplicol.config import (
+        Action,
+        ColorAccuracy,
+        ColorConfig,
+        EvaluatorBackend,
+        EvaluatorConfig,
+        EvaluatorExecutionMode,
+        EvaluatorOptimizationConfig,
+        GenerationConfig,
+        GenerationValidationConfig,
+        JITConfig,
+        LCFlowLayout,
+        ProcessConfig,
+        RecurrenceEvaluatorConfig,
+        RunConfig,
+    )
+
+    if execution_mode not in {"compiled", "eager", "recurrence"}:
+        raise HarnessError(f"unsupported generation mode {execution_mode!r}")
+    if lc_flow_layout not in {"topology-replay", "all-flow-union"}:
+        raise HarnessError(f"unsupported LC flow layout {lc_flow_layout!r}")
+    return RunConfig(
+        action=Action.GENERATE,
+        color=ColorConfig(
+            accuracy=ColorAccuracy.LC,
+            lc_flow_layout=LCFlowLayout(lc_flow_layout),
+        ),
+        process=ProcessConfig(
+            reference_color_order=(
+                () if gluon_count is None else _reference_color_order(gluon_count)
+            ),
+        ),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(
+                enabled=True,
+                samples=validation_samples,
+                seed=VALIDATION_SEED,
+                relative_tolerance=RTOL,
+                absolute_tolerance=ATOL,
+                post_build_validation=True,
+            ),
+        ),
+        evaluator=EvaluatorConfig(
+            backend=EvaluatorBackend.JIT,
+            execution_mode=EvaluatorExecutionMode(execution_mode),
+            batch_size=64,
+            output_chunk_size=512,
+            optimization=EvaluatorOptimizationConfig(
+                horner_iterations=10,
+                cores=1,
+                max_horner_variables=1000,
+                max_common_pair_cache_entries=5_000_000,
+                max_common_pair_distance=1000,
+                collect_factors="auto",
+            ),
+            # Recurrence process generation consumes its prepared pack without
+            # compiling. Compiled mode performs process-specific JIT work in
+            # the measured generation interval.
+            jit=JITConfig(
+                optimization_level=cast(
+                    Literal[0, 1, 2, 3],
+                    jit_optimization_level,
+                )
+            ),
+            recurrence=RecurrenceEvaluatorConfig(
+                point_tile_size=point_tile_size,
+            ),
+        ),
+    )
+
+
+def _generate_worker(arguments: argparse.Namespace) -> dict[str, object]:
+    from pyamplicol import Generator, ModelSource
+    from pyamplicol.assets.prepared_models import (
+        BUILTIN_SM_JIT_O2,
+        packaged_prepared_model_path,
+    )
+    from pyamplicol.reporting import StreamProgressSink
+
+    artifact = arguments.artifact.resolve()
+    prepared_access_started = time.perf_counter()
+    prepared_context = (
+        contextlib.nullcontext(arguments.prepared_model.resolve())
+        if arguments.prepared_model is not None
+        else (
+            contextlib.nullcontext(None)
+            if arguments.mode == "compiled"
+            else packaged_prepared_model_path(BUILTIN_SM_JIT_O2)
+        )
+    )
+    try:
+        with prepared_context as prepared_model:
+            if prepared_model is None:
+                model_source = ModelSource.built_in_sm()
+                model_record: dict[str, object] = {
+                    "kind": "built-in-sm-source",
+                    "resource_id": None,
+                    "compile_excluded_from_generation": False,
+                }
+            else:
+                if not prepared_model.is_file():
+                    raise HarnessError(
+                        f"prepared model does not exist: {prepared_model}"
+                    )
+                model_source = ModelSource.from_path(prepared_model)
+                prepared_identity = _path_identity(prepared_model)
+                model_record = {
+                    "kind": (
+                        "packaged-prepared-model"
+                        if arguments.prepared_model is None
+                        else "explicit-prepared-model"
+                    ),
+                    "resource_id": (
+                        PREPARED_MODEL_ID if arguments.prepared_model is None else None
+                    ),
+                    "file": (
+                        None if arguments.prepared_model is None else prepared_identity
+                    ),
+                    "size_bytes": prepared_identity["size_bytes"],
+                    "sha256": prepared_identity["sha256"],
+                    "compile_excluded_from_generation": True,
+                }
+            prepared_access_seconds = time.perf_counter() - prepared_access_started
+            generation_started = time.perf_counter()
+            config = _generation_config(
+                arguments.mode,
+                validation_samples=arguments.validation_samples,
+                lc_flow_layout=arguments.lc_flow_layout,
+                point_tile_size=arguments.point_tile_size,
+                jit_optimization_level=arguments.jit_optimization_level,
+                gluon_count=(
+                    arguments.gluon_count
+                    if arguments.process_expression is None
+                    else None
+                ),
+            )
+            selected_flow_word = _generation_selected_flow_word(arguments)
+            if selected_flow_word is not None:
+                config = dataclasses.replace(
+                    config,
+                    process=dataclasses.replace(
+                        config.process,
+                        reference_color_order=selected_flow_word,
+                        selected_color_sector_ids=(0,),
+                    ),
+                )
+            Generator(
+                config,
+                progress=StreamProgressSink(sys.stderr),
+            ).generate(
+                _selected_process(arguments),
+                artifact,
+                model=model_source,
+                mode=arguments.write_mode,
+            )
+    except Exception as error:
+        if arguments.mode == "recurrence":
+            raise HarnessError(
+                "recurrence generation is unavailable or failed; install a native "
+                "build with recurrence support and a current built-in prepared "
+                f"model pack: {error}"
+            ) from error
+        raise
+    return {
+        "mode": arguments.mode,
+        "generation_wall_seconds": time.perf_counter() - generation_started,
+        "generation_reused": False,
+        "peak_rss": _resource_peak(),
+        "specialized_flow_word": (
+            None
+            if selected_flow_word is None
+            else list(int(label) for label in selected_flow_word)
+        ),
+        "model_source": {
+            **model_record,
+            "access_seconds": prepared_access_seconds,
+        },
+    }
+
+
+def _profile_worker(arguments: argparse.Namespace) -> dict[str, object]:
+    from pyamplicol import BenchmarkRunner, Runtime
+    from pyamplicol.config import BenchmarkConfig
+
+    timing_profile = getattr(arguments, "operation", "profile") == "profile"
+    if timing_profile and len(arguments.batch_size) != 1:
+        raise HarnessError(
+            "profile timing workers require exactly one batch size per subprocess"
+        )
+    if not timing_profile and arguments.batch_size:
+        raise HarnessError("preflight workers do not accept timing batch sizes")
+    pre_timing_verification = _verify_profile_worker_environment(arguments)
+    artifact = arguments.artifact.resolve()
+    load_started = time.perf_counter()
+    try:
+        process = _selected_process(arguments)
+        runtime = Runtime.load(artifact, process=process)
+    except Exception as error:
+        if arguments.mode == "recurrence":
+            raise HarnessError(
+                "the installed runtime cannot load the recurrence artifact; "
+                f"rebuild pyAmpliCol with recurrence support: {error}"
+            ) from error
+        raise
+    loaded_artifact_before_timing = _loaded_runtime_artifact_verification(
+        runtime,
+        expected_artifact_id=pre_timing_verification["expected"]["artifact_id"],
+        phase="after-native-load-before-timing",
+    )
+    pre_timing_verification["loaded_runtime_artifact"] = loaded_artifact_before_timing
+    cold_load_seconds = time.perf_counter() - load_started
+    peak_after_load = _resource_peak()
+    physics = runtime.physics
+    if physics.process.casefold() != process.casefold():
+        raise HarnessError(
+            f"artifact resolved process {physics.process!r}, expected {process!r}"
+        )
+    if physics.color_accuracy != "lc" or not physics.color_flows:
+        raise HarnessError("benchmark artifact does not expose physical LC flows")
+
+    def resolve_axis(
+        requested: str,
+        available_ids: tuple[str, ...],
+        *,
+        label: str,
+    ) -> str:
+        try:
+            ordinal = int(requested, 10)
+        except ValueError:
+            ordinal = 0
+        if ordinal:
+            if ordinal < 1 or ordinal > len(available_ids):
+                raise HarnessError(
+                    f"{label} ordinal is outside 1..{len(available_ids)}"
+                )
+            return available_ids[ordinal - 1]
+        if requested not in set(available_ids):
+            raise HarnessError(
+                f"unknown {label} {requested!r}; artifact exposes "
+                f"{len(available_ids)} values"
+            )
+        return requested
+
+    color_flow_id = resolve_axis(
+        arguments.color_flow,
+        tuple(flow.id for flow in physics.color_flows),
+        label="color flow",
+    )
+    helicity_id = resolve_axis(
+        arguments.helicity,
+        tuple(helicity.id for helicity in physics.helicities),
+        label="helicity",
+    )
+    union_workload = arguments.lc_flow_layout == "all-flow-union"
+    selectors: dict[str, Any] = (
+        {"helicities": (helicity_id,)}
+        if union_workload
+        else {"color_flows": (color_flow_id,)}
+    )
+
+    validation_point_artifact = arguments.validation_point_artifact.resolve()
+    validation_points, validation_fixture = _validation_fixture(
+        validation_point_artifact,
+        physics.process_id,
+    )
+    if not validation_points:
+        raise HarnessError("artifact contains no deterministic validation point")
+    selected_totals = tuple(
+        complex(value) for value in runtime.evaluate(validation_points, **selectors)
+    )
+    selected_resolved = runtime.evaluate_resolved(validation_points, **selectors)
+    resolved_totals = tuple(complex(value) for value in selected_resolved.total())
+    resolved_components = [
+        [
+            _complex_payload(complex(value))
+            for helicity_row in point_values
+            for value in helicity_row
+        ]
+        for point_values in selected_resolved.values
+    ]
+    if len(selected_totals) != len(validation_points) or len(resolved_totals) != len(
+        validation_points
+    ):
+        raise HarnessError("runtime validation result count does not match fixture")
+    point_comparisons: list[dict[str, object]] = []
+    for index, (selected_total, resolved_total) in enumerate(
+        zip(selected_totals, resolved_totals, strict=True)
+    ):
+        absolute = abs(selected_total - resolved_total)
+        relative = absolute / max(abs(selected_total), abs(resolved_total), 1.0e-300)
+        point_comparisons.append(
+            {
+                "point_index": index,
+                "selected_total": _complex_payload(selected_total),
+                "resolved_sum": _complex_payload(resolved_total),
+                "absolute_difference": absolute,
+                "relative_difference": relative,
+                "passes": _within_numerical_tolerance(
+                    selected_total,
+                    resolved_total,
+                ),
+            }
+        )
+
+    profiles: list[dict[str, object]] = []
+    for batch_size in arguments.batch_size if timing_profile else ():
+        try:
+            result = BenchmarkRunner(
+                BenchmarkConfig(
+                    target_runtime=arguments.target_runtime,
+                    batch_size=batch_size,
+                    precision=16,
+                    warmup_runs=arguments.warmup_runs,
+                    minimum_samples=arguments.minimum_samples,
+                    color_flow_ids=(() if union_workload else (color_flow_id,)),
+                    helicity_ids=((helicity_id,) if union_workload else ()),
+                )
+            ).run(runtime, points=validation_points)
+        except Exception as error:
+            if arguments.mode == "recurrence":
+                raise HarnessError(
+                    "the installed runtime cannot profile recurrence execution at "
+                    f"batch {batch_size}: {error}"
+                ) from error
+            raise
+        if (
+            isinstance(result.effective_config.batch_size, bool)
+            or not isinstance(result.effective_config.batch_size, int)
+            or result.effective_config.batch_size != batch_size
+            or isinstance(result.sample_count, bool)
+            or not isinstance(result.sample_count, int)
+            or result.sample_count <= 0
+            or isinstance(result.repetitions_per_sample, bool)
+            or not isinstance(result.repetitions_per_sample, int)
+            or result.repetitions_per_sample <= 0
+            or isinstance(result.evaluation_count, bool)
+            or not isinstance(result.evaluation_count, int)
+            or result.evaluation_count <= 0
+            or isinstance(result.evaluated_point_count, bool)
+            or not isinstance(result.evaluated_point_count, int)
+            or result.evaluated_point_count <= 0
+            or result.evaluation_count
+            != result.sample_count * result.repetitions_per_sample
+            or result.evaluated_point_count != result.evaluation_count * batch_size
+        ):
+            raise HarnessError("benchmark runner returned invalid timing counts")
+        minimum_block_count = max(
+            MIN_AUTHORITATIVE_SAMPLES,
+            arguments.minimum_samples,
+        )
+        estimated_seconds_per_repetition = (
+            float(result.wall_time_per_point) * batch_size
+        )
+        if (
+            not math.isfinite(estimated_seconds_per_repetition)
+            or estimated_seconds_per_repetition <= 0.0
+        ):
+            raise HarnessError(
+                "benchmark runner returned an invalid raw-wall calibration"
+            )
+        repetitions_per_raw_block = max(
+            result.repetitions_per_sample,
+            math.ceil(
+                (arguments.target_runtime * 1.02)
+                / (minimum_block_count * estimated_seconds_per_repetition)
+            ),
+        )
+        calibration = {
+            "kind": "benchmark-runner-wall-rate-calibration",
+            "schema_version": 1,
+            "benchmark_runner_sample_count": result.sample_count,
+            "benchmark_runner_repetitions_per_sample": (
+                result.repetitions_per_sample
+            ),
+            "benchmark_runner_total_repetitions": (
+                result.sample_count * result.repetitions_per_sample
+            ),
+            "benchmark_runner_wall_seconds_per_point": (
+                float(result.wall_time_per_point)
+            ),
+            "requested_minimum_block_count": minimum_block_count,
+            "preceded_by_benchmark_runner_warmup_runs": (
+                arguments.warmup_runs
+            ),
+            "duration_headroom_factor": 1.02,
+            "scaled_repetitions_per_block": repetitions_per_raw_block,
+        }
+        raw_blocks = _native_wall_block_payload(
+            runtime,
+            validation_points,
+            batch_size=batch_size,
+            repetitions_per_block=repetitions_per_raw_block,
+            block_count=minimum_block_count,
+            minimum_native_wall_seconds=arguments.target_runtime,
+            calibration=calibration,
+            selectors=selectors,
+            fixture_points_sha256=str(validation_fixture["points_sha256"]),
+        )
+        measurement = _benchmark_payload(result)
+        for field in (
+            "wall_seconds_per_point",
+            "wall_uncertainty",
+            "sample_count",
+            "repetitions_per_sample",
+            "evaluation_count",
+            "evaluated_point_count",
+        ):
+            measurement[f"benchmark_runner_{field}"] = measurement[field]
+        measurement["wall_seconds_per_point"] = raw_blocks[
+            "wall_seconds_per_point_median"
+        ]
+        measurement["wall_uncertainty"] = {
+            "statistics_contract": "median-and-raw-mad-v1",
+            "raw_mad_seconds_per_point": raw_blocks["wall_seconds_per_point_mad"],
+        }
+        measurement["sample_count"] = raw_blocks["block_count"]
+        measurement["repetitions_per_sample"] = raw_blocks[
+            "repetitions_per_block"
+        ]
+        measurement["evaluation_count"] = raw_blocks["evaluation_count"]
+        measurement["evaluated_point_count"] = raw_blocks["evaluated_point_count"]
+        measurement["inner_native_wall_blocks"] = raw_blocks
+        profiles.append(measurement)
+
+    loaded_artifact_after_timing = _loaded_runtime_artifact_verification(
+        runtime,
+        expected_artifact_id=pre_timing_verification["expected"]["artifact_id"],
+        phase=("after-timing" if timing_profile else "after-validation-preflight"),
+    )
+
+    return {
+        "mode": arguments.mode,
+        "schedule_index": arguments.schedule_index,
+        "schedule_round": arguments.schedule_round,
+        "pre_timing_verification": pre_timing_verification,
+        "post_timing_loaded_runtime_artifact": loaded_artifact_after_timing,
+        "timing_configuration": {
+            "minimum_internal_samples": arguments.minimum_samples,
+            "warmup_runs": arguments.warmup_runs,
+            "target_runtime_seconds": arguments.target_runtime,
+        },
+        "cold_load_seconds": cold_load_seconds,
+        "peak_rss_after_cold_load": peak_after_load,
+        "peak_rss_after_profile": _resource_peak(),
+        "process_id": physics.process_id,
+        "process_expression": physics.process,
+        "selector_contract": {
+            "color_flow_request": arguments.color_flow,
+            "resolved_color_flow_id": (None if union_workload else color_flow_id),
+            "helicity_request": arguments.helicity,
+            "resolved_helicity_id": helicity_id if union_workload else None,
+            "color_flow_count": len(physics.color_flows),
+            "helicity_count": len(physics.helicities),
+            "structural_zero_helicity_count": (physics.structural_zero_helicity_count),
+            "workload": (
+                "all-flows/runtime-selected-single-helicity"
+                if union_workload
+                else "single-runtime-selected-flow/helicity-sum"
+            ),
+        },
+        "validation": {
+            "point_source_artifact": str(validation_point_artifact),
+            "fixture": validation_fixture,
+            "selected_totals": [_complex_payload(value) for value in selected_totals],
+            "resolved_sums": [_complex_payload(value) for value in resolved_totals],
+            "resolved_helicity_ids": list(selected_resolved.helicity_ids),
+            "resolved_color_ids": list(selected_resolved.color_ids),
+            "resolved_components": resolved_components,
+            "point_comparisons": point_comparisons,
+            "maximum_absolute_difference": max(
+                abs(selected - resolved)
+                for selected, resolved in zip(
+                    selected_totals,
+                    resolved_totals,
+                    strict=True,
+                )
+            ),
+            "maximum_relative_difference": max(
+                abs(selected - resolved) / max(abs(selected), abs(resolved), 1.0e-300)
+                for selected, resolved in zip(
+                    selected_totals,
+                    resolved_totals,
+                    strict=True,
+                )
+            ),
+            "passes": all(bool(item["passes"]) for item in point_comparisons),
+        },
+        "profiles": profiles,
+    }
+
+
+def _worker_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("operation", choices=("generate", "preflight", "profile"))
+    parser.add_argument(
+        "--mode",
+        choices=("compiled", "eager", "recurrence"),
+        required=True,
+    )
+    parser.add_argument("--artifact", type=Path, required=True)
+    parser.add_argument("--validation-point-artifact", type=Path)
+    parser.add_argument("--write-mode", choices=("error", "replace"), default="error")
+    parser.add_argument("--batch-size", type=_positive_int, action="append", default=[])
+    parser.add_argument("--schedule-index", type=int)
+    parser.add_argument("--schedule-round", type=int)
+    for field in _PROFILE_EXPECTATION_FIELDS:
+        parser.add_argument(f"--expected-{field.replace('_', '-')}")
+    parser.add_argument("--target-runtime", type=_positive_float, default=5.0)
+    parser.add_argument("--minimum-samples", type=_positive_int, default=5)
+    parser.add_argument("--warmup-runs", type=int, default=2)
+    parser.add_argument("--color-flow", default="1")
+    parser.add_argument("--helicity", default="1")
+    parser.add_argument(
+        "--lc-flow-layout",
+        choices=("topology-replay", "all-flow-union"),
+        default="topology-replay",
+    )
+    parser.add_argument("--gluon-count", type=_positive_int, default=6)
+    parser.add_argument("--process-expression")
+    parser.add_argument("--validation-samples", type=_positive_int, default=10)
+    parser.add_argument("--point-tile-size", type=_positive_int, default=1024)
+    parser.add_argument(
+        "--jit-optimization-level",
+        type=int,
+        choices=(0, 1, 2, 3),
+        default=2,
+    )
+    parser.add_argument("--prepared-model", type=Path)
+    parser.add_argument(
+        "--specialize-flow-at-generation",
+        action="store_true",
+    )
+    return parser
+
+
+def _worker_main(argv: Sequence[str]) -> int:
+    started_at = _utc_now()
+    started = time.perf_counter()
+    arguments = _worker_parser().parse_args(argv)
+    if arguments.warmup_runs < 0:
+        raise HarnessError("warmup runs must be non-negative")
+    if (
+        arguments.operation in {"preflight", "profile"}
+        and arguments.validation_point_artifact is None
+    ):
+        raise HarnessError(
+            "validation workers require an explicit --validation-point-artifact"
+        )
+    if arguments.operation == "profile" and (
+        arguments.schedule_index is None
+        or arguments.schedule_index < 0
+        or arguments.schedule_round is None
+        or arguments.schedule_round < 0
+    ):
+        raise HarnessError("profile workers require non-negative schedule coordinates")
+    operation = (
+        _generate_worker if arguments.operation == "generate" else _profile_worker
+    )
+    payload = operation(arguments)
+    process_record = {
+        "started_at_utc": started_at,
+        "finished_at_utc": _utc_now(),
+        "wall_seconds": time.perf_counter() - started,
+        "process_id": os.getpid(),
+        "operation": arguments.operation,
+        "mode": arguments.mode,
+        "payload_sha256": _canonical_sha256(payload),
+    }
+    process_record["content_sha256"] = _canonical_sha256(process_record)
+    payload["worker_process_record"] = process_record
+    print(_WORKER_MARKER + json.dumps(payload, sort_keys=True, allow_nan=False))
+    return 0
+
+
+def _run_worker(
+    arguments: Sequence[str],
+    *,
+    mode: str,
+    phase: str,
+    timeout_seconds: float,
+) -> dict[str, Any]:
+    command = (sys.executable, str(DRIVER_PATH), "_worker", *arguments)
+    expected_operation = arguments[0] if arguments else None
+    environment = os.environ.copy()
+    environment.setdefault("SYMBOLICA_HIDE_BANNER", "1")
+    environment.setdefault("PYTHONFAULTHANDLER", "1")
+    started_at = _utc_now()
+    started = time.perf_counter()
+    try:
+        completed = subprocess.run(
+            command,
+            cwd=ROOT,
+            env=environment,
+            check=False,
+            stdout=subprocess.PIPE,
+            text=True,
+            timeout=timeout_seconds,
+        )
+    except subprocess.TimeoutExpired as error:
+        raise HarnessError(
+            f"{mode} {phase} worker exceeded {timeout_seconds:g} seconds"
+        ) from error
+    if completed.stderr:
+        print(completed.stderr, file=sys.stderr, end="")
+    if completed.returncode != 0:
+        stderr_text = completed.stderr or ""
+        detail = (
+            "\n".join(
+                section
+                for section in (
+                    completed.stdout.strip()[-4000:],
+                    stderr_text.strip()[-4000:],
+                )
+                if section
+            )
+            or "no worker output"
+        )
+        raise HarnessError(
+            f"{mode} {phase} worker failed with exit {completed.returncode}: {detail}"
+        )
+    for line in reversed(completed.stdout.splitlines()):
+        if line.startswith(_WORKER_MARKER):
+            payload = json.loads(line.removeprefix(_WORKER_MARKER))
+            if isinstance(payload, dict):
+                process_record = payload.get("worker_process_record")
+                payload_without_process_record = dict(payload)
+                payload_without_process_record.pop("worker_process_record", None)
+                if not isinstance(process_record, Mapping):
+                    raise HarnessError(
+                        f"{mode} {phase} worker returned no content-addressed "
+                        "process record"
+                    )
+                process_record_without_digest = dict(process_record)
+                process_record_digest = process_record_without_digest.pop(
+                    "content_sha256",
+                    None,
+                )
+                process_wall_seconds = process_record.get("wall_seconds")
+                process_id = process_record.get("process_id")
+                if (
+                    process_record.get("payload_sha256")
+                    != _canonical_sha256(payload_without_process_record)
+                    or process_record_digest
+                    != _canonical_sha256(process_record_without_digest)
+                    or not _is_utc_timestamp(process_record.get("started_at_utc"))
+                    or not _is_utc_timestamp(process_record.get("finished_at_utc"))
+                    or not _utc_timestamps_nondecreasing(
+                        process_record.get("started_at_utc"),
+                        process_record.get("finished_at_utc"),
+                    )
+                    or isinstance(process_wall_seconds, bool)
+                    or not isinstance(process_wall_seconds, (float, int))
+                    or not math.isfinite(float(process_wall_seconds))
+                    or float(process_wall_seconds) <= 0.0
+                    or isinstance(process_id, bool)
+                    or not isinstance(process_id, int)
+                    or process_id <= 0
+                    or process_record.get("operation") != expected_operation
+                    or process_record.get("mode") != mode
+                ):
+                    raise HarnessError(
+                        f"{mode} {phase} worker process record failed its "
+                        "content-address check"
+                    )
+                command_identity = _command_identity(command)
+                payload["worker_command"] = command_identity
+                invocation = {
+                    "started_at_utc": started_at,
+                    "finished_at_utc": _utc_now(),
+                    "wall_seconds": time.perf_counter() - started,
+                    "command": command_identity,
+                }
+                invocation["content_sha256"] = _canonical_sha256(invocation)
+                payload["worker_invocation"] = invocation
+                result_record = {
+                    "recorded_at_utc": _utc_now(),
+                    "addressed_payload_sha256": _canonical_sha256(payload),
+                    "worker_process_record_sha256": process_record_digest,
+                    "worker_invocation_sha256": invocation["content_sha256"],
+                }
+                result_record["content_sha256"] = _canonical_sha256(result_record)
+                payload["worker_result_record"] = result_record
+                return payload
+            break
+    raise HarnessError(f"{mode} {phase} worker did not emit a JSON result")
+
+
+def _assert_identity_unchanged(
+    label: str,
+    expected: object,
+    observed: object,
+) -> None:
+    if _canonical_sha256(expected) != _canonical_sha256(observed):
+        raise HarnessError(f"{label} drifted during a worker or long-running phase")
+
+
+def _artifact_drift_baseline(
+    artifact: Path,
+    *,
+    generation_signature: Mapping[str, object],
+    artifact_identity: Mapping[str, object],
+    reuse_signature: Mapping[str, object],
+) -> dict[str, object]:
+    return {
+        "artifact": str(artifact.resolve()),
+        "generation_signature": dict(generation_signature),
+        "artifact_identity": dict(artifact_identity),
+        "reuse_signature": dict(reuse_signature),
+        "reuse_sidecar_sha256": _path_identity(_reuse_signature_path(artifact))[
+            "sha256"
+        ],
+    }
+
+
+def _recheck_driver_state(
+    source_identity: Mapping[str, object],
+    runtime_provenance: Mapping[str, object],
+    artifact_baselines: Mapping[str, Mapping[str, object]],
+    *,
+    phase: str,
+) -> dict[str, object]:
+    """Fail immediately if source, runtime, or any completed artifact drifted."""
+
+    observed_source = _git_source_identity()
+    _assert_identity_unchanged(
+        "benchmark source identity",
+        source_identity,
+        observed_source,
+    )
+    observed_runtime = _runtime_provenance(observed_source)
+    _assert_identity_unchanged(
+        "benchmark runtime provenance",
+        runtime_provenance,
+        observed_runtime,
+    )
+    observed_artifacts: dict[str, dict[str, str]] = {}
+    for mode, baseline in artifact_baselines.items():
+        raw_artifact = baseline.get("artifact")
+        expected_generation = baseline.get("generation_signature")
+        expected_identity = baseline.get("artifact_identity")
+        expected_reuse = baseline.get("reuse_signature")
+        if (
+            not isinstance(raw_artifact, str)
+            or not isinstance(expected_generation, Mapping)
+            or not isinstance(expected_identity, Mapping)
+            or not isinstance(expected_reuse, Mapping)
+        ):
+            raise HarnessError(f"driver artifact drift baseline is invalid for {mode}")
+        artifact = Path(raw_artifact)
+        expected_tree = expected_identity.get("tree")
+        if not isinstance(expected_tree, Mapping):
+            raise HarnessError(f"driver artifact tree baseline is invalid for {mode}")
+        expected_sidecar_sha = _required_sha256(
+            baseline.get("reuse_sidecar_sha256"),
+            label=f"{mode} reuse sidecar baseline",
+        )
+        observed_identity, observed_reuse, observed_sidecar_identity = (
+            _require_bound_reusable_artifact(
+                artifact,
+                expected_tree_sha256=_required_sha256(
+                    expected_tree.get("sha256"),
+                    label=f"{mode} artifact tree baseline",
+                ),
+                expected_semantic_identity_sha256=_required_sha256(
+                    expected_identity.get("semantic_identity_sha256"),
+                    label=f"{mode} artifact semantic baseline",
+                ),
+                expected_reuse_semantic_signature_sha256=_required_sha256(
+                    expected_reuse.get("semantic_signature_sha256"),
+                    label=f"{mode} reuse semantic baseline",
+                ),
+                expected_sidecar_sha256=expected_sidecar_sha,
+                expected_signature=expected_generation,
+            )
+        )
+        observed_tree = observed_identity.get("tree")
+        if not isinstance(observed_tree, Mapping):
+            raise HarnessError(f"{mode} bound artifact tree is incomplete")
+        _assert_identity_unchanged(
+            f"{mode} artifact tree",
+            expected_tree,
+            observed_tree,
+        )
+        expected_semantic = expected_identity.get("semantic_identity")
+        observed_semantic = observed_identity.get("semantic_identity")
+        if not isinstance(expected_semantic, Mapping) or not isinstance(
+            observed_semantic,
+            Mapping,
+        ):
+            raise HarnessError(f"{mode} artifact semantic baseline is incomplete")
+        _assert_identity_unchanged(
+            f"{mode} artifact semantic identity",
+            expected_semantic,
+            observed_semantic,
+        )
+        expected_bound_identity = {
+            str(key): value
+            for key, value in expected_identity.items()
+            if key != "payloads"
+        }
+        _assert_identity_unchanged(
+            f"{mode} bound artifact identity",
+            expected_bound_identity,
+            observed_identity,
+        )
+        expected_payloads = expected_identity.get("payloads")
+        if not isinstance(expected_payloads, list):
+            raise HarnessError(
+                f"driver artifact payload baseline is invalid for {mode}"
+            )
+        observed_full_identity = {
+            **observed_identity,
+            "payloads": list(expected_payloads),
+        }
+        _assert_identity_unchanged(
+            f"{mode} reconstructed full artifact identity",
+            expected_identity,
+            observed_full_identity,
+        )
+        _assert_identity_unchanged(
+            f"{mode} artifact reuse signature",
+            expected_reuse,
+            observed_reuse,
+        )
+        observed_sidecar_sha = _required_sha256(
+            observed_sidecar_identity.get("sha256"),
+            label=f"{mode} observed reuse sidecar",
+        )
+        if observed_sidecar_sha != expected_sidecar_sha:
+            raise HarnessError(
+                f"{mode} artifact reuse sidecar drifted during a worker or long run"
+            )
+        observed_artifacts[mode] = {
+            "artifact_identity_sha256": _canonical_sha256(observed_full_identity),
+            "reuse_signature_sha256": _canonical_sha256(observed_reuse),
+            "reuse_sidecar_sha256": observed_sidecar_sha,
+        }
+    return {
+        "phase": phase,
+        "checked_at_utc": _utc_now(),
+        "source_identity_sha256": _canonical_sha256(observed_source),
+        "runtime_provenance_sha256": _canonical_sha256(observed_runtime),
+        "artifacts": observed_artifacts,
+    }
+
+
+def _complex_values(value: object, *, label: str) -> tuple[complex, ...]:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes, bytearray)):
+        raise HarnessError(f"{label} must be a sequence")
+    result: list[complex] = []
+    for entry in value:
+        if (
+            not isinstance(entry, Sequence)
+            or isinstance(entry, (str, bytes, bytearray))
+            or len(entry) != 2
+        ):
+            raise HarnessError(f"{label} contains an invalid complex value")
+        real = entry[0]
+        imaginary = entry[1]
+        if (
+            isinstance(real, bool)
+            or not isinstance(real, (float, int))
+            or not math.isfinite(float(real))
+            or isinstance(imaginary, bool)
+            or not isinstance(imaginary, (float, int))
+            or not math.isfinite(float(imaginary))
+        ):
+            raise HarnessError(f"{label} contains an invalid complex value")
+        result.append(complex(float(real), float(imaginary)))
+    if not result:
+        raise HarnessError(f"{label} contains no validation values")
+    return tuple(result)
+
+
+def _comparison(
+    left_mode: str,
+    left: object,
+    right_mode: str,
+    right: object,
+) -> dict[str, object]:
+    left_values = _complex_values(left, label=f"{left_mode} validation values")
+    right_values = _complex_values(right, label=f"{right_mode} validation values")
+    point_comparisons: list[dict[str, object]] = []
+    for index, (left_value, right_value) in enumerate(
+        zip(left_values, right_values, strict=False)
+    ):
+        absolute = abs(left_value - right_value)
+        relative = absolute / max(abs(left_value), abs(right_value), 1.0e-300)
+        point_comparisons.append(
+            {
+                "point_index": index,
+                "left": _complex_payload(left_value),
+                "right": _complex_payload(right_value),
+                "absolute_difference": absolute,
+                "relative_difference": relative,
+                "passes": _within_numerical_tolerance(
+                    left_value,
+                    right_value,
+                ),
+            }
+        )
+    counts_match = len(left_values) == len(right_values)
+    return {
+        "left_mode": left_mode,
+        "right_mode": right_mode,
+        "left_point_count": len(left_values),
+        "right_point_count": len(right_values),
+        "point_counts_match": counts_match,
+        "point_comparisons": point_comparisons,
+        "maximum_absolute_difference": max(
+            abs(left_value - right_value)
+            for left_value, right_value in zip(
+                left_values,
+                right_values,
+                strict=False,
+            )
+        ),
+        "maximum_relative_difference": max(
+            abs(left_value - right_value)
+            / max(abs(left_value), abs(right_value), 1.0e-300)
+            for left_value, right_value in zip(
+                left_values,
+                right_values,
+                strict=False,
+            )
+        ),
+        "passes": counts_match
+        and all(bool(item["passes"]) for item in point_comparisons),
+    }
+
+
+def _validation_fixture_contract(
+    validation: Mapping[str, Any],
+    *,
+    mode: str,
+) -> dict[str, object]:
+    fixture = validation.get("fixture")
+    if not isinstance(fixture, Mapping):
+        raise HarnessError(f"{mode} profile has no validation fixture identity")
+    raw_file = fixture.get("file")
+    if not isinstance(raw_file, Mapping):
+        raise HarnessError(f"{mode} profile has no validation fixture file identity")
+    point_count = fixture.get("point_count")
+    points_sha256 = fixture.get("points_sha256")
+    file_sha256 = raw_file.get("sha256")
+    if (
+        isinstance(point_count, bool)
+        or not isinstance(point_count, int)
+        or point_count <= 0
+        or not isinstance(points_sha256, str)
+        or _SHA256_PATTERN.fullmatch(points_sha256) is None
+        or not isinstance(file_sha256, str)
+        or _SHA256_PATTERN.fullmatch(file_sha256) is None
+    ):
+        raise HarnessError(f"{mode} profile validation fixture identity is invalid")
+    return {
+        "point_count": point_count,
+        "points_sha256": points_sha256,
+        "file_sha256": file_sha256,
+    }
+
+
+def _profile_selector_contract_matches(
+    arguments: argparse.Namespace,
+    selector_contract: object,
+    semantic_identity: object,
+) -> bool:
+    if not isinstance(selector_contract, Mapping) or set(selector_contract) != {
+        "color_flow_request",
+        "resolved_color_flow_id",
+        "helicity_request",
+        "resolved_helicity_id",
+        "color_flow_count",
+        "helicity_count",
+        "structural_zero_helicity_count",
+        "workload",
+    }:
+        return False
+    if not isinstance(semantic_identity, Mapping):
+        return False
+    color_axis = semantic_identity.get("physical_color_flows")
+    helicity_axis = semantic_identity.get("physical_helicities")
+    if not isinstance(color_axis, Mapping) or not isinstance(
+        helicity_axis,
+        Mapping,
+    ):
+        return False
+    color_ids = color_axis.get("ordered_ids")
+    helicity_ids = helicity_axis.get("ordered_ids")
+    helicity_entries = helicity_axis.get("ordered_entries")
+    if (
+        not isinstance(color_ids, list)
+        or not isinstance(helicity_ids, list)
+        or not isinstance(helicity_entries, list)
+    ):
+        return False
+    structural_zero_ids = {
+        entry.get("id")
+        for entry in helicity_entries
+        if isinstance(entry, Mapping) and entry.get("structural_zero") is True
+    }
+    color_count = selector_contract.get("color_flow_count")
+    helicity_count = selector_contract.get("helicity_count")
+    structural_zero_count = selector_contract.get("structural_zero_helicity_count")
+    if (
+        selector_contract.get("color_flow_request") != arguments.color_flow
+        or selector_contract.get("helicity_request") != arguments.helicity
+        or isinstance(color_count, bool)
+        or not isinstance(color_count, int)
+        or color_count <= 0
+        or isinstance(helicity_count, bool)
+        or not isinstance(helicity_count, int)
+        or helicity_count <= 0
+        or isinstance(structural_zero_count, bool)
+        or not isinstance(structural_zero_count, int)
+        or structural_zero_count < 0
+        or structural_zero_count > helicity_count
+        or not _is_exact_int(color_axis.get("count"), color_count)
+        or not _is_exact_int(helicity_axis.get("count"), helicity_count)
+        or structural_zero_count != len(structural_zero_ids)
+    ):
+        return False
+    color_id = selector_contract.get("resolved_color_flow_id")
+    helicity_id = selector_contract.get("resolved_helicity_id")
+    if arguments.lc_flow_layout == "all-flow-union":
+        return (
+            color_id is None
+            and isinstance(helicity_id, str)
+            and bool(helicity_id)
+            and helicity_id in helicity_ids
+            and helicity_id not in structural_zero_ids
+            and selector_contract.get("workload")
+            == "all-flows/runtime-selected-single-helicity"
+        )
+    return (
+        isinstance(color_id, str)
+        and bool(color_id)
+        and color_id in color_ids
+        and helicity_id is None
+        and selector_contract.get("workload")
+        == "single-runtime-selected-flow/helicity-sum"
+    )
+
+
+def _selected_union_selector_projection(
+    arguments: argparse.Namespace,
+    selector_contract: object,
+    semantic_identity: object,
+) -> dict[str, object]:
+    """Project away only the audited nonselected structural-zero census."""
+
+    if not _selected_union_semantic_exception_enabled(arguments):
+        raise HarnessError(
+            "selected-union selector projection is outside its audited workload"
+        )
+    if not _profile_selector_contract_matches(
+        arguments,
+        selector_contract,
+        semantic_identity,
+    ):
+        raise HarnessError("selected-union selector contract is invalid")
+    assert isinstance(selector_contract, Mapping)
+    if (
+        selector_contract.get("resolved_helicity_id")
+        != MIGRATION_UNION_SELECTED_HELICITY_ID
+        or selector_contract.get("workload")
+        != "all-flows/runtime-selected-single-helicity"
+    ):
+        raise HarnessError("selected-union selector does not resolve the audited ID")
+    return {
+        key: selector_contract[key]
+        for key in (
+            "color_flow_request",
+            "resolved_color_flow_id",
+            "helicity_request",
+            "resolved_helicity_id",
+            "color_flow_count",
+            "helicity_count",
+            "workload",
+        )
+    }
+
+
+def _validated_lane_validation_values(
+    validation: Mapping[str, Any],
+    fixture_contract: Mapping[str, object],
+    *,
+    mode: str,
+) -> tuple[complex, ...]:
+    point_count = fixture_contract.get("point_count")
+    if isinstance(point_count, bool) or not isinstance(point_count, int):
+        raise HarnessError(f"{mode} validation fixture point count is invalid")
+    selected = _complex_values(
+        validation.get("selected_totals"),
+        label=f"{mode} selected validation totals",
+    )
+    resolved = _complex_values(
+        validation.get("resolved_sums"),
+        label=f"{mode} resolved validation sums",
+    )
+    comparisons = validation.get("point_comparisons")
+    if (
+        len(selected) != point_count
+        or len(resolved) != point_count
+        or not isinstance(comparisons, list)
+        or len(comparisons) != point_count
+    ):
+        raise HarnessError(f"{mode} validation inventory disagrees with fixture")
+    absolute_values: list[float] = []
+    relative_values: list[float] = []
+    expected_passes: list[bool] = []
+    for index, (selected_value, resolved_value, comparison) in enumerate(
+        zip(selected, resolved, comparisons, strict=True)
+    ):
+        absolute = abs(selected_value - resolved_value)
+        relative = absolute / max(
+            abs(selected_value),
+            abs(resolved_value),
+            1.0e-300,
+        )
+        expected_pass = _within_numerical_tolerance(
+            selected_value,
+            resolved_value,
+        )
+        if (
+            not math.isfinite(absolute)
+            or not math.isfinite(relative)
+            or not isinstance(comparison, Mapping)
+            or set(comparison)
+            != {
+                "point_index",
+                "selected_total",
+                "resolved_sum",
+                "absolute_difference",
+                "relative_difference",
+                "passes",
+            }
+            or not _is_exact_int(comparison.get("point_index"), index)
+            or _canonical_sha256(comparison.get("selected_total"))
+            != _canonical_sha256(_complex_payload(selected_value))
+            or _canonical_sha256(comparison.get("resolved_sum"))
+            != _canonical_sha256(_complex_payload(resolved_value))
+            or isinstance(comparison.get("absolute_difference"), bool)
+            or not isinstance(
+                comparison.get("absolute_difference"),
+                (float, int),
+            )
+            or float(comparison["absolute_difference"]) != absolute
+            or isinstance(comparison.get("relative_difference"), bool)
+            or not isinstance(
+                comparison.get("relative_difference"),
+                (float, int),
+            )
+            or float(comparison["relative_difference"]) != relative
+            or comparison.get("passes") is not expected_pass
+        ):
+            raise HarnessError(f"{mode} validation point evidence is inconsistent")
+        absolute_values.append(absolute)
+        relative_values.append(relative)
+        expected_passes.append(expected_pass)
+    maximum_absolute = validation.get("maximum_absolute_difference")
+    maximum_relative = validation.get("maximum_relative_difference")
+    lane_passes = all(expected_passes)
+    if (
+        isinstance(maximum_absolute, bool)
+        or not isinstance(maximum_absolute, (float, int))
+        or float(maximum_absolute) != max(absolute_values)
+        or isinstance(maximum_relative, bool)
+        or not isinstance(maximum_relative, (float, int))
+        or float(maximum_relative) != max(relative_values)
+        or validation.get("passes") is not lane_passes
+    ):
+        raise HarnessError(f"{mode} validation summary is inconsistent")
+    resolved_components = _validated_resolved_components(
+        validation,
+        point_count=point_count,
+        mode=mode,
+    )
+    for resolved_value, components in zip(
+        resolved,
+        resolved_components,
+        strict=True,
+    ):
+        component_sum = sum(components, 0.0j)
+        absolute = abs(resolved_value - component_sum)
+        relative = absolute / max(
+            abs(resolved_value),
+            abs(component_sum),
+            1.0e-300,
+        )
+        if not _within_numerical_tolerance(component_sum, resolved_value):
+            raise HarnessError(
+                f"{mode} resolved sum disagrees with its physical components"
+            )
+    return selected
+
+
+def _validated_resolved_components(
+    validation: Mapping[str, Any],
+    *,
+    point_count: int,
+    mode: str,
+) -> tuple[tuple[complex, ...], ...]:
+    helicity_ids = validation.get("resolved_helicity_ids")
+    color_ids = validation.get("resolved_color_ids")
+    raw_points = validation.get("resolved_components")
+    if (
+        not isinstance(helicity_ids, list)
+        or not helicity_ids
+        or any(not isinstance(value, str) or not value for value in helicity_ids)
+        or len(set(helicity_ids)) != len(helicity_ids)
+        or not isinstance(color_ids, list)
+        or not color_ids
+        or any(not isinstance(value, str) or not value for value in color_ids)
+        or len(set(color_ids)) != len(color_ids)
+        or not isinstance(raw_points, list)
+        or len(raw_points) != point_count
+    ):
+        raise HarnessError(f"{mode} resolved-component inventory is invalid")
+    expected_component_count = len(helicity_ids) * len(color_ids)
+    points: list[tuple[complex, ...]] = []
+    for raw_point in raw_points:
+        point = _complex_values(
+            raw_point,
+            label=f"{mode} resolved component values",
+        )
+        if len(point) != expected_component_count:
+            raise HarnessError(
+                f"{mode} resolved-component inventory disagrees with its axes"
+            )
+        points.append(point)
+    return tuple(points)
+
+
+def _resolved_component_comparison(
+    left_mode: str,
+    left: Mapping[str, Any],
+    right_mode: str,
+    right: Mapping[str, Any],
+) -> dict[str, object]:
+    left_raw_points = left.get("resolved_components")
+    right_raw_points = right.get("resolved_components")
+    left_points = _validated_resolved_components(
+        left,
+        point_count=len(left_raw_points) if isinstance(left_raw_points, list) else -1,
+        mode=left_mode,
+    )
+    right_points = _validated_resolved_components(
+        right,
+        point_count=(
+            len(right_raw_points) if isinstance(right_raw_points, list) else -1
+        ),
+        mode=right_mode,
+    )
+    axes_match = left.get("resolved_helicity_ids") == right.get(
+        "resolved_helicity_ids"
+    ) and left.get("resolved_color_ids") == right.get("resolved_color_ids")
+    point_counts_match = len(left_points) == len(right_points)
+    component_counts_match = point_counts_match and all(
+        len(left_point) == len(right_point)
+        for left_point, right_point in zip(left_points, right_points, strict=True)
+    )
+    maximum_absolute = 0.0
+    maximum_relative = 0.0
+    values_pass = True
+    compared_component_count = 0
+    for left_point, right_point in zip(left_points, right_points, strict=False):
+        for left_value, right_value in zip(
+            left_point,
+            right_point,
+            strict=False,
+        ):
+            absolute = abs(left_value - right_value)
+            relative = absolute / max(abs(left_value), abs(right_value), 1.0e-300)
+            maximum_absolute = max(maximum_absolute, absolute)
+            maximum_relative = max(maximum_relative, relative)
+            values_pass &= _within_numerical_tolerance(left_value, right_value)
+            compared_component_count += 1
+    return {
+        "left_mode": left_mode,
+        "right_mode": right_mode,
+        "axes_match": axes_match,
+        "left_point_count": len(left_points),
+        "right_point_count": len(right_points),
+        "point_counts_match": point_counts_match,
+        "component_counts_match": component_counts_match,
+        "compared_component_count": compared_component_count,
+        "maximum_absolute_difference": maximum_absolute,
+        "maximum_relative_difference": maximum_relative,
+        "passes": (
+            axes_match and point_counts_match and component_counts_match and values_pass
+        ),
+    }
+
+
+def _pairwise_profile_validation(
+    profiles: Mapping[str, Mapping[str, Any]],
+    *,
+    arguments: argparse.Namespace | None = None,
+) -> dict[str, object]:
+    unknown = set(profiles).difference(EXECUTION_MODES)
+    if unknown:
+        raise HarnessError(
+            "profile validation received unknown modes: " + ", ".join(sorted(unknown))
+        )
+    comparisons: dict[str, dict[str, object]] = {}
+    resolved_component_comparisons: dict[str, dict[str, object]] = {}
+    ordered_modes = [mode for mode in EXECUTION_MODES if mode in profiles]
+    if not ordered_modes:
+        raise HarnessError("profile validation requires at least one lane")
+    lane_validation_passes = True
+    selector_contracts: list[object] = []
+    selector_projections: list[dict[str, object]] = []
+    fixture_contracts: list[dict[str, object]] = []
+    selected_union_projection = _selected_union_semantic_exception_enabled(arguments)
+    for mode in ordered_modes:
+        validation = profiles[mode].get("validation")
+        if not isinstance(validation, Mapping):
+            raise HarnessError(f"{mode} profile returned invalid validation metadata")
+        selector_contract = profiles[mode].get("selector_contract")
+        selector_contracts.append(selector_contract)
+        if selected_union_projection:
+            assert arguments is not None
+            selector_projections.append(
+                _selected_union_selector_projection(
+                    arguments,
+                    selector_contract,
+                    profiles[mode].get("artifact_semantic_identity"),
+                )
+            )
+        fixture_contract = _validation_fixture_contract(validation, mode=mode)
+        fixture_contracts.append(fixture_contract)
+        _validated_lane_validation_values(
+            validation,
+            fixture_contract,
+            mode=mode,
+        )
+        lane_validation_passes = (
+            lane_validation_passes and validation.get("passes") is True
+        )
+    for left_index, left_mode in enumerate(ordered_modes):
+        left_validation = profiles[left_mode]["validation"]
+        for right_mode in ordered_modes[left_index + 1 :]:
+            right_validation = profiles[right_mode]["validation"]
+            key = f"{left_mode}__{right_mode}"
+            comparisons[key] = _comparison(
+                left_mode,
+                left_validation["selected_totals"],
+                right_mode,
+                right_validation["selected_totals"],
+            )
+            resolved_component_comparisons[key] = _resolved_component_comparison(
+                left_mode,
+                left_validation,
+                right_mode,
+                right_validation,
+            )
+    selectors_match = (
+        all(
+            projection == selector_projections[0]
+            for projection in selector_projections[1:]
+        )
+        if selected_union_projection
+        else all(
+            contract == selector_contracts[0] for contract in selector_contracts[1:]
+        )
+    )
+    fixtures_match = all(
+        contract == fixture_contracts[0] for contract in fixture_contracts[1:]
+    )
+    pairwise_passes = (
+        None
+        if not comparisons
+        else all(bool(item["passes"]) for item in comparisons.values())
+        and all(
+            bool(item["passes"]) for item in resolved_component_comparisons.values()
+        )
+    )
+    validation_passes = (
+        lane_validation_passes
+        and selectors_match
+        and fixtures_match
+        and pairwise_passes is not False
+    )
+    return {
+        "comparisons": comparisons,
+        "resolved_component_comparisons": resolved_component_comparisons,
+        "selectors_match": selectors_match,
+        "selector_comparison_policy": (
+            "ddbar-z6g-all-flow-union-selected-helicity-v1"
+            if selected_union_projection
+            else "strict-exact-v1"
+        ),
+        "fixtures_match": fixtures_match,
+        "fixture_contract": fixture_contracts[0] if fixtures_match else None,
+        "lane_validation_passes": lane_validation_passes,
+        "pairwise_validation_passes": pairwise_passes,
+        "passes": validation_passes,
+    }
+
+
+def _preflight_profile_from_worker(
+    worker: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Extract the immutable semantic/numerical body from a preflight worker."""
+
+    mode = worker.get("mode")
+    verification = worker.get("pre_timing_verification")
+    measurements = worker.get("profiles")
+    if (
+        not isinstance(mode, str)
+        or mode not in EXECUTION_MODES
+        or not isinstance(verification, Mapping)
+        or measurements != []
+    ):
+        raise HarnessError("validation preflight worker returned an invalid payload")
+    semantic_identity = verification.get("artifact_semantic_identity")
+    semantic_identity_sha256 = verification.get("artifact_semantic_identity_sha256")
+    if not isinstance(
+        semantic_identity, Mapping
+    ) or semantic_identity_sha256 != _canonical_sha256(semantic_identity):
+        raise HarnessError(
+            "validation preflight worker returned unaddressed artifact semantics"
+        )
+    return {
+        "mode": mode,
+        "process_id": worker.get("process_id"),
+        "process_expression": worker.get("process_expression"),
+        "selector_contract": worker.get("selector_contract"),
+        "validation": worker.get("validation"),
+        "artifact_semantic_identity": dict(semantic_identity),
+        "artifact_semantic_identity_sha256": semantic_identity_sha256,
+        "profiles": [],
+    }
+
+
+def _validation_preflight_contract(
+    arguments: argparse.Namespace,
+    profiles: Mapping[str, Mapping[str, Any]],
+) -> dict[str, object]:
+    """Validate lane semantics and deterministic physics before any timing."""
+
+    semantic = _profile_artifact_semantic_contract(
+        profiles,
+        arguments=arguments,
+    )
+    numerical = _pairwise_profile_validation(
+        profiles,
+        arguments=arguments,
+    )
+    passes = (
+        bool(profiles)
+        and semantic.get("passes") is True
+        and semantic.get("lanes_match") is True
+        and numerical.get("passes") is True
+    )
+    return {
+        "kind": "pyamplicol-pre-profile-validation-contract",
+        "schema_version": 1,
+        "passes": passes,
+        "observed_modes": [mode for mode in EXECUTION_MODES if mode in profiles],
+        "semantic_contract": semantic,
+        "numerical_contract": numerical,
+    }
+
+
+def _require_validation_preflight(
+    arguments: argparse.Namespace,
+    profiles: Mapping[str, Mapping[str, Any]],
+) -> dict[str, object]:
+    try:
+        contract = _validation_preflight_contract(arguments, profiles)
+    except HarnessError as error:
+        raise HarnessError(
+            "pre-profile lane validation failed before timing: " + str(error)
+        ) from error
+    if contract["passes"] is not True:
+        semantic = contract["semantic_contract"]
+        assert isinstance(semantic, Mapping)
+        raw_errors = semantic.get("errors")
+        errors = (
+            [str(error) for error in raw_errors] if isinstance(raw_errors, list) else []
+        )
+        detail = "; ".join(errors) or "deterministic numerical comparison failed"
+        raise HarnessError(
+            "pre-profile lane validation failed before timing: " + detail
+        )
+    return contract
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def _content_addressed_record(payload: Mapping[str, object]) -> dict[str, object]:
+    result = dict(payload)
+    result["content_sha256"] = _canonical_sha256(result)
+    return result
+
+
+def _read_content_addressed_record(path: Path, *, label: str) -> dict[str, object]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise HarnessError(f"{label} is not readable canonical JSON: {path}") from error
+    if not isinstance(payload, dict):
+        raise HarnessError(f"{label} is not a JSON object: {path}")
+    unsigned = dict(payload)
+    digest = unsigned.pop("content_sha256", None)
+    if (
+        not isinstance(digest, str)
+        or _SHA256_PATTERN.fullmatch(digest) is None
+        or digest != _canonical_sha256(unsigned)
+    ):
+        raise HarnessError(f"{label} is not content-addressed: {path}")
+    return payload
+
+
+def _paired_coordination_role_directory(arguments: argparse.Namespace) -> Path | None:
+    root = arguments.paired_profile_coordination_dir
+    if root is None:
+        return None
+    return (
+        root.resolve()
+        / arguments.paired_profile_session_id
+        / arguments.lc_flow_layout
+        / arguments.paired_profile_role
+    )
+
+
+def _paired_schedule_plan(
+    profile_schedule: Mapping[str, object],
+) -> list[dict[str, object]]:
+    raw_entries = profile_schedule.get("entries")
+    if not isinstance(raw_entries, list):
+        raise HarnessError("paired profile coordination requires a planned schedule")
+    result: list[dict[str, object]] = []
+    for index, raw in enumerate(raw_entries):
+        if not isinstance(raw, Mapping):
+            raise HarnessError(f"paired profile schedule entry {index} is invalid")
+        result.append(
+            {
+                field: raw.get(field)
+                for field in ("schedule_index", "round", "mode", "batch_size")
+            }
+        )
+    return result
+
+
+def _initialize_paired_profile_coordination(
+    arguments: argparse.Namespace,
+    *,
+    source_identity: Mapping[str, object],
+    runtime_provenance: Mapping[str, object],
+    profile_schedule: Mapping[str, object],
+    result_json: Path,
+) -> dict[str, object] | None:
+    role_directory = _paired_coordination_role_directory(arguments)
+    if role_directory is None:
+        return None
+    role_directory.mkdir(parents=True, exist_ok=True)
+    plan = _paired_schedule_plan(profile_schedule)
+    ready = _content_addressed_record(
+        {
+            "kind": PAIRED_PROFILE_READY_KIND,
+            "schema_version": PAIRED_PROFILE_COORDINATION_SCHEMA,
+            "session_id": arguments.paired_profile_session_id,
+            "role": arguments.paired_profile_role,
+            "layout": arguments.lc_flow_layout,
+            "source_revision": source_identity.get("revision"),
+            "source_identity_sha256": _canonical_sha256(source_identity),
+            "runtime_provenance_sha256": _canonical_sha256(runtime_provenance),
+            "profile_schedule_plan": plan,
+            "profile_schedule_plan_sha256": _canonical_sha256(plan),
+            "result_json": str(result_json),
+            "ready_at_utc": _utc_now(),
+        }
+    )
+    ready_path = role_directory / "ready.json"
+    if ready_path.exists():
+        raise HarnessError(
+            "paired profile coordination ready record already exists; "
+            "use a fresh session directory"
+        )
+    _write_json_atomic(ready_path, ready)
+    return {
+        "kind": PAIRED_PROFILE_COORDINATION_KIND,
+        "schema_version": PAIRED_PROFILE_COORDINATION_SCHEMA,
+        "session_id": arguments.paired_profile_session_id,
+        "role": arguments.paired_profile_role,
+        "layout": arguments.lc_flow_layout,
+        "ready_record": ready,
+        "completion_records": [],
+    }
+
+
+def _wait_for_paired_profile_token(
+    arguments: argparse.Namespace,
+    schedule_entry: Mapping[str, object],
+) -> dict[str, object] | None:
+    role_directory = _paired_coordination_role_directory(arguments)
+    if role_directory is None:
+        return None
+    schedule_index = schedule_entry.get("schedule_index")
+    if isinstance(schedule_index, bool) or not isinstance(schedule_index, int):
+        raise HarnessError("paired profile schedule index is invalid")
+    path = role_directory / f"token-{schedule_index:06d}.json"
+    deadline = time.monotonic() + arguments.paired_profile_wait_timeout
+    while not path.is_file():
+        if time.monotonic() >= deadline:
+            raise HarnessError(f"timed out waiting for paired profile token: {path}")
+        time.sleep(0.1)
+    token = _read_content_addressed_record(path, label="paired profile token")
+    expected = {
+        "kind": PAIRED_PROFILE_TOKEN_KIND,
+        "schema_version": PAIRED_PROFILE_COORDINATION_SCHEMA,
+        "session_id": arguments.paired_profile_session_id,
+        "role": arguments.paired_profile_role,
+        "layout": arguments.lc_flow_layout,
+        **{
+            field: schedule_entry.get(field)
+            for field in ("schedule_index", "round", "mode", "batch_size")
+        },
+    }
+    if any(token.get(field) != value for field, value in expected.items()):
+        raise HarnessError(f"paired profile token does not match its slot: {path}")
+    if not _is_utc_timestamp(token.get("issued_at_utc")):
+        raise HarnessError(f"paired profile token has no valid timestamp: {path}")
+    return token
+
+
+def _record_paired_profile_completion(
+    arguments: argparse.Namespace,
+    *,
+    schedule_entry: Mapping[str, object],
+    token: Mapping[str, object] | None,
+    worker_result: Mapping[str, object],
+) -> dict[str, object] | None:
+    role_directory = _paired_coordination_role_directory(arguments)
+    if role_directory is None:
+        return None
+    if token is None:
+        raise HarnessError("paired profile completion has no scheduler token")
+    invocation = worker_result.get("worker_invocation")
+    result_record = worker_result.get("worker_result_record")
+    if not isinstance(invocation, Mapping) or not isinstance(result_record, Mapping):
+        raise HarnessError("paired profile completion lacks worker provenance")
+    schedule_index = schedule_entry.get("schedule_index")
+    assert isinstance(schedule_index, int)
+    completion = _content_addressed_record(
+        {
+            "kind": PAIRED_PROFILE_COMPLETION_KIND,
+            "schema_version": PAIRED_PROFILE_COORDINATION_SCHEMA,
+            "session_id": arguments.paired_profile_session_id,
+            "role": arguments.paired_profile_role,
+            "layout": arguments.lc_flow_layout,
+            **{
+                field: schedule_entry.get(field)
+                for field in ("schedule_index", "round", "mode", "batch_size")
+            },
+            "token_sha256": token.get("content_sha256"),
+            "worker_invocation_sha256": invocation.get("content_sha256"),
+            "worker_result_record_sha256": result_record.get("content_sha256"),
+            "worker_started_at_utc": invocation.get("started_at_utc"),
+            "worker_finished_at_utc": invocation.get("finished_at_utc"),
+            "recorded_at_utc": _utc_now(),
+        }
+    )
+    path = role_directory / f"completion-{schedule_index:06d}.json"
+    if path.exists():
+        raise HarnessError(f"paired profile completion already exists: {path}")
+    _write_json_atomic(path, completion)
+    return completion
+
+
+def _build_profile_schedule(
+    modes: Sequence[str],
+    batch_sizes: Sequence[int],
+    *,
+    subprocess_samples: int,
+) -> dict[str, object]:
+    if subprocess_samples <= 0 or not modes or not batch_sizes:
+        raise HarnessError("profile schedule dimensions must be non-empty")
+    entries: list[dict[str, object]] = []
+    schedule_index = 0
+    for round_index in range(subprocess_samples):
+        rotated_modes = tuple(modes[round_index % len(modes) :]) + tuple(
+            modes[: round_index % len(modes)]
+        )
+        rotated_batches = tuple(batch_sizes[round_index % len(batch_sizes) :]) + tuple(
+            batch_sizes[: round_index % len(batch_sizes)]
+        )
+        for batch_size in rotated_batches:
+            for mode in rotated_modes:
+                entries.append(
+                    {
+                        "schedule_index": schedule_index,
+                        "round": round_index,
+                        "mode": mode,
+                        "batch_size": batch_size,
+                    }
+                )
+                schedule_index += 1
+    return {
+        "kind": PROFILE_SCHEDULE_KIND,
+        "schema_version": PROFILE_SCHEDULE_SCHEMA,
+        "algorithm": "round-major-cyclic-mode-and-batch-interleave-v1",
+        "sample_unit": "independent-profile-worker-subprocess",
+        "subprocess_samples_per_cell": subprocess_samples,
+        "modes": list(modes),
+        "batch_sizes": list(batch_sizes),
+        "entries": entries,
+    }
+
+
+def _profile_schedule_contract(
+    schedule: Mapping[str, object] | None,
+    *,
+    modes: Sequence[str],
+    batch_sizes: Sequence[int],
+    subprocess_samples: int,
+) -> dict[str, object]:
+    errors: list[str] = []
+    if not isinstance(schedule, Mapping):
+        return {
+            "passes": False,
+            "errors": ["interleaved subprocess schedule is missing"],
+        }
+    expected = _build_profile_schedule(
+        modes,
+        batch_sizes,
+        subprocess_samples=subprocess_samples,
+    )
+    for key in (
+        "kind",
+        "algorithm",
+        "sample_unit",
+    ):
+        if schedule.get(key) != expected[key]:
+            errors.append(f"profile schedule {key} does not match its contract")
+    for key in ("modes", "batch_sizes"):
+        if _canonical_sha256(schedule.get(key)) != _canonical_sha256(expected[key]):
+            errors.append(f"profile schedule {key} does not match its contract")
+    if not _is_exact_int(
+        schedule.get("schema_version"),
+        PROFILE_SCHEDULE_SCHEMA,
+    ):
+        errors.append("profile schedule schema_version does not match its contract")
+    if not _is_exact_int(
+        schedule.get("subprocess_samples_per_cell"),
+        subprocess_samples,
+    ):
+        errors.append(
+            "profile schedule subprocess_samples_per_cell does not match its contract"
+        )
+    raw_entries = schedule.get("entries")
+    expected_entries = expected["entries"]
+    assert isinstance(expected_entries, list)
+    if not isinstance(raw_entries, list):
+        raw_entries = []
+        errors.append("profile schedule entries are missing")
+    if len(raw_entries) != len(expected_entries):
+        errors.append("profile schedule entry count is incomplete")
+    command_digests: list[str] = []
+    cells: dict[tuple[str, int], int] = {}
+    for index, (raw, planned) in enumerate(
+        zip(raw_entries, expected_entries, strict=False)
+    ):
+        if not isinstance(raw, Mapping):
+            errors.append(f"profile schedule entry {index} is invalid")
+            continue
+        schedule_index = raw.get("schedule_index")
+        round_index = raw.get("round")
+        mode = raw.get("mode")
+        batch_size = raw.get("batch_size")
+        if (
+            isinstance(schedule_index, bool)
+            or not isinstance(schedule_index, int)
+            or schedule_index < 0
+            or isinstance(round_index, bool)
+            or not isinstance(round_index, int)
+            or round_index < 0
+            or not isinstance(mode, str)
+            or not mode
+            or isinstance(batch_size, bool)
+            or not isinstance(batch_size, int)
+            or batch_size <= 0
+        ):
+            errors.append(
+                f"profile schedule entry {index} has invalid slot coordinates"
+            )
+        for field in ("schedule_index", "round", "mode", "batch_size"):
+            if raw.get(field) != planned[field]:
+                errors.append(f"profile schedule entry {index} changed planned {field}")
+        if (
+            isinstance(mode, str)
+            and mode
+            and not isinstance(batch_size, bool)
+            and isinstance(batch_size, int)
+            and batch_size > 0
+        ):
+            cell = (mode, batch_size)
+            cells[cell] = cells.get(cell, 0) + 1
+        invocation = raw.get("worker_invocation")
+        if not isinstance(invocation, Mapping):
+            errors.append(f"profile schedule entry {index} has no worker provenance")
+            continue
+        try:
+            command = _validated_command_identity(invocation.get("command"))
+        except HarnessError:
+            errors.append(f"profile schedule entry {index} command is invalid")
+            continue
+        command_digests.append(str(command["argv_sha256"]))
+        for timestamp_field in ("started_at_utc", "finished_at_utc"):
+            timestamp = invocation.get(timestamp_field)
+            if not _is_utc_timestamp(timestamp):
+                errors.append(
+                    f"profile schedule entry {index} has invalid {timestamp_field}"
+                )
+        if not _utc_timestamps_nondecreasing(
+            invocation.get("started_at_utc"),
+            invocation.get("finished_at_utc"),
+        ):
+            errors.append(
+                f"profile schedule entry {index} has inverted invocation timestamps"
+            )
+        wall_seconds = invocation.get("wall_seconds")
+        if (
+            isinstance(wall_seconds, bool)
+            or not isinstance(wall_seconds, (float, int))
+            or not math.isfinite(float(wall_seconds))
+            or float(wall_seconds) <= 0.0
+        ):
+            errors.append(
+                f"profile schedule entry {index} has invalid worker wall time"
+            )
+        invocation_without_digest = dict(invocation)
+        invocation_digest = invocation_without_digest.pop("content_sha256", None)
+        if invocation_digest != _canonical_sha256(invocation_without_digest):
+            errors.append(
+                f"profile schedule entry {index} invocation is not content-addressed"
+            )
+        verification = raw.get("pre_timing_verification")
+        if (
+            not isinstance(verification, Mapping)
+            or verification.get("kind") != WORKER_VERIFICATION_KIND
+            or not _is_exact_int(
+                verification.get("schema_version"),
+                WORKER_VERIFICATION_SCHEMA,
+            )
+            or not _is_utc_timestamp(verification.get("verified_at_utc"))
+        ):
+            errors.append(
+                f"profile schedule entry {index} lacks pre-timing verification"
+            )
+        else:
+            expected_identities = verification.get("expected")
+            observed_identities = verification.get("observed")
+            effective_contract = verification.get("effective_contract")
+            if not isinstance(expected_identities, Mapping) or not isinstance(
+                observed_identities,
+                Mapping,
+            ):
+                errors.append(
+                    f"profile schedule entry {index} identity verification is invalid"
+                )
+            else:
+                try:
+                    _validate_profile_worker_expectations(
+                        expected_identities,
+                        observed_identities,
+                    )
+                    _validate_loaded_runtime_artifact_verification(
+                        verification.get("loaded_runtime_artifact"),
+                        expected_artifact_id=expected_identities.get("artifact_id"),
+                        phase="after-native-load-before-timing",
+                    )
+                except HarnessError:
+                    errors.append(
+                        f"profile schedule entry {index} contains identity drift"
+                    )
+                semantic_identity_sha256 = verification.get(
+                    "artifact_semantic_identity_sha256"
+                )
+                if (
+                    not isinstance(semantic_identity_sha256, str)
+                    or _SHA256_PATTERN.fullmatch(semantic_identity_sha256) is None
+                    or expected_identities.get("artifact_semantic_identity_sha256")
+                    != semantic_identity_sha256
+                    or observed_identities.get("artifact_semantic_identity_sha256")
+                    != semantic_identity_sha256
+                ):
+                    errors.append(
+                        f"profile schedule entry {index} artifact semantic "
+                        "identity is not bound to verification"
+                    )
+            if (
+                not isinstance(effective_contract, Mapping)
+                or effective_contract.get("execution_mode") != mode
+                or effective_contract.get("backend") != "jit"
+                or effective_contract.get("color_accuracy") != "lc"
+            ):
+                errors.append(
+                    f"profile schedule entry {index} effective contract is invalid"
+                )
+        result_digest = raw.get("worker_result_sha256")
+        result_record = raw.get("worker_result_record")
+        if (
+            not isinstance(result_digest, str)
+            or _SHA256_PATTERN.fullmatch(result_digest) is None
+        ):
+            errors.append(
+                f"profile schedule entry {index} lacks a worker-result digest"
+            )
+        if not isinstance(result_record, Mapping):
+            errors.append(
+                f"profile schedule entry {index} lacks a worker-result record"
+            )
+        else:
+            record_without_digest = dict(result_record)
+            record_digest = record_without_digest.pop("content_sha256", None)
+            recorded_at = result_record.get("recorded_at_utc")
+            if (
+                record_digest != _canonical_sha256(record_without_digest)
+                or result_record.get("kind") != RETAINED_WORKER_RESULT_KIND
+                or not _is_exact_int(
+                    result_record.get("schema_version"),
+                    RETAINED_WORKER_RESULT_SCHEMA,
+                )
+                or not _is_utc_timestamp(recorded_at)
+                or not _utc_timestamps_nondecreasing(
+                    invocation.get("finished_at_utc"),
+                    recorded_at,
+                )
+                or any(
+                    _SHA256_PATTERN.fullmatch(value) is None
+                    for value in (
+                        result_record.get("addressed_payload_sha256"),
+                        result_record.get("upstream_worker_result_record_sha256"),
+                        result_record.get("worker_process_record_sha256"),
+                        result_record.get("worker_invocation_sha256"),
+                    )
+                    if isinstance(value, str)
+                )
+                or not all(
+                    isinstance(result_record.get(field), str)
+                    for field in (
+                        "addressed_payload_sha256",
+                        "upstream_worker_result_record_sha256",
+                        "worker_process_record_sha256",
+                        "worker_invocation_sha256",
+                    )
+                )
+                or result_record.get("worker_invocation_sha256") != invocation_digest
+                or result_record.get("addressed_payload_sha256") != result_digest
+            ):
+                errors.append(
+                    f"profile schedule entry {index} result record is not "
+                    "content-addressed"
+                )
+    if len(command_digests) != len(set(command_digests)):
+        errors.append("profile schedule reused a subprocess command identity")
+    for mode in modes:
+        for batch_size in batch_sizes:
+            if cells.get((mode, batch_size), 0) != subprocess_samples:
+                errors.append(
+                    f"profile schedule cell {mode}/{batch_size} has the wrong "
+                    "subprocess sample count"
+                )
+    if len(modes) > 1:
+        observed_modes = [
+            entry.get("mode") for entry in raw_entries if isinstance(entry, Mapping)
+        ]
+        if any(left == right for left, right in pairwise(observed_modes)):
+            errors.append("profile subprocess lanes are not interleaved")
+    return {
+        "passes": not errors,
+        "errors": errors,
+        "entry_count": len(raw_entries),
+        "unique_worker_command_count": len(set(command_digests)),
+        "subprocess_samples_per_cell": subprocess_samples,
+    }
+
+
+def _compact_profile_verification(
+    verification: Mapping[str, object],
+) -> dict[str, object]:
+    return {
+        "kind": verification.get("kind"),
+        "schema_version": verification.get("schema_version"),
+        "verified_at_utc": verification.get("verified_at_utc"),
+        "expected": verification.get("expected"),
+        "observed": verification.get("observed"),
+        "artifact_semantic_identity_sha256": verification.get(
+            "artifact_semantic_identity_sha256"
+        ),
+        "effective_contract": verification.get("effective_contract"),
+        "loaded_runtime_artifact": verification.get("loaded_runtime_artifact"),
+    }
+
+
+def _retained_profile_sample_evidence(
+    sample: Mapping[str, object],
+) -> dict[str, object]:
+    return {
+        str(key): value
+        for key, value in sample.items()
+        if key != "worker_result_record"
+    }
+
+
+def _preserved_worker_result_evidence(
+    result: Mapping[str, object],
+) -> dict[str, object]:
+    result_record = result.get("worker_result_record")
+    process_record = result.get("worker_process_record")
+    invocation = result.get("worker_invocation")
+    payload = {
+        str(key): value
+        for key, value in result.items()
+        if key != "worker_result_record"
+    }
+    operation_payload = {
+        key: value
+        for key, value in payload.items()
+        if key
+        not in {
+            "worker_process_record",
+            "worker_command",
+            "worker_invocation",
+        }
+    }
+    if (
+        not isinstance(result_record, Mapping)
+        or not isinstance(process_record, Mapping)
+        or not isinstance(invocation, Mapping)
+    ):
+        raise HarnessError("worker result cannot be preserved without provenance")
+    result_record_without_digest = dict(result_record)
+    result_record_sha256 = result_record_without_digest.pop("content_sha256", None)
+    process_record_without_digest = dict(process_record)
+    process_record_sha256 = process_record_without_digest.pop("content_sha256", None)
+    invocation_without_digest = dict(invocation)
+    invocation_sha256 = invocation_without_digest.pop("content_sha256", None)
+    process_wall_seconds = process_record.get("wall_seconds")
+    process_id = process_record.get("process_id")
+    invocation_wall_seconds = invocation.get("wall_seconds")
+    try:
+        worker_command = _validated_command_identity(payload.get("worker_command"))
+        invocation_command = _validated_command_identity(invocation.get("command"))
+    except HarnessError as error:
+        raise HarnessError(
+            "worker result evidence has invalid command provenance"
+        ) from error
+    if (
+        set(process_record)
+        != {
+            "started_at_utc",
+            "finished_at_utc",
+            "wall_seconds",
+            "process_id",
+            "operation",
+            "mode",
+            "payload_sha256",
+            "content_sha256",
+        }
+        or set(invocation)
+        != {
+            "started_at_utc",
+            "finished_at_utc",
+            "wall_seconds",
+            "command",
+            "content_sha256",
+        }
+        or set(result_record)
+        != {
+            "recorded_at_utc",
+            "addressed_payload_sha256",
+            "worker_process_record_sha256",
+            "worker_invocation_sha256",
+            "content_sha256",
+        }
+        or result_record_sha256 != _canonical_sha256(result_record_without_digest)
+        or process_record_sha256 != _canonical_sha256(process_record_without_digest)
+        or invocation_sha256 != _canonical_sha256(invocation_without_digest)
+        or process_record.get("payload_sha256") != _canonical_sha256(operation_payload)
+        or process_record.get("operation") not in {"generate", "profile"}
+        or process_record.get("mode") not in EXECUTION_MODES
+        or process_record.get("mode") != operation_payload.get("mode")
+        or isinstance(process_wall_seconds, bool)
+        or not isinstance(process_wall_seconds, (float, int))
+        or not math.isfinite(float(process_wall_seconds))
+        or float(process_wall_seconds) <= 0.0
+        or isinstance(process_id, bool)
+        or not isinstance(process_id, int)
+        or process_id <= 0
+        or isinstance(invocation_wall_seconds, bool)
+        or not isinstance(invocation_wall_seconds, (float, int))
+        or not math.isfinite(float(invocation_wall_seconds))
+        or float(invocation_wall_seconds) <= 0.0
+        or worker_command != invocation_command
+        or result_record.get("addressed_payload_sha256") != _canonical_sha256(payload)
+        or result_record.get("worker_process_record_sha256") != process_record_sha256
+        or result_record.get("worker_invocation_sha256") != invocation_sha256
+        or not _utc_timestamps_nondecreasing(
+            invocation.get("started_at_utc"),
+            process_record.get("started_at_utc"),
+            process_record.get("finished_at_utc"),
+            invocation.get("finished_at_utc"),
+            result_record.get("recorded_at_utc"),
+        )
+    ):
+        raise HarnessError("worker result evidence failed its content-address contract")
+    evidence = {
+        "kind": PRESERVED_WORKER_RESULT_KIND,
+        "schema_version": PRESERVED_WORKER_RESULT_SCHEMA,
+        "payload": payload,
+        "worker_result_record": dict(result_record),
+    }
+    evidence["content_sha256"] = _canonical_sha256(evidence)
+    return evidence
+
+
+def _retained_profile_worker_result_record(
+    sample: Mapping[str, object],
+    *,
+    upstream_result_record: Mapping[str, object],
+) -> dict[str, object]:
+    invocation = sample.get("worker_invocation")
+    process_record = sample.get("worker_process_record")
+    if not isinstance(invocation, Mapping) or not isinstance(
+        process_record,
+        Mapping,
+    ):
+        raise HarnessError("retained profile sample has incomplete worker provenance")
+    invocation_sha256 = _required_sha256(
+        invocation.get("content_sha256"),
+        label="retained worker invocation",
+    )
+    process_record_sha256 = _required_sha256(
+        process_record.get("content_sha256"),
+        label="retained worker process record",
+    )
+    upstream_sha256 = _required_sha256(
+        upstream_result_record.get("content_sha256"),
+        label="upstream worker result record",
+    )
+    recorded_at = upstream_result_record.get("recorded_at_utc")
+    if not _is_utc_timestamp(recorded_at):
+        raise HarnessError("upstream worker result record has an invalid timestamp")
+    if not _utc_timestamps_nondecreasing(
+        invocation.get("started_at_utc"),
+        process_record.get("started_at_utc"),
+        process_record.get("finished_at_utc"),
+        invocation.get("finished_at_utc"),
+        recorded_at,
+    ):
+        raise HarnessError("retained profile worker timestamps are not chronological")
+    record = {
+        "kind": RETAINED_WORKER_RESULT_KIND,
+        "schema_version": RETAINED_WORKER_RESULT_SCHEMA,
+        "recorded_at_utc": recorded_at,
+        "addressed_payload_sha256": _canonical_sha256(
+            _retained_profile_sample_evidence(sample)
+        ),
+        "upstream_worker_result_record_sha256": upstream_sha256,
+        "worker_process_record_sha256": process_record_sha256,
+        "worker_invocation_sha256": invocation_sha256,
+    }
+    record["content_sha256"] = _canonical_sha256(record)
+    return record
+
+
+def _aggregate_profile_workers(
+    schedule: Mapping[str, object],
+    worker_results: Sequence[Mapping[str, Any]],
+) -> dict[str, dict[str, Any]]:
+    raw_entries = schedule.get("entries")
+    if not isinstance(raw_entries, list) or len(raw_entries) != len(worker_results):
+        raise HarnessError("cannot aggregate an incomplete profile worker schedule")
+    lane_contracts: dict[str, dict[str, object]] = {}
+    lane_samples: dict[str, dict[int, list[dict[str, object]]]] = {}
+    for raw_entry, worker in zip(raw_entries, worker_results, strict=True):
+        if not isinstance(raw_entry, Mapping):
+            raise HarnessError("profile schedule contains an invalid entry")
+        mode = raw_entry.get("mode")
+        batch_size = raw_entry.get("batch_size")
+        schedule_index = raw_entry.get("schedule_index")
+        round_index = raw_entry.get("round")
+        if (
+            not isinstance(mode, str)
+            or isinstance(batch_size, bool)
+            or not isinstance(batch_size, int)
+            or isinstance(schedule_index, bool)
+            or not isinstance(schedule_index, int)
+            or isinstance(round_index, bool)
+            or not isinstance(round_index, int)
+            or worker.get("mode") != mode
+            or worker.get("schedule_index") != schedule_index
+            or worker.get("schedule_round") != round_index
+        ):
+            raise HarnessError("profile worker result does not match its schedule slot")
+        measurements = worker.get("profiles")
+        if not isinstance(measurements, list) or len(measurements) != 1:
+            raise HarnessError(
+                "profile worker must return exactly one batch measurement"
+            )
+        measurement = measurements[0]
+        if (
+            not isinstance(measurement, Mapping)
+            or measurement.get("batch_size") != batch_size
+        ):
+            raise HarnessError("profile worker returned the wrong batch measurement")
+        verification = worker.get("pre_timing_verification")
+        if not isinstance(verification, Mapping):
+            raise HarnessError("profile worker returned no pre-timing verification")
+        semantic_identity = verification.get("artifact_semantic_identity")
+        if not isinstance(semantic_identity, Mapping):
+            raise HarnessError("profile worker returned no artifact semantic identity")
+        semantic_identity_sha256 = verification.get("artifact_semantic_identity_sha256")
+        if semantic_identity_sha256 != _canonical_sha256(semantic_identity):
+            raise HarnessError(
+                "profile worker artifact semantic identity is not content-addressed"
+            )
+        contract = {
+            "process_id": worker.get("process_id"),
+            "process_expression": worker.get("process_expression"),
+            "selector_contract": worker.get("selector_contract"),
+            "validation": worker.get("validation"),
+            "artifact_semantic_identity": dict(semantic_identity),
+            "artifact_semantic_identity_sha256": semantic_identity_sha256,
+        }
+        existing_contract = lane_contracts.setdefault(mode, contract)
+        _assert_identity_unchanged(
+            f"{mode} repeated profile semantic contract",
+            existing_contract,
+            contract,
+        )
+        worker_process_record = worker.get("worker_process_record")
+        upstream_result_record = worker.get("worker_result_record")
+        if not isinstance(worker_process_record, Mapping) or not isinstance(
+            upstream_result_record,
+            Mapping,
+        ):
+            raise HarnessError("profile worker returned incomplete result provenance")
+        sample = {
+            "schedule_index": schedule_index,
+            "round": round_index,
+            "worker_command": worker.get("worker_command"),
+            "worker_invocation": worker.get("worker_invocation"),
+            "worker_process_record": dict(worker_process_record),
+            "peak_rss_after_cold_load": worker.get("peak_rss_after_cold_load"),
+            "peak_rss_after_profile": worker.get("peak_rss_after_profile"),
+            "pre_timing_verification": _compact_profile_verification(verification),
+            "post_timing_loaded_runtime_artifact": worker.get(
+                "post_timing_loaded_runtime_artifact"
+            ),
+            "cold_load_seconds": worker.get("cold_load_seconds"),
+            "lane_contract_sha256": _canonical_sha256(contract),
+            "timing_configuration": worker.get("timing_configuration"),
+            "worker_measurement": dict(measurement),
+            "internal_sample_count": measurement.get("sample_count"),
+            "repetitions_per_sample": measurement.get("repetitions_per_sample"),
+            "evaluation_count": measurement.get("evaluation_count"),
+            "evaluated_point_count": measurement.get("evaluated_point_count"),
+            "wall_seconds_per_point": measurement.get("wall_seconds_per_point"),
+            "inner_native_wall_blocks": measurement.get("inner_native_wall_blocks"),
+            "timing_sources": measurement.get("timing_sources"),
+            "environment": measurement.get("environment"),
+            "interrupted": measurement.get("interrupted"),
+        }
+        retained_result_record = _retained_profile_worker_result_record(
+            sample,
+            upstream_result_record=upstream_result_record,
+        )
+        sample["worker_result_record"] = retained_result_record
+        if not isinstance(raw_entry, dict):
+            raise HarnessError("profile schedule entry cannot retain worker provenance")
+        raw_entry["worker_result_record"] = dict(retained_result_record)
+        raw_entry["worker_result_sha256"] = retained_result_record[
+            "addressed_payload_sha256"
+        ]
+        lane_samples.setdefault(mode, {}).setdefault(batch_size, []).append(sample)
+    profiles: dict[str, dict[str, Any]] = {}
+    for mode, contract in lane_contracts.items():
+        aggregated_measurements: list[dict[str, object]] = []
+        for batch_size, samples in sorted(lane_samples[mode].items()):
+            values: list[float] = []
+            cold_load_values: list[float] = []
+            cold_load_rss_values: list[int] = []
+            profiled_rss_values: list[int] = []
+            for sample in samples:
+                value = sample.get("wall_seconds_per_point")
+                if (
+                    isinstance(value, bool)
+                    or not isinstance(value, (float, int))
+                    or not math.isfinite(float(value))
+                    or float(value) <= 0.0
+                ):
+                    raise HarnessError(
+                        f"{mode}/{batch_size} worker returned invalid wall timing"
+                    )
+                values.append(float(value))
+                cold_load = sample.get("cold_load_seconds")
+                peak_after_load = sample.get("peak_rss_after_cold_load")
+                peak_after_profile = sample.get("peak_rss_after_profile")
+                if (
+                    isinstance(cold_load, bool)
+                    or not isinstance(cold_load, (float, int))
+                    or not math.isfinite(float(cold_load))
+                    or float(cold_load) <= 0.0
+                    or not _valid_resource_peak(peak_after_load)
+                    or not _valid_resource_peak(peak_after_profile)
+                ):
+                    raise HarnessError(
+                        f"{mode}/{batch_size} worker returned invalid cold-load "
+                        "resource evidence"
+                    )
+                assert isinstance(peak_after_load, Mapping)
+                assert isinstance(peak_after_profile, Mapping)
+                cold_load_values.append(float(cold_load))
+                cold_load_rss_values.append(
+                    int(peak_after_load["observed_lower_bound_bytes"])
+                )
+                profiled_rss_values.append(
+                    int(peak_after_profile["observed_lower_bound_bytes"])
+                )
+            median = statistics.median(values)
+            mad = statistics.median(abs(value - median) for value in values)
+            cold_load_median = statistics.median(cold_load_values)
+            cold_load_mad = statistics.median(
+                abs(value - cold_load_median) for value in cold_load_values
+            )
+            aggregated_measurements.append(
+                {
+                    "batch_size": batch_size,
+                    "sample_count": len(samples),
+                    "subprocess_sample_count": len(samples),
+                    "wall_seconds_per_point": median,
+                    "wall_seconds_per_point_median": median,
+                    "wall_seconds_per_point_mad": mad,
+                    "statistics_contract": "subprocess-median-and-raw-mad-v1",
+                    "cold_load_seconds_median": cold_load_median,
+                    "cold_load_seconds_mad": cold_load_mad,
+                    "cold_load_peak_rss_bytes_median": statistics.median(
+                        cold_load_rss_values
+                    ),
+                    "profiled_peak_rss_bytes_median": statistics.median(
+                        profiled_rss_values
+                    ),
+                    "resource_statistics_contract": (
+                        "subprocess-median-and-raw-mad-v1"
+                    ),
+                    "subprocess_samples": samples,
+                    "interrupted": any(
+                        sample.get("interrupted") is not False for sample in samples
+                    ),
+                }
+            )
+        profiles[mode] = {
+            "mode": mode,
+            **contract,
+            "profiles": aggregated_measurements,
+        }
+    return profiles
+
+
+def _profile_measurement_contract(
+    arguments: argparse.Namespace,
+    profiles: Mapping[str, Mapping[str, Any]],
+    *,
+    profile_schedule: Mapping[str, object] | None,
+    required_modes: Sequence[str] | None = None,
+) -> dict[str, object]:
+    selected_modes = tuple(
+        arguments.modes if required_modes is None else required_modes
+    )
+    lanes: dict[str, dict[str, object]] = {}
+    root_process_contracts = [
+        (
+            profile.get("process_id"),
+            (
+                " ".join(process_expression.split()).casefold()
+                if isinstance(
+                    (process_expression := profile.get("process_expression")),
+                    str,
+                )
+                else None
+            ),
+        )
+        for mode in selected_modes
+        if (profile := profiles.get(mode)) is not None
+    ]
+    root_processes_match = bool(root_process_contracts) and all(
+        contract == root_process_contracts[0] for contract in root_process_contracts[1:]
+    )
+    schedule_contract = _profile_schedule_contract(
+        profile_schedule,
+        modes=arguments.modes,
+        batch_sizes=arguments.batch_size,
+        subprocess_samples=arguments.subprocess_samples,
+    )
+    raw_schedule_entries = (
+        profile_schedule.get("entries")
+        if isinstance(profile_schedule, Mapping)
+        else None
+    )
+    scheduled_entries = (
+        {
+            entry["schedule_index"]: entry
+            for entry in raw_schedule_entries
+            if isinstance(entry, Mapping)
+            and isinstance(entry.get("schedule_index"), int)
+        }
+        if isinstance(raw_schedule_entries, list)
+        else {}
+    )
+    passes = (
+        schedule_contract["passes"] is True
+        and arguments.subprocess_samples >= MIN_AUTHORITATIVE_SAMPLES
+        and arguments.minimum_samples >= MIN_AUTHORITATIVE_SAMPLES
+        and arguments.warmup_runs >= 2
+        and arguments.target_runtime >= 5.0
+    )
+    for mode in selected_modes:
+        profile = profiles.get(mode)
+        if profile is None:
+            lanes[mode] = {
+                "passes": False,
+                "observed_batch_sizes": [],
+                "missing_batch_sizes": list(DEFAULT_BATCH_SIZES),
+                "errors": ["profile lane is missing"],
+            }
+            passes = False
+            continue
+        raw_measurements = profile.get("profiles")
+        errors: list[str] = []
+        observed: list[int] = []
+        if profile.get("mode") != mode:
+            errors.append("profile lane mode does not match its inventory key")
+        process_id = profile.get("process_id")
+        process_expression = profile.get("process_expression")
+        semantic_identity = profile.get("artifact_semantic_identity")
+        execution_ordering = (
+            semantic_identity.get("execution_schedule_ordering")
+            if isinstance(semantic_identity, Mapping)
+            else None
+        )
+        runtime_process_contract = (
+            execution_ordering.get("runtime_process_contract")
+            if isinstance(execution_ordering, Mapping)
+            else None
+        )
+        expected_process = " ".join(_selected_process(arguments).split()).casefold()
+        if (
+            not root_processes_match
+            or not isinstance(process_id, str)
+            or not process_id
+            or not isinstance(process_expression, str)
+            or " ".join(process_expression.split()).casefold() != expected_process
+            or not isinstance(runtime_process_contract, Mapping)
+            or runtime_process_contract.get("id") != process_id
+        ):
+            errors.append(
+                "profile lane process identity is inconsistent with requested process"
+            )
+        if not _profile_selector_contract_matches(
+            arguments,
+            profile.get("selector_contract"),
+            semantic_identity,
+        ):
+            errors.append("profile lane selector workload contract is invalid")
+        validation = profile.get("validation")
+        fixture_contract = (
+            _validation_fixture_contract(validation, mode=mode)
+            if isinstance(validation, Mapping)
+            else None
+        )
+        expected_fixture_sha256 = (
+            fixture_contract.get("points_sha256")
+            if isinstance(fixture_contract, Mapping)
+            else None
+        )
+        profile_semantic_sha256 = profile.get("artifact_semantic_identity_sha256")
+        lane_contract_payload = {
+            field: profile.get(field)
+            for field in (
+                "process_id",
+                "process_expression",
+                "selector_contract",
+                "validation",
+                "artifact_semantic_identity",
+                "artifact_semantic_identity_sha256",
+            )
+        }
+        expected_lane_contract_sha256 = _canonical_sha256(lane_contract_payload)
+        if not isinstance(expected_fixture_sha256, str):
+            errors.append("profile has no shared validation fixture identity")
+        if (
+            not isinstance(profile_semantic_sha256, str)
+            or _SHA256_PATTERN.fullmatch(profile_semantic_sha256) is None
+        ):
+            errors.append("profile has no artifact semantic identity digest")
+        if not isinstance(raw_measurements, list):
+            errors.append("profile measurements are missing")
+            raw_measurements = []
+        for raw in raw_measurements:
+            if not isinstance(raw, Mapping):
+                errors.append("profile measurement is not an object")
+                continue
+            batch_size = raw.get("batch_size")
+            sample_count = raw.get("subprocess_sample_count")
+            headline_sample_count = raw.get("sample_count")
+            wall_seconds = raw.get("wall_seconds_per_point")
+            median = raw.get("wall_seconds_per_point_median")
+            mad = raw.get("wall_seconds_per_point_mad")
+            statistics_contract = raw.get("statistics_contract")
+            subprocess_samples = raw.get("subprocess_samples")
+            interrupted = raw.get("interrupted")
+            if (
+                isinstance(batch_size, bool)
+                or not isinstance(batch_size, int)
+                or batch_size <= 0
+            ):
+                errors.append("profile measurement has an invalid batch size")
+                continue
+            if batch_size in observed:
+                errors.append(f"profile batch {batch_size} is duplicated")
+                continue
+            observed.append(batch_size)
+            if (
+                isinstance(sample_count, bool)
+                or not isinstance(sample_count, int)
+                or sample_count < MIN_AUTHORITATIVE_SAMPLES
+                or sample_count != arguments.subprocess_samples
+                or not _is_exact_int(headline_sample_count, sample_count)
+            ):
+                errors.append(
+                    f"profile batch {batch_size} has too few independent subprocess "
+                    "samples"
+                )
+            if (
+                isinstance(wall_seconds, bool)
+                or not isinstance(wall_seconds, (float, int))
+                or not math.isfinite(float(wall_seconds))
+                or float(wall_seconds) <= 0.0
+            ):
+                errors.append(f"profile batch {batch_size} has an invalid wall time")
+            if (
+                isinstance(median, bool)
+                or not isinstance(median, (float, int))
+                or not math.isfinite(float(median))
+                or float(median) <= 0.0
+                or wall_seconds != median
+                or isinstance(mad, bool)
+                or not isinstance(mad, (float, int))
+                or not math.isfinite(float(mad))
+                or float(mad) < 0.0
+                or statistics_contract != "subprocess-median-and-raw-mad-v1"
+            ):
+                errors.append(
+                    f"profile batch {batch_size} lacks an explicit median/MAD"
+                )
+            if not isinstance(subprocess_samples, list):
+                errors.append(
+                    f"profile batch {batch_size} has no subprocess sample inventory"
+                )
+                subprocess_samples = []
+            if len(subprocess_samples) != sample_count:
+                errors.append(
+                    f"profile batch {batch_size} subprocess inventory is incomplete"
+                )
+            sample_values: list[float] = []
+            schedule_indices: list[int] = []
+            for sample_index, sample in enumerate(subprocess_samples):
+                if not isinstance(sample, Mapping):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} is invalid"
+                    )
+                    continue
+                internal_count = sample.get("internal_sample_count")
+                repetitions = sample.get("repetitions_per_sample")
+                evaluation_count = sample.get("evaluation_count")
+                evaluated_point_count = sample.get("evaluated_point_count")
+                sample_wall = sample.get("wall_seconds_per_point")
+                raw_blocks = sample.get("inner_native_wall_blocks")
+                worker_measurement = sample.get("worker_measurement")
+                worker_process_record = sample.get("worker_process_record")
+                worker_result_record = sample.get("worker_result_record")
+                sources = sample.get("timing_sources")
+                environment = sample.get("environment")
+                timing_configuration = sample.get("timing_configuration")
+                cold_load_seconds = sample.get("cold_load_seconds")
+                peak_rss_after_cold_load = sample.get("peak_rss_after_cold_load")
+                peak_rss_after_profile = sample.get("peak_rss_after_profile")
+                schedule_index = sample.get("schedule_index")
+                verification = sample.get("pre_timing_verification")
+                post_timing_loaded_artifact = sample.get(
+                    "post_timing_loaded_runtime_artifact"
+                )
+                sample_round = sample.get("round")
+                invocation = sample.get("worker_invocation")
+                worker_command = sample.get("worker_command")
+                if (
+                    isinstance(cold_load_seconds, bool)
+                    or not isinstance(cold_load_seconds, (float, int))
+                    or not math.isfinite(float(cold_load_seconds))
+                    or float(cold_load_seconds) <= 0.0
+                    or not _valid_resource_peak(peak_rss_after_cold_load)
+                    or not _valid_resource_peak(peak_rss_after_profile)
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} lacks cold-load/resource evidence"
+                    )
+                if (
+                    isinstance(sample_round, bool)
+                    or not isinstance(sample_round, int)
+                    or sample_round < 0
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} has an invalid schedule round"
+                    )
+                try:
+                    retained_worker_command = _validated_command_identity(
+                        worker_command
+                    )
+                    invocation_command = (
+                        _validated_command_identity(invocation.get("command"))
+                        if isinstance(invocation, Mapping)
+                        else None
+                    )
+                except HarnessError:
+                    retained_worker_command = None
+                    invocation_command = None
+                if (
+                    retained_worker_command is None
+                    or invocation_command is None
+                    or retained_worker_command != invocation_command
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} has inconsistent worker command provenance"
+                    )
+                if sample.get("lane_contract_sha256") != (
+                    expected_lane_contract_sha256
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} is not bound to its lane contract"
+                    )
+                if not isinstance(verification, Mapping):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} has no artifact verification"
+                    )
+                else:
+                    expected_identities = verification.get("expected")
+                    observed_identities = verification.get("observed")
+                    effective_contract = verification.get("effective_contract")
+                    expected_effective_contract = {
+                        "execution_mode": mode,
+                        "backend": "jit",
+                        "jit_optimization_level": (
+                            _expected_effective_jit_optimization_level(
+                                arguments,
+                                mode=mode,
+                            )
+                        ),
+                        "color_accuracy": "lc",
+                        "lc_flow_layout": arguments.lc_flow_layout,
+                    }
+                    if (
+                        verification.get("kind") != WORKER_VERIFICATION_KIND
+                        or not _is_exact_int(
+                            verification.get("schema_version"),
+                            WORKER_VERIFICATION_SCHEMA,
+                        )
+                        or not _is_utc_timestamp(verification.get("verified_at_utc"))
+                        or verification.get("artifact_semantic_identity_sha256")
+                        != profile_semantic_sha256
+                        or not isinstance(expected_identities, Mapping)
+                        or not isinstance(observed_identities, Mapping)
+                        or expected_identities.get("artifact_semantic_identity_sha256")
+                        != profile_semantic_sha256
+                        or observed_identities.get("artifact_semantic_identity_sha256")
+                        != profile_semantic_sha256
+                        or not isinstance(effective_contract, Mapping)
+                        or _canonical_sha256(effective_contract)
+                        != _canonical_sha256(expected_effective_contract)
+                    ):
+                        errors.append(
+                            f"profile batch {batch_size} subprocess sample "
+                            f"{sample_index} artifact identity is not bound"
+                        )
+                    else:
+                        try:
+                            _validate_loaded_runtime_artifact_verification(
+                                verification.get("loaded_runtime_artifact"),
+                                expected_artifact_id=expected_identities.get(
+                                    "artifact_id"
+                                ),
+                                phase="after-native-load-before-timing",
+                            )
+                            _validate_loaded_runtime_artifact_verification(
+                                post_timing_loaded_artifact,
+                                expected_artifact_id=expected_identities.get(
+                                    "artifact_id"
+                                ),
+                                phase="after-timing",
+                            )
+                        except HarnessError:
+                            errors.append(
+                                f"profile batch {batch_size} subprocess sample "
+                                f"{sample_index} loaded artifact identity is not bound"
+                            )
+                if (
+                    isinstance(internal_count, bool)
+                    or not isinstance(internal_count, int)
+                    or internal_count < MIN_AUTHORITATIVE_SAMPLES
+                    or internal_count < arguments.minimum_samples
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} has too few native timing blocks"
+                    )
+                if (
+                    isinstance(repetitions, bool)
+                    or not isinstance(repetitions, int)
+                    or repetitions <= 0
+                    or isinstance(evaluation_count, bool)
+                    or not isinstance(evaluation_count, int)
+                    or evaluation_count <= 0
+                    or isinstance(evaluated_point_count, bool)
+                    or not isinstance(evaluated_point_count, int)
+                    or evaluated_point_count <= 0
+                    or (
+                        isinstance(internal_count, int)
+                        and evaluation_count != internal_count * repetitions
+                    )
+                    or evaluated_point_count != evaluation_count * batch_size
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} has invalid repetition/evaluation counts"
+                    )
+                if (
+                    not isinstance(worker_measurement, Mapping)
+                    or not _is_exact_int(
+                        worker_measurement.get("batch_size"),
+                        batch_size,
+                    )
+                    or not isinstance(internal_count, int)
+                    or not _is_exact_int(
+                        worker_measurement.get("sample_count"),
+                        internal_count,
+                    )
+                    or not isinstance(repetitions, int)
+                    or not _is_exact_int(
+                        worker_measurement.get("repetitions_per_sample"),
+                        repetitions,
+                    )
+                    or not isinstance(evaluation_count, int)
+                    or not _is_exact_int(
+                        worker_measurement.get("evaluation_count"),
+                        evaluation_count,
+                    )
+                    or not isinstance(evaluated_point_count, int)
+                    or not _is_exact_int(
+                        worker_measurement.get("evaluated_point_count"),
+                        evaluated_point_count,
+                    )
+                    or worker_measurement.get("wall_seconds_per_point") != sample_wall
+                    or worker_measurement.get("inner_native_wall_blocks") != raw_blocks
+                    or worker_measurement.get("timing_sources") != sources
+                    or worker_measurement.get("environment") != environment
+                    or worker_measurement.get("interrupted")
+                    != sample.get("interrupted")
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} disagrees with its retained worker measurement"
+                    )
+                if not isinstance(worker_process_record, Mapping):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} has no worker process record"
+                    )
+                else:
+                    process_record_without_digest = dict(worker_process_record)
+                    process_record_digest = process_record_without_digest.pop(
+                        "content_sha256",
+                        None,
+                    )
+                    process_wall_seconds = worker_process_record.get("wall_seconds")
+                    process_id = worker_process_record.get("process_id")
+                    process_payload_sha256 = worker_process_record.get("payload_sha256")
+                    if (
+                        process_record_digest
+                        != _canonical_sha256(process_record_without_digest)
+                        or not _is_utc_timestamp(
+                            worker_process_record.get("started_at_utc")
+                        )
+                        or not _is_utc_timestamp(
+                            worker_process_record.get("finished_at_utc")
+                        )
+                        or not _utc_timestamps_nondecreasing(
+                            worker_process_record.get("started_at_utc"),
+                            (
+                                verification.get("verified_at_utc")
+                                if isinstance(verification, Mapping)
+                                else None
+                            ),
+                            worker_process_record.get("finished_at_utc"),
+                        )
+                        or isinstance(process_wall_seconds, bool)
+                        or not isinstance(process_wall_seconds, (float, int))
+                        or not math.isfinite(float(process_wall_seconds))
+                        or float(process_wall_seconds) <= 0.0
+                        or isinstance(process_id, bool)
+                        or not isinstance(process_id, int)
+                        or process_id <= 0
+                        or worker_process_record.get("operation") != "profile"
+                        or worker_process_record.get("mode") != mode
+                        or not isinstance(process_payload_sha256, str)
+                        or _SHA256_PATTERN.fullmatch(process_payload_sha256) is None
+                    ):
+                        errors.append(
+                            f"profile batch {batch_size} subprocess sample "
+                            f"{sample_index} worker process record is invalid"
+                        )
+                if not isinstance(worker_result_record, Mapping):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} has no worker result record"
+                    )
+                else:
+                    result_record_without_digest = dict(worker_result_record)
+                    result_record_digest = result_record_without_digest.pop(
+                        "content_sha256",
+                        None,
+                    )
+                    invocation = sample.get("worker_invocation")
+                    process_record_sha256 = (
+                        worker_process_record.get("content_sha256")
+                        if isinstance(worker_process_record, Mapping)
+                        else None
+                    )
+                    invocation_sha256 = (
+                        invocation.get("content_sha256")
+                        if isinstance(invocation, Mapping)
+                        else None
+                    )
+                    if (
+                        worker_result_record.get("kind") != RETAINED_WORKER_RESULT_KIND
+                        or not _is_exact_int(
+                            worker_result_record.get("schema_version"),
+                            RETAINED_WORKER_RESULT_SCHEMA,
+                        )
+                        or result_record_digest
+                        != _canonical_sha256(result_record_without_digest)
+                        or not _is_utc_timestamp(
+                            worker_result_record.get("recorded_at_utc")
+                        )
+                        or not isinstance(invocation, Mapping)
+                        or not _utc_timestamps_nondecreasing(
+                            invocation.get("started_at_utc"),
+                            (
+                                worker_process_record.get("started_at_utc")
+                                if isinstance(worker_process_record, Mapping)
+                                else None
+                            ),
+                            (
+                                worker_process_record.get("finished_at_utc")
+                                if isinstance(worker_process_record, Mapping)
+                                else None
+                            ),
+                            invocation.get("finished_at_utc"),
+                            worker_result_record.get("recorded_at_utc"),
+                        )
+                        or worker_result_record.get("addressed_payload_sha256")
+                        != _canonical_sha256(_retained_profile_sample_evidence(sample))
+                        or worker_result_record.get("worker_process_record_sha256")
+                        != process_record_sha256
+                        or worker_result_record.get("worker_invocation_sha256")
+                        != invocation_sha256
+                        or not isinstance(
+                            worker_result_record.get(
+                                "upstream_worker_result_record_sha256"
+                            ),
+                            str,
+                        )
+                        or _SHA256_PATTERN.fullmatch(
+                            worker_result_record["upstream_worker_result_record_sha256"]
+                        )
+                        is None
+                    ):
+                        errors.append(
+                            f"profile batch {batch_size} subprocess sample "
+                            f"{sample_index} worker result address is invalid"
+                        )
+                if (
+                    isinstance(sample_wall, bool)
+                    or not isinstance(sample_wall, (float, int))
+                    or not math.isfinite(float(sample_wall))
+                    or float(sample_wall) <= 0.0
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} has invalid wall timing"
+                    )
+                else:
+                    sample_values.append(float(sample_wall))
+                if (
+                    not isinstance(sources, Mapping)
+                    or sources.get("wall") != "runtime_core_repeated_wall_time"
+                    or not isinstance(environment, Mapping)
+                    or environment.get("wall_time_source")
+                    != "runtime_core_repeated_wall_time"
+                    or environment.get("wall_time_sample_pass")
+                    != "runtime._benchmark_f64_wall_time"
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} is not an unprofiled native-wall sample"
+                    )
+                if (
+                    not isinstance(timing_configuration, Mapping)
+                    or not _is_exact_int(
+                        timing_configuration.get("minimum_internal_samples"),
+                        arguments.minimum_samples,
+                    )
+                    or not _is_exact_int(
+                        timing_configuration.get("warmup_runs"),
+                        arguments.warmup_runs,
+                    )
+                    or isinstance(
+                        timing_configuration.get("target_runtime_seconds"),
+                        bool,
+                    )
+                    or not isinstance(
+                        timing_configuration.get("target_runtime_seconds"),
+                        (float, int),
+                    )
+                    or not math.isfinite(
+                        float(timing_configuration["target_runtime_seconds"])
+                    )
+                    or float(timing_configuration["target_runtime_seconds"]) <= 0.0
+                    or timing_configuration.get("target_runtime_seconds")
+                    != arguments.target_runtime
+                    or arguments.warmup_runs < 1
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} is not warmed"
+                    )
+                if sample.get("interrupted") is not False:
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} was interrupted"
+                    )
+                if not isinstance(raw_blocks, Mapping):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} has no raw native-wall blocks"
+                    )
+                else:
+                    raw_inventory = raw_blocks.get("blocks")
+                    raw_block_count = raw_blocks.get("block_count")
+                    raw_repetitions = raw_blocks.get("repetitions_per_block")
+                    raw_evaluation_count = raw_blocks.get("evaluation_count")
+                    raw_evaluated_point_count = raw_blocks.get("evaluated_point_count")
+                    raw_wall_median = raw_blocks.get("wall_seconds_per_point_median")
+                    raw_wall_mad = raw_blocks.get("wall_seconds_per_point_mad")
+                    raw_minimum_duration = raw_blocks.get(
+                        "minimum_native_wall_seconds"
+                    )
+                    raw_observed_duration = raw_blocks.get(
+                        "observed_native_wall_seconds"
+                    )
+                    raw_caller_duration = raw_blocks.get(
+                        "observed_caller_elapsed_seconds"
+                    )
+                    raw_calibration = raw_blocks.get("calibration")
+                    calibration_runner_samples = (
+                        raw_calibration.get("benchmark_runner_sample_count")
+                        if isinstance(raw_calibration, Mapping)
+                        else None
+                    )
+                    calibration_runner_repetitions = (
+                        raw_calibration.get(
+                            "benchmark_runner_repetitions_per_sample"
+                        )
+                        if isinstance(raw_calibration, Mapping)
+                        else None
+                    )
+                    calibration_runner_total = (
+                        raw_calibration.get("benchmark_runner_total_repetitions")
+                        if isinstance(raw_calibration, Mapping)
+                        else None
+                    )
+                    calibration_runner_wall = (
+                        raw_calibration.get(
+                            "benchmark_runner_wall_seconds_per_point"
+                        )
+                        if isinstance(raw_calibration, Mapping)
+                        else None
+                    )
+                    calibration_headroom = (
+                        raw_calibration.get("duration_headroom_factor")
+                        if isinstance(raw_calibration, Mapping)
+                        else None
+                    )
+                    if (
+                        raw_blocks.get("kind") != RAW_NATIVE_WALL_BLOCK_KIND
+                        or not _is_exact_int(
+                            raw_blocks.get("schema_version"),
+                            RAW_NATIVE_WALL_BLOCK_SCHEMA,
+                        )
+                        or raw_blocks.get("measurement_contract")
+                        != RAW_NATIVE_WALL_MEASUREMENT_CONTRACT
+                        or raw_blocks.get("source")
+                        != "runtime._benchmark_f64_wall_time"
+                        or raw_blocks.get("fixture_points_sha256")
+                        != expected_fixture_sha256
+                        or isinstance(raw_repetitions, bool)
+                        or not isinstance(raw_repetitions, int)
+                        or raw_repetitions <= 0
+                        or raw_repetitions != repetitions
+                        or isinstance(raw_evaluation_count, bool)
+                        or not isinstance(raw_evaluation_count, int)
+                        or raw_evaluation_count <= 0
+                        or raw_evaluation_count != evaluation_count
+                        or isinstance(raw_evaluated_point_count, bool)
+                        or not isinstance(raw_evaluated_point_count, int)
+                        or raw_evaluated_point_count <= 0
+                        or raw_evaluated_point_count != evaluated_point_count
+                        or isinstance(raw_block_count, bool)
+                        or not isinstance(raw_block_count, int)
+                        or raw_block_count < MIN_AUTHORITATIVE_SAMPLES
+                        or raw_block_count != internal_count
+                        or raw_evaluation_count != raw_block_count * raw_repetitions
+                        or raw_evaluated_point_count
+                        != raw_evaluation_count * batch_size
+                        or isinstance(raw_wall_median, bool)
+                        or not isinstance(raw_wall_median, (float, int))
+                        or not math.isfinite(float(raw_wall_median))
+                        or float(raw_wall_median) <= 0.0
+                        or isinstance(raw_wall_mad, bool)
+                        or not isinstance(raw_wall_mad, (float, int))
+                        or not math.isfinite(float(raw_wall_mad))
+                        or float(raw_wall_mad) < 0.0
+                        or not isinstance(raw_inventory, list)
+                        or not raw_inventory
+                        or len(raw_inventory) != raw_block_count
+                        or raw_blocks.get("blocks_sha256")
+                        != _canonical_sha256(raw_inventory)
+                        or raw_wall_median != sample_wall
+                        or isinstance(raw_minimum_duration, bool)
+                        or not isinstance(raw_minimum_duration, (float, int))
+                        or not math.isfinite(float(raw_minimum_duration))
+                        or raw_minimum_duration != arguments.target_runtime
+                        or isinstance(raw_observed_duration, bool)
+                        or not isinstance(raw_observed_duration, (float, int))
+                        or not math.isfinite(float(raw_observed_duration))
+                        or float(raw_observed_duration)
+                        < float(raw_minimum_duration)
+                        or isinstance(raw_caller_duration, bool)
+                        or not isinstance(raw_caller_duration, (float, int))
+                        or not math.isfinite(float(raw_caller_duration))
+                        or float(raw_caller_duration) <= 0.0
+                        or float(raw_caller_duration)
+                        < float(raw_observed_duration)
+                        or raw_blocks.get("minimum_duration_satisfied") is not True
+                        or not isinstance(raw_calibration, Mapping)
+                        or raw_calibration.get("kind")
+                        != "benchmark-runner-wall-rate-calibration"
+                        or not _is_exact_int(
+                            raw_calibration.get("schema_version"),
+                            1,
+                        )
+                        or isinstance(calibration_runner_samples, bool)
+                        or not isinstance(calibration_runner_samples, int)
+                        or calibration_runner_samples <= 0
+                        or isinstance(calibration_runner_repetitions, bool)
+                        or not isinstance(calibration_runner_repetitions, int)
+                        or calibration_runner_repetitions <= 0
+                        or not _is_exact_int(
+                            calibration_runner_total,
+                            calibration_runner_samples
+                            * calibration_runner_repetitions,
+                        )
+                        or isinstance(calibration_runner_wall, bool)
+                        or not isinstance(calibration_runner_wall, (float, int))
+                        or not math.isfinite(float(calibration_runner_wall))
+                        or float(calibration_runner_wall) <= 0.0
+                        or isinstance(calibration_headroom, bool)
+                        or not isinstance(calibration_headroom, (float, int))
+                        or not math.isfinite(float(calibration_headroom))
+                        or float(calibration_headroom) != 1.02
+                        or not _is_exact_int(
+                            raw_calibration.get(
+                                "requested_minimum_block_count"
+                            ),
+                            max(
+                                MIN_AUTHORITATIVE_SAMPLES,
+                                arguments.minimum_samples,
+                            ),
+                        )
+                        or not _is_exact_int(
+                            raw_calibration.get(
+                                "scaled_repetitions_per_block"
+                            ),
+                            raw_repetitions,
+                        )
+                        or not _is_exact_int(
+                            raw_calibration.get(
+                                "preceded_by_benchmark_runner_warmup_runs"
+                            ),
+                            arguments.warmup_runs,
+                        )
+                    ):
+                        errors.append(
+                            f"profile batch {batch_size} subprocess sample "
+                            f"{sample_index} raw native-wall inventory is invalid"
+                        )
+                    elif any(
+                        not isinstance(block, Mapping)
+                        or isinstance(block.get("block_index"), bool)
+                        or not isinstance(block.get("block_index"), int)
+                        or block.get("block_index") != block_index
+                        or not _is_utc_timestamp(block.get("started_at_utc"))
+                        or not _is_utc_timestamp(block.get("finished_at_utc"))
+                        or not _utc_timestamps_nondecreasing(
+                            (
+                                worker_process_record.get("started_at_utc")
+                                if isinstance(worker_process_record, Mapping)
+                                else None
+                            ),
+                            block.get("started_at_utc"),
+                            block.get("finished_at_utc"),
+                            (
+                                worker_process_record.get("finished_at_utc")
+                                if isinstance(worker_process_record, Mapping)
+                                else None
+                            ),
+                        )
+                        or (
+                            block_index == 0
+                            and not _utc_timestamps_nondecreasing(
+                                (
+                                    verification.get("verified_at_utc")
+                                    if isinstance(verification, Mapping)
+                                    else None
+                                ),
+                                block.get("started_at_utc"),
+                            )
+                        )
+                        or (
+                            block_index > 0
+                            and (
+                                not isinstance(
+                                    raw_inventory[block_index - 1],
+                                    Mapping,
+                                )
+                                or not _utc_timestamps_nondecreasing(
+                                    raw_inventory[block_index - 1].get(
+                                        "finished_at_utc"
+                                    ),
+                                    block.get("started_at_utc"),
+                                )
+                            )
+                        )
+                        or isinstance(block.get("caller_elapsed_seconds"), bool)
+                        or not isinstance(
+                            block.get("caller_elapsed_seconds"),
+                            (float, int),
+                        )
+                        or not math.isfinite(float(block["caller_elapsed_seconds"]))
+                        or float(block["caller_elapsed_seconds"]) <= 0.0
+                        or isinstance(block.get("native_wall_seconds"), bool)
+                        or not isinstance(
+                            block.get("native_wall_seconds"),
+                            (float, int),
+                        )
+                        or not math.isfinite(float(block["native_wall_seconds"]))
+                        or float(block["native_wall_seconds"]) <= 0.0
+                        or float(block["caller_elapsed_seconds"])
+                        < float(block["native_wall_seconds"])
+                        or isinstance(
+                            block.get("wall_seconds_per_point"),
+                            bool,
+                        )
+                        or not isinstance(
+                            block.get("wall_seconds_per_point"),
+                            (float, int),
+                        )
+                        or not math.isfinite(float(block["wall_seconds_per_point"]))
+                        or float(block["wall_seconds_per_point"]) <= 0.0
+                        or not math.isclose(
+                            float(block["wall_seconds_per_point"]),
+                            float(block["native_wall_seconds"])
+                            / (repetitions * batch_size),
+                            rel_tol=1.0e-15,
+                            abs_tol=0.0,
+                        )
+                        or any(
+                            isinstance(block.get(field), bool)
+                            or not isinstance(block.get(field), int)
+                            or block[field] <= 0
+                            for field in (
+                                "repetitions",
+                                "batch_size",
+                                "evaluation_count",
+                                "evaluated_point_count",
+                            )
+                        )
+                        or block.get("repetitions") != repetitions
+                        or block.get("batch_size") != batch_size
+                        or block.get("evaluation_count") != repetitions
+                        or block.get("evaluated_point_count")
+                        != repetitions * batch_size
+                        or block.get("content_sha256")
+                        != _canonical_sha256(
+                            {
+                                key: value
+                                for key, value in block.items()
+                                if key != "content_sha256"
+                            }
+                        )
+                        for block_index, block in enumerate(raw_inventory)
+                    ):
+                        errors.append(
+                            f"profile batch {batch_size} subprocess sample "
+                            f"{sample_index} raw block content address is invalid"
+                        )
+                    else:
+                        raw_values = [
+                            float(block["wall_seconds_per_point"])
+                            for block in raw_inventory
+                        ]
+                        raw_median = statistics.median(raw_values)
+                        raw_mad = statistics.median(
+                            abs(value - raw_median) for value in raw_values
+                        )
+                        observed_native_duration = sum(
+                            float(block["native_wall_seconds"])
+                            for block in raw_inventory
+                        )
+                        observed_caller_duration = sum(
+                            float(block["caller_elapsed_seconds"])
+                            for block in raw_inventory
+                        )
+                        requested_block_count = int(
+                            raw_calibration["requested_minimum_block_count"]
+                        )
+                        runner_repetition_count = int(
+                            calibration_runner_repetitions
+                        )
+                        runner_wall_seconds = float(calibration_runner_wall)
+                        headroom_factor = float(calibration_headroom)
+                        runner_total_repetitions = int(calibration_runner_total)
+                        expected_scaled_repetitions = max(
+                            runner_repetition_count,
+                            math.ceil(
+                                (
+                                    float(arguments.target_runtime)
+                                    * headroom_factor
+                                )
+                                / (
+                                    requested_block_count
+                                    * runner_wall_seconds
+                                    * batch_size
+                                )
+                            ),
+                        )
+                        invocation_wall_duration = (
+                            invocation.get("wall_seconds")
+                            if isinstance(invocation, Mapping)
+                            else None
+                        )
+                        process_wall_duration = (
+                            worker_process_record.get("wall_seconds")
+                            if isinstance(worker_process_record, Mapping)
+                            else None
+                        )
+                        if (
+                            not raw_values
+                            or any(
+                                not math.isfinite(value) or value <= 0.0
+                                for value in raw_values
+                            )
+                            or raw_wall_median != raw_median
+                            or raw_wall_mad != raw_mad
+                            or raw_observed_duration != observed_native_duration
+                            or raw_caller_duration != observed_caller_duration
+                            or observed_native_duration
+                            < float(arguments.target_runtime)
+                            or observed_caller_duration
+                            < float(arguments.target_runtime)
+                            or raw_repetitions != expected_scaled_repetitions
+                            or not isinstance(worker_measurement, Mapping)
+                            or worker_measurement.get(
+                                "benchmark_runner_sample_count"
+                            )
+                            != calibration_runner_samples
+                            or worker_measurement.get(
+                                "benchmark_runner_repetitions_per_sample"
+                            )
+                            != runner_repetition_count
+                            or worker_measurement.get(
+                                "benchmark_runner_evaluation_count"
+                            )
+                            != runner_total_repetitions
+                            or worker_measurement.get(
+                                "benchmark_runner_evaluated_point_count"
+                            )
+                            != runner_total_repetitions * batch_size
+                            or worker_measurement.get(
+                                "benchmark_runner_wall_seconds_per_point"
+                            )
+                            != runner_wall_seconds
+                            or isinstance(invocation_wall_duration, bool)
+                            or not isinstance(
+                                invocation_wall_duration,
+                                (float, int),
+                            )
+                            or not math.isfinite(
+                                float(invocation_wall_duration)
+                            )
+                            or float(invocation_wall_duration)
+                            < observed_native_duration
+                            or float(invocation_wall_duration)
+                            < observed_caller_duration
+                            or isinstance(process_wall_duration, bool)
+                            or not isinstance(
+                                process_wall_duration,
+                                (float, int),
+                            )
+                            or not math.isfinite(
+                                float(process_wall_duration)
+                            )
+                            or float(process_wall_duration)
+                            < observed_native_duration
+                            or float(process_wall_duration)
+                            < observed_caller_duration
+                        ):
+                            errors.append(
+                                f"profile batch {batch_size} subprocess sample "
+                                f"{sample_index} raw block statistics are invalid"
+                            )
+                if isinstance(schedule_index, bool) or not isinstance(
+                    schedule_index, int
+                ):
+                    errors.append(
+                        f"profile batch {batch_size} subprocess sample "
+                        f"{sample_index} has no schedule identity"
+                    )
+                else:
+                    schedule_indices.append(schedule_index)
+                    scheduled = scheduled_entries.get(schedule_index)
+                    if (
+                        not isinstance(scheduled, Mapping)
+                        or scheduled.get("mode") != mode
+                        or scheduled.get("batch_size") != batch_size
+                        or scheduled.get("round") != sample.get("round")
+                        or scheduled.get("worker_invocation")
+                        != sample.get("worker_invocation")
+                        or scheduled.get("pre_timing_verification")
+                        != sample.get("pre_timing_verification")
+                        or scheduled.get("worker_result_record")
+                        != sample.get("worker_result_record")
+                        or not isinstance(worker_result_record, Mapping)
+                        or scheduled.get("worker_result_sha256")
+                        != worker_result_record.get("addressed_payload_sha256")
+                    ):
+                        errors.append(
+                            f"profile batch {batch_size} subprocess sample "
+                            f"{sample_index} is not bound to the interleaved schedule"
+                        )
+            if len(schedule_indices) != len(set(schedule_indices)):
+                errors.append(f"profile batch {batch_size} reused a worker subprocess")
+            if len(sample_values) == len(subprocess_samples) and sample_values:
+                expected_median = statistics.median(sample_values)
+                expected_mad = statistics.median(
+                    abs(value - expected_median) for value in sample_values
+                )
+                if median != expected_median or mad != expected_mad:
+                    errors.append(
+                        f"profile batch {batch_size} median/MAD is not reproducible"
+                    )
+            if interrupted is not False:
+                errors.append(f"profile batch {batch_size} was interrupted")
+        missing = [
+            batch_size
+            for batch_size in DEFAULT_BATCH_SIZES
+            if batch_size not in observed
+        ]
+        lane_passes = not errors and not missing
+        lanes[mode] = {
+            "passes": lane_passes,
+            "observed_batch_sizes": observed,
+            "missing_batch_sizes": missing,
+            "errors": errors,
+        }
+        passes = passes and lane_passes
+    return {
+        "passes": passes,
+        "lanes": lanes,
+        "schedule": schedule_contract,
+        "minimum_authoritative_samples": MIN_AUTHORITATIVE_SAMPLES,
+        "configured_subprocess_samples": arguments.subprocess_samples,
+        "configured_internal_minimum_samples": arguments.minimum_samples,
+        "configured_warmup_runs": arguments.warmup_runs,
+        "root_processes_match": root_processes_match,
+    }
+
+
+def _selected_union_semantic_projection(
+    arguments: argparse.Namespace,
+    profile: Mapping[str, Any],
+    identity: Mapping[str, Any],
+    *,
+    mode: str,
+) -> dict[str, object]:
+    """Build the sole relaxed cross-lane semantic projection.
+
+    Every lane is still fully authenticated and internally validated.  Across
+    lanes, this projection ignores only nonselected helicity coefficients and
+    structural-zero flags plus logical/execution reduction identities.  Those
+    fields may legitimately differ because recurrence carries a conservative
+    live-helicity census while compiled artifacts can certify more zeros.
+    """
+
+    if not _selected_union_semantic_exception_enabled(arguments):
+        raise HarnessError(
+            "selected-union semantic projection is outside its audited workload"
+        )
+    coverage = identity.get("coverage")
+    color_axis = identity.get("physical_color_flows")
+    helicity_axis = identity.get("physical_helicities")
+    specialized_axes = identity.get("generation_specialized_axes")
+    if (
+        not isinstance(coverage, Mapping)
+        or coverage.get("color") != "complete"
+        or coverage.get("helicities") != "complete"
+        or coverage.get("complete_physical_axes") is not True
+        or specialized_axes != []
+        or not isinstance(color_axis, Mapping)
+        or not isinstance(helicity_axis, Mapping)
+    ):
+        raise HarnessError(
+            f"{mode} selected-union artifact does not expose complete physical axes"
+        )
+    validated_color = _validated_logical_physical_axis(
+        color_axis,
+        label="physical_color_flows",
+        require_structural_zero=False,
+    )
+    validated_helicity = _validated_logical_physical_axis(
+        helicity_axis,
+        label="physical_helicities",
+        require_structural_zero=True,
+    )
+    color_ids = validated_color["ordered_ids"]
+    color_entries = validated_color["ordered_entries"]
+    helicity_ids = validated_helicity["ordered_ids"]
+    helicity_entries = validated_helicity["ordered_entries"]
+    assert isinstance(color_ids, list)
+    assert isinstance(color_entries, list)
+    assert isinstance(helicity_ids, list)
+    assert isinstance(helicity_entries, list)
+    if (
+        validated_color.get("count") != MIGRATION_UNION_PHYSICAL_COLOR_COUNT
+        or len(color_ids) != MIGRATION_UNION_PHYSICAL_COLOR_COUNT
+        or MIGRATION_UNION_SELECTED_HELICITY_ID not in helicity_ids
+    ):
+        raise HarnessError(
+            f"{mode} selected-union artifact has the wrong physical-axis inventory"
+        )
+    selected_index = helicity_ids.index(MIGRATION_UNION_SELECTED_HELICITY_ID)
+    selected_entry = helicity_entries[selected_index]
+    assert isinstance(selected_entry, Mapping)
+    selected_coefficient = selected_entry.get("coefficient")
+    if (
+        selected_entry.get("index") != selected_index
+        or selected_entry.get("id") != MIGRATION_UNION_SELECTED_HELICITY_ID
+        or tuple(selected_entry.get("values", ()))
+        != MIGRATION_UNION_SELECTED_HELICITY_VALUES
+        or isinstance(selected_coefficient, bool)
+        or not isinstance(selected_coefficient, (float, int))
+        or not math.isfinite(float(selected_coefficient))
+        or float(selected_coefficient) <= 0.0
+        or selected_entry.get("structural_zero") is not False
+    ):
+        raise HarnessError(
+            f"{mode} selected-union helicity entry is not live and canonical"
+        )
+    selector_projection = _selected_union_selector_projection(
+        arguments,
+        profile.get("selector_contract"),
+        identity,
+    )
+    validation = profile.get("validation")
+    if (
+        not isinstance(validation, Mapping)
+        or validation.get("resolved_helicity_ids")
+        != [MIGRATION_UNION_SELECTED_HELICITY_ID]
+        or validation.get("resolved_color_ids") != color_ids
+    ):
+        raise HarnessError(
+            f"{mode} selected-union resolved axes do not match artifact physics"
+        )
+    process_id = profile.get("process_id")
+    process_expression = profile.get("process_expression")
+    if (
+        not isinstance(process_id, str)
+        or not process_id
+        or not isinstance(process_expression, str)
+        or " ".join(process_expression.split()).casefold()
+        != MIGRATION_PROCESS_CANONICAL.casefold()
+    ):
+        raise HarnessError(
+            f"{mode} selected-union profile has the wrong process identity"
+        )
+    helicity_kinematics = [
+        {
+            "index": entry["index"],
+            "id": entry["id"],
+            "values": entry["values"],
+            **(
+                {
+                    "coefficient": entry["coefficient"],
+                    "structural_zero": entry["structural_zero"],
+                }
+                if entry["id"] == MIGRATION_UNION_SELECTED_HELICITY_ID
+                else {}
+            ),
+        }
+        for entry in helicity_entries
+        if isinstance(entry, Mapping)
+    ]
+    model_identity = identity.get("manifest_model_identity")
+    if not isinstance(model_identity, Mapping):
+        raise HarnessError(f"{mode} selected-union artifact has no model identity")
+    return {
+        "policy": "ddbar-z6g-all-flow-union-selected-helicity-v1",
+        "process_id": process_id,
+        "process_expression": MIGRATION_PROCESS_CANONICAL,
+        "physical_color_flows": {
+            "count": validated_color["count"],
+            "ordered_ids_sha256": validated_color["ordered_ids_sha256"],
+            "ordered_entries_sha256": validated_color["ordered_entries_sha256"],
+        },
+        "physical_helicities": {
+            "count": validated_helicity["count"],
+            "ordered_ids_sha256": validated_helicity["ordered_ids_sha256"],
+            "kinematic_entries_sha256": _canonical_sha256(helicity_kinematics),
+            "selected_index": selected_index,
+            "selected_entry": dict(selected_entry),
+        },
+        "normalization_sha256": identity.get("normalization_sha256"),
+        "model_common_physics_identity_sha256": model_identity.get(
+            "common_physics_identity_sha256"
+        ),
+        "runtime_selector_semantics_sha256": identity.get(
+            "runtime_selector_semantics_sha256"
+        ),
+        "profile_selector": selector_projection,
+        "resolved_color_ids_sha256": _canonical_sha256(color_ids),
+    }
+
+
+def _profile_artifact_semantic_contract(
+    profiles: Mapping[str, Mapping[str, Any]],
+    *,
+    arguments: argparse.Namespace | None = None,
+) -> dict[str, object]:
+    lane_contracts: dict[str, dict[str, object]] = {}
+    errors: list[str] = []
+    selected_union_projection = _selected_union_semantic_exception_enabled(arguments)
+    for mode, profile in profiles.items():
+        identity = profile.get("artifact_semantic_identity")
+        identity_sha256 = profile.get("artifact_semantic_identity_sha256")
+        if not isinstance(identity, Mapping):
+            errors.append(f"{mode} profile has no artifact semantic identity")
+            continue
+        if identity_sha256 != _canonical_sha256(identity):
+            errors.append(
+                f"{mode} profile artifact semantic identity is not content-addressed"
+            )
+            continue
+        coverage = identity.get("coverage")
+        color_axis = identity.get("physical_color_flows")
+        helicity_axis = identity.get("physical_helicities")
+        normalization = identity.get("normalization")
+        model_identity = identity.get("manifest_model_identity")
+        selector_semantics = identity.get("runtime_selector_semantics")
+        runtime_selectors = identity.get("runtime_selectors")
+        reduction_ordering = identity.get("reduction_ordering")
+        reduction_coverage = identity.get("reduction_coverage")
+        execution_reduction = identity.get("execution_reduction_identity")
+        execution_reduction_coverage = identity.get("execution_reduction_coverage")
+        execution_ordering = identity.get("execution_schedule_ordering")
+        if (
+            identity.get("kind") != "pyamplicol-benchmark-artifact-semantic-identity"
+            or not _is_exact_int(
+                identity.get("schema_version"),
+                ARTIFACT_SEMANTIC_IDENTITY_SCHEMA,
+            )
+            or not isinstance(coverage, Mapping)
+            or not isinstance(color_axis, Mapping)
+            or not isinstance(helicity_axis, Mapping)
+            or not isinstance(normalization, Mapping)
+            or not isinstance(model_identity, Mapping)
+            or not isinstance(selector_semantics, Mapping)
+            or not isinstance(runtime_selectors, Mapping)
+            or not isinstance(reduction_ordering, Mapping)
+            or not isinstance(reduction_coverage, Mapping)
+            or not isinstance(execution_reduction, Mapping)
+            or not isinstance(execution_reduction_coverage, Mapping)
+            or not isinstance(execution_ordering, Mapping)
+        ):
+            errors.append(f"{mode} artifact semantic identity is incomplete")
+            continue
+        axis_contracts: dict[str, dict[str, object]] = {}
+        axes_are_valid = True
+        for label, axis, require_structural_zero in (
+            ("physical_color_flows", color_axis, False),
+            ("physical_helicities", helicity_axis, True),
+        ):
+            try:
+                validated_axis = _validated_logical_physical_axis(
+                    axis,
+                    label=label,
+                    require_structural_zero=require_structural_zero,
+                )
+            except HarnessError:
+                errors.append(f"{mode} {label} semantic identity is invalid")
+                axes_are_valid = False
+                continue
+            axis_contracts[label] = {
+                "count": validated_axis["count"],
+                "ordered_ids_sha256": validated_axis["ordered_ids_sha256"],
+                "ordered_entries_sha256": validated_axis["ordered_entries_sha256"],
+            }
+        if not axes_are_valid or len(axis_contracts) != 2:
+            continue
+        normalization_sha256 = identity.get("normalization_sha256")
+        manifest_model = model_identity.get("manifest")
+        manifest_model_sha256 = model_identity.get("manifest_sha256")
+        model_common = model_identity.get("common_physics_identity")
+        model_common_sha256 = model_identity.get("common_physics_identity_sha256")
+        selector_semantics_sha256 = identity.get("runtime_selector_semantics_sha256")
+        runtime_selectors_sha256 = identity.get("runtime_selectors_sha256")
+        reduction_ordering_sha256 = identity.get("reduction_ordering_sha256")
+        execution_reduction_sha256 = identity.get("execution_reduction_identity_sha256")
+        execution_ordering_sha256 = identity.get("execution_schedule_ordering_sha256")
+        try:
+            validated_model_identity = _manifest_model_identity(
+                {"model": manifest_model}
+            )
+        except HarnessError:
+            validated_model_identity = None
+        color_coverage = coverage.get("color")
+        helicity_coverage = coverage.get("helicities")
+        try:
+            validated_selector_semantics = (
+                _runtime_selector_semantic_identity(
+                    runtime_selectors,
+                    color_coverage=color_coverage,
+                    helicity_coverage=helicity_coverage,
+                    artifact=Path(f"<{mode}-profile>"),
+                )
+                if isinstance(color_coverage, str)
+                and isinstance(helicity_coverage, str)
+                else None
+            )
+        except HarnessError:
+            validated_selector_semantics = None
+        runtime_process_contract = execution_ordering.get("runtime_process_contract")
+        manifest_payload_order = execution_ordering.get("manifest_payload_order")
+        execution_ordering_is_valid = (
+            isinstance(runtime_process_contract, Mapping)
+            and bool(runtime_process_contract)
+            and isinstance(manifest_payload_order, list)
+            and bool(manifest_payload_order)
+            and all(
+                isinstance(entry, Mapping)
+                and isinstance(entry.get("path"), str)
+                and bool(entry.get("path"))
+                for entry in manifest_payload_order
+            )
+        )
+        try:
+            validated_reduction = _logical_reduction_ordering_identity(
+                reduction_ordering.get("kind"),
+                color_axis=color_axis,
+                helicity_axis=helicity_axis,
+                artifact=Path(f"<{mode}-profile>"),
+            )
+        except HarnessError:
+            validated_reduction = None
+        execution_reduction_is_valid = False
+        if validated_reduction is not None:
+            try:
+                _validate_execution_reduction_summary(
+                    execution_reduction,
+                    execution_reduction_coverage,
+                    logical_reduction=validated_reduction["ordering"],
+                    artifact=Path(f"<{mode}-profile>"),
+                )
+            except HarnessError:
+                pass
+            else:
+                execution_reduction_is_valid = True
+        if (
+            normalization_sha256 != _canonical_sha256(normalization)
+            or coverage.get("complete_physical_axes")
+            is not (color_coverage == "complete" and helicity_coverage == "complete")
+            or validated_model_identity is None
+            or manifest_model_sha256 != validated_model_identity["manifest_sha256"]
+            or _canonical_sha256(manifest_model)
+            != _canonical_sha256(validated_model_identity["manifest"])
+            or not isinstance(model_common, Mapping)
+            or _canonical_sha256(model_common)
+            != _canonical_sha256(validated_model_identity["common_physics_identity"])
+            or model_common_sha256
+            != validated_model_identity["common_physics_identity_sha256"]
+            or validated_selector_semantics is None
+            or _canonical_sha256(selector_semantics)
+            != _canonical_sha256(validated_selector_semantics)
+            or selector_semantics.get("generation_specialized_axes")
+            != identity.get("generation_specialized_axes")
+            or selector_semantics_sha256 != _canonical_sha256(selector_semantics)
+            or runtime_selectors_sha256 != _canonical_sha256(runtime_selectors)
+            or validated_reduction is None
+            or _canonical_sha256(reduction_ordering)
+            != _canonical_sha256(validated_reduction["ordering"])
+            or reduction_ordering_sha256 != validated_reduction["ordering_sha256"]
+            or _canonical_sha256(reduction_coverage)
+            != _canonical_sha256(validated_reduction["coverage"])
+            or execution_reduction_sha256 != _canonical_sha256(execution_reduction)
+            or not execution_reduction_is_valid
+            or not execution_ordering_is_valid
+            or execution_ordering_sha256 != _canonical_sha256(execution_ordering)
+            or reduction_coverage.get("complete") is not True
+        ):
+            errors.append(
+                f"{mode} model/selector/reduction semantic identity is invalid"
+            )
+            continue
+        lane_contract: dict[str, object] = {
+            **axis_contracts,
+            "normalization_sha256": normalization_sha256,
+            "model_common_physics_identity_sha256": model_common_sha256,
+            "runtime_selector_semantics_sha256": selector_semantics_sha256,
+            "runtime_selectors_sha256": runtime_selectors_sha256,
+            "reduction_ordering_sha256": reduction_ordering_sha256,
+            "execution_reduction_identity_sha256": (execution_reduction_sha256),
+            "execution_schedule_ordering_sha256": execution_ordering_sha256,
+        }
+        if selected_union_projection:
+            assert arguments is not None
+            try:
+                lane_contract["selected_union_workload_projection"] = (
+                    _selected_union_semantic_projection(
+                        arguments,
+                        profile,
+                        identity,
+                        mode=mode,
+                    )
+                )
+            except HarnessError as error:
+                errors.append(str(error))
+                continue
+        lane_contracts[mode] = lane_contract
+    common_physics = (
+        {
+            mode: contract["selected_union_workload_projection"]
+            for mode, contract in lane_contracts.items()
+        }
+        if selected_union_projection
+        else {
+            mode: {
+                "physical_color_flows": contract["physical_color_flows"],
+                "physical_helicities": contract["physical_helicities"],
+                "normalization_sha256": contract["normalization_sha256"],
+                "model_common_physics_identity_sha256": contract[
+                    "model_common_physics_identity_sha256"
+                ],
+                "runtime_selector_semantics_sha256": contract[
+                    "runtime_selector_semantics_sha256"
+                ],
+                "reduction_ordering_sha256": contract["reduction_ordering_sha256"],
+            }
+            for mode, contract in lane_contracts.items()
+        }
+    )
+    common_values = list(common_physics.values())
+    lanes_match = (
+        bool(common_values)
+        and set(lane_contracts) == set(profiles)
+        and all(value == common_values[0] for value in common_values[1:])
+    )
+    if common_values and set(lane_contracts) == set(profiles) and not lanes_match:
+        errors.append(
+            "profile lanes differ outside the audited selected-union "
+            "helicity/reduction projection"
+            if selected_union_projection
+            else (
+                "profile lanes have different model, ordered physical-axis "
+                "entries, runtime-selector semantics, normalization, or "
+                "reduction ordering"
+            )
+        )
+    return {
+        "passes": bool(profiles)
+        and not errors
+        and len(lane_contracts) == len(profiles),
+        "errors": errors,
+        "lanes_match": lanes_match,
+        "comparison_policy": (
+            "ddbar-z6g-all-flow-union-selected-helicity-v1"
+            if selected_union_projection
+            else "strict-exact-v1"
+        ),
+        "lane_contracts": lane_contracts,
+        "common_physics_contract": (
+            common_values[0] if common_values and lanes_match else None
+        ),
+    }
+
+
+def _resource_peak_mapping_errors(
+    value: object,
+    *,
+    label: str,
+) -> list[str]:
+    if not isinstance(value, Mapping):
+        return [f"{label} is missing"]
+    errors: list[str] = []
+    if set(value) != _RESOURCE_PEAK_KEYS:
+        errors.append(f"{label} has unexpected keys")
+    if value.get("source") != "resource.getrusage":
+        errors.append(f"{label} has an invalid source")
+    if value.get("semantics") != _RESOURCE_PEAK_SEMANTICS:
+        errors.append(f"{label} has invalid semantics")
+    integer_fields = (
+        "self_peak_bytes",
+        "maximum_child_peak_bytes",
+        "observed_lower_bound_bytes",
+    )
+    integers: dict[str, int] = {}
+    for field in integer_fields:
+        raw = value.get(field)
+        if isinstance(raw, bool) or not isinstance(raw, int) or raw < 0:
+            errors.append(f"{label} {field} is not a non-negative integer")
+        else:
+            integers[field] = raw
+    if len(integers) == len(integer_fields) and integers[
+        "observed_lower_bound_bytes"
+    ] != max(
+        integers["self_peak_bytes"],
+        integers["maximum_child_peak_bytes"],
+    ):
+        errors.append(f"{label} observed lower bound is inconsistent")
+    return errors
+
+
+def _recurrence_profile_rss_contract(
+    profile: Mapping[str, Any] | None,
+) -> dict[str, object]:
+    errors: list[str] = []
+    worker_count = 0
+    maximum_cold_load_bytes = 0
+    maximum_post_profile_bytes = 0
+    raw_measurements = profile.get("profiles") if isinstance(profile, Mapping) else None
+    if not isinstance(raw_measurements, list):
+        return {
+            "passes": False,
+            "errors": ["recurrence profile measurements are missing for RSS"],
+            "worker_count": 0,
+            "maximum_cold_load_observed_lower_bound_bytes": None,
+            "maximum_post_profile_observed_lower_bound_bytes": None,
+        }
+    for measurement_index, measurement in enumerate(raw_measurements):
+        samples = (
+            measurement.get("subprocess_samples")
+            if isinstance(measurement, Mapping)
+            else None
+        )
+        if not isinstance(samples, list):
+            errors.append(
+                f"recurrence RSS measurement {measurement_index} has no workers"
+            )
+            continue
+        for sample_index, sample in enumerate(samples):
+            worker_count += 1
+            label = f"recurrence RSS worker {measurement_index}/{sample_index}"
+            if not isinstance(sample, Mapping):
+                errors.append(f"{label} is invalid")
+                continue
+            cold = sample.get("peak_rss_after_cold_load")
+            post = sample.get("peak_rss_after_profile")
+            cold_errors = _resource_peak_mapping_errors(
+                cold,
+                label=f"{label} cold-load mapping",
+            )
+            post_errors = _resource_peak_mapping_errors(
+                post,
+                label=f"{label} post-profile mapping",
+            )
+            errors.extend(cold_errors)
+            errors.extend(post_errors)
+            if cold_errors or post_errors:
+                continue
+            assert isinstance(cold, Mapping)
+            assert isinstance(post, Mapping)
+            cold_values = {
+                field: cast(int, cold[field])
+                for field in (
+                    "self_peak_bytes",
+                    "maximum_child_peak_bytes",
+                    "observed_lower_bound_bytes",
+                )
+            }
+            post_values = {
+                field: cast(int, post[field])
+                for field in (
+                    "self_peak_bytes",
+                    "maximum_child_peak_bytes",
+                    "observed_lower_bound_bytes",
+                )
+            }
+            for field in cold_values:
+                if post_values[field] < cold_values[field]:
+                    errors.append(f"{label} post-profile {field} is below cold-load")
+            maximum_cold_load_bytes = max(
+                maximum_cold_load_bytes,
+                cold_values["observed_lower_bound_bytes"],
+            )
+            maximum_post_profile_bytes = max(
+                maximum_post_profile_bytes,
+                post_values["observed_lower_bound_bytes"],
+            )
+    if worker_count == 0:
+        errors.append("recurrence RSS profile contains no workers")
+    return {
+        "passes": not errors,
+        "errors": errors,
+        "worker_count": worker_count,
+        "maximum_cold_load_observed_lower_bound_bytes": (
+            maximum_cold_load_bytes if worker_count else None
+        ),
+        "maximum_post_profile_observed_lower_bound_bytes": (
+            maximum_post_profile_bytes if worker_count else None
+        ),
+    }
+
+
+def _recurrence_runtime_acceptance(
+    arguments: argparse.Namespace,
+    *,
+    source_identity: Mapping[str, object],
+    runtime_provenance: Mapping[str, object],
+    generation: Mapping[str, Mapping[str, object]],
+    profiles: Mapping[str, Mapping[str, Any]],
+    validation_summary: Mapping[str, object] | None,
+    profile_schedule: Mapping[str, object] | None,
+) -> dict[str, object]:
+    """Build a developer-only, fail-closed recurrence runtime evidence record."""
+
+    errors: list[str] = []
+    required_configuration = {
+        "modes": ["recurrence"],
+        "generation_only": False,
+        "batch_sizes": list(DEFAULT_BATCH_SIZES),
+        "target_runtime_seconds": 5.0,
+        "warmup_runs": 2,
+        "minimum_internal_samples": MIN_AUTHORITATIVE_SAMPLES,
+        "subprocess_samples_minimum": MIN_AUTHORITATIVE_SAMPLES,
+        "subprocess_samples_maximum": 21,
+        "process_family": "d d~ > Z + (n-1)*g",
+        "accepted_n_values": [6, 7],
+        "generation_specialized_axes_allowed": False,
+        "complete_physical_axes_required": True,
+    }
+    observed_configuration = {
+        "modes": getattr(arguments, "modes", None),
+        "generation_only": getattr(arguments, "generation_only", None),
+        "batch_sizes": getattr(arguments, "batch_size", None),
+        "target_runtime_seconds": getattr(arguments, "target_runtime", None),
+        "warmup_runs": getattr(arguments, "warmup_runs", None),
+        "minimum_internal_samples": getattr(arguments, "minimum_samples", None),
+        "subprocess_samples": getattr(arguments, "subprocess_samples", None),
+        "gluon_count": getattr(arguments, "gluon_count", None),
+        "process_expression_override": getattr(
+            arguments,
+            "process_expression",
+            None,
+        ),
+        "lc_flow_layout": getattr(arguments, "lc_flow_layout", None),
+        "color_flow_request": getattr(arguments, "color_flow", None),
+        "helicity_request": getattr(arguments, "helicity", None),
+        "validation_samples": getattr(arguments, "validation_samples", None),
+        "point_tile_size": getattr(arguments, "point_tile_size", None),
+        "jit_optimization_level": getattr(
+            arguments,
+            "jit_optimization_level",
+            None,
+        ),
+        "specialize_flow_at_generation": getattr(
+            arguments,
+            "specialize_flow_at_generation",
+            None,
+        ),
+        "prepared_model_path": (
+            None
+            if getattr(arguments, "prepared_model", None) is None
+            else str(arguments.prepared_model)
+        ),
+    }
+    if getattr(arguments, "modes", None) != ["recurrence"]:
+        errors.append("runtime acceptance requires only the recurrence mode")
+    if getattr(arguments, "generation_only", None) is not False:
+        errors.append("runtime acceptance requires completed profiling")
+    if getattr(arguments, "batch_size", None) != list(DEFAULT_BATCH_SIZES):
+        errors.append("runtime acceptance requires exact batches [1, 128, 1024]")
+    if not _is_exact_int(getattr(arguments, "warmup_runs", None), 2):
+        errors.append("runtime acceptance requires exactly two warm-up runs")
+    target_runtime = getattr(arguments, "target_runtime", None)
+    if (
+        isinstance(target_runtime, bool)
+        or not isinstance(target_runtime, (float, int))
+        or not math.isfinite(float(target_runtime))
+        or float(target_runtime) != 5.0
+    ):
+        errors.append("runtime acceptance requires a five-second target")
+    minimum_samples = getattr(arguments, "minimum_samples", None)
+    if (
+        isinstance(minimum_samples, bool)
+        or not isinstance(minimum_samples, int)
+        or minimum_samples < MIN_AUTHORITATIVE_SAMPLES
+    ):
+        errors.append("runtime acceptance requires at least seven native samples")
+    subprocess_samples = getattr(arguments, "subprocess_samples", None)
+    if (
+        isinstance(subprocess_samples, bool)
+        or not isinstance(subprocess_samples, int)
+        or not MIN_AUTHORITATIVE_SAMPLES <= subprocess_samples <= 21
+    ):
+        errors.append(
+            "runtime acceptance requires seven through twenty-one worker samples"
+        )
+    gluon_count = getattr(arguments, "gluon_count", None)
+    selected_process = _selected_process(arguments)
+    normalized_selected_process = " ".join(selected_process.split()).casefold()
+    expected_ladder_process = (
+        "d d~ > z" + " g" * gluon_count
+        if (
+            not isinstance(gluon_count, bool)
+            and isinstance(gluon_count, int)
+            and gluon_count in (5, 6)
+        )
+        else None
+    )
+    if (
+        expected_ladder_process is None
+        or normalized_selected_process != expected_ladder_process
+    ):
+        errors.append(
+            "runtime acceptance requires the exact d d~ > Z+(n-1)g "
+            "ladder process for n=6 or n=7"
+        )
+    if getattr(arguments, "lc_flow_layout", None) not in LC_FLOW_LAYOUTS:
+        errors.append("runtime acceptance has an invalid LC flow layout")
+    if getattr(arguments, "specialize_flow_at_generation", None) is not False:
+        errors.append("runtime acceptance forbids generation specialization")
+
+    recurrence_profile = profiles.get("recurrence")
+    recurrence_profiles = (
+        {"recurrence": recurrence_profile}
+        if isinstance(recurrence_profile, Mapping)
+        else {}
+    )
+    if set(profiles) != {"recurrence"}:
+        errors.append("runtime acceptance profile inventory is not recurrence-only")
+
+    try:
+        measurement_contract = _profile_measurement_contract(
+            arguments,
+            recurrence_profiles,
+            profile_schedule=profile_schedule,
+            required_modes=("recurrence",),
+        )
+    except (HarnessError, TypeError, ValueError) as error:
+        measurement_contract = {
+            "passes": False,
+            "errors": [f"measurement contract failed closed: {error}"],
+        }
+    if measurement_contract.get("passes") is not True:
+        errors.append("authenticated recurrence measurement contract did not pass")
+
+    try:
+        artifact_semantic_contract = _profile_artifact_semantic_contract(
+            recurrence_profiles
+        )
+    except (HarnessError, TypeError, ValueError) as error:
+        artifact_semantic_contract = {
+            "passes": False,
+            "errors": [f"artifact semantic contract failed closed: {error}"],
+        }
+    if artifact_semantic_contract.get("passes") is not True:
+        errors.append("recurrence artifact semantic contract did not pass")
+
+    try:
+        recomputed_validation = _pairwise_profile_validation(recurrence_profiles)
+    except (HarnessError, TypeError, ValueError) as error:
+        recomputed_validation = {
+            "passes": False,
+            "errors": [f"lane validation failed closed: {error}"],
+        }
+    if (
+        recomputed_validation.get("passes") is not True
+        or recomputed_validation.get("lane_validation_passes") is not True
+        or recomputed_validation.get("selectors_match") is not True
+        or recomputed_validation.get("fixtures_match") is not True
+        or recomputed_validation.get("pairwise_validation_passes") is not None
+    ):
+        errors.append("recurrence lane self-validation did not pass")
+    if not isinstance(validation_summary, Mapping) or _canonical_sha256(
+        validation_summary
+    ) != _canonical_sha256(recomputed_validation):
+        errors.append("retained validation summary does not match recomputation")
+
+    rss_contract = _recurrence_profile_rss_contract(
+        recurrence_profile if isinstance(recurrence_profile, Mapping) else None
+    )
+    if rss_contract.get("passes") is not True:
+        errors.append("recurrence worker RSS contract did not pass")
+
+    semantic_identity = (
+        recurrence_profile.get("artifact_semantic_identity")
+        if isinstance(recurrence_profile, Mapping)
+        else None
+    )
+    semantic_identity_sha256 = (
+        recurrence_profile.get("artifact_semantic_identity_sha256")
+        if isinstance(recurrence_profile, Mapping)
+        else None
+    )
+    coverage = (
+        semantic_identity.get("coverage")
+        if isinstance(semantic_identity, Mapping)
+        else None
+    )
+    generation_specialized_axes = (
+        semantic_identity.get("generation_specialized_axes")
+        if isinstance(semantic_identity, Mapping)
+        else None
+    )
+    if (
+        not isinstance(coverage, Mapping)
+        or coverage.get("complete_physical_axes") is not True
+        or generation_specialized_axes != []
+    ):
+        errors.append("recurrence artifact lacks complete unspecialized physical axes")
+
+    generation_record = generation.get("recurrence")
+    if (
+        not isinstance(generation_record, Mapping)
+        or generation_record.get("mode") != "recurrence"
+        or generation_record.get("generation_reused") is not False
+    ):
+        errors.append("recurrence generation evidence is not a fresh recurrence lane")
+    artifact_identity = (
+        generation_record.get("artifact_identity")
+        if isinstance(generation_record, Mapping)
+        else None
+    )
+    generation_semantic_identity = (
+        artifact_identity.get("semantic_identity")
+        if isinstance(artifact_identity, Mapping)
+        else None
+    )
+    artifact_id: str | None = None
+    try:
+        artifact_id = _required_sha256(
+            (
+                artifact_identity.get("artifact_id")
+                if isinstance(artifact_identity, Mapping)
+                else None
+            ),
+            label="recurrence generation artifact",
+        )
+    except HarnessError:
+        errors.append("recurrence generation artifact ID is invalid")
+    generation_semantic_sha256 = (
+        artifact_identity.get("semantic_identity_sha256")
+        if isinstance(artifact_identity, Mapping)
+        else None
+    )
+    generation_top_level_semantic_sha256 = (
+        generation_record.get("artifact_semantic_identity_sha256")
+        if isinstance(generation_record, Mapping)
+        else None
+    )
+    if (
+        not isinstance(semantic_identity_sha256, str)
+        or _SHA256_PATTERN.fullmatch(semantic_identity_sha256) is None
+        or not isinstance(generation_semantic_identity, Mapping)
+        or _canonical_sha256(generation_semantic_identity) != semantic_identity_sha256
+        or generation_semantic_sha256 != semantic_identity_sha256
+        or generation_top_level_semantic_sha256 != semantic_identity_sha256
+    ):
+        errors.append(
+            "recurrence generation artifact semantic identity is not profile-bound"
+        )
+    expected_effective_contract = {
+        "execution_mode": "recurrence",
+        "backend": "jit",
+        "jit_optimization_level": (
+            _expected_effective_jit_optimization_level(
+                arguments,
+                mode="recurrence",
+            )
+        ),
+        "color_accuracy": "lc",
+        "lc_flow_layout": getattr(arguments, "lc_flow_layout", None),
+    }
+    effective_contract = (
+        generation_record.get("effective_contract")
+        if isinstance(generation_record, Mapping)
+        else None
+    )
+    if not isinstance(effective_contract, Mapping) or any(
+        effective_contract.get(key) != value
+        for key, value in expected_effective_contract.items()
+    ):
+        errors.append("recurrence generation artifact contract is invalid")
+
+    selector_contract = (
+        recurrence_profile.get("selector_contract")
+        if isinstance(recurrence_profile, Mapping)
+        else None
+    )
+    validation = (
+        recurrence_profile.get("validation")
+        if isinstance(recurrence_profile, Mapping)
+        else None
+    )
+    try:
+        fixture_contract = (
+            _validation_fixture_contract(validation, mode="recurrence")
+            if isinstance(validation, Mapping)
+            else None
+        )
+    except HarnessError:
+        fixture_contract = None
+    if not isinstance(selector_contract, Mapping):
+        errors.append("recurrence selector identity is missing")
+    if not isinstance(fixture_contract, Mapping):
+        errors.append("recurrence validation fixture identity is missing")
+
+    source_identity_sha256 = (
+        _canonical_sha256(source_identity)
+        if isinstance(source_identity, Mapping) and source_identity
+        else None
+    )
+    runtime_provenance_sha256 = (
+        _canonical_sha256(runtime_provenance)
+        if isinstance(runtime_provenance, Mapping) and runtime_provenance
+        else None
+    )
+    if source_identity_sha256 is None:
+        errors.append("source identity is missing")
+    if runtime_provenance_sha256 is None:
+        errors.append("runtime provenance is missing")
+    expected_worker_bindings = {
+        "source_identity_sha256": source_identity_sha256,
+        "runtime_provenance_sha256": runtime_provenance_sha256,
+        "artifact_id": artifact_id,
+        "artifact_semantic_identity_sha256": semantic_identity_sha256,
+    }
+    raw_schedule_entries = (
+        profile_schedule.get("entries")
+        if isinstance(profile_schedule, Mapping)
+        else None
+    )
+    workers_are_generation_bound = isinstance(raw_schedule_entries, list) and bool(
+        raw_schedule_entries
+    )
+    if isinstance(raw_schedule_entries, list):
+        for entry in raw_schedule_entries:
+            verification = (
+                entry.get("pre_timing_verification")
+                if isinstance(entry, Mapping)
+                else None
+            )
+            expected = (
+                verification.get("expected")
+                if isinstance(verification, Mapping)
+                else None
+            )
+            observed = (
+                verification.get("observed")
+                if isinstance(verification, Mapping)
+                else None
+            )
+            if (
+                not isinstance(expected, Mapping)
+                or not isinstance(observed, Mapping)
+                or any(
+                    expected.get(field) != value or observed.get(field) != value
+                    for field, value in expected_worker_bindings.items()
+                )
+            ):
+                workers_are_generation_bound = False
+                break
+    if not workers_are_generation_bound:
+        errors.append(
+            "recurrence profile workers are not bound to source, runtime, and "
+            "generation identities"
+        )
+
+    process_expression = (
+        " ".join(
+            cast(str, recurrence_profile.get("process_expression")).split()
+        ).casefold()
+        if isinstance(recurrence_profile, Mapping)
+        and isinstance(recurrence_profile.get("process_expression"), str)
+        else None
+    )
+    expected_process_expression = " ".join(
+        _selected_process(arguments).split()
+    ).casefold()
+    process_id = (
+        recurrence_profile.get("process_id")
+        if isinstance(recurrence_profile, Mapping)
+        else None
+    )
+    if (
+        process_expression != expected_process_expression
+        or not isinstance(process_id, str)
+        or not process_id
+    ):
+        errors.append("recurrence process identity is invalid")
+
+    bindings = {
+        "source_identity_sha256": source_identity_sha256,
+        "runtime_provenance_sha256": runtime_provenance_sha256,
+        "generation_artifact_id": artifact_id,
+        "generation_artifact_semantic_identity_sha256": (generation_semantic_sha256),
+        "profile_schedule_sha256": (
+            _canonical_sha256(profile_schedule)
+            if isinstance(profile_schedule, Mapping)
+            else None
+        ),
+        "recurrence_profile_sha256": (
+            _canonical_sha256(recurrence_profile)
+            if isinstance(recurrence_profile, Mapping)
+            else None
+        ),
+        "selector_contract": (
+            dict(selector_contract) if isinstance(selector_contract, Mapping) else None
+        ),
+        "selector_contract_sha256": (
+            _canonical_sha256(selector_contract)
+            if isinstance(selector_contract, Mapping)
+            else None
+        ),
+        "validation_fixture": (
+            dict(fixture_contract) if isinstance(fixture_contract, Mapping) else None
+        ),
+        "validation_fixture_sha256": (
+            _canonical_sha256(fixture_contract)
+            if isinstance(fixture_contract, Mapping)
+            else None
+        ),
+        "process_id": process_id,
+        "process_expression": process_expression,
+        "lc_flow_layout": getattr(arguments, "lc_flow_layout", None),
+        "configuration": observed_configuration,
+        "configuration_sha256": _canonical_sha256(observed_configuration),
+    }
+    accepted = not errors
+    record: dict[str, object] = {
+        "kind": RECURRENCE_RUNTIME_ACCEPTANCE_KIND,
+        "schema_version": RECURRENCE_RUNTIME_ACCEPTANCE_SCHEMA,
+        "accepted": accepted,
+        "status": "accepted" if accepted else "rejected",
+        "errors": errors,
+        "required": required_configuration,
+        "contracts": {
+            "measurement": measurement_contract,
+            "artifact_semantics": artifact_semantic_contract,
+            "lane_validation": {
+                "passes": recomputed_validation.get("passes"),
+                "lane_validation_passes": recomputed_validation.get(
+                    "lane_validation_passes"
+                ),
+                "selectors_match": recomputed_validation.get("selectors_match"),
+                "fixtures_match": recomputed_validation.get("fixtures_match"),
+                "pairwise_validation_passes": recomputed_validation.get(
+                    "pairwise_validation_passes"
+                ),
+                "summary_sha256": _canonical_sha256(recomputed_validation),
+            },
+            "worker_rss": rss_contract,
+        },
+        "bindings": bindings,
+    }
+    record["content_sha256"] = _canonical_sha256(record)
+    return record
+
+
+def _capture_acceptance(
+    arguments: argparse.Namespace,
+    profiles: Mapping[str, Mapping[str, Any]],
+    validation_summary: Mapping[str, object] | None,
+    *,
+    profile_schedule: Mapping[str, object] | None,
+) -> dict[str, object]:
+    authoritative_profiles = {
+        mode: profiles[mode]
+        for mode in AUTHORITATIVE_EXECUTION_MODES
+        if mode in profiles
+    }
+    observed_modes = [
+        mode for mode in AUTHORITATIVE_EXECUTION_MODES if mode in profiles
+    ]
+    missing_modes = [
+        mode for mode in AUTHORITATIVE_EXECUTION_MODES if mode not in profiles
+    ]
+    missing_batch_sizes = [
+        batch_size
+        for batch_size in DEFAULT_BATCH_SIZES
+        if batch_size not in set(arguments.batch_size)
+    ]
+    measurement_contract = _profile_measurement_contract(
+        arguments,
+        profiles,
+        profile_schedule=profile_schedule,
+        required_modes=AUTHORITATIVE_EXECUTION_MODES,
+    )
+    artifact_semantic_contract = _profile_artifact_semantic_contract(
+        authoritative_profiles,
+        arguments=arguments,
+    )
+    authoritative_validation = (
+        _pairwise_profile_validation(
+            authoritative_profiles,
+            arguments=arguments,
+        )
+        if not missing_modes
+        else None
+    )
+    specialized_axes_by_mode: dict[str, list[str]] = {}
+    incomplete_physical_axes: list[str] = []
+    for mode, profile in authoritative_profiles.items():
+        semantic_identity = profile.get("artifact_semantic_identity")
+        coverage = (
+            semantic_identity.get("coverage")
+            if isinstance(semantic_identity, Mapping)
+            else None
+        )
+        specialized_axes = (
+            semantic_identity.get("generation_specialized_axes")
+            if isinstance(semantic_identity, Mapping)
+            else None
+        )
+        if not isinstance(specialized_axes, list) or any(
+            not isinstance(axis, str) for axis in specialized_axes
+        ):
+            specialized_axes_by_mode[mode] = ["unknown"]
+        elif specialized_axes:
+            specialized_axes_by_mode[mode] = list(specialized_axes)
+        if (
+            not isinstance(coverage, Mapping)
+            or coverage.get("complete_physical_axes") is not True
+        ):
+            incomplete_physical_axes.append(mode)
+    ineligibility_reasons: list[str] = []
+    if not _authoritative_process_family(arguments):
+        ineligibility_reasons.append(
+            "the custom process expression is outside the authoritative "
+            "u u~ or d d~ Z+6g campaigns"
+        )
+    if arguments.gluon_count != 6:
+        ineligibility_reasons.append(
+            "milestone 0 requires the default Z+6g process family"
+        )
+    if arguments.specialize_flow_at_generation:
+        ineligibility_reasons.append(
+            "generation-time flow specialization was requested"
+        )
+    if specialized_axes_by_mode:
+        ineligibility_reasons.append(
+            "one or more artifacts have generation-specialized physical axes"
+        )
+    if incomplete_physical_axes:
+        ineligibility_reasons.append(
+            "one or more artifacts lack complete physical flow/helicity coverage"
+        )
+    if artifact_semantic_contract["passes"] is not True:
+        ineligibility_reasons.append(
+            "artifact physical-axis, normalization, or reduction-order semantics "
+            "are incomplete or inconsistent"
+        )
+    authoritative_eligible = not ineligibility_reasons
+    evidence_complete = (
+        not arguments.generation_only
+        and not missing_modes
+        and not missing_batch_sizes
+        and measurement_contract["passes"] is True
+    )
+    complete = evidence_complete and authoritative_eligible
+    passes = (
+        authoritative_validation.get("passes") is True
+        and measurement_contract["passes"] is True
+        if complete and authoritative_validation is not None
+        else None
+    )
+    eager_requested = "eager" in arguments.modes
+    eager_observed = "eager" in profiles
+    eager_profiles = {
+        mode: profiles[mode]
+        for mode in (*AUTHORITATIVE_EXECUTION_MODES, "eager")
+        if mode in profiles
+    }
+    eager_measurement = (
+        _profile_measurement_contract(
+            arguments,
+            profiles,
+            profile_schedule=profile_schedule,
+            required_modes=("eager",),
+        )
+        if eager_requested
+        else None
+    )
+    eager_semantics = (
+        _profile_artifact_semantic_contract(
+            eager_profiles,
+            arguments=arguments,
+        )
+        if eager_observed and not missing_modes
+        else None
+    )
+    eager_validation = (
+        _pairwise_profile_validation(
+            eager_profiles,
+            arguments=arguments,
+        )
+        if eager_observed and not missing_modes
+        else None
+    )
+    eager_complete = bool(
+        eager_requested
+        and eager_observed
+        and not missing_batch_sizes
+        and eager_measurement is not None
+        and eager_measurement.get("passes") is True
+        and eager_semantics is not None
+        and eager_semantics.get("passes") is True
+        and eager_semantics.get("lanes_match") is True
+    )
+    eager_passes = (
+        eager_validation.get("passes") is True
+        if eager_complete and eager_validation is not None
+        else None
+    )
+    eager_diagnostic = {
+        "requested": eager_requested,
+        "observed": eager_observed,
+        "complete": eager_complete,
+        "passes": eager_passes,
+        "measurement_contract": eager_measurement,
+        "artifact_semantic_contract": eager_semantics,
+        "validation_summary": eager_validation,
+        "ineligibility_reasons": [
+            reason
+            for condition, reason in (
+                (
+                    eager_requested and not eager_observed,
+                    "the requested eager profile lane is missing",
+                ),
+                (
+                    eager_observed
+                    and eager_measurement is not None
+                    and eager_measurement.get("passes") is not True,
+                    "eager measurement evidence is incomplete",
+                ),
+                (
+                    eager_observed
+                    and eager_semantics is not None
+                    and eager_semantics.get("passes") is not True,
+                    "eager selectors or physical semantics are not comparable",
+                ),
+                (
+                    eager_observed
+                    and eager_validation is not None
+                    and eager_validation.get("passes") is not True,
+                    "eager numerical validation is not comparable or passing",
+                ),
+            )
+            if condition
+        ],
+    }
+    return {
+        "kind": "pyamplicol-three-lane-layout-capture",
+        "schema_version": CAPTURE_ACCEPTANCE_SCHEMA,
+        "complete": complete,
+        "evidence_complete": evidence_complete,
+        "passes": passes,
+        "authoritative_eligible": authoritative_eligible,
+        "authoritative_ineligibility_reasons": ineligibility_reasons,
+        "generation_specialized_axes_by_mode": specialized_axes_by_mode,
+        "incomplete_physical_axes": incomplete_physical_axes,
+        "required_modes": list(AUTHORITATIVE_EXECUTION_MODES),
+        "observed_modes": observed_modes,
+        "missing_modes": missing_modes,
+        "diagnostic_modes": list(DIAGNOSTIC_EXECUTION_MODES),
+        "eager_diagnostic": eager_diagnostic,
+        "required_batch_sizes": list(DEFAULT_BATCH_SIZES),
+        "observed_batch_sizes": list(arguments.batch_size),
+        "missing_batch_sizes": missing_batch_sizes,
+        "measurement_contract": measurement_contract,
+        "artifact_semantic_contract": artifact_semantic_contract,
+        "layout": arguments.lc_flow_layout,
+        "generation_only": arguments.generation_only,
+        "lane_self_validation_passes": (
+            None
+            if authoritative_validation is None
+            else authoritative_validation.get("lane_validation_passes")
+        ),
+        "pairwise_validation_passes": (
+            None
+            if authoritative_validation is None
+            else authoritative_validation.get("pairwise_validation_passes")
+        ),
+    }
+
+
+def _milestone0_acceptance_manifest(
+    arguments: argparse.Namespace,
+    capture: Mapping[str, object],
+) -> dict[str, object]:
+    """Describe the external evidence still required; never self-certify M0."""
+
+    missing_layouts = [
+        layout for layout in LC_FLOW_LAYOUTS if layout != arguments.lc_flow_layout
+    ]
+    missing_evidence: list[dict[str, object]] = [
+        {"kind": "layout_capture", "value": layout} for layout in missing_layouts
+    ]
+    missing_evidence.append({"kind": "external_lane", "value": "amplicol"})
+    if capture.get("complete") is not True:
+        missing_evidence.append(
+            {
+                "kind": "complete_current_layout_capture",
+                "value": arguments.lc_flow_layout,
+            }
+        )
+    elif capture.get("passes") is not True:
+        missing_evidence.append(
+            {
+                "kind": "passing_current_layout_capture",
+                "value": arguments.lc_flow_layout,
+            }
+        )
+    return {
+        "kind": M0_ACCEPTANCE_KIND,
+        "schema_version": M0_ACCEPTANCE_SCHEMA,
+        "accepted": False,
+        "status": "incomplete",
+        "required": {
+            "authoritative_execution_modes": list(AUTHORITATIVE_EXECUTION_MODES),
+            "diagnostic_execution_modes": list(DIAGNOSTIC_EXECUTION_MODES),
+            "lc_flow_layouts": list(LC_FLOW_LAYOUTS),
+            "batch_sizes": list(DEFAULT_BATCH_SIZES),
+            "external_lanes": ["amplicol"],
+            "generation_specialized_axes_allowed": False,
+            "timing": {
+                "minimum_native_wall_blocks_per_worker": (MIN_AUTHORITATIVE_SAMPLES),
+                "minimum_interleaved_worker_subprocesses_per_cell": (
+                    MIN_AUTHORITATIVE_SAMPLES
+                ),
+                "headline_source": "runtime_core_repeated_wall_time",
+                "statistics": "subprocess-median-and-raw-mad-v1",
+            },
+        },
+        "observed_current_layout_capture": dict(capture),
+        "missing_evidence": missing_evidence,
+        "integration_step": (
+            "A separate fail-closed orchestrator must combine content-hashed "
+            "topology-replay and all-flow-union captures with pinned AmpliCol "
+            "selected-flow and all-flow raw evidence containing at least seven "
+            "paired interleaved subprocess samples before "
+            "milestone 0 can be accepted."
+        ),
+    }
+
+
+def run(arguments: argparse.Namespace) -> dict[str, object]:
+    if (
+        getattr(arguments, "paired_profile_coordination_dir", None) is not None
+        and arguments.warmup_runs != 2
+    ):
+        raise HarnessError(
+            "paired migration captures require exactly two warmup runs"
+        )
+    started_at = _utc_now()
+    started = time.perf_counter()
+    source_identity = _git_source_identity()
+    runtime_provenance = _runtime_provenance(source_identity)
+    _validate_expected_runtime_identity(
+        source_identity,
+        runtime_provenance,
+        expected_source_revision=getattr(
+            arguments,
+            "expected_source_revision",
+            None,
+        ),
+        expected_native_build_inputs_sha256=getattr(
+            arguments,
+            "expected_native_build_inputs_sha256",
+            None,
+        ),
+    )
+    if arguments.prepared_model is not None:
+        try:
+            arguments.prepared_model = arguments.prepared_model.expanduser().resolve(
+                strict=True
+            )
+        except OSError as error:
+            raise HarnessError(
+                f"prepared model does not exist: {arguments.prepared_model}"
+            ) from error
+        if not arguments.prepared_model.is_file():
+            raise HarnessError(
+                f"prepared model is not a regular file: {arguments.prepared_model}"
+            )
+    output_root = arguments.output_root.resolve()
+    output_root.mkdir(parents=True, exist_ok=True)
+    result_json = (
+        arguments.result_json.resolve()
+        if arguments.result_json is not None
+        else output_root / "result.json"
+    )
+    layout_suffix = arguments.lc_flow_layout
+    all_artifacts = {
+        "recurrence": output_root / f"recurrence-{layout_suffix}",
+        "compiled": (
+            output_root
+            / f"compiled-jit-o{arguments.jit_optimization_level}-{layout_suffix}"
+        ),
+        "eager": (
+            output_root
+            / f"eager-jit-o{arguments.jit_optimization_level}-{layout_suffix}"
+        ),
+    }
+    artifacts = {mode: all_artifacts[mode] for mode in arguments.modes}
+    model_identities = {
+        mode: _selected_model_identity(
+            arguments,
+            mode=mode,
+            source_identity=source_identity,
+        )
+        for mode in arguments.modes
+    }
+    generation_signatures = {
+        mode: _semantic_generation_signature(
+            arguments,
+            mode=mode,
+            source_identity=source_identity,
+            runtime_provenance=runtime_provenance,
+            model_identity=model_identities[mode],
+        )
+        for mode in arguments.modes
+    }
+    generation: dict[str, dict[str, object]] = {}
+    artifact_baselines: dict[str, dict[str, object]] = {}
+    drift_rechecks: list[dict[str, object]] = []
+    for mode, artifact in artifacts.items():
+        signature = generation_signatures[mode]
+        if artifact.exists() and not arguments.force:
+            if not artifact.is_dir():
+                raise HarnessError(f"artifact path is not a directory: {artifact}")
+            artifact_identity, reuse_provenance = _require_reusable_artifact(
+                artifact,
+                expected_signature=signature,
+            )
+            record: dict[str, object] = {
+                "mode": mode,
+                "generation_wall_seconds": None,
+                "generation_reused": True,
+                "peak_rss": None,
+                "worker_command": None,
+                "original_generation_command": reuse_provenance["generation_command"],
+                "model_source": model_identities[mode],
+            }
+        else:
+            if arguments.reuse_only:
+                raise HarnessError(f"required artifact does not exist: {artifact}")
+            print(f"Generating {mode} artifact at {artifact}", file=sys.stderr)
+            record = _run_worker(
+                (
+                    "generate",
+                    "--mode",
+                    mode,
+                    "--artifact",
+                    str(artifact),
+                    "--write-mode",
+                    "replace" if arguments.force else "error",
+                    "--gluon-count",
+                    str(arguments.gluon_count),
+                    *(
+                        ()
+                        if arguments.process_expression is None
+                        else ("--process-expression", arguments.process_expression)
+                    ),
+                    "--validation-samples",
+                    str(arguments.validation_samples),
+                    "--point-tile-size",
+                    str(arguments.point_tile_size),
+                    "--jit-optimization-level",
+                    str(arguments.jit_optimization_level),
+                    "--lc-flow-layout",
+                    arguments.lc_flow_layout,
+                    *(
+                        ("--specialize-flow-at-generation",)
+                        if arguments.specialize_flow_at_generation
+                        else ()
+                    ),
+                    *(
+                        ()
+                        if arguments.prepared_model is None
+                        else ("--prepared-model", str(arguments.prepared_model))
+                    ),
+                ),
+                mode=mode,
+                phase="generation",
+                timeout_seconds=arguments.generation_timeout,
+            )
+            drift_rechecks.append(
+                _recheck_driver_state(
+                    source_identity,
+                    runtime_provenance,
+                    artifact_baselines,
+                    phase=f"after-{mode}-generation-worker",
+                )
+            )
+            generation_worker_result_evidence = _preserved_worker_result_evidence(
+                record
+            )
+            record.pop("worker_result_record", None)
+            worker_model_source = record.pop("model_source", None)
+            _validate_worker_model_identity(
+                model_identities[mode],
+                worker_model_source,
+            )
+            record["worker_reported_model_source"] = worker_model_source
+            record["model_source"] = model_identities[mode]
+            record["generation_worker_result_evidence"] = (
+                generation_worker_result_evidence
+            )
+            artifact_identity = _artifact_identity(artifact)
+            _write_reuse_signature(
+                artifact,
+                signature=signature,
+                artifact_identity=artifact_identity,
+                generation_command=record.get("worker_command"),
+            )
+            reuse_provenance = _json_object(
+                _reuse_signature_path(artifact),
+                label="artifact reuse signature",
+            )
+        effective_contract = _validate_artifact_contract(
+            artifact,
+            artifact_identity,
+            arguments=arguments,
+            mode=mode,
+        )
+        phases = _artifact_phases(artifact)
+        record.update(
+            {
+                "artifact": str(artifact),
+                "artifact_stats": _artifact_stats(artifact),
+                "artifact_identity": artifact_identity,
+                "artifact_semantic_identity": artifact_identity["semantic_identity"],
+                "artifact_semantic_identity_sha256": artifact_identity[
+                    "semantic_identity_sha256"
+                ],
+                "artifact_reuse_provenance": reuse_provenance,
+                "phase_timings_seconds": phases,
+                "phase_total_seconds": sum(phases.values()),
+                "effective_contract": effective_contract,
+                "semantic_generation_signature": signature,
+                "semantic_generation_signature_sha256": (_canonical_sha256(signature)),
+                "combined_reuse_semantic_signature_sha256": reuse_provenance[
+                    "semantic_signature_sha256"
+                ],
+                "reuse_signature": _path_identity(_reuse_signature_path(artifact)),
+            }
+        )
+        generation[mode] = record
+        artifact_baselines[mode] = _artifact_drift_baseline(
+            artifact,
+            generation_signature=signature,
+            artifact_identity=artifact_identity,
+            reuse_signature=reuse_provenance,
+        )
+        drift_rechecks.append(
+            _recheck_driver_state(
+                source_identity,
+                runtime_provenance,
+                artifact_baselines,
+                phase=f"after-{mode}-artifact-binding",
+            )
+        )
+
+    validation_point_artifact = artifacts.get(
+        "recurrence",
+        next(iter(artifacts.values())),
+    )
+    validation_worker_arguments: list[str] = [
+        "--validation-point-artifact",
+        str(validation_point_artifact),
+        "--target-runtime",
+        str(arguments.target_runtime),
+        "--minimum-samples",
+        str(arguments.minimum_samples),
+        "--warmup-runs",
+        str(arguments.warmup_runs),
+        "--color-flow",
+        arguments.color_flow,
+        "--helicity",
+        arguments.helicity,
+        "--lc-flow-layout",
+        arguments.lc_flow_layout,
+        "--gluon-count",
+        str(arguments.gluon_count),
+        *(
+            ()
+            if arguments.process_expression is None
+            else ("--process-expression", arguments.process_expression)
+        ),
+        "--validation-samples",
+        str(arguments.validation_samples),
+        "--jit-optimization-level",
+        str(arguments.jit_optimization_level),
+    ]
+    validation_preflight: dict[str, object] | None = None
+    preflight_profiles: dict[str, dict[str, Any]] = {}
+    preflight_worker_evidence: dict[str, dict[str, object]] = {}
+    if not arguments.generation_only:
+        for mode, artifact in artifacts.items():
+            generation_record = generation[mode]
+            scheduled_artifact_identity = generation_record["artifact_identity"]
+            scheduled_reuse_provenance = generation_record["artifact_reuse_provenance"]
+            assert isinstance(scheduled_artifact_identity, Mapping)
+            assert isinstance(scheduled_reuse_provenance, Mapping)
+            expectations = _profile_identity_expectations(
+                source_identity,
+                runtime_provenance,
+                scheduled_artifact_identity,
+                scheduled_reuse_provenance,
+                reuse_sidecar=_reuse_signature_path(artifact),
+            )
+            print(f"Validating {mode} lane before profiling", file=sys.stderr)
+            worker = _run_worker(
+                (
+                    "preflight",
+                    *validation_worker_arguments,
+                    "--mode",
+                    mode,
+                    "--artifact",
+                    str(artifact),
+                    *_profile_expectation_arguments(expectations),
+                ),
+                mode=mode,
+                phase="validation-preflight",
+                timeout_seconds=arguments.profile_timeout,
+            )
+            drift_rechecks.append(
+                _recheck_driver_state(
+                    source_identity,
+                    runtime_provenance,
+                    artifact_baselines,
+                    phase=f"after-{mode}-validation-preflight",
+                )
+            )
+            preflight_profiles[mode] = _preflight_profile_from_worker(worker)
+            verification = worker.get("pre_timing_verification")
+            assert isinstance(verification, Mapping)
+            fixture = preflight_profiles[mode]["validation"]
+            fixture_contract = (
+                _validation_fixture_contract(fixture, mode=mode)
+                if isinstance(fixture, Mapping)
+                else None
+            )
+            preflight_worker_evidence[mode] = {
+                "worker_invocation": worker.get("worker_invocation"),
+                "worker_process_record": worker.get("worker_process_record"),
+                "worker_result_record": worker.get("worker_result_record"),
+                "cold_load_seconds": worker.get("cold_load_seconds"),
+                "peak_rss_after_cold_load": worker.get("peak_rss_after_cold_load"),
+                "peak_rss_after_validation": worker.get("peak_rss_after_profile"),
+                "artifact_semantic_identity_sha256": verification.get(
+                    "artifact_semantic_identity_sha256"
+                ),
+                "validation_fixture": fixture_contract,
+            }
+        authoritative_preflight_profiles = {
+            mode: preflight_profiles[mode]
+            for mode in AUTHORITATIVE_EXECUTION_MODES
+            if mode in preflight_profiles
+        }
+        if not authoritative_preflight_profiles:
+            authoritative_preflight_profiles = dict(preflight_profiles)
+        validation_preflight = _require_validation_preflight(
+            arguments,
+            authoritative_preflight_profiles,
+        )
+        validation_preflight["worker_evidence"] = preflight_worker_evidence
+
+    worker_profile_arguments: list[str] = [
+        "profile",
+        *validation_worker_arguments,
+    ]
+    profile_schedule: dict[str, object] | None = None
+    paired_profile_coordination: dict[str, object] | None = None
+    profile_worker_results: list[dict[str, Any]] = []
+    if not arguments.generation_only:
+        profile_schedule = _build_profile_schedule(
+            arguments.modes,
+            arguments.batch_size,
+            subprocess_samples=arguments.subprocess_samples,
+        )
+        paired_profile_coordination = _initialize_paired_profile_coordination(
+            arguments,
+            source_identity=source_identity,
+            runtime_provenance=runtime_provenance,
+            profile_schedule=profile_schedule,
+            result_json=result_json,
+        )
+        raw_schedule_entries = profile_schedule["entries"]
+        assert isinstance(raw_schedule_entries, list)
+        for raw_entry in raw_schedule_entries:
+            assert isinstance(raw_entry, dict)
+            mode = str(raw_entry["mode"])
+            batch_size = int(raw_entry["batch_size"])
+            schedule_index = int(raw_entry["schedule_index"])
+            schedule_round = int(raw_entry["round"])
+            artifact = artifacts[mode]
+            generation_record = generation[mode]
+            scheduled_artifact_identity = generation_record["artifact_identity"]
+            scheduled_reuse_provenance = generation_record["artifact_reuse_provenance"]
+            assert isinstance(scheduled_artifact_identity, Mapping)
+            assert isinstance(scheduled_reuse_provenance, Mapping)
+            expectations = _profile_identity_expectations(
+                source_identity,
+                runtime_provenance,
+                scheduled_artifact_identity,
+                scheduled_reuse_provenance,
+                reuse_sidecar=_reuse_signature_path(artifact),
+            )
+            paired_token = _wait_for_paired_profile_token(arguments, raw_entry)
+            print(
+                f"Profiling schedule {schedule_index}: round {schedule_round}, "
+                f"{mode}, batch {batch_size}",
+                file=sys.stderr,
+            )
+            worker_result = _run_worker(
+                (
+                    *worker_profile_arguments,
+                    "--mode",
+                    mode,
+                    "--artifact",
+                    str(artifact),
+                    "--batch-size",
+                    str(batch_size),
+                    "--schedule-index",
+                    str(schedule_index),
+                    "--schedule-round",
+                    str(schedule_round),
+                    *_profile_expectation_arguments(expectations),
+                ),
+                mode=mode,
+                phase="profile",
+                timeout_seconds=arguments.profile_timeout,
+            )
+            drift_rechecks.append(
+                _recheck_driver_state(
+                    source_identity,
+                    runtime_provenance,
+                    artifact_baselines,
+                    phase=f"after-profile-worker-{schedule_index}",
+                )
+            )
+            verification = worker_result.get("pre_timing_verification")
+            invocation = worker_result.get("worker_invocation")
+            if not isinstance(verification, Mapping) or not isinstance(
+                invocation,
+                Mapping,
+            ):
+                raise HarnessError(
+                    f"profile worker {schedule_index} returned incomplete provenance"
+                )
+            raw_entry["worker_invocation"] = dict(invocation)
+            raw_entry["pre_timing_verification"] = _compact_profile_verification(
+                verification
+            )
+            result_record = worker_result.get("worker_result_record")
+            if not isinstance(result_record, Mapping):
+                raise HarnessError(
+                    f"profile worker {schedule_index} returned no result record"
+                )
+            raw_entry["worker_result_record"] = dict(result_record)
+            raw_entry["worker_result_sha256"] = result_record[
+                "addressed_payload_sha256"
+            ]
+            paired_completion = _record_paired_profile_completion(
+                arguments,
+                schedule_entry=raw_entry,
+                token=paired_token,
+                worker_result=worker_result,
+            )
+            if paired_completion is not None:
+                raw_entry["paired_profile_token"] = dict(paired_token or {})
+                raw_entry["paired_profile_completion"] = paired_completion
+                assert paired_profile_coordination is not None
+                completion_records = paired_profile_coordination["completion_records"]
+                assert isinstance(completion_records, list)
+                completion_records.append(paired_completion)
+            profile_worker_results.append(worker_result)
+
+    profiles = (
+        {}
+        if profile_schedule is None
+        else _aggregate_profile_workers(profile_schedule, profile_worker_results)
+    )
+
+    validation_summary = (
+        _pairwise_profile_validation(
+            profiles,
+            arguments=arguments,
+        )
+        if profiles
+        else None
+    )
+    capture = _capture_acceptance(
+        arguments,
+        profiles,
+        validation_summary,
+        profile_schedule=profile_schedule,
+    )
+    milestone0 = _milestone0_acceptance_manifest(arguments, capture)
+    recurrence_runtime_acceptance = _recurrence_runtime_acceptance(
+        arguments,
+        source_identity=source_identity,
+        runtime_provenance=runtime_provenance,
+        generation=generation,
+        profiles=profiles,
+        validation_summary=validation_summary,
+        profile_schedule=profile_schedule,
+    )
+    finished_at = _utc_now()
+    driver_command = getattr(arguments, "driver_command", None)
+    if not isinstance(driver_command, Mapping):
+        driver_command = _command_identity((sys.executable, str(DRIVER_PATH)))
+    payload: dict[str, object] = {
+        "kind": RESULT_KIND,
+        "schema_version": RESULT_SCHEMA,
+        "complete": capture["complete"],
+        "passes": capture["passes"],
+        "capture_acceptance": capture,
+        "milestone0_acceptance": milestone0,
+        "recurrence_runtime_acceptance": recurrence_runtime_acceptance,
+        "source": source_identity,
+        "runtime_provenance": runtime_provenance,
+        "provenance": {
+            "started_at_utc": started_at,
+            "finished_at_utc": finished_at,
+            "wall_seconds": time.perf_counter() - started,
+            "host": _host_identity(),
+            "working_directory": str(Path.cwd()),
+            "driver_command": dict(driver_command),
+            "post_worker_identity_rechecks": drift_rechecks,
+            "external_watchdog_required_for_long_runs": True,
+        },
+        "process": _selected_process(arguments),
+        "process_name": _selected_process_name(arguments),
+        "workload": (
+            "all-flows/runtime-selected-single-helicity"
+            if arguments.lc_flow_layout == "all-flow-union"
+            else "single-runtime-selected-flow/helicity-sum"
+        ),
+        "configuration": {
+            "batch_sizes": list(arguments.batch_size),
+            "target_runtime_seconds": arguments.target_runtime,
+            "minimum_samples": arguments.minimum_samples,
+            "subprocess_samples": arguments.subprocess_samples,
+            "warmup_runs": arguments.warmup_runs,
+            "generation_timeout_seconds": arguments.generation_timeout,
+            "profile_timeout_seconds": arguments.profile_timeout,
+            "color_flow_request": arguments.color_flow,
+            "helicity_request": arguments.helicity,
+            "lc_flow_layout": arguments.lc_flow_layout,
+            "gluon_count": arguments.gluon_count,
+            "validation_samples": arguments.validation_samples,
+            "point_tile_size": arguments.point_tile_size,
+            "jit_optimization_level": arguments.jit_optimization_level,
+            "validation_point_artifact": str(validation_point_artifact),
+            "generation_only": arguments.generation_only,
+            "allow_diagnostic_incomplete_success": (
+                arguments.allow_diagnostic_incomplete_success
+            ),
+            "modes": list(arguments.modes),
+            "prepared_model_path": (
+                None
+                if arguments.prepared_model is None
+                else str(arguments.prepared_model)
+            ),
+            "model_identities": model_identities,
+            "validation_seed": VALIDATION_SEED,
+            "specialize_flow_at_generation": (arguments.specialize_flow_at_generation),
+            "external_watchdog_required_for_long_runs": True,
+        },
+        "generation": generation,
+        "profile_schedule": profile_schedule,
+        "validation_preflight": validation_preflight,
+        "paired_profile_coordination": paired_profile_coordination,
+        "profiles": profiles,
+        "validation_summary": validation_summary,
+        "selector_contracts_match": (
+            None
+            if validation_summary is None
+            else validation_summary["selectors_match"]
+        ),
+        "validation_fixtures_match": (
+            None if validation_summary is None else validation_summary["fixtures_match"]
+        ),
+        "lane_comparisons": (
+            None if validation_summary is None else validation_summary["comparisons"]
+        ),
+        "result_json": str(result_json),
+    }
+    _write_json_atomic(result_json, payload)
+    return payload
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument(
+        "--output-root",
+        type=Path,
+        default=ROOT / ".artifacts" / "developer" / "recurrence-z6g",
+        help="artifact/result directory",
+    )
+    result.add_argument("--result-json", type=Path)
+    result.add_argument("--gluon-count", type=_positive_int, default=6)
+    result.add_argument(
+        "--process-expression",
+        help="explicit diagnostic process expression instead of the qq_Zng family",
+    )
+    result.add_argument("--validation-samples", type=_positive_int, default=10)
+    result.add_argument(
+        "--point-tile-size",
+        type=_positive_int,
+        default=1024,
+        help="recurrence workspace point stride used for cache-tiling experiments",
+    )
+    result.add_argument(
+        "--jit-optimization-level",
+        type=int,
+        choices=(0, 1, 2, 3),
+        default=2,
+        help="JIT optimization level used for generated artifacts (default: 2)",
+    )
+    result.add_argument(
+        "--prepared-model",
+        type=Path,
+        help="explicit prepared-model bundle used by every selected execution mode",
+    )
+    result.add_argument(
+        "--expected-source-revision",
+        help=(
+            "externally pinned clean source revision; must be supplied together "
+            "with --expected-native-build-inputs-sha256"
+        ),
+    )
+    result.add_argument(
+        "--expected-native-build-inputs-sha256",
+        help=(
+            "externally pinned native build-input digest; must be supplied "
+            "together with --expected-source-revision"
+        ),
+    )
+    result.add_argument(
+        "--generation-only",
+        action="store_true",
+        help="generate and report artifact statistics without runtime profiling",
+    )
+    result.add_argument(
+        "--allow-diagnostic-incomplete-success",
+        action="store_true",
+        help=(
+            "return success for an explicitly diagnostic incomplete capture; "
+            "authoritative incomplete captures fail by default"
+        ),
+    )
+    result.add_argument(
+        "--mode",
+        dest="modes",
+        choices=EXECUTION_MODES,
+        action="append",
+        help=(
+            "execution mode to generate/profile; repeat to select multiple "
+            "(default: compiled, eager, recurrence)"
+        ),
+    )
+    result.add_argument(
+        "--only-mode",
+        choices=EXECUTION_MODES,
+        help=argparse.SUPPRESS,
+    )
+    result.add_argument(
+        "--batch-size",
+        type=_positive_int,
+        action="append",
+        default=None,
+        help="native profiling batch size; repeat (default: 1, 128, and 1024)",
+    )
+    result.add_argument("--target-runtime", type=_positive_float, default=5.0)
+    result.add_argument(
+        "--generation-timeout",
+        type=_positive_float,
+        default=900.0,
+        help="maximum seconds for either generation worker (default: 900)",
+    )
+    result.add_argument(
+        "--profile-timeout",
+        type=_positive_float,
+        default=300.0,
+        help="maximum seconds for either profiling worker (default: 300)",
+    )
+    result.add_argument(
+        "--minimum-samples",
+        type=_positive_int,
+        default=MIN_AUTHORITATIVE_SAMPLES,
+        help="minimum native-wall timing blocks per subprocess (default: 7)",
+    )
+    result.add_argument(
+        "--subprocess-samples",
+        type=_positive_int,
+        default=MIN_AUTHORITATIVE_SAMPLES,
+        help=(
+            "independent interleaved worker subprocesses per mode/batch cell "
+            "(default: 7)"
+        ),
+    )
+    result.add_argument("--warmup-runs", type=int, default=2)
+    result.add_argument(
+        "--color-flow",
+        default="1",
+        help="one-based flow ordinal or stable flow ID (default: 1)",
+    )
+    result.add_argument(
+        "--helicity",
+        default="1",
+        help="one-based helicity ordinal or stable helicity ID (default: 1)",
+    )
+    result.add_argument(
+        "--lc-flow-layout",
+        choices=("topology-replay", "all-flow-union"),
+        default="topology-replay",
+        help="recurrence/compiled LC layout and matching benchmark workload",
+    )
+    result.add_argument(
+        "--force",
+        action="store_true",
+        help="replace every selected artifact before profiling",
+    )
+    result.add_argument(
+        "--specialize-flow-at-generation",
+        action="store_true",
+        help=(
+            "for topology-replay, generate a true one-flow artifact using the "
+            "requested stable flow ID or ordinal 1"
+        ),
+    )
+    result.add_argument(
+        "--reuse-only",
+        action="store_true",
+        help="fail rather than generate when any selected artifact is missing",
+    )
+    result.add_argument(
+        "--paired-profile-coordination-dir",
+        type=Path,
+        help=(
+            "workspace-local coordination directory used by the paired "
+            "baseline/candidate scheduler"
+        ),
+    )
+    result.add_argument(
+        "--paired-profile-role",
+        choices=("baseline", "candidate"),
+        help="role owned by this driver in a paired profile campaign",
+    )
+    result.add_argument(
+        "--paired-profile-session-id",
+        help="opaque scheduler session identifier for paired profiling",
+    )
+    result.add_argument(
+        "--paired-profile-wait-timeout",
+        type=_positive_float,
+        default=7200.0,
+        help="maximum seconds to wait for each paired scheduler token",
+    )
+    return result
+
+
+def _normalize_modes(arguments: argparse.Namespace) -> list[str]:
+    if arguments.only_mode is not None and arguments.modes is not None:
+        raise HarnessError("--only-mode cannot be combined with --mode")
+    if arguments.only_mode is not None:
+        return [arguments.only_mode]
+    if arguments.modes is None:
+        return list(EXECUTION_MODES)
+    if len(set(arguments.modes)) != len(arguments.modes):
+        raise HarnessError("execution modes must be unique")
+    return list(arguments.modes)
+
+
+def _normalize_batch_sizes(arguments: argparse.Namespace) -> list[int]:
+    if arguments.batch_size is None:
+        return list(DEFAULT_BATCH_SIZES)
+    if len(set(arguments.batch_size)) != len(arguments.batch_size):
+        raise HarnessError("batch sizes must be unique")
+    return list(arguments.batch_size)
+
+
+def _result_exit_code(
+    result: Mapping[str, object],
+    *,
+    allow_diagnostic_incomplete_success: bool,
+) -> int:
+    complete = result.get("complete")
+    passes = result.get("passes")
+    if complete is True and passes is True:
+        return 0
+    if complete is not True and passes is None and allow_diagnostic_incomplete_success:
+        return 0
+    return 1
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    values = list(sys.argv[1:] if argv is None else argv)
+    try:
+        if values[:1] == ["_worker"]:
+            return _worker_main(values[1:])
+        arguments = parser().parse_args(values)
+        if arguments.force and arguments.reuse_only:
+            raise HarnessError("--force and --reuse-only are mutually exclusive")
+        paired_fields = (
+            arguments.paired_profile_coordination_dir,
+            arguments.paired_profile_role,
+            arguments.paired_profile_session_id,
+        )
+        if any(value is not None for value in paired_fields) and not all(
+            value is not None for value in paired_fields
+        ):
+            raise HarnessError(
+                "paired profile coordination directory, role, and session ID "
+                "must be provided together"
+            )
+        if arguments.paired_profile_coordination_dir is not None:
+            if arguments.generation_only:
+                raise HarnessError(
+                    "paired profile coordination cannot be generation-only"
+                )
+            if (
+                not isinstance(arguments.paired_profile_session_id, str)
+                or re.fullmatch(
+                    r"[A-Za-z0-9][A-Za-z0-9_.-]{0,127}",
+                    arguments.paired_profile_session_id,
+                )
+                is None
+            ):
+                raise HarnessError("paired profile session ID is invalid")
+        arguments.modes = _normalize_modes(arguments)
+        arguments.batch_size = _normalize_batch_sizes(arguments)
+        arguments.driver_command = _command_identity(
+            (sys.executable, str(DRIVER_PATH), *values)
+        )
+        if arguments.warmup_runs < 0:
+            raise HarnessError("warmup runs must be non-negative")
+        result = run(arguments)
+    except (
+        HarnessError,
+        ImportError,
+        OSError,
+        RuntimeError,
+        ValueError,
+        json.JSONDecodeError,
+    ) as error:
+        print(f"recurrence-z6g-benchmark: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, indent=2, sort_keys=True, allow_nan=False))
+    return _result_exit_code(
+        result,
+        allow_diagnostic_incomplete_success=(
+            arguments.allow_diagnostic_incomplete_success
+        ),
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/reference_capture/__init__.py b/pyamplicol/tools/developer/reference_capture/__init__.py
new file mode 100644
index 0000000000..df72a20120
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_capture/__init__.py
@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: 0BSD
+"""Strict developer-only reference fixture capture helpers."""
+
+from .common import (
+    ANALYTIC_EVIDENCE_FILENAME,
+    BUNDLE_MANIFEST_FILENAME,
+    FORTRAN_EVIDENCE_FILENAME,
+    PHYSICS_FILENAME,
+    WATCHDOG_GB,
+    ArtifactCaptureSpec,
+    CaptureConfig,
+    CaptureError,
+    CapturePoint,
+    CaptureResult,
+    DependencySnapshot,
+    ProcessCaptureSpec,
+    RuntimeSnapshot,
+    SourceSnapshot,
+    StressMetric,
+    canonical_decimal,
+    decimal_digits_to_bits,
+)
+from .evidence import (
+    atomic_write_documents,
+    point_input_sha256,
+    validate_and_publish,
+)
+from .pipeline import run_capture
+from .points import (
+    build_reference_points,
+    stable_external_leg_ids,
+    validate_point_kinematics,
+)
+from .provenance import (
+    github_https_uri,
+    require_clean_tracked_tree,
+    tracked_source_tree_sha256,
+)
+
+__all__ = [
+    "ANALYTIC_EVIDENCE_FILENAME",
+    "BUNDLE_MANIFEST_FILENAME",
+    "FORTRAN_EVIDENCE_FILENAME",
+    "PHYSICS_FILENAME",
+    "WATCHDOG_GB",
+    "ArtifactCaptureSpec",
+    "CaptureConfig",
+    "CaptureError",
+    "CapturePoint",
+    "CaptureResult",
+    "DependencySnapshot",
+    "ProcessCaptureSpec",
+    "RuntimeSnapshot",
+    "SourceSnapshot",
+    "StressMetric",
+    "atomic_write_documents",
+    "build_reference_points",
+    "canonical_decimal",
+    "decimal_digits_to_bits",
+    "github_https_uri",
+    "point_input_sha256",
+    "require_clean_tracked_tree",
+    "run_capture",
+    "stable_external_leg_ids",
+    "tracked_source_tree_sha256",
+    "validate_and_publish",
+    "validate_point_kinematics",
+]
diff --git a/pyamplicol/tools/developer/reference_capture/artifacts.py b/pyamplicol/tools/developer/reference_capture/artifacts.py
new file mode 100644
index 0000000000..ac83b8e50a
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_capture/artifacts.py
@@ -0,0 +1,1035 @@
+# SPDX-License-Identifier: 0BSD
+"""Artifact generation, runtime extraction, and fixture assembly."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import json
+import sys
+from collections.abc import Mapping, Sequence
+from decimal import Decimal
+from itertools import product
+from pathlib import Path
+from typing import Any, Literal, cast
+
+from .common import (
+    ANALYTIC_CERTIFIED_DIGITS,
+    ANALYTIC_EVIDENCE_SET_ID,
+    FORTRAN_CERTIFIED_DIGITS,
+    FORTRAN_EVIDENCE_SET_ID,
+    MODEL_ASSETS,
+    OBSERVATION_PRECISION,
+    ROOT,
+    WATCHDOG_GB,
+    ArtifactCaptureSpec,
+    CaptureError,
+    CapturePoint,
+    DependencySnapshot,
+    ProcessCaptureSpec,
+    RuntimeSnapshot,
+    SourceSnapshot,
+    as_mapping,
+    as_sequence,
+    canonical_decimal,
+    decimal_digits_to_bits,
+    developer_module,
+)
+from .points import build_reference_points, stable_external_leg_ids
+
+SM_ONE_BODY_PROCESSES = (
+    ProcessCaptureSpec(
+        "sm_ddbar_z",
+        "d d~ > z",
+        "model:builtin-sm",
+        ("0", "0", "91.188"),
+        "exact-2to1",
+    ),
+    ProcessCaptureSpec(
+        "sm_udbar_wplus",
+        "u d~ > w+",
+        "model:builtin-sm",
+        ("0", "0", "80.41900244575616"),
+        "exact-2to1",
+    ),
+)
+SM_TWO_BODY_PROCESSES = (
+    ProcessCaptureSpec(
+        "sm_ddbar_zg",
+        "d d~ > z g",
+        "model:builtin-sm",
+        ("0", "0", "91.188", "0"),
+        "seeded-two-body",
+        (104729, 104759, 104761),
+    ),
+    ProcessCaptureSpec(
+        "sm_ddbar_ee",
+        "d d~ > e- e+",
+        "model:builtin-sm",
+        ("0", "0", "0", "0"),
+        "seeded-two-body",
+        (196613, 196643, 196657),
+    ),
+    ProcessCaptureSpec(
+        "sm_ddbar_uubar",
+        "d d~ > u u~",
+        "model:builtin-sm",
+        ("0", "0", "0", "0"),
+        "seeded-two-body",
+        (221603, 221621, 221623),
+    ),
+    ProcessCaptureSpec(
+        "sm_ddbar_ddbar",
+        "d d~ > d d~",
+        "model:builtin-sm",
+        ("0", "0", "0", "0"),
+        "seeded-two-body",
+        (234803, 234811, 234817),
+    ),
+    ProcessCaptureSpec(
+        "sm_gg_gg",
+        "g g > g g",
+        "model:builtin-sm",
+        ("0", "0", "0", "0"),
+        "seeded-two-body",
+        (246613, 246631, 246637),
+    ),
+    ProcessCaptureSpec(
+        "sm_gg_ttbar",
+        "g g > t t~",
+        "model:builtin-sm",
+        ("0", "0", "173", "173"),
+        "seeded-two-body",
+        (271603, 271619, 271637),
+    ),
+)
+SM_THREE_BODY_PROCESSES = (
+    ProcessCaptureSpec(
+        "sm_ddbar_zgg",
+        "d d~ > z g g",
+        "model:builtin-sm",
+        ("0", "0", "91.188", "0", "0"),
+        "one-massive-two-massless",
+        (130363, 130367, 130369),
+    ),
+)
+SCALAR_PROCESS = ProcessCaptureSpec(
+    "scalars_2to2",
+    "scalar_0 scalar_0 > scalar_0 scalar_0",
+    "model:scalars-json",
+    ("0", "0", "0", "0"),
+    "seeded-two-body",
+    (155921, 155933, 155947),
+)
+SCALAR_GRAVITY_PROCESS = ProcessCaptureSpec(
+    "scalar_gravity_2to2",
+    "scalar_0 scalar_0 > graviton graviton",
+    "model:scalar-gravity-json",
+    ("0", "0", "0", "0"),
+    "seeded-two-body",
+    (181081, 181087, 181123),
+)
+
+
+def artifact_capture_specs(artifact_root: Path) -> tuple[ArtifactCaptureSpec, ...]:
+    """Return the fixed named process ladder captured under ``artifact_root``."""
+
+    del artifact_root
+    scalar_source = MODEL_ASSETS / "scalars" / "scalars.json"
+    gravity_source = MODEL_ASSETS / "scalar_gravity" / "scalar_gravity.json"
+    return (
+        *(
+            ArtifactCaptureSpec(
+                id=f"builtin-sm-one-body-{accuracy}",
+                directory_name=f"builtin-sm-one-body-{accuracy}",
+                model_id="model:builtin-sm",
+                model_source=None,
+                color_accuracy=cast(Literal["lc", "nlc", "full"], accuracy),
+                processes=SM_ONE_BODY_PROCESSES,
+            )
+            for accuracy in ("lc", "nlc", "full")
+        ),
+        *(
+            ArtifactCaptureSpec(
+                id=f"builtin-sm-two-body-{accuracy}",
+                directory_name=f"builtin-sm-two-body-{accuracy}",
+                model_id="model:builtin-sm",
+                model_source=None,
+                color_accuracy=cast(Literal["lc", "nlc", "full"], accuracy),
+                processes=SM_TWO_BODY_PROCESSES,
+            )
+            for accuracy in ("lc", "nlc", "full")
+        ),
+        ArtifactCaptureSpec(
+            id="scalars-json-lc",
+            directory_name="scalars-json-lc",
+            model_id="model:scalars-json",
+            model_source=scalar_source,
+            color_accuracy="lc",
+            processes=(SCALAR_PROCESS,),
+        ),
+        ArtifactCaptureSpec(
+            id="scalar-gravity-json-lc",
+            directory_name="scalar-gravity-json-lc",
+            model_id="model:scalar-gravity-json",
+            model_source=gravity_source,
+            color_accuracy="lc",
+            processes=(SCALAR_GRAVITY_PROCESS,),
+        ),
+        *(
+            ArtifactCaptureSpec(
+                id=f"builtin-sm-three-body-{accuracy}",
+                directory_name=f"builtin-sm-three-body-{accuracy}",
+                model_id="model:builtin-sm",
+                model_source=None,
+                color_accuracy=cast(Literal["lc", "nlc", "full"], accuracy),
+                processes=SM_THREE_BODY_PROCESSES,
+            )
+            for accuracy in ("lc", "nlc", "full")
+        ),
+    )
+
+
+def _api_types() -> tuple[Any, Any, Any, Any, Any]:
+    root_text = str(ROOT)
+    if root_text not in sys.path:
+        sys.path.insert(0, root_text)
+    api = importlib.import_module("pyamplicol")
+    config = importlib.import_module("pyamplicol.config")
+    return (
+        api.Generator,
+        api.ModelSource,
+        api.ProcessRequest,
+        api.ProcessSet,
+        config,
+    )
+
+
+def materialize_artifacts(
+    specs: Sequence[ArtifactCaptureSpec],
+    artifact_root: Path,
+    mode: Literal["generate", "reuse"],
+) -> dict[str, Path]:
+    """Generate without replacement or explicitly validate retained locations."""
+
+    if mode not in {"generate", "reuse"}:
+        raise CaptureError(f"unsupported artifact mode {mode!r}")
+    paths = {spec.id: artifact_root / spec.directory_name for spec in specs}
+    if mode == "reuse":
+        missing = [
+            path for path in paths.values() if not (path / "artifact.json").is_file()
+        ]
+        if missing:
+            rendered = ", ".join(str(path) for path in missing)
+            raise CaptureError(
+                "explicit artifact reuse requested, but schema-v3 manifests are "
+                f"missing from: {rendered}"
+            )
+        return paths
+
+    Generator, ModelSource, ProcessRequest, ProcessSet, config_module = _api_types()
+    artifact_root.mkdir(parents=True, exist_ok=True)
+    for spec in specs:
+        destination = paths[spec.id]
+        if destination.exists():
+            raise CaptureError(
+                f"artifact destination already exists: {destination}; use "
+                "--reuse-artifacts to retain and reuse it, or choose a new root"
+            )
+        process_set = ProcessSet(
+            tuple(
+                ProcessRequest.parse(process.expression, name=process.id)
+                for process in spec.processes
+            )
+        )
+        run_config = config_module.RunConfig(
+            action="generate",
+            color=config_module.ColorConfig(accuracy=spec.color_accuracy),
+            generation=config_module.GenerationConfig(
+                validation=config_module.GenerationValidationConfig(samples=10)
+            ),
+        )
+        model = (
+            None
+            if spec.model_source is None
+            else ModelSource.from_path(spec.model_source)
+        )
+        try:
+            result = Generator(run_config).generate(
+                process_set,
+                destination,
+                model=model,
+                mode="error",
+            )
+        except Exception as error:
+            raise CaptureError(
+                f"schema-v3 generation failed for {spec.id}; any completed artifacts "
+                f"remain under {artifact_root}: {error}"
+            ) from error
+        if result.schema_version != 3 or result.output != destination.resolve():
+            raise CaptureError(
+                f"generation returned invalid result metadata for {spec.id}"
+            )
+    return paths
+
+
+def _read_json(path: Path) -> Mapping[str, object]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"), parse_float=Decimal)
+    except (OSError, json.JSONDecodeError) as error:
+        raise CaptureError(f"cannot read artifact JSON {path}: {error}") from error
+    return as_mapping(value, str(path))
+
+
+def _load_manifest(path: Path) -> Any:
+    root_text = str(ROOT)
+    if root_text not in sys.path:
+        sys.path.insert(0, root_text)
+    artifacts = importlib.import_module("pyamplicol.artifacts")
+    try:
+        return artifacts.load_manifest(path, verify_payloads=True)
+    except Exception as error:
+        raise CaptureError(
+            f"invalid retained schema-v3 artifact {path}: {error}"
+        ) from error
+
+
+def _load_runtime(path: Path, process_id: str) -> Any:
+    root_text = str(ROOT)
+    if root_text not in sys.path:
+        sys.path.insert(0, root_text)
+    api = importlib.import_module("pyamplicol")
+    try:
+        return api.Runtime.load(path, process=process_id)
+    except Exception as error:
+        raise CaptureError(
+            f"cannot load runtime for {process_id!r} from {path}: {error}"
+        ) from error
+
+
+def _payload_record(manifest: Any, role: str, process_id: str | None) -> Any:
+    matches = tuple(
+        record
+        for record in manifest.payloads
+        if record.role == role and record.process_id == process_id
+    )
+    if len(matches) != 1:
+        scope = "model" if process_id is None else f"process {process_id}"
+        raise CaptureError(
+            f"artifact {manifest.root} must contain exactly one {role} payload for "
+            f"{scope}; found {len(matches)}"
+        )
+    return matches[0]
+
+
+def _artifact_process(manifest: Any, process_id: str) -> Mapping[str, object]:
+    matches = tuple(
+        process for process in manifest.processes if process["id"] == process_id
+    )
+    if len(matches) != 1:
+        raise CaptureError(
+            f"artifact {manifest.root} does not contain exactly one process "
+            f"{process_id}"
+        )
+    return cast(Mapping[str, object], matches[0])
+
+
+def _json_number(value: object, where: str) -> str:
+    if isinstance(value, (Decimal, float, int)) and not isinstance(value, bool):
+        return canonical_decimal(value)
+    raise CaptureError(f"{where} is not a finite JSON number")
+
+
+def _compiled_model_contract_sha256(compiled: Mapping[str, object]) -> str:
+    semantic_payload = {
+        key: value
+        for key, value in compiled.items()
+        if key not in {"conversion_seconds", "phase_timings"}
+    }
+    encoded = _canonical_json_bytes(semantic_payload)
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _canonical_json_bytes(value: object) -> bytes:
+    if value is None:
+        return b"null"
+    if isinstance(value, bool):
+        return b"true" if value else b"false"
+    if isinstance(value, int):
+        return str(value).encode("ascii")
+    if isinstance(value, (Decimal, float)):
+        return canonical_decimal(value).encode("ascii")
+    if isinstance(value, str):
+        return json.dumps(value, ensure_ascii=True).encode("ascii")
+    if isinstance(value, Mapping):
+        if not all(isinstance(key, str) for key in value):
+            raise CaptureError("canonical compiled-model JSON has a non-string key")
+        members = (
+            json.dumps(key, ensure_ascii=True).encode("ascii")
+            + b":"
+            + _canonical_json_bytes(value[key])
+            for key in sorted(cast(Mapping[str, object], value))
+        )
+        return b"{" + b",".join(members) + b"}"
+    if isinstance(value, Sequence) and not isinstance(value, (bytes, bytearray, str)):
+        return b"[" + b",".join(_canonical_json_bytes(item) for item in value) + b"]"
+    raise CaptureError(
+        f"canonical compiled-model JSON contains unsupported {type(value).__name__}"
+    )
+
+
+def _model_payload(
+    spec: ArtifactCaptureSpec,
+    manifest: Any,
+    dependencies: DependencySnapshot,
+    compiled: Mapping[str, object],
+) -> dict[str, object]:
+    if compiled.get("schema_version") != manifest.model["compiled_schema_version"]:
+        raise CaptureError(f"compiled-model schema mismatch in {manifest.root}")
+    source = as_mapping(compiled.get("source"), "compiled-model.source")
+    if source.get("digest") != manifest.model["content_sha256"]:
+        raise CaptureError(f"compiled-model source digest mismatch in {manifest.root}")
+    defaults = as_mapping(
+        compiled.get("parameter_defaults"), "compiled-model.parameter_defaults"
+    )
+    parameter_defaults: dict[str, object] = {}
+    for name, raw_value in sorted(defaults.items()):
+        components = as_sequence(raw_value, f"parameter_defaults.{name}")
+        if len(components) != 2:
+            raise CaptureError(f"model parameter {name!r} is not complex-valued")
+        parameter_defaults[str(name)] = {
+            "real": _json_number(components[0], f"parameter_defaults.{name}.real"),
+            "imag": _json_number(components[1], f"parameter_defaults.{name}.imag"),
+        }
+
+    lock = dependencies.release_lock
+    symbolica = as_mapping(lock.get("symbolica"), "release-lock.symbolica")
+    loader = as_mapping(lock.get("ufo_model_loader"), "release-lock.ufo_model_loader")
+    producer = as_mapping(compiled.get("producer"), "compiled-model.producer")
+    if producer.get("symbolica") != symbolica["python_version"]:
+        raise CaptureError(
+            "compiled model was not produced by release-locked Symbolica"
+        )
+    if producer.get("ufo_model_loader") != loader["required_version"]:
+        raise CaptureError(
+            "compiled model was not produced by release-locked ufo-model-loader"
+        )
+    artifact_symbolica = tuple(
+        dependency
+        for dependency in manifest.dependencies
+        if str(dependency["name"]).lower() == "symbolica"
+    )
+    if len(artifact_symbolica) != 1 or (
+        artifact_symbolica[0]["version"] != symbolica["python_version"]
+    ):
+        raise CaptureError("artifact dependency metadata disagrees with release lock")
+
+    return {
+        "id": spec.model_id,
+        "name": str(manifest.model["name"]),
+        "source_kind": str(manifest.model["source_kind"]),
+        "content_sha256": str(manifest.model["content_sha256"]),
+        "compiled_model_sha256": _compiled_model_contract_sha256(compiled),
+        "compiled_schema_version": int(manifest.model["compiled_schema_version"]),
+        "restriction": manifest.model.get("restriction"),
+        "dependency_ids": [
+            "dependency:pyamplicol-candidate",
+            "dependency:release-lock",
+            "dependency:install-state",
+            "dependency:symbolica",
+            "dependency:symjit",
+            "dependency:ufo-model-loader",
+        ],
+        "parameter_defaults": parameter_defaults,
+    }
+
+
+def _external_model_metadata(
+    process_id: str,
+    pdgs: Sequence[int],
+    compiled: Mapping[str, object],
+) -> tuple[tuple[int, ...], tuple[int, ...], tuple[Decimal, ...]]:
+    ir = as_mapping(compiled.get("ir"), "compiled-model.ir")
+    raw_particles = as_sequence(ir.get("particles"), "compiled-model.ir.particles")
+    particle_by_pdg: dict[int, Mapping[str, object]] = {}
+    for index, raw_particle in enumerate(raw_particles):
+        particle = as_mapping(raw_particle, f"compiled-model.ir.particles[{index}]")
+        pdg = particle.get("pdg_code")
+        if isinstance(pdg, bool) or not isinstance(pdg, int):
+            raise CaptureError("compiled-model particle PDG is not an integer")
+        if pdg in particle_by_pdg:
+            raise CaptureError(f"compiled-model contains duplicate particle PDG {pdg}")
+        particle_by_pdg[pdg] = particle
+    defaults = as_mapping(
+        compiled.get("parameter_defaults"), "compiled-model.parameter_defaults"
+    )
+    spins: list[int] = []
+    colors: list[int] = []
+    masses: list[Decimal] = []
+    for pdg in pdgs:
+        external_particle = particle_by_pdg.get(pdg)
+        if external_particle is None:
+            raise CaptureError(f"{process_id} PDG {pdg} is absent from compiled model")
+        if external_particle.get("propagating") is not True:
+            raise CaptureError(f"{process_id} PDG {pdg} is not a propagating particle")
+        spin = external_particle.get("spin")
+        color = external_particle.get("color")
+        if isinstance(spin, bool) or not isinstance(spin, int) or spin < 1:
+            raise CaptureError(f"{process_id} PDG {pdg} has invalid UFO spin")
+        if isinstance(color, bool) or not isinstance(color, int):
+            raise CaptureError(
+                f"{process_id} PDG {pdg} has invalid color representation"
+            )
+        mass_name = external_particle.get("mass")
+        if not isinstance(mass_name, str) or not mass_name:
+            raise CaptureError(f"{process_id} PDG {pdg} has invalid mass metadata")
+        if mass_name == "ZERO":
+            mass = Decimal(0)
+        else:
+            components = as_sequence(
+                defaults.get(mass_name),
+                f"compiled-model.parameter_defaults.{mass_name}",
+            )
+            if len(components) != 2:
+                raise CaptureError(
+                    f"mass parameter {mass_name!r} is not complex-valued"
+                )
+            mass = Decimal(str(components[0]))
+            imaginary = Decimal(str(components[1]))
+            if not mass.is_finite() or mass < 0 or imaginary != 0:
+                raise CaptureError(
+                    f"mass parameter {mass_name!r} is not finite, real, and "
+                    "non-negative"
+                )
+        spins.append(spin)
+        colors.append(color)
+        masses.append(mass)
+    return tuple(spins), tuple(colors), tuple(masses)
+
+
+def _physical_helicity_domain(spin: int, mass: Decimal) -> tuple[int, ...]:
+    if spin == 1:
+        return (0,)
+    if spin % 2 == 0:
+        return tuple(range(-(spin - 1), spin, 2))
+    physical_spin = (spin - 1) // 2
+    if mass == 0:
+        return (-physical_spin, physical_spin)
+    return tuple(range(-physical_spin, physical_spin + 1))
+
+
+def _process_payload(
+    process_spec: ProcessCaptureSpec,
+    manifest_process: Mapping[str, object],
+    physics: Any,
+    compiled: Mapping[str, object],
+) -> dict[str, object]:
+    particles = tuple(sorted(physics.external_particles, key=lambda item: item.index))
+    indices = tuple(particle.index for particle in particles)
+    if indices != tuple(range(len(particles))):
+        raise CaptureError(f"{process_spec.id} external-particle indices are not dense")
+    pdgs = tuple(particle.pdg_id for particle in particles)
+    manifest_pdg_values = as_sequence(
+        manifest_process.get("external_pdgs"),
+        f"{process_spec.id} manifest external_pdgs",
+    )
+    if any(
+        isinstance(value, bool) or not isinstance(value, int)
+        for value in manifest_pdg_values
+    ):
+        raise CaptureError(f"{process_spec.id} manifest PDGs are not integers")
+    manifest_pdgs = tuple(cast(int, value) for value in manifest_pdg_values)
+    if pdgs != manifest_pdgs:
+        raise CaptureError(f"{process_spec.id} runtime and manifest PDG order differs")
+    if physics.process != process_spec.expression or (
+        manifest_process["expression"] != process_spec.expression
+    ):
+        raise CaptureError(
+            f"{process_spec.id} process expression is not the named input"
+        )
+    if physics.helicity_coverage != "complete":
+        raise CaptureError(
+            f"{process_spec.id} lacks complete runtime helicity coverage"
+        )
+    spins, colors, masses = _external_model_metadata(process_spec.id, pdgs, compiled)
+    domains = tuple(
+        _physical_helicity_domain(spin, mass)
+        for spin, mass in zip(spins, masses, strict=True)
+    )
+    complete_axis = set(product(*domains))
+    actual_axis = {tuple(helicity.values) for helicity in physics.helicities}
+    if actual_axis != complete_axis:
+        raise CaptureError(
+            f"{process_spec.id} runtime axis does not span its per-leg domains"
+        )
+    return {
+        "id": process_spec.id,
+        "expression": process_spec.expression,
+        "external_pdgs": list(pdgs),
+        "external_labels": [particle.label for particle in particles],
+        "external_leg_ids": list(stable_external_leg_ids(particles)),
+        "external_spins": list(spins),
+        "external_colors": list(colors),
+        "external_masses": [canonical_decimal(mass) for mass in masses],
+        "external_helicity_domains": [list(domain) for domain in domains],
+        "initial_state_count": sum(
+            particle.state == "incoming" for particle in particles
+        ),
+        "alias_of": None,
+        "final_state_permutation": None,
+    }
+
+
+def _axis_payload(physics: Any) -> dict[str, object]:
+    helicities = [
+        {
+            "id": helicity.id,
+            "index": helicity.index,
+            "values": list(helicity.values),
+            "computed": helicity.computed,
+            "structural_zero": helicity.structural_zero,
+            "representative_id": helicity.representative_id,
+            "coefficient": canonical_decimal(helicity.coefficient),
+        }
+        for helicity in physics.helicities
+    ]
+    if physics.color_accuracy == "lc":
+        colors = [
+            {
+                "kind": "lc-flow",
+                "id": color.id,
+                "index": color.index,
+                "word": list(color.word),
+                "computed": color.computed,
+                "representative_id": color.representative_id,
+                "coefficient": canonical_decimal(color.coefficient),
+            }
+            for color in physics.color_flows
+        ]
+    else:
+        colors = [
+            {
+                "kind": "contracted-color",
+                "id": color.id,
+                "index": color.index,
+                "description": color.description,
+            }
+            for color in physics.contracted_color_components
+        ]
+    return {"helicities": helicities, "colors": colors}
+
+
+def _normalization_payload(
+    physics_payload: Mapping[str, object],
+    color_accuracy: str,
+) -> dict[str, object]:
+    extensions = as_mapping(physics_payload.get("extensions"), "physics.extensions")
+    normalization = as_mapping(
+        extensions.get("normalization"), "physics.extensions.normalization"
+    )
+    if normalization.get("color_accuracy") != color_accuracy:
+        raise CaptureError("runtime normalization color accuracy is inconsistent")
+    coupling_flag = normalization.get("couplings_in_stage_evaluators")
+    if not isinstance(coupling_flag, bool):
+        raise CaptureError(
+            "normalization.couplings_in_stage_evaluators must be boolean"
+        )
+    return {
+        "average_factor": _json_number(
+            normalization.get("average_factor"), "normalization.average_factor"
+        ),
+        "color_factor": _json_number(
+            normalization.get("color_factor"), "normalization.color_factor"
+        ),
+        "identical_factor": _json_number(
+            normalization.get("identical_factor"), "normalization.identical_factor"
+        ),
+        "global_coupling_factor": _json_number(
+            normalization.get("global_coupling_factor"),
+            "normalization.global_coupling_factor",
+        ),
+        "quark_line_partner_factor": _json_number(
+            normalization.get("quark_line_partner_factor", 1),
+            "normalization.quark_line_partner_factor",
+        ),
+        "couplings_in_stage_evaluators": coupling_flag,
+    }
+
+
+def _topology_payload(
+    execution_payload: Mapping[str, object], physics: Any
+) -> dict[str, object]:
+    summary = as_mapping(execution_payload.get("dag_summary"), "execution.dag_summary")
+    required = ("current_count", "interaction_count", "amplitude_root_count")
+    if any(
+        isinstance(summary.get(name), bool) or not isinstance(summary.get(name), int)
+        for name in required
+    ):
+        raise CaptureError(
+            "execution DAG summary does not contain integer topology counts"
+        )
+    return {
+        "currents": int(cast(int, summary["current_count"])),
+        "interactions": int(cast(int, summary["interaction_count"])),
+        "roots": int(cast(int, summary["amplitude_root_count"])),
+        "reduction_groups": len(physics.reduction.groups),
+    }
+
+
+def _reduction_payload(physics: Any, *, lc: bool) -> dict[str, object]:
+    groups = [
+        {
+            "id": str(group.id),
+            "representative_helicity_id": str(group.representative_helicity_id),
+            "representative_color_id": str(group.representative_color_id),
+            "physical_helicity_ids": [
+                str(identifier) for identifier in group.physical_helicity_ids
+            ],
+            "physical_color_ids": [
+                str(identifier) for identifier in group.physical_color_ids
+            ],
+        }
+        for group in physics.reduction.groups
+    ]
+    if not groups:
+        raise CaptureError("runtime physics metadata has no reduction groups")
+    return {
+        "kind": physics.reduction.kind,
+        "cell_semantics": (
+            "sum-all-contributing-groups" if lc else "fully-contracted-color"
+        ),
+        "groups": groups,
+        "plan_sha256": "0" * 64,
+    }
+
+
+def _exact_decimal_sum(values: Sequence[Decimal]) -> Decimal:
+    if not values:
+        return Decimal(0)
+    if not all(value.is_finite() for value in values):
+        raise CaptureError("runtime returned a non-finite resolved observation")
+
+    def finite_exponent(value: Decimal) -> int:
+        exponent = value.as_tuple().exponent
+        if not isinstance(exponent, int):
+            raise CaptureError("finite Decimal has a non-integral exponent")
+        return exponent
+
+    common_exponent = min(finite_exponent(value) for value in values)
+    total = 0
+    for value in values:
+        sign, digits, _ = value.as_tuple()
+        exponent = finite_exponent(value)
+        coefficient = int("".join(str(digit) for digit in digits) or "0")
+        if sign:
+            coefficient = -coefficient
+        total += coefficient * 10 ** (exponent - common_exponent)
+    if total == 0:
+        return Decimal(0)
+    digits = tuple(int(character) for character in str(abs(total)))
+    return Decimal((int(total < 0), digits, common_exponent))
+
+
+def _resolved_observations(
+    runtime: Any,
+    physics: Any,
+    points: Sequence[CapturePoint],
+    evidence_ids: Sequence[str],
+    certified_digits: int,
+) -> list[dict[str, object]]:
+    momenta = tuple(point.momenta for point in points)
+    try:
+        resolved = runtime.evaluate_resolved(momenta, precision=OBSERVATION_PRECISION)
+    except Exception as error:
+        raise CaptureError(
+            f"p{OBSERVATION_PRECISION} resolved evaluation failed for "
+            f"{physics.process_id}: {error}"
+        ) from error
+    if resolved.helicity_ids != physics.helicity_ids or (
+        resolved.color_ids != physics.color_ids
+    ):
+        raise CaptureError(
+            f"resolved output axes differ from runtime physics for {physics.process_id}"
+        )
+    if len(resolved.values) != len(points):
+        raise CaptureError(f"runtime omitted points for {physics.process_id}")
+    observations: list[dict[str, object]] = []
+    for point, point_values, evidence_id in zip(
+        points, resolved.values, evidence_ids, strict=True
+    ):
+        rows: list[list[str]] = []
+        flat: list[Decimal] = []
+        for helicity, raw_row in zip(physics.helicities, point_values, strict=True):
+            row: list[str] = []
+            for raw_value in raw_row:
+                if not isinstance(raw_value, Decimal) or not raw_value.is_finite():
+                    raise CaptureError(
+                        "p80 runtime returned a non-Decimal cell for "
+                        f"{physics.process_id}"
+                    )
+                if helicity.structural_zero and raw_value != 0:
+                    raise CaptureError(
+                        f"runtime violated structural zero {helicity.id} at {point.id}"
+                    )
+                flat.append(raw_value)
+                row.append(canonical_decimal(raw_value))
+            rows.append(row)
+        total = _exact_decimal_sum(flat)
+        observations.append(
+            {
+                "point_id": point.id,
+                "arithmetic_precision_bits": decimal_digits_to_bits(
+                    OBSERVATION_PRECISION
+                ),
+                "round_trip_decimal_digits": OBSERVATION_PRECISION,
+                "certified_decimal_digits": certified_digits,
+                "values": rows,
+                "total": canonical_decimal(total),
+                "evidence_refs": [evidence_id],
+            }
+        )
+    return observations
+
+
+def _case_payload(
+    spec: ArtifactCaptureSpec,
+    process_spec: ProcessCaptureSpec,
+    manifest: Any,
+    manifest_process: Mapping[str, object],
+    runtime: Any,
+    points: Sequence[CapturePoint],
+) -> dict[str, object]:
+    physics = runtime.physics
+    physics_record = _payload_record(manifest, "runtime-physics", process_spec.id)
+    execution_record = _payload_record(manifest, "evaluator-manifest", process_spec.id)
+    physics_payload = _read_json(manifest.root / physics_record.path)
+    execution_payload = _read_json(manifest.root / execution_record.path)
+    if physics_payload.get("process_id") != process_spec.id or (
+        execution_payload.get("process") != process_spec.expression
+    ):
+        raise CaptureError(f"artifact payload identity mismatch for {process_spec.id}")
+    if physics.color_accuracy != spec.color_accuracy or (
+        manifest_process["color_accuracy"] != spec.color_accuracy
+    ):
+        raise CaptureError(f"artifact color accuracy mismatch for {process_spec.id}")
+    axes = _axis_payload(physics)
+    color_count = len(cast(Sequence[object], axes["colors"]))
+    capabilities = set(physics.selector_capabilities)
+    if "helicity" not in capabilities:
+        raise CaptureError(
+            f"runtime does not expose helicity selection: {process_spec.id}"
+        )
+    case_id = f"case:{process_spec.id}:{spec.color_accuracy}"
+    evidence_ids = tuple(
+        (
+            f"evidence:fortran:{case_id}:{point.id}"
+            if spec.model_id == "model:builtin-sm"
+            else f"evidence:analytic:{case_id}:{point.id}"
+        )
+        for point in points
+    )
+    lc = spec.color_accuracy == "lc"
+    certified_digits = (
+        FORTRAN_CERTIFIED_DIGITS
+        if spec.model_id == "model:builtin-sm"
+        else ANALYTIC_CERTIFIED_DIGITS
+    )
+    return {
+        "id": case_id,
+        "case_kind": "substantive",
+        "model_id": spec.model_id,
+        "process_id": process_spec.id,
+        "color_accuracy": spec.color_accuracy,
+        "point_policy": (
+            "degenerate-2to1"
+            if process_spec.point_policy == "exact-2to1"
+            else "standard"
+        ),
+        "point_ids": [point.id for point in points],
+        "coverage": {
+            "helicities": physics.helicity_coverage,
+            "color": physics.color_coverage,
+            "color_kind": physics.color_kind,
+            "helicity_count": len(physics.helicities),
+            "color_component_count": color_count,
+            "structural_zero_helicity_count": physics.structural_zero_helicity_count,
+        },
+        "selectors": {
+            "helicity": "helicity" in capabilities,
+            "color_flow": "color_flow" in capabilities,
+            "omitted_helicity": "all-components",
+            "omitted_color": "all-components" if lc else "contracted-component",
+        },
+        "normalization": _normalization_payload(physics_payload, spec.color_accuracy),
+        "topology": _topology_payload(execution_payload, physics),
+        "artifact_physics_sha256": physics_record.sha256,
+        "artifact_execution_sha256": execution_record.sha256,
+        "physics_case_sha256": "0" * 64,
+        "axes": axes,
+        "reduction": _reduction_payload(physics, lc=lc),
+        "observations": _resolved_observations(
+            runtime,
+            physics,
+            points,
+            evidence_ids,
+            certified_digits,
+        ),
+    }
+
+
+def _validated_capture_masses(
+    process_spec: ProcessCaptureSpec,
+    process_payload: Mapping[str, object],
+) -> tuple[Decimal, ...]:
+    try:
+        expected = tuple(
+            Decimal(value) for value in process_spec.expected_external_masses
+        )
+        actual = tuple(
+            Decimal(str(value))
+            for value in cast(
+                Sequence[object], process_payload["external_masses"]
+            )
+        )
+    except (ArithmeticError, KeyError) as error:
+        raise CaptureError(
+            f"invalid mass contract for {process_spec.expression!r}"
+        ) from error
+    if any(
+        canonical_decimal(value) != declared
+        for value, declared in zip(
+            expected,
+            process_spec.expected_external_masses,
+            strict=True,
+        )
+    ):
+        raise CaptureError(
+            f"declared masses for {process_spec.expression!r} are not canonical"
+        )
+    if actual != expected:
+        raise CaptureError(
+            f"artifact masses {actual} for {process_spec.expression!r} differ "
+            f"from the independent capture contract {expected}"
+        )
+    return expected
+
+
+def assemble_fixture(
+    specs: Sequence[ArtifactCaptureSpec],
+    artifact_paths: Mapping[str, Path],
+    source: SourceSnapshot,
+    runtime_snapshot: RuntimeSnapshot,
+    dependencies: DependencySnapshot,
+    *,
+    captured_at: str,
+    capture_command: Sequence[str],
+) -> dict[str, object]:
+    """Assemble the fixture exclusively from validated artifacts and runtimes."""
+
+    process_payloads: dict[str, dict[str, object]] = {}
+    point_payloads: dict[str, tuple[CapturePoint, ...]] = {}
+    model_payloads: dict[str, dict[str, object]] = {}
+    cases: list[dict[str, object]] = []
+    for spec in specs:
+        path = artifact_paths.get(spec.id)
+        if path is None:
+            raise CaptureError(f"no artifact path was supplied for {spec.id}")
+        manifest = _load_manifest(path)
+        producer = as_mapping(manifest.producer, f"artifact {path} producer")
+        if producer.get("version") != runtime_snapshot.version:
+            raise CaptureError(
+                f"artifact {path} was produced by pyamplicol "
+                f"{producer.get('version')!r}, not the validated capture candidate "
+                f"{runtime_snapshot.version!r}"
+            )
+        expected = {process.id: process.expression for process in spec.processes}
+        actual = {
+            str(process["id"]): str(process["expression"])
+            for process in manifest.processes
+        }
+        if actual != expected:
+            raise CaptureError(
+                f"artifact {path} does not contain the required named process set"
+            )
+        compiled_record = _payload_record(manifest, "compiled-model", None)
+        compiled = _read_json(manifest.root / compiled_record.path)
+        model_payload = _model_payload(spec, manifest, dependencies, compiled)
+        previous_model = model_payloads.setdefault(spec.model_id, model_payload)
+        if previous_model != model_payload:
+            raise CaptureError(
+                f"retained artifacts disagree on model provenance for {spec.model_id}"
+            )
+        for process_spec in spec.processes:
+            manifest_process = _artifact_process(manifest, process_spec.id)
+            runtime = _load_runtime(path, process_spec.id)
+            process_payload = _process_payload(
+                process_spec, manifest_process, runtime.physics, compiled
+            )
+            previous_process = process_payloads.setdefault(
+                process_spec.id, process_payload
+            )
+            if previous_process != process_payload:
+                raise CaptureError(
+                    "retained artifacts disagree on process metadata for "
+                    f"{process_spec.id}"
+                )
+            points = point_payloads.setdefault(
+                process_spec.id,
+                build_reference_points(
+                    process_spec,
+                    _validated_capture_masses(process_spec, process_payload),
+                ),
+            )
+            cases.append(
+                _case_payload(
+                    spec,
+                    process_spec,
+                    manifest,
+                    manifest_process,
+                    runtime,
+                    points,
+                )
+            )
+
+    process_order = tuple(
+        dict.fromkeys(process.id for spec in specs for process in spec.processes)
+    )
+    model_order = tuple(dict.fromkeys(spec.model_id for spec in specs))
+    fixture: dict[str, object] = {
+        "fixture_schema_version": 2,
+        "kind": "pyamplicol-reference-physics",
+        "fixture_id": "fixture:compact-reference-ladder-v2",
+        "provenance": {
+            "source_repository": source.repository_uri,
+            "source_revision": source.revision,
+            "source_tree_sha256": source.tree_sha256,
+            "captured_at": captured_at,
+            "capture_command": list(capture_command),
+            "working_tree_clean": True,
+            "memory_watchdog_gb": WATCHDOG_GB,
+        },
+        "dependencies": list(dependencies.payloads),
+        "models": [model_payloads[model_id] for model_id in model_order],
+        "processes": [process_payloads[process_id] for process_id in process_order],
+        "points": [
+            point.as_payload()
+            for process_id in process_order
+            for point in point_payloads[process_id]
+        ],
+        "cases": cases,
+        "evidence_sets": [
+            FORTRAN_EVIDENCE_SET_ID,
+            ANALYTIC_EVIDENCE_SET_ID,
+        ],
+    }
+    reference = developer_module("reference_fixture_v2")
+    for raw_case in cast(list[dict[str, object]], fixture["cases"]):
+        reduction = as_mapping(raw_case["reduction"], "case.reduction")
+        cast(dict[str, object], reduction)["plan_sha256"] = (
+            reference.reduction_plan_sha256(reduction)
+        )
+        raw_case["physics_case_sha256"] = reference.physics_case_sha256(
+            fixture,
+            str(raw_case["id"]),
+        )
+    return fixture
diff --git a/pyamplicol/tools/developer/reference_capture/common.py b/pyamplicol/tools/developer/reference_capture/common.py
new file mode 100644
index 0000000000..e47a8526cd
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_capture/common.py
@@ -0,0 +1,250 @@
+# SPDX-License-Identifier: 0BSD
+"""Shared contracts and canonical serialization for reference capture."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import json
+import math
+import sys
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+from typing import Any, Literal, cast
+
+ROOT = Path(__file__).resolve().parents[3]
+DEPENDENCIES = ROOT / "dependencies"
+RELEASE_LOCK = DEPENDENCIES / "release-lock.toml"
+CONTRIBUTOR_LOCK = DEPENDENCIES / "contributor-lock.toml"
+INSTALL_STATE = DEPENDENCIES / "install-state.json"
+MODEL_ASSETS = ROOT / "src" / "pyamplicol" / "assets" / "models" / "json"
+
+PHYSICS_FILENAME = "physics-v2.json"
+FORTRAN_EVIDENCE_FILENAME = "legacy-fortran-v2.json"
+ANALYTIC_EVIDENCE_FILENAME = "analytic-oracles-v2.json"
+BUNDLE_MANIFEST_FILENAME = "reference-fixture-v2.manifest.json"
+FORTRAN_EVIDENCE_SET_ID = "evidence-set:legacy-fortran-amplicol"
+ANALYTIC_EVIDENCE_SET_ID = "evidence-set:analytic-oracles"
+WATCHDOG_GB = 30
+OBSERVATION_PRECISION = 80
+FORTRAN_CERTIFIED_DIGITS = 10
+ANALYTIC_CERTIFIED_DIGITS = 12
+
+
+class CaptureError(RuntimeError):
+    """The capture cannot proceed without violating its provenance contract."""
+
+
+Momentum = tuple[Decimal, Decimal, Decimal, Decimal]
+
+
+@dataclass(frozen=True, slots=True)
+class StressMetric:
+    """One quantified singularity measure derived from captured momenta."""
+
+    kind: Literal[
+        "minimum-final-energy-fraction",
+        "minimum-final-transverse-momentum-squared-fraction",
+        "relative-excess-energy",
+    ]
+    value: Decimal
+
+    def as_payload(self) -> dict[str, str]:
+        return {"kind": self.kind, "value": canonical_decimal(self.value)}
+
+
+@dataclass(frozen=True, slots=True)
+class CapturePoint:
+    """One exact wire-level phase-space input."""
+
+    id: str
+    process_id: str
+    point_class: Literal["canonical", "generic", "stress"]
+    algorithm_name: str
+    algorithm_version: str
+    rng: str | None
+    seed: int | None
+    sqrt_s: Decimal
+    momenta: tuple[Momentum, ...]
+    masses: tuple[Decimal, ...]
+    arithmetic_precision_bits: int
+    round_trip_decimal_digits: int
+    certified_decimal_digits: int
+    stress_metric: StressMetric | None
+
+    def as_payload(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "process_id": self.process_id,
+            "class": self.point_class,
+            "algorithm": {
+                "name": self.algorithm_name,
+                "version": self.algorithm_version,
+                "rng": self.rng,
+                "seed": self.seed,
+            },
+            "sqrt_s": canonical_decimal(self.sqrt_s),
+            "momenta": [
+                [canonical_decimal(component) for component in momentum]
+                for momentum in self.momenta
+            ],
+            "masses": [canonical_decimal(mass) for mass in self.masses],
+            "arithmetic_precision_bits": self.arithmetic_precision_bits,
+            "round_trip_decimal_digits": self.round_trip_decimal_digits,
+            "certified_decimal_digits": self.certified_decimal_digits,
+            "stress_metric": (
+                None if self.stress_metric is None else self.stress_metric.as_payload()
+            ),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessCaptureSpec:
+    id: str
+    expression: str
+    model_id: str
+    expected_external_masses: tuple[str, ...]
+    point_policy: Literal[
+        "exact-2to1",
+        "seeded-two-body",
+        "one-massive-two-massless",
+    ]
+    point_seeds: tuple[int, int, int] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactCaptureSpec:
+    id: str
+    directory_name: str
+    model_id: str
+    model_source: Path | None
+    color_accuracy: Literal["lc", "nlc", "full"]
+    processes: tuple[ProcessCaptureSpec, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class SourceSnapshot:
+    repository_uri: str
+    revision: str
+    tree_sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeSnapshot:
+    """Identity of the installed candidate used for generation and replay."""
+
+    version: str
+    candidate_fingerprint: str
+    source_revision: str
+    distribution_sha256: str
+    build_info_sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class DependencySnapshot:
+    payloads: tuple[dict[str, object], ...]
+    release_lock: Mapping[str, object]
+    contributor_lock: Mapping[str, object]
+    install_state: Mapping[str, object]
+
+
+@dataclass(frozen=True, slots=True)
+class CaptureConfig:
+    output_directory: Path
+    artifact_root: Path
+    legacy_repository: Path
+    legacy_jobs: int
+    artifact_mode: Literal["generate", "reuse"]
+    capture_command: tuple[str, ...]
+    external_watchdog_gb: int = WATCHDOG_GB
+
+
+@dataclass(frozen=True, slots=True)
+class CaptureResult:
+    fixture_path: Path
+    evidence_paths: tuple[Path, ...]
+    bundle_manifest_path: Path
+    artifact_paths: tuple[Path, ...]
+
+
+def canonical_decimal(value: Decimal | float | int | str) -> str:
+    """Return the schema's canonical fixed-point decimal spelling."""
+
+    if isinstance(value, bool):
+        raise CaptureError("boolean values are not decimal physics values")
+    try:
+        if isinstance(value, Decimal):
+            decimal = value
+        elif isinstance(value, float):
+            if not math.isfinite(value):
+                raise CaptureError(f"non-finite binary64 value {value!r}")
+            decimal = Decimal(format(value, ".17g"))
+        elif isinstance(value, (int, str)):
+            decimal = Decimal(value)
+        else:
+            raise CaptureError(f"unsupported decimal value {value!r}")
+    except InvalidOperation as error:
+        raise CaptureError(f"invalid decimal value {value!r}") from error
+    if not decimal.is_finite():
+        raise CaptureError(f"non-finite decimal value {value!r}")
+    if decimal == 0:
+        return "0"
+    rendered = format(decimal, "f")
+    if "." in rendered:
+        rendered = rendered.rstrip("0").rstrip(".")
+    return rendered
+
+
+def decimal_digits_to_bits(decimal_digits: int) -> int:
+    """Return the smallest binary precision able to carry ``decimal_digits``."""
+
+    if isinstance(decimal_digits, bool) or decimal_digits < 1:
+        raise CaptureError("decimal precision must be a positive integer")
+    numerator = decimal_digits * 1_000_000_000_000_000_000
+    denominator = 301_029_995_663_981_195
+    return (numerator + denominator - 1) // denominator
+
+
+def as_mapping(value: object, where: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise CaptureError(f"{where} must be an object")
+    return cast(Mapping[str, object], value)
+
+
+def as_sequence(value: object, where: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise CaptureError(f"{where} must be an array")
+    return cast(Sequence[object], value)
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def canonical_sha256(value: object) -> str:
+    encoded = json.dumps(
+        value,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def developer_module(name: str) -> Any:
+    root_text = str(ROOT)
+    if root_text not in sys.path:
+        sys.path.insert(0, root_text)
+    return importlib.import_module(f"tools.developer.{name}")
+
+
+def json_bytes(value: Mapping[str, object]) -> bytes:
+    return (
+        json.dumps(value, ensure_ascii=True, indent=2, sort_keys=True) + "\n"
+    ).encode("ascii")
diff --git a/pyamplicol/tools/developer/reference_capture/evidence.py b/pyamplicol/tools/developer/reference_capture/evidence.py
new file mode 100644
index 0000000000..db494d2118
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_capture/evidence.py
@@ -0,0 +1,418 @@
+# SPDX-License-Identifier: 0BSD
+"""Independent oracle evidence and atomic fixture publication."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import tempfile
+from collections.abc import Mapping, Sequence
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+from typing import cast
+
+from .common import (
+    ANALYTIC_CERTIFIED_DIGITS,
+    ANALYTIC_EVIDENCE_FILENAME,
+    ANALYTIC_EVIDENCE_SET_ID,
+    BUNDLE_MANIFEST_FILENAME,
+    FORTRAN_EVIDENCE_FILENAME,
+    PHYSICS_FILENAME,
+    ROOT,
+    CaptureError,
+    Momentum,
+    as_mapping,
+    as_sequence,
+    canonical_decimal,
+    canonical_sha256,
+    decimal_digits_to_bits,
+    developer_module,
+    json_bytes,
+    sha256_file,
+)
+
+
+def point_input_sha256(point: Mapping[str, object]) -> str:
+    """Digest the canonical physics input independently of fixture metadata."""
+
+    payload = {
+        "arithmetic_precision_bits": point["arithmetic_precision_bits"],
+        "certified_decimal_digits": point["certified_decimal_digits"],
+        "masses": point["masses"],
+        "momenta": point["momenta"],
+        "process_id": point["process_id"],
+        "round_trip_decimal_digits": point["round_trip_decimal_digits"],
+        "sqrt_s": point["sqrt_s"],
+    }
+    return canonical_sha256(payload)
+
+
+def _point_momenta(point: Mapping[str, object]) -> tuple[Momentum, ...]:
+    result: list[Momentum] = []
+    for row_index, raw_row in enumerate(
+        as_sequence(point.get("momenta"), "point.momenta")
+    ):
+        row = as_sequence(raw_row, f"point.momenta[{row_index}]")
+        if len(row) != 4:
+            raise CaptureError("analytic point momentum must contain four components")
+        try:
+            result.append(cast(Momentum, tuple(Decimal(str(value)) for value in row)))
+        except InvalidOperation as error:
+            raise CaptureError("analytic point contains an invalid decimal") from error
+    return tuple(result)
+
+
+def _analytic_output_digest(
+    *,
+    formula: str,
+    input_sha256: str,
+    coupling: Decimal,
+    helicity_ids: Sequence[str],
+    color_ids: Sequence[str],
+    values: Sequence[Sequence[str]],
+    total: str,
+) -> str:
+    return canonical_sha256(
+        {
+            "color_ids": list(color_ids),
+            "coupling": canonical_decimal(coupling),
+            "formula": formula,
+            "helicity_ids": list(helicity_ids),
+            "input_sha256": input_sha256,
+            "total": total,
+            "values": [list(row) for row in values],
+        }
+    )
+
+
+def build_analytic_evidence(fixture: Mapping[str, object]) -> dict[str, object]:
+    """Evaluate scalar formulas with explicit arithmetic and certified precision."""
+
+    analytic = developer_module("analytic_oracles")
+    process_records = tuple(
+        as_mapping(value, "fixture process")
+        for value in as_sequence(fixture.get("processes"), "fixture.processes")
+    )
+    point_records = tuple(
+        as_mapping(value, "fixture point")
+        for value in as_sequence(fixture.get("points"), "fixture.points")
+    )
+    model_records = tuple(
+        as_mapping(value, "fixture model")
+        for value in as_sequence(fixture.get("models"), "fixture.models")
+    )
+    processes = {str(process["id"]): process for process in process_records}
+    points = {str(point["id"]): point for point in point_records}
+    models = {str(model["id"]): model for model in model_records}
+    records: list[dict[str, object]] = []
+    for raw_case in as_sequence(fixture.get("cases"), "fixture.cases"):
+        case = as_mapping(raw_case, "fixture case")
+        if case["model_id"] == "model:builtin-sm":
+            continue
+        process = processes[str(case["process_id"])]
+        model = models[str(case["model_id"])]
+        axes = as_mapping(case.get("axes"), "case.axes")
+        helicities = tuple(
+            as_mapping(value, "case helicity")
+            for value in as_sequence(axes.get("helicities"), "case.axes.helicities")
+        )
+        colors = tuple(
+            as_mapping(value, "case color")
+            for value in as_sequence(axes.get("colors"), "case.axes.colors")
+        )
+        if len(colors) != 1:
+            raise CaptureError(
+                f"analytic colorless case {case['id']} must have one color axis"
+            )
+        helicity_ids = tuple(str(value["id"]) for value in helicities)
+        color_ids = (str(colors[0]["id"]),)
+        defaults = as_mapping(
+            model.get("parameter_defaults"), "model.parameter_defaults"
+        )
+        if case["model_id"] == "model:scalars-json":
+            formula = "scalar_contact_2to2"
+            coupling = Decimal(1)
+        elif case["model_id"] == "model:scalar-gravity-json":
+            formula = "scalar_gravity_2to2"
+            kappa = as_mapping(defaults.get("kappa"), "model parameter kappa")
+            coupling = Decimal(str(kappa["real"]))
+        else:
+            raise CaptureError(f"no analytic oracle is defined for {case['model_id']}")
+        for point_id_value in as_sequence(case.get("point_ids"), "case.point_ids"):
+            point_id = str(point_id_value)
+            point = points[point_id]
+            observation = (
+                analytic.scalar_contact_2to2(
+                    coupling,
+                    certified_accuracy_digits=ANALYTIC_CERTIFIED_DIGITS,
+                )
+                if formula == "scalar_contact_2to2"
+                else analytic.scalar_gravity_2to2(
+                    _point_momenta(point),
+                    coupling,
+                    precision=100,
+                    certified_accuracy_digits=ANALYTIC_CERTIFIED_DIGITS,
+                )
+            )
+            values_by_id = dict(observation.resolved_by_helicity)
+            if set(values_by_id) != set(helicity_ids):
+                raise CaptureError(
+                    f"analytic oracle axis differs from runtime axis for {case['id']}"
+                )
+            values = [
+                [canonical_decimal(values_by_id[helicity_id])]
+                for helicity_id in helicity_ids
+            ]
+            for helicity, row in zip(helicities, values, strict=True):
+                if bool(helicity["structural_zero"]) and row != ["0"]:
+                    raise CaptureError(
+                        f"analytic oracle violated structural zero {helicity['id']}"
+                    )
+            total = canonical_decimal(observation.total)
+            input_digest = point_input_sha256(point)
+            record_id = f"evidence:analytic:{case['id']}:{point_id}"
+            record: dict[str, object] = {
+                "id": record_id,
+                "case_id": case["id"],
+                "point_id": point_id,
+                "independent_of_pyamplicol": True,
+                "arithmetic_precision_bits": decimal_digits_to_bits(
+                    observation.metadata.arithmetic_precision_decimal_digits
+                ),
+                "round_trip_decimal_digits": (
+                    observation.metadata.arithmetic_precision_decimal_digits
+                ),
+                "certified_decimal_digits": (
+                    observation.metadata.certified_accuracy_decimal_digits
+                ),
+                "arithmetic": "analytic",
+                "coverage": "resolved",
+                "helicity_ids": list(helicity_ids),
+                "color_ids": list(color_ids),
+                "observed_total": total,
+                "observed_helicity_totals": None,
+                "observed_values": values,
+                "process_identity": {
+                    "expression": process["expression"],
+                    "ordered_external_pdgs": process["external_pdgs"],
+                    "ordered_external_leg_ids": process["external_leg_ids"],
+                    "source_to_row_permutation": list(
+                        range(len(cast(Sequence[object], process["external_pdgs"])))
+                    ),
+                    "row_id": None,
+                    "color_order_count": len(colors),
+                    "ordered_color_legs": [],
+                },
+                "input_sha256": input_digest,
+                "physics_case_sha256": case["physics_case_sha256"],
+                "oracle_output_sha256": _analytic_output_digest(
+                    formula=formula,
+                    input_sha256=input_digest,
+                    coupling=coupling,
+                    helicity_ids=helicity_ids,
+                    color_ids=color_ids,
+                    values=values,
+                    total=total,
+                ),
+                "command": [
+                    "tools/developer/analytic_oracles.py",
+                    formula,
+                    f"case={case['id']}",
+                    f"point={point_id}",
+                ],
+                "tolerances": {
+                    "relative": "0.000000000001",
+                    "absolute": "0.000000000000001",
+                },
+            }
+            reference = developer_module("reference_fixture_v2")
+            record["evidence_record_sha256"] = reference.evidence_record_sha256(record)
+            records.append(record)
+    if not records:
+        raise CaptureError("fixture contains no external-model analytic cases")
+    provenance = as_mapping(fixture.get("provenance"), "fixture.provenance")
+    return {
+        "evidence_schema_version": 2,
+        "kind": "pyamplicol-reference-oracle-evidence",
+        "evidence_set_id": ANALYTIC_EVIDENCE_SET_ID,
+        "captured_at": provenance["captured_at"],
+        "oracle": {
+            "id": "oracle:analytic-scalars",
+            "name": "Independent closed-form scalar oracles",
+            "implementation": "tools/developer/analytic_oracles.py Decimal formulas",
+            "revision": provenance["source_revision"],
+            "content_sha256": sha256_file(
+                ROOT / "tools" / "developer" / "analytic_oracles.py"
+            ),
+            "independence_statement": (
+                "Closed-form scalar formulas consume only captured momenta and "
+                "model defaults; they do not import generation or runtime evaluators."
+            ),
+            "validation_profile": "high-precision",
+            "tolerance_ceiling": {
+                "relative": "0.000000000001",
+                "absolute": "0.000000000000001",
+            },
+        },
+        "dependency_ids": ["dependency:analytic-oracles"],
+        "records": records,
+    }
+
+
+def build_fortran_evidence(
+    fixture: Mapping[str, object],
+    repository: Path,
+    jobs: int,
+) -> dict[str, object]:
+    """Run the pinned legacy Fortran oracle through its public adapter."""
+
+    if jobs < 1:
+        raise CaptureError("legacy oracle jobs must be a positive integer")
+    legacy = developer_module("legacy_amplicol")
+    try:
+        legacy.prepare_checkout(repository)
+        with tempfile.TemporaryDirectory(
+            prefix="pyamplicol-reference-v2-draft-"
+        ) as raw:
+            draft_path = Path(raw) / PHYSICS_FILENAME
+            draft_path.write_bytes(json_bytes(fixture))
+            return cast(
+                dict[str, object],
+                legacy.verify_fixture(
+                    repository,
+                    draft_path,
+                    jobs=jobs,
+                    build=True,
+                ),
+            )
+    except Exception as error:
+        raise CaptureError(f"pinned legacy Fortran oracle failed: {error}") from error
+
+
+def validate_capture_documents(
+    fixture: Mapping[str, object],
+    evidence_documents: Sequence[Mapping[str, object]],
+) -> None:
+    """Invoke the strict fixture parser with the complete evidence set."""
+
+    reference = developer_module("reference_fixture_v2")
+    try:
+        reference.parse_reference_fixture(fixture, evidence_documents)
+    except Exception as error:
+        raise CaptureError(
+            "strict reference fixture validation failed; no final files written: "
+            f"{error}"
+        ) from error
+
+
+def atomic_write_documents(
+    output_directory: Path,
+    documents: Mapping[str, Mapping[str, object]],
+    *,
+    bundle_manifest_name: str | None = None,
+) -> tuple[Path, ...]:
+    """Publish JSON documents, optionally committing them with a final manifest."""
+
+    if not documents:
+        raise CaptureError("no capture documents were supplied")
+    if any(Path(name).name != name for name in documents):
+        raise CaptureError("capture document names must be plain filenames")
+    if bundle_manifest_name is not None and (
+        Path(bundle_manifest_name).name != bundle_manifest_name
+        or bundle_manifest_name in documents
+    ):
+        raise CaptureError("capture bundle manifest name is invalid")
+    output_directory.mkdir(parents=True, exist_ok=True)
+    encoded_documents = {
+        name: json_bytes(document) for name, document in documents.items()
+    }
+    document_targets = tuple(output_directory / name for name in documents)
+    publication = list(encoded_documents.items())
+    manifest_target: Path | None = None
+    if bundle_manifest_name is not None:
+        file_records = [
+            {
+                "path": name,
+                "sha256": hashlib.sha256(content).hexdigest(),
+            }
+            for name, content in sorted(encoded_documents.items())
+        ]
+        manifest: dict[str, object] = {
+            "schema_version": 1,
+            "kind": "pyamplicol-reference-fixture-bundle",
+            "files": file_records,
+            "bundle_sha256": canonical_sha256(
+                {
+                    "contract": "pyamplicol-reference-fixture-bundle-v1",
+                    "files": file_records,
+                }
+            ),
+        }
+        publication.append((bundle_manifest_name, json_bytes(manifest)))
+        manifest_target = output_directory / bundle_manifest_name
+    all_targets = tuple(output_directory / name for name, _content in publication)
+    existing = tuple(path for path in all_targets if path.exists())
+    if existing:
+        raise CaptureError(
+            "capture output already exists and will not be overwritten: "
+            + ", ".join(str(path) for path in existing)
+        )
+    staged: list[Path] = []
+    published: list[Path] = []
+    try:
+        for name, content in publication:
+            descriptor, raw_path = tempfile.mkstemp(
+                prefix=f".{name}.",
+                suffix=".tmp",
+                dir=output_directory,
+            )
+            path = Path(raw_path)
+            staged.append(path)
+            with os.fdopen(descriptor, "wb") as stream:
+                stream.write(content)
+                stream.flush()
+                os.fsync(stream.fileno())
+        for path, target in zip(staged, all_targets, strict=True):
+            try:
+                os.link(path, target)
+            except FileExistsError as error:
+                raise CaptureError(
+                    "capture output appeared concurrently and was not overwritten: "
+                    f"{target}"
+                ) from error
+            published.append(target)
+        directory_descriptor = os.open(output_directory, os.O_RDONLY)
+        try:
+            os.fsync(directory_descriptor)
+        finally:
+            os.close(directory_descriptor)
+    except Exception:
+        for path in published:
+            path.unlink(missing_ok=True)
+        raise
+    finally:
+        for path in staged:
+            path.unlink(missing_ok=True)
+    if manifest_target is not None and published[-1] != manifest_target:
+        raise AssertionError("bundle manifest was not published last")
+    return document_targets
+
+
+def validate_and_publish(
+    output_directory: Path,
+    fixture: Mapping[str, object],
+    fortran_evidence: Mapping[str, object],
+    analytic_evidence: Mapping[str, object],
+) -> tuple[Path, ...]:
+    """Strictly validate the whole bundle before creating any final file."""
+
+    validate_capture_documents(fixture, (fortran_evidence, analytic_evidence))
+    return atomic_write_documents(
+        output_directory,
+        {
+            PHYSICS_FILENAME: fixture,
+            FORTRAN_EVIDENCE_FILENAME: fortran_evidence,
+            ANALYTIC_EVIDENCE_FILENAME: analytic_evidence,
+        },
+        bundle_manifest_name=BUNDLE_MANIFEST_FILENAME,
+    )
diff --git a/pyamplicol/tools/developer/reference_capture/pipeline.py b/pyamplicol/tools/developer/reference_capture/pipeline.py
new file mode 100644
index 0000000000..4e226532cf
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_capture/pipeline.py
@@ -0,0 +1,82 @@
+# SPDX-License-Identifier: 0BSD
+"""Capture orchestration with a validate-before-publish boundary."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from .artifacts import (
+    artifact_capture_specs,
+    assemble_fixture,
+    materialize_artifacts,
+)
+from .common import (
+    BUNDLE_MANIFEST_FILENAME,
+    ROOT,
+    WATCHDOG_GB,
+    CaptureConfig,
+    CaptureError,
+    CaptureResult,
+)
+from .evidence import (
+    build_analytic_evidence,
+    build_fortran_evidence,
+    validate_and_publish,
+)
+from .provenance import (
+    assert_runtime_snapshot_unchanged,
+    assert_source_snapshot_unchanged,
+    collect_dependency_snapshot,
+    collect_runtime_snapshot,
+    collect_source_snapshot,
+)
+
+
+def _utc_now() -> str:
+    return datetime.now(UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def run_capture(config: CaptureConfig) -> CaptureResult:
+    """Run artifact capture, evidence, strict validation, and publication."""
+
+    if config.external_watchdog_gb != WATCHDOG_GB:
+        raise CaptureError(
+            f"capture requires confirmation of an external {WATCHDOG_GB} GB watchdog"
+        )
+    source = collect_source_snapshot(ROOT)
+    runtime = collect_runtime_snapshot(source)
+    dependencies = collect_dependency_snapshot(runtime)
+    specs = artifact_capture_specs(config.artifact_root)
+    artifact_paths = materialize_artifacts(
+        specs, config.artifact_root, config.artifact_mode
+    )
+    captured_at = _utc_now()
+    fixture = assemble_fixture(
+        specs,
+        artifact_paths,
+        source,
+        runtime,
+        dependencies,
+        captured_at=captured_at,
+        capture_command=config.capture_command,
+    )
+    analytic_evidence = build_analytic_evidence(fixture)
+    fortran_evidence = build_fortran_evidence(
+        fixture,
+        config.legacy_repository,
+        config.legacy_jobs,
+    )
+    assert_source_snapshot_unchanged(source, ROOT)
+    assert_runtime_snapshot_unchanged(runtime, source)
+    written = validate_and_publish(
+        config.output_directory,
+        fixture,
+        fortran_evidence,
+        analytic_evidence,
+    )
+    return CaptureResult(
+        fixture_path=written[0],
+        evidence_paths=(written[1], written[2]),
+        bundle_manifest_path=config.output_directory / BUNDLE_MANIFEST_FILENAME,
+        artifact_paths=tuple(artifact_paths[spec.id] for spec in specs),
+    )
diff --git a/pyamplicol/tools/developer/reference_capture/points.py b/pyamplicol/tools/developer/reference_capture/points.py
new file mode 100644
index 0000000000..7071774ff1
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_capture/points.py
@@ -0,0 +1,612 @@
+# SPDX-License-Identifier: 0BSD
+"""Deterministic canonical phase-space points and external leg identity."""
+
+from __future__ import annotations
+
+import math
+import random
+import re
+from collections import Counter
+from collections.abc import Mapping, Sequence
+from decimal import Decimal, localcontext
+from typing import cast
+
+from .common import (
+    CaptureError,
+    CapturePoint,
+    Momentum,
+    ProcessCaptureSpec,
+    StressMetric,
+    canonical_decimal,
+    decimal_digits_to_bits,
+)
+
+_PUBLIC_ID_PART_RE = re.compile(r"[^A-Za-z0-9._~-]+")
+_GENERIC_SQRT_S = Decimal("1000")
+_BINARY64_BITS = 53
+_BINARY64_ROUND_TRIP_DIGITS = 17
+_BINARY64_CERTIFIED_DIGITS = 12
+_DECIMAL_WORKING_DIGITS = 110
+_DECIMAL_ROUND_TRIP_DIGITS = _DECIMAL_WORKING_DIGITS
+_DECIMAL_CERTIFIED_DIGITS = 80
+# Keep this point genuinely soft and near-collinear while retaining the ten
+# decimal digits certified by the independent binary64 Fortran oracle.
+_THREE_BODY_STRESS_ENERGY_FRACTION = Decimal("1e-3")
+_THREE_BODY_STRESS_SINE = Decimal("0.2")
+_THRESHOLD_STRESS_RELATIVE_EXCESS = Decimal("1e-6")
+def _f64_decimal(value: float) -> Decimal:
+    return Decimal(canonical_decimal(value))
+
+
+def _lambda(x: Decimal, y: Decimal, z: Decimal) -> Decimal:
+    return x * x + y * y + z * z - 2 * (x * y + x * z + y * z)
+
+
+def _incoming(sqrt_s: Decimal) -> tuple[Momentum, Momentum]:
+    half = sqrt_s / 2
+    zero = Decimal(0)
+    return (
+        (half, zero, zero, half),
+        (half, zero, zero, -half),
+    )
+
+
+def _transverse_stress_metric(
+    momenta: Sequence[Momentum],
+    sqrt_s: Decimal,
+    *,
+    initial_state_count: int = 2,
+) -> StressMetric:
+    with localcontext() as context:
+        context.prec = _DECIMAL_WORKING_DIGITS
+        value = +min(
+            (momentum[1] * momentum[1] + momentum[2] * momentum[2]) / (sqrt_s * sqrt_s)
+            for momentum in momenta[initial_state_count:]
+        )
+    return StressMetric(
+        "minimum-final-transverse-momentum-squared-fraction",
+        value,
+    )
+
+
+def _two_body_generic(
+    process_id: str,
+    expression: str,
+    seed: int,
+    index: int,
+    masses: tuple[Decimal, Decimal],
+) -> CapturePoint:
+    sqrt_s = float(_GENERIC_SQRT_S)
+    mass_3, mass_4 = (float(mass) for mass in masses)
+    s = sqrt_s * sqrt_s
+    radicand = (s - (mass_3 + mass_4) ** 2) * (s - (mass_3 - mass_4) ** 2)
+    if radicand <= 0:
+        raise CaptureError(f"two-body point is below threshold for {expression}")
+    momentum = math.sqrt(radicand) / (2.0 * sqrt_s)
+    energy_3 = (s + mass_3 * mass_3 - mass_4 * mass_4) / (2.0 * sqrt_s)
+    energy_4 = sqrt_s - energy_3
+    generator = random.Random(seed)
+    cosine = generator.uniform(-0.82, 0.82)
+    sine = math.sqrt(1.0 - cosine * cosine)
+    phi = generator.uniform(0.0, 2.0 * math.pi)
+    px = momentum * sine * math.cos(phi)
+    py = momentum * sine * math.sin(phi)
+    pz = momentum * cosine
+    raw = (
+        (sqrt_s / 2.0, 0.0, 0.0, sqrt_s / 2.0),
+        (sqrt_s / 2.0, 0.0, 0.0, -sqrt_s / 2.0),
+        (energy_3, px, py, pz),
+        (energy_4, -px, -py, -pz),
+    )
+    point = CapturePoint(
+        id=f"point:{process_id}:generic-{index}",
+        process_id=process_id,
+        point_class="generic",
+        algorithm_name="seeded-two-body-binary64",
+        algorithm_version="1",
+        rng="python-random-mt19937",
+        seed=seed,
+        sqrt_s=_f64_decimal(sqrt_s),
+        momenta=tuple(
+            cast(Momentum, tuple(_f64_decimal(component) for component in row))
+            for row in raw
+        ),
+        masses=(Decimal(0), Decimal(0), *masses),
+        arithmetic_precision_bits=_BINARY64_BITS,
+        round_trip_decimal_digits=_BINARY64_ROUND_TRIP_DIGITS,
+        certified_decimal_digits=_BINARY64_CERTIFIED_DIGITS,
+        stress_metric=None,
+    )
+    validate_point_kinematics(point, point.masses)
+    return point
+
+
+def _two_body_stress(
+    process_id: str,
+    expression: str,
+    masses: tuple[Decimal, Decimal],
+) -> CapturePoint:
+    with localcontext() as context:
+        context.prec = _DECIMAL_WORKING_DIGITS
+        sqrt_s = +_GENERIC_SQRT_S
+        mass_3, mass_4 = masses
+        s = sqrt_s * sqrt_s
+        radicand = _lambda(s, mass_3 * mass_3, mass_4 * mass_4)
+        if radicand <= 0:
+            raise CaptureError(
+                f"two-body stress point is below threshold: {expression}"
+            )
+        momentum = +(radicand.sqrt() / (2 * sqrt_s))
+        energy_3 = +(s + mass_3 * mass_3 - mass_4 * mass_4) / (2 * sqrt_s)
+        energy_4 = +(sqrt_s - energy_3)
+        sine = Decimal("0.002")
+        cosine = +(Decimal(1) - sine * sine).sqrt()
+        px = +(momentum * sine)
+        pz = +(momentum * cosine)
+        zero = Decimal(0)
+        momenta = (
+            *_incoming(sqrt_s),
+            (energy_3, px, zero, pz),
+            (energy_4, -px, zero, -pz),
+        )
+    point = CapturePoint(
+        id=f"point:{process_id}:stress-near-collinear",
+        process_id=process_id,
+        point_class="stress",
+        algorithm_name="decimal-near-collinear-two-body",
+        algorithm_version="1",
+        rng=None,
+        seed=None,
+        sqrt_s=sqrt_s,
+        momenta=momenta,
+        masses=(Decimal(0), Decimal(0), *masses),
+        arithmetic_precision_bits=decimal_digits_to_bits(_DECIMAL_WORKING_DIGITS),
+        round_trip_decimal_digits=_DECIMAL_ROUND_TRIP_DIGITS,
+        certified_decimal_digits=_DECIMAL_CERTIFIED_DIGITS,
+        stress_metric=_transverse_stress_metric(momenta, sqrt_s),
+    )
+    validate_point_kinematics(point, point.masses)
+    return point
+
+
+def _two_body_threshold_stress(
+    process_id: str,
+    expression: str,
+    masses: tuple[Decimal, Decimal],
+) -> CapturePoint:
+    with localcontext() as context:
+        context.prec = _DECIMAL_WORKING_DIGITS
+        mass_3, mass_4 = masses
+        threshold = +(mass_3 + mass_4)
+        if mass_3 <= 0 or mass_4 <= 0:
+            raise CaptureError(
+                f"threshold stress point requires two massive final legs: "
+                f"{expression}"
+            )
+        sqrt_s = +(threshold * (Decimal(1) + _THRESHOLD_STRESS_RELATIVE_EXCESS))
+        s = +(sqrt_s * sqrt_s)
+        radicand = _lambda(s, mass_3 * mass_3, mass_4 * mass_4)
+        if radicand <= 0:
+            raise CaptureError(
+                f"threshold stress point is below threshold: {expression}"
+            )
+        momentum = +(radicand.sqrt() / (2 * sqrt_s))
+        energy_3 = +(s + mass_3 * mass_3 - mass_4 * mass_4) / (2 * sqrt_s)
+        energy_4 = +(sqrt_s - energy_3)
+        sine = Decimal("0.6")
+        cosine = Decimal("0.8")
+        zero = Decimal(0)
+        momenta = (
+            *_incoming(sqrt_s),
+            (energy_3, +(momentum * sine), zero, +(momentum * cosine)),
+            (energy_4, -(momentum * sine), zero, -(momentum * cosine)),
+        )
+    point = CapturePoint(
+        id=f"point:{process_id}:stress-near-threshold",
+        process_id=process_id,
+        point_class="stress",
+        algorithm_name="decimal-near-threshold-two-body",
+        algorithm_version="1",
+        rng=None,
+        seed=None,
+        sqrt_s=sqrt_s,
+        momenta=momenta,
+        masses=(Decimal(0), Decimal(0), *masses),
+        arithmetic_precision_bits=decimal_digits_to_bits(_DECIMAL_WORKING_DIGITS),
+        round_trip_decimal_digits=_DECIMAL_ROUND_TRIP_DIGITS,
+        certified_decimal_digits=_DECIMAL_CERTIFIED_DIGITS,
+        stress_metric=StressMetric(
+            "relative-excess-energy",
+            _THRESHOLD_STRESS_RELATIVE_EXCESS,
+        ),
+    )
+    validate_point_kinematics(point, point.masses)
+    return point
+
+
+def _boost_z_f64(
+    momentum: tuple[float, float, float, float], beta: float
+) -> tuple[float, float, float, float]:
+    gamma = 1.0 / math.sqrt(1.0 - beta * beta)
+    energy, px, py, pz = momentum
+    return (
+        gamma * (energy + beta * pz),
+        px,
+        py,
+        gamma * (pz + beta * energy),
+    )
+
+
+def _rotate_f64(
+    momentum: tuple[float, float, float, float],
+    *,
+    cosine: float,
+    sine: float,
+    phi: float,
+) -> tuple[float, float, float, float]:
+    energy, px, py, pz = momentum
+    x_tilted = cosine * px + sine * pz
+    z_tilted = -sine * px + cosine * pz
+    cosine_phi = math.cos(phi)
+    sine_phi = math.sin(phi)
+    return (
+        energy,
+        cosine_phi * x_tilted - sine_phi * py,
+        sine_phi * x_tilted + cosine_phi * py,
+        z_tilted,
+    )
+
+
+def _three_body_generic(
+    process_id: str,
+    seed: int,
+    index: int,
+    mass: Decimal,
+) -> CapturePoint:
+    sqrt_s = float(_GENERIC_SQRT_S)
+    final_mass = float(mass)
+    generator = random.Random(seed)
+    soft_energy = sqrt_s * (0.08 + 0.12 * generator.random())
+    q_energy = sqrt_s - soft_energy
+    q_mass = math.sqrt(sqrt_s * sqrt_s - 2.0 * sqrt_s * soft_energy)
+    hard_energy = (q_mass * q_mass - final_mass * final_mass) / (2.0 * q_mass)
+    massive_energy = (q_mass * q_mass + final_mass * final_mass) / (2.0 * q_mass)
+    cosine = generator.uniform(-0.72, 0.72)
+    sine = math.sqrt(1.0 - cosine * cosine)
+    phi = generator.uniform(0.0, 2.0 * math.pi)
+    px = hard_energy * sine * math.cos(phi)
+    py = hard_energy * sine * math.sin(phi)
+    pz = hard_energy * cosine
+    beta = -soft_energy / q_energy
+    hard = _boost_z_f64((hard_energy, px, py, pz), beta)
+    massive = _boost_z_f64((massive_energy, -px, -py, -pz), beta)
+    rotation_cosine = generator.uniform(-0.75, 0.75)
+    rotation_sine = math.sqrt(1.0 - rotation_cosine * rotation_cosine)
+    rotation_phi = generator.uniform(0.0, 2.0 * math.pi)
+    final_state = tuple(
+        _rotate_f64(
+            momentum,
+            cosine=rotation_cosine,
+            sine=rotation_sine,
+            phi=rotation_phi,
+        )
+        for momentum in (
+            massive,
+            hard,
+            (soft_energy, 0.0, 0.0, soft_energy),
+        )
+    )
+    raw = (
+        (sqrt_s / 2.0, 0.0, 0.0, sqrt_s / 2.0),
+        (sqrt_s / 2.0, 0.0, 0.0, -sqrt_s / 2.0),
+        *final_state,
+    )
+    point = CapturePoint(
+        id=f"point:{process_id}:generic-{index}",
+        process_id=process_id,
+        point_class="generic",
+        algorithm_name="seeded-sequential-three-body-binary64",
+        algorithm_version="2",
+        rng="python-random-mt19937",
+        seed=seed,
+        sqrt_s=_f64_decimal(sqrt_s),
+        momenta=tuple(
+            cast(Momentum, tuple(_f64_decimal(component) for component in row))
+            for row in raw
+        ),
+        masses=(Decimal(0), Decimal(0), mass, Decimal(0), Decimal(0)),
+        arithmetic_precision_bits=_BINARY64_BITS,
+        round_trip_decimal_digits=_BINARY64_ROUND_TRIP_DIGITS,
+        certified_decimal_digits=_BINARY64_CERTIFIED_DIGITS,
+        stress_metric=None,
+    )
+    validate_point_kinematics(point, point.masses)
+    return point
+
+
+def _boost_decimal(
+    momentum: Momentum,
+    beta: tuple[Decimal, Decimal, Decimal],
+) -> Momentum:
+    beta_square = sum((component * component for component in beta), Decimal(0))
+    if beta_square == 0:
+        return momentum
+    if beta_square >= 1:
+        raise CaptureError("decimal boost velocity is not subluminal")
+    gamma = Decimal(1) / (Decimal(1) - beta_square).sqrt()
+    energy, px, py, pz = momentum
+    spatial = (px, py, pz)
+    beta_dot_momentum = sum(
+        (left * right for left, right in zip(beta, spatial, strict=True)),
+        Decimal(0),
+    )
+    spatial_factor = (
+        gamma - Decimal(1)
+    ) * beta_dot_momentum / beta_square + gamma * energy
+    boosted = tuple(
+        +(component + spatial_factor * velocity)
+        for component, velocity in zip(spatial, beta, strict=True)
+    )
+    return cast(Momentum, (+(gamma * (energy + beta_dot_momentum)), *boosted))
+
+
+def _three_body_stress(process_id: str, mass: Decimal) -> CapturePoint:
+    with localcontext() as context:
+        context.prec = _DECIMAL_WORKING_DIGITS
+        sqrt_s = +_GENERIC_SQRT_S
+        mass = +mass
+        soft_energy = +(sqrt_s * _THREE_BODY_STRESS_ENERGY_FRACTION)
+        q_energy = +(sqrt_s - soft_energy)
+        q_mass = +(sqrt_s * sqrt_s - 2 * sqrt_s * soft_energy).sqrt()
+        hard_energy = +(q_mass * q_mass - mass * mass) / (2 * q_mass)
+        massive_energy = +(q_mass * q_mass + mass * mass) / (2 * q_mass)
+        sine = _THREE_BODY_STRESS_SINE
+        cosine = +(Decimal(1) - sine * sine).sqrt()
+        zero = Decimal(0)
+        soft_px = +(soft_energy * sine)
+        soft_pz = +(soft_energy * cosine)
+        beta = (-soft_px / q_energy, zero, -soft_pz / q_energy)
+        hard = _boost_decimal((hard_energy, zero, hard_energy, zero), beta)
+        massive = _boost_decimal((massive_energy, zero, -hard_energy, zero), beta)
+        momenta = (
+            *_incoming(sqrt_s),
+            massive,
+            hard,
+            (soft_energy, soft_px, zero, soft_pz),
+        )
+    point = CapturePoint(
+        id=f"point:{process_id}:stress-soft-collinear",
+        process_id=process_id,
+        point_class="stress",
+        algorithm_name="decimal-soft-near-collinear-sequential-three-body",
+        algorithm_version="2",
+        rng=None,
+        seed=None,
+        sqrt_s=sqrt_s,
+        momenta=momenta,
+        masses=(Decimal(0), Decimal(0), mass, Decimal(0), Decimal(0)),
+        arithmetic_precision_bits=decimal_digits_to_bits(_DECIMAL_WORKING_DIGITS),
+        round_trip_decimal_digits=_DECIMAL_ROUND_TRIP_DIGITS,
+        certified_decimal_digits=_DECIMAL_CERTIFIED_DIGITS,
+        stress_metric=_transverse_stress_metric(momenta, sqrt_s),
+    )
+    validate_point_kinematics(point, point.masses)
+    return point
+
+
+def _exact_two_to_one(
+    process: ProcessCaptureSpec,
+    masses: tuple[Decimal, ...],
+) -> CapturePoint:
+    if len(masses) != 3 or any(mass != 0 for mass in masses[:2]):
+        raise CaptureError(
+            f"exact two-to-one point requires two massless incoming legs: "
+            f"{process.expression}"
+        )
+    final_mass = masses[2]
+    if final_mass <= 0:
+        raise CaptureError(
+            f"exact two-to-one point requires a massive final leg: "
+            f"{process.expression}"
+        )
+    half = final_mass / 2
+    zero = Decimal(0)
+    point = CapturePoint(
+        id=f"point:{process.id}:canonical",
+        process_id=process.id,
+        point_class="canonical",
+        algorithm_name="exact-two-to-one",
+        algorithm_version="1",
+        rng=None,
+        seed=None,
+        sqrt_s=final_mass,
+        momenta=(
+            (half, zero, zero, half),
+            (half, zero, zero, -half),
+            (final_mass, zero, zero, zero),
+        ),
+        masses=masses,
+        arithmetic_precision_bits=_BINARY64_BITS,
+        round_trip_decimal_digits=_BINARY64_ROUND_TRIP_DIGITS,
+        certified_decimal_digits=15,
+        stress_metric=None,
+    )
+    validate_point_kinematics(point, masses)
+    return point
+
+
+def build_reference_points(
+    process: ProcessCaptureSpec,
+    masses: tuple[Decimal, ...],
+) -> tuple[CapturePoint, ...]:
+    """Construct the deterministic compact point ladder for one process."""
+
+    if process.point_policy == "exact-2to1":
+        if process.point_seeds:
+            raise CaptureError(
+                f"exact point policy for {process.expression!r} must not define seeds"
+            )
+        return (_exact_two_to_one(process, masses),)
+    if len(process.point_seeds) != 3:
+        raise CaptureError(
+            f"point policy for {process.expression!r} requires exactly three seeds"
+        )
+    if any(mass != 0 for mass in masses[:2]):
+        raise CaptureError(
+            f"reference point policy currently requires massless incoming legs: "
+            f"{process.expression}"
+        )
+    if process.point_policy == "one-massive-two-massless":
+        if len(masses) != 5 or masses[2] <= 0 or any(
+            mass != 0 for mass in masses[3:]
+        ):
+            raise CaptureError(
+                "one-massive-two-massless point policy received incompatible "
+                f"masses for {process.expression!r}"
+            )
+        return (
+            *(
+                _three_body_generic(process.id, seed, index, masses[2])
+                for index, seed in enumerate(process.point_seeds, start=1)
+            ),
+            _three_body_stress(process.id, masses[2]),
+        )
+    if process.point_policy != "seeded-two-body" or len(masses) != 4:
+        raise CaptureError(
+            f"no strict point policy is defined for {process.expression!r}"
+        )
+    final_masses = (masses[2], masses[3])
+    return (
+        *(
+            _two_body_generic(
+                process.id,
+                process.expression,
+                seed,
+                index,
+                final_masses,
+            )
+            for index, seed in enumerate(process.point_seeds, start=1)
+        ),
+        (
+            _two_body_threshold_stress(
+                process.id,
+                process.expression,
+                final_masses,
+            )
+            if all(mass > 0 for mass in final_masses)
+            else _two_body_stress(process.id, process.expression, final_masses)
+        ),
+    )
+
+
+def _mass_square(momentum: Sequence[Decimal]) -> Decimal:
+    return momentum[0] ** 2 - sum(
+        (component**2 for component in momentum[1:]), Decimal(0)
+    )
+
+
+def validate_point_kinematics(
+    point: CapturePoint,
+    masses: Sequence[Decimal],
+    *,
+    initial_state_count: int = 2,
+) -> None:
+    """Reject non-finite, off-shell, or non-conserving capture points."""
+
+    if len(masses) != len(point.momenta):
+        raise CaptureError(f"{point.id} mass and momentum dimensions differ")
+    if initial_state_count <= 0 or initial_state_count >= len(point.momenta):
+        raise CaptureError(f"{point.id} has an invalid initial-state count")
+    if any(
+        not component.is_finite()
+        for momentum in point.momenta
+        for component in momentum
+    ):
+        raise CaptureError(f"{point.id} contains non-finite momentum components")
+    with localcontext() as context:
+        context.prec = max(
+            _DECIMAL_WORKING_DIGITS,
+            point.certified_decimal_digits + 30,
+        )
+        scale = max(
+            (abs(component) for momentum in point.momenta for component in momentum),
+            default=Decimal(1),
+        )
+        relative = Decimal(1).scaleb(-point.certified_decimal_digits)
+        momentum_tolerance = max(scale, Decimal(1)) * relative
+        shell_tolerance = max(scale * scale, Decimal(1)) * relative
+        imbalance = tuple(
+            sum(
+                (
+                    momentum[component]
+                    for momentum in point.momenta[:initial_state_count]
+                ),
+                Decimal(0),
+            )
+            - sum(
+                (
+                    momentum[component]
+                    for momentum in point.momenta[initial_state_count:]
+                ),
+                Decimal(0),
+            )
+            for component in range(4)
+        )
+        if any(abs(component) > momentum_tolerance for component in imbalance):
+            raise CaptureError(
+                f"{point.id} violates four-momentum conservation: {imbalance}"
+            )
+        for index, (momentum, mass) in enumerate(
+            zip(point.momenta, masses, strict=True)
+        ):
+            residual = _mass_square(momentum) - mass * mass
+            if abs(residual) > shell_tolerance:
+                raise CaptureError(
+                    f"{point.id} momentum {index} is off shell by {residual}"
+                )
+            if momentum[0] <= 0:
+                raise CaptureError(
+                    f"{point.id} momentum {index} has non-positive energy"
+                )
+
+
+def _particle_field(particle: object, *names: str) -> object:
+    if isinstance(particle, Mapping):
+        for name in names:
+            if name in particle:
+                return particle[name]
+    for name in names:
+        if hasattr(particle, name):
+            return getattr(particle, name)
+    raise CaptureError(f"external particle is missing {names[0]}")
+
+
+def _leg_particle_token(name: str) -> str:
+    token = name.replace("~", "bar").replace("+", "plus").replace("-", "minus")
+    token = _PUBLIC_ID_PART_RE.sub("-", token).strip("-")
+    if not token:
+        raise CaptureError(f"cannot derive a stable leg ID from particle {name!r}")
+    return token
+
+
+def stable_external_leg_ids(particles: Sequence[object]) -> tuple[str, ...]:
+    """Derive role-aware stable IDs, numbering only identical role/particle legs."""
+
+    identities: list[tuple[str, str]] = []
+    for particle in particles:
+        raw_state = str(_particle_field(particle, "state", "role"))
+        state = {"initial": "incoming", "final": "outgoing"}.get(raw_state, raw_state)
+        if state not in {"incoming", "outgoing"}:
+            raise CaptureError(f"unsupported external-particle state {raw_state!r}")
+        name = str(_particle_field(particle, "name", "particle"))
+        identities.append((state, _leg_particle_token(name)))
+    totals = Counter(identities)
+    seen: Counter[tuple[str, str]] = Counter()
+    identifiers: list[str] = []
+    for identity in identities:
+        seen[identity] += 1
+        suffix = f"-{seen[identity]}" if totals[identity] > 1 else ""
+        identifiers.append(f"leg:{identity[0]}-{identity[1]}{suffix}")
+    if len(set(identifiers)) != len(identifiers):
+        raise CaptureError("stable external leg IDs are not unique")
+    return tuple(identifiers)
diff --git a/pyamplicol/tools/developer/reference_capture/provenance.py b/pyamplicol/tools/developer/reference_capture/provenance.py
new file mode 100644
index 0000000000..741978c99f
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_capture/provenance.py
@@ -0,0 +1,452 @@
+# SPDX-License-Identifier: 0BSD
+"""Tracked-source and dependency provenance for reference capture."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import json
+import os
+import re
+import subprocess
+import tomllib
+from collections.abc import Mapping
+from importlib import metadata
+from pathlib import Path
+from typing import cast
+from urllib.parse import urlparse
+
+from .common import (
+    CONTRIBUTOR_LOCK,
+    INSTALL_STATE,
+    RELEASE_LOCK,
+    ROOT,
+    CaptureError,
+    DependencySnapshot,
+    RuntimeSnapshot,
+    SourceSnapshot,
+    as_mapping,
+    canonical_sha256,
+    developer_module,
+    sha256_file,
+)
+
+_SHA256_RE = re.compile(r"^[a-f0-9]{64}$")
+_GIT_REVISION_RE = re.compile(r"^[a-f0-9]{40}$")
+_OFFICIAL_SYMJIT_SOURCE_URL = "https://github.com/siravan/symjit-crate.git"
+with RELEASE_LOCK.open("rb") as _release_stream:
+    _RELEASE_VERSION = str(tomllib.load(_release_stream)["project"]["version"])
+
+
+def _git_environment() -> dict[str, str]:
+    environment = dict(os.environ)
+    environment.update({"LC_ALL": "C", "LANG": "C"})
+    return environment
+
+
+def _git_bytes(root: Path, *arguments: str) -> bytes:
+    completed = subprocess.run(
+        ["git", *arguments],
+        cwd=root,
+        env=_git_environment(),
+        check=False,
+        capture_output=True,
+    )
+    if completed.returncode != 0:
+        detail = completed.stderr.decode("utf-8", errors="replace").strip()
+        raise CaptureError(
+            f"git {' '.join(arguments)} failed in {root}"
+            + (f": {detail}" if detail else "")
+        )
+    return completed.stdout
+
+
+def require_clean_tracked_tree(root: Path) -> str:
+    """Require a clean checkout, including non-ignored untracked files."""
+
+    repository = Path(
+        _git_bytes(root, "rev-parse", "--show-toplevel").decode("utf-8").strip()
+    ).resolve()
+    if repository != root.resolve():
+        raise CaptureError(
+            f"capture root {root.resolve()} is not Git top-level {repository}"
+        )
+    status = _git_bytes(
+        root,
+        "status",
+        "--porcelain=v1",
+        "-z",
+        "--untracked-files=all",
+    )
+    if status:
+        entries = [
+            entry.decode("utf-8", errors="replace")
+            for entry in status.split(b"\0")
+            if entry
+        ]
+        rendered = ", ".join(entries[:8])
+        if len(entries) > 8:
+            rendered += f", and {len(entries) - 8} more"
+        raise CaptureError(
+            "fixture capture requires a clean source tree; commit, move, or "
+            f"ignore these changes first: {rendered}"
+        )
+    revision = _git_bytes(root, "rev-parse", "HEAD").decode("ascii").strip()
+    if _GIT_REVISION_RE.fullmatch(revision) is None:
+        raise CaptureError(f"HEAD is not a full Git SHA-1: {revision!r}")
+    return revision
+
+
+def tracked_source_tree_sha256(root: Path, revision: str = "HEAD") -> str:
+    """Hash tracked path, mode, type, and blob bytes in deterministic tree order."""
+
+    listing = _git_bytes(root, "ls-tree", "-r", "-z", "--full-tree", revision)
+    digest = hashlib.sha256(b"pyamplicol-tracked-source-tree-v1\0")
+    for raw_record in listing.split(b"\0"):
+        if not raw_record:
+            continue
+        try:
+            metadata, path = raw_record.split(b"\t", 1)
+            mode, object_type, object_id = metadata.split(b" ", 2)
+        except ValueError as error:
+            raise CaptureError("git ls-tree returned an invalid record") from error
+        content = (
+            _git_bytes(root, "cat-file", "blob", object_id.decode("ascii"))
+            if object_type == b"blob"
+            else object_id
+        )
+        for field in (mode, object_type, path, content):
+            digest.update(len(field).to_bytes(8, "big"))
+            digest.update(field)
+    return digest.hexdigest()
+
+
+def github_https_uri(origin: str) -> str:
+    """Normalize GitHub SSH remotes to a schema-compliant HTTPS URI."""
+
+    scp_prefix = "git@github.com:"
+    if origin.startswith(scp_prefix):
+        return "https://github.com/" + origin.removeprefix(scp_prefix)
+    parsed = urlparse(origin)
+    if parsed.scheme == "ssh" and parsed.hostname == "github.com":
+        return "https://github.com/" + parsed.path.lstrip("/")
+    if parsed.scheme in {"http", "https", "ssh", "git"} and parsed.netloc:
+        return origin
+    raise CaptureError(
+        f"Git origin {origin!r} is not an absolute repository URI; configure origin"
+    )
+
+
+def collect_source_snapshot(root: Path = ROOT) -> SourceSnapshot:
+    revision = require_clean_tracked_tree(root)
+    origin = _git_bytes(root, "remote", "get-url", "origin").decode("utf-8").strip()
+    return SourceSnapshot(
+        repository_uri=github_https_uri(origin),
+        revision=revision,
+        tree_sha256=tracked_source_tree_sha256(root, revision),
+    )
+
+
+def assert_source_snapshot_unchanged(
+    snapshot: SourceSnapshot,
+    root: Path = ROOT,
+) -> None:
+    revision = require_clean_tracked_tree(root)
+    digest = tracked_source_tree_sha256(root, revision)
+    if revision != snapshot.revision or digest != snapshot.tree_sha256:
+        raise CaptureError(
+            "tracked source changed during capture; retained artifacts were not "
+            "removed, but fixture files were not published"
+        )
+
+
+def _distribution_sha256(distribution: metadata.Distribution) -> str:
+    files = distribution.files
+    if files is None:
+        raise CaptureError("installed pyamplicol distribution has no file inventory")
+    digest = hashlib.sha256(b"pyamplicol-installed-distribution-v1\0")
+    included = 0
+    for package_path in sorted(files, key=lambda item: str(item)):
+        relative = Path(str(package_path))
+        if (
+            "__pycache__" in relative.parts
+            or relative.suffix in {".pyc", ".pyo"}
+            or relative.name in {"INSTALLER", "RECORD", "REQUESTED", "direct_url.json"}
+        ):
+            continue
+        path = Path(str(distribution.locate_file(package_path)))
+        if not path.is_file():
+            raise CaptureError(
+                f"installed pyamplicol distribution member is missing: {relative}"
+            )
+        encoded = relative.as_posix().encode("utf-8")
+        content = path.read_bytes()
+        digest.update(len(encoded).to_bytes(8, "big"))
+        digest.update(encoded)
+        digest.update(len(content).to_bytes(8, "big"))
+        digest.update(content)
+        included += 1
+    if included == 0:
+        raise CaptureError("installed pyamplicol distribution inventory is empty")
+    return digest.hexdigest()
+
+
+def collect_runtime_snapshot(source: SourceSnapshot) -> RuntimeSnapshot:
+    """Bind capture to one installed candidate built from ``source`` exactly."""
+
+    try:
+        package = importlib.import_module("pyamplicol")
+        raw_package_path = getattr(package, "__file__", None)
+        if not isinstance(raw_package_path, str):
+            raise CaptureError("installed pyamplicol module has no filesystem path")
+        package_path = Path(raw_package_path).resolve(strict=True)
+        distribution = metadata.distribution("pyamplicol")
+    except (
+        AttributeError,
+        ImportError,
+        metadata.PackageNotFoundError,
+        OSError,
+    ) as error:
+        raise CaptureError(
+            "reference capture requires an installed pyamplicol candidate wheel"
+        ) from error
+    source_package = (ROOT / "src" / "pyamplicol").resolve()
+    if package_path.is_relative_to(source_package):
+        raise CaptureError(
+            "reference capture may not import pyamplicol directly from the source "
+            "tree; "
+            "install a candidate wheel built from the clean revision"
+        )
+    build_info_path = package_path.parent / "_build_info.json"
+    try:
+        build_info = as_mapping(
+            json.loads(build_info_path.read_text(encoding="utf-8")),
+            "installed pyamplicol _build_info.json",
+        )
+    except (OSError, json.JSONDecodeError) as error:
+        raise CaptureError(
+            "installed pyamplicol is not a provenance-marked candidate wheel"
+        ) from error
+    version = str(build_info.get("version", ""))
+    fingerprint = str(build_info.get("candidate_fingerprint", ""))
+    revision = str(build_info.get("source_revision", ""))
+    if (
+        build_info.get("schema_version") != 1
+        or build_info.get("publishable") is not False
+        or re.fullmatch(r"[a-f0-9]{12}", fingerprint) is None
+        or version != f"{_RELEASE_VERSION}.dev0+candidate.{fingerprint}"
+    ):
+        raise CaptureError(
+            "installed pyamplicol has invalid candidate build provenance"
+        )
+    if revision != source.revision:
+        raise CaptureError(
+            "installed pyamplicol candidate was not built from the clean capture "
+            f"revision {source.revision}; found {revision or 'no source revision'}"
+        )
+    if str(getattr(package, "__version__", "")) != version:
+        raise CaptureError(
+            "installed pyamplicol module version differs from its candidate marker"
+        )
+    if distribution.version != version:
+        raise CaptureError(
+            "installed pyamplicol distribution version differs from its candidate "
+            "marker"
+        )
+    return RuntimeSnapshot(
+        version=version,
+        candidate_fingerprint=fingerprint,
+        source_revision=revision,
+        distribution_sha256=_distribution_sha256(distribution),
+        build_info_sha256=sha256_file(build_info_path),
+    )
+
+
+def assert_runtime_snapshot_unchanged(
+    snapshot: RuntimeSnapshot,
+    source: SourceSnapshot,
+) -> None:
+    if collect_runtime_snapshot(source) != snapshot:
+        raise CaptureError("installed pyamplicol candidate changed during capture")
+
+
+def collect_dependency_snapshot(runtime: RuntimeSnapshot) -> DependencySnapshot:
+    """Bind dependency records to the release lock and installed source state."""
+
+    try:
+        with RELEASE_LOCK.open("rb") as stream:
+            release = cast(Mapping[str, object], tomllib.load(stream))
+        with CONTRIBUTOR_LOCK.open("rb") as stream:
+            contributor = cast(Mapping[str, object], tomllib.load(stream))
+        state = cast(
+            Mapping[str, object],
+            json.loads(INSTALL_STATE.read_text(encoding="utf-8")),
+        )
+    except (OSError, json.JSONDecodeError, tomllib.TOMLDecodeError) as error:
+        raise CaptureError(f"cannot read dependency provenance: {error}") from error
+    if (
+        release.get("schema_version") != 1
+        or contributor.get("schema_version") != 1
+        or state.get("schema_version") != 1
+    ):
+        raise CaptureError(
+            "release-lock, contributor-lock, and install-state schema versions "
+            "must be 1"
+        )
+    if state.get("publishable") is not False:
+        raise CaptureError("reference capture requires non-publishable install state")
+
+    release_digest = sha256_file(RELEASE_LOCK)
+    sources = as_mapping(state.get("sources"), "install-state.sources")
+    symbolica = as_mapping(
+        contributor.get("symbolica"),
+        "contributor-lock.symbolica",
+    )
+    symjit = as_mapping(contributor.get("symjit"), "contributor-lock.symjit")
+    loader = {
+        **as_mapping(
+            release.get("ufo_model_loader"),
+            "release-lock.ufo_model_loader",
+        ),
+        **as_mapping(
+            contributor.get("ufo_model_loader"),
+            "contributor-lock.ufo_model_loader",
+        ),
+    }
+    legacy = as_mapping(
+        contributor.get("legacy_amplicol"),
+        "contributor-lock.legacy_amplicol",
+    )
+    release_abis = as_mapping(release.get("abis"), "release-lock.abis")
+    contributor_abis = as_mapping(
+        contributor.get("abis"),
+        "contributor-lock.abis",
+    )
+    project = as_mapping(release.get("project"), "release-lock.project")
+    symbolica_source = as_mapping(sources.get("symbolica"), "source symbolica")
+    symjit_source = as_mapping(sources.get("symjit"), "source symjit")
+
+    symbolica_descriptor = {
+        "url": symbolica.get("source_url"),
+        "revision": symbolica.get("candidate_revision"),
+    }
+    symjit_descriptor = {
+        "url": symjit.get("repository"),
+        "revision": symjit.get("revision"),
+    }
+    for name, descriptor, installed in (
+        ("Symbolica", symbolica_descriptor, symbolica_source),
+        ("SymJIT", symjit_descriptor, symjit_source),
+    ):
+        source_url = descriptor["url"]
+        revision = descriptor["revision"]
+        if (
+            not isinstance(source_url, str)
+            or not source_url
+            or not isinstance(revision, str)
+            or _GIT_REVISION_RE.fullmatch(revision) is None
+        ):
+            raise CaptureError(f"{name} dependency source contract is invalid")
+        if installed.get("url") != source_url or installed.get("revision") != revision:
+            raise CaptureError(
+                f"installed {name} source does not match its dependency contract"
+            )
+    if symjit_descriptor["url"] != _OFFICIAL_SYMJIT_SOURCE_URL:
+        raise CaptureError("release lock does not use the official SymJIT repository")
+
+    legacy_module = developer_module("legacy_amplicol")
+    legacy_digest = canonical_sha256(
+        {
+            "branch": legacy_module.checkout_branch(),
+            "revision": legacy_module.expected_revision(),
+            "source_url": str(legacy["source_url"]),
+        }
+    )
+    analytic_path = ROOT / "tools" / "developer" / "analytic_oracles.py"
+    payloads: tuple[dict[str, object], ...] = (
+        {
+            "id": "dependency:pyamplicol-candidate",
+            "name": "Installed pyAmpliCol capture candidate",
+            "version": runtime.version,
+            "revision": runtime.source_revision,
+            "content_sha256": runtime.distribution_sha256,
+            "serialization_abi": str(release_abis["symbolica_serialization"]),
+            "license": str(project["license"]),
+        },
+        {
+            "id": "dependency:release-lock",
+            "name": "pyAmpliCol dependency release lock",
+            "version": "schema-1",
+            "revision": None,
+            "content_sha256": release_digest,
+            "serialization_abi": str(release_abis["symbolica_serialization"]),
+            "license": str(project["license"]),
+        },
+        {
+            "id": "dependency:install-state",
+            "name": "pyAmpliCol installed dependency state",
+            "version": "schema-1",
+            "revision": None,
+            "content_sha256": sha256_file(INSTALL_STATE),
+            "serialization_abi": str(release_abis["symbolica_serialization"]),
+            "license": str(project["license"]),
+        },
+        {
+            "id": "dependency:symbolica",
+            "name": "Symbolica",
+            "version": str(symbolica["candidate_version"]),
+            "revision": str(symbolica_descriptor["revision"]),
+            "content_sha256": canonical_sha256(symbolica_descriptor),
+            "serialization_abi": str(contributor_abis["symbolica_serialization"]),
+            "license": "Symbolica proprietary",
+        },
+        {
+            "id": "dependency:symjit",
+            "name": "Symjit",
+            "version": str(symjit["candidate_version"]),
+            "revision": str(symjit_descriptor["revision"]),
+            "content_sha256": canonical_sha256(symjit_descriptor),
+            "serialization_abi": str(release_abis["symjit_application"]),
+            "license": "MIT",
+        },
+        {
+            "id": "dependency:ufo-model-loader",
+            "name": "ufo-model-loader",
+            "version": str(loader["required_version"]),
+            "revision": str(loader["published_revision"]),
+            "content_sha256": str(loader["wheel_sha256"]),
+            "serialization_abi": None,
+            "license": str(loader["license"]),
+        },
+        {
+            "id": "dependency:legacy-amplicol",
+            "name": "Pinned legacy Fortran AmpliCol",
+            "version": str(legacy["release_status"]),
+            "revision": str(legacy["revision"]),
+            "content_sha256": legacy_digest,
+            "serialization_abi": None,
+            "license": str(legacy["license"]),
+        },
+        {
+            "id": "dependency:analytic-oracles",
+            "name": "pyAmpliCol independent analytic oracles",
+            "version": "1",
+            "revision": None,
+            "content_sha256": sha256_file(analytic_path),
+            "serialization_abi": None,
+            "license": "0BSD",
+        },
+    )
+    for payload in payloads:
+        digest = str(payload["content_sha256"])
+        if _SHA256_RE.fullmatch(digest) is None or digest == "0" * 64:
+            raise CaptureError(
+                f"dependency {payload['id']} has invalid content digest {digest!r}"
+            )
+    return DependencySnapshot(payloads, release, contributor, state)
+
+
+def default_artifact_root(revision: str) -> Path:
+    if _GIT_REVISION_RE.fullmatch(revision) is None:
+        raise CaptureError("default artifact roots require a full Git revision")
+    return ROOT / ".artifacts" / "reference-fixture-v2" / revision
diff --git a/pyamplicol/tools/developer/reference_fixture/__init__.py b/pyamplicol/tools/developer/reference_fixture/__init__.py
new file mode 100644
index 0000000000..7b9438ad89
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_fixture/__init__.py
@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: 0BSD
+"""Strict typed reference-physics fixture reader."""
+
+from .api import load_reference_fixture, parse_reference_fixture
+from .codec import (
+    _parse_point,
+    _validate_evidence_record_hashes,
+    _validate_physics_case_hashes,
+    _validate_reduction_plan_hashes,
+    _validate_wire,
+    evidence_record_sha256,
+    physics_case_sha256,
+    reduction_plan_sha256,
+)
+from .model import (
+    ColorAxis,
+    ComplexDecimal,
+    ContractedColorComponent,
+    Coverage,
+    DependencyProvenance,
+    FixtureProvenance,
+    HelicityAxis,
+    LCColorFlow,
+    ModelProvenance,
+    Normalization,
+    Observation,
+    OracleEvidence,
+    OracleEvidenceSet,
+    OracleProvenance,
+    PointAlgorithm,
+    Process,
+    ProcessIdentity,
+    Reduction,
+    ReductionGroup,
+    ReferenceCase,
+    ReferenceFixture,
+    ReferenceFixtureError,
+    ReferencePoint,
+    Selectors,
+    StressMetric,
+    Tolerances,
+    Topology,
+)
+from .numerics import _within_tolerance
+
+__all__ = [
+    "ColorAxis",
+    "ComplexDecimal",
+    "ContractedColorComponent",
+    "Coverage",
+    "DependencyProvenance",
+    "FixtureProvenance",
+    "HelicityAxis",
+    "LCColorFlow",
+    "ModelProvenance",
+    "Normalization",
+    "Observation",
+    "OracleEvidence",
+    "OracleEvidenceSet",
+    "OracleProvenance",
+    "PointAlgorithm",
+    "Process",
+    "ProcessIdentity",
+    "Reduction",
+    "ReductionGroup",
+    "ReferenceCase",
+    "ReferenceFixture",
+    "ReferenceFixtureError",
+    "ReferencePoint",
+    "Selectors",
+    "StressMetric",
+    "Tolerances",
+    "Topology",
+    "_parse_point",
+    "_validate_evidence_record_hashes",
+    "_validate_physics_case_hashes",
+    "_validate_reduction_plan_hashes",
+    "_validate_wire",
+    "_within_tolerance",
+    "evidence_record_sha256",
+    "load_reference_fixture",
+    "parse_reference_fixture",
+    "physics_case_sha256",
+    "reduction_plan_sha256",
+]
diff --git a/pyamplicol/tools/developer/reference_fixture/api.py b/pyamplicol/tools/developer/reference_fixture/api.py
new file mode 100644
index 0000000000..78db18ac89
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_fixture/api.py
@@ -0,0 +1,447 @@
+# SPDX-License-Identifier: 0BSD
+"""Public parsing API and cross-document fixture validation."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from decimal import Decimal
+from pathlib import Path
+
+from .codec import (
+    _array,
+    _canonical_sha256,
+    _object,
+    _parse_case,
+    _parse_dependency,
+    _parse_evidence_set,
+    _parse_model,
+    _parse_point,
+    _parse_process,
+    _parse_provenance,
+    _string,
+    _strings,
+    _validate_evidence_record_hashes,
+    _validate_physics_case_hashes,
+    _validate_reduction_plan_hashes,
+    _validate_wire,
+)
+from .evidence import _validate_evidence, _validate_oracle_provenance
+from .model import (
+    Observation,
+    OracleEvidence,
+    Process,
+    ReferenceFixture,
+    ReferenceFixtureError,
+    ReferencePoint,
+)
+from .numerics import (
+    _as_fraction,
+    _exact_sum,
+    _required_stress_certified_digits,
+    _validate_point_kinematics,
+    _validate_precision_metadata,
+)
+from .structure import (
+    _unique,
+    _validate_case_axes,
+    _validate_digest,
+    _validate_observation_reduction_relations,
+    _validate_processes,
+)
+
+
+def _validate_semantics(fixture: ReferenceFixture) -> None:
+    dependencies = _unique(fixture.dependencies, "dependency")
+    models = _unique(fixture.models, "model")
+    processes = _unique(fixture.processes, "process")
+    points = _unique(fixture.points, "point")
+    _unique(fixture.cases, "case")
+    evidence_sets = _unique(fixture.evidence_sets, "evidence set")
+    evidence = _unique(
+        (
+            record
+            for evidence_set in fixture.evidence_sets
+            for record in evidence_set.records
+        ),
+        "evidence",
+    )
+    oracle_by_evidence_id = {
+        record.id: evidence_set.oracle
+        for evidence_set in fixture.evidence_sets
+        for record in evidence_set.records
+    }
+
+    if not fixture.provenance.working_tree_clean:
+        raise ReferenceFixtureError("reference fixtures require a clean source tree")
+    if fixture.provenance.source_revision == "0" * 40:
+        raise ReferenceFixtureError("reference fixtures require a real source revision")
+    _validate_digest(
+        fixture.provenance.source_tree_sha256,
+        "provenance.source_tree_sha256",
+    )
+    for dependency in fixture.dependencies:
+        _validate_digest(
+            dependency.content_sha256,
+            f"dependency {dependency.id} content_sha256",
+        )
+    for model in fixture.models:
+        _validate_digest(model.content_sha256, f"model {model.id} content_sha256")
+        _validate_digest(
+            model.compiled_model_sha256,
+            f"model {model.id} compiled_model_sha256",
+        )
+    for case in fixture.cases:
+        _validate_digest(
+            case.artifact_physics_sha256,
+            f"case {case.id} artifact_physics_sha256",
+        )
+        _validate_digest(
+            case.artifact_execution_sha256,
+            f"case {case.id} artifact_execution_sha256",
+        )
+        _validate_digest(
+            case.physics_case_sha256,
+            f"case {case.id} physics_case_sha256",
+        )
+        _validate_digest(
+            case.reduction.plan_sha256,
+            f"case {case.id} reduction.plan_sha256",
+        )
+    for evidence_set in fixture.evidence_sets:
+        _validate_oracle_provenance(evidence_set.oracle)
+        _validate_digest(
+            evidence_set.oracle.content_sha256,
+            f"oracle {evidence_set.oracle.id} content_sha256",
+        )
+        for record in evidence_set.records:
+            _validate_digest(
+                record.oracle_output_sha256,
+                f"evidence {record.id} oracle_output_sha256",
+            )
+            _validate_digest(
+                record.evidence_record_sha256,
+                f"evidence {record.id} evidence_record_sha256",
+            )
+            _validate_digest(
+                record.physics_case_sha256,
+                f"evidence {record.id} physics_case_sha256",
+            )
+
+    _validate_processes(processes)
+    for model in fixture.models:
+        unknown = set(model.dependency_ids) - dependencies.keys()
+        if unknown:
+            raise ReferenceFixtureError(
+                f"model {model.id} references unknown dependencies: {sorted(unknown)}"
+            )
+    for evidence_set in fixture.evidence_sets:
+        unknown = set(evidence_set.dependency_ids) - dependencies.keys()
+        if unknown:
+            raise ReferenceFixtureError(
+                f"evidence set {evidence_set.id} references unknown dependencies: "
+                f"{sorted(unknown)}"
+            )
+
+    masses_by_process: dict[str, tuple[Decimal, ...]] = {}
+    for point in fixture.points:
+        process = processes.get(point.process_id)
+        if not isinstance(process, Process):
+            raise ReferenceFixtureError(
+                f"point {point.id} references unknown process {point.process_id}"
+            )
+        _validate_point_kinematics(point, process)
+        previous_masses = masses_by_process.setdefault(point.process_id, point.masses)
+        if previous_masses != point.masses:
+            raise ReferenceFixtureError(
+                f"point {point.id} changes explicit per-leg masses for process "
+                f"{process.id}"
+            )
+
+    used_evidence: set[str] = set()
+    for case in fixture.cases:
+        if case.model_id not in models:
+            raise ReferenceFixtureError(
+                f"case {case.id} references unknown model {case.model_id}"
+            )
+        process = processes.get(case.process_id)
+        if not isinstance(process, Process):
+            raise ReferenceFixtureError(
+                f"case {case.id} references unknown process {case.process_id}"
+            )
+        case_points: list[ReferencePoint] = []
+        for point_id in case.point_ids:
+            case_point = points.get(point_id)
+            if not isinstance(case_point, ReferencePoint):
+                raise ReferenceFixtureError(
+                    f"case {case.id} references unknown point {point_id}"
+                )
+            if case_point.process_id != case.process_id:
+                raise ReferenceFixtureError(
+                    f"case {case.id} point {case_point.id} belongs to another process"
+                )
+            case_points.append(case_point)
+        if case.point_policy == "standard":
+            generic_count = sum(point.point_class == "generic" for point in case_points)
+            stress_count = sum(point.point_class == "stress" for point in case_points)
+            if generic_count < 3 or stress_count < 1:
+                raise ReferenceFixtureError(
+                    f"standard case {case.id} requires at least three generic "
+                    "points and one stress point"
+                )
+            physics_momenta = [
+                point.momenta
+                for point in case_points
+                if point.point_class in {"generic", "stress"}
+            ]
+            if len(set(physics_momenta)) != len(physics_momenta):
+                raise ReferenceFixtureError(
+                    f"standard case {case.id} requires distinct generic/stress momenta"
+                )
+        else:
+            if process.initial_state_count != 2 or len(process.external_pdgs) != 3:
+                raise ReferenceFixtureError(
+                    f"degenerate-2to1 case {case.id} requires exactly two incoming "
+                    "and one outgoing particle"
+                )
+            if len(case_points) != 1 or case_points[0].point_class != "canonical":
+                raise ReferenceFixtureError(
+                    f"degenerate-2to1 case {case.id} requires exactly one "
+                    "canonical point"
+                )
+        _validate_case_axes(case, process)
+        for value in (
+            case.normalization.average_factor,
+            case.normalization.color_factor,
+            case.normalization.identical_factor,
+            case.normalization.global_coupling_factor,
+            case.normalization.quark_line_partner_factor,
+        ):
+            if value <= 0:
+                raise ReferenceFixtureError(
+                    f"case {case.id} normalization factors must be positive"
+                )
+
+        observations = _unique(
+            case.observations,
+            f"case {case.id} observation",
+            key="point_id",
+        )
+        if set(observations) != set(case.point_ids):
+            raise ReferenceFixtureError(
+                f"case {case.id} must contain exactly one observation per point"
+            )
+        for point in case_points:
+            observation = observations[point.id]
+            assert isinstance(observation, Observation)
+            _validate_precision_metadata(
+                arithmetic_precision_bits=observation.arithmetic_precision_bits,
+                round_trip_decimal_digits=observation.round_trip_decimal_digits,
+                certified_decimal_digits=observation.certified_decimal_digits,
+                where=f"observation {case.id}/{point.id}",
+            )
+            if observation.certified_decimal_digits > point.certified_decimal_digits:
+                raise ReferenceFixtureError(
+                    f"observation {case.id}/{point.id} overclaims the certified "
+                    "point precision"
+                )
+            if point.point_class == "stress" and (
+                observation.certified_decimal_digits
+                < _required_stress_certified_digits(point)
+            ):
+                raise ReferenceFixtureError(
+                    f"stress observation {case.id}/{point.id} certification is not "
+                    "commensurate with the stress metric"
+                )
+            if len(observation.values) != len(case.helicities) or any(
+                len(row) != len(case.colors) for row in observation.values
+            ):
+                raise ReferenceFixtureError(
+                    f"observation {case.id}/{point.id} must be a dense "
+                    "[helicity][color] matrix"
+                )
+            for helicity, row in zip(case.helicities, observation.values, strict=True):
+                if helicity.structural_zero and any(value != 0 for value in row):
+                    raise ReferenceFixtureError(
+                        f"observation {case.id}/{point.id} does not explicitly "
+                        f"zero structural helicity {helicity.id}"
+                    )
+            _validate_observation_reduction_relations(case, observation)
+            total = _exact_sum(value for row in observation.values for value in row)
+            if total != _as_fraction(observation.total):
+                raise ReferenceFixtureError(
+                    f"observation {case.id}/{point.id} component sum does not "
+                    "equal its declared total"
+                )
+            covered_cells: set[tuple[str, str]] = set()
+            covered_aggregates: set[str] = set()
+            for evidence_id in observation.evidence_refs:
+                evidence_record = evidence.get(evidence_id)
+                if not isinstance(evidence_record, OracleEvidence):
+                    raise ReferenceFixtureError(
+                        f"observation {case.id}/{point.id} references unknown "
+                        f"evidence {evidence_id}"
+                    )
+                used_evidence.add(evidence_id)
+                oracle = oracle_by_evidence_id[evidence_id]
+                coverage = _validate_evidence(
+                    evidence_record,
+                    oracle=oracle,
+                    case=case,
+                    process=process,
+                    point=point,
+                    observation=observation,
+                )
+                covered_cells.update(coverage.resolved_cells)
+                covered_aggregates.update(coverage.helicity_aggregates)
+            color_ids = {color.id for color in case.colors}
+            fully_resolved_helicities = {
+                helicity.id
+                for helicity in case.helicities
+                if all(
+                    (helicity.id, color_id) in covered_cells for color_id in color_ids
+                )
+            }
+            required_helicities = {helicity.id for helicity in case.helicities}
+            if fully_resolved_helicities | covered_aggregates != required_helicities:
+                raise ReferenceFixtureError(
+                    f"observation {case.id}/{point.id} lacks independent resolved "
+                    "or complete-color aggregate evidence for every helicity"
+                )
+
+    unused = set(evidence) - used_evidence
+    if unused:
+        raise ReferenceFixtureError(f"unreferenced evidence records: {sorted(unused)}")
+    if not evidence_sets:
+        raise ReferenceFixtureError("at least one evidence set is required")
+
+
+def parse_reference_fixture(
+    payload: Mapping[str, object],
+    evidence_payloads: Sequence[Mapping[str, object]],
+) -> ReferenceFixture:
+    """Validate wire payloads and return an immutable typed fixture."""
+
+    _validate_wire(payload, "reference-physics-v2.schema.json", "fixture")
+    for index, evidence_payload in enumerate(evidence_payloads):
+        _validate_wire(
+            evidence_payload,
+            "reference-oracle-evidence-v2.schema.json",
+            f"evidence[{index}]",
+        )
+        _validate_evidence_record_hashes(evidence_payload)
+    _validate_reduction_plan_hashes(payload)
+    _validate_physics_case_hashes(payload)
+
+    fixture_evidence_ids = _strings(payload["evidence_sets"], "evidence_sets")
+    parsed_evidence = tuple(
+        _parse_evidence_set(evidence_payload, index)
+        for index, evidence_payload in enumerate(evidence_payloads)
+    )
+    if set(fixture_evidence_ids) != {item.id for item in parsed_evidence} or len(
+        fixture_evidence_ids
+    ) != len(parsed_evidence):
+        raise ReferenceFixtureError(
+            "fixture evidence_sets must match the supplied evidence documents exactly"
+        )
+
+    fixture = ReferenceFixture(
+        id=_string(payload["fixture_id"], "fixture_id"),
+        provenance=_parse_provenance(payload["provenance"]),
+        dependencies=tuple(
+            _parse_dependency(item, index)
+            for index, item in enumerate(
+                _array(payload["dependencies"], "dependencies")
+            )
+        ),
+        models=tuple(
+            _parse_model(item, index)
+            for index, item in enumerate(_array(payload["models"], "models"))
+        ),
+        processes=tuple(
+            _parse_process(item, index)
+            for index, item in enumerate(_array(payload["processes"], "processes"))
+        ),
+        points=tuple(
+            _parse_point(item, index)
+            for index, item in enumerate(_array(payload["points"], "points"))
+        ),
+        cases=tuple(
+            _parse_case(item, index)
+            for index, item in enumerate(_array(payload["cases"], "cases"))
+        ),
+        evidence_sets=parsed_evidence,
+    )
+    _validate_semantics(fixture)
+    return fixture
+
+
+def load_reference_fixture(
+    fixture_path: Path,
+    evidence_paths: Sequence[Path],
+) -> ReferenceFixture:
+    """Load a reference fixture and its independent evidence documents."""
+
+    all_paths = (fixture_path, *evidence_paths)
+    parents = {path.resolve(strict=False).parent for path in all_paths}
+    if len(parents) != 1:
+        raise ReferenceFixtureError(
+            "fixture and evidence documents must share one bundle directory"
+        )
+    directory = next(iter(parents))
+    manifest_path = directory / "reference-fixture-v2.manifest.json"
+    try:
+        manifest = _object(
+            json.loads(manifest_path.read_text(encoding="utf-8")),
+            str(manifest_path),
+        )
+    except (OSError, json.JSONDecodeError) as error:
+        raise ReferenceFixtureError(
+            f"reference fixture bundle commit marker is unavailable: {error}"
+        ) from error
+    _validate_wire(
+        manifest,
+        "reference-fixture-bundle-v1.schema.json",
+        "fixture bundle manifest",
+    )
+    expected_names = tuple(sorted(path.name for path in all_paths))
+    records = tuple(
+        _object(value, f"fixture bundle files[{index}]")
+        for index, value in enumerate(_array(manifest["files"], "files"))
+    )
+    actual_names = tuple(str(record["path"]) for record in records)
+    if actual_names != expected_names:
+        raise ReferenceFixtureError(
+            "fixture bundle manifest does not identify exactly the requested documents"
+        )
+    for record in records:
+        path = directory / str(record["path"])
+        try:
+            actual_digest = hashlib.sha256(path.read_bytes()).hexdigest()
+        except OSError as error:
+            raise ReferenceFixtureError(
+                f"fixture bundle member cannot be read: {path.name}: {error}"
+            ) from error
+        if actual_digest != record["sha256"]:
+            raise ReferenceFixtureError(
+                f"fixture bundle member digest mismatch: {path.name}"
+            )
+    expected_bundle_digest = _canonical_sha256(
+        {
+            "contract": "pyamplicol-reference-fixture-bundle-v1",
+            "files": [dict(record) for record in records],
+        }
+    )
+    if manifest["bundle_sha256"] != expected_bundle_digest:
+        raise ReferenceFixtureError("fixture bundle manifest digest is inconsistent")
+
+    payload = _object(
+        json.loads(fixture_path.read_text(encoding="utf-8")),
+        str(fixture_path),
+    )
+    evidence_payloads = tuple(
+        _object(json.loads(path.read_text(encoding="utf-8")), str(path))
+        for path in evidence_paths
+    )
+    return parse_reference_fixture(payload, evidence_payloads)
diff --git a/pyamplicol/tools/developer/reference_fixture/codec.py b/pyamplicol/tools/developer/reference_fixture/codec.py
new file mode 100644
index 0000000000..4556096f59
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_fixture/codec.py
@@ -0,0 +1,861 @@
+# SPDX-License-Identifier: 0BSD
+"""Wire-format parsing and canonical hashing for reference fixtures."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from collections.abc import Mapping, Sequence
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+
+import jsonschema  # type: ignore[import-untyped]
+
+from .model import (
+    ColorAxis,
+    ComplexDecimal,
+    ContractedColorComponent,
+    Coverage,
+    DependencyProvenance,
+    FixtureProvenance,
+    HelicityAxis,
+    LCColorFlow,
+    ModelProvenance,
+    Normalization,
+    Observation,
+    OracleEvidence,
+    OracleEvidenceSet,
+    OracleProvenance,
+    PointAlgorithm,
+    Process,
+    ProcessIdentity,
+    Reduction,
+    ReductionGroup,
+    ReferenceCase,
+    ReferenceFixtureError,
+    ReferencePoint,
+    Selectors,
+    StressMetric,
+    Tolerances,
+    Topology,
+)
+
+ROOT = Path(__file__).resolve().parents[3]
+SCHEMA_ROOT = ROOT / "schemas"
+
+_DECIMAL_RE = re.compile(
+    r"^(?:0|-?(?:(?:[1-9][0-9]*)(?:\.[0-9]*[1-9])?|0\.[0-9]*[1-9]))$"
+)
+
+
+def _schema(name: str) -> Mapping[str, object]:
+    payload = json.loads((SCHEMA_ROOT / name).read_text(encoding="utf-8"))
+    return _object(payload, f"schema {name}")
+
+
+def _validate_wire(payload: object, schema_name: str, label: str) -> None:
+    validator = jsonschema.Draft202012Validator(
+        _schema(schema_name),
+        format_checker=jsonschema.FormatChecker(),
+    )
+    errors = sorted(
+        validator.iter_errors(payload),
+        key=lambda error: tuple(str(part) for part in error.absolute_path),
+    )
+    if not errors:
+        return
+    error = errors[0]
+    path = ".".join(str(part) for part in error.absolute_path) or "<root>"
+    raise ReferenceFixtureError(f"{label} schema violation at {path}: {error.message}")
+
+
+def _object(value: object, where: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise ReferenceFixtureError(f"{where} must be an object")
+    return value
+
+
+def _array(value: object, where: str) -> Sequence[object]:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes, bytearray)):
+        raise ReferenceFixtureError(f"{where} must be an array")
+    return value
+
+
+def _string(value: object, where: str) -> str:
+    if not isinstance(value, str):
+        raise ReferenceFixtureError(f"{where} must be a string")
+    return value
+
+
+def _optional_string(value: object, where: str) -> str | None:
+    if value is None:
+        return None
+    return _string(value, where)
+
+
+def _integer(value: object, where: str) -> int:
+    if not isinstance(value, int) or isinstance(value, bool):
+        raise ReferenceFixtureError(f"{where} must be an integer")
+    return value
+
+
+def _optional_integer(value: object, where: str) -> int | None:
+    if value is None:
+        return None
+    return _integer(value, where)
+
+
+def _boolean(value: object, where: str) -> bool:
+    if not isinstance(value, bool):
+        raise ReferenceFixtureError(f"{where} must be a boolean")
+    return value
+
+
+def _decimal(value: object, where: str) -> Decimal:
+    text = _string(value, where)
+    if not _DECIMAL_RE.fullmatch(text):
+        raise ReferenceFixtureError(
+            f"{where} must be a canonical fixed-point decimal string"
+        )
+    try:
+        parsed = Decimal(text)
+    except InvalidOperation as error:
+        raise ReferenceFixtureError(f"{where} is not a finite decimal") from error
+    if not parsed.is_finite() or _decimal_text(parsed) != text:
+        raise ReferenceFixtureError(
+            f"{where} must be a canonical fixed-point decimal string"
+        )
+    return parsed
+
+
+def _decimal_text(value: Decimal) -> str:
+    return format(value, "f")
+
+
+def _canonical_sha256(value: object) -> str:
+    encoded = json.dumps(
+        value,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def evidence_record_sha256(record: Mapping[str, object]) -> str:
+    """Hash every canonical evidence field except the digest itself."""
+
+    payload = dict(record)
+    payload.pop("evidence_record_sha256", None)
+    return _canonical_sha256(
+        {
+            "contract": "pyamplicol-reference-oracle-evidence-record-v2",
+            "record": payload,
+        }
+    )
+
+
+def reduction_plan_sha256(reduction: Mapping[str, object]) -> str:
+    """Hash the complete normalized reduction mapping except its digest."""
+
+    payload = dict(reduction)
+    payload.pop("plan_sha256", None)
+    return _canonical_sha256(
+        {
+            "contract": "pyamplicol-reference-reduction-plan-v1",
+            "reduction": payload,
+        }
+    )
+
+
+def _validate_reduction_plan_hashes(payload: Mapping[str, object]) -> None:
+    for index, raw_case in enumerate(_array(payload["cases"], "cases")):
+        case = _object(raw_case, f"cases[{index}]")
+        reduction = _object(case["reduction"], f"cases[{index}].reduction")
+        actual = _string(
+            reduction["plan_sha256"],
+            f"cases[{index}].reduction.plan_sha256",
+        )
+        expected = reduction_plan_sha256(reduction)
+        if actual != expected:
+            raise ReferenceFixtureError(
+                f"case {case.get('id', index)!r} reduction plan hash does not "
+                "cover its complete normalized mapping"
+            )
+
+
+def _validate_evidence_record_hashes(payload: Mapping[str, object]) -> None:
+    for index, raw_record in enumerate(_array(payload["records"], "records")):
+        record = _object(raw_record, f"records[{index}]")
+        actual = _string(
+            record["evidence_record_sha256"],
+            f"records[{index}].evidence_record_sha256",
+        )
+        expected = evidence_record_sha256(record)
+        if actual != expected:
+            raise ReferenceFixtureError(
+                f"evidence record {record.get('id', index)!r} canonical hash "
+                "does not cover its complete normalized record"
+            )
+
+
+def physics_case_sha256(
+    fixture_payload: Mapping[str, object],
+    case_id: str,
+) -> str:
+    """Hash the complete canonical contract for one fixture physics case."""
+
+    cases = [
+        _object(value, "case")
+        for value in _array(fixture_payload["cases"], "cases")
+        if _object(value, "case").get("id") == case_id
+    ]
+    if len(cases) != 1:
+        raise ReferenceFixtureError(
+            f"physics case contract requires exactly one case {case_id}"
+        )
+    case = cases[0]
+    model_id = _string(case["model_id"], f"case {case_id}.model_id")
+    process_id = _string(case["process_id"], f"case {case_id}.process_id")
+
+    models = [
+        _object(value, "model")
+        for value in _array(fixture_payload["models"], "models")
+        if _object(value, "model").get("id") == model_id
+    ]
+    process_records = [
+        _object(value, "process")
+        for value in _array(fixture_payload["processes"], "processes")
+    ]
+    processes_by_id = {
+        _string(value["id"], "process.id"): value for value in process_records
+    }
+    process = processes_by_id.get(process_id)
+    if len(models) != 1 or process is None:
+        raise ReferenceFixtureError(
+            f"physics case contract {case_id} has ambiguous model or process identity"
+        )
+    model = models[0]
+    process_chain = [process]
+    seen_process_ids = {process_id}
+    while process_chain[-1].get("alias_of") is not None:
+        source_id = _string(
+            process_chain[-1]["alias_of"],
+            f"process {process_chain[-1]['id']}.alias_of",
+        )
+        if source_id in seen_process_ids:
+            raise ReferenceFixtureError(
+                f"physics case contract {case_id} contains a process alias cycle"
+            )
+        source = processes_by_id.get(source_id)
+        if source is None:
+            raise ReferenceFixtureError(
+                f"physics case contract {case_id} references unknown alias source "
+                f"{source_id}"
+            )
+        seen_process_ids.add(source_id)
+        process_chain.append(source)
+
+    dependencies_by_id = {
+        _string(item["id"], "dependency.id"): item
+        for item in (
+            _object(value, "dependency")
+            for value in _array(fixture_payload["dependencies"], "dependencies")
+        )
+    }
+    dependency_ids = _strings(
+        model["dependency_ids"], f"model {model_id}.dependency_ids"
+    )
+    try:
+        model_dependencies = [dependencies_by_id[value] for value in dependency_ids]
+    except KeyError as error:
+        raise ReferenceFixtureError(
+            f"physics case contract {case_id} references an unknown dependency"
+        ) from error
+
+    points_by_id = {
+        _string(item["id"], "point.id"): item
+        for item in (
+            _object(value, "point")
+            for value in _array(fixture_payload["points"], "points")
+        )
+    }
+    point_ids = _strings(case["point_ids"], f"case {case_id}.point_ids")
+    try:
+        case_points = [points_by_id[value] for value in point_ids]
+    except KeyError as error:
+        raise ReferenceFixtureError(
+            f"physics case contract {case_id} references an unknown point"
+        ) from error
+
+    canonical_case = {
+        key: value for key, value in case.items() if key != "physics_case_sha256"
+    }
+    return _canonical_sha256(
+        {
+            "case": canonical_case,
+            "contract": "pyamplicol-reference-physics-case-v2",
+            "fixture_kind": fixture_payload["kind"],
+            "fixture_schema_version": fixture_payload["fixture_schema_version"],
+            "model": model,
+            "model_dependencies": model_dependencies,
+            "points": case_points,
+            "process": process,
+            "process_alias_sources": process_chain[1:],
+        }
+    )
+
+
+def _validate_physics_case_hashes(payload: Mapping[str, object]) -> None:
+    for index, value in enumerate(_array(payload["cases"], "cases")):
+        case = _object(value, f"cases[{index}]")
+        case_id = _string(case["id"], f"cases[{index}].id")
+        actual = _string(
+            case["physics_case_sha256"], f"cases[{index}].physics_case_sha256"
+        )
+        expected = physics_case_sha256(payload, case_id)
+        if actual != expected:
+            raise ReferenceFixtureError(
+                f"case {case_id} physics case hash does not cover its complete "
+                "canonical contract"
+            )
+
+
+def _strings(value: object, where: str) -> tuple[str, ...]:
+    return tuple(
+        _string(item, f"{where}[{index}]")
+        for index, item in enumerate(_array(value, where))
+    )
+
+
+def _integers(value: object, where: str) -> tuple[int, ...]:
+    return tuple(
+        _integer(item, f"{where}[{index}]")
+        for index, item in enumerate(_array(value, where))
+    )
+
+
+def _decimals(value: object, where: str) -> tuple[Decimal, ...]:
+    return tuple(
+        _decimal(item, f"{where}[{index}]")
+        for index, item in enumerate(_array(value, where))
+    )
+
+
+def _decimal_matrix(
+    value: object,
+    where: str,
+) -> tuple[tuple[Decimal, ...], ...]:
+    return tuple(
+        _decimals(row, f"{where}[{index}]")
+        for index, row in enumerate(_array(value, where))
+    )
+
+
+def _parse_provenance(value: object) -> FixtureProvenance:
+    item = _object(value, "provenance")
+    return FixtureProvenance(
+        source_repository=_string(item["source_repository"], "source_repository"),
+        source_revision=_string(item["source_revision"], "source_revision"),
+        source_tree_sha256=_string(item["source_tree_sha256"], "source_tree_sha256"),
+        captured_at=_string(item["captured_at"], "captured_at"),
+        capture_command=_strings(item["capture_command"], "capture_command"),
+        working_tree_clean=_boolean(item["working_tree_clean"], "working_tree_clean"),
+        memory_watchdog_gb=_integer(item["memory_watchdog_gb"], "memory_watchdog_gb"),
+    )
+
+
+def _parse_dependency(value: object, index: int) -> DependencyProvenance:
+    where = f"dependencies[{index}]"
+    item = _object(value, where)
+    return DependencyProvenance(
+        id=_string(item["id"], f"{where}.id"),
+        name=_string(item["name"], f"{where}.name"),
+        version=_string(item["version"], f"{where}.version"),
+        revision=_optional_string(item["revision"], f"{where}.revision"),
+        content_sha256=_string(item["content_sha256"], f"{where}.content_sha256"),
+        serialization_abi=_optional_string(
+            item["serialization_abi"], f"{where}.serialization_abi"
+        ),
+        license=_string(item["license"], f"{where}.license"),
+    )
+
+
+def _parse_complex_decimal(value: object, where: str) -> ComplexDecimal:
+    item = _object(value, where)
+    return ComplexDecimal(
+        real=_decimal(item["real"], f"{where}.real"),
+        imag=_decimal(item["imag"], f"{where}.imag"),
+    )
+
+
+def _parse_model(value: object, index: int) -> ModelProvenance:
+    where = f"models[{index}]"
+    item = _object(value, where)
+    parameters = _object(item["parameter_defaults"], f"{where}.parameter_defaults")
+    return ModelProvenance(
+        id=_string(item["id"], f"{where}.id"),
+        name=_string(item["name"], f"{where}.name"),
+        source_kind=_string(item["source_kind"], f"{where}.source_kind"),
+        content_sha256=_string(item["content_sha256"], f"{where}.content_sha256"),
+        compiled_model_sha256=_string(
+            item["compiled_model_sha256"], f"{where}.compiled_model_sha256"
+        ),
+        compiled_schema_version=_integer(
+            item["compiled_schema_version"], f"{where}.compiled_schema_version"
+        ),
+        restriction=_optional_string(item["restriction"], f"{where}.restriction"),
+        dependency_ids=_strings(item["dependency_ids"], f"{where}.dependency_ids"),
+        parameter_defaults=tuple(
+            (
+                name,
+                _parse_complex_decimal(parameter, f"{where}.parameter_defaults.{name}"),
+            )
+            for name, parameter in sorted(parameters.items())
+        ),
+    )
+
+
+def _parse_process(value: object, index: int) -> Process:
+    where = f"processes[{index}]"
+    item = _object(value, where)
+    permutation = item["final_state_permutation"]
+    return Process(
+        id=_string(item["id"], f"{where}.id"),
+        expression=_string(item["expression"], f"{where}.expression"),
+        external_pdgs=_integers(item["external_pdgs"], f"{where}.external_pdgs"),
+        external_labels=_integers(item["external_labels"], f"{where}.external_labels"),
+        external_leg_ids=_strings(
+            item["external_leg_ids"], f"{where}.external_leg_ids"
+        ),
+        external_spins=_integers(item["external_spins"], f"{where}.external_spins"),
+        external_colors=_integers(item["external_colors"], f"{where}.external_colors"),
+        external_masses=_decimals(item["external_masses"], f"{where}.external_masses"),
+        external_helicity_domains=tuple(
+            _integers(domain, f"{where}.external_helicity_domains[{domain_index}]")
+            for domain_index, domain in enumerate(
+                _array(
+                    item["external_helicity_domains"],
+                    f"{where}.external_helicity_domains",
+                )
+            )
+        ),
+        initial_state_count=_integer(
+            item["initial_state_count"], f"{where}.initial_state_count"
+        ),
+        alias_of=_optional_string(item["alias_of"], f"{where}.alias_of"),
+        final_state_permutation=(
+            None
+            if permutation is None
+            else _integers(permutation, f"{where}.final_state_permutation")
+        ),
+    )
+
+
+def _parse_stress_metric(value: object, where: str) -> StressMetric | None:
+    if value is None:
+        return None
+    item = _object(value, where)
+    return StressMetric(
+        kind=_string(item["kind"], f"{where}.kind"),
+        value=_decimal(item["value"], f"{where}.value"),
+    )
+
+
+def _parse_point(value: object, index: int) -> ReferencePoint:
+    where = f"points[{index}]"
+    item = _object(value, where)
+    algorithm = _object(item["algorithm"], f"{where}.algorithm")
+    momenta: list[tuple[Decimal, Decimal, Decimal, Decimal]] = []
+    for row_index, row_value in enumerate(_array(item["momenta"], f"{where}.momenta")):
+        row = _decimals(row_value, f"{where}.momenta[{row_index}]")
+        if len(row) != 4:
+            raise ReferenceFixtureError(
+                f"{where}.momenta[{row_index}] must contain four components"
+            )
+        momenta.append((row[0], row[1], row[2], row[3]))
+    return ReferencePoint(
+        id=_string(item["id"], f"{where}.id"),
+        process_id=_string(item["process_id"], f"{where}.process_id"),
+        point_class=_string(item["class"], f"{where}.class"),
+        algorithm=PointAlgorithm(
+            name=_string(algorithm["name"], f"{where}.algorithm.name"),
+            version=_string(algorithm["version"], f"{where}.algorithm.version"),
+            rng=_optional_string(algorithm["rng"], f"{where}.algorithm.rng"),
+            seed=_optional_integer(algorithm["seed"], f"{where}.algorithm.seed"),
+        ),
+        sqrt_s=_decimal(item["sqrt_s"], f"{where}.sqrt_s"),
+        momenta=tuple(momenta),
+        masses=_decimals(item["masses"], f"{where}.masses"),
+        arithmetic_precision_bits=_integer(
+            item["arithmetic_precision_bits"],
+            f"{where}.arithmetic_precision_bits",
+        ),
+        round_trip_decimal_digits=_integer(
+            item["round_trip_decimal_digits"],
+            f"{where}.round_trip_decimal_digits",
+        ),
+        certified_decimal_digits=_integer(
+            item["certified_decimal_digits"],
+            f"{where}.certified_decimal_digits",
+        ),
+        stress_metric=_parse_stress_metric(
+            item["stress_metric"], f"{where}.stress_metric"
+        ),
+    )
+
+
+def _parse_coverage(value: object, where: str) -> Coverage:
+    item = _object(value, where)
+    return Coverage(
+        helicities=_string(item["helicities"], f"{where}.helicities"),
+        color=_string(item["color"], f"{where}.color"),
+        color_kind=_string(item["color_kind"], f"{where}.color_kind"),
+        helicity_count=_integer(item["helicity_count"], f"{where}.helicity_count"),
+        color_component_count=_integer(
+            item["color_component_count"], f"{where}.color_component_count"
+        ),
+        structural_zero_helicity_count=_integer(
+            item["structural_zero_helicity_count"],
+            f"{where}.structural_zero_helicity_count",
+        ),
+    )
+
+
+def _parse_selectors(value: object, where: str) -> Selectors:
+    item = _object(value, where)
+    return Selectors(
+        helicity=_boolean(item["helicity"], f"{where}.helicity"),
+        color_flow=_boolean(item["color_flow"], f"{where}.color_flow"),
+        omitted_helicity=_string(item["omitted_helicity"], f"{where}.omitted_helicity"),
+        omitted_color=_string(item["omitted_color"], f"{where}.omitted_color"),
+    )
+
+
+def _parse_normalization(value: object, where: str) -> Normalization:
+    item = _object(value, where)
+    return Normalization(
+        average_factor=_decimal(item["average_factor"], f"{where}.average_factor"),
+        color_factor=_decimal(item["color_factor"], f"{where}.color_factor"),
+        identical_factor=_decimal(
+            item["identical_factor"], f"{where}.identical_factor"
+        ),
+        global_coupling_factor=_decimal(
+            item["global_coupling_factor"], f"{where}.global_coupling_factor"
+        ),
+        quark_line_partner_factor=_decimal(
+            item["quark_line_partner_factor"],
+            f"{where}.quark_line_partner_factor",
+        ),
+        couplings_in_stage_evaluators=_boolean(
+            item["couplings_in_stage_evaluators"],
+            f"{where}.couplings_in_stage_evaluators",
+        ),
+    )
+
+
+def _parse_topology(value: object, where: str) -> Topology:
+    item = _object(value, where)
+    return Topology(
+        currents=_integer(item["currents"], f"{where}.currents"),
+        interactions=_integer(item["interactions"], f"{where}.interactions"),
+        roots=_integer(item["roots"], f"{where}.roots"),
+        reduction_groups=_integer(
+            item["reduction_groups"], f"{where}.reduction_groups"
+        ),
+    )
+
+
+def _parse_helicity(value: object, where: str) -> HelicityAxis:
+    item = _object(value, where)
+    return HelicityAxis(
+        id=_string(item["id"], f"{where}.id"),
+        index=_integer(item["index"], f"{where}.index"),
+        values=_integers(item["values"], f"{where}.values"),
+        computed=_boolean(item["computed"], f"{where}.computed"),
+        structural_zero=_boolean(item["structural_zero"], f"{where}.structural_zero"),
+        representative_id=_string(
+            item["representative_id"], f"{where}.representative_id"
+        ),
+        coefficient=_decimal(item["coefficient"], f"{where}.coefficient"),
+    )
+
+
+def _parse_color(value: object, where: str) -> ColorAxis:
+    item = _object(value, where)
+    kind = _string(item["kind"], f"{where}.kind")
+    if kind == "lc-flow":
+        return LCColorFlow(
+            id=_string(item["id"], f"{where}.id"),
+            index=_integer(item["index"], f"{where}.index"),
+            word=_integers(item["word"], f"{where}.word"),
+            computed=_boolean(item["computed"], f"{where}.computed"),
+            representative_id=_string(
+                item["representative_id"], f"{where}.representative_id"
+            ),
+            coefficient=_decimal(item["coefficient"], f"{where}.coefficient"),
+        )
+    return ContractedColorComponent(
+        id=_string(item["id"], f"{where}.id"),
+        index=_integer(item["index"], f"{where}.index"),
+        description=_string(item["description"], f"{where}.description"),
+    )
+
+
+def _parse_reduction_group(value: object, where: str) -> ReductionGroup:
+    item = _object(value, where)
+    return ReductionGroup(
+        id=_string(item["id"], f"{where}.id"),
+        representative_helicity_id=_string(
+            item["representative_helicity_id"],
+            f"{where}.representative_helicity_id",
+        ),
+        representative_color_id=_string(
+            item["representative_color_id"],
+            f"{where}.representative_color_id",
+        ),
+        physical_helicity_ids=_strings(
+            item["physical_helicity_ids"],
+            f"{where}.physical_helicity_ids",
+        ),
+        physical_color_ids=_strings(
+            item["physical_color_ids"],
+            f"{where}.physical_color_ids",
+        ),
+    )
+
+
+def _parse_observation(value: object, where: str) -> Observation:
+    item = _object(value, where)
+    return Observation(
+        point_id=_string(item["point_id"], f"{where}.point_id"),
+        arithmetic_precision_bits=_integer(
+            item["arithmetic_precision_bits"],
+            f"{where}.arithmetic_precision_bits",
+        ),
+        round_trip_decimal_digits=_integer(
+            item["round_trip_decimal_digits"],
+            f"{where}.round_trip_decimal_digits",
+        ),
+        certified_decimal_digits=_integer(
+            item["certified_decimal_digits"],
+            f"{where}.certified_decimal_digits",
+        ),
+        values=_decimal_matrix(item["values"], f"{where}.values"),
+        total=_decimal(item["total"], f"{where}.total"),
+        evidence_refs=_strings(item["evidence_refs"], f"{where}.evidence_refs"),
+    )
+
+
+def _parse_case(value: object, index: int) -> ReferenceCase:
+    where = f"cases[{index}]"
+    item = _object(value, where)
+    axes = _object(item["axes"], f"{where}.axes")
+    reduction = _object(item["reduction"], f"{where}.reduction")
+    return ReferenceCase(
+        id=_string(item["id"], f"{where}.id"),
+        case_kind=_string(item["case_kind"], f"{where}.case_kind"),
+        model_id=_string(item["model_id"], f"{where}.model_id"),
+        process_id=_string(item["process_id"], f"{where}.process_id"),
+        color_accuracy=_string(item["color_accuracy"], f"{where}.color_accuracy"),
+        point_policy=_string(item["point_policy"], f"{where}.point_policy"),
+        point_ids=_strings(item["point_ids"], f"{where}.point_ids"),
+        coverage=_parse_coverage(item["coverage"], f"{where}.coverage"),
+        selectors=_parse_selectors(item["selectors"], f"{where}.selectors"),
+        normalization=_parse_normalization(
+            item["normalization"], f"{where}.normalization"
+        ),
+        topology=_parse_topology(item["topology"], f"{where}.topology"),
+        artifact_physics_sha256=_string(
+            item["artifact_physics_sha256"], f"{where}.artifact_physics_sha256"
+        ),
+        artifact_execution_sha256=_string(
+            item["artifact_execution_sha256"],
+            f"{where}.artifact_execution_sha256",
+        ),
+        physics_case_sha256=_string(
+            item["physics_case_sha256"], f"{where}.physics_case_sha256"
+        ),
+        helicities=tuple(
+            _parse_helicity(entry, f"{where}.axes.helicities[{axis_index}]")
+            for axis_index, entry in enumerate(
+                _array(axes["helicities"], f"{where}.axes.helicities")
+            )
+        ),
+        colors=tuple(
+            _parse_color(entry, f"{where}.axes.colors[{axis_index}]")
+            for axis_index, entry in enumerate(
+                _array(axes["colors"], f"{where}.axes.colors")
+            )
+        ),
+        reduction=Reduction(
+            kind=_string(reduction["kind"], f"{where}.reduction.kind"),
+            cell_semantics=_string(
+                reduction["cell_semantics"], f"{where}.reduction.cell_semantics"
+            ),
+            groups=tuple(
+                _parse_reduction_group(
+                    entry,
+                    f"{where}.reduction.groups[{group_index}]",
+                )
+                for group_index, entry in enumerate(
+                    _array(reduction["groups"], f"{where}.reduction.groups")
+                )
+            ),
+            plan_sha256=_string(
+                reduction["plan_sha256"],
+                f"{where}.reduction.plan_sha256",
+            ),
+        ),
+        observations=tuple(
+            _parse_observation(entry, f"{where}.observations[{observation_index}]")
+            for observation_index, entry in enumerate(
+                _array(item["observations"], f"{where}.observations")
+            )
+        ),
+    )
+
+
+def _parse_oracle(value: object, where: str) -> OracleProvenance:
+    item = _object(value, where)
+    tolerance_ceiling = _object(item["tolerance_ceiling"], f"{where}.tolerance_ceiling")
+    return OracleProvenance(
+        id=_string(item["id"], f"{where}.id"),
+        name=_string(item["name"], f"{where}.name"),
+        implementation=_string(item["implementation"], f"{where}.implementation"),
+        revision=_string(item["revision"], f"{where}.revision"),
+        content_sha256=_string(item["content_sha256"], f"{where}.content_sha256"),
+        independence_statement=_string(
+            item["independence_statement"], f"{where}.independence_statement"
+        ),
+        validation_profile=_string(
+            item["validation_profile"], f"{where}.validation_profile"
+        ),
+        tolerance_ceiling=Tolerances(
+            relative=_decimal(
+                tolerance_ceiling["relative"],
+                f"{where}.tolerance_ceiling.relative",
+            ),
+            absolute=_decimal(
+                tolerance_ceiling["absolute"],
+                f"{where}.tolerance_ceiling.absolute",
+            ),
+        ),
+    )
+
+
+def _parse_evidence_record(
+    value: object,
+    *,
+    index: int,
+    evidence_set_id: str,
+    oracle_id: str,
+) -> OracleEvidence:
+    where = f"evidence {evidence_set_id}.records[{index}]"
+    item = _object(value, where)
+    identity = _object(item["process_identity"], f"{where}.process_identity")
+    tolerances = _object(item["tolerances"], f"{where}.tolerances")
+    helicity_totals = item["observed_helicity_totals"]
+    observed_values = item["observed_values"]
+    return OracleEvidence(
+        id=_string(item["id"], f"{where}.id"),
+        evidence_set_id=evidence_set_id,
+        oracle_id=oracle_id,
+        case_id=_string(item["case_id"], f"{where}.case_id"),
+        point_id=_string(item["point_id"], f"{where}.point_id"),
+        arithmetic_precision_bits=_integer(
+            item["arithmetic_precision_bits"],
+            f"{where}.arithmetic_precision_bits",
+        ),
+        round_trip_decimal_digits=_integer(
+            item["round_trip_decimal_digits"],
+            f"{where}.round_trip_decimal_digits",
+        ),
+        certified_decimal_digits=_integer(
+            item["certified_decimal_digits"],
+            f"{where}.certified_decimal_digits",
+        ),
+        arithmetic=_string(item["arithmetic"], f"{where}.arithmetic"),
+        coverage=_string(item["coverage"], f"{where}.coverage"),
+        helicity_ids=_strings(item["helicity_ids"], f"{where}.helicity_ids"),
+        color_ids=_strings(item["color_ids"], f"{where}.color_ids"),
+        observed_total=_decimal(item["observed_total"], f"{where}.observed_total"),
+        observed_helicity_totals=(
+            None
+            if helicity_totals is None
+            else _decimals(helicity_totals, f"{where}.observed_helicity_totals")
+        ),
+        observed_values=(
+            None
+            if observed_values is None
+            else _decimal_matrix(observed_values, f"{where}.observed_values")
+        ),
+        process_identity=ProcessIdentity(
+            expression=_string(
+                identity["expression"], f"{where}.process_identity.expression"
+            ),
+            ordered_external_pdgs=_integers(
+                identity["ordered_external_pdgs"],
+                f"{where}.process_identity.ordered_external_pdgs",
+            ),
+            ordered_external_leg_ids=_strings(
+                identity["ordered_external_leg_ids"],
+                f"{where}.process_identity.ordered_external_leg_ids",
+            ),
+            source_to_row_permutation=_integers(
+                identity["source_to_row_permutation"],
+                f"{where}.process_identity.source_to_row_permutation",
+            ),
+            row_id=_optional_string(
+                identity["row_id"], f"{where}.process_identity.row_id"
+            ),
+            color_order_count=_integer(
+                identity["color_order_count"],
+                f"{where}.process_identity.color_order_count",
+            ),
+            ordered_color_legs=_strings(
+                identity["ordered_color_legs"],
+                f"{where}.process_identity.ordered_color_legs",
+            ),
+        ),
+        input_sha256=_string(item["input_sha256"], f"{where}.input_sha256"),
+        physics_case_sha256=_string(
+            item["physics_case_sha256"], f"{where}.physics_case_sha256"
+        ),
+        oracle_output_sha256=_string(
+            item["oracle_output_sha256"], f"{where}.oracle_output_sha256"
+        ),
+        evidence_record_sha256=_string(
+            item["evidence_record_sha256"], f"{where}.evidence_record_sha256"
+        ),
+        command=_strings(item["command"], f"{where}.command"),
+        tolerances=Tolerances(
+            relative=_decimal(tolerances["relative"], f"{where}.tolerances.relative"),
+            absolute=_decimal(tolerances["absolute"], f"{where}.tolerances.absolute"),
+        ),
+    )
+
+
+def _parse_evidence_set(value: object, index: int) -> OracleEvidenceSet:
+    where = f"evidence_sets[{index}]"
+    item = _object(value, where)
+    evidence_set_id = _string(item["evidence_set_id"], f"{where}.evidence_set_id")
+    oracle = _parse_oracle(item["oracle"], f"{where}.oracle")
+    return OracleEvidenceSet(
+        id=evidence_set_id,
+        captured_at=_string(item["captured_at"], f"{where}.captured_at"),
+        oracle=oracle,
+        dependency_ids=_strings(item["dependency_ids"], f"{where}.dependency_ids"),
+        records=tuple(
+            _parse_evidence_record(
+                entry,
+                index=record_index,
+                evidence_set_id=evidence_set_id,
+                oracle_id=oracle.id,
+            )
+            for record_index, entry in enumerate(
+                _array(item["records"], f"{where}.records")
+            )
+        ),
+    )
diff --git a/pyamplicol/tools/developer/reference_fixture/evidence.py b/pyamplicol/tools/developer/reference_fixture/evidence.py
new file mode 100644
index 0000000000..2a204687d1
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_fixture/evidence.py
@@ -0,0 +1,296 @@
+# SPDX-License-Identifier: 0BSD
+"""Independent-oracle evidence validation for reference fixtures."""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from fractions import Fraction
+
+from .model import (
+    Observation,
+    OracleEvidence,
+    OracleProvenance,
+    Process,
+    ReferenceCase,
+    ReferenceFixtureError,
+    ReferencePoint,
+    Tolerances,
+    _EvidenceCoverage,
+)
+from .numerics import (
+    _exact_sum,
+    _required_stress_certified_digits,
+    _validate_precision_metadata,
+    _within_tolerance,
+)
+
+
+def _oracle_profile_limit(profile: str) -> Tolerances:
+    if profile == "exact":
+        return Tolerances(relative=Decimal(0), absolute=Decimal(0))
+    if profile == "binary64":
+        return Tolerances(
+            relative=Decimal("0.0000000001"),
+            absolute=Decimal("0.000000000001"),
+        )
+    return Tolerances(
+        relative=Decimal("0.000000000001"),
+        absolute=Decimal("0.000000000000001"),
+    )
+
+
+def _validate_oracle_provenance(oracle: OracleProvenance) -> None:
+    ceiling = oracle.tolerance_ceiling
+    if ceiling.relative < 0 or ceiling.absolute < 0:
+        raise ReferenceFixtureError(
+            f"oracle {oracle.id} tolerance ceiling must be nonnegative"
+        )
+    hard_limit = _oracle_profile_limit(oracle.validation_profile)
+    if ceiling.relative > hard_limit.relative or ceiling.absolute > hard_limit.absolute:
+        raise ReferenceFixtureError(
+            f"oracle {oracle.id} tolerance ceiling exceeds its profile limit"
+        )
+
+
+def _validate_evidence(
+    evidence: OracleEvidence,
+    *,
+    oracle: OracleProvenance,
+    case: ReferenceCase,
+    process: Process,
+    point: ReferencePoint,
+    observation: Observation,
+) -> _EvidenceCoverage:
+    if evidence.case_id != case.id or evidence.point_id != point.id:
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} does not identify observation {case.id}/{point.id}"
+        )
+    if evidence.input_sha256 != point.input_sha256():
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} input hash does not match point {point.id}"
+        )
+    if evidence.physics_case_sha256 != case.physics_case_sha256:
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} physics case hash does not match case {case.id}"
+        )
+    _validate_precision_metadata(
+        arithmetic_precision_bits=evidence.arithmetic_precision_bits,
+        round_trip_decimal_digits=evidence.round_trip_decimal_digits,
+        certified_decimal_digits=evidence.certified_decimal_digits,
+        where=f"evidence {evidence.id}",
+    )
+    if evidence.certified_decimal_digits > point.certified_decimal_digits:
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} overclaims the certified point precision"
+        )
+    if evidence.certified_decimal_digits < observation.certified_decimal_digits:
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} certification is below the observation claim"
+        )
+    if point.point_class == "stress" and evidence.certified_decimal_digits < (
+        _required_stress_certified_digits(point)
+    ):
+        raise ReferenceFixtureError(
+            f"stress evidence {evidence.id} certification is not commensurate "
+            "with the stress metric"
+        )
+    allowed_arithmetic = {
+        "exact": {"analytic", "rational"},
+        "binary64": {"binary64"},
+        "high-precision": {"analytic", "decimal", "rational"},
+    }[oracle.validation_profile]
+    if evidence.arithmetic not in allowed_arithmetic:
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} arithmetic is incompatible with oracle "
+            f"profile {oracle.validation_profile}"
+        )
+    if (
+        oracle.validation_profile == "high-precision"
+        and evidence.arithmetic_precision_bits < 128
+    ):
+        raise ReferenceFixtureError(
+            f"high-precision evidence {evidence.id} requires at least 128 "
+            "arithmetic bits"
+        )
+    identity = evidence.process_identity
+    if identity.expression != process.expression:
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} has the wrong process expression"
+        )
+    permutation = identity.source_to_row_permutation
+    if sorted(permutation) != list(range(len(process.external_pdgs))):
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} has an invalid source-to-row permutation"
+        )
+    expected_pdgs = tuple(process.external_pdgs[position] for position in permutation)
+    if identity.ordered_external_pdgs != expected_pdgs:
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} ordered PDGs do not match its permutation"
+        )
+    expected_legs = tuple(
+        process.external_leg_ids[position] for position in permutation
+    )
+    if identity.ordered_external_leg_ids != expected_legs:
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} ordered leg identities do not match its "
+            "permutation"
+        )
+    if not set(identity.ordered_color_legs) <= set(process.external_leg_ids):
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} color order references unknown external legs"
+        )
+    helicity_indices = {axis.id: index for index, axis in enumerate(case.helicities)}
+    color_indices = {axis.id: index for index, axis in enumerate(case.colors)}
+    if not set(evidence.helicity_ids) <= helicity_indices.keys():
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} references invalid helicity axes"
+        )
+    if not set(evidence.color_ids) <= color_indices.keys():
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} references invalid color axes"
+        )
+    if (
+        case.color_accuracy == "lc"
+        and case.coverage.color == "complete"
+        and (identity.color_order_count != len(case.colors))
+    ):
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} color-order count does not match the "
+            "complete LC axis"
+        )
+    if evidence.tolerances.relative < 0 or evidence.tolerances.absolute < 0:
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} tolerances must be nonnegative"
+        )
+    if (
+        evidence.tolerances.relative > oracle.tolerance_ceiling.relative
+        or evidence.tolerances.absolute > oracle.tolerance_ceiling.absolute
+    ):
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} exceeds its oracle-specific tolerance ceiling"
+        )
+    digit_ceiling = Decimal(1).scaleb(-evidence.certified_decimal_digits)
+    if (
+        evidence.tolerances.relative > digit_ceiling
+        or evidence.tolerances.absolute > digit_ceiling
+    ):
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} tolerances are not commensurate with its "
+            "certified digits"
+        )
+    if evidence.arithmetic == "binary64" and (
+        evidence.arithmetic_precision_bits != 53
+        or evidence.round_trip_decimal_digits != 17
+        or evidence.certified_decimal_digits > 15
+    ):
+        raise ReferenceFixtureError(
+            f"binary64 evidence {evidence.id} must declare 53 arithmetic bits, "
+            "17 round-trip digits, and at most 15 certified digits"
+        )
+
+    if evidence.coverage == "total":
+        if evidence.helicity_ids or evidence.color_ids:
+            raise ReferenceFixtureError(
+                f"total evidence {evidence.id} must not declare resolved axes"
+            )
+        expected_total: Decimal | Fraction = observation.total
+        if not _within_tolerance(
+            expected_total,
+            evidence.observed_total,
+            evidence.tolerances,
+        ):
+            raise ReferenceFixtureError(
+                f"evidence {evidence.id} total is outside its declared tolerance"
+            )
+        return _EvidenceCoverage(total=True)
+
+    if evidence.coverage == "helicity-aggregate":
+        totals = evidence.observed_helicity_totals
+        if (
+            totals is None
+            or len(totals) != len(evidence.helicity_ids)
+            or not evidence.helicity_ids
+            or not evidence.color_ids
+        ):
+            raise ReferenceFixtureError(
+                f"evidence {evidence.id} has the wrong helicity-aggregate shape"
+            )
+        if set(evidence.color_ids) != set(color_indices):
+            raise ReferenceFixtureError(
+                f"helicity-aggregate evidence {evidence.id} must cover the "
+                "complete color axis"
+            )
+        expected_totals = tuple(
+            _exact_sum(
+                observation.values[helicity_indices[helicity_id]][
+                    color_indices[color_id]
+                ]
+                for color_id in evidence.color_ids
+            )
+            for helicity_id in evidence.helicity_ids
+        )
+        for helicity_id, observed in zip(evidence.helicity_ids, totals, strict=True):
+            if (
+                case.helicities[helicity_indices[helicity_id]].structural_zero
+                and observed != 0
+            ):
+                raise ReferenceFixtureError(
+                    f"evidence {evidence.id} does not preserve an exact structural zero"
+                )
+        if any(
+            not _within_tolerance(expected, observed, evidence.tolerances)
+            for expected, observed in zip(expected_totals, totals, strict=True)
+        ):
+            raise ReferenceFixtureError(
+                f"evidence {evidence.id} helicity aggregates are outside tolerance"
+            )
+        expected_total = sum(expected_totals, Fraction())
+        if not _within_tolerance(
+            expected_total,
+            evidence.observed_total,
+            evidence.tolerances,
+        ):
+            raise ReferenceFixtureError(
+                f"evidence {evidence.id} aggregate total is outside tolerance"
+            )
+        return _EvidenceCoverage(helicity_aggregates=frozenset(evidence.helicity_ids))
+
+    values = evidence.observed_values
+    if (
+        values is None
+        or not evidence.helicity_ids
+        or not evidence.color_ids
+        or len(values) != len(evidence.helicity_ids)
+        or any(len(row) != len(evidence.color_ids) for row in values)
+    ):
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} has the wrong resolved shape"
+        )
+    covered: set[tuple[str, str]] = set()
+    for helicity_id, observed_row in zip(evidence.helicity_ids, values, strict=True):
+        row_index = helicity_indices[helicity_id]
+        for color_id, observed in zip(evidence.color_ids, observed_row, strict=True):
+            expected = observation.values[row_index][color_indices[color_id]]
+            if case.helicities[row_index].structural_zero and observed != 0:
+                raise ReferenceFixtureError(
+                    f"evidence {evidence.id} does not preserve an exact structural zero"
+                )
+            if not _within_tolerance(expected, observed, evidence.tolerances):
+                raise ReferenceFixtureError(
+                    f"evidence {evidence.id} resolved values are outside tolerance"
+                )
+            covered.add((helicity_id, color_id))
+    expected_total = _exact_sum(
+        observation.values[helicity_indices[helicity_id]][color_indices[color_id]]
+        for helicity_id in evidence.helicity_ids
+        for color_id in evidence.color_ids
+    )
+    if not _within_tolerance(
+        expected_total,
+        evidence.observed_total,
+        evidence.tolerances,
+    ):
+        raise ReferenceFixtureError(
+            f"evidence {evidence.id} resolved total is outside tolerance"
+        )
+    return _EvidenceCoverage(resolved_cells=frozenset(covered))
diff --git a/pyamplicol/tools/developer/reference_fixture/model.py b/pyamplicol/tools/developer/reference_fixture/model.py
new file mode 100644
index 0000000000..d80bfe3019
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_fixture/model.py
@@ -0,0 +1,347 @@
+# SPDX-License-Identifier: 0BSD
+"""Immutable typed records for reference-physics fixtures."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import TypeAlias
+
+
+def _decimal_text(value: Decimal) -> str:
+    return format(value, "f")
+
+
+class ReferenceFixtureError(ValueError):
+    """A reference fixture violates its wire or semantic contract."""
+
+
+@dataclass(frozen=True, slots=True)
+class ComplexDecimal:
+    real: Decimal
+    imag: Decimal
+
+
+@dataclass(frozen=True, slots=True)
+class FixtureProvenance:
+    source_repository: str
+    source_revision: str
+    source_tree_sha256: str
+    captured_at: str
+    capture_command: tuple[str, ...]
+    working_tree_clean: bool
+    memory_watchdog_gb: int
+
+
+@dataclass(frozen=True, slots=True)
+class DependencyProvenance:
+    id: str
+    name: str
+    version: str
+    revision: str | None
+    content_sha256: str
+    serialization_abi: str | None
+    license: str
+
+
+@dataclass(frozen=True, slots=True)
+class ModelProvenance:
+    id: str
+    name: str
+    source_kind: str
+    content_sha256: str
+    compiled_model_sha256: str
+    compiled_schema_version: int
+    restriction: str | None
+    dependency_ids: tuple[str, ...]
+    parameter_defaults: tuple[tuple[str, ComplexDecimal], ...]
+
+
+@dataclass(frozen=True, slots=True)
+class Process:
+    id: str
+    expression: str
+    external_pdgs: tuple[int, ...]
+    external_labels: tuple[int, ...]
+    external_leg_ids: tuple[str, ...]
+    external_spins: tuple[int, ...]
+    external_colors: tuple[int, ...]
+    external_masses: tuple[Decimal, ...]
+    external_helicity_domains: tuple[tuple[int, ...], ...]
+    initial_state_count: int
+    alias_of: str | None
+    final_state_permutation: tuple[int, ...] | None
+
+
+@dataclass(frozen=True, slots=True)
+class PointAlgorithm:
+    name: str
+    version: str
+    rng: str | None
+    seed: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class StressMetric:
+    kind: str
+    value: Decimal
+
+
+@dataclass(frozen=True, slots=True)
+class ReferencePoint:
+    id: str
+    process_id: str
+    point_class: str
+    algorithm: PointAlgorithm
+    sqrt_s: Decimal
+    momenta: tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]
+    masses: tuple[Decimal, ...]
+    arithmetic_precision_bits: int
+    round_trip_decimal_digits: int
+    certified_decimal_digits: int
+    stress_metric: StressMetric | None
+
+    def runtime_momenta(
+        self,
+    ) -> tuple[tuple[Decimal, Decimal, Decimal, Decimal], ...]:
+        """Return momenta without reducing their recorded decimal precision."""
+
+        return self.momenta
+
+    def f64_momenta(self) -> tuple[tuple[float, float, float, float], ...]:
+        """Return the explicit binary64 projection used by f64-only tests."""
+
+        return tuple(
+            (float(row[0]), float(row[1]), float(row[2]), float(row[3]))
+            for row in self.momenta
+        )
+
+    def input_sha256(self) -> str:
+        """Hash the ordered process and exact kinematic input contract."""
+
+        payload = {
+            "arithmetic_precision_bits": self.arithmetic_precision_bits,
+            "certified_decimal_digits": self.certified_decimal_digits,
+            "masses": [_decimal_text(mass) for mass in self.masses],
+            "momenta": [
+                [_decimal_text(component) for component in row] for row in self.momenta
+            ],
+            "process_id": self.process_id,
+            "round_trip_decimal_digits": self.round_trip_decimal_digits,
+            "sqrt_s": _decimal_text(self.sqrt_s),
+        }
+        encoded = json.dumps(
+            payload,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+        return hashlib.sha256(encoded).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class Coverage:
+    helicities: str
+    color: str
+    color_kind: str
+    helicity_count: int
+    color_component_count: int
+    structural_zero_helicity_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class Selectors:
+    helicity: bool
+    color_flow: bool
+    omitted_helicity: str
+    omitted_color: str
+
+
+@dataclass(frozen=True, slots=True)
+class Normalization:
+    average_factor: Decimal
+    color_factor: Decimal
+    identical_factor: Decimal
+    global_coupling_factor: Decimal
+    quark_line_partner_factor: Decimal
+    couplings_in_stage_evaluators: bool
+
+
+@dataclass(frozen=True, slots=True)
+class Topology:
+    currents: int
+    interactions: int
+    roots: int
+    reduction_groups: int
+
+
+@dataclass(frozen=True, slots=True)
+class HelicityAxis:
+    id: str
+    index: int
+    values: tuple[int, ...]
+    computed: bool
+    structural_zero: bool
+    representative_id: str
+    coefficient: Decimal
+
+
+@dataclass(frozen=True, slots=True)
+class LCColorFlow:
+    id: str
+    index: int
+    word: tuple[int, ...]
+    computed: bool
+    representative_id: str
+    coefficient: Decimal
+
+
+@dataclass(frozen=True, slots=True)
+class ContractedColorComponent:
+    id: str
+    index: int
+    description: str
+
+
+ColorAxis: TypeAlias = LCColorFlow | ContractedColorComponent
+
+
+@dataclass(frozen=True, slots=True)
+class ReductionGroup:
+    id: str
+    representative_helicity_id: str
+    representative_color_id: str
+    physical_helicity_ids: tuple[str, ...]
+    physical_color_ids: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class Reduction:
+    kind: str
+    cell_semantics: str
+    groups: tuple[ReductionGroup, ...]
+    plan_sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class Observation:
+    point_id: str
+    arithmetic_precision_bits: int
+    round_trip_decimal_digits: int
+    certified_decimal_digits: int
+    values: tuple[tuple[Decimal, ...], ...]
+    total: Decimal
+    evidence_refs: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ReferenceCase:
+    id: str
+    case_kind: str
+    model_id: str
+    process_id: str
+    color_accuracy: str
+    point_policy: str
+    point_ids: tuple[str, ...]
+    coverage: Coverage
+    selectors: Selectors
+    normalization: Normalization
+    topology: Topology
+    artifact_physics_sha256: str
+    artifact_execution_sha256: str
+    physics_case_sha256: str
+    helicities: tuple[HelicityAxis, ...]
+    colors: tuple[ColorAxis, ...]
+    reduction: Reduction
+    observations: tuple[Observation, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class OracleProvenance:
+    id: str
+    name: str
+    implementation: str
+    revision: str
+    content_sha256: str
+    independence_statement: str
+    validation_profile: str
+    tolerance_ceiling: Tolerances
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessIdentity:
+    expression: str
+    ordered_external_pdgs: tuple[int, ...]
+    ordered_external_leg_ids: tuple[str, ...]
+    source_to_row_permutation: tuple[int, ...]
+    row_id: str | None
+    color_order_count: int
+    ordered_color_legs: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class Tolerances:
+    relative: Decimal
+    absolute: Decimal
+
+
+@dataclass(frozen=True, slots=True)
+class _EvidenceCoverage:
+    resolved_cells: frozenset[tuple[str, str]] = frozenset()
+    helicity_aggregates: frozenset[str] = frozenset()
+    total: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class OracleEvidence:
+    id: str
+    evidence_set_id: str
+    oracle_id: str
+    case_id: str
+    point_id: str
+    arithmetic_precision_bits: int
+    round_trip_decimal_digits: int
+    certified_decimal_digits: int
+    arithmetic: str
+    coverage: str
+    helicity_ids: tuple[str, ...]
+    color_ids: tuple[str, ...]
+    observed_total: Decimal
+    observed_helicity_totals: tuple[Decimal, ...] | None
+    observed_values: tuple[tuple[Decimal, ...], ...] | None
+    process_identity: ProcessIdentity
+    input_sha256: str
+    physics_case_sha256: str
+    oracle_output_sha256: str
+    evidence_record_sha256: str
+    command: tuple[str, ...]
+    tolerances: Tolerances
+
+
+@dataclass(frozen=True, slots=True)
+class OracleEvidenceSet:
+    id: str
+    captured_at: str
+    oracle: OracleProvenance
+    dependency_ids: tuple[str, ...]
+    records: tuple[OracleEvidence, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ReferenceFixture:
+    id: str
+    provenance: FixtureProvenance
+    dependencies: tuple[DependencyProvenance, ...]
+    models: tuple[ModelProvenance, ...]
+    processes: tuple[Process, ...]
+    points: tuple[ReferencePoint, ...]
+    cases: tuple[ReferenceCase, ...]
+    evidence_sets: tuple[OracleEvidenceSet, ...]
+
+    def point(self, point_id: str) -> ReferencePoint:
+        for point in self.points:
+            if point.id == point_id:
+                return point
+        raise KeyError(point_id)
diff --git a/pyamplicol/tools/developer/reference_fixture/numerics.py b/pyamplicol/tools/developer/reference_fixture/numerics.py
new file mode 100644
index 0000000000..dbd69a120f
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_fixture/numerics.py
@@ -0,0 +1,227 @@
+# SPDX-License-Identifier: 0BSD
+"""Exact arithmetic and kinematic validation for reference fixtures."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from decimal import Decimal
+from fractions import Fraction
+
+from .model import Process, ReferenceFixtureError, ReferencePoint, Tolerances
+
+_LOG10_2_NUMERATOR = 301_029_995_663_981_195
+_LOG10_2_DENOMINATOR = 1_000_000_000_000_000_000
+_MAX_STRESS_METRIC = Decimal("0.000001")
+_BASELINE_CERTIFIED_DIGITS = 12
+
+
+def _as_fraction(value: Decimal | Fraction) -> Fraction:
+    return value if isinstance(value, Fraction) else Fraction(value)
+
+
+def _exact_sum(values: Iterable[Decimal]) -> Fraction:
+    return sum((_as_fraction(value) for value in values), Fraction())
+
+
+def _validate_precision_metadata(
+    *,
+    arithmetic_precision_bits: int,
+    round_trip_decimal_digits: int,
+    certified_decimal_digits: int,
+    where: str,
+) -> None:
+    if certified_decimal_digits > round_trip_decimal_digits:
+        raise ReferenceFixtureError(
+            f"{where} certified digits exceed its round-trip digits"
+        )
+    supported_certified_digits = (
+        arithmetic_precision_bits * _LOG10_2_NUMERATOR
+    ) // _LOG10_2_DENOMINATOR
+    if certified_decimal_digits > supported_certified_digits:
+        raise ReferenceFixtureError(
+            f"{where} certified digits exceed its arithmetic-bit capacity"
+        )
+    maximum_round_trip_digits = (
+        arithmetic_precision_bits * _LOG10_2_NUMERATOR + _LOG10_2_DENOMINATOR - 1
+    ) // _LOG10_2_DENOMINATOR + 1
+    if round_trip_decimal_digits > maximum_round_trip_digits:
+        raise ReferenceFixtureError(
+            f"{where} round-trip digits exceed its arithmetic-bit capacity"
+        )
+
+
+def _minkowski_square(momentum: Sequence[Decimal | Fraction]) -> Fraction:
+    values = tuple(_as_fraction(component) for component in momentum)
+    return values[0] * values[0] - sum(
+        (component * component for component in values[1:]), Fraction()
+    )
+
+
+def _stress_metric_value(
+    point: ReferencePoint,
+    process: Process,
+) -> Fraction:
+    final_momenta = point.momenta[process.initial_state_count :]
+    if point.stress_metric is None:
+        raise ReferenceFixtureError(f"stress point {point.id} lacks a stress metric")
+    sqrt_s = _as_fraction(point.sqrt_s)
+    if point.stress_metric.kind == "minimum-final-energy-fraction":
+        return min(_as_fraction(momentum[0]) / sqrt_s for momentum in final_momenta)
+    if point.stress_metric.kind == "relative-excess-energy":
+        threshold = sum(
+            (
+                _as_fraction(mass)
+                for mass in point.masses[process.initial_state_count :]
+            ),
+            Fraction(),
+        )
+        if threshold <= 0:
+            raise ReferenceFixtureError(
+                f"threshold stress point {point.id} has no massive final state"
+            )
+        return (sqrt_s - threshold) / threshold
+    sqrt_s_squared = sqrt_s * sqrt_s
+    return min(
+        (_as_fraction(momentum[1]) ** 2 + _as_fraction(momentum[2]) ** 2)
+        / sqrt_s_squared
+        for momentum in final_momenta
+    )
+
+
+def _required_stress_certified_digits(point: ReferencePoint) -> int:
+    metric = point.stress_metric
+    if metric is None:
+        return 0
+    severity_digits = max(0, -metric.value.adjusted())
+    return max(6, severity_digits + 2)
+
+
+def _validate_point_kinematics(point: ReferencePoint, process: Process) -> None:
+    width = len(process.external_pdgs)
+    if len(point.momenta) != width or len(point.masses) != width:
+        raise ReferenceFixtureError(
+            f"point {point.id} momentum and mass metadata must match process "
+            f"{process.id}"
+        )
+    if point.masses != process.external_masses:
+        raise ReferenceFixtureError(
+            f"point {point.id} masses differ from process {process.id} "
+            "model-derived masses"
+        )
+    _validate_precision_metadata(
+        arithmetic_precision_bits=point.arithmetic_precision_bits,
+        round_trip_decimal_digits=point.round_trip_decimal_digits,
+        certified_decimal_digits=point.certified_decimal_digits,
+        where=f"point {point.id}",
+    )
+    if point.certified_decimal_digits < _BASELINE_CERTIFIED_DIGITS:
+        raise ReferenceFixtureError(
+            f"point {point.id} must certify at least "
+            f"{_BASELINE_CERTIFIED_DIGITS} decimal digits"
+        )
+    if point.sqrt_s <= 0:
+        raise ReferenceFixtureError(f"point {point.id} sqrt_s must be positive")
+    if any(mass < 0 for mass in point.masses):
+        raise ReferenceFixtureError(f"point {point.id} masses must be nonnegative")
+    if any(momentum[0] <= 0 for momentum in point.momenta):
+        raise ReferenceFixtureError(
+            f"point {point.id} external energies must be positive"
+        )
+
+    scale = max(
+        Fraction(1),
+        _as_fraction(point.sqrt_s),
+        *(abs(_as_fraction(component)) for row in point.momenta for component in row),
+    )
+    relative_tolerance = Fraction(1, 10**point.certified_decimal_digits)
+    momentum_tolerance = scale * relative_tolerance
+    shell_tolerance = scale * scale * relative_tolerance
+    incoming = tuple(
+        sum(
+            (
+                _as_fraction(momentum[component])
+                for momentum in point.momenta[: process.initial_state_count]
+            ),
+            Fraction(),
+        )
+        for component in range(4)
+    )
+    outgoing = tuple(
+        sum(
+            (
+                _as_fraction(momentum[component])
+                for momentum in point.momenta[process.initial_state_count :]
+            ),
+            Fraction(),
+        )
+        for component in range(4)
+    )
+    if any(
+        abs(incoming_component - outgoing_component) > momentum_tolerance
+        for incoming_component, outgoing_component in zip(
+            incoming, outgoing, strict=True
+        )
+    ):
+        raise ReferenceFixtureError(
+            f"point {point.id} violates four-momentum conservation"
+        )
+    if abs(_minkowski_square(incoming) - _as_fraction(point.sqrt_s) ** 2) > (
+        shell_tolerance
+    ):
+        raise ReferenceFixtureError(
+            f"point {point.id} incoming invariant does not match sqrt_s"
+        )
+    for index, (momentum, mass) in enumerate(
+        zip(point.momenta, point.masses, strict=True)
+    ):
+        residual = _minkowski_square(momentum) - _as_fraction(mass) ** 2
+        if abs(residual) > shell_tolerance:
+            raise ReferenceFixtureError(
+                f"point {point.id} leg {index} is off shell for its declared mass"
+            )
+
+    if point.point_class == "stress":
+        metric = point.stress_metric
+        if metric is None:
+            raise ReferenceFixtureError(
+                f"stress point {point.id} lacks a quantified stress metric"
+            )
+        expected_metric = _stress_metric_value(point, process)
+        metric_value = _as_fraction(metric.value)
+        metric_tolerance = max(
+            Fraction(1, 10**point.certified_decimal_digits),
+            abs(expected_metric) / 10**point.certified_decimal_digits,
+        )
+        if abs(expected_metric - metric_value) > metric_tolerance:
+            raise ReferenceFixtureError(
+                f"stress point {point.id} metric does not match its momenta"
+            )
+        if metric.value > _MAX_STRESS_METRIC:
+            raise ReferenceFixtureError(
+                f"stress point {point.id} metric is not sufficiently singular"
+            )
+        required_digits = _required_stress_certified_digits(point)
+        if point.certified_decimal_digits < required_digits:
+            raise ReferenceFixtureError(
+                f"stress point {point.id} certification is not commensurate with "
+                "its stress metric"
+            )
+    elif point.stress_metric is not None:
+        raise ReferenceFixtureError(
+            f"non-stress point {point.id} must not declare a stress metric"
+        )
+
+
+def _within_tolerance(
+    expected: Decimal | Fraction,
+    observed: Decimal | Fraction,
+    tolerances: Tolerances,
+) -> bool:
+    exact_expected = _as_fraction(expected)
+    exact_observed = _as_fraction(observed)
+    scale = max(abs(exact_expected), abs(exact_observed))
+    allowed = max(
+        _as_fraction(tolerances.absolute),
+        _as_fraction(tolerances.relative) * scale,
+    )
+    return abs(exact_expected - exact_observed) <= allowed
diff --git a/pyamplicol/tools/developer/reference_fixture/structure.py b/pyamplicol/tools/developer/reference_fixture/structure.py
new file mode 100644
index 0000000000..dd567ec089
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_fixture/structure.py
@@ -0,0 +1,562 @@
+# SPDX-License-Identifier: 0BSD
+"""Structural invariants for parsed reference fixtures."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from decimal import Decimal
+from itertools import product
+from typing import TypeVar
+
+from .model import (
+    ContractedColorComponent,
+    HelicityAxis,
+    LCColorFlow,
+    Observation,
+    Process,
+    ReferenceCase,
+    ReferenceFixtureError,
+)
+from .numerics import _as_fraction
+
+_Item = TypeVar("_Item")
+
+
+def _unique(
+    items: Iterable[_Item],
+    kind: str,
+    *,
+    key: str = "id",
+) -> dict[str, _Item]:
+    result: dict[str, _Item] = {}
+    for item in items:
+        item_id = getattr(item, key)
+        if item_id in result:
+            raise ReferenceFixtureError(f"duplicate {kind} id: {item_id}")
+        result[item_id] = item
+    return result
+
+
+def _validate_digest(value: str, where: str) -> None:
+    if value == "0" * 64:
+        raise ReferenceFixtureError(f"{where} must not use an all-zero digest")
+
+
+def _physical_helicity_domain(spin: int, mass: Decimal) -> tuple[int, ...]:
+    if spin < 1:
+        raise ReferenceFixtureError("external UFO spin codes must be positive")
+    if mass < 0:
+        raise ReferenceFixtureError("external particle masses must be non-negative")
+    if spin == 1:
+        return (0,)
+    if spin % 2 == 0:
+        return tuple(range(-(spin - 1), spin, 2))
+    physical_spin = (spin - 1) // 2
+    if mass == 0:
+        return (-physical_spin, physical_spin)
+    return tuple(range(-physical_spin, physical_spin + 1))
+
+
+def _validate_processes(processes: Mapping[str, object]) -> None:
+    typed = {
+        key: value for key, value in processes.items() if isinstance(value, Process)
+    }
+    for process in typed.values():
+        width = len(process.external_pdgs)
+        if (
+            len(process.external_labels) != width
+            or len(process.external_leg_ids) != width
+            or len(process.external_spins) != width
+            or len(process.external_colors) != width
+            or len(process.external_masses) != width
+            or len(process.external_helicity_domains) != width
+        ):
+            raise ReferenceFixtureError(
+                f"process {process.id} external identity/helicity metadata has "
+                "the wrong width"
+            )
+        if len(set(process.external_labels)) != width or any(
+            label < 1 for label in process.external_labels
+        ):
+            raise ReferenceFixtureError(
+                f"process {process.id} external labels must be distinct and positive"
+            )
+        unsupported_colors = set(process.external_colors) - {1, 3, -3, 8}
+        if unsupported_colors:
+            raise ReferenceFixtureError(
+                f"process {process.id} uses unsupported external color "
+                f"representations {sorted(unsupported_colors)}"
+            )
+        expected_domains = tuple(
+            _physical_helicity_domain(spin, mass)
+            for spin, mass in zip(
+                process.external_spins, process.external_masses, strict=True
+            )
+        )
+        if process.external_helicity_domains != expected_domains:
+            raise ReferenceFixtureError(
+                f"process {process.id} helicity domains do not follow its "
+                "model-derived spin and mass metadata"
+            )
+        if process.initial_state_count >= len(process.external_pdgs):
+            raise ReferenceFixtureError(
+                f"process {process.id} has no final-state particles"
+            )
+        if process.alias_of is None:
+            if process.final_state_permutation is not None:
+                raise ReferenceFixtureError(
+                    f"primary process {process.id} must not define a final-state "
+                    "permutation"
+                )
+            continue
+        source = typed.get(process.alias_of)
+        if source is None:
+            raise ReferenceFixtureError(
+                f"process {process.id} references unknown alias source "
+                f"{process.alias_of}"
+            )
+        if process.id == source.id:
+            raise ReferenceFixtureError(f"process {process.id} aliases itself")
+        if process.initial_state_count != source.initial_state_count:
+            raise ReferenceFixtureError(
+                f"process {process.id} alias changes the initial-state width"
+            )
+        if len(process.external_pdgs) != len(source.external_pdgs):
+            raise ReferenceFixtureError(
+                f"process {process.id} alias changes the external-state width"
+            )
+        if process.external_labels != source.external_labels:
+            raise ReferenceFixtureError(
+                f"process {process.id} alias changes canonical external labels"
+            )
+        if (
+            process.external_pdgs[: process.initial_state_count]
+            != source.external_pdgs[: source.initial_state_count]
+        ):
+            raise ReferenceFixtureError(
+                f"process {process.id} alias changes initial-state PDGs"
+            )
+        if (
+            process.external_leg_ids[: process.initial_state_count]
+            != source.external_leg_ids[: source.initial_state_count]
+        ):
+            raise ReferenceFixtureError(
+                f"process {process.id} alias changes initial-state leg identities"
+            )
+        if (
+            process.external_helicity_domains[: process.initial_state_count]
+            != source.external_helicity_domains[: source.initial_state_count]
+        ):
+            raise ReferenceFixtureError(
+                f"process {process.id} alias changes initial-state helicity domains"
+            )
+        for name, values, source_values in (
+            ("spin", process.external_spins, source.external_spins),
+            ("color", process.external_colors, source.external_colors),
+            ("mass", process.external_masses, source.external_masses),
+        ):
+            if (
+                values[: process.initial_state_count]
+                != source_values[: source.initial_state_count]
+            ):
+                raise ReferenceFixtureError(
+                    f"process {process.id} alias changes initial-state {name} metadata"
+                )
+        permutation = process.final_state_permutation
+        final_count = len(source.external_pdgs) - source.initial_state_count
+        if permutation is None or sorted(permutation) != list(range(final_count)):
+            raise ReferenceFixtureError(
+                f"process {process.id} has an invalid final-state permutation"
+            )
+        source_final = source.external_pdgs[source.initial_state_count :]
+        expected_final = tuple(source_final[position] for position in permutation)
+        if process.external_pdgs[process.initial_state_count :] != expected_final:
+            raise ReferenceFixtureError(
+                f"process {process.id} final-state permutation does not match its PDGs"
+            )
+        source_final_legs = source.external_leg_ids[source.initial_state_count :]
+        expected_final_legs = tuple(
+            source_final_legs[position] for position in permutation
+        )
+        if process.external_leg_ids[process.initial_state_count :] != (
+            expected_final_legs
+        ):
+            raise ReferenceFixtureError(
+                f"process {process.id} final-state permutation does not match "
+                "its leg identities"
+            )
+        source_final_helicities = source.external_helicity_domains[
+            source.initial_state_count :
+        ]
+        expected_final_helicities = tuple(
+            source_final_helicities[position] for position in permutation
+        )
+        if process.external_helicity_domains[process.initial_state_count :] != (
+            expected_final_helicities
+        ):
+            raise ReferenceFixtureError(
+                f"process {process.id} final-state permutation does not match "
+                "its helicity domains"
+            )
+        for name, values, source_values in (
+            ("spin", process.external_spins, source.external_spins),
+            ("color", process.external_colors, source.external_colors),
+            ("mass", process.external_masses, source.external_masses),
+        ):
+            expected_values = tuple(
+                source_values[source.initial_state_count :][position]
+                for position in permutation
+            )
+            if values[process.initial_state_count :] != expected_values:
+                raise ReferenceFixtureError(
+                    f"process {process.id} final-state permutation does not match "
+                    f"its {name} metadata"
+                )
+
+    for process in typed.values():
+        seen: set[str] = set()
+        current = process
+        while current.alias_of is not None:
+            if current.id in seen:
+                raise ReferenceFixtureError(
+                    f"process alias cycle includes {current.id}"
+                )
+            seen.add(current.id)
+            current = typed[current.alias_of]
+
+
+def _validate_case_axes(case: ReferenceCase, process: Process) -> None:
+    helicity_ids = _unique(case.helicities, f"case {case.id} helicity")
+    color_ids = _unique(case.colors, f"case {case.id} color")
+    if [axis.index for axis in case.helicities] != list(range(len(case.helicities))):
+        raise ReferenceFixtureError(
+            f"case {case.id} helicity indices must be contiguous and ordered"
+        )
+    if [axis.index for axis in case.colors] != list(range(len(case.colors))):
+        raise ReferenceFixtureError(
+            f"case {case.id} color indices must be contiguous and ordered"
+        )
+    if case.coverage.helicity_count != len(case.helicities):
+        raise ReferenceFixtureError(
+            f"case {case.id} helicity axis count does not match coverage"
+        )
+    if case.coverage.color_component_count != len(case.colors):
+        raise ReferenceFixtureError(
+            f"case {case.id} color axis count does not match coverage"
+        )
+    if case.case_kind == "substantive":
+        if case.coverage.helicities != "complete":
+            raise ReferenceFixtureError(
+                f"substantive case {case.id} requires complete helicity coverage"
+            )
+        expected_color_coverage = (
+            "complete" if case.color_accuracy == "lc" else "contracted"
+        )
+        if case.coverage.color != expected_color_coverage:
+            raise ReferenceFixtureError(
+                f"substantive case {case.id} requires complete color coverage"
+            )
+    elif (
+        case.coverage.helicities == "selected" or case.coverage.color == "selected"
+    ) and case.case_kind != "diagnostic":
+        raise ReferenceFixtureError(
+            f"selected coverage is restricted to diagnostic case {case.id}"
+        )
+    helicity_values = [axis.values for axis in case.helicities]
+    if len(set(helicity_values)) != len(helicity_values):
+        raise ReferenceFixtureError(f"case {case.id} has duplicate helicity vectors")
+    physical_helicities = set(product(*process.external_helicity_domains))
+    if not set(helicity_values) <= physical_helicities:
+        raise ReferenceFixtureError(
+            f"case {case.id} contains helicities outside the process domains"
+        )
+    if case.coverage.helicities == "complete" and set(helicity_values) != (
+        physical_helicities
+    ):
+        raise ReferenceFixtureError(
+            f"case {case.id} does not contain the complete physical helicity axis"
+        )
+    for helicity in case.helicities:
+        if len(helicity.values) != len(process.external_pdgs):
+            raise ReferenceFixtureError(
+                f"case {case.id} helicity {helicity.id} has the wrong width"
+            )
+        if helicity.representative_id not in helicity_ids:
+            raise ReferenceFixtureError(
+                f"case {case.id} helicity {helicity.id} has an unknown representative"
+            )
+        representative = helicity_ids[helicity.representative_id]
+        assert isinstance(representative, HelicityAxis)
+        if helicity.structural_zero:
+            if (
+                helicity.computed
+                or helicity.coefficient != 0
+                or helicity.representative_id != helicity.id
+            ):
+                raise ReferenceFixtureError(
+                    f"case {case.id} structural-zero helicity {helicity.id} "
+                    "must be uncomputed, self-represented, and have zero coefficient"
+                )
+        elif helicity.computed:
+            if helicity.representative_id != helicity.id or helicity.coefficient != 1:
+                raise ReferenceFixtureError(
+                    f"case {case.id} computed helicity {helicity.id} must be its "
+                    "own unit-coefficient representative"
+                )
+        elif (
+            representative.structural_zero
+            or not representative.computed
+            or helicity.representative_id == helicity.id
+            or helicity.coefficient <= 0
+        ):
+            raise ReferenceFixtureError(
+                f"case {case.id} folded helicity {helicity.id} must reference a "
+                "computed representative with a positive physical weight"
+            )
+    structural_zeros = sum(axis.structural_zero for axis in case.helicities)
+    if structural_zeros != case.coverage.structural_zero_helicity_count:
+        raise ReferenceFixtureError(
+            f"case {case.id} structural-zero coverage count is inconsistent"
+        )
+    if not case.selectors.helicity:
+        raise ReferenceFixtureError(
+            f"case {case.id} must expose physical helicity selection"
+        )
+
+    if case.color_accuracy == "lc":
+        if not all(isinstance(color, LCColorFlow) for color in case.colors):
+            raise ReferenceFixtureError(
+                f"LC case {case.id} must use only physical LC flow axes"
+            )
+        if (
+            case.coverage.color_kind != "physical-lc-flows"
+            or case.coverage.color
+            not in {
+                "complete",
+                "selected",
+            }
+        ):
+            raise ReferenceFixtureError(f"LC case {case.id} has invalid color coverage")
+        if (
+            not case.selectors.color_flow
+            or case.selectors.omitted_color != "all-components"
+        ):
+            raise ReferenceFixtureError(
+                f"LC case {case.id} has invalid color-flow selector semantics"
+            )
+        if (
+            case.reduction.kind != "lc-diagonal"
+            or case.reduction.cell_semantics != "sum-all-contributing-groups"
+        ):
+            raise ReferenceFixtureError(
+                f"LC case {case.id} has invalid reduction semantics"
+            )
+        color_words = [
+            color.word for color in case.colors if isinstance(color, LCColorFlow)
+        ]
+        if len(set(color_words)) != len(color_words):
+            raise ReferenceFixtureError(f"case {case.id} has duplicate LC flow words")
+        colored_labels = {
+            label
+            for label, color in zip(
+                process.external_labels, process.external_colors, strict=True
+            )
+            if color != 1
+        }
+        for word in color_words:
+            if len(set(word)) != len(word) or set(word) != colored_labels:
+                raise ReferenceFixtureError(
+                    f"case {case.id} LC flow word does not contain exactly the "
+                    "model-derived colored external labels"
+                )
+        for color in case.colors:
+            assert isinstance(color, LCColorFlow)
+            if color.representative_id not in color_ids:
+                raise ReferenceFixtureError(
+                    f"case {case.id} color {color.id} has an unknown representative"
+                )
+            color_representative = color_ids[color.representative_id]
+            assert isinstance(color_representative, LCColorFlow)
+            if color.computed:
+                if color.representative_id != color.id or color.coefficient != 1:
+                    raise ReferenceFixtureError(
+                        f"case {case.id} computed color {color.id} must be its "
+                        "own unit-coefficient representative"
+                    )
+            elif (
+                not color_representative.computed
+                or color.representative_id == color.id
+                or color.coefficient <= 0
+            ):
+                raise ReferenceFixtureError(
+                    f"case {case.id} folded color {color.id} must reference a "
+                    "computed representative with a positive physical weight"
+                )
+    else:
+        if len(case.colors) != 1 or not isinstance(
+            case.colors[0], ContractedColorComponent
+        ):
+            raise ReferenceFixtureError(
+                f"{case.color_accuracy.upper()} case {case.id} must have exactly one "
+                "contracted color axis"
+            )
+        if case.coverage.color != "contracted" or case.coverage.color_kind != (
+            "contracted-color"
+        ):
+            raise ReferenceFixtureError(
+                f"{case.color_accuracy.upper()} case {case.id} has invalid "
+                "color coverage"
+            )
+        if case.selectors.color_flow or case.selectors.omitted_color != (
+            "contracted-component"
+        ):
+            raise ReferenceFixtureError(
+                f"{case.color_accuracy.upper()} case {case.id} has invalid "
+                "selector semantics"
+            )
+        if (
+            case.reduction.kind != "contracted-color"
+            or case.reduction.cell_semantics != "fully-contracted-color"
+        ):
+            raise ReferenceFixtureError(
+                f"{case.color_accuracy.upper()} case {case.id} has invalid "
+                "reduction semantics"
+            )
+    _validate_reduction_groups(case, helicity_ids, color_ids)
+
+
+def _validate_reduction_groups(
+    case: ReferenceCase,
+    helicity_ids: Mapping[str, object],
+    color_ids: Mapping[str, object],
+) -> None:
+    groups = _unique(case.reduction.groups, f"case {case.id} reduction group")
+    if len(groups) != case.topology.reduction_groups:
+        raise ReferenceFixtureError(
+            f"case {case.id} reduction group count does not match topology"
+        )
+
+    expected_cells = {
+        (helicity.id, color.id)
+        for helicity in case.helicities
+        if not helicity.structural_zero
+        for color in case.colors
+    }
+    covered_cells: set[tuple[str, str]] = set()
+    for group in case.reduction.groups:
+        if (
+            not group.physical_helicity_ids
+            or not group.physical_color_ids
+            or len(set(group.physical_helicity_ids)) != len(group.physical_helicity_ids)
+            or len(set(group.physical_color_ids)) != len(group.physical_color_ids)
+        ):
+            raise ReferenceFixtureError(
+                f"case {case.id} reduction group {group.id} has empty or duplicate "
+                "physical members"
+            )
+        if (
+            group.representative_helicity_id not in group.physical_helicity_ids
+            or group.representative_color_id not in group.physical_color_ids
+        ):
+            raise ReferenceFixtureError(
+                f"case {case.id} reduction group {group.id} excludes its representative"
+            )
+        unknown_helicities = set(group.physical_helicity_ids) - helicity_ids.keys()
+        unknown_colors = set(group.physical_color_ids) - color_ids.keys()
+        if unknown_helicities or unknown_colors:
+            raise ReferenceFixtureError(
+                f"case {case.id} reduction group {group.id} references unknown axes"
+            )
+
+        representative_helicity = helicity_ids[group.representative_helicity_id]
+        assert isinstance(representative_helicity, HelicityAxis)
+        if not representative_helicity.computed:
+            raise ReferenceFixtureError(
+                f"case {case.id} reduction group {group.id} helicity "
+                "representative is not computed"
+            )
+        for identifier in group.physical_helicity_ids:
+            helicity = helicity_ids[identifier]
+            assert isinstance(helicity, HelicityAxis)
+            if helicity.structural_zero or (
+                helicity.representative_id != group.representative_helicity_id
+            ):
+                raise ReferenceFixtureError(
+                    f"case {case.id} reduction group {group.id} has an invalid "
+                    f"helicity member {identifier}"
+                )
+
+        representative_color = color_ids[group.representative_color_id]
+        if isinstance(representative_color, LCColorFlow) and not (
+            representative_color.computed
+        ):
+            raise ReferenceFixtureError(
+                f"case {case.id} reduction group {group.id} color representative "
+                "is not computed"
+            )
+        for identifier in group.physical_color_ids:
+            color = color_ids[identifier]
+            if isinstance(color, LCColorFlow) and (
+                color.representative_id != group.representative_color_id
+            ):
+                raise ReferenceFixtureError(
+                    f"case {case.id} reduction group {group.id} has an invalid "
+                    f"color member {identifier}"
+                )
+
+        group_cells = set(
+            product(group.physical_helicity_ids, group.physical_color_ids)
+        )
+        # LC groups expand disjoint representative cells. Contracted NLC/full
+        # outputs are many-to-one: several coherent groups can contribute to
+        # the same public (helicity, contracted-color) cell.
+        if case.color_accuracy == "lc" and covered_cells & group_cells:
+            raise ReferenceFixtureError(
+                f"case {case.id} reduction groups overlap on physical cells"
+            )
+        covered_cells.update(group_cells)
+
+    if covered_cells != expected_cells:
+        relation = "partition" if case.color_accuracy == "lc" else "cover"
+        raise ReferenceFixtureError(
+            f"case {case.id} reduction groups do not {relation} every nonzero "
+            "physical cell"
+        )
+
+
+def _validate_observation_reduction_relations(
+    case: ReferenceCase,
+    observation: Observation,
+) -> None:
+    helicity_indices = {axis.id: index for index, axis in enumerate(case.helicities)}
+    color_indices = {axis.id: index for index, axis in enumerate(case.colors)}
+    for helicity in case.helicities:
+        if helicity.computed or helicity.structural_zero:
+            continue
+        member_index = helicity_indices[helicity.id]
+        representative_index = helicity_indices[helicity.representative_id]
+        coefficient = _as_fraction(helicity.coefficient)
+        for member, representative in zip(
+            observation.values[member_index],
+            observation.values[representative_index],
+            strict=True,
+        ):
+            if _as_fraction(member) != coefficient * _as_fraction(representative):
+                raise ReferenceFixtureError(
+                    f"observation {case.id}/{observation.point_id} violates "
+                    f"helicity representative relation for {helicity.id}"
+                )
+    for color in case.colors:
+        if not isinstance(color, LCColorFlow) or color.computed:
+            continue
+        member_index = color_indices[color.id]
+        representative_index = color_indices[color.representative_id]
+        coefficient = _as_fraction(color.coefficient)
+        for row in observation.values:
+            if _as_fraction(row[member_index]) != (
+                coefficient * _as_fraction(row[representative_index])
+            ):
+                raise ReferenceFixtureError(
+                    f"observation {case.id}/{observation.point_id} violates "
+                    f"color representative relation for {color.id}"
+                )
diff --git a/pyamplicol/tools/developer/reference_fixture_v2.py b/pyamplicol/tools/developer/reference_fixture_v2.py
new file mode 100644
index 0000000000..2bc48237f2
--- /dev/null
+++ b/pyamplicol/tools/developer/reference_fixture_v2.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Compatibility entry point for the strict reference-fixture v2 reader."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+DEVELOPER_ROOT = Path(__file__).resolve().parent
+if str(DEVELOPER_ROOT) not in sys.path:
+    sys.path.insert(0, str(DEVELOPER_ROOT))
+
+from reference_fixture import *  # type: ignore[import-not-found] # noqa: E402,F403
+from reference_fixture import __all__  # noqa: E402,F401
diff --git a/pyamplicol/tools/developer/reset_performance_campaign.py b/pyamplicol/tools/developer/reset_performance_campaign.py
new file mode 100644
index 0000000000..d754da7e47
--- /dev/null
+++ b/pyamplicol/tools/developer/reset_performance_campaign.py
@@ -0,0 +1,651 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+# ruff: noqa: E402
+"""Prepare, commit, recover, and verify one full report-campaign restart."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tomllib
+import uuid
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+_REPOSITORY_ROOT = Path(__file__).resolve().parents[2]
+if os.fspath(_REPOSITORY_ROOT) not in sys.path:
+    sys.path.insert(0, os.fspath(_REPOSITORY_ROOT))
+
+from tools.performance_report.artifacts import ArtifactStore
+from tools.performance_report.cache import empty_measurement
+from tools.performance_report.campaign_activity import (
+    blocking_process_lines,
+    is_snapshot_publisher_process,
+    parse_lsof_field_output,
+)
+from tools.performance_report.campaign_policy import validate_policy_profile
+from tools.performance_report.campaign_reset import (
+    BASELINE_GATE_FILENAME,
+    CAMPAIGN_MARKER_FILENAME,
+    EXPECTED_AMPLICOL_CELL_COUNT,
+    EXPECTED_CATALOG_CELL_COUNT,
+    EXPECTED_NON_AMPLICOL_CELL_COUNT,
+    CampaignResetError,
+    OriginalAmplicolSeed,
+    ResetTransactionPaths,
+    assert_campaign_marker,
+    build_seed_manifest,
+    campaign_marker,
+    canonical_json_bytes,
+    commit_or_recover_reset,
+    lightweight_archive_inventory,
+    mark_campaign_ready,
+    sha256_path,
+    sha256_payload,
+    stage_seed_store,
+    temporary_staging_root,
+    write_prepared_journal,
+)
+from tools.performance_report.catalog import REPORT_CATALOG
+from tools.performance_report.models import ExecutionMode
+from tools.performance_report.service import ReportPaths, ReportService
+from tools.performance_report.source_identity import require_eligible_report_source
+from tools.performance_report.workspace import load_profile_campaign_policy
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Archive an old performance campaign and seed a clean epoch with "
+            "same-host authenticated original-AmpliCol currents."
+        )
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    prepare = subparsers.add_parser("prepare")
+    for item in (prepare,):
+        item.add_argument("--source-repo-root", type=Path, required=True)
+        item.add_argument("--destination-repo-root", type=Path, required=True)
+        item.add_argument("--profile", required=True)
+        item.add_argument("--campaign-id", required=True)
+        item.add_argument("--archive-id", required=True)
+        item.add_argument("--expected-source-revision", required=True)
+        item.add_argument("--expected-source-tree", required=True)
+        item.add_argument("--source-artifact-root", type=Path)
+        item.add_argument("--source-coordination-root", type=Path)
+        item.add_argument("--destination-artifact-root", type=Path)
+        item.add_argument("--destination-coordination-root", type=Path)
+        item.add_argument("--archive-root", type=Path)
+
+    for command in ("commit", "recover"):
+        item = subparsers.add_parser(command)
+        item.add_argument("--journal", type=Path, required=True)
+
+    verify = subparsers.add_parser("verify-baseline")
+    verify.add_argument("--repo-root", type=Path, required=True)
+    verify.add_argument("--profile", required=True)
+    verify.add_argument("--campaign-id", required=True)
+    verify.add_argument("--expected-source-revision", required=True)
+    verify.add_argument("--expected-source-tree", required=True)
+    verify.add_argument("--expected-marker-sha256")
+    verify.add_argument("--artifact-root", type=Path)
+    verify.add_argument("--coordination-root", type=Path)
+
+    marker = subparsers.add_parser("assert-marker")
+    marker.add_argument("--repo-root", type=Path, required=True)
+    marker.add_argument("--profile", required=True)
+    marker.add_argument("--campaign-id", required=True)
+    marker.add_argument("--expected-source-revision", required=True)
+    marker.add_argument("--expected-source-tree", required=True)
+    marker.add_argument("--expected-marker-sha256")
+    marker.add_argument("--artifact-root", type=Path)
+    return parser
+
+
+def _run(
+    command: Sequence[str],
+    *,
+    cwd: Path,
+    check: bool = True,
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        tuple(command),
+        cwd=cwd,
+        check=check,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _strict_idle(
+    *,
+    coordination_roots: Sequence[Path],
+    entrypoints: Sequence[Path],
+) -> None:
+    process_output = _run(
+        ("ps", "-axo", "pid=,comm=,args="),
+        cwd=Path.cwd(),
+    ).stdout
+    blocking = list(
+        blocking_process_lines(
+            process_output,
+            entrypoints=entrypoints,
+        )
+    )
+    for line in process_output.splitlines():
+        fields = line.strip().split(None, 2)
+        if len(fields) == 3 and is_snapshot_publisher_process(fields[2]):
+            blocking.append(line.strip())
+    if blocking:
+        raise CampaignResetError(
+            "campaign reset requires process idleness: "
+            + "; ".join(blocking[:12])
+        )
+    open_files: list[str] = []
+    for root in coordination_roots:
+        if not root.exists():
+            continue
+        result = _run(
+            ("lsof", "-Fpcfnt", "+D", os.fspath(root)),
+            cwd=Path.cwd(),
+            check=False,
+        )
+        open_files.extend(
+            f"{item.pid}:{item.command}:{item.descriptor}:{item.path}"
+            for item in parse_lsof_field_output(result.stdout)
+        )
+    if open_files:
+        raise CampaignResetError(
+            "campaign reset requires every coordination FD closed: "
+            + "; ".join(open_files[:12])
+        )
+
+
+def _copy_tree(source: Path, destination: Path) -> None:
+    if destination.exists():
+        raise CampaignResetError(f"staging destination already exists: {destination}")
+    if not source.is_dir() or source.is_symlink():
+        raise CampaignResetError(f"source is not a regular directory: {source}")
+    shutil.copytree(source, destination, symlinks=False)
+
+
+def _filesystem_device(path: Path) -> int:
+    candidate = path.expanduser().resolve(strict=False)
+    while not candidate.exists():
+        parent = candidate.parent
+        if parent == candidate:
+            raise CampaignResetError(
+                f"cannot resolve filesystem device for {path}"
+            )
+        candidate = parent
+    return candidate.stat().st_dev
+
+
+def _require_same_filesystem(paths: Sequence[Path]) -> None:
+    devices = {_filesystem_device(path) for path in paths}
+    if len(devices) != 1:
+        raise CampaignResetError(
+            "campaign reset roots/staging/archive are not on one filesystem"
+        )
+
+
+def _pinned_legacy_revision(repo_root: Path) -> str:
+    path = repo_root / "dependencies" / "contributor-lock.toml"
+    try:
+        payload = tomllib.loads(path.read_text(encoding="utf-8"))
+        legacy = payload["legacy_amplicol"]
+        revision = legacy["revision"]
+    except (OSError, KeyError, TypeError, tomllib.TOMLDecodeError) as error:
+        raise CampaignResetError(
+            "cannot load contributor-lock original-AmpliCol revision"
+        ) from error
+    if not isinstance(revision, str):
+        raise CampaignResetError(
+            "contributor-lock original-AmpliCol revision is malformed"
+        )
+    return revision
+
+
+def _write_json(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{uuid.uuid4()}.tmp")
+    with temporary.open("wb") as stream:
+        stream.write(canonical_json_bytes(payload))
+        stream.flush()
+        os.fsync(stream.fileno())
+    os.replace(temporary, path)
+
+
+def _resolved_paths(arguments: argparse.Namespace) -> tuple[
+    Path,
+    Path,
+    ReportPaths,
+    ReportPaths,
+    Path,
+]:
+    source = arguments.source_repo_root.expanduser().resolve(strict=True)
+    destination = arguments.destination_repo_root.expanduser().resolve(strict=True)
+    source_paths = ReportPaths.from_repo(
+        source,
+        profile=arguments.profile,
+        artifact_root=arguments.source_artifact_root,
+        coordination_root=arguments.source_coordination_root,
+    )
+    destination_paths = ReportPaths.from_repo(
+        destination,
+        profile=arguments.profile,
+        artifact_root=arguments.destination_artifact_root,
+        coordination_root=arguments.destination_coordination_root,
+    )
+    archive = (
+        arguments.archive_root.expanduser().resolve(strict=False)
+        if arguments.archive_root is not None
+        else (
+            source
+            / ".artifacts"
+            / "performance-report-archive"
+            / arguments.archive_id
+            / arguments.profile
+        )
+    )
+    return source, destination, source_paths, destination_paths, archive
+
+
+def _prepare(arguments: argparse.Namespace) -> dict[str, object]:
+    (
+        source,
+        destination,
+        source_paths,
+        destination_paths,
+        archive_root,
+    ) = _resolved_paths(arguments)
+    identity = require_eligible_report_source(destination)
+    if (
+        identity.revision != arguments.expected_source_revision
+        or identity.tree != arguments.expected_source_tree
+    ):
+        raise CampaignResetError("destination source identity differs")
+    if archive_root.exists():
+        raise CampaignResetError(f"archive already exists: {archive_root}")
+    if (
+        destination_paths.artifact_root.exists()
+        or destination_paths.coordination_root.exists()
+    ):
+        raise CampaignResetError("destination campaign roots already exist")
+    _strict_idle(
+        coordination_roots=(source_paths.coordination_root,),
+        entrypoints=(
+            source_paths.docs_dir / "result_tables.py",
+            destination_paths.docs_dir / "result_tables.py",
+        ),
+    )
+    policy = load_profile_campaign_policy(
+        destination,
+        arguments.profile,
+        expected_source_revision=identity.revision,
+    )
+    validate_policy_profile(policy, arguments.profile)
+    _require_same_filesystem(
+        (
+            source_paths.docs_dir,
+            source_paths.artifact_root,
+            source_paths.coordination_root,
+            destination_paths.docs_dir,
+            destination_paths.artifact_root.parent,
+            destination_paths.coordination_root.parent,
+            archive_root.parent,
+        )
+    )
+    source_store = ArtifactStore(
+        artifact_root=source_paths.artifact_root,
+        lock_root=source_paths.coordination_root,
+    )
+    seed_manifest = build_seed_manifest(
+        profile=arguments.profile,
+        store=source_store,
+        policy=policy,
+        final_source_revision=identity.revision,
+        final_source_tree=identity.tree,
+        expected_legacy_revision=_pinned_legacy_revision(destination),
+    )
+    staging = temporary_staging_root(
+        destination_paths.artifact_root.parent,
+        campaign_id=arguments.campaign_id,
+    )
+    fresh_artifacts = staging / "fresh-artifacts"
+    fresh_coordination = staging / "fresh-coordination"
+    fresh_store = stage_seed_store(
+        source_store=source_store,
+        destination_root=fresh_artifacts,
+        destination_lock_root=fresh_coordination,
+        seed_manifest=seed_manifest,
+    )
+    archive_publication = staging / "archive-publication"
+    _copy_tree(source_paths.docs_dir, archive_publication)
+    fresh_publication = staging / "fresh-publication"
+    _copy_tree(destination_paths.docs_dir, fresh_publication)
+    inventory = lightweight_archive_inventory(
+        (
+            source_paths.docs_dir,
+            source_paths.artifact_root,
+            source_paths.coordination_root,
+        )
+    )
+    archive_manifest: dict[str, object] = {
+        "schema": "pyamplicol-performance-campaign-archive-v1",
+        "archive_id": arguments.archive_id,
+        "profile": arguments.profile,
+        "source_repo_root": os.fspath(source),
+        "source_publication": os.fspath(source_paths.docs_dir),
+        "source_artifact_root": os.fspath(source_paths.artifact_root),
+        "source_coordination_root": os.fspath(source_paths.coordination_root),
+        "inventory": inventory,
+    }
+    archive_manifest["archive_manifest_sha256"] = sha256_payload(archive_manifest)
+    _write_json(staging / "archive-manifest.json", archive_manifest)
+    marker = campaign_marker(
+        campaign_id=arguments.campaign_id,
+        profile=arguments.profile,
+        source_revision=identity.revision,
+        source_tree=identity.tree,
+        policy_sha256=sha256_payload(policy.as_manifest()),
+        seed_manifest_sha256=str(seed_manifest["seed_manifest_sha256"]),
+        archive_manifest_sha256=str(
+            archive_manifest["archive_manifest_sha256"]
+        ),
+    )
+    _write_json(fresh_artifacts / CAMPAIGN_MARKER_FILENAME, marker)
+    staged_service = ReportService(
+        ReportPaths(
+            repo_root=destination,
+            docs_dir=fresh_publication,
+            results_dir=fresh_publication / "results",
+            artifact_root=fresh_artifacts,
+            coordination_root=fresh_coordination,
+        )
+    )
+    staged_service.bind_original_amplicol_seed(
+        OriginalAmplicolSeed.load(
+            fresh_artifacts / "original_amplicol_seed.json",
+            profile=arguments.profile,
+            store=fresh_store,
+            expected_final_source_revision=identity.revision,
+            expected_final_source_tree=identity.tree,
+            expected_manifest_sha256=str(
+                seed_manifest["seed_manifest_sha256"]
+            ),
+        )
+    )
+    staged_service.publish(reset=True, merge_artifacts=False)
+    staged_service.publish(reset=False, merge_artifacts=True)
+    paths = ResetTransactionPaths(
+        source_publication=source_paths.docs_dir,
+        source_artifact_root=source_paths.artifact_root,
+        source_coordination_root=source_paths.coordination_root,
+        destination_publication=destination_paths.docs_dir,
+        destination_artifact_root=destination_paths.artifact_root,
+        destination_coordination_root=destination_paths.coordination_root,
+        archive_root=archive_root,
+        staging_root=staging,
+        guard_path=archive_root.parent / ".campaign-reset.guard",
+    )
+    journal = write_prepared_journal(
+        profile=arguments.profile,
+        campaign_id=arguments.campaign_id,
+        archive_id=arguments.archive_id,
+        paths=paths,
+        archive_manifest_sha256=str(
+            archive_manifest["archive_manifest_sha256"]
+        ),
+        seed_manifest_sha256=str(seed_manifest["seed_manifest_sha256"]),
+        marker_sha256=str(marker["marker_sha256"]),
+    )
+    return {
+        "status": "PREPARED",
+        "journal": os.fspath(paths.journal_path),
+        "journal_sha256": journal["journal_sha256"],
+        "archive_manifest_sha256": archive_manifest[
+            "archive_manifest_sha256"
+        ],
+        "seed_manifest_sha256": seed_manifest["seed_manifest_sha256"],
+        "marker_sha256": marker["marker_sha256"],
+        "reused": seed_manifest["seed_count"],
+    }
+
+
+def _commit(arguments: argparse.Namespace) -> dict[str, object]:
+    journal = json.loads(
+        arguments.journal.expanduser().resolve(strict=True).read_text()
+    )
+    paths = journal.get("paths", {})
+    if not isinstance(paths, Mapping):
+        raise CampaignResetError("campaign reset journal paths are malformed")
+    coordination = tuple(
+        Path(str(paths[key]))
+        for key in ("source_coordination_root", "destination_coordination_root")
+        if Path(str(paths[key])).exists()
+    )
+    _strict_idle(coordination_roots=coordination, entrypoints=())
+    return commit_or_recover_reset(arguments.journal.expanduser().resolve())
+
+
+def _publisher_command(
+    *,
+    repo_root: Path,
+    profile: str,
+    artifact_root: Path,
+    coordination_root: Path,
+    command: str,
+) -> tuple[str, ...]:
+    return (
+        sys.executable,
+        os.fspath(
+            repo_root / "docs" / "performance_reports" / profile / "result_tables.py"
+        ),
+        "--repo-root",
+        os.fspath(repo_root),
+        "--report-profile",
+        profile,
+        "--artifact-root",
+        os.fspath(artifact_root),
+        "--coordination-root",
+        os.fspath(coordination_root),
+        command,
+    )
+
+
+def _verify_baseline(arguments: argparse.Namespace) -> dict[str, object]:
+    repo = arguments.repo_root.expanduser().resolve(strict=True)
+    paths = ReportPaths.from_repo(
+        repo,
+        profile=arguments.profile,
+        artifact_root=arguments.artifact_root,
+        coordination_root=arguments.coordination_root,
+    )
+    marker = assert_campaign_marker(
+        paths.artifact_root,
+        campaign_id=arguments.campaign_id,
+        profile=arguments.profile,
+        source_revision=arguments.expected_source_revision,
+        source_tree=arguments.expected_source_tree,
+        expected_marker_sha256=arguments.expected_marker_sha256,
+        require_ready=False,
+    )
+    store = ArtifactStore(
+        artifact_root=paths.artifact_root,
+        lock_root=paths.coordination_root,
+    )
+    seed = OriginalAmplicolSeed.load(
+        paths.artifact_root / "original_amplicol_seed.json",
+        profile=arguments.profile,
+        store=store,
+        expected_final_source_revision=arguments.expected_source_revision,
+        expected_final_source_tree=arguments.expected_source_tree,
+        expected_manifest_sha256=str(marker["seed_manifest_sha256"]),
+    )
+    records = {record.cell_id: record for record in store.recover_current_records()}
+    if set(records) != set(seed.pins_by_cell):
+        raise CampaignResetError("fresh current inventory differs from seed pins")
+    for cell_id in records:
+        if store.cell_attempt_ids(cell_id) != (records[cell_id].attempt_id,):
+            raise CampaignResetError(f"{cell_id}: fresh attempt inventory differs")
+    observed_attempts = {
+        attempt
+        for path in store.cells_root.glob("*/attempts")
+        if path.is_dir()
+        for attempt in path.iterdir()
+        if attempt.is_dir()
+    }
+    expected_attempts = {record.manifest_path.parent for record in records.values()}
+    if observed_attempts != expected_attempts:
+        raise CampaignResetError(
+            "fresh store contains a non-seed or orphan attempt"
+        )
+    _strict_idle(
+        coordination_roots=(paths.coordination_root,),
+        entrypoints=(paths.docs_dir / "result_tables.py",),
+    )
+    publication = _run(
+        _publisher_command(
+            repo_root=repo,
+            profile=arguments.profile,
+            artifact_root=paths.artifact_root,
+            coordination_root=paths.coordination_root,
+            command="publish-snapshot",
+        ),
+        cwd=repo,
+    )
+    publication_log = paths.artifact_root / "baseline-publication.log"
+    publication_log.write_text(
+        publication.stdout + publication.stderr,
+        encoding="utf-8",
+    )
+    snapshot = json.loads(
+        _run(
+            _publisher_command(
+                repo_root=repo,
+                profile=arguments.profile,
+                artifact_root=paths.artifact_root,
+                coordination_root=paths.coordination_root,
+                command="validate-snapshot",
+            ),
+            cwd=repo,
+        ).stdout
+    )
+    service = ReportService(paths)
+    caches = service.load_caches()
+    entries = {
+        str(entry["cell_id"]): entry["measurement"]
+        for cache in caches.values()
+        for entry in cache["entries"]
+    }
+    cells = REPORT_CATALOG.measurement_cells()
+    if (
+        len(cells) != EXPECTED_CATALOG_CELL_COUNT
+        or set(entries) != {cell.cell_id for cell in cells}
+    ):
+        raise CampaignResetError("baseline gate does not cover exactly 1,796 cells")
+    amplicol = {
+        cell.cell_id
+        for cell in cells
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+    }
+    non_amplicol = {cell.cell_id for cell in cells} - amplicol
+    if (
+        len(amplicol) != EXPECTED_AMPLICOL_CELL_COUNT
+        or len(non_amplicol) != EXPECTED_NON_AMPLICOL_CELL_COUNT
+    ):
+        raise CampaignResetError(
+            "baseline gate catalog split differs from 314/1,482"
+        )
+    for cell_id in non_amplicol:
+        if entries[cell_id] != empty_measurement():
+            raise CampaignResetError(f"{cell_id}: pyAmpliCol row is not canonical N/A")
+    for cell_id in amplicol:
+        populated = entries[cell_id].get("status") != "not_available"
+        if populated != (cell_id in seed.pins_by_cell):
+            raise CampaignResetError(
+                f"{cell_id}: baseline population differs from seed pins"
+            )
+    pdf = paths.docs_dir / "pyAmpliCol.pdf"
+    info = _run(("pdfinfo", os.fspath(pdf)), cwd=repo).stdout
+    page_values = [
+        line.split(":", 1)[1].strip()
+        for line in info.splitlines()
+        if line.startswith("Pages:") and ":" in line
+    ]
+    if page_values != ["73"]:
+        raise CampaignResetError("baseline PDF does not contain exactly 73 pages")
+    reused = len(seed.pins_by_cell)
+    gate: dict[str, object] = {
+        "schema": "pyamplicol-performance-baseline-gate-v1",
+        "campaign_id": arguments.campaign_id,
+        "profile": arguments.profile,
+        "source_revision": arguments.expected_source_revision,
+        "source_tree": arguments.expected_source_tree,
+        "prepared_marker_sha256": marker["marker_sha256"],
+        "seed_manifest_sha256": seed.digest,
+        "catalog_cell_count": len(cells),
+        "amplicol_cell_count": len(amplicol),
+        "non_amplicol_na_count": len(non_amplicol),
+        "reused": reused,
+        "new": 0,
+        "completed": reused,
+        "remaining": len(cells) - reused,
+        "pdf_sha256": sha256_path(pdf),
+        "pdf_mtime_ns": pdf.stat().st_mtime_ns,
+        "pdf_pages": 73,
+        "publisher_log_sha256": sha256_path(publication_log),
+        "snapshot": snapshot,
+    }
+    gate["baseline_gate_sha256"] = sha256_payload(gate)
+    _write_json(paths.artifact_root / BASELINE_GATE_FILENAME, gate)
+    ready_marker = mark_campaign_ready(
+        paths.artifact_root,
+        baseline_gate_sha256=str(gate["baseline_gate_sha256"]),
+    )
+    assert_campaign_marker(
+        paths.artifact_root,
+        campaign_id=arguments.campaign_id,
+        profile=arguments.profile,
+        source_revision=arguments.expected_source_revision,
+        source_tree=arguments.expected_source_tree,
+        expected_marker_sha256=str(ready_marker["marker_sha256"]),
+    )
+    return {**gate, "ready_marker_sha256": ready_marker["marker_sha256"]}
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = _parser().parse_args(argv)
+    try:
+        if arguments.command == "prepare":
+            result = _prepare(arguments)
+        elif arguments.command in {"commit", "recover"}:
+            result = _commit(arguments)
+        elif arguments.command == "verify-baseline":
+            result = _verify_baseline(arguments)
+        else:
+            paths = ReportPaths.from_repo(
+                arguments.repo_root.expanduser().resolve(strict=True),
+                profile=arguments.profile,
+                artifact_root=arguments.artifact_root,
+            )
+            result = assert_campaign_marker(
+                paths.artifact_root,
+                campaign_id=arguments.campaign_id,
+                profile=arguments.profile,
+                source_revision=arguments.expected_source_revision,
+                source_tree=arguments.expected_source_tree,
+                expected_marker_sha256=arguments.expected_marker_sha256,
+            )
+    except CampaignResetError as error:
+        raise SystemExit(f"campaign reset failed: {error}") from error
+    print(json.dumps(result, allow_nan=False, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/runtime_selector_profile.py b/pyamplicol/tools/developer/runtime_selector_profile.py
new file mode 100644
index 0000000000..ba289c1595
--- /dev/null
+++ b/pyamplicol/tools/developer/runtime_selector_profile.py
@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Profile stable per-point selector grouping on one generated artifact."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import random
+import statistics
+import sys
+from collections import Counter
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any, Literal
+
+_PATTERNS = ("homogeneous", "pre-pooled", "alternating", "seeded-random")
+_MAX_SAMPLE_COUNT = 80
+_TARGET_SAMPLE_SECONDS = 0.25
+
+
+class SelectorProfileError(RuntimeError):
+    """Raised when selector profiling cannot establish a valid contract."""
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive finite number")
+    return parsed
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return parsed
+
+
+def selector_pattern(
+    name: str,
+    selector_ids: Sequence[str],
+    point_count: int,
+    *,
+    seed: int,
+) -> tuple[str, ...]:
+    """Build one deterministic selector sequence for the native planner."""
+
+    selectors = tuple(selector_ids)
+    if len(selectors) < 2:
+        raise SelectorProfileError("selector-pattern profiling needs two selectors")
+    if point_count < len(selectors):
+        raise SelectorProfileError(
+            "selector-pattern batch must contain at least one point per selector"
+        )
+    if name == "homogeneous":
+        return (selectors[0],) * point_count
+    if name == "pre-pooled":
+        quotient, remainder = divmod(point_count, len(selectors))
+        return tuple(
+            selector
+            for index, selector in enumerate(selectors)
+            for _ in range(quotient + (index < remainder))
+        )
+    if name == "alternating":
+        return tuple(selectors[index % len(selectors)] for index in range(point_count))
+    if name == "seeded-random":
+        generator = random.Random(seed)
+        result = [generator.choice(selectors) for _ in range(point_count)]
+        for index, selector in enumerate(selectors):
+            result[index] = selector
+        return tuple(result)
+    raise SelectorProfileError(f"unknown selector pattern {name!r}")
+
+
+def _selector_ids(
+    runtime: Any,
+    axis: Literal["color", "helicity"],
+    count: int,
+) -> tuple[str, ...]:
+    physics = runtime.physics
+    if axis == "color":
+        candidates = tuple(flow.id for flow in physics.color_flows)
+    else:
+        candidates = tuple(
+            helicity.id
+            for helicity in physics.helicities
+            if not helicity.structural_zero
+        )
+    selected = candidates[:count]
+    if len(selected) < 2:
+        raise SelectorProfileError(
+            f"artifact exposes fewer than two usable {axis} selectors"
+        )
+    return selected
+
+
+def _selector_kwargs(
+    axis: Literal["color", "helicity"], selectors: Sequence[str]
+) -> dict[str, tuple[str, ...]]:
+    key = "color_flow_by_point" if axis == "color" else "helicity_by_point"
+    return {key: tuple(selectors)}
+
+
+def _global_selector_kwargs(
+    axis: Literal["color", "helicity"], selector: str
+) -> dict[str, tuple[str, ...]]:
+    key = "color_flows" if axis == "color" else "helicities"
+    return {key: (selector,)}
+
+
+def _assert_scatter_correct(
+    runtime: Any,
+    batch: Sequence[Sequence[Sequence[float]]],
+    axis: Literal["color", "helicity"],
+    selectors: Sequence[str],
+) -> dict[str, object]:
+    actual = runtime.evaluate(batch, **_selector_kwargs(axis, selectors))
+    expected_by_selector = {
+        selector: runtime.evaluate(batch, **_global_selector_kwargs(axis, selector))
+        for selector in dict.fromkeys(selectors)
+    }
+    maximum_absolute = 0.0
+    maximum_relative = 0.0
+    passes = True
+    for point_index, (selector, actual_value) in enumerate(
+        zip(selectors, actual, strict=True)
+    ):
+        expected_value = expected_by_selector[selector][point_index]
+        absolute = abs(complex(actual_value) - complex(expected_value))
+        relative = absolute / max(
+            abs(complex(actual_value)), abs(complex(expected_value)), 1.0e-300
+        )
+        maximum_absolute = max(maximum_absolute, absolute)
+        maximum_relative = max(maximum_relative, relative)
+        passes = passes and (absolute <= 1.0e-15 or relative <= 1.0e-12)
+    return {
+        "maximum_absolute_difference": maximum_absolute,
+        "maximum_relative_difference": maximum_relative,
+        "passes": passes,
+    }
+
+
+def _mean_statistics(samples: Sequence[float]) -> dict[str, float]:
+    mean = statistics.fmean(samples)
+    deviation = statistics.stdev(samples) if len(samples) > 1 else 0.0
+    error = deviation / math.sqrt(len(samples)) if samples else 0.0
+    return {
+        "mean_seconds_per_point": mean,
+        "standard_deviation_seconds_per_point": deviation,
+        "standard_error_seconds_per_point": error,
+        "relative_standard_error": error / mean if mean > 0 else 0.0,
+    }
+
+
+def _profile_pattern(
+    runtime: Any,
+    batch: Sequence[Sequence[Sequence[float]]],
+    axis: Literal["color", "helicity"],
+    pattern: str,
+    selectors: tuple[str, ...],
+    *,
+    target_runtime: float,
+    minimum_samples: int,
+    warmup_runs: int,
+    seed: int,
+) -> dict[str, object]:
+    sequence = selector_pattern(pattern, selectors, len(batch), seed=seed)
+    selector_kwargs = _selector_kwargs(axis, sequence)
+    correctness = _assert_scatter_correct(runtime, batch, axis, sequence)
+    for _ in range(warmup_runs):
+        runtime.evaluate(batch, **selector_kwargs)
+
+    probe = runtime._backend.profile_repeated(batch, 1, **selector_kwargs)
+    probe_seconds = float(probe["wall_time_s"])
+    if not math.isfinite(probe_seconds) or probe_seconds <= 0:
+        raise SelectorProfileError("native selector profile returned no wall time")
+    target_sample = min(
+        _TARGET_SAMPLE_SECONDS,
+        target_runtime / max(minimum_samples, 1),
+    )
+    repetitions = max(1, math.ceil(target_sample / probe_seconds))
+    sample_count = max(
+        minimum_samples,
+        math.ceil(target_runtime / (probe_seconds * repetitions)),
+    )
+    sample_count = min(sample_count, _MAX_SAMPLE_COUNT)
+
+    profiles = tuple(
+        runtime._backend.profile_repeated(
+            batch,
+            repetitions,
+            **selector_kwargs,
+        )
+        for _ in range(sample_count)
+    )
+    measured_points = len(batch) * repetitions
+    wall_samples = tuple(
+        float(profile["wall_time_s"]) / measured_points for profile in profiles
+    )
+    first = profiles[0]
+    stable_fields = (
+        "selector_plan_kind",
+        "selector_group_sizes",
+        "selector_reordered_point_count",
+        "selector_simd_lane_width",
+        "selector_simd_occupancy",
+    )
+    for profile in profiles[1:]:
+        if any(profile[field] != first[field] for field in stable_fields):
+            raise SelectorProfileError("native selector plan changed between samples")
+    expected_kind = {
+        "homogeneous": "homogeneous",
+        "pre-pooled": "contiguous",
+        "alternating": "stable-grouped",
+        "seeded-random": "stable-grouped",
+    }[pattern]
+    if first["selector_plan_kind"] != expected_kind:
+        raise SelectorProfileError(
+            f"{pattern} selector plan used {first['selector_plan_kind']!r}, "
+            f"expected {expected_kind!r}"
+        )
+
+    component_fields = (
+        "selector_planner_time_s",
+        "selector_gather_time_s",
+        "selector_scatter_time_s",
+    )
+    timing = {
+        field.removesuffix("_time_s") + "_seconds_per_point": statistics.fmean(
+            float(profile[field]) / measured_points for profile in profiles
+        )
+        for field in component_fields
+    }
+    population = Counter(sequence)
+    digest = hashlib.sha256("\0".join(sequence).encode("utf-8")).hexdigest()
+    return {
+        "pattern": pattern,
+        "selector_axis": axis,
+        "selector_ids": list(selectors),
+        "selector_population": dict(population),
+        "selector_sequence_sha256": digest,
+        "seed": seed if pattern == "seeded-random" else None,
+        "batch_size": len(batch),
+        "warmup_runs": warmup_runs,
+        "sample_count": sample_count,
+        "repetitions_per_sample": repetitions,
+        "measured_point_count": measured_points * sample_count,
+        "selector_plan_kind": first["selector_plan_kind"],
+        "selector_group_sizes": list(first["selector_group_sizes"]),
+        "selector_reordered_point_count": int(
+            first["selector_reordered_point_count"]
+        ),
+        "selector_simd_lane_width": int(first["selector_simd_lane_width"]),
+        "selector_simd_occupancy": float(first["selector_simd_occupancy"]),
+        "correctness": correctness,
+        "wall": _mean_statistics(wall_samples),
+        **timing,
+    }
+
+
+def profile_artifact(arguments: argparse.Namespace) -> dict[str, object]:
+    from pyamplicol import Runtime
+
+    runtime = Runtime.load(arguments.artifact, process=arguments.process)
+    validation = runtime._backend.validation_momenta()
+    if validation is None or len(validation) == 0:
+        raise SelectorProfileError("artifact has no deterministic validation point")
+    source = tuple(validation)
+    batch = tuple(source[index % len(source)] for index in range(arguments.batch_size))
+    axes = ("color", "helicity") if arguments.axis == "both" else (arguments.axis,)
+    results: list[dict[str, object]] = []
+    for axis in axes:
+        selector_ids = _selector_ids(runtime, axis, arguments.selector_count)
+        for pattern in _PATTERNS:
+            results.append(
+                _profile_pattern(
+                    runtime,
+                    batch,
+                    axis,
+                    pattern,
+                    selector_ids,
+                    target_runtime=arguments.target_runtime,
+                    minimum_samples=arguments.minimum_samples,
+                    warmup_runs=arguments.warmup_runs,
+                    seed=arguments.seed,
+                )
+            )
+    return {
+        "kind": "pyamplicol-runtime-selector-pattern-profile",
+        "schema_version": 1,
+        "artifact": str(arguments.artifact.resolve()),
+        "process": runtime.physics.process,
+        "process_id": runtime.physics.process_id,
+        "execution_mode": str(getattr(runtime._backend, "execution_mode", "unknown")),
+        "complete": True,
+        "passes": all(bool(result["correctness"]["passes"]) for result in results),
+        "profiles": results,
+    }
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("artifact", type=Path)
+    result.add_argument("--process")
+    result.add_argument("--axis", choices=("color", "helicity", "both"), default="both")
+    result.add_argument("--batch-size", type=_positive_int, default=1024)
+    result.add_argument("--selector-count", type=_positive_int, default=4)
+    result.add_argument("--seed", type=int, default=0xC0FFEE)
+    result.add_argument("--target-runtime", type=_positive_float, default=1.0)
+    result.add_argument("--minimum-samples", type=_positive_int, default=5)
+    result.add_argument("--warmup-runs", type=int, default=2)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    if arguments.warmup_runs < 0:
+        parser().error("--warmup-runs must be non-negative")
+    try:
+        result = profile_artifact(arguments)
+    except (OSError, SelectorProfileError, ValueError) as error:
+        print(f"runtime-selector-profile: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result["passes"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/structural_work_certificate.py b/pyamplicol/tools/developer/structural_work_certificate.py
new file mode 100644
index 0000000000..752efdc11b
--- /dev/null
+++ b/pyamplicol/tools/developer/structural_work_certificate.py
@@ -0,0 +1,609 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Certify pure-gluon full-color work against an AmpliCol replay.
+
+The legacy generated library materializes one reduced current/interaction
+module and replays one module for every retained color ordering.  pyAmpliCol
+instead fuses those color orderings into one recurrence/DAG/eager schedule.
+Comparing pyAmpliCol with only one legacy module is therefore misleading.  This
+tool computes the exact legacy dynamic replay work and checks that the final
+pyAmpliCol schedule does not evaluate more currents or interactions.
+
+For recurrence artifacts it additionally bounds construction-only inflation.
+Those peaks are intentionally kept separate from the final runtime work: they
+diagnose cold-generation regressions without pretending that discarded
+construction candidates execute at every phase-space point.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+
+class StructuralWorkError(RuntimeError):
+    """The artifacts cannot produce a valid structural-work certificate."""
+
+
+_AFTER_FILTER = re.compile(
+    r"Total number of currents, vertices and amplitudes after filter"
+    r"\s+(\d+)\s+(\d+)\s+(\d+)"
+)
+_VAL_C = re.compile(r"dimension\s*\(\s*1\s*:\s*\d+\s*,\s*(\d+)\s*\)\s*::\s*val_c\b")
+_INT_C = re.compile(r"dimension\s*\(\s*1\s*:\s*\d+\s*,\s*(\d+)\s*\)\s*::\s*int_c\b")
+_PEAK_CONTRIBUTION_COUNT_SEMANTICS = "resident-pending-contributions-v1"
+
+
+@dataclass(frozen=True)
+class LegacyReplayWork:
+    module_current_count: int
+    module_interaction_count: int
+    retained_color_ordering_count: int
+    replay_current_count: int
+    replay_interaction_count: int
+    generated_module_count: int
+
+
+@dataclass(frozen=True)
+class CandidateFinalWork:
+    mode: str
+    current_count: int
+    interaction_count: int
+    current_ratio_to_legacy_replay: float
+    interaction_ratio_to_legacy_replay: float
+
+
+@dataclass(frozen=True)
+class FinalWorkComparison:
+    current_delta_count: int
+    interaction_delta_count: int
+    current_savings_fraction: float
+    interaction_savings_fraction: float
+    classification: str
+
+
+@dataclass(frozen=True)
+class RecurrenceConstructionWork:
+    peak_current_count: int
+    peak_contribution_count: int
+    peak_to_final_current_ratio: float
+    peak_to_final_contribution_ratio: float
+    peak_current_ratio_to_legacy_replay: float
+
+
+@dataclass(frozen=True)
+class StructuralWorkCertificate:
+    schema: str
+    process: str
+    external_pdg_order: tuple[int, ...]
+    legacy: LegacyReplayWork
+    candidate: CandidateFinalWork
+    final_work_comparison: FinalWorkComparison
+    recurrence_construction: RecurrenceConstructionWork | None
+    limits: dict[str, float]
+    status: str
+
+
+@dataclass(frozen=True)
+class AdjacentMultiplicityCensus:
+    schema: str
+    mode: str
+    lower_n_final: int
+    higher_n_final: int
+    legacy_current_growth: float
+    candidate_current_growth: float
+    normalized_current_growth: float
+    legacy_interaction_growth: float
+    candidate_interaction_growth: float
+    normalized_interaction_growth: float
+    normalized_peak_current_growth: float | None
+    limits: dict[str, float]
+    status: str
+
+
+@dataclass(frozen=True)
+class StaticTemplateMaterializationCensus:
+    schema: str
+    mode: str
+    legacy_generated_module_count: int
+    legacy_static_current_count: int
+    legacy_static_interaction_count: int
+    legacy_replay_multiplicity_per_module: int
+    candidate_final_current_count: int
+    candidate_final_interaction_count: int
+    candidate_final_current_ratio: float
+    candidate_final_interaction_ratio: float
+    candidate_peak_current_count: int | None
+    candidate_peak_interaction_count: int | None
+    candidate_peak_current_ratio: float | None
+    candidate_peak_interaction_ratio: float | None
+    limits: dict[str, float]
+    violations: tuple[str, ...]
+    status: str
+
+
+MAX_UNPROVEN_FINAL_TO_LEGACY = 1.05
+MAX_ADJACENT_FINAL_GROWTH = 1.05
+MAX_ADJACENT_PEAK_GROWTH = 1.25
+MAX_STATIC_TEMPLATE_MATERIALIZATION = 1.05
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text())
+    except (OSError, json.JSONDecodeError) as error:
+        raise StructuralWorkError(f"cannot read JSON {path}: {error}") from error
+    if not isinstance(payload, dict):
+        raise StructuralWorkError(f"JSON root is not an object: {path}")
+    return payload
+
+
+def _single_file(root: Path, name: str) -> Path:
+    files = sorted(root.rglob(name))
+    if len(files) != 1:
+        raise StructuralWorkError(
+            f"{root} must contain exactly one {name}; found {len(files)}"
+        )
+    return files[0]
+
+
+def legacy_replay_work(legacy_artifact: Path) -> LegacyReplayWork:
+    probe = _single_file(legacy_artifact, "amplicol_color_library_probe.output")
+    match = _AFTER_FILTER.search(probe.read_text())
+    if match is None:
+        raise StructuralWorkError(
+            "legacy probe lacks authenticated after-filter counts"
+        )
+    _, _, retained_amplitudes = (int(value) for value in match.groups())
+    if retained_amplitudes <= 0:
+        raise StructuralWorkError("legacy probe has no retained color orderings")
+
+    modules = sorted(legacy_artifact.rglob("amp*_lib.f03"))
+    if not modules:
+        raise StructuralWorkError("legacy artifact has no generated library modules")
+    dimensions: set[tuple[int, int]] = set()
+    for module in modules:
+        text = module.read_text()
+        current = _VAL_C.search(text)
+        interaction = _INT_C.search(text)
+        if current is None or interaction is None:
+            raise StructuralWorkError(
+                f"legacy module lacks val_c/int_c dimensions: {module}"
+            )
+        dimensions.add((int(current.group(1)), int(interaction.group(1))))
+    if len(dimensions) != 1:
+        raise StructuralWorkError(
+            "legacy pure-gluon modules do not share one replay shape"
+        )
+    module_currents, module_interactions = dimensions.pop()
+    return LegacyReplayWork(
+        module_current_count=module_currents,
+        module_interaction_count=module_interactions,
+        retained_color_ordering_count=retained_amplitudes,
+        replay_current_count=module_currents * retained_amplitudes,
+        replay_interaction_count=module_interactions * retained_amplitudes,
+        generated_module_count=len(modules),
+    )
+
+
+def _positive_integer(payload: dict[str, Any], key: str, label: str) -> int:
+    value = payload.get(key)
+    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+        raise StructuralWorkError(f"{label} {key} must be a positive integer")
+    return value
+
+
+def candidate_final_work(
+    execution: dict[str, Any],
+    legacy: LegacyReplayWork,
+) -> tuple[CandidateFinalWork, RecurrenceConstructionWork | None]:
+    kind = execution.get("kind")
+    construction = None
+    if kind == "pyamplicol-runtime-recurrence-execution":
+        try:
+            inspection = execution["plan"]["inspection_summary"]
+            schedule = inspection["schedule"]
+        except (KeyError, TypeError) as error:
+            raise StructuralWorkError(
+                "recurrence execution lacks inspection schedule"
+            ) from error
+        mode = "recurrence"
+        currents = _positive_integer(schedule, "current_count", "recurrence schedule")
+        interactions = _positive_integer(
+            schedule, "contribution_count", "recurrence schedule"
+        )
+        construction_payload = inspection.get("construction")
+        if not isinstance(construction_payload, dict):
+            raise StructuralWorkError(
+                "recurrence execution lacks construction diagnostics"
+            )
+        if (
+            construction_payload.get("peak_contribution_count_semantics")
+            != _PEAK_CONTRIBUTION_COUNT_SEMANTICS
+        ):
+            raise StructuralWorkError(
+                "recurrence construction lacks authenticated resident "
+                "peak-contribution semantics"
+            )
+        peak_currents = _positive_integer(
+            construction_payload,
+            "peak_current_count",
+            "recurrence construction",
+        )
+        peak_contributions = _positive_integer(
+            construction_payload,
+            "peak_contribution_count",
+            "recurrence construction",
+        )
+        construction = RecurrenceConstructionWork(
+            peak_current_count=peak_currents,
+            peak_contribution_count=peak_contributions,
+            peak_to_final_current_ratio=peak_currents / currents,
+            peak_to_final_contribution_ratio=peak_contributions / interactions,
+            peak_current_ratio_to_legacy_replay=(
+                peak_currents / legacy.replay_current_count
+            ),
+        )
+    elif kind == "pyamplicol-runtime-execution":
+        summary = execution.get("helicity_sum_execution", {}).get("dag_summary")
+        if not isinstance(summary, dict):
+            raise StructuralWorkError(
+                "compiled execution lacks helicity-sum DAG summary"
+            )
+        mode = "compiled"
+        currents = _positive_integer(summary, "current_count", "compiled DAG")
+        interactions = _positive_integer(summary, "interaction_count", "compiled DAG")
+    elif kind == "pyamplicol-runtime-eager-execution":
+        try:
+            summary = execution["plan"]["inspection_summary"]
+        except (KeyError, TypeError) as error:
+            raise StructuralWorkError(
+                "eager execution lacks inspection summary"
+            ) from error
+        mode = "eager"
+        currents = _positive_integer(summary, "current_count", "eager plan")
+        # Attachments are the eager representation of DAG interaction fan-in.
+        interactions = _positive_integer(summary, "attachment_count", "eager plan")
+    else:
+        raise StructuralWorkError(f"unsupported candidate execution kind: {kind!r}")
+
+    return (
+        CandidateFinalWork(
+            mode=mode,
+            current_count=currents,
+            interaction_count=interactions,
+            current_ratio_to_legacy_replay=currents / legacy.replay_current_count,
+            interaction_ratio_to_legacy_replay=(
+                interactions / legacy.replay_interaction_count
+            ),
+        ),
+        construction,
+    )
+
+
+def _final_work_comparison(
+    legacy: LegacyReplayWork,
+    candidate: CandidateFinalWork,
+) -> FinalWorkComparison:
+    current_delta = candidate.current_count - legacy.replay_current_count
+    interaction_delta = candidate.interaction_count - legacy.replay_interaction_count
+    classification = (
+        "proven-recycling"
+        if current_delta <= 0 and interaction_delta <= 0
+        else "within-structural-tolerance"
+    )
+    return FinalWorkComparison(
+        current_delta_count=current_delta,
+        interaction_delta_count=interaction_delta,
+        current_savings_fraction=-current_delta / legacy.replay_current_count,
+        interaction_savings_fraction=(
+            -interaction_delta / legacy.replay_interaction_count
+        ),
+        classification=classification,
+    )
+
+
+def certify(
+    legacy_artifact: Path,
+    candidate_artifact: Path,
+    *,
+    max_final_to_legacy: float = MAX_UNPROVEN_FINAL_TO_LEGACY,
+    max_peak_current_to_legacy: float = 1.5,
+    max_peak_to_final_current: float = 4.0,
+    max_peak_to_final_contribution: float = 6.0,
+) -> StructuralWorkCertificate:
+    if (
+        not math.isfinite(max_final_to_legacy)
+        or max_final_to_legacy <= 0.0
+        or max_final_to_legacy > MAX_UNPROVEN_FINAL_TO_LEGACY
+    ):
+        raise StructuralWorkError(
+            "unreviewed final-work budget must be positive and no greater "
+            f"than {MAX_UNPROVEN_FINAL_TO_LEGACY:.2f}x legacy replay"
+        )
+    legacy = legacy_replay_work(legacy_artifact)
+    execution_path = _single_file(candidate_artifact, "execution.json")
+    execution = _read_json(execution_path)
+    external = execution.get("external_pdg_order")
+    if (
+        not isinstance(external, list)
+        or len(external) < 4
+        or any(pdg != 21 for pdg in external)
+        or execution.get("color_accuracy") != "full"
+    ):
+        raise StructuralWorkError(
+            "certificate currently requires a full-color pure-gluon process"
+        )
+    candidate, construction = candidate_final_work(execution, legacy)
+    limits = {
+        "max_final_to_legacy_replay": max_final_to_legacy,
+        "max_peak_current_to_legacy_replay": max_peak_current_to_legacy,
+        "max_peak_to_final_current": max_peak_to_final_current,
+        "max_peak_to_final_contribution": max_peak_to_final_contribution,
+    }
+    failures = []
+    if candidate.current_ratio_to_legacy_replay > max_final_to_legacy:
+        failures.append("final current work exceeds legacy replay")
+    if candidate.interaction_ratio_to_legacy_replay > max_final_to_legacy:
+        failures.append("final interaction work exceeds legacy replay")
+    if construction is not None:
+        if (
+            construction.peak_current_ratio_to_legacy_replay
+            > max_peak_current_to_legacy
+        ):
+            failures.append("peak construction currents exceed legacy replay budget")
+        if construction.peak_to_final_current_ratio > max_peak_to_final_current:
+            failures.append("peak/final construction current ratio exceeds budget")
+        if (
+            construction.peak_to_final_contribution_ratio
+            > max_peak_to_final_contribution
+        ):
+            failures.append("peak/final construction contribution ratio exceeds budget")
+    if failures:
+        raise StructuralWorkError("; ".join(failures))
+
+    process = execution.get("process")
+    if not isinstance(process, str) or not process:
+        process = execution_path.parent.name
+    return StructuralWorkCertificate(
+        schema="pyamplicol-structural-work-certificate-v1",
+        process=process,
+        external_pdg_order=tuple(external),
+        legacy=legacy,
+        candidate=candidate,
+        final_work_comparison=_final_work_comparison(legacy, candidate),
+        recurrence_construction=construction,
+        limits=limits,
+        status="ok",
+    )
+
+
+def adjacent_multiplicity_census(
+    lower: StructuralWorkCertificate,
+    higher: StructuralWorkCertificate,
+    *,
+    max_normalized_final_growth: float = MAX_ADJACENT_FINAL_GROWTH,
+    max_normalized_peak_growth: float = MAX_ADJACENT_PEAK_GROWTH,
+) -> AdjacentMultiplicityCensus:
+    lower_n_final = len(lower.external_pdg_order) - 2
+    higher_n_final = len(higher.external_pdg_order) - 2
+    if higher_n_final != lower_n_final + 1:
+        raise StructuralWorkError(
+            "structural-work census requires adjacent final-state multiplicities"
+        )
+    if lower.candidate.mode != higher.candidate.mode:
+        raise StructuralWorkError(
+            "structural-work census requires one candidate generation mode"
+        )
+    for value, label in [
+        (max_normalized_final_growth, "adjacent final-work growth"),
+        (max_normalized_peak_growth, "adjacent construction-peak growth"),
+    ]:
+        if not math.isfinite(value) or value <= 0.0:
+            raise StructuralWorkError(f"{label} limit must be positive and finite")
+
+    legacy_current_growth = (
+        higher.legacy.replay_current_count / lower.legacy.replay_current_count
+    )
+    candidate_current_growth = (
+        higher.candidate.current_count / lower.candidate.current_count
+    )
+    legacy_interaction_growth = (
+        higher.legacy.replay_interaction_count / lower.legacy.replay_interaction_count
+    )
+    candidate_interaction_growth = (
+        higher.candidate.interaction_count / lower.candidate.interaction_count
+    )
+    normalized_current_growth = candidate_current_growth / legacy_current_growth
+    normalized_interaction_growth = (
+        candidate_interaction_growth / legacy_interaction_growth
+    )
+    normalized_peak_current_growth = None
+    if (
+        lower.recurrence_construction is not None
+        and higher.recurrence_construction is not None
+    ):
+        peak_growth = (
+            higher.recurrence_construction.peak_current_count
+            / lower.recurrence_construction.peak_current_count
+        )
+        normalized_peak_current_growth = peak_growth / legacy_current_growth
+
+    failures = []
+    if normalized_current_growth > max_normalized_final_growth:
+        failures.append(
+            "adjacent final-current growth exceeds legacy-normalized budget"
+        )
+    if normalized_interaction_growth > max_normalized_final_growth:
+        failures.append(
+            "adjacent final-interaction growth exceeds legacy-normalized budget"
+        )
+    if (
+        normalized_peak_current_growth is not None
+        and normalized_peak_current_growth > max_normalized_peak_growth
+    ):
+        failures.append(
+            "adjacent construction-peak growth exceeds legacy-normalized budget"
+        )
+    if failures:
+        raise StructuralWorkError("; ".join(failures))
+
+    return AdjacentMultiplicityCensus(
+        schema="pyamplicol-adjacent-structural-work-census-v1",
+        mode=lower.candidate.mode,
+        lower_n_final=lower_n_final,
+        higher_n_final=higher_n_final,
+        legacy_current_growth=legacy_current_growth,
+        candidate_current_growth=candidate_current_growth,
+        normalized_current_growth=normalized_current_growth,
+        legacy_interaction_growth=legacy_interaction_growth,
+        candidate_interaction_growth=candidate_interaction_growth,
+        normalized_interaction_growth=normalized_interaction_growth,
+        normalized_peak_current_growth=normalized_peak_current_growth,
+        limits={
+            "max_normalized_final_growth": max_normalized_final_growth,
+            "max_normalized_peak_growth": max_normalized_peak_growth,
+        },
+        status="ok",
+    )
+
+
+def static_template_materialization_census(
+    certificate: StructuralWorkCertificate,
+    *,
+    max_materialization_to_legacy_static: float = (MAX_STATIC_TEMPLATE_MATERIALIZATION),
+) -> StaticTemplateMaterializationCensus:
+    """Compare artifact materialization with generated legacy templates.
+
+    Legacy dynamic replay is the correct runtime-work comparator, but it can
+    hide a severe cold-generation expansion.  This independent census treats
+    the generated module inventory as the static baseline and reports both the
+    final artifact and recurrence-construction peak.
+    """
+
+    limit = float(max_materialization_to_legacy_static)
+    if not math.isfinite(limit) or limit <= 0.0:
+        raise StructuralWorkError(
+            "static-template materialization limit must be positive and finite"
+        )
+    legacy = certificate.legacy
+    if (
+        legacy.generated_module_count <= 0
+        or legacy.retained_color_ordering_count % legacy.generated_module_count
+    ):
+        raise StructuralWorkError(
+            "legacy color replay count is not an integer multiple of its "
+            "generated module inventory"
+        )
+    static_currents = legacy.module_current_count * legacy.generated_module_count
+    static_interactions = (
+        legacy.module_interaction_count * legacy.generated_module_count
+    )
+    candidate = certificate.candidate
+    final_current_ratio = candidate.current_count / static_currents
+    final_interaction_ratio = candidate.interaction_count / static_interactions
+    construction = certificate.recurrence_construction
+    peak_currents = None if construction is None else construction.peak_current_count
+    peak_interactions = (
+        None if construction is None else construction.peak_contribution_count
+    )
+    peak_current_ratio = (
+        None if peak_currents is None else peak_currents / static_currents
+    )
+    peak_interaction_ratio = (
+        None if peak_interactions is None else peak_interactions / static_interactions
+    )
+    violations = []
+    if final_current_ratio > limit:
+        violations.append("final currents exceed legacy static-template budget")
+    if final_interaction_ratio > limit:
+        violations.append("final interactions exceed legacy static-template budget")
+    if peak_current_ratio is not None and peak_current_ratio > limit:
+        violations.append("peak currents exceed legacy static-template budget")
+    if peak_interaction_ratio is not None and peak_interaction_ratio > limit:
+        violations.append("peak interactions exceed legacy static-template budget")
+    return StaticTemplateMaterializationCensus(
+        schema="pyamplicol-static-template-materialization-census-v1",
+        mode=candidate.mode,
+        legacy_generated_module_count=legacy.generated_module_count,
+        legacy_static_current_count=static_currents,
+        legacy_static_interaction_count=static_interactions,
+        legacy_replay_multiplicity_per_module=(
+            legacy.retained_color_ordering_count // legacy.generated_module_count
+        ),
+        candidate_final_current_count=candidate.current_count,
+        candidate_final_interaction_count=candidate.interaction_count,
+        candidate_final_current_ratio=final_current_ratio,
+        candidate_final_interaction_ratio=final_interaction_ratio,
+        candidate_peak_current_count=peak_currents,
+        candidate_peak_interaction_count=peak_interactions,
+        candidate_peak_current_ratio=peak_current_ratio,
+        candidate_peak_interaction_ratio=peak_interaction_ratio,
+        limits={"max_materialization_to_legacy_static": limit},
+        violations=tuple(violations),
+        status="ok" if not violations else "exceeds-budget",
+    )
+
+
+def require_static_template_materialization_parity(
+    certificate: StructuralWorkCertificate,
+    *,
+    max_materialization_to_legacy_static: float = (MAX_STATIC_TEMPLATE_MATERIALIZATION),
+) -> StaticTemplateMaterializationCensus:
+    """Fail closed unless final and peak materialization have static parity."""
+
+    census = static_template_materialization_census(
+        certificate,
+        max_materialization_to_legacy_static=(max_materialization_to_legacy_static),
+    )
+    if census.violations:
+        raise StructuralWorkError("; ".join(census.violations))
+    return census
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("legacy_artifact", type=Path)
+    parser.add_argument("candidate_artifact", type=Path)
+    parser.add_argument(
+        "--max-final-to-legacy",
+        type=float,
+        default=MAX_UNPROVEN_FINAL_TO_LEGACY,
+    )
+    parser.add_argument("--max-peak-current-to-legacy", type=float, default=1.5)
+    parser.add_argument("--max-peak-to-final-current", type=float, default=4.0)
+    parser.add_argument("--max-peak-to-final-contribution", type=float, default=6.0)
+    parser.add_argument(
+        "--require-static-template-parity",
+        action="store_true",
+        help=(
+            "also reject final/peak materialization above 1.05x the generated "
+            "legacy template inventory"
+        ),
+    )
+    return parser
+
+
+def main() -> int:
+    arguments = _parser().parse_args()
+    certificate = certify(
+        arguments.legacy_artifact,
+        arguments.candidate_artifact,
+        max_final_to_legacy=arguments.max_final_to_legacy,
+        max_peak_current_to_legacy=arguments.max_peak_current_to_legacy,
+        max_peak_to_final_current=arguments.max_peak_to_final_current,
+        max_peak_to_final_contribution=(arguments.max_peak_to_final_contribution),
+    )
+    if arguments.require_static_template_parity:
+        require_static_template_materialization_parity(certificate)
+    print(json.dumps(asdict(certificate), indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/symjit_2_22_generated_fixture_gate.py b/pyamplicol/tools/developer/symjit_2_22_generated_fixture_gate.py
new file mode 100644
index 0000000000..f7a7a050f4
--- /dev/null
+++ b/pyamplicol/tools/developer/symjit_2_22_generated_fixture_gate.py
@@ -0,0 +1,1034 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run the fail-closed SymJIT 2.22 generated-artifact fixture gates."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shlex
+import subprocess
+import sys
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import contextmanager
+from dataclasses import dataclass, fields
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "build_backend"))
+
+import _pyamplicol_build as build_backend  # noqa: E402
+
+_DEFAULT_EXECUTION_ROOT = (
+    Path(".artifacts")
+    / "symjit-2.22-migration"
+    / "generated-fixture-gate"
+)
+_CANDIDATE_MANIFEST_PLACEHOLDER = "<authenticated-candidate-overlay>/Cargo.toml"
+_EXPECTED_PROCESS_EXPRESSION = "d d~ > z g g g g g g"
+_EXPECTED_PROCESS_ID = "d_dbar_to_z_g_g_g_g_g_g"
+_EXPECTED_EXTERNAL_PDGS = (1, -1, 23, 21, 21, 21, 21, 21, 21)
+_SOURCE_REVISION_PATTERN = re.compile(r"[0-9a-f]{40}")
+_NATIVE_BUILD_INPUTS_PATTERN = re.compile(r"[0-9a-f]{64}")
+_CANDIDATE_VERSION_PATTERN = re.compile(
+    r"[0-9]+\.[0-9]+\.[0-9]+\.dev0\+candidate\.[0-9a-f]{12}"
+)
+_ARTIFACT_IDENTITY_CONTRACT = {
+    "kind": "pyamplicol-runtime-payload-identity",
+    "schema_version": 1,
+}
+
+
+class GateError(RuntimeError):
+    """Raised when a fixture or focused gate fails closed."""
+
+
+@dataclass(frozen=True)
+class FixturePaths:
+    compiled_o3: Path
+    eager_o2: Path
+    recurrence_topology_o2: Path
+    recurrence_union_o2: Path
+    contracted_nlc: Path
+
+    def as_dict(self) -> dict[str, Path]:
+        return {field.name: getattr(self, field.name) for field in fields(self)}
+
+
+@dataclass(frozen=True)
+class ExecutionPaths:
+    cargo_home: Path
+    cargo_target_dir: Path
+    tmpdir: Path
+    pip_cache_dir: Path
+    xdg_cache_home: Path
+    python_cache_prefix: Path
+
+    def as_dict(self) -> dict[str, Path]:
+        return {field.name: getattr(self, field.name) for field in fields(self)}
+
+    def environment(self) -> dict[str, str]:
+        return {
+            "CARGO_HOME": str(self.cargo_home),
+            "CARGO_TARGET_DIR": str(self.cargo_target_dir),
+            "TMPDIR": str(self.tmpdir),
+            "PIP_CACHE_DIR": str(self.pip_cache_dir),
+            "XDG_CACHE_HOME": str(self.xdg_cache_home),
+            "PYTHONPYCACHEPREFIX": str(self.python_cache_prefix),
+            "PYAMPLICOL_REQUIRE_NATIVE_TESTS": "1",
+            "CARGO_TERM_COLOR": "never",
+        }
+
+    def create(self) -> None:
+        for path in self.as_dict().values():
+            path.mkdir(parents=True, exist_ok=True)
+
+
+@dataclass(frozen=True)
+class GateCommand:
+    label: str
+    arguments: tuple[str, ...]
+    expected_tests: tuple[str, ...]
+
+
+_ARTIFACT_ENVIRONMENT_ROUTES = (
+    ("RUSTICOL_COMPILED_DIRECT_ARTIFACT", "compiled_o3"),
+    ("RUSTICOL_COMPILED_ARTIFACT", "compiled_o3"),
+    ("RUSTICOL_TEST_COMPILED_REPLAY_QUICK_ARTIFACT", "compiled_o3"),
+    ("RUSTICOL_SELECTOR_ARTIFACT", "compiled_o3"),
+    ("RUSTICOL_EAGER_ARTIFACT", "eager_o2"),
+    ("RUSTICOL_RECURRENCE_ARTIFACT", "recurrence_topology_o2"),
+    (
+        "RUSTICOL_RECURRENCE_TOPOLOGY_ALLOCATION_ARTIFACT",
+        "recurrence_topology_o2",
+    ),
+    ("RUSTICOL_RECURRENCE_UNION_ALLOCATION_ARTIFACT", "recurrence_union_o2"),
+    (
+        "RUSTICOL_RECURRENCE_CONTRACTED_ALLOCATION_ARTIFACT",
+        "contracted_nlc",
+    ),
+    ("RUSTICOL_CONTRACTED_SELECTOR_ARTIFACT", "contracted_nlc"),
+)
+
+_COMPILED_FULL_TEST = (
+    "engine::compiled_direct_prototype::tests::"
+    "retained_compiled_o3_artifact_native_runtime_direct_matches_legacy_contract"
+)
+_COMPILED_QUICK_TEST = (
+    "engine::compiled_direct_prototype::tests::"
+    "retained_compiled_replay_totals_quick_contract"
+)
+_EAGER_ALLOCATION_TEST = (
+    "engine::eager_integration_tests::"
+    "generated_eager_native_into_is_warmed_allocation_free_when_fixture_is_supplied"
+)
+_RECURRENCE_SMOKE_TEST = (
+    "engine::recurrence_integration_tests::"
+    "generated_recurrence_artifact_loads_when_fixture_is_supplied"
+)
+_RECURRENCE_BOUNDARY_TEST = (
+    "engine::recurrence_integration_tests::"
+    "generated_recurrence_odd_tails_report_zero_direct_boundary_traffic_when_fixtures_are_supplied"
+)
+_RECURRENCE_ALLOCATION_TESTS = (
+    "genuine_topology_replay_artifact_warmed_loop_allocates_zero_heap_bytes",
+    "genuine_all_flow_union_artifact_warmed_loop_allocates_zero_heap_bytes",
+    "genuine_contracted_color_artifact_warmed_loop_allocates_zero_heap_bytes",
+    "genuine_contracted_color_prepared_selector_allocates_zero_heap_bytes",
+)
+_ODD_TAIL_TESTS = (
+    "genuine_compiled_o3_odd_tails_preserve_numerics_allocations_and_boundary_traffic",
+    "genuine_eager_o2_odd_tails_preserve_numerics_allocations_and_boundary_traffic",
+    "genuine_topology_recurrence_o2_odd_tails_preserve_numerics_and_allocations",
+    "genuine_all_flow_union_recurrence_o2_odd_tails_preserve_numerics_and_allocations",
+)
+_CAPI_ARTIFACT_TESTS = (
+    "generated_compiled_artifact_reports_compiled_execution_mode",
+    "generated_eager_artifact_loads_and_evaluates_through_the_c_abi",
+)
+_CAPI_SELECTOR_TESTS = (
+    "direct_total_outputs_preserve_bits_canaries_and_capacity_errors",
+    "homogeneous_and_alternating_per_point_selectors_match_resolved_components",
+    "malformed_selector_buffers_fail_without_touching_output",
+    "contracted_color_rejects_global_and_per_point_flow_selectors",
+)
+
+
+def _workspace_artifact(
+    raw_path: str | Path,
+    *,
+    label: str,
+    workspace_root: Path,
+    source_revision: str,
+    native_build_inputs_sha256: str,
+) -> Path:
+    root = workspace_root.resolve()
+    candidate = Path(raw_path)
+    if not candidate.is_absolute():
+        candidate = root / candidate
+    try:
+        resolved = candidate.resolve(strict=True)
+    except OSError as error:
+        raise GateError(f"{label} artifact does not exist: {candidate}") from error
+    try:
+        resolved.relative_to(root)
+    except ValueError as error:
+        raise GateError(
+            f"{label} artifact must be workspace-local: {resolved}"
+        ) from error
+    if not resolved.is_dir():
+        raise GateError(f"{label} artifact is not a directory: {resolved}")
+
+    manifest = resolved / "artifact.json"
+    if not manifest.is_file():
+        raise GateError(f"{label} artifact is missing artifact.json: {resolved}")
+    try:
+        manifest = manifest.resolve(strict=True)
+    except OSError as error:
+        raise GateError(
+            f"{label} artifact.json could not be resolved: {manifest}"
+        ) from error
+    try:
+        manifest.relative_to(root)
+    except ValueError as error:
+        raise GateError(
+            f"{label} artifact.json must be workspace-local: {manifest}"
+        ) from error
+    try:
+        payload = json.loads(manifest.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise GateError(
+            f"{label} artifact.json is not valid JSON: {manifest}"
+        ) from error
+    if not isinstance(payload, dict):
+        raise GateError(f"{label} artifact.json must contain a JSON object: {manifest}")
+    _validate_fixture_identity(
+        payload,
+        label=label,
+        manifest=manifest,
+        source_revision=source_revision,
+        native_build_inputs_sha256=native_build_inputs_sha256,
+    )
+    return resolved
+
+
+def _validated_identity_digest(
+    value: str,
+    *,
+    label: str,
+    length: int,
+    pattern: re.Pattern[str],
+) -> str:
+    if pattern.fullmatch(value) is None:
+        raise GateError(f"{label} must be a lowercase {length}-digit hex value")
+    return value
+
+
+def _validate_fixture_identity(
+    payload: Mapping[str, object],
+    *,
+    label: str,
+    manifest: Path,
+    source_revision: str,
+    native_build_inputs_sha256: str,
+) -> None:
+    extensions = payload.get("extensions")
+    if (
+        not isinstance(extensions, dict)
+        or extensions.get("artifact_identity") != _ARTIFACT_IDENTITY_CONTRACT
+    ):
+        raise GateError(
+            f"{label} lacks the current artifact identity contract; "
+            f"regenerate it: {manifest}"
+        )
+    producer = payload.get("producer")
+    if not isinstance(producer, dict):
+        raise GateError(f"{label} producer must be a JSON object: {manifest}")
+    expected_producer = {
+        "distribution": "pyamplicol",
+        "git_revision": source_revision,
+        "native_build_inputs_sha256": native_build_inputs_sha256,
+    }
+    for key, expected in expected_producer.items():
+        observed = producer.get(key)
+        if observed != expected:
+            raise GateError(
+                f"{label} producer {key} does not match the authenticated "
+                f"candidate (expected {expected!r}, got {observed!r}): {manifest}"
+            )
+    version = producer.get("version")
+    if (
+        not isinstance(version, str)
+        or _CANDIDATE_VERSION_PATTERN.fullmatch(version) is None
+    ):
+        raise GateError(
+            f"{label} producer version is not a candidate build "
+            f"(got {version!r}): {manifest}"
+        )
+
+    processes = payload.get("processes")
+    if (
+        not isinstance(processes, list)
+        or len(processes) != 1
+        or not isinstance(processes[0], dict)
+    ):
+        raise GateError(
+            f"{label} must contain exactly one object-valued process: {manifest}"
+        )
+    process = processes[0]
+    expected_process = {
+        "id": _EXPECTED_PROCESS_ID,
+        "expression": _EXPECTED_PROCESS_EXPRESSION,
+        "external_pdgs": list(_EXPECTED_EXTERNAL_PDGS),
+    }
+    for key, expected in expected_process.items():
+        observed = process.get(key)
+        if observed != expected:
+            raise GateError(
+                f"{label} process {key} does not identify the exact Z+6g "
+                f"fixture (expected {expected!r}, got {observed!r}): {manifest}"
+            )
+    default_process_id = payload.get("default_process_id")
+    if default_process_id != _EXPECTED_PROCESS_ID:
+        raise GateError(
+            f"{label} default_process_id does not identify the exact Z+6g "
+            f"fixture (expected {_EXPECTED_PROCESS_ID!r}, "
+            f"got {default_process_id!r}): {manifest}"
+        )
+
+
+def preflight_fixtures(
+    raw_paths: Mapping[str, str | Path],
+    *,
+    workspace_root: Path,
+    source_revision: str,
+    native_build_inputs_sha256: str,
+) -> FixturePaths:
+    source_revision = _validated_identity_digest(
+        source_revision,
+        label="source revision",
+        length=40,
+        pattern=_SOURCE_REVISION_PATTERN,
+    )
+    native_build_inputs_sha256 = _validated_identity_digest(
+        native_build_inputs_sha256,
+        label="native build inputs SHA-256",
+        length=64,
+        pattern=_NATIVE_BUILD_INPUTS_PATTERN,
+    )
+    expected_names = {field.name for field in fields(FixturePaths)}
+    if set(raw_paths) != expected_names:
+        missing = sorted(expected_names.difference(raw_paths))
+        unexpected = sorted(set(raw_paths).difference(expected_names))
+        raise GateError(
+            "fixture arguments do not match the required roles "
+            f"(missing={missing}, unexpected={unexpected})"
+        )
+    resolved = {
+        name: _workspace_artifact(
+            raw_paths[name],
+            label=name.replace("_", " "),
+            workspace_root=workspace_root,
+            source_revision=source_revision,
+            native_build_inputs_sha256=native_build_inputs_sha256,
+        )
+        for name in sorted(expected_names)
+    }
+    if len(set(resolved.values())) != len(resolved):
+        raise GateError(
+            "the five fixture roles must name distinct artifact directories"
+        )
+    fixtures = FixturePaths(**resolved)
+    _common_fixture_candidate_version(fixtures)
+    return fixtures
+
+
+def _workspace_execution_path(
+    raw_path: str | Path,
+    *,
+    label: str,
+    workspace_root: Path,
+) -> Path:
+    root = workspace_root.resolve()
+    candidate = Path(raw_path)
+    if not candidate.is_absolute():
+        candidate = root / candidate
+    try:
+        resolved = candidate.resolve(strict=False)
+    except OSError as error:
+        raise GateError(f"could not resolve {label}: {candidate}") from error
+    try:
+        relative = resolved.relative_to(root)
+    except ValueError as error:
+        raise GateError(f"{label} must be workspace-local: {resolved}") from error
+    if not relative.parts:
+        raise GateError(f"{label} must be below the workspace root: {resolved}")
+    if resolved.exists() and not resolved.is_dir():
+        raise GateError(f"{label} exists but is not a directory: {resolved}")
+    return resolved
+
+
+def preflight_execution_paths(
+    raw_paths: Mapping[str, str | Path],
+    *,
+    workspace_root: Path,
+) -> ExecutionPaths:
+    expected_names = {field.name for field in fields(ExecutionPaths)}
+    if set(raw_paths) != expected_names:
+        missing = sorted(expected_names.difference(raw_paths))
+        unexpected = sorted(set(raw_paths).difference(expected_names))
+        raise GateError(
+            "execution path arguments do not match the required roles "
+            f"(missing={missing}, unexpected={unexpected})"
+        )
+    resolved = {
+        name: _workspace_execution_path(
+            raw_paths[name],
+            label=name.replace("_", " "),
+            workspace_root=workspace_root,
+        )
+        for name in sorted(expected_names)
+    }
+    if len(set(resolved.values())) != len(resolved):
+        raise GateError("cache and temporary directories must be distinct")
+    return ExecutionPaths(**resolved)
+
+
+def artifact_environment(fixtures: FixturePaths) -> dict[str, str]:
+    paths = fixtures.as_dict()
+    return {
+        environment_name: str(paths[fixture_name])
+        for environment_name, fixture_name in _ARTIFACT_ENVIRONMENT_ROUTES
+    }
+
+
+def _common_fixture_candidate_version(fixtures: FixturePaths) -> str:
+    versions: dict[str, str] = {}
+    for label, artifact in fixtures.as_dict().items():
+        manifest = artifact / "artifact.json"
+        try:
+            payload = json.loads(manifest.read_text(encoding="utf-8"))
+            producer = payload["producer"]
+            version = producer["version"]
+        except (
+            KeyError,
+            OSError,
+            TypeError,
+            UnicodeError,
+            json.JSONDecodeError,
+        ) as error:
+            raise GateError(
+                f"{label.replace('_', ' ')} candidate version could not be "
+                f"re-authenticated: {manifest}"
+            ) from error
+        if (
+            not isinstance(version, str)
+            or _CANDIDATE_VERSION_PATTERN.fullmatch(version) is None
+        ):
+            raise GateError(
+                f"{label.replace('_', ' ')} producer version is not a "
+                f"candidate build (got {version!r}): {manifest}"
+            )
+        versions[label] = version
+    unique = set(versions.values())
+    if len(unique) != 1:
+        raise GateError(
+            "the five authenticated fixtures were not generated by one "
+            f"candidate build: {versions}"
+        )
+    return unique.pop()
+
+
+def _authenticate_candidate_overlay_build_info(
+    overlay: Path,
+    *,
+    source_revision: str,
+    native_build_inputs_sha256: str,
+    candidate_version: str,
+) -> None:
+    build_info_path = overlay / "src" / "pyamplicol" / "_build_info.json"
+    if build_info_path.is_symlink():
+        raise GateError(
+            "authenticated candidate overlay build info must not be a symlink: "
+            f"{build_info_path}"
+        )
+    try:
+        resolved_build_info = build_info_path.resolve(strict=True)
+        resolved_build_info.relative_to(overlay)
+    except (OSError, ValueError) as error:
+        raise GateError(
+            "authenticated candidate overlay build info is missing or escaped "
+            f"the overlay: {build_info_path}"
+        ) from error
+    if not resolved_build_info.is_file():
+        raise GateError(
+            "authenticated candidate overlay build info is not a regular file: "
+            f"{resolved_build_info}"
+        )
+    try:
+        payload = json.loads(resolved_build_info.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise GateError(
+            "authenticated candidate overlay build info is not valid JSON: "
+            f"{resolved_build_info}"
+        ) from error
+    if not isinstance(payload, dict):
+        raise GateError(
+            "authenticated candidate overlay build info must be a JSON object: "
+            f"{resolved_build_info}"
+        )
+
+    schema_version = payload.get("schema_version")
+    if (
+        not isinstance(schema_version, int)
+        or isinstance(schema_version, bool)
+        or schema_version != 1
+    ):
+        raise GateError(
+            "authenticated candidate overlay build identity does not match "
+            "the generated fixtures: schema_version must be integer 1"
+        )
+    if payload.get("publishable") is not False:
+        raise GateError(
+            "authenticated candidate overlay build identity does not match "
+            "the generated fixtures: publishable must be false"
+        )
+    if payload.get("selftest_fixture_bootstrap") is not False:
+        raise GateError(
+            "authenticated candidate overlay build identity does not match "
+            "the generated fixtures: selftest_fixture_bootstrap must be false"
+        )
+    expected = {
+        "source_revision": source_revision,
+        "native_build_inputs_sha256": native_build_inputs_sha256,
+        "version": candidate_version,
+    }
+    for key, value in expected.items():
+        if payload.get(key) != value:
+            raise GateError(
+                "authenticated candidate overlay build identity does not match "
+                f"the generated fixtures: {key} expected {value!r}, got "
+                f"{payload.get(key)!r}"
+            )
+    fingerprint = payload.get("candidate_fingerprint")
+    if (
+        not isinstance(fingerprint, str)
+        or re.fullmatch(r"[0-9a-f]{12}", fingerprint) is None
+        or not candidate_version.endswith(f"+candidate.{fingerprint}")
+    ):
+        raise GateError(
+            "authenticated candidate overlay fingerprint does not match its "
+            f"candidate version: {resolved_build_info}"
+        )
+    if "release_prepared_model_bootstrap" in payload:
+        raise GateError(
+            "authenticated candidate overlay unexpectedly enables release "
+            f"prepared-model bootstrap: {resolved_build_info}"
+        )
+
+
+@contextmanager
+def authenticated_candidate_overlay(
+    execution_paths: ExecutionPaths,
+    *,
+    source_revision: str,
+    native_build_inputs_sha256: str,
+    candidate_version: str,
+) -> Iterator[Path]:
+    """Stage one authenticated candidate graph shared by every Cargo command."""
+
+    source_revision = _validated_identity_digest(
+        source_revision,
+        label="source revision",
+        length=40,
+        pattern=_SOURCE_REVISION_PATTERN,
+    )
+    native_build_inputs_sha256 = _validated_identity_digest(
+        native_build_inputs_sha256,
+        label="native build inputs SHA-256",
+        length=64,
+        pattern=_NATIVE_BUILD_INPUTS_PATTERN,
+    )
+    if _CANDIDATE_VERSION_PATTERN.fullmatch(candidate_version) is None:
+        raise GateError(
+            "candidate version must identify an authenticated candidate build"
+        )
+    try:
+        execution_paths.create()
+        build_backend._check_dependencies("candidate")
+        with build_backend._overlay(
+            "candidate",
+            temporary_directory=execution_paths.tmpdir,
+            cargo_target_directory=execution_paths.cargo_target_dir,
+        ) as (overlay, cargo_target):
+            resolved_overlay = overlay.resolve(strict=True)
+            resolved_tmpdir = execution_paths.tmpdir.resolve(strict=True)
+            resolved_target = cargo_target.resolve(strict=False)
+            try:
+                resolved_overlay.relative_to(resolved_tmpdir)
+            except ValueError as error:
+                raise GateError(
+                    "authenticated candidate overlay escaped the workspace-local "
+                    f"temporary root: {resolved_overlay}"
+                ) from error
+            if resolved_target != execution_paths.cargo_target_dir:
+                raise GateError(
+                    "authenticated candidate overlay selected the wrong Cargo "
+                    f"target directory: {resolved_target}"
+                )
+            for required in (
+                resolved_overlay / "Cargo.lock",
+                resolved_overlay / ".cargo" / "config.toml",
+            ):
+                if not required.is_file():
+                    raise GateError(
+                        "authenticated candidate overlay is incomplete: "
+                        f"{required}"
+                    )
+            _authenticate_candidate_overlay_build_info(
+                resolved_overlay,
+                source_revision=source_revision,
+                native_build_inputs_sha256=native_build_inputs_sha256,
+                candidate_version=candidate_version,
+            )
+            yield resolved_overlay
+    except GateError:
+        raise
+    except (OSError, RuntimeError, subprocess.CalledProcessError) as error:
+        raise GateError(
+            f"could not stage the authenticated candidate Cargo overlay: {error}"
+        ) from error
+
+
+def _core_lib_command(
+    cargo: str,
+    manifest: Path,
+    label: str,
+    test_name: str,
+) -> GateCommand:
+    return GateCommand(
+        label=label,
+        arguments=(
+            cargo,
+            "test",
+            "--locked",
+            "--manifest-path",
+            str(manifest),
+            "-p",
+            "rusticol-core",
+            "--lib",
+            test_name,
+            "--",
+            "--exact",
+            "--show-output",
+            "--test-threads=1",
+        ),
+        expected_tests=(test_name,),
+    )
+
+
+def gate_commands(
+    *,
+    cargo: str,
+    workspace_root: Path,
+) -> tuple[GateCommand, ...]:
+    manifest = workspace_root.resolve() / "Cargo.toml"
+    if not manifest.is_file():
+        raise GateError(f"workspace Cargo.toml is missing: {manifest}")
+
+    commands = [
+        _core_lib_command(
+            cargo,
+            manifest,
+            "compiled O3 full allocation and selector contract",
+            _COMPILED_FULL_TEST,
+        ),
+        _core_lib_command(
+            cargo,
+            manifest,
+            "compiled O3 quick replay allocation contract",
+            _COMPILED_QUICK_TEST,
+        ),
+        _core_lib_command(
+            cargo,
+            manifest,
+            "eager O2 allocation and selector contract",
+            _EAGER_ALLOCATION_TEST,
+        ),
+        GateCommand(
+            label="recurrence topology/union O2 generated-artifact contracts",
+            arguments=(
+                cargo,
+                "test",
+                "--locked",
+                "--manifest-path",
+                str(manifest),
+                "-p",
+                "rusticol-core",
+                "--lib",
+                "engine::recurrence_integration_tests::",
+                "--",
+                "--show-output",
+                "--test-threads=1",
+            ),
+            expected_tests=(
+                _RECURRENCE_SMOKE_TEST,
+                _RECURRENCE_BOUNDARY_TEST,
+            ),
+        ),
+        GateCommand(
+            label="recurrence generated-artifact allocation contracts",
+            arguments=(
+                cargo,
+                "test",
+                "--locked",
+                "--manifest-path",
+                str(manifest),
+                "-p",
+                "rusticol-core",
+                "--test",
+                "recurrence_direct_arena_allocations",
+                "--",
+                "--show-output",
+                "--test-threads=1",
+            ),
+            expected_tests=_RECURRENCE_ALLOCATION_TESTS,
+        ),
+        GateCommand(
+            label="compiled, eager, and recurrence genuine-artifact odd-tail contracts",
+            arguments=(
+                cargo,
+                "test",
+                "--locked",
+                "--manifest-path",
+                str(manifest),
+                "-p",
+                "rusticol-core",
+                "--test",
+                "generated_artifact_odd_tails",
+                "--",
+                "--show-output",
+                "--test-threads=1",
+            ),
+            expected_tests=_ODD_TAIL_TESTS,
+        ),
+        GateCommand(
+            label="compiled and eager C ABI generated-artifact contracts",
+            arguments=(
+                cargo,
+                "test",
+                "--locked",
+                "--manifest-path",
+                str(manifest),
+                "-p",
+                "rusticol-capi",
+                "--test",
+                "eager_artifact",
+                "--",
+                "--show-output",
+                "--test-threads=1",
+            ),
+            expected_tests=_CAPI_ARTIFACT_TESTS,
+        ),
+        GateCommand(
+            label="compiled and contracted C ABI selector contracts",
+            arguments=(
+                cargo,
+                "test",
+                "--locked",
+                "--manifest-path",
+                str(manifest),
+                "-p",
+                "rusticol-capi",
+                "--test",
+                "runtime_selectors",
+                "--",
+                "--show-output",
+                "--test-threads=1",
+            ),
+            expected_tests=_CAPI_SELECTOR_TESTS,
+        ),
+    ]
+    return tuple(commands)
+
+
+def verify_test_markers(command: GateCommand, output: str) -> None:
+    missing = [
+        test_name
+        for test_name in command.expected_tests
+        if re.search(
+            rf"(?m)^test {re.escape(test_name)} \.\.\. ok(?:[ \t].*)?\r?$",
+            output,
+        )
+        is None
+    ]
+    if missing:
+        raise GateError(
+            f"{command.label} did not run every required test; "
+            f"missing successful markers: {missing}"
+        )
+
+
+def run_commands(
+    commands: Sequence[GateCommand],
+    *,
+    environment: Mapping[str, str],
+    execution_paths: ExecutionPaths,
+    workspace_root: Path,
+) -> None:
+    required_environment = {
+        environment_name
+        for environment_name, _fixture_name in _ARTIFACT_ENVIRONMENT_ROUTES
+    }
+    if set(environment) != required_environment:
+        missing = sorted(required_environment.difference(environment))
+        unexpected = sorted(set(environment).difference(required_environment))
+        raise GateError(
+            "generated-fixture environment is incomplete "
+            f"(missing={missing}, unexpected={unexpected})"
+        )
+    try:
+        execution_paths.create()
+    except OSError as error:
+        raise GateError(
+            f"could not create workspace-local execution directories: {error}"
+        ) from error
+    updates = {
+        **environment,
+        **execution_paths.environment(),
+        **build_backend._macos_native_build_updates(),
+    }
+    inherited = {
+        name: value
+        for name, value in build_backend._clean_environment(updates).items()
+        if not (name.startswith("RUSTICOL_") and name.endswith("_ARTIFACT"))
+    }
+    inherited.update(environment)
+
+    print("[generated-fixture-gate] artifact mappings", flush=True)
+    for name in sorted(environment):
+        print(f"{name}={shlex.quote(environment[name])}", flush=True)
+    print("[generated-fixture-gate] execution environment", flush=True)
+    for name, value in sorted(execution_paths.environment().items()):
+        print(f"{name}={shlex.quote(value)}", flush=True)
+
+    for command in commands:
+        print(f"[generated-fixture-gate] {command.label}", flush=True)
+        print(f"$ {shlex.join(command.arguments)}", flush=True)
+        try:
+            completed = subprocess.run(
+                command.arguments,
+                cwd=workspace_root,
+                env=inherited,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                check=False,
+            )
+        except OSError as error:
+            raise GateError(f"could not launch {command.label}: {error}") from error
+        sys.stdout.write(completed.stdout)
+        sys.stdout.flush()
+        if completed.returncode != 0:
+            raise GateError(
+                f"{command.label} failed with exit status {completed.returncode}"
+            )
+        verify_test_markers(command, completed.stdout)
+
+
+def plan_payload(
+    fixtures: FixturePaths,
+    commands: Sequence[GateCommand],
+    *,
+    execution_paths: ExecutionPaths,
+    workspace_root: Path,
+    source_revision: str,
+    native_build_inputs_sha256: str,
+) -> dict[str, object]:
+    environment = artifact_environment(fixtures)
+    environment.update(execution_paths.environment())
+    source_manifest = str(workspace_root.resolve() / "Cargo.toml")
+    return {
+        "schema_version": 1,
+        "workspace_root": str(workspace_root.resolve()),
+        "cargo_input": {
+            "mode": "authenticated-candidate-overlay",
+            "manifest": _CANDIDATE_MANIFEST_PLACEHOLDER,
+            "shared_target": str(execution_paths.cargo_target_dir),
+        },
+        "fixture_identity": {
+            "producer": {
+                "distribution": "pyamplicol",
+                "git_revision": source_revision,
+                "native_build_inputs_sha256": native_build_inputs_sha256,
+                "version_pattern": _CANDIDATE_VERSION_PATTERN.pattern,
+            },
+            "process": {
+                "id": _EXPECTED_PROCESS_ID,
+                "expression": _EXPECTED_PROCESS_EXPRESSION,
+                "external_pdgs": list(_EXPECTED_EXTERNAL_PDGS),
+            },
+        },
+        "artifacts": {
+            name: str(path) for name, path in fixtures.as_dict().items()
+        },
+        "execution_paths": {
+            name: str(path)
+            for name, path in execution_paths.as_dict().items()
+        },
+        "environment": environment,
+        "commands": [
+            {
+                "label": command.label,
+                "arguments": [
+                    (
+                        _CANDIDATE_MANIFEST_PLACEHOLDER
+                        if argument == source_manifest
+                        else argument
+                    )
+                    for argument in command.arguments
+                ],
+                "expected_tests": list(command.expected_tests),
+            }
+            for command in commands
+        ],
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--compiled-o3-artifact", required=True)
+    parser.add_argument("--eager-o2-artifact", required=True)
+    parser.add_argument("--recurrence-topology-o2-artifact", required=True)
+    parser.add_argument("--recurrence-union-o2-artifact", required=True)
+    parser.add_argument("--contracted-nlc-artifact", required=True)
+    parser.add_argument(
+        "--source-revision",
+        required=True,
+        help="authenticated candidate source revision (40 lowercase hex digits)",
+    )
+    parser.add_argument(
+        "--native-build-inputs-sha256",
+        required=True,
+        help="authenticated candidate native-build-input digest",
+    )
+    parser.add_argument(
+        "--cargo-home",
+        default=str(_DEFAULT_EXECUTION_ROOT / "cargo-home"),
+        help="workspace-local Cargo home",
+    )
+    parser.add_argument(
+        "--cargo-target-dir",
+        default=str(_DEFAULT_EXECUTION_ROOT / "cargo-target"),
+        help="workspace-local Cargo target directory",
+    )
+    parser.add_argument(
+        "--tmpdir",
+        default=str(_DEFAULT_EXECUTION_ROOT / "tmp"),
+        help="workspace-local temporary directory",
+    )
+    parser.add_argument(
+        "--pip-cache-dir",
+        default=str(_DEFAULT_EXECUTION_ROOT / "pip-cache"),
+        help="workspace-local pip cache",
+    )
+    parser.add_argument(
+        "--xdg-cache-home",
+        default=str(_DEFAULT_EXECUTION_ROOT / "xdg-cache"),
+        help="workspace-local XDG cache",
+    )
+    parser.add_argument(
+        "--python-cache-prefix",
+        default=str(_DEFAULT_EXECUTION_ROOT / "python-cache"),
+        help="workspace-local Python bytecode cache",
+    )
+    parser.add_argument(
+        "--cargo",
+        default="cargo",
+        help="Cargo executable to invoke from PATH or by explicit path",
+    )
+    parser.add_argument(
+        "--plan",
+        action="store_true",
+        help="preflight fixtures and print the exact JSON plan without running Cargo",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _parser()
+    arguments = parser.parse_args(argv)
+    raw_paths = {
+        "compiled_o3": arguments.compiled_o3_artifact,
+        "eager_o2": arguments.eager_o2_artifact,
+        "recurrence_topology_o2": arguments.recurrence_topology_o2_artifact,
+        "recurrence_union_o2": arguments.recurrence_union_o2_artifact,
+        "contracted_nlc": arguments.contracted_nlc_artifact,
+    }
+    raw_execution_paths = {
+        "cargo_home": arguments.cargo_home,
+        "cargo_target_dir": arguments.cargo_target_dir,
+        "tmpdir": arguments.tmpdir,
+        "pip_cache_dir": arguments.pip_cache_dir,
+        "xdg_cache_home": arguments.xdg_cache_home,
+        "python_cache_prefix": arguments.python_cache_prefix,
+    }
+    try:
+        fixtures = preflight_fixtures(
+            raw_paths,
+            workspace_root=ROOT,
+            source_revision=arguments.source_revision,
+            native_build_inputs_sha256=arguments.native_build_inputs_sha256,
+        )
+        execution_paths = preflight_execution_paths(
+            raw_execution_paths,
+            workspace_root=ROOT,
+        )
+        candidate_version = _common_fixture_candidate_version(fixtures)
+        if arguments.plan:
+            commands = gate_commands(cargo=arguments.cargo, workspace_root=ROOT)
+            print(
+                json.dumps(
+                    plan_payload(
+                        fixtures,
+                        commands,
+                        execution_paths=execution_paths,
+                        workspace_root=ROOT,
+                        source_revision=arguments.source_revision,
+                        native_build_inputs_sha256=(
+                            arguments.native_build_inputs_sha256
+                        ),
+                    ),
+                    indent=2,
+                    sort_keys=True,
+                )
+            )
+            return 0
+        with authenticated_candidate_overlay(
+            execution_paths,
+            source_revision=arguments.source_revision,
+            native_build_inputs_sha256=arguments.native_build_inputs_sha256,
+            candidate_version=candidate_version,
+        ) as overlay:
+            commands = gate_commands(
+                cargo=arguments.cargo,
+                workspace_root=overlay,
+            )
+            run_commands(
+                commands,
+                environment=artifact_environment(fixtures),
+                execution_paths=execution_paths,
+                workspace_root=overlay,
+            )
+    except GateError as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/symjit_2_22_migration_benchmark_gate.py b/pyamplicol/tools/developer/symjit_2_22_migration_benchmark_gate.py
new file mode 100644
index 0000000000..afb77a815a
--- /dev/null
+++ b/pyamplicol/tools/developer/symjit_2_22_migration_benchmark_gate.py
@@ -0,0 +1,4140 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Compare authenticated SymJIT 2.22 migration benchmark captures.
+
+The recurrence z+6g harness deliberately records raw, independently warmed
+subprocess measurements.  This gate consumes one topology-replay and one
+all-flow-union capture for both the immutable pre-migration baseline and the
+candidate.  It validates their workload identities, recomputes every statistic
+used for acceptance from the retained raw samples, authenticates the outer
+30-GiB watchdog report against the paired command/session/result, and emits one
+content-addressed comparison record. The exact candidate revision, both native
+build-input digests, and both prepared-model digests are independent required
+inputs rather than identities inferred from the captures being judged.
+
+This is a focused migration gate. It reports compiled/recurrence and eager
+inventories separately, but applies the same regression acceptance rules to
+all three required lanes.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import hashlib
+import json
+import math
+import os
+import statistics
+import sys
+import tempfile
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+CAPTURE_KIND = "pyamplicol-recurrence-z6g-benchmark"
+MINIMUM_CAPTURE_SCHEMA = 7
+COMPARISON_KIND = "pyamplicol-symjit-2.22-migration-benchmark-comparison"
+COMPARISON_SCHEMA = 2
+BASELINE_REVISION = "172e58fd33a3c65563866c50cfbb5e1ddcd7b302"
+
+LAYOUTS = ("topology-replay", "all-flow-union")
+AUTHORITATIVE_MODES = ("compiled", "recurrence")
+DIAGNOSTIC_MODES = ("eager",)
+MODES = AUTHORITATIVE_MODES
+CAPTURE_MODES = AUTHORITATIVE_MODES
+BATCH_SIZES = (1, 128, 1024)
+RATIO_BATCH_SIZES = (128, 1024)
+MINIMUM_SUBPROCESS_SAMPLES = 7
+MINIMUM_INTERNAL_SAMPLES = 7
+MINIMUM_WARMUPS = 2
+MINIMUM_TARGET_RUNTIME_SECONDS = 5.0
+
+RUNTIME_RELATIVE_LIMIT = 1.03
+RUNTIME_NOISE_MAD_MULTIPLIER = 3.0
+COMPILED_RECURRENCE_RATIO_LIMIT = 1.15
+GENERATION_CELL_LIMIT = 1.10
+GENERATION_GEOMEAN_LIMIT = 1.05
+RESOURCE_GROWTH_LIMIT = 1.03
+RESOURCE_EXCEPTION_GAIN = 0.10
+
+STRICT_SEMANTIC_COMPARISON_POLICY = "strict-exact-v1"
+SELECTED_UNION_SEMANTIC_COMPARISON_POLICY = (
+    "ddbar-z6g-all-flow-union-selected-helicity-v1"
+)
+SELECTED_UNION_PROCESS = "d d~ > Z g g g g g g"
+SELECTED_UNION_HELICITY_ID = "h:-1,+1,-1,+1,-1,+1,-1,+1,-1"
+SELECTED_UNION_HELICITY_VALUES = (-1, 1, -1, 1, -1, 1, -1, 1, -1)
+SELECTED_UNION_HELICITY_INDEX = 234
+SELECTED_UNION_COLOR_COUNT = 720
+PAIRED_CAMPAIGN_KIND = "pyamplicol-symjit-2.22-paired-benchmark-campaign"
+PAIRED_CAMPAIGN_SCHEMA = 2
+PAIRED_HARNESS_KIND = "pyamplicol-paired-benchmark-harness-identity"
+PAIRED_HARNESS_SCHEMA = 1
+PAIRED_HARNESS_RELATIVE_PATH = "tools/developer/recurrence_z6g_benchmark.py"
+PAIRED_DRIVER_RELATIVE_PATH = "tools/developer/symjit_2_22_paired_benchmark.py"
+RAW_NATIVE_WALL_BLOCK_KIND = "pyamplicol-raw-native-wall-blocks"
+RAW_NATIVE_WALL_BLOCK_SCHEMA = 2
+RAW_NATIVE_WALL_MEASUREMENT_CONTRACT = (
+    "warmed-native-wall-minimum-duration-v1"
+)
+WATCHDOG_REPORT_KIND = "pyamplicol-memory-watchdog-execution-report"
+WATCHDOG_REPORT_SCHEMA = 2
+WATCHDOG_LIMIT_BYTES = 30 * 1024**3
+WATCHDOG_SCOPE = "complete-orchestrator-process-tree-v1"
+WATCHDOG_BINDING = "outer-command-session-result-v1"
+WATCHDOG_RELATIVE_PATH = "tools/ci/memory_watchdog.py"
+
+_SHA256_LENGTH = 64
+_REVISION_LENGTH = 40
+
+
+class EvidenceError(RuntimeError):
+    """Raised when a capture cannot support an acceptance decision."""
+
+
+@dataclass(frozen=True)
+class Distribution:
+    """Raw values and statistics recomputed by this gate."""
+
+    values: tuple[float, ...]
+    median: float
+    raw_mad: float
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "sample_count": len(self.values),
+            "values": list(self.values),
+            "median": self.median,
+            "raw_mad": self.raw_mad,
+        }
+
+
+@dataclass(frozen=True)
+class CellEvidence:
+    """One validated mode/batch cell from a capture."""
+
+    runtime: Distribution
+    cold_load: Distribution
+    cold_load_rss: Distribution
+    profiled_rss: Distribution
+    by_round: Mapping[int, float]
+
+
+@dataclass(frozen=True)
+class GenerationEvidence:
+    """Fresh generation metrics for one mode."""
+
+    wall_seconds: float
+    payload_size_bytes: int
+    peak_rss_bytes: int
+
+
+@dataclass(frozen=True)
+class CaptureEvidence:
+    """Validated evidence extracted from one recurrence-z6g capture."""
+
+    input_identity: Mapping[str, object]
+    layout: str
+    logical_process: str
+    source_revision: str
+    build_identity: Mapping[str, object]
+    host_identity: Mapping[str, object]
+    campaign_identity: Mapping[str, object]
+    workload_identities: Mapping[str, Mapping[str, object]]
+    cells: Mapping[tuple[str, int], CellEvidence]
+    generation: Mapping[str, GenerationEvidence]
+    configured_modes: tuple[str, ...]
+    paired_profile_coordination: Mapping[str, object]
+    eager_diagnostic: Mapping[str, object]
+    interpreter_path: str
+    interpreter_resolved_path: str
+    prepared_model_path: str
+    prepared_model_sha256: str
+
+
+def _canonical_json_bytes(value: object) -> bytes:
+    try:
+        return json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    except (TypeError, ValueError) as error:
+        raise EvidenceError("evidence is not canonical-JSON serializable") from error
+
+
+def _sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_json_bytes(value)).hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    try:
+        with path.open("rb") as stream:
+            for block in iter(lambda: stream.read(1024 * 1024), b""):
+                digest.update(block)
+    except OSError as error:
+        raise EvidenceError(f"cannot read capture: {path}") from error
+    return digest.hexdigest()
+
+
+def _input_identity(path: Path) -> dict[str, object]:
+    try:
+        resolved = path.expanduser().resolve(strict=True)
+        stat = resolved.stat()
+    except OSError as error:
+        raise EvidenceError(f"cannot inspect capture: {path}") from error
+    if not resolved.is_file():
+        raise EvidenceError(f"capture is not a regular file: {path}")
+    return {
+        "path": str(path),
+        "resolved_path": str(resolved),
+        "size_bytes": stat.st_size,
+        "sha256": _sha256_file(resolved),
+    }
+
+
+def _read_json_mapping(
+    path: Path,
+    *,
+    label: str,
+) -> tuple[dict[str, Any], dict[str, object]]:
+    identity = _input_identity(path)
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise EvidenceError(f"{label} is not valid UTF-8 JSON: {path}") from error
+    if not isinstance(value, dict):
+        raise EvidenceError(f"{label} root is not an object: {path}")
+    return value, identity
+
+
+def _read_capture(path: Path) -> tuple[dict[str, Any], dict[str, object]]:
+    return _read_json_mapping(path, label="capture")
+
+
+def _mapping(value: object, label: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise EvidenceError(f"{label} is missing or is not an object")
+    return value
+
+
+def _sequence(value: object, label: str) -> Sequence[Any]:
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise EvidenceError(f"{label} is missing or is not an array")
+    return value
+
+
+def _string(value: object, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise EvidenceError(f"{label} is missing or is not a non-empty string")
+    return value
+
+
+def _exact_int(value: object, label: str, *, minimum: int | None = None) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise EvidenceError(f"{label} is missing or is not an integer")
+    if minimum is not None and value < minimum:
+        raise EvidenceError(f"{label} must be at least {minimum}")
+    return value
+
+
+def _positive_number(value: object, label: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise EvidenceError(f"{label} is missing or is not numeric")
+    result = float(value)
+    if not math.isfinite(result) or result <= 0.0:
+        raise EvidenceError(f"{label} must be a positive finite number")
+    return result
+
+
+def _nonnegative_number(value: object, label: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise EvidenceError(f"{label} is missing or is not numeric")
+    result = float(value)
+    if not math.isfinite(result) or result < 0.0:
+        raise EvidenceError(f"{label} must be a finite non-negative number")
+    return result
+
+
+def _valid_sha256(value: object, label: str) -> str:
+    result = _string(value, label)
+    if len(result) != _SHA256_LENGTH:
+        raise EvidenceError(f"{label} is not a SHA-256 digest")
+    try:
+        int(result, 16)
+    except ValueError as error:
+        raise EvidenceError(f"{label} is not a SHA-256 digest") from error
+    if result != result.lower():
+        raise EvidenceError(f"{label} is not a lowercase SHA-256 digest")
+    return result
+
+
+def _valid_revision(value: object, label: str) -> str:
+    result = _string(value, label)
+    if len(result) != _REVISION_LENGTH:
+        raise EvidenceError(f"{label} is not a full Git revision")
+    try:
+        int(result, 16)
+    except ValueError as error:
+        raise EvidenceError(f"{label} is not a Git revision") from error
+    if result != result.lower():
+        raise EvidenceError(f"{label} is not a lowercase Git revision")
+    return result
+
+
+def _validate_content_address(value: object, label: str) -> Mapping[str, Any]:
+    record = _mapping(value, label)
+    unsigned = dict(record)
+    digest = _valid_sha256(
+        unsigned.pop("content_sha256", None), f"{label}.content_sha256"
+    )
+    if digest != _sha256(unsigned):
+        raise EvidenceError(f"{label} content address does not match its payload")
+    return record
+
+
+def _validate_nested_content_addresses(value: object, label: str) -> None:
+    if isinstance(value, Mapping):
+        if "content_sha256" in value:
+            record = _validate_content_address(value, label)
+            for field, child in record.items():
+                if field != "content_sha256":
+                    _validate_nested_content_addresses(child, f"{label}.{field}")
+            return
+        for field, child in value.items():
+            _validate_nested_content_addresses(child, f"{label}.{field}")
+    elif isinstance(value, Sequence) and not isinstance(
+        value,
+        (str, bytes, bytearray),
+    ):
+        for index, child in enumerate(value):
+            _validate_nested_content_addresses(child, f"{label}[{index}]")
+
+
+def _utc_timestamp(value: object, label: str) -> dt.datetime:
+    if not isinstance(value, str):
+        raise EvidenceError(f"{label} is not a UTC timestamp")
+    try:
+        parsed = dt.datetime.fromisoformat(value)
+    except ValueError as error:
+        raise EvidenceError(f"{label} is not a UTC timestamp") from error
+    if parsed.tzinfo is None or parsed.utcoffset() != dt.timedelta(0):
+        raise EvidenceError(f"{label} is not a UTC timestamp")
+    return parsed
+
+
+def _distribution(values: Sequence[float], label: str) -> Distribution:
+    if len(values) < MINIMUM_SUBPROCESS_SAMPLES:
+        raise EvidenceError(
+            f"{label} has {len(values)} subprocess samples; "
+            f"at least {MINIMUM_SUBPROCESS_SAMPLES} are required"
+        )
+    checked = tuple(_positive_number(value, f"{label} raw sample") for value in values)
+    median = float(statistics.median(checked))
+    raw_mad = float(statistics.median(abs(value - median) for value in checked))
+    return Distribution(values=checked, median=median, raw_mad=raw_mad)
+
+
+def _rss_observation(value: object, label: str) -> float:
+    peak = _mapping(value, label)
+    if peak.get("source") != "resource.getrusage":
+        raise EvidenceError(f"{label} has an unsupported RSS source")
+    self_peak = _exact_int(
+        peak.get("self_peak_bytes"), f"{label}.self_peak_bytes", minimum=0
+    )
+    child_peak = _exact_int(
+        peak.get("maximum_child_peak_bytes"),
+        f"{label}.maximum_child_peak_bytes",
+        minimum=0,
+    )
+    observed = _exact_int(
+        peak.get("observed_lower_bound_bytes"),
+        f"{label}.observed_lower_bound_bytes",
+        minimum=1,
+    )
+    if observed != max(self_peak, child_peak):
+        raise EvidenceError(f"{label} is not a consistent resource peak")
+    return float(observed)
+
+
+def _recorded_statistic(
+    observed: object,
+    expected: float,
+    label: str,
+) -> None:
+    value = _nonnegative_number(observed, label)
+    if not math.isclose(value, expected, rel_tol=1.0e-14, abs_tol=0.0):
+        raise EvidenceError(
+            f"{label} is not reproducible from retained raw subprocess samples"
+        )
+
+
+def _logical_process(value: object, label: str) -> str:
+    normalized = " ".join(_string(value, label).split()).casefold()
+    supported = {
+        "u u~ > z g g g g g g": "u u~ > Z g g g g g g",
+        "d d~ > z + 6*g": "d d~ > Z g g g g g g",
+        "d d~ > z g g g g g g": "d d~ > Z g g g g g g",
+    }
+    try:
+        return supported[normalized]
+    except KeyError as error:
+        raise EvidenceError(
+            f"{label} is not the supported u u~ or exact d d~ > Z + 6g route"
+        ) from error
+
+
+def _expected_semantic_comparison_policy(
+    *,
+    logical_process: str,
+    layout: str,
+    configuration: Mapping[str, Any],
+    label: str,
+) -> str:
+    if logical_process == SELECTED_UNION_PROCESS and layout == "all-flow-union":
+        if configuration.get("helicity_request") != SELECTED_UNION_HELICITY_ID:
+            raise EvidenceError(
+                f"{label} exact d all-flow-union route must select "
+                f"{SELECTED_UNION_HELICITY_ID}"
+            )
+        return SELECTED_UNION_SEMANTIC_COMPARISON_POLICY
+    return STRICT_SEMANTIC_COMPARISON_POLICY
+
+
+def _validated_selected_union_projection(
+    value: object,
+    *,
+    configuration: Mapping[str, Any],
+    label: str,
+) -> Mapping[str, Any]:
+    projection = _mapping(value, label)
+    expected_fields = {
+        "policy",
+        "process_id",
+        "process_expression",
+        "physical_color_flows",
+        "physical_helicities",
+        "normalization_sha256",
+        "model_common_physics_identity_sha256",
+        "runtime_selector_semantics_sha256",
+        "profile_selector",
+        "resolved_color_ids_sha256",
+    }
+    if set(projection) != expected_fields:
+        raise EvidenceError(f"{label} has an unexpected projection schema")
+    if (
+        projection.get("policy") != SELECTED_UNION_SEMANTIC_COMPARISON_POLICY
+        or _logical_process(
+            projection.get("process_expression"),
+            f"{label}.process_expression",
+        )
+        != SELECTED_UNION_PROCESS
+    ):
+        raise EvidenceError(f"{label} has the wrong selected-union policy or process")
+    _string(projection.get("process_id"), f"{label}.process_id")
+
+    colors = _mapping(
+        projection.get("physical_color_flows"),
+        f"{label}.physical_color_flows",
+    )
+    if (
+        set(colors)
+        != {
+            "count",
+            "ordered_ids_sha256",
+            "ordered_entries_sha256",
+        }
+        or _exact_int(
+            colors.get("count"),
+            f"{label}.physical_color_flows.count",
+            minimum=1,
+        )
+        != SELECTED_UNION_COLOR_COUNT
+    ):
+        raise EvidenceError(f"{label} does not bind exactly 720 physical colors")
+    for field in ("ordered_ids_sha256", "ordered_entries_sha256"):
+        _valid_sha256(colors.get(field), f"{label}.physical_color_flows.{field}")
+
+    helicities = _mapping(
+        projection.get("physical_helicities"),
+        f"{label}.physical_helicities",
+    )
+    if set(helicities) != {
+        "count",
+        "ordered_ids_sha256",
+        "kinematic_entries_sha256",
+        "selected_index",
+        "selected_entry",
+    }:
+        raise EvidenceError(f"{label} has an invalid physical-helicity projection")
+    helicity_count = _exact_int(
+        helicities.get("count"),
+        f"{label}.physical_helicities.count",
+        minimum=SELECTED_UNION_HELICITY_INDEX + 1,
+    )
+    selected_index = _exact_int(
+        helicities.get("selected_index"),
+        f"{label}.physical_helicities.selected_index",
+        minimum=0,
+    )
+    if selected_index != SELECTED_UNION_HELICITY_INDEX:
+        raise EvidenceError(f"{label} selected helicity has the wrong ordered index")
+    for field in ("ordered_ids_sha256", "kinematic_entries_sha256"):
+        _valid_sha256(helicities.get(field), f"{label}.physical_helicities.{field}")
+    selected = _mapping(
+        helicities.get("selected_entry"),
+        f"{label}.physical_helicities.selected_entry",
+    )
+    if (
+        set(selected) != {"index", "id", "values", "coefficient", "structural_zero"}
+        or selected.get("index") != selected_index
+        or selected.get("id") != SELECTED_UNION_HELICITY_ID
+        or selected.get("values") != list(SELECTED_UNION_HELICITY_VALUES)
+        or selected.get("structural_zero") is not False
+    ):
+        raise EvidenceError(f"{label} selected helicity entry is not canonical/live")
+    _positive_number(
+        selected.get("coefficient"),
+        f"{label}.physical_helicities.selected_entry.coefficient",
+    )
+
+    selector = _mapping(
+        projection.get("profile_selector"),
+        f"{label}.profile_selector",
+    )
+    if (
+        set(selector)
+        != {
+            "color_flow_request",
+            "resolved_color_flow_id",
+            "helicity_request",
+            "resolved_helicity_id",
+            "color_flow_count",
+            "helicity_count",
+            "workload",
+        }
+        or selector.get("color_flow_request") != configuration.get("color_flow_request")
+        or selector.get("resolved_color_flow_id") is not None
+        or selector.get("helicity_request") != SELECTED_UNION_HELICITY_ID
+        or selector.get("resolved_helicity_id") != SELECTED_UNION_HELICITY_ID
+        or selector.get("color_flow_count") != SELECTED_UNION_COLOR_COUNT
+        or selector.get("helicity_count") != helicity_count
+        or selector.get("workload") != "all-flows/runtime-selected-single-helicity"
+    ):
+        raise EvidenceError(f"{label} has the wrong selected-union selector")
+    for field in (
+        "normalization_sha256",
+        "model_common_physics_identity_sha256",
+        "runtime_selector_semantics_sha256",
+        "resolved_color_ids_sha256",
+    ):
+        _valid_sha256(projection.get(field), f"{label}.{field}")
+    return projection
+
+
+def _capture_semantic_projection(
+    acceptance: Mapping[str, Any],
+    *,
+    configuration: Mapping[str, Any],
+    logical_process: str,
+    layout: str,
+    label: str,
+) -> Mapping[str, Any] | None:
+    semantic_contract = _mapping(
+        acceptance.get("artifact_semantic_contract"),
+        f"{label}.artifact_semantic_contract",
+    )
+    lane_contracts = _mapping(
+        semantic_contract.get("lane_contracts"),
+        f"{label}.artifact_semantic_contract.lane_contracts",
+    )
+    expected_policy = _expected_semantic_comparison_policy(
+        logical_process=logical_process,
+        layout=layout,
+        configuration=configuration,
+        label=label,
+    )
+    if semantic_contract.get("comparison_policy") != expected_policy:
+        raise EvidenceError(
+            f"{label} artifact-semantic comparison policy does not match its route"
+        )
+    if expected_policy == STRICT_SEMANTIC_COMPARISON_POLICY:
+        if any(
+            isinstance(lane, Mapping) and "selected_union_workload_projection" in lane
+            for lane in lane_contracts.values()
+        ):
+            raise EvidenceError(
+                f"{label} strict route unexpectedly contains a "
+                "selected-union projection"
+            )
+        return None
+
+    common = _validated_selected_union_projection(
+        semantic_contract.get("common_physics_contract"),
+        configuration=configuration,
+        label=f"{label}.artifact_semantic_contract.common_physics_contract",
+    )
+    for mode in CAPTURE_MODES:
+        lane = _mapping(
+            lane_contracts.get(mode),
+            f"{label}.artifact_semantic_contract.lane_contracts.{mode}",
+        )
+        lane_projection = lane.get("selected_union_workload_projection")
+        if lane_projection != common:
+            raise EvidenceError(
+                f"{label} {mode} selected-union projection differs from common"
+            )
+    return common
+
+
+def _validate_capture_acceptance(
+    payload: Mapping[str, Any],
+    configuration: Mapping[str, Any],
+    *,
+    expected_layout: str,
+    subprocess_samples: int,
+    internal_samples: int,
+    warmups: int,
+    configured_modes: Sequence[str],
+) -> Mapping[str, Any]:
+    label = f"{expected_layout}.capture_acceptance"
+    if payload.get("complete") is not True or payload.get("passes") is not True:
+        raise EvidenceError(
+            f"{expected_layout} capture is not top-level complete and passing"
+        )
+    acceptance = _mapping(payload.get("capture_acceptance"), label)
+    if (
+        acceptance.get("kind") != "pyamplicol-three-lane-layout-capture"
+        or _exact_int(
+            acceptance.get("schema_version"),
+            f"{label}.schema_version",
+        )
+        < 6
+    ):
+        raise EvidenceError(f"{label} has an unsupported identity")
+    required_true = (
+        "complete",
+        "evidence_complete",
+        "passes",
+        "authoritative_eligible",
+        "lane_self_validation_passes",
+        "pairwise_validation_passes",
+    )
+    if any(acceptance.get(field) is not True for field in required_true):
+        raise EvidenceError(f"{label} is not authoritative, complete, and passing")
+    if (
+        acceptance.get("authoritative_ineligibility_reasons") != []
+        or acceptance.get("generation_specialized_axes_by_mode") != {}
+        or acceptance.get("incomplete_physical_axes") != []
+        or acceptance.get("missing_modes") != []
+        or acceptance.get("missing_batch_sizes") != []
+        or acceptance.get("generation_only") is not False
+        or acceptance.get("layout") != expected_layout
+    ):
+        raise EvidenceError(f"{label} contains authoritative ineligibility evidence")
+    if (
+        list(
+            _sequence(
+                acceptance.get("required_modes"),
+                f"{label}.required_modes",
+            )
+        )
+        != list(CAPTURE_MODES)
+        or list(
+            _sequence(
+                acceptance.get("observed_modes"),
+                f"{label}.observed_modes",
+            )
+        )
+        != list(CAPTURE_MODES)
+        or set(
+            _sequence(
+                acceptance.get("required_batch_sizes"),
+                f"{label}.required_batch_sizes",
+            )
+        )
+        != set(BATCH_SIZES)
+        or set(
+            _sequence(
+                acceptance.get("observed_batch_sizes"),
+                f"{label}.observed_batch_sizes",
+            )
+        )
+        != set(BATCH_SIZES)
+    ):
+        raise EvidenceError(f"{label} required/observed inventory is inconsistent")
+
+    measurement = _mapping(
+        acceptance.get("measurement_contract"),
+        f"{label}.measurement_contract",
+    )
+    if (
+        measurement.get("passes") is not True
+        or measurement.get("root_processes_match") is not True
+        or measurement.get("configured_internal_minimum_samples") != internal_samples
+        or measurement.get("configured_subprocess_samples") != subprocess_samples
+        or measurement.get("configured_warmup_runs") != warmups
+        or _exact_int(
+            measurement.get("minimum_authoritative_samples"),
+            f"{label}.measurement_contract.minimum_authoritative_samples",
+            minimum=MINIMUM_SUBPROCESS_SAMPLES,
+        )
+        > subprocess_samples
+    ):
+        raise EvidenceError(f"{label} measurement contract is inconsistent")
+    schedule_contract = _mapping(
+        measurement.get("schedule"),
+        f"{label}.measurement_contract.schedule",
+    )
+    expected_entry_count = len(configured_modes) * len(BATCH_SIZES) * subprocess_samples
+    if (
+        schedule_contract.get("passes") is not True
+        or schedule_contract.get("errors") != []
+        or schedule_contract.get("entry_count") != expected_entry_count
+        or schedule_contract.get("unique_worker_command_count") != expected_entry_count
+        or schedule_contract.get("subprocess_samples_per_cell") != subprocess_samples
+    ):
+        raise EvidenceError(f"{label} schedule contract is incomplete")
+    lane_contracts = _mapping(
+        measurement.get("lanes"),
+        f"{label}.measurement_contract.lanes",
+    )
+    if set(lane_contracts) != set(CAPTURE_MODES):
+        raise EvidenceError(f"{label} measurement lane inventory is inconsistent")
+    for mode in CAPTURE_MODES:
+        lane = _mapping(
+            lane_contracts.get(mode),
+            f"{label}.measurement_contract.lanes.{mode}",
+        )
+        if (
+            lane.get("passes") is not True
+            or lane.get("errors") != []
+            or set(
+                _sequence(
+                    lane.get("observed_batch_sizes"),
+                    f"{label}.measurement_contract.lanes.{mode}.observed_batch_sizes",
+                )
+            )
+            != set(BATCH_SIZES)
+            or lane.get("missing_batch_sizes") != []
+        ):
+            raise EvidenceError(f"{label} {mode} measurement lane is incomplete")
+
+    semantic_contract = _mapping(
+        acceptance.get("artifact_semantic_contract"),
+        f"{label}.artifact_semantic_contract",
+    )
+    semantic_lanes = _mapping(
+        semantic_contract.get("lane_contracts"),
+        f"{label}.artifact_semantic_contract.lane_contracts",
+    )
+    if (
+        semantic_contract.get("passes") is not True
+        or semantic_contract.get("errors") != []
+        or semantic_contract.get("lanes_match") is not True
+        or not isinstance(semantic_contract.get("common_physics_contract"), Mapping)
+        or set(semantic_lanes) != set(CAPTURE_MODES)
+    ):
+        raise EvidenceError(f"{label} artifact-semantic contract is incomplete")
+
+    eager = _mapping(
+        acceptance.get("eager_diagnostic"),
+        f"{label}.eager_diagnostic",
+    )
+    eager_measurement = _mapping(
+        eager.get("measurement_contract"),
+        f"{label}.eager_diagnostic.measurement_contract",
+    )
+    eager_semantics = _mapping(
+        eager.get("artifact_semantic_contract"),
+        f"{label}.eager_diagnostic.artifact_semantic_contract",
+    )
+    eager_validation = _mapping(
+        eager.get("validation_summary"),
+        f"{label}.eager_diagnostic.validation_summary",
+    )
+    if (
+        eager.get("requested") is not True
+        or eager.get("observed") is not True
+        or eager.get("complete") is not True
+        or eager.get("passes") is not True
+        or eager.get("ineligibility_reasons") != []
+        or eager_measurement.get("passes") is not True
+        or eager_semantics.get("passes") is not True
+        or eager_semantics.get("lanes_match") is not True
+        or eager_validation.get("passes") is not True
+    ):
+        raise EvidenceError(f"{label} eager diagnostic is not complete and admissible")
+    authoritative_validation = {
+        "passes": acceptance.get("passes"),
+        "lane_validation_passes": acceptance.get("lane_self_validation_passes"),
+        "pairwise_validation_passes": acceptance.get("pairwise_validation_passes"),
+    }
+    if (
+        authoritative_validation["passes"] is not True
+        or authoritative_validation["lane_validation_passes"] is not True
+        or authoritative_validation["pairwise_validation_passes"] is not True
+    ):
+        raise EvidenceError(
+            f"{expected_layout} capture validation summary is not passing"
+        )
+    if set(
+        _sequence(
+            configuration.get("modes"),
+            f"{expected_layout}.configuration.modes",
+        )
+    ) != set(configured_modes):
+        raise EvidenceError(f"{label} does not match the configured lane inventory")
+    return acceptance
+
+
+def _semantic_digest(
+    semantic: Mapping[str, Any],
+    field: str,
+    digest_field: str,
+    label: str,
+) -> tuple[object, str]:
+    value = semantic.get(field)
+    if value is None:
+        raise EvidenceError(f"{label}.{field} is missing")
+    digest = _valid_sha256(
+        semantic.get(digest_field),
+        f"{label}.{digest_field}",
+    )
+    if digest != _sha256(value):
+        raise EvidenceError(f"{label}.{digest_field} does not match {field}")
+    return value, digest
+
+
+def _bind_selected_union_projection(
+    projection: Mapping[str, Any],
+    *,
+    semantic: Mapping[str, Any],
+    selector: Mapping[str, Any],
+    validation: Mapping[str, Any],
+    process_id: str,
+    normalization_sha256: str,
+    model_sha256: str,
+    selector_semantics_sha256: str,
+    label: str,
+) -> None:
+    if projection.get("process_id") != process_id:
+        raise EvidenceError(f"{label} projected process ID differs from its profile")
+    projected_selector = _mapping(
+        projection.get("profile_selector"),
+        f"{label}.selected_union_projection.profile_selector",
+    )
+    selector_fields = (
+        "color_flow_request",
+        "resolved_color_flow_id",
+        "helicity_request",
+        "resolved_helicity_id",
+        "color_flow_count",
+        "helicity_count",
+        "workload",
+    )
+    if set(selector) != {*selector_fields, "structural_zero_helicity_count"} or {
+        field: selector.get(field) for field in selector_fields
+    } != dict(projected_selector):
+        raise EvidenceError(
+            f"{label} selector differs from its selected-union projection"
+        )
+
+    projected_colors = _mapping(
+        projection.get("physical_color_flows"),
+        f"{label}.selected_union_projection.physical_color_flows",
+    )
+    colors = _mapping(
+        semantic.get("physical_color_flows"),
+        f"{label}.physical_color_flows",
+    )
+    color_ids = list(
+        _sequence(
+            colors.get("ordered_ids"),
+            f"{label}.physical_color_flows.ordered_ids",
+        )
+    )
+    color_entries = list(
+        _sequence(
+            colors.get("ordered_entries"),
+            f"{label}.physical_color_flows.ordered_entries",
+        )
+    )
+    if (
+        colors.get("count") != SELECTED_UNION_COLOR_COUNT
+        or len(color_ids) != SELECTED_UNION_COLOR_COUNT
+        or len(color_entries) != SELECTED_UNION_COLOR_COUNT
+        or len(set(color_ids)) != SELECTED_UNION_COLOR_COUNT
+        or any(
+            not isinstance(identifier, str) or not identifier
+            for identifier in color_ids
+        )
+        or _valid_sha256(
+            colors.get("ordered_ids_sha256"),
+            f"{label}.physical_color_flows.ordered_ids_sha256",
+        )
+        != _sha256(color_ids)
+        or _valid_sha256(
+            colors.get("ordered_entries_sha256"),
+            f"{label}.physical_color_flows.ordered_entries_sha256",
+        )
+        != _sha256(color_entries)
+        or projected_colors.get("count") != colors.get("count")
+        or projected_colors.get("ordered_ids_sha256")
+        != colors.get("ordered_ids_sha256")
+        or projected_colors.get("ordered_entries_sha256")
+        != colors.get("ordered_entries_sha256")
+    ):
+        raise EvidenceError(
+            f"{label} physical colors differ from selected-union projection"
+        )
+
+    projected_helicities = _mapping(
+        projection.get("physical_helicities"),
+        f"{label}.selected_union_projection.physical_helicities",
+    )
+    helicities = _mapping(
+        semantic.get("physical_helicities"),
+        f"{label}.physical_helicities",
+    )
+    helicity_ids = list(
+        _sequence(
+            helicities.get("ordered_ids"),
+            f"{label}.physical_helicities.ordered_ids",
+        )
+    )
+    raw_helicity_entries = list(
+        _sequence(
+            helicities.get("ordered_entries"),
+            f"{label}.physical_helicities.ordered_entries",
+        )
+    )
+    helicity_count = _exact_int(
+        helicities.get("count"),
+        f"{label}.physical_helicities.count",
+        minimum=SELECTED_UNION_HELICITY_INDEX + 1,
+    )
+    if (
+        len(helicity_ids) != helicity_count
+        or len(raw_helicity_entries) != helicity_count
+        or len(set(helicity_ids)) != helicity_count
+        or _valid_sha256(
+            helicities.get("ordered_ids_sha256"),
+            f"{label}.physical_helicities.ordered_ids_sha256",
+        )
+        != _sha256(helicity_ids)
+        or projected_helicities.get("count") != helicity_count
+        or projected_helicities.get("ordered_ids_sha256")
+        != helicities.get("ordered_ids_sha256")
+    ):
+        raise EvidenceError(
+            f"{label} physical helicities differ from selected-union projection"
+        )
+    kinematic_entries: list[dict[str, object]] = []
+    selected_entry: dict[str, object] | None = None
+    for index, raw_entry in enumerate(raw_helicity_entries):
+        entry = _mapping(
+            raw_entry,
+            f"{label}.physical_helicities.ordered_entries[{index}]",
+        )
+        identifier = entry.get("id")
+        values = entry.get("values")
+        if (
+            entry.get("index") != index
+            or helicity_ids[index] != identifier
+            or not isinstance(identifier, str)
+            or not isinstance(values, list)
+        ):
+            raise EvidenceError(f"{label} physical helicity ordering is invalid")
+        projected_entry: dict[str, object] = {
+            "index": index,
+            "id": identifier,
+            "values": values,
+        }
+        if identifier == SELECTED_UNION_HELICITY_ID:
+            projected_entry.update(
+                {
+                    "coefficient": entry.get("coefficient"),
+                    "structural_zero": entry.get("structural_zero"),
+                }
+            )
+            selected_entry = dict(entry)
+        kinematic_entries.append(projected_entry)
+    if (
+        helicity_ids[SELECTED_UNION_HELICITY_INDEX] != SELECTED_UNION_HELICITY_ID
+        or selected_entry is None
+        or selected_entry != projected_helicities.get("selected_entry")
+        or projected_helicities.get("selected_index") != SELECTED_UNION_HELICITY_INDEX
+        or projected_helicities.get("kinematic_entries_sha256")
+        != _sha256(kinematic_entries)
+    ):
+        raise EvidenceError(
+            f"{label} selected helicity differs from selected-union projection"
+        )
+
+    resolved_colors = list(
+        _sequence(
+            validation.get("resolved_color_ids"),
+            f"{label}.validation.resolved_color_ids",
+        )
+    )
+    if (
+        resolved_colors != color_ids
+        or projection.get("resolved_color_ids_sha256") != _sha256(resolved_colors)
+        or validation.get("resolved_helicity_ids") != [SELECTED_UNION_HELICITY_ID]
+        or projection.get("normalization_sha256") != normalization_sha256
+        or projection.get("model_common_physics_identity_sha256") != model_sha256
+        or projection.get("runtime_selector_semantics_sha256")
+        != selector_semantics_sha256
+    ):
+        raise EvidenceError(
+            f"{label} selected-union physics/digests differ from projection"
+        )
+
+
+def _workload_identity(
+    *,
+    profile: Mapping[str, Any],
+    generation: Mapping[str, Any],
+    mode: str,
+    layout: str,
+    logical_process: str,
+    expected_workload: str,
+    selected_union_projection: Mapping[str, Any] | None,
+    label: str,
+) -> dict[str, object]:
+    if profile.get("mode") != mode:
+        raise EvidenceError(f"{label}.mode does not match its lane")
+    if (
+        _logical_process(
+            profile.get("process_expression"), f"{label}.process_expression"
+        )
+        != logical_process
+    ):
+        raise EvidenceError(f"{label} process expression drifted from its capture")
+    process_id = _string(profile.get("process_id"), f"{label}.process_id")
+    selector = _mapping(profile.get("selector_contract"), f"{label}.selector_contract")
+    if selector.get("workload") != expected_workload:
+        raise EvidenceError(f"{label}.selector_contract has the wrong workload")
+    validation = _mapping(profile.get("validation"), f"{label}.validation")
+    if validation.get("passes") is not True:
+        raise EvidenceError(f"{label} numerical validation did not pass")
+    fixture = _mapping(validation.get("fixture"), f"{label}.validation.fixture")
+    point_count = _exact_int(
+        fixture.get("point_count"),
+        f"{label}.validation.fixture.point_count",
+        minimum=1,
+    )
+    points_sha256 = _valid_sha256(
+        fixture.get("points_sha256"),
+        f"{label}.validation.fixture.points_sha256",
+    )
+
+    semantic = _mapping(
+        profile.get("artifact_semantic_identity"),
+        f"{label}.artifact_semantic_identity",
+    )
+    semantic_digest = _valid_sha256(
+        profile.get("artifact_semantic_identity_sha256"),
+        f"{label}.artifact_semantic_identity_sha256",
+    )
+    if semantic_digest != _sha256(semantic):
+        raise EvidenceError(
+            f"{label} artifact semantic identity is not content-addressed"
+        )
+    generation_identity = _mapping(
+        generation.get("artifact_identity"),
+        f"{label}.generation.artifact_identity",
+    )
+    if (
+        generation_identity.get("semantic_identity") != semantic
+        or generation_identity.get("semantic_identity_sha256") != semantic_digest
+    ):
+        raise EvidenceError(
+            f"{label} profile and generation artifact identities differ"
+        )
+    if semantic.get("generation_specialized_axes") != []:
+        raise EvidenceError(f"{label} has generation-specialized physical axes")
+    coverage = _mapping(semantic.get("coverage"), f"{label}.coverage")
+    if coverage.get("complete_physical_axes") is not True:
+        raise EvidenceError(f"{label} does not contain complete physical axes")
+    reduction_coverage = _mapping(
+        semantic.get("reduction_coverage"),
+        f"{label}.reduction_coverage",
+    )
+    if reduction_coverage.get("complete") is not True:
+        raise EvidenceError(f"{label} reduction coverage is incomplete")
+
+    normalization, normalization_sha256 = _semantic_digest(
+        semantic,
+        "normalization",
+        "normalization_sha256",
+        label,
+    )
+    reduction_ordering, reduction_ordering_sha256 = _semantic_digest(
+        semantic,
+        "reduction_ordering",
+        "reduction_ordering_sha256",
+        label,
+    )
+    selector_semantics, selector_semantics_sha256 = _semantic_digest(
+        semantic,
+        "runtime_selector_semantics",
+        "runtime_selector_semantics_sha256",
+        label,
+    )
+    model_identity = _mapping(
+        semantic.get("manifest_model_identity"),
+        f"{label}.manifest_model_identity",
+    )
+    common_model = _mapping(
+        model_identity.get("common_physics_identity"),
+        f"{label}.manifest_model_identity.common_physics_identity",
+    )
+    common_model_sha256 = _valid_sha256(
+        model_identity.get("common_physics_identity_sha256"),
+        f"{label}.manifest_model_identity.common_physics_identity_sha256",
+    )
+    if common_model_sha256 != _sha256(common_model):
+        raise EvidenceError(f"{label} common model identity is not content-addressed")
+    physical_color_flows = semantic.get("physical_color_flows")
+    physical_helicities = semantic.get("physical_helicities")
+    if physical_color_flows is None or physical_helicities is None:
+        raise EvidenceError(f"{label} physical-axis identity is incomplete")
+
+    effective = _mapping(
+        generation.get("effective_contract"),
+        f"{label}.generation.effective_contract",
+    )
+    expected_optimization = 3 if mode == "compiled" else 2
+    expected_effective = {
+        "backend": "jit",
+        "color_accuracy": "lc",
+        "execution_mode": mode,
+        "jit_optimization_level": expected_optimization,
+        "lc_flow_layout": layout,
+    }
+    if any(effective.get(key) != value for key, value in expected_effective.items()):
+        raise EvidenceError(
+            f"{label} does not use {mode} JIT O{expected_optimization} "
+            f"with the requested {layout} layout"
+        )
+
+    common_identity = {
+        "process": logical_process,
+        "process_id": process_id,
+        "layout": layout,
+        "mode": mode,
+        "workload": expected_workload,
+        "validation_fixture": {
+            "point_count": point_count,
+            "points_sha256": points_sha256,
+        },
+        "coverage_sha256": _sha256(coverage),
+        "effective_contract": expected_effective,
+    }
+    if selected_union_projection is not None:
+        _bind_selected_union_projection(
+            selected_union_projection,
+            semantic=semantic,
+            selector=selector,
+            validation=validation,
+            process_id=process_id,
+            normalization_sha256=normalization_sha256,
+            model_sha256=common_model_sha256,
+            selector_semantics_sha256=selector_semantics_sha256,
+            label=label,
+        )
+        return {
+            **common_identity,
+            "semantic_comparison_policy": (SELECTED_UNION_SEMANTIC_COMPARISON_POLICY),
+            "selected_union_projection_sha256": _sha256(selected_union_projection),
+        }
+
+    # Store digests for the large physical inventories so the comparison
+    # remains compact while still binding every ordered entry.
+    return {
+        **common_identity,
+        "selector_contract_sha256": _sha256(selector),
+        "common_model_identity_sha256": common_model_sha256,
+        "normalization_sha256": normalization_sha256,
+        "normalization_payload_sha256": _sha256(normalization),
+        "reduction_ordering_sha256": reduction_ordering_sha256,
+        "reduction_ordering_payload_sha256": _sha256(reduction_ordering),
+        "runtime_selector_semantics_sha256": selector_semantics_sha256,
+        "runtime_selector_semantics_payload_sha256": _sha256(selector_semantics),
+        "physical_color_flows_sha256": _sha256(physical_color_flows),
+        "physical_helicities_sha256": _sha256(physical_helicities),
+    }
+
+
+def _validated_schedule_worker_records(
+    schedule_entry: Mapping[str, Any],
+    label: str,
+) -> tuple[
+    Mapping[str, Any],
+    Mapping[str, Any],
+    str,
+    str,
+    str,
+]:
+    invocation = _validate_content_address(
+        schedule_entry.get("worker_invocation"),
+        f"{label}.worker_invocation",
+    )
+    result = _validate_content_address(
+        schedule_entry.get("worker_result_record"),
+        f"{label}.worker_result_record",
+    )
+    invocation_sha256 = _valid_sha256(
+        invocation.get("content_sha256"),
+        f"{label}.worker_invocation.content_sha256",
+    )
+    result_sha256 = _valid_sha256(
+        result.get("content_sha256"),
+        f"{label}.worker_result_record.content_sha256",
+    )
+    process_sha256 = _valid_sha256(
+        result.get("worker_process_record_sha256"),
+        f"{label}.worker_result_record.worker_process_record_sha256",
+    )
+    if result.get("worker_invocation_sha256") != invocation_sha256:
+        raise EvidenceError(
+            f"{label} result is not bound to its scheduled worker invocation"
+        )
+    return (
+        invocation,
+        result,
+        invocation_sha256,
+        process_sha256,
+        result_sha256,
+    )
+
+
+def _validate_sample_address(
+    sample: Mapping[str, Any],
+    schedule_entry: Mapping[str, Any],
+    label: str,
+    seen_addresses: set[str],
+) -> None:
+    invocation = _validate_content_address(
+        sample.get("worker_invocation"), f"{label}.worker_invocation"
+    )
+    process_record = _validate_content_address(
+        sample.get("worker_process_record"),
+        f"{label}.worker_process_record",
+    )
+    result_record = _validate_content_address(
+        sample.get("worker_result_record"),
+        f"{label}.worker_result_record",
+    )
+    invocation_sha256 = _valid_sha256(
+        invocation.get("content_sha256"),
+        f"{label}.worker_invocation.content_sha256",
+    )
+    process_sha256 = _valid_sha256(
+        process_record.get("content_sha256"),
+        f"{label}.worker_process_record.content_sha256",
+    )
+    result_sha256 = _valid_sha256(
+        result_record.get("content_sha256"),
+        f"{label}.worker_result_record.content_sha256",
+    )
+    for address_name, address in (
+        ("invocation", invocation_sha256),
+        ("process", process_sha256),
+        ("result", result_sha256),
+    ):
+        scoped = f"{address_name}:{address}"
+        if scoped in seen_addresses:
+            raise EvidenceError(f"{label} reuses a {address_name} subprocess identity")
+        seen_addresses.add(scoped)
+    if (
+        result_record.get("worker_invocation_sha256") != invocation_sha256
+        or result_record.get("worker_process_record_sha256") != process_sha256
+    ):
+        raise EvidenceError(f"{label} worker result is not bound to its subprocess")
+    (
+        scheduled_invocation,
+        scheduled_result,
+        scheduled_invocation_sha256,
+        scheduled_process_sha256,
+        scheduled_result_sha256,
+    ) = _validated_schedule_worker_records(
+        schedule_entry,
+        f"{label}.profile_schedule_entry",
+    )
+    if (
+        scheduled_invocation != invocation
+        or scheduled_result != result_record
+        or scheduled_invocation_sha256 != invocation_sha256
+        or scheduled_process_sha256 != process_sha256
+        or scheduled_result_sha256 != result_sha256
+    ):
+        raise EvidenceError(
+            f"{label} sample worker provenance differs from its profile schedule entry"
+        )
+    completion = _validate_content_address(
+        schedule_entry.get("paired_profile_completion"),
+        f"{label}.paired_profile_completion",
+    )
+    if (
+        completion.get("worker_invocation_sha256") != invocation_sha256
+        or completion.get("worker_result_record_sha256") != result_sha256
+        or completion.get("worker_started_at_utc") != invocation.get("started_at_utc")
+        or completion.get("worker_finished_at_utc") != invocation.get("finished_at_utc")
+    ):
+        raise EvidenceError(
+            f"{label} paired completion differs from its retained sample worker"
+        )
+    invocation_started = _utc_timestamp(
+        invocation.get("started_at_utc"),
+        f"{label}.worker_invocation.started_at_utc",
+    )
+    invocation_finished = _utc_timestamp(
+        invocation.get("finished_at_utc"),
+        f"{label}.worker_invocation.finished_at_utc",
+    )
+    if invocation_started > invocation_finished:
+        raise EvidenceError(f"{label} worker invocation timestamps are inverted")
+    unsigned_sample = {
+        str(key): value
+        for key, value in sample.items()
+        if key != "worker_result_record"
+    }
+    addressed_payload = _valid_sha256(
+        result_record.get("addressed_payload_sha256"),
+        f"{label}.worker_result_record.addressed_payload_sha256",
+    )
+    if addressed_payload != _sha256(unsigned_sample):
+        raise EvidenceError(f"{label} retained raw sample content address is invalid")
+    if schedule_entry.get("worker_result_sha256") != addressed_payload:
+        raise EvidenceError(f"{label} is not bound to its profile schedule entry")
+
+
+def _validate_raw_native_wall_measurement(
+    sample: Mapping[str, Any],
+    *,
+    batch_size: int,
+    internal_samples: int,
+    warmups: int,
+    target_runtime: float,
+    sample_wall: float,
+    fixture_points_sha256: str,
+    label: str,
+) -> None:
+    raw = _mapping(
+        sample.get("inner_native_wall_blocks"),
+        f"{label}.inner_native_wall_blocks",
+    )
+    blocks = _sequence(
+        raw.get("blocks"),
+        f"{label}.inner_native_wall_blocks.blocks",
+    )
+    block_count = _exact_int(
+        raw.get("block_count"),
+        f"{label}.inner_native_wall_blocks.block_count",
+        minimum=MINIMUM_INTERNAL_SAMPLES,
+    )
+    repetitions = _exact_int(
+        raw.get("repetitions_per_block"),
+        f"{label}.inner_native_wall_blocks.repetitions_per_block",
+        minimum=1,
+    )
+    evaluation_count = _exact_int(
+        raw.get("evaluation_count"),
+        f"{label}.inner_native_wall_blocks.evaluation_count",
+        minimum=1,
+    )
+    evaluated_point_count = _exact_int(
+        raw.get("evaluated_point_count"),
+        f"{label}.inner_native_wall_blocks.evaluated_point_count",
+        minimum=1,
+    )
+    minimum_duration = _positive_number(
+        raw.get("minimum_native_wall_seconds"),
+        f"{label}.inner_native_wall_blocks.minimum_native_wall_seconds",
+    )
+    observed_duration = _positive_number(
+        raw.get("observed_native_wall_seconds"),
+        f"{label}.inner_native_wall_blocks.observed_native_wall_seconds",
+    )
+    observed_caller_duration = _positive_number(
+        raw.get("observed_caller_elapsed_seconds"),
+        f"{label}.inner_native_wall_blocks.observed_caller_elapsed_seconds",
+    )
+    invocation = _mapping(
+        sample.get("worker_invocation"),
+        f"{label}.worker_invocation",
+    )
+    process_record = _mapping(
+        sample.get("worker_process_record"),
+        f"{label}.worker_process_record",
+    )
+    invocation_wall = _positive_number(
+        invocation.get("wall_seconds"),
+        f"{label}.worker_invocation.wall_seconds",
+    )
+    process_wall = _positive_number(
+        process_record.get("wall_seconds"),
+        f"{label}.worker_process_record.wall_seconds",
+    )
+    calibration = _mapping(
+        raw.get("calibration"),
+        f"{label}.inner_native_wall_blocks.calibration",
+    )
+    runner_samples = _exact_int(
+        calibration.get("benchmark_runner_sample_count"),
+        f"{label}.inner_native_wall_blocks.calibration."
+        "benchmark_runner_sample_count",
+        minimum=1,
+    )
+    runner_repetitions = _exact_int(
+        calibration.get("benchmark_runner_repetitions_per_sample"),
+        f"{label}.inner_native_wall_blocks.calibration."
+        "benchmark_runner_repetitions_per_sample",
+        minimum=1,
+    )
+    runner_wall = _positive_number(
+        calibration.get("benchmark_runner_wall_seconds_per_point"),
+        f"{label}.inner_native_wall_blocks.calibration."
+        "benchmark_runner_wall_seconds_per_point",
+    )
+    requested_block_count = _exact_int(
+        calibration.get("requested_minimum_block_count"),
+        f"{label}.inner_native_wall_blocks.calibration."
+        "requested_minimum_block_count",
+        minimum=MINIMUM_INTERNAL_SAMPLES,
+    )
+    scaled_repetitions = _exact_int(
+        calibration.get("scaled_repetitions_per_block"),
+        f"{label}.inner_native_wall_blocks.calibration."
+        "scaled_repetitions_per_block",
+        minimum=1,
+    )
+    headroom = _positive_number(
+        calibration.get("duration_headroom_factor"),
+        f"{label}.inner_native_wall_blocks.calibration."
+        "duration_headroom_factor",
+    )
+    calibration_target = target_runtime * headroom
+    calibration_denominator = requested_block_count * runner_wall * batch_size
+    if (
+        not math.isfinite(calibration_target)
+        or not math.isfinite(calibration_denominator)
+        or calibration_denominator <= 0.0
+    ):
+        raise EvidenceError(f"{label} raw native-wall calibration is not finite")
+    expected_scaled_repetitions = max(
+        runner_repetitions,
+        math.ceil(calibration_target / calibration_denominator),
+    )
+    worker_measurement = _mapping(
+        sample.get("worker_measurement"),
+        f"{label}.worker_measurement",
+    )
+    if (
+        raw.get("kind") != RAW_NATIVE_WALL_BLOCK_KIND
+        or raw.get("schema_version") != RAW_NATIVE_WALL_BLOCK_SCHEMA
+        or raw.get("measurement_contract")
+        != RAW_NATIVE_WALL_MEASUREMENT_CONTRACT
+        or raw.get("source") != "runtime._benchmark_f64_wall_time"
+        or raw.get("fixture_points_sha256") != fixture_points_sha256
+        or raw.get("minimum_duration_satisfied") is not True
+        or minimum_duration != target_runtime
+        or observed_duration < target_runtime
+        or observed_caller_duration < target_runtime
+        or observed_caller_duration < observed_duration
+        or invocation_wall < observed_duration
+        or invocation_wall < observed_caller_duration
+        or process_wall < observed_duration
+        or process_wall < observed_caller_duration
+        or len(blocks) != block_count
+        or evaluation_count != block_count * repetitions
+        or evaluated_point_count != evaluation_count * batch_size
+        or raw.get("blocks_sha256") != _sha256(list(blocks))
+        or calibration.get("kind") != "benchmark-runner-wall-rate-calibration"
+        or calibration.get("schema_version") != 1
+        or calibration.get("benchmark_runner_total_repetitions")
+        != runner_samples * runner_repetitions
+        or requested_block_count != max(MINIMUM_INTERNAL_SAMPLES, internal_samples)
+        or scaled_repetitions != repetitions
+        or scaled_repetitions != expected_scaled_repetitions
+        or _exact_int(
+            calibration.get("preceded_by_benchmark_runner_warmup_runs"),
+            f"{label}.inner_native_wall_blocks.calibration."
+            "preceded_by_benchmark_runner_warmup_runs",
+            minimum=MINIMUM_WARMUPS,
+        )
+        != warmups
+        or headroom != 1.02
+        or worker_measurement.get("batch_size") != batch_size
+        or worker_measurement.get("sample_count") != block_count
+        or worker_measurement.get("repetitions_per_sample") != repetitions
+        or worker_measurement.get("evaluation_count") != evaluation_count
+        or worker_measurement.get("evaluated_point_count")
+        != evaluated_point_count
+        or worker_measurement.get("wall_seconds_per_point") != sample_wall
+        or worker_measurement.get("inner_native_wall_blocks") != raw
+        or worker_measurement.get("benchmark_runner_sample_count")
+        != runner_samples
+        or worker_measurement.get("benchmark_runner_repetitions_per_sample")
+        != runner_repetitions
+        or worker_measurement.get("benchmark_runner_evaluation_count")
+        != runner_samples * runner_repetitions
+        or worker_measurement.get("benchmark_runner_evaluated_point_count")
+        != runner_samples * runner_repetitions * batch_size
+        or worker_measurement.get("benchmark_runner_wall_seconds_per_point")
+        != runner_wall
+    ):
+        raise EvidenceError(
+            f"{label} raw native-wall measurement contract is invalid"
+        )
+
+    wall_values: list[float] = []
+    native_durations: list[float] = []
+    caller_durations: list[float] = []
+    previous_finished: dt.datetime | None = None
+    for block_index, raw_block in enumerate(blocks):
+        block_label = (
+            f"{label}.inner_native_wall_blocks.blocks[{block_index}]"
+        )
+        block = _validate_content_address(raw_block, block_label)
+        native = _positive_number(
+            block.get("native_wall_seconds"),
+            f"{block_label}.native_wall_seconds",
+        )
+        wall = _positive_number(
+            block.get("wall_seconds_per_point"),
+            f"{block_label}.wall_seconds_per_point",
+        )
+        caller = _positive_number(
+            block.get("caller_elapsed_seconds"),
+            f"{block_label}.caller_elapsed_seconds",
+        )
+        if (
+            block.get("block_index") != block_index
+            or block.get("repetitions") != repetitions
+            or block.get("batch_size") != batch_size
+            or block.get("evaluation_count") != repetitions
+            or block.get("evaluated_point_count") != repetitions * batch_size
+            or caller < native
+            or not math.isclose(
+                wall,
+                native / (repetitions * batch_size),
+                rel_tol=1.0e-15,
+                abs_tol=0.0,
+            )
+        ):
+            raise EvidenceError(f"{block_label} is internally inconsistent")
+        block_started = _utc_timestamp(
+            block.get("started_at_utc"),
+            f"{block_label}.started_at_utc",
+        )
+        block_finished = _utc_timestamp(
+            block.get("finished_at_utc"),
+            f"{block_label}.finished_at_utc",
+        )
+        if (
+            block_started > block_finished
+            or (
+                previous_finished is not None
+                and previous_finished > block_started
+            )
+        ):
+            raise EvidenceError(f"{block_label} timestamps are inverted")
+        previous_finished = block_finished
+        wall_values.append(wall)
+        native_durations.append(native)
+        caller_durations.append(caller)
+
+    recomputed_median = statistics.median(wall_values)
+    recomputed_mad = statistics.median(
+        abs(value - recomputed_median) for value in wall_values
+    )
+    if (
+        sum(native_durations) != observed_duration
+        or sum(caller_durations) != observed_caller_duration
+        or observed_duration < MINIMUM_TARGET_RUNTIME_SECONDS
+        or _positive_number(
+            raw.get("wall_seconds_per_point_median"),
+            f"{label}.inner_native_wall_blocks.wall_seconds_per_point_median",
+        )
+        != recomputed_median
+        or _nonnegative_number(
+            raw.get("wall_seconds_per_point_mad"),
+            f"{label}.inner_native_wall_blocks.wall_seconds_per_point_mad",
+        )
+        != recomputed_mad
+        or sample_wall != recomputed_median
+        or sample.get("internal_sample_count") != block_count
+        or sample.get("repetitions_per_sample") != repetitions
+        or sample.get("evaluation_count") != evaluation_count
+        or sample.get("evaluated_point_count") != evaluated_point_count
+    ):
+        raise EvidenceError(
+            f"{label} raw native-wall duration/statistics are not reproducible"
+        )
+
+
+def _extract_cell(
+    *,
+    aggregate: Mapping[str, Any],
+    mode: str,
+    batch_size: int,
+    subprocess_samples: int,
+    internal_samples: int,
+    warmups: int,
+    target_runtime: float,
+    fixture_points_sha256: str,
+    schedule_by_index: Mapping[int, Mapping[str, Any]],
+    seen_addresses: set[str],
+    label: str,
+) -> CellEvidence:
+    if aggregate.get("batch_size") != batch_size:
+        raise EvidenceError(f"{label}.batch_size does not match its inventory slot")
+    samples = _sequence(
+        aggregate.get("subprocess_samples"), f"{label}.subprocess_samples"
+    )
+    if len(samples) != subprocess_samples:
+        raise EvidenceError(
+            f"{label} has {len(samples)} subprocess samples, but its campaign "
+            f"declares {subprocess_samples}"
+        )
+    runtime_values: list[float] = []
+    cold_values: list[float] = []
+    cold_rss_values: list[float] = []
+    profiled_rss_values: list[float] = []
+    by_round: dict[int, float] = {}
+    for sample_index, raw_sample in enumerate(samples):
+        sample_label = f"{label}.subprocess_samples[{sample_index}]"
+        sample = _mapping(raw_sample, sample_label)
+        round_index = _exact_int(
+            sample.get("round"), f"{sample_label}.round", minimum=0
+        )
+        if round_index in by_round:
+            raise EvidenceError(f"{label} duplicates subprocess round {round_index}")
+        schedule_index = _exact_int(
+            sample.get("schedule_index"),
+            f"{sample_label}.schedule_index",
+            minimum=0,
+        )
+        schedule_entry = schedule_by_index.get(schedule_index)
+        if schedule_entry is None:
+            raise EvidenceError(
+                f"{sample_label} has no matching profile schedule entry"
+            )
+        if (
+            schedule_entry.get("mode") != mode
+            or schedule_entry.get("batch_size") != batch_size
+            or schedule_entry.get("round") != round_index
+        ):
+            raise EvidenceError(f"{sample_label} does not match its schedule slot")
+        if sample.get("interrupted") is not False:
+            raise EvidenceError(f"{sample_label} was interrupted")
+        timing = _mapping(
+            sample.get("timing_configuration"),
+            f"{sample_label}.timing_configuration",
+        )
+        sample_warmups = _exact_int(
+            timing.get("warmup_runs"),
+            f"{sample_label}.timing_configuration.warmup_runs",
+            minimum=MINIMUM_WARMUPS,
+        )
+        sample_target = _positive_number(
+            timing.get("target_runtime_seconds"),
+            f"{sample_label}.timing_configuration.target_runtime_seconds",
+        )
+        sample_internal_minimum = _exact_int(
+            timing.get("minimum_internal_samples"),
+            f"{sample_label}.timing_configuration.minimum_internal_samples",
+            minimum=MINIMUM_INTERNAL_SAMPLES,
+        )
+        if (
+            sample_warmups != warmups
+            or sample_target != target_runtime
+            or sample_internal_minimum != internal_samples
+        ):
+            raise EvidenceError(f"{sample_label} timing configuration drifted")
+        _exact_int(
+            sample.get("internal_sample_count"),
+            f"{sample_label}.internal_sample_count",
+            minimum=MINIMUM_INTERNAL_SAMPLES,
+        )
+        sources = _mapping(
+            sample.get("timing_sources"), f"{sample_label}.timing_sources"
+        )
+        if sources.get("wall") != "runtime_core_repeated_wall_time":
+            raise EvidenceError(
+                f"{sample_label} is not an unprofiled native-wall sample"
+            )
+
+        runtime = _positive_number(
+            sample.get("wall_seconds_per_point"),
+            f"{sample_label}.wall_seconds_per_point",
+        )
+        _validate_raw_native_wall_measurement(
+            sample,
+            batch_size=batch_size,
+            internal_samples=internal_samples,
+            warmups=warmups,
+            target_runtime=target_runtime,
+            sample_wall=runtime,
+            fixture_points_sha256=fixture_points_sha256,
+            label=sample_label,
+        )
+        if "cold_load_seconds" not in sample:
+            raise EvidenceError(
+                f"{sample_label} lacks cold_load_seconds. The capture predates "
+                "the resource-evidence contract; re-run the baseline/candidate "
+                "recurrence_z6g campaign with the current harness before comparing."
+            )
+        cold = _positive_number(
+            sample.get("cold_load_seconds"),
+            f"{sample_label}.cold_load_seconds",
+        )
+        if (
+            "peak_rss_after_cold_load" not in sample
+            or "peak_rss_after_profile" not in sample
+        ):
+            raise EvidenceError(
+                f"{sample_label} lacks cold-load/profile RSS evidence. Re-run "
+                "the baseline/candidate recurrence_z6g campaign with the current "
+                "harness before comparing."
+            )
+        cold_rss = _rss_observation(
+            sample.get("peak_rss_after_cold_load"),
+            f"{sample_label}.peak_rss_after_cold_load",
+        )
+        profiled_rss = _rss_observation(
+            sample.get("peak_rss_after_profile"),
+            f"{sample_label}.peak_rss_after_profile",
+        )
+        _validate_sample_address(sample, schedule_entry, sample_label, seen_addresses)
+        runtime_values.append(runtime)
+        cold_values.append(cold)
+        cold_rss_values.append(cold_rss)
+        profiled_rss_values.append(profiled_rss)
+        by_round[round_index] = runtime
+    expected_rounds = set(range(subprocess_samples))
+    if set(by_round) != expected_rounds:
+        raise EvidenceError(f"{label} does not retain exactly one sample per round")
+
+    runtime_distribution = _distribution(runtime_values, f"{label}.runtime")
+    cold_distribution = _distribution(cold_values, f"{label}.cold_load")
+    cold_rss_distribution = _distribution(cold_rss_values, f"{label}.cold_load_rss")
+    profiled_rss_distribution = _distribution(
+        profiled_rss_values,
+        f"{label}.profiled_rss",
+    )
+    if aggregate.get("statistics_contract") != "subprocess-median-and-raw-mad-v1":
+        raise EvidenceError(f"{label} has an unsupported statistics contract")
+    if (
+        aggregate.get("resource_statistics_contract")
+        != "subprocess-median-and-raw-mad-v1"
+    ):
+        raise EvidenceError(f"{label} has an unsupported resource statistics contract")
+    if aggregate.get("interrupted") is not False:
+        raise EvidenceError(f"{label} aggregate is interrupted")
+    if (
+        aggregate.get("sample_count") != subprocess_samples
+        or aggregate.get("subprocess_sample_count") != subprocess_samples
+    ):
+        raise EvidenceError(f"{label} aggregate sample count is inconsistent")
+    _recorded_statistic(
+        aggregate.get("wall_seconds_per_point_median"),
+        runtime_distribution.median,
+        f"{label}.wall_seconds_per_point_median",
+    )
+    _recorded_statistic(
+        aggregate.get("wall_seconds_per_point_mad"),
+        runtime_distribution.raw_mad,
+        f"{label}.wall_seconds_per_point_mad",
+    )
+    _recorded_statistic(
+        aggregate.get("cold_load_seconds_median"),
+        cold_distribution.median,
+        f"{label}.cold_load_seconds_median",
+    )
+    _recorded_statistic(
+        aggregate.get("cold_load_seconds_mad"),
+        cold_distribution.raw_mad,
+        f"{label}.cold_load_seconds_mad",
+    )
+    _recorded_statistic(
+        aggregate.get("cold_load_peak_rss_bytes_median"),
+        cold_rss_distribution.median,
+        f"{label}.cold_load_peak_rss_bytes_median",
+    )
+    _recorded_statistic(
+        aggregate.get("profiled_peak_rss_bytes_median"),
+        profiled_rss_distribution.median,
+        f"{label}.profiled_peak_rss_bytes_median",
+    )
+    return CellEvidence(
+        runtime=runtime_distribution,
+        cold_load=cold_distribution,
+        cold_load_rss=cold_rss_distribution,
+        profiled_rss=profiled_rss_distribution,
+        by_round=by_round,
+    )
+
+
+def _validate_paired_profile_coordination(
+    payload: Mapping[str, Any],
+    *,
+    role: str,
+    layout: str,
+    revision: str,
+    schedule_by_index: Mapping[int, Mapping[str, Any]],
+) -> Mapping[str, object]:
+    label = f"{role}/{layout}.paired_profile_coordination"
+    coordination = _mapping(payload.get("paired_profile_coordination"), label)
+    if (
+        coordination.get("kind") != "pyamplicol-paired-profile-coordination"
+        or coordination.get("schema_version") != 1
+        or coordination.get("role") != role
+        or coordination.get("layout") != layout
+    ):
+        raise EvidenceError(f"{label} has an unsupported identity")
+    session_id = _string(coordination.get("session_id"), f"{label}.session_id")
+    ready = _validate_content_address(
+        coordination.get("ready_record"),
+        f"{label}.ready_record",
+    )
+    plan = _sequence(
+        ready.get("profile_schedule_plan"),
+        f"{label}.ready_record.profile_schedule_plan",
+    )
+    expected_plan = [
+        {
+            field: schedule_by_index[index].get(field)
+            for field in ("schedule_index", "round", "mode", "batch_size")
+        }
+        for index in sorted(schedule_by_index)
+    ]
+    if (
+        ready.get("kind") != "pyamplicol-paired-profile-ready"
+        or ready.get("schema_version") != 1
+        or ready.get("session_id") != session_id
+        or ready.get("role") != role
+        or ready.get("layout") != layout
+        or ready.get("source_revision") != revision
+        or list(plan) != expected_plan
+        or ready.get("profile_schedule_plan_sha256") != _sha256(expected_plan)
+    ):
+        raise EvidenceError(f"{label} ready record does not bind the capture")
+    ready_at = _utc_timestamp(
+        ready.get("ready_at_utc"),
+        f"{label}.ready_record.ready_at_utc",
+    )
+    raw_completions = _sequence(
+        coordination.get("completion_records"),
+        f"{label}.completion_records",
+    )
+    if len(raw_completions) != len(schedule_by_index):
+        raise EvidenceError(f"{label} completion inventory is incomplete")
+    slots: dict[int, dict[str, object]] = {}
+    for index, entry in schedule_by_index.items():
+        token = _validate_content_address(
+            entry.get("paired_profile_token"),
+            f"{label}.slots[{index}].token",
+        )
+        completion = _validate_content_address(
+            entry.get("paired_profile_completion"),
+            f"{label}.slots[{index}].completion",
+        )
+        expected = {
+            "session_id": session_id,
+            "role": role,
+            "layout": layout,
+            "schedule_index": index,
+            "round": entry.get("round"),
+            "mode": entry.get("mode"),
+            "batch_size": entry.get("batch_size"),
+        }
+        if (
+            token.get("kind") != "pyamplicol-paired-profile-token"
+            or token.get("schema_version") != 1
+            or completion.get("kind") != "pyamplicol-paired-profile-completion"
+            or completion.get("schema_version") != 1
+            or any(token.get(field) != value for field, value in expected.items())
+            or any(completion.get(field) != value for field, value in expected.items())
+            or completion.get("token_sha256") != token.get("content_sha256")
+        ):
+            raise EvidenceError(f"{label} slot {index} changed paired coordinates")
+        (
+            invocation,
+            _,
+            invocation_sha256,
+            process_sha256,
+            result_sha256,
+        ) = _validated_schedule_worker_records(
+            entry,
+            f"{label}.slots[{index}]",
+        )
+        if (
+            completion.get("worker_invocation_sha256") != invocation_sha256
+            or completion.get("worker_result_record_sha256") != result_sha256
+            or completion.get("worker_started_at_utc")
+            != invocation.get("started_at_utc")
+            or completion.get("worker_finished_at_utc")
+            != invocation.get("finished_at_utc")
+        ):
+            raise EvidenceError(
+                f"{label} slot {index} completion is not bound to its worker"
+            )
+        issued = _utc_timestamp(
+            token.get("issued_at_utc"),
+            f"{label}.slots[{index}].token.issued_at_utc",
+        )
+        started = _utc_timestamp(
+            completion.get("worker_started_at_utc"),
+            f"{label}.slots[{index}].completion.worker_started_at_utc",
+        )
+        finished = _utc_timestamp(
+            completion.get("worker_finished_at_utc"),
+            f"{label}.slots[{index}].completion.worker_finished_at_utc",
+        )
+        recorded = _utc_timestamp(
+            completion.get("recorded_at_utc"),
+            f"{label}.slots[{index}].completion.recorded_at_utc",
+        )
+        if not ready_at <= issued <= started <= finished <= recorded:
+            raise EvidenceError(f"{label} slot {index} timestamps are inverted")
+        slots[index] = {
+            "token": dict(token),
+            "completion": dict(completion),
+            "issued": issued,
+            "started": started,
+            "finished": finished,
+            "recorded": recorded,
+            "worker_invocation_sha256": invocation_sha256,
+            "worker_process_record_sha256": process_sha256,
+            "worker_result_record_sha256": result_sha256,
+        }
+    if list(raw_completions) != [slots[index]["completion"] for index in sorted(slots)]:
+        raise EvidenceError(f"{label} completion summary differs from its schedule")
+    return {
+        "session_id": session_id,
+        "role": role,
+        "layout": layout,
+        "slots": slots,
+        "ready_at": ready_at,
+        "ready_record": dict(ready),
+    }
+
+
+def _validate_capture(
+    payload: Mapping[str, Any],
+    input_identity: Mapping[str, object],
+    *,
+    role: str,
+    expected_layout: str,
+) -> CaptureEvidence:
+    label = f"{role}/{expected_layout}"
+    if payload.get("kind") != CAPTURE_KIND:
+        raise EvidenceError(f"{label} has the wrong capture kind")
+    schema = _exact_int(payload.get("schema_version"), f"{label}.schema_version")
+    if schema < MINIMUM_CAPTURE_SCHEMA:
+        raise EvidenceError(
+            f"{label} schema {schema} predates the required raw-evidence contract"
+        )
+    logical_process = _logical_process(payload.get("process"), f"{label}.process")
+    expected_workload = (
+        "single-runtime-selected-flow/helicity-sum"
+        if expected_layout == "topology-replay"
+        else "all-flows/runtime-selected-single-helicity"
+    )
+    if payload.get("workload") != expected_workload:
+        raise EvidenceError(f"{label} has the wrong workload")
+
+    configuration = _mapping(payload.get("configuration"), f"{label}.configuration")
+    if configuration.get("lc_flow_layout") != expected_layout:
+        raise EvidenceError(f"{label} is in the wrong layout slot")
+    if configuration.get("generation_only") is not False:
+        raise EvidenceError(f"{label} is a generation-only capture")
+    configured_modes = list(
+        _sequence(configuration.get("modes"), f"{label}.configuration.modes")
+    )
+    allowed_modes = {*CAPTURE_MODES, *DIAGNOSTIC_MODES}
+    if set(configured_modes) != allowed_modes or len(configured_modes) != len(
+        set(configured_modes)
+    ):
+        raise EvidenceError(
+            f"{label} must contain compiled, recurrence, and eager exactly once"
+        )
+    configured_batches = tuple(
+        _exact_int(value, f"{label}.configuration.batch_sizes")
+        for value in _sequence(
+            configuration.get("batch_sizes"),
+            f"{label}.configuration.batch_sizes",
+        )
+    )
+    if len(configured_batches) != len(BATCH_SIZES) or set(configured_batches) != set(
+        BATCH_SIZES
+    ):
+        raise EvidenceError(f"{label} must contain exactly batches {list(BATCH_SIZES)}")
+    subprocess_samples = _exact_int(
+        configuration.get("subprocess_samples"),
+        f"{label}.configuration.subprocess_samples",
+        minimum=MINIMUM_SUBPROCESS_SAMPLES,
+    )
+    if subprocess_samples != MINIMUM_SUBPROCESS_SAMPLES:
+        raise EvidenceError(
+            f"{label} must retain exactly {MINIMUM_SUBPROCESS_SAMPLES} "
+            "independent subprocess pairs"
+        )
+    internal_samples = _exact_int(
+        configuration.get("minimum_samples"),
+        f"{label}.configuration.minimum_samples",
+        minimum=MINIMUM_INTERNAL_SAMPLES,
+    )
+    warmups = _exact_int(
+        configuration.get("warmup_runs"),
+        f"{label}.configuration.warmup_runs",
+        minimum=MINIMUM_WARMUPS,
+    )
+    if warmups != MINIMUM_WARMUPS:
+        raise EvidenceError(
+            f"{label} must use exactly {MINIMUM_WARMUPS} warmup runs"
+        )
+    target_runtime = _positive_number(
+        configuration.get("target_runtime_seconds"),
+        f"{label}.configuration.target_runtime_seconds",
+    )
+    if target_runtime < MINIMUM_TARGET_RUNTIME_SECONDS:
+        raise EvidenceError(
+            f"{label} target runtime is below {MINIMUM_TARGET_RUNTIME_SECONDS:g}s"
+        )
+    if configuration.get("jit_optimization_level") != 3:
+        raise EvidenceError(f"{label} compiled JIT is not configured for O3")
+    acceptance = _validate_capture_acceptance(
+        payload,
+        configuration,
+        expected_layout=expected_layout,
+        subprocess_samples=subprocess_samples,
+        internal_samples=internal_samples,
+        warmups=warmups,
+        configured_modes=configured_modes,
+    )
+    selected_union_projection = _capture_semantic_projection(
+        acceptance,
+        configuration=configuration,
+        logical_process=logical_process,
+        layout=expected_layout,
+        label=label,
+    )
+
+    source = _mapping(payload.get("source"), f"{label}.source")
+    revision = _string(source.get("revision"), f"{label}.source.revision")
+    if len(revision) != _REVISION_LENGTH:
+        raise EvidenceError(f"{label}.source.revision is not a full Git revision")
+    try:
+        int(revision, 16)
+    except ValueError as error:
+        raise EvidenceError(f"{label}.source.revision is not a Git revision") from error
+    if (
+        source.get("dirty") is not False
+        or source.get("untracked_files_checked") is not True
+    ):
+        raise EvidenceError(f"{label} source checkout is not clean and authenticated")
+
+    provenance = _mapping(payload.get("provenance"), f"{label}.provenance")
+    host = dict(_mapping(provenance.get("host"), f"{label}.provenance.host"))
+    runtime = _mapping(payload.get("runtime_provenance"), f"{label}.runtime_provenance")
+    interpreter = _mapping(
+        runtime.get("interpreter"), f"{label}.runtime_provenance.interpreter"
+    )
+    native_extension = _mapping(
+        runtime.get("native_extension"),
+        f"{label}.runtime_provenance.native_extension",
+    )
+    build_info = _mapping(
+        _mapping(
+            runtime.get("active_build_info"),
+            f"{label}.runtime_provenance.active_build_info",
+        ).get("payload"),
+        f"{label}.runtime_provenance.active_build_info.payload",
+    )
+    if build_info.get("source_revision") != revision:
+        raise EvidenceError(
+            f"{label} installed build does not match its source revision"
+        )
+    build_identity = {
+        "source_revision": revision,
+        "native_extension_sha256": _valid_sha256(
+            native_extension.get("sha256"),
+            f"{label}.runtime_provenance.native_extension.sha256",
+        ),
+        "native_build_inputs_sha256": _valid_sha256(
+            native_extension.get("build_inputs_sha256"),
+            f"{label}.runtime_provenance.native_extension.build_inputs_sha256",
+        ),
+        "package_version": _string(
+            native_extension.get("package_version"),
+            f"{label}.runtime_provenance.native_extension.package_version",
+        ),
+        "build_info_version": _string(
+            build_info.get("version"),
+            f"{label}.runtime_provenance.active_build_info.payload.version",
+        ),
+    }
+    interpreter_identity = {
+        "implementation": _string(
+            interpreter.get("implementation"),
+            f"{label}.runtime_provenance.interpreter.implementation",
+        ),
+        "python_version": _string(
+            interpreter.get("python_version"),
+            f"{label}.runtime_provenance.interpreter.python_version",
+        ),
+        "executable_sha256": _valid_sha256(
+            interpreter.get("sha256"),
+            f"{label}.runtime_provenance.interpreter.sha256",
+        ),
+    }
+    interpreter_path = _string(
+        interpreter.get("path"),
+        f"{label}.runtime_provenance.interpreter.path",
+    )
+    interpreter_resolved_path = _string(
+        interpreter.get("resolved_path"),
+        f"{label}.runtime_provenance.interpreter.resolved_path",
+    )
+    model_identities = _mapping(
+        configuration.get("model_identities"),
+        f"{label}.configuration.model_identities",
+    )
+    if set(model_identities) != set(configured_modes):
+        raise EvidenceError(
+            f"{label} prepared-model identity inventory is incomplete"
+        )
+    prepared_paths: set[str] = set()
+    prepared_hashes: set[str] = set()
+    for mode in configured_modes:
+        model_identity = _mapping(
+            model_identities.get(mode),
+            f"{label}.configuration.model_identities.{mode}",
+        )
+        if model_identity.get("kind") != "explicit-prepared-model":
+            raise EvidenceError(
+                f"{label} paired campaign did not use an explicit prepared model"
+            )
+        model_file = _mapping(
+            model_identity.get("file"),
+            f"{label}.configuration.model_identities.{mode}.file",
+        )
+        prepared_paths.add(
+            _string(
+                model_file.get("resolved_path"),
+                f"{label}.configuration.model_identities.{mode}.file.resolved_path",
+            )
+        )
+        prepared_hashes.add(
+            _valid_sha256(
+                model_file.get("sha256"),
+                f"{label}.configuration.model_identities.{mode}.file.sha256",
+            )
+        )
+    if len(prepared_paths) != 1 or len(prepared_hashes) != 1:
+        raise EvidenceError(f"{label} modes use different prepared model packs")
+    prepared_model_path = prepared_paths.pop()
+    prepared_model_sha256 = prepared_hashes.pop()
+
+    schedule = _mapping(payload.get("profile_schedule"), f"{label}.profile_schedule")
+    if (
+        schedule.get("kind") != "pyamplicol-interleaved-subprocess-profile-schedule"
+        or schedule.get("schema_version") != 2
+        or schedule.get("algorithm")
+        != "round-major-cyclic-mode-and-batch-interleave-v1"
+        or schedule.get("sample_unit") != "independent-profile-worker-subprocess"
+        or schedule.get("subprocess_samples_per_cell") != subprocess_samples
+        or set(
+            _sequence(
+                schedule.get("modes"),
+                f"{label}.profile_schedule.modes",
+            )
+        )
+        != set(configured_modes)
+        or set(
+            _sequence(
+                schedule.get("batch_sizes"),
+                f"{label}.profile_schedule.batch_sizes",
+            )
+        )
+        != set(BATCH_SIZES)
+    ):
+        raise EvidenceError(f"{label} profile schedule identity is inconsistent")
+    entries = _sequence(schedule.get("entries"), f"{label}.profile_schedule.entries")
+    expected_entry_count = len(configured_modes) * len(BATCH_SIZES) * subprocess_samples
+    if len(entries) != expected_entry_count:
+        raise EvidenceError(
+            f"{label} profile schedule has {len(entries)} entries; "
+            f"{expected_entry_count} are required"
+        )
+    schedule_by_index: dict[int, Mapping[str, Any]] = {}
+    for position, raw_entry in enumerate(entries):
+        entry = _mapping(raw_entry, f"{label}.profile_schedule.entries[{position}]")
+        index = _exact_int(
+            entry.get("schedule_index"),
+            f"{label}.profile_schedule.entries[{position}].schedule_index",
+            minimum=0,
+        )
+        if index != position or index in schedule_by_index:
+            raise EvidenceError(f"{label} profile schedule index is not canonical")
+        schedule_by_index[index] = entry
+    paired_profile_coordination = _validate_paired_profile_coordination(
+        payload,
+        role=role,
+        layout=expected_layout,
+        revision=revision,
+        schedule_by_index=schedule_by_index,
+    )
+
+    generations = _mapping(payload.get("generation"), f"{label}.generation")
+    raw_profiles = _mapping(payload.get("profiles"), f"{label}.profiles")
+    if set(generations) != set(configured_modes) or set(raw_profiles) != set(
+        configured_modes
+    ):
+        raise EvidenceError(
+            f"{label} three-lane generation/profile inventory is incomplete"
+        )
+    generation_evidence: dict[str, GenerationEvidence] = {}
+    workload_identities: dict[str, Mapping[str, object]] = {}
+    cells: dict[tuple[str, int], CellEvidence] = {}
+    seen_addresses: set[str] = set()
+    eager_acceptance = _mapping(
+        acceptance.get("eager_diagnostic"),
+        f"{label}.capture_acceptance.eager_diagnostic",
+    )
+    eager_admissible = bool(
+        "eager" in configured_modes
+        and eager_acceptance.get("complete") is True
+        and eager_acceptance.get("passes") is True
+    )
+    parsed_modes = (*CAPTURE_MODES, "eager") if eager_admissible else CAPTURE_MODES
+    for mode in parsed_modes:
+        generation = _mapping(generations.get(mode), f"{label}.generation.{mode}")
+        if generation.get("mode") != mode:
+            raise EvidenceError(f"{label}.generation.{mode} has the wrong mode")
+        if generation.get("generation_reused") is not False:
+            raise EvidenceError(
+                f"{label}.generation.{mode} was reused; a fresh generation "
+                "time is required"
+            )
+        generation_wall = _positive_number(
+            generation.get("generation_wall_seconds"),
+            f"{label}.generation.{mode}.generation_wall_seconds",
+        )
+        stats = _mapping(
+            generation.get("artifact_stats"),
+            f"{label}.generation.{mode}.artifact_stats",
+        )
+        _exact_int(
+            stats.get("file_count"),
+            f"{label}.generation.{mode}.artifact_stats.file_count",
+            minimum=1,
+        )
+        payload_size = _exact_int(
+            stats.get("size_bytes"),
+            f"{label}.generation.{mode}.artifact_stats.size_bytes",
+            minimum=1,
+        )
+        generation_peak = int(
+            _rss_observation(
+                generation.get("peak_rss"),
+                f"{label}.generation.{mode}.peak_rss",
+            )
+        )
+        generation_evidence[mode] = GenerationEvidence(
+            wall_seconds=generation_wall,
+            payload_size_bytes=payload_size,
+            peak_rss_bytes=generation_peak,
+        )
+
+        profile = _mapping(raw_profiles.get(mode), f"{label}.profiles.{mode}")
+        workload_identities[mode] = _workload_identity(
+            profile=profile,
+            generation=generation,
+            mode=mode,
+            layout=expected_layout,
+            logical_process=logical_process,
+            expected_workload=expected_workload,
+            selected_union_projection=selected_union_projection,
+            label=f"{label}.profiles.{mode}",
+        )
+        validation_fixture = _mapping(
+            workload_identities[mode].get("validation_fixture"),
+            f"{label}.profiles.{mode}.validation_fixture",
+        )
+        fixture_points_sha256 = _valid_sha256(
+            validation_fixture.get("points_sha256"),
+            f"{label}.profiles.{mode}.validation_fixture.points_sha256",
+        )
+        aggregates = _sequence(
+            profile.get("profiles"),
+            f"{label}.profiles.{mode}.profiles",
+        )
+        by_batch: dict[int, Mapping[str, Any]] = {}
+        for aggregate_index, raw_aggregate in enumerate(aggregates):
+            aggregate = _mapping(
+                raw_aggregate,
+                f"{label}.profiles.{mode}.profiles[{aggregate_index}]",
+            )
+            batch = _exact_int(
+                aggregate.get("batch_size"),
+                f"{label}.profiles.{mode}.profiles[{aggregate_index}].batch_size",
+                minimum=1,
+            )
+            if batch in by_batch:
+                raise EvidenceError(f"{label}.profiles.{mode} duplicates batch {batch}")
+            by_batch[batch] = aggregate
+        if set(by_batch) != set(BATCH_SIZES):
+            raise EvidenceError(
+                f"{label}.profiles.{mode} does not contain exactly {list(BATCH_SIZES)}"
+            )
+        for batch_size in BATCH_SIZES:
+            cells[(mode, batch_size)] = _extract_cell(
+                aggregate=by_batch[batch_size],
+                mode=mode,
+                batch_size=batch_size,
+                subprocess_samples=subprocess_samples,
+                internal_samples=internal_samples,
+                warmups=warmups,
+                target_runtime=target_runtime,
+                fixture_points_sha256=fixture_points_sha256,
+                schedule_by_index=schedule_by_index,
+                seen_addresses=seen_addresses,
+                label=f"{label}.profiles.{mode}.batch[{batch_size}]",
+            )
+
+    # Each round must retain exactly one independently scheduled subprocess for
+    # every lane and batch. Compiled/recurrence ratios are paired by this
+    # shared round identity, and eager is independently evaluated below.
+    for batch_size in BATCH_SIZES:
+        for round_index in range(subprocess_samples):
+            pair = [
+                entry
+                for entry in schedule_by_index.values()
+                if entry.get("batch_size") == batch_size
+                and entry.get("round") == round_index
+                and entry.get("mode") in configured_modes
+            ]
+            if len(pair) != len(configured_modes) or {
+                entry.get("mode") for entry in pair
+            } != set(configured_modes):
+                raise EvidenceError(
+                    f"{label} batch {batch_size} round {round_index} does not "
+                    "contain one subprocess for every capture lane"
+                )
+
+    campaign_identity = {
+        "logical_process": logical_process,
+        "layout": expected_layout,
+        "workload": expected_workload,
+        "batch_sizes": list(BATCH_SIZES),
+        "subprocess_samples": subprocess_samples,
+        "minimum_internal_samples": configuration.get("minimum_samples"),
+        "warmup_runs": warmups,
+        "target_runtime_seconds": target_runtime,
+        "color_flow_request": configuration.get("color_flow_request"),
+        "helicity_request": configuration.get("helicity_request"),
+        "validation_seed": configuration.get("validation_seed"),
+        "point_tile_size": configuration.get("point_tile_size"),
+        "interpreter": interpreter_identity,
+        "configured_modes": list(configured_modes),
+    }
+    addressed_input_identity = dict(input_identity)
+    addressed_input_identity["capture_acceptance_sha256"] = _sha256(acceptance)
+    return CaptureEvidence(
+        input_identity=addressed_input_identity,
+        layout=expected_layout,
+        logical_process=logical_process,
+        source_revision=revision,
+        build_identity=build_identity,
+        host_identity=host,
+        campaign_identity=campaign_identity,
+        workload_identities=workload_identities,
+        cells=cells,
+        generation=generation_evidence,
+        configured_modes=tuple(configured_modes),
+        paired_profile_coordination=paired_profile_coordination,
+        eager_diagnostic=dict(eager_acceptance),
+        interpreter_path=interpreter_path,
+        interpreter_resolved_path=interpreter_resolved_path,
+        prepared_model_path=prepared_model_path,
+        prepared_model_sha256=prepared_model_sha256,
+    )
+
+
+def _geometric_mean(values: Sequence[float], label: str) -> float:
+    checked = [_positive_number(value, label) for value in values]
+    if not checked:
+        raise EvidenceError(f"{label} is empty")
+    return math.exp(math.fsum(math.log(value) for value in checked) / len(checked))
+
+
+def _runtime_cell_comparison(
+    *,
+    layout: str,
+    mode: str,
+    batch_size: int,
+    baseline: CellEvidence,
+    candidate: CellEvidence,
+) -> dict[str, object]:
+    relative_limit = RUNTIME_RELATIVE_LIMIT * baseline.runtime.median
+    noise_limit = (
+        baseline.runtime.median
+        + RUNTIME_NOISE_MAD_MULTIPLIER * baseline.runtime.raw_mad
+    )
+    passes_relative = candidate.runtime.median <= relative_limit
+    passes_noise = candidate.runtime.median <= noise_limit
+    gain_at_least_ten_percent = (
+        candidate.runtime.median
+        <= (1.0 - RESOURCE_EXCEPTION_GAIN) * baseline.runtime.median
+    )
+    gain_beyond_noise = (
+        candidate.runtime.median
+        <= baseline.runtime.median
+        - RUNTIME_NOISE_MAD_MULTIPLIER * baseline.runtime.raw_mad
+    )
+    return {
+        "layout": layout,
+        "mode": mode,
+        "batch_size": batch_size,
+        "baseline": baseline.runtime.as_dict(),
+        "candidate": candidate.runtime.as_dict(),
+        "candidate_to_baseline_ratio": (
+            candidate.runtime.median / baseline.runtime.median
+        ),
+        "relative_limit_seconds_per_point": relative_limit,
+        "noise_limit_seconds_per_point": noise_limit,
+        "passes_relative_limit": passes_relative,
+        "passes_noise_limit": passes_noise,
+        "passes": passes_relative and passes_noise,
+        "resource_exception_runtime_gain": {
+            "gain_at_least_10_percent": gain_at_least_ten_percent,
+            "gain_beyond_3_baseline_raw_mad": gain_beyond_noise,
+            "passes": gain_at_least_ten_percent and gain_beyond_noise,
+        },
+    }
+
+
+def _paired_ratio(
+    *,
+    layout: str,
+    batch_size: int,
+    capture: CaptureEvidence,
+) -> dict[str, object]:
+    compiled = capture.cells[("compiled", batch_size)].by_round
+    recurrence = capture.cells[("recurrence", batch_size)].by_round
+    if set(compiled) != set(recurrence):
+        raise EvidenceError(
+            f"{layout} batch {batch_size} compiled/recurrence rounds do not match"
+        )
+    rounds = sorted(compiled)
+    ratios = [compiled[round_index] / recurrence[round_index] for round_index in rounds]
+    distribution = _distribution(ratios, f"{layout}/{batch_size} paired ratio")
+    upper_bound = (
+        distribution.median + RUNTIME_NOISE_MAD_MULTIPLIER * distribution.raw_mad
+    )
+    return {
+        "rounds": rounds,
+        "compiled_to_recurrence_ratio": distribution.as_dict(),
+        "median_plus_3_raw_mad": upper_bound,
+    }
+
+
+def _resource_comparison(
+    *,
+    layout: str,
+    mode: str,
+    metric: str,
+    baseline: Distribution,
+    candidate: Distribution,
+    runtime_gain: Mapping[str, object],
+    batch_size: int | None = None,
+) -> dict[str, object]:
+    ratio = candidate.median / baseline.median
+    within_growth_limit = ratio <= RESOURCE_GROWTH_LIMIT
+    exception = runtime_gain.get("passes") is True
+    result: dict[str, object] = {
+        "layout": layout,
+        "mode": mode,
+        "metric": metric,
+        "baseline": baseline.as_dict(),
+        "candidate": candidate.as_dict(),
+        "candidate_to_baseline_ratio": ratio,
+        "within_3_percent_growth_limit": within_growth_limit,
+        "runtime_gain_exception": dict(runtime_gain),
+        "passes": within_growth_limit or exception,
+    }
+    if batch_size is not None:
+        result["batch_size"] = batch_size
+    return result
+
+
+def _single_resource_comparison(
+    *,
+    layout: str,
+    mode: str,
+    metric: str,
+    baseline: float,
+    candidate: float,
+    runtime_gain: Mapping[str, object],
+) -> dict[str, object]:
+    baseline_distribution = Distribution((baseline,), baseline, 0.0)
+    candidate_distribution = Distribution((candidate,), candidate, 0.0)
+    return _resource_comparison(
+        layout=layout,
+        mode=mode,
+        metric=metric,
+        baseline=baseline_distribution,
+        candidate=candidate_distribution,
+        runtime_gain=runtime_gain,
+    )
+
+
+def _assert_role_consistency(
+    captures: Mapping[str, CaptureEvidence],
+    *,
+    role: str,
+) -> None:
+    topology = captures["topology-replay"]
+    union = captures["all-flow-union"]
+    if topology.source_revision != union.source_revision:
+        raise EvidenceError(f"{role} captures use different source revisions")
+    if topology.build_identity != union.build_identity:
+        raise EvidenceError(f"{role} captures use different native builds")
+    if topology.host_identity != union.host_identity:
+        raise EvidenceError(f"{role} captures were not measured on the same host")
+    if topology.logical_process != union.logical_process:
+        raise EvidenceError(f"{role} captures use different processes")
+    if topology.paired_profile_coordination.get(
+        "session_id"
+    ) != union.paired_profile_coordination.get("session_id"):
+        raise EvidenceError(f"{role} captures use different paired sessions")
+    topology_campaign = dict(topology.campaign_identity)
+    union_campaign = dict(union.campaign_identity)
+    for field in ("layout", "workload", "color_flow_request", "helicity_request"):
+        topology_campaign.pop(field, None)
+        union_campaign.pop(field, None)
+    if topology_campaign != union_campaign:
+        raise EvidenceError(f"{role} capture campaign configuration drifted by layout")
+
+
+def _assert_paired_role_order(
+    baseline: CaptureEvidence,
+    candidate: CaptureEvidence,
+    *,
+    layout: str,
+) -> None:
+    baseline_coordination = baseline.paired_profile_coordination
+    candidate_coordination = candidate.paired_profile_coordination
+    if baseline_coordination.get("session_id") != candidate_coordination.get(
+        "session_id"
+    ):
+        raise EvidenceError(f"{layout} roles use different paired sessions")
+    baseline_slots = _mapping(
+        baseline_coordination.get("slots"),
+        f"{layout}.baseline paired slots",
+    )
+    candidate_slots = _mapping(
+        candidate_coordination.get("slots"),
+        f"{layout}.candidate paired slots",
+    )
+    if set(baseline_slots) != set(candidate_slots):
+        raise EvidenceError(f"{layout} paired role slots differ")
+    previous_finished: dt.datetime | None = None
+    for index in sorted(baseline_slots):
+        baseline_slot = _mapping(
+            baseline_slots[index], f"{layout}.baseline paired slot {index}"
+        )
+        candidate_slot = _mapping(
+            candidate_slots[index], f"{layout}.candidate paired slot {index}"
+        )
+        baseline_token = _mapping(
+            baseline_slot.get("token"), f"{layout}.baseline token {index}"
+        )
+        candidate_token = _mapping(
+            candidate_slot.get("token"), f"{layout}.candidate token {index}"
+        )
+        coordinates = ("schedule_index", "round", "mode", "batch_size", "pair_index")
+        if (
+            any(
+                baseline_token.get(field) != candidate_token.get(field)
+                for field in coordinates
+            )
+            or baseline_token.get("pair_index") != index
+        ):
+            raise EvidenceError(f"{layout} paired slot {index} coordinates differ")
+        round_index = _exact_int(
+            baseline_token.get("round"),
+            f"{layout}.paired slot {index}.round",
+            minimum=0,
+        )
+        expected_order = (
+            ("baseline", "candidate")
+            if round_index % 2 == 0
+            else ("candidate", "baseline")
+        )
+        by_role = {
+            "baseline": baseline_slot,
+            "candidate": candidate_slot,
+        }
+        order_coordinates = tuple(
+            (
+                _exact_int(
+                    _mapping(
+                        by_role[role].get("token"),
+                        f"{layout}.{role} token {index}",
+                    ).get("order_in_pair"),
+                    f"{layout}.{role} token {index}.order_in_pair",
+                    minimum=0,
+                ),
+                role,
+            )
+            for role in ("baseline", "candidate")
+        )
+        if {order for order, _ in order_coordinates} != {0, 1}:
+            raise EvidenceError(
+                f"{layout} paired slot {index} has invalid role positions"
+            )
+        observed_order = tuple(role for _, role in sorted(order_coordinates))
+        if observed_order != expected_order:
+            raise EvidenceError(
+                f"{layout} paired slot {index} does not alternate role order"
+            )
+        for identity in (
+            "worker_invocation_sha256",
+            "worker_process_record_sha256",
+            "worker_result_record_sha256",
+        ):
+            if baseline_slot.get(identity) == candidate_slot.get(identity):
+                raise EvidenceError(
+                    f"{layout} paired slot {index} reuses {identity} "
+                    "identity across roles"
+                )
+        first = by_role[expected_order[0]]
+        second = by_role[expected_order[1]]
+        first_issued = first.get("issued")
+        first_started = first.get("started")
+        first_finished = first.get("finished")
+        second_issued = second.get("issued")
+        second_started = second.get("started")
+        second_finished = second.get("finished")
+        if not all(
+            isinstance(value, dt.datetime)
+            for value in (
+                first_issued,
+                first_started,
+                first_finished,
+                second_issued,
+                second_started,
+                second_finished,
+            )
+        ):
+            raise EvidenceError(f"{layout} paired slot {index} lacks timestamps")
+        assert isinstance(first_issued, dt.datetime)
+        assert isinstance(first_started, dt.datetime)
+        assert isinstance(first_finished, dt.datetime)
+        assert isinstance(second_issued, dt.datetime)
+        assert isinstance(second_started, dt.datetime)
+        assert isinstance(second_finished, dt.datetime)
+        if first_finished > second_issued:
+            raise EvidenceError(
+                f"{layout} paired slot {index} admitted the second role "
+                "before the first worker finished"
+            )
+        if first_finished > second_started:
+            raise EvidenceError(f"{layout} paired slot {index} workers overlap")
+        if previous_finished is not None and previous_finished > first_issued:
+            raise EvidenceError(f"{layout} paired slots overlap or reorder")
+        previous_finished = second_finished
+
+
+def _assert_cross_layout_sequence(
+    baseline: Mapping[str, CaptureEvidence],
+    candidate: Mapping[str, CaptureEvidence],
+) -> None:
+    topology_finished: list[dt.datetime] = []
+    for role, captures in (("baseline", baseline), ("candidate", candidate)):
+        slots = _mapping(
+            captures["topology-replay"].paired_profile_coordination.get("slots"),
+            f"{role} topology paired slots",
+        )
+        for index, raw_slot in slots.items():
+            finished = _mapping(
+                raw_slot,
+                f"{role} topology paired slot {index}",
+            ).get("finished")
+            if not isinstance(finished, dt.datetime):
+                raise EvidenceError(
+                    f"{role} topology paired slot {index} lacks a finish timestamp"
+                )
+            topology_finished.append(finished)
+    union_ready = [
+        captures["all-flow-union"].paired_profile_coordination.get("ready_at")
+        for captures in (baseline, candidate)
+    ]
+    if not topology_finished or not all(
+        isinstance(value, dt.datetime) for value in union_ready
+    ):
+        raise EvidenceError("paired campaign lacks cross-layout timestamps")
+    if max(topology_finished) > min(union_ready):
+        raise EvidenceError(
+            "paired campaign layouts overlap or reorder; all-flow-union became "
+            "ready before topology-replay completed"
+        )
+
+
+def _assert_global_worker_identity_separation(
+    baseline: Mapping[str, CaptureEvidence],
+    candidate: Mapping[str, CaptureEvidence],
+) -> None:
+    for identity in (
+        "worker_invocation_sha256",
+        "worker_process_record_sha256",
+        "worker_result_record_sha256",
+    ):
+        seen: dict[str, tuple[str, str, object]] = {}
+        for role, captures in (("baseline", baseline), ("candidate", candidate)):
+            for layout in LAYOUTS:
+                slots = _mapping(
+                    captures[layout].paired_profile_coordination.get("slots"),
+                    f"{role}/{layout} paired slots",
+                )
+                for index, raw_slot in slots.items():
+                    slot = _mapping(
+                        raw_slot,
+                        f"{role}/{layout} paired slot {index}",
+                    )
+                    digest = _valid_sha256(
+                        slot.get(identity),
+                        f"{role}/{layout} paired slot {index}.{identity}",
+                    )
+                    previous = seen.get(digest)
+                    if previous is not None:
+                        raise EvidenceError(
+                            f"{role}/{layout} paired slot {index} reuses {identity} "
+                            f"identity from {previous[0]}/{previous[1]} "
+                            f"slot {previous[2]}"
+                        )
+                    seen[digest] = (role, layout, index)
+
+
+def _assert_externally_pinned_role_inputs(
+    baseline: Mapping[str, CaptureEvidence],
+    candidate: Mapping[str, CaptureEvidence],
+    *,
+    expected_candidate_source_revision: str,
+    expected_baseline_native_build_inputs_sha256: str,
+    expected_candidate_native_build_inputs_sha256: str,
+    expected_baseline_prepared_model_sha256: str,
+    expected_candidate_prepared_model_sha256: str,
+) -> dict[str, object]:
+    expected_candidate_source_revision = _valid_revision(
+        expected_candidate_source_revision,
+        "expected candidate source revision",
+    )
+    expected = {
+        "baseline": {
+            "native_build_inputs_sha256": _valid_sha256(
+                expected_baseline_native_build_inputs_sha256,
+                "expected baseline native-build-input digest",
+            ),
+            "prepared_model_sha256": _valid_sha256(
+                expected_baseline_prepared_model_sha256,
+                "expected baseline prepared-model digest",
+            ),
+        },
+        "candidate": {
+            "native_build_inputs_sha256": _valid_sha256(
+                expected_candidate_native_build_inputs_sha256,
+                "expected candidate native-build-input digest",
+            ),
+            "prepared_model_sha256": _valid_sha256(
+                expected_candidate_prepared_model_sha256,
+                "expected candidate prepared-model digest",
+            ),
+        },
+    }
+    if expected_candidate_source_revision == BASELINE_REVISION:
+        raise EvidenceError(
+            "expected candidate source revision still identifies the baseline"
+        )
+    for role, captures in (("baseline", baseline), ("candidate", candidate)):
+        for layout, capture in captures.items():
+            if (
+                role == "candidate"
+                and capture.source_revision != expected_candidate_source_revision
+            ):
+                raise EvidenceError(
+                    f"candidate {layout} capture does not match the externally "
+                    "pinned source revision"
+                )
+            if (
+                capture.build_identity.get("native_build_inputs_sha256")
+                != expected[role]["native_build_inputs_sha256"]
+            ):
+                raise EvidenceError(
+                    f"{role} {layout} capture does not match the externally "
+                    "pinned native-build-input digest"
+                )
+            if (
+                capture.prepared_model_sha256
+                != expected[role]["prepared_model_sha256"]
+            ):
+                raise EvidenceError(
+                    f"{role} {layout} capture does not match the externally "
+                    "pinned prepared-model digest"
+                )
+    return {
+        "candidate_source_revision": expected_candidate_source_revision,
+        "roles": expected,
+    }
+
+
+def _assert_pair_identity(
+    baseline: Mapping[str, CaptureEvidence],
+    candidate: Mapping[str, CaptureEvidence],
+) -> None:
+    if baseline["topology-replay"].source_revision != BASELINE_REVISION:
+        raise EvidenceError(
+            "baseline source revision is not the immutable migration baseline "
+            f"{BASELINE_REVISION}"
+        )
+    if candidate["topology-replay"].source_revision == BASELINE_REVISION:
+        raise EvidenceError("candidate capture still identifies the baseline revision")
+    baseline_host = baseline["topology-replay"].host_identity
+    candidate_host = candidate["topology-replay"].host_identity
+    if baseline_host != candidate_host:
+        raise EvidenceError(
+            "baseline and candidate captures were not run on the same host"
+        )
+    _assert_global_worker_identity_separation(baseline, candidate)
+    for layout in LAYOUTS:
+        baseline_capture = baseline[layout]
+        candidate_capture = candidate[layout]
+        _assert_paired_role_order(
+            baseline_capture,
+            candidate_capture,
+            layout=layout,
+        )
+        if baseline_capture.campaign_identity != candidate_capture.campaign_identity:
+            raise EvidenceError(
+                f"{layout} baseline/candidate campaign configurations differ"
+            )
+        modes = list(CAPTURE_MODES)
+        if (
+            baseline_capture.eager_diagnostic.get("complete") is True
+            and baseline_capture.eager_diagnostic.get("passes") is True
+            and candidate_capture.eager_diagnostic.get("complete") is True
+            and candidate_capture.eager_diagnostic.get("passes") is True
+        ):
+            modes.append("eager")
+        for mode in modes:
+            if (
+                baseline_capture.workload_identities[mode]
+                != candidate_capture.workload_identities[mode]
+            ):
+                raise EvidenceError(
+                    f"{layout}/{mode} baseline/candidate workload identities differ"
+                )
+    _assert_cross_layout_sequence(baseline, candidate)
+
+
+def compare_captures(
+    *,
+    baseline: Mapping[str, CaptureEvidence],
+    candidate: Mapping[str, CaptureEvidence],
+) -> dict[str, object]:
+    """Build the content-addressed comparison for four validated captures."""
+
+    if set(baseline) != set(LAYOUTS) or set(candidate) != set(LAYOUTS):
+        raise EvidenceError("comparison requires both layouts for both revisions")
+    _assert_role_consistency(baseline, role="baseline")
+    _assert_role_consistency(candidate, role="candidate")
+    _assert_pair_identity(baseline, candidate)
+
+    runtime_cells: list[dict[str, object]] = []
+    eager_runtime_cells: list[dict[str, object]] = []
+    runtime_by_key: dict[tuple[str, str, int], Mapping[str, object]] = {}
+    failures: list[str] = []
+    eager_failures: list[str] = []
+    all_captures = [
+        captures[layout] for captures in (baseline, candidate) for layout in LAYOUTS
+    ]
+    eager_requested = all(
+        "eager" in capture.configured_modes for capture in all_captures
+    )
+    eager_available = bool(
+        eager_requested
+        and all(
+            capture.eager_diagnostic.get("complete") is True
+            and capture.eager_diagnostic.get("passes") is True
+            for capture in all_captures
+        )
+    )
+    eager_inadmissibility_reasons = [
+        {
+            "role": role,
+            "layout": layout,
+            "reasons": capture.eager_diagnostic.get("ineligibility_reasons"),
+        }
+        for role, captures in (("baseline", baseline), ("candidate", candidate))
+        for layout, capture in captures.items()
+        if "eager" in capture.configured_modes
+        and (
+            capture.eager_diagnostic.get("complete") is not True
+            or capture.eager_diagnostic.get("passes") is not True
+        )
+    ]
+    for layout in LAYOUTS:
+        for mode in CAPTURE_MODES:
+            for batch_size in BATCH_SIZES:
+                cell_result = _runtime_cell_comparison(
+                    layout=layout,
+                    mode=mode,
+                    batch_size=batch_size,
+                    baseline=baseline[layout].cells[(mode, batch_size)],
+                    candidate=candidate[layout].cells[(mode, batch_size)],
+                )
+                runtime_cells.append(cell_result)
+                runtime_by_key[(layout, mode, batch_size)] = cell_result
+                if cell_result["passes"] is not True:
+                    failures.append(
+                        f"runtime regression: {layout}/{mode}/batch-{batch_size}"
+                    )
+    if eager_available:
+        for layout in LAYOUTS:
+            for batch_size in BATCH_SIZES:
+                cell_result = _runtime_cell_comparison(
+                    layout=layout,
+                    mode="eager",
+                    batch_size=batch_size,
+                    baseline=baseline[layout].cells[("eager", batch_size)],
+                    candidate=candidate[layout].cells[("eager", batch_size)],
+                )
+                eager_runtime_cells.append(cell_result)
+                runtime_by_key[(layout, "eager", batch_size)] = cell_result
+                if cell_result["passes"] is not True:
+                    eager_failures.append(
+                        "eager diagnostic runtime regression: "
+                        f"{layout}/eager/batch-{batch_size}"
+                    )
+
+    paired_ratios: list[dict[str, object]] = []
+    for layout in LAYOUTS:
+        for batch_size in RATIO_BATCH_SIZES:
+            baseline_ratio = _paired_ratio(
+                layout=layout,
+                batch_size=batch_size,
+                capture=baseline[layout],
+            )
+            candidate_ratio = _paired_ratio(
+                layout=layout,
+                batch_size=batch_size,
+                capture=candidate[layout],
+            )
+            candidate_upper = _positive_number(
+                candidate_ratio["median_plus_3_raw_mad"],
+                f"{layout}/{batch_size} candidate paired-ratio upper bound",
+            )
+            passes = candidate_upper <= COMPILED_RECURRENCE_RATIO_LIMIT
+            paired_ratios.append(
+                {
+                    "layout": layout,
+                    "batch_size": batch_size,
+                    "baseline": baseline_ratio,
+                    "candidate": candidate_ratio,
+                    "limit": COMPILED_RECURRENCE_RATIO_LIMIT,
+                    "passes": passes,
+                }
+            )
+            if not passes:
+                failures.append(
+                    f"compiled/recurrence ratio regression: {layout}/batch-{batch_size}"
+                )
+
+    generation_cells: list[dict[str, object]] = []
+    generation_ratios: list[float] = []
+    for layout in LAYOUTS:
+        for mode in MODES:
+            baseline_wall = baseline[layout].generation[mode].wall_seconds
+            candidate_wall = candidate[layout].generation[mode].wall_seconds
+            ratio = candidate_wall / baseline_wall
+            passes = ratio <= GENERATION_CELL_LIMIT
+            generation_ratios.append(ratio)
+            generation_cells.append(
+                {
+                    "layout": layout,
+                    "mode": mode,
+                    "baseline_wall_seconds": baseline_wall,
+                    "candidate_wall_seconds": candidate_wall,
+                    "candidate_to_baseline_ratio": ratio,
+                    "limit": GENERATION_CELL_LIMIT,
+                    "passes": passes,
+                }
+            )
+            if not passes:
+                failures.append(f"generation regression: {layout}/{mode}")
+    generation_geomean = _geometric_mean(
+        generation_ratios,
+        "generation candidate/baseline ratios",
+    )
+    generation_geomean_passes = generation_geomean <= GENERATION_GEOMEAN_LIMIT
+    if not generation_geomean_passes:
+        failures.append("generation geometric-mean regression")
+
+    eager_generation_cells: list[dict[str, object]] = []
+    eager_generation_ratios: list[float] = []
+    if eager_available:
+        for layout in LAYOUTS:
+            baseline_wall = baseline[layout].generation["eager"].wall_seconds
+            candidate_wall = candidate[layout].generation["eager"].wall_seconds
+            ratio = candidate_wall / baseline_wall
+            eager_generation_ratios.append(ratio)
+            passes = ratio <= GENERATION_CELL_LIMIT
+            eager_generation_cells.append(
+                {
+                    "layout": layout,
+                    "mode": "eager",
+                    "baseline_wall_seconds": baseline_wall,
+                    "candidate_wall_seconds": candidate_wall,
+                    "candidate_to_baseline_ratio": ratio,
+                    "limit": GENERATION_CELL_LIMIT,
+                    "passes": passes,
+                }
+            )
+            if not passes:
+                eager_failures.append(
+                    f"eager diagnostic generation regression: {layout}/eager"
+                )
+    eager_generation_geomean = (
+        _geometric_mean(
+            eager_generation_ratios,
+            "eager generation candidate/baseline ratios",
+        )
+        if eager_available
+        else None
+    )
+    eager_generation_geomean_passes = (
+        eager_generation_geomean <= GENERATION_GEOMEAN_LIMIT
+        if eager_generation_geomean is not None
+        else None
+    )
+    if eager_generation_geomean_passes is False:
+        eager_failures.append("eager diagnostic generation geometric-mean regression")
+
+    # A mode-level payload or generation-RSS exception requires a >=10%
+    # geometric-mean runtime gain and a gain beyond three baseline raw MADs in
+    # every measured batch.  Cell-level cold-load/RSS exceptions use the
+    # corresponding batch's runtime evidence directly.
+    mode_runtime_gain: dict[tuple[str, str], dict[str, object]] = {}
+    for layout in LAYOUTS:
+        modes_with_diagnostic = (
+            (*CAPTURE_MODES, "eager") if eager_available else CAPTURE_MODES
+        )
+        for mode in modes_with_diagnostic:
+            comparisons = [
+                runtime_by_key[(layout, mode, batch_size)] for batch_size in BATCH_SIZES
+            ]
+            ratios = [
+                _positive_number(
+                    comparison["candidate_to_baseline_ratio"],
+                    f"{layout}/{mode} candidate/baseline runtime ratio",
+                )
+                for comparison in comparisons
+            ]
+            ratio_geomean = _geometric_mean(
+                ratios,
+                f"{layout}/{mode} runtime ratios",
+            )
+            beyond_noise_all = all(
+                _mapping(
+                    comparison["resource_exception_runtime_gain"],
+                    "runtime gain evidence",
+                ).get("gain_beyond_3_baseline_raw_mad")
+                is True
+                for comparison in comparisons
+            )
+            mode_runtime_gain[(layout, mode)] = {
+                "runtime_ratio_geometric_mean": ratio_geomean,
+                "gain_at_least_10_percent": (
+                    ratio_geomean <= 1.0 - RESOURCE_EXCEPTION_GAIN
+                ),
+                "gain_beyond_3_baseline_raw_mad_in_every_batch": beyond_noise_all,
+                "passes": (
+                    ratio_geomean <= 1.0 - RESOURCE_EXCEPTION_GAIN and beyond_noise_all
+                ),
+            }
+
+    resources: list[dict[str, object]] = []
+    eager_resources: list[dict[str, object]] = []
+    for layout in LAYOUTS:
+        modes_with_diagnostic = (
+            (*CAPTURE_MODES, "eager") if eager_available else CAPTURE_MODES
+        )
+        for mode in modes_with_diagnostic:
+            baseline_generation = baseline[layout].generation[mode]
+            candidate_generation = candidate[layout].generation[mode]
+            aggregate_gain = mode_runtime_gain[(layout, mode)]
+            mode_resources = eager_resources if mode == "eager" else resources
+            mode_resources.extend(
+                (
+                    _single_resource_comparison(
+                        layout=layout,
+                        mode=mode,
+                        metric="artifact_payload_size_bytes",
+                        baseline=float(baseline_generation.payload_size_bytes),
+                        candidate=float(candidate_generation.payload_size_bytes),
+                        runtime_gain=aggregate_gain,
+                    ),
+                    _single_resource_comparison(
+                        layout=layout,
+                        mode=mode,
+                        metric="generation_peak_rss_bytes",
+                        baseline=float(baseline_generation.peak_rss_bytes),
+                        candidate=float(candidate_generation.peak_rss_bytes),
+                        runtime_gain=aggregate_gain,
+                    ),
+                )
+            )
+            for batch_size in BATCH_SIZES:
+                baseline_cell = baseline[layout].cells[(mode, batch_size)]
+                candidate_cell = candidate[layout].cells[(mode, batch_size)]
+                gain = _mapping(
+                    runtime_by_key[(layout, mode, batch_size)][
+                        "resource_exception_runtime_gain"
+                    ],
+                    "runtime gain evidence",
+                )
+                mode_resources.extend(
+                    (
+                        _resource_comparison(
+                            layout=layout,
+                            mode=mode,
+                            batch_size=batch_size,
+                            metric="cold_load_seconds",
+                            baseline=baseline_cell.cold_load,
+                            candidate=candidate_cell.cold_load,
+                            runtime_gain=gain,
+                        ),
+                        _resource_comparison(
+                            layout=layout,
+                            mode=mode,
+                            batch_size=batch_size,
+                            metric="cold_load_peak_rss_bytes",
+                            baseline=baseline_cell.cold_load_rss,
+                            candidate=candidate_cell.cold_load_rss,
+                            runtime_gain=gain,
+                        ),
+                        _resource_comparison(
+                            layout=layout,
+                            mode=mode,
+                            batch_size=batch_size,
+                            metric="profiled_peak_rss_bytes",
+                            baseline=baseline_cell.profiled_rss,
+                            candidate=candidate_cell.profiled_rss,
+                            runtime_gain=gain,
+                        ),
+                    )
+                )
+    for diagnostic, inventory in (
+        (False, resources),
+        (True, eager_resources),
+    ):
+        for resource in inventory:
+            if resource["passes"] is not True:
+                batch_suffix = (
+                    ""
+                    if "batch_size" not in resource
+                    else f"/batch-{resource['batch_size']}"
+                )
+                prefix = (
+                    "eager diagnostic resource regression"
+                    if diagnostic
+                    else "resource regression"
+                )
+                failure_inventory = eager_failures if diagnostic else failures
+                failure_inventory.append(
+                    f"{prefix}: "
+                    f"{resource['layout']}/{resource['mode']}{batch_suffix}/"
+                    f"{resource['metric']}"
+                )
+
+    identity = {
+        "logical_process": baseline["topology-replay"].logical_process,
+        "host_identity_sha256": _sha256(baseline["topology-replay"].host_identity),
+        "baseline_source_revision": baseline["topology-replay"].source_revision,
+        "candidate_source_revision": candidate["topology-replay"].source_revision,
+        "baseline_build_identity_sha256": _sha256(
+            baseline["topology-replay"].build_identity
+        ),
+        "candidate_build_identity_sha256": _sha256(
+            candidate["topology-replay"].build_identity
+        ),
+        "workloads": {
+            layout: {
+                mode: _sha256(baseline[layout].workload_identities[mode])
+                for mode in CAPTURE_MODES
+            }
+            for layout in LAYOUTS
+        },
+    }
+    eager_runtime_passes = (
+        all(cell["passes"] is True for cell in eager_runtime_cells)
+        if eager_available
+        else None
+    )
+    eager_generation_passes = (
+        eager_generation_geomean_passes is True
+        and all(cell["passes"] is True for cell in eager_generation_cells)
+        if eager_available
+        else None
+    )
+    eager_resource_passes = (
+        all(resource["passes"] is True for resource in eager_resources)
+        if eager_available
+        else None
+    )
+    if not eager_available:
+        eager_failures.append("eager campaign is not admissible")
+    failures.extend(eager_failures)
+    comparison_result: dict[str, object] = {
+        "kind": COMPARISON_KIND,
+        "schema_version": COMPARISON_SCHEMA,
+        "complete": True,
+        "passes": not failures,
+        "identity": identity,
+        "identity_sha256": _sha256(identity),
+        "inputs": {
+            role: {layout: dict(captures[layout].input_identity) for layout in LAYOUTS}
+            for role, captures in (
+                ("baseline", baseline),
+                ("candidate", candidate),
+            )
+        },
+        "thresholds": {
+            "runtime_candidate_median_relative_to_baseline": RUNTIME_RELATIVE_LIMIT,
+            "runtime_baseline_raw_mad_multiplier": RUNTIME_NOISE_MAD_MULTIPLIER,
+            "compiled_to_recurrence_ratio_median_plus_3_raw_mad": (
+                COMPILED_RECURRENCE_RATIO_LIMIT
+            ),
+            "generation_cell_candidate_to_baseline": GENERATION_CELL_LIMIT,
+            "generation_geometric_mean_candidate_to_baseline": (
+                GENERATION_GEOMEAN_LIMIT
+            ),
+            "resource_growth_candidate_to_baseline": RESOURCE_GROWTH_LIMIT,
+            "resource_exception_minimum_runtime_gain": RESOURCE_EXCEPTION_GAIN,
+        },
+        "runtime_cells": runtime_cells,
+        "paired_compiled_recurrence_ratios": paired_ratios,
+        "generation": {
+            "cells": generation_cells,
+            "candidate_to_baseline_ratio_geometric_mean": generation_geomean,
+            "geometric_mean_limit": GENERATION_GEOMEAN_LIMIT,
+            "geometric_mean_passes": generation_geomean_passes,
+            "passes": (
+                generation_geomean_passes
+                and all(cell["passes"] is True for cell in generation_cells)
+            ),
+        },
+        "payload_cold_load_rss": resources,
+        "eager_diagnostic": {
+            "requested": eager_requested,
+            "admissible": eager_available,
+            "inadmissibility_reasons": eager_inadmissibility_reasons,
+            "runtime_cells": eager_runtime_cells,
+            "runtime_passes": eager_runtime_passes,
+            "generation": {
+                "cells": eager_generation_cells,
+                "candidate_to_baseline_ratio_geometric_mean": (
+                    eager_generation_geomean
+                ),
+                "geometric_mean_limit": GENERATION_GEOMEAN_LIMIT,
+                "geometric_mean_passes": eager_generation_geomean_passes,
+                "passes": eager_generation_passes,
+            },
+            "payload_cold_load_rss": eager_resources,
+            "resource_passes": eager_resource_passes,
+            "paired_compiled_recurrence_ratio_applicable": False,
+            "passes": (
+                eager_runtime_passes
+                and eager_generation_passes
+                and eager_resource_passes
+                if eager_available
+                else None
+            ),
+            "failures": eager_failures,
+        },
+        "failures": failures,
+    }
+    comparison_result["content_sha256"] = _sha256(comparison_result)
+    return comparison_result
+
+
+def _validate_campaign_capture_identity(
+    value: object,
+    *,
+    evidence: CaptureEvidence,
+    label: str,
+) -> None:
+    identity = _mapping(value, label)
+    if set(identity) != {"path", "resolved_path", "size_bytes", "sha256"}:
+        raise EvidenceError(f"{label} has an unsupported capture identity")
+    resolved_path = _string(identity.get("resolved_path"), f"{label}.resolved_path")
+    if (
+        _string(identity.get("path"), f"{label}.path")
+        != evidence.input_identity.get("path")
+        or resolved_path != evidence.input_identity.get("resolved_path")
+        or _exact_int(
+            identity.get("size_bytes"),
+            f"{label}.size_bytes",
+            minimum=1,
+        )
+        != evidence.input_identity.get("size_bytes")
+        or _valid_sha256(identity.get("sha256"), f"{label}.sha256")
+        != evidence.input_identity.get("sha256")
+    ):
+        raise EvidenceError(f"{label} does not identify its supplied capture file")
+
+
+def _validate_paired_campaign(
+    payload: Mapping[str, Any],
+    input_identity: Mapping[str, object],
+    *,
+    baseline: Mapping[str, CaptureEvidence],
+    candidate: Mapping[str, CaptureEvidence],
+) -> Mapping[str, object]:
+    label = "paired campaign"
+    campaign = _validate_content_address(payload, label)
+    _validate_nested_content_addresses(campaign, label)
+    expected_root_fields = {
+        "kind",
+        "schema_version",
+        "complete",
+        "session_id",
+        "started_at_utc",
+        "finished_at_utc",
+        "process",
+        "orchestrator",
+        "harness",
+        "roles",
+        "configuration",
+        "layouts",
+        "content_sha256",
+    }
+    if (
+        set(campaign) != expected_root_fields
+        or campaign.get("kind") != PAIRED_CAMPAIGN_KIND
+        or campaign.get("schema_version") != PAIRED_CAMPAIGN_SCHEMA
+        or campaign.get("complete") is not True
+    ):
+        raise EvidenceError(f"{label} has an unsupported identity")
+    session_id = _string(campaign.get("session_id"), f"{label}.session_id")
+    started = _utc_timestamp(
+        campaign.get("started_at_utc"),
+        f"{label}.started_at_utc",
+    )
+    finished = _utc_timestamp(
+        campaign.get("finished_at_utc"),
+        f"{label}.finished_at_utc",
+    )
+    if started > finished:
+        raise EvidenceError(f"{label} timestamps are inverted")
+    logical_process = _logical_process(campaign.get("process"), f"{label}.process")
+    if logical_process != baseline["topology-replay"].logical_process:
+        raise EvidenceError(f"{label} process differs from its supplied captures")
+
+    harness = _mapping(campaign.get("harness"), f"{label}.harness")
+    expected_harness_fields = {
+        "kind",
+        "schema_version",
+        "candidate_relative_path",
+        "head_blob_sha256",
+        "working_file_sha256",
+        "head_blob_equals_working_file",
+        "content_sha256",
+    }
+    harness_path = (
+        Path(__file__).resolve().parents[2] / PAIRED_HARNESS_RELATIVE_PATH
+    )
+    harness_sha256 = _sha256_file(harness_path)
+    if (
+        set(harness) != expected_harness_fields
+        or harness.get("kind") != PAIRED_HARNESS_KIND
+        or harness.get("schema_version") != PAIRED_HARNESS_SCHEMA
+        or harness.get("candidate_relative_path") != PAIRED_HARNESS_RELATIVE_PATH
+        or harness.get("head_blob_equals_working_file") is not True
+        or _valid_sha256(
+            harness.get("head_blob_sha256"),
+            f"{label}.harness.head_blob_sha256",
+        )
+        != harness_sha256
+        or _valid_sha256(
+            harness.get("working_file_sha256"),
+            f"{label}.harness.working_file_sha256",
+        )
+        != harness_sha256
+    ):
+        raise EvidenceError(
+            f"{label} harness is not the exact candidate benchmark driver"
+        )
+    orchestrator = _mapping(
+        campaign.get("orchestrator"),
+        f"{label}.orchestrator",
+    )
+    orchestrator_path = (
+        Path(__file__).resolve().parents[2] / PAIRED_DRIVER_RELATIVE_PATH
+    )
+    orchestrator_sha256 = _sha256_file(orchestrator_path)
+    if (
+        set(orchestrator) != expected_harness_fields
+        or orchestrator.get("kind") != PAIRED_HARNESS_KIND
+        or orchestrator.get("schema_version") != PAIRED_HARNESS_SCHEMA
+        or orchestrator.get("candidate_relative_path")
+        != PAIRED_DRIVER_RELATIVE_PATH
+        or orchestrator.get("head_blob_equals_working_file") is not True
+        or _valid_sha256(
+            orchestrator.get("head_blob_sha256"),
+            f"{label}.orchestrator.head_blob_sha256",
+        )
+        != orchestrator_sha256
+        or _valid_sha256(
+            orchestrator.get("working_file_sha256"),
+            f"{label}.orchestrator.working_file_sha256",
+        )
+        != orchestrator_sha256
+    ):
+        raise EvidenceError(
+            f"{label} orchestrator is not the exact paired benchmark driver"
+        )
+
+    captures_by_role = {"baseline": baseline, "candidate": candidate}
+    roles = _mapping(campaign.get("roles"), f"{label}.roles")
+    if set(roles) != set(captures_by_role):
+        raise EvidenceError(f"{label} role inventory is incomplete")
+    expected_role_fields = {
+        "source_root",
+        "source_revision",
+        "python",
+        "python_resolved_target",
+        "python_sha256",
+        "prepared_model",
+        "prepared_model_sha256",
+    }
+    for role, captures in captures_by_role.items():
+        role_record = _mapping(roles.get(role), f"{label}.roles.{role}")
+        reference = captures["topology-replay"]
+        if any(
+            capture.paired_profile_coordination.get("session_id") != session_id
+            for capture in captures.values()
+        ):
+            raise EvidenceError(
+                f"{label}.session_id differs from its {role} captures"
+            )
+        if set(role_record) != expected_role_fields:
+            raise EvidenceError(f"{label}.roles.{role} has an unsupported identity")
+        for field in (
+            "source_root",
+            "python",
+            "python_resolved_target",
+            "prepared_model",
+        ):
+            _string(role_record.get(field), f"{label}.roles.{role}.{field}")
+        if (
+            role_record.get("source_revision") != reference.source_revision
+            or role_record.get("python") != reference.interpreter_path
+            or role_record.get("python_resolved_target")
+            != reference.interpreter_resolved_path
+            or _valid_sha256(
+                role_record.get("python_sha256"),
+                f"{label}.roles.{role}.python_sha256",
+            )
+            != reference.campaign_identity["interpreter"]["executable_sha256"]
+            or role_record.get("prepared_model") != reference.prepared_model_path
+            or _valid_sha256(
+                role_record.get("prepared_model_sha256"),
+                f"{label}.roles.{role}.prepared_model_sha256",
+            )
+            != reference.prepared_model_sha256
+        ):
+            raise EvidenceError(
+                f"{label}.roles.{role} differs from its capture provenance"
+            )
+
+    reference_campaign = baseline["topology-replay"].campaign_identity
+    expected_configuration = {
+        "authoritative_modes": list(AUTHORITATIVE_MODES),
+        "diagnostic_modes": list(DIAGNOSTIC_MODES),
+        "batch_sizes": list(BATCH_SIZES),
+        "target_runtime_seconds": reference_campaign["target_runtime_seconds"],
+        "minimum_samples": reference_campaign["minimum_internal_samples"],
+        "subprocess_samples": reference_campaign["subprocess_samples"],
+        "warmup_runs": reference_campaign["warmup_runs"],
+        "watchdog": {
+            "required": True,
+            "report_kind": WATCHDOG_REPORT_KIND,
+            "report_schema_version": WATCHDOG_REPORT_SCHEMA,
+            "limit_bytes": WATCHDOG_LIMIT_BYTES,
+            "scope": WATCHDOG_SCOPE,
+            "binding": WATCHDOG_BINDING,
+        },
+    }
+    configuration = _mapping(
+        campaign.get("configuration"),
+        f"{label}.configuration",
+    )
+    if dict(configuration) != expected_configuration:
+        raise EvidenceError(f"{label} configuration differs from its captures")
+
+    layouts = _mapping(campaign.get("layouts"), f"{label}.layouts")
+    if set(layouts) != set(LAYOUTS):
+        raise EvidenceError(f"{label} layout inventory is incomplete")
+    for layout in LAYOUTS:
+        layout_record = _mapping(layouts.get(layout), f"{label}.layouts.{layout}")
+        if (
+            set(layout_record)
+            != {
+                "layout",
+                "ready_records",
+                "paired_schedule_algorithm",
+                "pairs",
+                "captures",
+            }
+            or layout_record.get("layout") != layout
+            or layout_record.get("paired_schedule_algorithm")
+            != "slot-adjacent-round-alternating-role-order-v1"
+        ):
+            raise EvidenceError(f"{label}.layouts.{layout} has an unsupported identity")
+        ready_records = _mapping(
+            layout_record.get("ready_records"),
+            f"{label}.layouts.{layout}.ready_records",
+        )
+        capture_identities = _mapping(
+            layout_record.get("captures"),
+            f"{label}.layouts.{layout}.captures",
+        )
+        if set(ready_records) != set(captures_by_role) or set(
+            capture_identities
+        ) != set(captures_by_role):
+            raise EvidenceError(
+                f"{label}.layouts.{layout} role inventory is incomplete"
+            )
+        for role, captures in captures_by_role.items():
+            evidence = captures[layout]
+            if (
+                ready_records.get(role)
+                != evidence.paired_profile_coordination["ready_record"]
+            ):
+                raise EvidenceError(
+                    f"{label}.layouts.{layout}.{role} ready record differs "
+                    "from its capture"
+                )
+            _validate_campaign_capture_identity(
+                capture_identities.get(role),
+                evidence=evidence,
+                label=f"{label}.layouts.{layout}.captures.{role}",
+            )
+            ready_at = evidence.paired_profile_coordination.get("ready_at")
+            if not isinstance(ready_at, dt.datetime) or not started <= ready_at:
+                raise EvidenceError(
+                    f"{label}.layouts.{layout}.{role} became ready before "
+                    "the campaign started"
+                )
+
+        raw_pairs = _sequence(
+            layout_record.get("pairs"),
+            f"{label}.layouts.{layout}.pairs",
+        )
+        baseline_slots = _mapping(
+            baseline[layout].paired_profile_coordination.get("slots"),
+            f"{label}.layouts.{layout}.baseline slots",
+        )
+        candidate_slots = _mapping(
+            candidate[layout].paired_profile_coordination.get("slots"),
+            f"{label}.layouts.{layout}.candidate slots",
+        )
+        if len(raw_pairs) != len(baseline_slots):
+            raise EvidenceError(
+                f"{label}.layouts.{layout} pair inventory is incomplete"
+            )
+        for pair_index, raw_pair in enumerate(raw_pairs):
+            pair = _mapping(
+                raw_pair,
+                f"{label}.layouts.{layout}.pairs[{pair_index}]",
+            )
+            baseline_slot = _mapping(
+                baseline_slots[pair_index],
+                f"{label}.layouts.{layout}.baseline slot {pair_index}",
+            )
+            candidate_slot = _mapping(
+                candidate_slots[pair_index],
+                f"{label}.layouts.{layout}.candidate slot {pair_index}",
+            )
+            token = _mapping(
+                baseline_slot.get("token"),
+                f"{label}.layouts.{layout}.baseline token {pair_index}",
+            )
+            round_index = _exact_int(
+                token.get("round"),
+                f"{label}.layouts.{layout}.pairs[{pair_index}].round",
+                minimum=0,
+            )
+            expected_order = (
+                ["baseline", "candidate"]
+                if round_index % 2 == 0
+                else ["candidate", "baseline"]
+            )
+            expected_coordinates = {
+                field: token.get(field)
+                for field in (
+                    "schedule_index",
+                    "round",
+                    "mode",
+                    "batch_size",
+                )
+            }
+            completions = _mapping(
+                pair.get("completions"),
+                f"{label}.layouts.{layout}.pairs[{pair_index}].completions",
+            )
+            if (
+                pair.get("kind") != "pyamplicol-paired-profile-pair"
+                or pair.get("schema_version") != 1
+                or pair.get("pair_index") != pair_index
+                or any(
+                    pair.get(field) != value
+                    for field, value in expected_coordinates.items()
+                )
+                or pair.get("role_order") != expected_order
+                or dict(completions)
+                != {
+                    "baseline": baseline_slot["completion"],
+                    "candidate": candidate_slot["completion"],
+                }
+            ):
+                raise EvidenceError(
+                    f"{label}.layouts.{layout}.pairs[{pair_index}] differs "
+                    "from its captures"
+                )
+            for role_slot in (baseline_slot, candidate_slot):
+                recorded = role_slot.get("recorded")
+                if not isinstance(recorded, dt.datetime) or recorded > finished:
+                    raise EvidenceError(
+                        f"{label}.layouts.{layout} completed after the campaign"
+                    )
+
+    result = dict(input_identity)
+    result["campaign_content_sha256"] = _valid_sha256(
+        campaign.get("content_sha256"),
+        f"{label}.content_sha256",
+    )
+    result["harness_content_sha256"] = _valid_sha256(
+        harness.get("content_sha256"),
+        f"{label}.harness.content_sha256",
+    )
+    result["orchestrator_content_sha256"] = _valid_sha256(
+        orchestrator.get("content_sha256"),
+        f"{label}.orchestrator.content_sha256",
+    )
+    return result
+
+
+def _validate_watchdog_report(
+    payload: Mapping[str, Any],
+    input_identity: Mapping[str, object],
+    *,
+    campaign: Mapping[str, Any],
+    campaign_input_identity: Mapping[str, object],
+) -> Mapping[str, object]:
+    label = "outer memory watchdog report"
+    report = _validate_content_address(payload, label)
+    _validate_nested_content_addresses(report, label)
+    expected_fields = {
+        "kind",
+        "schema_version",
+        "complete",
+        "passes",
+        "watchdog",
+        "working_directory",
+        "execution",
+        "enforcement",
+        "result_binding",
+        "content_sha256",
+    }
+    if (
+        set(report) != expected_fields
+        or report.get("kind") != WATCHDOG_REPORT_KIND
+        or report.get("schema_version") != WATCHDOG_REPORT_SCHEMA
+        or report.get("complete") is not True
+        or report.get("passes") is not True
+    ):
+        raise EvidenceError(f"{label} is not complete and passing")
+
+    watchdog_identity = _mapping(
+        report.get("watchdog"),
+        f"{label}.watchdog",
+    )
+    watchdog_path = Path(__file__).resolve().parents[2] / WATCHDOG_RELATIVE_PATH
+    if (
+        set(watchdog_identity) != {"path", "resolved_path", "size_bytes", "sha256"}
+        or watchdog_identity.get("resolved_path") != str(watchdog_path.resolve())
+        or _exact_int(
+            watchdog_identity.get("size_bytes"),
+            f"{label}.watchdog.size_bytes",
+            minimum=1,
+        )
+        != watchdog_path.stat().st_size
+        or _valid_sha256(
+            watchdog_identity.get("sha256"),
+            f"{label}.watchdog.sha256",
+        )
+        != _sha256_file(watchdog_path)
+    ):
+        raise EvidenceError(
+            f"{label} was not emitted by the authenticated watchdog tool"
+        )
+
+    execution = _mapping(report.get("execution"), f"{label}.execution")
+    if set(execution) != {
+        "command",
+        "command_sha256",
+        "started_at_utc",
+        "finished_at_utc",
+        "elapsed_wall_seconds",
+        "child_pid",
+        "child_exit_code",
+        "watchdog_exit_code",
+        "outcome",
+        "reason",
+    }:
+        raise EvidenceError(f"{label} execution has an unsupported schema")
+    command = list(_sequence(execution.get("command"), f"{label}.execution.command"))
+    if (
+        len(command) < 2
+        or any(not isinstance(value, str) or not value for value in command)
+        or _valid_sha256(
+            execution.get("command_sha256"),
+            f"{label}.execution.command_sha256",
+        )
+        != _sha256(command)
+        or execution.get("child_exit_code") != 0
+        or execution.get("watchdog_exit_code") != 0
+        or execution.get("outcome") != "command-finished"
+        or execution.get("reason") is not None
+        or _exact_int(
+            execution.get("child_pid"),
+            f"{label}.execution.child_pid",
+            minimum=1,
+        )
+        < 1
+        or _positive_number(
+            execution.get("elapsed_wall_seconds"),
+            f"{label}.execution.elapsed_wall_seconds",
+        )
+        <= 0.0
+    ):
+        raise EvidenceError(f"{label} did not record a successful child execution")
+    watchdog_started = _utc_timestamp(
+        execution.get("started_at_utc"),
+        f"{label}.execution.started_at_utc",
+    )
+    watchdog_finished = _utc_timestamp(
+        execution.get("finished_at_utc"),
+        f"{label}.execution.finished_at_utc",
+    )
+    campaign_started = _utc_timestamp(
+        campaign.get("started_at_utc"),
+        "paired campaign.started_at_utc",
+    )
+    campaign_finished = _utc_timestamp(
+        campaign.get("finished_at_utc"),
+        "paired campaign.finished_at_utc",
+    )
+    if not watchdog_started <= campaign_started <= campaign_finished <= watchdog_finished:
+        raise EvidenceError(
+            f"{label} timestamps do not enclose the paired campaign"
+        )
+
+    enforcement = _mapping(report.get("enforcement"), f"{label}.enforcement")
+    if (
+        set(enforcement)
+        != {
+            "scope",
+            "limit_bytes",
+            "poll_interval_seconds",
+            "terminate_grace_seconds",
+            "metric",
+            "probe_sample_count",
+            "probe_failure_count",
+            "maximum_consecutive_probe_failures",
+            "completed_under_retry_policy",
+            "peak_rss_bytes",
+            "peak_physical_footprint_bytes",
+            "peak_guard_bytes",
+            "peak_processes",
+        }
+        or enforcement.get("scope") != WATCHDOG_SCOPE
+        or enforcement.get("limit_bytes") != WATCHDOG_LIMIT_BYTES
+        or enforcement.get("metric")
+        not in {
+            "process-tree-rss",
+            "max(process-tree-rss,darwin-process-tree-physical-footprint)",
+        }
+        or enforcement.get("completed_under_retry_policy") is not True
+        or _exact_int(
+            enforcement.get("probe_sample_count"),
+            f"{label}.enforcement.probe_sample_count",
+            minimum=1,
+        )
+        < 1
+        or _positive_number(
+            enforcement.get("poll_interval_seconds"),
+            f"{label}.enforcement.poll_interval_seconds",
+        )
+        <= 0.0
+        or _nonnegative_number(
+            enforcement.get("terminate_grace_seconds"),
+            f"{label}.enforcement.terminate_grace_seconds",
+        )
+        < 0.0
+    ):
+        raise EvidenceError(
+            f"{label} does not prove successful 30-GiB enforcement"
+        )
+    probe_failure_count = _exact_int(
+        enforcement.get("probe_failure_count"),
+        f"{label}.enforcement.probe_failure_count",
+        minimum=0,
+    )
+    maximum_consecutive_probe_failures = _exact_int(
+        enforcement.get("maximum_consecutive_probe_failures"),
+        f"{label}.enforcement.maximum_consecutive_probe_failures",
+        minimum=0,
+    )
+    if (
+        maximum_consecutive_probe_failures > 2
+        or maximum_consecutive_probe_failures > probe_failure_count
+        or (probe_failure_count == 0) != (maximum_consecutive_probe_failures == 0)
+    ):
+        raise EvidenceError(
+            f"{label} exceeds the watchdog's recovered-probe retry policy"
+        )
+    peak_rss = _exact_int(
+        enforcement.get("peak_rss_bytes"),
+        f"{label}.enforcement.peak_rss_bytes",
+        minimum=0,
+    )
+    peak_guard = _exact_int(
+        enforcement.get("peak_guard_bytes"),
+        f"{label}.enforcement.peak_guard_bytes",
+        minimum=0,
+    )
+    _exact_int(
+        enforcement.get("peak_processes"),
+        f"{label}.enforcement.peak_processes",
+        minimum=1,
+    )
+    physical_peak = enforcement.get("peak_physical_footprint_bytes")
+    if physical_peak is not None:
+        physical_peak = _exact_int(
+            physical_peak,
+            f"{label}.enforcement.peak_physical_footprint_bytes",
+            minimum=0,
+        )
+    metric = enforcement.get("metric")
+    if (
+        peak_guard > WATCHDOG_LIMIT_BYTES
+        or (
+            metric == "process-tree-rss"
+            and (physical_peak is not None or peak_guard != peak_rss)
+        )
+        or (
+            metric
+            == "max(process-tree-rss,darwin-process-tree-physical-footprint)"
+            and (
+                physical_peak is None
+                or peak_guard != max(peak_rss, physical_peak)
+            )
+        )
+    ):
+        raise EvidenceError(f"{label} peak observations are internally inconsistent")
+
+    working_directory = Path(
+        _string(report.get("working_directory"), f"{label}.working_directory")
+    )
+    if not working_directory.is_absolute():
+        raise EvidenceError(f"{label} working directory is not absolute")
+
+    def option(name: str) -> str:
+        indices = [index for index, value in enumerate(command) if value == name]
+        if (
+            len(indices) != 1
+            or indices[0] + 1 >= len(command)
+            or not isinstance(command[indices[0] + 1], str)
+            or not command[indices[0] + 1]
+        ):
+            raise EvidenceError(f"{label} command has no unique {name}")
+        return command[indices[0] + 1]
+
+    roles = _mapping(campaign.get("roles"), "paired campaign.roles")
+    candidate_role = _mapping(
+        roles.get("candidate"),
+        "paired campaign.roles.candidate",
+    )
+    if command[0] != candidate_role.get("python"):
+        raise EvidenceError(
+            f"{label} command did not use the candidate campaign interpreter"
+        )
+    command_driver = Path(command[1]).expanduser()
+    if not command_driver.is_absolute():
+        command_driver = working_directory / command_driver
+    if command_driver.resolve() != (
+        Path(__file__).resolve().parents[2] / PAIRED_DRIVER_RELATIVE_PATH
+    ).resolve():
+        raise EvidenceError(
+            f"{label} command did not execute the paired benchmark driver"
+        )
+    if option("--session-id") != campaign.get("session_id"):
+        raise EvidenceError(f"{label} command session differs from the campaign")
+    result_argument = Path(option("--result-json")).expanduser()
+    if not result_argument.is_absolute():
+        result_argument = working_directory / result_argument
+    result_resolved = str(result_argument.resolve())
+    if result_resolved != campaign_input_identity.get("resolved_path"):
+        raise EvidenceError(
+            f"{label} command result path differs from the supplied campaign"
+        )
+
+    binding = _mapping(report.get("result_binding"), f"{label}.result_binding")
+    if set(binding) != {"requested", "requested_path", "identity", "error"}:
+        raise EvidenceError(f"{label} result binding has an unsupported schema")
+    identity = _mapping(
+        binding.get("identity"),
+        f"{label}.result_binding.identity",
+    )
+    if (
+        binding.get("requested") is not True
+        or binding.get("error") is not None
+        or set(identity) != {"path", "resolved_path", "size_bytes", "sha256"}
+        or identity.get("path") != binding.get("requested_path")
+        or str(Path(_string(identity.get("path"), f"{label}.result path")).expanduser())
+        != str(Path(option("--result-json")).expanduser())
+        or identity.get("resolved_path") != result_resolved
+        or identity.get("resolved_path")
+        != campaign_input_identity.get("resolved_path")
+        or identity.get("size_bytes") != campaign_input_identity.get("size_bytes")
+        or identity.get("sha256") != campaign_input_identity.get("sha256")
+    ):
+        raise EvidenceError(
+            f"{label} does not content-address the supplied paired campaign"
+        )
+
+    result = dict(input_identity)
+    result["report_content_sha256"] = _valid_sha256(
+        report.get("content_sha256"),
+        f"{label}.content_sha256",
+    )
+    result["command_sha256"] = _valid_sha256(
+        execution.get("command_sha256"),
+        f"{label}.execution.command_sha256",
+    )
+    result["bound_campaign_sha256"] = _valid_sha256(
+        identity.get("sha256"),
+        f"{label}.result_binding.identity.sha256",
+    )
+    result["watchdog_sha256"] = _valid_sha256(
+        watchdog_identity.get("sha256"),
+        f"{label}.watchdog.sha256",
+    )
+    return result
+
+
+def compare_capture_files(
+    *,
+    campaign: Path,
+    watchdog_report: Path,
+    baseline_topology: Path,
+    baseline_all_flow_union: Path,
+    candidate_topology: Path,
+    candidate_all_flow_union: Path,
+    expected_candidate_source_revision: str,
+    expected_baseline_native_build_inputs_sha256: str,
+    expected_candidate_native_build_inputs_sha256: str,
+    expected_baseline_prepared_model_sha256: str,
+    expected_candidate_prepared_model_sha256: str,
+) -> dict[str, object]:
+    """Load, validate, and compare the four required capture files."""
+
+    campaign_payload, campaign_input_identity = _read_json_mapping(
+        campaign,
+        label="paired campaign",
+    )
+    watchdog_payload, watchdog_input_identity = _read_json_mapping(
+        watchdog_report,
+        label="outer memory watchdog report",
+    )
+    paths = {
+        "baseline": {
+            "topology-replay": baseline_topology,
+            "all-flow-union": baseline_all_flow_union,
+        },
+        "candidate": {
+            "topology-replay": candidate_topology,
+            "all-flow-union": candidate_all_flow_union,
+        },
+    }
+    evidence: dict[str, dict[str, CaptureEvidence]] = {
+        "baseline": {},
+        "candidate": {},
+    }
+    for role in ("baseline", "candidate"):
+        for layout in LAYOUTS:
+            payload, input_identity = _read_capture(paths[role][layout])
+            evidence[role][layout] = _validate_capture(
+                payload,
+                input_identity,
+                role=role,
+                expected_layout=layout,
+            )
+    expected_role_inputs = _assert_externally_pinned_role_inputs(
+        evidence["baseline"],
+        evidence["candidate"],
+        expected_candidate_source_revision=expected_candidate_source_revision,
+        expected_baseline_native_build_inputs_sha256=(
+            expected_baseline_native_build_inputs_sha256
+        ),
+        expected_candidate_native_build_inputs_sha256=(
+            expected_candidate_native_build_inputs_sha256
+        ),
+        expected_baseline_prepared_model_sha256=(
+            expected_baseline_prepared_model_sha256
+        ),
+        expected_candidate_prepared_model_sha256=(
+            expected_candidate_prepared_model_sha256
+        ),
+    )
+    comparison = compare_captures(
+        baseline=evidence["baseline"],
+        candidate=evidence["candidate"],
+    )
+    campaign_identity = _validate_paired_campaign(
+        campaign_payload,
+        campaign_input_identity,
+        baseline=evidence["baseline"],
+        candidate=evidence["candidate"],
+    )
+    watchdog_identity = _validate_watchdog_report(
+        watchdog_payload,
+        watchdog_input_identity,
+        campaign=campaign_payload,
+        campaign_input_identity=campaign_input_identity,
+    )
+    unsigned = dict(comparison)
+    unsigned.pop("content_sha256")
+    inputs = dict(_mapping(unsigned.get("inputs"), "comparison.inputs"))
+    inputs["externally_pinned_role_inputs"] = expected_role_inputs
+    inputs["paired_campaign"] = dict(campaign_identity)
+    inputs["outer_memory_watchdog"] = dict(watchdog_identity)
+    unsigned["inputs"] = inputs
+    unsigned["content_sha256"] = _sha256(unsigned)
+    return unsigned
+
+
+def _write_json_atomic(path: Path, value: Mapping[str, object]) -> None:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        data = _canonical_json_bytes(value) + b"\n"
+        with tempfile.NamedTemporaryFile(
+            mode="wb",
+            dir=path.parent,
+            prefix=f".{path.name}.",
+            suffix=".tmp",
+            delete=False,
+        ) as stream:
+            temporary = Path(stream.name)
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+    except OSError as error:
+        raise EvidenceError(f"cannot write comparison JSON: {path}") from error
+    finally:
+        temporary_path = locals().get("temporary")
+        if isinstance(temporary_path, Path) and temporary_path.exists():
+            temporary_path.unlink()
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--campaign", type=Path, required=True)
+    result.add_argument("--watchdog-report", type=Path, required=True)
+    result.add_argument("--baseline-topology", type=Path, required=True)
+    result.add_argument("--baseline-all-flow-union", type=Path, required=True)
+    result.add_argument("--candidate-topology", type=Path, required=True)
+    result.add_argument("--candidate-all-flow-union", type=Path, required=True)
+    result.add_argument("--expected-candidate-source-revision", required=True)
+    result.add_argument(
+        "--expected-baseline-native-build-inputs-sha256",
+        required=True,
+    )
+    result.add_argument(
+        "--expected-candidate-native-build-inputs-sha256",
+        required=True,
+    )
+    result.add_argument(
+        "--expected-baseline-prepared-model-sha256",
+        required=True,
+    )
+    result.add_argument(
+        "--expected-candidate-prepared-model-sha256",
+        required=True,
+    )
+    result.add_argument("--output", type=Path, required=True)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    try:
+        comparison = compare_capture_files(
+            campaign=arguments.campaign,
+            watchdog_report=arguments.watchdog_report,
+            baseline_topology=arguments.baseline_topology,
+            baseline_all_flow_union=arguments.baseline_all_flow_union,
+            candidate_topology=arguments.candidate_topology,
+            candidate_all_flow_union=arguments.candidate_all_flow_union,
+            expected_candidate_source_revision=(
+                arguments.expected_candidate_source_revision
+            ),
+            expected_baseline_native_build_inputs_sha256=(
+                arguments.expected_baseline_native_build_inputs_sha256
+            ),
+            expected_candidate_native_build_inputs_sha256=(
+                arguments.expected_candidate_native_build_inputs_sha256
+            ),
+            expected_baseline_prepared_model_sha256=(
+                arguments.expected_baseline_prepared_model_sha256
+            ),
+            expected_candidate_prepared_model_sha256=(
+                arguments.expected_candidate_prepared_model_sha256
+            ),
+        )
+        _write_json_atomic(arguments.output, comparison)
+    except EvidenceError as error:
+        print(f"benchmark evidence error: {error}", file=sys.stderr)
+        return 2
+    return 0 if comparison["passes"] is True else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/symjit_2_22_paired_benchmark.py b/pyamplicol/tools/developer/symjit_2_22_paired_benchmark.py
new file mode 100644
index 0000000000..4a284c29c3
--- /dev/null
+++ b/pyamplicol/tools/developer/symjit_2_22_paired_benchmark.py
@@ -0,0 +1,1307 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run the SymJIT migration benchmark as alternating baseline/candidate pairs.
+
+The command itself must be run behind ``tools/ci/memory_watchdog.py`` with a
+30-GiB limit, ``--report-json``, and ``--bind-result-json`` naming this
+campaign's ``--result-json``.  It starts one authenticated capture driver at a
+time for generation, then admits exactly one profile worker at a time.
+Baseline and candidate workers for the same layout/mode/batch/round are
+adjacent, and the first role alternates by round.
+
+The candidate revision, both native build-input digests, and both prepared
+model digests are externally pinned CLI inputs. They are checked before useful
+measurement work and rechecked by the comparison gate.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import hashlib
+import json
+import math
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from collections.abc import Mapping, Sequence
+from contextlib import suppress
+from pathlib import Path
+from typing import Any, TextIO
+
+BASELINE_REVISION = "172e58fd33a3c65563866c50cfbb5e1ddcd7b302"
+LAYOUTS = ("topology-replay", "all-flow-union")
+AUTHORITATIVE_MODES = ("compiled", "recurrence")
+DIAGNOSTIC_MODES = ("eager",)
+BATCH_SIZES = (1, 128, 1024)
+ROLES = ("baseline", "candidate")
+MINIMUM_SUBPROCESS_SAMPLES = 7
+MINIMUM_WARMUPS = 2
+MINIMUM_TARGET_RUNTIME_SECONDS = 5.0
+MINIMUM_GENERATION_TIMEOUT_SECONDS = 10_800.0
+MINIMUM_COORDINATION_TIMEOUT_SECONDS = 43_200.0
+CAMPAIGN_KIND = "pyamplicol-symjit-2.22-paired-benchmark-campaign"
+CAMPAIGN_SCHEMA = 2
+HARNESS_IDENTITY_KIND = "pyamplicol-paired-benchmark-harness-identity"
+HARNESS_IDENTITY_SCHEMA = 1
+PAIRED_DRIVER_RELATIVE_PATH = "tools/developer/symjit_2_22_paired_benchmark.py"
+WATCHDOG_REPORT_KIND = "pyamplicol-memory-watchdog-execution-report"
+WATCHDOG_REPORT_SCHEMA = 2
+WATCHDOG_LIMIT_BYTES = 30 * 1024**3
+WATCHDOG_SCOPE = "complete-orchestrator-process-tree-v1"
+WATCHDOG_BINDING = "outer-command-session-result-v1"
+READY_KIND = "pyamplicol-paired-profile-ready"
+TOKEN_KIND = "pyamplicol-paired-profile-token"
+COMPLETION_KIND = "pyamplicol-paired-profile-completion"
+COORDINATION_SCHEMA = 1
+_SHA256 = re.compile(r"[0-9a-f]{64}")
+_REVISION = re.compile(r"[0-9a-f]{40}")
+
+
+class CampaignError(RuntimeError):
+    """Raised when a paired campaign cannot remain authenticated."""
+
+
+def _canonical_json_bytes(value: object) -> bytes:
+    try:
+        return json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    except (TypeError, ValueError) as error:
+        raise CampaignError("campaign evidence is not canonical JSON") from error
+
+
+def _sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_json_bytes(value)).hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    try:
+        with path.open("rb") as stream:
+            for block in iter(lambda: stream.read(1024 * 1024), b""):
+                digest.update(block)
+    except OSError as error:
+        raise CampaignError(f"cannot hash file: {path}") from error
+    return digest.hexdigest()
+
+
+def _validate_addressed_mapping(
+    payload: Mapping[str, object],
+    *,
+    label: str,
+) -> None:
+    unsigned = dict(payload)
+    digest = unsigned.pop("content_sha256", None)
+    if (
+        not isinstance(digest, str)
+        or _SHA256.fullmatch(digest) is None
+        or digest != _sha256(unsigned)
+    ):
+        raise CampaignError(f"{label} is not content-addressed")
+    _validate_nested_content_addresses(unsigned, label=label)
+
+
+def _validate_nested_content_addresses(value: object, *, label: str) -> None:
+    if isinstance(value, Mapping):
+        if "content_sha256" in value:
+            _validate_addressed_mapping(value, label=label)
+            return
+        for field, child in value.items():
+            _validate_nested_content_addresses(
+                child,
+                label=f"{label}.{field}",
+            )
+    elif isinstance(value, Sequence) and not isinstance(
+        value,
+        (str, bytes, bytearray),
+    ):
+        for index, child in enumerate(value):
+            _validate_nested_content_addresses(
+                child,
+                label=f"{label}[{index}]",
+            )
+
+
+def _address(payload: Mapping[str, object]) -> dict[str, object]:
+    _validate_nested_content_addresses(payload, label="campaign evidence")
+    result = dict(payload)
+    result["content_sha256"] = _sha256(result)
+    return result
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    try:
+        temporary.write_bytes(_canonical_json_bytes(payload) + b"\n")
+        os.replace(temporary, path)
+    except OSError as error:
+        raise CampaignError(f"cannot write campaign evidence: {path}") from error
+    finally:
+        if temporary.exists():
+            temporary.unlink()
+
+
+def _read_addressed(path: Path, *, label: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise CampaignError(f"{label} is not readable JSON: {path}") from error
+    if not isinstance(payload, dict):
+        raise CampaignError(f"{label} is not a JSON object: {path}")
+    try:
+        _validate_addressed_mapping(payload, label=label)
+    except CampaignError as error:
+        raise CampaignError(f"{error}: {path}") from error
+    return payload
+
+
+def _utc_now() -> str:
+    return dt.datetime.now(dt.UTC).isoformat()
+
+
+def _utc(value: object, *, label: str) -> dt.datetime:
+    if not isinstance(value, str):
+        raise CampaignError(f"{label} has no UTC timestamp")
+    try:
+        parsed = dt.datetime.fromisoformat(value)
+    except ValueError as error:
+        raise CampaignError(f"{label} has an invalid UTC timestamp") from error
+    if parsed.tzinfo is None or parsed.utcoffset() != dt.timedelta(0):
+        raise CampaignError(f"{label} timestamp is not UTC")
+    return parsed
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be positive")
+    return parsed
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0.0:
+        raise argparse.ArgumentTypeError("must be positive and finite")
+    return parsed
+
+
+def _revision_argument(value: str) -> str:
+    if _REVISION.fullmatch(value) is None:
+        raise argparse.ArgumentTypeError(
+            "must be a lowercase 40-digit Git revision"
+        )
+    return value
+
+
+def _sha256_argument(value: str) -> str:
+    if _SHA256.fullmatch(value) is None:
+        raise argparse.ArgumentTypeError(
+            "must be a lowercase 64-digit SHA-256 value"
+        )
+    return value
+
+
+def _source_revision(path: Path, *, role: str) -> str:
+    try:
+        root = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise CampaignError(f"{role} source root does not exist") from error
+    if not root.is_dir():
+        raise CampaignError(f"{role} source root is not a directory")
+    revision = subprocess.run(
+        ("git", "rev-parse", "--verify", "HEAD"),
+        cwd=root,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    top_level = subprocess.run(
+        ("git", "rev-parse", "--show-toplevel"),
+        cwd=root,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    status = subprocess.run(
+        ("git", "status", "--porcelain=v1", "--untracked-files=all"),
+        cwd=root,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    head = revision.stdout.strip()
+    if revision.returncode != 0 or _REVISION.fullmatch(head) is None:
+        raise CampaignError(f"{role} source root has no full Git revision")
+    repository_root_text = top_level.stdout.strip()
+    if top_level.returncode != 0 or not repository_root_text:
+        raise CampaignError(f"{role} source root has no Git top-level")
+    try:
+        repository_root = Path(repository_root_text).resolve(strict=True)
+    except OSError as error:
+        raise CampaignError(f"{role} source root has no Git top-level") from error
+    if repository_root != root:
+        raise CampaignError(f"{role} source root is not the exact Git repository root")
+    if status.returncode != 0 or status.stdout.strip():
+        raise CampaignError(f"{role} source root is not clean")
+    if role == "baseline" and head != BASELINE_REVISION:
+        raise CampaignError(
+            f"baseline source is not immutable revision {BASELINE_REVISION}"
+        )
+    if role == "candidate" and head == BASELINE_REVISION:
+        raise CampaignError("candidate source still identifies the baseline revision")
+    return head
+
+
+def _regular_file(path: Path, *, label: str) -> Path:
+    try:
+        resolved = path.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise CampaignError(f"{label} does not exist: {path}") from error
+    if not resolved.is_file():
+        raise CampaignError(f"{label} is not a regular file: {path}")
+    return resolved
+
+
+def _executable_file(path: Path, *, label: str) -> tuple[Path, Path]:
+    """Return the lexical executable path and its separately verified target."""
+
+    expanded = path.expanduser()
+    lexical = Path(os.path.abspath(expanded))
+    try:
+        resolved = lexical.resolve(strict=True)
+    except OSError as error:
+        raise CampaignError(f"{label} does not exist: {path}") from error
+    if not resolved.is_file():
+        raise CampaignError(f"{label} is not a regular file: {path}")
+    if not os.access(lexical, os.X_OK):
+        raise CampaignError(f"{label} is not executable: {path}")
+    return lexical, resolved
+
+
+def _head_bound_file_identity(
+    path: Path,
+    *,
+    source_root: Path,
+    label: str,
+) -> tuple[Path, dict[str, object]]:
+    """Return a tracked, HEAD-identical file and its content address."""
+
+    resolved = _regular_file(path, label=label)
+    try:
+        relative = resolved.relative_to(source_root)
+    except ValueError as error:
+        raise CampaignError(
+            f"{label} must come from the candidate source snapshot"
+        ) from error
+    relative_text = relative.as_posix()
+    tracked = subprocess.run(
+        ("git", "ls-files", "--error-unmatch", "--", relative_text),
+        cwd=source_root,
+        check=False,
+        capture_output=True,
+    )
+    if tracked.returncode != 0:
+        raise CampaignError(f"{label} is not tracked by the candidate repository")
+    head_blob = subprocess.run(
+        ("git", "cat-file", "blob", f"HEAD:{relative_text}"),
+        cwd=source_root,
+        check=False,
+        capture_output=True,
+    )
+    if head_blob.returncode != 0:
+        raise CampaignError(f"{label} is absent from candidate HEAD")
+    try:
+        working_bytes = resolved.read_bytes()
+    except OSError as error:
+        raise CampaignError(f"cannot read {label}: {resolved}") from error
+    matches_head = working_bytes == head_blob.stdout
+    if not matches_head:
+        raise CampaignError(f"{label} is not byte-identical to candidate HEAD")
+    identity = _address(
+        {
+            "kind": HARNESS_IDENTITY_KIND,
+            "schema_version": HARNESS_IDENTITY_SCHEMA,
+            "candidate_relative_path": relative_text,
+            "head_blob_sha256": hashlib.sha256(head_blob.stdout).hexdigest(),
+            "working_file_sha256": hashlib.sha256(working_bytes).hexdigest(),
+            "head_blob_equals_working_file": matches_head,
+        }
+    )
+    return resolved, identity
+
+
+def _head_bound_file(path: Path, *, source_root: Path, label: str) -> Path:
+    """Require a regular file to be tracked and byte-identical to ``HEAD``."""
+
+    resolved, _identity = _head_bound_file_identity(
+        path,
+        source_root=source_root,
+        label=label,
+    )
+    return resolved
+
+
+def _verify_campaign_inputs_unchanged(
+    *,
+    source_roots: Mapping[str, Path],
+    revisions: Mapping[str, str],
+    pythons: Mapping[str, Path],
+    python_targets: Mapping[str, Path],
+    python_hashes: Mapping[str, str],
+    prepared_models: Mapping[str, Path],
+    prepared_model_hashes: Mapping[str, str],
+    harness: Path,
+    harness_identity: Mapping[str, object],
+    orchestrator: Path,
+    orchestrator_identity: Mapping[str, object],
+) -> None:
+    for role in ROLES:
+        if _source_revision(source_roots[role], role=role) != revisions[role]:
+            raise CampaignError(f"{role} source revision changed during campaign")
+        current_python, current_target = _executable_file(
+            pythons[role],
+            label=f"{role} Python",
+        )
+        if (
+            current_python != pythons[role]
+            or current_target != python_targets[role]
+            or _sha256_file(current_target) != python_hashes[role]
+        ):
+            raise CampaignError(f"{role} Python changed during campaign")
+        current_prepared_model = _regular_file(
+            prepared_models[role],
+            label=f"{role} prepared model",
+        )
+        if (
+            current_prepared_model != prepared_models[role]
+            or _sha256_file(current_prepared_model) != prepared_model_hashes[role]
+        ):
+            raise CampaignError(f"{role} prepared model changed during campaign")
+    current_harness, current_harness_identity = _head_bound_file_identity(
+        harness,
+        source_root=source_roots["candidate"],
+        label="benchmark harness",
+    )
+    if current_harness != harness or current_harness_identity != dict(harness_identity):
+        raise CampaignError("benchmark harness changed during campaign")
+    current_orchestrator, current_orchestrator_identity = _head_bound_file_identity(
+        orchestrator,
+        source_root=source_roots["candidate"],
+        label="paired benchmark orchestrator",
+    )
+    if (
+        current_orchestrator != orchestrator
+        or current_orchestrator_identity != dict(orchestrator_identity)
+        or _sha256_file(Path(__file__).resolve())
+        != current_orchestrator_identity["working_file_sha256"]
+    ):
+        raise CampaignError("paired benchmark orchestrator changed during campaign")
+
+
+def _wait_for_record(
+    path: Path,
+    *,
+    label: str,
+    timeout: float,
+    process: subprocess.Popen[bytes] | None = None,
+) -> dict[str, Any]:
+    deadline = time.monotonic() + timeout
+    while not path.is_file():
+        if process is not None and process.poll() is not None:
+            raise CampaignError(
+                f"{label} producer exited with status {process.returncode}"
+            )
+        if time.monotonic() >= deadline:
+            raise CampaignError(f"timed out waiting for {label}: {path}")
+        time.sleep(0.1)
+    return _read_addressed(path, label=label)
+
+
+def _role_directory(
+    coordination_root: Path,
+    *,
+    session_id: str,
+    layout: str,
+    role: str,
+) -> Path:
+    return coordination_root / session_id / layout / role
+
+
+def _capture_command(
+    arguments: argparse.Namespace,
+    *,
+    role: str,
+    layout: str,
+    source_root: Path,
+    python: Path,
+    prepared_model: Path,
+    result_json: Path,
+    output_root: Path,
+    coordination_root: Path,
+) -> tuple[str, ...]:
+    modes = (
+        (*AUTHORITATIVE_MODES, *DIAGNOSTIC_MODES)
+        if arguments.include_eager
+        else AUTHORITATIVE_MODES
+    )
+    selector_arguments = (
+        (
+            "--color-flow",
+            arguments.topology_color_flow,
+            "--helicity",
+            arguments.topology_helicity,
+        )
+        if layout == "topology-replay"
+        else (
+            "--color-flow",
+            arguments.union_color_flow,
+            "--helicity",
+            arguments.union_helicity,
+        )
+    )
+    expected_runtime_arguments = (
+        "--expected-source-revision",
+        (
+            BASELINE_REVISION
+            if role == "baseline"
+            else arguments.expected_candidate_source_revision
+        ),
+        "--expected-native-build-inputs-sha256",
+        getattr(
+            arguments,
+            f"expected_{role}_native_build_inputs_sha256",
+        ),
+    )
+    return (
+        str(python),
+        str(arguments.harness),
+        "--output-root",
+        str(output_root),
+        "--result-json",
+        str(result_json),
+        "--prepared-model",
+        str(prepared_model),
+        *expected_runtime_arguments,
+        "--process-expression",
+        arguments.process_expression,
+        "--jit-optimization-level",
+        "3",
+        "--lc-flow-layout",
+        layout,
+        *sum((("--mode", mode) for mode in modes), ()),
+        "--batch-size",
+        "1",
+        "--batch-size",
+        "128",
+        "--batch-size",
+        "1024",
+        "--target-runtime",
+        str(arguments.target_runtime),
+        "--minimum-samples",
+        str(arguments.minimum_samples),
+        "--subprocess-samples",
+        str(arguments.subprocess_samples),
+        "--warmup-runs",
+        str(arguments.warmup_runs),
+        "--validation-samples",
+        str(arguments.validation_samples),
+        "--point-tile-size",
+        str(arguments.point_tile_size),
+        "--generation-timeout",
+        str(arguments.generation_timeout),
+        "--profile-timeout",
+        str(arguments.profile_timeout),
+        "--paired-profile-coordination-dir",
+        str(coordination_root),
+        "--paired-profile-role",
+        role,
+        "--paired-profile-session-id",
+        arguments.session_id,
+        "--paired-profile-wait-timeout",
+        str(arguments.coordination_timeout),
+        *selector_arguments,
+    )
+
+
+def _role_environment(
+    output_root: Path,
+    *,
+    source_root: Path,
+    role: str,
+) -> dict[str, str]:
+    environment = os.environ.copy()
+    cache_root = output_root / "workspace-local-environment" / role
+    paths = {
+        "TMPDIR": cache_root / "tmp",
+        "PIP_CACHE_DIR": cache_root / "pip-cache",
+        "XDG_CACHE_HOME": cache_root / "xdg-cache",
+        "PYTHONPYCACHEPREFIX": cache_root / "pycache",
+        "CARGO_HOME": cache_root / "cargo-home",
+        "CARGO_TARGET_DIR": cache_root / "cargo-target",
+    }
+    for path in paths.values():
+        path.mkdir(parents=True, exist_ok=True)
+    environment.update({key: str(path) for key, path in paths.items()})
+    environment["PYAMPLICOL_BENCHMARK_SOURCE_ROOT"] = str(source_root)
+    return environment
+
+
+def _start_capture(
+    command: Sequence[str],
+    *,
+    environment: Mapping[str, str],
+    log: TextIO,
+) -> subprocess.Popen[bytes]:
+    return subprocess.Popen(
+        tuple(command),
+        stdin=subprocess.DEVNULL,
+        stdout=log,
+        stderr=subprocess.STDOUT,
+        env=dict(environment),
+        start_new_session=True,
+    )
+
+
+def _signal_capture_group(
+    process: subprocess.Popen[bytes],
+    signal_number: int,
+) -> None:
+    """Signal the isolated capture group, falling back to its leader."""
+
+    killpg = getattr(os, "killpg", None)
+    if killpg is not None:
+        try:
+            killpg(process.pid, signal_number)
+            return
+        except (OSError, ValueError):
+            pass
+    if process.poll() is None:
+        with suppress(OSError, ValueError):
+            process.send_signal(signal_number)
+
+
+def _capture_group_exists(process: subprocess.Popen[bytes]) -> bool:
+    killpg = getattr(os, "killpg", None)
+    if killpg is not None:
+        try:
+            killpg(process.pid, 0)
+        except ProcessLookupError:
+            return False
+        except (OSError, ValueError):
+            return process.poll() is None
+        return True
+    return process.poll() is None
+
+
+def _terminate(
+    processes: Mapping[str, subprocess.Popen[bytes]],
+    *,
+    grace_seconds: float = 10.0,
+) -> None:
+    captures = tuple(processes.values())
+    for process in captures:
+        _signal_capture_group(process, signal.SIGTERM)
+    deadline = time.monotonic() + grace_seconds
+    while (
+        any(_capture_group_exists(process) for process in captures)
+        and time.monotonic() < deadline
+    ):
+        for process in captures:
+            process.poll()
+        time.sleep(0.05)
+    for process in captures:
+        if _capture_group_exists(process):
+            _signal_capture_group(process, signal.SIGKILL)
+    for process in captures:
+        try:
+            process.wait(timeout=1.0)
+        except subprocess.TimeoutExpired:
+            with suppress(OSError):
+                process.kill()
+            with suppress(subprocess.TimeoutExpired):
+                process.wait(timeout=1.0)
+
+
+def _validate_ready_pair(
+    baseline: Mapping[str, Any],
+    candidate: Mapping[str, Any],
+    *,
+    layout: str,
+    session_id: str,
+    baseline_revision: str,
+    candidate_revision: str,
+    modes: Sequence[str],
+    subprocess_samples: int,
+) -> list[dict[str, object]]:
+    for role, ready, revision in (
+        ("baseline", baseline, baseline_revision),
+        ("candidate", candidate, candidate_revision),
+    ):
+        expected = {
+            "kind": READY_KIND,
+            "schema_version": COORDINATION_SCHEMA,
+            "session_id": session_id,
+            "role": role,
+            "layout": layout,
+            "source_revision": revision,
+        }
+        if any(ready.get(field) != value for field, value in expected.items()):
+            raise CampaignError(f"{layout} {role} ready record has drifted")
+        _utc(ready.get("ready_at_utc"), label=f"{layout} {role} ready record")
+    baseline_plan = baseline.get("profile_schedule_plan")
+    candidate_plan = candidate.get("profile_schedule_plan")
+    if (
+        not isinstance(baseline_plan, list)
+        or baseline_plan != candidate_plan
+        or baseline.get("profile_schedule_plan_sha256") != _sha256(baseline_plan)
+        or candidate.get("profile_schedule_plan_sha256") != _sha256(candidate_plan)
+    ):
+        raise CampaignError(f"{layout} role profile plans are not identical")
+    expected_cells = {
+        (mode, batch_size, round_index)
+        for mode in modes
+        for batch_size in BATCH_SIZES
+        for round_index in range(subprocess_samples)
+    }
+    observed_cells = {
+        (entry.get("mode"), entry.get("batch_size"), entry.get("round"))
+        for entry in baseline_plan
+        if isinstance(entry, Mapping)
+    }
+    if len(baseline_plan) != len(expected_cells) or observed_cells != expected_cells:
+        raise CampaignError(f"{layout} profile plan is incomplete")
+    if any(
+        entry.get("schedule_index") != index
+        for index, entry in enumerate(baseline_plan)
+        if isinstance(entry, Mapping)
+    ):
+        raise CampaignError(f"{layout} profile plan indices are not canonical")
+    return [dict(entry) for entry in baseline_plan if isinstance(entry, Mapping)]
+
+
+def _issue_token(
+    coordination_root: Path,
+    *,
+    session_id: str,
+    layout: str,
+    role: str,
+    entry: Mapping[str, object],
+    pair_index: int,
+    order_in_pair: int,
+) -> dict[str, object]:
+    token = _address(
+        {
+            "kind": TOKEN_KIND,
+            "schema_version": COORDINATION_SCHEMA,
+            "session_id": session_id,
+            "role": role,
+            "layout": layout,
+            **{
+                field: entry.get(field)
+                for field in ("schedule_index", "round", "mode", "batch_size")
+            },
+            "pair_index": pair_index,
+            "order_in_pair": order_in_pair,
+            "issued_at_utc": _utc_now(),
+        }
+    )
+    schedule_index = entry["schedule_index"]
+    assert isinstance(schedule_index, int)
+    path = (
+        _role_directory(
+            coordination_root,
+            session_id=session_id,
+            layout=layout,
+            role=role,
+        )
+        / f"token-{schedule_index:06d}.json"
+    )
+    if path.exists():
+        raise CampaignError(f"paired scheduler token already exists: {path}")
+    _write_json_atomic(path, token)
+    return token
+
+
+def _validate_completion(
+    completion: Mapping[str, Any],
+    *,
+    token: Mapping[str, object],
+    role: str,
+    layout: str,
+    entry: Mapping[str, object],
+) -> dict[str, object]:
+    expected = {
+        "kind": COMPLETION_KIND,
+        "schema_version": COORDINATION_SCHEMA,
+        "session_id": token.get("session_id"),
+        "role": role,
+        "layout": layout,
+        "token_sha256": token.get("content_sha256"),
+        **{
+            field: entry.get(field)
+            for field in ("schedule_index", "round", "mode", "batch_size")
+        },
+    }
+    if any(completion.get(field) != value for field, value in expected.items()):
+        raise CampaignError(f"{layout} {role} completion does not match its token")
+    started = _utc(
+        completion.get("worker_started_at_utc"),
+        label=f"{layout} {role} worker start",
+    )
+    finished = _utc(
+        completion.get("worker_finished_at_utc"),
+        label=f"{layout} {role} worker finish",
+    )
+    recorded = _utc(
+        completion.get("recorded_at_utc"),
+        label=f"{layout} {role} completion",
+    )
+    issued = _utc(token.get("issued_at_utc"), label=f"{layout} {role} token")
+    if not issued <= started <= finished <= recorded:
+        raise CampaignError(f"{layout} {role} paired timestamps are inverted")
+    for field in ("worker_invocation_sha256", "worker_result_record_sha256"):
+        value = completion.get(field)
+        if not isinstance(value, str) or _SHA256.fullmatch(value) is None:
+            raise CampaignError(f"{layout} {role} completion lacks {field}")
+    return dict(completion)
+
+
+def _capture_identity(path: Path) -> dict[str, object]:
+    try:
+        resolved = path.resolve(strict=True)
+        stat = resolved.stat()
+    except OSError as error:
+        raise CampaignError(f"capture result does not exist: {path}") from error
+    return {
+        "path": str(path),
+        "resolved_path": str(resolved),
+        "size_bytes": stat.st_size,
+        "sha256": _sha256_file(resolved),
+    }
+
+
+def _run_layout(
+    arguments: argparse.Namespace,
+    *,
+    layout: str,
+    revisions: Mapping[str, str],
+    source_roots: Mapping[str, Path],
+    pythons: Mapping[str, Path],
+    prepared_models: Mapping[str, Path],
+    output_root: Path,
+    coordination_root: Path,
+) -> dict[str, object]:
+    processes: dict[str, subprocess.Popen[bytes]] = {}
+    logs: dict[str, TextIO] = {}
+    result_paths = {role: output_root / role / f"{layout}.json" for role in ROLES}
+    capture_roots = {role: output_root / role / layout for role in ROLES}
+    try:
+        for role in ROLES:
+            log_path = output_root / "logs" / f"{layout}-{role}.log"
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            log = log_path.open("w", encoding="utf-8")
+            logs[role] = log
+            command = _capture_command(
+                arguments,
+                role=role,
+                layout=layout,
+                source_root=source_roots[role],
+                python=pythons[role],
+                prepared_model=prepared_models[role],
+                result_json=result_paths[role],
+                output_root=capture_roots[role],
+                coordination_root=coordination_root,
+            )
+            processes[role] = _start_capture(
+                command,
+                environment=_role_environment(
+                    output_root,
+                    source_root=source_roots[role],
+                    role=role,
+                ),
+                log=log,
+            )
+            ready_path = (
+                _role_directory(
+                    coordination_root,
+                    session_id=arguments.session_id,
+                    layout=layout,
+                    role=role,
+                )
+                / "ready.json"
+            )
+            _wait_for_record(
+                ready_path,
+                label=f"{layout} {role} ready record",
+                timeout=arguments.coordination_timeout,
+                process=processes[role],
+            )
+
+        ready_records = {
+            role: _read_addressed(
+                _role_directory(
+                    coordination_root,
+                    session_id=arguments.session_id,
+                    layout=layout,
+                    role=role,
+                )
+                / "ready.json",
+                label=f"{layout} {role} ready record",
+            )
+            for role in ROLES
+        }
+        modes = (
+            (*AUTHORITATIVE_MODES, *DIAGNOSTIC_MODES)
+            if arguments.include_eager
+            else AUTHORITATIVE_MODES
+        )
+        plan = _validate_ready_pair(
+            ready_records["baseline"],
+            ready_records["candidate"],
+            layout=layout,
+            session_id=arguments.session_id,
+            baseline_revision=revisions["baseline"],
+            candidate_revision=revisions["candidate"],
+            modes=modes,
+            subprocess_samples=arguments.subprocess_samples,
+        )
+        pair_records: list[dict[str, object]] = []
+        previous_pair_finished: dt.datetime | None = None
+        for pair_index, entry in enumerate(plan):
+            round_index = entry.get("round")
+            assert isinstance(round_index, int)
+            role_order = (
+                ("baseline", "candidate")
+                if round_index % 2 == 0
+                else ("candidate", "baseline")
+            )
+            completions: dict[str, dict[str, object]] = {}
+            for order_in_pair, role in enumerate(role_order):
+                token = _issue_token(
+                    coordination_root,
+                    session_id=arguments.session_id,
+                    layout=layout,
+                    role=role,
+                    entry=entry,
+                    pair_index=pair_index,
+                    order_in_pair=order_in_pair,
+                )
+                schedule_index = entry["schedule_index"]
+                assert isinstance(schedule_index, int)
+                completion_path = (
+                    _role_directory(
+                        coordination_root,
+                        session_id=arguments.session_id,
+                        layout=layout,
+                        role=role,
+                    )
+                    / f"completion-{schedule_index:06d}.json"
+                )
+                completion = _wait_for_record(
+                    completion_path,
+                    label=f"{layout} {role} completion",
+                    timeout=arguments.coordination_timeout,
+                    process=processes[role],
+                )
+                completions[role] = _validate_completion(
+                    completion,
+                    token=token,
+                    role=role,
+                    layout=layout,
+                    entry=entry,
+                )
+            first = completions[role_order[0]]
+            second = completions[role_order[1]]
+            first_finished = _utc(
+                first["worker_finished_at_utc"],
+                label=f"{layout} first paired completion",
+            )
+            second_started = _utc(
+                second["worker_started_at_utc"],
+                label=f"{layout} second paired completion",
+            )
+            if first_finished > second_started:
+                raise CampaignError(f"{layout} paired profile workers overlapped")
+            pair_started = _utc(
+                first["worker_started_at_utc"],
+                label=f"{layout} pair start",
+            )
+            pair_finished = _utc(
+                second["worker_finished_at_utc"],
+                label=f"{layout} pair finish",
+            )
+            if (
+                previous_pair_finished is not None
+                and previous_pair_finished > pair_started
+            ):
+                raise CampaignError(f"{layout} profile pairs overlap or reorder")
+            previous_pair_finished = pair_finished
+            pair_records.append(
+                _address(
+                    {
+                        "kind": "pyamplicol-paired-profile-pair",
+                        "schema_version": COORDINATION_SCHEMA,
+                        "pair_index": pair_index,
+                        **{
+                            field: entry.get(field)
+                            for field in (
+                                "schedule_index",
+                                "round",
+                                "mode",
+                                "batch_size",
+                            )
+                        },
+                        "role_order": list(role_order),
+                        "completions": completions,
+                    }
+                )
+            )
+
+        for role, process in processes.items():
+            try:
+                return_code = process.wait(timeout=arguments.coordination_timeout)
+            except subprocess.TimeoutExpired as error:
+                raise CampaignError(f"{layout} {role} driver did not finish") from error
+            if return_code != 0:
+                raise CampaignError(
+                    f"{layout} {role} driver exited with status {return_code}"
+                )
+        return {
+            "layout": layout,
+            "ready_records": ready_records,
+            "paired_schedule_algorithm": (
+                "slot-adjacent-round-alternating-role-order-v1"
+            ),
+            "pairs": pair_records,
+            "captures": {role: _capture_identity(result_paths[role]) for role in ROLES},
+        }
+    except BaseException:
+        _terminate(processes)
+        raise
+    finally:
+        for log in logs.values():
+            log.close()
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--baseline-python", type=Path, required=True)
+    result.add_argument("--baseline-source-root", type=Path, required=True)
+    result.add_argument("--baseline-prepared-model", type=Path, required=True)
+    result.add_argument("--candidate-python", type=Path, required=True)
+    result.add_argument("--candidate-source-root", type=Path, required=True)
+    result.add_argument("--candidate-prepared-model", type=Path, required=True)
+    result.add_argument(
+        "--expected-candidate-source-revision",
+        type=_revision_argument,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-baseline-native-build-inputs-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-candidate-native-build-inputs-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-baseline-prepared-model-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+    result.add_argument(
+        "--expected-candidate-prepared-model-sha256",
+        type=_sha256_argument,
+        required=True,
+    )
+    result.add_argument(
+        "--harness",
+        type=Path,
+        default=Path(__file__).with_name("recurrence_z6g_benchmark.py"),
+    )
+    result.add_argument("--output-root", type=Path, required=True)
+    result.add_argument("--result-json", type=Path, required=True)
+    result.add_argument("--session-id", required=True)
+    eager = result.add_mutually_exclusive_group()
+    eager.add_argument(
+        "--include-eager",
+        dest="include_eager",
+        action="store_true",
+        default=True,
+        help="include the gate-required eager lane (default)",
+    )
+    eager.add_argument(
+        "--no-eager",
+        dest="include_eager",
+        action="store_false",
+        help="omit eager only for focused harness tests or diagnostics",
+    )
+    result.add_argument("--process-expression", default="d d~ > z + 6*g")
+    result.add_argument("--target-runtime", type=_positive_float, default=5.0)
+    result.add_argument(
+        "--minimum-samples",
+        type=_positive_int,
+        default=MINIMUM_SUBPROCESS_SAMPLES,
+    )
+    result.add_argument(
+        "--subprocess-samples",
+        type=_positive_int,
+        default=MINIMUM_SUBPROCESS_SAMPLES,
+    )
+    result.add_argument("--warmup-runs", type=int, default=MINIMUM_WARMUPS)
+    result.add_argument("--validation-samples", type=_positive_int, default=3)
+    result.add_argument("--point-tile-size", type=_positive_int, default=1024)
+    result.add_argument(
+        "--generation-timeout",
+        type=_positive_float,
+        default=MINIMUM_GENERATION_TIMEOUT_SECONDS,
+    )
+    result.add_argument("--profile-timeout", type=_positive_float, default=900.0)
+    result.add_argument(
+        "--coordination-timeout",
+        type=_positive_float,
+        default=MINIMUM_COORDINATION_TIMEOUT_SECONDS,
+    )
+    result.add_argument(
+        "--topology-color-flow",
+        default="flow:2,4,5,6,7,8,9,1",
+    )
+    result.add_argument("--topology-helicity", default="1")
+    result.add_argument("--union-color-flow", default="1")
+    result.add_argument(
+        "--union-helicity",
+        default="h:-1,+1,-1,+1,-1,+1,-1,+1,-1",
+    )
+    return result
+
+
+def run(arguments: argparse.Namespace) -> dict[str, object]:
+    if (
+        arguments.subprocess_samples != MINIMUM_SUBPROCESS_SAMPLES
+        or arguments.minimum_samples < MINIMUM_SUBPROCESS_SAMPLES
+        or arguments.warmup_runs != MINIMUM_WARMUPS
+        or arguments.target_runtime < MINIMUM_TARGET_RUNTIME_SECONDS
+    ):
+        raise CampaignError(
+            "paired campaign requires exactly seven independent subprocess "
+            "pairs, at least seven internal 5-second samples, and exactly two "
+            "warmups per subprocess"
+        )
+    if (
+        arguments.generation_timeout < MINIMUM_GENERATION_TIMEOUT_SECONDS
+        or arguments.coordination_timeout < MINIMUM_COORDINATION_TIMEOUT_SECONDS
+    ):
+        raise CampaignError(
+            "paired Z+6g campaign requires at least "
+            f"{MINIMUM_GENERATION_TIMEOUT_SECONDS:g} seconds for generation "
+            f"and {MINIMUM_COORDINATION_TIMEOUT_SECONDS:g} seconds for "
+            "coordination"
+        )
+    expected_candidate_revision = getattr(
+        arguments,
+        "expected_candidate_source_revision",
+        None,
+    )
+    if (
+        not isinstance(expected_candidate_revision, str)
+        or _REVISION.fullmatch(expected_candidate_revision) is None
+    ):
+        raise CampaignError(
+            "paired campaign requires an externally pinned candidate revision"
+        )
+    expected_sha256 = {
+        (role, identity): getattr(
+            arguments,
+            f"expected_{role}_{identity}_sha256",
+            None,
+        )
+        for role in ROLES
+        for identity in (
+            "native_build_inputs",
+            "prepared_model",
+        )
+    }
+    if any(
+        not isinstance(value, str) or _SHA256.fullmatch(value) is None
+        for value in expected_sha256.values()
+    ):
+        raise CampaignError(
+            "paired campaign requires externally pinned native-build and "
+            "prepared-model SHA-256 values for both roles"
+        )
+    if re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,127}", arguments.session_id) is None:
+        raise CampaignError("session ID is invalid")
+    normalized_process = " ".join(arguments.process_expression.split()).casefold()
+    if normalized_process not in {
+        "d d~ > z + 6*g",
+        "d d~ > z g g g g g g",
+    }:
+        raise CampaignError("paired migration campaign requires exact d d~ > Z+6g")
+    output_root = arguments.output_root.expanduser().resolve()
+    if output_root.exists():
+        raise CampaignError("paired campaign output root already exists")
+    result_json = arguments.result_json.expanduser().resolve()
+    if result_json.exists():
+        raise CampaignError("paired campaign result JSON already exists")
+    source_roots = {
+        role: getattr(arguments, f"{role}_source_root")
+        .expanduser()
+        .resolve(strict=True)
+        for role in ROLES
+    }
+    if source_roots["baseline"] == source_roots["candidate"]:
+        raise CampaignError("baseline and candidate source roots must be distinct")
+    revisions = {
+        role: _source_revision(source_roots[role], role=role) for role in ROLES
+    }
+    if revisions["candidate"] != expected_candidate_revision:
+        raise CampaignError(
+            "candidate source does not match the externally pinned revision"
+        )
+    orchestrator, orchestrator_identity = _head_bound_file_identity(
+        source_roots["candidate"] / PAIRED_DRIVER_RELATIVE_PATH,
+        source_root=source_roots["candidate"],
+        label="paired benchmark orchestrator",
+    )
+    if (
+        _sha256_file(Path(__file__).resolve())
+        != orchestrator_identity["working_file_sha256"]
+    ):
+        raise CampaignError(
+            "running paired benchmark orchestrator is not candidate HEAD"
+        )
+    arguments.harness, harness_identity = _head_bound_file_identity(
+        arguments.harness,
+        source_root=source_roots["candidate"],
+        label="benchmark harness",
+    )
+    python_identities = {
+        role: _executable_file(
+            getattr(arguments, f"{role}_python"),
+            label=f"{role} Python",
+        )
+        for role in ROLES
+    }
+    pythons = {role: identity[0] for role, identity in python_identities.items()}
+    python_targets = {role: identity[1] for role, identity in python_identities.items()}
+    python_hashes = {role: _sha256_file(python_targets[role]) for role in ROLES}
+    if python_hashes["baseline"] != python_hashes["candidate"]:
+        raise CampaignError(
+            "baseline and candidate must use the same Python interpreter binary"
+        )
+    prepared_models = {
+        role: _regular_file(
+            getattr(arguments, f"{role}_prepared_model"),
+            label=f"{role} prepared model",
+        )
+        for role in ROLES
+    }
+    prepared_model_hashes = {
+        role: _sha256_file(prepared_models[role]) for role in ROLES
+    }
+    for role in ROLES:
+        expected = expected_sha256[(role, "prepared_model")]
+        if prepared_model_hashes[role] != expected:
+            raise CampaignError(
+                f"{role} prepared model does not match the externally pinned "
+                "SHA-256 value"
+            )
+    output_root.mkdir(parents=True)
+    coordination_root = output_root / "coordination"
+    started_at = _utc_now()
+    layouts: dict[str, object] = {}
+    for layout in LAYOUTS:
+        layouts[layout] = _run_layout(
+            arguments,
+            layout=layout,
+            revisions=revisions,
+            source_roots=source_roots,
+            pythons=pythons,
+            prepared_models=prepared_models,
+            output_root=output_root,
+            coordination_root=coordination_root,
+        )
+    _verify_campaign_inputs_unchanged(
+        source_roots=source_roots,
+        revisions=revisions,
+        pythons=pythons,
+        python_targets=python_targets,
+        python_hashes=python_hashes,
+        prepared_models=prepared_models,
+        prepared_model_hashes=prepared_model_hashes,
+        harness=arguments.harness,
+        harness_identity=harness_identity,
+        orchestrator=orchestrator,
+        orchestrator_identity=orchestrator_identity,
+    )
+    payload = {
+        "kind": CAMPAIGN_KIND,
+        "schema_version": CAMPAIGN_SCHEMA,
+        "complete": True,
+        "session_id": arguments.session_id,
+        "started_at_utc": started_at,
+        "finished_at_utc": _utc_now(),
+        "process": "d d~ > Z g g g g g g",
+        "orchestrator": orchestrator_identity,
+        "harness": harness_identity,
+        "roles": {
+            role: {
+                "source_root": str(source_roots[role]),
+                "source_revision": revisions[role],
+                "python": str(pythons[role]),
+                "python_resolved_target": str(python_targets[role]),
+                "python_sha256": python_hashes[role],
+                "prepared_model": str(prepared_models[role]),
+                "prepared_model_sha256": prepared_model_hashes[role],
+            }
+            for role in ROLES
+        },
+        "configuration": {
+            "authoritative_modes": list(AUTHORITATIVE_MODES),
+            "diagnostic_modes": (
+                list(DIAGNOSTIC_MODES) if arguments.include_eager else []
+            ),
+            "batch_sizes": list(BATCH_SIZES),
+            "target_runtime_seconds": arguments.target_runtime,
+            "minimum_samples": arguments.minimum_samples,
+            "subprocess_samples": arguments.subprocess_samples,
+            "warmup_runs": arguments.warmup_runs,
+            "watchdog": {
+                "required": True,
+                "report_kind": WATCHDOG_REPORT_KIND,
+                "report_schema_version": WATCHDOG_REPORT_SCHEMA,
+                "limit_bytes": WATCHDOG_LIMIT_BYTES,
+                "scope": WATCHDOG_SCOPE,
+                "binding": WATCHDOG_BINDING,
+            },
+        },
+        "layouts": layouts,
+    }
+    addressed = _address(payload)
+    _write_json_atomic(result_json, addressed)
+    return addressed
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    try:
+        result = run(parser().parse_args(argv))
+    except (CampaignError, OSError, ValueError) as error:
+        print(f"paired benchmark campaign: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, indent=2, sort_keys=True, allow_nan=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/x86_performance_runtime_bundle.py b/pyamplicol/tools/developer/x86_performance_runtime_bundle.py
new file mode 100644
index 0000000000..e3655cb246
--- /dev/null
+++ b/pyamplicol/tools/developer/x86_performance_runtime_bundle.py
@@ -0,0 +1,1141 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Build-time authentication helpers for the x86 performance runtime bundle.
+
+The frozen pre-Arena candidate predates reproducible dependency-state
+timestamps.  ``freeze-baseline`` restores the already accepted generated state
+only after every path-independent dependency input matches its pinned digest.
+The other commands content-bind or verify the two installed candidates, their
+shared external dependency distributions, wheel bytes, and the UFO prepared
+model used by the recurrence comparison.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.metadata
+import json
+import os
+import platform
+import re
+import shutil
+import stat
+import subprocess
+import sys
+import venv
+from collections.abc import Mapping, Sequence
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.developer import compiled_mode_matrix as matrix  # noqa: E402
+from tools.developer import compiled_mode_regression as regression  # noqa: E402
+
+BUNDLE_KIND = "pyamplicol-x86-performance-runtime-bundle"
+BASELINE_ATTESTATION_KIND = "pyamplicol-frozen-baseline-source-attestation"
+SCHEMA_VERSION = 1
+CONTENT_IDENTITY_ALGORITHM = "sha256-canonical-json-body-v1"
+FROZEN_SOURCE_ROOT = Path("/private/tmp/pyamplicol-eager-compiled-arena-base-src")
+FROZEN_CANDIDATE_LOCK_SHA256 = (
+    "3ec1fd00ed1369adcb736a6816495bb21bcc11a377d0922a59cc0b845a0df3ef"
+)
+FROZEN_CARGO_CONFIG_SHA256 = (
+    "f14f5d6595a26680e636c5f25f2ea9d88772a6e44b6777c363cb8b810e2ca661"
+)
+FROZEN_INSTALL_STATE_SHA256 = (
+    "d4835339f2e35ac5e3ba4ec10941f6cffa4465fec505e3560e25e7eba534bb09"
+)
+_SHA256 = re.compile(r"[0-9a-f]{64}")
+_GIT_SHA = re.compile(r"[0-9a-f]{40}")
+_BASELINE_IGNORED_ENTRY_LIMIT = 100_000
+_BASELINE_GENERATED_FILES = (
+    "dependencies/candidate-Cargo.lock",
+    "dependencies/candidate-cargo-config.toml",
+    "dependencies/install-state.json",
+)
+_BASELINE_BOOTSTRAP_ROOTS = (
+    ".venv/",
+    "dependencies/checkouts/",
+    "dependencies/wheelhouse/",
+)
+
+FROZEN_INSTALL_STATE: dict[str, object] = {
+    "candidate_lock_sha256": FROZEN_CANDIDATE_LOCK_SHA256,
+    "cargo_config_sha256": FROZEN_CARGO_CONFIG_SHA256,
+    "contributor_lock_sha256": (
+        "91a4cd4d03bc3d35b7e2794f04bed4580428f5d17ea2f846fa530c5df8197cb5"
+    ),
+    "created_utc": "2026-07-24T16:52:37.275744+00:00",
+    "patches": [
+        {
+            "applies_to_revision": "48197f32536c894b51ef25b2cf05ddd05c22675f",
+            "name": "symjit-aarch64-compression-and-direct-arena",
+            "path": "patches/symjit/0001-aarch64-compression-and-direct-arena.patch",
+            "sha256": (
+                "6d456e69fc160ec5361188f60f994d10fb2dd3360eb47a91c4979a1bde69626e"
+            ),
+            "target": "symjit",
+        }
+    ],
+    "publishable": False,
+    "python_runtime_lock_sha256": (
+        "f8c929cfe925630a96e1a9d80bb8d6106964ace84a4efc4df171784a4f8f522b"
+    ),
+    "release_lock_sha256": (
+        "3302cacd840eb9f14e9e00e4c4c712d1a4735a45c1702224b84e4f34385f50ee"
+    ),
+    "schema_version": 1,
+    "sources": {
+        "gammaloop": {
+            "revision": "fff1d66ee7ca039b9e165fe8d29da91f4c27113c",
+            "url": "https://github.com/alphal00p/gammaloop.git",
+            "worktree_sha256": (
+                "2576a8cd3bd5cd58c649af7c6b480d7a8c3ed86afd0c7ac8b20be605d7e9f005"
+            ),
+        },
+        "legacy-amplicol": {
+            "branch": "amplicol_with_patches",
+            "revision": "79c96cecf2a722e50c3d2030b6894d755f96518a",
+            "url": "git@github.com:rikkert-frederix/AmpliCol.git",
+            "worktree_sha256": (
+                "2b6678c6fe477fcc0f99b5ed636e34b6c783ba778c328268e57d34de44bd7d65"
+            ),
+        },
+        "symbolica": {
+            "revision": "77c137481904b8a5531ede86e3ef36b82beed7fd",
+            "url": "https://github.com/symbolica-dev/symbolica.git",
+            "worktree_sha256": (
+                "3a52b012e62783988a9567260d022b049d9d07183a8604e7cbfc99218344cd59"
+            ),
+        },
+        "symbolica-community": {
+            "revision": "0deaa0f1484ec5c24f5f109176fa66f0d30134ca",
+            "url": "https://github.com/symbolica-dev/symbolica-community.git",
+            "worktree_sha256": (
+                "bbe726e158192c2bac478cf482f68576d8bd49d06f28282e0e4cc5fa43c1c479"
+            ),
+        },
+        "symjit": {
+            "archive_sha256": (
+                "876930348cc06761ca780570fb282d009f143f4a469e321e3b5039c5ee217424"
+            ),
+            "patch_sha256": (
+                "6d456e69fc160ec5361188f60f994d10fb2dd3360eb47a91c4979a1bde69626e"
+            ),
+            "revision": "48197f32536c894b51ef25b2cf05ddd05c22675f",
+            "url": (
+                "https://github.com/siravan/symjit/archive/"
+                "48197f32536c894b51ef25b2cf05ddd05c22675f.tar.gz"
+            ),
+            "version": "2.21.1",
+            "worktree_sha256": (
+                "932bb24df2633cc8bbf9c743a80282662d11e70b692885de5ff7a3ed20b3df31"
+            ),
+        },
+    },
+}
+
+
+class BundleError(RuntimeError):
+    """Raised when the runtime bundle cannot be authenticated."""
+
+
+def _canonical_bytes(value: object) -> bytes:
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode()
+
+
+def _canonical_sha256(value: object) -> str:
+    return hashlib.sha256(_canonical_bytes(value)).hexdigest()
+
+
+def _attach_content_identity(body: Mapping[str, object]) -> dict[str, object]:
+    result = dict(body)
+    result["content_identity"] = {
+        "algorithm": CONTENT_IDENTITY_ALGORITHM,
+        "sha256": _canonical_sha256(body),
+    }
+    return result
+
+
+def _require_content_identity(payload: Mapping[str, object]) -> None:
+    identity = payload.get("content_identity")
+    body = dict(payload)
+    body.pop("content_identity", None)
+    if (
+        not isinstance(identity, Mapping)
+        or set(identity) != {"algorithm", "sha256"}
+        or identity.get("algorithm") != CONTENT_IDENTITY_ALGORITHM
+        or identity.get("sha256") != _canonical_sha256(body)
+    ):
+        raise BundleError("runtime bundle content identity is invalid")
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _file_identity(path: Path) -> dict[str, object]:
+    expanded = path.expanduser().absolute()
+    try:
+        before = expanded.lstat()
+    except OSError as error:
+        raise BundleError(f"cannot inspect bundle input: {path}") from error
+    if not stat.S_ISREG(before.st_mode) or expanded.is_symlink():
+        raise BundleError(f"bundle input is not a regular non-symlink file: {path}")
+    resolved = expanded.resolve(strict=True)
+    digest = _sha256_file(resolved)
+    try:
+        after = expanded.lstat()
+    except OSError as error:
+        raise BundleError(f"cannot recheck bundle input: {path}") from error
+    stable_fields = ("st_dev", "st_ino", "st_mode", "st_size", "st_mtime_ns")
+    if any(getattr(before, field) != getattr(after, field) for field in stable_fields):
+        raise BundleError(f"bundle input changed while it was hashed: {path}")
+    return {
+        "relative_path": None,
+        "size_bytes": before.st_size,
+        "sha256": digest,
+    }
+
+
+def _reject_constant(value: str) -> None:
+    raise BundleError(f"non-finite JSON constant is forbidden: {value}")
+
+
+def _reject_duplicate_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise BundleError(f"duplicate JSON key is forbidden: {key}")
+        result[key] = value
+    return result
+
+
+def _checked_json(path: Path, *, label: str) -> dict[str, Any]:
+    expanded = path.expanduser().absolute()
+    try:
+        before = expanded.lstat()
+    except OSError as error:
+        raise BundleError(f"cannot inspect {label}") from error
+    if not stat.S_ISREG(before.st_mode) or expanded.is_symlink() or before.st_size <= 0:
+        raise BundleError(f"{label} is not a nonempty regular non-symlink file")
+    try:
+        encoded = expanded.read_bytes()
+        after = expanded.lstat()
+    except OSError as error:
+        raise BundleError(f"cannot read {label}") from error
+    stable_fields = ("st_dev", "st_ino", "st_mode", "st_size", "st_mtime_ns")
+    if any(getattr(before, field) != getattr(after, field) for field in stable_fields):
+        raise BundleError(f"{label} changed while it was read")
+    try:
+        payload = json.loads(
+            encoded,
+            parse_constant=_reject_constant,
+            object_pairs_hook=_reject_duplicate_keys,
+        )
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise BundleError(f"{label} is not strict JSON") from error
+    if not isinstance(payload, dict):
+        raise BundleError(f"{label} is not a JSON object")
+    return payload
+
+
+def _git_output(root: Path, *arguments: str) -> str:
+    completed = subprocess.run(
+        ("git", *arguments),
+        cwd=root,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        raise BundleError(f"git inspection failed: {completed.stderr.strip()}")
+    return completed.stdout
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def frozen_install_state_bytes() -> bytes:
+    return (
+        json.dumps(
+            FROZEN_INSTALL_STATE,
+            indent=2,
+            sort_keys=True,
+            allow_nan=False,
+        )
+        + "\n"
+    ).encode()
+
+
+def frozen_cargo_config_bytes() -> bytes:
+    root = FROZEN_SOURCE_ROOT.as_posix()
+    return (
+        "# Generated by dependencies/install_dependencies.py\n"
+        "[patch.crates-io]\n"
+        f'graphica = {{ path = "{root}/dependencies/checkouts/'
+        'symbolica/lib/graphica" }\n'
+        f'numerica = {{ path = "{root}/dependencies/checkouts/'
+        'symbolica/lib/numerica" }\n'
+        f'symbolica = {{ path = "{root}/dependencies/checkouts/symbolica" }}\n'
+        f'symjit = {{ path = "{root}/dependencies/checkouts/symjit" }}\n'
+    ).encode()
+
+
+def _baseline_ignored_inventory(root: Path) -> dict[str, object]:
+    status = _git_output(root, "status", "--porcelain=v1", "--untracked-files=all")
+    if status:
+        raise BundleError("frozen baseline has tracked or unexpected source changes")
+    raw_ignored = _git_output(
+        root,
+        "ls-files",
+        "--others",
+        "--ignored",
+        "--exclude-standard",
+        "-z",
+    )
+    ignored = sorted(path for path in raw_ignored.split("\0") if path)
+    unexpected = [
+        path
+        for path in ignored
+        if path not in _BASELINE_GENERATED_FILES
+        and not any(path.startswith(prefix) for prefix in _BASELINE_BOOTSTRAP_ROOTS)
+    ]
+    if unexpected:
+        raise BundleError(
+            "frozen baseline has unexpected ignored source/bootstrap files: "
+            + ", ".join(unexpected[:20])
+        )
+    missing_generated = [
+        relative
+        for relative in _BASELINE_GENERATED_FILES
+        if not (root / relative).is_file()
+    ]
+    missing_roots = [
+        relative
+        for relative in _BASELINE_BOOTSTRAP_ROOTS
+        if not (root / relative).is_dir()
+    ]
+    if missing_generated or missing_roots:
+        raise BundleError(
+            "frozen baseline bootstrap is incomplete: "
+            f"files={missing_generated}, roots={missing_roots}"
+        )
+    ignored_entries_by_bootstrap_root = {
+        relative.rstrip("/"): sum(path.startswith(relative) for path in ignored)
+        for relative in _BASELINE_BOOTSTRAP_ROOTS
+    }
+    return {
+        "tracked_and_untracked_status_clean": True,
+        "ignored_entry_count": len(ignored),
+        "ignored_relative_paths": ignored,
+        "ignored_paths_sha256": _canonical_sha256(ignored),
+        "ignored_entries_by_bootstrap_root": (ignored_entries_by_bootstrap_root),
+        "allowed_generated_files": list(_BASELINE_GENERATED_FILES),
+        "allowed_bootstrap_roots": list(_BASELINE_BOOTSTRAP_ROOTS),
+        "unexpected_ignored_files": [],
+    }
+
+
+def _baseline_generated_identities(root: Path) -> dict[str, object]:
+    generated_files: dict[str, object] = {}
+    for relative in _BASELINE_GENERATED_FILES:
+        identity = _file_identity(root / relative)
+        identity["relative_path"] = relative
+        generated_files[relative] = identity
+    bootstrap_trees: dict[str, object] = {}
+    for relative in _BASELINE_BOOTSTRAP_ROOTS:
+        logical_path = relative.rstrip("/")
+        identity = regression._tree_identity(root / relative)
+        identity["relative_path"] = logical_path
+        bootstrap_trees[logical_path] = identity
+    return {
+        "generated_files": generated_files,
+        "bootstrap_trees": bootstrap_trees,
+    }
+
+
+def freeze_baseline(source_root: Path) -> dict[str, object]:
+    root = source_root.expanduser().resolve(strict=True)
+    if hashlib.sha256(frozen_cargo_config_bytes()).hexdigest() != (
+        FROZEN_CARGO_CONFIG_SHA256
+    ):
+        raise BundleError("frozen cargo-config path contract is inconsistent")
+    if root != FROZEN_SOURCE_ROOT:
+        raise BundleError(
+            f"frozen baseline must use the path {FROZEN_SOURCE_ROOT}, got {root}"
+        )
+    if _git_output(root, "rev-parse", "--verify", "HEAD").strip() != (
+        matrix.FROZEN_BASELINE_SOURCE_REVISION
+    ):
+        raise BundleError("baseline checkout is not the frozen source revision")
+    ignored_inventory = _baseline_ignored_inventory(root)
+    dependencies = root / "dependencies"
+    lock = dependencies / "candidate-Cargo.lock"
+    config = dependencies / "candidate-cargo-config.toml"
+    state = dependencies / "install-state.json"
+    identities = {
+        "candidate_lock": _sha256_file(lock),
+        "cargo_config": _sha256_file(config),
+    }
+    if identities != {
+        "candidate_lock": FROZEN_CANDIDATE_LOCK_SHA256,
+        "cargo_config": FROZEN_CARGO_CONFIG_SHA256,
+    }:
+        raise BundleError(f"generated baseline dependency inputs differ: {identities}")
+    if state.is_file():
+        try:
+            generated = json.loads(state.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as error:
+            raise BundleError("generated baseline install state is invalid") from error
+        if not isinstance(generated, dict):
+            raise BundleError("generated baseline install state is not an object")
+        for key in (
+            "candidate_lock_sha256",
+            "cargo_config_sha256",
+            "contributor_lock_sha256",
+            "patches",
+            "publishable",
+            "python_runtime_lock_sha256",
+            "release_lock_sha256",
+            "schema_version",
+        ):
+            if generated.get(key) != FROZEN_INSTALL_STATE[key]:
+                raise BundleError(
+                    f"generated baseline state disagrees with frozen field {key}"
+                )
+        generated_sources = generated.get("sources")
+        frozen_sources = FROZEN_INSTALL_STATE["sources"]
+        if not isinstance(generated_sources, Mapping) or not isinstance(
+            frozen_sources, Mapping
+        ):
+            raise BundleError("generated baseline source inventory is invalid")
+        for name, frozen in frozen_sources.items():
+            if name == "legacy-amplicol" and name not in generated_sources:
+                continue
+            if generated_sources.get(name) != frozen:
+                raise BundleError(
+                    f"generated baseline source {name} differs from the freeze"
+                )
+    encoded = frozen_install_state_bytes()
+    if hashlib.sha256(encoded).hexdigest() != FROZEN_INSTALL_STATE_SHA256:
+        raise AssertionError("embedded frozen install state bytes changed")
+    temporary = state.with_name(f".{state.name}.tmp-{os.getpid()}")
+    temporary.write_bytes(encoded)
+    os.replace(temporary, state)
+    result = _attach_content_identity(
+        {
+            "kind": BASELINE_ATTESTATION_KIND,
+            "schema_version": SCHEMA_VERSION,
+            "source_root": str(root),
+            "source_revision": matrix.FROZEN_BASELINE_SOURCE_REVISION,
+            "native_build_inputs_sha256": (matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256),
+            "candidate_lock_sha256": identities["candidate_lock"],
+            "cargo_config_sha256": identities["cargo_config"],
+            "install_state_sha256": _sha256_file(state),
+            "source_inventory": ignored_inventory,
+            "generated_identity": _baseline_generated_identities(root),
+            "passes": _sha256_file(state) == FROZEN_INSTALL_STATE_SHA256,
+        }
+    )
+    if result["passes"] is not True or not _valid_baseline_attestation_payload(result):
+        raise BundleError("frozen install state could not be materialized exactly")
+    return result
+
+
+def _stable_installation(identity: Mapping[str, Any]) -> dict[str, object]:
+    build_files = identity.get("build_info_files")
+    native_modules = identity.get("native_modules")
+    distribution = identity.get("distribution_content")
+    if (
+        not isinstance(build_files, list)
+        or len(build_files) != 1
+        or not isinstance(build_files[0], Mapping)
+        or not isinstance(build_files[0].get("payload"), Mapping)
+        or not isinstance(native_modules, list)
+        or len(native_modules) != 1
+        or not isinstance(native_modules[0], Mapping)
+        or not isinstance(distribution, Mapping)
+    ):
+        raise BundleError("installed pyamplicol identity is incomplete")
+    payload = dict(build_files[0]["payload"])
+    return {
+        "package_version": identity.get("package_version"),
+        "build_info": payload,
+        "build_info_sha256": build_files[0].get("sha256"),
+        "distribution_content": {
+            key: distribution.get(key)
+            for key in ("algorithm", "sha256", "file_count", "size_bytes")
+        },
+        "native_module": {
+            key: native_modules[0].get(key)
+            for key in ("relative_path", "sha256", "size_bytes")
+        },
+    }
+
+
+def _installation(python: Path) -> dict[str, object]:
+    identity = regression._installed_pyamplicol_identity(
+        python.expanduser().resolve(strict=True),
+        environment=regression._environment(),
+    )
+    return _stable_installation(identity)
+
+
+def _stable_dependency_site(path: Path) -> dict[str, object]:
+    identity = regression._dependency_site_identity(path)
+    distributions = identity["distributions"]
+    return {
+        "algorithm": identity["algorithm"],
+        "sha256": identity["sha256"],
+        "distributions": {
+            name: {
+                key: record[key]
+                for key in (
+                    "name",
+                    "version",
+                    "algorithm",
+                    "sha256",
+                    "file_count",
+                    "size_bytes",
+                )
+            }
+            for name, record in sorted(distributions.items())
+        },
+    }
+
+
+def _wheel_inventory(root: Path) -> dict[str, dict[str, object]]:
+    result: dict[str, dict[str, object]] = {}
+    wheels_root = root / "wheels"
+    if (
+        not wheels_root.is_dir()
+        or wheels_root.is_symlink()
+        or {path.name for path in wheels_root.iterdir()} != {"baseline", "current"}
+    ):
+        raise BundleError("runtime bundle wheel lane inventory is not exact")
+    for lane in ("baseline", "current"):
+        lane_root = wheels_root / lane
+        entries = sorted(lane_root.iterdir(), key=lambda path: path.name)
+        candidates = [
+            path
+            for path in entries
+            if path.suffix == ".whl" and path.is_file() and not path.is_symlink()
+        ]
+        if len(candidates) != 1 or entries != candidates:
+            raise BundleError(
+                f"runtime bundle requires exactly one file, the {lane} wheel"
+            )
+        identity = _file_identity(candidates[0])
+        identity["relative_path"] = candidates[0].relative_to(root).as_posix()
+        result[lane] = identity
+    return result
+
+
+def _prepared_inventory(root: Path) -> dict[str, object]:
+    path = root / "prepared-models" / "ufo-sm-jit-o2.pyamplicol-model"
+    identity = _file_identity(path)
+    identity["relative_path"] = path.relative_to(root).as_posix()
+    return identity
+
+
+def _nonnegative_integer(value: object) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool) and value >= 0
+
+
+def _positive_integer(value: object) -> bool:
+    return _nonnegative_integer(value) and value > 0
+
+
+def _valid_ignored_relative_path(value: object) -> bool:
+    if not isinstance(value, str) or not value or "\\" in value:
+        return False
+    directory_marker = value.endswith("/")
+    path = value[:-1] if directory_marker else value
+    if not path:
+        return False
+    normalized = PurePosixPath(path)
+    expected = normalized.as_posix() + ("/" if directory_marker else "")
+    return (
+        value == expected
+        and expected not in {".", "./"}
+        and not normalized.is_absolute()
+        and ".." not in normalized.parts
+    )
+
+
+def _valid_generated_file_identity(
+    value: object,
+    *,
+    relative_path: str,
+    expected_sha256: str,
+) -> bool:
+    return (
+        isinstance(value, Mapping)
+        and set(value) == {"relative_path", "size_bytes", "sha256"}
+        and value.get("relative_path") == relative_path
+        and _positive_integer(value.get("size_bytes"))
+        and value.get("sha256") == expected_sha256
+    )
+
+
+def _valid_bootstrap_tree_identity(
+    value: object,
+    *,
+    relative_path: str,
+) -> bool:
+    return (
+        isinstance(value, Mapping)
+        and set(value)
+        == {
+            "algorithm",
+            "relative_path",
+            "sha256",
+            "file_count",
+            "size_bytes",
+        }
+        and value.get("algorithm") == "sha256-relative-path-size-content-v1"
+        and value.get("relative_path") == relative_path
+        and isinstance(value.get("sha256"), str)
+        and _SHA256.fullmatch(str(value.get("sha256"))) is not None
+        and _positive_integer(value.get("file_count"))
+        and _positive_integer(value.get("size_bytes"))
+    )
+
+
+def _valid_baseline_attestation_payload(payload: Mapping[str, object]) -> bool:
+    source_inventory = payload.get("source_inventory")
+    generated_identity = payload.get("generated_identity")
+    if (
+        not isinstance(source_inventory, Mapping)
+        or set(source_inventory)
+        != {
+            "tracked_and_untracked_status_clean",
+            "ignored_entry_count",
+            "ignored_relative_paths",
+            "ignored_paths_sha256",
+            "ignored_entries_by_bootstrap_root",
+            "allowed_generated_files",
+            "allowed_bootstrap_roots",
+            "unexpected_ignored_files",
+        }
+        or source_inventory.get("tracked_and_untracked_status_clean") is not True
+        or source_inventory.get("allowed_generated_files")
+        != list(_BASELINE_GENERATED_FILES)
+        or source_inventory.get("allowed_bootstrap_roots")
+        != list(_BASELINE_BOOTSTRAP_ROOTS)
+        or source_inventory.get("unexpected_ignored_files") != []
+        or not isinstance(generated_identity, Mapping)
+        or set(generated_identity) != {"generated_files", "bootstrap_trees"}
+    ):
+        return False
+    ignored_paths = source_inventory.get("ignored_relative_paths")
+    ignored_counts = source_inventory.get("ignored_entries_by_bootstrap_root")
+    bootstrap_paths = {
+        relative.rstrip("/"): relative for relative in _BASELINE_BOOTSTRAP_ROOTS
+    }
+    if (
+        not isinstance(ignored_paths, list)
+        or not 0 < len(ignored_paths) <= _BASELINE_IGNORED_ENTRY_LIMIT
+        or any(not _valid_ignored_relative_path(path) for path in ignored_paths)
+        or ignored_paths != sorted(set(ignored_paths))
+        or source_inventory.get("ignored_entry_count") != len(ignored_paths)
+        or source_inventory.get("ignored_paths_sha256")
+        != _canonical_sha256(ignored_paths)
+        or not isinstance(ignored_counts, Mapping)
+        or set(ignored_counts) != set(bootstrap_paths)
+        or any(not _nonnegative_integer(count) for count in ignored_counts.values())
+        or any(relative not in ignored_paths for relative in _BASELINE_GENERATED_FILES)
+        or any(
+            path not in _BASELINE_GENERATED_FILES
+            and not any(path.startswith(prefix) for prefix in bootstrap_paths.values())
+            for path in ignored_paths
+        )
+        or any(
+            ignored_counts[logical]
+            != sum(path.startswith(prefix) for path in ignored_paths)
+            for logical, prefix in bootstrap_paths.items()
+        )
+        or len(_BASELINE_GENERATED_FILES) + sum(ignored_counts.values())
+        != len(ignored_paths)
+    ):
+        return False
+    generated_files = generated_identity.get("generated_files")
+    bootstrap_trees = generated_identity.get("bootstrap_trees")
+    expected_file_sha256 = {
+        "dependencies/candidate-Cargo.lock": FROZEN_CANDIDATE_LOCK_SHA256,
+        "dependencies/candidate-cargo-config.toml": FROZEN_CARGO_CONFIG_SHA256,
+        "dependencies/install-state.json": FROZEN_INSTALL_STATE_SHA256,
+    }
+    expected_bootstrap_paths = {
+        relative.rstrip("/") for relative in _BASELINE_BOOTSTRAP_ROOTS
+    }
+    return (
+        isinstance(generated_files, Mapping)
+        and set(generated_files) == set(_BASELINE_GENERATED_FILES)
+        and all(
+            _valid_generated_file_identity(
+                generated_files.get(relative),
+                relative_path=relative,
+                expected_sha256=expected_file_sha256[relative],
+            )
+            for relative in _BASELINE_GENERATED_FILES
+        )
+        and isinstance(bootstrap_trees, Mapping)
+        and set(bootstrap_trees) == expected_bootstrap_paths
+        and all(
+            _valid_bootstrap_tree_identity(
+                bootstrap_trees.get(relative),
+                relative_path=relative,
+            )
+            for relative in expected_bootstrap_paths
+        )
+    )
+
+
+def _baseline_attestation_inventory(root: Path) -> dict[str, object]:
+    path = root / "frozen-baseline-attestation.json"
+    payload = _checked_json(path, label="frozen baseline source attestation")
+    _require_content_identity(payload)
+    if (
+        set(payload)
+        != {
+            "kind",
+            "schema_version",
+            "source_root",
+            "source_revision",
+            "native_build_inputs_sha256",
+            "candidate_lock_sha256",
+            "cargo_config_sha256",
+            "install_state_sha256",
+            "source_inventory",
+            "generated_identity",
+            "passes",
+            "content_identity",
+        }
+        or payload.get("kind") != BASELINE_ATTESTATION_KIND
+        or payload.get("schema_version") != SCHEMA_VERSION
+        or payload.get("source_root") != str(FROZEN_SOURCE_ROOT)
+        or payload.get("source_revision") != matrix.FROZEN_BASELINE_SOURCE_REVISION
+        or payload.get("native_build_inputs_sha256")
+        != matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256
+        or payload.get("candidate_lock_sha256") != FROZEN_CANDIDATE_LOCK_SHA256
+        or payload.get("cargo_config_sha256") != FROZEN_CARGO_CONFIG_SHA256
+        or payload.get("install_state_sha256") != FROZEN_INSTALL_STATE_SHA256
+        or not _valid_baseline_attestation_payload(payload)
+        or payload.get("passes") is not True
+    ):
+        raise BundleError("frozen baseline source attestation is invalid")
+    identity = _file_identity(path)
+    identity["relative_path"] = path.relative_to(root).as_posix()
+    return {
+        "file": identity,
+        "content_sha256": payload["content_identity"]["sha256"],
+    }
+
+
+def create_manifest(arguments: argparse.Namespace) -> dict[str, object]:
+    if platform.system() != "Linux" or platform.machine() not in {"x86_64", "AMD64"}:
+        raise BundleError("x86 runtime bundle must be produced on Linux x86-64")
+    bundle_root = arguments.bundle_root.expanduser().resolve(strict=True)
+    baseline = _installation(arguments.baseline_python)
+    current = _installation(arguments.current_python)
+    for lane, identity, expected_source, expected_inputs in (
+        (
+            "baseline",
+            baseline,
+            matrix.FROZEN_BASELINE_SOURCE_REVISION,
+            matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256,
+        ),
+        (
+            "current",
+            current,
+            arguments.expected_current_revision,
+            arguments.expected_current_native_inputs_sha256,
+        ),
+    ):
+        build = identity["build_info"]
+        if (
+            not isinstance(build, Mapping)
+            or build.get("source_revision") != expected_source
+            or build.get("native_build_inputs_sha256") != expected_inputs
+            or build.get("publishable") is not False
+        ):
+            raise BundleError(f"{lane} installed build identity is not exact")
+    payload = _attach_content_identity(
+        {
+            "kind": BUNDLE_KIND,
+            "schema_version": SCHEMA_VERSION,
+            "target": "x86_64-unknown-linux-gnu",
+            "workflow_run_id": arguments.workflow_run_id,
+            "expected_current_revision": arguments.expected_current_revision,
+            "installations": {"baseline": baseline, "current": current},
+            "dependency_site": _stable_dependency_site(arguments.dependency_site),
+            "wheels": _wheel_inventory(bundle_root),
+            "prepared_models": {"ufo-sm": _prepared_inventory(bundle_root)},
+            "frozen_baseline_source_attestation": (
+                _baseline_attestation_inventory(bundle_root)
+            ),
+            "frozen_baseline": {
+                "source_root": str(FROZEN_SOURCE_ROOT),
+                "source_revision": matrix.FROZEN_BASELINE_SOURCE_REVISION,
+                "native_build_inputs_sha256": (
+                    matrix.FROZEN_BASELINE_NATIVE_INPUTS_SHA256
+                ),
+                "candidate_lock_sha256": FROZEN_CANDIDATE_LOCK_SHA256,
+                "cargo_config_sha256": FROZEN_CARGO_CONFIG_SHA256,
+                "install_state_sha256": FROZEN_INSTALL_STATE_SHA256,
+            },
+            "passes": True,
+        }
+    )
+    _write_json_atomic(arguments.output, payload)
+    return payload
+
+
+def _checked_manifest(path: Path) -> dict[str, Any]:
+    payload = _checked_json(path, label="runtime bundle manifest")
+    _require_content_identity(payload)
+    if (
+        payload.get("kind") != BUNDLE_KIND
+        or payload.get("schema_version") != SCHEMA_VERSION
+        or payload.get("target") != "x86_64-unknown-linux-gnu"
+        or payload.get("passes") is not True
+    ):
+        raise BundleError("runtime bundle manifest contract is invalid")
+    return payload
+
+
+def verify_manifest(arguments: argparse.Namespace) -> dict[str, object]:
+    payload = _checked_manifest(arguments.manifest)
+    if (
+        payload.get("workflow_run_id") != arguments.workflow_run_id
+        or payload.get("expected_current_revision")
+        != arguments.expected_current_revision
+    ):
+        raise BundleError("runtime bundle workflow/source binding changed")
+    observed = {
+        "installations": {
+            "baseline": _installation(arguments.baseline_python),
+            "current": _installation(arguments.current_python),
+        },
+        "dependency_site": _stable_dependency_site(arguments.dependency_site),
+    }
+    expected = {
+        "installations": payload.get("installations"),
+        "dependency_site": payload.get("dependency_site"),
+    }
+    if observed != expected:
+        raise BundleError("installed runtime/dependency identity differs from bundle")
+    bundle_root = arguments.bundle_root.expanduser().resolve(strict=True)
+    if _wheel_inventory(bundle_root) != payload.get("wheels") or {
+        "ufo-sm": _prepared_inventory(bundle_root)
+    } != payload.get("prepared_models"):
+        raise BundleError("runtime bundle files differ from their manifest")
+    if _baseline_attestation_inventory(bundle_root) != payload.get(
+        "frozen_baseline_source_attestation"
+    ):
+        raise BundleError("frozen baseline attestation differs from its manifest")
+    return {
+        "kind": "pyamplicol-x86-performance-runtime-bundle-verification",
+        "schema_version": 1,
+        "manifest_content_sha256": payload["content_identity"]["sha256"],
+        "passes": True,
+    }
+
+
+def bundle_dependencies(source_site: Path, destination: Path) -> dict[str, object]:
+    source = source_site.expanduser().resolve(strict=True)
+    destination = destination.expanduser().absolute()
+    if destination.exists():
+        if destination.is_symlink() or not destination.is_dir():
+            raise BundleError("dependency bundle destination is unsafe")
+        if any(destination.iterdir()):
+            raise BundleError("dependency bundle destination must be empty")
+    else:
+        destination.mkdir(parents=True)
+    available = {
+        re.sub(r"[-_.]+", "-", str(dist.metadata.get("Name", ""))).casefold(): dist
+        for dist in importlib.metadata.distributions(path=[str(source)])
+    }
+    for distribution_name, _import_name in regression.DEPENDENCY_DISTRIBUTIONS:
+        key = re.sub(r"[-_.]+", "-", distribution_name).casefold()
+        distribution = available.get(key)
+        if distribution is None:
+            raise BundleError(f"dependency site lacks {distribution_name}")
+        for entry in distribution.files or ():
+            relative = Path(str(entry))
+            if (
+                relative.is_absolute()
+                or ".." in relative.parts
+                or "__pycache__" in relative.parts
+                or relative.suffix == ".pyc"
+            ):
+                continue
+            source_file = (source / relative).resolve(strict=True)
+            source_file.relative_to(source)
+            if not source_file.is_file():
+                continue
+            target = destination / relative
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(source_file, target)
+    source_identity = _stable_dependency_site(source)
+    destination_identity = _stable_dependency_site(destination)
+    if source_identity != destination_identity:
+        raise BundleError("copied dependency bundle identity changed")
+    return destination_identity
+
+
+def _empty_external_directory(path: Path, *, label: str) -> Path:
+    destination = path.expanduser().absolute()
+    checkout = ROOT.resolve(strict=True)
+    if destination == Path(destination.anchor):
+        raise BundleError(f"{label} cannot be a filesystem root")
+    try:
+        destination.relative_to(checkout)
+    except ValueError:
+        pass
+    else:
+        raise BundleError(f"{label} must be outside the source checkout")
+    if destination.exists():
+        if destination.is_symlink() or not destination.is_dir():
+            raise BundleError(f"{label} is unsafe")
+        if any(destination.iterdir()):
+            raise BundleError(f"{label} must be empty")
+    else:
+        destination.mkdir(parents=True)
+    return destination
+
+
+def _venv_python(root: Path) -> Path:
+    relative = Path("Scripts/python.exe") if os.name == "nt" else Path("bin/python")
+    return (root / relative).resolve(strict=True)
+
+
+def _venv_purelib(python: Path) -> Path:
+    completed = subprocess.run(
+        (
+            str(python),
+            "-c",
+            "import sysconfig; print(sysconfig.get_paths()['purelib'])",
+        ),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        raise BundleError("cannot resolve materialized runtime site-packages")
+    try:
+        result = Path(completed.stdout.strip()).resolve(strict=True)
+    except OSError as error:
+        raise BundleError(
+            "materialized runtime site-packages is unavailable"
+        ) from error
+    if not result.is_dir():
+        raise BundleError("materialized runtime site-packages is not a directory")
+    return result
+
+
+def materialize_runtime(
+    bundle_root: Path,
+    runtime_root: Path,
+) -> dict[str, object]:
+    """Rebuild the two fixed-path venvs from portable bundle members."""
+
+    bundle = bundle_root.expanduser().resolve(strict=True)
+    destination = _empty_external_directory(
+        runtime_root,
+        label="materialized runtime root",
+    )
+    dependencies = (bundle / "dependency-site").resolve(strict=True)
+    if not dependencies.is_dir():
+        raise BundleError("runtime bundle has no dependency site")
+    dependency_identity = _stable_dependency_site(dependencies)
+    wheels = _wheel_inventory(bundle)
+    lanes: dict[str, dict[str, object]] = {}
+    for lane in ("baseline", "current"):
+        lane_root = destination / lane
+        # A copied interpreter keeps ``resolve(strict=True)`` inside the lane;
+        # symlinked venv interpreters would collapse to the setup-python host
+        # executable and lose the selected site-packages identity.
+        venv.EnvBuilder(with_pip=True, symlinks=False).create(lane_root)
+        python = _venv_python(lane_root)
+        purelib = _venv_purelib(python)
+        for entry in sorted(dependencies.iterdir(), key=lambda path: path.name):
+            target = purelib / entry.name
+            if entry.is_dir():
+                shutil.copytree(entry, target)
+            elif entry.is_file():
+                shutil.copy2(entry, target)
+            else:
+                raise BundleError(f"dependency bundle member is unsafe: {entry}")
+        if _stable_dependency_site(purelib) != dependency_identity:
+            raise BundleError(f"{lane} materialized dependency identity changed")
+        wheel = bundle / str(wheels[lane]["relative_path"])
+        environment = os.environ.copy()
+        environment.update(
+            {
+                "PIP_DISABLE_PIP_VERSION_CHECK": "1",
+                "PIP_NO_INDEX": "1",
+                "PYTHONDONTWRITEBYTECODE": "1",
+            }
+        )
+        completed = subprocess.run(
+            (
+                str(python),
+                "-m",
+                "pip",
+                "install",
+                "--no-compile",
+                "--no-deps",
+                str(wheel),
+            ),
+            check=False,
+            capture_output=True,
+            text=True,
+            env=environment,
+        )
+        if completed.returncode != 0:
+            raise BundleError(
+                f"cannot install {lane} runtime wheel: {completed.stderr.strip()}"
+            )
+        lanes[lane] = {
+            "python": str(python),
+            "site_packages": str(purelib),
+            "installation": _installation(python),
+        }
+    return {
+        "runtime_root": str(destination),
+        "dependency_site": str(dependencies),
+        "dependency_site_identity": dependency_identity,
+        "lanes": lanes,
+        "passes": True,
+    }
+
+
+def prepare_ufo(output: Path, artifact_root: Path) -> dict[str, object]:
+    from tools.performance_report.artifacts import ArtifactStore
+    from tools.performance_report.prepared import ensure_report_ufo_sm_prepared_model
+
+    store = ArtifactStore(
+        artifact_root=artifact_root.expanduser().absolute(),
+        lock_root=artifact_root.expanduser().absolute() / "locks",
+    )
+    prepared, _reused = ensure_report_ufo_sm_prepared_model(
+        store=store,
+        repo_root=ROOT,
+        worker_cores=1,
+    )
+    destination = output.expanduser().absolute()
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(prepared, destination)
+    return _file_identity(destination)
+
+
+def _sha256_argument(value: str) -> str:
+    if _SHA256.fullmatch(value) is None:
+        raise argparse.ArgumentTypeError("must be a lowercase SHA-256")
+    return value
+
+
+def _git_sha_argument(value: str) -> str:
+    if _GIT_SHA.fullmatch(value) is None:
+        raise argparse.ArgumentTypeError("must be a lowercase Git SHA")
+    return value
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    commands = result.add_subparsers(dest="command", required=True)
+    frozen = commands.add_parser("freeze-baseline")
+    frozen.add_argument("--source-root", type=Path, required=True)
+    frozen.add_argument("--output", type=Path, required=True)
+
+    dependencies = commands.add_parser("bundle-dependencies")
+    dependencies.add_argument("--source-site", type=Path, required=True)
+    dependencies.add_argument("--destination", type=Path, required=True)
+
+    materialize = commands.add_parser("materialize")
+    materialize.add_argument("--bundle-root", type=Path, required=True)
+    materialize.add_argument("--runtime-root", type=Path, required=True)
+
+    prepared = commands.add_parser("prepare-ufo")
+    prepared.add_argument("--output", type=Path, required=True)
+    prepared.add_argument("--artifact-root", type=Path, required=True)
+
+    for name in ("create-manifest", "verify"):
+        command = commands.add_parser(name)
+        command.add_argument("--bundle-root", type=Path, required=True)
+        command.add_argument("--baseline-python", type=Path, required=True)
+        command.add_argument("--current-python", type=Path, required=True)
+        command.add_argument("--dependency-site", type=Path, required=True)
+        command.add_argument("--workflow-run-id", required=True)
+        command.add_argument(
+            "--expected-current-revision",
+            type=_git_sha_argument,
+            required=True,
+        )
+        if name == "create-manifest":
+            command.add_argument(
+                "--expected-current-native-inputs-sha256",
+                type=_sha256_argument,
+                required=True,
+            )
+            command.add_argument("--output", type=Path, required=True)
+        else:
+            command.add_argument("--manifest", type=Path, required=True)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    try:
+        if arguments.command == "freeze-baseline":
+            payload = freeze_baseline(arguments.source_root)
+            _write_json_atomic(arguments.output, payload)
+        elif arguments.command == "bundle-dependencies":
+            payload = bundle_dependencies(
+                arguments.source_site,
+                arguments.destination,
+            )
+        elif arguments.command == "materialize":
+            payload = materialize_runtime(
+                arguments.bundle_root,
+                arguments.runtime_root,
+            )
+        elif arguments.command == "prepare-ufo":
+            payload = prepare_ufo(arguments.output, arguments.artifact_root)
+        elif arguments.command == "create-manifest":
+            payload = create_manifest(arguments)
+        else:
+            payload = verify_manifest(arguments)
+    except (BundleError, OSError, regression.RegressionError) as error:
+        print(f"x86-performance-runtime-bundle: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(payload, sort_keys=True, allow_nan=False))
+    return 0 if payload.get("passes", True) is True else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/x86_portable_performance_acceptance.py b/pyamplicol/tools/developer/x86_portable_performance_acceptance.py
new file mode 100644
index 0000000000..bae786f638
--- /dev/null
+++ b/pyamplicol/tools/developer/x86_portable_performance_acceptance.py
@@ -0,0 +1,645 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Combine x86 correctness, 168-cell matrix, and ``qq -> Z+6g`` evidence.
+
+The inputs are independently content-addressed artifacts from the same
+dispatched source revision.  The output intentionally contains no host-local
+paths so it can be retained as the final portable candidate verdict.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import re
+import statistics
+import sys
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.developer import arena_native_x86_acceptance as native  # noqa: E402
+from tools.developer import compiled_mode_matrix as matrix  # noqa: E402
+from tools.developer import compiled_mode_matrix_x86 as matrix_x86  # noqa: E402
+from tools.developer import x86_qq_recurrence_acceptance as qq  # noqa: E402
+
+RESULT_KIND = "pyamplicol-x86-portable-candidate-acceptance"
+SCHEMA_VERSION = 1
+CONTENT_IDENTITY_ALGORITHM = "sha256-canonical-json-body-v1"
+_GIT_SHA = re.compile(r"[0-9a-f]{40}")
+_SHA256 = re.compile(r"[0-9a-f]{64}")
+
+
+class PortableAcceptanceError(RuntimeError):
+    """Raised when independently produced x86 evidence does not compose."""
+
+
+def _canonical_sha256(value: object) -> str:
+    return matrix_x86._canonical_sha256(value)
+
+
+def _is_sha256(value: object) -> bool:
+    return isinstance(value, str) and _SHA256.fullmatch(value) is not None
+
+
+def _positive_finite(value: object) -> bool:
+    return (
+        isinstance(value, (int, float))
+        and not isinstance(value, bool)
+        and math.isfinite(float(value))
+        and float(value) > 0.0
+    )
+
+
+def _seven_positive_values(value: object) -> list[float] | None:
+    if (
+        not isinstance(value, list)
+        or len(value) != 7
+        or not all(_positive_finite(item) for item in value)
+    ):
+        return None
+    return [float(item) for item in value]
+
+
+def _attach_content_identity(body: Mapping[str, object]) -> dict[str, object]:
+    result = dict(body)
+    result["content_identity"] = {
+        "algorithm": CONTENT_IDENTITY_ALGORITHM,
+        "sha256": _canonical_sha256(body),
+    }
+    return result
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def _require_content_identity(
+    payload: Mapping[str, object],
+    *,
+    label: str,
+) -> str:
+    identity = payload.get("content_identity")
+    body = dict(payload)
+    body.pop("content_identity", None)
+    if (
+        not isinstance(identity, Mapping)
+        or set(identity) != {"algorithm", "sha256"}
+        or identity.get("algorithm") != CONTENT_IDENTITY_ALGORITHM
+        or identity.get("sha256") != _canonical_sha256(body)
+    ):
+        raise PortableAcceptanceError(f"{label} content identity is invalid")
+    return str(identity["sha256"])
+
+
+def _portable_file_identity(identity: Mapping[str, object]) -> dict[str, object]:
+    return {
+        key: identity[key]
+        for key in ("size_bytes", "sha256", "canonical_sha256")
+        if key in identity
+    }
+
+
+def _checked_input(
+    path: Path,
+    *,
+    label: str,
+) -> tuple[dict[str, Any], dict[str, object], str]:
+    try:
+        payload, identity = matrix_x86._checked_json(path, label=label)
+    except matrix_x86.ShardError as error:
+        raise PortableAcceptanceError(str(error)) from error
+    digest = _require_content_identity(payload, label=label)
+    return payload, _portable_file_identity(identity), digest
+
+
+def _audit_native(
+    payload: Mapping[str, Any],
+    *,
+    expected_revision: str,
+) -> dict[str, object]:
+    request = payload.get("request")
+    source = payload.get("source_identity")
+    runtime = payload.get("runtime_identity")
+    evidence = payload.get("evidence")
+    validation = payload.get("validation")
+    if (
+        payload.get("kind") != native.ACCEPTANCE_KIND
+        or payload.get("schema_version") != native.SCHEMA_VERSION
+        or payload.get("status") != "ok"
+        or payload.get("passes") is not True
+        or not isinstance(request, Mapping)
+        or request.get("expected_revision") != expected_revision
+        or request.get("expected_target") != native.EXPECTED_TARGET
+        or request.get("point_count") != native.EXPECTED_POINT_COUNT
+        or not isinstance(source, Mapping)
+        or source.get("all_match") is not True
+        or not isinstance(runtime, Mapping)
+        or runtime.get("all_match") is not True
+        or not isinstance(evidence, Mapping)
+        or set(evidence)
+        != {
+            "runtime_preflight",
+            "compiled_all_jit",
+            "four_quark",
+            "eager_compiled_color",
+        }
+        or not isinstance(validation, Mapping)
+        or not validation
+        or any(value is not True for value in validation.values())
+    ):
+        raise PortableAcceptanceError("native correctness acceptance is incomplete")
+    for name, record in evidence.items():
+        semantic = (
+            record.get("semantic_validation")
+            if isinstance(record, Mapping)
+            else None
+        )
+        if not isinstance(semantic, Mapping) or semantic.get("passes") is not True:
+            raise PortableAcceptanceError(
+                f"native correctness evidence {name} did not pass"
+            )
+    audit_source = source.get("audit")
+    audit_runtime = runtime.get("audit")
+    active_build = (
+        audit_runtime.get("active_build_info")
+        if isinstance(audit_runtime, Mapping)
+        else None
+    )
+    build_payload = (
+        active_build.get("payload")
+        if isinstance(active_build, Mapping)
+        else None
+    )
+    native_extension = (
+        audit_runtime.get("native_extension")
+        if isinstance(audit_runtime, Mapping)
+        else None
+    )
+    native_build_inputs = (
+        build_payload.get("native_build_inputs_sha256")
+        if isinstance(build_payload, Mapping)
+        else None
+    )
+    native_module_sha256 = (
+        native_extension.get("sha256")
+        if isinstance(native_extension, Mapping)
+        else None
+    )
+    if (
+        not isinstance(audit_source, Mapping)
+        or audit_source.get("revision") != expected_revision
+        or audit_source.get("dirty") is not False
+        or not isinstance(build_payload, Mapping)
+        or build_payload.get("source_revision") != expected_revision
+        or build_payload.get("publishable") is not False
+        or not isinstance(native_extension, Mapping)
+        or native_extension.get("target") != native.EXPECTED_TARGET
+        or native_extension.get("build_inputs_sha256")
+        != native_build_inputs
+    ):
+        raise PortableAcceptanceError("native correctness runtime/source drifted")
+    if not _is_sha256(native_build_inputs) or not _is_sha256(native_module_sha256):
+        raise PortableAcceptanceError(
+            "native correctness identity digests are invalid"
+        )
+    return {
+        "target": native.EXPECTED_TARGET,
+        "point_count": native.EXPECTED_POINT_COUNT,
+        "native_build_inputs_sha256": native_build_inputs,
+        "native_module_sha256": native_module_sha256,
+        "required_evidence": sorted(evidence),
+        "passes": True,
+    }
+
+
+def _audit_matrix(
+    payload: Mapping[str, Any],
+    *,
+    workflow_run_id: str,
+    expected_revision: str,
+) -> dict[str, object]:
+    shard_gate = payload.get("shard_gate")
+    audit = payload.get("matrix_audit")
+    if (
+        payload.get("kind") != matrix_x86.AGGREGATE_KIND
+        or payload.get("schema_version") != matrix_x86.SCHEMA_VERSION
+        or payload.get("matrix_contract") != matrix.MATRIX_CONTRACT
+        or payload.get("workflow_run_id") != workflow_run_id
+        or payload.get("expected_current_source_revision") != expected_revision
+        or payload.get("complete") is not True
+        or payload.get("passes") is not True
+        or not isinstance(shard_gate, Mapping)
+        or shard_gate.get("passes") is not True
+        or shard_gate.get("errors") != []
+        or not isinstance(audit, Mapping)
+        or audit.get("complete") is not True
+        or audit.get("passes") is not True
+    ):
+        raise PortableAcceptanceError("168-cell matrix acceptance is incomplete")
+    coverage = audit.get("coverage")
+    cell_gate = audit.get("cell_gate")
+    identity_gate = audit.get("identity_gate")
+    gain_gate = audit.get("gain_gate")
+    generation_gate = audit.get("generation_gate")
+    if (
+        not isinstance(coverage, Mapping)
+        or coverage.get("expected") != 168
+        or coverage.get("observed") != 168
+        or coverage.get("missing") != []
+        or coverage.get("unexpected") != []
+        or coverage.get("passes") is not True
+        or not all(
+            isinstance(gate, Mapping) and gate.get("passes") is True
+            for gate in (cell_gate, identity_gate, gain_gate, generation_gate)
+        )
+    ):
+        raise PortableAcceptanceError("168-cell matrix gates are incomplete")
+    expected_builds = payload.get("expected_builds")
+    current = (
+        expected_builds.get("current")
+        if isinstance(expected_builds, Mapping)
+        else None
+    )
+    current_native_inputs = (
+        current.get("native_build_inputs_sha256")
+        if isinstance(current, Mapping)
+        else None
+    )
+    current_native_module = (
+        current.get("native_module_sha256")
+        if isinstance(current, Mapping)
+        else None
+    )
+    runtime_bundle_sha256 = payload.get("runtime_bundle_sha256")
+    if (
+        not isinstance(current, Mapping)
+        or current.get("source_revision") != expected_revision
+        or not _is_sha256(current_native_inputs)
+        or not _is_sha256(current_native_module)
+        or not _is_sha256(runtime_bundle_sha256)
+    ):
+        raise PortableAcceptanceError("matrix current build identity drifted")
+    return {
+        "matrix_contract": matrix.MATRIX_CONTRACT,
+        "cell_count": 168,
+        "shard_count": matrix_x86.SHARD_COUNT,
+        "runtime_bundle_sha256": runtime_bundle_sha256,
+        "current_native_build_inputs_sha256": current_native_inputs,
+        "current_native_module_sha256": current_native_module,
+        "gain_gate": {
+            "required_relative_gain": gain_gate.get("required_relative_gain"),
+            "passes": True,
+        },
+        "generation_gate": {
+            "maximum_geometric_mean": generation_gate.get(
+                "maximum_geometric_mean"
+            ),
+            "observed_geometric_mean": generation_gate.get(
+                "geometric_mean_current_over_baseline"
+            ),
+            "passes": True,
+        },
+        "passes": True,
+    }
+
+
+def _audit_qq(
+    payload: Mapping[str, Any],
+    *,
+    workflow_run_id: str,
+    expected_revision: str,
+) -> dict[str, object]:
+    captures = payload.get("captures")
+    policy = payload.get("policy")
+    expected_policy = {
+        "required_capture_roles": list(qq.CAPTURE_CONTRACTS),
+        "required_modes": list(qq.REQUIRED_MODES),
+        "required_batch_sizes": list(qq.REQUIRED_BATCH_SIZES),
+        "performance_batch_sizes": list(qq.PERFORMANCE_BATCH_SIZES),
+        "minimum_target_runtime_seconds_per_worker": 5.0,
+        "subprocess_samples_per_cell": 7,
+        "native_wall_blocks_per_worker": 7,
+        "warmup_runs": 2,
+        "numerical_validation_samples": 10,
+        "compiled_over_recurrence_ratio_ceiling": (
+            qq.COMPILED_RECURRENCE_RATIO_CEILING
+        ),
+        "ratio_gate": "median-plus-three-raw-mad-at-or-below-ceiling-v1",
+        "diagnostic_shortcuts_allowed": False,
+    }
+    if (
+        payload.get("kind") != qq.RESULT_KIND
+        or payload.get("schema_version") != qq.SCHEMA_VERSION
+        or payload.get("workflow_run_id") != workflow_run_id
+        or payload.get("target") != native.EXPECTED_TARGET
+        or payload.get("expected_current_revision") != expected_revision
+        or payload.get("performance_cell_count") != 8
+        or payload.get("passes") is not True
+        or not isinstance(captures, Mapping)
+        or set(captures) != set(qq.CAPTURE_CONTRACTS)
+        or policy != expected_policy
+    ):
+        raise PortableAcceptanceError("qq Z+6g acceptance is incomplete")
+    cell_count = 0
+    maximum_upper = 0.0
+    for role, capture in captures.items():
+        contract = qq.CAPTURE_CONTRACTS[role]
+        cells = (
+            capture.get("performance_cells")
+            if isinstance(capture, Mapping)
+            else None
+        )
+        numerical = (
+            capture.get("numerical_validation")
+            if isinstance(capture, Mapping)
+            else None
+        )
+        if (
+            not isinstance(capture, Mapping)
+            or capture.get("passes") is not True
+            or capture.get("source_revision") != expected_revision
+            or not _is_sha256(capture.get("runtime_provenance_sha256"))
+            or capture.get("layout") != contract["layout"]
+            or capture.get("workload") != contract["workload"]
+            or not isinstance(capture.get("model"), Mapping)
+            or capture["model"].get("kind") != contract["model"]
+            or not isinstance(numerical, Mapping)
+            or numerical.get("contract")
+            != "recomputed-recurrence-z6g-pairwise-and-resolved-v1"
+            or numerical.get("passes") is not True
+            or not isinstance(cells, list)
+            or len(cells) != 2
+        ):
+            raise PortableAcceptanceError(f"qq Z+6g capture {role} is incomplete")
+        batches = [
+            cell.get("batch_size") if isinstance(cell, Mapping) else None
+            for cell in cells
+        ]
+        if (
+            any(
+                isinstance(batch, bool) or not isinstance(batch, int)
+                for batch in batches
+            )
+            or len(set(batches)) != len(batches)
+            or set(batches) != set(qq.PERFORMANCE_BATCH_SIZES)
+        ):
+            raise PortableAcceptanceError(
+                f"qq Z+6g capture {role} batch coverage is incomplete"
+            )
+        for cell in cells:
+            statistics_record = (
+                cell.get("ratio_statistics")
+                if isinstance(cell, Mapping)
+                else None
+            )
+            upper = (
+                statistics_record.get("upper_three_raw_mad")
+                if isinstance(statistics_record, Mapping)
+                else None
+            )
+            compiled = _seven_positive_values(
+                cell.get("compiled_wall_seconds_per_point_by_round")
+                if isinstance(cell, Mapping)
+                else None
+            )
+            recurrence = _seven_positive_values(
+                cell.get("recurrence_wall_seconds_per_point_by_round")
+                if isinstance(cell, Mapping)
+                else None
+            )
+            ratios = _seven_positive_values(
+                cell.get("compiled_over_recurrence_ratios_by_round")
+                if isinstance(cell, Mapping)
+                else None
+            )
+            if (
+                not isinstance(cell, Mapping)
+                or cell.get("passes") is not True
+                or cell.get("sample_count") != 7
+                or cell.get("batch_size") not in qq.PERFORMANCE_BATCH_SIZES
+                or cell.get("pairing") != "same-interleaved-schedule-round-v1"
+                or cell.get("ceiling")
+                != qq.COMPILED_RECURRENCE_RATIO_CEILING
+                or compiled is None
+                or recurrence is None
+                or ratios is None
+                or not isinstance(statistics_record, Mapping)
+                or statistics_record.get("contract") != "median-and-raw-mad-v1"
+                or not _positive_finite(statistics_record.get("median"))
+                or not _positive_finite(statistics_record.get("raw_mad"))
+                or not _positive_finite(upper)
+                or float(upper) > qq.COMPILED_RECURRENCE_RATIO_CEILING
+            ):
+                raise PortableAcceptanceError(
+                    f"qq Z+6g capture {role} performance gate failed"
+                )
+            recomputed_ratios = [
+                compiled_value / recurrence_value
+                for compiled_value, recurrence_value in zip(
+                    compiled,
+                    recurrence,
+                    strict=True,
+                )
+            ]
+            median = statistics.median(recomputed_ratios)
+            raw_mad = statistics.median(
+                abs(value - median) for value in recomputed_ratios
+            )
+            recomputed_upper = median + 3.0 * raw_mad
+            if (
+                any(
+                    not math.isclose(
+                        observed,
+                        expected,
+                        rel_tol=1.0e-15,
+                        abs_tol=0.0,
+                    )
+                    for observed, expected in zip(
+                        ratios,
+                        recomputed_ratios,
+                        strict=True,
+                    )
+                )
+                or not math.isclose(
+                    float(statistics_record["median"]),
+                    median,
+                    rel_tol=1.0e-15,
+                    abs_tol=0.0,
+                )
+                or not math.isclose(
+                    float(statistics_record["raw_mad"]),
+                    raw_mad,
+                    rel_tol=1.0e-15,
+                    abs_tol=0.0,
+                )
+                or not math.isclose(
+                    float(upper),
+                    recomputed_upper,
+                    rel_tol=1.0e-15,
+                    abs_tol=0.0,
+                )
+            ):
+                raise PortableAcceptanceError(
+                    f"qq Z+6g capture {role} ratio evidence changed"
+                )
+            cell_count += 1
+            maximum_upper = max(maximum_upper, float(upper))
+    runtime_bundle = payload.get("runtime_bundle")
+    if not isinstance(runtime_bundle, Mapping):
+        raise PortableAcceptanceError("qq Z+6g runtime bundle identity is absent")
+    runtime_bundle_sha256 = runtime_bundle.get("content_sha256")
+    if not _is_sha256(runtime_bundle_sha256):
+        raise PortableAcceptanceError("qq Z+6g runtime bundle digest is absent")
+    return {
+        "capture_count": len(captures),
+        "performance_cell_count": cell_count,
+        "runtime_bundle_sha256": runtime_bundle_sha256,
+        "compiled_over_recurrence_ratio_ceiling": (
+            qq.COMPILED_RECURRENCE_RATIO_CEILING
+        ),
+        "maximum_observed_upper_three_raw_mad": maximum_upper,
+        "numerical_validation": True,
+        "passes": True,
+    }
+
+
+def audit(
+    *,
+    native_acceptance: Path,
+    matrix_acceptance: Path,
+    qq_acceptance: Path,
+    workflow_run_id: str,
+    expected_revision: str,
+) -> dict[str, object]:
+    native_payload, native_file, native_digest = _checked_input(
+        native_acceptance,
+        label="native x86 correctness acceptance",
+    )
+    matrix_payload, matrix_file, matrix_digest = _checked_input(
+        matrix_acceptance,
+        label="x86 168-cell matrix acceptance",
+    )
+    qq_payload, qq_file, qq_digest = _checked_input(
+        qq_acceptance,
+        label="x86 qq Z+6g acceptance",
+    )
+    native_summary = _audit_native(
+        native_payload,
+        expected_revision=expected_revision,
+    )
+    matrix_summary = _audit_matrix(
+        matrix_payload,
+        workflow_run_id=workflow_run_id,
+        expected_revision=expected_revision,
+    )
+    qq_summary = _audit_qq(
+        qq_payload,
+        workflow_run_id=workflow_run_id,
+        expected_revision=expected_revision,
+    )
+    if (
+        native_summary["native_build_inputs_sha256"]
+        != matrix_summary["current_native_build_inputs_sha256"]
+    ):
+        raise PortableAcceptanceError(
+            "correctness and performance used different native build inputs"
+        )
+    if (
+        native_summary["native_module_sha256"]
+        != matrix_summary["current_native_module_sha256"]
+    ):
+        raise PortableAcceptanceError(
+            "correctness and performance used different native modules"
+        )
+    if (
+        matrix_summary["runtime_bundle_sha256"]
+        != qq_summary["runtime_bundle_sha256"]
+    ):
+        raise PortableAcceptanceError(
+            "matrix and qq evidence used different runtime bundles"
+        )
+    return _attach_content_identity(
+        {
+            "kind": RESULT_KIND,
+            "schema_version": SCHEMA_VERSION,
+            "workflow_run_id": workflow_run_id,
+            "source_revision": expected_revision,
+            "target": native.EXPECTED_TARGET,
+            "inputs": {
+                "native_correctness": {
+                    "file": native_file,
+                    "content_sha256": native_digest,
+                },
+                "compiled_eager_matrix": {
+                    "file": matrix_file,
+                    "content_sha256": matrix_digest,
+                },
+                "qq_z6g_recurrence": {
+                    "file": qq_file,
+                    "content_sha256": qq_digest,
+                },
+            },
+            "correctness": native_summary,
+            "compiled_eager_matrix": matrix_summary,
+            "qq_z6g_recurrence": qq_summary,
+            "bindings": {
+                "same_source_revision": True,
+                "same_native_build_inputs": True,
+                "same_native_module": True,
+                "same_performance_runtime_bundle": True,
+            },
+            "passes": True,
+        }
+    )
+
+
+def _git_sha(value: str) -> str:
+    if _GIT_SHA.fullmatch(value) is None:
+        raise argparse.ArgumentTypeError("must be a lowercase 40-character Git SHA")
+    return value
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("--native-acceptance", type=Path, required=True)
+    result.add_argument("--matrix-acceptance", type=Path, required=True)
+    result.add_argument("--qq-acceptance", type=Path, required=True)
+    result.add_argument("--workflow-run-id", required=True)
+    result.add_argument("--expected-revision", type=_git_sha, required=True)
+    result.add_argument("--output", type=Path, required=True)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    try:
+        result = audit(
+            native_acceptance=arguments.native_acceptance,
+            matrix_acceptance=arguments.matrix_acceptance,
+            qq_acceptance=arguments.qq_acceptance,
+            workflow_run_id=arguments.workflow_run_id,
+            expected_revision=arguments.expected_revision,
+        )
+        _write_json_atomic(arguments.output, result)
+    except (OSError, PortableAcceptanceError) as error:
+        print(f"x86-portable-performance-acceptance: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, sort_keys=True, allow_nan=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/developer/x86_qq_recurrence_acceptance.py b/pyamplicol/tools/developer/x86_qq_recurrence_acceptance.py
new file mode 100644
index 0000000000..07d243b9f5
--- /dev/null
+++ b/pyamplicol/tools/developer/x86_qq_recurrence_acceptance.py
@@ -0,0 +1,767 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Audit the four authoritative x86 ``qq -> Z+6g`` recurrence captures.
+
+This command deliberately consumes the complete three-lane output from
+``recurrence_z6g_benchmark.py``.  It does not provide a shorter diagnostic
+profiling path.  Every stored validation, artifact-semantic, worker, timing,
+and interleaving contract is recomputed before the compiled/recurrence
+performance ratios are considered.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import re
+import statistics
+import sys
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.developer import (  # noqa: E402
+    compiled_mode_matrix_x86 as shard_io,
+)
+from tools.developer import (  # noqa: E402
+    recurrence_z6g_benchmark as benchmark,
+)
+from tools.developer import (  # noqa: E402
+    x86_performance_runtime_bundle as runtime_bundle,
+)
+
+RESULT_KIND = "pyamplicol-x86-qq-z6g-recurrence-acceptance"
+SCHEMA_VERSION = 1
+CONTENT_IDENTITY_ALGORITHM = "sha256-canonical-json-body-v1"
+COMPILED_RECURRENCE_RATIO_CEILING = 1.15
+PERFORMANCE_BATCH_SIZES = (128, 1024)
+REQUIRED_BATCH_SIZES = tuple(benchmark.DEFAULT_BATCH_SIZES)
+REQUIRED_MODES = tuple(benchmark.EXECUTION_MODES)
+TOPOLOGY_FLOW_ID = "flow:2,4,5,6,7,8,9,1"
+UNION_HELICITY_ID = "h:-1,+1,-1,+1,-1,+1,-1,+1,-1"
+_GIT_SHA = re.compile(r"[0-9a-f]{40}")
+
+CAPTURE_CONTRACTS: dict[str, dict[str, object]] = {
+    "builtin-topology": {
+        "model": "builtin",
+        "layout": "topology-replay",
+        "color_flow": TOPOLOGY_FLOW_ID,
+        "helicity": "1",
+        "workload": "single-runtime-selected-flow/helicity-sum",
+    },
+    "builtin-union": {
+        "model": "builtin",
+        "layout": "all-flow-union",
+        "color_flow": "1",
+        "helicity": UNION_HELICITY_ID,
+        "workload": "all-flows/runtime-selected-single-helicity",
+    },
+    "ufo-topology": {
+        "model": "ufo",
+        "layout": "topology-replay",
+        "color_flow": TOPOLOGY_FLOW_ID,
+        "helicity": "1",
+        "workload": "single-runtime-selected-flow/helicity-sum",
+    },
+    "ufo-union": {
+        "model": "ufo",
+        "layout": "all-flow-union",
+        "color_flow": "1",
+        "helicity": UNION_HELICITY_ID,
+        "workload": "all-flows/runtime-selected-single-helicity",
+    },
+}
+
+
+class AcceptanceError(RuntimeError):
+    """Raised when capture provenance or structure cannot be authenticated."""
+
+
+def _canonical_sha256(value: object) -> str:
+    return shard_io._canonical_sha256(value)
+
+
+def _attach_content_identity(body: Mapping[str, object]) -> dict[str, object]:
+    result = dict(body)
+    result["content_identity"] = {
+        "algorithm": CONTENT_IDENTITY_ALGORITHM,
+        "sha256": _canonical_sha256(body),
+    }
+    return result
+
+
+def _write_json_atomic(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def _exact_int(value: object, expected: int) -> bool:
+    return not isinstance(value, bool) and isinstance(value, int) and value == expected
+
+
+def _positive_number(value: object) -> bool:
+    return (
+        not isinstance(value, bool)
+        and isinstance(value, (int, float))
+        and math.isfinite(float(value))
+        and float(value) > 0.0
+    )
+
+
+def _configuration_namespace(configuration: Mapping[str, object]) -> SimpleNamespace:
+    """Reconstruct only the arguments used by the harness acceptance functions."""
+
+    return SimpleNamespace(
+        batch_size=configuration.get("batch_sizes"),
+        color_flow=configuration.get("color_flow_request"),
+        generation_only=configuration.get("generation_only"),
+        gluon_count=configuration.get("gluon_count"),
+        helicity=configuration.get("helicity_request"),
+        jit_optimization_level=configuration.get("jit_optimization_level"),
+        lc_flow_layout=configuration.get("lc_flow_layout"),
+        minimum_samples=configuration.get("minimum_samples"),
+        modes=configuration.get("modes"),
+        process_expression=None,
+        specialize_flow_at_generation=configuration.get(
+            "specialize_flow_at_generation"
+        ),
+        subprocess_samples=configuration.get("subprocess_samples"),
+        target_runtime=configuration.get("target_runtime_seconds"),
+        warmup_runs=configuration.get("warmup_runs"),
+    )
+
+
+def _recompute_harness_contracts(payload: Mapping[str, Any]) -> None:
+    """Re-run the authoritative harness validators over retained evidence."""
+
+    configuration = payload.get("configuration")
+    profiles = payload.get("profiles")
+    schedule = payload.get("profile_schedule")
+    stored_validation = payload.get("validation_summary")
+    stored_capture = payload.get("capture_acceptance")
+    stored_milestone = payload.get("milestone0_acceptance")
+    if (
+        not isinstance(configuration, Mapping)
+        or not isinstance(profiles, Mapping)
+        or not isinstance(schedule, Mapping)
+        or not isinstance(stored_validation, Mapping)
+        or not isinstance(stored_capture, Mapping)
+        or not isinstance(stored_milestone, Mapping)
+    ):
+        raise AcceptanceError("capture lacks complete harness evidence")
+    arguments = _configuration_namespace(configuration)
+    try:
+        validation = benchmark._pairwise_profile_validation(profiles)
+        capture = benchmark._capture_acceptance(
+            arguments,
+            profiles,
+            validation,
+            profile_schedule=schedule,
+        )
+        milestone = benchmark._milestone0_acceptance_manifest(arguments, capture)
+    except (
+        AttributeError,
+        KeyError,
+        TypeError,
+        ValueError,
+        benchmark.HarnessError,
+    ) as error:
+        raise AcceptanceError("capture evidence cannot be revalidated") from error
+    if validation != stored_validation:
+        raise AcceptanceError("stored numerical validation is not reproducible")
+    if capture != stored_capture:
+        raise AcceptanceError("stored capture acceptance is not reproducible")
+    if milestone != stored_milestone:
+        raise AcceptanceError("stored milestone evidence is not reproducible")
+    if (
+        capture.get("complete") is not True
+        or capture.get("evidence_complete") is not True
+        or capture.get("passes") is not True
+        or capture.get("authoritative_eligible") is not True
+        or capture.get("authoritative_ineligibility_reasons") != []
+        or capture.get("generation_specialized_axes_by_mode") != {}
+        or capture.get("incomplete_physical_axes") != []
+        or validation.get("passes") is not True
+    ):
+        raise AcceptanceError("capture is not complete authoritative passing evidence")
+
+
+def _validate_configuration(
+    payload: Mapping[str, Any],
+    *,
+    role: str,
+) -> Mapping[str, Any]:
+    configuration = payload.get("configuration")
+    contract = CAPTURE_CONTRACTS[role]
+    if not isinstance(configuration, Mapping):
+        raise AcceptanceError(f"{role} has no configuration")
+    if (
+        configuration.get("modes") != list(REQUIRED_MODES)
+        or configuration.get("batch_sizes") != list(REQUIRED_BATCH_SIZES)
+        or configuration.get("lc_flow_layout") != contract["layout"]
+        or configuration.get("color_flow_request") != contract["color_flow"]
+        or configuration.get("helicity_request") != contract["helicity"]
+        or not _exact_int(configuration.get("gluon_count"), 6)
+        or not _exact_int(configuration.get("jit_optimization_level"), 3)
+        or not _exact_int(configuration.get("minimum_samples"), 7)
+        or not _exact_int(configuration.get("subprocess_samples"), 7)
+        or not _exact_int(configuration.get("warmup_runs"), 2)
+        or not _exact_int(configuration.get("point_tile_size"), 1024)
+        or not _exact_int(configuration.get("validation_samples"), 10)
+        or not _positive_number(configuration.get("target_runtime_seconds"))
+        or float(configuration["target_runtime_seconds"]) < 5.0
+        or configuration.get("generation_only") is not False
+        or configuration.get("allow_diagnostic_incomplete_success") is not False
+        or configuration.get("specialize_flow_at_generation") is not False
+        or configuration.get("external_watchdog_required_for_long_runs") is not True
+    ):
+        raise AcceptanceError(f"{role} does not use the authoritative benchmark policy")
+    if (
+        payload.get("process") != "u u~ > Z g g g g g g"
+        or payload.get("process_name") != "uubar_Z_6g"
+        or payload.get("workload") != contract["workload"]
+    ):
+        raise AcceptanceError(f"{role} process/workload identity is wrong")
+    return configuration
+
+
+def _stable_capture_installation(runtime: Mapping[str, Any]) -> dict[str, object]:
+    active = runtime.get("active_build_info")
+    distribution = runtime.get("installed_distribution")
+    native = runtime.get("native_extension")
+    if (
+        not isinstance(active, Mapping)
+        or not isinstance(active.get("payload"), Mapping)
+        or not isinstance(distribution, Mapping)
+        or not isinstance(native, Mapping)
+    ):
+        raise AcceptanceError("capture runtime identity is incomplete")
+    build_files = distribution.get("build_info_files")
+    native_modules = distribution.get("native_modules")
+    content = distribution.get("distribution_content")
+    if (
+        not isinstance(build_files, list)
+        or len(build_files) != 1
+        or not isinstance(build_files[0], Mapping)
+        or not isinstance(native_modules, list)
+        or len(native_modules) != 1
+        or not isinstance(native_modules[0], Mapping)
+        or not isinstance(content, Mapping)
+    ):
+        raise AcceptanceError("capture installed-distribution identity is incomplete")
+    return {
+        "package_version": distribution.get("package_version"),
+        "build_info": dict(active["payload"]),
+        "build_info_sha256": active.get("sha256"),
+        "distribution_content": {
+            key: content.get(key)
+            for key in ("algorithm", "sha256", "file_count", "size_bytes")
+        },
+        "native_module": {
+            key: native_modules[0].get(key)
+            for key in ("relative_path", "sha256", "size_bytes")
+        },
+        "native_runtime": {
+            "sha256": native.get("sha256"),
+            "size_bytes": native.get("size_bytes"),
+            "build_inputs_sha256": native.get("build_inputs_sha256"),
+            "package_version": native.get("package_version"),
+        },
+        "distribution_build_info_sha256": build_files[0].get("sha256"),
+    }
+
+
+def _validate_runtime(
+    payload: Mapping[str, Any],
+    *,
+    role: str,
+    expected_revision: str,
+    bundle: Mapping[str, Any],
+) -> str:
+    source = payload.get("source")
+    runtime = payload.get("runtime_provenance")
+    provenance = payload.get("provenance")
+    host = (
+        provenance.get("host")
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    if (
+        not isinstance(source, Mapping)
+        or source.get("revision") != expected_revision
+        or source.get("dirty") is not False
+        or source.get("untracked_files_checked") is not True
+        or not isinstance(runtime, Mapping)
+        or not isinstance(host, Mapping)
+        or host.get("system") != "Linux"
+        or host.get("machine") not in {"x86_64", "AMD64"}
+    ):
+        raise AcceptanceError(f"{role} was not measured from exact clean x86 source")
+    installations = bundle.get("installations")
+    current = (
+        installations.get("current")
+        if isinstance(installations, Mapping)
+        else None
+    )
+    if not isinstance(current, Mapping):
+        raise AcceptanceError("runtime bundle has no current installation identity")
+    observed = _stable_capture_installation(runtime)
+    expected_native = current.get("native_module")
+    expected_build = current.get("build_info")
+    if (
+        observed.get("package_version") != current.get("package_version")
+        or observed.get("build_info") != expected_build
+        or observed.get("build_info_sha256") != current.get("build_info_sha256")
+        or observed.get("distribution_build_info_sha256")
+        != current.get("build_info_sha256")
+        or observed.get("distribution_content")
+        != current.get("distribution_content")
+        or observed.get("native_module") != expected_native
+        or not isinstance(expected_build, Mapping)
+        or not isinstance(expected_native, Mapping)
+        or observed["native_runtime"].get("sha256")
+        != expected_native.get("sha256")
+        or observed["native_runtime"].get("size_bytes")
+        != expected_native.get("size_bytes")
+        or observed["native_runtime"].get("build_inputs_sha256")
+        != expected_build.get("native_build_inputs_sha256")
+    ):
+        raise AcceptanceError(f"{role} runtime does not match the frozen bundle")
+    return _canonical_sha256(runtime)
+
+
+def _validate_model(
+    configuration: Mapping[str, Any],
+    *,
+    role: str,
+    expected_revision: str,
+    bundle: Mapping[str, Any],
+) -> dict[str, object]:
+    identities = configuration.get("model_identities")
+    if not isinstance(identities, Mapping) or set(identities) != set(REQUIRED_MODES):
+        raise AcceptanceError(f"{role} has an incomplete model identity inventory")
+    model_kind = CAPTURE_CONTRACTS[role]["model"]
+    if model_kind == "builtin":
+        if configuration.get("prepared_model_path") is not None:
+            raise AcceptanceError(f"{role} unexpectedly uses an explicit model")
+        compiled = identities.get("compiled")
+        if (
+            not isinstance(compiled, Mapping)
+            or compiled
+            != {
+                "kind": "built-in-sm-source",
+                "resource_id": None,
+                "source_revision": expected_revision,
+                "compile_excluded_from_generation": False,
+            }
+        ):
+            raise AcceptanceError(f"{role} compiled lane is not built-in source")
+        packaged: dict[str, object] | None = None
+        for mode in ("eager", "recurrence"):
+            identity = identities.get(mode)
+            if (
+                not isinstance(identity, Mapping)
+                or identity.get("kind") != "packaged-prepared-model"
+                or identity.get("resource_id") != benchmark.PREPARED_MODEL_ID
+                or identity.get("compile_excluded_from_generation") is not True
+                or not _positive_number(identity.get("size_bytes"))
+                or not isinstance(identity.get("sha256"), str)
+            ):
+                raise AcceptanceError(f"{role} {mode} model identity is invalid")
+            stable = {
+                key: identity.get(key)
+                for key in (
+                    "kind",
+                    "resource_id",
+                    "size_bytes",
+                    "sha256",
+                    "compile_excluded_from_generation",
+                )
+            }
+            if packaged is None:
+                packaged = stable
+            elif stable != packaged:
+                raise AcceptanceError(f"{role} packaged model identities differ")
+        assert packaged is not None
+        return {"kind": "builtin", "packaged_prepared_model": packaged}
+    if not isinstance(configuration.get("prepared_model_path"), str):
+        raise AcceptanceError(f"{role} has no explicit UFO prepared model")
+    prepared_models = bundle.get("prepared_models")
+    expected_file = (
+        prepared_models.get("ufo-sm")
+        if isinstance(prepared_models, Mapping)
+        else None
+    )
+    if not isinstance(expected_file, Mapping):
+        raise AcceptanceError("runtime bundle has no UFO prepared-model identity")
+    stable_explicit: dict[str, object] | None = None
+    for mode in REQUIRED_MODES:
+        identity = identities.get(mode)
+        file_identity = identity.get("file") if isinstance(identity, Mapping) else None
+        if (
+            not isinstance(identity, Mapping)
+            or identity.get("kind") != "explicit-prepared-model"
+            or identity.get("resource_id") is not None
+            or identity.get("compile_excluded_from_generation") is not True
+            or not isinstance(file_identity, Mapping)
+            or file_identity.get("sha256") != expected_file.get("sha256")
+            or file_identity.get("size_bytes") != expected_file.get("size_bytes")
+        ):
+            raise AcceptanceError(f"{role} {mode} UFO model identity is invalid")
+        stable = {
+            "kind": identity.get("kind"),
+            "resource_id": identity.get("resource_id"),
+            "compile_excluded_from_generation": identity.get(
+                "compile_excluded_from_generation"
+            ),
+            "file": {
+                "sha256": file_identity.get("sha256"),
+                "size_bytes": file_identity.get("size_bytes"),
+            },
+        }
+        if stable_explicit is None:
+            stable_explicit = stable
+        elif stable != stable_explicit:
+            raise AcceptanceError(f"{role} explicit model identities differ")
+    assert stable_explicit is not None
+    return {"kind": "ufo", "prepared_model": stable_explicit}
+
+
+def _profile_for_batch(
+    payload: Mapping[str, Any],
+    *,
+    mode: str,
+    batch_size: int,
+) -> Mapping[str, Any]:
+    profiles = payload.get("profiles")
+    lane = profiles.get(mode) if isinstance(profiles, Mapping) else None
+    measurements = lane.get("profiles") if isinstance(lane, Mapping) else None
+    if not isinstance(measurements, list):
+        raise AcceptanceError(f"{mode} profile inventory is missing")
+    matches = [
+        measurement
+        for measurement in measurements
+        if isinstance(measurement, Mapping)
+        and measurement.get("batch_size") == batch_size
+    ]
+    if len(matches) != 1:
+        raise AcceptanceError(f"{mode} batch {batch_size} is not unique")
+    return matches[0]
+
+
+def _paired_cell_evidence(
+    payload: Mapping[str, Any],
+    *,
+    batch_size: int,
+    ceiling: float,
+) -> dict[str, object]:
+    by_mode: dict[str, dict[int, float]] = {}
+    for mode in ("compiled", "recurrence"):
+        measurement = _profile_for_batch(
+            payload,
+            mode=mode,
+            batch_size=batch_size,
+        )
+        samples = measurement.get("subprocess_samples")
+        if (
+            measurement.get("interrupted") is not False
+            or not _exact_int(measurement.get("sample_count"), 7)
+            or not _exact_int(measurement.get("subprocess_sample_count"), 7)
+            or measurement.get("statistics_contract")
+            != "subprocess-median-and-raw-mad-v1"
+            or not isinstance(samples, list)
+            or len(samples) != 7
+        ):
+            raise AcceptanceError(
+                f"{mode} batch {batch_size} is not seven-sample evidence"
+            )
+        rounds: dict[int, float] = {}
+        for sample in samples:
+            round_index = sample.get("round") if isinstance(sample, Mapping) else None
+            wall = (
+                sample.get("wall_seconds_per_point")
+                if isinstance(sample, Mapping)
+                else None
+            )
+            if (
+                isinstance(round_index, bool)
+                or not isinstance(round_index, int)
+                or round_index < 0
+                or round_index >= 7
+                or round_index in rounds
+                or not _positive_number(wall)
+            ):
+                raise AcceptanceError(
+                    f"{mode} batch {batch_size} has invalid paired samples"
+                )
+            rounds[round_index] = float(wall)
+        if set(rounds) != set(range(7)):
+            raise AcceptanceError(
+                f"{mode} batch {batch_size} does not cover seven rounds"
+            )
+        values = list(rounds.values())
+        observed_median = statistics.median(values)
+        observed_mad = statistics.median(
+            abs(value - observed_median) for value in values
+        )
+        if (
+            not math.isclose(
+                float(measurement.get("wall_seconds_per_point_median", math.nan)),
+                observed_median,
+                rel_tol=1.0e-15,
+                abs_tol=0.0,
+            )
+            or not math.isclose(
+                float(measurement.get("wall_seconds_per_point_mad", math.nan)),
+                observed_mad,
+                rel_tol=1.0e-15,
+                abs_tol=0.0,
+            )
+        ):
+            raise AcceptanceError(
+                f"{mode} batch {batch_size} headline statistics changed"
+            )
+        by_mode[mode] = rounds
+    ratios = [
+        by_mode["compiled"][round_index] / by_mode["recurrence"][round_index]
+        for round_index in range(7)
+    ]
+    ratio_median = statistics.median(ratios)
+    ratio_mad = statistics.median(abs(value - ratio_median) for value in ratios)
+    upper = ratio_median + 3.0 * ratio_mad
+    passes = (
+        math.isfinite(ratio_median)
+        and ratio_median >= 0.0
+        and math.isfinite(ratio_mad)
+        and ratio_mad >= 0.0
+        and math.isfinite(upper)
+        and upper >= 0.0
+        and ratio_median <= ceiling
+        and upper <= ceiling
+    )
+    return {
+        "batch_size": batch_size,
+        "pairing": "same-interleaved-schedule-round-v1",
+        "sample_count": len(ratios),
+        "compiled_wall_seconds_per_point_by_round": [
+            by_mode["compiled"][index] for index in range(7)
+        ],
+        "recurrence_wall_seconds_per_point_by_round": [
+            by_mode["recurrence"][index] for index in range(7)
+        ],
+        "compiled_over_recurrence_ratios_by_round": ratios,
+        "ratio_statistics": {
+            "contract": "median-and-raw-mad-v1",
+            "median": ratio_median,
+            "raw_mad": ratio_mad,
+            "upper_three_raw_mad": upper,
+        },
+        "ceiling": ceiling,
+        "passes": passes,
+    }
+
+
+def _checked_bundle(
+    path: Path,
+    *,
+    workflow_run_id: str,
+    expected_revision: str,
+) -> tuple[dict[str, Any], dict[str, object]]:
+    payload, file_identity = shard_io._checked_json(
+        path,
+        label="x86 runtime bundle manifest",
+    )
+    try:
+        runtime_bundle._require_content_identity(payload)
+    except runtime_bundle.BundleError as error:
+        raise AcceptanceError("runtime bundle content identity is invalid") from error
+    if (
+        payload.get("kind") != runtime_bundle.BUNDLE_KIND
+        or payload.get("schema_version") != runtime_bundle.SCHEMA_VERSION
+        or payload.get("target") != "x86_64-unknown-linux-gnu"
+        or payload.get("workflow_run_id") != workflow_run_id
+        or payload.get("expected_current_revision") != expected_revision
+        or payload.get("passes") is not True
+    ):
+        raise AcceptanceError("runtime bundle is not bound to this workflow/source")
+    return payload, file_identity
+
+
+def audit(
+    *,
+    capture_paths: Mapping[str, Path],
+    runtime_bundle_manifest: Path,
+    workflow_run_id: str,
+    expected_current_revision: str,
+    ratio_ceiling: float = COMPILED_RECURRENCE_RATIO_CEILING,
+) -> dict[str, object]:
+    if set(capture_paths) != set(CAPTURE_CONTRACTS):
+        raise AcceptanceError("exactly the four canonical capture roles are required")
+    if not _positive_number(ratio_ceiling):
+        raise AcceptanceError("compiled/recurrence ratio ceiling must be positive")
+    bundle, bundle_file = _checked_bundle(
+        runtime_bundle_manifest,
+        workflow_run_id=workflow_run_id,
+        expected_revision=expected_current_revision,
+    )
+    capture_evidence: dict[str, object] = {}
+    runtime_digests: set[str] = set()
+    for role in CAPTURE_CONTRACTS:
+        payload, file_identity = shard_io._checked_json(
+            capture_paths[role],
+            label=f"{role} recurrence capture",
+        )
+        if (
+            payload.get("kind") != benchmark.RESULT_KIND
+            or payload.get("schema_version") != benchmark.RESULT_SCHEMA
+            or payload.get("complete") is not True
+            or payload.get("passes") is not True
+        ):
+            raise AcceptanceError(f"{role} is not a passing benchmark result")
+        configuration = _validate_configuration(payload, role=role)
+        runtime_digest = _validate_runtime(
+            payload,
+            role=role,
+            expected_revision=expected_current_revision,
+            bundle=bundle,
+        )
+        runtime_digests.add(runtime_digest)
+        model = _validate_model(
+            configuration,
+            role=role,
+            expected_revision=expected_current_revision,
+            bundle=bundle,
+        )
+        _recompute_harness_contracts(payload)
+        cells = [
+            _paired_cell_evidence(
+                payload,
+                batch_size=batch_size,
+                ceiling=float(ratio_ceiling),
+            )
+            for batch_size in PERFORMANCE_BATCH_SIZES
+        ]
+        capture_evidence[role] = {
+            "capture_file": {
+                key: file_identity[key]
+                for key in ("size_bytes", "sha256", "canonical_sha256")
+            },
+            "source_revision": expected_current_revision,
+            "runtime_provenance_sha256": runtime_digest,
+            "model": model,
+            "layout": CAPTURE_CONTRACTS[role]["layout"],
+            "workload": CAPTURE_CONTRACTS[role]["workload"],
+            "numerical_validation": {
+                "contract": "recomputed-recurrence-z6g-pairwise-and-resolved-v1",
+                "passes": True,
+            },
+            "performance_cells": cells,
+            "passes": all(cell["passes"] is True for cell in cells),
+        }
+    if len(runtime_digests) != 1:
+        raise AcceptanceError("the four captures used different runtime provenance")
+    all_cells = [
+        cell
+        for capture in capture_evidence.values()
+        if isinstance(capture, Mapping)
+        for cell in capture["performance_cells"]
+    ]
+    body = {
+        "kind": RESULT_KIND,
+        "schema_version": SCHEMA_VERSION,
+        "workflow_run_id": workflow_run_id,
+        "target": "x86_64-unknown-linux-gnu",
+        "expected_current_revision": expected_current_revision,
+        "runtime_bundle": {
+            "content_sha256": bundle["content_identity"]["sha256"],
+            "file_sha256": bundle_file["sha256"],
+        },
+        "policy": {
+            "required_capture_roles": list(CAPTURE_CONTRACTS),
+            "required_modes": list(REQUIRED_MODES),
+            "required_batch_sizes": list(REQUIRED_BATCH_SIZES),
+            "performance_batch_sizes": list(PERFORMANCE_BATCH_SIZES),
+            "minimum_target_runtime_seconds_per_worker": 5.0,
+            "subprocess_samples_per_cell": 7,
+            "native_wall_blocks_per_worker": 7,
+            "warmup_runs": 2,
+            "numerical_validation_samples": 10,
+            "compiled_over_recurrence_ratio_ceiling": float(ratio_ceiling),
+            "ratio_gate": "median-plus-three-raw-mad-at-or-below-ceiling-v1",
+            "diagnostic_shortcuts_allowed": False,
+        },
+        "captures": capture_evidence,
+        "performance_cell_count": len(all_cells),
+        "passes": (
+            len(all_cells) == len(CAPTURE_CONTRACTS) * len(PERFORMANCE_BATCH_SIZES)
+            and all(cell["passes"] is True for cell in all_cells)
+        ),
+    }
+    return _attach_content_identity(body)
+
+
+def _git_sha(value: str) -> str:
+    if _GIT_SHA.fullmatch(value) is None:
+        raise argparse.ArgumentTypeError("must be a lowercase 40-character Git SHA")
+    return value
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    for role in CAPTURE_CONTRACTS:
+        result.add_argument(f"--{role}", type=Path, required=True)
+    result.add_argument("--runtime-bundle-manifest", type=Path, required=True)
+    result.add_argument("--workflow-run-id", required=True)
+    result.add_argument(
+        "--expected-current-revision",
+        type=_git_sha,
+        required=True,
+    )
+    result.add_argument(
+        "--compiled-recurrence-ratio-ceiling",
+        type=float,
+        default=COMPILED_RECURRENCE_RATIO_CEILING,
+    )
+    result.add_argument("--output", type=Path, required=True)
+    return result
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    try:
+        result = audit(
+            capture_paths={
+                role: getattr(arguments, role.replace("-", "_"))
+                for role in CAPTURE_CONTRACTS
+            },
+            runtime_bundle_manifest=arguments.runtime_bundle_manifest,
+            workflow_run_id=arguments.workflow_run_id,
+            expected_current_revision=arguments.expected_current_revision,
+            ratio_ceiling=arguments.compiled_recurrence_ratio_ceiling,
+        )
+        _write_json_atomic(arguments.output, result)
+    except (
+        AcceptanceError,
+        OSError,
+        shard_io.ShardError,
+    ) as error:
+        print(f"x86-qq-recurrence-acceptance: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, sort_keys=True, allow_nan=False))
+    return 0 if result["passes"] is True else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/fft_profiling/__init__.py b/pyamplicol/tools/fft_profiling/__init__.py
new file mode 100644
index 0000000000..e68b21fb13
--- /dev/null
+++ b/pyamplicol/tools/fft_profiling/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: 0BSD
+"""Cluster-oriented FFT profiling orchestration."""
diff --git a/pyamplicol/tools/fft_profiling/fft_profiling.py b/pyamplicol/tools/fft_profiling/fft_profiling.py
new file mode 100755
index 0000000000..b1352324a6
--- /dev/null
+++ b/pyamplicol/tools/fft_profiling/fft_profiling.py
@@ -0,0 +1,5274 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run and render the FullColor FFT profiling scan on a workstation or cluster.
+
+This is deliberately an orchestration layer.  Physics generation, timings,
+per-cell resource enforcement, numerical validation, report validation,
+plotting, and PDF assembly remain owned by the existing developer tools.
+
+Typical use::
+
+    python tools/fft_profiling/fft_profiling.py --dry-run --cores 8
+    python tools/fft_profiling/fft_profiling.py --lines pyamplicol-recurrence
+    python tools/fft_profiling/fft_profiling.py --cores 8 --candidate-cores 2
+    python tools/fft_profiling/fft_profiling.py --compare-helicity-sums --cores 8
+    python tools/fft_profiling/fft_profiling.py --resume --cores 16
+    python tools/fft_profiling/fft_profiling.py --render
+
+``--render`` never waits for active workers.  It freezes one already-published
+campaign snapshot and delegates the six PNGs and PDF to the authoritative
+renderers.  ``--campaign-report`` can render another live scaling-study report,
+which is useful for an existing non-orchestrated campaign.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import copy
+import fcntl
+import hashlib
+import json
+import math
+import os
+import shlex
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+import uuid
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, BinaryIO
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+try:
+    import colorama
+    import progressbar
+except ModuleNotFoundError as error:  # pragma: no cover - installation dependent
+    raise SystemExit(
+        "fft_profiling.py requires the project dependencies progressbar2 and "
+        "colorama; install pyAmpliCol in this Python environment"
+    ) from error
+
+from tools.ci import memory_watchdog  # noqa: E402
+from tools.developer import fft_madgraph_selected_runtime as madgraph  # noqa: E402
+from tools.developer import (  # noqa: E402
+    fft_scaling_final_publication_report as publication,
+)
+from tools.developer import fft_scaling_selected_scalar_report as selected  # noqa: E402
+from tools.developer import fft_scaling_study as study  # noqa: E402
+
+KIND = "pyamplicol-fft-profiling-orchestrator"
+SCHEMA_VERSION = 1
+DEFAULT_RUNS_ROOT = ROOT / "IMPLEMENTATION_DOCS" / "RESULTS" / "fft-profiling" / "runs"
+DEFAULT_FIXED_OUTPUT = DEFAULT_RUNS_ROOT / "cluster-fullcolor-n2-n9"
+DEFAULT_SUM_OUTPUT = DEFAULT_RUNS_ROOT / "cluster-fullcolor-helicity-sum-n2-n9"
+CANONICAL_RESULTS_ROOT = ROOT / "IMPLEMENTATION_DOCS" / "RESULTS"
+STUDY_TOOL = ROOT / "tools" / "developer" / "fft_scaling_study.py"
+MERGE_TOOL = ROOT / "tools" / "developer" / "fft_scaling_final_publication_report.py"
+PLOT_TOOL = ROOT / "tools" / "developer" / "fft_scaling_study_plots.py"
+PDF_TOOL = ROOT / "tools" / "developer" / "fft_results_summary_pdf.py"
+MADGRAPH_TOOL = ROOT / "tools" / "developer" / "fft_madgraph_selected_runtime.py"
+RENDER_REQUIREMENTS = ("matplotlib==3.11.2", "reportlab==4.5.1")
+TERMINAL_STATUSES = frozenset({"complete", "complete-with-failures"})
+ORCHESTRATOR_TERMINAL_CELL_STATUSES = frozenset(
+    {"measured", "failed", "skipped", "not-applicable"}
+)
+MUTABLE_RESOURCE_IDENTITY_PATHS = frozenset(
+    {
+        "scan.target_seconds",
+        "resources.per_cell_generation_timeout_seconds",
+        "resources.per_cell_memory_limit_gib",
+        "resources.per_cell_runtime_timeout_seconds",
+    }
+)
+RETRYABLE_CELL_STATUSES = frozenset({"failed", "skipped"})
+LEGACY_MADGRAPH_NOTE = (
+    "MadGraph points are retained from a same-workstation snapshot that "
+    "predates the node-fingerprint field; strict terminal host authentication "
+    "is therefore unavailable for this anytime render."
+)
+
+
+class ProfilingError(RuntimeError):
+    """The cluster profiling orchestration contract could not be satisfied."""
+
+
+class CampaignSignal(KeyboardInterrupt):
+    """A termination signal requested a resumable campaign shutdown."""
+
+    def __init__(self, signum: int) -> None:
+        super().__init__(signum)
+        self.signum = signum
+
+
+@dataclass(frozen=True, slots=True)
+class Shard:
+    name: str
+    family: str
+    modes: tuple[str, ...]
+    owned_modes: tuple[str, ...]
+    dependency: tuple[str, str] | None
+    phase: int
+    candidate: bool
+
+
+@dataclass(frozen=True, slots=True)
+class ShardWork:
+    shard: Shard
+    final_multiplicity: int
+    owned_mode: str
+
+
+@dataclass(slots=True)
+class ActiveJob:
+    shard: Shard
+    final_multiplicity: int | None
+    owned_mode: str | None
+    command: tuple[str, ...]
+    process: subprocess.Popen[bytes]
+    stdout: BinaryIO
+    stderr: BinaryIO
+    sampler: memory_watchdog.ProcessTreeSampler
+    claimed_cores: int
+    detail: str
+
+
+@dataclass(frozen=True, slots=True)
+class RenderSelection:
+    source: Path
+    overlay: Path | None
+
+
+CellIdentity = tuple[str, str, int]
+
+
+SHARDS = (
+    Shard("gg-reference", "gg", ("reference-fft",), ("reference-fft",), None, 1, False),
+    Shard("ddbar-amplicol", "ddbar", ("amplicol",), ("amplicol",), None, 1, False),
+    Shard(
+        "gg-recurrence",
+        "gg",
+        ("reference-fft", "recurrence-direct", "recurrence-fft"),
+        ("recurrence-direct", "recurrence-fft"),
+        ("gg-reference", "reference-fft"),
+        2,
+        True,
+    ),
+    Shard(
+        "gg-otf",
+        "gg",
+        ("reference-fft", "otf-direct", "otf-fft"),
+        ("otf-direct", "otf-fft"),
+        ("gg-reference", "reference-fft"),
+        2,
+        True,
+    ),
+    Shard(
+        "ddbar-recurrence",
+        "ddbar",
+        ("amplicol", "recurrence-direct", "recurrence-fft"),
+        ("recurrence-direct", "recurrence-fft"),
+        ("ddbar-amplicol", "amplicol"),
+        2,
+        True,
+    ),
+    Shard(
+        "ddbar-otf",
+        "ddbar",
+        ("amplicol", "otf-direct", "otf-fft"),
+        ("otf-direct", "otf-fft"),
+        ("ddbar-amplicol", "amplicol"),
+        2,
+        True,
+    ),
+    Shard(
+        "gg-amplicol",
+        "gg",
+        ("reference-fft", "amplicol"),
+        ("amplicol",),
+        ("gg-reference", "reference-fft"),
+        2,
+        False,
+    ),
+)
+SHARD_BY_NAME = {shard.name: shard for shard in SHARDS}
+MODE_OWNER = {
+    (shard.family, mode): shard.name for shard in SHARDS for mode in shard.owned_modes
+}
+FAMILIES = ("gg", "ddbar")
+LINE_GROUPS = (
+    "reference-fft",
+    "amplicol",
+    "pyamplicol-recurrence",
+    "pyamplicol-otf",
+    "madgraph",
+)
+LINE_MODE_SELECTORS = (
+    "recurrence-direct",
+    "recurrence-fft",
+    "otf-direct",
+    "otf-fft",
+)
+LINE_CHOICES = (*LINE_GROUPS, *LINE_MODE_SELECTORS)
+RENDER_LINE_CHOICES = (
+    *LINE_CHOICES,
+    "madgraph-standalone",
+    "recola",
+    "compiled-direct",
+    "compiled-fft",
+)
+LINE_SELECTOR_SHARDS = {
+    "reference-fft": ("gg-reference",),
+    "amplicol": ("ddbar-amplicol", "gg-amplicol"),
+    "pyamplicol-recurrence": ("gg-recurrence", "ddbar-recurrence"),
+    "pyamplicol-otf": ("gg-otf", "ddbar-otf"),
+    "madgraph": (),
+    "recurrence-direct": ("gg-recurrence", "ddbar-recurrence"),
+    "recurrence-fft": ("gg-recurrence", "ddbar-recurrence"),
+    "otf-direct": ("gg-otf", "ddbar-otf"),
+    "otf-fft": ("gg-otf", "ddbar-otf"),
+}
+LINE_SELECTOR_OWNED_MODES = {
+    "reference-fft": ("reference-fft",),
+    "amplicol": ("amplicol",),
+    "pyamplicol-recurrence": ("recurrence-direct", "recurrence-fft"),
+    "pyamplicol-otf": ("otf-direct", "otf-fft"),
+    "madgraph": (),
+    "recurrence-direct": ("recurrence-direct",),
+    "recurrence-fft": ("recurrence-fft",),
+    "otf-direct": ("otf-direct",),
+    "otf-fft": ("otf-fft",),
+}
+
+
+def _positive_finite(raw: str) -> float:
+    value = float(raw)
+    if not math.isfinite(value) or value <= 0.0:
+        raise argparse.ArgumentTypeError("must be positive and finite")
+    return value
+
+
+def _finite_float(raw: str) -> float:
+    value = float(raw)
+    if not math.isfinite(value):
+        raise argparse.ArgumentTypeError("must be finite")
+    return value
+
+
+def _positive_integer(raw: str) -> int:
+    value = int(raw)
+    if value < 1:
+        raise argparse.ArgumentTypeError("must be positive")
+    return value
+
+
+def _default_madgraph_root() -> Path | None:
+    configured = os.environ.get("PYAMPLICOL_MADGRAPH_ROOT")
+    candidates = (
+        *((Path(configured).expanduser(),) if configured else ()),
+        ROOT / "dependencies" / "checkouts" / "MG5_aMC",
+        ROOT.parent / "MG5_aMC",
+        Path.home() / "MG5" / "MG5_aMC_v3_7_1",
+    )
+    return next(
+        (
+            candidate.resolve(strict=False)
+            for candidate in candidates
+            if (candidate / "bin" / "mg5_aMC").is_file()
+            and (candidate / "VERSION").is_file()
+        ),
+        None,
+    )
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    action = parser.add_mutually_exclusive_group()
+    action.add_argument(
+        "--refresh",
+        action="store_true",
+        help=(
+            "remove the exact recognized profiling --output and restart from scratch"
+        ),
+    )
+    action.add_argument(
+        "--render",
+        action="store_true",
+        help="render the latest frozen snapshot immediately; never wait for workers",
+    )
+    action.add_argument("--status", action="store_true", help="print JSON status")
+    action.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="print the deterministic plan as JSON without writing or launching",
+    )
+    parser.add_argument(
+        "--resume",
+        action="store_true",
+        help="explicit alias for the default automatic resume behavior",
+    )
+    rerun = parser.add_mutually_exclusive_group()
+    rerun.add_argument(
+        "--retry",
+        action="store_true",
+        help=(
+            "rerun failed/skipped cells in the current --families/--lines/"
+            "--multiplicities selection without refreshing the whole output"
+        ),
+    )
+    rerun.add_argument(
+        "--overwrite",
+        action="store_true",
+        help=(
+            "rerun every cell in the current --families/--lines/--multiplicities "
+            "selection, replacing each old result only when its worker starts"
+        ),
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=None,
+        help=(
+            "complete profiling run/render directory (default is a distinct "
+            "fixed-helicity or helicity-sum run directory)"
+        ),
+    )
+    parser.add_argument(
+        "--compare-helicity-sums",
+        action="store_true",
+        help=(
+            "profile the complete physical-helicity-summed matrix element in "
+            "an independent campaign, including a genuine summed MadGraph "
+            "standalone series when --madgraph-root is available"
+        ),
+    )
+    parser.add_argument(
+        "--multiplicities",
+        type=int,
+        nargs="+",
+        default=list(range(2, 10)),
+        metavar="N",
+        help=(
+            "final-state multiplicities to add to the resumable scan; unfinished "
+            "prior requests are also recovered (default: 2 3 ... 9)"
+        ),
+    )
+    parser.add_argument(
+        "--lines",
+        nargs="+",
+        choices=LINE_CHOICES,
+        default=list(LINE_GROUPS),
+        metavar="LINE",
+        help=(
+            "plot line groups to add to the resumable scan: reference-fft, "
+            "amplicol, pyamplicol-recurrence (direct and FFT), "
+            "pyamplicol-otf (direct and FFT), concrete pyAmpliCol modes "
+            "recurrence-direct, recurrence-fft, otf-direct, otf-fft, and/or "
+            "madgraph; repeated runs add exactly the requested selectors and "
+            "multiplicities in the same --output (default: all groups)"
+        ),
+    )
+    parser.add_argument(
+        "--families",
+        "--process-families",
+        nargs="+",
+        choices=FAMILIES,
+        default=list(FAMILIES),
+        metavar="FAMILY",
+        help=(
+            "process families to add to the scan: gg for g g > g g + gluons, "
+            "ddbar for d d~ > d d~ + gluons (default: both)"
+        ),
+    )
+    parser.add_argument(
+        "--cores",
+        type=_positive_integer,
+        default=max(1, os.cpu_count() or 1),
+        help="total scheduler core budget (default: detected logical cores)",
+    )
+    parser.add_argument(
+        "--candidate-cores",
+        type=_positive_integer,
+        default=1,
+        help=(
+            "cores claimed by one candidate shard and passed exactly as "
+            "evaluator.optimization.cores (default: 1)"
+        ),
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=_positive_integer,
+        default=study.BENCHMARK_BATCH_SIZE,
+        help=(
+            "points in each pyAmpliCol public profile call; Reference FFT and "
+            "AmpliCol remain scalar aggregates normalized per point "
+            f"(default: {study.BENCHMARK_BATCH_SIZE})"
+        ),
+    )
+    parser.add_argument(
+        "--memory-limit-gib",
+        type=_positive_finite,
+        default=study.REQUESTED_MEMORY_LIMIT_GIB,
+        help="strict RAM cutoff for each measurement child (default: 30)",
+    )
+    parser.add_argument(
+        "--time-limit-seconds",
+        type=_positive_finite,
+        default=study.DEFAULT_TIME_LIMIT_SECONDS,
+        help="generation and runtime cutoff for each cell (default: 3600)",
+    )
+    parser.add_argument("--python", default=sys.executable)
+    parser.add_argument("--cxx", default=os.environ.get("CXX", "c++"))
+    parser.add_argument("--fc", default=os.environ.get("FC", "gfortran"))
+    parser.add_argument("--make", default=os.environ.get("MAKE", "make"))
+    parser.add_argument(
+        "--target-seconds",
+        type=_positive_finite,
+        default=study.DEFAULT_PROFILE_TARGET_SECONDS,
+        help=(
+            "target runtime for each profiling cell after its first "
+            "calibration/probe evaluation (default: 180)"
+        ),
+    )
+    parser.add_argument(
+        "--otf-max-multiplicity",
+        type=int,
+        default=study.DEFAULT_OTF_MAX_MULTIPLICITY,
+        help=(
+            "largest final-state multiplicity to admit for pyAmpliCol OTF "
+            "measurements; raise this for an explicit high-multiplicity top-up "
+            f"(default: {study.DEFAULT_OTF_MAX_MULTIPLICITY})"
+        ),
+    )
+    parser.add_argument(
+        "--amplicol-root",
+        "--amplicol-repository",
+        dest="amplicol_root",
+        type=Path,
+        default=study.legacy_amplicol.DEFAULT_REPOSITORY,
+        help=(
+            "original-AmpliCol checkout (default path is populated by "
+            "dev-install --with-legacy-amplicol)"
+        ),
+    )
+    parser.add_argument(
+        "--reference-fft-root",
+        type=Path,
+        default=study.performance.DEFAULT_REFERENCE_ROOT,
+        help=(
+            "pinned AllGluonsMultipletFFT checkout for Reference FFT "
+            "(default path is populated by dev-install --with-reference-fft)"
+        ),
+    )
+    parser.add_argument(
+        "--build-amplicol",
+        action="store_true",
+        help="allow the prerequisite AmpliCol shard to build its probe once",
+    )
+    parser.add_argument(
+        "--madgraph-root",
+        type=Path,
+        default=_default_madgraph_root(),
+        help=(
+            "MadGraph installation used for the same-host standalone series "
+            "(defaults to PYAMPLICOL_MADGRAPH_ROOT or a developer checkout)"
+        ),
+    )
+    parser.add_argument(
+        "--madgraph-overlay",
+        type=Path,
+        help="with --render --campaign-report, an existing authenticated overlay",
+    )
+    parser.add_argument(
+        "--campaign-report",
+        type=Path,
+        help="with --render, freeze and render this existing live report",
+    )
+    parser.add_argument(
+        "--recola-results",
+        type=Path,
+        help="with --render, overlay a Recola profiling JSON as a Recola line",
+    )
+    parser.add_argument(
+        "--main-y-range",
+        type=_finite_float,
+        nargs=2,
+        metavar=("MIN", "MAX"),
+        help="with --render, force the main-panel log y-range for every plot",
+    )
+    parser.add_argument(
+        "--ratio-y-range",
+        type=_finite_float,
+        nargs=2,
+        metavar=("MIN", "MAX"),
+        help="with --render, force the ratio-panel y-range for every plot",
+    )
+    parser.add_argument(
+        "--ratio-y-scale",
+        choices=("log", "linear"),
+        default="log",
+        help="with --render, ratio-panel y-axis scale (default: log)",
+    )
+    parser.add_argument(
+        "--main-include-lines",
+        nargs="+",
+        choices=RENDER_LINE_CHOICES,
+        metavar="LINE",
+        help="with --render, main-panel line ids to include; overrides vetoes",
+    )
+    parser.add_argument(
+        "--main-veto-lines",
+        nargs="+",
+        choices=RENDER_LINE_CHOICES,
+        metavar="LINE",
+        help="with --render, main-panel line ids to hide when include is absent",
+    )
+    parser.add_argument(
+        "--ratio-include-lines",
+        nargs="+",
+        choices=RENDER_LINE_CHOICES,
+        metavar="LINE",
+        help="with --render, ratio-panel line ids to include; overrides vetoes",
+    )
+    parser.add_argument(
+        "--ratio-veto-lines",
+        nargs="+",
+        choices=RENDER_LINE_CHOICES,
+        metavar="LINE",
+        help="with --render, ratio-panel line ids to hide when include is absent",
+    )
+    parser.add_argument("--dpi", type=int, default=160)
+    parser.add_argument("--poll-seconds", type=_positive_finite, default=0.5)
+    parser.add_argument("--no-color", action="store_true")
+    return parser
+
+
+def _absolute(path: Path) -> Path:
+    return path.expanduser().resolve(strict=False)
+
+
+def _configured_run_path(arguments: argparse.Namespace) -> Path:
+    if arguments.output is not None:
+        return arguments.output
+    return (
+        DEFAULT_SUM_OUTPUT if arguments.compare_helicity_sums else DEFAULT_FIXED_OUTPUT
+    )
+
+
+def _run_directory(arguments: argparse.Namespace) -> Path:
+    return _absolute(_configured_run_path(arguments))
+
+
+def _helicity_workload(arguments: argparse.Namespace) -> str:
+    return "sum" if arguments.compare_helicity_sums else "fixed"
+
+
+def _pdf_filename(arguments: argparse.Namespace) -> str:
+    return (
+        "summary_plots_final_helicity_sum.pdf"
+        if arguments.compare_helicity_sums
+        else "summary_plots_final.pdf"
+    )
+
+
+def _canonical_pdf_path(arguments: argparse.Namespace) -> Path:
+    return CANONICAL_RESULTS_ROOT / _pdf_filename(arguments)
+
+
+def _json_filename(arguments: argparse.Namespace) -> str:
+    return Path(_pdf_filename(arguments)).with_suffix(".json").name
+
+
+def _canonical_publication_enabled(arguments: argparse.Namespace) -> bool:
+    return arguments.output is None and arguments.campaign_report is None
+
+
+def _universe(arguments: argparse.Namespace) -> tuple[int, ...]:
+    stored = getattr(arguments, "universe_multiplicities", None)
+    if stored is not None:
+        return tuple(int(value) for value in stored)
+    return tuple(range(2, 10))
+
+
+def _selection(arguments: argparse.Namespace) -> tuple[int, ...]:
+    return tuple(sorted(set(arguments.multiplicities)))
+
+
+def _family_selection(arguments: argparse.Namespace) -> tuple[str, ...]:
+    selected = set(arguments.families)
+    return tuple(family for family in FAMILIES if family in selected)
+
+
+def _line_selection(arguments: argparse.Namespace) -> tuple[str, ...]:
+    selected = set(arguments.lines)
+    return tuple(line for line in LINE_CHOICES if line in selected)
+
+
+def _requested_line_groups(
+    arguments: argparse.Namespace, run_directory: Path
+) -> tuple[str, ...]:
+    _ = run_directory
+    selected = set(_line_selection(arguments))
+    return tuple(line for line in LINE_CHOICES if line in selected)
+
+
+def _madgraph_requested(arguments: argparse.Namespace, run_directory: Path) -> bool:
+    return "madgraph" in _requested_line_groups(arguments, run_directory)
+
+
+def _requested_shards(
+    arguments: argparse.Namespace, run_directory: Path
+) -> tuple[Shard, ...]:
+    selected_families = set(_family_selection(arguments))
+    names = {
+        name
+        for line in _requested_line_groups(arguments, run_directory)
+        for name in LINE_SELECTOR_SHARDS[line]
+        if SHARD_BY_NAME[name].family in selected_families
+    }
+    if _madgraph_requested(arguments, run_directory):
+        source_modes = (
+            publication.SUM_SOURCE_MODE
+            if arguments.compare_helicity_sums
+            else publication.SOURCE_MODE
+        )
+        names.update(
+            MODE_OWNER[(family, mode)]
+            for family, mode in source_modes.items()
+            if family in selected_families
+        )
+    pending = list(names)
+    while pending:
+        shard = SHARD_BY_NAME[pending.pop()]
+        if shard.dependency is None:
+            continue
+        dependency_name, _ = shard.dependency
+        if dependency_name not in names:
+            names.add(dependency_name)
+            pending.append(dependency_name)
+    return tuple(shard for shard in SHARDS if shard.name in names)
+
+
+def _line_selected_owned_modes(
+    arguments: argparse.Namespace, run_directory: Path, shard: Shard
+) -> tuple[str, ...]:
+    selected: set[str] = set()
+    for line in _requested_line_groups(arguments, run_directory):
+        for mode in LINE_SELECTOR_OWNED_MODES[line]:
+            if mode in shard.owned_modes:
+                selected.add(mode)
+    if _madgraph_requested(arguments, run_directory):
+        source_modes = (
+            publication.SUM_SOURCE_MODE
+            if arguments.compare_helicity_sums
+            else publication.SOURCE_MODE
+        )
+        for family, mode in source_modes.items():
+            if MODE_OWNER[(family, mode)] == shard.name:
+                selected.add(mode)
+    return tuple(mode for mode in shard.owned_modes if mode in selected)
+
+
+def _shard_owned_modes(
+    arguments: argparse.Namespace, run_directory: Path, shard: Shard
+) -> tuple[str, ...]:
+    selected = set(_line_selected_owned_modes(arguments, run_directory, shard))
+    requested_names = {
+        requested.name for requested in _requested_shards(arguments, run_directory)
+    }
+    for requested in SHARDS:
+        if requested.name not in requested_names or requested.dependency is None:
+            continue
+        dependency_name, dependency_mode = requested.dependency
+        if dependency_name == shard.name and dependency_mode in shard.owned_modes:
+            selected.add(dependency_mode)
+    return tuple(mode for mode in shard.owned_modes if mode in selected)
+
+
+def _shard_modes(
+    arguments: argparse.Namespace, run_directory: Path, shard: Shard
+) -> tuple[str, ...]:
+    selected = set(_shard_owned_modes(arguments, run_directory, shard))
+    if selected and shard.dependency is not None:
+        _, dependency_mode = shard.dependency
+        selected.add(dependency_mode)
+    return tuple(mode for mode in shard.modes if mode in selected)
+
+
+def _counted_owned_modes(
+    arguments: argparse.Namespace, run_directory: Path, shard: Shard
+) -> tuple[str, ...]:
+    if arguments.retry or arguments.overwrite:
+        return _line_selected_owned_modes(arguments, run_directory, shard)
+    return _shard_owned_modes(arguments, run_directory, shard)
+
+
+def _scheduled_shards(
+    arguments: argparse.Namespace, run_directory: Path
+) -> tuple[Shard, ...]:
+    if not (arguments.retry or arguments.overwrite):
+        return _requested_shards(arguments, run_directory)
+    return tuple(
+        shard
+        for shard in _requested_shards(arguments, run_directory)
+        if _counted_owned_modes(arguments, run_directory, shard)
+    )
+
+
+def _shard_run_id(shard: Shard, final_multiplicity: int | None = None) -> str:
+    if final_multiplicity is None:
+        return shard.name
+    return f"{shard.name}-n{final_multiplicity}"
+
+
+def _work_split_path(work: ShardWork) -> bool:
+    return len(work.shard.owned_modes) > 1
+
+
+def _work_run_id(work: ShardWork) -> str:
+    if not _work_split_path(work):
+        return _shard_run_id(work.shard, work.final_multiplicity)
+    return f"{work.shard.name}-{work.owned_mode}-n{work.final_multiplicity}"
+
+
+def _work_identity(work: ShardWork) -> CellIdentity:
+    return (work.shard.family, work.owned_mode, work.final_multiplicity)
+
+
+def _shard_cell_root(
+    run_directory: Path, shard: Shard, final_multiplicity: int
+) -> Path:
+    return run_directory / "shards" / shard.name / "cells" / f"n{final_multiplicity}"
+
+
+def _work_cell_root(run_directory: Path, work: ShardWork) -> Path:
+    if not _work_split_path(work):
+        return _shard_cell_root(run_directory, work.shard, work.final_multiplicity)
+    return (
+        run_directory
+        / "shards"
+        / work.shard.name
+        / "mode-cells"
+        / work.owned_mode
+        / f"n{work.final_multiplicity}"
+    )
+
+
+def _shard_study_root(
+    run_directory: Path, shard: Shard, final_multiplicity: int | None = None
+) -> Path:
+    if final_multiplicity is None:
+        return run_directory / "shards" / shard.name / "study"
+    return _shard_cell_root(run_directory, shard, final_multiplicity) / "study"
+
+
+def _work_study_root(run_directory: Path, work: ShardWork) -> Path:
+    return _work_cell_root(run_directory, work) / "study"
+
+
+def _shard_report_path(
+    run_directory: Path, shard: Shard, final_multiplicity: int | None = None
+) -> Path:
+    return (
+        _shard_study_root(run_directory, shard, final_multiplicity)
+        / "runs"
+        / _shard_run_id(shard, final_multiplicity)
+        / "report.json"
+    )
+
+
+def _work_report_path(run_directory: Path, work: ShardWork) -> Path:
+    return (
+        _work_study_root(run_directory, work)
+        / "runs"
+        / _work_run_id(work)
+        / "report.json"
+    )
+
+
+def _master_study_root(run_directory: Path) -> Path:
+    return run_directory / "master"
+
+
+def _master_report_path(run_directory: Path) -> Path:
+    return _master_study_root(run_directory) / "runs" / "campaign" / "report.json"
+
+
+def _madgraph_overlay_path(run_directory: Path) -> Path:
+    return run_directory / "madgraph" / "overlay.json"
+
+
+def _madgraph_progress_path(run_directory: Path) -> Path:
+    return run_directory / "madgraph" / "overlay.progress.json"
+
+
+def _madgraph_cache_path(run_directory: Path) -> Path:
+    return run_directory / "madgraph" / "cache"
+
+
+def _requested_multiplicities(
+    arguments: argparse.Namespace, run_directory: Path
+) -> tuple[int, ...]:
+    _ = run_directory
+    return _selection(arguments)
+
+
+def _manifest_int_history(
+    manifest: Mapping[str, Any], primary: str, fallback: str
+) -> list[int]:
+    values = manifest.get(primary, manifest.get(fallback, []))
+    if not isinstance(values, list) or any(
+        not isinstance(value, int) for value in values
+    ):
+        raise ProfilingError("profiling manifest has invalid fill history")
+    return values
+
+
+def _manifest_line_history(manifest: Mapping[str, Any]) -> list[str]:
+    values = manifest.get(
+        "line_group_history", manifest.get("requested_line_groups", [])
+    )
+    if (
+        not isinstance(values, list)
+        or any(not isinstance(value, str) for value in values)
+        or not set(values).issubset(LINE_CHOICES)
+    ):
+        raise ProfilingError("profiling manifest has invalid line-group history")
+    selected = set(values)
+    return [line for line in LINE_CHOICES if line in selected]
+
+
+def _manifest_family_history(manifest: Mapping[str, Any]) -> list[str]:
+    identity = manifest.get("identity")
+    scan = identity.get("scan") if isinstance(identity, Mapping) else None
+    fallback = (
+        scan.get("families")
+        if isinstance(scan, Mapping) and isinstance(scan.get("families"), list)
+        else []
+    )
+    values = manifest.get(
+        "process_family_history", manifest.get("requested_families", fallback)
+    )
+    if (
+        not isinstance(values, list)
+        or any(not isinstance(value, str) for value in values)
+        or not set(values).issubset(FAMILIES)
+    ):
+        raise ProfilingError("profiling manifest has invalid process-family history")
+    selected = set(values)
+    return [family for family in FAMILIES if family in selected]
+
+
+def _manifest_backed_arguments(
+    arguments: argparse.Namespace, run_directory: Path
+) -> argparse.Namespace:
+    manifest_path = _manifest_path(run_directory)
+    if not manifest_path.is_file():
+        return arguments
+    manifest = _load_json(manifest_path, context="profiling manifest")
+    identity = manifest.get("identity")
+    if not isinstance(identity, Mapping):
+        return arguments
+    backed = copy.copy(arguments)
+    scan = identity.get("scan")
+    if isinstance(scan, Mapping):
+        workload = scan.get("helicity_workload")
+        if workload in {"fixed", "sum"}:
+            backed.compare_helicity_sums = workload == "sum"
+        if isinstance(scan.get("batch_size"), int):
+            backed.batch_size = scan["batch_size"]
+        if isinstance(scan.get("target_seconds"), int | float):
+            backed.target_seconds = float(scan["target_seconds"])
+    resources = identity.get("resources")
+    if isinstance(resources, Mapping):
+        if isinstance(resources.get("candidate_optimization_cores"), int):
+            backed.candidate_cores = resources["candidate_optimization_cores"]
+        if isinstance(resources.get("per_cell_memory_limit_gib"), int | float):
+            backed.memory_limit_gib = float(resources["per_cell_memory_limit_gib"])
+        generation_timeout = resources.get("per_cell_generation_timeout_seconds")
+        runtime_timeout = resources.get("per_cell_runtime_timeout_seconds")
+        if isinstance(generation_timeout, int | float) and isinstance(
+            runtime_timeout, int | float
+        ):
+            backed.time_limit_seconds = float(max(generation_timeout, runtime_timeout))
+    tools = identity.get("tools")
+    if isinstance(tools, Mapping):
+        for attribute in ("python", "cxx", "fc"):
+            value = tools.get(attribute)
+            if isinstance(value, str) and value:
+                setattr(backed, attribute, value)
+        for attribute in ("amplicol_root", "reference_fft_root", "madgraph_root"):
+            value = tools.get(attribute)
+            if isinstance(value, str) and value:
+                setattr(backed, attribute, Path(value))
+    return backed
+
+
+def _composition_arguments(
+    arguments: argparse.Namespace, run_directory: Path
+) -> argparse.Namespace:
+    backed = _manifest_backed_arguments(arguments, run_directory)
+    manifest_path = _manifest_path(run_directory)
+    if not manifest_path.is_file():
+        return backed
+    manifest = _load_json(manifest_path, context="profiling manifest")
+    composed = copy.copy(backed)
+    composed.multiplicities = _manifest_int_history(
+        manifest, "fill_history_multiplicities", "requested_multiplicities"
+    )
+    composed.lines = _manifest_line_history(manifest)
+    composed.families = _manifest_family_history(manifest)
+    return composed
+
+
+def _madgraph_source_path(arguments: argparse.Namespace, run_directory: Path) -> Path:
+    multiplicities = _requested_multiplicities(arguments, run_directory)
+    selection = "-".join(str(value) for value in multiplicities)
+    return run_directory / "madgraph" / "source-reports" / f"n-{selection}.json"
+
+
+def _manifest_path(run_directory: Path) -> Path:
+    return run_directory / "manifest.json"
+
+
+def _study_cli_arguments(
+    arguments: argparse.Namespace,
+    *,
+    study_root: Path,
+    run_id: str,
+    families: Sequence[str],
+    modes: Sequence[str],
+    resume: bool,
+    build_amplicol: bool = False,
+    fill_multiplicities: Sequence[int] | None = None,
+    fill_modes: Sequence[str] | None = None,
+) -> tuple[str, ...]:
+    result = [
+        "--study-root",
+        str(study_root),
+        "--run-id",
+        run_id,
+        "--fft",
+        "--explicit-modes",
+        "--batch-size",
+        str(arguments.batch_size),
+        "--optimization-cores",
+        str(arguments.candidate_cores),
+        "--python",
+        str(arguments.python),
+        "--cxx",
+        str(arguments.cxx),
+        "--fc",
+        str(arguments.fc),
+        "--alpha-s",
+        format(study.DEFAULT_ALPHA_S, ".17g"),
+        "--target-seconds",
+        format(arguments.target_seconds, ".17g"),
+        "--generation-timeout",
+        format(arguments.time_limit_seconds, ".17g"),
+        "--runtime-timeout",
+        format(arguments.time_limit_seconds, ".17g"),
+        "--memory-limit-gib",
+        format(arguments.memory_limit_gib, ".17g"),
+        "--otf-max-multiplicity",
+        str(arguments.otf_max_multiplicity),
+        "--amplicol-repository",
+        str(_absolute(arguments.amplicol_root)),
+        "--reference-fft-root",
+        str(_absolute(arguments.reference_fft_root)),
+    ]
+    for multiplicity in _universe(arguments):
+        result.extend(("--multiplicity", str(multiplicity)))
+    for multiplicity in (
+        _selection(arguments)
+        if fill_multiplicities is None
+        else tuple(fill_multiplicities)
+    ):
+        result.extend(("--fill-multiplicity", str(multiplicity)))
+    if fill_modes is not None:
+        for mode in fill_modes:
+            result.extend(("--fill-mode", mode))
+    for family in families:
+        result.extend(("--family", family))
+    for mode in modes:
+        result.extend(("--mode", mode))
+    if resume:
+        result.append("--resume")
+    if build_amplicol:
+        result.append("--build-amplicol")
+    if arguments.compare_helicity_sums:
+        result.append("--compare-helicity-sums")
+    return tuple(result)
+
+
+def _shard_cli_arguments(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    shard: Shard,
+    final_multiplicity: int | None = None,
+    *,
+    modes: Sequence[str] | None = None,
+    fill_modes: Sequence[str] | None = None,
+) -> tuple[str, ...]:
+    return _study_cli_arguments(
+        arguments,
+        study_root=_shard_study_root(run_directory, shard, final_multiplicity),
+        run_id=_shard_run_id(shard, final_multiplicity),
+        families=(shard.family,),
+        modes=(
+            tuple(modes)
+            if modes is not None
+            else _shard_modes(arguments, run_directory, shard)
+        ),
+        resume=True,
+        build_amplicol=arguments.build_amplicol and shard.name == "ddbar-amplicol",
+        fill_multiplicities=(
+            _requested_multiplicities(arguments, run_directory)
+            if final_multiplicity is None
+            else (final_multiplicity,)
+        ),
+        fill_modes=fill_modes,
+    )
+
+
+def _master_arguments(
+    arguments: argparse.Namespace, run_directory: Path
+) -> argparse.Namespace:
+    modes = tuple(
+        dict.fromkeys(
+            mode
+            for family in FAMILIES
+            for mode in publication.FAMILY_MODES[family]
+        )
+    )
+    original = arguments.multiplicities
+    arguments.multiplicities = list(_universe(arguments))
+    try:
+        raw_arguments = _study_cli_arguments(
+            arguments,
+            study_root=_master_study_root(run_directory),
+            run_id="campaign",
+            families=FAMILIES,
+            modes=modes,
+            resume=True,
+        )
+    finally:
+        arguments.multiplicities = original
+    namespace = study._parser().parse_args(raw_arguments)
+    study._validate_arguments(namespace)
+    return namespace
+
+
+def _shard_arguments(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    shard: Shard,
+    final_multiplicity: int | None = None,
+    *,
+    modes: Sequence[str] | None = None,
+) -> argparse.Namespace:
+    namespace = study._parser().parse_args(
+        _shard_cli_arguments(
+            arguments,
+            run_directory,
+            shard,
+            final_multiplicity,
+            modes=modes,
+        )
+    )
+    study._validate_arguments(namespace)
+    return namespace
+
+
+def _work_owned_modes(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> tuple[str, ...]:
+    counted = _counted_owned_modes(arguments, run_directory, work.shard)
+    if work.owned_mode not in counted:
+        return ()
+    return (work.owned_mode,)
+
+
+def _work_modes(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> tuple[str, ...]:
+    selected = set(_work_owned_modes(arguments, run_directory, work))
+    if selected and work.shard.dependency is not None:
+        _, dependency_mode = work.shard.dependency
+        selected.add(dependency_mode)
+    return tuple(mode for mode in work.shard.modes if mode in selected)
+
+
+def _work_cli_arguments(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> tuple[str, ...]:
+    return _study_cli_arguments(
+        arguments,
+        study_root=_work_study_root(run_directory, work),
+        run_id=_work_run_id(work),
+        families=(work.shard.family,),
+        modes=_work_modes(arguments, run_directory, work),
+        resume=True,
+        build_amplicol=arguments.build_amplicol and work.shard.name == "ddbar-amplicol",
+        fill_multiplicities=(work.final_multiplicity,),
+        fill_modes=_work_owned_modes(arguments, run_directory, work),
+    )
+
+
+def _work_arguments(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> argparse.Namespace:
+    namespace = study._parser().parse_args(
+        _work_cli_arguments(arguments, run_directory, work)
+    )
+    study._validate_arguments(namespace)
+    return namespace
+
+
+def _validate_y_range(
+    values: Sequence[float] | None,
+    *,
+    option: str,
+    positive: bool,
+) -> None:
+    if values is None:
+        return
+    if len(values) != 2:
+        raise ProfilingError(f"{option} requires exactly two values")
+    low, high = (float(values[0]), float(values[1]))
+    if not math.isfinite(low) or not math.isfinite(high):
+        raise ProfilingError(f"{option} values must be finite")
+    if high <= low:
+        raise ProfilingError(f"{option} requires MIN < MAX")
+    if positive and low <= 0.0:
+        raise ProfilingError(f"{option} must be positive for a logarithmic y-axis")
+
+
+def _validate_render_line_filter(values: Sequence[str] | None, *, option: str) -> None:
+    if values is None:
+        return
+    selected = tuple(str(value) for value in values)
+    if len(set(selected)) != len(selected):
+        raise ProfilingError(f"{option} must not contain duplicates")
+    invalid = sorted(set(selected) - set(RENDER_LINE_CHOICES))
+    if invalid:
+        raise ProfilingError(f"{option} has unknown line id(s): {', '.join(invalid)}")
+
+
+def _validate_arguments(arguments: argparse.Namespace) -> None:
+    _normalize_executables(arguments)
+    if arguments.refresh:
+        _reject_refresh_symlinks(_configured_run_path(arguments))
+    targeted_rerun = arguments.retry or arguments.overwrite
+    if targeted_rerun and arguments.refresh:
+        raise ProfilingError(
+            "--retry/--overwrite are targeted alternatives to --refresh"
+        )
+    if targeted_rerun and (arguments.render or arguments.status):
+        raise ProfilingError(
+            "--retry/--overwrite are valid only for profiling runs"
+        )
+    if arguments.candidate_cores > arguments.cores:
+        raise ProfilingError("--candidate-cores cannot exceed --cores")
+    if arguments.dpi < 72 or arguments.dpi > 600:
+        raise ProfilingError("--dpi must be between 72 and 600")
+    _validate_y_range(arguments.main_y_range, option="--main-y-range", positive=True)
+    _validate_y_range(
+        arguments.ratio_y_range,
+        option="--ratio-y-range",
+        positive=arguments.ratio_y_scale == "log",
+    )
+    _validate_render_line_filter(
+        arguments.main_include_lines,
+        option="--main-include-lines",
+    )
+    _validate_render_line_filter(
+        arguments.main_veto_lines,
+        option="--main-veto-lines",
+    )
+    _validate_render_line_filter(
+        arguments.ratio_include_lines,
+        option="--ratio-include-lines",
+    )
+    _validate_render_line_filter(
+        arguments.ratio_veto_lines,
+        option="--ratio-veto-lines",
+    )
+    if arguments.target_seconds < 0.25:
+        raise ProfilingError("--target-seconds must be at least 0.25")
+    if not 2 <= arguments.otf_max_multiplicity <= 9:
+        raise ProfilingError("--otf-max-multiplicity must be in the range 2..9")
+    if (
+        not arguments.multiplicities
+        or min(arguments.multiplicities) < 2
+        or max(arguments.multiplicities) > 9
+    ):
+        raise ProfilingError(
+            "--multiplicities values must be integers in the final-PDF scan range 2..9"
+        )
+    if len(set(arguments.multiplicities)) != len(arguments.multiplicities):
+        raise ProfilingError("--multiplicities must not contain duplicates")
+    if len(set(arguments.lines)) != len(arguments.lines):
+        raise ProfilingError("--lines must not contain duplicates")
+    if len(set(arguments.families)) != len(arguments.families):
+        raise ProfilingError("--families must not contain duplicates")
+    # The authoritative parser owns run-id, n-range, mode, and resource checks.
+    _master_arguments(arguments, _run_directory(arguments))
+    if arguments.campaign_report is not None and not arguments.render:
+        raise ProfilingError("--campaign-report is valid only with --render")
+    if arguments.recola_results is not None:
+        if not arguments.render:
+            raise ProfilingError("--recola-results is valid only with --render")
+        if not _absolute(arguments.recola_results).is_file():
+            raise ProfilingError(
+                f"Recola results JSON is missing: {_absolute(arguments.recola_results)}"
+            )
+    render_only_options = {
+        "--main-y-range": arguments.main_y_range is not None,
+        "--ratio-y-range": arguments.ratio_y_range is not None,
+        "--ratio-y-scale": arguments.ratio_y_scale != "log",
+        "--main-include-lines": arguments.main_include_lines is not None,
+        "--main-veto-lines": arguments.main_veto_lines is not None,
+        "--ratio-include-lines": arguments.ratio_include_lines is not None,
+        "--ratio-veto-lines": arguments.ratio_veto_lines is not None,
+    }
+    for option, configured in render_only_options.items():
+        if configured and not arguments.render:
+            raise ProfilingError(f"{option} is valid only with --render")
+    run_directory = _run_directory(arguments)
+    if (
+        not arguments.render
+        and not _requested_shards(arguments, run_directory)
+        and not _madgraph_requested(arguments, run_directory)
+    ):
+        raise ProfilingError(
+            "the selected --families and --lines leave no applicable profiling work"
+        )
+
+
+def _normalize_executables(arguments: argparse.Namespace) -> None:
+    for attribute in ("python", "cxx", "fc", "make"):
+        raw = str(getattr(arguments, attribute))
+        path = Path(raw).expanduser()
+        if path.parent != Path("."):
+            # Preserve virtual-environment launcher symlinks: resolving the
+            # final component would silently bypass the venv's site-packages.
+            setattr(arguments, attribute, str(Path(os.path.abspath(path))))
+            continue
+        located = shutil.which(raw)
+        if located is not None:
+            setattr(arguments, attribute, str(Path(os.path.abspath(located))))
+
+
+def _identity(arguments: argparse.Namespace, run_directory: Path) -> dict[str, Any]:
+    return {
+        "run_directory": str(run_directory),
+        "measurement_host": madgraph.measurement_host_identity(),
+        "scan": {
+            "multiplicity_universe": list(_universe(arguments)),
+            "helicity_workload": _helicity_workload(arguments),
+            "families": list(FAMILIES),
+            "modes": {
+                family: list(publication.FAMILY_MODES[family])
+                for family in FAMILIES
+            },
+            "batch_size": arguments.batch_size,
+            "fft_enabled": True,
+            "target_seconds": arguments.target_seconds,
+        },
+        "resources": {
+            "candidate_optimization_cores": arguments.candidate_cores,
+            "per_cell_memory_limit_gib": arguments.memory_limit_gib,
+            "per_cell_generation_timeout_seconds": arguments.time_limit_seconds,
+            "per_cell_runtime_timeout_seconds": arguments.time_limit_seconds,
+        },
+        "tools": {
+            "python": str(arguments.python),
+            "cxx": str(arguments.cxx),
+            "fc": str(arguments.fc),
+            "amplicol_root": str(_absolute(arguments.amplicol_root)),
+            "reference_fft_root": str(_absolute(arguments.reference_fft_root)),
+            "madgraph_root": (
+                str(_absolute(arguments.madgraph_root))
+                if arguments.madgraph_root is not None
+                else None
+            ),
+        },
+    }
+
+
+def _child_command(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    work: ShardWork,
+) -> tuple[str, ...]:
+    return (
+        str(arguments.python),
+        str(STUDY_TOOL),
+        *_work_cli_arguments(arguments, run_directory, work),
+    )
+
+
+def _measurement_multiplicities(
+    arguments: argparse.Namespace, run_directory: Path, shard: Shard
+) -> tuple[int, ...]:
+    owned_modes = _counted_owned_modes(arguments, run_directory, shard)
+    return _measurement_multiplicities_for_modes(
+        arguments, run_directory, shard, owned_modes
+    )
+
+
+def _measurement_multiplicities_for_modes(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    shard: Shard,
+    owned_modes: Sequence[str],
+) -> tuple[int, ...]:
+    _ = run_directory
+    if not owned_modes:
+        return ()
+    return tuple(
+        final_multiplicity
+        for final_multiplicity in _selection(arguments)
+        if not all(
+            study.otf_protocol_scope_cell(
+                family=shard.family,
+                mode=study.MODE_BY_KEY[mode],
+                final_multiplicity=final_multiplicity,
+                sum_helicities=arguments.compare_helicity_sums,
+                maximum_multiplicity=arguments.otf_max_multiplicity,
+            )
+            is not None
+            for mode in owned_modes
+        )
+    )
+
+
+def _work_measurement_multiplicities(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> tuple[int, ...]:
+    return _measurement_multiplicities_for_modes(
+        arguments,
+        run_directory,
+        work.shard,
+        _work_owned_modes(arguments, run_directory, work),
+    )
+
+
+def _render_commands(
+    arguments: argparse.Namespace,
+    *,
+    source_report: Path,
+    staged_report: Path,
+    staged_plots: Path,
+    staged_pdf: Path,
+    strict: bool,
+    madgraph_overlay: Path | None,
+) -> tuple[tuple[str, ...], ...]:
+    commands: list[tuple[str, ...]] = []
+    plot_report = source_report
+    if strict:
+        if madgraph_overlay is None:
+            raise ProfilingError(
+                "strict terminal rendering requires an authenticated MadGraph overlay"
+            )
+        commands.append(
+            (
+                str(arguments.python),
+                str(MERGE_TOOL),
+                "--campaign-report",
+                str(source_report),
+                "--madgraph-overlay",
+                str(_absolute(madgraph_overlay)),
+                "--output",
+                str(staged_report),
+            )
+        )
+        plot_report = staged_report
+    plot_command = [
+        str(arguments.python),
+        str(PLOT_TOOL),
+        str(plot_report),
+        str(staged_plots),
+        "--dpi",
+        str(arguments.dpi),
+    ]
+    if arguments.recola_results is not None:
+        plot_command.extend(
+            ("--recola-results", str(_absolute(arguments.recola_results)))
+        )
+    if arguments.main_y_range is not None:
+        plot_command.extend(
+            ("--main-y-range", *(str(value) for value in arguments.main_y_range))
+        )
+    if arguments.ratio_y_range is not None:
+        plot_command.extend(
+            ("--ratio-y-range", *(str(value) for value in arguments.ratio_y_range))
+        )
+    if arguments.ratio_y_scale != "log":
+        plot_command.extend(("--ratio-y-scale", arguments.ratio_y_scale))
+    for option, values in (
+        ("--main-include-lines", arguments.main_include_lines),
+        ("--main-veto-lines", arguments.main_veto_lines),
+        ("--ratio-include-lines", arguments.ratio_include_lines),
+        ("--ratio-veto-lines", arguments.ratio_veto_lines),
+    ):
+        if values is not None:
+            plot_command.extend((option, *(str(value) for value in values)))
+    commands.extend(
+        (
+            tuple(plot_command),
+            (
+                str(arguments.python),
+                str(PDF_TOOL),
+                "--campaign-report",
+                str(plot_report),
+                "--plot-directory",
+                str(staged_plots),
+                "--output",
+                str(staged_pdf),
+            ),
+        )
+    )
+    return tuple(commands)
+
+
+def dry_run_plan(arguments: argparse.Namespace) -> dict[str, Any]:
+    run_directory = _run_directory(arguments)
+    example_stage = run_directory / "render" / ".staging-EXAMPLE"
+    pdf_filename = _pdf_filename(arguments)
+    requested_shard_names = {
+        shard.name for shard in _scheduled_shards(arguments, run_directory)
+    }
+    works_by_shard: dict[str, list[ShardWork]] = {shard.name: [] for shard in SHARDS}
+    for phase_number in _scheduled_phase_numbers(arguments, run_directory):
+        for work in _phase_work_items(arguments, run_directory, phase_number):
+            works_by_shard[work.shard.name].append(work)
+    requested_lines = _requested_line_groups(arguments, run_directory)
+    requested_families = _family_selection(arguments)
+    madgraph_requested = _madgraph_requested(arguments, run_directory)
+    shard_jobs = {
+        shard.name: [
+            {
+                "n": work.final_multiplicity,
+                "mode": work.owned_mode,
+                "study_root": str(_work_study_root(run_directory, work)),
+                "report": str(_work_report_path(run_directory, work)),
+                "argv": list(_child_command(arguments, run_directory, work)),
+                "shell_command": shlex.join(
+                    _child_command(arguments, run_directory, work)
+                ),
+            }
+            for work in works_by_shard[shard.name]
+        ]
+        for shard in SHARDS
+    }
+    commands = {
+        shard.name: {
+            "scheduled": shard.name in requested_shard_names,
+            "phase": shard.phase,
+            "family": shard.family,
+            "modes": list(_shard_modes(arguments, run_directory, shard)),
+            "owned_modes": list(_counted_owned_modes(arguments, run_directory, shard)),
+            "dependency": list(shard.dependency) if shard.dependency else None,
+            "claimed_cores": (arguments.candidate_cores if shard.candidate else 1),
+            "measurement_multiplicities": list(
+                _measurement_multiplicities(arguments, run_directory, shard)
+            ),
+            "protocol_skip_multiplicities": sorted(
+                set(_selection(arguments))
+                - set(_measurement_multiplicities(arguments, run_directory, shard))
+            ),
+            "study_root": str(_shard_study_root(run_directory, shard)),
+            "report": str(_shard_report_path(run_directory, shard)),
+            "jobs": shard_jobs[shard.name],
+            "argv": (
+                shard_jobs[shard.name][0]["argv"] if shard_jobs[shard.name] else None
+            ),
+            "shell_command": (
+                shard_jobs[shard.name][0]["shell_command"]
+                if shard_jobs[shard.name]
+                else None
+            ),
+        }
+        for shard in SHARDS
+    }
+    strict = (
+        set(requested_lines) == set(LINE_GROUPS)
+        and requested_families == FAMILIES
+        and _publication_profile(arguments)
+    )
+    render_commands = _render_commands(
+        arguments,
+        source_report=_master_report_path(run_directory),
+        staged_report=example_stage / "report.json",
+        staged_plots=example_stage / "plots",
+        staged_pdf=example_stage / pdf_filename,
+        strict=strict,
+        madgraph_overlay=_madgraph_overlay_path(run_directory),
+    )
+    return {
+        "kind": KIND,
+        "schema_version": SCHEMA_VERSION,
+        "helicity_workload": _helicity_workload(arguments),
+        "batch_size": arguments.batch_size,
+        "requested_fill_multiplicities": list(_selection(arguments)),
+        "requested_process_families": list(requested_families),
+        "requested_line_groups": list(requested_lines),
+        "identity": _identity(arguments, run_directory),
+        "scheduler": {
+            "total_core_budget": arguments.cores,
+            "candidate_cores_per_active_candidate_work_item": arguments.candidate_cores,
+            "baseline_cores_per_active_work_item": 1,
+            "parallelism": "weighted dependency-aware shard-multiplicity workers",
+        },
+        "shards": commands,
+        "madgraph": {
+            "phase": 4,
+            "applicable": madgraph_requested,
+            "helicity_workload": _helicity_workload(arguments),
+            "process_families": list(requested_families),
+            "measurement_multiplicities": [
+                n
+                for n in _requested_multiplicities(arguments, run_directory)
+                if any(
+                    madgraph.protocol_measures_multiplicity(family, n)
+                    for family in requested_families
+                )
+            ],
+            "protocol_scope_multiplicities": [
+                n
+                for n in _requested_multiplicities(arguments, run_directory)
+                if not any(
+                    madgraph.protocol_measures_multiplicity(family, n)
+                    for family in requested_families
+                )
+            ],
+            "measurement_multiplicities_by_family": {
+                family: [
+                    n
+                    for n in _requested_multiplicities(arguments, run_directory)
+                    if madgraph.protocol_measures_multiplicity(family, n)
+                ]
+                for family in requested_families
+            },
+            "protocol_scope_multiplicities_by_family": {
+                family: [
+                    n
+                    for n in _requested_multiplicities(arguments, run_directory)
+                    if not madgraph.protocol_measures_multiplicity(family, n)
+                ]
+                for family in requested_families
+            },
+            "dependency": (
+                "completed pyAmpliCol source cells for the requested MadGraph fill"
+                if madgraph_requested
+                else None
+            ),
+            "not_applicable_reason": (
+                None if madgraph_requested else "madgraph line group not selected"
+            ),
+            "report": str(_madgraph_overlay_path(run_directory)),
+            "argv": (
+                list(_madgraph_command(arguments, run_directory))
+                if madgraph_requested and arguments.madgraph_root is not None
+                else None
+            ),
+            "shell_command": (
+                shlex.join(_madgraph_command(arguments, run_directory))
+                if madgraph_requested and arguments.madgraph_root is not None
+                else None
+            ),
+        },
+        "outputs": {
+            "manifest": str(_manifest_path(run_directory)),
+            "master_report": str(_master_report_path(run_directory)),
+            "render_pointer": str(run_directory / "render" / "current"),
+            "final_pdf": str(run_directory / "render" / "current" / pdf_filename),
+            "final_json": str(
+                run_directory / "render" / "current" / _json_filename(arguments)
+            ),
+            "canonical_pdf": (
+                str(_canonical_pdf_path(arguments))
+                if _canonical_publication_enabled(arguments)
+                else None
+            ),
+            "canonical_json": (
+                str(_canonical_pdf_path(arguments).with_suffix(".json"))
+                if _canonical_publication_enabled(arguments)
+                else None
+            ),
+        },
+        "terminal_render": {
+            "strict_publication_profile": strict,
+            "commands": [list(command) for command in render_commands],
+            "shell_commands": [shlex.join(command) for command in render_commands],
+        },
+        "prerequisites": [
+            "Python environment containing pyAmpliCol, progressbar2, colorama, "
+            "matplotlib, and reportlab",
+            f"C++ compiler: {arguments.cxx}",
+            f"Fortran compiler: {arguments.fc}",
+            f"make: {arguments.make}",
+            f"legacy AmpliCol checkout: {_absolute(arguments.amplicol_root)}",
+            f"Reference FFT checkout: {_absolute(arguments.reference_fft_root)}",
+            (
+                f"MadGraph installation: {_absolute(arguments.madgraph_root)}"
+                if madgraph_requested and arguments.madgraph_root is not None
+                else (
+                    "MadGraph installation: REQUIRED (--madgraph-root)"
+                    if madgraph_requested
+                    else "MadGraph installation: not required by selected lines"
+                )
+            ),
+        ],
+    }
+
+
+def _canonical_json(value: object) -> bytes:
+    return (json.dumps(value, indent=2, sort_keys=True, allow_nan=False) + "\n").encode(
+        "utf-8"
+    )
+
+
+def _write_json_atomic(path: Path, value: Mapping[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    raw = _canonical_json(value)
+    if path.is_file() and path.read_bytes() == raw:
+        return
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    temporary.write_bytes(raw)
+    temporary.replace(path)
+
+
+def _load_json(path: Path, *, context: str) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_bytes())
+    except (OSError, json.JSONDecodeError) as error:
+        raise ProfilingError(f"cannot read {context} {path}: {error}") from error
+    if not isinstance(value, dict):
+        raise ProfilingError(f"{context} {path} must be a JSON object")
+    return value
+
+
+def _identity_diff(stored: object, requested: object, prefix: str = "") -> list[str]:
+    if isinstance(stored, Mapping) and isinstance(requested, Mapping):
+        differences: list[str] = []
+        for key in sorted(set(stored) | set(requested)):
+            child = f"{prefix}.{key}" if prefix else str(key)
+            if key not in stored:
+                differences.append(f"{child}: missing -> {requested[key]!r}")
+            elif key not in requested:
+                differences.append(f"{child}: {stored[key]!r} -> missing")
+            else:
+                differences.extend(_identity_diff(stored[key], requested[key], child))
+        return differences
+    return [] if stored == requested else [f"{prefix}: {stored!r} -> {requested!r}"]
+
+
+def _identity_path_value(identity: object, path: str) -> object:
+    value = identity
+    for key in path.split("."):
+        if not isinstance(value, Mapping):
+            return None
+        value = value.get(key)
+    return value
+
+
+def _identity_difference_path(difference: str) -> str:
+    return difference.split(":", 1)[0]
+
+
+def _mutable_resource_identity_update_allowed(
+    stored: object, requested: object, differences: Sequence[str]
+) -> bool:
+    changed_paths = {
+        _identity_difference_path(difference) for difference in differences
+    }
+    if not changed_paths or not changed_paths <= MUTABLE_RESOURCE_IDENTITY_PATHS:
+        return False
+    for path in changed_paths:
+        old = _identity_path_value(stored, path)
+        new = _identity_path_value(requested, path)
+        if (
+            not isinstance(old, int | float)
+            or isinstance(old, bool)
+            or not isinstance(new, int | float)
+            or isinstance(new, bool)
+            or float(new) <= 0
+        ):
+            return False
+    return True
+
+
+def _immutable_identity_differences(differences: Sequence[str]) -> list[str]:
+    return [
+        difference
+        for difference in differences
+        if _identity_difference_path(difference) not in MUTABLE_RESOURCE_IDENTITY_PATHS
+    ]
+
+
+def _create_or_resume_manifest(
+    arguments: argparse.Namespace, run_directory: Path
+) -> dict[str, Any]:
+    path = _manifest_path(run_directory)
+    requested_identity = _identity(arguments, run_directory)
+    if path.is_file():
+        manifest = _load_json(path, context="profiling manifest")
+        if (
+            manifest.get("kind") != KIND
+            or manifest.get("schema_version") != SCHEMA_VERSION
+        ):
+            raise ProfilingError("profiling manifest has the wrong schema")
+        differences = _identity_diff(manifest.get("identity"), requested_identity)
+        identity_updated = False
+        if differences:
+            if _mutable_resource_identity_update_allowed(
+                manifest.get("identity"), requested_identity, differences
+            ):
+                manifest["identity"] = requested_identity
+                identity_updated = True
+            else:
+                preview = "\n  ".join(differences[:12])
+                raise ProfilingError(
+                    "resume measurement identity differs from the manifest:\n  "
+                    + preview
+                )
+        selected = list(_selection(arguments))
+        selected_lines = list(_line_selection(arguments))
+        selected_families = list(_family_selection(arguments))
+        prior = _manifest_int_history(
+            manifest, "fill_history_multiplicities", "requested_multiplicities"
+        )
+        history = sorted(set(prior) | set(selected))
+        prior_lines = _manifest_line_history(manifest)
+        line_history = [
+            line
+            for line in LINE_CHOICES
+            if line in set(prior_lines) | set(selected_lines)
+        ]
+        prior_families = _manifest_family_history(manifest)
+        family_history = [
+            family
+            for family in FAMILIES
+            if family in set(prior_families) | set(selected_families)
+        ]
+        updates = {
+            "requested_multiplicities": selected,
+            "requested_families": selected_families,
+            "requested_line_groups": selected_lines,
+            "active_multiplicities": selected,
+            "active_families": selected_families,
+            "active_line_groups": selected_lines,
+            "fill_history_multiplicities": history,
+            "process_family_history": family_history,
+            "line_group_history": line_history,
+        }
+        if identity_updated or any(
+            manifest.get(key) != value for key, value in updates.items()
+        ):
+            manifest.update(updates)
+            _write_json_atomic(path, manifest)
+        return manifest
+    selected = list(_selection(arguments))
+    selected_lines = list(_line_selection(arguments))
+    selected_families = list(_family_selection(arguments))
+    manifest = {
+        "kind": KIND,
+        "schema_version": SCHEMA_VERSION,
+        "identity": requested_identity,
+        "initial_scheduler_core_budget": arguments.cores,
+        "requested_multiplicities": selected,
+        "requested_families": selected_families,
+        "requested_line_groups": selected_lines,
+        "active_multiplicities": selected,
+        "active_families": selected_families,
+        "active_line_groups": selected_lines,
+        "fill_history_multiplicities": selected,
+        "process_family_history": selected_families,
+        "line_group_history": selected_lines,
+    }
+    _write_json_atomic(path, manifest)
+    return manifest
+
+
+def _expected_shard_policy(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    shard: Shard,
+    final_multiplicity: int | None = None,
+    *,
+    modes: Sequence[str] | None = None,
+) -> dict[str, object]:
+    return study.dry_run_plan(
+        _shard_arguments(
+            arguments,
+            run_directory,
+            shard,
+            final_multiplicity,
+            modes=modes,
+        )
+    )
+
+
+def _pyamplicol_contractions_for_modes(
+    modes: Sequence[str],
+) -> dict[str, list[str]]:
+    selected: dict[str, list[str]] = {}
+    for mode in modes:
+        if mode == "recurrence-direct":
+            selected.setdefault("recurrence", []).append("direct")
+        elif mode == "recurrence-fft":
+            selected.setdefault("recurrence", []).append("symmetric-group-fft")
+        elif mode == "otf-direct":
+            selected.setdefault("on-the-fly", []).append("direct")
+        elif mode == "otf-fft":
+            selected.setdefault("on-the-fly", []).append("symmetric-group-fft")
+    return selected
+
+
+def _policy_with_expected_mode_subset(
+    policy: object, *, family: str, modes: Sequence[str]
+) -> object:
+    if not isinstance(policy, Mapping):
+        return policy
+    normalized = copy.deepcopy(dict(policy))
+    normalized.pop("run_root", None)
+    process_families = normalized.get("process_families")
+    if isinstance(process_families, dict):
+        family_policy = process_families.get(family)
+        if isinstance(family_policy, dict):
+            actual_modes = family_policy.get("modes")
+            if (
+                isinstance(actual_modes, list)
+                and set(modes).issubset(set(actual_modes))
+            ):
+                family_policy["modes"] = list(modes)
+
+    expected_contractions = _pyamplicol_contractions_for_modes(modes)
+    contractions = normalized.get("selected_pyamplicol_color_contractions")
+    if expected_contractions:
+        if isinstance(contractions, Mapping) and all(
+            set(values).issubset(set(contractions.get(key, ())))
+            for key, values in expected_contractions.items()
+        ):
+            normalized["selected_pyamplicol_color_contractions"] = (
+                expected_contractions
+            )
+    else:
+        normalized.pop("selected_pyamplicol_color_contractions", None)
+    measurement = normalized.get("measurement")
+    if isinstance(measurement, dict):
+        for key in (
+            "cell_admission_limits",
+            *study.MUTABLE_RESUME_MEASUREMENT_POLICY_KEYS,
+            "generation_timeout_seconds",
+            "memory_policy",
+            "memory_watchdog_gib",
+            "requested_memory_ceiling_gib",
+            "runtime_timeout_seconds",
+        ):
+            measurement.pop(key, None)
+    return normalized
+
+
+def _shard_policy_matches_requested_modes(
+    stored: object,
+    expected: object,
+    *,
+    family: str,
+    modes: Sequence[str],
+) -> bool:
+    return _policy_with_expected_mode_subset(
+        stored, family=family, modes=modes
+    ) == _policy_with_expected_mode_subset(expected, family=family, modes=modes)
+
+
+def _validate_shard_report(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    shard: Shard,
+    report: Mapping[str, Any],
+    *,
+    context: str,
+    final_multiplicity: int | None = None,
+    modes: Sequence[str] | None = None,
+    allow_partial_modes: bool = False,
+) -> None:
+    expected_modes = (
+        tuple(modes)
+        if modes is not None
+        else _shard_modes(arguments, run_directory, shard)
+    )
+    cells = report.get("cells")
+    if not isinstance(cells, Mapping):
+        raise ProfilingError(f"{context} has no cells")
+    family_cells = cells.get(shard.family)
+    if not isinstance(family_cells, Mapping):
+        raise ProfilingError(f"{context} mode set differs")
+    present_modes = tuple(mode for mode in expected_modes if mode in family_cells)
+    if not present_modes or (
+        not allow_partial_modes and set(present_modes) != set(expected_modes)
+    ):
+        raise ProfilingError(f"{context} mode set differs")
+    if report.get("kind") != study.KIND or report.get(
+        "schema_version"
+    ) != study.SCHEMA_VERSION or not _shard_policy_matches_requested_modes(
+        report.get("policy"),
+        _expected_shard_policy(
+            arguments,
+            run_directory,
+            shard,
+            final_multiplicity,
+            modes=present_modes,
+        ),
+        family=shard.family,
+        modes=present_modes,
+    ):
+        raise ProfilingError(f"{context} policy/schema differs")
+
+
+def _load_single_shard_report(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    shard: Shard,
+    path: Path,
+    *,
+    final_multiplicity: int | None = None,
+    modes: Sequence[str] | None = None,
+    allow_partial_modes: bool = False,
+) -> dict[str, Any]:
+    report = _load_json(path, context=f"{shard.name} shard report")
+    _validate_shard_report(
+        arguments,
+        run_directory,
+        shard,
+        report,
+        context=f"{shard.name} shard report",
+        final_multiplicity=final_multiplicity,
+        modes=modes,
+        allow_partial_modes=allow_partial_modes,
+    )
+    study.normalize_loaded_failure_cells(report, path.parent)
+    return report
+
+
+def _mode_set_validation_error(error: ProfilingError) -> bool:
+    return str(error).endswith(" mode set differs")
+
+
+def _load_compatible_shard_report(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    shard: Shard,
+    path: Path,
+    *,
+    final_multiplicity: int | None = None,
+    modes: Sequence[str] | None = None,
+    allow_partial_modes: bool = False,
+) -> dict[str, Any] | None:
+    try:
+        return _load_single_shard_report(
+            arguments,
+            run_directory,
+            shard,
+            path,
+            final_multiplicity=final_multiplicity,
+            modes=modes,
+            allow_partial_modes=allow_partial_modes,
+        )
+    except ProfilingError as error:
+        if allow_partial_modes:
+            return None
+        if not _mode_set_validation_error(error):
+            raise
+    try:
+        return _load_single_shard_report(
+            arguments,
+            run_directory,
+            shard,
+            path,
+            final_multiplicity=final_multiplicity,
+            modes=modes,
+            allow_partial_modes=True,
+        )
+    except ProfilingError as error:
+        if _mode_set_validation_error(error):
+            return None
+        raise
+
+
+def _merge_cell_record(
+    target_curve: dict[str, object],
+    raw_n: str,
+    cell: Mapping[str, Any],
+) -> None:
+    existing = target_curve.get(raw_n)
+    if (
+        isinstance(existing, Mapping)
+        and existing.get("status") == "measured"
+        and cell.get("status") != "measured"
+    ):
+        return
+    target_curve[raw_n] = copy.deepcopy(dict(cell))
+
+
+def _obsolete_otf_protocol_scope_cell(
+    arguments: argparse.Namespace,
+    *,
+    mode: str,
+    raw_n: str,
+    cell: Mapping[str, Any],
+) -> bool:
+    return (
+        raw_n.isdigit()
+        and mode in study.MODE_BY_KEY
+        and study.MODE_BY_KEY[mode].execution_mode == "on-the-fly"
+        and int(raw_n) <= arguments.otf_max_multiplicity
+        and cell.get("failure_category") == "publication-protocol-scope"
+    )
+
+
+def _cell_terminal_for_orchestrator(cell: object) -> bool:
+    return (
+        isinstance(cell, Mapping)
+        and cell.get("status") in ORCHESTRATOR_TERMINAL_CELL_STATUSES
+    )
+
+
+def _selected_cells_terminal_for_orchestrator(
+    report: Mapping[str, Any],
+    *,
+    family: str,
+    modes: Sequence[str],
+    multiplicities: Sequence[int],
+) -> bool:
+    cells = report.get("cells")
+    if not isinstance(cells, Mapping):
+        return False
+    family_cells = cells.get(family)
+    if not isinstance(family_cells, Mapping):
+        return False
+    for mode in modes:
+        curve = family_cells.get(mode)
+        if not isinstance(curve, Mapping):
+            return False
+        for final_multiplicity in multiplicities:
+            if not _cell_terminal_for_orchestrator(
+                curve.get(str(final_multiplicity))
+            ):
+                return False
+    return True
+
+
+def _report_modes_for_shard(report: Mapping[str, Any], shard: Shard) -> tuple[str, ...]:
+    cells = report.get("cells")
+    if not isinstance(cells, Mapping):
+        return ()
+    family_cells = cells.get(shard.family)
+    if not isinstance(family_cells, Mapping):
+        return ()
+    return tuple(mode for mode in shard.modes if mode in family_cells)
+
+
+def _remove_selected_cells_from_report(
+    shard: Shard,
+    report: dict[str, Any],
+    *,
+    modes: Sequence[str],
+    multiplicities: Sequence[int],
+    statuses: frozenset[str] | None,
+) -> set[tuple[str, str, int]]:
+    removed: set[tuple[str, str, int]] = set()
+    cells = report.get("cells")
+    if not isinstance(cells, Mapping):
+        return removed
+    family_cells = cells.get(shard.family)
+    if not isinstance(family_cells, Mapping):
+        return removed
+    for mode in modes:
+        curve = family_cells.get(mode)
+        if not isinstance(curve, dict):
+            continue
+        for final_multiplicity in multiplicities:
+            raw_n = str(final_multiplicity)
+            cell = curve.get(raw_n)
+            if (
+                isinstance(cell, Mapping)
+                and (statuses is None or cell.get("status") in statuses)
+            ):
+                del curve[raw_n]
+                removed.add((shard.family, mode, final_multiplicity))
+    return removed
+
+
+def _rewrite_selected_report(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    shard: Shard,
+    path: Path,
+    *,
+    final_multiplicity: int | None,
+    modes: Sequence[str],
+    multiplicities: Sequence[int],
+    statuses: frozenset[str] | None,
+    context: str,
+) -> set[tuple[str, str, int]]:
+    if not path.is_file():
+        return set()
+    report = _load_json(path, context=context)
+    report_modes = _report_modes_for_shard(report, shard)
+    selected_modes = tuple(mode for mode in modes if mode in report_modes)
+    if not selected_modes:
+        return set()
+    _validate_shard_report(
+        arguments,
+        run_directory,
+        shard,
+        report,
+        context=context,
+        final_multiplicity=final_multiplicity,
+        modes=report_modes,
+        allow_partial_modes=True,
+    )
+    study.normalize_loaded_failure_cells(report, path.parent)
+    removed = _remove_selected_cells_from_report(
+        shard,
+        report,
+        modes=selected_modes,
+        multiplicities=multiplicities,
+        statuses=statuses,
+    )
+    if not removed:
+        return set()
+    rewritten = study.compose_report(
+        _shard_arguments(
+            arguments,
+            run_directory,
+            shard,
+            final_multiplicity,
+            modes=report_modes,
+        ),
+        report["cells"],
+    )
+    _write_json_atomic(path, rewritten)
+    return removed
+
+
+def _rewrite_retry_report(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    shard: Shard,
+    path: Path,
+    *,
+    final_multiplicity: int | None,
+    multiplicities: Sequence[int],
+) -> set[tuple[str, str, int]]:
+    return _rewrite_selected_report(
+        arguments,
+        run_directory,
+        shard,
+        path,
+        final_multiplicity=final_multiplicity,
+        modes=_counted_owned_modes(arguments, run_directory, shard),
+        multiplicities=multiplicities,
+        statuses=RETRYABLE_CELL_STATUSES,
+        context=f"{shard.name} retry report",
+    )
+
+
+def _apply_retry_invalidation(
+    arguments: argparse.Namespace, run_directory: Path
+) -> int:
+    if not arguments.retry:
+        return 0
+    requested = _requested_multiplicities(arguments, run_directory)
+    removed: set[tuple[str, str, int]] = set()
+    for shard in _scheduled_shards(arguments, run_directory):
+        removed.update(
+            _rewrite_retry_report(
+                arguments,
+                run_directory,
+                shard,
+                _shard_report_path(run_directory, shard),
+                final_multiplicity=None,
+                multiplicities=requested,
+            )
+        )
+        for final_multiplicity in requested:
+            removed.update(
+                _rewrite_retry_report(
+                    arguments,
+                    run_directory,
+                    shard,
+                    _shard_report_path(run_directory, shard, final_multiplicity),
+                    final_multiplicity=final_multiplicity,
+                    multiplicities=(final_multiplicity,),
+                )
+            )
+            for mode in _counted_owned_modes(arguments, run_directory, shard):
+                removed.update(
+                    _rewrite_retry_report(
+                        arguments,
+                        run_directory,
+                        shard,
+                        _work_report_path(
+                            run_directory,
+                            ShardWork(shard, final_multiplicity, mode),
+                        ),
+                        final_multiplicity=final_multiplicity,
+                        multiplicities=(final_multiplicity,),
+                    )
+                )
+    return len(removed)
+
+
+def _reject_overwrite_symlinks(path: Path) -> None:
+    absolute = Path(os.path.abspath(path.expanduser()))
+    for candidate in (absolute, *absolute.parents):
+        if candidate.is_symlink():
+            raise ProfilingError(
+                f"refusing --overwrite through symlinked path component: {candidate}"
+            )
+
+
+def _prepare_overwrite_work(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    work: ShardWork,
+) -> int:
+    """Invalidate one selected cell immediately before launching its worker."""
+
+    if not arguments.overwrite:
+        return 0
+    cell_root = _work_cell_root(run_directory, work)
+    _reject_overwrite_symlinks(cell_root)
+    backup: Path | None = None
+    if cell_root.exists():
+        backup = cell_root.with_name(
+            f".{cell_root.name}.overwrite-{uuid.uuid4().hex}"
+        )
+        cell_root.replace(backup)
+
+    removed: set[tuple[str, str, int]] = set()
+    try:
+        report_paths: dict[Path, int | None] = {
+            _shard_report_path(run_directory, work.shard): None
+        }
+        shard_root = run_directory / "shards" / work.shard.name
+        for pattern in (
+            f"cells/n{work.final_multiplicity}/study/runs/*/report.json",
+            f"mode-cells/*/n{work.final_multiplicity}/study/runs/*/report.json",
+        ):
+            report_paths.update(
+                (path, work.final_multiplicity) for path in shard_root.glob(pattern)
+            )
+        for path, final_multiplicity in sorted(
+            report_paths.items(), key=lambda item: str(item[0])
+        ):
+            removed.update(
+                _rewrite_selected_report(
+                    arguments,
+                    run_directory,
+                    work.shard,
+                    path,
+                    final_multiplicity=final_multiplicity,
+                    modes=(work.owned_mode,),
+                    multiplicities=(work.final_multiplicity,),
+                    statuses=None,
+                    context=(
+                        f"{work.shard.name} overwrite report for "
+                        f"{work.shard.family}/{work.owned_mode}/"
+                        f"n{work.final_multiplicity}"
+                    ),
+                )
+            )
+    except BaseException:
+        if backup is not None and not cell_root.exists():
+            backup.replace(cell_root)
+        raise
+    if backup is not None:
+        shutil.rmtree(backup)
+    return len(removed)
+
+
+def _resource_frontier_failure_at(
+    cell: Mapping[str, Any], fallback_multiplicity: int
+) -> int | None:
+    if cell.get("censors_higher_multiplicities") is not True or cell.get(
+        "status"
+    ) not in {"failed", "skipped"}:
+        return None
+    failed_at = cell.get("failed_at_n")
+    if isinstance(failed_at, int) and not isinstance(failed_at, bool):
+        return failed_at
+    return fallback_multiplicity
+
+
+def _mode_resource_frontier(
+    curve: Mapping[str, Any], final_multiplicity: int
+) -> int | None:
+    frontier: int | None = None
+    for raw_n, cell in curve.items():
+        if not str(raw_n).isdigit() or not isinstance(cell, Mapping):
+            continue
+        failed_at = _resource_frontier_failure_at(cell, int(raw_n))
+        if failed_at is not None and failed_at < final_multiplicity:
+            frontier = min(frontier if frontier is not None else failed_at, failed_at)
+    return frontier
+
+
+def _resource_frontier_skip_cell(
+    arguments: argparse.Namespace,
+    *,
+    family: str,
+    mode: str,
+    final_multiplicity: int,
+    failed_at: int,
+) -> dict[str, object]:
+    reason = f"curve censored after resource limit at n={failed_at}"
+    return study._cell_base(
+        family,
+        study.MODE_BY_KEY[mode],
+        final_multiplicity,
+        sum_helicities=arguments.compare_helicity_sums,
+    ) | {
+        "status": "skipped",
+        "failure_reason": reason,
+        "failed_at_n": failed_at,
+        "censors_higher_multiplicities": True,
+    }
+
+
+def _apply_resource_frontier_censoring(
+    arguments: argparse.Namespace,
+    report: dict[str, Any],
+    shard: Shard,
+    *,
+    modes: Sequence[str],
+    multiplicities: Sequence[int],
+) -> bool:
+    cells = report["cells"]
+    assert isinstance(cells, dict)
+    family_cells = cells[shard.family]
+    assert isinstance(family_cells, dict)
+    changed = False
+    for mode in modes:
+        curve = family_cells[mode]
+        assert isinstance(curve, dict)
+        for final_multiplicity in multiplicities:
+            frontier = _mode_resource_frontier(curve, final_multiplicity)
+            if frontier is None:
+                continue
+            raw_n = str(final_multiplicity)
+            existing = curve.get(raw_n)
+            if isinstance(existing, Mapping):
+                if (
+                    existing.get("status") in {"failed", "skipped"}
+                    and existing.get("censors_higher_multiplicities") is True
+                ):
+                    continue
+                if existing.get("status") == "measured":
+                    continue
+            curve[raw_n] = _resource_frontier_skip_cell(
+                arguments,
+                family=shard.family,
+                mode=mode,
+                final_multiplicity=final_multiplicity,
+                failed_at=frontier,
+            )
+            changed = True
+    return changed
+
+
+def _dependency_skip_cell(
+    arguments: argparse.Namespace,
+    *,
+    shard: Shard,
+    mode: str,
+    final_multiplicity: int,
+    dependency_name: str,
+    dependency_mode: str,
+    dependency_cell: Mapping[str, Any],
+) -> dict[str, object]:
+    failed_at = _resource_frontier_failure_at(dependency_cell, final_multiplicity)
+    dependency: dict[str, object] = {
+        "shard": dependency_name,
+        "family": shard.family,
+        "mode": dependency_mode,
+        "n": final_multiplicity,
+        "status": str(dependency_cell.get("status")),
+    }
+    if failed_at is not None:
+        dependency["resource_failure_at_n"] = failed_at
+    return study._cell_base(
+        shard.family,
+        study.MODE_BY_KEY[mode],
+        final_multiplicity,
+        sum_helicities=arguments.compare_helicity_sums,
+    ) | {
+        "status": "skipped",
+        "failure_category": "dependency-unavailable",
+        "failure_reason": (
+            f"{dependency_mode} baseline/input unavailable because "
+            f"{dependency_name} recorded "
+            f"{dependency_cell.get('status')} at n={final_multiplicity}"
+        ),
+        "censors_higher_multiplicities": False,
+        "dependency": dependency,
+    }
+
+
+def _apply_dependency_skips(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    report: dict[str, Any],
+    shard: Shard,
+    *,
+    multiplicities: Sequence[int],
+) -> bool:
+    if shard.dependency is None:
+        return False
+    dependency_name, dependency_mode = shard.dependency
+    dependency_shard = SHARD_BY_NAME[dependency_name]
+    source = _load_shard_report(arguments, run_directory, dependency_shard)
+    if source is None:
+        return False
+    source_cells = source["cells"]
+    target_cells = report["cells"]
+    assert isinstance(source_cells, Mapping)
+    assert isinstance(target_cells, dict)
+    source_family = source_cells[shard.family]
+    target_family = target_cells[shard.family]
+    assert isinstance(source_family, Mapping)
+    assert isinstance(target_family, dict)
+    dependency_curve = source_family[dependency_mode]
+    assert isinstance(dependency_curve, Mapping)
+    changed = False
+    for final_multiplicity in multiplicities:
+        if not _selected_cells_terminal_for_orchestrator(
+            source,
+            family=shard.family,
+            modes=(dependency_mode,),
+            multiplicities=(final_multiplicity,),
+        ):
+            continue
+        dependency_cell = dependency_curve.get(str(final_multiplicity))
+        if (
+            not isinstance(dependency_cell, Mapping)
+            or dependency_cell.get("status") == "measured"
+        ):
+            continue
+        for mode in _shard_owned_modes(arguments, run_directory, shard):
+            curve = target_family[mode]
+            assert isinstance(curve, dict)
+            if str(final_multiplicity) in curve:
+                continue
+            curve[str(final_multiplicity)] = _dependency_skip_cell(
+                arguments,
+                shard=shard,
+                mode=mode,
+                final_multiplicity=final_multiplicity,
+                dependency_name=dependency_name,
+                dependency_mode=dependency_mode,
+                dependency_cell=dependency_cell,
+            )
+            changed = True
+    return changed
+
+
+def _load_shard_report(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    shard: Shard,
+    *,
+    required: bool = False,
+    modes: Sequence[str] | None = None,
+    allow_partial_modes: bool = False,
+) -> dict[str, Any] | None:
+    shard_modes = (
+        tuple(modes)
+        if modes is not None
+        else _shard_modes(arguments, run_directory, shard)
+    )
+    sources: list[tuple[dict[str, Any], int | None]] = []
+    aggregate_path = _shard_report_path(run_directory, shard)
+    if aggregate_path.is_file():
+        aggregate = _load_compatible_shard_report(
+            arguments,
+            run_directory,
+            shard,
+            aggregate_path,
+            final_multiplicity=None,
+            modes=shard_modes,
+            allow_partial_modes=allow_partial_modes,
+        )
+        if aggregate is not None:
+            sources.append((aggregate, None))
+    cell_reports: dict[Path, int] = {}
+    for path in (run_directory / "shards" / shard.name / "cells").glob(
+        "n*/study/runs/*/report.json"
+    ):
+        raw_n = path.parent.parent.parent.parent.name
+        if raw_n.startswith("n") and raw_n[1:].isdigit():
+            cell_reports[path] = int(raw_n[1:])
+    for path in (run_directory / "shards" / shard.name / "mode-cells").glob(
+        "*/n*/study/runs/*/report.json"
+    ):
+        raw_n = path.parent.parent.parent.parent.name
+        if raw_n.startswith("n") and raw_n[1:].isdigit():
+            cell_reports[path] = int(raw_n[1:])
+    for final_multiplicity in _requested_multiplicities(arguments, run_directory):
+        legacy_path = _shard_report_path(run_directory, shard, final_multiplicity)
+        if legacy_path.is_file():
+            cell_reports[legacy_path] = final_multiplicity
+        for mode in shard_modes:
+            if mode not in shard.owned_modes:
+                continue
+            work = ShardWork(shard, final_multiplicity, mode)
+            work_path = _work_report_path(run_directory, work)
+            if work_path.is_file():
+                cell_reports[work_path] = final_multiplicity
+    for path, final_multiplicity in sorted(
+        cell_reports.items(), key=lambda item: (item[1], str(item[0]))
+    ):
+        if not path.is_file():
+            continue
+        report = _load_compatible_shard_report(
+            arguments,
+            run_directory,
+            shard,
+            path,
+            final_multiplicity=final_multiplicity,
+            modes=shard_modes,
+            allow_partial_modes=allow_partial_modes,
+        )
+        if report is not None:
+            sources.append((report, final_multiplicity))
+    if not sources:
+        if required:
+            raise ProfilingError(f"required shard report is missing: {aggregate_path}")
+        return None
+    curve_sources: dict[str, dict[str, dict[str, object]]] = {
+        shard.family: {mode: {} for mode in shard_modes}
+    }
+    target_family = curve_sources[shard.family]
+    for source, source_multiplicity in sources:
+        cells = source["cells"]
+        assert isinstance(cells, Mapping)
+        family_cells = cells[shard.family]
+        assert isinstance(family_cells, Mapping)
+        for mode in shard_modes:
+            source_curve = family_cells.get(mode)
+            if not isinstance(source_curve, Mapping):
+                continue
+            target_curve = target_family[mode]
+            if source_multiplicity is None:
+                for raw_n, cell in source_curve.items():
+                    if (
+                        isinstance(raw_n, str)
+                        and raw_n.isdigit()
+                        and isinstance(cell, Mapping)
+                        and not _obsolete_otf_protocol_scope_cell(
+                            arguments,
+                            mode=mode,
+                            raw_n=raw_n,
+                            cell=cell,
+                        )
+                    ):
+                        _merge_cell_record(target_curve, raw_n, cell)
+                continue
+            cell = source_curve.get(str(source_multiplicity))
+            if isinstance(cell, Mapping) and not _obsolete_otf_protocol_scope_cell(
+                arguments,
+                mode=mode,
+                raw_n=str(source_multiplicity),
+                cell=cell,
+            ):
+                _merge_cell_record(
+                    target_curve, str(source_multiplicity), cell
+                )
+    report = study.compose_report(
+        _shard_arguments(arguments, run_directory, shard, modes=shard_modes),
+        curve_sources,
+    )
+    _apply_resource_frontier_censoring(
+        arguments,
+        report,
+        shard,
+        modes=shard_modes,
+        multiplicities=_requested_multiplicities(arguments, run_directory),
+    )
+    return study.compose_report(
+        _shard_arguments(arguments, run_directory, shard, modes=shard_modes),
+        report["cells"],
+    )
+
+
+def _publish_shard_report(
+    arguments: argparse.Namespace, run_directory: Path, shard: Shard
+) -> dict[str, Any] | None:
+    report = _load_shard_report(arguments, run_directory, shard)
+    if report is not None:
+        _write_json_atomic(_shard_report_path(run_directory, shard), report)
+    return report
+
+
+def _selected_shard_complete(
+    arguments: argparse.Namespace,
+    shard: Shard,
+    report: Mapping[str, Any] | None,
+    *,
+    multiplicities: Sequence[int] | None = None,
+) -> bool:
+    return (
+        report is not None
+        and not str(report.get("status", "")).startswith("stopped")
+        and _selected_cells_terminal_for_orchestrator(
+            report,
+            family=shard.family,
+            modes=_counted_owned_modes(arguments, _run_directory(arguments), shard),
+            multiplicities=(
+                _selection(arguments)
+                if multiplicities is None
+                else tuple(multiplicities)
+            ),
+        )
+    )
+
+
+def _selected_work_complete(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    work: ShardWork,
+    report: Mapping[str, Any] | None,
+) -> bool:
+    return report is not None and _selected_cells_terminal_for_orchestrator(
+        report,
+        family=work.shard.family,
+        modes=_work_owned_modes(arguments, run_directory, work),
+        multiplicities=(work.final_multiplicity,),
+    )
+
+
+def _phase_work_items(
+    arguments: argparse.Namespace, run_directory: Path, phase_number: int
+) -> tuple[ShardWork, ...]:
+    works = [
+        ShardWork(shard, final_multiplicity, owned_mode)
+        for final_multiplicity in _requested_multiplicities(arguments, run_directory)
+        for shard in _scheduled_shards(arguments, run_directory)
+        if shard.phase == phase_number
+        for owned_mode in _counted_owned_modes(arguments, run_directory, shard)
+        if final_multiplicity
+        in _work_measurement_multiplicities(
+            arguments,
+            run_directory,
+            ShardWork(shard, final_multiplicity, owned_mode),
+        )
+    ]
+    return tuple(
+        sorted(
+            works,
+            key=lambda work: (
+                work.final_multiplicity,
+                0 if work.shard.name == "gg-amplicol" else 1,
+                work.shard.name,
+            ),
+        )
+    )
+
+
+def _scheduled_phase_numbers(
+    arguments: argparse.Namespace, run_directory: Path
+) -> tuple[int, ...]:
+    return tuple(
+        sorted(
+            {
+                shard.phase
+                for shard in _scheduled_shards(arguments, run_directory)
+                if _counted_owned_modes(arguments, run_directory, shard)
+            }
+        )
+    )
+
+
+def _work_dependency_ready(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> bool:
+    if work.shard.dependency is None:
+        return True
+    dependency_name, dependency_mode = work.shard.dependency
+    dependency_shard = SHARD_BY_NAME[dependency_name]
+    source = _load_shard_report(arguments, run_directory, dependency_shard)
+    return source is not None and _selected_cells_terminal_for_orchestrator(
+        source,
+        family=work.shard.family,
+        modes=(dependency_mode,),
+        multiplicities=(work.final_multiplicity,),
+    )
+
+
+def _empty_cell_report(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> dict[str, Any]:
+    return study.compose_report(_work_arguments(arguments, run_directory, work), {})
+
+
+def _project_work_report(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    work: ShardWork,
+    report: Mapping[str, Any],
+) -> dict[str, Any]:
+    cells = report.get("cells")
+    family_cells = cells.get(work.shard.family) if isinstance(cells, Mapping) else None
+    projected = {
+        work.shard.family: {
+            mode: copy.deepcopy(dict(curve))
+            for mode in _work_modes(arguments, run_directory, work)
+            if isinstance(family_cells, Mapping)
+            and isinstance((curve := family_cells.get(mode)), Mapping)
+        }
+    }
+    return study.compose_report(
+        _work_arguments(arguments, run_directory, work), projected
+    )
+
+
+def _load_cell_report(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> dict[str, Any]:
+    path = _work_report_path(run_directory, work)
+    if not path.is_file():
+        legacy_path = _shard_report_path(
+            run_directory, work.shard, work.final_multiplicity
+        )
+        if legacy_path.is_file() and legacy_path != path:
+            return _project_work_report(
+                arguments,
+                run_directory,
+                work,
+                _load_single_shard_report(
+                    arguments,
+                    run_directory,
+                    work.shard,
+                    legacy_path,
+                    final_multiplicity=work.final_multiplicity,
+                    modes=_work_modes(arguments, run_directory, work),
+                ),
+            )
+        return _empty_cell_report(arguments, run_directory, work)
+    return _project_work_report(
+        arguments,
+        run_directory,
+        work,
+        _load_single_shard_report(
+            arguments,
+            run_directory,
+            work.shard,
+            path,
+            final_multiplicity=work.final_multiplicity,
+            modes=_work_modes(arguments, run_directory, work),
+        ),
+    )
+
+
+def _seed_cell_inputs(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> None:
+    report = _load_cell_report(arguments, run_directory, work)
+    target_cells = report["cells"]
+    assert isinstance(target_cells, dict)
+    target_family = target_cells[work.shard.family]
+    assert isinstance(target_family, dict)
+
+    existing = _load_shard_report(arguments, run_directory, work.shard)
+    if existing is not None:
+        existing_cells = existing["cells"]
+        assert isinstance(existing_cells, Mapping)
+        existing_family = existing_cells[work.shard.family]
+        assert isinstance(existing_family, Mapping)
+        for mode in _work_owned_modes(arguments, run_directory, work):
+            source_curve = existing_family[mode]
+            target_curve = target_family[mode]
+            assert isinstance(source_curve, Mapping)
+            assert isinstance(target_curve, dict)
+            target_curve.update(copy.deepcopy(dict(source_curve)))
+
+    if work.shard.dependency is not None:
+        dependency_name, dependency_mode = work.shard.dependency
+        dependency_shard = SHARD_BY_NAME[dependency_name]
+        source = _load_shard_report(
+            arguments, run_directory, dependency_shard, required=True
+        )
+        if not _selected_cells_terminal_for_orchestrator(
+            source,
+            family=work.shard.family,
+            modes=(dependency_mode,),
+            multiplicities=(work.final_multiplicity,),
+        ):
+            raise ProfilingError(
+                f"dependency {dependency_name} has not completed "
+                f"{work.shard.family}/{dependency_mode}/n{work.final_multiplicity}"
+            )
+        source_cells = source["cells"]
+        assert isinstance(source_cells, Mapping)
+        source_family = source_cells[work.shard.family]
+        assert isinstance(source_family, Mapping)
+        dependency_curve = source_family[dependency_mode]
+        target_curve = target_family[dependency_mode]
+        assert isinstance(dependency_curve, Mapping)
+        assert isinstance(target_curve, dict)
+        dependency_cell = dependency_curve.get(str(work.final_multiplicity))
+        if isinstance(dependency_cell, Mapping):
+            target_curve[str(work.final_multiplicity)] = copy.deepcopy(
+                dict(dependency_cell)
+            )
+
+    report["status"] = "running"
+    _write_json_atomic(_work_report_path(run_directory, work), report)
+
+
+def _seed_protocol_scope(
+    arguments: argparse.Namespace, run_directory: Path, shard: Shard
+) -> None:
+    owned_modes = _shard_owned_modes(arguments, run_directory, shard)
+    if not any(mode.startswith("otf-") for mode in owned_modes):
+        return
+    target = _shard_report_path(run_directory, shard)
+    namespace = _shard_arguments(arguments, run_directory, shard)
+    report = _load_shard_report(
+        arguments, run_directory, shard
+    ) or study.compose_report(namespace, {})
+    if study.apply_protocol_scope_cells(
+        report,
+        family=shard.family,
+        modes=owned_modes,
+        multiplicities=_requested_multiplicities(arguments, run_directory),
+        maximum_multiplicity=arguments.otf_max_multiplicity,
+    ):
+        report["status"] = "running"
+        _write_json_atomic(target, report)
+
+
+def _publication_profile(arguments: argparse.Namespace) -> bool:
+    run_directory = _run_directory(arguments)
+    namespace = _master_arguments(
+        _manifest_backed_arguments(arguments, run_directory), run_directory
+    )
+    return publication.campaign_policy_is_publication_profile(
+        study.compose_report(namespace, {})
+    )
+
+
+def _report_publication_profile(report: Mapping[str, Any]) -> bool:
+    return report.get(
+        "status"
+    ) in TERMINAL_STATUSES and publication.campaign_policy_is_publication_profile(
+        report
+    )
+
+
+def _compose_master(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    *,
+    active: Sequence[str] = (),
+    halt_reason: str | None = None,
+) -> dict[str, Any]:
+    compose_arguments = _composition_arguments(arguments, run_directory)
+    namespace = _master_arguments(compose_arguments, run_directory)
+    reports: dict[str, dict[str, Any] | None] = {}
+    shard_status: dict[str, str] = {}
+    for shard in SHARDS:
+        shard_modes = _shard_modes(compose_arguments, run_directory, shard)
+        shard_report = (
+            _load_shard_report(
+                compose_arguments,
+                run_directory,
+                shard,
+                modes=shard_modes,
+                allow_partial_modes=True,
+            )
+            if shard_modes
+            else None
+        )
+        reports[shard.name] = shard_report
+        shard_status[shard.name] = (
+            str(shard_report.get("status")) if shard_report is not None else "pending"
+        )
+    curve_sources: dict[str, dict[str, Mapping[str, object]]] = {
+        "gg": {},
+        "ddbar": {},
+    }
+    for family in FAMILIES:
+        for mode in publication.FAMILY_MODES[family]:
+            owner = SHARD_BY_NAME[MODE_OWNER[(family, mode)]]
+            owner_report = reports[owner.name]
+            if owner_report is None:
+                continue
+            owner_cells = owner_report["cells"]
+            assert isinstance(owner_cells, Mapping)
+            owner_family = owner_cells[family]
+            assert isinstance(owner_family, Mapping)
+            if mode not in owner_family:
+                continue
+            curve = owner_family[mode]
+            assert isinstance(curve, Mapping)
+            curve_sources[family][mode] = curve
+
+    report = study.compose_report(
+        namespace,
+        curve_sources,
+        halt_reason=halt_reason,
+    )
+    report["measurement_host"] = madgraph.measurement_host_identity()
+    policy = report["policy"]
+    assert isinstance(policy, dict)
+    measurement = policy["measurement"]
+    assert isinstance(measurement, dict)
+    measurement["schedule_order"] = (
+        "dependency-ordered-parallel-shard-multiplicity-workers"
+    )
+    plot = policy.setdefault("plot", {})
+    assert isinstance(plot, dict)
+    if arguments.compare_helicity_sums:
+        plot["notes"] = [
+            "Complete physical-helicity-summed matrix-element workload; "
+            "MadGraph standalone uses generated SMATRIX with USERHEL=-1; "
+            "warmed GOODHEL pruning remains enabled."
+        ]
+    elif not _publication_profile(compose_arguments):
+        plot["notes"] = [
+            "Cluster scan with configured per-cell resource caps; this is not the "
+            "canonical 30-GiB/one-hour publication profile."
+        ]
+    report["profiling_orchestration"] = {
+        "kind": KIND,
+        "schema_version": SCHEMA_VERSION,
+        "shard_status": shard_status,
+        "active_shards": list(active),
+        "total_core_budget": arguments.cores,
+        "candidate_optimization_cores": arguments.candidate_cores,
+    }
+    return report
+
+
+def _publish_master(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    *,
+    active: Sequence[str] = (),
+    halt_reason: str | None = None,
+) -> dict[str, Any]:
+    report = _compose_master(
+        arguments, run_directory, active=active, halt_reason=halt_reason
+    )
+    _write_json_atomic(_master_report_path(run_directory), report)
+    return report
+
+
+def _completed_cells(report: Mapping[str, Any]) -> int:
+    cells = report.get("cells")
+    if not isinstance(cells, Mapping):
+        return 0
+    return sum(
+        len(mode_cells)
+        for family_cells in cells.values()
+        if isinstance(family_cells, Mapping)
+        for mode_cells in family_cells.values()
+        if isinstance(mode_cells, Mapping)
+    )
+
+
+def _selected_cell_identities(
+    arguments: argparse.Namespace,
+    *,
+    multiplicities: Sequence[int] | None = None,
+) -> tuple[CellIdentity, ...]:
+    run_directory = _run_directory(arguments)
+    requested = (
+        _selection(arguments) if multiplicities is None else tuple(multiplicities)
+    )
+    return tuple(
+        (shard.family, mode, final_multiplicity)
+        for shard in _scheduled_shards(arguments, run_directory)
+        for mode in _counted_owned_modes(arguments, run_directory, shard)
+        for final_multiplicity in requested
+    )
+
+
+def _cell_identity_terminal(
+    report: Mapping[str, Any], identity: CellIdentity
+) -> bool:
+    family, mode, final_multiplicity = identity
+    return _selected_cells_terminal_for_orchestrator(
+        report,
+        family=family,
+        modes=(mode,),
+        multiplicities=(final_multiplicity,),
+    )
+
+
+def _selected_completed_cells(
+    arguments: argparse.Namespace,
+    report: Mapping[str, Any],
+    *,
+    multiplicities: Sequence[int] | None = None,
+    ignored_cells: set[CellIdentity] | frozenset[CellIdentity] = frozenset(),
+) -> int:
+    return sum(
+        identity not in ignored_cells and _cell_identity_terminal(report, identity)
+        for identity in _selected_cell_identities(
+            arguments, multiplicities=multiplicities
+        )
+    )
+
+
+def _selected_master_complete(
+    arguments: argparse.Namespace,
+    report: Mapping[str, Any],
+    *,
+    multiplicities: Sequence[int] | None = None,
+    ignored_cells: set[CellIdentity] | frozenset[CellIdentity] = frozenset(),
+) -> bool:
+    return not str(report.get("status", "")).startswith("stopped") and all(
+        identity not in ignored_cells and _cell_identity_terminal(report, identity)
+        for identity in _selected_cell_identities(
+            arguments, multiplicities=multiplicities
+        )
+    )
+
+
+def _selected_pending_cells(
+    arguments: argparse.Namespace,
+    report: Mapping[str, Any],
+    *,
+    multiplicities: Sequence[int] | None = None,
+    ignored_cells: set[CellIdentity] | frozenset[CellIdentity] = frozenset(),
+) -> int:
+    return sum(
+        identity in ignored_cells or not _cell_identity_terminal(report, identity)
+        for identity in _selected_cell_identities(
+            arguments, multiplicities=multiplicities
+        )
+    )
+
+
+def _run_checked(
+    command: Sequence[str], *, environment: Mapping[str, str] | None = None
+) -> None:
+    completed = subprocess.run(
+        tuple(command),
+        check=False,
+        env=environment,
+        stdout=subprocess.PIPE,
+        text=True,
+    )
+    if completed.returncode != 0:
+        stdout = completed.stdout.strip()
+        detail = (
+            f"command failed with status {completed.returncode}: {shlex.join(command)}"
+        )
+        if stdout:
+            detail = f"{detail}\nstdout:\n{stdout}"
+        raise ProfilingError(detail)
+
+
+def _source_snapshot(path: Path) -> tuple[bytes, dict[str, Any], str]:
+    try:
+        raw = path.read_bytes()
+        report = json.loads(raw)
+    except (OSError, json.JSONDecodeError) as error:
+        raise ProfilingError(
+            f"cannot freeze campaign report {path}: {error}"
+        ) from error
+    if not isinstance(report, dict):
+        raise ProfilingError("campaign report must be a JSON object")
+    return raw, report, hashlib.sha256(raw).hexdigest()
+
+
+def _fallback_render_candidates() -> tuple[Path, ...]:
+    """Return legacy/current campaign reports eligible for implicit rendering."""
+
+    study_root = CANONICAL_RESULTS_ROOT / "fft-scaling-study"
+    profiling_root = CANONICAL_RESULTS_ROOT / "fft-profiling" / "runs"
+    candidates = {
+        *study_root.joinpath("data").glob("campaign-report*.json"),
+        *study_root.joinpath("raw", "runs").glob("*/report.json"),
+        *profiling_root.glob("*/master/runs/*/report.json"),
+        *profiling_root.glob("*/composites/*/report.json"),
+        *profiling_root.glob("*/source-snapshots/*/report.json"),
+    }
+    # A render generation is an immutable report snapshot.  Discover the few
+    # structural nesting depths produced by the orchestrator and isolated
+    # extension tooling without recursively walking generated artifacts.
+    for depth in range(1, 4):
+        prefix = "/".join("*" for _ in range(depth))
+        candidates.update(
+            profiling_root.glob(f"{prefix}/render/generations/*/report.json")
+        )
+    return tuple(sorted((_absolute(path) for path in candidates), key=str))
+
+
+def _fallback_madgraph_candidates() -> tuple[Path, ...]:
+    """Return discoverable terminal and partial MadGraph overlays."""
+
+    study_root = CANONICAL_RESULTS_ROOT / "fft-scaling-study"
+    profiling_root = CANONICAL_RESULTS_ROOT / "fft-profiling" / "runs"
+    candidates = {
+        *study_root.joinpath("data").glob("*madgraph*overlay*.json"),
+        *profiling_root.glob("*/overlay.json"),
+        *profiling_root.glob("*/overlay.progress.json"),
+        *profiling_root.glob("*/madgraph/overlay.json"),
+        *profiling_root.glob("*/madgraph/overlay.progress.json"),
+    }
+    return tuple(sorted((_absolute(path) for path in candidates), key=str))
+
+
+def _render_inventory(
+    report: Mapping[str, Any], *, requested: set[int]
+) -> tuple[int, int, int, int, int]:
+    measured: set[tuple[str, str, int]] = set()
+    recorded: set[tuple[str, str, int]] = set()
+    madgraph_measured: set[tuple[str, str, int]] = set()
+    for section in ("cells", "runtime_series"):
+        families = report.get(section)
+        if not isinstance(families, Mapping):
+            continue
+        for family, family_cells in families.items():
+            if not isinstance(family_cells, Mapping):
+                continue
+            for mode, mode_cells in family_cells.items():
+                if not isinstance(mode_cells, Mapping):
+                    continue
+                for raw_n, cell in mode_cells.items():
+                    if not str(raw_n).isdigit() or not isinstance(cell, Mapping):
+                        continue
+                    identity = (str(family), str(mode), int(raw_n))
+                    recorded.add(identity)
+                    if cell.get("status") == "measured":
+                        measured.add(identity)
+                        if mode == "madgraph-standalone":
+                            madgraph_measured.add(identity)
+    return (
+        len({identity for identity in measured if identity[2] in requested}),
+        len({identity for identity in madgraph_measured if identity[2] in requested}),
+        len({identity for identity in recorded if identity[2] in requested}),
+        len(measured),
+        len(recorded),
+    )
+
+
+def _render_candidate_score(
+    arguments: argparse.Namespace,
+    report: Mapping[str, Any],
+    *,
+    source: Path,
+    overlay: Path | None,
+) -> tuple[int, int, int, int, int, int, int, int, str, str]:
+    requested = set(_selection(arguments))
+    policy = report.get("policy")
+    multiplicities = (
+        policy.get("final_state_multiplicities")
+        if isinstance(policy, Mapping)
+        else None
+    )
+    observed = (
+        {int(value) for value in multiplicities}
+        if isinstance(multiplicities, list)
+        and all(
+            isinstance(value, int) and not isinstance(value, bool)
+            for value in multiplicities
+        )
+        else set()
+    )
+    measured, madgraph_measured, recorded, measured_all, recorded_all = (
+        _render_inventory(report, requested=requested)
+    )
+    overlay_kind = ""
+    if overlay is not None:
+        with contextlib.suppress(ProfilingError):
+            overlay_kind = str(
+                _load_json(overlay, context="MadGraph render overlay").get("kind", "")
+            )
+    return (
+        measured,
+        madgraph_measured,
+        measured_all,
+        recorded,
+        recorded_all,
+        int(requested <= observed),
+        len(observed & requested),
+        int(overlay_kind == madgraph.KIND),
+        str(source),
+        str(overlay or ""),
+    )
+
+
+def _compatible_render_report(
+    arguments: argparse.Namespace, path: Path
+) -> dict[str, Any] | None:
+    try:
+        _raw, report, _digest = _source_snapshot(path)
+        if (
+            report.get("kind") != study.KIND
+            or report.get("schema_version") != study.SCHEMA_VERSION
+            or not isinstance(report.get("cells"), Mapping)
+        ):
+            return None
+        _validate_render_workload(arguments, report)
+        if report.get("measurement_host") is None and _has_madgraph_series(report):
+            _append_plot_note(report, LEGACY_MADGRAPH_NOTE)
+    except (OSError, ProfilingError, TypeError, ValueError):
+        return None
+    return report
+
+
+def _implicit_render_selection(
+    arguments: argparse.Namespace, run_directory: Path
+) -> RenderSelection:
+    primary = _master_report_path(run_directory)
+    candidates = {primary, *_fallback_render_candidates()}
+    overlays = _fallback_madgraph_candidates()
+    ranked: list[
+        tuple[
+            tuple[int, int, int, int, int, int, int, int, str, str],
+            RenderSelection,
+        ]
+    ] = []
+    for source in sorted(candidates, key=str):
+        if not source.is_file():
+            continue
+        report = _compatible_render_report(arguments, source)
+        if report is None:
+            continue
+        variants: list[tuple[dict[str, Any], Path | None]] = [(report, None)]
+        for overlay in overlays:
+            enriched = copy.deepcopy(report)
+            try:
+                _attach_partial_overlay(enriched, overlay)
+            except ProfilingError:
+                continue
+            variants.append((enriched, overlay))
+        for candidate_report, overlay in variants:
+            ranked.append(
+                (
+                    _render_candidate_score(
+                        arguments,
+                        candidate_report,
+                        source=source,
+                        overlay=overlay,
+                    ),
+                    RenderSelection(source=source, overlay=overlay),
+                )
+            )
+    if not ranked:
+        return RenderSelection(source=primary, overlay=None)
+    return max(ranked, key=lambda item: item[0])[1]
+
+
+def _fallback_render_source(arguments: argparse.Namespace) -> Path | None:
+    """Choose the richest compatible report for an otherwise bare render."""
+
+    primary = _master_report_path(_run_directory(arguments))
+    selection = _implicit_render_selection(arguments, _run_directory(arguments))
+    return selection.source if selection.source != primary else None
+
+
+def _render_source(arguments: argparse.Namespace, run_directory: Path) -> Path:
+    if arguments.campaign_report is not None:
+        return _absolute(arguments.campaign_report)
+    primary = _master_report_path(run_directory)
+    if arguments.output is not None:
+        return primary
+    return _implicit_render_selection(arguments, run_directory).source
+
+
+def _validate_render_workload(
+    arguments: argparse.Namespace, report: Mapping[str, Any]
+) -> None:
+    try:
+        observed = study.report_helicity_workload(report)
+    except study.StudyError as error:
+        raise ProfilingError(f"invalid campaign helicity workload: {error}") from error
+    expected = _helicity_workload(arguments)
+    if observed != expected:
+        raise ProfilingError(
+            f"requested {expected!r} helicity workload but the frozen campaign "
+            f"report declares {observed!r}; select the matching "
+            "--compare-helicity-sums setting"
+        )
+
+
+def _has_madgraph_series(report: Mapping[str, Any]) -> bool:
+    for section in ("cells", "runtime_series"):
+        families = report.get(section)
+        if not isinstance(families, Mapping):
+            continue
+        if any(
+            isinstance(family, Mapping) and "madgraph-standalone" in family
+            for family in families.values()
+        ):
+            return True
+    return False
+
+
+def _append_plot_note(report: dict[str, Any], note: str) -> None:
+    policy = report.get("policy")
+    if not isinstance(policy, dict):
+        return
+    plot = policy.setdefault("plot", {})
+    if not isinstance(plot, dict):
+        return
+    raw_notes = plot.get("notes")
+    notes = [str(item) for item in raw_notes] if isinstance(raw_notes, list) else []
+    if note not in notes:
+        notes.append(note)
+    plot["notes"] = notes
+
+
+def _legacy_madgraph_host_matches_current(value: object) -> bool:
+    legacy_keys = {"system", "machine", "python"}
+    if not isinstance(value, Mapping) or set(value) != legacy_keys:
+        return False
+    current = madgraph.measurement_host_identity()
+    return all(value[key] == current[key] for key in legacy_keys)
+
+
+def _attach_partial_overlay(report: dict[str, Any], path: Path) -> None:
+    raw, payload, digest = _source_snapshot(path)
+    report.setdefault("summary", {})
+    try:
+        if payload.get("kind") == madgraph.PROGRESS_KIND:
+            with tempfile.TemporaryDirectory(prefix="fft-mg-progress-") as directory:
+                frozen_progress = Path(directory) / "progress.json"
+                frozen_progress.write_bytes(raw)
+                payload = madgraph.load_runtime_progress(frozen_progress)
+        raw_campaign_host = report.get("measurement_host")
+        if raw_campaign_host is not None:
+            campaign_host = madgraph.validate_measurement_host(
+                raw_campaign_host, context="campaign measurement_host"
+            )
+            overlay_host = madgraph.validate_measurement_host(
+                payload.get("host"), context="MadGraph overlay host"
+            )
+            if campaign_host != overlay_host:
+                raise madgraph.SelectedMadGraphError(
+                    "campaign and MadGraph overlay use different measurement hosts"
+                )
+        elif not _legacy_madgraph_host_matches_current(payload.get("host")):
+            raise madgraph.SelectedMadGraphError(
+                "legacy MadGraph overlay does not match this workstation"
+            )
+        selected.apply_runtime_series_source(
+            report,
+            selected.SourceReport(
+                key=(
+                    "madgraph-progress"
+                    if payload.get("kind") == madgraph.PROGRESS_KIND
+                    else "madgraph-overlay"
+                ),
+                path=path,
+                sha256=digest,
+                payload=payload,
+            ),
+        )
+        if raw_campaign_host is None:
+            _append_plot_note(report, LEGACY_MADGRAPH_NOTE)
+        overlay_policy = payload.get("policy")
+        if (
+            isinstance(overlay_policy, Mapping)
+            and madgraph._declared_helicity_workload(overlay_policy) == "sum"
+        ):
+            report_policy = report.get("policy")
+            if isinstance(report_policy, dict):
+                plot = report_policy.setdefault("plot", {})
+                if isinstance(plot, dict):
+                    raw_notes = plot.get("notes")
+                    notes = (
+                        [str(note) for note in raw_notes]
+                        if isinstance(raw_notes, list)
+                        else []
+                    )
+                    notes = [
+                        note
+                        for note in notes
+                        if not (
+                            "MadGraph" in note
+                            and (
+                                "omitted" in note.lower()
+                                or "fixed-helicity" in note.lower()
+                            )
+                        )
+                    ]
+                    replacement = (
+                        "MadGraph standalone uses generated SMATRIX with "
+                        "USERHEL=-1; warmed GOODHEL pruning remains enabled."
+                    )
+                    if replacement not in notes:
+                        notes.append(replacement)
+                    plot["notes"] = notes
+    except (
+        KeyError,
+        selected.CompositeError,
+        madgraph.SelectedMadGraphError,
+    ) as error:
+        raise ProfilingError(f"invalid MadGraph overlay {path}: {error}") from error
+
+
+def _matching_madgraph_overlay(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    *,
+    require_exact: bool = True,
+) -> Path | None:
+    path = _madgraph_overlay_path(run_directory)
+    if not path.is_file():
+        return None
+    try:
+        payload = _load_json(path, context="MadGraph overlay")
+    except ProfilingError:
+        return None
+    policy = payload.get("policy")
+    raw_multiplicities = (
+        policy.get("final_state_multiplicities")
+        if isinstance(policy, Mapping)
+        else None
+    )
+    try:
+        overlay_workload = (
+            madgraph._declared_helicity_workload(policy)
+            if isinstance(policy, Mapping)
+            else None
+        )
+    except madgraph.SelectedMadGraphError:
+        return None
+    try:
+        overlay_host = madgraph.validate_measurement_host(
+            payload.get("host"), context="MadGraph overlay host"
+        )
+    except madgraph.SelectedMadGraphError:
+        if require_exact:
+            return None
+        # Historical overlays remain usable for explicitly nonterminal
+        # anytime rendering, but can never enter the strict final merger.
+        if not _legacy_madgraph_host_matches_current(payload.get("host")):
+            return None
+        overlay_host = None
+    if (
+        not isinstance(policy, Mapping)
+        or overlay_workload != _helicity_workload(arguments)
+        or (
+            overlay_host is not None
+            and overlay_host != madgraph.measurement_host_identity()
+        )
+        or policy.get("maximum_measured_multiplicity")
+        != madgraph.MAX_PROTOCOL_MEASURED_MULTIPLICITY
+        or policy.get("family_maximum_measured_multiplicity")
+        != madgraph.protocol_measured_multiplicity_limits()
+        or policy.get("higher_multiplicity_policy") != "not-applicable-protocol-scope"
+    ):
+        return None
+    if (
+        not isinstance(raw_multiplicities, list)
+        or not raw_multiplicities
+        or any(not isinstance(value, int) for value in raw_multiplicities)
+    ):
+        return None
+    requested = _requested_multiplicities(arguments, run_directory)
+    observed = tuple(raw_multiplicities)
+    raw_families = policy.get("selected_process_families")
+    if isinstance(raw_families, list) and set(raw_families) < set(
+        _family_selection(arguments)
+    ):
+        return None
+    if require_exact:
+        if observed != requested:
+            return None
+    elif observed != tuple(value for value in requested if value in set(observed)):
+        return None
+    return path
+
+
+def _madgraph_render_source(
+    arguments: argparse.Namespace, run_directory: Path
+) -> Path | None:
+    progress = _matching_madgraph_progress(arguments, run_directory)
+    if progress is not None and progress.get("status") == "running":
+        return _madgraph_progress_path(run_directory)
+    terminal = _matching_madgraph_overlay(arguments, run_directory, require_exact=False)
+    if terminal is not None:
+        return terminal
+    if progress is not None:
+        return _madgraph_progress_path(run_directory)
+    return None
+
+
+def _publish_render_generation(
+    stage: Path, render_root: Path, digest: str, pdf_filename: str
+) -> Path:
+    generations = render_root / "generations"
+    generations.mkdir(parents=True, exist_ok=True)
+    destination = generations / f"{digest[:16]}-{uuid.uuid4().hex[:8]}"
+    stage.replace(destination)
+    current = render_root / "current"
+    if current.exists() and not current.is_symlink():
+        raise ProfilingError(
+            f"refusing to replace non-symlink render pointer: {current}"
+        )
+    temporary_link = render_root / f".current-{uuid.uuid4().hex}.tmp"
+    relative = os.path.relpath(destination, render_root)
+    os.symlink(relative, temporary_link)
+    os.replace(temporary_link, current)
+    return current / pdf_filename
+
+
+def _publish_canonical_pdf(source: Path, arguments: argparse.Namespace) -> Path:
+    destination = _canonical_pdf_path(arguments)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    for source_path, destination_path in (
+        (source, destination),
+        (source.with_suffix(".json"), destination.with_suffix(".json")),
+    ):
+        if not source_path.is_file():
+            raise ProfilingError(f"canonical render source is missing: {source_path}")
+        temporary = destination_path.with_name(
+            f".{destination_path.name}.{os.getpid()}.{uuid.uuid4().hex[:8]}.tmp"
+        )
+        try:
+            shutil.copyfile(source_path, temporary)
+            os.replace(temporary, destination_path)
+        finally:
+            with contextlib.suppress(FileNotFoundError):
+                temporary.unlink()
+    return destination
+
+
+def render_snapshot(
+    arguments: argparse.Namespace, *, renderer_preflight: bool = True
+) -> Path:
+    run_directory = _run_directory(arguments)
+    lock = _acquire_render_lock(run_directory)
+    try:
+        return _render_snapshot_locked(
+            arguments,
+            run_directory=run_directory,
+            renderer_preflight=renderer_preflight,
+        )
+    finally:
+        lock.close()
+
+
+def _render_snapshot_locked(
+    arguments: argparse.Namespace,
+    *,
+    run_directory: Path,
+    renderer_preflight: bool,
+) -> Path:
+    if arguments.campaign_report is not None:
+        render_arguments = arguments
+    elif arguments.output is not None:
+        render_arguments = _composition_arguments(arguments, run_directory)
+    else:
+        render_arguments = _manifest_backed_arguments(arguments, run_directory)
+    if (
+        arguments.output is not None
+        and arguments.campaign_report is None
+        and _manifest_path(run_directory).is_file()
+    ):
+        _publish_master(render_arguments, run_directory)
+    if arguments.campaign_report is not None:
+        selection = RenderSelection(
+            source=_absolute(arguments.campaign_report),
+            overlay=(
+                _absolute(arguments.madgraph_overlay)
+                if arguments.madgraph_overlay is not None
+                else None
+            ),
+        )
+    elif arguments.output is not None:
+        selection = RenderSelection(
+            source=_master_report_path(run_directory),
+            overlay=_madgraph_render_source(render_arguments, run_directory),
+        )
+    else:
+        selection = _implicit_render_selection(render_arguments, run_directory)
+    source = selection.source
+    if not source.is_file():
+        raise ProfilingError(
+            f"no campaign snapshot yet: {source}; start the scan before --render"
+        )
+    if renderer_preflight:
+        _preflight_renderer(render_arguments)
+    raw, report, digest = _source_snapshot(source)
+    _validate_render_workload(render_arguments, report)
+    pdf_filename = _pdf_filename(render_arguments)
+    terminal_overlay = (
+        _matching_madgraph_overlay(render_arguments, run_directory)
+        if arguments.campaign_report is None
+        else None
+    )
+    selected_overlay_kind = ""
+    if selection.overlay is not None and selection.overlay.is_file():
+        with contextlib.suppress(ProfilingError):
+            selected_overlay_kind = str(
+                _load_json(
+                    selection.overlay,
+                    context="selected MadGraph render overlay",
+                ).get("kind", "")
+            )
+    strict = bool(
+        _report_publication_profile(report)
+        and selection.overlay is not None
+        and selection.overlay.is_file()
+        and selected_overlay_kind == madgraph.KIND
+        and (
+            arguments.campaign_report is not None
+            or (
+                source == _master_report_path(run_directory)
+                and selection.overlay == terminal_overlay
+            )
+        )
+    )
+    overlay = selection.overlay if strict else None
+    partial_overlay = selection.overlay or (run_directory / "madgraph" / ".unavailable")
+
+    render_root = run_directory / "render"
+    render_root.mkdir(parents=True, exist_ok=True)
+    stage = Path(tempfile.mkdtemp(prefix=".staging-", dir=render_root))
+    try:
+        if strict:
+            # The strict merger checks that the campaign file lives inside its
+            # recorded run_root.  Keep an immutable digest-named freeze beside
+            # the source so all downstream provenance remains resolvable.
+            frozen_source = source.parent / f"render-snapshot-{digest}.json"
+            if frozen_source.is_file() and frozen_source.read_bytes() != raw:
+                raise ProfilingError(
+                    f"render snapshot digest collision: {frozen_source}"
+                )
+            if not frozen_source.is_file():
+                temporary = frozen_source.with_suffix(".json.tmp")
+                temporary.write_bytes(raw)
+                temporary.replace(frozen_source)
+            staged_report = stage / "report.json"
+        else:
+            frozen_source = stage / "report.json"
+            frozen = copy.deepcopy(report)
+            if _report_publication_profile(report) and not strict:
+                # The candidate campaign is terminal, but the same-host MG
+                # phase is not.  Keep anytime rendering visibly nonterminal.
+                frozen["status"] = "running-madgraph-series"
+            if partial_overlay.is_file():
+                _attach_partial_overlay(frozen, partial_overlay)
+            frozen["render_snapshot"] = {
+                "status": "in-progress"
+                if report.get("status") not in TERMINAL_STATUSES
+                else "cluster-terminal",
+                "source_report": str(source),
+                "source_sha256": digest,
+            }
+            _write_json_atomic(frozen_source, frozen)
+            staged_report = frozen_source
+        staged_plots = stage / "plots"
+        staged_pdf = stage / pdf_filename
+        commands = _render_commands(
+            render_arguments,
+            source_report=frozen_source,
+            staged_report=staged_report,
+            staged_plots=staged_plots,
+            staged_pdf=staged_pdf,
+            strict=strict,
+            madgraph_overlay=overlay,
+        )
+        render_environment = _renderer_environment(render_arguments)
+        for command in commands:
+            _run_checked(command, environment=render_environment)
+        expected_plots = {
+            f"fullcolor-{family}-{metric}.png"
+            for family in ("gg", "ddbar")
+            for metric in ("generation", "warm-runtime", "rss")
+        }
+        observed_plots = {
+            path.name for path in staged_plots.glob("*.png") if path.stat().st_size > 0
+        }
+        staged_json = staged_pdf.with_suffix(".json")
+        if observed_plots != expected_plots or not (
+            staged_pdf.is_file() and staged_pdf.stat().st_size > 0
+        ) or not (
+            staged_json.is_file() and staged_json.stat().st_size > 0
+        ):
+            raise ProfilingError(
+                "render commands did not produce one complete output set"
+            )
+        published = _publish_render_generation(stage, render_root, digest, pdf_filename)
+        if _canonical_publication_enabled(render_arguments):
+            _publish_canonical_pdf(published, render_arguments)
+        return published
+    except BaseException:
+        if stage.is_dir():
+            shutil.rmtree(stage)
+        raise
+
+
+def _safe_refresh(run_directory: Path) -> bool:
+    _validate_refresh_target(run_directory)
+    render_lock = _acquire_render_lock(run_directory)
+    try:
+        try:
+            cache_lock = madgraph._acquire_cache_lock(
+                _madgraph_cache_path(run_directory)
+            )
+        except madgraph.SelectedMadGraphError as error:
+            raise ProfilingError(f"cannot refresh while {error}") from error
+        try:
+            return _safe_refresh_locked(run_directory)
+        finally:
+            cache_lock.close()
+    finally:
+        render_lock.close()
+
+
+def _safe_refresh_locked(run_directory: Path) -> bool:
+    _validate_refresh_target(run_directory)
+    resolved = run_directory.resolve(strict=False)
+    if not resolved.exists():
+        return False
+    manifest_path = resolved / "manifest.json"
+    if not manifest_path.is_file():
+        raise ProfilingError(
+            "--refresh requires an existing recognized profiling manifest at "
+            f"{manifest_path}"
+        )
+    manifest = _load_json(manifest_path, context="profiling refresh manifest")
+    identity = manifest.get("identity")
+    if (
+        manifest.get("kind") != KIND
+        or manifest.get("schema_version") != SCHEMA_VERSION
+        or not isinstance(identity, Mapping)
+        or identity.get("run_directory") != str(resolved)
+    ):
+        raise ProfilingError(
+            f"refusing --refresh for unrecognized profiling directory: {resolved}"
+        )
+    shutil.rmtree(resolved)
+    return True
+
+
+def _validate_refresh_target(run_directory: Path) -> None:
+    _reject_refresh_symlinks(run_directory)
+    unsafe = {
+        Path("/").resolve(),
+        Path.home().resolve(),
+        ROOT.resolve(),
+        DEFAULT_RUNS_ROOT.resolve(strict=False),
+    }
+    resolved = run_directory.resolve(strict=False)
+    if resolved in unsafe or len(resolved.parts) < 4:
+        raise ProfilingError(f"refusing ambiguous --refresh target: {resolved}")
+
+
+def _reject_refresh_symlinks(path: Path) -> None:
+    expanded = path.expanduser()
+    absolute = Path(os.path.abspath(expanded))
+    for candidate in (absolute, *absolute.parents):
+        if candidate.is_symlink():
+            raise ProfilingError(
+                f"refusing --refresh through symlinked path component: {candidate}"
+            )
+
+
+def _command_available(command: str) -> bool:
+    path = Path(command).expanduser()
+    return (
+        path.is_file() and os.access(path, os.X_OK)
+        if path.parent != Path(".")
+        else shutil.which(command) is not None
+    )
+
+
+def _dependency_status(arguments: argparse.Namespace) -> dict[str, Any]:
+    amplicol = _absolute(arguments.amplicol_root)
+    reference_fft = _absolute(arguments.reference_fft_root)
+    madgraph = (
+        _absolute(arguments.madgraph_root)
+        if arguments.madgraph_root is not None
+        else None
+    )
+    return {
+        "python": {
+            "path": str(arguments.python),
+            "available": _command_available(str(arguments.python)),
+        },
+        "cxx": {
+            "path": str(arguments.cxx),
+            "available": _command_available(str(arguments.cxx)),
+        },
+        "fortran": {
+            "path": str(arguments.fc),
+            "available": _command_available(str(arguments.fc)),
+        },
+        "make": {
+            "path": str(arguments.make),
+            "available": _command_available(str(arguments.make)),
+        },
+        "amplicol_root": {
+            "path": str(amplicol),
+            "compatible": (amplicol / "process_list.py").is_file(),
+            "probe": str(amplicol / "amplicol_color_probe"),
+            "probe_available": (amplicol / "amplicol_color_probe").is_file(),
+        },
+        "reference_fft_root": {
+            "path": str(reference_fft),
+            "compatible": (reference_fft / "Benchmark" / "run_benchmark.py").is_file(),
+        },
+        "madgraph_root": {
+            "path": str(madgraph) if madgraph is not None else None,
+            "applicable": True,
+            "compatible": bool(
+                madgraph is not None
+                and (madgraph / "bin" / "mg5_aMC").is_file()
+                and (madgraph / "VERSION").is_file()
+            ),
+        },
+    }
+
+
+def _preflight(arguments: argparse.Namespace) -> None:
+    status = _dependency_status(arguments)
+    run_directory = _run_directory(arguments)
+    requested_shards = _requested_shards(arguments, run_directory)
+    for key in ("python", "cxx", "fortran"):
+        if status[key]["available"] is not True:
+            raise ProfilingError(
+                f"required {key} executable is unavailable: {status[key]['path']}"
+            )
+    if _pyamplicol_runtime_required(requested_shards):
+        _preflight_pyamplicol_runtime(arguments)
+    needs_amplicol = any(
+        "amplicol" in _shard_modes(arguments, run_directory, shard)
+        for shard in requested_shards
+    )
+    if needs_amplicol:
+        amplicol = status["amplicol_root"]
+        if amplicol["compatible"] is not True:
+            raise ProfilingError(
+                f"invalid --amplicol-root: {amplicol['path']}; pass a compatible "
+                "checkout or run `just dev-install --with-legacy-amplicol`"
+            )
+        if (
+            not arguments.compare_helicity_sums
+            and amplicol["probe_available"] is not True
+            and not arguments.build_amplicol
+        ):
+            raise ProfilingError(
+                "AmpliCol probe is missing; pass --build-amplicol to build it once: "
+                f"{amplicol['probe']}"
+            )
+    needs_reference_fft = any(
+        "reference-fft" in _shard_modes(arguments, run_directory, shard)
+        for shard in requested_shards
+    )
+    if needs_reference_fft:
+        reference_fft = status["reference_fft_root"]
+        if reference_fft["compatible"] is not True:
+            raise ProfilingError(
+                "invalid --reference-fft-root: expected "
+                f"Benchmark/run_benchmark.py below {reference_fft['path']}; pass a "
+                "compatible checkout or run "
+                "`just dev-install --with-reference-fft`"
+            )
+    if _madgraph_requested(arguments, run_directory):
+        if status["make"]["available"] is not True:
+            raise ProfilingError(
+                f"required make executable is unavailable: {status['make']['path']}"
+            )
+        madgraph = status["madgraph_root"]
+        if madgraph["compatible"] is not True:
+            raise ProfilingError(
+                "MadGraph installation is missing or incompatible; pass "
+                "--madgraph-root PATH containing bin/mg5_aMC and VERSION"
+            )
+    _preflight_renderer(arguments)
+
+
+def _preflight_renderer(arguments: argparse.Namespace) -> None:
+    if not _command_available(str(arguments.python)):
+        raise ProfilingError(
+            f"renderer --python executable is unavailable: {arguments.python}"
+        )
+    renderer = subprocess.run(
+        (
+            str(arguments.python),
+            "-c",
+            "import matplotlib, platform, reportlab; print(platform.python_version())",
+        ),
+        check=False,
+        capture_output=True,
+        text=True,
+        env=_renderer_environment(arguments),
+    )
+    if renderer.returncode != 0:
+        install_command = shlex.join(
+            (
+                str(arguments.python),
+                "-m",
+                "pip",
+                "install",
+                *RENDER_REQUIREMENTS,
+            )
+        )
+        raise ProfilingError(
+            "plot/PDF dependencies are missing from --python; install them with "
+            f"{install_command}"
+        )
+    selected_version = renderer.stdout.strip()
+    driver_version = str(madgraph.measurement_host_identity()["python"])
+    if selected_version != driver_version:
+        raise ProfilingError(
+            "--python uses Python "
+            f"{selected_version!r}, but the profiling driver uses {driver_version!r}; "
+            "run fft_profiling.py with the selected interpreter"
+        )
+
+
+def _renderer_environment(arguments: argparse.Namespace) -> dict[str, str]:
+    cache = _run_directory(arguments) / "render" / ".matplotlib"
+    cache.mkdir(parents=True, exist_ok=True)
+    environment = os.environ.copy()
+    environment["MPLCONFIGDIR"] = str(cache)
+    return environment
+
+
+def _madgraph_timeout(arguments: argparse.Namespace) -> float:
+    # The canonical publication overlay has historically used a strict 3595-s
+    # MG limit while the pyAmpliCol cells use the strict 3600-s admission edge.
+    # Custom cluster limits are transmitted without clamping.
+    return (
+        study.DEFAULT_TIME_LIMIT_SECONDS - 5.0
+        if arguments.time_limit_seconds == study.DEFAULT_TIME_LIMIT_SECONDS
+        else arguments.time_limit_seconds
+    )
+
+
+def _madgraph_command(
+    arguments: argparse.Namespace, run_directory: Path
+) -> tuple[str, ...]:
+    if arguments.madgraph_root is None:
+        raise ProfilingError("--madgraph-root is required for the same-host series")
+    result = [
+        str(arguments.python),
+        str(MADGRAPH_TOOL),
+        "--source-report",
+        str(_madgraph_source_path(arguments, run_directory)),
+        "--cache-dir",
+        str(_madgraph_cache_path(run_directory)),
+        "--output",
+        str(_madgraph_overlay_path(run_directory)),
+        "--mg5-root",
+        str(_absolute(arguments.madgraph_root)),
+        "--fc",
+        str(arguments.fc),
+        "--make",
+        str(arguments.make),
+        "--generation-timeout-seconds",
+        format(_madgraph_timeout(arguments), ".17g"),
+        "--memory-limit-gib",
+        format(arguments.memory_limit_gib, ".17g"),
+        "--target-seconds",
+        format(arguments.target_seconds, ".17g"),
+    ]
+    selected_families = _family_selection(arguments)
+    for multiplicity in _requested_multiplicities(arguments, run_directory):
+        measured_by_requested_family = any(
+            madgraph.protocol_measures_multiplicity(family, multiplicity)
+            for family in selected_families
+        )
+        result.extend(
+            (
+                (
+                    "--multiplicity"
+                    if measured_by_requested_family
+                    else "--protocol-scope-multiplicity"
+                ),
+                str(multiplicity),
+            )
+        )
+    if len(selected_families) == 1:
+        result.extend(("--family", selected_families[0]))
+    if arguments.compare_helicity_sums:
+        result.append("--compare-helicity-sums")
+    return tuple(result)
+
+
+def _madgraph_source_projection(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    report: Mapping[str, Any],
+) -> dict[str, Any]:
+    policy = report.get("policy")
+    if not isinstance(policy, Mapping):
+        raise ProfilingError("MadGraph source report has no policy")
+    measurement = policy.get("measurement")
+    if not isinstance(measurement, Mapping):
+        raise ProfilingError("MadGraph source report has no measurement policy")
+    alpha_s = measurement.get("alpha_s")
+    if not isinstance(alpha_s, int | float) or isinstance(alpha_s, bool):
+        raise ProfilingError("MadGraph source report has invalid alpha_s")
+    workload = _helicity_workload(arguments)
+    cells = report.get("cells")
+    if not isinstance(cells, Mapping):
+        raise ProfilingError("MadGraph source report has no cells")
+    requested = {
+        str(value) for value in _requested_multiplicities(arguments, run_directory)
+    }
+    source_cells: dict[str, dict[str, dict[str, object]]] = {}
+    for family in _family_selection(arguments):
+        mode = madgraph.source_mode(family, _helicity_workload(arguments))
+        family_cells = cells.get(family)
+        if not isinstance(family_cells, Mapping):
+            raise ProfilingError(f"MadGraph source report has no {family} cells")
+        curve = family_cells.get(mode)
+        if not isinstance(curve, Mapping):
+            raise ProfilingError(f"MadGraph source report has no {family}/{mode} curve")
+        source_cells[family] = {
+            mode: {
+                str(raw_n): copy.deepcopy(cell)
+                for raw_n, cell in curve.items()
+                if str(raw_n) in requested
+            }
+        }
+    projected: dict[str, Any] = {
+        "kind": madgraph.SOURCE_KIND,
+        "schema_version": 1,
+        "status": "complete",
+        "policy": {
+            "helicity_workload": workload,
+            "measurement": {
+                "alpha_s": float(alpha_s),
+                "helicity_workload": workload,
+                "warm_fixed_helicity": workload == "fixed",
+                "warm_helicity_sum": workload == "sum",
+            },
+        },
+        "cells": source_cells,
+    }
+    if isinstance(report.get("measurement_host"), Mapping):
+        projected["measurement_host"] = copy.deepcopy(report["measurement_host"])
+    return projected
+
+
+def _freeze_madgraph_source(arguments: argparse.Namespace, run_directory: Path) -> Path:
+    master_path = _master_report_path(run_directory)
+    _raw, master, _ = _source_snapshot(master_path)
+    if not _madgraph_source_ready(arguments, run_directory, master):
+        raise ProfilingError(
+            "cannot freeze MadGraph source before its selected source cells "
+            "are complete"
+        )
+    source = _madgraph_source_projection(arguments, run_directory, master)
+    destination = _madgraph_source_path(arguments, run_directory)
+    if destination.is_file():
+        existing = _load_json(destination, context="frozen MadGraph source")
+        normalized_existing = _madgraph_source_projection(
+            arguments, run_directory, existing
+        )
+        if normalized_existing == source:
+            return destination
+    _write_json_atomic(destination, source)
+    return destination
+
+
+def _madgraph_source_ready(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    master: Mapping[str, Any] | None = None,
+) -> bool:
+    if not _madgraph_requested(arguments, run_directory):
+        return False
+    if master is None:
+        master_path = _master_report_path(run_directory)
+        if not master_path.is_file():
+            return False
+        _raw, master, _ = _source_snapshot(master_path)
+    for family in _family_selection(arguments):
+        source_mode = madgraph.source_mode(family, _helicity_workload(arguments))
+        if not _selected_cells_terminal_for_orchestrator(
+            master,
+            family=family,
+            modes=(source_mode,),
+            multiplicities=_requested_multiplicities(arguments, run_directory),
+        ):
+            return False
+    return True
+
+
+def _ensure_madgraph_overlay(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    dashboard: Dashboard,
+) -> None:
+    if not _madgraph_requested(arguments, run_directory):
+        return
+    _freeze_madgraph_source(arguments, run_directory)
+    if _matching_madgraph_overlay(arguments, run_directory) is not None:
+        _diagnostic(
+            "Reusing the matching MadGraph overlay.",
+            colorama.Fore.CYAN,
+        )
+        return
+    _run_madgraph(arguments, run_directory, dashboard)
+
+
+def _start_madgraph_overlay(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+) -> ActiveJob | None:
+    if not _madgraph_requested(arguments, run_directory):
+        return None
+    _freeze_madgraph_source(arguments, run_directory)
+    if _matching_madgraph_overlay(arguments, run_directory) is not None:
+        _diagnostic(
+            "Reusing the matching MadGraph overlay.",
+            colorama.Fore.CYAN,
+        )
+        return None
+    return _launch_madgraph_job(arguments, run_directory)
+
+
+def _maybe_start_madgraph_overlay(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    active: list[ActiveJob],
+) -> bool:
+    if (
+        active
+        or not _madgraph_requested(arguments, run_directory)
+        or not _madgraph_source_ready(arguments, run_directory)
+    ):
+        return False
+    job = _start_madgraph_overlay(arguments, run_directory)
+    if job is None:
+        return True
+    active.append(job)
+    return False
+
+
+def _format_duration(seconds: float | None) -> str:
+    if seconds is None or not math.isfinite(seconds):
+        return "?"
+    value = max(0, int(seconds))
+    hours, remainder = divmod(value, 3600)
+    minutes, seconds_i = divmod(remainder, 60)
+    return f"{hours:d}:{minutes:02d}:{seconds_i:02d}"
+
+
+def _aggregate_rss(active: Sequence[ActiveJob]) -> int | None:
+    if not active:
+        return 0
+    try:
+        records = memory_watchdog.process_snapshot()
+        return sum(job.sampler.sample(records).rss_bytes for job in active)
+    except memory_watchdog.ProbeError:
+        return None
+
+
+def _matching_madgraph_progress(
+    arguments: argparse.Namespace, run_directory: Path
+) -> dict[str, Any] | None:
+    path = _madgraph_progress_path(run_directory)
+    if not path.is_file():
+        return None
+    try:
+        payload = madgraph.load_runtime_progress(path)
+    except madgraph.SelectedMadGraphError:
+        return None
+    policy = payload.get("policy")
+    try:
+        progress_workload = (
+            madgraph._declared_helicity_workload(policy)
+            if isinstance(policy, Mapping)
+            else None
+        )
+        progress_host = madgraph.validate_measurement_host(
+            payload.get("host"), context="MadGraph runtime progress host"
+        )
+    except madgraph.SelectedMadGraphError:
+        return None
+    requested_multiplicities = _requested_multiplicities(arguments, run_directory)
+    raw_multiplicities = policy.get("final_state_multiplicities")
+    if (
+        not isinstance(policy, Mapping)
+        or progress_workload != _helicity_workload(arguments)
+        or progress_host != madgraph.measurement_host_identity()
+        or policy.get("family_maximum_measured_multiplicity")
+        != madgraph.protocol_measured_multiplicity_limits()
+    ):
+        return None
+    if (
+        not isinstance(raw_multiplicities, list)
+        or not raw_multiplicities
+        or any(not isinstance(value, int) for value in raw_multiplicities)
+    ):
+        return None
+    observed_multiplicities = tuple(raw_multiplicities)
+    observed_set = set(observed_multiplicities)
+    if observed_multiplicities != tuple(
+        value for value in requested_multiplicities if value in observed_set
+    ):
+        return None
+    raw_families = policy.get("selected_process_families")
+    if isinstance(raw_families, list) and set(raw_families) < set(
+        _family_selection(arguments)
+    ):
+        return None
+    return payload
+
+
+def _madgraph_completed(arguments: argparse.Namespace, run_directory: Path) -> int:
+    if not _madgraph_requested(arguments, run_directory):
+        return 0
+    terminal = _matching_madgraph_overlay(arguments, run_directory)
+    progress_payload = _matching_madgraph_progress(arguments, run_directory)
+    if progress_payload is not None and progress_payload.get("status") == "running":
+        report = progress_payload
+    elif terminal is not None:
+        report = _load_json(terminal, context="MadGraph overlay")
+    elif progress_payload is not None:
+        report = progress_payload
+    else:
+        return 0
+    series = report.get("runtime_series")
+    if not isinstance(series, Mapping):
+        return 0
+    requested_families = set(_family_selection(arguments))
+    requested_multiplicities = {
+        str(value) for value in _requested_multiplicities(arguments, run_directory)
+    }
+    return sum(
+        1
+        for family, family_cells in series.items()
+        if family in requested_families
+        if isinstance(family_cells, Mapping)
+        for mode_cells in family_cells.values()
+        if isinstance(mode_cells, Mapping)
+        for raw_n in mode_cells
+        if str(raw_n) in requested_multiplicities
+    )
+
+
+class Dashboard:
+    def __init__(
+        self,
+        *,
+        total: int,
+        core_budget: int,
+        helicity_workload: str,
+        batch_size: int,
+    ) -> None:
+        self.total = total
+        self.core_budget = core_budget
+        self.started = time.monotonic()
+        self.workload = helicity_workload
+        self.batch_size = batch_size
+        self.bar = progressbar.ProgressBar(
+            max_value=total,
+            fd=sys.stderr,
+            widgets=[
+                progressbar.Variable("headline", width=96),
+                " ",
+                progressbar.Bar(),
+                " ",
+                progressbar.Percentage(),
+            ],
+        )
+        self.bar.start()
+
+    def update(
+        self,
+        completed: int,
+        *,
+        phase: str,
+        active: Sequence[ActiveJob],
+    ) -> None:
+        elapsed = time.monotonic() - self.started
+        rss = _aggregate_rss(active)
+        rss_text = "RSS n/a" if rss is None else f"RSS {rss / 1024**3:.2f} GiB"
+        active_cores = sum(job.claimed_cores for job in active)
+        jobs = ",".join(job.detail for job in active) or "idle"
+        headline = (
+            f"{completed}/{self.total} cells | {self.workload} "
+            f"batch={self.batch_size} | "
+            f"{phase}: {jobs} | "
+            f"cores active={active_cores}/{self.core_budget} | {rss_text} | "
+            f"elapsed {_format_duration(elapsed)}"
+        )
+        self.bar.update(min(completed, self.total), headline=headline, force=True)
+
+    def finish(self) -> None:
+        self.bar.finish(dirty=True)
+
+
+def _color_enabled(arguments: argparse.Namespace) -> bool:
+    return (
+        not arguments.no_color and "NO_COLOR" not in os.environ and sys.stderr.isatty()
+    )
+
+
+def _diagnostic(message: str, color: str = "") -> None:
+    suffix = colorama.Style.RESET_ALL if color else ""
+    print(f"{color}{message}{suffix}", file=sys.stderr, flush=True)
+
+
+def _python_source_environment(arguments: argparse.Namespace) -> dict[str, str]:
+    environment = os.environ.copy()
+    source = str(ROOT / "src")
+    existing = environment.get("PYTHONPATH")
+    environment["PYTHONPATH"] = (
+        source if not existing else os.pathsep.join((source, existing))
+    )
+    environment["PYTHONDONTWRITEBYTECODE"] = "1"
+    environment.setdefault("SYMBOLICA_HIDE_BANNER", "1")
+    environment["FFT_ACCEPTANCE_PYTHON"] = str(arguments.python)
+    return environment
+
+
+def _pyamplicol_runtime_required(requested_shards: Sequence[Shard]) -> bool:
+    return any(
+        shard.family == "ddbar"
+        or any(study.MODE_BY_KEY[mode].kind == "candidate" for mode in shard.modes)
+        for shard in requested_shards
+    )
+
+
+def _preflight_pyamplicol_runtime(arguments: argparse.Namespace) -> None:
+    completed = subprocess.run(
+        (
+            str(arguments.python),
+            "-c",
+            (
+                "import pyamplicol; "
+                "from pyamplicol.generation.phase_space import "
+                "massive_rambo_final_state; "
+                "print(pyamplicol.__version__)"
+            ),
+        ),
+        check=False,
+        capture_output=True,
+        text=True,
+        env=_python_source_environment(arguments),
+    )
+    if completed.returncode == 0:
+        return
+    detail = (completed.stderr or completed.stdout).strip()
+    if len(detail) > 4000:
+        detail = detail[-4000:]
+    raise ProfilingError(
+        "selected --python cannot import pyAmpliCol from this checkout; "
+        "rerun `just dev-install` in this workspace or fix the Python/native "
+        f"runtime before profiling.\n{detail}"
+    )
+
+
+def _claimed_cores(arguments: argparse.Namespace, shard: Shard | ShardWork) -> int:
+    if isinstance(shard, ShardWork):
+        shard = shard.shard
+    return arguments.candidate_cores if shard.candidate else 1
+
+
+def _launch_shard(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> ActiveJob:
+    command = _child_command(arguments, run_directory, work)
+    log_root = _work_cell_root(run_directory, work) / "orchestrator-logs"
+    log_root.mkdir(parents=True, exist_ok=True)
+    stdout = (log_root / "stdout.log").open("wb")
+    stderr = (log_root / "stderr.log").open("wb")
+    claimed = _claimed_cores(arguments, work)
+    environment = os.environ.copy()
+    for key in (
+        "OMP_NUM_THREADS",
+        "OPENBLAS_NUM_THREADS",
+        "MKL_NUM_THREADS",
+        "NUMEXPR_NUM_THREADS",
+        "VECLIB_MAXIMUM_THREADS",
+        "RAYON_NUM_THREADS",
+    ):
+        environment[key] = str(claimed)
+    try:
+        process = subprocess.Popen(
+            command,
+            stdout=stdout,
+            stderr=stderr,
+            env=environment,
+            start_new_session=True,
+        )
+    except BaseException:
+        stdout.close()
+        stderr.close()
+        raise
+    return ActiveJob(
+        shard=work.shard,
+        final_multiplicity=work.final_multiplicity,
+        owned_mode=work.owned_mode,
+        command=command,
+        process=process,
+        stdout=stdout,
+        stderr=stderr,
+        sampler=memory_watchdog.ProcessTreeSampler(process.pid, process.pid),
+        claimed_cores=claimed,
+        detail=f"{work.shard.family}/{work.owned_mode}/n{work.final_multiplicity}",
+    )
+
+
+def _work_detail(
+    arguments: argparse.Namespace, run_directory: Path, work: ShardWork
+) -> str:
+    report = _load_shard_report(arguments, run_directory, work.shard)
+    for mode in _work_owned_modes(arguments, run_directory, work):
+        if report is None or not _selected_cells_terminal_for_orchestrator(
+            report,
+            family=work.shard.family,
+            modes=(mode,),
+            multiplicities=(work.final_multiplicity,),
+        ):
+            return f"{work.shard.family}/{mode}/n{work.final_multiplicity}"
+    return f"{work.shard.name}/n{work.final_multiplicity}/finalizing"
+
+
+def _shard_detail(
+    arguments: argparse.Namespace, run_directory: Path, shard: Shard
+) -> str:
+    report = _load_shard_report(arguments, run_directory, shard)
+    for final_multiplicity in _requested_multiplicities(arguments, run_directory):
+        for mode in _counted_owned_modes(arguments, run_directory, shard):
+            work = ShardWork(shard, final_multiplicity, mode)
+            if not _selected_work_complete(arguments, run_directory, work, report):
+                return _work_detail(arguments, run_directory, work)
+    return f"{shard.name}/finalizing"
+
+
+def _terminate_jobs(active: Sequence[ActiveJob]) -> None:
+    for job in active:
+        if job.process.poll() is None:
+            with contextlib.suppress(ProcessLookupError):
+                os.killpg(job.process.pid, signal.SIGTERM)
+    deadline = time.monotonic() + 5.0
+    for job in active:
+        remaining = max(0.0, deadline - time.monotonic())
+        with contextlib.suppress(subprocess.TimeoutExpired):
+            job.process.wait(timeout=remaining)
+    for job in active:
+        if job.process.poll() is None:
+            with contextlib.suppress(ProcessLookupError):
+                os.killpg(job.process.pid, signal.SIGKILL)
+            job.process.wait()
+        job.stdout.close()
+        job.stderr.close()
+
+
+@contextlib.contextmanager
+def _termination_signal_handlers():
+    previous: dict[int, Any] = {}
+
+    def interrupt(signum: int, _frame: object) -> None:
+        raise CampaignSignal(signum)
+
+    for signum in (signal.SIGTERM, signal.SIGHUP):
+        previous[signum] = signal.getsignal(signum)
+        signal.signal(signum, interrupt)
+    try:
+        yield
+    finally:
+        for signum, handler in previous.items():
+            signal.signal(signum, handler)
+
+
+def _prepare_phase_shard_state(
+    arguments: argparse.Namespace, run_directory: Path, shard: Shard
+) -> dict[str, Any] | None:
+    _seed_protocol_scope(arguments, run_directory, shard)
+    report = _load_shard_report(arguments, run_directory, shard)
+    loaded = report is not None
+    if report is None and shard.dependency is None:
+        return None
+    if report is None:
+        report = study.compose_report(
+            _shard_arguments(arguments, run_directory, shard), {}
+        )
+    changed = _apply_resource_frontier_censoring(
+        arguments,
+        report,
+        shard,
+        modes=_counted_owned_modes(arguments, run_directory, shard),
+        multiplicities=_requested_multiplicities(arguments, run_directory),
+    )
+    changed = (
+        _apply_dependency_skips(
+            arguments,
+            run_directory,
+            report,
+            shard,
+            multiplicities=_requested_multiplicities(arguments, run_directory),
+        )
+        or changed
+    )
+    if changed:
+        report = study.compose_report(
+            _shard_arguments(arguments, run_directory, shard), report["cells"]
+        )
+    if loaded or changed:
+        _write_json_atomic(_shard_report_path(run_directory, shard), report)
+    return report
+
+
+def _overwrite_work_blocker(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    work: ShardWork,
+    report: Mapping[str, Any] | None,
+) -> str | None:
+    if report is not None:
+        cells = report.get("cells")
+        family_cells = (
+            cells.get(work.shard.family) if isinstance(cells, Mapping) else None
+        )
+        curve = (
+            family_cells.get(work.owned_mode)
+            if isinstance(family_cells, Mapping)
+            else None
+        )
+        if isinstance(curve, Mapping):
+            frontier = _mode_resource_frontier(curve, work.final_multiplicity)
+            if frontier is not None:
+                return f"resource limit at n={frontier}"
+
+    if work.shard.dependency is None:
+        return None
+    dependency_name, dependency_mode = work.shard.dependency
+    dependency_shard = SHARD_BY_NAME[dependency_name]
+    dependency = _load_shard_report(arguments, run_directory, dependency_shard)
+    if dependency is None:
+        return None
+    cells = dependency.get("cells")
+    family_cells = cells.get(work.shard.family) if isinstance(cells, Mapping) else None
+    curve = (
+        family_cells.get(dependency_mode)
+        if isinstance(family_cells, Mapping)
+        else None
+    )
+    cell = (
+        curve.get(str(work.final_multiplicity))
+        if isinstance(curve, Mapping)
+        else None
+    )
+    if (
+        isinstance(cell, Mapping)
+        and _cell_terminal_for_orchestrator(cell)
+        and cell.get("status") != "measured"
+    ):
+        return f"dependency {dependency_name} is {cell.get('status')}"
+    return None
+
+
+def _refresh_phase_pending(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    pending: Sequence[ShardWork],
+    active: Sequence[ActiveJob],
+    *,
+    overwrite_pending: set[CellIdentity] | None = None,
+) -> list[ShardWork]:
+    forced = overwrite_pending if overwrite_pending is not None else set()
+    reports: dict[str, dict[str, Any] | None] = {}
+    for shard in {work.shard for work in pending}:
+        reports[shard.name] = _prepare_phase_shard_state(
+            arguments, run_directory, shard
+        )
+    active_keys = {
+        (job.shard.name, job.final_multiplicity, job.owned_mode)
+        for job in active
+        if job.final_multiplicity is not None
+    }
+    blocked: set[CellIdentity] = set()
+    for work in pending:
+        identity = _work_identity(work)
+        if identity not in forced:
+            continue
+        blocker = _overwrite_work_blocker(
+            arguments, run_directory, work, reports.get(work.shard.name)
+        )
+        if blocker is None:
+            continue
+        blocked.add(identity)
+        forced.remove(identity)
+        _diagnostic(
+            f"Retaining existing {work.shard.family}/{work.owned_mode}/"
+            f"n{work.final_multiplicity}; overwrite was not attempted because "
+            f"of {blocker}.",
+            colorama.Fore.YELLOW,
+        )
+    return [
+        work
+        for work in pending
+        if _work_identity(work) not in blocked
+        if (work.shard.name, work.final_multiplicity, work.owned_mode)
+        not in active_keys
+        and (
+            _work_identity(work) in forced
+            or not _selected_work_complete(
+                arguments,
+                run_directory,
+                work,
+                reports.get(work.shard.name)
+                if work.shard.name in reports
+                else _load_shard_report(arguments, run_directory, work.shard),
+            )
+        )
+    ]
+
+
+def _work_launch_conflicts(
+    arguments: argparse.Namespace, work: ShardWork, active: Sequence[ActiveJob]
+) -> bool:
+    if arguments.compare_helicity_sums and work.owned_mode == "amplicol":
+        return any(job.owned_mode == "amplicol" for job in active)
+    if not arguments.build_amplicol or work.shard.name != "ddbar-amplicol":
+        return False
+    probe = _absolute(arguments.amplicol_root) / "amplicol_color_probe"
+    return not probe.is_file() and any(
+        job.shard.name == work.shard.name for job in active
+    )
+
+
+def _phase(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    phase_number: int,
+    dashboard: Dashboard,
+    *,
+    background: list[ActiveJob] | None = None,
+    madgraph_overlay_ready: bool = False,
+    overwrite_pending: set[CellIdentity] | None = None,
+) -> bool:
+    pending = list(_phase_work_items(arguments, run_directory, phase_number))
+    active: list[ActiveJob] = []
+    failure: str | None = None
+    background_jobs = background if background is not None else []
+    try:
+        while pending or active:
+            failure = _poll_madgraph_jobs(arguments, run_directory, background_jobs)
+            if failure is not None:
+                break
+            pending = _refresh_phase_pending(
+                arguments,
+                run_directory,
+                pending,
+                active,
+                overwrite_pending=overwrite_pending,
+            )
+            used = sum(job.claimed_cores for job in active + background_jobs)
+            launched = True
+            while launched:
+                launched = False
+                for index, work in enumerate(pending):
+                    if not _work_dependency_ready(arguments, run_directory, work):
+                        continue
+                    claim = _claimed_cores(arguments, work)
+                    if used + claim > arguments.cores:
+                        continue
+                    if _work_launch_conflicts(arguments, work, active):
+                        continue
+                    identity = _work_identity(work)
+                    if (
+                        overwrite_pending is not None
+                        and identity in overwrite_pending
+                    ):
+                        _prepare_overwrite_work(arguments, run_directory, work)
+                        overwrite_pending.remove(identity)
+                    _seed_cell_inputs(arguments, run_directory, work)
+                    report = _publish_shard_report(arguments, run_directory, work.shard)
+                    if _selected_work_complete(arguments, run_directory, work, report):
+                        pending.pop(index)
+                        launched = True
+                        break
+                    job = _launch_shard(arguments, run_directory, work)
+                    active.append(job)
+                    pending.pop(index)
+                    used += claim
+                    launched = True
+                    break
+
+            for job in active:
+                assert job.final_multiplicity is not None
+                assert job.owned_mode is not None
+                job.detail = _work_detail(
+                    arguments,
+                    run_directory,
+                    ShardWork(job.shard, job.final_multiplicity, job.owned_mode),
+                )
+            names = tuple(
+                (
+                    f"{job.shard.name}:{job.owned_mode}:n{job.final_multiplicity}"
+                    if job.owned_mode is not None
+                    else f"{job.shard.name}:n{job.final_multiplicity}"
+                )
+                for job in active
+            )
+            master = _publish_master(arguments, run_directory, active=names)
+            if not madgraph_overlay_ready:
+                madgraph_overlay_ready = _maybe_start_madgraph_overlay(
+                    arguments, run_directory, background_jobs
+                )
+            dashboard.update(
+                _selected_completed_cells(
+                    arguments,
+                    master,
+                    ignored_cells=(
+                        overwrite_pending
+                        if overwrite_pending is not None
+                        else frozenset()
+                    ),
+                )
+                + _madgraph_completed(arguments, run_directory),
+                phase=f"phase {phase_number}",
+                active=tuple(background_jobs) + tuple(active),
+            )
+            if not active and pending:
+                if background_jobs and any(
+                    _work_dependency_ready(arguments, run_directory, work)
+                    for work in pending
+                ):
+                    time.sleep(arguments.poll_seconds)
+                    continue
+                unready = next(
+                    (
+                        work
+                        for work in pending
+                        if not _work_dependency_ready(arguments, run_directory, work)
+                    ),
+                    None,
+                )
+                if unready is not None:
+                    dependency_name = (
+                        unready.shard.dependency[0]
+                        if unready.shard.dependency is not None
+                        else "unknown"
+                    )
+                    failure = (
+                        f"{unready.shard.name} cannot start "
+                        f"n{unready.final_multiplicity} because dependency "
+                        f"{dependency_name} is incomplete"
+                    )
+                    break
+            if not active:
+                break
+            time.sleep(arguments.poll_seconds)
+            failure = _poll_madgraph_jobs(arguments, run_directory, background_jobs)
+            if failure is not None:
+                break
+            for job in tuple(active):
+                returncode = job.process.poll()
+                if returncode is None:
+                    continue
+                job.stdout.close()
+                job.stderr.close()
+                active.remove(job)
+                assert job.final_multiplicity is not None
+                assert job.owned_mode is not None
+                report = _publish_shard_report(arguments, run_directory, job.shard)
+                work = ShardWork(job.shard, job.final_multiplicity, job.owned_mode)
+                if not _selected_work_complete(
+                    arguments, run_directory, work, report
+                ):
+                    failure = (
+                        f"{job.shard.name} n{job.final_multiplicity} exited "
+                        f"{returncode} without completing the requested "
+                        "authoritative cells; inspect its "
+                        "orchestrator logs"
+                    )
+                    break
+            if failure is not None:
+                break
+    finally:
+        if active:
+            _terminate_jobs(active)
+    if failure is not None:
+        _publish_master(arguments, run_directory, halt_reason=failure)
+        raise ProfilingError(failure)
+    return madgraph_overlay_ready
+
+
+def _run_madgraph(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    dashboard: Dashboard,
+) -> None:
+    active = [_launch_madgraph_job(arguments, run_directory)]
+    try:
+        _wait_madgraph_jobs(arguments, run_directory, dashboard, active)
+    except BaseException:
+        if active:
+            _terminate_jobs(active)
+        raise
+
+
+def _launch_madgraph_job(
+    arguments: argparse.Namespace, run_directory: Path
+) -> ActiveJob:
+    command = _madgraph_command(arguments, run_directory)
+    log_root = run_directory / "madgraph" / "orchestrator-logs"
+    log_root.mkdir(parents=True, exist_ok=True)
+    stdout = (log_root / "stdout.log").open("wb")
+    stderr = (log_root / "stderr.log").open("wb")
+    process = subprocess.Popen(
+        command,
+        stdout=stdout,
+        stderr=stderr,
+        start_new_session=True,
+    )
+    pseudo = Shard("madgraph", "gg", (), (), None, 4, False)
+    job = ActiveJob(
+        shard=pseudo,
+        final_multiplicity=None,
+        owned_mode=None,
+        command=command,
+        process=process,
+        stdout=stdout,
+        stderr=stderr,
+        sampler=memory_watchdog.ProcessTreeSampler(process.pid, process.pid),
+        claimed_cores=1,
+        detail="madgraph/initializing",
+    )
+    return job
+
+
+def _update_madgraph_job_detail(run_directory: Path, job: ActiveJob) -> None:
+    progress_path = _madgraph_progress_path(run_directory)
+    if not progress_path.is_file():
+        return
+    try:
+        progress = madgraph.load_runtime_progress(progress_path)
+        current = progress.get("current_cell")
+        if isinstance(current, Mapping):
+            job.detail = (
+                f"{current.get('family')}/{current.get('mode')}/"
+                f"n{current.get('n')}"
+            )
+        else:
+            job.detail = "madgraph/finalizing"
+    except madgraph.SelectedMadGraphError:
+        job.detail = "madgraph/progress-unavailable"
+
+
+def _poll_madgraph_jobs(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    active: list[ActiveJob],
+) -> str | None:
+    log_root = run_directory / "madgraph" / "orchestrator-logs"
+    for job in tuple(active):
+        _update_madgraph_job_detail(run_directory, job)
+        returncode = job.process.poll()
+        if returncode is None:
+            continue
+        job.stdout.close()
+        job.stderr.close()
+        active.remove(job)
+        if (
+            returncode != 0
+            or _matching_madgraph_overlay(arguments, run_directory) is None
+        ):
+            return f"MadGraph series exited {returncode}; inspect {log_root}"
+    return None
+
+
+def _wait_madgraph_jobs(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    dashboard: Dashboard,
+    active: list[ActiveJob],
+) -> None:
+    while active:
+        failure = _poll_madgraph_jobs(arguments, run_directory, active)
+        if failure is not None:
+            raise ProfilingError(failure)
+        master = _load_json(_master_report_path(run_directory), context="master report")
+        dashboard.update(
+            _selected_completed_cells(arguments, master)
+            + _madgraph_completed(arguments, run_directory),
+            phase="phase 4",
+            active=active,
+        )
+        if active:
+            time.sleep(arguments.poll_seconds)
+
+
+def _canonical_madgraph_overlay_authenticated(
+    arguments: argparse.Namespace,
+    run_directory: Path,
+    master: Mapping[str, Any],
+) -> bool:
+    """Use the strict publication boundary to skip a completed canonical overlay."""
+
+    if not _report_publication_profile(master):
+        return False
+    overlay = _matching_madgraph_overlay(arguments, run_directory)
+    if overlay is None:
+        return False
+    try:
+        publication.build_final_report(
+            campaign_path=_master_report_path(run_directory),
+            madgraph_overlay_path=overlay,
+        )
+    except publication.PublicationMergeError:
+        return False
+    return True
+
+
+def _lock_path(run_directory: Path, purpose: str) -> Path:
+    run_directory.parent.mkdir(parents=True, exist_ok=True)
+    digest = hashlib.sha256(str(run_directory).encode("utf-8")).hexdigest()[:12]
+    return run_directory.parent / (f".{run_directory.name}.{digest}.{purpose}.lock")
+
+
+def _acquire_render_lock(run_directory: Path) -> BinaryIO:
+    """Serialize render generations and refresh without blocking workers."""
+
+    path = _lock_path(run_directory, "render")
+    handle = path.open("a+b")
+    fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+    return handle
+
+
+def _acquire_execution_lock(run_directory: Path) -> BinaryIO:
+    # The lock must survive --refresh deleting/recreating the selected output.
+    # Keeping it beside the output closes the destructive race without locking
+    # unrelated profiling runs in the same parent directory.
+    path = _lock_path(run_directory, "orchestrator")
+    handle = path.open("a+b")
+    try:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError as error:
+        handle.close()
+        raise ProfilingError(f"another profiling driver holds {path}") from error
+    return handle
+
+
+def _render_phase_boundary(arguments: argparse.Namespace, run_directory: Path) -> Path:
+    _publish_master(arguments, run_directory)
+    return render_snapshot(arguments, renderer_preflight=False)
+
+
+def run_campaign(arguments: argparse.Namespace) -> Path:
+    if arguments.refresh:
+        _reject_refresh_symlinks(_configured_run_path(arguments))
+    run_directory = _run_directory(arguments)
+    if arguments.refresh:
+        _validate_refresh_target(run_directory)
+    lock = _acquire_execution_lock(run_directory)
+    dashboard: Dashboard | None = None
+    madgraph_jobs: list[ActiveJob] = []
+    try:
+        with _termination_signal_handlers():
+            if arguments.refresh:
+                removed = _safe_refresh(run_directory)
+                _diagnostic(
+                    (
+                        f"Removed recognized profiling output {run_directory}; "
+                        "restarting."
+                        if removed
+                        else f"No profiling output exists at {run_directory}; starting."
+                    ),
+                    colorama.Fore.YELLOW,
+                )
+            _create_or_resume_manifest(arguments, run_directory)
+            _preflight(arguments)
+            retried = _apply_retry_invalidation(arguments, run_directory)
+            if retried:
+                _diagnostic(
+                    f"Retrying {retried} failed/skipped profiling cell"
+                    f"{'' if retried == 1 else 's'}.",
+                    colorama.Fore.CYAN,
+                )
+            overwrite_pending = (
+                {
+                    _work_identity(work)
+                    for phase_number in _scheduled_phase_numbers(
+                        arguments, run_directory
+                    )
+                    for work in _phase_work_items(
+                        arguments, run_directory, phase_number
+                    )
+                }
+                if arguments.overwrite
+                else set()
+            )
+            if overwrite_pending:
+                _diagnostic(
+                    f"Overwriting {len(overwrite_pending)} selected profiling cell"
+                    f"{'' if len(overwrite_pending) == 1 else 's'} as each worker "
+                    "starts.",
+                    colorama.Fore.CYAN,
+                )
+            initial = _publish_master(arguments, run_directory)
+            requested = _requested_multiplicities(arguments, run_directory)
+            completed = _selected_completed_cells(
+                arguments,
+                initial,
+                multiplicities=requested,
+                ignored_cells=overwrite_pending,
+            )
+            total = (
+                completed
+                + _selected_pending_cells(
+                    arguments,
+                    initial,
+                    multiplicities=requested,
+                    ignored_cells=overwrite_pending,
+                )
+                + (
+                    len(_family_selection(arguments)) * len(requested)
+                    if _madgraph_requested(arguments, run_directory)
+                    else 0
+                )
+            )
+            dashboard = Dashboard(
+                total=total,
+                core_budget=arguments.cores,
+                helicity_workload=_helicity_workload(arguments),
+                batch_size=arguments.batch_size,
+            )
+            dashboard.update(completed, phase="initializing", active=())
+            madgraph_overlay_ready = False
+            for phase_number in _scheduled_phase_numbers(arguments, run_directory):
+                madgraph_overlay_ready = _phase(
+                    arguments,
+                    run_directory,
+                    phase_number,
+                    dashboard,
+                    background=madgraph_jobs,
+                    madgraph_overlay_ready=madgraph_overlay_ready,
+                    overwrite_pending=overwrite_pending,
+                ) or madgraph_overlay_ready
+                if not madgraph_overlay_ready:
+                    madgraph_overlay_ready = _maybe_start_madgraph_overlay(
+                        arguments, run_directory, madgraph_jobs
+                    )
+                _render_phase_boundary(arguments, run_directory)
+            terminal = _publish_master(arguments, run_directory)
+            if not _selected_master_complete(
+                arguments,
+                terminal,
+                multiplicities=requested,
+                ignored_cells=overwrite_pending,
+            ):
+                raise ProfilingError(
+                    "pyAmpliCol master did not complete the requested fill"
+                )
+            if _madgraph_requested(arguments, run_directory):
+                if madgraph_jobs:
+                    _wait_madgraph_jobs(
+                        arguments, run_directory, dashboard, madgraph_jobs
+                    )
+                    madgraph_overlay_ready = True
+                elif not madgraph_overlay_ready:
+                    _ensure_madgraph_overlay(arguments, run_directory, dashboard)
+                    madgraph_overlay_ready = True
+                if _canonical_madgraph_overlay_authenticated(
+                    arguments, run_directory, terminal
+                ):
+                    _diagnostic(
+                        "MadGraph overlay authenticated for the terminal snapshot.",
+                        colorama.Fore.CYAN,
+                    )
+            final_count = _selected_completed_cells(
+                arguments,
+                terminal,
+                multiplicities=requested,
+                ignored_cells=overwrite_pending,
+            ) + _madgraph_completed(arguments, run_directory)
+            dashboard.update(final_count, phase="rendering", active=())
+            pdf = render_snapshot(arguments, renderer_preflight=False)
+            message = (
+                "Completed profiling scan"
+                if terminal.get("status") in TERMINAL_STATUSES
+                else (
+                    "Completed requested line groups and multiplicities; "
+                    "campaign snapshot remains resumable"
+                )
+            )
+            _diagnostic(f"{message}: {pdf}", colorama.Fore.GREEN)
+            return pdf
+    except (KeyboardInterrupt, CampaignSignal):
+        with contextlib.suppress(Exception):
+            _publish_master(
+                arguments,
+                run_directory,
+                halt_reason="interrupted by user; rerun the same command to resume",
+            )
+        raise
+    finally:
+        if madgraph_jobs:
+            _terminate_jobs(madgraph_jobs)
+        if dashboard is not None:
+            dashboard.finish()
+        lock.close()
+
+
+def status_payload(arguments: argparse.Namespace) -> dict[str, Any]:
+    run_directory = _run_directory(arguments)
+    manifest_path = _manifest_path(run_directory)
+    master_path = _master_report_path(run_directory)
+    manifest = (
+        _load_json(manifest_path, context="profiling manifest")
+        if manifest_path.is_file()
+        else None
+    )
+    master = (
+        _load_json(master_path, context="master report")
+        if master_path.is_file()
+        else None
+    )
+    if manifest is not None:
+        identity_diff = _identity_diff(
+            manifest.get("identity"), _identity(arguments, run_directory)
+        )
+        differences = _immutable_identity_differences(identity_diff)
+        if differences:
+            preview = "\n  ".join(differences[:12])
+            raise ProfilingError(
+                "status measurement identity differs from the manifest:\n  " + preview
+            )
+    if master is not None:
+        _validate_render_workload(arguments, master)
+    return {
+        "kind": KIND,
+        "schema_version": SCHEMA_VERSION,
+        "helicity_workload": _helicity_workload(arguments),
+        "batch_size": arguments.batch_size,
+        "output": str(run_directory),
+        "requested_multiplicities": list(_selection(arguments)),
+        "requested_families": list(_family_selection(arguments)),
+        "requested_line_groups": list(_requested_line_groups(arguments, run_directory)),
+        "fill_history_multiplicities": (
+            _manifest_int_history(
+                manifest, "fill_history_multiplicities", "requested_multiplicities"
+            )
+            if manifest is not None
+            else []
+        ),
+        "line_group_history": (
+            _manifest_line_history(manifest) if manifest is not None else []
+        ),
+        "process_family_history": (
+            _manifest_family_history(manifest) if manifest is not None else []
+        ),
+        "manifest": str(manifest_path),
+        "manifest_available": manifest is not None,
+        "configured_tools": (
+            manifest.get("identity", {}).get("tools")
+            if isinstance(manifest, Mapping)
+            and isinstance(manifest.get("identity"), Mapping)
+            else None
+        ),
+        "master_report": str(master_path),
+        "campaign_status": master.get("status")
+        if master is not None
+        else "not-started",
+        "completed_requested_measurement_cells": (
+            _selected_completed_cells(arguments, master)
+            + _madgraph_completed(arguments, run_directory)
+            if master is not None
+            else 0
+        ),
+        "completed_measurement_cells": (
+            _completed_cells(master) + _madgraph_completed(arguments, run_directory)
+            if master is not None
+            else 0
+        ),
+        "dependencies": _dependency_status(arguments),
+        "madgraph_overlay": {
+            "path": str(_madgraph_overlay_path(run_directory)),
+            "applicable": (
+                _madgraph_requested(arguments, run_directory)
+                if manifest is not None
+                else "madgraph" in _line_selection(arguments)
+            ),
+            "helicity_workload": _helicity_workload(arguments),
+            "available": (
+                _matching_madgraph_overlay(arguments, run_directory) is not None
+            ),
+        },
+        "rendered_pdf": {
+            "path": str(
+                run_directory / "render" / "current" / _pdf_filename(arguments)
+            ),
+            "available": (
+                run_directory / "render" / "current" / _pdf_filename(arguments)
+            ).is_file(),
+        },
+        "canonical_pdf": {
+            "path": str(_canonical_pdf_path(arguments)),
+            "applicable": _canonical_publication_enabled(arguments),
+            "available": (
+                _canonical_publication_enabled(arguments)
+                and _canonical_pdf_path(arguments).is_file()
+            ),
+        },
+    }
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = _parser().parse_args(sys.argv[1:] if argv is None else argv)
+    enabled_color = _color_enabled(arguments)
+    colorama.init(strip=not enabled_color, convert=False)
+    try:
+        _validate_arguments(arguments)
+        if arguments.dry_run:
+            print(json.dumps(dry_run_plan(arguments), indent=2, sort_keys=True))
+            return 0
+        if arguments.status:
+            print(json.dumps(status_payload(arguments), indent=2, sort_keys=True))
+            return 0
+        if arguments.render:
+            pdf = render_snapshot(arguments)
+            print(pdf)
+            return 0
+        pdf = run_campaign(arguments)
+        print(pdf)
+        return 0
+    except CampaignSignal as error:
+        _diagnostic(
+            f"Profiling stopped by signal {error.signum}; rerun the same command "
+            "to resume."
+        )
+        return 128 + error.signum
+    except KeyboardInterrupt:
+        _diagnostic("Profiling interrupted; rerun the same command to resume.")
+        return 130
+    except (
+        OSError,
+        ProfilingError,
+        madgraph.SelectedMadGraphError,
+        study.StudyError,
+    ) as error:
+        _diagnostic(f"FFT profiling: {error}", colorama.Fore.RED)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/performance_report/__init__.py b/pyamplicol/tools/performance_report/__init__.py
new file mode 100644
index 0000000000..90be2eeefc
--- /dev/null
+++ b/pyamplicol/tools/performance_report/__init__.py
@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: 0BSD
+"""Three-mode performance-report support.
+
+The package deliberately keeps measurement, storage, scheduling, and rendering
+separate. ``src/pyamplicol/_profiling_campaign/result_tables.py`` is the
+canonical command entry point.
+"""
+
+from .catalog import MADGRAPH_FULL_COMPARISON_VIEWS, REPORT_CATALOG, ReportCatalog
+from .models import (
+    Accuracy,
+    ArtifactPolicy,
+    CellSpec,
+    ExecutionMode,
+    MatrixComparisonView,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+
+__all__ = [
+    "MADGRAPH_FULL_COMPARISON_VIEWS",
+    "REPORT_CATALOG",
+    "Accuracy",
+    "ArtifactPolicy",
+    "CellSpec",
+    "ExecutionMode",
+    "MatrixComparisonView",
+    "ModelKey",
+    "ReportCatalog",
+    "ResultStatus",
+    "Workload",
+]
diff --git a/pyamplicol/tools/performance_report/__main__.py b/pyamplicol/tools/performance_report/__main__.py
new file mode 100644
index 0000000000..71b9b00a85
--- /dev/null
+++ b/pyamplicol/tools/performance_report/__main__.py
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: 0BSD
+"""Installed worker entry point for packaged profiling campaigns."""
+
+from __future__ import annotations
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/performance_report/aggregate_audit.py b/pyamplicol/tools/performance_report/aggregate_audit.py
new file mode 100644
index 0000000000..29ad111183
--- /dev/null
+++ b/pyamplicol/tools/performance_report/aggregate_audit.py
@@ -0,0 +1,259 @@
+# SPDX-License-Identifier: 0BSD
+"""Authenticate a main commit assembled from audited architecture reports."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+from collections.abc import Mapping, Sequence
+from pathlib import Path, PurePosixPath
+
+from .service import validate_profile_name
+
+
+class AggregateAuditError(RuntimeError):
+    """The aggregate report commit is not an allowed report-only descendant."""
+
+
+_PROFILE_ROOT = PurePosixPath("docs/performance_reports")
+_FIXED_OUTPUTS = frozenset(
+    {
+        "pyAmpliCol.pdf",
+        "report_environment.json",
+        "report_environment.tex",
+        "result_validation_summary.tex",
+    }
+)
+
+
+def _git(
+    repo_root: Path,
+    arguments: Sequence[str],
+    *,
+    text: bool = True,
+) -> str | bytes:
+    completed = subprocess.run(
+        ("git", *arguments),
+        cwd=repo_root,
+        check=False,
+        capture_output=True,
+        text=text,
+    )
+    if completed.returncode != 0:
+        detail = (
+            completed.stderr.strip()
+            if text
+            else completed.stderr.decode("utf-8", errors="replace").strip()
+        )
+        raise AggregateAuditError(
+            f"git {' '.join(arguments)} failed: {detail or completed.returncode}"
+        )
+    return completed.stdout
+
+
+def _commit(repo_root: Path, revision: str) -> str:
+    output = _git(repo_root, ("rev-parse", "--verify", f"{revision}^{{commit}}"))
+    assert isinstance(output, str)
+    return output.strip()
+
+
+def _profile_for_output(path: str) -> str | None:
+    candidate = PurePosixPath(path)
+    try:
+        relative = candidate.relative_to(_PROFILE_ROOT)
+    except ValueError:
+        return None
+    if len(relative.parts) < 2:
+        return None
+    profile = relative.parts[0]
+    try:
+        validate_profile_name(profile)
+    except ValueError:
+        return None
+    output = PurePosixPath(*relative.parts[1:])
+    if len(output.parts) == 1:
+        name = output.name
+        if name in _FIXED_OUTPUTS:
+            return profile
+        if name.startswith("result_") and name.endswith("_table.tex"):
+            return profile
+        return None
+    if (
+        len(output.parts) == 2
+        and output.parts[0] == "results"
+        and output.name.endswith(".json")
+    ):
+        return profile
+    return None
+
+
+def _changed_paths(
+    repo_root: Path,
+    base_revision: str,
+    revision: str,
+) -> tuple[tuple[str, str], ...]:
+    raw = _git(
+        repo_root,
+        (
+            "diff",
+            "--no-renames",
+            "--name-status",
+            "-z",
+            f"{base_revision}..{revision}",
+        ),
+        text=False,
+    )
+    assert isinstance(raw, bytes)
+    fields = raw.split(b"\0")
+    if fields[-1:] == [b""]:
+        fields.pop()
+    if len(fields) % 2:
+        raise AggregateAuditError("malformed NUL-delimited git diff output")
+    changed: list[tuple[str, str]] = []
+    for offset in range(0, len(fields), 2):
+        status = fields[offset].decode("ascii", errors="strict")
+        path = fields[offset + 1].decode("utf-8", errors="surrogateescape")
+        changed.append((status, path))
+    return tuple(changed)
+
+
+def _tree_entry(repo_root: Path, revision: str, path: str) -> bytes:
+    raw = _git(
+        repo_root,
+        ("ls-tree", "-z", revision, "--", path),
+        text=False,
+    )
+    assert isinstance(raw, bytes)
+    return raw
+
+
+def _profile_tree(repo_root: Path, revision: str, profile: str) -> str:
+    path = (_PROFILE_ROOT / profile).as_posix()
+    output = _git(repo_root, ("rev-parse", f"{revision}:{path}"))
+    assert isinstance(output, str)
+    return output.strip()
+
+
+def audit_aggregate_report(
+    repo_root: Path,
+    *,
+    base_revision: str,
+    revision: str,
+    audited_profiles: Mapping[str, str],
+) -> dict[str, object]:
+    """Verify exact report-only paths and audited profile subtree identities."""
+
+    root = repo_root.expanduser().resolve(strict=True)
+    base = _commit(root, base_revision)
+    aggregate = _commit(root, revision)
+    _git(root, ("merge-base", "--is-ancestor", base, aggregate))
+
+    audited = {
+        validate_profile_name(profile): _commit(root, profile_revision)
+        for profile, profile_revision in audited_profiles.items()
+    }
+    if not audited:
+        raise AggregateAuditError("at least one audited profile is required")
+
+    changed = _changed_paths(root, base, aggregate)
+    changed_profiles: set[str] = set()
+    for status, path in changed:
+        if status not in {"A", "M"}:
+            raise AggregateAuditError(
+                f"aggregate path must be added or modified, not {status}: {path}"
+            )
+        profile = _profile_for_output(path)
+        if profile is None:
+            raise AggregateAuditError(
+                f"aggregate commit changes a non-publication output: {path}"
+            )
+        entry = _tree_entry(root, aggregate, path)
+        if not entry.startswith(b"100644 blob ") or not entry.endswith(b"\0"):
+            raise AggregateAuditError(
+                f"aggregate output is not one regular non-executable file: {path}"
+            )
+        changed_profiles.add(profile)
+
+    if not changed_profiles:
+        raise AggregateAuditError("aggregate commit contains no report outputs")
+    missing = changed_profiles.difference(audited)
+    if missing:
+        raise AggregateAuditError(
+            "aggregate changes profiles without audited revisions: "
+            + ", ".join(sorted(missing))
+        )
+
+    for profile in sorted(changed_profiles):
+        profile_revision = audited[profile]
+        _git(
+            root,
+            ("merge-base", "--is-ancestor", profile_revision, aggregate),
+        )
+        aggregate_tree = _profile_tree(root, aggregate, profile)
+        audited_tree = _profile_tree(root, profile_revision, profile)
+        if aggregate_tree != audited_tree:
+            raise AggregateAuditError(
+                f"aggregate {profile!r} subtree differs from its audited revision"
+            )
+
+    return {
+        "schema": "pyamplicol-report-aggregate-audit-v1",
+        "base_revision": base,
+        "aggregate_revision": aggregate,
+        "changed_path_count": len(changed),
+        "changed_profiles": sorted(changed_profiles),
+        "audited_profile_revisions": {
+            profile: audited[profile] for profile in sorted(changed_profiles)
+        },
+        "status": "ok",
+    }
+
+
+def _audited_profile(value: str) -> tuple[str, str]:
+    profile, separator, revision = value.partition("=")
+    if not separator or not revision:
+        raise argparse.ArgumentTypeError(
+            "audited profile must use PROFILE=REVISION"
+        )
+    try:
+        validated = validate_profile_name(profile)
+    except ValueError as error:
+        raise argparse.ArgumentTypeError(str(error)) from error
+    return validated, revision
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Authenticate a main commit assembled from audited reports."
+    )
+    parser.add_argument("--repo-root", type=Path, default=Path.cwd())
+    parser.add_argument("--base-revision", required=True)
+    parser.add_argument("--revision", default="HEAD")
+    parser.add_argument(
+        "--audited-profile",
+        action="append",
+        default=[],
+        type=_audited_profile,
+        metavar="PROFILE=REVISION",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = _parser().parse_args(argv)
+    audited = dict(arguments.audited_profile)
+    if len(audited) != len(arguments.audited_profile):
+        raise AggregateAuditError("each audited profile may appear only once")
+    result = audit_aggregate_report(
+        arguments.repo_root,
+        base_revision=arguments.base_revision,
+        revision=arguments.revision,
+        audited_profiles=audited,
+    )
+    print(json.dumps(result, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/performance_report/agreements.py b/pyamplicol/tools/performance_report/agreements.py
new file mode 100644
index 0000000000..fb3f235da0
--- /dev/null
+++ b/pyamplicol/tools/performance_report/agreements.py
@@ -0,0 +1,1135 @@
+# SPDX-License-Identifier: 0BSD
+"""Direct numerical-agreement edges required by the publication contract."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .models import (
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from .runner import (
+    ABSOLUTE_TOLERANCE,
+    CONDITIONED_COMPARISON_ABI,
+    INDEPENDENT_RELATIVE_TOLERANCE,
+    MADGRAPH_RELATIVE_TOLERANCE,
+    RELATIVE_TOLERANCE,
+    SelectorContract,
+    _real_nonnegative,
+    point_digest,
+    pointwise_validation,
+    validate_conditioned_comparison_record,
+)
+
+DIRECT_AGREEMENT_ABI = "pyamplicol-report-direct-agreement-v1"
+DIRECT_AGREEMENT_V1_ABI = DIRECT_AGREEMENT_ABI
+DIRECT_AGREEMENT_V2_ABI = "pyamplicol-report-direct-agreement-v2"
+LC_COMMON_COMPONENT_ABI = "pyamplicol-report-lc-common-component-v1"
+BUILTIN_UFO_RECURRENCE = "builtin-ufo-recurrence"
+Z_RECURRENCE_CROSS_MODE = "z-recurrence-cross-mode"
+LC_CROSS_LAYOUT_COMPONENT = "lc-cross-layout-component"
+LC_LEGACY_PYAMPLICOL_COMPONENT = "lc-legacy-pyamplicol-component"
+MADGRAPH_FULL_COLOUR = "madgraph-full-colour"
+DIRECT_AGREEMENT_KINDS = (
+    BUILTIN_UFO_RECURRENCE,
+    Z_RECURRENCE_CROSS_MODE,
+    LC_CROSS_LAYOUT_COMPONENT,
+    LC_LEGACY_PYAMPLICOL_COMPONENT,
+    MADGRAPH_FULL_COLOUR,
+)
+DIRECT_AGREEMENT_FIELD = "direct_agreements"
+MADGRAPH_COMPARISON_FIELD = "madgraph_comparison"
+MADGRAPH_COMPARISON_ABI = "pyamplicol-report-madgraph-comparison-v1"
+LC_COMMON_COMPONENT_FIELD = "lc_common_component"
+INDEPENDENT_AUTHORITY_ABI = "pyamplicol-report-independent-authority-v1"
+INDEPENDENT_AUTHORITY_FIELD = "independent_authority"
+STRICT_RELATIVE_TOLERANCE = RELATIVE_TOLERANCE
+STRICT_ABSOLUTE_TOLERANCE = ABSOLUTE_TOLERANCE
+
+
+class AgreementError(RuntimeError):
+    """A required direct numerical comparison could not be established."""
+
+
+@dataclass(frozen=True, slots=True)
+class AgreementEdge:
+    kind: str
+    baseline: CellSpec
+    candidate: CellSpec
+
+    @property
+    def value_kind(self) -> str:
+        return (
+            LC_COMMON_COMPONENT_FIELD
+            if self.kind in {LC_CROSS_LAYOUT_COMPONENT, LC_LEGACY_PYAMPLICOL_COMPONENT}
+            else "matrix_element"
+        )
+
+    @property
+    def relative_tolerance(self) -> float:
+        return agreement_relative_tolerance(self.kind)
+
+    @property
+    def required(self) -> bool:
+        """Whether this peer is a hard measurement prerequisite.
+
+        Original-AmpliCol LC agreement is useful as a legacy diagnostic when
+        available, but its absence must not censor an otherwise independently
+        validated pyAmpliCol measurement.  Z cross-mode recurrence is likewise
+        an availability-only numerical authority.  Model-source and
+        cross-layout pyAmpliCol edges remain mandatory.
+        """
+
+        return self.kind not in {
+            LC_LEGACY_PYAMPLICOL_COMPONENT,
+            Z_RECURRENCE_CROSS_MODE,
+        }
+
+
+def validation_baseline_is_required(
+    cell: CellSpec,
+    baseline: CellSpec | None,
+) -> bool:
+    """Return whether ``baseline`` is a hard numerical prerequisite.
+
+    Recurrence has its own resolved-sum and high-precision validation path, so
+    original AmpliCol is an optional diagnostic for recurrence.  Compiled and
+    eager comparison surfaces use recurrence as their availability-only
+    numerical authority rather than a hard prerequisite.
+    """
+
+    if baseline is None:
+        return False
+    if baseline.measurement.execution_mode is ExecutionMode.MADGRAPH:
+        # The MadGraph direct edge is the single authoritative boundary.
+        return False
+    if cell.measurement.execution_mode in {
+        ExecutionMode.COMPILED,
+        ExecutionMode.EAGER,
+    } and baseline.measurement.execution_mode in {
+        ExecutionMode.RECURRENCE,
+        ExecutionMode.AMPLICOL,
+    }:
+        return False
+    if baseline.measurement.execution_mode is not ExecutionMode.AMPLICOL:
+        return True
+    return cell.measurement.execution_mode is not ExecutionMode.RECURRENCE
+
+
+def _unique_cell(
+    matches: Sequence[CellSpec],
+    *,
+    context: str,
+) -> CellSpec:
+    if len(matches) != 1:
+        qualifier = "no" if not matches else "several"
+        raise AgreementError(f"{context} has {qualifier} matching report peer cells")
+    return matches[0]
+
+
+def _builtin_recurrence_peer(
+    cell: CellSpec,
+    cells: Sequence[CellSpec],
+) -> CellSpec | None:
+    if (
+        cell.measurement.execution_mode is not ExecutionMode.RECURRENCE
+        or cell.measurement.model is not ModelKey.UFO_SM
+    ):
+        return None
+    return _unique_cell(
+        tuple(
+            candidate
+            for candidate in cells
+            if candidate.measurement.execution_mode is ExecutionMode.RECURRENCE
+            and candidate.measurement.model is ModelKey.BUILTIN_SM
+            and candidate.measurement.accuracy is cell.measurement.accuracy
+            and candidate.process == cell.process
+            and candidate.process_key == cell.process_key
+            and candidate.n_final == cell.n_final
+            and candidate.workload is cell.workload
+            and (
+                (
+                    cell.dataset_id.startswith("matrix_recurrence_")
+                    and candidate.dataset_id.startswith("matrix_recurrence_builtin_sm_")
+                    and candidate.variant is None
+                )
+                or (
+                    cell.dataset_id == "z_external_sm"
+                    and candidate.dataset_id == "z_builtin_sm"
+                    and candidate.variant == "recurrence_jit_o2"
+                    and cell.variant == "recurrence_jit_o2"
+                )
+            )
+        ),
+        context=f"{cell.cell_id} built-in/UFO recurrence agreement",
+    )
+
+
+def _z_recurrence_peer(
+    cell: CellSpec,
+    cells: Sequence[CellSpec],
+) -> CellSpec | None:
+    if not cell.dataset_id.startswith("z_") or cell.measurement.execution_mode not in {
+        ExecutionMode.COMPILED,
+        ExecutionMode.EAGER,
+    }:
+        return None
+    return _unique_cell(
+        tuple(
+            candidate
+            for candidate in cells
+            if candidate.dataset_id == cell.dataset_id
+            and candidate.measurement.execution_mode is ExecutionMode.RECURRENCE
+            and candidate.measurement.model is cell.measurement.model
+            and candidate.measurement.accuracy is cell.measurement.accuracy
+            and candidate.variant == "recurrence_jit_o2"
+            and candidate.process == cell.process
+            and candidate.process_key == cell.process_key
+            and candidate.n_final == cell.n_final
+            and candidate.workload is cell.workload
+        ),
+        context=f"{cell.cell_id} Z recurrence agreement",
+    )
+
+
+def _lc_layout_peer(
+    cell: CellSpec,
+    cells: Sequence[CellSpec],
+    *,
+    catalog: ReportCatalog,
+) -> CellSpec | None:
+    if (
+        cell.measurement.accuracy is not Accuracy.LC
+        or cell.workload is not Workload.ALL_FLOW
+        or (
+            cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+            and not catalog.legacy_reference_available(cell)
+        )
+    ):
+        return None
+    return _unique_cell(
+        tuple(
+            candidate
+            for candidate in cells
+            if candidate.dataset_id == cell.dataset_id
+            and candidate.process == cell.process
+            and candidate.process_key == cell.process_key
+            and candidate.n_final == cell.n_final
+            and candidate.measurement == cell.measurement
+            and candidate.variant == cell.variant
+            and candidate.workload is Workload.SELECTED_FLOW
+        ),
+        context=f"{cell.cell_id} LC cross-layout agreement",
+    )
+
+
+def _lc_legacy_peer(
+    cell: CellSpec,
+    cells: Sequence[CellSpec],
+    *,
+    catalog: ReportCatalog,
+) -> CellSpec | None:
+    if (
+        cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        or cell.measurement.accuracy is not Accuracy.LC
+        or cell.workload is not Workload.ALL_FLOW
+        or not catalog.legacy_reference_available(cell)
+    ):
+        return None
+    return _unique_cell(
+        tuple(
+            candidate
+            for candidate in cells
+            if candidate.dataset_id == "reference_amplicol_lc"
+            and candidate.measurement.execution_mode is ExecutionMode.AMPLICOL
+            and candidate.measurement.accuracy is Accuracy.LC
+            and candidate.process == cell.process
+            and candidate.process_key == cell.process_key
+            and candidate.n_final == cell.n_final
+            and candidate.workload is Workload.ALL_FLOW
+        ),
+        context=f"{cell.cell_id} legacy/pyAmpliCol LC agreement",
+    )
+
+
+def _madgraph_full_colour_peer(
+    cell: CellSpec,
+    cells: Sequence[CellSpec],
+) -> CellSpec | None:
+    if (
+        cell.measurement.execution_mode
+        not in {
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.COMPILED,
+            ExecutionMode.EAGER,
+            ExecutionMode.ON_THE_FLY,
+        }
+        or cell.measurement.model is not ModelKey.UFO_SM
+        or cell.measurement.accuracy is not Accuracy.FULL
+        or cell.workload is not Workload.CONTRACTED
+        or cell.dataset_id
+        not in {
+            "matrix_recurrence_ufo_sm_full",
+            "matrix_compiled_ufo_sm_full",
+            "matrix_eager_ufo_sm_full",
+            "matrix_on_the_fly_ufo_sm_full",
+        }
+    ):
+        return None
+    return _unique_cell(
+        tuple(
+            candidate
+            for candidate in cells
+            if candidate.dataset_id == "reference_madgraph_full"
+            and candidate.measurement.execution_mode is ExecutionMode.MADGRAPH
+            and candidate.process == cell.process
+            and candidate.process_key == cell.process_key
+            and candidate.n_final == cell.n_final
+            and candidate.workload is Workload.CONTRACTED
+        ),
+        context=f"{cell.cell_id} MadGraph full-colour agreement",
+    )
+
+
+def agreement_relative_tolerance(kind: str) -> float:
+    """Return the independent tolerance assigned to one direct-edge family."""
+
+    if kind == LC_LEGACY_PYAMPLICOL_COMPONENT:
+        return INDEPENDENT_RELATIVE_TOLERANCE
+    if kind == MADGRAPH_FULL_COLOUR:
+        return MADGRAPH_RELATIVE_TOLERANCE
+    if kind in DIRECT_AGREEMENT_KINDS:
+        return STRICT_RELATIVE_TOLERANCE
+    raise AgreementError(f"unsupported direct-agreement kind {kind!r}")
+
+
+def madgraph_candidate_precision(cell: CellSpec) -> int:
+    """Return the precision supported by one full-colour MadGraph candidate."""
+
+    return 16 if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY else 200
+
+
+def incoming_agreement_edges(
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[AgreementEdge, ...]:
+    """Return the exact direct-comparison peers consumed by ``cell``."""
+
+    cells = catalog.measurement_cells()
+    edges: list[AgreementEdge] = []
+    builtin = _builtin_recurrence_peer(cell, cells)
+    if builtin is not None:
+        edges.append(AgreementEdge(BUILTIN_UFO_RECURRENCE, builtin, cell))
+    recurrence = _z_recurrence_peer(cell, cells)
+    if recurrence is not None:
+        edges.append(AgreementEdge(Z_RECURRENCE_CROSS_MODE, recurrence, cell))
+    layout = _lc_layout_peer(cell, cells, catalog=catalog)
+    if layout is not None:
+        edges.append(AgreementEdge(LC_CROSS_LAYOUT_COMPONENT, layout, cell))
+    legacy = _lc_legacy_peer(cell, cells, catalog=catalog)
+    if legacy is not None:
+        edges.append(AgreementEdge(LC_LEGACY_PYAMPLICOL_COMPONENT, legacy, cell))
+    madgraph = _madgraph_full_colour_peer(cell, cells)
+    if madgraph is not None:
+        edges.append(AgreementEdge(MADGRAPH_FULL_COLOUR, madgraph, cell))
+    return tuple(
+        sorted(
+            edges,
+            key=lambda edge: (
+                DIRECT_AGREEMENT_KINDS.index(edge.kind),
+                edge.baseline.cell_id,
+            ),
+        )
+    )
+
+
+def independent_numerical_authorities(
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSpec, ...]:
+    """Return the canonical ordered independent-authority chain.
+
+    This identity is shared by planning, the isolated worker, strict result
+    validation, and late reconciliation.  Original AmpliCol is deliberately
+    excluded: it remains a report diagnostic, but no longer certifies a
+    candidate after MadGraph became the authoritative full-colour boundary.
+    """
+
+    if cell.measurement.execution_mode not in {
+        ExecutionMode.COMPILED,
+        ExecutionMode.EAGER,
+    }:
+        return ()
+    candidates: list[CellSpec] = []
+    baseline = catalog.validation_baseline_cell(cell)
+    recurrence_peer = next(
+        (
+            edge.baseline
+            for edge in incoming_agreement_edges(cell, catalog=catalog)
+            if edge.kind == Z_RECURRENCE_CROSS_MODE
+        ),
+        None,
+    )
+    recurrence = (
+        recurrence_peer
+        if recurrence_peer is not None
+        else (
+            baseline
+            if baseline is not None
+            and baseline.measurement.execution_mode is ExecutionMode.RECURRENCE
+            else None
+        )
+    )
+    if recurrence is not None:
+        candidates.append(recurrence)
+    return tuple(candidates)
+
+
+def requires_independent_numerical_authority(
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> bool:
+    """Whether ``cell`` needs an external numerical authority to become OK.
+
+    This is a success-classification rule, not a hard scheduling dependency.
+    Standalone absolute benchmark surfaces have no catalog authority chain and
+    are certified by their own strict internal validation contract.  Matrix
+    and Z compiled/eager comparison surfaces do expose such a chain and remain
+    unverified until one of its endpoints agrees.
+    """
+
+    return bool(independent_numerical_authorities(cell, catalog=catalog))
+
+
+def agreement_edges(
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    maximum_n_final: int | None = None,
+) -> tuple[AgreementEdge, ...]:
+    selected = tuple(
+        cell
+        for cell in catalog.measurement_cells()
+        if maximum_n_final is None or cell.n_final <= maximum_n_final
+    )
+    selected_ids = {cell.cell_id for cell in selected}
+    return tuple(
+        edge
+        for cell in sorted(selected, key=lambda item: item.cell_id)
+        for edge in incoming_agreement_edges(cell, catalog=catalog)
+        if edge.baseline.cell_id in selected_ids
+    )
+
+
+def _lc_component_record(
+    cell: CellSpec,
+    contract: SelectorContract,
+    value: float,
+) -> dict[str, object]:
+    return {
+        "abi": LC_COMMON_COMPONENT_ABI,
+        "cell_id": cell.cell_id,
+        "value": value,
+        "point_digest": contract.point_digest,
+        "helicity_ids": list(contract.all_flow_helicity_ids),
+        "color_flow_ids": list(contract.selected_color_flow_ids),
+    }
+
+
+def evaluate_lc_common_component(
+    runtime: object,
+    points: object,
+    *,
+    cell: CellSpec,
+    contract: SelectorContract,
+) -> dict[str, object]:
+    """Evaluate the selector intersection common to both LC layouts."""
+
+    # Selected-flow topology replay exposes its complete physical-helicity
+    # axis, but need not have an independently executable singleton lane.
+    # Resolve that same workload, then select the untimed comparison by ID.
+    full_helicity_axis = cell.workload is Workload.SELECTED_FLOW
+    resolved = runtime.evaluate_resolved(  # type: ignore[attr-defined]
+        points,
+        precision=16,
+        helicities=(
+            None if full_helicity_axis else contract.runtime_all_flow_helicity_ids
+        ),
+        color_flows=contract.selected_color_flow_ids,
+    )
+    helicity_ids = tuple(getattr(resolved, "helicity_ids", ()))
+    color_ids = tuple(getattr(resolved, "color_ids", ()))
+    expected_helicity_ids = contract.runtime_all_flow_helicity_ids
+    if (
+        len(expected_helicity_ids) != 1
+        or len(set(helicity_ids)) != len(helicity_ids)
+        or expected_helicity_ids[0] not in helicity_ids
+        or (not full_helicity_axis and helicity_ids != expected_helicity_ids)
+    ):
+        raise AgreementError(
+            f"{cell.cell_id} LC common component has a different helicity axis"
+        )
+    if color_ids != contract.selected_color_flow_ids:
+        raise AgreementError(
+            f"{cell.cell_id} LC common component has a different color-flow axis"
+        )
+    values = getattr(resolved, "values", None)
+    try:
+        helicity_index = helicity_ids.index(expected_helicity_ids[0])
+        raw_value = values[0][helicity_index][0]
+        if (
+            len(values) != 1
+            or len(values[0]) != len(helicity_ids)
+            or any(len(row) != 1 for row in values[0])
+        ):
+            raise IndexError
+    except (IndexError, TypeError) as error:
+        raise AgreementError(
+            f"{cell.cell_id} LC common component is not a scalar"
+        ) from error
+    return _lc_component_record(
+        cell,
+        contract,
+        _real_nonnegative(raw_value),
+    )
+
+
+def legacy_lc_common_component(
+    cell: CellSpec,
+    contract: SelectorContract,
+    value: float,
+) -> dict[str, object]:
+    """Shape an independently probed original-AmpliCol LC row component."""
+
+    return _lc_component_record(cell, contract, float(value))
+
+
+def _measurement_number(
+    measurement: Mapping[str, object],
+    *,
+    edge: AgreementEdge,
+    role: str,
+) -> float:
+    if edge.kind == MADGRAPH_FULL_COLOUR and role == "candidate":
+        validation = measurement.get("validation")
+        comparison = (
+            validation.get(MADGRAPH_COMPARISON_FIELD)
+            if isinstance(validation, Mapping)
+            else None
+        )
+        if not isinstance(comparison, Mapping):
+            raise AgreementError(f"{edge.candidate.cell_id} has no MadGraph comparison")
+        value = comparison.get("candidate")
+    elif edge.value_kind == "matrix_element":
+        value = measurement.get("matrix_element")
+    else:
+        validation = measurement.get("validation")
+        if not isinstance(validation, Mapping):
+            raise AgreementError(
+                f"{edge.candidate.cell_id} {role} validation is unavailable"
+            )
+        observation = validation.get(LC_COMMON_COMPONENT_FIELD)
+        if not isinstance(observation, Mapping):
+            raise AgreementError(
+                f"{edge.candidate.cell_id} {role} LC common component is unavailable"
+            )
+        value = observation.get("value")
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise AgreementError(
+            f"{edge.candidate.cell_id} {role} {edge.value_kind} is not numeric"
+        )
+    number = float(value)
+    if not math.isfinite(number):
+        raise AgreementError(
+            f"{edge.candidate.cell_id} {role} {edge.value_kind} is not finite"
+        )
+    return number
+
+
+def _agreement_source_digest(value: object) -> str:
+    return hashlib.sha256(
+        json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+
+
+def _measurement_point_digest(measurement: Mapping[str, object]) -> str:
+    selector = measurement.get("selector_contract")
+    if isinstance(selector, Mapping):
+        raw = selector.get("point_digest")
+        if isinstance(raw, str):
+            return raw
+    validation = measurement.get("validation")
+    if isinstance(validation, Mapping):
+        raw = validation.get("point_digest")
+        if isinstance(raw, str):
+            return raw
+    provenance = measurement.get("provenance")
+    if isinstance(provenance, Mapping) and "report_momenta" in provenance:
+        return point_digest(provenance["report_momenta"])
+    raise AgreementError("direct agreement measurement has no point identity")
+
+
+def _measurement_scale(
+    measurement: Mapping[str, object],
+    *,
+    edge: AgreementEdge,
+    role: str,
+    number: float,
+) -> tuple[float, str, str]:
+    validation = measurement.get("validation")
+    if edge.value_kind == LC_COMMON_COMPONENT_FIELD and isinstance(validation, Mapping):
+        component = validation.get(LC_COMMON_COMPONENT_FIELD)
+        if isinstance(component, Mapping):
+            return (
+                abs(number),
+                "authority-component-magnitude",
+                _agreement_source_digest(component),
+            )
+    if (
+        edge.kind != MADGRAPH_FULL_COLOUR
+        and edge.value_kind == "matrix_element"
+        and isinstance(validation, Mapping)
+    ):
+        resolved = validation.get("resolved_sum")
+        if isinstance(resolved, Mapping):
+            records = resolved.get("points")
+            source = resolved.get("resolved_source_sha256")
+            if (
+                isinstance(records, list)
+                and len(records) == 1
+                and isinstance(records[0], Mapping)
+                and isinstance(source, str)
+            ):
+                raw_scale = records[0].get("candidate_scale")
+                if (
+                    not isinstance(raw_scale, bool)
+                    and isinstance(raw_scale, (int, float))
+                    and math.isfinite(float(raw_scale))
+                    and float(raw_scale) >= abs(number)
+                ):
+                    return float(raw_scale), "resolved-component-l1", source
+    stable_validation = (
+        {key: item for key, item in validation.items() if key != DIRECT_AGREEMENT_FIELD}
+        if isinstance(validation, Mapping)
+        else validation
+    )
+    source = _agreement_source_digest(
+        {
+            "role": role,
+            "value_kind": edge.value_kind,
+            "value": number,
+            "selector_contract": measurement.get("selector_contract"),
+            "validation": stable_validation,
+            "provenance": measurement.get("provenance"),
+        }
+    )
+    return abs(number), "authority-value-magnitude", source
+
+
+def madgraph_comparison_record(
+    edge: AgreementEdge,
+    *,
+    candidate: float,
+    baseline_measurement: Mapping[str, object],
+    point_identity: str,
+) -> dict[str, object]:
+    """Build strict candidate-versus-binary64-MadGraph evidence."""
+
+    if edge.kind != MADGRAPH_FULL_COLOUR:
+        raise AgreementError("MadGraph comparison requires a MadGraph edge")
+    baseline = _measurement_number(
+        baseline_measurement,
+        edge=edge,
+        role="baseline",
+    )
+    baseline_point = _measurement_point_digest(baseline_measurement)
+    if point_identity != baseline_point:
+        raise AgreementError("MadGraph comparison points differ")
+    candidate_precision = madgraph_candidate_precision(edge.candidate)
+    candidate_source = _agreement_source_digest(
+        {
+            "cell_id": edge.candidate.cell_id,
+            "precision": candidate_precision,
+            "point_digest": point_identity,
+            "value": candidate,
+        }
+    )
+    baseline_source = _agreement_source_digest(
+        {
+            "cell_id": edge.baseline.cell_id,
+            "point_digest": baseline_point,
+            "matrix_element": baseline,
+            "provenance": baseline_measurement.get("provenance"),
+        }
+    )
+    identity = {
+        "candidate_cell_id": edge.candidate.cell_id,
+        "baseline_cell_id": edge.baseline.cell_id,
+        "candidate_precision": candidate_precision,
+        "baseline_precision": "binary64",
+        "point_digest": point_identity,
+    }
+    comparison = pointwise_validation(
+        candidate,
+        baseline,
+        relative_tolerance=MADGRAPH_RELATIVE_TOLERANCE,
+        candidate_scale=abs(candidate),
+        baseline_scale=abs(baseline),
+        candidate_scale_source=f"p{candidate_precision}-value-magnitude",
+        baseline_scale_source="madgraph-binary64-value-magnitude",
+        comparison_binding={
+            "point_digest": point_identity,
+            "selector_component_identity": identity,
+            "selector_component_sha256": _agreement_source_digest(identity),
+            "candidate_source_sha256": candidate_source,
+            "baseline_source_sha256": baseline_source,
+        },
+    )
+    return {
+        "abi": MADGRAPH_COMPARISON_ABI,
+        "candidate_cell_id": edge.candidate.cell_id,
+        "baseline_cell_id": edge.baseline.cell_id,
+        "candidate_precision": candidate_precision,
+        "baseline_precision": "binary64",
+        **{key: value for key, value in comparison.items() if key != "abi"},
+    }
+
+
+def validate_madgraph_comparison_record(
+    value: object,
+    *,
+    expected_candidate_id: str | None = None,
+    expected_candidate_precision: int | None = None,
+) -> None:
+    if not isinstance(value, Mapping):
+        raise ValueError(f"{MADGRAPH_COMPARISON_FIELD} must be an object")
+    identity_fields = {
+        "abi",
+        "candidate_cell_id",
+        "baseline_cell_id",
+        "candidate_precision",
+        "baseline_precision",
+    }
+    comparison_fields = {
+        "status",
+        "candidate",
+        "baseline",
+        "candidate_scale",
+        "baseline_scale",
+        "candidate_scale_source",
+        "baseline_scale_source",
+        "comparison_scale",
+        "absolute_difference",
+        "relative_difference",
+        "conditioned_residual",
+        "error_bound",
+        "relative_tolerance",
+        "comparison_binding",
+    }
+    if set(value) != identity_fields | comparison_fields:
+        raise ValueError(f"{MADGRAPH_COMPARISON_FIELD} fields differ from the ABI")
+    candidate_id = value.get("candidate_cell_id")
+    baseline_id = value.get("baseline_cell_id")
+    if (
+        value.get("abi") != MADGRAPH_COMPARISON_ABI
+        or not isinstance(candidate_id, str)
+        or not candidate_id
+        or (
+            expected_candidate_id is not None
+            and candidate_id != expected_candidate_id
+        )
+        or not isinstance(baseline_id, str)
+        or not baseline_id
+        or value.get("candidate_precision") not in {16, 200}
+        or (
+            expected_candidate_precision is not None
+            and value.get("candidate_precision") != expected_candidate_precision
+        )
+        or value.get("baseline_precision") != "binary64"
+    ):
+        raise ValueError(f"{MADGRAPH_COMPARISON_FIELD} identity is invalid")
+    comparison = {
+        key: item for key, item in value.items() if key not in identity_fields
+    }
+    comparison["abi"] = CONDITIONED_COMPARISON_ABI
+    validate_conditioned_comparison_record(comparison, require_binding=True)
+    if float(comparison["relative_tolerance"]) != MADGRAPH_RELATIVE_TOLERANCE:
+        raise ValueError(f"{MADGRAPH_COMPARISON_FIELD} tolerance is invalid")
+
+
+def direct_agreement_record(
+    edge: AgreementEdge,
+    *,
+    candidate_measurement: Mapping[str, object],
+    baseline_measurement: Mapping[str, object],
+) -> dict[str, object]:
+    candidate = _measurement_number(
+        candidate_measurement,
+        edge=edge,
+        role="candidate",
+    )
+    baseline = _measurement_number(
+        baseline_measurement,
+        edge=edge,
+        role="baseline",
+    )
+    candidate_scale, candidate_scale_source, candidate_source = _measurement_scale(
+        candidate_measurement,
+        edge=edge,
+        role="candidate",
+        number=candidate,
+    )
+    baseline_scale, baseline_scale_source, baseline_source = _measurement_scale(
+        baseline_measurement,
+        edge=edge,
+        role="baseline",
+        number=baseline,
+    )
+    candidate_point = _measurement_point_digest(candidate_measurement)
+    baseline_point = _measurement_point_digest(baseline_measurement)
+    if candidate_point != baseline_point:
+        raise AgreementError("direct agreement points differ")
+    selector_identity = {
+        "candidate_cell_id": edge.candidate.cell_id,
+        "baseline_cell_id": edge.baseline.cell_id,
+        "candidate_accuracy": edge.candidate.measurement.accuracy.value,
+        "baseline_accuracy": edge.baseline.measurement.accuracy.value,
+        "candidate_workload": edge.candidate.workload.value,
+        "baseline_workload": edge.baseline.workload.value,
+        "value_kind": edge.value_kind,
+        "candidate_selector": candidate_measurement.get("selector_contract"),
+        "baseline_selector": baseline_measurement.get("selector_contract"),
+    }
+    comparison = pointwise_validation(
+        candidate,
+        baseline,
+        relative_tolerance=edge.relative_tolerance,
+        candidate_scale=candidate_scale,
+        baseline_scale=baseline_scale,
+        candidate_scale_source=candidate_scale_source,
+        baseline_scale_source=baseline_scale_source,
+        comparison_binding={
+            "point_digest": candidate_point,
+            "selector_component_identity": selector_identity,
+            "selector_component_sha256": _agreement_source_digest(selector_identity),
+            "candidate_source_sha256": candidate_source,
+            "baseline_source_sha256": baseline_source,
+        },
+    )
+    comparison.pop("abi")
+    return {
+        "abi": DIRECT_AGREEMENT_V2_ABI,
+        "edge_kind": edge.kind,
+        "value_kind": edge.value_kind,
+        "baseline_cell_id": edge.baseline.cell_id,
+        "candidate_cell_id": edge.candidate.cell_id,
+        **comparison,
+    }
+
+
+def validate_direct_agreement_records(
+    value: object,
+    *,
+    expected_candidate_id: str | None = None,
+) -> None:
+    """Validate the complete per-measurement direct-agreement wire contract."""
+
+    if not isinstance(value, list):
+        raise ValueError(f"{DIRECT_AGREEMENT_FIELD} must be an array")
+    identity_fields = {
+        "abi",
+        "edge_kind",
+        "value_kind",
+        "baseline_cell_id",
+        "candidate_cell_id",
+    }
+    v1_fields = identity_fields | {
+        "status",
+        "candidate",
+        "baseline",
+        "absolute_difference",
+        "relative_difference",
+        "relative_tolerance",
+        "absolute_tolerance",
+    }
+    v2_fields = identity_fields | {
+        "status",
+        "candidate",
+        "baseline",
+        "candidate_scale",
+        "baseline_scale",
+        "candidate_scale_source",
+        "baseline_scale_source",
+        "comparison_scale",
+        "absolute_difference",
+        "relative_difference",
+        "conditioned_residual",
+        "error_bound",
+        "relative_tolerance",
+        "comparison_binding",
+    }
+    seen: set[tuple[str, str, str]] = set()
+    for index, raw in enumerate(value):
+        if not isinstance(raw, Mapping):
+            raise ValueError(f"{DIRECT_AGREEMENT_FIELD}[{index}] must be an object")
+        abi = raw.get("abi")
+        expected_fields = v2_fields if abi == DIRECT_AGREEMENT_V2_ABI else v1_fields
+        if set(raw) != expected_fields:
+            raise ValueError(
+                f"{DIRECT_AGREEMENT_FIELD}[{index}] fields differ from the ABI"
+            )
+        kind = raw.get("edge_kind")
+        if not isinstance(kind, str) or kind not in DIRECT_AGREEMENT_KINDS:
+            raise ValueError(
+                f"{DIRECT_AGREEMENT_FIELD}[{index}] edge kind is unsupported"
+            )
+        expected_value_kind = (
+            LC_COMMON_COMPONENT_FIELD
+            if kind in {LC_CROSS_LAYOUT_COMPONENT, LC_LEGACY_PYAMPLICOL_COMPONENT}
+            else "matrix_element"
+        )
+        baseline_id = raw.get("baseline_cell_id")
+        candidate_id = raw.get("candidate_cell_id")
+        if (
+            abi not in {DIRECT_AGREEMENT_V2_ABI, DIRECT_AGREEMENT_V1_ABI}
+            or raw.get("value_kind") != expected_value_kind
+            or not isinstance(baseline_id, str)
+            or not baseline_id
+            or not isinstance(candidate_id, str)
+            or not candidate_id
+            or (
+                expected_candidate_id is not None
+                and candidate_id != expected_candidate_id
+            )
+        ):
+            raise ValueError(f"{DIRECT_AGREEMENT_FIELD}[{index}] identity is invalid")
+        key = (kind, baseline_id, candidate_id)
+        if key in seen:
+            raise ValueError(f"{DIRECT_AGREEMENT_FIELD}[{index}] duplicates an edge")
+        seen.add(key)
+        expected_relative_tolerance = agreement_relative_tolerance(kind)
+        comparison = {
+            key: item for key, item in raw.items() if key not in identity_fields
+        }
+        if abi == DIRECT_AGREEMENT_V2_ABI:
+            comparison["abi"] = CONDITIONED_COMPARISON_ABI
+        try:
+            validate_conditioned_comparison_record(
+                comparison,
+                require_binding=abi == DIRECT_AGREEMENT_V2_ABI,
+            )
+        except ValueError as error:
+            raise ValueError(
+                f"{DIRECT_AGREEMENT_FIELD}[{index}] numerical record is invalid"
+            ) from error
+        if float(comparison["relative_tolerance"]) != expected_relative_tolerance:
+            raise ValueError(f"{DIRECT_AGREEMENT_FIELD}[{index}] tolerance is invalid")
+        if (
+            abi == DIRECT_AGREEMENT_V1_ABI
+            and float(comparison["absolute_tolerance"]) != STRICT_ABSOLUTE_TOLERANCE
+        ):
+            raise ValueError(
+                f"{DIRECT_AGREEMENT_FIELD}[{index}] legacy tolerance is invalid"
+            )
+        if (
+            raw.get("status") != ResultStatus.OK.value
+            and kind != LC_LEGACY_PYAMPLICOL_COMPONENT
+        ):
+            raise ValueError(
+                f"{DIRECT_AGREEMENT_FIELD}[{index}] agreement is not successful"
+            )
+
+
+def validate_lc_common_component(
+    value: object,
+    *,
+    expected_cell_id: str | None = None,
+    selector_contract: object = None,
+) -> None:
+    """Validate one LC component record before it is admitted to the cache."""
+
+    if not isinstance(value, Mapping):
+        raise ValueError(f"{LC_COMMON_COMPONENT_FIELD} must be an object")
+    expected_fields = {
+        "abi",
+        "cell_id",
+        "value",
+        "point_digest",
+        "helicity_ids",
+        "color_flow_ids",
+    }
+    if set(value) != expected_fields:
+        raise ValueError(f"{LC_COMMON_COMPONENT_FIELD} fields differ from the ABI")
+    cell_id = value.get("cell_id")
+    number = value.get("value")
+    point_digest = value.get("point_digest")
+    helicity_ids = value.get("helicity_ids")
+    color_flow_ids = value.get("color_flow_ids")
+    if (
+        value.get("abi") != LC_COMMON_COMPONENT_ABI
+        or not isinstance(cell_id, str)
+        or not cell_id
+        or (expected_cell_id is not None and cell_id != expected_cell_id)
+        or isinstance(number, bool)
+        or not isinstance(number, (int, float))
+        or not math.isfinite(float(number))
+        or not isinstance(point_digest, str)
+        or len(point_digest) != 64
+        or any(character not in "0123456789abcdef" for character in point_digest)
+        or not isinstance(helicity_ids, list)
+        or not helicity_ids
+        or any(not isinstance(item, str) or not item for item in helicity_ids)
+        or len(set(helicity_ids)) != len(helicity_ids)
+        or not isinstance(color_flow_ids, list)
+        or not color_flow_ids
+        or any(not isinstance(item, str) or not item for item in color_flow_ids)
+        or len(set(color_flow_ids)) != len(color_flow_ids)
+    ):
+        raise ValueError(f"{LC_COMMON_COMPONENT_FIELD} record is invalid")
+    if selector_contract is not None:
+        try:
+            selector = SelectorContract.from_mapping(
+                selector_contract  # type: ignore[arg-type]
+            )
+        except (TypeError, ValueError, RuntimeError) as error:
+            raise ValueError("selector contract is invalid") from error
+        if (
+            point_digest != selector.point_digest
+            or helicity_ids != list(selector.all_flow_helicity_ids)
+            or color_flow_ids != list(selector.selected_color_flow_ids)
+        ):
+            raise ValueError(
+                f"{LC_COMMON_COMPONENT_FIELD} is not bound to the selector"
+            )
+
+
+def attach_direct_agreements(
+    cell: CellSpec,
+    measurement: dict[str, object],
+    peers: Mapping[str, Mapping[str, object]],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> None:
+    """Attach every incoming direct edge and make authoritative failures terminal."""
+
+    initial_status = measurement.get("status")
+    if initial_status not in {
+        ResultStatus.OK.value,
+        ResultStatus.UNVERIFIED.value,
+    }:
+        return
+    validation = measurement.get("validation")
+    if not isinstance(validation, Mapping):
+        raise AgreementError(f"{cell.cell_id} has no validation record")
+    mutable_validation = dict(validation)
+    expected = incoming_agreement_edges(cell, catalog=catalog)
+    expected_peer_ids = {edge.baseline.cell_id for edge in expected}
+    required_peer_ids = {edge.baseline.cell_id for edge in expected if edge.required}
+    observed_peer_ids = set(peers)
+    if not required_peer_ids.issubset(observed_peer_ids) or not (
+        observed_peer_ids <= expected_peer_ids
+    ):
+        raise AgreementError(
+            f"{cell.cell_id} direct-agreement peers differ: "
+            f"required={sorted(required_peer_ids)}, "
+            f"allowed={sorted(expected_peer_ids)}, "
+            f"observed={sorted(observed_peer_ids)}"
+        )
+    records: list[dict[str, object]] = []
+    for edge in expected:
+        if edge.baseline.cell_id not in peers:
+            assert not edge.required
+            continue
+        peer = peers[edge.baseline.cell_id]
+        if peer.get("status") != ResultStatus.OK.value:
+            raise AgreementError(
+                f"{cell.cell_id} peer {edge.baseline.cell_id} is not successful"
+            )
+        if measurement.get("selector_contract") != peer.get("selector_contract"):
+            raise AgreementError(
+                f"{cell.cell_id} selector contract differs from direct peer "
+                f"{edge.baseline.cell_id}"
+            )
+        records.append(
+            direct_agreement_record(
+                edge,
+                candidate_measurement=measurement,
+                baseline_measurement=peer,
+            )
+        )
+    mutable_validation[DIRECT_AGREEMENT_FIELD] = records
+    failed = any(
+        record["status"] != ResultStatus.OK.value
+        and record["edge_kind"] != LC_LEGACY_PYAMPLICOL_COMPONENT
+        for record in records
+    )
+    if failed:
+        mutable_validation["status"] = ResultStatus.VALIDATION_FAILED.value
+        measurement["status"] = ResultStatus.VALIDATION_FAILED.value
+        measurement["failure"] = {
+            "kind": "MeasurementValidationError",
+            "message": "required direct numerical agreement failed",
+        }
+    elif initial_status == ResultStatus.UNVERIFIED.value:
+        # Hard model/layout/provider agreements remain mandatory even when the
+        # independent recurrence numerical authority is unavailable.
+        # Passing them is necessary but deliberately cannot promote a
+        # diagnostic candidate to a reusable success.
+        mutable_validation["status"] = ResultStatus.UNVERIFIED.value
+    measurement["validation"] = mutable_validation
+
+
+__all__ = [
+    "BUILTIN_UFO_RECURRENCE",
+    "DIRECT_AGREEMENT_ABI",
+    "DIRECT_AGREEMENT_FIELD",
+    "DIRECT_AGREEMENT_KINDS",
+    "DIRECT_AGREEMENT_V2_ABI",
+    "INDEPENDENT_AUTHORITY_ABI",
+    "INDEPENDENT_AUTHORITY_FIELD",
+    "LC_COMMON_COMPONENT_ABI",
+    "LC_COMMON_COMPONENT_FIELD",
+    "LC_CROSS_LAYOUT_COMPONENT",
+    "LC_LEGACY_PYAMPLICOL_COMPONENT",
+    "MADGRAPH_COMPARISON_ABI",
+    "MADGRAPH_COMPARISON_FIELD",
+    "MADGRAPH_FULL_COLOUR",
+    "STRICT_ABSOLUTE_TOLERANCE",
+    "STRICT_RELATIVE_TOLERANCE",
+    "Z_RECURRENCE_CROSS_MODE",
+    "AgreementEdge",
+    "AgreementError",
+    "agreement_edges",
+    "agreement_relative_tolerance",
+    "attach_direct_agreements",
+    "direct_agreement_record",
+    "evaluate_lc_common_component",
+    "incoming_agreement_edges",
+    "independent_numerical_authorities",
+    "legacy_lc_common_component",
+    "madgraph_candidate_precision",
+    "madgraph_comparison_record",
+    "requires_independent_numerical_authority",
+    "validate_direct_agreement_records",
+    "validate_lc_common_component",
+    "validate_madgraph_comparison_record",
+    "validation_baseline_is_required",
+]
diff --git a/pyamplicol/tools/performance_report/arena_profile.py b/pyamplicol/tools/performance_report/arena_profile.py
new file mode 100644
index 0000000000..70c816a98d
--- /dev/null
+++ b/pyamplicol/tools/performance_report/arena_profile.py
@@ -0,0 +1,401 @@
+# SPDX-License-Identifier: 0BSD
+"""Fail-closed evidence for the private warmed-Arena profiling boundary."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections.abc import Mapping, Sequence
+
+ARENA_PROFILE_EVIDENCE_ABI = "pyamplicol-report-arena-profile-evidence-v1"
+ARENA_PROFILE_PROTOCOL = "arena"
+ARENA_PROFILE_SAMPLE_PASS = "runtime._profile_arena_repeated"
+ARENA_PROFILE_BOUNDARY = (
+    "warmed-direct-arena-borrowed-input-preallocated-output-v1"
+)
+ARENA_PHASE_TIMING_SCOPE = "coarse-arena-boundary-only-v1"
+PAIRED_TIMING_SAMPLE_CONTRACT = (
+    "paired_unprofiled_headline_profiled_attribution_v1"
+)
+
+ZERO_ARENA_COUNTER_FIELDS = (
+    "native_input_container_allocation_count",
+    "native_input_pack_bytes",
+    "native_input_crossing_bytes",
+    "stage_input_copy_component_count",
+    "stage_leaf_input_copy_component_count",
+    "stage_evaluator_output_gather_component_count",
+    "stage_output_assign_component_count",
+    "amplitude_input_copy_component_count",
+    "amplitude_leaf_input_copy_component_count",
+    "amplitude_evaluator_output_gather_component_count",
+    "amplitude_output_remap_component_count",
+    "selector_gather_point_count",
+    "selector_gather_bytes",
+    "selector_scatter_value_count",
+    "observed_scratch_reallocation_count",
+    "native_output_allocation_count",
+)
+ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS = (
+    "compiled_direct_arena_boundary_input_bytes",
+    "compiled_direct_arena_boundary_current_output_bytes",
+    "compiled_direct_arena_boundary_amplitude_output_bytes",
+)
+COMPILED_ACTIVITY_COUNTER_FIELDS = (
+    "compiled_direct_arena_engine_count",
+    "compiled_direct_arena_call_count",
+    "evaluator_backend_call_count",
+)
+ZERO_ARENA_PHASE_TIME_FIELDS = (
+    "native_input_pack_time_s",
+    "native_input_crossing_time_s",
+    "state_prepare_time_s",
+    "state_clear_time_s",
+    "source_fill_time_s",
+    "momentum_input_setup_time_s",
+    "momentum_setup_time_s",
+    "model_parameter_setup_time_s",
+    "stage_input_pack_time_s",
+    "stage_leaf_input_pack_time_s",
+    "stage_evaluator_call_time_s",
+    "stage_evaluator_time_s",
+    "stage_backend_call_time_s",
+    "stage_evaluator_output_gather_time_s",
+    "output_assign_time_s",
+    "amplitude_input_pack_time_s",
+    "amplitude_leaf_input_pack_time_s",
+    "amplitude_evaluator_call_time_s",
+    "amplitude_backend_call_time_s",
+    "amplitude_evaluator_output_gather_time_s",
+    "amplitude_output_remap_time_s",
+    "amplitude_evaluator_time_s",
+    "reduction_time_s",
+    "resolved_reduction_materialization_inclusive_time_s",
+    "total_materialization_time_s",
+    "final_output_copy_time_s",
+    "eager_initialize_time_s",
+    "eager_gather_time_s",
+    "eager_kernel_call_time_s",
+    "eager_invocation_scatter_time_s",
+    "eager_finalization_time_s",
+    "eager_scatter_finalization_time_s",
+    "eager_closure_time_s",
+    "eager_reduction_time_s",
+    "eager_copy_out_time_s",
+    "recurrence_momentum_fill_time_s",
+    "recurrence_union_source_fill_time_s",
+    "recurrence_schedule_time_s",
+    "recurrence_source_kernel_time_s",
+    "recurrence_contribution_kernel_time_s",
+    "recurrence_finalization_time_s",
+    "recurrence_closure_time_s",
+    "recurrence_replay_output_mapping_time_s",
+    "selector_planner_time_s",
+    "selector_gather_time_s",
+    "selector_scatter_time_s",
+)
+EMPTY_ARENA_PHASE_VECTOR_FIELDS = (
+    "stage_input_pack_by_stage_time_s",
+    "stage_leaf_input_pack_by_stage_time_s",
+    "stage_evaluator_call_by_stage_time_s",
+    "stage_backend_call_by_stage_time_s",
+    "stage_evaluator_output_gather_by_stage_time_s",
+    "stage_output_assign_by_stage_time_s",
+)
+ARENA_PROFILE_EVIDENCE_FIELDS = frozenset(
+    {
+        "abi",
+        "execution_mode",
+        "profile_count",
+        "repetitions_per_profile",
+        "batch_size",
+        "evaluated_points_per_profile",
+        "total_evaluated_points",
+        "warmed_boundary_wall_seconds_per_point",
+        "raw_profiles",
+        "raw_profiles_sha256",
+        "counter_totals",
+        "counter_totals_sha256",
+    }
+)
+
+
+class ArenaProfileEvidenceError(ValueError):
+    """Raised when warmed-Arena profile evidence is incomplete or inconsistent."""
+
+
+def _canonical_json(value: object) -> bytes:
+    try:
+        return json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    except (TypeError, ValueError) as error:
+        raise ArenaProfileEvidenceError(
+            "Arena profile evidence is not canonical JSON"
+        ) from error
+
+
+def digest_arena_profile_value(value: object) -> str:
+    return hashlib.sha256(_canonical_json(value)).hexdigest()
+
+
+def _json_copy(value: object) -> object:
+    return json.loads(_canonical_json(value).decode("ascii"))
+
+
+def _positive_integer(value: object, name: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+        raise ArenaProfileEvidenceError(f"{name} must be a positive integer")
+    return value
+
+
+def _integer(profile: Mapping[str, object], field: str) -> int:
+    value = profile.get(field)
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ArenaProfileEvidenceError(
+            f"Arena profile field {field!r} must be an integer"
+        )
+    return value
+
+
+def _finite(profile: Mapping[str, object], field: str) -> float:
+    value = profile.get(field)
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(float(value))
+    ):
+        raise ArenaProfileEvidenceError(
+            f"Arena profile field {field!r} must be finite"
+        )
+    return float(value)
+
+
+def _counter_fields(
+    profiles: Sequence[Mapping[str, object]],
+) -> tuple[str, ...]:
+    """Return every scalar native count/traffic field exposed by the samples."""
+
+    inventories = [
+        {
+            field
+            for field, value in profile.items()
+            if field == "points"
+            or (
+                (field.endswith("_count") or field.endswith("_bytes"))
+                and isinstance(value, int)
+                and not isinstance(value, bool)
+            )
+        }
+        for profile in profiles
+    ]
+    expected = inventories[0]
+    if any(inventory != expected for inventory in inventories[1:]):
+        raise ArenaProfileEvidenceError(
+            "Arena profile counter inventory differs between raw samples"
+        )
+    return tuple(sorted(expected))
+
+
+def _validate_raw_profile(
+    profile: Mapping[str, object],
+    *,
+    execution_mode: str,
+    evaluated_points: int,
+) -> None:
+    if profile.get("execution_mode") != execution_mode:
+        raise ArenaProfileEvidenceError(
+            "Arena profile execution mode does not match the measured runtime"
+        )
+    if (
+        profile.get("profile_boundary") != ARENA_PROFILE_BOUNDARY
+        or profile.get("borrowed_flat_input") is not True
+        or profile.get("preallocated_output") is not True
+        or profile.get("phase_timing_scope") != ARENA_PHASE_TIMING_SCOPE
+        or profile.get("evaluator_timing_available") is not False
+    ):
+        raise ArenaProfileEvidenceError(
+            "Arena profile does not authenticate the warmed borrowed-input, "
+            "preallocated-output boundary"
+        )
+    if _integer(profile, "points") != evaluated_points:
+        raise ArenaProfileEvidenceError(
+            "Arena profile point count does not match batch repetitions"
+        )
+    wall = _finite(profile, "wall_time_s")
+    orchestration = _finite(profile, "orchestration_time_s")
+    if wall <= 0.0 or orchestration != wall:
+        raise ArenaProfileEvidenceError(
+            "Arena profile boundary wall time must be positive and fully "
+            "accounted by orchestration"
+        )
+    zero_counter_fields = [
+        *ZERO_ARENA_COUNTER_FIELDS,
+        *ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS,
+    ]
+    for field in zero_counter_fields:
+        if _integer(profile, field) != 0:
+            raise ArenaProfileEvidenceError(
+                f"Arena profile field {field!r} must be zero"
+            )
+    for field in ZERO_ARENA_PHASE_TIME_FIELDS:
+        if _finite(profile, field) != 0.0:
+            raise ArenaProfileEvidenceError(
+                f"Arena profile field {field!r} must be zero"
+            )
+    for field in EMPTY_ARENA_PHASE_VECTOR_FIELDS:
+        if profile.get(field) != []:
+            raise ArenaProfileEvidenceError(
+                f"Arena profile field {field!r} must be an empty list"
+            )
+    if execution_mode == "compiled":
+        engine_count = _integer(profile, "compiled_direct_arena_engine_count")
+        call_count = _integer(profile, "compiled_direct_arena_call_count")
+        backend_count = _integer(profile, "evaluator_backend_call_count")
+        if engine_count <= 0 or call_count <= 0 or backend_count <= 0:
+            raise ArenaProfileEvidenceError(
+                "compiled Arena profile activity counters must be positive"
+            )
+        if call_count != backend_count:
+            raise ArenaProfileEvidenceError(
+                "compiled Arena calls do not cover every evaluator backend call"
+            )
+
+
+def build_arena_profile_evidence(
+    raw_profiles: Sequence[Mapping[str, object]],
+    *,
+    execution_mode: str,
+    repetitions_per_profile: int,
+    batch_size: int,
+) -> dict[str, object]:
+    """Validate raw samples and build their independently recomputed evidence."""
+
+    if execution_mode not in {"compiled", "eager"}:
+        raise ArenaProfileEvidenceError("Arena profile execution mode is unsupported")
+    repetitions = _positive_integer(
+        repetitions_per_profile,
+        "repetitions_per_profile",
+    )
+    points_per_batch = _positive_integer(batch_size, "batch_size")
+    if (
+        isinstance(raw_profiles, (str, bytes, bytearray))
+        or not isinstance(raw_profiles, Sequence)
+        or not raw_profiles
+    ):
+        raise ArenaProfileEvidenceError("Arena profile evidence requires raw samples")
+    evaluated_points = repetitions * points_per_batch
+    canonical_profiles: list[dict[str, object]] = []
+    wall_per_point: list[float] = []
+    for index, raw_profile in enumerate(raw_profiles):
+        if not isinstance(raw_profile, Mapping):
+            raise ArenaProfileEvidenceError(
+                f"Arena profile sample {index} is not an object"
+            )
+        copied = _json_copy(dict(raw_profile))
+        if not isinstance(copied, dict):
+            raise ArenaProfileEvidenceError(
+                f"Arena profile sample {index} is not an object"
+            )
+        _validate_raw_profile(
+            copied,
+            execution_mode=execution_mode,
+            evaluated_points=evaluated_points,
+        )
+        canonical_profiles.append(copied)
+        wall_per_point.append(float(copied["wall_time_s"]) / evaluated_points)
+    counter_totals = {
+        field: 0 for field in _counter_fields(canonical_profiles)
+    }
+    for copied in canonical_profiles:
+        for field in counter_totals:
+            counter_totals[field] += _integer(copied, field)
+    profile_count = len(canonical_profiles)
+    warmed_wall = math.fsum(wall_per_point) / profile_count
+    return {
+        "abi": ARENA_PROFILE_EVIDENCE_ABI,
+        "execution_mode": execution_mode,
+        "profile_count": profile_count,
+        "repetitions_per_profile": repetitions,
+        "batch_size": points_per_batch,
+        "evaluated_points_per_profile": evaluated_points,
+        "total_evaluated_points": profile_count * evaluated_points,
+        "warmed_boundary_wall_seconds_per_point": warmed_wall,
+        "raw_profiles": canonical_profiles,
+        "raw_profiles_sha256": digest_arena_profile_value(canonical_profiles),
+        "counter_totals": counter_totals,
+        "counter_totals_sha256": digest_arena_profile_value(counter_totals),
+    }
+
+
+def validate_arena_profile_evidence(
+    value: object,
+    *,
+    execution_mode: str,
+    sample_count: int,
+    native_profile_points_per_sample: int,
+) -> Mapping[str, object]:
+    """Recompute and authenticate stored warmed-Arena evidence."""
+
+    if not isinstance(value, Mapping) or set(value) != ARENA_PROFILE_EVIDENCE_FIELDS:
+        raise ArenaProfileEvidenceError(
+            "Arena profile evidence fields do not match the contract"
+        )
+    raw_profiles = value.get("raw_profiles")
+    if not isinstance(raw_profiles, Sequence) or isinstance(
+        raw_profiles,
+        (str, bytes, bytearray),
+    ):
+        raise ArenaProfileEvidenceError("Arena profile raw samples are invalid")
+    repetitions = _positive_integer(
+        value.get("repetitions_per_profile"),
+        "repetitions_per_profile",
+    )
+    batch_size = _positive_integer(value.get("batch_size"), "batch_size")
+    rebuilt = build_arena_profile_evidence(
+        raw_profiles,  # type: ignore[arg-type]
+        execution_mode=execution_mode,
+        repetitions_per_profile=repetitions,
+        batch_size=batch_size,
+    )
+    if dict(value) != rebuilt:
+        raise ArenaProfileEvidenceError(
+            "Arena profile evidence differs from independently recomputed values"
+        )
+    if rebuilt["profile_count"] != sample_count:
+        raise ArenaProfileEvidenceError(
+            "Arena profile count does not match the measurement sample count"
+        )
+    if (
+        rebuilt["evaluated_points_per_profile"]
+        != native_profile_points_per_sample
+    ):
+        raise ArenaProfileEvidenceError(
+            "Arena profile point count does not match timing provenance"
+        )
+    return value
+
+
+__all__ = [
+    "ARENA_PHASE_TIMING_SCOPE",
+    "ARENA_PROFILE_BOUNDARY",
+    "ARENA_PROFILE_EVIDENCE_ABI",
+    "ARENA_PROFILE_EVIDENCE_FIELDS",
+    "ARENA_PROFILE_PROTOCOL",
+    "ARENA_PROFILE_SAMPLE_PASS",
+    "COMPILED_ACTIVITY_COUNTER_FIELDS",
+    "EMPTY_ARENA_PHASE_VECTOR_FIELDS",
+    "PAIRED_TIMING_SAMPLE_CONTRACT",
+    "ZERO_ARENA_COUNTER_FIELDS",
+    "ZERO_ARENA_PHASE_TIME_FIELDS",
+    "ZERO_COMPILED_BOUNDARY_COUNTER_FIELDS",
+    "ArenaProfileEvidenceError",
+    "build_arena_profile_evidence",
+    "digest_arena_profile_value",
+    "validate_arena_profile_evidence",
+]
diff --git a/pyamplicol/tools/performance_report/artifacts.py b/pyamplicol/tools/performance_report/artifacts.py
new file mode 100644
index 0000000000..06771dae81
--- /dev/null
+++ b/pyamplicol/tools/performance_report/artifacts.py
@@ -0,0 +1,1686 @@
+# SPDX-License-Identifier: 0BSD
+"""Immutable report artifacts, validated current pointers, and filesystem locks."""
+
+from __future__ import annotations
+
+import errno
+import fcntl
+import hashlib
+import json
+import os
+import re
+import shutil
+import threading
+import time
+import uuid
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from contextlib import contextmanager
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+from types import TracebackType
+from typing import TYPE_CHECKING, Any, BinaryIO
+
+from .models import ArtifactPolicy
+
+if TYPE_CHECKING:
+    from .service import ReportPaths
+
+ATTEMPT_SCHEMA = "pyamplicol-performance-attempt-v1"
+CURRENT_SCHEMA = "pyamplicol-performance-current-v1"
+PORTABLE_CURRENT_SCHEMA = "pyamplicol-performance-portable-current-v1"
+
+_ATTEMPT_KEYS = {
+    "schema",
+    "cell_id",
+    "attempt_id",
+    "status",
+    "artifact_policy",
+    "based_on",
+    "result_path",
+    "artifacts",
+    "error",
+}
+_CURRENT_KEYS = {
+    "schema",
+    "cell_id",
+    "attempt_id",
+    "manifest_path",
+    "manifest_sha256",
+}
+_FILE_KEYS = {"path", "size", "sha256"}
+_BASED_ON_KEYS = {"attempt_id", "manifest_sha256"}
+_SHA256_RE = re.compile(r"[0-9a-f]{64}")
+_LOCK_STATE = threading.local()
+
+
+class ArtifactStoreError(RuntimeError):
+    """Base error for the immutable report artifact store."""
+
+
+class ManifestValidationError(ArtifactStoreError):
+    """An artifact manifest or current pointer failed validation."""
+
+
+class LockTimeoutError(ArtifactStoreError):
+    """A filesystem lock could not be acquired before its deadline."""
+
+
+class LockCancelledError(ArtifactStoreError):
+    """A caller cancelled while waiting for a filesystem lock."""
+
+
+class DiskFullError(ArtifactStoreError):
+    """A report write failed because its filesystem has no free space."""
+
+
+class ArtifactAction(StrEnum):
+    """Concrete action selected from an artifact policy and current state."""
+
+    REUSE_CURRENT = "reuse-current"
+    RETIME_CURRENT = "retime-current"
+    GENERATE = "generate"
+
+
+def _thread_lock_depths() -> dict[Path, int]:
+    process_id = os.getpid()
+    if getattr(_LOCK_STATE, "process_id", None) != process_id:
+        _LOCK_STATE.process_id = process_id
+        _LOCK_STATE.depths = {}
+    depths = getattr(_LOCK_STATE, "depths", None)
+    if depths is None:
+        depths = {}
+        _LOCK_STATE.depths = depths
+    return depths
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactFile:
+    relative_path: str
+    path: Path
+    size: int
+    sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class CurrentRecord:
+    cell_id: str
+    attempt_id: str
+    manifest_path: Path
+    manifest_sha256: str
+    result_path: Path
+    result: Mapping[str, Any]
+    artifacts: tuple[ArtifactFile, ...]
+    artifact_policy: ArtifactPolicy
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactDecision:
+    requested_policy: ArtifactPolicy
+    action: ArtifactAction
+    current: CurrentRecord | None
+
+    @property
+    def requires_generation(self) -> bool:
+        return self.action is ArtifactAction.GENERATE
+
+    @property
+    def requires_timing(self) -> bool:
+        return self.action is not ArtifactAction.REUSE_CURRENT
+
+
+def _canonical_json_bytes(payload: Mapping[str, Any]) -> bytes:
+    try:
+        encoded = json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+    except (TypeError, ValueError) as error:
+        raise ArtifactStoreError(f"payload is not canonical JSON: {error}") from error
+    return f"{encoded}\n".encode()
+
+
+def _fsync_directory(path: Path) -> None:
+    descriptor = os.open(path, os.O_RDONLY)
+    try:
+        os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+def _raise_disk_full(error: OSError, path: Path) -> None:
+    if error.errno != errno.ENOSPC:
+        raise error
+    probe = path if path.is_dir() else path.parent
+    while not probe.exists() and probe != probe.parent:
+        probe = probe.parent
+    try:
+        free = shutil.disk_usage(probe).free
+        detail = f"; {free} bytes available"
+    except OSError:
+        detail = ""
+    raise DiskFullError(f"disk full while writing {path}{detail}") from error
+
+
+def _atomic_write_json(path: Path, payload: Mapping[str, Any]) -> None:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = path.with_name(f".{path.name}.tmp-{uuid.uuid4()}")
+        data = _canonical_json_bytes(payload)
+        with temporary.open("xb") as stream:
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+        _fsync_directory(path.parent)
+    except OSError as error:
+        _raise_disk_full(error, path)
+    finally:
+        if "temporary" in locals():
+            temporary.unlink(missing_ok=True)
+
+
+def _read_json_object(path: Path, *, description: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise ManifestValidationError(
+            f"could not read {description} {path}: {error}"
+        ) from error
+    if not isinstance(payload, dict):
+        raise ManifestValidationError(f"{description} must be a JSON object: {path}")
+    return payload
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _validate_sha256(value: object, *, field: str) -> str:
+    if not isinstance(value, str) or _SHA256_RE.fullmatch(value) is None:
+        raise ManifestValidationError(f"{field} must be a lowercase SHA-256 digest")
+    return value
+
+
+def _validate_uuid(value: object, *, field: str) -> str:
+    if not isinstance(value, str):
+        raise ManifestValidationError(f"{field} must be a UUID string")
+    try:
+        parsed = uuid.UUID(value)
+    except ValueError as error:
+        raise ManifestValidationError(f"{field} must be a UUID string") from error
+    if str(parsed) != value:
+        raise ManifestValidationError(f"{field} must use canonical UUID spelling")
+    return value
+
+
+def _validate_cell_id(cell_id: object) -> str:
+    if not isinstance(cell_id, str) or not cell_id or "\x00" in cell_id:
+        raise ManifestValidationError("cell_id must be a non-empty string")
+    if len(cell_id.encode()) > 4096:
+        raise ManifestValidationError("cell_id is unreasonably long")
+    return cell_id
+
+
+def _safe_component(value: str, *, prefix_length: int = 48) -> str:
+    digest = hashlib.sha256(value.encode()).hexdigest()[:16]
+    prefix = re.sub(r"[^A-Za-z0-9_.-]+", "-", value).strip(".-")
+    if not prefix:
+        prefix = "item"
+    return f"{prefix[:prefix_length]}-{digest}"
+
+
+def _strict_relative_path(value: object, *, field: str) -> Path:
+    if not isinstance(value, str) or not value:
+        raise ManifestValidationError(f"{field} must be a non-empty relative path")
+    path = Path(value)
+    if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts):
+        raise ManifestValidationError(f"{field} contains an unsafe path: {value!r}")
+    return path
+
+
+def _resolve_member(
+    root: Path,
+    relative: object,
+    *,
+    field: str,
+    require_file: bool = True,
+) -> tuple[str, Path]:
+    relative_path = _strict_relative_path(relative, field=field)
+    candidate = root.joinpath(relative_path)
+    if candidate.is_symlink():
+        raise ManifestValidationError(
+            f"{field} is not a regular attempt file: {relative_path}"
+        )
+    try:
+        resolved = candidate.resolve(strict=require_file)
+    except OSError as error:
+        raise ManifestValidationError(
+            f"{field} does not resolve to a readable file: {relative_path}"
+        ) from error
+    try:
+        resolved.relative_to(root.resolve())
+    except ValueError as error:
+        raise ManifestValidationError(
+            f"{field} escapes its attempt directory: {relative_path}"
+        ) from error
+    if require_file and (not resolved.is_file() or candidate.is_symlink()):
+        raise ManifestValidationError(
+            f"{field} is not a regular attempt file: {relative_path}"
+        )
+    return relative_path.as_posix(), resolved
+
+
+@contextmanager
+def _filesystem_lock(
+    path: Path,
+    *,
+    timeout: float | None,
+    poll_interval: float,
+    cancellation_requested: Callable[[], bool] | None = None,
+) -> Iterator[None]:
+    if timeout is not None and timeout < 0:
+        raise ValueError("lock timeout must be non-negative or None")
+    if poll_interval <= 0:
+        raise ValueError("lock poll interval must be positive")
+    lock_path = path.expanduser().resolve(strict=False)
+    depths = _thread_lock_depths()
+    depth = depths.get(lock_path, 0)
+    if depth:
+        depths[lock_path] = depth + 1
+        try:
+            yield
+        finally:
+            remaining = depths[lock_path] - 1
+            if remaining:
+                depths[lock_path] = remaining
+            else:
+                del depths[lock_path]
+        return
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    stream: BinaryIO = lock_path.open("a+b")
+    deadline = None if timeout is None else time.monotonic() + timeout
+    try:
+        while True:
+            if cancellation_requested is not None and cancellation_requested():
+                raise LockCancelledError(
+                    f"cancelled while waiting for filesystem lock {lock_path}"
+                )
+            try:
+                fcntl.flock(stream.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+                break
+            except OSError as error:
+                if error.errno not in (errno.EACCES, errno.EAGAIN):
+                    raise
+                if deadline is not None and time.monotonic() >= deadline:
+                    raise LockTimeoutError(
+                        f"timed out acquiring filesystem lock {lock_path}"
+                    ) from error
+                remaining = (
+                    poll_interval
+                    if deadline is None
+                    else min(poll_interval, max(0.0, deadline - time.monotonic()))
+                )
+                time.sleep(remaining)
+        depths[lock_path] = 1
+        yield
+    finally:
+        depths.pop(lock_path, None)
+        try:
+            fcntl.flock(stream.fileno(), fcntl.LOCK_UN)
+        finally:
+            stream.close()
+
+
+class ArtifactStore:
+    """Store immutable attempts and atomically select one validated current result."""
+
+    def __init__(
+        self,
+        *,
+        artifact_root: Path,
+        lock_root: Path,
+        current_publication_paths: ReportPaths | None = None,
+    ) -> None:
+        self.artifact_root = Path(artifact_root).expanduser().resolve(strict=False)
+        self.lock_root = Path(lock_root).expanduser().resolve(strict=False)
+        self.current_publication_paths = current_publication_paths
+        if current_publication_paths is not None and (
+            current_publication_paths.artifact_root != self.artifact_root
+            or current_publication_paths.coordination_root != self.lock_root
+        ):
+            raise ValueError(
+                "portable current roots must match the artifact store roots"
+            )
+        self.cells_root = self.artifact_root / "cells"
+        self.attempt_history_root = self.artifact_root / "attempt-history"
+        self.cells_root.mkdir(parents=True, exist_ok=True)
+        self.lock_root.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def current_schema(self) -> str:
+        return (
+            CURRENT_SCHEMA
+            if self.current_publication_paths is None
+            else PORTABLE_CURRENT_SCHEMA
+        )
+
+    def _stored_current_result(
+        self,
+        result: Mapping[str, Any],
+    ) -> Mapping[str, Any]:
+        if self.current_publication_paths is None:
+            return result
+        from .publication import portable_current_value
+
+        portable = portable_current_value(result, self.current_publication_paths)
+        if not isinstance(portable, Mapping):  # pragma: no cover - input is a mapping.
+            raise ArtifactStoreError("portable current result must remain an object")
+        return portable
+
+    def materialize_current_result(
+        self,
+        result: Mapping[str, Any],
+    ) -> Mapping[str, Any]:
+        """Resolve an authenticated stored current against this store's roots."""
+
+        if self.current_publication_paths is None:
+            return result
+        from .publication import PublicationPortabilityError, materialize_current_value
+
+        try:
+            materialized = materialize_current_value(
+                result,
+                self.current_publication_paths,
+            )
+        except PublicationPortabilityError as error:
+            raise ManifestValidationError(
+                f"portable current result contains an unsafe locator: {error}"
+            ) from error
+        if not isinstance(materialized, Mapping):  # pragma: no cover - input is object.
+            raise ManifestValidationError(
+                "portable current result did not materialize as an object"
+            )
+        return materialized
+
+    def _cell_root(self, cell_id: str) -> Path:
+        validated = _validate_cell_id(cell_id)
+        return self.cells_root / _safe_component(validated)
+
+    def _validate_cells_root(self) -> None:
+        if self.cells_root.is_symlink() or not self.cells_root.is_dir():
+            raise ManifestValidationError(
+                f"artifact cells root is not a regular directory: {self.cells_root}"
+            )
+        try:
+            resolved = self.cells_root.resolve(strict=True)
+        except OSError as error:
+            raise ManifestValidationError(
+                f"artifact cells root is unavailable: {self.cells_root}"
+            ) from error
+        if resolved != self.cells_root:
+            raise ManifestValidationError(
+                f"artifact cells root escapes its canonical path: {self.cells_root}"
+            )
+
+    def _validate_cell_root_path(
+        self,
+        cell_root: Path,
+        *,
+        missing_ok: bool,
+    ) -> Path | None:
+        self._validate_cells_root()
+        if cell_root.parent != self.cells_root:
+            raise ManifestValidationError(
+                f"cell root is outside the artifact inventory: {cell_root}"
+            )
+        if cell_root.is_symlink():
+            raise ManifestValidationError(
+                f"cell root is a symbolic link: {cell_root}"
+            )
+        if not cell_root.exists():
+            if missing_ok:
+                return None
+            raise ManifestValidationError(
+                f"artifact cell root is absent: {cell_root}"
+            )
+        if not cell_root.is_dir():
+            raise ManifestValidationError(
+                f"cell root is not a regular directory: {cell_root}"
+            )
+        try:
+            resolved = cell_root.resolve(strict=True)
+        except OSError as error:
+            raise ManifestValidationError(
+                f"cell root is unavailable: {cell_root}"
+            ) from error
+        if resolved != cell_root:
+            raise ManifestValidationError(
+                f"cell root escapes its canonical path: {cell_root}"
+            )
+        return cell_root
+
+    def _existing_cell_root(
+        self,
+        cell_id: str,
+        *,
+        missing_ok: bool,
+    ) -> Path | None:
+        return self._validate_cell_root_path(
+            self._cell_root(cell_id),
+            missing_ok=missing_ok,
+        )
+
+    def _cell_lock_path(self, cell_id: str) -> Path:
+        validated = _validate_cell_id(cell_id)
+        return self.lock_root / "cells" / f"{_safe_component(validated)}.lock"
+
+    def _attempt_root(self, cell_id: str, attempt_id: str) -> Path:
+        validated_cell = _validate_cell_id(cell_id)
+        validated_attempt = _validate_uuid(attempt_id, field="attempt_id")
+        return self._cell_root(validated_cell) / "attempts" / validated_attempt
+
+    def _attempt_history_cell_root(self, cell_id: str) -> Path:
+        validated = _validate_cell_id(cell_id)
+        return self.attempt_history_root / _safe_component(validated)
+
+    @staticmethod
+    def _validate_direct_inventory_directory(
+        path: Path,
+        *,
+        parent: Path,
+        description: str,
+        missing_ok: bool,
+    ) -> Path | None:
+        if path.parent != parent:
+            raise ManifestValidationError(
+                f"{description} is outside its canonical inventory: {path}"
+            )
+        if path.is_symlink():
+            raise ManifestValidationError(f"{description} is a symbolic link: {path}")
+        if not path.exists():
+            if missing_ok:
+                return None
+            raise ManifestValidationError(f"{description} is absent: {path}")
+        if not path.is_dir():
+            raise ManifestValidationError(
+                f"{description} is not a regular directory: {path}"
+            )
+        try:
+            resolved = path.resolve(strict=True)
+        except OSError as error:
+            raise ManifestValidationError(
+                f"{description} is unavailable: {path}"
+            ) from error
+        if resolved != path:
+            raise ManifestValidationError(
+                f"{description} escapes its canonical path: {path}"
+            )
+        return path
+
+    def _existing_live_attempt_root(
+        self,
+        cell_id: str,
+        attempt_id: str,
+    ) -> Path | None:
+        cell_root = self._existing_cell_root(cell_id, missing_ok=True)
+        if cell_root is None:
+            return None
+        attempts_root = self._validate_direct_inventory_directory(
+            cell_root / "attempts",
+            parent=cell_root,
+            description="attempts root",
+            missing_ok=True,
+        )
+        if attempts_root is None:
+            return None
+        return self._validate_direct_inventory_directory(
+            attempts_root / _validate_uuid(attempt_id, field="attempt_id"),
+            parent=attempts_root,
+            description="attempt root",
+            missing_ok=True,
+        )
+
+    def _existing_archived_attempt_root(
+        self,
+        cell_id: str,
+        attempt_id: str,
+    ) -> Path | None:
+        history_root = self._validate_direct_inventory_directory(
+            self.attempt_history_root,
+            parent=self.artifact_root,
+            description="attempt history root",
+            missing_ok=True,
+        )
+        if history_root is None:
+            return None
+        history_cell = self._validate_direct_inventory_directory(
+            self._attempt_history_cell_root(cell_id),
+            parent=history_root,
+            description="attempt history cell root",
+            missing_ok=True,
+        )
+        if history_cell is None:
+            return None
+        return self._validate_direct_inventory_directory(
+            history_cell / _validate_uuid(attempt_id, field="attempt_id"),
+            parent=history_cell,
+            description="archived attempt root",
+            missing_ok=True,
+        )
+
+    @contextmanager
+    def cell_lock(
+        self,
+        cell_id: str,
+        *,
+        timeout: float | None = None,
+        poll_interval: float = 0.05,
+        cancellation_requested: Callable[[], bool] | None = None,
+    ) -> Iterator[None]:
+        with _filesystem_lock(
+            self._cell_lock_path(cell_id),
+            timeout=timeout,
+            poll_interval=poll_interval,
+            cancellation_requested=cancellation_requested,
+        ):
+            yield
+
+    @contextmanager
+    def named_lock(
+        self,
+        name: str,
+        *,
+        timeout: float | None = None,
+        poll_interval: float = 0.05,
+        cancellation_requested: Callable[[], bool] | None = None,
+    ) -> Iterator[None]:
+        validated = _validate_cell_id(name)
+        path = self.lock_root / "named" / f"{_safe_component(validated)}.lock"
+        with _filesystem_lock(
+            path,
+            timeout=timeout,
+            poll_interval=poll_interval,
+            cancellation_requested=cancellation_requested,
+        ):
+            yield
+
+    def decide(
+        self,
+        cell_id: str,
+        policy: ArtifactPolicy,
+    ) -> ArtifactDecision:
+        current = self.load_current(cell_id, missing_ok=True)
+        if policy is ArtifactPolicy.REUSE and current is not None:
+            action = ArtifactAction.REUSE_CURRENT
+        elif policy is ArtifactPolicy.RETIME and current is not None:
+            action = ArtifactAction.RETIME_CURRENT
+        else:
+            action = ArtifactAction.GENERATE
+        return ArtifactDecision(policy, action, current)
+
+    def new_attempt(
+        self,
+        cell_id: str,
+        policy: ArtifactPolicy,
+        *,
+        based_on: CurrentRecord | None = None,
+    ) -> ArtifactAttempt:
+        validated = _validate_cell_id(cell_id)
+        if based_on is not None and based_on.cell_id != validated:
+            raise ArtifactStoreError("based-on record belongs to a different cell")
+        attempt_id = str(uuid.uuid4())
+        self._validate_cells_root()
+        cell_root = self._cell_root(validated)
+        if cell_root.exists() or cell_root.is_symlink():
+            self._validate_cell_root_path(cell_root, missing_ok=False)
+        root = cell_root / "attempts" / attempt_id
+        try:
+            root.mkdir(parents=True, exist_ok=False)
+            _fsync_directory(root.parent)
+        except OSError as error:
+            _raise_disk_full(error, root)
+        return ArtifactAttempt(
+            store=self,
+            cell_id=validated,
+            attempt_id=attempt_id,
+            root=root,
+            artifact_policy=policy,
+            based_on=based_on,
+        )
+
+    def seal_existing_worker_result(
+        self,
+        cell_id: str,
+        attempt_id: str,
+        *,
+        worker_result_sha256: str,
+        artifact_policy: ArtifactPolicy,
+        validate_result: Callable[[Mapping[str, Any], Path], None],
+    ) -> CurrentRecord:
+        """Seal one controller-orphaned worker result without rerunning it."""
+
+        validated_cell = _validate_cell_id(cell_id)
+        validated_attempt = _validate_uuid(attempt_id, field="attempt_id")
+        expected_worker_digest = _validate_sha256(
+            worker_result_sha256,
+            field="worker_result_sha256",
+        )
+        cell_root = self._existing_cell_root(validated_cell, missing_ok=False)
+        assert cell_root is not None
+        attempt_root = cell_root / "attempts" / validated_attempt
+        with self.cell_lock(validated_cell):
+            pointer_path = cell_root / "current.json"
+            if pointer_path.exists() or pointer_path.is_symlink():
+                raise ArtifactStoreError(
+                    "orphan sealing cannot replace an existing current"
+                )
+            if (
+                attempt_root.is_symlink()
+                or not attempt_root.is_dir()
+                or attempt_root.parent.is_symlink()
+            ):
+                raise ArtifactStoreError(
+                    "orphan attempt is not its canonical regular directory"
+                )
+            for reserved in ("result.json", "manifest.json"):
+                path = attempt_root / reserved
+                if path.exists() or path.is_symlink():
+                    raise ArtifactStoreError(
+                        f"orphan attempt already contains {reserved}"
+                    )
+            _, worker_result = _resolve_member(
+                attempt_root,
+                "worker-result.json",
+                field="worker-result.json",
+            )
+            if _sha256(worker_result) != expected_worker_digest:
+                raise ArtifactStoreError("worker-result.json digest mismatch")
+            result = _read_json_object(
+                worker_result,
+                description="orphan worker result",
+            )
+            validate_result(result, attempt_root)
+            artifact_paths: list[str] = []
+            for path in sorted(attempt_root.rglob("*")):
+                if path.is_symlink():
+                    raise ArtifactStoreError(
+                        f"orphan attempt contains a symbolic link: {path}"
+                    )
+                if path.is_file():
+                    artifact_paths.append(path.relative_to(attempt_root).as_posix())
+                elif not path.is_dir():
+                    raise ArtifactStoreError(
+                        f"orphan attempt contains a special file: {path}"
+                    )
+            if "worker-result.json" not in artifact_paths:
+                raise ArtifactStoreError("orphan attempt lacks worker-result.json")
+            attempt = ArtifactAttempt(
+                store=self,
+                cell_id=validated_cell,
+                attempt_id=validated_attempt,
+                root=attempt_root,
+                artifact_policy=artifact_policy,
+                based_on=None,
+            )
+            record = attempt.publish(
+                result,
+                artifact_paths=artifact_paths,
+            )
+            if _sha256(worker_result) != expected_worker_digest:
+                raise ArtifactStoreError(
+                    "worker-result.json changed during orphan sealing"
+                )
+            return record
+
+    def load_current(
+        self,
+        cell_id: str,
+        *,
+        missing_ok: bool = False,
+    ) -> CurrentRecord | None:
+        validated = _validate_cell_id(cell_id)
+        cell_root = self._existing_cell_root(validated, missing_ok=True)
+        if cell_root is None:
+            if missing_ok:
+                return None
+            raise FileNotFoundError(f"no artifact cell for {validated!r}")
+        pointer_path = cell_root / "current.json"
+        if pointer_path.is_symlink():
+            raise ManifestValidationError(
+                f"current pointer is a symbolic link: {pointer_path}"
+            )
+        if not pointer_path.exists():
+            if missing_ok:
+                return None
+            raise FileNotFoundError(f"no current artifact for cell {validated!r}")
+        if not pointer_path.is_file():
+            raise ManifestValidationError(
+                f"current pointer is not a regular file: {pointer_path}"
+            )
+        return self._validate_current_pointer(
+            pointer_path,
+            expected_cell_id=validated,
+            expected_cell_root=cell_root,
+        )
+
+    def recover_current_records(self) -> tuple[CurrentRecord, ...]:
+        records: list[CurrentRecord] = []
+        self._validate_cells_root()
+        for pointer_path in sorted(self.cells_root.glob("*/current.json")):
+            self._validate_cell_root_path(pointer_path.parent, missing_ok=False)
+            records.append(
+                self._validate_current_pointer(
+                    pointer_path,
+                    expected_cell_id=None,
+                    expected_cell_root=pointer_path.parent,
+                )
+            )
+        return tuple(records)
+
+    def cell_attempt_ids(self, cell_id: str) -> tuple[str, ...]:
+        """Return the canonical immutable-attempt inventory for one cell."""
+
+        cell_root = self._existing_cell_root(cell_id, missing_ok=True)
+        if cell_root is None:
+            return ()
+        attempts_root = cell_root / "attempts"
+        if not attempts_root.exists():
+            return ()
+        if attempts_root.is_symlink() or not attempts_root.is_dir():
+            raise ManifestValidationError(
+                f"attempt inventory is not a regular directory: {attempts_root}"
+            )
+        attempt_ids: list[str] = []
+        for path in sorted(attempts_root.iterdir()):
+            if path.is_symlink() or not path.is_dir():
+                raise ManifestValidationError(
+                    f"attempt inventory contains a non-directory: {path}"
+                )
+            attempt_ids.append(
+                _validate_uuid(path.name, field="attempt inventory member")
+            )
+        return tuple(attempt_ids)
+
+    def load_sealed_unsuccessful_worker_result(
+        self,
+        cell_id: str,
+        attempt_id: str,
+    ) -> Mapping[str, Any]:
+        """Load one explicitly named failed result through its sealed manifest.
+
+        This is deliberately not a history search.  Presentation metadata
+        names the exact attempt UUID, and this method authenticates only that
+        attempt's compact ``worker-result.json``.  It supports the canonical
+        live and archived locations used by bounded artifact cleanup.
+        """
+
+        validated_cell = _validate_cell_id(cell_id)
+        validated_attempt = _validate_uuid(attempt_id, field="attempt_id")
+        live_root = self._existing_live_attempt_root(
+            validated_cell,
+            validated_attempt,
+        )
+        archived_root = self._existing_archived_attempt_root(
+            validated_cell,
+            validated_attempt,
+        )
+        roots = tuple(
+            root
+            for root in (live_root, archived_root)
+            if root is not None
+        )
+        if len(roots) != 1:
+            raise ManifestValidationError(
+                "named unsuccessful attempt is absent or has colliding locations"
+            )
+        root = roots[0]
+        archived = root == archived_root
+        if root.is_symlink() or not root.is_dir():
+            raise ManifestValidationError(
+                f"named unsuccessful attempt is not a regular directory: {root}"
+            )
+        manifest_path = root / "manifest.json"
+        if manifest_path.is_symlink() or not manifest_path.is_file():
+            raise ManifestValidationError(
+                f"named unsuccessful attempt has no regular manifest: {root}"
+            )
+        manifest = _read_json_object(
+            manifest_path,
+            description="unsuccessful attempt manifest",
+        )
+        if (
+            set(manifest) != _ATTEMPT_KEYS
+            or manifest.get("schema") != ATTEMPT_SCHEMA
+            or manifest.get("cell_id") != validated_cell
+            or manifest.get("attempt_id") != validated_attempt
+            or manifest.get("status") not in {"failed", "interrupted"}
+            or manifest.get("result_path") is not None
+            or not isinstance(manifest.get("error"), str)
+            or not manifest.get("error")
+        ):
+            raise ManifestValidationError(
+                "named unsuccessful attempt manifest is invalid"
+            )
+        try:
+            ArtifactPolicy(manifest.get("artifact_policy"))
+        except (TypeError, ValueError) as error:
+            raise ManifestValidationError(
+                "unsuccessful attempt artifact policy is invalid"
+            ) from error
+        self._validate_based_on(manifest.get("based_on"))
+        raw_artifacts = manifest.get("artifacts")
+        if not isinstance(raw_artifacts, list):
+            raise ManifestValidationError(
+                "unsuccessful attempt artifacts must be an array"
+            )
+        artifacts: list[ArtifactFile] = []
+        for index, raw in enumerate(raw_artifacts):
+            if not isinstance(raw, dict) or set(raw) != _FILE_KEYS:
+                raise ManifestValidationError(
+                    f"artifact record {index} has an unsupported schema shape"
+                )
+            relative = _strict_relative_path(
+                raw.get("path"),
+                field=f"artifacts[{index}].path",
+            )
+            self._validate_unsuccessful_artifact_ancestors(root, relative)
+            candidate = root.joinpath(relative)
+            if archived and not candidate.exists() and not candidate.is_symlink():
+                if not relative.parts or relative.parts[0] != "artifact":
+                    raise ManifestValidationError(
+                        "archived compact diagnostic artifact is missing: "
+                        f"{relative.as_posix()}"
+                    )
+                self._validate_missing_archived_artifact_record(
+                    raw,
+                    index=index,
+                )
+                continue
+            artifacts.append(self._validate_artifact_file(root, raw, index=index))
+        paths = [
+            _strict_relative_path(raw.get("path"), field="artifact path").as_posix()
+            for raw in raw_artifacts
+            if isinstance(raw, Mapping)
+        ]
+        if len(paths) != len(set(paths)):
+            raise ManifestValidationError(
+                "unsuccessful attempt manifest has duplicate artifacts"
+            )
+        matches = tuple(
+            artifact
+            for artifact in artifacts
+            if artifact.relative_path == "worker-result.json"
+        )
+        if len(matches) != 1:
+            raise ManifestValidationError(
+                "unsuccessful attempt does not authenticate worker-result.json"
+            )
+        return self.materialize_current_result(
+            _read_json_object(
+                matches[0].path,
+                description="unsuccessful worker result",
+            )
+        )
+
+    @staticmethod
+    def _validate_unsuccessful_artifact_ancestors(
+        attempt_root: Path,
+        relative: Path,
+    ) -> None:
+        cursor = attempt_root
+        for offset, part in enumerate(relative.parts):
+            cursor = cursor / part
+            if cursor.is_symlink():
+                raise ManifestValidationError(
+                    "unsuccessful artifact traverses a symbolic link: "
+                    f"{relative.as_posix()}"
+                )
+            if (
+                offset < len(relative.parts) - 1
+                and cursor.exists()
+                and not cursor.is_dir()
+            ):
+                raise ManifestValidationError(
+                    "unsuccessful artifact traverses a non-directory: "
+                    f"{relative.as_posix()}"
+                )
+
+    @staticmethod
+    def _validate_missing_archived_artifact_record(
+        raw_record: Mapping[str, object],
+        *,
+        index: int,
+    ) -> None:
+        size = raw_record.get("size")
+        if isinstance(size, bool) or not isinstance(size, int) or size < 0:
+            raise ManifestValidationError(
+                f"artifacts[{index}].size must be a non-negative integer"
+            )
+        _validate_sha256(
+            raw_record.get("sha256"),
+            field=f"artifacts[{index}].sha256",
+        )
+
+    def lightweight_current_payload(
+        self,
+        cell_id: str,
+        *,
+        missing_ok: bool = False,
+    ) -> tuple[str, Mapping[str, Any]] | None:
+        """Read authenticated pointer/manifest/result metadata without big files.
+
+        This deliberately authenticates the small manifest and result records
+        only.  It is used solely to protect live artifact owners during history
+        pruning; ordinary current loading retains full artifact validation.
+        """
+
+        validated = _validate_cell_id(cell_id)
+        cell_root = self._existing_cell_root(validated, missing_ok=True)
+        if cell_root is None:
+            if missing_ok:
+                return None
+            raise FileNotFoundError(f"no artifact cell for {validated!r}")
+        pointer_path = cell_root / "current.json"
+        if pointer_path.is_symlink():
+            raise ManifestValidationError(
+                f"current pointer is a symbolic link: {pointer_path}"
+            )
+        if not pointer_path.exists():
+            if missing_ok:
+                return None
+            raise FileNotFoundError(f"no current artifact for cell {validated!r}")
+        if not pointer_path.is_file():
+            raise ManifestValidationError(
+                f"current pointer is not a regular file: {pointer_path}"
+            )
+        pointer = _read_json_object(pointer_path, description="current pointer")
+        if (
+            set(pointer) != _CURRENT_KEYS
+            or pointer.get("schema") != self.current_schema
+        ):
+            raise ManifestValidationError("current pointer has an unsupported shape")
+        if pointer.get("cell_id") != validated:
+            raise ManifestValidationError("current pointer cell_id does not match")
+        attempt_id = _validate_uuid(pointer.get("attempt_id"), field="attempt_id")
+        expected_manifest = f"attempts/{attempt_id}/manifest.json"
+        if pointer.get("manifest_path") != expected_manifest:
+            raise ManifestValidationError(
+                "current pointer manifest_path is not its canonical attempt manifest"
+            )
+        _, manifest_path = _resolve_member(
+            cell_root,
+            expected_manifest,
+            field="manifest_path",
+        )
+        expected_digest = _validate_sha256(
+            pointer.get("manifest_sha256"), field="manifest_sha256"
+        )
+        if _sha256(manifest_path) != expected_digest:
+            raise ManifestValidationError("current manifest digest mismatch")
+        manifest = _read_json_object(manifest_path, description="attempt manifest")
+        if (
+            set(manifest) != _ATTEMPT_KEYS
+            or manifest.get("schema") != ATTEMPT_SCHEMA
+            or manifest.get("cell_id") != validated
+            or manifest.get("attempt_id") != attempt_id
+            or manifest.get("status") != "ok"
+            or manifest.get("error") is not None
+        ):
+            raise ManifestValidationError("current attempt manifest is invalid")
+        try:
+            ArtifactPolicy(manifest.get("artifact_policy"))
+        except (TypeError, ValueError) as error:
+            raise ManifestValidationError(
+                "current manifest artifact policy is invalid"
+            ) from error
+        self._validate_based_on(manifest.get("based_on"))
+        result_relative = _strict_relative_path(
+            manifest.get("result_path"), field="result_path"
+        ).as_posix()
+        raw_artifacts = manifest.get("artifacts")
+        if not isinstance(raw_artifacts, list):
+            raise ManifestValidationError("current manifest artifacts are invalid")
+        artifact_paths: list[str] = []
+        for index, record in enumerate(raw_artifacts):
+            if not isinstance(record, dict) or set(record) != _FILE_KEYS:
+                raise ManifestValidationError(
+                    f"current artifact record {index} is invalid"
+                )
+            relative = _strict_relative_path(
+                record.get("path"), field=f"artifacts[{index}].path"
+            ).as_posix()
+            _validate_sha256(record.get("sha256"), field=f"artifacts[{index}].sha256")
+            size = record.get("size")
+            if not isinstance(size, int) or isinstance(size, bool) or size < 0:
+                raise ManifestValidationError(
+                    f"artifacts[{index}].size must be a non-negative integer"
+                )
+            artifact_paths.append(relative)
+        if len(set(artifact_paths)) != len(artifact_paths):
+            raise ManifestValidationError("current manifest has duplicate artifacts")
+        result_record = next(
+            (
+                record
+                for record in raw_artifacts
+                if isinstance(record, dict) and record.get("path") == result_relative
+            ),
+            None,
+        )
+        if result_record is None:
+            raise ManifestValidationError("current result is absent from manifest")
+        result_file = self._validate_artifact_file(
+            manifest_path.parent,
+            result_record,
+            index=raw_artifacts.index(result_record),
+        )
+        result = self.materialize_current_result(
+            _read_json_object(result_file.path, description="attempt result")
+        )
+        return attempt_id, result
+
+    def protected_attempt_ids(
+        self,
+        cell_id: str,
+        *,
+        consumer_cell_ids: Iterable[str],
+    ) -> frozenset[str]:
+        """Return target attempts retained by live current/equivalent consumers."""
+
+        validated = _validate_cell_id(cell_id)
+        attempt_ids = self.cell_attempt_ids(validated)
+        candidate_artifacts = {
+            self._attempt_root(validated, attempt_id)
+            .joinpath("artifact")
+            .resolve(strict=False): attempt_id
+            for attempt_id in attempt_ids
+        }
+        protected: set[str] = set()
+        own = self.lightweight_current_payload(validated, missing_ok=True)
+        if own is not None:
+            protected.add(own[0])
+        consumers = {_validate_cell_id(value) for value in consumer_cell_ids}
+        for consumer_id in sorted(consumers):
+            current = self.lightweight_current_payload(consumer_id, missing_ok=True)
+            if current is None:
+                continue
+            artifact = current[1].get("artifact")
+            raw_path = artifact.get("path") if isinstance(artifact, Mapping) else None
+            if not isinstance(raw_path, str) or not raw_path:
+                continue
+            if not Path(raw_path).is_absolute():
+                raise ManifestValidationError(
+                    f"current artifact path is not absolute: {raw_path!r}"
+                )
+            referenced_artifact = Path(raw_path)
+            if referenced_artifact.is_symlink() or not referenced_artifact.is_dir():
+                raise ManifestValidationError(
+                    f"current artifact path is unavailable or unsafe: {raw_path!r}"
+                )
+            owner = candidate_artifacts.get(
+                referenced_artifact.expanduser().resolve(strict=False)
+            )
+            if owner is not None:
+                protected.add(owner)
+        return frozenset(protected)
+
+    def archive_obsolete_attempts(
+        self,
+        cell_id: str,
+        *,
+        consumer_cell_ids: Iterable[str],
+    ) -> tuple[str, ...]:
+        """Archive sealed noncurrent attempts and remove only heavy payloads.
+
+        The caller must already hold the campaign-cell lock.  Per-attempt use
+        locks are acquired non-blockingly so a concurrent equivalent reuse is
+        never disturbed.
+        """
+
+        validated = _validate_cell_id(cell_id)
+        if self.attempt_history_root.exists() and (
+            self.attempt_history_root.is_symlink()
+            or not self.attempt_history_root.is_dir()
+        ):
+            raise ArtifactStoreError(
+                "attempt history root is not a regular directory: "
+                f"{self.attempt_history_root}"
+            )
+        history_cell = self._attempt_history_cell_root(validated)
+        try:
+            self._prune_archived_payloads(history_cell)
+        except OSError as error:
+            _raise_disk_full(error, history_cell)
+        archived: list[str] = []
+        for attempt_id in self.cell_attempt_ids(validated):
+            try:
+                with self.named_lock(
+                    f"campaign-artifact-use-{attempt_id}", timeout=0.0
+                ):
+                    protected = self.protected_attempt_ids(
+                        validated,
+                        consumer_cell_ids=consumer_cell_ids,
+                    )
+                    if attempt_id in protected:
+                        continue
+                    source = self._attempt_root(validated, attempt_id)
+                    manifest = source / "manifest.json"
+                    if (
+                        source.is_symlink()
+                        or not source.is_dir()
+                        or manifest.is_symlink()
+                        or not manifest.is_file()
+                    ):
+                        continue
+                    raw = _read_json_object(manifest, description="attempt manifest")
+                    if (
+                        set(raw) != _ATTEMPT_KEYS
+                        or raw.get("schema") != ATTEMPT_SCHEMA
+                        or raw.get("cell_id") != validated
+                        or raw.get("attempt_id") != attempt_id
+                        or raw.get("status") not in {"ok", "failed", "interrupted"}
+                    ):
+                        raise ManifestValidationError(
+                            f"sealed attempt metadata is invalid: {source}"
+                        )
+                    if history_cell.exists() and (
+                        history_cell.is_symlink() or not history_cell.is_dir()
+                    ):
+                        raise ArtifactStoreError(
+                            "attempt history is not a regular directory: "
+                            f"{history_cell}"
+                        )
+                    history_cell.mkdir(parents=True, exist_ok=True)
+                    destination = history_cell / attempt_id
+                    if destination.exists() or destination.is_symlink():
+                        raise ArtifactStoreError(
+                            f"attempt history collision: {destination}"
+                        )
+                    self._validate_attempt_tree(source)
+                    os.replace(source, destination)
+                    _fsync_directory(source.parent)
+                    _fsync_directory(history_cell)
+                    self._remove_archived_artifact(destination)
+                    archived.append(attempt_id)
+            except LockTimeoutError:
+                continue
+            except OSError as error:
+                _raise_disk_full(error, history_cell)
+        return tuple(archived)
+
+    def _prune_archived_payloads(self, history_cell: Path) -> None:
+        if not history_cell.exists():
+            return
+        if history_cell.is_symlink() or not history_cell.is_dir():
+            raise ArtifactStoreError(
+                f"attempt history is not a regular directory: {history_cell}"
+            )
+        for archived in sorted(history_cell.iterdir()):
+            if archived.is_symlink() or not archived.is_dir():
+                raise ArtifactStoreError(
+                    f"attempt history contains a non-directory: {archived}"
+                )
+            _validate_uuid(archived.name, field="attempt history member")
+            self._remove_archived_artifact(archived)
+
+    @staticmethod
+    def _validate_attempt_tree(attempt: Path) -> None:
+        for root, directories, files in os.walk(attempt, topdown=True):
+            root_path = Path(root)
+            for name in (*directories, *files):
+                member = root_path / name
+                if member.is_symlink() or (
+                    not member.is_dir() and not member.is_file()
+                ):
+                    raise ArtifactStoreError(
+                        f"attempt contains an unsafe member: {member}"
+                    )
+
+    @staticmethod
+    def _validate_archived_artifact(archived_attempt: Path) -> None:
+        artifact = archived_attempt / "artifact"
+        if not artifact.exists() and not artifact.is_symlink():
+            return
+        if artifact.is_symlink() or not artifact.is_dir():
+            raise ArtifactStoreError(
+                f"archived artifact payload is not a regular directory: {artifact}"
+            )
+        for root, directories, files in os.walk(artifact, topdown=True):
+            root_path = Path(root)
+            for name in (*directories, *files):
+                member = root_path / name
+                if member.is_symlink() or (
+                    not member.is_dir() and not member.is_file()
+                ):
+                    raise ArtifactStoreError(
+                        f"archived artifact payload contains an unsafe member: {member}"
+                    )
+
+    @classmethod
+    def _remove_archived_artifact(cls, archived_attempt: Path) -> None:
+        artifact = archived_attempt / "artifact"
+        cls._validate_archived_artifact(archived_attempt)
+        if not artifact.exists():
+            return
+        shutil.rmtree(artifact)
+        _fsync_directory(archived_attempt)
+
+    def _validate_current_pointer(
+        self,
+        pointer_path: Path,
+        *,
+        expected_cell_id: str | None,
+        expected_cell_root: Path,
+    ) -> CurrentRecord:
+        self._validate_cell_root_path(expected_cell_root, missing_ok=False)
+        if (
+            pointer_path.parent != expected_cell_root
+            or pointer_path.name != "current.json"
+            or pointer_path.is_symlink()
+            or not pointer_path.is_file()
+        ):
+            raise ManifestValidationError(
+                f"current pointer is not its canonical regular file: {pointer_path}"
+            )
+        pointer = _read_json_object(pointer_path, description="current pointer")
+        if set(pointer) != _CURRENT_KEYS:
+            raise ManifestValidationError(
+                f"current pointer has an unsupported schema shape: {pointer_path}"
+            )
+        if pointer["schema"] != self.current_schema:
+            raise ManifestValidationError(
+                f"unsupported current pointer schema: {pointer['schema']!r}"
+            )
+        cell_id = _validate_cell_id(pointer["cell_id"])
+        if expected_cell_id is not None and cell_id != expected_cell_id:
+            raise ManifestValidationError("current pointer cell_id does not match")
+        if expected_cell_root != self._cell_root(cell_id):
+            raise ManifestValidationError(
+                "current pointer is stored under the wrong cell directory"
+            )
+        attempt_id = _validate_uuid(pointer["attempt_id"], field="attempt_id")
+        expected_manifest = f"attempts/{attempt_id}/manifest.json"
+        if pointer["manifest_path"] != expected_manifest:
+            raise ManifestValidationError(
+                "current pointer manifest_path is not its canonical attempt manifest"
+            )
+        _, manifest_path = _resolve_member(
+            expected_cell_root,
+            pointer["manifest_path"],
+            field="manifest_path",
+        )
+        expected_digest = _validate_sha256(
+            pointer["manifest_sha256"],
+            field="manifest_sha256",
+        )
+        actual_digest = _sha256(manifest_path)
+        if actual_digest != expected_digest:
+            raise ManifestValidationError("current manifest digest mismatch")
+        return self._validate_attempt_manifest(
+            manifest_path,
+            expected_cell_id=cell_id,
+            expected_attempt_id=attempt_id,
+            expected_digest=expected_digest,
+        )
+
+    def _validate_attempt_manifest(
+        self,
+        manifest_path: Path,
+        *,
+        expected_cell_id: str,
+        expected_attempt_id: str,
+        expected_digest: str,
+    ) -> CurrentRecord:
+        manifest = _read_json_object(manifest_path, description="attempt manifest")
+        if set(manifest) != _ATTEMPT_KEYS:
+            raise ManifestValidationError(
+                f"attempt manifest has an unsupported schema shape: {manifest_path}"
+            )
+        if manifest["schema"] != ATTEMPT_SCHEMA:
+            raise ManifestValidationError(
+                f"unsupported attempt manifest schema: {manifest['schema']!r}"
+            )
+        if _validate_cell_id(manifest["cell_id"]) != expected_cell_id:
+            raise ManifestValidationError("attempt manifest cell_id does not match")
+        if (
+            _validate_uuid(manifest["attempt_id"], field="attempt_id")
+            != expected_attempt_id
+        ):
+            raise ManifestValidationError("attempt manifest attempt_id does not match")
+        if manifest["status"] != "ok":
+            raise ManifestValidationError(
+                "current pointer targets a non-success attempt"
+            )
+        if manifest["error"] is not None:
+            raise ManifestValidationError("successful attempt contains an error")
+        try:
+            policy = ArtifactPolicy(manifest["artifact_policy"])
+        except (TypeError, ValueError) as error:
+            raise ManifestValidationError(
+                "attempt manifest has an unsupported artifact policy"
+            ) from error
+        self._validate_based_on(manifest["based_on"])
+        result_relative = _strict_relative_path(
+            manifest["result_path"],
+            field="result_path",
+        ).as_posix()
+        raw_artifacts = manifest["artifacts"]
+        if not isinstance(raw_artifacts, list) or not raw_artifacts:
+            raise ManifestValidationError(
+                "successful attempt must contain artifact records"
+            )
+        attempt_root = manifest_path.parent
+        artifacts: list[ArtifactFile] = []
+        seen: set[str] = set()
+        for index, raw_record in enumerate(raw_artifacts):
+            artifacts.append(
+                self._validate_artifact_file(
+                    attempt_root,
+                    raw_record,
+                    index=index,
+                )
+            )
+            relative = artifacts[-1].relative_path
+            if relative in seen:
+                raise ManifestValidationError(
+                    f"duplicate artifact path in attempt manifest: {relative}"
+                )
+            seen.add(relative)
+        if result_relative not in seen:
+            raise ManifestValidationError(
+                "result_path is not authenticated as an artifact"
+            )
+        result_file = next(
+            artifact
+            for artifact in artifacts
+            if artifact.relative_path == result_relative
+        )
+        result = self.materialize_current_result(
+            _read_json_object(result_file.path, description="attempt result")
+        )
+        return CurrentRecord(
+            cell_id=expected_cell_id,
+            attempt_id=expected_attempt_id,
+            manifest_path=manifest_path,
+            manifest_sha256=expected_digest,
+            result_path=result_file.path,
+            result=result,
+            artifacts=tuple(artifacts),
+            artifact_policy=policy,
+        )
+
+    @staticmethod
+    def _validate_based_on(raw: object) -> None:
+        if raw is None:
+            return
+        if not isinstance(raw, dict) or set(raw) != _BASED_ON_KEYS:
+            raise ManifestValidationError("based_on has an unsupported schema shape")
+        _validate_uuid(raw["attempt_id"], field="based_on.attempt_id")
+        _validate_sha256(
+            raw["manifest_sha256"],
+            field="based_on.manifest_sha256",
+        )
+
+    @staticmethod
+    def _validate_artifact_file(
+        attempt_root: Path,
+        raw_record: object,
+        *,
+        index: int,
+    ) -> ArtifactFile:
+        if not isinstance(raw_record, dict) or set(raw_record) != _FILE_KEYS:
+            raise ManifestValidationError(
+                f"artifact record {index} has an unsupported schema shape"
+            )
+        relative, path = _resolve_member(
+            attempt_root,
+            raw_record["path"],
+            field=f"artifacts[{index}].path",
+        )
+        size = raw_record["size"]
+        if not isinstance(size, int) or isinstance(size, bool) or size < 0:
+            raise ManifestValidationError(
+                f"artifacts[{index}].size must be a non-negative integer"
+            )
+        if path.stat().st_size != size:
+            raise ManifestValidationError(f"artifact size mismatch: {relative}")
+        expected_digest = _validate_sha256(
+            raw_record["sha256"],
+            field=f"artifacts[{index}].sha256",
+        )
+        if _sha256(path) != expected_digest:
+            raise ManifestValidationError(f"artifact digest mismatch: {relative}")
+        return ArtifactFile(relative, path, size, expected_digest)
+
+    def _publish(self, attempt: ArtifactAttempt) -> CurrentRecord:
+        manifest_path = attempt.root / "manifest.json"
+        digest = _sha256(manifest_path)
+        pointer = {
+            "schema": self.current_schema,
+            "cell_id": attempt.cell_id,
+            "attempt_id": attempt.attempt_id,
+            "manifest_path": f"attempts/{attempt.attempt_id}/manifest.json",
+            "manifest_sha256": digest,
+        }
+        with self.cell_lock(attempt.cell_id):
+            self._validate_attempt_manifest(
+                manifest_path,
+                expected_cell_id=attempt.cell_id,
+                expected_attempt_id=attempt.attempt_id,
+                expected_digest=digest,
+            )
+            pointer_path = self._cell_root(attempt.cell_id) / "current.json"
+            _atomic_write_json(pointer_path, pointer)
+            return self._validate_current_pointer(
+                pointer_path,
+                expected_cell_id=attempt.cell_id,
+                expected_cell_root=pointer_path.parent,
+            )
+
+
+class ArtifactAttempt:
+    """One immutable UUID-qualified attempt for a report cell."""
+
+    def __init__(
+        self,
+        *,
+        store: ArtifactStore,
+        cell_id: str,
+        attempt_id: str,
+        root: Path,
+        artifact_policy: ArtifactPolicy,
+        based_on: CurrentRecord | None,
+    ) -> None:
+        self.store = store
+        self.cell_id = cell_id
+        self.attempt_id = attempt_id
+        self.root = root
+        self.artifact_policy = artifact_policy
+        self.based_on = based_on
+        self._sealed = False
+
+    def __enter__(self) -> ArtifactAttempt:
+        return self
+
+    def __exit__(
+        self,
+        exception_type: type[BaseException] | None,
+        exception: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool:
+        del traceback
+        if not self._sealed:
+            if exception_type is None:
+                self.mark_interrupted("attempt exited without publication")
+            else:
+                self.mark_interrupted(f"{exception_type.__name__}: {exception}")
+        return False
+
+    def path(self, relative_path: str) -> Path:
+        if self._sealed:
+            raise ArtifactStoreError("attempt is already sealed")
+        _, path = _resolve_member(
+            self.root,
+            relative_path,
+            field="attempt output path",
+            require_file=False,
+        )
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+        except OSError as error:
+            _raise_disk_full(error, path)
+        return path
+
+    def write_json(
+        self,
+        relative_path: str,
+        payload: Mapping[str, Any],
+    ) -> Path:
+        path = self.path(relative_path)
+        _atomic_write_json(path, payload)
+        return path
+
+    def publish(
+        self,
+        result: Mapping[str, Any],
+        *,
+        artifact_paths: Iterable[str] = (),
+    ) -> CurrentRecord:
+        self._require_open()
+        self.write_json("result.json", self.store._stored_current_result(result))
+        relative_paths = {"result.json", *artifact_paths}
+        records = [self._file_record(relative) for relative in sorted(relative_paths)]
+        manifest = self._manifest(
+            status="ok",
+            result_path="result.json",
+            artifacts=records,
+            error=None,
+        )
+        _atomic_write_json(self.root / "manifest.json", manifest)
+        self._sealed = True
+        return self.store._publish(self)
+
+    def mark_failed(
+        self,
+        error: str,
+        *,
+        artifact_paths: Iterable[str] = (),
+    ) -> None:
+        self._seal_unsuccessful(
+            "failed",
+            error,
+            artifact_paths=artifact_paths,
+        )
+
+    def mark_interrupted(
+        self,
+        error: str,
+        *,
+        artifact_paths: Iterable[str] = (),
+    ) -> None:
+        self._seal_unsuccessful(
+            "interrupted",
+            error,
+            artifact_paths=artifact_paths,
+        )
+
+    def discard(self) -> None:
+        """Remove an unpublished attempt instead of retaining partial history."""
+
+        self._require_open()
+        if self.root.is_symlink() or not self.root.is_dir():
+            raise ArtifactStoreError(
+                f"attempt is not its canonical regular directory: {self.root}"
+            )
+        shutil.rmtree(self.root)
+        self._sealed = True
+
+    def _seal_unsuccessful(
+        self,
+        status: str,
+        error: str,
+        *,
+        artifact_paths: Iterable[str] = (),
+    ) -> None:
+        self._require_open()
+        if not isinstance(error, str) or not error:
+            raise ArtifactStoreError("failed attempt error must be a non-empty string")
+        manifest = self._manifest(
+            status=status,
+            result_path=None,
+            artifacts=[
+                self._file_record(relative) for relative in sorted(set(artifact_paths))
+            ],
+            error=error,
+        )
+        _atomic_write_json(self.root / "manifest.json", manifest)
+        self._sealed = True
+
+    def _file_record(self, relative_path: str) -> dict[str, Any]:
+        relative, path = _resolve_member(
+            self.root,
+            relative_path,
+            field="artifact path",
+        )
+        if path.name == "manifest.json":
+            raise ArtifactStoreError("manifest.json cannot authenticate itself")
+        return {
+            "path": relative,
+            "size": path.stat().st_size,
+            "sha256": _sha256(path),
+        }
+
+    def _manifest(
+        self,
+        *,
+        status: str,
+        result_path: str | None,
+        artifacts: list[dict[str, Any]],
+        error: str | None,
+    ) -> dict[str, Any]:
+        based_on = None
+        if self.based_on is not None:
+            based_on = {
+                "attempt_id": self.based_on.attempt_id,
+                "manifest_sha256": self.based_on.manifest_sha256,
+            }
+        return {
+            "schema": ATTEMPT_SCHEMA,
+            "cell_id": self.cell_id,
+            "attempt_id": self.attempt_id,
+            "status": status,
+            "artifact_policy": self.artifact_policy.value,
+            "based_on": based_on,
+            "result_path": result_path,
+            "artifacts": artifacts,
+            "error": error,
+        }
+
+    def _require_open(self) -> None:
+        if self._sealed:
+            raise ArtifactStoreError("attempt is already sealed")
+
+
+__all__ = [
+    "ATTEMPT_SCHEMA",
+    "CURRENT_SCHEMA",
+    "PORTABLE_CURRENT_SCHEMA",
+    "ArtifactAction",
+    "ArtifactAttempt",
+    "ArtifactDecision",
+    "ArtifactFile",
+    "ArtifactStore",
+    "ArtifactStoreError",
+    "CurrentRecord",
+    "DiskFullError",
+    "LockCancelledError",
+    "LockTimeoutError",
+    "ManifestValidationError",
+]
diff --git a/pyamplicol/tools/performance_report/boundary.py b/pyamplicol/tools/performance_report/boundary.py
new file mode 100644
index 0000000000..c69df0bd56
--- /dev/null
+++ b/pyamplicol/tools/performance_report/boundary.py
@@ -0,0 +1,169 @@
+# SPDX-License-Identifier: 0BSD
+"""Authoritative per-cell boundaries for asynchronous report publication."""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from typing import Any
+
+from .artifacts import ArtifactStore, ArtifactStoreError, CurrentRecord
+
+CELL_BOUNDARY_SCHEMA = "pyamplicol-performance-cell-boundary-v1"
+_SHA256_RE = re.compile(r"[0-9a-f]{64}")
+
+
+class CellBoundaryError(ArtifactStoreError):
+    """A fast-controller cell boundary was not authoritative."""
+
+
+def _artifact_digest(record: CurrentRecord, relative_path: str) -> str:
+    matches = [
+        artifact.sha256
+        for artifact in record.artifacts
+        if artifact.relative_path == relative_path
+    ]
+    if len(matches) != 1:
+        raise CellBoundaryError(
+            f"current attempt does not authenticate exactly one {relative_path}"
+        )
+    return matches[0]
+
+
+def _current_identity(record: CurrentRecord) -> dict[str, object]:
+    return {
+        "attempt_id": record.attempt_id,
+        "manifest_path": str(record.manifest_path),
+        "manifest_sha256": record.manifest_sha256,
+        "result_path": str(record.result_path),
+        "result_sha256": next(
+            artifact.sha256
+            for artifact in record.artifacts
+            if artifact.path == record.result_path
+        ),
+        "status": record.result.get("status"),
+        "worker_result_sha256": _artifact_digest(
+            record,
+            "worker-result.json",
+        ),
+    }
+
+
+def snapshot_cell_boundary(
+    store: ArtifactStore,
+    cell_id: str,
+) -> dict[str, object]:
+    """Snapshot one locked attempt inventory and authenticated current."""
+
+    with store.cell_lock(cell_id):
+        return _snapshot_cell_boundary_unlocked(store, cell_id)
+
+
+def _snapshot_cell_boundary_unlocked(
+    store: ArtifactStore,
+    cell_id: str,
+) -> dict[str, object]:
+    attempt_ids = store.cell_attempt_ids(cell_id)
+    current = store.load_current(cell_id, missing_ok=True)
+    return {
+        "schema": CELL_BOUNDARY_SCHEMA,
+        "cell_id": cell_id,
+        "attempt_ids": list(attempt_ids),
+        "current": None if current is None else _current_identity(current),
+    }
+
+
+def load_cell_boundary(path: Path) -> Mapping[str, Any]:
+    """Load a new snapshot or the legacy fast-wrapper snapshot shape."""
+
+    try:
+        payload = json.loads(path.read_text(encoding="ascii"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise CellBoundaryError(
+            f"cannot read pre-populate cell boundary {path}: {error}"
+        ) from error
+    if not isinstance(payload, dict):
+        raise CellBoundaryError("pre-populate cell boundary must be an object")
+    return payload
+
+
+def authenticate_current_delta(
+    store: ArtifactStore,
+    *,
+    cell_id: str,
+    expected_attempt_id: str,
+    before: Mapping[str, Any],
+    validate_result: Callable[[Mapping[str, Any]], None] | None = None,
+) -> dict[str, object]:
+    """Require exactly one new immutable attempt and its successful current."""
+
+    before_schema = before.get("schema")
+    if before_schema not in {None, CELL_BOUNDARY_SCHEMA}:
+        raise CellBoundaryError("pre-populate cell boundary schema differs")
+    before_cell = before.get("cell_id")
+    if before_cell not in {None, cell_id}:
+        raise CellBoundaryError("pre-populate cell boundary cell_id differs")
+    before_attempts = before.get("attempt_ids")
+    if (
+        not isinstance(before_attempts, list)
+        or not all(isinstance(value, str) for value in before_attempts)
+        or len(set(before_attempts)) != len(before_attempts)
+    ):
+        raise CellBoundaryError(
+            "pre-populate cell boundary has an invalid attempt inventory"
+        )
+    if before.get("current") is not None:
+        raise CellBoundaryError(
+            "accepted missing cell had a current before populate"
+        )
+
+    with store.cell_lock(cell_id):
+        after = _snapshot_cell_boundary_unlocked(store, cell_id)
+        after_attempts = after["attempt_ids"]
+        assert isinstance(after_attempts, list)
+        added = sorted(set(after_attempts) - set(before_attempts))
+        removed = sorted(set(before_attempts) - set(after_attempts))
+        if (
+            added != [expected_attempt_id]
+            or removed
+            or len(after_attempts) != len(before_attempts) + 1
+        ):
+            raise CellBoundaryError(
+                "populate did not add exactly its reported immutable attempt"
+            )
+        current = after["current"]
+        if not isinstance(current, dict):
+            raise CellBoundaryError("accepted cell has no authenticated current")
+        if (
+            current.get("attempt_id") != expected_attempt_id
+            or current.get("status") != "ok"
+        ):
+            raise CellBoundaryError(
+                "accepted current identity or result status differs"
+            )
+        for field in (
+            "manifest_sha256",
+            "result_sha256",
+            "worker_result_sha256",
+        ):
+            value = current.get(field)
+            if not isinstance(value, str) or _SHA256_RE.fullmatch(value) is None:
+                raise CellBoundaryError(
+                    f"accepted current lacks authenticated {field}"
+                )
+        record = store.load_current(cell_id)
+        assert record is not None
+        if validate_result is not None:
+            validate_result(record.result)
+        return after
+
+
+__all__ = [
+    "CELL_BOUNDARY_SCHEMA",
+    "CellBoundaryError",
+    "authenticate_current_delta",
+    "load_cell_boundary",
+    "snapshot_cell_boundary",
+]
diff --git a/pyamplicol/tools/performance_report/cache.py b/pyamplicol/tools/performance_report/cache.py
new file mode 100644
index 0000000000..7223adc35a
--- /dev/null
+++ b/pyamplicol/tools/performance_report/cache.py
@@ -0,0 +1,1674 @@
+# SPDX-License-Identifier: 0BSD
+"""Canonical reset caches and strict compact measurement validation."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections import Counter
+from collections.abc import Iterable, Mapping
+from pathlib import Path
+from typing import Any
+
+from .agreements import (
+    DIRECT_AGREEMENT_FIELD,
+    DIRECT_AGREEMENT_KINDS,
+    INDEPENDENT_AUTHORITY_ABI,
+    INDEPENDENT_AUTHORITY_FIELD,
+    LC_COMMON_COMPONENT_FIELD,
+    LC_LEGACY_PYAMPLICOL_COMPONENT,
+    MADGRAPH_COMPARISON_FIELD,
+    MADGRAPH_FULL_COLOUR,
+    incoming_agreement_edges,
+    independent_numerical_authorities,
+    madgraph_candidate_precision,
+    requires_independent_numerical_authority,
+    validate_direct_agreement_records,
+    validate_lc_common_component,
+    validate_madgraph_comparison_record,
+)
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .models import Accuracy, CellSpec, ExecutionMode, ResultStatus
+from .runner import (
+    CONDITIONED_COMPARISON_ABI,
+    CONVENTIONAL_WARMUP_FIELDS,
+    CONVENTIONAL_WARMUP_TIMING_SCOPE,
+    OTF_ACTIVE_FAMILY_COUNT_FIELDS,
+    OTF_COLD_WARMUP_FIELDS,
+    OTF_COLD_WARMUP_RUNTIME_FRESHNESSES,
+    OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE,
+    OTF_COLD_WARMUP_TIMING_SCOPE,
+    OTF_RECURRENCE_AUTHORITY_VALIDATION_ABI,
+    OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD,
+    OTF_RUNTIME_STATE_CENSUS_KIND,
+    OTF_RUNTIME_STATE_COUNT_FIELDS,
+    OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT,
+    OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY,
+    WARMUP_TIMER_SOURCE,
+    validate_conditioned_comparison_record,
+    validate_on_the_fly_recurrence_authority_validation_record,
+    validate_profile_warmup_evidence,
+    validate_resolved_sum_validation_record,
+)
+from .timing import (
+    ARENA_UNAVAILABLE_EXECUTION_TIMING_ABI,
+    EVALUATOR_TOTAL_TIMING_KEY,
+    MEASURED_EXECUTION_TIMING_ABI,
+    evaluator_total_timing_record,
+    unavailable_execution_timing_record,
+)
+
+CACHE_SCHEMA_VERSION = 5
+REPORT_VERSION = "0.3.0"
+_MEASURED_EXECUTION_TIMING_FIELDS = frozenset(
+    {
+        "abi",
+        "status",
+        "ratio_eligible",
+        "raw_seconds_per_point",
+        "source",
+        "compiled_direct_arena_active",
+        "sample_count",
+        "native_profile_points_per_sample",
+        "sample_contract",
+    }
+)
+_LOADED_ORIGIN_OBSERVATION_FIELDS = frozenset(
+    {
+        "observed_module_count",
+        "observations",
+        "observations_sha256",
+    }
+)
+_RUNTIME_POSTFLIGHT_FIELDS = frozenset(
+    {
+        "runtime_identity_sha256",
+        "runtime_identity_stable_sha256",
+        "runtime_identity_postflight_stable_sha256",
+        "runtime_identity_postflight_loaded_module_origin_policy",
+        "runtime_identity_postflight_match",
+    }
+)
+_PRECISION_DIAGNOSTIC_ABI = (
+    "pyamplicol-report-validation-failure-precision-diagnostic-v2"
+)
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=True,
+    ).encode("utf-8")
+
+
+def digest_json(value: object) -> str:
+    return hashlib.sha256(_canonical_json(value)).hexdigest()
+
+
+def _stable_runtime_identity(identity: Mapping[str, object]) -> dict[str, object]:
+    stable = dict(identity)
+    raw_policy = stable.get("loaded_module_origin_policy")
+    if isinstance(raw_policy, Mapping):
+        stable["loaded_module_origin_policy"] = {
+            field: value
+            for field, value in raw_policy.items()
+            if field not in _LOADED_ORIGIN_OBSERVATION_FIELDS
+        }
+    return stable
+
+
+def _loaded_origin_policy(
+    value: object,
+    name: str,
+) -> tuple[Mapping[str, object], list[object]]:
+    policy = _required_mapping(value, name)
+    observations = policy.get("observations")
+    count = policy.get("observed_module_count")
+    if (
+        policy.get("kind") != "pyamplicol-loaded-module-origin-policy-v1"
+        or policy.get("all_loaded_origins_authenticated") is not True
+        or policy.get("native_image_origin_bound") is not True
+        or policy.get("loaded_bytecode_eligible") is not False
+        or isinstance(count, bool)
+        or not isinstance(count, int)
+        or count < 1
+        or not isinstance(observations, list)
+        or len(observations) != count
+        or policy.get("observations_sha256") != digest_json(observations)
+    ):
+        raise ValueError(f"{name} is not authenticated loaded-origin evidence")
+    return policy, observations
+
+
+def _validate_runtime_identity_postflight(
+    provenance: Mapping[str, object],
+    validation: Mapping[str, object],
+) -> None:
+    """Require the initial/post-evaluation runtime identity binding."""
+
+    raw_identity = provenance.get("runtime_identity")
+    if raw_identity is None:
+        if (
+            provenance.get("method") == "original-amplicol-generated-library"
+            or validation.get("method") == "independent-original-amplicol-oracle"
+            or (
+                "source_revision" not in provenance
+                and not (_RUNTIME_POSTFLIGHT_FIELDS & provenance.keys())
+            )
+        ):
+            return
+        raise ValueError("successful pyAmpliCol measurement requires runtime_identity")
+    identity = _required_mapping(raw_identity, "provenance.runtime_identity")
+    if provenance.get("runtime_identity_sha256") != digest_json(identity):
+        raise ValueError("provenance.runtime_identity_sha256 does not match")
+    stable_digest = digest_json(_stable_runtime_identity(identity))
+    if provenance.get("runtime_identity_stable_sha256") != stable_digest:
+        raise ValueError("provenance.runtime_identity_stable_sha256 does not match")
+    if provenance.get("runtime_identity_postflight_stable_sha256") != stable_digest:
+        raise ValueError(
+            "provenance.runtime_identity postflight stable SHA-256 differs"
+        )
+    if provenance.get("runtime_identity_postflight_match") is not True:
+        raise ValueError("provenance.runtime_identity_postflight_match must be true")
+
+    initial_policy, initial_observations = _loaded_origin_policy(
+        identity.get("loaded_module_origin_policy"),
+        "provenance.runtime_identity.loaded_module_origin_policy",
+    )
+    postflight_policy, postflight_observations = _loaded_origin_policy(
+        provenance.get("runtime_identity_postflight_loaded_module_origin_policy"),
+        ("provenance.runtime_identity_postflight_loaded_module_origin_policy"),
+    )
+    stable_initial_policy = {
+        field: value
+        for field, value in initial_policy.items()
+        if field not in _LOADED_ORIGIN_OBSERVATION_FIELDS
+    }
+    stable_postflight_policy = {
+        field: value
+        for field, value in postflight_policy.items()
+        if field not in _LOADED_ORIGIN_OBSERVATION_FIELDS
+    }
+    if stable_postflight_policy != stable_initial_policy:
+        raise ValueError("provenance runtime postflight origin policy changed")
+    postflight_keys = {_canonical_json(record) for record in postflight_observations}
+    if any(
+        _canonical_json(record) not in postflight_keys
+        for record in initial_observations
+    ):
+        raise ValueError("provenance runtime postflight lost a loaded-module origin")
+
+
+def empty_measurement() -> dict[str, object]:
+    return {
+        "status": ResultStatus.NOT_AVAILABLE.value,
+        "generation_seconds": None,
+        "wall_seconds_per_point": None,
+        "execution_seconds_per_point": None,
+        "matrix_element": None,
+        "sample_count": None,
+        "standard_error_seconds_per_point": None,
+        "relative_standard_error": None,
+        "artifact": None,
+        "selector_contract": None,
+        "validation": None,
+        "resources": None,
+        "provenance": None,
+        "failure": None,
+    }
+
+
+def _measurement_spec_payload(cell: CellSpec) -> dict[str, object]:
+    measurement = cell.measurement
+    return {
+        "execution_mode": measurement.execution_mode.value,
+        "model": None if measurement.model is None else measurement.model.value,
+        "accuracy": measurement.accuracy.value,
+        "backend": measurement.backend,
+        "jit_optimization_level": measurement.jit_optimization_level,
+    }
+
+
+def reset_entry(cell: CellSpec) -> dict[str, object]:
+    return {
+        "cell_id": cell.cell_id,
+        "process_key": cell.process_key,
+        "process": cell.process,
+        "n_final": cell.n_final,
+        "variant": cell.variant,
+        "workload": cell.workload.value,
+        "measurement_spec": _measurement_spec_payload(cell),
+        "measurement": empty_measurement(),
+    }
+
+
+def build_reset_cache(dataset_id: str, cells: Iterable[CellSpec]) -> dict[str, object]:
+    selected = tuple(sorted(cells, key=lambda cell: cell.cell_id))
+    if not selected:
+        raise ValueError(f"dataset {dataset_id!r} has no cells")
+    if any(cell.dataset_id != dataset_id for cell in selected):
+        raise ValueError("cache cells must all belong to the requested dataset")
+    descriptors = [_measurement_spec_payload(cell) for cell in selected]
+    unique_descriptors = {
+        json.dumps(descriptor, sort_keys=True) for descriptor in descriptors
+    }
+    return {
+        "$schema": "./report-cache.schema.json",
+        "schema_version": CACHE_SCHEMA_VERSION,
+        "report_version": REPORT_VERSION,
+        "kind": "performance_measurements",
+        "dataset_id": dataset_id,
+        "measurement_specs": [
+            json.loads(value) for value in sorted(unique_descriptors)
+        ],
+        "entries": [reset_entry(cell) for cell in selected],
+    }
+
+
+def build_reset_caches(
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> dict[str, dict[str, object]]:
+    grouped: dict[str, list[CellSpec]] = {}
+    for cell in catalog.measurement_cells():
+        grouped.setdefault(cell.dataset_id, []).append(cell)
+    return {
+        f"{dataset_id}.json": build_reset_cache(dataset_id, cells)
+        for dataset_id, cells in sorted(grouped.items())
+    }
+
+
+def _required_mapping(value: object, name: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise ValueError(f"{name} must be an object")
+    return value
+
+
+def _required_number_or_none(value: object, name: str) -> float | None:
+    if value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValueError(f"{name} must be a number or null")
+    number = float(value)
+    if not number >= 0.0:
+        raise ValueError(f"{name} must be non-negative")
+    return number
+
+
+def _validate_execution_timing(
+    value: object,
+    *,
+    execution_seconds_per_point: float | None,
+    measurement_sample_count: int,
+    arena_profile_evidence: object,
+) -> None:
+    timing = _required_mapping(value, "measurement.provenance.execution_timing")
+    if timing.get("abi") == ARENA_UNAVAILABLE_EXECUTION_TIMING_ABI:
+        measurement = {
+            "execution_seconds_per_point": execution_seconds_per_point,
+            "provenance": {
+                "execution_timing": timing,
+                "arena_profile_evidence": arena_profile_evidence,
+            },
+        }
+        if (
+            unavailable_execution_timing_record(
+                measurement,
+                "execution_seconds_per_point",
+            )
+            is None
+            or timing.get("sample_count") != measurement_sample_count
+        ):
+            raise ValueError(
+                "measurement.provenance.execution_timing is not an "
+                "authenticated Arena unavailable-attribution record"
+            )
+        return
+    if set(timing) != _MEASURED_EXECUTION_TIMING_FIELDS:
+        raise ValueError(
+            "measurement.provenance.execution_timing fields do not match contract"
+        )
+    if timing.get("abi") != MEASURED_EXECUTION_TIMING_ABI:
+        raise ValueError("measurement.provenance.execution_timing ABI is invalid")
+    raw = timing.get("raw_seconds_per_point")
+    if (
+        isinstance(raw, bool)
+        or not isinstance(raw, (int, float))
+        or not math.isfinite(float(raw))
+        or float(raw) <= 0.0
+    ):
+        raise ValueError("measurement.provenance.execution_timing raw time is invalid")
+    sample_count = timing.get("sample_count")
+    if (
+        isinstance(sample_count, bool)
+        or not isinstance(sample_count, int)
+        or sample_count < 1
+        or sample_count != measurement_sample_count
+    ):
+        raise ValueError(
+            "measurement.provenance.execution_timing sample_count is invalid"
+        )
+    native_points = timing.get("native_profile_points_per_sample")
+    if native_points is not None and (
+        isinstance(native_points, bool)
+        or not isinstance(native_points, int)
+        or native_points < 1
+    ):
+        raise ValueError(
+            "measurement.provenance.execution_timing native point count is invalid"
+        )
+    sample_contract = timing.get("sample_contract")
+    if not isinstance(sample_contract, str) or not sample_contract:
+        raise ValueError(
+            "measurement.provenance.execution_timing sample contract is invalid"
+        )
+    if timing.get("status") != "measured":
+        raise ValueError(
+            "measurement.provenance.execution_timing status is unsupported"
+        )
+    if (
+        execution_seconds_per_point is None
+        or float(raw) != execution_seconds_per_point
+        or execution_seconds_per_point <= 0.0
+        or timing.get("ratio_eligible") is not True
+        or not isinstance(timing.get("compiled_direct_arena_active"), bool)
+        or not isinstance(timing.get("source"), str)
+        or not timing.get("source")
+    ):
+        raise ValueError(
+            "measurement.provenance.execution_timing measured record is inconsistent"
+        )
+
+
+def _validate_conditioned_measurement_bindings(
+    validation: Mapping[str, object],
+    *,
+    expected_cell: CellSpec | None,
+    selector_contract: object,
+) -> None:
+    resolved = validation.get("resolved_sum")
+    if not isinstance(resolved, Mapping):
+        return
+    point_identity = resolved.get("point_digest")
+    resolved_source = resolved.get("resolved_source_sha256")
+    high_resolved = validation.get("high_precision_resolved_sum")
+    high_source = (
+        high_resolved.get("resolved_source_sha256")
+        if isinstance(high_resolved, Mapping)
+        else None
+    )
+    component = validation.get(LC_COMMON_COMPONENT_FIELD)
+    for field in ("pointwise", "high_precision"):
+        record = validation.get(field)
+        if not (
+            isinstance(record, Mapping)
+            and record.get("abi") == CONDITIONED_COMPARISON_ABI
+        ):
+            continue
+        binding = _required_mapping(
+            record.get("comparison_binding"),
+            f"validation.{field}.comparison_binding",
+        )
+        identity = _required_mapping(
+            binding.get("selector_component_identity"),
+            f"validation.{field}.selector_component_identity",
+        )
+        if binding.get("point_digest") != point_identity:
+            raise ValueError(f"validation.{field} is bound to a different point")
+        value_kind = identity.get("value_kind")
+        if expected_cell is not None:
+            expected_identity = {
+                "cell_id": expected_cell.cell_id,
+                "accuracy": expected_cell.measurement.accuracy.value,
+                "workload": expected_cell.workload.value,
+                "selector_contract": selector_contract,
+                "value_kind": value_kind,
+            }
+            for key, expected in expected_identity.items():
+                if identity.get(key) != expected:
+                    raise ValueError(
+                        f"validation.{field} selector/component identity differs"
+                    )
+        if value_kind == LC_COMMON_COMPONENT_FIELD:
+            if not isinstance(component, Mapping):
+                raise ValueError(f"validation.{field} has no LC component scale source")
+            component_identity = identity.get("component_identity")
+            if not isinstance(component_identity, Mapping):
+                raise ValueError(
+                    f"validation.{field} LC component identity is unavailable"
+                )
+            for key in ("point_digest", "helicity_ids", "color_flow_ids"):
+                if component_identity.get(key) != component.get(key):
+                    raise ValueError(
+                        f"validation.{field} LC component identity differs"
+                    )
+            expected_candidate_source = digest_json(component)
+        else:
+            expected_candidate_source = resolved_source
+        if binding.get("candidate_source_sha256") != expected_candidate_source:
+            raise ValueError(
+                f"validation.{field} candidate scale source differs from resolved "
+                "evidence"
+            )
+        if field == "high_precision" and (
+            value_kind != "matrix-element-p16-versus-p32"
+            or binding.get("baseline_source_sha256") != high_source
+        ):
+            raise ValueError(
+                "validation.high_precision source binding differs from p32 evidence"
+            )
+
+
+def _validate_independent_authority_record(
+    validation: Mapping[str, object],
+    *,
+    expected_cell: CellSpec,
+    expected_status: str,
+    catalog: ReportCatalog,
+) -> None:
+    if not requires_independent_numerical_authority(
+        expected_cell,
+        catalog=catalog,
+    ):
+        raise ValueError(
+            "independent-authority evidence is not applicable to this catalog cell"
+        )
+    raw = validation.get(INDEPENDENT_AUTHORITY_FIELD)
+    record = _required_mapping(raw, f"validation.{INDEPENDENT_AUTHORITY_FIELD}")
+    expected_fields = {
+        "abi",
+        "expected_cell_ids",
+        "selected_cell_id",
+        "status",
+        "reason",
+        "same_artifact_diagnostics_are_authority",
+    }
+    canonical_ids = [
+        cell.cell_id
+        for cell in independent_numerical_authorities(
+            expected_cell,
+            catalog=catalog,
+        )
+    ]
+    if (
+        set(record) != expected_fields
+        or record.get("abi") != INDEPENDENT_AUTHORITY_ABI
+        or record.get("expected_cell_ids") != canonical_ids
+        or record.get("status") != expected_status
+        or record.get("same_artifact_diagnostics_are_authority") is not False
+    ):
+        raise ValueError("independent-authority record is invalid")
+    selected = record.get("selected_cell_id")
+    reason = record.get("reason")
+    if expected_status == "unavailable":
+        if selected is not None or reason != "no-successful-independent-authority":
+            raise ValueError("unavailable independent-authority record is invalid")
+    elif (
+        not isinstance(selected, str)
+        or selected not in canonical_ids
+        or not isinstance(reason, str)
+        or not reason
+    ):
+        raise ValueError("selected independent-authority record is invalid")
+
+
+def _validate_unverified_precision_diagnostic(value: object) -> None:
+    record = _required_mapping(value, "validation.precision_diagnostic")
+    if (
+        record.get("abi") != _PRECISION_DIAGNOSTIC_ABI
+        or record.get("promotes_measurement") is not False
+    ):
+        raise ValueError("unverified precision diagnostic is invalid")
+    if record.get("status") == "unavailable":
+        error = _required_mapping(
+            record.get("error"),
+            "validation.precision_diagnostic.error",
+        )
+        if not isinstance(error.get("kind"), str) or not isinstance(
+            error.get("message"), str
+        ):
+            raise ValueError("unavailable precision diagnostic has no error")
+        return
+    if record.get("status") != "diagnostic-only":
+        raise ValueError("unverified precision diagnostic status is invalid")
+    attempts = record.get("attempts")
+    if not isinstance(attempts, list) or [
+        attempt.get("precision_digits") if isinstance(attempt, Mapping) else None
+        for attempt in attempts
+    ] != [32, 200]:
+        raise ValueError("unverified precision diagnostic must retain p32 and p200")
+    if any(
+        attempt.get("status") not in {"evaluated", "unavailable"}
+        for attempt in attempts
+        if isinstance(attempt, Mapping)
+    ) or any(not isinstance(attempt, Mapping) for attempt in attempts):
+        raise ValueError("unverified precision diagnostic attempt is invalid")
+
+
+def _validate_standalone_internal_validation(
+    measurement: Mapping[str, object],
+    validation: Mapping[str, object],
+) -> None:
+    """Validate the p16/resolved/p32 contract for standalone benchmarks."""
+
+    if INDEPENDENT_AUTHORITY_FIELD in validation:
+        raise ValueError(
+            "standalone measurement cannot store independent-authority evidence"
+        )
+    resolved = _required_mapping(
+        validation.get("resolved_sum"),
+        "validation.resolved_sum",
+    )
+    high_resolved = _required_mapping(
+        validation.get("high_precision_resolved_sum"),
+        "validation.high_precision_resolved_sum",
+    )
+    high_precision = _required_mapping(
+        validation.get("high_precision"),
+        "validation.high_precision",
+    )
+    resolved_points = resolved.get("points")
+    high_points = high_resolved.get("points")
+    if (
+        not isinstance(resolved_points, list)
+        or len(resolved_points) != 1
+        or not isinstance(resolved_points[0], Mapping)
+        or not isinstance(high_points, list)
+        or len(high_points) != 1
+        or not isinstance(high_points[0], Mapping)
+    ):
+        raise ValueError(
+            "standalone measurement requires one p16 and one p32 resolved point"
+        )
+    resolved_point = resolved_points[0]
+    high_point = high_points[0]
+    if (
+        resolved.get("status") != ResultStatus.OK.value
+        or resolved.get("precision_digits") != 16
+        or high_resolved.get("status") != ResultStatus.OK.value
+        or high_resolved.get("precision_digits") != 32
+        or high_precision.get("status") != ResultStatus.OK.value
+    ):
+        raise ValueError(
+            "standalone measurement requires successful resolved and p32 validation"
+        )
+    identity_fields = (
+        "point_digest",
+        "helicity_ids",
+        "color_flow_ids",
+        "resolved_ordering_sha256",
+    )
+    if any(
+        resolved.get(field) != high_resolved.get(field) for field in identity_fields
+    ):
+        raise ValueError(
+            "standalone p16 and p32 resolved evidence has different identity"
+        )
+    matrix_element = measurement.get("matrix_element")
+    if (
+        isinstance(matrix_element, bool)
+        or not isinstance(matrix_element, (int, float))
+        or not math.isfinite(float(matrix_element))
+    ):
+        raise ValueError("standalone measurement matrix element is not finite")
+    expected_links = (
+        (resolved_point.get("candidate"), matrix_element),
+        (high_precision.get("candidate"), matrix_element),
+        (high_precision.get("baseline"), high_point.get("candidate")),
+        (
+            high_precision.get("candidate_scale"),
+            resolved_point.get("candidate_scale"),
+        ),
+        (
+            high_precision.get("baseline_scale"),
+            high_point.get("candidate_scale"),
+        ),
+        (high_precision.get("relative_tolerance"), resolved.get("relative_tolerance")),
+        (
+            high_precision.get("relative_tolerance"),
+            high_resolved.get("relative_tolerance"),
+        ),
+    )
+    if any(observed != expected for observed, expected in expected_links):
+        raise ValueError(
+            "standalone matrix element and p16/p32 evidence are not exactly linked"
+        )
+    if (
+        high_precision.get("candidate_scale_source") != "resolved-component-l1-binary64"
+        or high_precision.get("baseline_scale_source") != "resolved-component-l1-p32"
+    ):
+        raise ValueError("standalone p16/p32 scale-source labels are invalid")
+
+
+def _validate_unverified_direct_agreement_coverage(
+    validation: Mapping[str, object],
+    *,
+    expected_cell: CellSpec,
+    catalog: ReportCatalog,
+) -> None:
+    direct_records = validation.get(DIRECT_AGREEMENT_FIELD)
+    if not isinstance(direct_records, list):
+        raise ValueError("unverified result has no direct-agreement records")
+    observed_edges = {
+        (
+            record.get("edge_kind"),
+            record.get("baseline_cell_id"),
+            record.get("candidate_cell_id"),
+        )
+        for record in direct_records
+        if isinstance(record, Mapping)
+    }
+    if any(
+        record.get("status") != ResultStatus.OK.value
+        and record.get("edge_kind") != LC_LEGACY_PYAMPLICOL_COMPONENT
+        for record in direct_records
+        if isinstance(record, Mapping)
+    ):
+        raise ValueError("unverified result has a failed direct-agreement record")
+    catalog_edges = incoming_agreement_edges(expected_cell, catalog=catalog)
+    required_edges = {
+        (edge.kind, edge.baseline.cell_id, edge.candidate.cell_id)
+        for edge in catalog_edges
+        if edge.required
+    }
+    allowed_edges = {
+        (edge.kind, edge.baseline.cell_id, edge.candidate.cell_id)
+        for edge in catalog_edges
+    }
+    if not required_edges.issubset(observed_edges) or not (
+        observed_edges <= allowed_edges
+    ):
+        raise ValueError("unverified result direct-agreement coverage is incomplete")
+
+
+def _validate_successful_otf_recurrence_authority(
+    measurement: Mapping[str, object],
+    validation: Mapping[str, object],
+    *,
+    expected_cell: CellSpec,
+    catalog: ReportCatalog,
+) -> None:
+    if (
+        expected_cell.measurement.execution_mode is not ExecutionMode.ON_THE_FLY
+        or expected_cell.measurement.accuracy is not Accuracy.LC
+    ):
+        return
+    recurrence = catalog.validation_baseline_cell(expected_cell)
+    if (
+        recurrence is None
+        or recurrence.measurement.execution_mode is not ExecutionMode.RECURRENCE
+    ):
+        raise ValueError("on-the-fly recurrence authority is invalid")
+    provenance = _required_mapping(
+        measurement.get("provenance"), "measurement.provenance"
+    )
+    runtime_identity = _required_mapping(
+        provenance.get("runtime_identity"),
+        "measurement.provenance.runtime_identity",
+    )
+    candidate_artifact_id = runtime_identity.get("artifact_id")
+    if not isinstance(candidate_artifact_id, str):
+        raise ValueError("on-the-fly runtime identity has no artifact ID")
+    validate_on_the_fly_recurrence_authority_validation_record(
+        validation.get(OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD),
+        expected_cell=expected_cell,
+        selector_contract=measurement.get("selector_contract"),
+        candidate_artifact_id=candidate_artifact_id,
+        expected_authority_cell_id=recurrence.cell_id,
+    )
+
+
+def _validate_successful_otf_warmup_evidence(
+    measurement: Mapping[str, object],
+    *,
+    expected_cell: CellSpec,
+) -> None:
+    if expected_cell.measurement.execution_mode is not ExecutionMode.ON_THE_FLY:
+        return
+    provenance = _required_mapping(
+        measurement.get("provenance"), "measurement.provenance"
+    )
+    if provenance.get("runtime_load_included_in_cold_warmup") is not False:
+        raise ValueError(
+            "on-the-fly runtime load must be excluded from cold warm-up timing"
+        )
+    if provenance.get("generation_timer_excludes_model_preparation") is not True:
+        raise ValueError("on-the-fly generation timing must exclude model preparation")
+    effective = _required_mapping(
+        provenance.get("effective_config"),
+        "measurement.provenance.effective_config",
+    )
+    benchmark = _required_mapping(
+        effective.get("benchmark"),
+        "measurement.provenance.effective_config.benchmark",
+    )
+    expected_batch_size = benchmark.get("batch_size")
+    expected_warmup_runs = benchmark.get("warmup_runs")
+    if (
+        isinstance(expected_batch_size, bool)
+        or not isinstance(expected_batch_size, int)
+        or expected_batch_size < 1
+    ):
+        raise ValueError("on-the-fly effective benchmark batch_size must be positive")
+    if (
+        isinstance(expected_warmup_runs, bool)
+        or not isinstance(expected_warmup_runs, int)
+        or expected_warmup_runs < 0
+    ):
+        raise ValueError(
+            "on-the-fly effective benchmark warmup_runs must be non-negative"
+        )
+    validate_profile_warmup_evidence(
+        provenance.get("runtime_profile"),
+        execution_mode=expected_cell.measurement.execution_mode,
+        expected_batch_size=expected_batch_size,
+        expected_warmup_run_count=expected_warmup_runs,
+    )
+
+
+def validate_measurement(
+    value: object,
+    *,
+    expected_cell: CellSpec | None = None,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> None:
+    measurement = _required_mapping(value, "measurement")
+    expected_keys = set(empty_measurement())
+    if set(measurement) != expected_keys:
+        missing = sorted(expected_keys - set(measurement))
+        extra = sorted(set(measurement) - expected_keys)
+        raise ValueError(
+            f"measurement fields do not match schema; missing={missing}, extra={extra}"
+        )
+    try:
+        status = ResultStatus(str(measurement["status"]))
+    except ValueError as exc:
+        raise ValueError("measurement.status is unsupported") from exc
+    for field in (
+        "generation_seconds",
+        "wall_seconds_per_point",
+        "execution_seconds_per_point",
+        "standard_error_seconds_per_point",
+        "relative_standard_error",
+    ):
+        _required_number_or_none(measurement[field], f"measurement.{field}")
+    sample_count = measurement["sample_count"]
+    if sample_count is not None and (
+        isinstance(sample_count, bool)
+        or not isinstance(sample_count, int)
+        or sample_count < 1
+    ):
+        raise ValueError("measurement.sample_count must be a positive integer or null")
+    if status is ResultStatus.NOT_AVAILABLE:
+        expected = empty_measurement()
+        if dict(measurement) != expected:
+            raise ValueError("not_available measurement must be the canonical reset")
+    elif status in {ResultStatus.OK, ResultStatus.UNVERIFIED}:
+        retained_diagnostic = status is ResultStatus.UNVERIFIED
+        for field in (
+            "generation_seconds",
+            "wall_seconds_per_point",
+            "matrix_element",
+            "sample_count",
+            "artifact",
+            "validation",
+            "resources",
+            "provenance",
+        ):
+            if measurement[field] is None:
+                raise ValueError(f"measured result requires {field}")
+        validation = _required_mapping(measurement["validation"], "validation")
+        expected_validation_status = (
+            ResultStatus.UNVERIFIED.value
+            if retained_diagnostic
+            else ResultStatus.OK.value
+        )
+        if validation.get("status") != expected_validation_status:
+            raise ValueError("measurement validation status is inconsistent")
+        if "resolved_sum" in validation:
+            validate_resolved_sum_validation_record(validation["resolved_sum"])
+        for field in ("pointwise", "high_precision"):
+            if field in validation:
+                validate_conditioned_comparison_record(
+                    validation[field],
+                    require_binding=True,
+                )
+        if "high_precision_resolved_sum" in validation:
+            validate_resolved_sum_validation_record(
+                validation["high_precision_resolved_sum"]
+            )
+        _validate_conditioned_measurement_bindings(
+            validation,
+            expected_cell=expected_cell,
+            selector_contract=measurement.get("selector_contract"),
+        )
+        validate_direct_agreement_records(
+            validation.get(DIRECT_AGREEMENT_FIELD),
+            expected_candidate_id=(
+                None if expected_cell is None else expected_cell.cell_id
+            ),
+        )
+        madgraph_edges = (
+            ()
+            if expected_cell is None
+            else tuple(
+                edge
+                for edge in incoming_agreement_edges(
+                    expected_cell,
+                    catalog=catalog,
+                )
+                if edge.kind == MADGRAPH_FULL_COLOUR
+            )
+        )
+        if madgraph_edges:
+            validate_madgraph_comparison_record(
+                validation.get(MADGRAPH_COMPARISON_FIELD),
+                expected_candidate_id=expected_cell.cell_id,
+                expected_candidate_precision=madgraph_candidate_precision(
+                    expected_cell
+                ),
+            )
+        elif MADGRAPH_COMPARISON_FIELD in validation:
+            raise ValueError(
+                "measurement without a MadGraph edge has MadGraph comparison evidence"
+            )
+        selector_contract = measurement.get("selector_contract")
+        if expected_cell is not None:
+            expects_lc = expected_cell.measurement.accuracy is Accuracy.LC
+            if expects_lc and not isinstance(selector_contract, Mapping):
+                raise ValueError("successful LC measurement requires selector_contract")
+            if not expects_lc and selector_contract is not None:
+                raise ValueError(
+                    "successful non-LC measurement cannot contain selector_contract"
+                )
+        requires_lc_component = (
+            expected_cell.measurement.accuracy is Accuracy.LC
+            if expected_cell is not None
+            else isinstance(selector_contract, Mapping)
+        )
+        if requires_lc_component:
+            validate_lc_common_component(
+                validation.get(LC_COMMON_COMPONENT_FIELD),
+                expected_cell_id=(
+                    None if expected_cell is None else expected_cell.cell_id
+                ),
+                selector_contract=selector_contract,
+            )
+        elif validation.get(LC_COMMON_COMPONENT_FIELD) is not None:
+            raise ValueError("non-LC measurement cannot contain lc_common_component")
+        if expected_cell is not None and not retained_diagnostic:
+            _validate_successful_otf_recurrence_authority(
+                measurement,
+                validation,
+                expected_cell=expected_cell,
+                catalog=catalog,
+            )
+        if retained_diagnostic:
+            if (
+                expected_cell is None
+                or expected_cell.measurement.execution_mode
+                not in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+            ):
+                raise ValueError(
+                    "unverified timing requires a compiled/eager catalog cell"
+                )
+            _validate_independent_authority_record(
+                validation,
+                expected_cell=expected_cell,
+                expected_status="unavailable",
+                catalog=catalog,
+            )
+            _validate_unverified_direct_agreement_coverage(
+                validation,
+                expected_cell=expected_cell,
+                catalog=catalog,
+            )
+            resolved = _required_mapping(
+                validation.get("resolved_sum"),
+                "validation.resolved_sum",
+            )
+            high_resolved = _required_mapping(
+                validation.get("high_precision_resolved_sum"),
+                "validation.high_precision_resolved_sum",
+            )
+            high_precision = _required_mapping(
+                validation.get("high_precision"),
+                "validation.high_precision",
+            )
+            if any(
+                record.get("status") != ResultStatus.OK.value
+                for record in (resolved, high_resolved, high_precision)
+            ):
+                raise ValueError(
+                    "unverified result requires successful same-artifact diagnostics"
+                )
+            _validate_unverified_precision_diagnostic(
+                validation.get("precision_diagnostic")
+            )
+        elif (
+            expected_cell is not None
+            and (
+                expected_cell.measurement.execution_mode
+                is ExecutionMode.RECURRENCE
+                or (
+                    expected_cell.measurement.execution_mode
+                    in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+                    and not requires_independent_numerical_authority(
+                        expected_cell,
+                        catalog=catalog,
+                    )
+                )
+            )
+        ):
+            _validate_standalone_internal_validation(measurement, validation)
+        elif INDEPENDENT_AUTHORITY_FIELD in validation:
+            if expected_cell is None:
+                raise ValueError(
+                    "independent-authority evidence requires a catalog cell"
+                )
+            _validate_independent_authority_record(
+                validation,
+                expected_cell=expected_cell,
+                expected_status="verified",
+                catalog=catalog,
+            )
+            pointwise = _required_mapping(
+                validation.get("pointwise"),
+                "validation.pointwise",
+            )
+            if pointwise.get("status") != ResultStatus.OK.value:
+                raise ValueError(
+                    "verified independent-authority comparison is not successful"
+                )
+            if "precision_diagnostic" in validation:
+                _validate_unverified_precision_diagnostic(
+                    validation.get("precision_diagnostic")
+                )
+        provenance = _required_mapping(
+            measurement["provenance"], "measurement.provenance"
+        )
+        if expected_cell is not None:
+            _validate_successful_otf_warmup_evidence(
+                measurement,
+                expected_cell=expected_cell,
+            )
+        execution_seconds = _required_number_or_none(
+            measurement["execution_seconds_per_point"],
+            "measurement.execution_seconds_per_point",
+        )
+        raw_execution_timing = provenance.get("execution_timing")
+        if raw_execution_timing is not None:
+            _validate_execution_timing(
+                raw_execution_timing,
+                execution_seconds_per_point=execution_seconds,
+                measurement_sample_count=int(measurement["sample_count"]),
+                arena_profile_evidence=provenance.get("arena_profile_evidence"),
+            )
+        elif execution_seconds is None and "source_revision" in provenance:
+            raise ValueError(
+                "successful pyAmpliCol measurement with unavailable execution "
+                "timing requires authenticated Arena provenance"
+            )
+        if (
+            EVALUATOR_TOTAL_TIMING_KEY in provenance
+            and evaluator_total_timing_record(measurement) is None
+        ):
+            raise ValueError(
+                "measurement.provenance.evaluator_total_timing is not an "
+                "authenticated accumulated evaluator-total record"
+            )
+        _validate_runtime_identity_postflight(provenance, validation)
+        if retained_diagnostic:
+            failure = _required_mapping(
+                measurement["failure"],
+                "measurement.failure",
+            )
+            if (
+                set(failure) != {"kind", "message"}
+                or failure.get("kind") != "IndependentAuthorityUnavailable"
+                or not isinstance(failure.get("message"), str)
+                or not failure.get("message")
+            ):
+                raise ValueError("unverified result failure metadata is invalid")
+        elif measurement["failure"] is not None:
+            raise ValueError("successful measurement cannot contain failure metadata")
+    elif measurement["failure"] is None:
+        raise ValueError("non-success measurement requires failure metadata")
+
+
+def validate_cache(
+    payload: object,
+    *,
+    expected_cells: Iterable[CellSpec] | None = None,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> None:
+    expected_cell_list = None if expected_cells is None else tuple(expected_cells)
+    expected_by_id = (
+        {}
+        if expected_cell_list is None
+        else {cell.cell_id: cell for cell in expected_cell_list}
+    )
+    cache = _required_mapping(payload, "cache")
+    if cache.get("schema_version") != CACHE_SCHEMA_VERSION:
+        raise ValueError("cache schema_version is unsupported")
+    if cache.get("report_version") != REPORT_VERSION:
+        raise ValueError("cache report_version is unsupported")
+    if cache.get("kind") != "performance_measurements":
+        raise ValueError("cache kind is unsupported")
+    dataset_id = cache.get("dataset_id")
+    if not isinstance(dataset_id, str) or not dataset_id:
+        raise ValueError("cache dataset_id must be a non-empty string")
+    entries = cache.get("entries")
+    if not isinstance(entries, list):
+        raise ValueError("cache entries must be a list")
+    ids: list[str] = []
+    for index, raw_entry in enumerate(entries):
+        entry = _required_mapping(raw_entry, f"entries[{index}]")
+        cell_id = entry.get("cell_id")
+        if not isinstance(cell_id, str) or not cell_id:
+            raise ValueError(f"entries[{index}].cell_id must be a non-empty string")
+        ids.append(cell_id)
+        if entry.get("process_key") is not None and not isinstance(
+            entry.get("process_key"), str
+        ):
+            raise ValueError(f"entries[{index}].process_key must be a string or null")
+        if not isinstance(entry.get("process"), str):
+            raise ValueError(f"entries[{index}].process must be a string")
+        n_final = entry.get("n_final")
+        if isinstance(n_final, bool) or not isinstance(n_final, int) or n_final < 1:
+            raise ValueError(f"entries[{index}].n_final must be positive")
+        validate_measurement(
+            entry.get("measurement"),
+            expected_cell=expected_by_id.get(cell_id),
+            catalog=catalog,
+        )
+    duplicate_ids = sorted(
+        cell_id for cell_id, count in Counter(ids).items() if count > 1
+    )
+    if duplicate_ids:
+        raise ValueError(f"cache contains duplicate cell IDs: {duplicate_ids}")
+    if expected_cell_list is not None:
+        expected = sorted(cell.cell_id for cell in expected_cell_list)
+        if sorted(ids) != expected:
+            raise ValueError(f"cache coverage differs for dataset {dataset_id}")
+
+
+def schema_document() -> dict[str, object]:
+    statuses = [status.value for status in ResultStatus]
+    nullable_number: dict[str, Any] = {"type": ["number", "null"], "minimum": 0}
+    cold_warmup_required = sorted(OTF_COLD_WARMUP_FIELDS)
+    otf_warmup_required = sorted(CONVENTIONAL_WARMUP_FIELDS | OTF_COLD_WARMUP_FIELDS)
+    nonnegative_integer: dict[str, Any] = {"type": "integer", "minimum": 0}
+    active_family_fields = {
+        "basis": {"const": "shared-query-family-union-v1"},
+        "scope": {"const": "active-family-union"},
+        **{
+            field: dict(nonnegative_integer) for field in OTF_ACTIVE_FAMILY_COUNT_FIELDS
+        },
+    }
+    active_family_census: dict[str, Any] = {
+        "oneOf": [
+            {"type": "null"},
+            {
+                "type": "object",
+                "required": sorted(active_family_fields),
+                "properties": active_family_fields,
+                "additionalProperties": False,
+            },
+        ]
+    }
+    runtime_state_fields = {
+        "kind": {"const": OTF_RUNTIME_STATE_CENSUS_KIND},
+        "process_id": {"type": "string", "minLength": 1},
+        "family_cache_policy": {"const": OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY},
+        "family_cache_limit": {"const": OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT},
+        **{
+            field: dict(nonnegative_integer) for field in OTF_RUNTIME_STATE_COUNT_FIELDS
+        },
+        "active_family_union_census": active_family_census,
+    }
+    runtime_state_fields["retained_family_count"] = {
+        "type": "integer",
+        "minimum": 0,
+        "maximum": OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT,
+    }
+    runtime_state_census: dict[str, Any] = {
+        "type": "object",
+        "required": sorted(runtime_state_fields),
+        "properties": runtime_state_fields,
+        "additionalProperties": False,
+    }
+    runtime_profile: dict[str, Any] = {
+        "type": "object",
+        "properties": {
+            "cold_warmup_elapsed_seconds": {
+                "type": "number",
+                "exclusiveMinimum": 0,
+            },
+            "cold_warmup_run_count": {"const": 1},
+            "cold_warmup_batch_size": {"type": "integer", "minimum": 1},
+            "cold_warmup_point_count": {"type": "integer", "minimum": 1},
+            "cold_warmup_timer_source": {"const": WARMUP_TIMER_SOURCE},
+            "cold_warmup_timing_scope": {"const": OTF_COLD_WARMUP_TIMING_SCOPE},
+            "cold_warmup_runtime_freshness": {
+                "enum": sorted(OTF_COLD_WARMUP_RUNTIME_FRESHNESSES)
+            },
+            "cold_warmup_runtime_state_evidence": {
+                "const": OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE
+            },
+            "cold_warmup_runtime_state_before": runtime_state_census,
+            "cold_warmup_runtime_state_after": runtime_state_census,
+            "cold_warmup_runtime_cold_before_first_evaluation": {"type": "boolean"},
+            "cold_warmup_runtime_retained_before_first_evaluation": {"type": "boolean"},
+            "cold_warmup_runtime_retained_after_first_evaluation": {"const": True},
+            "cold_warmup_ratio_eligible": {"const": False},
+            "cold_warmup_acceptance_eligible": {"const": False},
+            "warmup_elapsed_seconds": {"type": "number", "minimum": 0},
+            "warmup_configured_run_count": {
+                "type": "integer",
+                "minimum": 0,
+            },
+            "warmup_batch_size": {"type": "integer", "minimum": 1},
+            "warmup_point_count": {"type": "integer", "minimum": 0},
+            "warmup_run_outer_wall_seconds": {
+                "type": "array",
+                "items": {"type": "number", "minimum": 0},
+            },
+            "first_warmup_run_outer_wall_seconds": {
+                "type": ["number", "null"],
+                "minimum": 0,
+            },
+            "warmup_timer_source": {"const": WARMUP_TIMER_SOURCE},
+            "warmup_timing_scope": {"const": CONVENTIONAL_WARMUP_TIMING_SCOPE},
+        },
+        "dependentRequired": {
+            field: otf_warmup_required for field in cold_warmup_required
+        },
+    }
+    provenance_record: dict[str, Any] = {
+        "oneOf": [
+            {"type": "null"},
+            {
+                "type": "object",
+                "properties": {
+                    "runtime_profile": runtime_profile,
+                    "runtime_load_included_in_cold_warmup": {"const": False},
+                    "generation_timer_excludes_model_preparation": {"const": True},
+                },
+            },
+        ]
+    }
+    direct_identity_properties: dict[str, Any] = {
+        "edge_kind": {"enum": list(DIRECT_AGREEMENT_KINDS)},
+        "value_kind": {"enum": ["matrix_element", LC_COMMON_COMPONENT_FIELD]},
+        "baseline_cell_id": {"type": "string", "minLength": 1},
+        "candidate_cell_id": {"type": "string", "minLength": 1},
+        "status": {"enum": statuses},
+        "candidate": {"type": "number"},
+        "baseline": {"type": "number"},
+        "absolute_difference": {"type": "number", "minimum": 0},
+        "relative_difference": {"type": "number", "minimum": 0},
+        "relative_tolerance": {"type": "number", "minimum": 0},
+    }
+    direct_v1: dict[str, Any] = {
+        "type": "object",
+        "required": [
+            "abi",
+            "edge_kind",
+            "value_kind",
+            "baseline_cell_id",
+            "candidate_cell_id",
+            "status",
+            "candidate",
+            "baseline",
+            "absolute_difference",
+            "relative_difference",
+            "relative_tolerance",
+            "absolute_tolerance",
+        ],
+        "properties": {
+            "abi": {"const": "pyamplicol-report-direct-agreement-v1"},
+            **direct_identity_properties,
+            "absolute_tolerance": {"type": "number", "minimum": 0},
+        },
+        "additionalProperties": False,
+    }
+    direct_v2_fields = [
+        "abi",
+        "edge_kind",
+        "value_kind",
+        "baseline_cell_id",
+        "candidate_cell_id",
+        "status",
+        "candidate",
+        "baseline",
+        "candidate_scale",
+        "baseline_scale",
+        "candidate_scale_source",
+        "baseline_scale_source",
+        "comparison_scale",
+        "absolute_difference",
+        "relative_difference",
+        "conditioned_residual",
+        "error_bound",
+        "relative_tolerance",
+        "comparison_binding",
+    ]
+    direct_v2: dict[str, Any] = {
+        "type": "object",
+        "required": direct_v2_fields,
+        "properties": {
+            "abi": {"const": "pyamplicol-report-direct-agreement-v2"},
+            **direct_identity_properties,
+            "candidate_scale": {"type": "number", "minimum": 0},
+            "baseline_scale": {"type": "number", "minimum": 0},
+            "candidate_scale_source": {"type": "string", "minLength": 1},
+            "baseline_scale_source": {"type": "string", "minLength": 1},
+            "comparison_scale": {"type": "number", "minimum": 0},
+            "conditioned_residual": {"type": "number", "minimum": 0},
+            "error_bound": {"type": "number", "minimum": 0},
+            "comparison_binding": {"type": "object", "minProperties": 1},
+        },
+        "additionalProperties": False,
+    }
+    direct_agreement_record: dict[str, Any] = {"oneOf": [direct_v1, direct_v2]}
+    lc_common_component: dict[str, Any] = {
+        "type": "object",
+        "required": [
+            "abi",
+            "cell_id",
+            "value",
+            "point_digest",
+            "helicity_ids",
+            "color_flow_ids",
+        ],
+        "properties": {
+            "abi": {"const": "pyamplicol-report-lc-common-component-v1"},
+            "cell_id": {"type": "string", "minLength": 1},
+            "value": {"type": "number"},
+            "point_digest": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$",
+            },
+            "helicity_ids": {
+                "type": "array",
+                "minItems": 1,
+                "uniqueItems": True,
+                "items": {"type": "string", "minLength": 1},
+            },
+            "color_flow_ids": {
+                "type": "array",
+                "minItems": 1,
+                "uniqueItems": True,
+                "items": {"type": "string", "minLength": 1},
+            },
+        },
+        "additionalProperties": False,
+    }
+    otf_total_summary: dict[str, Any] = {
+        "type": "object",
+        "required": [
+            "check_count",
+            "maximum_conditioned_residual",
+            "maximum_absolute_delta",
+        ],
+        "properties": {
+            "check_count": {"type": "integer", "minimum": 1},
+            "maximum_conditioned_residual": {"type": "number", "minimum": 0},
+            "maximum_absolute_delta": {"type": "number", "minimum": 0},
+        },
+        "additionalProperties": False,
+    }
+    otf_component_summary: dict[str, Any] = {
+        "type": "object",
+        "required": [
+            "check_count",
+            "component_count",
+            "maximum_conditioned_residual",
+            "maximum_absolute_delta",
+        ],
+        "properties": {
+            **otf_total_summary["properties"],
+            "component_count": {"type": "integer", "minimum": 1},
+        },
+        "additionalProperties": False,
+    }
+    otf_comparison: dict[str, Any] = {
+        "type": "object",
+        "required": ["authority_cell_id", "total", "resolved_components"],
+        "properties": {
+            "authority_cell_id": {"type": "string", "minLength": 1},
+            "total": otf_total_summary,
+            "resolved_components": otf_component_summary,
+        },
+        "additionalProperties": False,
+    }
+    otf_stage: dict[str, Any] = {
+        "type": "object",
+        "required": [
+            "candidate_total_source_sha256",
+            "candidate_resolved_total_source_sha256",
+            "candidate_resolved_ordering_sha256",
+            "candidate_resolved_source_sha256",
+            "candidate_resolved_sum",
+            "comparison",
+        ],
+        "properties": {
+            "candidate_total_source_sha256": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$",
+            },
+            "candidate_resolved_total_source_sha256": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$",
+            },
+            "candidate_resolved_ordering_sha256": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$",
+            },
+            "candidate_resolved_source_sha256": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$",
+            },
+            "candidate_resolved_sum": otf_total_summary,
+            "comparison": otf_comparison,
+        },
+        "additionalProperties": False,
+    }
+    otf_authority: dict[str, Any] = {
+        "type": "object",
+        "required": [
+            "cell_id",
+            "artifact_id",
+            "total_source_sha256",
+            "resolved_total_source_sha256",
+            "resolved_ordering_sha256",
+            "resolved_source_sha256",
+            "resolved_sum",
+        ],
+        "properties": {
+            "cell_id": {"type": "string", "minLength": 1},
+            **{
+                field: {"type": "string", "pattern": "^[0-9a-f]{64}$"}
+                for field in (
+                    "artifact_id",
+                    "total_source_sha256",
+                    "resolved_total_source_sha256",
+                    "resolved_ordering_sha256",
+                    "resolved_source_sha256",
+                )
+            },
+            "resolved_sum": otf_total_summary,
+        },
+        "additionalProperties": False,
+    }
+    otf_recurrence_authority: dict[str, Any] = {
+        "type": "object",
+        "required": [
+            "abi",
+            "status",
+            "candidate_cell_id",
+            "candidate_artifact_id",
+            "workload",
+            "precision_digits",
+            "relative_tolerance",
+            "point_digest",
+            "selector_sha256",
+            "point_count",
+            "resolved_component_count",
+            "resolved_check_count",
+            "authority",
+            "before_clear",
+            "after_clear",
+            "lifecycle",
+        ],
+        "properties": {
+            "abi": {"const": OTF_RECURRENCE_AUTHORITY_VALIDATION_ABI},
+            "status": {"const": ResultStatus.OK.value},
+            "candidate_cell_id": {"type": "string", "minLength": 1},
+            "candidate_artifact_id": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$",
+            },
+            "workload": {"enum": ["selected-flow", "all-flow"]},
+            "precision_digits": {"const": 16},
+            "relative_tolerance": {"const": 1.0e-12},
+            "point_digest": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
+            "selector_sha256": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$",
+            },
+            "point_count": {"type": "integer", "minimum": 1},
+            "resolved_component_count": {"type": "integer", "minimum": 1},
+            "resolved_check_count": {"type": "integer", "minimum": 1},
+            "authority": otf_authority,
+            "before_clear": otf_stage,
+            "after_clear": otf_stage,
+            "lifecycle": {
+                "type": "object",
+                "required": [
+                    "authority_artifact_loaded_only",
+                    "candidate_loaded_before_validation",
+                    "validated_before_clear",
+                    "validated_after_clear",
+                    "clear_call_count",
+                    "final_clear_before_profile",
+                ],
+                "properties": {
+                    "authority_artifact_loaded_only": {"const": True},
+                    "candidate_loaded_before_validation": {"const": True},
+                    "validated_before_clear": {"const": True},
+                    "validated_after_clear": {"const": True},
+                    "clear_call_count": {"const": 2},
+                    "final_clear_before_profile": {"const": True},
+                },
+                "additionalProperties": False,
+            },
+        },
+        "additionalProperties": False,
+    }
+    validation_properties = {
+        "status": {"enum": statuses},
+        DIRECT_AGREEMENT_FIELD: {
+            "type": "array",
+            "items": direct_agreement_record,
+        },
+        INDEPENDENT_AUTHORITY_FIELD: {
+            "type": "object",
+            "required": [
+                "abi",
+                "expected_cell_ids",
+                "selected_cell_id",
+                "status",
+                "reason",
+                "same_artifact_diagnostics_are_authority",
+            ],
+            "properties": {
+                "abi": {"const": INDEPENDENT_AUTHORITY_ABI},
+                "expected_cell_ids": {
+                    "type": "array",
+                    "uniqueItems": True,
+                    "items": {"type": "string", "minLength": 1},
+                },
+                "selected_cell_id": {"type": ["string", "null"]},
+                "status": {
+                    "enum": ["unavailable", "verified", "mismatch", "incompatible"]
+                },
+                "reason": {"type": "string", "minLength": 1},
+                "same_artifact_diagnostics_are_authority": {"const": False},
+            },
+            "additionalProperties": False,
+        },
+        LC_COMMON_COMPONENT_FIELD: lc_common_component,
+        MADGRAPH_COMPARISON_FIELD: {"type": "object"},
+        OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD: otf_recurrence_authority,
+    }
+    validation_record: dict[str, Any] = {
+        "oneOf": [
+            {"type": "null"},
+            {
+                "type": "object",
+                "properties": validation_properties,
+            },
+        ]
+    }
+    successful_validation_record: dict[str, Any] = {
+        "type": "object",
+        "required": [DIRECT_AGREEMENT_FIELD],
+        "properties": validation_properties,
+    }
+    return {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "$id": "https://pyamplicol.dev/schema/report-cache-v5.json",
+        "title": "pyAmpliCol performance cache",
+        "type": "object",
+        "required": [
+            "$schema",
+            "schema_version",
+            "report_version",
+            "kind",
+            "dataset_id",
+            "measurement_specs",
+            "entries",
+        ],
+        "properties": {
+            "$schema": {"const": "./report-cache.schema.json"},
+            "schema_version": {"const": CACHE_SCHEMA_VERSION},
+            "report_version": {"const": REPORT_VERSION},
+            "kind": {"const": "performance_measurements"},
+            "dataset_id": {"type": "string", "minLength": 1},
+            "measurement_specs": {"type": "array", "items": {"type": "object"}},
+            "entries": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "required": [
+                        "cell_id",
+                        "process_key",
+                        "process",
+                        "n_final",
+                        "variant",
+                        "workload",
+                        "measurement_spec",
+                        "measurement",
+                    ],
+                    "properties": {
+                        "cell_id": {"type": "string", "minLength": 1},
+                        "process_key": {"type": ["string", "null"]},
+                        "process": {"type": "string", "minLength": 1},
+                        "n_final": {"type": "integer", "minimum": 1},
+                        "variant": {"type": ["string", "null"]},
+                        "workload": {
+                            "enum": ["selected-flow", "all-flow", "contracted"]
+                        },
+                        "measurement_spec": {"type": "object"},
+                        "measurement": {
+                            "type": "object",
+                            "required": list(empty_measurement()),
+                            "properties": {
+                                "status": {"enum": statuses},
+                                "generation_seconds": nullable_number,
+                                "wall_seconds_per_point": nullable_number,
+                                "execution_seconds_per_point": nullable_number,
+                                "matrix_element": {
+                                    "type": ["number", "string", "null"]
+                                },
+                                "sample_count": {
+                                    "type": ["integer", "null"],
+                                    "minimum": 1,
+                                },
+                                "standard_error_seconds_per_point": nullable_number,
+                                "relative_standard_error": nullable_number,
+                                "artifact": {"type": ["object", "null"]},
+                                "selector_contract": {"type": ["object", "null"]},
+                                "validation": validation_record,
+                                "resources": {"type": ["object", "null"]},
+                                "provenance": provenance_record,
+                                "failure": {"type": ["object", "null"]},
+                            },
+                            "allOf": [
+                                {
+                                    "if": {
+                                        "properties": {
+                                            "status": {"const": ResultStatus.OK.value}
+                                        },
+                                        "required": ["status"],
+                                    },
+                                    "then": {
+                                        "properties": {
+                                            "validation": (successful_validation_record)
+                                        }
+                                    },
+                                },
+                                {
+                                    "if": {
+                                        "properties": {
+                                            "status": {
+                                                "const": ResultStatus.UNVERIFIED.value
+                                            }
+                                        },
+                                        "required": ["status"],
+                                    },
+                                    "then": {
+                                        "properties": {
+                                            "validation": {
+                                                "type": "object",
+                                                "required": [
+                                                    "status",
+                                                    DIRECT_AGREEMENT_FIELD,
+                                                    INDEPENDENT_AUTHORITY_FIELD,
+                                                    "resolved_sum",
+                                                    "high_precision_resolved_sum",
+                                                    "high_precision",
+                                                    "precision_diagnostic",
+                                                ],
+                                                "properties": validation_properties,
+                                            },
+                                            "failure": {"type": "object"},
+                                        }
+                                    },
+                                },
+                            ],
+                            "additionalProperties": False,
+                        },
+                    },
+                    "additionalProperties": False,
+                },
+            },
+        },
+        "additionalProperties": False,
+    }
+
+
+def write_reset_caches(
+    results_dir: Path,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[Path, ...]:
+    results_dir.mkdir(parents=True, exist_ok=True)
+    caches = build_reset_caches(catalog)
+    written: list[Path] = []
+    schema_path = results_dir / "report-cache.schema.json"
+    schema_path.write_bytes(_canonical_json(schema_document()) + b"\n")
+    written.append(schema_path)
+    for name, payload in caches.items():
+        path = results_dir / name
+        path.write_bytes(_canonical_json(payload) + b"\n")
+        written.append(path)
+    return tuple(written)
+
+
+__all__ = [
+    "CACHE_SCHEMA_VERSION",
+    "REPORT_VERSION",
+    "build_reset_cache",
+    "build_reset_caches",
+    "digest_json",
+    "empty_measurement",
+    "schema_document",
+    "validate_cache",
+    "validate_measurement",
+    "write_reset_caches",
+]
diff --git a/pyamplicol/tools/performance_report/campaign_activity.py b/pyamplicol/tools/performance_report/campaign_activity.py
new file mode 100644
index 0000000000..9d9da4df8c
--- /dev/null
+++ b/pyamplicol/tools/performance_report/campaign_activity.py
@@ -0,0 +1,288 @@
+# SPDX-License-Identifier: 0BSD
+"""Bounded campaign-idle census that excludes report-only publication work."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+_MEASUREMENT_ACTIONS = frozenset({"populate", "_worker", "_prepare"})
+_INSTALL_ENTRYPOINTS = frozenset(
+    {
+        "install_dependencies.py",
+        "prepare_source_runtime.py",
+    }
+)
+_NATIVE_BUILD_EXECUTABLES = frozenset({"cargo", "maturin", "rustc"})
+_LATEX_EXECUTABLES = frozenset(
+    {"latexmk", "lualatex", "pdflatex", "xelatex"}
+)
+
+
+class CampaignActivityError(RuntimeError):
+    """Raised when a measurement or mutation owner remains active."""
+
+
+@dataclass(frozen=True, slots=True)
+class OpenFile:
+    """One machine-readable ``lsof`` file-descriptor record."""
+
+    pid: int
+    command: str
+    descriptor: str
+    file_type: str
+    path: Path
+
+
+@dataclass(frozen=True, slots=True)
+class CampaignActivity:
+    """Blocking processes and coordination file descriptors."""
+
+    processes: tuple[str, ...]
+    coordination_files: tuple[OpenFile, ...]
+
+    @property
+    def idle(self) -> bool:
+        return not self.processes and not self.coordination_files
+
+
+def _arguments(command: str) -> tuple[str, ...]:
+    try:
+        return tuple(shlex.split(command))
+    except ValueError:
+        return tuple(command.split())
+
+
+def _argument_basename(argument: str) -> str:
+    return Path(argument).name.lower()
+
+
+def is_snapshot_publisher_process(command: str) -> bool:
+    """Return whether ``command`` is private snapshot render/compile work."""
+
+    arguments = _arguments(command)
+    lowered = tuple(argument.lower() for argument in arguments)
+    if "publish-snapshot" in lowered:
+        return True
+    basenames = {_argument_basename(argument) for argument in arguments}
+    return bool(
+        basenames & _LATEX_EXECUTABLES
+        and any(Path(argument).name == "pyAmpliCol.tex" for argument in arguments)
+    )
+
+
+def _is_campaign_process(
+    command: str,
+    *,
+    entrypoints: frozenset[str],
+) -> bool:
+    if is_snapshot_publisher_process(command):
+        return False
+    arguments = _arguments(command)
+    if not arguments:
+        return False
+    basenames = {_argument_basename(argument) for argument in arguments}
+    if basenames & _INSTALL_ENTRYPOINTS:
+        return True
+    if _argument_basename(arguments[0]) in _NATIVE_BUILD_EXECUTABLES:
+        return True
+    if not any(argument in _MEASUREMENT_ACTIONS for argument in arguments):
+        return False
+    if not entrypoints:
+        return True
+    resolved_arguments = {
+        os.path.realpath(argument)
+        for argument in arguments
+        if argument.endswith(".py")
+    }
+    return bool(resolved_arguments & entrypoints)
+
+
+def blocking_process_lines(
+    process_output: str,
+    *,
+    entrypoints: Iterable[Path] = (),
+) -> tuple[str, ...]:
+    """Filter ``ps -axo pid=,comm=,args=`` output to campaign blockers."""
+
+    exact_entrypoints = frozenset(
+        os.path.realpath(os.fspath(path)) for path in entrypoints
+    )
+    blocked: list[str] = []
+    for raw_line in process_output.splitlines():
+        line = raw_line.strip()
+        fields = line.split(None, 2)
+        if len(fields) != 3:
+            continue
+        if _is_campaign_process(fields[2], entrypoints=exact_entrypoints):
+            blocked.append(line)
+    return tuple(blocked)
+
+
+def parse_lsof_field_output(output: str) -> tuple[OpenFile, ...]:
+    """Parse ``lsof -Fpcfnt`` output without depending on display columns."""
+
+    records: list[OpenFile] = []
+    pid: int | None = None
+    command = ""
+    descriptor = ""
+    file_type = ""
+    path: Path | None = None
+
+    def flush_file() -> None:
+        nonlocal descriptor, file_type, path
+        if pid is not None and descriptor and path is not None:
+            records.append(
+                OpenFile(
+                    pid=pid,
+                    command=command,
+                    descriptor=descriptor,
+                    file_type=file_type,
+                    path=path,
+                )
+            )
+        descriptor = ""
+        file_type = ""
+        path = None
+
+    for line in output.splitlines():
+        if not line:
+            continue
+        field, value = line[0], line[1:]
+        if field == "p":
+            flush_file()
+            try:
+                pid = int(value)
+            except ValueError:
+                pid = None
+            command = ""
+        elif field == "c":
+            command = value
+        elif field == "f":
+            flush_file()
+            descriptor = value
+            file_type = ""
+        elif field == "t":
+            file_type = value
+        elif field == "n":
+            path = Path(value)
+    flush_file()
+    return tuple(records)
+
+
+def is_publisher_private_coordination_file(
+    record: OpenFile,
+    *,
+    coordination_root: Path,
+) -> bool:
+    """Recognize only regular publisher-private coordination state."""
+
+    publication_root = (
+        coordination_root.expanduser().resolve(strict=False) / "publication"
+    )
+    path = record.path.expanduser().resolve(strict=False)
+    return (
+        record.file_type == "REG"
+        and path != publication_root
+        and publication_root in path.parents
+    )
+
+
+def blocking_coordination_files(
+    lsof_output: str,
+    *,
+    coordination_root: Path,
+) -> tuple[OpenFile, ...]:
+    """Exclude publisher-private files but retain every lock/write owner."""
+
+    return tuple(
+        record
+        for record in parse_lsof_field_output(lsof_output)
+        if not is_publisher_private_coordination_file(
+            record,
+            coordination_root=coordination_root,
+        )
+    )
+
+
+def campaign_activity(
+    *,
+    coordination_root: Path,
+    entrypoints: Sequence[Path] = (),
+) -> CampaignActivity:
+    """Take one read-only process/coordination census."""
+
+    processes = subprocess.run(
+        ("ps", "-axo", "pid=,comm=,args="),
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout
+    lsof = subprocess.run(
+        (
+            "lsof",
+            "-Fpcfnt",
+            "+D",
+            os.fspath(coordination_root),
+        ),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return CampaignActivity(
+        processes=blocking_process_lines(
+            processes,
+            entrypoints=entrypoints,
+        ),
+        coordination_files=blocking_coordination_files(
+            lsof.stdout,
+            coordination_root=coordination_root,
+        ),
+    )
+
+
+def require_campaign_idle(
+    *,
+    coordination_root: Path,
+    entrypoints: Sequence[Path] = (),
+) -> None:
+    """Reject real campaign activity without treating the publisher as a worker."""
+
+    activity = campaign_activity(
+        coordination_root=coordination_root,
+        entrypoints=entrypoints,
+    )
+    if activity.processes:
+        raise CampaignActivityError(
+            "measurement or install process remains active: "
+            f"{list(activity.processes[:10])}"
+        )
+    if activity.coordination_files:
+        held = [
+            (
+                f"{record.command}[{record.pid}] "
+                f"{record.descriptor} {record.file_type} {record.path}"
+            )
+            for record in activity.coordination_files[:10]
+        ]
+        raise CampaignActivityError(
+            f"campaign coordination files remain held: {held}"
+        )
+
+
+__all__ = [
+    "CampaignActivity",
+    "CampaignActivityError",
+    "OpenFile",
+    "blocking_coordination_files",
+    "blocking_process_lines",
+    "campaign_activity",
+    "is_publisher_private_coordination_file",
+    "is_snapshot_publisher_process",
+    "parse_lsof_field_output",
+    "require_campaign_idle",
+]
diff --git a/pyamplicol/tools/performance_report/campaign_holds.py b/pyamplicol/tools/performance_report/campaign_holds.py
new file mode 100644
index 0000000000..0f1508155b
--- /dev/null
+++ b/pyamplicol/tools/performance_report/campaign_holds.py
@@ -0,0 +1,464 @@
+# SPDX-License-Identifier: 0BSD
+"""Fail-closed re-admission of dependency-held campaign cells."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Iterable, Mapping
+from dataclasses import dataclass
+
+from .agreements import (
+    incoming_agreement_edges,
+    validation_baseline_is_required,
+)
+from .artifacts import ArtifactStore, CurrentRecord
+from .cache import validate_measurement
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .models import CellSpec, ResultStatus
+
+PRIOR_HELD_DISPOSITION_ABI = "pyamplicol-prior-held-disposition-v1"
+PRIOR_HELD_HISTORY_ABI = "pyamplicol-prior-held-history-v1"
+DEPENDENCY_HOLD_REASON = "authenticated non-ok dependency"
+_SHA256_RE = re.compile(r"[0-9a-f]{64}")
+_GIT_OBJECT_RE = re.compile(r"[0-9a-f]{40,64}")
+
+
+class PriorHeldEligibilityError(RuntimeError):
+    """A historical hold could not be classified without guessing."""
+
+
+@dataclass(frozen=True, slots=True)
+class PriorHeldDisposition:
+    """One authenticated historical-hold eligibility decision."""
+
+    cell_id: str
+    eligible: bool
+    reason: str
+    historical_reasons: tuple[str, ...]
+    historical_observations: tuple[tuple[str, str, str], ...]
+    target_attempt_ids: tuple[str, ...]
+    prerequisite_ids: tuple[str, ...]
+    blocking_prerequisites: tuple[tuple[str, str], ...]
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "abi": PRIOR_HELD_DISPOSITION_ABI,
+            "cell_id": self.cell_id,
+            "eligible": self.eligible,
+            "reason": self.reason,
+            "historical_reasons": list(self.historical_reasons),
+            "historical_observations": [
+                {
+                    "reason": reason,
+                    "summary_path": summary_path,
+                    "summary_sha256": summary_sha256,
+                }
+                for summary_path, summary_sha256, reason in (
+                    self.historical_observations
+                )
+            ],
+            "target_attempt_ids": list(self.target_attempt_ids),
+            "prerequisite_ids": list(self.prerequisite_ids),
+            "blocking_prerequisites": [
+                {"cell_id": cell_id, "state": state}
+                for cell_id, state in self.blocking_prerequisites
+            ],
+        }
+
+
+def prior_held_history_record(
+    cell_id: str,
+    observations: Iterable[Mapping[str, object]],
+) -> dict[str, object]:
+    """Build one complete, deterministic historical-hold record."""
+
+    if not isinstance(cell_id, str) or not cell_id:
+        raise PriorHeldEligibilityError(
+            "historical hold record has an invalid catalog cell identity"
+        )
+    normalized: list[dict[str, str]] = []
+    for index, observation in enumerate(observations):
+        if not isinstance(observation, Mapping) or set(observation) != {
+            "reason",
+            "summary_path",
+            "summary_sha256",
+        }:
+            raise PriorHeldEligibilityError(
+                f"{cell_id} historical hold observation {index} is invalid"
+            )
+        reason = observation.get("reason")
+        summary_path = observation.get("summary_path")
+        summary_sha256 = observation.get("summary_sha256")
+        if (
+            not isinstance(reason, str)
+            or not reason
+            or not isinstance(summary_path, str)
+            or not summary_path
+            or not isinstance(summary_sha256, str)
+            or _SHA256_RE.fullmatch(summary_sha256) is None
+        ):
+            raise PriorHeldEligibilityError(
+                f"{cell_id} historical hold observation {index} is invalid"
+            )
+        normalized.append(
+            {
+                "reason": reason,
+                "summary_path": summary_path,
+                "summary_sha256": summary_sha256,
+            }
+        )
+    if not normalized:
+        raise PriorHeldEligibilityError(f"{cell_id} historical hold history is empty")
+    normalized.sort(key=lambda observation: observation["summary_path"])
+    summary_paths = [observation["summary_path"] for observation in normalized]
+    if len(set(summary_paths)) != len(summary_paths):
+        raise PriorHeldEligibilityError(
+            f"{cell_id} historical hold history repeats a summary"
+        )
+    return {
+        "abi": PRIOR_HELD_HISTORY_ABI,
+        "cell_id": cell_id,
+        "observations": normalized,
+        "reasons": [observation["reason"] for observation in normalized],
+    }
+
+
+def _validated_historical_history(
+    cell_id: str,
+    raw_record: object,
+) -> tuple[tuple[str, ...], tuple[tuple[str, str, str], ...]]:
+    if not isinstance(raw_record, Mapping):
+        raise PriorHeldEligibilityError(
+            f"{cell_id} historical hold record must be an object"
+        )
+    observations = raw_record.get("observations")
+    if (
+        raw_record.get("abi") != PRIOR_HELD_HISTORY_ABI
+        or raw_record.get("cell_id") != cell_id
+        or not isinstance(observations, list)
+    ):
+        raise PriorHeldEligibilityError(f"{cell_id} historical hold record is invalid")
+    rebuilt = prior_held_history_record(cell_id, observations)
+    if dict(raw_record) != rebuilt:
+        raise PriorHeldEligibilityError(
+            f"{cell_id} historical hold record is inconsistent"
+        )
+    reasons = rebuilt["reasons"]
+    assert isinstance(reasons, list)
+    normalized = rebuilt["observations"]
+    assert isinstance(normalized, list)
+    return (
+        tuple(str(reason) for reason in reasons),
+        tuple(
+            (
+                str(observation["summary_path"]),
+                str(observation["summary_sha256"]),
+                str(observation["reason"]),
+            )
+            for observation in normalized
+        ),
+    )
+
+
+def catalog_prerequisite_cells(
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSpec, ...]:
+    """Return required baseline and agreement/equivalence prerequisites."""
+
+    candidate_baseline = catalog.validation_baseline_cell(cell)
+    baseline = (
+        candidate_baseline
+        if validation_baseline_is_required(cell, candidate_baseline)
+        else None
+    )
+    peers = tuple(
+        edge.baseline
+        for edge in incoming_agreement_edges(cell, catalog=catalog)
+        if edge.required
+    )
+    return tuple(
+        sorted(
+            {
+                prerequisite.cell_id: prerequisite
+                for prerequisite in (
+                    *((baseline,) if baseline is not None else ()),
+                    *peers,
+                )
+            }.values(),
+            key=lambda prerequisite: prerequisite.cell_id,
+        )
+    )
+
+
+def catalog_prerequisite_closure(
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSpec, ...]:
+    """Return the complete acyclic prerequisite closure for one cell."""
+
+    resolved: dict[str, CellSpec] = {}
+    visiting: set[str] = set()
+
+    def visit(candidate: CellSpec) -> None:
+        if candidate.cell_id in visiting:
+            raise PriorHeldEligibilityError(
+                f"report prerequisite cycle reaches {candidate.cell_id!r}"
+            )
+        visiting.add(candidate.cell_id)
+        try:
+            for prerequisite in catalog_prerequisite_cells(
+                candidate,
+                catalog=catalog,
+            ):
+                if prerequisite.cell_id not in resolved:
+                    visit(prerequisite)
+                    resolved[prerequisite.cell_id] = prerequisite
+        finally:
+            visiting.remove(candidate.cell_id)
+
+    visit(cell)
+    return tuple(resolved[cell_id] for cell_id in sorted(resolved))
+
+
+def _catalog_cells_by_id(catalog: ReportCatalog) -> dict[str, CellSpec]:
+    cells = catalog.measurement_cells()
+    by_id = {cell.cell_id: cell for cell in cells}
+    if len(by_id) != len(cells):
+        raise PriorHeldEligibilityError(
+            "report catalog contains duplicate cell identities"
+        )
+    return by_id
+
+
+def _validated_current_state(
+    store: ArtifactStore,
+    cell: CellSpec,
+    *,
+    expected_source_revision: str | None,
+    expected_source_tree: str | None,
+    authenticate_current: Callable[[CellSpec, CurrentRecord], bool] | None,
+) -> str:
+    current = store.load_current(cell.cell_id, missing_ok=True)
+    if current is None:
+        return "missing"
+    try:
+        validate_measurement(current.result, expected_cell=cell)
+    except ValueError as error:
+        raise PriorHeldEligibilityError(
+            f"{cell.cell_id} current measurement is invalid: {error}"
+        ) from error
+    raw_status = current.result.get("status")
+    try:
+        status = ResultStatus(str(raw_status))
+    except ValueError as error:
+        raise PriorHeldEligibilityError(
+            f"{cell.cell_id} current status is unknown"
+        ) from error
+    if status is not ResultStatus.OK:
+        return status.value
+    if expected_source_revision is not None:
+        provenance = current.result.get("provenance")
+        if (
+            not isinstance(provenance, Mapping)
+            or provenance.get("report_source_revision") != expected_source_revision
+            or provenance.get("report_measured_source_revision")
+            != expected_source_revision
+            or (
+                expected_source_tree is not None
+                and (
+                    provenance.get("report_source_tree") != expected_source_tree
+                    or provenance.get("report_measured_source_tree")
+                    != expected_source_tree
+                )
+            )
+        ):
+            return "source-stale"
+    if authenticate_current is not None:
+        authenticated = authenticate_current(cell, current)
+        if authenticated is not True:
+            return "unauthenticated"
+    return ResultStatus.OK.value
+
+
+def classify_prior_held_cells(
+    store: ArtifactStore,
+    prior_held_records: Mapping[str, object],
+    *,
+    active_scoped_hold_ids: Iterable[str] = (),
+    catalog: ReportCatalog = REPORT_CATALOG,
+    expected_source_revision: str | None = None,
+    expected_source_tree: str | None = None,
+    authenticate_current: Callable[[CellSpec, CurrentRecord], bool] | None = None,
+) -> dict[str, PriorHeldDisposition]:
+    """Classify historical holds without permanently excluding resolved cells.
+
+    Only histories in which every reason is
+    :data:`DEPENDENCY_HOLD_REASON` can become eligible. Eligibility also
+    requires an explicit source-authentication policy, a target that has never
+    acquired an attempt or current, no active scoped defect hold, and an
+    immutable, schema-valid ``ok`` current for every transitive baseline or
+    direct agreement/equivalence prerequisite.
+    """
+
+    prior_ids = tuple(prior_held_records)
+    active_ids = frozenset(active_scoped_hold_ids)
+    if any(
+        not isinstance(cell_id, str) or not cell_id
+        for cell_id in (*prior_ids, *active_ids)
+    ):
+        raise PriorHeldEligibilityError(
+            "hold input contains an invalid catalog cell identity"
+        )
+    if (expected_source_revision is None) != (expected_source_tree is None):
+        raise PriorHeldEligibilityError(
+            "expected source revision and tree must be provided together"
+        )
+    if expected_source_revision is not None and (
+        not isinstance(expected_source_revision, str)
+        or _GIT_OBJECT_RE.fullmatch(expected_source_revision) is None
+        or not isinstance(expected_source_tree, str)
+        or _GIT_OBJECT_RE.fullmatch(expected_source_tree) is None
+    ):
+        raise PriorHeldEligibilityError(
+            "expected source revision and tree must be Git object identities"
+        )
+    if expected_source_revision is None and authenticate_current is None:
+        raise PriorHeldEligibilityError(
+            "current source authentication policy is required"
+        )
+    by_id = _catalog_cells_by_id(catalog)
+    unknown = sorted((set(prior_ids) | active_ids) - set(by_id))
+    if unknown:
+        raise PriorHeldEligibilityError(
+            f"hold input contains unknown catalog cells: {unknown}"
+        )
+
+    dispositions: dict[str, PriorHeldDisposition] = {}
+    for cell_id in sorted(prior_ids):
+        cell = by_id[cell_id]
+        historical_reasons, historical_observations = _validated_historical_history(
+            cell_id,
+            prior_held_records[cell_id],
+        )
+        with store.cell_lock(cell_id):
+            current = store.load_current(cell_id, missing_ok=True)
+            attempt_ids = store.cell_attempt_ids(cell_id)
+        if current is not None and current.attempt_id not in attempt_ids:
+            raise PriorHeldEligibilityError(
+                f"{cell_id} current is absent from its attempt inventory"
+            )
+        prerequisites = catalog_prerequisite_closure(cell, catalog=catalog)
+        prerequisite_ids = tuple(prerequisite.cell_id for prerequisite in prerequisites)
+
+        if attempt_ids or current is not None:
+            dispositions[cell_id] = PriorHeldDisposition(
+                cell_id,
+                False,
+                "target-already-attempted",
+                historical_reasons,
+                historical_observations,
+                attempt_ids,
+                prerequisite_ids,
+                (),
+            )
+            continue
+        if cell_id in active_ids:
+            dispositions[cell_id] = PriorHeldDisposition(
+                cell_id,
+                False,
+                "active-scoped-defect-hold",
+                historical_reasons,
+                historical_observations,
+                (),
+                prerequisite_ids,
+                (),
+            )
+            continue
+        if any(reason != DEPENDENCY_HOLD_REASON for reason in historical_reasons):
+            dispositions[cell_id] = PriorHeldDisposition(
+                cell_id,
+                False,
+                "historical-hold-not-dependency",
+                historical_reasons,
+                historical_observations,
+                (),
+                prerequisite_ids,
+                (),
+            )
+            continue
+
+        blocking: list[tuple[str, str]] = []
+        for prerequisite in prerequisites:
+            if prerequisite.cell_id in active_ids:
+                blocking.append(
+                    (
+                        prerequisite.cell_id,
+                        "active-scoped-defect-hold",
+                    )
+                )
+                continue
+            state = _validated_current_state(
+                store,
+                prerequisite,
+                expected_source_revision=expected_source_revision,
+                expected_source_tree=expected_source_tree,
+                authenticate_current=authenticate_current,
+            )
+            if state != ResultStatus.OK.value:
+                blocking.append((prerequisite.cell_id, state))
+        dispositions[cell_id] = PriorHeldDisposition(
+            cell_id,
+            not blocking,
+            "eligible" if not blocking else "prerequisite-not-ok",
+            historical_reasons,
+            historical_observations,
+            (),
+            prerequisite_ids,
+            tuple(blocking),
+        )
+    return dispositions
+
+
+def active_prior_held_ids(
+    store: ArtifactStore,
+    prior_held_records: Mapping[str, object],
+    *,
+    active_scoped_hold_ids: Iterable[str] = (),
+    catalog: ReportCatalog = REPORT_CATALOG,
+    expected_source_revision: str | None = None,
+    expected_source_tree: str | None = None,
+    authenticate_current: Callable[[CellSpec, CurrentRecord], bool] | None = None,
+) -> frozenset[str]:
+    """Return only historical holds that are still fail-closed."""
+
+    dispositions = classify_prior_held_cells(
+        store,
+        prior_held_records,
+        active_scoped_hold_ids=active_scoped_hold_ids,
+        catalog=catalog,
+        expected_source_revision=expected_source_revision,
+        expected_source_tree=expected_source_tree,
+        authenticate_current=authenticate_current,
+    )
+    return frozenset(
+        cell_id
+        for cell_id, disposition in dispositions.items()
+        if not disposition.eligible
+    )
+
+
+__all__ = [
+    "DEPENDENCY_HOLD_REASON",
+    "PRIOR_HELD_DISPOSITION_ABI",
+    "PRIOR_HELD_HISTORY_ABI",
+    "PriorHeldDisposition",
+    "PriorHeldEligibilityError",
+    "active_prior_held_ids",
+    "catalog_prerequisite_cells",
+    "catalog_prerequisite_closure",
+    "classify_prior_held_cells",
+    "prior_held_history_record",
+]
diff --git a/pyamplicol/tools/performance_report/campaign_policy.py b/pyamplicol/tools/performance_report/campaign_policy.py
new file mode 100644
index 0000000000..ddd2de7552
--- /dev/null
+++ b/pyamplicol/tools/performance_report/campaign_policy.py
@@ -0,0 +1,1505 @@
+# SPDX-License-Identifier: 0BSD
+"""Profile-bound completion and resource policies for report campaigns."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from enum import StrEnum
+
+try:
+    from tools.ci.memory_watchdog import (
+        DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON,
+        DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON,
+        MEMORY_PROBE_REASON,
+        RSS_LIMIT_REASON,
+    )
+except ModuleNotFoundError as error:
+    if error.name not in {"tools", "tools.ci", "tools.ci.memory_watchdog"}:
+        raise
+    from ._memory_watchdog import (
+        DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON,
+        DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON,
+        MEMORY_PROBE_REASON,
+        RSS_LIMIT_REASON,
+    )
+
+from .cache import empty_measurement
+from .models import Accuracy, CellSpec, ExecutionMode, ResultStatus, Workload
+from .resources import PROCESS_TREE_MEMORY_METRIC_ABI
+from .source_identity import SOURCE_IDENTITY_SCHEMA, ReportSourceIdentity
+from .worker_harness import (
+    WORKER_HARNESS_PROVENANCE_FIELD,
+    WorkerHarnessError,
+    require_worker_harness_identity,
+)
+
+CAMPAIGN_POLICY_SCHEMA = "pyamplicol-report-campaign-policy-v1"
+LEGACY_POLICY_CENSOR_ABI = "pyamplicol-report-policy-censor-v2"
+POLICY_CENSOR_ABI = "pyamplicol-report-policy-censor-v3"
+RESOURCE_FRONTIER_ABI = "pyamplicol-report-resource-frontier-v1"
+GENERATION_PHASE_EVIDENCE_ABI = "pyamplicol-report-generation-phase-evidence-v1"
+WORKER_PHASE_STATE_ABI = "pyamplicol-report-worker-phase-state-v1"
+STRICT_POLICY_NAME = "strict-complete-v1"
+MACBOOK_M3_POLICY_NAME = "macbook-m3-v1"
+MACBOOK_M3_Z_TABLE_F_POLICY_NAME = "macbook-m3-z-table-f-v1"
+X86_EPYC_POLICY_NAME = "x86-epyc-v1"
+MACBOOK_M3_PROFILE = "macbook_M3"
+X86_EPYC_PROFILE = "x86_EPYC"
+MACBOOK_M3_WORKERS = 1
+MACBOOK_M3_CELL_CORES = 1
+MACBOOK_M3_TARGET_RUNTIME_SECONDS = 5.0
+MACBOOK_M3_MEMORY_LIMIT_BYTES = 30_000_000_000
+MACBOOK_M3_Z_TABLE_F_GENERATION_LIMIT_SECONDS = 60.0 * 60.0
+X86_EPYC_LEGACY_WORKERS = 10
+X86_EPYC_WORKERS = 25
+X86_EPYC_CELL_CORES = 1
+X86_EPYC_TARGET_RUNTIME_SECONDS = 5.0
+X86_EPYC_GENERATION_LIMIT_SECONDS = 2.0 * 60.0 * 60.0
+X86_EPYC_LEGACY_MEMORY_LIMIT_BYTES = 100_000_000_000
+X86_EPYC_MEMORY_LIMIT_BYTES = 80_000_000_000
+X86_EPYC_NATIVE_COMPILER_SLOTS = 4
+
+_SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
+_SOURCE_FIELDS = frozenset(
+    {
+        "report_source_identity_schema",
+        "report_source_revision",
+        "report_source_tree",
+        "report_measured_source_revision",
+        "report_measured_source_tree",
+        "report_source_clean",
+    }
+)
+_STUDY_CONTRACT_BINDING_FIELDS = frozenset(
+    {
+        "abi",
+        "study_id",
+        "study_contract_sha256",
+    }
+)
+_LEGACY_CENSOR_FIELDS = frozenset(
+    {
+        "abi",
+        "policy",
+        "profile",
+        "cell_id",
+        "kind",
+        "generation_limit_seconds",
+        "memory_limit_bytes",
+        "observed_generation_seconds",
+        "observed_rss_bytes",
+        "phase_evidence",
+        "dependencies",
+        "frontier",
+    }
+)
+_CENSOR_FIELDS = _LEGACY_CENSOR_FIELDS | {
+    "observed_guard_bytes",
+    "memory_metric_abi",
+    "memory_limit_reason",
+}
+_MEMORY_RESOURCE_FIELDS = frozenset(
+    {
+        "memory_metric_abi",
+        "current_physical_footprint_bytes",
+        "peak_physical_footprint_bytes",
+        "current_guard_bytes",
+        "peak_guard_bytes",
+        "memory_limit_bytes",
+        "memory_limit_reason",
+        "memory_probe_reason",
+    }
+)
+_MEMORY_LIMIT_REASONS = frozenset(
+    {
+        RSS_LIMIT_REASON,
+        DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON,
+    }
+)
+_MEMORY_PROBE_REASONS = frozenset(
+    {
+        MEMORY_PROBE_REASON,
+        DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON,
+    }
+)
+_DEPENDENCY_FIELDS = frozenset({"cell_id", "status", "censor_sha256"})
+_FRONTIER_FIELDS = frozenset({"abi", "lane", "root"})
+_FRONTIER_LANE_FIELDS = frozenset(
+    {
+        "process_key",
+        "execution_mode",
+        "model",
+        "accuracy",
+        "backend",
+        "jit_optimization_level",
+        "workload",
+        "variant",
+    }
+)
+_FRONTIER_ROOT_FIELDS = frozenset(
+    {
+        "cell_id",
+        "n_final",
+        "kind",
+        "status",
+        "censor_sha256",
+    }
+)
+_GENERATION_PHASE_FIELDS = frozenset(
+    {
+        "abi",
+        "phase_state_abi",
+        "configured_timeout_seconds",
+        "supervisor_reason",
+        "authenticated",
+        "run_id",
+        "worker_pid",
+        "final_sequence",
+        "final_phase",
+        "generation_started_monotonic_ns",
+        "generation_finished_monotonic_ns",
+        "generation_elapsed_seconds",
+        "final_state_sha256",
+        "error",
+    }
+)
+
+
+class CampaignPolicyError(ValueError):
+    """A report campaign or terminal measurement violates its bound policy."""
+
+
+class PolicyCensorKind(StrEnum):
+    GENERATION_LIMIT = "generation_limit"
+    MEMORY_LIMIT = "memory_limit"
+    WORKER_TIMEOUT = "worker_timeout"
+    PROFILING_TIMEOUT = "profiling_timeout"
+    VALIDATION_TIMEOUT = "validation_timeout"
+    DEPENDENCY = "dependency"
+    RESOURCE_FRONTIER = "resource_frontier"
+
+
+class PolicyMeasurementState(StrEnum):
+    SUCCESS = "success"
+    GENERATION_LIMIT = "generation_limit"
+    MEMORY_LIMIT = "memory_limit"
+    WORKER_TIMEOUT = "worker_timeout"
+    PROFILING_TIMEOUT = "profiling_timeout"
+    VALIDATION_TIMEOUT = "validation_timeout"
+    DEPENDENCY = "dependency"
+    RESOURCE_FRONTIER = "resource_frontier"
+
+
+@dataclass(frozen=True, slots=True)
+class CampaignPolicy:
+    name: str
+    allow_terminal_censors: bool
+    workers: int | None = None
+    cell_cores: int | None = None
+    target_runtime_seconds: float = X86_EPYC_TARGET_RUNTIME_SECONDS
+    generation_limit_seconds: float | None = None
+    memory_limit_bytes: int | None = None
+    require_symbolica_parallel: bool = False
+    generation_limit_all_cells: bool = False
+
+    def as_manifest(self) -> dict[str, object]:
+        return {
+            "schema": CAMPAIGN_POLICY_SCHEMA,
+            "name": self.name,
+            "allow_terminal_censors": self.allow_terminal_censors,
+            "workers": self.workers,
+            "cell_cores": self.cell_cores,
+            "target_runtime_seconds": self.target_runtime_seconds,
+            "generation_limit_seconds": self.generation_limit_seconds,
+            "memory_limit_bytes": self.memory_limit_bytes,
+            "generation_limit_exemptions": (
+                "none"
+                if self.generation_limit_all_cells
+                or self.generation_limit_seconds is None
+                else (
+                    "all original-AmpliCol cells and pyAmpliCol "
+                    "compiled/recurrence LC selected-flow cells"
+                )
+            ),
+            "require_symbolica_parallel": self.require_symbolica_parallel,
+        }
+
+
+STRICT_POLICY = CampaignPolicy(
+    name=STRICT_POLICY_NAME,
+    allow_terminal_censors=False,
+)
+MACBOOK_M3_POLICY = CampaignPolicy(
+    name=MACBOOK_M3_POLICY_NAME,
+    allow_terminal_censors=True,
+    workers=MACBOOK_M3_WORKERS,
+    cell_cores=MACBOOK_M3_CELL_CORES,
+    target_runtime_seconds=MACBOOK_M3_TARGET_RUNTIME_SECONDS,
+    memory_limit_bytes=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+)
+MACBOOK_M3_Z_TABLE_F_POLICY = CampaignPolicy(
+    name=MACBOOK_M3_Z_TABLE_F_POLICY_NAME,
+    allow_terminal_censors=True,
+    workers=MACBOOK_M3_WORKERS,
+    cell_cores=MACBOOK_M3_CELL_CORES,
+    target_runtime_seconds=MACBOOK_M3_TARGET_RUNTIME_SECONDS,
+    generation_limit_seconds=(MACBOOK_M3_Z_TABLE_F_GENERATION_LIMIT_SECONDS),
+    memory_limit_bytes=MACBOOK_M3_MEMORY_LIMIT_BYTES,
+    generation_limit_all_cells=True,
+)
+X86_EPYC_POLICY = CampaignPolicy(
+    name=X86_EPYC_POLICY_NAME,
+    allow_terminal_censors=True,
+    workers=X86_EPYC_WORKERS,
+    cell_cores=X86_EPYC_CELL_CORES,
+    target_runtime_seconds=X86_EPYC_TARGET_RUNTIME_SECONDS,
+    generation_limit_seconds=X86_EPYC_GENERATION_LIMIT_SECONDS,
+    memory_limit_bytes=X86_EPYC_MEMORY_LIMIT_BYTES,
+    require_symbolica_parallel=True,
+)
+
+
+def campaign_policy(name: str) -> CampaignPolicy:
+    if name == STRICT_POLICY_NAME:
+        return STRICT_POLICY
+    if name == MACBOOK_M3_POLICY_NAME:
+        return MACBOOK_M3_POLICY
+    if name == MACBOOK_M3_Z_TABLE_F_POLICY_NAME:
+        return MACBOOK_M3_Z_TABLE_F_POLICY
+    if name == X86_EPYC_POLICY_NAME:
+        return X86_EPYC_POLICY
+    raise CampaignPolicyError(f"unsupported report campaign policy {name!r}")
+
+
+def default_campaign_policy(profile: str) -> CampaignPolicy:
+    if profile == MACBOOK_M3_PROFILE:
+        return MACBOOK_M3_POLICY
+    if profile == X86_EPYC_PROFILE:
+        return X86_EPYC_POLICY
+    return STRICT_POLICY
+
+
+def validate_policy_profile(policy: CampaignPolicy, profile: str) -> None:
+    macbook_policies = {
+        MACBOOK_M3_POLICY,
+        MACBOOK_M3_Z_TABLE_F_POLICY,
+    }
+    if policy in macbook_policies and profile != MACBOOK_M3_PROFILE:
+        raise CampaignPolicyError(
+            f"{policy.name} is reserved for profile {MACBOOK_M3_PROFILE!r}"
+        )
+    if policy is X86_EPYC_POLICY and profile != X86_EPYC_PROFILE:
+        raise CampaignPolicyError(
+            f"{X86_EPYC_POLICY_NAME} is reserved for profile {X86_EPYC_PROFILE!r}"
+        )
+    if profile == X86_EPYC_PROFILE and policy is not X86_EPYC_POLICY:
+        raise CampaignPolicyError(
+            f"profile {X86_EPYC_PROFILE!r} requires {X86_EPYC_POLICY_NAME}"
+        )
+    if profile == MACBOOK_M3_PROFILE and policy not in macbook_policies:
+        raise CampaignPolicyError(
+            f"profile {MACBOOK_M3_PROFILE!r} requires a MacBook M3 policy"
+        )
+
+
+def policy_from_manifest(value: object, *, profile: str) -> CampaignPolicy:
+    if not isinstance(value, Mapping):
+        raise CampaignPolicyError("workspace campaign_policy must be an object")
+    name = value.get("name")
+    if not isinstance(name, str):
+        raise CampaignPolicyError("workspace campaign_policy has no name")
+    policy = campaign_policy(name)
+    accepted_manifests = [policy.as_manifest()]
+    if policy is X86_EPYC_POLICY:
+        legacy_manifest = policy.as_manifest()
+        legacy_manifest["workers"] = X86_EPYC_LEGACY_WORKERS
+        legacy_manifest["memory_limit_bytes"] = X86_EPYC_LEGACY_MEMORY_LIMIT_BYTES
+        accepted_manifests.append(legacy_manifest)
+    if dict(value) not in accepted_manifests:
+        raise CampaignPolicyError(
+            "workspace campaign_policy differs from its canonical definition"
+        )
+    validate_policy_profile(policy, profile)
+    return policy
+
+
+def generation_limit_exempt(cell: CellSpec) -> bool:
+    measurement = cell.measurement
+    return measurement.execution_mode is ExecutionMode.AMPLICOL or (
+        measurement.execution_mode in {ExecutionMode.COMPILED, ExecutionMode.RECURRENCE}
+        and measurement.accuracy is Accuracy.LC
+        and cell.workload is Workload.SELECTED_FLOW
+    )
+
+
+def generation_limit_for_cell(
+    policy: CampaignPolicy,
+    cell: CellSpec,
+) -> float | None:
+    if policy.generation_limit_seconds is None:
+        return None
+    if policy.generation_limit_all_cells:
+        return policy.generation_limit_seconds
+    if generation_limit_exempt(cell):
+        return None
+    return policy.generation_limit_seconds
+
+
+def validate_campaign_settings(policy: CampaignPolicy, settings: object) -> None:
+    """Reject settings that weaken or misstate an architecture policy."""
+
+    if policy is STRICT_POLICY:
+        return
+    checks = (
+        (getattr(settings, "workers", None), policy.workers, "workers"),
+        (getattr(settings, "cell_cores", None), policy.cell_cores, "cell_cores"),
+        (
+            getattr(settings, "target_runtime_seconds", None),
+            policy.target_runtime_seconds,
+            "target_runtime_seconds",
+        ),
+        (
+            getattr(settings, "max_rss_bytes", None),
+            policy.memory_limit_bytes,
+            "max_rss_bytes",
+        ),
+        (
+            getattr(settings, "generation_time_limit_seconds", None),
+            None,
+            "generation_time_limit_seconds",
+        ),
+        (getattr(settings, "timeout_seconds", None), None, "timeout_seconds"),
+        (
+            getattr(settings, "campaign_max_rss_bytes", None),
+            None,
+            "campaign_max_rss_bytes",
+        ),
+        (
+            getattr(settings, "allow_symbolica_parallel", None),
+            policy.require_symbolica_parallel,
+            "allow_symbolica_parallel",
+        ),
+    )
+    mismatches = [
+        f"{field}={observed!r}, expected {expected!r}"
+        for observed, expected, field in checks
+        if observed != expected
+    ]
+    if mismatches:
+        raise CampaignPolicyError(
+            f"{policy.name} settings differ: " + "; ".join(mismatches)
+        )
+
+
+def _canonical_digest(value: object) -> str:
+    return hashlib.sha256(
+        json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+
+
+def _finite_number(value: object, field: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise CampaignPolicyError(f"{field} must be a finite number")
+    number = float(value)
+    if not math.isfinite(number):
+        raise CampaignPolicyError(f"{field} must be finite")
+    return number
+
+
+def _source_provenance(
+    source_identity: ReportSourceIdentity | Mapping[str, object],
+) -> dict[str, object]:
+    provenance = (
+        source_identity.provenance()
+        if isinstance(source_identity, ReportSourceIdentity)
+        else dict(source_identity)
+    )
+    if set(provenance) != _SOURCE_FIELDS:
+        raise CampaignPolicyError("policy censor source identity is malformed")
+    return provenance
+
+
+def dependency_reference(
+    cell_id: str,
+    measurement: Mapping[str, object],
+) -> dict[str, object]:
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        raise CampaignPolicyError(f"dependency {cell_id!r} has no policy provenance")
+    digest = provenance.get("policy_censor_sha256")
+    if not isinstance(digest, str) or _SHA256_RE.fullmatch(digest) is None:
+        raise CampaignPolicyError(f"dependency {cell_id!r} has no policy-censor digest")
+    return {
+        "cell_id": cell_id,
+        "status": str(measurement.get("status")),
+        "censor_sha256": digest,
+    }
+
+
+def resource_lane_identity(cell: CellSpec) -> dict[str, object]:
+    """Return the canonical multiplicity-independent resource lane."""
+
+    measurement = cell.measurement
+    return {
+        "process_key": cell.process_key,
+        "execution_mode": measurement.execution_mode.value,
+        "model": None if measurement.model is None else measurement.model.value,
+        "accuracy": measurement.accuracy.value,
+        "backend": measurement.backend,
+        "jit_optimization_level": measurement.jit_optimization_level,
+        "workload": cell.workload.value,
+        "variant": cell.variant,
+    }
+
+
+def resource_frontier_reference(
+    cell: CellSpec,
+    source_cell: CellSpec,
+    source_measurement: Mapping[str, object],
+) -> dict[str, object]:
+    """Bind a higher cell directly to its first lower hard-resource censor."""
+
+    if source_cell.n_final >= cell.n_final or resource_lane_identity(
+        source_cell
+    ) != resource_lane_identity(cell):
+        raise CampaignPolicyError(
+            "resource-frontier source is not lower in the same lane"
+        )
+    provenance = source_measurement.get("provenance")
+    censor = (
+        provenance.get("policy_censor") if isinstance(provenance, Mapping) else None
+    )
+    digest = (
+        provenance.get("policy_censor_sha256")
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    if (
+        not isinstance(censor, Mapping)
+        or censor.get("kind")
+        not in {
+            PolicyCensorKind.GENERATION_LIMIT.value,
+            PolicyCensorKind.MEMORY_LIMIT.value,
+        }
+        or source_measurement.get("status")
+        not in {
+            ResultStatus.TIMEOUT.value,
+            ResultStatus.MEMORY_LIMIT.value,
+        }
+        or not isinstance(digest, str)
+        or _SHA256_RE.fullmatch(digest) is None
+    ):
+        raise CampaignPolicyError(
+            "resource-frontier source is not a direct hard-resource censor"
+        )
+    return {
+        "abi": RESOURCE_FRONTIER_ABI,
+        "lane": resource_lane_identity(cell),
+        "root": {
+            "cell_id": source_cell.cell_id,
+            "n_final": source_cell.n_final,
+            "kind": censor["kind"],
+            "status": source_measurement["status"],
+            "censor_sha256": digest,
+        },
+    }
+
+
+def policy_censor_measurement(
+    policy: CampaignPolicy,
+    profile: str,
+    cell: CellSpec,
+    *,
+    kind: PolicyCensorKind,
+    source_identity: ReportSourceIdentity | Mapping[str, object],
+    resources: Mapping[str, object] | None,
+    observed_generation_seconds: float | None = None,
+    observed_rss_bytes: int | None = None,
+    observed_guard_bytes: int | None = None,
+    memory_metric_abi: str | None = None,
+    memory_limit_reason: str | None = None,
+    phase_evidence: Mapping[str, object] | None = None,
+    dependencies: Sequence[Mapping[str, object]] = (),
+    frontier: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    if not policy.allow_terminal_censors:
+        raise CampaignPolicyError(
+            "terminal censors require an architecture campaign policy"
+        )
+    validate_policy_profile(policy, profile)
+    if kind is PolicyCensorKind.GENERATION_LIMIT:
+        status = ResultStatus.TIMEOUT
+    elif kind is PolicyCensorKind.MEMORY_LIMIT:
+        status = ResultStatus.MEMORY_LIMIT
+    elif kind in {
+        PolicyCensorKind.DEPENDENCY,
+        PolicyCensorKind.RESOURCE_FRONTIER,
+    }:
+        status = ResultStatus.SKIP
+    else:  # pragma: no cover - exhaustive StrEnum defense
+        raise CampaignPolicyError(f"unsupported policy censor kind {kind!r}")
+    legacy_rss_memory_censor = (
+        kind is PolicyCensorKind.MEMORY_LIMIT
+        and observed_guard_bytes is None
+        and memory_metric_abi is None
+        and memory_limit_reason is None
+    )
+    record: dict[str, object] = {
+        "abi": (
+            LEGACY_POLICY_CENSOR_ABI if legacy_rss_memory_censor else POLICY_CENSOR_ABI
+        ),
+        "policy": policy.name,
+        "profile": profile,
+        "cell_id": cell.cell_id,
+        "kind": kind.value,
+        "generation_limit_seconds": policy.generation_limit_seconds,
+        "memory_limit_bytes": policy.memory_limit_bytes,
+        "observed_generation_seconds": observed_generation_seconds,
+        "observed_rss_bytes": observed_rss_bytes,
+        "phase_evidence": (None if phase_evidence is None else dict(phase_evidence)),
+        "dependencies": [dict(item) for item in dependencies],
+        "frontier": None if frontier is None else dict(frontier),
+    }
+    if not legacy_rss_memory_censor:
+        record.update(
+            {
+                "observed_guard_bytes": observed_guard_bytes,
+                "memory_metric_abi": memory_metric_abi,
+                "memory_limit_reason": memory_limit_reason,
+            }
+        )
+    provenance = {
+        **_source_provenance(source_identity),
+        "policy_censor": record,
+        "policy_censor_sha256": _canonical_digest(record),
+    }
+    result = empty_measurement()
+    result.update(
+        {
+            "status": status.value,
+            "resources": None if resources is None else dict(resources),
+            "provenance": provenance,
+            "failure": {
+                "kind": "ReportPolicyCensor",
+                "message": (
+                    (
+                        "process generation exceeded its authenticated "
+                        f"{float(policy.generation_limit_seconds or 0):g}-second "
+                        "limit"
+                    )
+                    if kind is PolicyCensorKind.GENERATION_LIMIT
+                    else (
+                        "worker process tree exceeded "
+                        f"{int(policy.memory_limit_bytes or 0) / 1_000_000_000:g} "
+                        "GB under its authenticated memory guard"
+                        if kind is PolicyCensorKind.MEMORY_LIMIT
+                        else (
+                            "higher multiplicity omitted after a lower-multiplicity "
+                            "resource ceiling"
+                            if kind is PolicyCensorKind.RESOURCE_FRONTIER
+                            else (
+                                "required numerical-agreement dependency was censored"
+                            )
+                        )
+                    )
+                ),
+            },
+        }
+    )
+    validate_policy_measurement(
+        policy,
+        profile,
+        cell,
+        result,
+        expected_source_revision=str(provenance["report_source_revision"]),
+        expected_source_tree=str(provenance["report_source_tree"]),
+    )
+    return result
+
+
+def _policy_record(
+    policy: CampaignPolicy,
+    profile: str,
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    *,
+    expected_source_revision: str,
+    expected_source_tree: str | None,
+) -> tuple[PolicyCensorKind, Mapping[str, object]]:
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        raise CampaignPolicyError("terminal measurement has no provenance")
+    base_fields = _SOURCE_FIELDS | {
+        "policy_censor",
+        "policy_censor_sha256",
+    }
+    provenance_fields = set(provenance)
+    if policy is MACBOOK_M3_Z_TABLE_F_POLICY and "study_contract" in provenance:
+        if provenance_fields != base_fields | {
+            "study_contract",
+            WORKER_HARNESS_PROVENANCE_FIELD,
+        }:
+            raise CampaignPolicyError(
+                "terminal measurement provenance is not canonical"
+            )
+        study_contract = provenance.get("study_contract")
+        if (
+            not isinstance(study_contract, Mapping)
+            or set(study_contract) != _STUDY_CONTRACT_BINDING_FIELDS
+            or study_contract.get("abi") != "pyamplicol-z-table-f-attempt-binding-v1"
+            or study_contract.get("study_id") != "macbook-m3-z-table-f"
+            or not isinstance(
+                study_contract.get("study_contract_sha256"),
+                str,
+            )
+            or _SHA256_RE.fullmatch(str(study_contract["study_contract_sha256"]))
+            is None
+        ):
+            raise CampaignPolicyError(
+                "terminal measurement study contract is not canonical"
+            )
+        try:
+            require_worker_harness_identity(
+                measurement,
+                expected_measured_revision=expected_source_revision,
+                expected_measured_tree=expected_source_tree,
+            )
+        except WorkerHarnessError as error:
+            raise CampaignPolicyError(str(error)) from error
+    elif provenance_fields != base_fields:
+        raise CampaignPolicyError("terminal measurement provenance is not canonical")
+    if (
+        provenance.get("report_source_identity_schema") != SOURCE_IDENTITY_SCHEMA
+        or provenance.get("report_source_revision") != expected_source_revision
+        or provenance.get("report_measured_source_revision") != expected_source_revision
+        or provenance.get("report_source_clean") is not True
+    ):
+        raise CampaignPolicyError("terminal measurement source identity does not match")
+    if expected_source_tree is not None and (
+        provenance.get("report_source_tree") != expected_source_tree
+        or provenance.get("report_measured_source_tree") != expected_source_tree
+    ):
+        raise CampaignPolicyError("terminal measurement source tree does not match")
+    raw = provenance.get("policy_censor")
+    if not isinstance(raw, Mapping):
+        raise CampaignPolicyError("policy_censor fields do not match the ABI")
+    censor_abi = raw.get("abi")
+    expected_fields = (
+        _LEGACY_CENSOR_FIELDS
+        if censor_abi == LEGACY_POLICY_CENSOR_ABI
+        else _CENSOR_FIELDS
+    )
+    if set(raw) != expected_fields:
+        raise CampaignPolicyError("policy_censor fields do not match the ABI")
+    digest = provenance.get("policy_censor_sha256")
+    if digest != _canonical_digest(raw):
+        raise CampaignPolicyError("policy_censor_sha256 does not match")
+    try:
+        kind = PolicyCensorKind(str(raw.get("kind")))
+    except ValueError as error:
+        raise CampaignPolicyError("policy_censor kind is unsupported") from error
+    if policy is MACBOOK_M3_Z_TABLE_F_POLICY and censor_abi != POLICY_CENSOR_ABI:
+        raise CampaignPolicyError(
+            "the Z-table F policy requires policy-censor v3 evidence"
+        )
+    if (
+        censor_abi not in {LEGACY_POLICY_CENSOR_ABI, POLICY_CENSOR_ABI}
+        or raw.get("policy") != policy.name
+        or raw.get("profile") != profile
+        or raw.get("cell_id") != cell.cell_id
+        or raw.get("generation_limit_seconds") != policy.generation_limit_seconds
+        or raw.get("memory_limit_bytes") != policy.memory_limit_bytes
+    ):
+        raise CampaignPolicyError("policy_censor identity or limits differ")
+    return kind, raw
+
+
+def _optional_nonnegative_integer(value: object, field: str) -> int | None:
+    if value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise CampaignPolicyError(f"{field} is not a non-negative integer")
+    return value
+
+
+def _validate_memory_metric(
+    resources: Mapping[str, object],
+    policy: CampaignPolicy,
+) -> None:
+    metric_abi = resources.get("memory_metric_abi")
+    present_fields = _MEMORY_RESOURCE_FIELDS.intersection(resources)
+    if metric_abi is None:
+        if present_fields:
+            raise CampaignPolicyError(
+                "memory metric fields require an authenticated metric ABI"
+            )
+        return
+    if (
+        metric_abi != PROCESS_TREE_MEMORY_METRIC_ABI
+        or present_fields != _MEMORY_RESOURCE_FIELDS
+    ):
+        raise CampaignPolicyError("memory metric ABI or fields are unsupported")
+
+    current_rss = _optional_nonnegative_integer(
+        resources.get("current_rss_bytes"),
+        "current_rss_bytes",
+    )
+    peak_rss = _optional_nonnegative_integer(
+        resources.get("peak_rss_bytes"),
+        "peak_rss_bytes",
+    )
+    current_physical = _optional_nonnegative_integer(
+        resources.get("current_physical_footprint_bytes"),
+        "current_physical_footprint_bytes",
+    )
+    peak_physical = _optional_nonnegative_integer(
+        resources.get("peak_physical_footprint_bytes"),
+        "peak_physical_footprint_bytes",
+    )
+    current_guard = _optional_nonnegative_integer(
+        resources.get("current_guard_bytes"),
+        "current_guard_bytes",
+    )
+    peak_guard = _optional_nonnegative_integer(
+        resources.get("peak_guard_bytes"),
+        "peak_guard_bytes",
+    )
+    if current_rss is None or peak_rss is None:
+        raise CampaignPolicyError("memory metric has incomplete RSS evidence")
+    expected_current_guard = max(
+        current_rss,
+        current_physical if current_physical is not None else current_rss,
+    )
+    expected_peak_guard = max(
+        peak_rss,
+        peak_physical if peak_physical is not None else peak_rss,
+    )
+    if current_guard != expected_current_guard or peak_guard != expected_peak_guard:
+        raise CampaignPolicyError("memory guard does not match RSS/footprint maxima")
+
+    memory_limit = resources.get("memory_limit_bytes")
+    assert policy.memory_limit_bytes is not None
+    if (
+        isinstance(memory_limit, bool)
+        or not isinstance(memory_limit, int)
+        or memory_limit != policy.memory_limit_bytes
+    ):
+        raise CampaignPolicyError("memory metric limit differs from policy")
+    reason = resources.get("memory_limit_reason")
+    if reason is not None and reason not in _MEMORY_LIMIT_REASONS:
+        raise CampaignPolicyError("memory metric reason is unsupported")
+    probe_reason = resources.get("memory_probe_reason")
+    if probe_reason is not None:
+        if probe_reason not in _MEMORY_PROBE_REASONS:
+            raise CampaignPolicyError("memory probe reason is unsupported")
+        raise CampaignPolicyError(
+            "policy measurement has incomplete memory observations"
+        )
+    if reason == DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON and (
+        current_physical is None
+        or current_physical < current_rss
+        or current_guard <= memory_limit
+    ):
+        raise CampaignPolicyError(
+            "physical-footprint limit reason contradicts current evidence"
+        )
+    if reason == RSS_LIMIT_REASON and (
+        current_rss
+        < (current_physical if current_physical is not None else current_rss)
+        or current_guard <= memory_limit
+    ):
+        raise CampaignPolicyError("RSS limit reason contradicts current evidence")
+
+
+def _validate_resources(
+    measurement: Mapping[str, object],
+    policy: CampaignPolicy,
+    *,
+    allow_pinned_orphan_unavailable_resources: bool = False,
+) -> Mapping[str, object]:
+    resources = measurement.get("resources")
+    if not isinstance(resources, Mapping):
+        raise CampaignPolicyError(
+            "architecture-policy measurement has no resource evidence"
+        )
+    if allow_pinned_orphan_unavailable_resources and dict(resources) == {
+        "monitor": "external-cell-supervisor",
+        "peak_rss_gib": None,
+    }:
+        if policy.memory_limit_bytes is None:
+            raise CampaignPolicyError("architecture policy has no memory ceiling")
+        return resources
+    peak = resources.get("peak_rss_bytes")
+    if (
+        resources.get("available") is not True
+        or resources.get("probe_error") is not None
+        or isinstance(peak, bool)
+        or not isinstance(peak, int)
+        or peak < 0
+    ):
+        raise CampaignPolicyError(
+            "architecture-policy resource monitoring is unavailable or incomplete"
+        )
+    if policy.memory_limit_bytes is None:
+        raise CampaignPolicyError("architecture policy has no memory ceiling")
+    _validate_memory_metric(resources, policy)
+    if policy is MACBOOK_M3_Z_TABLE_F_POLICY:
+        current_physical = resources.get("current_physical_footprint_bytes")
+        peak_physical = resources.get("peak_physical_footprint_bytes")
+        if (
+            resources.get("memory_metric_abi") != PROCESS_TREE_MEMORY_METRIC_ABI
+            or isinstance(current_physical, bool)
+            or not isinstance(current_physical, int)
+            or current_physical < 0
+            or isinstance(peak_physical, bool)
+            or not isinstance(peak_physical, int)
+            or peak_physical < 0
+        ):
+            raise CampaignPolicyError(
+                "the Z-table F policy requires non-null authenticated "
+                "current and peak Darwin physical-footprint evidence"
+            )
+        reason = resources.get("memory_limit_reason")
+        current_rss = resources.get("current_rss_bytes")
+        assert isinstance(current_rss, int) and not isinstance(current_rss, bool)
+        if reason is not None:
+            expected_reason = (
+                DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON
+                if current_physical >= current_rss
+                else RSS_LIMIT_REASON
+            )
+            if reason != expected_reason:
+                raise CampaignPolicyError(
+                    "the Z-table F memory-limit reason does not match the "
+                    "authenticated Darwin guard"
+                )
+    return resources
+
+
+def _validate_generation_phase(
+    value: object,
+    policy: CampaignPolicy,
+    *,
+    expected_reason: str,
+) -> Mapping[str, object]:
+    if not isinstance(value, Mapping) or set(value) != _GENERATION_PHASE_FIELDS:
+        raise CampaignPolicyError(
+            "generation-phase evidence fields do not match the ABI"
+        )
+    assert policy.generation_limit_seconds is not None
+    run_id = value.get("run_id")
+    worker_pid = value.get("worker_pid")
+    sequence = value.get("final_sequence")
+    started = value.get("generation_started_monotonic_ns")
+    finished = value.get("generation_finished_monotonic_ns")
+    elapsed = _finite_number(
+        value.get("generation_elapsed_seconds"),
+        "generation_phase.generation_elapsed_seconds",
+    )
+    state_digest = value.get("final_state_sha256")
+    if expected_reason == "generation_timeout":
+        boundary_valid = (
+            sequence == 1
+            and value.get("final_phase") == "generation"
+            and isinstance(started, int)
+            and not isinstance(started, bool)
+            and started > 0
+            and finished is None
+        ) or (
+            sequence == 0
+            and value.get("final_phase") == "pre-generation"
+            and started is None
+            and finished is None
+        )
+    else:
+        boundary_valid = (
+            sequence == 2
+            and value.get("final_phase") == "post-generation"
+            and isinstance(started, int)
+            and not isinstance(started, bool)
+            and started > 0
+            and isinstance(finished, int)
+            and not isinstance(finished, bool)
+            and finished >= started
+        )
+    if (
+        value.get("abi") != GENERATION_PHASE_EVIDENCE_ABI
+        or value.get("phase_state_abi") != WORKER_PHASE_STATE_ABI
+        or value.get("configured_timeout_seconds") != policy.generation_limit_seconds
+        or value.get("supervisor_reason") != expected_reason
+        or value.get("authenticated") is not True
+        or not isinstance(run_id, str)
+        or not run_id
+        or isinstance(worker_pid, bool)
+        or not isinstance(worker_pid, int)
+        or worker_pid <= 0
+        or isinstance(sequence, bool)
+        or not isinstance(sequence, int)
+        or not boundary_valid
+        or not isinstance(state_digest, str)
+        or _SHA256_RE.fullmatch(state_digest) is None
+        or value.get("error") is not None
+    ):
+        raise CampaignPolicyError(
+            "generation-phase evidence is unauthenticated or inconsistent"
+        )
+    if expected_reason == "generation_timeout":
+        if elapsed < policy.generation_limit_seconds:
+            raise CampaignPolicyError(
+                "generation-phase evidence did not reach its ceiling"
+            )
+    elif elapsed > policy.generation_limit_seconds:
+        raise CampaignPolicyError(
+            "successful generation-phase evidence exceeded its ceiling"
+        )
+    return value
+
+
+def validate_policy_measurement(
+    policy: CampaignPolicy,
+    profile: str,
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    *,
+    expected_source_revision: str,
+    expected_source_tree: str | None = None,
+    allow_pinned_orphan_unavailable_resources: bool = False,
+) -> PolicyMeasurementState:
+    """Validate one successful or policy-terminal current measurement."""
+
+    validate_policy_profile(policy, profile)
+    status = str(measurement.get("status"))
+    if status == ResultStatus.OK.value:
+        provenance = measurement.get("provenance")
+        if not isinstance(provenance, Mapping):
+            raise CampaignPolicyError("successful measurement has no provenance")
+        if (
+            provenance.get("report_source_identity_schema") != SOURCE_IDENTITY_SCHEMA
+            or provenance.get("report_source_revision") != expected_source_revision
+            or provenance.get("report_measured_source_revision")
+            != expected_source_revision
+            or provenance.get("report_source_clean") is not True
+        ):
+            raise CampaignPolicyError(
+                "successful measurement source identity does not match"
+            )
+        if expected_source_tree is not None and (
+            provenance.get("report_source_tree") != expected_source_tree
+            or provenance.get("report_measured_source_tree") != expected_source_tree
+        ):
+            raise CampaignPolicyError(
+                "successful measurement source tree does not match"
+            )
+        if policy is MACBOOK_M3_Z_TABLE_F_POLICY:
+            try:
+                require_worker_harness_identity(
+                    measurement,
+                    expected_measured_revision=expected_source_revision,
+                    expected_measured_tree=expected_source_tree,
+                )
+            except WorkerHarnessError as error:
+                raise CampaignPolicyError(str(error)) from error
+        if policy.allow_terminal_censors:
+            resources = _validate_resources(
+                measurement,
+                policy,
+                allow_pinned_orphan_unavailable_resources=(
+                    allow_pinned_orphan_unavailable_resources
+                ),
+            )
+            peak = (
+                resources.get("peak_guard_bytes")
+                if resources.get("memory_metric_abi") is not None
+                else resources.get("peak_rss_bytes")
+            )
+            if peak is not None:
+                assert isinstance(peak, int) and not isinstance(peak, bool)
+                assert policy.memory_limit_bytes is not None
+                if peak > policy.memory_limit_bytes:
+                    raise CampaignPolicyError(
+                        "successful architecture measurement exceeded its "
+                        "memory ceiling"
+                    )
+            generation = _finite_number(
+                measurement.get("generation_seconds"),
+                "generation_seconds",
+            )
+            limit = generation_limit_for_cell(policy, cell)
+            if limit is not None and generation > limit:
+                raise CampaignPolicyError(
+                    "successful architecture measurement exceeded its "
+                    "generation ceiling"
+                )
+            if limit is not None:
+                _validate_generation_phase(
+                    resources.get("generation_phase"),
+                    policy,
+                    expected_reason="completed",
+                )
+        return PolicyMeasurementState.SUCCESS
+
+    if policy is STRICT_POLICY:
+        raise CampaignPolicyError(
+            "strict report profiles require a successful measurement"
+        )
+    kind, record = _policy_record(
+        policy,
+        profile,
+        cell,
+        measurement,
+        expected_source_revision=expected_source_revision,
+        expected_source_tree=expected_source_tree,
+    )
+    failure = measurement.get("failure")
+    if (
+        not isinstance(failure, Mapping)
+        or failure.get("kind") != "ReportPolicyCensor"
+        or not isinstance(failure.get("message"), str)
+    ):
+        raise CampaignPolicyError("terminal measurement failure is not canonical")
+    for field in (
+        "generation_seconds",
+        "wall_seconds_per_point",
+        "execution_seconds_per_point",
+        "matrix_element",
+        "sample_count",
+        "standard_error_seconds_per_point",
+        "relative_standard_error",
+        "artifact",
+        "selector_contract",
+        "validation",
+    ):
+        if measurement.get(field) is not None:
+            raise CampaignPolicyError(
+                f"terminal measurement unexpectedly contains {field}"
+            )
+    dependencies = record.get("dependencies")
+    if not isinstance(dependencies, list):
+        raise CampaignPolicyError("policy_censor dependencies must be an array")
+    frontier = record.get("frontier")
+
+    if kind is PolicyCensorKind.GENERATION_LIMIT:
+        cell_limit = generation_limit_for_cell(policy, cell)
+        if cell_limit is None or status != ResultStatus.TIMEOUT.value:
+            raise CampaignPolicyError(
+                "generation censor status or exemption is invalid"
+            )
+        observed = _finite_number(
+            record.get("observed_generation_seconds"),
+            "observed_generation_seconds",
+        )
+        if observed < cell_limit:
+            raise CampaignPolicyError(
+                "generation censor did not reach its authenticated ceiling"
+            )
+        phase = record.get("phase_evidence")
+        _validate_generation_phase(
+            phase,
+            policy,
+            expected_reason="generation_timeout",
+        )
+        assert isinstance(phase, Mapping)
+        if observed != float(phase["generation_elapsed_seconds"]):
+            raise CampaignPolicyError(
+                "generation censor observed time differs from phase evidence"
+            )
+        resources = _validate_resources(measurement, policy)
+        if resources.get("generation_phase") != phase:
+            raise CampaignPolicyError(
+                "generation censor phase evidence differs from resources"
+            )
+        if (
+            record.get("observed_rss_bytes") is not None
+            or record.get("observed_guard_bytes") is not None
+            or record.get("memory_limit_reason") is not None
+            or record.get("memory_metric_abi") is not None
+            or dependencies
+            or frontier is not None
+        ):
+            raise CampaignPolicyError("generation censor fields are inconsistent")
+        return PolicyMeasurementState.GENERATION_LIMIT
+
+    if kind is PolicyCensorKind.MEMORY_LIMIT:
+        if status != ResultStatus.MEMORY_LIMIT.value:
+            raise CampaignPolicyError("memory censor status is invalid")
+        resources = _validate_resources(measurement, policy)
+        assert policy.memory_limit_bytes is not None
+        legacy_censor = record.get("abi") == LEGACY_POLICY_CENSOR_ABI
+        observed_rss = record.get("observed_rss_bytes")
+        common_invalid = (
+            record.get("observed_generation_seconds") is not None
+            or record.get("phase_evidence") is not None
+            or dependencies
+            or frontier is not None
+        )
+        if legacy_censor:
+            invalid = (
+                isinstance(observed_rss, bool)
+                or not isinstance(observed_rss, int)
+                or observed_rss <= policy.memory_limit_bytes
+                or observed_rss != resources.get("peak_rss_bytes")
+                or common_invalid
+            )
+        else:
+            observed_guard = record.get("observed_guard_bytes")
+            invalid = (
+                isinstance(observed_rss, bool)
+                or not isinstance(observed_rss, int)
+                or observed_rss != resources.get("peak_rss_bytes")
+                or isinstance(observed_guard, bool)
+                or not isinstance(observed_guard, int)
+                or observed_guard <= policy.memory_limit_bytes
+                or observed_guard != resources.get("peak_guard_bytes")
+                or record.get("memory_metric_abi") != PROCESS_TREE_MEMORY_METRIC_ABI
+                or resources.get("memory_metric_abi") != PROCESS_TREE_MEMORY_METRIC_ABI
+                or record.get("memory_limit_reason")
+                != resources.get("memory_limit_reason")
+                or record.get("memory_limit_reason") not in _MEMORY_LIMIT_REASONS
+                or common_invalid
+            )
+        if invalid:
+            raise CampaignPolicyError("memory censor evidence is inconsistent")
+        return PolicyMeasurementState.MEMORY_LIMIT
+
+    if status != ResultStatus.SKIP.value:
+        raise CampaignPolicyError("derived censor status is invalid")
+    if (
+        record.get("observed_generation_seconds") is not None
+        or record.get("observed_rss_bytes") is not None
+        or record.get("observed_guard_bytes") is not None
+        or record.get("memory_limit_reason") is not None
+        or record.get("memory_metric_abi") is not None
+        or record.get("phase_evidence") is not None
+        or measurement.get("resources") is not None
+    ):
+        raise CampaignPolicyError("derived censor fields are inconsistent")
+    if kind is PolicyCensorKind.RESOURCE_FRONTIER:
+        if dependencies or not isinstance(frontier, Mapping):
+            raise CampaignPolicyError(
+                "resource-frontier censor fields are inconsistent"
+            )
+        if set(frontier) != _FRONTIER_FIELDS:
+            raise CampaignPolicyError("resource-frontier reference is malformed")
+        lane = frontier.get("lane")
+        root = frontier.get("root")
+        if (
+            frontier.get("abi") != RESOURCE_FRONTIER_ABI
+            or not isinstance(lane, Mapping)
+            or set(lane) != _FRONTIER_LANE_FIELDS
+            or dict(lane) != resource_lane_identity(cell)
+            or not isinstance(root, Mapping)
+            or set(root) != _FRONTIER_ROOT_FIELDS
+        ):
+            raise CampaignPolicyError("resource-frontier identity is invalid")
+        cell_id = root.get("cell_id")
+        digest = root.get("censor_sha256")
+        root_n = root.get("n_final")
+        root_kind = root.get("kind")
+        root_status = root.get("status")
+        if (
+            not isinstance(cell_id, str)
+            or not cell_id
+            or isinstance(root_n, bool)
+            or not isinstance(root_n, int)
+            or root_n < 1
+            or root_n >= cell.n_final
+            or root_kind
+            not in {
+                PolicyCensorKind.GENERATION_LIMIT.value,
+                PolicyCensorKind.MEMORY_LIMIT.value,
+            }
+            or root_status
+            not in {
+                ResultStatus.TIMEOUT.value,
+                ResultStatus.MEMORY_LIMIT.value,
+            }
+            or not isinstance(digest, str)
+            or _SHA256_RE.fullmatch(digest) is None
+        ):
+            raise CampaignPolicyError("resource-frontier reference is invalid")
+        if (
+            root_kind == PolicyCensorKind.GENERATION_LIMIT.value
+            and root_status != ResultStatus.TIMEOUT.value
+        ) or (
+            root_kind == PolicyCensorKind.MEMORY_LIMIT.value
+            and root_status != ResultStatus.MEMORY_LIMIT.value
+        ):
+            raise CampaignPolicyError("resource-frontier kind and status differ")
+        return PolicyMeasurementState.RESOURCE_FRONTIER
+    if frontier is not None or not dependencies:
+        raise CampaignPolicyError("dependency censor fields are inconsistent")
+    seen: set[str] = set()
+    for dependency in dependencies:
+        if not isinstance(dependency, Mapping) or set(dependency) != _DEPENDENCY_FIELDS:
+            raise CampaignPolicyError("dependency censor reference is malformed")
+        cell_id = dependency.get("cell_id")
+        digest = dependency.get("censor_sha256")
+        dep_status = dependency.get("status")
+        if (
+            not isinstance(cell_id, str)
+            or not cell_id
+            or cell_id in seen
+            or dep_status
+            not in {
+                ResultStatus.TIMEOUT.value,
+                ResultStatus.MEMORY_LIMIT.value,
+                ResultStatus.SKIP.value,
+            }
+            or not isinstance(digest, str)
+            or _SHA256_RE.fullmatch(digest) is None
+        ):
+            raise CampaignPolicyError("dependency censor reference is invalid")
+        seen.add(cell_id)
+    return PolicyMeasurementState.DEPENDENCY
+
+
+def _generation_limit_label(record: Mapping[str, object]) -> str | None:
+    raw_limit = record.get("generation_limit_seconds")
+    if (
+        isinstance(raw_limit, bool)
+        or not isinstance(raw_limit, (int, float))
+        or not math.isfinite(float(raw_limit))
+        or float(raw_limit) <= 0.0
+    ):
+        return None
+    limit = float(raw_limit)
+    hours = limit / 3600.0
+    if hours.is_integer():
+        return f">{int(hours)}h"
+    return f">{limit:g}s"
+
+
+def _manual_time_limit_label(
+    record: Mapping[str, object],
+    field: str,
+    prefix: str,
+) -> str | None:
+    raw_limit = record.get(field)
+    if (
+        isinstance(raw_limit, bool)
+        or not isinstance(raw_limit, (int, float))
+        or not math.isfinite(float(raw_limit))
+        or float(raw_limit) <= 0.0
+    ):
+        return None
+    limit = float(raw_limit)
+    hours = limit / 3600.0
+    rendered = f"{int(hours)}h" if hours.is_integer() else f"{limit:g}s"
+    return f"{prefix} >{rendered}"
+
+
+def policy_measurement_state_hint(
+    measurement: Mapping[str, object],
+) -> PolicyMeasurementState | None:
+    """Decode a current's status/kind pair without deeper artifact checks.
+
+    This is intentionally only a lightweight classification helper. Callers
+    remain responsible for the profile-specific validation and source checks
+    required at their publication or reuse boundary.
+    """
+
+    status = measurement.get("status")
+    if status == ResultStatus.OK.value:
+        return PolicyMeasurementState.SUCCESS
+    provenance = measurement.get("provenance")
+    censor = (
+        provenance.get("policy_censor") if isinstance(provenance, Mapping) else None
+    )
+    kind = censor.get("kind") if isinstance(censor, Mapping) else None
+    manual = (
+        provenance.get("manual_campaign") if isinstance(provenance, Mapping) else None
+    )
+    timeout_states = {
+        PolicyCensorKind.GENERATION_LIMIT.value: (
+            PolicyMeasurementState.GENERATION_LIMIT
+        ),
+        PolicyCensorKind.WORKER_TIMEOUT.value: PolicyMeasurementState.WORKER_TIMEOUT,
+        PolicyCensorKind.PROFILING_TIMEOUT.value: (
+            PolicyMeasurementState.PROFILING_TIMEOUT
+        ),
+        PolicyCensorKind.VALIDATION_TIMEOUT.value: (
+            PolicyMeasurementState.VALIDATION_TIMEOUT
+        ),
+    }
+    if status == ResultStatus.TIMEOUT.value:
+        state = timeout_states.get(kind)
+        if state is not None:
+            return state
+        if (
+            kind is None
+            and isinstance(manual, Mapping)
+            and _generation_limit_label(manual) is not None
+        ):
+            return PolicyMeasurementState.GENERATION_LIMIT
+        return None
+    if (
+        status == ResultStatus.MEMORY_LIMIT.value
+        and kind == PolicyCensorKind.MEMORY_LIMIT.value
+    ):
+        return PolicyMeasurementState.MEMORY_LIMIT
+    if (
+        status == ResultStatus.MEMORY_LIMIT.value
+        and kind is None
+        and isinstance(manual, Mapping)
+        and isinstance(manual.get("memory_limit_bytes"), int)
+        and not isinstance(manual.get("memory_limit_bytes"), bool)
+        and int(manual["memory_limit_bytes"]) > 0
+    ):
+        return PolicyMeasurementState.MEMORY_LIMIT
+    if status == ResultStatus.SKIP.value:
+        return {
+            PolicyCensorKind.DEPENDENCY.value: PolicyMeasurementState.DEPENDENCY,
+            PolicyCensorKind.RESOURCE_FRONTIER.value: (
+                PolicyMeasurementState.RESOURCE_FRONTIER
+            ),
+        }.get(kind)
+    return None
+
+
+def policy_status_label(measurement: Mapping[str, object]) -> str | None:
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        return None
+    record = provenance.get("policy_censor")
+    if not isinstance(record, Mapping):
+        manual = provenance.get("manual_campaign")
+        if not isinstance(manual, Mapping):
+            return None
+        status = measurement.get("status")
+        if status == ResultStatus.TIMEOUT.value:
+            return _generation_limit_label(manual)
+        if status == ResultStatus.MEMORY_LIMIT.value:
+            record = manual
+            kind = PolicyCensorKind.MEMORY_LIMIT.value
+        else:
+            return None
+    else:
+        kind = record.get("kind")
+    if kind == PolicyCensorKind.GENERATION_LIMIT.value:
+        return _generation_limit_label(record)
+    if kind == PolicyCensorKind.MEMORY_LIMIT.value:
+        memory_limit = record.get("memory_limit_bytes")
+        if (
+            isinstance(memory_limit, bool)
+            or not isinstance(memory_limit, int)
+            or memory_limit <= 0
+            or memory_limit % 1_000_000_000
+        ):
+            return None
+        return f">{memory_limit // 1_000_000_000}GB"
+    if kind == PolicyCensorKind.WORKER_TIMEOUT.value:
+        return _manual_time_limit_label(
+            record,
+            "worker_wall_limit_seconds",
+            "worker",
+        )
+    if kind == PolicyCensorKind.PROFILING_TIMEOUT.value:
+        return _manual_time_limit_label(
+            record,
+            "profiling_time_limit_seconds",
+            "profile",
+        )
+    if kind == PolicyCensorKind.VALIDATION_TIMEOUT.value:
+        return _manual_time_limit_label(
+            record,
+            "validation_time_limit_seconds",
+            "validation",
+        )
+    if kind in {
+        PolicyCensorKind.DEPENDENCY.value,
+        PolicyCensorKind.RESOURCE_FRONTIER.value,
+    }:
+        if kind == PolicyCensorKind.RESOURCE_FRONTIER.value:
+            raw_frontier = record.get("frontier")
+            root = (
+                raw_frontier.get("root") if isinstance(raw_frontier, Mapping) else None
+            )
+            dependencies = [root] if isinstance(root, Mapping) else []
+        else:
+            dependencies = record.get("dependencies")
+        labels: set[str] = set()
+        if isinstance(dependencies, list):
+            for dependency in dependencies:
+                if not isinstance(dependency, Mapping):
+                    continue
+                status = dependency.get("status")
+                if status == ResultStatus.TIMEOUT.value:
+                    labels.add(_generation_limit_label(record) or "timeout")
+                elif status == ResultStatus.MEMORY_LIMIT.value:
+                    memory_limit = record.get("memory_limit_bytes")
+                    if (
+                        isinstance(memory_limit, int)
+                        and not isinstance(memory_limit, bool)
+                        and memory_limit > 0
+                        and memory_limit % 1_000_000_000 == 0
+                    ):
+                        labels.add(f">{memory_limit // 1_000_000_000}GB")
+                    else:
+                        labels.add("blocked")
+                else:
+                    labels.add("blocked")
+        detail = "/".join(sorted(labels)) if labels else "blocked"
+        return f"dependency {detail}"
+    return None
+
+
+__all__ = [
+    "CAMPAIGN_POLICY_SCHEMA",
+    "GENERATION_PHASE_EVIDENCE_ABI",
+    "LEGACY_POLICY_CENSOR_ABI",
+    "MACBOOK_M3_CELL_CORES",
+    "MACBOOK_M3_MEMORY_LIMIT_BYTES",
+    "MACBOOK_M3_POLICY",
+    "MACBOOK_M3_POLICY_NAME",
+    "MACBOOK_M3_PROFILE",
+    "MACBOOK_M3_TARGET_RUNTIME_SECONDS",
+    "MACBOOK_M3_WORKERS",
+    "MACBOOK_M3_Z_TABLE_F_GENERATION_LIMIT_SECONDS",
+    "MACBOOK_M3_Z_TABLE_F_POLICY",
+    "MACBOOK_M3_Z_TABLE_F_POLICY_NAME",
+    "POLICY_CENSOR_ABI",
+    "RESOURCE_FRONTIER_ABI",
+    "STRICT_POLICY",
+    "STRICT_POLICY_NAME",
+    "WORKER_PHASE_STATE_ABI",
+    "X86_EPYC_CELL_CORES",
+    "X86_EPYC_GENERATION_LIMIT_SECONDS",
+    "X86_EPYC_LEGACY_MEMORY_LIMIT_BYTES",
+    "X86_EPYC_LEGACY_WORKERS",
+    "X86_EPYC_MEMORY_LIMIT_BYTES",
+    "X86_EPYC_NATIVE_COMPILER_SLOTS",
+    "X86_EPYC_POLICY",
+    "X86_EPYC_POLICY_NAME",
+    "X86_EPYC_PROFILE",
+    "X86_EPYC_TARGET_RUNTIME_SECONDS",
+    "X86_EPYC_WORKERS",
+    "CampaignPolicy",
+    "CampaignPolicyError",
+    "PolicyCensorKind",
+    "PolicyMeasurementState",
+    "campaign_policy",
+    "default_campaign_policy",
+    "dependency_reference",
+    "generation_limit_exempt",
+    "generation_limit_for_cell",
+    "policy_censor_measurement",
+    "policy_from_manifest",
+    "policy_measurement_state_hint",
+    "policy_status_label",
+    "resource_frontier_reference",
+    "resource_lane_identity",
+    "validate_campaign_settings",
+    "validate_policy_measurement",
+    "validate_policy_profile",
+]
diff --git a/pyamplicol/tools/performance_report/campaign_reset.py b/pyamplicol/tools/performance_report/campaign_reset.py
new file mode 100644
index 0000000000..582e1eacb4
--- /dev/null
+++ b/pyamplicol/tools/performance_report/campaign_reset.py
@@ -0,0 +1,1320 @@
+# SPDX-License-Identifier: 0BSD
+"""Auditable campaign epochs and host-local original-AmpliCol seeds.
+
+This module deliberately keeps old measurement provenance immutable.  A new
+campaign may authorize a digest-pinned, same-profile original-AmpliCol current,
+but it never rewrites that current to impersonate the new report source.
+"""
+
+from __future__ import annotations
+
+import errno
+import fcntl
+import hashlib
+import json
+import math
+import os
+import re
+import shutil
+import tempfile
+import uuid
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .artifacts import ArtifactStore, CurrentRecord
+from .cache import validate_measurement
+from .campaign_policy import CampaignPolicy, validate_policy_measurement
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .models import Accuracy, CellSpec, ExecutionMode, ResultStatus, Workload
+
+SEED_FILENAME = "original_amplicol_seed.json"
+CAMPAIGN_MARKER_FILENAME = "campaign-epoch.json"
+RESET_JOURNAL_FILENAME = "campaign-reset-journal.json"
+BASELINE_GATE_FILENAME = "baseline-gate.json"
+SEED_SCHEMA = "pyamplicol-original-amplicol-seed-v1"
+CAMPAIGN_MARKER_SCHEMA = "pyamplicol-performance-campaign-epoch-v1"
+RESET_JOURNAL_SCHEMA = "pyamplicol-performance-campaign-reset-v1"
+BASELINE_GATE_SCHEMA = "pyamplicol-performance-baseline-gate-v1"
+EXPECTED_CATALOG_CELL_COUNT = 2198
+EXPECTED_AMPLICOL_CELL_COUNT = 314
+EXPECTED_NON_AMPLICOL_CELL_COUNT = 1884
+_SUPPORTED_SEED_CATALOG_CARDINALITIES = frozenset(
+    {
+        (1646, 284, 1362),
+        (1666, 288, 1378),
+        (1706, 296, 1410),
+        (1796, 314, 1482),
+        (
+            EXPECTED_CATALOG_CELL_COUNT,
+            EXPECTED_AMPLICOL_CELL_COUNT,
+            EXPECTED_NON_AMPLICOL_CELL_COUNT,
+        ),
+    }
+)
+
+_SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
+_GIT_REVISION_RE = re.compile(r"^[0-9a-f]{40}$")
+_PROFILE_RE = re.compile(r"^[A-Za-z0-9_.-]+$")
+_LEGACY_METHOD = "original-amplicol-generated-library"
+_LEGACY_VALIDATION_METHOD = "independent-original-amplicol-oracle"
+_COMPILER_FIELDS = frozenset(
+    {"identity", "version", "flags", "target", "executable_sha256"}
+)
+_HASHED_ARCHIVE_BASENAMES = frozenset(
+    {
+        "current.json",
+        "manifest.json",
+        "result.json",
+        "worker-result.json",
+        "report-workspace.json",
+        "report_environment.json",
+        "measurement_lineage.json",
+        "pyAmpliCol.pdf",
+    }
+)
+
+
+class CampaignResetError(RuntimeError):
+    """The requested campaign epoch transition is not auditable."""
+
+
+def canonical_json_bytes(payload: object) -> bytes:
+    return (
+        json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        + "\n"
+    ).encode("ascii")
+
+
+def sha256_path(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def sha256_payload(payload: object) -> str:
+    return hashlib.sha256(canonical_json_bytes(payload)).hexdigest()
+
+
+def _atomic_write_json(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{uuid.uuid4()}.tmp")
+    try:
+        with temporary.open("xb") as stream:
+            stream.write(canonical_json_bytes(payload))
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+        _fsync_directory(path.parent)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _fsync_directory(path: Path) -> None:
+    descriptor = os.open(path, os.O_RDONLY)
+    try:
+        os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+def _read_object(path: Path, *, label: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise CampaignResetError(f"cannot read {label} {path}: {error}") from error
+    if not isinstance(payload, dict):
+        raise CampaignResetError(f"{label} must be a JSON object: {path}")
+    return payload
+
+
+def _require_sha256(value: object, *, label: str) -> str:
+    if not isinstance(value, str) or _SHA256_RE.fullmatch(value) is None:
+        raise CampaignResetError(f"{label} is not a lowercase SHA-256 digest")
+    return value
+
+
+def _require_revision(value: object, *, label: str) -> str:
+    if not isinstance(value, str) or _GIT_REVISION_RE.fullmatch(value) is None:
+        raise CampaignResetError(f"{label} is not a full Git revision")
+    return value
+
+
+def _current_pointer_path(record: CurrentRecord) -> Path:
+    return record.manifest_path.parent.parent.parent / "current.json"
+
+
+def _legacy_contract(
+    record: CurrentRecord,
+    *,
+    requires_selector: bool,
+    expected_legacy_revision: str | None = None,
+    expected_point_digest: str | None = None,
+) -> dict[str, object]:
+    provenance = record.result.get("provenance")
+    validation = record.result.get("validation")
+    selector = record.result.get("selector_contract")
+    resources = record.result.get("resources")
+    if not isinstance(provenance, Mapping):
+        raise CampaignResetError(f"{record.cell_id}: provenance is missing")
+    if provenance.get("method") != _LEGACY_METHOD:
+        raise CampaignResetError(
+            f"{record.cell_id}: result is not original generated-library AmpliCol"
+        )
+    legacy_revision = _require_revision(
+        provenance.get("revision"),
+        label=f"{record.cell_id}.provenance.revision",
+    )
+    if (
+        expected_legacy_revision is not None
+        and legacy_revision != expected_legacy_revision
+    ):
+        raise CampaignResetError(
+            f"{record.cell_id}: original-AmpliCol revision is not "
+            "contributor-lock pinned"
+        )
+    source_revision = _require_revision(
+        provenance.get("report_source_revision"),
+        label=f"{record.cell_id}.provenance.report_source_revision",
+    )
+    source_tree = _require_revision(
+        provenance.get("report_source_tree"),
+        label=f"{record.cell_id}.provenance.report_source_tree",
+    )
+    if (
+        provenance.get("report_measured_source_revision") != source_revision
+        or provenance.get("report_measured_source_tree") != source_tree
+        or provenance.get("report_source_clean") is not True
+    ):
+        raise CampaignResetError(
+            f"{record.cell_id}: report source provenance is not internally exact"
+        )
+    compiler = provenance.get("compiler")
+    if not isinstance(compiler, Mapping) or set(compiler) != _COMPILER_FIELDS:
+        raise CampaignResetError(f"{record.cell_id}: compiler identity is missing")
+    if (
+        not isinstance(compiler.get("identity"), str)
+        or not compiler["identity"]
+        or not isinstance(compiler.get("version"), str)
+        or not compiler["version"]
+        or not isinstance(compiler.get("target"), str)
+        or not compiler["target"]
+        or not isinstance(compiler.get("flags"), list)
+        or not all(isinstance(flag, str) for flag in compiler["flags"])
+    ):
+        raise CampaignResetError(
+            f"{record.cell_id}: compiler identity/version/flags/target are malformed"
+        )
+    _require_sha256(
+        compiler.get("executable_sha256"),
+        label=f"{record.cell_id}.compiler.executable_sha256",
+    )
+    if (
+        not isinstance(validation, Mapping)
+        or validation.get("status") != "ok"
+        or validation.get("method") != _LEGACY_VALIDATION_METHOD
+    ):
+        raise CampaignResetError(
+            f"{record.cell_id}: numerical validation is not successful"
+        )
+    validation_point_digest = _require_sha256(
+        validation.get("point_digest"),
+        label=f"{record.cell_id}.validation.point_digest",
+    )
+    if requires_selector:
+        if not isinstance(selector, Mapping):
+            raise CampaignResetError(
+                f"{record.cell_id}: LC selector contract is missing"
+            )
+        from .agreements import (
+            LC_COMMON_COMPONENT_FIELD,
+            validate_lc_common_component,
+        )
+        from .runner import SelectorContract
+
+        try:
+            typed_selector = SelectorContract.from_mapping(selector)
+            validate_lc_common_component(
+                validation.get(LC_COMMON_COMPONENT_FIELD),
+                expected_cell_id=record.cell_id,
+                selector_contract=selector,
+            )
+        except (TypeError, ValueError, RuntimeError) as error:
+            raise CampaignResetError(
+                f"{record.cell_id}: LC selector evidence is invalid"
+            ) from error
+        if typed_selector.point_digest != validation_point_digest:
+            raise CampaignResetError(
+                f"{record.cell_id}: LC selector and validation points differ"
+            )
+        if (
+            expected_point_digest is not None
+            and typed_selector.point_digest != expected_point_digest
+        ):
+            raise CampaignResetError(
+                f"{record.cell_id}: LC selector point predates the active "
+                "deterministic point corpus"
+            )
+        common_component = validation[LC_COMMON_COMPONENT_FIELD]
+        assert isinstance(common_component, Mapping)
+        if float(common_component["value"]) <= 0.0:
+            raise CampaignResetError(
+                f"{record.cell_id}: LC selector common component is structural zero"
+            )
+        selector_digest: str | None = sha256_payload(dict(selector))
+    elif selector is not None:
+        raise CampaignResetError(
+            f"{record.cell_id}: contracted AmpliCol result has a selector contract"
+        )
+    else:
+        selector_digest = None
+    if not isinstance(resources, Mapping):
+        raise CampaignResetError(f"{record.cell_id}: resource evidence is missing")
+    target = provenance.get("target_runtime_seconds")
+    achieved = (
+        provenance.get("runtime_profile", {})
+        if isinstance(provenance.get("runtime_profile"), Mapping)
+        else {}
+    )
+    measurement = (
+        achieved.get("measurement")
+        if isinstance(achieved, Mapping)
+        else None
+    )
+    if (
+        not isinstance(target, (int, float))
+        or isinstance(target, bool)
+        or not math.isfinite(float(target))
+        or float(target) <= 0.0
+        or not isinstance(measurement, Mapping)
+        or measurement.get("target_runtime_achieved") is not True
+    ):
+        raise CampaignResetError(
+            f"{record.cell_id}: finite target-runtime evidence is missing"
+        )
+    return {
+        "legacy_revision": legacy_revision,
+        "report_source_revision": source_revision,
+        "report_source_tree": source_tree,
+        "compiler_sha256": sha256_payload(dict(compiler)),
+        "selector_contract_sha256": selector_digest,
+        "validation_sha256": sha256_payload(dict(validation)),
+        "resource_evidence_sha256": sha256_payload(dict(resources)),
+        "target_runtime_seconds": float(target),
+        "workload_specific_generation": (
+            provenance.get("generation_timing_is_workload_specific") is True
+        ),
+        "row_selection_policy": provenance.get("row_selection_policy"),
+        "selector_color_word_policy": provenance.get(
+            "selector_color_word_policy"
+        ),
+    }
+
+
+def _pin_for_record(
+    record: CurrentRecord,
+    *,
+    profile: str,
+    catalog: ReportCatalog,
+    policy: CampaignPolicy,
+    expected_legacy_revision: str,
+) -> dict[str, object]:
+    cell = catalog.cell(record.cell_id)
+    if cell.measurement.execution_mode is not ExecutionMode.AMPLICOL:
+        raise CampaignResetError(f"{record.cell_id}: seed cell is not AmpliCol")
+    if record.result.get("status") != ResultStatus.OK.value:
+        raise CampaignResetError(f"{record.cell_id}: seed result is not ok")
+    validate_measurement(record.result, expected_cell=cell)
+    expected_point_digest: str | None = None
+    if cell.measurement.accuracy is Accuracy.LC:
+        from .measurement import shared_validation_points
+        from .runner import point_digest
+
+        expected_point_digest = point_digest(shared_validation_points(cell.process))
+    contract = _legacy_contract(
+        record,
+        requires_selector=(
+            cell.measurement.accuracy is Accuracy.LC
+        ),
+        expected_legacy_revision=expected_legacy_revision,
+        expected_point_digest=expected_point_digest,
+    )
+    validate_policy_measurement(
+        policy,
+        profile,
+        cell,
+        record.result,
+        expected_source_revision=str(contract["report_source_revision"]),
+        expected_source_tree=str(contract["report_source_tree"]),
+    )
+    pointer = _current_pointer_path(record)
+    return {
+        "cell_id": record.cell_id,
+        "attempt_id": record.attempt_id,
+        "current_pointer_sha256": sha256_path(pointer),
+        "manifest_sha256": record.manifest_sha256,
+        "result_sha256": sha256_path(record.result_path),
+        "artifact_count": len(record.artifacts),
+        "artifact_manifest_sha256": sha256_payload(
+            [
+                {
+                    "path": artifact.relative_path,
+                    "sha256": artifact.sha256,
+                    "size": artifact.size,
+                }
+                for artifact in record.artifacts
+            ]
+        ),
+        "contract": contract,
+    }
+
+
+def _lc_seed_family_rejections(
+    *,
+    cells: Mapping[str, CellSpec],
+    records_by_cell: Mapping[str, CurrentRecord],
+    admitted_cell_ids: set[str],
+) -> dict[str, str]:
+    """Reject LC seeds unless both layouts authenticate one exact selector.
+
+    A selected-flow seed is the selector authority for a subsequently measured
+    all-flow row.  Reusing only one historical layout, or two layouts carrying
+    different contracts, can therefore make a fresh dependent compare values
+    evaluated at different physical components.  Reject the complete pair so
+    the current adapter derives both rows from the same deterministic point and
+    selector; never rewrite historical numerical evidence.
+    """
+
+    families: dict[tuple[object, ...], dict[Workload, str]] = {}
+    for cell_id, cell in cells.items():
+        if (
+            cell.measurement.execution_mode is not ExecutionMode.AMPLICOL
+            or cell.measurement.accuracy is not Accuracy.LC
+        ):
+            continue
+        key = (
+            cell.dataset_id,
+            cell.process,
+            cell.process_key,
+            cell.n_final,
+            cell.measurement,
+            cell.variant,
+        )
+        families.setdefault(key, {})[cell.workload] = cell_id
+
+    rejected: dict[str, str] = {}
+    for family in families.values():
+        selected_id = family.get(Workload.SELECTED_FLOW)
+        all_flow_id = family.get(Workload.ALL_FLOW)
+        if selected_id is None or all_flow_id is None:
+            continue
+        admitted = {
+            cell_id
+            for cell_id in (selected_id, all_flow_id)
+            if cell_id in admitted_cell_ids
+        }
+        if not admitted:
+            continue
+        if admitted != {selected_id, all_flow_id}:
+            reason = (
+                "LC seed family is incomplete; selected/all-flow rows must be "
+                "remeasured under one selector authority"
+            )
+            rejected.update((cell_id, reason) for cell_id in admitted)
+            continue
+        selected = records_by_cell[selected_id].result.get("selector_contract")
+        all_flow = records_by_cell[all_flow_id].result.get("selector_contract")
+        if selected != all_flow:
+            reason = (
+                "LC selected/all-flow seed contracts differ; both layouts must "
+                "be remeasured under one selector authority"
+            )
+            rejected[selected_id] = reason
+            rejected[all_flow_id] = reason
+    return rejected
+
+
+def build_seed_manifest(
+    *,
+    profile: str,
+    store: ArtifactStore,
+    policy: CampaignPolicy,
+    final_source_revision: str,
+    final_source_tree: str,
+    expected_legacy_revision: str,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> dict[str, object]:
+    """Return the fail-closed same-profile AmpliCol seed manifest."""
+
+    if _PROFILE_RE.fullmatch(profile) is None:
+        raise CampaignResetError(f"invalid report profile {profile!r}")
+    _require_revision(final_source_revision, label="final_source_revision")
+    _require_revision(final_source_tree, label="final_source_tree")
+    _require_revision(
+        expected_legacy_revision,
+        label="expected_legacy_revision",
+    )
+    pins_by_cell: dict[str, dict[str, object]] = {}
+    records_by_cell: dict[str, CurrentRecord] = {}
+    rejected_by_cell: dict[str, str] = {}
+    cells = {cell.cell_id: cell for cell in catalog.measurement_cells()}
+    for record in store.recover_current_records():
+        cell = cells.get(record.cell_id)
+        if (
+            cell is None
+            or cell.measurement.execution_mode is not ExecutionMode.AMPLICOL
+        ):
+            continue
+        records_by_cell[record.cell_id] = record
+        try:
+            pins_by_cell[record.cell_id] = _pin_for_record(
+                record,
+                profile=profile,
+                catalog=catalog,
+                policy=policy,
+                expected_legacy_revision=expected_legacy_revision,
+            )
+        except (CampaignResetError, KeyError, ValueError) as error:
+            rejected_by_cell[record.cell_id] = str(error)
+    family_rejections = _lc_seed_family_rejections(
+        cells=cells,
+        records_by_cell=records_by_cell,
+        admitted_cell_ids=set(pins_by_cell),
+    )
+    for cell_id, reason in family_rejections.items():
+        pins_by_cell.pop(cell_id, None)
+        rejected_by_cell[cell_id] = reason
+    pins = sorted(pins_by_cell.values(), key=lambda item: str(item["cell_id"]))
+    rejected = [
+        {"cell_id": cell_id, "reason": reason}
+        for cell_id, reason in sorted(rejected_by_cell.items())
+    ]
+    amplicol_count = sum(
+        cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        for cell in cells.values()
+    )
+    if (
+        len(cells) != EXPECTED_CATALOG_CELL_COUNT
+        or amplicol_count != EXPECTED_AMPLICOL_CELL_COUNT
+        or len(cells) - amplicol_count != EXPECTED_NON_AMPLICOL_CELL_COUNT
+    ):
+        raise CampaignResetError(
+            "campaign reset catalog cardinality differs from "
+            f"{EXPECTED_CATALOG_CELL_COUNT}/{EXPECTED_AMPLICOL_CELL_COUNT}/"
+            f"{EXPECTED_NON_AMPLICOL_CELL_COUNT}"
+        )
+    payload: dict[str, object] = {
+        "schema": SEED_SCHEMA,
+        "profile": profile,
+        "final_source_revision": final_source_revision,
+        "final_source_tree": final_source_tree,
+        "expected_legacy_revision": expected_legacy_revision,
+        "catalog_cell_count": len(cells),
+        "amplicol_catalog_cell_count": amplicol_count,
+        "seed_count": len(pins),
+        "pins": pins,
+        "rejected": rejected,
+    }
+    payload["seed_manifest_sha256"] = sha256_payload(payload)
+    return payload
+
+
+@dataclass(frozen=True, slots=True)
+class OriginalAmplicolSeed:
+    """Digest-pinned authorization for host-local inherited baselines."""
+
+    profile: str
+    payload: Mapping[str, object]
+    pins_by_cell: Mapping[str, Mapping[str, object]]
+
+    @classmethod
+    def load(
+        cls,
+        path: Path,
+        *,
+        profile: str,
+        store: ArtifactStore,
+        catalog: ReportCatalog = REPORT_CATALOG,
+        expected_final_source_revision: str | None = None,
+        expected_final_source_tree: str | None = None,
+        expected_manifest_sha256: str | None = None,
+    ) -> OriginalAmplicolSeed:
+        raw = _read_object(path, label="original AmpliCol seed")
+        digest = raw.pop("seed_manifest_sha256", None)
+        if raw.get("schema") != SEED_SCHEMA or raw.get("profile") != profile:
+            raise CampaignResetError("original AmpliCol seed identity differs")
+        if _require_sha256(digest, label="seed_manifest_sha256") != sha256_payload(
+            raw
+        ):
+            raise CampaignResetError("original AmpliCol seed digest differs")
+        if expected_manifest_sha256 is not None and digest != expected_manifest_sha256:
+            raise CampaignResetError(
+                "original AmpliCol seed is not pinned by the campaign marker"
+            )
+        final_revision = _require_revision(
+            raw.get("final_source_revision"),
+            label="seed.final_source_revision",
+        )
+        final_tree = _require_revision(
+            raw.get("final_source_tree"),
+            label="seed.final_source_tree",
+        )
+        if (
+            expected_final_source_revision is not None
+            and final_revision != expected_final_source_revision
+        ):
+            raise CampaignResetError(
+                "original AmpliCol seed final source revision differs"
+            )
+        if (
+            expected_final_source_tree is not None
+            and final_tree != expected_final_source_tree
+        ):
+            raise CampaignResetError("original AmpliCol seed final source tree differs")
+        catalog_cells = catalog.measurement_cells()
+        expected_amplicol_count = sum(
+            cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+            for cell in catalog_cells
+        )
+        seed_catalog_count = raw.get("catalog_cell_count")
+        seed_amplicol_count = raw.get("amplicol_catalog_cell_count")
+        seed_non_amplicol_count = (
+            seed_catalog_count - seed_amplicol_count
+            if isinstance(seed_catalog_count, int)
+            and not isinstance(seed_catalog_count, bool)
+            and isinstance(seed_amplicol_count, int)
+            and not isinstance(seed_amplicol_count, bool)
+            else None
+        )
+        if (
+            len(catalog_cells) != EXPECTED_CATALOG_CELL_COUNT
+            or expected_amplicol_count != EXPECTED_AMPLICOL_CELL_COUNT
+            or len(catalog_cells) - expected_amplicol_count
+            != EXPECTED_NON_AMPLICOL_CELL_COUNT
+            or (
+                seed_catalog_count,
+                seed_amplicol_count,
+                seed_non_amplicol_count,
+            )
+            not in _SUPPORTED_SEED_CATALOG_CARDINALITIES
+            or seed_catalog_count > len(catalog_cells)
+            or seed_amplicol_count > expected_amplicol_count
+        ):
+            raise CampaignResetError(
+                "original AmpliCol seed catalog coverage differs"
+            )
+        pins = raw.get("pins")
+        if not isinstance(pins, list) or raw.get("seed_count") != len(pins):
+            raise CampaignResetError("original AmpliCol seed pin count differs")
+        by_cell: dict[str, Mapping[str, object]] = {}
+        for item in pins:
+            if not isinstance(item, Mapping):
+                raise CampaignResetError("original AmpliCol seed pin is malformed")
+            cell_id = item.get("cell_id")
+            if not isinstance(cell_id, str) or cell_id in by_cell:
+                raise CampaignResetError("original AmpliCol seed cell is duplicated")
+            cell = catalog.cell(cell_id)
+            if cell.measurement.execution_mode is not ExecutionMode.AMPLICOL:
+                raise CampaignResetError(f"{cell_id}: seed pin is not AmpliCol")
+            record = store.load_current(cell_id)
+            if record is None or not cls._matches(record, item):
+                raise CampaignResetError(f"{cell_id}: seeded current digest differs")
+            by_cell[cell_id] = item
+        complete = dict(raw)
+        complete["seed_manifest_sha256"] = digest
+        return cls(profile=profile, payload=complete, pins_by_cell=by_cell)
+
+    @staticmethod
+    def _matches(record: CurrentRecord, pin: Mapping[str, object]) -> bool:
+        contract = pin.get("contract")
+        try:
+            requires_selector = (
+                REPORT_CATALOG.cell(record.cell_id).measurement.accuracy.value == "lc"
+            )
+        except KeyError:
+            return False
+        try:
+            observed = _legacy_contract(
+                record,
+                requires_selector=requires_selector,
+                expected_legacy_revision=(
+                    str(contract.get("legacy_revision"))
+                    if isinstance(contract, Mapping)
+                    else None
+                ),
+            )
+        except CampaignResetError:
+            return False
+        return (
+            record.result.get("status") == ResultStatus.OK.value
+            and record.attempt_id == pin.get("attempt_id")
+            and record.manifest_sha256 == pin.get("manifest_sha256")
+            and sha256_path(_current_pointer_path(record))
+            == pin.get("current_pointer_sha256")
+            and sha256_path(record.result_path) == pin.get("result_sha256")
+            and len(record.artifacts) == pin.get("artifact_count")
+            and sha256_payload(
+                [
+                    {
+                        "path": artifact.relative_path,
+                        "sha256": artifact.sha256,
+                        "size": artifact.size,
+                    }
+                    for artifact in record.artifacts
+                ]
+            )
+            == pin.get("artifact_manifest_sha256")
+            and isinstance(contract, Mapping)
+            and dict(contract) == observed
+        )
+
+    @property
+    def digest(self) -> str:
+        return str(self.payload["seed_manifest_sha256"])
+
+    def source_for_current(
+        self,
+        record: CurrentRecord,
+        *,
+        active_revision: str,
+        active_tree: str,
+    ) -> tuple[str, str] | None:
+        if (
+            active_revision != self.payload.get("final_source_revision")
+            or active_tree != self.payload.get("final_source_tree")
+        ):
+            return None
+        provenance = record.result.get("provenance")
+        if isinstance(provenance, Mapping) and (
+            provenance.get("report_source_revision") == active_revision
+            and provenance.get("report_source_tree") == active_tree
+            and provenance.get("report_measured_source_revision")
+            == active_revision
+            and provenance.get("report_measured_source_tree") == active_tree
+        ):
+            return active_revision, active_tree
+        pin = self.pins_by_cell.get(record.cell_id)
+        if pin is None or not self._matches(record, pin):
+            return None
+        contract = pin.get("contract")
+        assert isinstance(contract, Mapping)
+        return (
+            str(contract["report_source_revision"]),
+            str(contract["report_source_tree"]),
+        )
+
+
+def load_seed_if_present(
+    *,
+    profile: str,
+    store: ArtifactStore,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> OriginalAmplicolSeed | None:
+    path = store.artifact_root / SEED_FILENAME
+    if not path.exists():
+        return None
+    if path.is_symlink() or not path.is_file():
+        raise CampaignResetError(f"seed manifest is not a regular file: {path}")
+    marker = _load_campaign_marker(
+        store.artifact_root,
+        profile=profile,
+        require_ready=True,
+    )
+    return OriginalAmplicolSeed.load(
+        path,
+        profile=profile,
+        store=store,
+        catalog=catalog,
+        expected_final_source_revision=str(marker["source_revision"]),
+        expected_final_source_tree=str(marker["source_tree"]),
+        expected_manifest_sha256=str(marker["seed_manifest_sha256"]),
+    )
+
+
+def _link_or_copy(source: Path, destination: Path) -> None:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        os.link(source, destination)
+    except OSError as error:
+        if error.errno not in {
+            errno.EXDEV,
+            errno.EPERM,
+            errno.EACCES,
+            getattr(errno, "EOPNOTSUPP", errno.EPERM),
+        }:
+            raise
+        shutil.copy2(source, destination)
+
+
+def stage_seed_store(
+    *,
+    source_store: ArtifactStore,
+    destination_root: Path,
+    destination_lock_root: Path,
+    seed_manifest: Mapping[str, object],
+) -> ArtifactStore:
+    """Create a fresh store containing only digest-pinned seed attempts."""
+
+    if destination_root.exists() or destination_lock_root.exists():
+        raise CampaignResetError("fresh campaign staging roots already exist")
+    destination = ArtifactStore(
+        artifact_root=destination_root,
+        lock_root=destination_lock_root,
+    )
+    pins = seed_manifest.get("pins")
+    if not isinstance(pins, list):
+        raise CampaignResetError("seed manifest pins are malformed")
+    records = {
+        record.cell_id: record for record in source_store.recover_current_records()
+    }
+    for pin in pins:
+        if not isinstance(pin, Mapping) or not isinstance(pin.get("cell_id"), str):
+            raise CampaignResetError("seed manifest pin is malformed")
+        record = records.get(str(pin["cell_id"]))
+        if record is None or not OriginalAmplicolSeed._matches(record, pin):
+            raise CampaignResetError(f"{pin['cell_id']}: source seed changed")
+        destination_cell = destination._cell_root(record.cell_id)
+        source_cell = _current_pointer_path(record).parent
+        destination_cell.mkdir(parents=True, exist_ok=True)
+        _link_or_copy(
+            source_cell / "current.json",
+            destination_cell / "current.json",
+        )
+        source_attempt = record.manifest_path.parent
+        destination_attempt = (
+            destination_cell / "attempts" / record.attempt_id
+        )
+        destination_attempt.mkdir(parents=True, exist_ok=True)
+        authenticated_files = {
+            record.manifest_path,
+            *(artifact.path for artifact in record.artifacts),
+        }
+        for source in sorted(authenticated_files):
+            if source.is_symlink() or not source.is_file():
+                raise CampaignResetError(
+                    f"seed contains an unauthenticated file type: {source}"
+                )
+            relative = source.relative_to(source_attempt)
+            _link_or_copy(source, destination_attempt / relative)
+    complete = dict(seed_manifest)
+    _atomic_write_json(destination_root / SEED_FILENAME, complete)
+    OriginalAmplicolSeed.load(
+        destination_root / SEED_FILENAME,
+        profile=str(seed_manifest["profile"]),
+        store=destination,
+        expected_final_source_revision=str(
+            seed_manifest["final_source_revision"]
+        ),
+        expected_final_source_tree=str(seed_manifest["final_source_tree"]),
+        expected_manifest_sha256=str(seed_manifest["seed_manifest_sha256"]),
+    )
+    return destination
+
+
+def lightweight_archive_inventory(roots: Sequence[Path]) -> dict[str, object]:
+    """Inventory an archive without re-reading manifest-authenticated binaries."""
+
+    entries: list[dict[str, object]] = []
+    for root in roots:
+        resolved = root.expanduser().resolve(strict=False)
+        if not resolved.exists():
+            continue
+        for path in sorted((resolved, *resolved.rglob("*"))):
+            stat = path.lstat()
+            entry: dict[str, object] = {
+                "root": os.fspath(resolved),
+                "path": (
+                    "."
+                    if path == resolved
+                    else path.relative_to(resolved).as_posix()
+                ),
+                "type": (
+                    "symlink"
+                    if path.is_symlink()
+                    else "directory"
+                    if path.is_dir()
+                    else "file"
+                    if path.is_file()
+                    else "special"
+                ),
+                "size": stat.st_size,
+                "mtime_ns": stat.st_mtime_ns,
+            }
+            if path.is_file() and (
+                path.name in _HASHED_ARCHIVE_BASENAMES
+                or path.suffix in {".json", ".pdf"}
+            ):
+                entry["sha256"] = sha256_path(path)
+            entries.append(entry)
+    payload: dict[str, object] = {
+        "schema": "pyamplicol-performance-archive-inventory-v1",
+        "entries": entries,
+    }
+    payload["inventory_sha256"] = sha256_payload(payload)
+    return payload
+
+
+def campaign_marker(
+    *,
+    campaign_id: str,
+    profile: str,
+    source_revision: str,
+    source_tree: str,
+    policy_sha256: str,
+    seed_manifest_sha256: str,
+    archive_manifest_sha256: str,
+) -> dict[str, object]:
+    if not campaign_id or "/" in campaign_id or "\x00" in campaign_id:
+        raise CampaignResetError("campaign_id is not a safe component")
+    payload: dict[str, object] = {
+        "schema": CAMPAIGN_MARKER_SCHEMA,
+        "state": "PREPARED",
+        "campaign_id": campaign_id,
+        "profile": profile,
+        "source_revision": _require_revision(
+            source_revision, label="source_revision"
+        ),
+        "source_tree": _require_revision(source_tree, label="source_tree"),
+        "policy_sha256": _require_sha256(
+            policy_sha256, label="policy_sha256"
+        ),
+        "seed_manifest_sha256": _require_sha256(
+            seed_manifest_sha256, label="seed_manifest_sha256"
+        ),
+        "archive_manifest_sha256": _require_sha256(
+            archive_manifest_sha256, label="archive_manifest_sha256"
+        ),
+        "baseline_gate_sha256": None,
+        "prepared_marker_sha256": None,
+    }
+    payload["marker_sha256"] = sha256_payload(payload)
+    return payload
+
+
+def _load_campaign_marker(
+    artifact_root: Path,
+    *,
+    profile: str,
+    require_ready: bool,
+) -> dict[str, object]:
+    path = artifact_root / CAMPAIGN_MARKER_FILENAME
+    marker = _read_object(path, label="campaign marker")
+    digest = marker.pop("marker_sha256", None)
+    if (
+        marker.get("schema") != CAMPAIGN_MARKER_SCHEMA
+        or marker.get("profile") != profile
+        or marker.get("state") not in {"PREPARED", "READY"}
+        or _require_sha256(digest, label="marker_sha256")
+        != sha256_payload(marker)
+    ):
+        raise CampaignResetError("active campaign marker differs")
+    if require_ready:
+        if marker.get("state") != "READY":
+            raise CampaignResetError("campaign baseline gate is not READY")
+        gate_digest = _require_sha256(
+            marker.get("baseline_gate_sha256"),
+            label="baseline_gate_sha256",
+        )
+        prepared_digest = _require_sha256(
+            marker.get("prepared_marker_sha256"),
+            label="prepared_marker_sha256",
+        )
+        gate = _read_object(
+            artifact_root / BASELINE_GATE_FILENAME,
+            label="campaign baseline gate",
+        )
+        observed_gate_digest = gate.pop("baseline_gate_sha256", None)
+        if (
+            _require_sha256(
+                observed_gate_digest,
+                label="baseline_gate.baseline_gate_sha256",
+            )
+            != sha256_payload(gate)
+            or observed_gate_digest != gate_digest
+            or gate.get("prepared_marker_sha256") != prepared_digest
+            or gate.get("campaign_id") != marker.get("campaign_id")
+            or gate.get("profile") != profile
+            or gate.get("source_revision") != marker.get("source_revision")
+            or gate.get("source_tree") != marker.get("source_tree")
+        ):
+            raise CampaignResetError("campaign baseline gate differs")
+    marker["marker_sha256"] = digest
+    return marker
+
+
+def mark_campaign_ready(
+    artifact_root: Path,
+    *,
+    baseline_gate_sha256: str,
+) -> dict[str, object]:
+    raw_marker = _read_object(
+        artifact_root / CAMPAIGN_MARKER_FILENAME,
+        label="campaign marker",
+    )
+    profile = raw_marker.get("profile")
+    if not isinstance(profile, str) or not profile:
+        raise CampaignResetError("campaign marker profile is malformed")
+    marker = _load_campaign_marker(
+        artifact_root,
+        profile=profile,
+        require_ready=False,
+    )
+    if marker.get("state") != "PREPARED":
+        raise CampaignResetError("campaign marker is not PREPARED")
+    prepared_digest = str(marker.pop("marker_sha256"))
+    marker["state"] = "READY"
+    marker["baseline_gate_sha256"] = _require_sha256(
+        baseline_gate_sha256,
+        label="baseline_gate_sha256",
+    )
+    marker["prepared_marker_sha256"] = prepared_digest
+    marker["marker_sha256"] = sha256_payload(marker)
+    _atomic_write_json(artifact_root / CAMPAIGN_MARKER_FILENAME, marker)
+    return marker
+
+
+def assert_campaign_marker(
+    artifact_root: Path,
+    *,
+    campaign_id: str,
+    profile: str,
+    source_revision: str,
+    source_tree: str,
+    expected_marker_sha256: str | None = None,
+    require_ready: bool = True,
+) -> dict[str, object]:
+    marker = _load_campaign_marker(
+        artifact_root,
+        profile=profile,
+        require_ready=require_ready,
+    )
+    digest = marker["marker_sha256"]
+    if (
+        marker.get("campaign_id") != campaign_id
+        or marker.get("profile") != profile
+        or marker.get("source_revision") != source_revision
+        or marker.get("source_tree") != source_tree
+    ):
+        raise CampaignResetError("active campaign marker differs")
+    if expected_marker_sha256 is not None and digest != expected_marker_sha256:
+        raise CampaignResetError("active campaign marker digest differs")
+    return marker
+
+
+def temporary_staging_root(parent: Path, *, campaign_id: str) -> Path:
+    parent.mkdir(parents=True, exist_ok=True)
+    return Path(
+        tempfile.mkdtemp(
+            prefix=f".campaign-reset-{campaign_id}.",
+            dir=parent,
+        )
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class ResetTransactionPaths:
+    """Explicit paths participating in one same-filesystem epoch transition."""
+
+    source_publication: Path
+    source_artifact_root: Path
+    source_coordination_root: Path
+    destination_publication: Path
+    destination_artifact_root: Path
+    destination_coordination_root: Path
+    archive_root: Path
+    staging_root: Path
+    guard_path: Path
+
+    @property
+    def journal_path(self) -> Path:
+        return self.staging_root / RESET_JOURNAL_FILENAME
+
+
+def _transaction_payload(
+    *,
+    state: str,
+    profile: str,
+    campaign_id: str,
+    archive_id: str,
+    paths: ResetTransactionPaths,
+    archive_manifest_sha256: str,
+    seed_manifest_sha256: str,
+    marker_sha256: str,
+) -> dict[str, object]:
+    payload: dict[str, object] = {
+        "schema": RESET_JOURNAL_SCHEMA,
+        "state": state,
+        "profile": profile,
+        "campaign_id": campaign_id,
+        "archive_id": archive_id,
+        "paths": {
+            field: os.fspath(getattr(paths, field))
+            for field in (
+                "source_publication",
+                "source_artifact_root",
+                "source_coordination_root",
+                "destination_publication",
+                "destination_artifact_root",
+                "destination_coordination_root",
+                "archive_root",
+                "staging_root",
+                "guard_path",
+            )
+        },
+        "archive_manifest_sha256": archive_manifest_sha256,
+        "seed_manifest_sha256": seed_manifest_sha256,
+        "marker_sha256": marker_sha256,
+    }
+    payload["journal_sha256"] = sha256_payload(payload)
+    return payload
+
+
+def write_prepared_journal(
+    *,
+    profile: str,
+    campaign_id: str,
+    archive_id: str,
+    paths: ResetTransactionPaths,
+    archive_manifest_sha256: str,
+    seed_manifest_sha256: str,
+    marker_sha256: str,
+) -> dict[str, object]:
+    payload = _transaction_payload(
+        state="PREPARED",
+        profile=profile,
+        campaign_id=campaign_id,
+        archive_id=archive_id,
+        paths=paths,
+        archive_manifest_sha256=archive_manifest_sha256,
+        seed_manifest_sha256=seed_manifest_sha256,
+        marker_sha256=marker_sha256,
+    )
+    _atomic_write_json(paths.journal_path, payload)
+    return payload
+
+
+def _validated_journal(path: Path) -> dict[str, Any]:
+    payload = _read_object(path, label="campaign reset journal")
+    digest = payload.pop("journal_sha256", None)
+    if (
+        payload.get("schema") != RESET_JOURNAL_SCHEMA
+        or payload.get("state") not in {"PREPARED", "COMMITTING", "COMMITTED"}
+        or _require_sha256(digest, label="journal_sha256")
+        != sha256_payload(payload)
+    ):
+        raise CampaignResetError("campaign reset journal differs")
+    payload["journal_sha256"] = digest
+    return payload
+
+
+def _paths_from_journal(payload: Mapping[str, object]) -> ResetTransactionPaths:
+    raw = payload.get("paths")
+    if not isinstance(raw, Mapping):
+        raise CampaignResetError("campaign reset journal paths are malformed")
+    names = (
+        "source_publication",
+        "source_artifact_root",
+        "source_coordination_root",
+        "destination_publication",
+        "destination_artifact_root",
+        "destination_coordination_root",
+        "archive_root",
+        "staging_root",
+        "guard_path",
+    )
+    if set(raw) != set(names):
+        raise CampaignResetError("campaign reset journal path set differs")
+    resolved: dict[str, Path] = {}
+    for name in names:
+        value = raw.get(name)
+        if not isinstance(value, str) or not Path(value).is_absolute():
+            raise CampaignResetError(f"campaign reset path {name} is not absolute")
+        resolved[name] = Path(value).resolve(strict=False)
+    return ResetTransactionPaths(**resolved)
+
+
+def _rename_forward(source: Path, destination: Path, *, label: str) -> None:
+    if destination.exists():
+        if source.exists():
+            raise CampaignResetError(
+                f"{label}: both source and destination exist"
+            )
+        return
+    if not source.exists():
+        raise CampaignResetError(f"{label}: source is missing")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    os.replace(source, destination)
+    _fsync_directory(destination.parent)
+
+
+def _filesystem_device(path: Path) -> int:
+    candidate = path.expanduser().resolve(strict=False)
+    while not candidate.exists():
+        parent = candidate.parent
+        if parent == candidate:
+            raise CampaignResetError(
+                f"cannot resolve filesystem device for {path}"
+            )
+        candidate = parent
+    return candidate.stat().st_dev
+
+
+def _require_transaction_filesystem(paths: ResetTransactionPaths) -> None:
+    devices = {
+        _filesystem_device(path)
+        for path in (
+            paths.source_publication,
+            paths.source_artifact_root,
+            paths.source_coordination_root,
+            paths.destination_publication,
+            paths.destination_artifact_root,
+            paths.destination_coordination_root,
+            paths.archive_root,
+            paths.staging_root,
+            paths.guard_path,
+        )
+    }
+    if len(devices) != 1:
+        raise CampaignResetError(
+            "campaign reset journal crosses filesystem boundaries"
+        )
+
+
+def _install_publication_tree(source: Path, destination: Path) -> None:
+    if not source.is_dir() or source.is_symlink():
+        raise CampaignResetError("staged publication is not a regular directory")
+    destination.mkdir(parents=True, exist_ok=True)
+    for staged in sorted(source.rglob("*")):
+        relative = staged.relative_to(source)
+        target = destination / relative
+        if staged.is_symlink():
+            raise CampaignResetError(
+                f"staged publication contains a symlink: {staged}"
+            )
+        if staged.is_dir():
+            target.mkdir(parents=True, exist_ok=True)
+            continue
+        if not staged.is_file():
+            raise CampaignResetError(
+                f"staged publication contains a special file: {staged}"
+            )
+        target.parent.mkdir(parents=True, exist_ok=True)
+        temporary = target.with_name(f".{target.name}.{uuid.uuid4()}.tmp")
+        shutil.copy2(staged, temporary)
+        os.replace(temporary, target)
+        _fsync_directory(target.parent)
+
+
+def commit_or_recover_reset(journal_path: Path) -> dict[str, object]:
+    """Finish a PREPARED reset transaction; repeated calls are idempotent."""
+
+    journal = _validated_journal(journal_path)
+    paths = _paths_from_journal(journal)
+    _require_transaction_filesystem(paths)
+    paths.guard_path.parent.mkdir(parents=True, exist_ok=True)
+    with paths.guard_path.open("a+b") as guard:
+        fcntl.flock(guard.fileno(), fcntl.LOCK_EX)
+        try:
+            journal = _validated_journal(journal_path)
+            if journal["state"] == "COMMITTED":
+                return journal
+            committing = dict(journal)
+            committing["state"] = "COMMITTING"
+            committing.pop("journal_sha256", None)
+            committing["journal_sha256"] = sha256_payload(committing)
+            _atomic_write_json(journal_path, committing)
+
+            archive_artifacts = paths.archive_root / "artifacts"
+            archive_coordination = paths.archive_root / "coordination"
+            archive_publication = paths.archive_root / "publication"
+            staged_artifacts = paths.staging_root / "fresh-artifacts"
+            staged_coordination = paths.staging_root / "fresh-coordination"
+            staged_publication = paths.staging_root / "fresh-publication"
+            staged_archive_publication = (
+                paths.staging_root / "archive-publication"
+            )
+            staged_archive_manifest = (
+                paths.staging_root / "archive-manifest.json"
+            )
+            _rename_forward(
+                staged_archive_publication,
+                archive_publication,
+                label="archive publication",
+            )
+            _rename_forward(
+                staged_archive_manifest,
+                paths.archive_root / "archive-manifest.json",
+                label="archive manifest",
+            )
+            _rename_forward(
+                paths.source_artifact_root,
+                archive_artifacts,
+                label="archive artifact root",
+            )
+            _rename_forward(
+                paths.source_coordination_root,
+                archive_coordination,
+                label="archive coordination root",
+            )
+            _rename_forward(
+                staged_artifacts,
+                paths.destination_artifact_root,
+                label="install fresh artifact root",
+            )
+            _rename_forward(
+                staged_coordination,
+                paths.destination_coordination_root,
+                label="install fresh coordination root",
+            )
+            _install_publication_tree(
+                staged_publication,
+                paths.destination_publication,
+            )
+            committed = dict(committing)
+            committed["state"] = "COMMITTED"
+            committed.pop("journal_sha256", None)
+            committed["journal_sha256"] = sha256_payload(committed)
+            archive_journal = paths.archive_root / RESET_JOURNAL_FILENAME
+            _atomic_write_json(archive_journal, committed)
+            _atomic_write_json(journal_path, committed)
+            return committed
+        finally:
+            fcntl.flock(guard.fileno(), fcntl.LOCK_UN)
+
+
+__all__ = [
+    "BASELINE_GATE_FILENAME",
+    "CAMPAIGN_MARKER_FILENAME",
+    "CAMPAIGN_MARKER_SCHEMA",
+    "EXPECTED_AMPLICOL_CELL_COUNT",
+    "EXPECTED_CATALOG_CELL_COUNT",
+    "EXPECTED_NON_AMPLICOL_CELL_COUNT",
+    "RESET_JOURNAL_FILENAME",
+    "SEED_FILENAME",
+    "SEED_SCHEMA",
+    "CampaignResetError",
+    "OriginalAmplicolSeed",
+    "ResetTransactionPaths",
+    "assert_campaign_marker",
+    "build_seed_manifest",
+    "campaign_marker",
+    "canonical_json_bytes",
+    "commit_or_recover_reset",
+    "lightweight_archive_inventory",
+    "load_seed_if_present",
+    "mark_campaign_ready",
+    "sha256_path",
+    "sha256_payload",
+    "stage_seed_store",
+    "temporary_staging_root",
+    "write_prepared_journal",
+]
diff --git a/pyamplicol/tools/performance_report/catalog.py b/pyamplicol/tools/performance_report/catalog.py
new file mode 100644
index 0000000000..b4780ae46b
--- /dev/null
+++ b/pyamplicol/tools/performance_report/catalog.py
@@ -0,0 +1,821 @@
+# SPDX-License-Identifier: 0BSD
+"""Canonical report process, mode, dataset, and cell catalog."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .models import (
+    LEGACY_AMPLICOL_MAX_OPEN_QUARK_LINES,
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    MatrixComparisonView,
+    MatrixDataset,
+    MeasurementSpec,
+    ModelKey,
+    ModelSpec,
+    ProcessFamily,
+    ScalarDataset,
+    Workload,
+    ZVariant,
+    open_quark_line_count,
+)
+
+BUILTIN_SM = ModelSpec(
+    ModelKey.BUILTIN_SM,
+    "built-in-sm",
+    "Built-in Standard Model",
+    "built-in-sm",
+)
+UFO_SM = ModelSpec(ModelKey.UFO_SM, "external-sm", "UFO-SM", "json")
+SCALAR_CONTACT = ModelSpec(
+    ModelKey.SCALAR_CONTACT,
+    "scalar-contact",
+    "Massless scalar contact model",
+    "json",
+)
+SCALAR_GRAVITY = ModelSpec(
+    ModelKey.SCALAR_GRAVITY,
+    "scalar-gravity",
+    "Scalar-gravity model",
+    "json",
+)
+
+MODELS = {
+    model.key: model
+    for model in (BUILTIN_SM, UFO_SM, SCALAR_CONTACT, SCALAR_GRAVITY)
+}
+
+PROCESS_FAMILIES = (
+    ProcessFamily(1, "dd_z_jets", r"$d\bar d\to Z+(n-1)g$", ("d", "d~"), ("z",), 9),
+    ProcessFamily(
+        2,
+        "ud_w_jets",
+        r"$u\bar d\to W^++(n-1)g$",
+        ("u", "d~"),
+        ("w+",),
+        9,
+        include_cc=True,
+    ),
+    ProcessFamily(
+        3,
+        "dd_epem_jets",
+        r"$d\bar d\to e^+e^-+(n-2)g$",
+        ("d", "d~"),
+        ("e+", "e-"),
+        9,
+    ),
+    ProcessFamily(
+        4,
+        "ud_epve_jets",
+        r"$u\bar d\to e^+\nu_e+(n-2)g$",
+        ("u", "d~"),
+        ("e+", "ve"),
+        9,
+        include_cc=True,
+    ),
+    ProcessFamily(
+        5,
+        "dd_zz_jets",
+        r"$d\bar d\to ZZ+(n-2)g$",
+        ("d", "d~"),
+        ("z", "z"),
+        9,
+    ),
+    ProcessFamily(
+        6,
+        "gg_tt_jets",
+        r"$gg\to t\bar t+(n-2)g$",
+        ("g", "g"),
+        ("t", "t~"),
+        9,
+    ),
+    ProcessFamily(
+        7,
+        "dd_tt_jets",
+        r"$d\bar d\to t\bar t+(n-2)g$",
+        ("d", "d~"),
+        ("t", "t~"),
+        9,
+    ),
+    ProcessFamily(
+        8,
+        "gg_gluons",
+        r"$gg\to gg+(n-2)g$",
+        ("g", "g"),
+        ("g", "g"),
+        9,
+    ),
+    ProcessFamily(
+        9,
+        "dd_zzz_jets",
+        r"$d\bar d\to ZZZ+(n-3)g$",
+        ("d", "d~"),
+        ("z", "z", "z"),
+        9,
+    ),
+    ProcessFamily(
+        10,
+        "dd_epemzh_jets",
+        r"$d\bar d\to e^+e^-ZH+(n-4)g$",
+        ("d", "d~"),
+        ("e+", "e-", "z", "h"),
+        9,
+    ),
+    ProcessFamily(
+        11,
+        "dd_ttzh_jets",
+        r"$d\bar d\to t\bar t ZH+(n-4)g$",
+        ("d", "d~"),
+        ("t", "t~", "z", "h"),
+        9,
+    ),
+    ProcessFamily(
+        12,
+        "dd_4l_jets",
+        r"$d\bar d\to e^+e^-e^+e^-+(n-4)g$",
+        ("d", "d~"),
+        ("e+", "e-", "e+", "e-"),
+        9,
+    ),
+    ProcessFamily(
+        13,
+        "dd_3q_lines",
+        r"$d\bar d\to u\bar u\,s\bar s+(n-4)g$",
+        ("d", "d~"),
+        ("u", "u~", "s", "s~"),
+        9,
+        maximum_contracted_n=6,
+        include_3qqbar=True,
+    ),
+    ProcessFamily(
+        14,
+        "dd_4q_lines",
+        r"$d\bar d\to u\bar u\,s\bar s\,c\bar c+(n-6)g$",
+        ("d", "d~"),
+        ("u", "u~", "s", "s~", "c", "c~"),
+        9,
+        maximum_contracted_n=6,
+        include_3qqbar=True,
+    ),
+    ProcessFamily(
+        15,
+        "dd_3q_identical_lines",
+        r"$d\bar d\to u\bar u\,u\bar u+(n-4)g$",
+        ("d", "d~"),
+        ("u", "u~", "u", "u~"),
+        9,
+        maximum_contracted_n=6,
+        include_3qqbar=True,
+    ),
+)
+
+
+def matrix_multiplicities(accuracy: Accuracy) -> tuple[int, ...]:
+    """Return publication multiplicities for one matrix accuracy.
+
+    LC retains the full report ladder.  Contracted NLC/full-colour tables
+    expose ``n=6`` so multi-quark families can declare candidate coverage
+    independently of the historical AmpliCol implementation.
+    """
+
+    return tuple(range(1, 10 if accuracy is Accuracy.LC else 7))
+
+
+def _measurement(
+    mode: ExecutionMode,
+    model: ModelKey | None,
+    accuracy: Accuracy,
+) -> MeasurementSpec:
+    if mode is ExecutionMode.AMPLICOL:
+        return MeasurementSpec(mode, None, accuracy, "fortran", None)
+    if mode is ExecutionMode.MADGRAPH:
+        return MeasurementSpec(mode, model, accuracy, "fortran", None)
+    if mode is ExecutionMode.COMPILED:
+        return MeasurementSpec(mode, model, accuracy, "jit", 3)
+    return MeasurementSpec(mode, model, accuracy, "jit", 2)
+
+
+def _matrix_dataset(
+    *,
+    mode: ExecutionMode,
+    model: ModelKey,
+    accuracy: Accuracy,
+    baseline_mode: ExecutionMode,
+    multiplicities: tuple[int, ...] | None = None,
+    static_na_reason_code: str | None = None,
+) -> MatrixDataset:
+    model_label = "Built-in SM" if model is ModelKey.BUILTIN_SM else "UFO-SM"
+    accuracy_label = {
+        Accuracy.LC: "LC",
+        Accuracy.NLC: "NLC",
+        Accuracy.FULL: "full-colour",
+    }[accuracy]
+    mode_label = {
+        ExecutionMode.RECURRENCE: "recurrence",
+        ExecutionMode.COMPILED: "compiled JIT O3",
+        ExecutionMode.EAGER: "eager-DAG JIT O2",
+        ExecutionMode.ON_THE_FLY: "on-the-fly JIT O2",
+    }[mode]
+    baseline_label = {
+        ExecutionMode.AMPLICOL: "AmpliCol",
+        ExecutionMode.MADGRAPH: "MadGraph",
+        ExecutionMode.RECURRENCE: "recurrence JIT O2",
+    }[baseline_mode]
+    baseline_model = (
+        ModelKey.UFO_SM
+        if baseline_mode is ExecutionMode.MADGRAPH
+        else ModelKey.BUILTIN_SM
+    )
+    stem = f"matrix_{mode.value.replace('-', '_')}_{model.value}_{accuracy.value}"
+    return MatrixDataset(
+        dataset_id=stem,
+        cache_name=f"{stem}.json",
+        table_name=f"result_{stem}_table.tex",
+        title=f"{model_label} {mode_label} versus {baseline_label} {accuracy_label}",
+        candidate=_measurement(mode, model, accuracy),
+        baseline=_measurement(baseline_mode, baseline_model, accuracy),
+        multiplicities=(
+            matrix_multiplicities(accuracy)
+            if multiplicities is None
+            else multiplicities
+        ),
+        static_na_reason_code=static_na_reason_code,
+    )
+
+
+MATRIX_DATASETS = tuple(
+    _matrix_dataset(
+        mode=ExecutionMode.RECURRENCE,
+        model=model,
+        accuracy=accuracy,
+        baseline_mode=ExecutionMode.AMPLICOL,
+    )
+    for model in (ModelKey.BUILTIN_SM, ModelKey.UFO_SM)
+    for accuracy in Accuracy
+) + tuple(
+    _matrix_dataset(
+        mode=mode,
+        model=ModelKey.BUILTIN_SM,
+        accuracy=accuracy,
+        baseline_mode=ExecutionMode.RECURRENCE,
+    )
+    for mode in (ExecutionMode.COMPILED, ExecutionMode.EAGER)
+    for accuracy in Accuracy
+) + tuple(
+    _matrix_dataset(
+        mode=ExecutionMode.ON_THE_FLY,
+        model=ModelKey.BUILTIN_SM,
+        accuracy=accuracy,
+        baseline_mode=ExecutionMode.AMPLICOL,
+        multiplicities=(
+            (1, 2, 3, 4)
+            if accuracy is Accuracy.LC
+            else matrix_multiplicities(accuracy)
+        ),
+    )
+    for accuracy in Accuracy
+) + tuple(
+    _matrix_dataset(
+        mode=mode,
+        model=ModelKey.UFO_SM,
+        accuracy=Accuracy.FULL,
+        baseline_mode=ExecutionMode.MADGRAPH,
+    )
+    for mode in (
+        ExecutionMode.COMPILED,
+        ExecutionMode.EAGER,
+        ExecutionMode.ON_THE_FLY,
+    )
+)
+
+
+def _madgraph_full_comparison_view(
+    mode: ExecutionMode,
+) -> MatrixComparisonView:
+    mode_label = {
+        ExecutionMode.RECURRENCE: "recurrence JIT O2",
+        ExecutionMode.COMPILED: "compiled JIT O3",
+        ExecutionMode.EAGER: "eager-DAG JIT O2",
+        ExecutionMode.ON_THE_FLY: "on-the-fly JIT O2",
+    }[mode]
+    stem = f"matrix_{mode.value.replace('-', '_')}_ufo_sm_full_vs_madgraph"
+    return MatrixComparisonView(
+        comparison_id=stem,
+        candidate_dataset_id=(
+            f"matrix_{mode.value.replace('-', '_')}_ufo_sm_full"
+        ),
+        baseline_dataset_id="reference_madgraph_full",
+        title=f"UFO-SM {mode_label} versus MadGraph full-colour",
+        table_name=f"result_{stem}_table.tex",
+    )
+
+
+MADGRAPH_FULL_COMPARISON_VIEWS = tuple(
+    _madgraph_full_comparison_view(mode)
+    for mode in (
+        ExecutionMode.RECURRENCE,
+        ExecutionMode.COMPILED,
+        ExecutionMode.EAGER,
+        ExecutionMode.ON_THE_FLY,
+    )
+)
+
+SCALAR_DATASETS = (
+    ScalarDataset(
+        dataset_id="scalar_contact",
+        cache_name="scalar_contact.json",
+        table_name="result_scalar_contact_table.tex",
+        title="Scalar-contact ladder",
+        model=ModelKey.SCALAR_CONTACT,
+        process_template="scalar_0 scalar_0 > n*scalar_0",
+        final_particle="scalar_0",
+        multiplicities=tuple(range(2, 9)),
+        measurement=_measurement(
+            ExecutionMode.COMPILED,
+            ModelKey.SCALAR_CONTACT,
+            Accuracy.FULL,
+        ),
+    ),
+    ScalarDataset(
+        dataset_id="scalar_gravity",
+        cache_name="scalar_gravity.json",
+        table_name="result_scalar_gravity_table.tex",
+        title="Scalar-gravity ladder",
+        model=ModelKey.SCALAR_GRAVITY,
+        process_template="scalar_0 scalar_0 > n*graviton",
+        final_particle="graviton",
+        multiplicities=tuple(range(2, 5)),
+        measurement=_measurement(
+            ExecutionMode.COMPILED,
+            ModelKey.SCALAR_GRAVITY,
+            Accuracy.FULL,
+        ),
+    ),
+)
+
+Z_VARIANTS = (
+    ZVariant("reference", "Independent reference", ExecutionMode.AMPLICOL, "fortran"),
+    ZVariant("jit_o1", "JIT level 1", ExecutionMode.COMPILED, "jit", 1),
+    ZVariant(
+        "asm_o3",
+        "ASM O3",
+        ExecutionMode.COMPILED,
+        "asm",
+        maximum_generation_n_final=6,
+        static_na_reason_code="native-backend-generation-cap-n6-v1",
+    ),
+    ZVariant(
+        "cpp_o3",
+        "C++ O3",
+        ExecutionMode.COMPILED,
+        "cpp",
+        cpp_optimization="O3",
+        maximum_generation_n_final=6,
+        static_na_reason_code="native-backend-generation-cap-n6-v1",
+    ),
+    ZVariant("jit_o3", "JIT level 3", ExecutionMode.COMPILED, "jit", 3),
+    ZVariant(
+        "eager_jit_o2",
+        "eager-DAG JIT O2",
+        ExecutionMode.EAGER,
+        "jit",
+        2,
+    ),
+    ZVariant(
+        "recurrence_jit_o2",
+        "recurrence JIT O2",
+        ExecutionMode.RECURRENCE,
+        "jit",
+        2,
+    ),
+    ZVariant(
+        "on_the_fly_jit_o2",
+        "on-the-fly JIT O2",
+        ExecutionMode.ON_THE_FLY,
+        "jit",
+        2,
+    ),
+)
+
+STATIC_NA_ORIGINAL_AMPLICOL_OPEN_QUARK_LINE_LIMIT = (
+    "original-amplicol-open-quark-line-limit"
+)
+STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6 = (
+    "native-backend-generation-cap-n6-v1"
+)
+STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6_DESCRIPTION = (
+    "user cap: native C++/ASM generation is not attempted above n=6"
+)
+
+
+def z_dataset_id(model: ModelKey) -> str:
+    if model is ModelKey.BUILTIN_SM:
+        return "z_builtin_sm"
+    if model is ModelKey.UFO_SM:
+        return "z_external_sm"
+    raise ValueError("Z ladders support only built-in SM and UFO-SM")
+
+
+@dataclass(frozen=True, slots=True)
+class ReportCatalog:
+    models: dict[ModelKey, ModelSpec]
+    process_families: tuple[ProcessFamily, ...]
+    matrix_datasets: tuple[MatrixDataset, ...]
+    matrix_comparison_views: tuple[MatrixComparisonView, ...]
+    scalar_datasets: tuple[ScalarDataset, ...]
+    z_variants: tuple[ZVariant, ...]
+    _measurement_cells_cache: tuple[CellSpec, ...] | None = field(
+        default=None,
+        init=False,
+        repr=False,
+        compare=False,
+        hash=False,
+    )
+
+    def dataset(self, dataset_id: str) -> MatrixDataset:
+        matches = [
+            dataset
+            for dataset in self.matrix_datasets
+            if dataset.dataset_id == dataset_id
+        ]
+        if not matches:
+            raise KeyError(f"unknown matrix dataset {dataset_id!r}")
+        return matches[0]
+
+    def comparison_view(self, comparison_id: str) -> MatrixComparisonView:
+        matches = [
+            view
+            for view in self.matrix_comparison_views
+            if view.comparison_id == comparison_id
+        ]
+        if not matches:
+            raise KeyError(f"unknown matrix comparison view {comparison_id!r}")
+        return matches[0]
+
+    def matrix_cells(self) -> tuple[CellSpec, ...]:
+        cells: list[CellSpec] = []
+        for dataset in self.matrix_datasets:
+            for family in self.process_families:
+                for n_final in dataset.multiplicities:
+                    process = family.process(n_final)
+                    if process is None or n_final > family.maximum_n(
+                        dataset.candidate.accuracy
+                    ):
+                        continue
+                    workloads = (
+                        (Workload.SELECTED_FLOW, Workload.ALL_FLOW)
+                        if dataset.candidate.accuracy is Accuracy.LC
+                        else (Workload.CONTRACTED,)
+                    )
+                    for workload in workloads:
+                        cells.append(
+                            CellSpec(
+                                dataset_id=dataset.dataset_id,
+                                process=process,
+                                n_final=n_final,
+                                process_key=family.key,
+                                measurement=dataset.candidate,
+                                workload=workload,
+                            )
+                        )
+        return tuple(cells)
+
+    def reference_cells(self) -> tuple[CellSpec, ...]:
+        cells: list[CellSpec] = []
+        for accuracy in Accuracy:
+            multiplicities = matrix_multiplicities(accuracy)
+            for family in self.process_families:
+                for n_final in multiplicities:
+                    process = family.process(n_final)
+                    if process is None or n_final > family.maximum_n(accuracy):
+                        continue
+                    workloads = (
+                        (Workload.SELECTED_FLOW, Workload.ALL_FLOW)
+                        if accuracy is Accuracy.LC
+                        else (Workload.CONTRACTED,)
+                    )
+                    for workload in workloads:
+                        cells.append(
+                            CellSpec(
+                                dataset_id=f"reference_amplicol_{accuracy.value}",
+                                process=process,
+                                n_final=n_final,
+                                process_key=family.key,
+                                measurement=_measurement(
+                                    ExecutionMode.AMPLICOL,
+                                    None,
+                                    accuracy,
+                                ),
+                                workload=workload,
+                            )
+                        )
+        for family in self.process_families:
+            for n_final in matrix_multiplicities(Accuracy.FULL):
+                process = family.process(n_final)
+                if process is None or n_final > family.maximum_n(Accuracy.FULL):
+                    continue
+                cells.append(
+                    CellSpec(
+                        dataset_id="reference_madgraph_full",
+                        process=process,
+                        n_final=n_final,
+                        process_key=family.key,
+                        measurement=_measurement(
+                            ExecutionMode.MADGRAPH,
+                            ModelKey.UFO_SM,
+                            Accuracy.FULL,
+                        ),
+                        workload=Workload.CONTRACTED,
+                    )
+                )
+        return tuple(cells)
+
+    def scalar_cells(self) -> tuple[CellSpec, ...]:
+        return tuple(
+            CellSpec(
+                dataset_id=dataset.dataset_id,
+                process=dataset.process(n_final),
+                n_final=n_final,
+                process_key=dataset.dataset_id,
+                measurement=dataset.measurement,
+                workload=Workload.CONTRACTED,
+            )
+            for dataset in self.scalar_datasets
+            for n_final in dataset.multiplicities
+        )
+
+    def z_cells(self) -> tuple[CellSpec, ...]:
+        cells: list[CellSpec] = []
+        for model in (ModelKey.BUILTIN_SM, ModelKey.UFO_SM):
+            for n_final in range(1, 10):
+                process = PROCESS_FAMILIES[0].process(n_final)
+                assert process is not None
+                for variant in self.z_variants:
+                    if variant.execution_mode is ExecutionMode.AMPLICOL:
+                        continue
+                    measurement = MeasurementSpec(
+                        variant.execution_mode,
+                        model,
+                        Accuracy.LC,
+                        variant.backend,
+                        variant.jit_optimization_level,
+                    )
+                    for workload in (
+                        Workload.SELECTED_FLOW,
+                        Workload.ALL_FLOW,
+                    ):
+                        cells.append(
+                            CellSpec(
+                                dataset_id=z_dataset_id(model),
+                                process=process,
+                                n_final=n_final,
+                                process_key="dd_z_jets",
+                                measurement=measurement,
+                                workload=workload,
+                                variant=variant.key,
+                            )
+                        )
+        return tuple(cells)
+
+    def measurement_cells(self) -> tuple[CellSpec, ...]:
+        cached = self._measurement_cells_cache
+        if cached is None:
+            cached = (
+                *self.reference_cells(),
+                *self.matrix_cells(),
+                *self.scalar_cells(),
+                *self.z_cells(),
+            )
+            object.__setattr__(self, "_measurement_cells_cache", cached)
+        return cached
+
+    def cell(self, cell_id: str) -> CellSpec:
+        matches = [
+            cell for cell in self.measurement_cells() if cell.cell_id == cell_id
+        ]
+        if len(matches) != 1:
+            qualifier = "unknown" if not matches else "ambiguous"
+            raise KeyError(f"{qualifier} report cell {cell_id!r}")
+        return matches[0]
+
+    def equivalent_cells(self, cell: CellSpec) -> tuple[CellSpec, ...]:
+        """Return artifact owners whose generated artifact this cell may reuse."""
+
+        if cell.measurement.execution_mode in {
+            ExecutionMode.AMPLICOL,
+            ExecutionMode.MADGRAPH,
+        }:
+            return ()
+        directional_otf_artifact = (
+            cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+            and cell.measurement.accuracy is Accuracy.LC
+            and cell.workload in {Workload.SELECTED_FLOW, Workload.ALL_FLOW}
+        )
+        if directional_otf_artifact and cell.workload is Workload.SELECTED_FLOW:
+            return ()
+
+        def identity(candidate: CellSpec) -> tuple[object, ...]:
+            return (
+                candidate.process,
+                candidate.n_final,
+                candidate.process_key,
+                candidate.measurement,
+                None if directional_otf_artifact else candidate.workload,
+            )
+
+        expected = identity(cell)
+        return tuple(
+            sorted(
+                (
+                    candidate
+                    for candidate in self.measurement_cells()
+                    if candidate.cell_id != cell.cell_id
+                    and (
+                        not directional_otf_artifact
+                        or (
+                            candidate.workload is Workload.SELECTED_FLOW
+                            and candidate.dataset_id == cell.dataset_id
+                            and candidate.variant == cell.variant
+                        )
+                    )
+                    and identity(candidate) == expected
+                ),
+                key=lambda candidate: candidate.cell_id,
+            )
+        )
+
+    def baseline_cell(self, cell: CellSpec) -> CellSpec | None:
+        """Return the display baseline for ``cell``.
+
+        This retains the original-AmpliCol row even when the historical
+        implementation cannot evaluate the process.  Use
+        :meth:`validation_baseline_cell` for measurement dependencies.
+        """
+
+        if (
+            cell.measurement.execution_mode
+            in {ExecutionMode.AMPLICOL, ExecutionMode.MADGRAPH}
+            or cell.dataset_id in {
+                dataset.dataset_id for dataset in self.scalar_datasets
+            }
+        ):
+            return None
+        if cell.dataset_id.startswith("z_"):
+            baseline_mode = ExecutionMode.AMPLICOL
+            dataset_id = f"reference_amplicol_{cell.measurement.accuracy.value}"
+        else:
+            dataset = self.dataset(cell.dataset_id)
+            baseline_mode = dataset.baseline.execution_mode
+            if baseline_mode is ExecutionMode.AMPLICOL:
+                dataset_id = f"reference_amplicol_{cell.measurement.accuracy.value}"
+            elif baseline_mode is ExecutionMode.MADGRAPH:
+                dataset_id = "reference_madgraph_full"
+            else:
+                dataset_id = (
+                    "matrix_recurrence_builtin_sm_"
+                    f"{cell.measurement.accuracy.value}"
+                )
+        return next(
+            candidate
+            for candidate in self.measurement_cells()
+            if candidate.dataset_id == dataset_id
+            and candidate.process_key == cell.process_key
+            and candidate.n_final == cell.n_final
+            and candidate.workload is cell.workload
+            and candidate.measurement.execution_mode is baseline_mode
+        )
+
+    def legacy_reference_available(self, cell: CellSpec) -> bool:
+        """Whether original AmpliCol can evaluate ``cell``'s concrete process."""
+
+        return (
+            open_quark_line_count(cell.process)
+            <= LEGACY_AMPLICOL_MAX_OPEN_QUARK_LINES
+        )
+
+    def static_na_reason(self, cell: CellSpec) -> str | None:
+        """Return the catalog-authenticated reason ``cell`` is not measurable.
+
+        Static N/A cells remain declared catalog rows so publication layout and
+        descriptor identities stay stable.  They are excluded from campaign
+        planning and authenticated-current completeness because the historical
+        oracle cannot represent the concrete process at all.
+        """
+
+        if cell.dataset_id.startswith("matrix_"):
+            dataset = self.dataset(cell.dataset_id)
+            if dataset.static_na_reason_code is not None:
+                return dataset.static_na_reason_code
+        if cell.dataset_id.startswith("z_") and cell.variant is not None:
+            variant = next(
+                (
+                    candidate
+                    for candidate in self.z_variants
+                    if candidate.key == cell.variant
+                ),
+                None,
+            )
+            if (
+                variant is not None
+                and variant.maximum_generation_n_final is not None
+                and cell.n_final > variant.maximum_generation_n_final
+            ):
+                return variant.static_na_reason_code
+        if (
+            cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+            and not self.legacy_reference_available(cell)
+        ):
+            return STATIC_NA_ORIGINAL_AMPLICOL_OPEN_QUARK_LINE_LIMIT
+        return None
+
+    def static_na_description(self, cell: CellSpec) -> str | None:
+        """Return a stable human explanation for a catalog static N/A cell."""
+
+        reason = self.static_na_reason(cell)
+        if reason == STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6:
+            return STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6_DESCRIPTION
+        return reason
+
+    def validation_baseline_cell(self, cell: CellSpec) -> CellSpec | None:
+        """Return the executable numerical baseline for ``cell``.
+
+        Original AmpliCol remains visible in the report for processes beyond
+        its three-open-line scope, but it must not censor pyAmpliCol's
+        otherwise model-generic recurrence measurements.
+        """
+
+        if (
+            cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+            and cell.dataset_id.startswith("z_")
+        ):
+            return next(
+                candidate
+                for candidate in self.measurement_cells()
+                if candidate.dataset_id == cell.dataset_id
+                and candidate.process_key == cell.process_key
+                and candidate.n_final == cell.n_final
+                and candidate.workload is cell.workload
+                and candidate.variant == "recurrence_jit_o2"
+            )
+        if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY and (
+            self.dataset(cell.dataset_id).baseline.execution_mode
+            is not ExecutionMode.MADGRAPH
+        ):
+            return next(
+                candidate
+                for candidate in self.measurement_cells()
+                if candidate.dataset_id
+                == (
+                    "matrix_recurrence_builtin_sm_"
+                    f"{cell.measurement.accuracy.value}"
+                )
+                and candidate.process_key == cell.process_key
+                and candidate.n_final == cell.n_final
+                and candidate.workload is cell.workload
+            )
+        baseline = self.baseline_cell(cell)
+        if (
+            baseline is not None
+            and baseline.measurement.execution_mode is ExecutionMode.MADGRAPH
+        ):
+            # MadGraph is consumed once through the strict direct edge.
+            return None
+        if (
+            baseline is not None
+            and baseline.measurement.execution_mode is ExecutionMode.AMPLICOL
+            and not self.legacy_reference_available(cell)
+        ):
+            return None
+        return baseline
+
+
+REPORT_CATALOG = ReportCatalog(
+    MODELS,
+    PROCESS_FAMILIES,
+    MATRIX_DATASETS,
+    MADGRAPH_FULL_COMPARISON_VIEWS,
+    SCALAR_DATASETS,
+    Z_VARIANTS,
+)
+
+__all__ = [
+    "BUILTIN_SM",
+    "MADGRAPH_FULL_COMPARISON_VIEWS",
+    "MATRIX_DATASETS",
+    "MODELS",
+    "PROCESS_FAMILIES",
+    "REPORT_CATALOG",
+    "SCALAR_CONTACT",
+    "SCALAR_DATASETS",
+    "SCALAR_GRAVITY",
+    "STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6",
+    "STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6_DESCRIPTION",
+    "STATIC_NA_ORIGINAL_AMPLICOL_OPEN_QUARK_LINE_LIMIT",
+    "UFO_SM",
+    "Z_VARIANTS",
+    "ReportCatalog",
+    "matrix_multiplicities",
+    "z_dataset_id",
+]
diff --git a/pyamplicol/tools/performance_report/cli.py b/pyamplicol/tools/performance_report/cli.py
new file mode 100644
index 0000000000..64b3add7f4
--- /dev/null
+++ b/pyamplicol/tools/performance_report/cli.py
@@ -0,0 +1,1609 @@
+# SPDX-License-Identifier: 0BSD
+"""Command-line entry point for the three-mode performance report."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+from .artifacts import ArtifactStoreError
+from .boundary import (
+    authenticate_current_delta,
+    load_cell_boundary,
+    snapshot_cell_boundary,
+)
+from .cache import validate_measurement
+from .campaign_policy import (
+    MACBOOK_M3_POLICY_NAME,
+    MACBOOK_M3_PROFILE,
+    MACBOOK_M3_Z_TABLE_F_POLICY_NAME,
+    STRICT_POLICY,
+    STRICT_POLICY_NAME,
+    X86_EPYC_POLICY_NAME,
+    PolicyMeasurementState,
+    validate_policy_measurement,
+)
+from .campaign_policy import (
+    campaign_policy as resolve_campaign_policy,
+)
+from .catalog import REPORT_CATALOG
+from .measurement_lineage import (
+    CLASS_C_HZZ_IMPACT,
+    CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+    MeasurementLineageError,
+    audit_measurement_lineage,
+    class_c_pending_path,
+    finalize_class_c_bridge,
+    load_and_audit_measurement_lineage,
+    load_measurement_lineage,
+    prepare_class_c_bridge,
+)
+from .models import (
+    Accuracy,
+    ArtifactPolicy,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from .prepared import ensure_report_prepared_model
+from .publisher import (
+    DEFAULT_EXPECTED_PAGE_COUNT,
+    DEFAULT_PDF_TIMEOUT_SECONDS,
+    DEFAULT_PUBLICATION_INTERVAL_SECONDS,
+    _report_source_copy_ignore,
+    run_publisher,
+    validate_published_snapshot,
+)
+from .runner import DEFAULT_TARGET_RUNTIME_SECONDS
+from .scheduler import (
+    CampaignScheduler,
+    CampaignSettings,
+    CellSelection,
+    plan_campaign,
+    select_cells,
+    validate_campaign_plan,
+)
+from .service import (
+    CANONICAL_REPORT_ENTRYPOINT,
+    ReportPaths,
+    ReportService,
+    validate_profile_name,
+)
+from .source_identity import require_eligible_report_source
+from .standalone_build import StandaloneBuildError, validate_latex_log
+from .study_contract import (
+    StudyContractError,
+    audit_z_table_f_policy_projection,
+    load_z_table_f_study_contract,
+    require_z_table_f_explicit_cell,
+    z_table_f_worker_harness_identity,
+)
+from .worker import _JsonlProgressSink, write_cell_result
+from .worker_harness import (
+    LEGACY_ADAPTER,
+    POLICY_ENTRYPOINT,
+    worker_harness_identity,
+)
+from .workspace import (
+    ReportWorkspaceError,
+    export_profile,
+    initialize_profile,
+    load_profile_campaign_policy,
+    refresh_profile_environment,
+    require_active_profile_environment,
+)
+
+_PINNED_EPYC_ORPHAN_CELL_ID = "reference-amplicol-lc-n8-gg-gluons-selected-flow"
+_PINNED_EPYC_ORPHAN_ATTEMPT_ID = "83e5c9c7-dbf6-4d61-b724-f4580df2cfa3"
+_PINNED_EPYC_ORPHAN_WORKER_SHA256 = (
+    "5f3a42f9e3d034efedd8b670e7acbf2b54a427449106dbabc29050f3d93afbe6"
+)
+_PINNED_EPYC_ORPHAN_RESOURCES = {
+    "monitor": "external-cell-supervisor",
+    "peak_rss_gib": None,
+}
+
+
+def _is_pinned_epyc_orphan_without_rss(
+    *,
+    profile: str,
+    cell_id: str,
+    attempt_id: str,
+    worker_result_sha256: str,
+    result: Mapping[str, object],
+) -> bool:
+    """Match the sole authenticated legacy worker result lacking RSS."""
+
+    resources = result.get("resources")
+    return (
+        profile == "x86_EPYC"
+        and cell_id == _PINNED_EPYC_ORPHAN_CELL_ID
+        and attempt_id == _PINNED_EPYC_ORPHAN_ATTEMPT_ID
+        and worker_result_sha256 == _PINNED_EPYC_ORPHAN_WORKER_SHA256
+        and isinstance(resources, Mapping)
+        and dict(resources) == _PINNED_EPYC_ORPHAN_RESOURCES
+    )
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parents[2]
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _authenticated_worker_harness(
+    args: argparse.Namespace,
+    repo_root: Path,
+) -> dict[str, object] | None:
+    """Recheck both checkouts before an internal split worker can run."""
+
+    names = (
+        "measurement_source_root",
+        "expected_measurement_source_revision",
+        "expected_measurement_source_tree",
+        "expected_policy_wrapper_revision",
+        "expected_policy_wrapper_tree",
+        "expected_policy_entrypoint_sha256",
+        "expected_legacy_adapter_sha256",
+        "study_contract_sha256",
+    )
+    values = {name: getattr(args, name) for name in names}
+    if all(value is None for value in values.values()):
+        return None
+    if any(value is None for value in values.values()):
+        raise ValueError(
+            "split worker wrapper/source options must be specified together"
+        )
+    if args.command not in {"_prepare", "_worker"}:
+        raise ValueError(
+            "split worker wrapper/source options are restricted to workers"
+        )
+    measured_root = (
+        Path(values["measurement_source_root"]).expanduser().resolve(strict=True)
+    )
+    if measured_root != repo_root.resolve(strict=True):
+        raise ValueError("worker --repo-root must equal --measurement-source-root")
+    measured = require_eligible_report_source(measured_root)
+    if (
+        measured.revision != values["expected_measurement_source_revision"]
+        or measured.tree != values["expected_measurement_source_tree"]
+    ):
+        raise ValueError(
+            "worker measured-source identity differs from its authorization"
+        )
+    wrapper_root = _repo_root().resolve(strict=True)
+    wrapper = require_eligible_report_source(wrapper_root)
+    if (
+        wrapper.revision != values["expected_policy_wrapper_revision"]
+        or wrapper.tree != values["expected_policy_wrapper_tree"]
+    ):
+        raise ValueError(
+            "worker policy-wrapper identity differs from its authorization"
+        )
+    entrypoint_sha256 = _sha256_file(wrapper_root / POLICY_ENTRYPOINT)
+    legacy_adapter_sha256 = _sha256_file(wrapper_root / LEGACY_ADAPTER)
+    if (
+        entrypoint_sha256 != values["expected_policy_entrypoint_sha256"]
+        or legacy_adapter_sha256 != values["expected_legacy_adapter_sha256"]
+    ):
+        raise ValueError(
+            "worker policy-wrapper file identity differs from its authorization"
+        )
+    return worker_harness_identity(
+        study_contract_sha256=str(values["study_contract_sha256"]),
+        policy_wrapper_revision=wrapper.revision,
+        policy_wrapper_tree=wrapper.tree,
+        policy_entrypoint_sha256=entrypoint_sha256,
+        legacy_adapter_sha256=legacy_adapter_sha256,
+        measured_source_revision=measured.revision,
+        measured_source_tree=measured.tree,
+    )
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Build and populate the pyAmpliCol performance report.",
+    )
+    parser.add_argument(
+        "--repo-root",
+        type=Path,
+        default=_repo_root(),
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--report-profile",
+        type=validate_profile_name,
+        help=(
+            "use docs/performance_reports/PROFILE with isolated evaluator "
+            "artifacts and coordination state"
+        ),
+    )
+    parser.add_argument("--docs-dir", type=Path, help=argparse.SUPPRESS)
+    parser.add_argument("--artifact-root", type=Path, help=argparse.SUPPRESS)
+    parser.add_argument("--coordination-root", type=Path, help=argparse.SUPPRESS)
+    parser.add_argument(
+        "--class-c-ancestor-runtime-root",
+        type=Path,
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--measurement-source-root",
+        type=Path,
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--expected-measurement-source-revision",
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--expected-measurement-source-tree",
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--expected-policy-wrapper-revision",
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--expected-policy-wrapper-tree",
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--expected-policy-entrypoint-sha256",
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--expected-legacy-adapter-sha256",
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--study-contract-sha256",
+        help=argparse.SUPPRESS,
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    for command, help_text in (
+        ("validate", "validate canonical caches and rendered tables"),
+        ("audit", "verify exact cache coverage and checked-in table rendering"),
+        ("reset", "reset all report measurements to N/A"),
+        ("render", "merge immutable results and render tables"),
+        ("recover", "recover immutable worker results and render tables"),
+    ):
+        item = subparsers.add_parser(command, help=help_text)
+        if command in {"reset", "render", "recover"}:
+            item.add_argument(
+                "--compile",
+                action="store_true",
+                help="compile pyAmpliCol.pdf after publishing tables",
+            )
+
+    study_audit = subparsers.add_parser(
+        "audit-z-table-study",
+        help=argparse.SUPPRESS,
+    )
+    study_audit.add_argument("--study-contract", type=Path, required=True)
+    study_audit.add_argument("--maximum-n", type=int, required=True)
+
+    publish_snapshot = subparsers.add_parser(
+        "publish-snapshot",
+        help="copy, validate, render, and compile one current-cache snapshot",
+    )
+    publish_snapshot.add_argument("--watch", action="store_true")
+    publish_snapshot.add_argument(
+        "--interval-seconds",
+        type=float,
+        default=DEFAULT_PUBLICATION_INTERVAL_SECONDS,
+    )
+    publish_snapshot.add_argument(
+        "--pdf-timeout-seconds",
+        type=float,
+        default=DEFAULT_PDF_TIMEOUT_SECONDS,
+    )
+    publish_snapshot.add_argument(
+        "--expected-page-count",
+        type=int,
+        default=DEFAULT_EXPECTED_PAGE_COUNT,
+    )
+    subparsers.add_parser(
+        "validate-snapshot",
+        help="validate the published cache/table/PDF snapshot identities",
+    )
+    snapshot_boundary = subparsers.add_parser(
+        "snapshot-cell-boundary",
+        help="snapshot one authoritative current and immutable-attempt inventory",
+    )
+    snapshot_boundary.add_argument("--cell-id", required=True)
+    accept_boundary = subparsers.add_parser(
+        "accept-cell-boundary",
+        help="authenticate a new current without consulting report caches",
+    )
+    accept_boundary.add_argument("--cell-id", required=True)
+    accept_boundary.add_argument("--expected-attempt-id", required=True)
+    accept_boundary.add_argument(
+        "--before-snapshot",
+        type=Path,
+        required=True,
+    )
+
+    initialize = subparsers.add_parser(
+        "init-profile",
+        help="create an isolated architecture-specific report workspace",
+    )
+    initialize.add_argument("profile", type=validate_profile_name)
+    initialize.add_argument(
+        "--source-profile",
+        type=validate_profile_name,
+        help="copy publication inputs from another report profile instead of docs/",
+    )
+    initialize.add_argument(
+        "--reset-measurements",
+        action="store_true",
+        help="replace copied measurements with canonical N/A caches and tables",
+    )
+    initialize.add_argument(
+        "--measurement-policy",
+        choices=(
+            STRICT_POLICY_NAME,
+            MACBOOK_M3_POLICY_NAME,
+            X86_EPYC_POLICY_NAME,
+        ),
+        help=(
+            "bind a canonical completion/resource policy; defaults to the "
+            "matching architecture policy for macbook_M3 or x86_EPYC and "
+            "strict completion for every other profile"
+        ),
+    )
+
+    refresh_environment = subparsers.add_parser(
+        "refresh-profile-environment",
+        help="authenticate and record the exact installed measurement runtime",
+    )
+    refresh_environment.add_argument("--expected-source-revision", required=True)
+
+    prepare_bridge = subparsers.add_parser(
+        "prepare-class-c-bridge",
+        help="snapshot an exact frozen campaign before one bounded source correction",
+    )
+    prepare_bridge.add_argument("--ancestor-revision", required=True)
+    prepare_bridge.add_argument("--descendant-revision", required=True)
+    prepare_bridge.add_argument(
+        "--impact",
+        choices=(
+            CLASS_C_HZZ_IMPACT,
+            CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+        ),
+        required=True,
+    )
+
+    finalize_bridge = subparsers.add_parser(
+        "finalize-class-c-bridge",
+        help="authenticate the corrected runtime and publish its source lineage",
+    )
+    finalize_bridge.add_argument("--ancestor-revision", required=True)
+    finalize_bridge.add_argument("--descendant-revision", required=True)
+
+    audit_bridge = subparsers.add_parser(
+        "audit-source-bridge",
+        help="audit one finalized mixed-source profile without changing it",
+    )
+    audit_bridge.add_argument("--expected-active-source-revision", required=True)
+
+    seal_orphan = subparsers.add_parser(
+        "seal-existing-worker-result",
+        help="authenticate and seal one completed controller-orphaned worker result",
+    )
+    seal_orphan.add_argument("--cell-id", required=True)
+    seal_orphan.add_argument("--attempt-id", required=True)
+    seal_orphan.add_argument("--worker-result-sha256", required=True)
+    seal_orphan.add_argument(
+        "--artifact-policy",
+        choices=tuple(policy.value for policy in ArtifactPolicy),
+        required=True,
+    )
+    seal_orphan.add_argument("--expected-source-revision", required=True)
+
+    export = subparsers.add_parser(
+        "export-profile",
+        help="copy a tracked report workspace without evaluator artifacts",
+    )
+    export.add_argument("profile", type=validate_profile_name)
+    export.add_argument("destination", type=Path)
+    export.add_argument(
+        "--include-pdf",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+    )
+
+    final_audit = subparsers.add_parser(
+        "final-audit",
+        help=(
+            "run the measured-SHA/runtime and report-only publication "
+            "numerical, artifact, and PDF gate"
+        ),
+    )
+    final_audit.add_argument("--expected-source-revision", required=True)
+    final_audit.add_argument(
+        "--publication-revision",
+        help="require the clean publication checkout to equal this full Git SHA",
+    )
+    final_audit.add_argument("--max-n-final", type=int, default=9)
+    final_audit.add_argument("--expected-cell-count", type=int, default=2198)
+    final_audit.add_argument(
+        "--structural-only",
+        action="store_true",
+        help="authenticate records and artifacts without numerical replay",
+    )
+
+    worker = subparsers.add_parser("_worker", help=argparse.SUPPRESS)
+    worker.add_argument("--cell-id", required=True)
+    worker.add_argument("--attempt-root", type=Path, required=True)
+    worker.add_argument("--result-json", type=Path, required=True)
+    worker.add_argument("--log-path", type=Path)
+    worker.add_argument("--baseline-json", type=Path)
+    worker.add_argument(
+        "--expected-authority-cell-id",
+        action="append",
+        default=[],
+        help=argparse.SUPPRESS,
+    )
+    worker.add_argument(
+        "--selected-authority-cell-id",
+        help=argparse.SUPPRESS,
+    )
+    worker.add_argument(
+        "--peer-json",
+        action="append",
+        nargs=2,
+        metavar=("CELL_ID", "PATH"),
+        default=[],
+        help=argparse.SUPPRESS,
+    )
+    worker.add_argument("--prepared-model", type=Path)
+    worker.add_argument("--reused-measurement-json", type=Path)
+    worker.add_argument("--legacy-repository", type=Path, help=argparse.SUPPRESS)
+    worker.add_argument(
+        "--legacy-source-repository",
+        type=Path,
+        help=argparse.SUPPRESS,
+    )
+    worker.add_argument("--legacy-workspace", type=Path, help=argparse.SUPPRESS)
+    worker.add_argument(
+        "--legacy-copy-source",
+        action="store_true",
+        help=argparse.SUPPRESS,
+    )
+    worker.add_argument("--legacy-source-revision", help=argparse.SUPPRESS)
+    worker.add_argument("--madgraph", type=Path, help=argparse.SUPPRESS)
+    worker.add_argument(
+        "--target-runtime",
+        type=float,
+        default=DEFAULT_TARGET_RUNTIME_SECONDS,
+    )
+    worker.add_argument("--batch-size", type=int, default=128)
+    worker.add_argument("--cell-cores", type=int, default=1)
+    worker.add_argument(
+        "--amplicol-build-jobs",
+        type=int,
+        default=1,
+        help=argparse.SUPPRESS,
+    )
+    worker.add_argument("--memory-limit-bytes", type=int, help=argparse.SUPPRESS)
+    worker.add_argument("--warmup-runs", type=int, default=2)
+    worker.add_argument("--minimum-samples", type=int, default=5)
+    worker.add_argument("--progress-jsonl", type=Path)
+    worker.add_argument("--worker-wall-limit", type=float, help=argparse.SUPPRESS)
+    worker.add_argument(
+        "--profiling-time-limit",
+        type=float,
+        help=argparse.SUPPRESS,
+    )
+    worker.add_argument(
+        "--validation-time-limit",
+        type=float,
+        help=argparse.SUPPRESS,
+    )
+    worker.add_argument("--generation-lock-path", type=Path, help=argparse.SUPPRESS)
+    worker.add_argument("--manual-source-revision", help=argparse.SUPPRESS)
+    worker.add_argument("--manual-source-tree", help=argparse.SUPPRESS)
+    worker.add_argument("--phase-state-path", type=Path, help=argparse.SUPPRESS)
+    worker.add_argument("--phase-state-run-id", help=argparse.SUPPRESS)
+    worker.add_argument(
+        "--phase-state-authentication-key",
+        help=argparse.SUPPRESS,
+    )
+
+    prepare = subparsers.add_parser("_prepare", help=argparse.SUPPRESS)
+    prepare.add_argument(
+        "--model",
+        required=True,
+        choices=(ModelKey.BUILTIN_SM.value, ModelKey.UFO_SM.value),
+    )
+    prepare.add_argument("--result-json", type=Path, required=True)
+    prepare.add_argument("--progress-jsonl", type=Path)
+    prepare.add_argument("--cell-cores", type=int, default=1)
+    prepare.add_argument("--producer-revision", help=argparse.SUPPRESS)
+
+    populate = subparsers.add_parser(
+        "populate",
+        help="run selected cells through isolated direct-API workers",
+    )
+    populate.add_argument("--dataset", action="append", default=[])
+    populate.add_argument(
+        "--mode",
+        action="append",
+        choices=tuple(mode.value for mode in ExecutionMode),
+        default=[],
+    )
+    populate.add_argument(
+        "--model",
+        action="append",
+        choices=tuple(model.value for model in ModelKey),
+        default=[],
+    )
+    populate.add_argument(
+        "--accuracy",
+        action="append",
+        choices=tuple(accuracy.value for accuracy in Accuracy),
+        default=[],
+    )
+    populate.add_argument("--process-key", action="append", default=[])
+    populate.add_argument("--process", action="append", default=[])
+    populate.add_argument("--n-final", action="append", default=[])
+    populate.add_argument(
+        "--variant",
+        action="append",
+        default=[],
+        help=(
+            "filter named Z implementations; rows without a variant dimension "
+            "remain eligible"
+        ),
+    )
+    populate.add_argument(
+        "--workload",
+        choices=("selected-flow", "all-flow", "both", "contracted"),
+    )
+    populate.add_argument("--cell-id", action="append", default=[])
+    populate.add_argument(
+        "--exclude-cell-id",
+        action="append",
+        default=[],
+        help=(
+            "omit a held cell and any selected cell whose unresolved "
+            "dependency closure reaches it"
+        ),
+    )
+    populate.add_argument("--missing-only", action="store_true")
+    populate.add_argument("--rerun", action="store_true")
+    populate.add_argument(
+        "--artifact-policy",
+        choices=tuple(policy.value for policy in ArtifactPolicy),
+        default=ArtifactPolicy.REGENERATE.value,
+    )
+    populate.add_argument("--workers", type=int, default=1)
+    populate.add_argument("--cell-cores", type=int, default=1)
+    populate.add_argument("--amplicol-build-jobs", type=int, default=1)
+    populate.add_argument(
+        "--target-runtime",
+        type=float,
+        default=DEFAULT_TARGET_RUNTIME_SECONDS,
+    )
+    populate.add_argument("--batch-size", type=int, default=128)
+    populate.add_argument("--timeout-seconds", type=float)
+    populate.add_argument(
+        "--generation-time-limit-seconds",
+        type=float,
+        help="limit only the authenticated Generator.generate phase",
+    )
+    populate.add_argument("--max-ram-gib", type=float)
+    populate.add_argument(
+        "--max-ram-gb",
+        type=float,
+        help="decimal GB ceiling for each worker process tree",
+    )
+    populate.add_argument("--campaign-max-ram-gib", type=float)
+    populate.add_argument(
+        "--campaign-max-ram-gb",
+        type=float,
+        help="decimal GB ceiling for all concurrent worker process trees",
+    )
+    populate.add_argument(
+        "--limit-gib",
+        type=float,
+        help="compatibility alias for --campaign-max-ram-gib",
+    )
+    populate.add_argument("--allow-symbolica-parallel", action="store_true")
+    populate.add_argument(
+        "--fast-lineage",
+        action="store_true",
+        help=argparse.SUPPRESS,
+    )
+    populate.add_argument("--dry-run", action="store_true")
+    populate.add_argument(
+        "--refresh-pdf",
+        choices=("never", "end"),
+        default="never",
+    )
+    populate.add_argument(
+        "--study-policy",
+        choices=(MACBOOK_M3_Z_TABLE_F_POLICY_NAME,),
+        help=argparse.SUPPRESS,
+    )
+    populate.add_argument(
+        "--study-contract",
+        type=Path,
+        help=argparse.SUPPRESS,
+    )
+    populate.add_argument(
+        "--reuse-cross-source-comparison-dependencies", action="store_true"
+    )
+    return parser
+
+
+def _git_commit(root: Path, revision: str) -> str:
+    completed = subprocess.run(
+        ("git", "-C", str(root), "rev-parse", "--verify", f"{revision}^{{commit}}"),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    value = completed.stdout.strip()
+    if (
+        completed.returncode != 0
+        or len(value) != 40
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise MeasurementLineageError(
+            f"cannot resolve Class-C runtime revision {revision!r}"
+        )
+    return value
+
+
+def _class_c_ancestor_runtime_identity(
+    repo_root: Path,
+    runtime_root: Path,
+    *,
+    ancestor_revision: str,
+    descendant_revision: str,
+) -> dict[str, object]:
+    """Authenticate the ancestor package selected by the direct bootstrap."""
+
+    try:
+        root = runtime_root.expanduser().resolve(strict=True)
+        source_package = (root / "src/pyamplicol").resolve(strict=True)
+    except OSError as error:
+        raise MeasurementLineageError(
+            "Class-C ancestor runtime root is unavailable"
+        ) from error
+    if root == repo_root.resolve(strict=False) or not source_package.is_dir():
+        raise MeasurementLineageError(
+            "Class-C ancestor runtime must be a separate source checkout"
+        )
+    ancestor = _git_commit(root, ancestor_revision)
+    descendant = _git_commit(repo_root, descendant_revision)
+    if _git_commit(root, "HEAD") != ancestor:
+        raise MeasurementLineageError(
+            "Class-C ancestor runtime checkout is not at the requested ancestor"
+        )
+    if _git_commit(repo_root, "HEAD") != descendant:
+        raise MeasurementLineageError(
+            "Class-C controller checkout is not at the requested descendant"
+        )
+    tracked = subprocess.run(
+        (
+            "git",
+            "-C",
+            str(root),
+            "status",
+            "--porcelain=v1",
+            "--untracked-files=no",
+        ),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if tracked.returncode != 0 or tracked.stdout:
+        raise MeasurementLineageError(
+            "Class-C ancestor runtime has tracked source modifications"
+        )
+
+    import pyamplicol
+
+    try:
+        package_origin = Path(str(pyamplicol.__file__)).resolve(strict=True)
+    except OSError as error:
+        raise MeasurementLineageError(
+            "loaded Class-C ancestor package origin is unavailable"
+        ) from error
+    if package_origin.parent != source_package:
+        raise MeasurementLineageError(
+            "loaded pyamplicol package does not originate in the Class-C "
+            "ancestor runtime checkout"
+        )
+    from .runtime_evidence import established_preimport_runtime_identity
+
+    preimport = established_preimport_runtime_identity()
+    tree = preimport.get("python_package_tree")
+    native = preimport.get("native_extension")
+    if (
+        not isinstance(tree, Mapping)
+        or tree.get("roots") != [str(source_package)]
+        or not isinstance(native, Mapping)
+    ):
+        raise MeasurementLineageError(
+            "Class-C ancestor package was not exclusively preauthenticated"
+        )
+    native_path = native.get("path")
+    if (
+        not isinstance(native_path, str)
+        or Path(native_path).resolve(strict=False).parent != source_package
+    ):
+        raise MeasurementLineageError(
+            "Class-C ancestor native extension was not preauthenticated"
+        )
+    return {
+        "revision": ancestor,
+        "root": str(root),
+        "package_root": str(source_package),
+        "python_package_tree_sha256": tree.get("sha256"),
+        "native_extension_sha256": native.get("sha256"),
+    }
+
+
+def _multiplicities(values: Sequence[str]) -> frozenset[int]:
+    selected: set[int] = set()
+    for value in values:
+        for item in value.split(","):
+            text = item.strip()
+            if not text:
+                continue
+            if ".." in text:
+                start_text, stop_text = text.split("..", 1)
+                start, stop = int(start_text), int(stop_text)
+                if start > stop:
+                    raise ValueError("n-final range start must not exceed its end")
+                selected.update(range(start, stop + 1))
+            else:
+                selected.add(int(text))
+    if any(value < 1 for value in selected):
+        raise ValueError("n-final values must be positive")
+    return frozenset(selected)
+
+
+def _workloads(value: str | None) -> frozenset[Workload]:
+    if value is None:
+        return frozenset()
+    if value == "both":
+        return frozenset({Workload.SELECTED_FLOW, Workload.ALL_FLOW})
+    return frozenset({Workload(value)})
+
+
+def _selection(args: argparse.Namespace) -> CellSelection:
+    return CellSelection(
+        datasets=frozenset(args.dataset),
+        modes=frozenset(ExecutionMode(value) for value in args.mode),
+        models=frozenset(ModelKey(value) for value in args.model),
+        accuracies=frozenset(Accuracy(value) for value in args.accuracy),
+        process_keys=frozenset(args.process_key),
+        processes=frozenset(args.process),
+        multiplicities=_multiplicities(args.n_final),
+        variants=frozenset(args.variant),
+        workloads=_workloads(args.workload),
+        cell_ids=frozenset(args.cell_id),
+    )
+
+
+def _gib_bytes(value: float | None) -> int | None:
+    if value is None:
+        return None
+    if value <= 0.0:
+        raise ValueError("RAM limits must be positive")
+    return int(value * 1024**3)
+
+
+def _gb_bytes(value: float | None) -> int | None:
+    if value is None:
+        return None
+    if value <= 0.0:
+        raise ValueError("RAM limits must be positive")
+    return int(value * 1_000_000_000)
+
+
+def _compile_pdf(service: ReportService) -> Path:
+    latexmk = shutil.which("latexmk")
+    if latexmk is None:
+        raise FileNotFoundError("latexmk is required for --compile")
+    environment = os.environ.copy()
+    environment.update({"LANG": "C", "LC_ALL": "C", "LC_CTYPE": "C"})
+    build_root = service.paths.artifact_root / "pdf-builds"
+    build_root.mkdir(parents=True, exist_ok=True)
+    staging = Path(tempfile.mkdtemp(prefix="report-pdf-", dir=build_root))
+    try:
+        build_docs = staging / "docs"
+        shutil.copytree(
+            service.paths.docs_dir,
+            build_docs,
+            ignore=_report_source_copy_ignore(
+                service.paths.docs_dir,
+                "*.aux",
+                "*.fdb_latexmk",
+                "*.fls",
+                "*.log",
+                "*.out",
+                "*.toc",
+                "pyAmpliCol.pdf",
+                ".coordination",
+            ),
+        )
+        completed = subprocess.run(
+            (
+                latexmk,
+                "-pdf",
+                "-interaction=nonstopmode",
+                "-halt-on-error",
+                "-file-line-error",
+                "pyAmpliCol.tex",
+            ),
+            cwd=build_docs,
+            check=False,
+            capture_output=True,
+            text=True,
+            env=environment,
+        )
+        if completed.returncode != 0:
+            tail = "\n".join(
+                (*completed.stdout.splitlines(), *completed.stderr.splitlines())[-80:]
+            )
+            raise RuntimeError(
+                f"latexmk failed with exit {completed.returncode}:\n{tail}"
+            )
+        latex_log = build_docs / "pyAmpliCol.log"
+        try:
+            log = latex_log.read_text(encoding="utf-8", errors="replace")
+            validate_latex_log(log)
+        except OSError as error:
+            raise RuntimeError(f"cannot read LaTeX log: {error}") from error
+        except StandaloneBuildError as error:
+            raise RuntimeError(str(error)) from error
+        built_pdf = build_docs / "pyAmpliCol.pdf"
+        if not built_pdf.is_file() or built_pdf.stat().st_size == 0:
+            raise RuntimeError("latexmk did not produce a non-empty PDF")
+        output = service.paths.docs_dir / "pyAmpliCol.pdf"
+        temporary = output.with_name(f".{output.name}.new")
+        shutil.copy2(built_pdf, temporary)
+        temporary.replace(output)
+        return output
+    finally:
+        shutil.rmtree(staging, ignore_errors=True)
+
+
+def _launch_async_publication(
+    service: ReportService,
+    *,
+    entrypoint: Path | None = None,
+) -> Path:
+    """Request a one-shot report publication without waiting for it."""
+
+    entrypoint_candidate = (
+        service.paths.repo_root / CANONICAL_REPORT_ENTRYPOINT
+        if entrypoint is None
+        else entrypoint
+    ).expanduser()
+    if entrypoint_candidate.is_symlink():
+        raise RuntimeError("asynchronous publication entrypoint is unavailable")
+    selected_entrypoint = entrypoint_candidate.resolve(strict=True)
+    if not selected_entrypoint.is_file():
+        raise RuntimeError("asynchronous publication entrypoint is unavailable")
+    log_root = service.paths.artifact_root / "publication-logs"
+    log_root.mkdir(parents=True, exist_ok=True)
+    log_path = log_root / "refresh-pdf-end.log"
+    command = (
+        sys.executable,
+        "-I",
+        "-S",
+        "-B",
+        os.fspath(selected_entrypoint),
+        "--repo-root",
+        os.fspath(service.paths.repo_root),
+        "--docs-dir",
+        os.fspath(service.paths.docs_dir),
+        "--artifact-root",
+        os.fspath(service.paths.artifact_root),
+        "--coordination-root",
+        os.fspath(service.paths.coordination_root),
+        "publish-snapshot",
+    )
+    environment = os.environ.copy()
+    for name in (
+        "PYAMPLICOL_EXACT_PYTHON_REEXEC",
+        "PYAMPLICOL_EXACT_IMPORT_PATHS",
+        "PYTHONPYCACHEPREFIX",
+    ):
+        environment.pop(name, None)
+    with log_path.open("ab") as stream:
+        subprocess.Popen(
+            command,
+            stdin=subprocess.DEVNULL,
+            stdout=stream,
+            stderr=subprocess.STDOUT,
+            env=environment,
+            start_new_session=True,
+            close_fds=True,
+        )
+    return log_path
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _parser()
+    args = parser.parse_args(argv)
+    repo_root = args.repo_root.expanduser().resolve(strict=False)
+    try:
+        worker_harness = _authenticated_worker_harness(args, repo_root)
+    except (OSError, TypeError, ValueError) as error:
+        parser.error(str(error))
+    if (
+        args.class_c_ancestor_runtime_root is not None
+        and args.command != "prepare-class-c-bridge"
+    ):
+        parser.error(
+            "--class-c-ancestor-runtime-root is restricted to prepare-class-c-bridge"
+        )
+    if args.command == "init-profile":
+        output = initialize_profile(
+            repo_root,
+            args.profile,
+            source_profile=args.source_profile,
+            reset_measurements=args.reset_measurements,
+            measurement_policy=args.measurement_policy,
+        )
+        print(output.relative_to(repo_root))
+        return 0
+    if args.command == "export-profile":
+        output = export_profile(
+            repo_root,
+            args.profile,
+            args.destination,
+            include_pdf=args.include_pdf,
+        )
+        print(output)
+        return 0
+
+    service = ReportService(
+        ReportPaths.from_repo(
+            repo_root,
+            profile=args.report_profile,
+            docs_dir=args.docs_dir,
+            artifact_root=args.artifact_root,
+            coordination_root=args.coordination_root,
+        )
+    )
+
+    if args.command == "publish-snapshot":
+        run_publisher(
+            service,
+            watch=args.watch,
+            interval_seconds=args.interval_seconds,
+            expected_page_count=args.expected_page_count,
+            pdf_timeout_seconds=args.pdf_timeout_seconds,
+        )
+        return 0
+    if args.command == "validate-snapshot":
+        print(
+            json.dumps(
+                validate_published_snapshot(service),
+                allow_nan=False,
+                sort_keys=True,
+            )
+        )
+        return 0
+    if args.command == "snapshot-cell-boundary":
+        if args.cell_id not in {
+            cell.cell_id for cell in REPORT_CATALOG.measurement_cells()
+        }:
+            parser.error(f"unknown --cell-id {args.cell_id!r}")
+        print(
+            json.dumps(
+                snapshot_cell_boundary(service.store, args.cell_id),
+                allow_nan=False,
+                sort_keys=True,
+            )
+        )
+        return 0
+    if args.command == "accept-cell-boundary":
+        try:
+            cell = REPORT_CATALOG.cell(args.cell_id)
+        except KeyError:
+            parser.error(f"unknown --cell-id {args.cell_id!r}")
+        accepted = authenticate_current_delta(
+            service.store,
+            cell_id=cell.cell_id,
+            expected_attempt_id=args.expected_attempt_id,
+            before=load_cell_boundary(args.before_snapshot),
+            validate_result=lambda result: validate_measurement(
+                result,
+                expected_cell=cell,
+            ),
+        )
+        print(json.dumps(accepted, allow_nan=False, sort_keys=True))
+        return 0
+    if args.command == "validate":
+        print(json.dumps(service.validate(), sort_keys=True))
+        return 0
+    if args.command == "audit":
+        print(json.dumps(service.audit(), sort_keys=True))
+        return 0
+    if args.command == "audit-z-table-study":
+        try:
+            contract = load_z_table_f_study_contract(
+                args.study_contract,
+                repo_root,
+                Path(__file__).resolve().parents[2],
+                prior_store=service.store,
+            )
+            result = audit_z_table_f_policy_projection(
+                contract,
+                service,
+                maximum_n=args.maximum_n,
+            )
+        except (OSError, TypeError, ValueError) as error:
+            parser.error(str(error))
+        print(json.dumps(result, allow_nan=False, sort_keys=True))
+        return 0
+    if args.command == "refresh-profile-environment":
+        if args.report_profile is None:
+            parser.error("refresh-profile-environment requires --report-profile")
+        environment = refresh_profile_environment(
+            repo_root,
+            args.report_profile,
+            expected_source_revision=args.expected_source_revision,
+        )
+        print(json.dumps(environment, allow_nan=False, sort_keys=True))
+        return 0
+    if args.command == "prepare-class-c-bridge":
+        if args.report_profile is None:
+            parser.error("prepare-class-c-bridge requires --report-profile")
+        ancestor_runtime = (
+            None
+            if args.class_c_ancestor_runtime_root is None
+            else _class_c_ancestor_runtime_identity(
+                repo_root,
+                args.class_c_ancestor_runtime_root,
+                ancestor_revision=args.ancestor_revision,
+                descendant_revision=args.descendant_revision,
+            )
+        )
+        prepared = prepare_class_c_bridge(
+            repo_root,
+            service.paths.docs_dir,
+            service.store,
+            ancestor_revision=args.ancestor_revision,
+            descendant_revision=args.descendant_revision,
+            impact=args.impact,
+        )
+        pending = class_c_pending_path(
+            service.store,
+            ancestor_revision=str(prepared["ancestor_revision"]),
+            descendant_revision=str(prepared["descendant_revision"]),
+        )
+        print(
+            json.dumps(
+                {
+                    "pending_locator": pending.relative_to(
+                        service.paths.artifact_root
+                    ).as_posix(),
+                    "current_snapshot_sha256": prepared["current_snapshot_sha256"],
+                    **(
+                        {}
+                        if ancestor_runtime is None
+                        else {"ancestor_runtime": ancestor_runtime}
+                    ),
+                },
+                sort_keys=True,
+            )
+        )
+        return 0
+    if args.command == "finalize-class-c-bridge":
+        if args.report_profile is None:
+            parser.error("finalize-class-c-bridge requires --report-profile")
+        pending = class_c_pending_path(
+            service.store,
+            ancestor_revision=args.ancestor_revision,
+            descendant_revision=args.descendant_revision,
+        )
+        finalized = finalize_class_c_bridge(
+            repo_root,
+            service.paths.docs_dir,
+            service.store,
+            pending_path=pending,
+            expected_active_source_revision=args.descendant_revision,
+        )
+        print(
+            json.dumps(
+                {
+                    "lineage": (service.paths.docs_dir / "measurement_lineage.json")
+                    .relative_to(repo_root)
+                    .as_posix(),
+                    "descendant_revision": finalized["descendant_revision"],
+                },
+                sort_keys=True,
+            )
+        )
+        return 0
+    if args.command == "audit-source-bridge":
+        if args.report_profile is None:
+            parser.error("audit-source-bridge requires --report-profile")
+        result = audit_measurement_lineage(
+            repo_root,
+            service.paths.docs_dir,
+            service.store,
+            expected_active_source_revision=args.expected_active_source_revision,
+        )
+        print(json.dumps(result, allow_nan=False, sort_keys=True))
+        return 0
+    if args.command == "seal-existing-worker-result":
+        if args.report_profile is None:
+            parser.error("seal-existing-worker-result requires --report-profile")
+        source = require_eligible_report_source(repo_root)
+        if source.revision != args.expected_source_revision:
+            parser.error("active source does not match --expected-source-revision")
+        require_active_profile_environment(
+            repo_root,
+            args.report_profile,
+            expected_source_revision=source.revision,
+        )
+        try:
+            cell = REPORT_CATALOG.cell(args.cell_id)
+        except KeyError:
+            parser.error(f"unknown --cell-id {args.cell_id!r}")
+        policy = load_profile_campaign_policy(
+            repo_root,
+            args.report_profile,
+            expected_source_revision=source.revision,
+        )
+
+        def validate_orphan_result(
+            result: Mapping[str, object],
+            attempt_root: Path,
+        ) -> None:
+            validate_measurement(result, expected_cell=cell)
+            provenance = result.get("provenance")
+            artifact = result.get("artifact")
+            if (
+                result.get("status") != ResultStatus.OK.value
+                or not isinstance(provenance, Mapping)
+                or provenance.get("report_source_revision") != source.revision
+                or provenance.get("report_source_tree") != source.tree
+                or provenance.get("report_measured_source_revision") != source.revision
+                or provenance.get("report_measured_source_tree") != source.tree
+                or not isinstance(artifact, Mapping)
+                or artifact.get("path") != os.fspath(attempt_root / "artifact")
+                or provenance.get("worker_log")
+                != os.fspath(attempt_root / "worker.log")
+                or not (attempt_root / "artifact").is_dir()
+                or (attempt_root / "artifact").is_symlink()
+                or not (attempt_root / "worker.log").is_file()
+                or (attempt_root / "worker.log").is_symlink()
+            ):
+                raise ValueError(
+                    "orphan worker result lacks exact source/artifact/log evidence"
+                )
+            allow_unavailable_resources = _is_pinned_epyc_orphan_without_rss(
+                profile=args.report_profile,
+                cell_id=args.cell_id,
+                attempt_id=args.attempt_id,
+                worker_result_sha256=args.worker_result_sha256,
+                result=result,
+            )
+            state = validate_policy_measurement(
+                policy,
+                args.report_profile,
+                cell,
+                result,
+                expected_source_revision=source.revision,
+                expected_source_tree=source.tree,
+                allow_pinned_orphan_unavailable_resources=(allow_unavailable_resources),
+            )
+            if state is not PolicyMeasurementState.SUCCESS:
+                raise ValueError(
+                    "orphan worker result is not a successful policy measurement"
+                )
+
+        try:
+            record = service.store.seal_existing_worker_result(
+                args.cell_id,
+                args.attempt_id,
+                worker_result_sha256=args.worker_result_sha256,
+                artifact_policy=ArtifactPolicy(args.artifact_policy),
+                validate_result=validate_orphan_result,
+            )
+        except (ValueError, OSError, ArtifactStoreError) as error:
+            parser.error(str(error))
+        print(
+            json.dumps(
+                {
+                    "cell_id": record.cell_id,
+                    "attempt_id": record.attempt_id,
+                    "manifest_sha256": record.manifest_sha256,
+                    "result_sha256": hashlib.sha256(
+                        record.result_path.read_bytes()
+                    ).hexdigest(),
+                    "resource_monitoring": (
+                        "unavailable-pinned-worker-result"
+                        if _is_pinned_epyc_orphan_without_rss(
+                            profile=args.report_profile,
+                            cell_id=args.cell_id,
+                            attempt_id=args.attempt_id,
+                            worker_result_sha256=args.worker_result_sha256,
+                            result=record.result,
+                        )
+                        else "available"
+                    ),
+                },
+                sort_keys=True,
+            )
+        )
+        return 0
+    if args.command == "final-audit":
+        from .final_audit import audit_final_report
+
+        if args.report_profile is None:
+            parser.error("final-audit requires --report-profile")
+        require_active_profile_environment(
+            repo_root,
+            args.report_profile,
+            expected_source_revision=args.expected_source_revision,
+        )
+        result = audit_final_report(
+            repo_root,
+            expected_source_revision=args.expected_source_revision,
+            expected_publication_revision=args.publication_revision,
+            max_n_final=args.max_n_final,
+            expected_cell_count=args.expected_cell_count,
+            replay=not args.structural_only,
+            service=service,
+        )
+        print(json.dumps(result, allow_nan=False, sort_keys=True))
+        return 0 if result["final_gate_complete"] is True else 2
+    if args.command == "populate":
+        active_study_contract: Mapping[str, object] | None = None
+        try:
+            requested = select_cells(_selection(args))
+            if not requested:
+                parser.error("cell filters select no report cells")
+            catalog_ids = {cell.cell_id for cell in REPORT_CATALOG.measurement_cells()}
+            unknown_exclusions = sorted(
+                set(args.exclude_cell_id).difference(catalog_ids)
+            )
+            if unknown_exclusions:
+                parser.error(
+                    "unknown --exclude-cell-id values: " + ", ".join(unknown_exclusions)
+                )
+            if args.max_ram_gib is not None and args.max_ram_gb is not None:
+                parser.error("--max-ram-gib and --max-ram-gb are mutually exclusive")
+            if args.campaign_max_ram_gb is not None and (
+                args.campaign_max_ram_gib is not None or args.limit_gib is not None
+            ):
+                parser.error(
+                    "--campaign-max-ram-gb is mutually exclusive with "
+                    "--campaign-max-ram-gib and --limit-gib"
+                )
+            campaign_limit_gib = (
+                args.campaign_max_ram_gib
+                if args.campaign_max_ram_gib is not None
+                else args.limit_gib
+            )
+            source_identity = require_eligible_report_source(repo_root)
+            expected_revision = source_identity.revision
+            if args.fast_lineage and args.report_profile is None:
+                parser.error("--fast-lineage requires --report-profile")
+            original_amplicol_seed = (
+                None
+                if args.report_profile is None
+                else service._original_amplicol_seed()
+            )
+            if args.report_profile is None:
+                measurement_lineage = None
+            elif args.fast_lineage:
+                measurement_lineage = load_measurement_lineage(
+                    repo_root,
+                    service.paths.docs_dir,
+                    expected_active_revision=expected_revision,
+                    expected_active_tree=source_identity.tree,
+                )
+                if measurement_lineage is None and original_amplicol_seed is None:
+                    raise MeasurementLineageError(
+                        "--fast-lineage requires a finalized measurement lineage "
+                        "or authenticated original-AmpliCol campaign seed"
+                    )
+            else:
+                measurement_lineage = load_and_audit_measurement_lineage(
+                    repo_root,
+                    service.paths.docs_dir,
+                    service.store,
+                    expected_active_source_revision=expected_revision,
+                )
+            policy_profile = args.report_profile
+            if args.study_policy is not None:
+                if args.report_profile is not None:
+                    raise ValueError(
+                        "--study-policy cannot be combined with --report-profile"
+                    )
+                if args.study_contract is None:
+                    raise ValueError("--study-policy requires --study-contract")
+                if (
+                    len(args.cell_id) != 1
+                    or args.dataset
+                    or args.mode
+                    or args.model
+                    or args.accuracy
+                    or args.process_key
+                    or args.process
+                    or args.n_final
+                    or args.variant
+                    or args.workload is not None
+                ):
+                    raise ValueError(
+                        "--study-policy requires exactly one explicit "
+                        "--cell-id and no broad cell selectors"
+                    )
+                active_study_contract = load_z_table_f_study_contract(
+                    args.study_contract,
+                    repo_root,
+                    Path(__file__).resolve().parents[2],
+                    prior_store=service.store,
+                )
+                require_z_table_f_explicit_cell(
+                    active_study_contract,
+                    args.cell_id[0],
+                )
+                campaign_policy = resolve_campaign_policy(args.study_policy)
+                policy_profile = MACBOOK_M3_PROFILE
+            elif args.study_contract is not None:
+                raise ValueError("--study-contract requires --study-policy")
+            elif args.report_profile is None:
+                campaign_policy = STRICT_POLICY
+            else:
+                campaign_policy = load_profile_campaign_policy(
+                    repo_root,
+                    args.report_profile,
+                    expected_source_revision=expected_revision,
+                )
+            settings = CampaignSettings(
+                workers=args.workers,
+                cell_cores=args.cell_cores,
+                amplicol_build_jobs=args.amplicol_build_jobs,
+                target_runtime_seconds=args.target_runtime,
+                batch_size=args.batch_size,
+                timeout_seconds=args.timeout_seconds,
+                generation_time_limit_seconds=args.generation_time_limit_seconds,
+                max_rss_bytes=(
+                    _gb_bytes(args.max_ram_gb)
+                    if args.max_ram_gb is not None
+                    else _gib_bytes(args.max_ram_gib)
+                ),
+                campaign_max_rss_bytes=(
+                    _gb_bytes(args.campaign_max_ram_gb)
+                    if args.campaign_max_ram_gb is not None
+                    else _gib_bytes(campaign_limit_gib)
+                ),
+                artifact_policy=ArtifactPolicy(args.artifact_policy),
+                missing_only=args.missing_only,
+                rerun=args.rerun,
+                allow_symbolica_parallel=args.allow_symbolica_parallel,
+                campaign_policy=campaign_policy,
+                report_profile=policy_profile,
+                study_contract_sha256=(
+                    None
+                    if active_study_contract is None
+                    else str(active_study_contract["sha256"])
+                ),
+                reuse_cross_source_comparison_dependencies=args.reuse_cross_source_comparison_dependencies,
+            )
+        except (ValueError, ReportWorkspaceError, MeasurementLineageError) as error:
+            parser.error(str(error))
+        planned = plan_campaign(
+            requested,
+            store=service.store,
+            settings=settings,
+            expected_revision=expected_revision,
+            expected_tree=source_identity.tree,
+            measurement_lineage=measurement_lineage,
+            original_amplicol_seed=original_amplicol_seed,
+            excluded_cell_ids=frozenset(args.exclude_cell_id),
+            expected_worker_harness=(
+                None
+                if active_study_contract is None
+                else z_table_f_worker_harness_identity(active_study_contract)
+            ),
+        )
+        try:
+            validate_campaign_plan(planned, settings)
+        except StudyContractError as error:
+            parser.error(str(error))
+        if args.dry_run:
+            print(
+                json.dumps(
+                    {
+                        "requested": len(requested),
+                        "scheduled": len(planned),
+                        "source_revision": expected_revision,
+                        "source_tree": source_identity.tree,
+                        "campaign_policy": (settings.campaign_policy.as_manifest()),
+                        "policy_profile": settings.report_profile,
+                        "study_contract_sha256": (
+                            None
+                            if active_study_contract is None
+                            else active_study_contract["sha256"]
+                        ),
+                        "excluded_cell_ids": sorted(set(args.exclude_cell_id)),
+                        "cells": [
+                            {
+                                "cell_id": item.cell.cell_id,
+                                "dependency": item.dependency,
+                                "baseline_cell_id": item.baseline_cell_id,
+                                "comparison_peer_ids": list(item.comparison_peer_ids),
+                                "rank": item.rank,
+                            }
+                            for item in planned
+                        ],
+                    },
+                    sort_keys=True,
+                )
+            )
+            return 0
+        if args.report_profile is not None:
+            require_active_profile_environment(
+                repo_root,
+                args.report_profile,
+                expected_source_revision=expected_revision,
+            )
+        service.bind_measurement_lineage(measurement_lineage)
+        if active_study_contract is None:
+            scheduler = CampaignScheduler(service, settings=settings)
+        else:
+            scheduler = CampaignScheduler(
+                service,
+                settings=settings,
+                study_contract=active_study_contract,
+                study_contract_wrapper_root=(Path(__file__).resolve().parents[2]),
+            )
+        result = scheduler.run(planned)
+        if args.refresh_pdf == "end":
+            _launch_async_publication(
+                service,
+                entrypoint=scheduler.worker_entrypoint,
+            )
+        print(
+            json.dumps(
+                {
+                    "planned": len(result.planned),
+                    "completed": len(result.outcomes),
+                    "failed": len(result.failed),
+                    "source_revision": expected_revision,
+                    "source_tree": source_identity.tree,
+                    "campaign_policy": (settings.campaign_policy.as_manifest()),
+                    "policy_profile": settings.report_profile,
+                    "study_contract_sha256": (
+                        None
+                        if active_study_contract is None
+                        else active_study_contract["sha256"]
+                    ),
+                    "outcomes": [
+                        {
+                            "cell_id": outcome.cell_id,
+                            "status": outcome.status,
+                            "detail": outcome.detail,
+                        }
+                        for outcome in result.outcomes
+                    ],
+                },
+                sort_keys=True,
+            )
+        )
+        return 1 if result.failed else 0
+    if args.command in {"reset", "render", "recover"}:
+        written = service.publish(
+            reset=args.command == "reset",
+            merge_artifacts=args.command != "reset",
+        )
+        if args.compile:
+            written = (*written, _compile_pdf(service))
+        for path in written:
+            print(path.relative_to(repo_root))
+        return 0
+    if args.command == "_worker":
+        if args.cell_id not in {
+            cell.cell_id for cell in REPORT_CATALOG.measurement_cells()
+        }:
+            parser.error(f"unknown --cell-id {args.cell_id!r}")
+        write_cell_result(
+            args.cell_id,
+            args.result_json,
+            repo_root=repo_root,
+            attempt_root=args.attempt_root,
+            target_runtime_seconds=args.target_runtime,
+            batch_size=args.batch_size,
+            worker_cores=args.cell_cores,
+            amplicol_build_jobs=args.amplicol_build_jobs,
+            memory_limit_bytes=args.memory_limit_bytes,
+            warmup_runs=args.warmup_runs,
+            minimum_samples=args.minimum_samples,
+            progress_jsonl=args.progress_jsonl,
+            worker_wall_limit_seconds=args.worker_wall_limit,
+            profiling_time_limit_seconds=args.profiling_time_limit,
+            validation_time_limit_seconds=args.validation_time_limit,
+            generation_lock_path=args.generation_lock_path,
+            manual_source_revision=args.manual_source_revision,
+            manual_source_tree=args.manual_source_tree,
+            baseline_json=args.baseline_json,
+            expected_authority_cell_ids=tuple(args.expected_authority_cell_id),
+            selected_authority_cell_id=args.selected_authority_cell_id,
+            peer_json=tuple((cell_id, Path(path)) for cell_id, path in args.peer_json),
+            prepared_model_path=args.prepared_model,
+            reused_measurement_json=args.reused_measurement_json,
+            phase_state_path=args.phase_state_path,
+            phase_state_run_id=args.phase_state_run_id,
+            phase_state_authentication_key=args.phase_state_authentication_key,
+            legacy_repository=args.legacy_repository,
+            legacy_source_repository=args.legacy_source_repository,
+            legacy_workspace=args.legacy_workspace,
+            legacy_copy_source=args.legacy_copy_source,
+            legacy_source_revision=args.legacy_source_revision,
+            madgraph_installation=args.madgraph,
+            log_path=args.log_path,
+            worker_harness=worker_harness,
+        )
+        return 0
+    if args.command == "_prepare":
+        try:
+            path, reused = ensure_report_prepared_model(
+                store=service.store,
+                repo_root=repo_root,
+                worker_cores=args.cell_cores,
+                model=ModelKey(args.model),
+                producer_revision=args.producer_revision,
+                progress=(
+                    None
+                    if args.progress_jsonl is None
+                    else _JsonlProgressSink(args.progress_jsonl)
+                ),
+            )
+            payload = {
+                "path": os.fspath(path),
+                "reused": reused,
+                **(
+                    {} if worker_harness is None else {"worker_harness": worker_harness}
+                ),
+            }
+            returncode = 0
+        except Exception as error:
+            payload = {
+                "error": {
+                    "kind": type(error).__name__,
+                    "message": str(error),
+                }
+            }
+            returncode = 1
+        args.result_json.parent.mkdir(parents=True, exist_ok=True)
+        args.result_json.write_text(
+            json.dumps(payload, sort_keys=True) + "\n",
+            encoding="ascii",
+        )
+        return returncode
+    parser.error(f"unsupported command {args.command!r}")
+    return 2
+
+
+__all__ = ["main"]
diff --git a/pyamplicol/tools/performance_report/display_contract.py b/pyamplicol/tools/performance_report/display_contract.py
new file mode 100644
index 0000000000..5d9cf00867
--- /dev/null
+++ b/pyamplicol/tools/performance_report/display_contract.py
@@ -0,0 +1,89 @@
+# SPDX-License-Identifier: 0BSD
+"""Logical display accounting for publication-facing report tables."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .models import ExecutionMode, ModelKey, Workload
+
+
+@dataclass(frozen=True, slots=True)
+class DisplayAccounting:
+    """Counts that distinguish measured cells from intentional table markers."""
+
+    maximum_n_final: int
+    declared_measurement_cell_count: int
+    required_measurement_count: int
+    catalog_static_na_cell_count: int
+    structurally_not_applicable_display_slot_count: int
+    not_exposed_display_slot_count: int
+
+
+def report_display_accounting(
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    max_n_final: int = 9,
+) -> DisplayAccounting:
+    """Return canonical logical-slot counts through ``max_n_final``.
+
+    A declared measurement is one catalog ``CellSpec``. Required measurements
+    exclude only catalog-authenticated static N/A cells that no supported
+    producer can evaluate. A structurally inapplicable slot is one matrix
+    process/multiplicity position for which no process exists. A not-exposed
+    slot is one original-AmpliCol execution submetric in a dedicated Z-ladder
+    row; those rows expose generation and wall timing, but not a separately
+    defined native-execution boundary.
+    """
+
+    if max_n_final < 1:
+        raise ValueError("max_n_final must be positive")
+    declared_cells = tuple(
+        cell
+        for cell in catalog.measurement_cells()
+        if cell.n_final <= max_n_final
+    )
+    static_na = sum(
+        catalog.static_na_reason(cell) is not None for cell in declared_cells
+    )
+    required = len(declared_cells) - static_na
+    matrix_datasets = getattr(catalog, "matrix_datasets", ())
+    process_families = getattr(catalog, "process_families", ())
+    structural = 0
+    for dataset in matrix_datasets:
+        for family in process_families:
+            for n_final in dataset.multiplicities:
+                if n_final > max_n_final:
+                    continue
+                if family.process(n_final) is None or n_final > family.maximum_n(
+                    dataset.candidate.accuracy
+                ):
+                    structural += 1
+
+    variants = getattr(catalog, "z_variants", ())
+    reference_variants = sum(
+        variant.execution_mode is ExecutionMode.AMPLICOL for variant in variants
+    )
+    model_count = sum(
+        model in getattr(catalog, "models", {})
+        for model in (ModelKey.BUILTIN_SM, ModelKey.UFO_SM)
+    )
+    z_multiplicity_count = sum(n_final <= max_n_final for n_final in range(1, 10))
+    not_exposed = (
+        reference_variants
+        * model_count
+        * z_multiplicity_count
+        * len((Workload.SELECTED_FLOW, Workload.ALL_FLOW))
+    )
+    return DisplayAccounting(
+        maximum_n_final=max_n_final,
+        declared_measurement_cell_count=len(declared_cells),
+        required_measurement_count=required,
+        catalog_static_na_cell_count=static_na,
+        structurally_not_applicable_display_slot_count=structural,
+        not_exposed_display_slot_count=not_exposed,
+    )
+
+
+__all__ = ["DisplayAccounting", "report_display_accounting"]
diff --git a/pyamplicol/tools/performance_report/final_audit.py b/pyamplicol/tools/performance_report/final_audit.py
new file mode 100644
index 0000000000..38c80d1eaa
--- /dev/null
+++ b/pyamplicol/tools/performance_report/final_audit.py
@@ -0,0 +1,7201 @@
+# SPDX-License-Identifier: 0BSD
+"""Final-SHA structural and numerical audit for checked-in report measurements."""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import hashlib
+import importlib
+import io
+import json
+import math
+import os
+import re
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+import tomllib
+from collections import Counter, defaultdict
+from collections.abc import Callable, Collection, Mapping, Sequence
+from dataclasses import dataclass
+from functools import cache
+from importlib.machinery import EXTENSION_SUFFIXES
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+from .agreements import (
+    BUILTIN_UFO_RECURRENCE,
+    DIRECT_AGREEMENT_FIELD,
+    DIRECT_AGREEMENT_V1_ABI,
+    DIRECT_AGREEMENT_V2_ABI,
+    INDEPENDENT_AUTHORITY_ABI,
+    INDEPENDENT_AUTHORITY_FIELD,
+    LC_COMMON_COMPONENT_ABI,
+    LC_COMMON_COMPONENT_FIELD,
+    LC_CROSS_LAYOUT_COMPONENT,
+    LC_LEGACY_PYAMPLICOL_COMPONENT,
+    MADGRAPH_COMPARISON_FIELD,
+    MADGRAPH_FULL_COLOUR,
+    STRICT_ABSOLUTE_TOLERANCE,
+    STRICT_RELATIVE_TOLERANCE,
+    Z_RECURRENCE_CROSS_MODE,
+    AgreementEdge,
+    agreement_edges,
+    direct_agreement_record,
+    evaluate_lc_common_component,
+    incoming_agreement_edges,
+    independent_numerical_authorities,
+    madgraph_candidate_precision,
+    requires_independent_numerical_authority,
+    validate_madgraph_comparison_record,
+    validation_baseline_is_required,
+)
+from .cache import _validate_standalone_internal_validation, digest_json, reset_entry
+from .campaign_policy import (
+    MACBOOK_M3_POLICY,
+    MACBOOK_M3_PROFILE,
+    MACBOOK_M3_Z_TABLE_F_POLICY,
+    STRICT_POLICY,
+    X86_EPYC_POLICY,
+    X86_EPYC_PROFILE,
+    CampaignPolicy,
+    CampaignPolicyError,
+    PolicyMeasurementState,
+    dependency_reference,
+    resource_frontier_reference,
+    resource_lane_identity,
+    validate_policy_measurement,
+)
+from .catalog import (
+    REPORT_CATALOG,
+    STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6,
+    STATIC_NA_ORIGINAL_AMPLICOL_OPEN_QUARK_LINE_LIMIT,
+    ReportCatalog,
+)
+from .measurement import (
+    baseline_uses_lc_common_component_authority,
+    conditioned_measurement_comparison,
+    shared_validation_points,
+)
+from .measurement_lineage import (
+    MeasurementLineage,
+    MeasurementLineageError,
+    _is_authorized_native_inputs_transition,
+    load_and_audit_measurement_lineage,
+)
+from .models import (
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from .publication import publication_measurement_matches_current
+from .publisher import _report_source_copy_ignore
+from .render import render_all_tables, summarize_visible_completeness
+from .report_policy import publication_measurement_policy_issues
+from .runner import (
+    ABSOLUTE_TOLERANCE,
+    CONDITIONED_COMPARISON_ABI,
+    INDEPENDENT_RELATIVE_TOLERANCE,
+    RELATIVE_TOLERANCE,
+    REPORT_BENCHMARK_BATCH_SIZE,
+    REPORT_BENCHMARK_WARMUP_RUNS,
+    RESOLVED_SUM_VALIDATION_ABI,
+    SelectorContract,
+    _valid_symjit_plane_target,
+    point_digest,
+    resolved_sum_validation,
+    runtime_validation_points,
+    validate_conditioned_comparison_record,
+    validate_profile_warmup_evidence,
+    validate_resolved_sum_validation_record,
+    validate_runtime_contract,
+    validate_selector_contract,
+)
+from .runtime_evidence import (
+    RuntimeEvidenceError,
+    established_preimport_runtime_identity,
+    loaded_pyamplicol_origin_policy,
+    native_extension_in_package,
+    preimport_python_runtime_identity,
+    python_package_tree_identity,
+    source_only_bytecode_policy,
+)
+from .service import ReportPaths, ReportService, validate_profile_name
+from .source_identity import (
+    ReportSourceIdentityError,
+    require_report_only_publication,
+)
+from .standalone_build import StandaloneBuildError, validate_latex_log
+from .timing import (
+    ARENA_UNAVAILABLE_EXECUTION_TIMING_FIELDS,
+    EVALUATOR_TOTAL_TIMING_KEY,
+    evaluator_total_timing_record,
+    unavailable_execution_timing_record,
+)
+from .workspace import load_profile_campaign_policy
+
+_GIT_SHA_RE = re.compile(r"^[0-9a-f]{40}$")
+_SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
+_FULL_CATALOG_MAX_N_FINAL = 9
+_EXPECTED_FULL_CATALOG_CELL_COUNT = 2198
+_EXPECTED_FULL_STATIC_NA_REASONS = {
+    **{
+        cell_id: STATIC_NA_ORIGINAL_AMPLICOL_OPEN_QUARK_LINE_LIMIT
+        for cell_id in {
+            "reference-amplicol-lc-n6-dd-4q-lines-selected-flow",
+            "reference-amplicol-lc-n6-dd-4q-lines-all-flow",
+            "reference-amplicol-lc-n7-dd-4q-lines-selected-flow",
+            "reference-amplicol-lc-n7-dd-4q-lines-all-flow",
+            "reference-amplicol-lc-n8-dd-4q-lines-selected-flow",
+            "reference-amplicol-lc-n8-dd-4q-lines-all-flow",
+            "reference-amplicol-lc-n9-dd-4q-lines-selected-flow",
+            "reference-amplicol-lc-n9-dd-4q-lines-all-flow",
+            "reference-amplicol-nlc-n6-dd-4q-lines-contracted",
+            "reference-amplicol-full-n6-dd-4q-lines-contracted",
+        }
+    },
+    **{
+        (
+            f"z-{model}-n{n_final}-dd-z-jets-{variant}-{workload}"
+        ): STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6
+        for model in ("builtin-sm", "external-sm")
+        for n_final in (7, 8, 9)
+        for variant in ("asm-o3", "cpp-o3")
+        for workload in ("selected-flow", "all-flow")
+    },
+}
+_EXPECTED_FULL_STATIC_NA_CELL_IDS = frozenset(_EXPECTED_FULL_STATIC_NA_REASONS)
+_EXPECTED_FULL_DIRECT_AGREEMENT_COUNT = 1973
+_EXPECTED_N4_CELL_COUNT = 1042
+_EXPECTED_N4_DIRECT_AGREEMENT_COUNTS = {
+    BUILTIN_UFO_RECURRENCE: 140,
+    Z_RECURRENCE_CROSS_MODE: 80,
+    LC_CROSS_LAYOUT_COMPONENT: 254,
+    LC_LEGACY_PYAMPLICOL_COMPONENT: 221,
+    MADGRAPH_FULL_COLOUR: 132,
+}
+_EXPECTED_FULL_DIRECT_AGREEMENT_COUNTS = {
+    BUILTIN_UFO_RECURRENCE: 332,
+    Z_RECURRENCE_CROSS_MODE: 156,
+    LC_CROSS_LAYOUT_COMPONENT: 678,
+    LC_LEGACY_PYAMPLICOL_COMPONENT: 559,
+    MADGRAPH_FULL_COLOUR: 200,
+}
+_FULLY_REPLAYED_PYAMPLICOL = "fully-replayed-pyamplicol"
+_REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY = (
+    "replayed-pyamplicol-vs-authenticated-legacy"
+)
+_AUTHENTICATED_STORED_LEGACY_LAYOUT = "authenticated-stored-legacy-layout"
+_AUTHENTICATED_STORED_MADGRAPH = "authenticated-stored-madgraph"
+_DIRECT_REPLAY_CATEGORIES = (
+    _FULLY_REPLAYED_PYAMPLICOL,
+    _REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY,
+    _AUTHENTICATED_STORED_LEGACY_LAYOUT,
+    _AUTHENTICATED_STORED_MADGRAPH,
+)
+_EXPECTED_N4_DIRECT_REPLAY_COUNTS = {
+    _FULLY_REPLAYED_PYAMPLICOL: 441,
+    _REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY: 221,
+    _AUTHENTICATED_STORED_LEGACY_LAYOUT: 33,
+    _AUTHENTICATED_STORED_MADGRAPH: 132,
+}
+_EXPECTED_FULL_DIRECT_REPLAY_COUNTS = {
+    _FULLY_REPLAYED_PYAMPLICOL: 1063,
+    _REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY: 559,
+    _AUTHENTICATED_STORED_LEGACY_LAYOUT: 103,
+    _AUTHENTICATED_STORED_MADGRAPH: 200,
+}
+
+
+def _count_contract_matches_with_optional_categories(
+    observed: Mapping[str, int],
+    expected_maxima: Mapping[str, int],
+    *,
+    optional_categories: Collection[str],
+) -> bool:
+    """Keep required counts exact while bounding optional edge categories."""
+
+    optional = frozenset(optional_categories)
+    if set(observed) != set(expected_maxima) or not optional <= set(expected_maxima):
+        return False
+    return all(
+        (
+            0 <= observed[category] <= expected
+            if category in optional
+            else observed[category] == expected
+        )
+        for category, expected in expected_maxima.items()
+    )
+
+
+def _replay_count_contract_matches_direct_edges(
+    observed: Mapping[str, int],
+    direct_edge_counts: Mapping[str, int],
+    expected_replay_counts: Mapping[str, int],
+) -> bool:
+    """Require replay of every direct edge that was actually available.
+
+    Z recurrence and legacy-AmpliCol comparison edges may be absent.  The
+    remaining built-in/UFO and LC cross-layout edges are still exact at the
+    direct-edge gate.  Projecting the replay categories from those already
+    checked direct counts prevents either a required replay or an available
+    optional replay from disappearing behind an aggregate category count.
+    """
+
+    if set(observed) != set(expected_replay_counts):
+        return False
+    try:
+        stored_legacy_layout = expected_replay_counts[
+            _AUTHENTICATED_STORED_LEGACY_LAYOUT
+        ]
+        fully_replayed = (
+            direct_edge_counts[BUILTIN_UFO_RECURRENCE]
+            + direct_edge_counts[Z_RECURRENCE_CROSS_MODE]
+            + direct_edge_counts[LC_CROSS_LAYOUT_COMPONENT]
+            - stored_legacy_layout
+        )
+        replayed_legacy = direct_edge_counts[LC_LEGACY_PYAMPLICOL_COMPONENT]
+        stored_madgraph = direct_edge_counts[MADGRAPH_FULL_COLOUR]
+    except KeyError:
+        return False
+    if fully_replayed < 0:
+        return False
+    return dict(observed) == {
+        _FULLY_REPLAYED_PYAMPLICOL: fully_replayed,
+        _REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY: replayed_legacy,
+        _AUTHENTICATED_STORED_LEGACY_LAYOUT: stored_legacy_layout,
+        _AUTHENTICATED_STORED_MADGRAPH: stored_madgraph,
+    }
+
+
+_LOADED_ORIGIN_OBSERVATION_FIELDS = frozenset(
+    {
+        "observed_module_count",
+        "observations",
+        "observations_sha256",
+    }
+)
+_ARENA_CAPABILITY = {
+    ExecutionMode.COMPILED: "compiled-plane-arena-v1",
+    ExecutionMode.EAGER: "eager-direct-arena-v1",
+    ExecutionMode.RECURRENCE: ("rusticol.recurrence-direct-arena.complex-f64.v1"),
+    ExecutionMode.ON_THE_FLY: "rusticol.on-the-fly.complex-f64.v1",
+}
+_ON_THE_FLY_LC_COLOR_CAPABILITY = "rusticol.on-the-fly.lc-color.v1"
+_ON_THE_FLY_CONTRACTED_COLOR_CAPABILITY = "rusticol.on-the-fly.contracted-color.v1"
+_ON_THE_FLY_COLOR_CONTRACTION_ABI = "pyamplicol-recurrence-color-contraction-v3"
+_ON_THE_FLY_EXECUTION_KIND = "pyamplicol-runtime-on-the-fly-execution"
+_ON_THE_FLY_RUNTIME_CONTAINER_KIND = "pyamplicol-on-the-fly-runtime-container"
+_ON_THE_FLY_RUNTIME_STORAGE_ABI = "pacbin-v1"
+_ON_THE_FLY_SEED_MEMBER_PATH = "on-the-fly/process-seed-v1.bin"
+_ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI = "pyamplicol-on-the-fly-process-seed-identity-v1"
+_ON_THE_FLY_PROCESS_SEED_IDENTITY_FIELDS = frozenset(
+    {
+        "abi",
+        "process_digest",
+        "compiled_model_digest",
+        "recurrence_template_catalog_digest",
+        "prepared_kernel_pack_digest",
+        "recurrence_direct_template_catalog_digest",
+        "semantic_digest",
+        "external_permutation",
+        "external_sources",
+    }
+)
+_EAGER_PREPARED_PACK_IDENTITY_KIND = "pyamplicol-prepared-kernel-pack-identity"
+_EAGER_PREPARED_PACK_IDENTITY_SCHEMA_VERSION = 1
+_COMPILED_DIRECT_ABI = "pyamplicol-compiled-plane-kernel-v2"
+_NATIVE_COMPILED_DIRECT_ABI = "pyamplicol-native-compiled-direct-application-v1"
+_SYMJIT_APPLICATION_ABI = "symjit-application-storage-v3"
+_SYMJIT_PLANE_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+_EAGER_NATIVE_APPLICATION_ABI = "pyamplicol-eager-native-direct-table-v1"
+_EAGER_DIRECT_CAPABILITY = "eager-direct-arena-v1"
+_EAGER_DIRECT_DESCRIPTOR_ABI = "pyamplicol-eager-plane-table-descriptor-v1"
+_EAGER_DIRECT_BINDING_ABI = "pyamplicol-eager-plane-table-binding-v2"
+_RECURRENCE_DIRECT_TEMPLATE_ABI = "pyamplicol-recurrence-direct-template-v1"
+_RECURRENCE_DIRECT_BACKEND_ABI = "rusticol.recurrence-direct-backend.v1"
+_RECURRENCE_DIRECT_CANONICALIZATION_ABI = "pyamplicol-canonical-json-v1"
+_RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI = "pyamplicol-recurrence-plane-binding-v2"
+_RECURRENCE_JIT_DIRECT_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+_SOURCE_RUNTIME_CAPABILITY = {
+    "jit": "symjit.application.complex-f64.v1",
+    "cpp": "symbolica.compiled-cpp.complex-f64.v1",
+    "asm": "symbolica.compiled-asm.complex-f64.v1",
+}
+_MODEL_SOURCE_PATH = {
+    ModelKey.UFO_SM: "src/pyamplicol/assets/models/json/sm/sm.json",
+    ModelKey.SCALAR_CONTACT: ("src/pyamplicol/assets/models/json/scalars/scalars.json"),
+    ModelKey.SCALAR_GRAVITY: (
+        "src/pyamplicol/assets/models/json/scalar_gravity/scalar_gravity.json"
+    ),
+}
+_TEX_INPUT_RE = re.compile(r"\\(?:input|include)\s*\{([^{}]+)\}")
+_REPORT_PROFILE_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,63}")
+_PUBLICATION_MEMBER_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]*")
+_PORTABLE_ARTIFACT_ROOT = "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}"
+_PUBLICATION_LINEAGE_KIND = "pyamplicol-report-publication-lineage-v1"
+
+
+class FinalAuditError(RuntimeError):
+    """The final report evidence does not satisfy its publication contract."""
+
+
+@cache
+def _cached_packaged_eager_prepared_pack_identity(
+    model: ModelKey | None,
+    backend: str,
+    jit_optimization_level: int | None,
+) -> dict[str, object]:
+    """Return the exact wheel-owned prepared identity for one report lane."""
+
+    if (
+        model is not ModelKey.BUILTIN_SM
+        or backend != "jit"
+        or jit_optimization_level != 2
+    ):
+        raise FinalAuditError(
+            "on-the-fly report cells require the packaged built-in-SM JIT O2 pack"
+        )
+    try:
+        from pyamplicol.assets.prepared_models import (
+            BUILTIN_SM_JIT_O2,
+            open_packaged_prepared_model,
+        )
+        from pyamplicol.models.prepared import (
+            EAGER_KERNEL_ABI,
+            PREPARED_KERNEL_PACK_IDENTITY_ABI,
+            prepared_kernel_pack_manifest_identity_sha256,
+        )
+
+        with open_packaged_prepared_model(BUILTIN_SM_JIT_O2) as bundle:
+            if bundle.kernel_pack.backend != backend:
+                raise FinalAuditError(
+                    "packaged prepared-kernel backend differs from the report cell"
+                )
+            return {
+                "kind": _EAGER_PREPARED_PACK_IDENTITY_KIND,
+                "schema_version": _EAGER_PREPARED_PACK_IDENTITY_SCHEMA_VERSION,
+                "abi": PREPARED_KERNEL_PACK_IDENTITY_ABI,
+                "eager_kernel_abi": EAGER_KERNEL_ABI,
+                "identity_sha256": (
+                    prepared_kernel_pack_manifest_identity_sha256(bundle.manifest)
+                ),
+                "backend": bundle.kernel_pack.backend,
+                "kernel_count": len(bundle.kernel_pack.kernels),
+            }
+    except (ImportError, OSError, RuntimeError, TypeError, ValueError) as error:
+        raise FinalAuditError(
+            "packaged prepared-kernel identity is unavailable"
+        ) from error
+
+
+def _expected_eager_prepared_pack_identity(cell: CellSpec) -> dict[str, object]:
+    measurement = cell.measurement
+    return _cached_packaged_eager_prepared_pack_identity(
+        measurement.model,
+        measurement.backend,
+        measurement.jit_optimization_level,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactEvidence:
+    """Identity proven directly from one validated process artifact."""
+
+    artifact_id: str
+    process_id: str
+    producer_version: str
+    producer_git_revision: str | None
+    producer_native_build_inputs_sha256: str | None
+    runtime_version: str
+    runtime_capabilities: tuple[str, ...]
+    execution_manifest_path: str
+    execution_manifest_sha256: str
+    execution_mode: str
+    arena_record_count: int
+    direct_leaf_count: int
+    effective_config: Mapping[str, object]
+    source_jit_identity: Mapping[str, object] | None
+
+
+@dataclass(frozen=True, slots=True)
+class _ArtifactReference:
+    cell: CellSpec
+    measurement: Mapping[str, object]
+    path: Path
+    process_id: str
+
+
+@dataclass(frozen=True, slots=True)
+class _ReplayObservation:
+    matrix_element: float
+    resolved_maximum_absolute: float
+    resolved_maximum_relative: float
+    lc_common_component: float | None
+
+
+ArtifactAuditor = Callable[[CellSpec, Path, str], ArtifactEvidence]
+RuntimeLoader = Callable[[Path, str], object]
+SourceAuditor = Callable[[Path, str], Mapping[str, object] | None]
+PdfAuditor = Callable[[ReportService], Mapping[str, object]]
+RuntimeAuditor = Callable[[str, Path], Mapping[str, object]]
+
+
+def _mapping(value: object, context: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise FinalAuditError(f"{context} must be an object")
+    return value
+
+
+def _sequence(value: object, context: str) -> Sequence[object]:
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise FinalAuditError(f"{context} must be an array")
+    return value
+
+
+def _finite_number(value: object, context: str, *, nonnegative: bool = False) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise FinalAuditError(f"{context} must be a finite number")
+    result = float(value)
+    if not math.isfinite(result):
+        raise FinalAuditError(f"{context} must be finite")
+    if nonnegative and result < 0.0:
+        raise FinalAuditError(f"{context} must be non-negative")
+    return result
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _canonical_relative_path(relative: object, context: str) -> PurePosixPath:
+    if not isinstance(relative, str) or not relative:
+        raise FinalAuditError(f"{context} path is missing")
+    logical = PurePosixPath(relative)
+    if (
+        logical.is_absolute()
+        or not logical.parts
+        or any(part in {"", ".", ".."} for part in logical.parts)
+        or logical.as_posix() != relative
+    ):
+        raise FinalAuditError(f"{context} path is not canonical")
+    return logical
+
+
+def _authenticated_payload_bytes(
+    artifact: Path,
+    manifest: object,
+    relative: object,
+    *,
+    role: str,
+    media_type: str,
+    process_id: str | None,
+    context: str,
+) -> tuple[bytes, str, str]:
+    """Read one manifest-declared payload through one checked descriptor."""
+
+    logical = _canonical_relative_path(relative, context)
+    canonical = logical.as_posix()
+    payloads = getattr(manifest, "payloads", None)
+    if not isinstance(payloads, Sequence):
+        raise FinalAuditError(f"{context} has no artifact payload inventory")
+    matches = [
+        payload for payload in payloads if getattr(payload, "path", None) == canonical
+    ]
+    if len(matches) != 1:
+        raise FinalAuditError(f"{context} payload is missing or ambiguous")
+    payload = matches[0]
+    expected_size = getattr(payload, "size_bytes", None)
+    expected_sha256 = getattr(payload, "sha256", None)
+    if (
+        getattr(payload, "role", None) != role
+        or getattr(payload, "media_type", None) != media_type
+        or getattr(payload, "process_id", None) != process_id
+        or getattr(payload, "executable", None) is not False
+        or isinstance(expected_size, bool)
+        or not isinstance(expected_size, int)
+        or expected_size < 0
+        or not isinstance(expected_sha256, str)
+        or _SHA256_RE.fullmatch(expected_sha256) is None
+    ):
+        raise FinalAuditError(f"{context} has an invalid artifact declaration")
+    path = artifact.joinpath(*logical.parts)
+    flags = os.O_RDONLY | getattr(os, "O_CLOEXEC", 0) | getattr(os, "O_NOFOLLOW", 0)
+    descriptor: int | None = None
+    try:
+        descriptor = os.open(path, flags)
+        metadata = os.fstat(descriptor)
+        if not stat.S_ISREG(metadata.st_mode) or metadata.st_size != expected_size:
+            raise FinalAuditError(f"{context} does not match its artifact declaration")
+        with os.fdopen(descriptor, "rb", closefd=True) as stream:
+            descriptor = None
+            data = stream.read(expected_size + 1)
+    except OSError as error:
+        raise FinalAuditError(f"cannot read authenticated {context}") from error
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+    actual_sha256 = hashlib.sha256(data).hexdigest()
+    if len(data) != expected_size or actual_sha256 != expected_sha256:
+        raise FinalAuditError(f"{context} does not match the artifact manifest")
+    return data, canonical, actual_sha256
+
+
+def _authenticated_json_payload(
+    artifact: Path,
+    manifest: object,
+    relative: object,
+    *,
+    process_id: str | None,
+    context: str,
+) -> tuple[dict[str, Any], str, str]:
+    data, canonical, sha256 = _authenticated_payload_bytes(
+        artifact,
+        manifest,
+        relative,
+        role="evaluator-manifest",
+        media_type="application/json",
+        process_id=process_id,
+        context=context,
+    )
+    try:
+        value = json.loads(data)
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise FinalAuditError(f"authenticated {context} is invalid JSON") from error
+    if not isinstance(value, dict):
+        raise FinalAuditError(f"authenticated {context} must be an object")
+    return value, canonical, sha256
+
+
+def _authenticated_effective_config(
+    artifact: Path,
+    manifest: object,
+) -> Mapping[str, object]:
+    configuration = _mapping(
+        getattr(manifest, "configuration", None),
+        "artifact.configuration",
+    )
+    data, _canonical, _sha256 = _authenticated_payload_bytes(
+        artifact,
+        manifest,
+        configuration.get("effective_path"),
+        role="configuration-effective",
+        media_type="application/toml",
+        process_id=None,
+        context="effective configuration",
+    )
+    try:
+        value = tomllib.loads(data.decode("utf-8"))
+    except (UnicodeDecodeError, tomllib.TOMLDecodeError) as error:
+        raise FinalAuditError(
+            "authenticated effective configuration is invalid TOML"
+        ) from error
+    return _mapping(value, "authenticated effective configuration")
+
+
+def _python_package_tree_identity(
+    package_roots: Path | Sequence[Path],
+) -> dict[str, object]:
+    """Translate exact-runtime evidence failures into final-audit failures."""
+
+    try:
+        return python_package_tree_identity(package_roots)
+    except RuntimeEvidenceError as error:
+        raise FinalAuditError(
+            "installed pyamplicol namespace cannot be authenticated"
+        ) from error
+
+
+def _validate_python_package_tree_identity(
+    value: object,
+    *,
+    context: str,
+) -> Mapping[str, object]:
+    identity = _mapping(value, context)
+    root = identity.get("root")
+    roots = identity.get("roots")
+    file_count = identity.get("file_count")
+    total_bytes = identity.get("total_bytes")
+    digest = identity.get("sha256")
+    bytecode_policy = identity.get("bytecode_policy")
+    if (
+        identity.get("kind") != "pyamplicol-python-package-tree-v2"
+        or not isinstance(root, str)
+        or not root
+        or not Path(root).is_absolute()
+        or isinstance(roots, (str, bytes))
+        or not isinstance(roots, Sequence)
+        or not roots
+        or any(
+            not isinstance(item, str) or not Path(item).is_absolute() for item in roots
+        )
+        or len(set(roots)) != len(roots)
+        or roots[0] != root
+        or isinstance(file_count, bool)
+        or not isinstance(file_count, int)
+        or file_count < 1
+        or isinstance(total_bytes, bool)
+        or not isinstance(total_bytes, int)
+        or total_bytes < 0
+        or not isinstance(digest, str)
+        or _SHA256_RE.fullmatch(digest) is None
+        or identity.get("member_set_stable") is not True
+        or identity.get("namespace_bound_to_root_fd") is not True
+        or not isinstance(bytecode_policy, Mapping)
+        or bytecode_policy.get("kind") != "pyamplicol-source-only-bytecode-policy-v1"
+        or bytecode_policy.get("dont_write_bytecode") is not True
+        or bytecode_policy.get("external_pycache_prefix_absent") is not True
+        or bytecode_policy.get("package_local_bytecode_eligible") is not False
+        or bytecode_policy.get("isolated_startup") is not True
+        or bytecode_policy.get("site_initialization") is not False
+        or bytecode_policy.get("python_environment_ignored_at_startup") is not True
+    ):
+        raise FinalAuditError(f"{context} is not a valid package-tree identity")
+    return identity
+
+
+def _validate_loaded_origin_policy(
+    value: object,
+    *,
+    context: str,
+) -> Mapping[str, object]:
+    policy = _mapping(value, context)
+    count = policy.get("observed_module_count")
+    observations = policy.get("observations")
+    if (
+        policy.get("kind") != "pyamplicol-loaded-module-origin-policy-v1"
+        or policy.get("all_loaded_origins_authenticated") is not True
+        or policy.get("native_image_origin_bound") is not True
+        or policy.get("loaded_bytecode_eligible") is not False
+        or isinstance(count, bool)
+        or not isinstance(count, int)
+        or count < 1
+        or isinstance(observations, (str, bytes))
+        or not isinstance(observations, Sequence)
+        or len(observations) != count
+        or _SHA256_RE.fullmatch(str(policy.get("observations_sha256"))) is None
+        or digest_json(list(observations)) != policy.get("observations_sha256")
+    ):
+        raise FinalAuditError(f"{context} is not a valid loaded-origin policy")
+    return policy
+
+
+def _stable_runtime_identity(identity: Mapping[str, object]) -> dict[str, object]:
+    stable = dict(identity)
+    raw_policy = stable.get("loaded_module_origin_policy")
+    if isinstance(raw_policy, Mapping):
+        stable["loaded_module_origin_policy"] = {
+            field: value
+            for field, value in raw_policy.items()
+            if field not in _LOADED_ORIGIN_OBSERVATION_FIELDS
+        }
+    return stable
+
+
+def _audit_runtime_identity_postflight(
+    provenance: Mapping[str, object],
+    identity: Mapping[str, object],
+    *,
+    context: str,
+) -> None:
+    stable_digest = digest_json(_stable_runtime_identity(identity))
+    if provenance.get("runtime_identity_stable_sha256") != stable_digest:
+        raise FinalAuditError(
+            f"{context}.runtime_identity_stable_sha256 does not match"
+        )
+    if provenance.get("runtime_identity_postflight_stable_sha256") != stable_digest:
+        raise FinalAuditError(
+            f"{context}.runtime_identity postflight stable SHA-256 differs"
+        )
+    if provenance.get("runtime_identity_postflight_match") is not True:
+        raise FinalAuditError(
+            f"{context}.runtime_identity_postflight_match is not true"
+        )
+
+    initial_policy = _validate_loaded_origin_policy(
+        identity.get("loaded_module_origin_policy"),
+        context=f"{context}.runtime_identity.loaded_module_origin_policy",
+    )
+    postflight_policy = _validate_loaded_origin_policy(
+        provenance.get("runtime_identity_postflight_loaded_module_origin_policy"),
+        context=(f"{context}.runtime_identity_postflight_loaded_module_origin_policy"),
+    )
+    stable_initial_policy = {
+        field: value
+        for field, value in initial_policy.items()
+        if field not in _LOADED_ORIGIN_OBSERVATION_FIELDS
+    }
+    stable_postflight_policy = {
+        field: value
+        for field, value in postflight_policy.items()
+        if field not in _LOADED_ORIGIN_OBSERVATION_FIELDS
+    }
+    if stable_postflight_policy != stable_initial_policy:
+        raise FinalAuditError(f"{context} runtime postflight origin policy changed")
+    initial_observations = _sequence(
+        initial_policy.get("observations"),
+        f"{context}.runtime_identity.loaded_module_origin_policy.observations",
+    )
+    postflight_observations = _sequence(
+        postflight_policy.get("observations"),
+        (
+            f"{context}."
+            "runtime_identity_postflight_loaded_module_origin_policy."
+            "observations"
+        ),
+    )
+    postflight_keys = {
+        json.dumps(
+            observation,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        for observation in postflight_observations
+    }
+    if any(
+        json.dumps(
+            observation,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        not in postflight_keys
+        for observation in initial_observations
+    ):
+        raise FinalAuditError(
+            f"{context} runtime postflight lost a loaded-module origin"
+        )
+
+
+def _canonical_status(
+    absolute: float,
+    relative: float,
+    *,
+    absolute_tolerance: float,
+    relative_tolerance: float,
+) -> str:
+    return (
+        ResultStatus.OK.value
+        if absolute <= absolute_tolerance or relative <= relative_tolerance
+        else ResultStatus.VALIDATION_FAILED.value
+    )
+
+
+def _expected_pointwise_tolerance(cell: CellSpec) -> float:
+    if cell.dataset_id.startswith("matrix_recurrence_") or cell.dataset_id.startswith(
+        "z_"
+    ):
+        return INDEPENDENT_RELATIVE_TOLERANCE
+    return RELATIVE_TOLERANCE
+
+
+def _same_float(observed: float, expected: float) -> bool:
+    return math.isclose(observed, expected, rel_tol=0.0, abs_tol=0.0)
+
+
+def _audit_pointwise(
+    raw: object,
+    *,
+    context: str,
+    expected_candidate: float,
+    expected_baseline: float,
+    expected_relative_tolerance: float,
+    expected_point_digest: str | None = None,
+    expected_candidate_source_sha256: str | None = None,
+    expected_baseline_source_sha256: str | None = None,
+    expected_selector_identity: Mapping[str, object] | None = None,
+    require_success: bool = True,
+) -> None:
+    record = _mapping(raw, context)
+    direct_abi = record.get("abi")
+    if direct_abi in {DIRECT_AGREEMENT_V2_ABI, DIRECT_AGREEMENT_V1_ABI}:
+        record = {
+            key: value
+            for key, value in record.items()
+            if key
+            not in {
+                "abi",
+                "edge_kind",
+                "value_kind",
+                "baseline_cell_id",
+                "candidate_cell_id",
+            }
+        }
+        if direct_abi == DIRECT_AGREEMENT_V2_ABI:
+            record["abi"] = CONDITIONED_COMPARISON_ABI
+    try:
+        validate_conditioned_comparison_record(
+            record,
+            require_binding=record.get("abi") == CONDITIONED_COMPARISON_ABI,
+        )
+    except ValueError as error:
+        raise FinalAuditError(f"{context}: {error}") from error
+    candidate = _finite_number(record.get("candidate"), f"{context}.candidate")
+    baseline = _finite_number(record.get("baseline"), f"{context}.baseline")
+    relative_tolerance = _finite_number(
+        record.get("relative_tolerance"),
+        f"{context}.relative_tolerance",
+        nonnegative=True,
+    )
+    checks = [
+        (
+            _same_float(candidate, expected_candidate),
+            "candidate does not equal measurement.matrix_element",
+        ),
+        (
+            _same_float(baseline, expected_baseline),
+            "baseline does not equal the canonical baseline measurement",
+        ),
+        (
+            _same_float(relative_tolerance, expected_relative_tolerance),
+            "relative tolerance is not the catalog contract",
+        ),
+    ]
+    if require_success:
+        checks.append(
+            (
+                record.get("status") == ResultStatus.OK.value,
+                "stored or recomputed status is not ok",
+            )
+        )
+    failures = [message for passed, message in checks if not passed]
+    if record.get("abi") == CONDITIONED_COMPARISON_ABI:
+        binding = _mapping(record.get("comparison_binding"), f"{context}.binding")
+        if (
+            expected_point_digest is not None
+            and binding.get("point_digest") != expected_point_digest
+        ):
+            failures.append("comparison scale is bound to a different point")
+        if (
+            expected_candidate_source_sha256 is not None
+            and binding.get("candidate_source_sha256")
+            != expected_candidate_source_sha256
+        ):
+            failures.append("candidate scale source differs from resolved evidence")
+        if (
+            expected_baseline_source_sha256 is not None
+            and binding.get("baseline_source_sha256") != expected_baseline_source_sha256
+        ):
+            failures.append("baseline scale source differs from authority evidence")
+        if (
+            expected_selector_identity is not None
+            and binding.get("selector_component_identity") != expected_selector_identity
+        ):
+            failures.append("selector/component scale identity differs")
+    else:
+        absolute_tolerance = _finite_number(
+            record.get("absolute_tolerance"),
+            f"{context}.absolute_tolerance",
+            nonnegative=True,
+        )
+        if not _same_float(absolute_tolerance, ABSOLUTE_TOLERANCE):
+            failures.append("legacy absolute tolerance is not the report contract")
+    if failures:
+        raise FinalAuditError(f"{context}: " + "; ".join(failures))
+
+
+def _audit_resolved_sum(raw: object, *, context: str) -> None:
+    record = _mapping(raw, context)
+    try:
+        validate_resolved_sum_validation_record(record)
+    except ValueError as error:
+        raise FinalAuditError(f"{context}: {error}") from error
+    if (
+        _finite_number(
+            record.get("relative_tolerance"),
+            f"{context}.relative_tolerance",
+            nonnegative=True,
+        )
+        != RELATIVE_TOLERANCE
+        or record.get("status") != ResultStatus.OK.value
+    ):
+        raise FinalAuditError(f"{context} is not a successful resolved-sum record")
+
+
+def _audit_lc_common_component(
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    *,
+    context: str,
+) -> float:
+    validation = _mapping(measurement.get("validation"), f"{context}.validation")
+    raw = _mapping(
+        validation.get(LC_COMMON_COMPONENT_FIELD),
+        f"{context}.validation.{LC_COMMON_COMPONENT_FIELD}",
+    )
+    expected_fields = {
+        "abi",
+        "cell_id",
+        "value",
+        "point_digest",
+        "helicity_ids",
+        "color_flow_ids",
+    }
+    if set(raw) != expected_fields:
+        raise FinalAuditError(
+            f"{context} LC common-component fields differ from the contract"
+        )
+    selector = SelectorContract.from_mapping(
+        _mapping(measurement.get("selector_contract"), f"{context}.selector_contract")
+    )
+    if (
+        raw.get("abi") != LC_COMMON_COMPONENT_ABI
+        or raw.get("cell_id") != cell.cell_id
+        or raw.get("point_digest") != selector.point_digest
+        or raw.get("helicity_ids") != list(selector.all_flow_helicity_ids)
+        or raw.get("color_flow_ids") != list(selector.selected_color_flow_ids)
+    ):
+        raise FinalAuditError(
+            f"{context} LC common component is not bound to its selector contract"
+        )
+    return _finite_number(raw.get("value"), f"{context}.lc_common_component")
+
+
+def _agreement_value(
+    edge: AgreementEdge,
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    *,
+    context: str,
+) -> float:
+    if edge.kind == MADGRAPH_FULL_COLOUR and cell.cell_id == edge.candidate.cell_id:
+        validation = _mapping(
+            measurement.get("validation"),
+            f"{context}.validation",
+        )
+        comparison = _mapping(
+            validation.get(MADGRAPH_COMPARISON_FIELD),
+            f"{context}.validation.{MADGRAPH_COMPARISON_FIELD}",
+        )
+        try:
+            validate_madgraph_comparison_record(
+                comparison,
+                expected_candidate_id=edge.candidate.cell_id,
+                expected_candidate_precision=madgraph_candidate_precision(
+                    edge.candidate
+                ),
+            )
+        except ValueError as error:
+            raise FinalAuditError(f"{context}: {error}") from error
+        binding = _mapping(
+            comparison.get("comparison_binding"),
+            f"{context}.validation.{MADGRAPH_COMPARISON_FIELD}.binding",
+        )
+        expected_point_digest = _measurement_validation_point_digest(
+            measurement,
+            context=context,
+        )
+        if (
+            comparison.get("baseline_cell_id") != edge.baseline.cell_id
+            or binding.get("point_digest") != expected_point_digest
+        ):
+            raise FinalAuditError(
+                f"{context} MadGraph comparison identity differs from the edge"
+            )
+        return _finite_number(
+            comparison.get("candidate"),
+            f"{context}.validation.{MADGRAPH_COMPARISON_FIELD}.candidate",
+        )
+    if edge.value_kind == "matrix_element":
+        return _finite_number(
+            measurement.get("matrix_element"),
+            f"{context}.matrix_element",
+        )
+    return _audit_lc_common_component(
+        cell,
+        measurement,
+        context=context,
+    )
+
+
+def _measurement_validation_point_digest(
+    measurement: Mapping[str, object],
+    *,
+    context: str,
+) -> str:
+    selector = measurement.get("selector_contract")
+    if isinstance(selector, Mapping):
+        raw = selector.get("point_digest")
+        if isinstance(raw, str):
+            return raw
+    validation = measurement.get("validation")
+    if isinstance(validation, Mapping):
+        raw = validation.get("point_digest")
+        if isinstance(raw, str):
+            return raw
+    provenance = measurement.get("provenance")
+    if isinstance(provenance, Mapping) and "report_momenta" in provenance:
+        return point_digest(provenance["report_momenta"])
+    raise FinalAuditError(f"{context} has no validation point identity")
+
+
+def _stored_direct_agreement(
+    measurement: Mapping[str, object],
+    *,
+    edge_kind: str,
+    baseline_cell_id: str | None = None,
+) -> Mapping[str, object] | None:
+    validation = measurement.get("validation")
+    records = (
+        validation.get(DIRECT_AGREEMENT_FIELD)
+        if isinstance(validation, Mapping)
+        else None
+    )
+    if not isinstance(records, list):
+        return None
+    matches = tuple(
+        record
+        for record in records
+        if isinstance(record, Mapping)
+        and record.get("edge_kind") == edge_kind
+        and (
+            baseline_cell_id is None
+            or record.get("baseline_cell_id") == baseline_cell_id
+        )
+    )
+    return matches[0] if len(matches) == 1 else None
+
+
+def _stored_pointwise_matches_baseline(
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    baseline: Mapping[str, object],
+) -> bool:
+    validation = measurement.get("validation")
+    pointwise = validation.get("pointwise") if isinstance(validation, Mapping) else None
+    if not isinstance(pointwise, Mapping):
+        return False
+    if cell.measurement.accuracy is Accuracy.LC and measurement.get(
+        "selector_contract"
+    ) != baseline.get("selector_contract"):
+        return False
+    candidate_value = measurement.get("matrix_element")
+    baseline_value = baseline.get("matrix_element")
+    if (
+        isinstance(candidate_value, bool)
+        or not isinstance(candidate_value, (int, float))
+        or isinstance(baseline_value, bool)
+        or not isinstance(baseline_value, (int, float))
+    ):
+        return False
+    try:
+        _audit_pointwise(
+            pointwise,
+            context=f"{cell.cell_id}.validation.pointwise",
+            expected_candidate=float(candidate_value),
+            expected_baseline=float(baseline_value),
+            expected_relative_tolerance=_expected_pointwise_tolerance(cell),
+            expected_point_digest=(
+                _measurement_validation_point_digest(
+                    measurement,
+                    context=cell.cell_id,
+                )
+                if pointwise.get("abi") == CONDITIONED_COMPARISON_ABI
+                else None
+            ),
+        )
+    except FinalAuditError:
+        return False
+    return True
+
+
+def _stored_independent_pointwise_matches_baseline(
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    baseline_cell: CellSpec,
+    baseline: Mapping[str, object],
+) -> bool:
+    """Authenticate the stored comparison against its selected authority.
+
+    Authorities compare matrix elements and use the ordinary pointwise audit.
+    The retained Original-AmpliCol LC all-flow diagnostic authenticates only
+    the common selector component; its aggregate is never a candidate
+    baseline.
+    """
+
+    validation = measurement.get("validation")
+    pointwise = validation.get("pointwise") if isinstance(validation, Mapping) else None
+    if not isinstance(pointwise, Mapping):
+        return False
+    if pointwise.get("abi") == CONDITIONED_COMPARISON_ABI:
+        try:
+            canonical = conditioned_measurement_comparison(
+                cell,
+                measurement,
+                baseline,
+            )
+        except (RuntimeError, TypeError, ValueError):
+            return False
+        return dict(pointwise) == canonical
+
+    try:
+        component_only = baseline_uses_lc_common_component_authority(
+            cell,
+            baseline,
+        )
+    except (RuntimeError, ValueError):
+        return False
+    if not component_only:
+        return _stored_pointwise_matches_baseline(cell, measurement, baseline)
+    if measurement.get("selector_contract") != baseline.get("selector_contract"):
+        return False
+    baseline_validation = baseline.get("validation")
+    if not isinstance(validation, Mapping) or not isinstance(
+        baseline_validation,
+        Mapping,
+    ):
+        return False
+    candidate_component = validation.get(LC_COMMON_COMPONENT_FIELD)
+    baseline_component = baseline_validation.get(LC_COMMON_COMPONENT_FIELD)
+    if not isinstance(candidate_component, Mapping) or not isinstance(
+        baseline_component,
+        Mapping,
+    ):
+        return False
+    try:
+        candidate_value = _audit_lc_common_component(
+            cell,
+            measurement,
+            context=cell.cell_id,
+        )
+        baseline_value = _audit_lc_common_component(
+            baseline_cell,
+            baseline,
+            context=baseline_cell.cell_id,
+        )
+        component_identity = {
+            "candidate_cell_id": candidate_component.get("cell_id"),
+            "baseline_cell_id": baseline_component.get("cell_id"),
+            "point_digest": candidate_component.get("point_digest"),
+            "helicity_ids": candidate_component.get("helicity_ids"),
+            "color_flow_ids": candidate_component.get("color_flow_ids"),
+        }
+        if any(
+            candidate_component.get(field) != baseline_component.get(field)
+            for field in ("point_digest", "helicity_ids", "color_flow_ids")
+        ):
+            return False
+        selector_identity = {
+            "cell_id": cell.cell_id,
+            "accuracy": cell.measurement.accuracy.value,
+            "workload": cell.workload.value,
+            "selector_contract": measurement.get("selector_contract"),
+            "value_kind": LC_COMMON_COMPONENT_FIELD,
+            "component_identity": component_identity,
+        }
+        _audit_pointwise(
+            validation.get("pointwise"),
+            context=f"{cell.cell_id}.validation.pointwise",
+            expected_candidate=candidate_value,
+            expected_baseline=baseline_value,
+            expected_relative_tolerance=_expected_pointwise_tolerance(cell),
+            expected_point_digest=_measurement_validation_point_digest(
+                measurement,
+                context=cell.cell_id,
+            ),
+            expected_candidate_source_sha256=digest_json(candidate_component),
+            expected_baseline_source_sha256=digest_json(baseline_component),
+            expected_selector_identity=selector_identity,
+        )
+    except (FinalAuditError, RuntimeError, TypeError, ValueError):
+        return False
+    return True
+
+
+def _stored_legacy_component_matches_baseline(
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    baseline_cell: CellSpec,
+    baseline: Mapping[str, object],
+) -> bool:
+    record = _stored_direct_agreement(
+        measurement,
+        edge_kind=LC_LEGACY_PYAMPLICOL_COMPONENT,
+        baseline_cell_id=baseline_cell.cell_id,
+    )
+    if (
+        record is None
+        or baseline.get("status") != ResultStatus.OK.value
+        or measurement.get("selector_contract") != baseline.get("selector_contract")
+    ):
+        return False
+    edge = AgreementEdge(LC_LEGACY_PYAMPLICOL_COMPONENT, baseline_cell, cell)
+    try:
+        _audit_pointwise(
+            record,
+            context=f"{cell.cell_id}.validation.{DIRECT_AGREEMENT_FIELD}",
+            expected_candidate=_agreement_value(
+                edge,
+                cell,
+                measurement,
+                context=cell.cell_id,
+            ),
+            expected_baseline=_agreement_value(
+                edge,
+                baseline_cell,
+                baseline,
+                context=baseline_cell.cell_id,
+            ),
+            expected_relative_tolerance=edge.relative_tolerance,
+            expected_point_digest=(
+                _measurement_validation_point_digest(
+                    measurement,
+                    context=cell.cell_id,
+                )
+                if record.get("abi") == DIRECT_AGREEMENT_V2_ABI
+                else None
+            ),
+        )
+    except FinalAuditError:
+        return False
+    return True
+
+
+def _audit_direct_agreements(
+    cells: Sequence[CellSpec],
+    measurements: Mapping[str, Mapping[str, object]],
+    *,
+    catalog: ReportCatalog,
+) -> tuple[tuple[AgreementEdge, ...], dict[str, int]]:
+    """Authenticate every stored direct edge and reject missing or extra ones."""
+
+    selected_ids = {cell.cell_id for cell in cells}
+    allowed_edges = tuple(
+        edge
+        for edge in agreement_edges(catalog=catalog)
+        if edge.candidate.cell_id in selected_ids
+        and (not edge.required or edge.baseline.cell_id in measurements)
+    )
+    incoming: dict[str, list[AgreementEdge]] = defaultdict(list)
+    for edge in allowed_edges:
+        incoming[edge.candidate.cell_id].append(edge)
+
+    errors: list[str] = []
+    audited_edges: list[AgreementEdge] = []
+    for cell in cells:
+        measurement = measurements[cell.cell_id]
+        validation = _mapping(
+            measurement.get("validation"),
+            f"{cell.cell_id}.validation",
+        )
+        raw_records = validation.get(DIRECT_AGREEMENT_FIELD)
+        if not isinstance(raw_records, list):
+            errors.append(
+                f"{cell.cell_id}: validation.{DIRECT_AGREEMENT_FIELD} is not an array"
+            )
+            continue
+        allowed = tuple(
+            sorted(
+                incoming.get(cell.cell_id, ()),
+                key=lambda edge: (edge.kind, edge.baseline.cell_id),
+            )
+        )
+        required = tuple(edge for edge in allowed if edge.required)
+        records_by_key: dict[tuple[str, str], Mapping[str, object]] = {}
+        for index, raw_record in enumerate(raw_records):
+            if not isinstance(raw_record, Mapping):
+                errors.append(
+                    f"{cell.cell_id}: direct agreement {index} is not an object"
+                )
+                continue
+            key = (
+                str(raw_record.get("edge_kind")),
+                str(raw_record.get("baseline_cell_id")),
+            )
+            if key in records_by_key:
+                errors.append(f"{cell.cell_id}: duplicate direct agreement {key!r}")
+            records_by_key[key] = raw_record
+        required_keys = {(edge.kind, edge.baseline.cell_id) for edge in required}
+        allowed_keys = {(edge.kind, edge.baseline.cell_id) for edge in allowed}
+        observed_keys = set(records_by_key)
+        if not required_keys.issubset(observed_keys) or not (
+            observed_keys <= allowed_keys
+        ):
+            errors.append(
+                f"{cell.cell_id}: direct agreement edge set differs; "
+                f"required={sorted(required_keys)}, "
+                f"allowed={sorted(allowed_keys)}, "
+                f"observed={sorted(observed_keys)}"
+            )
+            continue
+        for edge in allowed:
+            key = (edge.kind, edge.baseline.cell_id)
+            if key not in records_by_key:
+                assert not edge.required
+                continue
+            context = f"{cell.cell_id}.validation.{DIRECT_AGREEMENT_FIELD}[{edge.kind}]"
+            record = records_by_key[key]
+            baseline_measurement = measurements.get(edge.baseline.cell_id)
+            if (
+                record.get("abi")
+                not in {DIRECT_AGREEMENT_V2_ABI, DIRECT_AGREEMENT_V1_ABI}
+                or record.get("edge_kind") != edge.kind
+                or record.get("value_kind") != edge.value_kind
+                or record.get("baseline_cell_id") != edge.baseline.cell_id
+                or record.get("candidate_cell_id") != edge.candidate.cell_id
+            ):
+                errors.append(f"{context}: edge identity differs from the catalog")
+                continue
+            try:
+                candidate_value = _agreement_value(
+                    edge,
+                    edge.candidate,
+                    measurement,
+                    context=edge.candidate.cell_id,
+                )
+                stored_baseline = _finite_number(
+                    record.get("baseline"),
+                    f"{context}.baseline",
+                )
+                current_baseline: float | None = None
+                if (
+                    baseline_measurement is not None
+                    and baseline_measurement.get("status") == ResultStatus.OK.value
+                    and measurement.get("selector_contract")
+                    == baseline_measurement.get("selector_contract")
+                ):
+                    current_baseline = _agreement_value(
+                        edge,
+                        edge.baseline,
+                        baseline_measurement,
+                        context=edge.baseline.cell_id,
+                    )
+                if edge.required and current_baseline is None:
+                    raise FinalAuditError(
+                        f"{context}: required baseline is not a successful "
+                        "selector-compatible current"
+                    )
+                if (
+                    record.get("abi") == DIRECT_AGREEMENT_V2_ABI
+                    and current_baseline is not None
+                    and baseline_measurement is not None
+                ):
+                    expected_record = direct_agreement_record(
+                        edge,
+                        candidate_measurement=measurement,
+                        baseline_measurement=baseline_measurement,
+                    )
+                    if dict(record) != expected_record:
+                        raise FinalAuditError(
+                            f"{context}: conditioned scale/source binding differs "
+                            "from the current candidate and authority"
+                        )
+                _audit_pointwise(
+                    record,
+                    context=context,
+                    expected_candidate=candidate_value,
+                    expected_baseline=(
+                        current_baseline
+                        if edge.required
+                        or (
+                            current_baseline is not None
+                            and _same_float(current_baseline, stored_baseline)
+                        )
+                        else stored_baseline
+                    ),
+                    expected_relative_tolerance=edge.relative_tolerance,
+                    expected_point_digest=(
+                        _measurement_validation_point_digest(
+                            measurement,
+                            context=edge.candidate.cell_id,
+                        )
+                        if record.get("abi") == DIRECT_AGREEMENT_V2_ABI
+                        else None
+                    ),
+                    require_success=(edge.kind != LC_LEGACY_PYAMPLICOL_COMPONENT),
+                )
+                audited_edges.append(edge)
+            except Exception as error:
+                errors.append(f"{context}: {error}")
+
+    for cell in cells:
+        measurement = measurements[cell.cell_id]
+        validation = _mapping(
+            measurement.get("validation"),
+            f"{cell.cell_id}.validation",
+        )
+        if cell.measurement.accuracy is Accuracy.LC:
+            try:
+                _audit_lc_common_component(
+                    cell,
+                    measurement,
+                    context=cell.cell_id,
+                )
+            except Exception as error:
+                errors.append(f"{cell.cell_id}: {error}")
+        elif validation.get(LC_COMMON_COMPONENT_FIELD) is not None:
+            errors.append(
+                f"{cell.cell_id}: contracted-color cell stores an LC component"
+            )
+    if errors:
+        rendered = "\n".join(f"- {message}" for message in errors[:50])
+        suffix = (
+            ""
+            if len(errors) <= 50
+            else f"\n- ... and {len(errors) - 50} additional failures"
+        )
+        raise FinalAuditError(
+            f"final report direct-agreement audit failed ({len(errors)}):\n"
+            f"{rendered}{suffix}"
+        )
+    counts = Counter(edge.kind for edge in audited_edges)
+    return tuple(audited_edges), {
+        kind: counts.get(kind, 0)
+        for kind in (
+            BUILTIN_UFO_RECURRENCE,
+            Z_RECURRENCE_CROSS_MODE,
+            LC_CROSS_LAYOUT_COMPONENT,
+            LC_LEGACY_PYAMPLICOL_COMPONENT,
+            MADGRAPH_FULL_COLOUR,
+        )
+    }
+
+
+def _runtime_namespace_paths(
+    expected_checkout: Path,
+    *,
+    search_path: Sequence[str] | None = None,
+) -> tuple[tuple[Path, ...], Path]:
+    """Resolve source-first roots and only the first native-bearing candidate."""
+
+    try:
+        checkout = expected_checkout.expanduser().resolve(strict=True)
+        source_package = (checkout / "src" / "pyamplicol").resolve(strict=True)
+    except OSError as error:
+        raise FinalAuditError(
+            "cannot resolve the expected source pyamplicol package"
+        ) from error
+    if not source_package.is_dir():
+        raise FinalAuditError(
+            "expected checkout has no source pyamplicol package directory"
+        )
+    entries = tuple(sys.path if search_path is None else search_path)
+    native_package: Path | None = None
+    native_extension: Path | None = None
+    for raw_entry in entries:
+        try:
+            entry = Path(raw_entry or os.getcwd()).expanduser().resolve(strict=True)
+            candidate = (entry / "pyamplicol").resolve(strict=True)
+        except OSError:
+            continue
+        if not candidate.is_dir():
+            continue
+        matches = tuple(
+            path
+            for path in candidate.iterdir()
+            if path.is_file()
+            and path.name.startswith("_rusticol")
+            and path.name.endswith(tuple(EXTENSION_SUFFIXES))
+        )
+        if not matches:
+            continue
+        try:
+            native = native_extension_in_package(candidate)
+        except RuntimeEvidenceError as error:
+            raise FinalAuditError(
+                "native-bearing pyamplicol candidate is ambiguous"
+            ) from error
+        native_package = candidate
+        native_extension = native
+        break
+    if native_package is None or native_extension is None:
+        raise FinalAuditError(
+            "no native-bearing pyamplicol candidate exists on the original "
+            "Python search path"
+        )
+    roots = (
+        (source_package,)
+        if native_package == source_package
+        else (source_package, native_package)
+    )
+    return roots, native_extension
+
+
+def _prepare_exact_pyamplicol_namespace(
+    expected_checkout: Path,
+) -> tuple[object, tuple[Path, ...], Path, Mapping[str, object]]:
+    """Authenticate and establish the exact source/native namespace."""
+
+    package_roots, expected_native = _runtime_namespace_paths(expected_checkout)
+    already_loaded = any(
+        name == "pyamplicol" or name.startswith("pyamplicol.") for name in sys.modules
+    )
+    try:
+        if already_loaded:
+            preimport_identity = established_preimport_runtime_identity()
+        else:
+            preimport_identity = preimport_python_runtime_identity(
+                package_roots,
+                native_extension=expected_native,
+            )
+    except RuntimeEvidenceError as error:
+        raise FinalAuditError(
+            "pyamplicol runtime was not authenticated before import"
+        ) from error
+
+    source_parent = str(package_roots[0].parent)
+    sys.path[:] = [
+        source_parent,
+        *(entry for entry in sys.path if entry != source_parent),
+    ]
+    pyamplicol = importlib.import_module("pyamplicol")
+    try:
+        package_origin = Path(str(pyamplicol.__file__)).resolve(strict=True)
+    except OSError as error:
+        raise FinalAuditError(
+            "loaded pyamplicol package origin cannot be resolved"
+        ) from error
+    if package_origin.parent != package_roots[0]:
+        raise FinalAuditError(
+            "loaded pyamplicol package does not originate in the expected checkout"
+        )
+    pyamplicol.__path__ = [str(root) for root in package_roots]
+    return pyamplicol, package_roots, expected_native, preimport_identity
+
+
+def _active_runtime_snapshot(
+    expected_source_revision: str,
+    *,
+    expected_checkout: Path,
+) -> dict[str, object]:
+    """Resolve the active candidate wheel/native identity once for the audit."""
+
+    (
+        pyamplicol,
+        package_roots,
+        expected_native,
+        preimport_identity,
+    ) = _prepare_exact_pyamplicol_namespace(expected_checkout)
+    from pyamplicol._internal.versions import (
+        _active_build_info,
+        verify_native_module,
+    )
+
+    native = importlib.import_module("pyamplicol._rusticol")
+    verify_native_module(native)
+    build_info = _mapping(
+        _active_build_info(), "active pyamplicol candidate build identity"
+    )
+    fields = (
+        "schema_version",
+        "version",
+        "candidate_fingerprint",
+        "source_revision",
+        "source_checkout",
+        "native_build_inputs_sha256",
+        "publishable",
+    )
+    candidate = {field: build_info.get(field) for field in fields}
+    native_digest = native.native_build_inputs_sha256()
+    native_version = str(native.package_version())
+    source_checkout = candidate["source_checkout"]
+    try:
+        checkout_matches = isinstance(source_checkout, str) and Path(
+            source_checkout
+        ).expanduser().resolve(strict=True) == expected_checkout.resolve(strict=True)
+    except OSError:
+        checkout_matches = False
+    if (
+        candidate["source_revision"] != expected_source_revision
+        or candidate["publishable"] is not False
+        or candidate["native_build_inputs_sha256"] != native_digest
+        or candidate["version"] != pyamplicol.__version__
+        or native_version.replace("-dev.", ".dev") != pyamplicol.__version__
+        or not checkout_matches
+        or not isinstance(native_digest, str)
+        or _SHA256_RE.fullmatch(native_digest) is None
+        or any(candidate[field] is None for field in fields)
+    ):
+        raise FinalAuditError(
+            "active candidate/native runtime is not bound to the expected final SHA"
+        )
+    native_path = Path(str(native.__file__)).resolve(strict=True)
+    if native_path != expected_native:
+        raise FinalAuditError(
+            "imported native extension is not the first eligible candidate"
+        )
+    package_tree = _python_package_tree_identity(package_roots)
+    expected_package_tree = _mapping(
+        preimport_identity.get("python_package_tree"),
+        "preimport runtime identity.python_package_tree",
+    )
+    expected_native_identity = _mapping(
+        preimport_identity.get("native_extension"),
+        "preimport runtime identity.native_extension",
+    )
+    if preimport_identity.get(
+        "kind"
+    ) != "pyamplicol-preimport-runtime-identity-v1" or dict(package_tree) != dict(
+        expected_package_tree
+    ):
+        raise FinalAuditError(
+            "active pyamplicol package differs from its preimport identity"
+        )
+    try:
+        loaded_origin_policy = loaded_pyamplicol_origin_policy(
+            package_roots,
+            native_extension=native_path,
+            expected_package_identity=dict(expected_package_tree),
+            expected_native_identity=dict(expected_native_identity),
+        )
+    except RuntimeEvidenceError as error:
+        raise FinalAuditError(
+            "loaded pyamplicol module origins cannot be authenticated"
+        ) from error
+    target = native.target_info()
+    return {
+        "package_version": pyamplicol.__version__,
+        "python_package_tree": package_tree,
+        "loaded_module_origin_policy": loaded_origin_policy,
+        "candidate_build_identity": candidate,
+        "candidate_build_identity_sha256": digest_json(candidate),
+        "native_build_inputs_sha256": native_digest,
+        "native_extension": {
+            "path": str(native_path),
+            "sha256": _sha256_file(native_path),
+            "package_version": native_version,
+        },
+        "native_target": {
+            "triple": str(target.triple),
+            "cpu_features": [str(value) for value in target.cpu_features],
+        },
+    }
+
+
+def _audit_active_runtime(
+    expected_source_revision: str,
+    expected_checkout: Path,
+) -> Mapping[str, object]:
+    return _active_runtime_snapshot(
+        expected_source_revision,
+        expected_checkout=expected_checkout,
+    )
+
+
+def _git_checked(
+    repo_root: Path,
+    arguments: Sequence[str],
+    *,
+    timeout: float = 30.0,
+) -> bytes:
+    try:
+        completed = subprocess.run(
+            ("git", *arguments),
+            cwd=repo_root,
+            check=False,
+            capture_output=True,
+            timeout=timeout,
+        )
+    except (OSError, subprocess.SubprocessError) as error:
+        raise FinalAuditError(
+            "cannot authenticate report publication Git history"
+        ) from error
+    if completed.returncode != 0:
+        detail = completed.stderr.decode("utf-8", errors="replace").strip()
+        raise FinalAuditError(
+            "cannot authenticate report publication Git history: "
+            f"git {' '.join(arguments)} failed" + (f": {detail}" if detail else "")
+        )
+    return completed.stdout
+
+
+def _publication_relative_member(path: str) -> PurePosixPath | None:
+    """Return an allowed report member, rejecting executable/source paths."""
+
+    logical = PurePosixPath(path)
+    if (
+        not logical.parts
+        or logical.is_absolute()
+        or logical.as_posix() != path
+        or any(part in {"", ".", ".."} for part in logical.parts)
+    ):
+        return None
+    parts = logical.parts
+    if parts[:3] == ("src", "pyamplicol", "_profiling_campaign"):
+        root_length = 3
+    elif parts[:2] == ("docs", "performance_reports"):
+        if (
+            len(parts) < 4
+            or _REPORT_PROFILE_RE.fullmatch(parts[2]) is None
+            or ".." in parts[2]
+        ):
+            return None
+        root_length = 3
+    else:
+        return None
+    relative = PurePosixPath(*parts[root_length:])
+    relative_parts = relative.parts
+    if not relative_parts:
+        return None
+    if relative_parts[0] == "results":
+        return (
+            relative
+            if (
+                len(relative_parts) == 2
+                and _PUBLICATION_MEMBER_RE.fullmatch(relative_parts[1]) is not None
+                and relative_parts[1].endswith(".json")
+            )
+            else None
+        )
+    if len(relative_parts) != 1:
+        return None
+    name = relative_parts[0]
+    if _PUBLICATION_MEMBER_RE.fullmatch(name) is None:
+        return None
+    if name in {
+        "README.md",
+        "architecture-profile.json",
+        "architecture_profile.json",
+        "final-audit.json",
+        "pyAmpliCol.pdf",
+        "pyAmpliCol.tex",
+        "report-manifest.json",
+        "report-workspace.json",
+        "report_environment.json",
+        "report_environment.tex",
+    }:
+        return relative
+    if name.endswith(".manifest.json"):
+        return relative
+    if name.endswith(".md"):
+        return relative
+    if name.startswith("section_") and name.endswith(".tex"):
+        return relative
+    if name.startswith("result_") and name.endswith("_table.tex"):
+        return relative
+    return None
+
+
+def _git_tree_entry(
+    repo_root: Path,
+    revision: str,
+    path: str,
+) -> tuple[str, str] | None:
+    payload = _git_checked(
+        repo_root,
+        ("ls-tree", "-z", revision, "--", path),
+    )
+    if not payload:
+        return None
+    records = tuple(record for record in payload.split(b"\0") if record)
+    if len(records) != 1:
+        raise FinalAuditError(
+            f"publication path {path!r} is ambiguous in Git tree {revision}"
+        )
+    try:
+        metadata, observed_path = records[0].split(b"\t", 1)
+        mode, kind, _object_id = metadata.decode("ascii").split(" ", 2)
+        decoded_path = os.fsdecode(observed_path)
+    except (UnicodeDecodeError, ValueError) as error:
+        raise FinalAuditError(
+            f"publication path {path!r} has malformed Git tree metadata"
+        ) from error
+    if decoded_path != path:
+        raise FinalAuditError(
+            f"publication path {path!r} does not match its Git tree entry"
+        )
+    return mode, kind
+
+
+def _require_nonexecutable_publication_blob(
+    repo_root: Path,
+    revision: str,
+    path: str,
+) -> None:
+    entry = _git_tree_entry(repo_root, revision, path)
+    if entry is None:
+        return
+    mode, kind = entry
+    if mode != "100644" or kind != "blob":
+        raise FinalAuditError(
+            f"publication path {path!r} is executable, a symlink, or not a file"
+        )
+
+
+def _publication_diff(
+    repo_root: Path,
+    measurement_source_revision: str,
+    publication_revision: str,
+) -> tuple[dict[str, str], ...]:
+    payload = _git_checked(
+        repo_root,
+        (
+            "diff",
+            "--name-status",
+            "--no-renames",
+            "-z",
+            measurement_source_revision,
+            publication_revision,
+            "--",
+        ),
+        timeout=120.0,
+    )
+    fields = tuple(field for field in payload.split(b"\0") if field)
+    if len(fields) % 2:
+        raise FinalAuditError("publication Git diff has malformed name-status data")
+    changes: list[dict[str, str]] = []
+    for offset in range(0, len(fields), 2):
+        try:
+            status = fields[offset].decode("ascii")
+            path = os.fsdecode(fields[offset + 1])
+        except UnicodeDecodeError as error:
+            raise FinalAuditError(
+                "publication Git diff contains invalid metadata"
+            ) from error
+        if status not in {"A", "D", "M"}:
+            raise FinalAuditError(
+                f"publication Git diff has unsupported status {status!r} for {path!r}"
+            )
+        if _publication_relative_member(path) is None:
+            raise FinalAuditError(
+                "publication descendant changes a path outside the explicit "
+                f"non-executable report allowlist: {path!r}"
+            )
+        if status != "A":
+            _require_nonexecutable_publication_blob(
+                repo_root,
+                measurement_source_revision,
+                path,
+            )
+        if status != "D":
+            _require_nonexecutable_publication_blob(
+                repo_root,
+                publication_revision,
+                path,
+            )
+        changes.append({"status": status, "path": path})
+    return tuple(changes)
+
+
+def _report_publication_lineage(
+    repo_root: Path,
+    measurement_source_revision: str,
+) -> dict[str, object]:
+    """Authenticate a clean report-only descendant of one measured SHA."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    if _GIT_SHA_RE.fullmatch(measurement_source_revision) is None:
+        raise FinalAuditError("measurement source revision must be a full Git SHA")
+    publication_revision = (
+        _git_checked(
+            root,
+            ("rev-parse", "--verify", "HEAD^{commit}"),
+        )
+        .decode("ascii")
+        .strip()
+    )
+    if _GIT_SHA_RE.fullmatch(publication_revision) is None:
+        raise FinalAuditError("publication revision is not a full Git SHA")
+    _git_checked(
+        root,
+        ("cat-file", "-e", f"{measurement_source_revision}^{{commit}}"),
+    )
+    status = _git_checked(
+        root,
+        ("status", "--porcelain=v1", "-z", "--untracked-files=all"),
+    )
+    if status:
+        raise FinalAuditError(
+            "publication checkout must be completely clean, including report outputs"
+        )
+    ancestor = subprocess.run(
+        (
+            "git",
+            "merge-base",
+            "--is-ancestor",
+            measurement_source_revision,
+            publication_revision,
+        ),
+        cwd=root,
+        check=False,
+        capture_output=True,
+        timeout=30,
+    )
+    if ancestor.returncode not in {0, 1}:
+        raise FinalAuditError("cannot authenticate measurement/publication ancestry")
+    if ancestor.returncode != 0:
+        raise FinalAuditError(
+            "publication revision is not a descendant of the measurement "
+            "source revision"
+        )
+    changes = _publication_diff(
+        root,
+        measurement_source_revision,
+        publication_revision,
+    )
+    same_revision = publication_revision == measurement_source_revision
+    if not same_revision and not changes:
+        raise FinalAuditError(
+            "later publication revision has no report-only publication diff"
+        )
+    return {
+        "kind": _PUBLICATION_LINEAGE_KIND,
+        "schema_version": 1,
+        "measurement_source_revision": measurement_source_revision,
+        "publication_revision": publication_revision,
+        "relationship": ("same-commit" if same_revision else "report-only-descendant"),
+        "worktree_clean": True,
+        "changed_path_count": len(changes),
+        "changed_paths": list(changes),
+        "changed_paths_sha256": digest_json(list(changes)),
+        "allowed_path_contract": (
+            "src/pyamplicol/_profiling_campaign or "
+            "docs/performance_reports/PROFILE roots: "
+            "results/*.json, generated table TeX, report TeX/Markdown/PDF, "
+            "architecture metadata, and report manifests; regular "
+            "non-executable blobs only"
+        ),
+        "executable_source_unchanged": True,
+    }
+
+
+def _require_report_source_checkout(
+    repo_root: Path,
+    expected_source_revision: str,
+) -> Mapping[str, object]:
+    return _report_publication_lineage(repo_root, expected_source_revision)
+
+
+def _active_report_profile(repo_root: Path, service: ReportService) -> str:
+    root = repo_root.expanduser().resolve(strict=False)
+    if service.paths.repo_root.resolve(strict=False) != root:
+        raise FinalAuditError(
+            "final-audit report service belongs to a different repository"
+        )
+    profile_root = root / "docs" / "performance_reports"
+    try:
+        relative = service.paths.docs_dir.resolve(strict=False).relative_to(
+            profile_root
+        )
+    except ValueError as error:
+        raise FinalAuditError(
+            "final-audit requires an architecture-specific report profile"
+        ) from error
+    if len(relative.parts) != 1:
+        raise FinalAuditError(
+            "final-audit report workspace is not one architecture profile"
+        )
+    if service.paths.results_dir.resolve(strict=False) != (
+        service.paths.docs_dir.resolve(strict=False) / "results"
+    ):
+        raise FinalAuditError(
+            "final-audit report results are not inside the active profile"
+        )
+    try:
+        return validate_profile_name(relative.parts[0])
+    except ValueError as error:
+        raise FinalAuditError("final-audit report profile is invalid") from error
+
+
+def _profile_publication_lineage(
+    repo_root: Path,
+    measurement_source_revision: str,
+    *,
+    profile: str,
+) -> dict[str, object]:
+    """Authenticate a clean descendant limited to one active report profile."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    status = _git_checked(
+        root,
+        ("status", "--porcelain=v1", "-z", "--untracked-files=all"),
+    )
+    if status:
+        raise FinalAuditError(
+            "publication checkout must be completely clean, including report outputs"
+        )
+    try:
+        identity = require_report_only_publication(
+            root,
+            measured_revision=measurement_source_revision,
+            profile=profile,
+            publication_revision="HEAD",
+        )
+    except ReportSourceIdentityError as error:
+        raise FinalAuditError(str(error)) from error
+    same_revision = identity.publication_revision == identity.measured_revision
+    changes = list(identity.changed_paths)
+    if not same_revision and not changes:
+        raise FinalAuditError(
+            "later publication revision has no report-only publication diff"
+        )
+    return {
+        "kind": _PUBLICATION_LINEAGE_KIND,
+        "schema_version": 1,
+        "measurement_source_revision": identity.measured_revision,
+        "measurement_source_tree": identity.measured_tree,
+        "publication_revision": identity.publication_revision,
+        "publication_tree": identity.publication_tree,
+        "report_profile": profile,
+        "relationship": ("same-commit" if same_revision else "report-only-descendant"),
+        "worktree_clean": True,
+        "changed_path_count": len(changes),
+        "changed_paths": changes,
+        "changed_paths_sha256": digest_json(changes),
+        "allowed_path_contract": (
+            f"docs/performance_reports/{profile}/results/*.json, generated "
+            "environment JSON/TeX, table/summary TeX, and pyAmpliCol.pdf; "
+            "regular non-executable blobs only"
+        ),
+        "executable_source_unchanged": True,
+    }
+
+
+def _validated_publication_lineage(
+    value: Mapping[str, object] | None,
+    *,
+    measurement_source_revision: str,
+    expected_publication_revision: str | None,
+    expected_profile: str | None = None,
+) -> dict[str, object]:
+    if value is None:
+        # Injectable source auditors used by focused unit tests predate the
+        # lineage return value. Production always uses the fail-closed auditor.
+        result: dict[str, object] = {
+            "kind": _PUBLICATION_LINEAGE_KIND,
+            "schema_version": 1,
+            "measurement_source_revision": measurement_source_revision,
+            "measurement_source_tree": None,
+            "publication_revision": measurement_source_revision,
+            "publication_tree": None,
+            "report_profile": expected_profile,
+            "relationship": "same-commit",
+            "worktree_clean": True,
+            "changed_path_count": 0,
+            "changed_paths": [],
+            "changed_paths_sha256": digest_json([]),
+            "allowed_path_contract": "injected source auditor",
+            "executable_source_unchanged": True,
+        }
+    else:
+        result = dict(value)
+    publication_revision = result.get("publication_revision")
+    changes = result.get("changed_paths")
+    changed_count = result.get("changed_path_count")
+    if (
+        result.get("kind") != _PUBLICATION_LINEAGE_KIND
+        or result.get("schema_version") != 1
+        or result.get("measurement_source_revision") != measurement_source_revision
+        or not isinstance(publication_revision, str)
+        or _GIT_SHA_RE.fullmatch(publication_revision) is None
+        or result.get("relationship") not in {"same-commit", "report-only-descendant"}
+        or result.get("worktree_clean") is not True
+        or result.get("executable_source_unchanged") is not True
+        or isinstance(changes, (str, bytes))
+        or not isinstance(changes, Sequence)
+        or isinstance(changed_count, bool)
+        or not isinstance(changed_count, int)
+        or changed_count != len(changes)
+        or result.get("changed_paths_sha256") != digest_json(list(changes))
+    ):
+        raise FinalAuditError("source auditor returned invalid publication lineage")
+    if expected_profile is not None and (
+        result.get("report_profile") != expected_profile
+        or not isinstance(result.get("measurement_source_tree"), str)
+        or _GIT_SHA_RE.fullmatch(str(result["measurement_source_tree"])) is None
+        or not isinstance(result.get("publication_tree"), str)
+        or _GIT_SHA_RE.fullmatch(str(result["publication_tree"])) is None
+    ):
+        raise FinalAuditError(
+            "source auditor returned a lineage for the wrong report profile or tree"
+        )
+    if (
+        expected_publication_revision is not None
+        and publication_revision != expected_publication_revision
+    ):
+        raise FinalAuditError(
+            "publication checkout HEAD does not equal the explicitly expected "
+            "publication revision"
+        )
+    return result
+
+
+def _pdf_text_identity(path: Path) -> dict[str, object]:
+    try:
+        from pypdf import PdfReader
+
+        reader = PdfReader(path)
+        if reader.is_encrypted:
+            raise FinalAuditError("report PDF is unexpectedly encrypted")
+        pages = [page.extract_text() or "" for page in reader.pages]
+    except ModuleNotFoundError as error:
+        if error.name == "pypdf":
+            raise FinalAuditError(
+                "final PDF audit requires the documentation extra; install "
+                "`pyamplicol[docs]`"
+            ) from error
+        raise
+    except FinalAuditError:
+        raise
+    except Exception as error:
+        raise FinalAuditError(f"cannot extract report PDF text: {path}") from error
+    if not pages or not any(page.strip() for page in pages):
+        raise FinalAuditError("report PDF has no extractable page text")
+    return {
+        "page_count": len(pages),
+        "text_sha256": digest_json(pages),
+        "text_character_count": sum(len(page) for page in pages),
+    }
+
+
+def _pdf_visual_identity(path: Path, output_root: Path) -> dict[str, object]:
+    """Render every page with one Poppler binary and hash the resulting pixels."""
+
+    pdftoppm = shutil.which("pdftoppm")
+    if pdftoppm is None:
+        raise FinalAuditError("pdftoppm is required for the final PDF visual audit")
+    output_root.mkdir(parents=True, exist_ok=False)
+    prefix = output_root / "page"
+    try:
+        completed = subprocess.run(
+            (
+                pdftoppm,
+                "-png",
+                "-r",
+                "96",
+                str(path),
+                str(prefix),
+            ),
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=900,
+        )
+    except subprocess.TimeoutExpired as error:
+        raise FinalAuditError(f"PDF rendering timed out: {path}") from error
+    if completed.returncode != 0:
+        tail = "\n".join(
+            (*completed.stdout.splitlines(), *completed.stderr.splitlines())[-40:]
+        )
+        raise FinalAuditError(
+            f"PDF rendering failed with exit {completed.returncode}: {path}\n{tail}"
+        )
+    pages = sorted(output_root.glob("page-*.png"))
+    if not pages:
+        raise FinalAuditError(f"PDF rendering produced no pages: {path}")
+    page_hashes = [_sha256_file(page) for page in pages]
+    return {
+        "page_count": len(page_hashes),
+        "page_pixel_sha256": digest_json(page_hashes),
+    }
+
+
+def _tex_without_comments(source: str) -> str:
+    return re.sub(r"(?<!\\)%[^\n]*", "", source)
+
+
+def _audit_tex_table_reachability(
+    master_tex: Path,
+    canonical_tables: Sequence[Path],
+) -> dict[str, object]:
+    """Require every rendered table to be reachable from the PDF master."""
+
+    try:
+        master = master_tex.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise FinalAuditError(
+            f"report master TeX is unavailable: {master_tex}"
+        ) from error
+    docs_root = master.parent
+    tables: list[Path] = []
+    for raw_table in canonical_tables:
+        try:
+            table = raw_table.expanduser().resolve(strict=True)
+            table.relative_to(docs_root)
+        except (OSError, ValueError) as error:
+            raise FinalAuditError(
+                f"canonical report table is unavailable or outside docs: {raw_table}"
+            ) from error
+        tables.append(table)
+    if not tables:
+        raise FinalAuditError("report PDF audit has no canonical rendered tables")
+
+    reachable: set[Path] = set()
+    pending = [master]
+    while pending:
+        source = pending.pop()
+        if source in reachable:
+            continue
+        reachable.add(source)
+        try:
+            text = source.read_text(encoding="utf-8")
+        except OSError as error:
+            raise FinalAuditError(
+                f"cannot read reachable report TeX source: {source}"
+            ) from error
+        for match in _TEX_INPUT_RE.finditer(_tex_without_comments(text)):
+            raw_dependency = match.group(1).strip()
+            if not raw_dependency:
+                raise FinalAuditError(f"{source} contains an empty TeX dependency")
+            dependency = source.parent / raw_dependency
+            if dependency.suffix == "":
+                dependency = dependency.with_suffix(".tex")
+            try:
+                dependency = dependency.resolve(strict=True)
+                dependency.relative_to(docs_root)
+            except (OSError, ValueError) as error:
+                raise FinalAuditError(
+                    f"{source} has an unavailable or out-of-tree TeX dependency "
+                    f"{raw_dependency!r}"
+                ) from error
+            pending.append(dependency)
+
+    missing = sorted(
+        table.relative_to(docs_root).as_posix()
+        for table in set(tables).difference(reachable)
+    )
+    if missing:
+        raise FinalAuditError(
+            "canonical rendered tables are not reachable from pyAmpliCol.tex: "
+            + ", ".join(missing)
+        )
+    relative_sources = sorted(
+        source.relative_to(docs_root).as_posix() for source in reachable
+    )
+    return {
+        "master_path": str(master),
+        "reachable_tex_source_count": len(reachable),
+        "reachable_tex_sources_sha256": digest_json(relative_sources),
+        "reachable_table_source_count": len(set(tables)),
+    }
+
+
+def _audit_pdf(service: ReportService) -> dict[str, object]:
+    """Rebuild the PDF and compare both extracted text and rendered pixels."""
+
+    latexmk = shutil.which("latexmk")
+    if latexmk is None:
+        raise FinalAuditError("latexmk is required for the final PDF audit")
+    published = service.paths.docs_dir / "pyAmpliCol.pdf"
+    if not published.is_file() or published.stat().st_size == 0:
+        raise FinalAuditError("published report pyAmpliCol.pdf is missing or empty")
+    rendered_tables = render_all_tables(
+        service.load_caches(),
+        catalog=service.catalog,
+    )
+    table_paths = [service.paths.docs_dir / name for name in sorted(rendered_tables)]
+    tex_dependency_identity = _audit_tex_table_reachability(
+        service.paths.docs_dir / "pyAmpliCol.tex",
+        table_paths,
+    )
+    service.paths.artifact_root.mkdir(parents=True, exist_ok=True)
+    staging = Path(
+        tempfile.mkdtemp(
+            prefix="final-report-pdf-audit-",
+            dir=service.paths.artifact_root,
+        )
+    )
+    try:
+        build_docs = staging / "docs"
+        shutil.copytree(
+            service.paths.docs_dir,
+            build_docs,
+            ignore=_report_source_copy_ignore(
+                service.paths.docs_dir,
+                "*.aux",
+                "*.fdb_latexmk",
+                "*.fls",
+                "*.log",
+                "*.out",
+                "*.toc",
+                "pyAmpliCol.pdf",
+                ".coordination",
+            ),
+        )
+        environment = os.environ.copy()
+        environment.update({"LANG": "C", "LC_ALL": "C", "LC_CTYPE": "C"})
+        completed = subprocess.run(
+            (
+                latexmk,
+                "-pdf",
+                "-interaction=nonstopmode",
+                "-halt-on-error",
+                "-file-line-error",
+                "pyAmpliCol.tex",
+            ),
+            cwd=build_docs,
+            check=False,
+            capture_output=True,
+            text=True,
+            env=environment,
+            timeout=900,
+        )
+        if completed.returncode != 0:
+            tail = "\n".join(
+                (*completed.stdout.splitlines(), *completed.stderr.splitlines())[-80:]
+            )
+            raise FinalAuditError(
+                f"isolated report PDF rebuild failed with exit "
+                f"{completed.returncode}:\n{tail}"
+            )
+        latex_log = build_docs / "pyAmpliCol.log"
+        try:
+            log = latex_log.read_text(encoding="utf-8", errors="replace")
+            validate_latex_log(log)
+        except OSError as error:
+            raise FinalAuditError(
+                f"cannot read isolated report LaTeX log: {error}"
+            ) from error
+        except StandaloneBuildError as error:
+            raise FinalAuditError(str(error)) from error
+        rebuilt = build_docs / "pyAmpliCol.pdf"
+        if not rebuilt.is_file() or rebuilt.stat().st_size == 0:
+            raise FinalAuditError("isolated report PDF rebuild produced no PDF")
+        published_text = _pdf_text_identity(published)
+        rebuilt_text = _pdf_text_identity(rebuilt)
+        if published_text != rebuilt_text:
+            raise FinalAuditError(
+                "published report PDF page text differs from a rebuild of the "
+                "audited caches and tables"
+            )
+        published_visual = _pdf_visual_identity(
+            published,
+            staging / "published-pages",
+        )
+        rebuilt_visual = _pdf_visual_identity(
+            rebuilt,
+            staging / "rebuilt-pages",
+        )
+        if published_visual != rebuilt_visual:
+            raise FinalAuditError(
+                "published report PDF rendered pixels differ from a rebuild of "
+                "the audited caches and tables"
+            )
+        table_identity = {path.name: _sha256_file(path) for path in table_paths}
+        return {
+            "status": ResultStatus.OK.value,
+            "published_path": str(published.resolve(strict=True)),
+            "published_sha256": _sha256_file(published),
+            "rebuilt_sha256": _sha256_file(rebuilt),
+            "normalized_page_text": published_text,
+            "rendered_pages": published_visual,
+            "table_source_count": len(table_identity),
+            "table_sources_sha256": digest_json(table_identity),
+            "master_tex_dependencies": tex_dependency_identity,
+        }
+    except subprocess.TimeoutExpired as error:
+        raise FinalAuditError("isolated report PDF rebuild timed out") from error
+    finally:
+        shutil.rmtree(staging, ignore_errors=True)
+
+
+def _expected_evaluator_abis(cell: CellSpec) -> tuple[str, str]:
+    if cell.measurement.execution_mode is ExecutionMode.COMPILED:
+        if cell.measurement.backend == "jit":
+            return _COMPILED_DIRECT_ABI, _SYMJIT_PLANE_APPLICATION_ABI
+        return _NATIVE_COMPILED_DIRECT_ABI, _NATIVE_COMPILED_DIRECT_ABI
+    if cell.measurement.execution_mode is ExecutionMode.EAGER:
+        source = (
+            _SYMJIT_PLANE_APPLICATION_ABI
+            if cell.measurement.backend == "jit"
+            else _EAGER_NATIVE_APPLICATION_ABI
+        )
+        return _EAGER_DIRECT_BINDING_ABI, source
+    if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY:
+        if cell.measurement.backend != "jit":
+            raise FinalAuditError(
+                "on-the-fly report cells require prepared JIT source evaluators"
+            )
+        return _ON_THE_FLY_EXECUTION_KIND, _SYMJIT_PLANE_APPLICATION_ABI
+    source = (
+        _SYMJIT_PLANE_APPLICATION_ABI
+        if cell.measurement.backend == "jit"
+        else _SOURCE_RUNTIME_CAPABILITY[cell.measurement.backend]
+    )
+    return "pyamplicol-recurrence-runtime-layout-v2", source
+
+
+def _audit_runtime_identity(
+    cell: CellSpec,
+    provenance: Mapping[str, object],
+    *,
+    expected_source_revision: str | None,
+    active_runtime: Mapping[str, object],
+    artifact: ArtifactEvidence | None,
+) -> None:
+    context = f"{cell.cell_id}.provenance.runtime_identity"
+    identity = _mapping(provenance.get("runtime_identity"), context)
+    identity_digest = provenance.get("runtime_identity_sha256")
+    if identity_digest != digest_json(identity):
+        raise FinalAuditError(f"{context} canonical SHA-256 does not match")
+    active_package_tree = _validate_python_package_tree_identity(
+        active_runtime.get("python_package_tree"),
+        context="active_runtime.python_package_tree",
+    )
+    _validate_loaded_origin_policy(
+        active_runtime.get("loaded_module_origin_policy"),
+        context="active_runtime.loaded_module_origin_policy",
+    )
+    _validate_loaded_origin_policy(
+        identity.get("loaded_module_origin_policy"),
+        context=f"{context}.loaded_module_origin_policy",
+    )
+    _audit_runtime_identity_postflight(
+        provenance,
+        identity,
+        context=f"{cell.cell_id}.provenance",
+    )
+    expected_capability = _ARENA_CAPABILITY[cell.measurement.execution_mode]
+    expected_abi, expected_source_abi = _expected_evaluator_abis(cell)
+    expected_source_runtime_capability = _SOURCE_RUNTIME_CAPABILITY.get(
+        cell.measurement.backend
+    )
+    if expected_source_runtime_capability is None:
+        raise FinalAuditError(
+            f"{context} has unsupported backend {cell.measurement.backend!r}"
+        )
+    checks = {
+        "kind": "pyamplicol-report-runtime-identity-v1",
+        "execution_mode": cell.measurement.execution_mode.value,
+        "loaded_execution_mode": cell.measurement.execution_mode.value,
+        "backend": cell.measurement.backend,
+        "required_arena_capability": expected_capability,
+        "expected_evaluator_abi": expected_abi,
+        "expected_source_evaluator_abi": expected_source_abi,
+        "expected_source_evaluator_runtime_capability": (
+            expected_source_runtime_capability
+        ),
+        "source_revision": expected_source_revision,
+        "package_version": active_runtime.get("package_version"),
+        "python_package_tree": active_package_tree,
+        "candidate_build_identity": active_runtime.get("candidate_build_identity"),
+        "candidate_build_identity_sha256": active_runtime.get(
+            "candidate_build_identity_sha256"
+        ),
+        "native_build_inputs_sha256": active_runtime.get("native_build_inputs_sha256"),
+        "native_extension": active_runtime.get("native_extension"),
+        "native_target": active_runtime.get("native_target"),
+    }
+    mismatches = [
+        field for field, expected in checks.items() if identity.get(field) != expected
+    ]
+    source_level_field = "source_jit_optimization_level"
+    direct_level_field = "direct_codegen_optimization_level"
+    if cell.measurement.backend == "jit":
+        source_level = identity.get(source_level_field)
+        if (
+            type(source_level) is not int
+            or source_level != cell.measurement.jit_optimization_level
+        ):
+            mismatches.append(source_level_field)
+    elif source_level_field in identity:
+        mismatches.append(source_level_field)
+    if (
+        cell.measurement.execution_mode is ExecutionMode.COMPILED
+        and cell.measurement.backend == "jit"
+    ):
+        direct_level = identity.get(direct_level_field)
+        if (
+            type(direct_level) is not int
+            or direct_level != cell.measurement.jit_optimization_level
+        ):
+            mismatches.append(direct_level_field)
+        direct_identity = _mapping(
+            identity.get("direct_codegen_identity"),
+            f"{context}.direct_codegen_identity",
+        )
+        if (
+            direct_identity.get("kind")
+            != "authenticated-compiled-plane-arena-direct-codegen-v1"
+            or direct_identity.get("optimization_level")
+            != cell.measurement.jit_optimization_level
+            or direct_identity.get("source_optimization_level")
+            != cell.measurement.jit_optimization_level
+            or type(direct_identity.get("leaf_count")) is not int
+            or int(direct_identity["leaf_count"]) <= 0
+            or not isinstance(direct_identity.get("execution_manifest_path"), str)
+            or not isinstance(direct_identity.get("execution_manifest_sha256"), str)
+            or _SHA256_RE.fullmatch(
+                str(direct_identity.get("execution_manifest_sha256"))
+            )
+            is None
+        ):
+            mismatches.append("direct_codegen_identity")
+    else:
+        if direct_level_field in identity:
+            mismatches.append(direct_level_field)
+        if "direct_codegen_identity" in identity:
+            mismatches.append("direct_codegen_identity")
+    if (
+        cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.backend == "jit"
+    ):
+        source_jit_identity = _mapping(
+            identity.get("source_jit_identity"),
+            f"{context}.source_jit_identity",
+        )
+        if (
+            source_jit_identity.get("kind")
+            != "authenticated-recurrence-direct-template-source-v1"
+            or source_jit_identity.get("optimization_level")
+            != cell.measurement.jit_optimization_level
+            or type(source_jit_identity.get("direct_template_count")) is not int
+            or int(source_jit_identity["direct_template_count"]) <= 0
+            or type(source_jit_identity.get("prepared_direct_template_count"))
+            is not int
+            or int(source_jit_identity["prepared_direct_template_count"]) <= 0
+            or type(source_jit_identity.get("source_evaluator_leaf_count")) is not int
+            or int(source_jit_identity["source_evaluator_leaf_count"]) <= 0
+            or source_jit_identity.get("source_application_abi")
+            != _SYMJIT_PLANE_APPLICATION_ABI
+            or source_jit_identity.get("direct_application_abi")
+            != _RECURRENCE_JIT_DIRECT_APPLICATION_ABI
+            or _SHA256_RE.fullmatch(
+                str(source_jit_identity.get("prepared_kernel_pack_digest"))
+            )
+            is None
+            or _SHA256_RE.fullmatch(
+                str(source_jit_identity.get("direct_template_catalog_digest"))
+            )
+            is None
+            or not isinstance(source_jit_identity.get("execution_manifest_path"), str)
+            or not isinstance(source_jit_identity.get("kernel_pack_path"), str)
+            or not isinstance(source_jit_identity.get("execution_manifest_sha256"), str)
+            or _SHA256_RE.fullmatch(
+                str(source_jit_identity.get("execution_manifest_sha256"))
+            )
+            is None
+            or not isinstance(source_jit_identity.get("kernel_pack_sha256"), str)
+            or _SHA256_RE.fullmatch(str(source_jit_identity.get("kernel_pack_sha256")))
+            is None
+        ):
+            mismatches.append("source_jit_identity")
+    elif "source_jit_identity" in identity:
+        mismatches.append("source_jit_identity")
+    if identity.get("artifact_identity_match") is not True:
+        mismatches.append("artifact_identity_match")
+    if mismatches:
+        raise FinalAuditError(
+            f"{context} differs from the active final runtime: "
+            + ", ".join(sorted(set(mismatches)))
+        )
+    if artifact is None:
+        return
+    _audit_artifact_producer_identity(
+        artifact,
+        expected_source_revision=expected_source_revision,
+        active_runtime=active_runtime,
+    )
+    artifact_checks = {
+        "artifact_id": artifact.artifact_id,
+        "loaded_artifact_id": artifact.artifact_id,
+        "process_id": artifact.process_id,
+        "artifact_runtime_version": artifact.runtime_version,
+        "process_required_runtime_capabilities": list(artifact.runtime_capabilities),
+    }
+    mismatches = []
+    measured_effective = _mapping(
+        provenance.get("effective_config"),
+        f"{cell.cell_id}.provenance.effective_config",
+    )
+    if dict(measured_effective) != dict(artifact.effective_config):
+        mismatches.append("effective_config")
+    if (
+        cell.measurement.execution_mode is ExecutionMode.COMPILED
+        and cell.measurement.backend == "jit"
+    ):
+        direct_identity = _mapping(
+            identity.get("direct_codegen_identity"),
+            f"{context}.direct_codegen_identity",
+        )
+        direct_checks = {
+            "execution_manifest_path": artifact.execution_manifest_path,
+            "execution_manifest_sha256": artifact.execution_manifest_sha256,
+            "leaf_count": artifact.direct_leaf_count,
+        }
+        mismatches.extend(
+            f"direct_codegen_identity.{field}"
+            for field, expected in direct_checks.items()
+            if direct_identity.get(field) != expected
+        )
+    if (
+        cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+        and cell.measurement.backend == "jit"
+    ):
+        source_jit_identity = _mapping(
+            identity.get("source_jit_identity"),
+            f"{context}.source_jit_identity",
+        )
+        if artifact.source_jit_identity is None or dict(source_jit_identity) != dict(
+            artifact.source_jit_identity
+        ):
+            mismatches.append("source_jit_identity")
+    elif artifact.source_jit_identity is not None:
+        mismatches.append("artifact.source_jit_identity")
+    mismatches.extend(
+        field
+        for field, expected in artifact_checks.items()
+        if identity.get(field) != expected
+    )
+    if mismatches:
+        raise FinalAuditError(
+            f"{context} differs from the authenticated artifact: "
+            + ", ".join(mismatches)
+        )
+
+
+def _audit_artifact_producer_identity(
+    artifact: ArtifactEvidence,
+    *,
+    expected_source_revision: str | None,
+    active_runtime: Mapping[str, object],
+) -> None:
+    """Bind artifact production to the measured native runtime identity."""
+
+    candidate = _mapping(
+        active_runtime.get("candidate_build_identity"),
+        "active_runtime.candidate_build_identity",
+    )
+    if candidate.get("source_revision") != expected_source_revision:
+        raise FinalAuditError(
+            "active runtime source revision differs from the measurement source"
+        )
+    checks = {
+        "version": (
+            artifact.producer_version,
+            active_runtime.get("package_version"),
+        ),
+        "git_revision": (
+            artifact.producer_git_revision,
+            expected_source_revision,
+        ),
+        "native_build_inputs_sha256": (
+            artifact.producer_native_build_inputs_sha256,
+            active_runtime.get("native_build_inputs_sha256"),
+        ),
+    }
+    mismatches = [
+        field for field, (observed, expected) in checks.items() if observed != expected
+    ]
+    if mismatches:
+        raise FinalAuditError(
+            "artifact producer differs from the measured runtime: "
+            + ", ".join(mismatches)
+        )
+
+
+def _runtime_for_measurement_source(
+    active_runtime: Mapping[str, object],
+    provenance: Mapping[str, object],
+    *,
+    source_revision: str,
+    measurement_lineage: MeasurementLineage | None,
+) -> Mapping[str, object]:
+    """Project invariant descendant runtime fields onto a retained A identity."""
+
+    if (
+        measurement_lineage is None
+        or source_revision == measurement_lineage.descendant_revision
+    ):
+        return active_runtime
+    if source_revision != measurement_lineage.ancestor_revision:
+        raise FinalAuditError(
+            f"measurement source {source_revision} is outside the source bridge"
+        )
+    identity = _mapping(
+        provenance.get("runtime_identity"),
+        "retained ancestor provenance.runtime_identity",
+    )
+    package_tree = identity.get("python_package_tree")
+    if not isinstance(package_tree, Mapping):
+        raise FinalAuditError(
+            "retained ancestor runtime identity lacks its Python package tree"
+        )
+    candidate = identity.get("candidate_build_identity")
+    candidate_digest = identity.get("candidate_build_identity_sha256")
+    native_extension = identity.get("native_extension")
+    native_target = identity.get("native_target")
+    native_features = (
+        native_target.get("cpu_features")
+        if isinstance(native_target, Mapping)
+        else None
+    )
+    environment = measurement_lineage.environment_for_source(source_revision)
+    if (
+        not isinstance(candidate, Mapping)
+        or candidate.get("source_revision") != source_revision
+        or candidate_digest != digest_json(candidate)
+        or not isinstance(native_extension, Mapping)
+        or not isinstance(native_target, Mapping)
+        or not isinstance(native_features, list)
+        or not all(isinstance(feature, str) for feature in native_features)
+        or environment is None
+        or package_tree.get("sha256") != environment.get("python_package_tree_sha256")
+        or identity.get("package_version") != environment.get("pyamplicol")
+        or candidate.get("candidate_fingerprint")
+        != environment.get("candidate_fingerprint")
+        or candidate.get("native_build_inputs_sha256")
+        != environment.get("native_build_inputs_sha256")
+        or identity.get("native_build_inputs_sha256")
+        != environment.get("native_build_inputs_sha256")
+        or native_extension.get("sha256") != environment.get("native_extension_sha256")
+        or native_target.get("triple") != environment.get("native_target")
+        or (", ".join(native_features) or "baseline")
+        != environment.get("native_cpu_features")
+    ):
+        raise FinalAuditError(
+            "retained ancestor runtime identity differs from its authenticated "
+            "Class-C environment"
+        )
+    ancestor_native_inputs = identity.get("native_build_inputs_sha256")
+    descendant_native_inputs = active_runtime.get("native_build_inputs_sha256")
+    native_inputs_match = ancestor_native_inputs == descendant_native_inputs
+    if not native_inputs_match:
+        native_inputs_match = _is_authorized_native_inputs_transition(
+            impact=measurement_lineage.impact,
+            ancestor_revision=measurement_lineage.ancestor_revision,
+            descendant_revision=measurement_lineage.descendant_revision,
+            ancestor_digest=ancestor_native_inputs,
+            descendant_digest=descendant_native_inputs,
+        )
+    if not native_inputs_match or native_target != active_runtime.get("native_target"):
+        raise FinalAuditError(
+            "retained ancestor runtime changes a Class-C invariant native identity"
+        )
+    projected = dict(active_runtime)
+    projected["package_version"] = identity.get("package_version")
+    projected["python_package_tree"] = package_tree
+    projected["candidate_build_identity"] = candidate
+    projected["candidate_build_identity_sha256"] = candidate_digest
+    projected["native_build_inputs_sha256"] = ancestor_native_inputs
+    # The ancestor and descendant extensions are independently authenticated by
+    # their endpoint environments.  A fresh relink need not be byte-identical,
+    # so retained ancestor measurements must be checked against their own
+    # extension identity rather than the active descendant's output file.
+    projected["native_extension"] = native_extension
+    origin_policy = identity.get("loaded_module_origin_policy")
+    if isinstance(origin_policy, Mapping):
+        projected["loaded_module_origin_policy"] = origin_policy
+    return projected
+
+
+def _audit_effective_config(
+    cell: CellSpec,
+    provenance: Mapping[str, object],
+) -> Mapping[str, object]:
+    context = f"{cell.cell_id}.provenance.effective_config"
+    effective = _mapping(provenance.get("effective_config"), context)
+    _audit_effective_config_mapping(cell, effective, context=context)
+    return effective
+
+
+def _audit_effective_config_mapping(
+    cell: CellSpec,
+    effective: Mapping[str, object],
+    *,
+    context: str,
+) -> None:
+    evaluator = _mapping(effective.get("evaluator"), f"{context}.evaluator")
+    color = _mapping(effective.get("color"), f"{context}.color")
+    generation = _mapping(effective.get("generation"), f"{context}.generation")
+    on_the_fly = cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+    expected_layout = (
+        "topology-replay"
+        if on_the_fly
+        else (
+            "all-flow-union"
+            if cell.workload is Workload.ALL_FLOW
+            else "topology-replay"
+        )
+    )
+    mismatches: list[str] = []
+    expected = {
+        "execution_mode": cell.measurement.execution_mode.value,
+        "backend": cell.measurement.backend,
+    }
+    mismatches.extend(
+        f"evaluator.{field}"
+        for field, value in expected.items()
+        if evaluator.get(field) != value
+    )
+    if color.get("accuracy") != cell.measurement.accuracy.value:
+        mismatches.append("color.accuracy")
+    if color.get("lc_flow_layout") != expected_layout:
+        mismatches.append("color.lc_flow_layout")
+    if cell.measurement.jit_optimization_level is not None:
+        jit = _mapping(evaluator.get("jit"), f"{context}.evaluator.jit")
+        if jit.get("optimization_level") != cell.measurement.jit_optimization_level:
+            mismatches.append("evaluator.jit.optimization_level")
+    if on_the_fly and generation.get("relation_discovery") != {"mode": "off"}:
+        mismatches.append("generation.relation_discovery")
+    if mismatches:
+        raise FinalAuditError(
+            f"{context} differs from the report contract: " + ", ".join(mismatches)
+        )
+
+
+def _audit_model_source(
+    cell: CellSpec,
+    effective: Mapping[str, object],
+) -> None:
+    context = "authenticated effective configuration.model.source"
+    model = _mapping(
+        effective.get("model"), "authenticated effective configuration.model"
+    )
+    source = model.get("source")
+    if not isinstance(source, str) or not source:
+        raise FinalAuditError(f"{context} is invalid")
+    if cell.measurement.model is ModelKey.BUILTIN_SM:
+        if source != "built-in-sm":
+            raise FinalAuditError(f"{context} differs from the built-in-SM cell")
+        return
+    relative = _MODEL_SOURCE_PATH.get(cell.measurement.model)
+    if relative is None:
+        raise FinalAuditError(
+            f"{cell.cell_id} has no authenticated model-source contract"
+        )
+    repo_root = Path(__file__).resolve().parents[2]
+    expected = (repo_root / relative).resolve(strict=True)
+    try:
+        observed = Path(source).expanduser().resolve(strict=True)
+    except OSError as error:
+        raise FinalAuditError(f"{context} is unavailable: {source}") from error
+    if observed != expected:
+        raise FinalAuditError(
+            f"{context} differs from the exact source for "
+            f"{cell.measurement.model.value}"
+        )
+
+
+def _artifact_reference(
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    *,
+    report_paths: ReportPaths | None = None,
+) -> _ArtifactReference:
+    artifact = _mapping(measurement.get("artifact"), f"{cell.cell_id}.artifact")
+    raw_path = artifact.get("path")
+    process_id = artifact.get("process_id")
+    if not isinstance(raw_path, str) or not raw_path:
+        raise FinalAuditError(f"{cell.cell_id}.artifact.path is invalid")
+    if not isinstance(process_id, str) or not process_id:
+        raise FinalAuditError(f"{cell.cell_id}.artifact.process_id is invalid")
+    try:
+        if raw_path.startswith(_PORTABLE_ARTIFACT_ROOT):
+            if report_paths is None:
+                raise FinalAuditError(
+                    f"{cell.cell_id}.artifact.path requires report path context"
+                )
+            suffix = raw_path.removeprefix(_PORTABLE_ARTIFACT_ROOT)
+            if not suffix.startswith("/") or suffix == "/":
+                raise FinalAuditError(
+                    f"{cell.cell_id}.artifact.path has an invalid portable locator"
+                )
+            logical = _canonical_relative_path(
+                suffix.removeprefix("/"),
+                f"{cell.cell_id}.artifact",
+            )
+            path = report_paths.artifact_root.joinpath(*logical.parts).resolve(
+                strict=True
+            )
+            path.relative_to(report_paths.artifact_root.resolve(strict=True))
+        else:
+            if "${" in raw_path:
+                raise FinalAuditError(
+                    f"{cell.cell_id}.artifact.path has an unsupported locator"
+                )
+            path = Path(raw_path).expanduser().resolve(strict=True)
+    except OSError as error:
+        raise FinalAuditError(
+            f"{cell.cell_id}.artifact.path is unavailable: {raw_path}"
+        ) from error
+    except ValueError as error:
+        raise FinalAuditError(
+            f"{cell.cell_id}.artifact.path escapes its report artifact root"
+        ) from error
+    if not path.is_dir():
+        raise FinalAuditError(f"{cell.cell_id}.artifact.path is not a directory")
+    return _ArtifactReference(cell, measurement, path, process_id)
+
+
+def _shared_artifact_contract(cell: CellSpec) -> tuple[object, ...]:
+    """Fields that must agree when report cells reuse one process artifact."""
+
+    workload = (
+        None
+        if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+        and cell.measurement.accuracy is Accuracy.LC
+        and cell.workload in {Workload.SELECTED_FLOW, Workload.ALL_FLOW}
+        else cell.workload
+    )
+    return (
+        cell.process,
+        cell.n_final,
+        cell.process_key,
+        cell.measurement,
+        workload,
+    )
+
+
+def _expected_legacy_revision(repo_root: Path) -> str:
+    lock_path = repo_root / "dependencies" / "contributor-lock.toml"
+    try:
+        lock = tomllib.loads(lock_path.read_text(encoding="utf-8"))
+        section = _mapping(lock.get("legacy_amplicol"), "legacy_amplicol lock")
+        revision = section.get("revision")
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        raise FinalAuditError(
+            "cannot authenticate the pinned original-AmpliCol revision"
+        ) from error
+    if not isinstance(revision, str) or _GIT_SHA_RE.fullmatch(revision) is None:
+        raise FinalAuditError("pinned original-AmpliCol revision is invalid")
+    return revision
+
+
+def _audit_unavailable_execution_timing(
+    cell: CellSpec,
+    provenance: Mapping[str, object],
+    *,
+    measurement_sample_count: int,
+    context: str,
+) -> None:
+    """Authenticate an unavailable execution attribution from the Arena profiler."""
+
+    timing = _mapping(
+        provenance.get("execution_timing"),
+        f"{context}.provenance.execution_timing",
+    )
+    if set(timing) != ARENA_UNAVAILABLE_EXECUTION_TIMING_FIELDS:
+        raise FinalAuditError(
+            f"{context}.provenance.execution_timing fields do not match "
+            "the authenticated contract"
+        )
+    timing_sample_count = timing.get("sample_count")
+    measurement = {
+        "execution_seconds_per_point": None,
+        "provenance": {
+            "execution_timing": timing,
+            "arena_profile_evidence": provenance.get("arena_profile_evidence"),
+        },
+    }
+    if (
+        unavailable_execution_timing_record(
+            measurement,
+            "execution_seconds_per_point",
+        )
+        is None
+        or isinstance(timing_sample_count, bool)
+        or not isinstance(timing_sample_count, int)
+        or timing_sample_count < 5
+        or timing_sample_count != measurement_sample_count
+        or timing.get("execution_mode") != cell.measurement.execution_mode.value
+    ):
+        raise FinalAuditError(
+            f"{context}.provenance.execution_timing is not an authenticated "
+            "Arena unavailable-attribution record"
+        )
+
+
+def _publication_policy_errors(
+    context: str,
+    measurement: Mapping[str, object],
+    *,
+    expected_source_revision: str,
+    expected_source_tree: str | None,
+) -> tuple[str, ...]:
+    errors = [
+        f"{context}.{issue.field}: {issue.detail}"
+        for issue in publication_measurement_policy_issues(measurement)
+    ]
+    if measurement.get("status") != ResultStatus.OK.value:
+        return tuple(errors)
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        return tuple(errors)
+    for field in ("report_source_revision", "report_measured_source_revision"):
+        if provenance.get(field) != expected_source_revision:
+            errors.append(
+                f"{context}.provenance.{field}: does not match the measured commit"
+            )
+    if expected_source_tree is not None:
+        for field in ("report_source_tree", "report_measured_source_tree"):
+            if provenance.get(field) != expected_source_tree:
+                errors.append(
+                    f"{context}.provenance.{field}: "
+                    "does not match the measured Git tree"
+                )
+    return tuple(errors)
+
+
+def _audit_runtime_profile_warmup_evidence(
+    cell: CellSpec,
+    provenance: Mapping[str, object],
+    *,
+    context: str,
+) -> None:
+    """Reject incomplete or semantically widened OTF warm-up timings."""
+
+    if cell.measurement.execution_mode is not ExecutionMode.ON_THE_FLY:
+        return
+    if provenance.get("runtime_load_included_in_cold_warmup") is not False:
+        raise FinalAuditError(
+            f"{context}.provenance.runtime_load_included_in_cold_warmup must be false"
+        )
+    if provenance.get("generation_timer_excludes_model_preparation") is not True:
+        raise FinalAuditError(
+            f"{context}.provenance.generation_timer_excludes_model_preparation "
+            "must be true"
+        )
+    effective = _mapping(
+        provenance.get("effective_config"),
+        f"{context}.provenance.effective_config",
+    )
+    benchmark = _mapping(
+        effective.get("benchmark"),
+        f"{context}.provenance.effective_config.benchmark",
+    )
+    expected_batch_size = benchmark.get("batch_size")
+    expected_warmup_runs = benchmark.get("warmup_runs")
+    if (
+        isinstance(expected_batch_size, bool)
+        or not isinstance(expected_batch_size, int)
+        or expected_batch_size < 1
+    ):
+        raise FinalAuditError(
+            f"{context}.provenance.effective_config.benchmark.batch_size must "
+            "be positive"
+        )
+    if (
+        isinstance(expected_warmup_runs, bool)
+        or not isinstance(expected_warmup_runs, int)
+        or expected_warmup_runs < 0
+    ):
+        raise FinalAuditError(
+            f"{context}.provenance.effective_config.benchmark.warmup_runs must "
+            "be non-negative"
+        )
+    if expected_batch_size != REPORT_BENCHMARK_BATCH_SIZE:
+        raise FinalAuditError(
+            f"{context}.provenance.effective_config.benchmark.batch_size must "
+            f"equal the final report contract {REPORT_BENCHMARK_BATCH_SIZE}"
+        )
+    if expected_warmup_runs != REPORT_BENCHMARK_WARMUP_RUNS:
+        raise FinalAuditError(
+            f"{context}.provenance.effective_config.benchmark.warmup_runs must "
+            f"equal the final report contract {REPORT_BENCHMARK_WARMUP_RUNS}"
+        )
+    try:
+        validate_profile_warmup_evidence(
+            provenance.get("runtime_profile"),
+            execution_mode=cell.measurement.execution_mode,
+            expected_batch_size=expected_batch_size,
+            expected_warmup_run_count=expected_warmup_runs,
+        )
+    except ValueError as error:
+        raise FinalAuditError(
+            f"{context}.provenance.runtime_profile: {error}"
+        ) from error
+
+
+def _audit_measurement(
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    *,
+    baseline: Mapping[str, object] | None,
+    baseline_cell: CellSpec | None = None,
+    expected_source_revision: str,
+    expected_legacy_revision: str,
+    active_runtime: Mapping[str, object] | None,
+    expected_source_tree: str | None = None,
+    report_paths: ReportPaths | None = None,
+) -> _ArtifactReference | None:
+    context = cell.cell_id
+    if measurement.get("status") != ResultStatus.OK.value:
+        raise FinalAuditError(
+            f"{context}.measurement.status is not {ResultStatus.OK.value!r}"
+        )
+    if measurement.get("failure") is not None:
+        raise FinalAuditError(f"{context}.measurement has failure metadata")
+    matrix_element = _finite_number(
+        measurement.get("matrix_element"),
+        f"{context}.measurement.matrix_element",
+        nonnegative=True,
+    )
+    for field in ("generation_seconds", "wall_seconds_per_point"):
+        _finite_number(
+            measurement.get(field),
+            f"{context}.measurement.{field}",
+            nonnegative=True,
+        )
+    sample_count = measurement.get("sample_count")
+    if (
+        isinstance(sample_count, bool)
+        or not isinstance(sample_count, int)
+        or sample_count < 5
+    ):
+        raise FinalAuditError(
+            f"{context}.measurement.sample_count must be at least five"
+        )
+    provenance = _mapping(
+        measurement.get("provenance"), f"{context}.measurement.provenance"
+    )
+    _audit_runtime_profile_warmup_evidence(
+        cell,
+        provenance,
+        context=f"{context}.measurement",
+    )
+    if provenance.get("report_source_revision") != expected_source_revision:
+        raise FinalAuditError(
+            f"{context} was not measured at source SHA {expected_source_revision}"
+        )
+    if expected_source_tree is not None and (
+        provenance.get("report_source_tree") != expected_source_tree
+        or provenance.get("report_measured_source_tree") != expected_source_tree
+    ):
+        raise FinalAuditError(
+            f"{context} source tree does not match the measured Git tree"
+        )
+    validation = _mapping(
+        measurement.get("validation"), f"{context}.measurement.validation"
+    )
+    if validation.get("status") != ResultStatus.OK.value:
+        raise FinalAuditError(f"{context}.measurement.validation.status is not ok")
+    validation_point_digest = _measurement_validation_point_digest(
+        measurement,
+        context=context,
+    )
+
+    raw_selector = measurement.get("selector_contract")
+    selector: SelectorContract | None = None
+    if cell.measurement.accuracy is Accuracy.LC:
+        selector = SelectorContract.from_mapping(
+            _mapping(raw_selector, f"{context}.measurement.selector_contract")
+        )
+    elif raw_selector is not None:
+        raise FinalAuditError(
+            f"{context} contracted-color measurement has a selector contract"
+        )
+
+    if cell.measurement.execution_mode is ExecutionMode.AMPLICOL:
+        if validation.get("method") != "independent-original-amplicol-oracle":
+            raise FinalAuditError(
+                f"{context} does not identify the legacy AmpliCol diagnostic"
+            )
+        stored_point_digest = validation.get("point_digest")
+        expected_point_digest = point_digest(shared_validation_points(cell.process))
+        if (
+            not isinstance(stored_point_digest, str)
+            or _SHA256_RE.fullmatch(stored_point_digest) is None
+            or stored_point_digest != expected_point_digest
+        ):
+            raise FinalAuditError(
+                f"{context} oracle point digest does not match its physical process"
+            )
+        if selector is not None and stored_point_digest != selector.point_digest:
+            raise FinalAuditError(
+                f"{context} oracle and selector use different validation points"
+            )
+        revision = provenance.get("revision")
+        if revision != expected_legacy_revision:
+            raise FinalAuditError(
+                f"{context} does not use the pinned original-AmpliCol revision"
+            )
+        return None
+
+    if cell.measurement.execution_mode is ExecutionMode.MADGRAPH:
+        if baseline is not None or baseline_cell is not None:
+            raise FinalAuditError(f"{context} MadGraph oracle has a catalog baseline")
+        if validation.get("method") != "independent-madgraph-tree-level-oracle":
+            raise FinalAuditError(
+                f"{context} does not identify the independent MadGraph oracle"
+            )
+        expected_point_digest = point_digest(shared_validation_points(cell.process))
+        if validation.get("point_digest") != expected_point_digest:
+            raise FinalAuditError(
+                f"{context} MadGraph point digest differs from its physical process"
+            )
+        execution_seconds = _finite_number(
+            measurement.get("execution_seconds_per_point"),
+            f"{context}.measurement.execution_seconds_per_point",
+        )
+        if execution_seconds <= 0.0:
+            raise FinalAuditError(
+                f"{context}.measurement.execution_seconds_per_point must be positive"
+            )
+        if provenance.get("method") != "madgraph-standalone-custom-fortran-driver":
+            raise FinalAuditError(f"{context} MadGraph driver method is invalid")
+        from .madgraph import madgraph_command_card
+
+        expected_command_card = madgraph_command_card(cell.process)
+        if (
+            provenance.get("command_card") != expected_command_card
+            or provenance.get("command_card_sha256")
+            != hashlib.sha256(expected_command_card.encode("utf-8")).hexdigest()
+            or provenance.get("generation_timing_scope")
+            != "generate-output-standalone-launch-force"
+            or provenance.get("generation_includes_madgraph_compilation") is not True
+            or provenance.get("driver_compilation_in_generation_seconds") is not False
+        ):
+            raise FinalAuditError(
+                f"{context} MadGraph generation command/timing scope is invalid"
+            )
+        warmup_calls = provenance.get("driver_warmup_calls")
+        profile_chunks = provenance.get("profile_chunk_count")
+        if (
+            isinstance(warmup_calls, bool)
+            or not isinstance(warmup_calls, int)
+            or warmup_calls < 20
+            or isinstance(profile_chunks, bool)
+            or not isinstance(profile_chunks, int)
+            or profile_chunks < 5
+        ):
+            raise FinalAuditError(
+                f"{context} MadGraph driver warmup/profile census is invalid"
+            )
+        model = _mapping(provenance.get("model"), f"{context}.provenance.model")
+        if (
+            model.get("name") != "sm"
+            or not isinstance(model.get("source_directory"), str)
+            or not Path(str(model["source_directory"])).is_absolute()
+            or _SHA256_RE.fullmatch(str(model.get("source_sha256"))) is None
+        ):
+            raise FinalAuditError(f"{context} MadGraph UFO-SM identity is invalid")
+        for field in ("default_restriction", "exact_param_card"):
+            parameter_record = _mapping(
+                provenance.get(field),
+                f"{context}.provenance.{field}",
+            )
+            count = parameter_record.get("external_parameter_count")
+            if (
+                isinstance(count, bool)
+                or not isinstance(count, int)
+                or count < 1
+                or _SHA256_RE.fullmatch(
+                    str(parameter_record.get("external_parameters_sha256"))
+                )
+                is None
+                or parameter_record.get("binary64_exact_match") is not True
+                or parameter_record.get("format") != "%.14e"
+            ):
+                raise FinalAuditError(f"{context} MadGraph {field} identity is invalid")
+        commands = _sequence(
+            provenance.get("commands"),
+            f"{context}.provenance.commands",
+        )
+        if len(commands) < profile_chunks + 2:
+            raise FinalAuditError(f"{context} MadGraph command census is incomplete")
+        for index, raw_command in enumerate(commands):
+            command = _mapping(
+                raw_command,
+                f"{context}.provenance.commands[{index}]",
+            )
+            args = command.get("args")
+            cwd = command.get("cwd")
+            elapsed = _finite_number(
+                command.get("elapsed_seconds"),
+                f"{context}.provenance.commands[{index}].elapsed_seconds",
+                nonnegative=True,
+            )
+            if (
+                command.get("returncode") != 0
+                or isinstance(args, (str, bytes))
+                or not isinstance(args, Sequence)
+                or not args
+                or not isinstance(cwd, str)
+                or not Path(cwd).is_absolute()
+                or elapsed < 0.0
+            ):
+                raise FinalAuditError(f"{context} MadGraph command {index} is invalid")
+        return None
+
+    raw_execution_seconds = measurement.get("execution_seconds_per_point")
+    if raw_execution_seconds is None:
+        _audit_unavailable_execution_timing(
+            cell,
+            provenance,
+            measurement_sample_count=sample_count,
+            context=f"{context}.measurement",
+        )
+    else:
+        execution_seconds = _finite_number(
+            raw_execution_seconds,
+            f"{context}.measurement.execution_seconds_per_point",
+        )
+        if execution_seconds <= 0.0:
+            raise FinalAuditError(
+                f"{context}.measurement.execution_seconds_per_point must be positive"
+            )
+    if EVALUATOR_TOTAL_TIMING_KEY in provenance:
+        evaluator_total = evaluator_total_timing_record(measurement)
+        if (
+            evaluator_total is None
+            or evaluator_total.get("execution_mode")
+            != cell.measurement.execution_mode.value
+        ):
+            raise FinalAuditError(
+                f"{context}.measurement.provenance.evaluator_total_timing "
+                "is not an authenticated accumulated evaluator-total record"
+            )
+    if provenance.get("source_revision") != expected_source_revision:
+        raise FinalAuditError(
+            f"{context} pyAmpliCol source revision is not the measurement SHA"
+        )
+    if active_runtime is None:
+        raise FinalAuditError("pyAmpliCol measurements require an active runtime")
+    _audit_effective_config(cell, provenance)
+    raw_resolved_sum = _mapping(
+        validation.get("resolved_sum"),
+        f"{context}.measurement.validation.resolved_sum",
+    )
+    _audit_resolved_sum(
+        raw_resolved_sum,
+        context=f"{context}.measurement.validation.resolved_sum",
+    )
+    resolved_source_sha256 = (
+        str(raw_resolved_sum["resolved_source_sha256"])
+        if raw_resolved_sum.get("abi") == RESOLVED_SUM_VALIDATION_ABI
+        else None
+    )
+    ordinary_selector_identity = {
+        "cell_id": cell.cell_id,
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+        "selector_contract": raw_selector,
+        "value_kind": "matrix-element",
+    }
+    high_selector_identity = {
+        **ordinary_selector_identity,
+        "value_kind": "matrix-element-p16-versus-p32",
+    }
+    raw_high_precision = validation.get("high_precision")
+    raw_high_resolved: Mapping[str, object] | None = None
+    if (
+        isinstance(raw_high_precision, Mapping)
+        and raw_high_precision.get("abi") == CONDITIONED_COMPARISON_ABI
+    ):
+        raw_high_resolved = _mapping(
+            validation.get("high_precision_resolved_sum"),
+            f"{context}.measurement.validation.high_precision_resolved_sum",
+        )
+        _audit_resolved_sum(
+            raw_high_resolved,
+            context=f"{context}.measurement.validation.high_precision_resolved_sum",
+        )
+        if (
+            raw_high_resolved.get("point_digest") != validation_point_digest
+            or raw_high_resolved.get("precision_digits") != 32
+        ):
+            raise FinalAuditError(
+                f"{context} p32 resolved scale is bound to a different point/precision"
+            )
+
+    scalar = cell.measurement.model in {
+        ModelKey.SCALAR_CONTACT,
+        ModelKey.SCALAR_GRAVITY,
+    }
+    if scalar:
+        try:
+            _validate_standalone_internal_validation(measurement, validation)
+        except ValueError as error:
+            raise FinalAuditError(
+                f"{context}.measurement.validation standalone evidence: {error}"
+            ) from error
+        _audit_pointwise(
+            validation.get("high_precision"),
+            context=f"{context}.measurement.validation.high_precision",
+            expected_candidate=matrix_element,
+            expected_baseline=_finite_number(
+                _mapping(
+                    validation.get("high_precision"),
+                    f"{context}.measurement.validation.high_precision",
+                ).get("baseline"),
+                f"{context}.measurement.validation.high_precision.baseline",
+            ),
+            expected_relative_tolerance=RELATIVE_TOLERANCE,
+            expected_point_digest=validation_point_digest,
+            expected_candidate_source_sha256=resolved_source_sha256,
+            expected_baseline_source_sha256=(
+                str(raw_high_resolved["resolved_source_sha256"])
+                if isinstance(raw_high_precision, Mapping)
+                and raw_high_precision.get("abi") == CONDITIONED_COMPARISON_ABI
+                else None
+            ),
+            expected_selector_identity=high_selector_identity,
+        )
+        if baseline is not None:
+            raise FinalAuditError(f"{context} scalar cell has a catalog baseline")
+    else:
+        if baseline is None:
+            raw_pointwise = validation.get("pointwise")
+            if isinstance(raw_high_precision, Mapping):
+                if cell.measurement.execution_mode not in {
+                    ExecutionMode.RECURRENCE,
+                    ExecutionMode.COMPILED,
+                    ExecutionMode.EAGER,
+                }:
+                    raise FinalAuditError(
+                        f"{context} stores inapplicable high-precision authority"
+                    )
+                _audit_pointwise(
+                    raw_high_precision,
+                    context=f"{context}.measurement.validation.high_precision",
+                    expected_candidate=matrix_element,
+                    expected_baseline=_finite_number(
+                        raw_high_precision.get("baseline"),
+                        f"{context}.measurement.validation.high_precision.baseline",
+                        nonnegative=True,
+                    ),
+                    expected_relative_tolerance=RELATIVE_TOLERANCE,
+                    expected_point_digest=validation_point_digest,
+                    expected_candidate_source_sha256=resolved_source_sha256,
+                    expected_baseline_source_sha256=(
+                        str(raw_high_resolved["resolved_source_sha256"])
+                        if raw_high_resolved is not None
+                        else None
+                    ),
+                    expected_selector_identity=high_selector_identity,
+                )
+            elif cell.measurement.execution_mode is ExecutionMode.RECURRENCE:
+                raise FinalAuditError(
+                    f"{context}.measurement.validation has no high_precision "
+                    "self-consistency authority"
+                )
+            elif isinstance(raw_pointwise, Mapping):
+                raise FinalAuditError(f"{context} has an unbound pointwise baseline")
+            elif (
+                _stored_direct_agreement(
+                    measurement,
+                    edge_kind=Z_RECURRENCE_CROSS_MODE,
+                )
+                is None
+            ):
+                raise FinalAuditError(
+                    f"{context} has no canonical or stored recurrence authority"
+                )
+        elif baseline_uses_lc_common_component_authority(cell, baseline):
+            if INDEPENDENT_AUTHORITY_FIELD in validation:
+                if baseline_cell is None:
+                    raise FinalAuditError(
+                        f"{context} has no selected LC component authority"
+                    )
+                if not _stored_independent_pointwise_matches_baseline(
+                    cell,
+                    measurement,
+                    baseline_cell,
+                    baseline,
+                ):
+                    raise FinalAuditError(
+                        f"{context} LC component authority comparison is invalid"
+                    )
+            elif "pointwise" in validation:
+                raise FinalAuditError(
+                    f"{context} compares an LC all-flow aggregate outside the "
+                    "legacy provider replay authority"
+                )
+            baseline_selector = baseline.get("selector_contract")
+            if raw_selector != baseline_selector:
+                raise FinalAuditError(
+                    f"{context} selector contract differs from canonical baseline"
+                )
+        else:
+            baseline_value = _finite_number(
+                baseline.get("matrix_element"),
+                f"{context}.canonical_baseline.matrix_element",
+                nonnegative=True,
+            )
+            _audit_pointwise(
+                validation.get("pointwise"),
+                context=f"{context}.measurement.validation.pointwise",
+                expected_candidate=matrix_element,
+                expected_baseline=baseline_value,
+                expected_relative_tolerance=_expected_pointwise_tolerance(cell),
+                expected_point_digest=validation_point_digest,
+                expected_candidate_source_sha256=resolved_source_sha256,
+                expected_selector_identity=ordinary_selector_identity,
+            )
+            if INDEPENDENT_AUTHORITY_FIELD in validation and (
+                baseline_cell is None
+                or not _stored_independent_pointwise_matches_baseline(
+                    cell,
+                    measurement,
+                    baseline_cell,
+                    baseline,
+                )
+            ):
+                raise FinalAuditError(
+                    f"{context} conditioned authority binding is not canonical"
+                )
+            baseline_selector = baseline.get("selector_contract")
+            if cell.measurement.accuracy is Accuracy.LC:
+                if raw_selector != baseline_selector:
+                    raise FinalAuditError(
+                        f"{context} selector contract differs from canonical baseline"
+                    )
+            elif baseline_selector is not None:
+                raise FinalAuditError(
+                    f"{context} contracted canonical baseline has selectors"
+                )
+
+    return _artifact_reference(
+        cell,
+        measurement,
+        report_paths=report_paths,
+    )
+
+
+def _validation_baseline_endpoint_for_audit(
+    cell: CellSpec,
+    measurements: Mapping[str, Mapping[str, object]],
+    measurement_states: Mapping[str, PolicyMeasurementState],
+    *,
+    catalog: ReportCatalog,
+) -> tuple[CellSpec, Mapping[str, object]] | None:
+    """Resolve an authoritative baseline without promoting diagnostics.
+
+    Original AmpliCol is never returned as an authority, irrespective of
+    whether its optional comparison happens to agree.  Recurrence is audited
+    through its high-precision self-consistency evidence; compiled/eager
+    results authenticate the recurrence endpoint selected by their durable
+    independent-authority record.
+    """
+
+    measurement = measurements.get(cell.cell_id)
+    if measurement is None:
+        raise FinalAuditError(f"candidate measurement {cell.cell_id!r} is missing")
+    validation = _mapping(
+        measurement.get("validation"),
+        f"{cell.cell_id}.validation",
+    )
+    raw_authority = validation.get(INDEPENDENT_AUTHORITY_FIELD)
+    if raw_authority is not None:
+        if not requires_independent_numerical_authority(cell, catalog=catalog):
+            raise FinalAuditError(
+                f"{cell.cell_id} stores inapplicable independent authority"
+            )
+        record = _mapping(
+            raw_authority,
+            f"{cell.cell_id}.validation.{INDEPENDENT_AUTHORITY_FIELD}",
+        )
+        expected_fields = {
+            "abi",
+            "expected_cell_ids",
+            "selected_cell_id",
+            "status",
+            "reason",
+            "same_artifact_diagnostics_are_authority",
+        }
+        authorities = independent_numerical_authorities(cell, catalog=catalog)
+        authority_ids = [authority.cell_id for authority in authorities]
+        selected_id = record.get("selected_cell_id")
+        if (
+            set(record) != expected_fields
+            or record.get("abi") != INDEPENDENT_AUTHORITY_ABI
+            or record.get("expected_cell_ids") != authority_ids
+            or record.get("status") != "verified"
+            or record.get("reason") != "independent-authority-agreement"
+            or record.get("same_artifact_diagnostics_are_authority") is not False
+            or not isinstance(selected_id, str)
+            or selected_id not in authority_ids
+        ):
+            raise FinalAuditError(
+                f"{cell.cell_id} independent-authority record is invalid"
+            )
+        selected_index = authority_ids.index(selected_id)
+        for higher_priority in authorities[:selected_index]:
+            if (
+                measurement_states.get(higher_priority.cell_id)
+                is PolicyMeasurementState.SUCCESS
+            ):
+                raise FinalAuditError(
+                    f"{cell.cell_id} has an unreconciled higher-priority authority "
+                    f"{higher_priority.cell_id!r}"
+                )
+        selected_cell = authorities[selected_index]
+        selected = measurements.get(selected_id)
+        if (
+            selected is None
+            or measurement_states.get(selected_id) is not PolicyMeasurementState.SUCCESS
+        ):
+            raise FinalAuditError(
+                f"selected independent authority {selected_id!r} is unavailable"
+            )
+        if not _stored_independent_pointwise_matches_baseline(
+            cell,
+            measurement,
+            selected_cell,
+            selected,
+        ):
+            raise FinalAuditError(
+                f"{cell.cell_id} stored comparison does not authenticate selected "
+                f"authority {selected_id!r}"
+            )
+        return selected_cell, selected
+    baseline_cell = catalog.validation_baseline_cell(cell)
+    if baseline_cell is None:
+        return None
+    baseline = measurements.get(baseline_cell.cell_id)
+    baseline_state = measurement_states.get(baseline_cell.cell_id)
+    if validation_baseline_is_required(cell, baseline_cell):
+        if baseline is None:
+            raise FinalAuditError(
+                f"canonical baseline {baseline_cell.cell_id!r} is missing"
+            )
+        if baseline_state is not PolicyMeasurementState.SUCCESS:
+            raise FinalAuditError(
+                f"required canonical baseline {baseline_cell.cell_id!r} "
+                "is not successful"
+            )
+        return baseline_cell, baseline
+    if (
+        baseline_cell.measurement.execution_mode is not ExecutionMode.AMPLICOL
+        and baseline_state is PolicyMeasurementState.SUCCESS
+    ):
+        if baseline is None:
+            raise FinalAuditError(
+                f"successful optional baseline {baseline_cell.cell_id!r} is missing"
+            )
+        if _stored_pointwise_matches_baseline(cell, measurement, baseline):
+            return baseline_cell, baseline
+    if cell.measurement.execution_mode is ExecutionMode.RECURRENCE:
+        return None
+    if cell.measurement.execution_mode in {
+        ExecutionMode.COMPILED,
+        ExecutionMode.EAGER,
+    }:
+        # Compatibility for already-valid currents produced before the durable
+        # authority record was introduced.  They must still carry an
+        # authenticated comparison to a successful canonical endpoint.
+        for authority_cell in independent_numerical_authorities(
+            cell,
+            catalog=catalog,
+        ):
+            authority = measurements.get(authority_cell.cell_id)
+            if (
+                authority is None
+                or measurement_states.get(authority_cell.cell_id)
+                is not PolicyMeasurementState.SUCCESS
+            ):
+                continue
+            if _stored_independent_pointwise_matches_baseline(
+                cell,
+                measurement,
+                authority_cell,
+                authority,
+            ):
+                return authority_cell, authority
+            if (
+                authority_cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+                and _stored_direct_agreement(
+                    measurement,
+                    edge_kind=Z_RECURRENCE_CROSS_MODE,
+                    baseline_cell_id=authority_cell.cell_id,
+                )
+                is not None
+            ):
+                return None
+        raise FinalAuditError(
+            f"{cell.cell_id} has no successful authenticated numerical authority"
+        )
+    raise FinalAuditError(f"{cell.cell_id} has no successful canonical baseline")
+
+
+def _validation_baseline_for_audit(
+    cell: CellSpec,
+    measurements: Mapping[str, Mapping[str, object]],
+    measurement_states: Mapping[str, PolicyMeasurementState],
+    *,
+    catalog: ReportCatalog,
+) -> Mapping[str, object] | None:
+    endpoint = _validation_baseline_endpoint_for_audit(
+        cell,
+        measurements,
+        measurement_states,
+        catalog=catalog,
+    )
+    return None if endpoint is None else endpoint[1]
+
+
+def _legacy_consumer_coverage(
+    successful_cells: Sequence[CellSpec],
+    measurements: Mapping[str, Mapping[str, object]],
+    measurement_states: Mapping[str, PolicyMeasurementState],
+    *,
+    catalog: ReportCatalog,
+) -> tuple[tuple[str, str], ...]:
+    """Report authenticated legacy diagnostics without treating them as authority."""
+
+    legacy_ids = {
+        cell.cell_id
+        for cell in successful_cells
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+    }
+    linked: list[tuple[str, str]] = []
+    for candidate in successful_cells:
+        direct_legacy = next(
+            (
+                edge
+                for edge in incoming_agreement_edges(candidate, catalog=catalog)
+                if edge.kind == LC_LEGACY_PYAMPLICOL_COMPONENT
+                and edge.baseline.cell_id in legacy_ids
+                and _stored_direct_agreement(
+                    measurements[candidate.cell_id],
+                    edge_kind=edge.kind,
+                    baseline_cell_id=edge.baseline.cell_id,
+                )
+                is not None
+            ),
+            None,
+        )
+        if direct_legacy is not None:
+            linked.append((direct_legacy.baseline.cell_id, candidate.cell_id))
+            continue
+        baseline_cell = catalog.validation_baseline_cell(candidate)
+        if (
+            baseline_cell is None
+            or baseline_cell.cell_id not in legacy_ids
+            or measurement_states.get(baseline_cell.cell_id)
+            is not PolicyMeasurementState.SUCCESS
+        ):
+            continue
+        baseline = measurements.get(baseline_cell.cell_id)
+        if baseline is not None and (
+            _stored_pointwise_matches_baseline(
+                candidate,
+                measurements[candidate.cell_id],
+                baseline,
+            )
+            or _stored_legacy_component_matches_baseline(
+                candidate,
+                measurements[candidate.cell_id],
+                baseline_cell,
+                baseline,
+            )
+        ):
+            linked.append((baseline_cell.cell_id, candidate.cell_id))
+    return tuple(linked)
+
+
+def _find_process_execution(
+    artifact: Path,
+    manifest: object,
+    process_id: str,
+) -> tuple[dict[str, Any], str, str, tuple[str, ...]]:
+    runtime = _mapping(manifest.runtime, "artifact.runtime")
+    raw_index = runtime.get("evaluator_manifest_path")
+    index, index_relative, _index_sha256 = _authenticated_json_payload(
+        artifact,
+        manifest,
+        raw_index,
+        process_id=None,
+        context="evaluator manifest index",
+    )
+    if (
+        index.get("kind") != "pyamplicol-runtime-execution-set"
+        or type(index.get("schema_version")) is not int
+        or index.get("schema_version") != 3
+    ):
+        raise FinalAuditError("artifact evaluator index has an invalid contract")
+    matches = [
+        item
+        for item in _sequence(index.get("processes"), "evaluator index.processes")
+        if isinstance(item, Mapping) and item.get("process_id") == process_id
+    ]
+    if len(matches) != 1:
+        raise FinalAuditError(
+            f"artifact evaluator index does not uniquely identify {process_id!r}"
+        )
+    record = matches[0]
+    raw_execution = record.get("manifest_path")
+    execution_logical = _canonical_relative_path(
+        raw_execution,
+        "process execution manifest",
+    )
+    execution_relative = (
+        PurePosixPath(index_relative).parent / execution_logical
+    ).as_posix()
+    execution, execution_relative, execution_sha256 = _authenticated_json_payload(
+        artifact,
+        manifest,
+        execution_relative,
+        process_id=process_id,
+        context="process execution manifest",
+    )
+    capabilities = tuple(
+        str(value)
+        for value in _sequence(
+            record.get("required_runtime_capabilities"),
+            "evaluator process capabilities",
+        )
+    )
+    return execution, execution_relative, execution_sha256, capabilities
+
+
+def _walk_compiled_lanes(
+    value: object,
+    *,
+    path: str = "execution",
+) -> list[tuple[str, Mapping[str, object]]]:
+    result: list[tuple[str, Mapping[str, object]]] = []
+    if isinstance(value, Mapping):
+        compiled = value.get("compiled")
+        if isinstance(compiled, Mapping) and isinstance(
+            compiled.get("stage_evaluators"), Mapping
+        ):
+            result.append((f"{path}.compiled", compiled))
+        for key, child in value.items():
+            result.extend(_walk_compiled_lanes(child, path=f"{path}.{key}"))
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        for index, child in enumerate(value):
+            result.extend(_walk_compiled_lanes(child, path=f"{path}[{index}]"))
+    return result
+
+
+def _audit_symjit_plane_evaluator_leaves(
+    value: object,
+    *,
+    optimization_level: int,
+    context: str,
+) -> list[tuple[str, str]]:
+    evaluator = _mapping(value, context)
+    if evaluator.get("kind") == "chunked-symbolica-evaluator":
+        chunks = _sequence(evaluator.get("chunks"), f"{context}.chunks")
+        if not chunks:
+            raise FinalAuditError(f"{context} has no source-evaluator leaves")
+        leaves: list[tuple[str, str]] = []
+        for index, chunk in enumerate(chunks):
+            leaves.extend(
+                _audit_symjit_plane_evaluator_leaves(
+                    chunk,
+                    optimization_level=optimization_level,
+                    context=f"{context}.chunks[{index}]",
+                )
+            )
+        return leaves
+    mismatches: list[str] = []
+    if evaluator.get("kind") != "symjit-application-evaluator":
+        mismatches.append("kind")
+    legacy_backend = evaluator.get("backend")
+    if "backend" in evaluator and legacy_backend != "jit":
+        mismatches.append("backend")
+    if evaluator.get("runtime_capability") != _SOURCE_RUNTIME_CAPABILITY["jit"]:
+        mismatches.append("runtime_capability")
+    if evaluator.get("application_abi") != _SYMJIT_APPLICATION_ABI:
+        mismatches.append("application_abi")
+    if evaluator.get("element_layout") != "complex-f64":
+        mismatches.append("element_layout")
+    if evaluator.get("batch_layout") != "row-major":
+        mismatches.append("batch_layout")
+    if evaluator.get("compiler_type") != "native":
+        mismatches.append("compiler_type")
+    if evaluator.get("translation_mode") not in {"direct", "indirect"}:
+        mismatches.append("translation_mode")
+    if evaluator.get("optimization_level") != optimization_level:
+        mismatches.append("optimization_level")
+    if evaluator.get("word_bits") != 64:
+        mismatches.append("word_bits")
+    if evaluator.get("endianness") != "little":
+        mismatches.append("endianness")
+    if evaluator.get("required_defuns") != []:
+        mismatches.append("required_defuns")
+    fallback_path = evaluator.get("evaluator_state_path")
+    fallback_capability = evaluator.get("evaluator_state_runtime_capability")
+    if fallback_path is None and fallback_capability is None:
+        pass
+    elif (
+        not isinstance(fallback_path, str)
+        or fallback_capability != "symbolica.legacy-jit-container.complex-f64.v1"
+    ):
+        mismatches.append("evaluator_state_fallback")
+    else:
+        _canonical_relative_path(
+            fallback_path,
+            f"{context}.fallback_evaluator_state",
+        )
+    input_len = evaluator.get("input_len")
+    output_len = evaluator.get("output_len")
+    if isinstance(input_len, bool) or not isinstance(input_len, int) or input_len < 0:
+        mismatches.append("input_len")
+    if (
+        isinstance(output_len, bool)
+        or not isinstance(output_len, int)
+        or output_len < 0
+    ):
+        mismatches.append("output_len")
+    _canonical_relative_path(
+        evaluator.get("application_path"),
+        f"{context}.ordinary_application",
+    )
+    plane = _mapping(
+        evaluator.get("plane_application"),
+        f"{context}.plane_application",
+    )
+    if plane.get("application_abi") != _SYMJIT_PLANE_APPLICATION_ABI:
+        mismatches.append("plane_application.application_abi")
+    if plane.get("storage_abi") != _SYMJIT_APPLICATION_ABI:
+        mismatches.append("plane_application.storage_abi")
+    if plane.get("element_layout") != "split-complex-plane-major":
+        mismatches.append("plane_application.element_layout")
+    if plane.get("descriptor_order") != "inputs-re-im-then-outputs-re-im":
+        mismatches.append("plane_application.descriptor_order")
+    if isinstance(input_len, int) and not isinstance(input_len, bool):
+        if plane.get("input_complex_count") != input_len:
+            mismatches.append("plane_application.input_complex_count")
+        if plane.get("input_plane_count") != 2 * input_len:
+            mismatches.append("plane_application.input_plane_count")
+    if isinstance(output_len, int) and not isinstance(output_len, bool):
+        if plane.get("output_complex_count") != output_len:
+            mismatches.append("plane_application.output_complex_count")
+        if plane.get("output_plane_count") != 2 * output_len:
+            mismatches.append("plane_application.output_plane_count")
+    if plane.get("compiler_type") != "native":
+        mismatches.append("plane_application.compiler_type")
+    if plane.get("translation_mode") != "symbolica-structured-instructions":
+        mismatches.append("plane_application.translation_mode")
+    if plane.get("direct_arena") is not True:
+        mismatches.append("plane_application.direct_arena")
+    if plane.get("simd") is not True:
+        mismatches.append("plane_application.simd")
+    if plane.get("complex") is not True:
+        mismatches.append("plane_application.complex")
+    if plane.get("fast_math") is not True:
+        mismatches.append("plane_application.fast_math")
+    if plane.get("fast_complex") is not False:
+        mismatches.append("plane_application.fast_complex")
+    if not isinstance(plane.get("compression"), bool):
+        mismatches.append("plane_application.compression")
+    if plane.get("threading") is not False:
+        mismatches.append("plane_application.threading")
+    if plane.get("optimization_level") != optimization_level:
+        mismatches.append("plane_application.optimization_level")
+    target = plane.get("target")
+    if not _valid_symjit_plane_target(target):
+        mismatches.append("plane_application.target")
+    plane_path = _canonical_relative_path(
+        plane.get("application_path"),
+        f"{context}.plane_application.application",
+    ).as_posix()
+    source_digest = _require_sha256(
+        plane.get("source_digest"),
+        f"{context}.plane_application.source_digest",
+    )
+    if mismatches:
+        raise FinalAuditError(
+            f"{context} differs from the JIT plane source evaluator contract: "
+            + ", ".join(mismatches)
+        )
+    return [(plane_path, source_digest)]
+
+
+def _audit_source_evaluator(
+    value: object,
+    cell: CellSpec,
+    *,
+    context: str,
+) -> int:
+    if cell.measurement.backend == "jit":
+        level = cell.measurement.jit_optimization_level
+        if isinstance(level, bool) or not isinstance(level, int):
+            raise FinalAuditError(
+                f"{context} has no authenticated JIT optimization level"
+            )
+        return len(
+            _audit_symjit_plane_evaluator_leaves(
+                value,
+                optimization_level=level,
+                context=context,
+            )
+        )
+    evaluator = _mapping(value, context)
+    kind = evaluator.get("kind")
+    if kind == "chunked-symbolica-evaluator":
+        chunks = _sequence(evaluator.get("chunks"), f"{context}.chunks")
+        if not chunks:
+            raise FinalAuditError(f"{context} has no source-evaluator leaves")
+        return sum(
+            _audit_source_evaluator(
+                chunk,
+                cell,
+                context=f"{context}.chunks[{index}]",
+            )
+            for index, chunk in enumerate(chunks)
+        )
+    expected_kind = "compiled-complex-evaluator"
+    expected_capability = _SOURCE_RUNTIME_CAPABILITY.get(cell.measurement.backend)
+    if expected_capability is None:
+        raise FinalAuditError(
+            f"{cell.cell_id} has unsupported evaluator backend "
+            f"{cell.measurement.backend!r}"
+        )
+    mismatches: list[str] = []
+    if kind != expected_kind:
+        mismatches.append("kind")
+    if evaluator.get("runtime_capability") != expected_capability:
+        mismatches.append("runtime_capability")
+    if mismatches:
+        raise FinalAuditError(
+            f"{context} differs from the {cell.measurement.backend} source "
+            "evaluator contract: " + ", ".join(mismatches)
+        )
+    return 1
+
+
+def _audit_compiled_execution(
+    execution: Mapping[str, object],
+    cell: CellSpec,
+) -> tuple[int, int]:
+    if execution.get("kind") != "pyamplicol-runtime-execution":
+        raise FinalAuditError("compiled execution manifest kind is invalid")
+    expected_application, expected_source = _expected_evaluator_abis(cell)
+    lanes = _walk_compiled_lanes(execution)
+    if not lanes:
+        raise FinalAuditError("compiled execution contains no executable lanes")
+    plane_count = 0
+    direct_leaf_count = 0
+    for lane_path, compiled in lanes:
+        stages = _mapping(
+            compiled.get("stage_evaluators"),
+            f"{lane_path}.stage_evaluators",
+        )
+        stage_records = list(_sequence(stages.get("stages"), f"{lane_path}.stages"))
+        stage_records.append(
+            _mapping(
+                stages.get("amplitude_stage"),
+                f"{lane_path}.amplitude_stage",
+            )
+        )
+        if not stage_records:
+            raise FinalAuditError(f"{lane_path} has no fused stages")
+        for index, raw_stage in enumerate(stage_records):
+            stage = _mapping(raw_stage, f"{lane_path}.stage[{index}]")
+            arena = _mapping(
+                stage.get("compiled_plane_arena"),
+                f"{lane_path}.stage[{index}].compiled_plane_arena",
+            )
+            expected = {
+                "schema_version": 1,
+                "kind": "compiled-plane-arena-stage",
+                "application_abi": expected_application,
+                "source_application_abi": expected_source,
+                "element_layout": "split-complex-component-major",
+                "output_operation": "overwrite",
+                "output_factor": "identity",
+                "input_output_aliasing": "forbidden",
+                "output_output_aliasing": "forbidden",
+            }
+            mismatches = [
+                field for field, value in expected.items() if arena.get(field) != value
+            ]
+            inputs = _sequence(
+                arena.get("input_bindings"), f"{lane_path}.arena.input_bindings"
+            )
+            outputs = _sequence(
+                arena.get("output_bindings"),
+                f"{lane_path}.arena.output_bindings",
+            )
+            leaves = _sequence(arena.get("leaves"), f"{lane_path}.arena.leaves")
+            if len(inputs) != stage.get("parameter_count"):
+                mismatches.append("input_bindings")
+            if len(outputs) != stage.get("output_length"):
+                mismatches.append("output_bindings")
+            if not leaves:
+                mismatches.append("leaves")
+            source_planes: list[tuple[str, str]] = []
+            if cell.measurement.backend == "jit":
+                source_level = cell.measurement.jit_optimization_level
+                if isinstance(source_level, bool) or not isinstance(
+                    source_level,
+                    int,
+                ):
+                    raise FinalAuditError(
+                        f"{lane_path}.stage[{index}] has no JIT optimization level"
+                    )
+                source_planes = _audit_symjit_plane_evaluator_leaves(
+                    stage.get("evaluator"),
+                    optimization_level=source_level,
+                    context=f"{lane_path}.stage[{index}].evaluator",
+                )
+                source_leaf_count = len(source_planes)
+            else:
+                source_leaf_count = _audit_source_evaluator(
+                    stage.get("evaluator"),
+                    cell,
+                    context=f"{lane_path}.stage[{index}].evaluator",
+                )
+            if source_leaf_count != len(leaves):
+                mismatches.append("source_evaluator_leaf_count")
+            for leaf_index, leaf in enumerate(leaves):
+                leaf_record = _mapping(leaf, f"{lane_path}.arena.leaf")
+                if leaf_record.get("source_application_abi") != expected_source:
+                    mismatches.append("leaf.source_application_abi")
+                if (
+                    cell.measurement.backend == "jit"
+                    and leaf_record.get("optimization_level")
+                    != cell.measurement.jit_optimization_level
+                ):
+                    mismatches.append("leaf.optimization_level")
+                if (
+                    cell.measurement.backend == "jit"
+                    and leaf_index < len(source_planes)
+                    and leaf_record.get("application_path")
+                    != source_planes[leaf_index][0]
+                ):
+                    mismatches.append("leaf.application_path")
+                expected_direct_level = (
+                    cell.measurement.jit_optimization_level
+                    if cell.measurement.backend == "jit"
+                    else 3
+                )
+                if (
+                    leaf_record.get("direct_codegen_optimization_level")
+                    != expected_direct_level
+                ):
+                    mismatches.append("leaf.direct_codegen_optimization_level")
+            if mismatches:
+                raise FinalAuditError(
+                    f"{lane_path} has incompatible plane-Arena metadata: "
+                    + ", ".join(sorted(set(mismatches)))
+                )
+            plane_count += 1
+            direct_leaf_count += len(leaves)
+        model_parameters = compiled.get("model_parameter_evaluator")
+        if model_parameters is not None:
+            _assert_model_parameter_not_direct(
+                model_parameters,
+                context=f"{lane_path}.model_parameter_evaluator",
+            )
+    return plane_count, direct_leaf_count
+
+
+def _assert_model_parameter_not_direct(
+    value: object,
+    *,
+    context: str,
+) -> None:
+    """Reject every compiled DirectApplication representation recursively."""
+
+    if isinstance(value, Mapping):
+        if value.get("kind") == "compiled-plane-arena-stage":
+            raise FinalAuditError(
+                f"{context} model-parameter evaluator entered plane Arena"
+            )
+        if "compiled_plane_arena" in value or "native_direct_application" in value:
+            raise FinalAuditError(
+                f"{context} model-parameter evaluator carries "
+                "DirectApplication metadata"
+            )
+        if value.get("application_abi") in {
+            _COMPILED_DIRECT_ABI,
+            _NATIVE_COMPILED_DIRECT_ABI,
+        }:
+            raise FinalAuditError(
+                f"{context} model-parameter evaluator uses a direct application ABI"
+            )
+        for name, child in value.items():
+            _assert_model_parameter_not_direct(
+                child,
+                context=f"{context}.{name}",
+            )
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        for index, child in enumerate(value):
+            _assert_model_parameter_not_direct(
+                child,
+                context=f"{context}[{index}]",
+            )
+
+
+def _assert_eager_model_parameter_not_direct(
+    value: object,
+    *,
+    context: str,
+) -> None:
+    """Reject every eager DirectTable representation recursively."""
+
+    if isinstance(value, Mapping):
+        if "direct_table" in value:
+            raise FinalAuditError(
+                f"{context} model-parameter evaluator carries DirectTable metadata"
+            )
+        direct_markers = {
+            _EAGER_DIRECT_CAPABILITY,
+            _EAGER_DIRECT_DESCRIPTOR_ABI,
+            _EAGER_DIRECT_BINDING_ABI,
+            _EAGER_NATIVE_APPLICATION_ABI,
+        }
+        for name, child in value.items():
+            if isinstance(child, str) and child in direct_markers:
+                raise FinalAuditError(
+                    f"{context}.{name} model-parameter evaluator uses eager "
+                    "Direct-Arena metadata"
+                )
+            _assert_eager_model_parameter_not_direct(
+                child,
+                context=f"{context}.{name}",
+            )
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        for index, child in enumerate(value):
+            _assert_eager_model_parameter_not_direct(
+                child,
+                context=f"{context}[{index}]",
+            )
+
+
+def _audit_eager_execution(
+    artifact: Path,
+    manifest: object,
+    execution: Mapping[str, object],
+    cell: CellSpec,
+) -> int:
+    if execution.get("kind") != "pyamplicol-runtime-eager-execution":
+        raise FinalAuditError("eager execution manifest kind is invalid")
+    plan = _mapping(execution.get("plan"), "eager execution.plan")
+    expected = {
+        "eager_plan_abi": "pyamplicol-eager-plan-v3",
+        "lowering_input_abi": "pyamplicol-eager-lowering-input-v1",
+        "runtime_layout_abi": "pyamplicol-eager-runtime-layout-v1",
+    }
+    for field, value in expected.items():
+        if plan.get(field) != value:
+            raise FinalAuditError(f"eager execution.plan.{field} is incompatible")
+    if execution.get("eager_plan_abi") != expected["eager_plan_abi"]:
+        raise FinalAuditError("eager execution eager_plan_abi is incompatible")
+    extensions = _mapping(manifest.extensions, "artifact.extensions")
+    prepared = _mapping(
+        extensions.get("eager_prepared_pack"),
+        "artifact.extensions.eager_prepared_pack",
+    )
+    if (
+        prepared.get("kind") != "pyamplicol-prepared-kernel-pack-identity"
+        or prepared.get("schema_version") != 1
+        or prepared.get("backend") != cell.measurement.backend
+        or prepared.get("eager_kernel_abi") != "pyamplicol-eager-kernel-v1"
+        or not isinstance(prepared.get("identity_sha256"), str)
+        or _SHA256_RE.fullmatch(str(prepared.get("identity_sha256"))) is None
+    ):
+        raise FinalAuditError("eager prepared-pack identity is incompatible")
+    kernel_pack = _mapping(execution.get("kernel_pack"), "eager kernel_pack")
+    raw_pack = kernel_pack.get("manifest_path")
+    pack, _pack_path, _pack_sha256 = _authenticated_json_payload(
+        artifact,
+        manifest,
+        raw_pack,
+        process_id=None,
+        context="eager kernel pack",
+    )
+    kernels = _sequence(pack.get("kernels"), "eager kernel pack.kernels")
+    prepared_kernel_count = prepared.get("kernel_count")
+    if (
+        isinstance(prepared_kernel_count, bool)
+        or not isinstance(prepared_kernel_count, int)
+        or prepared_kernel_count < len(kernels)
+        or not kernels
+    ):
+        raise FinalAuditError("eager prepared-pack kernel inventory is invalid")
+    direct_count = 0
+    expected_source = _expected_evaluator_abis(cell)[1]
+    for index, raw_kernel in enumerate(kernels):
+        kernel = _mapping(raw_kernel, f"eager kernel[{index}]")
+        evaluator = _mapping(
+            kernel.get("f64_evaluator_manifest"),
+            f"eager kernel[{index}].f64_evaluator_manifest",
+        )
+        direct = evaluator.get("direct_table")
+        if kernel.get("contract_kind") == "model-parameter":
+            _assert_eager_model_parameter_not_direct(
+                kernel,
+                context=f"eager kernel[{index}]",
+            )
+            continue
+        source_leaf_count = _audit_source_evaluator(
+            evaluator,
+            cell,
+            context=f"eager kernel[{index}].f64_evaluator_manifest",
+        )
+        if source_leaf_count != 1:
+            raise FinalAuditError(
+                f"eager kernel[{index}] has a non-canonical source leaf count"
+            )
+        table = _mapping(direct, f"eager kernel[{index}].direct_table")
+        expected = {
+            "capability": _EAGER_DIRECT_CAPABILITY,
+            "descriptor_abi": _EAGER_DIRECT_DESCRIPTOR_ABI,
+            "binding_abi": _EAGER_DIRECT_BINDING_ABI,
+            "source_application_abi": expected_source,
+        }
+        mismatches = [
+            field for field, value in expected.items() if table.get(field) != value
+        ]
+        if (
+            cell.measurement.backend == "jit"
+            and evaluator.get("optimization_level")
+            != cell.measurement.jit_optimization_level
+        ):
+            mismatches.append("optimization_level")
+        if mismatches:
+            raise FinalAuditError(
+                f"eager kernel[{index}] DirectTable identity differs: "
+                + ", ".join(mismatches)
+            )
+        direct_count += 1
+    if direct_count == 0:
+        raise FinalAuditError("eager artifact contains no direct-Arena kernels")
+    return direct_count
+
+
+def _audit_recurrence_source_pack(
+    artifact: Path,
+    manifest: object,
+    execution: Mapping[str, object],
+    cell: CellSpec,
+    *,
+    execution_manifest_path: str,
+    execution_manifest_sha256: str,
+) -> Mapping[str, object]:
+    if (
+        cell.measurement.backend != "jit"
+        or cell.measurement.jit_optimization_level != 2
+    ):
+        raise FinalAuditError(
+            "recurrence report cells require an authenticated JIT O2 source pack"
+        )
+    kernel_pack = _mapping(execution.get("kernel_pack"), "recurrence kernel_pack")
+    pack, pack_path, pack_sha256 = _authenticated_json_payload(
+        artifact,
+        manifest,
+        kernel_pack.get("manifest_path"),
+        process_id=None,
+        context="recurrence prepared kernel pack",
+    )
+    optimization = _mapping(
+        pack.get("optimization_settings"),
+        "recurrence prepared kernel pack.optimization_settings",
+    )
+    plan = _mapping(execution.get("plan"), "recurrence execution.plan")
+    expected_execution_abis = {
+        "direct_template_abi": _RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "direct_backend_abi": _RECURRENCE_DIRECT_BACKEND_ABI,
+    }
+    for field, expected in expected_execution_abis.items():
+        if execution.get(field) != expected or plan.get(field) != expected:
+            raise FinalAuditError(f"recurrence execution/plan {field} is incompatible")
+    prepared_kernel_pack_digest = _require_sha256(
+        execution.get("prepared_kernel_pack_digest"),
+        "recurrence execution.prepared_kernel_pack_digest",
+    )
+    direct_template_catalog_digest = _require_sha256(
+        execution.get("direct_template_catalog_digest"),
+        "recurrence execution.direct_template_catalog_digest",
+    )
+    if (
+        plan.get("prepared_kernel_pack_digest") != prepared_kernel_pack_digest
+        or plan.get("direct_template_catalog_digest") != direct_template_catalog_digest
+    ):
+        raise FinalAuditError("recurrence execution/plan source digests differ")
+    kernel_payload_root = _canonical_relative_path(
+        kernel_pack.get("payload_root"),
+        "recurrence kernel payload root",
+    ).as_posix()
+    mismatches = []
+    if pack.get("backend") != "jit":
+        mismatches.append("backend")
+    if optimization.get("backend") != "jit":
+        mismatches.append("optimization_settings.backend")
+    if optimization.get("jit_optimization_level") != 2:
+        mismatches.append("optimization_settings.jit_optimization_level")
+    direct_catalog = _mapping(
+        pack.get("recurrence_direct_template"),
+        "recurrence prepared kernel pack.recurrence_direct_template",
+    )
+    templates = _sequence(
+        direct_catalog.get("templates"),
+        "recurrence prepared kernel pack.recurrence_direct_template.templates",
+    )
+    expected_direct = {
+        "abi": _RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "backend": "jit",
+        "backend_abi": _RECURRENCE_DIRECT_BACKEND_ABI,
+        "canonicalization_abi": _RECURRENCE_DIRECT_CANONICALIZATION_ABI,
+        "optimization_level": 2,
+        "portable": True,
+    }
+    mismatches.extend(
+        f"recurrence_direct_template.{field}"
+        for field, expected in expected_direct.items()
+        if direct_catalog.get(field) != expected
+    )
+    if not templates:
+        mismatches.append("recurrence_direct_template.templates")
+    if (
+        direct_catalog.get("prepared_kernel_pack_digest") != prepared_kernel_pack_digest
+        or direct_catalog.get("catalog_digest") != direct_template_catalog_digest
+    ):
+        mismatches.append("recurrence_direct_template.execution_digest_links")
+    if _digest_mapping_without(direct_catalog, "catalog_digest") != (
+        direct_template_catalog_digest
+    ):
+        mismatches.append("recurrence_direct_template.catalog_digest")
+    if mismatches:
+        raise FinalAuditError(
+            "recurrence prepared kernel pack does not prove JIT O2: "
+            + ", ".join(mismatches)
+        )
+
+    evaluator_members = _authenticated_evaluator_container_members(
+        artifact,
+        manifest,
+    )
+    authenticated_source_payloads: dict[str, str] = {}
+
+    def authenticate_source_payload(relative: str, *, context: str) -> str:
+        cached = authenticated_source_payloads.get(relative)
+        if cached is not None:
+            return cached
+        result = _authenticated_recurrence_source_payload(
+            artifact,
+            manifest,
+            evaluator_members,
+            relative,
+            context=context,
+        )
+        authenticated_source_payloads[relative] = result
+        return result
+
+    kernels = _sequence(
+        pack.get("kernels"),
+        "recurrence prepared kernel pack.kernels",
+    )
+    variants = _sequence(
+        pack.get("kernel_variants"),
+        "recurrence prepared kernel pack.kernel_variants",
+    )
+    if not kernels:
+        raise FinalAuditError("recurrence prepared kernel pack has no source kernels")
+    source_leaves_by_kernel: dict[int, set[tuple[str, str]]] = {}
+    source_evaluator_leaf_count = 0
+    for index, raw_kernel in enumerate(kernels):
+        kernel = _mapping(
+            raw_kernel,
+            f"recurrence prepared kernel pack.kernels[{index}]",
+        )
+        kernel_id = kernel.get("kernel_id")
+        if (
+            isinstance(kernel_id, bool)
+            or not isinstance(kernel_id, int)
+            or kernel_id < 0
+            or kernel_id in source_leaves_by_kernel
+        ):
+            raise FinalAuditError(
+                f"recurrence prepared kernel pack.kernels[{index}] "
+                "has an invalid kernel ID"
+            )
+        leaves = _audit_recurrence_source_evaluator_leaves(
+            kernel.get("f64_evaluator_manifest"),
+            payload_root=kernel_payload_root,
+            authenticate_payload=authenticate_source_payload,
+            context=(
+                f"recurrence prepared kernel pack.kernels[{index}]"
+                ".f64_evaluator_manifest"
+            ),
+        )
+        source_evaluator_leaf_count += len(leaves)
+        source_leaves_by_kernel[kernel_id] = set(leaves)
+    for index, raw_variant in enumerate(variants):
+        variant = _mapping(
+            raw_variant,
+            f"recurrence prepared kernel pack.kernel_variants[{index}]",
+        )
+        source_evaluator_leaf_count += len(
+            _audit_recurrence_source_evaluator_leaves(
+                variant.get("f64_evaluator_manifest"),
+                payload_root=kernel_payload_root,
+                authenticate_payload=authenticate_source_payload,
+                context=(
+                    "recurrence prepared kernel pack."
+                    f"kernel_variants[{index}].f64_evaluator_manifest"
+                ),
+            )
+        )
+
+    prepared_direct_template_count = 0
+    for index, raw_template in enumerate(templates):
+        template = _mapping(
+            raw_template,
+            f"recurrence prepared kernel pack.direct_template[{index}]",
+        )
+        if (
+            template.get("abi") != _RECURRENCE_DIRECT_TEMPLATE_ABI
+            or template.get("backend") != "jit"
+            or template.get("portable") is not True
+            or template.get("optimization_level") != 2
+        ):
+            raise FinalAuditError(
+                f"recurrence direct template[{index}] contract is incompatible"
+            )
+        if _digest_mapping_without(template, "semantic_digest") != (
+            template.get("semantic_digest")
+        ):
+            raise FinalAuditError(
+                f"recurrence direct template[{index}] semantic digest is invalid"
+            )
+        binding = _mapping(
+            template.get("payload_binding"),
+            f"recurrence direct template[{index}].payload_binding",
+        )
+        if (
+            binding.get("abi") != _RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI
+            or _recurrence_payload_binding_digest(binding)
+            != binding.get("payload_digest")
+        ):
+            raise FinalAuditError(
+                f"recurrence direct template[{index}] payload-binding "
+                "contract is invalid"
+            )
+        binding_kind = binding.get("kind")
+        if binding_kind == "rusticol-intrinsic":
+            if (
+                binding.get("source_application_abi") is not None
+                or binding.get("direct_application_abi") is not None
+                or binding.get("source_application_path") is not None
+                or binding.get("source_application_sha256") is not None
+                or binding.get("payload_paths") != []
+                or not isinstance(binding.get("runtime_template"), str)
+                or not binding.get("runtime_template")
+            ):
+                raise FinalAuditError(
+                    f"recurrence direct template[{index}] intrinsic source "
+                    "contract is invalid"
+                )
+            continue
+        if binding_kind != "prepared-direct-call":
+            raise FinalAuditError(
+                f"recurrence direct template[{index}] is not executable"
+            )
+        prepared_direct_template_count += 1
+        source_path = _canonical_relative_path(
+            binding.get("source_application_path"),
+            f"recurrence direct template[{index}] source application",
+        ).as_posix()
+        source_sha256 = _require_sha256(
+            binding.get("source_application_sha256"),
+            f"recurrence direct template[{index}] source application digest",
+        )
+        prepared_kernel_id = binding.get("prepared_kernel_id")
+        if (
+            binding.get("source_application_abi") != _SYMJIT_PLANE_APPLICATION_ABI
+            or binding.get("direct_application_abi")
+            != _RECURRENCE_JIT_DIRECT_APPLICATION_ABI
+            or binding.get("payload_paths") != [source_path]
+            or isinstance(prepared_kernel_id, bool)
+            or not isinstance(prepared_kernel_id, int)
+            or prepared_kernel_id < 0
+            or (source_path, source_sha256)
+            not in source_leaves_by_kernel.get(prepared_kernel_id, set())
+        ):
+            raise FinalAuditError(
+                f"recurrence direct template[{index}] source application "
+                "is not bound to its prepared kernel"
+            )
+    if prepared_direct_template_count == 0 or source_evaluator_leaf_count == 0:
+        raise FinalAuditError(
+            "recurrence direct-template pack has no source application evidence"
+        )
+    return {
+        "kind": "authenticated-recurrence-direct-template-source-v1",
+        "optimization_level": 2,
+        "direct_template_count": len(templates),
+        "prepared_direct_template_count": prepared_direct_template_count,
+        "source_evaluator_leaf_count": source_evaluator_leaf_count,
+        "source_application_abi": _SYMJIT_PLANE_APPLICATION_ABI,
+        "direct_application_abi": _RECURRENCE_JIT_DIRECT_APPLICATION_ABI,
+        "prepared_kernel_pack_digest": prepared_kernel_pack_digest,
+        "direct_template_catalog_digest": direct_template_catalog_digest,
+        "execution_manifest_path": execution_manifest_path,
+        "execution_manifest_sha256": execution_manifest_sha256,
+        "kernel_pack_path": pack_path,
+        "kernel_pack_sha256": pack_sha256,
+    }
+
+
+def _require_sha256(value: object, context: str) -> str:
+    if not isinstance(value, str) or _SHA256_RE.fullmatch(value) is None:
+        raise FinalAuditError(f"{context} must be a lowercase SHA-256")
+    return value
+
+
+def _digest_mapping_without(value: Mapping[str, object], field: str) -> str:
+    payload = dict(value)
+    payload.pop(field, None)
+    return digest_json(payload)
+
+
+def _recurrence_payload_binding_digest(binding: Mapping[str, object]) -> str:
+    if binding.get("kind") != "rusticol-intrinsic":
+        return _digest_mapping_without(binding, "payload_digest")
+    if binding.get("role") == "contribution":
+        fields = (
+            "abi",
+            "destination_operation",
+            "contribution_parent_permutation",
+            "intrinsic_contract_digest",
+            "kind",
+            "role",
+            "runtime_template",
+            "scalar_input_count",
+            "scalar_projections",
+        )
+        return digest_json({field: binding.get(field) for field in fields})
+    # Source/finalization intrinsic digests include semantic-catalog fields
+    # which are not duplicated in the payload binding.  The opaque digest is
+    # nevertheless bound by the recomputed template and catalog identities.
+    return _require_sha256(
+        binding.get("payload_digest"),
+        "recurrence intrinsic payload digest",
+    )
+
+
+def _authenticated_evaluator_container_members(
+    artifact: Path,
+    manifest: object,
+) -> Mapping[str, tuple[int, str]]:
+    extensions = _mapping(
+        getattr(manifest, "extensions", None),
+        "artifact.extensions",
+    )
+    raw_container = extensions.get("evaluator_payload_container")
+    if raw_container is None:
+        return {}
+    container = _mapping(
+        raw_container,
+        "artifact.extensions.evaluator_payload_container",
+    )
+    required = {
+        "kind",
+        "schema_version",
+        "storage_abi",
+        "path",
+        "member_count",
+        "unpacked_size_bytes",
+        "index_sha256",
+    }
+    if (
+        set(container) != required
+        or container.get("kind") != "pyamplicol-evaluator-payload-container"
+        or container.get("schema_version") != 1
+        or container.get("storage_abi") != "pacbin-v1"
+    ):
+        raise FinalAuditError("artifact evaluator payload container contract drifted")
+    member_count = container.get("member_count")
+    unpacked_size = container.get("unpacked_size_bytes")
+    index_sha256 = _require_sha256(
+        container.get("index_sha256"),
+        "artifact evaluator payload container index digest",
+    )
+    if (
+        isinstance(member_count, bool)
+        or not isinstance(member_count, int)
+        or member_count < 0
+        or isinstance(unpacked_size, bool)
+        or not isinstance(unpacked_size, int)
+        or unpacked_size < 0
+    ):
+        raise FinalAuditError(
+            "artifact evaluator payload container inventory is invalid"
+        )
+    data, _canonical, _sha256 = _authenticated_payload_bytes(
+        artifact,
+        manifest,
+        container.get("path"),
+        role="evaluator-state",
+        media_type="application/octet-stream",
+        process_id=None,
+        context="evaluator payload container",
+    )
+    try:
+        from pyamplicol.generation.evaluator_container import PacbinReader
+
+        with PacbinReader.open(io.BytesIO(data), verify_payloads=True) as reader:
+            index = reader.index
+            members = tuple(reader.members)
+    except (OSError, TypeError, ValueError) as error:
+        raise FinalAuditError(
+            "authenticated evaluator payload container is invalid"
+        ) from error
+    if (
+        len(members) != member_count
+        or sum(member.length for member in members) != unpacked_size
+        or index.index_sha256 != index_sha256
+    ):
+        raise FinalAuditError(
+            "authenticated evaluator payload container index metadata drifted"
+        )
+    return {
+        member.logical_path: (int(member.kind), member.sha256) for member in members
+    }
+
+
+def _authenticated_recurrence_source_payload(
+    artifact: Path,
+    manifest: object,
+    evaluator_members: Mapping[str, tuple[int, str]],
+    relative: str,
+    *,
+    context: str,
+) -> str:
+    canonical = _canonical_relative_path(relative, context).as_posix()
+    payloads = getattr(manifest, "payloads", None)
+    if not isinstance(payloads, Sequence):
+        raise FinalAuditError(f"{context} has no artifact payload inventory")
+    loose = [
+        payload for payload in payloads if getattr(payload, "path", None) == canonical
+    ]
+    packed = evaluator_members.get(canonical)
+    if len(loose) + (packed is not None) != 1:
+        raise FinalAuditError(f"{context} payload is missing or ambiguous")
+    if loose:
+        _data, _canonical, sha256 = _authenticated_payload_bytes(
+            artifact,
+            manifest,
+            canonical,
+            role="evaluator-state",
+            media_type="application/octet-stream",
+            process_id=None,
+            context=context,
+        )
+        return sha256
+    assert packed is not None
+    kind, sha256 = packed
+    if kind != 1:
+        raise FinalAuditError(f"{context} is not a packed SymJIT application")
+    return _require_sha256(sha256, f"{context} packed member digest")
+
+
+def _audit_recurrence_source_evaluator_leaves(
+    value: object,
+    *,
+    payload_root: str,
+    authenticate_payload: Callable[..., str],
+    context: str,
+) -> list[tuple[str, str]]:
+    plane_leaves = _audit_symjit_plane_evaluator_leaves(
+        value,
+        optimization_level=2,
+        context=context,
+    )
+    result: list[tuple[str, str]] = []
+    for application_path, _source_digest in plane_leaves:
+        payload_path = (
+            PurePosixPath(payload_root) / PurePosixPath(application_path)
+        ).as_posix()
+        sha256 = authenticate_payload(
+            payload_path,
+            context=f"{context}.plane_application",
+        )
+        result.append((application_path, sha256))
+    return result
+
+
+def _audit_recurrence_execution(
+    execution: Mapping[str, object],
+    cell: CellSpec,
+) -> int:
+    if execution.get("kind") != "pyamplicol-runtime-recurrence-execution":
+        raise FinalAuditError("recurrence execution manifest kind is invalid")
+    expected = {
+        "builder_input_abi": "pyamplicol-recurrence-builder-input-v2",
+        "recurrence_plan_abi": "pyamplicol-recurrence-plan-v2",
+        "runtime_layout_abi": "pyamplicol-recurrence-runtime-layout-v2",
+        "direct_template_abi": "pyamplicol-recurrence-direct-template-v1",
+        "direct_backend_abi": "rusticol.recurrence-direct-backend.v1",
+    }
+    mismatches = [
+        field for field, value in expected.items() if execution.get(field) != value
+    ]
+    plan = _mapping(execution.get("plan"), "recurrence execution.plan")
+    mismatches.extend(
+        f"plan.{field}" for field, value in expected.items() if plan.get(field) != value
+    )
+    summary = _mapping(
+        plan.get("inspection_summary"),
+        "recurrence execution.plan.inspection_summary",
+    )
+    arena = _mapping(
+        summary.get("direct_arena"),
+        "recurrence execution.plan.inspection_summary.direct_arena",
+    )
+    for field in ("packed_input_bytes", "packed_output_bytes", "scatter_bytes"):
+        if arena.get(field) != 0:
+            mismatches.append(f"direct_arena.{field}")
+    capabilities = set(
+        str(value)
+        for value in _sequence(
+            execution.get("required_runtime_capabilities"),
+            "recurrence capabilities",
+        )
+    )
+    expected_color = (
+        "rusticol.recurrence-color.lc.v1"
+        if cell.measurement.accuracy is Accuracy.LC
+        else "rusticol.recurrence-color.contracted.v1"
+    )
+    if capabilities != {
+        _ARENA_CAPABILITY[ExecutionMode.RECURRENCE],
+        expected_color,
+    }:
+        mismatches.append("required_runtime_capabilities")
+    if mismatches:
+        raise FinalAuditError(
+            "recurrence direct-Arena identity differs: "
+            + ", ".join(sorted(set(mismatches)))
+        )
+    row_groups = arena.get("row_group_count")
+    if (
+        isinstance(row_groups, bool)
+        or not isinstance(row_groups, int)
+        or row_groups < 1
+    ):
+        raise FinalAuditError("recurrence direct Arena has no row groups")
+    return row_groups
+
+
+def _native_on_the_fly_process_seed_identity(payload: bytes) -> Mapping[str, object]:
+    """Decode one process seed with the production Rust authority."""
+
+    try:
+        module = importlib.import_module("pyamplicol._rusticol")
+        binding = getattr(module, "_inspect_on_the_fly_process_seed_v1", None)
+        if not callable(binding):
+            raise TypeError("native seed inspector is unavailable")
+        encoded = binding(payload)
+        if not isinstance(encoded, str):
+            raise TypeError("native seed inspector did not return JSON text")
+        decoded = json.loads(encoded)
+    except Exception as error:
+        raise FinalAuditError(
+            "on-the-fly compact seed cannot be decoded by the native authority"
+        ) from error
+    return _mapping(decoded, "native on-the-fly process-seed identity")
+
+
+def _audit_on_the_fly_process_seed_identity(
+    identity: Mapping[str, object],
+    runtime_metadata: Mapping[str, object],
+    pack: Mapping[str, object],
+) -> None:
+    """Bind decoded source identity to compact execution and prepared catalogs."""
+
+    if (
+        set(identity) != _ON_THE_FLY_PROCESS_SEED_IDENTITY_FIELDS
+        or identity.get("abi") != _ON_THE_FLY_PROCESS_SEED_IDENTITY_ABI
+    ):
+        raise FinalAuditError("on-the-fly process-seed identity contract differs")
+    for field in (
+        "process_digest",
+        "compiled_model_digest",
+        "recurrence_template_catalog_digest",
+        "prepared_kernel_pack_digest",
+        "recurrence_direct_template_catalog_digest",
+        "semantic_digest",
+    ):
+        if _SHA256_RE.fullmatch(str(identity.get(field))) is None:
+            raise FinalAuditError(
+                f"on-the-fly process-seed identity {field} is invalid"
+            )
+
+    template = _mapping(
+        pack.get("recurrence_template"),
+        "on-the-fly prepared recurrence template",
+    )
+    header = _mapping(
+        template.get("header"),
+        "on-the-fly prepared recurrence template header",
+    )
+    direct = _mapping(
+        pack.get("recurrence_direct_template"),
+        "on-the-fly prepared direct-template catalog",
+    )
+    expected_catalog_identities = {
+        "compiled_model_digest": header.get("compiled_model_digest"),
+        "recurrence_template_catalog_digest": header.get("catalog_digest"),
+        "prepared_kernel_pack_digest": header.get("prepared_kernel_pack_digest"),
+        "recurrence_direct_template_catalog_digest": direct.get("catalog_digest"),
+    }
+    if any(
+        identity.get(field) != expected
+        for field, expected in expected_catalog_identities.items()
+    ) or (
+        direct.get("compiled_model_digest") != header.get("compiled_model_digest")
+        or direct.get("recurrence_template_catalog_digest")
+        != header.get("catalog_digest")
+        or direct.get("prepared_kernel_pack_digest")
+        != header.get("prepared_kernel_pack_digest")
+    ):
+        raise FinalAuditError(
+            "on-the-fly process seed disagrees with its prepared catalogs"
+        )
+
+    external_legs = _sequence(
+        runtime_metadata.get("external_legs"),
+        "on-the-fly runtime metadata external_legs",
+    )
+    parameter_projection = _sequence(
+        runtime_metadata.get("parameter_projection"),
+        "on-the-fly runtime metadata parameter_projection",
+    )
+    permutation = _sequence(
+        identity.get("external_permutation"),
+        "on-the-fly process-seed external_permutation",
+    )
+    sources = _sequence(
+        identity.get("external_sources"),
+        "on-the-fly process-seed external_sources",
+    )
+    if (
+        len(permutation) != len(external_legs)
+        or len(sources) != len(external_legs)
+        or any(
+            isinstance(slot, bool) or not isinstance(slot, int) for slot in permutation
+        )
+        or sorted(permutation) != list(range(len(permutation)))
+    ):
+        raise FinalAuditError(
+            "on-the-fly process-seed external domain is not canonical"
+        )
+    mass_slots: dict[str, int | None] = {}
+    for index, raw_projection in enumerate(parameter_projection):
+        projection = _mapping(
+            raw_projection,
+            f"on-the-fly parameter_projection[{index}]",
+        )
+        runtime_name = projection.get("runtime_name")
+        component = projection.get("component")
+        prepared_id = projection.get("prepared_parameter_id")
+        if (
+            isinstance(runtime_name, str)
+            and runtime_name.startswith("particle.")
+            and runtime_name.endswith(".mass")
+            and component == 0
+            and (
+                prepared_id is None
+                or (not isinstance(prepared_id, bool) and isinstance(prepared_id, int))
+            )
+        ):
+            mass_slots[runtime_name] = prepared_id
+    for source_slot, (raw_source, raw_leg) in enumerate(
+        zip(sources, external_legs, strict=True)
+    ):
+        source = _mapping(
+            raw_source,
+            f"on-the-fly process-seed external_sources[{source_slot}]",
+        )
+        leg = _mapping(
+            raw_leg,
+            f"on-the-fly runtime metadata external_legs[{source_slot}]",
+        )
+        if set(source) != {"source_slot", "public_label", "is_initial", "states"}:
+            raise FinalAuditError("on-the-fly process-seed source contract differs")
+        outgoing_pdg = leg.get("outgoing_pdg")
+        if isinstance(outgoing_pdg, bool) or not isinstance(outgoing_pdg, int):
+            raise FinalAuditError("on-the-fly external source PDG is invalid")
+        expected_mass_slot = mass_slots.get(f"particle.{abs(outgoing_pdg)}.mass")
+        states = _sequence(
+            source.get("states"),
+            f"on-the-fly process-seed external_sources[{source_slot}].states",
+        )
+        if (
+            source.get("source_slot") != source_slot
+            or source.get("public_label") != leg.get("public_label")
+            or source.get("is_initial") != leg.get("is_initial")
+            or not states
+        ):
+            raise FinalAuditError(
+                "on-the-fly process-seed source identity disagrees with "
+                "runtime metadata"
+            )
+        previous_state_index = -1
+        for raw_state in states:
+            state = _mapping(raw_state, "on-the-fly process-seed source state")
+            state_index = state.get("state_index")
+            if (
+                set(state)
+                != {
+                    "state_index",
+                    "public_helicity",
+                    "prepared_mass_parameter_slot",
+                }
+                or isinstance(state_index, bool)
+                or not isinstance(state_index, int)
+                or state_index <= previous_state_index
+                or isinstance(state.get("public_helicity"), bool)
+                or not isinstance(state.get("public_helicity"), int)
+                or state.get("prepared_mass_parameter_slot") != expected_mass_slot
+            ):
+                raise FinalAuditError(
+                    "on-the-fly process-seed source state or mass slot differs"
+                )
+            previous_state_index = state_index
+
+
+def _audit_on_the_fly_color_contraction(
+    artifact: Path,
+    manifest: object,
+    runtime_metadata: Mapping[str, object],
+    cell: CellSpec,
+    *,
+    process_id: str,
+    execution_manifest_path: str,
+) -> None:
+    """Authenticate the loose contracted-colour payload without dense axes."""
+
+    raw = runtime_metadata.get("color_contraction")
+    if cell.measurement.accuracy is Accuracy.LC:
+        if raw is not None or "color_contraction" in runtime_metadata:
+            raise FinalAuditError(
+                "LC on-the-fly execution unexpectedly carries color contraction"
+            )
+        return
+    reference = _mapping(raw, "on-the-fly color contraction")
+    expected_fields = {
+        "abi",
+        "color_accuracy",
+        "storage",
+        "includes_color_factor",
+        "group_count",
+        "sector_count",
+        "active_sector_count",
+        "component_count",
+        "destination_count",
+        "entry_count",
+        "logical_entry_count",
+        "semantic_digest",
+        "factorization",
+        "path",
+        "size_bytes",
+        "sha256",
+    }
+    counters: dict[str, int] = {}
+    for field in (
+        "group_count",
+        "sector_count",
+        "active_sector_count",
+        "component_count",
+        "destination_count",
+        "entry_count",
+        "logical_entry_count",
+        "size_bytes",
+    ):
+        value = reference.get(field)
+        if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+            raise FinalAuditError(
+                f"on-the-fly color contraction {field} must be positive"
+            )
+        counters[field] = value
+    payload_sha256 = reference.get("sha256")
+    if (
+        set(reference) != expected_fields
+        or reference.get("abi") != _ON_THE_FLY_COLOR_CONTRACTION_ABI
+        or reference.get("color_accuracy") != cell.measurement.accuracy.value
+        or reference.get("storage") != "expanded"
+        or reference.get("includes_color_factor") is not True
+        or reference.get("factorization") is not None
+        or counters["component_count"] != 1
+        or counters["active_sector_count"] != counters["group_count"]
+        or counters["destination_count"] != counters["group_count"]
+        or counters["group_count"] > counters["sector_count"]
+        or counters["logical_entry_count"] != counters["entry_count"]
+        or reference.get("path") != "on-the-fly-color.bin"
+        or not isinstance(payload_sha256, str)
+        or _SHA256_RE.fullmatch(payload_sha256) is None
+        or reference.get("semantic_digest") != payload_sha256
+    ):
+        raise FinalAuditError(
+            "on-the-fly contracted color payload reference is noncanonical"
+        )
+    execution_parent = PurePosixPath(execution_manifest_path).parent
+    relative = (
+        execution_parent
+        / _canonical_relative_path(
+            reference["path"],
+            "on-the-fly color contraction",
+        )
+    ).as_posix()
+    data, _payload_path, authenticated_sha256 = _authenticated_payload_bytes(
+        artifact,
+        manifest,
+        relative,
+        role="evaluator-state",
+        media_type="application/octet-stream",
+        process_id=process_id,
+        context="on-the-fly color contraction",
+    )
+    if authenticated_sha256 != payload_sha256 or len(data) != counters["size_bytes"]:
+        raise FinalAuditError(
+            "on-the-fly contracted color payload differs from its reference"
+        )
+
+
+def _audit_on_the_fly_execution(
+    artifact: Path,
+    manifest: object,
+    execution: Mapping[str, object],
+    cell: CellSpec,
+    *,
+    process_id: str,
+    execution_manifest_path: str,
+    effective_config: Mapping[str, object] | None = None,
+) -> int:
+    """Authenticate the compact OTF seed and its prepared JIT source pack."""
+
+    expected_fields = {
+        "schema_version",
+        "kind",
+        "required_runtime_capabilities",
+        "process",
+        "key",
+        "color_accuracy",
+        "external_pdg_order",
+        "kernel_pack",
+        "runtime_options",
+        "selector_policy",
+        "runtime_metadata",
+        "runtime_container",
+    }
+    capabilities = tuple(
+        str(value)
+        for value in _sequence(
+            execution.get("required_runtime_capabilities"),
+            "on-the-fly execution capabilities",
+        )
+    )
+    expected_color_capability = (
+        _ON_THE_FLY_LC_COLOR_CAPABILITY
+        if cell.measurement.accuracy is Accuracy.LC
+        else _ON_THE_FLY_CONTRACTED_COLOR_CAPABILITY
+    )
+    if (
+        set(execution) != expected_fields
+        or execution.get("schema_version") != 3
+        or execution.get("kind") != _ON_THE_FLY_EXECUTION_KIND
+        or execution.get("process") != cell.process
+        or execution.get("key") != process_id
+        or execution.get("color_accuracy") != cell.measurement.accuracy.value
+        or len(capabilities) != 2
+        or set(capabilities)
+        != {
+            _ARENA_CAPABILITY[ExecutionMode.ON_THE_FLY],
+            expected_color_capability,
+        }
+        or (
+            cell.measurement.accuracy is Accuracy.LC
+            and cell.workload not in {Workload.SELECTED_FLOW, Workload.ALL_FLOW}
+        )
+        or (
+            cell.measurement.accuracy in {Accuracy.NLC, Accuracy.FULL}
+            and cell.workload is not Workload.CONTRACTED
+        )
+        or cell.measurement.backend != "jit"
+        or cell.measurement.jit_optimization_level != 2
+    ):
+        raise FinalAuditError("on-the-fly execution compact contract differs")
+    external_pdgs = _sequence(
+        execution.get("external_pdg_order"),
+        "on-the-fly execution external_pdg_order",
+    )
+    if len(external_pdgs) != cell.n_final + 2 or any(
+        isinstance(value, bool) or not isinstance(value, int) for value in external_pdgs
+    ):
+        raise FinalAuditError("on-the-fly execution external PDG order is invalid")
+    runtime_options = _mapping(
+        execution.get("runtime_options"),
+        "on-the-fly execution runtime_options",
+    )
+    point_tile_size = runtime_options.get("point_tile_size")
+    query_construction_threads = runtime_options.get("query_construction_threads")
+    contracted_color = cell.measurement.accuracy in {Accuracy.NLC, Accuracy.FULL}
+    expected_color_coverage = "contracted" if contracted_color else "complete"
+    if (
+        set(runtime_options) != {"point_tile_size", "query_construction_threads"}
+        or isinstance(point_tile_size, bool)
+        or not isinstance(point_tile_size, int)
+        or point_tile_size < 1
+        or isinstance(query_construction_threads, bool)
+        or not isinstance(query_construction_threads, int)
+        or query_construction_threads < 1
+    ):
+        raise FinalAuditError("on-the-fly execution runtime options are invalid")
+    if effective_config is not None:
+        evaluator = _mapping(
+            effective_config.get("evaluator"),
+            "on-the-fly authenticated effective evaluator configuration",
+        )
+        optimization = _mapping(
+            evaluator.get("optimization"),
+            "on-the-fly authenticated effective evaluator optimization",
+        )
+        effective_cores = optimization.get("cores")
+        if (
+            isinstance(effective_cores, bool)
+            or not isinstance(effective_cores, int)
+            or effective_cores < 1
+            or query_construction_threads != effective_cores
+        ):
+            raise FinalAuditError(
+                "on-the-fly query construction threads differ from the "
+                "authenticated effective evaluator cores"
+            )
+    selector_policy = _mapping(
+        execution.get("selector_policy"),
+        "on-the-fly selector_policy",
+    )
+    if (
+        set(selector_policy)
+        != {
+            "color_coverage",
+            "reference_color_word",
+            "trace_reflections_folded",
+            "selector_census",
+        }
+        or selector_policy.get("color_coverage") != expected_color_coverage
+        or not isinstance(selector_policy.get("trace_reflections_folded"), bool)
+        or (
+            contracted_color
+            and selector_policy.get("trace_reflections_folded") is not False
+        )
+    ):
+        raise FinalAuditError("on-the-fly selector policy differs")
+    reference_color_word = selector_policy.get("reference_color_word")
+    if contracted_color and reference_color_word is not None:
+        raise FinalAuditError(
+            "contracted on-the-fly selector policy has a flow selector"
+        )
+    if reference_color_word is not None:
+        reference = _sequence(
+            reference_color_word,
+            "on-the-fly selector policy reference_color_word",
+        )
+        if (
+            not reference
+            or any(
+                isinstance(label, bool) or not isinstance(label, int) or label < 1
+                for label in reference
+            )
+            or len(set(reference)) != len(reference)
+        ):
+            raise FinalAuditError("on-the-fly selector reference word is invalid")
+    selector_census = _mapping(
+        selector_policy.get("selector_census"),
+        "on-the-fly selector census",
+    )
+    if set(selector_census) != {
+        "physical_helicity_count",
+        "physical_color_flow_count",
+    }:
+        raise FinalAuditError("on-the-fly selector census fields differ")
+    for field in ("physical_helicity_count", "physical_color_flow_count"):
+        count = selector_census.get(field)
+        if (
+            isinstance(count, bool)
+            or not isinstance(count, int)
+            or count < 1
+            or count > (1 << 64) - 1
+        ):
+            raise FinalAuditError(
+                f"on-the-fly selector census {field} is outside positive u64"
+            )
+    if contracted_color and selector_census["physical_color_flow_count"] != 1:
+        raise FinalAuditError(
+            "contracted on-the-fly selector census must expose one color result"
+        )
+    runtime_metadata = _mapping(
+        execution.get("runtime_metadata"),
+        "on-the-fly runtime_metadata",
+    )
+    _audit_on_the_fly_color_contraction(
+        artifact,
+        manifest,
+        runtime_metadata,
+        cell,
+        process_id=process_id,
+        execution_manifest_path=execution_manifest_path,
+    )
+
+    kernel_pack = _mapping(
+        execution.get("kernel_pack"),
+        "on-the-fly execution kernel_pack",
+    )
+    if kernel_pack != {
+        "manifest_path": "model/eager-kernel-pack.json",
+        "payload_root": "model/eager-kernels",
+    }:
+        raise FinalAuditError("on-the-fly prepared-kernel paths are not canonical")
+    pack, _pack_path, _pack_sha256 = _authenticated_json_payload(
+        artifact,
+        manifest,
+        kernel_pack["manifest_path"],
+        process_id=None,
+        context="on-the-fly prepared kernel pack",
+    )
+    dependencies = _mapping(
+        pack.get("dependency_abis"),
+        "on-the-fly prepared kernel pack dependency_abis",
+    )
+    optimization = _mapping(
+        pack.get("optimization_settings"),
+        "on-the-fly prepared kernel pack optimization_settings",
+    )
+    if (
+        pack.get("backend") != "jit"
+        or pack.get("eager_kernel_abi") != "pyamplicol-eager-kernel-v1"
+        or dependencies.get("symjit_application") != _SYMJIT_APPLICATION_ABI
+        or dependencies.get("symjit_plane_application") != _SYMJIT_PLANE_APPLICATION_ABI
+        or optimization.get("backend") != "jit"
+        or optimization.get("jit_optimization_level") != 2
+    ):
+        raise FinalAuditError("on-the-fly prepared kernel pack does not prove JIT O2")
+    kernels = _sequence(pack.get("kernels"), "on-the-fly prepared kernels")
+    variants = _sequence(
+        pack.get("kernel_variants"),
+        "on-the-fly prepared kernel variants",
+    )
+    source_leaf_count = 0
+    for label, records in (("kernels", kernels), ("kernel_variants", variants)):
+        for index, raw_record in enumerate(records):
+            record = _mapping(raw_record, f"on-the-fly {label}[{index}]")
+            if record.get("contract_kind") == "model-parameter":
+                continue
+            source_leaf_count += _audit_source_evaluator(
+                record.get("f64_evaluator_manifest"),
+                cell,
+                context=f"on-the-fly {label}[{index}].f64_evaluator_manifest",
+            )
+    extensions = _mapping(getattr(manifest, "extensions", None), "artifact.extensions")
+    prepared = _mapping(
+        extensions.get("eager_prepared_pack"),
+        "artifact.extensions.eager_prepared_pack",
+    )
+    expected_prepared = _expected_eager_prepared_pack_identity(cell)
+    if (
+        not kernels
+        or source_leaf_count < 1
+        or set(prepared) != set(expected_prepared)
+        or any(
+            prepared.get(field) != value for field, value in expected_prepared.items()
+        )
+        or prepared.get("kernel_count") != len(kernels)
+    ):
+        raise FinalAuditError("on-the-fly prepared-pack identity is incompatible")
+
+    container = _mapping(
+        execution.get("runtime_container"),
+        "on-the-fly runtime container",
+    )
+    if container != {
+        "kind": _ON_THE_FLY_RUNTIME_CONTAINER_KIND,
+        "schema_version": 1,
+        "storage_abi": _ON_THE_FLY_RUNTIME_STORAGE_ABI,
+        "path": "on-the-fly-runtime.pacbin",
+        "seed_member_path": _ON_THE_FLY_SEED_MEMBER_PATH,
+    }:
+        raise FinalAuditError("on-the-fly runtime container contract differs")
+    execution_parent = PurePosixPath(execution_manifest_path).parent
+    runtime_relative = (
+        execution_parent
+        / _canonical_relative_path(
+            container["path"],
+            "on-the-fly runtime container",
+        )
+    ).as_posix()
+    data, _runtime_path, _runtime_sha256 = _authenticated_payload_bytes(
+        artifact,
+        manifest,
+        runtime_relative,
+        role="evaluator-state",
+        media_type="application/octet-stream",
+        process_id=process_id,
+        context="on-the-fly runtime container",
+    )
+    try:
+        from pyamplicol.generation.evaluator_container import (
+            PacbinMemberKind,
+            PacbinReader,
+        )
+
+        with PacbinReader.open(io.BytesIO(data), verify_payloads=True) as reader:
+            members = tuple(reader.members)
+            if (
+                len(members) != 1
+                or members[0].logical_path != _ON_THE_FLY_SEED_MEMBER_PATH
+                or members[0].kind is not PacbinMemberKind.ON_THE_FLY_PROCESS_SEED
+                or members[0].length < 1
+            ):
+                raise FinalAuditError(
+                    "on-the-fly runtime container does not contain exactly its "
+                    "compact seed"
+                )
+            seed_payload = reader.read_member(
+                _ON_THE_FLY_SEED_MEMBER_PATH,
+                length=members[0].length,
+            )
+    except FinalAuditError:
+        raise
+    except (OSError, TypeError, ValueError) as error:
+        raise FinalAuditError("on-the-fly runtime container is invalid") from error
+    native_identity = _native_on_the_fly_process_seed_identity(seed_payload)
+    recorded_identity = _mapping(
+        runtime_metadata.get("process_seed_identity"),
+        "on-the-fly runtime metadata process_seed_identity",
+    )
+    if native_identity != recorded_identity:
+        raise FinalAuditError(
+            "on-the-fly runtime metadata does not identify its native compact seed"
+        )
+    _audit_on_the_fly_process_seed_identity(
+        native_identity,
+        runtime_metadata,
+        pack,
+    )
+    seed_helicity_count = math.prod(
+        len(
+            _sequence(
+                _mapping(source, "on-the-fly native source identity").get("states"),
+                "on-the-fly native source identity states",
+            )
+        )
+        for source in _sequence(
+            native_identity.get("external_sources"),
+            "on-the-fly native source identities",
+        )
+    )
+    if seed_helicity_count != selector_census["physical_helicity_count"]:
+        raise FinalAuditError(
+            "on-the-fly selector helicity census disagrees with the decoded seed"
+        )
+    return source_leaf_count
+
+
+def audit_artifact(
+    cell: CellSpec,
+    artifact: Path,
+    process_id: str,
+) -> ArtifactEvidence:
+    """Authenticate one artifact and prove the mode-specific Arena ABI."""
+
+    from pyamplicol.artifacts import inspect_artifact, load_manifest
+
+    inspection = inspect_artifact(artifact)
+    if inspection.integrity != "verified":
+        raise FinalAuditError(f"artifact integrity is not verified: {artifact}")
+    # ``inspect_artifact`` has just verified every payload.  Re-load the typed
+    # manifest without hashing the potentially large evaluator container twice;
+    # every identity-bearing JSON/TOML payload below is then re-read through a
+    # checked descriptor against its own manifest size and SHA-256.
+    manifest = load_manifest(artifact, verify_payloads=False)
+    effective_config = _authenticated_effective_config(artifact, manifest)
+    _audit_effective_config_mapping(
+        cell,
+        effective_config,
+        context="authenticated effective configuration",
+    )
+    _audit_model_source(cell, effective_config)
+    process_matches = [
+        process for process in manifest.processes if process.get("id") == process_id
+    ]
+    inspected_matches = [
+        process for process in inspection.processes if process.id == process_id
+    ]
+    if len(process_matches) != 1 or len(inspected_matches) != 1:
+        raise FinalAuditError(
+            f"artifact process {process_id!r} is missing or ambiguous"
+        )
+    process = process_matches[0]
+    inspected = inspected_matches[0]
+    expected_layout = (
+        "compact/query-local"
+        if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+        else (
+            "all-flow-union"
+            if cell.workload is Workload.ALL_FLOW
+            else "topology-replay"
+        )
+    )
+    if (
+        process.get("expression") != cell.process
+        or process.get("color_accuracy") != cell.measurement.accuracy.value
+        or inspected.execution_mode != cell.measurement.execution_mode.value
+        or inspected.generation_specialized_axes
+        or inspected.selected_source_helicities
+        or inspected.selected_color_sector_ids
+        or (
+            cell.measurement.accuracy is Accuracy.LC
+            and inspected.lc_flow_layout != expected_layout
+        )
+    ):
+        raise FinalAuditError(
+            f"artifact physics/execution contract differs for {cell.cell_id}"
+        )
+    (
+        execution,
+        execution_path,
+        execution_sha256,
+        indexed_capabilities,
+    ) = _find_process_execution(artifact, manifest, process_id)
+    capabilities = tuple(
+        str(value) for value in process["required_runtime_capabilities"]
+    )
+    if capabilities != indexed_capabilities:
+        raise FinalAuditError("artifact and evaluator-index capabilities differ")
+    expected_capability = _ARENA_CAPABILITY[cell.measurement.execution_mode]
+    if expected_capability not in capabilities:
+        raise FinalAuditError(
+            f"artifact does not require final Arena capability {expected_capability}"
+        )
+    if cell.measurement.execution_mode is ExecutionMode.COMPILED:
+        arena_count, direct_leaf_count = _audit_compiled_execution(execution, cell)
+        source_jit_identity = None
+    elif cell.measurement.execution_mode is ExecutionMode.EAGER:
+        arena_count = _audit_eager_execution(artifact, manifest, execution, cell)
+        direct_leaf_count = arena_count
+        source_jit_identity = None
+    elif cell.measurement.execution_mode is ExecutionMode.RECURRENCE:
+        source_jit_identity = _audit_recurrence_source_pack(
+            artifact,
+            manifest,
+            execution,
+            cell,
+            execution_manifest_path=execution_path,
+            execution_manifest_sha256=execution_sha256,
+        )
+        arena_count = _audit_recurrence_execution(execution, cell)
+        direct_leaf_count = 0
+    elif cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY:
+        arena_count = _audit_on_the_fly_execution(
+            artifact,
+            manifest,
+            execution,
+            cell,
+            process_id=process_id,
+            execution_manifest_path=execution_path,
+            effective_config=effective_config,
+        )
+        direct_leaf_count = 0
+        source_jit_identity = None
+    else:
+        raise FinalAuditError(
+            "unsupported artifact execution mode "
+            f"{cell.measurement.execution_mode.value}"
+        )
+    return ArtifactEvidence(
+        artifact_id=manifest.artifact_id,
+        process_id=process_id,
+        producer_version=str(manifest.producer["version"]),
+        producer_git_revision=(
+            None
+            if manifest.producer.get("git_revision") is None
+            else str(manifest.producer["git_revision"])
+        ),
+        producer_native_build_inputs_sha256=(
+            None
+            if manifest.producer.get("native_build_inputs_sha256") is None
+            else str(manifest.producer["native_build_inputs_sha256"])
+        ),
+        runtime_version=str(manifest.runtime["engine_version"]),
+        runtime_capabilities=capabilities,
+        execution_manifest_path=execution_path,
+        execution_manifest_sha256=execution_sha256,
+        execution_mode=cell.measurement.execution_mode.value,
+        arena_record_count=arena_count,
+        direct_leaf_count=direct_leaf_count,
+        effective_config=effective_config,
+        source_jit_identity=source_jit_identity,
+    )
+
+
+def _selector_kwargs(
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+) -> dict[str, tuple[str, ...] | None]:
+    if cell.measurement.accuracy is not Accuracy.LC:
+        return {"helicities": None, "color_flows": None}
+    contract = SelectorContract.from_mapping(
+        _mapping(
+            measurement.get("selector_contract"),
+            f"{cell.cell_id}.selector_contract",
+        )
+    )
+    if cell.workload is Workload.SELECTED_FLOW:
+        return {
+            "helicities": None,
+            "color_flows": contract.selected_color_flow_ids,
+        }
+    return {
+        "helicities": contract.runtime_all_flow_helicity_ids,
+        "color_flows": None,
+    }
+
+
+def _real_nonnegative(value: object, context: str) -> float:
+    number = complex(value)
+    if not math.isfinite(number.real) or not math.isfinite(number.imag):
+        raise FinalAuditError(f"{context} is not finite")
+    if abs(number.imag) > 1.0e-9 * max(abs(number.real), 1.0):
+        raise FinalAuditError(f"{context} has a non-negligible imaginary part")
+    result = float(number.real)
+    if result < -ABSOLUTE_TOLERANCE:
+        raise FinalAuditError(f"{context} is materially negative")
+    return max(result, 0.0)
+
+
+def _resolved_differences(
+    optimized: Sequence[object],
+    resolved_totals: Sequence[object],
+    *,
+    context: str,
+) -> tuple[float, float]:
+    if len(optimized) != len(resolved_totals):
+        raise FinalAuditError(f"{context} optimized/resolved lengths differ")
+    maximum_absolute = 0.0
+    maximum_relative = 0.0
+    for candidate, baseline in zip(optimized, resolved_totals, strict=True):
+        absolute = abs(complex(candidate) - complex(baseline))
+        relative = absolute / max(abs(complex(candidate)), 1.0e-300)
+        maximum_absolute = max(maximum_absolute, absolute)
+        maximum_relative = max(maximum_relative, relative)
+    return maximum_absolute, maximum_relative
+
+
+def _replay_cell(
+    runtime: object,
+    reference: _ArtifactReference,
+    evidence: ArtifactEvidence,
+) -> _ReplayObservation:
+    cell = reference.cell
+    measurement = reference.measurement
+    context = f"{cell.cell_id}.replay"
+    if getattr(runtime, "artifact_id", None) != evidence.artifact_id:
+        raise FinalAuditError(f"{context} loaded artifact ID differs")
+    expected_mode = cell.measurement.execution_mode.value
+    loaded_mode = getattr(runtime, "execution_mode", None)
+    if loaded_mode != expected_mode or evidence.execution_mode != expected_mode:
+        raise FinalAuditError(
+            f"{context} loaded execution mode differs from requested {expected_mode!r}"
+        )
+    provenance = _mapping(
+        measurement.get("provenance"),
+        f"{context}.provenance",
+    )
+    runtime_identity = _mapping(
+        provenance.get("runtime_identity"),
+        f"{context}.provenance.runtime_identity",
+    )
+    if runtime_identity.get("loaded_execution_mode") != loaded_mode:
+        raise FinalAuditError(
+            f"{context} stored loaded_execution_mode differs from the runtime"
+        )
+    validate_runtime_contract(cell, runtime)  # type: ignore[arg-type]
+    points = (
+        runtime_validation_points(runtime)
+        if cell.measurement.model in {ModelKey.SCALAR_CONTACT, ModelKey.SCALAR_GRAVITY}
+        else shared_validation_points(cell.process)
+    )
+    raw_selector = measurement.get("selector_contract")
+    if raw_selector is not None:
+        validate_selector_contract(
+            runtime,  # type: ignore[arg-type]
+            SelectorContract.from_mapping(_mapping(raw_selector, context)),
+            points,
+            cell=cell,
+        )
+    selectors = _selector_kwargs(cell, measurement)
+    optimized = tuple(
+        runtime.evaluate(  # type: ignore[attr-defined]
+            points,
+            precision=16,
+            **selectors,
+        )
+    )
+    if not optimized:
+        raise FinalAuditError(f"{context} returned no matrix elements")
+    observed_matrix = _real_nonnegative(optimized[0], f"{context}.matrix_element")
+    stored_matrix = _finite_number(
+        measurement.get("matrix_element"), f"{context}.stored_matrix_element"
+    )
+    validation = _mapping(
+        measurement.get("validation"),
+        f"{context}.validation",
+    )
+    stored_resolved = _mapping(
+        validation.get("resolved_sum"),
+        f"{context}.validation.resolved_sum",
+    )
+    matrix_absolute = abs(observed_matrix - stored_matrix)
+    matrix_scale = max(abs(observed_matrix), abs(stored_matrix))
+    if stored_resolved.get("abi") == RESOLVED_SUM_VALIDATION_ABI:
+        records = stored_resolved.get("points")
+        if (
+            not isinstance(records, list)
+            or len(records) != 1
+            or not isinstance(records[0], Mapping)
+        ):
+            raise FinalAuditError(f"{context} has invalid resolved scale evidence")
+        matrix_scale = max(
+            matrix_scale,
+            _finite_number(
+                records[0].get("candidate_scale"),
+                f"{context}.candidate_scale",
+                nonnegative=True,
+            ),
+        )
+    if matrix_absolute > RELATIVE_TOLERANCE * matrix_scale:
+        raise FinalAuditError(
+            f"{context} no longer reproduces the stored matrix element"
+        )
+    resolved = runtime.evaluate_resolved(  # type: ignore[attr-defined]
+        points,
+        precision=16,
+        **selectors,
+    )
+    if stored_resolved.get("abi") == RESOLVED_SUM_VALIDATION_ABI:
+        replayed_resolved = resolved_sum_validation(
+            runtime,  # type: ignore[arg-type]
+            points,
+            cell=cell,
+            selector_contract=(
+                None
+                if raw_selector is None
+                else SelectorContract.from_mapping(_mapping(raw_selector, context))
+            ),
+            precision=16,
+        )
+        if replayed_resolved != dict(stored_resolved):
+            raise FinalAuditError(
+                f"{context} recomputed conditioned resolved evidence differs"
+            )
+        maximum_absolute = _finite_number(
+            replayed_resolved.get("maximum_absolute_difference"),
+            f"{context}.maximum_absolute_difference",
+            nonnegative=True,
+        )
+        maximum_relative = _finite_number(
+            replayed_resolved.get("maximum_relative_difference"),
+            f"{context}.maximum_relative_difference",
+            nonnegative=True,
+        )
+    else:
+        resolved_totals = tuple(resolved.total())
+        maximum_absolute, maximum_relative = _resolved_differences(
+            optimized,
+            resolved_totals,
+            context=context,
+        )
+        for field, observed in (
+            ("maximum_absolute_difference", maximum_absolute),
+            ("maximum_relative_difference", maximum_relative),
+        ):
+            stored = _finite_number(stored_resolved.get(field), f"{context}.{field}")
+            if not math.isclose(
+                observed,
+                stored,
+                rel_tol=RELATIVE_TOLERANCE,
+                abs_tol=ABSOLUTE_TOLERANCE,
+            ):
+                raise FinalAuditError(
+                    f"{context} recomputed {field} differs from stored evidence"
+                )
+    if validation.get("high_precision") is not None:
+        high_record = _mapping(
+            validation.get("high_precision"),
+            f"{context}.validation.high_precision",
+        )
+        if high_record.get("abi") == CONDITIONED_COMPARISON_ABI:
+            replayed_high_resolved = resolved_sum_validation(
+                runtime,  # type: ignore[arg-type]
+                points,
+                cell=cell,
+                selector_contract=(
+                    None
+                    if raw_selector is None
+                    else SelectorContract.from_mapping(_mapping(raw_selector, context))
+                ),
+                precision=32,
+            )
+            if replayed_high_resolved != validation.get("high_precision_resolved_sum"):
+                raise FinalAuditError(
+                    f"{context} recomputed p32 resolved evidence differs"
+                )
+            high_value = _finite_number(
+                _mapping(
+                    replayed_high_resolved["points"][0],
+                    f"{context}.precision32.point",
+                ).get("candidate"),
+                f"{context}.precision32",
+                nonnegative=True,
+            )
+        else:
+            high_precision = tuple(
+                runtime.evaluate(  # type: ignore[attr-defined]
+                    points,
+                    precision=32,
+                    **selectors,
+                )
+            )
+            if not high_precision:
+                raise FinalAuditError(f"{context} precision-32 evaluation is empty")
+            high_value = _real_nonnegative(high_precision[0], f"{context}.precision32")
+        _audit_pointwise(
+            high_record,
+            context=f"{context}.validation.high_precision",
+            expected_candidate=observed_matrix,
+            expected_baseline=high_value,
+            expected_relative_tolerance=RELATIVE_TOLERANCE,
+            expected_point_digest=point_digest(points),
+        )
+    common_component: float | None = None
+    if cell.measurement.accuracy is Accuracy.LC:
+        assert raw_selector is not None
+        common_record = evaluate_lc_common_component(
+            runtime,
+            points,
+            cell=cell,
+            contract=SelectorContract.from_mapping(
+                _mapping(raw_selector, f"{context}.selector_contract")
+            ),
+        )
+        common_component = _finite_number(
+            common_record.get("value"),
+            f"{context}.lc_common_component",
+        )
+        stored_component = _audit_lc_common_component(
+            cell,
+            measurement,
+            context=context,
+        )
+        absolute = abs(common_component - stored_component)
+        relative = absolute / max(abs(stored_component), 1.0e-300)
+        if (
+            absolute > STRICT_ABSOLUTE_TOLERANCE
+            and relative > STRICT_RELATIVE_TOLERANCE
+        ):
+            raise FinalAuditError(
+                f"{context} no longer reproduces the stored LC common component"
+            )
+    return _ReplayObservation(
+        matrix_element=observed_matrix,
+        resolved_maximum_absolute=maximum_absolute,
+        resolved_maximum_relative=maximum_relative,
+        lc_common_component=common_component,
+    )
+
+
+def _default_runtime_loader(path: Path, process_id: str) -> object:
+    from pyamplicol.api import Runtime
+
+    return Runtime.load(path, process=process_id)
+
+
+def _entry_map(
+    caches: Mapping[str, Mapping[str, object]],
+) -> dict[str, Mapping[str, object]]:
+    result: dict[str, Mapping[str, object]] = {}
+    for cache_name, payload in caches.items():
+        entries = _sequence(payload.get("entries"), f"{cache_name}.entries")
+        for raw_entry in entries:
+            entry = _mapping(raw_entry, f"{cache_name}.entry")
+            cell_id = entry.get("cell_id")
+            if not isinstance(cell_id, str) or not cell_id:
+                raise FinalAuditError(f"{cache_name} contains an invalid cell ID")
+            if cell_id in result:
+                raise FinalAuditError(f"duplicate cache cell {cell_id!r}")
+            result[cell_id] = entry
+    return result
+
+
+def _catalog_static_na_projection_errors(
+    cells: Sequence[CellSpec],
+    entries: Mapping[str, Mapping[str, object]],
+    *,
+    load_current: Callable[[str], object | None],
+) -> tuple[str, ...]:
+    """Audit the immutable no-measurement contract for static-N/A cells."""
+
+    errors: list[str] = []
+    for cell in cells:
+        entry = entries.get(cell.cell_id)
+        if entry is None:
+            errors.append(f"{cell.cell_id}: cache entry is missing")
+            continue
+        if entry != reset_entry(cell):
+            errors.append(
+                f"{cell.cell_id}: catalog static N/A cache entry differs "
+                "from the canonical reset entry"
+            )
+        if load_current(cell.cell_id) is not None:
+            errors.append(
+                f"{cell.cell_id}: catalog static N/A cell has a published current"
+            )
+    return tuple(errors)
+
+
+def _replayed_agreement_value(
+    edge: AgreementEdge,
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    replayed: Mapping[str, _ReplayObservation],
+    replay_required: bool,
+) -> float:
+    observation = replayed.get(cell.cell_id)
+    if replay_required and observation is None:
+        raise FinalAuditError(
+            f"{cell.cell_id} is missing its required pyAmpliCol replay"
+        )
+    if not replay_required and observation is not None:
+        raise FinalAuditError(
+            f"{cell.cell_id} unexpectedly has replay evidence in a stored-only lane"
+        )
+    if edge.value_kind == "matrix_element":
+        if not replay_required:
+            return _finite_number(
+                measurement.get("matrix_element"),
+                f"{cell.cell_id}.matrix_element",
+            )
+        assert observation is not None
+        return observation.matrix_element
+    if replay_required:
+        assert observation is not None
+        if observation.lc_common_component is None:
+            raise FinalAuditError(f"{cell.cell_id} replay has no LC common component")
+        return observation.lc_common_component
+    return _audit_lc_common_component(
+        cell,
+        measurement,
+        context=f"{cell.cell_id}.authenticated",
+    )
+
+
+def _direct_replay_category(edge: AgreementEdge) -> str:
+    if edge.kind == MADGRAPH_FULL_COLOUR:
+        if (
+            edge.baseline.measurement.execution_mode is not ExecutionMode.MADGRAPH
+            or edge.candidate.measurement.execution_mode
+            in {ExecutionMode.AMPLICOL, ExecutionMode.MADGRAPH}
+        ):
+            raise FinalAuditError(
+                f"{edge.candidate.cell_id}: invalid MadGraph direct-edge endpoints"
+            )
+        return _AUTHENTICATED_STORED_MADGRAPH
+    candidate_is_pyamplicol = edge.candidate.measurement.execution_mode not in {
+        ExecutionMode.AMPLICOL,
+        ExecutionMode.MADGRAPH,
+    }
+    baseline_is_pyamplicol = edge.baseline.measurement.execution_mode not in {
+        ExecutionMode.AMPLICOL,
+        ExecutionMode.MADGRAPH,
+    }
+    if candidate_is_pyamplicol and baseline_is_pyamplicol:
+        return _FULLY_REPLAYED_PYAMPLICOL
+    if (
+        candidate_is_pyamplicol
+        and not baseline_is_pyamplicol
+        and edge.kind == LC_LEGACY_PYAMPLICOL_COMPONENT
+    ):
+        return _REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY
+    if (
+        not candidate_is_pyamplicol
+        and not baseline_is_pyamplicol
+        and edge.kind == LC_CROSS_LAYOUT_COMPONENT
+    ):
+        return _AUTHENTICATED_STORED_LEGACY_LAYOUT
+    raise FinalAuditError(
+        f"{edge.candidate.cell_id}: unexpected direct-edge replay endpoint classes "
+        f"for {edge.kind}"
+    )
+
+
+def _audit_replayed_direct_agreements(
+    edges: Sequence[AgreementEdge],
+    measurements: Mapping[str, Mapping[str, object]],
+    replayed: Mapping[str, _ReplayObservation],
+) -> dict[str, int]:
+    errors: list[str] = []
+    counts: Counter[str] = Counter()
+    for edge in edges:
+        try:
+            category = _direct_replay_category(edge)
+            counts[category] += 1
+            stored_record = _stored_direct_agreement(
+                measurements[edge.candidate.cell_id],
+                edge_kind=edge.kind,
+                baseline_cell_id=edge.baseline.cell_id,
+            )
+            if stored_record is None:
+                raise FinalAuditError(
+                    f"{edge.candidate.cell_id} has no authenticated stored "
+                    f"{edge.kind} agreement"
+                )
+            candidate = _replayed_agreement_value(
+                edge,
+                edge.candidate,
+                measurements[edge.candidate.cell_id],
+                replayed,
+                replay_required=category
+                in {
+                    _FULLY_REPLAYED_PYAMPLICOL,
+                    _REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY,
+                    _AUTHENTICATED_STORED_MADGRAPH,
+                },
+            )
+            if category == _REPLAYED_PYAMPLICOL_AUTHENTICATED_LEGACY:
+                stored_candidate = _finite_number(
+                    stored_record.get("candidate"),
+                    f"{edge.candidate.cell_id}.stored_legacy_candidate",
+                )
+                absolute = abs(candidate - stored_candidate)
+                scale = max(abs(candidate), abs(stored_candidate))
+                if (
+                    absolute > STRICT_ABSOLUTE_TOLERANCE
+                    and absolute > STRICT_RELATIVE_TOLERANCE * scale
+                ):
+                    raise FinalAuditError(
+                        "replayed legacy diagnostic candidate differs from its "
+                        "authenticated stored candidate"
+                    )
+                # AmpliCol is diagnostic-only: a faithfully replayed candidate
+                # remains valid even when the stored legacy comparison failed.
+                continue
+            if category == _AUTHENTICATED_STORED_MADGRAPH:
+                candidate_precision = madgraph_candidate_precision(edge.candidate)
+                stored_authority_candidate = _finite_number(
+                    stored_record.get("candidate"),
+                    f"{edge.candidate.cell_id}.stored_madgraph_"
+                    f"p{candidate_precision}_candidate",
+                )
+                absolute = abs(candidate - stored_authority_candidate)
+                scale = max(abs(candidate), abs(stored_authority_candidate))
+                if stored_record.get("abi") == DIRECT_AGREEMENT_V2_ABI:
+                    scale = max(
+                        scale,
+                        _finite_number(
+                            stored_record.get("candidate_scale"),
+                            f"{edge.candidate.cell_id}.candidate_scale",
+                            nonnegative=True,
+                        ),
+                    )
+                if (
+                    absolute > STRICT_ABSOLUTE_TOLERANCE
+                    and absolute > edge.relative_tolerance * scale
+                ):
+                    raise FinalAuditError(
+                        "replayed p16 candidate differs from its authenticated "
+                        f"stored p{candidate_precision} MadGraph comparison"
+                    )
+                # The MadGraph executable is deliberately not replayed here.
+                # Its binary64 result and candidate comparison were already
+                # authenticated by the structural direct-edge audit.
+                continue
+            if category == _AUTHENTICATED_STORED_LEGACY_LAYOUT:
+                baseline = _replayed_agreement_value(
+                    edge,
+                    edge.baseline,
+                    measurements[edge.baseline.cell_id],
+                    replayed,
+                    replay_required=False,
+                )
+            else:
+                baseline = _replayed_agreement_value(
+                    edge,
+                    edge.baseline,
+                    measurements[edge.baseline.cell_id],
+                    replayed,
+                    replay_required=category == _FULLY_REPLAYED_PYAMPLICOL,
+                )
+            absolute = abs(candidate - baseline)
+            scale = max(abs(candidate), abs(baseline))
+            if (
+                isinstance(stored_record, Mapping)
+                and stored_record.get("abi") == DIRECT_AGREEMENT_V2_ABI
+            ):
+                scale = max(
+                    scale,
+                    _finite_number(
+                        stored_record.get("candidate_scale"),
+                        f"{edge.candidate.cell_id}.candidate_scale",
+                        nonnegative=True,
+                    ),
+                    _finite_number(
+                        stored_record.get("baseline_scale"),
+                        f"{edge.candidate.cell_id}.baseline_scale",
+                        nonnegative=True,
+                    ),
+                )
+            if absolute > edge.relative_tolerance * scale:
+                raise FinalAuditError(
+                    f"replayed {edge.kind} direct edge differs from "
+                    f"{edge.baseline.cell_id}"
+                )
+        except Exception as error:
+            errors.append(f"{edge.candidate.cell_id}: {error}")
+    if errors:
+        rendered = "\n".join(f"- {message}" for message in errors[:50])
+        raise FinalAuditError(
+            f"final report direct-edge replay failed ({len(errors)}):\n{rendered}"
+        )
+    return {category: counts.get(category, 0) for category in _DIRECT_REPLAY_CATEGORIES}
+
+
+def audit_final_report(
+    repo_root: Path,
+    *,
+    expected_source_revision: str,
+    expected_publication_revision: str | None = None,
+    max_n_final: int = _FULL_CATALOG_MAX_N_FINAL,
+    expected_cell_count: int | None = _EXPECTED_FULL_CATALOG_CELL_COUNT,
+    replay: bool = True,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    service: ReportService | None = None,
+    active_runtime: Mapping[str, object] | None = None,
+    artifact_auditor: ArtifactAuditor = audit_artifact,
+    runtime_loader: RuntimeLoader = _default_runtime_loader,
+    source_auditor: SourceAuditor = _require_report_source_checkout,
+    runtime_auditor: RuntimeAuditor = _audit_active_runtime,
+    verify_render: bool = True,
+    verify_pdf: bool = True,
+    pdf_auditor: PdfAuditor = _audit_pdf,
+    campaign_policy: CampaignPolicy | None = None,
+) -> dict[str, object]:
+    """Audit one cooperative report snapshot under the publication lock."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    report = service or ReportService(ReportPaths.from_repo(root), catalog=catalog)
+    with report.store.named_lock("report-writer"):
+        return _audit_final_report_locked(
+            root,
+            expected_source_revision=expected_source_revision,
+            expected_publication_revision=expected_publication_revision,
+            max_n_final=max_n_final,
+            expected_cell_count=expected_cell_count,
+            replay=replay,
+            catalog=catalog,
+            service=report,
+            active_runtime=active_runtime,
+            artifact_auditor=artifact_auditor,
+            runtime_loader=runtime_loader,
+            source_auditor=source_auditor,
+            runtime_auditor=runtime_auditor,
+            verify_render=verify_render,
+            verify_pdf=verify_pdf,
+            pdf_auditor=pdf_auditor,
+            campaign_policy=campaign_policy,
+        )
+
+
+def _audit_final_report_locked(
+    repo_root: Path,
+    *,
+    expected_source_revision: str,
+    expected_publication_revision: str | None = None,
+    max_n_final: int = _FULL_CATALOG_MAX_N_FINAL,
+    expected_cell_count: int | None = _EXPECTED_FULL_CATALOG_CELL_COUNT,
+    replay: bool = True,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    service: ReportService | None = None,
+    active_runtime: Mapping[str, object] | None = None,
+    artifact_auditor: ArtifactAuditor = audit_artifact,
+    runtime_loader: RuntimeLoader = _default_runtime_loader,
+    source_auditor: SourceAuditor = _require_report_source_checkout,
+    runtime_auditor: RuntimeAuditor = _audit_active_runtime,
+    verify_render: bool = True,
+    verify_pdf: bool = True,
+    pdf_auditor: PdfAuditor = _audit_pdf,
+    campaign_policy: CampaignPolicy | None = None,
+) -> dict[str, object]:
+    """Audit every selected record while the report-writer lock is held."""
+
+    if _GIT_SHA_RE.fullmatch(expected_source_revision) is None:
+        raise FinalAuditError("expected source revision must be a full Git SHA")
+    if (
+        expected_publication_revision is not None
+        and _GIT_SHA_RE.fullmatch(expected_publication_revision) is None
+    ):
+        raise FinalAuditError("expected publication revision must be a full Git SHA")
+    if max_n_final < 1:
+        raise FinalAuditError("max_n_final must be positive")
+    root = repo_root.expanduser().resolve(strict=False)
+    report = service or ReportService(ReportPaths.from_repo(root), catalog=catalog)
+    using_production_source_auditor = source_auditor is _require_report_source_checkout
+    if using_production_source_auditor:
+        report_profile = _active_report_profile(root, report)
+        try:
+            active_policy = load_profile_campaign_policy(
+                root,
+                report_profile,
+                expected_source_revision=expected_source_revision,
+            )
+        except Exception as error:
+            raise FinalAuditError(
+                f"cannot authenticate report campaign policy: {error}"
+            ) from error
+        if campaign_policy is not None and campaign_policy is not active_policy:
+            raise FinalAuditError(
+                "caller-supplied campaign policy differs from the measured profile"
+            )
+        raw_publication_lineage = _profile_publication_lineage(
+            root,
+            expected_source_revision,
+            profile=report_profile,
+        )
+        expected_source_tree: str | None = str(
+            raw_publication_lineage["measurement_source_tree"]
+        )
+        try:
+            measurement_lineage = load_and_audit_measurement_lineage(
+                root,
+                report.paths.docs_dir,
+                report.store,
+                expected_active_source_revision=expected_source_revision,
+                catalog=catalog,
+            )
+            report.bind_measurement_lineage(measurement_lineage)
+        except MeasurementLineageError as error:
+            seed = report._original_amplicol_seed()
+            if (
+                seed is None
+                or (report.paths.docs_dir / "measurement_lineage.json").exists()
+            ):
+                raise FinalAuditError(
+                    f"cannot authenticate measurement source bridge: {error}"
+                ) from error
+            measurement_lineage = None
+            report.bind_measurement_lineage(None)
+    else:
+        report_profile = None
+        active_policy = campaign_policy or STRICT_POLICY
+        raw_publication_lineage = source_auditor(
+            root,
+            expected_source_revision,
+        )
+        expected_source_tree = None
+        measurement_lineage = None
+    policy_profile = report_profile or (
+        MACBOOK_M3_PROFILE
+        if active_policy
+        in {
+            MACBOOK_M3_POLICY,
+            MACBOOK_M3_Z_TABLE_F_POLICY,
+        }
+        else (X86_EPYC_PROFILE if active_policy is X86_EPYC_POLICY else "")
+    )
+    publication_lineage = _validated_publication_lineage(
+        raw_publication_lineage,
+        measurement_source_revision=expected_source_revision,
+        expected_publication_revision=expected_publication_revision,
+        expected_profile=report_profile,
+    )
+    render_result = (
+        report.audit()
+        if verify_render
+        else {"cache_render_match": None, "skipped": True}
+    )
+    caches = report.load_caches()
+    entries = _entry_map(caches)
+    declared_cells = tuple(
+        sorted(
+            (
+                cell
+                for cell in catalog.measurement_cells()
+                if cell.n_final <= max_n_final
+            ),
+            key=lambda item: item.cell_id,
+        )
+    )
+    if expected_cell_count is not None and len(declared_cells) != expected_cell_count:
+        raise FinalAuditError(
+            "catalog selected "
+            f"{len(declared_cells)} declared cells, expected "
+            f"{expected_cell_count}"
+        )
+    static_na_cells = tuple(
+        cell for cell in declared_cells if catalog.static_na_reason(cell) is not None
+    )
+    if catalog is REPORT_CATALOG and max_n_final == _FULL_CATALOG_MAX_N_FINAL:
+        observed_static_na_ids = {cell.cell_id for cell in static_na_cells}
+        if observed_static_na_ids != _EXPECTED_FULL_STATIC_NA_CELL_IDS:
+            missing_static_na_ids = sorted(
+                _EXPECTED_FULL_STATIC_NA_CELL_IDS - observed_static_na_ids
+            )
+            extra_static_na_ids = sorted(
+                observed_static_na_ids - _EXPECTED_FULL_STATIC_NA_CELL_IDS
+            )
+            raise FinalAuditError(
+                "canonical catalog static-N/A census differs: "
+                f"missing={missing_static_na_ids}, "
+                f"extra={extra_static_na_ids}"
+            )
+        observed_static_na_reasons = {
+            cell.cell_id: catalog.static_na_reason(cell) for cell in static_na_cells
+        }
+        if observed_static_na_reasons != _EXPECTED_FULL_STATIC_NA_REASONS:
+            raise FinalAuditError(
+                "canonical catalog static-N/A reasons differ: "
+                f"{dict(sorted(observed_static_na_reasons.items()))}"
+            )
+    cells = tuple(
+        cell for cell in declared_cells if catalog.static_na_reason(cell) is None
+    )
+    published_measurements: dict[str, Mapping[str, object]] = {}
+    measurements: dict[str, Mapping[str, object]] = {}
+    measurement_sources: dict[str, tuple[str, str | None]] = {}
+    measurement_states: dict[str, PolicyMeasurementState] = {}
+    errors = list(
+        _catalog_static_na_projection_errors(
+            static_na_cells,
+            entries,
+            load_current=lambda cell_id: report.store.load_current(
+                cell_id,
+                missing_ok=True,
+            ),
+        )
+    )
+    for cell in cells:
+        entry = entries.get(cell.cell_id)
+        if entry is None:
+            errors.append(f"{cell.cell_id}: cache entry is missing")
+            continue
+        expected_entry = reset_entry(cell)
+        descriptor_mismatches = [
+            field
+            for field, value in expected_entry.items()
+            if field != "measurement" and entry.get(field) != value
+        ]
+        if descriptor_mismatches:
+            errors.append(
+                f"{cell.cell_id}: cache descriptor differs: "
+                + ", ".join(descriptor_mismatches)
+            )
+            continue
+        published = _mapping(
+            entry.get("measurement"),
+            f"{cell.cell_id}.published_measurement",
+        )
+        current = report.store.load_current(
+            cell.cell_id,
+            missing_ok=True,
+        )
+        if current is None:
+            errors.append(f"{cell.cell_id}: authenticated current result is missing")
+            continue
+        current_measurement = _mapping(
+            current.result,
+            f"{cell.cell_id}.current.result",
+        )
+        if measurement_lineage is None:
+            seed = report._original_amplicol_seed()
+            authorized_seed = (
+                None
+                if seed is None
+                else seed.source_for_current(
+                    current,
+                    active_revision=expected_source_revision,
+                    active_tree=expected_source_tree or "",
+                )
+            )
+            cell_source = (
+                authorized_seed
+                if authorized_seed is not None
+                else (expected_source_revision, expected_source_tree)
+            )
+        else:
+            authorized = measurement_lineage.source_for_current(
+                current,
+                active_revision=expected_source_revision,
+                active_tree=expected_source_tree or "",
+            )
+            if authorized is None:
+                errors.append(
+                    f"{cell.cell_id}: current is not authorized by the "
+                    "measurement source bridge"
+                )
+                continue
+            cell_source = authorized
+            if (
+                cell.cell_id in measurement_lineage.required_descendant_cell_ids
+                and cell_source[0] != expected_source_revision
+            ):
+                errors.append(
+                    f"{cell.cell_id}: Class-C impact/agreement target has not "
+                    "been remeasured at the descendant source"
+                )
+                continue
+        policy_errors = (
+            *_publication_policy_errors(
+                f"{cell.cell_id}.published_measurement",
+                published,
+                expected_source_revision=cell_source[0],
+                expected_source_tree=cell_source[1],
+            ),
+            *_publication_policy_errors(
+                f"{cell.cell_id}.current.result",
+                current_measurement,
+                expected_source_revision=cell_source[0],
+                expected_source_tree=cell_source[1],
+            ),
+        )
+        if policy_errors:
+            errors.extend(policy_errors)
+            continue
+        try:
+            published_state = validate_policy_measurement(
+                active_policy,
+                policy_profile,
+                cell,
+                published,
+                expected_source_revision=cell_source[0],
+                expected_source_tree=cell_source[1],
+            )
+            current_state = validate_policy_measurement(
+                active_policy,
+                policy_profile,
+                cell,
+                current_measurement,
+                expected_source_revision=cell_source[0],
+                expected_source_tree=cell_source[1],
+            )
+            if published_state is not current_state:
+                raise FinalAuditError("published and current policy states differ")
+        except (CampaignPolicyError, FinalAuditError) as error:
+            errors.append(f"{cell.cell_id}: {error}")
+            continue
+        if not publication_measurement_matches_current(
+            published,
+            current_measurement,
+            report.paths,
+        ):
+            errors.append(
+                f"{cell.cell_id}: checked-in cache is not the exact portable "
+                "projection of authenticated current.result"
+            )
+            continue
+        published_measurements[cell.cell_id] = published
+        measurements[cell.cell_id] = current_measurement
+        measurement_sources[cell.cell_id] = cell_source
+        measurement_states[cell.cell_id] = current_state
+    if errors:
+        rendered = "\n".join(f"- {message}" for message in errors[:50])
+        suffix = (
+            ""
+            if len(errors) <= 50
+            else f"\n- ... and {len(errors) - 50} additional failures"
+        )
+        raise FinalAuditError(
+            "final report publication projection audit failed "
+            f"({len(errors)}):\n{rendered}{suffix}"
+        )
+
+    def resource_lane(cell: CellSpec) -> tuple[object, ...]:
+        return tuple(resource_lane_identity(cell).items())
+
+    resource_sources: dict[tuple[object, ...], list[CellSpec]] = defaultdict(list)
+    for source_cell in cells:
+        if measurement_states[source_cell.cell_id] in {
+            PolicyMeasurementState.GENERATION_LIMIT,
+            PolicyMeasurementState.MEMORY_LIMIT,
+        }:
+            resource_sources[resource_lane(source_cell)].append(source_cell)
+    for lane_sources in resource_sources.values():
+        lane_sources.sort(key=lambda item: item.n_final)
+
+    dependency_errors: list[str] = []
+    for cell in cells:
+        lower_resource_sources = tuple(
+            source
+            for source in resource_sources.get(resource_lane(cell), ())
+            if source.n_final < cell.n_final
+        )
+        frontier_source = lower_resource_sources[0] if lower_resource_sources else None
+        state = measurement_states[cell.cell_id]
+        if frontier_source is not None:
+            expected_frontier = resource_frontier_reference(
+                cell,
+                frontier_source,
+                measurements[frontier_source.cell_id],
+            )
+            if state is not PolicyMeasurementState.RESOURCE_FRONTIER:
+                dependency_errors.append(
+                    f"{cell.cell_id}: higher multiplicity is not bound to "
+                    f"resource frontier {frontier_source.cell_id}"
+                )
+                continue
+            provenance = _mapping(
+                measurements[cell.cell_id].get("provenance"),
+                f"{cell.cell_id}.provenance",
+            )
+            censor = _mapping(
+                provenance.get("policy_censor"),
+                f"{cell.cell_id}.policy_censor",
+            )
+            if censor.get("frontier") != expected_frontier:
+                dependency_errors.append(
+                    f"{cell.cell_id}: resource frontier does not exactly bind "
+                    f"the first lower hard censor {frontier_source.cell_id}"
+                )
+            continue
+        if state is PolicyMeasurementState.RESOURCE_FRONTIER:
+            dependency_errors.append(
+                f"{cell.cell_id}: resource frontier has no current lower hard "
+                "resource censor in the same lane"
+            )
+            continue
+        candidate_baseline_cell = catalog.validation_baseline_cell(cell)
+        baseline_cell = (
+            candidate_baseline_cell
+            if validation_baseline_is_required(cell, candidate_baseline_cell)
+            else None
+        )
+        dependency_cells = {
+            dependency.cell_id: dependency
+            for dependency in (
+                *((baseline_cell,) if baseline_cell is not None else ()),
+                *(
+                    edge.baseline
+                    for edge in incoming_agreement_edges(cell, catalog=catalog)
+                    if edge.required
+                ),
+            )
+            if dependency.cell_id in measurements
+        }
+        terminal_dependencies = tuple(
+            sorted(
+                (
+                    dependency_reference(
+                        dependency.cell_id,
+                        measurements[dependency.cell_id],
+                    )
+                    for dependency in dependency_cells.values()
+                    if measurement_states[dependency.cell_id]
+                    is not PolicyMeasurementState.SUCCESS
+                ),
+                key=lambda item: str(item["cell_id"]),
+            )
+        )
+        if state is PolicyMeasurementState.SUCCESS and terminal_dependencies:
+            dependency_errors.append(
+                f"{cell.cell_id}: successful measurement depends on a "
+                "policy-censored comparison endpoint"
+            )
+            continue
+        if state is not PolicyMeasurementState.DEPENDENCY:
+            continue
+        provenance = _mapping(
+            measurements[cell.cell_id].get("provenance"),
+            f"{cell.cell_id}.provenance",
+        )
+        censor = _mapping(
+            provenance.get("policy_censor"),
+            f"{cell.cell_id}.policy_censor",
+        )
+        observed = censor.get("dependencies")
+        if observed != list(terminal_dependencies):
+            dependency_errors.append(
+                f"{cell.cell_id}: dependency censor does not exactly bind its "
+                "current required terminal dependencies"
+            )
+    if dependency_errors:
+        rendered = "\n".join(f"- {message}" for message in dependency_errors[:50])
+        raise FinalAuditError(
+            "final report policy-dependency audit failed "
+            f"({len(dependency_errors)}):\n{rendered}"
+        )
+
+    visible_completeness = summarize_visible_completeness(
+        caches,
+        catalog=catalog,
+        max_n_final=max_n_final,
+        policy=active_policy,
+    )
+    if (
+        visible_completeness.declared_measurement_cell_count != len(declared_cells)
+        or visible_completeness.required_measurement_count != len(cells)
+        or visible_completeness.rendered_required_measurement_count != len(cells)
+        or visible_completeness.catalog_static_na_cell_count != len(static_na_cells)
+        or visible_completeness.rendered_catalog_static_na_cell_count
+        != len(static_na_cells)
+        or not visible_completeness.complete
+    ):
+        evidence = visible_completeness.as_dict()
+        raise FinalAuditError(
+            "final report visible-completeness audit failed: "
+            f"declared={evidence['declared_measurement_cell_count']}, "
+            f"required={evidence['required_measurement_count']}, "
+            f"rendered={evidence['rendered_required_measurement_count']}, "
+            f"static={evidence['catalog_static_na_cell_count']}, "
+            "rendered_static="
+            f"{evidence['rendered_catalog_static_na_cell_count']}, "
+            f"applicable_NA={evidence['applicable_na_display_slot_count']}, "
+            f"missing={evidence['missing_rendered_cell_count']}, "
+            f"errors={evidence['contract_errors']}, "
+            f"slots={evidence['applicable_na_display_slots']}"
+        )
+
+    successful_cells = tuple(
+        cell
+        for cell in cells
+        if measurement_states[cell.cell_id] is PolicyMeasurementState.SUCCESS
+    )
+    pyamplicol_cells = tuple(
+        cell
+        for cell in successful_cells
+        if cell.measurement.execution_mode
+        not in {ExecutionMode.AMPLICOL, ExecutionMode.MADGRAPH}
+    )
+    madgraph_cells = tuple(
+        cell
+        for cell in successful_cells
+        if cell.measurement.execution_mode is ExecutionMode.MADGRAPH
+    )
+    successful_legacy_cells = tuple(
+        cell
+        for cell in successful_cells
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+    )
+    expected_legacy_revision = (
+        _expected_legacy_revision(root) if successful_legacy_cells else ""
+    )
+    if pyamplicol_cells and active_runtime is None:
+        active_runtime = runtime_auditor(
+            expected_source_revision,
+            root,
+        )
+
+    references: list[_ArtifactReference] = []
+    errors = []
+    for cell in successful_cells:
+        measurement = measurements[cell.cell_id]
+        try:
+            baseline_endpoint = _validation_baseline_endpoint_for_audit(
+                cell,
+                measurements,
+                measurement_states,
+                catalog=catalog,
+            )
+            baseline_cell = None if baseline_endpoint is None else baseline_endpoint[0]
+            baseline = None if baseline_endpoint is None else baseline_endpoint[1]
+            reference = _audit_measurement(
+                cell,
+                measurement,
+                baseline=baseline,
+                baseline_cell=baseline_cell,
+                expected_source_revision=measurement_sources[cell.cell_id][0],
+                expected_source_tree=measurement_sources[cell.cell_id][1],
+                expected_legacy_revision=expected_legacy_revision,
+                active_runtime=active_runtime,
+                report_paths=report.paths,
+            )
+            if reference is not None:
+                published_reference = _artifact_reference(
+                    cell,
+                    published_measurements[cell.cell_id],
+                    report_paths=report.paths,
+                )
+                if (
+                    published_reference.path != reference.path
+                    or published_reference.process_id != reference.process_id
+                ):
+                    raise FinalAuditError(
+                        "portable artifact locator differs from raw current.result"
+                    )
+                references.append(reference)
+        except Exception as error:  # collect every independently actionable cell
+            errors.append(f"{cell.cell_id}: {error}")
+    if errors:
+        rendered = "\n".join(f"- {message}" for message in errors[:50])
+        suffix = (
+            ""
+            if len(errors) <= 50
+            else f"\n- ... and {len(errors) - 50} additional failures"
+        )
+        raise FinalAuditError(
+            f"final report structural measurement audit failed ({len(errors)}):\n"
+            f"{rendered}{suffix}"
+        )
+
+    direct_edges, direct_agreement_counts = _audit_direct_agreements(
+        successful_cells,
+        measurements,
+        catalog=catalog,
+    )
+    if (
+        catalog is REPORT_CATALOG
+        and max_n_final == 4
+        and len(declared_cells) == _EXPECTED_N4_CELL_COUNT
+        and active_policy is STRICT_POLICY
+        and not _count_contract_matches_with_optional_categories(
+            direct_agreement_counts,
+            _EXPECTED_N4_DIRECT_AGREEMENT_COUNTS,
+            optional_categories={
+                Z_RECURRENCE_CROSS_MODE,
+                LC_LEGACY_PYAMPLICOL_COMPONENT,
+            },
+        )
+    ):
+        raise FinalAuditError(
+            "canonical n<=4 direct-agreement edge counts differ: "
+            f"expected={_EXPECTED_N4_DIRECT_AGREEMENT_COUNTS}, "
+            f"observed={direct_agreement_counts}"
+        )
+    if (
+        catalog is REPORT_CATALOG
+        and max_n_final == _FULL_CATALOG_MAX_N_FINAL
+        and len(declared_cells) == _EXPECTED_FULL_CATALOG_CELL_COUNT
+        and active_policy is STRICT_POLICY
+        and not _count_contract_matches_with_optional_categories(
+            direct_agreement_counts,
+            _EXPECTED_FULL_DIRECT_AGREEMENT_COUNTS,
+            optional_categories={
+                Z_RECURRENCE_CROSS_MODE,
+                LC_LEGACY_PYAMPLICOL_COMPONENT,
+            },
+        )
+    ):
+        raise FinalAuditError(
+            "canonical full-catalog direct-agreement edge counts differ: "
+            f"expected={_EXPECTED_FULL_DIRECT_AGREEMENT_COUNTS}, "
+            f"observed={direct_agreement_counts}"
+        )
+
+    legacy_cells = successful_legacy_cells
+    legacy_agreement_edges = _legacy_consumer_coverage(
+        successful_cells,
+        measurements,
+        measurement_states,
+        catalog=catalog,
+    )
+    covered_legacy_ids = {baseline for baseline, _candidate in legacy_agreement_edges}
+
+    grouped: dict[tuple[Path, str], list[_ArtifactReference]] = defaultdict(list)
+    for reference in references:
+        grouped[(reference.path, reference.process_id)].append(reference)
+    evidence_by_key: dict[tuple[Path, str], ArtifactEvidence] = {}
+    errors = []
+    for key, group in grouped.items():
+        representative = group[0]
+        try:
+            evidence = artifact_auditor(
+                representative.cell, representative.path, representative.process_id
+            )
+            evidence_by_key[key] = evidence
+            for reference in group:
+                if _shared_artifact_contract(
+                    reference.cell
+                ) != _shared_artifact_contract(representative.cell):
+                    raise FinalAuditError(
+                        "one artifact path is shared by incompatible report cells"
+                    )
+                provenance = _mapping(
+                    reference.measurement.get("provenance"),
+                    f"{reference.cell.cell_id}.provenance",
+                )
+                assert active_runtime is not None
+                source_revision = measurement_sources[reference.cell.cell_id][0]
+                _audit_runtime_identity(
+                    reference.cell,
+                    provenance,
+                    expected_source_revision=source_revision,
+                    active_runtime=_runtime_for_measurement_source(
+                        active_runtime,
+                        provenance,
+                        source_revision=source_revision,
+                        measurement_lineage=measurement_lineage,
+                    ),
+                    artifact=evidence,
+                )
+        except Exception as error:
+            errors.append(f"{representative.path}: {error}")
+    if errors:
+        rendered = "\n".join(f"- {message}" for message in errors[:50])
+        raise FinalAuditError(
+            f"final report artifact/Arena audit failed ({len(errors)}):\n{rendered}"
+        )
+
+    replayed: dict[str, _ReplayObservation] = {}
+    replayed_direct_agreement_counts = {
+        category: 0 for category in _DIRECT_REPLAY_CATEGORIES
+    }
+    if replay:
+        errors = []
+        for key, group in grouped.items():
+            path, process_id = key
+            try:
+                runtime = runtime_loader(path, process_id)
+                evidence = evidence_by_key[key]
+                for reference in group:
+                    replayed[reference.cell.cell_id] = _replay_cell(
+                        runtime, reference, evidence
+                    )
+            except Exception as error:
+                errors.append(f"{path} ({process_id}): {error}")
+            finally:
+                if "runtime" in locals():
+                    del runtime
+                gc.collect()
+        for cell in pyamplicol_cells:
+            observation = replayed.get(cell.cell_id)
+            if observation is None:
+                continue
+            try:
+                baseline_endpoint = _validation_baseline_endpoint_for_audit(
+                    cell,
+                    measurements,
+                    measurement_states,
+                    catalog=catalog,
+                )
+            except FinalAuditError as error:
+                errors.append(f"{cell.cell_id}: {error}")
+                continue
+            if baseline_endpoint is None:
+                continue
+            baseline_cell, baseline_measurement = baseline_endpoint
+            baseline_observation = replayed.get(baseline_cell.cell_id)
+            baseline_value = (
+                baseline_observation.matrix_element
+                if baseline_observation is not None
+                else _finite_number(
+                    baseline_measurement.get("matrix_element"),
+                    f"{baseline_cell.cell_id}.matrix_element",
+                )
+            )
+            absolute = abs(observation.matrix_element - baseline_value)
+            relative = absolute / max(abs(baseline_value), 1.0e-300)
+            if (
+                absolute > ABSOLUTE_TOLERANCE
+                and relative > _expected_pointwise_tolerance(cell)
+            ):
+                errors.append(f"{cell.cell_id}: replay differs from canonical baseline")
+        if errors:
+            rendered = "\n".join(f"- {message}" for message in errors[:50])
+            raise FinalAuditError(
+                f"final report numerical replay failed ({len(errors)}):\n{rendered}"
+            )
+        replayed_direct_agreement_counts = _audit_replayed_direct_agreements(
+            direct_edges,
+            measurements,
+            replayed,
+        )
+        if (
+            catalog is REPORT_CATALOG
+            and max_n_final == 4
+            and len(declared_cells) == _EXPECTED_N4_CELL_COUNT
+            and active_policy is STRICT_POLICY
+            and not _replay_count_contract_matches_direct_edges(
+                replayed_direct_agreement_counts,
+                direct_agreement_counts,
+                _EXPECTED_N4_DIRECT_REPLAY_COUNTS,
+            )
+        ):
+            raise FinalAuditError(
+                "canonical n<=4 direct-agreement replay categories differ: "
+                f"expected={_EXPECTED_N4_DIRECT_REPLAY_COUNTS}, "
+                f"observed={replayed_direct_agreement_counts}"
+            )
+        if (
+            catalog is REPORT_CATALOG
+            and max_n_final == _FULL_CATALOG_MAX_N_FINAL
+            and len(declared_cells) == _EXPECTED_FULL_CATALOG_CELL_COUNT
+            and active_policy is STRICT_POLICY
+            and not _replay_count_contract_matches_direct_edges(
+                replayed_direct_agreement_counts,
+                direct_agreement_counts,
+                _EXPECTED_FULL_DIRECT_REPLAY_COUNTS,
+            )
+        ):
+            raise FinalAuditError(
+                "canonical full-catalog direct-agreement replay categories "
+                f"differ: expected={_EXPECTED_FULL_DIRECT_REPLAY_COUNTS}, "
+                f"observed={replayed_direct_agreement_counts}"
+            )
+        if len(replayed) != len(pyamplicol_cells):
+            raise FinalAuditError(
+                "final report replay did not cover every pyAmpliCol measurement: "
+                f"{len(replayed)}/{len(pyamplicol_cells)}"
+            )
+
+    pdf_result: Mapping[str, object]
+    if verify_pdf:
+        pdf_result = pdf_auditor(report)
+        if pdf_result.get("status") != ResultStatus.OK.value:
+            raise FinalAuditError("final PDF auditor did not return status='ok'")
+    else:
+        pdf_result = {"status": "incomplete", "skipped": True}
+
+    raw_publication_postflight = (
+        _profile_publication_lineage(
+            root,
+            expected_source_revision,
+            profile=report_profile,
+        )
+        if using_production_source_auditor and report_profile is not None
+        else source_auditor(root, expected_source_revision)
+    )
+    publication_postflight = _validated_publication_lineage(
+        raw_publication_postflight,
+        measurement_source_revision=expected_source_revision,
+        expected_publication_revision=expected_publication_revision,
+        expected_profile=report_profile,
+    )
+    if publication_postflight != publication_lineage:
+        raise FinalAuditError(
+            "report publication lineage changed during final report audit"
+        )
+    if pyamplicol_cells:
+        runtime_postflight = runtime_auditor(expected_source_revision, root)
+        _validate_loaded_origin_policy(
+            runtime_postflight.get("loaded_module_origin_policy"),
+            context="postflight_runtime.loaded_module_origin_policy",
+        )
+        stable_postflight = dict(runtime_postflight)
+        stable_initial = dict(active_runtime or {})
+        stable_postflight.pop("loaded_module_origin_policy", None)
+        stable_initial.pop("loaded_module_origin_policy", None)
+        if stable_postflight != stable_initial:
+            raise FinalAuditError(
+                "active candidate runtime identity changed during final report audit"
+            )
+    else:
+        runtime_postflight = None
+
+    canonical_publication_scope = (
+        catalog is REPORT_CATALOG
+        and max_n_final == _FULL_CATALOG_MAX_N_FINAL
+        and expected_cell_count == _EXPECTED_FULL_CATALOG_CELL_COUNT
+        and len(declared_cells) == _EXPECTED_FULL_CATALOG_CELL_COUNT
+    )
+    final_gate_complete = (
+        replay and verify_render and verify_pdf and canonical_publication_scope
+    )
+    state_counts = Counter(state.value for state in measurement_states.values())
+    selected_ids = {cell.cell_id for cell in declared_cells}
+    catalog_direct_edges = tuple(
+        edge
+        for edge in agreement_edges(catalog=catalog)
+        if edge.candidate.cell_id in selected_ids
+        and edge.baseline.cell_id in selected_ids
+    )
+    if (
+        canonical_publication_scope
+        and len(catalog_direct_edges) != _EXPECTED_FULL_DIRECT_AGREEMENT_COUNT
+    ):
+        raise FinalAuditError(
+            "canonical publication direct-agreement catalog count differs: "
+            f"expected={_EXPECTED_FULL_DIRECT_AGREEMENT_COUNT}, "
+            f"observed={len(catalog_direct_edges)}"
+        )
+    declared_modes: dict[str, int] = defaultdict(int)
+    measurable_modes: dict[str, int] = defaultdict(int)
+    static_na_modes: dict[str, int] = defaultdict(int)
+    static_na_reasons: Counter[str] = Counter()
+    for cell in declared_cells:
+        mode = cell.measurement.execution_mode.value
+        declared_modes[mode] += 1
+        reason = catalog.static_na_reason(cell)
+        if reason is None:
+            measurable_modes[mode] += 1
+        else:
+            static_na_modes[mode] += 1
+            static_na_reasons[reason] += 1
+    return {
+        "kind": "pyamplicol-final-report-audit",
+        "schema_version": 5,
+        "status": (ResultStatus.OK.value if final_gate_complete else "incomplete"),
+        "expected_source_revision": expected_source_revision,
+        "measurement_source_revision": expected_source_revision,
+        "measurement_source_lineage": (
+            None
+            if measurement_lineage is None
+            else {
+                "schema": measurement_lineage.payload["schema"],
+                "impact": measurement_lineage.payload["impact"],
+                "ancestor_revision": measurement_lineage.ancestor_revision,
+                "ancestor_tree": measurement_lineage.ancestor_tree,
+                "descendant_revision": measurement_lineage.descendant_revision,
+                "descendant_tree": measurement_lineage.descendant_tree,
+                "retained_ancestor_current_count": sum(
+                    source[0] == measurement_lineage.ancestor_revision
+                    for source in measurement_sources.values()
+                ),
+                "descendant_current_count": sum(
+                    source[0] == measurement_lineage.descendant_revision
+                    for source in measurement_sources.values()
+                ),
+                "invalidated_cell_count": len(measurement_lineage.invalidated_cell_ids),
+                "recompare_cell_count": len(measurement_lineage.recompare_cell_ids),
+            }
+        ),
+        "publication_revision": publication_lineage["publication_revision"],
+        "publication_lineage": publication_lineage,
+        "report_profile": report_profile,
+        "campaign_policy": active_policy.as_manifest(),
+        "maximum_n_final": max_n_final,
+        "selected_cell_count": len(declared_cells),
+        "declared_cell_count": len(declared_cells),
+        "measurable_cell_count": len(cells),
+        "catalog_static_na_cell_count": len(static_na_cells),
+        "catalog_static_na_reason_counts": dict(sorted(static_na_reasons.items())),
+        "mode_counts": dict(sorted(declared_modes.items())),
+        "declared_mode_counts": dict(sorted(declared_modes.items())),
+        "measurable_mode_counts": dict(sorted(measurable_modes.items())),
+        "catalog_static_na_mode_counts": dict(sorted(static_na_modes.items())),
+        "authenticated_current_count": len(cells),
+        "portable_publication_projection_count": len(published_measurements),
+        "publication_cache_role": "portable-projection-of-current-result",
+        "cryptographic_audit_source": "immutable-current-result",
+        "policy_state_counts": dict(sorted(state_counts.items())),
+        "policy_complete_cell_count": len(measurement_states),
+        "hard_resource_censor_count": (
+            state_counts[PolicyMeasurementState.GENERATION_LIMIT.value]
+            + state_counts[PolicyMeasurementState.MEMORY_LIMIT.value]
+        ),
+        "resource_frontier_cell_count": state_counts[
+            PolicyMeasurementState.RESOURCE_FRONTIER.value
+        ],
+        "numerically_evidenced_cell_count": len(successful_cells),
+        "pyamplicol_measurement_count": len(pyamplicol_cells),
+        "madgraph_reference_measurement_count": len(madgraph_cells),
+        "legacy_fresh_oracle_count": len(legacy_cells),
+        "legacy_oracles_with_inbound_agreement": len(covered_legacy_ids),
+        "legacy_pointwise_agreement_edge_count": len(legacy_agreement_edges),
+        "direct_agreement_edge_count": len(direct_edges),
+        "direct_agreement_catalog_edge_count": len(catalog_direct_edges),
+        "direct_agreement_policy_unavailable_edge_count": (
+            len(catalog_direct_edges) - len(direct_edges)
+        ),
+        "direct_agreement_edge_counts": direct_agreement_counts,
+        "replayed_direct_agreement_edge_count": (
+            sum(replayed_direct_agreement_counts.values()) if replay else 0
+        ),
+        "direct_agreement_replay_category_counts": (
+            replayed_direct_agreement_counts
+            if replay
+            else {category: 0 for category in _DIRECT_REPLAY_CATEGORIES}
+        ),
+        "unique_artifact_count": len(grouped),
+        "arena_record_count": sum(
+            evidence.arena_record_count for evidence in evidence_by_key.values()
+        ),
+        "replay_enabled": replay,
+        "canonical_publication_scope": canonical_publication_scope,
+        "final_gate_complete": final_gate_complete,
+        "audit_scope": (
+            "final-numerical-pdf-gate"
+            if final_gate_complete
+            else "diagnostic-incomplete"
+        ),
+        "pyamplicol_replay_count": len(replayed),
+        "replayed_measurement_count": len(replayed),
+        "visible_completeness": visible_completeness.as_dict(),
+        "render_audit": render_result,
+        "pdf_audit": dict(pdf_result),
+        "report_snapshot_lock": "report-writer",
+        "source_identity_postflight_match": True,
+        "runtime_identity_postflight_match": (
+            True if runtime_postflight is not None else None
+        ),
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Audit every record in the complete declared report range at one "
+            "exact measured source/runtime SHA and an optional report-only "
+            "publication descendant. Numerical replay is mandatory by default."
+        )
+    )
+    parser.add_argument("--repo-root", type=Path, default=Path.cwd())
+    parser.add_argument(
+        "--report-profile",
+        type=validate_profile_name,
+        required=True,
+    )
+    parser.add_argument("--expected-source-revision", required=True)
+    parser.add_argument(
+        "--publication-revision",
+        help="require the clean publication checkout to equal this full Git SHA",
+    )
+    parser.add_argument(
+        "--max-n-final",
+        type=int,
+        default=_FULL_CATALOG_MAX_N_FINAL,
+    )
+    parser.add_argument(
+        "--expected-cell-count",
+        type=int,
+        default=_EXPECTED_FULL_CATALOG_CELL_COUNT,
+    )
+    replay = parser.add_mutually_exclusive_group()
+    replay.add_argument(
+        "--replay",
+        dest="replay",
+        action="store_true",
+        default=True,
+        help=(
+            "load every unique artifact and recompute matrix elements, resolved "
+            "totals, selectors, and precision-32 comparisons (default)"
+        ),
+    )
+    replay.add_argument(
+        "--structural-only",
+        dest="replay",
+        action="store_false",
+        help="authenticate records and artifacts without numerical replay",
+    )
+    return parser
+
+
+def _ensure_exact_cli_python(
+    repo_root: Path,
+    argv: Sequence[str],
+) -> None:
+    """Fail closed if this already-imported module was not isolated."""
+
+    del repo_root, argv
+    try:
+        source_only_bytecode_policy()
+    except RuntimeEvidenceError as error:
+        raise FinalAuditError(
+            "direct tools.performance_report.final_audit was imported before "
+            "source-only Python isolation; invoke "
+            "'python src/pyamplicol/_profiling_campaign/result_tables.py "
+            "final-audit ...' or start "
+            "the module under an already isolated -I -S -B bootstrap"
+        ) from error
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    raw_arguments = tuple(sys.argv[1:] if argv is None else argv)
+    arguments = _parser().parse_args(raw_arguments)
+    try:
+        _ensure_exact_cli_python(arguments.repo_root, raw_arguments)
+        if arguments.report_profile is None:
+            raise FinalAuditError("final-audit requires --report-profile")
+        service = ReportService(
+            ReportPaths.from_repo(
+                arguments.repo_root,
+                profile=arguments.report_profile,
+            )
+        )
+        result = audit_final_report(
+            arguments.repo_root,
+            expected_source_revision=arguments.expected_source_revision,
+            expected_publication_revision=arguments.publication_revision,
+            max_n_final=arguments.max_n_final,
+            expected_cell_count=arguments.expected_cell_count,
+            replay=arguments.replay,
+            service=service,
+        )
+    except Exception as error:
+        print(f"final report audit failed: {error}", file=sys.stderr)
+        return 1
+    print(json.dumps(result, allow_nan=False, sort_keys=True))
+    return 0 if result["final_gate_complete"] is True else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/performance_report/legacy.py b/pyamplicol/tools/performance_report/legacy.py
new file mode 100644
index 0000000000..c3dfa71964
--- /dev/null
+++ b/pyamplicol/tools/performance_report/legacy.py
@@ -0,0 +1,2737 @@
+# SPDX-License-Identifier: 0BSD
+"""Independent original-AmpliCol adapter for performance-report cells.
+
+This module deliberately depends on the maintained developer oracle rather
+than the historical report driver.  It owns only campaign orchestration:
+process-row selection, the three legacy measurement paths, bounded adaptive
+sampling, compact result shaping, and provenance capture.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import platform
+import re
+import shutil
+import statistics
+import subprocess
+import sys
+import tempfile
+import time
+from collections.abc import Mapping, Sequence
+from contextlib import contextmanager, nullcontext
+from dataclasses import asdict, dataclass, is_dataclass
+from pathlib import Path
+from typing import Any, Protocol
+
+from .agreements import (
+    DIRECT_AGREEMENT_FIELD,
+    LC_COMMON_COMPONENT_FIELD,
+    legacy_lc_common_component,
+    validate_lc_common_component,
+)
+from .cache import empty_measurement
+from .catalog import REPORT_CATALOG
+from .models import (
+    LEGACY_AMPLICOL_MAX_OPEN_QUARK_LINES,
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    ResultStatus,
+    Workload,
+)
+from .phase_state import WorkerPhaseReporter
+from .runner import (
+    ABSOLUTE_TOLERANCE,
+    DEFAULT_TARGET_RUNTIME_SECONDS,
+    RELATIVE_TOLERANCE,
+    ProfilingTimeLimitError,
+    SelectorContract,
+    point_digest,
+    pointwise_validation,
+)
+from .selector_policy import (
+    fixed_selector_helicity,
+    selector_color_flow_id,
+    selector_helicity_id,
+)
+
+DEFAULT_WARMUP_POINTS = 100
+DEFAULT_MIN_POINTS = 100
+DEFAULT_MAX_POINTS = 10_000_000
+DEFAULT_MIN_PROFILE_CHUNKS = 5
+DEFAULT_MAX_PROFILE_CHUNKS = 512
+MAX_OPEN_QUARK_LINES = LEGACY_AMPLICOL_MAX_OPEN_QUARK_LINES
+LEGACY_IMODE2_DIAGNOSTIC_FIELD = "legacy_imode2_diagnostic"
+LEGACY_IMODE2_DIAGNOSTIC_ABI = "pyamplicol-report-legacy-imode2-diagnostic-v1"
+LEGACY_NUMERICAL_AUTHORITY_FIELD = "legacy_numerical_authority"
+LEGACY_NUMERICAL_AUTHORITY_ABI = "pyamplicol-report-legacy-numerical-authority-v1"
+LEGACY_IMODE2_DIAGNOSTIC_MAX_COLOR_ORDERS = 5_000
+_ORIGINAL_AMPLICOL_BUILD_ENVIRONMENT = {"PDF_BACKEND": "internal"}
+_LIBRARY_COLOR_VALUE_RE = re.compile(
+    r"^AMPICOL_COLOR_PROBE_VALUE\s+(\S+)\s+(\d+)\s+(\d+)\s+"
+    r"([+\-0-9.EeDd]+)$",
+    re.MULTILINE,
+)
+_LIBRARY_COLOR_COMPONENTS_RE = re.compile(
+    r"^AMPICOL_COLOR_PROBE_COMPONENTS\s+"
+    r"([+\-0-9.EeDd]+)\s+([+\-0-9.EeDd]+)\s+([+\-0-9.EeDd]+)$",
+    re.MULTILINE,
+)
+
+
+class LegacyAdapterError(RuntimeError):
+    """The original-AmpliCol measurement contract could not be satisfied."""
+
+
+@dataclass(frozen=True, slots=True)
+class LegacySettings:
+    target_runtime_seconds: float = DEFAULT_TARGET_RUNTIME_SECONDS
+    warmup_points: int = DEFAULT_WARMUP_POINTS
+    minimum_points: int = DEFAULT_MIN_POINTS
+    maximum_points: int = DEFAULT_MAX_POINTS
+    minimum_profile_chunks: int = DEFAULT_MIN_PROFILE_CHUNKS
+    maximum_profile_chunks: int = DEFAULT_MAX_PROFILE_CHUNKS
+    jobs: int = 1
+    repository: Path | None = None
+    validate_checkout: bool = True
+    source_revision: str | None = None
+    profiling_time_limit_seconds: float | None = None
+    worker_deadline_monotonic: float | None = None
+
+    def __post_init__(self) -> None:
+        if self.target_runtime_seconds <= 0.0:
+            raise ValueError("target_runtime_seconds must be positive")
+        if self.warmup_points < 1:
+            raise ValueError("warmup_points must be positive")
+        if self.minimum_points < 1:
+            raise ValueError("minimum_points must be positive")
+        if self.maximum_points < self.minimum_points:
+            raise ValueError("maximum_points must not be below minimum_points")
+        if self.minimum_profile_chunks < 1:
+            raise ValueError("minimum_profile_chunks must be positive")
+        if self.maximum_profile_chunks < self.minimum_profile_chunks:
+            raise ValueError(
+                "maximum_profile_chunks must not be below minimum_profile_chunks"
+            )
+        if self.jobs < 1:
+            raise ValueError("jobs must be positive")
+        if self.source_revision is not None and re.fullmatch(
+            r"[0-9a-f]{40}", self.source_revision
+        ) is None:
+            raise ValueError("source_revision must be lowercase 40-hex")
+        for name, value in (
+            ("profiling_time_limit_seconds", self.profiling_time_limit_seconds),
+            ("worker_deadline_monotonic", self.worker_deadline_monotonic),
+        ):
+            if value is not None and (not math.isfinite(value) or value <= 0.0):
+                raise ValueError(f"{name} must be finite and positive when specified")
+
+
+@dataclass(frozen=True, slots=True)
+class CommandResult:
+    args: tuple[str, ...]
+    cwd: Path
+    elapsed_seconds: float
+    returncode: int
+    stdout: str
+    stderr: str
+    environment: Mapping[str, str]
+
+    def as_record(self) -> dict[str, object]:
+        return {
+            "args": list(self.args),
+            "cwd": os.fspath(self.cwd.resolve(strict=False)),
+            "elapsed_seconds": self.elapsed_seconds,
+            "returncode": self.returncode,
+            "environment": dict(self.environment),
+        }
+
+
+class CommandExecutor(Protocol):
+    def run(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+        environment: Mapping[str, str] | None = None,
+    ) -> CommandResult: ...
+
+
+class SubprocessExecutor:
+    """Small command seam used by unit tests and campaign supervision."""
+
+    def run(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+        environment: Mapping[str, str] | None = None,
+    ) -> CommandResult:
+        rendered = tuple(os.fspath(item) for item in args)
+        started = time.perf_counter()
+        completed = subprocess.run(
+            rendered,
+            cwd=cwd,
+            env=(None if environment is None else {**os.environ, **dict(environment)}),
+            capture_output=True,
+            check=False,
+            text=True,
+        )
+        result = CommandResult(
+            args=rendered,
+            cwd=cwd,
+            elapsed_seconds=time.perf_counter() - started,
+            returncode=completed.returncode,
+            stdout=completed.stdout,
+            stderr=completed.stderr,
+            environment={} if environment is None else dict(environment),
+        )
+        if completed.returncode != 0:
+            raise LegacyAdapterError(
+                f"command exited with {completed.returncode}: "
+                f"{' '.join(rendered)}\nstdout:\n{completed.stdout}\n"
+                f"stderr:\n{completed.stderr}"
+            )
+        return result
+
+
+class LegacyApi(Protocol):
+    default_repository: Path
+
+    def expected_revision(self) -> str: ...
+
+    def validate_checkout(self, repository: Path) -> None: ...
+
+    def compiler_provenance(self, repository: Path) -> object: ...
+
+    def process_pdgs(self, process: str) -> tuple[int, ...]: ...
+
+    def parse_process_file(self, path: Path) -> tuple[object, ...]: ...
+
+    def select_generated_process_entry(
+        self,
+        entries: Sequence[object],
+        *,
+        generated_process: str,
+        wanted_pdgs: Sequence[int],
+    ) -> tuple[object, tuple[object, ...]]: ...
+
+    def source_mapped_color_order(
+        self,
+        entry: object,
+        *,
+        source_pdgs: Sequence[int],
+    ) -> tuple[int, ...]: ...
+
+    def ordered_momenta(
+        self,
+        source_pdgs: Sequence[int],
+        target_pdgs: Sequence[int],
+        momenta: Sequence[Sequence[float]],
+    ) -> tuple[tuple[float, ...], ...]: ...
+
+    def source_to_row_permutation(
+        self,
+        source_pdgs: Sequence[int],
+        target_pdgs: Sequence[int],
+    ) -> tuple[int, ...]: ...
+
+    def parse_probe_output(self, output: str) -> object: ...
+
+    def run_selected_flow_probe(
+        self,
+        repository: Path,
+        *,
+        entry: object,
+        source_pdgs: Sequence[int],
+        momenta: Sequence[Sequence[float]],
+        helicities: Sequence[int],
+        points: int,
+    ) -> object: ...
+
+    def run_color_probe(
+        self,
+        repository: Path,
+        *,
+        process_file: Path,
+        entry: object,
+        source_pdgs: Sequence[int],
+        momenta: Sequence[Sequence[float]],
+        color_accuracy: str,
+        helicities: Sequence[int] | None,
+    ) -> object: ...
+
+
+class MaintainedLegacyApi:
+    """Thin adapter over ``tools.developer.legacy_amplicol``."""
+
+    def __init__(self) -> None:
+        try:
+            from tools.developer import legacy_amplicol
+        except ModuleNotFoundError as error:
+            if error.name not in {"tools", "tools.developer"}:
+                raise
+            from ._developer import legacy_amplicol
+
+        self._api = legacy_amplicol
+        self.default_repository = legacy_amplicol.DEFAULT_REPOSITORY
+
+    def expected_revision(self) -> str:
+        return str(self._api.expected_revision())
+
+    def validate_checkout(self, repository: Path) -> None:
+        self._api.validate_checkout(repository)
+
+    def compiler_provenance(self, repository: Path) -> object:
+        return self._api._compiler_provenance(repository)
+
+    def process_pdgs(self, process: str) -> tuple[int, ...]:
+        return tuple(self._api.process_pdgs(process))
+
+    def parse_process_file(self, path: Path) -> tuple[object, ...]:
+        return tuple(self._api.parse_process_file(path))
+
+    def select_generated_process_entry(
+        self,
+        entries: Sequence[object],
+        *,
+        generated_process: str,
+        wanted_pdgs: Sequence[int],
+    ) -> tuple[object, tuple[object, ...]]:
+        return self._api.select_generated_process_entry(
+            entries,
+            generated_process=generated_process,
+            wanted_pdgs=wanted_pdgs,
+        )
+
+    def source_mapped_color_order(
+        self,
+        entry: object,
+        *,
+        source_pdgs: Sequence[int],
+    ) -> tuple[int, ...]:
+        return tuple(
+            self._api.source_mapped_color_order(
+                entry,
+                source_pdgs=source_pdgs,
+            )
+        )
+
+    def ordered_momenta(
+        self,
+        source_pdgs: Sequence[int],
+        target_pdgs: Sequence[int],
+        momenta: Sequence[Sequence[float]],
+    ) -> tuple[tuple[float, ...], ...]:
+        return tuple(
+            tuple(float(component) for component in vector)
+            for vector in self._api._ordered_binary64_momenta(
+                source_pdgs,
+                target_pdgs,
+                momenta,
+            )
+        )
+
+    def source_to_row_permutation(
+        self,
+        source_pdgs: Sequence[int],
+        target_pdgs: Sequence[int],
+    ) -> tuple[int, ...]:
+        return tuple(self._api._permutation(source_pdgs, target_pdgs))
+
+    def parse_probe_output(self, output: str) -> object:
+        return self._api._parse_probe_output(output)
+
+    def run_selected_flow_probe(
+        self,
+        repository: Path,
+        *,
+        entry: object,
+        source_pdgs: Sequence[int],
+        momenta: Sequence[Sequence[float]],
+        helicities: Sequence[int],
+        points: int,
+    ) -> object:
+        return self._api.run_selected_flow_library_probe(
+            repository,
+            entry=entry,
+            source_pdgs=source_pdgs,
+            momenta=momenta,
+            helicities=helicities,
+            points=points,
+        )
+
+    def run_color_probe(
+        self,
+        repository: Path,
+        *,
+        process_file: Path,
+        entry: object,
+        source_pdgs: Sequence[int],
+        momenta: Sequence[Sequence[float]],
+        color_accuracy: str,
+        helicities: Sequence[int] | None,
+    ) -> object:
+        return self._api.run_color_probe(
+            repository,
+            process_file=process_file,
+            entry=entry,
+            source_pdgs=source_pdgs,
+            momenta=momenta,
+            color_accuracy=color_accuracy,
+            helicities=helicities,
+        )
+
+
+class ArtifactSnapshotter(Protocol):
+    def snapshot(
+        self,
+        repository: Path,
+        destination: Path,
+        *,
+        executables: Sequence[str],
+        process_file: Path,
+    ) -> Path: ...
+
+
+class GeneratedLibrarySnapshotter:
+    """Copy a generated legacy library into its immutable cell attempt."""
+
+    def snapshot(
+        self,
+        repository: Path,
+        destination: Path,
+        *,
+        executables: Sequence[str],
+        process_file: Path,
+    ) -> Path:
+        if destination.exists():
+            shutil.rmtree(destination)
+        destination.mkdir(parents=True)
+        libraries = tuple(sorted(repository.glob("libamp*.so")))
+        if not libraries:
+            raise LegacyAdapterError("legacy generation produced no libamp*.so")
+        for source in libraries:
+            shutil.copy2(source, destination / source.name)
+        source_library = repository / "Library"
+        if not source_library.is_dir():
+            raise LegacyAdapterError("legacy generation produced no Library directory")
+        shutil.copytree(source_library, destination / "Library")
+        for executable in executables:
+            source = repository / executable
+            if not source.is_file():
+                raise LegacyAdapterError(
+                    f"legacy generated-library probe is missing: {source}"
+                )
+            shutil.copy2(source, destination / executable)
+        shutil.copy2(process_file, destination / "processes.txt")
+        return destination
+
+
+@dataclass(frozen=True, slots=True)
+class TimingRow:
+    label: str
+    seconds: float
+
+
+@dataclass(frozen=True, slots=True)
+class ProfileResult:
+    points: int
+    seconds: float
+    rows: tuple[TimingRow, ...]
+    record: Mapping[str, object]
+    probe: object | None
+    warmup_record: Mapping[str, object]
+    standard_error_seconds_per_point: float
+    relative_standard_error: float
+
+
+@dataclass(frozen=True, slots=True)
+class _ProfileChunk:
+    points: int
+    seconds: float
+    rows: tuple[TimingRow, ...]
+    result: CommandResult
+    probe: object | None
+
+
+def _profile_rate_uncertainty(
+    chunks: Sequence[_ProfileChunk],
+) -> tuple[float, float]:
+    if len(chunks) < 2:
+        return 0.0, 0.0
+    rates = tuple(chunk.seconds / chunk.points for chunk in chunks)
+    mean_rate = statistics.fmean(rates)
+    standard_error = statistics.stdev(rates) / math.sqrt(len(rates))
+    relative_standard_error = standard_error / mean_rate if mean_rate > 0.0 else 0.0
+    return standard_error, relative_standard_error
+
+
+@dataclass(frozen=True, slots=True)
+class _ProcessContext:
+    process_file: Path
+    entries: tuple[object, ...]
+    entry: object
+    matching_rows: int
+    source_pdgs: tuple[int, ...]
+    momenta: tuple[tuple[float, ...], ...]
+    points: tuple[tuple[tuple[float, ...], ...], ...]
+    mapped_color_order: tuple[int, ...]
+    selector_contract: SelectorContract
+
+
+@dataclass(frozen=True, slots=True)
+class _SelectedFlowMeasurement:
+    measurement: dict[str, object]
+    fixed_helicity_value: float
+
+
+@dataclass(frozen=True, slots=True)
+class _ContractedMeasurement:
+    measurement: dict[str, object]
+    imode2_diagnostic: dict[str, object] | None
+
+
+def _imode2_diagnostic(
+    *,
+    authoritative_source: str,
+    authoritative_value: float,
+    imode2_value: float,
+) -> dict[str, object]:
+    absolute = abs(authoritative_value - imode2_value)
+    return {
+        "abi": LEGACY_IMODE2_DIAGNOSTIC_ABI,
+        "certifying": False,
+        "authoritative_source": authoritative_source,
+        "authoritative_value": authoritative_value,
+        "imode2_value": imode2_value,
+        "absolute_difference": absolute,
+        "relative_difference": absolute / max(abs(authoritative_value), 1.0e-300),
+    }
+
+
+def _imode2_component_diagnostic_supported(source_pdgs: Sequence[int]) -> bool:
+    """Return whether the optional direct fixed-flow diagnostic is bounded."""
+
+    if _quark_line_count(source_pdgs) != MAX_OPEN_QUARK_LINES:
+        return True
+    singlets = sum(
+        not (1 <= abs(int(pdg)) <= 6 or abs(int(pdg)) == 21)
+        for pdg in source_pdgs
+    )
+    if singlets:
+        return False
+    gluons = sum(abs(int(pdg)) == 21 for pdg in source_pdgs)
+    color_orders = 3 * math.factorial(gluons) * (gluons + 1) * (gluons + 2)
+    return color_orders <= LEGACY_IMODE2_DIAGNOSTIC_MAX_COLOR_ORDERS
+
+
+def _parse_generated_library_color_probe_output(
+    output: str,
+    *,
+    expected_accuracy: str,
+    expected_group: int,
+    expected_integral: int,
+) -> float:
+    """Parse the compact generated-library probe wire format."""
+
+    values = _LIBRARY_COLOR_VALUE_RE.findall(output)
+    component_rows = _LIBRARY_COLOR_COMPONENTS_RE.findall(output)
+    if len(values) != 1 or len(component_rows) != 1:
+        raise LegacyAdapterError(
+            "generated-library color probe must emit exactly one VALUE and "
+            "one three-component record"
+        )
+    accuracy, raw_group, raw_integral, raw_value = values[0]
+
+    def finite_number(raw: str, *, field: str) -> float:
+        try:
+            value = float(raw.replace("D", "E").replace("d", "e"))
+        except ValueError as error:
+            raise LegacyAdapterError(
+                f"generated-library color probe {field} is malformed"
+            ) from error
+        if not math.isfinite(value):
+            raise LegacyAdapterError(
+                f"generated-library color probe {field} is not finite"
+            )
+        return value
+
+    value = finite_number(raw_value, field="VALUE")
+    components = tuple(
+        finite_number(raw, field=f"COMPONENTS[{index}]")
+        for index, raw in enumerate(component_rows[0])
+    )
+    if (
+        accuracy != expected_accuracy
+        or int(raw_group) != expected_group
+        or int(raw_integral) != expected_integral
+    ):
+        raise LegacyAdapterError(
+            "generated-library color probe identity differs from the requested row"
+        )
+    component_index = {
+        Accuracy.LC.value: 0,
+        Accuracy.NLC.value: 1,
+        Accuracy.FULL.value: 2,
+    }.get(expected_accuracy)
+    if component_index is None or value != components[component_index]:
+        raise LegacyAdapterError(
+            "generated-library color probe VALUE differs from its requested component"
+        )
+    return value
+
+
+def _initial_state_count(process: str) -> int:
+    initial, separator, final = process.partition(">")
+    initial_count = len(initial.split())
+    final_count = len(final.split())
+    if (
+        separator != ">"
+        or process.count(">") != 1
+        or initial_count < 1
+        or final_count < 1
+    ):
+        raise LegacyAdapterError(
+            f"cannot identify initial and final legs in process {process!r}"
+        )
+    return initial_count
+
+
+def _colored_roles(
+    source_pdgs: Sequence[int],
+    *,
+    initial_state_count: int,
+) -> dict[int, str]:
+    roles: dict[int, str] = {}
+    for label, physical_pdg in enumerate(source_pdgs, start=1):
+        absolute = abs(int(physical_pdg))
+        if absolute == 21:
+            roles[label] = "adjoint"
+            continue
+        if not 1 <= absolute <= 6:
+            continue
+        outgoing_pdg = (
+            -int(physical_pdg) if label <= initial_state_count else int(physical_pdg)
+        )
+        roles[label] = "fundamental" if outgoing_pdg > 0 else "antifundamental"
+    return roles
+
+
+def _canonical_mapped_color_word(
+    source_pdgs: Sequence[int],
+    mapped_color_order: Sequence[int],
+    *,
+    initial_state_count: int,
+) -> tuple[int, ...]:
+    """Project a generated-library row onto the canonical public LC axis."""
+
+    pdgs = tuple(int(pdg) for pdg in source_pdgs)
+    mapped = tuple(int(label) for label in mapped_color_order)
+    expected_labels = tuple(range(1, len(pdgs) + 1))
+    if tuple(sorted(mapped)) != expected_labels:
+        raise LegacyAdapterError(
+            "legacy mapped color row must be a permutation of source labels "
+            f"1..{len(pdgs)}, got {mapped}"
+        )
+    if not 0 < initial_state_count < len(pdgs):
+        raise LegacyAdapterError(
+            "legacy selector canonicalization requires nonempty initial and "
+            "final states"
+        )
+    roles = _colored_roles(pdgs, initial_state_count=initial_state_count)
+    return _canonical_colored_word(
+        pdgs,
+        tuple(label for label in mapped if label in roles),
+        initial_state_count=initial_state_count,
+    )
+
+
+def _canonical_colored_word(
+    source_pdgs: Sequence[int],
+    colored_word: Sequence[int],
+    *,
+    initial_state_count: int,
+) -> tuple[int, ...]:
+    """Canonicalize one exact colored-label permutation without padding it."""
+
+    pdgs = tuple(int(pdg) for pdg in source_pdgs)
+    word = tuple(colored_word)
+    if not 0 < initial_state_count < len(pdgs):
+        raise LegacyAdapterError(
+            "legacy selector canonicalization requires nonempty initial and "
+            "final states"
+        )
+
+    roles = _colored_roles(pdgs, initial_state_count=initial_state_count)
+
+    if not roles:
+        raise LegacyAdapterError("selected legacy LC row has no colored word")
+    if (
+        any(isinstance(label, bool) or not isinstance(label, int) for label in word)
+        or len(word) != len(roles)
+        or len(set(word)) != len(word)
+        or set(word) != set(roles)
+    ):
+        raise LegacyAdapterError(
+            "legacy mapped color word must contain every colored source label "
+            "exactly once"
+        )
+
+    fundamental_count = sum(role == "fundamental" for role in roles.values())
+    antifundamental_count = sum(role == "antifundamental" for role in roles.values())
+    if fundamental_count == antifundamental_count == 0:
+        return word
+    if fundamental_count != antifundamental_count:
+        raise LegacyAdapterError(
+            "legacy mapped color word has unbalanced fundamental endpoints"
+        )
+
+    blocks: list[tuple[int, ...]] = []
+    cursor = 0
+    while cursor < len(word):
+        first = word[cursor]
+        if roles[first] != "fundamental":
+            raise LegacyAdapterError(
+                "legacy mapped color word is not a concatenation of "
+                "[fundamental, adjoints..., antifundamental] blocks"
+            )
+        block = [first]
+        cursor += 1
+        while cursor < len(word) and roles[word[cursor]] == "adjoint":
+            block.append(word[cursor])
+            cursor += 1
+        if cursor >= len(word) or roles[word[cursor]] != "antifundamental":
+            raise LegacyAdapterError(
+                "legacy mapped color word is not a concatenation of "
+                "[fundamental, adjoints..., antifundamental] blocks"
+            )
+        block.append(word[cursor])
+        cursor += 1
+        blocks.append(tuple(block))
+
+    blocks.sort(key=lambda block: block[0])
+    return tuple(label for block in blocks for label in block)
+
+
+def _canonical_process_entry(
+    api: LegacyApi,
+    matches: Sequence[object],
+    *,
+    preferred_entry: object,
+    source_pdgs: Sequence[int],
+    initial_state_count: int,
+) -> tuple[object, tuple[int, ...], tuple[int, ...]]:
+    """Bind the exact-source row selected by the generated process file."""
+
+    if sum(entry is preferred_entry for entry in matches) != 1:
+        raise LegacyAdapterError(
+            "preferred generated-library selector row is missing or ambiguous"
+        )
+    mapped = api.source_mapped_color_order(
+        preferred_entry,
+        source_pdgs=source_pdgs,
+    )
+    word = _canonical_mapped_color_word(
+        source_pdgs,
+        mapped,
+        initial_state_count=initial_state_count,
+    )
+    return preferred_entry, mapped, word
+
+
+def adaptive_profile_points(
+    warmup_seconds: float,
+    *,
+    target_runtime_seconds: float,
+    warmup_points: int = DEFAULT_WARMUP_POINTS,
+    minimum_points: int = DEFAULT_MIN_POINTS,
+    maximum_points: int = DEFAULT_MAX_POINTS,
+) -> int:
+    """Choose a bounded integer sample count from one warmup."""
+
+    if warmup_points < 1 or minimum_points < 1:
+        raise ValueError("profile point bounds must be positive")
+    if maximum_points < minimum_points:
+        raise ValueError("maximum_points must not be below minimum_points")
+    if not math.isfinite(warmup_seconds) or warmup_seconds <= 0.0:
+        return minimum_points
+    estimate = math.ceil(float(target_runtime_seconds) * warmup_points / warmup_seconds)
+    return max(minimum_points, min(maximum_points, int(estimate)))
+
+
+def _timing_rows(output: str) -> tuple[TimingRow, ...]:
+    rows: list[TimingRow] = []
+    in_summary = False
+    for line in output.splitlines():
+        if "Timing summary" in line:
+            in_summary = True
+            continue
+        if not in_summary:
+            continue
+        tokens = line.strip().split()
+        if len(tokens) < 2:
+            continue
+        seconds_index: int | None = None
+        seconds: float | None = None
+        for index in range(1, len(tokens)):
+            try:
+                candidate = float(tokens[index])
+            except ValueError:
+                continue
+            seconds_index = index
+            seconds = candidate
+            break
+        if seconds_index is None or seconds is None:
+            continue
+        rows.append(TimingRow(" ".join(tokens[:seconds_index]).lower(), seconds))
+    return tuple(rows)
+
+
+def _timing_seconds(rows: Sequence[TimingRow], *labels: str) -> float | None:
+    for label in labels:
+        wanted = label.strip().lower()
+        for row in rows:
+            if row.label == wanted:
+                return row.seconds
+        for row in rows:
+            if wanted in row.label:
+                return row.seconds
+    return None
+
+
+def _quark_line_count(pdgs: Sequence[int]) -> int:
+    return sum(1 for pdg in pdgs if 1 <= abs(int(pdg)) <= 6) // 2
+
+
+_fixed_helicity = fixed_selector_helicity
+_helicity_id = selector_helicity_id
+
+
+def _compiler_payload(value: object) -> object:
+    if is_dataclass(value):
+        return asdict(value)
+    if isinstance(value, Mapping):
+        return dict(value)
+    return str(value)
+
+
+def _shared_point(
+    process: str,
+) -> tuple[
+    tuple[int, ...],
+    tuple[tuple[float, ...], ...],
+    tuple[tuple[tuple[float, ...], ...], ...],
+]:
+    from pyamplicol.models.builtin.validation import generic_validation_point
+
+    particles = tuple(generic_validation_point(process))
+    pdgs = tuple(int(particle.pdg) for particle in particles)
+    momenta = tuple(
+        tuple(float(component) for component in particle.momentum)
+        for particle in particles
+    )
+    return pdgs, momenta, (momenta,)
+
+
+def _library_environment(path: Path) -> dict[str, str]:
+    existing = os.environ.get("LD_LIBRARY_PATH")
+    root = os.fspath(path.resolve(strict=False))
+    return {"LD_LIBRARY_PATH": root if not existing else f"{root}:{existing}"}
+
+
+@contextmanager
+def _staged_process_file(repository: Path, process_file: Path):
+    repository.mkdir(parents=True, exist_ok=True)
+    target = repository / "processes.txt"
+    backup = repository / ".processes.txt.pyamplicol-report-backup"
+    existed = target.exists()
+    if existed:
+        shutil.copy2(target, backup)
+    shutil.copy2(process_file, target)
+    try:
+        yield target.name
+    finally:
+        if existed:
+            shutil.move(backup, target)
+        else:
+            target.unlink(missing_ok=True)
+        backup.unlink(missing_ok=True)
+
+
+@contextmanager
+def _generation_lepton_pt_cut(repository: Path):
+    """Keep massless-lepton discovery away from the singular zero-energy map."""
+
+    common = repository / "common.f03"
+    original = common.read_text(encoding="utf-8")
+    modified, count = re.subn(
+        r"(?im)^(\s*real\(kind=8\),parameter\s*::\s*pTl_min\s*=\s*)[^!\n]+",
+        r"\g<1>30d0",
+        original,
+    )
+    if count != 1:
+        raise LegacyAdapterError("could not configure library-generation lepton pT cut")
+    common.write_text(modified, encoding="utf-8")
+    # Rebuild this module and its Make dependants even on coarse timestamps.
+    common_object = repository / "common.o"
+    common_object.unlink(missing_ok=True)
+    try:
+        yield
+    finally:
+        common.write_text(original, encoding="utf-8")
+        common_object.unlink(missing_ok=True)
+
+
+class LegacyMeasurementAdapter:
+    """Measure one original-AmpliCol report workload."""
+
+    def __init__(
+        self,
+        *,
+        api: LegacyApi | None = None,
+        executor: CommandExecutor | None = None,
+        snapshotter: ArtifactSnapshotter | None = None,
+        structural_proof: bool | None = None,
+    ) -> None:
+        use_default_api = api is None
+        self.api = MaintainedLegacyApi() if api is None else api
+        self.executor = SubprocessExecutor() if executor is None else executor
+        self.snapshotter = (
+            GeneratedLibrarySnapshotter() if snapshotter is None else snapshotter
+        )
+        # Injected APIs are unit-test/developer seams and preserve the historical
+        # adapter surface unless the caller explicitly supplies real probe
+        # sources.  The production worker constructs the default maintained API,
+        # for which structural evidence is mandatory and fail-closed.
+        self.structural_proof = (
+            use_default_api if structural_proof is None else structural_proof
+        )
+
+    def measure(
+        self,
+        cell: CellSpec,
+        *,
+        artifact_path: Path,
+        settings: LegacySettings,
+        phase_reporter: WorkerPhaseReporter | None = None,
+        selector_provider: Mapping[str, object] | None = None,
+    ) -> dict[str, object]:
+        if cell.measurement.execution_mode is not ExecutionMode.AMPLICOL:
+            raise LegacyAdapterError("legacy adapter requires an AmpliCol cell")
+        if selector_provider is not None and not (
+            cell.measurement.accuracy is Accuracy.LC
+            and cell.workload is Workload.ALL_FLOW
+        ):
+            raise LegacyAdapterError(
+                "selector_provider is only valid for LC all-flow AmpliCol cells"
+            )
+        source_pdgs = self.api.process_pdgs(cell.process)
+        if _quark_line_count(source_pdgs) > MAX_OPEN_QUARK_LINES:
+            if phase_reporter is not None:
+                # Unsupported catalog declarations perform no generation, but
+                # a supervised worker must still close its authenticated phase
+                # channel rather than remain indefinitely in pre-generation.
+                with phase_reporter.generation():
+                    pass
+            result = self._unsupported_measurement(
+                f"original AmpliCol supports at most {MAX_OPEN_QUARK_LINES} "
+                "open quark lines in this report"
+            )
+            if self.structural_proof:
+                from .legacy_structure import (
+                    emit_legacy_scope_unavailable_proof,
+                )
+
+                artifact_path.mkdir(parents=True, exist_ok=True)
+                revision = settings.source_revision or self.api.expected_revision()
+                proof = emit_legacy_scope_unavailable_proof(
+                    cell,
+                    artifact_path=artifact_path,
+                    source_revision=revision,
+                    maximum_open_quark_lines=MAX_OPEN_QUARK_LINES,
+                    observed_open_quark_lines=_quark_line_count(source_pdgs),
+                )
+                result["artifact"] = {
+                    "path": os.fspath(artifact_path),
+                    "legacy_structural_proof": os.fspath(proof),
+                }
+                result["provenance"] = {
+                    "method": "original-amplicol-scope-boundary",
+                    "revision": revision,
+                }
+            if phase_reporter is not None:
+                phase_reporter.profiling_started()
+                phase_reporter.validation_started()
+            return result
+
+        repository = settings.repository or self.api.default_repository
+        repository_context: Any = nullcontext()
+        if self.structural_proof:
+            from .legacy_structure import legacy_structural_probe_lock
+
+            repository_context = legacy_structural_probe_lock(repository)
+        with repository_context:
+            if settings.validate_checkout:
+                self.api.validate_checkout(repository)
+            artifact_path.mkdir(parents=True, exist_ok=True)
+            instrumentation_context: Any = nullcontext(None)
+            if self.structural_proof:
+                from .legacy_structure import instrument_legacy_structural_probes
+
+                instrumentation_context = instrument_legacy_structural_probes(
+                    repository,
+                    artifact_path,
+                )
+            with instrumentation_context as instrumentation:
+                return self._measure_supported(
+                    cell,
+                    repository=repository,
+                    artifact_path=artifact_path,
+                    settings=settings,
+                    instrumentation=instrumentation,
+                    phase_reporter=phase_reporter,
+                    selector_provider=selector_provider,
+                )
+
+    def _measure_supported(
+        self,
+        cell: CellSpec,
+        *,
+        repository: Path,
+        artifact_path: Path,
+        settings: LegacySettings,
+        instrumentation: object | None,
+        phase_reporter: WorkerPhaseReporter | None,
+        selector_provider: Mapping[str, object] | None,
+    ) -> dict[str, object]:
+        log_path = artifact_path / "legacy.log"
+        commands: list[dict[str, object]] = []
+        context = self._prepare_process(
+            cell,
+            repository=repository,
+            artifact_path=artifact_path,
+            commands=commands,
+            log_path=log_path,
+        )
+        provided_common_component = (
+            None
+            if selector_provider is None
+            else self._selector_provider_common_component(
+                cell,
+                context=context,
+                selector_provider=selector_provider,
+                commands=commands,
+                log_path=log_path,
+            )
+        )
+        contracted: _ContractedMeasurement | None = None
+        if cell.measurement.accuracy is Accuracy.LC:
+            if cell.workload is Workload.SELECTED_FLOW:
+                selected = self._measure_selected_flow(
+                    cell,
+                    context=context,
+                    repository=repository,
+                    artifact_path=artifact_path,
+                    settings=settings,
+                    commands=commands,
+                    log_path=log_path,
+                    phase_reporter=phase_reporter,
+                )
+                result = selected.measurement
+            elif cell.workload is Workload.ALL_FLOW:
+                result = self._measure_all_flow(
+                    cell,
+                    context=context,
+                    repository=repository,
+                    artifact_path=artifact_path,
+                    settings=settings,
+                    commands=commands,
+                    log_path=log_path,
+                    phase_reporter=phase_reporter,
+                )
+            else:
+                raise LegacyAdapterError("LC AmpliCol cell requires an LC workload")
+        elif cell.workload is Workload.CONTRACTED:
+            contracted = self._measure_contracted(
+                cell,
+                context=context,
+                repository=repository,
+                artifact_path=artifact_path,
+                settings=settings,
+                commands=commands,
+                log_path=log_path,
+                phase_reporter=phase_reporter,
+            )
+            result = contracted.measurement
+        else:
+            raise LegacyAdapterError("NLC/full AmpliCol cells must be contracted")
+
+        process_row = (
+            f"group:{int(context.entry.group)}:integral:{int(context.entry.integral)}"
+        )
+        result["artifact"] = {
+            "path": os.fspath(artifact_path),
+            "process_row": process_row,
+            "log_path": os.fspath(log_path),
+        }
+        result["selector_contract"] = (
+            context.selector_contract.as_dict()
+            if cell.measurement.accuracy is Accuracy.LC
+            else None
+        )
+        result["validation"] = {
+            "status": ResultStatus.OK.value,
+            "method": "independent-original-amplicol-oracle",
+            "point_digest": context.selector_contract.point_digest,
+            DIRECT_AGREEMENT_FIELD: [],
+        }
+        authority_source: str | None = None
+        if cell.workload is Workload.SELECTED_FLOW:
+            authority_source = "selected-flow-generated-library"
+        elif (
+            cell.workload is Workload.ALL_FLOW
+            and provided_common_component is not None
+        ):
+            authority_source = "all-flow-selected-provider-replay"
+        elif contracted is not None:
+            authority_source = (
+                "contracted-generated-library"
+                if contracted.imode2_diagnostic is not None
+                else "direct-imode2-three-quark-line"
+            )
+        if authority_source is not None:
+            result["validation"][LEGACY_NUMERICAL_AUTHORITY_FIELD] = {
+                "abi": LEGACY_NUMERICAL_AUTHORITY_ABI,
+                "source": authority_source,
+            }
+        if contracted is not None and contracted.imode2_diagnostic is not None:
+            result["validation"][LEGACY_IMODE2_DIAGNOSTIC_FIELD] = (
+                contracted.imode2_diagnostic
+            )
+        if cell.measurement.accuracy is Accuracy.LC:
+            if cell.workload is Workload.SELECTED_FLOW:
+                common_component = legacy_lc_common_component(
+                    cell,
+                    context.selector_contract,
+                    selected.fixed_helicity_value,
+                )
+            elif provided_common_component is None:
+                common_component = self._measure_lc_common_component(
+                    cell,
+                    context=context,
+                    repository=repository,
+                    commands=commands,
+                    log_path=log_path,
+                )
+            else:
+                common_component = provided_common_component
+                if _imode2_component_diagnostic_supported(context.source_pdgs):
+                    direct_common_component = self._measure_lc_common_component(
+                        cell,
+                        context=context,
+                        repository=repository,
+                        commands=commands,
+                        log_path=log_path,
+                    )
+                    result["validation"][LEGACY_IMODE2_DIAGNOSTIC_FIELD] = (
+                        _imode2_diagnostic(
+                            authoritative_source=(
+                                "selected-flow-generated-library-component"
+                            ),
+                            authoritative_value=float(common_component["value"]),
+                            imode2_value=float(direct_common_component["value"]),
+                        )
+                    )
+            result["validation"][LC_COMMON_COMPONENT_FIELD] = common_component
+            if cell.workload is Workload.ALL_FLOW and (
+                float(result["matrix_element"]) <= 0.0
+                or float(common_component["value"]) <= 0.0
+            ):
+                raise LegacyAdapterError(
+                    "LC all-flow selector resolved to a structural-zero "
+                    "helicity; choose and remeasure a nonzero fixed-helicity "
+                    "selector before publishing dependent cells"
+                )
+        result["resources"] = {
+            "monitor": "external-cell-supervisor",
+            "peak_rss_gib": None,
+        }
+        try:
+            compiler = _compiler_payload(self.api.compiler_provenance(repository))
+        except Exception as error:
+            compiler = {
+                "status": "unavailable",
+                "error": str(error),
+            }
+        revision = settings.source_revision or self.api.expected_revision()
+        result["provenance"] = {
+            **dict(result.get("provenance") or {}),
+            "method": "original-amplicol-generated-library",
+            "revision": revision,
+            "compiler": compiler,
+            "platform": platform.platform(),
+            "python": platform.python_version(),
+            "repository": os.fspath(repository.resolve(strict=False)),
+            "row_selection_policy": (
+                "exact-external-pdg-order-then-process-file-order-v1"
+            ),
+            "matching_row_count": context.matching_rows,
+            "raw_mapped_color_order": list(context.mapped_color_order),
+            "selector_color_word_policy": (
+                "outgoing-open-string-blocks-by-fundamental-source-label-v1"
+            ),
+            "commands": commands,
+            "target_runtime_seconds": settings.target_runtime_seconds,
+            "warmup_points": settings.warmup_points,
+            "minimum_points": settings.minimum_points,
+            "maximum_points": settings.maximum_points,
+            "minimum_profile_chunks": settings.minimum_profile_chunks,
+            "maximum_profile_chunks": settings.maximum_profile_chunks,
+            "generation_timing_is_workload_specific": True,
+        }
+        if instrumentation is not None:
+            from .legacy_structure import emit_legacy_structural_proof
+
+            proof = emit_legacy_structural_proof(
+                cell,
+                artifact_path=artifact_path,
+                process_row=process_row,
+                source_revision=revision,
+                repository=repository,
+                instrumentation=instrumentation,
+            )
+            result["artifact"]["legacy_structural_proof"] = os.fspath(proof)
+        if result["status"] == ResultStatus.OK.value:
+            result["failure"] = None
+        return result
+
+    def _selector_provider_common_component(
+        self,
+        cell: CellSpec,
+        *,
+        context: _ProcessContext,
+        selector_provider: Mapping[str, object],
+        commands: list[dict[str, object]],
+        log_path: Path,
+    ) -> dict[str, object]:
+        if selector_provider.get("status") != ResultStatus.OK.value:
+            raise LegacyAdapterError(
+                "LC all-flow selector provider is not a successful measurement"
+            )
+        raw_contract = selector_provider.get("selector_contract")
+        if not isinstance(raw_contract, Mapping):
+            raise LegacyAdapterError(
+                "LC all-flow selector provider has no selector contract"
+            )
+        try:
+            provider_contract = SelectorContract.from_mapping(raw_contract)
+        except (TypeError, ValueError) as error:
+            raise LegacyAdapterError(
+                "LC all-flow selector provider has an invalid selector contract"
+            ) from error
+        if provider_contract != context.selector_contract:
+            raise LegacyAdapterError(
+                "LC all-flow selector provider contract does not match the cell"
+            )
+        raw_validation = selector_provider.get("validation")
+        if (
+            not isinstance(raw_validation, Mapping)
+            or raw_validation.get("status") != ResultStatus.OK.value
+        ):
+            raise LegacyAdapterError(
+                "LC all-flow selector provider has no successful validation"
+            )
+        raw_component = raw_validation.get(LC_COMMON_COMPONENT_FIELD)
+        try:
+            validate_lc_common_component(
+                raw_component,
+                selector_contract=raw_contract,
+            )
+        except ValueError as error:
+            raise LegacyAdapterError(
+                "LC all-flow selector provider has an invalid common component"
+            ) from error
+        assert isinstance(raw_component, Mapping)
+        raw_value = raw_component.get("value")
+        if (
+            isinstance(raw_value, bool)
+            or not isinstance(raw_value, (int, float))
+            or not math.isfinite(float(raw_value))
+        ):
+            raise LegacyAdapterError(
+                "LC all-flow selector provider common component is not finite"
+            )
+        raw_artifact = selector_provider.get("artifact")
+        raw_artifact_path = (
+            raw_artifact.get("path") if isinstance(raw_artifact, Mapping) else None
+        )
+        if not isinstance(raw_artifact_path, str) or not raw_artifact_path:
+            raise LegacyAdapterError(
+                "LC all-flow selector provider has no artifact path"
+            )
+        generated = Path(raw_artifact_path) / "selected-flow-generated-library"
+        required_paths = (
+            generated / "amplicol_library_benchmark",
+            generated / "processes.txt",
+            generated / "Library",
+        )
+        if (
+            not required_paths[0].is_file()
+            or not os.access(required_paths[0], os.X_OK)
+            or not required_paths[1].is_file()
+            or not required_paths[2].is_dir()
+        ):
+            raise LegacyAdapterError(
+                "LC all-flow selector provider generated-library artifact is incomplete"
+            )
+        provider_entries = self.api.parse_process_file(required_paths[1])
+        _provider_entry, provider_matches = self.api.select_generated_process_entry(
+            provider_entries,
+            generated_process=cell.process,
+            wanted_pdgs=context.source_pdgs,
+        )
+        provider_entry, _provider_mapped, provider_word = _canonical_process_entry(
+            self.api,
+            provider_matches,
+            preferred_entry=_provider_entry,
+            source_pdgs=context.source_pdgs,
+            initial_state_count=_initial_state_count(cell.process),
+        )
+        if provider_word != context.selector_contract.selected_color_words[0]:
+            raise LegacyAdapterError(
+                "LC all-flow selector provider artifact row does not match its "
+                "selector contract"
+            )
+        fixed_helicities = tuple(
+            value
+            for _label, value in context.selector_contract.all_flow_source_helicities
+        )
+        probe_args = (
+            "legacy_amplicol.run_selected_flow_library_probe",
+            os.fspath(generated),
+            "points=1",
+            "helicities=" + ",".join(f"{value:+d}" for value in fixed_helicities),
+        )
+        record_index, probe_started = self._record_api_launch(
+            probe_args,
+            cwd=generated,
+            commands=commands,
+            log_path=log_path,
+            intended_points=1,
+        )
+        with _temporary_environment(_library_environment(generated)):
+            probe = self.api.run_selected_flow_probe(
+                generated,
+                entry=provider_entry,
+                source_pdgs=context.source_pdgs,
+                momenta=context.momenta,
+                helicities=fixed_helicities,
+                points=1,
+            )
+        self._finish_api_launch(
+            record_index,
+            probe_args,
+            cwd=generated,
+            commands=commands,
+            started=probe_started,
+        )
+        fresh_value = getattr(probe, "fixed_helicity_value", None)
+        if (
+            isinstance(fresh_value, bool)
+            or not isinstance(fresh_value, (int, float))
+            or not math.isfinite(float(fresh_value))
+        ):
+            raise LegacyAdapterError(
+                "LC all-flow selector provider replay emitted no finite fixed-"
+                "helicity component"
+            )
+        replay = pointwise_validation(
+            float(fresh_value),
+            float(raw_value),
+            relative_tolerance=RELATIVE_TOLERANCE,
+            absolute_tolerance=ABSOLUTE_TOLERANCE,
+        )
+        if replay["status"] != ResultStatus.OK.value:
+            raise LegacyAdapterError(
+                "LC all-flow selector provider replay disagrees with its recorded "
+                "common component"
+            )
+        return legacy_lc_common_component(
+            cell,
+            context.selector_contract,
+            float(fresh_value),
+        )
+
+    def _measure_lc_common_component(
+        self,
+        cell: CellSpec,
+        *,
+        context: _ProcessContext,
+        repository: Path,
+        commands: list[dict[str, object]],
+        log_path: Path,
+    ) -> dict[str, object]:
+        """Probe the fixed-helicity/fixed-flow component common to both lanes."""
+
+        if cell.workload is Workload.SELECTED_FLOW:
+            raise LegacyAdapterError(
+                "selected-flow LC common components must come from the generated "
+                "library probe"
+            )
+        helicities = tuple(
+            value
+            for _label, value in (context.selector_contract.all_flow_source_helicities)
+        )
+        probe_args = (
+            "legacy_amplicol.run_color_probe",
+            Accuracy.LC.value,
+            "fixed-helicity",
+            "points=1",
+        )
+        record_index, started = self._record_api_launch(
+            probe_args,
+            cwd=repository,
+            commands=commands,
+            log_path=log_path,
+            intended_points=1,
+        )
+        probe = self.api.run_color_probe(
+            repository,
+            process_file=context.process_file,
+            entry=context.entry,
+            source_pdgs=context.source_pdgs,
+            momenta=context.momenta,
+            color_accuracy=Accuracy.LC.value,
+            helicities=helicities,
+        )
+        self._finish_api_launch(
+            record_index,
+            probe_args,
+            cwd=repository,
+            commands=commands,
+            started=started,
+        )
+        partitions = tuple(getattr(probe, "lc_row_partitions", ()))
+        if not partitions:
+            raise LegacyAdapterError(
+                "direct LC probe emitted no resolved row partitions"
+            )
+        source_to_row = self.api.source_to_row_permutation(
+            context.source_pdgs,
+            context.entry.process_pdgs,
+        )
+        if (
+            len(source_to_row) != len(context.source_pdgs)
+            or any(
+                isinstance(position, bool) or not isinstance(position, int)
+                for position in source_to_row
+            )
+            or set(source_to_row) != set(range(len(context.source_pdgs)))
+        ):
+            raise LegacyAdapterError(
+                "direct LC probe source-to-row mapping is not a permutation"
+            )
+        wanted_word = context.selector_contract.selected_color_words[0]
+        matching: list[object] = []
+        seen_rows: set[int] = set()
+        seen_words: set[tuple[int, ...]] = set()
+        resolved_values: list[float] = []
+        for partition in partitions:
+            raw_permutation = tuple(getattr(partition, "permutation", ()))
+            row = getattr(partition, "row", None)
+            if (
+                isinstance(row, bool)
+                or not isinstance(row, int)
+                or row < 1
+                or row in seen_rows
+            ):
+                raise LegacyAdapterError(
+                    "direct LC probe emitted an invalid or duplicate row index"
+                )
+            seen_rows.add(row)
+            if (
+                any(
+                    isinstance(position, bool) or not isinstance(position, int)
+                    for position in raw_permutation
+                )
+                or len(set(raw_permutation)) != len(raw_permutation)
+                or any(
+                    position < 1 or position > len(source_to_row)
+                    for position in raw_permutation
+                )
+            ):
+                raise LegacyAdapterError(
+                    "direct LC probe emitted an invalid row permutation"
+                )
+            source_word = tuple(
+                source_to_row[position - 1] + 1 for position in raw_permutation
+            )
+            if source_word in seen_words:
+                raise LegacyAdapterError(
+                    "direct LC probe emitted a duplicate physical row"
+                )
+            seen_words.add(source_word)
+            canonical_word = _canonical_colored_word(
+                context.source_pdgs,
+                source_word,
+                initial_state_count=_initial_state_count(cell.process),
+            )
+            raw_value = getattr(partition, "value", None)
+            if (
+                isinstance(raw_value, bool)
+                or not isinstance(raw_value, (int, float))
+                or not math.isfinite(float(raw_value))
+            ):
+                raise LegacyAdapterError(
+                    "direct LC probe emitted a non-finite partition value"
+                )
+            resolved_values.append(float(raw_value))
+            if canonical_word == wanted_word:
+                matching.append(partition)
+        if sorted(seen_rows) != list(range(1, len(partitions) + 1)):
+            raise LegacyAdapterError(
+                "direct LC probe row indices are not a complete contiguous axis"
+            )
+        raw_partition_sum = getattr(probe, "lc_partition_sum", None)
+        raw_aggregate = getattr(probe, "value", None)
+        if (
+            isinstance(raw_partition_sum, bool)
+            or not isinstance(raw_partition_sum, (int, float))
+            or not math.isfinite(float(raw_partition_sum))
+            or isinstance(raw_aggregate, bool)
+            or not isinstance(raw_aggregate, (int, float))
+            or not math.isfinite(float(raw_aggregate))
+        ):
+            raise LegacyAdapterError("direct LC probe aggregate evidence is not finite")
+        resolved_sum = math.fsum(resolved_values)
+        if not math.isclose(
+            resolved_sum,
+            float(raw_partition_sum),
+            rel_tol=1.0e-10,
+            abs_tol=1.0e-12,
+        ):
+            raise LegacyAdapterError(
+                "direct LC probe resolved partitions do not match their sum"
+            )
+        if not math.isclose(
+            float(raw_partition_sum),
+            float(raw_aggregate),
+            rel_tol=1.0e-10,
+            abs_tol=1.0e-12,
+        ):
+            raise LegacyAdapterError(
+                "direct LC probe partition sum does not match its aggregate"
+            )
+        if len(matching) != 1:
+            raise LegacyAdapterError(
+                "direct LC probe did not identify exactly one selected physical row"
+            )
+        raw_value = getattr(matching[0], "value", None)
+        if (
+            isinstance(raw_value, bool)
+            or not isinstance(raw_value, (int, float))
+            or not math.isfinite(float(raw_value))
+        ):
+            raise LegacyAdapterError("direct LC probe selected row has no finite value")
+        return legacy_lc_common_component(
+            cell,
+            context.selector_contract,
+            float(raw_value),
+        )
+
+    def _prepare_process(
+        self,
+        cell: CellSpec,
+        *,
+        repository: Path,
+        artifact_path: Path,
+        commands: list[dict[str, object]],
+        log_path: Path,
+    ) -> _ProcessContext:
+        source_pdgs, momenta, points = _shared_point(cell.process)
+        declared_pdgs = self.api.process_pdgs(cell.process)
+        if source_pdgs != declared_pdgs:
+            raise LegacyAdapterError(
+                "shared validation point external order differs from the "
+                "legacy process expression"
+            )
+        family = next(
+            (
+                item
+                for item in REPORT_CATALOG.process_families
+                if item.key == cell.process_key
+            ),
+            None,
+        )
+        flags: list[str] = []
+        if family is not None:
+            if family.include_3qqbar:
+                flags.append("-3")
+            if family.include_cc:
+                flags.append("-cc")
+            if family.include_resonance:
+                flags.append("-res")
+        process_result = self._run(
+            [
+                sys.executable,
+                repository / "process_list.py",
+                "--serial",
+                *flags,
+                cell.process,
+            ],
+            cwd=artifact_path,
+            commands=commands,
+            log_path=log_path,
+        )
+        process_file = artifact_path / "processes.txt"
+        if not process_file.is_file():
+            raise LegacyAdapterError(
+                "legacy process_list.py did not produce processes.txt; "
+                f"output={process_result.stdout[-1000:]!r}"
+            )
+        entries = self.api.parse_process_file(process_file)
+        entry, matches = self.api.select_generated_process_entry(
+            entries,
+            generated_process=cell.process,
+            wanted_pdgs=source_pdgs,
+        )
+        if cell.measurement.accuracy is Accuracy.LC:
+            entry, mapped, color_word = _canonical_process_entry(
+                self.api,
+                matches,
+                preferred_entry=entry,
+                source_pdgs=source_pdgs,
+                initial_state_count=_initial_state_count(cell.process),
+            )
+        else:
+            mapped = self.api.source_mapped_color_order(
+                entry,
+                source_pdgs=source_pdgs,
+            )
+            color_word = _canonical_mapped_color_word(
+                source_pdgs,
+                mapped,
+                initial_state_count=_initial_state_count(cell.process),
+            )
+        helicities = _fixed_helicity(source_pdgs)
+        contract = SelectorContract(
+            selected_color_flow_ids=(selector_color_flow_id(color_word),),
+            selected_color_words=(color_word,),
+            all_flow_helicity_ids=(_helicity_id(helicities),),
+            all_flow_source_helicities=tuple(
+                (index, value) for index, value in enumerate(helicities, start=1)
+            ),
+            point_digest=point_digest(points),
+        )
+        return _ProcessContext(
+            process_file=process_file,
+            entries=entries,
+            entry=entry,
+            matching_rows=len(matches),
+            source_pdgs=source_pdgs,
+            momenta=momenta,
+            points=points,
+            mapped_color_order=mapped,
+            selector_contract=contract,
+        )
+
+    def _generate_library(
+        self,
+        *,
+        context: _ProcessContext,
+        repository: Path,
+        raw_color: bool,
+        n_final: int,
+        process_key: str | None,
+        settings: LegacySettings,
+        commands: list[dict[str, object]],
+        log_path: Path,
+        phase_reporter: WorkerPhaseReporter | None = None,
+    ) -> float:
+        # Building the reusable generator and its object graph is campaign
+        # bootstrap, not per-process generation.  Resolve that one-time cost
+        # before opening the generation timing boundary.  ``cleanlib`` updates
+        # dummy.o, so the ordinary per-process relink below remains measured.
+        self._run(
+            ("make", f"-j{settings.jobs}", "amplicol_generate"),
+            cwd=repository,
+            commands=commands,
+            log_path=log_path,
+        )
+        started_index = len(commands)
+        generation_context = (
+            nullcontext() if phase_reporter is None else phase_reporter.generation()
+        )
+        with generation_context:
+            # Optimized LC library creation discovers numerical-zero and alias
+            # helicities over ten accepted events.  The supplied-momenta probe
+            # rereads one point and repeats it ten times, which can permanently
+            # prune a live helicity that is accidentally tiny at that point.
+            # Use standard, reproducibly seeded integration so those ten events
+            # carry genuinely distinct kinematics.  For a 2-to-1 process,
+            # legacy gen23 leaves the sole final-state momentum at zero; that
+            # makes its H_T/2 scale invalid, so use the supplied canonical
+            # physical point instead.  The same generator has a degenerate
+            # massless 2-to-2 lepton branch: its t range remains identically
+            # zero and it appends the diagnostic forever.  Massless fermion
+            # helicity zeros are chirality identities rather than accidental
+            # pointwise zeros, so the non-degenerate canonical point is the
+            # safe library-construction boundary for these two-body leptonic
+            # references as well.
+            # Raw-color creation does not apply this filter and likewise keeps
+            # its existing single-point path.
+            final_pdgs = context.source_pdgs[2:]
+            massless_two_body_leptons = (
+                n_final == 2
+                and len(final_pdgs) == 2
+                and all(11 <= abs(pdg) <= 16 for pdg in final_pdgs)
+            )
+            generation_point_arguments = (
+                ("--amplicol_momenta_probe=10", "--amplicol_probe_quiet")
+                if raw_color or n_final == 1 or massless_two_body_leptons
+                else ("--seed=101",)
+            )
+            if (
+                not raw_color
+                and n_final >= 4
+                and process_key in {"dd_epemzh_jets", "ud_epve_jets"}
+            ):
+                # The default gen23 inverse map aborts with smin >= smax
+                # for these multi-body leptonic families. The existing
+                # t-channel map avoids that branch while retaining distinct
+                # seeded discovery points.
+                generation_point_arguments += ("--phasespace=4",)
+            momenta_directory = repository / "Utilities" / "ME_checks"
+            momenta_directory.mkdir(parents=True, exist_ok=True)
+            for entry in context.entries:
+                ordered = self.api.ordered_momenta(
+                    context.source_pdgs,
+                    entry.process_pdgs,
+                    context.momenta,
+                )
+                momenta_path = (
+                    momenta_directory / f"momenta_{entry.group}_{entry.integral}.txt"
+                )
+                momenta_path.write_text(
+                    "\n".join(
+                        " ".join(f"{component:.17e}" for component in vector)
+                        for vector in ordered
+                    )
+                    + "\n",
+                    encoding="utf-8",
+                )
+            with _staged_process_file(
+                repository,
+                context.process_file,
+            ) as process_arg:
+                for args in (
+                    ("make", "cleanlib"),
+                    ("make", f"-j{settings.jobs}", "amplicol_generate"),
+                    (
+                        "./amplicol_generate",
+                        f"--library={'create-raw' if raw_color else 'create'}",
+                        f"--process={process_arg}",
+                        *generation_point_arguments,
+                        "--timing=none",
+                    ),
+                    ("make", f"-j{settings.jobs}", "amplicol_generate_library"),
+                ):
+                    self._run(
+                        args,
+                        cwd=repository,
+                        commands=commands,
+                        log_path=log_path,
+                    )
+        return math.fsum(
+            float(record["elapsed_seconds"]) for record in commands[started_index:]
+        )
+
+    def _measure_selected_flow(
+        self,
+        cell: CellSpec,
+        *,
+        context: _ProcessContext,
+        repository: Path,
+        artifact_path: Path,
+        settings: LegacySettings,
+        commands: list[dict[str, object]],
+        log_path: Path,
+        phase_reporter: WorkerPhaseReporter | None,
+    ) -> _SelectedFlowMeasurement:
+        # Disabled lepton cuts leave singular zero-energy/transfer endpoints
+        # in gen23, also when the four-lepton family includes jets.
+        # These cuts only choose ten distinct library-discovery points; restore
+        # the original module before building the fixed-momenta benchmark.
+        discovery_cuts = (
+            _generation_lepton_pt_cut(repository)
+            if cell.process_key == "dd_4l_jets" and cell.n_final >= 4
+            else nullcontext()
+        )
+        with discovery_cuts:
+            generation_seconds = self._generate_library(
+                context=context,
+                repository=repository,
+                raw_color=False,
+                n_final=cell.n_final,
+                process_key=cell.process_key,
+                settings=settings,
+                commands=commands,
+                log_path=log_path,
+                phase_reporter=phase_reporter,
+            )
+        self._run(
+            ("make", f"-j{settings.jobs}", "amplicol_library_benchmark"),
+            cwd=repository,
+            commands=commands,
+            log_path=log_path,
+        )
+        generated = self.snapshotter.snapshot(
+            repository,
+            artifact_path / "selected-flow-generated-library",
+            executables=("amplicol_library_benchmark",),
+            process_file=context.process_file,
+        )
+        ordered = self.api.ordered_momenta(
+            context.source_pdgs,
+            context.entry.process_pdgs,
+            context.momenta,
+        )
+        # Time the campaign's authenticated point explicitly.  The legacy
+        # no-argument path instead replays an internal random generation point
+        # and applies a brittle componentwise check to cancellation residues;
+        # that self-check is not the selected-flow observable validated below.
+        momenta_path = generated / "profile-momenta.dat"
+        momenta_path.write_text(
+            "\n".join(
+                " ".join(format(component, ".17g") for component in vector)
+                for vector in ordered
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        environment = _library_environment(generated)
+        profile = self._profile(
+            lambda count: self._invoke_command(
+                (
+                    "./amplicol_library_benchmark",
+                    str(count),
+                    str(context.entry.group),
+                    str(context.entry.integral),
+                    momenta_path.name,
+                ),
+                cwd=generated,
+                environment=environment,
+                commands=commands,
+                log_path=log_path,
+            ),
+            settings=settings,
+            # Match pyAmpliCol's selected-flow observable: the physical
+            # helicity sum of squared amplitudes, not amplitude production alone.
+            timing_labels=("total",),
+            phase_reporter=phase_reporter,
+        )
+        if phase_reporter is not None:
+            phase_reporter.validation_started()
+        with _temporary_environment(environment):
+            fixed_helicities = tuple(
+                value
+                for _label, value in (
+                    context.selector_contract.all_flow_source_helicities
+                )
+            )
+            probe_args = (
+                "legacy_amplicol.run_selected_flow_library_probe",
+                os.fspath(generated),
+                "points=1",
+                "helicities=" + ",".join(f"{value:+d}" for value in fixed_helicities),
+            )
+            record_index, probe_started = self._record_api_launch(
+                probe_args,
+                cwd=generated,
+                commands=commands,
+                log_path=log_path,
+                intended_points=1,
+            )
+            probe = self.api.run_selected_flow_probe(
+                generated,
+                entry=context.entry,
+                source_pdgs=context.source_pdgs,
+                momenta=context.momenta,
+                helicities=fixed_helicities,
+                points=1,
+            )
+            self._finish_api_launch(
+                record_index,
+                probe_args,
+                cwd=generated,
+                commands=commands,
+                started=probe_started,
+            )
+        fixed_helicity_value = getattr(probe, "fixed_helicity_value", None)
+        if (
+            isinstance(fixed_helicity_value, bool)
+            or not isinstance(fixed_helicity_value, (int, float))
+            or not math.isfinite(float(fixed_helicity_value))
+        ):
+            raise LegacyAdapterError(
+                "selected-flow generated-library probe emitted no finite "
+                "fixed-helicity component"
+            )
+        return _SelectedFlowMeasurement(
+            measurement=self._success_measurement(
+                generation_seconds=generation_seconds,
+                profile=profile,
+                matrix_element=float(probe.value),
+                generation_source="generated-library-create-mode-1",
+            ),
+            fixed_helicity_value=float(fixed_helicity_value),
+        )
+
+    def _measure_all_flow(
+        self,
+        cell: CellSpec,
+        *,
+        context: _ProcessContext,
+        repository: Path,
+        artifact_path: Path,
+        settings: LegacySettings,
+        commands: list[dict[str, object]],
+        log_path: Path,
+        phase_reporter: WorkerPhaseReporter | None,
+    ) -> dict[str, object]:
+        self._run(
+            ("make", f"-j{settings.jobs}", "amplicol_color_probe"),
+            cwd=repository,
+            commands=commands,
+            log_path=log_path,
+        )
+        helicities = tuple(
+            value
+            for _label, value in (context.selector_contract.all_flow_source_helicities)
+        )
+        with tempfile.TemporaryDirectory(prefix="pac-", dir="/tmp") as raw:
+            work = Path(raw)
+            process_copy = work / "processes.txt"
+            momenta_path = work / "momenta.dat"
+            shutil.copy2(context.process_file, process_copy)
+            ordered = self.api.ordered_momenta(
+                context.source_pdgs,
+                context.entry.process_pdgs,
+                context.momenta,
+            )
+            momenta_path.write_text(
+                "\n".join(
+                    " ".join(format(component, ".17g") for component in vector)
+                    for vector in ordered
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+            permutation = self.api.source_to_row_permutation(
+                context.source_pdgs,
+                context.entry.process_pdgs,
+            )
+            ordered_helicities = tuple(helicities[index] for index in permutation)
+            probe_args = (
+                repository / "amplicol_color_probe",
+                str(1),
+                str(context.entry.group),
+                str(context.entry.integral),
+                "lc",
+                process_copy,
+                momenta_path,
+                *(str(value) for value in ordered_helicities),
+            )
+            if phase_reporter is not None:
+                _generation_result, generation_rows, generation_probe = (
+                    self._invoke_generation_probe(
+                        probe_args,
+                        phase_reporter=phase_reporter,
+                        cwd=work,
+                        commands=commands,
+                        log_path=log_path,
+                    )
+                )
+            profile = self._profile(
+                lambda count: self._invoke_probe_command(
+                    (
+                        repository / "amplicol_color_probe",
+                        str(count),
+                        str(context.entry.group),
+                        str(context.entry.integral),
+                        "lc",
+                        process_copy,
+                        momenta_path,
+                        *(str(value) for value in ordered_helicities),
+                    ),
+                    cwd=work,
+                    commands=commands,
+                    log_path=log_path,
+                ),
+                settings=settings,
+                timing_labels=("amplitude evaluation", "total"),
+                phase_reporter=phase_reporter,
+            )
+            if phase_reporter is not None:
+                phase_reporter.validation_started()
+            if phase_reporter is None:
+                # Preserve the unsupervised adapter's historical single-profile
+                # behavior.  Campaign workers always supply a reporter and use
+                # the dedicated authenticated generation probe above.
+                generation_rows = profile.rows
+                generation_probe = profile.probe
+            if self.structural_proof:
+                from .legacy_structure import (
+                    STRUCTURAL_PROBE_ENVIRONMENT,
+                    write_legacy_structural_probe_output,
+                )
+
+                structural, _rows, _probe = self._invoke_probe_command(
+                    probe_args,
+                    cwd=work,
+                    commands=commands,
+                    log_path=log_path,
+                    environment={STRUCTURAL_PROBE_ENVIRONMENT: "1"},
+                )
+                write_legacy_structural_probe_output(
+                    artifact_path
+                    / "legacy-structural-evidence"
+                    / "direct-structural-probe.stdout",
+                    stdout=structural.stdout,
+                    stderr=structural.stderr,
+                )
+        generation_seconds = _timing_seconds(
+            generation_rows,
+            "generation setup",
+        )
+        if generation_seconds is None:
+            raise LegacyAdapterError(
+                "direct all-flow probe did not report generation setup"
+            )
+        if generation_probe is None:
+            raise LegacyAdapterError("direct all-flow probe emitted no value")
+        return self._success_measurement(
+            generation_seconds=generation_seconds,
+            profile=profile,
+            matrix_element=float(generation_probe.value),
+            generation_source="direct-imode2-generation-setup",
+        )
+
+    def _measure_contracted(
+        self,
+        cell: CellSpec,
+        *,
+        context: _ProcessContext,
+        repository: Path,
+        artifact_path: Path,
+        settings: LegacySettings,
+        commands: list[dict[str, object]],
+        log_path: Path,
+        phase_reporter: WorkerPhaseReporter | None,
+    ) -> _ContractedMeasurement:
+        if _quark_line_count(context.source_pdgs) == MAX_OPEN_QUARK_LINES:
+            return _ContractedMeasurement(
+                measurement=self._measure_direct_contracted(
+                    cell,
+                    context=context,
+                    repository=repository,
+                    artifact_path=artifact_path,
+                    settings=settings,
+                    commands=commands,
+                    log_path=log_path,
+                    phase_reporter=phase_reporter,
+                ),
+                imode2_diagnostic=None,
+            )
+        generation_seconds = self._generate_library(
+            context=context,
+            repository=repository,
+            raw_color=True,
+            n_final=cell.n_final,
+            process_key=cell.process_key,
+            settings=settings,
+            commands=commands,
+            log_path=log_path,
+            phase_reporter=phase_reporter,
+        )
+        self._run(
+            (
+                "make",
+                f"-j{settings.jobs}",
+                "amplicol_color_library_probe",
+                "amplicol_color_probe",
+            ),
+            cwd=repository,
+            commands=commands,
+            log_path=log_path,
+        )
+        generated = self.snapshotter.snapshot(
+            repository,
+            artifact_path / "contracted-generated-library",
+            executables=("amplicol_color_library_probe",),
+            process_file=context.process_file,
+        )
+        ordered = self.api.ordered_momenta(
+            context.source_pdgs,
+            context.entry.process_pdgs,
+            context.momenta,
+        )
+        momenta_path = generated / "momenta.dat"
+        momenta_path.write_text(
+            "\n".join(
+                " ".join(format(component, ".17g") for component in vector)
+                for vector in ordered
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        environment = _library_environment(generated)
+        profile = self._profile(
+            lambda count: self._invoke_command(
+                (
+                    "./amplicol_color_library_probe",
+                    str(count),
+                    str(context.entry.group),
+                    str(context.entry.integral),
+                    cell.measurement.accuracy.value,
+                    momenta_path.name,
+                ),
+                cwd=generated,
+                environment=environment,
+                commands=commands,
+                log_path=log_path,
+            ),
+            settings=settings,
+            timing_labels=("total",),
+            phase_reporter=phase_reporter,
+        )
+        if phase_reporter is not None:
+            phase_reporter.validation_started()
+        library_result, _, _ = self._invoke_command(
+            (
+                "./amplicol_color_library_probe",
+                "1",
+                str(context.entry.group),
+                str(context.entry.integral),
+                cell.measurement.accuracy.value,
+                momenta_path.name,
+            ),
+            cwd=generated,
+            environment=environment,
+            commands=commands,
+            log_path=log_path,
+        )
+        library_value = _parse_generated_library_color_probe_output(
+            library_result.stdout + "\n" + library_result.stderr,
+            expected_accuracy=cell.measurement.accuracy.value,
+            expected_group=int(context.entry.group),
+            expected_integral=int(context.entry.integral),
+        )
+        if self.structural_proof:
+            from .legacy_structure import (
+                STRUCTURAL_PROBE_ENVIRONMENT,
+                write_legacy_structural_probe_output,
+            )
+
+            structural, _rows, _probe = self._invoke_command(
+                (
+                    "./amplicol_color_library_probe",
+                    "1",
+                    str(context.entry.group),
+                    str(context.entry.integral),
+                    cell.measurement.accuracy.value,
+                    momenta_path.name,
+                ),
+                cwd=generated,
+                environment={
+                    **environment,
+                    STRUCTURAL_PROBE_ENVIRONMENT: "1",
+                },
+                commands=commands,
+                log_path=log_path,
+            )
+            write_legacy_structural_probe_output(
+                artifact_path
+                / "legacy-structural-evidence"
+                / "contracted-structural-probe.stdout",
+                stdout=structural.stdout,
+                stderr=structural.stderr,
+            )
+        probe_args = (
+            "legacy_amplicol.run_color_probe",
+            cell.measurement.accuracy.value,
+            "points=1",
+        )
+        record_index, probe_started = self._record_api_launch(
+            probe_args,
+            cwd=repository,
+            commands=commands,
+            log_path=log_path,
+            intended_points=1,
+        )
+        probe = self.api.run_color_probe(
+            repository,
+            process_file=context.process_file,
+            entry=context.entry,
+            source_pdgs=context.source_pdgs,
+            momenta=context.momenta,
+            color_accuracy=cell.measurement.accuracy.value,
+            helicities=None,
+        )
+        self._finish_api_launch(
+            record_index,
+            probe_args,
+            cwd=repository,
+            commands=commands,
+            started=probe_started,
+        )
+        raw_direct_value = getattr(probe, "value", None)
+        if (
+            isinstance(raw_direct_value, bool)
+            or not isinstance(raw_direct_value, (int, float))
+            or not math.isfinite(float(raw_direct_value))
+        ):
+            raise LegacyAdapterError(
+                "contracted direct recursive probe emitted no finite value"
+            )
+        direct_value = float(raw_direct_value)
+        return _ContractedMeasurement(
+            measurement=self._success_measurement(
+                generation_seconds=generation_seconds,
+                profile=profile,
+                matrix_element=library_value,
+                generation_source="generated-library-create-raw",
+            ),
+            imode2_diagnostic=_imode2_diagnostic(
+                authoritative_source="dedicated-generated-library-probe",
+                authoritative_value=library_value,
+                imode2_value=direct_value,
+            ),
+        )
+
+    def _measure_direct_contracted(
+        self,
+        cell: CellSpec,
+        *,
+        context: _ProcessContext,
+        repository: Path,
+        artifact_path: Path,
+        settings: LegacySettings,
+        commands: list[dict[str, object]],
+        log_path: Path,
+        phase_reporter: WorkerPhaseReporter | None,
+    ) -> dict[str, object]:
+        """Measure the exact direct path for three independent quark lines."""
+
+        self._run(
+            ("make", f"-j{settings.jobs}", "amplicol_color_probe"),
+            cwd=repository,
+            commands=commands,
+            log_path=log_path,
+        )
+        with tempfile.TemporaryDirectory(prefix="pac-", dir="/tmp") as raw:
+            work = Path(raw)
+            process_copy = work / "processes.txt"
+            momenta_path = work / "momenta.dat"
+            shutil.copy2(context.process_file, process_copy)
+            ordered = self.api.ordered_momenta(
+                context.source_pdgs,
+                context.entry.process_pdgs,
+                context.momenta,
+            )
+            momenta_path.write_text(
+                "\n".join(
+                    " ".join(format(component, ".17g") for component in vector)
+                    for vector in ordered
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+            generation_args = (
+                repository / "amplicol_color_probe",
+                "1",
+                str(context.entry.group),
+                str(context.entry.integral),
+                cell.measurement.accuracy.value,
+                process_copy,
+                momenta_path,
+            )
+            if phase_reporter is not None:
+                _generation_result, generation_rows, generation_probe = (
+                    self._invoke_generation_probe(
+                        generation_args,
+                        phase_reporter=phase_reporter,
+                        cwd=work,
+                        commands=commands,
+                        log_path=log_path,
+                    )
+                )
+            profile = self._profile(
+                lambda count: self._invoke_probe_command(
+                    (
+                        repository / "amplicol_color_probe",
+                        str(count),
+                        str(context.entry.group),
+                        str(context.entry.integral),
+                        cell.measurement.accuracy.value,
+                        process_copy,
+                        momenta_path,
+                    ),
+                    cwd=work,
+                    commands=commands,
+                    log_path=log_path,
+                ),
+                settings=settings,
+                timing_labels=("total",),
+                phase_reporter=phase_reporter,
+            )
+            if phase_reporter is not None:
+                phase_reporter.validation_started()
+            if phase_reporter is None:
+                generation_rows = profile.rows
+                generation_probe = profile.probe
+            if self.structural_proof:
+                from .legacy_structure import (
+                    STRUCTURAL_PROBE_ENVIRONMENT,
+                    write_legacy_structural_probe_output,
+                )
+
+                structural, _rows, _probe = self._invoke_probe_command(
+                    (
+                        repository / "amplicol_color_probe",
+                        "1",
+                        str(context.entry.group),
+                        str(context.entry.integral),
+                        cell.measurement.accuracy.value,
+                        process_copy,
+                        momenta_path,
+                    ),
+                    cwd=work,
+                    commands=commands,
+                    log_path=log_path,
+                    environment={STRUCTURAL_PROBE_ENVIRONMENT: "1"},
+                )
+                write_legacy_structural_probe_output(
+                    artifact_path
+                    / "legacy-structural-evidence"
+                    / "direct-structural-probe.stdout",
+                    stdout=structural.stdout,
+                    stderr=structural.stderr,
+                )
+        generation_seconds = _timing_seconds(
+            generation_rows,
+            "generation setup",
+        )
+        if generation_seconds is None:
+            raise LegacyAdapterError(
+                "direct three-quark-line probe did not report generation setup"
+            )
+        if generation_probe is None:
+            raise LegacyAdapterError("direct three-quark-line probe emitted no value")
+        return self._success_measurement(
+            generation_seconds=generation_seconds,
+            profile=profile,
+            matrix_element=float(generation_probe.value),
+            generation_source="direct-imode2-three-quark-line-setup",
+        )
+
+    def _profile(
+        self,
+        invoke: Any,
+        *,
+        settings: LegacySettings,
+        timing_labels: Sequence[str],
+        phase_reporter: WorkerPhaseReporter | None = None,
+    ) -> ProfileResult:
+        if phase_reporter is not None:
+            phase_reporter.profiling_started()
+        deadlines = tuple(
+            deadline
+            for deadline in (
+                settings.worker_deadline_monotonic,
+                (
+                    None
+                    if settings.profiling_time_limit_seconds is None
+                    else time.monotonic() + settings.profiling_time_limit_seconds
+                ),
+            )
+            if deadline is not None
+        )
+        profiling_deadline = min(deadlines) if deadlines else None
+
+        def require_chunk_budget(estimated_seconds: float | None, points: int) -> None:
+            if profiling_deadline is None:
+                return
+            remaining = profiling_deadline - time.monotonic()
+            if remaining <= 0.0 or (
+                estimated_seconds is not None and estimated_seconds > remaining
+            ):
+                estimate = (
+                    "unknown"
+                    if estimated_seconds is None
+                    else f"{estimated_seconds:.6g}s"
+                )
+                raise ProfilingTimeLimitError(
+                    "profiling stage has insufficient remaining budget for "
+                    f"legacy {points}-point chunk: "
+                    f"remaining={max(remaining, 0.0):.6g}s, estimated={estimate}"
+                )
+        # Calibrate with the smallest valid request.  A fixed 100-point first
+        # call can itself run far beyond the intended stage budget for a large
+        # original-AmpliCol process.
+        calibration_points = 1
+        require_chunk_budget(None, calibration_points)
+        warmup_result, warmup_rows, _warmup_probe = invoke(calibration_points)
+        warmup_seconds = _timing_seconds(warmup_rows, *timing_labels)
+        if warmup_seconds is None or warmup_seconds <= 0.0:
+            warmup_seconds = warmup_result.elapsed_seconds
+        chunks: list[_ProfileChunk] = []
+        phase = "measurement_chunks"
+        points = adaptive_profile_points(
+            warmup_seconds,
+            target_runtime_seconds=(
+                settings.target_runtime_seconds / settings.minimum_profile_chunks
+            ),
+            warmup_points=calibration_points,
+            minimum_points=settings.minimum_points,
+            maximum_points=settings.maximum_points,
+        )
+        measured_seconds = 0.0
+        estimated_seconds = warmup_seconds * points / calibration_points
+        for _index in range(settings.maximum_profile_chunks):
+            require_chunk_budget(estimated_seconds, points)
+            result, rows, probe = invoke(points)
+            seconds = _timing_seconds(rows, *timing_labels)
+            if seconds is None or seconds <= 0.0:
+                seconds = result.elapsed_seconds
+            if not math.isfinite(seconds) or seconds <= 0.0:
+                raise LegacyAdapterError(
+                    "legacy timing chunk did not report a positive duration"
+                )
+            chunks.append(
+                _ProfileChunk(
+                    points,
+                    seconds,
+                    tuple(rows),
+                    result,
+                    probe,
+                )
+            )
+            measured_seconds = math.fsum(chunk.seconds for chunk in chunks)
+            minimum_complete = len(chunks) >= settings.minimum_profile_chunks
+            target_complete = measured_seconds >= settings.target_runtime_seconds
+            standard_error, relative_standard_error = _profile_rate_uncertainty(chunks)
+            uncertainty_complete = (
+                settings.minimum_profile_chunks == 1
+                or (
+                    math.isfinite(standard_error)
+                    and standard_error > 0.0
+                    and math.isfinite(relative_standard_error)
+                    and relative_standard_error > 0.0
+                )
+            )
+            if minimum_complete and target_complete and uncertainty_complete:
+                break
+            remaining = max(
+                settings.target_runtime_seconds - measured_seconds,
+                0.0,
+            )
+            remaining_minimum_chunks = max(
+                settings.minimum_profile_chunks - len(chunks),
+                1,
+            )
+            next_chunk_target = remaining / remaining_minimum_chunks
+            estimated = math.ceil(next_chunk_target * points / seconds)
+            points = max(
+                settings.minimum_points,
+                min(settings.maximum_points, int(estimated)),
+            )
+            estimated_seconds = seconds * points / chunks[-1].points
+        else:
+            raise LegacyAdapterError(
+                "legacy timing did not reach its target, minimum sample "
+                "count, and positive measured uncertainty within "
+                f"{settings.maximum_profile_chunks} bounded chunks"
+            )
+
+        points = sum(chunk.points for chunk in chunks)
+        seconds = math.fsum(chunk.seconds for chunk in chunks)
+        if seconds < settings.target_runtime_seconds:
+            raise LegacyAdapterError(
+                "legacy timing completed without reaching its target runtime"
+            )
+        standard_error, relative_standard_error = _profile_rate_uncertainty(chunks)
+        representative = chunks[0]
+        final = chunks[-1]
+        return ProfileResult(
+            points=points,
+            seconds=seconds,
+            rows=representative.rows,
+            record={
+                **final.result.as_record(),
+                "profile_phase": phase,
+                "target_runtime_seconds": settings.target_runtime_seconds,
+                "achieved_runtime_seconds": seconds,
+                "target_runtime_achieved": True,
+                "chunk_count": len(chunks),
+                "total_points": points,
+                "chunks": [
+                    {
+                        **chunk.result.as_record(),
+                        "points": chunk.points,
+                        "profile_seconds": chunk.seconds,
+                    }
+                    for chunk in chunks
+                ],
+            },
+            probe=final.probe,
+            warmup_record=warmup_result.as_record(),
+            standard_error_seconds_per_point=standard_error,
+            relative_standard_error=relative_standard_error,
+        )
+
+    def _invoke_command(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+        commands: list[dict[str, object]],
+        log_path: Path,
+        environment: Mapping[str, str] | None = None,
+    ) -> tuple[CommandResult, tuple[TimingRow, ...], None]:
+        result = self._run(
+            args,
+            cwd=cwd,
+            environment=environment,
+            commands=commands,
+            log_path=log_path,
+        )
+        return result, _timing_rows(result.stdout + "\n" + result.stderr), None
+
+    def _invoke_probe_command(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+        commands: list[dict[str, object]],
+        log_path: Path,
+        environment: Mapping[str, str] | None = None,
+    ) -> tuple[CommandResult, tuple[TimingRow, ...], object]:
+        result = self._run(
+            args,
+            cwd=cwd,
+            environment=environment,
+            commands=commands,
+            log_path=log_path,
+        )
+        output = result.stdout + "\n" + result.stderr
+        return result, _timing_rows(output), self.api.parse_probe_output(output)
+
+    def _invoke_generation_probe(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        phase_reporter: WorkerPhaseReporter | None,
+        cwd: Path,
+        commands: list[dict[str, object]],
+        log_path: Path,
+    ) -> tuple[CommandResult, tuple[TimingRow, ...], object]:
+        """Run one direct generation setup inside the authenticated phase.
+
+        Direct original-AmpliCol probes combine their setup and a single
+        evaluation in one process.  A dedicated one-point invocation gives the
+        supervisor one bounded generation interval, while the subsequent
+        adaptive runtime profile remains strictly post-generation.
+        """
+
+        generation_context = (
+            nullcontext() if phase_reporter is None else phase_reporter.generation()
+        )
+        with generation_context:
+            return self._invoke_probe_command(
+                args,
+                cwd=cwd,
+                commands=commands,
+                log_path=log_path,
+            )
+
+    def _run(
+        self,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+        commands: list[dict[str, object]],
+        log_path: Path,
+        environment: Mapping[str, str] | None = None,
+    ) -> CommandResult:
+        rendered = tuple(os.fspath(item) for item in args)
+        if rendered and rendered[0] == "make":
+            environment = {
+                **({} if environment is None else dict(environment)),
+                **_ORIGINAL_AMPLICOL_BUILD_ENVIRONMENT,
+            }
+        launch_record: dict[str, object] = {
+            "args": list(rendered),
+            "cwd": os.fspath(cwd.resolve(strict=False)),
+            "environment": {} if environment is None else dict(environment),
+            "status": "launching",
+        }
+        try:
+            intended_points = int(rendered[1])
+        except (IndexError, ValueError):
+            intended_points = None
+        if intended_points is not None and intended_points > 0:
+            launch_record["intended_points"] = intended_points
+        record_index = len(commands)
+        commands.append(launch_record)
+        with log_path.open("a", encoding="utf-8") as stream:
+            stream.write(f"$ {' '.join(rendered)}\n")
+            if intended_points is not None and intended_points > 0:
+                stream.write(f"[launch] intended_points={intended_points}\n")
+            stream.flush()
+        result = self.executor.run(rendered, cwd=cwd, environment=environment)
+        commands[record_index] = result.as_record()
+        with log_path.open("a", encoding="utf-8") as stream:
+            stream.write(result.stdout)
+            if result.stdout and not result.stdout.endswith("\n"):
+                stream.write("\n")
+            stream.write(result.stderr)
+            if result.stderr and not result.stderr.endswith("\n"):
+                stream.write("\n")
+        return result
+
+    @staticmethod
+    def _record_api_launch(
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+        commands: list[dict[str, object]],
+        log_path: Path,
+        intended_points: int,
+    ) -> tuple[int, float]:
+        rendered = tuple(os.fspath(item) for item in args)
+        record_index = len(commands)
+        commands.append(
+            {
+                "args": list(rendered),
+                "cwd": os.fspath(cwd.resolve(strict=False)),
+                "intended_points": intended_points,
+                "status": "launching",
+            }
+        )
+        with log_path.open("a", encoding="utf-8") as stream:
+            stream.write(f"$ {' '.join(rendered)}\n")
+            stream.write(f"[launch] intended_points={intended_points}\n")
+            stream.flush()
+        return record_index, time.perf_counter()
+
+    @staticmethod
+    def _finish_api_launch(
+        record_index: int,
+        args: Sequence[str | os.PathLike[str]],
+        *,
+        cwd: Path,
+        commands: list[dict[str, object]],
+        started: float,
+    ) -> None:
+        commands[record_index] = {
+            "args": [os.fspath(item) for item in args],
+            "cwd": os.fspath(cwd.resolve(strict=False)),
+            "elapsed_seconds": time.perf_counter() - started,
+            "returncode": 0,
+        }
+
+    @staticmethod
+    def _success_measurement(
+        *,
+        generation_seconds: float,
+        profile: ProfileResult,
+        matrix_element: float,
+        generation_source: str,
+    ) -> dict[str, object]:
+        measurement = empty_measurement()
+        measurement.update(
+            {
+                "status": ResultStatus.OK.value,
+                "generation_seconds": float(generation_seconds),
+                "wall_seconds_per_point": profile.seconds / profile.points,
+                "execution_seconds_per_point": profile.seconds / profile.points,
+                "matrix_element": abs(float(matrix_element)),
+                "sample_count": profile.points,
+                "standard_error_seconds_per_point": (
+                    profile.standard_error_seconds_per_point
+                ),
+                "relative_standard_error": profile.relative_standard_error,
+                "provenance": {
+                    "generation_source": generation_source,
+                    "runtime_profile": {
+                        "measurement": dict(profile.record),
+                        "warmup": dict(profile.warmup_record),
+                        "timing_rows": [
+                            {"label": row.label, "seconds": row.seconds}
+                            for row in profile.rows
+                        ],
+                    },
+                },
+            }
+        )
+        return measurement
+
+    @staticmethod
+    def _unsupported_measurement(message: str) -> dict[str, object]:
+        measurement = empty_measurement()
+        measurement.update(
+            {
+                "status": ResultStatus.UNSUPPORTED.value,
+                "failure": {
+                    "kind": "LegacyOracleScopeError",
+                    "message": message,
+                },
+            }
+        )
+        return measurement
+
+
+@contextmanager
+def _temporary_environment(values: Mapping[str, str]):
+    saved = {key: os.environ.get(key) for key in values}
+    os.environ.update(values)
+    try:
+        yield
+    finally:
+        for key, value in saved.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+
+
+def measurement_digest(measurement: Mapping[str, object]) -> str:
+    """Stable helper used when linking a legacy reference from another cache."""
+
+    payload = json.dumps(
+        measurement,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(payload).hexdigest()
+
+
+__all__ = [
+    "CommandExecutor",
+    "CommandResult",
+    "LegacyAdapterError",
+    "LegacyMeasurementAdapter",
+    "LegacySettings",
+    "MaintainedLegacyApi",
+    "SubprocessExecutor",
+    "adaptive_profile_points",
+    "measurement_digest",
+]
diff --git a/pyamplicol/tools/performance_report/legacy_structure.py b/pyamplicol/tools/performance_report/legacy_structure.py
new file mode 100644
index 0000000000..c044e141d5
--- /dev/null
+++ b/pyamplicol/tools/performance_report/legacy_structure.py
@@ -0,0 +1,1106 @@
+# SPDX-License-Identifier: 0BSD
+"""Authenticated structural evidence for original-AmpliCol measurements.
+
+The performance campaign times an unmodified physics path.  Structural
+evidence is collected separately:
+
+* generated libraries are parsed from their persisted ``amp*_lib.f03`` files;
+* direct imode-2 and contracted-library probes execute one additional point
+  with diagnostic-only Fortran output enabled.
+
+The pinned legacy checkout may be shared by manually steered cells.  This
+module serializes its temporary instrumentation per checkout, adds diagnostics
+to the two probe sources, snapshots the exact instrumented sources, and
+restores the checkout byte-for-byte after the attempt.  The diagnostics do not
+alter generation, evaluation, filtering, or contraction.  No structural count
+is inferred from timing or filled with a fallback value.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import tempfile
+from collections import Counter
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+
+from .artifacts import _filesystem_lock
+from .models import CellSpec, Workload
+
+LEGACY_PROOF_SCHEMA = "pyamplicol-legacy-final-structural-proof-v1"
+LEGACY_SCOPE_REASON = "original-amplicol-open-quark-line-limit"
+STRUCTURAL_PROBE_ENVIRONMENT = "AMPICOL_STRUCTURAL_PROBE"
+_EVIDENCE_DIRECTORY = "legacy-structural-evidence"
+_INDEX_SCHEMA = "pyamplicol-legacy-structural-index-v1"
+_SOURCE_CONTRACT_SCHEMA = "pyamplicol-legacy-structural-source-contract-v1"
+_INSTRUMENTATION_ABI = "pyamplicol-legacy-probe-structural-diagnostics-v1"
+_MAPPING_ABI = "pyamplicol-legacy-structural-object-mapping-v1"
+_LOCK_DIRECTORY = "pyamplicol-performance-report-locks"
+
+_MODULE_NAME = re.compile(r"amp(\d+)_(\d+)_lib\.f03$")
+_MODULE_CURRENT = re.compile(
+    r"dimension\s*\(\s*1\s*:\s*\d+\s*,\s*(\d+)\s*\)\s*::\s*val_c\b",
+    re.IGNORECASE,
+)
+_MODULE_INTERACTION = re.compile(
+    r"dimension\s*\(\s*1\s*:\s*\d+\s*,\s*(\d+)\s*\)\s*::\s*int_c\b",
+    re.IGNORECASE,
+)
+_MODULE_AMPLITUDE = re.compile(
+    r"complex\s*\(\s*kind\s*=\s*8\s*\)\s*,\s*dimension\s*\(\s*(\d+)\s*\)"
+    r"\s*,\s*intent\s*\(\s*out\s*\)\s*::\s*amps\b",
+    re.IGNORECASE,
+)
+_SUBROUTINE = re.compile(
+    r"^\s*subroutine\s+(\w+)\b(.*?)^\s*end\s+subroutine\s+\1\b",
+    re.IGNORECASE | re.MULTILINE | re.DOTALL,
+)
+_EXTERNAL_CURRENT = re.compile(
+    r"call\s+ext_\w+\s*\(.*?val_c\s*\(\s*1\s*,\s*(\d+)\s*\).*?\)",
+    re.IGNORECASE | re.DOTALL,
+)
+_INT1_ARRAY = re.compile(
+    r"integer\s*,\s*parameter\s*,\s*dimension\s*\(([^)]*)\)\s*::\s*"
+    r"int1\s*=\s*(?:reshape\s*\(\s*)?\[\s*&?(.*?)\]"
+    r"(?:\s*,\s*shape\s*=\s*\[[^]]*\]\s*\))?",
+    re.IGNORECASE | re.DOTALL,
+)
+_COMBINE_SHAPE = re.compile(r"0:(\d+),(\d+)")
+_AMPLITUDE_ASSIGNMENT = re.compile(
+    r"amps\s*\(\s*(\d+)\s*\)\s*=\s*sum\s*\(\s*"
+    r"val_c\s*\([^,]+,\s*(\d+)\s*\)\s*\*\s*"
+    r"val_c\s*\([^,]+,\s*(\d+)\s*\)\s*\)",
+    re.IGNORECASE,
+)
+_PROCESS_ROW = re.compile(r"group:(\d+):integral:(\d+)")
+
+_DIRECT_CURRENT = re.compile(
+    r"^AMPICOL_STRUCTURAL_CURRENT\s+"
+    r"(\d+)\s+([01])\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)\s*$",
+    re.MULTILINE,
+)
+_DIRECT_KERNEL = re.compile(
+    r"^AMPICOL_STRUCTURAL_KERNEL\s+"
+    r"(\d+)\s+(-?\d+)\s+(-?\d+)\s+(\d+)\s+(\d+)\s+"
+    r"(\S+)\s+(\S+)\s*$",
+    re.MULTILINE,
+)
+_DIRECT_SINGLET = re.compile(
+    r"^AMPICOL_STRUCTURAL_KERNEL_SINGLET\s+(\d+)\s+(.*?)\s*$",
+    re.MULTILINE,
+)
+_DIRECT_ATTACHMENT = re.compile(
+    r"^AMPICOL_STRUCTURAL_ATTACHMENT\s+"
+    r"(\d+)\s+(\d+)\s+(\d+)\s+(-?1)\s*$",
+    re.MULTILINE,
+)
+_DIRECT_DESTINATION = re.compile(
+    r"^AMPICOL_STRUCTURAL_DESTINATION\s+"
+    r"(\d+)\s+(\d+)\s+(\d+)\s*$",
+    re.MULTILINE,
+)
+_DIRECT_SUMMARY = {
+    "current": re.compile(r"^AMPICOL_COLOR_PROBE_CURRENTS\s+(\d+)\s*$", re.M),
+    "kernel": re.compile(r"^AMPICOL_COLOR_PROBE_VERTICES\s+(\d+)\s*$", re.M),
+    "destination": re.compile(
+        r"^AMPICOL_COLOR_PROBE_AMPLITUDES\s+(\d+)\s*$", re.M
+    ),
+    "accuracy": re.compile(r"^color_accuracy\s+(\S+)\s*$", re.M),
+}
+_LIBRARY_CALL = re.compile(
+    r"^AMPICOL_COLOR_PROBE_LIBRARY_CALLS\s+(\d+)\s+(\d+)\s+(\d+)\s*$",
+    re.MULTILINE,
+)
+_LIBRARY_ROW = re.compile(
+    r"^AMPICOL_COLOR_PROBE_LIBRARY_ROW\s+"
+    r"(\d+)\s+(\d+)\s+(\d+)\s+(-?1)\s*$",
+    re.MULTILINE,
+)
+
+
+class LegacyStructuralProofError(RuntimeError):
+    """The real legacy generation/probe evidence is absent or inconsistent."""
+
+
+@dataclass(frozen=True, slots=True)
+class InstrumentationRecord:
+    """Exact source identities for one temporary diagnostic installation."""
+
+    abi: str
+    sources: tuple[Mapping[str, str], ...]
+    evidence_paths: tuple[Path, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _ModuleStructure:
+    path: Path
+    group: int
+    integral: int
+    declared_current_count: int
+    declared_kernel_count: int
+    source_current_ids: tuple[int, ...]
+    produced_current_ids: tuple[int, ...]
+    kernel_term_ids: tuple[int, ...]
+    combine_routes: tuple[tuple[int, tuple[int, ...]], ...]
+    amplitude_destinations: tuple[tuple[int, int, int], ...]
+
+    @property
+    def counts(self) -> dict[str, int]:
+        return {
+            "source_current_count": len(self.source_current_ids),
+            "produced_current_count": len(self.produced_current_ids),
+            "kernel_evaluation_count": len(self.kernel_term_ids),
+            "attachment_count": sum(
+                len(kernel_ids) for _current, kernel_ids in self.combine_routes
+            ),
+            "amplitude_destination_count": len(self.amplitude_destinations),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class _DirectStructure:
+    accuracy: str
+    current_map: tuple[tuple[int, int, int, int, int], ...]
+    kernel_map: tuple[tuple[int, int, int, int, int, str, str], ...]
+    singlet_map: tuple[tuple[int, tuple[int, ...]], ...]
+    attachment_map: tuple[tuple[int, int, int, int], ...]
+    destination_map: tuple[tuple[int, int, int], ...]
+
+    @property
+    def counts(self) -> dict[str, int]:
+        return {
+            "source_current_count": sum(row[1] for row in self.current_map),
+            "produced_current_count": sum(1 - row[1] for row in self.current_map),
+            "kernel_evaluation_count": len(self.kernel_map),
+            "attachment_count": len(self.attachment_map),
+            "amplitude_destination_count": len(self.destination_map),
+        }
+
+
+def _sha256_bytes(payload: bytes) -> str:
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _canonical_bytes(value: object) -> bytes:
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+def _canonical_sha256(value: object) -> str:
+    return _sha256_bytes(_canonical_bytes(value))
+
+
+def _atomic_write(path: Path, payload: bytes) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, raw = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+    temporary = Path(raw)
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            stream.write(payload)
+            stream.flush()
+            os.fsync(stream.fileno())
+        temporary.replace(path)
+    except BaseException:
+        temporary.unlink(missing_ok=True)
+        raise
+
+
+def _atomic_json(path: Path, value: object) -> None:
+    _atomic_write(
+        path,
+        json.dumps(value, indent=2, sort_keys=True).encode("utf-8") + b"\n",
+    )
+
+
+def _replace_once(text: str, old: str, new: str, *, label: str) -> str:
+    if text.count(old) != 1:
+        raise LegacyStructuralProofError(
+            f"legacy probe instrumentation anchor {label!r} occurs "
+            f"{text.count(old)} times, expected exactly once"
+        )
+    return text.replace(old, new, 1)
+
+
+_DIRECT_SUBROUTINE = r"""
+  subroutine print_structural_proof()
+    implicit none
+    integer :: current_id, kernel_id, route_index, destination_id
+    integer :: source_flag, route_sign
+    do current_id=1,amp%n_cur
+       source_flag = 0
+       if (popcnt(amp%current_list(current_id)%bin).eq.1) source_flag = 1
+       write (*,'(a,5(1x,i0))') 'AMPICOL_STRUCTURAL_CURRENT',&
+            current_id,source_flag,amp%current_list(current_id)%type,&
+            amp%current_list(current_id)%chirality,&
+            amp%current_list(current_id)%bin
+       do route_index=1,amp%current_list(current_id)%n_vert
+          route_sign = 1
+          if (amp%current_list(current_id)%vertex_sign(route_index)) route_sign = -1
+          write (*,'(a,4(1x,i0))') 'AMPICOL_STRUCTURAL_ATTACHMENT',&
+               current_id,route_index,&
+               amp%current_list(current_id)%vertices(route_index),route_sign
+       enddo
+    enddo
+    do kernel_id=1,amp%n_vert
+       write (*,'(a,5(1x,i0),2(1x,es24.16))') 'AMPICOL_STRUCTURAL_KERNEL',&
+            kernel_id,amp%interaction_list(kernel_id)%type,&
+            amp%interaction_list(kernel_id)%chirality,&
+            amp%interaction_list(kernel_id)%currents(1),&
+            amp%interaction_list(kernel_id)%currents(2),&
+            amp%interaction_list(kernel_id)%coupl(1),&
+            amp%interaction_list(kernel_id)%coupl(2)
+       if (allocated(amp%interaction_list(kernel_id)%singlet_mv)) then
+          write (*,'(a,1x,i0,1x,*(i0,1x))')&
+               'AMPICOL_STRUCTURAL_KERNEL_SINGLET',kernel_id,&
+               amp%interaction_list(kernel_id)%singlet_mv(&
+               0:amp%interaction_list(kernel_id)%singlet_mv(0))
+       else
+          write (*,'(a,2(1x,i0))')&
+               'AMPICOL_STRUCTURAL_KERNEL_SINGLET',kernel_id,0
+       endif
+    enddo
+    do destination_id=1,amp%n_amps
+       write (*,'(a,3(1x,i0))') 'AMPICOL_STRUCTURAL_DESTINATION',&
+            destination_id,amp%curr2amp(1,destination_id),&
+            amp%curr2amp(2,destination_id)
+    enddo
+  end subroutine print_structural_proof
+
+"""
+
+
+_LIBRARY_SUBROUTINE = r"""
+  subroutine print_library_call_histogram()
+    implicit none
+    integer :: row, previous, call_count
+    logical :: first_occurrence
+    do row=1,colour_amp%nColOrd
+       first_occurrence = .true.
+       do previous=1,row-1
+          if (row_to_group(previous).eq.row_to_group(row) .and.&
+               row_to_integral(previous).eq.row_to_integral(row)) then
+             first_occurrence = .false.
+             exit
+          endif
+       enddo
+       if (.not.first_occurrence) cycle
+       call_count = count(row_to_group.eq.row_to_group(row) .and.&
+            row_to_integral.eq.row_to_integral(row))
+       write (*,'(a,3(1x,i0))') 'AMPICOL_COLOR_PROBE_LIBRARY_CALLS',&
+            row_to_group(row),row_to_integral(row),call_count
+       write (99,'(a,3(1x,i0))') 'AMPICOL_COLOR_PROBE_LIBRARY_CALLS',&
+            row_to_group(row),row_to_integral(row),call_count
+    enddo
+    do row=1,colour_amp%nColOrd
+       write (*,'(a,4(1x,i0))') 'AMPICOL_COLOR_PROBE_LIBRARY_ROW',&
+            row,row_to_group(row),row_to_integral(row),row_sign(row)
+       write (99,'(a,4(1x,i0))') 'AMPICOL_COLOR_PROBE_LIBRARY_ROW',&
+            row,row_to_group(row),row_to_integral(row),row_sign(row)
+    enddo
+  end subroutine print_library_call_histogram
+
+"""
+
+
+def _instrument_direct_source(text: str) -> str:
+    if "subroutine print_structural_proof()" in text:
+        raise LegacyStructuralProofError("direct probe is already instrumented")
+    text = _replace_once(
+        text,
+        "  logical :: print_matrix, fixed_helicity\n",
+        "  logical :: print_matrix, fixed_helicity, print_structure\n",
+        label="direct logical declaration",
+    )
+    text = _replace_once(
+        text,
+        "  print_matrix = .false.\n  fixed_helicity = .false.\n",
+        "  print_matrix = .false.\n"
+        "  fixed_helicity = .false.\n"
+        "  print_structure = .false.\n",
+        label="direct logical initialization",
+    )
+    text = _replace_once(
+        text,
+        "  if (trim(adjustl(env_value)).eq.'1') print_matrix = .true.\n"
+        "  env_value = ''\n",
+        "  if (trim(adjustl(env_value)).eq.'1') print_matrix = .true.\n"
+        "  env_value = ''\n"
+        "  call get_environment_variable('AMPICOL_STRUCTURAL_PROBE',env_value)\n"
+        "  if (trim(adjustl(env_value)).eq.'1') print_structure = .true.\n"
+        "  env_value = ''\n",
+        label="direct structural environment",
+    )
+    text = _replace_once(
+        text,
+        "  call print_recursion_counts()\n",
+        "  call print_recursion_counts()\n"
+        "  if (print_structure) call print_structural_proof()\n",
+        label="direct structural call",
+    )
+    return _replace_once(
+        text,
+        "  subroutine parse_color_accuracy()\n",
+        _DIRECT_SUBROUTINE + "  subroutine parse_color_accuracy()\n",
+        label="direct structural subroutine",
+    )
+
+
+def _instrument_library_source(text: str) -> str:
+    if "subroutine print_library_call_histogram()" in text:
+        raise LegacyStructuralProofError("library probe is already instrumented")
+    text = _replace_once(
+        text,
+        "  logical :: print_matrix\n",
+        "  logical :: print_matrix, print_structure\n",
+        label="library logical declaration",
+    )
+    text = _replace_once(
+        text,
+        "  print_matrix = .false.\n"
+        "  call get_environment_variable('AMPICOL_COLOR_PROBE_MATRIX',env_value)\n",
+        "  print_matrix = .false.\n"
+        "  print_structure = .false.\n"
+        "  call get_environment_variable('AMPICOL_COLOR_PROBE_MATRIX',env_value)\n",
+        label="library logical initialization",
+    )
+    text = _replace_once(
+        text,
+        "  if (trim(adjustl(env_value)).eq.'1') print_matrix = .true.\n\n"
+        "  argc = command_argument_count()\n",
+        "  if (trim(adjustl(env_value)).eq.'1') print_matrix = .true.\n"
+        "  env_value = ''\n"
+        "  call get_environment_variable('AMPICOL_STRUCTURAL_PROBE',env_value)\n"
+        "  if (trim(adjustl(env_value)).eq.'1') print_structure = .true.\n\n"
+        "  argc = command_argument_count()\n",
+        label="library structural environment",
+    )
+    text = _replace_once(
+        text,
+        "  call build_row_to_integral()\n",
+        "  call build_row_to_integral()\n"
+        "  if (print_structure) call print_library_call_histogram()\n",
+        label="library structural call",
+    )
+    return _replace_once(
+        text,
+        "  integer function colour_order_match_sign(jgroup,jint,row,pass,leg_map)\n",
+        _LIBRARY_SUBROUTINE
+        + "  integer function colour_order_match_sign(jgroup,jint,row,pass,leg_map)\n",
+        label="library structural subroutine",
+    )
+
+
+def _legacy_structural_probe_lock_path(repository: Path) -> Path:
+    resolved = repository.expanduser().resolve(strict=False)
+    repository_id = hashlib.sha256(os.fsencode(resolved)).hexdigest()
+    return (
+        Path(tempfile.gettempdir())
+        / f"{_LOCK_DIRECTORY}-{os.getuid()}"
+        / f"{repository_id}.lock"
+    )
+
+
+@contextmanager
+def legacy_structural_probe_lock(repository: Path) -> Iterator[None]:
+    """Serialize temporary probe-source edits for one shared legacy checkout."""
+
+    with _filesystem_lock(
+        _legacy_structural_probe_lock_path(repository),
+        timeout=None,
+        poll_interval=0.05,
+    ):
+        yield
+
+
+@contextmanager
+def instrument_legacy_structural_probes(
+    repository: Path,
+    artifact_path: Path,
+) -> Iterator[InstrumentationRecord]:
+    """Install diagnostic-only probe output and restore exact source bytes."""
+
+    with (
+        legacy_structural_probe_lock(repository),
+        _instrument_legacy_structural_probes(
+            repository,
+            artifact_path,
+        ) as instrumentation,
+    ):
+        yield instrumentation
+
+
+@contextmanager
+def _instrument_legacy_structural_probes(
+    repository: Path,
+    artifact_path: Path,
+) -> Iterator[InstrumentationRecord]:
+    evidence_root = artifact_path / _EVIDENCE_DIRECTORY
+    transformers = {
+        "amplicol_color_probe.f03": _instrument_direct_source,
+        "amplicol_color_library_probe.f03": _instrument_library_source,
+    }
+    originals: dict[Path, tuple[bytes, os.stat_result]] = {}
+    records: list[Mapping[str, str]] = []
+    evidence_paths: list[Path] = []
+    try:
+        for name, transform in transformers.items():
+            source = repository / name
+            if not source.is_file():
+                raise LegacyStructuralProofError(
+                    f"pinned legacy probe source is absent: {source}"
+                )
+            original = source.read_bytes()
+            stat = source.stat()
+            originals[source] = (original, stat)
+            try:
+                patched = transform(original.decode("utf-8")).encode("utf-8")
+            except UnicodeDecodeError as error:
+                raise LegacyStructuralProofError(
+                    f"legacy probe source is not UTF-8: {source}"
+                ) from error
+            snapshot = evidence_root / f"instrumented-{name}"
+            _atomic_write(snapshot, patched)
+            _atomic_write(source, patched)
+            os.chmod(source, stat.st_mode)
+            records.append(
+                {
+                    "path": name,
+                    "original_sha256": _sha256_bytes(original),
+                    "instrumented_sha256": _sha256_bytes(patched),
+                    "instrumented_evidence_path": snapshot.relative_to(
+                        artifact_path
+                    ).as_posix(),
+                }
+            )
+            evidence_paths.append(snapshot)
+        yield InstrumentationRecord(
+            abi=_INSTRUMENTATION_ABI,
+            sources=tuple(records),
+            evidence_paths=tuple(evidence_paths),
+        )
+    finally:
+        for source, (payload, stat) in originals.items():
+            _atomic_write(source, payload)
+            os.chmod(source, stat.st_mode)
+            os.utime(source, ns=(stat.st_atime_ns, stat.st_mtime_ns))
+
+
+def _required_match(pattern: re.Pattern[str], text: str, label: str) -> re.Match[str]:
+    match = pattern.search(text)
+    if match is None:
+        raise LegacyStructuralProofError(f"legacy structural evidence lacks {label}")
+    return match
+
+
+def _parse_module(path: Path) -> _ModuleStructure:
+    name = _MODULE_NAME.fullmatch(path.name)
+    if name is None:
+        raise LegacyStructuralProofError(f"invalid generated module name: {path}")
+    text = path.read_text(encoding="utf-8")
+    declared_current_count = int(
+        _required_match(_MODULE_CURRENT, text, "module current dimension").group(1)
+    )
+    declared_kernel_count = int(
+        _required_match(_MODULE_INTERACTION, text, "module kernel dimension").group(1)
+    )
+    source_ids = {int(value) for value in _EXTERNAL_CURRENT.findall(text)}
+    produced_ids: set[int] = set()
+    kernel_ids: set[int] = set()
+    referenced_kernel_ids: set[int] = set()
+    routes: list[tuple[int, tuple[int, ...]]] = []
+    for match in _SUBROUTINE.finditer(text):
+        routine = match.group(1).lower()
+        array = _INT1_ARRAY.search(match.group(2))
+        if array is None:
+            continue
+        values = [int(value) for value in re.findall(r"\d+", array.group(2))]
+        if routine.startswith("vertex_"):
+            kernel_ids.update(values)
+            continue
+        if not routine.startswith("combine_currents"):
+            continue
+        shape = _COMBINE_SHAPE.fullmatch(array.group(1).replace(" ", ""))
+        if shape is None:
+            raise LegacyStructuralProofError(
+                f"unsupported combine-route shape in {path}"
+            )
+        stride = int(shape.group(1)) + 1
+        column_count = int(shape.group(2))
+        if len(values) != stride * column_count:
+            raise LegacyStructuralProofError(
+                f"combine-route payload has the wrong size in {path}"
+            )
+        for start in range(0, len(values), stride):
+            current = values[start]
+            contributions = tuple(values[start + 1 : start + stride])
+            produced_ids.add(current)
+            referenced_kernel_ids.update(contributions)
+            routes.append((current, contributions))
+    destinations = tuple(
+        (int(index), int(left), int(right))
+        for index, left, right in _AMPLITUDE_ASSIGNMENT.findall(text)
+    )
+    amplitude_count = int(
+        _required_match(_MODULE_AMPLITUDE, text, "module amplitude dimension").group(
+            1
+        )
+    )
+    expected_currents = set(range(1, declared_current_count + 1))
+    expected_kernels = set(range(1, declared_kernel_count + 1))
+    if (
+        source_ids & produced_ids
+        or source_ids | produced_ids != expected_currents
+        or kernel_ids != expected_kernels
+        or referenced_kernel_ids != expected_kernels
+        or [item[0] for item in destinations] != list(range(1, amplitude_count + 1))
+        or any(
+            left not in expected_currents or right not in expected_currents
+            for _index, left, right in destinations
+        )
+    ):
+        raise LegacyStructuralProofError(
+            f"generated module has sparse/dangling structural objects: {path}"
+        )
+    return _ModuleStructure(
+        path=path,
+        group=int(name.group(1)),
+        integral=int(name.group(2)),
+        declared_current_count=declared_current_count,
+        declared_kernel_count=declared_kernel_count,
+        source_current_ids=tuple(sorted(source_ids)),
+        produced_current_ids=tuple(sorted(produced_ids)),
+        kernel_term_ids=tuple(sorted(kernel_ids)),
+        combine_routes=tuple(routes),
+        amplitude_destinations=destinations,
+    )
+
+
+def _parse_direct(path: Path, expected_accuracy: str) -> _DirectStructure:
+    text = path.read_text(encoding="utf-8")
+    current_map = tuple(
+        tuple(int(value) for value in match)
+        for match in _DIRECT_CURRENT.findall(text)
+    )
+    kernel_map = tuple(
+        (
+            int(identifier),
+            int(kind),
+            int(chirality),
+            int(left),
+            int(right),
+            coupling_left,
+            coupling_right,
+        )
+        for (
+            identifier,
+            kind,
+            chirality,
+            left,
+            right,
+            coupling_left,
+            coupling_right,
+        ) in _DIRECT_KERNEL.findall(text)
+    )
+    singlet_map = tuple(
+        (
+            int(identifier),
+            tuple(int(value) for value in values.split()),
+        )
+        for identifier, values in _DIRECT_SINGLET.findall(text)
+    )
+    attachment_map = tuple(
+        tuple(int(value) for value in match)
+        for match in _DIRECT_ATTACHMENT.findall(text)
+    )
+    destination_map = tuple(
+        tuple(int(value) for value in match)
+        for match in _DIRECT_DESTINATION.findall(text)
+    )
+    counts = {
+        label: int(_required_match(pattern, text, label).group(1))
+        for label, pattern in _DIRECT_SUMMARY.items()
+        if label != "accuracy"
+    }
+    accuracy = _required_match(
+        _DIRECT_SUMMARY["accuracy"], text, "color accuracy"
+    ).group(1)
+    if accuracy != expected_accuracy:
+        raise LegacyStructuralProofError(
+            f"direct structural probe accuracy is {accuracy}, "
+            f"expected {expected_accuracy}"
+        )
+    current_ids = [row[0] for row in current_map]
+    kernel_ids = [row[0] for row in kernel_map]
+    singlet_ids = [row[0] for row in singlet_map]
+    destination_ids = [row[0] for row in destination_map]
+    current_id_set = set(current_ids)
+    kernel_id_set = set(kernel_ids)
+    if (
+        current_ids != list(range(1, counts["current"] + 1))
+        or kernel_ids != list(range(1, counts["kernel"] + 1))
+        or singlet_ids != kernel_ids
+        or destination_ids != list(range(1, counts["destination"] + 1))
+        or any(
+            left not in current_id_set or right not in current_id_set
+            for _identifier, _kind, _chirality, left, right, _coupling_a, _coupling_b
+            in kernel_map
+        )
+        or any(
+            current not in current_id_set
+            or kernel not in kernel_id_set
+            or position < 1
+            for current, position, kernel, _sign in attachment_map
+        )
+        or any(
+            left not in current_id_set or right not in current_id_set
+            for _destination, left, right in destination_map
+        )
+        or set(range(1, counts["kernel"] + 1))
+        != {row[2] for row in attachment_map}
+    ):
+        raise LegacyStructuralProofError(
+            f"direct structural probe has sparse/dangling objects: {path}"
+        )
+    positions: Counter[int] = Counter()
+    for current, position, _kernel, _sign in attachment_map:
+        positions[current] += 1
+        if positions[current] != position:
+            raise LegacyStructuralProofError(
+                f"direct structural attachment positions are not contiguous: {path}"
+            )
+    return _DirectStructure(
+        accuracy=accuracy,
+        current_map=current_map,
+        kernel_map=kernel_map,
+        singlet_map=singlet_map,
+        attachment_map=attachment_map,
+        destination_map=destination_map,
+    )
+
+
+def _parse_library_histogram(
+    path: Path,
+    modules: Mapping[tuple[int, int], _ModuleStructure],
+) -> tuple[tuple[tuple[int, int, int], ...], tuple[tuple[int, int, int, int], ...]]:
+    text = path.read_text(encoding="utf-8")
+    histogram = tuple(
+        tuple(int(value) for value in match)
+        for match in _LIBRARY_CALL.findall(text)
+    )
+    rows = tuple(
+        tuple(int(value) for value in match)
+        for match in _LIBRARY_ROW.findall(text)
+    )
+    if not histogram or not rows:
+        raise LegacyStructuralProofError(
+            f"contracted probe lacks exact row-to-module calls: {path}"
+        )
+    row_ids = [row[0] for row in rows]
+    if row_ids != list(range(1, len(rows) + 1)):
+        raise LegacyStructuralProofError(
+            f"contracted probe row axis is not contiguous: {path}"
+        )
+    observed = Counter((group, integral) for _row, group, integral, _sign in rows)
+    declared = Counter(
+        {(group, integral): count for group, integral, count in histogram}
+    )
+    if (
+        observed != declared
+        or len(declared) != len(histogram)
+        or any(key not in modules for key in declared)
+    ):
+        raise LegacyStructuralProofError(
+            f"contracted probe row histogram is incomplete or stale: {path}"
+        )
+    return histogram, rows
+
+
+def _sum_counts(
+    modules: Mapping[tuple[int, int], _ModuleStructure],
+    multiplicities: Mapping[tuple[int, int], int],
+) -> dict[str, int]:
+    fields = (
+        "source_current_count",
+        "produced_current_count",
+        "kernel_evaluation_count",
+        "attachment_count",
+        "amplitude_destination_count",
+    )
+    return {
+        field: sum(
+            module.counts[field] * multiplicities.get(key, 0)
+            for key, module in modules.items()
+        )
+        for field in fields
+    }
+
+
+def _mapping_payload(
+    modules: Mapping[tuple[int, int], _ModuleStructure],
+) -> dict[str, object]:
+    ordered = [modules[key] for key in sorted(modules)]
+    return {
+        "current_map": [
+            {
+                "module": [module.group, module.integral],
+                "source_ids": list(module.source_current_ids),
+                "produced_ids": list(module.produced_current_ids),
+            }
+            for module in ordered
+        ],
+        "kernel_map": [
+            {
+                "module": [module.group, module.integral],
+                "kernel_term_ids": list(module.kernel_term_ids),
+            }
+            for module in ordered
+        ],
+        "combine_route_map": [
+            {
+                "module": [module.group, module.integral],
+                "routes": [
+                    [current, list(kernel_ids)]
+                    for current, kernel_ids in module.combine_routes
+                ],
+            }
+            for module in ordered
+        ],
+        "destination_map": [
+            {
+                "module": [module.group, module.integral],
+                "destinations": [list(item) for item in module.amplitude_destinations],
+            }
+            for module in ordered
+        ],
+    }
+
+
+def _direct_mapping_payload(structure: _DirectStructure) -> dict[str, object]:
+    return {
+        "current_map": [list(item) for item in structure.current_map],
+        "kernel_map": [list(item) for item in structure.kernel_map],
+        "kernel_singlet_map": [
+            [identifier, list(values)] for identifier, values in structure.singlet_map
+        ],
+        "combine_route_map": [list(item) for item in structure.attachment_map],
+        "destination_map": [list(item) for item in structure.destination_map],
+    }
+
+
+def _copy_evidence(source: Path, destination: Path) -> Path:
+    if not source.is_file():
+        raise LegacyStructuralProofError(f"legacy evidence file is absent: {source}")
+    _atomic_write(destination, source.read_bytes())
+    return destination
+
+
+def write_legacy_structural_probe_output(
+    path: Path,
+    *,
+    stdout: str,
+    stderr: str,
+) -> None:
+    """Atomically preserve one dedicated diagnostic probe transcript."""
+
+    payload = stdout
+    if payload and not payload.endswith("\n"):
+        payload += "\n"
+    payload += stderr
+    if payload and not payload.endswith("\n"):
+        payload += "\n"
+    _atomic_write(path, payload.encode("utf-8"))
+
+
+def _evidence_inventory(
+    artifact_path: Path,
+    paths: set[Path],
+) -> list[dict[str, str]]:
+    root = artifact_path.resolve()
+    inventory: list[dict[str, str]] = []
+    for path in sorted(paths):
+        resolved = path.resolve()
+        try:
+            relative = resolved.relative_to(root)
+        except ValueError as error:
+            raise LegacyStructuralProofError(
+                f"legacy evidence escapes artifact: {path}"
+            ) from error
+        if not resolved.is_file():
+            raise LegacyStructuralProofError(
+                f"legacy evidence disappeared before publication: {path}"
+            )
+        inventory.append(
+            {"path": relative.as_posix(), "sha256": _sha256(resolved)}
+        )
+    if not inventory:
+        raise LegacyStructuralProofError("legacy evidence inventory is empty")
+    return inventory
+
+
+def emit_legacy_structural_proof(
+    cell: CellSpec,
+    *,
+    artifact_path: Path,
+    process_row: str,
+    source_revision: str,
+    repository: Path,
+    instrumentation: InstrumentationRecord,
+) -> Path:
+    """Validate real structural evidence and atomically publish its sidecar."""
+
+    evidence_root = artifact_path / _EVIDENCE_DIRECTORY
+    evidence_paths = set(instrumentation.evidence_paths)
+    process_path = artifact_path / "processes.txt"
+    log_path = artifact_path / "legacy.log"
+    evidence_paths.update((process_path, log_path))
+    modules_by_key: dict[tuple[int, int], _ModuleStructure] = {}
+    for path in sorted(artifact_path.rglob("amp*_lib.f03")):
+        module = _parse_module(path)
+        key = (module.group, module.integral)
+        if key in modules_by_key:
+            raise LegacyStructuralProofError(
+                f"duplicate generated module identity {key} in {artifact_path}"
+            )
+        modules_by_key[key] = module
+        evidence_paths.add(path)
+
+    direct_path = evidence_root / "direct-structural-probe.stdout"
+    contracted_path = evidence_root / "contracted-structural-probe.stdout"
+    mapping: dict[str, object]
+    histogram: tuple[tuple[int, int, int], ...]
+    row_map: tuple[tuple[int, int, int, int], ...]
+    if direct_path.is_file():
+        if modules_by_key:
+            raise LegacyStructuralProofError(
+                "direct structural evidence unexpectedly contains generated modules"
+            )
+        direct = _parse_direct(direct_path, cell.measurement.accuracy.value)
+        mapping = _direct_mapping_payload(direct)
+        active = direct.counts
+        static = direct.counts
+        row = _PROCESS_ROW.fullmatch(process_row)
+        if row is None:
+            raise LegacyStructuralProofError(
+                f"invalid direct-probe process row: {process_row!r}"
+            )
+        histogram = ((int(row.group(1)), int(row.group(2)), 1),)
+        row_map = (
+            (1, int(row.group(1)), int(row.group(2)), 1),
+        )
+        evidence_paths.add(direct_path)
+        executable = _copy_evidence(
+            repository / "amplicol_color_probe",
+            evidence_root / "amplicol_color_probe",
+        )
+        evidence_paths.add(executable)
+        evidence_kind = "direct-imode2-exact-object-map"
+    else:
+        if not modules_by_key:
+            raise LegacyStructuralProofError(
+                "generated-library structural proof has no modules"
+            )
+        mapping = _mapping_payload(modules_by_key)
+        static = _sum_counts(
+            modules_by_key,
+            {key: 1 for key in modules_by_key},
+        )
+        if cell.workload is Workload.SELECTED_FLOW:
+            row = _PROCESS_ROW.fullmatch(process_row)
+            if row is None:
+                raise LegacyStructuralProofError(
+                    f"invalid selected-flow process row: {process_row!r}"
+                )
+            key = (int(row.group(1)), int(row.group(2)))
+            if key not in modules_by_key:
+                raise LegacyStructuralProofError(
+                    f"selected-flow generated module is absent: {key}"
+                )
+            histogram = ((key[0], key[1], 1),)
+            row_map = ((1, key[0], key[1], 1),)
+            active = _sum_counts(modules_by_key, {key: 1})
+            executable = _copy_evidence(
+                artifact_path
+                / "selected-flow-generated-library"
+                / "amplicol_library_benchmark",
+                evidence_root / "amplicol_library_benchmark",
+            )
+            evidence_paths.add(executable)
+            evidence_kind = "generated-library-selected-row-exact-object-map"
+        elif cell.workload is Workload.CONTRACTED:
+            histogram, row_map = _parse_library_histogram(
+                contracted_path,
+                modules_by_key,
+            )
+            active = _sum_counts(
+                modules_by_key,
+                {(group, integral): count for group, integral, count in histogram},
+            )
+            evidence_paths.add(contracted_path)
+            output = (
+                artifact_path
+                / "contracted-generated-library"
+                / "amplicol_color_library_probe.output"
+            )
+            evidence_paths.add(output)
+            executable = (
+                artifact_path
+                / "contracted-generated-library"
+                / "amplicol_color_library_probe"
+            )
+            evidence_paths.add(executable)
+            evidence_kind = "generated-library-contracted-exact-call-map"
+        else:
+            raise LegacyStructuralProofError(
+                "generated-library evidence cannot certify this workload"
+            )
+
+    mapping_sections = {
+        "current_object_map_sha256": _canonical_sha256(mapping["current_map"]),
+        "kernel_term_map_sha256": _canonical_sha256(mapping["kernel_map"]),
+        "combine_route_map_sha256": _canonical_sha256(
+            mapping["combine_route_map"]
+        ),
+        "amplitude_destination_map_sha256": _canonical_sha256(
+            mapping["destination_map"]
+        ),
+    }
+    source_contract = {
+        "schema": _SOURCE_CONTRACT_SCHEMA,
+        "cell_id": cell.cell_id,
+        "process_key": cell.process_key,
+        "process": cell.process,
+        "n_final": cell.n_final,
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+        "process_row": process_row,
+        "source_revision": source_revision,
+        "instrumentation": {
+            "abi": instrumentation.abi,
+            "sources": list(instrumentation.sources),
+        },
+        "scope": "available",
+    }
+    source_contract_path = evidence_root / "source-contract.json"
+    _atomic_json(source_contract_path, source_contract)
+    evidence_paths.add(source_contract_path)
+    source_contract_sha256 = _canonical_sha256(source_contract)
+    histogram_payload = {
+        "histogram": [list(item) for item in histogram],
+        "row_map": [list(item) for item in row_map],
+    }
+    index = {
+        "schema": _INDEX_SCHEMA,
+        "evidence_kind": evidence_kind,
+        "active": active,
+        "static": static,
+        "object_mapping": {
+            **mapping_sections,
+            "source_contract_sha256": source_contract_sha256,
+        },
+        "row_multiplicity": histogram_payload,
+        "module_count": len(modules_by_key),
+    }
+    index_path = evidence_root / "legacy-structural-index.json"
+    _atomic_json(index_path, index)
+    evidence_paths.add(index_path)
+    proof = {
+        "schema": LEGACY_PROOF_SCHEMA,
+        "cell_id": cell.cell_id,
+        "source_revision": source_revision,
+        "scope": "available",
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+        "active": active,
+        "static": static,
+        "object_mapping": {
+            "status": "exact",
+            "abi": _MAPPING_ABI,
+            "accuracy": cell.measurement.accuracy.value,
+            **mapping_sections,
+            "source_contract_sha256": source_contract_sha256,
+        },
+        "row_multiplicity": {
+            "status": "exact",
+            "scope": cell.workload.value,
+            "call_count": sum(count for _group, _integral, count in histogram),
+            "histogram_sha256": _canonical_sha256(histogram_payload),
+        },
+        "evidence_files": _evidence_inventory(artifact_path, evidence_paths),
+    }
+    proof_path = artifact_path / "legacy-structural-proof.json"
+    _atomic_json(proof_path, proof)
+    return proof_path
+
+
+def emit_legacy_scope_unavailable_proof(
+    cell: CellSpec,
+    *,
+    artifact_path: Path,
+    source_revision: str,
+    maximum_open_quark_lines: int,
+    observed_open_quark_lines: int,
+) -> Path:
+    """Publish the exact original-AmpliCol scope boundary, with no fake counts."""
+
+    contract = {
+        "schema": _SOURCE_CONTRACT_SCHEMA,
+        "cell_id": cell.cell_id,
+        "process_key": cell.process_key,
+        "process": cell.process,
+        "n_final": cell.n_final,
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+        "source_revision": source_revision,
+        "scope": "unavailable",
+        "reason": LEGACY_SCOPE_REASON,
+        "maximum_open_quark_lines": maximum_open_quark_lines,
+        "observed_open_quark_lines": observed_open_quark_lines,
+    }
+    contract_path = artifact_path / _EVIDENCE_DIRECTORY / "source-contract.json"
+    _atomic_json(contract_path, contract)
+    proof = {
+        "schema": LEGACY_PROOF_SCHEMA,
+        "cell_id": cell.cell_id,
+        "source_revision": source_revision,
+        "scope": "unavailable",
+        "reason": LEGACY_SCOPE_REASON,
+        "maximum_open_quark_lines": maximum_open_quark_lines,
+        "observed_open_quark_lines": observed_open_quark_lines,
+        "source_contract_sha256": _canonical_sha256(contract),
+        "evidence_files": _evidence_inventory(artifact_path, {contract_path}),
+    }
+    proof_path = artifact_path / "legacy-structural-proof.json"
+    _atomic_json(proof_path, proof)
+    return proof_path
+
+
+__all__ = [
+    "LEGACY_PROOF_SCHEMA",
+    "LEGACY_SCOPE_REASON",
+    "STRUCTURAL_PROBE_ENVIRONMENT",
+    "InstrumentationRecord",
+    "LegacyStructuralProofError",
+    "emit_legacy_scope_unavailable_proof",
+    "emit_legacy_structural_proof",
+    "instrument_legacy_structural_probes",
+    "legacy_structural_probe_lock",
+    "write_legacy_structural_probe_output",
+]
diff --git a/pyamplicol/tools/performance_report/madgraph.py b/pyamplicol/tools/performance_report/madgraph.py
new file mode 100644
index 0000000000..b85ba32b86
--- /dev/null
+++ b/pyamplicol/tools/performance_report/madgraph.py
@@ -0,0 +1,773 @@
+# SPDX-License-Identifier: 0BSD
+"""MadGraph tree-level authority adapter for full-colour report cells.
+
+The authority is MadGraph's installation-owned, default-restricted UFO ``sm``
+model.  The adapter authenticates that model's external parameter identities
+and values against the campaign UFO-SM inputs before evaluating either side.
+"""
+
+from __future__ import annotations
+
+import ast
+import hashlib
+import importlib.resources
+import json
+import math
+import os
+import shutil
+import statistics
+import time
+from collections.abc import Mapping
+from contextlib import nullcontext
+from dataclasses import dataclass
+from pathlib import Path
+
+from tools.developer.madgraph_correctness import (
+    MADGRAPH_DRIVER_SOURCE_SHA256,
+    CommandExecutor,
+    CommandResult,
+    DriverResult,
+    MadGraphAdapterError,
+    StandaloneMadGraphRunner,
+    SubprocessExecutor,
+)
+from tools.developer.madgraph_correctness import (
+    discover_subprocess as _discover_subprocess,
+)
+from tools.developer.madgraph_correctness import (
+    madgraph_command_card as _correctness_command_card,
+)
+from tools.developer.madgraph_correctness import (
+    momenta_rows as _momenta_rows,
+)
+from tools.developer.madgraph_correctness import (
+    reject_failed_generation as _reject_generic_generation,
+)
+from tools.developer.madgraph_correctness import (
+    validate_installation as _validate_base_installation,
+)
+
+from .agreements import DIRECT_AGREEMENT_FIELD
+from .cache import empty_measurement
+from .measurement import shared_validation_points
+from .models import Accuracy, CellSpec, ExecutionMode, ModelKey, ResultStatus, Workload
+from .phase_state import WorkerPhaseReporter
+from .runner import (
+    DEFAULT_TARGET_RUNTIME_SECONDS,
+    MADGRAPH_RELATIVE_TOLERANCE,
+    point_digest,
+)
+
+DEFAULT_WARMUP_CALLS = 20
+DEFAULT_MINIMUM_CALLS = 10
+DEFAULT_MAXIMUM_CALLS = 10_000_000
+DEFAULT_MINIMUM_PROFILE_CHUNKS = 5
+
+
+@dataclass(frozen=True, slots=True)
+class MadGraphSettings:
+    installation: Path
+    target_runtime_seconds: float = DEFAULT_TARGET_RUNTIME_SECONDS
+    warmup_calls: int = DEFAULT_WARMUP_CALLS
+    minimum_calls: int = DEFAULT_MINIMUM_CALLS
+    maximum_calls: int = DEFAULT_MAXIMUM_CALLS
+    minimum_profile_chunks: int = DEFAULT_MINIMUM_PROFILE_CHUNKS
+    json_model_path: Path | None = None
+    restriction_json_path: Path | None = None
+    worker_deadline_monotonic: float | None = None
+
+    def __post_init__(self) -> None:
+        if (
+            not math.isfinite(self.target_runtime_seconds)
+            or self.target_runtime_seconds <= 0.0
+        ):
+            raise ValueError("target_runtime_seconds must be finite and positive")
+        if self.warmup_calls < DEFAULT_WARMUP_CALLS:
+            raise ValueError(f"warmup_calls must be at least {DEFAULT_WARMUP_CALLS}")
+        if self.minimum_calls < 1:
+            raise ValueError("minimum_calls must be positive")
+        if self.maximum_calls < self.minimum_calls:
+            raise ValueError("maximum_calls must not be below minimum_calls")
+        if self.minimum_profile_chunks < DEFAULT_MINIMUM_PROFILE_CHUNKS:
+            raise ValueError(
+                "minimum_profile_chunks must be at least "
+                f"{DEFAULT_MINIMUM_PROFILE_CHUNKS}"
+            )
+        if self.worker_deadline_monotonic is not None and (
+            not math.isfinite(self.worker_deadline_monotonic)
+            or self.worker_deadline_monotonic <= 0.0
+        ):
+            raise ValueError("worker_deadline_monotonic must be finite and positive")
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _directory_digest(path: Path) -> str:
+    digest = hashlib.sha256()
+    files = tuple(
+        sorted(
+            candidate
+            for candidate in path.rglob("*")
+            if candidate.is_file()
+            and not candidate.is_symlink()
+            and "__pycache__" not in candidate.parts
+            and candidate.suffix != ".pyc"
+        )
+    )
+    if not files:
+        raise MadGraphAdapterError(f"UFO model directory is empty: {path}")
+    for candidate in files:
+        relative = candidate.relative_to(path).as_posix().encode("utf-8")
+        payload = candidate.read_bytes()
+        digest.update(len(relative).to_bytes(8, "big"))
+        digest.update(relative)
+        digest.update(len(payload).to_bytes(8, "big"))
+        digest.update(payload)
+    return digest.hexdigest()
+
+
+def _default_json_model_path() -> Path:
+    resource = importlib.resources.files("pyamplicol").joinpath(
+        "assets", "models", "json", "sm", "sm.json"
+    )
+    if not isinstance(resource, os.PathLike):
+        raise MadGraphAdapterError("installed UFO-SM JSON is not filesystem-backed")
+    try:
+        result = Path(os.fspath(resource)).resolve(strict=True)
+    except OSError as error:
+        raise MadGraphAdapterError("packaged UFO-SM JSON is unavailable") from error
+    if not result.is_file():
+        raise MadGraphAdapterError("packaged UFO-SM JSON is not a regular file")
+    return result
+
+
+def _default_restriction_json_path() -> Path:
+    resource = importlib.resources.files("pyamplicol").joinpath(
+        "assets", "models", "json", "sm", "restrict_default.json"
+    )
+    if not isinstance(resource, os.PathLike):
+        raise MadGraphAdapterError(
+            "installed UFO-SM default restriction is not filesystem-backed"
+        )
+    try:
+        result = Path(os.fspath(resource)).resolve(strict=True)
+    except OSError as error:
+        raise MadGraphAdapterError(
+            "packaged UFO-SM default restriction is unavailable"
+        ) from error
+    if not result.is_file():
+        raise MadGraphAdapterError(
+            "packaged UFO-SM default restriction is not a regular file"
+        )
+    return result
+
+
+def _expected_external_parameters(
+    model_path: Path,
+    restriction_path: Path,
+) -> dict[tuple[str, tuple[int, ...]], tuple[str, float]]:
+    try:
+        payload = json.loads(model_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise MadGraphAdapterError("cannot read packaged UFO-SM JSON") from error
+    raw_parameters = payload.get("parameters")
+    if not isinstance(raw_parameters, list):
+        raise MadGraphAdapterError("packaged UFO-SM JSON has no parameter list")
+    try:
+        restriction = json.loads(restriction_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise MadGraphAdapterError(
+            "cannot read packaged UFO-SM default restriction"
+        ) from error
+    if not isinstance(restriction, Mapping):
+        raise MadGraphAdapterError("packaged UFO-SM restriction is not an object")
+    result: dict[tuple[str, tuple[int, ...]], tuple[str, float]] = {}
+    observed_names: set[str] = set()
+    for raw in raw_parameters:
+        if not isinstance(raw, Mapping) or raw.get("nature") != "external":
+            continue
+        block = raw.get("lhablock")
+        codes = raw.get("lhacode")
+        name = raw.get("name")
+        value = raw.get("value")
+        if (
+            not isinstance(block, str)
+            or not isinstance(codes, list)
+            or not codes
+            or any(
+                isinstance(code, bool) or not isinstance(code, int) for code in codes
+            )
+            or not isinstance(name, str)
+            or not isinstance(value, list)
+            or len(value) != 2
+            or isinstance(value[0], bool)
+            or not isinstance(value[0], (int, float))
+            or float(value[1]) != 0.0
+        ):
+            raise MadGraphAdapterError(
+                "packaged UFO-SM external parameter is malformed"
+            )
+        key = (block.upper(), tuple(codes))
+        if key in result:
+            raise MadGraphAdapterError("packaged UFO-SM repeats an external LHA key")
+        restricted = restriction.get(name)
+        if (
+            not isinstance(restricted, list)
+            or len(restricted) != 2
+            or isinstance(restricted[0], bool)
+            or not isinstance(restricted[0], (int, float))
+            or float(restricted[1]) != 0.0
+        ):
+            raise MadGraphAdapterError(
+                f"default restriction has no real value for external {name}"
+            )
+        observed_names.add(name)
+        result[key] = (name, float(restricted[0]))
+    if not result:
+        raise MadGraphAdapterError("packaged UFO-SM has no external parameters")
+    extra = set(restriction).difference(observed_names)
+    if extra:
+        raise MadGraphAdapterError(
+            f"default restriction contains unknown externals: {sorted(extra)!r}"
+        )
+    return result
+
+
+def _ufo_external_parameters(
+    parameters_path: Path,
+) -> dict[tuple[str, tuple[int, ...]], tuple[str, float]]:
+    """Read literal UFO external declarations without importing model code."""
+
+    try:
+        tree = ast.parse(parameters_path.read_text(encoding="utf-8"))
+    except (OSError, SyntaxError) as error:
+        raise MadGraphAdapterError("cannot parse MadGraph UFO parameters.py") from error
+    result: dict[tuple[str, tuple[int, ...]], tuple[str, float]] = {}
+    for node in tree.body:
+        if (
+            not isinstance(node, ast.Assign)
+            or len(node.targets) != 1
+            or not isinstance(node.targets[0], ast.Name)
+            or not isinstance(node.value, ast.Call)
+            or not isinstance(node.value.func, ast.Name)
+            or node.value.func.id != "Parameter"
+        ):
+            continue
+        keywords = {
+            keyword.arg: keyword.value
+            for keyword in node.value.keywords
+            if keyword.arg is not None
+        }
+        try:
+            nature = ast.literal_eval(keywords["nature"])
+        except (KeyError, ValueError, TypeError):
+            continue
+        if nature != "external":
+            continue
+        try:
+            name = ast.literal_eval(keywords["name"])
+            value = ast.literal_eval(keywords["value"])
+            block = ast.literal_eval(keywords["lhablock"])
+            codes = ast.literal_eval(keywords["lhacode"])
+        except (KeyError, ValueError, TypeError) as error:
+            raise MadGraphAdapterError(
+                "MadGraph UFO external parameter is not literal"
+            ) from error
+        if (
+            not isinstance(name, str)
+            or not isinstance(block, str)
+            or isinstance(value, bool)
+            or not isinstance(value, (int, float))
+            or not isinstance(codes, list)
+            or not codes
+            or any(
+                isinstance(code, bool) or not isinstance(code, int) for code in codes
+            )
+        ):
+            raise MadGraphAdapterError("MadGraph UFO external parameter is malformed")
+        key = (block.upper(), tuple(codes))
+        if key in result:
+            raise MadGraphAdapterError("MadGraph UFO repeats an external LHA key")
+        result[key] = (name, float(value))
+    if not result:
+        raise MadGraphAdapterError("MadGraph UFO has no literal external parameters")
+    return result
+
+
+def _write_exact_param_card(
+    card_path: Path,
+    *,
+    parameters_path: Path,
+    model_path: Path,
+    restriction_path: Path,
+) -> dict[str, object]:
+    """Write the exact external LHA inputs within MG's 20-character limit."""
+
+    expected = _expected_external_parameters(model_path, restriction_path)
+    madgraph_parameters = _ufo_external_parameters(parameters_path)
+    expected_identity = {key: value[0] for key, value in expected.items()}
+    madgraph_identity = {key: value[0] for key, value in madgraph_parameters.items()}
+    if madgraph_identity != expected_identity:
+        missing = sorted(set(expected).difference(madgraph_parameters))
+        extra = sorted(set(madgraph_parameters).difference(expected))
+        changed = tuple(
+            (key, expected[key][0], madgraph_parameters[key][0])
+            for key in sorted(set(expected).intersection(madgraph_parameters))
+            if expected[key][0] != madgraph_parameters[key][0]
+        )
+        raise MadGraphAdapterError(
+            "MadGraph UFO external identities differ from the packaged JSON model: "
+            f"missing={missing!r}, extra={extra!r}, changed={changed!r}"
+        )
+    blocks = sorted(
+        {key[0] for key in expected if key[0] != "DECAY"},
+        key=lambda name: (
+            {"SMINPUTS": 0, "MASS": 1}.get(name, 2),
+            name,
+        ),
+    )
+    lines = [
+        "######################################################################",
+        "## Exact packaged UFO-SM external parameters for MadGraph validation",
+        "######################################################################",
+        "",
+    ]
+    for block in blocks:
+        lines.append(f"Block {block}")
+        for key in sorted(candidate for candidate in expected if candidate[0] == block):
+            name, value = expected[key]
+            rendered = f"{value:.14e}"
+            if len(rendered) > 20:
+                raise MadGraphAdapterError(
+                    f"external parameter {name} exceeds MadGraph's LHA value field"
+                )
+            codes = " ".join(str(code) for code in key[1])
+            lines.append(f"  {codes} {rendered} # {name}")
+        lines.append("")
+    for key in sorted(candidate for candidate in expected if candidate[0] == "DECAY"):
+        name, value = expected[key]
+        rendered = f"{value:.14e}"
+        if len(rendered) > 20:
+            raise MadGraphAdapterError(
+                f"external parameter {name} exceeds MadGraph's LHA value field"
+            )
+        codes = " ".join(str(code) for code in key[1])
+        lines.append(f"DECAY {codes} {rendered} # {name}")
+    card_path.write_text("\n".join(lines) + "\n", encoding="ascii")
+    return _validate_exact_param_card(
+        card_path,
+        model_path,
+        restriction_path,
+    )
+
+
+def _validate_exact_param_card(
+    card_path: Path,
+    model_path: Path,
+    restriction_path: Path,
+) -> dict[str, object]:
+    expected = _expected_external_parameters(model_path, restriction_path)
+    observed: dict[tuple[str, tuple[int, ...]], float] = {}
+    block: str | None = None
+    for raw_line in card_path.read_text(encoding="utf-8", errors="strict").splitlines():
+        content = raw_line.partition("#")[0].strip()
+        if not content:
+            continue
+        tokens = content.split()
+        keyword = tokens[0].upper()
+        if keyword == "BLOCK" and len(tokens) >= 2:
+            block = tokens[1].upper()
+            continue
+        if keyword == "DECAY" and len(tokens) >= 3:
+            key = ("DECAY", (int(tokens[1]),))
+            value_token = tokens[2]
+        elif block is not None and len(tokens) >= 2:
+            try:
+                codes = tuple(int(token) for token in tokens[:-1])
+            except ValueError:
+                continue
+            key = (block, codes)
+            value_token = tokens[-1]
+        else:
+            continue
+        if key not in expected:
+            continue
+        if key in observed:
+            raise MadGraphAdapterError(
+                "exact parameter card repeats an external LHA key"
+            )
+        try:
+            observed[key] = float(value_token.replace("D", "E").replace("d", "e"))
+        except ValueError as error:
+            raise MadGraphAdapterError(
+                "exact parameter card contains a malformed external value"
+            ) from error
+    if set(observed) != set(expected):
+        missing = sorted(set(expected).difference(observed))
+        raise MadGraphAdapterError(
+            "exact parameter card does not cover packaged UFO-SM externals: "
+            f"missing={missing!r}"
+        )
+    mismatches = tuple(
+        (key, expected[key][1], observed[key])
+        for key in sorted(expected)
+        if expected[key][1] != observed[key]
+    )
+    if mismatches:
+        raise MadGraphAdapterError(
+            "exact parameter card differs from packaged UFO-SM defaults: "
+            f"{mismatches!r}"
+        )
+    canonical = json.dumps(
+        {expected[key][0]: [observed[key], 0.0] for key in sorted(expected)},
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return {
+        "external_parameter_count": len(expected),
+        "external_parameters_sha256": hashlib.sha256(canonical).hexdigest(),
+        "binary64_exact_match": True,
+        "format": "%.14e",
+    }
+
+
+def _validate_installation(path: Path) -> tuple[Path, Path, Path]:
+    installation, launcher = _validate_base_installation(path)
+    model = installation / "models" / "sm"
+    required_model_files = (model / "parameters.py", model / "restrict_default.dat")
+    if (
+        model.is_symlink()
+        or not model.is_dir()
+        or any(path.is_symlink() or not path.is_file() for path in required_model_files)
+    ):
+        raise MadGraphAdapterError(
+            "MadGraph installation must contain its regular UFO models/sm model"
+        )
+    return installation, launcher, model
+
+
+def madgraph_command_card(process: str) -> str:
+    return _correctness_command_card(process)
+
+
+def _reject_failed_generation(
+    result: CommandResult,
+    standalone: Path,
+) -> None:
+    try:
+        _reject_generic_generation(
+            result,
+            standalone,
+            expected_model_import="sm",
+        )
+    except MadGraphAdapterError as error:
+        if "bound exclusively" not in str(error):
+            raise
+        raise MadGraphAdapterError(
+            "standalone process card is not bound exclusively to MadGraph UFO sm"
+        ) from error
+
+
+class MadGraphMeasurementAdapter(StandaloneMadGraphRunner):
+    """Generate, drive, and profile one standalone MadGraph matrix element."""
+
+    @staticmethod
+    def _assert_deadline(settings: MadGraphSettings) -> None:
+        deadline = settings.worker_deadline_monotonic
+        if deadline is not None and time.monotonic() >= deadline:
+            raise MadGraphAdapterError("MadGraph worker deadline was exhausted")
+
+    def measure(
+        self,
+        cell: CellSpec,
+        *,
+        artifact_path: Path,
+        settings: MadGraphSettings,
+        phase_reporter: WorkerPhaseReporter | None = None,
+    ) -> dict[str, object]:
+        if (
+            cell.measurement.execution_mode is not ExecutionMode.MADGRAPH
+            or cell.measurement.model is not ModelKey.UFO_SM
+            or cell.measurement.accuracy is not Accuracy.FULL
+            or cell.workload is not Workload.CONTRACTED
+        ):
+            raise MadGraphAdapterError(
+                "MadGraph adapter requires a contracted full-colour UFO-SM "
+                "reference cell"
+            )
+        installation, launcher, madgraph_model = _validate_installation(
+            settings.installation
+        )
+        json_model_path = settings.json_model_path or _default_json_model_path()
+        restriction_json_path = (
+            settings.restriction_json_path or _default_restriction_json_path()
+        )
+        artifact_path.mkdir(parents=True, exist_ok=True)
+        log_path = artifact_path / "madgraph.log"
+        standalone = artifact_path / "standalone"
+        model_record = {
+            "name": "sm",
+            "source_directory": os.fspath(madgraph_model),
+            "source_sha256": _directory_digest(madgraph_model),
+        }
+        command_card = madgraph_command_card(cell.process)
+        command_card_path = artifact_path / "madgraph_command_card.dat"
+        command_card_path.write_text(command_card, encoding="utf-8")
+        commands: list[dict[str, object]] = []
+
+        generation_context = (
+            nullcontext() if phase_reporter is None else phase_reporter.generation()
+        )
+        with generation_context:
+            self._assert_deadline(settings)
+            generation = self._run_logged(
+                self.executor,
+                (launcher, command_card_path),
+                cwd=artifact_path,
+                log_path=log_path,
+            )
+            commands.append(generation.record())
+            _reject_failed_generation(generation, standalone)
+            restriction_card_record = _validate_exact_param_card(
+                madgraph_model / "restrict_default.dat",
+                json_model_path,
+                restriction_json_path,
+            )
+            param_card = standalone / "Cards" / "param_card.dat"
+            rounded_param_card = (
+                standalone / "Cards" / "param_card.madgraph-rounded.dat"
+            )
+            shutil.copy2(param_card, rounded_param_card)
+            exact_param_card_record = _write_exact_param_card(
+                param_card,
+                parameters_path=madgraph_model / "parameters.py",
+                model_path=json_model_path,
+                restriction_path=restriction_json_path,
+            )
+            subprocess_dir = _discover_subprocess(standalone)
+            executable, compilation, driver_digest = self._compile_driver(
+                standalone,
+                subprocess_dir,
+                log_path=log_path,
+            )
+            commands.append(compilation.record())
+
+        validation_points = shared_validation_points(cell.process)
+        momenta = _momenta_rows(validation_points)
+        momenta_path = subprocess_dir / "pyamplicol_momenta.dat"
+        momenta_path.write_text(
+            "".join(
+                " ".join(format(component, ".17e") for component in row) + "\n"
+                for row in momenta
+            ),
+            encoding="ascii",
+        )
+        if phase_reporter is not None:
+            phase_reporter.profiling_started()
+
+        self._assert_deadline(settings)
+        calibration = self._run_driver(
+            executable,
+            subprocess_dir=subprocess_dir,
+            momenta_path=momenta_path,
+            points=settings.minimum_calls,
+            warmup_calls=settings.warmup_calls,
+            log_path=log_path,
+        )
+        commands.append(calibration.command.record())
+        calibration_seconds = calibration.seconds
+        calibration_calls = calibration.points
+        target_chunk_seconds = (
+            settings.target_runtime_seconds / settings.minimum_profile_chunks
+        )
+        calibration_target_seconds = min(0.1, 0.25 * target_chunk_seconds)
+        while (
+            calibration_seconds < calibration_target_seconds
+            and calibration_calls < settings.maximum_calls
+        ):
+            if calibration_seconds <= 0.0:
+                next_calls = calibration_calls * 10
+            else:
+                next_calls = math.ceil(
+                    1.25
+                    * calibration_calls
+                    * calibration_target_seconds
+                    / calibration_seconds
+                )
+            calibration_calls = min(
+                settings.maximum_calls,
+                max(calibration_calls + 1, next_calls),
+            )
+            calibration = self._run_driver(
+                executable,
+                subprocess_dir=subprocess_dir,
+                momenta_path=momenta_path,
+                points=calibration_calls,
+                warmup_calls=settings.warmup_calls,
+                log_path=log_path,
+            )
+            commands.append(calibration.command.record())
+            calibration_seconds = calibration.seconds
+        if calibration_seconds <= 0.0:
+            raise MadGraphAdapterError("MadGraph driver timer did not advance")
+        seconds_per_call = calibration_seconds / calibration.points
+        profile_calls = max(
+            settings.minimum_calls,
+            min(
+                settings.maximum_calls,
+                math.ceil(target_chunk_seconds / seconds_per_call),
+            ),
+        )
+        chunks: list[DriverResult] = []
+        attempted_profile_chunks = 0
+        zero_duration_profile_chunks = 0
+        while not chunks:
+            attempt: list[DriverResult] = []
+            for _ in range(settings.minimum_profile_chunks):
+                self._assert_deadline(settings)
+                chunk = self._run_driver(
+                    executable,
+                    subprocess_dir=subprocess_dir,
+                    momenta_path=momenta_path,
+                    points=profile_calls,
+                    warmup_calls=settings.warmup_calls,
+                    log_path=log_path,
+                )
+                attempted_profile_chunks += 1
+                commands.append(chunk.command.record())
+                if not math.isclose(
+                    chunk.value,
+                    calibration.value,
+                    rel_tol=5.0e-13,
+                    abs_tol=1.0e-300,
+                ):
+                    raise MadGraphAdapterError(
+                        "MadGraph driver value changed between independent "
+                        "profile chunks"
+                    )
+                if chunk.seconds <= 0.0:
+                    zero_duration_profile_chunks += 1
+                    break
+                attempt.append(chunk)
+            if len(attempt) == settings.minimum_profile_chunks:
+                chunks = attempt
+                break
+            if profile_calls >= settings.maximum_calls:
+                raise MadGraphAdapterError(
+                    "MadGraph profile timer did not advance at maximum_calls"
+                )
+            profile_calls = min(
+                settings.maximum_calls,
+                max(profile_calls + 1, profile_calls * 10),
+            )
+        if phase_reporter is not None:
+            phase_reporter.validation_started()
+
+        total_points = sum(chunk.points for chunk in chunks)
+        total_seconds = math.fsum(chunk.seconds for chunk in chunks)
+        if total_seconds <= 0.0:
+            raise MadGraphAdapterError("MadGraph profile accumulated no positive time")
+        rates = tuple(chunk.seconds / chunk.points for chunk in chunks)
+        mean_rate = total_seconds / total_points
+        standard_error = statistics.stdev(rates) / math.sqrt(len(rates))
+        relative_standard_error = standard_error / mean_rate
+        version_path = installation / "VERSION"
+
+        measurement = empty_measurement()
+        measurement.update(
+            {
+                "status": ResultStatus.OK.value,
+                "generation_seconds": generation.elapsed_seconds,
+                "wall_seconds_per_point": mean_rate,
+                "execution_seconds_per_point": mean_rate,
+                "matrix_element": calibration.value,
+                "sample_count": total_points,
+                "standard_error_seconds_per_point": standard_error,
+                "relative_standard_error": relative_standard_error,
+                "artifact": {
+                    "path": os.fspath(artifact_path),
+                    "standalone": os.fspath(standalone),
+                    "subprocess": os.fspath(subprocess_dir.relative_to(artifact_path)),
+                    "log_path": os.fspath(log_path),
+                },
+                "selector_contract": None,
+                "validation": {
+                    "status": ResultStatus.OK.value,
+                    "method": "independent-madgraph-tree-level-oracle",
+                    "point_digest": point_digest(validation_points),
+                    DIRECT_AGREEMENT_FIELD: [],
+                },
+                "resources": {
+                    "monitor": "external-cell-supervisor",
+                    "peak_rss_gib": None,
+                },
+                "provenance": {
+                    "method": "madgraph-standalone-custom-fortran-driver",
+                    "installation": os.fspath(installation),
+                    "version": (
+                        None
+                        if not version_path.is_file()
+                        else version_path.read_text(
+                            encoding="utf-8", errors="replace"
+                        ).strip()
+                    ),
+                    "version_sha256": (
+                        None if not version_path.is_file() else _sha256(version_path)
+                    ),
+                    "model": model_record,
+                    "default_restriction": restriction_card_record,
+                    "command_card": command_card,
+                    "command_card_sha256": _sha256(command_card_path),
+                    "process_card_sha256": _sha256(
+                        standalone / "Cards" / "proc_card_mg5.dat"
+                    ),
+                    "param_card_sha256": _sha256(param_card),
+                    "madgraph_rounded_param_card_sha256": _sha256(rounded_param_card),
+                    "exact_param_card": exact_param_card_record,
+                    "driver_sha256": driver_digest,
+                    "driver_compile_seconds": compilation.elapsed_seconds,
+                    "driver_timer": "fortran-system-clock-int64",
+                    "driver_warmup_calls": settings.warmup_calls,
+                    "report_momenta": validation_points,
+                    "profile_chunk_count": len(chunks),
+                    "profile_calls_per_chunk": profile_calls,
+                    "profile_attempted_chunk_count": attempted_profile_chunks,
+                    "profile_discarded_chunk_count": (
+                        attempted_profile_chunks - len(chunks)
+                    ),
+                    "profile_zero_duration_chunk_count": (zero_duration_profile_chunks),
+                    "commands": commands,
+                    "generation_timing_scope": (
+                        "generate-output-standalone-launch-force"
+                    ),
+                    "generation_includes_madgraph_compilation": True,
+                    "driver_compilation_in_generation_seconds": False,
+                },
+                "failure": None,
+            }
+        )
+        return measurement
+
+
+__all__ = [
+    "DEFAULT_MAXIMUM_CALLS",
+    "DEFAULT_MINIMUM_CALLS",
+    "DEFAULT_MINIMUM_PROFILE_CHUNKS",
+    "DEFAULT_WARMUP_CALLS",
+    "MADGRAPH_DRIVER_SOURCE_SHA256",
+    "MADGRAPH_RELATIVE_TOLERANCE",
+    "CommandExecutor",
+    "CommandResult",
+    "MadGraphAdapterError",
+    "MadGraphMeasurementAdapter",
+    "MadGraphSettings",
+    "SubprocessExecutor",
+    "madgraph_command_card",
+]
diff --git a/pyamplicol/tools/performance_report/manual_campaign.py b/pyamplicol/tools/performance_report/manual_campaign.py
new file mode 100644
index 0000000000..eefc71e819
--- /dev/null
+++ b/pyamplicol/tools/performance_report/manual_campaign.py
@@ -0,0 +1,10126 @@
+# SPDX-License-Identifier: 0BSD
+"""Human-steerable pyAmpliCol profiling campaign.
+
+This module is intentionally a thin controller.  Cell definition, dependency
+planning, generation, profiling, atomic attempt publication, rendering, and PDF
+compilation remain owned by the existing performance-report and public
+``pyamplicol`` command APIs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import copy
+import difflib
+import errno
+import hashlib
+import importlib
+import json
+import math
+import os
+import re
+import shlex
+import shutil
+import stat
+import statistics
+import struct
+import subprocess
+import sys
+import tempfile
+import textwrap
+import threading
+import time
+import uuid
+import zlib
+from collections import Counter
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
+from contextlib import contextmanager, suppress
+from dataclasses import asdict, dataclass, field
+from datetime import UTC, datetime
+from enum import StrEnum
+from pathlib import Path
+from typing import Any, Protocol, TextIO
+
+from colorama import Fore, Style, just_fix_windows_console
+from prettytable import PrettyTable
+
+from .artifacts import (
+    ATTEMPT_SCHEMA,
+    ArtifactStore,
+    CurrentRecord,
+    LockTimeoutError,
+    ManifestValidationError,
+    _raise_disk_full,
+)
+from .cache import reset_entry, validate_measurement
+from .campaign_policy import (
+    PolicyMeasurementState,
+    policy_measurement_state_hint,
+    policy_status_label,
+)
+from .catalog import PROCESS_FAMILIES, REPORT_CATALOG, ReportCatalog
+from .measurement import failure_measurement
+from .models import (
+    Accuracy,
+    ArtifactPolicy,
+    CellSpec,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from .publication import PORTABLE_CURRENT_REPRODUCTION_RECIPE_ABI
+from .publisher import (
+    DEFAULT_PDF_TIMEOUT_SECONDS,
+    _compile_pdf,
+    _report_source_copy_ignore,
+)
+from .resources import (
+    DEFAULT_ATTEMPT_OUTPUT_LIMIT_BYTES,
+    DEFAULT_MINIMUM_FREE_DISK_BYTES,
+)
+from .scheduler import (
+    CampaignResult,
+    CampaignScheduler,
+    CampaignSettings,
+    CellSelection,
+    PlannedCell,
+    plan_campaign,
+    reconcile_attempt_history,
+    select_cells,
+)
+from .service import ReportPaths, ReportService, validate_profile_name
+from .source_identity import ReportSourceIdentity, _generated_report_path
+from .timing import (
+    evaluator_total_timing_record,
+    recurrence_core_seconds_per_point,
+)
+from .workspace import (
+    ENVIRONMENT_JSON,
+    ENVIRONMENT_TEX,
+    record_authenticated_profile_environment,
+)
+
+PROFILE = "macbook_M3_manual"
+_ACTIVE_PROFILE = PROFILE
+_PRESENTATION_PROFILE = "campaign-local-v1"
+DEFAULT_GENERATION_LIMIT_SECONDS = 60.0 * 60.0
+DEFAULT_WORKER_WALL_LIMIT_SECONDS = 60.0 * 60.0
+DEFAULT_RAM_BYTES = 30_000_000_000
+DEFAULT_CORES_PER_WORKER = 1
+DEFAULT_TARGET_RUNTIME_SECONDS = 5.0
+_NUMERICAL_RELATION_CORRECTNESS_ABI = (
+    "pyamplicol-numerical-current-relation-correctness-v1"
+)
+DEFAULT_BATCH_SIZE = 128
+DEFAULT_WARMUP_RUNS = 2
+DEFAULT_MINIMUM_SAMPLES = 5
+DEFAULT_WORKER_STALE_SECONDS = 15.0
+DEFAULT_MANUAL_EXPECTED_PAGE_COUNT = 73
+_REPORT_SECTION_MARKER = re.compile(
+    r"^% pyamplicol-report-section-(begin|end): ([a-z][a-z0-9-]*)$"
+)
+_ORIGINAL_AMPLICOL_REQUIRED_FILES = (
+    "makefile",
+    "process_list.py",
+    "amplicol_color_probe.f03",
+    "amplicol_color_library_probe.f03",
+    "amplicol_library_benchmark.f03",
+)
+_ORIGINAL_AMPLICOL_REQUIRED_MAKE_TARGETS = (
+    "amplicol_generate_library",
+    "amplicol_library_benchmark",
+    "amplicol_color_probe",
+    "amplicol_color_library_probe",
+)
+_LOCAL_AMPLICOL_CONFIG = ".pyamplicol-original-amplicol"
+_LOCAL_MADGRAPH_CONFIG = ".pyamplicol-madgraph"
+MAX_TAIL_READ_BYTES = 64 * 1024
+MAX_LOG_TAIL_LINES = 8
+MANUAL_STATE_SCHEMA = "pyamplicol-manual-campaign-state-v1"
+SOURCE_MARKER_SCHEMA = "pyamplicol-manual-source-v1"
+PRESENTATION_OUTCOME_SCHEMA = "pyamplicol-manual-presentation-outcome-v1"
+_FULL_SOURCE_REVISION = re.compile(r"[0-9a-f]{40}")
+_SAFE_OUTCOME_SLUG = re.compile(r"[a-z][a-z0-9_-]{0,63}")
+_SAFE_OUTCOME_CELL_ID = re.compile(r"[a-z0-9][a-z0-9-]{0,127}")
+_PRESENTATION_FAILURE_KIND_PREFIX = "ManualCampaignOutcome:"
+_UNRECORDED_MEASUREMENT_NUMPY = "unavailable (not recorded by measurement)"
+_MAX_PRESENTATION_COMPLETED_AT_NS = (1 << 63) - 1
+_PRESENTATION_OUTCOME_KEYS = frozenset(
+    {
+        "schema",
+        "profile",
+        "cell_id",
+        "source_revision",
+        "campaign_invocation_id",
+        "attempt_id",
+        "status",
+        "label",
+        "completed_at_ns",
+    }
+)
+_DASHBOARD_COUNTER_KEYS = (
+    "selected",
+    "recycled",
+    "active",
+    "selected_active",
+    "dependency_active",
+    "completed",
+    "remaining",
+    "static_na",
+    "capped",
+    "failed",
+    "unverified",
+    "dependency_only",
+    "dependency_completed",
+    "dependency_issues",
+)
+_ANSI_ESCAPE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+_ACTIVE_WORKER_STATUSES = frozenset({"queued", "preparing", "running"})
+_RECYCLED_SUCCESS_STATUSES = frozenset({"recycled", "reused", "skipped-current"})
+_COMPLETED_WORKER_STATUSES = frozenset(
+    {"ok", "success", *_RECYCLED_SUCCESS_STATUSES}
+)
+_TERMINAL_CAP_STATUSES = frozenset(
+    {
+        PolicyMeasurementState.GENERATION_LIMIT.value,
+        PolicyMeasurementState.MEMORY_LIMIT.value,
+        PolicyMeasurementState.WORKER_TIMEOUT.value,
+        PolicyMeasurementState.PROFILING_TIMEOUT.value,
+        PolicyMeasurementState.VALIDATION_TIMEOUT.value,
+    }
+)
+_TERMINAL_CAP_STATES = frozenset(
+    {
+        PolicyMeasurementState.GENERATION_LIMIT,
+        PolicyMeasurementState.MEMORY_LIMIT,
+        PolicyMeasurementState.WORKER_TIMEOUT,
+        PolicyMeasurementState.PROFILING_TIMEOUT,
+        PolicyMeasurementState.VALIDATION_TIMEOUT,
+    }
+)
+_PHASE_TIMELINE_SCHEMA = "pyamplicol-manual-campaign-phase-timeline-v1"
+_REPRODUCTION_STAGES = ("prepare", "generate", "profile")
+_SUMMARY_SUCCESS_STATUSES = frozenset(
+    {"ok", "success", "recycled", "reused", "skipped-current"}
+)
+_FAIL_FAST_SUCCESS_STATUSES = frozenset(
+    {"ok", "success", "reused", "skipped-current"}
+)
+FAIL_FAST_FAILURE_LOG = "fail_fast_failure.log"
+
+
+class _DashboardTerminalOutcome(StrEnum):
+    """One normalized terminal category for a dashboard-owned cell.
+
+    The map keyed by cell ID is the sole terminal-state authority. Counter
+    sets are derived views, so retries cannot leave a cell in two categories.
+    """
+
+    SUCCESS = "success"
+    CAPPED = "capped"
+    FAILED = "failed"
+    UNVERIFIED = "unverified"
+
+
+class ManualCampaignError(RuntimeError):
+    """One concise, user-facing steering error."""
+
+
+def _require_literal_directory(
+    path: Path,
+    *,
+    label: str,
+    required: bool,
+) -> None:
+    """Reject symlink and special-file campaign roots before resolution."""
+
+    try:
+        metadata = path.lstat()
+    except FileNotFoundError:
+        if required:
+            raise ManualCampaignError(f"{label} does not exist: {path}") from None
+        return
+    except OSError as error:
+        raise ManualCampaignError(f"cannot inspect {label} {path}: {error}") from error
+    if stat.S_ISLNK(metadata.st_mode):
+        raise ManualCampaignError(f"{label} must not be a symbolic link: {path}")
+    if not stat.S_ISDIR(metadata.st_mode):
+        raise ManualCampaignError(f"{label} must be a directory: {path}")
+
+
+def _campaign_report_paths(repo_root: Path, docs_dir: Path) -> ReportPaths:
+    """Derive every private campaign path from one literal campaign directory."""
+
+    expanded = docs_dir.expanduser()
+    literal_docs = expanded if expanded.is_absolute() else Path.cwd() / expanded
+    _require_literal_directory(
+        literal_docs,
+        label="campaign directory",
+        required=True,
+    )
+    literal_artifacts = literal_docs / "campaign_artifacts"
+    literal_coordination = literal_artifacts / "coordination"
+    _require_literal_directory(
+        literal_artifacts,
+        label="campaign artifact root",
+        required=False,
+    )
+    _require_literal_directory(
+        literal_coordination,
+        label="campaign coordination root",
+        required=False,
+    )
+    resolved_docs = literal_docs.resolve(strict=True)
+    if resolved_docs != Path(os.path.abspath(literal_docs)):
+        raise ManualCampaignError(
+            f"campaign directory must not traverse a symbolic link: {literal_docs}"
+        )
+    artifact_root = resolved_docs / "campaign_artifacts"
+    return ReportPaths.from_repo(
+        repo_root,
+        docs_dir=resolved_docs,
+        artifact_root=artifact_root,
+        coordination_root=artifact_root / "coordination",
+    )
+
+
+def _require_launcher_working_directory_identity(
+    *, launcher_path_checked: bool
+) -> None:
+    """Reject a launcher left inside a renamed campaign directory."""
+
+    if launcher_path_checked:
+        return
+    invocation = Path(sys.argv[0])
+    if invocation.name != "steer_performance_campaign.py":
+        return
+    logical_text = os.environ.get("PWD")
+    logical_cwd = Path(logical_text) if logical_text else None
+    try:
+        physical_cwd = Path.cwd()
+        same_directory = (
+            logical_cwd is not None
+            and logical_cwd.is_absolute()
+            and logical_cwd.samefile(physical_cwd)
+        )
+    except OSError:
+        same_directory = False
+    if not same_directory:
+        raise ManualCampaignError(
+            "campaign launcher cannot identify its working directory: "
+            "the shell PWD is missing or no longer names the physical directory. "
+            "Run `cd ..` and re-enter the intended campaign directory, then retry "
+            "(or invoke its absolute path from another working directory)."
+        )
+
+
+def _acquire_campaign_directory_lock(docs_dir: Path) -> int:
+    """Hold a shared lifetime claim so ``copy --force`` cannot reset state."""
+
+    import fcntl
+
+    flags = os.O_RDONLY | getattr(os, "O_DIRECTORY", 0)
+    try:
+        descriptor = os.open(docs_dir, flags)
+    except OSError as error:
+        raise ManualCampaignError(
+            f"cannot open campaign directory for coordination: {docs_dir}"
+        ) from error
+    try:
+        fcntl.flock(descriptor, fcntl.LOCK_SH)
+    except OSError as error:
+        os.close(descriptor)
+        if error.errno in {errno.EACCES, errno.EAGAIN}:
+            raise ManualCampaignError(
+                f"campaign directory is being reset: {docs_dir}"
+            ) from None
+        raise ManualCampaignError(
+            f"cannot coordinate campaign directory: {docs_dir}"
+        ) from error
+    return descriptor
+
+
+def _release_campaign_directory_lock(descriptor: int) -> None:
+    import fcntl
+
+    try:
+        fcntl.flock(descriptor, fcntl.LOCK_UN)
+    finally:
+        os.close(descriptor)
+
+
+def _missing_ratatui_bindings() -> tuple[str, ...]:
+    missing: list[str] = []
+    for module_name in ("ratatui", "ratatui_py"):
+        try:
+            importlib.import_module(module_name)
+        except Exception:
+            missing.append(module_name)
+    return tuple(missing)
+
+
+def _configure_dashboard_capability(
+    arguments: argparse.Namespace,
+    *,
+    installed: bool,
+) -> bool:
+    """Apply the release-wheel fallback and report whether it changed a run."""
+
+    if not installed or arguments.command not in {"dashboard-snapshot", "run"}:
+        return False
+    missing = _missing_ratatui_bindings()
+    if not missing:
+        return False
+    if arguments.command == "dashboard-snapshot":
+        missing_text = ", ".join(f"{name!r}" for name in missing)
+        raise ManualCampaignError(
+            "dashboard rendering is a contributor feature unless the optional "
+            f"ratatui bindings are installed (missing: {missing_text}); use "
+            "`run --no-dashboard` with a release wheel, or run from a contributor "
+            "checkout built with `just dev-install`"
+        )
+    changed = not arguments.no_dashboard
+    arguments.no_dashboard = True
+    return changed
+
+
+def _manual_static_na_reason(cell: CellSpec) -> str | None:
+    """Return only stable catalog policy exclusions.
+
+    Runtime implementation limits belong under the ordinary worker resource
+    caps rather than becoming controller-specific static N/A rows.
+    """
+
+    return REPORT_CATALOG.static_na_reason(cell)
+
+
+class HelpFormatter(argparse.RawDescriptionHelpFormatter):
+    """Keep examples readable while displaying option defaults."""
+
+    def _get_help_string(self, action: argparse.Action) -> str:
+        text = action.help or ""
+        if (
+            action.default is not None
+            and action.default is not argparse.SUPPRESS
+            and "%(default)" not in text
+            and action.option_strings
+        ):
+            text += " (default: %(default)s)"
+        return text
+
+
+@dataclass(frozen=True, slots=True)
+class ReportSection:
+    """One stable top-level section that can be omitted from a PDF build."""
+
+    identifier: str
+    title: str
+
+
+REPORT_SECTIONS = (
+    ReportSection("scope", "Scope"),
+    ReportSection("recursion", "Current Recursion and Model Lowering"),
+    ReportSection("colour-runtime", "Colour and Runtime Semantics"),
+    ReportSection("methodology", "Benchmark Methodology"),
+    ReportSection("process-matrices", "Standard-Model Process Matrices"),
+    ReportSection("z-ladders", "Z-plus-Jets Evaluator Ladders"),
+    ReportSection("scalar-ladders", "Colour-Singlet Model Ladders"),
+    ReportSection("interpretation", "Interpretation"),
+    ReportSection("worked-zgg", "Worked d dbar -> Z g g Example"),
+    ReportSection(
+        "shared-current-dag",
+        "Shared-Current DAG and Numerical Execution",
+    ),
+    ReportSection("lc-layouts", "Reusable Leading-Colour Execution Layouts"),
+    ReportSection(
+        "execution-modes",
+        "Compiled, Eager, and Recurrence Execution",
+    ),
+    ReportSection("ufo-support", "Supported UFO and Serialized-JSON Models"),
+)
+
+
+class Palette:
+    def __init__(self, enabled: bool) -> None:
+        self.enabled = enabled
+        just_fix_windows_console()
+
+    def paint(self, color: str, value: object, *, bright: bool = False) -> str:
+        text = str(value)
+        if not self.enabled:
+            return text
+        prefix = Style.BRIGHT if bright else ""
+        return f"{prefix}{color}{text}{Style.RESET_ALL}"
+
+    def key(self, value: object) -> str:
+        return self.paint(Fore.CYAN, value, bright=True)
+
+    def success(self, value: object) -> str:
+        return self.paint(Fore.GREEN, value)
+
+    def warning(self, value: object) -> str:
+        return self.paint(Fore.YELLOW, value)
+
+    def failure(self, value: object) -> str:
+        return self.paint(Fore.RED, value)
+
+    def neutral(self, value: object) -> str:
+        return str(value)
+
+
+class _SnapshotProgress(Protocol):
+    def begin(self, *, total: int, attempt: int, maximum_attempts: int) -> None: ...
+
+    def update(self, completed: int, total: int, message: str) -> None: ...
+
+    def end(self, *, success: bool, message: str, elapsed_seconds: float) -> None: ...
+
+    def close(self) -> None: ...
+
+
+@dataclass(slots=True)
+class _RefreshScanProgress:
+    """One compact coloured progress line owned by ``refresh-pdf``."""
+
+    stream: TextIO
+    palette: Palette
+    _active: bool = False
+    _completed: int = 0
+    _total: int = 0
+    _last_width: int = 0
+
+    def begin(self, *, total: int, attempt: int, maximum_attempts: int) -> None:
+        self._active = True
+        self._completed = 0
+        self._total = total
+        self.update(
+            0,
+            total,
+            f"starting snapshot attempt {attempt}/{maximum_attempts}",
+        )
+
+    def update(self, completed: int, total: int, message: str) -> None:
+        self._completed = completed
+        self._total = total
+        fraction = 1.0 if total == 0 else min(1.0, completed / total)
+        width = 28
+        filled = min(width, int(fraction * width))
+        bar = self.palette.key("█" * filled) + "·" * (width - filled)
+        line = (
+            f"{self.palette.key('Scanning campaign artifacts')} "
+            f"[{bar}] {completed:>{len(str(max(total, 1)))}}/{total} {message}"
+        )
+        visible_padding = max(0, self._last_width - len(line))
+        self.stream.write("\r" + line + " " * visible_padding)
+        self.stream.flush()
+        self._last_width = len(line)
+
+    def end(self, *, success: bool, message: str, elapsed_seconds: float) -> None:
+        if not self._active:
+            return
+        color = self.palette.success if success else self.palette.failure
+        suffix = color(f"{message} in {elapsed_seconds:.2f}s")
+        self.update(self._completed, self._total, suffix)
+        self.stream.write("\n")
+        self.stream.flush()
+        self._active = False
+        self._last_width = 0
+
+    def close(self) -> None:
+        if self._active:
+            self.stream.write("\n")
+            self.stream.flush()
+            self._active = False
+            self._last_width = 0
+
+
+def _color_enabled(arguments: argparse.Namespace, *, json_output: bool = False) -> bool:
+    return (
+        not json_output
+        and not bool(getattr(arguments, "no_color", False))
+        and "NO_COLOR" not in os.environ
+    )
+
+
+def _utc_now() -> str:
+    return datetime.now(UTC).isoformat(timespec="seconds").replace("+00:00", "Z")
+
+
+def _atomic_json(path: Path, payload: object, *, sync: bool = True) -> None:
+    temporary: Path | None = None
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp")
+        with temporary.open("x", encoding="ascii") as stream:
+            json.dump(
+                payload,
+                stream,
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            stream.write("\n")
+            stream.flush()
+            if sync:
+                os.fsync(stream.fileno())
+        os.replace(temporary, path)
+    except OSError as error:
+        _raise_disk_full(error, path)
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+
+
+def _fsync_directory(path: Path) -> None:
+    descriptor = os.open(path, os.O_RDONLY)
+    try:
+        os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+def _summary_status(value: str) -> str:
+    normalized = re.sub(r"[^a-z0-9]+", "_", value.strip().lower()).strip("_")
+    if normalized == "cancelled":
+        return "interrupted"
+    if not normalized:
+        raise ManualCampaignError("campaign outcome has an empty status")
+    return normalized
+
+
+def _campaign_summary_categories(
+    *,
+    static_na_ids: Iterable[str] = (),
+    result: CampaignResult | None = None,
+    state: DashboardState | None = None,
+    interrupted: bool = False,
+) -> dict[str, set[str]]:
+    categories: dict[str, set[str]] = {}
+
+    def add(status: str, cell_id: str) -> None:
+        normalized = _summary_status(status)
+        if normalized in _SUMMARY_SUCCESS_STATUSES:
+            return
+        categories.setdefault(normalized, set()).add(cell_id)
+
+    for cell_id in static_na_ids:
+        add("static_na", cell_id)
+    observed_workers = (
+        {}
+        if state is None
+        else {
+            cell_id: worker
+            for cell_id, worker in state.workers.items()
+            if worker.peer_instance is None
+            and cell_id in state.invocation_evidence_ids
+        }
+    )
+    outcome_ids: set[str] = set()
+    if result is not None:
+        for outcome in result.outcomes:
+            if (
+                outcome.status == "cancelled"
+                and outcome.cell_id not in observed_workers
+            ):
+                continue
+            outcome_ids.add(outcome.cell_id)
+            add(outcome.status, outcome.cell_id)
+    if state is not None:
+        workers = tuple(observed_workers.values())
+        for worker in workers:
+            if worker.recycled or worker.cell_id in state.recycled_ids:
+                continue
+            if worker.cell_id in outcome_ids:
+                continue
+            if interrupted and worker.status in _ACTIVE_WORKER_STATUSES:
+                add("interrupted", worker.cell_id)
+            elif worker.status not in _ACTIVE_WORKER_STATUSES:
+                add(worker.status, worker.cell_id)
+    return categories
+
+
+def _has_invocation_summary_evidence(
+    result: CampaignResult | None,
+    state: DashboardState,
+) -> bool:
+    if state.invocation_evidence_ids:
+        return True
+    return result is not None and any(
+        outcome.status != "cancelled" for outcome in result.outcomes
+    )
+
+
+def _validate_existing_summary_directory(path: Path) -> None:
+    if path.is_symlink() or not path.is_dir():
+        raise ManualCampaignError(
+            f"campaign summary target is not a regular directory: {path}"
+        )
+
+
+def _publish_campaign_summary_ids(
+    service: ReportService,
+    categories: Mapping[str, Iterable[str]],
+    *,
+    fail_fast_failure_log: str | None = None,
+) -> tuple[Path, dict[str, int]]:
+    target = service.paths.docs_dir / "campaign_summary_ids"
+    publication_root = service.paths.coordination_root / "campaign-summary-publication"
+    stage: Path | None = None
+    backup: Path | None = None
+    counts: dict[str, int] = {}
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        publication_root.mkdir(parents=True, exist_ok=True)
+        if publication_root.is_symlink() or not publication_root.is_dir():
+            raise ManualCampaignError(
+                "campaign summary staging root is not a regular directory: "
+                f"{publication_root}"
+            )
+        if publication_root.stat().st_dev != target.parent.stat().st_dev:
+            raise ManualCampaignError(
+                "campaign summary cannot be replaced atomically because its "
+                "documentation and coordination roots are on different "
+                f"filesystems: {target.parent} and {publication_root}"
+            )
+        token = uuid.uuid4().hex
+        stage = publication_root / f"{target.name}-{token}.stage"
+        backup = publication_root / f"{target.name}-{token}.backup"
+        stage.mkdir()
+        for raw_status, raw_ids in sorted(categories.items()):
+            status = _summary_status(raw_status)
+            if status in _SUMMARY_SUCCESS_STATUSES:
+                continue
+            cell_ids = tuple(sorted(set(raw_ids)))
+            if not cell_ids:
+                continue
+            path = stage / f"{status}.txt"
+            with path.open("x", encoding="utf-8", newline="\n") as stream:
+                stream.write("".join(f"{cell_id}\n" for cell_id in cell_ids))
+                stream.flush()
+                os.fsync(stream.fileno())
+            counts[status] = len(cell_ids)
+        if fail_fast_failure_log is not None:
+            if not fail_fast_failure_log.strip():
+                raise ManualCampaignError("fail-fast failure log is empty")
+            failure_path = stage / FAIL_FAST_FAILURE_LOG
+            with failure_path.open("x", encoding="utf-8", newline="\n") as stream:
+                stream.write(fail_fast_failure_log.rstrip("\n"))
+                stream.write("\n")
+                stream.flush()
+                os.fsync(stream.fileno())
+        _fsync_directory(stage)
+        with service.store.named_lock("campaign-summary-ids"):
+            moved_old = False
+            if target.exists() or target.is_symlink():
+                _validate_existing_summary_directory(target)
+                os.replace(target, backup)
+                moved_old = True
+            try:
+                os.replace(stage, target)
+                _fsync_directory(target.parent)
+            except BaseException:
+                if moved_old and not target.exists():
+                    os.replace(backup, target)
+                    _fsync_directory(target.parent)
+                raise
+            if moved_old:
+                shutil.rmtree(backup)
+                _fsync_directory(target.parent)
+    except OSError as error:
+        _raise_disk_full(error, target)
+    finally:
+        if stage is not None and stage.exists():
+            shutil.rmtree(stage)
+        if backup is not None and backup.exists() and target.exists():
+            shutil.rmtree(backup)
+    return target.resolve(strict=True), counts
+
+
+def _print_campaign_summary_ids(
+    path: Path,
+    counts: Mapping[str, int],
+    palette: Palette,
+) -> None:
+    print()
+    print(
+        _table(
+            ("campaign summary", "entries"),
+            (
+                (palette.key(status), palette.warning(count))
+                for status, count in sorted(counts.items())
+            )
+            if counts
+            else ((palette.success("non-OK entries"), palette.success(0)),),
+            align={"entries": "r"},
+        )
+    )
+    print(f"Campaign summary IDs: {path}")
+
+
+def _normal(value: str) -> str:
+    return value.strip().lower().replace("-", "_").replace(" ", "_")
+
+
+def _positive_finite_float(value: str) -> float:
+    try:
+        result = float(value)
+    except ValueError as error:
+        raise argparse.ArgumentTypeError("expected a finite number") from error
+    if not math.isfinite(result) or result <= 0.0:
+        raise argparse.ArgumentTypeError("expected a positive finite number")
+    return result
+
+
+def _positive_int(value: str) -> int:
+    try:
+        result = int(value)
+    except ValueError as error:
+        raise argparse.ArgumentTypeError("expected a positive integer") from error
+    if result <= 0:
+        raise argparse.ArgumentTypeError("expected a positive integer")
+    return result
+
+
+def _nonnegative_finite_float(value: str) -> float:
+    try:
+        result = float(value)
+    except ValueError as error:
+        raise argparse.ArgumentTypeError("expected a finite number") from error
+    if not math.isfinite(result) or result < 0.0:
+        raise argparse.ArgumentTypeError("expected a non-negative finite number")
+    return result
+
+
+def _flatten(values: Sequence[Sequence[str]] | None) -> tuple[str, ...]:
+    if not values:
+        return ()
+    flattened = tuple(item for group in values for item in group)
+    if any(_normal(item) in {"*", "all"} for item in flattened):
+        return ()
+    return flattened
+
+
+def _shell_join(arguments: Iterable[object]) -> str:
+    return shlex.join(tuple(str(argument) for argument in arguments))
+
+
+def _table(
+    headers: Sequence[str],
+    rows: Iterable[Sequence[object]],
+    *,
+    align: Mapping[str, str] | None = None,
+    max_width: Mapping[str, int] | None = None,
+) -> str:
+    value = PrettyTable()
+    value.field_names = list(headers)
+    value.hrules = 1
+    value.vrules = 1
+    value.padding_width = 1
+    for header in headers:
+        value.align[header] = "l"
+    if align is not None:
+        for header, direction in align.items():
+            value.align[header] = direction
+    if max_width is not None:
+        for header, width in max_width.items():
+            value.max_width[header] = width
+    for row in rows:
+        value.add_row(list(row))
+    return value.get_string()
+
+
+_MODEL_ALIASES = {
+    "builtin": ModelKey.BUILTIN_SM,
+    "built_in": ModelKey.BUILTIN_SM,
+    "built_in_sm": ModelKey.BUILTIN_SM,
+    "builtin_sm": ModelKey.BUILTIN_SM,
+    "sm": ModelKey.BUILTIN_SM,
+    "ufo": ModelKey.UFO_SM,
+    "sm_ufo": ModelKey.UFO_SM,
+    "ufo_sm": ModelKey.UFO_SM,
+    "external_sm": ModelKey.UFO_SM,
+    "scalar_contact": ModelKey.SCALAR_CONTACT,
+    "scalar_gravity": ModelKey.SCALAR_GRAVITY,
+}
+_ACCURACY_ALIASES = {
+    "lc": Accuracy.LC,
+    "leading_color": Accuracy.LC,
+    "leading_colour": Accuracy.LC,
+    "nlc": Accuracy.NLC,
+    "next_to_leading_color": Accuracy.NLC,
+    "next_to_leading_colour": Accuracy.NLC,
+    "full": Accuracy.FULL,
+    "full_color": Accuracy.FULL,
+    "full_colour": Accuracy.FULL,
+}
+_MODE_ALIASES = {
+    "amplicol": ExecutionMode.AMPLICOL,
+    "legacy": ExecutionMode.AMPLICOL,
+    "recurrence": ExecutionMode.RECURRENCE,
+    "ampli_col": ExecutionMode.RECURRENCE,
+    "compiled": ExecutionMode.COMPILED,
+    "eager": ExecutionMode.EAGER,
+    "on_the_fly": ExecutionMode.ON_THE_FLY,
+    "onthefly": ExecutionMode.ON_THE_FLY,
+    "otf": ExecutionMode.ON_THE_FLY,
+}
+_WORKLOAD_ALIASES = {
+    "non_union_flow": Workload.SELECTED_FLOW,
+    "selected_flow": Workload.SELECTED_FLOW,
+    "single_flow": Workload.SELECTED_FLOW,
+    "single_flow_hel_sum": Workload.SELECTED_FLOW,
+    "topology_replay": Workload.SELECTED_FLOW,
+    "union_flow": Workload.ALL_FLOW,
+    "all_flow": Workload.ALL_FLOW,
+    "all_flows": Workload.ALL_FLOW,
+    "all_flows_single_hel": Workload.ALL_FLOW,
+    "all_flow_union": Workload.ALL_FLOW,
+    "contracted": Workload.CONTRACTED,
+}
+
+
+def _dataset_aliases(catalog: ReportCatalog) -> dict[str, frozenset[str]]:
+    dataset_ids = frozenset(cell.dataset_id for cell in catalog.measurement_cells())
+    aliases: dict[str, frozenset[str]] = {
+        _normal(dataset): frozenset({dataset}) for dataset in dataset_ids
+    }
+    aliases.update(
+        {
+            "z": frozenset(
+                dataset for dataset in dataset_ids if dataset.startswith("z_")
+            ),
+            "z_table": frozenset(
+                dataset for dataset in dataset_ids if dataset.startswith("z_")
+            ),
+            "matrix": frozenset(
+                dataset for dataset in dataset_ids if dataset.startswith("matrix_")
+            ),
+            "matrix_table": frozenset(
+                dataset for dataset in dataset_ids if dataset.startswith("matrix_")
+            ),
+            "matrix_best": frozenset(
+                dataset
+                for dataset in dataset_ids
+                if dataset.startswith("matrix_") and "_builtin_sm_" in dataset
+            ),
+            "reference": frozenset(
+                dataset
+                for dataset in dataset_ids
+                if dataset.startswith("reference_amplicol_")
+            ),
+            "scalar": frozenset(
+                dataset for dataset in dataset_ids if dataset.startswith("scalar_")
+            ),
+        }
+    )
+    return aliases
+
+
+def _invalid_value(
+    option: str,
+    value: str,
+    allowed: Iterable[str],
+) -> ManualCampaignError:
+    choices = tuple(sorted(set(allowed)))
+    suggestions = difflib.get_close_matches(_normal(value), choices, n=3, cutoff=0.45)
+    suffix = "" if not suggestions else f"; did you mean {', '.join(suggestions)}?"
+    if len(choices) > 24:
+        displayed = (
+            *choices[:24],
+            f"… {len(choices) - 24} more (use --help or a dry run to browse)",
+        )
+    else:
+        displayed = choices
+    return ManualCampaignError(
+        f"{option}: unsupported value {value!r}{suffix}\n"
+        + _table(("option", "allowed values"), ((option, ", ".join(displayed)),))
+    )
+
+
+def _empty_selection_error(
+    arguments: argparse.Namespace,
+    catalog: ReportCatalog,
+) -> ManualCampaignError:
+    provided = tuple(
+        option
+        for attribute, option in (
+            ("table", "--table"),
+            ("process_id", "--process-id"),
+            ("multiplicity", "--multiplicity"),
+            ("color_approximation", "--color-approximation"),
+            ("generation_mode", "--generation-mode"),
+            ("generation_engine", "--generation-engine"),
+            ("model", "--model"),
+            ("variant", "--variant"),
+            ("cell_id", "--cell-id"),
+            ("cell_id_file", "--cell-id-file"),
+        )
+        if getattr(arguments, attribute, None)
+    )
+    variants = sorted(
+        {
+            str(cell.variant)
+            for cell in catalog.measurement_cells()
+            if cell.variant is not None
+        }
+    )
+    multiplicities = sorted({cell.n_final for cell in catalog.measurement_cells()})
+    processes = tuple(
+        f"{family.identifier}:{family.key}" for family in PROCESS_FAMILIES
+    )
+    rows = (
+        (
+            "--table",
+            "z_table, matrix_table, matrix_best, scalar_contact, "
+            "scalar_gravity, reference",
+        ),
+        ("--process-id", ", ".join(processes)),
+        ("--multiplicity", ", ".join(str(value) for value in multiplicities)),
+        ("--color-approximation", "lc, nlc, full"),
+        ("--generation-mode", "non-union-flow, union-flow, contracted"),
+        (
+            "--generation-engine",
+            "amplicol, recurrence, compiled, eager, on-the-fly (otf)",
+        ),
+        ("--model", "built_in, sm_ufo, scalar_contact, scalar_gravity"),
+        ("--variant", ", ".join(variants)),
+        (
+            "--cell-id",
+            "one exact canonical cell ID (see --help or a broader dry run)",
+        ),
+        (
+            "--cell-id-file",
+            "UTF-8 files containing one exact canonical cell ID per line",
+        ),
+    )
+    suggestion = (
+        "Remove one selector at a time to find the conflicting dimension"
+        if not provided
+        else "Try removing one of " + ", ".join(provided)
+    )
+    return ManualCampaignError(
+        "the selector intersection contains no catalog entries. "
+        f"{suggestion}; wildcard `*`/`all` is also accepted.\n"
+        + _table(
+            ("selector", "canonical values / useful aliases"),
+            rows,
+            max_width={"canonical values / useful aliases": 96},
+        )
+    )
+
+
+def _resolve_map(
+    option: str,
+    raw_values: Sequence[str],
+    aliases: Mapping[str, Any],
+) -> frozenset[Any]:
+    resolved: set[Any] = set()
+    for raw in raw_values:
+        key = _normal(raw)
+        try:
+            resolved.add(aliases[key])
+        except KeyError:
+            raise _invalid_value(option, raw, aliases) from None
+    return frozenset(resolved)
+
+
+def _resolve_datasets(
+    raw_values: Sequence[str],
+    catalog: ReportCatalog,
+) -> frozenset[str]:
+    aliases = _dataset_aliases(catalog)
+    resolved: set[str] = set()
+    for raw in raw_values:
+        key = _normal(raw)
+        try:
+            resolved.update(aliases[key])
+        except KeyError:
+            raise _invalid_value("--table", raw, aliases) from None
+    return frozenset(resolved)
+
+
+def _resolve_processes(
+    raw_values: Sequence[str],
+) -> tuple[frozenset[str], frozenset[str]]:
+    by_id = {str(family.identifier): family.key for family in PROCESS_FAMILIES}
+    by_key = {_normal(family.key): family.key for family in PROCESS_FAMILIES}
+    process_keys: set[str] = set()
+    concrete: set[str] = set()
+    allowed = {**by_id, **by_key}
+    for raw in raw_values:
+        key = _normal(raw)
+        if key in allowed:
+            process_keys.add(allowed[key])
+        elif ">" in raw:
+            concrete.add(" ".join(raw.split()))
+        else:
+            raise _invalid_value("--process-id", raw, allowed) from None
+    return frozenset(process_keys), frozenset(concrete)
+
+
+def _cell_ids_from_files(
+    raw_groups: Sequence[Sequence[Path]] | None,
+    *,
+    known_cells: frozenset[str],
+) -> frozenset[str]:
+    selected: set[str] = set()
+    for group in raw_groups or ():
+        for raw_path in group:
+            path = Path(raw_path).expanduser()
+            try:
+                lines = path.read_text(encoding="utf-8").splitlines()
+            except (OSError, UnicodeError) as error:
+                raise ManualCampaignError(
+                    f"--cell-id-file could not read {path}: {error}"
+                ) from error
+            for line_number, line in enumerate(lines, start=1):
+                value = line.strip()
+                if not value or value.startswith("#"):
+                    continue
+                location = f"{path}:{line_number}"
+                if _normal(value) in {"*", "all"}:
+                    raise ManualCampaignError(
+                        f"{location}: wildcards are not allowed in a cell-ID file"
+                    )
+                if value not in known_cells:
+                    suggestions = difflib.get_close_matches(
+                        value,
+                        sorted(known_cells),
+                        n=3,
+                        cutoff=0.45,
+                    )
+                    suffix = (
+                        ""
+                        if not suggestions
+                        else f"; did you mean {', '.join(suggestions)}?"
+                    )
+                    raise ManualCampaignError(
+                        f"{location}: unknown canonical cell ID {value!r}{suffix}"
+                    )
+                selected.add(value)
+    return frozenset(selected)
+
+
+def selection_from_arguments(
+    arguments: argparse.Namespace,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSelection, tuple[CellSpec, ...]]:
+    raw_tables = _flatten(getattr(arguments, "table", None))
+    raw_processes = _flatten(getattr(arguments, "process_id", None))
+    raw_multiplicities = _flatten(getattr(arguments, "multiplicity", None))
+    raw_accuracies = _flatten(getattr(arguments, "color_approximation", None))
+    raw_workloads = _flatten(getattr(arguments, "generation_mode", None))
+    raw_modes = _flatten(getattr(arguments, "generation_engine", None))
+    raw_models = _flatten(getattr(arguments, "model", None))
+    raw_variants = _flatten(getattr(arguments, "variant", None))
+    raw_cell_id_groups = getattr(arguments, "cell_id", None)
+    raw_cell_ids = _flatten(raw_cell_id_groups)
+    direct_cell_wildcard = any(
+        _normal(value) in {"*", "all"}
+        for group in raw_cell_id_groups or ()
+        for value in group
+    )
+
+    multiplicities: set[int] = set()
+    for raw in raw_multiplicities:
+        try:
+            value = int(raw)
+        except ValueError:
+            raise ManualCampaignError(
+                f"--multiplicity expects positive integers, not {raw!r}"
+            ) from None
+        if value < 1:
+            raise ManualCampaignError("--multiplicity values must be positive")
+        multiplicities.add(value)
+
+    process_keys, processes = _resolve_processes(raw_processes)
+    known_variants = frozenset(
+        cell.variant for cell in catalog.measurement_cells() if cell.variant is not None
+    )
+    variants: set[str] = set()
+    for raw in raw_variants:
+        matches = {
+            variant for variant in known_variants if _normal(variant) == _normal(raw)
+        }
+        if not matches:
+            raise _invalid_value("--variant", raw, map(_normal, known_variants))
+        variants.update(matches)
+
+    known_cells = frozenset(cell.cell_id for cell in catalog.measurement_cells())
+    cell_ids: set[str] = set()
+    for raw in raw_cell_ids:
+        normalized = raw.strip()
+        if _normal(normalized) in {"*", "all"}:
+            continue
+        if normalized not in known_cells:
+            raise _invalid_value("--cell-id", normalized, known_cells)
+        cell_ids.add(normalized)
+    file_cell_ids = _cell_ids_from_files(
+        getattr(arguments, "cell_id_file", None),
+        known_cells=known_cells,
+    )
+    if (
+        getattr(arguments, "cell_id_file", None)
+        and not file_cell_ids
+        and not raw_cell_ids
+        and not direct_cell_wildcard
+    ):
+        raise ManualCampaignError(
+            "--cell-id-file inputs contain no canonical cell IDs"
+        )
+    if not direct_cell_wildcard:
+        cell_ids.update(file_cell_ids)
+
+    resolved_modes = _resolve_map(
+        "--generation-engine",
+        raw_modes,
+        _MODE_ALIASES,
+    )
+    resolved_models = _resolve_map("--model", raw_models, _MODEL_ALIASES)
+    selection = CellSelection(
+        datasets=_resolve_datasets(raw_tables, catalog),
+        modes=resolved_modes,
+        # Legacy AmpliCol represents the built-in SM but stores model=None.
+        # Apply the friendly model filter below so built_in + amplicol works.
+        models=frozenset(),
+        accuracies=_resolve_map(
+            "--color-approximation",
+            raw_accuracies,
+            _ACCURACY_ALIASES,
+        ),
+        process_keys=process_keys,
+        processes=processes,
+        multiplicities=frozenset(multiplicities),
+        variants=frozenset(variants),
+        workloads=_resolve_map(
+            "--generation-mode",
+            raw_workloads,
+            _WORKLOAD_ALIASES,
+        ),
+        cell_ids=frozenset(cell_ids),
+    )
+    selected = list(select_cells(selection, catalog=catalog))
+
+    normalized_tables = {_normal(value) for value in raw_tables}
+    if ExecutionMode.AMPLICOL in resolved_modes:
+        supplemental_datasets: frozenset[str] = frozenset()
+        supplemental_process_keys = selection.process_keys
+        supplemental_workloads = selection.workloads
+        supplemental_accuracies = selection.accuracies
+        if "z" in normalized_tables or "z_table" in normalized_tables:
+            supplemental_datasets = frozenset({"reference_amplicol_lc"})
+            supplemental_process_keys = frozenset({"dd_z_jets"})
+            supplemental_workloads = frozenset({Workload.SELECTED_FLOW})
+            supplemental_accuracies = frozenset({Accuracy.LC})
+        elif normalized_tables.intersection({"matrix", "matrix_table", "matrix_best"}):
+            supplemental_datasets = frozenset(
+                {
+                    "reference_amplicol_lc",
+                    "reference_amplicol_nlc",
+                    "reference_amplicol_full",
+                }
+            )
+        if supplemental_datasets:
+            supplement = CellSelection(
+                datasets=supplemental_datasets,
+                modes=frozenset({ExecutionMode.AMPLICOL}),
+                accuracies=supplemental_accuracies,
+                process_keys=supplemental_process_keys,
+                processes=selection.processes,
+                multiplicities=selection.multiplicities,
+                variants=selection.variants,
+                workloads=supplemental_workloads,
+                cell_ids=selection.cell_ids,
+            )
+            selected.extend(select_cells(supplement, catalog=catalog))
+
+    if resolved_models:
+        selected = [
+            cell
+            for cell in selected
+            if cell.measurement.model in resolved_models
+            or (
+                cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+                and ModelKey.BUILTIN_SM in resolved_models
+            )
+        ]
+    cells = tuple(
+        sorted(
+            {cell.cell_id: cell for cell in selected}.values(),
+            key=lambda item: item.cell_id,
+        )
+    )
+    if not cells:
+        raise _empty_selection_error(arguments, catalog)
+    return selection, cells
+
+
+def _model_cli_source(cell: CellSpec, repo_root: Path) -> str:
+    from .runner import _model_source_path
+
+    model = cell.measurement.model
+    if model is None:
+        return "<legacy-AmpliCol-has-no-pyamplicol-model>"
+    source = _model_source_path(repo_root, model)
+    return "built-in-sm" if source is None else os.fspath(source)
+
+
+def _reproduction_root(artifact_root: Path, cell: CellSpec) -> Path:
+    return artifact_root / "manual-reproductions" / cell.cell_id
+
+
+def _pyamplicol_cli(repo_root: Path) -> tuple[str, ...]:
+    """Return a cwd-independent source CLI prefix for contributor installs."""
+
+    source_package = repo_root / "src/pyamplicol"
+    executable = repo_root / ".venv/bin/pyamplicol"
+    if not source_package.is_dir() or not executable.is_file():
+        return (sys.executable, "-m", "pyamplicol")
+    return (
+        "env",
+        f"PYTHONPATH={os.fspath((repo_root / 'src').resolve(strict=False))}",
+        os.fspath(executable.expanduser().resolve(strict=False)),
+    )
+
+
+def _materialize_reproduction_momenta(
+    cell: CellSpec,
+    *,
+    artifact_root: Path,
+    momenta: object,
+) -> Path:
+    """Publish the exact recorded report points for public recurrence."""
+
+    path = _reproduction_root(artifact_root, cell) / "momenta.json"
+    _atomic_json(path, momenta)
+    return path
+
+
+@dataclass(frozen=True, slots=True)
+class ReproductionRecipe:
+    kind: str
+    prepare: tuple[str, ...] | None
+    generate: tuple[str, ...] | None
+    profile: tuple[str, ...] | None
+    note: str
+    exact: bool
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "abi": PORTABLE_CURRENT_REPRODUCTION_RECIPE_ABI,
+            "kind": self.kind,
+            "prepare": None if self.prepare is None else list(self.prepare),
+            "generate": None if self.generate is None else list(self.generate),
+            "profile": None if self.profile is None else list(self.profile),
+            "note": self.note,
+            "exact": self.exact,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ReproductionSettings:
+    """Effective invocation settings used for active public CLI recipes."""
+
+    cores: int = DEFAULT_CORES_PER_WORKER
+    target_runtime: float = DEFAULT_TARGET_RUNTIME_SECONDS
+    batch_size: int = DEFAULT_BATCH_SIZE
+    warmups: int = DEFAULT_WARMUP_RUNS
+    minimum_samples: int = DEFAULT_MINIMUM_SAMPLES
+
+
+def _validated_recipe_numerical_relation_fallback(
+    provenance: object,
+) -> Mapping[str, object] | None:
+    if not isinstance(provenance, Mapping):
+        return None
+    raw = provenance.get("numerical_relation_fallback")
+    if raw is None:
+        return None
+    from pyamplicol.generation.recurrence_numerical_current_warmup import (
+        EVIDENCE_ENVELOPE_FALLBACK_REASON,
+        NUMERICAL_RELATION_FALLBACK_ABI,
+        RecurrenceNumericalEvidenceGeometry,
+    )
+
+    expected_fields = {
+        "abi",
+        "requested_mode",
+        "effective_mode",
+        "effective_reuse_state",
+        "reason",
+        "geometry",
+        "certified_relation_count",
+        "applied_relation_count",
+    }
+    geometry_fields = {
+        "current_count",
+        "component_count",
+        "candidate_probe_count",
+        "verification_probe_count",
+        "runtime_parameter_count",
+        "scalar_count",
+        "row_count",
+    }
+    geometry = raw.get("geometry") if isinstance(raw, Mapping) else None
+    if (
+        not isinstance(raw, Mapping)
+        or set(raw) != expected_fields
+        or raw.get("abi") != NUMERICAL_RELATION_FALLBACK_ABI
+        or raw.get("requested_mode") != "certified-reuse"
+        or raw.get("effective_mode") != "off"
+        or raw.get("effective_reuse_state") != "disabled"
+        or raw.get("reason") != EVIDENCE_ENVELOPE_FALLBACK_REASON
+        or raw.get("certified_relation_count") != 0
+        or isinstance(raw.get("certified_relation_count"), bool)
+        or raw.get("applied_relation_count") != 0
+        or isinstance(raw.get("applied_relation_count"), bool)
+        or not isinstance(geometry, Mapping)
+        or set(geometry) != geometry_fields
+        or any(type(geometry.get(field)) is not int for field in geometry_fields)
+    ):
+        raise ManualCampaignError(
+            "measurement numerical-relation fallback provenance is malformed"
+        )
+    try:
+        expected_geometry = RecurrenceNumericalEvidenceGeometry.from_counts(
+            current_count=int(geometry["current_count"]),
+            component_count=int(geometry["component_count"]),
+            candidate_probe_count=int(geometry["candidate_probe_count"]),
+            verification_probe_count=int(geometry["verification_probe_count"]),
+            runtime_parameter_count=int(geometry["runtime_parameter_count"]),
+        ).to_json_dict()
+    except (OverflowError, TypeError, ValueError) as error:
+        raise ManualCampaignError(
+            "measurement numerical-relation fallback provenance is malformed"
+        ) from error
+    if dict(geometry) != expected_geometry:
+        raise ManualCampaignError(
+            "measurement numerical-relation fallback geometry is inconsistent"
+        )
+    return raw
+
+
+def reproduction_recipe(
+    cell: CellSpec,
+    *,
+    repo_root: Path,
+    artifact_root: Path,
+    artifact_path: str = "<ARTIFACT_DIR>",
+    cores: int = DEFAULT_CORES_PER_WORKER,
+    target_runtime: float = DEFAULT_TARGET_RUNTIME_SECONDS,
+    batch_size: int = DEFAULT_BATCH_SIZE,
+    warmups: int = DEFAULT_WARMUP_RUNS,
+    minimum_samples: int = DEFAULT_MINIMUM_SAMPLES,
+    measurement: Mapping[str, object] | None = None,
+) -> ReproductionRecipe:
+    if cell.measurement.execution_mode is ExecutionMode.AMPLICOL:
+        return ReproductionRecipe(
+            kind="legacy-report-adapter",
+            prepare=None,
+            generate=None,
+            profile=None,
+            note="Original AmpliCol has no public pyamplicol CLI subcommand.",
+            exact=False,
+        )
+    cli = _pyamplicol_cli(repo_root)
+    if artifact_path == "<ARTIFACT_DIR>":
+        artifact_path = os.fspath(_reproduction_root(artifact_root, cell) / "artifact")
+    model_cache = _reproduction_root(artifact_root, cell) / "model-cache"
+    provenance = (
+        measurement.get("provenance") if isinstance(measurement, Mapping) else None
+    )
+    numerical_relation_fallback = _validated_recipe_numerical_relation_fallback(
+        provenance
+    )
+    requested = (
+        provenance.get("requested_config") if isinstance(provenance, Mapping) else None
+    )
+    requested_model = requested.get("model") if isinstance(requested, Mapping) else None
+    recorded_model_source = (
+        requested_model.get("source") if isinstance(requested_model, Mapping) else None
+    )
+    raw_model_source = (
+        recorded_model_source
+        if isinstance(recorded_model_source, str) and recorded_model_source
+        else _model_cli_source(cell, repo_root)
+    )
+    artifact_record = (
+        measurement.get("artifact") if isinstance(measurement, Mapping) else None
+    )
+    process_selector = cell.process
+    completed = (
+        isinstance(measurement, Mapping)
+        and measurement.get("status") == ResultStatus.OK.value
+        and isinstance(artifact_record, Mapping)
+        and isinstance(artifact_record.get("path"), str)
+        and isinstance(artifact_record.get("process_id"), str)
+    )
+    prepare: tuple[str, ...] | None = None
+    model_source = raw_model_source
+    prepared_execution = cell.measurement.execution_mode in {
+        ExecutionMode.EAGER,
+        ExecutionMode.RECURRENCE,
+        ExecutionMode.ON_THE_FLY,
+    }
+    if prepared_execution and cell.measurement.model in {
+        ModelKey.BUILTIN_SM,
+        ModelKey.UFO_SM,
+    }:
+        prepared_source = _model_cli_source(cell, repo_root)
+        prepared_stem = (
+            "built-in-sm" if cell.measurement.model is ModelKey.BUILTIN_SM else "ufo-sm"
+        )
+        prepared_path = (
+            _reproduction_root(artifact_root, cell)
+            / "prepared-models"
+            / f"{prepared_stem}-jit-o2.pyamplicol-model"
+        )
+        prepare = (
+            *cli,
+            "model",
+            "compile",
+            prepared_source,
+            os.fspath(prepared_path),
+            "--model-cache-dir",
+            os.fspath(model_cache),
+            "--model-cache",
+            "--backend",
+            "jit",
+            "--cores",
+            str(cores),
+            "--jit-optimization-level",
+            "2",
+            "--set",
+            "evaluator.execution_mode=recurrence",
+            "--json",
+            "--color",
+            "always",
+            "--progress",
+            "tty",
+        )
+        model_source = os.fspath(prepared_path)
+    on_the_fly = cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+    layout = (
+        "topology-replay"
+        if on_the_fly
+        else (
+            "all-flow-union"
+            if cell.workload is Workload.ALL_FLOW
+            else "topology-replay"
+        )
+    )
+    numerical_reuse_flag = (
+        "--no-numerical-current-reuse"
+        if on_the_fly or numerical_relation_fallback is not None
+        else "--numerical-current-reuse"
+    )
+    generate = (
+        *cli,
+        "generate",
+        cell.process,
+        artifact_path,
+        "--model",
+        model_source,
+        "--model-cache",
+        "--model-cache-dir",
+        os.fspath(model_cache),
+        "--color-accuracy",
+        cell.measurement.accuracy.value,
+        "--lc-flow-layout",
+        layout,
+        "--execution-mode",
+        cell.measurement.execution_mode.value,
+        "--backend",
+        cell.measurement.backend,
+        "--workers",
+        str(cores),
+        "--cores",
+        str(cores),
+        "--batch-size",
+        str(batch_size),
+        "--output-chunk-size",
+        "512",
+        "--horner-iterations",
+        "10",
+        "--cpe-iterations",
+        "none",
+        "--max-horner-variables",
+        "1000",
+        "--max-common-pair-cache-entries",
+        "5000000",
+        "--max-common-pair-distance",
+        "1000",
+        "--jit-optimization-level",
+        str(cell.measurement.jit_optimization_level or 2),
+        "--cpp-optimization",
+        "O3",
+        "--no-emit-api-bundle" if on_the_fly else "--emit-api-bundle",
+        "--no-validation" if on_the_fly else "--validation",
+        "--validation-samples",
+        "1",
+        "--validation-seed",
+        "12345",
+        "--relative-tolerance",
+        "1e-12",
+        "--absolute-tolerance",
+        "1e-300",
+        "--no-post-build-validation",
+        numerical_reuse_flag,
+        "--force",
+        "--color",
+        "always",
+        "--progress",
+        "tty",
+    )
+    selector_contract = (
+        measurement.get("selector_contract")
+        if isinstance(measurement, Mapping)
+        else None
+    )
+    selector: tuple[str, ...] = ()
+    if isinstance(selector_contract, Mapping):
+        if cell.workload is Workload.SELECTED_FLOW:
+            raw_flows = selector_contract.get("selected_color_flow_ids")
+            if isinstance(raw_flows, Sequence) and not isinstance(
+                raw_flows, (str, bytes)
+            ):
+                selector = tuple(
+                    argument
+                    for value in raw_flows
+                    for argument in ("--color-flow", str(value))
+                )
+        elif cell.workload is Workload.ALL_FLOW:
+            try:
+                from .runner import SelectorContract
+
+                raw_helicities: object = SelectorContract.from_mapping(
+                    selector_contract
+                ).runtime_all_flow_helicity_ids
+            except (TypeError, ValueError):
+                raw_helicities = ()
+            if isinstance(raw_helicities, Sequence):
+                selector = tuple(
+                    argument
+                    for value in raw_helicities
+                    for argument in ("--helicity", str(value))
+                )
+    selector_ready = cell.workload is Workload.CONTRACTED or bool(selector)
+    recorded_momenta = (
+        provenance.get("report_momenta") if isinstance(provenance, Mapping) else None
+    )
+    momenta_ready = isinstance(recorded_momenta, Sequence) and not isinstance(
+        recorded_momenta,
+        (str, bytes),
+    )
+    exact = (
+        completed
+        and cell.measurement.execution_mode
+        in {ExecutionMode.RECURRENCE, ExecutionMode.ON_THE_FLY}
+        and selector_ready
+        and momenta_ready
+    )
+    momenta: tuple[str, ...] = ()
+    if exact:
+        momenta = (
+            "--momenta",
+            os.fspath(
+                _materialize_reproduction_momenta(
+                    cell,
+                    artifact_root=artifact_root,
+                    momenta=recorded_momenta,
+                )
+            ),
+        )
+    profile = (
+        *cli,
+        "profile",
+        artifact_path,
+        "--process",
+        process_selector,
+        "--target-runtime",
+        f"{target_runtime:g}",
+        "--batch-size",
+        str(batch_size),
+        "--warmup-runs",
+        str(warmups),
+        "--minimum-samples",
+        str(minimum_samples),
+        "--precision",
+        "16",
+        *momenta,
+        *selector,
+        "--json",
+        "--color",
+        "always",
+        "--progress",
+        "tty",
+    )
+    if cell.measurement.execution_mode is ExecutionMode.COMPILED:
+        kind = "public-cli+precompiled-generation+paired-arena-exceptions"
+        note = (
+            "Diagnostic only: the report injects a precompiled model outside "
+            "generation_seconds and publishes a paired private Arena profile; "
+            "the public commands do not reproduce either timing boundary."
+        )
+    elif cell.measurement.execution_mode is ExecutionMode.EAGER:
+        kind = "public-cli+paired-arena-profile-exception"
+        note = (
+            "Generation uses the public CLI path. Profile is diagnostic only: "
+            "the report publishes a paired private Arena timing boundary."
+        )
+    elif exact:
+        kind = "public-cli-exact"
+        note = (
+            "Exact completed-cell public commands with the published stable "
+            "selector and materialized report momenta."
+        )
+    else:
+        kind = "public-cli-template"
+        note = (
+            "Prepare (when shown) and generate are runnable. Profile is a "
+            "template only: its stable flow/helicity selector and exact "
+            "momenta are published after successful generation/measurement."
+        )
+    if numerical_relation_fallback is not None:
+        kind += "+effective-reuse-off-fallback"
+        note += (
+            " The measured generation took the authenticated "
+            "evidence-envelope fallback: numerical-current reuse was effectively "
+            "disabled, so the reproduction command uses "
+            "--no-numerical-current-reuse."
+        )
+    if prepare is not None:
+        kind += "+model-compile-prerequisite"
+    return ReproductionRecipe(
+        kind=kind,
+        prepare=prepare,
+        generate=generate,
+        profile=profile,
+        note=note,
+        exact=exact,
+    )
+
+
+def _git_directory(repo_root: Path) -> Path:
+    git_marker = repo_root / ".git"
+    if git_marker.is_file():
+        text = git_marker.read_text(encoding="ascii").strip()
+        prefix = "gitdir:"
+        if not text.startswith(prefix):
+            raise ManualCampaignError(".git worktree marker is malformed")
+        git_dir = Path(text[len(prefix) :].strip())
+        if not git_dir.is_absolute():
+            git_dir = (repo_root / git_dir).resolve(strict=False)
+    else:
+        git_dir = git_marker
+    if not git_dir.is_dir():
+        raise ManualCampaignError("checkout Git metadata directory is unavailable")
+    return git_dir
+
+
+def _git_common_directory(git_dir: Path) -> Path:
+    commondir = git_dir / "commondir"
+    if not commondir.is_file():
+        return git_dir
+    return (git_dir / commondir.read_text(encoding="ascii").strip()).resolve(
+        strict=False
+    )
+
+
+def _repo_head(repo_root: Path) -> str:
+    """Read the checkout revision without invoking Git."""
+
+    git_dir = _git_directory(repo_root)
+    head = (git_dir / "HEAD").read_text(encoding="ascii").strip()
+    if head.startswith("ref: "):
+        reference = head[5:]
+        loose = git_dir / reference
+        if loose.is_file():
+            head = loose.read_text(encoding="ascii").strip()
+        else:
+            common_dir = _git_common_directory(git_dir)
+            common_loose = common_dir / reference
+            if common_loose.is_file():
+                head = common_loose.read_text(encoding="ascii").strip()
+            else:
+                packed = common_dir / "packed-refs"
+                value = None
+                if packed.is_file():
+                    for line in packed.read_text(encoding="ascii").splitlines():
+                        if line.startswith(("#", "^")):
+                            continue
+                        candidate, separator, name = line.partition(" ")
+                        if separator and name == reference:
+                            value = candidate
+                            break
+                if value is None:
+                    raise ManualCampaignError(
+                        f"cannot resolve Git reference {reference!r}"
+                    )
+                head = value
+    if len(head) != 40 or any(
+        character not in "0123456789abcdef" for character in head
+    ):
+        raise ManualCampaignError("checkout HEAD is not a lowercase 40-hex revision")
+    return head
+
+
+def _commit_tree_marker(repo_root: Path, revision: str) -> str:
+    """Read HEAD's tree, using one Git query only when the commit is packed."""
+
+    common_dir = _git_common_directory(_git_directory(repo_root))
+    object_path = common_dir / "objects" / revision[:2] / revision[2:]
+    try:
+        raw = zlib.decompress(object_path.read_bytes())
+    except (OSError, zlib.error):
+        # Ordinary clones and repositories after ``git gc`` store commits in
+        # pack files.  Parsing Git's pack format here would duplicate Git and
+        # be substantially more fragile than this single read-only fallback.
+        try:
+            completed = subprocess.run(
+                ("git", "rev-parse", "--verify", f"{revision}^{{tree}}"),
+                cwd=repo_root,
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=15,
+            )
+        except (OSError, subprocess.SubprocessError):
+            return f"manual-revision:{revision}"
+        tree = completed.stdout.strip()
+        if completed.returncode == 0 and _FULL_SOURCE_REVISION.fullmatch(tree):
+            return tree
+        return f"manual-revision:{revision}"
+    _header, separator, body = raw.partition(b"\0")
+    if not separator:
+        return f"manual-revision:{revision}"
+    for line in body.splitlines():
+        if not line.startswith(b"tree "):
+            continue
+        value = line[5:].decode("ascii", errors="ignore")
+        if len(value) == 40 and all(
+            character in "0123456789abcdef" for character in value
+        ):
+            return value
+    return f"manual-revision:{revision}"
+
+
+def _index_tree_marker(
+    entries: Sequence[tuple[bytes, int, bytes]],
+) -> str:
+    """Build Git's tree identity from index object IDs, never file contents."""
+
+    root: dict[bytes, Any] = {}
+    for raw_path, indexed_mode, object_id in entries:
+        parts = raw_path.split(b"/")
+        if not parts or any(part in {b"", b".", b".."} for part in parts):
+            raise ManualCampaignError("checkout index contains an unsafe path")
+        node = root
+        for part in parts[:-1]:
+            existing = node.get(part)
+            if existing is None:
+                child: dict[bytes, Any] = {}
+                node[part] = child
+                node = child
+            elif isinstance(existing, dict):
+                node = existing
+            else:
+                raise ManualCampaignError(
+                    "checkout index contains a file/directory path collision"
+                )
+        leaf = parts[-1]
+        if leaf in node:
+            raise ManualCampaignError("checkout index contains duplicate paths")
+        kind = indexed_mode & 0o170000
+        if kind == 0o100000:
+            tree_mode = 0o100755 if indexed_mode & 0o111 else 0o100644
+        elif kind in {0o120000, 0o160000}:
+            tree_mode = kind
+        else:
+            raise ManualCampaignError(
+                f"checkout index contains unsupported mode {indexed_mode:o}"
+            )
+        node[leaf] = (tree_mode, object_id)
+
+    def encode_tree(node: Mapping[bytes, Any]) -> bytes:
+        records: list[bytes] = []
+        ordered = sorted(
+            node.items(),
+            key=lambda item: item[0] + (b"/" if isinstance(item[1], dict) else b""),
+        )
+        for name, value in ordered:
+            if isinstance(value, dict):
+                mode = b"40000"
+                object_id = encode_tree(value)
+            else:
+                indexed_mode, object_id = value
+                mode = f"{indexed_mode:o}".encode("ascii")
+            records.append(mode + b" " + name + b"\0" + object_id)
+        payload = b"".join(records)
+        # SHA-1 here is Git's tree-object address over index metadata.  No
+        # worktree or performance artifact bytes are read or hashed.
+        return hashlib.sha1(
+            b"tree " + str(len(payload)).encode("ascii") + b"\0" + payload,
+            usedforsecurity=False,
+        ).digest()
+
+    return encode_tree(root).hex()
+
+
+def _index_metadata_dirty_paths(
+    repo_root: Path,
+    *,
+    committed_tree: str | None = None,
+) -> tuple[str, ...]:
+    """Check index/worktree metadata and index-vs-HEAD with a packed-HEAD fallback."""
+
+    index_path = _git_directory(repo_root) / "index"
+    try:
+        data = index_path.read_bytes()
+    except OSError as error:
+        raise ManualCampaignError(f"checkout index is unreadable: {error}") from error
+    if len(data) < 12:
+        raise ManualCampaignError("checkout index is truncated")
+    signature, version, count = struct.unpack("!4sII", data[:12])
+    if signature != b"DIRC" or version not in {2, 3}:
+        raise ManualCampaignError(
+            f"unsupported checkout index format: signature={signature!r}, "
+            f"version={version}"
+        )
+    offset = 12
+    tracked: set[str] = set()
+    dirty: list[str] = []
+    tree_entries: list[tuple[bytes, int, bytes]] = []
+    unmerged = False
+    for _entry in range(count):
+        start = offset
+        if offset + 62 > len(data):
+            raise ManualCampaignError("checkout index entry is truncated")
+        fields = struct.unpack("!10I20sH", data[offset : offset + 62])
+        offset += 62
+        mtime_seconds, mtime_nanoseconds = fields[2], fields[3]
+        indexed_mode, indexed_size, flags = fields[6], fields[9], fields[11]
+        object_id = fields[10]
+        if version >= 3 and flags & 0x4000:
+            offset += 2
+        encoded_length = flags & 0x0FFF
+        if encoded_length < 0x0FFF:
+            end = offset + encoded_length
+        else:
+            try:
+                end = data.index(b"\0", offset)
+            except ValueError as error:
+                raise ManualCampaignError(
+                    "checkout index path is unterminated"
+                ) from error
+        if end >= len(data):
+            raise ManualCampaignError("checkout index path is truncated")
+        raw_relative = data[offset:end]
+        relative = raw_relative.decode("utf-8", errors="surrogateescape")
+        tracked.add(relative)
+        offset = end + 1
+        while (offset - start) % 8:
+            offset += 1
+        if flags & 0x3000:
+            unmerged = True
+        else:
+            tree_entries.append((raw_relative, indexed_mode, object_id))
+        if _generated_report_path(relative):
+            continue
+        path = repo_root / relative
+        try:
+            observed = path.lstat()
+        except OSError:
+            dirty.append(relative)
+            continue
+        metadata = (
+            observed.st_mtime_ns // 1_000_000_000,
+            observed.st_mtime_ns % 1_000_000_000,
+            observed.st_size,
+            observed.st_mode & 0o170000,
+            observed.st_mode & 0o111,
+        )
+        expected = (
+            mtime_seconds,
+            mtime_nanoseconds,
+            indexed_size,
+            indexed_mode & 0o170000,
+            indexed_mode & 0o111,
+        )
+        if metadata != expected:
+            dirty.append(relative)
+    if committed_tree is None:
+        try:
+            revision = _repo_head(repo_root)
+        except (ManualCampaignError, OSError):
+            # Keep the metadata helper usable for deliberately minimal test
+            # indexes.  lightweight_source_identity() resolves HEAD first and
+            # therefore never takes this compatibility path.
+            revision = None
+        if revision is not None:
+            committed_tree = _commit_tree_marker(repo_root, revision)
+    if committed_tree is not None:
+        if unmerged:
+            dirty.append("<unmerged Git index>")
+        elif committed_tree.startswith("manual-revision:"):
+            dirty.append("<index-vs-HEAD tree unavailable>")
+        elif _index_tree_marker(tree_entries) != committed_tree:
+            dirty.append("<staged index differs from HEAD>")
+    critical = (
+        "tools/performance_report/manual_campaign.py",
+        "src/pyamplicol/_profiling_campaign/steer_performance_campaign.py",
+    )
+    dirty.extend(
+        relative
+        for relative in critical
+        if (repo_root / relative).exists() and relative not in tracked
+    )
+    return tuple(sorted(set(dirty)))
+
+
+def lightweight_source_identity(repo_root: Path) -> ReportSourceIdentity:
+    revision = _repo_head(repo_root)
+    tree = _commit_tree_marker(repo_root, revision)
+    return ReportSourceIdentity(
+        revision,
+        tree,
+        _index_metadata_dirty_paths(repo_root, committed_tree=tree),
+    )
+
+
+def installed_source_identity(
+    *,
+    allow_candidate_checkout: bool = False,
+) -> ReportSourceIdentity:
+    """Bind a copied campaign to its wheel or a dry-run candidate checkout."""
+
+    from pyamplicol._internal.versions import (
+        active_source_checkout,
+        active_source_revision,
+    )
+
+    revision = active_source_revision()
+    if revision is None:
+        checkout = active_source_checkout() if allow_candidate_checkout else None
+        if checkout is not None:
+            return lightweight_source_identity(checkout)
+        raise ManualCampaignError(
+            "installed pyAmpliCol has no source revision in its build info; "
+            "reinstall a release wheel that retains build provenance"
+        )
+    tree = hashlib.sha1(
+        f"pyamplicol-installed-report-tree-v1:{revision}".encode("ascii"),
+        usedforsecurity=False,
+    ).hexdigest()
+    return ReportSourceIdentity(revision, tree, ())
+
+
+@dataclass(frozen=True, slots=True)
+class LightweightCurrent:
+    cell_id: str
+    attempt_id: str
+    result_path: Path
+    result: Mapping[str, object]
+    complete: bool
+    reusable: bool
+    reason: str
+    record: CurrentRecord | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class _ProfileEnvironmentWitness:
+    active_runtime: Mapping[str, object]
+    host_environment: Mapping[str, object]
+
+
+@dataclass(frozen=True, slots=True)
+class RecordedSourcePolicy:
+    """The active measurement revision and persisted read-only reuse policy."""
+
+    source_revision: str
+    continue_across_revisions: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class LightweightPresentationOutcome:
+    """One tiny presentation-only terminal outcome for an otherwise empty cell."""
+
+    profile: str
+    cell_id: str
+    source_revision: str
+    campaign_invocation_id: str
+    attempt_id: str | None
+    status: str
+    label: str
+    completed_at_ns: int
+
+    @property
+    def ordering_key(self) -> tuple[int, str, str, str]:
+        return (
+            self.completed_at_ns,
+            self.campaign_invocation_id,
+            self.attempt_id or "",
+            self.status,
+        )
+
+    @property
+    def successful(self) -> bool:
+        return self.status in _SUMMARY_SUCCESS_STATUSES
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "schema": PRESENTATION_OUTCOME_SCHEMA,
+            "profile": self.profile,
+            "cell_id": self.cell_id,
+            "source_revision": self.source_revision,
+            "campaign_invocation_id": self.campaign_invocation_id,
+            "attempt_id": self.attempt_id,
+            "status": self.status,
+            "label": self.label,
+            "completed_at_ns": self.completed_at_ns,
+        }
+
+
+def _read_object(path: Path) -> dict[str, object] | None:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return None
+    return value if isinstance(value, dict) else None
+
+
+def _presentation_outcome_path(
+    service: ReportService,
+    cell_id: str,
+    *,
+    catalog_validated: bool = False,
+) -> Path:
+    if not catalog_validated:
+        service.catalog.cell(cell_id)
+    if _SAFE_OUTCOME_CELL_ID.fullmatch(cell_id) is None:
+        raise ManualCampaignError(
+            f"presentation outcome cell ID is unsafe: {cell_id!r}"
+        )
+    return (
+        service.paths.coordination_root
+        / "manual-presentation-outcomes"
+        / f"{cell_id}.json"
+    )
+
+
+def _canonical_attempt_uuid(value: object) -> str | None:
+    if not isinstance(value, str):
+        return None
+    try:
+        parsed = uuid.UUID(value)
+    except ValueError:
+        return None
+    return value if str(parsed) == value else None
+
+
+def _humanized_outcome_label(status: str) -> str:
+    if status == "cancelled":
+        return "interrupted"
+    return " ".join(status.replace("_", " ").replace("-", " ").split())
+
+
+def _parse_presentation_outcome(
+    raw: Mapping[str, object] | None,
+    *,
+    expected_profile: str,
+    expected_cell_id: str,
+    source_revision: str,
+    accept_historical_source: bool,
+) -> LightweightPresentationOutcome | None:
+    if raw is None or set(raw) != _PRESENTATION_OUTCOME_KEYS:
+        return None
+    profile = raw.get("profile")
+    cell_id = raw.get("cell_id")
+    revision = raw.get("source_revision")
+    invocation_id = raw.get("campaign_invocation_id")
+    status = raw.get("status")
+    label = raw.get("label")
+    completed_at_ns = raw.get("completed_at_ns")
+    if (
+        raw.get("schema") != PRESENTATION_OUTCOME_SCHEMA
+        or not isinstance(profile, str)
+        or profile != expected_profile
+        or not isinstance(cell_id, str)
+        or cell_id != expected_cell_id
+        or not isinstance(revision, str)
+        or _FULL_SOURCE_REVISION.fullmatch(revision) is None
+        or (revision != source_revision and not accept_historical_source)
+        or not isinstance(invocation_id, str)
+        or not (1 <= len(invocation_id) <= 128)
+        or not invocation_id.isascii()
+        or not invocation_id.isprintable()
+        or not isinstance(status, str)
+        or _SAFE_OUTCOME_SLUG.fullmatch(status) is None
+        or not isinstance(label, str)
+        or not (1 <= len(label) <= 64)
+        or label != label.strip()
+        or not label.isascii()
+        or not label.isprintable()
+        or isinstance(completed_at_ns, bool)
+        or not isinstance(completed_at_ns, int)
+        or completed_at_ns <= 0
+        or completed_at_ns > _MAX_PRESENTATION_COMPLETED_AT_NS
+    ):
+        return None
+    raw_attempt_id = raw.get("attempt_id")
+    attempt_id = _canonical_attempt_uuid(raw_attempt_id)
+    if raw_attempt_id is not None and attempt_id is None:
+        return None
+    return LightweightPresentationOutcome(
+        profile=profile,
+        cell_id=cell_id,
+        source_revision=revision,
+        campaign_invocation_id=invocation_id,
+        attempt_id=attempt_id,
+        status=status,
+        label=label,
+        completed_at_ns=completed_at_ns,
+    )
+
+
+def lightweight_presentation_outcome(
+    service: ReportService,
+    cell: CellSpec,
+    *,
+    source_revision: str,
+    accept_historical_source: bool = False,
+) -> LightweightPresentationOutcome | None:
+    """Read one direct compact outcome, ignoring unsafe or malformed metadata."""
+
+    path = _presentation_outcome_path(
+        service,
+        cell.cell_id,
+        catalog_validated=True,
+    )
+    if path.is_symlink() or not path.is_file():
+        return None
+    return _parse_presentation_outcome(
+        _read_object(path),
+        expected_profile=_PRESENTATION_PROFILE,
+        expected_cell_id=cell.cell_id,
+        source_revision=source_revision,
+        accept_historical_source=accept_historical_source,
+    )
+
+
+def lightweight_presentation_outcomes(
+    service: ReportService,
+    cells: Sequence[CellSpec],
+    *,
+    source_revision: str,
+    accept_historical_source: bool = False,
+    progress: Callable[[int, int], None] | None = None,
+) -> dict[str, LightweightPresentationOutcome]:
+    result: dict[str, LightweightPresentationOutcome] = {}
+    total = len(cells)
+    for completed, cell in enumerate(cells, start=1):
+        outcome = lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision=source_revision,
+            accept_historical_source=accept_historical_source,
+        )
+        if outcome is not None:
+            result[cell.cell_id] = outcome
+        if progress is not None:
+            progress(completed, total)
+    return result
+
+
+def _replace_presentation_outcome_locked(
+    service: ReportService,
+    outcome: LightweightPresentationOutcome,
+    *,
+    accept_historical_source: bool,
+    only_if_replacing_failure: bool = False,
+    catalog_validated: bool = False,
+) -> bool:
+    """Replace one outcome while the shared presentation lock is held."""
+
+    validated = _parse_presentation_outcome(
+        outcome.as_dict(),
+        expected_profile=_PRESENTATION_PROFILE,
+        expected_cell_id=outcome.cell_id,
+        source_revision=outcome.source_revision,
+        accept_historical_source=False,
+    )
+    if validated is None:
+        raise ManualCampaignError("presentation outcome metadata is invalid")
+    outcome = validated
+    path = _presentation_outcome_path(
+        service,
+        outcome.cell_id,
+        catalog_validated=catalog_validated,
+    )
+    raw_existing = (
+        None if path.is_symlink() or not path.is_file() else _read_object(path)
+    )
+    existing = (
+        None
+        if raw_existing is None
+        else _parse_presentation_outcome(
+            raw_existing,
+            expected_profile=_PRESENTATION_PROFILE,
+            expected_cell_id=outcome.cell_id,
+            source_revision=outcome.source_revision,
+            accept_historical_source=accept_historical_source,
+        )
+    )
+    if only_if_replacing_failure:
+        replacement_target = existing
+        if replacement_target is None and not accept_historical_source:
+            historical = (
+                None
+                if raw_existing is None
+                else _parse_presentation_outcome(
+                    raw_existing,
+                    expected_profile=_PRESENTATION_PROFILE,
+                    expected_cell_id=outcome.cell_id,
+                    source_revision=outcome.source_revision,
+                    accept_historical_source=True,
+                )
+            )
+            if historical is not None and not historical.successful:
+                replacement_target = historical
+        if replacement_target is None or replacement_target.successful:
+            return False
+    if existing is not None and existing.ordering_key > outcome.ordering_key:
+        return False
+    _atomic_json(path, outcome.as_dict(), sync=False)
+    return True
+
+
+def _publish_presentation_outcome(
+    service: ReportService,
+    outcome: LightweightPresentationOutcome,
+    *,
+    only_if_replacing_failure: bool = False,
+    catalog_validated: bool = False,
+) -> bool:
+    """Atomically retain only the deterministically latest presentation outcome."""
+
+    with service.store.named_lock("manual-source-marker"):
+        source_policy = _recorded_measurement_source_policy_locked(
+            service,
+            checkout_revision=outcome.source_revision,
+            allow_missing=False,
+        )
+        if (
+            not source_policy.continue_across_revisions
+            and source_policy.source_revision != outcome.source_revision
+        ):
+            return False
+        with service.store.named_lock(
+            f"manual-presentation-outcome-{outcome.cell_id}"
+        ):
+            return _replace_presentation_outcome_locked(
+                service,
+                outcome,
+                accept_historical_source=(
+                    source_policy.continue_across_revisions
+                ),
+                only_if_replacing_failure=only_if_replacing_failure,
+                catalog_validated=catalog_validated,
+            )
+
+
+def _publish_recycled_presentation_outcomes(
+    service: ReportService,
+    currents: Mapping[str, LightweightCurrent],
+    recycled_ids: Iterable[str],
+    *,
+    source_revision: str,
+    campaign_invocation_id: str,
+    accept_historical_source: bool = False,
+) -> tuple[str, ...]:
+    """Publish front-end recycle outcomes that bypass scheduler observers."""
+
+    cells_by_id = {
+        cell.cell_id: cell for cell in service.catalog.measurement_cells()
+    }
+    warnings: list[str] = []
+    for cell_id in sorted(set(recycled_ids)):
+        current = currents.get(cell_id)
+        if (
+            current is None
+            or not current.reusable
+            or current.result.get("status") != ResultStatus.OK.value
+        ):
+            continue
+        cell = cells_by_id[cell_id]
+        observed = lightweight_presentation_outcome(
+            service,
+            cell,
+            source_revision=source_revision,
+            accept_historical_source=accept_historical_source,
+        )
+        if observed is not None and observed.successful:
+            continue
+        try:
+            with service.store.named_lock(
+                f"campaign-cell-{cell_id}",
+                timeout=0.0,
+            ):
+                _publish_presentation_outcome(
+                    service,
+                    LightweightPresentationOutcome(
+                        profile=_PRESENTATION_PROFILE,
+                        cell_id=cell_id,
+                        source_revision=source_revision,
+                        campaign_invocation_id=campaign_invocation_id,
+                        attempt_id=current.attempt_id,
+                        status="reused",
+                        label="reused",
+                        completed_at_ns=time.time_ns(),
+                    ),
+                    only_if_replacing_failure=True,
+                    catalog_validated=True,
+                )
+        except LockTimeoutError:
+            continue
+        except Exception as error:
+            warnings.append(f"{cell_id}: {type(error).__name__}: {error}")
+    return tuple(warnings)
+
+
+def _presentation_failure_measurement(
+    outcome: LightweightPresentationOutcome,
+) -> dict[str, object]:
+    try:
+        status = ResultStatus(outcome.status)
+    except ValueError:
+        status = ResultStatus.FAILED
+    # A durable ``unverified`` measurement is valid only when it is loaded
+    # from the exact authenticated sealed attempt below.  Never synthesize an
+    # otherwise schema-invalid measured result from the tiny presentation
+    # ledger when that attempt is absent, malformed, or mismatched.
+    if status in {
+        ResultStatus.NOT_AVAILABLE,
+        ResultStatus.OK,
+        ResultStatus.UNVERIFIED,
+    }:
+        status = ResultStatus.FAILED
+    measurement = failure_measurement(status, outcome.label)
+    failure = measurement["failure"]
+    assert isinstance(failure, dict)
+    failure["kind"] = _PRESENTATION_FAILURE_KIND_PREFIX + outcome.status
+    return measurement
+
+
+def _presentation_measurement(
+    service: ReportService,
+    cell: CellSpec,
+    outcome: LightweightPresentationOutcome,
+) -> dict[str, object]:
+    """Return a presentation-only terminal measurement, failing closed.
+
+    Unverified compiled/eager attempts are the sole terminal class whose
+    measured timings are useful.  The tiny ledger supplies its exact attempt
+    UUID; the artifact store authenticates that sealed worker result without
+    scanning history.  Every malformed or mismatched record falls back to the
+    ordinary compact terminal label.
+    """
+
+    if outcome.status != ResultStatus.UNVERIFIED.value or outcome.attempt_id is None:
+        return _presentation_failure_measurement(outcome)
+    try:
+        loaded = dict(
+            service.store.load_sealed_unsuccessful_worker_result(
+                cell.cell_id,
+                outcome.attempt_id,
+            )
+        )
+        if (
+            loaded.get("status") != ResultStatus.UNVERIFIED.value
+            or not _result_matches_cell(loaded, cell)
+            or _measurement_source_revision(loaded) != outcome.source_revision
+        ):
+            raise ValueError("unverified result identity differs from presentation")
+        validate_measurement(loaded, expected_cell=cell)
+    except (OSError, TypeError, ValueError, ManifestValidationError):
+        return _presentation_failure_measurement(outcome)
+    return loaded
+
+
+def _result_matches_cell(
+    result: Mapping[str, object],
+    cell: CellSpec,
+) -> bool:
+    provenance = result.get("provenance")
+    manual = (
+        provenance.get("manual_campaign") if isinstance(provenance, Mapping) else None
+    )
+    identity = manual.get("cell_identity") if isinstance(manual, Mapping) else None
+    if not isinstance(identity, Mapping):
+        return False
+    expected = {
+        "cell_id": cell.cell_id,
+        "dataset_id": cell.dataset_id,
+        "process_key": cell.process_key,
+        "process": cell.process,
+        "n_final": cell.n_final,
+        "workload": cell.workload.value,
+        "execution_mode": cell.measurement.execution_mode.value,
+        "model": (
+            None if cell.measurement.model is None else cell.measurement.model.value
+        ),
+        "accuracy": cell.measurement.accuracy.value,
+        "backend": cell.measurement.backend,
+        "variant": cell.variant,
+    }
+    return all(identity.get(key) == value for key, value in expected.items())
+
+
+def _required_result_artifact_exists(result: Mapping[str, object]) -> bool:
+    if result.get("status") != ResultStatus.OK.value:
+        return True
+    artifact = result.get("artifact")
+    if not isinstance(artifact, Mapping):
+        return False
+    raw_path = artifact.get("path")
+    return isinstance(raw_path, str) and Path(raw_path).exists()
+
+
+def _measurement_source_revision(result: Mapping[str, object]) -> str | None:
+    provenance = result.get("provenance")
+    revision = (
+        provenance.get("report_source_revision")
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    return (
+        revision
+        if isinstance(revision, str)
+        and _FULL_SOURCE_REVISION.fullmatch(revision) is not None
+        else None
+    )
+
+
+def _historical_numerical_relation_compatible(
+    cell: CellSpec,
+    result: Mapping[str, object],
+) -> bool:
+    """Accept only historical results whose compact metadata proves safety."""
+
+    if cell.measurement.execution_mode is ExecutionMode.AMPLICOL:
+        return True
+    provenance = result.get("provenance")
+    if not isinstance(provenance, Mapping):
+        return False
+    correctness = provenance.get("numerical_relation_correctness")
+    if isinstance(correctness, Mapping):
+        applied = correctness.get("applied_relation_count")
+        state = correctness.get("state")
+        if (
+            correctness.get("abi") != _NUMERICAL_RELATION_CORRECTNESS_ABI
+            or isinstance(applied, bool)
+            or not isinstance(applied, int)
+            or applied < 0
+        ):
+            return False
+        if state == "no-applied-relations":
+            return applied == 0
+        if state == "member-scoped-v1":
+            return applied > 0
+        return False
+    effective = provenance.get("effective_config")
+    generation = effective.get("generation") if isinstance(effective, Mapping) else None
+    relation = (
+        generation.get("relation_discovery")
+        if isinstance(generation, Mapping)
+        else None
+    )
+    return isinstance(relation, Mapping) and relation.get("mode") == "off"
+
+
+def _legacy_numerical_authority_compatible(
+    cell: CellSpec,
+    result: Mapping[str, object],
+) -> bool:
+    """Require the corrected legacy numerical path for affected currents.
+
+    Older selected-flow measurements already used the generated library as
+    their numerical authority, and the special three-quark-line contracted
+    path remains a direct ``imode2`` measurement.  Retain those inexpensive
+    metadata-identifiable currents while refreshing only the paths whose
+    authority changed.
+    """
+
+    if (
+        cell.measurement.execution_mode is not ExecutionMode.AMPLICOL
+        or result.get("status") != ResultStatus.OK.value
+    ):
+        return True
+    from .legacy import (
+        LEGACY_NUMERICAL_AUTHORITY_ABI,
+        LEGACY_NUMERICAL_AUTHORITY_FIELD,
+    )
+
+    validation = result.get("validation")
+    authority = (
+        validation.get(LEGACY_NUMERICAL_AUTHORITY_FIELD)
+        if isinstance(validation, Mapping)
+        else None
+    )
+    expected_sources = {
+        Workload.SELECTED_FLOW: {"selected-flow-generated-library"},
+        Workload.ALL_FLOW: {"all-flow-selected-provider-replay"},
+        Workload.CONTRACTED: {
+            "contracted-generated-library",
+            "direct-imode2-three-quark-line",
+        },
+    }
+    if authority is not None:
+        return (
+            isinstance(authority, Mapping)
+            and authority.get("abi") == LEGACY_NUMERICAL_AUTHORITY_ABI
+            and authority.get("source")
+            in expected_sources.get(cell.workload, set())
+        )
+
+    provenance = result.get("provenance")
+    generation_source = (
+        provenance.get("generation_source")
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    return (
+        cell.workload is Workload.SELECTED_FLOW
+        and generation_source == "generated-library-create-mode-1"
+    ) or (
+        cell.workload is Workload.CONTRACTED
+        and generation_source == "direct-imode2-three-quark-line-setup"
+    )
+
+
+def lightweight_current(
+    store: ArtifactStore,
+    cell: CellSpec,
+    *,
+    source_revision: str,
+    accept_historical_source: bool = False,
+) -> LightweightCurrent | None:
+    """Read only the pointer, manifest metadata, and result required for reuse."""
+
+    root = store._cell_root(cell.cell_id)
+    pointer = _read_object(root / "current.json")
+    raw_attempt_id = None if pointer is None else pointer.get("attempt_id")
+    if (
+        pointer is None
+        or pointer.get("schema") != store.current_schema
+        or pointer.get("cell_id") != cell.cell_id
+        or not isinstance(raw_attempt_id, str)
+    ):
+        return None
+    attempt_id = raw_attempt_id
+    try:
+        parsed_attempt_id = uuid.UUID(attempt_id)
+    except ValueError:
+        parsed_attempt_id = None
+    canonical_manifest = f"attempts/{attempt_id}/manifest.json"
+    manifest_sha256 = pointer.get("manifest_sha256")
+    if (
+        parsed_attempt_id is None
+        or str(parsed_attempt_id) != attempt_id
+        or pointer.get("manifest_path") != canonical_manifest
+        or not isinstance(manifest_sha256, str)
+        or len(manifest_sha256) != 64
+        or any(character not in "0123456789abcdef" for character in manifest_sha256)
+    ):
+        return LightweightCurrent(
+            cell.cell_id,
+            attempt_id,
+            root,
+            {},
+            False,
+            False,
+            "incomplete pointer metadata",
+        )
+    manifest_path = root / canonical_manifest
+    manifest = _read_object(manifest_path)
+    if (
+        manifest is None
+        or manifest.get("schema") != ATTEMPT_SCHEMA
+        or manifest.get("cell_id") != cell.cell_id
+        or manifest.get("attempt_id") != attempt_id
+        or manifest.get("status") != "ok"
+        or manifest.get("error") is not None
+        or not isinstance(manifest.get("result_path"), str)
+    ):
+        return LightweightCurrent(
+            cell.cell_id,
+            attempt_id,
+            root,
+            {},
+            False,
+            False,
+            "incomplete metadata",
+        )
+    try:
+        artifact_policy = ArtifactPolicy(str(manifest.get("artifact_policy")))
+    except ValueError:
+        return LightweightCurrent(
+            cell.cell_id,
+            attempt_id,
+            manifest_path,
+            {},
+            False,
+            False,
+            "unsupported artifact policy",
+        )
+    relative = Path(str(manifest["result_path"]))
+    if (
+        relative.is_absolute()
+        or not relative.parts
+        or any(part in {"", ".", ".."} for part in relative.parts)
+    ):
+        return LightweightCurrent(
+            cell.cell_id,
+            attempt_id,
+            root,
+            {},
+            False,
+            False,
+            "unsafe result path",
+        )
+    artifact_records = manifest.get("artifacts")
+    if not isinstance(artifact_records, list) or not any(
+        isinstance(record, Mapping) and record.get("path") == relative.as_posix()
+        for record in artifact_records
+    ):
+        return LightweightCurrent(
+            cell.cell_id,
+            attempt_id,
+            manifest_path,
+            {},
+            False,
+            False,
+            "result missing from manifest",
+        )
+    result_path = root / "attempts" / attempt_id / relative
+    result = _read_object(result_path)
+    if result is None:
+        return LightweightCurrent(
+            cell.cell_id,
+            attempt_id,
+            result_path,
+            {},
+            False,
+            False,
+            "result unreadable",
+        )
+    try:
+        result = dict(store.materialize_current_result(result))
+    except ManifestValidationError:
+        return LightweightCurrent(
+            cell.cell_id,
+            attempt_id,
+            result_path,
+            {},
+            False,
+            False,
+            "unsafe result locator",
+        )
+    revision = _measurement_source_revision(result)
+    revision_valid = revision is not None
+    status = str(result.get("status", ""))
+    complete = status in {
+        ResultStatus.OK.value,
+        ResultStatus.TIMEOUT.value,
+        ResultStatus.MEMORY_LIMIT.value,
+    }
+    measurement_valid = False
+    if complete:
+        try:
+            validate_measurement(result, expected_cell=cell)
+        except ValueError:
+            pass
+        else:
+            measurement_valid = True
+    complete = complete and measurement_valid
+    cell_match = _result_matches_cell(result, cell)
+    artifact_exists = _required_result_artifact_exists(result)
+    historical_relation_compatible = (
+        revision == source_revision
+        or not revision_valid
+        or _historical_numerical_relation_compatible(cell, result)
+    )
+    legacy_authority_compatible = _legacy_numerical_authority_compatible(
+        cell,
+        result,
+    )
+    source_accepted = revision == source_revision or (
+        accept_historical_source and revision_valid and historical_relation_compatible
+    )
+    reusable = (
+        complete
+        and source_accepted
+        and cell_match
+        and artifact_exists
+        and legacy_authority_compatible
+    )
+    if status not in {
+        ResultStatus.OK.value,
+        ResultStatus.TIMEOUT.value,
+        ResultStatus.MEMORY_LIMIT.value,
+    }:
+        reason = "incomplete status"
+    elif not measurement_valid:
+        reason = "invalid measurement schema"
+    elif not revision_valid:
+        reason = "invalid source revision"
+    elif revision != source_revision and not accept_historical_source:
+        reason = "source mismatch"
+    elif revision != source_revision and not historical_relation_compatible:
+        reason = "historical numerical-relation policy is not reusable"
+    elif not legacy_authority_compatible:
+        reason = "legacy numerical authority requires refresh"
+    elif not cell_match:
+        reason = "cell metadata mismatch"
+    elif not artifact_exists:
+        reason = "required artifact missing"
+    elif status in {ResultStatus.TIMEOUT.value, ResultStatus.MEMORY_LIMIT.value}:
+        reason = (
+            "historical resource-capped terminal"
+            if revision != source_revision
+            else "resource-capped terminal"
+        )
+    elif revision != source_revision:
+        reason = "historical source current"
+    else:
+        reason = "reusable"
+    record = (
+        CurrentRecord(
+            cell_id=cell.cell_id,
+            attempt_id=attempt_id,
+            manifest_path=manifest_path,
+            manifest_sha256=manifest_sha256,
+            result_path=result_path,
+            result=result,
+            artifacts=(),
+            artifact_policy=artifact_policy,
+        )
+        if complete
+        else None
+    )
+    return LightweightCurrent(
+        cell.cell_id,
+        attempt_id,
+        result_path,
+        result,
+        complete,
+        reusable,
+        reason,
+        record,
+    )
+
+
+def lightweight_currents(
+    service: ReportService,
+    cells: Sequence[CellSpec],
+    *,
+    source_revision: str,
+    accept_historical_source: bool = False,
+    progress: Callable[[int, int], None] | None = None,
+) -> dict[str, LightweightCurrent]:
+    result: dict[str, LightweightCurrent] = {}
+    total = len(cells)
+    for completed, cell in enumerate(cells, start=1):
+        current = lightweight_current(
+            service.store,
+            cell,
+            source_revision=source_revision,
+            accept_historical_source=accept_historical_source,
+        )
+        if current is not None:
+            result[cell.cell_id] = current
+        if progress is not None:
+            progress(completed, total)
+    return result
+
+
+def _selective_retry_requested(arguments: argparse.Namespace) -> bool:
+    return bool(
+        getattr(arguments, "rerun_failed", False)
+        or getattr(arguments, "rerun_capped", False)
+    )
+
+
+def _fresh_attempt_requested(arguments: argparse.Namespace) -> bool:
+    return bool(
+        getattr(arguments, "force_refresh", False)
+        or _selective_retry_requested(arguments)
+    )
+
+
+def _artifact_cleanup_enabled(arguments: argparse.Namespace) -> bool:
+    """Compact disposable payloads unless full debug workspaces were requested."""
+
+    return not bool(getattr(arguments, "retain_workspaces", False))
+
+
+def _selective_retry_category(
+    current: LightweightCurrent | None,
+    outcome: LightweightPresentationOutcome | None,
+) -> str | None:
+    """Classify the latest reusable terminal for selective retry.
+
+    Tiny presentation outcomes are authoritative for ordering, but a cap is
+    trusted only when it names the exact attempt of a validated reusable cap
+    current.  This keeps future/unauthenticated timeout-like slugs in the
+    ordinary failure class rather than silently granting them policy meaning.
+    """
+
+    cap_state: PolicyMeasurementState | None = None
+    current_state: PolicyMeasurementState | None = None
+    if current is not None and current.reusable:
+        current_state = policy_measurement_state_hint(current.result)
+        if (
+            current_state in _TERMINAL_CAP_STATES
+            and policy_status_label(current.result) is not None
+        ):
+            cap_state = current_state
+
+    if outcome is not None:
+        if outcome.successful:
+            return None
+        if (
+            cap_state is not None
+            and current is not None
+            and outcome.attempt_id == current.attempt_id
+            and outcome.status == cap_state.value
+        ):
+            return "capped"
+        return "failed"
+
+    if current is None or not current.reusable:
+        return None
+    if current_state is PolicyMeasurementState.SUCCESS:
+        return None
+    return "capped" if cap_state is not None else "failed"
+
+
+def _selective_retry_cells(
+    cells: Sequence[CellSpec],
+    currents: Mapping[str, LightweightCurrent],
+    outcomes: Mapping[str, LightweightPresentationOutcome],
+    *,
+    rerun_failed: bool,
+    rerun_capped: bool,
+) -> tuple[CellSpec, ...]:
+    selected_categories = {
+        category
+        for category, enabled in (
+            ("failed", rerun_failed),
+            ("capped", rerun_capped),
+        )
+        if enabled
+    }
+    return tuple(
+        cell
+        for cell in cells
+        if _selective_retry_category(
+            currents.get(cell.cell_id),
+            outcomes.get(cell.cell_id),
+        )
+        in selected_categories
+    )
+
+
+def _source_cohort_counts(
+    currents: Mapping[str, LightweightCurrent],
+    *,
+    cell_ids: set[str] | None = None,
+) -> dict[str, int]:
+    counts: Counter[str] = Counter()
+    for cell_id, current in currents.items():
+        if cell_ids is not None and cell_id not in cell_ids:
+            continue
+        if not current.reusable:
+            continue
+        revision = _measurement_source_revision(current.result)
+        if revision is not None:
+            counts[revision] += 1
+    return dict(sorted(counts.items()))
+
+
+def _format_source_cohorts(cohorts: Mapping[str, int]) -> str:
+    return (
+        ", ".join(f"{revision}={count}" for revision, count in cohorts.items())
+        or "none"
+    )
+
+
+def _lightweight_current_resolver(
+    service: ReportService,
+    *,
+    source_revision: str,
+    initial: Mapping[str, LightweightCurrent] | None = None,
+) -> Callable[
+    [CellSpec],
+    tuple[CurrentRecord, PolicyMeasurementState] | None,
+]:
+    """Resolve planner currents from cheap metadata without artifact hashing."""
+
+    cache: dict[str, LightweightCurrent | None] = dict(initial or {})
+
+    def resolve(
+        cell: CellSpec,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+        if cell.cell_id not in cache:
+            cache[cell.cell_id] = lightweight_current(
+                service.store,
+                cell,
+                source_revision=source_revision,
+            )
+        current = cache[cell.cell_id]
+        if current is None or not current.reusable or current.record is None:
+            return None
+        state = policy_measurement_state_hint(current.result)
+        return None if state is None else (current.record, state)
+
+    return resolve
+
+
+def _installed_source_revision() -> str | None:
+    try:
+        from pyamplicol._internal.versions import (
+            active_source_revision,
+            package_version,
+        )
+    except (ImportError, RuntimeError, ValueError) as error:
+        raise ManualCampaignError(
+            f"measurement runtime provenance cannot be loaded: {error}; rerun "
+            "`just dev-install`"
+        ) from error
+    try:
+        package_version()
+        return active_source_revision()
+    except (RuntimeError, ValueError) as error:
+        raise ManualCampaignError(
+            f"measurement runtime provenance check failed: {error}"
+        ) from error
+
+
+def require_measurement_ready(source: ReportSourceIdentity) -> None:
+    if not source.eligible:
+        examples = ", ".join(source.dirty_paths[:5])
+        remainder = max(0, len(source.dirty_paths) - 5)
+        suffix = "" if remainder == 0 else f", … {remainder} more"
+        raise ManualCampaignError(
+            "measurement source is not a clean committed checkout "
+            f"({examples}{suffix}); commit the campaign implementation and "
+            "rebuild before running measurements"
+        )
+    installed = _installed_source_revision()
+    if installed is None:
+        raise ManualCampaignError(
+            "measurement runtime contains no clean source revision for this "
+            f"checkout ({source.revision}); rebuild it with `just dev-install` "
+            "after committing evaluator-source changes. Copied profiling "
+            "campaigns and generated report outputs do not invalidate the build."
+        )
+    if installed != source.revision:
+        raise ManualCampaignError(
+            "measurement runtime is not a clean build of this checkout: "
+            f"checkout={source.revision}, installed={installed}. Commit the "
+            "implementation, ensure the worktree is clean, then run "
+            "`just dev-install`; dirty-build evidence is never reusable."
+        )
+
+
+def _source_marker_path(service: ReportService) -> Path:
+    return service.paths.coordination_root / "manual-source.json"
+
+
+def update_source_marker(
+    service: ReportService,
+    source: ReportSourceIdentity,
+    *,
+    continue_across_revisions: bool = False,
+) -> bool:
+    """Record the active source and lightweight publication policy once."""
+
+    path = _source_marker_path(service)
+    with service.store.named_lock("manual-source-marker"):
+        previous = _read_object(path)
+        changed = previous is not None and (
+            previous.get("source_revision") != source.revision
+            or previous.get("continue_across_revisions", False)
+            != continue_across_revisions
+        )
+        _atomic_json(
+            path,
+            {
+                "schema": SOURCE_MARKER_SCHEMA,
+                "source_revision": source.revision,
+                "continue_across_revisions": continue_across_revisions,
+                "recorded_at_utc": _utc_now(),
+            },
+        )
+    return changed
+
+
+def recorded_measurement_source_policy(
+    service: ReportService,
+    *,
+    checkout_revision: str,
+) -> RecordedSourcePolicy:
+    """Read the recorded measurement epoch and its lightweight reuse policy.
+
+    Renderer-only commits must not make already published measurements vanish.
+    Real campaign runs update this marker only after the checkout and installed
+    runtime have passed the strict measurement-readiness checks.  The optional
+    continuation policy lets read-only views merge per-cell currents from more
+    than one valid recorded source revision without weakening active-revision
+    dependency planning.
+    """
+
+    with service.store.named_lock("manual-source-marker"):
+        return _recorded_measurement_source_policy_locked(
+            service,
+            checkout_revision=checkout_revision,
+            allow_missing=True,
+        )
+
+
+def _recorded_measurement_source_policy_locked(
+    service: ReportService,
+    *,
+    checkout_revision: str,
+    allow_missing: bool,
+) -> RecordedSourcePolicy:
+    """Decode the source marker while its named lock is already held."""
+
+    path = _source_marker_path(service)
+    exists = path.exists()
+    marker = _read_object(path)
+    if marker is None:
+        if exists or not allow_missing:
+            raise ManualCampaignError(
+                f"campaign source marker is unreadable: {path}; refusing to "
+                "guess which measurement cohort to publish"
+            )
+        return RecordedSourcePolicy(checkout_revision)
+    revision = marker.get("source_revision")
+    continue_across_revisions = marker.get("continue_across_revisions", False)
+    if (
+        marker.get("schema") != SOURCE_MARKER_SCHEMA
+        or not isinstance(revision, str)
+        or _FULL_SOURCE_REVISION.fullmatch(revision) is None
+        or not isinstance(continue_across_revisions, bool)
+    ):
+        raise ManualCampaignError(
+            f"campaign source marker is malformed: {path}; refusing to guess "
+            "which measurement cohort to publish"
+        )
+    return RecordedSourcePolicy(revision, continue_across_revisions)
+
+
+def recorded_measurement_source_revision(
+    service: ReportService,
+    *,
+    checkout_revision: str,
+) -> str:
+    """Return the active recorded measurement revision for compatibility."""
+
+    return recorded_measurement_source_policy(
+        service,
+        checkout_revision=checkout_revision,
+    ).source_revision
+
+
+@dataclass(slots=True)
+class _IncrementalTailState:
+    identity: tuple[int, int] | None = None
+    offset: int = 0
+    pending: bytes = b""
+    last_read_bytes: int = 0
+
+
+@dataclass(frozen=True, slots=True)
+class PhaseTimelineRow:
+    """One normalized, presentation-only phase record from persisted evidence."""
+
+    phase: str
+    wall_seconds: float | None = None
+    cpu_seconds: float | None = None
+    peak_memory_bytes: int | None = None
+    status: str | None = None
+    detail: str | None = None
+
+
+@dataclass(slots=True)
+class WorkerView:
+    cell_id: str
+    dependency: bool = False
+    peer_instance: str | None = None
+    generation_engine: str | None = None
+    status: str = "queued"
+    step: str = "waiting"
+    phase: str = "preparation"
+    attempt_id: str | None = None
+    pid: int | None = None
+    member_pids: tuple[int, ...] = ()
+    wall_seconds: float = 0.0
+    cpu_seconds: float | None = None
+    current_rss_bytes: int = 0
+    peak_rss_bytes: int = 0
+    current_physical_footprint_bytes: int | None = None
+    peak_physical_footprint_bytes: int | None = None
+    current_guard_bytes: int = 0
+    peak_guard_bytes: int = 0
+    child_count: int = 0
+    progress_completed: int | None = None
+    progress_total: int | None = None
+    progress_message: str = ""
+    progress_task_id: str | None = None
+    progress_details: dict[str, object] = field(default_factory=dict)
+    log_path: str | None = None
+    progress_path: str | None = None
+    reproduce_prepare: str | None = None
+    reproduce_generate: str | None = None
+    reproduce_profile: str | None = None
+    published_wall_seconds_per_point: float | None = None
+    published_evaluator_total_seconds_per_point: float | None = None
+    published_recurrence_core_seconds_per_point: float | None = None
+    phase_timeline: tuple[PhaseTimelineRow, ...] = ()
+    provenance_summary: str | None = None
+    reuse_explanation: str | None = None
+    blocked_prerequisite_ids: tuple[str, ...] = ()
+    recycled: bool = False
+    events: list[str] = field(default_factory=list)
+    log_tail: list[str] = field(default_factory=list)
+    updated_at: float = field(default_factory=time.time)
+    _progress_tail_state: _IncrementalTailState = field(
+        default_factory=_IncrementalTailState,
+        repr=False,
+    )
+    _log_tail_state: _IncrementalTailState = field(
+        default_factory=_IncrementalTailState,
+        repr=False,
+    )
+
+    def as_dict(self) -> dict[str, object]:
+        payload = asdict(self)
+        payload.pop("_progress_tail_state", None)
+        payload.pop("_log_tail_state", None)
+        return payload
+
+
+@dataclass(slots=True)
+class DashboardState:
+    instance_id: str
+    selected_ids: tuple[str, ...]
+    recycled_ids: set[str]
+    static_na_ids: set[str]
+    source_revision: str = ""
+    generation_time_limit_seconds: float = DEFAULT_GENERATION_LIMIT_SECONDS
+    memory_limit_bytes: int = DEFAULT_RAM_BYTES
+    worker_wall_limit_seconds: float | None = DEFAULT_WORKER_WALL_LIMIT_SECONDS
+    reproduction_settings: ReproductionSettings = field(
+        default_factory=ReproductionSettings
+    )
+    dependency_ids: set[str] = field(default_factory=set)
+    workers: dict[str, WorkerView] = field(default_factory=dict)
+    terminal_outcomes: dict[str, _DashboardTerminalOutcome] = field(
+        default_factory=dict
+    )
+    selected_index: int = 0
+    detail_scroll: int = 0
+    show_completed: bool = False
+    show_errors: bool = True
+    show_help: bool = False
+    command_stage: str | None = None
+    command_scroll: int = 0
+    command_notice: str | None = None
+    pending_clipboard: tuple[str, str] | None = None
+    pending_print: tuple[str, str] | None = None
+    started_at: float = field(default_factory=time.time)
+    interrupted: bool = False
+    counter_snapshot: dict[str, int] | None = None
+    lease_updated_at: float | None = None
+    live_snapshot: bool = False
+    ready_count: int = 0
+    waiting_dependency_count: int = 0
+    waiting_coordination_lock_count: int = 0
+    cleanup_warnings: list[tuple[str, str]] = field(default_factory=list)
+    invocation_evidence_ids: set[str] = field(default_factory=set)
+
+    def _clear_cell_disposition(self, cell_id: str) -> None:
+        self.terminal_outcomes.pop(cell_id, None)
+        self.recycled_ids.discard(cell_id)
+
+    def _reduce_started(self, cell_id: str, *, dependency: bool) -> WorkerView:
+        """Apply one started event and return a wholly fresh worker view."""
+
+        self._clear_cell_disposition(cell_id)
+        worker = WorkerView(
+            cell_id,
+            dependency=dependency,
+            status="preparing",
+            step="dependency preparation",
+            phase="preparation",
+        )
+        self.workers[cell_id] = worker
+        return worker
+
+    def _reduce_finished(
+        self,
+        cell_id: str,
+        status: str,
+        *,
+        recycled: bool = False,
+    ) -> None:
+        """Reduce a finished event into one normalized terminal category."""
+
+        self._clear_cell_disposition(cell_id)
+        if recycled or status in _RECYCLED_SUCCESS_STATUSES:
+            self.recycled_ids.add(cell_id)
+        if status in _SUMMARY_SUCCESS_STATUSES:
+            outcome = _DashboardTerminalOutcome.SUCCESS
+        elif status in _TERMINAL_CAP_STATUSES:
+            outcome = _DashboardTerminalOutcome.CAPPED
+        elif status == ResultStatus.UNVERIFIED.value:
+            outcome = _DashboardTerminalOutcome.UNVERIFIED
+        elif status != "cancelled":
+            outcome = _DashboardTerminalOutcome.FAILED
+        else:
+            return
+        self.terminal_outcomes[cell_id] = outcome
+
+    @property
+    def completed_ids(self) -> set[str]:
+        return {
+            cell_id
+            for cell_id, outcome in self.terminal_outcomes.items()
+            if cell_id not in self.recycled_ids
+            and outcome is _DashboardTerminalOutcome.SUCCESS
+        }
+
+    @property
+    def capped_ids(self) -> set[str]:
+        return {
+            cell_id
+            for cell_id, outcome in self.terminal_outcomes.items()
+            if outcome is _DashboardTerminalOutcome.CAPPED
+        }
+
+    @property
+    def failed_ids(self) -> set[str]:
+        return {
+            cell_id
+            for cell_id, outcome in self.terminal_outcomes.items()
+            if outcome is _DashboardTerminalOutcome.FAILED
+        }
+
+    @property
+    def unverified_ids(self) -> set[str]:
+        return {
+            cell_id
+            for cell_id, outcome in self.terminal_outcomes.items()
+            if outcome is _DashboardTerminalOutcome.UNVERIFIED
+        }
+
+    @property
+    def active(self) -> tuple[WorkerView, ...]:
+        """Return active work owned by this invocation only.
+
+        Peer leases are rendered to make cross-process activity observable, but
+        they must not inflate the primary ``Active`` counter for this runner.
+        """
+
+        return tuple(
+            worker
+            for worker in self.workers.values()
+            if worker.peer_instance is None and worker.status in _ACTIVE_WORKER_STATUSES
+        )
+
+    @property
+    def peer_active(self) -> tuple[WorkerView, ...]:
+        """Return visible active work owned by concurrent peer invocations."""
+
+        return tuple(
+            worker
+            for worker in self.workers.values()
+            if worker.peer_instance is not None
+            and worker.status in _ACTIVE_WORKER_STATUSES
+        )
+
+    def visible_workers(self) -> tuple[WorkerView, ...]:
+        """Return the single ordered worker view used by table and details."""
+
+        def rank(worker: WorkerView) -> tuple[int, str, str]:
+            status_rank = {
+                "running": 0,
+                "preparing": 1,
+                "queued": 2,
+            }.get(
+                worker.status,
+                4 if worker.status in _COMPLETED_WORKER_STATUSES else 3,
+            )
+            return status_rank, worker.cell_id, worker.peer_instance or ""
+
+        return tuple(
+            sorted(
+                (
+                    worker
+                    for worker in self.workers.values()
+                    if (
+                        self.show_completed
+                        or worker.status not in _COMPLETED_WORKER_STATUSES
+                    )
+                    and (
+                        self.show_errors
+                        or worker.status in _ACTIVE_WORKER_STATUSES
+                        or worker.status in _COMPLETED_WORKER_STATUSES
+                    )
+                ),
+                key=rank,
+            )
+        )
+
+    def counters(self) -> dict[str, int]:
+        """Return one snapshot with non-overlapping selection dispositions.
+
+        ``Selected`` progress is one exclusive partition.  Active work is not
+        a terminal disposition, so it remains in ``remaining`` until it
+        finishes.  Slot utilisation deliberately spans direct and dependency
+        work, and is exposed separately as ``active`` with an explicit split.
+        """
+
+        if self.counter_snapshot is not None:
+            return dict(self.counter_snapshot)
+        selected = set(self.selected_ids)
+        recycled_ids = self.recycled_ids & selected
+        selected_outcomes = {
+            cell_id: outcome
+            for cell_id, outcome in self.terminal_outcomes.items()
+            if cell_id in selected and cell_id not in recycled_ids
+        }
+        selected_terminal_ids = set(selected_outcomes)
+        static_na_ids = (
+            (self.static_na_ids & selected)
+            - recycled_ids
+            - selected_terminal_ids
+        )
+        remaining_ids = selected - recycled_ids - selected_terminal_ids - static_na_ids
+        dependency_only_ids = self.dependency_ids - selected
+        active_ids = {worker.cell_id for worker in self.active}
+        selected_active_ids = active_ids & selected
+        dependency_active_ids = active_ids & dependency_only_ids
+        dependency_outcomes = {
+            cell_id: outcome
+            for cell_id, outcome in self.terminal_outcomes.items()
+            if cell_id in dependency_only_ids
+        }
+        dependency_completed = sum(
+            outcome is _DashboardTerminalOutcome.SUCCESS
+            for outcome in dependency_outcomes.values()
+        )
+        dependency_issues = sum(
+            outcome is not _DashboardTerminalOutcome.SUCCESS
+            for outcome in dependency_outcomes.values()
+        )
+        return {
+            "selected": len(self.selected_ids),
+            "recycled": len(recycled_ids),
+            "active": len(active_ids),
+            "selected_active": len(selected_active_ids),
+            "dependency_active": len(dependency_active_ids),
+            "completed": sum(
+                outcome is _DashboardTerminalOutcome.SUCCESS
+                for outcome in selected_outcomes.values()
+            ),
+            "remaining": len(remaining_ids),
+            "static_na": len(static_na_ids),
+            "capped": sum(
+                outcome is _DashboardTerminalOutcome.CAPPED
+                for outcome in selected_outcomes.values()
+            ),
+            "failed": sum(
+                outcome is _DashboardTerminalOutcome.FAILED
+                for outcome in selected_outcomes.values()
+            ),
+            "unverified": sum(
+                outcome is _DashboardTerminalOutcome.UNVERIFIED
+                for outcome in selected_outcomes.values()
+            ),
+            "dependency_only": len(dependency_only_ids),
+            "dependency_completed": dependency_completed,
+            "dependency_issues": dependency_issues,
+        }
+
+    def selected_worker(self) -> WorkerView | None:
+        rows = self.visible_workers()
+        if not rows:
+            self.selected_index = 0
+            return None
+        self.selected_index %= len(rows)
+        return rows[self.selected_index]
+
+
+class LeaseManager:
+    """Publish compact atomic informational state for concurrent dashboards."""
+
+    def __init__(
+        self,
+        service: ReportService,
+        state: DashboardState,
+    ) -> None:
+        self.service = service
+        self.state = state
+        self._guard = threading.Lock()
+        self._closed = False
+        self.path = (
+            service.paths.coordination_root
+            / "manual-leases"
+            / f"{state.instance_id}.json"
+        )
+
+    def _write(self) -> None:
+        if self._closed:
+            return
+        _atomic_json(
+            self.path,
+            {
+                "schema": MANUAL_STATE_SCHEMA,
+                "instance_id": self.state.instance_id,
+                "controller_pid": os.getpid(),
+                "source_revision": self.state.source_revision,
+                "started_at": self.state.started_at,
+                "updated_at": time.time(),
+                "counters": self.state.counters(),
+                "limits": {
+                    "generation_time_limit_seconds": (
+                        self.state.generation_time_limit_seconds
+                    ),
+                    "memory_limit_bytes": self.state.memory_limit_bytes,
+                    "worker_wall_limit_seconds": (self.state.worker_wall_limit_seconds),
+                },
+                "scheduler": {
+                    "ready": self.state.ready_count,
+                    "waiting_dependency": self.state.waiting_dependency_count,
+                    "waiting_coordination_lock": (
+                        self.state.waiting_coordination_lock_count
+                    ),
+                },
+                "workers": {
+                    key: worker.as_dict()
+                    for key, worker in sorted(self.state.workers.items())
+                    if worker.peer_instance is None
+                },
+            },
+        )
+
+    def publish(self) -> None:
+        with self._guard:
+            self._write()
+
+    def dashboard_snapshot(self) -> DashboardState:
+        with self._guard:
+            _merge_peer_workers(self.service, self.state)
+            return copy.deepcopy(self.state)
+
+    def observe(self, payload: Mapping[str, object]) -> None:
+        event = str(payload.get("event", "update"))
+        with self._guard:
+            if self._closed:
+                return
+            if event == "scheduler-state":
+                self.state.ready_count = max(
+                    0,
+                    _optional_int(payload.get("ready")) or 0,
+                )
+                self.state.waiting_dependency_count = max(
+                    0,
+                    _optional_int(payload.get("waiting_dependency")) or 0,
+                )
+                self.state.waiting_coordination_lock_count = max(
+                    0,
+                    _optional_int(payload.get("waiting_coordination_lock")) or 0,
+                )
+                self._write()
+                return
+            cell_id = str(payload.get("cell_id", ""))
+            if not cell_id:
+                return
+            if event == "preflight-finished":
+                attempt_id = str(payload.get("attempt_id") or "")
+                worker = self.state.workers.get(cell_id)
+                if worker is not None and worker.attempt_id == attempt_id:
+                    del self.state.workers[cell_id]
+                self._write()
+                return
+            worker = self.state.workers.setdefault(cell_id, WorkerView(cell_id))
+            worker.updated_at = time.time()
+            cleanup_detail: str | None = None
+            if event == "started":
+                self.state.invocation_evidence_ids.add(cell_id)
+                worker = self.state._reduce_started(
+                    cell_id,
+                    dependency=bool(payload.get("dependency", False)),
+                )
+                try:
+                    cell = self.service.catalog.cell(cell_id)
+                except KeyError:
+                    cell = None
+                if cell is not None:
+                    worker.generation_engine = cell.measurement.execution_mode.value
+                    settings = self.state.reproduction_settings
+                    recipe = reproduction_recipe(
+                        cell,
+                        repo_root=self.service.paths.repo_root,
+                        artifact_root=self.service.paths.artifact_root,
+                        cores=settings.cores,
+                        target_runtime=settings.target_runtime,
+                        batch_size=settings.batch_size,
+                        warmups=settings.warmups,
+                        minimum_samples=settings.minimum_samples,
+                    )
+                    worker.reproduce_prepare = (
+                        None if recipe.prepare is None else _shell_join(recipe.prepare)
+                    )
+                    worker.reproduce_generate = (
+                        None
+                        if recipe.generate is None
+                        else _shell_join(recipe.generate)
+                    )
+                    worker.reproduce_profile = (
+                        None if recipe.profile is None else _shell_join(recipe.profile)
+                    )
+            elif event == "worker":
+                if worker.status not in _ACTIVE_WORKER_STATUSES:
+                    self._write()
+                    return
+                self.state.invocation_evidence_ids.add(cell_id)
+                worker.status = "running"
+                worker.step = "worker launched"
+                worker.attempt_id = str(payload.get("attempt_id") or "") or None
+                worker.log_path = str(payload.get("log_path") or "") or None
+                worker.progress_path = str(payload.get("progress_path") or "") or None
+            elif event == "resource":
+                resource_attempt_id = str(payload.get("attempt_id") or "") or None
+                if worker.status not in _ACTIVE_WORKER_STATUSES or (
+                    resource_attempt_id is not None
+                    and resource_attempt_id != worker.attempt_id
+                ):
+                    self._write()
+                    return
+                self.state.invocation_evidence_ids.add(cell_id)
+                worker.status = "running"
+                worker.pid = _optional_int(payload.get("pid"))
+                worker.member_pids = tuple(
+                    int(value) for value in payload.get("member_pids", ())
+                )
+                worker.phase = str(payload.get("phase") or "unknown")
+                worker.step = worker.phase.replace("_", " ")
+                worker.wall_seconds = _finite_float(payload.get("wall_seconds"))
+                worker.cpu_seconds = _optional_finite_float(payload.get("cpu_seconds"))
+                worker.current_rss_bytes = (
+                    _optional_int(payload.get("current_rss_bytes")) or 0
+                )
+                worker.peak_rss_bytes = (
+                    _optional_int(payload.get("peak_rss_bytes")) or 0
+                )
+                worker.current_physical_footprint_bytes = _optional_int(
+                    payload.get("current_physical_footprint_bytes")
+                )
+                worker.peak_physical_footprint_bytes = _optional_int(
+                    payload.get("peak_physical_footprint_bytes")
+                )
+                worker.current_guard_bytes = (
+                    _optional_int(payload.get("current_guard_bytes")) or 0
+                )
+                worker.peak_guard_bytes = (
+                    _optional_int(payload.get("peak_guard_bytes")) or 0
+                )
+                worker.child_count = _optional_int(payload.get("child_count")) or 0
+                _tail_progress(worker)
+                _tail_log(worker)
+            elif event == "finished":
+                reported_status = str(payload.get("status") or "unknown")
+                reported_detail = str(payload.get("detail") or "")
+                raw_terminal_detail = payload.get("terminal_detail")
+                reported_terminal_detail = (
+                    raw_terminal_detail
+                    if isinstance(raw_terminal_detail, str)
+                    else None
+                )
+                outcome_attempt_id = worker.attempt_id
+                reported_attempt_id = _canonical_attempt_uuid(outcome_attempt_id)
+                if reported_attempt_id is None:
+                    reported_attempt_id = _canonical_attempt_uuid(reported_detail)
+                reported_success = reported_status in _SUMMARY_SUCCESS_STATUSES
+                if not (
+                    reported_status == "cancelled"
+                    and reported_detail in {"not started", "lock wait cancelled"}
+                ):
+                    self.state.invocation_evidence_ids.add(cell_id)
+                worker.status = (
+                    "recycled"
+                    if reported_status in _RECYCLED_SUCCESS_STATUSES
+                    else reported_status
+                )
+                worker.recycled = reported_status in _RECYCLED_SUCCESS_STATUSES
+                worker.step = reported_detail or worker.status
+                raw_prerequisites = payload.get("prerequisite_cell_ids")
+                if isinstance(raw_prerequisites, Sequence) and not isinstance(
+                    raw_prerequisites,
+                    (str, bytes),
+                ):
+                    worker.blocked_prerequisite_ids = tuple(
+                        sorted(
+                            {
+                                str(value)
+                                for value in raw_prerequisites
+                                if isinstance(value, str) and value
+                            }
+                        )
+                    )
+                try:
+                    cell = self.service.catalog.cell(cell_id)
+                except KeyError:
+                    cell = None
+                current: LightweightCurrent | None = None
+                terminal_result: Mapping[str, object] | None = None
+                if cell is not None:
+                    worker.generation_engine = cell.measurement.execution_mode.value
+                    current = lightweight_current(
+                        self.service.store,
+                        cell,
+                        source_revision=self.state.source_revision,
+                    )
+                    current_is_observed_attempt = (
+                        current is not None
+                        and current.complete
+                        and (
+                            reported_success
+                            or reported_attempt_id == current.attempt_id
+                        )
+                    )
+                    if current_is_observed_attempt:
+                        assert current is not None
+                        terminal_result = current.result
+                        worker.attempt_id = current.attempt_id
+                        _apply_persisted_worker_result(
+                            worker,
+                            current.result,
+                            recycled=worker.recycled,
+                            reuse_explanation=(
+                                current.reason if worker.recycled else None
+                            ),
+                        )
+                        worker.published_wall_seconds_per_point = _number(
+                            current.result,
+                            "wall_seconds_per_point",
+                        )
+                        worker.published_evaluator_total_seconds_per_point = (
+                            _evaluator_total_number(current.result)
+                        )
+                        worker.published_recurrence_core_seconds_per_point = (
+                            _recurrence_core_number(current.result)
+                        )
+                        provenance = current.result.get("provenance")
+                        manual = (
+                            provenance.get("manual_campaign")
+                            if isinstance(provenance, Mapping)
+                            else None
+                        )
+                        recipe = (
+                            manual.get("public_cli_reproduction")
+                            if isinstance(manual, Mapping)
+                            else None
+                        )
+                        if isinstance(recipe, Mapping):
+                            worker.reproduce_prepare = _stored_reproduction_command(
+                                recipe,
+                                "prepare",
+                            )
+                            worker.reproduce_generate = _stored_reproduction_command(
+                                recipe,
+                                "generate",
+                            )
+                            worker.reproduce_profile = _stored_reproduction_command(
+                                recipe,
+                                "profile",
+                            )
+                terminal_step = _concise_terminal_step(reported_terminal_detail)
+                if terminal_step is None and terminal_result is not None:
+                    terminal_step = _terminal_result_step(terminal_result)
+                if terminal_step is not None:
+                    worker.step = terminal_step
+                if worker.recycled and worker.reuse_explanation is None:
+                    worker.reuse_explanation = worker.step
+                _tail_progress(worker)
+                _tail_log(worker)
+                self.state._reduce_finished(
+                    cell_id,
+                    worker.status,
+                    recycled=worker.recycled,
+                )
+                successful_current = (
+                    current
+                    if reported_success
+                    and current is not None
+                    and current.reusable
+                    and current.result.get("status") == ResultStatus.OK.value
+                    else None
+                )
+                if (
+                    cell is not None
+                    and reported_status != ResultStatus.NOT_AVAILABLE.value
+                    and (not reported_success or successful_current is not None)
+                    and not (
+                        reported_status == "cancelled"
+                        and reported_detail in {"not started", "lock wait cancelled"}
+                    )
+                ):
+                    normalized_status = (
+                        reported_status
+                        if _SAFE_OUTCOME_SLUG.fullmatch(reported_status) is not None
+                        else _summary_status(reported_status)
+                    )
+                    attempt_id = _canonical_attempt_uuid(
+                        None
+                        if successful_current is None
+                        else successful_current.attempt_id
+                    )
+                    if attempt_id is None:
+                        attempt_id = _canonical_attempt_uuid(outcome_attempt_id)
+                    if attempt_id is None:
+                        attempt_id = _canonical_attempt_uuid(reported_detail)
+                    label = _humanized_outcome_label(normalized_status)
+                    if (
+                        current is not None
+                        and attempt_id is not None
+                        and current.attempt_id == attempt_id
+                    ):
+                        label = policy_status_label(current.result) or label
+                    completed_at_ns = (
+                        _optional_int(payload.get("completed_at_ns")) or time.time_ns()
+                    )
+                    try:
+                        _publish_presentation_outcome(
+                            self.service,
+                            LightweightPresentationOutcome(
+                                profile=_PRESENTATION_PROFILE,
+                                cell_id=cell_id,
+                                source_revision=self.state.source_revision,
+                                campaign_invocation_id=self.state.instance_id,
+                                attempt_id=attempt_id,
+                                status=normalized_status,
+                                label=label,
+                                completed_at_ns=completed_at_ns,
+                            ),
+                            only_if_replacing_failure=reported_success,
+                            catalog_validated=True,
+                        )
+                    except Exception as error:
+                        worker.events.append(
+                            "presentation outcome warning: "
+                            f"{type(error).__name__}: {error}"
+                        )
+            elif event == "cleanup-warning":
+                cleanup_detail = str(payload.get("detail") or "unknown cleanup error")
+                warning = (cell_id, cleanup_detail)
+                if warning not in self.state.cleanup_warnings:
+                    self.state.cleanup_warnings.append(warning)
+            observed_event = (
+                f"cleanup warning: {cleanup_detail}"
+                if cleanup_detail is not None
+                else (
+                    f"resource: {worker.phase}"
+                    if event == "resource"
+                    else f"{event}: {worker.step}"
+                )
+            )
+            if not (
+                event == "resource"
+                and worker.events
+                and worker.events[-1] == observed_event
+            ):
+                worker.events.append(observed_event)
+            del worker.events[:-8]
+            self._write()
+
+    def close(self) -> None:
+        with self._guard:
+            self._closed = True
+            self.path.unlink(missing_ok=True)
+
+
+@dataclass(frozen=True, slots=True)
+class _FailFastTerminalFailure:
+    observed_at_utc: str
+    cell_id: str
+    status: str
+    detail: str
+    terminal_detail: str | None
+    completed_at_ns: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class _FailFastReport:
+    text: str
+    cell_id: str
+    attempt_root: str | None
+    artifact_path: str | None
+    worker_log_path: str | None
+    worker_progress_path: str | None
+
+
+class _FailFastObserver:
+    """Turn the first terminal failure event into the campaign stop signal."""
+
+    def __init__(
+        self,
+        delegate: Callable[[Mapping[str, object]], None],
+        cancellation: threading.Event,
+    ) -> None:
+        self._delegate = delegate
+        self._cancellation = cancellation
+        self._guard = threading.Lock()
+        self._failure: _FailFastTerminalFailure | None = None
+
+    @property
+    def failure(self) -> _FailFastTerminalFailure | None:
+        with self._guard:
+            return self._failure
+
+    def observe(self, payload: Mapping[str, object]) -> None:
+        if payload.get("event") == "finished":
+            status = str(payload.get("status") or "unknown")
+            if status not in _FAIL_FAST_SUCCESS_STATUSES and status != "cancelled":
+                with self._guard:
+                    if self._failure is None and not self._cancellation.is_set():
+                        raw_terminal_detail = payload.get("terminal_detail")
+                        raw_completed_at_ns = payload.get("completed_at_ns")
+                        self._failure = _FailFastTerminalFailure(
+                            observed_at_utc=_utc_now(),
+                            cell_id=str(payload.get("cell_id") or ""),
+                            status=status,
+                            detail=str(payload.get("detail") or ""),
+                            terminal_detail=(
+                                raw_terminal_detail
+                                if isinstance(raw_terminal_detail, str)
+                                else None
+                            ),
+                            completed_at_ns=(
+                                raw_completed_at_ns
+                                if isinstance(raw_completed_at_ns, int)
+                                and not isinstance(raw_completed_at_ns, bool)
+                                else None
+                            ),
+                        )
+                        # The scheduler consults this same event before filling
+                        # another slot, and live supervisors consult it while
+                        # sampling their process trees.
+                        self._cancellation.set()
+        self._delegate(payload)
+
+
+def _attempt_failure_evidence(
+    service: ReportService,
+    *,
+    cell_id: str,
+    attempt_id: str | None,
+) -> tuple[Path | None, Mapping[str, object] | None]:
+    if attempt_id is None:
+        return None, None
+    current: CurrentRecord | None = None
+    with suppress(Exception):
+        current = service.store.load_current(cell_id, missing_ok=True)
+    if current is not None and current.attempt_id == attempt_id:
+        return current.manifest_path.parent, current.result
+
+    live_root: Path | None = None
+    archived_root: Path | None = None
+    with suppress(Exception):
+        live_root = service.store._existing_live_attempt_root(cell_id, attempt_id)
+    with suppress(Exception):
+        archived_root = service.store._existing_archived_attempt_root(
+            cell_id,
+            attempt_id,
+        )
+    roots = tuple(root for root in (live_root, archived_root) if root is not None)
+    root = roots[0] if len(roots) == 1 else None
+    result: Mapping[str, object] | None = None
+    with suppress(Exception):
+        result = service.store.load_sealed_unsuccessful_worker_result(
+            cell_id,
+            attempt_id,
+        )
+    return root, result
+
+
+def _fail_fast_report_value(value: object) -> str:
+    if value is None:
+        return "<unavailable>"
+    text = str(value)
+    return text if text else "<unavailable>"
+
+
+def _fail_fast_report_line(label: str, value: object) -> str:
+    rendered = (
+        _fail_fast_report_value(value)
+        .replace("\r\n", "\n")
+        .replace(
+            "\r",
+            "\n",
+        )
+    )
+    return f"{label}: " + rendered.replace("\n", "\n  ")
+
+
+def _build_fail_fast_report(
+    service: ReportService,
+    state: DashboardState,
+    failure: _FailFastTerminalFailure,
+    *,
+    invocation_command: str,
+) -> _FailFastReport:
+    try:
+        cell = service.catalog.cell(failure.cell_id)
+    except KeyError as error:
+        raise ManualCampaignError(
+            f"fail-fast terminal references unknown cell {failure.cell_id!r}"
+        ) from error
+    worker = state.workers.get(failure.cell_id)
+    attempt_id = _canonical_attempt_uuid(
+        None if worker is None else worker.attempt_id
+    )
+    if attempt_id is None:
+        attempt_id = _canonical_attempt_uuid(failure.detail)
+    attempt_root, result = _attempt_failure_evidence(
+        service,
+        cell_id=cell.cell_id,
+        attempt_id=attempt_id,
+    )
+    failure_record = result.get("failure") if isinstance(result, Mapping) else None
+    failure_class = (
+        failure_record.get("kind") if isinstance(failure_record, Mapping) else None
+    )
+    failure_message = (
+        failure_record.get("message")
+        if isinstance(failure_record, Mapping)
+        else None
+    )
+    if not isinstance(failure_class, str) or not failure_class:
+        failure_class = None
+    if not isinstance(failure_message, str) or not failure_message:
+        failure_message = failure.terminal_detail or failure.detail or None
+    artifact = result.get("artifact") if isinstance(result, Mapping) else None
+    raw_artifact_path = artifact.get("path") if isinstance(artifact, Mapping) else None
+    artifact_path = (
+        raw_artifact_path
+        if isinstance(raw_artifact_path, str) and raw_artifact_path
+        else None
+    )
+    if (
+        artifact_path is None
+        and attempt_root is not None
+        and (attempt_root / "artifact").is_dir()
+    ):
+        artifact_path = str(attempt_root / "artifact")
+    worker_log_path = None if worker is None else worker.log_path
+    worker_progress_path = None if worker is None else worker.progress_path
+    if attempt_root is not None:
+        if worker_log_path is None and (attempt_root / "worker.log").is_file():
+            worker_log_path = str(attempt_root / "worker.log")
+        if (
+            worker_progress_path is None
+            and (attempt_root / "worker-progress.jsonl").is_file()
+        ):
+            worker_progress_path = str(attempt_root / "worker-progress.jsonl")
+    process_family_id = next(
+        (
+            family.identifier
+            for family in PROCESS_FAMILIES
+            if family.key == cell.process_key
+        ),
+        None,
+    )
+    rows = (
+        ("timestamp_utc", failure.observed_at_utc),
+        ("campaign_invocation_id", state.instance_id),
+        ("campaign_invocation", invocation_command),
+        ("cell_id", cell.cell_id),
+        ("process_family_id", process_family_id),
+        ("process_key", cell.process_key),
+        ("process", cell.process),
+        ("n_final", cell.n_final),
+        ("mode", cell.measurement.execution_mode.value),
+        ("workload", cell.workload.value),
+        ("accuracy", cell.measurement.accuracy.value),
+        ("terminal_status", failure.status),
+        ("outcome_detail", failure.detail),
+        ("terminal_detail", failure.terminal_detail),
+        ("failure_class", failure_class),
+        ("failure_message", failure_message),
+        ("attempt_uuid", attempt_id),
+        ("attempt_root", attempt_root),
+        ("artifact_path", artifact_path),
+        ("worker_log_path", worker_log_path),
+        ("worker_progress_path", worker_progress_path),
+        (
+            "reproduce_prepare",
+            None if worker is None else worker.reproduce_prepare,
+        ),
+        (
+            "reproduce_generate",
+            None if worker is None else worker.reproduce_generate,
+        ),
+        (
+            "reproduce_profile",
+            None if worker is None else worker.reproduce_profile,
+        ),
+    )
+    text = "\n".join(
+        (
+            "pyAmpliCol campaign fail-fast failure",
+            *(_fail_fast_report_line(label, value) for label, value in rows),
+        )
+    )
+    return _FailFastReport(
+        text=text,
+        cell_id=cell.cell_id,
+        attempt_root=None if attempt_root is None else str(attempt_root),
+        artifact_path=artifact_path,
+        worker_log_path=worker_log_path,
+        worker_progress_path=worker_progress_path,
+    )
+
+
+def _publish_completion_summary(
+    service: ReportService,
+    categories: Mapping[str, Iterable[str]],
+    *,
+    state: DashboardState,
+    fail_fast_failure: _FailFastTerminalFailure | None,
+    invocation_command: str,
+    palette: Palette,
+) -> Path:
+    report = (
+        None
+        if fail_fast_failure is None
+        else _build_fail_fast_report(
+            service,
+            state,
+            fail_fast_failure,
+            invocation_command=invocation_command,
+        )
+    )
+    summary_path, summary_counts = _publish_campaign_summary_ids(
+        service,
+        categories,
+        fail_fast_failure_log=None if report is None else report.text,
+    )
+    _print_campaign_summary_ids(summary_path, summary_counts, palette)
+    if report is not None:
+        report_path = summary_path / FAIL_FAST_FAILURE_LOG
+        print(file=sys.stderr)
+        print(
+            palette.failure(
+                "Fail-fast stopped dispatch after the first terminal failure."
+            ),
+            file=sys.stderr,
+        )
+        print(report.text, file=sys.stderr)
+        print(f"fail_fast_report: {report_path}", file=sys.stderr)
+    return summary_path
+
+
+def _print_cleanup_warnings(state: DashboardState, palette: Palette) -> None:
+    for cell_id, detail in state.cleanup_warnings:
+        print(
+            palette.warning(f"artifact cleanup skipped for {cell_id}: {detail}"),
+            file=sys.stderr,
+        )
+
+
+def _optional_int(value: object) -> int | None:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    return int(value)
+
+
+def _finite_float(value: object) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return 0.0
+    result = float(value)
+    return result if math.isfinite(result) else 0.0
+
+
+def _optional_finite_float(value: object) -> float | None:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    result = float(value)
+    return result if math.isfinite(result) else None
+
+
+def _first_mapping_text(
+    values: Sequence[Mapping[str, object]],
+    keys: Sequence[str],
+) -> str | None:
+    for value in values:
+        for key in keys:
+            observed = value.get(key)
+            if isinstance(observed, str) and observed.strip():
+                return observed.strip()
+    return None
+
+
+def _manual_phase_timeline(
+    result: Mapping[str, object],
+) -> Mapping[str, object] | None:
+    """Return only the versioned manual-campaign phase-timeline contract."""
+
+    provenance = result.get("provenance")
+    if not isinstance(provenance, Mapping):
+        return None
+    manual = provenance.get("manual_campaign")
+    if not isinstance(manual, Mapping):
+        return None
+    timeline = manual.get("phase_timeline")
+    if (
+        not isinstance(timeline, Mapping)
+        or timeline.get("schema") != _PHASE_TIMELINE_SCHEMA
+    ):
+        return None
+    return timeline
+
+
+def _persisted_phase_timeline_row(value: object) -> PhaseTimelineRow | None:
+    """Decode exactly one entry from the versioned persisted contract."""
+
+    if not isinstance(value, Mapping):
+        return None
+    phase = _first_mapping_text((value,), ("label", "key"))
+    if phase is None:
+        return None
+    seconds = _optional_finite_float(value.get("seconds"))
+    cpu_seconds = _optional_finite_float(value.get("cpu_seconds"))
+    peak_memory = _optional_int(value.get("peak_memory_bytes"))
+    return PhaseTimelineRow(
+        phase=phase,
+        wall_seconds=seconds if seconds is not None and seconds >= 0.0 else None,
+        cpu_seconds=(
+            cpu_seconds if cpu_seconds is not None and cpu_seconds >= 0.0 else None
+        ),
+        peak_memory_bytes=(
+            peak_memory if peak_memory is not None and peak_memory >= 0 else None
+        ),
+        status=_first_mapping_text((value,), ("status",)),
+        detail=_first_mapping_text((value,), ("detail",)),
+    )
+
+
+def _persisted_phase_timeline_rows(
+    timeline: Mapping[str, object],
+) -> tuple[PhaseTimelineRow, ...]:
+    entries = timeline.get("entries")
+    if not isinstance(entries, Sequence) or isinstance(entries, (str, bytes)):
+        return ()
+    return tuple(
+        row
+        for entry in entries[:16]
+        if (row := _persisted_phase_timeline_row(entry)) is not None
+    )
+
+
+def _lease_phase_timeline_rows(value: object) -> tuple[PhaseTimelineRow, ...]:
+    """Decode only the controller's own compact WorkerView lease shape."""
+
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        return ()
+    rows: list[PhaseTimelineRow] = []
+    for item in value[:16]:
+        if isinstance(item, PhaseTimelineRow):
+            rows.append(item)
+            continue
+        if not isinstance(item, Mapping):
+            continue
+        phase = item.get("phase")
+        if not isinstance(phase, str) or not phase:
+            continue
+        wall = _optional_finite_float(item.get("wall_seconds"))
+        cpu = _optional_finite_float(item.get("cpu_seconds"))
+        peak = _optional_int(item.get("peak_memory_bytes"))
+        status = item.get("status")
+        detail = item.get("detail")
+        rows.append(
+            PhaseTimelineRow(
+                phase=phase,
+                wall_seconds=wall if wall is not None and wall >= 0.0 else None,
+                cpu_seconds=cpu if cpu is not None and cpu >= 0.0 else None,
+                peak_memory_bytes=peak if peak is not None and peak >= 0 else None,
+                status=status if isinstance(status, str) and status else None,
+                detail=detail if isinstance(detail, str) and detail else None,
+            )
+        )
+    return tuple(rows)
+
+
+def _extract_phase_timeline(
+    result: Mapping[str, object],
+) -> tuple[PhaseTimelineRow, ...]:
+    """Normalize a persisted timeline without requiring it for result reuse."""
+
+    timeline = _manual_phase_timeline(result)
+    if timeline is not None:
+        return _persisted_phase_timeline_rows(timeline)
+
+    # Older results expose a few exact durations without a timeline wrapper.
+    # Use only those recorded numbers; never derive one phase from another.
+    rows: list[PhaseTimelineRow] = []
+    provenance = result.get("provenance")
+    provenance_values = provenance if isinstance(provenance, Mapping) else {}
+    preparation = _optional_finite_float(
+        provenance_values.get("model_preparation_seconds")
+    )
+    if preparation is not None and preparation >= 0.0:
+        rows.append(
+            PhaseTimelineRow(
+                "Model preparation",
+                wall_seconds=preparation,
+                status=(
+                    "reused"
+                    if provenance_values.get("model_preparation_reused") is True
+                    else "measured"
+                ),
+            )
+        )
+    generation = _optional_finite_float(result.get("generation_seconds"))
+    if generation is not None and generation >= 0.0:
+        rows.append(PhaseTimelineRow("Generation", wall_seconds=generation))
+    benchmark = provenance_values.get("runtime_profile")
+    benchmark_values = benchmark if isinstance(benchmark, Mapping) else {}
+    legacy_warmup = benchmark_values.get("warmup")
+    legacy_measurement = benchmark_values.get("measurement")
+    if isinstance(legacy_warmup, Mapping):
+        seconds = _optional_finite_float(legacy_warmup.get("elapsed_seconds"))
+        if seconds is not None and seconds >= 0.0:
+            rows.append(PhaseTimelineRow("Runtime warm-up", wall_seconds=seconds))
+    if isinstance(legacy_measurement, Mapping):
+        chunks = legacy_measurement.get("chunks")
+        durations: list[float] = []
+        if isinstance(chunks, Sequence) and not isinstance(chunks, (str, bytes)):
+            for chunk in chunks:
+                if not isinstance(chunk, Mapping):
+                    durations = []
+                    break
+                seconds = _optional_finite_float(chunk.get("elapsed_seconds"))
+                if seconds is None or seconds < 0.0:
+                    durations = []
+                    break
+                durations.append(seconds)
+        if durations:
+            rows.append(
+                PhaseTimelineRow(
+                    "Timed profiling",
+                    wall_seconds=math.fsum(durations),
+                )
+            )
+    for key, label in (
+        ("warmup_elapsed_seconds", "Runtime warm-up"),
+        ("calibration_outer_elapsed_seconds", "Runtime calibration"),
+        ("profile_attribution_elapsed_seconds", "Profiling attribution"),
+        ("evaluator_elapsed_seconds", "Profiling attribution"),
+        ("profile_total_elapsed_seconds", "Complete runtime profile"),
+    ):
+        seconds = _optional_finite_float(benchmark_values.get(key))
+        if seconds is not None and seconds >= 0.0:
+            rows.append(PhaseTimelineRow(label, wall_seconds=seconds))
+    if not any(
+        row.phase in {"Timed profiling", "Timed headline measurement"} for row in rows
+    ):
+        seconds = _optional_finite_float(
+            benchmark_values.get("achieved_runtime_seconds")
+        )
+        if seconds is None:
+            seconds = _optional_finite_float(
+                benchmark_values.get("measurement_phase_elapsed_seconds")
+            )
+        if seconds is not None and seconds >= 0.0:
+            rows.append(
+                PhaseTimelineRow(
+                    "Timed headline measurement",
+                    wall_seconds=seconds,
+                )
+            )
+    return tuple(rows)
+
+
+def _extract_provenance_summary(result: Mapping[str, object]) -> str | None:
+    provenance = result.get("provenance")
+    provenance_values = provenance if isinstance(provenance, Mapping) else {}
+    manual = provenance_values.get("manual_campaign")
+    manual_values = manual if isinstance(manual, Mapping) else {}
+    identity = manual_values.get("cell_identity")
+    identity_values = identity if isinstance(identity, Mapping) else {}
+    revision = _first_mapping_text(
+        (manual_values, provenance_values, result),
+        (
+            "report_measured_source_revision",
+            "report_source_revision",
+            "source_revision",
+        ),
+    )
+    engine = _first_mapping_text(
+        (identity_values, manual_values),
+        ("execution_mode", "generation_engine", "engine"),
+    )
+    model = _first_mapping_text(
+        (identity_values, manual_values),
+        ("model", "model_source"),
+    )
+    fragments: list[str] = []
+    if revision is not None:
+        fragments.append(f"source {revision[:12]}")
+    if engine is not None:
+        fragments.append(f"engine {engine}")
+    if model is not None:
+        fragments.append(f"model {model}")
+    recorded_at = _first_mapping_text((manual_values,), ("recorded_at_utc",))
+    if recorded_at is not None:
+        fragments.append(f"recorded {recorded_at}")
+    return " · ".join(fragments) or None
+
+
+def _stored_reproduction_command(
+    recipe: object,
+    key: str,
+) -> str | None:
+    value = recipe.get(key) if isinstance(recipe, Mapping) else None
+    if (
+        not isinstance(value, Sequence)
+        or isinstance(value, (str, bytes, bytearray))
+        or not value
+        or any(not isinstance(argument, str) or not argument for argument in value)
+    ):
+        return None
+    return _shell_join(value)
+
+
+def _apply_persisted_worker_result(
+    worker: WorkerView,
+    result: Mapping[str, object],
+    *,
+    recycled: bool,
+    reuse_explanation: str | None = None,
+) -> None:
+    """Populate optional dashboard evidence without making reuse depend on it."""
+
+    worker.phase_timeline = _extract_phase_timeline(result)
+    worker.provenance_summary = _extract_provenance_summary(result)
+    worker.recycled = recycled
+    worker.reuse_explanation = reuse_explanation if recycled else None
+    timeline = _manual_phase_timeline(result)
+    if isinstance(timeline, Mapping):
+        total_wall = _optional_finite_float(timeline.get("total_worker_wall_seconds"))
+        peak_rss = _optional_int(timeline.get("peak_rss_bytes"))
+        peak_guard = _optional_int(timeline.get("peak_guard_bytes"))
+        if worker.wall_seconds <= 0.0 and total_wall is not None and total_wall >= 0.0:
+            worker.wall_seconds = total_wall
+        if worker.peak_rss_bytes <= 0 and peak_rss is not None and peak_rss >= 0:
+            worker.peak_rss_bytes = peak_rss
+        if worker.peak_guard_bytes <= 0 and peak_guard is not None and peak_guard >= 0:
+            worker.peak_guard_bytes = peak_guard
+
+
+def _concise_terminal_step(value: str | None) -> str | None:
+    """Normalize one event-carried terminal reason for bounded display."""
+
+    if value is None:
+        return None
+    concise = " ".join(_dashboard_log_line(value).split())
+    if not concise:
+        return None
+    return concise if len(concise) <= 240 else f"{concise[:237]}..."
+
+
+def _terminal_result_step(result: Mapping[str, object]) -> str | None:
+    """Return one concise terminal reason from an already loaded current."""
+
+    resources = result.get("resources")
+    supervisor = resources.get("supervisor") if isinstance(resources, Mapping) else None
+    if (
+        isinstance(supervisor, Mapping)
+        and supervisor.get("reason") == "phase_state_error"
+    ):
+        phase_error = supervisor.get("phase_state_error")
+        if isinstance(phase_error, str) and phase_error.strip():
+            value = phase_error
+        else:
+            value = "worker phase-state validation failed"
+    else:
+        policy_label = policy_status_label(result)
+        failure = result.get("failure")
+        failure_message = (
+            failure.get("message") if isinstance(failure, Mapping) else None
+        )
+        if isinstance(policy_label, str) and policy_label.strip():
+            value = policy_label
+        elif isinstance(failure_message, str) and failure_message.strip():
+            value = failure_message
+        else:
+            return None
+    return _concise_terminal_step(value)
+
+
+def _coalesced_worker_events(events: Sequence[str]) -> tuple[str, ...]:
+    """Collapse repeated resource samples while retaining phase transitions."""
+
+    rows: list[str] = []
+    previous_resource: str | None = None
+    for event in events:
+        resource = event if event.startswith("resource:") else None
+        if resource is not None and resource == previous_resource:
+            continue
+        rows.append(event)
+        previous_resource = resource
+    return tuple(rows)
+
+
+def _incremental_tail_lines(
+    path: Path,
+    state: _IncrementalTailState,
+    *,
+    max_read_bytes: int = MAX_TAIL_READ_BYTES,
+) -> tuple[str, ...]:
+    """Read only newly appended complete lines, bounded after large jumps."""
+
+    if max_read_bytes <= 0:
+        raise ValueError("max_read_bytes must be positive")
+    try:
+        metadata = path.stat()
+    except OSError:
+        state.last_read_bytes = 0
+        return ()
+    identity = (metadata.st_dev, metadata.st_ino)
+    if state.identity != identity or metadata.st_size < state.offset:
+        state.identity = identity
+        state.offset = 0
+        state.pending = b""
+    start = state.offset
+    discard_partial_prefix = False
+    if metadata.st_size - start > max_read_bytes:
+        start = metadata.st_size - max_read_bytes
+        state.pending = b""
+        discard_partial_prefix = start > 0
+    try:
+        with path.open("rb") as stream:
+            stream.seek(start)
+            payload = stream.read(max_read_bytes)
+    except OSError:
+        state.last_read_bytes = 0
+        return ()
+    state.offset = start + len(payload)
+    state.last_read_bytes = len(payload)
+    if discard_partial_prefix:
+        separator = payload.find(b"\n")
+        payload = b"" if separator < 0 else payload[separator + 1 :]
+    combined = state.pending + payload
+    chunks = combined.split(b"\n")
+    if combined.endswith(b"\n"):
+        state.pending = b""
+        chunks.pop()
+    else:
+        state.pending = chunks.pop()[-max_read_bytes:]
+    return tuple(
+        chunk.rstrip(b"\r").decode("utf-8", errors="replace") for chunk in chunks
+    )
+
+
+def _tail_progress(worker: WorkerView) -> None:
+    if worker.progress_path is None:
+        return
+    lines = _incremental_tail_lines(
+        Path(worker.progress_path),
+        worker._progress_tail_state,
+    )
+    for line in reversed(lines):
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(event, Mapping):
+            continue
+        task_id = event.get("task_id")
+        worker.progress_task_id = (
+            str(task_id) if isinstance(task_id, str) and task_id else None
+        )
+        completed = _optional_int(event.get("completed"))
+        total = _optional_int(event.get("total"))
+        event_kind = event.get("event")
+        if completed is not None:
+            worker.progress_completed = completed
+        elif event_kind == "start":
+            worker.progress_completed = 0
+        if total is not None:
+            worker.progress_total = total
+        details = event.get("details")
+        if isinstance(details, Mapping):
+            worker.progress_details = {
+                str(key): value
+                for key, value in details.items()
+                if value is None or isinstance(value, (bool, int, float, str))
+            }
+        else:
+            worker.progress_details = {}
+        detail_step = worker.progress_details.get("step")
+        message = (
+            event.get("message")
+            or event.get("description")
+            or (detail_step if isinstance(detail_step, str) else None)
+        )
+        worker.progress_message = "" if message is None else str(message)
+        if worker.progress_message:
+            worker.step = worker.progress_message
+        return
+
+
+def _dashboard_log_line(value: str) -> str:
+    value = _ANSI_ESCAPE.sub("", value)
+    cleaned = "".join(
+        character
+        for character in value.replace("\t", "  ")
+        if ord(character) >= 32 and ord(character) != 127
+    )
+    return cleaned[-500:]
+
+
+def _tail_log(worker: WorkerView) -> None:
+    if worker.log_path is None:
+        return
+    lines = _incremental_tail_lines(Path(worker.log_path), worker._log_tail_state)
+    worker.log_tail.extend(
+        cleaned for line in lines if (cleaned := _dashboard_log_line(line))
+    )
+    del worker.log_tail[:-MAX_LOG_TAIL_LINES]
+
+
+def _human_duration(seconds: float) -> str:
+    seconds = max(0.0, seconds)
+    hours, remainder = divmod(int(seconds), 3600)
+    minutes, whole = divmod(remainder, 60)
+    return f"{hours:02d}:{minutes:02d}:{whole:02d}"
+
+
+def _human_phase_duration(seconds: float) -> str:
+    """Keep short phase timings visible without widening the worker runtime."""
+
+    seconds = max(0.0, seconds)
+    if seconds < 1.0:
+        return f"{seconds * 1000.0:.1f} ms"
+    if seconds < 60.0:
+        return f"{seconds:.2f} s"
+    if seconds < 3600.0:
+        minutes, remainder = divmod(seconds, 60.0)
+        return f"{int(minutes):02d}:{remainder:04.1f}"
+    return _human_duration(seconds)
+
+
+def _human_bytes(value: int) -> str:
+    if value < 1000:
+        return f"{value} B"
+    units = ("kB", "MB", "GB", "TB")
+    amount = float(value)
+    for unit in units:
+        amount /= 1000.0
+        if amount < 1000.0 or unit == units[-1]:
+            return f"{amount:.2f} {unit}"
+    return f"{value} B"
+
+
+def _progress_detail_summary(details: Mapping[str, object]) -> str:
+    """Render typed progress details without discarding native stage counters."""
+
+    ignored = {"process", "step"}
+    ordered_keys = (
+        "stage_index",
+        "stage_total",
+        "subset_size",
+        "candidate_parent_pair_count",
+        "candidate_parent_pair_total",
+        "current_count",
+        "contribution_count",
+        "dynamic_color_state_count",
+        "color_target_prune_count",
+        "inspected_current_count",
+        "certified_relation_count",
+        "applied_relation_count",
+        "generation_evidence_encoding",
+        "generation_raw_evidence_bytes",
+        "generation_evidence_transport_bytes",
+    )
+    ordered = [key for key in ordered_keys if key in details]
+    ordered.extend(
+        sorted(key for key in details if key not in ignored and key not in ordered)
+    )
+    fragments: list[str] = []
+    consumed: set[str] = set()
+    if "stage_index" in details and "stage_total" in details:
+        fragments.append(f"stage {details['stage_index']}/{details['stage_total']}")
+        consumed.update({"stage_index", "stage_total"})
+    if (
+        "candidate_parent_pair_count" in details
+        and "candidate_parent_pair_total" in details
+    ):
+        count = details["candidate_parent_pair_count"]
+        total = details["candidate_parent_pair_total"]
+        if isinstance(count, int) and isinstance(total, int):
+            fragments.append(f"candidate pairs {count:,}/{total:,}")
+            consumed.update(
+                {"candidate_parent_pair_count", "candidate_parent_pair_total"}
+            )
+    labels = {
+        "subset_size": "subset",
+        "current_count": "currents",
+        "contribution_count": "contributions",
+        "dynamic_color_state_count": "colour states",
+        "color_target_prune_count": "colour pruned",
+        "inspected_current_count": "currents inspected",
+        "certified_relation_count": "relations certified",
+        "applied_relation_count": "relations applied",
+        "generation_evidence_encoding": "evidence",
+        "generation_raw_evidence_bytes": "evidence raw",
+        "generation_evidence_transport_bytes": "evidence transport",
+    }
+    byte_fields = {
+        "generation_raw_evidence_bytes",
+        "generation_evidence_transport_bytes",
+    }
+    for key in ordered:
+        if key in consumed:
+            continue
+        value = details[key]
+        label = labels.get(key, key.replace("_", " "))
+        if key in byte_fields and isinstance(value, int):
+            rendered = _human_bytes(value)
+        elif isinstance(value, int) and not isinstance(value, bool):
+            rendered = f"{value:,}"
+        else:
+            rendered = str(value)
+        fragments.append(f"{label} {rendered}")
+    return " · ".join(fragments)
+
+
+def _worker_progress_ratio(worker: WorkerView) -> float:
+    if (
+        worker.progress_completed is not None
+        and worker.progress_total is not None
+        and worker.progress_total > 0
+    ):
+        return min(1.0, worker.progress_completed / worker.progress_total)
+    phase_ratio = {
+        "preparation": 0.05,
+        "generation": 0.35,
+        "profiling": 0.75,
+        "completed": 1.0,
+    }
+    return phase_ratio.get(worker.phase, 0.1)
+
+
+def _worker_progress_indicator(worker: WorkerView, *, compact: bool) -> str:
+    ratio = _worker_progress_ratio(worker)
+    slots = 4 if compact else 6
+    filled = min(slots, max(0, round(ratio * slots)))
+    return f"{'▰' * filled}{'▱' * (slots - filled)} {ratio * 100:3.0f}%"
+
+
+def _worker_enforcement_memory(worker: WorkerView, *, peak: bool = False) -> int:
+    guard = worker.peak_guard_bytes if peak else worker.current_guard_bytes
+    rss = worker.peak_rss_bytes if peak else worker.current_rss_bytes
+    return guard if guard > 0 else rss
+
+
+def _reproduction_command(worker: WorkerView | None, stage: str | None) -> str | None:
+    """Return one exact persisted command without regenerating or normalizing it."""
+
+    if worker is None or stage not in _REPRODUCTION_STAGES:
+        return None
+    value = getattr(worker, f"reproduce_{stage}")
+    return value if isinstance(value, str) and value else None
+
+
+def _available_reproduction_stages(worker: WorkerView | None) -> tuple[str, ...]:
+    return tuple(
+        stage
+        for stage in _REPRODUCTION_STAGES
+        if _reproduction_command(worker, stage) is not None
+    )
+
+
+def _cycle_reproduction_stage(state: DashboardState, step: int = 1) -> None:
+    available = _available_reproduction_stages(state.selected_worker())
+    if not available:
+        state.command_stage = None
+        state.command_notice = "No public CLI reproduction is available"
+        state.command_scroll = 0
+        return
+    try:
+        index = available.index(state.command_stage or "")
+    except ValueError:
+        index = -1 if step >= 0 else 0
+    state.command_stage = available[(index + step) % len(available)]
+    state.command_scroll = 0
+    state.command_notice = None
+
+
+def _osc52_clipboard_sequence(value: str) -> str:
+    """Encode an explicitly requested clipboard copy without a subprocess."""
+
+    encoded = base64.b64encode(value.encode("utf-8")).decode("ascii")
+    return f"\x1b]52;c;{encoded}\x07"
+
+
+def _phase_timeline_lines(
+    rows: Sequence[PhaseTimelineRow],
+    *,
+    compact: bool,
+    limit: int,
+) -> tuple[str, ...]:
+    """Render a small aligned phase table that remains legible at 80 columns."""
+
+    rendered: list[str] = []
+    for row in rows[: max(0, limit)]:
+        wall = (
+            "unavailable"
+            if row.wall_seconds is None
+            else _human_phase_duration(row.wall_seconds)
+        )
+        outcome = (
+            " · ".join(value for value in (row.status, row.detail) if value)
+            or "recorded"
+        )
+        if compact:
+            rendered.append(f"{row.phase[:20]} · {wall} · {outcome}")
+            continue
+        cpu = (
+            "unavailable"
+            if row.cpu_seconds is None
+            else _human_phase_duration(row.cpu_seconds)
+        )
+        peak = (
+            "unavailable"
+            if row.peak_memory_bytes is None
+            else _human_bytes(row.peak_memory_bytes)
+        )
+        rendered.append(
+            f"{row.phase[:20]:<20}  {wall:>11}  {cpu:>11}  {peak:>11}  {outcome}"
+        )
+    if len(rows) > len(rendered):
+        rendered.append(f"… {len(rows) - len(rendered)} more persisted phases")
+    return tuple(rendered)
+
+
+def _worker_from_lease(
+    cell_id: str,
+    raw: Mapping[str, object],
+    *,
+    peer_instance: str | None,
+) -> WorkerView:
+    """Decode one informational worker row without following referenced paths."""
+
+    def optional_text(key: str) -> str | None:
+        value = raw.get(key)
+        return value if isinstance(value, str) and value else None
+
+    def text(key: str, default: str) -> str:
+        value = optional_text(key)
+        return default if value is None else value
+
+    raw_status = text("status", "unknown")
+    recycled = raw.get("recycled") is True or raw_status in _RECYCLED_SUCCESS_STATUSES
+    worker = WorkerView(
+        cell_id=cell_id,
+        dependency=raw.get("dependency") is True,
+        peer_instance=peer_instance,
+        generation_engine=optional_text("generation_engine"),
+        status="recycled" if raw_status in _RECYCLED_SUCCESS_STATUSES else raw_status,
+        step=text("step", "waiting"),
+        phase=text("phase", "unknown"),
+        attempt_id=optional_text("attempt_id"),
+        pid=_optional_int(raw.get("pid")),
+        wall_seconds=max(0.0, _finite_float(raw.get("wall_seconds"))),
+        cpu_seconds=(
+            None
+            if (cpu_seconds := _optional_finite_float(raw.get("cpu_seconds"))) is None
+            else max(0.0, cpu_seconds)
+        ),
+        current_rss_bytes=max(
+            0,
+            _optional_int(raw.get("current_rss_bytes")) or 0,
+        ),
+        peak_rss_bytes=max(
+            0,
+            _optional_int(raw.get("peak_rss_bytes")) or 0,
+        ),
+        current_physical_footprint_bytes=_optional_int(
+            raw.get("current_physical_footprint_bytes")
+        ),
+        peak_physical_footprint_bytes=_optional_int(
+            raw.get("peak_physical_footprint_bytes")
+        ),
+        current_guard_bytes=max(
+            0,
+            _optional_int(raw.get("current_guard_bytes")) or 0,
+        ),
+        peak_guard_bytes=max(
+            0,
+            _optional_int(raw.get("peak_guard_bytes")) or 0,
+        ),
+        child_count=max(0, _optional_int(raw.get("child_count")) or 0),
+        progress_completed=_optional_int(raw.get("progress_completed")),
+        progress_total=_optional_int(raw.get("progress_total")),
+        progress_message=text("progress_message", ""),
+        progress_task_id=optional_text("progress_task_id"),
+        log_path=optional_text("log_path"),
+        progress_path=optional_text("progress_path"),
+        reproduce_prepare=optional_text("reproduce_prepare"),
+        reproduce_generate=optional_text("reproduce_generate"),
+        reproduce_profile=optional_text("reproduce_profile"),
+        published_wall_seconds_per_point=_optional_finite_float(
+            raw.get("published_wall_seconds_per_point")
+        ),
+        published_evaluator_total_seconds_per_point=_optional_finite_float(
+            raw.get("published_evaluator_total_seconds_per_point")
+        ),
+        published_recurrence_core_seconds_per_point=_optional_finite_float(
+            raw.get("published_recurrence_core_seconds_per_point")
+        ),
+        phase_timeline=_lease_phase_timeline_rows(raw.get("phase_timeline")),
+        provenance_summary=optional_text("provenance_summary"),
+        reuse_explanation=optional_text("reuse_explanation"),
+        blocked_prerequisite_ids=tuple(
+            sorted(
+                {
+                    str(value)
+                    for value in raw.get("blocked_prerequisite_ids", ())
+                    if isinstance(value, str) and value
+                }
+            )
+        )
+        if isinstance(raw.get("blocked_prerequisite_ids"), Sequence)
+        and not isinstance(raw.get("blocked_prerequisite_ids"), (str, bytes))
+        else (),
+        recycled=recycled,
+        updated_at=max(0.0, _finite_float(raw.get("updated_at"))),
+    )
+    raw_member_pids = raw.get("member_pids")
+    if isinstance(raw_member_pids, Sequence) and not isinstance(
+        raw_member_pids,
+        (str, bytes),
+    ):
+        worker.member_pids = tuple(
+            value
+            for item in raw_member_pids
+            if (value := _optional_int(item)) is not None and value >= 0
+        )
+    raw_progress_details = raw.get("progress_details")
+    if isinstance(raw_progress_details, Mapping):
+        worker.progress_details = {
+            str(key): value
+            for key, value in raw_progress_details.items()
+            if value is None or isinstance(value, (bool, int, float, str))
+        }
+    raw_events = raw.get("events")
+    if isinstance(raw_events, Sequence) and not isinstance(
+        raw_events,
+        (str, bytes),
+    ):
+        worker.events = [str(value) for value in raw_events[-8:]]
+    raw_log_tail = raw.get("log_tail")
+    if isinstance(raw_log_tail, Sequence) and not isinstance(
+        raw_log_tail,
+        (str, bytes),
+    ):
+        worker.log_tail = [
+            _dashboard_log_line(str(value))
+            for value in raw_log_tail[-MAX_LOG_TAIL_LINES:]
+        ]
+    return worker
+
+
+def _live_lease_workers(
+    service: ReportService,
+    selected_ids: frozenset[str],
+    *,
+    exclude_instance: str,
+    source_revision: str,
+) -> tuple[WorkerView, ...]:
+    root = service.paths.coordination_root / "manual-leases"
+    now = time.time()
+    workers: list[WorkerView] = []
+    if not root.is_dir():
+        return ()
+    for path in root.glob("*.json"):
+        payload = _read_object(path)
+        if payload is None:
+            continue
+        updated = _finite_float(payload.get("updated_at"))
+        if now - updated > DEFAULT_WORKER_STALE_SECONDS:
+            continue
+        instance_id = str(payload.get("instance_id") or "")
+        if not instance_id or instance_id == exclude_instance:
+            continue
+        if payload.get("source_revision") != source_revision:
+            continue
+        raw_workers = payload.get("workers")
+        if not isinstance(raw_workers, Mapping):
+            continue
+        for cell_id, raw in raw_workers.items():
+            if cell_id not in selected_ids or not isinstance(raw, Mapping):
+                continue
+            worker = _worker_from_lease(
+                str(cell_id),
+                raw,
+                peer_instance=instance_id,
+            )
+            if worker.status in {"queued", "preparing", "running"}:
+                workers.append(worker)
+    return tuple(workers)
+
+
+def _merge_peer_workers(
+    service: ReportService,
+    state: DashboardState,
+) -> None:
+    for key in tuple(state.workers):
+        if state.workers[key].peer_instance is not None:
+            del state.workers[key]
+    peers = _live_lease_workers(
+        service,
+        frozenset(state.selected_ids),
+        exclude_instance=state.instance_id,
+        source_revision=state.source_revision,
+    )
+    for worker in peers:
+        state.workers[f"peer:{worker.peer_instance}:{worker.cell_id}"] = worker
+
+
+def _lease_counter_snapshot(value: object) -> dict[str, int] | None:
+    if not isinstance(value, Mapping):
+        return None
+    counters: dict[str, int] = {}
+    for key in _DASHBOARD_COUNTER_KEYS:
+        observed = _optional_int(
+            value.get(key, 0 if key == "unverified" else None)
+        )
+        if observed is None or observed < 0:
+            return None
+        counters[key] = observed
+    return counters
+
+
+def _lease_limits(
+    value: object,
+) -> tuple[float, int, float | None] | None:
+    """Decode effective invocation caps, retaining defaults for old leases."""
+
+    if value is None:
+        return (
+            DEFAULT_GENERATION_LIMIT_SECONDS,
+            DEFAULT_RAM_BYTES,
+            DEFAULT_WORKER_WALL_LIMIT_SECONDS,
+        )
+    if not isinstance(value, Mapping):
+        return None
+    generation = _optional_finite_float(value.get("generation_time_limit_seconds"))
+    memory = _optional_int(value.get("memory_limit_bytes"))
+    raw_wall = value.get("worker_wall_limit_seconds")
+    wall = None if raw_wall is None else _optional_finite_float(raw_wall)
+    if (
+        generation is None
+        or generation <= 0.0
+        or memory is None
+        or memory <= 0
+        or (raw_wall is not None and (wall is None or wall <= 0.0))
+    ):
+        return None
+    return generation, memory, wall
+
+
+def _lease_scheduler_state(value: object) -> tuple[int, int, int]:
+    if not isinstance(value, Mapping):
+        return (0, 0, 0)
+    observed = tuple(
+        _optional_int(value.get(key))
+        for key in ("ready", "waiting_dependency", "waiting_coordination_lock")
+    )
+    if any(item is None or item < 0 for item in observed):
+        return (0, 0, 0)
+    return tuple(int(item) for item in observed)  # type: ignore[arg-type,return-value]
+
+
+def _live_dashboard_snapshot(
+    coordination_root: Path,
+    *,
+    instance: str | None,
+    stale_after_seconds: float,
+    now: float | None = None,
+) -> DashboardState:
+    """Build one read-only frame from compact, non-stale lease JSON only."""
+
+    if not math.isfinite(stale_after_seconds) or stale_after_seconds <= 0.0:
+        raise ManualCampaignError("--stale-after must be a positive finite value")
+    lease_root = coordination_root / "manual-leases"
+    current_time = time.time() if now is None else now
+    records: list[dict[str, object]] = []
+    if lease_root.is_dir():
+        for path in sorted(lease_root.glob("*.json")):
+            payload = _read_object(path)
+            if payload is None or payload.get("schema") != MANUAL_STATE_SCHEMA:
+                continue
+            instance_id = payload.get("instance_id")
+            source_revision = payload.get("source_revision")
+            updated_at = _optional_finite_float(payload.get("updated_at"))
+            counters = _lease_counter_snapshot(payload.get("counters"))
+            limits = _lease_limits(payload.get("limits"))
+            workers = payload.get("workers")
+            if (
+                not isinstance(instance_id, str)
+                or not instance_id
+                or len(instance_id) > 128
+                or not isinstance(source_revision, str)
+                or not source_revision
+                or updated_at is None
+                or updated_at <= 0.0
+                or current_time - updated_at > stale_after_seconds
+                or counters is None
+                or limits is None
+                or not isinstance(workers, Mapping)
+            ):
+                continue
+            records.append(payload)
+    if not records:
+        raise ManualCampaignError(
+            "no active manual-campaign lease is available; start `run` in "
+            "another terminal or increase --stale-after"
+        )
+
+    chosen: dict[str, object] | None = None
+    if instance is not None:
+        exact = [
+            payload for payload in records if payload.get("instance_id") == instance
+        ]
+        matches = (
+            exact
+            if exact
+            else [
+                payload
+                for payload in records
+                if str(payload.get("instance_id")).startswith(instance)
+            ]
+        )
+        identifiers = sorted({str(payload.get("instance_id")) for payload in matches})
+        if not matches:
+            available = ", ".join(
+                sorted(str(payload.get("instance_id")) for payload in records)
+            )
+            raise ManualCampaignError(
+                f"no active lease matches instance {instance!r}; available: {available}"
+            )
+        if len(identifiers) > 1:
+            raise ManualCampaignError(
+                f"instance prefix {instance!r} is ambiguous: " + ", ".join(identifiers)
+            )
+        chosen = max(
+            matches,
+            key=lambda payload: _finite_float(payload.get("updated_at")),
+        )
+    else:
+        chosen = max(
+            records,
+            key=lambda payload: _finite_float(payload.get("updated_at")),
+        )
+
+    instance_id = str(chosen["instance_id"])
+    source_revision = str(chosen["source_revision"])
+    updated_at = _finite_float(chosen["updated_at"])
+    started_at = _optional_finite_float(chosen.get("started_at")) or updated_at
+    counters = _lease_counter_snapshot(chosen["counters"])
+    assert counters is not None
+    limits = _lease_limits(chosen.get("limits"))
+    assert limits is not None
+    generation_limit, memory_limit, wall_limit = limits
+    ready_count, waiting_dependency_count, waiting_coordination_lock_count = (
+        _lease_scheduler_state(chosen.get("scheduler"))
+    )
+    state = DashboardState(
+        instance_id=instance_id,
+        selected_ids=(),
+        recycled_ids=set(),
+        static_na_ids=set(),
+        source_revision=source_revision,
+        generation_time_limit_seconds=generation_limit,
+        memory_limit_bytes=memory_limit,
+        worker_wall_limit_seconds=wall_limit,
+        started_at=min(started_at, current_time),
+        counter_snapshot=counters,
+        lease_updated_at=updated_at,
+        live_snapshot=True,
+        ready_count=ready_count,
+        waiting_dependency_count=waiting_dependency_count,
+        waiting_coordination_lock_count=waiting_coordination_lock_count,
+    )
+    raw_workers = chosen["workers"]
+    assert isinstance(raw_workers, Mapping)
+    for cell_id, raw in raw_workers.items():
+        if not isinstance(cell_id, str) or not cell_id or not isinstance(raw, Mapping):
+            continue
+        state.workers[cell_id] = _worker_from_lease(
+            cell_id,
+            raw,
+            peer_instance=None,
+        )
+
+    # Show active workers from concurrent same-source instances as peer rows.
+    # The overview counters remain the chosen invocation's own atomic snapshot,
+    # avoiding guesses or double-counting when selections overlap.
+    for payload in records:
+        peer_instance = str(payload["instance_id"])
+        if (
+            peer_instance == instance_id
+            or payload.get("source_revision") != source_revision
+        ):
+            continue
+        raw_peer_workers = payload["workers"]
+        assert isinstance(raw_peer_workers, Mapping)
+        for cell_id, raw in raw_peer_workers.items():
+            if (
+                not isinstance(cell_id, str)
+                or not cell_id
+                or not isinstance(raw, Mapping)
+            ):
+                continue
+            worker = _worker_from_lease(
+                cell_id,
+                raw,
+                peer_instance=peer_instance,
+            )
+            if worker.status not in {"queued", "preparing", "running"}:
+                continue
+            state.workers[f"peer:{peer_instance}:{cell_id}"] = worker
+
+    ordered_workers = state.visible_workers()
+    state.selected_index = next(
+        (
+            index
+            for index, worker in enumerate(ordered_workers)
+            if worker.status in _ACTIVE_WORKER_STATUSES
+        ),
+        0,
+    )
+    return state
+
+
+def _snapshot_fixture(
+    *,
+    selected: int = 1796,
+    recycled: int = 318,
+    completed: int = 41,
+) -> DashboardState:
+    state = DashboardState(
+        instance_id="snapshot-demo",
+        selected_ids=tuple(f"cell-{index:04d}" for index in range(selected)),
+        recycled_ids={f"cell-{index:04d}" for index in range(recycled)},
+        static_na_ids={f"cell-{index:04d}" for index in range(12)},
+        source_revision="5b58aeb7600548e84e7214ee0ef62e5f159ec3fb",
+    )
+    for index in range(recycled, recycled + completed):
+        state._reduce_finished(f"cell-{index:04d}", "ok")
+    state._reduce_finished("cell-0412", "memory_limit")
+    state._reduce_finished("cell-0413", "error")
+    state.dependency_ids = {"reference-amplicol-lc-n6-dd-zzz-jets-selected-flow"}
+    state.workers = {
+        "matrix-compiled-builtin-sm-lc-n9-dd-zzz-jets-selected-flow": WorkerView(
+            "matrix-compiled-builtin-sm-lc-n9-dd-zzz-jets-selected-flow",
+            generation_engine=ExecutionMode.COMPILED.value,
+            status="running",
+            step="native Arena sample 4/8",
+            phase="profiling",
+            attempt_id="b92b46a0-demo",
+            pid=42173,
+            member_pids=(42173, 42174, 42175),
+            wall_seconds=412.8,
+            cpu_seconds=971.2,
+            current_rss_bytes=8_724_300_000,
+            peak_rss_bytes=11_941_200_000,
+            child_count=2,
+            progress_completed=4,
+            progress_total=8,
+            progress_message="native Arena sample 4/8",
+            published_wall_seconds_per_point=0.000_669_99,
+            published_evaluator_total_seconds_per_point=0.000_654_31,
+            events=[
+                "generation: compiled Direct-Arena complete",
+                "profiling: warmups complete",
+                "profiling: native Arena sample 4/8",
+            ],
+        ),
+        "matrix-recurrence-ufo-sm-lc-n7-gg-gluons-all-flow": WorkerView(
+            "matrix-recurrence-ufo-sm-lc-n7-gg-gluons-all-flow",
+            generation_engine=ExecutionMode.RECURRENCE.value,
+            status="ok",
+            step="measurement published",
+            phase="complete",
+            attempt_id="dd84040e-demo",
+            pid=42191,
+            member_pids=(42191,),
+            wall_seconds=224.7,
+            cpu_seconds=216.3,
+            current_rss_bytes=3_252_000_000,
+            peak_rss_bytes=4_018_000_000,
+            progress_completed=72,
+            progress_total=72,
+            progress_message="measurement published",
+            published_wall_seconds_per_point=218.105e-6,
+            published_evaluator_total_seconds_per_point=217.812e-6,
+            published_recurrence_core_seconds_per_point=205.431e-6,
+            events=[
+                "generation: model loaded",
+                "generation: recurrence plan projected",
+                "profiling: independent clocks published",
+            ],
+        ),
+        "reference-amplicol-full-n6-dd-3q-lines-contracted": WorkerView(
+            "reference-amplicol-full-n6-dd-3q-lines-contracted",
+            dependency=True,
+            generation_engine=ExecutionMode.AMPLICOL.value,
+            status="preparing",
+            step="prewarming original AmpliCol generator",
+            phase="preparation",
+            wall_seconds=8.3,
+            current_rss_bytes=181_000_000,
+            peak_rss_bytes=205_000_000,
+            events=["preparation: legacy generator prewarm"],
+        ),
+    }
+    worker_ids = tuple(state.workers)
+    state._reduce_finished(
+        "matrix-recurrence-ufo-sm-lc-n7-gg-gluons-all-flow",
+        "ok",
+    )
+    state.selected_ids = (
+        *worker_ids,
+        *(f"cell-{index:04d}" for index in range(max(0, selected - len(worker_ids)))),
+    )
+    return state
+
+
+def _append_dashboard_line(
+    paragraph: Any,
+    spans: Sequence[tuple[str, object]],
+) -> None:
+    """Append a styled line through Ratatui's stable single-span API."""
+
+    for text, style in spans:
+        paragraph.append_span(text, style)
+    paragraph.line_break()
+
+
+def _fit_dashboard_field(value: object, width: int) -> str:
+    text = str(value)
+    if width <= 0:
+        return ""
+    if len(text) > width:
+        text = text[: max(0, width - 1)] + "…"
+    return text.ljust(width)
+
+
+def _append_detail_fields(
+    paragraph: Any,
+    fields: Sequence[tuple[str, object, object]],
+    *,
+    width: int,
+    compact: bool,
+    key_style: object,
+) -> None:
+    """Render fixed detail columns so keys and values retain vertical anchors."""
+
+    content_width = max(20, width - 4)
+    gutter = 1 if compact else 3
+    group_width = max(20, (content_width - gutter) // 2)
+    key_width = min(16 if compact else 18, max(12, group_width // 2))
+    value_width = max(1, group_width - key_width)
+    for offset in range(0, len(fields), 2):
+        spans: list[tuple[str, object]] = []
+        for local_index, (key, value, value_style) in enumerate(
+            fields[offset : offset + 2]
+        ):
+            if local_index:
+                spans.append((" " * gutter, key_style))
+            spans.extend(
+                (
+                    (f"{key:<{key_width}}", key_style),
+                    (_fit_dashboard_field(value, value_width), value_style),
+                )
+            )
+        _append_dashboard_line(paragraph, spans)
+
+
+def _ratatui_commands(
+    state: DashboardState,
+    *,
+    width: int,
+    height: int,
+    color: bool = True,
+) -> list[object]:
+    try:
+        from ratatui import Color, DrawCmd, Gauge, Paragraph
+        from ratatui import Style as RStyle
+    except ImportError as error:
+        raise ManualCampaignError(
+            "Ratatui is unavailable; run `just dev-install`"
+        ) from error
+
+    counters = state.counters()
+    peer_active_count = len(state.peer_active)
+    compact = width < 105 or height < 30
+    overview_height = 7 if compact else 8
+    table_height = max(7, min(13, height // 3) - (1 if compact else 0))
+    footer_height = 1
+    detail_y = overview_height + table_height
+    detail_height = max(4, height - detail_y - footer_height)
+
+    if color:
+        title_style = RStyle(fg=Color.Cyan).bold()
+        key_style = RStyle(fg=Color.Cyan).bold()
+        success_style = RStyle(fg=Color.Green)
+        warning_style = RStyle(fg=Color.Yellow)
+        failure_style = RStyle(fg=Color.Red)
+        neutral_style = RStyle(fg=Color.White)
+        muted_style = RStyle(fg=Color.DarkGray).dim()
+        metric_style = RStyle(fg=Color.LightCyan)
+        memory_style = RStyle(fg=Color.LightMagenta)
+        table_header_style = RStyle(fg=Color.LightCyan).bold().underlined()
+        summary_style = RStyle(fg=Color.LightCyan, bg=Color.DarkGray).bold()
+        highlight_style = RStyle(fg=Color.Black, bg=Color.Cyan).bold()
+        gauge_label_style = RStyle(fg=Color.White).bold()
+        gauge_value_style = RStyle(fg=Color.Green, bg=Color.Black).bold()
+    else:
+        title_style = RStyle()
+        key_style = RStyle()
+        success_style = RStyle()
+        warning_style = RStyle()
+        failure_style = RStyle()
+        neutral_style = RStyle()
+        muted_style = RStyle()
+        metric_style = RStyle()
+        memory_style = RStyle()
+        table_header_style = RStyle()
+        summary_style = RStyle()
+        highlight_style = RStyle()
+        gauge_label_style = RStyle()
+        gauge_value_style = RStyle()
+
+    def status_style(status: str) -> object:
+        if status in {"error", "failed", "blocked_dependency"}:
+            return failure_style
+        if status in {
+            *_TERMINAL_CAP_STATUSES,
+            "timeout",
+            "cancelled",
+            ResultStatus.UNVERIFIED.value,
+        }:
+            return warning_style
+        if status in _COMPLETED_WORKER_STATUSES:
+            return success_style
+        if status in _ACTIVE_WORKER_STATUSES:
+            return warning_style
+        return muted_style
+
+    def phase_style(phase: str) -> object:
+        normalized = phase.casefold().replace("_", "-")
+        if "profil" in normalized:
+            return metric_style
+        if "generat" in normalized or "post-generation" in normalized:
+            return memory_style
+        if normalized in {"complete", "completed"}:
+            return success_style
+        if "prepar" in normalized:
+            return warning_style
+        return neutral_style
+
+    def outcome_style(status: str | None) -> object:
+        normalized = (status or "").casefold()
+        if any(value in normalized for value in ("error", "failed")):
+            return failure_style
+        if any(value in normalized for value in ("limit", "capped", "timeout")):
+            return warning_style
+        if any(
+            value in normalized
+            for value in ("measured", "completed", "reused", "observed")
+        ):
+            return success_style
+        if any(value in normalized for value in ("unavailable", "not_applicable")):
+            return muted_style
+        return neutral_style
+
+    overview = Paragraph.new_empty()
+    overview.set_block_title(
+        f" LIVE pyAmpliCol profiling campaign · {state.instance_id[:12]} "
+        if state.live_snapshot
+        else " pyAmpliCol profiling campaign "
+    )
+    selection_progress = [
+        ("Selected ", key_style),
+        (str(counters["selected"]), neutral_style),
+        ("   Recycled ", key_style),
+        (str(counters["recycled"]), success_style),
+        ("   Completed ", key_style),
+        (str(counters["completed"]), success_style),
+        ("   Remaining ", key_style),
+        (str(counters["remaining"]), neutral_style),
+    ]
+    selection_issues = [
+        ("   Capped ", key_style),
+        (str(counters["capped"]), warning_style),
+        ("   Errors ", key_style),
+        (str(counters["failed"]), failure_style),
+        ("   Unverified ", key_style),
+        (str(counters["unverified"]), warning_style),
+    ]
+    if compact:
+        _append_dashboard_line(overview, selection_progress)
+        _append_dashboard_line(
+            overview,
+            [
+                *selection_issues,
+                ("   Static N/A ", key_style),
+                (str(counters["static_na"]), warning_style),
+            ],
+        )
+    else:
+        _append_dashboard_line(overview, [*selection_progress, *selection_issues])
+    worker_scope = [
+        ("Workers active ", key_style),
+        (str(counters["active"]), warning_style),
+        ("   selected ", key_style),
+        (str(counters["selected_active"]), warning_style),
+        ("   dependency ", key_style),
+        (str(counters["dependency_active"]), warning_style),
+        *(
+            (
+                ("   Peer active ", key_style),
+                (str(peer_active_count), metric_style),
+            )
+            if peer_active_count
+            else ()
+        ),
+        *(
+            ()
+            if compact
+            else (
+                ("   Static N/A ", key_style),
+                (str(counters["static_na"]), warning_style),
+            )
+        ),
+        ("   Dependency-only ", key_style),
+        (str(counters["dependency_only"]), neutral_style),
+        *(
+            (
+                ("   Dependency done ", key_style),
+                (str(counters["dependency_completed"]), success_style),
+                ("   issues ", key_style),
+                (str(counters["dependency_issues"]), failure_style),
+            )
+            if not compact
+            else ()
+        ),
+    ]
+    _append_dashboard_line(overview, worker_scope)
+    _append_dashboard_line(
+        overview,
+        [
+            ("Ready ", key_style),
+            (str(state.ready_count), success_style),
+            ("   Waiting dependency ", key_style),
+            (str(state.waiting_dependency_count), muted_style),
+            ("   Waiting coordination lock ", key_style),
+            (str(state.waiting_coordination_lock_count), warning_style),
+        ],
+    )
+    _append_dashboard_line(
+        overview,
+        [
+            ("Caps ", key_style),
+            ("Generation ", key_style),
+            (
+                _human_duration(state.generation_time_limit_seconds),
+                warning_style,
+            ),
+            ("   RAM ", key_style),
+            (_human_bytes(state.memory_limit_bytes), warning_style),
+            ("   Total wall ", key_style),
+            (
+                (
+                    "disabled"
+                    if state.worker_wall_limit_seconds is None
+                    else _human_duration(state.worker_wall_limit_seconds)
+                ),
+                warning_style,
+            ),
+        ],
+    )
+    if not compact:
+        _append_dashboard_line(
+            overview,
+            [
+                ("Elapsed ", key_style),
+                (_human_duration(time.time() - state.started_at), neutral_style),
+                ("   Source ", key_style),
+                (state.source_revision[:12] or "unavailable", neutral_style),
+                *(
+                    (
+                        ("   Lease age ", key_style),
+                        (
+                            _human_duration(
+                                max(0.0, time.time() - state.lease_updated_at)
+                            ),
+                            success_style,
+                        ),
+                    )
+                    if state.lease_updated_at is not None
+                    else ()
+                ),
+            ],
+        )
+        _append_dashboard_line(
+            overview,
+            [
+                ("Clocks ", key_style),
+                (
+                    "outer wall, evaluator-total, and recurrence core stay independent",
+                    neutral_style,
+                ),
+            ],
+        )
+
+    workers = state.visible_workers()
+    selected_index = 0
+    viewport_start = 0
+    viewport_capacity = max(1, table_height - 3)
+    if workers:
+        selected_index = state.selected_index % len(workers)
+        state.selected_index = selected_index
+        viewport_start = min(
+            max(0, selected_index - viewport_capacity + 1),
+            max(0, len(workers) - viewport_capacity),
+        )
+    viewport = workers[viewport_start : viewport_start + viewport_capacity]
+    viewport_end = viewport_start + len(viewport)
+    worker_table = Paragraph.new_empty()
+    worker_table.set_block_title(
+        " Workers ↑/↓"
+        f" · {viewport_start + 1 if viewport else 0}-{viewport_end}/{len(workers)}"
+        f" · d done:{'on' if state.show_completed else 'off'}"
+        f" · e errors:{'on' if state.show_errors else 'off'} "
+    )
+    if compact:
+        headers = [
+            " ",
+            "cell",
+            "status",
+            "phase / step",
+            "progress",
+            "runtime",
+            "cap guard",
+        ]
+        percentages = [3, 25, 10, 24, 16, 10, 12]
+    else:
+        headers = [
+            " ",
+            "cell",
+            "status",
+            "phase / step",
+            "progress",
+            "runtime",
+            "cap guard",
+            "PID tree",
+        ]
+        percentages = [3, 23, 9, 22, 13, 8, 12, 10]
+    table_content_width = max(len(headers), width - 2)
+    spacing_width = len(headers) - 1
+    distributable_width = max(len(headers), table_content_width - spacing_width)
+    column_widths = [
+        max(1, distributable_width * percentage // 100) for percentage in percentages
+    ]
+    column_widths[-1] += max(
+        0,
+        distributable_width - sum(column_widths),
+    )
+    header_spans: list[tuple[str, object]] = []
+    for header_index, (header, column_width) in enumerate(
+        zip(headers, column_widths, strict=True)
+    ):
+        if header_index:
+            header_spans.append((" ", table_header_style))
+        header_spans.append(
+            (_fit_dashboard_field(header, column_width), table_header_style)
+        )
+    _append_dashboard_line(worker_table, header_spans)
+    for local_index, worker in enumerate(viewport):
+        index = viewport_start + local_index
+        marker = "▶" if index == selected_index else " "
+        enforcement = _worker_enforcement_memory(worker)
+        guard_style = (
+            failure_style
+            if enforcement > state.memory_limit_bytes
+            else (
+                warning_style
+                if enforcement >= int(0.8 * state.memory_limit_bytes)
+                else muted_style
+            )
+        )
+        row_values = [
+            marker,
+            worker.cell_id,
+            (
+                "blocked by dependency"
+                if worker.status == "blocked_dependency"
+                else worker.status
+            ),
+            worker.step,
+            _worker_progress_indicator(worker, compact=compact),
+            _human_duration(worker.wall_seconds),
+            _human_bytes(enforcement),
+        ]
+        row_styles = [
+            title_style,
+            title_style if index == selected_index else neutral_style,
+            status_style(worker.status),
+            phase_style(worker.phase),
+            status_style(worker.status),
+            metric_style,
+            guard_style,
+        ]
+        if not compact:
+            row_values.append(
+                "—"
+                if worker.pid is None
+                else f"{worker.pid}+{max(0, len(worker.member_pids) - 1)}"
+            )
+            row_styles.append(muted_style)
+        row_spans: list[tuple[str, object]] = []
+        for column_index, (value, value_style, column_width) in enumerate(
+            zip(row_values, row_styles, column_widths, strict=True)
+        ):
+            rendered_style = highlight_style if index == selected_index else value_style
+            if column_index:
+                row_spans.append((" ", rendered_style))
+            row_spans.append(
+                (_fit_dashboard_field(value, column_width), rendered_style)
+            )
+        _append_dashboard_line(worker_table, row_spans)
+    worker_table.set_wrap(False)
+
+    selected = state.selected_worker()
+    details = Paragraph.new_empty()
+    details.set_block_title(
+        " Dashboard help " if state.show_help else " Selected worker "
+    )
+    if state.show_help:
+        _append_dashboard_line(
+            details, [("↑/↓ or j/k ", key_style), ("select worker", neutral_style)]
+        )
+        _append_dashboard_line(
+            details,
+            [("PgUp/PgDn ", key_style), ("scroll worker details", neutral_style)],
+        )
+        _append_dashboard_line(
+            details,
+            [
+                ("d ", key_style),
+                ("show/hide completed and successful reused workers", neutral_style),
+            ],
+        )
+        _append_dashboard_line(
+            details,
+            [
+                ("e ", key_style),
+                ("show/hide errors, caps, and recycled attention rows", neutral_style),
+            ],
+        )
+        _append_dashboard_line(
+            details,
+            [
+                ("1/2/3 ", key_style),
+                ("open full prepare/generate/profile command", neutral_style),
+            ],
+        )
+        _append_dashboard_line(
+            details,
+            [
+                ("y / p ", key_style),
+                ("copy exact command / print it for terminal selection", neutral_style),
+            ],
+        )
+        _append_dashboard_line(
+            details, [("? ", key_style), ("close this help", neutral_style)]
+        )
+        _append_dashboard_line(
+            details,
+            [
+                ("Ctrl-C/Esc ", key_style),
+                ("stop dispatch and workers safely", warning_style),
+            ],
+        )
+        ratio = 0.0 if selected is None else _worker_progress_ratio(selected)
+        gauge_label = "keyboard help"
+    elif selected is None:
+        _append_dashboard_line(
+            details,
+            [
+                ("No workers match the current d/e filters", warning_style),
+            ],
+        )
+        ratio = 0.0
+        gauge_label = "filtered"
+    else:
+        _append_dashboard_line(
+            details,
+            [
+                ("Cell ", key_style),
+                (selected.cell_id, title_style),
+                *(
+                    (
+                        ("   Peer ", key_style),
+                        (selected.peer_instance[:12], neutral_style),
+                    )
+                    if selected.peer_instance is not None
+                    else ()
+                ),
+            ],
+        )
+        persisted_summary = (
+            selected.status in _COMPLETED_WORKER_STATUSES or selected.recycled
+        )
+        _append_detail_fields(
+            details,
+            (
+                ("Phase", selected.phase, phase_style(selected.phase)),
+                ("Step", selected.step, neutral_style),
+            ),
+            width=width,
+            compact=compact,
+            key_style=key_style,
+        )
+        if selected.blocked_prerequisite_ids:
+            _append_dashboard_line(
+                details,
+                [
+                    ("Blocked by ", key_style),
+                    (", ".join(selected.blocked_prerequisite_ids), failure_style),
+                ],
+            )
+        if compact and selected.log_tail and not persisted_summary:
+            _append_dashboard_line(
+                details,
+                [
+                    ("Recent log ", key_style),
+                    (selected.log_tail[-1], neutral_style),
+                ],
+            )
+        enforcement_current = _worker_enforcement_memory(selected)
+        enforcement_peak = _worker_enforcement_memory(selected, peak=True)
+        enforcement_style = (
+            failure_style
+            if enforcement_current > state.memory_limit_bytes
+            else warning_style
+        )
+        if compact and not persisted_summary:
+            _append_detail_fields(
+                details,
+                (
+                    (
+                        "Guard current",
+                        _human_bytes(enforcement_current),
+                        enforcement_style,
+                    ),
+                    ("Guard peak", _human_bytes(enforcement_peak), enforcement_style),
+                    ("RAM cap", _human_bytes(state.memory_limit_bytes), warning_style),
+                    (
+                        "Physical current",
+                        (
+                            "unavailable"
+                            if selected.current_physical_footprint_bytes is None
+                            else _human_bytes(selected.current_physical_footprint_bytes)
+                        ),
+                        (
+                            muted_style
+                            if selected.current_physical_footprint_bytes is None
+                            else memory_style
+                        ),
+                    ),
+                ),
+                width=width,
+                compact=compact,
+                key_style=key_style,
+            )
+        if persisted_summary:
+            if selected.recycled:
+                _append_dashboard_line(
+                    details,
+                    [
+                        (
+                            "No work executed by this invocation",
+                            success_style,
+                        ),
+                    ],
+                )
+                _append_dashboard_line(
+                    details,
+                    [
+                        ("Reuse ", key_style),
+                        (
+                            selected.reuse_explanation or "existing current reused",
+                            neutral_style,
+                        ),
+                    ],
+                )
+            _append_dashboard_line(
+                details,
+                [
+                    ("Provenance ", key_style),
+                    (selected.provenance_summary or "unavailable", neutral_style),
+                ],
+            )
+            if selected.phase_timeline:
+                timeline_phase_width = 38 if width >= 150 else 28
+                _append_dashboard_line(
+                    details,
+                    [("Phase timeline", key_style)],
+                )
+                if compact:
+                    _append_dashboard_line(
+                        details,
+                        [
+                            ("  phase", table_header_style),
+                            (" · wall · outcome", table_header_style),
+                        ],
+                    )
+                else:
+                    _append_dashboard_line(
+                        details,
+                        [
+                            (
+                                f"  {'phase':<{timeline_phase_width}}",
+                                table_header_style,
+                            ),
+                            (f"{'wall':>12}  ", table_header_style),
+                            (f"{'CPU':>12}  ", table_header_style),
+                            (f"{'peak RAM':>12}  ", table_header_style),
+                            ("outcome", table_header_style),
+                        ],
+                    )
+                for timeline_row in selected.phase_timeline:
+                    wall = (
+                        "unavailable"
+                        if timeline_row.wall_seconds is None
+                        else _human_phase_duration(timeline_row.wall_seconds)
+                    )
+                    outcome = (
+                        " · ".join(
+                            value
+                            for value in (timeline_row.status, timeline_row.detail)
+                            if value
+                        )
+                        or "recorded"
+                    )
+                    is_summary = timeline_row.phase.casefold() == "worker supervision"
+                    if compact:
+                        row_style = summary_style if is_summary else neutral_style
+                        _append_dashboard_line(
+                            details,
+                            [
+                                ("Σ " if is_summary else "  ", row_style),
+                                (timeline_row.phase, row_style),
+                                (" · ", row_style),
+                                (
+                                    wall,
+                                    summary_style
+                                    if is_summary
+                                    else (
+                                        muted_style
+                                        if timeline_row.wall_seconds is None
+                                        else metric_style
+                                    ),
+                                ),
+                                (" · ", row_style),
+                                (
+                                    outcome,
+                                    summary_style
+                                    if is_summary
+                                    else outcome_style(timeline_row.status),
+                                ),
+                            ],
+                        )
+                        continue
+                    cpu = (
+                        "unavailable"
+                        if timeline_row.cpu_seconds is None
+                        else _human_phase_duration(timeline_row.cpu_seconds)
+                    )
+                    peak = (
+                        "unavailable"
+                        if timeline_row.peak_memory_bytes is None
+                        else _human_bytes(timeline_row.peak_memory_bytes)
+                    )
+                    row_style = summary_style if is_summary else neutral_style
+                    metric_row_style = summary_style if is_summary else metric_style
+                    unavailable_row_style = summary_style if is_summary else muted_style
+                    _append_dashboard_line(
+                        details,
+                        [
+                            ("Σ " if is_summary else "  ", row_style),
+                            (
+                                _fit_dashboard_field(
+                                    timeline_row.phase,
+                                    timeline_phase_width,
+                                ),
+                                row_style,
+                            ),
+                            (
+                                f"{wall:>12}  ",
+                                unavailable_row_style
+                                if timeline_row.wall_seconds is None
+                                else metric_row_style,
+                            ),
+                            (
+                                f"{cpu:>12}  ",
+                                unavailable_row_style
+                                if timeline_row.cpu_seconds is None
+                                else (summary_style if is_summary else title_style),
+                            ),
+                            (
+                                f"{peak:>12}  ",
+                                unavailable_row_style
+                                if timeline_row.peak_memory_bytes is None
+                                else (summary_style if is_summary else memory_style),
+                            ),
+                            (
+                                outcome,
+                                summary_style
+                                if is_summary
+                                else outcome_style(timeline_row.status),
+                            ),
+                        ],
+                    )
+            else:
+                _append_dashboard_line(
+                    details,
+                    [
+                        ("Phase timeline ", key_style),
+                        ("unavailable (older result)", warning_style),
+                    ],
+                )
+        _append_detail_fields(
+            details,
+            (
+                (
+                    "Wall",
+                    _human_phase_duration(selected.wall_seconds),
+                    metric_style,
+                ),
+                (
+                    "CPU",
+                    (
+                        "unavailable"
+                        if selected.cpu_seconds is None
+                        else _human_phase_duration(selected.cpu_seconds)
+                    ),
+                    muted_style if selected.cpu_seconds is None else metric_style,
+                ),
+            ),
+            width=width,
+            compact=compact,
+            key_style=key_style,
+        )
+        _append_detail_fields(
+            details,
+            (
+                ("RSS current", _human_bytes(selected.current_rss_bytes), memory_style),
+                ("RSS peak", _human_bytes(selected.peak_rss_bytes), memory_style),
+            ),
+            width=width,
+            compact=compact,
+            key_style=key_style,
+        )
+        if selected.current_physical_footprint_bytes is not None and not compact:
+            physical_peak = (
+                selected.peak_physical_footprint_bytes
+                if selected.peak_physical_footprint_bytes is not None
+                else selected.current_physical_footprint_bytes
+            )
+            _append_detail_fields(
+                details,
+                (
+                    (
+                        "Physical current",
+                        _human_bytes(selected.current_physical_footprint_bytes),
+                        memory_style,
+                    ),
+                    ("Physical peak", _human_bytes(physical_peak), memory_style),
+                ),
+                width=width,
+                compact=compact,
+                key_style=key_style,
+            )
+        if not (compact and not persisted_summary):
+            _append_detail_fields(
+                details,
+                (
+                    (
+                        "Guard current",
+                        _human_bytes(enforcement_current),
+                        enforcement_style,
+                    ),
+                    ("Guard peak", _human_bytes(enforcement_peak), enforcement_style),
+                    ("RAM cap", _human_bytes(state.memory_limit_bytes), warning_style),
+                    (
+                        "Physical current" if compact else "Worker wall cap",
+                        (
+                            (
+                                "unavailable"
+                                if selected.current_physical_footprint_bytes is None
+                                else _human_bytes(
+                                    selected.current_physical_footprint_bytes
+                                )
+                            )
+                            if compact
+                            else (
+                                "disabled"
+                                if state.worker_wall_limit_seconds is None
+                                else _human_duration(state.worker_wall_limit_seconds)
+                            )
+                        ),
+                        (
+                            muted_style
+                            if (
+                                (
+                                    compact
+                                    and selected.current_physical_footprint_bytes
+                                    is None
+                                )
+                                or (
+                                    not compact
+                                    and state.worker_wall_limit_seconds is None
+                                )
+                            )
+                            else (memory_style if compact else warning_style)
+                        ),
+                    ),
+                ),
+                width=width,
+                compact=compact,
+                key_style=key_style,
+            )
+        evaluator_total = selected.published_evaluator_total_seconds_per_point
+        recurrence_core = selected.published_recurrence_core_seconds_per_point
+        missing_published = (
+            "pending"
+            if selected.status in {"queued", "preparing", "running"}
+            else (
+                "not exposed"
+                if selected.status in _COMPLETED_WORKER_STATUSES
+                else "unavailable"
+            )
+        )
+        missing_recurrence_core = (
+            "not applicable"
+            if selected.generation_engine is not None
+            and selected.generation_engine != ExecutionMode.RECURRENCE.value
+            else missing_published
+        )
+        outer_wall_value = (
+            missing_published
+            if selected.published_wall_seconds_per_point is None
+            else f"{selected.published_wall_seconds_per_point * 1.0e6:.6g} μs/pt"
+        )
+        evaluator_total_value = (
+            missing_published
+            if evaluator_total is None
+            else f"{evaluator_total * 1.0e6:.6g} μs/pt"
+        )
+        _append_detail_fields(
+            details,
+            (
+                (
+                    "Outer wall",
+                    outer_wall_value,
+                    (
+                        muted_style
+                        if selected.published_wall_seconds_per_point is None
+                        else metric_style
+                    ),
+                ),
+                (
+                    "Evaluator total",
+                    evaluator_total_value,
+                    muted_style if evaluator_total is None else metric_style,
+                ),
+            ),
+            width=width,
+            compact=compact,
+            key_style=key_style,
+        )
+        recurrence_value = (
+            missing_recurrence_core
+            if recurrence_core is None
+            else f"{recurrence_core * 1.0e6:.6g} μs/pt"
+        )
+        _append_detail_fields(
+            details,
+            (
+                (
+                    "Recurrence core",
+                    recurrence_value,
+                    muted_style if recurrence_core is None else metric_style,
+                ),
+                ("Attribution", "independent narrow clock", muted_style),
+            ),
+            width=width,
+            compact=compact,
+            key_style=key_style,
+        )
+        if not compact:
+            progress_details = _progress_detail_summary(selected.progress_details)
+            if progress_details:
+                _append_dashboard_line(
+                    details,
+                    [
+                        ("Progress data ", key_style),
+                        (progress_details, neutral_style),
+                    ],
+                )
+            _append_detail_fields(
+                details,
+                (
+                    (
+                        "PID tree",
+                        ", ".join(str(value) for value in selected.member_pids) or "—",
+                        metric_style,
+                    ),
+                    ("Attempt", selected.attempt_id or "—", neutral_style),
+                ),
+                width=width,
+                compact=compact,
+                key_style=key_style,
+            )
+        if selected.log_tail and not compact and not persisted_summary:
+            for index, line in enumerate(selected.log_tail[-3:]):
+                _append_dashboard_line(
+                    details,
+                    [
+                        ("Recent log " if index == 0 else "           ", key_style),
+                        (line, neutral_style),
+                    ],
+                )
+        if not compact:
+            visible_events = _coalesced_worker_events(selected.events)
+            if not persisted_summary:
+                for event in visible_events[-max(1, detail_height - 6) :]:
+                    _append_dashboard_line(
+                        details,
+                        [("• ", key_style), (event, neutral_style)],
+                    )
+            available_commands = _available_reproduction_stages(selected)
+            if available_commands:
+                _append_dashboard_line(
+                    details,
+                    [
+                        ("Commands ", key_style),
+                        *(
+                            span
+                            for stage in available_commands
+                            for span in (
+                                (
+                                    f"{_REPRODUCTION_STAGES.index(stage) + 1} ",
+                                    key_style,
+                                ),
+                                (stage, success_style),
+                                ("   ", neutral_style),
+                            )
+                        ),
+                        ("open full command · y copies there", muted_style),
+                    ],
+                )
+            elif selected.generation_engine == ExecutionMode.AMPLICOL.value:
+                _append_dashboard_line(
+                    details,
+                    [
+                        ("Commands ", key_style),
+                        (
+                            "original AmpliCol uses the report adapter; "
+                            "no public CLI reproduction is available",
+                            muted_style,
+                        ),
+                    ],
+                )
+        ratio = _worker_progress_ratio(selected)
+        gauge_label = (
+            selected.progress_message or f"{selected.phase} {round(100.0 * ratio):d}%"
+        )
+    if selected is not None and state.command_stage is not None:
+        stage = state.command_stage
+        command = _reproduction_command(selected, stage)
+        command_details = Paragraph.new_empty()
+        command_details.set_block_title(
+            f" Reproduction command · {stage} · {selected.cell_id} "
+        )
+        _append_dashboard_line(
+            command_details,
+            [
+                ("Stage ", key_style),
+                (stage, success_style if command is not None else warning_style),
+                ("   1 prepare  2 generate  3 profile  Tab/←/→ cycle", muted_style),
+            ],
+        )
+        _append_dashboard_line(
+            command_details,
+            [
+                ("Copy ", key_style),
+                ("y exact clipboard", success_style),
+                ("   Print ", key_style),
+                ("p normal terminal", metric_style),
+                *(
+                    ()
+                    if compact
+                    else (("   Scroll PgUp/PgDn   Close Esc", muted_style),)
+                ),
+            ],
+        )
+        if compact:
+            _append_dashboard_line(
+                command_details,
+                [("Scroll PgUp/PgDn   Close Esc", muted_style)],
+            )
+        if state.command_notice:
+            _append_dashboard_line(
+                command_details,
+                [
+                    ("Status ", key_style),
+                    (
+                        state.command_notice,
+                        warning_style
+                        if "unavailable" in state.command_notice.casefold()
+                        else success_style,
+                    ),
+                ],
+            )
+        if command is None:
+            _append_dashboard_line(
+                command_details,
+                [
+                    ("Unavailable ", warning_style),
+                    (
+                        "this worker does not expose that public CLI stage",
+                        muted_style,
+                    ),
+                ],
+            )
+        else:
+            wrapped = textwrap.wrap(
+                command,
+                width=max(24, width - 6),
+                break_long_words=True,
+                break_on_hyphens=False,
+                replace_whitespace=False,
+                drop_whitespace=True,
+            ) or [command]
+            header_lines = (4 if compact else 3) + bool(state.command_notice)
+            command_capacity = max(1, detail_height - 4 - header_lines)
+            command_start = min(
+                max(0, state.command_scroll),
+                max(0, len(wrapped) - command_capacity),
+            )
+            command_end = min(len(wrapped), command_start + command_capacity)
+            _append_dashboard_line(
+                command_details,
+                [
+                    ("Exact command ", key_style),
+                    (
+                        f"{len(command):,} characters · wrapped lines "
+                        f"{command_start + 1}-{command_end}/{len(wrapped)}",
+                        muted_style,
+                    ),
+                ],
+            )
+            for line in wrapped[command_start:command_end]:
+                _append_dashboard_line(
+                    command_details,
+                    [("  ", key_style), (line, neutral_style)],
+                )
+        command_details.set_wrap(False)
+        details = command_details
+    else:
+        details.set_scroll(state.detail_scroll)
+
+    gauge = Gauge().ratio(ratio).label(gauge_label)
+    gauge.set_styles(
+        neutral_style,
+        gauge_label_style,
+        gauge_value_style,
+    )
+    if state.command_stage is not None:
+        footer_text = (
+            (
+                " 1/2/3 stage  Tab cycle  Pg scroll  y copy"
+                "  p print  Esc close  Ctrl-C stop "
+            )
+            if compact
+            else (
+                " 1/2/3 stage  Tab/←/→ cycle  PgUp/PgDn scroll"
+                "  y copy  p print  Esc close  Ctrl-C stop "
+            )
+        )
+    elif compact:
+        footer_text = (
+            " ↑/↓ select  d done  e errors  1/2/3 command  ? help  Ctrl-C stop safely "
+        )
+    else:
+        footer_text = (
+            " ↑/↓ select  d completed  e errors  1/2/3 command"
+            "  PgUp/PgDn details  ? help  Ctrl-C stop safely "
+        )
+    footer = Paragraph.from_text(footer_text)
+
+    return [
+        DrawCmd.paragraph(overview, (0, 0, width, overview_height)),
+        DrawCmd.paragraph(worker_table, (0, overview_height, width, table_height)),
+        DrawCmd.paragraph(details, (0, detail_y, width, detail_height - 2)),
+        DrawCmd.gauge(gauge, (0, height - 3, width, 2)),
+        DrawCmd.paragraph(footer, (0, height - 1, width, footer_height)),
+    ]
+
+
+def render_dashboard_frame(
+    state: DashboardState,
+    *,
+    width: int,
+    height: int,
+    cells: bool = False,
+    color: bool = True,
+) -> object:
+    if width < 60 or height < 18:
+        raise ManualCampaignError("dashboard dimensions must be at least 60x18")
+    try:
+        from ratatui_py import headless_render_frame, headless_render_frame_cells
+    except ImportError as error:
+        raise ManualCampaignError(
+            "Ratatui is unavailable; run `just dev-install`"
+        ) from error
+    commands = _ratatui_commands(state, width=width, height=height, color=color)
+    if cells:
+        return headless_render_frame_cells(width, height, commands)
+    return headless_render_frame(width, height, commands)
+
+
+def _toggle_worker_filter(state: DashboardState, attribute: str) -> None:
+    selected = state.selected_worker()
+    selected_identity = (
+        None if selected is None else (selected.cell_id, selected.peer_instance)
+    )
+    setattr(state, attribute, not bool(getattr(state, attribute)))
+    rows = state.visible_workers()
+    if not rows:
+        state.selected_index = 0
+    elif selected_identity is not None:
+        state.selected_index = next(
+            (
+                index
+                for index, worker in enumerate(rows)
+                if (worker.cell_id, worker.peer_instance) == selected_identity
+            ),
+            min(state.selected_index, len(rows) - 1),
+        )
+    else:
+        state.selected_index %= len(rows)
+    state.detail_scroll = 0
+
+
+def _handle_dashboard_key(
+    state: DashboardState,
+    event: Mapping[str, object],
+    cancellation: threading.Event,
+) -> bool:
+    """Apply one Ratatui key event; return true when rendering should stop."""
+
+    from ratatui import KeyCode, KeyMods
+
+    if event.get("kind") != "key":
+        return False
+    code = event.get("code")
+    ch = event.get("ch")
+    mods = _optional_int(event.get("mods")) or 0
+    if code == KeyCode.Char and ch in {ord("c"), ord("C")} and mods & int(KeyMods.CTRL):
+        state.interrupted = True
+        cancellation.set()
+        return True
+    if code == KeyCode.Esc and state.command_stage is not None:
+        state.command_stage = None
+        state.command_scroll = 0
+        state.command_notice = None
+        state.pending_clipboard = None
+        state.pending_print = None
+    elif code == KeyCode.Up or (code == KeyCode.Char and ch == ord("k")):
+        state.selected_index -= 1
+        state.detail_scroll = 0
+        state.command_scroll = 0
+        state.command_notice = None
+    elif code == KeyCode.Down or (code == KeyCode.Char and ch == ord("j")):
+        state.selected_index += 1
+        state.detail_scroll = 0
+        state.command_scroll = 0
+        state.command_notice = None
+    elif code == KeyCode.PageUp:
+        if state.command_stage is None:
+            state.detail_scroll = max(0, state.detail_scroll - 3)
+        else:
+            state.command_scroll = max(0, state.command_scroll - 3)
+    elif code == KeyCode.PageDown:
+        if state.command_stage is None:
+            state.detail_scroll += 3
+        else:
+            state.command_scroll += 3
+    elif code == KeyCode.Char and ch in {ord("1"), ord("2"), ord("3")}:
+        assert isinstance(ch, int)
+        state.command_stage = _REPRODUCTION_STAGES[ch - ord("1")]
+        state.command_scroll = 0
+        state.command_notice = None
+        state.show_help = False
+    elif code == KeyCode.Tab or code == KeyCode.Right:
+        _cycle_reproduction_stage(state, 1)
+        state.show_help = False
+    elif code == KeyCode.Left:
+        _cycle_reproduction_stage(state, -1)
+        state.show_help = False
+    elif code == KeyCode.Char and ch in {ord("y"), ord("Y")}:
+        command = _reproduction_command(state.selected_worker(), state.command_stage)
+        if command is None or state.command_stage is None:
+            state.command_notice = "Selected command is unavailable"
+        else:
+            state.pending_clipboard = (state.command_stage, command)
+    elif code == KeyCode.Char and ch in {ord("p"), ord("P")}:
+        command = _reproduction_command(state.selected_worker(), state.command_stage)
+        if command is None or state.command_stage is None:
+            state.command_notice = "Selected command is unavailable"
+        else:
+            state.pending_print = (state.command_stage, command)
+    elif code == KeyCode.Char and ch in {ord("d"), ord("D")}:
+        _toggle_worker_filter(state, "show_completed")
+    elif code == KeyCode.Char and ch in {ord("e"), ord("E")}:
+        _toggle_worker_filter(state, "show_errors")
+    elif code == KeyCode.Char and ch == ord("?"):
+        state.show_help = not state.show_help
+        state.command_stage = None
+        state.detail_scroll = 0
+    elif code == KeyCode.Esc:
+        state.interrupted = True
+        cancellation.set()
+        return True
+    return False
+
+
+@contextmanager
+def _ratatui_terminal_session() -> Iterator[Any]:
+    """Open Ratatui without calling the package's unsafe mode wrappers.
+
+    ``ratatui_py.terminal_session`` currently calls several native functions
+    without the terminal handle required by the bundled FFI.  The native
+    terminal constructor and destructor already own raw-mode and alternate-
+    screen setup/cleanup, selected through environment variables, so use that
+    supported lifecycle directly.
+    """
+
+    try:
+        from ratatui_py import Terminal
+    except ImportError as error:
+        raise ManualCampaignError(
+            "Ratatui is unavailable; run `just dev-install`"
+        ) from error
+
+    alt_was_set = "RATATUI_FFI_ALTSCR" in os.environ
+    previous_alt = os.environ.get("RATATUI_FFI_ALTSCR")
+    no_raw_was_set = "RATATUI_FFI_NO_RAW" in os.environ
+    previous_no_raw = os.environ.get("RATATUI_FFI_NO_RAW")
+    os.environ["RATATUI_FFI_ALTSCR"] = "1"
+    os.environ.pop("RATATUI_FFI_NO_RAW", None)
+    try:
+        terminal = Terminal()
+    finally:
+        if alt_was_set:
+            os.environ["RATATUI_FFI_ALTSCR"] = previous_alt or ""
+        else:
+            os.environ.pop("RATATUI_FFI_ALTSCR", None)
+        if no_raw_was_set:
+            os.environ["RATATUI_FFI_NO_RAW"] = previous_no_raw or ""
+        else:
+            os.environ.pop("RATATUI_FFI_NO_RAW", None)
+
+    try:
+        yield terminal
+    finally:
+        terminal.close()
+
+
+def _run_live_dashboard(
+    lease: LeaseManager,
+    state: DashboardState,
+    finished: threading.Event,
+    cancellation: threading.Event,
+    *,
+    color: bool = True,
+) -> None:
+    while not finished.is_set():
+        print_request: tuple[str, str] | None = None
+        with _ratatui_terminal_session() as terminal:
+            while not finished.is_set():
+                display_state = lease.dashboard_snapshot()
+                width, height = terminal.size()
+                terminal.draw_frame(
+                    _ratatui_commands(
+                        display_state,
+                        width=width,
+                        height=height,
+                        color=color,
+                    )
+                )
+                event = terminal.next_event(timeout_ms=150)
+                if event is None:
+                    continue
+                if _handle_dashboard_key(state, event, cancellation):
+                    return
+                if state.pending_clipboard is not None:
+                    stage, command = state.pending_clipboard
+                    state.pending_clipboard = None
+                    try:
+                        sys.stdout.write(_osc52_clipboard_sequence(command))
+                        sys.stdout.flush()
+                    except OSError:
+                        state.command_notice = (
+                            "Clipboard unavailable; press p to print the command"
+                        )
+                    else:
+                        state.command_notice = (
+                            f"Copied full {stage} command ({len(command):,} characters)"
+                        )
+                if state.pending_print is not None:
+                    print_request = state.pending_print
+                    state.pending_print = None
+                    break
+        if print_request is None:
+            continue
+        stage, command = print_request
+        print(f"\nFull {stage} command ({len(command):,} characters):\n")
+        print(command)
+        print()
+        with suppress(EOFError):
+            input("Press Enter to return to the dashboard… ")
+        state.command_notice = f"Returned from printed {stage} command"
+
+
+def _manual_baseline(
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> CellSpec | None:
+    if cell.measurement.execution_mode is ExecutionMode.AMPLICOL:
+        return None
+    dataset_id = f"reference_amplicol_{cell.measurement.accuracy.value}"
+    return next(
+        (
+            candidate
+            for candidate in catalog.measurement_cells()
+            if candidate.dataset_id == dataset_id
+            and candidate.process_key == cell.process_key
+            and candidate.n_final == cell.n_final
+            and candidate.workload is cell.workload
+        ),
+        None,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class Comparison:
+    cell: CellSpec
+    baseline: CellSpec
+    candidate: float
+    reference: float
+
+    @property
+    def multiplier(self) -> float:
+        return self.candidate / self.reference
+
+
+def _number(measurement: Mapping[str, object], field: str) -> float | None:
+    value = measurement.get(field)
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(float(value))
+        or float(value) <= 0.0
+    ):
+        return None
+    return float(value)
+
+
+def _evaluator_total_number(measurement: Mapping[str, object]) -> float | None:
+    record = evaluator_total_timing_record(measurement)
+    return None if record is None else _number(record, "raw_seconds_per_point")
+
+
+def _recurrence_core_number(measurement: Mapping[str, object]) -> float | None:
+    return recurrence_core_seconds_per_point(measurement)
+
+
+@dataclass(frozen=True, slots=True)
+class AbsoluteMetric:
+    cell: CellSpec
+    value: float
+
+
+def _absolute_metric_identity(item: AbsoluteMetric) -> dict[str, object]:
+    cell = item.cell
+    return {
+        "table": cell.dataset_id,
+        "cell_id": cell.cell_id,
+        "process_id": cell.process_key,
+        "process": cell.process,
+        "multiplicity": cell.n_final,
+        "color_approximation": cell.measurement.accuracy.value,
+        "generation_mode": cell.workload.value,
+        "generation_engine": cell.measurement.execution_mode.value,
+        "backend": cell.measurement.backend,
+        "model": (
+            None if cell.measurement.model is None else cell.measurement.model.value
+        ),
+        "variant": cell.variant,
+        "seconds_per_point": item.value,
+        "microseconds_per_point": item.value * 1.0e6,
+    }
+
+
+def _inspect_recurrence_core(
+    cells: Sequence[CellSpec],
+    currents: Mapping[str, LightweightCurrent],
+) -> tuple[dict[str, object], Counter[str]]:
+    observations: list[AbsoluteMetric] = []
+    exclusions: Counter[str] = Counter()
+    for cell in cells:
+        if cell.measurement.execution_mode is not ExecutionMode.RECURRENCE:
+            exclusions["not_recurrence"] += 1
+            continue
+        current = currents.get(cell.cell_id)
+        if current is None:
+            exclusions["candidate_missing"] += 1
+            continue
+        if not current.reusable:
+            exclusions[f"candidate_{current.reason.replace(' ', '_')}"] += 1
+            continue
+        if current.result.get("status") in {
+            ResultStatus.TIMEOUT.value,
+            ResultStatus.MEMORY_LIMIT.value,
+        }:
+            exclusions["candidate_resource_capped"] += 1
+            continue
+        value = _recurrence_core_number(current.result)
+        if value is None:
+            exclusions["value_unavailable"] += 1
+            continue
+        observations.append(AbsoluteMetric(cell=cell, value=value))
+    ordered = sorted(observations, key=lambda item: item.value)
+    values = [item.value for item in ordered]
+    payload: dict[str, object] = {
+        "count": len(ordered),
+        "fastest": (None if not ordered else _absolute_metric_identity(ordered[0])),
+        "slowest": (None if not ordered else _absolute_metric_identity(ordered[-1])),
+        "median_seconds_per_point": (None if not values else statistics.median(values)),
+        "mean_seconds_per_point": (None if not values else statistics.fmean(values)),
+    }
+    return payload, exclusions
+
+
+def comparison_statistics(comparisons: Sequence[Comparison]) -> dict[str, object]:
+    if not comparisons:
+        return {
+            "count": 0,
+            "best": None,
+            "worst": None,
+            "median": None,
+            "mean": None,
+            "weighted_mean": None,
+        }
+    ordered = sorted(comparisons, key=lambda item: item.multiplier)
+    ratios = [item.multiplier for item in ordered]
+    return {
+        "count": len(ordered),
+        "best": ordered[0],
+        "worst": ordered[-1],
+        "median": statistics.median(ratios),
+        "mean": statistics.fmean(ratios),
+        "weighted_mean": (
+            math.fsum(item.candidate for item in ordered)
+            / math.fsum(item.reference for item in ordered)
+        ),
+    }
+
+
+def _comparison_identity(item: Comparison) -> dict[str, object]:
+    cell = item.cell
+    return {
+        "table": cell.dataset_id,
+        "cell_id": cell.cell_id,
+        "process_id": cell.process_key,
+        "process": cell.process,
+        "multiplicity": cell.n_final,
+        "color_approximation": cell.measurement.accuracy.value,
+        "generation_mode": cell.workload.value,
+        "generation_engine": cell.measurement.execution_mode.value,
+        "backend": cell.measurement.backend,
+        "model": (
+            None if cell.measurement.model is None else cell.measurement.model.value
+        ),
+        "variant": cell.variant,
+        "candidate": item.candidate,
+        "amplicol": item.reference,
+        "multiplier": item.multiplier,
+        "amplicol_cell_id": item.baseline.cell_id,
+    }
+
+
+def _inspect_metric(
+    cells: Sequence[CellSpec],
+    currents: Mapping[str, LightweightCurrent],
+    *,
+    field: str | None,
+    generation: bool,
+    evaluator_total: bool = False,
+) -> tuple[dict[str, object], Counter[str]]:
+    comparisons: list[Comparison] = []
+    exclusions: Counter[str] = Counter()
+    for cell in cells:
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL:
+            exclusions["amplicol_candidate"] += 1
+            continue
+        baseline = _manual_baseline(cell)
+        if baseline is None:
+            exclusions["no_amplicol_baseline"] += 1
+            continue
+        if generation and cell.workload is Workload.ALL_FLOW:
+            exclusions["incompatible_generation_layout"] += 1
+            continue
+        candidate_current = currents.get(cell.cell_id)
+        baseline_current = currents.get(baseline.cell_id)
+        if candidate_current is None:
+            exclusions["candidate_missing"] += 1
+            continue
+        if not candidate_current.reusable:
+            exclusions[f"candidate_{candidate_current.reason.replace(' ', '_')}"] += 1
+            continue
+        if baseline_current is None:
+            exclusions["baseline_missing"] += 1
+            continue
+        if not baseline_current.reusable:
+            exclusions[f"baseline_{baseline_current.reason.replace(' ', '_')}"] += 1
+            continue
+        if candidate_current.result.get("status") in {
+            ResultStatus.TIMEOUT.value,
+            ResultStatus.MEMORY_LIMIT.value,
+        }:
+            exclusions["candidate_resource_capped"] += 1
+            continue
+        if baseline_current.result.get("status") in {
+            ResultStatus.TIMEOUT.value,
+            ResultStatus.MEMORY_LIMIT.value,
+        }:
+            exclusions["baseline_resource_capped"] += 1
+            continue
+        if evaluator_total:
+            candidate = _evaluator_total_number(candidate_current.result)
+            reference = _evaluator_total_number(baseline_current.result)
+        else:
+            assert field is not None
+            candidate = _number(candidate_current.result, field)
+            reference = _number(baseline_current.result, field)
+        if candidate is None or reference is None:
+            exclusions["value_unavailable"] += 1
+            continue
+        comparisons.append(Comparison(cell, baseline, candidate, reference))
+    raw = comparison_statistics(comparisons)
+    payload = {
+        key: (_comparison_identity(value) if isinstance(value, Comparison) else value)
+        for key, value in raw.items()
+    }
+    return payload, exclusions
+
+
+def _inspect_payload(
+    service: ReportService,
+    cells: Sequence[CellSpec],
+    *,
+    source_revision: str,
+    renderer_revision: str,
+    accept_historical_source: bool = False,
+) -> dict[str, object]:
+    required = {cell.cell_id: cell for cell in cells}
+    for cell in cells:
+        baseline = _manual_baseline(cell)
+        if baseline is not None:
+            required[baseline.cell_id] = baseline
+    currents = lightweight_currents(
+        service,
+        tuple(required.values()),
+        source_revision=source_revision,
+        accept_historical_source=accept_historical_source,
+    )
+    outcomes = lightweight_presentation_outcomes(
+        service,
+        tuple(required.values()),
+        source_revision=source_revision,
+        accept_historical_source=accept_historical_source,
+    )
+    statuses: Counter[str] = Counter()
+    unverified_diagnostics: list[dict[str, object]] = []
+    for cell in cells:
+        if _manual_static_na_reason(cell) is not None:
+            statuses["static_not_available"] += 1
+            continue
+        current = currents.get(cell.cell_id)
+        outcome = outcomes.get(cell.cell_id)
+        if current is None:
+            if outcome is None or outcome.successful:
+                statuses[ResultStatus.NOT_AVAILABLE.value] += 1
+            else:
+                statuses[outcome.status] += 1
+                if outcome.status == ResultStatus.UNVERIFIED.value:
+                    diagnostic = _presentation_measurement(
+                        service,
+                        cell,
+                        outcome,
+                    )
+                    if diagnostic.get("status") == ResultStatus.UNVERIFIED.value:
+                        provenance = diagnostic.get("provenance")
+                        evaluator = (
+                            provenance.get("evaluator_total_timing")
+                            if isinstance(provenance, Mapping)
+                            else None
+                        )
+                        unverified_diagnostics.append(
+                            {
+                                "cell_id": cell.cell_id,
+                                "attempt_id": outcome.attempt_id,
+                                "generation_seconds": diagnostic.get(
+                                    "generation_seconds"
+                                ),
+                                "wall_seconds_per_point": diagnostic.get(
+                                    "wall_seconds_per_point"
+                                ),
+                                "evaluator_total_seconds_per_point": (
+                                    evaluator.get("raw_seconds_per_point")
+                                    if isinstance(evaluator, Mapping)
+                                    else None
+                                ),
+                                "reason": (
+                                    diagnostic.get("failure", {}).get("message")
+                                    if isinstance(diagnostic.get("failure"), Mapping)
+                                    else outcome.label
+                                ),
+                            }
+                        )
+        elif not current.reusable:
+            statuses[current.reason.replace(" ", "_")] += 1
+        else:
+            statuses[str(current.result.get("status"))] += 1
+    generation, generation_exclusions = _inspect_metric(
+        cells,
+        currents,
+        field="generation_seconds",
+        generation=True,
+    )
+    runtime, runtime_exclusions = _inspect_metric(
+        cells,
+        currents,
+        field="wall_seconds_per_point",
+        generation=False,
+    )
+    evaluator_total, evaluator_total_exclusions = _inspect_metric(
+        cells,
+        currents,
+        field=None,
+        generation=False,
+        evaluator_total=True,
+    )
+    recurrence_core, recurrence_core_exclusions = _inspect_recurrence_core(
+        cells,
+        currents,
+    )
+    selected_currents = tuple(
+        currents[cell.cell_id]
+        for cell in cells
+        if cell.cell_id in currents and currents[cell.cell_id].reusable
+    )
+    clock_coverage = {
+        "outer_wall_available": sum(
+            _number(current.result, "wall_seconds_per_point") is not None
+            for current in selected_currents
+        ),
+        "evaluator_total_available": sum(
+            _evaluator_total_number(current.result) is not None
+            for current in selected_currents
+        ),
+        "recurrence_core_available": sum(
+            _recurrence_core_number(current.result) is not None
+            for current in selected_currents
+        ),
+    }
+    return {
+        "profile": _ACTIVE_PROFILE,
+        "source_revision": source_revision,
+        "renderer_source_revision": renderer_revision,
+        "source_policy": (
+            "continue_across_revisions"
+            if accept_historical_source
+            else "strict_same_source"
+        ),
+        "source_cohorts": _source_cohort_counts(currents),
+        "selection_count": len(cells),
+        "reusable_count": sum(
+            bool(current.reusable)
+            for cell_id, current in currents.items()
+            if cell_id in {cell.cell_id for cell in cells}
+        ),
+        "statuses": dict(sorted(statuses.items())),
+        "unverified_diagnostics": sorted(
+            unverified_diagnostics,
+            key=lambda item: str(item["cell_id"]),
+        ),
+        "generation_multiplier_vs_amplicol": generation,
+        "runtime_wall_multiplier_vs_amplicol": runtime,
+        "runtime_evaluator_total_multiplier_vs_amplicol": evaluator_total,
+        "recurrence_core_absolute": recurrence_core,
+        "clock_coverage": clock_coverage,
+        "exclusions": {
+            "generation": dict(sorted(generation_exclusions.items())),
+            "runtime_wall": dict(sorted(runtime_exclusions.items())),
+            "runtime_evaluator_total": dict(sorted(evaluator_total_exclusions.items())),
+            "recurrence_core": dict(sorted(recurrence_core_exclusions.items())),
+        },
+        "clock_note": (
+            "Outer wall, evaluator-total, and recurrence core are independent "
+            "raw clocks; unavailable values are never copied or derived."
+        ),
+    }
+
+
+def _format_multiplier(value: object) -> str:
+    return "—" if value is None else f"{float(value):.4g}x"
+
+
+def _paint_multiplier(palette: Palette, value: object) -> str:
+    rendered = _format_multiplier(value)
+    if value is None:
+        return palette.neutral(rendered)
+    multiplier = float(value)
+    if math.isclose(multiplier, 1.0, rel_tol=1.0e-12, abs_tol=1.0e-12):
+        return palette.neutral(rendered)
+    return palette.success(rendered) if multiplier < 1.0 else palette.failure(rendered)
+
+
+def _format_seconds_per_point(value: object) -> str:
+    return "—" if value is None else f"{float(value) * 1.0e6:.6g} μs/pt"
+
+
+def _print_inspect(payload: Mapping[str, object], palette: Palette) -> None:
+    source_revision = str(payload["source_revision"])
+    renderer_revision = str(payload["renderer_source_revision"])
+    source_cohorts = payload["source_cohorts"]
+    if not isinstance(source_cohorts, Mapping):
+        raise ManualCampaignError("inspect source cohort summary is malformed")
+    rendered_source_cohorts = _format_source_cohorts(
+        {str(revision): int(count) for revision, count in source_cohorts.items()}
+    )
+    identity_rows: list[tuple[object, object]] = [
+        (palette.key("profile"), payload["profile"]),
+        (palette.key("source policy"), payload["source_policy"]),
+        (palette.key("active measurement build"), source_revision),
+        (
+            palette.key("measurement source cohorts"),
+            rendered_source_cohorts,
+        ),
+    ]
+    if renderer_revision != source_revision:
+        identity_rows.append((palette.key("renderer checkout"), renderer_revision[:12]))
+    identity_rows.extend(
+        (
+            (palette.key("selected"), payload["selection_count"]),
+            (palette.key("reusable"), palette.success(payload["reusable_count"])),
+            (
+                palette.key("clock coverage"),
+                ", ".join(
+                    f"{key}={value}" for key, value in payload["clock_coverage"].items()
+                ),
+            ),
+            (palette.key("clock semantics"), payload["clock_note"]),
+        )
+    )
+    print(
+        _table(
+            ("key", "value"),
+            identity_rows,
+        )
+    )
+    statuses = payload["statuses"]
+    assert isinstance(statuses, Mapping)
+    print()
+    print(
+        _table(
+            ("status", "entries"),
+            (
+                (
+                    palette.key(status),
+                    (
+                        palette.success(count)
+                        if status == ResultStatus.OK.value
+                        else (
+                            palette.failure(count)
+                            if any(
+                                token in status
+                                for token in ("error", "failed", "mismatch")
+                            )
+                            else palette.warning(count)
+                        )
+                    ),
+                )
+                for status, count in statuses.items()
+            ),
+            align={"entries": "r"},
+        )
+    )
+    unverified = payload.get("unverified_diagnostics")
+    if isinstance(unverified, list) and unverified:
+        print()
+        print(
+            _table(
+                (
+                    "unverified cell",
+                    "generation",
+                    "wall",
+                    "evaluator total",
+                    "reason",
+                ),
+                (
+                    (
+                        item.get("cell_id"),
+                        (
+                            "—"
+                            if item.get("generation_seconds") is None
+                            else f"{float(item['generation_seconds']):.6g} s"
+                        ),
+                        _format_seconds_per_point(
+                            item.get("wall_seconds_per_point")
+                        ),
+                        _format_seconds_per_point(
+                            item.get("evaluator_total_seconds_per_point")
+                        ),
+                        item.get("reason"),
+                    )
+                    for item in unverified
+                    if isinstance(item, Mapping)
+                ),
+            )
+        )
+    rows: list[tuple[object, ...]] = []
+    for title, key in (
+        ("Generation", "generation_multiplier_vs_amplicol"),
+        ("Runtime wall", "runtime_wall_multiplier_vs_amplicol"),
+        (
+            "Runtime evaluator total",
+            "runtime_evaluator_total_multiplier_vs_amplicol",
+        ),
+    ):
+        summary = payload[key]
+        assert isinstance(summary, Mapping)
+        best = summary.get("best")
+        worst = summary.get("worst")
+        rows.append(
+            (
+                palette.key(title),
+                summary.get("count"),
+                _paint_multiplier(
+                    palette,
+                    (None if not isinstance(best, Mapping) else best.get("multiplier")),
+                ),
+                _paint_multiplier(palette, summary.get("median")),
+                _paint_multiplier(palette, summary.get("mean")),
+                _paint_multiplier(palette, summary.get("weighted_mean")),
+                _paint_multiplier(
+                    palette,
+                    (
+                        None
+                        if not isinstance(worst, Mapping)
+                        else worst.get("multiplier")
+                    ),
+                ),
+            )
+        )
+    print()
+    print(
+        _table(
+            (
+                "metric",
+                "pairs",
+                "best",
+                "median",
+                "average",
+                "weighted avg",
+                "worst",
+            ),
+            rows,
+            align={"pairs": "r"},
+        )
+    )
+    core_summary = payload["recurrence_core_absolute"]
+    assert isinstance(core_summary, Mapping)
+    fastest = core_summary.get("fastest")
+    slowest = core_summary.get("slowest")
+    print()
+    print(
+        _table(
+            ("metric", "samples", "fastest", "median", "average", "slowest"),
+            (
+                (
+                    palette.key("Recurrence core (absolute)"),
+                    core_summary.get("count"),
+                    _format_seconds_per_point(
+                        fastest.get("seconds_per_point")
+                        if isinstance(fastest, Mapping)
+                        else None
+                    ),
+                    _format_seconds_per_point(
+                        core_summary.get("median_seconds_per_point")
+                    ),
+                    _format_seconds_per_point(
+                        core_summary.get("mean_seconds_per_point")
+                    ),
+                    _format_seconds_per_point(
+                        slowest.get("seconds_per_point")
+                        if isinstance(slowest, Mapping)
+                        else None
+                    ),
+                ),
+            ),
+            align={"samples": "r"},
+        )
+    )
+    identities: list[tuple[object, ...]] = []
+    for title, key in (
+        ("generation best", "generation_multiplier_vs_amplicol"),
+        ("generation worst", "generation_multiplier_vs_amplicol"),
+        ("runtime best", "runtime_wall_multiplier_vs_amplicol"),
+        ("runtime worst", "runtime_wall_multiplier_vs_amplicol"),
+        (
+            "evaluator-total best",
+            "runtime_evaluator_total_multiplier_vs_amplicol",
+        ),
+        (
+            "evaluator-total worst",
+            "runtime_evaluator_total_multiplier_vs_amplicol",
+        ),
+    ):
+        summary = payload[key]
+        assert isinstance(summary, Mapping)
+        identity = summary.get("best" if title.endswith("best") else "worst")
+        if not isinstance(identity, Mapping):
+            continue
+        for label, identity_field in (
+            ("table", "table"),
+            ("cell", "cell_id"),
+            ("process ID", "process_id"),
+            ("concrete process", "process"),
+            ("multiplicity", "multiplicity"),
+            ("colour", "color_approximation"),
+            ("layout/workload", "generation_mode"),
+            ("engine", "generation_engine"),
+            ("backend", "backend"),
+            ("model", "model"),
+            ("variant", "variant"),
+            ("candidate value", "candidate"),
+            ("AmpliCol baseline", "amplicol"),
+            ("multiplier", "multiplier"),
+        ):
+            value = identity.get(identity_field)
+            if identity_field == "multiplier":
+                value = _paint_multiplier(palette, value)
+            identities.append((palette.key(title), palette.key(label), value))
+    for title, identity in (
+        ("recurrence-core fastest", fastest),
+        ("recurrence-core slowest", slowest),
+    ):
+        if not isinstance(identity, Mapping):
+            continue
+        for label, identity_field in (
+            ("table", "table"),
+            ("cell", "cell_id"),
+            ("process ID", "process_id"),
+            ("concrete process", "process"),
+            ("multiplicity", "multiplicity"),
+            ("colour", "color_approximation"),
+            ("layout/workload", "generation_mode"),
+            ("engine", "generation_engine"),
+            ("backend", "backend"),
+            ("model", "model"),
+            ("variant", "variant"),
+            ("absolute value", "seconds_per_point"),
+        ):
+            value = identity.get(identity_field)
+            if identity_field == "seconds_per_point":
+                value = _format_seconds_per_point(value)
+            identities.append((palette.key(title), palette.key(label), value))
+    if identities:
+        print()
+        print(
+            _table(
+                ("extreme", "key", "value"),
+                identities,
+            )
+        )
+    exclusions = payload["exclusions"]
+    assert isinstance(exclusions, Mapping)
+    print()
+    print(
+        _table(
+            ("metric", "excluded reason", "count"),
+            (
+                (palette.key(metric), reason, count)
+                for metric, raw in exclusions.items()
+                if isinstance(raw, Mapping)
+                for reason, count in raw.items()
+            ),
+            align={"count": "r"},
+        )
+    )
+
+
+def _campaign_settings(
+    arguments: argparse.Namespace,
+    source: ReportSourceIdentity,
+    *,
+    original_amplicol_available: bool = False,
+    observer: Any = None,
+    cancelled: Any = None,
+    campaign_invocation_id: str | None = None,
+) -> CampaignSettings:
+    workers = int(arguments.workers)
+    cores = int(arguments.cores_per_worker)
+    amplicol_build_jobs = int(getattr(arguments, "amplicol_build_jobs", 1))
+    available = os.cpu_count() or 1
+    effective_worker_cores = max(cores, amplicol_build_jobs)
+    if workers * effective_worker_cores > available and not bool(
+        arguments.allow_oversubscription
+    ):
+        raise ManualCampaignError(
+            f"{workers} workers x {effective_worker_cores} maximum per-worker "
+            f"cores exceeds {available} logical CPUs; lower --workers, "
+            "--cores-per-worker, or --amplicol-build-jobs, or pass "
+            "--allow-oversubscription"
+        )
+    fresh_attempt = _fresh_attempt_requested(arguments)
+    original_amplicol_revision = getattr(
+        arguments,
+        "original_amplicol_revision",
+        None,
+    )
+    return CampaignSettings(
+        workers=workers,
+        cell_cores=cores,
+        amplicol_build_jobs=amplicol_build_jobs,
+        target_runtime_seconds=float(arguments.target_measurement_duration),
+        batch_size=int(arguments.batch_size),
+        warmup_runs=int(arguments.warmups),
+        minimum_samples=int(arguments.minimum_samples),
+        timeout_seconds=arguments.worker_wall_limit,
+        generation_time_limit_seconds=float(arguments.generation_time_limit),
+        profiling_time_limit_seconds=(
+            None
+            if arguments.worker_wall_limit is None
+            else float(arguments.worker_wall_limit)
+        ),
+        validation_time_limit_seconds=(
+            None
+            if arguments.worker_wall_limit is None
+            else float(arguments.worker_wall_limit)
+        ),
+        max_rss_bytes=int(arguments.ram_limit),
+        campaign_max_rss_bytes=(
+            None
+            if getattr(arguments, "campaign_ram_limit", None) is None
+            else int(arguments.campaign_ram_limit)
+        ),
+        attempt_output_limit_bytes=int(
+            getattr(
+                arguments,
+                "attempt_output_limit",
+                DEFAULT_ATTEMPT_OUTPUT_LIMIT_BYTES,
+            )
+        ),
+        minimum_free_disk_bytes=int(
+            getattr(
+                arguments,
+                "minimum_free_disk",
+                DEFAULT_MINIMUM_FREE_DISK_BYTES,
+            )
+        ),
+        artifact_policy=(
+            ArtifactPolicy.REGENERATE
+            if fresh_attempt
+            else ArtifactPolicy.REUSE
+        ),
+        missing_only=not fresh_attempt,
+        rerun=fresh_attempt,
+        add_optional_dependencies=not bool(
+            getattr(arguments, "no_dependencies_added", False)
+        ),
+        original_amplicol_available=original_amplicol_available,
+        allow_symbolica_parallel=bool(arguments.allow_engine_parallelism),
+        resource_sample_interval_seconds=float(arguments.resource_sample_interval),
+        termination_grace_seconds=float(arguments.termination_grace),
+        source_identity_override=source,
+        campaign_invocation_id=campaign_invocation_id,
+        progress_observer=observer,
+        cancellation_requested=cancelled,
+        manual_terminal_censors=True,
+        discard_cancelled_attempts=False,
+        remove_heavy_attempt_artifacts=_artifact_cleanup_enabled(arguments),
+        retain_workspaces=bool(getattr(arguments, "retain_workspaces", False)),
+        report_profile=None,
+        original_amplicol_repository=(
+            arguments.original_amplicol
+            if original_amplicol_revision is not None
+            else None
+        ),
+        original_amplicol_revision=original_amplicol_revision,
+        madgraph_installation=getattr(arguments, "madgraph", None),
+        multiplicity_wave_barrier=bool(getattr(arguments, "fail_fast", False)),
+    )
+
+
+def _validated_original_amplicol_checkout(path: Path) -> tuple[Path, str]:
+    """Return one clean checkout exposing the maintained profiling interface."""
+
+    repository = path.expanduser().resolve(strict=True)
+    missing = tuple(
+        name
+        for name in _ORIGINAL_AMPLICOL_REQUIRED_FILES
+        if not (repository / name).is_file() or (repository / name).is_symlink()
+    )
+    if missing:
+        raise ManualCampaignError(
+            "--original-amplicol is not a complete patched checkout; missing "
+            + ", ".join(missing)
+        )
+    makefile = (repository / "makefile").read_text(
+        encoding="utf-8",
+        errors="replace",
+    )
+    missing_targets = tuple(
+        target
+        for target in _ORIGINAL_AMPLICOL_REQUIRED_MAKE_TARGETS
+        if re.search(rf"(?m)^{re.escape(target)}\s*:", makefile) is None
+    )
+    if missing_targets:
+        raise ManualCampaignError(
+            "--original-amplicol lacks required Make targets: "
+            + ", ".join(missing_targets)
+        )
+    head = subprocess.run(
+        ("git", "rev-parse", "HEAD"),
+        cwd=repository,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    revision = head.stdout.strip()
+    if head.returncode != 0 or re.fullmatch(r"[0-9a-f]{40}", revision) is None:
+        raise ManualCampaignError(
+            "--original-amplicol must be a Git checkout with a concrete HEAD"
+        )
+    status = subprocess.run(
+        ("git", "status", "--porcelain=v1", "--untracked-files=all"),
+        cwd=repository,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if status.returncode != 0 or status.stdout:
+        raise ManualCampaignError(
+            "--original-amplicol must be a clean checkout; commit, remove, "
+            "or relocate local changes and build products first"
+        )
+    return repository, revision
+
+
+def _configured_original_amplicol(docs_dir: Path) -> Path | None:
+    config = docs_dir / _LOCAL_AMPLICOL_CONFIG
+    if not config.exists():
+        return None
+    if config.is_symlink() or not config.is_file():
+        raise ManualCampaignError(
+            f"campaign local-AmpliCol configuration is not a regular file: {config}"
+        )
+    try:
+        lines = config.read_text(encoding="utf-8").splitlines()
+    except OSError as error:
+        raise ManualCampaignError(
+            f"cannot read campaign local-AmpliCol configuration: {config}"
+        ) from error
+    if len(lines) != 1 or not lines[0] or not Path(lines[0]).is_absolute():
+        raise ManualCampaignError(
+            f"campaign local-AmpliCol configuration is invalid: {config}"
+        )
+    return Path(lines[0])
+
+
+def _configured_madgraph(docs_dir: Path) -> Path | None:
+    config = docs_dir / _LOCAL_MADGRAPH_CONFIG
+    if not config.exists():
+        return None
+    if config.is_symlink() or not config.is_file():
+        raise ManualCampaignError(
+            f"campaign MadGraph configuration is not a regular file: {config}"
+        )
+    try:
+        lines = config.read_text(encoding="utf-8").splitlines()
+    except OSError as error:
+        raise ManualCampaignError(
+            f"cannot read campaign MadGraph configuration: {config}"
+        ) from error
+    if len(lines) != 1 or not lines[0] or not Path(lines[0]).is_absolute():
+        raise ManualCampaignError(
+            f"campaign MadGraph configuration is invalid: {config}"
+        )
+    return Path(lines[0])
+
+
+def _validated_madgraph_installation(path: Path) -> Path:
+    try:
+        installation = path.expanduser().resolve(strict=True)
+    except (OSError, RuntimeError) as error:
+        raise ManualCampaignError(
+            f"--madgraph installation does not exist: {path}"
+        ) from error
+    if not installation.is_dir():
+        raise ManualCampaignError(
+            f"--madgraph must name an installation directory: {installation}"
+        )
+    executable = installation / "bin/mg5_aMC"
+    try:
+        executable_mode = executable.stat(follow_symlinks=False).st_mode
+    except OSError as error:
+        raise ManualCampaignError(
+            "--madgraph must contain a regular executable bin/mg5_aMC"
+        ) from error
+    if not stat.S_ISREG(executable_mode) or not os.access(executable, os.X_OK):
+        raise ManualCampaignError(
+            "--madgraph must contain a regular executable bin/mg5_aMC"
+        )
+    return installation
+
+
+def _resolve_madgraph(
+    arguments: argparse.Namespace,
+    *,
+    installed: bool,
+    docs_dir: Path,
+) -> Path | None:
+    installation = arguments.madgraph
+    if installation is None and installed:
+        installation = _configured_madgraph(docs_dir)
+    if installation is None:
+        return None
+    return _validated_madgraph_installation(installation)
+
+
+def _original_amplicol_available_for_planning(
+    arguments: argparse.Namespace,
+    *,
+    installed: bool,
+    root: Path,
+    docs_dir: Path,
+) -> bool:
+    """Whether optional validation dependencies may include original AmpliCol."""
+
+    if bool(getattr(arguments, "no_dependencies_added", False)):
+        return False
+    if arguments.original_amplicol is not None:
+        return True
+    if not installed:
+        return (root / "dependencies/checkouts/legacy-amplicol").is_dir()
+    try:
+        configured = _configured_original_amplicol(docs_dir)
+    except ManualCampaignError:
+        return False
+    return configured is not None and configured.is_dir()
+
+
+def _resolve_original_amplicol(
+    arguments: argparse.Namespace,
+    *,
+    installed: bool,
+    root: Path,
+    docs_dir: Path,
+) -> tuple[Path | None, str | None]:
+    original = arguments.original_amplicol
+    if original is None:
+        if installed:
+            original = _configured_original_amplicol(docs_dir)
+        else:
+            default_original = root / "dependencies/checkouts/legacy-amplicol"
+            if default_original.is_dir():
+                original = default_original
+    if original is None:
+        return None, None
+    return _validated_original_amplicol_checkout(original)
+
+
+def _bind_original_amplicol_if_required(
+    arguments: argparse.Namespace,
+    planned: Sequence[PlannedCell],
+    *,
+    installed: bool,
+    root: Path,
+    docs_dir: Path,
+) -> None:
+    """Validate the optional legacy checkout only for work that will use it."""
+
+    if not any(
+        item.cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+        for item in planned
+    ):
+        arguments.original_amplicol = None
+        arguments.original_amplicol_revision = None
+        return
+    repository, revision = _resolve_original_amplicol(
+        arguments,
+        installed=installed,
+        root=root,
+        docs_dir=docs_dir,
+    )
+    if repository is None:
+        raise ManualCampaignError(
+            "this campaign selection requires original AmpliCol; pass "
+            "--original-amplicol PATH_TO_COMPLETE_CHECKOUT containing the "
+            "profiling interface from AmpliCol PR #12"
+        )
+    arguments.original_amplicol = repository
+    arguments.original_amplicol_revision = revision
+
+
+def _dry_run_rows(
+    direct: Sequence[CellSpec],
+    planned: Sequence[PlannedCell],
+    *,
+    repo_root: Path,
+    artifact_root: Path,
+    arguments: argparse.Namespace,
+) -> Iterable[tuple[object, ...]]:
+    direct_ids = {cell.cell_id for cell in direct}
+    for item in planned:
+        recipe = reproduction_recipe(
+            item.cell,
+            repo_root=repo_root,
+            artifact_root=artifact_root,
+            cores=arguments.cores_per_worker,
+            target_runtime=arguments.target_measurement_duration,
+            batch_size=arguments.batch_size,
+            warmups=arguments.warmups,
+            minimum_samples=arguments.minimum_samples,
+        )
+        role = "direct" if item.cell.cell_id in direct_ids else "dependency"
+        yield (
+            f"{role} · rank {item.rank}",
+            "\n".join(
+                (
+                    item.cell.cell_id,
+                    f"engine: {item.cell.measurement.execution_mode.value}",
+                    f"kind: {recipe.kind}",
+                    f"exact: {'yes' if recipe.exact else 'no'}",
+                    f"note: {recipe.note}",
+                )
+            ),
+        )
+
+
+def _wrapped_shell(
+    arguments: Sequence[str],
+    *,
+    width: int,
+    indent: str = "  ",
+) -> str:
+    """Wrap shell words without splitting quoted arguments."""
+
+    words = [shlex.quote(str(argument)) for argument in arguments]
+    lines: list[str] = []
+    current = indent
+    for word in words:
+        separator = "" if current == indent else " "
+        if current != indent and len(current) + len(separator) + len(word) > width:
+            lines.append(current)
+            current = indent + word
+        else:
+            current += separator + word
+    if current != indent:
+        lines.append(current)
+    return " \\\n".join(lines)
+
+
+def _dry_run_recipe_blocks(
+    direct: Sequence[CellSpec],
+    *,
+    repo_root: Path,
+    artifact_root: Path,
+    arguments: argparse.Namespace,
+    width: int,
+) -> Iterable[str]:
+    for index, cell in enumerate(direct, start=1):
+        if _manual_static_na_reason(cell) is not None:
+            continue
+        recipe = reproduction_recipe(
+            cell,
+            repo_root=repo_root,
+            artifact_root=artifact_root,
+            cores=arguments.cores_per_worker,
+            target_runtime=arguments.target_measurement_duration,
+            batch_size=arguments.batch_size,
+            warmups=arguments.warmups,
+            minimum_samples=arguments.minimum_samples,
+        )
+        metadata = _table(
+            ("key", "value"),
+            (
+                ("recipe", index),
+                ("cell", cell.cell_id),
+                ("kind", recipe.kind),
+                ("exact", "yes" if recipe.exact else "no"),
+                ("note", recipe.note),
+            ),
+            max_width={"value": max(36, width - 16)},
+        )
+        commands: list[str] = [metadata]
+        for label, command in (
+            ("Prepare prerequisite", recipe.prepare),
+            ("Generate", recipe.generate),
+            (
+                "Profile" if recipe.exact else "Profile template/diagnostic",
+                recipe.profile,
+            ),
+        ):
+            if command is None:
+                continue
+            commands.extend((f"{label}:", _wrapped_shell(command, width=width)))
+        yield "\n".join(commands)
+
+
+def _cancel_and_join_campaign_worker(
+    worker: threading.Thread,
+    cancellation: threading.Event,
+    *,
+    timeout_seconds: float,
+) -> tuple[bool, bool]:
+    """Poll cancellation until the non-daemon controller has fully exited."""
+
+    cancellation.set()
+    interrupted = False
+    poll_seconds = min(max(timeout_seconds, 0.05), 0.25)
+    notice_polls = max(1, math.ceil(max(timeout_seconds, 1.0) / poll_seconds))
+    polls = 0
+    while worker.is_alive():
+        try:
+            worker.join(timeout=poll_seconds)
+        except KeyboardInterrupt:
+            interrupted = True
+            cancellation.set()
+            print(
+                "Interrupt repeated; still waiting for supervised worker-tree "
+                "cleanup...",
+                file=sys.stderr,
+                flush=True,
+            )
+        polls += 1
+        if worker.is_alive() and polls % notice_polls == 0:
+            cancellation.set()
+            print(
+                "Waiting for campaign cancellation cleanup; no leases or claims "
+                "will be released early...",
+                file=sys.stderr,
+                flush=True,
+            )
+    return interrupted, False
+
+
+def _recycled_attention_workers(
+    cells: Sequence[CellSpec],
+    currents: Mapping[str, LightweightCurrent],
+    recycled_ids: set[str],
+    *,
+    repo_root: Path,
+    artifact_root: Path,
+    settings: ReproductionSettings,
+) -> dict[str, WorkerView]:
+    """Expose same-source recycled currents without scanning attempt history."""
+
+    workers: dict[str, WorkerView] = {}
+    for cell in cells:
+        if cell.cell_id not in recycled_ids:
+            continue
+        current = currents.get(cell.cell_id)
+        if current is None:
+            continue
+        result_status = str(current.result.get("status") or "")
+        state = policy_measurement_state_hint(current.result)
+        status = (
+            "recycled"
+            if result_status in {ResultStatus.OK.value, "reused", "skipped-current"}
+            else (None if state is None else state.value)
+        )
+        if status is None:
+            continue
+        resources = current.result.get("resources")
+        resource_values = resources if isinstance(resources, Mapping) else {}
+        provenance = current.result.get("provenance")
+        manual = (
+            provenance.get("manual_campaign")
+            if isinstance(provenance, Mapping)
+            else None
+        )
+        stored_recipe = (
+            manual.get("public_cli_reproduction")
+            if isinstance(manual, Mapping)
+            else None
+        )
+        recipe = None
+        if not isinstance(stored_recipe, Mapping):
+            recipe = reproduction_recipe(
+                cell,
+                repo_root=repo_root,
+                artifact_root=artifact_root,
+                cores=settings.cores,
+                target_runtime=settings.target_runtime,
+                batch_size=settings.batch_size,
+                warmups=settings.warmups,
+                minimum_samples=settings.minimum_samples,
+                measurement=current.result,
+            )
+
+        worker = WorkerView(
+            cell.cell_id,
+            generation_engine=cell.measurement.execution_mode.value,
+            status=status,
+            step=(
+                "recycled generation-time cap"
+                if status == "generation_limit"
+                else (
+                    "recycled process-tree RAM cap"
+                    if status == "memory_limit"
+                    else (
+                        f"recycled {status.replace('_', ' ')}"
+                        if status in _TERMINAL_CAP_STATUSES
+                        else "reused existing current"
+                    )
+                )
+            ),
+            phase="recycled current",
+            attempt_id=current.attempt_id,
+            wall_seconds=_finite_float(resource_values.get("wall_seconds")),
+            cpu_seconds=_optional_finite_float(resource_values.get("cpu_seconds")),
+            current_rss_bytes=_optional_int(resource_values.get("current_rss_bytes"))
+            or 0,
+            peak_rss_bytes=_optional_int(resource_values.get("peak_rss_bytes")) or 0,
+            current_physical_footprint_bytes=_optional_int(
+                resource_values.get("current_physical_footprint_bytes")
+            ),
+            peak_physical_footprint_bytes=_optional_int(
+                resource_values.get("peak_physical_footprint_bytes")
+            ),
+            current_guard_bytes=_optional_int(
+                resource_values.get("current_guard_bytes")
+            )
+            or 0,
+            peak_guard_bytes=_optional_int(resource_values.get("peak_guard_bytes"))
+            or 0,
+            progress_completed=1,
+            progress_total=1,
+            progress_message=(
+                "recycled capped result"
+                if status in _TERMINAL_CAP_STATUSES
+                else "recycled current"
+            ),
+            reproduce_prepare=(
+                _stored_reproduction_command(stored_recipe, "prepare")
+                if recipe is None
+                else (None if recipe.prepare is None else _shell_join(recipe.prepare))
+            ),
+            reproduce_generate=(
+                _stored_reproduction_command(stored_recipe, "generate")
+                if recipe is None
+                else (None if recipe.generate is None else _shell_join(recipe.generate))
+            ),
+            reproduce_profile=(
+                _stored_reproduction_command(stored_recipe, "profile")
+                if recipe is None
+                else (None if recipe.profile is None else _shell_join(recipe.profile))
+            ),
+            published_wall_seconds_per_point=_number(
+                current.result,
+                "wall_seconds_per_point",
+            ),
+            published_evaluator_total_seconds_per_point=(
+                _evaluator_total_number(current.result)
+            ),
+            published_recurrence_core_seconds_per_point=(
+                _recurrence_core_number(current.result)
+            ),
+            recycled=True,
+            reuse_explanation=current.reason,
+            events=[f"recycled: {current.reason}"],
+        )
+        _apply_persisted_worker_result(
+            worker,
+            current.result,
+            recycled=True,
+            reuse_explanation=current.reason,
+        )
+        workers[cell.cell_id] = worker
+    return workers
+
+
+def _run_campaign(
+    arguments: argparse.Namespace,
+    *,
+    repo_root: Path,
+    service: ReportService,
+    source: ReportSourceIdentity,
+    cells: Sequence[CellSpec],
+    palette: Palette,
+    installed: bool = False,
+) -> int:
+    invocation_command = getattr(arguments, "_campaign_invocation_command", None)
+    if not isinstance(invocation_command, str) or not invocation_command:
+        invocation_command = (
+            "steer_performance_campaign.py run "
+            "<invocation arguments unavailable to Python API>"
+        )
+    selective_retry = _selective_retry_requested(arguments)
+    if bool(getattr(arguments, "force_refresh", False)) and selective_retry:
+        raise ManualCampaignError(
+            "--force-refresh cannot be combined with --rerun-failed or "
+            "--rerun-capped; use force refresh for every selected cell or the "
+            "selective retry flags"
+        )
+    fresh_attempt = _fresh_attempt_requested(arguments)
+    measurable = tuple(cell for cell in cells if _manual_static_na_reason(cell) is None)
+    static_na = {
+        cell.cell_id for cell in cells if _manual_static_na_reason(cell) is not None
+    }
+    if not measurable and selective_retry:
+        print(
+            palette.success(
+                "No measurable selected entries match the requested selective "
+                "retry; no workers or attempts were created."
+            )
+        )
+        return 0
+    if not measurable:
+        print(
+            palette.warning(
+                f"All {len(cells)} selected entries are policy/static unavailable; "
+                "no attempts were created."
+            )
+        )
+        print(
+            _table(
+                ("cell", "reason"),
+                ((cell.cell_id, _manual_static_na_reason(cell)) for cell in cells),
+            )
+        )
+        if not arguments.dry_run:
+            summary_path, summary_counts = _publish_campaign_summary_ids(
+                service,
+                {"static_na": static_na},
+            )
+            _print_campaign_summary_ids(summary_path, summary_counts, palette)
+        return 0
+    active_lightweight = lightweight_currents(
+        service,
+        measurable,
+        source_revision=source.revision,
+    )
+    continue_across_revisions = bool(
+        getattr(arguments, "continue_across_revisions", False)
+    )
+    lightweight = (
+        lightweight_currents(
+            service,
+            measurable,
+            source_revision=source.revision,
+            accept_historical_source=True,
+        )
+        if continue_across_revisions
+        else active_lightweight
+    )
+    if selective_retry:
+        outcomes = lightweight_presentation_outcomes(
+            service,
+            measurable,
+            source_revision=source.revision,
+            accept_historical_source=continue_across_revisions,
+        )
+        base_measurable_count = len(measurable)
+        measurable = _selective_retry_cells(
+            measurable,
+            lightweight,
+            outcomes,
+            rerun_failed=bool(getattr(arguments, "rerun_failed", False)),
+            rerun_capped=bool(getattr(arguments, "rerun_capped", False)),
+        )
+        if not measurable:
+            requested = " and ".join(
+                option
+                for option, enabled in (
+                    ("--rerun-failed", getattr(arguments, "rerun_failed", False)),
+                    ("--rerun-capped", getattr(arguments, "rerun_capped", False)),
+                )
+                if enabled
+            )
+            print(
+                palette.success(
+                    f"No entries among {base_measurable_count} measurable "
+                    f"selected cells match {requested}; no workers or attempts "
+                    "were created."
+                )
+            )
+            return 0
+        matched_ids = {cell.cell_id for cell in measurable}
+        cells = measurable
+        static_na = set()
+        active_lightweight = {
+            cell_id: current
+            for cell_id, current in active_lightweight.items()
+            if cell_id in matched_ids
+        }
+        lightweight = {
+            cell_id: current
+            for cell_id, current in lightweight.items()
+            if cell_id in matched_ids
+        }
+        print(
+            palette.warning(
+                f"Selective retry matched {len(measurable)} of "
+                f"{base_measurable_count} measurable selected entries."
+            )
+        )
+    recycled = {
+        cell_id
+        for cell_id, current in lightweight.items()
+        if current.reusable and not fresh_attempt
+    }
+    historical_recycled = {
+        cell_id
+        for cell_id in recycled
+        if _measurement_source_revision(lightweight[cell_id].result) != source.revision
+    }
+    requested_for_plan = tuple(
+        cell
+        for cell in measurable
+        if fresh_attempt or cell.cell_id not in historical_recycled
+    )
+    original_amplicol_available = _original_amplicol_available_for_planning(
+        arguments,
+        installed=installed,
+        root=repo_root,
+        docs_dir=service.paths.docs_dir,
+    )
+    arguments.madgraph = _resolve_madgraph(
+        arguments,
+        installed=installed,
+        docs_dir=service.paths.docs_dir,
+    )
+    preliminary_settings = _campaign_settings(
+        arguments,
+        source,
+        original_amplicol_available=original_amplicol_available,
+    )
+    planned = plan_campaign(
+        requested_for_plan,
+        store=service.store,
+        settings=preliminary_settings,
+        expected_revision=source.revision,
+        expected_tree=None,
+        current_resolver=_lightweight_current_resolver(
+            service,
+            source_revision=source.revision,
+            initial=active_lightweight,
+        ),
+    )
+    # A historical cell can still be required as an active-source dependency
+    # of a newly measured cell.  In that case it is work, not recycled work.
+    recycled.difference_update(item.cell.cell_id for item in planned)
+    selected_cohorts = _source_cohort_counts(
+        lightweight,
+        cell_ids=recycled,
+    )
+    if continue_across_revisions:
+        print(
+            palette.warning(
+                "Cross-revision continuation is enabled: completed selected "
+                "currents are kept per cell; dependencies needed by new work "
+                "still require the active source revision. Recycled cohorts: "
+                f"{_format_source_cohorts(selected_cohorts)}"
+            )
+        )
+    if arguments.dry_run:
+        terminal_width = max(
+            80,
+            min(160, shutil.get_terminal_size(fallback=(120, 24)).columns),
+        )
+        print(
+            _table(
+                ("key", "value"),
+                (
+                    (palette.key("direct entries"), len(cells)),
+                    (palette.key("static N/A"), len(static_na)),
+                    (palette.key("recycled"), len(recycled)),
+                    (
+                        palette.key("historical recycled"),
+                        len(recycled & historical_recycled),
+                    ),
+                    (palette.key("planned with dependencies"), len(planned)),
+                    (palette.key("source"), source.revision),
+                    (
+                        palette.key("source policy"),
+                        (
+                            "continue across revisions"
+                            if continue_across_revisions
+                            else "strict same-source"
+                        ),
+                    ),
+                    (
+                        palette.key("artifact cleanup"),
+                        (
+                            "compact retention (default)"
+                            if _artifact_cleanup_enabled(arguments)
+                            else "full debug workspaces (--retain-workspaces)"
+                        ),
+                    ),
+                ),
+            )
+        )
+        print()
+        if static_na:
+            print(
+                _table(
+                    ("static/policy unavailable cell", "reason"),
+                    (
+                        (cell.cell_id, _manual_static_na_reason(cell))
+                        for cell in cells
+                        if cell.cell_id in static_na
+                    ),
+                )
+            )
+            print()
+        print(
+            _table(
+                ("entry", "details"),
+                _dry_run_rows(
+                    cells,
+                    planned,
+                    repo_root=repo_root,
+                    artifact_root=service.paths.artifact_root,
+                    arguments=arguments,
+                ),
+                max_width={"entry": 18, "details": max(48, terminal_width - 27)},
+            )
+        )
+        direct_recipes = tuple(
+            cell for cell in cells if _manual_static_na_reason(cell) is None
+        )
+        for block in _dry_run_recipe_blocks(
+            direct_recipes,
+            repo_root=repo_root,
+            artifact_root=service.paths.artifact_root,
+            arguments=arguments,
+            width=terminal_width,
+        ):
+            print()
+            print(block)
+        return 0
+
+    _bind_original_amplicol_if_required(
+        arguments,
+        planned,
+        installed=installed,
+        root=repo_root,
+        docs_dir=service.paths.docs_dir,
+    )
+
+    require_measurement_ready(source)
+    if continue_across_revisions:
+        update_source_marker(
+            service,
+            source,
+            continue_across_revisions=True,
+        )
+    else:
+        update_source_marker(service, source)
+    campaign_invocation_id = uuid.uuid4().hex
+    for warning in _publish_recycled_presentation_outcomes(
+        service,
+        lightweight,
+        recycled,
+        source_revision=source.revision,
+        campaign_invocation_id=campaign_invocation_id,
+        accept_historical_source=continue_across_revisions,
+    ):
+        print(
+            palette.warning(f"presentation outcome warning: {warning}"),
+            file=sys.stderr,
+        )
+    if _artifact_cleanup_enabled(arguments):
+        cleanup_cells = tuple(
+            {
+                cell.cell_id: cell
+                for cell in (
+                    *measurable,
+                    *(item.cell for item in planned),
+                )
+            }.values()
+        )
+        cleanup_warnings = reconcile_attempt_history(service, cleanup_cells)
+        for cell_id, detail in cleanup_warnings:
+            print(
+                palette.warning(
+                    f"artifact cleanup skipped for {cell_id}: {detail}"
+                ),
+                file=sys.stderr,
+            )
+    measurable_ids = {cell.cell_id for cell in measurable}
+    if not planned and measurable_ids <= recycled:
+        print(
+            _table(
+                ("key", "value"),
+                (
+                    (palette.key("selected entries"), len(cells)),
+                    (palette.key("measurable entries"), len(measurable)),
+                    (
+                        palette.key("recycled measurable entries"),
+                        palette.success(len(recycled)),
+                    ),
+                    (
+                        palette.key("static N/A entries"),
+                        (
+                            palette.warning(len(static_na))
+                            if static_na
+                            else palette.neutral(0)
+                        ),
+                    ),
+                    (palette.key("workers created"), palette.success(0)),
+                    (palette.key("attempts created"), palette.success(0)),
+                ),
+                align={"value": "r"},
+            )
+        )
+        print()
+        print(
+            palette.success(
+                "All selected measurable entries were recycled "
+                f"({len(recycled)} of {len(measurable)}); no workers or "
+                "attempts were created."
+            )
+        )
+        if static_na:
+            print(
+                palette.warning(
+                    f"{len(static_na)} selected static N/A "
+                    f"{'entry remains' if len(static_na) == 1 else 'entries remain'} "
+                    "policy unavailable and accounted for separately."
+                )
+            )
+        summary_path, summary_counts = _publish_campaign_summary_ids(
+            service,
+            _campaign_summary_categories(
+                static_na_ids=static_na,
+            ),
+        )
+        _print_campaign_summary_ids(summary_path, summary_counts, palette)
+        return 0
+    cancellation = threading.Event()
+    finished = threading.Event()
+    state = DashboardState(
+        instance_id=campaign_invocation_id,
+        selected_ids=tuple(cell.cell_id for cell in cells),
+        recycled_ids=recycled,
+        static_na_ids=static_na,
+        source_revision=source.revision,
+        generation_time_limit_seconds=float(arguments.generation_time_limit),
+        memory_limit_bytes=(
+            preliminary_settings.effective_cell_rss_limit()
+            or int(arguments.ram_limit)
+        ),
+        worker_wall_limit_seconds=arguments.worker_wall_limit,
+        reproduction_settings=ReproductionSettings(
+            cores=int(arguments.cores_per_worker),
+            target_runtime=float(arguments.target_measurement_duration),
+            batch_size=int(arguments.batch_size),
+            warmups=int(arguments.warmups),
+            minimum_samples=int(arguments.minimum_samples),
+        ),
+        dependency_ids={item.cell.cell_id for item in planned if item.dependency},
+    )
+    state.workers.update(
+        _recycled_attention_workers(
+            measurable,
+            lightweight,
+            recycled,
+            repo_root=repo_root,
+            artifact_root=service.paths.artifact_root,
+            settings=state.reproduction_settings,
+        )
+    )
+    for cell_id, worker in state.workers.items():
+        state._reduce_finished(
+            cell_id,
+            worker.status,
+            recycled=worker.recycled,
+        )
+    lease = LeaseManager(service, state)
+    lease.publish()
+    fail_fast_observer = (
+        _FailFastObserver(lease.observe, cancellation)
+        if bool(getattr(arguments, "fail_fast", False))
+        else None
+    )
+    settings = _campaign_settings(
+        arguments,
+        source,
+        original_amplicol_available=original_amplicol_available,
+        observer=(
+            lease.observe
+            if fail_fast_observer is None
+            else fail_fast_observer.observe
+        ),
+        cancelled=cancellation.is_set,
+        campaign_invocation_id=state.instance_id,
+    )
+    scheduler = CampaignScheduler(service, settings=settings)
+    result_holder: list[CampaignResult] = []
+    error_holder: list[BaseException] = []
+
+    def execute() -> None:
+        try:
+            result_holder.append(scheduler.run(planned))
+        except BaseException as error:
+            error_holder.append(error)
+        finally:
+            finished.set()
+
+    worker = threading.Thread(
+        target=execute,
+        name="manual-performance-campaign",
+        daemon=False,
+    )
+    worker.start()
+    interrupted = False
+    join_interrupted = False
+    worker_alive = False
+    try:
+        interactive = (
+            not arguments.no_dashboard
+            and bool(getattr(sys.stdin, "isatty", lambda: False)())
+            and bool(getattr(sys.stdout, "isatty", lambda: False)())
+        )
+        if interactive:
+            _run_live_dashboard(
+                lease,
+                state,
+                finished,
+                cancellation,
+                color=palette.enabled,
+            )
+        else:
+            while not finished.wait(timeout=0.25):
+                pass
+    except KeyboardInterrupt:
+        interrupted = True
+        state.interrupted = True
+        cancellation.set()
+    finally:
+        if state.interrupted:
+            interrupted = True
+        try:
+            join_interrupted, worker_alive = _cancel_and_join_campaign_worker(
+                worker,
+                cancellation,
+                timeout_seconds=max(5.0, arguments.termination_grace + 2.0),
+            )
+        finally:
+            lease.close()
+    if join_interrupted or worker_alive:
+        interrupted = True
+        state.interrupted = True
+    fail_fast_failure = (
+        None if fail_fast_observer is None else fail_fast_observer.failure
+    )
+    _print_cleanup_warnings(state, palette)
+    if interrupted:
+        result = result_holder[0] if result_holder else None
+        _publish_completion_summary(
+            service,
+            _campaign_summary_categories(
+                static_na_ids=static_na,
+                result=result,
+                state=state,
+                interrupted=True,
+            ),
+            state=state,
+            fail_fast_failure=fail_fast_failure,
+            invocation_command=invocation_command,
+            palette=palette,
+        )
+        artifact_outcome = (
+            "disposable workspaces were compacted (default)"
+            if _artifact_cleanup_enabled(arguments)
+            else "full debug workspaces were retained (--retain-workspaces)"
+        )
+        print(
+            palette.warning(
+                "Interrupted: dispatch stopped, process trees received cancellation, "
+                "compact interrupted-attempt diagnostics and completed currents "
+                f"were preserved, {artifact_outcome}, and leases were removed."
+            ),
+            file=sys.stderr,
+        )
+        return 130
+    if error_holder:
+        partial_result = result_holder[0] if result_holder else None
+        if fail_fast_failure is not None or _has_invocation_summary_evidence(
+            partial_result, state
+        ):
+            _publish_completion_summary(
+                service,
+                _campaign_summary_categories(
+                    static_na_ids=static_na,
+                    result=partial_result,
+                    state=state,
+                ),
+                state=state,
+                fail_fast_failure=fail_fast_failure,
+                invocation_command=invocation_command,
+                palette=palette,
+            )
+        raise error_holder[0]
+    result = result_holder[0]
+    statuses = Counter(outcome.status for outcome in result.outcomes)
+    print(
+        _table(
+            ("status", "entries"),
+            (
+                (
+                    palette.key(status),
+                    (
+                        palette.success(count)
+                        if status in _FAIL_FAST_SUCCESS_STATUSES
+                        else palette.warning(count)
+                    ),
+                )
+                for status, count in sorted(statuses.items())
+            ),
+            align={"entries": "r"},
+        )
+    )
+    _publish_completion_summary(
+        service,
+        _campaign_summary_categories(
+            static_na_ids=static_na,
+            result=result,
+            state=state,
+        ),
+        state=state,
+        fail_fast_failure=fail_fast_failure,
+        invocation_command=invocation_command,
+        palette=palette,
+    )
+    if bool(getattr(arguments, "fail_fast", False)):
+        has_terminal_failure = any(
+            outcome.status not in _FAIL_FAST_SUCCESS_STATUSES
+            and outcome.status != "cancelled"
+            for outcome in result.outcomes
+        )
+        return 1 if fail_fast_failure is not None or has_terminal_failure else 0
+    return 1 if result.failed else 0
+
+
+def _capture_lightweight_snapshot(
+    service: ReportService,
+    *,
+    source_revision: str,
+    accept_historical_source: bool = False,
+    progress: _SnapshotProgress | None = None,
+) -> tuple[
+    dict[str, LightweightCurrent],
+    dict[str, LightweightPresentationOutcome],
+    tuple[tuple[str, str], ...],
+]:
+    cells = tuple(service.catalog.measurement_cells())
+    total = 4 * len(cells)
+    for attempt in range(3):
+        started_at = time.monotonic()
+        completed_offset = 0
+        last_update = 0.0
+
+        if progress is not None:
+            progress.begin(
+                total=total,
+                attempt=attempt + 1,
+                maximum_attempts=3,
+            )
+
+        def callback(
+            stage: str,
+            stage_offset: int,
+        ) -> Callable[[int, int], None] | None:
+            nonlocal last_update
+            if progress is None:
+                return None
+            progress.update(stage_offset, total, stage)
+
+            def update(completed: int, _stage_total: int) -> None:
+                nonlocal last_update
+                now = time.monotonic()
+                overall = stage_offset + completed
+                if completed == 1 or overall == total or now - last_update >= 0.08:
+                    progress.update(overall, total, stage)
+                    last_update = now
+
+            return update
+
+        try:
+            currents = lightweight_currents(
+                service,
+                cells,
+                source_revision=source_revision,
+                accept_historical_source=accept_historical_source,
+                progress=callback(
+                    "Reading current records",
+                    completed_offset,
+                ),
+            )
+            completed_offset += len(cells)
+            outcomes = lightweight_presentation_outcomes(
+                service,
+                cells,
+                source_revision=source_revision,
+                accept_historical_source=accept_historical_source,
+                progress=callback(
+                    "Reading terminal outcomes",
+                    completed_offset,
+                ),
+            )
+            completed_offset += len(cells)
+            identity = tuple(
+                sorted(
+                    (cell_id, current.attempt_id)
+                    for cell_id, current in currents.items()
+                    if current.reusable
+                )
+            )
+            outcome_identity = tuple(
+                sorted(
+                    (cell_id, outcome.ordering_key)
+                    for cell_id, outcome in outcomes.items()
+                )
+            )
+            confirmed = lightweight_currents(
+                service,
+                cells,
+                source_revision=source_revision,
+                accept_historical_source=accept_historical_source,
+                progress=callback(
+                    "Confirming current records",
+                    completed_offset,
+                ),
+            )
+            completed_offset += len(cells)
+            confirmed_outcomes = lightweight_presentation_outcomes(
+                service,
+                cells,
+                source_revision=source_revision,
+                accept_historical_source=accept_historical_source,
+                progress=callback(
+                    "Confirming terminal outcomes",
+                    completed_offset,
+                ),
+            )
+            confirmed_identity = tuple(
+                sorted(
+                    (cell_id, current.attempt_id)
+                    for cell_id, current in confirmed.items()
+                    if current.reusable
+                )
+            )
+            confirmed_outcome_identity = tuple(
+                sorted(
+                    (cell_id, outcome.ordering_key)
+                    for cell_id, outcome in confirmed_outcomes.items()
+                )
+            )
+            stable = (
+                identity == confirmed_identity
+                and outcome_identity == confirmed_outcome_identity
+            )
+        except BaseException:
+            if progress is not None:
+                progress.end(
+                    success=False,
+                    message="artifact scan failed",
+                    elapsed_seconds=time.monotonic() - started_at,
+                )
+            raise
+        final_attempt = attempt + 1 == 3
+        if progress is not None:
+            progress.end(
+                success=stable or not final_attempt,
+                message=(
+                    "stable snapshot captured"
+                    if stable
+                    else (
+                        "campaign state remained unstable after three scans"
+                        if final_attempt
+                        else "campaign state changed; rescanning"
+                    )
+                ),
+                elapsed_seconds=time.monotonic() - started_at,
+            )
+        if stable:
+            return currents, outcomes, identity
+    raise ManualCampaignError(
+        "current pointers or presentation outcomes changed during three "
+        "snapshot reads; retry refresh-pdf"
+    )
+
+
+def _merge_lightweight_snapshot(
+    service: ReportService,
+    currents: Mapping[str, LightweightCurrent],
+    outcomes: Mapping[str, LightweightPresentationOutcome] | None = None,
+) -> tuple[dict[str, dict[str, object]], int]:
+    caches = service.reset_payloads()
+    visible_outcomes = {} if outcomes is None else outcomes
+    by_cell = {cell.cell_id: cell for cell in service.catalog.measurement_cells()}
+    merged = 0
+    for payload in caches.values():
+        entries = payload["entries"]
+        assert isinstance(entries, list)
+        for entry in entries:
+            assert isinstance(entry, dict)
+            cell_id = str(entry["cell_id"])
+            cell = by_cell[cell_id]
+            if service.catalog.static_na_reason(cell) is not None:
+                entry["measurement"] = reset_entry(cell)["measurement"]
+                continue
+            current = currents.get(cell_id)
+            outcome = visible_outcomes.get(cell_id)
+            if (
+                current is not None
+                and current.reusable
+                and current.result.get("status") == ResultStatus.OK.value
+            ):
+                measurement = dict(current.result)
+            elif outcome is not None and not outcome.successful:
+                if (
+                    current is not None
+                    and current.reusable
+                    and outcome.attempt_id is not None
+                    and outcome.attempt_id == current.attempt_id
+                ):
+                    measurement = dict(current.result)
+                else:
+                    measurement = _presentation_measurement(service, cell, outcome)
+            elif outcome is not None and outcome.successful:
+                if current is None or not current.reusable:
+                    continue
+                measurement = dict(current.result)
+            elif current is not None and current.reusable:
+                measurement = dict(current.result)
+            else:
+                continue
+            validate_measurement(measurement, expected_cell=cell)
+            entry["measurement"] = measurement
+            merged += 1
+    service.validate_payloads(caches)
+    return caches, merged
+
+
+def _copy_report_sources(source: Path, destination: Path) -> None:
+    shutil.copytree(
+        source,
+        destination,
+        ignore=_report_source_copy_ignore(
+            source,
+            "pyAmpliCol.pdf",
+            "*.aux",
+            "*.bbl",
+            "*.bcf",
+            "*.blg",
+            "*.fdb_latexmk",
+            "*.fls",
+            "*.log",
+            "*.out",
+            "*.run.xml",
+            "*.synctex.gz",
+            "*.toc",
+        ),
+    )
+
+
+def _selected_report_sections(raw: Sequence[str] | None) -> tuple[ReportSection, ...]:
+    requested = set(raw or ())
+    known = {section.identifier for section in REPORT_SECTIONS}
+    unknown = tuple(sorted(requested - known))
+    if unknown:
+        raise ManualCampaignError(
+            "unknown report section ID(s): "
+            + ", ".join(unknown)
+            + "; run `refresh-pdf --list-sections` to list valid IDs"
+        )
+    return tuple(
+        section for section in REPORT_SECTIONS if section.identifier in requested
+    )
+
+
+def _filter_report_sections(
+    master: Path,
+    removed: Sequence[ReportSection],
+) -> None:
+    """Remove selected marked sections from one private staged TeX source."""
+
+    removed_ids = {section.identifier for section in removed}
+    if not removed_ids:
+        return
+    try:
+        lines = master.read_text(encoding="utf-8").splitlines(keepends=True)
+    except OSError as error:
+        raise ManualCampaignError(
+            f"cannot read staged report source {master}"
+        ) from error
+    events = tuple(
+        (match.group(1), match.group(2))
+        for line in lines
+        if (match := _REPORT_SECTION_MARKER.fullmatch(line.rstrip("\r\n")))
+        is not None
+    )
+    expected = tuple(
+        event
+        for section in REPORT_SECTIONS
+        for event in (("begin", section.identifier), ("end", section.identifier))
+    )
+    if events != expected:
+        raise ManualCampaignError(
+            "report section markers differ from the installed section registry; "
+            "refresh the copied campaign template before using --remove-sections"
+        )
+    output: list[str] = []
+    active: str | None = None
+    for line in lines:
+        match = _REPORT_SECTION_MARKER.fullmatch(line.rstrip("\r\n"))
+        if match is not None:
+            event, identifier = match.groups()
+            if event == "begin":
+                active = identifier
+                if identifier not in removed_ids:
+                    output.append(line)
+            else:
+                if identifier not in removed_ids:
+                    output.append(line)
+                active = None
+            continue
+        if active not in removed_ids:
+            output.append(line)
+    master.write_text("".join(output), encoding="utf-8")
+
+
+def _print_report_sections(palette: Palette) -> None:
+    print(
+        _table(
+            ("section ID", "PDF section"),
+            (
+                (palette.key(section.identifier), section.title)
+                for section in REPORT_SECTIONS
+            ),
+        )
+    )
+
+
+def _stage_copied_profile_identity(staging_docs: Path, profile: str) -> None:
+    """Rebind copied workspace labels inside the private PDF build only."""
+
+    environment_path = staging_docs / "report_environment.json"
+    environment = _read_object(environment_path)
+    if environment is not None:
+        environment["profile"] = profile
+        _atomic_json(environment_path, environment)
+
+    workspace_path = staging_docs / "report-workspace.json"
+    workspace = _read_object(workspace_path)
+    if workspace is not None:
+        workspace["profile"] = profile
+        workspace["artifact_root"] = "campaign_artifacts"
+        workspace["coordination_root"] = "campaign_artifacts/coordination"
+        initialized = workspace.get("initialized_environment")
+        if isinstance(initialized, Mapping):
+            workspace["initialized_environment"] = {
+                **initialized,
+                "profile": profile,
+            }
+        _atomic_json(workspace_path, workspace)
+
+    tex_path = staging_docs / "report_environment.tex"
+    try:
+        tex = tex_path.read_text(encoding="utf-8")
+    except OSError:
+        return
+    escaped_profile = profile.replace("_", r"\_")
+    updated, replacements = re.subn(
+        r"(\\renewcommand\{\\ReportProfileName\}\{)[^}\r\n]*(\})",
+        lambda match: f"{match.group(1)}{escaped_profile}{match.group(2)}",
+        tex,
+        count=1,
+    )
+    if replacements != 1:
+        raise ManualCampaignError(
+            "staged report environment does not define ReportProfileName"
+        )
+    tex_path.write_text(updated, encoding="utf-8")
+
+
+def _require_reusable_staged_environment(
+    staging_docs: Path,
+    profile: str,
+    *,
+    expected_source_revision: str,
+) -> None:
+    """Reject authenticated metadata from an older measurement-source epoch."""
+
+    environment_path = staging_docs / ENVIRONMENT_JSON
+    if not environment_path.exists():
+        # The atomic installer reports a missing report member below.  This
+        # helper is concerned only with preventing stale authentication reuse.
+        return
+    environment = _read_object(environment_path)
+    if environment is None:
+        raise ManualCampaignError(
+            "staged report environment metadata is malformed"
+        )
+    if environment.get("profile") != profile:
+        raise ManualCampaignError(
+            "staged report environment profile was not rebound"
+        )
+    status = environment.get("status")
+    source_revision = environment.get("source_revision")
+    if status == "pending_exact_runtime" and source_revision == "pending":
+        return
+    if status == "authenticated" and source_revision == expected_source_revision:
+        return
+    raise ManualCampaignError(
+        "no active-source runtime witness is available, and the staged report "
+        "environment is not authenticated for the active measurement source"
+    )
+
+
+def _install_report_snapshot(
+    service: ReportService,
+    staging_docs: Path,
+    table_names: Sequence[str],
+) -> None:
+    sources: list[tuple[Path, Path]] = [
+        *(
+            (
+                path,
+                service.paths.results_dir / path.name,
+            )
+            for path in sorted((staging_docs / "results").glob("*.json"))
+        ),
+        *(
+            (
+                staging_docs / name,
+                service.paths.docs_dir / name,
+            )
+            for name in sorted(table_names)
+        ),
+        *(
+            (
+                staging_docs / name,
+                service.paths.docs_dir / name,
+            )
+            for name in (ENVIRONMENT_JSON, ENVIRONMENT_TEX)
+        ),
+        (
+            staging_docs / "pyAmpliCol.pdf",
+            service.paths.docs_dir / "pyAmpliCol.pdf",
+        ),
+    ]
+    for source_path, _destination in sources:
+        if not source_path.is_file():
+            raise ManualCampaignError(f"staged report member is missing: {source_path}")
+    backup_root = staging_docs.parent / "previous"
+    backup_root.mkdir()
+    replaced: list[tuple[Path, Path | None]] = []
+    with service.store.named_lock("report-writer"):
+        try:
+            for source_path, destination in sources:
+                destination.parent.mkdir(parents=True, exist_ok=True)
+                backup = None
+                if destination.exists():
+                    backup = backup_root / destination.relative_to(
+                        service.paths.docs_dir
+                    )
+                    backup.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(destination, backup)
+                temporary = destination.with_name(
+                    f".{destination.name}.manual-{uuid.uuid4().hex}"
+                )
+                try:
+                    shutil.copy2(source_path, temporary)
+                    os.replace(temporary, destination)
+                finally:
+                    temporary.unlink(missing_ok=True)
+                replaced.append((destination, backup))
+        except BaseException:
+            for destination, backup in reversed(replaced):
+                if backup is None:
+                    destination.unlink(missing_ok=True)
+                else:
+                    os.replace(backup, destination)
+            raise
+
+
+def _active_environment_runtime_witness(
+    currents: Mapping[str, LightweightCurrent],
+    *,
+    source_revision: str,
+) -> _ProfileEnvironmentWitness | None:
+    """Select one consistent runtime witness from validated active currents."""
+
+    selected: _ProfileEnvironmentWitness | None = None
+    selected_identity: str | None = None
+    for cell_id in sorted(currents):
+        current = currents[cell_id]
+        if (
+            not current.reusable
+            or current.result.get("status") != ResultStatus.OK.value
+            or _measurement_source_revision(current.result) != source_revision
+        ):
+            continue
+        provenance = current.result.get("provenance")
+        runtime = (
+            provenance.get("runtime_identity")
+            if isinstance(provenance, Mapping)
+            else None
+        )
+        if runtime is None:
+            # Original AmpliCol results carry no pyAmpliCol runtime witness.
+            continue
+        if (
+            not isinstance(runtime, Mapping)
+            or runtime.get("source_revision") != source_revision
+        ):
+            raise ManualCampaignError(
+                f"{cell_id}: active-source runtime witness is malformed"
+            )
+        candidate = runtime.get("candidate_build_identity")
+        package_tree = runtime.get("python_package_tree")
+        native_extension = runtime.get("native_extension")
+        native_target = runtime.get("native_target")
+        if not all(
+            isinstance(value, Mapping)
+            for value in (candidate, package_tree, native_extension, native_target)
+        ):
+            raise ManualCampaignError(
+                f"{cell_id}: active-source runtime witness is incomplete"
+            )
+        assert isinstance(candidate, Mapping)
+        if candidate.get("source_revision") != source_revision:
+            raise ManualCampaignError(
+                f"{cell_id}: active-source runtime build identity is malformed"
+            )
+        numpy_version = provenance.get("numpy")
+        if numpy_version is None:
+            numpy_version = _UNRECORDED_MEASUREMENT_NUMPY
+        host_environment = {
+            "platform": provenance.get("platform"),
+            "machine": provenance.get("machine"),
+            "processor": provenance.get("processor"),
+            "python": provenance.get("python"),
+            "python_implementation": provenance.get(
+                "python_implementation",
+                "CPython",
+            ),
+            "numpy": numpy_version,
+        }
+        if not all(
+            isinstance(host_environment[field], str) and bool(host_environment[field])
+            for field in (
+                "platform",
+                "machine",
+                "python",
+                "python_implementation",
+                "numpy",
+            )
+        ) or not isinstance(host_environment["processor"], str):
+            raise ManualCampaignError(
+                f"{cell_id}: active-source measurement-host witness is incomplete"
+            )
+        assert isinstance(package_tree, Mapping)
+        assert isinstance(native_extension, Mapping)
+        assert isinstance(native_target, Mapping)
+        fingerprint = candidate.get("candidate_fingerprint")
+        if fingerprint is None and candidate.get("publishable") is True:
+            fingerprint = runtime.get("candidate_build_identity_sha256")
+        projection = {
+            "source_revision": runtime.get("source_revision"),
+            "package_version": runtime.get("package_version"),
+            "python_package_tree_sha256": package_tree.get("sha256"),
+            "build_fingerprint": fingerprint,
+            "native_build_inputs_sha256": runtime.get("native_build_inputs_sha256"),
+            "native_extension_sha256": native_extension.get("sha256"),
+            "native_target": native_target.get("triple"),
+            "native_cpu_features": native_target.get("cpu_features"),
+            "measurement_host": host_environment,
+        }
+        identity = json.dumps(
+            projection,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        if selected_identity is not None and identity != selected_identity:
+            raise ManualCampaignError(
+                "active measurement-source currents disagree on their "
+                "authenticated runtime environment"
+            )
+        selected = _ProfileEnvironmentWitness(runtime, host_environment)
+        selected_identity = identity
+    return selected
+
+
+def _refresh_pdf(
+    arguments: argparse.Namespace,
+    *,
+    service: ReportService,
+    source: ReportSourceIdentity,
+    palette: Palette,
+) -> int:
+    removed_sections = _selected_report_sections(arguments.remove_sections)
+    source_policy = recorded_measurement_source_policy(
+        service,
+        checkout_revision=source.revision,
+    )
+    scan_progress: _SnapshotProgress | None = None
+    if not bool(arguments.quiet) and bool(
+        getattr(sys.stderr, "isatty", lambda: False)()
+    ):
+        scan_progress = _RefreshScanProgress(sys.stderr, palette)
+    try:
+        snapshot_arguments = {
+            "source_revision": source_policy.source_revision,
+            "accept_historical_source": (
+                source_policy.continue_across_revisions
+            ),
+        }
+        if scan_progress is None:
+            currents, outcomes, snapshot = _capture_lightweight_snapshot(
+                service,
+                **snapshot_arguments,
+            )
+        else:
+            currents, outcomes, snapshot = _capture_lightweight_snapshot(
+                service,
+                progress=scan_progress,
+                **snapshot_arguments,
+            )
+    finally:
+        if scan_progress is not None:
+            scan_progress.close()
+    source_cohorts = _source_cohort_counts(currents)
+    environment_runtime = _active_environment_runtime_witness(
+        currents,
+        source_revision=source_policy.source_revision,
+    )
+    publication_caches, merged = _merge_lightweight_snapshot(
+        service,
+        currents,
+    )
+    render_caches, _presentation_merged = _merge_lightweight_snapshot(
+        service,
+        currents,
+        outcomes,
+    )
+    build_root = service.paths.artifact_root / "manual-publication-builds"
+    build_root.mkdir(parents=True, exist_ok=True)
+    staging = Path(tempfile.mkdtemp(prefix="refresh-", dir=build_root))
+    try:
+        staging_docs = staging / "docs"
+        _copy_report_sources(service.paths.docs_dir, staging_docs)
+        _stage_copied_profile_identity(
+            staging_docs,
+            service.paths.docs_dir.name,
+        )
+        if environment_runtime is not None:
+            record_authenticated_profile_environment(
+                staging_docs,
+                service.paths.docs_dir.name,
+                expected_source_revision=source_policy.source_revision,
+                active_runtime=environment_runtime.active_runtime,
+                host_environment=environment_runtime.host_environment,
+            )
+        else:
+            _require_reusable_staged_environment(
+                staging_docs,
+                service.paths.docs_dir.name,
+                expected_source_revision=source_policy.source_revision,
+            )
+        _filter_report_sections(
+            staging_docs / "pyAmpliCol.tex",
+            removed_sections,
+        )
+        staging_service = ReportService(
+            ReportPaths.from_repo(
+                service.paths.repo_root,
+                docs_dir=staging_docs,
+                artifact_root=service.paths.artifact_root,
+                coordination_root=service.paths.coordination_root,
+            ),
+            catalog=service.catalog,
+        )
+        staging_service.bind_measurement_lineage(None)
+        staging_service.bind_original_amplicol_seed(None)
+        tables = staging_service._render_tables(render_caches)
+        staging_service._snapshot_files(publication_caches, tables)
+        page_count = _compile_pdf(
+            staging_docs,
+            expected_page_count=(
+                None
+                if arguments.expected_page_count is None
+                else int(arguments.expected_page_count)
+            ),
+            timeout_seconds=float(arguments.pdf_timeout),
+            allow_overfull_boxes=True,
+            stream_output=not bool(arguments.quiet),
+        )
+        _install_report_snapshot(service, staging_docs, tuple(tables))
+    finally:
+        shutil.rmtree(staging, ignore_errors=True)
+    print(
+        _table(
+            ("key", "value"),
+            (
+                (
+                    palette.key("source policy"),
+                    (
+                        "continue across revisions"
+                        if source_policy.continue_across_revisions
+                        else "strict same-source"
+                    ),
+                ),
+                (
+                    palette.key("measurement source cohorts"),
+                    _format_source_cohorts(source_cohorts),
+                ),
+                (palette.key("renderer checkout"), source.revision),
+                (palette.key("current snapshot"), len(snapshot)),
+                (palette.key("measurements merged"), merged),
+                (palette.key("tables rebuilt"), len(tables)),
+                (
+                    palette.key("sections omitted"),
+                    (
+                        ", ".join(
+                            section.identifier for section in removed_sections
+                        )
+                        or "none"
+                    ),
+                ),
+                (palette.key("PDF pages"), page_count),
+                (
+                    palette.key("installed"),
+                    palette.success(service.paths.docs_dir / "pyAmpliCol.pdf"),
+                ),
+            ),
+        )
+    )
+    print(f"PDF: {(service.paths.docs_dir / 'pyAmpliCol.pdf').resolve(strict=False)}")
+    return 0
+
+
+_PROCESS_SELECTOR_GUIDE = "\n".join(
+    f"  {family.identifier:>2}: {family.key}" for family in PROCESS_FAMILIES
+)
+_DATASET_SELECTOR_GUIDE = textwrap.fill(
+    ", ".join(sorted({cell.dataset_id for cell in REPORT_CATALOG.measurement_cells()})),
+    width=78,
+    initial_indent="  ",
+    subsequent_indent="  ",
+)
+_ALIAS_SELECTOR_GUIDE = """
+  table groups: z/z_table; matrix/matrix_table; matrix_best; reference; scalar
+  colour: lc/leading_color/leading_colour;
+          nlc/next_to_leading_color/next_to_leading_colour;
+          full/full_color/full_colour
+  layouts: non_union_flow/selected_flow/single_flow/single_flow_hel_sum/
+           topology_replay; union_flow/all_flow/all_flows/
+           all_flows_single_hel/all_flow_union; contracted
+  engines: amplicol/legacy; recurrence/ampli_col; compiled; eager;
+           on-the-fly/otf
+  models: builtin/built_in/built_in_sm/builtin_sm/sm;
+          ufo/sm_ufo/ufo_sm/external_sm; scalar_contact; scalar_gravity
+""".strip("\n")
+
+
+STEERING_GUIDE = f"""
+Steering model
+--------------
+Selectors are repeatable and accept several values after one option. Values
+within one dimension are ORed; dimensions are ANDed. Omitted dimensions and a
+quoted '*' (or 'all') mean all values. Hyphens, underscores, and case are
+normalized. `non-union-flow` means one selected colour flow with the helicity
+sum; `union-flow` means all colour flows at one helicity; NLC/full rows use the
+contracted workload.
+
+`--cell-id-file` reads exact IDs, one per UTF-8 line, ignoring blank lines and
+full-line `#` comments. IDs from files and `--cell-id` are ORed before the
+remaining selectors are applied. Each completed run atomically refreshes
+`campaign_summary_ids/`; use one or more of its status files to target a retry.
+`unverified.txt` needs no `--force-refresh`: those retained diagnostics are not
+successful currents, and a later recurrence authority or AmpliCol diagnostic
+dependency causes the selected cells to run and validate again automatically.
+By default the controller retains results, provenance, commands, progress, and
+bounded log tails while removing disposable legacy/MadGraph/build workspaces
+and obsolete heavy payloads. Use `--retain-workspaces` only when a debugging
+session needs the full workspaces; output and free-disk safety limits still
+apply. `--cleanup-artifacts` remains an accepted compatibility spelling for
+the default. `--attempt-output-limit` defaults to 64 MiB per watched file and
+`--minimum-free-disk` reserves 5 GiB on the campaign artifact volume. Keyboard
+interruption and fail-fast leave attempts sealed with compact diagnostics
+rather than leaving unbounded partial workspaces behind.
+
+Where the report protocol permits, the controller parses, resolves, and
+dispatches the real public `pyamplicol generate` and `pyamplicol profile`
+subcommands in-process. Dry runs print directly runnable generation commands
+and clearly labelled pre-generation profile templates; completed recurrence
+provenance replaces templates with stable selectors and a materialized exact
+momenta input. Compiled generation's precompiled-model injection and
+compiled/eager paired Arena publication remain explicit report-protocol
+exceptions. Original AmpliCol uses its maintained legacy adapter because no
+public pyamplicol subcommand exists.
+
+Campaign copies
+---------------
+Create a complete reset campaign with
+`pyamplicol profiling-campaign copy DESTINATION`. The destination directory
+name is the profile identity, so separate copies receive distinct artifact,
+coordination, source-marker, result, and PDF paths.
+
+Resource and availability policy
+--------------------------------
+Multiplicity-eight all-flow recurrence is runnable. Current releases use
+bounded numerical-current evidence; a shape that cannot fit the 1-GiB envelope
+visibly falls back to reuse-off while ordinary generation continues under the
+generation-time and 30-GB process-tree caps. Z-table C++/ASM variants above
+multiplicity six remain catalog-defined static N/A and create no attempts.
+
+By default the planner adds each selected cell's available validation
+dependencies at the active source revision. The exact per-process order is the
+original-AmpliCol diagnostic, recurrence authority, then compiled/eager
+candidate; added cells are shown as dependency-only work. Independent processes
+remain parallel. A missing or terminal authority releases its candidate to run
+unverified rather than creating a blocked dependency. Use
+`--no-dependencies-added` for an explicitly baseline-free selection; hard
+construction and selector/provider dependencies are always retained. Selecting
+`amplicol` explicitly still requires a clean complete checkout. An omitted
+engine selector and quoted `*` both mean every engine.
+
+Canonical selector values and aliases
+-------------------------------------
+  tables: z_table (z), matrix, matrix_best, reference, scalar, or exact dataset
+  colour: lc, nlc, full
+  layouts: non-union-flow (selected-flow/topology-replay),
+           union-flow (all-flow), contracted
+  engines: amplicol, recurrence, compiled, eager, on-the-fly (otf)
+  models: built_in (builtin_sm), sm_ufo (ufo_sm), scalar_contact, scalar_gravity
+  variants: recurrence_jit_o2, jit_o1, jit_o3, eager_jit_o2, cpp_o3, asm_o3
+            (filters named Z implementations only; unvaried rows remain)
+  wildcard: quoted '*' or all; omitted selectors also mean all
+
+Accepted aliases
+----------------
+{_ALIAS_SELECTOR_GUIDE}
+
+Exact dataset IDs
+-----------------
+{_DATASET_SELECTOR_GUIDE}
+
+Process IDs
+-----------
+{_PROCESS_SELECTOR_GUIDE}
+
+Common recipes
+--------------
+  One exact cell:
+    steer_performance_campaign.py run --cell-id CELL_ID
+
+  Multiplicities 3 and 4 for both SM models:
+    steer_performance_campaign.py run --multiplicity 3 4 --model built_in sm_ufo
+
+  Complete Z table:
+    steer_performance_campaign.py run --table z_table
+
+  Every catalog entry, planned only:
+    steer_performance_campaign.py run --dry-run
+
+  Four workers, two cores each:
+    steer_performance_campaign.py run --workers 4 --cores-per-worker 2
+
+  Stop dispatch on the first terminal failure and retain its full evidence:
+    steer_performance_campaign.py run --fail-fast --workers 4 --table matrix
+
+  All pyAmpliCol engines without adding optional validation dependencies:
+    steer_performance_campaign.py run \\
+      --generation-engine recurrence compiled eager on-the-fly \\
+      --no-dependencies-added
+
+  Recompute instead of reusing same-source currents:
+    steer_performance_campaign.py run --force-refresh --table z_table
+
+  Retry only failed or policy-capped cells inside the ordinary selection:
+    steer_performance_campaign.py run --rerun-failed --rerun-capped \
+      --continue-across-revisions --table matrix
+
+  Retry exact error and validation-failure IDs:
+    steer_performance_campaign.py run \
+      --cell-id-file campaign_summary_ids/error.txt \
+                     campaign_summary_ids/validation_failed.txt \
+      --force-refresh
+
+  Keep completed cells while complementing them with a new clean build:
+    steer_performance_campaign.py run --continue-across-revisions \\
+      --table z_table
+
+  Inspect recurrence and compiled LC rows:
+    steer_performance_campaign.py inspect --color-approximation lc \\
+      --generation-engine recurrence compiled
+
+  Rebuild every JSON/TeX table and the PDF:
+    steer_performance_campaign.py refresh-pdf
+
+  List stable PDF section IDs or omit selected sections from one build:
+    steer_performance_campaign.py refresh-pdf --list-sections
+    steer_performance_campaign.py refresh-pdf \\
+      --remove-sections worked-zgg shared-current-dag
+
+  Deterministic dashboard fixture for layout review:
+    steer_performance_campaign.py dashboard-snapshot --width 120 --height 36
+
+  Read-only snapshot of the newest active campaign lease:
+    steer_performance_campaign.py dashboard-snapshot --live
+
+  Snapshot one concurrent invocation by exact ID or unique prefix:
+    steer_performance_campaign.py dashboard-snapshot --live --instance ID_PREFIX
+
+Keyboard controls
+-----------------
+  ↑/↓ or j/k  select a worker     PgUp/PgDn  scroll worker details
+  d           show/hide completed successful workers (hidden by default)
+  e           show/hide errors, caps, and recycled non-success rows
+  1/2/3       open the complete prepare/generate/profile command drawer
+  Tab or ←/→  cycle available commands       y  copy the exact command
+  p           print the exact command outside the dashboard for selection
+  Esc         close the command drawer        ?  show dashboard help
+  Ctrl-C      stop safely, preserve compact diagnostics, and summarize IDs
+
+The selected-worker panel preserves typed engine details when available,
+including recurrence stages, current/contribution counts, relation counts,
+and evidence sizes. RAM is the sampled process-tree current/peak usage.
+"""
+
+
+def _selector_parent() -> argparse.ArgumentParser:
+    parent = argparse.ArgumentParser(add_help=False)
+    parent.add_argument(
+        "--table",
+        nargs="+",
+        action="append",
+        metavar="TABLE",
+        help=(
+            "Rendered table/dataset selector. Canonical groups: z_table, "
+            "matrix, matrix_best, reference, scalar; exact dataset IDs are "
+            "also accepted. Repeat or supply multiple values."
+        ),
+    )
+    parent.add_argument(
+        "--process-id",
+        nargs="+",
+        action="append",
+        metavar="ID",
+        help=(
+            "Process family number 1..15, process key, or quoted concrete "
+            "process. Numeric IDs follow the report's canonical process list."
+        ),
+    )
+    parent.add_argument(
+        "--multiplicity",
+        "--multiplcity",
+        nargs="+",
+        action="append",
+        metavar="N",
+        help="Final-state multiplicity; positive integers such as 3 4.",
+    )
+    parent.add_argument(
+        "--color-approximation",
+        "--color_approximation",
+        "--colour-approximation",
+        "--colour_approximation",
+        nargs="+",
+        action="append",
+        metavar="LEVEL",
+        help="Colour accuracy: lc, nlc, or full (friendly long aliases accepted).",
+    )
+    parent.add_argument(
+        "--generation-mode",
+        nargs="+",
+        action="append",
+        metavar="LAYOUT",
+        help=(
+            "Workload/layout: union-flow, non-union-flow, or contracted. "
+            "Aliases all-flow, selected-flow, and topology-replay are accepted."
+        ),
+    )
+    parent.add_argument(
+        "--generation-engine",
+        nargs="+",
+        action="append",
+        metavar="ENGINE",
+        help=(
+            "Engine: amplicol, recurrence, compiled, eager, or on-the-fly (alias otf)."
+        ),
+    )
+    parent.add_argument(
+        "--model",
+        nargs="+",
+        action="append",
+        metavar="MODEL",
+        help=(
+            "Model: built_in/builtin_sm, sm_ufo/ufo_sm, scalar_contact, or "
+            "scalar_gravity."
+        ),
+    )
+    parent.add_argument(
+        "--variant",
+        nargs="+",
+        action="append",
+        metavar="VARIANT",
+        help=(
+            "Z-table implementation variant; repeat or supply multiple values. "
+            "This narrows only variant-bearing rows; ordinary matrix/reference "
+            "rows have no variant dimension and remain eligible."
+        ),
+    )
+    parent.add_argument(
+        "--cell-id",
+        nargs="+",
+        action="append",
+        metavar="CELL",
+        help="Exact canonical cell identity; repeat or supply multiple values.",
+    )
+    parent.add_argument(
+        "--cell-id-file",
+        nargs="+",
+        action="append",
+        type=Path,
+        metavar="PATH",
+        help=(
+            "UTF-8 file containing one exact canonical cell ID per line; blank "
+            "lines and full-line # comments are ignored. Repeat or supply "
+            "multiple paths. IDs are unioned with --cell-id and intersected "
+            "with every other selector. Wildcards are not accepted in files. "
+            "Running blocked_dependency.txt plans its prerequisite closure; "
+            "unverified.txt retries without --force-refresh when independent "
+            "authority becomes available; "
+            "use --force-refresh when a selected ID already has a reusable "
+            "terminal current."
+        ),
+    )
+    return parent
+
+
+def _output_parent() -> argparse.ArgumentParser:
+    parent = argparse.ArgumentParser(add_help=False)
+    parent.add_argument(
+        "--no-color",
+        action="store_true",
+        help=(
+            "Disable ANSI colours and Ratatui styles. Output is coloured by "
+            "default; NO_COLOR also disables colour. Inspect JSON never contains "
+            "ANSI escapes; dashboard cell JSON retains numeric style metadata "
+            "unless colour is disabled."
+        ),
+    )
+    return parent
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="steer_performance_campaign.py",
+        description=(
+            "Safely steer, observe, inspect, and publish a pyAmpliCol "
+            "profiling campaign."
+        ),
+        epilog=STEERING_GUIDE,
+        formatter_class=HelpFormatter,
+    )
+    commands = parser.add_subparsers(dest="command", required=True)
+    selectors = _selector_parent()
+    output = _output_parent()
+
+    run = commands.add_parser(
+        "run",
+        parents=[selectors, output],
+        help="Select cells, preview dependencies, or run supervised workers.",
+        description=(
+            "Select report cells, reuse matching same-source currents by "
+            "default, plan dependencies, and execute resource-supervised "
+            "workers. Cross-revision continuation is explicit and keeps "
+            "active-build dependency planning strict."
+        ),
+        epilog=STEERING_GUIDE,
+        formatter_class=HelpFormatter,
+    )
+    resources = run.add_argument_group("workers and resource limits")
+    resources.add_argument(
+        "--workers",
+        type=int,
+        default=1,
+        help="Concurrent cell workers.",
+    )
+    resources.add_argument(
+        "--cores-per-worker",
+        type=int,
+        default=DEFAULT_CORES_PER_WORKER,
+        help="Generation/engine cores assigned to each worker.",
+    )
+    resources.add_argument(
+        "--amplicol-build-jobs",
+        type=int,
+        default=1,
+        metavar="JOBS",
+        help=(
+            "Make jobs used only for original AmpliCol builds (default: 1). "
+            "Keep this at 1 for the maintained legacy checkout, whose "
+            "generator target is not parallel-safe."
+        ),
+    )
+    resources.add_argument(
+        "--generation-time-limit",
+        type=_positive_finite_float,
+        default=DEFAULT_GENERATION_LIMIT_SECONDS,
+        metavar="SECONDS",
+        help=(
+            "Generation-only cap per process tree; preparation and legacy "
+            "generation count, adaptive profiling does not."
+        ),
+    )
+    resources.add_argument(
+        "--ram-limit",
+        type=_positive_int,
+        default=DEFAULT_RAM_BYTES,
+        metavar="BYTES",
+        help="Decimal process-tree RAM ceiling per worker (30 GB = 30000000000).",
+    )
+    resources.add_argument(
+        "--campaign-ram-limit",
+        type=_positive_int,
+        metavar="BYTES",
+        help=(
+            "Optional decimal RAM ceiling across all concurrent worker trees. "
+            "The controller enforces it conservatively by also limiting each "
+            "worker to this value divided by --workers; the effective worker "
+            "cap is the smaller of that share and --ram-limit."
+        ),
+    )
+    resources.add_argument(
+        "--attempt-output-limit",
+        type=_positive_int,
+        default=DEFAULT_ATTEMPT_OUTPUT_LIMIT_BYTES,
+        metavar="BYTES",
+        help=(
+            "Maximum size of each supervised attempt log/output stream "
+            f"(default: {DEFAULT_ATTEMPT_OUTPUT_LIMIT_BYTES} bytes). A breach "
+            "terminates that worker tree and records an error."
+        ),
+    )
+    resources.add_argument(
+        "--minimum-free-disk",
+        type=_positive_int,
+        default=DEFAULT_MINIMUM_FREE_DISK_BYTES,
+        metavar="BYTES",
+        help=(
+            "Minimum free bytes reserved on the campaign artifact volume "
+            f"(default: {DEFAULT_MINIMUM_FREE_DISK_BYTES}). Crossing the "
+            "reserve terminates the active worker tree and records an error."
+        ),
+    )
+    resources.add_argument(
+        "--worker-wall-limit",
+        type=_positive_finite_float,
+        default=DEFAULT_WORKER_WALL_LIMIT_SECONDS,
+        metavar="SECONDS",
+        help=(
+            "Hard total process-tree wall-time cap per worker; defaults to "
+            "3600 seconds and bounds generation, profiling, validation, and "
+            "every descendant command."
+        ),
+    )
+    resources.add_argument(
+        "--resource-sample-interval",
+        type=_positive_finite_float,
+        default=1.0,
+        metavar="SECONDS",
+        help="Process-tree CPU/RAM/dashboard sampling interval.",
+    )
+    resources.add_argument(
+        "--termination-grace",
+        type=_nonnegative_finite_float,
+        default=5.0,
+        metavar="SECONDS",
+        help=(
+            "Grace after SIGTERM before a remaining process tree is killed; "
+            "cancelled attempts are then sealed with compact diagnostics. "
+            "Output/free-disk breaches escalate immediately for host safety."
+        ),
+    )
+    resources.add_argument(
+        "--allow-oversubscription",
+        action="store_true",
+        help="Permit workers x cores to exceed logical CPU count.",
+    )
+    resources.add_argument(
+        "--allow-engine-parallelism",
+        action="store_true",
+        help=(
+            "Allow concurrent engine preparation where the scheduler normally "
+            "serializes it."
+        ),
+    )
+    resources.add_argument(
+        "--original-amplicol",
+        type=Path,
+        metavar="PATH_TO_COMPLETE_CHECKOUT",
+        help=(
+            "Clean, complete original-AmpliCol checkout containing the profiling "
+            "interface from PR #12 (currently amplicol_with_patches; compatible "
+            "upstream revisions are accepted after merge). Required when the "
+            "direct selection or automatically added diagnostic dependency "
+            "includes the amplicol engine. When no checkout is configured, "
+            "recurrence remains available as the authority for compiled/eager "
+            "work. Pass "
+            "--no-dependencies-added for an explicitly baseline-free selection. "
+            "Omitted or '*' engine selection means all engines."
+        ),
+    )
+    resources.add_argument(
+        "--madgraph",
+        type=Path,
+        metavar="PATH_TO_MADGRAPH_INSTALLATION",
+        help=(
+            "MadGraph installation containing an executable bin/mg5_aMC. "
+            "Installed campaign copies default to the path saved in "
+            ".pyamplicol-madgraph."
+        ),
+    )
+    profiling = run.add_argument_group("profiling hyperparameters")
+    profiling.add_argument(
+        "--target-measurement-duration",
+        type=_positive_finite_float,
+        default=DEFAULT_TARGET_RUNTIME_SECONDS,
+        metavar="SECONDS",
+        help="Target accumulated profiling duration for each runtime.",
+    )
+    profiling.add_argument(
+        "--minimum-samples",
+        type=int,
+        default=DEFAULT_MINIMUM_SAMPLES,
+        help="Minimum independent timed profiling blocks (at least 5).",
+    )
+    profiling.add_argument(
+        "--warmups",
+        type=int,
+        default=DEFAULT_WARMUP_RUNS,
+        help="Untimed runtime warmup calls before calibration.",
+    )
+    profiling.add_argument(
+        "--batch-size",
+        type=int,
+        default=DEFAULT_BATCH_SIZE,
+        help="Phase-space points in each runtime batch.",
+    )
+    behavior = run.add_argument_group("reuse and display")
+    behavior.add_argument(
+        "--no-dependencies-added",
+        action="store_true",
+        help=(
+            "Do not automatically add availability-optional numerical "
+            "authorities outside the direct selection. Hard construction and "
+            "selector/provider dependencies are always retained; explicitly "
+            "selected authorities still run first."
+        ),
+    )
+    behavior.add_argument(
+        "--force-refresh",
+        action="store_true",
+        help=(
+            "Create a fresh generation+measurement attempt even when a "
+            "complete current exists (including one accepted through "
+            "--continue-across-revisions). Disposable workspaces are compacted "
+            "after preserving bounded diagnostics by default."
+        ),
+    )
+    behavior.add_argument(
+        "--rerun-failed",
+        action="store_true",
+        help=(
+            "Create fresh attempts only for selected cells whose latest "
+            "terminal outcome is a non-cap failure. Valid, unseen, static-N/A, "
+            "and authenticated capped cells are excluded. Missing or historical "
+            "numerical authorities are added as dependency-only work unless "
+            "--no-dependencies-added is given. May be combined with "
+            "--rerun-capped, but not --force-refresh."
+        ),
+    )
+    behavior.add_argument(
+        "--rerun-capped",
+        action="store_true",
+        help=(
+            "Create fresh attempts only for selected cells with an "
+            "authenticated generation, RAM, worker, profiling, or validation "
+            "cap. May be combined with --rerun-failed, but not "
+            "--force-refresh."
+        ),
+    )
+    behavior.add_argument(
+        "--cleanup-artifacts",
+        action="store_true",
+        help=(
+            "Compatibility spelling for the default compact-retention policy: "
+            "preserve results, provenance, progress, and bounded diagnostics "
+            "while removing disposable build/reference workspaces."
+        ),
+    )
+    behavior.add_argument(
+        "--retain-workspaces",
+        action="store_true",
+        help=(
+            "Opt in to retaining full legacy, MadGraph, build, failed, and "
+            "obsolete attempt workspaces for debugging. Output and free-disk "
+            "safety limits remain enforced."
+        ),
+    )
+    behavior.add_argument(
+        "--fail-fast",
+        action="store_true",
+        help=(
+            "Stop new dispatch after the first terminal non-success, cancel "
+            "other live workers, complete multiplicities in n=1, n=2, ... "
+            "waves, retain bounded failed/cancelled diagnostics, exit "
+            "nonzero, and atomically write "
+            "campaign_summary_ids/fail_fast_failure.log with exact diagnostic "
+            "and reproduction paths. Cancelled outcomes caused by the stop are "
+            "not treated as a second failure. With --dry-run no report is "
+            "created."
+        ),
+    )
+    behavior.add_argument(
+        "--continue-across-revisions",
+        action="store_true",
+        help=(
+            "Explicitly keep structurally valid completed selected cells from "
+            "older pyAmpliCol source revisions while filling missing cells "
+            "with this clean active build. Historical currents never satisfy "
+            "dependencies required by newly run cells: those dependencies are "
+            "planned again at the active revision. The policy is persisted so "
+            "later inspect and refresh-pdf commands automatically merge the "
+            "per-cell currents and report every exact source cohort/count."
+        ),
+    )
+    behavior.add_argument(
+        "--dry-run",
+        action="store_true",
+        help=(
+            "Print direct cells, dependency closure, reuse counts, and "
+            "copy-paste public CLI recipes without launching workers."
+        ),
+    )
+    behavior.add_argument(
+        "--no-dashboard",
+        action="store_true",
+        help="Run without the interactive Ratatui terminal dashboard.",
+    )
+
+    inspect = commands.add_parser(
+        "inspect",
+        parents=[selectors, output],
+        help="Inspect coverage and AmpliCol-relative summary statistics.",
+        description=(
+            "Summarize lightweight current metadata and compute candidate / "
+            "AmpliCol generation and outer-wall runtime multipliers. Dedicated "
+            "evaluator-total multipliers are emitted only when both sides "
+            "expose that clock; original AmpliCol normally does not. "
+            "Recurrence core is reported separately as an absolute statistic. "
+            "If the latest real run enabled cross-revision continuation, the "
+            "persisted mixed current set and its exact source cohorts are used."
+        ),
+        epilog=(
+            "Lower multipliers are better. The weighted average is exactly "
+            "sum(candidate) / sum(AmpliCol). Missing, capped, incompatible, "
+            "baseline-less, and unexposed clocks are excluded and counted. "
+            "Outer wall, evaluator-total, and recurrence core are never copied "
+            "or derived from one another.\n\n" + STEERING_GUIDE
+        ),
+        formatter_class=HelpFormatter,
+    )
+    inspect.add_argument(
+        "--format",
+        choices=("human", "json"),
+        default="human",
+        help="Human coloured tables or stable uncoloured JSON.",
+    )
+
+    refresh = commands.add_parser(
+        "refresh-pdf",
+        parents=[output],
+        help="Rebuild every table and atomically replace the report PDF.",
+        description=(
+            "Capture one stable current snapshot, rebuild every "
+            "result JSON and TeX table, compile in a fresh directory, and "
+            "atomically install pyAmpliCol.pdf. Overfull-box diagnostics are "
+            "reported by LaTeX but are non-fatal here; compilation errors and "
+            "unresolved references remain fatal. Compilation output streams "
+            "live by default; --quiet suppresses it. The final absolute PDF "
+            "path is printed on success. A prior real run with "
+            "--continue-across-revisions automatically publishes the mixed "
+            "per-cell current set and reports every exact source cohort/count."
+        ),
+        epilog=STEERING_GUIDE,
+        formatter_class=HelpFormatter,
+    )
+    refresh.add_argument(
+        "--expected-page-count",
+        type=int,
+        default=None,
+        help=(
+            "Optional stable page-count assertion. Omit it to accept legitimate "
+            "layout changes or a copied campaign profile with a different name."
+        ),
+    )
+    refresh.add_argument(
+        "--pdf-timeout",
+        type=_positive_finite_float,
+        default=DEFAULT_PDF_TIMEOUT_SECONDS,
+        metavar="SECONDS",
+        help="Direct latexmk process timeout.",
+    )
+    refresh.add_argument(
+        "--quiet",
+        action="store_true",
+        help=(
+            "Suppress the live artifact-scan progress display and latexmk "
+            "stdout/stderr. The final publication summary and absolute PDF "
+            "path are still printed."
+        ),
+    )
+    sections = refresh.add_mutually_exclusive_group()
+    sections.add_argument(
+        "--list-sections",
+        action="store_true",
+        help=(
+            "List stable section IDs and exit without reading campaign "
+            "artifacts or rebuilding the PDF."
+        ),
+    )
+    sections.add_argument(
+        "--remove-sections",
+        nargs="+",
+        metavar="SECTION_ID",
+        help=(
+            "Omit one or more listed top-level sections from this PDF build. "
+            "Measurements, caches, tables, and the source template are unchanged."
+        ),
+    )
+
+    snapshot = commands.add_parser(
+        "dashboard-snapshot",
+        parents=[output],
+        help="Capture a deterministic fixture or read-only live lease frame.",
+        description=(
+            "Render a Ratatui headless frame for visual review and automated "
+            "style/value assertions. The default is a deterministic synthetic "
+            "fixture. --live instead reads only compact non-stale JSON leases "
+            "from the manual profile's ignored coordination directory: it "
+            "does not inspect results, artifacts, source identity, or Git."
+        ),
+        epilog=(
+            "Selection rules:\n"
+            "  Without --live, output is deterministic and independent of "
+            "campaign state.\n"
+            "  With --live, the newest active lease is selected unless "
+            "--instance names\n"
+            "  an exact ID or unique prefix. Active same-source peer workers "
+            "are shown\n"
+            "  as peer rows; overview totals remain the selected invocation's "
+            "own atomic\n"
+            "  counters so overlapping selections are never guessed or "
+            "double-counted.\n\n"
+            "Examples:\n"
+            "  steer_performance_campaign.py dashboard-snapshot "
+            "--width 80 --height 24\n"
+            "  steer_performance_campaign.py dashboard-snapshot "
+            "--width 160 --height 48 --cells-json\n"
+            "  steer_performance_campaign.py dashboard-snapshot --live "
+            "--width 160 --height 48\n"
+            "  steer_performance_campaign.py dashboard-snapshot --live "
+            "--instance 7f91c2 --stale-after 30"
+        ),
+        formatter_class=HelpFormatter,
+    )
+    snapshot.add_argument("--width", type=int, default=120, help="Frame columns.")
+    snapshot.add_argument("--height", type=int, default=36, help="Frame rows.")
+    snapshot.add_argument(
+        "--cells-json",
+        action="store_true",
+        help=(
+            "Emit ANSI-free styled-cell JSON instead of the terminal frame. "
+            "Use --no-color or NO_COLOR to zero the Ratatui style metadata."
+        ),
+    )
+    snapshot.add_argument(
+        "--live",
+        action="store_true",
+        help=(
+            "Capture actual running state from lightweight lease JSON only. "
+            "No measurement/current/artifact/source/Git data is read, and "
+            "nothing is written. Without this flag the synthetic fixture is "
+            "rendered."
+        ),
+    )
+    snapshot.add_argument(
+        "--instance",
+        "--instance-id",
+        metavar="ID_OR_PREFIX",
+        help=(
+            "With --live, select one invocation by its exact instance ID or a "
+            "unique prefix. Omit to select the most recently updated active "
+            "lease."
+        ),
+    )
+    snapshot.add_argument(
+        "--stale-after",
+        type=_positive_finite_float,
+        default=DEFAULT_WORKER_STALE_SECONDS,
+        metavar="SECONDS",
+        help=(
+            "With --live, ignore leases older than this positive interval. "
+            "Increase only when resource sampling is intentionally slower."
+        ),
+    )
+    return parser
+
+
+def main(
+    argv: Sequence[str] | None = None,
+    *,
+    repo_root: Path | None = None,
+    profile: str = PROFILE,
+    docs_dir: Path | None = None,
+    installed: bool = False,
+    launcher_path_checked: bool = False,
+) -> int:
+    global _ACTIVE_PROFILE
+
+    selected_profile = validate_profile_name(profile)
+    _ACTIVE_PROFILE = selected_profile
+    parser = build_parser()
+    invocation_arguments = tuple(sys.argv[1:] if argv is None else argv)
+    invocation_program = sys.argv[0] if argv is None else parser.prog
+    arguments = parser.parse_args(invocation_arguments)
+    arguments._campaign_invocation_command = _shell_join(
+        (invocation_program, *invocation_arguments)
+    )
+    root = (
+        Path.cwd().resolve(strict=False)
+        if repo_root is None
+        else repo_root.expanduser().resolve(strict=False)
+    )
+    if installed and docs_dir is None:
+        raise ValueError("installed campaign mode requires its destination directory")
+    campaign_docs = (
+        root / "docs/performance_reports" / selected_profile
+        if docs_dir is None
+        else docs_dir
+    )
+    json_output = arguments.command == "inspect" and arguments.format == "json"
+    palette = Palette(_color_enabled(arguments, json_output=json_output))
+    campaign_lock: int | None = None
+    try:
+        _require_launcher_working_directory_identity(
+            launcher_path_checked=launcher_path_checked,
+        )
+        if arguments.command == "refresh-pdf" and arguments.list_sections:
+            _print_report_sections(palette)
+            return 0
+        paths = _campaign_report_paths(root, campaign_docs)
+        campaign_lock = _acquire_campaign_directory_lock(paths.docs_dir)
+        dashboard_disabled = _configure_dashboard_capability(
+            arguments,
+            installed=installed,
+        )
+        if (
+            dashboard_disabled
+            and bool(getattr(sys.stdin, "isatty", lambda: False)())
+            and bool(getattr(sys.stdout, "isatty", lambda: False)())
+        ):
+            print(
+                palette.warning(
+                    "Optional Ratatui bindings are unavailable; continuing with "
+                    "--no-dashboard."
+                ),
+                file=sys.stderr,
+            )
+        if arguments.command == "dashboard-snapshot":
+            if arguments.instance is not None and not arguments.live:
+                raise ManualCampaignError("--instance requires --live")
+            state = (
+                _live_dashboard_snapshot(
+                    paths.coordination_root,
+                    instance=arguments.instance,
+                    stale_after_seconds=arguments.stale_after,
+                )
+                if arguments.live
+                else _snapshot_fixture()
+            )
+            result = render_dashboard_frame(
+                state,
+                width=arguments.width,
+                height=arguments.height,
+                cells=arguments.cells_json,
+                color=palette.enabled,
+            )
+            if arguments.cells_json:
+                json.dump(result, sys.stdout, indent=2, sort_keys=True)
+                sys.stdout.write("\n")
+            else:
+                print(result)
+            return 0
+
+        service = ReportService(paths, portable_current_results=True)
+        service.bind_measurement_lineage(None)
+        service.bind_original_amplicol_seed(None)
+        source = (
+            installed_source_identity(
+                allow_candidate_checkout=(
+                    arguments.command == "run"
+                    and bool(getattr(arguments, "dry_run", False))
+                )
+            )
+            if installed
+            else lightweight_source_identity(root)
+        )
+
+        if arguments.command == "refresh-pdf":
+            return _refresh_pdf(
+                arguments,
+                service=service,
+                source=source,
+                palette=palette,
+            )
+
+        _selection, cells = selection_from_arguments(arguments)
+        if arguments.command == "inspect":
+            source_policy = recorded_measurement_source_policy(
+                service,
+                checkout_revision=source.revision,
+            )
+            payload = _inspect_payload(
+                service,
+                cells,
+                source_revision=source_policy.source_revision,
+                renderer_revision=source.revision,
+                accept_historical_source=(source_policy.continue_across_revisions),
+            )
+            if arguments.format == "json":
+                json.dump(payload, sys.stdout, indent=2, sort_keys=True)
+                sys.stdout.write("\n")
+            else:
+                _print_inspect(payload, palette)
+            return 0
+        if arguments.command == "run":
+            return _run_campaign(
+                arguments,
+                repo_root=root,
+                service=service,
+                source=source,
+                cells=cells,
+                palette=palette,
+                installed=installed,
+            )
+        parser.error(f"unsupported command {arguments.command!r}")
+    except KeyboardInterrupt:
+        print(
+            palette.warning("Interrupted cleanly; completed currents were preserved."),
+            file=sys.stderr,
+        )
+        return 130
+    except (ManualCampaignError, OSError, RuntimeError, TypeError, ValueError) as error:
+        print(palette.failure(f"error: {error}"), file=sys.stderr)
+        return 2
+    finally:
+        if campaign_lock is not None:
+            _release_campaign_directory_lock(campaign_lock)
+    return 2
+
+
+__all__ = [
+    "Comparison",
+    "DashboardState",
+    "LightweightCurrent",
+    "ManualCampaignError",
+    "ReproductionRecipe",
+    "ReproductionSettings",
+    "WorkerView",
+    "build_parser",
+    "comparison_statistics",
+    "lightweight_current",
+    "main",
+    "render_dashboard_frame",
+    "reproduction_recipe",
+    "selection_from_arguments",
+]
diff --git a/pyamplicol/tools/performance_report/measurement.py b/pyamplicol/tools/performance_report/measurement.py
new file mode 100644
index 0000000000..c917b39b9f
--- /dev/null
+++ b/pyamplicol/tools/performance_report/measurement.py
@@ -0,0 +1,1911 @@
+# SPDX-License-Identifier: 0BSD
+"""One-cell measurement orchestration over the public pyAmpliCol Python API."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import time
+import uuid
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .service import ReportPaths
+
+from .agreements import (
+    DIRECT_AGREEMENT_FIELD,
+    INDEPENDENT_AUTHORITY_ABI,
+    INDEPENDENT_AUTHORITY_FIELD,
+    LC_COMMON_COMPONENT_FIELD,
+    MADGRAPH_COMPARISON_FIELD,
+    MADGRAPH_FULL_COLOUR,
+    evaluate_lc_common_component,
+    incoming_agreement_edges,
+    independent_numerical_authorities,
+    madgraph_candidate_precision,
+    madgraph_comparison_record,
+    requires_independent_numerical_authority,
+    validate_lc_common_component,
+)
+from .cache import empty_measurement
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .models import (
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from .phase_state import WorkerPhaseReporter
+from .runner import (
+    INDEPENDENT_RELATIVE_TOLERANCE,
+    OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD,
+    RELATIVE_TOLERANCE,
+    GeneratedArtifact,
+    RunnerError,
+    RunnerSettings,
+    SelectorContract,
+    _real_nonnegative,
+    _selector_kwargs,
+    generate_artifact,
+    on_the_fly_recurrence_authority_validation,
+    point_digest,
+    pointwise_validation,
+    profile_runtime,
+    provenance_payload,
+    resolved_sum_validation,
+    runtime_identity_payload,
+    runtime_validation_points,
+    validate_artifact_contract,
+    validate_resolved_sum_validation_record,
+)
+from .source_identity import (
+    ReportSourceIdentityError,
+    inspect_report_source,
+    require_eligible_report_source,
+)
+
+
+def shared_validation_points(process: str) -> object:
+    from pyamplicol.models.builtin.validation import generic_validation_point
+
+    return (
+        tuple(
+            tuple(float(component) for component in particle.momentum)
+            for particle in generic_validation_point(process)
+        ),
+    )
+
+
+def _reproduction_momenta(points: object) -> object:
+    """Return the exact measured points in portable public-CLI JSON form."""
+
+    to_list = getattr(points, "tolist", None)
+    payload = to_list() if callable(to_list) else points
+    try:
+        encoded = json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+        )
+    except (TypeError, ValueError) as error:
+        raise RunnerError(
+            "report profiling points cannot be materialized for reproduction"
+        ) from error
+    return json.loads(encoded)
+
+
+def source_revision(repo_root: Path, *, require_clean: bool = False) -> str:
+    try:
+        identity = (
+            require_eligible_report_source(repo_root)
+            if require_clean
+            else inspect_report_source(repo_root)
+        )
+    except ReportSourceIdentityError as error:
+        if require_clean:
+            raise RunnerError(
+                "report source worktree contains changes outside generated "
+                f"report outputs: {error}"
+            ) from error
+        return "unknown"
+    return identity.revision
+
+
+def file_digest(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _baseline_selector_contract(
+    baseline: Mapping[str, object] | None,
+) -> SelectorContract | None:
+    if baseline is None:
+        return None
+    raw = baseline.get("selector_contract")
+    if raw is None:
+        return None
+    if not isinstance(raw, Mapping):
+        raise RunnerError("baseline selector_contract must be an object")
+    return SelectorContract.from_mapping(raw)
+
+
+def _measurement_selector_contract(
+    cell: CellSpec,
+    baseline: Mapping[str, object] | None,
+    selector_provider: Mapping[str, object] | None,
+) -> SelectorContract | None:
+    """Choose one canonical LC selector before candidate work starts."""
+
+    if cell.measurement.accuracy is not Accuracy.LC:
+        return None
+    baseline_contract = _baseline_selector_contract(baseline)
+    provider_contract: SelectorContract | None = None
+    if selector_provider is not None:
+        if selector_provider.get("status") != ResultStatus.OK.value:
+            raise RunnerError("LC selector provider is not a successful measurement")
+        try:
+            provider_contract = _baseline_selector_contract(selector_provider)
+        except (TypeError, ValueError) as error:
+            raise RunnerError("LC selector provider has an invalid contract") from error
+        if provider_contract is None:
+            raise RunnerError("LC selector provider has no selector_contract")
+    if (
+        baseline_contract is not None
+        and provider_contract is not None
+        and baseline_contract != provider_contract
+    ):
+        raise RunnerError(
+            "LC validation baseline and selected-flow selector provider disagree"
+        )
+    if baseline_contract is not None:
+        return baseline_contract
+    return provider_contract
+
+
+def _baseline_matrix_element(
+    baseline: Mapping[str, object] | None,
+) -> float | None:
+    if baseline is None:
+        return None
+    if baseline.get("status") != ResultStatus.OK.value:
+        raise RunnerError("candidate baseline is not a valid completed measurement")
+    value = baseline.get("matrix_element")
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise RunnerError("candidate baseline has no matrix element")
+    return float(value)
+
+
+_LEGACY_NUMERICAL_AUTHORITY_ABI = "pyamplicol-report-legacy-numerical-authority-v1"
+_LEGACY_NUMERICAL_AUTHORITY_FIELD = "legacy_numerical_authority"
+_LEGACY_ALL_FLOW_COMPONENT_AUTHORITY_SOURCE = "all-flow-selected-provider-replay"
+
+
+def _independent_authority_record(
+    expected_cell_ids: Sequence[str],
+    *,
+    selected_cell_id: str | None,
+    status: str,
+    reason: str,
+) -> dict[str, object]:
+    return {
+        "abi": INDEPENDENT_AUTHORITY_ABI,
+        "expected_cell_ids": list(expected_cell_ids),
+        "selected_cell_id": selected_cell_id,
+        "status": status,
+        "reason": reason,
+        "same_artifact_diagnostics_are_authority": False,
+    }
+
+
+def baseline_uses_lc_common_component_authority(
+    cell: CellSpec,
+    baseline: Mapping[str, object] | None,
+) -> bool:
+    """Whether an LC all-flow baseline authenticates only its shared component."""
+
+    if (
+        baseline is None
+        or cell.measurement.accuracy is not Accuracy.LC
+        or cell.workload is not Workload.ALL_FLOW
+    ):
+        return False
+    validation = baseline.get("validation")
+    authority = (
+        validation.get(_LEGACY_NUMERICAL_AUTHORITY_FIELD)
+        if isinstance(validation, Mapping)
+        else None
+    )
+    if not (
+        isinstance(authority, Mapping)
+        and authority.get("abi") == _LEGACY_NUMERICAL_AUTHORITY_ABI
+        and authority.get("source") == _LEGACY_ALL_FLOW_COMPONENT_AUTHORITY_SOURCE
+    ):
+        return False
+    if baseline.get("status") != ResultStatus.OK.value:
+        raise RunnerError("LC all-flow component authority is not successful")
+    try:
+        validate_lc_common_component(
+            validation.get(LC_COMMON_COMPONENT_FIELD),
+            selector_contract=baseline.get("selector_contract"),
+        )
+    except ValueError as error:
+        raise RunnerError(
+            "LC all-flow component authority is not bound to its selector"
+        ) from error
+    return True
+
+
+def _attach_baseline_validation(
+    cell: CellSpec,
+    validation: dict[str, object],
+    *,
+    candidate_matrix_element: float,
+    baseline: Mapping[str, object] | None,
+    points: object = None,
+    contract: SelectorContract | None = None,
+) -> None:
+    if baseline_uses_lc_common_component_authority(cell, baseline):
+        # The worker's direct-agreement edge compares the authenticated shared
+        # component.  Direct imode2's aggregate is diagnostic, not authority.
+        return
+    baseline_value = _baseline_matrix_element(baseline)
+    if baseline_value is not None:
+        resolved_sum = validation.get("resolved_sum")
+        if not isinstance(resolved_sum, Mapping):
+            raise RunnerError("candidate resolved-sum scale evidence is unavailable")
+        point_records = resolved_sum.get("points")
+        if not isinstance(point_records, list) or len(point_records) != 1:
+            raise RunnerError("candidate comparison requires one resolved point")
+        point_record = point_records[0]
+        if not isinstance(point_record, Mapping):
+            raise RunnerError("candidate resolved scale record is unavailable")
+        candidate_scale = point_record.get("candidate_scale")
+        candidate_source = resolved_sum.get("resolved_source_sha256")
+        if (
+            isinstance(candidate_scale, bool)
+            or not isinstance(candidate_scale, (int, float))
+            or not isinstance(candidate_source, str)
+        ):
+            raise RunnerError("candidate resolved scale evidence is invalid")
+        baseline_source = _comparison_source_digest(
+            {
+                "matrix_element": baseline_value,
+                "selector_contract": baseline.get("selector_contract"),
+                "validation": baseline.get("validation"),
+                "provenance": baseline.get("provenance"),
+            }
+        )
+        validation["pointwise"] = pointwise_validation(
+            candidate_matrix_element,
+            baseline_value,
+            relative_tolerance=_pointwise_tolerance(cell),
+            candidate_scale=float(candidate_scale),
+            baseline_scale=abs(baseline_value),
+            candidate_scale_source="resolved-component-l1",
+            baseline_scale_source="authority-value-magnitude",
+            comparison_binding=_conditioned_binding(
+                cell,
+                points,
+                contract,
+                candidate_source_sha256=candidate_source,
+                baseline_source_sha256=baseline_source,
+                value_kind="matrix-element",
+            ),
+        )
+
+
+def _stored_validation_point_digest(measurement: Mapping[str, object]) -> str:
+    selector = measurement.get("selector_contract")
+    if isinstance(selector, Mapping):
+        raw = selector.get("point_digest")
+        if isinstance(raw, str):
+            return raw
+    validation = measurement.get("validation")
+    if isinstance(validation, Mapping):
+        raw = validation.get("point_digest")
+        if isinstance(raw, str):
+            return raw
+        resolved = validation.get("resolved_sum")
+        if isinstance(resolved, Mapping):
+            try:
+                validate_resolved_sum_validation_record(resolved)
+            except ValueError as error:
+                raise RunnerError(
+                    "measurement resolved-sum point identity is invalid"
+                ) from error
+            raw = resolved.get("point_digest")
+            if isinstance(raw, str):
+                return raw
+    provenance = measurement.get("provenance")
+    if isinstance(provenance, Mapping) and "report_momenta" in provenance:
+        return point_digest(provenance["report_momenta"])
+    raise RunnerError("measurement has no validation point identity")
+
+
+def _stored_conditioned_scale(
+    measurement: Mapping[str, object],
+    value: float,
+) -> tuple[float, str, str]:
+    validation = measurement.get("validation")
+    if isinstance(validation, Mapping):
+        resolved = validation.get("resolved_sum")
+        if isinstance(resolved, Mapping):
+            try:
+                validate_resolved_sum_validation_record(resolved)
+            except ValueError as error:
+                raise RunnerError(
+                    "measurement resolved-sum scale evidence is invalid"
+                ) from error
+            records = resolved.get("points")
+            source = resolved.get("resolved_source_sha256")
+            if (
+                isinstance(records, list)
+                and len(records) == 1
+                and isinstance(records[0], Mapping)
+                and isinstance(source, str)
+            ):
+                raw_scale = records[0].get("candidate_scale")
+                raw_candidate = records[0].get("candidate")
+                if (
+                    not isinstance(raw_scale, bool)
+                    and isinstance(raw_scale, (int, float))
+                    and math.isfinite(float(raw_scale))
+                    and float(raw_scale) >= abs(value)
+                    and not isinstance(raw_candidate, bool)
+                    and isinstance(raw_candidate, (int, float))
+                    and float(raw_candidate) == value
+                ):
+                    return float(raw_scale), "resolved-component-l1", source
+                raise RunnerError(
+                    "measurement matrix element differs from resolved-sum evidence"
+                )
+    source = _comparison_source_digest(
+        {
+            "matrix_element": value,
+            "selector_contract": measurement.get("selector_contract"),
+            "validation": validation,
+            "provenance": measurement.get("provenance"),
+        }
+    )
+    return abs(value), "authority-value-magnitude", source
+
+
+def _stored_lc_common_component(
+    measurement: Mapping[str, object],
+    *,
+    selector_contract: Mapping[str, object],
+    expected_cell_id: str | None,
+) -> tuple[float, Mapping[str, object], str]:
+    validation = measurement.get("validation")
+    observation = (
+        validation.get(LC_COMMON_COMPONENT_FIELD)
+        if isinstance(validation, Mapping)
+        else None
+    )
+    try:
+        validate_lc_common_component(
+            observation,
+            expected_cell_id=expected_cell_id,
+            selector_contract=selector_contract,
+        )
+    except ValueError as error:
+        raise RunnerError(
+            "LC all-flow authority has no selector-bound common component"
+        ) from error
+    assert isinstance(observation, Mapping)
+    raw_value = observation.get("value")
+    if isinstance(raw_value, bool) or not isinstance(raw_value, (int, float)):
+        raise RunnerError("LC all-flow common component is not numeric")
+    value = float(raw_value)
+    if not math.isfinite(value):
+        raise RunnerError("LC all-flow common component is not finite")
+    return value, observation, _comparison_source_digest(observation)
+
+
+def conditioned_measurement_comparison(
+    cell: CellSpec,
+    candidate: Mapping[str, object],
+    baseline: Mapping[str, object],
+) -> dict[str, object]:
+    """Compare a completed candidate to late independent authority evidence."""
+
+    raw_contract = candidate.get("selector_contract")
+    baseline_contract = baseline.get("selector_contract")
+    if raw_contract != baseline_contract:
+        raise RunnerError("candidate and authority selector contracts differ")
+    contract = (
+        None if raw_contract is None else SelectorContract.from_mapping(raw_contract)  # type: ignore[arg-type]
+    )
+    candidate_point = _stored_validation_point_digest(candidate)
+    baseline_point = _stored_validation_point_digest(baseline)
+    if candidate_point != baseline_point:
+        raise RunnerError("candidate and authority validation points differ")
+
+    if baseline_uses_lc_common_component_authority(cell, baseline):
+        if not isinstance(raw_contract, Mapping) or contract is None:
+            raise RunnerError("LC all-flow authority has no selector contract")
+        candidate_value, candidate_component, candidate_source = (
+            _stored_lc_common_component(
+                candidate,
+                selector_contract=raw_contract,
+                expected_cell_id=cell.cell_id,
+            )
+        )
+        baseline_value, baseline_component, baseline_source = (
+            _stored_lc_common_component(
+                baseline,
+                selector_contract=raw_contract,
+                expected_cell_id=None,
+            )
+        )
+        component_identity = {
+            "candidate_cell_id": candidate_component["cell_id"],
+            "baseline_cell_id": baseline_component["cell_id"],
+            "point_digest": candidate_component["point_digest"],
+            "helicity_ids": candidate_component["helicity_ids"],
+            "color_flow_ids": candidate_component["color_flow_ids"],
+        }
+        if any(
+            candidate_component[field] != baseline_component[field]
+            for field in ("point_digest", "helicity_ids", "color_flow_ids")
+        ):
+            raise RunnerError("LC all-flow common-component identities differ")
+        selector_identity = {
+            "cell_id": cell.cell_id,
+            "accuracy": cell.measurement.accuracy.value,
+            "workload": cell.workload.value,
+            "selector_contract": contract.as_dict(),
+            "value_kind": LC_COMMON_COMPONENT_FIELD,
+            "component_identity": component_identity,
+        }
+        return pointwise_validation(
+            candidate_value,
+            baseline_value,
+            relative_tolerance=_pointwise_tolerance(cell),
+            candidate_scale=abs(candidate_value),
+            baseline_scale=abs(baseline_value),
+            candidate_scale_source="authority-component-magnitude",
+            baseline_scale_source="authority-component-magnitude",
+            comparison_binding={
+                "point_digest": candidate_point,
+                "selector_component_identity": selector_identity,
+                "selector_component_sha256": _comparison_source_digest(
+                    selector_identity
+                ),
+                "candidate_source_sha256": candidate_source,
+                "baseline_source_sha256": baseline_source,
+            },
+        )
+
+    raw_candidate_value = candidate.get("matrix_element")
+    if isinstance(raw_candidate_value, bool) or not isinstance(
+        raw_candidate_value, (int, float)
+    ):
+        raise RunnerError("candidate has no matrix element")
+    candidate_value = float(raw_candidate_value)
+    if not math.isfinite(candidate_value):
+        raise RunnerError("candidate matrix element is not finite")
+    baseline_value = _baseline_matrix_element(baseline)
+    assert baseline_value is not None
+    candidate_scale, candidate_scale_source, candidate_source = (
+        _stored_conditioned_scale(candidate, candidate_value)
+    )
+    baseline_scale, baseline_scale_source, baseline_source = _stored_conditioned_scale(
+        baseline, baseline_value
+    )
+    return pointwise_validation(
+        candidate_value,
+        baseline_value,
+        relative_tolerance=_pointwise_tolerance(cell),
+        candidate_scale=candidate_scale,
+        baseline_scale=baseline_scale,
+        candidate_scale_source=candidate_scale_source,
+        baseline_scale_source=baseline_scale_source,
+        comparison_binding={
+            "point_digest": candidate_point,
+            "selector_component_identity": {
+                "cell_id": cell.cell_id,
+                "accuracy": cell.measurement.accuracy.value,
+                "workload": cell.workload.value,
+                "selector_contract": None if contract is None else contract.as_dict(),
+                "value_kind": "matrix-element",
+            },
+            "selector_component_sha256": _comparison_source_digest(
+                {
+                    "cell_id": cell.cell_id,
+                    "accuracy": cell.measurement.accuracy.value,
+                    "workload": cell.workload.value,
+                    "selector_contract": (
+                        None if contract is None else contract.as_dict()
+                    ),
+                    "value_kind": "matrix-element",
+                }
+            ),
+            "candidate_source_sha256": candidate_source,
+            "baseline_source_sha256": baseline_source,
+        },
+    )
+
+
+def reconcile_independent_authority(
+    cell: CellSpec,
+    measurement: Mapping[str, object],
+    authority: Mapping[str, object],
+    *,
+    authority_cell_id: str,
+) -> dict[str, object]:
+    """Resolve one durable unverified result against late authority evidence."""
+
+    initial_status = measurement.get("status")
+    if initial_status not in {
+        ResultStatus.UNVERIFIED.value,
+        ResultStatus.OK.value,
+    }:
+        raise RunnerError(
+            "late authority reconciliation requires measured candidate input"
+        )
+    validation = measurement.get("validation")
+    if not isinstance(validation, Mapping):
+        raise RunnerError("unverified result has no validation evidence")
+    record = validation.get(INDEPENDENT_AUTHORITY_FIELD)
+    if not isinstance(record, Mapping):
+        raise RunnerError("unverified result has no independent-authority record")
+    expected_ids = tuple(record.get("expected_cell_ids", ()))
+    canonical_ids = tuple(
+        candidate.cell_id for candidate in independent_numerical_authorities(cell)
+    )
+    previous_selected = record.get("selected_cell_id")
+    record_status = record.get("status")
+    if (
+        record.get("abi") != INDEPENDENT_AUTHORITY_ABI
+        or expected_ids != canonical_ids
+        or authority_cell_id not in canonical_ids
+        or authority.get("status") != ResultStatus.OK.value
+    ):
+        raise RunnerError("late independent-authority contract is invalid")
+    if initial_status == ResultStatus.UNVERIFIED.value:
+        if previous_selected is not None or record_status != "unavailable":
+            raise RunnerError("unverified independent-authority state is invalid")
+    elif (
+        not isinstance(previous_selected, str)
+        or previous_selected not in canonical_ids
+        or record_status != "verified"
+        or canonical_ids.index(authority_cell_id)
+        >= canonical_ids.index(previous_selected)
+    ):
+        raise RunnerError("late authority does not supersede the selected authority")
+
+    updated = dict(measurement)
+    mutable_validation = dict(validation)
+    try:
+        comparison = conditioned_measurement_comparison(cell, updated, authority)
+    except Exception as error:
+        mutable_validation[INDEPENDENT_AUTHORITY_FIELD] = _independent_authority_record(
+            canonical_ids,
+            selected_cell_id=authority_cell_id,
+            status="incompatible",
+            reason="successful-independent-authority-contract-incompatible",
+        )
+        mutable_validation["status"] = ResultStatus.VALIDATION_FAILED.value
+        updated["status"] = ResultStatus.VALIDATION_FAILED.value
+        updated["validation"] = mutable_validation
+        updated["failure"] = {
+            "kind": "IndependentAuthorityContractError",
+            "message": str(error),
+        }
+        return updated
+
+    mutable_validation["pointwise"] = comparison
+    passed = comparison.get("status") == ResultStatus.OK.value
+    mutable_validation[INDEPENDENT_AUTHORITY_FIELD] = _independent_authority_record(
+        canonical_ids,
+        selected_cell_id=authority_cell_id,
+        status="verified" if passed else "mismatch",
+        reason=(
+            "independent-authority-agreement"
+            if passed
+            else "independent-authority-mismatch"
+        ),
+    )
+    resolved_status = (
+        ResultStatus.OK.value if passed else ResultStatus.VALIDATION_FAILED.value
+    )
+    mutable_validation["status"] = resolved_status
+    updated["status"] = resolved_status
+    updated["validation"] = mutable_validation
+    updated["failure"] = (
+        None
+        if passed
+        else {
+            "kind": "IndependentAuthorityMismatch",
+            "message": "candidate disagrees with independent numerical authority",
+        }
+    )
+    return updated
+
+
+_PRECISION_DIAGNOSTIC_ABI = (
+    "pyamplicol-report-validation-failure-precision-diagnostic-v2"
+)
+_PRECISION_DIAGNOSTIC_CELL_IDS = frozenset(
+    {
+        "matrix-compiled-builtin-sm-full-n4-dd-tt-jets-contracted",
+        "matrix-compiled-builtin-sm-nlc-n4-dd-tt-jets-contracted",
+        "matrix-recurrence-builtin-sm-lc-n4-dd-tt-jets-all-flow",
+    }
+)
+
+
+def _precision_diagnostic_enabled(cell: CellSpec) -> bool:
+    return cell.cell_id in _PRECISION_DIAGNOSTIC_CELL_IDS
+
+
+def _diagnostic_number(value: object) -> dict[str, object]:
+    real = getattr(value, "real", value)
+    if callable(real):
+        real = real()
+    return {"value": str(real), "binary64": _real_nonnegative(value)}
+
+
+def _unavailable_precision_diagnostic(error: BaseException) -> dict[str, object]:
+    return {
+        "abi": _PRECISION_DIAGNOSTIC_ABI,
+        "status": "unavailable",
+        "promotes_measurement": False,
+        "error": {"kind": type(error).__name__, "message": str(error)},
+    }
+
+
+def _diagnostic_timing_context(
+    cell: CellSpec,
+    measurement: Mapping[str, object] | None,
+) -> dict[str, object]:
+    """Copy independent measured clocks without recomputing or deriving them."""
+
+    measurement = measurement or {}
+    provenance = measurement.get("provenance")
+    provenance = provenance if isinstance(provenance, Mapping) else {}
+    evaluator_total = provenance.get("evaluator_total_timing")
+    execution = provenance.get("execution_timing")
+    return {
+        "source": "copied-from-measurement",
+        "recomputed": False,
+        "outer_wall_seconds_per_point": measurement.get("wall_seconds_per_point"),
+        "evaluator_total_timing": (
+            dict(evaluator_total) if isinstance(evaluator_total, Mapping) else None
+        ),
+        "recurrence_core_timing": (
+            dict(execution)
+            if cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+            and isinstance(execution, Mapping)
+            else None
+        ),
+    }
+
+
+def _diagnostic_authorities(
+    cell: CellSpec,
+    measurements: Mapping[str, Mapping[str, object]],
+) -> list[dict[str, object]]:
+    """Extract the few already-stored values relevant to the retained canaries."""
+
+    result: list[dict[str, object]] = []
+    for label, measurement in measurements.items():
+        validation = measurement.get("validation")
+        validation = validation if isinstance(validation, Mapping) else {}
+        component_only = baseline_uses_lc_common_component_authority(cell, measurement)
+        legacy = validation.get(_LEGACY_NUMERICAL_AUTHORITY_FIELD)
+        source = (
+            str(legacy.get("source"))
+            if isinstance(legacy, Mapping)
+            else "stored-successful-measurement"
+        )
+
+        common = validation.get(LC_COMMON_COMPONENT_FIELD)
+        imode2 = validation.get("legacy_imode2_diagnostic")
+        kind = LC_COMMON_COMPONENT_FIELD if component_only else "total"
+        candidates = (
+            ("matrix-element", "total", measurement.get("matrix_element"), source),
+            (
+                LC_COMMON_COMPONENT_FIELD,
+                LC_COMMON_COMPONENT_FIELD,
+                common.get("value") if isinstance(common, Mapping) else None,
+                source,
+            ),
+            (
+                "generated-library",
+                kind,
+                imode2.get("authoritative_value")
+                if isinstance(imode2, Mapping)
+                else None,
+                str(imode2.get("authoritative_source", source))
+                if isinstance(imode2, Mapping)
+                else source,
+            ),
+            (
+                "direct-imode2",
+                kind,
+                imode2.get("imode2_value") if isinstance(imode2, Mapping) else None,
+                "legacy-direct-imode2-non-certifying",
+            ),
+        )
+        for name, value_kind, value, value_source in candidates:
+            if (
+                (name == "matrix-element" and component_only)
+                or isinstance(value, bool)
+                or not isinstance(value, (int, float))
+            ):
+                continue
+            result.append(
+                {
+                    "authority": f"{label}:{name}",
+                    "value_kind": value_kind,
+                    "value": float(value),
+                    "source": value_source,
+                }
+            )
+    return result
+
+
+def _diagnostic_evaluation(
+    runtime: object,
+    points: object,
+    *,
+    cell: CellSpec,
+    contract: SelectorContract | None,
+    precision: int,
+    point_context: str,
+) -> dict[str, object]:
+    selectors = _selector_kwargs(cell, contract)
+    values = runtime.evaluate(  # type: ignore[attr-defined]
+        points, precision=precision, **selectors
+    )
+    resolved = runtime.evaluate_resolved(  # type: ignore[attr-defined]
+        points, precision=precision, **selectors
+    )
+    totals = tuple(resolved.total())
+    if len(values) != 1 or len(totals) != 1:
+        raise RunnerError("precision diagnostic requires exactly one point")
+    result = {
+        "point_context": point_context,
+        "total": _diagnostic_number(values[0]),
+        "resolved_sum": _diagnostic_number(totals[0]),
+        "internal_agreement": pointwise_validation(
+            _real_nonnegative(values[0]),
+            _real_nonnegative(totals[0]),
+        ),
+    }
+    if (
+        contract is not None
+        and cell.measurement.accuracy is Accuracy.LC
+        and cell.workload is Workload.ALL_FLOW
+    ):
+        component = runtime.evaluate_resolved(  # type: ignore[attr-defined]
+            points,
+            precision=precision,
+            helicities=contract.runtime_all_flow_helicity_ids,
+            color_flows=contract.selected_color_flow_ids,
+        )
+        if (
+            tuple(component.helicity_ids) != contract.runtime_all_flow_helicity_ids
+            or tuple(component.color_ids) != contract.selected_color_flow_ids
+        ):
+            raise RunnerError("diagnostic LC common-component axes changed")
+        try:
+            result[LC_COMMON_COMPONENT_FIELD] = _diagnostic_number(
+                component.values[0][0][0]
+            )
+        except (AttributeError, IndexError, TypeError) as error:
+            raise RunnerError("diagnostic LC common component is not scalar") from error
+    return result
+
+
+def _validation_failure_precision_diagnostic(
+    runtime: object,
+    points: object,
+    *,
+    cell: CellSpec,
+    contract: SelectorContract | None,
+    baseline: Mapping[str, object] | None,
+    peers: Mapping[str, Mapping[str, object]] | None = None,
+    measurement_context: Mapping[str, object] | None = None,
+    complete_ladder: bool = False,
+) -> dict[str, object]:
+    """Attach a bounded, non-promoting p32/p200 explanation to three canaries."""
+
+    try:
+        measurements = dict(peers or {})
+        if baseline is not None:
+            measurements = {"baseline": baseline, **measurements}
+        authorities = _diagnostic_authorities(cell, measurements)
+        retained_digest = point_digest(points)
+        projector = getattr(runtime, "_diagnostic_project_onshell", None)
+        if not callable(projector):
+            raise RunnerError("runtime does not expose diagnostic on-shell projection")
+        diagnostic_points, raw_projection = projector(points, precision=200)
+        if not isinstance(raw_projection, Mapping):
+            raise RunnerError("runtime returned invalid diagnostic projection metadata")
+        projection = dict(raw_projection)
+        unchanged = projection.get("unchanged")
+        if not isinstance(unchanged, bool):
+            raise RunnerError(
+                "diagnostic projection does not report whether it changed"
+            )
+        projected_digest = projection.get("projected_digest")
+        if not isinstance(projected_digest, str) or not projected_digest:
+            raise RunnerError("diagnostic projection has no projected point digest")
+        projection["original_digest"] = retained_digest
+        if unchanged:
+            candidate_point_context = "retained-point-unchanged-by-projection"
+            authority_point_context = candidate_point_context
+        else:
+            candidate_point_context = "projected-onshell-point"
+            authority_point_context = "original-retained-point"
+        result: dict[str, object] = {
+            "abi": _PRECISION_DIAGNOSTIC_ABI,
+            "status": "diagnostic-only",
+            "promotes_measurement": False,
+            "timings_unchanged": True,
+            "retained_point": {
+                "digest": retained_digest,
+                "momenta": _reproduction_momenta(points),
+            },
+            "kinematic_projection": projection,
+            "stored_peer_point_context": authority_point_context,
+            "selector_contract": None if contract is None else contract.as_dict(),
+            "execution_identity": {
+                "cell_id": cell.cell_id,
+                "process": cell.process,
+                "multiplicity": cell.n_final,
+                "workload": cell.workload.value,
+                "layout": cell.workload.value,
+                "execution_mode": cell.measurement.execution_mode.value,
+                "backend": cell.measurement.backend,
+                "model": (
+                    None
+                    if cell.measurement.model is None
+                    else cell.measurement.model.value
+                ),
+                "accuracy": cell.measurement.accuracy.value,
+                "variant": cell.variant,
+            },
+            "measurement_timing_context": _diagnostic_timing_context(
+                cell, measurement_context
+            ),
+            "attempts": [],
+        }
+        attempts = result["attempts"]
+        assert isinstance(attempts, list)
+        for precision in (32, 200):
+            attempt: dict[str, object] = {"precision_digits": precision}
+            try:
+                candidate = _diagnostic_evaluation(
+                    runtime,
+                    diagnostic_points,
+                    cell=cell,
+                    contract=contract,
+                    precision=precision,
+                    point_context=candidate_point_context,
+                )
+                comparisons = []
+                for authority in authorities:
+                    value_kind = str(authority["value_kind"])
+                    candidate_fields = (
+                        ("total", "resolved_sum")
+                        if value_kind == "total"
+                        else (value_kind,)
+                    )
+                    for candidate_field in candidate_fields:
+                        candidate_value = candidate.get(candidate_field)
+                        if not isinstance(candidate_value, Mapping):
+                            continue
+                        comparison = pointwise_validation(
+                            float(candidate_value["binary64"]),
+                            float(authority["value"]),
+                            relative_tolerance=_pointwise_tolerance(cell),
+                        )
+                        comparison_payload = {
+                            "candidate_value_kind": candidate_field,
+                            "authority": authority["authority"],
+                            "source": authority["source"],
+                            "candidate_point_context": candidate_point_context,
+                            "authority_point_context": authority_point_context,
+                            "same_kinematic_point": unchanged,
+                            "certifying": unchanged,
+                            **comparison,
+                        }
+                        if not unchanged:
+                            comparison_payload.pop("status", None)
+                            comparison_payload["context_only"] = True
+                        comparisons.append(comparison_payload)
+                attempt.update(
+                    {
+                        "status": "evaluated",
+                        "candidate": candidate,
+                        "comparisons": comparisons,
+                    }
+                )
+            except Exception as error:
+                attempt.update(
+                    {
+                        "status": "unavailable",
+                        "error": {
+                            "kind": type(error).__name__,
+                            "message": str(error),
+                        },
+                    }
+                )
+                attempts.append(attempt)
+                continue
+            attempts.append(attempt)
+            internal = candidate["internal_agreement"]
+            if (
+                not complete_ladder
+                and precision == 32
+                and isinstance(internal, Mapping)
+                and internal.get("status") == ResultStatus.OK.value
+                and comparisons
+                and all(
+                    comparison.get("status") == ResultStatus.OK.value
+                    for comparison in comparisons
+                )
+            ):
+                break
+        return result
+    except Exception as error:
+        return _unavailable_precision_diagnostic(error)
+
+
+def attach_validation_failure_precision_diagnostic(
+    cell: CellSpec,
+    measurement: dict[str, object],
+    *,
+    baseline: Mapping[str, object] | None,
+    peers: Mapping[str, Mapping[str, object]] | None = None,
+) -> None:
+    """Add the same bounded diagnostic after late direct-agreement failures."""
+
+    validation = measurement.get("validation")
+    if (
+        measurement.get("status") != ResultStatus.VALIDATION_FAILED.value
+        or not _precision_diagnostic_enabled(cell)
+        or not isinstance(validation, Mapping)
+        or "precision_diagnostic" in validation
+    ):
+        return
+    mutable_validation = dict(validation)
+    try:
+        artifact = measurement.get("artifact")
+        if not isinstance(artifact, Mapping):
+            raise RunnerError("failed measurement has no generated artifact")
+        path = artifact.get("path")
+        process_id = artifact.get("process_id")
+        if not isinstance(path, str) or not isinstance(process_id, str):
+            raise RunnerError("failed measurement artifact is not loadable")
+        runtime = _load_runtime(
+            Path(path).expanduser().resolve(strict=False), process_id
+        )
+        points = shared_validation_points(cell.process)
+        raw_contract = measurement.get("selector_contract")
+        contract = (
+            None
+            if raw_contract is None
+            else SelectorContract.from_mapping(raw_contract)
+        )
+        diagnostic = _validation_failure_precision_diagnostic(
+            runtime,
+            points,
+            cell=cell,
+            contract=contract,
+            baseline=baseline,
+            peers=peers,
+            measurement_context=measurement,
+        )
+    except Exception as error:
+        diagnostic = _unavailable_precision_diagnostic(error)
+    mutable_validation["precision_diagnostic"] = diagnostic
+    measurement["validation"] = mutable_validation
+
+
+def _require_nonzero_lc_all_flow_baseline(
+    cell: CellSpec,
+    baseline: Mapping[str, object] | None,
+) -> None:
+    """Reject inherited selector contracts that authenticate only a zero lane."""
+
+    if (
+        baseline is None
+        or cell.measurement.accuracy is not Accuracy.LC
+        or cell.workload is not Workload.ALL_FLOW
+    ):
+        return
+    validation = baseline.get("validation")
+    common = (
+        validation.get(LC_COMMON_COMPONENT_FIELD)
+        if isinstance(validation, Mapping)
+        else None
+    )
+    value = common.get("value") if isinstance(common, Mapping) else None
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(float(value))
+        or float(value) <= 0.0
+    ):
+        raise RunnerError(
+            "LC all-flow baseline selector is structural zero; remeasure the "
+            "baseline with a nonzero fixed-helicity selector before generating "
+            "a dependent candidate"
+        )
+
+
+def generated_artifact_from_measurement(
+    measurement: Mapping[str, object],
+) -> GeneratedArtifact:
+    if measurement.get("status") != ResultStatus.OK.value:
+        raise RunnerError("only a successful measurement can provide an artifact")
+    artifact = measurement.get("artifact")
+    provenance = measurement.get("provenance")
+    generation_seconds = measurement.get("generation_seconds")
+    if (
+        not isinstance(artifact, Mapping)
+        or not isinstance(provenance, Mapping)
+        or isinstance(generation_seconds, bool)
+        or not isinstance(generation_seconds, (int, float))
+    ):
+        raise RunnerError("measurement does not contain reusable artifact metadata")
+    path = artifact.get("path")
+    process_id = artifact.get("process_id")
+    requested = provenance.get("requested_config")
+    effective = provenance.get("effective_config")
+    preparation_seconds = provenance.get("model_preparation_seconds", 0.0)
+    preparation_reused = provenance.get("model_preparation_reused", True)
+    generation_command_path = provenance.get("generation_command_path")
+    numerical_relation_correctness = provenance.get("numerical_relation_correctness")
+    numerical_relation_fallback = provenance.get("numerical_relation_fallback")
+    if (
+        not isinstance(path, str)
+        or not isinstance(process_id, str)
+        or not isinstance(requested, Mapping)
+        or not isinstance(effective, Mapping)
+        or isinstance(preparation_seconds, bool)
+        or not isinstance(preparation_seconds, (int, float))
+        or not isinstance(preparation_reused, bool)
+        or (
+            generation_command_path is not None
+            and not isinstance(generation_command_path, str)
+        )
+        or (
+            numerical_relation_correctness is not None
+            and not isinstance(numerical_relation_correctness, Mapping)
+        )
+        or (
+            numerical_relation_fallback is not None
+            and not isinstance(numerical_relation_fallback, Mapping)
+        )
+    ):
+        raise RunnerError("measurement reusable artifact metadata is malformed")
+    artifact_path = Path(path).expanduser().resolve(strict=False)
+    if not artifact_path.is_dir():
+        raise RunnerError(f"reusable artifact directory is missing: {artifact_path}")
+    return GeneratedArtifact(
+        path=artifact_path,
+        process_id=process_id,
+        generation_seconds=float(generation_seconds),
+        model_preparation_seconds=float(preparation_seconds),
+        model_preparation_reused=preparation_reused,
+        requested_config=dict(requested),
+        effective_config=dict(effective),
+        generation_command_path=generation_command_path,
+        numerical_relation_correctness=(
+            None
+            if numerical_relation_correctness is None
+            else dict(numerical_relation_correctness)
+        ),
+        numerical_relation_fallback=(
+            None
+            if numerical_relation_fallback is None
+            else dict(numerical_relation_fallback)
+        ),
+    )
+
+
+def _reuse_artifact_for_measurement(
+    artifact: GeneratedArtifact,
+    *,
+    phase_reporter: WorkerPhaseReporter | None,
+) -> GeneratedArtifact:
+    """Close the local generation phase when no generation work is needed."""
+
+    if phase_reporter is not None:
+        # The inherited generation_seconds remains the cost of producing the
+        # reusable artifact.  This empty local interval only gives the current
+        # supervised worker an authenticated terminal phase state.
+        with phase_reporter.generation():
+            pass
+    return artifact
+
+
+def _pointwise_tolerance(cell: CellSpec) -> float:
+    if cell.dataset_id.startswith("matrix_recurrence_") or cell.dataset_id.startswith(
+        "z_"
+    ):
+        return INDEPENDENT_RELATIVE_TOLERANCE
+    return RELATIVE_TOLERANCE
+
+
+def _stable_runtime_identity(
+    identity: Mapping[str, object],
+) -> dict[str, object]:
+    """Remove only the growing loaded-module observation inventory."""
+
+    stable = dict(identity)
+    raw_policy = stable.get("loaded_module_origin_policy")
+    if isinstance(raw_policy, Mapping):
+        policy = dict(raw_policy)
+        for field in (
+            "observed_module_count",
+            "observations",
+            "observations_sha256",
+        ):
+            policy.pop(field, None)
+        stable["loaded_module_origin_policy"] = policy
+    return stable
+
+
+def _runtime_identity_digest(identity: Mapping[str, object]) -> str:
+    return hashlib.sha256(
+        json.dumps(
+            identity,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+
+
+def _comparison_source_digest(value: object) -> str:
+    return hashlib.sha256(
+        json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+
+
+def _conditioned_binding(
+    cell: CellSpec,
+    points: object,
+    contract: SelectorContract | None,
+    *,
+    candidate_source_sha256: str,
+    baseline_source_sha256: str,
+    value_kind: str,
+) -> dict[str, object]:
+    selector_identity = {
+        "cell_id": cell.cell_id,
+        "accuracy": cell.measurement.accuracy.value,
+        "workload": cell.workload.value,
+        "selector_contract": None if contract is None else contract.as_dict(),
+        "value_kind": value_kind,
+    }
+    return {
+        "point_digest": point_digest(points),
+        "selector_component_identity": selector_identity,
+        "selector_component_sha256": _comparison_source_digest(selector_identity),
+        "candidate_source_sha256": candidate_source_sha256,
+        "baseline_source_sha256": baseline_source_sha256,
+    }
+
+
+def _validate_runtime_identity_postflight(
+    initial: Mapping[str, object],
+    postflight: Mapping[str, object],
+) -> None:
+    if _stable_runtime_identity(initial) != _stable_runtime_identity(postflight):
+        raise RunnerError(
+            "candidate runtime identity changed during report measurement"
+        )
+    initial_policy = initial.get("loaded_module_origin_policy")
+    postflight_policy = postflight.get("loaded_module_origin_policy")
+    if not isinstance(initial_policy, Mapping) or not isinstance(
+        postflight_policy,
+        Mapping,
+    ):
+        raise RunnerError("report runtime has no loaded-module origin evidence")
+    initial_observations = initial_policy.get("observations")
+    postflight_observations = postflight_policy.get("observations")
+    if not isinstance(initial_observations, list) or not isinstance(
+        postflight_observations,
+        list,
+    ):
+        raise RunnerError("report runtime loaded-module evidence is incomplete")
+    postflight_keys = {
+        json.dumps(
+            observation,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        for observation in postflight_observations
+    }
+    if any(
+        json.dumps(
+            observation,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        not in postflight_keys
+        for observation in initial_observations
+    ):
+        raise RunnerError("report runtime lost an authenticated loaded-module origin")
+
+
+def _load_runtime(artifact_path: Path, process_id: str) -> object:
+    from pyamplicol.api import Runtime
+
+    return Runtime.load(artifact_path, process=process_id)
+
+
+def _requires_high_precision_validation(
+    cell: CellSpec,
+    *,
+    baseline: Mapping[str, object] | None,
+    selected_authority_cell_id: str | None,
+    catalog: ReportCatalog,
+) -> tuple[bool, bool]:
+    """Return the p32 requirement and whether ``baseline`` is legacy-only.
+
+    A successful original-AmpliCol diagnostic must not suppress pyAmpliCol's
+    own p16-versus-p32 certification now that the legacy evaluator is no
+    longer a numerical authority.
+    """
+
+    baseline_cell = catalog.validation_baseline_cell(cell)
+    baseline_is_legacy_amplicol = (
+        baseline is not None
+        and selected_authority_cell_id is None
+        and baseline_cell is not None
+        and baseline_cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+    )
+    scalar = cell.measurement.model in {
+        ModelKey.SCALAR_CONTACT,
+        ModelKey.SCALAR_GRAVITY,
+    }
+    required = scalar or (
+        (baseline is None or baseline_is_legacy_amplicol)
+        and cell.measurement.execution_mode
+        in {
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.COMPILED,
+            ExecutionMode.EAGER,
+        }
+    )
+    return required, baseline_is_legacy_amplicol
+
+
+def _load_on_the_fly_recurrence_authority(
+    cell: CellSpec,
+    *,
+    baseline: Mapping[str, object] | None,
+    catalog: ReportCatalog,
+) -> tuple[CellSpec, object]:
+    """Load the already measured recurrence authority without generating work."""
+
+    if (
+        cell.measurement.execution_mode is not ExecutionMode.ON_THE_FLY
+        or cell.measurement.accuracy is not Accuracy.LC
+    ):
+        raise RunnerError("recurrence authority requires an on-the-fly LC cell")
+    recurrence_cell = catalog.validation_baseline_cell(cell)
+    if (
+        recurrence_cell is None
+        or recurrence_cell.measurement.execution_mode is not ExecutionMode.RECURRENCE
+        or baseline is None
+    ):
+        raise RunnerError("on-the-fly measurement requires its recurrence baseline")
+    artifact = generated_artifact_from_measurement(baseline)
+    validate_artifact_contract(recurrence_cell, artifact.path)
+    return (
+        recurrence_cell,
+        _load_runtime(artifact.path, artifact.process_id),
+    )
+
+
+def _resolution_benchmark_config(effective_config: Mapping[str, object]) -> object:
+    from pyamplicol.config import Action
+    from pyamplicol.config.resolver import resolve_config
+
+    return resolve_config(
+        effective_config,
+        action=Action.GENERATE,
+        base_dir=Path.cwd(),
+    ).effective.benchmark
+
+
+def measure_pyamplicol_cell(
+    cell: CellSpec,
+    *,
+    artifact_path: Path,
+    settings: RunnerSettings,
+    repo_root: Path,
+    baseline: Mapping[str, object] | None,
+    expected_authority_cell_ids: Sequence[str] = (),
+    selected_authority_cell_id: str | None = None,
+    validation_peers: Mapping[str, Mapping[str, object]] | None = None,
+    selector_provider: Mapping[str, object] | None = None,
+    prepared_model_path: Path | None = None,
+    reused_artifact: GeneratedArtifact | None = None,
+    phase_reporter: WorkerPhaseReporter | None = None,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> dict[str, object]:
+    """Generate or retime one complete-coverage pyAmpliCol artifact."""
+
+    canonical_authority_ids = tuple(
+        authority.cell_id
+        for authority in independent_numerical_authorities(cell, catalog=catalog)
+    )
+    authority_ids = tuple(expected_authority_cell_ids)
+    if authority_ids != canonical_authority_ids:
+        raise RunnerError(
+            "expected numerical authorities differ from the canonical catalog chain"
+        )
+    if selected_authority_cell_id is not None and (
+        selected_authority_cell_id not in authority_ids or baseline is None
+    ):
+        raise RunnerError("selected numerical authority is invalid")
+    if authority_ids and (baseline is not None) != (
+        selected_authority_cell_id is not None
+    ):
+        raise RunnerError(
+            "compiled/eager baseline and selected numerical authority differ"
+        )
+
+    _require_nonzero_lc_all_flow_baseline(cell, baseline)
+    contract = _measurement_selector_contract(cell, baseline, selector_provider)
+    if (
+        cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+        and cell.measurement.accuracy is Accuracy.LC
+        and contract is None
+    ):
+        raise RunnerError(
+            "on-the-fly measurement requires an inherited recurrence selector contract"
+        )
+    generated = (
+        generate_artifact(
+            cell,
+            artifact_path,
+            settings=settings,
+            repo_root=repo_root,
+            prepared_model_path=prepared_model_path,
+            phase_reporter=phase_reporter,
+        )
+        if reused_artifact is None
+        else _reuse_artifact_for_measurement(
+            reused_artifact,
+            phase_reporter=phase_reporter,
+        )
+    )
+    validate_artifact_contract(cell, generated.path)
+    runtime_load_started = time.perf_counter()
+    runtime = _load_runtime(generated.path, generated.process_id)
+    runtime_load_seconds = time.perf_counter() - runtime_load_started
+    revision = settings.source_revision_override or source_revision(
+        repo_root,
+        require_clean=True,
+    )
+    runtime_identity = runtime_identity_payload(
+        cell,
+        runtime,
+        generated.path,
+        generated.process_id,
+        expected_source_revision=revision,
+    )
+    runtime_identity_sha256 = _runtime_identity_digest(runtime_identity)
+    points = (
+        runtime_validation_points(runtime)
+        if cell.measurement.model in {ModelKey.SCALAR_CONTACT, ModelKey.SCALAR_GRAVITY}
+        else shared_validation_points(cell.process)
+    )
+    if cell.measurement.accuracy is Accuracy.LC and contract is None:
+        from .runner import derive_selector_contract
+
+        contract = derive_selector_contract(runtime, points)
+    otf_recurrence_authority: dict[str, object] | None = None
+    if (
+        cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+        and cell.measurement.accuracy is Accuracy.LC
+    ):
+        assert contract is not None
+        recurrence_authority = _load_on_the_fly_recurrence_authority(
+            cell,
+            baseline=baseline,
+            catalog=catalog,
+        )
+        try:
+            otf_recurrence_authority = on_the_fly_recurrence_authority_validation(
+                runtime,
+                points,
+                cell=cell,
+                selector_contract=contract,
+                authority=recurrence_authority,
+            )
+        finally:
+            # Keep public candidate timing free of the loaded recurrence peer.
+            del recurrence_authority
+    if phase_reporter is not None:
+        phase_reporter.profiling_started()
+    profiling_deadlines = tuple(
+        deadline
+        for deadline in (
+            settings.worker_deadline_monotonic,
+            (
+                None
+                if settings.profiling_time_limit_seconds is None
+                else time.monotonic() + settings.profiling_time_limit_seconds
+            ),
+        )
+        if deadline is not None
+    )
+    profile = profile_runtime(
+        runtime,
+        points,
+        cell=cell,
+        benchmark_config=_resolution_benchmark_config(generated.effective_config),
+        selector_contract=contract,
+        progress=settings.progress,
+        profiling_deadline_monotonic=(
+            min(profiling_deadlines) if profiling_deadlines else None
+        ),
+    )
+    execution_timing = profile.pop("execution_timing")
+    evaluator_total_timing = profile.pop("evaluator_total_timing", None)
+    arena_profile_evidence = profile.pop("arena_profile_evidence")
+    benchmark_evidence = profile.pop("benchmark_evidence")
+    if phase_reporter is not None:
+        phase_reporter.validation_started()
+    resolved_sum = profile.pop("resolved_sum_validation")
+    validation: dict[str, object] = {
+        "resolved_sum": resolved_sum,
+        DIRECT_AGREEMENT_FIELD: [],
+        **(
+            {OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD: otf_recurrence_authority}
+            if otf_recurrence_authority is not None
+            else {}
+        ),
+    }
+    if cell.measurement.accuracy is Accuracy.LC:
+        assert contract is not None
+        validation[LC_COMMON_COMPONENT_FIELD] = evaluate_lc_common_component(
+            runtime,
+            points,
+            cell=cell,
+            contract=contract,
+        )
+    authority_expected = requires_independent_numerical_authority(
+        cell,
+        catalog=catalog,
+    )
+    diagnostic_without_authority = (
+        authority_expected and selected_authority_cell_id is None
+    )
+    requires_high_precision, baseline_is_legacy_amplicol = (
+        _requires_high_precision_validation(
+            cell,
+            baseline=baseline,
+            selected_authority_cell_id=selected_authority_cell_id,
+            catalog=catalog,
+        )
+    )
+    if requires_high_precision:
+        high_precision_resolved = resolved_sum_validation(
+            runtime,
+            points,
+            cell=cell,
+            selector_contract=contract,
+            precision=32,
+        )
+        high_precision_records = high_precision_resolved.get("points")
+        candidate_records = resolved_sum.get("points")
+        if (
+            not isinstance(high_precision_records, list)
+            or len(high_precision_records) != 1
+            or not isinstance(candidate_records, list)
+            or len(candidate_records) != 1
+            or not isinstance(high_precision_records[0], Mapping)
+            or not isinstance(candidate_records[0], Mapping)
+        ):
+            raise RunnerError("high-precision validation requires one resolved point")
+        high_record = high_precision_records[0]
+        candidate_record = candidate_records[0]
+        high_precision_value = float(high_record["candidate"])
+        candidate_source = resolved_sum.get("resolved_source_sha256")
+        baseline_source = high_precision_resolved.get("resolved_source_sha256")
+        if not isinstance(candidate_source, str) or not isinstance(
+            baseline_source, str
+        ):
+            raise RunnerError("high-precision resolved source binding is unavailable")
+        validation["high_precision_resolved_sum"] = high_precision_resolved
+        validation["high_precision"] = pointwise_validation(
+            float(profile["matrix_element"]),
+            high_precision_value,
+            candidate_scale=float(candidate_record["candidate_scale"]),
+            baseline_scale=float(high_record["candidate_scale"]),
+            candidate_scale_source="resolved-component-l1-binary64",
+            baseline_scale_source="resolved-component-l1-p32",
+            comparison_binding=_conditioned_binding(
+                cell,
+                points,
+                contract,
+                candidate_source_sha256=candidate_source,
+                baseline_source_sha256=baseline_source,
+                value_kind="matrix-element-p16-versus-p32",
+            ),
+        )
+    madgraph_edges = tuple(
+        edge
+        for edge in incoming_agreement_edges(cell, catalog=catalog)
+        if edge.kind == MADGRAPH_FULL_COLOUR
+    )
+    if madgraph_edges:
+        if len(madgraph_edges) != 1:
+            raise RunnerError("candidate has ambiguous MadGraph authority edges")
+        edge = madgraph_edges[0]
+        peers = {} if validation_peers is None else validation_peers
+        madgraph_peer = peers.get(edge.baseline.cell_id)
+        if madgraph_peer is None:
+            raise RunnerError("required MadGraph authority measurement is unavailable")
+        comparison_precision = madgraph_candidate_precision(cell)
+        values = runtime.evaluate(  # type: ignore[attr-defined]
+            points,
+            precision=comparison_precision,
+            **_selector_kwargs(cell, contract),
+        )
+        if len(values) != 1:
+            raise RunnerError(
+                "MadGraph comparison requires exactly one "
+                f"p{comparison_precision} value"
+            )
+        validation[MADGRAPH_COMPARISON_FIELD] = madgraph_comparison_record(
+            edge,
+            candidate=_real_nonnegative(values[0]),
+            baseline_measurement=madgraph_peer,
+            point_identity=point_digest(points),
+        )
+    _attach_baseline_validation(
+        cell,
+        validation,
+        candidate_matrix_element=float(profile["matrix_element"]),
+        baseline=baseline,
+        points=points,
+        contract=contract,
+    )
+    authority_failure: dict[str, str] | None = None
+    if authority_expected:
+        if selected_authority_cell_id is None:
+            validation[INDEPENDENT_AUTHORITY_FIELD] = _independent_authority_record(
+                authority_ids,
+                selected_cell_id=None,
+                status="unavailable",
+                reason="no-successful-independent-authority",
+            )
+        else:
+            assert baseline is not None
+            candidate_view = {
+                "matrix_element": float(profile["matrix_element"]),
+                "selector_contract": None if contract is None else contract.as_dict(),
+                "validation": validation,
+            }
+            try:
+                comparison = conditioned_measurement_comparison(
+                    cell,
+                    candidate_view,
+                    baseline,
+                )
+            except Exception as error:
+                validation[INDEPENDENT_AUTHORITY_FIELD] = _independent_authority_record(
+                    authority_ids,
+                    selected_cell_id=selected_authority_cell_id,
+                    status="incompatible",
+                    reason=("successful-independent-authority-contract-incompatible"),
+                )
+                validation["authority_contract_error"] = {
+                    "kind": type(error).__name__,
+                    "message": str(error),
+                }
+                authority_failure = {
+                    "kind": "IndependentAuthorityContractError",
+                    "message": str(error),
+                }
+            else:
+                validation["pointwise"] = comparison
+                passed = comparison.get("status") == ResultStatus.OK.value
+                validation[INDEPENDENT_AUTHORITY_FIELD] = _independent_authority_record(
+                    authority_ids,
+                    selected_cell_id=selected_authority_cell_id,
+                    status="verified" if passed else "mismatch",
+                    reason=(
+                        "independent-authority-agreement"
+                        if passed
+                        else "independent-authority-mismatch"
+                    ),
+                )
+                if not passed:
+                    authority_failure = {
+                        "kind": "IndependentAuthorityMismatch",
+                        "message": (
+                            "candidate disagrees with independent numerical authority"
+                        ),
+                    }
+    legacy_baseline = (
+        baseline_is_legacy_amplicol
+        and baseline is not None
+        and baseline.get("status") == ResultStatus.OK.value
+    )
+    statuses = {
+        str(record.get("status"))
+        for field, record in validation.items()
+        if isinstance(record, Mapping)
+        and not (legacy_baseline and field == "pointwise")
+    }
+    internal_failure = ResultStatus.VALIDATION_FAILED.value in statuses
+    validation["status"] = (
+        ResultStatus.VALIDATION_FAILED.value
+        if internal_failure or authority_failure is not None
+        else (
+            ResultStatus.UNVERIFIED.value
+            if diagnostic_without_authority
+            else ResultStatus.OK.value
+        )
+    )
+    if (
+        validation["status"] == ResultStatus.VALIDATION_FAILED.value
+        and _precision_diagnostic_enabled(cell)
+    ) or validation["status"] == ResultStatus.UNVERIFIED.value:
+        validation["precision_diagnostic"] = _validation_failure_precision_diagnostic(
+            runtime,
+            points,
+            cell=cell,
+            contract=contract,
+            baseline=baseline,
+            peers=validation_peers,
+            measurement_context={
+                "wall_seconds_per_point": profile.get("wall_seconds_per_point"),
+                "provenance": {
+                    "execution_timing": execution_timing,
+                    "evaluator_total_timing": evaluator_total_timing,
+                },
+            },
+            complete_ladder=(validation["status"] == ResultStatus.UNVERIFIED.value),
+        )
+    status = str(profile["status"])
+    if validation["status"] == ResultStatus.VALIDATION_FAILED.value:
+        status = ResultStatus.VALIDATION_FAILED.value
+    elif validation["status"] == ResultStatus.UNVERIFIED.value:
+        status = ResultStatus.UNVERIFIED.value
+    runtime_identity_postflight = runtime_identity_payload(
+        cell,
+        runtime,
+        generated.path,
+        generated.process_id,
+        expected_source_revision=revision,
+    )
+    _validate_runtime_identity_postflight(
+        runtime_identity,
+        runtime_identity_postflight,
+    )
+    runtime_identity_stable_sha256 = _runtime_identity_digest(
+        _stable_runtime_identity(runtime_identity)
+    )
+    runtime_identity_postflight_stable_sha256 = _runtime_identity_digest(
+        _stable_runtime_identity(runtime_identity_postflight)
+    )
+    postflight_origin_policy = runtime_identity_postflight.get(
+        "loaded_module_origin_policy"
+    )
+    if not isinstance(postflight_origin_policy, Mapping):
+        raise RunnerError(
+            "report runtime postflight has no loaded-module origin evidence"
+        )
+
+    measurement = empty_measurement()
+    measurement.update(profile)
+    measurement.update(
+        {
+            "status": status,
+            "generation_seconds": generated.generation_seconds,
+            "artifact": {
+                "path": str(generated.path),
+                "process_id": generated.process_id,
+                "policy": "reused" if reused_artifact is not None else "generated",
+            },
+            "selector_contract": None if contract is None else contract.as_dict(),
+            "validation": validation,
+            "resources": None,
+            "provenance": {
+                **provenance_payload(),
+                "source_revision": revision,
+                "requested_config": dict(generated.requested_config),
+                "effective_config": dict(generated.effective_config),
+                "model_preparation_seconds": generated.model_preparation_seconds,
+                "model_preparation_reused": generated.model_preparation_reused,
+                "generation_timer_excludes_model_preparation": True,
+                "generation_command_path": generated.generation_command_path,
+                "runtime_load_seconds": runtime_load_seconds,
+                "runtime_load_included_in_cold_warmup": False,
+                **(
+                    {
+                        "numerical_relation_correctness": dict(
+                            generated.numerical_relation_correctness
+                        )
+                    }
+                    if generated.numerical_relation_correctness is not None
+                    else {}
+                ),
+                **(
+                    {
+                        "numerical_relation_fallback": dict(
+                            generated.numerical_relation_fallback
+                        )
+                    }
+                    if generated.numerical_relation_fallback is not None
+                    else {}
+                ),
+                "report_momenta": _reproduction_momenta(points),
+                "runtime_profile": benchmark_evidence,
+                "execution_timing": execution_timing,
+                **(
+                    {"evaluator_total_timing": evaluator_total_timing}
+                    if evaluator_total_timing is not None
+                    else {}
+                ),
+                "arena_profile_evidence": arena_profile_evidence,
+                "runtime_identity": runtime_identity,
+                "runtime_identity_sha256": runtime_identity_sha256,
+                "runtime_identity_stable_sha256": (runtime_identity_stable_sha256),
+                "runtime_identity_postflight_stable_sha256": (
+                    runtime_identity_postflight_stable_sha256
+                ),
+                "runtime_identity_postflight_loaded_module_origin_policy": dict(
+                    postflight_origin_policy
+                ),
+                "runtime_identity_postflight_match": True,
+            },
+            "failure": None,
+        }
+    )
+    if status == ResultStatus.UNVERIFIED.value:
+        measurement["failure"] = {
+            "kind": "IndependentAuthorityUnavailable",
+            "message": "no successful independent numerical authority is available",
+        }
+    elif status != ResultStatus.OK.value:
+        measurement["failure"] = authority_failure or {
+            "kind": "MeasurementValidationError",
+            "message": "candidate or same-artifact numerical validation failed",
+        }
+    return measurement
+
+
+def failure_measurement(
+    status: ResultStatus,
+    error: BaseException | str,
+    *,
+    resources: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    if status in {ResultStatus.NOT_AVAILABLE, ResultStatus.OK}:
+        raise ValueError("failure measurement requires a terminal failure status")
+    message = str(error)
+    failure = empty_measurement()
+    failure.update(
+        {
+            "status": status.value,
+            "resources": None if resources is None else dict(resources),
+            "failure": {
+                "kind": (
+                    type(error).__name__ if isinstance(error, BaseException) else None
+                ),
+                "message": message,
+            },
+        }
+    )
+    return failure
+
+
+def _validate_portable_current_result_path(
+    path: Path,
+    paths: ReportPaths,
+) -> Path:
+    root_input = paths.artifact_root.expanduser()
+    root_lexical = Path(os.path.abspath(root_input))
+    try:
+        root = root_input.resolve(strict=True)
+    except OSError as error:
+        raise ValueError("portable current artifact root is unavailable") from error
+    if root_input.is_symlink() or root != root_lexical or not root.is_dir():
+        raise ValueError("portable current artifact root is not canonical")
+
+    source_input = path.expanduser()
+    source_lexical = Path(os.path.abspath(source_input))
+    try:
+        source = source_input.resolve(strict=True)
+    except OSError as error:
+        raise ValueError("portable current result file is unavailable") from error
+    if source_input.is_symlink() or source != source_lexical or not source.is_file():
+        raise ValueError("portable current result path is not canonical")
+    try:
+        relative = source.relative_to(root)
+    except ValueError as error:
+        raise ValueError(
+            "portable current result is outside the artifact root"
+        ) from error
+    parts = relative.parts
+    if (
+        len(parts) != 5
+        or parts[0] != "cells"
+        or not parts[1]
+        or parts[2] != "attempts"
+        or parts[4] != "result.json"
+    ):
+        raise ValueError("portable current result path has an unsupported shape")
+    try:
+        attempt_id = str(uuid.UUID(parts[3]))
+    except (AttributeError, ValueError) as error:
+        raise ValueError("portable current result attempt ID is invalid") from error
+    if attempt_id != parts[3]:
+        raise ValueError("portable current result attempt ID is not canonical")
+    return source
+
+
+def load_measurement(
+    path: Path,
+    *,
+    publication_paths: ReportPaths | None = None,
+) -> dict[str, object]:
+    source = (
+        path
+        if publication_paths is None
+        else _validate_portable_current_result_path(path, publication_paths)
+    )
+    payload = json.loads(source.read_text(encoding="utf-8"))
+    if not isinstance(payload, Mapping):
+        raise ValueError("measurement file must contain an object")
+    if publication_paths is not None:
+        from .publication import materialize_current_value
+
+        payload = materialize_current_value(payload, publication_paths)
+        if not isinstance(payload, Mapping):  # pragma: no cover - parsed object above.
+            raise ValueError("portable measurement did not materialize as an object")
+    return dict(payload)
+
+
+__all__ = [
+    "attach_validation_failure_precision_diagnostic",
+    "baseline_uses_lc_common_component_authority",
+    "conditioned_measurement_comparison",
+    "failure_measurement",
+    "file_digest",
+    "generated_artifact_from_measurement",
+    "load_measurement",
+    "measure_pyamplicol_cell",
+    "reconcile_independent_authority",
+    "shared_validation_points",
+    "source_revision",
+]
diff --git a/pyamplicol/tools/performance_report/measurement_lineage.py b/pyamplicol/tools/performance_report/measurement_lineage.py
new file mode 100644
index 0000000000..df9537151c
--- /dev/null
+++ b/pyamplicol/tools/performance_report/measurement_lineage.py
@@ -0,0 +1,4914 @@
+# SPDX-License-Identifier: 0BSD
+"""Fail-closed executable-source lineage for architecture report profiles.
+
+The ordinary report contract deliberately accepts measurements from one exact
+source revision only.  A Class-C bridge is the narrow exception used when a
+bounded physics correction must replace only the directly affected cells in a
+frozen architecture campaign.  It never rewrites measurement provenance:
+every retained ancestor current is authorized by its immutable attempt and
+manifest digest.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import re
+import subprocess
+import uuid
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+from .agreements import incoming_agreement_edges
+from .artifacts import ATTEMPT_SCHEMA, ArtifactStore, CurrentRecord
+from .cache import _validate_runtime_identity_postflight, validate_measurement
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .models import (
+    Accuracy,
+    ArtifactPolicy,
+    CellSpec,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from .runner import (
+    validate_conditioned_comparison_record,
+    validate_resolved_sum_validation_record,
+)
+from .source_identity import require_eligible_report_source
+
+MEASUREMENT_LINEAGE_SCHEMA = "pyamplicol-performance-measurement-lineage-v2"
+MEASUREMENT_LINEAGE_WRAPPER_SCHEMA = (
+    "pyamplicol-performance-measurement-lineage-envelope-v1"
+)
+MEASUREMENT_LINEAGE_FILENAME = "measurement_lineage.json"
+CLASS_C_HZZ_IMPACT = "hzz-orientation-v1"
+CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT = "recurrence-summary-cap-v1"
+_CLASS_C_IMPACTS = frozenset(
+    {
+        CLASS_C_HZZ_IMPACT,
+        CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+    }
+)
+
+_SHA256_RE = re.compile(r"[0-9a-f]{64}")
+_GIT_SHA_RE = re.compile(r"[0-9a-f]{40,64}")
+_ATTEMPT_KEYS = {
+    "schema",
+    "cell_id",
+    "attempt_id",
+    "status",
+    "artifact_policy",
+    "based_on",
+    "result_path",
+    "artifacts",
+    "error",
+}
+_PROFILE_ROOT = PurePosixPath("docs/performance_reports")
+_HZZ_CONTRACT_IDS = frozenset(
+    {
+        "pyamplicol.models.builtin.model.BuiltinSMModel:18",
+        "pyamplicol.models.builtin.model.BuiltinSMModel:19",
+    }
+)
+
+# The executable descendant is deliberately specific.  Any additional path
+# requires a reviewed source change to this allowlist and therefore cannot be
+# smuggled into a bridge manifest at run time.
+_HZZ_ALLOWED_PATHS = frozenset(
+    {
+        "src/pyamplicol/models/builtin/lowering.py",
+        "src/pyamplicol/assets/prepared_models/"
+        "built-in-sm-jit-o2-aarch64.pyamplicol-model",
+        "src/pyamplicol/assets/prepared_models/"
+        "built-in-sm-jit-o2-aarch64.metadata.json",
+        "src/pyamplicol/assets/prepared_models/"
+        "built-in-sm-jit-o2-x86_64.pyamplicol-model",
+        "src/pyamplicol/assets/prepared_models/"
+        "built-in-sm-jit-o2-x86_64.metadata.json",
+        "release_assets/prepared_models/"
+        "built-in-sm-jit-o2-aarch64.pyamplicol-model",
+        "release_assets/prepared_models/"
+        "built-in-sm-jit-o2-aarch64.metadata.json",
+        "release_assets/prepared_models/"
+        "built-in-sm-jit-o2-x86_64.pyamplicol-model",
+        "release_assets/prepared_models/"
+        "built-in-sm-jit-o2-x86_64.metadata.json",
+        "tools/performance_report/measurement_lineage.py",
+        "tools/performance_report/source_identity.py",
+        "tools/performance_report/workspace.py",
+        "tools/performance_report/cli.py",
+        "tools/performance_report/scheduler.py",
+        "tools/performance_report/service.py",
+        "tools/performance_report/render.py",
+        "tools/performance_report/validation_summary.py",
+        "tools/performance_report/campaign_policy.py",
+        "tools/performance_report/final_audit.py",
+        "docs/arxiv/result_tables.py",
+        "docs/performance_reports/macbook_M3/result_tables.py",
+        "docs/performance_reports/x86_EPYC/result_tables.py",
+        "docs/performance_reports/macbook_M3/TABLE_FILLING.md",
+        "docs/performance_reports/x86_EPYC/TABLE_FILLING.md",
+        "tests/unit/test_performance_report_measurement_lineage.py",
+        "tests/unit/test_performance_report_measurement_lineage_adversarial.py",
+        "tests/unit/test_performance_report_source_identity.py",
+        "tests/unit/test_performance_report_workspace.py",
+        "tests/unit/test_performance_report_cli.py",
+        "tests/unit/test_three_mode_report_scheduler.py",
+        "tests/unit/test_three_mode_report_service.py",
+        "tests/unit/test_three_mode_report_render.py",
+        "tests/unit/test_performance_report_campaign_policy.py",
+        "tests/unit/test_performance_report_final_audit.py",
+        "tests/unit/test_model_builtin.py",
+        "tests/unit/test_packaged_prepared_model.py",
+        "tests/unit/test_recurrence_catalog_builder.py",
+    }
+)
+
+_HZZ_REQUIRED_FEATURE_PATHS = frozenset(
+    {
+        "src/pyamplicol/models/builtin/lowering.py",
+        "src/pyamplicol/assets/prepared_models/"
+        "built-in-sm-jit-o2-aarch64.pyamplicol-model",
+        "src/pyamplicol/assets/prepared_models/"
+        "built-in-sm-jit-o2-aarch64.metadata.json",
+        "src/pyamplicol/assets/prepared_models/"
+        "built-in-sm-jit-o2-x86_64.pyamplicol-model",
+        "src/pyamplicol/assets/prepared_models/"
+        "built-in-sm-jit-o2-x86_64.metadata.json",
+        "release_assets/prepared_models/"
+        "built-in-sm-jit-o2-aarch64.pyamplicol-model",
+        "release_assets/prepared_models/"
+        "built-in-sm-jit-o2-aarch64.metadata.json",
+        "release_assets/prepared_models/"
+        "built-in-sm-jit-o2-x86_64.pyamplicol-model",
+        "release_assets/prepared_models/"
+        "built-in-sm-jit-o2-x86_64.metadata.json",
+        "tests/unit/test_model_builtin.py",
+        "tests/unit/test_packaged_prepared_model.py",
+        "tests/unit/test_recurrence_catalog_builder.py",
+    }
+)
+
+_RECURRENCE_SUMMARY_CAP_REPORT_FILES = (
+    "pyAmpliCol.tex",
+    "result_matrix_best_builtin_sm_full_table.tex",
+    "result_matrix_best_builtin_sm_lc_table.tex",
+    "result_matrix_best_builtin_sm_nlc_table.tex",
+    "result_matrix_compiled_builtin_sm_full_table.tex",
+    "result_matrix_compiled_builtin_sm_lc_table.tex",
+    "result_matrix_compiled_builtin_sm_nlc_table.tex",
+    "result_matrix_eager_builtin_sm_full_table.tex",
+    "result_matrix_eager_builtin_sm_lc_table.tex",
+    "result_matrix_eager_builtin_sm_nlc_table.tex",
+    "result_matrix_recurrence_builtin_sm_full_table.tex",
+    "result_matrix_recurrence_builtin_sm_lc_table.tex",
+    "result_matrix_recurrence_builtin_sm_nlc_table.tex",
+    "result_matrix_recurrence_ufo_sm_full_table.tex",
+    "result_matrix_recurrence_ufo_sm_lc_table.tex",
+    "result_matrix_recurrence_ufo_sm_nlc_table.tex",
+    "result_scalar_contact_table.tex",
+    "result_scalar_gravity_table.tex",
+    "result_tables.py",
+    "result_z_builtin_sm_table.tex",
+    "result_z_external_sm_table.tex",
+    "section_three_mode_performance_tables.tex",
+)
+_RECURRENCE_SUMMARY_CAP_ALLOWED_PATHS = (
+    frozenset(
+        {
+            "docs/performance_reports/macbook_M3/TABLE_FILLING.md",
+            "docs/performance_reports/x86_EPYC/TABLE_FILLING.md",
+            "rust/crates/rusticol-core/src/engine/recurrence_manifest.rs",
+            "src/pyamplicol/generation/artifact_writer.py",
+            "tests/unit/test_performance_report_artifacts.py",
+            "tests/unit/test_performance_report_cli.py",
+            "tests/unit/test_performance_report_measurement_lineage.py",
+            "tests/unit/test_performance_report_measurement_lineage_adversarial.py",
+            "tests/unit/test_performance_report_publisher.py",
+            "tests/unit/test_recurrence_direct_artifact_metadata.py",
+            "tests/unit/test_three_mode_report_legacy.py",
+            "tests/unit/test_three_mode_report_render.py",
+            "tests/unit/test_three_mode_report_scheduler.py",
+            "tools/performance_report/artifacts.py",
+            "tools/performance_report/campaign_policy.py",
+            "tools/performance_report/cli.py",
+            "tools/performance_report/legacy.py",
+            "tools/performance_report/measurement_lineage.py",
+            "tools/performance_report/publisher.py",
+            "tools/performance_report/render.py",
+            "tools/performance_report/scheduler.py",
+            "tools/performance_report/workspace.py",
+        }
+    )
+    | frozenset(
+        f"{root}/{filename}"
+        for root in (
+            "docs/arxiv",
+            "docs/performance_reports/macbook_M3",
+            "docs/performance_reports/x86_EPYC",
+        )
+        for filename in _RECURRENCE_SUMMARY_CAP_REPORT_FILES
+    )
+)
+_RECURRENCE_SUMMARY_CAP_REQUIRED_PATHS = _RECURRENCE_SUMMARY_CAP_ALLOWED_PATHS
+
+_RECURRENCE_SUMMARY_CAP_PREDECESSOR_REVISION = (
+    "6536ef131e18e7ff873eb1f4db1f08631155f3a9"
+)
+_RECURRENCE_SUMMARY_CAP_ANCESTOR_REVISION = (
+    "be11d8304fdc04893dc0e23e9619be848126e3bc"
+)
+_RECURRENCE_SUMMARY_CAP_DESCENDANT_REVISION = (
+    "2594d8b520b802f71d60bd646f73ebaa5547927a"
+)
+_RECURRENCE_SUMMARY_CAP_ANCESTOR_NATIVE_INPUTS_SHA256 = (
+    "23b9637d5d3fba0947d78cf688df18799b0c9ee5b3bcbfa6a2963a1f1a21f870"
+)
+_RECURRENCE_SUMMARY_CAP_DESCENDANT_NATIVE_INPUTS_SHA256 = (
+    "96e1ff79a007aaf67a0900dd6d67327ee00f6bd2cca002589b879aa3a734de08"
+)
+_PRE_ARBITRARY_QUARK_LINES_AGREEMENT_GRAPH_SHA256 = (
+    "7b7e641dd22964ca9feb486519859e0f9dc956b44c7fc9da35bd765531ab7154"
+)
+_ARBITRARY_QUARK_LINES_AGREEMENT_GRAPH_SHA256 = (
+    "49ed0246dedc3efa42dbbf6a7197d82306251118e19e6fea7d0dce1b02c8388c"
+)
+_RECURRENCE_SUMMARY_CAP_PROFILE = "x86_EPYC"
+_RECURRENCE_SUMMARY_CAP_FAILURE_BYTES = {
+    "matrix-recurrence-builtin-sm-lc-n7-gg-gluons-selected-flow": 4_270_140,
+    "matrix-recurrence-builtin-sm-lc-n8-dd-tt-jets-selected-flow": 1_083_926,
+    "matrix-recurrence-builtin-sm-lc-n9-dd-z-jets-selected-flow": 4_449_888,
+    "matrix-recurrence-builtin-sm-lc-n9-ud-w-jets-selected-flow": 4_449_912,
+}
+_RECURRENCE_SUMMARY_CAP_AGREEMENT_IDS = frozenset(
+    {
+        "matrix-recurrence-builtin-sm-lc-n7-gg-gluons-all-flow",
+        "matrix-recurrence-builtin-sm-lc-n8-dd-tt-jets-all-flow",
+        "matrix-recurrence-builtin-sm-lc-n9-dd-z-jets-all-flow",
+        "matrix-recurrence-builtin-sm-lc-n9-ud-w-jets-all-flow",
+        "matrix-recurrence-ufo-sm-lc-n7-gg-gluons-all-flow",
+        "matrix-recurrence-ufo-sm-lc-n7-gg-gluons-selected-flow",
+        "matrix-recurrence-ufo-sm-lc-n8-dd-tt-jets-all-flow",
+        "matrix-recurrence-ufo-sm-lc-n8-dd-tt-jets-selected-flow",
+        "matrix-recurrence-ufo-sm-lc-n9-dd-z-jets-all-flow",
+        "matrix-recurrence-ufo-sm-lc-n9-dd-z-jets-selected-flow",
+        "matrix-recurrence-ufo-sm-lc-n9-ud-w-jets-all-flow",
+        "matrix-recurrence-ufo-sm-lc-n9-ud-w-jets-selected-flow",
+    }
+)
+_SIGNED_ZERO_HELICITY_REFERENCE_IDS = frozenset(
+    {
+        f"reference-amplicol-lc-n{n_final}-{process}-{workload}"
+        for n_final in range(4, 8)
+        for process in ("dd-epemzh-jets", "dd-ttzh-jets")
+        for workload in ("selected-flow", "all-flow")
+    }
+)
+_SIGNED_ZERO_HELICITY_SELECTED_RECURRENCE_IDS = frozenset(
+    {
+        f"matrix-recurrence-builtin-sm-lc-n{n_final}-{process}-selected-flow"
+        for n_final in range(4, 8)
+        for process in ("dd-epemzh-jets", "dd-ttzh-jets")
+    }
+)
+_SIGNED_ZERO_HELICITY_IMPACTED_IDS = (
+    _SIGNED_ZERO_HELICITY_REFERENCE_IDS
+    | _SIGNED_ZERO_HELICITY_SELECTED_RECURRENCE_IDS
+)
+_SIGNED_ZERO_HELICITY_AGREEMENT_IDS = frozenset(
+    {
+        f"matrix-recurrence-{model}-lc-n{n_final}-{process}-{workload}"
+        for model in ("builtin-sm", "ufo-sm")
+        for n_final in range(4, 8)
+        for process in ("dd-epemzh-jets", "dd-ttzh-jets")
+        for workload in (
+            ("all-flow",)
+            if model == "builtin-sm"
+            else ("selected-flow", "all-flow")
+        )
+    }
+) | frozenset(
+    {
+        f"matrix-{mode}-builtin-sm-lc-n{n_final}-{process}-all-flow"
+        for mode in ("compiled", "eager")
+        for n_final in range(4, 8)
+        for process in ("dd-epemzh-jets", "dd-ttzh-jets")
+    }
+) | frozenset(
+    {
+        f"matrix-on-the-fly-builtin-sm-lc-n4-{process}-all-flow"
+        for process in ("dd-epemzh-jets", "dd-ttzh-jets")
+    }
+)
+
+_ENVIRONMENT_KEYS = {
+    "schema",
+    "profile",
+    "status",
+    "source_revision",
+    "platform",
+    "machine",
+    "processor",
+    "python",
+    "python_implementation",
+    "pyamplicol",
+    "numpy",
+    "native_target",
+    "native_cpu_features",
+    "native_build_inputs_sha256",
+    "native_extension_sha256",
+    "python_package_tree_sha256",
+    "candidate_fingerprint",
+}
+
+# A fresh native relink is authenticated by its exact build-input digest,
+# candidate fingerprint, target, and CPU feature set.  The raw extension digest
+# is intentionally recorded in each endpoint environment but is not invariant:
+# Mach-O UUIDs, temporary build paths, and signatures make that output
+# byte-nondeterministic even when every native input is unchanged.
+_ENVIRONMENT_INVARIANT_FIELDS = (
+    "schema",
+    "profile",
+    "platform",
+    "machine",
+    "processor",
+    "python",
+    "python_implementation",
+    "status",
+    "pyamplicol",
+    "numpy",
+    "native_target",
+    "native_cpu_features",
+    "native_build_inputs_sha256",
+    "candidate_fingerprint",
+)
+
+_CURRENT_PIN_KEYS = {
+    "cell_id",
+    "attempt_id",
+    "manifest_sha256",
+    "current_locator",
+    "current_pointer_sha256",
+    "source_revision",
+    "source_tree",
+    "result_sha256",
+}
+
+_REACHABILITY_RECORD_KEYS = {
+    "cell_id",
+    "attempt_id",
+    "manifest_sha256",
+    "artifact_locator",
+    "artifact_owner",
+    "process_id",
+    "execution_manifest_path",
+    "execution_manifest_sha256",
+    "schedule_path",
+    "schedule_sha256",
+    "schedule_index_sha256",
+    "schedule_member_sha256",
+    "process_binding_path",
+    "process_binding_sha256",
+    "kernel_pack_path",
+    "kernel_pack_sha256",
+    "semantic_catalog_sha256",
+    "direct_catalog_sha256",
+    "active_executor_ids",
+    "matched_template_ids",
+    "matched_contract_ids",
+}
+
+_SUMMARY_CAP_FAILURE_RECORD_KEYS = {
+    "cell_id",
+    "attempt_id",
+    "manifest_sha256",
+    "result_locator",
+    "result_sha256",
+    "summary_bytes",
+    "failure_kind",
+    "failure_message",
+}
+_SUMMARY_CAP_EXCLUDED_RECORD_KEYS = {
+    "cell_id",
+    "attempt_id",
+    "manifest_sha256",
+    "result_locator",
+    "result_sha256",
+    "current_locator",
+    "current_pointer_sha256",
+    "status",
+    "failure_sha256",
+}
+_SUMMARY_CAP_PREDECESSOR_KEYS = {
+    "payload_sha256",
+    "profile",
+    "impact",
+    "ancestor_revision",
+    "ancestor_tree",
+    "descendant_revision",
+    "descendant_tree",
+    "ancestor_environment",
+    "ancestor_environment_sha256",
+    "descendant_environment_sha256",
+    "retained_currents",
+    "retained_currents_sha256",
+}
+
+_ARTIFACT_OWNER_KEYS = {
+    "relation",
+    "artifact_locator",
+    "consumer_cell_id",
+    "consumer_attempt_id",
+    "consumer_manifest_locator",
+    "consumer_manifest_sha256",
+    "consumer_result_locator",
+    "consumer_result_sha256",
+    "consumer_source_revision",
+    "consumer_source_tree",
+    "consumer_runtime_identity_sha256",
+    "consumer_runtime_identity_stable_sha256",
+    "owner_cell_id",
+    "owner_attempt_id",
+    "owner_current_locator",
+    "owner_current_sha256",
+    "owner_manifest_locator",
+    "owner_manifest_sha256",
+    "owner_result_locator",
+    "owner_result_sha256",
+    "owner_artifacts_sha256",
+    "owner_source_revision",
+    "owner_source_tree",
+    "owner_runtime_identity_sha256",
+    "owner_runtime_identity_stable_sha256",
+}
+
+_ATTEMPT_INVENTORY_KEYS = {
+    "cell_id",
+    "attempt_id",
+    "manifest_locator",
+    "manifest_sha256",
+    "status",
+    "error_sha256",
+    "result_path",
+    "result_sha256",
+    "artifact_count",
+    "artifacts_sha256",
+}
+
+_PAYLOAD_KEYS = {
+    "schema",
+    "state",
+    "class",
+    "impact",
+    "profile",
+    "ancestor_revision",
+    "ancestor_tree",
+    "descendant_revision",
+    "descendant_tree",
+    "git_diff",
+    "git_diff_sha256",
+    "ancestor_environment",
+    "ancestor_environment_sha256",
+    "descendant_environment",
+    "descendant_environment_sha256",
+    "runtime_invariant_fields",
+    "impacted_cells",
+    "agreement_closure_cells",
+    "impact_certificate_sha256",
+    "catalog_sha256",
+    "agreement_graph_sha256",
+    "workspace_manifest",
+    "workspace_manifest_sha256",
+    "campaign_policy_sha256",
+    "reachability_certificate",
+    "reachability_certificate_sha256",
+    "retained_currents",
+    "invalidated_currents",
+    "recompare_currents",
+    "attempt_inventory",
+    "no_attempt_cells",
+    "current_snapshot_sha256",
+}
+
+_CANONICAL_CATALOG_SHA256: str | None = None
+_CANONICAL_AGREEMENT_SHA256: str | None = None
+
+
+class MeasurementLineageError(RuntimeError):
+    """A Class-C measurement-lineage record is absent or inconsistent."""
+
+
+def _canonical_bytes(value: object) -> bytes:
+    try:
+        encoded = json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+    except (TypeError, ValueError) as error:
+        raise MeasurementLineageError(
+            f"measurement lineage is not canonical JSON: {error}"
+        ) from error
+    return f"{encoded}\n".encode("ascii")
+
+
+def _digest(value: object) -> str:
+    return hashlib.sha256(_canonical_bytes(value)).hexdigest()
+
+
+def _file_digest(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _reject_duplicate_pairs(
+    pairs: list[tuple[str, object]],
+) -> dict[str, object]:
+    value: dict[str, object] = {}
+    for key, item in pairs:
+        if key in value:
+            raise MeasurementLineageError(
+                f"measurement-lineage JSON contains duplicate key {key!r}"
+            )
+        value[key] = item
+    return value
+
+
+def _read_canonical_json(path: Path, *, context: str) -> dict[str, object]:
+    if path.is_symlink() or not path.is_file():
+        raise MeasurementLineageError(f"{context} is not a regular file: {path}")
+    try:
+        data = path.read_bytes()
+        raw = json.loads(
+            data.decode("ascii"),
+            object_pairs_hook=_reject_duplicate_pairs,
+        )
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise MeasurementLineageError(
+            f"cannot read {context} {path}: {error}"
+        ) from error
+    if not isinstance(raw, dict) or data != _canonical_bytes(raw):
+        raise MeasurementLineageError(
+            f"{context} has no valid canonical digest/JSON encoding: {path}"
+        )
+    return raw
+
+
+def _write_envelope(path: Path, payload: Mapping[str, object]) -> None:
+    envelope = {
+        "schema": MEASUREMENT_LINEAGE_WRAPPER_SCHEMA,
+        "payload": dict(payload),
+        "payload_sha256": _digest(payload),
+    }
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{uuid.uuid4().hex}")
+    try:
+        with temporary.open("xb") as stream:
+            stream.write(_canonical_bytes(envelope))
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _atomic_write_bytes(path: Path, data: bytes) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{uuid.uuid4().hex}")
+    try:
+        with temporary.open("xb") as stream:
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _restore_file(path: Path, previous: bytes | None) -> None:
+    if previous is None:
+        path.unlink(missing_ok=True)
+    else:
+        _atomic_write_bytes(path, previous)
+
+
+def _safe_locator(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and bool(value)
+        and not Path(value).is_absolute()
+        and all(
+            part not in {"", ".", ".."}
+            for part in Path(value).parts
+        )
+    )
+
+
+def _validate_artifact_owner(
+    record: Mapping[str, object],
+) -> None:
+    raw = record.get("artifact_owner")
+    if not isinstance(raw, Mapping) or set(raw) != _ARTIFACT_OWNER_KEYS:
+        raise MeasurementLineageError(
+            "measurement-lineage recurrence artifact-owner record is malformed"
+        )
+    relation = raw.get("relation")
+    try:
+        consumer_attempt = (
+            str(uuid.UUID(str(raw["consumer_attempt_id"])))
+            if isinstance(raw.get("consumer_attempt_id"), str)
+            else None
+        )
+        owner_attempt = (
+            str(uuid.UUID(str(raw["owner_attempt_id"])))
+            if isinstance(raw.get("owner_attempt_id"), str)
+            else None
+        )
+    except ValueError:
+        consumer_attempt = None
+        owner_attempt = None
+    consumer_cell = raw.get("consumer_cell_id")
+    owner_cell = raw.get("owner_cell_id")
+    locators = (
+        raw.get("artifact_locator"),
+        raw.get("consumer_manifest_locator"),
+        raw.get("consumer_result_locator"),
+        raw.get("owner_manifest_locator"),
+        raw.get("owner_result_locator"),
+    )
+    digests = (
+        "consumer_manifest_sha256",
+        "consumer_result_sha256",
+        "consumer_runtime_identity_sha256",
+        "consumer_runtime_identity_stable_sha256",
+        "owner_manifest_sha256",
+        "owner_result_sha256",
+        "owner_artifacts_sha256",
+        "owner_runtime_identity_sha256",
+        "owner_runtime_identity_stable_sha256",
+    )
+    revisions = (
+        "consumer_source_revision",
+        "consumer_source_tree",
+        "owner_source_revision",
+        "owner_source_tree",
+    )
+    if (
+        relation not in {"consumer-attempt", "equivalent-matrix-peer"}
+        or not isinstance(consumer_cell, str)
+        or not consumer_cell
+        or not isinstance(owner_cell, str)
+        or not owner_cell
+        or consumer_attempt != raw.get("consumer_attempt_id")
+        or owner_attempt != raw.get("owner_attempt_id")
+        or consumer_cell != record.get("cell_id")
+        or consumer_attempt != record.get("attempt_id")
+        or raw.get("consumer_manifest_sha256")
+        != record.get("manifest_sha256")
+        or raw.get("artifact_locator") != record.get("artifact_locator")
+        or not all(_safe_locator(value) for value in locators)
+        or any(
+            not isinstance(raw.get(field), str)
+            or _SHA256_RE.fullmatch(str(raw[field])) is None
+            for field in digests
+        )
+        or any(
+            not isinstance(raw.get(field), str)
+            or _GIT_SHA_RE.fullmatch(str(raw[field])) is None
+            for field in revisions
+        )
+        or raw.get("consumer_source_revision")
+        != raw.get("owner_source_revision")
+        or raw.get("consumer_source_tree") != raw.get("owner_source_tree")
+        or raw.get("consumer_runtime_identity_stable_sha256")
+        != raw.get("owner_runtime_identity_stable_sha256")
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage recurrence artifact-owner identity is invalid"
+        )
+
+    consumer_manifest = PurePosixPath(str(raw["consumer_manifest_locator"]))
+    consumer_result = PurePosixPath(str(raw["consumer_result_locator"]))
+    owner_manifest = PurePosixPath(str(raw["owner_manifest_locator"]))
+    owner_result = PurePosixPath(str(raw["owner_result_locator"]))
+    artifact = PurePosixPath(str(raw["artifact_locator"]))
+    owner_current = raw.get("owner_current_locator")
+    owner_current_sha256 = raw.get("owner_current_sha256")
+    if (
+        not consumer_manifest.as_posix().endswith(
+            f"/attempts/{consumer_attempt}/manifest.json"
+        )
+        or consumer_result.parent != consumer_manifest.parent
+        or not owner_manifest.as_posix().endswith(
+            f"/attempts/{owner_attempt}/manifest.json"
+        )
+        or owner_result.parent != owner_manifest.parent
+        or artifact != owner_manifest.parent / "artifact"
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage recurrence artifact-owner locators are inconsistent"
+        )
+    if relation == "consumer-attempt":
+        if (
+            owner_cell != consumer_cell
+            or owner_attempt != consumer_attempt
+            or owner_current is not None
+            or owner_current_sha256 is not None
+            or owner_manifest != consumer_manifest
+            or owner_result != consumer_result
+            or raw.get("owner_manifest_sha256")
+            != raw.get("consumer_manifest_sha256")
+            or raw.get("owner_result_sha256")
+            != raw.get("consumer_result_sha256")
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage direct artifact owner is inconsistent"
+            )
+    elif (
+        owner_cell == consumer_cell
+        or not _safe_locator(owner_current)
+        or not str(owner_current).endswith("/current.json")
+        or not isinstance(owner_current_sha256, str)
+        or _SHA256_RE.fullmatch(owner_current_sha256) is None
+        or PurePosixPath(str(owner_current))
+        != owner_manifest.parents[2] / "current.json"
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage matrix-peer artifact owner is inconsistent"
+        )
+
+
+def _summary_cap_failure_message(summary_bytes: int) -> str:
+    return (
+        "Rust recurrence execution summary must be smaller than 1 MiB; "
+        f"received {summary_bytes} bytes"
+    )
+
+
+def _validate_summary_cap_predecessor(
+    predecessor: object,
+) -> None:
+    if (
+        not isinstance(predecessor, Mapping)
+        or set(predecessor) != _SUMMARY_CAP_PREDECESSOR_KEYS
+        or predecessor.get("impact") != CLASS_C_HZZ_IMPACT
+        or predecessor.get("profile") != _RECURRENCE_SUMMARY_CAP_PROFILE
+        or predecessor.get("ancestor_revision")
+        != _RECURRENCE_SUMMARY_CAP_PREDECESSOR_REVISION
+        or predecessor.get("descendant_revision")
+        != _RECURRENCE_SUMMARY_CAP_ANCESTOR_REVISION
+        or not isinstance(predecessor.get("payload_sha256"), str)
+        or _SHA256_RE.fullmatch(str(predecessor["payload_sha256"])) is None
+        or any(
+            not isinstance(predecessor.get(field), str)
+            or _GIT_SHA_RE.fullmatch(str(predecessor[field])) is None
+            for field in (
+                "ancestor_revision",
+                "ancestor_tree",
+                "descendant_revision",
+                "descendant_tree",
+            )
+        )
+        or not isinstance(predecessor.get("ancestor_environment"), Mapping)
+        or set(predecessor["ancestor_environment"]) != _ENVIRONMENT_KEYS
+        or predecessor.get("ancestor_environment_sha256")
+        != _digest(predecessor["ancestor_environment"])
+        or not isinstance(
+            predecessor.get("descendant_environment_sha256"),
+            str,
+        )
+        or _SHA256_RE.fullmatch(
+            str(predecessor["descendant_environment_sha256"])
+        )
+        is None
+        or not isinstance(predecessor.get("retained_currents"), list)
+        or predecessor.get("retained_currents_sha256")
+        != _digest(predecessor["retained_currents"])
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage summary-cap predecessor is malformed"
+        )
+    retained = _validated_pins(predecessor, "retained_currents")
+    if any(
+        pin["source_revision"] != predecessor["ancestor_revision"]
+        or pin["source_tree"] != predecessor["ancestor_tree"]
+        for pin in retained
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage summary-cap predecessor pins another source"
+        )
+
+
+def _validate_summary_cap_certificate(
+    certificate: Mapping[str, object],
+) -> None:
+    expected_ids = sorted(_RECURRENCE_SUMMARY_CAP_FAILURE_BYTES)
+    records = certificate.get("records")
+    excluded = certificate.get("excluded_non_success_currents")
+    predecessor = certificate.get("predecessor")
+    invalidated = certificate.get("invalidated_generation_error_current_ids")
+    inspected = certificate.get("inspected_current_count")
+    successful = certificate.get("successful_current_count")
+    excluded_count = certificate.get("excluded_non_success_current_count")
+    if (
+        set(certificate)
+        != {
+            "algorithm",
+            "predecessor",
+            "target_summary_bytes",
+            "inspected_current_count",
+            "successful_current_count",
+            "excluded_non_success_current_count",
+            "records",
+            "excluded_non_success_currents",
+            "invalidated_generation_error_current_ids",
+            "sha256",
+        }
+        or certificate.get("algorithm")
+        != "authenticated-recurrence-summary-cap-failure-census-v1"
+        or certificate.get("target_summary_bytes")
+        != _RECURRENCE_SUMMARY_CAP_FAILURE_BYTES
+        or not isinstance(inspected, int)
+        or isinstance(inspected, bool)
+        or not isinstance(successful, int)
+        or isinstance(successful, bool)
+        or not isinstance(excluded_count, int)
+        or isinstance(excluded_count, bool)
+        or inspected != successful + excluded_count + len(expected_ids)
+        or successful < 0
+        or excluded_count < 0
+        or not isinstance(records, list)
+        or not isinstance(excluded, list)
+        or len(excluded) != excluded_count
+        or not isinstance(invalidated, list)
+        or invalidated != expected_ids
+        or len(records) != len(expected_ids)
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage recurrence summary-cap census is malformed"
+        )
+    _validate_summary_cap_predecessor(predecessor)
+    record_ids: list[str] = []
+    for record in records:
+        if (
+            not isinstance(record, dict)
+            or set(record) != _SUMMARY_CAP_FAILURE_RECORD_KEYS
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage recurrence summary-cap record is malformed"
+            )
+        cell_id = record.get("cell_id")
+        attempt_id = record.get("attempt_id")
+        try:
+            canonical_attempt = (
+                str(uuid.UUID(attempt_id))
+                if isinstance(attempt_id, str)
+                else None
+            )
+        except ValueError:
+            canonical_attempt = None
+        result_locator = record.get("result_locator")
+        summary_bytes = (
+            _RECURRENCE_SUMMARY_CAP_FAILURE_BYTES.get(cell_id)
+            if isinstance(cell_id, str)
+            else None
+        )
+        if (
+            summary_bytes is None
+            or canonical_attempt != attempt_id
+            or not _safe_locator(result_locator)
+            or not str(result_locator).endswith(
+                f"/attempts/{attempt_id}/result.json"
+            )
+            or not isinstance(record.get("manifest_sha256"), str)
+            or _SHA256_RE.fullmatch(str(record["manifest_sha256"])) is None
+            or not isinstance(record.get("result_sha256"), str)
+            or _SHA256_RE.fullmatch(str(record["result_sha256"])) is None
+            or record.get("summary_bytes") != summary_bytes
+            or record.get("failure_kind") != "GenerationError"
+            or record.get("failure_message")
+            != _summary_cap_failure_message(summary_bytes)
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage recurrence summary-cap record is invalid"
+            )
+        record_ids.append(cell_id)
+    if record_ids != expected_ids:
+        raise MeasurementLineageError(
+            "measurement-lineage recurrence summary-cap records do not match "
+            "the exact failure census"
+        )
+    excluded_ids: list[str] = []
+    for record in excluded:
+        if (
+            not isinstance(record, dict)
+            or set(record) != _SUMMARY_CAP_EXCLUDED_RECORD_KEYS
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage excluded terminal current is malformed"
+            )
+        cell_id = record.get("cell_id")
+        attempt_id = record.get("attempt_id")
+        try:
+            canonical_attempt = (
+                str(uuid.UUID(attempt_id))
+                if isinstance(attempt_id, str)
+                else None
+            )
+        except ValueError:
+            canonical_attempt = None
+        if (
+            not isinstance(cell_id, str)
+            or not cell_id
+            or cell_id in _RECURRENCE_SUMMARY_CAP_FAILURE_BYTES
+            or canonical_attempt != attempt_id
+            or not _safe_locator(record.get("result_locator"))
+            or not str(record["result_locator"]).endswith(
+                f"/attempts/{attempt_id}/result.json"
+            )
+            or not _safe_locator(record.get("current_locator"))
+            or not str(record["current_locator"]).endswith("/current.json")
+            or record.get("status") == ResultStatus.OK.value
+            or record.get("status")
+            not in {status.value for status in ResultStatus}
+            or any(
+                not isinstance(record.get(field), str)
+                or _SHA256_RE.fullmatch(str(record[field])) is None
+                for field in (
+                    "manifest_sha256",
+                    "result_sha256",
+                    "current_pointer_sha256",
+                    "failure_sha256",
+                )
+            )
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage excluded terminal current is invalid"
+            )
+        excluded_ids.append(cell_id)
+    if excluded_ids != sorted(set(excluded_ids)):
+        raise MeasurementLineageError(
+            "measurement-lineage excluded terminal currents are not a unique census"
+        )
+
+
+def _validate_payload_shape(payload: Mapping[str, object]) -> None:
+    if set(payload) != _PAYLOAD_KEYS:
+        raise MeasurementLineageError(
+            "measurement-lineage payload has an unsupported schema shape"
+        )
+    if (
+        payload.get("schema") != MEASUREMENT_LINEAGE_SCHEMA
+        or payload.get("state") not in {"pending", "finalized"}
+        or payload.get("class") != "C"
+        or payload.get("impact") not in _CLASS_C_IMPACTS
+        or not isinstance(payload.get("profile"), str)
+        or not payload["profile"]
+        or (
+            payload.get("impact")
+            == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+            and (
+                payload.get("profile") != _RECURRENCE_SUMMARY_CAP_PROFILE
+                or payload.get("ancestor_revision")
+                != _RECURRENCE_SUMMARY_CAP_ANCESTOR_REVISION
+                or payload.get("descendant_revision")
+                != _RECURRENCE_SUMMARY_CAP_DESCENDANT_REVISION
+            )
+        )
+        or payload.get("runtime_invariant_fields")
+        != list(_ENVIRONMENT_INVARIANT_FIELDS)
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage class, impact, profile, or invariants are invalid"
+        )
+    for field in (
+        "ancestor_revision",
+        "ancestor_tree",
+        "descendant_revision",
+        "descendant_tree",
+    ):
+        if (
+            not isinstance(payload.get(field), str)
+            or _GIT_SHA_RE.fullmatch(str(payload[field])) is None
+        ):
+            raise MeasurementLineageError(
+                f"measurement-lineage {field} is not a full Git identity"
+            )
+    for field in (
+        "git_diff_sha256",
+        "ancestor_environment_sha256",
+        "impact_certificate_sha256",
+        "catalog_sha256",
+        "agreement_graph_sha256",
+        "workspace_manifest_sha256",
+        "campaign_policy_sha256",
+        "reachability_certificate_sha256",
+        "current_snapshot_sha256",
+    ):
+        if (
+            not isinstance(payload.get(field), str)
+            or _SHA256_RE.fullmatch(str(payload[field])) is None
+        ):
+            raise MeasurementLineageError(
+                f"measurement-lineage {field} is not a SHA-256 digest"
+            )
+    ancestor_environment = payload.get("ancestor_environment")
+    if (
+        not isinstance(ancestor_environment, Mapping)
+        or set(ancestor_environment) != _ENVIRONMENT_KEYS
+        or payload.get("ancestor_environment_sha256")
+        != _digest(ancestor_environment)
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage ancestor environment is invalid"
+        )
+    descendant_environment = payload.get("descendant_environment")
+    descendant_digest = payload.get("descendant_environment_sha256")
+    if payload["state"] == "pending":
+        if descendant_environment is not None or descendant_digest is not None:
+            raise MeasurementLineageError(
+                "pending measurement lineage carries a descendant environment"
+            )
+    elif (
+        not isinstance(descendant_environment, Mapping)
+        or set(descendant_environment) != _ENVIRONMENT_KEYS
+        or not isinstance(descendant_digest, str)
+        or descendant_digest != _digest(descendant_environment)
+    ):
+        raise MeasurementLineageError(
+            "finalized measurement-lineage descendant environment is invalid"
+        )
+    workspace = payload.get("workspace_manifest")
+    if (
+        not isinstance(workspace, Mapping)
+        or set(workspace)
+        != {
+            "path",
+            "mode",
+            "object",
+            "sha256",
+            "campaign_policy_sha256",
+        }
+        or workspace.get("mode") != "100644"
+        or workspace.get("campaign_policy_sha256")
+        != payload.get("campaign_policy_sha256")
+        or payload.get("workspace_manifest_sha256") != _digest(workspace)
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage workspace manifest identity is invalid"
+        )
+    for field in (
+        "git_diff",
+        "impacted_cells",
+        "agreement_closure_cells",
+        "attempt_inventory",
+        "no_attempt_cells",
+        "retained_currents",
+        "invalidated_currents",
+        "recompare_currents",
+    ):
+        if not isinstance(payload.get(field), list):
+            raise MeasurementLineageError(
+                f"measurement-lineage {field} must be an array"
+            )
+    no_attempts = payload["no_attempt_cells"]
+    if no_attempts != sorted(set(no_attempts)) or not all(
+        isinstance(value, str) and value for value in no_attempts
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage no-attempt inventory is not sorted and unique"
+        )
+    inventory = payload["attempt_inventory"]
+    inventory_keys: list[tuple[str, str]] = []
+    for raw in inventory:
+        if not isinstance(raw, dict) or set(raw) != _ATTEMPT_INVENTORY_KEYS:
+            raise MeasurementLineageError(
+                "measurement-lineage attempt inventory row is malformed"
+            )
+        cell_id = raw.get("cell_id")
+        attempt_id = raw.get("attempt_id")
+        try:
+            canonical_attempt_id = (
+                str(uuid.UUID(attempt_id))
+                if isinstance(attempt_id, str)
+                else None
+            )
+        except ValueError:
+            canonical_attempt_id = None
+        locator = raw.get("manifest_locator")
+        result_path = raw.get("result_path")
+        status = raw.get("status")
+        if (
+            not isinstance(cell_id, str)
+            or not cell_id
+            or canonical_attempt_id != attempt_id
+            or not isinstance(locator, str)
+            or Path(locator).is_absolute()
+            or any(part in {"", ".", ".."} for part in Path(locator).parts)
+            or not locator.endswith(f"/attempts/{attempt_id}/manifest.json")
+            or status not in {"ok", "failed", "interrupted"}
+            or (
+                status == "ok"
+                and (
+                    not isinstance(result_path, str)
+                    or not result_path
+                    or Path(result_path).is_absolute()
+                    or any(
+                        part in {"", ".", ".."}
+                        for part in Path(result_path).parts
+                    )
+                )
+            )
+            or (status != "ok" and result_path is not None)
+            or not isinstance(raw.get("manifest_sha256"), str)
+            or _SHA256_RE.fullmatch(str(raw["manifest_sha256"])) is None
+            or not isinstance(raw.get("error_sha256"), str)
+            or _SHA256_RE.fullmatch(str(raw["error_sha256"])) is None
+            or (
+                raw.get("result_sha256") is not None
+                and (
+                    not isinstance(raw.get("result_sha256"), str)
+                    or _SHA256_RE.fullmatch(str(raw["result_sha256"])) is None
+                )
+            )
+            or isinstance(raw.get("artifact_count"), bool)
+            or not isinstance(raw.get("artifact_count"), int)
+            or int(raw["artifact_count"]) < 0
+            or not isinstance(raw.get("artifacts_sha256"), str)
+            or _SHA256_RE.fullmatch(str(raw["artifacts_sha256"])) is None
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage attempt inventory identity is invalid"
+            )
+        inventory_keys.append((cell_id, attempt_id))
+    if inventory_keys != sorted(set(inventory_keys)):
+        raise MeasurementLineageError(
+            "measurement-lineage attempt inventory is not sorted and unique"
+        )
+    reachability = payload.get("reachability_certificate")
+    if (
+        not isinstance(reachability, Mapping)
+        or not isinstance(reachability.get("sha256"), str)
+        or reachability.get("sha256")
+        != _digest(
+            {
+                key: value
+                for key, value in reachability.items()
+                if key != "sha256"
+            }
+        )
+        or payload.get("reachability_certificate_sha256")
+        != _digest(reachability)
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage recurrence reachability certificate is invalid"
+        )
+    assert isinstance(reachability, Mapping)
+    if payload.get("impact") == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT:
+        _validate_summary_cap_certificate(reachability)
+        return
+    if (
+        reachability.get("algorithm")
+        != "authenticated-recurrence-active-executor-reachability-v1"
+        or reachability.get("target_contract_ids") != sorted(_HZZ_CONTRACT_IDS)
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage recurrence reachability certificate is invalid"
+        )
+    records = reachability.get("records")
+    reached_ids = reachability.get("reached_cell_ids")
+    existing_target_ids = reachability.get("existing_catalog_target_ids")
+    invalidated_failure_ids = reachability.get(
+        "invalidated_validation_failed_current_ids"
+    )
+    if (
+        not isinstance(records, list)
+        or not isinstance(reached_ids, list)
+        or not isinstance(existing_target_ids, list)
+        or not isinstance(invalidated_failure_ids, list)
+        or reachability.get("inspected_current_count") != len(records)
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage recurrence reachability inventory is malformed"
+        )
+    record_ids: list[str] = []
+    derived_reached: list[str] = []
+    for record in records:
+        if not isinstance(record, dict) or set(record) != _REACHABILITY_RECORD_KEYS:
+            raise MeasurementLineageError(
+                "measurement-lineage recurrence reachability record is malformed"
+            )
+        _validate_artifact_owner(record)
+        cell_id = record.get("cell_id")
+        attempt_id = record.get("attempt_id")
+        try:
+            canonical_attempt = (
+                str(uuid.UUID(attempt_id))
+                if isinstance(attempt_id, str)
+                else None
+            )
+        except ValueError:
+            canonical_attempt = None
+        safe_paths = (
+            record.get("artifact_locator"),
+            record.get("execution_manifest_path"),
+            record.get("schedule_path"),
+            record.get("process_binding_path"),
+            record.get("kernel_pack_path"),
+        )
+        digest_fields = (
+            "manifest_sha256",
+            "execution_manifest_sha256",
+            "schedule_sha256",
+            "schedule_index_sha256",
+            "schedule_member_sha256",
+            "process_binding_sha256",
+            "kernel_pack_sha256",
+            "semantic_catalog_sha256",
+            "direct_catalog_sha256",
+        )
+        executor_ids = record.get("active_executor_ids")
+        templates = record.get("matched_template_ids")
+        contracts = record.get("matched_contract_ids")
+        if (
+            not isinstance(cell_id, str)
+            or not cell_id
+            or canonical_attempt != attempt_id
+            or not isinstance(record.get("process_id"), str)
+            or not record["process_id"]
+            or any(
+                not isinstance(value, str)
+                or not value
+                or Path(value).is_absolute()
+                or any(
+                    part in {"", ".", ".."} for part in Path(value).parts
+                )
+                for value in safe_paths
+            )
+            or any(
+                not isinstance(record.get(field), str)
+                or _SHA256_RE.fullmatch(str(record[field])) is None
+                for field in digest_fields
+            )
+            or not isinstance(executor_ids, list)
+            or executor_ids != sorted(set(executor_ids))
+            or any(
+                isinstance(value, bool) or not isinstance(value, int) or value < 0
+                for value in executor_ids
+            )
+            or not isinstance(templates, list)
+            or templates != sorted(set(templates))
+            or any(not isinstance(value, str) or not value for value in templates)
+            or not isinstance(contracts, list)
+            or contracts != sorted(set(contracts))
+            or any(value not in _HZZ_CONTRACT_IDS for value in contracts)
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage recurrence reachability record is invalid"
+            )
+        record_ids.append(cell_id)
+        if contracts:
+            derived_reached.append(cell_id)
+    if (
+        record_ids != sorted(set(record_ids))
+        or reached_ids != sorted(derived_reached)
+        or existing_target_ids != sorted(set(existing_target_ids))
+        or invalidated_failure_ids
+        != sorted(set(invalidated_failure_ids))
+        or any(
+            not isinstance(value, str) or value not in set(record_ids)
+            for value in existing_target_ids
+        )
+        or any(
+            not isinstance(value, str) or not value
+            for value in invalidated_failure_ids
+        )
+        or set(invalidated_failure_ids) & set(record_ids)
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage recurrence reachability sets are inconsistent"
+        )
+
+
+def _load_envelope(path: Path, *, expected_state: str | None = None) -> dict[str, Any]:
+    raw = _read_canonical_json(path, context="measurement-lineage envelope")
+    if (
+        not isinstance(raw, dict)
+        or set(raw) != {"schema", "payload", "payload_sha256"}
+        or raw.get("schema") != MEASUREMENT_LINEAGE_WRAPPER_SCHEMA
+        or not isinstance(raw.get("payload"), dict)
+        or not isinstance(raw.get("payload_sha256"), str)
+        or raw["payload_sha256"] != _digest(raw["payload"])
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage envelope or canonical digest is invalid"
+        )
+    payload = dict(raw["payload"])
+    if payload.get("schema") != MEASUREMENT_LINEAGE_SCHEMA:
+        raise MeasurementLineageError("measurement-lineage schema is incompatible")
+    _validate_payload_shape(payload)
+    if expected_state is not None and payload.get("state") != expected_state:
+        raise MeasurementLineageError(
+            f"measurement lineage is not in state {expected_state!r}"
+        )
+    return payload
+
+
+def _git(
+    repo_root: Path,
+    *arguments: str,
+    check: bool = True,
+) -> subprocess.CompletedProcess[bytes]:
+    try:
+        completed = subprocess.run(
+            ("git", *arguments),
+            cwd=repo_root,
+            check=False,
+            capture_output=True,
+            timeout=30,
+        )
+    except (OSError, subprocess.SubprocessError) as error:
+        raise MeasurementLineageError(f"cannot inspect Git lineage: {error}") from error
+    if check and completed.returncode != 0:
+        detail = completed.stderr.decode("utf-8", errors="replace").strip()
+        raise MeasurementLineageError(
+            f"git {' '.join(arguments)} failed: "
+            f"{detail or f'exit {completed.returncode}'}"
+        )
+    return completed
+
+
+def _git_commit(repo_root: Path, revision: str) -> str:
+    value = (
+        _git(repo_root, "rev-parse", "--verify", f"{revision}^{{commit}}")
+        .stdout.decode("ascii")
+        .strip()
+    )
+    if _GIT_SHA_RE.fullmatch(value) is None:
+        raise MeasurementLineageError("Git returned an invalid commit identity")
+    return value
+
+
+def _git_tree(repo_root: Path, revision: str) -> str:
+    value = (
+        _git(repo_root, "rev-parse", "--verify", f"{revision}^{{tree}}")
+        .stdout.decode("ascii")
+        .strip()
+    )
+    if _GIT_SHA_RE.fullmatch(value) is None:
+        raise MeasurementLineageError("Git returned an invalid tree identity")
+    return value
+
+
+def _tree_member(
+    repo_root: Path,
+    revision: str,
+    path: str,
+) -> dict[str, str] | None:
+    raw = _git(repo_root, "ls-tree", "-z", revision, "--", path).stdout
+    if not raw:
+        return None
+    record = raw.split(b"\0", 1)[0]
+    header, separator, recorded_path = record.partition(b"\t")
+    fields = header.split()
+    if (
+        not separator
+        or os.fsdecode(recorded_path) != path
+        or len(fields) != 3
+        or fields[1] != b"blob"
+    ):
+        raise MeasurementLineageError(f"Git tree metadata is malformed for {path!r}")
+    return {
+        "mode": fields[0].decode("ascii"),
+        "object": fields[2].decode("ascii"),
+    }
+
+
+def _blob_sha256(repo_root: Path, revision: str, path: str) -> str | None:
+    member = _tree_member(repo_root, revision, path)
+    if member is None:
+        return None
+    return hashlib.sha256(
+        _git(repo_root, "show", f"{revision}:{path}").stdout
+    ).hexdigest()
+
+
+def _diff_records(
+    repo_root: Path,
+    *,
+    ancestor: str,
+    descendant: str,
+    impact: str,
+) -> tuple[dict[str, object], ...]:
+    if impact == CLASS_C_HZZ_IMPACT:
+        allowed_paths = _HZZ_ALLOWED_PATHS
+        required_paths = _HZZ_REQUIRED_FEATURE_PATHS
+        impact_label = "HZZ"
+    elif impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT:
+        allowed_paths = _RECURRENCE_SUMMARY_CAP_ALLOWED_PATHS
+        required_paths = _RECURRENCE_SUMMARY_CAP_REQUIRED_PATHS
+        impact_label = "recurrence-summary-cap"
+    else:
+        raise MeasurementLineageError(f"unsupported Class-C impact {impact!r}")
+    ancestry = _git(
+        repo_root,
+        "merge-base",
+        "--is-ancestor",
+        ancestor,
+        descendant,
+        check=False,
+    )
+    if ancestry.returncode != 0:
+        raise MeasurementLineageError(
+            "Class-C descendant is not a direct Git descendant of its ancestor"
+        )
+    tokens = [
+        os.fsdecode(value)
+        for value in _git(
+            repo_root,
+            "diff",
+            "--name-status",
+            "-z",
+            "--no-renames",
+            f"{ancestor}..{descendant}",
+            "--",
+        ).stdout.split(b"\0")
+        if value
+    ]
+    if len(tokens) % 2:
+        raise MeasurementLineageError("Git returned a malformed Class-C diff")
+    records: list[dict[str, object]] = []
+    for offset in range(0, len(tokens), 2):
+        status, path = tokens[offset : offset + 2]
+        if status not in {"A", "M"}:
+            raise MeasurementLineageError(
+                f"Class-C diff contains unsupported status {status!r} for {path!r}"
+            )
+        if path not in allowed_paths:
+            raise MeasurementLineageError(
+                f"Class-C {impact_label} descendant changes disallowed path {path!r}"
+            )
+        old = _tree_member(repo_root, ancestor, path)
+        new = _tree_member(repo_root, descendant, path)
+        if new is None or new["mode"] != "100644":
+            raise MeasurementLineageError(
+                f"Class-C descendant member is not a regular 0644 file: {path!r}"
+            )
+        if old is not None and old["mode"] != "100644":
+            raise MeasurementLineageError(
+                f"Class-C ancestor member is not a regular 0644 file: {path!r}"
+            )
+        records.append(
+            {
+                "status": status,
+                "path": path,
+                "ancestor_blob": None if old is None else old["object"],
+                "ancestor_sha256": _blob_sha256(repo_root, ancestor, path),
+                "descendant_blob": new["object"],
+                "descendant_sha256": _blob_sha256(repo_root, descendant, path),
+                "mode": new["mode"],
+            }
+        )
+    if not records:
+        raise MeasurementLineageError("Class-C descendant has an empty Git diff")
+    changed = {str(record["path"]) for record in records}
+    if not required_paths.issubset(changed):
+        missing = sorted(required_paths - changed)
+        raise MeasurementLineageError(
+            f"{impact_label} Class-C descendant lacks reviewed members: "
+            + ", ".join(missing)
+        )
+    return tuple(records)
+
+
+def _cell_record(
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> dict[str, object]:
+    return {
+        "cell_id": cell.cell_id,
+        "dataset_id": cell.dataset_id,
+        "process": cell.process,
+        "process_key": cell.process_key,
+        "n_final": cell.n_final,
+        "mode": cell.measurement.execution_mode.value,
+        "model": (
+            None if cell.measurement.model is None else cell.measurement.model.value
+        ),
+        "accuracy": cell.measurement.accuracy.value,
+        "backend": cell.measurement.backend,
+        "jit_optimization_level": cell.measurement.jit_optimization_level,
+        "workload": cell.workload.value,
+        "variant": cell.variant,
+        "static_na_reason": catalog.static_na_reason(cell),
+    }
+
+
+def hzz_impacted_cells(
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSpec, ...]:
+    """Return the exact built-in recurrence cells affected by the HZZ fix."""
+
+    cells = tuple(
+        sorted(
+            (
+                cell
+                for cell in catalog.measurement_cells()
+                if (
+                    cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+                    and cell.measurement.model is ModelKey.BUILTIN_SM
+                    and cell.process_key == "dd_zzz_jets"
+                    and cell.n_final >= 3
+                )
+            ),
+            key=lambda item: item.cell_id,
+        )
+    )
+    if catalog is REPORT_CATALOG and len(cells) != 20:
+        raise MeasurementLineageError(
+            f"canonical HZZ impact census changed from 20 to {len(cells)} cells"
+        )
+    return cells
+
+
+def hzz_agreement_closure(
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSpec, ...]:
+    """Return every direct-agreement consumer of an affected HZZ cell."""
+
+    impacted = hzz_impacted_cells(catalog=catalog)
+    impacted_ids = {cell.cell_id for cell in impacted}
+    impacted_keys = {
+        (
+            cell.process,
+            cell.process_key,
+            cell.n_final,
+            cell.measurement.accuracy,
+            cell.workload,
+        )
+        for cell in impacted
+    }
+    peers = tuple(
+        sorted(
+            (
+                cell
+                for cell in catalog.measurement_cells()
+                if (
+                    cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+                    and cell.measurement.model is ModelKey.UFO_SM
+                    and (
+                        cell.process,
+                        cell.process_key,
+                        cell.n_final,
+                        cell.measurement.accuracy,
+                        cell.workload,
+                    )
+                    in impacted_keys
+                    and any(
+                        edge.baseline.cell_id in impacted_ids
+                        for edge in incoming_agreement_edges(
+                            cell,
+                            catalog=catalog,
+                        )
+                    )
+                )
+            ),
+            key=lambda item: item.cell_id,
+        )
+    )
+    if catalog is REPORT_CATALOG and (
+        len(peers) != 20
+        or any(
+            cell.measurement.execution_mode is not ExecutionMode.RECURRENCE
+            or cell.measurement.model is not ModelKey.UFO_SM
+            or cell.process_key != "dd_zzz_jets"
+            for cell in peers
+        )
+    ):
+        raise MeasurementLineageError(
+            "canonical HZZ direct-agreement closure is no longer the 20 UFO "
+            "recurrence peers"
+        )
+    return peers
+
+
+def recurrence_summary_cap_impacted_cells(
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSpec, ...]:
+    """Return the four currents blocked by the old recurrence summary cap."""
+
+    by_id = {cell.cell_id: cell for cell in catalog.measurement_cells()}
+    missing = sorted(set(_RECURRENCE_SUMMARY_CAP_FAILURE_BYTES) - set(by_id))
+    if missing:
+        raise MeasurementLineageError(
+            "recurrence summary-cap targets are absent from the catalog: "
+            + ", ".join(missing)
+        )
+    cells = tuple(
+        by_id[cell_id]
+        for cell_id in sorted(_RECURRENCE_SUMMARY_CAP_FAILURE_BYTES)
+    )
+    if any(
+        cell.measurement.execution_mode is not ExecutionMode.RECURRENCE
+        or cell.measurement.model is not ModelKey.BUILTIN_SM
+        or cell.measurement.accuracy is not Accuracy.LC
+        or cell.workload is not Workload.SELECTED_FLOW
+        for cell in cells
+    ):
+        raise MeasurementLineageError(
+            "recurrence summary-cap target semantics changed in the catalog"
+        )
+    return cells
+
+
+def recurrence_summary_cap_agreement_closure(
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSpec, ...]:
+    """Return the exact-equivalent and dependent peers of the four targets."""
+
+    closure = _agreement_consumer_closure(
+        {
+            cell.cell_id
+            for cell in recurrence_summary_cap_impacted_cells(catalog=catalog)
+        },
+        catalog=catalog,
+    )
+    if catalog is REPORT_CATALOG and {
+        cell.cell_id for cell in closure
+    } != _RECURRENCE_SUMMARY_CAP_AGREEMENT_IDS:
+        raise MeasurementLineageError(
+            "canonical recurrence summary-cap agreement closure changed from "
+            "its reviewed 12-cell census"
+        )
+    return closure
+
+
+def signed_zero_helicity_impacted_cells(
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSpec, ...]:
+    """Return the 24 cells directly blocked by legacy unsigned zero."""
+
+    by_id = {cell.cell_id: cell for cell in catalog.measurement_cells()}
+    missing = sorted(_SIGNED_ZERO_HELICITY_IMPACTED_IDS - set(by_id))
+    if missing:
+        raise MeasurementLineageError(
+            "signed-zero helicity targets are absent from the catalog: "
+            + ", ".join(missing)
+        )
+    cells = tuple(
+        by_id[cell_id]
+        for cell_id in sorted(_SIGNED_ZERO_HELICITY_IMPACTED_IDS)
+    )
+    if any(
+        cell.measurement.accuracy is not Accuracy.LC
+        or cell.workload not in {Workload.SELECTED_FLOW, Workload.ALL_FLOW}
+        or cell.process_key not in {"dd_epemzh_jets", "dd_ttzh_jets"}
+        or cell.n_final not in range(4, 8)
+        or (
+            cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+            and cell.measurement.model is not None
+        )
+        or (
+            cell.measurement.execution_mode is ExecutionMode.RECURRENCE
+            and (
+                cell.measurement.model is not ModelKey.BUILTIN_SM
+                or cell.workload is not Workload.SELECTED_FLOW
+            )
+        )
+        or cell.measurement.execution_mode
+        not in {ExecutionMode.AMPLICOL, ExecutionMode.RECURRENCE}
+        for cell in cells
+    ):
+        raise MeasurementLineageError(
+            "signed-zero helicity target semantics changed in the catalog"
+        )
+    return cells
+
+
+def signed_zero_helicity_agreement_closure(
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSpec, ...]:
+    """Return the exact 42-cell dependent closure of the signed-zero targets."""
+
+    closure = _agreement_consumer_closure(
+        {
+            cell.cell_id
+            for cell in signed_zero_helicity_impacted_cells(catalog=catalog)
+        },
+        catalog=catalog,
+    )
+    if catalog is REPORT_CATALOG and {
+        cell.cell_id for cell in closure
+    } != _SIGNED_ZERO_HELICITY_AGREEMENT_IDS:
+        raise MeasurementLineageError(
+            "canonical signed-zero agreement closure changed from its reviewed "
+            "42-cell census"
+        )
+    return closure
+
+
+def _agreement_consumer_closure(
+    affected_cell_ids: set[str],
+    *,
+    catalog: ReportCatalog,
+) -> tuple[CellSpec, ...]:
+    """Return the transitive incoming-agreement closure of ``affected_cell_ids``."""
+
+    affected = set(affected_cell_ids)
+    consumers: dict[str, CellSpec] = {}
+    changed = True
+    while changed:
+        changed = False
+        for cell in catalog.measurement_cells():
+            if cell.cell_id in affected:
+                continue
+            if any(
+                edge.baseline.cell_id in affected
+                for edge in incoming_agreement_edges(cell, catalog=catalog)
+            ):
+                affected.add(cell.cell_id)
+                consumers[cell.cell_id] = cell
+                changed = True
+    return tuple(
+        sorted(consumers.values(), key=lambda item: item.cell_id)
+    )
+
+
+def _impact_and_agreement_cells(
+    impact: str,
+    reachability: Mapping[str, object],
+    *,
+    catalog: ReportCatalog,
+) -> tuple[tuple[CellSpec, ...], tuple[CellSpec, ...]]:
+    if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT:
+        impacted = {
+            cell.cell_id: cell
+            for cell in (
+                *recurrence_summary_cap_impacted_cells(catalog=catalog),
+                *signed_zero_helicity_impacted_cells(catalog=catalog),
+            )
+        }
+        return (
+            tuple(sorted(impacted.values(), key=lambda item: item.cell_id)),
+            _agreement_consumer_closure(set(impacted), catalog=catalog),
+        )
+    if impact != CLASS_C_HZZ_IMPACT:
+        raise MeasurementLineageError(f"unsupported Class-C impact {impact!r}")
+    by_id = {cell.cell_id: cell for cell in catalog.measurement_cells()}
+    raw_reached = reachability.get("reached_cell_ids")
+    if not isinstance(raw_reached, list) or any(
+        not isinstance(value, str) or value not in by_id for value in raw_reached
+    ):
+        raise MeasurementLineageError(
+            "reachability certificate has unknown reached cells"
+        )
+    affected_by_id = {
+        cell.cell_id: cell for cell in hzz_impacted_cells(catalog=catalog)
+    }
+    affected_by_id.update({cell_id: by_id[cell_id] for cell_id in raw_reached})
+    affected = tuple(
+        sorted(affected_by_id.values(), key=lambda item: item.cell_id)
+    )
+    closure = _agreement_consumer_closure(
+        set(affected_by_id),
+        catalog=catalog,
+    )
+    return affected, closure
+
+
+def _catalog_digest(catalog: ReportCatalog) -> str:
+    global _CANONICAL_CATALOG_SHA256
+    if catalog is REPORT_CATALOG and _CANONICAL_CATALOG_SHA256 is not None:
+        return _CANONICAL_CATALOG_SHA256
+    result = _digest(
+        [
+            _cell_record(cell, catalog=catalog)
+            for cell in catalog.measurement_cells()
+        ]
+    )
+    if catalog is REPORT_CATALOG:
+        _CANONICAL_CATALOG_SHA256 = result
+    return result
+
+
+def _agreement_digest(catalog: ReportCatalog) -> str:
+    global _CANONICAL_AGREEMENT_SHA256
+    if catalog is REPORT_CATALOG and _CANONICAL_AGREEMENT_SHA256 is not None:
+        return _CANONICAL_AGREEMENT_SHA256
+    edges: list[dict[str, str]] = []
+    for cell in catalog.measurement_cells():
+        for edge in incoming_agreement_edges(cell, catalog=catalog):
+            edges.append(
+                {
+                    "candidate": cell.cell_id,
+                    "baseline": edge.baseline.cell_id,
+                    "kind": edge.kind,
+                }
+            )
+    result = _digest(sorted(edges, key=lambda item: tuple(item.values())))
+    if catalog is REPORT_CATALOG:
+        _CANONICAL_AGREEMENT_SHA256 = result
+    return result
+
+
+def _agreement_graph_digest_matches(
+    payload: Mapping[str, object],
+    active_digest: str,
+) -> bool:
+    """Authenticate the one controller-era agreement-graph transition.
+
+    Arbitrary-quark-line report support removed obsolete original-AmpliCol
+    dependency edges for process #14 without changing either frozen bridge's
+    measurement cells or physics closure.  Pending/finalized certificates from
+    before that controller-only correction retain their original graph digest.
+    Both digests and both exact EPYC lineages are pinned; every other graph
+    change remains fatal.
+    """
+
+    stored_digest = payload.get("agreement_graph_sha256")
+    if stored_digest == active_digest:
+        return True
+    if (
+        payload.get("profile") != _RECURRENCE_SUMMARY_CAP_PROFILE
+        or stored_digest
+        != _PRE_ARBITRARY_QUARK_LINES_AGREEMENT_GRAPH_SHA256
+        or active_digest != _ARBITRARY_QUARK_LINES_AGREEMENT_GRAPH_SHA256
+    ):
+        return False
+    identity = (
+        payload.get("impact"),
+        payload.get("ancestor_revision"),
+        payload.get("descendant_revision"),
+    )
+    return identity in {
+        (
+            CLASS_C_HZZ_IMPACT,
+            _RECURRENCE_SUMMARY_CAP_PREDECESSOR_REVISION,
+            _RECURRENCE_SUMMARY_CAP_ANCESTOR_REVISION,
+        ),
+        (
+            CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT,
+            _RECURRENCE_SUMMARY_CAP_ANCESTOR_REVISION,
+            _RECURRENCE_SUMMARY_CAP_DESCENDANT_REVISION,
+        ),
+    }
+
+
+def _environment(path: Path, *, expected_profile: str) -> dict[str, str]:
+    try:
+        raw = json.loads(path.read_text(encoding="ascii"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise MeasurementLineageError(
+            f"cannot read profile environment {path}: {error}"
+        ) from error
+    if (
+        not isinstance(raw, dict)
+        or set(raw) != _ENVIRONMENT_KEYS
+        or raw.get("profile") != expected_profile
+        or raw.get("status") != "authenticated"
+        or not all(isinstance(value, str) for value in raw.values())
+    ):
+        raise MeasurementLineageError(
+            "profile environment is not an authenticated string mapping"
+        )
+    return dict(raw)
+
+
+def _profile_name(repo_root: Path, docs_dir: Path) -> str:
+    try:
+        relative = docs_dir.resolve(strict=False).relative_to(
+            (repo_root / _PROFILE_ROOT).resolve(strict=False)
+        )
+    except ValueError as error:
+        raise MeasurementLineageError(
+            "Class-C bridges require an architecture-specific report profile"
+        ) from error
+    if len(relative.parts) != 1 or relative.parts[0] in {".", ".."}:
+        raise MeasurementLineageError(
+            "Class-C report profile path is not one safe component"
+        )
+    return relative.parts[0]
+
+
+def measurement_lineage_path(repo_root: Path, docs_dir: Path) -> Path:
+    _profile_name(repo_root, docs_dir)
+    return docs_dir / MEASUREMENT_LINEAGE_FILENAME
+
+
+def class_c_pending_path(
+    store: ArtifactStore,
+    *,
+    ancestor_revision: str,
+    descendant_revision: str,
+) -> Path:
+    """Return the only permitted pending-bridge locator for an A→D pair."""
+
+    if (
+        _GIT_SHA_RE.fullmatch(ancestor_revision) is None
+        or _GIT_SHA_RE.fullmatch(descendant_revision) is None
+    ):
+        raise MeasurementLineageError(
+            "pending Class-C bridge identities must be full Git object IDs"
+        )
+    return (
+        store.artifact_root
+        / "source-bridges"
+        / f"{ancestor_revision}-{descendant_revision}.pending.json"
+    )
+
+
+def _validated_pending_path(store: ArtifactStore, path: Path) -> Path:
+    candidate = path.expanduser().absolute()
+    root = (store.artifact_root / "source-bridges").absolute()
+    if (
+        candidate.parent != root
+        or root.is_symlink()
+        or not root.is_dir()
+        or candidate.is_symlink()
+        or not candidate.is_file()
+    ):
+        raise MeasurementLineageError(
+            "pending Class-C bridge is not a regular canonical artifact-root member"
+        )
+    try:
+        candidate.resolve(strict=True).relative_to(
+            store.artifact_root.resolve(strict=True)
+        )
+    except (OSError, ValueError) as error:
+        raise MeasurementLineageError(
+            "pending Class-C bridge escapes the profile artifact root"
+        ) from error
+    return candidate
+
+
+def _current_pin(
+    record: CurrentRecord,
+    *,
+    source_epoch_fallback: tuple[str, str] | None = None,
+) -> dict[str, object]:
+    provenance = record.result.get("provenance")
+    if not isinstance(provenance, Mapping) and source_epoch_fallback is None:
+        raise MeasurementLineageError(
+            f"current {record.cell_id!r} has no source provenance"
+        )
+    if isinstance(provenance, Mapping):
+        revision = provenance.get("report_source_revision")
+        tree = provenance.get("report_source_tree")
+        valid = (
+            isinstance(revision, str)
+            and _GIT_SHA_RE.fullmatch(revision) is not None
+            and isinstance(tree, str)
+            and _GIT_SHA_RE.fullmatch(tree) is not None
+            and provenance.get("report_measured_source_revision") == revision
+            and provenance.get("report_measured_source_tree") == tree
+        )
+    else:
+        revision, tree = source_epoch_fallback  # type: ignore[misc]
+        valid = (
+            _GIT_SHA_RE.fullmatch(revision) is not None
+            and _GIT_SHA_RE.fullmatch(tree) is not None
+        )
+    if not valid:
+        raise MeasurementLineageError(
+            f"current {record.cell_id!r} has invalid source provenance"
+        )
+    pointer = _current_pointer_identity(record)
+    return {
+        "cell_id": record.cell_id,
+        "attempt_id": record.attempt_id,
+        "manifest_sha256": record.manifest_sha256,
+        **pointer,
+        "source_revision": revision,
+        "source_tree": tree,
+        "result_sha256": _file_digest(record.result_path),
+    }
+
+
+def _current_pointer_identity(record: CurrentRecord) -> dict[str, str]:
+    current_path = record.manifest_path.parent.parent.parent / "current.json"
+    return {
+        "current_locator": current_path.relative_to(
+            record.manifest_path.parents[4]
+        ).as_posix(),
+        "current_pointer_sha256": _file_digest(current_path),
+    }
+
+
+def _artifact_canonical_bytes(value: object) -> bytes:
+    try:
+        encoded = json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=False,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+    except (TypeError, ValueError) as error:
+        raise MeasurementLineageError(
+            f"attempt manifest is not canonical JSON: {error}"
+        ) from error
+    return f"{encoded}\n".encode()
+
+
+def _read_attempt_manifest(path: Path) -> dict[str, object]:
+    if path.is_symlink() or not path.is_file():
+        raise MeasurementLineageError(f"attempt has no regular manifest: {path.parent}")
+    try:
+        data = path.read_bytes()
+        raw = json.loads(
+            data.decode("utf-8"),
+            object_pairs_hook=_reject_duplicate_pairs,
+        )
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise MeasurementLineageError(
+            f"cannot read attempt manifest {path}: {error}"
+        ) from error
+    if not isinstance(raw, dict) or data != _artifact_canonical_bytes(raw):
+        raise MeasurementLineageError(
+            f"attempt manifest is not canonical JSON: {path}"
+        )
+    return raw
+
+
+def _attempt_member(
+    attempt_root: Path,
+    relative: object,
+    *,
+    context: str,
+) -> tuple[str, Path]:
+    if (
+        not isinstance(relative, str)
+        or not relative
+        or Path(relative).is_absolute()
+        or any(part in {"", ".", ".."} for part in Path(relative).parts)
+    ):
+        raise MeasurementLineageError(f"{context} is not a safe relative path")
+    candidate = attempt_root.joinpath(*Path(relative).parts)
+    try:
+        resolved = candidate.resolve(strict=True)
+        resolved.relative_to(attempt_root.resolve(strict=True))
+    except (OSError, ValueError) as error:
+        raise MeasurementLineageError(
+            f"{context} is unavailable or escapes its attempt"
+        ) from error
+    if candidate.is_symlink() or not resolved.is_file():
+        raise MeasurementLineageError(f"{context} is not a regular file")
+    return Path(relative).as_posix(), resolved
+
+
+def _validated_attempt_inventory_row(
+    store: ArtifactStore,
+    path: Path,
+    *,
+    expected_cell_id: str,
+) -> dict[str, object]:
+    raw = _read_attempt_manifest(path)
+    attempt_id = path.parent.name
+    try:
+        parsed = uuid.UUID(attempt_id)
+    except ValueError as error:
+        raise MeasurementLineageError(
+            f"attempt directory is not a UUID: {path.parent}"
+        ) from error
+    if (
+        str(parsed) != attempt_id
+        or set(raw) != _ATTEMPT_KEYS
+        or raw.get("schema") != ATTEMPT_SCHEMA
+        or raw.get("cell_id") != expected_cell_id
+        or raw.get("attempt_id") != attempt_id
+    ):
+        raise MeasurementLineageError(
+            f"attempt manifest identity or schema is invalid: {path}"
+        )
+    try:
+        ArtifactPolicy(raw.get("artifact_policy"))
+    except (TypeError, ValueError) as error:
+        raise MeasurementLineageError(
+            f"attempt manifest has an invalid artifact policy: {path}"
+        ) from error
+    based_on = raw.get("based_on")
+    if based_on is not None:
+        if (
+            not isinstance(based_on, dict)
+            or set(based_on) != {"attempt_id", "manifest_sha256"}
+            or not isinstance(based_on.get("attempt_id"), str)
+            or not isinstance(based_on.get("manifest_sha256"), str)
+            or _SHA256_RE.fullmatch(str(based_on["manifest_sha256"])) is None
+        ):
+            raise MeasurementLineageError(
+                f"attempt manifest has an invalid based_on identity: {path}"
+            )
+        try:
+            if str(uuid.UUID(str(based_on["attempt_id"]))) != based_on["attempt_id"]:
+                raise ValueError
+        except ValueError as error:
+            raise MeasurementLineageError(
+                f"attempt manifest has an invalid based_on UUID: {path}"
+            ) from error
+
+    status = raw.get("status")
+    error = raw.get("error")
+    result_path = raw.get("result_path")
+    if status == "ok":
+        if error is not None or result_path is None:
+            raise MeasurementLineageError(
+                f"successful attempt has inconsistent result/error fields: {path}"
+            )
+    elif status in {"failed", "interrupted"}:
+        if not isinstance(error, str) or not error or result_path is not None:
+            raise MeasurementLineageError(
+                f"unsuccessful attempt has inconsistent result/error fields: {path}"
+            )
+    else:
+        raise MeasurementLineageError(
+            f"attempt manifest has an unsupported status: {path}"
+        )
+
+    raw_artifacts = raw.get("artifacts")
+    if not isinstance(raw_artifacts, list):
+        raise MeasurementLineageError(
+            f"attempt manifest artifacts are not an array: {path}"
+        )
+    records: list[dict[str, object]] = []
+    seen: set[str] = set()
+    for index, item in enumerate(raw_artifacts):
+        if not isinstance(item, dict) or set(item) != {"path", "size", "sha256"}:
+            raise MeasurementLineageError(
+                f"attempt artifact {index} has an invalid schema: {path}"
+            )
+        relative, member = _attempt_member(
+            path.parent,
+            item.get("path"),
+            context=f"attempt artifact {index}",
+        )
+        size = item.get("size")
+        sha256 = item.get("sha256")
+        if (
+            relative in seen
+            or isinstance(size, bool)
+            or not isinstance(size, int)
+            or size < 0
+            or member.stat().st_size != size
+            or not isinstance(sha256, str)
+            or _SHA256_RE.fullmatch(sha256) is None
+            or _file_digest(member) != sha256
+        ):
+            raise MeasurementLineageError(
+                f"attempt artifact {index} differs from its manifest: {path}"
+            )
+        seen.add(relative)
+        records.append({"path": relative, "size": size, "sha256": sha256})
+    if records != sorted(records, key=lambda item: str(item["path"])):
+        raise MeasurementLineageError(
+            f"attempt artifact records are not canonically sorted: {path}"
+        )
+    if status == "ok" and (not records or result_path not in seen):
+        raise MeasurementLineageError(
+            f"successful attempt result is not an authenticated artifact: {path}"
+        )
+    observed_files: set[str] = set()
+    for member in path.parent.rglob("*"):
+        if member.is_symlink():
+            raise MeasurementLineageError(
+                f"attempt contains a symbolic link: {member}"
+            )
+        if member.is_file():
+            observed_files.add(member.relative_to(path.parent).as_posix())
+    if observed_files != seen | {"manifest.json"}:
+        raise MeasurementLineageError(
+            f"attempt contains untracked or missing artifact members: {path}"
+        )
+    result_sha256: str | None = None
+    if result_path is not None:
+        _relative, result_file = _attempt_member(
+            path.parent,
+            result_path,
+            context="attempt result",
+        )
+        result_sha256 = _file_digest(result_file)
+    return {
+        "cell_id": expected_cell_id,
+        "attempt_id": attempt_id,
+        "manifest_locator": path.relative_to(store.artifact_root).as_posix(),
+        "manifest_sha256": _file_digest(path),
+        "status": status,
+        "error_sha256": _digest(error),
+        "result_path": result_path,
+        "result_sha256": result_sha256,
+        "artifact_count": len(records),
+        "artifacts_sha256": _digest(records),
+    }
+
+
+def _attempt_inventory(
+    store: ArtifactStore,
+    *,
+    catalog: ReportCatalog,
+) -> tuple[tuple[dict[str, object], ...], tuple[str, ...]]:
+    """Snapshot every catalog attempt, including failed and orphan attempts."""
+
+    catalog_cells = tuple(catalog.measurement_cells())
+    catalog_ids = {cell.cell_id for cell in catalog_cells}
+    roots = {store._cell_root(cell_id): cell_id for cell_id in catalog_ids}
+    if store.cells_root.is_symlink() or not store.cells_root.is_dir():
+        raise MeasurementLineageError(
+            f"artifact cells root is not a regular directory: {store.cells_root}"
+        )
+    for path in store.cells_root.iterdir():
+        if path not in roots:
+            raise MeasurementLineageError(
+                f"artifact store contains an unknown catalog cell directory: {path}"
+            )
+        if path.is_symlink() or not path.is_dir():
+            raise MeasurementLineageError(
+                f"artifact cell root is not a regular directory: {path}"
+            )
+
+    inventory: list[dict[str, object]] = []
+    no_attempts: list[str] = []
+    for cell_id in sorted(catalog_ids):
+        cell_root = store._cell_root(cell_id)  # same-package authenticated layout
+        attempts_root = cell_root / "attempts"
+        if attempts_root.exists() and (
+            attempts_root.is_symlink() or not attempts_root.is_dir()
+        ):
+            raise MeasurementLineageError(
+                f"attempt root is not a regular directory: {attempts_root}"
+            )
+        attempt_roots = (
+            ()
+            if not attempts_root.exists()
+            else tuple(sorted(attempts_root.iterdir()))
+        )
+        manifests: list[Path] = []
+        for attempt_root in attempt_roots:
+            if attempt_root.is_symlink() or not attempt_root.is_dir():
+                raise MeasurementLineageError(
+                    f"attempt entry is not a regular directory: {attempt_root}"
+                )
+            manifest = attempt_root / "manifest.json"
+            if manifest.is_symlink() or not manifest.is_file():
+                raise MeasurementLineageError(
+                    f"attempt has no regular manifest: {attempt_root}"
+                )
+            manifests.append(manifest)
+        if not manifests:
+            if store.load_current(cell_id, missing_ok=True) is not None:
+                raise MeasurementLineageError(
+                    f"cell {cell_id!r} has a current pointer but no attempt manifest"
+                )
+            no_attempts.append(cell_id)
+            continue
+        for path in manifests:
+            inventory.append(
+                _validated_attempt_inventory_row(
+                    store,
+                    path,
+                    expected_cell_id=cell_id,
+                )
+            )
+    return (
+        tuple(
+            sorted(
+                inventory,
+                key=lambda item: (item["cell_id"], item["attempt_id"]),
+            )
+        ),
+        tuple(no_attempts),
+    )
+
+
+RecurrenceReachabilityInspector = Callable[
+    [CurrentRecord, CellSpec],
+    Mapping[str, object],
+]
+
+
+def _runtime_identity_digest(value: Mapping[str, object]) -> str:
+    try:
+        encoded = json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    except (TypeError, ValueError) as error:
+        raise MeasurementLineageError(
+            f"runtime identity is not canonical JSON: {error}"
+        ) from error
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _runtime_identity_evidence(
+    record: CurrentRecord,
+) -> tuple[str, str]:
+    provenance = record.result.get("provenance")
+    identity = (
+        provenance.get("runtime_identity")
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    if not isinstance(identity, Mapping):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: current has no digest-covered runtime identity"
+        )
+    identity_digest = _runtime_identity_digest(identity)
+    stable = dict(identity)
+    policy = stable.get("loaded_module_origin_policy")
+    if isinstance(policy, Mapping):
+        stable_policy = dict(policy)
+        for field in (
+            "observed_module_count",
+            "observations",
+            "observations_sha256",
+        ):
+            stable_policy.pop(field, None)
+        stable["loaded_module_origin_policy"] = stable_policy
+    stable_digest = _runtime_identity_digest(stable)
+    if (
+        provenance.get("runtime_identity_sha256") != identity_digest
+        or provenance.get("runtime_identity_stable_sha256") != stable_digest
+        or provenance.get("runtime_identity_postflight_stable_sha256")
+        != stable_digest
+        or provenance.get("runtime_identity_postflight_match") is not True
+    ):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: runtime identity digest or postflight binding changed"
+        )
+    return identity_digest, stable_digest
+
+
+def _source_epoch(record: CurrentRecord) -> tuple[str, str]:
+    provenance = record.result.get("provenance")
+    revision = (
+        provenance.get("report_source_revision")
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    tree = (
+        provenance.get("report_source_tree")
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    if (
+        not isinstance(revision, str)
+        or _GIT_SHA_RE.fullmatch(revision) is None
+        or not isinstance(tree, str)
+        or _GIT_SHA_RE.fullmatch(tree) is None
+        or provenance.get("report_measured_source_revision") != revision
+        or provenance.get("report_measured_source_tree") != tree
+    ):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: current has no exact measured source epoch"
+        )
+    return revision, tree
+
+
+def _attempt_owner_evidence(
+    store: ArtifactStore,
+    record: CurrentRecord,
+) -> tuple[dict[str, object], str]:
+    try:
+        record.manifest_path.resolve(strict=True).relative_to(
+            store.artifact_root.resolve(strict=True)
+        )
+    except (OSError, ValueError) as error:
+        raise MeasurementLineageError(
+            f"{record.cell_id}: attempt is outside this profile artifact store"
+        ) from error
+    inventory = _validated_attempt_inventory_row(
+        store,
+        record.manifest_path,
+        expected_cell_id=record.cell_id,
+    )
+    if (
+        inventory.get("status") != "ok"
+        or inventory.get("attempt_id") != record.attempt_id
+        or inventory.get("manifest_sha256") != record.manifest_sha256
+        or inventory.get("result_sha256") != _file_digest(record.result_path)
+    ):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: attempt/result identity differs from its manifest"
+        )
+    result_locator = record.result_path.relative_to(
+        store.artifact_root
+    ).as_posix()
+    return inventory, result_locator
+
+
+def _resolve_recurrence_artifact_owner(
+    store: ArtifactStore,
+    catalog: ReportCatalog,
+    record: CurrentRecord,
+    cell: CellSpec,
+    artifact_root: Path,
+    process_id: str,
+) -> dict[str, object]:
+    """Authenticate a direct artifact or one bounded matrix-peer reuse."""
+
+    consumer_inventory, consumer_result_locator = _attempt_owner_evidence(
+        store,
+        record,
+    )
+    consumer_revision, consumer_tree = _source_epoch(record)
+    consumer_runtime, consumer_runtime_stable = _runtime_identity_evidence(record)
+    store_root = store.artifact_root.resolve(strict=True)
+    try:
+        artifact_locator = artifact_root.relative_to(store_root).as_posix()
+    except ValueError as error:
+        raise MeasurementLineageError(
+            f"{cell.cell_id}: recurrence artifact is outside this profile store"
+        ) from error
+
+    consumer_attempt = record.manifest_path.parent.resolve(strict=True)
+    try:
+        artifact_root.relative_to(consumer_attempt)
+    except ValueError:
+        relation = "equivalent-matrix-peer"
+    else:
+        try:
+            expected_consumer_artifact = (
+                consumer_attempt / "artifact"
+            ).resolve(strict=True)
+        except OSError as error:
+            raise MeasurementLineageError(
+                f"{cell.cell_id}: direct recurrence artifact is unavailable"
+            ) from error
+        if artifact_root != expected_consumer_artifact:
+            raise MeasurementLineageError(
+                f"{cell.cell_id}: direct recurrence artifact is not the canonical "
+                "attempt/artifact directory"
+            )
+        relation = "consumer-attempt"
+
+    owner = record
+    owner_current_locator: str | None = None
+    owner_current_sha256: str | None = None
+    if relation == "equivalent-matrix-peer":
+        peers = tuple(
+            peer
+            for peer in catalog.equivalent_cells(cell)
+            if peer.dataset_id.startswith("matrix_")
+        )
+        if len(peers) != 1:
+            raise MeasurementLineageError(
+                f"{cell.cell_id}: recurrence artifact owner matrix peer is "
+                f"missing or ambiguous"
+            )
+        try:
+            loaded = store.load_current(peers[0].cell_id, missing_ok=True)
+        except Exception as error:
+            raise MeasurementLineageError(
+                f"{cell.cell_id}: recurrence artifact owner current is invalid"
+            ) from error
+        if loaded is None:
+            raise MeasurementLineageError(
+                f"{cell.cell_id}: recurrence artifact owner current is missing"
+            )
+        owner = loaded
+        owner_artifact = owner.result.get("artifact")
+        owner_raw_path = (
+            owner_artifact.get("path")
+            if isinstance(owner_artifact, Mapping)
+            else None
+        )
+        owner_process_id = (
+            owner_artifact.get("process_id")
+            if isinstance(owner_artifact, Mapping)
+            else None
+        )
+        if (
+            not isinstance(owner_raw_path, str)
+            or not owner_raw_path
+            or "${" in owner_raw_path
+            or owner_process_id != process_id
+        ):
+            raise MeasurementLineageError(
+                f"{cell.cell_id}: recurrence artifact owner result is malformed"
+            )
+        try:
+            owner_artifact_root = Path(owner_raw_path).expanduser().resolve(
+                strict=True
+            )
+            expected_owner_artifact = (
+                owner.manifest_path.parent.resolve(strict=True) / "artifact"
+            ).resolve(strict=True)
+        except (OSError, ValueError) as error:
+            raise MeasurementLineageError(
+                f"{cell.cell_id}: recurrence artifact owner chains to another attempt"
+            ) from error
+        if (
+            Path(owner_raw_path).expanduser().is_symlink()
+            or not owner_artifact_root.is_dir()
+            or owner_artifact_root != expected_owner_artifact
+            or owner_artifact_root != artifact_root
+        ):
+            raise MeasurementLineageError(
+                f"{cell.cell_id}: recurrence artifact is not owned by its matrix peer"
+            )
+        owner_pin = _current_pin(owner)
+        owner_current_locator = str(owner_pin["current_locator"])
+        owner_current_sha256 = str(owner_pin["current_pointer_sha256"])
+
+    owner_inventory, owner_result_locator = _attempt_owner_evidence(store, owner)
+    owner_revision, owner_tree = _source_epoch(owner)
+    owner_runtime, owner_runtime_stable = _runtime_identity_evidence(owner)
+    if (
+        (owner_revision, owner_tree) != (consumer_revision, consumer_tree)
+        or owner_runtime_stable != consumer_runtime_stable
+    ):
+        raise MeasurementLineageError(
+            f"{cell.cell_id}: recurrence artifact owner belongs to another "
+            "source/runtime epoch"
+        )
+
+    return {
+        "relation": relation,
+        "artifact_locator": artifact_locator,
+        "consumer_cell_id": record.cell_id,
+        "consumer_attempt_id": record.attempt_id,
+        "consumer_manifest_locator": consumer_inventory["manifest_locator"],
+        "consumer_manifest_sha256": record.manifest_sha256,
+        "consumer_result_locator": consumer_result_locator,
+        "consumer_result_sha256": consumer_inventory["result_sha256"],
+        "consumer_source_revision": consumer_revision,
+        "consumer_source_tree": consumer_tree,
+        "consumer_runtime_identity_sha256": consumer_runtime,
+        "consumer_runtime_identity_stable_sha256": consumer_runtime_stable,
+        "owner_cell_id": owner.cell_id,
+        "owner_attempt_id": owner.attempt_id,
+        "owner_current_locator": owner_current_locator,
+        "owner_current_sha256": owner_current_sha256,
+        "owner_manifest_locator": owner_inventory["manifest_locator"],
+        "owner_manifest_sha256": owner.manifest_sha256,
+        "owner_result_locator": owner_result_locator,
+        "owner_result_sha256": owner_inventory["result_sha256"],
+        "owner_artifacts_sha256": owner_inventory["artifacts_sha256"],
+        "owner_source_revision": owner_revision,
+        "owner_source_tree": owner_tree,
+        "owner_runtime_identity_sha256": owner_runtime,
+        "owner_runtime_identity_stable_sha256": owner_runtime_stable,
+    }
+
+
+def _artifact_member(root: Path, relative: object, *, context: str) -> Path:
+    if (
+        not isinstance(relative, str)
+        or not relative
+        or Path(relative).is_absolute()
+        or any(part in {"", ".", ".."} for part in Path(relative).parts)
+    ):
+        raise MeasurementLineageError(f"{context} is not a safe artifact member")
+    candidate = root.joinpath(*Path(relative).parts)
+    try:
+        resolved = candidate.resolve(strict=True)
+        resolved.relative_to(root.resolve(strict=True))
+    except (OSError, ValueError) as error:
+        raise MeasurementLineageError(
+            f"{context} is unavailable or escapes its artifact"
+        ) from error
+    if candidate.is_symlink() or not resolved.is_file():
+        raise MeasurementLineageError(f"{context} is not a regular file")
+    return resolved
+
+
+def _validate_numerical_validation_failure(
+    record: CurrentRecord,
+    cell: CellSpec,
+) -> None:
+    """Validate one completed pointwise failure selected for replacement."""
+
+    validation = record.result.get("validation")
+    failure = record.result.get("failure")
+    artifact = record.result.get("artifact")
+    provenance = record.result.get("provenance")
+    try:
+        validate_measurement(record.result, expected_cell=cell)
+    except ValueError as error:
+        raise MeasurementLineageError(
+            f"{record.cell_id}: closure failure measurement schema is invalid"
+        ) from error
+    if (
+        record.result.get("status") != ResultStatus.VALIDATION_FAILED.value
+        or not isinstance(validation, Mapping)
+        or validation.get("status")
+        != ResultStatus.VALIDATION_FAILED.value
+        or not isinstance(failure, Mapping)
+        or set(failure) != {"kind", "message"}
+        or failure.get("kind") != "MeasurementValidationError"
+        or failure.get("message")
+        != "candidate or same-artifact numerical validation failed"
+        or not isinstance(artifact, Mapping)
+        or set(artifact) != {"path", "process_id", "policy"}
+        or not isinstance(artifact.get("path"), str)
+        or not artifact["path"]
+        or not isinstance(artifact.get("process_id"), str)
+        or not artifact["process_id"]
+        or artifact.get("policy") != "generated"
+        or not isinstance(provenance, Mapping)
+    ):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: closure current is not an authenticated "
+            "numerical-validation failure"
+        )
+
+    pointwise = validation.get("pointwise")
+    resolved_sum = validation.get("resolved_sum")
+    if not isinstance(pointwise, Mapping) or not isinstance(resolved_sum, Mapping):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: closure failure lacks complete pointwise/resolved "
+            "validation evidence"
+        )
+    try:
+        validate_conditioned_comparison_record(
+            pointwise,
+            require_binding="abi" in pointwise,
+        )
+        validate_resolved_sum_validation_record(resolved_sum)
+    except ValueError as error:
+        raise MeasurementLineageError(
+            f"{record.cell_id}: closure validation evidence is inconsistent"
+        ) from error
+    matrix_element = record.result.get("matrix_element")
+    candidate = pointwise.get("candidate")
+    if (
+        isinstance(candidate, bool)
+        or not isinstance(candidate, (int, float))
+        or not math.isfinite(float(candidate))
+        or float(candidate) < 0.0
+        or (
+            isinstance(matrix_element, bool)
+            or not isinstance(matrix_element, (int, float))
+            or not math.isfinite(float(matrix_element))
+            or float(matrix_element) < 0.0
+        )
+    ):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: closure validation evidence is not finite and "
+            "nonnegative"
+        )
+    if (
+        float(matrix_element) != float(candidate)
+        or pointwise.get("status") != ResultStatus.VALIDATION_FAILED.value
+        or resolved_sum.get("status") != ResultStatus.OK.value
+    ):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: closure validation evidence is numerically "
+            "inconsistent"
+        )
+
+    try:
+        artifact_root = Path(str(artifact["path"])).expanduser().resolve(strict=True)
+        expected_artifact_root = (
+            record.manifest_path.parent / "artifact"
+        ).resolve(strict=True)
+    except OSError as error:
+        raise MeasurementLineageError(
+            f"{record.cell_id}: closure failure artifact is unavailable"
+        ) from error
+    if (
+        Path(str(artifact["path"])).expanduser().is_symlink()
+        or not artifact_root.is_dir()
+        or artifact_root != expected_artifact_root
+    ):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: closure failure artifact is not its canonical "
+            "attempt artifact"
+        )
+    try:
+        _validate_runtime_identity_postflight(provenance, validation)
+    except ValueError as error:
+        raise MeasurementLineageError(
+            f"{record.cell_id}: closure failure runtime identity is invalid"
+        ) from error
+    _source_epoch(record)
+    _runtime_identity_evidence(record)
+
+
+def _authenticate_replaceable_validation_failure(
+    store: ArtifactStore,
+    record: CurrentRecord,
+    cell: CellSpec,
+) -> None:
+    """Authenticate one immutable current selected for replacement."""
+
+    _validate_numerical_validation_failure(record, cell)
+    _current_pin(record)
+    _attempt_owner_evidence(store, record)
+
+
+def _default_recurrence_reachability(
+    record: CurrentRecord,
+    cell: CellSpec,
+    *,
+    store: ArtifactStore,
+    catalog: ReportCatalog,
+) -> Mapping[str, object]:
+    """Authenticate one recurrence schedule and expose active model contracts."""
+
+    if (
+        cell.measurement.execution_mode is not ExecutionMode.RECURRENCE
+        or cell.measurement.model is not ModelKey.BUILTIN_SM
+    ):
+        raise MeasurementLineageError(
+            "recurrence reachability received a non-built-in recurrence cell"
+        )
+    artifact = record.result.get("artifact")
+    if not isinstance(artifact, Mapping):
+        raise MeasurementLineageError(
+            f"{cell.cell_id}: recurrence result has no artifact record"
+        )
+    raw_path = artifact.get("path")
+    process_id = artifact.get("process_id")
+    if (
+        not isinstance(raw_path, str)
+        or not raw_path
+        or "${" in raw_path
+        or not isinstance(process_id, str)
+        or not process_id
+    ):
+        raise MeasurementLineageError(
+            f"{cell.cell_id}: recurrence artifact locator is invalid"
+        )
+    try:
+        raw_artifact_root = Path(raw_path).expanduser()
+        artifact_root = raw_artifact_root.resolve(strict=True)
+    except OSError as error:
+        raise MeasurementLineageError(
+            f"{cell.cell_id}: recurrence artifact is unavailable"
+        ) from error
+    if raw_artifact_root.is_symlink() or not artifact_root.is_dir():
+        raise MeasurementLineageError(
+            f"{cell.cell_id}: recurrence artifact is not a regular directory"
+        )
+    artifact_owner = _resolve_recurrence_artifact_owner(
+        store,
+        catalog,
+        record,
+        cell,
+        artifact_root,
+        process_id,
+    )
+
+    try:
+        from pyamplicol.models.prepared import (
+            EAGER_KERNEL_ABI,
+            PreparedKernelPack,
+        )
+        from pyamplicol.runtime.recurrence_exact._plan_v2 import (
+            DIRECT_NONE_U32,
+            _load_recurrence_exact_sections_v1,
+        )
+
+        from .final_audit import audit_artifact
+
+        evidence = audit_artifact(cell, artifact_root, process_id)
+        execution_path = _artifact_member(
+            artifact_root,
+            evidence.execution_manifest_path,
+            context=f"{cell.cell_id} execution manifest",
+        )
+        execution = json.loads(execution_path.read_text(encoding="utf-8"))
+        if not isinstance(execution, dict):
+            raise MeasurementLineageError(
+                "recurrence execution manifest is not an object"
+            )
+        plan = execution.get("plan")
+        kernel_pack = execution.get("kernel_pack")
+        if not isinstance(plan, Mapping) or not isinstance(kernel_pack, Mapping):
+            raise MeasurementLineageError(
+                "recurrence execution lacks plan or kernel-pack identity"
+            )
+        runtime_schedule = plan.get("runtime_schedule")
+        process_binding = plan.get("process_binding")
+        if not isinstance(runtime_schedule, Mapping) or not isinstance(
+            process_binding, Mapping
+        ):
+            raise MeasurementLineageError(
+                "recurrence execution lacks schedule or process binding"
+            )
+        schedule_path = _artifact_member(
+            artifact_root,
+            runtime_schedule.get("path"),
+            context=f"{cell.cell_id} recurrence schedule",
+        )
+        binding_path = _artifact_member(
+            artifact_root
+            / "processes"
+            / process_id,
+            process_binding.get("path"),
+            context=f"{cell.cell_id} recurrence process binding",
+        )
+        if (
+            _file_digest(schedule_path) != runtime_schedule.get("sha256")
+            or schedule_path.stat().st_size != runtime_schedule.get("size_bytes")
+            or _file_digest(binding_path) != process_binding.get("sha256")
+            or binding_path.stat().st_size != process_binding.get("size_bytes")
+        ):
+            raise MeasurementLineageError(
+                "recurrence schedule or process-binding bytes differ from execution"
+            )
+        pack_path = _artifact_member(
+            artifact_root,
+            kernel_pack.get("manifest_path"),
+            context=f"{cell.cell_id} recurrence kernel pack",
+        )
+        raw_pack = json.loads(pack_path.read_text(encoding="utf-8"))
+        if (
+            not isinstance(raw_pack, dict)
+            or raw_pack.pop("eager_kernel_abi", None) != EAGER_KERNEL_ABI
+        ):
+            raise MeasurementLineageError(
+                "recurrence prepared pack has an incompatible eager-kernel ABI"
+            )
+        prepared_pack = PreparedKernelPack.from_dict(raw_pack)
+        direct_catalog = prepared_pack.recurrence_direct_template_catalog
+        semantic_catalog = prepared_pack.recurrence_template_catalog
+        if direct_catalog is None or semantic_catalog is None:
+            raise MeasurementLineageError(
+                "recurrence prepared pack lacks authenticated direct semantics"
+            )
+        sections = _load_recurrence_exact_sections_v1(
+            artifact_root,
+            process_id,
+        )
+        active_executor_ids = {
+            row.executor_id
+            for row in sections.row_groups
+            if row.executor_id != DIRECT_NONE_U32
+        }
+        selected_dispatch_ids = {
+            row.dispatch_variant_id
+            for row in sections.resolved_source_selections
+        }
+        for dispatch_id in selected_dispatch_ids:
+            try:
+                active_executor_ids.add(
+                    sections.source_dispatch_variants[dispatch_id].executor_id
+                )
+            except IndexError as error:
+                raise MeasurementLineageError(
+                    "recurrence source dispatch selects an absent variant"
+                ) from error
+        if not active_executor_ids:
+            raise MeasurementLineageError(
+                "recurrence schedule has no active direct executors"
+            )
+        if max(active_executor_ids) >= len(direct_catalog.templates):
+            raise MeasurementLineageError(
+                "recurrence schedule selects an unknown direct executor"
+            )
+        transition_by_id = {
+            transition.template_id: transition
+            for transition in semantic_catalog.transitions
+        }
+        matched_contracts: set[str] = set()
+        matched_templates: set[str] = set()
+        executor_by_id = {
+            executor.executor_id: executor for executor in sections.executors
+        }
+        for executor_id in active_executor_ids:
+            template = direct_catalog.templates[executor_id]
+            if template.direct_executor_id != executor_id:
+                raise MeasurementLineageError(
+                    "recurrence direct executor catalog is not dense"
+                )
+            executor = executor_by_id.get(executor_id)
+            binding = template.payload_binding
+            if (
+                executor is None
+                or executor.role != template.role
+                or executor.destination_operation != template.destination_operation
+                or executor.parent_component_counts
+                != template.parent_component_counts
+                or executor.destination_component_count
+                != template.destination_component_count
+                or executor.momentum_operand_count
+                != template.momentum_operand_count
+                or executor.prepared_kernel_id != binding.prepared_kernel_id
+                or executor.runtime_template != binding.runtime_template
+            ):
+                raise MeasurementLineageError(
+                    "active recurrence executor differs from its authenticated "
+                    f"direct template: {executor_id}"
+                )
+            for template_id in template.semantic_template_ids:
+                transition = transition_by_id.get(template_id)
+                if (
+                    transition is not None
+                    and transition.equivalence_class in _HZZ_CONTRACT_IDS
+                ):
+                    matched_contracts.add(transition.equivalence_class)
+                    matched_templates.add(template_id)
+    except MeasurementLineageError:
+        raise
+    except Exception as error:
+        raise MeasurementLineageError(
+            f"{cell.cell_id}: cannot authenticate recurrence reachability: {error}"
+        ) from error
+
+    return {
+        "cell_id": cell.cell_id,
+        "attempt_id": record.attempt_id,
+        "manifest_sha256": record.manifest_sha256,
+        "artifact_locator": artifact_root.relative_to(
+            record.manifest_path.parents[4]
+        ).as_posix(),
+        "artifact_owner": artifact_owner,
+        "process_id": process_id,
+        "execution_manifest_path": evidence.execution_manifest_path,
+        "execution_manifest_sha256": evidence.execution_manifest_sha256,
+        "schedule_path": schedule_path.relative_to(artifact_root).as_posix(),
+        "schedule_sha256": _file_digest(schedule_path),
+        "schedule_index_sha256": runtime_schedule.get("index_sha256"),
+        "schedule_member_sha256": runtime_schedule.get("sha256"),
+        "process_binding_path": binding_path.relative_to(artifact_root).as_posix(),
+        "process_binding_sha256": _file_digest(binding_path),
+        "kernel_pack_path": pack_path.relative_to(artifact_root).as_posix(),
+        "kernel_pack_sha256": _file_digest(pack_path),
+        "semantic_catalog_sha256": semantic_catalog.catalog_digest,
+        "direct_catalog_sha256": direct_catalog.catalog_digest,
+        "active_executor_ids": sorted(active_executor_ids),
+        "matched_template_ids": sorted(matched_templates),
+        "matched_contract_ids": sorted(matched_contracts),
+    }
+
+
+def _hzz_reachability_certificate(
+    store: ArtifactStore,
+    *,
+    catalog: ReportCatalog,
+    inspector: RecurrenceReachabilityInspector | None,
+) -> dict[str, object]:
+    by_id = {cell.cell_id: cell for cell in catalog.measurement_cells()}
+    target_ids = {cell.cell_id for cell in hzz_impacted_cells(catalog=catalog)}
+    replacement_ids = target_ids | {
+        cell.cell_id for cell in hzz_agreement_closure(catalog=catalog)
+    }
+    inspect = (
+        inspector
+        if inspector is not None
+        else lambda record, cell: _default_recurrence_reachability(
+            record,
+            cell,
+            store=store,
+            catalog=catalog,
+        )
+    )
+    records: list[dict[str, object]] = []
+    reached_ids: set[str] = set()
+    existing_target_ids: set[str] = set()
+    invalidated_failure_ids: set[str] = set()
+    for current in store.recover_current_records():
+        cell = by_id.get(current.cell_id)
+        if cell is None:
+            raise MeasurementLineageError(
+                f"artifact store current is absent from the report catalog: "
+                f"{current.cell_id}"
+            )
+        status = current.result.get("status")
+        if status != ResultStatus.OK.value:
+            if current.cell_id not in replacement_ids:
+                raise MeasurementLineageError(
+                    "current outside the exact HZZ replacement closure is not "
+                    f"successful: {current.cell_id}"
+                )
+            _authenticate_replaceable_validation_failure(store, current, cell)
+            invalidated_failure_ids.add(current.cell_id)
+            continue
+        if (
+            cell.measurement.execution_mode is not ExecutionMode.RECURRENCE
+            or cell.measurement.model is not ModelKey.BUILTIN_SM
+        ):
+            continue
+        raw = dict(inspect(current, cell))
+        matched = raw.get("matched_contract_ids")
+        if (
+            not isinstance(matched, list)
+            or matched != sorted(set(matched))
+            or any(value not in _HZZ_CONTRACT_IDS for value in matched)
+        ):
+            raise MeasurementLineageError(
+                f"recurrence reachability record is malformed: {current.cell_id}"
+            )
+        if matched:
+            reached_ids.add(current.cell_id)
+        if current.cell_id in target_ids:
+            existing_target_ids.add(current.cell_id)
+            if not matched:
+                raise MeasurementLineageError(
+                    "catalog HZZ target is not structurally reachable through its "
+                    f"stored schedule: {current.cell_id}"
+                )
+        records.append(raw)
+    certificate = {
+        "algorithm": "authenticated-recurrence-active-executor-reachability-v1",
+        "target_contract_ids": sorted(_HZZ_CONTRACT_IDS),
+        "inspected_current_count": len(records),
+        "records": sorted(records, key=lambda item: str(item.get("cell_id"))),
+        "reached_cell_ids": sorted(reached_ids),
+        "existing_catalog_target_ids": sorted(existing_target_ids),
+        "invalidated_validation_failed_current_ids": sorted(
+            invalidated_failure_ids
+        ),
+    }
+    certificate["sha256"] = _digest(certificate)
+    return certificate
+
+
+def _validate_recurrence_summary_cap_failure(
+    store: ArtifactStore,
+    record: CurrentRecord,
+    cell: CellSpec,
+    *,
+    expected_bytes: int,
+) -> dict[str, object]:
+    """Authenticate one exact source-less summary-cap failure attempt."""
+
+    try:
+        validate_measurement(record.result, expected_cell=cell)
+    except ValueError as error:
+        raise MeasurementLineageError(
+            f"{record.cell_id}: recurrence summary-cap failure schema is invalid"
+        ) from error
+    failure = record.result.get("failure")
+    expected_message = _summary_cap_failure_message(expected_bytes)
+    if (
+        _RECURRENCE_SUMMARY_CAP_FAILURE_BYTES.get(record.cell_id)
+        != expected_bytes
+        or cell.cell_id != record.cell_id
+        or record.result.get("status") != ResultStatus.ERROR.value
+        or not isinstance(failure, Mapping)
+        or set(failure) != {"kind", "message"}
+        or failure.get("kind") != "GenerationError"
+        or failure.get("message") != expected_message
+    ):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: current is not the authenticated "
+            "recurrence summary-cap GenerationError"
+        )
+    inventory, result_locator = _attempt_owner_evidence(store, record)
+    return {
+        "cell_id": record.cell_id,
+        "attempt_id": record.attempt_id,
+        "manifest_sha256": record.manifest_sha256,
+        "result_locator": result_locator,
+        "result_sha256": inventory["result_sha256"],
+        "summary_bytes": expected_bytes,
+        "failure_kind": "GenerationError",
+        "failure_message": expected_message,
+    }
+
+
+def _summary_cap_excluded_current_record(
+    store: ArtifactStore,
+    record: CurrentRecord,
+    cell: CellSpec,
+) -> dict[str, object]:
+    try:
+        validate_measurement(record.result, expected_cell=cell)
+    except ValueError as error:
+        raise MeasurementLineageError(
+            f"{record.cell_id}: excluded terminal current schema is invalid"
+        ) from error
+    status = record.result.get("status")
+    if (
+        status == ResultStatus.OK.value
+        or status not in {value.value for value in ResultStatus}
+        or record.result.get("failure") is None
+    ):
+        raise MeasurementLineageError(
+            f"{record.cell_id}: excluded current is not a terminal failure"
+        )
+    inventory, result_locator = _attempt_owner_evidence(store, record)
+    return {
+        "cell_id": record.cell_id,
+        "attempt_id": record.attempt_id,
+        "manifest_sha256": record.manifest_sha256,
+        "result_locator": result_locator,
+        "result_sha256": inventory["result_sha256"],
+        **_current_pointer_identity(record),
+        "status": status,
+        "failure_sha256": _digest(record.result["failure"]),
+    }
+
+
+def _summary_cap_predecessor_record(
+    lineage: MeasurementLineage,
+) -> dict[str, object]:
+    payload = lineage.payload
+    ancestor_environment = payload.get("ancestor_environment")
+    descendant_environment = payload.get("descendant_environment")
+    retained = payload.get("retained_currents")
+    if (
+        payload.get("state") != "finalized"
+        or payload.get("impact") != CLASS_C_HZZ_IMPACT
+        or not isinstance(ancestor_environment, Mapping)
+        or not isinstance(descendant_environment, Mapping)
+        or not isinstance(retained, list)
+    ):
+        raise MeasurementLineageError(
+            "recurrence summary-cap continuity requires one finalized HZZ "
+            "predecessor"
+        )
+    record = {
+        "payload_sha256": _digest(payload),
+        "profile": payload["profile"],
+        "impact": payload["impact"],
+        "ancestor_revision": lineage.ancestor_revision,
+        "ancestor_tree": lineage.ancestor_tree,
+        "descendant_revision": lineage.descendant_revision,
+        "descendant_tree": lineage.descendant_tree,
+        "ancestor_environment": dict(ancestor_environment),
+        "ancestor_environment_sha256": _digest(ancestor_environment),
+        "descendant_environment_sha256": _digest(descendant_environment),
+        "retained_currents": list(retained),
+        "retained_currents_sha256": _digest(retained),
+    }
+    _validate_summary_cap_predecessor(record)
+    return record
+
+
+def _recurrence_summary_cap_failure_certificate(
+    store: ArtifactStore,
+    *,
+    catalog: ReportCatalog,
+    predecessor_lineage: MeasurementLineage,
+) -> dict[str, object]:
+    by_id = {cell.cell_id: cell for cell in catalog.measurement_cells()}
+    target_ids = set(_RECURRENCE_SUMMARY_CAP_FAILURE_BYTES)
+    records: list[dict[str, object]] = []
+    excluded: list[dict[str, object]] = []
+    inspected_count = 0
+    successful_count = 0
+    for current in store.recover_current_records():
+        inspected_count += 1
+        cell = by_id.get(current.cell_id)
+        if cell is None:
+            raise MeasurementLineageError(
+                "artifact store current is absent from the report catalog: "
+                f"{current.cell_id}"
+            )
+        if current.cell_id in target_ids:
+            records.append(
+                _validate_recurrence_summary_cap_failure(
+                    store,
+                    current,
+                    cell,
+                    expected_bytes=_RECURRENCE_SUMMARY_CAP_FAILURE_BYTES[
+                        current.cell_id
+                    ],
+                )
+            )
+        elif current.result.get("status") != ResultStatus.OK.value:
+            excluded.append(
+                _summary_cap_excluded_current_record(
+                    store,
+                    current,
+                    cell,
+                )
+            )
+        else:
+            successful_count += 1
+    observed_ids = {str(record["cell_id"]) for record in records}
+    if observed_ids != target_ids or len(records) != len(target_ids):
+        missing = sorted(target_ids - observed_ids)
+        raise MeasurementLineageError(
+            "artifact store does not contain the exact recurrence summary-cap "
+            "failure census"
+            + (": " + ", ".join(missing) if missing else "")
+        )
+    certificate = {
+        "algorithm": "authenticated-recurrence-summary-cap-failure-census-v1",
+        "predecessor": _summary_cap_predecessor_record(predecessor_lineage),
+        "target_summary_bytes": dict(_RECURRENCE_SUMMARY_CAP_FAILURE_BYTES),
+        "inspected_current_count": inspected_count,
+        "successful_current_count": successful_count,
+        "excluded_non_success_current_count": len(excluded),
+        "records": sorted(records, key=lambda item: str(item["cell_id"])),
+        "excluded_non_success_currents": sorted(
+            excluded,
+            key=lambda item: str(item["cell_id"]),
+        ),
+        "invalidated_generation_error_current_ids": sorted(target_ids),
+    }
+    certificate["sha256"] = _digest(certificate)
+    return certificate
+
+
+def _reachability_certificate(
+    impact: str,
+    store: ArtifactStore,
+    *,
+    catalog: ReportCatalog,
+    inspector: RecurrenceReachabilityInspector | None,
+    predecessor_lineage: MeasurementLineage | None = None,
+) -> dict[str, object]:
+    if impact == CLASS_C_HZZ_IMPACT:
+        return _hzz_reachability_certificate(
+            store,
+            catalog=catalog,
+            inspector=inspector,
+        )
+    if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT:
+        if predecessor_lineage is None:
+            raise MeasurementLineageError(
+                "recurrence summary-cap continuity has no audited predecessor"
+            )
+        return _recurrence_summary_cap_failure_certificate(
+            store,
+            catalog=catalog,
+            predecessor_lineage=predecessor_lineage,
+        )
+    raise MeasurementLineageError(f"unsupported Class-C impact {impact!r}")
+
+
+def _certificate_failure_ids(
+    impact: str,
+    certificate: Mapping[str, object],
+) -> frozenset[str]:
+    if impact == CLASS_C_HZZ_IMPACT:
+        field = "invalidated_validation_failed_current_ids"
+    elif impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT:
+        field = "invalidated_generation_error_current_ids"
+    else:
+        raise MeasurementLineageError(f"unsupported Class-C impact {impact!r}")
+    raw = certificate.get(field)
+    if not isinstance(raw, list) or any(
+        not isinstance(value, str) for value in raw
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage invalidated failure census is malformed"
+        )
+    return frozenset(raw)
+
+
+def _summary_cap_inherited_pins(
+    certificate: Mapping[str, object],
+) -> tuple[dict[str, object], ...]:
+    predecessor = certificate.get("predecessor")
+    if not isinstance(predecessor, Mapping):
+        raise MeasurementLineageError(
+            "recurrence summary-cap predecessor is absent"
+        )
+    return _validated_pins(predecessor, "retained_currents")
+
+
+def _summary_cap_excluded_ids(
+    certificate: Mapping[str, object],
+) -> frozenset[str]:
+    raw = certificate.get("excluded_non_success_currents")
+    if not isinstance(raw, list):
+        raise MeasurementLineageError(
+            "recurrence summary-cap excluded census is absent"
+        )
+    return frozenset(
+        str(record["cell_id"])
+        for record in raw
+        if isinstance(record, Mapping)
+    )
+
+
+def _snapshot_currents(
+    store: ArtifactStore,
+    *,
+    ancestor_revision: str,
+    ancestor_tree: str,
+    catalog: ReportCatalog,
+    invalidated_cell_ids: Sequence[str],
+    recompare_cell_ids: Sequence[str],
+    source_less_failure_ids: Sequence[str] = (),
+    inherited_current_pins: Sequence[Mapping[str, object]] = (),
+    excluded_current_ids: Sequence[str] = (),
+) -> dict[str, object]:
+    impacted_ids = set(invalidated_cell_ids)
+    recompare_ids = set(recompare_cell_ids) - impacted_ids
+    source_less_ids = set(source_less_failure_ids)
+    inherited_by_cell = {
+        str(pin["cell_id"]): pin for pin in inherited_current_pins
+    }
+    excluded_ids = set(excluded_current_ids)
+    if not source_less_ids <= impacted_ids:
+        raise MeasurementLineageError(
+            "source-less failure pins escape the exact invalidated census"
+        )
+    retained: list[dict[str, object]] = []
+    invalidated: list[dict[str, object]] = []
+    recompare: list[dict[str, object]] = []
+    observed_excluded: set[str] = set()
+    for record in store.recover_current_records():
+        if record.cell_id in excluded_ids:
+            observed_excluded.add(record.cell_id)
+            continue
+        pin = _current_pin(
+            record,
+            source_epoch_fallback=(
+                (ancestor_revision, ancestor_tree)
+                if record.cell_id in source_less_ids
+                else None
+            ),
+        )
+        if (
+            pin["source_revision"] != ancestor_revision
+            or pin["source_tree"] != ancestor_tree
+        ) and dict(inherited_by_cell.get(record.cell_id, {})) != pin:
+            raise MeasurementLineageError(
+                f"frozen current {record.cell_id!r} is not authorized by the "
+                "exact ancestor or its audited predecessor"
+            )
+        if record.cell_id in impacted_ids:
+            invalidated.append(pin)
+        elif record.cell_id in recompare_ids:
+            recompare.append(pin)
+        else:
+            retained.append(pin)
+    if observed_excluded != excluded_ids:
+        raise MeasurementLineageError(
+            "excluded terminal current census changed during snapshot"
+        )
+    attempt_inventory, no_attempts = _attempt_inventory(store, catalog=catalog)
+    return {
+        "retained_currents": sorted(retained, key=lambda item: item["cell_id"]),
+        "invalidated_currents": sorted(
+            invalidated, key=lambda item: item["cell_id"]
+        ),
+        "recompare_currents": sorted(recompare, key=lambda item: item["cell_id"]),
+        "attempt_inventory": list(attempt_inventory),
+        "no_attempt_cells": list(no_attempts),
+    }
+
+
+def _workspace_manifest_identity(
+    repo_root: Path,
+    docs_dir: Path,
+    *,
+    ancestor_revision: str,
+    descendant_revision: str,
+) -> dict[str, object]:
+    path = docs_dir / "report-workspace.json"
+    try:
+        relative = path.resolve(strict=True).relative_to(repo_root.resolve(strict=True))
+    except (OSError, ValueError) as error:
+        raise MeasurementLineageError(
+            "report workspace manifest is unavailable or outside the repository"
+        ) from error
+    if path.is_symlink() or not path.is_file():
+        raise MeasurementLineageError(
+            "report workspace manifest is not a regular file"
+        )
+    logical = relative.as_posix()
+    ancestor_member = _tree_member(repo_root, ancestor_revision, logical)
+    descendant_member = _tree_member(repo_root, descendant_revision, logical)
+    if (
+        ancestor_member is None
+        or descendant_member is None
+        or ancestor_member != descendant_member
+        or ancestor_member["mode"] != "100644"
+    ):
+        raise MeasurementLineageError(
+            "Class-C bridge requires one unchanged regular report-workspace blob"
+        )
+    blob = _git(repo_root, "show", f"{ancestor_revision}:{logical}").stdout
+    if hashlib.sha256(path.read_bytes()).digest() != hashlib.sha256(blob).digest():
+        raise MeasurementLineageError(
+            "working report workspace manifest differs from its committed blob"
+        )
+    try:
+        raw = json.loads(blob.decode("ascii"))
+    except (UnicodeError, json.JSONDecodeError) as error:
+        raise MeasurementLineageError(
+            f"cannot read report workspace policy: {error}"
+        ) from error
+    if not isinstance(raw, dict) or not isinstance(raw.get("campaign_policy"), dict):
+        raise MeasurementLineageError("report workspace campaign policy is malformed")
+    return {
+        "path": logical,
+        "mode": ancestor_member["mode"],
+        "object": ancestor_member["object"],
+        "sha256": hashlib.sha256(blob).hexdigest(),
+        "campaign_policy_sha256": _digest(raw["campaign_policy"]),
+    }
+
+
+def _prepare_class_c_bridge_locked(
+    repo_root: Path,
+    docs_dir: Path,
+    store: ArtifactStore,
+    *,
+    ancestor_revision: str,
+    descendant_revision: str,
+    impact: str,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    reachability_inspector: RecurrenceReachabilityInspector | None = None,
+) -> dict[str, object]:
+    """Snapshot a frozen ancestor campaign before runtime authentication changes."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    profile = _profile_name(root, docs_dir)
+    ancestor = _git_commit(root, ancestor_revision)
+    descendant = _git_commit(root, descendant_revision)
+    source = require_eligible_report_source(root)
+    if source.revision != descendant:
+        raise MeasurementLineageError(
+            "Class-C bridge preparation requires checkout HEAD at the descendant"
+        )
+    ancestor_tree = _git_tree(root, ancestor)
+    descendant_tree = _git_tree(root, descendant)
+    environment = _environment(
+        docs_dir / "report_environment.json",
+        expected_profile=profile,
+    )
+    if environment.get("source_revision") != ancestor:
+        raise MeasurementLineageError(
+            "profile environment is not authenticated for the Class-C ancestor"
+        )
+    diff = _diff_records(
+        root,
+        ancestor=ancestor,
+        descendant=descendant,
+        impact=impact,
+    )
+    workspace_manifest = _workspace_manifest_identity(
+        root,
+        docs_dir,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+    )
+    predecessor_lineage = (
+        load_and_audit_measurement_lineage(
+            root,
+            docs_dir,
+            store,
+            expected_active_source_revision=ancestor,
+            catalog=catalog,
+            reachability_inspector=reachability_inspector,
+        )
+        if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+        else None
+    )
+    if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT and (
+        predecessor_lineage is None
+        or predecessor_lineage.descendant_revision != ancestor
+        or predecessor_lineage.descendant_tree != ancestor_tree
+        or predecessor_lineage.payload.get("profile") != profile
+        or predecessor_lineage.payload.get("descendant_environment")
+        != environment
+    ):
+        raise MeasurementLineageError(
+            "recurrence summary-cap continuity requires the audited HZZ bridge "
+            "ending at its exact measured ancestor"
+        )
+    reachability = _reachability_certificate(
+        impact,
+        store,
+        catalog=catalog,
+        inspector=reachability_inspector,
+        predecessor_lineage=predecessor_lineage,
+    )
+    impacted_cells, agreement_cells = _impact_and_agreement_cells(
+        impact,
+        reachability,
+        catalog=catalog,
+    )
+    impacted_ids = tuple(cell.cell_id for cell in impacted_cells)
+    agreement_ids = tuple(cell.cell_id for cell in agreement_cells)
+    snapshot = _snapshot_currents(
+        store,
+        ancestor_revision=ancestor,
+        ancestor_tree=ancestor_tree,
+        catalog=catalog,
+        invalidated_cell_ids=impacted_ids,
+        recompare_cell_ids=agreement_ids,
+        source_less_failure_ids=(
+            _certificate_failure_ids(impact, reachability)
+            if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+            else ()
+        ),
+        inherited_current_pins=(
+            _summary_cap_inherited_pins(reachability)
+            if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+            else ()
+        ),
+        excluded_current_ids=(
+            _summary_cap_excluded_ids(reachability)
+            if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+            else ()
+        ),
+    )
+    impacted = [
+        _cell_record(cell, catalog=catalog) for cell in impacted_cells
+    ]
+    closure = [
+        _cell_record(cell, catalog=catalog) for cell in agreement_cells
+    ]
+    payload: dict[str, object] = {
+        "schema": MEASUREMENT_LINEAGE_SCHEMA,
+        "state": "pending",
+        "class": "C",
+        "impact": impact,
+        "profile": profile,
+        "ancestor_revision": ancestor,
+        "ancestor_tree": ancestor_tree,
+        "descendant_revision": descendant,
+        "descendant_tree": descendant_tree,
+        "git_diff": list(diff),
+        "git_diff_sha256": _digest(diff),
+        "ancestor_environment": environment,
+        "ancestor_environment_sha256": _digest(environment),
+        "descendant_environment": None,
+        "descendant_environment_sha256": None,
+        "runtime_invariant_fields": list(_ENVIRONMENT_INVARIANT_FIELDS),
+        "impacted_cells": impacted,
+        "agreement_closure_cells": closure,
+        "impact_certificate_sha256": _digest(
+            {"impacted": impacted, "agreement_closure": closure}
+        ),
+        "catalog_sha256": _catalog_digest(catalog),
+        "agreement_graph_sha256": _agreement_digest(catalog),
+        "workspace_manifest": workspace_manifest,
+        "workspace_manifest_sha256": _digest(workspace_manifest),
+        "campaign_policy_sha256": workspace_manifest[
+            "campaign_policy_sha256"
+        ],
+        "reachability_certificate": reachability,
+        "reachability_certificate_sha256": _digest(reachability),
+        **snapshot,
+    }
+    payload["current_snapshot_sha256"] = _digest(snapshot)
+    output = class_c_pending_path(
+        store,
+        ancestor_revision=ancestor,
+        descendant_revision=descendant,
+    )
+    expected_root = store.artifact_root / "source-bridges"
+    expected_root.mkdir(parents=True, exist_ok=True)
+    if expected_root.is_symlink() or not expected_root.is_dir():
+        raise MeasurementLineageError(
+            "pending Class-C bridge root is not a regular directory"
+        )
+    try:
+        output.parent.resolve(strict=True).relative_to(
+            store.artifact_root.resolve(strict=True)
+        )
+    except ValueError as error:
+        raise MeasurementLineageError(
+            "pending Class-C bridge must stay under the profile artifact root"
+        ) from error
+    if output.exists() or output.is_symlink():
+        raise MeasurementLineageError(
+            f"pending Class-C bridge already exists: {output}"
+        )
+    _write_envelope(output, payload)
+    return payload
+
+
+def prepare_class_c_bridge(
+    repo_root: Path,
+    docs_dir: Path,
+    store: ArtifactStore,
+    *,
+    ancestor_revision: str,
+    descendant_revision: str,
+    impact: str,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    reachability_inspector: RecurrenceReachabilityInspector | None = None,
+) -> dict[str, object]:
+    """Snapshot a frozen ancestor campaign under the profile writer locks."""
+
+    with (
+        store.named_lock("report-writer"),
+        store.named_lock("measurement-lineage"),
+    ):
+        return _prepare_class_c_bridge_locked(
+            repo_root,
+            docs_dir,
+            store,
+            ancestor_revision=ancestor_revision,
+            descendant_revision=descendant_revision,
+            impact=impact,
+            catalog=catalog,
+            reachability_inspector=reachability_inspector,
+        )
+
+
+def _environment_invariants(environment: Mapping[str, object]) -> dict[str, object]:
+    try:
+        return {field: environment[field] for field in _ENVIRONMENT_INVARIANT_FIELDS}
+    except KeyError as error:
+        raise MeasurementLineageError(
+            f"profile environment lacks invariant field {error.args[0]!r}"
+        ) from error
+
+
+def _is_authorized_native_inputs_transition(
+    *,
+    impact: str,
+    ancestor_revision: str,
+    descendant_revision: str,
+    ancestor_digest: object,
+    descendant_digest: object,
+) -> bool:
+    """Recognize the one reviewed Class-C native-input transition.
+
+    Ordinary Class-C bridges remain native-input invariant.  The recurrence
+    summary-cap bridge is different: its reviewed source closure intentionally
+    changes the native recurrence executor, so both endpoint revisions and
+    both independently computed input digests are pinned here.
+    """
+
+    return (
+        impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+        and ancestor_revision == _RECURRENCE_SUMMARY_CAP_ANCESTOR_REVISION
+        and descendant_revision == _RECURRENCE_SUMMARY_CAP_DESCENDANT_REVISION
+        and ancestor_digest
+        == _RECURRENCE_SUMMARY_CAP_ANCESTOR_NATIVE_INPUTS_SHA256
+        and descendant_digest
+        == _RECURRENCE_SUMMARY_CAP_DESCENDANT_NATIVE_INPUTS_SHA256
+    )
+
+
+def _require_environment_transition(
+    *,
+    impact: str,
+    ancestor_revision: str,
+    descendant_revision: str,
+    ancestor_environment: Mapping[str, object],
+    descendant_environment: Mapping[str, object],
+) -> None:
+    """Require exact invariants, with one digest-pinned native exception."""
+
+    ancestor = _environment_invariants(ancestor_environment)
+    descendant = _environment_invariants(descendant_environment)
+    if impact != CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT:
+        if ancestor != descendant:
+            raise MeasurementLineageError(
+                "Class-C descendant changes dependency/native/host runtime identity"
+            )
+        return
+
+    ancestor_native = ancestor.pop("native_build_inputs_sha256")
+    descendant_native = descendant.pop("native_build_inputs_sha256")
+    if (
+        ancestor != descendant
+        or not _is_authorized_native_inputs_transition(
+            impact=impact,
+            ancestor_revision=ancestor_revision,
+            descendant_revision=descendant_revision,
+            ancestor_digest=ancestor_native,
+            descendant_digest=descendant_native,
+        )
+    ):
+        raise MeasurementLineageError(
+            "Class-C descendant changes dependency/native/host runtime identity "
+            "outside the exact recurrence-summary-cap transition"
+        )
+
+
+def _finalize_class_c_bridge_locked(
+    repo_root: Path,
+    docs_dir: Path,
+    store: ArtifactStore,
+    *,
+    pending_path: Path,
+    expected_active_source_revision: str,
+    runtime_auditor: Callable[[str, Path], Mapping[str, object]] | None = None,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    reachability_inspector: RecurrenceReachabilityInspector | None = None,
+) -> dict[str, object]:
+    """Authenticate the descendant runtime and publish the tracked lineage."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    profile = _profile_name(root, docs_dir)
+    pending_input = _validated_pending_path(store, pending_path)
+    payload = _load_envelope(pending_input, expected_state="pending")
+    active = _git_commit(root, expected_active_source_revision)
+    source = require_eligible_report_source(root)
+    if (
+        payload.get("profile") != profile
+        or payload.get("descendant_revision") != active
+        or payload.get("descendant_tree") != source.tree
+        or source.revision != active
+    ):
+        raise MeasurementLineageError(
+            "pending Class-C bridge does not identify the active descendant"
+        )
+    canonical_pending = class_c_pending_path(
+        store,
+        ancestor_revision=str(payload["ancestor_revision"]),
+        descendant_revision=active,
+    )
+    if (
+        pending_input != canonical_pending.absolute()
+    ):
+        raise MeasurementLineageError(
+            "pending Class-C bridge does not use its canonical A-D locator"
+        )
+    expected_diff = _diff_records(
+        root,
+        ancestor=str(payload["ancestor_revision"]),
+        descendant=active,
+        impact=str(payload["impact"]),
+    )
+    workspace_manifest = _workspace_manifest_identity(
+        root,
+        docs_dir,
+        ancestor_revision=str(payload["ancestor_revision"]),
+        descendant_revision=active,
+    )
+    impact = str(payload["impact"])
+    predecessor_lineage = (
+        load_and_audit_measurement_lineage(
+            root,
+            docs_dir,
+            store,
+            expected_active_source_revision=str(payload["ancestor_revision"]),
+            catalog=catalog,
+            reachability_inspector=reachability_inspector,
+        )
+        if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+        else None
+    )
+    if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT and (
+        predecessor_lineage is None
+        or predecessor_lineage.descendant_revision
+        != payload["ancestor_revision"]
+        or predecessor_lineage.descendant_tree != payload["ancestor_tree"]
+        or predecessor_lineage.payload.get("profile") != profile
+        or predecessor_lineage.payload.get("descendant_environment")
+        != payload.get("ancestor_environment")
+    ):
+        raise MeasurementLineageError(
+            "recurrence summary-cap predecessor changed after preparation"
+        )
+    reachability = _reachability_certificate(
+        impact,
+        store,
+        catalog=catalog,
+        inspector=reachability_inspector,
+        predecessor_lineage=predecessor_lineage,
+    )
+    active_agreement_graph = _agreement_digest(catalog)
+    if (
+        payload.get("git_diff") != list(expected_diff)
+        or payload.get("git_diff_sha256") != _digest(expected_diff)
+        or payload.get("catalog_sha256") != _catalog_digest(catalog)
+        or not _agreement_graph_digest_matches(
+            payload,
+            active_agreement_graph,
+        )
+        or payload.get("workspace_manifest") != workspace_manifest
+        or payload.get("workspace_manifest_sha256")
+        != _digest(workspace_manifest)
+        or payload.get("campaign_policy_sha256")
+        != workspace_manifest["campaign_policy_sha256"]
+        or payload.get("reachability_certificate") != reachability
+        or payload.get("reachability_certificate_sha256")
+        != _digest(reachability)
+    ):
+        raise MeasurementLineageError(
+            "pending Class-C source, catalog, agreement, or policy certificate changed"
+        )
+    snapshot = _snapshot_currents(
+        store,
+        ancestor_revision=str(payload["ancestor_revision"]),
+        ancestor_tree=str(payload["ancestor_tree"]),
+        catalog=catalog,
+        invalidated_cell_ids=tuple(
+            cell.cell_id
+            for cell in _impact_and_agreement_cells(
+                impact,
+                reachability,
+                catalog=catalog,
+            )[0]
+        ),
+        recompare_cell_ids=tuple(
+            cell.cell_id
+            for cell in _impact_and_agreement_cells(
+                impact,
+                reachability,
+                catalog=catalog,
+            )[1]
+        ),
+        source_less_failure_ids=(
+            _certificate_failure_ids(impact, reachability)
+            if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+            else ()
+        ),
+        inherited_current_pins=(
+            _summary_cap_inherited_pins(reachability)
+            if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+            else ()
+        ),
+        excluded_current_ids=(
+            _summary_cap_excluded_ids(reachability)
+            if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+            else ()
+        ),
+    )
+    if payload.get("current_snapshot_sha256") != _digest(snapshot):
+        raise MeasurementLineageError(
+            "current or attempt state changed after Class-C preparation"
+        )
+    if runtime_auditor is None:
+        from .final_audit import _audit_active_runtime
+
+        runtime_auditor = _audit_active_runtime
+    try:
+        raw_runtime = runtime_auditor(active, root)
+    except Exception as error:
+        raise MeasurementLineageError(
+            f"cannot authenticate descendant runtime: {error}"
+        ) from error
+    from .workspace import _authenticated_environment_payload
+
+    descendant_environment = _authenticated_environment_payload(
+        profile,
+        expected_source_revision=active,
+        active_runtime=raw_runtime,
+    )
+    ancestor_environment = payload.get("ancestor_environment")
+    if not isinstance(ancestor_environment, Mapping):
+        raise MeasurementLineageError("pending ancestor environment is malformed")
+    _require_environment_transition(
+        impact=impact,
+        ancestor_revision=str(payload["ancestor_revision"]),
+        descendant_revision=active,
+        ancestor_environment=ancestor_environment,
+        descendant_environment=descendant_environment,
+    )
+    if (
+        ancestor_environment.get("python_package_tree_sha256")
+        == descendant_environment.get("python_package_tree_sha256")
+    ):
+        raise MeasurementLineageError(
+            "Class-C executable descendant did not change the Python package tree"
+        )
+    finalized = dict(payload)
+    finalized.update(
+        {
+            "state": "finalized",
+            "descendant_environment": descendant_environment,
+            "descendant_environment_sha256": _digest(descendant_environment),
+        }
+    )
+    target = measurement_lineage_path(root, docs_dir)
+    json_path = docs_dir / "report_environment.json"
+    tex_path = docs_dir / "report_environment.tex"
+    previous_json = json_path.read_bytes() if json_path.exists() else None
+    previous_tex = tex_path.read_bytes() if tex_path.exists() else None
+    previous_lineage = target.read_bytes() if target.exists() else None
+    from .workspace import refresh_profile_environment
+
+    try:
+        refreshed = refresh_profile_environment(
+            root,
+            profile,
+            expected_source_revision=active,
+            runtime_auditor=lambda _revision, _root: raw_runtime,
+            _skip_workspace_validation=True,
+        )
+        if refreshed != descendant_environment:
+            raise MeasurementLineageError(
+                "written descendant environment differs from its "
+                "authenticated snapshot"
+            )
+        _write_envelope(target, finalized)
+        audit_measurement_lineage(
+            root,
+            docs_dir,
+            store,
+            expected_active_source_revision=active,
+            catalog=catalog,
+            reachability_inspector=reachability_inspector,
+        )
+        final_snapshot = _snapshot_currents(
+            store,
+            ancestor_revision=str(payload["ancestor_revision"]),
+            ancestor_tree=str(payload["ancestor_tree"]),
+            catalog=catalog,
+            invalidated_cell_ids=tuple(
+                cell.cell_id
+                for cell in _impact_and_agreement_cells(
+                    impact,
+                    reachability,
+                    catalog=catalog,
+                )[0]
+            ),
+            recompare_cell_ids=tuple(
+                cell.cell_id
+                for cell in _impact_and_agreement_cells(
+                    impact,
+                    reachability,
+                    catalog=catalog,
+                )[1]
+            ),
+            source_less_failure_ids=(
+                _certificate_failure_ids(impact, reachability)
+                if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+                else ()
+            ),
+            inherited_current_pins=(
+                _summary_cap_inherited_pins(reachability)
+                if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+                else ()
+            ),
+            excluded_current_ids=(
+                _summary_cap_excluded_ids(reachability)
+                if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+                else ()
+            ),
+        )
+        if payload.get("current_snapshot_sha256") != _digest(final_snapshot):
+            raise MeasurementLineageError(
+                "current or attempt state raced Class-C finalization"
+            )
+    except BaseException:
+        _restore_file(json_path, previous_json)
+        _restore_file(tex_path, previous_tex)
+        _restore_file(target, previous_lineage)
+        raise
+    return finalized
+
+
+def finalize_class_c_bridge(
+    repo_root: Path,
+    docs_dir: Path,
+    store: ArtifactStore,
+    *,
+    pending_path: Path,
+    expected_active_source_revision: str,
+    runtime_auditor: Callable[[str, Path], Mapping[str, object]] | None = None,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    reachability_inspector: RecurrenceReachabilityInspector | None = None,
+) -> dict[str, object]:
+    """Authenticate and publish a Class-C bridge under the profile writer locks."""
+
+    with (
+        store.named_lock("report-writer"),
+        store.named_lock("measurement-lineage"),
+    ):
+        return _finalize_class_c_bridge_locked(
+            repo_root,
+            docs_dir,
+            store,
+            pending_path=pending_path,
+            expected_active_source_revision=expected_active_source_revision,
+            runtime_auditor=runtime_auditor,
+            catalog=catalog,
+            reachability_inspector=reachability_inspector,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class MeasurementLineage:
+    """Validated authorization map for one finalized Class-C bridge."""
+
+    payload: Mapping[str, object]
+    retained_by_cell: Mapping[str, Mapping[str, object]]
+    invalidated_cell_ids: frozenset[str]
+    recompare_cell_ids: frozenset[str]
+    required_descendant_cell_ids: frozenset[str]
+    inherited_environments_by_revision: Mapping[str, Mapping[str, object]]
+
+    @property
+    def ancestor_revision(self) -> str:
+        return str(self.payload["ancestor_revision"])
+
+    @property
+    def ancestor_tree(self) -> str:
+        return str(self.payload["ancestor_tree"])
+
+    @property
+    def descendant_revision(self) -> str:
+        return str(self.payload["descendant_revision"])
+
+    @property
+    def descendant_tree(self) -> str:
+        return str(self.payload["descendant_tree"])
+
+    @property
+    def impact(self) -> str:
+        return str(self.payload["impact"])
+
+    def source_for_current(
+        self,
+        record: CurrentRecord,
+        *,
+        active_revision: str,
+        active_tree: str,
+    ) -> tuple[str, str] | None:
+        """Return the exact source authorized for ``record``, or reject it."""
+
+        provenance = record.result.get("provenance")
+        if not isinstance(provenance, Mapping):
+            return None
+        revision = provenance.get("report_source_revision")
+        tree = provenance.get("report_source_tree")
+        if (
+            revision == active_revision
+            and tree == active_tree
+            and provenance.get("report_measured_source_revision") == active_revision
+            and provenance.get("report_measured_source_tree") == active_tree
+        ):
+            return active_revision, active_tree
+        if record.cell_id in self.required_descendant_cell_ids:
+            return None
+        pin = self.retained_by_cell.get(record.cell_id)
+        if pin is None:
+            return None
+        if (
+            record.attempt_id != pin.get("attempt_id")
+            or record.manifest_sha256 != pin.get("manifest_sha256")
+            or _file_digest(
+                record.manifest_path.parent.parent.parent / "current.json"
+            )
+            != pin.get("current_pointer_sha256")
+            or _file_digest(record.result_path) != pin.get("result_sha256")
+            or revision != pin.get("source_revision")
+            or tree != pin.get("source_tree")
+            or provenance.get("report_measured_source_revision") != revision
+            or provenance.get("report_measured_source_tree") != tree
+        ):
+            return None
+        return str(revision), str(tree)
+
+    def environment_for_source(self, revision: str) -> Mapping[str, object] | None:
+        if revision == self.ancestor_revision:
+            value = self.payload.get("ancestor_environment")
+        elif revision == self.descendant_revision:
+            value = self.payload.get("descendant_environment")
+        else:
+            return self.inherited_environments_by_revision.get(revision)
+        return value if isinstance(value, Mapping) else None
+
+
+def _validated_pins(
+    payload: Mapping[str, object],
+    field: str,
+) -> tuple[dict[str, object], ...]:
+    raw = payload.get(field)
+    if not isinstance(raw, list):
+        raise MeasurementLineageError(f"measurement lineage {field} must be an array")
+    pins: list[dict[str, object]] = []
+    seen: set[str] = set()
+    for value in raw:
+        if not isinstance(value, dict) or set(value) != {
+            "cell_id",
+            "attempt_id",
+            "manifest_sha256",
+            "current_locator",
+            "current_pointer_sha256",
+            "source_revision",
+            "source_tree",
+            "result_sha256",
+        }:
+            raise MeasurementLineageError(
+                f"measurement lineage {field} contains an invalid current pin"
+            )
+        cell_id = value.get("cell_id")
+        try:
+            canonical_attempt_id = (
+                str(uuid.UUID(str(value["attempt_id"])))
+                if isinstance(value.get("attempt_id"), str)
+                else None
+            )
+        except ValueError:
+            canonical_attempt_id = None
+        if (
+            not isinstance(cell_id, str)
+            or not cell_id
+            or cell_id in seen
+            or canonical_attempt_id != value.get("attempt_id")
+            or not isinstance(value.get("manifest_sha256"), str)
+            or _SHA256_RE.fullmatch(str(value["manifest_sha256"])) is None
+            or not isinstance(value.get("current_locator"), str)
+            or not str(value["current_locator"]).endswith("/current.json")
+            or Path(str(value["current_locator"])).is_absolute()
+            or any(
+                part in {"", ".", ".."}
+                for part in Path(str(value["current_locator"])).parts
+            )
+            or not isinstance(value.get("current_pointer_sha256"), str)
+            or _SHA256_RE.fullmatch(str(value["current_pointer_sha256"])) is None
+            or not isinstance(value.get("result_sha256"), str)
+            or _SHA256_RE.fullmatch(str(value["result_sha256"])) is None
+            or not isinstance(value.get("source_revision"), str)
+            or _GIT_SHA_RE.fullmatch(str(value["source_revision"])) is None
+            or not isinstance(value.get("source_tree"), str)
+            or _GIT_SHA_RE.fullmatch(str(value["source_tree"])) is None
+        ):
+            raise MeasurementLineageError(
+                f"measurement lineage {field} current pin is malformed"
+            )
+        seen.add(cell_id)
+        pins.append(dict(value))
+    if [str(pin["cell_id"]) for pin in pins] != sorted(seen):
+        raise MeasurementLineageError(
+            f"measurement lineage {field} is not sorted by cell identity"
+        )
+    return tuple(pins)
+
+
+def load_measurement_lineage(
+    repo_root: Path,
+    docs_dir: Path,
+    *,
+    expected_active_revision: str,
+    expected_active_tree: str,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> MeasurementLineage | None:
+    path = measurement_lineage_path(repo_root, docs_dir)
+    if not path.exists():
+        return None
+    payload = _load_envelope(path, expected_state="finalized")
+    profile = _profile_name(repo_root, docs_dir)
+    if (
+        payload.get("profile") != profile
+        or payload.get("class") != "C"
+        or payload.get("impact") not in _CLASS_C_IMPACTS
+        or payload.get("descendant_revision") != expected_active_revision
+        or payload.get("descendant_tree") != expected_active_tree
+    ):
+        raise MeasurementLineageError(
+            "finalized measurement lineage does not identify the active profile/source"
+        )
+    retained = _validated_pins(payload, "retained_currents")
+    invalidated = _validated_pins(payload, "invalidated_currents")
+    recompare = _validated_pins(payload, "recompare_currents")
+    impact = str(payload["impact"])
+    groups = [
+        {str(pin["cell_id"]) for pin in values}
+        for values in (retained, invalidated, recompare)
+    ]
+    if any(groups[left] & groups[right] for left in range(3) for right in range(left)):
+        raise MeasurementLineageError(
+            "measurement-lineage current authorization groups overlap"
+        )
+    all_pins = (*retained, *invalidated, *recompare)
+    raw_certificate = payload.get("reachability_certificate")
+    inherited_by_cell = (
+        {
+            str(pin["cell_id"]): pin
+            for pin in _summary_cap_inherited_pins(raw_certificate)
+        }
+        if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+        and isinstance(raw_certificate, Mapping)
+        else {}
+    )
+    if any(
+        (
+            pin["source_revision"] != payload["ancestor_revision"]
+            or pin["source_tree"] != payload["ancestor_tree"]
+        )
+        and dict(inherited_by_cell.get(str(pin["cell_id"]), {})) != pin
+        for pin in all_pins
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage ancestor pin identifies another source"
+        )
+    inventory_by_key = {
+        (str(row["cell_id"]), str(row["attempt_id"])): row
+        for row in payload["attempt_inventory"]  # type: ignore[union-attr]
+        if isinstance(row, Mapping)
+    }
+    for pin in all_pins:
+        key = (str(pin["cell_id"]), str(pin["attempt_id"]))
+        row = inventory_by_key.get(key)
+        manifest_locator = (
+            PurePosixPath(str(row["manifest_locator"]))
+            if row is not None
+            else None
+        )
+        canonical_current = (
+            (manifest_locator.parents[2] / "current.json").as_posix()
+            if manifest_locator is not None
+            and len(manifest_locator.parents) >= 3
+            else None
+        )
+        if (
+            row is None
+            or row.get("status") != "ok"
+            or row.get("manifest_sha256") != pin["manifest_sha256"]
+            or row.get("result_sha256") != pin["result_sha256"]
+            or pin.get("current_locator") != canonical_current
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage current pin is not bound to exactly one "
+                "successful attempt-inventory row"
+            )
+    reachability = payload["reachability_certificate"]
+    assert isinstance(reachability, Mapping)
+    if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT:
+        predecessor = reachability.get("predecessor")
+        if (
+            not isinstance(predecessor, Mapping)
+            or predecessor.get("profile") != payload.get("profile")
+            or predecessor.get("descendant_revision")
+            != payload.get("ancestor_revision")
+            or predecessor.get("descendant_tree") != payload.get("ancestor_tree")
+            or predecessor.get("descendant_environment_sha256")
+            != payload.get("ancestor_environment_sha256")
+            or _environment_invariants(
+                predecessor["ancestor_environment"]
+            )
+            != _environment_invariants(payload["ancestor_environment"])
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage summary-cap predecessor does not end at "
+                "the exact active ancestor"
+            )
+    reachability_record_ids = {
+        str(record["cell_id"])
+        for record in reachability["records"]  # type: ignore[index]
+        if isinstance(record, Mapping)
+    }
+    catalog_by_id = {
+        cell.cell_id: cell
+        for cell in catalog.measurement_cells()
+    }
+    if impact == CLASS_C_HZZ_IMPACT:
+        for record in reachability["records"]:  # type: ignore[index]
+            if not isinstance(record, Mapping):
+                continue
+            owner = record.get("artifact_owner")
+            if not isinstance(owner, Mapping):
+                raise MeasurementLineageError(
+                    "measurement-lineage artifact owner is absent"
+                )
+            consumer = catalog_by_id.get(str(owner.get("consumer_cell_id")))
+            owner_cell = catalog_by_id.get(str(owner.get("owner_cell_id")))
+            if consumer is None or owner_cell is None:
+                raise MeasurementLineageError(
+                    "measurement-lineage artifact owner is absent from the catalog"
+                )
+            relation = owner.get("relation")
+            if relation == "equivalent-matrix-peer" and (
+                not owner_cell.dataset_id.startswith("matrix_")
+                or owner_cell not in catalog.equivalent_cells(consumer)
+            ):
+                raise MeasurementLineageError(
+                    "measurement-lineage artifact owner is not the catalog matrix peer"
+                )
+            if relation == "consumer-attempt" and owner_cell != consumer:
+                raise MeasurementLineageError(
+                    "measurement-lineage direct artifact owner changed catalog cell"
+                )
+        static_target_ids = {
+            cell.cell_id for cell in hzz_impacted_cells(catalog=catalog)
+        }
+        if reachability.get("existing_catalog_target_ids") != sorted(
+            static_target_ids & reachability_record_ids
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage existing HZZ target census is inconsistent"
+            )
+    impacted_cells, agreement_cells = _impact_and_agreement_cells(
+        impact,
+        reachability,
+        catalog=catalog,
+    )
+    impacted = [
+        _cell_record(cell, catalog=catalog) for cell in impacted_cells
+    ]
+    closure = [
+        _cell_record(cell, catalog=catalog) for cell in agreement_cells
+    ]
+    if (
+        payload.get("impacted_cells") != impacted
+        or payload.get("agreement_closure_cells") != closure
+        or payload.get("impact_certificate_sha256")
+        != _digest({"impacted": impacted, "agreement_closure": closure})
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage impact/agreement closure is invalid"
+        )
+    target_ids = {cell.cell_id for cell in impacted_cells}
+    closure_ids = {cell.cell_id for cell in agreement_cells}
+    failure_ids = set(_certificate_failure_ids(impact, reachability))
+    if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT:
+        failure_record_by_cell = {
+            str(record["cell_id"]): record
+            for record in reachability["records"]  # type: ignore[index]
+            if isinstance(record, Mapping)
+        }
+        invalidated_pin_by_cell = {
+            str(pin["cell_id"]): pin for pin in invalidated
+        }
+        if any(
+            (record := failure_record_by_cell.get(cell_id)) is None
+            or (pin := invalidated_pin_by_cell.get(cell_id)) is None
+            or record.get("attempt_id") != pin.get("attempt_id")
+            or record.get("manifest_sha256") != pin.get("manifest_sha256")
+            or record.get("result_sha256") != pin.get("result_sha256")
+            for cell_id in failure_ids
+        ):
+            raise MeasurementLineageError(
+                "measurement-lineage summary-cap failure records do not match "
+                "their invalidated current pins"
+            )
+    current_ids = set().union(*groups)
+    expected_invalidated = current_ids & target_ids
+    expected_recompare = (current_ids & closure_ids) - expected_invalidated
+    if (
+        not failure_ids <= expected_invalidated | expected_recompare
+        or failure_ids & groups[0]
+        or (
+            impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+            and (
+                len(current_ids)
+                != int(reachability["successful_current_count"])
+                + len(failure_ids)
+                or int(reachability["inspected_current_count"])
+                != len(current_ids)
+                + len(_summary_cap_excluded_ids(reachability))
+            )
+        )
+        or groups[1] != expected_invalidated
+        or groups[2] != expected_recompare
+        or groups[0] != current_ids - expected_invalidated - expected_recompare
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage current groups do not match impact reachability"
+        )
+    snapshot = {
+        field: payload[field]
+        for field in (
+            "retained_currents",
+            "invalidated_currents",
+            "recompare_currents",
+            "attempt_inventory",
+            "no_attempt_cells",
+        )
+    }
+    if payload.get("current_snapshot_sha256") != _digest(snapshot):
+        raise MeasurementLineageError(
+            "measurement-lineage current snapshot digest is invalid"
+        )
+    catalog_ids = {cell.cell_id for cell in catalog.measurement_cells()}
+    attempted_ids = {
+        str(row["cell_id"])
+        for row in payload["attempt_inventory"]  # type: ignore[union-attr]
+        if isinstance(row, Mapping)
+    }
+    no_attempt_ids = set(payload["no_attempt_cells"])  # type: ignore[arg-type]
+    if (
+        attempted_ids & no_attempt_ids
+        or attempted_ids | no_attempt_ids != catalog_ids
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage attempt/no-attempt inventory does not partition "
+            "the report catalog"
+        )
+    return MeasurementLineage(
+        payload=payload,
+        retained_by_cell={str(pin["cell_id"]): pin for pin in retained},
+        invalidated_cell_ids=frozenset(groups[1]),
+        recompare_cell_ids=frozenset(groups[2]),
+        required_descendant_cell_ids=frozenset(target_ids | closure_ids),
+        inherited_environments_by_revision=(
+            {
+                str(reachability["predecessor"]["ancestor_revision"]): dict(
+                    reachability["predecessor"]["ancestor_environment"]
+                )
+            }
+            if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+            else {}
+        ),
+    )
+
+
+def audit_measurement_lineage(
+    repo_root: Path,
+    docs_dir: Path,
+    store: ArtifactStore,
+    *,
+    expected_active_source_revision: str,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    reachability_inspector: RecurrenceReachabilityInspector | None = None,
+    _loaded_lineage: MeasurementLineage | None = None,
+) -> dict[str, object]:
+    """Audit source, environment, pins, and impact closure without mutation."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    active = _git_commit(root, expected_active_source_revision)
+    active_tree = _git_tree(root, active)
+    lineage = _loaded_lineage or load_measurement_lineage(
+        root,
+        docs_dir,
+        expected_active_revision=active,
+        expected_active_tree=active_tree,
+        catalog=catalog,
+    )
+    if lineage is None:
+        raise MeasurementLineageError("profile has no finalized measurement lineage")
+    payload = lineage.payload
+    expected_diff = _diff_records(
+        root,
+        ancestor=lineage.ancestor_revision,
+        descendant=lineage.descendant_revision,
+        impact=str(payload["impact"]),
+    )
+    reachability = payload["reachability_certificate"]
+    assert isinstance(reachability, Mapping)
+    impact = str(payload["impact"])
+    impacted_cells, agreement_cells = _impact_and_agreement_cells(
+        impact,
+        reachability,
+        catalog=catalog,
+    )
+    impacted = [
+        _cell_record(cell, catalog=catalog) for cell in impacted_cells
+    ]
+    closure = [
+        _cell_record(cell, catalog=catalog) for cell in agreement_cells
+    ]
+    workspace_manifest = _workspace_manifest_identity(
+        root,
+        docs_dir,
+        ancestor_revision=lineage.ancestor_revision,
+        descendant_revision=lineage.descendant_revision,
+    )
+    active_agreement_graph = _agreement_digest(catalog)
+    if (
+        payload.get("git_diff") != list(expected_diff)
+        or payload.get("git_diff_sha256") != _digest(expected_diff)
+        or payload.get("catalog_sha256") != _catalog_digest(catalog)
+        or not _agreement_graph_digest_matches(
+            payload,
+            active_agreement_graph,
+        )
+        or payload.get("workspace_manifest") != workspace_manifest
+        or payload.get("workspace_manifest_sha256")
+        != _digest(workspace_manifest)
+        or payload.get("campaign_policy_sha256")
+        != workspace_manifest["campaign_policy_sha256"]
+        or payload.get("impacted_cells") != impacted
+        or payload.get("agreement_closure_cells") != closure
+        or payload.get("impact_certificate_sha256")
+        != _digest({"impacted": impacted, "agreement_closure": closure})
+    ):
+        raise MeasurementLineageError(
+            "measurement-lineage source, policy, catalog, or impact certificate changed"
+        )
+    profile = _profile_name(root, docs_dir)
+    descendant_environment = _environment(
+        docs_dir / "report_environment.json",
+        expected_profile=profile,
+    )
+    if (
+        payload.get("descendant_environment") != descendant_environment
+        or payload.get("descendant_environment_sha256")
+        != _digest(descendant_environment)
+    ):
+        raise MeasurementLineageError(
+            "active profile environment differs from the finalized lineage"
+        )
+    ancestor_environment = payload.get("ancestor_environment")
+    if not isinstance(ancestor_environment, Mapping):
+        raise MeasurementLineageError(
+            "Class-C runtime invariant proof no longer holds"
+        )
+    try:
+        _require_environment_transition(
+            impact=impact,
+            ancestor_revision=lineage.ancestor_revision,
+            descendant_revision=lineage.descendant_revision,
+            ancestor_environment=ancestor_environment,
+            descendant_environment=descendant_environment,
+        )
+    except MeasurementLineageError as error:
+        raise MeasurementLineageError(
+            "Class-C runtime invariant proof no longer holds"
+        ) from error
+    missing_retained: list[str] = []
+    for cell_id, pin in lineage.retained_by_cell.items():
+        current = store.load_current(cell_id, missing_ok=True)
+        if (
+            current is None
+            or lineage.source_for_current(
+                current,
+                active_revision=active,
+                active_tree=active_tree,
+            )
+            != (pin.get("source_revision"), pin.get("source_tree"))
+        ):
+            missing_retained.append(cell_id)
+    if missing_retained:
+        raise MeasurementLineageError(
+            "retained ancestor currents changed or disappeared: "
+            + ", ".join(missing_retained[:8])
+        )
+    missing_history: list[str] = []
+    inventory_by_key: dict[tuple[str, str], Mapping[str, object]] = {}
+    for raw in payload["attempt_inventory"]:  # type: ignore[union-attr]
+        assert isinstance(raw, Mapping)
+        locator = raw.get("manifest_locator")
+        if not isinstance(locator, str):
+            missing_history.append("<invalid locator>")
+            continue
+        try:
+            manifest_path = _artifact_member(
+                store.artifact_root,
+                locator,
+                context="historical attempt manifest",
+            )
+        except MeasurementLineageError:
+            missing_history.append(locator)
+            continue
+        try:
+            observed = _validated_attempt_inventory_row(
+                store,
+                manifest_path,
+                expected_cell_id=str(raw["cell_id"]),
+            )
+        except MeasurementLineageError:
+            missing_history.append(locator)
+            continue
+        if observed != dict(raw):
+            missing_history.append(locator)
+            continue
+        inventory_by_key[(str(raw["cell_id"]), str(raw["attempt_id"]))] = raw
+    if missing_history:
+        raise MeasurementLineageError(
+            "immutable historical attempt evidence changed or disappeared: "
+            + ", ".join(missing_history[:8])
+        )
+    certificate = payload["reachability_certificate"]
+    assert isinstance(certificate, Mapping)
+    by_cell = {cell.cell_id: cell for cell in catalog.measurement_cells()}
+    failure_ids = set(_certificate_failure_ids(impact, certificate))
+    historical_status_errors: list[str] = []
+    for field in (
+        "retained_currents",
+        "invalidated_currents",
+        "recompare_currents",
+    ):
+        for pin in payload[field]:  # type: ignore[index]
+            assert isinstance(pin, Mapping)
+            cell_id = str(pin["cell_id"])
+            key = (cell_id, str(pin["attempt_id"]))
+            inventory = inventory_by_key.get(key)
+            if inventory is None:
+                historical_status_errors.append(cell_id)
+                continue
+            try:
+                manifest_path = _artifact_member(
+                    store.artifact_root,
+                    inventory["manifest_locator"],
+                    context="historical pinned attempt manifest",
+                )
+                historical = store._validate_attempt_manifest(
+                    manifest_path,
+                    expected_cell_id=cell_id,
+                    expected_attempt_id=key[1],
+                    expected_digest=str(inventory["manifest_sha256"]),
+                )
+                if cell_id in failure_ids:
+                    cell = by_cell.get(cell_id)
+                    if cell is None:
+                        raise MeasurementLineageError(
+                            f"{cell_id}: historical failure is absent from the catalog"
+                        )
+                    if impact == CLASS_C_HZZ_IMPACT:
+                        _validate_numerical_validation_failure(historical, cell)
+                    else:
+                        _validate_recurrence_summary_cap_failure(
+                            store,
+                            historical,
+                            cell,
+                            expected_bytes=(
+                                _RECURRENCE_SUMMARY_CAP_FAILURE_BYTES[cell_id]
+                            ),
+                        )
+                elif historical.result.get("status") != ResultStatus.OK.value:
+                    raise MeasurementLineageError(
+                        f"{cell_id}: non-successful current was selected for "
+                        "retention or replacement without failure evidence"
+                    )
+            except Exception:
+                historical_status_errors.append(cell_id)
+    if historical_status_errors:
+        raise MeasurementLineageError(
+            "historical current status or failure evidence changed: "
+            + ", ".join(historical_status_errors[:8])
+        )
+    inspect = (
+        reachability_inspector
+        if reachability_inspector is not None
+        else lambda record, cell: _default_recurrence_reachability(
+            record,
+            cell,
+            store=store,
+            catalog=catalog,
+        )
+    )
+    changed_reachability: list[str] = []
+    for raw_record in certificate["records"]:  # type: ignore[index]
+        assert isinstance(raw_record, Mapping)
+        key = (
+            str(raw_record["cell_id"]),
+            str(raw_record["attempt_id"]),
+        )
+        inventory = inventory_by_key.get(key)
+        cell = by_cell.get(key[0])
+        if inventory is None or cell is None:
+            changed_reachability.append(key[0])
+            continue
+        manifest_path = _artifact_member(
+            store.artifact_root,
+            inventory["manifest_locator"],
+            context="reachability attempt manifest",
+        )
+        try:
+            historical = store._validate_attempt_manifest(
+                manifest_path,
+                expected_cell_id=key[0],
+                expected_attempt_id=key[1],
+                expected_digest=str(inventory["manifest_sha256"]),
+            )
+            if impact == CLASS_C_HZZ_IMPACT:
+                observed_record = dict(inspect(historical, cell))
+            else:
+                observed_record = _validate_recurrence_summary_cap_failure(
+                    store,
+                    historical,
+                    cell,
+                    expected_bytes=_RECURRENCE_SUMMARY_CAP_FAILURE_BYTES[key[0]],
+                )
+        except Exception:
+            changed_reachability.append(key[0])
+            continue
+        if observed_record != dict(raw_record):
+            changed_reachability.append(key[0])
+    if changed_reachability:
+        raise MeasurementLineageError(
+            "authenticated recurrence reachability changed or cannot be replayed: "
+            + ", ".join(changed_reachability[:8])
+        )
+    excluded_by_cell: dict[str, Mapping[str, object]] = {}
+    if impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT:
+        excluded_errors: list[str] = []
+        for raw_record in certificate[
+            "excluded_non_success_currents"
+        ]:  # type: ignore[index]
+            assert isinstance(raw_record, Mapping)
+            cell_id = str(raw_record["cell_id"])
+            excluded_by_cell[cell_id] = raw_record
+            key = (cell_id, str(raw_record["attempt_id"]))
+            inventory = inventory_by_key.get(key)
+            cell = by_cell.get(cell_id)
+            if inventory is None or cell is None:
+                excluded_errors.append(cell_id)
+                continue
+            try:
+                manifest_path = _artifact_member(
+                    store.artifact_root,
+                    inventory["manifest_locator"],
+                    context="excluded terminal attempt manifest",
+                )
+                historical = store._validate_attempt_manifest(
+                    manifest_path,
+                    expected_cell_id=cell_id,
+                    expected_attempt_id=key[1],
+                    expected_digest=str(inventory["manifest_sha256"]),
+                )
+                observed = _summary_cap_excluded_current_record(
+                    store,
+                    historical,
+                    cell,
+                )
+            except Exception:
+                excluded_errors.append(cell_id)
+                continue
+            historical_fields = (
+                set(_SUMMARY_CAP_EXCLUDED_RECORD_KEYS)
+                - {"current_locator", "current_pointer_sha256"}
+            )
+            if any(
+                observed[field] != raw_record[field]
+                for field in historical_fields
+            ) or (
+                cell_id not in lineage.required_descendant_cell_ids
+                and observed != dict(raw_record)
+            ):
+                excluded_errors.append(cell_id)
+        if excluded_errors:
+            raise MeasurementLineageError(
+                "excluded terminal current evidence changed: "
+                + ", ".join(excluded_errors[:8])
+            )
+    stale_targets: list[str] = []
+    invalidated_pin_by_cell = {
+        str(pin["cell_id"]): pin
+        for pin in payload["invalidated_currents"]  # type: ignore[index]
+        if isinstance(pin, Mapping)
+    }
+    historical_target_pin_by_cell = {
+        str(pin["cell_id"]): pin
+        for field in ("invalidated_currents", "recompare_currents")
+        for pin in payload[field]  # type: ignore[index]
+        if isinstance(pin, Mapping)
+    }
+    for cell_id in sorted(
+        lineage.required_descendant_cell_ids
+    ):
+        current = store.load_current(cell_id, missing_ok=True)
+        if current is None:
+            continue
+        provenance = current.result.get("provenance")
+        if not isinstance(provenance, Mapping):
+            pin = invalidated_pin_by_cell.get(cell_id)
+            excluded = excluded_by_cell.get(cell_id)
+            if (
+                impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+                and cell_id in failure_ids
+                and pin is not None
+                and current.attempt_id == pin.get("attempt_id")
+                and current.manifest_sha256 == pin.get("manifest_sha256")
+                and _file_digest(current.result_path) == pin.get("result_sha256")
+                and _file_digest(
+                    current.manifest_path.parent.parent.parent / "current.json"
+                )
+                == pin.get("current_pointer_sha256")
+            ):
+                continue
+            if (
+                excluded is not None
+                and current.attempt_id == excluded.get("attempt_id")
+                and current.manifest_sha256 == excluded.get("manifest_sha256")
+                and _file_digest(current.result_path)
+                == excluded.get("result_sha256")
+                and _file_digest(
+                    current.manifest_path.parent.parent.parent / "current.json"
+                )
+                == excluded.get("current_pointer_sha256")
+            ):
+                continue
+            stale_targets.append(cell_id)
+            continue
+        historical_pin = historical_target_pin_by_cell.get(cell_id)
+        if (
+            impact == CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT
+            and historical_pin is not None
+            and provenance.get("report_source_revision")
+            == historical_pin.get("source_revision")
+            and provenance.get("report_source_tree")
+            == historical_pin.get("source_tree")
+            and provenance.get("report_measured_source_revision")
+            == historical_pin.get("source_revision")
+            and provenance.get("report_measured_source_tree")
+            == historical_pin.get("source_tree")
+            and current.attempt_id == historical_pin.get("attempt_id")
+            and current.manifest_sha256
+            == historical_pin.get("manifest_sha256")
+            and _file_digest(current.result_path)
+            == historical_pin.get("result_sha256")
+            and _file_digest(
+                current.manifest_path.parent.parent.parent / "current.json"
+            )
+            == historical_pin.get("current_pointer_sha256")
+        ):
+            continue
+        if (
+            provenance.get("report_source_revision") == lineage.ancestor_revision
+            and provenance.get("report_source_tree") == lineage.ancestor_tree
+            and provenance.get("report_measured_source_revision")
+            == lineage.ancestor_revision
+            and provenance.get("report_measured_source_tree")
+            == lineage.ancestor_tree
+        ):
+            # This historical pointer remains immutable evidence, but the
+            # scheduler and service must not authorize it as fresh.
+            continue
+        if (
+            provenance.get("report_source_revision") != active
+            or provenance.get("report_source_tree") != active_tree
+            or provenance.get("report_measured_source_revision") != active
+            or provenance.get("report_measured_source_tree") != active_tree
+        ):
+            stale_targets.append(cell_id)
+    if stale_targets:
+        raise MeasurementLineageError(
+            "Class-C target current has an unauthorized source: "
+            + ", ".join(stale_targets[:8])
+        )
+    return {
+        "schema": MEASUREMENT_LINEAGE_SCHEMA,
+        "profile": profile,
+        "impact": payload["impact"],
+        "ancestor_revision": lineage.ancestor_revision,
+        "descendant_revision": lineage.descendant_revision,
+        "retained_current_count": len(lineage.retained_by_cell),
+        "invalidated_current_count": len(lineage.invalidated_cell_ids),
+        "recompare_current_count": len(lineage.recompare_cell_ids),
+        "impacted_cell_count": len(impacted),
+        "agreement_closure_cell_count": len(closure),
+        "runtime_invariants_match": True,
+    }
+
+
+def load_and_audit_measurement_lineage(
+    repo_root: Path,
+    docs_dir: Path,
+    store: ArtifactStore,
+    *,
+    expected_active_source_revision: str,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    reachability_inspector: RecurrenceReachabilityInspector | None = None,
+) -> MeasurementLineage | None:
+    """Load one lineage object once and fully authenticate it under its lock."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    active = _git_commit(root, expected_active_source_revision)
+    active_tree = _git_tree(root, active)
+    with store.named_lock("measurement-lineage"):
+        lineage = load_measurement_lineage(
+            root,
+            docs_dir,
+            expected_active_revision=active,
+            expected_active_tree=active_tree,
+            catalog=catalog,
+        )
+        if lineage is None:
+            stale: list[str] = []
+            for current in store.recover_current_records():
+                provenance = current.result.get("provenance")
+                if not isinstance(provenance, Mapping):
+                    continue
+                measured_revision = provenance.get("report_measured_source_revision")
+                measured_tree = provenance.get("report_measured_source_tree")
+                if measured_revision is not None and (
+                    provenance.get("report_source_revision") != active
+                    or measured_revision != active
+                    or provenance.get("report_source_tree") != active_tree
+                    or measured_tree != active_tree
+                ):
+                    stale.append(current.cell_id)
+            if stale:
+                raise MeasurementLineageError(
+                    "profile has mixed/ancestor measurements but no authenticated "
+                    "measurement lineage: "
+                    + ", ".join(sorted(stale)[:8])
+                )
+            return None
+        audit_measurement_lineage(
+            root,
+            docs_dir,
+            store,
+            expected_active_source_revision=active,
+            catalog=catalog,
+            reachability_inspector=reachability_inspector,
+            _loaded_lineage=lineage,
+        )
+        if (
+            _load_envelope(
+                measurement_lineage_path(root, docs_dir),
+                expected_state="finalized",
+            )
+            != dict(lineage.payload)
+        ):
+            raise MeasurementLineageError(
+                "measurement lineage changed during authentication"
+            )
+        return lineage
+
+
+__all__ = [
+    "CLASS_C_HZZ_IMPACT",
+    "CLASS_C_RECURRENCE_SUMMARY_CAP_IMPACT",
+    "MEASUREMENT_LINEAGE_FILENAME",
+    "MEASUREMENT_LINEAGE_SCHEMA",
+    "MeasurementLineage",
+    "MeasurementLineageError",
+    "audit_measurement_lineage",
+    "finalize_class_c_bridge",
+    "hzz_agreement_closure",
+    "hzz_impacted_cells",
+    "load_and_audit_measurement_lineage",
+    "load_measurement_lineage",
+    "measurement_lineage_path",
+    "prepare_class_c_bridge",
+    "recurrence_summary_cap_agreement_closure",
+    "recurrence_summary_cap_impacted_cells",
+    "signed_zero_helicity_agreement_closure",
+    "signed_zero_helicity_impacted_cells",
+]
diff --git a/pyamplicol/tools/performance_report/models.py b/pyamplicol/tools/performance_report/models.py
new file mode 100644
index 0000000000..ff8fd4023d
--- /dev/null
+++ b/pyamplicol/tools/performance_report/models.py
@@ -0,0 +1,227 @@
+# SPDX-License-Identifier: 0BSD
+"""Typed contracts shared by the report catalog, runner, cache, and renderer."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Literal
+
+LEGACY_AMPLICOL_MAX_OPEN_QUARK_LINES = 3
+_QUARK_TOKENS = frozenset({"d", "u", "s", "c", "b", "t"})
+_ANTIQUARK_TOKENS = frozenset(f"{token}~" for token in _QUARK_TOKENS)
+
+
+def open_quark_line_count(process: str) -> int:
+    """Return the number of open quark/antiquark lines in a concrete process."""
+
+    initial, separator, final = process.partition(">")
+    if not separator:
+        raise ValueError(f"process has no initial/final separator: {process!r}")
+    tokens = (*initial.split(), *final.split())
+    quarks = sum(token in _QUARK_TOKENS for token in tokens)
+    antiquarks = sum(token in _ANTIQUARK_TOKENS for token in tokens)
+    if quarks != antiquarks:
+        raise ValueError(
+            "concrete report process has unpaired quark content: "
+            f"{process!r} ({quarks} quarks, {antiquarks} antiquarks)"
+        )
+    return quarks
+
+
+class Accuracy(StrEnum):
+    LC = "lc"
+    NLC = "nlc"
+    FULL = "full"
+
+
+class ExecutionMode(StrEnum):
+    AMPLICOL = "amplicol"
+    MADGRAPH = "madgraph"
+    RECURRENCE = "recurrence"
+    COMPILED = "compiled"
+    EAGER = "eager"
+    ON_THE_FLY = "on-the-fly"
+
+
+class ModelKey(StrEnum):
+    BUILTIN_SM = "builtin_sm"
+    UFO_SM = "ufo_sm"
+    SCALAR_CONTACT = "scalar_contact"
+    SCALAR_GRAVITY = "scalar_gravity"
+
+
+class Workload(StrEnum):
+    SELECTED_FLOW = "selected-flow"
+    ALL_FLOW = "all-flow"
+    CONTRACTED = "contracted"
+
+
+class ArtifactPolicy(StrEnum):
+    REUSE = "reuse"
+    RETIME = "retime"
+    REGENERATE = "regenerate"
+
+
+class ResultStatus(StrEnum):
+    NOT_AVAILABLE = "not_available"
+    OK = "ok"
+    FAILED = "failed"
+    TIMEOUT = "timeout"
+    MEMORY_LIMIT = "memory_limit"
+    SKIP = "skip"
+    VALIDATION_FAILED = "validation_failed"
+    UNVERIFIED = "unverified"
+    ERROR = "error"
+    UNSUPPORTED = "unsupported"
+
+
+@dataclass(frozen=True, slots=True)
+class ModelSpec:
+    key: ModelKey
+    profile: str
+    label: str
+    source_kind: Literal["built-in-sm", "json"]
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessFamily:
+    identifier: int
+    key: str
+    label_tex: str
+    initial_state: tuple[str, ...]
+    base_final_state: tuple[str, ...]
+    maximum_lc_n: int
+    maximum_contracted_n: int = 5
+    include_3qqbar: bool = False
+    include_cc: bool = False
+    include_resonance: bool = False
+
+    @property
+    def minimum_n(self) -> int:
+        return len(self.base_final_state)
+
+    def maximum_n(self, accuracy: Accuracy) -> int:
+        return (
+            self.maximum_lc_n
+            if accuracy is Accuracy.LC
+            else self.maximum_contracted_n
+        )
+
+    def process(self, n_final: int) -> str | None:
+        extra_gluons = n_final - self.minimum_n
+        if extra_gluons < 0:
+            return None
+        final_state = (*self.base_final_state, *("g" for _ in range(extra_gluons)))
+        return f"{' '.join(self.initial_state)} > {' '.join(final_state)}"
+
+
+@dataclass(frozen=True, slots=True)
+class MeasurementSpec:
+    execution_mode: ExecutionMode
+    model: ModelKey | None
+    accuracy: Accuracy
+    backend: str
+    jit_optimization_level: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class MatrixDataset:
+    dataset_id: str
+    title: str
+    table_name: str
+    cache_name: str
+    candidate: MeasurementSpec
+    baseline: MeasurementSpec
+    multiplicities: tuple[int, ...]
+    static_na_reason_code: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class MatrixComparisonView:
+    """One rendered matrix comparison backed by shared measurement datasets.
+
+    A view deliberately identifies its candidate and reference datasets by ID
+    instead of duplicating either measurement surface.  In particular, the
+    MadGraph recurrence view can reuse the existing UFO-SM/full recurrence
+    profile while presenting it against the independent MadGraph reference.
+    """
+
+    comparison_id: str
+    candidate_dataset_id: str
+    baseline_dataset_id: str
+    title: str
+    table_name: str
+
+
+@dataclass(frozen=True, slots=True)
+class ScalarDataset:
+    dataset_id: str
+    title: str
+    table_name: str
+    cache_name: str
+    model: ModelKey
+    process_template: str
+    final_particle: str
+    multiplicities: tuple[int, ...]
+    measurement: MeasurementSpec
+
+    def process(self, n_final: int) -> str:
+        final_state = " ".join(self.final_particle for _ in range(n_final))
+        return f"scalar_0 scalar_0 > {final_state}"
+
+
+@dataclass(frozen=True, slots=True)
+class ZVariant:
+    key: str
+    label: str
+    execution_mode: ExecutionMode
+    backend: str
+    jit_optimization_level: int | None = None
+    cpp_optimization: str | None = None
+    maximum_generation_n_final: int | None = None
+    static_na_reason_code: str | None = None
+
+    def __post_init__(self) -> None:
+        maximum = self.maximum_generation_n_final
+        reason = self.static_na_reason_code
+        if maximum is not None and (
+            isinstance(maximum, bool)
+            or not isinstance(maximum, int)
+            or maximum <= 0
+        ):
+            raise ValueError("maximum_generation_n_final must be a positive integer")
+        if maximum is None and reason is not None:
+            raise ValueError(
+                "static_na_reason_code requires maximum_generation_n_final"
+            )
+        if maximum is not None and (
+            not isinstance(reason, str) or not reason.strip()
+        ):
+            raise ValueError(
+                "maximum_generation_n_final requires a static_na_reason_code"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class CellSpec:
+    dataset_id: str
+    process: str
+    n_final: int
+    process_key: str | None
+    measurement: MeasurementSpec
+    workload: Workload
+    variant: str | None = None
+
+    @property
+    def cell_id(self) -> str:
+        parts = [
+            self.dataset_id,
+            f"n{self.n_final}",
+            self.process_key,
+            self.variant,
+            self.workload.value,
+        ]
+        return "-".join(
+            part.replace("_", "-") for part in parts if part is not None
+        )
diff --git a/pyamplicol/tools/performance_report/phase_state.py b/pyamplicol/tools/performance_report/phase_state.py
new file mode 100644
index 0000000000..f785b63782
--- /dev/null
+++ b/pyamplicol/tools/performance_report/phase_state.py
@@ -0,0 +1,630 @@
+# SPDX-License-Identifier: 0BSD
+"""Authenticated atomic phase state for one performance-report worker."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import os
+import secrets
+import tempfile
+import time
+from collections.abc import Callable, Iterator, Mapping
+from contextlib import AbstractContextManager, contextmanager, nullcontext
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal, cast
+
+WORKER_PHASE_STATE_ABI = "pyamplicol-report-worker-phase-state-v1"
+WORKER_PHASE_AUTHENTICATION = "hmac-sha256"
+
+WorkerPhase = Literal[
+    "pre-generation",
+    "generation",
+    "post-generation",
+    "profiling",
+    "validation",
+    "complete",
+]
+
+_PHASE_FIELDS = frozenset(
+    {
+        "abi",
+        "run_id",
+        "worker_pid",
+        "sequence",
+        "phase",
+        "transition_monotonic_ns",
+        "generation_started_monotonic_ns",
+        "generation_finished_monotonic_ns",
+        "profiling_started_monotonic_ns",
+        "profiling_finished_monotonic_ns",
+        "validation_started_monotonic_ns",
+        "validation_finished_monotonic_ns",
+    }
+)
+_STATE_FIELDS = _PHASE_FIELDS | {"authentication"}
+
+
+class WorkerPhaseStateError(RuntimeError):
+    """Raised when worker phase evidence is absent, malformed, or unauthenticated."""
+
+
+@dataclass(frozen=True, slots=True)
+class WorkerPhaseChannel:
+    """Parent-issued credentials for one worker phase-state file."""
+
+    path: Path
+    run_id: str
+    authentication_key: str
+
+    def __post_init__(self) -> None:
+        if not self.path.is_absolute():
+            raise ValueError("worker phase-state path must be absolute")
+        if len(self.run_id) != 32 or any(
+            character not in "0123456789abcdef" for character in self.run_id
+        ):
+            raise ValueError("worker phase-state run_id must be 128-bit lowercase hex")
+        if len(self.authentication_key) != 64 or any(
+            character not in "0123456789abcdef" for character in self.authentication_key
+        ):
+            raise ValueError(
+                "worker phase-state authentication key must be 256-bit lowercase hex"
+            )
+
+    @classmethod
+    def create(cls, path: Path) -> WorkerPhaseChannel:
+        """Create fresh credentials bound to ``path``."""
+
+        return cls(
+            path=path.expanduser().resolve(strict=False),
+            run_id=secrets.token_hex(16),
+            authentication_key=secrets.token_hex(32),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class WorkerPhaseState:
+    """One authenticated phase transition written by the worker."""
+
+    run_id: str
+    worker_pid: int
+    sequence: int
+    phase: WorkerPhase
+    transition_monotonic_ns: int
+    generation_started_monotonic_ns: int | None
+    generation_finished_monotonic_ns: int | None
+    profiling_started_monotonic_ns: int | None
+    profiling_finished_monotonic_ns: int | None
+    validation_started_monotonic_ns: int | None
+    validation_finished_monotonic_ns: int | None
+    sha256: str
+
+    def generation_elapsed_seconds(self, *, now_seconds: float) -> float | None:
+        """Return generation duration through the authenticated boundary."""
+
+        if self.generation_started_monotonic_ns is None:
+            return None
+        stop_ns = self.generation_finished_monotonic_ns
+        if stop_ns is None:
+            stop_ns = max(
+                int(now_seconds * 1_000_000_000),
+                self.generation_started_monotonic_ns,
+            )
+        return (stop_ns - self.generation_started_monotonic_ns) / 1_000_000_000
+
+    def stage_elapsed_seconds(
+        self,
+        stage: Literal["profiling", "validation"],
+        *,
+        now_seconds: float,
+    ) -> float | None:
+        """Return an active or closed stage duration from authenticated bounds."""
+
+        if stage == "profiling":
+            started_ns = self.profiling_started_monotonic_ns
+            finished_ns = self.profiling_finished_monotonic_ns
+        else:
+            started_ns = self.validation_started_monotonic_ns
+            finished_ns = self.validation_finished_monotonic_ns
+        if started_ns is None:
+            return None
+        stop_ns = (
+            max(int(now_seconds * 1_000_000_000), started_ns)
+            if finished_ns is None
+            else finished_ns
+        )
+        return (stop_ns - started_ns) / 1_000_000_000
+
+
+def _canonical_json(payload: Mapping[str, object]) -> bytes:
+    return json.dumps(
+        payload,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+def _authentication_digest(
+    payload: Mapping[str, object],
+    authentication_key: str,
+) -> str:
+    return hmac.new(
+        bytes.fromhex(authentication_key),
+        _canonical_json(payload),
+        hashlib.sha256,
+    ).hexdigest()
+
+
+def _atomic_json(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+        dir=path.parent,
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            stream.write(_canonical_json(payload) + b"\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        temporary.replace(path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _unsigned_state(
+    *,
+    channel: WorkerPhaseChannel,
+    worker_pid: int,
+    sequence: int,
+    phase: WorkerPhase,
+    transition_monotonic_ns: int,
+    generation_started_monotonic_ns: int | None,
+    generation_finished_monotonic_ns: int | None,
+    profiling_started_monotonic_ns: int | None,
+    profiling_finished_monotonic_ns: int | None,
+    validation_started_monotonic_ns: int | None,
+    validation_finished_monotonic_ns: int | None,
+) -> dict[str, object]:
+    return {
+        "abi": WORKER_PHASE_STATE_ABI,
+        "run_id": channel.run_id,
+        "worker_pid": worker_pid,
+        "sequence": sequence,
+        "phase": phase,
+        "transition_monotonic_ns": transition_monotonic_ns,
+        "generation_started_monotonic_ns": generation_started_monotonic_ns,
+        "generation_finished_monotonic_ns": generation_finished_monotonic_ns,
+        "profiling_started_monotonic_ns": profiling_started_monotonic_ns,
+        "profiling_finished_monotonic_ns": profiling_finished_monotonic_ns,
+        "validation_started_monotonic_ns": validation_started_monotonic_ns,
+        "validation_finished_monotonic_ns": validation_finished_monotonic_ns,
+    }
+
+
+class WorkerPhaseReporter:
+    """Publish the worker's one allowed generation interval."""
+
+    def __init__(
+        self,
+        channel: WorkerPhaseChannel,
+        *,
+        worker_pid: int | None = None,
+        clock_ns: Callable[[], int] = time.monotonic_ns,
+        track_post_generation_stages: bool = False,
+        generation_gate: Callable[[], AbstractContextManager[None]] | None = None,
+    ) -> None:
+        self.channel = channel
+        self.worker_pid = os.getpid() if worker_pid is None else worker_pid
+        if self.worker_pid <= 0:
+            raise ValueError("worker phase-state PID must be positive")
+        self._clock_ns = clock_ns
+        self._track_post_generation_stages = track_post_generation_stages
+        self._generation_gate = generation_gate
+        self._phase: WorkerPhase = "pre-generation"
+        self._sequence = 0
+        self._generation_started_ns: int | None = None
+        self._generation_finished_ns: int | None = None
+        self._profiling_started_ns: int | None = None
+        self._profiling_finished_ns: int | None = None
+        self._validation_started_ns: int | None = None
+        self._validation_finished_ns: int | None = None
+        self._last_transition_ns = self._clock()
+        self._write(self._last_transition_ns)
+
+    @property
+    def phase(self) -> WorkerPhase:
+        return self._phase
+
+    def _clock(self) -> int:
+        value = self._clock_ns()
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise WorkerPhaseStateError(
+                "worker phase-state monotonic clock must return non-negative int"
+            )
+        return value
+
+    def _write(self, transition_ns: int) -> None:
+        unsigned = _unsigned_state(
+            channel=self.channel,
+            worker_pid=self.worker_pid,
+            sequence=self._sequence,
+            phase=self._phase,
+            transition_monotonic_ns=transition_ns,
+            generation_started_monotonic_ns=self._generation_started_ns,
+            generation_finished_monotonic_ns=self._generation_finished_ns,
+            profiling_started_monotonic_ns=self._profiling_started_ns,
+            profiling_finished_monotonic_ns=self._profiling_finished_ns,
+            validation_started_monotonic_ns=self._validation_started_ns,
+            validation_finished_monotonic_ns=self._validation_finished_ns,
+        )
+        _atomic_json(
+            self.channel.path,
+            {
+                **unsigned,
+                "authentication": {
+                    "kind": WORKER_PHASE_AUTHENTICATION,
+                    "digest": _authentication_digest(
+                        unsigned,
+                        self.channel.authentication_key,
+                    ),
+                },
+            },
+        )
+
+    @contextmanager
+    def generation(self) -> Iterator[None]:
+        """Mark one local generation-work interval.
+
+        The interval may be empty when the worker authenticates reuse of an
+        artifact generated by an earlier measurement.
+        """
+
+        gate = (
+            nullcontext() if self._generation_gate is None else self._generation_gate()
+        )
+        with gate:
+            if self._phase != "pre-generation":
+                raise WorkerPhaseStateError(
+                    "worker phase reporter permits exactly one generation interval"
+                )
+            started_ns = max(self._clock(), self._last_transition_ns)
+            self._phase = "generation"
+            self._sequence = 1
+            self._generation_started_ns = started_ns
+            self._last_transition_ns = started_ns
+            self._write(started_ns)
+            try:
+                yield
+            finally:
+                finished_ns = max(self._clock(), started_ns)
+                self._generation_finished_ns = finished_ns
+                self._phase = "post-generation"
+                self._sequence = 2
+                self._last_transition_ns = finished_ns
+                self._write(finished_ns)
+
+    def profiling_started(self) -> None:
+        """Close the generation guard and start the profiling-stage clock."""
+
+        if not self._track_post_generation_stages:
+            return
+        self._transition(
+            expected="post-generation",
+            phase="profiling",
+            sequence=3,
+        )
+
+    def validation_started(self) -> None:
+        """Close profiling and start the post-profile validation-stage clock."""
+
+        if not self._track_post_generation_stages:
+            return
+        self._transition(
+            expected="profiling",
+            phase="validation",
+            sequence=4,
+        )
+
+    def complete(self) -> None:
+        """Mark successful completion of all supervised worker stages."""
+
+        if not self._track_post_generation_stages:
+            return
+        self._transition(
+            expected="validation",
+            phase="complete",
+            sequence=5,
+        )
+
+    def _transition(
+        self,
+        *,
+        expected: WorkerPhase,
+        phase: WorkerPhase,
+        sequence: int,
+    ) -> None:
+        if self._phase != expected:
+            raise WorkerPhaseStateError(
+                f"worker phase transition expected {expected!r}, observed "
+                f"{self._phase!r}"
+            )
+        transition_ns = max(self._clock(), self._last_transition_ns)
+        if self._generation_finished_ns is not None:
+            transition_ns = max(transition_ns, self._generation_finished_ns)
+        if phase == "profiling":
+            self._profiling_started_ns = transition_ns
+        elif phase == "validation":
+            self._profiling_finished_ns = transition_ns
+            self._validation_started_ns = transition_ns
+        elif phase == "complete":
+            self._validation_finished_ns = transition_ns
+        self._phase = phase
+        self._sequence = sequence
+        self._last_transition_ns = transition_ns
+        self._write(transition_ns)
+
+
+def _required_int(value: object, name: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise WorkerPhaseStateError(f"{name} must be a non-negative integer")
+    return value
+
+
+def _optional_timestamp(payload: Mapping[str, object], name: str) -> int | None:
+    value = payload.get(name)
+    return None if value is None else _required_int(value, name)
+
+
+def _validated_timing(
+    payload: Mapping[str, object],
+) -> tuple[
+    WorkerPhase,
+    int,
+    int | None,
+    int | None,
+    int | None,
+    int | None,
+    int | None,
+    int | None,
+]:
+    raw_phase = payload.get("phase")
+    if raw_phase not in {
+        "pre-generation",
+        "generation",
+        "post-generation",
+        "profiling",
+        "validation",
+        "complete",
+    }:
+        raise WorkerPhaseStateError("worker phase-state phase is unsupported")
+    phase = cast(WorkerPhase, raw_phase)
+    sequence = _required_int(payload.get("sequence"), "sequence")
+    transition_ns = _required_int(
+        payload.get("transition_monotonic_ns"),
+        "transition_monotonic_ns",
+    )
+    started_raw = payload.get("generation_started_monotonic_ns")
+    finished_raw = payload.get("generation_finished_monotonic_ns")
+    started_ns = (
+        None
+        if started_raw is None
+        else _required_int(started_raw, "generation_started_monotonic_ns")
+    )
+    finished_ns = (
+        None
+        if finished_raw is None
+        else _required_int(finished_raw, "generation_finished_monotonic_ns")
+    )
+    profiling_started_ns = _optional_timestamp(
+        payload,
+        "profiling_started_monotonic_ns",
+    )
+    profiling_finished_ns = _optional_timestamp(
+        payload,
+        "profiling_finished_monotonic_ns",
+    )
+    validation_started_ns = _optional_timestamp(
+        payload,
+        "validation_started_monotonic_ns",
+    )
+    validation_finished_ns = _optional_timestamp(
+        payload,
+        "validation_finished_monotonic_ns",
+    )
+    expected_sequence = {
+        "pre-generation": 0,
+        "generation": 1,
+        "post-generation": 2,
+        "profiling": 3,
+        "validation": 4,
+        "complete": 5,
+    }[phase]
+    if sequence != expected_sequence:
+        raise WorkerPhaseStateError(
+            "worker phase-state phase and sequence are inconsistent"
+        )
+    if phase == "pre-generation":
+        if any(
+            timestamp is not None
+            for timestamp in (
+                started_ns,
+                finished_ns,
+                profiling_started_ns,
+                profiling_finished_ns,
+                validation_started_ns,
+                validation_finished_ns,
+            )
+        ):
+            raise WorkerPhaseStateError(
+                "pre-generation state cannot contain generation timestamps"
+            )
+    elif phase == "generation":
+        if (
+            started_ns != transition_ns
+            or finished_ns is not None
+            or any(
+                timestamp is not None
+                for timestamp in (
+                    profiling_started_ns,
+                    profiling_finished_ns,
+                    validation_started_ns,
+                    validation_finished_ns,
+                )
+            )
+        ):
+            raise WorkerPhaseStateError(
+                "generation state has inconsistent generation timestamps"
+            )
+    elif (
+        started_ns is None
+        or finished_ns is None
+        or finished_ns < started_ns
+        or finished_ns > transition_ns
+        or (phase == "post-generation" and finished_ns != transition_ns)
+    ):
+        raise WorkerPhaseStateError(
+            "post-generation state has inconsistent generation timestamps"
+        )
+    if phase == "post-generation":
+        stage_timestamps = (
+            profiling_started_ns,
+            profiling_finished_ns,
+            validation_started_ns,
+            validation_finished_ns,
+        )
+        valid_stages = all(timestamp is None for timestamp in stage_timestamps)
+    elif phase == "profiling":
+        valid_stages = (
+            profiling_started_ns == transition_ns
+            and profiling_finished_ns is None
+            and validation_started_ns is None
+            and validation_finished_ns is None
+        )
+    elif phase == "validation":
+        valid_stages = (
+            profiling_started_ns is not None
+            and profiling_finished_ns is not None
+            and profiling_started_ns <= profiling_finished_ns
+            and profiling_finished_ns == transition_ns
+            and validation_started_ns == transition_ns
+            and validation_finished_ns is None
+        )
+    elif phase == "complete":
+        valid_stages = (
+            profiling_started_ns is not None
+            and profiling_finished_ns is not None
+            and profiling_started_ns <= profiling_finished_ns
+            and validation_started_ns == profiling_finished_ns
+            and validation_finished_ns == transition_ns
+            and validation_started_ns <= validation_finished_ns
+        )
+    else:
+        valid_stages = True
+    if not valid_stages:
+        raise WorkerPhaseStateError(
+            "worker phase-state has inconsistent profiling/validation timestamps"
+        )
+    return (
+        phase,
+        transition_ns,
+        started_ns,
+        finished_ns,
+        profiling_started_ns,
+        profiling_finished_ns,
+        validation_started_ns,
+        validation_finished_ns,
+    )
+
+
+def read_worker_phase_state(
+    channel: WorkerPhaseChannel,
+    *,
+    expected_pid: int,
+) -> WorkerPhaseState:
+    """Read and authenticate the current atomic worker phase state."""
+
+    if expected_pid <= 0:
+        raise ValueError("expected worker PID must be positive")
+    try:
+        raw = channel.path.read_bytes()
+    except FileNotFoundError:
+        raise
+    except OSError as error:
+        raise WorkerPhaseStateError(
+            f"cannot read worker phase-state file: {error}"
+        ) from error
+    if len(raw) > 64 * 1024:
+        raise WorkerPhaseStateError("worker phase-state file is unreasonably large")
+    try:
+        decoded = json.loads(raw)
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise WorkerPhaseStateError(
+            "worker phase-state file is not valid JSON"
+        ) from error
+    if not isinstance(decoded, Mapping) or set(decoded) != _STATE_FIELDS:
+        raise WorkerPhaseStateError(
+            "worker phase-state fields do not match the authenticated ABI"
+        )
+    unsigned = {field: decoded[field] for field in _PHASE_FIELDS}
+    authentication = decoded.get("authentication")
+    if (
+        not isinstance(authentication, Mapping)
+        or set(authentication) != {"kind", "digest"}
+        or authentication.get("kind") != WORKER_PHASE_AUTHENTICATION
+        or not isinstance(authentication.get("digest"), str)
+        or not hmac.compare_digest(
+            str(authentication["digest"]),
+            _authentication_digest(unsigned, channel.authentication_key),
+        )
+    ):
+        raise WorkerPhaseStateError("worker phase-state authentication is invalid")
+    if decoded.get("abi") != WORKER_PHASE_STATE_ABI:
+        raise WorkerPhaseStateError("worker phase-state ABI is unsupported")
+    if decoded.get("run_id") != channel.run_id:
+        raise WorkerPhaseStateError("worker phase-state run_id does not match")
+    worker_pid = _required_int(decoded.get("worker_pid"), "worker_pid")
+    if worker_pid != expected_pid:
+        raise WorkerPhaseStateError(
+            "worker phase-state PID does not match supervised worker"
+        )
+    (
+        phase,
+        transition_ns,
+        started_ns,
+        finished_ns,
+        profiling_started_ns,
+        profiling_finished_ns,
+        validation_started_ns,
+        validation_finished_ns,
+    ) = _validated_timing(decoded)
+    return WorkerPhaseState(
+        run_id=channel.run_id,
+        worker_pid=worker_pid,
+        sequence=int(decoded["sequence"]),
+        phase=phase,
+        transition_monotonic_ns=transition_ns,
+        generation_started_monotonic_ns=started_ns,
+        generation_finished_monotonic_ns=finished_ns,
+        profiling_started_monotonic_ns=profiling_started_ns,
+        profiling_finished_monotonic_ns=profiling_finished_ns,
+        validation_started_monotonic_ns=validation_started_ns,
+        validation_finished_monotonic_ns=validation_finished_ns,
+        sha256=hashlib.sha256(raw).hexdigest(),
+    )
+
+
+__all__ = [
+    "WORKER_PHASE_AUTHENTICATION",
+    "WORKER_PHASE_STATE_ABI",
+    "WorkerPhaseChannel",
+    "WorkerPhaseReporter",
+    "WorkerPhaseState",
+    "WorkerPhaseStateError",
+    "read_worker_phase_state",
+]
diff --git a/pyamplicol/tools/performance_report/phase_timeline.py b/pyamplicol/tools/performance_report/phase_timeline.py
new file mode 100644
index 0000000000..fb6189590d
--- /dev/null
+++ b/pyamplicol/tools/performance_report/phase_timeline.py
@@ -0,0 +1,359 @@
+# SPDX-License-Identifier: 0BSD
+"""Directly measured phase evidence for the manual campaign dashboard."""
+
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Mapping
+from pathlib import Path
+
+from .models import ExecutionMode
+
+PHASE_TIMELINE_SCHEMA = "pyamplicol-manual-campaign-phase-timeline-v1"
+
+
+def _seconds(value: object) -> float | None:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    result = float(value)
+    if not math.isfinite(result) or result < 0.0:
+        return None
+    return result
+
+
+def _count(value: object) -> int | None:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        return None
+    return value
+
+
+def _mapping(value: object) -> Mapping[str, object]:
+    return value if isinstance(value, Mapping) else {}
+
+
+def _legacy_profile_outer_seconds(measurement: Mapping[str, object]) -> float | None:
+    chunks = measurement.get("chunks")
+    if not isinstance(chunks, list) or not chunks:
+        return None
+    durations: list[float] = []
+    for chunk in chunks:
+        values = _mapping(chunk)
+        elapsed = _seconds(values.get("elapsed_seconds"))
+        if elapsed is None:
+            return None
+        durations.append(elapsed)
+    return math.fsum(durations)
+
+
+def _entry(
+    key: str,
+    label: str,
+    seconds: float | None,
+    *,
+    status: str,
+    source: str,
+    detail: str | None = None,
+    included_in: str | None = None,
+    cpu_seconds: float | None = None,
+    peak_memory_bytes: int | None = None,
+) -> dict[str, object]:
+    return {
+        "key": key,
+        "label": label,
+        "seconds": seconds,
+        "status": status,
+        "source": source,
+        "detail": detail,
+        "included_in": included_in,
+        "cpu_seconds": cpu_seconds,
+        "peak_memory_bytes": peak_memory_bytes,
+    }
+
+
+def _progress_generation_children(path: Path | None) -> tuple[dict[str, object], ...]:
+    """Read direct progress clocks for generation children once, if available."""
+
+    if path is None or not path.is_file():
+        return ()
+    starts: dict[str, tuple[str, str | None]] = {}
+    ended: dict[str, float] = {}
+    order: list[str] = []
+    try:
+        with path.open("r", encoding="utf-8") as stream:
+            for line in stream:
+                try:
+                    event = json.loads(line)
+                except (UnicodeError, json.JSONDecodeError):
+                    continue
+                if not isinstance(event, Mapping):
+                    continue
+                task_id = event.get("task_id")
+                if not isinstance(task_id, str):
+                    continue
+                if event.get("event") == "start":
+                    description = event.get("description")
+                    parent = event.get("parent_task_id")
+                    starts[task_id] = (
+                        description if isinstance(description, str) else task_id,
+                        parent if isinstance(parent, str) else None,
+                    )
+                    order.append(task_id)
+                elif event.get("event") == "end" and event.get("success") is not False:
+                    elapsed = _seconds(event.get("elapsed_seconds"))
+                    if elapsed is not None:
+                        ended[task_id] = elapsed
+    except OSError:
+        return ()
+
+    rows: list[dict[str, object]] = []
+    for task_id in order:
+        description, parent = starts[task_id]
+        if parent != "generation" or task_id not in ended:
+            continue
+        rows.append(
+            _entry(
+                f"generation-step:{task_id.removeprefix('generation:')}",
+                description,
+                ended[task_id],
+                status="measured",
+                source="worker progress direct elapsed clock",
+                detail="included in Generation",
+                included_in="generation",
+            )
+        )
+    return tuple(rows)
+
+
+def build_phase_timeline(
+    result: Mapping[str, object],
+    *,
+    progress_path: Path | None = None,
+) -> dict[str, object]:
+    """Build a compact timeline without deriving one clock from another."""
+
+    provenance = _mapping(result.get("provenance"))
+    manual = _mapping(provenance.get("manual_campaign"))
+    identity = _mapping(manual.get("cell_identity"))
+    runtime = _mapping(provenance.get("runtime_profile"))
+    resources = _mapping(result.get("resources"))
+    execution_mode = str(identity.get("execution_mode") or "")
+    entries: list[dict[str, object]] = []
+
+    preparation = _seconds(provenance.get("model_preparation_seconds"))
+    preparation_reused = provenance.get("model_preparation_reused") is True
+    if execution_mode == ExecutionMode.AMPLICOL.value:
+        entries.append(
+            _entry(
+                "model-preparation",
+                "Model preparation",
+                None,
+                status="not_applicable",
+                source="legacy adapter",
+                detail="not applicable to original AmpliCol",
+            )
+        )
+    else:
+        entries.append(
+            _entry(
+                "model-preparation",
+                "Model preparation",
+                preparation,
+                status=(
+                    "reused"
+                    if preparation_reused
+                    else ("measured" if preparation is not None else "unavailable")
+                ),
+                source="result provenance model_preparation_seconds",
+                detail=(
+                    "prepared model reused"
+                    if preparation_reused
+                    else (
+                        None
+                        if preparation is not None
+                        else "not recorded by this result"
+                    )
+                ),
+            )
+        )
+
+    generation = _seconds(result.get("generation_seconds"))
+    entries.append(
+        _entry(
+            "generation",
+            "Generation",
+            generation,
+            status="measured" if generation is not None else "unavailable",
+            source="result generation_seconds",
+        )
+    )
+    entries.extend(_progress_generation_children(progress_path))
+
+    if execution_mode == ExecutionMode.AMPLICOL.value:
+        warmup = _mapping(runtime.get("warmup"))
+        warmup_seconds = _seconds(warmup.get("elapsed_seconds"))
+        measurement = _mapping(runtime.get("measurement"))
+        measurement_seconds = _legacy_profile_outer_seconds(measurement)
+        entries.extend(
+            (
+                _entry(
+                    "runtime-warmup",
+                    "Runtime warm-up",
+                    warmup_seconds,
+                    status=(
+                        "measured" if warmup_seconds is not None else "unavailable"
+                    ),
+                    source="legacy warmup subprocess wall clock",
+                ),
+                _entry(
+                    "runtime-calibration",
+                    "Runtime calibration",
+                    None,
+                    status="not_applicable",
+                    source="legacy adaptive point calculation",
+                    detail="no timed calibration phase",
+                ),
+                _entry(
+                    "runtime-measurement",
+                    "Timed profiling",
+                    measurement_seconds,
+                    status=(
+                        "measured" if measurement_seconds is not None else "unavailable"
+                    ),
+                    source="sum of legacy profiling subprocess wall clocks",
+                    detail=(
+                        None
+                        if _count(measurement.get("chunk_count")) is None
+                        else f"{_count(measurement.get('chunk_count'))} chunks"
+                    ),
+                ),
+            )
+        )
+    else:
+        warmup_seconds = _seconds(runtime.get("warmup_elapsed_seconds"))
+        calibration_seconds = _seconds(runtime.get("calibration_outer_elapsed_seconds"))
+        if calibration_seconds is None and execution_mode in {
+            ExecutionMode.COMPILED.value,
+            ExecutionMode.EAGER.value,
+        }:
+            calibration_seconds = _seconds(runtime.get("calibration_elapsed_seconds"))
+        measurement_seconds = _seconds(runtime.get("achieved_runtime_seconds"))
+        if measurement_seconds is None:
+            measurement_seconds = _seconds(
+                runtime.get("measurement_phase_elapsed_seconds")
+            )
+        profile_total = _seconds(runtime.get("profile_total_elapsed_seconds"))
+        attribution = _seconds(runtime.get("profile_attribution_elapsed_seconds"))
+        if attribution is None:
+            attribution = _seconds(runtime.get("evaluator_elapsed_seconds"))
+        sample_count = _count(runtime.get("completed_sample_count"))
+        entries.extend(
+            (
+                _entry(
+                    "runtime-warmup",
+                    "Runtime warm-up",
+                    warmup_seconds,
+                    status=(
+                        "measured" if warmup_seconds is not None else "unavailable"
+                    ),
+                    source="benchmark warm-up wall clock",
+                ),
+                _entry(
+                    "runtime-calibration",
+                    "Runtime calibration",
+                    calibration_seconds,
+                    status=(
+                        "measured" if calibration_seconds is not None else "unavailable"
+                    ),
+                    source="benchmark calibration wall clock",
+                    detail=(
+                        None
+                        if _count(runtime.get("calibration_block_count")) is None
+                        else (
+                            f"{_count(runtime.get('calibration_block_count'))} blocks"
+                        )
+                    ),
+                ),
+                _entry(
+                    "runtime-measurement",
+                    "Timed headline measurement",
+                    measurement_seconds,
+                    status=(
+                        "measured" if measurement_seconds is not None else "unavailable"
+                    ),
+                    source="accumulated benchmark headline outer wall clock",
+                    detail=(
+                        None if sample_count is None else f"{sample_count} samples"
+                    ),
+                ),
+                _entry(
+                    "runtime-attribution",
+                    "Profiling attribution",
+                    attribution,
+                    status="measured" if attribution is not None else "unavailable",
+                    source="native profile-call outer wall clock",
+                    detail="separate from wall/evaluator-total/core metrics",
+                ),
+                _entry(
+                    "runtime-profile-total",
+                    "Complete runtime profile",
+                    profile_total,
+                    status=("measured" if profile_total is not None else "unavailable"),
+                    source="profile operation outer wall clock",
+                    detail="contains warm-up, calibration, measurement and attribution",
+                ),
+            )
+        )
+
+    validation_completed = result.get("validation") is not None
+    entries.extend(
+        (
+            _entry(
+                "post-profile-validation",
+                "Post-profile validation",
+                None,
+                status="completed" if validation_completed else "unavailable",
+                source="result validation status",
+                detail=(
+                    "completed; duration not separately timed"
+                    if validation_completed
+                    else "status and duration not separately recorded"
+                ),
+            ),
+            _entry(
+                "attempt-publication",
+                "Result publication",
+                None,
+                status="completed",
+                source="atomic attempt publication",
+                detail="completed; duration not separately timed",
+            ),
+        )
+    )
+
+    worker_wall = _seconds(resources.get("wall_seconds"))
+    peak_rss = _count(resources.get("peak_rss_bytes"))
+    peak_guard = _count(resources.get("peak_guard_bytes"))
+    cpu_seconds = _seconds(resources.get("cpu_seconds"))
+    entries.append(
+        _entry(
+            "worker-supervision",
+            "Worker supervision",
+            worker_wall,
+            status="observed" if worker_wall is not None else "unavailable",
+            source="resource supervisor sample",
+            detail="overall observed worker wall; phase rows may overlap",
+            cpu_seconds=cpu_seconds,
+            peak_memory_bytes=peak_guard or peak_rss,
+        )
+    )
+    return {
+        "schema": PHASE_TIMELINE_SCHEMA,
+        "entries": entries,
+        "total_worker_wall_seconds": worker_wall,
+        "peak_rss_bytes": peak_rss,
+        "peak_guard_bytes": peak_guard,
+    }
+
+
+__all__ = ["PHASE_TIMELINE_SCHEMA", "build_phase_timeline"]
diff --git a/pyamplicol/tools/performance_report/prepared.py b/pyamplicol/tools/performance_report/prepared.py
new file mode 100644
index 0000000000..97e5ba4ae4
--- /dev/null
+++ b/pyamplicol/tools/performance_report/prepared.py
@@ -0,0 +1,410 @@
+# SPDX-License-Identifier: 0BSD
+"""Deterministic, lock-protected prepared-model assets for report workers."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import platform
+import tempfile
+import uuid
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from pyamplicol.reporting import ProgressSink
+
+from .artifacts import ArtifactStore
+from .models import ModelKey
+from .runner import _model_source_path
+
+PREPARED_RECORD_SCHEMA = "pyamplicol-report-prepared-model-v1"
+PUBLIC_MODEL_COMPILE_COMMAND_PATH = "pyamplicol-model-compile-parse-resolve-dispatch-v1"
+
+
+class PreparedModelError(RuntimeError):
+    """Raised when a report prepared-model bundle is absent or invalid."""
+
+
+class CompilableModelSource(Protocol):
+    def compile(
+        self,
+        *,
+        cache_dir: os.PathLike[str] | str | None = None,
+        use_cache: bool = True,
+        require_supported: bool = True,
+        prepared_output: os.PathLike[str] | str | None = None,
+        evaluator: object | None = None,
+    ) -> object: ...
+
+
+class _PublicCliModelCompiler:
+    """Compile a report bundle through the real public model CLI path."""
+
+    command_path = PUBLIC_MODEL_COMPILE_COMMAND_PATH
+
+    def __init__(self, source: str, *, progress: ProgressSink | None = None) -> None:
+        self.source = source
+        self.progress = progress
+
+    def compile(
+        self,
+        *,
+        cache_dir: os.PathLike[str] | str | None = None,
+        use_cache: bool = True,
+        require_supported: bool = True,
+        prepared_output: os.PathLike[str] | str | None = None,
+        evaluator: object | None = None,
+    ) -> object:
+        if not require_supported:
+            raise PreparedModelError(
+                "report prepared-model compilation must require supported models"
+            )
+        if prepared_output is None or evaluator is None:
+            raise PreparedModelError(
+                "public model compilation requires an output and evaluator"
+            )
+
+        from pyamplicol.cli import CliInvocation, parse_cli
+        from pyamplicol.cli.handlers import DefaultCliServices, dispatch
+        from pyamplicol.reporting import NullProgressSink
+
+        output = Path(prepared_output).expanduser().resolve(strict=False)
+        backend = getattr(getattr(evaluator, "backend", None), "value", None)
+        execution_mode = getattr(
+            getattr(evaluator, "execution_mode", None),
+            "value",
+            None,
+        )
+        optimization = getattr(evaluator, "optimization", None)
+        cores = getattr(optimization, "cores", None)
+        jit = getattr(evaluator, "jit", None)
+        optimization_level = getattr(jit, "optimization_level", None)
+        compression = getattr(jit, "compress", None)
+        if (
+            backend != "jit"
+            or execution_mode not in {"compiled", "eager", "recurrence"}
+            or isinstance(cores, bool)
+            or not isinstance(cores, int)
+            or cores < 1
+            or isinstance(optimization_level, bool)
+            or not isinstance(optimization_level, int)
+            or (compression != "auto" and not isinstance(compression, bool))
+        ):
+            raise PreparedModelError(
+                "report prepared-model CLI requires a concrete JIT evaluator"
+            )
+        arguments = [
+            "model",
+            "compile",
+            self.source,
+            os.fspath(output),
+            "--backend",
+            backend,
+            "--cores",
+            str(cores),
+            "--jit-optimization-level",
+            str(optimization_level),
+            "--set",
+            f"evaluator.execution_mode={execution_mode}",
+            "--set",
+            f"evaluator.jit.compress={str(compression).lower()}",
+            "--model-cache" if use_cache else "--no-model-cache",
+        ]
+        if cache_dir is not None:
+            arguments.extend(("--model-cache-dir", os.fspath(cache_dir)))
+        invocation = parse_cli(tuple(arguments))
+        if not isinstance(invocation, CliInvocation):
+            raise PreparedModelError(
+                "public model compile parser returned a non-command invocation"
+            )
+        resolution = invocation.resolve()
+        if resolution.requested.evaluator != evaluator:
+            raise PreparedModelError(
+                "public model compile arguments changed the report evaluator settings"
+            )
+        result = dispatch(
+            resolution.effective,
+            DefaultCliServices(resolution=resolution),
+            self.progress or NullProgressSink(),
+            dry_run=invocation.dry_run,
+        )
+        if not isinstance(result, Mapping):
+            raise PreparedModelError(
+                "public model compile returned a non-object result"
+            )
+        raw_output = result.get("output")
+        if (
+            not isinstance(raw_output, str)
+            or Path(raw_output).expanduser().resolve(strict=False) != output
+        ):
+            raise PreparedModelError(
+                "public model compile did not publish the requested bundle"
+            )
+        return result
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _canonical_bytes(payload: object) -> bytes:
+    return (
+        json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        + "\n"
+    ).encode("ascii")
+
+
+def _atomic_write(path: Path, payload: object) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(
+        dir=path.parent,
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            stream.write(_canonical_bytes(payload))
+            stream.flush()
+            os.fsync(stream.fileno())
+        temporary.replace(path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def prepared_identity(
+    *,
+    model: ModelKey,
+    backend: str,
+    jit_optimization_level: int,
+    source_digest: str,
+    producer_revision: str,
+    target_platform: str | None = None,
+) -> dict[str, object]:
+    if len(source_digest) != 64:
+        raise ValueError("source_digest must be SHA-256")
+    if not producer_revision:
+        raise ValueError("producer_revision must not be empty")
+    return {
+        "model": model.value,
+        "backend": backend,
+        "jit_optimization_level": jit_optimization_level,
+        "source_digest": source_digest,
+        "producer_revision": producer_revision,
+        "target_platform": (
+            target_platform
+            if target_platform is not None
+            else f"{platform.system().lower()}-{platform.machine().lower()}"
+        ),
+    }
+
+
+def _record_path(bundle_path: Path) -> Path:
+    return bundle_path.with_suffix(bundle_path.suffix + ".report.json")
+
+
+def validate_prepared_record(
+    bundle_path: Path,
+    *,
+    expected_identity: Mapping[str, object],
+) -> dict[str, object]:
+    record_path = _record_path(bundle_path)
+    try:
+        record = json.loads(record_path.read_text(encoding="ascii"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise PreparedModelError(
+            f"cannot read prepared-model record: {error}"
+        ) from error
+    if not isinstance(record, Mapping):
+        raise PreparedModelError("prepared-model record must be an object")
+    if record.get("schema") != PREPARED_RECORD_SCHEMA:
+        raise PreparedModelError("prepared-model record schema is unsupported")
+    if record.get("identity") != dict(expected_identity):
+        raise PreparedModelError("prepared-model identity does not match")
+    if not bundle_path.is_file() or bundle_path.is_symlink():
+        raise PreparedModelError("prepared-model bundle is not a regular file")
+    if record.get("bundle_size") != bundle_path.stat().st_size:
+        raise PreparedModelError("prepared-model bundle size does not match")
+    if record.get("bundle_sha256") != _sha256(bundle_path):
+        raise PreparedModelError("prepared-model bundle digest does not match")
+    return dict(record)
+
+
+@contextmanager
+def ensure_prepared_model(
+    *,
+    store: ArtifactStore,
+    bundle_path: Path,
+    source: CompilableModelSource,
+    evaluator: object,
+    identity: Mapping[str, object],
+    model_cache_dir: Path,
+) -> Iterator[tuple[Path, bool]]:
+    """Create one prepared bundle atomically or reuse its validated record."""
+
+    lock_name = (
+        "prepared-" + hashlib.sha256(_canonical_bytes(dict(identity))).hexdigest()
+    )
+    with store.named_lock(lock_name):
+        try:
+            validate_prepared_record(bundle_path, expected_identity=identity)
+        except PreparedModelError:
+            reused = False
+            bundle_path.parent.mkdir(parents=True, exist_ok=True)
+            staging = bundle_path.with_name(
+                f".{bundle_path.stem}.{uuid.uuid4().hex}.staging.pyamplicol-model"
+            )
+            try:
+                source.compile(
+                    cache_dir=model_cache_dir,
+                    use_cache=True,
+                    require_supported=True,
+                    prepared_output=staging,
+                    evaluator=evaluator,
+                )
+                if not staging.is_file() or staging.is_symlink():
+                    raise PreparedModelError(
+                        "prepared-model compiler did not publish a regular bundle"
+                    )
+                digest = _sha256(staging)
+                size = staging.stat().st_size
+                staging.replace(bundle_path)
+                _atomic_write(
+                    _record_path(bundle_path),
+                    {
+                        "schema": PREPARED_RECORD_SCHEMA,
+                        "identity": dict(identity),
+                        "bundle_sha256": digest,
+                        "bundle_size": size,
+                        **(
+                            {"command_path": command_path}
+                            if isinstance(
+                                command_path := getattr(source, "command_path", None),
+                                str,
+                            )
+                            else {}
+                        ),
+                    },
+                )
+                validate_prepared_record(
+                    bundle_path,
+                    expected_identity=identity,
+                )
+            finally:
+                staging.unlink(missing_ok=True)
+        else:
+            reused = True
+        yield bundle_path, reused
+
+
+def ensure_report_prepared_model(
+    *,
+    store: ArtifactStore,
+    repo_root: Path,
+    worker_cores: int,
+    model: ModelKey,
+    producer_revision: str | None,
+    progress: ProgressSink | None = None,
+) -> tuple[Path, bool]:
+    """Create or reuse one portable report JIT O2 prepared bundle."""
+
+    if producer_revision is None:
+        raise PreparedModelError(
+            "report prepared-model creation requires an explicit producer revision"
+        )
+    from pyamplicol.config import (
+        EvaluatorBackend,
+        EvaluatorConfig,
+        EvaluatorExecutionMode,
+        EvaluatorOptimizationConfig,
+        JITConfig,
+    )
+
+    revision = producer_revision
+    if not revision:
+        raise ValueError("producer_revision must not be empty")
+    if model is ModelKey.BUILTIN_SM:
+        source_path = None
+        source = _PublicCliModelCompiler("built-in-sm", progress=progress)
+        digest = hashlib.sha256(f"built-in-sm:{revision}".encode("ascii")).hexdigest()
+        stem = "built-in-sm"
+    elif model is ModelKey.UFO_SM:
+        source_path = _model_source_path(repo_root, model)
+        if source_path is None:
+            raise PreparedModelError("UFO-SM model resource is unavailable")
+        source = _PublicCliModelCompiler(os.fspath(source_path), progress=progress)
+        digest = _sha256(source_path)
+        stem = "ufo-sm"
+    else:
+        raise ValueError("report prepared packs support built-in SM and UFO-SM")
+    identity = prepared_identity(
+        model=model,
+        backend="jit",
+        jit_optimization_level=2,
+        source_digest=digest,
+        producer_revision=revision,
+    )
+    identity_digest = hashlib.sha256(_canonical_bytes(identity)).hexdigest()[:20]
+    bundle_path = (
+        store.artifact_root
+        / "prepared-models"
+        / f"{stem}-jit-o2-{identity_digest}.pyamplicol-model"
+    )
+    evaluator = EvaluatorConfig(
+        backend=EvaluatorBackend.JIT,
+        execution_mode=EvaluatorExecutionMode.RECURRENCE,
+        optimization=EvaluatorOptimizationConfig(cores=worker_cores),
+        jit=JITConfig(optimization_level=2),
+    )
+    with ensure_prepared_model(
+        store=store,
+        bundle_path=bundle_path,
+        source=source,
+        evaluator=evaluator,
+        identity=identity,
+        model_cache_dir=store.artifact_root / "model-cache",
+    ) as result:
+        return result
+
+
+def ensure_report_ufo_sm_prepared_model(
+    *,
+    store: ArtifactStore,
+    repo_root: Path,
+    worker_cores: int,
+) -> tuple[Path, bool]:
+    from pyamplicol._internal.versions import active_source_revision
+
+    return ensure_report_prepared_model(
+        store=store,
+        repo_root=repo_root,
+        worker_cores=worker_cores,
+        model=ModelKey.UFO_SM,
+        producer_revision=active_source_revision(),
+    )
+
+
+__all__ = [
+    "PREPARED_RECORD_SCHEMA",
+    "PUBLIC_MODEL_COMPILE_COMMAND_PATH",
+    "PreparedModelError",
+    "ensure_prepared_model",
+    "ensure_report_prepared_model",
+    "ensure_report_ufo_sm_prepared_model",
+    "prepared_identity",
+    "validate_prepared_record",
+]
diff --git a/pyamplicol/tools/performance_report/publication.py b/pyamplicol/tools/performance_report/publication.py
new file mode 100644
index 0000000000..1dc5400b1c
--- /dev/null
+++ b/pyamplicol/tools/performance_report/publication.py
@@ -0,0 +1,853 @@
+# SPDX-License-Identifier: 0BSD
+"""Fail-closed publication projection and local-path resolution."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from collections.abc import Mapping, Sequence
+from pathlib import Path, PurePosixPath
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .service import ReportPaths
+
+_ARTIFACT_ROOT = "${PYAMPLICOL_REPORT_ARTIFACT_ROOT}"
+_COORDINATION_ROOT = "${PYAMPLICOL_REPORT_COORDINATION_ROOT}"
+_SOURCE_ROOT = "${PYAMPLICOL_SOURCE_ROOT}"
+_REDACTED_ROOT = "${LOCAL_PATH_REDACTED}"
+_PORTABLE_ROOTS = (
+    _ARTIFACT_ROOT,
+    _COORDINATION_ROOT,
+    _SOURCE_ROOT,
+    _REDACTED_ROOT,
+)
+PORTABLE_CURRENT_REPRODUCTION_RECIPE_ABI = (
+    "pyamplicol-portable-current-reproduction-recipe-v1"
+)
+_REPRODUCTION_RECIPE_POINTER = (
+    "provenance",
+    "manual_campaign",
+    "public_cli_reproduction",
+)
+_REPRODUCTION_STAGES = ("prepare", "generate", "profile")
+
+# These are the only measurement fields whose machine-local value is not part
+# of an authenticated identity or numerical result.  The patterns are relative
+# to ``measurement``; ``*`` matches one sequence element.  Adding a locator to
+# the report schema must therefore make an explicit, reviewable change here.
+_LOCATOR_POINTERS = (
+    ("artifact", "path"),
+    ("artifact", "log_path"),
+    # MadGraph retains its generated standalone tree as an ordinary artifact
+    # locator.  It is diagnostic/reusable campaign state, not numerical
+    # identity, and must be projected just like the enclosing artifact path.
+    ("artifact", "standalone"),
+    # Both supported and scope-unavailable original-AmpliCol measurements
+    # attach their authenticated structural proof at this artifact locator.
+    ("artifact", "legacy_structural_proof"),
+    ("provenance", "worker_log"),
+    ("provenance", "repository"),
+    # MadGraph records the selected installation and model directory for
+    # diagnostics.  Neither path contributes to the sealed numerical result;
+    # installations outside the report/source roots are therefore redacted.
+    ("provenance", "installation"),
+    ("provenance", "model", "source_directory"),
+    ("provenance", "requested_config", "model", "source"),
+    ("provenance", "requested_config", "model", "cache_dir"),
+    ("provenance", "effective_config", "model", "source"),
+    ("provenance", "effective_config", "model", "cache_dir"),
+    ("provenance", "worker_environment", "LD_LIBRARY_PATH"),
+    ("provenance", "worker_environment", "DYLD_LIBRARY_PATH"),
+    ("provenance", "commands", "*", "cwd"),
+    # Legacy command records are diagnostic, not authenticated evidence.  Their
+    # executable, first operand, and the all-flow probe's process/momenta file
+    # operands are the only schema positions that carry absolute launch paths.
+    ("provenance", "commands", "*", "args", 0),
+    ("provenance", "commands", "*", "args", 1),
+    ("provenance", "commands", "*", "args", 5),
+    ("provenance", "commands", "*", "args", 6),
+    ("provenance", "commands", "*", "environment", "LD_LIBRARY_PATH"),
+    ("provenance", "commands", "*", "environment", "DYLD_LIBRARY_PATH"),
+    ("provenance", "runtime_profile", "measurement", "args", 0),
+    ("provenance", "runtime_profile", "measurement", "args", 5),
+    ("provenance", "runtime_profile", "measurement", "args", 6),
+    ("provenance", "runtime_profile", "measurement", "cwd"),
+    (
+        "provenance",
+        "runtime_profile",
+        "measurement",
+        "environment",
+        "LD_LIBRARY_PATH",
+    ),
+    (
+        "provenance",
+        "runtime_profile",
+        "measurement",
+        "environment",
+        "DYLD_LIBRARY_PATH",
+    ),
+    (
+        "provenance",
+        "runtime_profile",
+        "measurement",
+        "chunks",
+        "*",
+        "args",
+        0,
+    ),
+    (
+        "provenance",
+        "runtime_profile",
+        "measurement",
+        "chunks",
+        "*",
+        "args",
+        5,
+    ),
+    (
+        "provenance",
+        "runtime_profile",
+        "measurement",
+        "chunks",
+        "*",
+        "args",
+        6,
+    ),
+    ("provenance", "runtime_profile", "measurement", "chunks", "*", "cwd"),
+    (
+        "provenance",
+        "runtime_profile",
+        "measurement",
+        "chunks",
+        "*",
+        "environment",
+        "LD_LIBRARY_PATH",
+    ),
+    (
+        "provenance",
+        "runtime_profile",
+        "measurement",
+        "chunks",
+        "*",
+        "environment",
+        "DYLD_LIBRARY_PATH",
+    ),
+    ("provenance", "runtime_profile", "warmup", "args", 0),
+    ("provenance", "runtime_profile", "warmup", "args", 5),
+    ("provenance", "runtime_profile", "warmup", "args", 6),
+    ("provenance", "runtime_profile", "warmup", "cwd"),
+    (
+        "provenance",
+        "runtime_profile",
+        "warmup",
+        "environment",
+        "LD_LIBRARY_PATH",
+    ),
+    (
+        "provenance",
+        "runtime_profile",
+        "warmup",
+        "environment",
+        "DYLD_LIBRARY_PATH",
+    ),
+    (
+        "provenance",
+        "manual_campaign",
+        "public_cli_reproduction",
+        "prepare",
+        "*",
+    ),
+    (
+        "provenance",
+        "manual_campaign",
+        "public_cli_reproduction",
+        "generate",
+        "*",
+    ),
+    (
+        "provenance",
+        "manual_campaign",
+        "public_cli_reproduction",
+        "profile",
+        "*",
+    ),
+)
+
+# Generation retains its output directory in the requested/effective CLI
+# configuration.  Unlike diagnostic locator fields, these values are expected
+# to identify the published result's artifact and must never be silently
+# redacted: an absolute path is accepted only when it is rooted in this
+# profile's artifact store.
+_STRICT_ARTIFACT_LOCATOR_POINTERS = (
+    ("provenance", "requested_config", "generation", "output"),
+    ("provenance", "effective_config", "generation", "output"),
+)
+
+# These exact-path fields are consumed when a current is reused.  Portable
+# current records therefore require an explicit rooted locator here; a raw
+# absolute path or a merely relative path must never be interpreted relative
+# to the process working directory after a campaign has moved.
+_CURRENT_ROOTED_PATH_POINTERS = (
+    ("artifact", "path"),
+    ("artifact", "log_path"),
+    ("artifact", "legacy_structural_proof"),
+    ("provenance", "worker_log"),
+    *_STRICT_ARTIFACT_LOCATOR_POINTERS,
+)
+
+_SCHEME_URI_RE = re.compile(r"[A-Za-z][A-Za-z0-9+.-]*://[^\s]+")
+_FILE_URI_RE = re.compile(r"file:(?://)?/[^\r\n]*", flags=re.IGNORECASE)
+_PATH_PREFIX = r"(?P<prefix>^|[\s:;,\"'=()\[\]{}@]|-[A-Za-z])"
+_WINDOWS_PATH_RE = re.compile(
+    _PATH_PREFIX + r"(?P<path>[A-Z]:[\\/][^\s:;,\"'=\]\[(){}]*)",
+    flags=re.IGNORECASE | re.MULTILINE,
+)
+_UNC_PATH_RE = re.compile(
+    _PATH_PREFIX + r"(?P<path>(?:\\\\|//)[^\s:;,\"'=\]\[(){}]+)",
+    flags=re.MULTILINE,
+)
+_POSIX_PATH_RE = re.compile(
+    _PATH_PREFIX + r"(?P<path>/(?!/)[^\s:;,\"'=\]\[(){}]*)",
+    flags=re.MULTILINE,
+)
+_KNOWN_ROOT_SUFFIX = r"(?=$|[/\\:;,\s\"'=)\]}\[])"
+
+
+class PublicationPortabilityError(ValueError):
+    """A publication value contains a non-whitelisted machine-local path."""
+
+
+def _known_roots(paths: ReportPaths) -> tuple[tuple[str, str], ...]:
+    return tuple(
+        sorted(
+            (
+                (paths.artifact_root.as_posix(), _ARTIFACT_ROOT),
+                (paths.coordination_root.as_posix(), _COORDINATION_ROOT),
+                (paths.repo_root.as_posix(), _SOURCE_ROOT),
+            ),
+            key=lambda item: len(item[0]),
+            reverse=True,
+        )
+    )
+
+
+def _measurement_pointer(
+    pointer: tuple[str | int, ...],
+) -> tuple[str | int, ...]:
+    if (
+        len(pointer) >= 3
+        and pointer[0] == "entries"
+        and isinstance(pointer[1], int)
+        and pointer[2] == "measurement"
+    ):
+        return pointer[3:]
+    if pointer and pointer[0] == "measurement":
+        return pointer[1:]
+    return pointer
+
+
+def _pointer_matches(
+    pointer: tuple[str | int, ...],
+    pattern: tuple[str | int, ...],
+) -> bool:
+    return len(pointer) == len(pattern) and all(
+        expected == "*" or observed == expected
+        for observed, expected in zip(pointer, pattern, strict=True)
+    )
+
+
+def _locator_pointer(pointer: tuple[str | int, ...]) -> bool:
+    relative = _measurement_pointer(pointer)
+    return any(_pointer_matches(relative, pattern) for pattern in _LOCATOR_POINTERS)
+
+
+def _strict_artifact_locator_pointer(pointer: tuple[str | int, ...]) -> bool:
+    relative = _measurement_pointer(pointer)
+    return any(
+        _pointer_matches(relative, pattern)
+        for pattern in _STRICT_ARTIFACT_LOCATOR_POINTERS
+    )
+
+
+def _current_rooted_path_pointer(pointer: tuple[str | int, ...]) -> bool:
+    relative = _measurement_pointer(pointer)
+    return any(
+        _pointer_matches(relative, pattern)
+        for pattern in _CURRENT_ROOTED_PATH_POINTERS
+    )
+
+
+def _current_reproduction_recipe_pointer(pointer: tuple[str | int, ...]) -> bool:
+    return _measurement_pointer(pointer) == _REPRODUCTION_RECIPE_POINTER
+
+
+def _validated_reproduction_argv(
+    value: Mapping[object, object],
+) -> dict[str, tuple[str, ...] | None]:
+    if value.get("abi") != PORTABLE_CURRENT_REPRODUCTION_RECIPE_ABI:
+        raise PublicationPortabilityError(
+            "portable current reproduction recipe has no supported structured ABI"
+        )
+    result: dict[str, tuple[str, ...] | None] = {}
+    for stage in _REPRODUCTION_STAGES:
+        raw_argv = value.get(stage)
+        if raw_argv is None:
+            result[stage] = None
+            continue
+        if (
+            not isinstance(raw_argv, Sequence)
+            or isinstance(raw_argv, (str, bytes, bytearray))
+            or not raw_argv
+            or any(
+                not isinstance(argument, str) or not argument
+                for argument in raw_argv
+            )
+        ):
+            raise PublicationPortabilityError(
+                f"portable current reproduction {stage} argv is malformed"
+            )
+        argv = tuple(raw_argv)
+        result[stage] = argv
+    return result
+
+
+def _canonical_bytes(value: object) -> bytes:
+    try:
+        rendered = json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+    except (TypeError, ValueError):
+        return b""
+    return rendered.encode("ascii")
+
+
+def _digest_matches(value: object, digest: object) -> bool:
+    if not isinstance(digest, str) or re.fullmatch(r"[0-9a-f]{64}", digest) is None:
+        return False
+    payload = _canonical_bytes(value)
+    return bool(payload) and hashlib.sha256(payload).hexdigest() == digest
+
+
+def _digest_covered_keys(
+    value: Mapping[object, object],
+    pointer: tuple[str | int, ...],
+) -> frozenset[str]:
+    """Return authenticated sibling objects that publication must not rewrite."""
+
+    rendered = {str(key): item for key, item in value.items()}
+    protected = {
+        key
+        for key, item in rendered.items()
+        if _digest_matches(item, rendered.get(f"{key}_sha256"))
+    }
+    relative = _measurement_pointer(pointer)
+    postflight_key = "runtime_identity_postflight_loaded_module_origin_policy"
+    if relative == ("provenance",):
+        postflight = rendered.get(postflight_key)
+        if isinstance(postflight, Mapping) and _digest_matches(
+            postflight.get("observations"),
+            postflight.get("observations_sha256"),
+        ):
+            protected.add(postflight_key)
+    return frozenset(protected)
+
+
+def _json_pointer(pointer: tuple[str | int, ...]) -> str:
+    return "/" + "/".join(
+        str(part).replace("~", "~0").replace("/", "~1") for part in pointer
+    )
+
+
+def _replace_known_root(value: str, local: str, portable: str) -> str:
+    # The prefix prevents a root such as /repo from matching the suffix of
+    # /other/repo.  The suffix prevents /repo from corrupting /repo-sibling.
+    prefix = r"(?P<prefix>^|[\s:;,\"'=()\[\]{}@]|-[A-Za-z])"
+    pattern = re.compile(
+        prefix + rf"(?P<root>{re.escape(local)}){_KNOWN_ROOT_SUFFIX}",
+        flags=re.MULTILINE,
+    )
+    return pattern.sub(
+        lambda match: f"{match.group('prefix')}{portable}",
+        value,
+    )
+
+
+def _portable_locator_string(value: str, paths: ReportPaths) -> str:
+    result = value
+    for local, portable in _known_roots(paths):
+        result = _replace_known_root(result, local, portable)
+        windows_local = local.replace("/", "\\")
+        if windows_local != local:
+            result = _replace_known_root(result, windows_local, portable)
+    if _absolute_path_fragments(result):
+        # Unknown local roots are deliberately irreversible.  Redact the whole
+        # locator field instead of attempting a lossy partial path parser.
+        return _REDACTED_ROOT
+    return result
+
+
+def _portable_artifact_locator_string(
+    value: str,
+    paths: ReportPaths,
+    *,
+    pointer: tuple[str | int, ...],
+) -> str:
+    """Project one exact artifact path, rejecting every external absolute root."""
+
+    has_absolute_path = bool(_absolute_path_fragments(value))
+    has_portable_root = any(marker in value for marker in _PORTABLE_ROOTS)
+    if not has_absolute_path and not has_portable_root:
+        return value
+    portable = _portable_locator_string(value, paths)
+    if not (portable == _ARTIFACT_ROOT or portable.startswith(f"{_ARTIFACT_ROOT}/")):
+        raise PublicationPortabilityError(
+            "artifact path outside publication artifact root at "
+            f"{_json_pointer(pointer)}: {value!r}"
+        )
+    try:
+        resolve_publication_path(portable, paths)
+    except ValueError as error:
+        raise PublicationPortabilityError(
+            f"invalid publication artifact path at {_json_pointer(pointer)}: {value!r}"
+        ) from error
+    return portable
+
+
+def _portable_publication_value(
+    value: object,
+    paths: ReportPaths,
+    *,
+    pointer: tuple[str | int, ...],
+) -> object:
+    if isinstance(value, str):
+        if _strict_artifact_locator_pointer(pointer):
+            return _portable_artifact_locator_string(
+                value,
+                paths,
+                pointer=pointer,
+            )
+        if _locator_pointer(pointer):
+            return _portable_locator_string(value, paths)
+        fragments = _absolute_path_fragments(value)
+        if fragments:
+            raise PublicationPortabilityError(
+                "absolute path outside publication locator allowlist at "
+                f"{_json_pointer(pointer)}: {fragments[0]!r}"
+            )
+        return value
+    if isinstance(value, Mapping):
+        protected = _digest_covered_keys(value, pointer)
+        result: dict[str, object] = {}
+        for key, item in value.items():
+            rendered_key = str(key)
+            key_fragments = _absolute_path_fragments(rendered_key)
+            if key_fragments:
+                raise PublicationPortabilityError(
+                    "absolute path in publication mapping key at "
+                    f"{_json_pointer((*pointer, rendered_key))}: "
+                    f"{key_fragments[0]!r}"
+                )
+            result[rendered_key] = (
+                item
+                if rendered_key in protected
+                else _portable_publication_value(
+                    item,
+                    paths,
+                    pointer=(*pointer, rendered_key),
+                )
+            )
+        return result
+    if isinstance(value, Sequence) and not isinstance(value, (bytes, bytearray)):
+        return [
+            _portable_publication_value(
+                item,
+                paths,
+                pointer=(*pointer, index),
+            )
+            for index, item in enumerate(value)
+        ]
+    return value
+
+
+def portable_publication_value(value: object, paths: ReportPaths) -> object:
+    """Project approved local locators and reject every unknown absolute path.
+
+    Digest-verified sibling objects and the authenticated postflight
+    loaded-origin policy are copied byte-identically.  Every absolute path
+    outside those opaque evidence objects must occur at an explicit locator
+    pointer above or publication fails closed.
+    """
+
+    return _portable_publication_value(value, paths, pointer=())
+
+
+def _current_state_roots(paths: ReportPaths) -> tuple[tuple[str, str], ...]:
+    return tuple(
+        sorted(
+            (
+                (paths.artifact_root.as_posix(), _ARTIFACT_ROOT),
+                (paths.coordination_root.as_posix(), _COORDINATION_ROOT),
+            ),
+            key=lambda item: len(item[0]),
+            reverse=True,
+        )
+    )
+
+
+def _portable_current_locator_string(value: str, paths: ReportPaths) -> str:
+    result = value
+    for local, portable in _current_state_roots(paths):
+        result = _replace_known_root(result, local, portable)
+        windows_local = local.replace("/", "\\")
+        if windows_local != local:
+            result = _replace_known_root(result, windows_local, portable)
+    return result
+
+
+def _validate_current_state_tokens(value: str) -> None:
+    forbidden = (_SOURCE_ROOT, _REDACTED_ROOT)
+    if any(marker in value for marker in forbidden):
+        raise PublicationPortabilityError(
+            "portable current contains a non-state publication locator"
+        )
+    delimiters = frozenset(" \t\r\n:;,\"'=()[]{}@")
+    for marker in (_ARTIFACT_ROOT, _COORDINATION_ROOT):
+        offset = 0
+        while True:
+            start = value.find(marker, offset)
+            if start < 0:
+                break
+            suffix_start = start + len(marker)
+            if suffix_start >= len(value) or value[suffix_start] != "/":
+                raise PublicationPortabilityError(
+                    "portable current state locator has an empty or invalid suffix"
+                )
+            end = suffix_start + 1
+            while end < len(value) and value[end] not in delimiters:
+                end += 1
+            suffix = value[suffix_start + 1 : end]
+            logical = PurePosixPath(suffix)
+            if (
+                not suffix
+                or "\\" in suffix
+                or logical.is_absolute()
+                or any(part in {"", ".", ".."} for part in logical.parts)
+                or logical.as_posix() != suffix
+            ):
+                raise PublicationPortabilityError(
+                    "portable current state locator suffix is not canonical"
+                )
+            offset = suffix_start
+
+
+def _current_root_for_locator(value: str, paths: ReportPaths) -> tuple[str, Path]:
+    for marker, root in (
+        (_ARTIFACT_ROOT, paths.artifact_root),
+        (_COORDINATION_ROOT, paths.coordination_root),
+    ):
+        if value.startswith(marker + "/"):
+            return marker, root
+    raise PublicationPortabilityError(
+        "portable current rooted path has no state-root locator"
+    )
+
+
+def _resolve_current_rooted_path(value: str, paths: ReportPaths) -> str:
+    _validate_current_state_tokens(value)
+    marker, raw_root = _current_root_for_locator(value, paths)
+    if value.count(_ARTIFACT_ROOT) + value.count(_COORDINATION_ROOT) != 1:
+        raise PublicationPortabilityError(
+            "portable current rooted path must contain exactly one locator"
+        )
+    try:
+        resolved = resolve_publication_path(value, paths)
+    except ValueError as error:
+        raise PublicationPortabilityError(
+            f"portable current contains an invalid rooted path: {value!r}"
+        ) from error
+    relative = PurePosixPath(value[len(marker) + 1 :])
+    lexical_root = Path(raw_root).expanduser()
+    lexical_root = Path(lexical_root.absolute())
+    lexical = lexical_root.joinpath(*relative.parts)
+    # ``resolve(strict=False)`` follows every existing symlink component.  A
+    # difference from the lexical canonical path therefore rejects even an
+    # in-root symlink, not merely an escape outside the state root.
+    if lexical != resolved:
+        raise PublicationPortabilityError(
+            f"portable current rooted path traverses a symbolic link: {value!r}"
+        )
+    return resolved.as_posix()
+
+
+def _portable_current_value(
+    value: object,
+    paths: ReportPaths,
+    *,
+    pointer: tuple[str | int, ...],
+) -> object:
+    if isinstance(value, str):
+        if _current_rooted_path_pointer(pointer):
+            portable = _portable_current_locator_string(value, paths)
+            _resolve_current_rooted_path(portable, paths)
+            return portable
+        if _locator_pointer(pointer):
+            portable = _portable_current_locator_string(value, paths)
+            _validate_current_state_tokens(portable)
+            return portable
+        projected = _portable_current_locator_string(value, paths)
+        _validate_current_state_tokens(projected)
+        return projected
+    if isinstance(value, Mapping):
+        if _current_reproduction_recipe_pointer(pointer):
+            _validated_reproduction_argv(value)
+        protected = _digest_covered_keys(value, pointer)
+        return {
+            str(key): (
+                item
+                if str(key) in protected
+                else _portable_current_value(
+                    item,
+                    paths,
+                    pointer=(*pointer, str(key)),
+                )
+            )
+            for key, item in value.items()
+        }
+    if isinstance(value, Sequence) and not isinstance(value, (bytes, bytearray)):
+        return [
+            _portable_current_value(
+                item,
+                paths,
+                pointer=(*pointer, index),
+            )
+            for index, item in enumerate(value)
+        ]
+    return value
+
+
+def _materialize_current_value(
+    value: object,
+    paths: ReportPaths,
+    *,
+    pointer: tuple[str | int, ...],
+) -> object:
+    if isinstance(value, str):
+        if _current_rooted_path_pointer(pointer):
+            if _absolute_path_fragments(value):
+                raise PublicationPortabilityError(
+                    "portable current contains a raw rooted path at "
+                    f"{_json_pointer(pointer)}: {value!r}"
+                )
+            return _resolve_current_rooted_path(value, paths)
+        if _locator_pointer(pointer):
+            _validate_current_state_tokens(value)
+            return resolve_publication_string(value, paths)
+        _validate_current_state_tokens(value)
+        if any(marker in value for marker in (_ARTIFACT_ROOT, _COORDINATION_ROOT)):
+            return resolve_publication_string(value, paths)
+        return value
+    if isinstance(value, Mapping):
+        if _current_reproduction_recipe_pointer(pointer):
+            _validated_reproduction_argv(value)
+        protected = _digest_covered_keys(value, pointer)
+        return {
+            str(key): (
+                item
+                if str(key) in protected
+                else _materialize_current_value(
+                    item,
+                    paths,
+                    pointer=(*pointer, str(key)),
+                )
+            )
+            for key, item in value.items()
+        }
+    if isinstance(value, Sequence) and not isinstance(value, (bytes, bytearray)):
+        return [
+            _materialize_current_value(
+                item,
+                paths,
+                pointer=(*pointer, index),
+            )
+            for index, item in enumerate(value)
+        ]
+    return value
+
+
+def portable_current_value(value: object, paths: ReportPaths) -> object:
+    """Project one newly sealed current into the portable locator ABI.
+
+    The ordinary publication projection remains unchanged.  This additional
+    boundary proves that every state path needed by current reuse is an exact,
+    canonical artifact/coordination-root locator before immutable result bytes
+    are written.
+    """
+
+    portable = _portable_current_value(value, paths, pointer=())
+    _materialize_current_value(portable, paths, pointer=())
+    return portable
+
+
+def materialize_current_value(value: object, paths: ReportPaths) -> object:
+    """Resolve one authenticated portable current against its present roots.
+
+    This deliberately does not migrate historical absolute-path records.  A
+    campaign current either uses the portable locator ABI in its stored bytes
+    or fails closed.
+    """
+
+    return _materialize_current_value(value, paths, pointer=())
+
+
+def resolve_publication_string(value: str, paths: ReportPaths) -> str:
+    """Resolve reversible publication placeholders on the current machine."""
+
+    replacements = (
+        (_ARTIFACT_ROOT, paths.artifact_root.as_posix()),
+        (_COORDINATION_ROOT, paths.coordination_root.as_posix()),
+        (_SOURCE_ROOT, paths.repo_root.as_posix()),
+    )
+    result = value
+    for portable, local in replacements:
+        result = result.replace(portable, local)
+    return result
+
+
+def resolve_publication_path(value: str, paths: ReportPaths) -> Path:
+    """Resolve one rooted portable path and enforce root containment."""
+
+    if _REDACTED_ROOT in value:
+        raise ValueError("redacted publication path cannot be resolved")
+    roots = (
+        (_ARTIFACT_ROOT, paths.artifact_root),
+        (_COORDINATION_ROOT, paths.coordination_root),
+        (_SOURCE_ROOT, paths.repo_root),
+    )
+    for marker, raw_root in roots:
+        if value == marker:
+            relative = ""
+        elif value.startswith(f"{marker}/"):
+            relative = value[len(marker) + 1 :]
+        else:
+            continue
+        logical = PurePosixPath(relative)
+        if relative and (
+            logical.is_absolute()
+            or "\\" in relative
+            or any(part in {"", ".", ".."} for part in logical.parts)
+            or logical.as_posix() != relative
+        ):
+            raise ValueError(f"publication path is not canonical: {value!r}")
+        root = raw_root.expanduser().resolve(strict=False)
+        resolved = root.joinpath(*logical.parts).resolve(strict=False)
+        try:
+            resolved.relative_to(root)
+        except ValueError as error:
+            raise ValueError(
+                f"publication path escapes its declared root: {value!r}"
+            ) from error
+        return resolved
+    raise ValueError(
+        f"publication path must begin with one recognized root placeholder: {value!r}"
+    )
+
+
+def publication_measurement_matches_current(
+    measurement: Mapping[str, object],
+    current: Mapping[str, object],
+    paths: ReportPaths,
+) -> bool:
+    """Compare a portable cache with an already-authenticated raw result.
+
+    The caller is responsible for authenticating ``current`` before invoking
+    this projection.  Neither input is mutated.
+    """
+
+    portable = portable_publication_value(current, paths)
+    return isinstance(portable, Mapping) and dict(measurement) == dict(portable)
+
+
+def _absolute_path_fragments(value: str) -> tuple[str, ...]:
+    sanitized = value
+    for marker in _PORTABLE_ROOTS:
+        sanitized = sanitized.replace(marker, "PORTABLE_ROOT")
+    file_uris = tuple(_FILE_URI_RE.findall(sanitized))
+    without_file_uris = _FILE_URI_RE.sub("", sanitized)
+    without_urls = _SCHEME_URI_RE.sub("", without_file_uris)
+    stripped = without_urls.strip()
+    direct: tuple[str, ...] = ()
+    if (
+        stripped.startswith(("/", "\\\\"))
+        or re.match(r"^[A-Za-z]:[\\/]", stripped) is not None
+    ):
+        direct = (stripped,)
+        without_urls = ""
+    fragments = (
+        *file_uris,
+        *direct,
+        *(match.group("path") for match in _WINDOWS_PATH_RE.finditer(without_urls)),
+        *(match.group("path") for match in _UNC_PATH_RE.finditer(without_urls)),
+        *(match.group("path") for match in _POSIX_PATH_RE.finditer(without_urls)),
+    )
+    return tuple(dict.fromkeys(fragment for fragment in fragments if fragment))
+
+
+def _publication_absolute_paths(
+    value: object,
+    *,
+    pointer: tuple[str | int, ...],
+) -> tuple[str, ...]:
+    if isinstance(value, str):
+        return _absolute_path_fragments(value)
+    if isinstance(value, Mapping):
+        protected = _digest_covered_keys(value, pointer)
+        return tuple(
+            fragment
+            for key, item in value.items()
+            if str(key) not in protected
+            for fragment in (
+                *_publication_absolute_paths(
+                    str(key),
+                    pointer=(*pointer, str(key), "<key>"),
+                ),
+                *_publication_absolute_paths(
+                    item,
+                    pointer=(*pointer, str(key)),
+                ),
+            )
+        )
+    if isinstance(value, Sequence) and not isinstance(value, (bytes, bytearray)):
+        return tuple(
+            fragment
+            for index, item in enumerate(value)
+            for fragment in _publication_absolute_paths(
+                item,
+                pointer=(*pointer, index),
+            )
+        )
+    return ()
+
+
+def publication_absolute_paths(value: object) -> tuple[str, ...]:
+    """Return host paths outside authenticated digest-covered objects."""
+
+    return _publication_absolute_paths(value, pointer=())
+
+
+__all__ = [
+    "PORTABLE_CURRENT_REPRODUCTION_RECIPE_ABI",
+    "PublicationPortabilityError",
+    "materialize_current_value",
+    "portable_current_value",
+    "portable_publication_value",
+    "publication_absolute_paths",
+    "publication_measurement_matches_current",
+    "resolve_publication_path",
+    "resolve_publication_string",
+]
diff --git a/pyamplicol/tools/performance_report/publisher.py b/pyamplicol/tools/performance_report/publisher.py
new file mode 100644
index 0000000000..44ed70478b
--- /dev/null
+++ b/pyamplicol/tools/performance_report/publisher.py
@@ -0,0 +1,662 @@
+# SPDX-License-Identifier: 0BSD
+"""Nonblocking snapshot, render, and PDF publication for live campaigns."""
+
+from __future__ import annotations
+
+import errno
+import fcntl
+import hashlib
+import json
+import math
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+import time
+import uuid
+from collections.abc import Callable, Iterator, Mapping
+from contextlib import ExitStack, contextmanager
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+
+from .artifacts import CurrentRecord, LockTimeoutError
+from .measurement_lineage import load_measurement_lineage
+from .service import ReportPaths, ReportService
+from .source_identity import require_eligible_report_source
+from .standalone_build import StandaloneBuildError, validate_latex_log
+
+PUBLICATION_SNAPSHOT_SCHEMA = "pyamplicol-report-publication-snapshot-v1"
+DEFAULT_PUBLICATION_INTERVAL_SECONDS = 600.0
+DEFAULT_PDF_TIMEOUT_SECONDS = 900.0
+DEFAULT_EXPECTED_PAGE_COUNT = 73
+_INSTALL_LOCK_INITIAL_BACKOFF_SECONDS = 0.05
+_INSTALL_LOCK_MAXIMUM_BACKOFF_SECONDS = 1.0
+
+_PAGE_COUNT_RE = re.compile(
+    r"Output written on .+? \((?P<pages>[1-9][0-9]*) pages?,"
+)
+
+
+class ReportPublisherError(RuntimeError):
+    """Raised when a report snapshot cannot be built or published."""
+
+
+@dataclass(frozen=True, slots=True)
+class PublicationResult:
+    """One internally consistent cache/table/PDF publication."""
+
+    current_count: int
+    page_count: int
+    snapshot_sha256: str
+    captured_at_utc: str
+    published_at_utc: str
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "schema": PUBLICATION_SNAPSHOT_SCHEMA,
+            "current_count": self.current_count,
+            "page_count": self.page_count,
+            "snapshot_sha256": self.snapshot_sha256,
+            "captured_at_utc": self.captured_at_utc,
+            "published_at_utc": self.published_at_utc,
+        }
+
+
+def _utc_now() -> str:
+    return datetime.now(UTC).isoformat(timespec="seconds").replace("+00:00", "Z")
+
+
+def _canonical_bytes(value: object) -> bytes:
+    return (
+        json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        + "\n"
+    ).encode("ascii")
+
+
+def _digest_bytes(value: object) -> str:
+    return hashlib.sha256(_canonical_bytes(value).rstrip(b"\n")).hexdigest()
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _fsync_directory(path: Path) -> None:
+    descriptor = os.open(path, os.O_RDONLY)
+    try:
+        os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+def _atomic_json(path: Path, payload: Mapping[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp-{uuid.uuid4().hex}")
+    try:
+        with temporary.open("xb") as stream:
+            stream.write(_canonical_bytes(payload))
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+        _fsync_directory(path.parent)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _snapshot_manifest_path(service: ReportService) -> Path:
+    return service.paths.coordination_root / "publication" / "current.json"
+
+
+def _publisher_state_path(service: ReportService) -> Path:
+    return service.paths.coordination_root / "publication" / "daemon.json"
+
+
+@contextmanager
+def _publisher_state_lease(
+    service: ReportService,
+    *,
+    interval_seconds: float,
+) -> Iterator[None]:
+    """Claim the publisher state without a long-lived campaign named lock."""
+
+    state_path = _publisher_state_path(service)
+    state_path.parent.mkdir(parents=True, exist_ok=True)
+    guard_path = state_path.parent / "daemon.guard"
+    guard = guard_path.open("a+b")
+    lease_id = uuid.uuid4().hex
+    payload = {
+        "schema": PUBLICATION_SNAPSHOT_SCHEMA,
+        "pid": os.getpid(),
+        "lease_id": lease_id,
+        "started_at_utc": _utc_now(),
+        "interval_seconds": interval_seconds,
+    }
+    try:
+        try:
+            fcntl.flock(guard.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError as error:
+            if error.errno not in (errno.EACCES, errno.EAGAIN):
+                raise
+            raise ReportPublisherError(
+                "another report publisher is already active"
+            ) from None
+        _atomic_json(state_path, payload)
+        try:
+            yield
+        finally:
+            try:
+                current = json.loads(state_path.read_text(encoding="ascii"))
+            except (json.JSONDecodeError, OSError):
+                current = None
+            if (
+                isinstance(current, Mapping)
+                and current.get("lease_id") == lease_id
+            ):
+                state_path.unlink(missing_ok=True)
+                _fsync_directory(state_path.parent)
+    finally:
+        try:
+            fcntl.flock(guard.fileno(), fcntl.LOCK_UN)
+        finally:
+            guard.close()
+
+
+@contextmanager
+def _publisher_writer_lock(service: ReportService) -> Iterator[None]:
+    """Yield only after the publisher can take the install lock without waiting."""
+
+    backoff = _INSTALL_LOCK_INITIAL_BACKOFF_SECONDS
+    while True:
+        stack = ExitStack()
+        try:
+            stack.enter_context(
+                service.store.named_lock("report-writer", timeout=0.0)
+            )
+        except LockTimeoutError:
+            stack.close()
+            time.sleep(backoff)
+            backoff = min(
+                _INSTALL_LOCK_MAXIMUM_BACKOFF_SECONDS,
+                backoff * 2.0,
+            )
+            continue
+        with stack:
+            yield
+        return
+
+
+def _current_snapshot(
+    records: tuple[CurrentRecord, ...],
+) -> tuple[dict[str, str], ...]:
+    return tuple(
+        {
+            "cell_id": record.cell_id,
+            "attempt_id": record.attempt_id,
+            "manifest_sha256": record.manifest_sha256,
+        }
+        for record in sorted(records, key=lambda item: item.cell_id)
+    )
+
+
+def _capture_current_records(
+    service: ReportService,
+) -> tuple[tuple[CurrentRecord, ...], tuple[dict[str, str], ...]]:
+    """Read a stable pointer set without taking any campaign writer lock."""
+
+    for _attempt in range(3):
+        records = service.store.recover_current_records()
+        snapshot = _current_snapshot(records)
+        confirmed = service.store.recover_current_records()
+        if _current_snapshot(confirmed) == snapshot:
+            return records, snapshot
+    raise ReportPublisherError(
+        "current pointers changed during three consecutive snapshot reads"
+    )
+
+
+def _report_source_copy_ignore(
+    source: Path,
+    *patterns: str,
+) -> Callable[[str, list[str]], set[str]]:
+    """Ignore build debris and only the report root's private campaign state."""
+
+    pattern_ignore = shutil.ignore_patterns(*patterns)
+    source_path = os.path.abspath(source)
+
+    def ignore(directory: str, names: list[str]) -> set[str]:
+        ignored = set(pattern_ignore(directory, names))
+        if os.path.abspath(directory) == source_path and "campaign_artifacts" in names:
+            ignored.add("campaign_artifacts")
+        return ignored
+
+    return ignore
+
+
+def _copy_report_source(source: Path, destination: Path) -> None:
+    shutil.copytree(
+        source,
+        destination,
+        ignore=_report_source_copy_ignore(
+            source,
+            "*.aux",
+            "*.fdb_latexmk",
+            "*.fls",
+            "*.log",
+            "*.out",
+            "*.toc",
+            "pyAmpliCol.pdf",
+            ".coordination",
+        ),
+    )
+
+
+def _compile_pdf(
+    docs_dir: Path,
+    *,
+    expected_page_count: int | None,
+    timeout_seconds: float,
+    allow_overfull_boxes: bool = False,
+    stream_output: bool = False,
+) -> int:
+    latexmk = shutil.which("latexmk")
+    if latexmk is None:
+        raise ReportPublisherError("latexmk is required for report publication")
+    if expected_page_count is not None and expected_page_count < 1:
+        raise ReportPublisherError("expected PDF page count must be positive")
+    if not math.isfinite(timeout_seconds) or timeout_seconds <= 0.0:
+        raise ReportPublisherError("PDF timeout must be finite and positive")
+    environment = os.environ.copy()
+    environment.update({"LANG": "C", "LC_ALL": "C", "LC_CTYPE": "C"})
+    try:
+        completed = subprocess.run(
+            (
+                latexmk,
+                "-pdf",
+                "-interaction=nonstopmode",
+                "-halt-on-error",
+                "-file-line-error",
+                "pyAmpliCol.tex",
+            ),
+            cwd=docs_dir,
+            check=False,
+            capture_output=not stream_output,
+            text=True,
+            env=environment,
+            timeout=timeout_seconds,
+        )
+    except subprocess.TimeoutExpired as error:
+        raise ReportPublisherError(
+            f"latexmk exceeded the {timeout_seconds:g}s publication timeout"
+        ) from error
+    if completed.returncode != 0:
+        if stream_output:
+            raise ReportPublisherError(
+                f"latexmk failed with exit {completed.returncode}; "
+                "see the compilation output above"
+            )
+        stdout = completed.stdout or ""
+        stderr = completed.stderr or ""
+        tail = "\n".join((*stdout.splitlines(), *stderr.splitlines())[-80:])
+        raise ReportPublisherError(
+            f"latexmk failed with exit {completed.returncode}:\n{tail}"
+        )
+    log_path = docs_dir / "pyAmpliCol.log"
+    try:
+        log = log_path.read_text(encoding="utf-8", errors="replace")
+        validate_latex_log(
+            log,
+            allow_overfull_boxes=allow_overfull_boxes,
+        )
+    except OSError as error:
+        raise ReportPublisherError(f"cannot read LaTeX log: {error}") from error
+    except StandaloneBuildError as error:
+        raise ReportPublisherError(str(error)) from error
+    matches = tuple(_PAGE_COUNT_RE.finditer(log))
+    if not matches:
+        raise ReportPublisherError("LaTeX log does not report a PDF page count")
+    page_count = int(matches[-1].group("pages"))
+    if (
+        expected_page_count is not None
+        and page_count != expected_page_count
+    ):
+        raise ReportPublisherError(
+            "compiled PDF page count differs from the expected stable layout: "
+            f"{page_count} != {expected_page_count}"
+        )
+    pdf = docs_dir / "pyAmpliCol.pdf"
+    if not pdf.is_file() or pdf.stat().st_size == 0:
+        raise ReportPublisherError("latexmk did not produce a non-empty PDF")
+    return page_count
+
+
+def _staged_publications(
+    staging_docs: Path,
+    service: ReportService,
+    table_names: tuple[str, ...],
+) -> tuple[tuple[Path, Path, str], ...]:
+    cache_names = tuple(
+        sorted(path.name for path in (staging_docs / "results").glob("*.json"))
+    )
+    return (
+        *(
+            (
+                staging_docs / "results" / name,
+                service.paths.results_dir / name,
+                f"results/{name}",
+            )
+            for name in cache_names
+        ),
+        *(
+            (
+                staging_docs / name,
+                service.paths.docs_dir / name,
+                name,
+            )
+            for name in table_names
+        ),
+        (
+            staging_docs / "pyAmpliCol.pdf",
+            service.paths.docs_dir / "pyAmpliCol.pdf",
+            "pyAmpliCol.pdf",
+        ),
+    )
+
+
+def _install_snapshot(
+    service: ReportService,
+    publications: tuple[tuple[Path, Path, str], ...],
+    manifest: Mapping[str, object],
+) -> None:
+    staging_root = publications[0][0].parents[2]
+    backup_root = staging_root / "previous"
+    backup_root.mkdir()
+    replaced: list[tuple[Path, Path | None]] = []
+    with _publisher_writer_lock(service):
+        try:
+            for source, destination, relative in publications:
+                if not source.is_file():
+                    raise ReportPublisherError(
+                        f"publication snapshot member is missing: {source}"
+                    )
+                destination.parent.mkdir(parents=True, exist_ok=True)
+                backup: Path | None = None
+                if destination.exists():
+                    backup = backup_root / relative
+                    backup.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(destination, backup)
+                temporary = destination.with_name(
+                    f".{destination.name}.publisher-{uuid.uuid4().hex}"
+                )
+                try:
+                    shutil.copy2(source, temporary)
+                    with temporary.open("rb") as stream:
+                        os.fsync(stream.fileno())
+                    os.replace(temporary, destination)
+                    _fsync_directory(destination.parent)
+                finally:
+                    temporary.unlink(missing_ok=True)
+                replaced.append((destination, backup))
+            _atomic_json(_snapshot_manifest_path(service), manifest)
+        except BaseException:
+            for destination, backup in reversed(replaced):
+                if backup is None:
+                    destination.unlink(missing_ok=True)
+                else:
+                    temporary = destination.with_name(
+                        f".{destination.name}.rollback-{uuid.uuid4().hex}"
+                    )
+                    try:
+                        shutil.copy2(backup, temporary)
+                        os.replace(temporary, destination)
+                    finally:
+                        temporary.unlink(missing_ok=True)
+            raise
+
+
+def validate_published_snapshot(service: ReportService) -> dict[str, object]:
+    """Validate only the committed schema and snapshot file identities."""
+
+    service.validate_payloads(service.load_caches())
+    path = _snapshot_manifest_path(service)
+    try:
+        payload = json.loads(path.read_text(encoding="ascii"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise ReportPublisherError(
+            f"cannot read publication snapshot manifest {path}: {error}"
+        ) from error
+    if not isinstance(payload, dict) or payload.get("schema") != (
+        PUBLICATION_SNAPSHOT_SCHEMA
+    ):
+        raise ReportPublisherError("publication snapshot manifest is malformed")
+    files = payload.get("files")
+    if not isinstance(files, list) or not files:
+        raise ReportPublisherError("publication snapshot file inventory is missing")
+    observed: list[dict[str, object]] = []
+    for index, item in enumerate(files):
+        if (
+            not isinstance(item, dict)
+            or set(item) != {"path", "sha256", "size"}
+            or not isinstance(item["path"], str)
+            or Path(item["path"]).is_absolute()
+            or ".." in Path(item["path"]).parts
+        ):
+            raise ReportPublisherError(
+                f"publication snapshot file record {index} is malformed"
+            )
+        source = service.paths.docs_dir / item["path"]
+        if (
+            not source.is_file()
+            or source.stat().st_size != item["size"]
+            or _sha256(source) != item["sha256"]
+        ):
+            raise ReportPublisherError(
+                f"published report differs from snapshot member {item['path']!r}"
+            )
+        observed.append(dict(item))
+    expected_digest = payload.get("snapshot_sha256")
+    unsigned = dict(payload)
+    unsigned.pop("snapshot_sha256", None)
+    if expected_digest != _digest_bytes(unsigned):
+        raise ReportPublisherError("publication snapshot digest does not recompute")
+    return {
+        "schema": PUBLICATION_SNAPSHOT_SCHEMA,
+        "snapshot_sha256": expected_digest,
+        "current_count": payload.get("current_count"),
+        "page_count": payload.get("page_count"),
+        "file_count": len(observed),
+        "status": "ok",
+    }
+
+
+def publish_once(
+    service: ReportService,
+    *,
+    expected_page_count: int = DEFAULT_EXPECTED_PAGE_COUNT,
+    pdf_timeout_seconds: float = DEFAULT_PDF_TIMEOUT_SECONDS,
+) -> PublicationResult:
+    """Render and compile an immutable current-pointer snapshot off-thread."""
+
+    source = require_eligible_report_source(service.paths.repo_root)
+    try:
+        profile_relative = service.paths.docs_dir.relative_to(
+            service.paths.repo_root / "docs/performance_reports"
+        )
+    except ValueError:
+        profile_relative = None
+    lineage = (
+        load_measurement_lineage(
+            service.paths.repo_root,
+            service.paths.docs_dir,
+            expected_active_revision=source.revision,
+            expected_active_tree=source.tree,
+        )
+        if profile_relative is not None and len(profile_relative.parts) == 1
+        else None
+    )
+    service.bind_measurement_lineage(lineage)
+    captured_at = _utc_now()
+    records, current_snapshot = _capture_current_records(service)
+    build_root = service.paths.artifact_root / "publication-builds"
+    build_root.mkdir(parents=True, exist_ok=True)
+    staging = Path(
+        tempfile.mkdtemp(prefix="report-publication-", dir=build_root)
+    )
+    try:
+        staging_docs = staging / "docs"
+        _copy_report_source(service.paths.docs_dir, staging_docs)
+        staging_service = ReportService(
+            ReportPaths.from_repo(
+                service.paths.repo_root,
+                docs_dir=staging_docs,
+                artifact_root=service.paths.artifact_root,
+                coordination_root=service.paths.coordination_root,
+            ),
+            catalog=service.catalog,
+        )
+        staging_service.bind_measurement_lineage(lineage)
+        caches = staging_service.load_caches()
+        staging_service.merge_current(caches, records)
+        tables = staging_service._render_tables(caches)
+        staging_service._snapshot_files(caches, tables)
+
+        checked_caches = staging_service.load_caches()
+        staging_service.validate_payloads(checked_caches)
+        rerendered = staging_service._render_tables(checked_caches)
+        if rerendered != tables:
+            raise ReportPublisherError(
+                "staged cache snapshot does not reproduce its staged tables"
+            )
+        page_count = _compile_pdf(
+            staging_docs,
+            expected_page_count=expected_page_count,
+            timeout_seconds=pdf_timeout_seconds,
+        )
+        publications = _staged_publications(
+            staging_docs,
+            service,
+            tuple(sorted(tables)),
+        )
+        file_inventory = [
+            {
+                "path": relative,
+                "size": source_path.stat().st_size,
+                "sha256": _sha256(source_path),
+            }
+            for source_path, _destination, relative in publications
+        ]
+        published_at = _utc_now()
+        manifest: dict[str, object] = {
+            "schema": PUBLICATION_SNAPSHOT_SCHEMA,
+            "source_revision": source.revision,
+            "source_tree": source.tree,
+            "captured_at_utc": captured_at,
+            "published_at_utc": published_at,
+            "current_count": len(current_snapshot),
+            "current_snapshot": list(current_snapshot),
+            "current_snapshot_sha256": _digest_bytes(current_snapshot),
+            "page_count": page_count,
+            "files": file_inventory,
+        }
+        manifest["snapshot_sha256"] = _digest_bytes(manifest)
+        _install_snapshot(service, publications, manifest)
+        validated = validate_published_snapshot(service)
+        if validated["snapshot_sha256"] != manifest["snapshot_sha256"]:
+            raise ReportPublisherError(
+                "installed publication snapshot identity changed"
+            )
+        return PublicationResult(
+            current_count=len(current_snapshot),
+            page_count=page_count,
+            snapshot_sha256=str(manifest["snapshot_sha256"]),
+            captured_at_utc=captured_at,
+            published_at_utc=published_at,
+        )
+    finally:
+        shutil.rmtree(staging, ignore_errors=True)
+
+
+def run_publisher(
+    service: ReportService,
+    *,
+    watch: bool,
+    interval_seconds: float = DEFAULT_PUBLICATION_INTERVAL_SECONDS,
+    expected_page_count: int = DEFAULT_EXPECTED_PAGE_COUNT,
+    pdf_timeout_seconds: float = DEFAULT_PDF_TIMEOUT_SECONDS,
+) -> PublicationResult:
+    """Publish immediately and optionally repeat at a start-to-start cadence."""
+
+    if not math.isfinite(interval_seconds) or interval_seconds <= 0.0:
+        raise ReportPublisherError(
+            "publication interval must be finite and positive"
+        )
+    with _publisher_state_lease(
+        service,
+        interval_seconds=interval_seconds,
+    ):
+        latest: PublicationResult | None = None
+        while True:
+            cycle_started = time.monotonic()
+            try:
+                latest = publish_once(
+                    service,
+                    expected_page_count=expected_page_count,
+                    pdf_timeout_seconds=pdf_timeout_seconds,
+                )
+                print(
+                    json.dumps(
+                        latest.as_dict(),
+                        allow_nan=False,
+                        sort_keys=True,
+                    ),
+                    flush=True,
+                )
+            except Exception as error:
+                print(
+                    json.dumps(
+                        {
+                            "schema": PUBLICATION_SNAPSHOT_SCHEMA,
+                            "status": "error",
+                            "kind": type(error).__name__,
+                            "message": str(error),
+                            "recorded_at_utc": _utc_now(),
+                        },
+                        allow_nan=False,
+                        sort_keys=True,
+                    ),
+                    flush=True,
+                )
+                if not watch:
+                    raise
+            if not watch:
+                assert latest is not None
+                return latest
+            remaining = interval_seconds - (
+                time.monotonic() - cycle_started
+            )
+            if remaining > 0.0:
+                time.sleep(remaining)
+
+
+__all__ = [
+    "DEFAULT_EXPECTED_PAGE_COUNT",
+    "DEFAULT_PDF_TIMEOUT_SECONDS",
+    "DEFAULT_PUBLICATION_INTERVAL_SECONDS",
+    "PUBLICATION_SNAPSHOT_SCHEMA",
+    "PublicationResult",
+    "ReportPublisherError",
+    "publish_once",
+    "run_publisher",
+    "validate_published_snapshot",
+]
diff --git a/pyamplicol/tools/performance_report/render.py b/pyamplicol/tools/performance_report/render.py
new file mode 100644
index 0000000000..636b4c244d
--- /dev/null
+++ b/pyamplicol/tools/performance_report/render.py
@@ -0,0 +1,5004 @@
+# SPDX-License-Identifier: 0BSD
+"""Dynamic baseline joins and fixed-block TeX rendering for the report tables."""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import re
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass, replace
+
+from .agreements import (
+    DIRECT_AGREEMENT_ABI,
+    DIRECT_AGREEMENT_FIELD,
+    DIRECT_AGREEMENT_V2_ABI,
+    LC_COMMON_COMPONENT_ABI,
+    LC_COMMON_COMPONENT_FIELD,
+    LC_LEGACY_PYAMPLICOL_COMPONENT,
+    incoming_agreement_edges,
+)
+from .cache import empty_measurement
+from .campaign_policy import (
+    STRICT_POLICY,
+    CampaignPolicy,
+    PolicyMeasurementState,
+    policy_measurement_state_hint,
+    policy_status_label,
+)
+from .catalog import (
+    REPORT_CATALOG,
+    STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6,
+    STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6_DESCRIPTION,
+    ReportCatalog,
+    matrix_multiplicities,
+    z_dataset_id,
+)
+from .display_contract import report_display_accounting
+from .models import (
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    MatrixComparisonView,
+    MatrixDataset,
+    ModelKey,
+    ProcessFamily,
+    ResultStatus,
+    ScalarDataset,
+    Workload,
+    ZVariant,
+)
+from .runner import (
+    OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD,
+    SelectorContract,
+    validate_on_the_fly_recurrence_authority_validation_record,
+)
+from .timing import (
+    evaluator_total_seconds_per_point,
+    evaluator_total_timing_record,
+    recurrence_core_seconds_per_point,
+    unavailable_execution_timing_record,
+)
+from .validation_summary import (
+    SUMMARY_TABLE_NAME,
+    render_validation_summary,
+)
+
+Measurement = Mapping[str, object]
+CachePayload = Mapping[str, object]
+
+_NA = empty_measurement()
+_MATRIX_BLOCK_SIZE = 3
+_Z_BLOCK_SIZE = 3
+_BEST_MODE_CODES = {
+    ExecutionMode.RECURRENCE: "r",
+    ExecutionMode.COMPILED: "c",
+    ExecutionMode.EAGER: "e",
+    ExecutionMode.ON_THE_FLY: "o",
+}
+_BEST_MODE_ORDER = tuple(_BEST_MODE_CODES)
+_BEST_MODE_TABLE_NAMES = {
+    Accuracy.LC: "result_matrix_best_builtin_sm_lc_table.tex",
+    Accuracy.NLC: "result_matrix_best_builtin_sm_nlc_table.tex",
+    Accuracy.FULL: "result_matrix_best_builtin_sm_full_table.tex",
+}
+_PRESENTATION_FAILURE_KIND_PREFIX = "ManualCampaignOutcome:"
+_SAFE_OUTCOME_SLUG = re.compile(r"[a-z][a-z0-9_-]{0,63}")
+_TIME_CAP_LABEL = re.compile(r">(?P<value>[0-9]+(?:\.[0-9]+)?)(?P<unit>h|s)")
+_RAM_CAP_LABEL = re.compile(r">(?P<value>[0-9]+)GB")
+_POLICY_PRESENTATION_OUTCOME_SLUGS = frozenset(
+    state.value
+    for state in PolicyMeasurementState
+    if state is not PolicyMeasurementState.SUCCESS
+)
+_MAX_BEST_MODE_TERMINAL_LABEL_CHARS = 48
+_TERMINAL_LABEL_DIGEST_CHARS = 6
+_KNOWN_PRESENTATION_TERMINAL_LABELS = {
+    "blocked_dependency": "blocked dependency",
+    "cancelled": "interrupted",
+    "error": "error",
+    "failed": "failed",
+    "generation_limit": "generation limit",
+    "interrupted": "interrupted",
+    "memory_limit": "memory limit",
+    "preparation_error": "preparation error",
+    "preparation_failed": "preparation failed",
+    "profiling_timeout": "profiling timeout",
+    "resource_frontier": "resource frontier",
+    "skip": "skip",
+    "static_na": "static na",
+    "unsupported": "unsupported",
+    "unverified": "unverified",
+    "validation_failed": "validation failed",
+    "validation_timeout": "validation timeout",
+    "worker_timeout": "worker timeout",
+}
+_KNOWN_PRESENTATION_TERMINAL_DISPLAY_LABELS = {
+    "blocked_dependency": "blocked dep.",
+}
+_KNOWN_RESULT_TERMINAL_LABELS = frozenset(
+    {
+        "N/A",
+        "t/o",
+        "RAM",
+        "skip",
+        "validation failed",
+        "unverified",
+        "unsupported",
+        "failed",
+        "error",
+    }
+)
+_POLICY_TERMINAL_DISPLAY_LABEL = re.compile(
+    r"(?:(?:worker|profile|validation) >[0-9]{1,4}(?:\.[0-9]{1,4})?(?:h|s)"
+    r"|>[0-9]{1,4}(?:\.[0-9]{1,4})?(?:h|s)|>[0-9]{1,4}GB"
+    r"|dependency(?: (?:>[0-9]{1,4}(?:\.[0-9]{1,4})?(?:h|s)"
+    r"|>[0-9]{1,4}GB|blocked))?)"
+)
+_COMPACT_OUTCOME_COUNT_LABEL = re.compile(
+    r"[1-9][0-9]* outcomes \[(?P<digest>[0-9a-f]{6})\]"
+)
+
+
+def _chunks(values: Sequence[int], size: int) -> tuple[tuple[int, ...], ...]:
+    return tuple(
+        tuple(values[start : start + size]) for start in range(0, len(values), size)
+    )
+
+
+def _cache_dataset_id(payload: CachePayload) -> str:
+    dataset_id = payload.get("dataset_id")
+    if not isinstance(dataset_id, str) or not dataset_id:
+        raise ValueError("cache payload has no dataset_id")
+    return dataset_id
+
+
+def _entry_key(
+    dataset_id: str,
+    entry: Mapping[str, object],
+) -> tuple[str, str | None, int, str, str | None]:
+    process_key = entry.get("process_key")
+    if process_key is not None and not isinstance(process_key, str):
+        raise ValueError("cache process_key must be a string or null")
+    n_final = entry.get("n_final")
+    if isinstance(n_final, bool) or not isinstance(n_final, int):
+        raise ValueError("cache n_final must be an integer")
+    workload = entry.get("workload")
+    if not isinstance(workload, str):
+        raise ValueError("cache workload must be a string")
+    variant = entry.get("variant")
+    if variant is not None and not isinstance(variant, str):
+        raise ValueError("cache variant must be a string or null")
+    return dataset_id, process_key, n_final, workload, variant
+
+
+class MeasurementIndex:
+    """Read-only index over mode-owned caches.
+
+    The index never copies measurements between datasets. Report views locate the
+    candidate and baseline independently and compute ratios while rendering.
+    """
+
+    def __init__(self, caches: Mapping[str, CachePayload] | Iterable[CachePayload]):
+        payloads = caches.values() if isinstance(caches, Mapping) else caches
+        entries: dict[
+            tuple[str, str | None, int, str, str | None],
+            Measurement,
+        ] = {}
+        for payload in payloads:
+            dataset_id = _cache_dataset_id(payload)
+            raw_entries = payload.get("entries")
+            if not isinstance(raw_entries, list):
+                raise ValueError(f"cache {dataset_id!r} has no entries list")
+            for raw_entry in raw_entries:
+                if not isinstance(raw_entry, Mapping):
+                    raise ValueError(
+                        f"cache {dataset_id!r} contains a non-object entry"
+                    )
+                key = _entry_key(dataset_id, raw_entry)
+                if key in entries:
+                    raise ValueError(f"duplicate report measurement key {key!r}")
+                measurement = raw_entry.get("measurement")
+                if not isinstance(measurement, Mapping):
+                    raise ValueError(f"cache entry {key!r} has no measurement object")
+                entries[key] = measurement
+        self._entries = entries
+
+    def get(
+        self,
+        dataset_id: str,
+        process_key: str | None,
+        n_final: int,
+        workload: Workload,
+        *,
+        variant: str | None = None,
+    ) -> Measurement:
+        return self._entries.get(
+            (dataset_id, process_key, n_final, workload.value, variant),
+            _NA,
+        )
+
+    def for_cell(self, cell: CellSpec) -> Measurement:
+        """Return the current measurement owned by one canonical catalog cell."""
+
+        return self.get(
+            cell.dataset_id,
+            cell.process_key,
+            cell.n_final,
+            cell.workload,
+            variant=cell.variant,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class JoinedWorkload:
+    workload: Workload
+    baseline: Measurement
+    candidate: Measurement
+    comparison_linked: bool = False
+    generation_comparison_linked: bool | None = None
+    legacy_diagnostic: Measurement | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class JoinedMatrixCell:
+    dataset: MatrixDataset
+    process_family: ProcessFamily
+    n_final: int
+    applicable: bool
+    workloads: tuple[JoinedWorkload, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _TerminalOutcome:
+    """One terminal result with identity and color kept separate from its label."""
+
+    identity: str
+    label: str
+    color: str
+
+
+@dataclass(frozen=True, slots=True)
+class _TerminalSummary:
+    """A bounded display label retaining every represented terminal outcome."""
+
+    outcomes: tuple[_TerminalOutcome, ...]
+    label: str
+    color: str
+
+
+@dataclass(frozen=True, slots=True)
+class BestModeWorkload:
+    workload: Workload
+    baseline: Measurement
+    candidate: Measurement
+    mode: ExecutionMode | None
+    terminal_label: _TerminalSummary | None
+    comparison_linked: bool = False
+    generation_comparison_linked: bool | None = None
+    legacy_diagnostic: Measurement | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class BestModeMatrixCell:
+    process_family: ProcessFamily
+    n_final: int
+    accuracy: Accuracy
+    applicable: bool
+    workloads: tuple[BestModeWorkload, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _BestModeComparisonLayout:
+    """One comparison token in both inline and column-aligned forms."""
+
+    inline: str
+    prefix: str
+    primary: str
+
+
+@dataclass(frozen=True, slots=True)
+class _BestModeCellRows:
+    """Physical generation/runtime rows for one multiplicity cell."""
+
+    generation: tuple[str, ...]
+    runtime: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _MatrixCellRows:
+    """Physical generation/runtime rows for one detailed matrix cell."""
+
+    generation: tuple[str, ...]
+    runtime: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class VisibleCompleteness:
+    """Render-level evidence for the publication's measured-cell contract."""
+
+    maximum_n_final: int
+    required_measurement_count: int
+    rendered_required_measurement_count: int
+    structurally_not_applicable_display_slot_count: int
+    not_exposed_display_slot_count: int
+    applicable_na_display_slots: tuple[str, ...]
+    missing_rendered_cell_ids: tuple[str, ...]
+    contract_errors: tuple[str, ...]
+    declared_measurement_cell_count: int = 0
+    catalog_static_na_cell_count: int = 0
+    rendered_catalog_static_na_cell_count: int = 0
+
+    @property
+    def complete(self) -> bool:
+        return not (
+            self.applicable_na_display_slots
+            or self.missing_rendered_cell_ids
+            or self.contract_errors
+            or self.declared_measurement_cell_count
+            != (self.required_measurement_count + self.catalog_static_na_cell_count)
+            or self.rendered_required_measurement_count
+            != self.required_measurement_count
+            or self.rendered_catalog_static_na_cell_count
+            != self.catalog_static_na_cell_count
+        )
+
+    def as_dict(self) -> dict[str, object]:
+        """Return compact, JSON-safe final-audit evidence."""
+
+        preview_limit = 50
+        return {
+            "kind": "pyamplicol-report-visible-completeness",
+            "schema_version": 2,
+            "status": "ok" if self.complete else "incomplete",
+            "maximum_n_final": self.maximum_n_final,
+            "declared_measurement_cell_count": (self.declared_measurement_cell_count),
+            "required_measurement_count": self.required_measurement_count,
+            "rendered_required_measurement_count": (
+                self.rendered_required_measurement_count
+            ),
+            "structurally_not_applicable_display_slot_count": (
+                self.structurally_not_applicable_display_slot_count
+            ),
+            "not_exposed_display_slot_count": self.not_exposed_display_slot_count,
+            "catalog_static_na_cell_count": self.catalog_static_na_cell_count,
+            "rendered_catalog_static_na_cell_count": (
+                self.rendered_catalog_static_na_cell_count
+            ),
+            "applicable_na_display_slot_count": len(self.applicable_na_display_slots),
+            "applicable_na_display_slots": list(
+                self.applicable_na_display_slots[:preview_limit]
+            ),
+            "missing_rendered_cell_count": len(self.missing_rendered_cell_ids),
+            "missing_rendered_cell_ids": list(
+                self.missing_rendered_cell_ids[:preview_limit]
+            ),
+            "contract_errors": list(self.contract_errors[:preview_limit]),
+        }
+
+
+class BaselineCandidateAdapter:
+    """Join candidate measurements to their canonical baseline at render time."""
+
+    def __init__(
+        self,
+        caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+        *,
+        catalog: ReportCatalog = REPORT_CATALOG,
+    ):
+        self.catalog = catalog
+        self.index = MeasurementIndex(caches)
+        self._cells = {
+            (
+                cell.dataset_id,
+                cell.process_key,
+                cell.n_final,
+                cell.workload,
+                cell.variant,
+            ): cell
+            for cell in catalog.measurement_cells()
+        }
+
+    def _cell(
+        self,
+        dataset_id: str,
+        process_key: str,
+        n_final: int,
+        workload: Workload,
+        *,
+        variant: str | None = None,
+    ) -> CellSpec:
+        return self._cells[(dataset_id, process_key, n_final, workload, variant)]
+
+    @staticmethod
+    def _finite_number(value: object) -> bool:
+        return (
+            not isinstance(value, bool)
+            and isinstance(value, (int, float))
+            and math.isfinite(float(value))
+        )
+
+    @classmethod
+    def _exact_number(cls, value: object, expected: object) -> bool:
+        if not cls._finite_number(value) or not cls._finite_number(expected):
+            return False
+        return float(value) == float(expected)
+
+    @staticmethod
+    def _selectors_match(
+        candidate_cell: CellSpec,
+        candidate: Measurement,
+        baseline: Measurement,
+    ) -> bool:
+        candidate_selector = candidate.get("selector_contract")
+        baseline_selector = baseline.get("selector_contract")
+        if candidate_cell.measurement.accuracy is Accuracy.LC:
+            return (
+                isinstance(candidate_selector, Mapping)
+                and isinstance(baseline_selector, Mapping)
+                and candidate_selector == baseline_selector
+            )
+        return candidate_selector is None and baseline_selector is None
+
+    @staticmethod
+    def _component(
+        cell: CellSpec,
+        measurement: Measurement,
+    ) -> Mapping[str, object] | None:
+        validation = measurement.get("validation")
+        component = (
+            validation.get(LC_COMMON_COMPONENT_FIELD)
+            if isinstance(validation, Mapping)
+            else None
+        )
+        if not isinstance(component, Mapping):
+            return None
+        if (
+            component.get("abi") != LC_COMMON_COMPONENT_ABI
+            or component.get("cell_id") != cell.cell_id
+            or not BaselineCandidateAdapter._finite_number(component.get("value"))
+        ):
+            return None
+        return component
+
+    def _direct_agreement_link(
+        self,
+        candidate_cell: CellSpec,
+        candidate: Measurement,
+        baseline_cell: CellSpec,
+        baseline: Measurement,
+    ) -> bool:
+        matching_edges = tuple(
+            edge
+            for edge in incoming_agreement_edges(
+                candidate_cell,
+                catalog=self.catalog,
+            )
+            if edge.baseline.cell_id == baseline_cell.cell_id
+        )
+        if not matching_edges:
+            return False
+        validation = candidate.get("validation")
+        records = (
+            validation.get(DIRECT_AGREEMENT_FIELD)
+            if isinstance(validation, Mapping)
+            else None
+        )
+        if not isinstance(records, list):
+            return False
+        for edge in matching_edges:
+            record = next(
+                (
+                    item
+                    for item in records
+                    if isinstance(item, Mapping)
+                    and item.get("abi")
+                    in {DIRECT_AGREEMENT_ABI, DIRECT_AGREEMENT_V2_ABI}
+                    and item.get("edge_kind") == edge.kind
+                    and item.get("value_kind") == edge.value_kind
+                    and item.get("candidate_cell_id") == candidate_cell.cell_id
+                    and item.get("baseline_cell_id") == baseline_cell.cell_id
+                    and (
+                        item.get("status") == ResultStatus.OK.value
+                        or (
+                            edge.kind == LC_LEGACY_PYAMPLICOL_COMPONENT
+                            and item.get("status")
+                            == ResultStatus.VALIDATION_FAILED.value
+                        )
+                    )
+                ),
+                None,
+            )
+            if record is None:
+                continue
+            if edge.value_kind == "matrix_element":
+                candidate_value = candidate.get("matrix_element")
+                baseline_value = baseline.get("matrix_element")
+            else:
+                candidate_component = self._component(candidate_cell, candidate)
+                baseline_component = self._component(baseline_cell, baseline)
+                if candidate_component is None or baseline_component is None:
+                    continue
+                identity_fields = (
+                    "point_digest",
+                    "helicity_ids",
+                    "color_flow_ids",
+                )
+                if any(
+                    candidate_component.get(field) != baseline_component.get(field)
+                    for field in identity_fields
+                ):
+                    continue
+                candidate_value = candidate_component.get("value")
+                baseline_value = baseline_component.get("value")
+            if self._exact_number(
+                record.get("candidate"),
+                candidate_value,
+            ) and self._exact_number(
+                record.get("baseline"),
+                baseline_value,
+            ):
+                return True
+        return False
+
+    def _direct_link(
+        self,
+        candidate_cell: CellSpec,
+        candidate: Measurement,
+        baseline_cell: CellSpec,
+        baseline: Measurement,
+    ) -> bool:
+        if not (_ok(candidate) and _ok(baseline)) or not self._selectors_match(
+            candidate_cell,
+            candidate,
+            baseline,
+        ):
+            return False
+        matching_edges = tuple(
+            edge
+            for edge in incoming_agreement_edges(
+                candidate_cell,
+                catalog=self.catalog,
+            )
+            if edge.baseline.cell_id == baseline_cell.cell_id
+        )
+        if matching_edges:
+            return self._direct_agreement_link(
+                candidate_cell,
+                candidate,
+                baseline_cell,
+                baseline,
+            )
+        canonical_baseline = self.catalog.validation_baseline_cell(candidate_cell)
+        if (
+            canonical_baseline is None
+            or canonical_baseline.cell_id != baseline_cell.cell_id
+        ):
+            return False
+        validation = candidate.get("validation")
+        pointwise = (
+            validation.get("pointwise") if isinstance(validation, Mapping) else None
+        )
+        comparison_status = (
+            pointwise.get("status") if isinstance(pointwise, Mapping) else None
+        )
+        legacy_diagnostic = (
+            baseline_cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+            and candidate_cell.measurement.execution_mode
+            is ExecutionMode.RECURRENCE
+        )
+        return (
+            isinstance(pointwise, Mapping)
+            and (
+                comparison_status == ResultStatus.OK.value
+                or (
+                    legacy_diagnostic
+                    and comparison_status == ResultStatus.VALIDATION_FAILED.value
+                )
+            )
+            and self._exact_number(
+                pointwise.get("candidate"),
+                candidate.get("matrix_element"),
+            )
+            and self._exact_number(
+                pointwise.get("baseline"),
+                baseline.get("matrix_element"),
+            )
+        )
+
+    def _recurrence_bridge(self, candidate_cell: CellSpec) -> CellSpec | None:
+        baseline = self.catalog.validation_baseline_cell(candidate_cell)
+        if (
+            baseline is not None
+            and baseline.measurement.execution_mode is ExecutionMode.RECURRENCE
+        ):
+            return baseline
+        peers = tuple(
+            edge.baseline
+            for edge in incoming_agreement_edges(
+                candidate_cell,
+                catalog=self.catalog,
+            )
+            if edge.baseline.measurement.execution_mode is ExecutionMode.RECURRENCE
+        )
+        return peers[0] if len(peers) == 1 else None
+
+    def _legacy_diagnostic_measurement(
+        self,
+        candidate_cell: CellSpec,
+        candidate: Measurement,
+        baseline_cell: CellSpec,
+    ) -> Measurement | None:
+        """Locate the recurrence record that compared with legacy AmpliCol."""
+
+        if (
+            baseline_cell.measurement.execution_mode
+            is not ExecutionMode.AMPLICOL
+        ):
+            return None
+        if (
+            candidate_cell.measurement.execution_mode
+            is ExecutionMode.RECURRENCE
+        ):
+            return candidate
+        recurrence_cell = self._recurrence_bridge(candidate_cell)
+        return (
+            None
+            if recurrence_cell is None
+            else self.index.for_cell(recurrence_cell)
+        )
+
+    @staticmethod
+    def _runtime_artifact_id(measurement: Measurement) -> str | None:
+        provenance = measurement.get("provenance")
+        runtime_identity = (
+            provenance.get("runtime_identity")
+            if isinstance(provenance, Mapping)
+            else None
+        )
+        artifact_id = (
+            runtime_identity.get("artifact_id")
+            if isinstance(runtime_identity, Mapping)
+            else None
+        )
+        return artifact_id if isinstance(artifact_id, str) else None
+
+    def _otf_recurrence_authority_link(
+        self,
+        candidate_cell: CellSpec,
+        candidate: Measurement,
+        recurrence_cell: CellSpec,
+        recurrence: Measurement,
+    ) -> bool:
+        """Authenticate the dedicated OTF-to-recurrence numerical edge."""
+
+        if not (_ok(candidate) and _ok(recurrence)) or not self._selectors_match(
+            candidate_cell,
+            candidate,
+            recurrence,
+        ):
+            return False
+        validation = candidate.get("validation")
+        authority_record = (
+            validation.get(OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD)
+            if isinstance(validation, Mapping)
+            else None
+        )
+        authority = (
+            authority_record.get("authority")
+            if isinstance(authority_record, Mapping)
+            else None
+        )
+        candidate_artifact_id = self._runtime_artifact_id(candidate)
+        recurrence_artifact_id = self._runtime_artifact_id(recurrence)
+        if (
+            candidate_artifact_id is None
+            or recurrence_artifact_id is None
+            or not isinstance(authority, Mapping)
+            or authority.get("artifact_id") != recurrence_artifact_id
+        ):
+            return False
+        try:
+            validate_on_the_fly_recurrence_authority_validation_record(
+                authority_record,
+                expected_cell=candidate_cell,
+                selector_contract=candidate.get("selector_contract"),
+                candidate_artifact_id=candidate_artifact_id,
+                expected_authority_cell_id=recurrence_cell.cell_id,
+            )
+        except (TypeError, ValueError):
+            return False
+        return True
+
+    @staticmethod
+    def _same_performance_scope(
+        candidate_cell: CellSpec,
+        baseline_cell: CellSpec,
+    ) -> bool:
+        """Match process-wide timing identities without using a numerical edge."""
+
+        return (
+            candidate_cell.process == baseline_cell.process
+            and candidate_cell.process_key == baseline_cell.process_key
+            and candidate_cell.n_final == baseline_cell.n_final
+            and candidate_cell.workload is baseline_cell.workload
+            and candidate_cell.measurement.model is ModelKey.BUILTIN_SM
+            and baseline_cell.measurement.model is None
+            and candidate_cell.measurement.accuracy
+            is baseline_cell.measurement.accuracy
+        )
+
+    @staticmethod
+    def _otf_amplicol_runtime_selectors_match(
+        workload: Workload,
+        candidate: Measurement,
+        baseline: Measurement,
+    ) -> bool:
+        candidate_selector = candidate.get("selector_contract")
+        baseline_selector = baseline.get("selector_contract")
+        if not isinstance(candidate_selector, Mapping) or not isinstance(
+            baseline_selector,
+            Mapping,
+        ):
+            return False
+        try:
+            candidate_contract = SelectorContract.from_mapping(candidate_selector)
+            baseline_contract = SelectorContract.from_mapping(baseline_selector)
+        except (TypeError, ValueError):
+            return False
+        if workload is Workload.SELECTED_FLOW:
+            return candidate_contract == baseline_contract
+        if workload is Workload.ALL_FLOW:
+            return (
+                candidate_contract.point_digest == baseline_contract.point_digest
+                and candidate_contract.all_flow_helicity_ids
+                == baseline_contract.all_flow_helicity_ids
+                and candidate_contract.all_flow_source_helicities
+                == baseline_contract.all_flow_source_helicities
+            )
+        return False
+
+    def _otf_amplicol_performance_link(
+        self,
+        candidate_cell: CellSpec,
+        candidate: Measurement,
+        baseline_cell: CellSpec,
+        baseline: Measurement,
+        *,
+        require_runtime_selectors: bool,
+    ) -> bool:
+        if (
+            candidate_cell.measurement.accuracy is not Accuracy.LC
+            or candidate_cell.workload
+            not in {Workload.SELECTED_FLOW, Workload.ALL_FLOW}
+            or not (_ok(candidate) and _ok(baseline))
+            or not self._same_performance_scope(candidate_cell, baseline_cell)
+        ):
+            return False
+        recurrence_cell = self._recurrence_bridge(candidate_cell)
+        if recurrence_cell is None:
+            return False
+        recurrence = self.index.for_cell(recurrence_cell)
+        if not self._otf_recurrence_authority_link(
+            candidate_cell,
+            candidate,
+            recurrence_cell,
+            recurrence,
+        ):
+            return False
+        return not require_runtime_selectors or (
+            self._otf_amplicol_runtime_selectors_match(
+                candidate_cell.workload,
+                candidate,
+                baseline,
+            )
+        )
+
+    def _comparison_linked(
+        self,
+        candidate_cell: CellSpec,
+        candidate: Measurement,
+        baseline_cell: CellSpec,
+        baseline: Measurement,
+    ) -> bool:
+        if (
+            baseline_cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+            and candidate_cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+            and candidate_cell.measurement.accuracy is Accuracy.LC
+        ):
+            return self._otf_amplicol_performance_link(
+                candidate_cell,
+                candidate,
+                baseline_cell,
+                baseline,
+                require_runtime_selectors=True,
+            )
+        if (
+            baseline_cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+            and candidate_cell.measurement.execution_mode
+            in {
+                ExecutionMode.COMPILED,
+                ExecutionMode.EAGER,
+                ExecutionMode.ON_THE_FLY,
+            }
+        ):
+            recurrence_cell = self._recurrence_bridge(candidate_cell)
+            if recurrence_cell is None:
+                return False
+            recurrence = self.index.for_cell(recurrence_cell)
+            return self._direct_link(
+                candidate_cell,
+                candidate,
+                recurrence_cell,
+                recurrence,
+            ) and self._direct_link(
+                recurrence_cell,
+                recurrence,
+                baseline_cell,
+                baseline,
+            )
+        return self._direct_link(
+            candidate_cell,
+            candidate,
+            baseline_cell,
+            baseline,
+        )
+
+    def _generation_comparison_linked(
+        self,
+        candidate_cell: CellSpec,
+        candidate: Measurement,
+        baseline_cell: CellSpec,
+        baseline: Measurement,
+    ) -> bool:
+        if (
+            baseline_cell.measurement.execution_mode is ExecutionMode.AMPLICOL
+            and candidate_cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+            and candidate_cell.measurement.accuracy is Accuracy.LC
+        ):
+            return self._otf_amplicol_performance_link(
+                candidate_cell,
+                candidate,
+                baseline_cell,
+                baseline,
+                require_runtime_selectors=False,
+            )
+        return self._comparison_linked(
+            candidate_cell,
+            candidate,
+            baseline_cell,
+            baseline,
+        )
+
+    def _best_mode_candidate(
+        self,
+        cell: CellSpec,
+    ) -> tuple[CellSpec, Measurement]:
+        """Resolve one mode across its owned and exact-equivalent attempts.
+
+        Campaign planning follows the same precedence: an existing current owned
+        by the requested cell wins before a reusable equivalent current.  The
+        report must nevertheless see an equivalent Z-ladder success when the
+        matrix-owned cell contains only a terminal outcome.  If neither surface
+        succeeded, retain the owned terminal before an equivalent terminal so
+        the recurrence fallback can report the attempt that actually ran.
+        """
+
+        measurement = self.index.for_cell(cell)
+        if _runtime_value(measurement) is not None:
+            return cell, measurement
+        equivalents = self.catalog.equivalent_cells(cell)
+        for equivalent in equivalents:
+            equivalent_measurement = self.index.for_cell(equivalent)
+            if _runtime_value(equivalent_measurement) is not None:
+                return equivalent, equivalent_measurement
+        if _terminal_measurement_label(measurement) is not None:
+            return cell, measurement
+        for equivalent in equivalents:
+            equivalent_measurement = self.index.for_cell(equivalent)
+            if _terminal_measurement_label(equivalent_measurement) is not None:
+                return equivalent, equivalent_measurement
+        return cell, measurement
+
+    def matrix_cell(
+        self,
+        dataset: MatrixDataset,
+        family: ProcessFamily,
+        n_final: int,
+        *,
+        baseline_dataset_id: str | None = None,
+    ) -> JoinedMatrixCell:
+        process = family.process(n_final)
+        applicable = (
+            process is not None
+            and n_final in dataset.multiplicities
+            and n_final <= family.maximum_n(dataset.candidate.accuracy)
+        )
+        workloads = (
+            (Workload.SELECTED_FLOW, Workload.ALL_FLOW)
+            if dataset.candidate.accuracy is Accuracy.LC
+            else (Workload.CONTRACTED,)
+        )
+        if not applicable:
+            joined = tuple(JoinedWorkload(workload, _NA, _NA) for workload in workloads)
+        else:
+            joined_items: list[JoinedWorkload] = []
+            for workload in workloads:
+                candidate_cell = self._cell(
+                    dataset.dataset_id,
+                    family.key,
+                    n_final,
+                    workload,
+                )
+                baseline_cell = (
+                    self.catalog.baseline_cell(candidate_cell)
+                    if baseline_dataset_id is None
+                    else self._cell(
+                        baseline_dataset_id,
+                        family.key,
+                        n_final,
+                        workload,
+                    )
+                )
+                assert baseline_cell is not None
+                candidate = self.index.for_cell(candidate_cell)
+                baseline = self.index.for_cell(baseline_cell)
+                comparison_linked = self._comparison_linked(
+                    candidate_cell,
+                    candidate,
+                    baseline_cell,
+                    baseline,
+                )
+                joined_items.append(
+                    JoinedWorkload(
+                        workload,
+                        baseline,
+                        candidate,
+                        comparison_linked,
+                        self._generation_comparison_linked(
+                            candidate_cell,
+                            candidate,
+                            baseline_cell,
+                            baseline,
+                        ),
+                        self._legacy_diagnostic_measurement(
+                            candidate_cell,
+                            candidate,
+                            baseline_cell,
+                        ),
+                    )
+                )
+            joined = tuple(joined_items)
+        return JoinedMatrixCell(dataset, family, n_final, applicable, joined)
+
+    def z_workload(
+        self,
+        *,
+        model: ModelKey,
+        n_final: int,
+        variant: ZVariant,
+        workload: Workload,
+    ) -> JoinedWorkload:
+        baseline = self.index.get(
+            "reference_amplicol_lc",
+            "dd_z_jets",
+            n_final,
+            workload,
+        )
+        if variant.execution_mode is ExecutionMode.AMPLICOL:
+            return JoinedWorkload(workload, baseline, baseline)
+        candidate_cell = self._cell(
+            z_dataset_id(model),
+            "dd_z_jets",
+            n_final,
+            workload,
+            variant=variant.key,
+        )
+        baseline_cell = self.catalog.baseline_cell(candidate_cell)
+        assert baseline_cell is not None
+        candidate = self.index.for_cell(candidate_cell)
+        comparison_linked = self._comparison_linked(
+            candidate_cell,
+            candidate,
+            baseline_cell,
+            baseline,
+        )
+        return JoinedWorkload(
+            workload,
+            baseline,
+            candidate,
+            comparison_linked,
+            self._generation_comparison_linked(
+                candidate_cell,
+                candidate,
+                baseline_cell,
+                baseline,
+            ),
+            self._legacy_diagnostic_measurement(
+                candidate_cell,
+                candidate,
+                baseline_cell,
+            ),
+        )
+
+    def best_mode_cell(
+        self,
+        accuracy: Accuracy,
+        family: ProcessFamily,
+        n_final: int,
+    ) -> BestModeMatrixCell:
+        """Join AmpliCol to the fastest valid built-in-SM mode per workload."""
+
+        process = family.process(n_final)
+        multiplicities = matrix_multiplicities(accuracy)
+        applicable = (
+            process is not None
+            and n_final in multiplicities
+            and n_final <= family.maximum_n(accuracy)
+        )
+        workloads = (
+            (Workload.SELECTED_FLOW, Workload.ALL_FLOW)
+            if accuracy is Accuracy.LC
+            else (Workload.CONTRACTED,)
+        )
+        if not applicable:
+            joined = tuple(
+                BestModeWorkload(workload, _NA, _NA, None, None)
+                for workload in workloads
+            )
+            return BestModeMatrixCell(
+                family,
+                n_final,
+                accuracy,
+                applicable,
+                joined,
+            )
+
+        baseline_dataset = f"reference_amplicol_{accuracy.value}"
+        joined_workloads: list[BestModeWorkload] = []
+        for workload in workloads:
+            baseline_cell = self._cell(
+                baseline_dataset,
+                family.key,
+                n_final,
+                workload,
+            )
+            baseline = self.index.for_cell(baseline_cell)
+            candidate_datasets = tuple(
+                (
+                    mode,
+                    "matrix_"
+                    f"{mode.value.replace('-', '_')}_builtin_sm_"
+                    f"{accuracy.value}",
+                )
+                for mode in _BEST_MODE_ORDER
+            )
+            candidates = tuple(
+                (
+                    mode,
+                    self._cell(
+                        dataset_id,
+                        family.key,
+                        n_final,
+                        workload,
+                    ),
+                )
+                for mode, dataset_id in candidate_datasets
+                if n_final in self.catalog.dataset(dataset_id).multiplicities
+            )
+            measured_candidates = tuple(
+                (mode, *self._best_mode_candidate(cell)) for mode, cell in candidates
+            )
+            eligible = tuple(
+                (mode, cell, measurement)
+                for mode, cell, measurement in measured_candidates
+                if _runtime_value(measurement) is not None
+            )
+            if eligible:
+                winner_mode, winner_cell, winner = min(
+                    eligible,
+                    key=lambda item: (
+                        _runtime_value(item[2]),
+                        _BEST_MODE_ORDER.index(item[0]),
+                    ),
+                )
+                terminal_label = None
+                comparison_linked = self._comparison_linked(
+                    winner_cell,
+                    winner,
+                    baseline_cell,
+                    baseline,
+                )
+                generation_comparison_linked = self._generation_comparison_linked(
+                    winner_cell,
+                    winner,
+                    baseline_cell,
+                    baseline,
+                )
+                legacy_diagnostic = self._legacy_diagnostic_measurement(
+                    winner_cell,
+                    winner,
+                    baseline_cell,
+                )
+            else:
+                _recurrence_mode, recurrence_cell, recurrence = next(
+                    candidate
+                    for candidate in measured_candidates
+                    if candidate[0] is ExecutionMode.RECURRENCE
+                )
+                if _terminal_measurement_label(recurrence) is None:
+                    winner_mode, winner = None, _NA
+                else:
+                    winner_mode, winner = ExecutionMode.RECURRENCE, recurrence
+                terminal_label = None
+                comparison_linked = False
+                generation_comparison_linked = False
+                legacy_diagnostic = self._legacy_diagnostic_measurement(
+                    recurrence_cell,
+                    recurrence,
+                    baseline_cell,
+                )
+            joined_workloads.append(
+                BestModeWorkload(
+                    workload,
+                    baseline,
+                    winner,
+                    winner_mode,
+                    terminal_label,
+                    comparison_linked,
+                    generation_comparison_linked,
+                    legacy_diagnostic,
+                )
+            )
+        return BestModeMatrixCell(
+            family,
+            n_final,
+            accuracy,
+            applicable,
+            tuple(joined_workloads),
+        )
+
+
+def _tex_escape(value: str) -> str:
+    replacements = {
+        "\\": r"\textbackslash{}",
+        "&": r"\&",
+        "%": r"\%",
+        "$": r"\$",
+        "#": r"\#",
+        "_": r"\_",
+        "{": r"\{",
+        "}": r"\}",
+        "~": r"\textasciitilde{}",
+        "^": r"\textasciicircum{}",
+    }
+    return "".join(replacements.get(character, character) for character in value)
+
+
+def _compact(value: float) -> str:
+    return f"{value:.3g}"
+
+
+def _timing_value(value: float) -> str:
+    return f"{value:.6g}"
+
+
+def _best_mode_value(value: float) -> str:
+    """Render exactly three significant digits in compact overview tables."""
+
+    rendered = f"{value:#.3g}"
+    if "e" not in rendered and "E" not in rendered and rendered.endswith("."):
+        return rendered[:-1]
+    return rendered
+
+
+def _best_mode_time(value: object, *, microseconds: bool = False) -> str:
+    if value is None:
+        return r"\matrixna{ReportMuted}"
+    number = float(value)
+    if not math.isfinite(number):
+        return r"\matrixna{ReportMuted}"
+    if microseconds:
+        number *= 1.0e6
+    return rf"\texttt{{{_best_mode_value(number)}}}"
+
+
+def _best_mode_ratio_color(value: float) -> str:
+    if value < 1.0:
+        return "ReportGreen"
+    if value < 2.0:
+        return "ReportOrange"
+    return "ReportRed"
+
+
+def _metric_group_span(accuracy: Accuracy) -> int:
+    return 8 if accuracy is Accuracy.LC else 3
+
+
+def _metric_group_column_spec(accuracy: Accuracy) -> str:
+    """Physical value columns shared by detailed and best-mode tables.
+
+    Ordinary inter-column padding is intentional: ``colortbl`` paints it as
+    part of a coloured row.  Non-zero ``@{...}`` inserts leave unpainted seams
+    through alternating row bands, so ``@{}`` is used only where two fragments
+    form one visually continuous value.
+    """
+
+    font = r"\matrixentryfontlc" if accuracy is Accuracy.LC else r"\matrixentryfont"
+    if accuracy is Accuracy.LC:
+        return (
+            rf">{{{font}}}l"
+            rf">{{{font}}}c"
+            rf">{{{font}}}l"
+            rf">{{{font}}}r"
+            r"@{}"
+            rf">{{{font}}}l"
+            rf">{{{font}}}c"
+            rf">{{{font}}}r"
+            r"@{}"
+            rf">{{{font}}}l"
+        )
+    return (
+        rf">{{{font}}}l"
+        rf">{{{font}}}r"
+        r"@{}"
+        rf">{{{font}}}l"
+    )
+
+
+def _metric_table_column_spec(
+    accuracy: Accuracy,
+    multiplicity_count: int,
+) -> str:
+    multiplicity_groups = "".join(
+        _metric_group_column_spec(accuracy) for _ in range(multiplicity_count)
+    )
+    return r"@{}rL{1.45in}l" + multiplicity_groups + r"@{}"
+
+
+def _metric_group_cell(
+    content: str,
+    accuracy: Accuracy,
+    *,
+    alignment: str = "c",
+) -> str:
+    if alignment not in {"c", "l", "r"}:
+        raise ValueError(f"unsupported metric-group alignment: {alignment}")
+    return (
+        rf"\multicolumn{{{_metric_group_span(accuracy)}}}"
+        rf"{{{alignment}}}{{{content}}}"
+    )
+
+
+def _metric_summary_group_cell(
+    content: str,
+    accuracy: Accuracy,
+    *,
+    group_index: int,
+) -> str:
+    """Render one centred summary group with block-local band shading."""
+
+    if group_index % 2 == 0:
+        content = rf"\cellcolor{{refblue}}{content}"
+    return _metric_group_cell(content, accuracy, alignment="c")
+
+
+def _metric_summary_header_row(
+    multiplicities: Sequence[int],
+    accuracy: Accuracy,
+    *,
+    annotations: Sequence[str] | None = None,
+) -> str:
+    """Repeat the multiplicity headings immediately above summary rows."""
+
+    if annotations is None:
+        annotations = ("",) * len(multiplicities)
+    if len(annotations) != len(multiplicities):
+        raise ValueError("summary header annotations must match multiplicities")
+
+    return (
+        r"\multicolumn{3}{@{}l}{} & "
+        + " & ".join(
+            _metric_summary_group_cell(
+                (
+                    rf"\textbf{{n={n_final}}}"
+                    + (rf"\hspace{{0.08in}}{annotation}" if annotation else "")
+                ),
+                accuracy,
+                group_index=group_index,
+            )
+            for group_index, (n_final, annotation) in enumerate(
+                zip(multiplicities, annotations, strict=True)
+            )
+        )
+        + r" \\"
+    )
+
+
+def _matrix_wall_summary_label(accuracy: Accuracy) -> str:
+    if accuracy is Accuracy.LC:
+        return (
+            r"\matrixsummaryworkloads"
+            r"{\textbf{summary: run single-flow, hel. sum}}"
+            r"{\textbf{summary: run all-flows, single hel.}}"
+        )
+    return r"\textbf{summary: wall}"
+
+
+def _metric_row_label(*, runtime: bool) -> str:
+    label = r"run [\(\mu\mathrm{s}/\mathrm{pt}\)]" if runtime else r"gen. [s]"
+    return rf"\textcolor{{ReportMuted}}{{\scriptsize {label}}}"
+
+
+def _time(value: object, *, microseconds: bool = False) -> str:
+    if value is None:
+        return r"\matrixna{ReportMuted}"
+    number = float(value)
+    if not math.isfinite(number):
+        return r"\matrixna{ReportMuted}"
+    if microseconds:
+        number *= 1.0e6
+    return rf"\texttt{{{_timing_value(number)}}}"
+
+
+def _unavailable_time(
+    measurement: Measurement,
+    field: str,
+    *,
+    microseconds: bool = False,
+) -> str | None:
+    record = unavailable_execution_timing_record(measurement, field)
+    if record is None:
+        return None
+    total_record = evaluator_total_timing_record(measurement)
+    if total_record is not None:
+        return (
+            r"\matrixtotalevaluator{"
+            + _time(
+                total_record["raw_seconds_per_point"],
+                microseconds=microseconds,
+            )
+            + "}"
+        )
+    return _not_exposed()
+
+
+def _presentation_outcome(
+    measurement: Measurement,
+) -> tuple[str, str] | None:
+    failure = measurement.get("failure")
+    if not isinstance(failure, Mapping):
+        return None
+    kind = failure.get("kind")
+    message = failure.get("message")
+    if (
+        not isinstance(kind, str)
+        or not kind.startswith(_PRESENTATION_FAILURE_KIND_PREFIX)
+        or not isinstance(message, str)
+        or not message
+    ):
+        return None
+    slug = kind.removeprefix(_PRESENTATION_FAILURE_KIND_PREFIX)
+    if _SAFE_OUTCOME_SLUG.fullmatch(slug) is None:
+        return None
+    return slug, message
+
+
+def _visible_status(measurement: Measurement) -> _TerminalOutcome:
+    """Return a visible label whose classification does not depend on its text."""
+
+    status = str(measurement.get("status", ResultStatus.NOT_AVAILABLE.value))
+    policy_label = policy_status_label(measurement)
+    if policy_label is not None:
+        policy_state = policy_measurement_state_hint(measurement)
+        display_label = (
+            "dependency"
+            if policy_state
+            in {
+                PolicyMeasurementState.DEPENDENCY,
+                PolicyMeasurementState.RESOURCE_FRONTIER,
+            }
+            else policy_label
+        )
+        return _TerminalOutcome(
+            identity=(
+                f"policy:{policy_state.value}"
+                if policy_state is not None
+                else f"policy-label:{policy_label}"
+            ),
+            label=display_label,
+            color="ReportOrange",
+        )
+    presentation = _presentation_outcome(measurement)
+    if presentation is not None:
+        slug, label = presentation
+        return _TerminalOutcome(
+            identity=f"presentation:{slug}",
+            label=label,
+            color=(
+                "ReportOrange"
+                if slug in _POLICY_PRESENTATION_OUTCOME_SLUGS
+                or slug == ResultStatus.UNVERIFIED.value
+                else "ReportRed"
+            ),
+        )
+    labels = {
+        ResultStatus.NOT_AVAILABLE.value: "N/A",
+        ResultStatus.TIMEOUT.value: "t/o",
+        ResultStatus.MEMORY_LIMIT.value: "RAM",
+        ResultStatus.SKIP.value: "skip",
+        ResultStatus.VALIDATION_FAILED.value: "validation failed",
+        ResultStatus.UNVERIFIED.value: "unverified",
+        ResultStatus.UNSUPPORTED.value: "unsupported",
+        ResultStatus.FAILED.value: "failed",
+        ResultStatus.ERROR.value: "error",
+    }
+    label = labels.get(status, status)
+    color = (
+        "ReportMuted"
+        if status == ResultStatus.NOT_AVAILABLE.value
+        else "ReportOrange"
+        if status == ResultStatus.UNVERIFIED.value
+        else "ReportRed"
+    )
+    return _TerminalOutcome(
+        identity=f"result:{status}",
+        label=label,
+        color=color,
+    )
+
+
+def _visible_status_label(measurement: Measurement) -> tuple[str, str]:
+    visible = _visible_status(measurement)
+    return _compact_terminal_display(visible), visible.color
+
+
+def _compact_terminal_display(outcome: _TerminalOutcome) -> str:
+    """Bound hostile/future labels while retaining one stable identity token."""
+
+    identity_kind, _, identity_value = outcome.identity.partition(":")
+    known_presentation = (
+        identity_kind == "presentation"
+        and _KNOWN_PRESENTATION_TERMINAL_LABELS.get(identity_value) == outcome.label
+    )
+    known_result = (
+        identity_kind == "result" and outcome.label in _KNOWN_RESULT_TERMINAL_LABELS
+    )
+    known_policy = (
+        (
+            identity_kind in {"policy", "policy-label"}
+            or (
+                identity_kind == "presentation"
+                and identity_value in _POLICY_PRESENTATION_OUTCOME_SLUGS
+            )
+        )
+        and _POLICY_TERMINAL_DISPLAY_LABEL.fullmatch(outcome.label) is not None
+        and len(outcome.label) <= 18
+    )
+    compact_count = (
+        _COMPACT_OUTCOME_COUNT_LABEL.fullmatch(outcome.label)
+        if identity_kind == "summary"
+        else None
+    )
+    if known_presentation or known_result or known_policy:
+        return (
+            _KNOWN_PRESENTATION_TERMINAL_DISPLAY_LABELS.get(
+                identity_value,
+                outcome.label,
+            )
+            if known_presentation
+            else outcome.label
+        )
+    if compact_count is not None:
+        return f"N out.[{compact_count.group('digest')}]"
+    if identity_kind in {"policy", "presentation"} and _SAFE_OUTCOME_SLUG.fullmatch(
+        identity_value
+    ):
+        slug_words = tuple(word for word in re.split(r"[_-]+", identity_value) if word)
+        if len(slug_words) == 1 and len(slug_words[0]) <= 12:
+            return slug_words[0]
+        if 2 <= len(slug_words) <= 3:
+            return " ".join(word[:4] for word in slug_words)
+    digest = hashlib.sha256(
+        f"{outcome.identity}\0{outcome.label}\0{outcome.color}".encode()
+    ).hexdigest()[:_TERMINAL_LABEL_DIGEST_CHARS]
+    if " | " in outcome.label:
+        return f"N out.[{digest}]"
+    prefix = "".join(
+        character
+        for character in outcome.label
+        if character.isascii() and character.isalnum()
+    )[:4]
+    return f"{prefix or 'term'}..{digest}"
+
+
+def _status(measurement: Measurement) -> str:
+    label, color = _visible_status_label(measurement)
+    return rf"\matrixstatus{{{color}}}{{{_tex_escape(label)}}}"
+
+
+def _ok(measurement: Measurement) -> bool:
+    return measurement.get("status") == ResultStatus.OK.value
+
+
+def _runtime_value(measurement: Measurement) -> float | None:
+    """Return a comparable wall time for best-mode selection."""
+
+    if not _ok(measurement):
+        return None
+    value = measurement.get("wall_seconds_per_point")
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    number = float(value)
+    if not math.isfinite(number) or number < 0.0:
+        return None
+    return number
+
+
+def _metric(measurement: Measurement, field: str, *, microseconds: bool = False) -> str:
+    if not _ok(measurement):
+        return _status(measurement)
+    unavailable = _unavailable_time(
+        measurement,
+        field,
+        microseconds=microseconds,
+    )
+    if unavailable is not None:
+        return unavailable
+    return _time(measurement.get(field), microseconds=microseconds)
+
+
+def _best_mode_metric(
+    measurement: Measurement,
+    field: str,
+    *,
+    microseconds: bool = False,
+) -> str:
+    if not _ok(measurement):
+        return _status(measurement)
+    unavailable = _unavailable_time(
+        measurement,
+        field,
+        microseconds=microseconds,
+    )
+    if unavailable is not None:
+        return unavailable
+    return _best_mode_time(measurement.get(field), microseconds=microseconds)
+
+
+def _failed_comparison_status(value: object) -> bool:
+    return value in {
+        ResultStatus.FAILED.value,
+        ResultStatus.VALIDATION_FAILED.value,
+        "mismatch",
+    }
+
+
+def _contains_failed_comparison(value: object) -> bool:
+    if isinstance(value, Mapping):
+        return _failed_comparison_status(value.get("status")) or any(
+            _contains_failed_comparison(item) for item in value.values()
+        )
+    if isinstance(value, list):
+        return any(_contains_failed_comparison(item) for item in value)
+    return False
+
+
+def _original_amplicol_comparison_failed(
+    candidate: Measurement,
+    *,
+    candidate_mode: ExecutionMode | None,
+) -> bool:
+    """Identify only failed comparisons against original AmpliCol."""
+
+    validation = candidate.get("validation")
+    if not isinstance(validation, Mapping):
+        return False
+    if _contains_failed_comparison(
+        validation.get("legacy_amplicol_comparison")
+    ):
+        return True
+    direct = validation.get(DIRECT_AGREEMENT_FIELD)
+    if isinstance(direct, list) and any(
+        isinstance(record, Mapping)
+        and str(record.get("baseline_cell_id", "")).startswith(
+            "reference-amplicol-"
+        )
+        and _failed_comparison_status(record.get("status"))
+        for record in direct
+    ):
+        return True
+    authority = validation.get("independent_authority")
+    if (
+        isinstance(authority, Mapping)
+        and str(authority.get("selected_cell_id", "")).startswith(
+            "reference-amplicol-"
+        )
+        and _failed_comparison_status(authority.get("status"))
+    ):
+        return True
+    for field in ("legacy_comparison", "amplicol_comparison"):
+        comparison = validation.get(field)
+        if isinstance(comparison, Mapping) and _failed_comparison_status(
+            comparison.get("status")
+        ):
+            return True
+    pointwise = validation.get("pointwise")
+    return (
+        candidate_mode is ExecutionMode.RECURRENCE
+        and isinstance(pointwise, Mapping)
+        and _failed_comparison_status(pointwise.get("status"))
+    )
+
+
+def _original_amplicol_generation_metric(
+    joined: JoinedWorkload | BestModeWorkload,
+    *,
+    candidate_mode: ExecutionMode | None,
+) -> str:
+    """Render a retained AmpliCol generation time red on legacy mismatch only."""
+
+    rendered = _best_mode_metric(joined.baseline, "generation_seconds")
+    value = joined.baseline.get("generation_seconds")
+    retained = (
+        _ok(joined.baseline)
+        and not isinstance(value, bool)
+        and isinstance(value, (int, float))
+        and math.isfinite(float(value))
+        and float(value) >= 0.0
+    )
+    diagnostic = joined.legacy_diagnostic or joined.candidate
+    diagnostic_mode = (
+        ExecutionMode.RECURRENCE
+        if joined.legacy_diagnostic is not None
+        else candidate_mode
+    )
+    if retained and _original_amplicol_comparison_failed(
+        diagnostic,
+        candidate_mode=diagnostic_mode,
+    ):
+        return rf"\textcolor{{ReportRed}}{{{rendered}}}"
+    return rendered
+
+
+def _diagnostic_best_mode_time(
+    measurement: Measurement,
+    field: str,
+    *,
+    microseconds: bool = False,
+) -> str:
+    """Render one retained diagnostic timing without treating it as success."""
+
+    value = measurement.get(field)
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return r"\matrixna{ReportMuted}"
+    number = float(value)
+    if not math.isfinite(number) or number < 0.0:
+        return r"\matrixna{ReportMuted}"
+    return _best_mode_time(number, microseconds=microseconds)
+
+
+def _unverified_runtime_clocks(measurement: Measurement) -> tuple[str, str]:
+    """Return retained evaluator-total and outer-wall clocks for diagnostics."""
+
+    wall = _diagnostic_best_mode_time(
+        measurement,
+        "wall_seconds_per_point",
+        microseconds=True,
+    )
+    evaluator_total = evaluator_total_seconds_per_point(measurement)
+    evaluator = (
+        r"\matrixna{ReportMuted}"
+        if evaluator_total is None
+        else _best_mode_time(evaluator_total, microseconds=True)
+    )
+    return evaluator, wall
+
+
+def _unverified_absolute_time(
+    measurement: Measurement,
+    field: str,
+    *,
+    microseconds: bool = False,
+) -> str:
+    """Render one retained diagnostic clock with its non-success marker."""
+
+    absolute = _diagnostic_best_mode_time(
+        measurement,
+        field,
+        microseconds=microseconds,
+    )
+    return rf"\matrixruntimepair{{{absolute}}}{{{_status(measurement)}}}"
+
+
+def _unverified_evaluator_total(measurement: Measurement) -> str:
+    """Render retained evaluator-total timing without making it comparable."""
+
+    total = evaluator_total_seconds_per_point(measurement)
+    absolute = (
+        r"\matrixna{ReportMuted}"
+        if total is None
+        else _best_mode_time(total, microseconds=True)
+    )
+    return rf"\matrixruntimepair{{{absolute}}}{{{_status(measurement)}}}"
+
+
+def _ratio_value(
+    candidate: Measurement,
+    baseline: Measurement,
+    field: str,
+) -> float | None:
+    if not (_ok(candidate) and _ok(baseline)):
+        return None
+    if field == "execution_seconds_per_point":
+        for measurement in (candidate, baseline):
+            provenance = measurement.get("provenance")
+            if not isinstance(provenance, Mapping):
+                continue
+            timing = provenance.get("execution_timing")
+            if isinstance(timing, Mapping) and timing.get("ratio_eligible") is not True:
+                return None
+    if (
+        unavailable_execution_timing_record(candidate, field) is not None
+        or unavailable_execution_timing_record(baseline, field) is not None
+    ):
+        return None
+    numerator = candidate.get(field)
+    denominator = baseline.get(field)
+    if numerator is None or denominator is None:
+        return None
+    numerator_number = float(numerator)
+    denominator_number = float(denominator)
+    if (
+        not math.isfinite(numerator_number)
+        or not math.isfinite(denominator_number)
+        or denominator_number <= 0.0
+    ):
+        return None
+    return numerator_number / denominator_number
+
+
+def _positive_timing_value(
+    measurement: Measurement,
+    field: str,
+) -> float | None:
+    """Return one finite positive timing without changing its clock identity."""
+
+    if not _ok(measurement):
+        return None
+    value = measurement.get(field)
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    number = float(value)
+    if not math.isfinite(number) or number <= 0.0:
+        return None
+    return number
+
+
+def _otf_cold_warmup_seconds(measurement: Measurement) -> float | None:
+    """Return the separately timed first OTF evaluation from provenance."""
+
+    provenance = measurement.get("provenance")
+    runtime_profile = (
+        provenance.get("runtime_profile")
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    value = (
+        runtime_profile.get("cold_warmup_elapsed_seconds")
+        if isinstance(runtime_profile, Mapping)
+        else None
+    )
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    seconds = float(value)
+    if not math.isfinite(seconds) or seconds <= 0.0:
+        return None
+    return seconds
+
+
+def _otf_generation_pair_layout(
+    candidate: Measurement,
+    baseline: Measurement | None,
+) -> _BestModeComparisonLayout:
+    """Render OTF generation alone beside generation plus its first evaluation."""
+
+    generation = _positive_timing_value(candidate, "generation_seconds")
+    cold_warmup = _otf_cold_warmup_seconds(candidate)
+    if generation is None or cold_warmup is None:
+        unavailable = r"\matrixna{ReportMuted}"
+        return _BestModeComparisonLayout(unavailable, "", unavailable)
+    total = generation + cold_warmup
+    if not math.isfinite(total):
+        unavailable = r"\matrixna{ReportMuted}"
+        return _BestModeComparisonLayout(unavailable, "", unavailable)
+
+    if baseline is None:
+        generation_text = _best_mode_value(generation)
+        total_text = _best_mode_value(total)
+        return _BestModeComparisonLayout(
+            rf"\bestmodecompactabsolute{{{generation_text}}}{{{total_text}}}",
+            rf"\bestmodecompactabsoluteprefix{{{generation_text}}}",
+            rf"\bestmodeabsoluteprimary{{{total_text}}}",
+        )
+
+    denominator = _positive_timing_value(baseline, "generation_seconds")
+    if denominator is None:
+        unavailable = r"\matrixna{ReportMuted}"
+        return _BestModeComparisonLayout(unavailable, "", unavailable)
+    generation_ratio = generation / denominator
+    total_ratio = total / denominator
+    color = _best_mode_ratio_color(total_ratio)
+    generation_text = _best_mode_value(generation_ratio)
+    total_text = _best_mode_value(total_ratio)
+    return _BestModeComparisonLayout(
+        rf"\bestmodecompactratio{{{generation_text}}}{{{color}}}{{{total_text}}}",
+        rf"\bestmodecompactprefix{{{generation_text}}}",
+        rf"\bestmodeprimaryratio{{{color}}}{{{total_text}}}",
+    )
+
+
+def _secondary_runtime_ratio(
+    candidate: Measurement,
+    baseline: Measurement,
+    *,
+    baseline_mode: ExecutionMode,
+) -> float | None:
+    """Return the documented supplementary runtime ratio, if available.
+
+    The clock hierarchy is deliberately strict: compare exposed execution
+    attribution first, then authenticated evaluator totals.  Only the legacy
+    AmpliCol reference may supply its direct execution (or wall) clock when it
+    has no evaluator-total record; a recurrence core is never used as the
+    denominator for another backend's evaluator total.
+    """
+
+    execution_ratio = _ratio_value(
+        candidate,
+        baseline,
+        "execution_seconds_per_point",
+    )
+    if execution_ratio is not None:
+        return execution_ratio
+
+    candidate_total = evaluator_total_seconds_per_point(candidate)
+    if candidate_total is None:
+        return None
+    baseline_total = evaluator_total_seconds_per_point(baseline)
+    if baseline_total is not None:
+        return candidate_total / baseline_total
+    if baseline_mode is not ExecutionMode.AMPLICOL:
+        return None
+
+    legacy_direct = _positive_timing_value(
+        baseline,
+        "execution_seconds_per_point",
+    )
+    if legacy_direct is None:
+        legacy_direct = _positive_timing_value(
+            baseline,
+            "wall_seconds_per_point",
+        )
+    if legacy_direct is None:
+        return None
+    return candidate_total / legacy_direct
+
+
+def _ratio(candidate: Measurement, baseline: Measurement, field: str) -> str:
+    value = _ratio_value(candidate, baseline, field)
+    if value is None:
+        if not _ok(candidate):
+            return _status(candidate)
+        if (
+            unavailable_execution_timing_record(candidate, field) is not None
+            or unavailable_execution_timing_record(baseline, field) is not None
+        ):
+            return _not_exposed()
+        return r"\matrixnaratio{ReportMuted}"
+    color = (
+        "ReportGreen" if value < 1.0 else "ReportOrange" if value < 2.0 else "ReportRed"
+    )
+    return rf"\matrixratio{{{color}}}{{{_compact(value)}}}"
+
+
+def _ratio_or_absolute(
+    candidate: Measurement,
+    baseline: Measurement,
+    field: str,
+    *,
+    absolute: bool,
+    microseconds: bool = False,
+) -> str:
+    if absolute and _ok(candidate):
+        return (
+            r"\matrixncabsolute{"
+            + _metric(candidate, field, microseconds=microseconds)
+            + "}"
+        )
+    return _ratio(candidate, baseline, field)
+
+
+def _evaluator_total_clock(measurement: Measurement) -> str:
+    total = evaluator_total_seconds_per_point(measurement)
+    value = _not_exposed() if total is None else _time(total, microseconds=True)
+    return r"\matrixtotalevaluator{" + value + "}"
+
+
+def _recurrence_core_clock(measurement: Measurement) -> str:
+    core = recurrence_core_seconds_per_point(measurement)
+    value = _not_exposed() if core is None else _time(core, microseconds=True)
+    return r"\matrixrecurrencecore{" + value + "}"
+
+
+def _ratio_pair(
+    candidate: Measurement,
+    baseline: Measurement,
+    *,
+    candidate_mode: ExecutionMode,
+) -> str:
+    wall = _ratio_value(candidate, baseline, "wall_seconds_per_point")
+    if not _ok(candidate):
+        return _status(candidate)
+    if wall is None:
+        wall_clock = r"\matrixna{ReportMuted}"
+    else:
+        color = (
+            "ReportGreen"
+            if wall < 1.0
+            else "ReportOrange"
+            if wall < 2.0
+            else "ReportRed"
+        )
+        wall_clock = rf"\matrixwallclock{{{color}}}{{x{_compact(wall)}}}"
+    total_clock = _evaluator_total_clock(candidate)
+    if candidate_mode is not ExecutionMode.RECURRENCE:
+        return rf"\matrixruntimepair{{{wall_clock}}}{{{total_clock}}}"
+    return (
+        rf"\matrixruntimetriple{{{wall_clock}}}{{{total_clock}}}"
+        rf"{{{_recurrence_core_clock(candidate)}}}"
+    )
+
+
+def _ratio_pair_or_absolute(
+    candidate: Measurement,
+    baseline: Measurement,
+    *,
+    candidate_mode: ExecutionMode,
+    absolute: bool,
+) -> str:
+    if absolute and _ok(candidate):
+        wall = _metric(candidate, "wall_seconds_per_point", microseconds=True)
+        wall_clock = r"\matrixncabsolute{\matrixwallabsolute{" + wall + "}}"
+        total_clock = _evaluator_total_clock(candidate)
+        if candidate_mode is not ExecutionMode.RECURRENCE:
+            return rf"\matrixruntimepair{{{wall_clock}}}{{{total_clock}}}"
+        return (
+            rf"\matrixruntimetriple{{{wall_clock}}}{{{total_clock}}}"
+            rf"{{{_recurrence_core_clock(candidate)}}}"
+        )
+    return _ratio_pair(
+        candidate,
+        baseline,
+        candidate_mode=candidate_mode,
+    )
+
+
+def _matrix_macros() -> list[str]:
+    return [
+        r"\providecommand{\matrixentryfont}{\fontsize{6.8pt}{7.8pt}\selectfont}",
+        r"\providecommand{\matrixentryfontlc}{\fontsize{6.5pt}{7.5pt}\selectfont}",
+        r"\providecommand{\matrixsummaryfont}{\fontsize{6.2pt}{7.4pt}\selectfont}",
+        (
+            r"\providecommand{\matrixfitwidth}[1]{\begingroup"
+            r"\sbox0{#1}\ifdim\wd0>\linewidth"
+            r"\resizebox{\linewidth}{!}{\usebox0}"
+            r"\else\makebox[\linewidth][c]{\usebox0}\fi\endgroup}"
+        ),
+        r"\providecommand{\matrixpunct}[1]{\textcolor{black}{\texttt{#1}}}",
+        (
+            r"\providecommand{\matrixratio}[2]{\matrixpunct{(}"
+            r"\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}"
+        ),
+        r"\providecommand{\matrixna}[1]{\textcolor{#1}{\texttt{N/A}}}",
+        (
+            r"\providecommand{\matrixnotapplicable}[1]{"
+            r"\textcolor{#1}{\textsc{not applicable}}}"
+        ),
+        (
+            r"\providecommand{\matrixnotexposed}[1]{"
+            r"\textcolor{#1}{\textsc{not exposed}}}"
+        ),
+        (
+            r"\providecommand{\matrixstaticna}[1]{"
+            r"\textcolor{#1}{\textsc{static N/A}}}"
+        ),
+        (
+            r"\providecommand{\matrixtotalevaluator}[1]{"
+            r"\textcolor{ReportBlue}{\texttt{T }}#1}"
+        ),
+        (
+            r"\providecommand{\matrixrecurrencecore}[1]{"
+            r"\textcolor{ReportOrange}{\texttt{C }}#1}"
+        ),
+        (
+            r"\providecommand{\matrixzrecurrenceclocks}[2]{"
+            r"\shortstack[r]{#1\\#2}}"
+        ),
+        (
+            r"\providecommand{\matrixwallclock}[2]{"
+            r"\textcolor{#1}{\texttt{W #2}}}"
+        ),
+        (
+            r"\providecommand{\matrixwallabsolute}[1]{"
+            r"\textcolor{ReportBlue}{\texttt{W }}#1}"
+        ),
+        (
+            r"\providecommand{\matrixruntimepair}[2]{"
+            r"\shortstack[l]{#1\\#2}}"
+        ),
+        (
+            r"\providecommand{\matrixruntimetriple}[3]{"
+            r"\shortstack[l]{#1\\#2\matrixpunct{ | }#3}}"
+        ),
+        r"\providecommand{\matrixbelow}[1]{\textcolor{ReportMuted}{\texttt{<#1}}}",
+        (
+            r"\providecommand{\matrixnaratio}[1]{\matrixpunct{(}"
+            r"\matrixna{#1}\matrixpunct{)}}"
+        ),
+        r"\providecommand{\matrixstatus}[2]{\textcolor{#1}{\textsc{#2}}}",
+        (
+            r"\providecommand{\matrixncabsolute}[1]{"
+            r"#1}"
+        ),
+        (
+            r"\providecommand{\matrixsummaryratio}[2]{"
+            r"\textcolor{#1}{\texttt{x#2}}}"
+        ),
+        (
+            r"\providecommand{\matrixsummaryratiohighlight}[2]{"
+            r"\begingroup\setlength{\fboxsep}{0.9pt}"
+            r"\setlength{\fboxrule}{0.35pt}"
+            r"\fbox{\textcolor{#1}{{\usefont{T1}{lmtt}{b}{n}x#2}}}"
+            r"\endgroup}"
+        ),
+        # Keep the five statistic anchors identical on every summary line.
+        # Max accommodates scientific notation; weighted average carries the frame.
+        (
+            r"\providecommand{\matrixsummarystats}[5]{"
+            r"\begingroup\matrixsummaryfont"
+            r"\begin{tabular}[t]{@{}l"
+            r"@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l"
+            r"@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l"
+            r"@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l"
+            r"@{\hspace{0.014in}\matrixpunct{|}\hspace{0.014in}}l@{}}"
+            r"\makebox[3.6em][l]{#1}&"
+            r"\makebox[4.6em][l]{#2}&"
+            r"\makebox[3.6em][l]{#3}&"
+            r"\makebox[3.6em][l]{#4}&"
+            r"\makebox[4.2em][l]{#5}"
+            r"\end{tabular}\endgroup}"
+        ),
+        (
+            r"\providecommand{\matrixsummaryworkloads}[2]{"
+            r"\begin{tabular}[t]{@{}l@{}}#1\\[-0.10em]#2\end{tabular}}"
+        ),
+    ]
+
+
+def _compact_comparison_macros() -> list[str]:
+    """Return the compact aligned comparison vocabulary shared by matrices."""
+
+    return [
+        (
+            r"\providecommand{\bestmoderatio}[2]{"
+            r"\textcolor{#1}{\texttt{x#2}}}"
+        ),
+        (
+            r"\providecommand{\bestmodecompactratio}[3]{"
+            r"\matrixpunct{(}"
+            r"\textcolor{ReportMuted}{\texttt{[x#1]}}"
+            r"\hspace{0.04in}"
+            r"\textcolor{#2}{\texttt{x#3}}"
+            r"\matrixpunct{)}}"
+        ),
+        (
+            r"\providecommand{\bestmodewallratio}[2]{"
+            r"\matrixpunct{(}\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}"
+        ),
+        (
+            r"\providecommand{\bestmodecompactprefix}[1]{"
+            r"\matrixpunct{(}\textcolor{ReportMuted}{\texttt{[x#1]}}"
+            r"\hspace{0.04in}}"
+        ),
+        (
+            r"\providecommand{\bestmodeopenprefix}{"
+            r"\matrixpunct{(}\hspace{0.04in}}"
+        ),
+        (
+            r"\providecommand{\bestmodeprimaryratio}[2]{"
+            r"\textcolor{#1}{\texttt{x#2}}\matrixpunct{)}}"
+        ),
+        (
+            r"\providecommand{\bestmodeabsoluteprefix}[1]{"
+            r"#1\hspace{0.04in}}"
+        ),
+        (
+            r"\providecommand{\bestmodecompactabsolute}[2]{"
+            r"\textcolor{ReportMuted}{\texttt{[#1]}}"
+            r"\hspace{0.04in}\textcolor{black}{\texttt{#2}}}"
+        ),
+        (
+            r"\providecommand{\bestmodecompactabsoluteprefix}[1]{"
+            r"\textcolor{ReportMuted}{\texttt{[#1]}}\hspace{0.04in}}"
+        ),
+        (
+            r"\providecommand{\bestmodeabsoluteprimary}[1]{"
+            r"\textcolor{black}{\texttt{#1}}}"
+        ),
+        (
+            r"\providecommand{\bestmodeunverifiedclockprefix}[2]{"
+            r"\textcolor{ReportMuted}{\texttt{[}#1\texttt{]}}"
+            r"\hspace{0.04in}#2\hspace{0.04in}}"
+        ),
+    ]
+
+
+def _not_applicable() -> str:
+    return r"\matrixnotapplicable{ReportMuted}"
+
+
+def _not_run() -> str:
+    return r"\matrixstatus{ReportMuted}{not run}"
+
+
+def _matrix_scope_marker(
+    family: ProcessFamily,
+    n_final: int,
+    accuracy: Accuracy,
+) -> str:
+    """Distinguish nonexistent processes from intentionally unrun cells."""
+
+    if family.process(n_final) is None:
+        return _not_applicable()
+    if n_final > family.maximum_n(accuracy):
+        return _not_run()
+    raise ValueError("applicable matrix cell has no scope marker")
+
+
+def _not_exposed() -> str:
+    return r"\matrixnotexposed{ReportMuted}"
+
+
+def _static_na() -> str:
+    return r"\matrixstaticna{ReportMuted}"
+
+
+def _legacy_baseline_static_na(
+    *,
+    catalog: ReportCatalog,
+    accuracy: Accuracy,
+    process_key: str,
+    n_final: int,
+    workload: Workload,
+) -> bool:
+    baseline = next(
+        cell
+        for cell in catalog.measurement_cells()
+        if cell.dataset_id == f"reference_amplicol_{accuracy.value}"
+        and cell.process_key == process_key
+        and cell.n_final == n_final
+        and cell.workload is workload
+    )
+    return catalog.static_na_reason(baseline) is not None
+
+
+def _legacy_baseline_unavailable(
+    view: JoinedMatrixCell,
+    *,
+    catalog: ReportCatalog,
+) -> bool:
+    return (
+        view.dataset.baseline.execution_mode is ExecutionMode.AMPLICOL
+        and _legacy_baseline_static_na(
+            catalog=catalog,
+            accuracy=view.dataset.baseline.accuracy,
+            process_key=view.process_family.key,
+            n_final=view.n_final,
+            workload=view.workloads[0].workload,
+        )
+    )
+
+
+def _generation_comparison_linked(
+    joined: JoinedWorkload | BestModeWorkload,
+) -> bool:
+    """Use a metric-specific link when generation is process-wide."""
+
+    if joined.generation_comparison_linked is None:
+        return joined.comparison_linked
+    return joined.generation_comparison_linked
+
+
+def _fixed_mode_generation_comparison_layout(
+    joined: JoinedWorkload,
+    *,
+    candidate_mode: ExecutionMode,
+    baseline_mode: ExecutionMode,
+    baseline_static_na: bool = False,
+    comparable: bool = True,
+) -> _BestModeComparisonLayout:
+    """Render one fixed-engine generation comparison without a mode letter."""
+
+    if joined.candidate.get("status") == ResultStatus.UNVERIFIED.value:
+        absolute = _diagnostic_best_mode_time(
+            joined.candidate,
+            "generation_seconds",
+        )
+        status = _status(joined.candidate)
+        return _BestModeComparisonLayout(
+            rf"{absolute}\,{status}",
+            rf"\bestmodeabsoluteprefix{{{absolute}}}",
+            status,
+        )
+    if not _ok(joined.candidate):
+        status = _status(joined.candidate)
+        return _BestModeComparisonLayout(status, "", status)
+    if (
+        candidate_mode is ExecutionMode.ON_THE_FLY
+        and baseline_mode is ExecutionMode.AMPLICOL
+    ):
+        if (
+            joined.workload is Workload.ALL_FLOW
+            or baseline_static_na
+            or not comparable
+            or not _generation_comparison_linked(joined)
+            or not _ok(joined.baseline)
+        ):
+            return _otf_generation_pair_layout(joined.candidate, None)
+        return _otf_generation_pair_layout(joined.candidate, joined.baseline)
+    if (
+        baseline_static_na
+        or not comparable
+        or not _generation_comparison_linked(joined)
+        or (baseline_mode is ExecutionMode.AMPLICOL and not _ok(joined.baseline))
+    ):
+        absolute = _best_mode_metric(joined.candidate, "generation_seconds")
+        return _BestModeComparisonLayout(
+            absolute,
+            rf"\bestmodeabsoluteprefix{{{absolute}}}",
+            "",
+        )
+    if not _ok(joined.baseline):
+        status = _status(joined.baseline)
+        return _BestModeComparisonLayout(status, "", status)
+    generation_ratio = _ratio_value(
+        joined.candidate,
+        joined.baseline,
+        "generation_seconds",
+    )
+    if generation_ratio is None:
+        unavailable = r"\matrixna{ReportMuted}"
+        return _BestModeComparisonLayout(unavailable, "", unavailable)
+    ratio = (
+        rf"\bestmoderatio{{{_best_mode_ratio_color(generation_ratio)}}}"
+        rf"{{{_best_mode_value(generation_ratio)}}}"
+    )
+    return _BestModeComparisonLayout(ratio, "", ratio)
+
+
+def _fixed_mode_runtime_comparison_layout(
+    joined: JoinedWorkload,
+    *,
+    candidate_mode: ExecutionMode,
+    baseline_mode: ExecutionMode,
+    baseline_static_na: bool = False,
+) -> _BestModeComparisonLayout:
+    """Use the best-table compact clock layout for one fixed engine."""
+
+    if joined.candidate.get("status") == ResultStatus.UNVERIFIED.value:
+        evaluator, wall = _unverified_runtime_clocks(joined.candidate)
+        status = _status(joined.candidate)
+        clocks = rf"\bestmodeunverifiedclockprefix{{{evaluator}}}{{{wall}}}"
+        return _BestModeComparisonLayout(
+            rf"{clocks}{status}",
+            clocks,
+            status,
+        )
+
+    return _best_mode_runtime_comparison_layout(
+        BestModeWorkload(
+            workload=joined.workload,
+            baseline=joined.baseline,
+            candidate=joined.candidate,
+            mode=candidate_mode,
+            terminal_label=None,
+            comparison_linked=joined.comparison_linked,
+        ),
+        baseline_mode=baseline_mode,
+        baseline_static_na=baseline_static_na,
+    )
+
+
+def _lc_cell(
+    view: JoinedMatrixCell,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> _MatrixCellRows:
+    selected, all_flow = view.workloads
+    legacy_baseline_unavailable = _legacy_baseline_unavailable(
+        view,
+        catalog=catalog,
+    )
+    selected_baseline_generation = (
+        _static_na()
+        if legacy_baseline_unavailable
+        else (
+            _original_amplicol_generation_metric(
+                selected,
+                candidate_mode=view.dataset.candidate.execution_mode,
+            )
+            if view.dataset.baseline.execution_mode is ExecutionMode.AMPLICOL
+            else _best_mode_metric(selected.baseline, "generation_seconds")
+        )
+    )
+    all_flow_baseline_generation = (
+        _static_na()
+        if legacy_baseline_unavailable
+        else (
+            _original_amplicol_generation_metric(
+                all_flow,
+                candidate_mode=view.dataset.candidate.execution_mode,
+            )
+            if view.dataset.baseline.execution_mode is ExecutionMode.AMPLICOL
+            else _best_mode_metric(all_flow.baseline, "generation_seconds")
+        )
+    )
+    selected_generation = _fixed_mode_generation_comparison_layout(
+        selected,
+        candidate_mode=view.dataset.candidate.execution_mode,
+        baseline_mode=view.dataset.baseline.execution_mode,
+        baseline_static_na=legacy_baseline_unavailable,
+    )
+    all_flow_generation = _fixed_mode_generation_comparison_layout(
+        all_flow,
+        candidate_mode=view.dataset.candidate.execution_mode,
+        baseline_mode=view.dataset.baseline.execution_mode,
+        baseline_static_na=legacy_baseline_unavailable,
+        comparable=not (
+            view.dataset.candidate.execution_mode is ExecutionMode.RECURRENCE
+            and view.dataset.baseline.execution_mode is ExecutionMode.AMPLICOL
+        ),
+    )
+    selected_baseline_runtime = (
+        _static_na()
+        if legacy_baseline_unavailable
+        else _best_mode_metric(
+            selected.baseline,
+            "wall_seconds_per_point",
+            microseconds=True,
+        )
+    )
+    all_flow_baseline_runtime = (
+        _static_na()
+        if legacy_baseline_unavailable
+        else _best_mode_metric(
+            all_flow.baseline,
+            "wall_seconds_per_point",
+            microseconds=True,
+        )
+    )
+    selected_runtime = _fixed_mode_runtime_comparison_layout(
+        selected,
+        candidate_mode=view.dataset.candidate.execution_mode,
+        baseline_mode=view.dataset.baseline.execution_mode,
+        baseline_static_na=legacy_baseline_unavailable,
+    )
+    all_flow_runtime = _fixed_mode_runtime_comparison_layout(
+        all_flow,
+        candidate_mode=view.dataset.candidate.execution_mode,
+        baseline_mode=view.dataset.baseline.execution_mode,
+        baseline_static_na=legacy_baseline_unavailable,
+    )
+    return _MatrixCellRows(
+        generation=(
+            selected_baseline_generation,
+            r"\matrixpunct{|}",
+            all_flow_baseline_generation,
+            *_best_mode_comparison_columns(selected_generation),
+            r"\matrixpunct{|}",
+            *_best_mode_comparison_columns(all_flow_generation),
+        ),
+        runtime=(
+            selected_baseline_runtime,
+            r"\matrixpunct{|}",
+            all_flow_baseline_runtime,
+            *_best_mode_comparison_columns(selected_runtime),
+            r"\matrixpunct{|}",
+            *_best_mode_comparison_columns(all_flow_runtime),
+        ),
+    )
+
+
+def _contracted_cell(
+    view: JoinedMatrixCell,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> _MatrixCellRows:
+    joined = view.workloads[0]
+    candidate_cell = next(
+        cell
+        for cell in catalog.measurement_cells()
+        if cell.dataset_id == view.dataset.dataset_id
+        and cell.process_key == view.process_family.key
+        and cell.n_final == view.n_final
+        and cell.workload is joined.workload
+        and cell.variant is None
+    )
+    candidate_static_na = catalog.static_na_reason(candidate_cell) is not None
+    legacy_baseline_unavailable = _legacy_baseline_unavailable(
+        view,
+        catalog=catalog,
+    )
+    candidate_generation = (
+        _BestModeComparisonLayout(_static_na(), "", _static_na())
+        if candidate_static_na
+        else _fixed_mode_generation_comparison_layout(
+            joined,
+            candidate_mode=view.dataset.candidate.execution_mode,
+            baseline_mode=view.dataset.baseline.execution_mode,
+            baseline_static_na=legacy_baseline_unavailable,
+        )
+    )
+    candidate_runtime = (
+        _BestModeComparisonLayout(_static_na(), "", _static_na())
+        if candidate_static_na
+        else _fixed_mode_runtime_comparison_layout(
+            joined,
+            candidate_mode=view.dataset.candidate.execution_mode,
+            baseline_mode=view.dataset.baseline.execution_mode,
+            baseline_static_na=legacy_baseline_unavailable,
+        )
+    )
+    baseline_generation = (
+        _static_na()
+        if legacy_baseline_unavailable
+        else (
+            _original_amplicol_generation_metric(
+                joined,
+                candidate_mode=view.dataset.candidate.execution_mode,
+            )
+            if view.dataset.baseline.execution_mode is ExecutionMode.AMPLICOL
+            else _best_mode_metric(joined.baseline, "generation_seconds")
+        )
+    )
+    baseline_runtime = (
+        _static_na()
+        if legacy_baseline_unavailable
+        else _best_mode_metric(
+            joined.baseline,
+            "wall_seconds_per_point",
+            microseconds=True,
+        )
+    )
+    return _MatrixCellRows(
+        generation=(
+            baseline_generation,
+            *_best_mode_comparison_columns(candidate_generation),
+        ),
+        runtime=(
+            baseline_runtime,
+            *_best_mode_comparison_columns(candidate_runtime),
+        ),
+    )
+
+
+def _summary_pair(
+    views: Sequence[JoinedMatrixCell],
+    workload: Workload,
+    field: str,
+) -> str:
+    joined = [
+        next(item for item in view.workloads if item.workload is workload)
+        for view in views
+        if view.applicable
+    ]
+    valid = [
+        item
+        for item in joined
+        if (
+            _generation_comparison_linked(item)
+            if field == "generation_seconds"
+            else item.comparison_linked
+        )
+        and _ok(item.baseline)
+        and _ok(item.candidate)
+        and item.baseline.get(field) is not None
+        and item.candidate.get(field) is not None
+        and unavailable_execution_timing_record(item.baseline, field) is None
+        and unavailable_execution_timing_record(item.candidate, field) is None
+        and math.isfinite(float(item.baseline[field]))
+        and math.isfinite(float(item.candidate[field]))
+        and float(item.baseline[field]) > 0.0
+        and float(item.candidate[field]) >= 0.0
+    ]
+    if not valid:
+        if field == "execution_seconds_per_point" and any(
+            unavailable_execution_timing_record(measurement, field) is not None
+            for item in joined
+            for measurement in (item.baseline, item.candidate)
+        ):
+            return _not_exposed()
+        for item in joined:
+            if not _ok(item.candidate) and policy_status_label(item.candidate):
+                return _status(item.candidate)
+            if not _ok(item.baseline) and policy_status_label(item.baseline):
+                return _status(item.baseline)
+        return r"\matrixna{ReportMuted}"
+    return _ratio_statistics_tex(
+        tuple(
+            (float(item.baseline[field]), float(item.candidate[field]))
+            for item in valid
+        )
+    )
+
+
+def _ratio_statistics_tex(
+    timings: Sequence[tuple[float, float]],
+) -> str:
+    """Render min/max/median/mean/ratio-of-sums for timing pairs."""
+
+    ratios = tuple(candidate / baseline for baseline, candidate in timings)
+    ordered = tuple(sorted(ratios))
+    middle = len(ordered) // 2
+    median = (
+        ordered[middle]
+        if len(ordered) % 2
+        else (ordered[middle - 1] + ordered[middle]) / 2.0
+    )
+    average = math.fsum(ratios) / len(ratios)
+    baseline_sum = math.fsum(baseline for baseline, _candidate in timings)
+    candidate_sum = math.fsum(candidate for _baseline, candidate in timings)
+    weighted_average = candidate_sum / baseline_sum
+    statistics = (
+        ordered[0],
+        ordered[-1],
+        median,
+        average,
+        weighted_average,
+    )
+    rendered = tuple(
+        (
+            rf"\matrixsummaryratiohighlight"
+            rf"{{{_best_mode_ratio_color(value)}}}"
+            rf"{{{_best_mode_value(value)}}}"
+            if index == 4
+            else rf"\matrixsummaryratio{{{_best_mode_ratio_color(value)}}}"
+            rf"{{{_best_mode_value(value)}}}"
+        )
+        for index, value in enumerate(statistics)
+    )
+    return r"\matrixsummarystats{" + "}{".join(rendered) + "}"
+
+
+def _matrix_block(
+    adapter: BaselineCandidateAdapter,
+    dataset: MatrixDataset,
+    multiplicities: tuple[int, ...],
+    *,
+    block_index: int,
+    block_count: int,
+    baseline_dataset_id: str | None = None,
+) -> list[str]:
+    if len(multiplicities) not in (2, 3):
+        raise ValueError("matrix blocks must contain two or three multiplicities")
+    accuracy = dataset.candidate.accuracy
+    array_stretch = (
+        "1.00"
+        if dataset.candidate.execution_mode is ExecutionMode.ON_THE_FLY
+        and accuracy is Accuracy.LC
+        else "1.04"
+    )
+    column_spec = _metric_table_column_spec(
+        accuracy,
+        len(multiplicities),
+    )
+    lines = [
+        r"\clearpage",
+        r"\noindent\begin{minipage}{\linewidth}",
+        (
+            rf"\subsubsection*{{{_tex_escape(dataset.title)}"
+            + (
+                ""
+                if block_count == 1
+                else rf" (block {block_index + 1} of {block_count})"
+            )
+            + "}"
+        ),
+        r"\begingroup",
+        r"\centering",
+        r"\footnotesize",
+        r"\setlength{\tabcolsep}{2.1pt}",
+        rf"\renewcommand{{\arraystretch}}{{{array_stretch}}}",
+        r"\matrixfitwidth{%",
+        rf"\begin{{tabular}}{{{column_spec}}}",
+        r"\toprule",
+        (
+            r"\textbf{ID} & \textbf{base process} & \textbf{metric} & "
+            + " & ".join(
+                _metric_group_cell(
+                    rf"\textbf{{n={n_final}}}",
+                    accuracy,
+                )
+                for n_final in multiplicities
+            )
+            + r" \\"
+        ),
+        r"\specialrule{0.85pt}{0pt}{0pt}",
+    ]
+    views_by_n: dict[int, list[JoinedMatrixCell]] = {
+        n_final: [] for n_final in multiplicities
+    }
+    for row_index, family in enumerate(adapter.catalog.process_families):
+        generation_row = [
+            rf"\texttt{{{family.identifier}}}",
+            family.label_tex,
+            _metric_row_label(runtime=False),
+        ]
+        runtime_row = ["", "", _metric_row_label(runtime=True)]
+        for n_final in multiplicities:
+            view = adapter.matrix_cell(
+                dataset,
+                family,
+                n_final,
+                baseline_dataset_id=baseline_dataset_id,
+            )
+            views_by_n[n_final].append(view)
+            if not view.applicable:
+                generation_row.append(
+                    _metric_group_cell(
+                        _matrix_scope_marker(family, n_final, accuracy),
+                        accuracy,
+                    )
+                )
+                runtime_row.append(
+                    _metric_group_cell(
+                        "",
+                        accuracy,
+                    )
+                )
+            elif accuracy is Accuracy.LC:
+                rendered = _lc_cell(view, catalog=adapter.catalog)
+                generation_row.extend(rendered.generation)
+                runtime_row.extend(rendered.runtime)
+            else:
+                rendered = _contracted_cell(view, catalog=adapter.catalog)
+                generation_row.extend(rendered.generation)
+                runtime_row.extend(rendered.runtime)
+        if row_index % 2 == 0:
+            lines.append(r"\rowcolor{refblue}")
+        lines.append(" & ".join(generation_row) + r" \\")
+        if row_index % 2 == 0:
+            lines.append(r"\rowcolor{refblue}")
+        lines.append(" & ".join(runtime_row) + r" \\")
+        lines.append(r"\addlinespace[0.05em]")
+    lines.extend(
+        [
+            r"\specialrule{1.05pt}{0.22em}{0.18em}",
+            _metric_summary_header_row(multiplicities, accuracy),
+            (
+                r"\multicolumn{3}{@{}l}{\textbf{summary: generation}} & "
+                + " & ".join(
+                    _metric_summary_group_cell(
+                        _matrix_generation_summary(
+                            views_by_n[n_final],
+                            dataset,
+                            catalog=adapter.catalog,
+                        ),
+                        accuracy,
+                        group_index=group_index,
+                    )
+                    for group_index, n_final in enumerate(multiplicities)
+                )
+                + r" \\[0.08em]"
+            ),
+            (
+                rf"\multicolumn{{3}}{{@{{}}l}}{{"
+                rf"{_matrix_wall_summary_label(accuracy)}}} & "
+                + " & ".join(
+                    _metric_summary_group_cell(
+                        _matrix_wall_summary(
+                            views_by_n[n_final],
+                            accuracy,
+                            dataset=dataset,
+                            catalog=adapter.catalog,
+                        ),
+                        accuracy,
+                        group_index=group_index,
+                    )
+                    for group_index, n_final in enumerate(multiplicities)
+                )
+                + r" \\"
+            ),
+            r"\bottomrule",
+            r"\end{tabular}",
+            r"}",
+            r"\endgroup",
+            _matrix_legend(dataset),
+            r"\end{minipage}",
+        ]
+    )
+    return lines
+
+
+def _matrix_generation_summary(
+    views: Sequence[JoinedMatrixCell],
+    dataset: MatrixDataset,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> str:
+    if _matrix_candidates_are_static_na(views, dataset, catalog=catalog):
+        return _static_na()
+    if dataset.candidate.accuracy is Accuracy.LC:
+        return _summary_pair(
+            views,
+            Workload.SELECTED_FLOW,
+            "generation_seconds",
+        )
+    return _summary_pair(views, Workload.CONTRACTED, "generation_seconds")
+
+
+def _matrix_wall_summary(
+    views: Sequence[JoinedMatrixCell],
+    accuracy: Accuracy,
+    *,
+    dataset: MatrixDataset | None = None,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> str:
+    if dataset is not None and _matrix_candidates_are_static_na(
+        views,
+        dataset,
+        catalog=catalog,
+    ):
+        return _static_na()
+    if accuracy is Accuracy.LC:
+        selected = _summary_pair(
+            views,
+            Workload.SELECTED_FLOW,
+            "wall_seconds_per_point",
+        )
+        all_flow = _summary_pair(
+            views,
+            Workload.ALL_FLOW,
+            "wall_seconds_per_point",
+        )
+        return rf"\matrixsummaryworkloads{{{selected}}}{{{all_flow}}}"
+    return _summary_pair(
+        views,
+        Workload.CONTRACTED,
+        "wall_seconds_per_point",
+    )
+
+
+def _matrix_candidates_are_static_na(
+    views: Sequence[JoinedMatrixCell],
+    dataset: MatrixDataset,
+    *,
+    catalog: ReportCatalog,
+) -> bool:
+    candidate_cells = {
+        (cell.process_key, cell.n_final, cell.workload): cell
+        for cell in catalog.measurement_cells()
+        if cell.dataset_id == dataset.dataset_id and cell.variant is None
+    }
+    applicable = tuple(view for view in views if view.applicable)
+    return bool(applicable) and all(
+        catalog.static_na_reason(
+            candidate_cells[
+                (view.process_family.key, view.n_final, joined.workload)
+            ]
+        )
+        is not None
+        for view in applicable
+        for joined in view.workloads
+    )
+
+
+def _mode_label(mode: ExecutionMode) -> str:
+    return {
+        ExecutionMode.AMPLICOL: "original AmpliCol",
+        ExecutionMode.MADGRAPH: "MadGraph standalone",
+        ExecutionMode.RECURRENCE: "recurrence JIT O2",
+        ExecutionMode.COMPILED: "compiled JIT O3",
+        ExecutionMode.EAGER: "eager-DAG JIT O2",
+        ExecutionMode.ON_THE_FLY: "on-the-fly JIT O2",
+    }[mode]
+
+
+def _matrix_legend(dataset: MatrixDataset) -> str:
+    baseline = _mode_label(dataset.baseline.execution_mode)
+    candidate = _mode_label(dataset.candidate.execution_mode)
+    if dataset.candidate.accuracy is Accuracy.LC:
+        if (
+            dataset.candidate.execution_mode is ExecutionMode.ON_THE_FLY
+            and dataset.baseline.execution_mode is ExecutionMode.AMPLICOL
+        ):
+            detail = (
+                "Each cell shows non-union-flow and union-flow quantities. "
+                "For non-union flow, generation is ([xG] x(G+W)): the muted "
+                "inner multiplier is artifact generation G alone and the "
+                "normally coloured outer multiplier adds exactly the first "
+                "cold on-the-fly evaluation W, both relative to AmpliCol "
+                "selected-flow generation. For union flow, generation is the "
+                "absolute [G] G+W pair, with G muted and G+W in normal black. "
+                "W excludes artifact loading and conventional benchmark warm-ups."
+            )
+        elif (
+            dataset.candidate.execution_mode is ExecutionMode.RECURRENCE
+            and dataset.baseline.execution_mode is ExecutionMode.AMPLICOL
+        ):
+            detail = (
+                "Each cell shows the selected-flow library-generation and "
+                "all-flow direct-setup baseline quantities. The selected-flow "
+                "entry carries a generation ratio; the all-flow entry carries "
+                "the absolute pyAmpliCol process-generation time. Its setup "
+                "boundary differs from the reference, so no generation ratio "
+                "is formed."
+            )
+        else:
+            detail = (
+                "Each cell shows the topology-replay/all-flow-union baseline "
+                "generation times and wall times, followed by layout-matched "
+                "candidate/baseline generation and wall-time ratios."
+            )
+    else:
+        detail = (
+            "Each cell shows the baseline generation and wall time, followed by "
+            "candidate/baseline generation and wall-time ratios."
+        )
+    clock_detail = (
+        " Runtime comparisons use ([xS]xW). The muted supplementary xS first "
+        "compares compatible exposed execution attributions; otherwise it "
+        "compares authenticated evaluator totals. Only when original AmpliCol "
+        "has no evaluator-total clock may a candidate evaluator total use the "
+        "legacy direct execution clock (or its wall clock when direct execution "
+        "is absent) as denominator. An evaluator total is never divided by a "
+        "recurrence core. This evaluator-total fallback is diagnostic only; the "
+        "execution/execution ratio remains the compatible supplementary "
+        "attribution. The coloured xW is always the candidate/baseline wall "
+        "multiplier and remains the primary figure of merit. When no compatible "
+        "supplementary clock exists, only (xW) is shown. No clock is fabricated "
+        "from another. Every displayed number uses exactly three significant "
+        "digits."
+    )
+    legacy_scope_detail = (
+        " Original AmpliCol is static N/A beyond three open quark lines; "
+        "unavailable, terminal, or unlinked baselines keep their status while "
+        "successful candidate timings remain absolute and leave summaries."
+        if dataset.baseline.execution_mode is ExecutionMode.AMPLICOL
+        else ""
+    )
+    madgraph_reference_detail = (
+        " MadGraph standalone is the authoritative full-colour numerical "
+        "reference; its generation and repeated-evaluation measurements are "
+        "shared by all four UFO-SM comparison views. Recurrence, compiled, and "
+        "eager candidates use p200 at the comparison point; the on-the-fly "
+        "candidate uses its supported p16 lane."
+        if dataset.baseline.execution_mode is ExecutionMode.MADGRAPH
+        else ""
+    )
+    unverified_detail = (
+        " Unverified compiled or eager diagnostics show absolute generation "
+        "and runtime values with a yellow unverified marker, but never enter "
+        "ratios or summaries. In their runtime token the muted bracketed value "
+        "is evaluator-total and the following value is outer wall time."
+        if dataset.candidate.execution_mode
+        in {ExecutionMode.COMPILED, ExecutionMode.EAGER}
+        else ""
+    )
+    summary_detail = (
+        " Summary rows contain multipliers only in min, max, median, average, "
+        "and weighted-average order; the weighted average is the ratio of "
+        "timing sums and is the framed bold entry. LC generation uses selected "
+        "flow only, while LC "
+        "runtime shows separate selected-flow and all-flow wall-only lines."
+        if dataset.candidate.accuracy is Accuracy.LC
+        else " Summary rows contain multipliers only in min, max, median, average, "
+        "and weighted-average order; the weighted average is the ratio of "
+        "timing sums, is the framed bold entry, and runtime statistics use wall "
+        "time only."
+    )
+    comparison_identity_detail = (
+        " Ratios and summaries require exact stored linkage to the current denominator."
+        if dataset.baseline.execution_mode is not ExecutionMode.AMPLICOL
+        else ""
+    )
+    return (
+        r"\ReportTableNote{{\scriptsize Baseline: "
+        + _tex_escape(baseline)
+        + "; candidate: "
+        + _tex_escape(candidate)
+        + ". "
+        + _tex_escape(detail)
+        + _tex_escape(clock_detail)
+        + _tex_escape(legacy_scope_detail)
+        + _tex_escape(madgraph_reference_detail)
+        + _tex_escape(unverified_detail)
+        + _tex_escape(comparison_identity_detail)
+        + _tex_escape(summary_detail)
+        + " "
+        + _tex_escape(
+            "Not applicable marks a multiplicity for which the process family "
+            "does not exist. Not run marks an otherwise defined process that "
+            "was intentionally excluded from the declared measurement scope. "
+            "Fixed-engine tables intentionally omit mode letters because the "
+            "selected engine is named in the table heading."
+        )
+        + "}}"
+    )
+
+
+def render_matrix_table(
+    dataset: MatrixDataset,
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    baseline_dataset_id: str | None = None,
+) -> str:
+    """Render one matrix dataset into nonbreaking page-sized TeX blocks."""
+
+    adapter = BaselineCandidateAdapter(caches, catalog=catalog)
+    # The scoped OTF LC surface has four multiplicities.  Keep every rendered
+    # matrix block within the established two-or-three-column table grammar.
+    block_size = (
+        2
+        if dataset.candidate.execution_mode is ExecutionMode.ON_THE_FLY
+        and len(dataset.multiplicities) == 4
+        else _MATRIX_BLOCK_SIZE
+    )
+    blocks = _chunks(dataset.multiplicities, block_size)
+    lines = [
+        "% SPDX-License-Identifier: 0BSD",
+        "% Generated by tools/performance_report/render.py; do not edit.",
+        *_matrix_macros(),
+        (
+            r"\providecommand{\matrixpair}[2]{"
+            r"\begin{tabular}[t]{@{}r@{\hspace{0.025in}"
+            r"\matrixpunct{|}\hspace{0.025in}}r@{}}"
+            r"#1&#2\end{tabular}}"
+        ),
+        *_compact_comparison_macros(),
+        r"\clearpage",
+        rf"\subsection{{{_tex_escape(dataset.title)}}}",
+    ]
+    for block_index, multiplicities in enumerate(blocks):
+        block = _matrix_block(
+            adapter,
+            dataset,
+            multiplicities,
+            block_index=block_index,
+            block_count=len(blocks),
+            baseline_dataset_id=baseline_dataset_id,
+        )
+        lines.extend(block[1:] if block_index == 0 else block)
+    return "\n".join(lines) + "\n"
+
+
+def render_matrix_comparison_table(
+    view: MatrixComparisonView,
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> str:
+    """Render a cache-reusing matrix view against its explicit reference."""
+
+    candidate = catalog.dataset(view.candidate_dataset_id)
+    baseline_specs = {
+        cell.measurement
+        for cell in catalog.reference_cells()
+        if cell.dataset_id == view.baseline_dataset_id
+    }
+    if len(baseline_specs) != 1:
+        raise ValueError(
+            f"comparison view {view.comparison_id!r} has no unique baseline spec"
+        )
+    dataset = replace(
+        candidate,
+        title=view.title,
+        table_name=view.table_name,
+        baseline=next(iter(baseline_specs)),
+    )
+    return render_matrix_table(
+        dataset,
+        caches,
+        catalog=catalog,
+        baseline_dataset_id=view.baseline_dataset_id,
+    )
+
+
+def render_all_matrix_tables(
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> dict[str, str]:
+    """Render canonical matrices and cache-reusing comparison views."""
+
+    cache_source = caches if isinstance(caches, Mapping) else tuple(caches)
+    comparison_candidate_ids = {
+        view.candidate_dataset_id for view in catalog.matrix_comparison_views
+    }
+    rendered = {
+        dataset.table_name: render_matrix_table(
+            dataset,
+            cache_source,
+            catalog=catalog,
+        )
+        for dataset in catalog.matrix_datasets
+        if not (
+            dataset.dataset_id in comparison_candidate_ids
+            and dataset.baseline.execution_mode is ExecutionMode.MADGRAPH
+        )
+    }
+    rendered.update(
+        {
+            view.table_name: render_matrix_comparison_table(
+                view,
+                cache_source,
+                catalog=catalog,
+            )
+            for view in catalog.matrix_comparison_views
+        }
+    )
+    return rendered
+
+
+def _canonical_best_mode_terminal_label(
+    terminals: Sequence[_TerminalOutcome | _TerminalSummary | None],
+) -> _TerminalSummary | None:
+    """Return one deterministic, bounded label for represented terminals."""
+
+    if not terminals:
+        return None
+    represented: list[_TerminalOutcome] = []
+    for terminal in terminals:
+        if terminal is None:
+            continue
+        outcomes = (
+            terminal.outcomes if isinstance(terminal, _TerminalSummary) else (terminal,)
+        )
+        for outcome in outcomes:
+            key = (outcome.identity, outcome.label, outcome.color)
+            if all(
+                (item.identity, item.label, item.color) != key for item in represented
+            ):
+                represented.append(outcome)
+
+    def order(outcome: _TerminalOutcome) -> tuple[int, float, str, str]:
+        time_cap = (
+            _TIME_CAP_LABEL.fullmatch(outcome.label)
+            if outcome.color == "ReportOrange"
+            else None
+        )
+        if time_cap is not None:
+            seconds = float(time_cap.group("value")) * (
+                3600.0 if time_cap.group("unit") == "h" else 1.0
+            )
+            return (0, seconds, outcome.label, outcome.identity)
+        ram_cap = (
+            _RAM_CAP_LABEL.fullmatch(outcome.label)
+            if outcome.color == "ReportOrange"
+            else None
+        )
+        if ram_cap is not None:
+            return (1, float(ram_cap.group("value")), outcome.label, outcome.identity)
+        if outcome.color == "ReportOrange" and outcome.label == "dependency":
+            return (2, 0.0, outcome.label, outcome.identity)
+        return (3, 0.0, outcome.label, outcome.identity)
+
+    outcomes = tuple(sorted(represented, key=order))
+    if not outcomes:
+        return None
+    labels = tuple(_compact_terminal_display(outcome) for outcome in outcomes)
+    label = " | ".join(labels)
+    if len(label) > _MAX_BEST_MODE_TERMINAL_LABEL_CHARS:
+        separators = 3 * (len(labels) - 1)
+        item_budget = max(
+            _TERMINAL_LABEL_DIGEST_CHARS + 3,
+            (_MAX_BEST_MODE_TERMINAL_LABEL_CHARS - separators) // len(labels),
+        )
+        compacted: list[str] = []
+        for outcome in outcomes:
+            if len(outcome.label) <= item_budget:
+                compacted.append(outcome.label)
+                continue
+            digest = hashlib.sha256(
+                f"{outcome.identity}\0{outcome.label}".encode()
+            ).hexdigest()[:_TERMINAL_LABEL_DIGEST_CHARS]
+            prefix_chars = item_budget - len(digest) - 2
+            compacted.append(f"{outcome.label[:prefix_chars]}..{digest}")
+        label = " | ".join(compacted)
+    if len(label) > _MAX_BEST_MODE_TERMINAL_LABEL_CHARS:
+        identity_digest = hashlib.sha256(
+            "\0".join(
+                f"{outcome.identity}\0{outcome.label}\0{outcome.color}"
+                for outcome in outcomes
+            ).encode()
+        ).hexdigest()[:_TERMINAL_LABEL_DIGEST_CHARS]
+        label = f"{len(outcomes)} outcomes [{identity_digest}]"
+    color = (
+        "ReportOrange"
+        if all(outcome.color == "ReportOrange" for outcome in outcomes)
+        else "ReportRed"
+    )
+    return _TerminalSummary(outcomes=outcomes, label=label, color=color)
+
+
+def _terminal_measurement_label(measurement: Measurement) -> _TerminalOutcome | None:
+    status = measurement.get("status")
+    if status in {ResultStatus.NOT_AVAILABLE.value, ResultStatus.OK.value}:
+        return None
+    return _visible_status(measurement)
+
+
+def _best_mode_terminal_status(joined: BestModeWorkload) -> str:
+    if joined.terminal_label is None:
+        return _status(joined.candidate)
+    display_label = _compact_terminal_summary_display(joined.terminal_label)
+    return (
+        rf"\matrixstatus{{{joined.terminal_label.color}}}"
+        rf"{{{_tex_escape(display_label)}}}"
+    )
+
+
+def _compact_terminal_summary_display(summary: _TerminalSummary) -> str:
+    if len(summary.outcomes) == 1:
+        return _compact_terminal_display(summary.outcomes[0])
+    return _compact_terminal_display(
+        _TerminalOutcome(
+            identity="summary:"
+            + "|".join(outcome.identity for outcome in summary.outcomes),
+            label=summary.label,
+            color=summary.color,
+        )
+    )
+
+
+def _best_mode_generation_comparison_layout(
+    joined: BestModeWorkload,
+    *,
+    baseline_static_na: bool = False,
+    comparable: bool = True,
+) -> _BestModeComparisonLayout:
+    if joined.mode is None:
+        status = _best_mode_terminal_status(joined)
+        return _BestModeComparisonLayout(status, "", status)
+    if not _ok(joined.candidate):
+        status = _status(joined.candidate)
+        mode_code = _BEST_MODE_CODES[joined.mode]
+        return _BestModeComparisonLayout(
+            rf"\bestmodecodeprefix{{{mode_code}}}{status}",
+            rf"\bestmodecodeprefix{{{mode_code}}}",
+            status,
+        )
+    assert joined.mode is not None
+    mode_code = _BEST_MODE_CODES[joined.mode]
+    if joined.mode is ExecutionMode.ON_THE_FLY:
+        absolute = (
+            joined.workload is Workload.ALL_FLOW
+            or baseline_static_na
+            or not comparable
+            or not _generation_comparison_linked(joined)
+            or not _ok(joined.baseline)
+        )
+        pair = _otf_generation_pair_layout(
+            joined.candidate,
+            None if absolute else joined.baseline,
+        )
+        if absolute:
+            code = rf"\bestmodecode{{{mode_code}}}"
+            return _BestModeComparisonLayout(
+                rf"{pair.inline}\hspace{{0.025in}}{code}",
+                pair.prefix,
+                rf"{pair.primary}\hspace{{0.025in}}{code}",
+            )
+        code_prefix = rf"\bestmodecodeprefix{{{mode_code}}}"
+        return _BestModeComparisonLayout(
+            f"{code_prefix}{pair.inline}",
+            f"{code_prefix}{pair.prefix}",
+            pair.primary,
+        )
+    if (
+        baseline_static_na
+        or not comparable
+        or not _generation_comparison_linked(joined)
+        or not _ok(joined.baseline)
+    ):
+        absolute = _best_mode_metric(joined.candidate, "generation_seconds")
+        return _BestModeComparisonLayout(
+            rf"\bestmodeabsolutechoice{{{absolute}}}{{{mode_code}}}",
+            rf"\bestmodeabsoluteprefix{{{absolute}}}",
+            rf"\bestmodecode{{{mode_code}}}",
+        )
+    if not _ok(joined.baseline):
+        status = _status(joined.baseline)
+        return _BestModeComparisonLayout(status, "", status)
+    generation_ratio = _ratio_value(
+        joined.candidate,
+        joined.baseline,
+        "generation_seconds",
+    )
+    if generation_ratio is None:
+        unavailable = r"\matrixna{ReportMuted}"
+        return _BestModeComparisonLayout(unavailable, "", unavailable)
+    generation_color = _best_mode_ratio_color(generation_ratio)
+    ratio = (
+        rf"\bestmoderatio{{{generation_color}}}"
+        rf"{{{_best_mode_value(generation_ratio)}}}"
+    )
+    return _BestModeComparisonLayout(
+        rf"\bestmodecodeprefix{{{mode_code}}}{ratio}",
+        rf"\bestmodecodeprefix{{{mode_code}}}",
+        ratio,
+    )
+
+
+def _best_mode_generation_comparison(
+    joined: BestModeWorkload,
+    *,
+    baseline_static_na: bool = False,
+    comparable: bool = True,
+) -> str:
+    return _best_mode_generation_comparison_layout(
+        joined,
+        baseline_static_na=baseline_static_na,
+        comparable=comparable,
+    ).inline
+
+
+def _best_mode_runtime_comparison_layout(
+    joined: BestModeWorkload,
+    *,
+    baseline_mode: ExecutionMode = ExecutionMode.AMPLICOL,
+    baseline_static_na: bool = False,
+) -> _BestModeComparisonLayout:
+    if joined.mode is None:
+        status = _best_mode_terminal_status(joined)
+        return _BestModeComparisonLayout(status, "", status)
+    if not _ok(joined.candidate):
+        status = _status(joined.candidate)
+        return _BestModeComparisonLayout(status, "", status)
+    if (
+        baseline_static_na
+        or not joined.comparison_linked
+        or (baseline_mode is ExecutionMode.AMPLICOL and not _ok(joined.baseline))
+    ):
+        wall = _best_mode_metric(
+            joined.candidate,
+            "wall_seconds_per_point",
+            microseconds=True,
+        )
+        return _BestModeComparisonLayout(
+            wall,
+            rf"\bestmodeabsoluteprefix{{{wall}}}",
+            "",
+        )
+    if not _ok(joined.baseline):
+        status = _status(joined.baseline)
+        return _BestModeComparisonLayout(status, "", status)
+    wall_ratio = _ratio_value(
+        joined.candidate,
+        joined.baseline,
+        "wall_seconds_per_point",
+    )
+    if wall_ratio is None:
+        unavailable = r"\matrixnaratio{ReportMuted}"
+        return _BestModeComparisonLayout(unavailable, "", unavailable)
+    wall_color = _best_mode_ratio_color(wall_ratio)
+    secondary_ratio = _secondary_runtime_ratio(
+        joined.candidate,
+        joined.baseline,
+        baseline_mode=baseline_mode,
+    )
+    if secondary_ratio is None:
+        inline = (
+            rf"\bestmodewallratio{{{wall_color}}}"
+            rf"{{{_best_mode_value(wall_ratio)}}}"
+        )
+        return _BestModeComparisonLayout(
+            inline,
+            "",
+            inline,
+        )
+    inline = (
+        rf"\bestmodecompactratio{{{_best_mode_value(secondary_ratio)}}}"
+        rf"{{{wall_color}}}{{{_best_mode_value(wall_ratio)}}}"
+    )
+    return _BestModeComparisonLayout(
+        inline,
+        rf"\bestmodecompactprefix{{{_best_mode_value(secondary_ratio)}}}",
+        (
+            rf"\bestmodeprimaryratio{{{wall_color}}}"
+            rf"{{{_best_mode_value(wall_ratio)}}}"
+        ),
+    )
+
+
+def _best_mode_runtime_comparison(
+    joined: BestModeWorkload,
+    *,
+    baseline_static_na: bool = False,
+) -> str:
+    return _best_mode_runtime_comparison_layout(
+        joined,
+        baseline_static_na=baseline_static_na,
+    ).inline
+
+
+def _best_mode_comparison_columns(
+    layout: _BestModeComparisonLayout,
+) -> tuple[str, str]:
+    """Expose a comparison's prefix and primary anchor as table columns."""
+
+    return layout.prefix, layout.primary
+
+
+def _best_mode_summary_terminal_label(
+    joined: BestModeWorkload,
+) -> _TerminalOutcome | _TerminalSummary | None:
+    if joined.mode is None:
+        return joined.terminal_label
+    if not _ok(joined.candidate):
+        return _terminal_measurement_label(joined.candidate)
+    return None
+
+
+def _best_mode_lc_cell(
+    view: BestModeMatrixCell,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> _BestModeCellRows:
+    selected, all_flow = view.workloads
+    baseline_static_na = _legacy_baseline_static_na(
+        catalog=catalog,
+        accuracy=view.accuracy,
+        process_key=view.process_family.key,
+        n_final=view.n_final,
+        workload=selected.workload,
+    )
+    selected_baseline_generation = (
+        _static_na()
+        if baseline_static_na
+        else _original_amplicol_generation_metric(
+            selected,
+            candidate_mode=selected.mode,
+        )
+    )
+    all_flow_baseline_generation = (
+        _static_na()
+        if baseline_static_na
+        else _original_amplicol_generation_metric(
+            all_flow,
+            candidate_mode=all_flow.mode,
+        )
+    )
+    selected_baseline_runtime = (
+        _static_na()
+        if baseline_static_na
+        else _best_mode_metric(
+            selected.baseline,
+            "wall_seconds_per_point",
+            microseconds=True,
+        )
+    )
+    all_flow_baseline_runtime = (
+        _static_na()
+        if baseline_static_na
+        else _best_mode_metric(
+            all_flow.baseline,
+            "wall_seconds_per_point",
+            microseconds=True,
+        )
+    )
+    selected_generation = _best_mode_generation_comparison_layout(
+        selected,
+        baseline_static_na=baseline_static_na,
+    )
+    all_flow_generation = _best_mode_generation_comparison_layout(
+        all_flow,
+        baseline_static_na=baseline_static_na,
+        comparable=False,
+    )
+    selected_runtime = _best_mode_runtime_comparison_layout(
+        selected,
+        baseline_static_na=baseline_static_na,
+    )
+    all_flow_runtime = _best_mode_runtime_comparison_layout(
+        all_flow,
+        baseline_static_na=baseline_static_na,
+    )
+    return _BestModeCellRows(
+        generation=(
+            selected_baseline_generation,
+            r"\matrixpunct{|}",
+            all_flow_baseline_generation,
+            *_best_mode_comparison_columns(selected_generation),
+            r"\matrixpunct{|}",
+            *_best_mode_comparison_columns(all_flow_generation),
+        ),
+        runtime=(
+            selected_baseline_runtime,
+            r"\matrixpunct{|}",
+            all_flow_baseline_runtime,
+            *_best_mode_comparison_columns(selected_runtime),
+            r"\matrixpunct{|}",
+            *_best_mode_comparison_columns(all_flow_runtime),
+        ),
+    )
+
+
+def _best_mode_contracted_cell(
+    view: BestModeMatrixCell,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> _BestModeCellRows:
+    joined = view.workloads[0]
+    baseline_static_na = _legacy_baseline_static_na(
+        catalog=catalog,
+        accuracy=view.accuracy,
+        process_key=view.process_family.key,
+        n_final=view.n_final,
+        workload=joined.workload,
+    )
+    baseline_generation = (
+        _static_na()
+        if baseline_static_na
+        else _original_amplicol_generation_metric(
+            joined,
+            candidate_mode=joined.mode,
+        )
+    )
+    baseline_runtime = (
+        _static_na()
+        if baseline_static_na
+        else _best_mode_metric(
+            joined.baseline,
+            "wall_seconds_per_point",
+            microseconds=True,
+        )
+    )
+    generation_comparison = _best_mode_generation_comparison_layout(
+        joined,
+        baseline_static_na=baseline_static_na,
+    )
+    runtime_comparison = _best_mode_runtime_comparison_layout(
+        joined,
+        baseline_static_na=baseline_static_na,
+    )
+    return _BestModeCellRows(
+        generation=(
+            baseline_generation,
+            *_best_mode_comparison_columns(generation_comparison),
+        ),
+        runtime=(
+            baseline_runtime,
+            *_best_mode_comparison_columns(runtime_comparison),
+        ),
+    )
+
+
+def _best_mode_summary_pair(
+    views: Sequence[BestModeMatrixCell],
+    workload: Workload,
+    field: str,
+) -> str:
+    joined, valid = _best_mode_summary_items(views, workload, field)
+    if not valid:
+        if field == "execution_seconds_per_point" and any(
+            unavailable_execution_timing_record(measurement, field) is not None
+            for item in joined
+            for measurement in (item.baseline, item.candidate)
+        ):
+            return _not_exposed()
+        terminal_label = _canonical_best_mode_terminal_label(
+            tuple(_best_mode_summary_terminal_label(item) for item in joined)
+        )
+        if terminal_label is not None:
+            display_label = _compact_terminal_summary_display(terminal_label)
+            return (
+                rf"\matrixstatus{{{terminal_label.color}}}"
+                rf"{{{_tex_escape(display_label)}}}"
+            )
+        return r"\matrixna{ReportMuted}"
+    timings: list[tuple[float, float]] = []
+    for item in valid:
+        candidate_value = _best_mode_summary_candidate_value(item, field)
+        assert candidate_value is not None
+        timings.append((float(item.baseline[field]), candidate_value))
+    return _ratio_statistics_tex(tuple(timings))
+
+
+def _best_mode_summary_candidate_value(
+    item: BestModeWorkload,
+    field: str,
+) -> float | None:
+    """Return the candidate value represented by a best-table primary token."""
+
+    if field == "generation_seconds" and item.mode is ExecutionMode.ON_THE_FLY:
+        generation = _positive_timing_value(item.candidate, field)
+        cold_warmup = _otf_cold_warmup_seconds(item.candidate)
+        if generation is None or cold_warmup is None:
+            return None
+        total = generation + cold_warmup
+        return total if math.isfinite(total) else None
+    value = item.candidate.get(field)
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    number = float(value)
+    return number if math.isfinite(number) and number >= 0.0 else None
+
+
+def _best_mode_summary_items(
+    views: Sequence[BestModeMatrixCell],
+    workload: Workload,
+    field: str,
+) -> tuple[tuple[BestModeWorkload, ...], tuple[BestModeWorkload, ...]]:
+    """Return joined and ratio-eligible workloads for one summary metric."""
+
+    joined = tuple(
+        next(item for item in view.workloads if item.workload is workload)
+        for view in views
+        if view.applicable
+    )
+    valid = tuple(
+        item
+        for item in joined
+        if (
+            _generation_comparison_linked(item)
+            if field == "generation_seconds"
+            else item.comparison_linked
+        )
+        and item.mode is not None
+        and _ok(item.baseline)
+        and _ok(item.candidate)
+        and item.baseline.get(field) is not None
+        and _best_mode_summary_candidate_value(item, field) is not None
+        and unavailable_execution_timing_record(item.baseline, field) is None
+        and unavailable_execution_timing_record(item.candidate, field) is None
+        and math.isfinite(float(item.baseline[field]))
+        and float(item.baseline[field]) > 0.0
+    )
+    return joined, valid
+
+
+def _best_mode_generation_mode_mix(
+    views: Sequence[BestModeMatrixCell],
+    accuracy: Accuracy,
+) -> str:
+    workload = (
+        Workload.SELECTED_FLOW if accuracy is Accuracy.LC else Workload.CONTRACTED
+    )
+    _joined, valid = _best_mode_summary_items(
+        views,
+        workload,
+        "generation_seconds",
+    )
+    if not valid:
+        return ""
+    displayed_modes = _BEST_MODE_ORDER
+    counts = {
+        mode: sum(item.mode is mode for item in valid) for mode in displayed_modes
+    }
+    return (
+        r"\bestmodemix{"
+        + "|".join(
+            f"{_BEST_MODE_CODES[mode]}:{counts[mode]}" for mode in displayed_modes
+        )
+        + "}"
+    )
+
+
+def _best_mode_generation_summary(
+    views: Sequence[BestModeMatrixCell],
+    accuracy: Accuracy,
+) -> str:
+    if accuracy is Accuracy.LC:
+        return _best_mode_summary_pair(
+            views,
+            Workload.SELECTED_FLOW,
+            "generation_seconds",
+        )
+    return _best_mode_summary_pair(
+        views,
+        Workload.CONTRACTED,
+        "generation_seconds",
+    )
+
+
+def _best_mode_wall_summary(
+    views: Sequence[BestModeMatrixCell],
+    accuracy: Accuracy,
+) -> str:
+    if accuracy is Accuracy.LC:
+        selected = _best_mode_summary_pair(
+            views,
+            Workload.SELECTED_FLOW,
+            "wall_seconds_per_point",
+        )
+        all_flow = _best_mode_summary_pair(
+            views,
+            Workload.ALL_FLOW,
+            "wall_seconds_per_point",
+        )
+        return rf"\matrixsummaryworkloads{{{selected}}}{{{all_flow}}}"
+    return _best_mode_summary_pair(
+        views,
+        Workload.CONTRACTED,
+        "wall_seconds_per_point",
+    )
+
+
+def _best_mode_block(
+    adapter: BaselineCandidateAdapter,
+    accuracy: Accuracy,
+    multiplicities: tuple[int, ...],
+    *,
+    block_index: int,
+    block_count: int,
+) -> list[str]:
+    accuracy_label = {
+        Accuracy.LC: "LC",
+        Accuracy.NLC: "NLC",
+        Accuracy.FULL: "full-colour",
+    }[accuracy]
+    if len(multiplicities) not in (2, 3):
+        raise ValueError("matrix blocks must contain two or three multiplicities")
+    column_spec = _metric_table_column_spec(
+        accuracy,
+        len(multiplicities),
+    )
+    lines = [
+        r"\clearpage",
+        r"\noindent\begin{minipage}{\linewidth}",
+        (
+            rf"\subsubsection*{{Built-in SM best measured mode versus AmpliCol "
+            rf"{accuracy_label}"
+            + (
+                ""
+                if block_count == 1
+                else rf" (block {block_index + 1} of {block_count})"
+            )
+            + "}"
+        ),
+        r"\begingroup",
+        r"\centering",
+        r"\footnotesize",
+        r"\setlength{\tabcolsep}{2.1pt}",
+        r"\renewcommand{\arraystretch}{1.00}",
+        r"\matrixfitwidth{%",
+        rf"\begin{{tabular}}{{{column_spec}}}",
+        r"\toprule",
+        (
+            r"\textbf{ID} & \textbf{base process} & \textbf{metric} & "
+            + " & ".join(
+                _metric_group_cell(
+                    rf"\textbf{{n={n_final}}}",
+                    accuracy,
+                )
+                for n_final in multiplicities
+            )
+            + r" \\"
+        ),
+        r"\specialrule{0.85pt}{0pt}{0pt}",
+    ]
+    views_by_n: dict[int, list[BestModeMatrixCell]] = {
+        n_final: [] for n_final in multiplicities
+    }
+    for row_index, family in enumerate(adapter.catalog.process_families):
+        generation_row = [
+            rf"\texttt{{{family.identifier}}}",
+            family.label_tex,
+            _metric_row_label(runtime=False),
+        ]
+        runtime_row = ["", "", _metric_row_label(runtime=True)]
+        for n_final in multiplicities:
+            view = adapter.best_mode_cell(accuracy, family, n_final)
+            views_by_n[n_final].append(view)
+            if not view.applicable:
+                generation_row.append(
+                    _metric_group_cell(
+                        _matrix_scope_marker(family, n_final, accuracy),
+                        accuracy,
+                    )
+                )
+                runtime_row.append(
+                    _metric_group_cell(
+                        "",
+                        accuracy,
+                    )
+                )
+            elif accuracy is Accuracy.LC:
+                rendered = _best_mode_lc_cell(
+                    view,
+                    catalog=adapter.catalog,
+                )
+                generation_row.extend(rendered.generation)
+                runtime_row.extend(rendered.runtime)
+            else:
+                rendered = _best_mode_contracted_cell(
+                    view,
+                    catalog=adapter.catalog,
+                )
+                generation_row.extend(rendered.generation)
+                runtime_row.extend(rendered.runtime)
+        if row_index % 2 == 0:
+            lines.append(r"\rowcolor{refblue}")
+        lines.append(" & ".join(generation_row) + r" \\")
+        if row_index % 2 == 0:
+            lines.append(r"\rowcolor{refblue}")
+        lines.append(" & ".join(runtime_row) + r" \\")
+        lines.append(r"\addlinespace[0.05em]")
+    boundary_note = (
+        r" For the LC all-flow workload, AmpliCol direct-evaluation setup and "
+        r"pyAmpliCol process generation have different boundaries, so the "
+        r"candidate generation value is shown absolutely; no "
+        r"misleading multiplier is formed."
+        if accuracy is Accuracy.LC
+        else ""
+    )
+    otf_generation_note = (
+        r" OTF \texttt{([xG]x(G+W)) | [G]G+W} follows the enclosing "
+        r"cold-start contract."
+        if accuracy is Accuracy.LC
+        else (
+            r" OTF \texttt{([xG]x(G+W))} follows the enclosing "
+            r"contracted cold-start contract."
+        )
+    )
+    mode_legend_note = (
+        r" Muted generation-row codes (r)|(c)|(e)|(o) identify "
+        r"recurrence JIT O2, compiled JIT O3, eager-DAG JIT O2, and "
+        r"on-the-fly JIT O2 wall-time winners; runtime rows omit them. "
+        r"Summary mode counts use r|c|e|o in the same order."
+    )
+    lines.extend(
+        [
+            r"\specialrule{1.05pt}{0.22em}{0.18em}",
+            _metric_summary_header_row(
+                multiplicities,
+                accuracy,
+                annotations=tuple(
+                    _best_mode_generation_mode_mix(
+                        views_by_n[n_final],
+                        accuracy,
+                    )
+                    for n_final in multiplicities
+                ),
+            ),
+            (
+                r"\multicolumn{3}{@{}l}{\textbf{summary: generation}} & "
+                + " & ".join(
+                    _metric_summary_group_cell(
+                        _best_mode_generation_summary(
+                            views_by_n[n_final],
+                            accuracy,
+                        ),
+                        accuracy,
+                        group_index=group_index,
+                    )
+                    for group_index, n_final in enumerate(multiplicities)
+                )
+                + r" \\[0.08em]"
+            ),
+            (
+                rf"\multicolumn{{3}}{{@{{}}l}}{{"
+                rf"{_matrix_wall_summary_label(accuracy)}}} & "
+                + " & ".join(
+                    _metric_summary_group_cell(
+                        _best_mode_wall_summary(
+                            views_by_n[n_final],
+                            accuracy,
+                        ),
+                        accuracy,
+                        group_index=group_index,
+                    )
+                    for group_index, n_final in enumerate(multiplicities)
+                )
+                + r" \\"
+            ),
+            r"\bottomrule",
+            r"\end{tabular}",
+            r"}",
+            r"\endgroup",
+            (
+                r"\ReportTableNote{{\scriptsize The candidate is selected "
+                r"independently in "
+                r"each cell and workload by the smallest validated wall time. "
+                r"The upper row is generation in seconds and the lower row is "
+                r"runtime in \(\mu\mathrm{s}/\mathrm{pt}\). In LC cells, each "
+                r"pair is non-union-flow \texttt{|} union-flow. Generation "
+                r"multipliers are coloured directly. Each runtime workload "
+                r"uses \texttt{([xS]xW)}. The muted supplementary xS first "
+                r"compares compatible exposed execution attributions; otherwise "
+                r"it uses authenticated evaluator totals. Because original "
+                r"AmpliCol exposes no evaluator-total clock, a candidate total "
+                r"then uses the AmpliCol direct execution clock, or its wall "
+                r"clock when direct execution is absent, as denominator. An "
+                r"evaluator total is "
+                r"never divided by a recurrence core. This evaluator-total "
+                r"fallback is diagnostic only; execution/execution remains the "
+                r"compatible supplementary attribution. The coloured xW is always "
+                r"the candidate/AmpliCol wall-time multiplier used for selection "
+                r"and as the primary figure of merit. If no compatible "
+                r"supplementary clock exists, only \texttt{(xW)} is shown. No "
+                r"clock is fabricated from another. Every "
+                r"displayed number uses exactly three significant digits. "
+                r"Original-AmpliCol "
+                r"rows beyond its three-open-quark-line scope are catalog "
+                r"static N/A entries; their candidates are shown absolutely and "
+                r"excluded from ratio summaries. Unavailable baselines keep "
+                r"their status; candidates remain absolute. Unverified "
+                r"compiled, eager, or on-the-fly diagnostics are never eligible "
+                r"for best-mode selection or summaries and remain visibly marked "
+                r"unverified."
+                + boundary_note
+                + otf_generation_note
+                + r" Only exact stored same-point links enter ratios."
+                + r" Summary rows contain multipliers only in min, max, "
+                r"median, average, and weighted-average order; the weighted "
+                r"average is the ratio of timing sums and is the framed bold "
+                r"entry. "
+                r"LC generation is non-union only; LC runtime retains separate "
+                r"non-union and union wall-only lines."
+                + mode_legend_note
+                + r"}}"
+            ),
+            r"\end{minipage}",
+        ]
+    )
+    return lines
+
+
+def render_best_mode_table(
+    accuracy: Accuracy,
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> str:
+    """Render the fastest valid built-in mode against AmpliCol."""
+
+    adapter = BaselineCandidateAdapter(caches, catalog=catalog)
+    multiplicities = matrix_multiplicities(accuracy)
+    blocks = _chunks(multiplicities, _MATRIX_BLOCK_SIZE)
+    accuracy_label = {
+        Accuracy.LC: "LC",
+        Accuracy.NLC: "NLC",
+        Accuracy.FULL: "full-colour",
+    }[accuracy]
+    lines = [
+        "% SPDX-License-Identifier: 0BSD",
+        "% Generated by tools/performance_report/render.py; do not edit.",
+        *_matrix_macros(),
+        (
+            r"\providecommand{\matrixpair}[2]{"
+            r"\begin{tabular}[t]{@{}r@{\hspace{0.025in}"
+            r"\matrixpunct{|}\hspace{0.025in}}r@{}}"
+            r"#1&#2\end{tabular}}"
+        ),
+        *_compact_comparison_macros(),
+        (
+            r"\providecommand{\bestmodecode}[1]{"
+            r"\textcolor{ReportMuted}{\texttt{(#1)}}}"
+        ),
+        (
+            r"\providecommand{\bestmodecodeprefix}[1]{"
+            r"\bestmodecode{#1}\hspace{0.025in}}"
+        ),
+        (
+            r"\providecommand{\bestmodeabsolutechoice}[2]{"
+            r"#1\hspace{0.025in}\bestmodecode{#2}}"
+        ),
+        (
+            r"\providecommand{\bestmodemix}[1]{"
+            r"\textcolor{ReportBlue}{\texttt{[#1]}}}"
+        ),
+        r"\clearpage",
+        (
+            r"\subsection{Built-in SM best measured mode versus AmpliCol: "
+            f"{accuracy_label}}}"
+        ),
+    ]
+    for block_index, block in enumerate(blocks):
+        rendered = _best_mode_block(
+            adapter,
+            accuracy,
+            block,
+            block_index=block_index,
+            block_count=len(blocks),
+        )
+        lines.extend(rendered[1:] if block_index == 0 else rendered)
+    return "\n".join(lines) + "\n"
+
+
+def render_all_best_mode_tables(
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> dict[str, str]:
+    cache_source = caches if isinstance(caches, Mapping) else tuple(caches)
+    return {
+        _BEST_MODE_TABLE_NAMES[accuracy]: render_best_mode_table(
+            accuracy,
+            cache_source,
+            catalog=catalog,
+        )
+        for accuracy in Accuracy
+    }
+
+
+def _z_setup(variant: ZVariant) -> str:
+    labels = {
+        "reference": r"\AC{} reference",
+        "jit_o1": r"compiled JIT O1",
+        "asm_o3": r"compiled ASM O3",
+        "cpp_o3": r"compiled C++ O3",
+        "jit_o3": r"compiled JIT O3",
+        "eager_jit_o2": r"eager-DAG JIT O2",
+        "recurrence_jit_o2": r"recurrence JIT O2",
+        "on_the_fly_jit_o2": r"on-the-fly JIT O2",
+    }
+    return labels.get(variant.key, _tex_escape(variant.label))
+
+
+def _z_value(
+    joined: JoinedWorkload,
+    field: str,
+    *,
+    reference: bool,
+    microseconds: bool = False,
+    comparable: bool = True,
+    static_na: bool = False,
+) -> str:
+    if static_na:
+        return _static_na()
+    measurement = joined.baseline if reference else joined.candidate
+    if (
+        not reference
+        and measurement.get("status") == ResultStatus.UNVERIFIED.value
+    ):
+        return _unverified_absolute_time(
+            measurement,
+            field,
+            microseconds=microseconds,
+        )
+    absolute = _metric(measurement, field, microseconds=microseconds)
+    if reference or not _ok(measurement):
+        return absolute
+    if (
+        unavailable_execution_timing_record(measurement, field) is not None
+        or unavailable_execution_timing_record(joined.baseline, field) is not None
+    ):
+        if evaluator_total_timing_record(measurement) is not None:
+            return absolute
+        return _not_exposed()
+    if not comparable or not joined.comparison_linked or not _ok(joined.baseline):
+        return rf"\matrixncabsolute{{{absolute}}}"
+    return absolute + r"\," + _ratio(measurement, joined.baseline, field)
+
+
+def _z_generation_value(
+    joined: JoinedWorkload,
+    variant: ZVariant,
+    *,
+    reference: bool,
+    comparable: bool = True,
+    static_na: bool = False,
+) -> str:
+    """Render one Z-ladder generation cell without hiding OTF cold start."""
+
+    if (
+        not reference
+        and variant.execution_mode is ExecutionMode.ON_THE_FLY
+        and not static_na
+        and _ok(joined.candidate)
+    ):
+        return _otf_generation_pair_layout(joined.candidate, None).inline
+    return _z_value(
+        joined,
+        "generation_seconds",
+        reference=reference,
+        comparable=comparable,
+        static_na=static_na,
+    )
+
+
+def _z_evaluator_total(
+    joined: JoinedWorkload,
+    *,
+    reference: bool,
+    static_na: bool = False,
+) -> str:
+    if static_na:
+        return _static_na()
+    measurement = joined.baseline if reference else joined.candidate
+    if reference:
+        return _not_exposed()
+    if measurement.get("status") == ResultStatus.UNVERIFIED.value:
+        return _unverified_evaluator_total(measurement)
+    if not _ok(measurement):
+        return _status(measurement)
+    total = evaluator_total_seconds_per_point(measurement)
+    if total is None:
+        return _not_exposed()
+    absolute = _time(total, microseconds=True)
+    if not joined.comparison_linked or not _ok(joined.baseline):
+        return rf"\matrixncabsolute{{{absolute}}}"
+    baseline_wall = joined.baseline.get("wall_seconds_per_point")
+    if (
+        isinstance(baseline_wall, bool)
+        or not isinstance(baseline_wall, (int, float))
+        or not math.isfinite(float(baseline_wall))
+        or float(baseline_wall) <= 0.0
+    ):
+        return absolute + r"\," + r"\matrixnaratio{ReportMuted}"
+    ratio = total / float(baseline_wall)
+    return (
+        absolute
+        + r"\,"
+        + rf"\matrixratio{{{_best_mode_ratio_color(ratio)}}}"
+        + rf"{{{_compact(ratio)}}}"
+    )
+
+
+def _z_block(
+    adapter: BaselineCandidateAdapter,
+    *,
+    model: ModelKey,
+    multiplicities: tuple[int, ...],
+    block_index: int,
+    block_count: int,
+) -> list[str]:
+    model_label = "Built-in SM" if model is ModelKey.BUILTIN_SM else "UFO-SM"
+    candidate_cells = {
+        (cell.n_final, cell.variant, cell.workload): cell
+        for cell in adapter.catalog.z_cells()
+        if cell.dataset_id == z_dataset_id(model)
+    }
+    lines = [
+        r"\clearpage",
+        r"\noindent\begin{minipage}{\linewidth}",
+        (
+            rf"\subsubsection*{{{model_label} \(d\bar d\to Z+\) gluon ladder"
+            + (
+                ""
+                if block_count == 1
+                else rf" (block {block_index + 1} of {block_count})"
+            )
+            + "}"
+        ),
+        r"\begingroup",
+        r"\centering",
+        r"\scriptsize",
+        r"\setlength{\tabcolsep}{1.4pt}",
+        r"\renewcommand{\arraystretch}{1.05}",
+        (
+            r"\begin{tabular}{@{}r L{1.50in} "
+            r"R{1.26in} R{1.26in} R{1.26in} "
+            r"@{\hspace{0.08in}}"
+            r"R{1.26in} R{1.26in} R{1.26in}@{}}"
+        ),
+        r"\toprule",
+        (
+            r"\textbf{n} & \textbf{setup} & "
+            r"\multicolumn{3}{c}{\textbf{selected flow, helicity sum}} & "
+            r"\multicolumn{3}{c}{\textbf{all flows, single helicity}} \\"
+        ),
+        (
+            r"& & \textbf{gen [s]} & "
+            r"\textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & "
+            r"\textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} & "
+            r"\textbf{gen [s]} & "
+            r"\textbf{wall [\(\mu\mathrm{s}/\mathrm{pt}\)]} & "
+            r"\textbf{eval [\(\mu\mathrm{s}/\mathrm{pt}\)]} \\"
+        ),
+        r"\midrule",
+    ]
+    for n_final in multiplicities:
+        for variant in adapter.catalog.z_variants:
+            selected = adapter.z_workload(
+                model=model,
+                n_final=n_final,
+                variant=variant,
+                workload=Workload.SELECTED_FLOW,
+            )
+            all_flow = adapter.z_workload(
+                model=model,
+                n_final=n_final,
+                variant=variant,
+                workload=Workload.ALL_FLOW,
+            )
+            reference = variant.execution_mode is ExecutionMode.AMPLICOL
+            selected_static_na = False
+            all_flow_static_na = False
+            if not reference:
+                selected_cell = candidate_cells[
+                    (n_final, variant.key, Workload.SELECTED_FLOW)
+                ]
+                all_flow_cell = candidate_cells[
+                    (n_final, variant.key, Workload.ALL_FLOW)
+                ]
+                selected_static_na = (
+                    adapter.catalog.static_na_reason(selected_cell) is not None
+                )
+                all_flow_static_na = (
+                    adapter.catalog.static_na_reason(all_flow_cell) is not None
+                )
+            if reference:
+                lines.append(r"\rowcolor{refblue}")
+            elif variant.key in {
+                "jit_o3",
+                "eager_jit_o2",
+                "recurrence_jit_o2",
+                "on_the_fly_jit_o2",
+            }:
+                lines.append(r"\rowcolor{ReportGreen!12}")
+            row = (
+                str(n_final),
+                _z_setup(variant),
+                _z_generation_value(
+                    selected,
+                    variant,
+                    reference=reference,
+                    static_na=selected_static_na,
+                ),
+                _z_value(
+                    selected,
+                    "wall_seconds_per_point",
+                    reference=reference,
+                    microseconds=True,
+                    static_na=selected_static_na,
+                ),
+                _z_evaluator_total(
+                    selected,
+                    reference=reference,
+                    static_na=selected_static_na,
+                ),
+                _z_generation_value(
+                    all_flow,
+                    variant,
+                    reference=reference,
+                    comparable=False,
+                    static_na=all_flow_static_na,
+                ),
+                _z_value(
+                    all_flow,
+                    "wall_seconds_per_point",
+                    reference=reference,
+                    microseconds=True,
+                    static_na=all_flow_static_na,
+                ),
+                _z_evaluator_total(
+                    all_flow,
+                    reference=reference,
+                    static_na=all_flow_static_na,
+                ),
+            )
+            lines.append(" & ".join(row) + r" \\")
+        if n_final != multiplicities[-1]:
+            lines.append(r"\midrule[0.45pt]")
+    lines.extend(
+        [
+            r"\bottomrule",
+            r"\end{tabular}",
+            r"\endgroup",
+            (
+                r"\ReportTableNote{Original AmpliCol is the denominator only "
+                r"when successful and exactly linked by stored same-point "
+                r"evidence, directly or through current recurrence. Otherwise "
+                r"its status remains visible and successful pyAmpliCol values "
+                r"are absolute. Unverified diagnostics retain absolute clocks "
+                r"with a yellow marker, but never enter ratios or summaries. "
+                r"Compiled, eager, and recurrence rows report separate "
+                r"topology-replay and all-flow-union generation and runtime "
+                r"measurements. On-the-fly uses one compact query-local "
+                r"process seed for both physical workloads. Its generation "
+                r"entry is the absolute \texttt{[G] G+W} pair: muted G is "
+                r"process-seed generation and G+W adds the first cold "
+                r"on-the-fly evaluation. "
+                r"Parenthesized values are candidate/reference ratios. "
+                r"All-flow generation shows the absolute pyAmpliCol value "
+                r"without a ratio because its setup boundary differs from the "
+                r"reference. The wall time is the common runtime observable. "
+                r"Not exposed means that a successful wall measurement has no "
+                r"dedicated authenticated evaluator-total timing. Authenticated "
+                r"accumulated warmed evaluator totals appear in the eval column "
+                r"with enough precision to remain distinct from wall time. Its "
+                r"parenthesized multiplier uses the original-AmpliCol wall "
+                r"measurement as denominator because the legacy reference has "
+                r"no separate evaluator-total clock. Recurrence rows retain the "
+                r"independently measured narrower recurrence core in detailed "
+                r"evidence; it is not relabeled as evaluator total. Neither "
+                r"evaluator total nor recurrence core is derived from wall "
+                r"time or from the other. Older entries "
+                r"without authenticated total evidence remain marked not "
+                r"exposed; it is not a missing measurement. "
+                + _tex_escape(STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6_DESCRIPTION)
+                + " ("
+                + _tex_escape(STATIC_NA_NATIVE_BACKEND_GENERATION_CAP_N6)
+                + r").}"
+            ),
+            r"\end{minipage}",
+        ]
+    )
+    return lines
+
+
+def render_z_ladder(
+    model: ModelKey,
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> str:
+    if model not in {ModelKey.BUILTIN_SM, ModelKey.UFO_SM}:
+        raise ValueError("Z ladder model must be built-in SM or UFO-SM")
+    adapter = BaselineCandidateAdapter(caches, catalog=catalog)
+    model_label = "Built-in SM" if model is ModelKey.BUILTIN_SM else "UFO-SM"
+    blocks = _chunks(tuple(range(1, 10)), _Z_BLOCK_SIZE)
+    lines = [
+        "% SPDX-License-Identifier: 0BSD",
+        "% Generated by tools/performance_report/render.py; do not edit.",
+        *_matrix_macros(),
+        r"\clearpage",
+        rf"\subsection{{{model_label} dedicated \(d\bar d\to Z+\) gluon performance}}",
+    ]
+    for block_index, multiplicities in enumerate(blocks):
+        block = _z_block(
+            adapter,
+            model=model,
+            multiplicities=multiplicities,
+            block_index=block_index,
+            block_count=len(blocks),
+        )
+        lines.extend(block[1:] if block_index == 0 else block)
+    return "\n".join(lines) + "\n"
+
+
+def render_all_z_ladders(
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> dict[str, str]:
+    cache_source = caches if isinstance(caches, Mapping) else tuple(caches)
+    return {
+        "result_z_builtin_sm_table.tex": render_z_ladder(
+            ModelKey.BUILTIN_SM,
+            cache_source,
+            catalog=catalog,
+        ),
+        "result_z_external_sm_table.tex": render_z_ladder(
+            ModelKey.UFO_SM,
+            cache_source,
+            catalog=catalog,
+        ),
+    }
+
+
+def _scalar_value(measurement: Measurement, field: str) -> str:
+    if field == "evaluator_total_seconds_per_point":
+        if measurement.get("status") == ResultStatus.UNVERIFIED.value:
+            return _unverified_evaluator_total(measurement)
+        if not _ok(measurement):
+            return _status(measurement)
+        total = evaluator_total_seconds_per_point(measurement)
+        if total is None:
+            return _not_exposed()
+        return _time(total, microseconds=True)
+    if field == "matrix_element":
+        if not _ok(measurement):
+            return _status(measurement)
+        value = measurement.get(field)
+        if value is None:
+            return r"\matrixna{ReportMuted}"
+        try:
+            return rf"\texttt{{{_compact(float(value))}}}"
+        except (TypeError, ValueError):
+            return rf"\texttt{{{_tex_escape(str(value))}}}"
+    if measurement.get("status") == ResultStatus.UNVERIFIED.value:
+        return _unverified_absolute_time(
+            measurement,
+            field,
+            microseconds=field
+            in {"wall_seconds_per_point", "execution_seconds_per_point"},
+        )
+    return _metric(
+        measurement,
+        field,
+        microseconds=field in {"wall_seconds_per_point", "execution_seconds_per_point"},
+    )
+
+
+def _scalar_relative_difference(measurement: Measurement) -> str:
+    if not _ok(measurement):
+        return _status(measurement)
+    validation = measurement.get("validation")
+    if not isinstance(validation, Mapping):
+        return r"\matrixna{ReportMuted}"
+    high_precision = validation.get("high_precision")
+    if not isinstance(high_precision, Mapping):
+        return r"\matrixna{ReportMuted}"
+    value = high_precision.get("relative_difference")
+    if value is None:
+        return r"\matrixna{ReportMuted}"
+    return rf"\texttt{{{_compact(float(value))}}}"
+
+
+def render_scalar_ladder(
+    dataset: ScalarDataset,
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+) -> str:
+    index = MeasurementIndex(caches)
+    dense = len(dataset.multiplicities) > 4
+    label_width = "1.00in" if dense else "1.08in"
+    value_width = "0.72in" if dense else "0.82in"
+    tab_column_separation = "2.2pt" if dense else "3.2pt"
+    column_spec = (
+        rf"@{{}}L{{{label_width}}}"
+        + "".join(rf"L{{{value_width}}}" for _ in dataset.multiplicities)
+        + r"@{}"
+    )
+    rows = (
+        ("generation [s]", "generation_seconds"),
+        (r"wall [\(\mu\mathrm{s}/\mathrm{pt}\)]", "wall_seconds_per_point"),
+        (
+            r"{\fontsize{6.4pt}{7.4pt}\selectfont"
+            r"\mbox{evaluator total [\(\mu\mathrm{s}/\mathrm{pt}\)]}}",
+            "evaluator_total_seconds_per_point",
+        ),
+        ("matrix element", "matrix_element"),
+    )
+    lines = [
+        "% SPDX-License-Identifier: 0BSD",
+        "% Generated by tools/performance_report/render.py; do not edit.",
+        *_matrix_macros(),
+        rf"\subsection{{{_tex_escape(dataset.title)}}}",
+        r"\begingroup",
+        r"\scriptsize",
+        rf"\setlength{{\tabcolsep}}{{{tab_column_separation}}}",
+        r"\renewcommand{\arraystretch}{1.10}",
+        r"\begin{center}",
+        rf"\begin{{tabular}}{{{column_spec}}}",
+        r"\toprule",
+        (
+            rf"\multicolumn{{{len(dataset.multiplicities) + 1}}}{{c}}"
+            rf"{{\texttt{{{_tex_escape(dataset.process_template)}}}}} \\"
+        ),
+        (
+            r"\textbf{metric} & "
+            + " & ".join(
+                rf"\textbf{{\texttt{{n={n_final}}}}}"
+                for n_final in dataset.multiplicities
+            )
+            + r" \\"
+        ),
+        r"\midrule",
+    ]
+    for row_index, (label, field) in enumerate(rows):
+        if row_index % 2 == 0:
+            lines.append(r"\rowcolor{refblue}")
+        values = [
+            _scalar_value(
+                index.get(
+                    dataset.dataset_id,
+                    dataset.dataset_id,
+                    n_final,
+                    Workload.CONTRACTED,
+                ),
+                field,
+            )
+            for n_final in dataset.multiplicities
+        ]
+        lines.append(label + " & " + " & ".join(values) + r" \\")
+    relative_values = [
+        _scalar_relative_difference(
+            index.get(
+                dataset.dataset_id,
+                dataset.dataset_id,
+                n_final,
+                Workload.CONTRACTED,
+            )
+        )
+        for n_final in dataset.multiplicities
+    ]
+    lines.extend(
+        [
+            r"\rowcolor{ReportOrange!8}",
+            "relative diff. vs hp & " + " & ".join(relative_values) + r" \\",
+            r"\bottomrule",
+            r"\end{tabular}",
+            r"\end{center}",
+            r"\endgroup",
+            (
+                r"\ReportTableNote{Wall time is the common runtime observable. "
+                r"Evaluator total is the independently measured accumulated "
+                r"warmed evaluator clock from its dedicated authenticated "
+                r"record; it is never copied from or derived from wall time. "
+                r"Unverified diagnostics retain absolute generation, wall, and "
+                r"evaluator clocks with a yellow marker; they are not successes. "
+                r"\textsc{not exposed} denotes a successful wall measurement, "
+                r"and older entries without dedicated evaluator-total evidence "
+                r"remain valid; it does not denote a missing result.}"
+            ),
+        ]
+    )
+    return "\n".join(lines) + "\n"
+
+
+def render_all_scalar_ladders(
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> dict[str, str]:
+    cache_source = caches if isinstance(caches, Mapping) else tuple(caches)
+    return {
+        dataset.table_name: render_scalar_ladder(dataset, cache_source)
+        for dataset in catalog.scalar_datasets
+    }
+
+
+def _renders_na(value: str) -> bool:
+    return r"\matrixna{" in value or r"\matrixnaratio{" in value or "{N/A}" in value
+
+
+def _measurements_by_cell_id(
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+) -> dict[str, Measurement]:
+    payloads = caches.values() if isinstance(caches, Mapping) else caches
+    measurements: dict[str, Measurement] = {}
+    for payload in payloads:
+        entries = payload.get("entries")
+        if not isinstance(entries, list):
+            raise ValueError("report cache has no entries list")
+        for entry in entries:
+            if not isinstance(entry, Mapping):
+                raise ValueError("report cache contains a non-object entry")
+            cell_id = entry.get("cell_id")
+            measurement = entry.get("measurement")
+            if not isinstance(cell_id, str) or not isinstance(measurement, Mapping):
+                raise ValueError("report cache entry is missing its measurement")
+            if cell_id in measurements:
+                raise ValueError(f"duplicate report cell {cell_id!r}")
+            measurements[cell_id] = measurement
+    return measurements
+
+
+def summarize_visible_completeness(
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    max_n_final: int = 9,
+    policy: CampaignPolicy = STRICT_POLICY,
+) -> VisibleCompleteness:
+    """Audit every logical table slot that represents a required measurement.
+
+    The check invokes the same field-level rendering helpers as the tables. It
+    therefore catches an ``ok`` cache record whose missing submetric would still
+    appear as ``N/A`` in TeX, as well as an applicable reset record. Structural
+    matrix positions and reference-only execution fields are counted separately
+    and are required to use their dedicated visible markers.
+    """
+
+    if max_n_final < 1:
+        raise ValueError("max_n_final must be positive")
+    cache_source = caches if isinstance(caches, Mapping) else tuple(caches)
+    measurements = _measurements_by_cell_id(cache_source)
+    declared_cells = tuple(
+        cell for cell in catalog.measurement_cells() if cell.n_final <= max_n_final
+    )
+    static_na_cells = tuple(
+        cell for cell in declared_cells if catalog.static_na_reason(cell) is not None
+    )
+    required_cells = tuple(
+        cell for cell in declared_cells if catalog.static_na_reason(cell) is None
+    )
+    required_by_id = {cell.cell_id: cell for cell in required_cells}
+    if len(required_by_id) != len(required_cells):
+        raise ValueError("report catalog contains duplicate required cell IDs")
+    cell_index = {
+        (
+            cell.dataset_id,
+            cell.process_key,
+            cell.n_final,
+            cell.workload,
+            cell.variant,
+        ): cell
+        for cell in catalog.measurement_cells()
+    }
+    rendered_cell_ids: set[str] = set()
+    rendered_static_na_cell_ids: set[str] = set()
+    na_slots: list[str] = []
+    contract_errors: list[str] = []
+    for cell in required_cells:
+        measurement = measurements.get(cell.cell_id, _NA)
+        status = measurement.get("status", ResultStatus.NOT_AVAILABLE.value)
+        policy_terminal = (
+            policy.allow_terminal_censors
+            and policy_status_label(measurement) is not None
+        )
+        if status != ResultStatus.OK.value and not policy_terminal:
+            contract_errors.append(
+                f"{cell.cell_id}: required measurement status is "
+                f"{status!r}, expected {ResultStatus.OK.value!r}"
+            )
+    for cell in static_na_cells:
+        measurement = measurements.get(cell.cell_id)
+        if measurement != _NA:
+            contract_errors.append(
+                f"{cell.cell_id}: catalog static N/A measurement differs "
+                "from the canonical reset record"
+            )
+
+    def inspect(
+        location: str,
+        fragments: Sequence[str],
+    ) -> None:
+        for index, fragment in enumerate(fragments):
+            if _renders_na(fragment):
+                na_slots.append(f"{location}[{index}]")
+
+    def record(
+        cell: CellSpec,
+        location: str,
+        fragments: Sequence[str],
+    ) -> None:
+        if cell.n_final > max_n_final:
+            return
+        rendered_cell_ids.add(cell.cell_id)
+        if catalog.static_na_reason(cell) is not None:
+            rendered_static_na_cell_ids.add(cell.cell_id)
+            if any(fragment != _static_na() for fragment in fragments):
+                contract_errors.append(
+                    f"{location} ({cell.cell_id}): catalog static N/A slot "
+                    "does not use the dedicated marker"
+                )
+            return
+        inspect(
+            f"{location} ({cell.cell_id})",
+            fragments,
+        )
+
+    def locate(
+        dataset_id: str,
+        process_key: str | None,
+        n_final: int,
+        workload: Workload,
+        variant: str | None = None,
+    ) -> CellSpec | None:
+        cell = cell_index.get((dataset_id, process_key, n_final, workload, variant))
+        if cell is None:
+            contract_errors.append(
+                f"renderer has no catalog cell for {dataset_id}/n{n_final}/"
+                f"{process_key}/{variant}/{workload.value}"
+            )
+        return cell
+
+    adapter = BaselineCandidateAdapter(cache_source, catalog=catalog)
+    structural_seen = 0
+    matrix_datasets = getattr(catalog, "matrix_datasets", ())
+    process_families = getattr(catalog, "process_families", ())
+    for dataset in matrix_datasets:
+        views_by_n: dict[int, list[JoinedMatrixCell]] = {}
+        for family in process_families:
+            for n_final in dataset.multiplicities:
+                if n_final > max_n_final:
+                    continue
+                view = adapter.matrix_cell(dataset, family, n_final)
+                views_by_n.setdefault(n_final, []).append(view)
+                if not view.applicable:
+                    structural_seen += 1
+                    marker = _matrix_scope_marker(
+                        family,
+                        n_final,
+                        dataset.candidate.accuracy,
+                    )
+                    if _renders_na(marker):
+                        contract_errors.append(
+                            f"{dataset.table_name}/n{n_final}/{family.key}: "
+                            "out-of-scope slot uses the missing-measurement marker"
+                        )
+                    continue
+                for joined in view.workloads:
+                    candidate = locate(
+                        dataset.dataset_id,
+                        family.key,
+                        n_final,
+                        joined.workload,
+                    )
+                    if candidate is None:
+                        continue
+                    baseline = catalog.baseline_cell(candidate)
+                    if baseline is None:
+                        contract_errors.append(
+                            f"{candidate.cell_id}: matrix baseline is missing"
+                        )
+                        continue
+                    baseline_static_na = catalog.static_na_reason(baseline) is not None
+                    candidate_static_na = (
+                        catalog.static_na_reason(candidate) is not None
+                    )
+                    record(
+                        baseline,
+                        (
+                            f"{dataset.table_name}/n{n_final}/{family.key}/"
+                            f"{joined.workload.value}/baseline"
+                        ),
+                        (
+                            (
+                                _static_na()
+                                if baseline_static_na
+                                else _best_mode_metric(
+                                    joined.baseline,
+                                    "generation_seconds",
+                                )
+                            ),
+                            (
+                                _static_na()
+                                if baseline_static_na
+                                else _best_mode_metric(
+                                    joined.baseline,
+                                    "wall_seconds_per_point",
+                                    microseconds=True,
+                                )
+                            ),
+                        ),
+                    )
+                    candidate_generation = _fixed_mode_generation_comparison_layout(
+                        joined,
+                        candidate_mode=dataset.candidate.execution_mode,
+                        baseline_mode=dataset.baseline.execution_mode,
+                        baseline_static_na=baseline_static_na,
+                        comparable=not (
+                            joined.workload is Workload.ALL_FLOW
+                            and dataset.candidate.execution_mode
+                            is ExecutionMode.RECURRENCE
+                            and dataset.baseline.execution_mode
+                            is ExecutionMode.AMPLICOL
+                        ),
+                    )
+                    record(
+                        candidate,
+                        (
+                            f"{dataset.table_name}/n{n_final}/{family.key}/"
+                            f"{joined.workload.value}/candidate"
+                        ),
+                        (
+                            (
+                                _static_na()
+                                if candidate_static_na
+                                else candidate_generation.inline
+                            ),
+                            (
+                                _static_na()
+                                if candidate_static_na
+                                else _fixed_mode_runtime_comparison_layout(
+                                    joined,
+                                    candidate_mode=(
+                                        dataset.candidate.execution_mode
+                                    ),
+                                    baseline_mode=(
+                                        dataset.baseline.execution_mode
+                                    ),
+                                    baseline_static_na=baseline_static_na,
+                                ).inline
+                            ),
+                        ),
+                    )
+        for n_final, views in views_by_n.items():
+            if not any(view.applicable for view in views):
+                continue
+            for label, fragment in (
+                (
+                    "generation-summary",
+                    _matrix_generation_summary(views, dataset, catalog=catalog),
+                ),
+                (
+                    "wall-summary",
+                    _matrix_wall_summary(
+                        views,
+                        dataset.candidate.accuracy,
+                        dataset=dataset,
+                        catalog=catalog,
+                    ),
+                ),
+            ):
+                if _renders_na(fragment):
+                    na_slots.append(f"{dataset.table_name}/n{n_final}/{label}")
+
+    for accuracy in Accuracy:
+        table_name = _BEST_MODE_TABLE_NAMES[accuracy]
+        multiplicities = matrix_multiplicities(accuracy)
+        views_by_n: dict[int, list[BestModeMatrixCell]] = {}
+        for family in process_families:
+            for n_final in multiplicities:
+                if n_final > max_n_final:
+                    continue
+                view = adapter.best_mode_cell(accuracy, family, n_final)
+                views_by_n.setdefault(n_final, []).append(view)
+                if not view.applicable:
+                    continue
+                for joined in view.workloads:
+                    baseline_static_na = _legacy_baseline_static_na(
+                        catalog=catalog,
+                        accuracy=accuracy,
+                        process_key=family.key,
+                        n_final=n_final,
+                        workload=joined.workload,
+                    )
+                    inspect(
+                        (
+                            f"{table_name}/n{n_final}/{family.key}/"
+                            f"{joined.workload.value}"
+                        ),
+                        (
+                            (
+                                _static_na()
+                                if baseline_static_na
+                                else _best_mode_metric(
+                                    joined.baseline,
+                                    "generation_seconds",
+                                )
+                            ),
+                            _best_mode_generation_comparison(
+                                joined,
+                                baseline_static_na=baseline_static_na,
+                                comparable=not (
+                                    accuracy is Accuracy.LC
+                                    and joined.workload is Workload.ALL_FLOW
+                                ),
+                            ),
+                            (
+                                _static_na()
+                                if baseline_static_na
+                                else _best_mode_metric(
+                                    joined.baseline,
+                                    "wall_seconds_per_point",
+                                    microseconds=True,
+                                )
+                            ),
+                            _best_mode_runtime_comparison(
+                                joined,
+                                baseline_static_na=baseline_static_na,
+                            ),
+                        ),
+                    )
+        for n_final, views in views_by_n.items():
+            if not any(view.applicable for view in views):
+                continue
+            inspect(
+                f"{table_name}/n{n_final}/best-mode-summaries",
+                (
+                    _best_mode_generation_summary(views, accuracy),
+                    _best_mode_wall_summary(views, accuracy),
+                ),
+            )
+
+    not_exposed_seen = 0
+    if getattr(catalog, "z_variants", ()):
+        for model in (ModelKey.BUILTIN_SM, ModelKey.UFO_SM):
+            if model not in getattr(catalog, "models", {}):
+                continue
+            for n_final in range(1, min(max_n_final, 9) + 1):
+                for variant in catalog.z_variants:
+                    for workload in (
+                        Workload.SELECTED_FLOW,
+                        Workload.ALL_FLOW,
+                    ):
+                        joined = adapter.z_workload(
+                            model=model,
+                            n_final=n_final,
+                            variant=variant,
+                            workload=workload,
+                        )
+                        reference = variant.execution_mode is ExecutionMode.AMPLICOL
+                        if reference:
+                            cell = locate(
+                                "reference_amplicol_lc",
+                                "dd_z_jets",
+                                n_final,
+                                workload,
+                            )
+                            if cell is None:
+                                continue
+                            fragments = (
+                                _z_value(
+                                    joined,
+                                    "generation_seconds",
+                                    reference=True,
+                                    comparable=workload is not Workload.ALL_FLOW,
+                                ),
+                                _z_value(
+                                    joined,
+                                    "wall_seconds_per_point",
+                                    reference=True,
+                                    microseconds=True,
+                                ),
+                            )
+                            not_exposed_seen += 1
+                            if _renders_na(_not_exposed()):
+                                contract_errors.append(
+                                    "reference execution slot uses the "
+                                    "missing-measurement marker"
+                                )
+                        else:
+                            cell = locate(
+                                z_dataset_id(model),
+                                "dd_z_jets",
+                                n_final,
+                                workload,
+                                variant.key,
+                            )
+                            if cell is None:
+                                continue
+                            static_na = catalog.static_na_reason(cell) is not None
+                            fragments = (
+                                _z_value(
+                                    joined,
+                                    "generation_seconds",
+                                    reference=False,
+                                    comparable=workload is not Workload.ALL_FLOW,
+                                    static_na=static_na,
+                                ),
+                                _z_value(
+                                    joined,
+                                    "wall_seconds_per_point",
+                                    reference=False,
+                                    microseconds=True,
+                                    static_na=static_na,
+                                ),
+                                _z_evaluator_total(
+                                    joined,
+                                    reference=False,
+                                    static_na=static_na,
+                                ),
+                            )
+                        record(
+                            cell,
+                            (
+                                f"result_z_{model.value}/n{n_final}/"
+                                f"{variant.key}/{workload.value}"
+                            ),
+                            fragments,
+                        )
+
+    for dataset in getattr(catalog, "scalar_datasets", ()):
+        for n_final in dataset.multiplicities:
+            if n_final > max_n_final:
+                continue
+            cell = locate(
+                dataset.dataset_id,
+                dataset.dataset_id,
+                n_final,
+                Workload.CONTRACTED,
+            )
+            if cell is None:
+                continue
+            measurement = measurements.get(cell.cell_id, _NA)
+            record(
+                cell,
+                f"{dataset.table_name}/n{n_final}",
+                (
+                    _scalar_value(measurement, "generation_seconds"),
+                    _scalar_value(measurement, "wall_seconds_per_point"),
+                    _scalar_value(
+                        measurement,
+                        "evaluator_total_seconds_per_point",
+                    ),
+                    _scalar_value(measurement, "matrix_element"),
+                    _scalar_relative_difference(measurement),
+                ),
+            )
+
+    if not (matrix_datasets or getattr(catalog, "scalar_datasets", ())):
+        # Small injected catalogs used by the final-audit unit boundary do not
+        # carry renderer metadata. Their cells still receive the core field-level
+        # visibility check, while the canonical catalog exercises every table.
+        for cell in required_cells:
+            measurement = measurements.get(cell.cell_id, _NA)
+            fragments = [
+                _metric(measurement, "generation_seconds"),
+                _metric(
+                    measurement,
+                    "wall_seconds_per_point",
+                    microseconds=True,
+                ),
+            ]
+            if cell.measurement.execution_mode is not ExecutionMode.AMPLICOL:
+                fragments.append(
+                    _metric(
+                        measurement,
+                        "execution_seconds_per_point",
+                        microseconds=True,
+                    )
+                )
+            record(cell, f"injected-catalog/{cell.cell_id}", fragments)
+        for cell in static_na_cells:
+            record(
+                cell,
+                f"injected-catalog/{cell.cell_id}",
+                (_static_na(), _static_na()),
+            )
+
+    accounting = report_display_accounting(
+        catalog=catalog,
+        max_n_final=max_n_final,
+    )
+    if structural_seen != (accounting.structurally_not_applicable_display_slot_count):
+        contract_errors.append(
+            "structural display-slot enumeration differs from the catalog: "
+            f"{structural_seen}/"
+            f"{accounting.structurally_not_applicable_display_slot_count}"
+        )
+    if not_exposed_seen != accounting.not_exposed_display_slot_count:
+        contract_errors.append(
+            "not-exposed display-slot enumeration differs from the catalog: "
+            f"{not_exposed_seen}/{accounting.not_exposed_display_slot_count}"
+        )
+    required_ids = set(required_by_id)
+    missing = tuple(sorted(required_ids - rendered_cell_ids))
+    static_na_ids = {cell.cell_id for cell in static_na_cells}
+    missing_static_na = tuple(sorted(static_na_ids - rendered_static_na_cell_ids))
+    if missing_static_na:
+        contract_errors.append(
+            "catalog static N/A cells are not rendered: " + ", ".join(missing_static_na)
+        )
+    return VisibleCompleteness(
+        maximum_n_final=max_n_final,
+        declared_measurement_cell_count=(accounting.declared_measurement_cell_count),
+        required_measurement_count=accounting.required_measurement_count,
+        rendered_required_measurement_count=len(rendered_cell_ids & required_ids),
+        structurally_not_applicable_display_slot_count=structural_seen,
+        not_exposed_display_slot_count=not_exposed_seen,
+        applicable_na_display_slots=tuple(sorted(set(na_slots))),
+        missing_rendered_cell_ids=missing,
+        contract_errors=tuple(sorted(set(contract_errors))),
+        catalog_static_na_cell_count=accounting.catalog_static_na_cell_count,
+        rendered_catalog_static_na_cell_count=len(rendered_static_na_cell_ids),
+    )
+
+
+def render_all_tables(
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    authenticated_source_lineage: tuple[str, str] | None = None,
+) -> dict[str, str]:
+    cache_source = caches if isinstance(caches, Mapping) else tuple(caches)
+    return {
+        SUMMARY_TABLE_NAME: render_validation_summary(
+            cache_source,
+            catalog=catalog,
+            authenticated_source_lineage=authenticated_source_lineage,
+        ),
+        **render_all_best_mode_tables(cache_source, catalog=catalog),
+        **render_all_matrix_tables(cache_source, catalog=catalog),
+        **render_all_z_ladders(cache_source, catalog=catalog),
+        **render_all_scalar_ladders(cache_source, catalog=catalog),
+    }
+
+
+__all__ = [
+    "BaselineCandidateAdapter",
+    "JoinedMatrixCell",
+    "JoinedWorkload",
+    "MeasurementIndex",
+    "VisibleCompleteness",
+    "render_all_best_mode_tables",
+    "render_all_matrix_tables",
+    "render_all_scalar_ladders",
+    "render_all_tables",
+    "render_all_z_ladders",
+    "render_best_mode_table",
+    "render_matrix_comparison_table",
+    "render_matrix_table",
+    "render_scalar_ladder",
+    "render_validation_summary",
+    "render_z_ladder",
+    "summarize_visible_completeness",
+]
diff --git a/pyamplicol/tools/performance_report/report_policy.py b/pyamplicol/tools/performance_report/report_policy.py
new file mode 100644
index 0000000000..6bd03296b4
--- /dev/null
+++ b/pyamplicol/tools/performance_report/report_policy.py
@@ -0,0 +1,289 @@
+# SPDX-License-Identifier: 0BSD
+"""Strict publication policies not duplicated by the exhaustive final auditor."""
+
+from __future__ import annotations
+
+import math
+import re
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+from .models import ResultStatus
+from .runner import DEFAULT_TARGET_RUNTIME_SECONDS
+from .source_identity import SOURCE_IDENTITY_SCHEMA
+from .timing import unavailable_execution_timing_record
+
+Measurement = Mapping[str, object]
+_FULL_SHA_RE = re.compile(r"[0-9a-f]{40}")
+_MINIMUM_TARGET_FRACTION = 0.95
+_MINIMUM_TIMED_SAMPLES = 5
+
+
+@dataclass(frozen=True, slots=True)
+class ReportPolicyIssue:
+    field: str
+    detail: str
+
+
+def _finite_number(value: object) -> float | None:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    result = float(value)
+    return result if math.isfinite(result) else None
+
+
+def _runtime_evidence(measurement: Measurement) -> Mapping[str, object] | None:
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        return None
+    runtime = provenance.get("runtime_profile")
+    if not isinstance(runtime, Mapping):
+        return None
+    legacy = runtime.get("measurement")
+    return legacy if isinstance(legacy, Mapping) else runtime
+
+
+def timing_policy_issues(
+    measurement: Measurement,
+    *,
+    target_runtime_seconds: float = DEFAULT_TARGET_RUNTIME_SECONDS,
+) -> tuple[ReportPolicyIssue, ...]:
+    """Return timing defects for one otherwise successful report measurement."""
+
+    if measurement.get("status") != ResultStatus.OK.value:
+        return ()
+    issues: list[ReportPolicyIssue] = []
+    for field in ("generation_seconds", "wall_seconds_per_point"):
+        value = _finite_number(measurement.get(field))
+        if value is None or value <= 0.0:
+            issues.append(
+                ReportPolicyIssue(field, "must be finite and strictly positive")
+            )
+
+    execution = _finite_number(measurement.get("execution_seconds_per_point"))
+    if execution is None:
+        if unavailable_execution_timing_record(
+            measurement,
+            "execution_seconds_per_point",
+        ) is None:
+            issues.append(
+                ReportPolicyIssue(
+                    "execution_seconds_per_point",
+                    (
+                        "must be measured or carry authenticated Arena evidence "
+                        "that the execution attribution is not exposed"
+                    ),
+                )
+            )
+    elif execution < 0.0:
+        issues.append(
+            ReportPolicyIssue(
+                "execution_seconds_per_point",
+                "must not be negative",
+            )
+        )
+    elif execution == 0.0:
+        issues.append(
+            ReportPolicyIssue(
+                "execution_seconds_per_point",
+                "zero is not a timing measurement; an unexposed attribution "
+                "must be null with authenticated Arena evidence",
+            )
+        )
+
+    sample_count = measurement.get("sample_count")
+    if (
+        isinstance(sample_count, bool)
+        or not isinstance(sample_count, int)
+        or sample_count < _MINIMUM_TIMED_SAMPLES
+    ):
+        issues.append(
+            ReportPolicyIssue(
+                "sample_count",
+                f"at least {_MINIMUM_TIMED_SAMPLES} timed samples are required",
+            )
+        )
+    for field in (
+        "standard_error_seconds_per_point",
+        "relative_standard_error",
+    ):
+        value = _finite_number(measurement.get(field))
+        if value is None or value <= 0.0:
+            issues.append(
+                ReportPolicyIssue(
+                    field,
+                    "must be finite, measured, and strictly positive",
+                )
+            )
+
+    evidence = _runtime_evidence(measurement)
+    if evidence is None:
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.runtime_profile",
+                "measured-duration evidence is required",
+            )
+        )
+        return tuple(issues)
+    requested = _finite_number(evidence.get("target_runtime_seconds"))
+    achieved = _finite_number(evidence.get("achieved_runtime_seconds"))
+    if requested is None or not math.isclose(
+        requested,
+        target_runtime_seconds,
+        rel_tol=0.0,
+        abs_tol=1.0e-12,
+    ):
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.runtime_profile.target_runtime_seconds",
+                f"must equal {target_runtime_seconds:g} seconds",
+            )
+        )
+    if (
+        achieved is None
+        or achieved < _MINIMUM_TARGET_FRACTION * target_runtime_seconds
+    ):
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.runtime_profile.achieved_runtime_seconds",
+                (
+                    "must record at least "
+                    f"{_MINIMUM_TARGET_FRACTION * target_runtime_seconds:g} "
+                    "seconds of timed evaluation"
+                ),
+            )
+        )
+    if evidence.get("target_runtime_achieved") is not True:
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.runtime_profile.target_runtime_achieved",
+                "must be true",
+            )
+        )
+    if evidence.get("interrupted") is True:
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.runtime_profile.interrupted",
+                "partial timing runs are not publishable",
+            )
+        )
+    completed = evidence.get("completed_sample_count")
+    planned = evidence.get("planned_sample_count")
+    if (completed is not None or planned is not None) and (
+            isinstance(completed, bool)
+            or not isinstance(completed, int)
+            or isinstance(planned, bool)
+            or not isinstance(planned, int)
+            or completed < _MINIMUM_TIMED_SAMPLES
+            or completed != planned
+    ):
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.runtime_profile.completed_sample_count",
+                "all planned timing blocks must complete",
+            )
+        )
+    chunk_count = evidence.get("chunk_count")
+    if chunk_count is not None and (
+        isinstance(chunk_count, bool)
+        or not isinstance(chunk_count, int)
+        or chunk_count < _MINIMUM_TIMED_SAMPLES
+    ):
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.runtime_profile.chunk_count",
+                f"at least {_MINIMUM_TIMED_SAMPLES} timed chunks are required",
+            )
+        )
+    if completed is None and chunk_count is None:
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.runtime_profile.sample_count",
+                "timed sample or chunk completion evidence is required",
+            )
+        )
+    return tuple(issues)
+
+
+def source_policy_issues(
+    measurement: Measurement,
+) -> tuple[ReportPolicyIssue, ...]:
+    """Require the exact clean measurement commit and tree in provenance."""
+
+    if measurement.get("status") != ResultStatus.OK.value:
+        return ()
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        return (
+            ReportPolicyIssue("provenance", "source identity is required"),
+        )
+    issues: list[ReportPolicyIssue] = []
+    if provenance.get("report_source_identity_schema") != SOURCE_IDENTITY_SCHEMA:
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.report_source_identity_schema",
+                f"must equal {SOURCE_IDENTITY_SCHEMA}",
+            )
+        )
+    for field in (
+        "report_source_revision",
+        "report_source_tree",
+        "report_measured_source_revision",
+        "report_measured_source_tree",
+    ):
+        value = provenance.get(field)
+        if not isinstance(value, str) or _FULL_SHA_RE.fullmatch(value) is None:
+            issues.append(
+                ReportPolicyIssue(
+                    f"provenance.{field}",
+                    "must be a full lowercase Git object ID",
+                )
+            )
+    if provenance.get("report_source_revision") != provenance.get(
+        "report_measured_source_revision"
+    ):
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.report_measured_source_revision",
+                "must match the measured source revision",
+            )
+        )
+    if provenance.get("report_source_tree") != provenance.get(
+        "report_measured_source_tree"
+    ):
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.report_measured_source_tree",
+                "must match the measured source tree",
+            )
+        )
+    if provenance.get("report_source_clean") is not True:
+        issues.append(
+            ReportPolicyIssue(
+                "provenance.report_source_clean",
+                "measurement source must be clean",
+            )
+        )
+    return tuple(issues)
+
+
+def publication_measurement_policy_issues(
+    measurement: Measurement,
+    *,
+    target_runtime_seconds: float = DEFAULT_TARGET_RUNTIME_SECONDS,
+) -> tuple[ReportPolicyIssue, ...]:
+    return (
+        *timing_policy_issues(
+            measurement,
+            target_runtime_seconds=target_runtime_seconds,
+        ),
+        *source_policy_issues(measurement),
+    )
+
+
+__all__ = [
+    "ReportPolicyIssue",
+    "publication_measurement_policy_issues",
+    "source_policy_issues",
+    "timing_policy_issues",
+]
diff --git a/pyamplicol/tools/performance_report/resources.py b/pyamplicol/tools/performance_report/resources.py
new file mode 100644
index 0000000000..dec488b448
--- /dev/null
+++ b/pyamplicol/tools/performance_report/resources.py
@@ -0,0 +1,2068 @@
+# SPDX-License-Identifier: 0BSD
+"""Portable process-tree resource monitoring for report workers."""
+
+from __future__ import annotations
+
+import ctypes
+import math
+import os
+import platform
+import shutil
+import signal
+import subprocess
+import threading
+import time
+from collections import defaultdict
+from collections.abc import Callable, Collection, Mapping, Sequence
+from contextlib import suppress
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from functools import cache
+from pathlib import Path
+from typing import Literal, Protocol
+
+try:
+    from tools.ci.memory_watchdog import (
+        DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON,
+        DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON,
+        MEMORY_PROBE_REASON,
+        RSS_LIMIT_REASON,
+        DarwinPhysicalFootprintProbe,
+    )
+    from tools.ci.memory_watchdog import (
+        ProbeError as WatchdogProbeError,
+    )
+    from tools.ci.memory_watchdog import (
+        ProcessInfo as WatchdogProcessInfo,
+    )
+    from tools.ci.memory_watchdog import (
+        _darwin_libproc_snapshot as _watchdog_darwin_libproc_snapshot,
+    )
+except ModuleNotFoundError as error:
+    if error.name not in {"tools", "tools.ci", "tools.ci.memory_watchdog"}:
+        raise
+    from ._memory_watchdog import (
+        DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON,
+        DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON,
+        MEMORY_PROBE_REASON,
+        RSS_LIMIT_REASON,
+        DarwinPhysicalFootprintProbe,
+    )
+    from ._memory_watchdog import (
+        ProbeError as WatchdogProbeError,
+    )
+    from ._memory_watchdog import (
+        ProcessInfo as WatchdogProcessInfo,
+    )
+    from ._memory_watchdog import (
+        _darwin_libproc_snapshot as _watchdog_darwin_libproc_snapshot,
+    )
+
+from .phase_state import (
+    WORKER_PHASE_STATE_ABI,
+    WorkerPhaseChannel,
+    WorkerPhaseState,
+    WorkerPhaseStateError,
+    read_worker_phase_state,
+)
+
+DEFAULT_SAMPLE_INTERVAL_SECONDS = 1.0
+DEFAULT_TERMINATION_GRACE_SECONDS = 5.0
+DEFAULT_PHASE_STATE_STARTUP_GRACE_SECONDS = 30.0
+GENERATION_PHASE_EVIDENCE_ABI = "pyamplicol-report-generation-phase-evidence-v1"
+PROCESS_TREE_MEMORY_METRIC_ABI = "pyamplicol-process-tree-memory-metric-v1"
+MAX_CONSECUTIVE_MEMORY_PROBE_FAILURES = 3
+DEFAULT_SUPERVISOR_STDERR_LIMIT_BYTES = 64 * 1024
+DEFAULT_ATTEMPT_OUTPUT_LIMIT_BYTES = 64 * 1024 * 1024
+DEFAULT_MINIMUM_FREE_DISK_BYTES = 5 * 1024 * 1024 * 1024
+DEFAULT_STORAGE_SAFETY_INTERVAL_SECONDS = 0.05
+_WORKER_IMPORT_ENVIRONMENT = frozenset(
+    {
+        "VIRTUAL_ENV",
+        "_OLD_VIRTUAL_PATH",
+        "__PYVENV_LAUNCHER__",
+    }
+)
+_EXPLICIT_PYAMPLICOL_WORKER_CONTROLS = frozenset(
+    {
+        "PYAMPLICOL_NATIVE_COMPILER_GATE_DIR",
+        "PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT",
+    }
+)
+
+
+class ResourceProbeError(RuntimeError):
+    """Raised when a host process snapshot cannot be collected."""
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessRecord:
+    """Resource data for one process."""
+
+    pid: int
+    ppid: int
+    rss_bytes: int
+    cpu_seconds: float | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessTreeSample:
+    """Aggregate resource data for a root process and its descendants."""
+
+    rss_bytes: int
+    child_count: int
+    cpu_seconds: float | None
+    member_pids: tuple[int, ...]
+    physical_footprint_bytes: int | None = None
+    guard_bytes: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ResourceUsage:
+    """Latest and peak resource data exposed to report scheduling."""
+
+    available: bool
+    current_rss_bytes: int | None
+    peak_rss_bytes: int | None
+    child_count: int | None
+    cpu_seconds: float | None
+    wall_seconds: float
+    error: str | None = None
+    current_physical_footprint_bytes: int | None = None
+    peak_physical_footprint_bytes: int | None = None
+    current_guard_bytes: int | None = None
+    peak_guard_bytes: int | None = None
+    memory_metric_abi: str | None = None
+    memory_probe_reason: str | None = None
+
+
+TerminationReason = Literal[
+    "completed",
+    "worker_exit",
+    "cancelled",
+    "worker_timeout",
+    "generation_timeout",
+    "profiling_timeout",
+    "validation_timeout",
+    "memory_limit",
+    "memory_probe_error",
+    "output_limit",
+    "output_probe_error",
+    "disk_space_limit",
+    "disk_probe_error",
+    "phase_state_error",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class WorkerObservation:
+    """One non-authoritative live sample for dashboards and logs."""
+
+    pid: int
+    usage: ResourceUsage
+    phase: str | None
+    phase_sequence: int | None
+    member_pids: tuple[int, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class GenerationPhaseEvidence:
+    """Supervisor-authenticated evidence for the worker generation interval."""
+
+    configured_timeout_seconds: float
+    supervisor_reason: TerminationReason
+    authenticated: bool
+    run_id: str
+    worker_pid: int
+    final_sequence: int | None
+    final_phase: str | None
+    generation_started_monotonic_ns: int | None
+    generation_finished_monotonic_ns: int | None
+    generation_elapsed_seconds: float | None
+    final_state_sha256: str | None
+    error: str | None = None
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "abi": GENERATION_PHASE_EVIDENCE_ABI,
+            "phase_state_abi": WORKER_PHASE_STATE_ABI,
+            "configured_timeout_seconds": self.configured_timeout_seconds,
+            "supervisor_reason": self.supervisor_reason,
+            "authenticated": self.authenticated,
+            "run_id": self.run_id,
+            "worker_pid": self.worker_pid,
+            "final_sequence": self.final_sequence,
+            "final_phase": self.final_phase,
+            "generation_started_monotonic_ns": (self.generation_started_monotonic_ns),
+            "generation_finished_monotonic_ns": (self.generation_finished_monotonic_ns),
+            "generation_elapsed_seconds": self.generation_elapsed_seconds,
+            "final_state_sha256": self.final_state_sha256,
+            "error": self.error,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class SupervisedResult:
+    """Result of one worker process supervised under optional limits."""
+
+    returncode: int
+    reason: TerminationReason
+    usage: ResourceUsage
+    generation_phase: GenerationPhaseEvidence | None = None
+    memory_limit_bytes: int | None = None
+    memory_limit_reason: str | None = None
+    output_limit_path: str | None = None
+    output_limit_bytes: int | None = None
+    observed_output_bytes: int | None = None
+    minimum_free_disk_bytes: int | None = None
+    observed_free_disk_bytes: int | None = None
+    pid: int | None = None
+    member_pids: tuple[int, ...] = ()
+    signal_number: int | None = None
+    signal_name: str | None = None
+    supervisor_stderr: str | None = None
+    supervisor_stderr_truncated: bool = False
+    supervisor_stderr_limit_bytes: int | None = None
+    phase_state_error: str | None = None
+    started_at_utc: str | None = None
+    finished_at_utc: str | None = None
+    teardown_escalated: bool = False
+    teardown_seconds: float = 0.0
+
+
+class _BoundedByteTail:
+    """Drain a pipe without allowing diagnostic capture to grow unbounded."""
+
+    def __init__(self, limit_bytes: int) -> None:
+        if limit_bytes <= 0:
+            raise ValueError("stderr capture limit must be positive")
+        self._limit_bytes = limit_bytes
+        self._tail = bytearray()
+        self._total_bytes = 0
+        self._lock = threading.Lock()
+
+    def drain(self, stream: object) -> None:
+        read = getattr(stream, "read", None)
+        if not callable(read):
+            return
+        while True:
+            try:
+                chunk = read(64 * 1024)
+            except (OSError, ValueError):
+                return
+            if not chunk:
+                return
+            if isinstance(chunk, str):
+                chunk = chunk.encode("utf-8", errors="replace")
+            with self._lock:
+                self._total_bytes += len(chunk)
+                self._tail.extend(chunk)
+                if len(self._tail) > self._limit_bytes:
+                    del self._tail[: len(self._tail) - self._limit_bytes]
+
+    def decoded(self) -> tuple[str | None, bool]:
+        with self._lock:
+            if not self._tail and self._total_bytes == 0:
+                return None, False
+            return (
+                bytes(self._tail).decode("utf-8", errors="replace"),
+                self._total_bytes > self._limit_bytes,
+            )
+
+
+class CompletedProcessLike(Protocol):
+    returncode: int
+    stdout: str
+    stderr: str
+
+
+class WorkerProcess(Protocol):
+    pid: int
+    returncode: int | None
+
+    def poll(self) -> int | None: ...
+
+    def wait(self, timeout: float | None = None) -> int: ...
+
+
+Snapshotter = Callable[[], Mapping[int, ProcessRecord]]
+DarwinSnapshotter = Callable[[], Mapping[int, WatchdogProcessInfo]]
+PhysicalFootprintProbe = Callable[[Collection[int]], Mapping[int, int]]
+PsRunner = Callable[[Sequence[str]], CompletedProcessLike]
+PopenFactory = Callable[..., WorkerProcess]
+Clock = Callable[[], float]
+Sleeper = Callable[[float], None]
+TreeSignaler = Callable[[int | None, Collection[int], int], None]
+ObservationCallback = Callable[[WorkerObservation], None]
+CancellationCheck = Callable[[], bool]
+DiskFreeProbe = Callable[[Path], int]
+
+
+def _disk_free_bytes(path: Path) -> int:
+    return int(shutil.disk_usage(path).free)
+
+
+@dataclass(frozen=True, slots=True)
+class _ProcessIdentity:
+    """Authenticated process birth identity plus its current signal group."""
+
+    birth_token: int | tuple[int, int]
+    process_group: int
+
+
+ProcessIdentityProbe = Callable[[int], _ProcessIdentity | None]
+
+
+def _parse_proc_stat(text: str, *, clock_ticks_per_second: int) -> tuple[int, float]:
+    """Return ``(ppid, cpu_seconds)`` from one Linux ``/proc/PID/stat`` row."""
+
+    if clock_ticks_per_second <= 0:
+        raise ValueError("clock_ticks_per_second must be positive")
+    closing_parenthesis = text.rfind(")")
+    if closing_parenthesis < 0:
+        raise ValueError("missing process-name terminator")
+    fields = text[closing_parenthesis + 1 :].split()
+    # fields starts at the kernel's field 3 (state).
+    if len(fields) < 13:
+        raise ValueError("incomplete /proc stat record")
+    ppid = int(fields[1])
+    cpu_ticks = int(fields[11]) + int(fields[12])
+    if min(ppid, cpu_ticks) < 0:
+        raise ValueError("negative /proc process value")
+    return ppid, cpu_ticks / clock_ticks_per_second
+
+
+def _parse_proc_status_rss(text: str) -> int:
+    """Return RSS bytes from one Linux ``/proc/PID/status`` payload."""
+
+    for line in text.splitlines():
+        if not line.startswith("VmRSS:"):
+            continue
+        fields = line.split()
+        if len(fields) != 3 or fields[2].lower() != "kb":
+            raise ValueError(f"invalid VmRSS record: {line!r}")
+        rss_kib = int(fields[1])
+        if rss_kib < 0:
+            raise ValueError("negative VmRSS value")
+        return rss_kib * 1024
+    return 0
+
+
+def _parse_ps_output(text: str) -> dict[int, ProcessRecord]:
+    """Parse ``ps -axo pid=,ppid=,rss=`` output."""
+
+    records: dict[int, ProcessRecord] = {}
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        if not line.strip():
+            continue
+        fields = line.split()
+        if len(fields) != 3:
+            raise ValueError(f"invalid ps row {line_number}: {line!r}")
+        pid, ppid, rss_kib = map(int, fields)
+        if min(pid, ppid, rss_kib) < 0:
+            raise ValueError(f"negative ps value on row {line_number}")
+        records[pid] = ProcessRecord(
+            pid=pid,
+            ppid=ppid,
+            rss_bytes=rss_kib * 1024,
+        )
+    return records
+
+
+def _parse_ps_cpu_time(value: str) -> float:
+    """Parse BSD ``ps time=`` as cumulative CPU seconds."""
+
+    raw = value.strip()
+    if not raw:
+        raise ValueError("empty ps CPU time")
+    days = 0
+    if "-" in raw:
+        raw_days, raw = raw.split("-", 1)
+        days = int(raw_days)
+    fields = raw.split(":")
+    if len(fields) == 2:
+        hours = 0
+        minutes = int(fields[0])
+        seconds = float(fields[1])
+    elif len(fields) == 3:
+        hours = int(fields[0])
+        minutes = int(fields[1])
+        seconds = float(fields[2])
+    else:
+        raise ValueError(f"invalid ps CPU time: {value!r}")
+    if (
+        min(days, hours, minutes) < 0
+        or not math.isfinite(seconds)
+        or seconds < 0.0
+        or seconds >= 60.0
+        or (len(fields) == 3 and minutes >= 60)
+    ):
+        raise ValueError(f"invalid ps CPU time: {value!r}")
+    return days * 86_400.0 + hours * 3_600.0 + minutes * 60.0 + seconds
+
+
+def _parse_darwin_ps_output(text: str) -> dict[int, ProcessRecord]:
+    """Parse Darwin process rows including truthful cumulative CPU time."""
+
+    records: dict[int, ProcessRecord] = {}
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        if not line.strip():
+            continue
+        fields = line.split()
+        if len(fields) != 4:
+            raise ValueError(f"invalid Darwin ps row {line_number}: {line!r}")
+        pid, ppid, rss_kib = map(int, fields[:3])
+        if min(pid, ppid, rss_kib) < 0:
+            raise ValueError(f"negative Darwin ps value on row {line_number}")
+        records[pid] = ProcessRecord(
+            pid=pid,
+            ppid=ppid,
+            rss_bytes=rss_kib * 1024,
+            cpu_seconds=_parse_ps_cpu_time(fields[3]),
+        )
+    return records
+
+
+def _linux_proc_snapshot(
+    proc_root: Path = Path("/proc"),
+    *,
+    clock_ticks_per_second: int | None = None,
+) -> dict[int, ProcessRecord]:
+    """Collect a Linux process snapshot directly from procfs."""
+
+    if clock_ticks_per_second is None:
+        clock_ticks_per_second = int(os.sysconf("SC_CLK_TCK"))
+    try:
+        entries = tuple(proc_root.iterdir())
+    except OSError as error:
+        raise ResourceProbeError(f"cannot enumerate {proc_root}: {error}") from error
+
+    records: dict[int, ProcessRecord] = {}
+    for entry in entries:
+        if not entry.name.isdecimal():
+            continue
+        try:
+            stat = (entry / "stat").read_text(encoding="utf-8", errors="replace")
+            status = (entry / "status").read_text(
+                encoding="utf-8",
+                errors="replace",
+            )
+            ppid, cpu_seconds = _parse_proc_stat(
+                stat,
+                clock_ticks_per_second=clock_ticks_per_second,
+            )
+            pid = int(entry.name)
+            records[pid] = ProcessRecord(
+                pid=pid,
+                ppid=ppid,
+                rss_bytes=_parse_proc_status_rss(status),
+                cpu_seconds=cpu_seconds,
+            )
+        except (OSError, ValueError):
+            # A process can disappear or become inaccessible during the scan.
+            continue
+    if not records:
+        raise ResourceProbeError(f"{proc_root} yielded no readable processes")
+    return records
+
+
+def _default_ps_runner(command: Sequence[str]) -> CompletedProcessLike:
+    environment = os.environ.copy()
+    environment["LC_ALL"] = "C"
+    try:
+        return subprocess.run(
+            tuple(command),
+            check=False,
+            capture_output=True,
+            text=True,
+            env=environment,
+            timeout=10,
+        )
+    except (OSError, subprocess.SubprocessError) as error:
+        raise ResourceProbeError(f"cannot execute ps: {error}") from error
+
+
+def _ps_snapshot(*, runner: PsRunner = _default_ps_runner) -> dict[int, ProcessRecord]:
+    """Collect a portable process snapshot through ``ps``."""
+
+    completed = runner(("ps", "-axo", "pid=,ppid=,rss="))
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or f"exit code {completed.returncode}"
+        raise ResourceProbeError(f"ps process probe failed: {detail}")
+    try:
+        records = _parse_ps_output(completed.stdout)
+    except ValueError as error:
+        raise ResourceProbeError(str(error)) from error
+    if not records:
+        raise ResourceProbeError("ps process probe yielded no records")
+    return records
+
+
+def _darwin_ps_snapshot(
+    *,
+    runner: PsRunner = _default_ps_runner,
+) -> dict[int, ProcessRecord]:
+    completed = runner(("ps", "-axo", "pid=,ppid=,rss=,time="))
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or f"exit code {completed.returncode}"
+        raise ResourceProbeError(f"Darwin ps process probe failed: {detail}")
+    try:
+        records = _parse_darwin_ps_output(completed.stdout)
+    except ValueError as error:
+        raise ResourceProbeError(str(error)) from error
+    if not records:
+        raise ResourceProbeError("Darwin ps process probe yielded no records")
+    return records
+
+
+def _darwin_native_snapshot(
+    *,
+    snapshotter: DarwinSnapshotter = _watchdog_darwin_libproc_snapshot,
+) -> dict[int, ProcessRecord]:
+    """Collect a Darwin process snapshot through ``libproc`` only."""
+
+    try:
+        native_records = snapshotter()
+    except WatchdogProbeError as error:
+        raise ResourceProbeError(str(error)) from error
+    records = {
+        pid: ProcessRecord(
+            pid=record.pid,
+            ppid=record.ppid,
+            rss_bytes=record.rss_bytes,
+            cpu_seconds=record.cpu_seconds,
+        )
+        for pid, record in native_records.items()
+    }
+    if not records:
+        raise ResourceProbeError("Darwin libproc process probe yielded no records")
+    return records
+
+
+def process_snapshot(
+    system: str | None = None,
+    *,
+    proc_root: Path = Path("/proc"),
+    ps_runner: PsRunner = _default_ps_runner,
+    darwin_snapshotter: DarwinSnapshotter = _watchdog_darwin_libproc_snapshot,
+) -> dict[int, ProcessRecord]:
+    """Collect one process snapshot on Linux or macOS."""
+
+    host = system or platform.system()
+    if host == "Linux":
+        try:
+            return _linux_proc_snapshot(proc_root)
+        except ResourceProbeError:
+            return _ps_snapshot(runner=ps_runner)
+    if host == "Darwin":
+        return _darwin_native_snapshot(snapshotter=darwin_snapshotter)
+    raise ResourceProbeError(f"unsupported host for resource monitoring: {host!r}")
+
+
+class ProcessTreeSampler:
+    """Aggregate a root and recursively discovered descendants."""
+
+    def __init__(self, root_pid: int) -> None:
+        if root_pid <= 0:
+            raise ValueError("root_pid must be positive")
+        self.root_pid = root_pid
+        self._known_pids = {root_pid}
+
+    def sample(
+        self,
+        records: Mapping[int, ProcessRecord],
+        physical_footprint_probe: PhysicalFootprintProbe | None = None,
+    ) -> ProcessTreeSample:
+        children: dict[int, list[int]] = defaultdict(list)
+        for record in records.values():
+            children[record.ppid].append(record.pid)
+
+        selected = {pid for pid in self._known_pids if pid in records}
+        if self.root_pid in records:
+            selected.add(self.root_pid)
+        pending = list(selected)
+        while pending:
+            parent = pending.pop()
+            for child in children.get(parent, ()):
+                if child not in selected:
+                    selected.add(child)
+                    pending.append(child)
+
+        self._known_pids = selected
+        members = tuple(sorted(selected))
+        cpu_values = [
+            records[pid].cpu_seconds
+            for pid in members
+            if records[pid].cpu_seconds is not None
+        ]
+        rss_bytes = sum(records[pid].rss_bytes for pid in members)
+        physical_footprint_bytes: int | None = None
+        if physical_footprint_probe is not None:
+            try:
+                footprints = physical_footprint_probe(members)
+            except WatchdogProbeError as error:
+                raise ResourceProbeError(str(error)) from error
+            physical_footprint_bytes = sum(
+                footprints.get(pid, records[pid].rss_bytes) for pid in members
+            )
+        return ProcessTreeSample(
+            rss_bytes=rss_bytes,
+            child_count=max(len(members) - (self.root_pid in selected), 0),
+            cpu_seconds=(
+                sum(cpu_values) if members and len(cpu_values) == len(members) else None
+            ),
+            member_pids=members,
+            physical_footprint_bytes=physical_footprint_bytes,
+            guard_bytes=max(
+                rss_bytes,
+                physical_footprint_bytes
+                if physical_footprint_bytes is not None
+                else rss_bytes,
+            ),
+        )
+
+
+class ResourceMonitor:
+    """Sample current and peak resource usage, optionally in a daemon thread."""
+
+    def __init__(
+        self,
+        root_pid: int,
+        *,
+        interval_seconds: float = DEFAULT_SAMPLE_INTERVAL_SECONDS,
+        snapshotter: Snapshotter = process_snapshot,
+        physical_footprint_probe: PhysicalFootprintProbe | None = None,
+        clock: Clock = time.monotonic,
+    ) -> None:
+        if interval_seconds <= 0:
+            raise ValueError("interval_seconds must be positive")
+        self._sampler = ProcessTreeSampler(root_pid)
+        self._interval_seconds = float(interval_seconds)
+        self._snapshotter = snapshotter
+        self._physical_footprint_probe = physical_footprint_probe
+        self._clock = clock
+        self._started_at = clock()
+        self._usage = ResourceUsage(
+            available=False,
+            current_rss_bytes=None,
+            peak_rss_bytes=None,
+            child_count=None,
+            cpu_seconds=None,
+            wall_seconds=0.0,
+            current_guard_bytes=None,
+            peak_guard_bytes=None,
+            memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+        )
+        self._last_members: tuple[int, ...] = ()
+        self._lock = threading.Lock()
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    @property
+    def usage(self) -> ResourceUsage:
+        with self._lock:
+            return self._usage
+
+    @property
+    def member_pids(self) -> tuple[int, ...]:
+        with self._lock:
+            return self._last_members
+
+    def sample_once(self) -> ResourceUsage:
+        """Take one sample and record unavailable host metrics."""
+
+        wall_seconds = max(self._clock() - self._started_at, 0.0)
+        try:
+            records = self._snapshotter()
+        except (
+            OSError,
+            ResourceProbeError,
+            subprocess.SubprocessError,
+            ValueError,
+        ) as error:
+            return self._record_probe_failure(
+                wall_seconds,
+                error,
+                MEMORY_PROBE_REASON,
+            )
+        try:
+            sample = self._sampler.sample(
+                records,
+                physical_footprint_probe=self._physical_footprint_probe,
+            )
+        except (
+            OSError,
+            ResourceProbeError,
+            subprocess.SubprocessError,
+            ValueError,
+        ) as error:
+            return self._record_probe_failure(
+                wall_seconds,
+                error,
+                (
+                    DARWIN_PHYSICAL_FOOTPRINT_PROBE_REASON
+                    if self._physical_footprint_probe is not None
+                    else MEMORY_PROBE_REASON
+                ),
+            )
+
+        with self._lock:
+            peak_rss = max(self._usage.peak_rss_bytes or 0, sample.rss_bytes)
+            peak_physical_footprint = self._usage.peak_physical_footprint_bytes
+            if sample.physical_footprint_bytes is not None:
+                peak_physical_footprint = max(
+                    peak_physical_footprint or 0,
+                    sample.physical_footprint_bytes,
+                )
+            assert sample.guard_bytes is not None
+            peak_guard = max(
+                self._usage.peak_guard_bytes or 0,
+                sample.guard_bytes,
+            )
+            self._last_members = sample.member_pids
+            self._usage = ResourceUsage(
+                available=True,
+                current_rss_bytes=sample.rss_bytes,
+                peak_rss_bytes=peak_rss,
+                child_count=sample.child_count,
+                cpu_seconds=sample.cpu_seconds,
+                wall_seconds=wall_seconds,
+                current_physical_footprint_bytes=(sample.physical_footprint_bytes),
+                peak_physical_footprint_bytes=peak_physical_footprint,
+                current_guard_bytes=sample.guard_bytes,
+                peak_guard_bytes=peak_guard,
+                memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+            )
+            return self._usage
+
+    def _record_probe_failure(
+        self,
+        wall_seconds: float,
+        error: BaseException,
+        reason: str,
+    ) -> ResourceUsage:
+        with self._lock:
+            self._usage = ResourceUsage(
+                available=False,
+                current_rss_bytes=None,
+                peak_rss_bytes=self._usage.peak_rss_bytes,
+                child_count=None,
+                cpu_seconds=self._usage.cpu_seconds,
+                wall_seconds=wall_seconds,
+                error=str(error),
+                current_physical_footprint_bytes=None,
+                peak_physical_footprint_bytes=(
+                    self._usage.peak_physical_footprint_bytes
+                ),
+                current_guard_bytes=None,
+                peak_guard_bytes=self._usage.peak_guard_bytes,
+                memory_metric_abi=PROCESS_TREE_MEMORY_METRIC_ABI,
+                memory_probe_reason=reason,
+            )
+            return self._usage
+
+    def start(self) -> None:
+        if self._thread is not None:
+            return
+        self.sample_once()
+        self._thread = threading.Thread(
+            target=self._run,
+            name="pyamplicol-report-resource-monitor",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def close(self) -> None:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=max(2.0 * self._interval_seconds, 1.0))
+            self._thread = None
+
+    def _run(self) -> None:
+        while not self._stop.wait(self._interval_seconds):
+            self.sample_once()
+
+    def __enter__(self) -> ResourceMonitor:
+        self.start()
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+
+def _default_popen(command: Sequence[str], **kwargs: object) -> WorkerProcess:
+    return subprocess.Popen(tuple(command), **kwargs)
+
+
+def _worker_environment(
+    overrides: Mapping[str, str] | None = None,
+    *,
+    scrub_import_environment: bool = False,
+) -> dict[str, str]:
+    """Copy the controller environment explicitly for supervised workers."""
+
+    environment = os.environ.copy()
+    if scrub_import_environment:
+        for name in tuple(environment):
+            if (
+                name in _WORKER_IMPORT_ENVIRONMENT
+                or name.startswith("PYTHON")
+                or name.startswith("PYAMPLICOL")
+            ):
+                environment.pop(name, None)
+    symbolica_license = os.environ.get("SYMBOLICA_LICENSE")
+    if symbolica_license is not None:
+        environment["SYMBOLICA_LICENSE"] = symbolica_license
+    for name, value in (overrides or {}).items():
+        if (
+            not isinstance(name, str)
+            or not name
+            or "=" in name
+            or "\x00" in name
+            or not isinstance(value, str)
+            or "\x00" in value
+            or (
+                scrub_import_environment
+                and (
+                    name in _WORKER_IMPORT_ENVIRONMENT
+                    or name.startswith("PYTHON")
+                    or (
+                        name.startswith("PYAMPLICOL")
+                        and name not in _EXPLICIT_PYAMPLICOL_WORKER_CONTROLS
+                    )
+                )
+            )
+        ):
+            raise ValueError("worker environment override is invalid")
+        environment[name] = value
+    return environment
+
+
+def _signal_process_tree(
+    root_process_group: int | None,
+    out_of_group_pids: Collection[int],
+    selected_signal: int,
+) -> None:
+    if root_process_group is not None:
+        with suppress(ProcessLookupError, PermissionError):
+            os.killpg(root_process_group, selected_signal)
+    for pid in out_of_group_pids:
+        with suppress(ProcessLookupError, PermissionError):
+            os.kill(pid, selected_signal)
+
+
+def _parse_linux_process_identity(stat: str) -> _ProcessIdentity:
+    """Authenticate a Linux process from one coherent ``/proc/PID/stat`` row."""
+
+    closing_parenthesis = stat.rfind(")")
+    if closing_parenthesis < 0:
+        raise ValueError("missing process-name terminator")
+    fields = stat[closing_parenthesis + 1 :].split()
+    # ``fields`` starts at kernel field 3 (state).  Read pgrp (field 5) and
+    # starttime (field 22) from the same snapshot so group migration cannot be
+    # mistaken for PID reuse.
+    process_group = int(fields[2])
+    start_ticks = int(fields[19])
+    if process_group <= 0 or start_ticks < 0:
+        raise ValueError("invalid process identity")
+    return _ProcessIdentity(
+        birth_token=start_ticks,
+        process_group=process_group,
+    )
+
+
+class _DarwinProcBsdInfo(ctypes.Structure):
+    """Darwin ``proc_bsdinfo`` fields needed for authenticated teardown."""
+
+    _fields_ = [
+        ("pbi_flags", ctypes.c_uint32),
+        ("pbi_status", ctypes.c_uint32),
+        ("pbi_xstatus", ctypes.c_uint32),
+        ("pbi_pid", ctypes.c_uint32),
+        ("pbi_ppid", ctypes.c_uint32),
+        ("pbi_uid", ctypes.c_uint32),
+        ("pbi_gid", ctypes.c_uint32),
+        ("pbi_ruid", ctypes.c_uint32),
+        ("pbi_rgid", ctypes.c_uint32),
+        ("pbi_svuid", ctypes.c_uint32),
+        ("pbi_svgid", ctypes.c_uint32),
+        ("rfu_1", ctypes.c_uint32),
+        ("pbi_comm", ctypes.c_char * 16),
+        ("pbi_name", ctypes.c_char * 32),
+        ("pbi_nfiles", ctypes.c_uint32),
+        ("pbi_pgid", ctypes.c_uint32),
+        ("pbi_pjobc", ctypes.c_uint32),
+        ("e_tdev", ctypes.c_uint32),
+        ("e_tpgid", ctypes.c_uint32),
+        ("pbi_nice", ctypes.c_int32),
+        ("pbi_start_tvsec", ctypes.c_uint64),
+        ("pbi_start_tvusec", ctypes.c_uint64),
+    ]
+
+
+@cache
+def _darwin_libproc() -> ctypes.CDLL:
+    return ctypes.CDLL("/usr/lib/libproc.dylib", use_errno=True)
+
+
+def _darwin_process_identity(pid: int) -> _ProcessIdentity | None:
+    info = _DarwinProcBsdInfo()
+    try:
+        proc_pidinfo = _darwin_libproc().proc_pidinfo
+        proc_pidinfo.argtypes = (
+            ctypes.c_int,
+            ctypes.c_int,
+            ctypes.c_uint64,
+            ctypes.c_void_p,
+            ctypes.c_int,
+        )
+        proc_pidinfo.restype = ctypes.c_int
+        written = proc_pidinfo(
+            pid,
+            3,  # PROC_PIDTBSDINFO
+            0,
+            ctypes.byref(info),
+            ctypes.sizeof(info),
+        )
+    except (AttributeError, OSError):
+        return None
+    if written != ctypes.sizeof(info):
+        return None
+    process_group = int(info.pbi_pgid)
+    start_seconds = int(info.pbi_start_tvsec)
+    start_microseconds = int(info.pbi_start_tvusec)
+    if (
+        int(info.pbi_pid) != pid
+        or process_group <= 0
+        or start_seconds < 0
+        or not 0 <= start_microseconds < 1_000_000
+        or (start_seconds == 0 and start_microseconds == 0)
+    ):
+        return None
+    return _ProcessIdentity(
+        birth_token=(start_seconds, start_microseconds),
+        process_group=process_group,
+    )
+
+
+def _process_identity(pid: int) -> _ProcessIdentity | None:
+    """Return immutable birth evidence and the process's current signal group."""
+
+    system = platform.system()
+    if system == "Linux":
+        try:
+            stat = Path(f"/proc/{pid}/stat").read_text(encoding="ascii")
+            return _parse_linux_process_identity(stat)
+        except (OSError, UnicodeError, ValueError, IndexError):
+            return None
+    if system == "Darwin":
+        return _darwin_process_identity(pid)
+    return None
+
+
+@dataclass(frozen=True, slots=True)
+class _TeardownResult:
+    returncode: int
+    escalated: bool
+    elapsed_seconds: float
+
+
+@dataclass(frozen=True, slots=True)
+class _TeardownDiagnostics:
+    escalated: bool
+    elapsed_seconds: float
+
+
+def _emit_teardown_observation(
+    process: WorkerProcess,
+    monitor: ResourceMonitor,
+    observation_callback: ObservationCallback | None,
+    *,
+    phase: str,
+) -> None:
+    usage = monitor.sample_once()
+    if observation_callback is None:
+        return
+    with suppress(Exception):
+        observation_callback(
+            WorkerObservation(
+                pid=process.pid,
+                usage=usage,
+                phase=phase,
+                phase_sequence=None,
+                member_pids=monitor.member_pids,
+            )
+        )
+
+
+def _identity_process_group(identity: _ProcessIdentity) -> int:
+    return identity.process_group
+
+
+def _capture_process_identities(
+    identities: dict[int, _ProcessIdentity],
+    member_pids: Collection[int],
+    identity_probe: ProcessIdentityProbe,
+) -> None:
+    """Retain the first authenticated identity observed for each worker PID."""
+
+    for pid in member_pids:
+        if pid in identities:
+            continue
+        identity = identity_probe(pid)
+        if identity is not None:
+            identities[pid] = identity
+
+
+def _live_descendant_identities(
+    process: WorkerProcess,
+    identities: Mapping[int, _ProcessIdentity],
+    identity_probe: ProcessIdentityProbe,
+) -> dict[int, _ProcessIdentity]:
+    surviving: dict[int, _ProcessIdentity] = {}
+    for pid, captured in identities.items():
+        if pid == process.pid:
+            continue
+        current = identity_probe(pid)
+        if current is None or current.birth_token != captured.birth_token:
+            continue
+        # Birth identity is immutable; route signals using the freshly probed
+        # process group in case the descendant called setpgid()/setsid().
+        surviving[pid] = current
+    return surviving
+
+
+def _signal_authenticated_tree(
+    process: WorkerProcess,
+    *,
+    returncode: int | None,
+    descendants: Mapping[int, _ProcessIdentity],
+    selected_signal: int,
+    signaler: TreeSignaler,
+) -> None:
+    """Signal each authenticated worker identity no more than once."""
+
+    group_is_live = returncode is None or any(
+        _identity_process_group(identity) == process.pid
+        for identity in descendants.values()
+    )
+    out_of_group = tuple(
+        sorted(
+            pid
+            for pid, identity in descendants.items()
+            if _identity_process_group(identity) != process.pid
+        )
+    )
+    if not group_is_live and not out_of_group:
+        return
+    signaler(process.pid if group_is_live else None, out_of_group, selected_signal)
+
+
+def _terminate_worker(
+    process: WorkerProcess,
+    *,
+    monitor: ResourceMonitor,
+    process_identities: dict[int, _ProcessIdentity],
+    grace_seconds: float,
+    signaler: TreeSignaler,
+    clock: Clock,
+    sleeper: Sleeper,
+    observation_callback: ObservationCallback | None,
+    identity_probe: ProcessIdentityProbe,
+) -> _TeardownResult:
+    started = clock()
+    identities = process_identities
+
+    def refresh(*, phase: str) -> tuple[int | None, dict[int, _ProcessIdentity]]:
+        returncode = process.poll()
+        surviving = _live_descendant_identities(
+            process,
+            identities,
+            identity_probe,
+        )
+        if returncode is not None and not surviving:
+            return returncode, {}
+        _emit_teardown_observation(
+            process,
+            monitor,
+            observation_callback,
+            phase=phase,
+        )
+        _capture_process_identities(
+            identities,
+            monitor.member_pids,
+            identity_probe,
+        )
+        returncode = process.poll()
+        surviving = _live_descendant_identities(
+            process,
+            identities,
+            identity_probe,
+        )
+        return returncode, surviving
+
+    returncode = process.poll()
+    surviving = _live_descendant_identities(
+        process,
+        identities,
+        identity_probe,
+    )
+    if returncode is not None and not surviving:
+        return _TeardownResult(
+            returncode=returncode,
+            escalated=False,
+            elapsed_seconds=max(clock() - started, 0.0),
+        )
+    _signal_authenticated_tree(
+        process,
+        returncode=returncode,
+        descendants=surviving,
+        selected_signal=signal.SIGTERM,
+        signaler=signaler,
+    )
+    deadline = clock() + grace_seconds
+    while True:
+        returncode, surviving = refresh(phase="terminating")
+        if returncode is not None and not surviving:
+            return _TeardownResult(
+                returncode=returncode,
+                escalated=False,
+                elapsed_seconds=max(clock() - started, 0.0),
+            )
+        if clock() >= deadline:
+            break
+        sleeper(min(0.25, max(deadline - clock(), 0.0)))
+
+    _signal_authenticated_tree(
+        process,
+        returncode=returncode,
+        descendants=surviving,
+        selected_signal=signal.SIGKILL,
+        signaler=signaler,
+    )
+    while True:
+        returncode, surviving = refresh(phase="waiting-for-reap")
+        if returncode is not None and not surviving:
+            return _TeardownResult(
+                returncode=returncode,
+                escalated=True,
+                elapsed_seconds=max(clock() - started, 0.0),
+            )
+        # SIGKILL can remain uninterruptible while a task is in kernel I/O.
+        # Keep this lane occupied, but let the dashboard and other lanes run.
+        sleeper(0.25)
+
+
+def _terminate_surviving_descendants(
+    process: WorkerProcess,
+    *,
+    monitor: ResourceMonitor,
+    grace_seconds: float,
+    signaler: TreeSignaler,
+    clock: Clock,
+    sleeper: Sleeper,
+    observation_callback: ObservationCallback | None,
+    identity_probe: ProcessIdentityProbe,
+    process_identities: dict[int, _ProcessIdentity],
+) -> _TeardownDiagnostics:
+    """Terminate a process group left behind after its root has exited."""
+
+    started = clock()
+    identities = process_identities
+    surviving = _live_descendant_identities(
+        process,
+        identities,
+        identity_probe,
+    )
+    if not surviving:
+        return _TeardownDiagnostics(
+            escalated=False,
+            elapsed_seconds=0.0,
+        )
+    _signal_authenticated_tree(
+        process,
+        returncode=process.poll(),
+        descendants=surviving,
+        selected_signal=signal.SIGTERM,
+        signaler=signaler,
+    )
+    deadline = clock() + grace_seconds
+    while surviving and clock() < deadline:
+        sleeper(min(0.05, max(deadline - clock(), 0.0)))
+        _emit_teardown_observation(
+            process,
+            monitor,
+            observation_callback,
+            phase="terminating",
+        )
+        _capture_process_identities(
+            identities,
+            monitor.member_pids,
+            identity_probe,
+        )
+        surviving = _live_descendant_identities(
+            process,
+            identities,
+            identity_probe,
+        )
+    if not surviving:
+        return _TeardownDiagnostics(
+            escalated=False,
+            elapsed_seconds=max(clock() - started, 0.0),
+        )
+    _signal_authenticated_tree(
+        process,
+        returncode=process.poll(),
+        descendants=surviving,
+        selected_signal=signal.SIGKILL,
+        signaler=signaler,
+    )
+    while surviving:
+        sleeper(0.25)
+        _emit_teardown_observation(
+            process,
+            monitor,
+            observation_callback,
+            phase="waiting-for-reap",
+        )
+        _capture_process_identities(
+            identities,
+            monitor.member_pids,
+            identity_probe,
+        )
+        surviving = _live_descendant_identities(
+            process,
+            identities,
+            identity_probe,
+        )
+    return _TeardownDiagnostics(
+        escalated=True,
+        elapsed_seconds=max(clock() - started, 0.0),
+    )
+
+
+def supervise_worker(
+    command: Sequence[str],
+    *,
+    timeout_seconds: float | None = None,
+    generation_timeout_seconds: float | None = None,
+    profiling_timeout_seconds: float | None = None,
+    validation_timeout_seconds: float | None = None,
+    generation_guard_includes_preparation: bool = False,
+    phase_channel: WorkerPhaseChannel | None = None,
+    max_rss_bytes: int | None = None,
+    output_file_limits: Mapping[Path, int] | None = None,
+    minimum_free_disk_bytes: int | None = None,
+    disk_probe_path: Path | None = None,
+    interval_seconds: float = DEFAULT_SAMPLE_INTERVAL_SECONDS,
+    termination_grace_seconds: float = DEFAULT_TERMINATION_GRACE_SECONDS,
+    phase_state_startup_grace_seconds: float = (
+        DEFAULT_PHASE_STATE_STARTUP_GRACE_SECONDS
+    ),
+    environment_overrides: Mapping[str, str] | None = None,
+    scrub_import_environment: bool = False,
+    working_directory: Path | None = None,
+    snapshotter: Snapshotter = process_snapshot,
+    physical_footprint_probe: PhysicalFootprintProbe | None = None,
+    popen_factory: PopenFactory = _default_popen,
+    clock: Clock = time.monotonic,
+    sleeper: Sleeper = time.sleep,
+    signaler: TreeSignaler = _signal_process_tree,
+    observation_callback: ObservationCallback | None = None,
+    cancellation_requested: CancellationCheck | None = None,
+    capture_stderr: bool = False,
+    stderr_limit_bytes: int = DEFAULT_SUPERVISOR_STDERR_LIMIT_BYTES,
+    process_identity_probe: ProcessIdentityProbe = _process_identity,
+    disk_free_probe: DiskFreeProbe = _disk_free_bytes,
+) -> SupervisedResult:
+    """Run a worker and enforce wall, stage, memory, and disk-safety limits.
+
+    ``generation_timeout_seconds`` requires an authenticated phase channel.
+    Missing, malformed, replayed, or incomplete phase evidence terminates the
+    worker rather than silently turning the generation limit into a wall limit.
+    """
+
+    if not command:
+        raise ValueError("command must not be empty")
+    if timeout_seconds is not None and (
+        timeout_seconds <= 0 or not math.isfinite(timeout_seconds)
+    ):
+        raise ValueError("timeout_seconds must be positive when specified")
+    if generation_timeout_seconds is not None and (
+        generation_timeout_seconds <= 0 or not math.isfinite(generation_timeout_seconds)
+    ):
+        raise ValueError("generation_timeout_seconds must be positive when specified")
+    for stage_name, stage_timeout in (
+        ("profiling_timeout_seconds", profiling_timeout_seconds),
+        ("validation_timeout_seconds", validation_timeout_seconds),
+    ):
+        if stage_timeout is not None and (
+            stage_timeout <= 0 or not math.isfinite(stage_timeout)
+        ):
+            raise ValueError(f"{stage_name} must be positive when specified")
+    if generation_timeout_seconds is not None and phase_channel is None:
+        raise ValueError(
+            "generation_timeout_seconds requires an authenticated phase_channel"
+        )
+    if (
+        profiling_timeout_seconds is not None
+        or validation_timeout_seconds is not None
+        or generation_guard_includes_preparation
+    ) and phase_channel is None:
+        raise ValueError("stage limits require an authenticated phase_channel")
+    if max_rss_bytes is not None and max_rss_bytes <= 0:
+        raise ValueError("max_rss_bytes must be positive when specified")
+    normalized_output_limits: tuple[tuple[Path, int], ...] = ()
+    if output_file_limits:
+        observed_limits: list[tuple[Path, int]] = []
+        for raw_path, raw_limit in output_file_limits.items():
+            if (
+                isinstance(raw_limit, bool)
+                or not isinstance(raw_limit, int)
+                or raw_limit <= 0
+            ):
+                raise ValueError("output file limits must be positive")
+            observed_limits.append(
+                (
+                    Path(os.path.abspath(Path(raw_path).expanduser())),
+                    int(raw_limit),
+                )
+            )
+        normalized_output_limits = tuple(
+            sorted(observed_limits, key=lambda item: os.fspath(item[0]))
+        )
+    if minimum_free_disk_bytes is not None and (
+        isinstance(minimum_free_disk_bytes, bool)
+        or not isinstance(minimum_free_disk_bytes, int)
+        or minimum_free_disk_bytes <= 0
+    ):
+        raise ValueError(
+            "minimum_free_disk_bytes must be a positive integer when specified"
+        )
+    if minimum_free_disk_bytes is not None and disk_probe_path is None:
+        disk_probe_path = working_directory or Path.cwd()
+    if disk_probe_path is not None:
+        disk_probe_path = disk_probe_path.expanduser().resolve(strict=True)
+        if not disk_probe_path.is_dir():
+            raise ValueError("disk_probe_path must be a directory")
+    if interval_seconds <= 0:
+        raise ValueError("interval_seconds must be positive")
+    if termination_grace_seconds < 0:
+        raise ValueError("termination_grace_seconds must be non-negative")
+    if phase_state_startup_grace_seconds < 0:
+        raise ValueError("phase_state_startup_grace_seconds must be non-negative")
+    if stderr_limit_bytes <= 0:
+        raise ValueError("stderr_limit_bytes must be positive")
+    if working_directory is not None:
+        working_directory = working_directory.expanduser().resolve(strict=True)
+        if not working_directory.is_dir():
+            raise ValueError("working_directory must be a directory")
+
+    if (
+        max_rss_bytes is not None
+        and physical_footprint_probe is None
+        and platform.system() == "Darwin"
+        and snapshotter is process_snapshot
+    ):
+        try:
+            darwin_probe = DarwinPhysicalFootprintProbe()
+        except WatchdogProbeError as error:
+            raise ResourceProbeError(
+                f"Darwin physical-footprint probe is unavailable: {error}"
+            ) from error
+
+        def physical_footprint_probe(
+            pids: Collection[int],
+        ) -> Mapping[int, int]:
+            return darwin_probe(pids)
+
+    started_at_utc = datetime.now(UTC).isoformat()
+    phase_monitor_started = clock()
+    popen_arguments: dict[str, object] = {
+        "start_new_session": True,
+        "env": _worker_environment(
+            environment_overrides,
+            scrub_import_environment=scrub_import_environment,
+        ),
+    }
+    if working_directory is not None:
+        popen_arguments["cwd"] = os.fspath(working_directory)
+    if capture_stderr:
+        popen_arguments["stderr"] = subprocess.PIPE
+    process = popen_factory(tuple(command), **popen_arguments)
+    if process_identity_probe is _process_identity and not isinstance(
+        process, subprocess.Popen
+    ):
+        # Injected protocol fakes have no relationship to host PIDs. Focused
+        # teardown tests opt in to an injected identity probe explicitly.
+        def unavailable_process_identity(_pid: int) -> _ProcessIdentity | None:
+            return None
+
+        process_identity_probe = unavailable_process_identity
+    stderr_tail = _BoundedByteTail(stderr_limit_bytes)
+    stderr_stream = getattr(process, "stderr", None) if capture_stderr else None
+    stderr_thread: threading.Thread | None = None
+    if stderr_stream is not None:
+        stderr_thread = threading.Thread(
+            target=stderr_tail.drain,
+            args=(stderr_stream,),
+            name=f"worker-{process.pid}-stderr",
+            daemon=True,
+        )
+        stderr_thread.start()
+    monitor = ResourceMonitor(
+        process.pid,
+        interval_seconds=interval_seconds,
+        snapshotter=snapshotter,
+        physical_footprint_probe=physical_footprint_probe,
+        clock=clock,
+    )
+    reason: TerminationReason = "completed"
+    returncode: int | None = None
+    phase_state: WorkerPhaseState | None = None
+    phase_error: str | None = None
+    memory_limit_reason: str | None = None
+    output_limit_path: str | None = None
+    output_limit_bytes: int | None = None
+    observed_output_bytes: int | None = None
+    observed_free_disk_bytes: int | None = None
+    storage_stop = threading.Event()
+    storage_wakeup = threading.Event()
+    storage_lock = threading.Lock()
+    storage_violation: tuple[
+        TerminationReason,
+        str | None,
+        int | None,
+        int | None,
+        int | None,
+    ] | None = None
+    consecutive_memory_probe_failures = 0
+    pending_memory_probe_reason: str | None = None
+    tree_termination_requested = False
+    teardown_escalated = False
+    teardown_seconds = 0.0
+    observed_member_pids = {process.pid}
+    observed_process_identities: dict[int, _ProcessIdentity] = {}
+    _capture_process_identities(
+        observed_process_identities,
+        (process.pid,),
+        process_identity_probe,
+    )
+
+    def terminate(selected_reason: TerminationReason) -> None:
+        nonlocal reason, returncode, tree_termination_requested
+        nonlocal teardown_escalated, teardown_seconds
+        if tree_termination_requested:
+            return
+        reason = selected_reason
+        tree_termination_requested = True
+        # Once output or free-disk containment has fired, an uncooperative
+        # writer must not receive another multi-second window in which to fill
+        # the host volume.  The process still receives SIGTERM first, followed
+        # immediately by SIGKILL when it does not exit.
+        grace_seconds = (
+            0.0
+            if selected_reason
+            in {
+                "output_limit",
+                "output_probe_error",
+                "disk_space_limit",
+                "disk_probe_error",
+            }
+            else termination_grace_seconds
+        )
+        teardown = _terminate_worker(
+            process,
+            monitor=monitor,
+            process_identities=observed_process_identities,
+            grace_seconds=grace_seconds,
+            signaler=signaler,
+            clock=clock,
+            sleeper=sleeper,
+            observation_callback=observation_callback,
+            identity_probe=process_identity_probe,
+        )
+        returncode = teardown.returncode
+        teardown_escalated = teardown.escalated
+        teardown_seconds = teardown.elapsed_seconds
+
+    def probe_storage_safety() -> tuple[
+        TerminationReason,
+        str | None,
+        int | None,
+        int | None,
+        int | None,
+    ] | None:
+        nonlocal observed_free_disk_bytes
+        for output_path, configured_limit in normalized_output_limits:
+            try:
+                output_size = output_path.stat().st_size
+            except FileNotFoundError:
+                continue
+            except OSError:
+                return (
+                    "output_probe_error",
+                    os.fspath(output_path),
+                    configured_limit,
+                    None,
+                    None,
+                )
+            if output_size > configured_limit:
+                return (
+                    "output_limit",
+                    os.fspath(output_path),
+                    configured_limit,
+                    output_size,
+                    None,
+                )
+        if minimum_free_disk_bytes is None:
+            return None
+        assert disk_probe_path is not None
+        try:
+            observed_free_disk_bytes = disk_free_probe(disk_probe_path)
+            if (
+                isinstance(observed_free_disk_bytes, bool)
+                or not isinstance(observed_free_disk_bytes, int)
+                or observed_free_disk_bytes < 0
+            ):
+                raise ValueError("free-disk probe returned an invalid value")
+        except (OSError, ValueError, OverflowError):
+            return ("disk_probe_error", None, None, None, None)
+        if observed_free_disk_bytes < minimum_free_disk_bytes:
+            return (
+                "disk_space_limit",
+                None,
+                None,
+                None,
+                observed_free_disk_bytes,
+            )
+        return None
+
+    def record_storage_violation(
+        violation: tuple[
+            TerminationReason,
+            str | None,
+            int | None,
+            int | None,
+            int | None,
+        ],
+    ) -> None:
+        nonlocal storage_violation
+        with storage_lock:
+            if storage_violation is None:
+                storage_violation = violation
+        storage_wakeup.set()
+
+    def pending_storage_violation() -> tuple[
+        TerminationReason,
+        str | None,
+        int | None,
+        int | None,
+        int | None,
+    ] | None:
+        with storage_lock:
+            return storage_violation
+
+    def capture_storage_violation(
+        violation: tuple[
+            TerminationReason,
+            str | None,
+            int | None,
+            int | None,
+            int | None,
+        ],
+    ) -> TerminationReason:
+        nonlocal output_limit_path, output_limit_bytes
+        nonlocal observed_output_bytes, observed_free_disk_bytes
+        (
+            selected_reason,
+            output_limit_path,
+            output_limit_bytes,
+            observed_output_bytes,
+            violation_free_disk_bytes,
+        ) = violation
+        if violation_free_disk_bytes is not None:
+            observed_free_disk_bytes = violation_free_disk_bytes
+        return selected_reason
+
+    def apply_storage_violation(
+        violation: tuple[
+            TerminationReason,
+            str | None,
+            int | None,
+            int | None,
+            int | None,
+        ],
+    ) -> None:
+        selected_reason = capture_storage_violation(violation)
+        exit_code = process.poll()
+        if exit_code is not None and exit_code != 0:
+            classify_process_exit(exit_code, now_seconds=clock())
+            return
+        terminate(selected_reason)
+
+    def watch_storage_safety() -> None:
+        while not storage_stop.wait(DEFAULT_STORAGE_SAFETY_INTERVAL_SECONDS):
+            violation = probe_storage_safety()
+            if violation is not None:
+                record_storage_violation(violation)
+                return
+
+    storage_thread: threading.Thread | None = None
+    if normalized_output_limits or minimum_free_disk_bytes is not None:
+        storage_thread = threading.Thread(
+            target=watch_storage_safety,
+            name=f"worker-{process.pid}-storage-guard",
+            daemon=True,
+        )
+        storage_thread.start()
+
+    def effective_generation_elapsed(
+        state: WorkerPhaseState,
+        *,
+        now_seconds: float,
+        wall_seconds: float,
+    ) -> float | None:
+        if not generation_guard_includes_preparation:
+            return state.generation_elapsed_seconds(now_seconds=now_seconds)
+        finished_ns = state.generation_finished_monotonic_ns
+        if finished_ns is None:
+            return wall_seconds
+        return max(finished_ns / 1_000_000_000 - phase_monitor_started, 0.0)
+
+    def observe_phase(now_seconds: float) -> float:
+        nonlocal phase_state, phase_error
+        assert phase_channel is not None
+        try:
+            observed = read_worker_phase_state(
+                phase_channel,
+                expected_pid=process.pid,
+            )
+        except FileNotFoundError:
+            observed_at_seconds = max(now_seconds, clock())
+            if (
+                phase_state is not None
+                or observed_at_seconds - phase_monitor_started
+                >= phase_state_startup_grace_seconds
+            ):
+                phase_error = "worker phase-state file is missing"
+            return observed_at_seconds
+        except WorkerPhaseStateError as error:
+            phase_error = str(error)
+            return max(now_seconds, clock())
+
+        # The dashboard callback and the authenticated file read both happen
+        # after the loop's initial sample.  Validate worker timestamps against
+        # a clock captured after that read so a legitimate transition during
+        # a slow observation cannot appear spuriously in the future.
+        observed_at_seconds = max(now_seconds, clock())
+        earliest_seconds = phase_monitor_started - interval_seconds
+        latest_seconds = observed_at_seconds + interval_seconds
+        observed_timestamps = (
+            observed.transition_monotonic_ns,
+            observed.generation_started_monotonic_ns,
+            observed.generation_finished_monotonic_ns,
+            observed.profiling_started_monotonic_ns,
+            observed.profiling_finished_monotonic_ns,
+            observed.validation_started_monotonic_ns,
+            observed.validation_finished_monotonic_ns,
+        )
+        if any(
+            timestamp is not None
+            and not (earliest_seconds <= timestamp / 1_000_000_000 <= latest_seconds)
+            for timestamp in observed_timestamps
+        ):
+            phase_error = (
+                "worker phase-state transition timestamp is outside the "
+                "supervised process lifetime"
+            )
+            return observed_at_seconds
+        if phase_state is not None:
+            if observed.sequence < phase_state.sequence:
+                phase_error = "worker phase-state sequence moved backwards"
+                return observed_at_seconds
+            if (
+                observed.sequence == phase_state.sequence
+                and observed.sha256 != phase_state.sha256
+            ):
+                phase_error = (
+                    "worker phase-state changed without advancing its sequence"
+                )
+                return observed_at_seconds
+            for field in (
+                "generation_started_monotonic_ns",
+                "generation_finished_monotonic_ns",
+                "profiling_started_monotonic_ns",
+                "profiling_finished_monotonic_ns",
+                "validation_started_monotonic_ns",
+                "validation_finished_monotonic_ns",
+            ):
+                prior_timestamp = getattr(phase_state, field)
+                if (
+                    prior_timestamp is not None
+                    and getattr(observed, field) != prior_timestamp
+                ):
+                    phase_error = f"worker {field} changed"
+                    return observed_at_seconds
+        phase_state = observed
+        return observed_at_seconds
+
+    def classify_process_exit(
+        exit_code: int,
+        *,
+        now_seconds: float,
+        zero_reason: TerminationReason = "completed",
+    ) -> None:
+        nonlocal returncode, reason, phase_error
+        returncode = exit_code
+        if phase_channel is not None:
+            observe_phase(now_seconds)
+            if phase_error is None and phase_state is None:
+                phase_error = "worker exited without authenticated phase-state evidence"
+            elif (
+                phase_error is None
+                and phase_state is not None
+                and phase_state.phase == "generation"
+            ):
+                phase_error = "worker exited before closing its generation interval"
+        if exit_code != 0:
+            reason = "worker_exit"
+        elif phase_error is not None:
+            reason = "phase_state_error"
+        else:
+            reason = zero_reason
+
+    def classify_process_exit_at_boundary(
+        exit_code: int,
+        *,
+        now_seconds: float,
+        zero_reason: TerminationReason = "completed",
+    ) -> None:
+        # A fast writer can cross its cap and exit between background storage
+        # samples.  A synchronous final probe keeps a clean exit from hiding
+        # that violation.  A genuine nonzero worker exit remains the primary
+        # outcome, while the storage evidence is still retained for diagnosis.
+        violation = pending_storage_violation() or probe_storage_safety()
+        if violation is not None:
+            selected_reason = capture_storage_violation(violation)
+            if exit_code == 0:
+                terminate(selected_reason)
+                return
+        classify_process_exit(
+            exit_code,
+            now_seconds=now_seconds,
+            zero_reason=zero_reason,
+        )
+
+    def wait_for_next_sample() -> None:
+        if storage_thread is None:
+            sleeper(interval_seconds)
+        else:
+            storage_wakeup.wait(timeout=interval_seconds)
+
+    try:
+        while True:
+            if (
+                violation := pending_storage_violation() or probe_storage_safety()
+            ) is not None:
+                apply_storage_violation(violation)
+                break
+            if cancellation_requested is not None and cancellation_requested():
+                returncode = process.poll()
+                if returncode is None:
+                    terminate("cancelled")
+                else:
+                    classify_process_exit_at_boundary(
+                        returncode,
+                        now_seconds=clock(),
+                        zero_reason="cancelled",
+                    )
+                break
+            if pending_memory_probe_reason is not None:
+                returncode = process.poll()
+                if returncode is not None:
+                    classify_process_exit_at_boundary(
+                        returncode,
+                        now_seconds=clock(),
+                        zero_reason="memory_probe_error",
+                    )
+                    break
+
+            usage = monitor.sample_once()
+            observed_member_pids.update(monitor.member_pids)
+            _capture_process_identities(
+                observed_process_identities,
+                monitor.member_pids,
+                process_identity_probe,
+            )
+            now_seconds = clock()
+            if observation_callback is not None:
+                # Monitoring is deliberately informational. A broken
+                # dashboard must never invalidate a measurement.
+                with suppress(Exception):
+                    observation_callback(
+                        WorkerObservation(
+                            pid=process.pid,
+                            usage=usage,
+                            phase=(None if phase_state is None else phase_state.phase),
+                            phase_sequence=(
+                                None if phase_state is None else phase_state.sequence
+                            ),
+                            member_pids=monitor.member_pids,
+                        )
+                    )
+            returncode = process.poll()
+            if returncode is not None:
+                classify_process_exit_at_boundary(
+                    returncode,
+                    now_seconds=now_seconds,
+                )
+                break
+            if max_rss_bytes is not None and usage.memory_probe_reason is not None:
+                consecutive_memory_probe_failures += 1
+                pending_memory_probe_reason = usage.memory_probe_reason
+                returncode = process.poll()
+                if returncode is not None:
+                    classify_process_exit_at_boundary(
+                        returncode,
+                        now_seconds=now_seconds,
+                        zero_reason="memory_probe_error",
+                    )
+                    break
+                if (
+                    consecutive_memory_probe_failures
+                    >= MAX_CONSECUTIVE_MEMORY_PROBE_FAILURES
+                ):
+                    terminate("memory_probe_error")
+                    break
+                wait_for_next_sample()
+                continue
+            if pending_memory_probe_reason is not None:
+                returncode = process.poll()
+                if returncode is not None:
+                    classify_process_exit_at_boundary(
+                        returncode,
+                        now_seconds=now_seconds,
+                        zero_reason="memory_probe_error",
+                    )
+                    break
+                pending_memory_probe_reason = None
+                consecutive_memory_probe_failures = 0
+            if (
+                max_rss_bytes is not None
+                and usage.current_guard_bytes is not None
+                and usage.current_guard_bytes > max_rss_bytes
+            ):
+                physical = usage.current_physical_footprint_bytes
+                rss = usage.current_rss_bytes
+                memory_limit_reason = (
+                    DARWIN_PHYSICAL_FOOTPRINT_LIMIT_REASON
+                    if physical is not None and rss is not None and physical >= rss
+                    else RSS_LIMIT_REASON
+                )
+                terminate("memory_limit")
+                break
+            if phase_channel is not None:
+                now_seconds = observe_phase(now_seconds)
+                if phase_error is not None:
+                    returncode = process.poll()
+                    if returncode is not None:
+                        classify_process_exit_at_boundary(
+                            returncode,
+                            now_seconds=now_seconds,
+                            zero_reason="phase_state_error",
+                        )
+                        if returncode == 0 and not tree_termination_requested:
+                            terminate("phase_state_error")
+                    else:
+                        terminate("phase_state_error")
+                    break
+                if phase_state is not None:
+                    if generation_timeout_seconds is not None:
+                        generation_elapsed = effective_generation_elapsed(
+                            phase_state,
+                            now_seconds=now_seconds,
+                            wall_seconds=usage.wall_seconds,
+                        )
+                        if (
+                            generation_elapsed is not None
+                            and generation_elapsed >= generation_timeout_seconds
+                        ):
+                            terminate("generation_timeout")
+                            break
+                    if (
+                        profiling_timeout_seconds is not None
+                        and (
+                            profiling_elapsed := phase_state.stage_elapsed_seconds(
+                                "profiling",
+                                now_seconds=now_seconds,
+                            )
+                        )
+                        is not None
+                        and profiling_elapsed >= profiling_timeout_seconds
+                    ):
+                        terminate("profiling_timeout")
+                        break
+                    if (
+                        validation_timeout_seconds is not None
+                        and (
+                            validation_elapsed := phase_state.stage_elapsed_seconds(
+                                "validation",
+                                now_seconds=now_seconds,
+                            )
+                        )
+                        is not None
+                        and validation_elapsed >= validation_timeout_seconds
+                    ):
+                        terminate("validation_timeout")
+                        break
+            if timeout_seconds is not None and usage.wall_seconds >= timeout_seconds:
+                terminate("worker_timeout")
+                break
+
+            returncode = process.poll()
+            if returncode is not None:
+                classify_process_exit_at_boundary(
+                    returncode,
+                    now_seconds=now_seconds,
+                )
+                break
+            wait_for_next_sample()
+    finally:
+        storage_stop.set()
+        storage_wakeup.set()
+        if storage_thread is not None:
+            storage_thread.join(timeout=1.0)
+        if process.poll() is None and not tree_termination_requested:
+            teardown = _terminate_worker(
+                process,
+                monitor=monitor,
+                process_identities=observed_process_identities,
+                grace_seconds=termination_grace_seconds,
+                signaler=signaler,
+                clock=clock,
+                sleeper=sleeper,
+                observation_callback=observation_callback,
+                identity_probe=process_identity_probe,
+            )
+            returncode = teardown.returncode
+            teardown_escalated = teardown.escalated
+            teardown_seconds = teardown.elapsed_seconds
+        elif not tree_termination_requested:
+            # ``poll`` reaps the root, but a daemonized/reparented descendant
+            # may still survive in the worker's process group. Do not return
+            # control to the scheduler until that known tree is gone.
+            returncode = process.wait()
+            descendant_teardown = _terminate_surviving_descendants(
+                process,
+                monitor=monitor,
+                grace_seconds=termination_grace_seconds,
+                signaler=signaler,
+                clock=clock,
+                sleeper=sleeper,
+                observation_callback=observation_callback,
+                identity_probe=process_identity_probe,
+                process_identities=observed_process_identities,
+            )
+            teardown_escalated = teardown_escalated or descendant_teardown.escalated
+            teardown_seconds += descendant_teardown.elapsed_seconds
+
+    if returncode is None:
+        returncode = process.wait()
+    observed_member_pids.update(monitor.member_pids)
+    if stderr_thread is not None:
+        stderr_thread.join(timeout=max(termination_grace_seconds, 1.0))
+        if stderr_thread.is_alive() and stderr_stream is not None:
+            with suppress(OSError, ValueError):
+                stderr_stream.close()
+            stderr_thread.join(timeout=1.0)
+    supervisor_stderr, supervisor_stderr_truncated = stderr_tail.decoded()
+    signal_number = -returncode if returncode < 0 else None
+    signal_name: str | None = None
+    if signal_number is not None:
+        try:
+            signal_name = signal.Signals(signal_number).name
+        except ValueError:
+            signal_name = f"SIG{signal_number}"
+    generation_phase = None
+    if phase_channel is not None and generation_timeout_seconds is not None:
+        generation_phase = GenerationPhaseEvidence(
+            configured_timeout_seconds=generation_timeout_seconds,
+            supervisor_reason=reason,
+            authenticated=phase_state is not None and phase_error is None,
+            run_id=phase_channel.run_id,
+            worker_pid=process.pid,
+            final_sequence=None if phase_state is None else phase_state.sequence,
+            final_phase=None if phase_state is None else phase_state.phase,
+            generation_started_monotonic_ns=(
+                None
+                if phase_state is None
+                else phase_state.generation_started_monotonic_ns
+            ),
+            generation_finished_monotonic_ns=(
+                None
+                if phase_state is None
+                else phase_state.generation_finished_monotonic_ns
+            ),
+            generation_elapsed_seconds=(
+                None
+                if phase_state is None
+                else effective_generation_elapsed(
+                    phase_state,
+                    now_seconds=clock(),
+                    wall_seconds=monitor.usage.wall_seconds,
+                )
+            ),
+            final_state_sha256=(None if phase_state is None else phase_state.sha256),
+            error=phase_error,
+        )
+    return SupervisedResult(
+        returncode=returncode,
+        reason=reason,
+        usage=monitor.usage,
+        generation_phase=generation_phase,
+        memory_limit_bytes=max_rss_bytes,
+        memory_limit_reason=memory_limit_reason,
+        output_limit_path=output_limit_path,
+        output_limit_bytes=output_limit_bytes,
+        observed_output_bytes=observed_output_bytes,
+        minimum_free_disk_bytes=minimum_free_disk_bytes,
+        observed_free_disk_bytes=observed_free_disk_bytes,
+        pid=process.pid,
+        member_pids=tuple(sorted(observed_member_pids)),
+        signal_number=signal_number,
+        signal_name=signal_name,
+        supervisor_stderr=supervisor_stderr,
+        supervisor_stderr_truncated=supervisor_stderr_truncated,
+        supervisor_stderr_limit_bytes=(stderr_limit_bytes if capture_stderr else None),
+        phase_state_error=phase_error,
+        started_at_utc=started_at_utc,
+        finished_at_utc=datetime.now(UTC).isoformat(),
+        teardown_escalated=teardown_escalated,
+        teardown_seconds=teardown_seconds,
+    )
+
+
+__all__ = [
+    "DEFAULT_ATTEMPT_OUTPUT_LIMIT_BYTES",
+    "DEFAULT_MINIMUM_FREE_DISK_BYTES",
+    "DEFAULT_PHASE_STATE_STARTUP_GRACE_SECONDS",
+    "DEFAULT_SAMPLE_INTERVAL_SECONDS",
+    "DEFAULT_STORAGE_SAFETY_INTERVAL_SECONDS",
+    "DEFAULT_SUPERVISOR_STDERR_LIMIT_BYTES",
+    "DEFAULT_TERMINATION_GRACE_SECONDS",
+    "GENERATION_PHASE_EVIDENCE_ABI",
+    "MAX_CONSECUTIVE_MEMORY_PROBE_FAILURES",
+    "PROCESS_TREE_MEMORY_METRIC_ABI",
+    "GenerationPhaseEvidence",
+    "ProcessRecord",
+    "ProcessTreeSample",
+    "ProcessTreeSampler",
+    "ResourceMonitor",
+    "ResourceProbeError",
+    "ResourceUsage",
+    "SupervisedResult",
+    "WorkerObservation",
+    "process_snapshot",
+    "supervise_worker",
+]
diff --git a/pyamplicol/tools/performance_report/runner.py b/pyamplicol/tools/performance_report/runner.py
new file mode 100644
index 0000000000..41de47f486
--- /dev/null
+++ b/pyamplicol/tools/performance_report/runner.py
@@ -0,0 +1,5499 @@
+# SPDX-License-Identifier: 0BSD
+"""Direct Python-API generation, profiling, and validation for report cells."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import importlib.resources
+import io
+import json
+import math
+import os
+import platform
+import re
+import stat
+import statistics
+import time
+import tomllib
+from collections.abc import Callable, Mapping, Sequence
+from contextlib import nullcontext
+from dataclasses import dataclass, replace
+from decimal import Decimal, InvalidOperation
+from pathlib import Path, PurePosixPath
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from pyamplicol.config import BenchmarkConfig
+    from pyamplicol.reporting import ProgressSink
+
+from .arena_profile import (
+    ARENA_PHASE_TIMING_SCOPE,
+    ARENA_PROFILE_BOUNDARY,
+    ARENA_PROFILE_PROTOCOL,
+    ARENA_PROFILE_SAMPLE_PASS,
+    PAIRED_TIMING_SAMPLE_CONTRACT,
+    ArenaProfileEvidenceError,
+    build_arena_profile_evidence,
+    digest_arena_profile_value,
+    validate_arena_profile_evidence,
+)
+from .models import (
+    Accuracy,
+    CellSpec,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from .phase_state import WorkerPhaseReporter
+from .runtime_evidence import (
+    RuntimeEvidenceError,
+    established_preimport_runtime_identity,
+    loaded_pyamplicol_origin_policy,
+    python_package_tree_identity,
+)
+from .selector_policy import (
+    SelectorPolicyError,
+    canonical_lc_flow_word,
+    canonical_lc_selector_word,
+    fixed_selector_helicity,
+    selector_color_flow_id,
+    selector_helicity_id,
+)
+from .timing import (
+    ARENA_UNAVAILABLE_EXECUTION_TIMING_ABI,
+    EVALUATOR_TOTAL_SAMPLE_CONTRACT,
+    EVALUATOR_TOTAL_TIMING_ABI,
+    EVALUATOR_TOTAL_TIMING_KEY,
+    EVALUATOR_TOTAL_TIMING_SOURCE,
+    MEASURED_EXECUTION_TIMING_ABI,
+    UNAVAILABLE_STATUS,
+    evaluator_total_timing_record,
+)
+
+RELATIVE_TOLERANCE = 1.0e-12
+INDEPENDENT_RELATIVE_TOLERANCE = 1.0e-8
+MADGRAPH_RELATIVE_TOLERANCE = 1.0e-10
+ABSOLUTE_TOLERANCE = 1.0e-15
+CONDITIONED_COMPARISON_ABI = "pyamplicol-report-conditioned-comparison-v2"
+RESOLVED_SUM_VALIDATION_ABI = "pyamplicol-report-resolved-sum-validation-v2"
+RESOLVED_COMPONENT_SCALE_ABI = "pyamplicol-report-resolved-component-scale-v1"
+OTF_RECURRENCE_AUTHORITY_VALIDATION_ABI = (
+    "pyamplicol-report-on-the-fly-recurrence-authority-validation-v1"
+)
+OTF_RECURRENCE_AUTHORITY_VALIDATION_FIELD = "on_the_fly_recurrence_authority"
+OTF_COLD_WARMUP_FIELDS = frozenset(
+    {
+        "cold_warmup_elapsed_seconds",
+        "cold_warmup_run_count",
+        "cold_warmup_batch_size",
+        "cold_warmup_point_count",
+        "cold_warmup_timer_source",
+        "cold_warmup_timing_scope",
+        "cold_warmup_runtime_freshness",
+        "cold_warmup_runtime_state_evidence",
+        "cold_warmup_runtime_state_before",
+        "cold_warmup_runtime_state_after",
+        "cold_warmup_runtime_cold_before_first_evaluation",
+        "cold_warmup_runtime_retained_before_first_evaluation",
+        "cold_warmup_runtime_retained_after_first_evaluation",
+        "cold_warmup_ratio_eligible",
+        "cold_warmup_acceptance_eligible",
+    }
+)
+CONVENTIONAL_WARMUP_FIELDS = frozenset(
+    {
+        "warmup_elapsed_seconds",
+        "warmup_configured_run_count",
+        "warmup_batch_size",
+        "warmup_point_count",
+        "warmup_run_outer_wall_seconds",
+        "first_warmup_run_outer_wall_seconds",
+        "warmup_timer_source",
+        "warmup_timing_scope",
+    }
+)
+WARMUP_TIMER_SOURCE = "python_outer_time.perf_counter"
+OTF_COLD_WARMUP_TIMING_SCOPE = (
+    "one initial requested-selector Runtime evaluation on the full benchmark "
+    "batch; artifact generation and Runtime/artifact load are excluded"
+)
+OTF_COLD_WARMUP_RUNTIME_FRESHNESS = "authenticated-cold"
+OTF_COLD_WARMUP_RUNTIME_RETAINED_FRESHNESS = "authenticated-already-retained"
+OTF_COLD_WARMUP_RUNTIME_FRESHNESSES = frozenset(
+    {
+        OTF_COLD_WARMUP_RUNTIME_FRESHNESS,
+        OTF_COLD_WARMUP_RUNTIME_RETAINED_FRESHNESS,
+    }
+)
+OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE = "authenticated-native-otf-census-v1"
+OTF_RUNTIME_STATE_CENSUS_KIND = "rusticol-on-the-fly-runtime-state-census-v1"
+OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY = "last-family-only"
+OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT = 1
+OTF_RUNTIME_STATE_COUNT_FIELDS = (
+    "process_preparation_count",
+    "retained_family_count",
+    "pending_family_count",
+    "retained_selection_count",
+    "retained_request_count",
+    "retained_amplitude_destination_count",
+    "retained_executor_handle_count",
+    "retained_query_local_trace_count",
+    "retained_embedded_lookup_key_count",
+    "semantic_executor_binding_count",
+)
+OTF_RUNTIME_STATE_RETAINED_BASE_POSITIVE_FIELDS = (
+    "process_preparation_count",
+    "retained_family_count",
+    "retained_selection_count",
+    "retained_request_count",
+)
+OTF_RUNTIME_STATE_RETAINED_EXECUTABLE_FIELDS = (
+    "retained_amplitude_destination_count",
+    "retained_executor_handle_count",
+    "semantic_executor_binding_count",
+)
+OTF_ACTIVE_FAMILY_COUNT_FIELDS = (
+    "query_count",
+    "union_unique_current_count",
+    "union_unique_current_component_count",
+    "union_source_rows",
+    "union_contribution_rows",
+    "union_finalization_rows",
+    "union_closure_rows",
+    "union_amplitude_destination_count",
+    "union_source_executor_call_groups",
+    "union_contribution_executor_call_groups",
+    "union_finalization_executor_call_groups",
+    "union_closure_executor_call_groups",
+)
+OTF_OPERATION_ROLES = ("source", "contribution", "finalization", "closure")
+CONVENTIONAL_WARMUP_TIMING_SCOPE = (
+    "configured benchmark warm-up iteration outer wall; includes the headline "
+    "evaluation and optional native-profile warm-up; artifact generation and "
+    "Runtime/artifact load are excluded"
+)
+_SHA256_PATTERN = re.compile(r"[0-9a-f]{64}")
+GENERATION_VALIDATION_SEED = 12345
+DEFAULT_TARGET_RUNTIME_SECONDS = 5.0
+REPORT_BENCHMARK_BATCH_SIZE = 128
+REPORT_BENCHMARK_WARMUP_RUNS = 2
+_ARENA_MINIMUM_SAMPLES = 5
+_ARENA_MAX_SAMPLES = 64
+_ARENA_MAX_CALIBRATION_BLOCKS = 4
+_ARENA_MAX_REPETITIONS = 1_000_000_000
+_ARENA_MINIMUM_TARGET_FRACTION = 0.95
+_MIB = 1024 * 1024
+_RECURRENCE_DIRECT_TEMPLATE_ABI = "pyamplicol-recurrence-direct-template-v1"
+_RECURRENCE_DIRECT_BACKEND_ABI = "rusticol.recurrence-direct-backend.v1"
+_RECURRENCE_DIRECT_CANONICALIZATION_ABI = "pyamplicol-canonical-json-v1"
+_RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI = "pyamplicol-recurrence-plane-binding-v2"
+_SYMJIT_APPLICATION_ABI = "symjit-application-storage-v3"
+_SYMJIT_PLANE_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+_RECURRENCE_JIT_SOURCE_APPLICATION_ABI = _SYMJIT_PLANE_APPLICATION_ABI
+_RECURRENCE_JIT_DIRECT_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+_RECURRENCE_JIT_SOURCE_RUNTIME_CAPABILITY = "symjit.application.complex-f64.v1"
+
+# These labels make the public-command boundary, and its two report-only
+# exceptions, explicit in returned generation/profile evidence.
+PUBLIC_CLI_COMMAND_PATH = "pyamplicol-cli-parse-resolve-dispatch-v1"
+LOADED_RUNTIME_PROFILE_COMMAND_PATH = (
+    "pyamplicol-profile-loaded-runtime-and-points-injection-v1"
+)
+PAIRED_ARENA_PROFILE_COMMAND_PATH = "pyamplicol-report-private-paired-arena-profile-v1"
+PRECOMPILED_GENERATION_COMMAND_PATH = (
+    "pyamplicol-generate-precompiled-model-injection-v1"
+)
+
+
+class RunnerError(RuntimeError):
+    """Raised when a cell cannot satisfy the report measurement contract."""
+
+
+class ProfilingTimeLimitError(RunnerError):
+    """Raised before a profiling chunk cannot fit its remaining stage budget."""
+
+
+ProfilingChunkGuard = Callable[[float | None, str], None]
+
+
+def profiling_chunk_guard(
+    deadline_monotonic: float | None,
+    *,
+    clock: Callable[[], float] | None = None,
+) -> ProfilingChunkGuard | None:
+    """Return a cheap pre-launch guard for one absolute profiling deadline."""
+
+    if deadline_monotonic is None:
+        return None
+    if not math.isfinite(deadline_monotonic) or deadline_monotonic <= 0.0:
+        raise ValueError("profiling deadline must be finite and positive")
+    selected_clock = time.monotonic if clock is None else clock
+
+    def guard(estimated_seconds: float | None, description: str) -> None:
+        if not isinstance(description, str) or not description:
+            raise ValueError("profiling chunk description must be non-empty")
+        if estimated_seconds is not None and (
+            not math.isfinite(estimated_seconds) or estimated_seconds < 0.0
+        ):
+            raise ValueError("profiling chunk estimate must be finite and non-negative")
+        remaining = deadline_monotonic - selected_clock()
+        if remaining <= 0.0 or (
+            estimated_seconds is not None and estimated_seconds > remaining
+        ):
+            estimate = (
+                "unknown" if estimated_seconds is None else f"{estimated_seconds:.6g}s"
+            )
+            raise ProfilingTimeLimitError(
+                "profiling stage has insufficient remaining budget for "
+                f"{description}: remaining={max(remaining, 0.0):.6g}s, "
+                f"estimated={estimate}"
+            )
+
+    return guard
+
+
+@dataclass(frozen=True, slots=True)
+class RunnerSettings:
+    target_runtime_seconds: float = DEFAULT_TARGET_RUNTIME_SECONDS
+    batch_size: int = REPORT_BENCHMARK_BATCH_SIZE
+    worker_cores: int = 1
+    memory_limit_bytes: int | None = None
+    warmup_runs: int = REPORT_BENCHMARK_WARMUP_RUNS
+    minimum_samples: int = 5
+    model_cache_dir: Path | None = None
+    progress: ProgressSink | None = None
+    source_revision_override: str | None = None
+    profiling_time_limit_seconds: float | None = None
+    worker_deadline_monotonic: float | None = None
+
+    def __post_init__(self) -> None:
+        if self.target_runtime_seconds <= 0.0:
+            raise ValueError("target_runtime_seconds must be positive")
+        if self.batch_size < 1:
+            raise ValueError("batch_size must be positive")
+        if self.worker_cores < 1:
+            raise ValueError("worker_cores must be positive")
+        if self.memory_limit_bytes is not None and (
+            isinstance(self.memory_limit_bytes, bool)
+            or not isinstance(self.memory_limit_bytes, int)
+            or self.memory_limit_bytes < _MIB
+        ):
+            raise ValueError("memory_limit_bytes must be at least one MiB")
+        if self.warmup_runs < 0:
+            raise ValueError("warmup_runs must be non-negative")
+        if self.minimum_samples < _ARENA_MINIMUM_SAMPLES:
+            raise ValueError(
+                f"minimum_samples must be at least {_ARENA_MINIMUM_SAMPLES}"
+            )
+        if self.progress is not None and not callable(
+            getattr(self.progress, "emit", None)
+        ):
+            raise TypeError("progress must implement ProgressSink.emit(event)")
+        if (
+            self.source_revision_override is not None
+            and not self.source_revision_override
+        ):
+            raise ValueError("source_revision_override must be non-empty")
+        for name, value in (
+            ("profiling_time_limit_seconds", self.profiling_time_limit_seconds),
+            ("worker_deadline_monotonic", self.worker_deadline_monotonic),
+        ):
+            if value is not None and (not math.isfinite(value) or value <= 0.0):
+                raise ValueError(f"{name} must be finite and positive when specified")
+
+
+@dataclass(frozen=True, slots=True)
+class SelectorContract:
+    selected_color_flow_ids: tuple[str, ...]
+    selected_color_words: tuple[tuple[int, ...], ...]
+    all_flow_helicity_ids: tuple[str, ...]
+    all_flow_source_helicities: tuple[tuple[int, int], ...]
+    point_digest: str
+
+    def __post_init__(self) -> None:
+        if not self.selected_color_flow_ids:
+            raise ValueError("selector contract requires a selected color flow")
+        if len(self.selected_color_flow_ids) != len(self.selected_color_words):
+            raise ValueError("color-flow IDs and words must have equal length")
+        if len(set(self.selected_color_flow_ids)) != len(self.selected_color_flow_ids):
+            raise ValueError("selector contract color-flow IDs must be unique")
+        if len(self.all_flow_helicity_ids) != 1:
+            raise ValueError("selector contract requires one fixed helicity")
+        if not self.all_flow_source_helicities:
+            raise ValueError("selector contract requires source helicities")
+        if len(self.point_digest) != 64:
+            raise ValueError("selector contract point digest must be SHA-256")
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "selected_color_flow_ids": list(self.selected_color_flow_ids),
+            "selected_color_words": [list(word) for word in self.selected_color_words],
+            "all_flow_helicity_ids": list(self.all_flow_helicity_ids),
+            "all_flow_source_helicities": {
+                str(label): value for label, value in self.all_flow_source_helicities
+            },
+            "point_digest": self.point_digest,
+        }
+
+    @property
+    def runtime_all_flow_helicity_ids(self) -> tuple[str, ...]:
+        """Return exact public runtime IDs for the stored physical states.
+
+        Historical original-AmpliCol contracts encoded a zero-helicity state as
+        ``0`` while generated runtime axes use the canonical signed spelling
+        ``+0``.  Treat only that textual alias as equivalent: the parsed ID must
+        reproduce every stored source state before it is canonicalized.
+        """
+
+        states = tuple(
+            state for _label, state in sorted(self.all_flow_source_helicities)
+        )
+        resolved: list[str] = []
+        for identifier in self.all_flow_helicity_ids:
+            if not identifier.startswith("h:"):
+                resolved.append(identifier)
+                continue
+            try:
+                encoded = tuple(
+                    int(token) for token in identifier.removeprefix("h:").split(",")
+                )
+            except ValueError:
+                resolved.append(identifier)
+                continue
+            if encoded != states:
+                resolved.append(identifier)
+                continue
+            resolved.append("h:" + ",".join(f"{state:+d}" for state in states))
+        return tuple(resolved)
+
+    @classmethod
+    def from_mapping(cls, value: Mapping[str, object]) -> SelectorContract:
+        raw_ids = value.get("selected_color_flow_ids")
+        raw_words = value.get("selected_color_words")
+        raw_helicities = value.get("all_flow_helicity_ids")
+        raw_sources = value.get("all_flow_source_helicities")
+        point_digest = value.get("point_digest")
+        if (
+            not isinstance(raw_ids, Sequence)
+            or isinstance(raw_ids, (str, bytes))
+            or not isinstance(raw_words, Sequence)
+            or isinstance(raw_words, (str, bytes))
+            or not isinstance(raw_helicities, Sequence)
+            or isinstance(raw_helicities, (str, bytes))
+            or not isinstance(raw_sources, Mapping)
+            or not isinstance(point_digest, str)
+        ):
+            raise ValueError("selector contract has an invalid shape")
+        return cls(
+            selected_color_flow_ids=tuple(str(item) for item in raw_ids),
+            selected_color_words=tuple(
+                tuple(int(label) for label in word)  # type: ignore[arg-type]
+                for word in raw_words
+            ),
+            all_flow_helicity_ids=tuple(str(item) for item in raw_helicities),
+            all_flow_source_helicities=tuple(
+                sorted((int(label), int(state)) for label, state in raw_sources.items())
+            ),
+            point_digest=point_digest,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class GeneratedArtifact:
+    path: Path
+    process_id: str
+    generation_seconds: float
+    model_preparation_seconds: float
+    model_preparation_reused: bool
+    requested_config: Mapping[str, object]
+    effective_config: Mapping[str, object]
+    generation_command_path: str | None = None
+    numerical_relation_correctness: Mapping[str, object] | None = None
+    numerical_relation_fallback: Mapping[str, object] | None = None
+
+
+class RuntimeLike(Protocol):
+    @property
+    def physics(self) -> object: ...
+
+    def evaluate(
+        self,
+        momenta: object,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        precision: int = 16,
+    ) -> Sequence[object]: ...
+
+    def evaluate_resolved(
+        self,
+        momenta: object,
+        *,
+        helicities: Sequence[str] | None = None,
+        color_flows: Sequence[str] | None = None,
+        precision: int = 16,
+    ) -> object: ...
+
+    def clear(self) -> None: ...
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+        default=lambda item: item.tolist(),
+    ).encode("ascii")
+
+
+def _regular_file_identity(path: Path) -> tuple[int, str]:
+    """Hash one unchanged regular file through a single no-follow descriptor."""
+
+    flags = (
+        os.O_RDONLY
+        | getattr(os, "O_CLOEXEC", 0)
+        | getattr(os, "O_NOFOLLOW", 0)
+        | getattr(os, "O_BINARY", 0)
+    )
+    digest = hashlib.sha256()
+    descriptor: int | None = None
+    try:
+        descriptor = os.open(path, flags)
+        before = os.fstat(descriptor)
+        if not stat.S_ISREG(before.st_mode):
+            raise RunnerError(f"identity target is not a regular file: {path}")
+        byte_count = 0
+        with os.fdopen(descriptor, "rb", closefd=True) as stream:
+            descriptor = None
+            for block in iter(lambda: stream.read(1024 * 1024), b""):
+                digest.update(block)
+                byte_count += len(block)
+            after = os.fstat(stream.fileno())
+    except OSError as error:
+        raise RunnerError(
+            f"cannot hash regular file through a checked fd: {path}"
+        ) from error
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+    stable_fields = (
+        "st_dev",
+        "st_ino",
+        "st_mode",
+        "st_size",
+        "st_mtime_ns",
+        "st_ctime_ns",
+    )
+    if byte_count != before.st_size or any(
+        getattr(before, name) != getattr(after, name) for name in stable_fields
+    ):
+        raise RunnerError(f"identity target changed while it was hashed: {path}")
+    return byte_count, digest.hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    return _regular_file_identity(path)[1]
+
+
+def point_digest(points: object) -> str:
+    return hashlib.sha256(_canonical_json(points)).hexdigest()
+
+
+def _scale_decimal(value: object) -> Decimal:
+    """Return one finite non-negative magnitude without binary64 accumulation."""
+
+    try:
+        magnitude = abs(value)  # type: ignore[arg-type]
+        decimal = Decimal(str(magnitude))
+    except (InvalidOperation, TypeError, ValueError) as error:
+        raise RunnerError("resolved component magnitude is not numeric") from error
+    if not decimal.is_finite() or decimal < 0:
+        raise RunnerError("resolved component magnitude is not finite")
+    return decimal
+
+
+def _resolved_l1(value: object) -> Decimal:
+    to_list = getattr(value, "tolist", None)
+    if callable(to_list):
+        value = to_list()
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return sum((_resolved_l1(item) for item in value), Decimal(0))
+    return _scale_decimal(value)
+
+
+def _exact_number_text(value: object) -> str:
+    """Serialize a real component deterministically for a source binding."""
+
+    if isinstance(value, bool):
+        raise RunnerError("resolved component is boolean")
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            raise RunnerError("resolved component is not finite")
+        return value.hex()
+    number = float(value)  # validates arbitrary-precision real values cheaply
+    if not math.isfinite(number):
+        raise RunnerError("resolved component is not finite")
+    return str(value)
+
+
+def _resolved_component_payload(value: object) -> object:
+    to_list = getattr(value, "tolist", None)
+    if callable(to_list):
+        value = to_list()
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return [_resolved_component_payload(item) for item in value]
+    real = getattr(value, "real", value)
+    imag = getattr(value, "imag", 0)
+    if callable(real):
+        real = real()
+    if callable(imag):
+        imag = imag()
+    return {"real": _exact_number_text(real), "imag": _exact_number_text(imag)}
+
+
+def resolved_component_scale_evidence(
+    resolved: object,
+    points: object,
+) -> dict[str, object]:
+    """Bind per-point L1 scales to exact axes, ordering, values and momenta."""
+
+    values = getattr(resolved, "values", None)
+    to_list = getattr(values, "tolist", None)
+    if callable(to_list):
+        values = to_list()
+    if not isinstance(values, Sequence) or not values:
+        raise RunnerError("resolved evaluation does not expose point components")
+    helicity_ids = tuple(str(item) for item in getattr(resolved, "helicity_ids", ()))
+    color_flow_ids = tuple(str(item) for item in getattr(resolved, "color_ids", ()))
+    ordered = {
+        "helicity_ids": list(helicity_ids),
+        "color_flow_ids": list(color_flow_ids),
+        "values": _resolved_component_payload(values),
+    }
+    source_digest = hashlib.sha256(_canonical_json(ordered)).hexdigest()
+    ordering_digest = hashlib.sha256(
+        _canonical_json(
+            {
+                "helicity_ids": list(helicity_ids),
+                "color_flow_ids": list(color_flow_ids),
+            }
+        )
+    ).hexdigest()
+    scales: list[float] = []
+    for point_values in values:
+        scale = float(_resolved_l1(point_values))
+        if not math.isfinite(scale) or scale < 0.0:
+            raise RunnerError("resolved component L1 scale is not finite")
+        scales.append(scale)
+    return {
+        "abi": RESOLVED_COMPONENT_SCALE_ABI,
+        "point_digest": point_digest(points),
+        "helicity_ids": list(helicity_ids),
+        "color_flow_ids": list(color_flow_ids),
+        "resolved_ordering_sha256": ordering_digest,
+        "resolved_source_sha256": source_digest,
+        "scales": scales,
+    }
+
+
+def validate_conditioned_comparison_record(
+    value: object,
+    *,
+    require_binding: bool,
+) -> None:
+    """Authenticate a v2 conditioned comparison or a safely reusable v1 row."""
+
+    if not isinstance(value, Mapping):
+        raise ValueError("conditioned comparison must be an object")
+    if value.get("abi") != CONDITIONED_COMPARISON_ABI:
+        # Schema-free v1 rows can be reused only when the stored numbers
+        # recompute and satisfy the symmetric, floor-free criterion.
+        expected_v1 = {
+            "status",
+            "candidate",
+            "baseline",
+            "absolute_difference",
+            "relative_difference",
+            "relative_tolerance",
+            "absolute_tolerance",
+        }
+        if set(value) != expected_v1:
+            raise ValueError("conditioned comparison ABI is unsupported")
+        numeric: dict[str, float] = {}
+        for field in expected_v1 - {"status"}:
+            raw = value.get(field)
+            if (
+                isinstance(raw, bool)
+                or not isinstance(raw, (int, float))
+                or not math.isfinite(float(raw))
+            ):
+                raise ValueError(f"legacy comparison {field} is not finite")
+            numeric[field] = float(raw)
+        delta = abs(numeric["candidate"] - numeric["baseline"])
+        relative = delta / max(abs(numeric["baseline"]), 1.0e-300)
+        old_passed = (
+            delta <= numeric["absolute_tolerance"]
+            or relative <= numeric["relative_tolerance"]
+        )
+        safe = delta <= numeric["relative_tolerance"] * max(
+            abs(numeric["candidate"]), abs(numeric["baseline"])
+        )
+        expected_status = (
+            ResultStatus.OK.value
+            if old_passed
+            else ResultStatus.VALIDATION_FAILED.value
+        )
+        if numeric["absolute_difference"] != delta:
+            raise ValueError("legacy absolute difference was not recomputed")
+        if numeric["relative_difference"] != relative:
+            raise ValueError("legacy relative difference was not recomputed")
+        if value.get("status") != expected_status:
+            raise ValueError("legacy comparison status is inconsistent")
+        if expected_status == ResultStatus.OK.value and not safe:
+            raise ValueError("legacy comparison is not safely reusable")
+        return
+
+    expected_v2 = {
+        "abi",
+        "status",
+        "candidate",
+        "baseline",
+        "candidate_scale",
+        "baseline_scale",
+        "candidate_scale_source",
+        "baseline_scale_source",
+        "comparison_scale",
+        "absolute_difference",
+        "relative_difference",
+        "conditioned_residual",
+        "error_bound",
+        "relative_tolerance",
+        "comparison_binding",
+    }
+    if set(value) != expected_v2:
+        raise ValueError("conditioned comparison fields differ from the v2 ABI")
+    numeric = {}
+    for field in (
+        "candidate",
+        "baseline",
+        "candidate_scale",
+        "baseline_scale",
+        "comparison_scale",
+        "absolute_difference",
+        "relative_difference",
+        "conditioned_residual",
+        "error_bound",
+        "relative_tolerance",
+    ):
+        raw = value.get(field)
+        if (
+            isinstance(raw, bool)
+            or not isinstance(raw, (int, float))
+            or not math.isfinite(float(raw))
+        ):
+            raise ValueError(f"conditioned comparison {field} is not finite")
+        numeric[field] = float(raw)
+    if any(
+        numeric[field] < 0.0
+        for field in (
+            "candidate_scale",
+            "baseline_scale",
+            "comparison_scale",
+            "absolute_difference",
+            "relative_difference",
+            "conditioned_residual",
+            "error_bound",
+            "relative_tolerance",
+        )
+    ):
+        raise ValueError("conditioned comparison contains a negative magnitude")
+    for field in ("candidate_scale_source", "baseline_scale_source"):
+        raw = value.get(field)
+        if not isinstance(raw, str) or not raw:
+            raise ValueError(f"conditioned comparison {field} is invalid")
+    binding = value.get("comparison_binding")
+    if require_binding and (not isinstance(binding, Mapping) or not binding):
+        raise ValueError("conditioned comparison is not bound to its source")
+    if binding is not None and not isinstance(binding, Mapping):
+        raise ValueError("conditioned comparison binding is invalid")
+    if require_binding:
+        assert isinstance(binding, Mapping)
+        point_identity = binding.get("point_digest")
+        if not isinstance(point_identity, str) or not _SHA256_PATTERN.fullmatch(
+            point_identity
+        ):
+            raise ValueError("conditioned comparison point binding is invalid")
+        if binding.get("abi") == RESOLVED_COMPONENT_SCALE_ABI:
+            for field in ("resolved_ordering_sha256", "resolved_source_sha256"):
+                raw_digest = binding.get(field)
+                if not isinstance(raw_digest, str) or not _SHA256_PATTERN.fullmatch(
+                    raw_digest
+                ):
+                    raise ValueError(
+                        f"conditioned comparison {field} binding is invalid"
+                    )
+        else:
+            expected_binding_fields = {
+                "point_digest",
+                "selector_component_identity",
+                "selector_component_sha256",
+                "candidate_source_sha256",
+                "baseline_source_sha256",
+            }
+            if set(binding) != expected_binding_fields:
+                raise ValueError("conditioned comparison source binding fields differ")
+            selector_identity = binding.get("selector_component_identity")
+            if not isinstance(selector_identity, Mapping) or not selector_identity:
+                raise ValueError(
+                    "conditioned comparison selector/component binding is invalid"
+                )
+            expected_selector_digest = hashlib.sha256(
+                _canonical_json(selector_identity)
+            ).hexdigest()
+            if binding.get("selector_component_sha256") != expected_selector_digest:
+                raise ValueError(
+                    "conditioned comparison selector/component digest differs"
+                )
+            for field in ("candidate_source_sha256", "baseline_source_sha256"):
+                raw_digest = binding.get(field)
+                if not isinstance(raw_digest, str) or not _SHA256_PATTERN.fullmatch(
+                    raw_digest
+                ):
+                    raise ValueError(
+                        f"conditioned comparison {field} binding is invalid"
+                    )
+    candidate = numeric["candidate"]
+    baseline = numeric["baseline"]
+    candidate_scale = numeric["candidate_scale"]
+    baseline_scale = numeric["baseline_scale"]
+    if candidate_scale < abs(candidate) or baseline_scale < abs(baseline):
+        raise ValueError("conditioned comparison scale is below its value")
+    delta = abs(candidate - baseline)
+    raw_relative = delta / max(abs(baseline), 1.0e-300)
+    scale = max(abs(candidate), abs(baseline), candidate_scale, baseline_scale)
+    if scale == 0.0:
+        if candidate != 0.0 or baseline != 0.0 or delta != 0.0:
+            raise ValueError("zero scale comparison contains a nonzero value")
+        residual = 0.0
+    else:
+        residual = delta / scale
+    bound = numeric["relative_tolerance"] * scale
+    status = (
+        ResultStatus.OK.value
+        if delta <= bound
+        else ResultStatus.VALIDATION_FAILED.value
+    )
+    if (
+        numeric["comparison_scale"] != scale
+        or numeric["absolute_difference"] != delta
+        or numeric["relative_difference"] != raw_relative
+        or numeric["conditioned_residual"] != residual
+        or numeric["error_bound"] != bound
+        or value.get("status") != status
+    ):
+        raise ValueError("conditioned comparison numerical evidence is inconsistent")
+
+
+def _real_nonnegative(value: object) -> float:
+    number = complex(value)
+    if not math.isfinite(number.real) or not math.isfinite(number.imag):
+        raise RunnerError("matrix element is not finite")
+    if abs(number.imag) > 1.0e-9 * max(abs(number.real), 1.0):
+        raise RunnerError(
+            f"matrix element has a non-negligible imaginary part: {value}"
+        )
+    result = float(number.real)
+    if result < -ABSOLUTE_TOLERANCE:
+        raise RunnerError(f"matrix element is materially negative: {value}")
+    return max(result, 0.0)
+
+
+def _model_source_path(repo_root: Path, model: ModelKey) -> Path | None:
+    if model is ModelKey.BUILTIN_SM:
+        return None
+    relative = {
+        ModelKey.UFO_SM: Path("sm/sm.json"),
+        ModelKey.SCALAR_CONTACT: Path("scalars/scalars.json"),
+        ModelKey.SCALAR_GRAVITY: Path("scalar_gravity/scalar_gravity.json"),
+    }.get(model)
+    if relative is None:
+        raise RunnerError(f"model {model.value!r} is not supported by process matrices")
+    source_path = repo_root / "src/pyamplicol/assets/models/json" / relative
+    if source_path.is_file():
+        return source_path
+    resource = importlib.resources.files("pyamplicol").joinpath(
+        "assets",
+        "models",
+        "json",
+        *relative.parts,
+    )
+    if not isinstance(resource, os.PathLike):
+        raise RunnerError("installed model resources are not filesystem-backed")
+    try:
+        return Path(os.fspath(resource)).resolve(strict=True)
+    except OSError as error:
+        raise RunnerError(
+            f"installed model resource is unavailable: {relative.as_posix()}"
+        ) from error
+
+
+def config_values(
+    cell: CellSpec,
+    settings: RunnerSettings,
+    *,
+    repo_root: Path,
+) -> dict[str, object]:
+    """Return complete generation/benchmark settings for one pyAmpliCol cell."""
+
+    measurement = cell.measurement
+    if measurement.execution_mode is ExecutionMode.AMPLICOL:
+        raise RunnerError("original AmpliCol does not use the pyAmpliCol runner")
+    if measurement.model is None:
+        raise RunnerError("pyAmpliCol measurement requires an explicit model")
+    on_the_fly = measurement.execution_mode is ExecutionMode.ON_THE_FLY
+    if on_the_fly and (
+        measurement.backend != "jit" or measurement.jit_optimization_level != 2
+    ):
+        raise RunnerError("on-the-fly campaign measurements require prepared JIT O2")
+    model_path = _model_source_path(repo_root, measurement.model)
+    layout = (
+        "topology-replay"
+        if on_the_fly
+        else (
+            "all-flow-union"
+            if cell.workload is Workload.ALL_FLOW
+            else "topology-replay"
+        )
+    )
+    values: dict[str, object] = {
+        "model": {
+            "source": "built-in-sm" if model_path is None else os.fspath(model_path),
+            "cache": True,
+            "cache_dir": (
+                None
+                if settings.model_cache_dir is None
+                else os.fspath(settings.model_cache_dir)
+            ),
+        },
+        "color": {
+            "accuracy": measurement.accuracy.value,
+            "lc_flow_layout": layout,
+        },
+        "generation": {
+            "workers": settings.worker_cores,
+            "emit_api_bundle": not on_the_fly,
+            "validation": {
+                "enabled": not on_the_fly,
+                "samples": 1,
+                "seed": GENERATION_VALIDATION_SEED,
+                "relative_tolerance": RELATIVE_TOLERANCE,
+                "absolute_tolerance": 1.0e-300,
+                # The campaign immediately loads the artifact and performs its
+                # own resolved, high-precision, and authority validation.
+                "post_build_validation": False,
+            },
+            # The published campaign protocol searches for certified numerical
+            # current reuse; it is explicit here because the package default
+            # is off.
+            "relation_discovery": {"mode": "off" if on_the_fly else "certified-reuse"},
+        },
+        "evaluator": {
+            "backend": measurement.backend,
+            "execution_mode": measurement.execution_mode.value,
+            "batch_size": settings.batch_size,
+            "output_chunk_size": 512,
+            "optimization": {
+                "horner_iterations": 10,
+                "cpe_iterations": None,
+                "cores": settings.worker_cores,
+                "max_horner_variables": 1000,
+                "max_common_pair_cache_entries": 5_000_000,
+                "max_common_pair_distance": 1000,
+            },
+            "jit": {
+                "optimization_level": measurement.jit_optimization_level or 2,
+            },
+            "cpp": {"optimization": "O3"},
+        },
+        "benchmark": {
+            "target_runtime": settings.target_runtime_seconds,
+            "batch_size": settings.batch_size,
+            "warmup_runs": settings.warmup_runs,
+            "minimum_samples": settings.minimum_samples,
+        },
+        "output": {"format": "json", "progress": "off"},
+    }
+    if settings.memory_limit_bytes is not None and measurement.execution_mode in {
+        ExecutionMode.EAGER,
+        ExecutionMode.RECURRENCE,
+    }:
+        workspace_mib = settings.memory_limit_bytes // _MIB
+        evaluator = values["evaluator"]
+        assert isinstance(evaluator, dict)
+        evaluator[measurement.execution_mode.value] = {"workspace_mib": workspace_mib}
+    return values
+
+
+def _cli_override_value(value: object) -> str:
+    """Encode one config leaf using the public ``--set`` value grammar."""
+
+    if value is None:
+        return "null"
+    if isinstance(value, Path):
+        value = os.fspath(value)
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+    )
+
+
+def _cli_overrides(
+    values: Mapping[str, object],
+    *,
+    prefix: str = "",
+) -> tuple[str, ...]:
+    """Flatten config values into deterministic public ``--set`` arguments."""
+
+    arguments: list[str] = []
+    for key in sorted(values):
+        path = f"{prefix}.{key}" if prefix else key
+        value = values[key]
+        if isinstance(value, Mapping):
+            arguments.extend(_cli_overrides(value, prefix=path))
+            continue
+        arguments.extend(("--set", f"{path}={_cli_override_value(value)}"))
+    return tuple(arguments)
+
+
+def _generation_cli_argv(
+    cell: CellSpec,
+    destination: Path,
+    values: Mapping[str, object],
+) -> tuple[str, ...]:
+    """Return the exact public ``pyamplicol generate`` argument vector."""
+
+    command_values = {key: value for key, value in values.items() if key != "process"}
+    output = command_values.get("output")
+    if isinstance(output, Mapping):
+        command_values["output"] = {
+            key: value for key, value in output.items() if key != "format"
+        }
+    return (
+        "generate",
+        cell.process,
+        os.fspath(destination),
+        "--json",
+        *_cli_overrides(command_values),
+    )
+
+
+def _physics_ids(physics: object, name: str) -> tuple[str, ...]:
+    return tuple(str(item.id) for item in getattr(physics, name, ()))
+
+
+def _on_the_fly_compact_context(
+    cell: CellSpec,
+    runtime: RuntimeLike,
+) -> tuple[int, int]:
+    """Validate OTF process identity and return compact selector counts."""
+
+    backend = getattr(runtime, "_backend", runtime)
+    operation = getattr(backend, "_on_the_fly_benchmark_context", None)
+    if not callable(operation):
+        raise RunnerError("on-the-fly report runtime has no compact selector context")
+    try:
+        raw = operation(())
+    except Exception as error:
+        raise RunnerError(
+            "on-the-fly report runtime compact selector context is unavailable"
+        ) from error
+    if not isinstance(raw, Mapping):
+        raise RunnerError(
+            "on-the-fly report runtime compact selector context is invalid"
+        )
+    process_id = raw.get("process_id")
+    process_expression = raw.get("process_expression")
+    selected_color_ids = raw.get("selected_color_ids")
+    if (
+        not isinstance(process_id, str)
+        or not process_id
+        or not isinstance(process_expression, str)
+        or process_expression.casefold() != cell.process.casefold()
+        or raw.get("color_accuracy") != cell.measurement.accuracy.value
+        or not isinstance(selected_color_ids, Sequence)
+        or isinstance(selected_color_ids, (str, bytes))
+        or selected_color_ids
+    ):
+        raise RunnerError("on-the-fly report runtime compact selector identity differs")
+    counts: list[int] = []
+    for field in ("helicity_count", "color_count"):
+        value = raw.get(field)
+        if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+            raise RunnerError(f"on-the-fly report runtime compact {field} is invalid")
+        counts.append(value)
+    return counts[0], counts[1]
+
+
+def _on_the_fly_selector_ordinals(
+    runtime: RuntimeLike,
+    values: Sequence[str],
+    *,
+    name: str,
+    count: int,
+) -> tuple[int, ...]:
+    backend = getattr(runtime, "_backend", runtime)
+    operation = getattr(backend, "_point_selector_indices", None)
+    if not callable(operation):
+        raise RunnerError("on-the-fly report runtime has no compact selector resolver")
+    try:
+        raw = operation(values, name)
+    except Exception as error:
+        raise RunnerError(f"on-the-fly report runtime cannot resolve {name}") from error
+    if (
+        not isinstance(raw, Sequence)
+        or isinstance(raw, (str, bytes))
+        or len(raw) != len(values)
+        or any(
+            isinstance(value, bool)
+            or not isinstance(value, int)
+            or value < 0
+            or value >= count
+            for value in raw
+        )
+        or len(set(raw)) != len(raw)
+    ):
+        raise RunnerError(f"on-the-fly report runtime returned invalid {name} ordinals")
+    return tuple(raw)
+
+
+def validate_runtime_contract(cell: CellSpec, runtime: RuntimeLike) -> None:
+    runtime_is_on_the_fly = (
+        _runtime_execution_mode(runtime) == ExecutionMode.ON_THE_FLY.value
+    )
+    cell_is_on_the_fly = cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+    if runtime_is_on_the_fly:
+        if not cell_is_on_the_fly:
+            raise RunnerError("on-the-fly report runtime has the wrong execution mode")
+        _helicity_count, color_count = _on_the_fly_compact_context(cell, runtime)
+        if cell.measurement.accuracy is Accuracy.LC:
+            if cell.workload not in {Workload.SELECTED_FLOW, Workload.ALL_FLOW}:
+                raise RunnerError("LC on-the-fly measurement has an invalid workload")
+        elif (
+            cell.measurement.accuracy not in {Accuracy.NLC, Accuracy.FULL}
+            or cell.workload is not Workload.CONTRACTED
+            or color_count != 1
+        ):
+            raise RunnerError(
+                "contracted on-the-fly measurement has an invalid public color axis"
+            )
+        return
+    if cell_is_on_the_fly:
+        raise RunnerError("on-the-fly report runtime has the wrong execution mode")
+    physics = runtime.physics
+    accuracy = str(getattr(physics, "color_accuracy", ""))
+    if accuracy != cell.measurement.accuracy.value:
+        raise RunnerError(
+            f"artifact color accuracy {accuracy!r} does not match "
+            f"{cell.measurement.accuracy.value!r}"
+        )
+    capabilities = set(getattr(physics, "selector_capabilities", ()))
+    helicity_ids = _physics_ids(physics, "helicities")
+    if not helicity_ids:
+        raise RunnerError("artifact exposes no physical helicities")
+    if cell.measurement.accuracy is Accuracy.LC:
+        color_ids = _physics_ids(physics, "color_flows")
+        if not color_ids:
+            raise RunnerError("LC artifact exposes no physical color flows")
+        missing = {"helicity", "color_flow"} - capabilities
+        if missing:
+            raise RunnerError(
+                "LC artifact does not retain complete runtime selectors: "
+                + ", ".join(sorted(missing))
+            )
+    elif cell.workload is not Workload.CONTRACTED:
+        raise RunnerError("NLC/full measurements must use the contracted workload")
+
+
+def validate_artifact_contract(cell: CellSpec, artifact_path: Path) -> None:
+    from pyamplicol._internal.versions import (
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+        EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+        ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+        ON_THE_FLY_RUNTIME_CAPABILITY,
+        RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+    )
+    from pyamplicol.artifacts import inspect_artifact
+
+    inspection = inspect_artifact(artifact_path)
+    if len(inspection.processes) != 1:
+        raise RunnerError("report artifacts must contain exactly one process")
+    process = inspection.processes[0]
+    if process.execution_mode != cell.measurement.execution_mode.value:
+        raise RunnerError(
+            f"artifact execution mode {process.execution_mode!r} does not match "
+            f"{cell.measurement.execution_mode.value!r}"
+        )
+    if process.generation_specialized_axes:
+        raise RunnerError(
+            "report artifacts must retain complete runtime coverage; specialized "
+            f"axes: {process.generation_specialized_axes}"
+        )
+    if process.selected_source_helicities or process.selected_color_sector_ids:
+        raise RunnerError("report artifact contains forbidden generation selectors")
+    expected_runtime_capability = {
+        ExecutionMode.COMPILED: COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+        ExecutionMode.EAGER: EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        ExecutionMode.RECURRENCE: RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        ExecutionMode.ON_THE_FLY: ON_THE_FLY_RUNTIME_CAPABILITY,
+    }[cell.measurement.execution_mode]
+    runtime_capabilities = set(inspection.runtime_capabilities)
+    if expected_runtime_capability not in runtime_capabilities:
+        raise RunnerError(
+            "report artifact does not require its authenticated execution lane "
+            f"{expected_runtime_capability!r}"
+        )
+    if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY:
+        expected_color_capability = (
+            ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY
+            if cell.measurement.accuracy is Accuracy.LC
+            else ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY
+        )
+        if len(inspection.runtime_capabilities) != 2 or runtime_capabilities != {
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+            expected_color_capability,
+        }:
+            raise RunnerError(
+                "on-the-fly report artifact does not expose exactly its two "
+                "accuracy-specific runtime capabilities"
+            )
+        if cell.measurement.accuracy is not Accuracy.LC and (
+            cell.workload is not Workload.CONTRACTED
+            or process.recurrence_color_accuracy != cell.measurement.accuracy.value
+            or process.recurrence_color_storage != "expanded"
+            or process.recurrence_color_component_count != 1
+            or process.recurrence_color_group_count is None
+            or process.recurrence_color_group_count < 1
+            or process.recurrence_color_destination_count
+            != process.recurrence_color_group_count
+        ):
+            raise RunnerError(
+                "contracted on-the-fly report artifact has no authenticated "
+                "expanded color payload"
+            )
+    if cell.measurement.accuracy is Accuracy.LC:
+        expected_layout = (
+            "compact/query-local"
+            if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+            else (
+                "all-flow-union"
+                if cell.workload is Workload.ALL_FLOW
+                else "topology-replay"
+            )
+        )
+        if process.lc_flow_layout != expected_layout:
+            raise RunnerError(
+                f"artifact LC layout {process.lc_flow_layout!r} does not match "
+                f"{expected_layout!r}"
+            )
+
+
+def runtime_identity_payload(
+    cell: CellSpec,
+    runtime: object,
+    artifact_path: Path,
+    process_id: str,
+    *,
+    expected_source_revision: str,
+) -> dict[str, object]:
+    """Return the exact artifact/native-Arena identity used by one report cell."""
+
+    import pyamplicol
+    from pyamplicol._internal.versions import (
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+        COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+        EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        EAGER_DIRECT_TABLE_BINDING_ABI,
+        NATIVE_COMPILED_DIRECT_APPLICATION_ABI,
+        ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY,
+        ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY,
+        ON_THE_FLY_RUNTIME_CAPABILITY,
+        RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+        RECURRENCE_RUNTIME_LAYOUT_ABI,
+        SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+        SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+        SYMJIT_F64_RUNTIME_CAPABILITY,
+        SYMJIT_PLANE_APPLICATION_ABI,
+        _active_build_info,
+        verify_native_module,
+    )
+    from pyamplicol.artifacts import load_manifest
+
+    manifest = load_manifest(artifact_path, verify_payloads=False)
+    matches = [
+        process for process in manifest.processes if process.get("id") == process_id
+    ]
+    if len(matches) != 1:
+        raise RunnerError(
+            f"report runtime process {process_id!r} is missing or ambiguous"
+        )
+    process = matches[0]
+    loaded_artifact_id = getattr(runtime, "artifact_id", None)
+    if loaded_artifact_id != manifest.artifact_id:
+        raise RunnerError(
+            "native runtime loaded artifact identity does not match the report "
+            "artifact manifest"
+        )
+    try:
+        loaded_execution_mode = runtime.execution_mode  # type: ignore[attr-defined]
+    except Exception as exc:
+        raise RunnerError(
+            "native runtime does not expose an authenticated execution mode"
+        ) from exc
+    expected_execution_mode = cell.measurement.execution_mode.value
+    if loaded_execution_mode != expected_execution_mode:
+        raise RunnerError(
+            f"native runtime loaded execution mode {loaded_execution_mode!r} "
+            f"does not match the requested report mode {expected_execution_mode!r}"
+        )
+    required_capabilities = tuple(
+        str(value) for value in process["required_runtime_capabilities"]
+    )
+    on_the_fly_color_capability = (
+        ON_THE_FLY_LC_COLOR_RUNTIME_CAPABILITY
+        if cell.measurement.accuracy is Accuracy.LC
+        else ON_THE_FLY_CONTRACTED_COLOR_RUNTIME_CAPABILITY
+    )
+    if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY and (
+        len(required_capabilities) != 2
+        or set(required_capabilities)
+        != {
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+            on_the_fly_color_capability,
+        }
+    ):
+        raise RunnerError(
+            "on-the-fly report runtime identity requires exactly its two "
+            "accuracy-specific capabilities"
+        )
+    arena_capability, evaluator_abi, source_evaluator_abi = {
+        ExecutionMode.EAGER: (
+            EAGER_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            EAGER_DIRECT_TABLE_BINDING_ABI,
+            SYMJIT_PLANE_APPLICATION_ABI,
+        ),
+        ExecutionMode.RECURRENCE: (
+            RECURRENCE_DIRECT_ARENA_RUNTIME_CAPABILITY,
+            RECURRENCE_RUNTIME_LAYOUT_ABI,
+            (
+                SYMJIT_PLANE_APPLICATION_ABI
+                if cell.measurement.backend == "jit"
+                else {
+                    "cpp": SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+                    "asm": SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+                }.get(cell.measurement.backend)
+            ),
+        ),
+        ExecutionMode.ON_THE_FLY: (
+            ON_THE_FLY_RUNTIME_CAPABILITY,
+            "pyamplicol-runtime-on-the-fly-execution",
+            SYMJIT_PLANE_APPLICATION_ABI,
+        ),
+    }.get(
+        cell.measurement.execution_mode,
+        (
+            COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+            (
+                COMPILED_PLANE_DIRECT_APPLICATION_ABI
+                if cell.measurement.backend == "jit"
+                else NATIVE_COMPILED_DIRECT_APPLICATION_ABI
+            ),
+            (
+                SYMJIT_PLANE_APPLICATION_ABI
+                if cell.measurement.backend == "jit"
+                else NATIVE_COMPILED_DIRECT_APPLICATION_ABI
+            ),
+        ),
+    )
+    if arena_capability not in required_capabilities:
+        raise RunnerError(
+            f"report artifact process does not require {arena_capability!r}"
+        )
+    source_evaluator_runtime_capability = {
+        "jit": SYMJIT_F64_RUNTIME_CAPABILITY,
+        "cpp": SYMBOLICA_CPP_RUNTIME_CAPABILITY,
+        "asm": SYMBOLICA_ASM_RUNTIME_CAPABILITY,
+    }.get(cell.measurement.backend)
+    if source_evaluator_runtime_capability is None:
+        raise RunnerError(
+            f"report runtime has unsupported backend {cell.measurement.backend!r}"
+        )
+    native = importlib.import_module("pyamplicol._rusticol")
+    verify_native_module(native)
+    native_digest = native.native_build_inputs_sha256()
+    target = native.target_info()
+    build_info = _active_build_info()
+    if not isinstance(build_info, Mapping):
+        raise RunnerError("report runtime has no exact wheel build identity")
+    publishable = build_info.get("publishable")
+    if publishable is False:
+        build_identity_fields = (
+            "schema_version",
+            "version",
+            "candidate_fingerprint",
+            "source_revision",
+            "source_checkout",
+            "native_build_inputs_sha256",
+            "publishable",
+        )
+        candidate_build_identity = {
+            field: build_info.get(field) for field in build_identity_fields
+        }
+        if candidate_build_identity[
+            "native_build_inputs_sha256"
+        ] != native_digest or not all(
+            candidate_build_identity[field] is not None
+            for field in build_identity_fields
+        ):
+            raise RunnerError(
+                "report runtime is not a complete compatible non-publishable "
+                "candidate build"
+            )
+    elif publishable is True:
+        build_identity_fields = (
+            "schema_version",
+            "version",
+            "source_revision",
+            "publishable",
+            "selftest_fixture_bootstrap",
+        )
+        candidate_build_identity = {
+            field: build_info.get(field) for field in build_identity_fields
+        }
+        if (
+            candidate_build_identity["source_revision"] != expected_source_revision
+            or candidate_build_identity["selftest_fixture_bootstrap"] is not False
+            or not all(
+                candidate_build_identity[field] is not None
+                for field in build_identity_fields
+                if field != "selftest_fixture_bootstrap"
+            )
+        ):
+            raise RunnerError(
+                "report runtime is not a complete compatible release-wheel build"
+            )
+    else:
+        raise RunnerError("report runtime build kind is unavailable")
+    if (
+        not isinstance(native_digest, str)
+        or re.fullmatch(r"[0-9a-f]{64}", native_digest) is None
+    ):
+        raise RunnerError("native runtime build-input identity is invalid")
+    native_path = Path(str(native.__file__)).resolve(strict=True)
+    native_extension_sha256 = _sha256_file(native_path)
+    package_roots = tuple(Path(str(path)) for path in pyamplicol.__path__)
+    try:
+        if __package__.startswith("pyamplicol."):
+            package_tree = python_package_tree_identity(package_roots)
+            loaded_origin_policy = loaded_pyamplicol_origin_policy(
+                package_roots,
+                native_extension=native_path,
+            )
+        else:
+            preimport_identity = established_preimport_runtime_identity()
+            expected_package_tree = preimport_identity.get("python_package_tree")
+            expected_native_identity = preimport_identity.get("native_extension")
+            if (
+                preimport_identity.get("kind")
+                != "pyamplicol-preimport-runtime-identity-v1"
+                or not isinstance(expected_package_tree, Mapping)
+                or not isinstance(expected_native_identity, Mapping)
+            ):
+                raise RuntimeEvidenceError(
+                    "preimport runtime identity has an invalid contract"
+                )
+            package_tree = python_package_tree_identity(package_roots)
+            if dict(package_tree) != dict(expected_package_tree):
+                raise RuntimeEvidenceError(
+                    "report runtime package tree differs from its preimport identity"
+                )
+            loaded_origin_policy = loaded_pyamplicol_origin_policy(
+                package_roots,
+                native_extension=native_path,
+                expected_package_identity=dict(expected_package_tree),
+                expected_native_identity=dict(expected_native_identity),
+            )
+    except RuntimeEvidenceError as error:
+        raise RunnerError(
+            "report runtime Python namespace cannot be authenticated"
+        ) from error
+    candidate_build_identity_sha256 = hashlib.sha256(
+        _canonical_json(candidate_build_identity)
+    ).hexdigest()
+    optimization_identity: dict[str, int] = {}
+    direct_codegen_identity: dict[str, object] = {}
+    source_jit_identity: dict[str, object] = {}
+    if cell.measurement.backend == "jit":
+        source_level = cell.measurement.jit_optimization_level
+        if (
+            isinstance(source_level, bool)
+            or not isinstance(source_level, int)
+            or source_level not in {0, 1, 2, 3}
+        ):
+            raise RunnerError(
+                "JIT Arena report runtime has no valid source optimization level"
+            )
+        if (
+            cell.measurement.execution_mode
+            in {
+                ExecutionMode.EAGER,
+                ExecutionMode.RECURRENCE,
+                ExecutionMode.ON_THE_FLY,
+            }
+            and source_level != 2
+        ):
+            raise RunnerError(
+                f"{cell.measurement.execution_mode.value} JIT Arena report "
+                "runtime must use its authenticated portable O2 source"
+            )
+        optimization_identity["source_jit_optimization_level"] = source_level
+        if cell.measurement.execution_mode is ExecutionMode.COMPILED:
+            direct_codegen_identity = _authenticated_direct_codegen_identity(
+                manifest,
+                process_id=process_id,
+                source_optimization_level=source_level,
+            )
+            optimization_identity["direct_codegen_optimization_level"] = int(
+                direct_codegen_identity["optimization_level"]
+            )
+        elif cell.measurement.execution_mode is ExecutionMode.RECURRENCE:
+            source_jit_identity = _authenticated_recurrence_source_identity(
+                manifest,
+                process_id=process_id,
+                source_optimization_level=source_level,
+            )
+    elif cell.measurement.jit_optimization_level is not None:
+        raise RunnerError(
+            "non-JIT Arena report runtime unexpectedly declares a JIT "
+            "optimization level"
+        )
+    return {
+        "kind": "pyamplicol-report-runtime-identity-v1",
+        "artifact_id": manifest.artifact_id,
+        "loaded_artifact_id": loaded_artifact_id,
+        "artifact_identity_match": True,
+        "process_id": process_id,
+        "execution_mode": expected_execution_mode,
+        "loaded_execution_mode": loaded_execution_mode,
+        "backend": cell.measurement.backend,
+        "required_arena_capability": arena_capability,
+        "expected_evaluator_abi": evaluator_abi,
+        "expected_source_evaluator_abi": source_evaluator_abi,
+        "expected_source_evaluator_runtime_capability": (
+            source_evaluator_runtime_capability
+        ),
+        "process_required_runtime_capabilities": list(required_capabilities),
+        "package_version": pyamplicol.__version__,
+        "python_package_tree": package_tree,
+        "loaded_module_origin_policy": loaded_origin_policy,
+        "artifact_runtime_version": manifest.runtime["engine_version"],
+        "source_revision": expected_source_revision,
+        "candidate_build_identity": candidate_build_identity,
+        "candidate_build_identity_sha256": candidate_build_identity_sha256,
+        "native_build_inputs_sha256": native_digest,
+        "native_extension": {
+            "path": str(native_path),
+            "sha256": native_extension_sha256,
+            "package_version": str(native.package_version()),
+        },
+        "native_target": {
+            "triple": str(target.triple),
+            "cpu_features": [str(value) for value in target.cpu_features],
+        },
+        **optimization_identity,
+        **(
+            {"direct_codegen_identity": direct_codegen_identity}
+            if direct_codegen_identity
+            else {}
+        ),
+        **({"source_jit_identity": source_jit_identity} if source_jit_identity else {}),
+    }
+
+
+def _authenticated_process_execution(
+    manifest: object,
+    *,
+    process_id: str,
+) -> tuple[Mapping[str, object], str, str, Path, Sequence[object]]:
+    runtime = getattr(manifest, "runtime", None)
+    root = getattr(manifest, "root", None)
+    payloads = getattr(manifest, "payloads", None)
+    if (
+        not isinstance(runtime, Mapping)
+        or not isinstance(root, Path)
+        or not isinstance(payloads, Sequence)
+    ):
+        raise RunnerError("artifact exposes no authenticated execution payload")
+    relative = runtime.get("evaluator_manifest_path")
+    if not isinstance(relative, str) or not relative:
+        raise RunnerError("artifact runtime has no evaluator manifest path")
+    evaluator_index, _ = _authenticated_json_payload(
+        root,
+        payloads,
+        relative,
+        expected_process_id=None,
+        label="evaluator index",
+    )
+    if (
+        evaluator_index.get("kind") != "pyamplicol-runtime-execution-set"
+        or type(evaluator_index.get("schema_version")) is not int
+        or evaluator_index.get("schema_version") != 3
+    ):
+        raise RunnerError("authenticated evaluator index has an invalid contract")
+    entries = evaluator_index.get("processes")
+    if isinstance(entries, (str, bytes)) or not isinstance(entries, Sequence):
+        raise RunnerError("authenticated evaluator index has no process entries")
+    matches = [
+        entry
+        for entry in entries
+        if isinstance(entry, Mapping) and entry.get("process_id") == process_id
+    ]
+    if len(matches) != 1:
+        raise RunnerError(
+            f"authenticated evaluator index has no unique entry for {process_id!r}"
+        )
+    entry_relative = matches[0].get("manifest_path")
+    if not isinstance(entry_relative, str) or not entry_relative:
+        raise RunnerError("authenticated evaluator index entry has no manifest path")
+    entry_logical = PurePosixPath(entry_relative)
+    if (
+        entry_logical.is_absolute()
+        or not entry_logical.parts
+        or any(part in {"", ".", ".."} for part in entry_logical.parts)
+        or entry_logical.as_posix() != entry_relative
+    ):
+        raise RunnerError(
+            "authenticated evaluator index entry has a noncanonical manifest path"
+        )
+    execution_relative = (PurePosixPath(relative).parent / entry_logical).as_posix()
+    execution, actual_sha256 = _authenticated_json_payload(
+        root,
+        payloads,
+        execution_relative,
+        expected_process_id=process_id,
+        label="process execution manifest",
+    )
+    return execution, execution_relative, actual_sha256, root, payloads
+
+
+def _authenticated_symjit_plane_leaves(
+    value: object,
+    *,
+    source_optimization_level: int,
+    context: str,
+) -> list[tuple[str, str]]:
+    if not isinstance(value, Mapping):
+        raise RunnerError(f"{context} source evaluator is not an object")
+    if value.get("kind") == "chunked-symbolica-evaluator":
+        chunks = value.get("chunks")
+        if (
+            isinstance(chunks, (str, bytes))
+            or not isinstance(chunks, Sequence)
+            or not chunks
+        ):
+            raise RunnerError(f"{context} chunked source evaluator has no leaves")
+        leaves: list[tuple[str, str]] = []
+        for index, chunk in enumerate(chunks):
+            leaves.extend(
+                _authenticated_symjit_plane_leaves(
+                    chunk,
+                    source_optimization_level=source_optimization_level,
+                    context=f"{context}.chunks[{index}]",
+                )
+            )
+        return leaves
+    legacy_backend = value.get("backend")
+    input_len = value.get("input_len")
+    output_len = value.get("output_len")
+    if (
+        value.get("kind") != "symjit-application-evaluator"
+        or ("backend" in value and legacy_backend != "jit")
+        or value.get("runtime_capability") != _RECURRENCE_JIT_SOURCE_RUNTIME_CAPABILITY
+        or value.get("application_abi") != _SYMJIT_APPLICATION_ABI
+        or value.get("element_layout") != "complex-f64"
+        or value.get("batch_layout") != "row-major"
+        or value.get("compiler_type") != "native"
+        or value.get("translation_mode") not in {"direct", "indirect"}
+        or value.get("optimization_level") != source_optimization_level
+        or value.get("word_bits") != 64
+        or value.get("endianness") != "little"
+        or value.get("required_defuns") != []
+        or isinstance(input_len, bool)
+        or not isinstance(input_len, int)
+        or input_len < 0
+        or isinstance(output_len, bool)
+        or not isinstance(output_len, int)
+        or output_len < 0
+    ):
+        raise RunnerError(f"{context} source evaluator leaf contract drifted")
+    _canonical_recurrence_path(
+        value.get("application_path"),
+        f"{context} ordinary source evaluator application",
+    )
+    fallback_path = value.get("evaluator_state_path")
+    fallback_capability = value.get("evaluator_state_runtime_capability")
+    if fallback_path is None and fallback_capability is None:
+        pass
+    elif (
+        not isinstance(fallback_path, str)
+        or fallback_capability != "symbolica.legacy-jit-container.complex-f64.v1"
+    ):
+        raise RunnerError(f"{context} source evaluator fallback contract drifted")
+    else:
+        _canonical_recurrence_path(
+            fallback_path,
+            f"{context} fallback source evaluator state",
+        )
+    plane = value.get("plane_application")
+    if not isinstance(plane, Mapping):
+        raise RunnerError(f"{context} source evaluator has no plane application")
+    target = plane.get("target")
+    if (
+        plane.get("application_abi") != _SYMJIT_PLANE_APPLICATION_ABI
+        or plane.get("storage_abi") != _SYMJIT_APPLICATION_ABI
+        or plane.get("element_layout") != "split-complex-plane-major"
+        or plane.get("descriptor_order") != "inputs-re-im-then-outputs-re-im"
+        or plane.get("input_complex_count") != input_len
+        or plane.get("output_complex_count") != output_len
+        or plane.get("input_plane_count") != 2 * input_len
+        or plane.get("output_plane_count") != 2 * output_len
+        or plane.get("compiler_type") != "native"
+        or plane.get("translation_mode") != "symbolica-structured-instructions"
+        or plane.get("simd") is not True
+        or plane.get("complex") is not True
+        or plane.get("fast_math") is not True
+        or plane.get("fast_complex") is not False
+        or not isinstance(plane.get("compression"), bool)
+        or plane.get("threading") is not False
+        or plane.get("direct_arena") is not True
+        or plane.get("optimization_level") != source_optimization_level
+        or not _valid_symjit_plane_target(target)
+    ):
+        raise RunnerError(f"{context} plane application contract drifted")
+    plane_path = _canonical_recurrence_path(
+        plane.get("application_path"),
+        f"{context} plane application",
+    )
+    source_digest = _lowercase_sha256(
+        plane.get("source_digest"),
+        f"{context} plane source digest",
+    )
+    return [(plane_path, source_digest)]
+
+
+def _valid_symjit_plane_target(value: object) -> bool:
+    """Match Rusticol's canonical SymJIT plane-target object contract."""
+
+    if not isinstance(value, Mapping):
+        return False
+    allowed_fields = {"word_bits", "endianness", "triple", "cpu_features"}
+    if set(value) - allowed_fields:
+        return False
+    word_bits = value.get("word_bits")
+    if isinstance(word_bits, bool) or not isinstance(word_bits, int) or word_bits != 64:
+        return False
+    if value.get("endianness") != "little":
+        return False
+    if "triple" in value:
+        triple = value.get("triple")
+        if not isinstance(triple, str) or not triple or "\0" in triple:
+            return False
+    if "cpu_features" in value:
+        features = value.get("cpu_features")
+        if not isinstance(features, list):
+            return False
+        previous: str | None = None
+        for feature in features:
+            if (
+                not isinstance(feature, str)
+                or not feature
+                or "\0" in feature
+                or (previous is not None and previous >= feature)
+            ):
+                return False
+            previous = feature
+    return True
+
+
+def _authenticated_direct_codegen_identity(
+    manifest: object,
+    *,
+    process_id: str,
+    source_optimization_level: int,
+) -> dict[str, object]:
+    """Authenticate P-kernel lowering in one artifact-ID-bound process payload."""
+
+    execution, execution_relative, actual_sha256, _, _ = (
+        _authenticated_process_execution(manifest, process_id=process_id)
+    )
+
+    leaf_count = 0
+
+    def walk(value: object) -> None:
+        nonlocal leaf_count
+        if isinstance(value, Mapping):
+            arena = value.get("compiled_plane_arena")
+            if isinstance(arena, Mapping):
+                source_leaves = _authenticated_symjit_plane_leaves(
+                    value.get("evaluator"),
+                    source_optimization_level=source_optimization_level,
+                    context="compiled plane-Arena evaluator",
+                )
+                leaves = arena.get("leaves")
+                if (
+                    isinstance(leaves, (str, bytes))
+                    or not isinstance(leaves, Sequence)
+                    or not leaves
+                ):
+                    raise RunnerError(
+                        "compiled plane-Arena descriptor has no authenticated leaves"
+                    )
+                if len(leaves) != len(source_leaves):
+                    raise RunnerError(
+                        "compiled plane-Arena descriptor does not cover its "
+                        "authenticated plane applications"
+                    )
+                for raw_leaf, (plane_path, _source_digest) in zip(
+                    leaves,
+                    source_leaves,
+                    strict=True,
+                ):
+                    if not isinstance(raw_leaf, Mapping):
+                        raise RunnerError(
+                            "compiled plane-Arena descriptor has an invalid leaf"
+                        )
+                    if (
+                        raw_leaf.get("application_path") != plane_path
+                        or raw_leaf.get("source_application_abi")
+                        != _SYMJIT_PLANE_APPLICATION_ABI
+                        or raw_leaf.get("optimization_level")
+                        != source_optimization_level
+                        or raw_leaf.get("direct_codegen_optimization_level")
+                        != source_optimization_level
+                    ):
+                        raise RunnerError(
+                            "compiled plane-Arena leaf optimization identity drifted"
+                        )
+                    leaf_count += 1
+            for child in value.values():
+                walk(child)
+        elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+            for child in value:
+                walk(child)
+
+    walk(execution)
+    if leaf_count == 0:
+        raise RunnerError("execution payload contains no compiled plane-Arena leaves")
+    return {
+        "kind": "authenticated-compiled-plane-arena-direct-codegen-v1",
+        "optimization_level": source_optimization_level,
+        "source_optimization_level": source_optimization_level,
+        "leaf_count": leaf_count,
+        "execution_manifest_path": execution_relative,
+        "execution_manifest_sha256": actual_sha256,
+    }
+
+
+def _authenticated_recurrence_source_identity(
+    manifest: object,
+    *,
+    process_id: str,
+    source_optimization_level: int,
+) -> dict[str, object]:
+    """Bind recurrence JIT O2 to its exact source and direct-template payloads."""
+
+    execution, execution_relative, execution_sha256, root, payloads = (
+        _authenticated_process_execution(manifest, process_id=process_id)
+    )
+    if execution.get("kind") != "pyamplicol-runtime-recurrence-execution":
+        raise RunnerError("authenticated recurrence execution kind is invalid")
+    plan = execution.get("plan")
+    if not isinstance(plan, Mapping):
+        raise RunnerError("authenticated recurrence execution has no plan")
+    expected_execution_abis = {
+        "direct_template_abi": _RECURRENCE_DIRECT_TEMPLATE_ABI,
+        "direct_backend_abi": _RECURRENCE_DIRECT_BACKEND_ABI,
+    }
+    for field, expected in expected_execution_abis.items():
+        if execution.get(field) != expected or plan.get(field) != expected:
+            raise RunnerError(
+                f"authenticated recurrence execution/plan {field} drifted"
+            )
+    prepared_kernel_pack_digest = _lowercase_sha256(
+        execution.get("prepared_kernel_pack_digest"),
+        "authenticated recurrence execution prepared-kernel pack digest",
+    )
+    direct_template_catalog_digest = _lowercase_sha256(
+        execution.get("direct_template_catalog_digest"),
+        "authenticated recurrence execution direct-template catalog digest",
+    )
+    if (
+        plan.get("prepared_kernel_pack_digest") != prepared_kernel_pack_digest
+        or plan.get("direct_template_catalog_digest") != direct_template_catalog_digest
+    ):
+        raise RunnerError(
+            "authenticated recurrence execution/plan source digests drifted"
+        )
+    kernel_pack = execution.get("kernel_pack")
+    if not isinstance(kernel_pack, Mapping):
+        raise RunnerError("authenticated recurrence execution has no kernel pack")
+    pack_relative = kernel_pack.get("manifest_path")
+    if not isinstance(pack_relative, str) or not pack_relative:
+        raise RunnerError("authenticated recurrence execution has no kernel-pack path")
+    payload_root = _canonical_recurrence_path(
+        kernel_pack.get("payload_root"),
+        "authenticated recurrence kernel payload root",
+    )
+    pack, pack_sha256 = _authenticated_json_payload(
+        root,
+        payloads,
+        pack_relative,
+        expected_process_id=None,
+        label="recurrence kernel pack",
+    )
+    settings = pack.get("optimization_settings")
+    direct_catalog = pack.get("recurrence_direct_template")
+    if not isinstance(settings, Mapping) or not isinstance(direct_catalog, Mapping):
+        raise RunnerError("authenticated recurrence kernel pack is incomplete")
+    templates = direct_catalog.get("templates")
+    if (
+        pack.get("backend") != "jit"
+        or settings.get("backend") != "jit"
+        or settings.get("jit_optimization_level") != source_optimization_level
+        or direct_catalog.get("abi") != _RECURRENCE_DIRECT_TEMPLATE_ABI
+        or direct_catalog.get("backend") != "jit"
+        or direct_catalog.get("backend_abi") != _RECURRENCE_DIRECT_BACKEND_ABI
+        or direct_catalog.get("canonicalization_abi")
+        != _RECURRENCE_DIRECT_CANONICALIZATION_ABI
+        or direct_catalog.get("optimization_level") != source_optimization_level
+        or direct_catalog.get("portable") is not True
+        or isinstance(templates, (str, bytes))
+        or not isinstance(templates, Sequence)
+        or not templates
+    ):
+        raise RunnerError(
+            "authenticated recurrence direct-template optimization identity drifted"
+        )
+    if (
+        direct_catalog.get("prepared_kernel_pack_digest") != prepared_kernel_pack_digest
+        or direct_catalog.get("catalog_digest") != direct_template_catalog_digest
+    ):
+        raise RunnerError(
+            "authenticated recurrence execution and kernel-pack digests differ"
+        )
+    if _mapping_digest_without(direct_catalog, "catalog_digest") != (
+        direct_template_catalog_digest
+    ):
+        raise RunnerError(
+            "authenticated recurrence direct-template catalog digest is invalid"
+        )
+
+    evaluator_members = _authenticated_evaluator_container_members(
+        manifest,
+        root=root,
+        payloads=payloads,
+    )
+    authenticated_source_payloads: dict[str, str] = {}
+
+    def authenticate_source_payload(relative: str, *, label: str) -> str:
+        cached = authenticated_source_payloads.get(relative)
+        if cached is not None:
+            return cached
+        result = _authenticated_recurrence_source_payload(
+            root,
+            payloads,
+            evaluator_members,
+            relative,
+            label=label,
+        )
+        authenticated_source_payloads[relative] = result
+        return result
+
+    kernels = pack.get("kernels")
+    variants = pack.get("kernel_variants")
+    if (
+        isinstance(kernels, (str, bytes))
+        or not isinstance(kernels, Sequence)
+        or not kernels
+        or isinstance(variants, (str, bytes))
+        or not isinstance(variants, Sequence)
+    ):
+        raise RunnerError(
+            "authenticated recurrence kernel pack has an invalid source inventory"
+        )
+    source_leaves_by_kernel: dict[int, set[tuple[str, str]]] = {}
+    source_evaluator_leaf_count = 0
+    for index, raw_kernel in enumerate(kernels):
+        if not isinstance(raw_kernel, Mapping):
+            raise RunnerError(
+                f"authenticated recurrence kernel {index} is not an object"
+            )
+        kernel_id = raw_kernel.get("kernel_id")
+        if (
+            isinstance(kernel_id, bool)
+            or not isinstance(kernel_id, int)
+            or kernel_id < 0
+            or kernel_id in source_leaves_by_kernel
+        ):
+            raise RunnerError(
+                f"authenticated recurrence kernel {index} has an invalid kernel ID"
+            )
+        leaves = _authenticated_recurrence_source_leaves(
+            raw_kernel.get("f64_evaluator_manifest"),
+            source_optimization_level=source_optimization_level,
+            payload_root=payload_root,
+            authenticate_payload=authenticate_source_payload,
+            context=f"authenticated recurrence kernel {index}",
+        )
+        source_evaluator_leaf_count += len(leaves)
+        source_leaves_by_kernel[kernel_id] = set(leaves)
+    for index, raw_variant in enumerate(variants):
+        if not isinstance(raw_variant, Mapping):
+            raise RunnerError(
+                f"authenticated recurrence kernel variant {index} is not an object"
+            )
+        source_evaluator_leaf_count += len(
+            _authenticated_recurrence_source_leaves(
+                raw_variant.get("f64_evaluator_manifest"),
+                source_optimization_level=source_optimization_level,
+                payload_root=payload_root,
+                authenticate_payload=authenticate_source_payload,
+                context=f"authenticated recurrence kernel variant {index}",
+            )
+        )
+
+    prepared_direct_template_count = 0
+    for index, raw_template in enumerate(templates):
+        if (
+            not isinstance(raw_template, Mapping)
+            or raw_template.get("abi") != _RECURRENCE_DIRECT_TEMPLATE_ABI
+            or raw_template.get("backend") != "jit"
+            or raw_template.get("portable") is not True
+            or raw_template.get("optimization_level") != source_optimization_level
+        ):
+            raise RunnerError(
+                f"authenticated recurrence direct-template {index} contract drifted"
+            )
+        if _mapping_digest_without(raw_template, "semantic_digest") != (
+            raw_template.get("semantic_digest")
+        ):
+            raise RunnerError(
+                f"authenticated recurrence direct-template {index} digest is invalid"
+            )
+        binding = raw_template.get("payload_binding")
+        if not isinstance(binding, Mapping):
+            raise RunnerError(
+                f"authenticated recurrence direct-template {index} has no "
+                "payload binding"
+            )
+        if (
+            binding.get("abi") != _RECURRENCE_DIRECT_PAYLOAD_BINDING_ABI
+            or _recurrence_payload_binding_digest(binding)
+            != binding.get("payload_digest")
+        ):
+            raise RunnerError(
+                f"authenticated recurrence direct-template {index} "
+                "payload-binding contract is invalid"
+            )
+        binding_kind = binding.get("kind")
+        if binding_kind == "rusticol-intrinsic":
+            if (
+                binding.get("source_application_abi") is not None
+                or binding.get("direct_application_abi") is not None
+                or binding.get("source_application_path") is not None
+                or binding.get("source_application_sha256") is not None
+                or binding.get("payload_paths") != []
+                or not isinstance(binding.get("runtime_template"), str)
+                or not binding.get("runtime_template")
+            ):
+                raise RunnerError(
+                    f"authenticated recurrence direct-template {index} "
+                    "intrinsic source contract is invalid"
+                )
+            continue
+        if binding_kind != "prepared-direct-call":
+            raise RunnerError(
+                f"authenticated recurrence direct-template {index} is not executable"
+            )
+        prepared_direct_template_count += 1
+        source_path = _canonical_recurrence_path(
+            binding.get("source_application_path"),
+            (f"authenticated recurrence direct-template {index} source application"),
+        )
+        source_sha256 = _lowercase_sha256(
+            binding.get("source_application_sha256"),
+            (
+                f"authenticated recurrence direct-template {index} "
+                "source application digest"
+            ),
+        )
+        prepared_kernel_id = binding.get("prepared_kernel_id")
+        if (
+            binding.get("source_application_abi")
+            != _RECURRENCE_JIT_SOURCE_APPLICATION_ABI
+            or binding.get("direct_application_abi")
+            != _RECURRENCE_JIT_DIRECT_APPLICATION_ABI
+            or binding.get("payload_paths") != [source_path]
+            or isinstance(prepared_kernel_id, bool)
+            or not isinstance(prepared_kernel_id, int)
+            or prepared_kernel_id < 0
+            or (source_path, source_sha256)
+            not in source_leaves_by_kernel.get(prepared_kernel_id, set())
+        ):
+            raise RunnerError(
+                f"authenticated recurrence direct-template {index} source "
+                "application is not bound to its prepared kernel"
+            )
+    if prepared_direct_template_count == 0 or source_evaluator_leaf_count == 0:
+        raise RunnerError(
+            "authenticated recurrence direct-template pack has no source "
+            "application evidence"
+        )
+    return {
+        "kind": "authenticated-recurrence-direct-template-source-v1",
+        "optimization_level": source_optimization_level,
+        "direct_template_count": len(templates),
+        "prepared_direct_template_count": prepared_direct_template_count,
+        "source_evaluator_leaf_count": source_evaluator_leaf_count,
+        "source_application_abi": _RECURRENCE_JIT_SOURCE_APPLICATION_ABI,
+        "direct_application_abi": _RECURRENCE_JIT_DIRECT_APPLICATION_ABI,
+        "prepared_kernel_pack_digest": prepared_kernel_pack_digest,
+        "direct_template_catalog_digest": direct_template_catalog_digest,
+        "execution_manifest_path": execution_relative,
+        "execution_manifest_sha256": execution_sha256,
+        "kernel_pack_path": pack_relative,
+        "kernel_pack_sha256": pack_sha256,
+    }
+
+
+def _lowercase_sha256(value: object, label: str) -> str:
+    if (
+        not isinstance(value, str)
+        or len(value) != 64
+        or any(character not in "0123456789abcdef" for character in value)
+    ):
+        raise RunnerError(f"{label} is not a lowercase SHA-256")
+    return value
+
+
+def _mapping_digest_without(value: Mapping[str, object], field: str) -> str:
+    payload = dict(value)
+    payload.pop(field, None)
+    return hashlib.sha256(_canonical_json(payload)).hexdigest()
+
+
+def _recurrence_payload_binding_digest(binding: Mapping[str, object]) -> str:
+    if binding.get("kind") != "rusticol-intrinsic":
+        return _mapping_digest_without(binding, "payload_digest")
+    if binding.get("role") == "contribution":
+        fields = (
+            "abi",
+            "destination_operation",
+            "contribution_parent_permutation",
+            "intrinsic_contract_digest",
+            "kind",
+            "role",
+            "runtime_template",
+            "scalar_input_count",
+            "scalar_projections",
+        )
+        return hashlib.sha256(
+            _canonical_json({field: binding.get(field) for field in fields})
+        ).hexdigest()
+    # Source/finalization intrinsics have an opaque Rusticol implementation
+    # digest whose derivation includes semantic-catalog fields not duplicated
+    # in the payload binding.  Its exact value remains transitively bound by
+    # the recomputed template and catalog digests.
+    return _lowercase_sha256(
+        binding.get("payload_digest"),
+        "authenticated recurrence intrinsic payload digest",
+    )
+
+
+def _canonical_recurrence_path(value: object, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise RunnerError(f"{label} path is missing")
+    logical = PurePosixPath(value)
+    if (
+        logical.is_absolute()
+        or not logical.parts
+        or any(part in {"", ".", ".."} for part in logical.parts)
+        or logical.as_posix() != value
+    ):
+        raise RunnerError(f"{label} path is not canonical")
+    return value
+
+
+def _authenticated_evaluator_container_members(
+    manifest: object,
+    *,
+    root: Path,
+    payloads: Sequence[object],
+) -> Mapping[str, tuple[int, str]]:
+    extensions = getattr(manifest, "extensions", None)
+    if extensions is None:
+        return {}
+    if not isinstance(extensions, Mapping):
+        raise RunnerError("artifact evaluator payload extensions are invalid")
+    raw_container = extensions.get("evaluator_payload_container")
+    if raw_container is None:
+        return {}
+    if not isinstance(raw_container, Mapping):
+        raise RunnerError("artifact evaluator payload container is invalid")
+    required = {
+        "kind",
+        "schema_version",
+        "storage_abi",
+        "path",
+        "member_count",
+        "unpacked_size_bytes",
+        "index_sha256",
+    }
+    if (
+        set(raw_container) != required
+        or raw_container.get("kind") != "pyamplicol-evaluator-payload-container"
+        or raw_container.get("schema_version") != 1
+        or raw_container.get("storage_abi") != "pacbin-v1"
+    ):
+        raise RunnerError("artifact evaluator payload container contract drifted")
+    member_count = raw_container.get("member_count")
+    unpacked_size = raw_container.get("unpacked_size_bytes")
+    index_sha256 = _lowercase_sha256(
+        raw_container.get("index_sha256"),
+        "artifact evaluator payload container index digest",
+    )
+    if (
+        isinstance(member_count, bool)
+        or not isinstance(member_count, int)
+        or member_count < 0
+        or isinstance(unpacked_size, bool)
+        or not isinstance(unpacked_size, int)
+        or unpacked_size < 0
+    ):
+        raise RunnerError("artifact evaluator payload container inventory is invalid")
+    container_path = _canonical_recurrence_path(
+        raw_container.get("path"),
+        "artifact evaluator payload container",
+    )
+    data, _ = _authenticated_payload_bytes(
+        root,
+        payloads,
+        container_path,
+        expected_process_id=None,
+        expected_role="evaluator-state",
+        expected_media_type="application/octet-stream",
+        label="evaluator payload container",
+    )
+    try:
+        from pyamplicol.generation.evaluator_container import PacbinReader
+
+        with PacbinReader.open(io.BytesIO(data), verify_payloads=True) as reader:
+            index = reader.index
+            members = tuple(reader.members)
+    except (OSError, TypeError, ValueError) as error:
+        raise RunnerError(
+            "authenticated evaluator payload container is invalid"
+        ) from error
+    if (
+        len(members) != member_count
+        or sum(member.length for member in members) != unpacked_size
+        or index.index_sha256 != index_sha256
+    ):
+        raise RunnerError(
+            "authenticated evaluator payload container index metadata drifted"
+        )
+    return {
+        member.logical_path: (int(member.kind), member.sha256) for member in members
+    }
+
+
+def _authenticated_recurrence_source_payload(
+    root: Path,
+    payloads: Sequence[object],
+    evaluator_members: Mapping[str, tuple[int, str]],
+    relative: str,
+    *,
+    label: str,
+) -> str:
+    canonical = _canonical_recurrence_path(relative, label)
+    loose = [
+        payload for payload in payloads if getattr(payload, "path", None) == canonical
+    ]
+    packed = evaluator_members.get(canonical)
+    if len(loose) + (packed is not None) != 1:
+        raise RunnerError(f"{label} payload is missing or ambiguous")
+    if loose:
+        _, sha256 = _authenticated_payload_bytes(
+            root,
+            payloads,
+            canonical,
+            expected_process_id=None,
+            expected_role="evaluator-state",
+            expected_media_type="application/octet-stream",
+            label=label,
+        )
+        return sha256
+    assert packed is not None
+    kind, sha256 = packed
+    if kind != 1:
+        raise RunnerError(f"{label} is not a packed SymJIT application")
+    return _lowercase_sha256(sha256, f"{label} packed member digest")
+
+
+def _authenticated_recurrence_source_leaves(
+    value: object,
+    *,
+    source_optimization_level: int,
+    payload_root: str,
+    authenticate_payload: object,
+    context: str,
+) -> list[tuple[str, str]]:
+    plane_leaves = _authenticated_symjit_plane_leaves(
+        value,
+        source_optimization_level=source_optimization_level,
+        context=context,
+    )
+    if not callable(authenticate_payload):
+        raise RunnerError("recurrence source payload authenticator is invalid")
+    result: list[tuple[str, str]] = []
+    for application_path, _source_digest in plane_leaves:
+        payload_path = (
+            PurePosixPath(payload_root) / PurePosixPath(application_path)
+        ).as_posix()
+        sha256 = authenticate_payload(  # type: ignore[operator]
+            payload_path,
+            label=f"{context} plane application",
+        )
+        if not isinstance(sha256, str):
+            raise RunnerError(f"{context} plane application digest is invalid")
+        result.append((application_path, sha256))
+    return result
+
+
+def _authenticated_json_payload(
+    root: Path,
+    payloads: Sequence[object],
+    relative: str,
+    *,
+    expected_process_id: str | None,
+    label: str,
+) -> tuple[Mapping[str, object], str]:
+    """Read one declared JSON payload through one checked file descriptor."""
+
+    data, actual_sha256 = _authenticated_payload_bytes(
+        root,
+        payloads,
+        relative,
+        expected_process_id=expected_process_id,
+        expected_role="evaluator-manifest",
+        expected_media_type="application/json",
+        label=label,
+    )
+    try:
+        value = json.loads(data)
+    except json.JSONDecodeError as error:
+        raise RunnerError(f"authenticated {label} is invalid JSON") from error
+    if not isinstance(value, Mapping):
+        raise RunnerError(f"authenticated {label} is not a JSON object")
+    return value, actual_sha256
+
+
+def _authenticated_payload_bytes(
+    root: Path,
+    payloads: Sequence[object],
+    relative: str,
+    *,
+    expected_process_id: str | None,
+    expected_role: str,
+    expected_media_type: str,
+    label: str,
+) -> tuple[bytes, str]:
+    """Read exact manifest-declared bytes through one no-follow descriptor."""
+
+    logical = PurePosixPath(relative)
+    if (
+        logical.is_absolute()
+        or not logical.parts
+        or any(part in {"", ".", ".."} for part in logical.parts)
+        or logical.as_posix() != relative
+    ):
+        raise RunnerError(f"{label} path is not canonical")
+    matches = [
+        payload for payload in payloads if getattr(payload, "path", None) == relative
+    ]
+    if len(matches) != 1:
+        raise RunnerError(f"{label} payload is missing or ambiguous")
+    payload = matches[0]
+    expected_size = getattr(payload, "size_bytes", None)
+    expected_sha256 = getattr(payload, "sha256", None)
+    if (
+        getattr(payload, "role", None) != expected_role
+        or getattr(payload, "media_type", None) != expected_media_type
+        or getattr(payload, "executable", None) is not False
+        or getattr(payload, "process_id", None) != expected_process_id
+        or isinstance(expected_size, bool)
+        or not isinstance(expected_size, int)
+        or expected_size < 0
+        or not isinstance(expected_sha256, str)
+        or len(expected_sha256) != 64
+    ):
+        raise RunnerError(f"{label} has an invalid artifact declaration")
+    path = root.joinpath(*logical.parts)
+    flags = (
+        os.O_RDONLY
+        | getattr(os, "O_CLOEXEC", 0)
+        | getattr(os, "O_NOFOLLOW", 0)
+        | getattr(os, "O_BINARY", 0)
+    )
+    descriptor: int | None = None
+    try:
+        descriptor = os.open(path, flags)
+        before = os.fstat(descriptor)
+        if not stat.S_ISREG(before.st_mode) or before.st_size != expected_size:
+            raise RunnerError(f"{label} does not match its artifact declaration")
+        with os.fdopen(descriptor, "rb", closefd=True) as stream:
+            descriptor = None
+            data = stream.read(expected_size + 1)
+            after = os.fstat(stream.fileno())
+    except OSError as error:
+        raise RunnerError(f"cannot read authenticated {label}") from error
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+    stable_fields = (
+        "st_dev",
+        "st_ino",
+        "st_mode",
+        "st_size",
+        "st_mtime_ns",
+        "st_ctime_ns",
+    )
+    if any(getattr(before, name) != getattr(after, name) for name in stable_fields):
+        raise RunnerError(f"authenticated {label} changed while it was read")
+    actual_sha256 = hashlib.sha256(data).hexdigest()
+    if len(data) != expected_size or actual_sha256 != expected_sha256:
+        raise RunnerError(f"{label} does not match the artifact manifest")
+    return data, actual_sha256
+
+
+def _authenticated_effective_config(artifact_path: Path) -> Mapping[str, object]:
+    """Return the exact effective TOML declared by a generated artifact."""
+
+    from pyamplicol.artifacts import load_manifest
+
+    manifest = load_manifest(artifact_path, verify_payloads=False)
+    root = getattr(manifest, "root", None)
+    payloads = getattr(manifest, "payloads", None)
+    configuration = getattr(manifest, "configuration", None)
+    if (
+        not isinstance(root, Path)
+        or not isinstance(payloads, Sequence)
+        or not isinstance(configuration, Mapping)
+    ):
+        raise RunnerError("generated artifact exposes no effective configuration")
+    relative = configuration.get("effective_path")
+    if not isinstance(relative, str) or not relative:
+        raise RunnerError("generated artifact has no effective configuration path")
+    data, _ = _authenticated_payload_bytes(
+        root,
+        payloads,
+        relative,
+        expected_process_id=None,
+        expected_role="configuration-effective",
+        expected_media_type="application/toml",
+        label="effective configuration",
+    )
+    try:
+        value = tomllib.loads(data.decode("utf-8"))
+    except (UnicodeDecodeError, tomllib.TOMLDecodeError) as error:
+        raise RunnerError(
+            "authenticated effective configuration is invalid TOML"
+        ) from error
+    if not isinstance(value, Mapping):
+        raise RunnerError("authenticated effective configuration is not a TOML table")
+    return value
+
+
+def _artifact_numerical_relation_metadata(
+    artifact_path: Path,
+    process_id: str,
+) -> tuple[Mapping[str, object], Mapping[str, object] | None]:
+    """Read compact correctness and fallback state from one manifest load."""
+
+    from pyamplicol.artifacts import load_manifest
+    from pyamplicol.generation.recurrence_numerical_current_warmup import (
+        recurrence_numerical_relation_correctness_summary,
+        recurrence_numerical_relation_fallback_summary,
+    )
+
+    manifest = load_manifest(artifact_path, verify_payloads=False)
+    generation = manifest.extensions.get("generation")
+    concrete = (
+        generation.get("concrete_processes")
+        if isinstance(generation, Mapping)
+        else None
+    )
+    if not isinstance(concrete, Sequence) or isinstance(concrete, (str, bytes)):
+        raise RunnerError("generated artifact has no concrete-process metadata")
+    matches = tuple(
+        entry
+        for entry in concrete
+        if isinstance(entry, Mapping) and entry.get("id") == process_id
+    )
+    if len(matches) != 1:
+        raise RunnerError(
+            "generated artifact numerical relation process is missing or ambiguous"
+        )
+    filters = matches[0].get("filters")
+    relation_report = (
+        filters.get("relation_discovery") if isinstance(filters, Mapping) else None
+    )
+    if not isinstance(relation_report, Mapping):
+        raise RunnerError("generated artifact has no numerical relation report")
+    try:
+        return (
+            recurrence_numerical_relation_correctness_summary(relation_report),
+            recurrence_numerical_relation_fallback_summary(relation_report),
+        )
+    except ValueError as error:
+        raise RunnerError(str(error)) from error
+
+
+def _selector_kwargs(
+    cell: CellSpec,
+    contract: SelectorContract | None,
+) -> dict[str, tuple[str, ...] | None]:
+    if cell.measurement.accuracy is not Accuracy.LC:
+        return {"helicities": None, "color_flows": None}
+    if contract is None:
+        raise RunnerError("LC measurement requires a selector contract")
+    if cell.workload is Workload.SELECTED_FLOW:
+        return {
+            "helicities": None,
+            "color_flows": contract.selected_color_flow_ids,
+        }
+    if cell.workload is Workload.ALL_FLOW:
+        return {
+            "helicities": contract.runtime_all_flow_helicity_ids,
+            "color_flows": None,
+        }
+    raise RunnerError("LC measurement has an invalid workload")
+
+
+def derive_selector_contract(
+    runtime: RuntimeLike,
+    points: object,
+) -> SelectorContract:
+    """Select one backend-independent labelled LC flow and helicity."""
+
+    if _runtime_execution_mode(runtime) == ExecutionMode.ON_THE_FLY.value:
+        raise RunnerError(
+            "on-the-fly selector contracts must be inherited from a dense authority"
+        )
+    physics = runtime.physics
+    color_flows = tuple(getattr(physics, "color_flows", ()))
+    helicities = tuple(getattr(physics, "helicities", ()))
+    particles = tuple(getattr(physics, "external_particles", ()))
+    if not color_flows or not helicities or not particles:
+        raise RunnerError("LC selector derivation requires complete physical axes")
+
+    try:
+        words = tuple(canonical_lc_flow_word(flow.word) for flow in color_flows)
+        selected_word = canonical_lc_selector_word(words)
+    except (AttributeError, SelectorPolicyError) as error:
+        raise RunnerError(str(error)) from error
+    selected_matches = tuple(
+        flow
+        for flow, word in zip(color_flows, words, strict=True)
+        if word == selected_word
+    )
+    if len(selected_matches) != 1:
+        raise RunnerError("LC selector did not identify exactly one physical flow")
+    selected_flow = selected_matches[0]
+    expected_flow_id = selector_color_flow_id(selected_word)
+    if str(selected_flow.id) != expected_flow_id:
+        raise RunnerError("LC selector flow ID does not encode its physical word")
+
+    try:
+        pdgs = tuple(int(particle.pdg_id) for particle in particles)
+        states = fixed_selector_helicity(pdgs)
+    except (AttributeError, SelectorPolicyError, TypeError, ValueError) as error:
+        raise RunnerError(
+            "LC selector derivation requires external particle PDGs"
+        ) from error
+    helicity_matches = tuple(
+        helicity
+        for helicity in helicities
+        if tuple(int(value) for value in helicity.values) == states
+    )
+    if len(helicity_matches) != 1:
+        raise RunnerError(
+            "artifact does not expose exactly one deterministic selector helicity"
+        )
+    helicity = helicity_matches[0]
+    expected_helicity_id = selector_helicity_id(states)
+    if str(helicity.id) != expected_helicity_id:
+        raise RunnerError("LC selector helicity ID does not encode its physical states")
+
+    resolved = runtime.evaluate_resolved(
+        points,
+        color_flows=(expected_flow_id,),
+        helicities=(expected_helicity_id,),
+    )
+    components = tuple(
+        complex(component)
+        for point in getattr(resolved, "values", ())
+        for helicity_row in point
+        for component in helicity_row
+    )
+    if not components:
+        raise RunnerError("fixed-helicity selector evaluation is empty")
+    if any(
+        not math.isfinite(component.real) or not math.isfinite(component.imag)
+        for component in components
+    ):
+        raise RunnerError("fixed-helicity selector contains a non-finite component")
+    if not any(abs(component) > 0.0 for component in components):
+        raise RunnerError("canonical fixed-helicity selector is zero at report point")
+
+    labels = tuple(int(particle.label) for particle in particles)
+    if len(labels) != len(states):
+        raise RunnerError(
+            "helicity source-state axis does not match external particles"
+        )
+    return SelectorContract(
+        selected_color_flow_ids=(expected_flow_id,),
+        selected_color_words=(selected_word,),
+        all_flow_helicity_ids=(expected_helicity_id,),
+        all_flow_source_helicities=tuple(zip(labels, states, strict=True)),
+        point_digest=point_digest(points),
+    )
+
+
+def validate_selector_contract(
+    runtime: RuntimeLike,
+    contract: SelectorContract,
+    points: object,
+    *,
+    cell: CellSpec | None = None,
+) -> None:
+    if point_digest(points) != contract.point_digest:
+        raise RunnerError("selector contract and measurement point differ")
+    runtime_is_on_the_fly = (
+        _runtime_execution_mode(runtime) == ExecutionMode.ON_THE_FLY.value
+    )
+    cell_is_on_the_fly = (
+        cell is not None and cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+    )
+    if runtime_is_on_the_fly:
+        if cell is None:
+            raise RunnerError("on-the-fly selector validation requires its report cell")
+        if not cell_is_on_the_fly:
+            raise RunnerError("on-the-fly report runtime has the wrong execution mode")
+        helicity_count, color_count = _on_the_fly_compact_context(
+            cell,
+            runtime,
+        )
+        for identifier, word in zip(
+            contract.selected_color_flow_ids,
+            contract.selected_color_words,
+            strict=True,
+        ):
+            try:
+                canonical_word = canonical_lc_flow_word(word)
+            except SelectorPolicyError as error:
+                raise RunnerError(str(error)) from error
+            if canonical_word != word or selector_color_flow_id(word) != identifier:
+                raise RunnerError(
+                    f"artifact does not expose selected physical flow {identifier!r}"
+                )
+        expected_states = tuple(
+            state for _label, state in sorted(contract.all_flow_source_helicities)
+        )
+        runtime_helicity_ids = contract.runtime_all_flow_helicity_ids
+        if runtime_helicity_ids != (selector_helicity_id(expected_states),):
+            raise RunnerError(
+                "artifact does not expose selected physical helicity "
+                f"{contract.all_flow_helicity_ids[0]!r}"
+            )
+        _on_the_fly_selector_ordinals(
+            runtime,
+            contract.selected_color_flow_ids,
+            name="color_flow_by_point",
+            count=color_count,
+        )
+        _on_the_fly_selector_ordinals(
+            runtime,
+            runtime_helicity_ids,
+            name="helicity_by_point",
+            count=helicity_count,
+        )
+        return
+    if cell_is_on_the_fly:
+        raise RunnerError("on-the-fly report runtime has the wrong execution mode")
+    physics = runtime.physics
+    colors = {
+        str(flow.id): tuple(int(label) for label in flow.word)
+        for flow in getattr(physics, "color_flows", ())
+    }
+    for identifier, word in zip(
+        contract.selected_color_flow_ids,
+        contract.selected_color_words,
+        strict=True,
+    ):
+        if colors.get(identifier) != word:
+            raise RunnerError(
+                f"artifact does not expose selected physical flow {identifier!r}"
+            )
+    helicities = {
+        str(item.id): tuple(int(value) for value in item.values)
+        for item in getattr(physics, "helicities", ())
+    }
+    labels = tuple(
+        int(particle.label) for particle in getattr(physics, "external_particles", ())
+    )
+    expected_states = dict(contract.all_flow_source_helicities)
+    expected = tuple(expected_states[label] for label in labels)
+    for identifier, runtime_identifier in zip(
+        contract.all_flow_helicity_ids,
+        contract.runtime_all_flow_helicity_ids,
+        strict=True,
+    ):
+        if helicities.get(runtime_identifier) != expected:
+            raise RunnerError(
+                f"artifact does not expose selected physical helicity {identifier!r}"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class _OtfAuthorityCapture:
+    totals: tuple[float, ...]
+    helicity_ids: tuple[str, ...]
+    color_flow_ids: tuple[str, ...]
+    components: tuple[tuple[tuple[float, ...], ...], ...]
+    total_source_sha256: str
+    resolved_total_source_sha256: str
+    resolved_ordering_sha256: str
+    resolved_source_sha256: str
+    resolved_sum: dict[str, object]
+
+
+def _finite_real(value: object, label: str) -> float:
+    try:
+        number = complex(value)  # type: ignore[arg-type]
+    except (OverflowError, TypeError, ValueError) as error:
+        raise RunnerError(f"{label} is not numeric") from error
+    if not math.isfinite(number.real) or not math.isfinite(number.imag):
+        raise RunnerError(f"{label} is not finite")
+    if number.imag != 0.0:
+        raise RunnerError(f"{label} is not real")
+    return float(number.real)
+
+
+def _otf_selector_digest(cell: CellSpec, contract: SelectorContract) -> str:
+    selectors = _selector_kwargs(cell, contract)
+    return hashlib.sha256(
+        _canonical_json(
+            {
+                "accuracy": cell.measurement.accuracy.value,
+                "workload": cell.workload.value,
+                "selector_contract": contract.as_dict(),
+                "helicities": (
+                    None
+                    if selectors["helicities"] is None
+                    else list(selectors["helicities"])
+                ),
+                "color_flows": (
+                    None
+                    if selectors["color_flows"] is None
+                    else list(selectors["color_flows"])
+                ),
+            }
+        )
+    ).hexdigest()
+
+
+def _otf_runtime_artifact_id(runtime: object, label: str) -> str:
+    artifact_id = getattr(runtime, "artifact_id", None)
+    if not isinstance(artifact_id, str) or not _SHA256_PATTERN.fullmatch(artifact_id):
+        raise RunnerError(f"{label} runtime has no authenticated artifact ID")
+    return artifact_id
+
+
+def _runtime_execution_mode(runtime: object) -> str:
+    value = getattr(runtime, "execution_mode", None)
+    return value.value if isinstance(value, ExecutionMode) else str(value)
+
+
+def _capture_otf_authority_values(
+    runtime: RuntimeLike,
+    points: object,
+    *,
+    cell: CellSpec,
+    contract: SelectorContract,
+    label: str,
+) -> _OtfAuthorityCapture:
+    selectors = _selector_kwargs(cell, contract)
+    raw_totals = tuple(runtime.evaluate(points, precision=16, **selectors))
+    try:
+        expected_point_count = len(points)  # type: ignore[arg-type]
+    except TypeError as error:
+        raise RunnerError("on-the-fly authority points have no finite axis") from error
+    if expected_point_count < 1 or len(raw_totals) != expected_point_count:
+        raise RunnerError(f"{label} total point axis is empty or differs")
+    totals = tuple(_real_nonnegative(value) for value in raw_totals)
+
+    resolved = runtime.evaluate_resolved(points, precision=16, **selectors)
+    helicity_ids = tuple(str(item) for item in getattr(resolved, "helicity_ids", ()))
+    color_flow_ids = tuple(str(item) for item in getattr(resolved, "color_ids", ()))
+    if (
+        not helicity_ids
+        or not color_flow_ids
+        or any(not item for item in helicity_ids + color_flow_ids)
+        or len(set(helicity_ids)) != len(helicity_ids)
+        or len(set(color_flow_ids)) != len(color_flow_ids)
+    ):
+        raise RunnerError(f"{label} resolved axes are empty or ambiguous")
+    if cell.workload is Workload.SELECTED_FLOW and (
+        len(color_flow_ids) != len(contract.selected_color_flow_ids)
+        or set(color_flow_ids) != set(contract.selected_color_flow_ids)
+    ):
+        raise RunnerError(f"{label} resolved output ignored the selected flow")
+    if cell.workload is Workload.ALL_FLOW and (
+        len(helicity_ids) != len(contract.runtime_all_flow_helicity_ids)
+        or set(helicity_ids) != set(contract.runtime_all_flow_helicity_ids)
+    ):
+        raise RunnerError(f"{label} resolved output ignored the selected helicity")
+
+    raw_components = getattr(resolved, "values", None)
+    to_list = getattr(raw_components, "tolist", None)
+    if callable(to_list):
+        raw_components = to_list()
+    if (
+        not isinstance(raw_components, Sequence)
+        or isinstance(raw_components, (str, bytes, bytearray))
+        or len(raw_components) != expected_point_count
+    ):
+        raise RunnerError(f"{label} resolved point axis is invalid")
+    components: list[tuple[tuple[float, ...], ...]] = []
+    for point_index, raw_point in enumerate(raw_components):
+        if (
+            not isinstance(raw_point, Sequence)
+            or isinstance(raw_point, (str, bytes, bytearray))
+            or len(raw_point) != len(helicity_ids)
+        ):
+            raise RunnerError(f"{label} resolved helicity axis is invalid")
+        point_rows: list[tuple[float, ...]] = []
+        for helicity_index, raw_row in enumerate(raw_point):
+            if (
+                not isinstance(raw_row, Sequence)
+                or isinstance(raw_row, (str, bytes, bytearray))
+                or len(raw_row) != len(color_flow_ids)
+            ):
+                raise RunnerError(f"{label} resolved color-flow axis is invalid")
+            point_rows.append(
+                tuple(
+                    _finite_real(
+                        value,
+                        (
+                            f"{label} resolved component "
+                            f"{point_index}/{helicity_index}/{color_index}"
+                        ),
+                    )
+                    for color_index, value in enumerate(raw_row)
+                )
+            )
+        components.append(tuple(point_rows))
+    frozen_components = tuple(components)
+    resolved_total = getattr(resolved, "total", None)
+    if not callable(resolved_total):
+        raise RunnerError(f"{label} resolved result does not expose total()")
+    raw_resolved_totals = tuple(resolved_total())
+    if len(raw_resolved_totals) != expected_point_count:
+        raise RunnerError(f"{label} resolved total point axis differs")
+    resolved_totals = tuple(_real_nonnegative(value) for value in raw_resolved_totals)
+    resolved_sum = _otf_compact_series_summary(
+        totals,
+        resolved_totals,
+        label=f"{label} optimized/resolved sum",
+    )
+    ordering = {
+        "helicity_ids": list(helicity_ids),
+        "color_flow_ids": list(color_flow_ids),
+    }
+    return _OtfAuthorityCapture(
+        totals=totals,
+        helicity_ids=helicity_ids,
+        color_flow_ids=color_flow_ids,
+        components=frozen_components,
+        total_source_sha256=hashlib.sha256(
+            _canonical_json(_resolved_component_payload(totals))
+        ).hexdigest(),
+        resolved_total_source_sha256=hashlib.sha256(
+            _canonical_json(_resolved_component_payload(resolved_totals))
+        ).hexdigest(),
+        resolved_ordering_sha256=hashlib.sha256(_canonical_json(ordering)).hexdigest(),
+        resolved_source_sha256=hashlib.sha256(
+            _canonical_json(
+                {
+                    **ordering,
+                    "values": _resolved_component_payload(frozen_components),
+                }
+            )
+        ).hexdigest(),
+        resolved_sum=resolved_sum,
+    )
+
+
+def _otf_compact_series_summary(
+    candidate: Sequence[float],
+    authority: Sequence[float],
+    *,
+    label: str,
+    candidate_scales: Sequence[float] | None = None,
+    authority_scales: Sequence[float] | None = None,
+) -> dict[str, object]:
+    if not candidate or len(candidate) != len(authority):
+        raise RunnerError(f"{label} comparison axes are empty or differ")
+    if (candidate_scales is None) != (authority_scales is None):
+        raise RunnerError(f"{label} comparison scales must be paired")
+    if candidate_scales is not None and (
+        len(candidate_scales) != len(candidate)
+        or authority_scales is None
+        or len(authority_scales) != len(authority)
+    ):
+        raise RunnerError(f"{label} comparison scale axes differ")
+
+    if candidate_scales is None:
+        scale_pairs: Sequence[tuple[float | None, float | None]] = (
+            (None, None),
+        ) * len(candidate)
+    else:
+        assert authority_scales is not None
+        scale_pairs = tuple(zip(candidate_scales, authority_scales, strict=True))
+    records = tuple(
+        pointwise_validation(
+            candidate_value,
+            authority_value,
+            relative_tolerance=RELATIVE_TOLERANCE,
+            candidate_scale=candidate_scale,
+            baseline_scale=authority_scale,
+            candidate_scale_source=(
+                "value-magnitude"
+                if candidate_scale is None
+                else "resolved-component-l1"
+            ),
+            baseline_scale_source=(
+                "value-magnitude"
+                if authority_scale is None
+                else "resolved-component-l1"
+            ),
+        )
+        for (candidate_value, authority_value), (
+            candidate_scale,
+            authority_scale,
+        ) in zip(
+            zip(candidate, authority, strict=True),
+            scale_pairs,
+            strict=True,
+        )
+    )
+    failed = next(
+        (
+            index
+            for index, record in enumerate(records)
+            if record["status"] != ResultStatus.OK.value
+        ),
+        None,
+    )
+    if failed is not None:
+        raise RunnerError(
+            f"{label} disagrees at check {failed}: conditioned residual "
+            f"{records[failed]['conditioned_residual']!r}"
+        )
+    return {
+        "check_count": len(records),
+        "maximum_conditioned_residual": max(
+            float(record["conditioned_residual"]) for record in records
+        ),
+        "maximum_absolute_delta": max(
+            float(record["absolute_difference"]) for record in records
+        ),
+    }
+
+
+def _otf_capture_comparison(
+    candidate: _OtfAuthorityCapture,
+    authority: _OtfAuthorityCapture,
+    *,
+    authority_cell_id: str,
+    label: str,
+) -> dict[str, object]:
+    total = _otf_compact_series_summary(
+        candidate.totals,
+        authority.totals,
+        label=f"{label} totals",
+    )
+    if (
+        len(candidate.helicity_ids) != len(authority.helicity_ids)
+        or set(candidate.helicity_ids) != set(authority.helicity_ids)
+        or len(candidate.color_flow_ids) != len(authority.color_flow_ids)
+        or set(candidate.color_flow_ids) != set(authority.color_flow_ids)
+    ):
+        raise RunnerError(f"{label} resolved semantic axes differ")
+    authority_helicities = {
+        identifier: index for index, identifier in enumerate(authority.helicity_ids)
+    }
+    authority_colors = {
+        identifier: index for index, identifier in enumerate(authority.color_flow_ids)
+    }
+    candidate_values: list[float] = []
+    authority_values: list[float] = []
+    candidate_scales: list[float] = []
+    authority_scales: list[float] = []
+    component_count = len(candidate.helicity_ids) * len(candidate.color_flow_ids)
+    for point_index in range(len(candidate.components)):
+        candidate_point = candidate.components[point_index]
+        authority_point = tuple(
+            tuple(
+                authority.components[point_index][authority_helicities[helicity_id]][
+                    authority_colors[color_id]
+                ]
+                for color_id in candidate.color_flow_ids
+            )
+            for helicity_id in candidate.helicity_ids
+        )
+        candidate_scales.extend(
+            [float(_resolved_l1(candidate_point))] * component_count
+        )
+        authority_scales.extend(
+            [float(_resolved_l1(authority_point))] * component_count
+        )
+        for candidate_row, authority_row in zip(
+            candidate_point,
+            authority_point,
+            strict=True,
+        ):
+            for candidate_value, authority_value in zip(
+                candidate_row,
+                authority_row,
+                strict=True,
+            ):
+                candidate_values.append(candidate_value)
+                authority_values.append(authority_value)
+    resolved = _otf_compact_series_summary(
+        candidate_values,
+        authority_values,
+        label=f"{label} resolved components",
+        candidate_scales=candidate_scales,
+        authority_scales=authority_scales,
+    )
+    resolved["component_count"] = component_count
+    return {
+        "authority_cell_id": authority_cell_id,
+        "total": total,
+        "resolved_components": resolved,
+    }
+
+
+def _otf_stage_record(
+    candidate: _OtfAuthorityCapture,
+    authority_cell: CellSpec,
+    authority: _OtfAuthorityCapture,
+    *,
+    stage: str,
+) -> dict[str, object]:
+    return {
+        "candidate_total_source_sha256": candidate.total_source_sha256,
+        "candidate_resolved_total_source_sha256": (
+            candidate.resolved_total_source_sha256
+        ),
+        "candidate_resolved_ordering_sha256": (candidate.resolved_ordering_sha256),
+        "candidate_resolved_source_sha256": candidate.resolved_source_sha256,
+        "candidate_resolved_sum": candidate.resolved_sum,
+        "comparison": _otf_capture_comparison(
+            candidate,
+            authority,
+            authority_cell_id=authority_cell.cell_id,
+            label=f"on-the-fly {stage}/recurrence",
+        ),
+    }
+
+
+def on_the_fly_recurrence_authority_validation(
+    candidate: RuntimeLike,
+    points: object,
+    *,
+    cell: CellSpec,
+    selector_contract: SelectorContract,
+    authority: tuple[CellSpec, RuntimeLike],
+) -> dict[str, object]:
+    """Validate cold OTF against recurrence, then reset it for profiling."""
+
+    if (
+        cell.measurement.execution_mode is not ExecutionMode.ON_THE_FLY
+        or cell.measurement.accuracy is not Accuracy.LC
+    ):
+        raise RunnerError(
+            "recurrence-authority preflight requires an on-the-fly LC cell"
+        )
+    validate_runtime_contract(cell, candidate)
+    if _runtime_execution_mode(candidate) != ExecutionMode.ON_THE_FLY.value:
+        raise RunnerError("on-the-fly candidate runtime has the wrong execution mode")
+    validate_selector_contract(
+        candidate,
+        selector_contract,
+        points,
+        cell=cell,
+    )
+    candidate_artifact_id = _otf_runtime_artifact_id(candidate, "on-the-fly candidate")
+
+    authority_cell, authority_runtime = authority
+    if (
+        authority_cell.measurement.execution_mode is not ExecutionMode.RECURRENCE
+        or authority_cell.measurement.accuracy is not Accuracy.LC
+        or authority_cell.process_key != cell.process_key
+        or authority_cell.n_final != cell.n_final
+        or authority_cell.workload is not cell.workload
+    ):
+        raise RunnerError("on-the-fly recurrence authority cell is incompatible")
+    validate_runtime_contract(authority_cell, authority_runtime)
+    if _runtime_execution_mode(authority_runtime) != ExecutionMode.RECURRENCE.value:
+        raise RunnerError("on-the-fly recurrence authority has the wrong mode")
+    validate_selector_contract(authority_runtime, selector_contract, points)
+    authority_capture = _capture_otf_authority_values(
+        authority_runtime,
+        points,
+        cell=authority_cell,
+        contract=selector_contract,
+        label="on-the-fly recurrence authority",
+    )
+    authority_record = {
+        "cell_id": authority_cell.cell_id,
+        "artifact_id": _otf_runtime_artifact_id(
+            authority_runtime, "on-the-fly recurrence authority"
+        ),
+        "total_source_sha256": authority_capture.total_source_sha256,
+        "resolved_total_source_sha256": (
+            authority_capture.resolved_total_source_sha256
+        ),
+        "resolved_ordering_sha256": authority_capture.resolved_ordering_sha256,
+        "resolved_source_sha256": authority_capture.resolved_source_sha256,
+        "resolved_sum": authority_capture.resolved_sum,
+    }
+
+    before = _capture_otf_authority_values(
+        candidate,
+        points,
+        cell=cell,
+        contract=selector_contract,
+        label="on-the-fly candidate before clear",
+    )
+    before_record = _otf_stage_record(
+        before,
+        authority_cell,
+        authority_capture,
+        stage="before-clear",
+    )
+    clear = getattr(candidate, "clear", None)
+    if not callable(clear):
+        raise RunnerError("on-the-fly candidate does not expose Runtime.clear()")
+    clear()
+    try:
+        after = _capture_otf_authority_values(
+            candidate,
+            points,
+            cell=cell,
+            contract=selector_contract,
+            label="on-the-fly candidate after clear",
+        )
+        after_record = _otf_stage_record(
+            after,
+            authority_cell,
+            authority_capture,
+            stage="after-clear",
+        )
+    finally:
+        # The public profiler must own the next evaluation and its cold clock.
+        clear()
+
+    point_count = len(before.totals)
+    component_count = len(before.helicity_ids) * len(before.color_flow_ids)
+    record = {
+        "abi": OTF_RECURRENCE_AUTHORITY_VALIDATION_ABI,
+        "status": ResultStatus.OK.value,
+        "candidate_cell_id": cell.cell_id,
+        "candidate_artifact_id": candidate_artifact_id,
+        "workload": cell.workload.value,
+        "precision_digits": 16,
+        "relative_tolerance": RELATIVE_TOLERANCE,
+        "point_digest": point_digest(points),
+        "selector_sha256": _otf_selector_digest(cell, selector_contract),
+        "point_count": point_count,
+        "resolved_component_count": component_count,
+        "resolved_check_count": point_count * component_count,
+        "authority": authority_record,
+        "before_clear": before_record,
+        "after_clear": after_record,
+        "lifecycle": {
+            "authority_artifact_loaded_only": True,
+            "candidate_loaded_before_validation": True,
+            "validated_before_clear": True,
+            "validated_after_clear": True,
+            "clear_call_count": 2,
+            "final_clear_before_profile": True,
+        },
+    }
+    validate_on_the_fly_recurrence_authority_validation_record(
+        record,
+        expected_cell=cell,
+        selector_contract=selector_contract.as_dict(),
+        candidate_artifact_id=candidate_artifact_id,
+        expected_authority_cell_id=authority_cell.cell_id,
+    )
+    return record
+
+
+def _require_otf_sha256(value: object, field: str) -> str:
+    if not isinstance(value, str) or not _SHA256_PATTERN.fullmatch(value):
+        raise ValueError(f"on-the-fly recurrence-authority {field} is not SHA-256")
+    return value
+
+
+def _validate_otf_compact_summary(
+    value: object,
+    *,
+    field: str,
+    expected_checks: int,
+    expected_components: int | None = None,
+    relative_tolerance: float,
+) -> None:
+    if not isinstance(value, Mapping):
+        raise ValueError(f"on-the-fly recurrence-authority {field} is not an object")
+    expected = {
+        "check_count",
+        "maximum_conditioned_residual",
+        "maximum_absolute_delta",
+    }
+    if expected_components is not None:
+        expected.add("component_count")
+    check_count = value.get("check_count")
+    if (
+        set(value) != expected
+        or isinstance(check_count, bool)
+        or not isinstance(check_count, int)
+        or check_count != expected_checks
+    ):
+        raise ValueError(f"on-the-fly recurrence-authority {field} counts differ")
+    if expected_components is not None:
+        component_count = value.get("component_count")
+        if (
+            isinstance(component_count, bool)
+            or not isinstance(component_count, int)
+            or component_count != expected_components
+        ):
+            raise ValueError(
+                f"on-the-fly recurrence-authority {field} component count differs"
+            )
+    for name in ("maximum_conditioned_residual", "maximum_absolute_delta"):
+        raw = value.get(name)
+        if (
+            isinstance(raw, bool)
+            or not isinstance(raw, (int, float))
+            or not math.isfinite(float(raw))
+            or float(raw) < 0.0
+        ):
+            raise ValueError(
+                f"on-the-fly recurrence-authority {field}.{name} is invalid"
+            )
+    if float(value["maximum_conditioned_residual"]) > relative_tolerance:
+        raise ValueError(f"on-the-fly recurrence-authority {field} is not successful")
+
+
+def validate_on_the_fly_recurrence_authority_validation_record(
+    value: object,
+    *,
+    expected_cell: CellSpec | None = None,
+    selector_contract: object = None,
+    candidate_artifact_id: str | None = None,
+    expected_authority_cell_id: str | None = None,
+) -> None:
+    """Validate the compact, success-only OTF numerical preflight record."""
+
+    if not isinstance(value, Mapping):
+        raise ValueError("on-the-fly recurrence-authority validation must be an object")
+    expected_fields = {
+        "abi",
+        "status",
+        "candidate_cell_id",
+        "candidate_artifact_id",
+        "workload",
+        "precision_digits",
+        "relative_tolerance",
+        "point_digest",
+        "selector_sha256",
+        "point_count",
+        "resolved_component_count",
+        "resolved_check_count",
+        "authority",
+        "before_clear",
+        "after_clear",
+        "lifecycle",
+    }
+    if set(value) != expected_fields:
+        raise ValueError("on-the-fly recurrence-authority validation fields differ")
+    if (
+        value.get("abi") != OTF_RECURRENCE_AUTHORITY_VALIDATION_ABI
+        or value.get("status") != ResultStatus.OK.value
+        or value.get("precision_digits") != 16
+        or value.get("relative_tolerance") != RELATIVE_TOLERANCE
+    ):
+        raise ValueError("on-the-fly recurrence-authority validation header is invalid")
+    _require_otf_sha256(value.get("candidate_artifact_id"), "candidate_artifact_id")
+    _require_otf_sha256(value.get("point_digest"), "point_digest")
+    _require_otf_sha256(value.get("selector_sha256"), "selector_sha256")
+    point_count = value.get("point_count")
+    component_count = value.get("resolved_component_count")
+    check_count = value.get("resolved_check_count")
+    if (
+        isinstance(point_count, bool)
+        or not isinstance(point_count, int)
+        or point_count < 1
+        or isinstance(component_count, bool)
+        or not isinstance(component_count, int)
+        or component_count < 1
+        or check_count != point_count * component_count
+    ):
+        raise ValueError(
+            "on-the-fly recurrence-authority validation counts are invalid"
+        )
+    if (
+        candidate_artifact_id is not None
+        and value.get("candidate_artifact_id") != candidate_artifact_id
+    ):
+        raise ValueError("on-the-fly candidate artifact ID differs")
+
+    if expected_cell is not None:
+        if (
+            expected_cell.measurement.execution_mode is not ExecutionMode.ON_THE_FLY
+            or expected_cell.measurement.accuracy is not Accuracy.LC
+            or value.get("candidate_cell_id") != expected_cell.cell_id
+            or value.get("workload") != expected_cell.workload.value
+        ):
+            raise ValueError("on-the-fly recurrence-authority candidate cell differs")
+        if not isinstance(selector_contract, Mapping):
+            raise ValueError(
+                "on-the-fly recurrence-authority selector contract is absent"
+            )
+        try:
+            contract = SelectorContract.from_mapping(selector_contract)
+        except (TypeError, ValueError) as error:
+            raise ValueError(
+                "on-the-fly recurrence-authority selector contract is invalid"
+            ) from error
+        if value.get("point_digest") != contract.point_digest or value.get(
+            "selector_sha256"
+        ) != _otf_selector_digest(expected_cell, contract):
+            raise ValueError("on-the-fly recurrence-authority selector binding differs")
+    elif (
+        not isinstance(value.get("candidate_cell_id"), str)
+        or not value.get("candidate_cell_id")
+        or value.get("workload")
+        not in {
+            Workload.SELECTED_FLOW.value,
+            Workload.ALL_FLOW.value,
+        }
+    ):
+        raise ValueError(
+            "on-the-fly recurrence-authority candidate identity is invalid"
+        )
+
+    authority = value.get("authority")
+    authority_fields = {
+        "cell_id",
+        "artifact_id",
+        "total_source_sha256",
+        "resolved_total_source_sha256",
+        "resolved_ordering_sha256",
+        "resolved_source_sha256",
+        "resolved_sum",
+    }
+    if not isinstance(authority, Mapping) or set(authority) != authority_fields:
+        raise ValueError("on-the-fly recurrence-authority fields differ")
+    authority_cell_id = authority.get("cell_id")
+    if not isinstance(authority_cell_id, str) or not authority_cell_id:
+        raise ValueError("on-the-fly recurrence-authority identity is invalid")
+    if (
+        expected_authority_cell_id is not None
+        and authority_cell_id != expected_authority_cell_id
+    ):
+        raise ValueError("on-the-fly recurrence-authority catalog identity differs")
+    for field in (
+        "artifact_id",
+        "total_source_sha256",
+        "resolved_total_source_sha256",
+        "resolved_ordering_sha256",
+        "resolved_source_sha256",
+    ):
+        _require_otf_sha256(authority.get(field), f"authority.{field}")
+    _validate_otf_compact_summary(
+        authority.get("resolved_sum"),
+        field="authority.resolved_sum",
+        expected_checks=point_count,
+        relative_tolerance=RELATIVE_TOLERANCE,
+    )
+
+    for stage_name in ("before_clear", "after_clear"):
+        stage = value.get(stage_name)
+        expected_stage_fields = {
+            "candidate_total_source_sha256",
+            "candidate_resolved_total_source_sha256",
+            "candidate_resolved_ordering_sha256",
+            "candidate_resolved_source_sha256",
+            "candidate_resolved_sum",
+            "comparison",
+        }
+        if not isinstance(stage, Mapping) or set(stage) != expected_stage_fields:
+            raise ValueError(
+                f"on-the-fly recurrence-authority {stage_name} fields differ"
+            )
+        for field in (
+            "candidate_total_source_sha256",
+            "candidate_resolved_total_source_sha256",
+            "candidate_resolved_ordering_sha256",
+            "candidate_resolved_source_sha256",
+        ):
+            _require_otf_sha256(stage.get(field), f"{stage_name}.{field}")
+        _validate_otf_compact_summary(
+            stage.get("candidate_resolved_sum"),
+            field=f"{stage_name}.candidate_resolved_sum",
+            expected_checks=point_count,
+            relative_tolerance=RELATIVE_TOLERANCE,
+        )
+        comparison = stage.get("comparison")
+        if not isinstance(comparison, Mapping) or set(comparison) != {
+            "authority_cell_id",
+            "total",
+            "resolved_components",
+        }:
+            raise ValueError(
+                f"on-the-fly recurrence-authority {stage_name} comparison fields differ"
+            )
+        if comparison.get("authority_cell_id") != authority_cell_id:
+            raise ValueError(
+                f"on-the-fly recurrence-authority {stage_name} identity differs"
+            )
+        _validate_otf_compact_summary(
+            comparison.get("total"),
+            field=f"{stage_name}.comparison.total",
+            expected_checks=point_count,
+            relative_tolerance=RELATIVE_TOLERANCE,
+        )
+        _validate_otf_compact_summary(
+            comparison.get("resolved_components"),
+            field=f"{stage_name}.comparison.resolved_components",
+            expected_checks=check_count,
+            expected_components=component_count,
+            relative_tolerance=RELATIVE_TOLERANCE,
+        )
+
+    expected_lifecycle = {
+        "authority_artifact_loaded_only": True,
+        "candidate_loaded_before_validation": True,
+        "validated_before_clear": True,
+        "validated_after_clear": True,
+        "clear_call_count": 2,
+        "final_clear_before_profile": True,
+    }
+    if value.get("lifecycle") != expected_lifecycle:
+        raise ValueError("on-the-fly recurrence-authority lifecycle is invalid")
+
+
+def resolved_sum_validation(
+    runtime: RuntimeLike,
+    points: object,
+    *,
+    cell: CellSpec,
+    selector_contract: SelectorContract | None,
+    precision: int = 16,
+) -> dict[str, object]:
+    selectors = _selector_kwargs(cell, selector_contract)
+    optimized = runtime.evaluate(points, precision=precision, **selectors)
+    resolved = runtime.evaluate_resolved(points, precision=precision, **selectors)
+    totals = tuple(resolved.total())
+    if len(optimized) != len(totals):
+        raise RunnerError("optimized and resolved evaluations have different lengths")
+    scale_evidence = resolved_component_scale_evidence(resolved, points)
+    scales = scale_evidence["scales"]
+    if not isinstance(scales, list) or len(scales) != len(totals):
+        raise RunnerError("resolved scale evidence differs from evaluated points")
+
+    records: list[dict[str, object]] = []
+    for point_index, (optimized_value, resolved_value, raw_scale) in enumerate(
+        zip(optimized, totals, scales, strict=True)
+    ):
+        candidate = _real_nonnegative(optimized_value)
+        baseline = _real_nonnegative(resolved_value)
+        scale = float(raw_scale)
+        binding = {
+            field: scale_evidence[field]
+            for field in (
+                "abi",
+                "point_digest",
+                "helicity_ids",
+                "color_flow_ids",
+                "resolved_ordering_sha256",
+                "resolved_source_sha256",
+            )
+        }
+        binding["point_index"] = point_index
+        records.append(
+            pointwise_validation(
+                candidate,
+                baseline,
+                candidate_scale=max(scale, abs(candidate)),
+                baseline_scale=max(scale, abs(baseline)),
+                candidate_scale_source="resolved-component-l1",
+                baseline_scale_source="resolved-component-l1",
+                comparison_binding=binding,
+            )
+        )
+    maximum_absolute = max(
+        (float(record["absolute_difference"]) for record in records), default=0.0
+    )
+    maximum_relative = max(
+        (float(record["relative_difference"]) for record in records), default=0.0
+    )
+    maximum_conditioned = max(
+        (float(record["conditioned_residual"]) for record in records), default=0.0
+    )
+    passed = all(record["status"] == ResultStatus.OK.value for record in records)
+    return {
+        "abi": RESOLVED_SUM_VALIDATION_ABI,
+        "status": (
+            ResultStatus.OK.value if passed else ResultStatus.VALIDATION_FAILED.value
+        ),
+        "maximum_absolute_difference": maximum_absolute,
+        "maximum_relative_difference": maximum_relative,
+        "maximum_conditioned_residual": maximum_conditioned,
+        "relative_tolerance": RELATIVE_TOLERANCE,
+        "point_digest": point_digest(points),
+        "helicity_ids": list(getattr(resolved, "helicity_ids", ())),
+        "color_flow_ids": list(getattr(resolved, "color_ids", ())),
+        "resolved_ordering_sha256": scale_evidence["resolved_ordering_sha256"],
+        "resolved_source_sha256": scale_evidence["resolved_source_sha256"],
+        "scale_source": "resolved-component-l1",
+        "precision_digits": precision,
+        "points": records,
+    }
+
+
+def pointwise_validation(
+    candidate: float,
+    baseline: float,
+    *,
+    relative_tolerance: float = RELATIVE_TOLERANCE,
+    absolute_tolerance: float | None = None,
+    candidate_scale: float | None = None,
+    baseline_scale: float | None = None,
+    candidate_scale_source: str = "value-magnitude",
+    baseline_scale_source: str = "value-magnitude",
+    comparison_binding: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    """Return a scale-conditioned comparison without an absolute escape hatch.
+
+    ``absolute_tolerance`` remains an accepted keyword solely so callers from
+    the v1 API fail over without a signature break.  It is deliberately not
+    used for acceptance and must be either absent or finite/non-negative.
+    """
+
+    numbers = (candidate, baseline, relative_tolerance)
+    if any(not math.isfinite(float(value)) for value in numbers):
+        raise ValueError("pointwise values and tolerance must be finite")
+    if relative_tolerance < 0.0:
+        raise ValueError("pointwise tolerance must be non-negative")
+    if absolute_tolerance is not None and (
+        not math.isfinite(absolute_tolerance) or absolute_tolerance < 0.0
+    ):
+        raise ValueError("legacy absolute tolerance must be finite and non-negative")
+    candidate_scale = abs(candidate) if candidate_scale is None else candidate_scale
+    baseline_scale = abs(baseline) if baseline_scale is None else baseline_scale
+    if any(
+        not math.isfinite(float(value)) or value < 0.0
+        for value in (candidate_scale, baseline_scale)
+    ):
+        raise ValueError("comparison scales must be finite and non-negative")
+    if candidate_scale < abs(candidate) or baseline_scale < abs(baseline):
+        raise ValueError("comparison scale is smaller than its value magnitude")
+    absolute = abs(candidate - baseline)
+    relative = absolute / max(abs(baseline), 1.0e-300)
+    comparison_scale = max(
+        abs(candidate), abs(baseline), candidate_scale, baseline_scale
+    )
+    if comparison_scale == 0.0:
+        if candidate != 0.0 or baseline != 0.0 or absolute != 0.0:
+            raise ValueError("zero comparison scale requires exact zero values")
+        conditioned_residual = 0.0
+    else:
+        conditioned_residual = absolute / comparison_scale
+    error_bound = relative_tolerance * comparison_scale
+    passed = absolute <= error_bound
+    return {
+        "abi": CONDITIONED_COMPARISON_ABI,
+        "status": (
+            ResultStatus.OK.value if passed else ResultStatus.VALIDATION_FAILED.value
+        ),
+        "candidate": candidate,
+        "baseline": baseline,
+        "candidate_scale": candidate_scale,
+        "baseline_scale": baseline_scale,
+        "candidate_scale_source": candidate_scale_source,
+        "baseline_scale_source": baseline_scale_source,
+        "comparison_scale": comparison_scale,
+        "absolute_difference": absolute,
+        "relative_difference": relative,
+        "conditioned_residual": conditioned_residual,
+        "error_bound": error_bound,
+        "relative_tolerance": relative_tolerance,
+        "comparison_binding": (
+            None if comparison_binding is None else dict(comparison_binding)
+        ),
+    }
+
+
+def validate_resolved_sum_validation_record(value: object) -> None:
+    """Validate v2 resolved-scale evidence or an exact-zero legacy record."""
+
+    if not isinstance(value, Mapping):
+        raise ValueError("resolved-sum validation must be an object")
+    if value.get("abi") != RESOLVED_SUM_VALIDATION_ABI:
+        expected_v1 = {
+            "status",
+            "maximum_absolute_difference",
+            "maximum_relative_difference",
+            "relative_tolerance",
+            "absolute_tolerance",
+        }
+        if set(value) != expected_v1:
+            raise ValueError("resolved-sum validation ABI is unsupported")
+        numbers: dict[str, float] = {}
+        for field in expected_v1 - {"status"}:
+            raw = value.get(field)
+            if (
+                isinstance(raw, bool)
+                or not isinstance(raw, (int, float))
+                or not math.isfinite(float(raw))
+                or float(raw) < 0.0
+            ):
+                raise ValueError(f"legacy resolved-sum {field} is invalid")
+            numbers[field] = float(raw)
+        old_passed = (
+            numbers["maximum_absolute_difference"] <= numbers["absolute_tolerance"]
+            or numbers["maximum_relative_difference"] <= numbers["relative_tolerance"]
+        )
+        if value.get("status") != (
+            ResultStatus.OK.value
+            if old_passed
+            else ResultStatus.VALIDATION_FAILED.value
+        ):
+            raise ValueError("legacy resolved-sum status is inconsistent")
+        # v1 did not retain either side of each comparison, so a nonzero
+        # difference cannot be authenticated against the new symmetric scale.
+        if old_passed and numbers["maximum_absolute_difference"] != 0.0:
+            raise ValueError("legacy resolved-sum evidence is floor-only or unbound")
+        return
+
+    expected = {
+        "abi",
+        "status",
+        "maximum_absolute_difference",
+        "maximum_relative_difference",
+        "maximum_conditioned_residual",
+        "relative_tolerance",
+        "point_digest",
+        "helicity_ids",
+        "color_flow_ids",
+        "resolved_ordering_sha256",
+        "resolved_source_sha256",
+        "scale_source",
+        "precision_digits",
+        "points",
+    }
+    if set(value) != expected:
+        raise ValueError("resolved-sum validation fields differ from the v2 ABI")
+    for field in ("point_digest", "resolved_ordering_sha256", "resolved_source_sha256"):
+        raw = value.get(field)
+        if (
+            not isinstance(raw, str)
+            or len(raw) != 64
+            or any(character not in "0123456789abcdef" for character in raw)
+        ):
+            raise ValueError(f"resolved-sum {field} is not SHA-256")
+    for field in ("helicity_ids", "color_flow_ids"):
+        raw = value.get(field)
+        if not isinstance(raw, list) or any(
+            not isinstance(item, str) or not item for item in raw
+        ):
+            raise ValueError(f"resolved-sum {field} is invalid")
+    if value.get("scale_source") != "resolved-component-l1":
+        raise ValueError("resolved-sum scale source is unsupported")
+    precision = value.get("precision_digits")
+    if isinstance(precision, bool) or not isinstance(precision, int) or precision < 1:
+        raise ValueError("resolved-sum precision is invalid")
+    relative_tolerance = value.get("relative_tolerance")
+    if (
+        isinstance(relative_tolerance, bool)
+        or not isinstance(relative_tolerance, (int, float))
+        or not math.isfinite(float(relative_tolerance))
+        or float(relative_tolerance) < 0.0
+    ):
+        raise ValueError("resolved-sum relative tolerance is invalid")
+    records = value.get("points")
+    if not isinstance(records, list) or not records:
+        raise ValueError("resolved-sum points are unavailable")
+    for point_index, record in enumerate(records):
+        validate_conditioned_comparison_record(record, require_binding=True)
+        assert isinstance(record, Mapping)
+        if float(record["relative_tolerance"]) != float(relative_tolerance):
+            raise ValueError("resolved-sum point tolerance differs")
+        binding = record.get("comparison_binding")
+        if not isinstance(binding, Mapping):
+            raise ValueError("resolved-sum point binding is unavailable")
+        expected_binding = {
+            "abi": RESOLVED_COMPONENT_SCALE_ABI,
+            "point_digest": value["point_digest"],
+            "helicity_ids": value["helicity_ids"],
+            "color_flow_ids": value["color_flow_ids"],
+            "resolved_ordering_sha256": value["resolved_ordering_sha256"],
+            "resolved_source_sha256": value["resolved_source_sha256"],
+            "point_index": point_index,
+        }
+        if dict(binding) != expected_binding:
+            raise ValueError("resolved-sum point binding differs from its source")
+    maximum_absolute = max(float(record["absolute_difference"]) for record in records)
+    maximum_relative = max(float(record["relative_difference"]) for record in records)
+    maximum_conditioned = max(
+        float(record["conditioned_residual"]) for record in records
+    )
+    for field, expected_value in (
+        ("maximum_absolute_difference", maximum_absolute),
+        ("maximum_relative_difference", maximum_relative),
+        ("maximum_conditioned_residual", maximum_conditioned),
+    ):
+        raw = value.get(field)
+        if (
+            isinstance(raw, bool)
+            or not isinstance(raw, (int, float))
+            or not math.isfinite(float(raw))
+            or float(raw) != expected_value
+        ):
+            raise ValueError(f"resolved-sum {field} is inconsistent")
+    status = (
+        ResultStatus.OK.value
+        if all(record["status"] == ResultStatus.OK.value for record in records)
+        else ResultStatus.VALIDATION_FAILED.value
+    )
+    if value.get("status") != status:
+        raise ValueError("resolved-sum status is inconsistent")
+
+
+@dataclass(frozen=True, slots=True)
+class _ArenaStatistics:
+    standard_deviation: float
+    standard_error: float
+    relative_standard_error: float
+
+
+@dataclass(frozen=True, slots=True)
+class _ArenaBenchmarkResult:
+    effective_config: object
+    sample_count: int
+    wall_time_per_point: float
+    evaluator_time_per_point: None
+    evaluator_total_time_per_point: float
+    uncertainty: _ArenaStatistics
+    environment: Mapping[str, object]
+    timing_breakdown: Mapping[str, object]
+    arena_profile_evidence: Mapping[str, object]
+    evaluator_uncertainty: None = None
+
+
+def _positive_duration(value: object, name: str) -> float:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(float(value))
+        or float(value) <= 0.0
+    ):
+        raise RunnerError(f"{name} must be finite and positive")
+    return float(value)
+
+
+def _arena_benchmark_batch(points: object, batch_size: int) -> tuple[object, ...]:
+    if (
+        not isinstance(points, Sequence)
+        or isinstance(points, (str, bytes, bytearray))
+        or not points
+    ):
+        raise RunnerError("Arena report benchmark requires validation points")
+    if (
+        isinstance(batch_size, bool)
+        or not isinstance(batch_size, int)
+        or batch_size < 1
+    ):
+        raise RunnerError("Arena report benchmark batch size must be positive")
+    source = tuple(points)
+    return tuple(source[index % len(source)] for index in range(batch_size))
+
+
+def _arena_statistics(samples: Sequence[float]) -> _ArenaStatistics:
+    if len(samples) < _ARENA_MINIMUM_SAMPLES:
+        raise RunnerError(
+            f"Arena report benchmark requires at least {_ARENA_MINIMUM_SAMPLES} "
+            "timed blocks"
+        )
+    mean = statistics.fmean(samples)
+    deviation = statistics.stdev(samples)
+    error = deviation / math.sqrt(len(samples))
+    relative = error / mean
+    return _ArenaStatistics(
+        standard_deviation=deviation,
+        standard_error=error,
+        relative_standard_error=relative,
+    )
+
+
+def _calibrate_arena_repetitions(
+    timer: object,
+    batch: tuple[object, ...],
+    *,
+    target_runtime: float,
+    sample_count: int,
+    selector_arguments: Mapping[str, object],
+    progress: ProgressSink | None = None,
+    task_id: str = "report-profile:calibration",
+) -> tuple[int, list[dict[str, object]]]:
+    if not callable(timer):
+        raise RunnerError("native unprofiled wall timer is unavailable")
+    if progress is not None:
+        from pyamplicol.reporting import ProgressUpdate
+
+    target_per_block = target_runtime / sample_count
+    repetitions = 1
+    observed = _positive_duration(
+        timer(batch, repetitions, **selector_arguments),
+        "Arena wall calibration duration",
+    )
+    blocks = [{"repetitions": repetitions, "duration_seconds": observed}]
+    minimum_repetition_confirmed = False
+    if progress is not None:
+        progress.emit(
+            ProgressUpdate(
+                task_id,
+                1,
+                _ARENA_MAX_CALIBRATION_BLOCKS + 1,
+                "initial timing block",
+                {
+                    "duration_seconds": observed,
+                    "repetitions": repetitions,
+                },
+            )
+        )
+    for _ in range(_ARENA_MAX_CALIBRATION_BLOCKS):
+        estimate = math.ceil(repetitions * target_per_block / observed)
+        candidate = min(max(estimate, 1), _ARENA_MAX_REPETITIONS)
+        if candidate == repetitions:
+            # A busy worker can make the first one-repetition probe arbitrarily
+            # slow.  At the repetition floor that outlier otherwise terminates
+            # calibration immediately, even when the warmed steady-state call
+            # is orders of magnitude faster.  Confirm the floor once and use
+            # the faster observation: scheduling contention can delay a probe,
+            # but it cannot make the native work complete spuriously early.
+            if (
+                repetitions == 1
+                and observed >= target_per_block
+                and not minimum_repetition_confirmed
+            ):
+                confirmation = _positive_duration(
+                    timer(batch, repetitions, **selector_arguments),
+                    "Arena wall calibration confirmation duration",
+                )
+                blocks.append(
+                    {
+                        "repetitions": repetitions,
+                        "duration_seconds": confirmation,
+                    }
+                )
+                observed = min(observed, confirmation)
+                minimum_repetition_confirmed = True
+                if progress is not None:
+                    progress.emit(
+                        ProgressUpdate(
+                            task_id,
+                            len(blocks),
+                            _ARENA_MAX_CALIBRATION_BLOCKS + 1,
+                            "confirming minimum-repetition timing",
+                            {
+                                "duration_seconds": confirmation,
+                                "selected_duration_seconds": observed,
+                                "repetitions": repetitions,
+                            },
+                        )
+                    )
+                continue
+            break
+        repetitions = candidate
+        observed = _positive_duration(
+            timer(batch, repetitions, **selector_arguments),
+            "Arena wall calibration duration",
+        )
+        blocks.append({"repetitions": repetitions, "duration_seconds": observed})
+        if progress is not None:
+            progress.emit(
+                ProgressUpdate(
+                    task_id,
+                    len(blocks),
+                    _ARENA_MAX_CALIBRATION_BLOCKS + 1,
+                    "refining repetitions",
+                    {
+                        "duration_seconds": observed,
+                        "repetitions": repetitions,
+                    },
+                )
+            )
+        ratio = observed / target_per_block
+        if 0.75 <= ratio <= 1.5:
+            break
+    return repetitions, blocks
+
+
+def _run_arena_benchmark(
+    runtime: object,
+    points: object,
+    *,
+    execution_mode: str,
+    benchmark_config: object,
+    selectors: Mapping[str, tuple[str, ...] | None],
+    progress: ProgressSink | None = None,
+    chunk_guard: ProfilingChunkGuard | None = None,
+) -> _ArenaBenchmarkResult:
+    """Measure native wall time and authenticate a paired private Arena profile."""
+
+    if execution_mode not in {"compiled", "eager"}:
+        raise RunnerError(
+            "private warmed Arena profiling is supported only for eager and "
+            "compiled report cells"
+        )
+    timer = getattr(runtime, "_benchmark_f64_wall_time", None)
+    profiler = getattr(runtime, "_profile_arena_repeated", None)
+    if not callable(timer):
+        raise RunnerError(
+            "current report timing requires runtime._benchmark_f64_wall_time"
+        )
+    if not callable(profiler):
+        raise RunnerError(
+            "current report timing requires runtime._profile_arena_repeated"
+        )
+    target_runtime = float(getattr(benchmark_config, "target_runtime", 0.0))
+    batch_size = getattr(benchmark_config, "batch_size", None)
+    warmup_runs = getattr(benchmark_config, "warmup_runs", None)
+    minimum_samples = getattr(benchmark_config, "minimum_samples", None)
+    precision = getattr(benchmark_config, "precision", None)
+    if not math.isfinite(target_runtime) or target_runtime <= 0.0:
+        raise RunnerError("Arena report target runtime must be finite and positive")
+    if (
+        isinstance(warmup_runs, bool)
+        or not isinstance(warmup_runs, int)
+        or warmup_runs < 0
+    ):
+        raise RunnerError("Arena report warmup count is invalid")
+    if (
+        isinstance(minimum_samples, bool)
+        or not isinstance(minimum_samples, int)
+        or minimum_samples < _ARENA_MINIMUM_SAMPLES
+    ):
+        raise RunnerError(
+            f"Arena report timing requires at least {_ARENA_MINIMUM_SAMPLES} samples"
+        )
+    if precision != 16:
+        raise RunnerError("Arena report timing requires native f64 precision")
+    if progress is not None:
+        from pyamplicol.reporting import ProgressEnd, ProgressStart, ProgressUpdate
+
+    batch = _arena_benchmark_batch(points, batch_size)
+    selector_arguments: dict[str, object] = {
+        "helicities": selectors.get("helicities"),
+        "color_flows": selectors.get("color_flows"),
+        "precision": 16,
+    }
+    profile_arguments = {**selector_arguments, "include_values": False}
+    timer_seconds_per_repetition: float | None = None
+    profiler_seconds_per_repetition: float | None = None
+
+    def guarded_timer(repetitions: int) -> float:
+        nonlocal timer_seconds_per_repetition
+        estimate = (
+            None
+            if timer_seconds_per_repetition is None
+            else timer_seconds_per_repetition * repetitions
+        )
+        if chunk_guard is not None:
+            chunk_guard(estimate, f"{execution_mode} evaluator timing chunk")
+        observed = _positive_duration(
+            timer(batch, repetitions, **selector_arguments),
+            "Arena evaluator duration",
+        )
+        timer_seconds_per_repetition = observed / repetitions
+        return observed
+
+    def guarded_profiler(
+        repetitions: int,
+        *,
+        measure_elapsed: bool = True,
+    ) -> tuple[Mapping[str, object], float]:
+        nonlocal profiler_seconds_per_repetition
+        estimated_per_repetition = (
+            profiler_seconds_per_repetition
+            if profiler_seconds_per_repetition is not None
+            else timer_seconds_per_repetition
+        )
+        estimate = (
+            None
+            if estimated_per_repetition is None
+            else estimated_per_repetition * repetitions
+        )
+        if chunk_guard is not None:
+            chunk_guard(estimate, f"{execution_mode} attribution chunk")
+        started = time.perf_counter() if measure_elapsed else None
+        raw = profiler(batch, repetitions, **profile_arguments)
+        observed = (
+            (time.perf_counter() - started)
+            if started is not None
+            else (estimate or 0.0)
+        )
+        if not isinstance(raw, Mapping):
+            raise RunnerError("native warmed Arena profile is not an object")
+        if observed > 0.0:
+            profiler_seconds_per_repetition = observed / repetitions
+        return raw, observed
+
+    parent_task_id = "report-profile"
+    warmup_task_id = f"{parent_task_id}:warmup"
+    calibration_task_id = f"{parent_task_id}:calibration"
+    samples_task_id = f"{parent_task_id}:samples"
+    started = time.perf_counter()
+    active_task_id: str | None = None
+    if progress is not None:
+        progress.emit(
+            ProgressStart(
+                parent_task_id,
+                f"Profiling {execution_mode} runtime",
+                None,
+                unit="stages",
+                details={
+                    "target_runtime_seconds": target_runtime,
+                    "minimum_samples": minimum_samples,
+                },
+            )
+        )
+    try:
+        active_task_id = warmup_task_id
+        if progress is not None:
+            progress.emit(
+                ProgressStart(
+                    warmup_task_id,
+                    "Warming the native runtime",
+                    warmup_runs,
+                    parent_task_id=parent_task_id,
+                    unit="runs",
+                )
+            )
+        warmup_started = time.perf_counter()
+        for index in range(warmup_runs):
+            guarded_timer(1)
+            warmup_profile, _warmup_profile_elapsed = guarded_profiler(
+                1,
+                measure_elapsed=False,
+            )
+            try:
+                build_arena_profile_evidence(
+                    (warmup_profile,),
+                    execution_mode=execution_mode,
+                    repetitions_per_profile=1,
+                    batch_size=len(batch),
+                )
+            except ArenaProfileEvidenceError as error:
+                raise RunnerError(f"invalid warmed Arena profile: {error}") from error
+            if progress is not None:
+                progress.emit(
+                    ProgressUpdate(
+                        warmup_task_id,
+                        index + 1,
+                        warmup_runs,
+                        "runtime warmed",
+                    )
+                )
+        warmup_elapsed = time.perf_counter() - warmup_started
+        if progress is not None:
+            progress.emit(
+                ProgressEnd(
+                    warmup_task_id,
+                    elapsed_seconds=warmup_elapsed,
+                )
+            )
+        active_task_id = calibration_task_id
+        if progress is not None:
+            progress.emit(
+                ProgressStart(
+                    calibration_task_id,
+                    "Calibrating repetitions",
+                    _ARENA_MAX_CALIBRATION_BLOCKS + 1,
+                    parent_task_id=parent_task_id,
+                    unit="blocks",
+                )
+            )
+        calibration_started = time.perf_counter()
+        repetitions, calibration_blocks = _calibrate_arena_repetitions(
+            lambda _batch, repetitions, **_arguments: guarded_timer(repetitions),
+            batch,
+            target_runtime=target_runtime,
+            sample_count=minimum_samples,
+            selector_arguments=selector_arguments,
+            progress=progress,
+            task_id=calibration_task_id,
+        )
+        calibration_elapsed = time.perf_counter() - calibration_started
+        if progress is not None:
+            progress.emit(
+                ProgressEnd(
+                    calibration_task_id,
+                    elapsed_seconds=calibration_elapsed,
+                    details={
+                        "blocks": len(calibration_blocks),
+                        "repetitions": repetitions,
+                    },
+                )
+            )
+        active_task_id = samples_task_id
+        if progress is not None:
+            progress.emit(
+                ProgressStart(
+                    samples_task_id,
+                    "Measuring paired runtime samples",
+                    _ARENA_MAX_SAMPLES,
+                    parent_task_id=parent_task_id,
+                    unit="samples",
+                    details={
+                        "minimum_samples": minimum_samples,
+                        "target_runtime_seconds": target_runtime,
+                    },
+                )
+            )
+        samples_started = time.perf_counter()
+        evaluated_points = repetitions * len(batch)
+        headline_samples: list[float] = []
+        headline_durations: list[float] = []
+        evaluator_total_durations: list[float] = []
+        raw_profiles: list[Mapping[str, object]] = []
+        profile_elapsed = 0.0
+        while (
+            len(headline_samples) < minimum_samples
+            or math.fsum(headline_durations) < target_runtime
+        ):
+            if len(headline_samples) >= _ARENA_MAX_SAMPLES:
+                raise RunnerError(
+                    "Arena report benchmark could not reach its target duration "
+                    f"within {_ARENA_MAX_SAMPLES} samples"
+                )
+            headline_started = time.perf_counter()
+            evaluator_total_duration = guarded_timer(repetitions)
+            wall_duration = _positive_duration(
+                time.perf_counter() - headline_started,
+                "Arena headline wall duration",
+            )
+            headline_durations.append(wall_duration)
+            evaluator_total_durations.append(evaluator_total_duration)
+            headline_samples.append(wall_duration / evaluated_points)
+            raw_profile, raw_profile_elapsed = guarded_profiler(repetitions)
+            profile_elapsed += raw_profile_elapsed
+            raw_profiles.append(raw_profile)
+            if progress is not None:
+                progress.emit(
+                    ProgressUpdate(
+                        samples_task_id,
+                        len(headline_samples),
+                        _ARENA_MAX_SAMPLES,
+                        "sample complete",
+                        {
+                            "elapsed_seconds": math.fsum(headline_durations),
+                            "minimum_samples": minimum_samples,
+                            "target_runtime_seconds": target_runtime,
+                        },
+                    )
+                )
+        samples_elapsed = time.perf_counter() - samples_started
+        if progress is not None:
+            progress.emit(
+                ProgressEnd(
+                    samples_task_id,
+                    elapsed_seconds=samples_elapsed,
+                    details={
+                        "samples": len(headline_samples),
+                        "measured_seconds": math.fsum(headline_durations),
+                    },
+                )
+            )
+        active_task_id = None
+        try:
+            arena_evidence = build_arena_profile_evidence(
+                raw_profiles,
+                execution_mode=execution_mode,
+                repetitions_per_profile=repetitions,
+                batch_size=len(batch),
+            )
+        except ArenaProfileEvidenceError as error:
+            raise RunnerError(f"invalid warmed Arena profile: {error}") from error
+        sample_count = len(headline_samples)
+        uncertainty = _arena_statistics(headline_samples)
+    except BaseException as error:
+        if progress is not None:
+            if active_task_id is not None:
+                progress.emit(
+                    ProgressEnd(active_task_id, success=False, message=str(error))
+                )
+            progress.emit(
+                ProgressEnd(
+                    parent_task_id,
+                    success=False,
+                    message=str(error),
+                    elapsed_seconds=time.perf_counter() - started,
+                )
+            )
+        raise
+    mean_wall = statistics.fmean(headline_samples)
+    achieved_runtime = math.fsum(headline_durations)
+    evaluator_total_accumulated = math.fsum(evaluator_total_durations)
+    measured_evaluations = sample_count * repetitions
+    measured_points = measured_evaluations * len(batch)
+    evaluator_total_time_per_point = evaluator_total_accumulated / measured_points
+    profile_total_elapsed = time.perf_counter() - started
+    if progress is not None:
+        progress.emit(
+            ProgressEnd(
+                parent_task_id,
+                elapsed_seconds=profile_total_elapsed,
+            )
+        )
+    return _ArenaBenchmarkResult(
+        effective_config=benchmark_config,
+        sample_count=sample_count,
+        wall_time_per_point=mean_wall,
+        evaluator_time_per_point=None,
+        evaluator_total_time_per_point=evaluator_total_time_per_point,
+        uncertainty=uncertainty,
+        environment={
+            "wall_time_source": "runtime_core_repeated_wall_time",
+            "wall_time_sample_pass": "runtime._benchmark_f64_wall_time",
+            "evaluator_time_raw_seconds_per_point": None,
+            "evaluator_time_status": UNAVAILABLE_STATUS,
+            "evaluator_time_ratio_eligible": False,
+            "evaluator_time_sample_pass": ARENA_PROFILE_SAMPLE_PASS,
+            "evaluator_total_time_raw_seconds_per_point": (
+                evaluator_total_time_per_point
+            ),
+            "evaluator_total_time_status": "measured",
+            "evaluator_total_time_ratio_eligible": False,
+            "evaluator_total_time_source": EVALUATOR_TOTAL_TIMING_SOURCE,
+            "evaluator_total_time_sample_contract": (EVALUATOR_TOTAL_SAMPLE_CONTRACT),
+            "evaluator_total_accumulated_seconds": (evaluator_total_accumulated),
+            "timing_breakdown_sample_pass": ARENA_PROFILE_SAMPLE_PASS,
+            "profile_protocol": ARENA_PROFILE_PROTOCOL,
+            "report_command_path": PAIRED_ARENA_PROFILE_COMMAND_PATH,
+            "report_public_cli_path": None,
+            "profile_attribution_boundary": ARENA_PROFILE_BOUNDARY,
+            "profile_attribution_borrowed_flat_input": True,
+            "profile_attribution_preallocated_output": True,
+            "profile_attribution_phase_timing_scope": ARENA_PHASE_TIMING_SCOPE,
+            "profile_attribution_evaluator_timing_available": False,
+            "profile_attribution_paired_with_headline": True,
+            "profile_attribution_identical_batch": True,
+            "profile_attribution_identical_repetitions": True,
+            "execution_mode": execution_mode,
+            "evaluator_sample_count": sample_count,
+            "native_profile_sample_count": sample_count,
+            "native_profile_points_per_sample": evaluated_points,
+            "native_profile_repetitions_per_sample": repetitions,
+            "native_profile_batch_size": len(batch),
+            "timing_sample_contract": PAIRED_TIMING_SAMPLE_CONTRACT,
+            "elapsed_seconds": achieved_runtime,
+            "warmup_elapsed_seconds": warmup_elapsed,
+            "calibration_elapsed_seconds": calibration_elapsed,
+            "calibration_outer_elapsed_seconds": calibration_elapsed,
+            "measurement_phase_elapsed_seconds": samples_elapsed,
+            "profile_total_elapsed_seconds": profile_total_elapsed,
+            "completed_sample_count": sample_count,
+            "planned_sample_count": sample_count,
+            "repetitions_per_sample": repetitions,
+            "measured_point_count": measured_points,
+            "profile_attribution_evaluation_count": measured_evaluations,
+            "profile_attribution_point_count": measured_points,
+            "profile_attribution_elapsed_seconds": profile_elapsed,
+            "headline_block_durations_seconds": headline_durations,
+            "calibration": {
+                "target_seconds_per_block": (target_runtime / minimum_samples),
+                "blocks": calibration_blocks,
+            },
+            "interrupted": False,
+        },
+        timing_breakdown={
+            "sample_count": sample_count,
+            "execution_mode": execution_mode,
+            "wall_time": {
+                "mean_seconds_per_point": arena_evidence[
+                    "warmed_boundary_wall_seconds_per_point"
+                ],
+            },
+            "evaluator_call_time": None,
+            "raw_profile_samples": arena_evidence["raw_profiles"],
+        },
+        arena_profile_evidence=arena_evidence,
+    )
+
+
+def _profile_cli_argv(
+    benchmark_config: BenchmarkConfig,
+) -> tuple[str, ...]:
+    """Return public ``pyamplicol profile`` arguments for one loaded runtime."""
+
+    arguments = [
+        "profile",
+        ".pyamplicol-loaded-runtime",
+        "--target-runtime",
+        str(benchmark_config.target_runtime),
+        "--batch-size",
+        str(benchmark_config.batch_size),
+        "--precision",
+        str(benchmark_config.precision),
+        "--warmup-runs",
+        str(benchmark_config.warmup_runs),
+        "--minimum-samples",
+        str(benchmark_config.minimum_samples),
+        "--json",
+        "--progress",
+        "off",
+    ]
+    for identifier in benchmark_config.helicity_ids:
+        arguments.extend(("--helicity", str(identifier)))
+    for identifier in benchmark_config.color_flow_ids:
+        arguments.extend(("--color-flow", str(identifier)))
+    return tuple(arguments)
+
+
+def _run_report_benchmark(
+    runtime: object,
+    points: object,
+    *,
+    execution_mode: ExecutionMode,
+    benchmark_config: BenchmarkConfig,
+    selectors: Mapping[str, tuple[str, ...] | None],
+    progress: ProgressSink | None = None,
+    chunk_guard: ProfilingChunkGuard | None = None,
+) -> object:
+    """Select the authenticated timing command path without fallback.
+
+    Recurrence and on-the-fly use the public ``profile`` parser/config/dispatch
+    path.  Their narrowly scoped service override supplies the already
+    authenticated runtime and exact in-memory point set, avoiding an artifact
+    reload inside the measured campaign.  Compiled/eager retain the report-only
+    paired private Arena protocol because the public profiler does not expose
+    that paired headline/attribution boundary.
+    """
+
+    if execution_mode in {ExecutionMode.EAGER, ExecutionMode.COMPILED}:
+        backend = getattr(runtime, "_backend", None)
+        if backend is None:
+            raise RunnerError(
+                "eager/compiled report timing requires the runtime's private "
+                "native backend"
+            )
+        return _run_arena_benchmark(
+            backend,
+            points,
+            execution_mode=execution_mode.value,
+            benchmark_config=benchmark_config,
+            selectors=selectors,
+            progress=progress,
+            chunk_guard=chunk_guard,
+        )
+    if execution_mode in {ExecutionMode.RECURRENCE, ExecutionMode.ON_THE_FLY}:
+        from pyamplicol.api import BenchmarkRunner
+        from pyamplicol.cli import CliInvocation, parse_cli
+        from pyamplicol.cli.handlers import DefaultCliServices, dispatch
+        from pyamplicol.config import RunConfig
+        from pyamplicol.reporting import NullProgressSink
+
+        selected_progress = progress or NullProgressSink()
+        invocation = parse_cli(_profile_cli_argv(benchmark_config))
+        if not isinstance(invocation, CliInvocation):
+            raise RunnerError("public profile parser returned a non-command invocation")
+        resolution = invocation.resolve()
+        if resolution.effective.benchmark != benchmark_config:
+            raise RunnerError(
+                "public profile arguments do not preserve report benchmark settings"
+            )
+        expected_helicities = tuple(selectors["helicities"] or ())
+        expected_color_flows = tuple(selectors["color_flows"] or ())
+        if (
+            resolution.effective.benchmark.helicity_ids != expected_helicities
+            or resolution.effective.benchmark.color_flow_ids != expected_color_flows
+        ):
+            raise RunnerError(
+                "public profile arguments do not preserve report selectors"
+            )
+
+        class _LoadedRuntimeProfileServices(DefaultCliServices):
+            """Inject only the authenticated loaded runtime and exact points.
+
+            Parsing, typed resolution, progress propagation, benchmark settings,
+            and dispatch remain the public ``pyamplicol profile`` path.
+            """
+
+            def benchmark(
+                self,
+                config: RunConfig,
+                command_progress: ProgressSink,
+            ) -> object:
+                profile_started = time.perf_counter()
+                runner_arguments: dict[str, object] = {
+                    "progress": command_progress,
+                }
+                if chunk_guard is not None:
+                    runner_arguments["_chunk_guard"] = chunk_guard
+                result = BenchmarkRunner(config, **runner_arguments).run(
+                    runtime,
+                    points=points,
+                )
+                profile_total_elapsed = time.perf_counter() - profile_started
+                environment = getattr(result, "environment", None)
+                if not isinstance(environment, Mapping):
+                    raise RunnerError(
+                        "public profile result does not retain environment evidence"
+                    )
+                return replace(
+                    result,
+                    environment={
+                        **environment,
+                        "report_command_path": (LOADED_RUNTIME_PROFILE_COMMAND_PATH),
+                        "report_public_cli_path": PUBLIC_CLI_COMMAND_PATH,
+                        "profile_total_elapsed_seconds": profile_total_elapsed,
+                    },
+                )
+
+        return dispatch(
+            resolution.effective,
+            _LoadedRuntimeProfileServices(),
+            selected_progress,
+            dry_run=invocation.dry_run,
+        )
+    raise RunnerError(
+        f"unsupported pyAmpliCol report execution mode: {execution_mode.value}"
+    )
+
+
+def _warmup_finite_number(
+    value: object,
+    field: str,
+    *,
+    positive: bool = False,
+) -> float:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(float(value))
+        or (float(value) <= 0.0 if positive else float(value) < 0.0)
+    ):
+        qualifier = "positive" if positive else "non-negative"
+        raise ValueError(f"runtime profile {field} must be a finite {qualifier} number")
+    return float(value)
+
+
+def _warmup_nonnegative_integer(value: object, field: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise ValueError(f"runtime profile {field} must be a non-negative integer")
+    return value
+
+
+def _warmup_boolean(value: object, field: str) -> bool:
+    if not isinstance(value, bool):
+        raise ValueError(f"runtime profile {field} must be a boolean")
+    return value
+
+
+def _warmup_plain_value(value: object) -> object:
+    if isinstance(value, Mapping):
+        return {str(key): _warmup_plain_value(item) for key, item in value.items()}
+    if isinstance(value, tuple):
+        return tuple(_warmup_plain_value(item) for item in value)
+    if isinstance(value, list):
+        return [_warmup_plain_value(item) for item in value]
+    return value
+
+
+def _validate_otf_runtime_state_census(
+    value: object,
+    field: str,
+) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise ValueError(f"runtime profile {field} must be a mapping")
+    expected_fields = {
+        "kind",
+        "process_id",
+        "family_cache_policy",
+        "family_cache_limit",
+        "active_family_union_census",
+        *OTF_RUNTIME_STATE_COUNT_FIELDS,
+    }
+    if set(value) != expected_fields:
+        raise ValueError(f"runtime profile {field} has invalid runtime census fields")
+    if value.get("kind") != OTF_RUNTIME_STATE_CENSUS_KIND:
+        raise ValueError(f"runtime profile {field} has an invalid runtime census kind")
+    if value.get("family_cache_policy") != OTF_RUNTIME_STATE_FAMILY_CACHE_POLICY:
+        raise ValueError(
+            f"runtime profile {field} has an unsupported family cache policy"
+        )
+    family_cache_limit = value.get("family_cache_limit")
+    if (
+        isinstance(family_cache_limit, bool)
+        or not isinstance(family_cache_limit, int)
+        or family_cache_limit != OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT
+    ):
+        raise ValueError(
+            f"runtime profile {field} must use family cache limit "
+            f"{OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT}"
+        )
+    process_id = value.get("process_id")
+    if not isinstance(process_id, str) or not process_id:
+        raise ValueError(
+            f"runtime profile {field} runtime census has an invalid process ID"
+        )
+    for count_field in OTF_RUNTIME_STATE_COUNT_FIELDS:
+        _warmup_nonnegative_integer(value[count_field], f"{field}.{count_field}")
+    if value["retained_family_count"] > OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT:
+        raise ValueError(
+            f"runtime profile {field} retained family count exceeds its cache limit"
+        )
+
+    active = value.get("active_family_union_census")
+    if active is None:
+        return value
+    if not isinstance(active, Mapping):
+        raise ValueError(
+            f"runtime profile {field} active-family census must be a mapping or null"
+        )
+    expected_active_fields = {
+        "basis",
+        "scope",
+        *OTF_ACTIVE_FAMILY_COUNT_FIELDS,
+    }
+    if set(active) != expected_active_fields:
+        raise ValueError(
+            f"runtime profile {field} has invalid active-family census fields"
+        )
+    if (
+        active.get("basis") != "shared-query-family-union-v1"
+        or active.get("scope") != "active-family-union"
+    ):
+        raise ValueError(
+            f"runtime profile {field} has an invalid active-family census identity"
+        )
+    for count_field in OTF_ACTIVE_FAMILY_COUNT_FIELDS:
+        _warmup_nonnegative_integer(
+            active[count_field],
+            f"{field}.active_family_union_census.{count_field}",
+        )
+    if (
+        active["query_count"] < 1
+        or active["union_unique_current_count"]
+        > active["union_unique_current_component_count"]
+        or active["union_amplitude_destination_count"] < 1
+        or active["union_amplitude_destination_count"] > active["query_count"]
+        or active["query_count"] > value["retained_request_count"]
+        or active["union_amplitude_destination_count"]
+        > value["retained_amplitude_destination_count"]
+    ):
+        raise ValueError(
+            f"runtime profile {field} active-family census is inconsistent"
+        )
+    for role in OTF_OPERATION_ROLES:
+        if active[f"union_{role}_executor_call_groups"] > active[f"union_{role}_rows"]:
+            raise ValueError(
+                f"runtime profile {field} active-family {role} call-group "
+                "count exceeds its row count"
+            )
+    return value
+
+
+def _otf_runtime_state_is_cold(value: Mapping[str, object]) -> bool:
+    return all(value[field] == 0 for field in OTF_RUNTIME_STATE_COUNT_FIELDS) and (
+        value["active_family_union_census"] is None
+    )
+
+
+def _otf_runtime_state_is_retained(value: Mapping[str, object]) -> bool:
+    if (
+        value["pending_family_count"] != 0
+        or value["process_preparation_count"] != 1
+        or value["retained_family_count"] != OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT
+        or value["retained_selection_count"] != OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT
+        or _warmup_nonnegative_integer(
+            value["retained_request_count"],
+            "retained_request_count",
+        )
+        < 1
+    ):
+        return False
+    executable_counts = tuple(
+        _warmup_nonnegative_integer(value[field], field)
+        for field in OTF_RUNTIME_STATE_RETAINED_EXECUTABLE_FIELDS
+    )
+    active = value["active_family_union_census"]
+    if isinstance(active, Mapping):
+        return (
+            executable_counts[0] > 0
+            and executable_counts[1] == OTF_RUNTIME_STATE_FAMILY_CACHE_LIMIT
+            and executable_counts[2] > 0
+        )
+    return active is None and all(count == 0 for count in executable_counts)
+
+
+def validate_profile_warmup_evidence(
+    value: object,
+    *,
+    execution_mode: ExecutionMode | str,
+    expected_batch_size: int | None = None,
+    expected_warmup_run_count: int | None = None,
+) -> None:
+    """Validate bounded OTF cold preparation and conventional warm-ups.
+
+    The fields are the flat environment evidence emitted by
+    :class:`BenchmarkBackend`; this validator deliberately does not introduce a
+    second timing record or reinterpret the backend's clocks.
+    """
+
+    if not isinstance(value, Mapping):
+        raise ValueError("runtime profile warm-up evidence must be a mapping")
+    mode = (
+        execution_mode.value
+        if isinstance(execution_mode, ExecutionMode)
+        else execution_mode
+    )
+    is_otf = mode == ExecutionMode.ON_THE_FLY.value
+    conventional_present = CONVENTIONAL_WARMUP_FIELDS & value.keys()
+    cold_present = OTF_COLD_WARMUP_FIELDS & value.keys()
+    if is_otf and conventional_present != CONVENTIONAL_WARMUP_FIELDS:
+        missing = sorted(CONVENTIONAL_WARMUP_FIELDS - value.keys())
+        raise ValueError(
+            "on-the-fly runtime profile has incomplete conventional warm-up "
+            f"evidence; missing={missing}"
+        )
+    if is_otf and cold_present != OTF_COLD_WARMUP_FIELDS:
+        missing = sorted(OTF_COLD_WARMUP_FIELDS - value.keys())
+        raise ValueError(
+            "on-the-fly runtime profile has incomplete cold warm-up evidence; "
+            f"missing={missing}"
+        )
+    if not is_otf and cold_present:
+        raise ValueError(
+            "non-on-the-fly runtime profile cannot contain cold warm-up evidence"
+        )
+    if (
+        not is_otf
+        and conventional_present
+        and conventional_present != CONVENTIONAL_WARMUP_FIELDS
+    ):
+        if conventional_present != {"warmup_elapsed_seconds"}:
+            missing = sorted(CONVENTIONAL_WARMUP_FIELDS - value.keys())
+            raise ValueError(
+                "runtime profile has unsupported partial conventional warm-up "
+                f"evidence; missing={missing}"
+            )
+        _warmup_finite_number(
+            value["warmup_elapsed_seconds"],
+            "warmup_elapsed_seconds",
+        )
+        return
+    if not conventional_present:
+        return
+
+    warmup_elapsed = _warmup_finite_number(
+        value["warmup_elapsed_seconds"],
+        "warmup_elapsed_seconds",
+    )
+    warmup_count = _warmup_nonnegative_integer(
+        value["warmup_configured_run_count"],
+        "warmup_configured_run_count",
+    )
+    if expected_warmup_run_count is not None and (
+        isinstance(expected_warmup_run_count, bool)
+        or not isinstance(expected_warmup_run_count, int)
+        or expected_warmup_run_count < 0
+        or warmup_count != expected_warmup_run_count
+    ):
+        raise ValueError(
+            "runtime profile warmup_configured_run_count does not match the "
+            "effective benchmark configuration"
+        )
+    warmup_batch_size = _warmup_nonnegative_integer(
+        value["warmup_batch_size"],
+        "warmup_batch_size",
+    )
+    if warmup_batch_size < 1:
+        raise ValueError("runtime profile warmup_batch_size must be positive")
+    warmup_point_count = _warmup_nonnegative_integer(
+        value["warmup_point_count"],
+        "warmup_point_count",
+    )
+    if warmup_point_count != warmup_count * warmup_batch_size:
+        raise ValueError(
+            "runtime profile warmup_point_count does not equal configured runs "
+            "times batch size"
+        )
+    raw_runs = value["warmup_run_outer_wall_seconds"]
+    if isinstance(raw_runs, (str, bytes)) or not isinstance(raw_runs, Sequence):
+        raise ValueError(
+            "runtime profile warmup_run_outer_wall_seconds must be a sequence"
+        )
+    runs = tuple(
+        _warmup_finite_number(item, "warmup_run_outer_wall_seconds[]")
+        for item in raw_runs
+    )
+    if len(runs) != warmup_count:
+        raise ValueError(
+            "runtime profile warmup_run_outer_wall_seconds length does not match "
+            "the configured run count"
+        )
+    warmup_sum = sum(runs)
+    consistency_tolerance = max(
+        1.0e-12,
+        max(abs(warmup_elapsed), abs(warmup_sum)) * 1.0e-12,
+    )
+    if abs(warmup_sum - warmup_elapsed) > consistency_tolerance:
+        raise ValueError(
+            "runtime profile warmup_elapsed_seconds does not equal its per-run "
+            "outer-wall timing sum"
+        )
+    first_run = value["first_warmup_run_outer_wall_seconds"]
+    if warmup_count == 0:
+        if first_run is not None:
+            raise ValueError(
+                "runtime profile first_warmup_run_outer_wall_seconds must be null "
+                "when no warm-up runs are configured"
+            )
+    elif (
+        _warmup_finite_number(
+            first_run,
+            "first_warmup_run_outer_wall_seconds",
+        )
+        != runs[0]
+    ):
+        raise ValueError(
+            "runtime profile first warm-up timing does not match the first per-run "
+            "timing"
+        )
+    if value["warmup_timer_source"] != WARMUP_TIMER_SOURCE:
+        raise ValueError("runtime profile warmup_timer_source is unsupported")
+    if value["warmup_timing_scope"] != CONVENTIONAL_WARMUP_TIMING_SCOPE:
+        raise ValueError("runtime profile warmup_timing_scope is unsupported")
+
+    if not is_otf:
+        return
+    cold_elapsed = _warmup_finite_number(
+        value["cold_warmup_elapsed_seconds"],
+        "cold_warmup_elapsed_seconds",
+        positive=True,
+    )
+    if cold_elapsed <= 0.0:  # Defensive clarity for static type narrowing.
+        raise ValueError("on-the-fly cold warm-up timing must be positive")
+    cold_runs = _warmup_nonnegative_integer(
+        value["cold_warmup_run_count"],
+        "cold_warmup_run_count",
+    )
+    cold_batch_size = _warmup_nonnegative_integer(
+        value["cold_warmup_batch_size"],
+        "cold_warmup_batch_size",
+    )
+    cold_point_count = _warmup_nonnegative_integer(
+        value["cold_warmup_point_count"],
+        "cold_warmup_point_count",
+    )
+    if cold_runs != 1:
+        raise ValueError("on-the-fly cold warm-up must contain exactly one run")
+    if (
+        cold_batch_size < 1
+        or cold_point_count != cold_batch_size
+        or cold_batch_size != warmup_batch_size
+    ):
+        raise ValueError(
+            "on-the-fly cold warm-up must cover exactly the full benchmark batch"
+        )
+    if expected_batch_size is not None and (
+        isinstance(expected_batch_size, bool)
+        or not isinstance(expected_batch_size, int)
+        or expected_batch_size < 1
+        or cold_batch_size != expected_batch_size
+    ):
+        raise ValueError(
+            "on-the-fly cold warm-up batch does not match the effective "
+            "benchmark configuration"
+        )
+    if value["cold_warmup_timer_source"] != WARMUP_TIMER_SOURCE:
+        raise ValueError("on-the-fly cold warm-up timer source is unsupported")
+    if value["cold_warmup_timing_scope"] != OTF_COLD_WARMUP_TIMING_SCOPE:
+        raise ValueError(
+            "on-the-fly cold warm-up scope must exclude artifact generation and "
+            "Runtime/artifact load"
+        )
+    if (
+        value["cold_warmup_runtime_state_evidence"]
+        != OTF_COLD_WARMUP_RUNTIME_STATE_EVIDENCE
+    ):
+        raise ValueError(
+            "on-the-fly cold warm-up runtime state evidence is unsupported"
+        )
+    state_before = _validate_otf_runtime_state_census(
+        value["cold_warmup_runtime_state_before"],
+        "cold_warmup_runtime_state_before",
+    )
+    state_after = _validate_otf_runtime_state_census(
+        value["cold_warmup_runtime_state_after"],
+        "cold_warmup_runtime_state_after",
+    )
+    if state_before["process_id"] != state_after["process_id"]:
+        raise ValueError(
+            "on-the-fly cold warm-up runtime state snapshots identify different "
+            "processes"
+        )
+    runtime_was_cold = _otf_runtime_state_is_cold(state_before)
+    runtime_was_retained = _otf_runtime_state_is_retained(state_before)
+    runtime_is_retained = _otf_runtime_state_is_retained(state_after)
+    if runtime_was_cold == runtime_was_retained:
+        raise ValueError(
+            "on-the-fly runtime state before the first evaluation must be exactly "
+            "cold or strictly retained"
+        )
+    if not runtime_is_retained:
+        raise ValueError(
+            "on-the-fly runtime state after the first evaluation must be strictly "
+            "retained"
+        )
+    if (
+        _warmup_boolean(
+            value["cold_warmup_runtime_cold_before_first_evaluation"],
+            "cold_warmup_runtime_cold_before_first_evaluation",
+        )
+        is not runtime_was_cold
+        or _warmup_boolean(
+            value["cold_warmup_runtime_retained_before_first_evaluation"],
+            "cold_warmup_runtime_retained_before_first_evaluation",
+        )
+        is not runtime_was_retained
+        or _warmup_boolean(
+            value["cold_warmup_runtime_retained_after_first_evaluation"],
+            "cold_warmup_runtime_retained_after_first_evaluation",
+        )
+        is not runtime_is_retained
+    ):
+        raise ValueError(
+            "on-the-fly cold warm-up runtime state booleans do not match the "
+            "authenticated census snapshots"
+        )
+    expected_freshness = (
+        OTF_COLD_WARMUP_RUNTIME_FRESHNESS
+        if runtime_was_cold
+        else OTF_COLD_WARMUP_RUNTIME_RETAINED_FRESHNESS
+    )
+    if value["cold_warmup_runtime_freshness"] != expected_freshness:
+        raise ValueError(
+            "on-the-fly cold warm-up freshness does not match the authenticated "
+            "runtime state"
+        )
+    if (
+        value["cold_warmup_ratio_eligible"] is not False
+        or value["cold_warmup_acceptance_eligible"] is not False
+    ):
+        raise ValueError(
+            "on-the-fly cold warm-up must be ineligible for ratios and acceptance"
+        )
+
+
+def _benchmark_measurement(
+    benchmark: object,
+    *,
+    matrix_element: float,
+) -> dict[str, object]:
+    uncertainty = benchmark.uncertainty
+    environment = getattr(benchmark, "environment", None)
+    if not isinstance(environment, Mapping):
+        raise RunnerError("benchmark did not retain timing provenance")
+    evaluator_time = benchmark.evaluator_time_per_point
+    raw_evaluator_time = environment.get("evaluator_time_raw_seconds_per_point")
+    timing_status = environment.get("evaluator_time_status")
+    ratio_eligible = environment.get("evaluator_time_ratio_eligible")
+    evaluator_sample_count = environment.get(
+        "evaluator_sample_count",
+        environment.get("native_profile_sample_count", benchmark.sample_count),
+    )
+    if (
+        isinstance(evaluator_sample_count, bool)
+        or not isinstance(evaluator_sample_count, int)
+        or evaluator_sample_count < 1
+    ):
+        raise RunnerError("benchmark has invalid evaluator timing sample count")
+    raw_points_per_sample = environment.get("native_profile_points_per_sample")
+    if (
+        isinstance(raw_points_per_sample, bool)
+        or not isinstance(raw_points_per_sample, int)
+        or raw_points_per_sample < 1
+    ):
+        raise RunnerError("benchmark has invalid native-profile point count")
+    timing_sample_contract = environment.get("timing_sample_contract")
+    arena_profile_evidence: Mapping[str, object] | None = None
+    if timing_status == UNAVAILABLE_STATUS:
+        breakdown = getattr(benchmark, "timing_breakdown", None)
+        wall_component = (
+            breakdown.get("wall_time")
+            if isinstance(breakdown, Mapping)
+            else getattr(breakdown, "wall_time", None)
+        )
+        warmed_wall = (
+            wall_component.get("mean_seconds_per_point")
+            if isinstance(wall_component, Mapping)
+            else getattr(wall_component, "mean_seconds_per_point", None)
+        )
+        evaluator_component = (
+            breakdown.get("evaluator_call_time")
+            if isinstance(breakdown, Mapping)
+            else getattr(breakdown, "evaluator_call_time", None)
+        )
+        raw_arena_evidence = getattr(benchmark, "arena_profile_evidence", None)
+        profile_repetitions = environment.get("native_profile_repetitions_per_sample")
+        profile_batch_size = environment.get("native_profile_batch_size")
+        try:
+            arena_profile_evidence = validate_arena_profile_evidence(
+                raw_arena_evidence,
+                execution_mode=str(environment.get("execution_mode")),
+                sample_count=evaluator_sample_count,
+                native_profile_points_per_sample=raw_points_per_sample,
+            )
+        except ArenaProfileEvidenceError as error:
+            raise RunnerError(
+                f"benchmark has invalid warmed Arena profile evidence: {error}"
+            ) from error
+        if (
+            evaluator_time is not None
+            or getattr(benchmark, "evaluator_uncertainty", None) is not None
+            or raw_evaluator_time is not None
+            or ratio_eligible is not False
+            or environment.get("profile_protocol") != ARENA_PROFILE_PROTOCOL
+            or environment.get("evaluator_time_sample_pass")
+            != ARENA_PROFILE_SAMPLE_PASS
+            or environment.get("timing_breakdown_sample_pass")
+            != ARENA_PROFILE_SAMPLE_PASS
+            or environment.get("profile_attribution_boundary") != ARENA_PROFILE_BOUNDARY
+            or environment.get("profile_attribution_borrowed_flat_input") is not True
+            or environment.get("profile_attribution_preallocated_output") is not True
+            or environment.get("profile_attribution_phase_timing_scope")
+            != ARENA_PHASE_TIMING_SCOPE
+            or environment.get("profile_attribution_evaluator_timing_available")
+            is not False
+            or environment.get("profile_attribution_paired_with_headline") is not True
+            or environment.get("profile_attribution_identical_batch") is not True
+            or environment.get("profile_attribution_identical_repetitions") is not True
+            or timing_sample_contract != PAIRED_TIMING_SAMPLE_CONTRACT
+            or environment.get("execution_mode") not in {"compiled", "eager"}
+            or evaluator_sample_count != benchmark.sample_count
+            or isinstance(profile_repetitions, bool)
+            or not isinstance(profile_repetitions, int)
+            or profile_repetitions < 1
+            or isinstance(profile_batch_size, bool)
+            or not isinstance(profile_batch_size, int)
+            or profile_batch_size < 1
+            or profile_repetitions * profile_batch_size != raw_points_per_sample
+            or arena_profile_evidence.get("repetitions_per_profile")
+            != profile_repetitions
+            or arena_profile_evidence.get("batch_size") != profile_batch_size
+            or evaluator_component is not None
+            or isinstance(warmed_wall, bool)
+            or not isinstance(warmed_wall, (int, float))
+            or not math.isfinite(float(warmed_wall))
+            or float(warmed_wall) <= 0.0
+        ):
+            raise RunnerError(
+                "benchmark unavailable execution timing is not authenticated "
+                "by the warmed Arena profile boundary"
+            )
+        execution_timing = {
+            "abi": ARENA_UNAVAILABLE_EXECUTION_TIMING_ABI,
+            "status": UNAVAILABLE_STATUS,
+            "ratio_eligible": False,
+            "raw_seconds_per_point": None,
+            "sample_count": evaluator_sample_count,
+            "native_profile_points_per_sample": raw_points_per_sample,
+            "repetitions_per_sample": profile_repetitions,
+            "batch_size": profile_batch_size,
+            "sample_contract": PAIRED_TIMING_SAMPLE_CONTRACT,
+            "profile_protocol": ARENA_PROFILE_PROTOCOL,
+            "profile_sample_pass": ARENA_PROFILE_SAMPLE_PASS,
+            "profile_boundary": ARENA_PROFILE_BOUNDARY,
+            "borrowed_flat_input": True,
+            "preallocated_output": True,
+            "phase_timing_scope": ARENA_PHASE_TIMING_SCOPE,
+            "evaluator_timing_available": False,
+            "paired_with_headline": True,
+            "identical_batch": True,
+            "identical_repetitions": True,
+            "execution_mode": environment["execution_mode"],
+            "warmed_boundary_wall_seconds_per_point": float(warmed_wall),
+            "arena_profile_evidence_sha256": digest_arena_profile_value(
+                arena_profile_evidence
+            ),
+        }
+    elif timing_status == "measured":
+        time_source = environment.get("evaluator_time_source")
+        compiled_direct_arena_active = environment.get(
+            "compiled_direct_arena_active",
+            False,
+        )
+        if (
+            isinstance(raw_evaluator_time, bool)
+            or not isinstance(raw_evaluator_time, (int, float))
+            or not math.isfinite(float(raw_evaluator_time))
+            or float(raw_evaluator_time) <= 0.0
+            or isinstance(evaluator_time, bool)
+            or not isinstance(evaluator_time, (int, float))
+            or not math.isfinite(float(evaluator_time))
+            or float(evaluator_time) != float(raw_evaluator_time)
+            or ratio_eligible is not True
+            or not isinstance(time_source, str)
+            or not time_source
+            or not isinstance(compiled_direct_arena_active, bool)
+            or not isinstance(timing_sample_contract, str)
+            or not timing_sample_contract
+        ):
+            raise RunnerError("benchmark measured execution timing is inconsistent")
+        execution_timing = {
+            "abi": MEASURED_EXECUTION_TIMING_ABI,
+            "status": "measured",
+            "ratio_eligible": True,
+            "raw_seconds_per_point": float(raw_evaluator_time),
+            "source": time_source,
+            "compiled_direct_arena_active": compiled_direct_arena_active,
+            "sample_count": evaluator_sample_count,
+            "native_profile_points_per_sample": raw_points_per_sample,
+            "sample_contract": timing_sample_contract,
+        }
+    else:
+        raise RunnerError("benchmark has unsupported evaluator timing status")
+    total_environment_fields = (
+        "evaluator_total_time_raw_seconds_per_point",
+        "evaluator_total_time_status",
+        "evaluator_total_time_ratio_eligible",
+        "evaluator_total_time_source",
+        "evaluator_total_time_sample_contract",
+        "evaluator_total_accumulated_seconds",
+    )
+    total_fields_present = tuple(
+        field in environment for field in total_environment_fields
+    )
+    evaluator_total_timing: Mapping[str, object] | None = None
+    if any(total_fields_present):
+        if not all(total_fields_present):
+            raise RunnerError(
+                "benchmark has incomplete accumulated evaluator-total timing"
+            )
+        repetitions = environment.get("native_profile_repetitions_per_sample")
+        batch_size = environment.get("native_profile_batch_size")
+        measured_point_count = environment.get("measured_point_count")
+        raw_total = environment["evaluator_total_time_raw_seconds_per_point"]
+        evaluator_total_timing = {
+            "abi": EVALUATOR_TOTAL_TIMING_ABI,
+            "status": environment["evaluator_total_time_status"],
+            "ratio_eligible": environment["evaluator_total_time_ratio_eligible"],
+            "raw_seconds_per_point": raw_total,
+            "source": environment["evaluator_total_time_source"],
+            "execution_mode": environment.get("execution_mode"),
+            "sample_contract": environment["evaluator_total_time_sample_contract"],
+            "sample_count": benchmark.sample_count,
+            "repetitions_per_sample": repetitions,
+            "batch_size": batch_size,
+            "points_per_sample": raw_points_per_sample,
+            "measured_point_count": measured_point_count,
+            "accumulated_seconds": environment["evaluator_total_accumulated_seconds"],
+        }
+        total_measurement = {
+            "status": ResultStatus.OK.value,
+            "wall_seconds_per_point": benchmark.wall_time_per_point,
+            "sample_count": benchmark.sample_count,
+            "provenance": {
+                EVALUATOR_TOTAL_TIMING_KEY: evaluator_total_timing,
+            },
+        }
+        result_total = getattr(
+            benchmark,
+            "evaluator_total_time_per_point",
+            None,
+        )
+        if (
+            evaluator_total_timing_record(total_measurement) is None
+            or isinstance(result_total, bool)
+            or not isinstance(result_total, (int, float))
+            or not math.isfinite(float(result_total))
+            or float(result_total) != float(raw_total)
+        ):
+            raise RunnerError(
+                "benchmark accumulated evaluator-total timing is inconsistent"
+            )
+    target_runtime = float(benchmark.effective_config.target_runtime)
+    if not math.isfinite(target_runtime) or target_runtime <= 0.0:
+        raise RunnerError("benchmark has an invalid target timing duration")
+    achieved_runtime = environment.get("elapsed_seconds")
+    if (
+        isinstance(achieved_runtime, bool)
+        or not isinstance(achieved_runtime, (int, float))
+        or not math.isfinite(float(achieved_runtime))
+        or float(achieved_runtime) < 0.0
+    ):
+        raise RunnerError("benchmark did not report its achieved timing duration")
+    command_evidence: dict[str, object] = {}
+    if "report_command_path" in environment:
+        command_path = environment.get("report_command_path")
+        if not isinstance(command_path, str) or not command_path:
+            raise RunnerError("benchmark has an invalid report command path")
+        command_evidence["report_command_path"] = command_path
+    if "report_public_cli_path" in environment:
+        public_path = environment.get("report_public_cli_path")
+        if public_path is not None and (
+            not isinstance(public_path, str) or not public_path
+        ):
+            raise RunnerError("benchmark has an invalid public CLI command path")
+        command_evidence["report_public_cli_path"] = public_path
+    phase_evidence: dict[str, object] = {}
+    raw_execution_mode = environment.get("execution_mode")
+    benchmark_batch_size: int | None = None
+    benchmark_warmup_runs: int | None = None
+    if raw_execution_mode == ExecutionMode.ON_THE_FLY.value:
+        raw_batch_size = environment.get("batch_size")
+        effective_batch_size = getattr(
+            benchmark.effective_config,
+            "batch_size",
+            None,
+        )
+        effective_warmup_runs = getattr(
+            benchmark.effective_config,
+            "warmup_runs",
+            None,
+        )
+        if (
+            isinstance(raw_batch_size, bool)
+            or not isinstance(raw_batch_size, int)
+            or raw_batch_size < 1
+            or isinstance(effective_batch_size, bool)
+            or not isinstance(effective_batch_size, int)
+            or effective_batch_size < 1
+            or raw_batch_size != effective_batch_size
+        ):
+            raise RunnerError(
+                "on-the-fly benchmark batch size does not match its effective "
+                "configuration"
+            )
+        if (
+            isinstance(effective_warmup_runs, bool)
+            or not isinstance(effective_warmup_runs, int)
+            or effective_warmup_runs < 0
+        ):
+            raise RunnerError(
+                "on-the-fly benchmark has an invalid effective warm-up run count"
+            )
+        benchmark_batch_size = effective_batch_size
+        benchmark_warmup_runs = effective_warmup_runs
+    try:
+        validate_profile_warmup_evidence(
+            environment,
+            execution_mode=(
+                raw_execution_mode
+                if isinstance(raw_execution_mode, str)
+                else "<unknown>"
+            ),
+            expected_batch_size=benchmark_batch_size,
+            expected_warmup_run_count=benchmark_warmup_runs,
+        )
+    except ValueError as error:
+        raise RunnerError(str(error)) from error
+    for field in (*sorted(OTF_COLD_WARMUP_FIELDS), *sorted(CONVENTIONAL_WARMUP_FIELDS)):
+        if field in environment:
+            phase_evidence[field] = _warmup_plain_value(environment[field])
+    for field in (
+        "calibration_elapsed_seconds",
+        "calibration_outer_elapsed_seconds",
+        "measurement_phase_elapsed_seconds",
+        "profile_total_elapsed_seconds",
+        "profile_attribution_elapsed_seconds",
+        "evaluator_elapsed_seconds",
+        "calibration_probe_seconds",
+    ):
+        if field not in environment:
+            continue
+        value = environment[field]
+        if (
+            isinstance(value, bool)
+            or not isinstance(value, (int, float))
+            or not math.isfinite(float(value))
+            or float(value) < 0.0
+        ):
+            raise RunnerError(f"benchmark has invalid {field.replace('_', ' ')}")
+        phase_evidence[field] = float(value)
+    for field in (
+        "calibration_block_count",
+        "calibration_evaluation_count",
+    ):
+        if field not in environment:
+            continue
+        value = environment[field]
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise RunnerError(f"benchmark has invalid {field.replace('_', ' ')}")
+        phase_evidence[field] = value
+    if "measurement_phase_elapsed_seconds" not in phase_evidence:
+        phase_evidence["measurement_phase_elapsed_seconds"] = float(achieved_runtime)
+    return {
+        "status": ResultStatus.OK.value,
+        "wall_seconds_per_point": float(benchmark.wall_time_per_point),
+        "execution_seconds_per_point": (
+            None if evaluator_time is None else float(evaluator_time)
+        ),
+        "execution_timing": execution_timing,
+        "evaluator_total_timing": evaluator_total_timing,
+        "arena_profile_evidence": arena_profile_evidence,
+        "matrix_element": matrix_element,
+        "sample_count": int(benchmark.sample_count),
+        "standard_error_seconds_per_point": float(uncertainty.standard_error),
+        "relative_standard_error": float(uncertainty.relative_standard_error),
+        "benchmark_evidence": {
+            **command_evidence,
+            **phase_evidence,
+            "target_runtime_seconds": target_runtime,
+            "achieved_runtime_seconds": float(achieved_runtime),
+            "target_runtime_achieved": (
+                float(achieved_runtime) >= 0.95 * target_runtime
+            ),
+            "completed_sample_count": environment.get("completed_sample_count"),
+            "planned_sample_count": environment.get("planned_sample_count"),
+            "repetitions_per_sample": environment.get("repetitions_per_sample"),
+            "measured_point_count": environment.get("measured_point_count"),
+            "interrupted": bool(environment.get("interrupted", False)),
+        },
+    }
+
+
+def profile_runtime(
+    runtime: RuntimeLike,
+    points: object,
+    *,
+    cell: CellSpec,
+    benchmark_config: BenchmarkConfig,
+    selector_contract: SelectorContract | None,
+    progress: ProgressSink | None = None,
+    profiling_deadline_monotonic: float | None = None,
+) -> dict[str, object]:
+    validate_runtime_contract(cell, runtime)
+    if selector_contract is not None:
+        validate_selector_contract(
+            runtime,
+            selector_contract,
+            points,
+            cell=cell,
+        )
+    selectors = _selector_kwargs(cell, selector_contract)
+    values = (
+        None
+        if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+        else runtime.evaluate(points, **selectors)
+    )
+    if values is not None and not values:
+        raise RunnerError("runtime returned no matrix elements")
+    selected_config = replace(
+        benchmark_config,
+        helicity_ids=tuple(selectors["helicities"] or ()),
+        color_flow_ids=tuple(selectors["color_flows"] or ()),
+    )
+    benchmark = _run_report_benchmark(
+        runtime,
+        points,
+        execution_mode=cell.measurement.execution_mode,
+        benchmark_config=selected_config,
+        selectors=selectors,
+        progress=progress,
+        chunk_guard=profiling_chunk_guard(profiling_deadline_monotonic),
+    )
+    # The public OTF profiler owns the first evaluation so that its separately
+    # reported cold warm-up is not destroyed by campaign-side validation.
+    if values is None:
+        values = runtime.evaluate(points, **selectors)
+    if not values:
+        raise RunnerError("runtime returned no matrix elements")
+    result = _benchmark_measurement(
+        benchmark,
+        matrix_element=_real_nonnegative(values[0]),
+    )
+    result["resolved_sum_validation"] = resolved_sum_validation(
+        runtime,
+        points,
+        cell=cell,
+        selector_contract=selector_contract,
+    )
+    if result["resolved_sum_validation"]["status"] != ResultStatus.OK.value:
+        result["status"] = ResultStatus.VALIDATION_FAILED.value
+    return result
+
+
+def runtime_validation_points(runtime: object) -> object:
+    backend = getattr(runtime, "_backend", None)
+    operation = getattr(backend, "validation_momenta", None)
+    if not callable(operation):
+        raise RunnerError("artifact does not retain deterministic validation momenta")
+    points = operation()
+    if points is None:
+        raise RunnerError("artifact validation momenta are unavailable")
+    return points
+
+
+def _single_process_id(artifact_path: Path, fallback: str) -> str:
+    manifest_path = artifact_path / "artifact.json"
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+        processes = manifest["processes"]
+        if isinstance(processes, list) and len(processes) == 1:
+            identifier = processes[0]["id"]
+            if isinstance(identifier, str) and identifier:
+                return identifier
+    except (KeyError, OSError, TypeError, json.JSONDecodeError):
+        pass
+    return fallback
+
+
+def generate_artifact(
+    cell: CellSpec,
+    destination: Path,
+    *,
+    settings: RunnerSettings,
+    repo_root: Path,
+    prepared_model_path: Path | None = None,
+    phase_reporter: WorkerPhaseReporter | None = None,
+) -> GeneratedArtifact:
+    """Generate one complete-coverage artifact and time process generation only."""
+
+    from pyamplicol.api import Generator, ModelSource
+    from pyamplicol.cli import CliInvocation, parse_cli
+    from pyamplicol.cli.handlers import DefaultCliServices, dispatch
+    from pyamplicol.config import Action, RunConfig
+    from pyamplicol.config.resolver import config_to_dict, resolve_config
+    from pyamplicol.reporting import NullProgressSink
+
+    values = config_values(cell, settings, repo_root=repo_root)
+    generation_values = values["generation"]
+    assert isinstance(generation_values, dict)
+    generation_values.update(
+        {
+            "output": os.fspath(destination),
+            "mode": "replace",
+        }
+    )
+    values["process"] = {"entries": [{"expression": cell.process}]}
+    if prepared_model_path is not None:
+        if not prepared_model_path.is_file():
+            raise RunnerError(f"prepared model does not exist: {prepared_model_path}")
+        model_values = values["model"]
+        assert isinstance(model_values, dict)
+        model_values["source"] = os.fspath(prepared_model_path)
+    expected_resolution = resolve_config(
+        values,
+        action=Action.GENERATE,
+        base_dir=repo_root,
+    )
+    invocation = parse_cli(_generation_cli_argv(cell, destination, values))
+    if not isinstance(invocation, CliInvocation):
+        raise RunnerError("public generate parser returned a non-command invocation")
+    resolution = invocation.resolve()
+    if (
+        resolution.requested != expected_resolution.requested
+        or resolution.effective != expected_resolution.effective
+    ):
+        raise RunnerError(
+            "public generate arguments do not preserve report generation settings"
+        )
+    generation_phase = (
+        nullcontext() if phase_reporter is None else phase_reporter.generation()
+    )
+    with generation_phase:
+        # The process-tree watchdog owns the complete preparation+generation
+        # interval, while the published generation timer below intentionally
+        # continues to measure dispatch/generation only.
+        assert cell.measurement.model is not None
+        source_path = _model_source_path(repo_root, cell.measurement.model)
+        source = (
+            ModelSource.built_in_sm()
+            if source_path is None
+            else ModelSource.from_path(source_path)
+        )
+        model_started = time.perf_counter()
+        prepared_execution = cell.measurement.execution_mode in {
+            ExecutionMode.EAGER,
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.ON_THE_FLY,
+        }
+        if prepared_model_path is not None:
+            model = ModelSource.from_path(prepared_model_path)
+            preparation_reused = True
+        elif prepared_execution and cell.measurement.model is ModelKey.BUILTIN_SM:
+            # Omitting the explicit model lets the generation service select the
+            # validated wheel-owned built-in-SM JIT O2 prepared pack.
+            model = None
+            preparation_reused = True
+        elif prepared_execution:
+            raise RunnerError(
+                f"{cell.measurement.model.value} "
+                f"{cell.measurement.execution_mode.value} generation requires "
+                "a prepared model path"
+            )
+        else:
+            model = source.compile(
+                cache_dir=settings.model_cache_dir,
+                use_cache=True,
+                require_supported=True,
+            )
+            preparation_reused = False
+        model_seconds = time.perf_counter() - model_started
+        generation_started = time.perf_counter()
+        selected_progress = settings.progress or NullProgressSink()
+        if prepared_execution:
+            command_services = DefaultCliServices(resolution=resolution)
+            generation_command_path = PUBLIC_CLI_COMMAND_PATH
+        else:
+
+            class _PreparedGenerationServices(DefaultCliServices):
+                """Inject only the already compiled model into public dispatch.
+
+                The public parser, typed resolution, progress path, and dispatch
+                are retained.  This report-only handler exception is necessary
+                to exclude model preparation from the process-generation timer.
+                """
+
+                def generate(
+                    self,
+                    config: RunConfig,
+                    command_progress: ProgressSink,
+                ) -> object:
+                    return Generator(
+                        resolution,
+                        progress=command_progress,
+                    ).generate(
+                        cell.process,
+                        destination,
+                        model=model,
+                        mode="replace",
+                    )
+
+            command_services = _PreparedGenerationServices(resolution=resolution)
+            generation_command_path = PRECOMPILED_GENERATION_COMMAND_PATH
+
+        dispatch(
+            resolution.effective,
+            command_services,
+            selected_progress,
+            dry_run=invocation.dry_run,
+        )
+        generation_seconds = time.perf_counter() - generation_started
+    effective_config = _authenticated_effective_config(destination)
+    process_id = _single_process_id(destination, cell.process)
+    if cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY:
+        numerical_relation_correctness = None
+        numerical_relation_fallback = None
+    else:
+        (
+            numerical_relation_correctness,
+            numerical_relation_fallback,
+        ) = _artifact_numerical_relation_metadata(destination, process_id)
+    return GeneratedArtifact(
+        path=destination,
+        process_id=process_id,
+        generation_seconds=generation_seconds,
+        model_preparation_seconds=model_seconds,
+        model_preparation_reused=preparation_reused,
+        requested_config=config_to_dict(resolution.requested),
+        effective_config=effective_config,
+        generation_command_path=generation_command_path,
+        numerical_relation_correctness=numerical_relation_correctness,
+        numerical_relation_fallback=numerical_relation_fallback,
+    )
+
+
+def provenance_payload() -> dict[str, object]:
+    numpy_version = getattr(importlib.import_module("numpy"), "__version__", None)
+    if not isinstance(numpy_version, str) or not numpy_version:
+        raise RunnerError("measurement NumPy version is unavailable")
+    return {
+        "platform": platform.platform(),
+        "python": platform.python_version(),
+        "python_implementation": platform.python_implementation(),
+        "numpy": numpy_version,
+        "machine": platform.machine(),
+        "processor": platform.processor(),
+    }
+
+
+__all__ = [
+    "ABSOLUTE_TOLERANCE",
+    "CONDITIONED_COMPARISON_ABI",
+    "INDEPENDENT_RELATIVE_TOLERANCE",
+    "MADGRAPH_RELATIVE_TOLERANCE",
+    "RELATIVE_TOLERANCE",
+    "RESOLVED_COMPONENT_SCALE_ABI",
+    "RESOLVED_SUM_VALIDATION_ABI",
+    "GeneratedArtifact",
+    "ProfilingTimeLimitError",
+    "RunnerError",
+    "RunnerSettings",
+    "SelectorContract",
+    "config_values",
+    "derive_selector_contract",
+    "generate_artifact",
+    "point_digest",
+    "pointwise_validation",
+    "profile_runtime",
+    "profiling_chunk_guard",
+    "provenance_payload",
+    "resolved_component_scale_evidence",
+    "resolved_sum_validation",
+    "runtime_identity_payload",
+    "runtime_validation_points",
+    "validate_artifact_contract",
+    "validate_conditioned_comparison_record",
+    "validate_resolved_sum_validation_record",
+    "validate_runtime_contract",
+    "validate_selector_contract",
+]
diff --git a/pyamplicol/tools/performance_report/runtime_evidence.py b/pyamplicol/tools/performance_report/runtime_evidence.py
new file mode 100644
index 0000000000..24bd274fc0
--- /dev/null
+++ b/pyamplicol/tools/performance_report/runtime_evidence.py
@@ -0,0 +1,645 @@
+# SPDX-License-Identifier: 0BSD
+"""Checked identities for the Python bytes eligible during final measurements."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib.machinery
+import json
+import os
+import stat
+import sys
+from collections.abc import Sequence
+from pathlib import Path, PurePosixPath
+
+_HASH_CHUNK_BYTES = 1024 * 1024
+_STABLE_STAT_FIELDS = (
+    "st_dev",
+    "st_ino",
+    "st_mode",
+    "st_size",
+    "st_mtime_ns",
+    "st_ctime_ns",
+)
+_PREIMPORT_RUNTIME_IDENTITY: dict[str, object] | None = None
+
+
+class RuntimeEvidenceError(RuntimeError):
+    """A runtime tree cannot be authenticated without a namespace race."""
+
+
+def _isolated_startup_flags() -> tuple[bool, bool, bool]:
+    return (
+        bool(sys.flags.isolated),
+        bool(sys.flags.no_site),
+        bool(sys.flags.ignore_environment),
+    )
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+def source_only_bytecode_policy() -> dict[str, object]:
+    """Prove that this process cannot read or write package-local bytecode.
+
+    ``-B`` prevents writes, while an absolute, absent ``PYTHONPYCACHEPREFIX``
+    makes the interpreter's cache lookup namespace empty.  The exact random
+    prefix is intentionally omitted so identities remain comparable across
+    isolated workers.
+    """
+
+    prefix_value = sys.pycache_prefix
+    isolated, no_site, ignore_environment = _isolated_startup_flags()
+    if not (isolated and ignore_environment):
+        raise RuntimeEvidenceError(
+            "exact runtime evidence requires isolated Python startup (-I)"
+        )
+    if not sys.dont_write_bytecode:
+        raise RuntimeEvidenceError(
+            "exact runtime evidence requires Python -B "
+            "(sys.dont_write_bytecode must be true)"
+        )
+    if not no_site:
+        if prefix_value is not None:
+            raise RuntimeEvidenceError(
+                "installed runtime evidence requires no external bytecode prefix"
+            )
+        return {
+            "kind": "pyamplicol-installed-bytecode-policy-v1",
+            "dont_write_bytecode": True,
+            "external_pycache_prefix": False,
+            "package_local_bytecode_eligible": False,
+            "isolated_startup": True,
+            "site_initialization": True,
+            "python_environment_ignored_at_startup": True,
+        }
+    if not isinstance(prefix_value, str) or not prefix_value:
+        raise RuntimeEvidenceError(
+            "exact runtime evidence requires an absent external "
+            "PYTHONPYCACHEPREFIX"
+        )
+    prefix = Path(prefix_value).expanduser()
+    if not prefix.is_absolute():
+        raise RuntimeEvidenceError(
+            "exact runtime evidence requires an absolute PYTHONPYCACHEPREFIX"
+        )
+    if prefix.exists():
+        raise RuntimeEvidenceError(
+            "exact runtime evidence requires PYTHONPYCACHEPREFIX to remain absent"
+        )
+    return {
+        "kind": "pyamplicol-source-only-bytecode-policy-v1",
+        "dont_write_bytecode": True,
+        "external_pycache_prefix": True,
+        "external_pycache_prefix_absent": True,
+        "package_local_bytecode_eligible": False,
+        "isolated_startup": True,
+        "site_initialization": False,
+        "python_environment_ignored_at_startup": True,
+    }
+
+
+def _same_stat(left: os.stat_result, right: os.stat_result) -> bool:
+    return all(
+        getattr(left, field) == getattr(right, field)
+        for field in _STABLE_STAT_FIELDS
+    )
+
+
+def _relative_directory(path: str) -> PurePosixPath:
+    if path in {"", "."}:
+        return PurePosixPath()
+    normalized = path[2:] if path.startswith("./") else path
+    logical = PurePosixPath(normalized)
+    if (
+        logical.is_absolute()
+        or any(part in {"", ".", ".."} for part in logical.parts)
+        or logical.as_posix() != normalized
+    ):
+        raise RuntimeEvidenceError(
+            f"package traversal produced a noncanonical directory: {path!r}"
+        )
+    return logical
+
+
+def _regular_file_record(
+    directory_fd: int,
+    name: str,
+    logical_path: str,
+) -> dict[str, object]:
+    flags = (
+        os.O_RDONLY
+        | getattr(os, "O_CLOEXEC", 0)
+        | getattr(os, "O_NOFOLLOW", 0)
+        | getattr(os, "O_BINARY", 0)
+    )
+    descriptor: int | None = None
+    try:
+        namespace_before = os.stat(name, dir_fd=directory_fd, follow_symlinks=False)
+        if not stat.S_ISREG(namespace_before.st_mode):
+            raise RuntimeEvidenceError(
+                f"package member is not a regular file: {logical_path}"
+            )
+        descriptor = os.open(name, flags, dir_fd=directory_fd)
+        opened_before = os.fstat(descriptor)
+        if not _same_stat(namespace_before, opened_before):
+            raise RuntimeEvidenceError(
+                f"package member changed while it was opened: {logical_path}"
+            )
+        digest = hashlib.sha256()
+        byte_count = 0
+        with os.fdopen(descriptor, "rb", closefd=True) as stream:
+            descriptor = None
+            for block in iter(lambda: stream.read(_HASH_CHUNK_BYTES), b""):
+                digest.update(block)
+                byte_count += len(block)
+            opened_after = os.fstat(stream.fileno())
+        namespace_after = os.stat(name, dir_fd=directory_fd, follow_symlinks=False)
+    except OSError as error:
+        raise RuntimeEvidenceError(
+            f"cannot authenticate installed package member: {logical_path}"
+        ) from error
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+    if (
+        byte_count != opened_before.st_size
+        or not _same_stat(opened_before, opened_after)
+        or not _same_stat(opened_after, namespace_after)
+    ):
+        raise RuntimeEvidenceError(
+            f"package member changed while it was hashed: {logical_path}"
+        )
+    return {
+        "path": logical_path,
+        "size": byte_count,
+        "sha256": digest.hexdigest(),
+    }
+
+
+def _path_file_identity(path: Path) -> dict[str, object]:
+    try:
+        parent = path.parent.resolve(strict=True)
+        name = path.name
+        flags = (
+            os.O_RDONLY
+            | getattr(os, "O_CLOEXEC", 0)
+            | getattr(os, "O_DIRECTORY", 0)
+            | getattr(os, "O_NOFOLLOW", 0)
+        )
+        directory_fd = os.open(parent, flags)
+        try:
+            parent_before = os.fstat(directory_fd)
+            record = _regular_file_record(directory_fd, name, name)
+            parent_after = os.fstat(directory_fd)
+            parent_namespace = os.stat(parent, follow_symlinks=False)
+        finally:
+            os.close(directory_fd)
+    except OSError as error:
+        raise RuntimeEvidenceError(
+            f"cannot authenticate runtime file: {path}"
+        ) from error
+    if (
+        not _same_stat(parent_before, parent_after)
+        or not _same_stat(parent_after, parent_namespace)
+    ):
+        raise RuntimeEvidenceError(
+            f"runtime file parent changed while it was authenticated: {path}"
+        )
+    return {
+        "path": str(parent / name),
+        "size": record["size"],
+        "sha256": record["sha256"],
+    }
+
+
+def _scan_package_tree(
+    root_fd: int,
+) -> tuple[list[dict[str, object]], tuple[object, ...]]:
+    records: list[dict[str, object]] = []
+    namespace: list[object] = []
+    try:
+        walker = os.fwalk(
+            ".",
+            topdown=True,
+            follow_symlinks=False,
+            dir_fd=root_fd,
+        )
+        for directory, directory_names, file_names, directory_fd in walker:
+            logical_directory = _relative_directory(directory)
+            directory_names.sort()
+            file_names.sort()
+            if "__pycache__" in directory_names:
+                directory_names.remove("__pycache__")
+            directory_metadata = os.fstat(directory_fd)
+            if not stat.S_ISDIR(directory_metadata.st_mode):
+                raise RuntimeEvidenceError(
+                    f"package member is not a directory: {logical_directory}"
+                )
+            namespace.append(
+                (
+                    "directory",
+                    logical_directory.as_posix(),
+                    *(
+                        getattr(directory_metadata, field)
+                        for field in _STABLE_STAT_FIELDS
+                    ),
+                )
+            )
+            for name in directory_names:
+                metadata = os.stat(
+                    name,
+                    dir_fd=directory_fd,
+                    follow_symlinks=False,
+                )
+                logical = (logical_directory / name).as_posix()
+                if not stat.S_ISDIR(metadata.st_mode):
+                    raise RuntimeEvidenceError(
+                        "installed pyamplicol package tree contains an "
+                        f"unsupported directory entry: {logical}"
+                    )
+                namespace.append(
+                    (
+                        "directory-entry",
+                        logical,
+                        *(getattr(metadata, field) for field in _STABLE_STAT_FIELDS),
+                    )
+                )
+            for name in file_names:
+                logical = (logical_directory / name).as_posix()
+                if Path(name).suffix in {".pyc", ".pyo"}:
+                    raise RuntimeEvidenceError(
+                        "installed pyamplicol package tree contains executable "
+                        f"sourceless bytecode: {logical}"
+                    )
+                record = _regular_file_record(directory_fd, name, logical)
+                records.append(record)
+                metadata = os.stat(
+                    name,
+                    dir_fd=directory_fd,
+                    follow_symlinks=False,
+                )
+                namespace.append(
+                    (
+                        "file",
+                        logical,
+                        *(getattr(metadata, field) for field in _STABLE_STAT_FIELDS),
+                    )
+                )
+    except OSError as error:
+        raise RuntimeEvidenceError(
+            "cannot traverse installed pyamplicol package through checked descriptors"
+        ) from error
+    records.sort(key=lambda record: str(record["path"]))
+    namespace.sort(key=repr)
+    return records, tuple(namespace)
+
+
+def _resolved_package_roots(package_roots: Path | Sequence[Path]) -> tuple[Path, ...]:
+    raw_roots = (
+        (package_roots,)
+        if isinstance(package_roots, Path)
+        else tuple(package_roots)
+    )
+    if not raw_roots:
+        raise RuntimeEvidenceError("installed pyamplicol package has no search roots")
+    roots: list[Path] = []
+    for raw_root in raw_roots:
+        try:
+            root = raw_root.expanduser().resolve(strict=True)
+        except OSError as error:
+            raise RuntimeEvidenceError(
+                f"cannot resolve installed pyamplicol package tree: {raw_root}"
+            ) from error
+        if root not in roots:
+            roots.append(root)
+    return tuple(roots)
+
+
+def _package_tree_records(root: Path) -> list[dict[str, object]]:
+    try:
+        flags = (
+            os.O_RDONLY
+            | getattr(os, "O_CLOEXEC", 0)
+            | getattr(os, "O_DIRECTORY", 0)
+            | getattr(os, "O_NOFOLLOW", 0)
+        )
+        root_fd = os.open(root, flags)
+        root_before = os.fstat(root_fd)
+        if not stat.S_ISDIR(root_before.st_mode):
+            raise RuntimeEvidenceError(
+                f"installed pyamplicol package tree is not a directory: {root}"
+            )
+        first_records, first_namespace = _scan_package_tree(root_fd)
+        second_records, second_namespace = _scan_package_tree(root_fd)
+        root_after = os.fstat(root_fd)
+        namespace_root = os.stat(root, follow_symlinks=False)
+    except OSError as error:
+        raise RuntimeEvidenceError(
+            f"cannot authenticate installed pyamplicol package tree: {root}"
+        ) from error
+    finally:
+        if "root_fd" in locals():
+            os.close(root_fd)
+    if (
+        not _same_stat(root_before, root_after)
+        or not _same_stat(root_after, namespace_root)
+        or first_records != second_records
+        or first_namespace != second_namespace
+    ):
+        raise RuntimeEvidenceError(
+            "installed pyamplicol package tree changed while it was authenticated"
+        )
+    if not first_records:
+        raise RuntimeEvidenceError(
+            "installed pyamplicol package tree contains no source/runtime files"
+        )
+    return first_records
+
+
+def python_package_tree_identity(
+    package_roots: Path | Sequence[Path],
+) -> dict[str, object]:
+    """Hash every ordered package search root through anchored directory fds."""
+
+    bytecode_policy = source_only_bytecode_policy()
+    roots = _resolved_package_roots(package_roots)
+    records: list[dict[str, object]] = []
+    for root_index, root in enumerate(roots):
+        for record in _package_tree_records(root):
+            records.append({"root_index": root_index, **record})
+    total_bytes = sum(int(record["size"]) for record in records)
+    return {
+        "kind": "pyamplicol-python-package-tree-v2",
+        "root": str(roots[0]),
+        "roots": [str(root) for root in roots],
+        "file_count": len(records),
+        "total_bytes": total_bytes,
+        "sha256": hashlib.sha256(_canonical_json(records)).hexdigest(),
+        "member_set_stable": True,
+        "namespace_bound_to_root_fd": True,
+        "bytecode_policy": bytecode_policy,
+    }
+
+
+def native_extension_in_package(package_root: Path) -> Path:
+    """Return the one importable native extension in an ordered package root."""
+
+    try:
+        root = package_root.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise RuntimeEvidenceError(
+            f"cannot resolve native package root: {package_root}"
+        ) from error
+    suffixes = tuple(importlib.machinery.EXTENSION_SUFFIXES)
+    matches = sorted(
+        (
+            path
+            for path in root.iterdir()
+            if path.is_file()
+            and path.name.startswith("_rusticol")
+            and path.name.endswith(suffixes)
+        ),
+        key=lambda path: path.name,
+    )
+    if len(matches) != 1:
+        raise RuntimeEvidenceError(
+            "exact runtime evidence requires one native _rusticol extension in "
+            f"{root}; found {len(matches)}"
+        )
+    return matches[0]
+
+
+def preimport_python_runtime_identity(
+    package_roots: Path | Sequence[Path],
+    *,
+    native_extension: Path,
+) -> dict[str, object]:
+    """Authenticate candidate Python/native files before importing pyamplicol."""
+
+    global _PREIMPORT_RUNTIME_IDENTITY
+    if any(
+        name == "pyamplicol" or name.startswith("pyamplicol.")
+        for name in sys.modules
+    ):
+        raise RuntimeEvidenceError(
+            "pyamplicol was imported before exact runtime preauthentication"
+        )
+    identity = {
+        "kind": "pyamplicol-preimport-runtime-identity-v1",
+        "python_package_tree": python_package_tree_identity(package_roots),
+        "native_extension": _path_file_identity(native_extension),
+    }
+    _PREIMPORT_RUNTIME_IDENTITY = identity
+    return identity
+
+
+def established_preimport_runtime_identity() -> dict[str, object]:
+    """Return the identity established before the first pyamplicol import."""
+
+    if _PREIMPORT_RUNTIME_IDENTITY is None:
+        raise RuntimeEvidenceError(
+            "exact runtime evidence has no preimport Python/native identity"
+        )
+    return _PREIMPORT_RUNTIME_IDENTITY
+
+
+def loaded_pyamplicol_origin_policy(
+    package_roots: Path | Sequence[Path],
+    *,
+    native_extension: Path,
+    expected_package_identity: dict[str, object] | None = None,
+    expected_native_identity: dict[str, object] | None = None,
+) -> dict[str, object]:
+    """Require every loaded pyamplicol module to originate in authenticated bytes."""
+
+    source_only_bytecode_policy()
+    try:
+        roots = _resolved_package_roots(package_roots)
+        native = native_extension.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise RuntimeEvidenceError(
+            "cannot resolve loaded pyamplicol module origins"
+        ) from error
+    current_package_identity = python_package_tree_identity(roots)
+    if (
+        expected_package_identity is not None
+        and current_package_identity != expected_package_identity
+    ):
+        raise RuntimeEvidenceError(
+            "pyamplicol package roots differ from their preimport identity"
+        )
+    current_native_identity = _path_file_identity(native)
+    if (
+        expected_native_identity is not None
+        and current_native_identity != expected_native_identity
+    ):
+        raise RuntimeEvidenceError(
+            "native extension differs from its preimport identity"
+        )
+    member_records: list[dict[str, object]] = []
+    for root_index, root in enumerate(roots):
+        member_records.extend(
+            {"root_index": root_index, **record}
+            for record in _package_tree_records(root)
+        )
+    members = {
+        (int(record["root_index"]), str(record["path"])): record
+        for record in member_records
+    }
+    observed = 0
+    observations: list[dict[str, object]] = []
+    for name, module in tuple(sys.modules.items()):
+        if name != "pyamplicol" and not name.startswith("pyamplicol."):
+            continue
+        specification = getattr(module, "__spec__", None)
+        origin_value = getattr(specification, "origin", None)
+        if not isinstance(origin_value, str) or origin_value in {
+            "built-in",
+            "frozen",
+        }:
+            origin_value = getattr(module, "__file__", None)
+        if not isinstance(origin_value, str) or not origin_value:
+            locations = getattr(specification, "submodule_search_locations", None)
+            if locations is None:
+                raise RuntimeEvidenceError(
+                    f"loaded pyamplicol module has no filesystem origin: {name}"
+                )
+            for raw_location in locations:
+                try:
+                    location = Path(str(raw_location)).expanduser().resolve(strict=True)
+                except OSError as error:
+                    raise RuntimeEvidenceError(
+                        "loaded pyamplicol namespace is outside the authenticated "
+                        f"package tree: {name}"
+                    ) from error
+                if not any(
+                    location == root or location.is_relative_to(root)
+                    for root in roots
+                ):
+                    raise RuntimeEvidenceError(
+                        "loaded pyamplicol namespace is outside the authenticated "
+                        f"package tree: {name}"
+                    )
+                root_index = next(
+                    index
+                    for index, root in enumerate(roots)
+                    if location == root or location.is_relative_to(root)
+                )
+                relative = location.relative_to(roots[root_index]).as_posix()
+                if "__pycache__" in PurePosixPath(relative).parts:
+                    raise RuntimeEvidenceError(
+                        f"loaded pyamplicol namespace uses excluded cache bytes: {name}"
+                    )
+                observations.append(
+                    {
+                        "module": name,
+                        "kind": "namespace",
+                        "root_index": root_index,
+                        "path": relative,
+                    }
+                )
+            observed += 1
+            continue
+        try:
+            origin = Path(origin_value).expanduser().resolve(strict=True)
+        except OSError as error:
+            raise RuntimeEvidenceError(
+                f"loaded pyamplicol module origin is unavailable: {name}"
+            ) from error
+        in_package = any(
+            origin == root or origin.is_relative_to(root) for root in roots
+        )
+        if not in_package and origin != native:
+            raise RuntimeEvidenceError(
+                "loaded pyamplicol module is outside the authenticated package "
+                f"tree/native image: {name} -> {origin}"
+            )
+        if origin.suffix in {".pyc", ".pyo"}:
+            raise RuntimeEvidenceError(
+                f"loaded pyamplicol module used sourceless bytecode: {name}"
+            )
+        if origin == native:
+            observations.append(
+                {
+                    "module": name,
+                    "kind": "native-extension",
+                    "path": current_native_identity["path"],
+                    "size": current_native_identity["size"],
+                    "sha256": current_native_identity["sha256"],
+                }
+            )
+        else:
+            root_index = next(
+                index
+                for index, root in enumerate(roots)
+                if origin == root or origin.is_relative_to(root)
+            )
+            relative = origin.relative_to(roots[root_index]).as_posix()
+            if "__pycache__" in PurePosixPath(relative).parts:
+                raise RuntimeEvidenceError(
+                    f"loaded pyamplicol module uses excluded cache bytes: {name}"
+                )
+            member = members.get((root_index, relative))
+            if member is None:
+                raise RuntimeEvidenceError(
+                    "loaded pyamplicol module is absent from the authenticated "
+                    f"member set: {name}"
+                )
+            actual = _path_file_identity(origin)
+            if (
+                actual["size"] != member["size"]
+                or actual["sha256"] != member["sha256"]
+            ):
+                raise RuntimeEvidenceError(
+                    f"loaded pyamplicol module bytes changed: {name}"
+                )
+            observations.append(
+                {
+                    "module": name,
+                    "kind": "package-member",
+                    "root_index": root_index,
+                    "path": relative,
+                    "size": member["size"],
+                    "sha256": member["sha256"],
+                }
+            )
+        observed += 1
+    if observed == 0:
+        raise RuntimeEvidenceError("no loaded pyamplicol modules were observed")
+    observations.sort(
+        key=lambda observation: (
+            str(observation["module"]),
+            str(observation["kind"]),
+            str(observation["path"]),
+        )
+    )
+    return {
+        "kind": "pyamplicol-loaded-module-origin-policy-v1",
+        "all_loaded_origins_authenticated": True,
+        "native_image_origin_bound": True,
+        "loaded_bytecode_eligible": False,
+        "observed_module_count": observed,
+        "observations": observations,
+        "observations_sha256": hashlib.sha256(
+            _canonical_json(observations)
+        ).hexdigest(),
+    }
+
+
+__all__ = [
+    "RuntimeEvidenceError",
+    "established_preimport_runtime_identity",
+    "loaded_pyamplicol_origin_policy",
+    "native_extension_in_package",
+    "preimport_python_runtime_identity",
+    "python_package_tree_identity",
+    "source_only_bytecode_policy",
+]
diff --git a/pyamplicol/tools/performance_report/scheduler.py b/pyamplicol/tools/performance_report/scheduler.py
new file mode 100644
index 0000000000..dc8becf524
--- /dev/null
+++ b/pyamplicol/tools/performance_report/scheduler.py
@@ -0,0 +1,3870 @@
+# SPDX-License-Identifier: 0BSD
+"""Dependency-aware, resource-supervised performance-report campaigns."""
+
+from __future__ import annotations
+
+import hashlib
+import heapq
+import json
+import math
+import os
+import re
+import shutil
+import sys
+import time
+import uuid
+from collections.abc import Callable, Mapping, Sequence
+from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait
+from contextlib import ExitStack, suppress
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+
+from .agreements import (
+    INDEPENDENT_AUTHORITY_FIELD,
+    attach_direct_agreements,
+    incoming_agreement_edges,
+    independent_numerical_authorities,
+    validation_baseline_is_required,
+)
+from .artifacts import (
+    ArtifactAction,
+    ArtifactStore,
+    CurrentRecord,
+    LockCancelledError,
+    LockTimeoutError,
+)
+from .cache import validate_measurement
+from .campaign_policy import (
+    MACBOOK_M3_Z_TABLE_F_POLICY,
+    STRICT_POLICY,
+    X86_EPYC_NATIVE_COMPILER_SLOTS,
+    X86_EPYC_PROFILE,
+    CampaignPolicy,
+    CampaignPolicyError,
+    PolicyCensorKind,
+    PolicyMeasurementState,
+    dependency_reference,
+    generation_limit_for_cell,
+    policy_censor_measurement,
+    policy_measurement_state_hint,
+    policy_status_label,
+    resource_frontier_reference,
+    resource_lane_identity,
+    validate_campaign_settings,
+    validate_policy_measurement,
+    validate_policy_profile,
+)
+from .campaign_reset import OriginalAmplicolSeed, load_seed_if_present
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .measurement import failure_measurement, reconcile_independent_authority
+from .measurement_lineage import MeasurementLineage
+from .models import (
+    Accuracy,
+    ArtifactPolicy,
+    CellSpec,
+    ExecutionMode,
+    ModelKey,
+    ResultStatus,
+    Workload,
+)
+from .phase_state import WorkerPhaseChannel
+from .resources import (
+    DEFAULT_ATTEMPT_OUTPUT_LIMIT_BYTES,
+    DEFAULT_MINIMUM_FREE_DISK_BYTES,
+    DEFAULT_SAMPLE_INTERVAL_SECONDS,
+    DEFAULT_TERMINATION_GRACE_SECONDS,
+    GenerationPhaseEvidence,
+    ResourceUsage,
+    SupervisedResult,
+    WorkerObservation,
+    supervise_worker,
+)
+from .runner import DEFAULT_TARGET_RUNTIME_SECONDS
+from .service import CANONICAL_REPORT_ENTRYPOINT, ReportService
+from .source_identity import ReportSourceIdentity, require_eligible_report_source
+from .study_contract import (
+    StudyContractError,
+    authenticate_z_table_f_study_contract,
+    bind_z_table_f_attempt,
+    require_z_table_f_attempt_binding,
+    z_table_f_attempt_binding,
+    z_table_f_cell_ids,
+    z_table_f_worker_harness_identity,
+)
+from .worker_harness import (
+    POLICY_ENTRYPOINT,
+    WorkerHarnessError,
+    attach_worker_harness_identity,
+    require_worker_harness_identity,
+    validate_worker_harness_identity,
+)
+
+_NATIVE_COMPILER_GATE_DIR_ENV = "PYAMPLICOL_NATIVE_COMPILER_GATE_DIR"
+_NATIVE_COMPILER_GATE_SLOT_COUNT_ENV = "PYAMPLICOL_NATIVE_COMPILER_SLOT_COUNT"
+_DIAGNOSTIC_TAIL_BYTES = 64 * 1024
+
+
+@dataclass(frozen=True, slots=True)
+class CellSelection:
+    datasets: frozenset[str] = frozenset()
+    modes: frozenset[ExecutionMode] = frozenset()
+    models: frozenset[ModelKey] = frozenset()
+    accuracies: frozenset[Accuracy] = frozenset()
+    process_keys: frozenset[str] = frozenset()
+    processes: frozenset[str] = frozenset()
+    multiplicities: frozenset[int] = frozenset()
+    variants: frozenset[str] = frozenset()
+    workloads: frozenset[Workload] = frozenset()
+    cell_ids: frozenset[str] = frozenset()
+
+    def matches(self, cell: CellSpec) -> bool:
+        model = cell.measurement.model
+        checks = (
+            not self.datasets or cell.dataset_id in self.datasets,
+            not self.modes or cell.measurement.execution_mode in self.modes,
+            not self.models or model in self.models,
+            not self.accuracies or cell.measurement.accuracy in self.accuracies,
+            not self.process_keys or cell.process_key in self.process_keys,
+            not self.processes or cell.process in self.processes,
+            not self.multiplicities or cell.n_final in self.multiplicities,
+            # Variants are an optional dimension exposed by Z-ladder rows.
+            # Ordinary matrix/reference/scalar rows have no variant to filter.
+            not self.variants or cell.variant is None or cell.variant in self.variants,
+            not self.workloads or cell.workload in self.workloads,
+            not self.cell_ids or cell.cell_id in self.cell_ids,
+        )
+        return all(checks)
+
+
+@dataclass(frozen=True, slots=True)
+class CampaignSettings:
+    workers: int = 1
+    cell_cores: int = 1
+    amplicol_build_jobs: int = 1
+    target_runtime_seconds: float = DEFAULT_TARGET_RUNTIME_SECONDS
+    batch_size: int = 128
+    warmup_runs: int = 2
+    minimum_samples: int = 5
+    timeout_seconds: float | None = None
+    generation_time_limit_seconds: float | None = None
+    profiling_time_limit_seconds: float | None = None
+    validation_time_limit_seconds: float | None = None
+    max_rss_bytes: int | None = None
+    campaign_max_rss_bytes: int | None = None
+    attempt_output_limit_bytes: int = DEFAULT_ATTEMPT_OUTPUT_LIMIT_BYTES
+    minimum_free_disk_bytes: int = DEFAULT_MINIMUM_FREE_DISK_BYTES
+    artifact_policy: ArtifactPolicy = ArtifactPolicy.REGENERATE
+    missing_only: bool = False
+    rerun: bool = False
+    add_optional_dependencies: bool = False
+    original_amplicol_available: bool = False
+    allow_symbolica_parallel: bool = False
+    resource_sample_interval_seconds: float = DEFAULT_SAMPLE_INTERVAL_SECONDS
+    termination_grace_seconds: float = DEFAULT_TERMINATION_GRACE_SECONDS
+    source_identity_override: ReportSourceIdentity | None = None
+    campaign_invocation_id: str | None = None
+    progress_observer: Callable[[Mapping[str, object]], None] | None = None
+    cancellation_requested: Callable[[], bool] | None = None
+    manual_terminal_censors: bool = False
+    discard_cancelled_attempts: bool = False
+    remove_heavy_attempt_artifacts: bool = True
+    retain_workspaces: bool = False
+    campaign_policy: CampaignPolicy = STRICT_POLICY
+    report_profile: str | None = None
+    study_contract_sha256: str | None = None
+    reuse_cross_source_comparison_dependencies: bool = False
+    original_amplicol_repository: Path | None = None
+    original_amplicol_revision: str | None = None
+    madgraph_installation: Path | None = None
+    multiplicity_wave_barrier: bool = False
+
+    def __post_init__(self) -> None:
+        if self.workers < 1 or self.cell_cores < 1 or self.amplicol_build_jobs < 1:
+            raise ValueError(
+                "workers, cell_cores, and amplicol_build_jobs must be positive"
+            )
+        if (
+            not math.isfinite(self.target_runtime_seconds)
+            or self.target_runtime_seconds <= 0.0
+            or self.batch_size < 1
+        ):
+            raise ValueError("target runtime and batch size must be positive")
+        if self.warmup_runs < 0 or self.minimum_samples < 5:
+            raise ValueError("warmups must be non-negative and samples at least five")
+        if (
+            not math.isfinite(self.resource_sample_interval_seconds)
+            or self.resource_sample_interval_seconds <= 0.0
+        ):
+            raise ValueError("resource sample interval must be positive")
+        if (
+            not math.isfinite(self.termination_grace_seconds)
+            or self.termination_grace_seconds < 0.0
+        ):
+            raise ValueError("termination grace must be non-negative")
+        if self.manual_terminal_censors and self.campaign_policy is not STRICT_POLICY:
+            raise ValueError("manual terminal censors require the strict base policy")
+        if self.timeout_seconds is not None and (
+            not math.isfinite(self.timeout_seconds) or self.timeout_seconds <= 0.0
+        ):
+            raise ValueError("timeout_seconds must be positive")
+        if self.generation_time_limit_seconds is not None and (
+            self.generation_time_limit_seconds <= 0.0
+            or not math.isfinite(self.generation_time_limit_seconds)
+        ):
+            raise ValueError("generation_time_limit_seconds must be positive")
+        for field_name, value in (
+            ("profiling_time_limit_seconds", self.profiling_time_limit_seconds),
+            ("validation_time_limit_seconds", self.validation_time_limit_seconds),
+        ):
+            if value is not None and (value <= 0.0 or not math.isfinite(value)):
+                raise ValueError(f"{field_name} must be positive")
+        if self.max_rss_bytes is not None and self.max_rss_bytes <= 0:
+            raise ValueError("max_rss_bytes must be positive")
+        if self.campaign_max_rss_bytes is not None and self.campaign_max_rss_bytes <= 0:
+            raise ValueError("campaign_max_rss_bytes must be positive")
+        if self.attempt_output_limit_bytes <= 0:
+            raise ValueError("attempt_output_limit_bytes must be positive")
+        if self.minimum_free_disk_bytes <= 0:
+            raise ValueError("minimum_free_disk_bytes must be positive")
+        if (
+            self.campaign_max_rss_bytes is not None
+            and self.campaign_max_rss_bytes < self.workers
+        ):
+            raise ValueError(
+                "campaign_max_rss_bytes must provide at least one byte per worker"
+            )
+        if self.campaign_invocation_id is not None and (
+            not self.campaign_invocation_id
+            or len(self.campaign_invocation_id) > 128
+            or not self.campaign_invocation_id.isprintable()
+        ):
+            raise ValueError(
+                "campaign_invocation_id must be 1..128 printable characters"
+            )
+        if self.missing_only and self.rerun:
+            raise ValueError("--missing-only and --rerun are mutually exclusive")
+        if (self.original_amplicol_repository is None) != (
+            self.original_amplicol_revision is None
+        ):
+            raise ValueError(
+                "original AmpliCol repository and revision must be specified together"
+            )
+        if (
+            self.original_amplicol_revision is not None
+            and re.fullmatch(r"[0-9a-f]{40}", self.original_amplicol_revision) is None
+        ):
+            raise ValueError("original AmpliCol revision must be lowercase 40-hex")
+        profile = self.report_profile or ""
+        if self.campaign_policy is not STRICT_POLICY or self.report_profile is not None:
+            validate_policy_profile(self.campaign_policy, profile)
+        if self.campaign_policy is MACBOOK_M3_Z_TABLE_F_POLICY:
+            if self.study_contract_sha256 is None:
+                raise ValueError(
+                    "the Z-table F policy requires a study contract SHA-256"
+                )
+            try:
+                z_table_f_attempt_binding(self.study_contract_sha256)
+            except StudyContractError as error:
+                raise ValueError(str(error)) from error
+        elif self.study_contract_sha256 is not None:
+            raise ValueError("a study contract SHA-256 requires the Z-table F policy")
+        validate_campaign_settings(self.campaign_policy, self)
+
+    def effective_cell_rss_limit(self) -> int | None:
+        """Return the conservative process-tree cap for each cell worker."""
+
+        limits = [
+            limit
+            for limit in (
+                self.max_rss_bytes,
+                (
+                    None
+                    if self.campaign_max_rss_bytes is None
+                    else self.campaign_max_rss_bytes // self.workers
+                ),
+            )
+            if limit is not None
+        ]
+        return min(limits) if limits else None
+
+
+@dataclass(frozen=True, slots=True)
+class PlannedCell:
+    cell: CellSpec
+    dependency: bool
+    baseline_cell_id: str | None
+    rank: int
+    comparison_peer_ids: tuple[str, ...] = ()
+    optional_baseline_cell_id: str | None = None
+    optional_comparison_peer_ids: tuple[str, ...] = ()
+    numerical_authority_cell_ids: tuple[str, ...] = ()
+    force_recompare: bool = False
+    prerequisite_cell_ids: tuple[str, ...] = ()
+    resource_predecessor_ids: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class CellOutcome:
+    cell_id: str
+    status: str
+    detail: str
+    prerequisite_cell_ids: tuple[str, ...] = ()
+    terminal_detail: str | None = None
+
+
+class _CoordinationDeferred(RuntimeError):
+    """Signal that a ready cell lost a non-blocking coordination-lock race."""
+
+    def __init__(self, lock_name: str) -> None:
+        super().__init__(f"coordination lock is busy: {lock_name}")
+        self.lock_name = lock_name
+
+
+class _PreparationFailed(RuntimeError):
+    """Memoized failure of one shared prepared-model prerequisite."""
+
+    def __init__(
+        self,
+        model: ModelKey,
+        reason: str,
+        detail: str,
+        supervised: SupervisedResult | None = None,
+    ) -> None:
+        super().__init__(detail)
+        self.model = model
+        self.reason = reason
+        self.detail = detail
+        self.supervised = supervised
+
+
+def _directional_otf_artifact_owner(
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog,
+) -> CellSpec | None:
+    """Return the sole selected-flow owner for one OTF all-flow artifact."""
+
+    if not (
+        cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+        and cell.measurement.accuracy is Accuracy.LC
+        and cell.workload is Workload.ALL_FLOW
+    ):
+        return None
+    owners = catalog.equivalent_cells(cell)
+    if len(owners) != 1 or owners[0].workload is not Workload.SELECTED_FLOW:
+        raise ValueError(
+            f"OTF all-flow cell {cell.cell_id!r} must have one selected-flow "
+            "artifact owner"
+        )
+    return owners[0]
+
+
+def _artifact_consumer_cell_ids(
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog,
+) -> tuple[str, ...]:
+    consumers = {
+        cell.cell_id,
+        *(candidate.cell_id for candidate in catalog.equivalent_cells(cell)),
+    }
+    if (
+        cell.measurement.execution_mode is ExecutionMode.ON_THE_FLY
+        and cell.measurement.accuracy is Accuracy.LC
+        and cell.workload is Workload.SELECTED_FLOW
+    ):
+        consumers.update(
+            candidate.cell_id
+            for candidate in catalog.measurement_cells()
+            if _directional_otf_artifact_owner(candidate, catalog=catalog) == cell
+        )
+    return tuple(sorted(consumers))
+
+
+def archive_cell_attempt_history(
+    service: ReportService,
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[str, ...]:
+    """Archive one cell's obsolete attempts while preserving live owners."""
+
+    return service.store.archive_obsolete_attempts(
+        cell.cell_id,
+        consumer_cell_ids=_artifact_consumer_cell_ids(cell, catalog=catalog),
+    )
+
+
+def reconcile_attempt_history(
+    service: ReportService,
+    cells: Sequence[CellSpec],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[tuple[str, str], ...]:
+    """Best-effort bounded startup cleanup for an explicit campaign closure."""
+
+    warnings: list[tuple[str, str]] = []
+    for cell in sorted(cells, key=lambda candidate: candidate.cell_id):
+        try:
+            with service.store.named_lock(
+                f"campaign-cell-{cell.cell_id}", timeout=0.0
+            ):
+                archive_cell_attempt_history(service, cell, catalog=catalog)
+        except LockTimeoutError:
+            continue
+        except Exception as error:
+            warnings.append((cell.cell_id, f"{type(error).__name__}: {error}"))
+    return tuple(warnings)
+
+
+def _worker_environment_overrides(
+    settings: CampaignSettings,
+    coordination_root: Path,
+) -> dict[str, str]:
+    """Return identity-neutral cross-controller worker controls."""
+
+    if settings.report_profile != X86_EPYC_PROFILE:
+        return {}
+    return {
+        _NATIVE_COMPILER_GATE_DIR_ENV: os.fspath(
+            coordination_root.resolve() / "native-compiler-slots"
+        ),
+        _NATIVE_COMPILER_GATE_SLOT_COUNT_ENV: str(X86_EPYC_NATIVE_COMPILER_SLOTS),
+    }
+
+
+def _symbolica_generation_lock_path(
+    settings: CampaignSettings,
+    coordination_root: Path,
+    cell: CellSpec,
+) -> Path | None:
+    if (
+        settings.allow_symbolica_parallel
+        or cell.measurement.model is not ModelKey.UFO_SM
+        or cell.measurement.execution_mode is not ExecutionMode.COMPILED
+    ):
+        return None
+    return coordination_root.resolve() / "symbolica-ufo-compiled-generation.lock"
+
+
+@dataclass(frozen=True, slots=True)
+class CampaignResult:
+    planned: tuple[PlannedCell, ...]
+    outcomes: tuple[CellOutcome, ...]
+
+    @property
+    def failed(self) -> tuple[CellOutcome, ...]:
+        return tuple(
+            outcome
+            for outcome in self.outcomes
+            if outcome.status
+            not in {
+                "ok",
+                "reused",
+                "skipped-current",
+                PolicyMeasurementState.GENERATION_LIMIT.value,
+                PolicyMeasurementState.MEMORY_LIMIT.value,
+                PolicyMeasurementState.WORKER_TIMEOUT.value,
+                PolicyMeasurementState.PROFILING_TIMEOUT.value,
+                PolicyMeasurementState.VALIDATION_TIMEOUT.value,
+                PolicyMeasurementState.DEPENDENCY.value,
+                PolicyMeasurementState.RESOURCE_FRONTIER.value,
+            }
+        )
+
+
+def select_cells(
+    selection: CellSelection,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CellSpec, ...]:
+    return tuple(
+        sorted(
+            (cell for cell in catalog.measurement_cells() if selection.matches(cell)),
+            key=lambda cell: cell.cell_id,
+        )
+    )
+
+
+def _rank(cell: CellSpec) -> int:
+    if cell.measurement.execution_mode in {
+        ExecutionMode.AMPLICOL,
+        ExecutionMode.MADGRAPH,
+    }:
+        return 0
+    if cell.measurement.execution_mode is ExecutionMode.RECURRENCE:
+        return 1
+    if cell.dataset_id in {"scalar_contact", "scalar_gravity"}:
+        return 0
+    return 2
+
+
+_READY_MODE_ORDER = {
+    ExecutionMode.MADGRAPH: 0,
+    ExecutionMode.AMPLICOL: 1,
+    ExecutionMode.RECURRENCE: 2,
+    ExecutionMode.COMPILED: 3,
+    ExecutionMode.ON_THE_FLY: 4,
+    ExecutionMode.EAGER: 5,
+}
+
+
+def _ready_priority(cell: CellSpec) -> tuple[object, ...]:
+    """Prefer the authority ladder within one comparable physics cohort.
+
+    Plan-level ordering prerequisites serialize optional authorities when both
+    endpoints are selected.  This priority only orders otherwise-ready cells;
+    independent physics cohorts remain work-conserving.
+    """
+
+    return (
+        cell.process_key or cell.process,
+        cell.n_final,
+        cell.measurement.accuracy.value,
+        cell.workload.value,
+        _READY_MODE_ORDER[cell.measurement.execution_mode],
+        "" if cell.measurement.model is None else cell.measurement.model.value,
+        cell.variant or "",
+        cell.cell_id,
+    )
+
+
+def _successful_current(
+    store: ArtifactStore,
+    cell_id: str,
+    *,
+    expected_revision: str | None = None,
+    expected_tree: str | None = None,
+    expected_cell: CellSpec | None = None,
+    measurement_lineage: MeasurementLineage | None = None,
+    expected_study_contract_sha256: str | None = None,
+    expected_worker_harness: Mapping[str, object] | None = None,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> CurrentRecord | None:
+    current = store.load_current(cell_id, missing_ok=True)
+    if current is None or current.result.get("status") != ResultStatus.OK.value:
+        return None
+    try:
+        validate_measurement(
+            current.result,
+            expected_cell=expected_cell,
+            catalog=catalog,
+        )
+        if expected_study_contract_sha256 is not None:
+            require_z_table_f_attempt_binding(
+                current.result,
+                expected_study_contract_sha256,
+            )
+            if expected_worker_harness is None:
+                raise WorkerHarnessError("the expected worker harness is unavailable")
+            require_worker_harness_identity(
+                current.result,
+                expected=expected_worker_harness,
+            )
+    except (StudyContractError, ValueError):
+        return None
+    if expected_revision is not None:
+        provenance = current.result.get("provenance")
+        if measurement_lineage is not None and expected_tree is not None:
+            source = measurement_lineage.source_for_current(
+                current,
+                active_revision=expected_revision,
+                active_tree=expected_tree,
+            )
+        else:
+            source = (
+                (expected_revision, expected_tree or "")
+                if isinstance(provenance, Mapping)
+                and provenance.get("report_source_revision") == expected_revision
+                and (
+                    expected_tree is None
+                    or provenance.get("report_source_tree") == expected_tree
+                )
+                else None
+            )
+        if source is None:
+            return None
+    return current
+
+
+def _policy_current(
+    store: ArtifactStore,
+    cell: CellSpec,
+    *,
+    settings: CampaignSettings,
+    expected_revision: str | None,
+    expected_tree: str | None = None,
+    measurement_lineage: MeasurementLineage | None = None,
+    original_amplicol_seed: OriginalAmplicolSeed | None = None,
+    expected_worker_harness: Mapping[str, object] | None = None,
+    comparison_dependency: bool = False,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+    if settings.campaign_policy is STRICT_POLICY:
+        current = _successful_current(
+            store,
+            cell.cell_id,
+            expected_revision=expected_revision,
+            expected_tree=expected_tree,
+            expected_cell=cell,
+            measurement_lineage=measurement_lineage,
+            expected_study_contract_sha256=(settings.study_contract_sha256),
+            expected_worker_harness=expected_worker_harness,
+            catalog=catalog,
+        )
+        if current is not None:
+            return current, PolicyMeasurementState.SUCCESS
+        if not settings.manual_terminal_censors:
+            return None
+        terminal = store.load_current(cell.cell_id, missing_ok=True)
+        if terminal is None:
+            return None
+        state = policy_measurement_state_hint(terminal.result)
+        if state is None or policy_status_label(terminal.result) is None:
+            return None
+        provenance = terminal.result.get("provenance")
+        if expected_revision is not None and (
+            not isinstance(provenance, Mapping)
+            or provenance.get("report_source_revision") != expected_revision
+        ):
+            return None
+        try:
+            validate_measurement(
+                terminal.result,
+                expected_cell=cell,
+                catalog=catalog,
+            )
+        except ValueError:
+            return None
+        return terminal, state
+    current = store.load_current(cell.cell_id, missing_ok=True)
+    if current is None or expected_revision is None:
+        return None
+    provenance = current.result.get("provenance")
+    expected_source = (
+        measurement_lineage.source_for_current(
+            current,
+            active_revision=expected_revision,
+            active_tree=expected_tree or "",
+        )
+        if measurement_lineage is not None and expected_tree is not None
+        else (
+            (expected_revision, expected_tree)
+            if isinstance(provenance, Mapping)
+            and provenance.get("report_source_revision") == expected_revision
+            and (
+                expected_tree is None
+                or provenance.get("report_source_tree") == expected_tree
+            )
+            else None
+        )
+    )
+    if expected_source is None and original_amplicol_seed is not None:
+        expected_source = original_amplicol_seed.source_for_current(
+            current,
+            active_revision=expected_revision,
+            active_tree=expected_tree or "",
+        )
+    cross_source = (
+        expected_source is None
+        and comparison_dependency
+        and settings.reuse_cross_source_comparison_dependencies
+        and isinstance(provenance, Mapping)
+        and isinstance(provenance.get("report_source_revision"), str)
+        and isinstance(provenance.get("report_source_tree"), str)
+    )
+    if cross_source:
+        expected_source = (
+            str(provenance["report_source_revision"]),
+            str(provenance["report_source_tree"]),
+        )
+    if expected_source is None:
+        return None
+    try:
+        validate_measurement(
+            current.result,
+            expected_cell=cell,
+            catalog=catalog,
+        )
+        if settings.study_contract_sha256 is not None and not cross_source:
+            require_z_table_f_attempt_binding(
+                current.result,
+                settings.study_contract_sha256,
+            )
+            if expected_worker_harness is None:
+                raise WorkerHarnessError("the expected worker harness is unavailable")
+            require_worker_harness_identity(
+                current.result,
+                expected=expected_worker_harness,
+            )
+        state = validate_policy_measurement(
+            settings.campaign_policy,
+            settings.report_profile or "",
+            cell,
+            current.result,
+            expected_source_revision=expected_source[0],
+            expected_source_tree=expected_source[1],
+        )
+    except (CampaignPolicyError, StudyContractError, ValueError):
+        return None
+    return current, state
+
+
+def _resource_lane_key(cell: CellSpec) -> tuple[object, ...]:
+    """Identify one monotone multiplicity lane across the report catalog."""
+
+    return tuple(resource_lane_identity(cell).items())
+
+
+def _resource_lane_lock_name(cell: CellSpec) -> str:
+    encoded = json.dumps(
+        resource_lane_identity(cell),
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return f"campaign-resource-lane-{hashlib.sha256(encoded).hexdigest()}"
+
+
+def _resource_frontier_source(
+    store: ArtifactStore,
+    cell: CellSpec,
+    *,
+    settings: CampaignSettings,
+    catalog: ReportCatalog,
+    expected_revision: str | None,
+    expected_tree: str | None,
+    measurement_lineage: MeasurementLineage | None = None,
+    original_amplicol_seed: OriginalAmplicolSeed | None = None,
+    expected_worker_harness: Mapping[str, object] | None = None,
+    lane_cells: Sequence[CellSpec] | None = None,
+    current_resolver: (
+        Callable[
+            [CellSpec],
+            tuple[CurrentRecord, PolicyMeasurementState] | None,
+        ]
+        | None
+    ) = None,
+) -> tuple[CellSpec, CurrentRecord, PolicyMeasurementState] | None:
+    """Return the first authenticated lower-multiplicity hard resource censor."""
+
+    if not settings.campaign_policy.allow_terminal_censors:
+        return None
+    lane = _resource_lane_key(cell)
+    sources: list[tuple[CellSpec, CurrentRecord, PolicyMeasurementState]] = []
+    candidates = catalog.measurement_cells() if lane_cells is None else lane_cells
+    for candidate in candidates:
+        if candidate.n_final >= cell.n_final or _resource_lane_key(candidate) != lane:
+            continue
+        current = (
+            current_resolver(candidate)
+            if current_resolver is not None
+            else _policy_current(
+                store,
+                candidate,
+                settings=settings,
+                expected_revision=expected_revision,
+                expected_tree=expected_tree,
+                measurement_lineage=measurement_lineage,
+                original_amplicol_seed=original_amplicol_seed,
+                expected_worker_harness=expected_worker_harness,
+                catalog=catalog,
+            )
+        )
+        if current is None:
+            continue
+        record, state = current
+        if state in {
+            PolicyMeasurementState.GENERATION_LIMIT,
+            PolicyMeasurementState.MEMORY_LIMIT,
+        }:
+            sources.append((candidate, record, state))
+    return min(sources, key=lambda item: item[0].n_final) if sources else None
+
+
+def _frontier_reference(
+    source: tuple[CellSpec, CurrentRecord, PolicyMeasurementState],
+    cell: CellSpec,
+) -> dict[str, object]:
+    source_cell, record, _state = source
+    return resource_frontier_reference(cell, source_cell, record.result)
+
+
+def _measurement_frontier(
+    measurement: Mapping[str, object],
+) -> object:
+    provenance = measurement.get("provenance")
+    censor = (
+        provenance.get("policy_censor") if isinstance(provenance, Mapping) else None
+    )
+    return censor.get("frontier") if isinstance(censor, Mapping) else None
+
+
+def _partition_dependency_records(
+    *,
+    baseline_cell_id: str | None,
+    comparison_peer_ids: Sequence[str],
+    optional_baseline_cell_id: str | None = None,
+    optional_comparison_peer_ids: Sequence[str] = (),
+    currents: Mapping[
+        str,
+        tuple[CurrentRecord, PolicyMeasurementState],
+    ],
+) -> tuple[
+    CurrentRecord | None,
+    dict[str, CurrentRecord],
+    tuple[dict[str, object], ...],
+]:
+    """Partition successful dependencies and retain every terminal blocker."""
+
+    baseline_record: CurrentRecord | None = None
+    terminal_required: list[dict[str, object]] = []
+    terminal_ids: set[str] = set()
+    if baseline_cell_id is not None:
+        record, state = currents[baseline_cell_id]
+        if state is PolicyMeasurementState.SUCCESS:
+            baseline_record = record
+        else:
+            terminal_required.append(
+                dependency_reference(baseline_cell_id, record.result)
+            )
+            terminal_ids.add(baseline_cell_id)
+    elif optional_baseline_cell_id is not None:
+        optional = currents.get(optional_baseline_cell_id)
+        if optional is not None and optional[1] is PolicyMeasurementState.SUCCESS:
+            baseline_record = optional[0]
+    peer_records: dict[str, CurrentRecord] = {}
+    for peer_cell_id in comparison_peer_ids:
+        record, state = currents[peer_cell_id]
+        if state is PolicyMeasurementState.SUCCESS:
+            peer_records[peer_cell_id] = record
+        elif peer_cell_id not in terminal_ids:
+            terminal_required.append(
+                dependency_reference(peer_cell_id, record.result)
+            )
+            terminal_ids.add(peer_cell_id)
+    for peer_cell_id in optional_comparison_peer_ids:
+        optional = currents.get(peer_cell_id)
+        if optional is not None and optional[1] is PolicyMeasurementState.SUCCESS:
+            peer_records[peer_cell_id] = optional[0]
+    return baseline_record, peer_records, tuple(terminal_required)
+
+
+def _fresh_equivalent_current(
+    store: ArtifactStore,
+    cell: CellSpec,
+    *,
+    catalog: ReportCatalog,
+    expected_revision: str,
+    expected_tree: str | None = None,
+    measurement_lineage: MeasurementLineage | None = None,
+    expected_study_contract_sha256: str | None = None,
+    expected_worker_harness: Mapping[str, object] | None = None,
+) -> CurrentRecord | None:
+    if cell.measurement.execution_mode is ExecutionMode.AMPLICOL:
+        return None
+    for equivalent in catalog.equivalent_cells(cell):
+        current = _successful_current(
+            store,
+            equivalent.cell_id,
+            expected_revision=expected_revision,
+            expected_tree=expected_tree,
+            expected_cell=equivalent,
+            measurement_lineage=measurement_lineage,
+            expected_study_contract_sha256=(expected_study_contract_sha256),
+            expected_worker_harness=expected_worker_harness,
+            catalog=catalog,
+        )
+        if current is not None:
+            return current
+    return None
+
+
+def plan_campaign(
+    requested: Sequence[CellSpec],
+    *,
+    store: ArtifactStore,
+    settings: CampaignSettings,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    expected_revision: str | None = None,
+    expected_tree: str | None = None,
+    measurement_lineage: MeasurementLineage | None = None,
+    original_amplicol_seed: OriginalAmplicolSeed | None = None,
+    excluded_cell_ids: frozenset[str] = frozenset(),
+    expected_worker_harness: Mapping[str, object] | None = None,
+    current_resolver: (
+        Callable[
+            [CellSpec],
+            tuple[CurrentRecord, PolicyMeasurementState] | None,
+        ]
+        | None
+    ) = None,
+) -> tuple[PlannedCell, ...]:
+    requested_ids = {cell.cell_id for cell in requested}
+    needed: dict[str, CellSpec] = {}
+    force_recompare_ids: set[str] = set()
+    visiting: set[str] = set()
+    resource_lanes: dict[tuple[object, ...], list[CellSpec]] = {}
+    if original_amplicol_seed is None and settings.report_profile is not None:
+        original_amplicol_seed = load_seed_if_present(
+            profile=settings.report_profile,
+            store=store,
+        )
+    if settings.campaign_policy.allow_terminal_censors:
+        for catalog_cell in catalog.measurement_cells():
+            if catalog.static_na_reason(catalog_cell) is not None:
+                continue
+            resource_lanes.setdefault(
+                _resource_lane_key(catalog_cell),
+                [],
+            ).append(catalog_cell)
+
+    def resolve_current(
+        cell: CellSpec,
+        *,
+        comparison_dependency: bool = False,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+        if current_resolver is not None:
+            return current_resolver(cell)
+        return _policy_current(
+            store,
+            cell,
+            settings=settings,
+            expected_revision=expected_revision,
+            expected_tree=expected_tree,
+            measurement_lineage=measurement_lineage,
+            original_amplicol_seed=original_amplicol_seed,
+            expected_worker_harness=expected_worker_harness,
+            comparison_dependency=comparison_dependency,
+            catalog=catalog,
+        )
+
+    def dependency_roles(
+        cell: CellSpec,
+    ) -> tuple[
+        CellSpec | None,
+        CellSpec | None,
+        tuple[CellSpec, ...],
+        tuple[CellSpec, ...],
+    ]:
+        candidate_baseline = catalog.validation_baseline_cell(cell)
+        baseline_required = validation_baseline_is_required(cell, candidate_baseline)
+        edges = incoming_agreement_edges(cell, catalog=catalog)
+        return (
+            candidate_baseline if baseline_required else None,
+            candidate_baseline if not baseline_required else None,
+            tuple(edge.baseline for edge in edges if edge.required),
+            tuple(edge.baseline for edge in edges if not edge.required),
+        )
+
+    def numerical_authorities(cell: CellSpec) -> tuple[CellSpec, ...]:
+        """Return ordered, availability-only numerical authorities.
+
+        Construction, selector/provider, cross-layout, and built-in/UFO
+        dependencies remain represented by the ordinary hard dependency
+        roles.  This list is only the independent numerical baseline chain
+        for compiled/eager measurements: recurrence first, then matching
+        original AmpliCol when the catalog exposes it.
+        """
+
+        return independent_numerical_authorities(cell, catalog=catalog)
+
+    def higher_priority_authority_is_now_successful(
+        cell: CellSpec,
+        current: CurrentRecord,
+    ) -> bool:
+        """Whether a verified current must be reconciled with a newer peer."""
+
+        authorities = numerical_authorities(cell)
+        if not authorities:
+            return False
+        validation = current.result.get("validation")
+        record = (
+            validation.get(INDEPENDENT_AUTHORITY_FIELD)
+            if isinstance(validation, Mapping)
+            else None
+        )
+        if not isinstance(record, Mapping):
+            # Existing verified currents predate the durable authority record;
+            # preserve their byte-for-byte reuse contract.
+            return False
+        authority_ids = tuple(authority.cell_id for authority in authorities)
+        if tuple(record.get("expected_cell_ids", ())) != authority_ids:
+            return True
+        selected_id = record.get("selected_cell_id")
+        if not isinstance(selected_id, str) or selected_id not in authority_ids:
+            return True
+        selected_index = authority_ids.index(selected_id)
+        return any(
+            (
+                resolved := resolve_current(
+                    authority,
+                    comparison_dependency=True,
+                )
+            )
+            is not None
+            and resolved[1] is PolicyMeasurementState.SUCCESS
+            for authority in authorities[:selected_index]
+        )
+
+    def dependencies(cell: CellSpec) -> tuple[CellSpec, ...]:
+        baseline, _optional_baseline, peers, _optional_peers = dependency_roles(cell)
+        return tuple(
+            {
+                dependency.cell_id: dependency
+                for dependency in (
+                    *((baseline,) if baseline is not None else ()),
+                    *peers,
+                )
+            }.values()
+        )
+
+    def optional_dependencies(cell: CellSpec) -> tuple[CellSpec, ...]:
+        _baseline, optional_baseline, _peers, optional_peers = dependency_roles(cell)
+        return tuple(
+            {
+                dependency.cell_id: dependency
+                for dependency in (
+                    *((optional_baseline,) if optional_baseline is not None else ()),
+                    *optional_peers,
+                )
+            }.values()
+        )
+
+    def automatically_added_authorities(cell: CellSpec) -> tuple[CellSpec, ...]:
+        """Return the runnable optional numerical-authority closure."""
+
+        if not settings.add_optional_dependencies:
+            return ()
+        candidates = list(numerical_authorities(cell))
+        if cell.measurement.execution_mode is ExecutionMode.RECURRENCE:
+            baseline = catalog.validation_baseline_cell(cell)
+            if (
+                baseline is not None
+                and not validation_baseline_is_required(cell, baseline)
+                and baseline.measurement.execution_mode is ExecutionMode.AMPLICOL
+            ):
+                candidates.append(baseline)
+        return tuple(
+            {
+                authority.cell_id: authority
+                for authority in candidates
+                if (
+                    authority.measurement.execution_mode is not ExecutionMode.AMPLICOL
+                    or settings.original_amplicol_available
+                )
+            }.values()
+        )
+
+    exclusion_memo: dict[str, bool] = {}
+    exclusion_visiting: set[str] = set()
+
+    def blocked_by_exclusion(cell: CellSpec) -> bool:
+        cached = exclusion_memo.get(cell.cell_id)
+        if cached is not None:
+            return cached
+        if cell.cell_id in excluded_cell_ids:
+            exclusion_memo[cell.cell_id] = True
+            return True
+        if cell.cell_id in exclusion_visiting:
+            raise ValueError(
+                f"report comparison dependency cycle reaches {cell.cell_id!r}"
+            )
+        exclusion_visiting.add(cell.cell_id)
+        try:
+            blocked = any(
+                blocked_by_exclusion(dependency)
+                for dependency in dependencies(cell)
+                if resolve_current(
+                    dependency,
+                    comparison_dependency=True,
+                )
+                is None
+            )
+        finally:
+            exclusion_visiting.remove(cell.cell_id)
+        exclusion_memo[cell.cell_id] = blocked
+        return blocked
+
+    def include(cell: CellSpec, *, explicitly_requested: bool) -> None:
+        if catalog.static_na_reason(cell) is not None:
+            return
+        if blocked_by_exclusion(cell):
+            return
+        cell_dependencies = dependencies(cell)
+        dependency_currents = {
+            dependency.cell_id: resolve_current(
+                dependency,
+                comparison_dependency=True,
+            )
+            for dependency in cell_dependencies
+        }
+        missing_dependencies = tuple(
+            dependency
+            for dependency in cell_dependencies
+            if dependency_currents[dependency.cell_id] is None
+        )
+        terminal_dependency_cells = tuple(
+            dependency
+            for dependency in cell_dependencies
+            if (
+                dependency_currents[dependency.cell_id] is not None
+                and dependency_currents[dependency.cell_id][1]  # type: ignore[index]
+                is not PolicyMeasurementState.SUCCESS
+            )
+        )
+        terminal_dependencies = tuple(
+            dependency_reference(
+                dependency.cell_id,
+                dependency_currents[dependency.cell_id][0].result,  # type: ignore[index]
+            )
+            for dependency in terminal_dependency_cells
+            if not settings.manual_terminal_censors
+        )
+        current = resolve_current(cell)
+        frontier_source = _resource_frontier_source(
+            store,
+            cell,
+            settings=settings,
+            catalog=catalog,
+            expected_revision=expected_revision,
+            expected_tree=expected_tree,
+            measurement_lineage=measurement_lineage,
+            original_amplicol_seed=original_amplicol_seed,
+            expected_worker_harness=expected_worker_harness,
+            lane_cells=resource_lanes.get(_resource_lane_key(cell), ()),
+            current_resolver=resolve_current,
+        )
+        expected_frontier = (
+            None
+            if frontier_source is None
+            else _frontier_reference(frontier_source, cell)
+        )
+        fresh_requested = False
+        if settings.missing_only and explicitly_requested and current is not None:
+            _record, state = current
+            if frontier_source is not None:
+                fresh_requested = (
+                    state is PolicyMeasurementState.RESOURCE_FRONTIER
+                    and _measurement_frontier(_record.result) == expected_frontier
+                )
+            elif state is PolicyMeasurementState.SUCCESS:
+                fresh_requested = (
+                    not missing_dependencies and not terminal_dependency_cells
+                    and not higher_priority_authority_is_now_successful(
+                        cell,
+                        _record,
+                    )
+                )
+            elif state is PolicyMeasurementState.DEPENDENCY:
+                provenance = _record.result.get("provenance")
+                censor = (
+                    provenance.get("policy_censor")
+                    if isinstance(provenance, Mapping)
+                    else None
+                )
+                observed = (
+                    censor.get("dependencies") if isinstance(censor, Mapping) else None
+                )
+                fresh_requested = (
+                    not missing_dependencies
+                    and bool(terminal_dependencies)
+                    and observed
+                    == list(
+                        sorted(
+                            terminal_dependencies,
+                            key=lambda item: str(item["cell_id"]),
+                        )
+                    )
+                )
+            elif state is PolicyMeasurementState.RESOURCE_FRONTIER:
+                fresh_requested = False
+            else:
+                fresh_requested = True
+        if fresh_requested:
+            return
+        if settings.missing_only and explicitly_requested and current is not None:
+            force_recompare_ids.add(cell.cell_id)
+        if cell.cell_id in needed:
+            return
+        if cell.cell_id in visiting:
+            raise ValueError(
+                f"report comparison dependency cycle reaches {cell.cell_id!r}"
+            )
+        visiting.add(cell.cell_id)
+        if frontier_source is None:
+            owner = _directional_otf_artifact_owner(cell, catalog=catalog)
+            refresh_owner = owner is not None and (
+                settings.artifact_policy is ArtifactPolicy.REGENERATE
+                or settings.rerun
+            )
+            required_generation_dependencies = {
+                dependency.cell_id: dependency for dependency in missing_dependencies
+            }
+            if refresh_owner:
+                required_generation_dependencies[owner.cell_id] = owner
+            for dependency in required_generation_dependencies.values():
+                include(dependency, explicitly_requested=False)
+            for authority in automatically_added_authorities(cell):
+                if (
+                    resolve_current(
+                        authority,
+                        comparison_dependency=True,
+                    )
+                    is None
+                ):
+                    include(authority, explicitly_requested=False)
+        visiting.remove(cell.cell_id)
+        needed[cell.cell_id] = cell
+
+    for cell in requested:
+        include(cell, explicitly_requested=True)
+
+    if settings.campaign_policy.allow_terminal_censors:
+        scheduled = tuple(needed.values())
+        for cell in requested:
+            if cell.cell_id in needed:
+                continue
+            if catalog.static_na_reason(cell) is not None:
+                continue
+            if blocked_by_exclusion(cell):
+                continue
+            if any(
+                predecessor.n_final < cell.n_final
+                and _resource_lane_key(predecessor) == _resource_lane_key(cell)
+                for predecessor in scheduled
+            ):
+                # The lower cell will run in this campaign. Retain the higher
+                # fresh current for a post-wave frontier rescan; _run_cell
+                # returns without launching it when the lower cell succeeds.
+                needed[cell.cell_id] = cell
+
+    def scheduled_dependencies(cell: CellSpec) -> tuple[CellSpec, ...]:
+        return tuple(
+            {
+                dependency.cell_id: dependency
+                for dependency in (
+                    *dependencies(cell),
+                    *optional_dependencies(cell),
+                )
+                if dependency.cell_id in needed
+            }.values()
+        )
+
+    ranks: dict[str, int] = {}
+
+    def planned_rank(cell: CellSpec) -> int:
+        if cell.cell_id in ranks:
+            return ranks[cell.cell_id]
+        rank = _rank(cell)
+        for dependency in scheduled_dependencies(cell):
+            scheduled = needed.get(dependency.cell_id)
+            if scheduled is not None:
+                rank = max(rank, planned_rank(scheduled) + 1)
+        if settings.campaign_policy.allow_terminal_censors:
+            predecessors = tuple(
+                candidate
+                for candidate in needed.values()
+                if candidate.n_final < cell.n_final
+                and _resource_lane_key(candidate) == _resource_lane_key(cell)
+            )
+            if predecessors:
+                predecessor = max(
+                    predecessors,
+                    key=lambda item: item.n_final,
+                )
+                rank = max(rank, planned_rank(predecessor) + 1)
+        ranks[cell.cell_id] = rank
+        return rank
+
+    def validation_baseline_id(cell: CellSpec) -> str | None:
+        baseline, _optional, _peers, _optional_peers = dependency_roles(cell)
+        return None if baseline is None else baseline.cell_id
+
+    def optional_baseline_id(cell: CellSpec) -> str | None:
+        _baseline, optional, _peers, _optional_peers = dependency_roles(cell)
+        return None if optional is None else optional.cell_id
+
+    def comparison_peer_ids(cell: CellSpec) -> tuple[str, ...]:
+        _baseline, _optional, peers, _optional_peers = dependency_roles(cell)
+        return tuple(peer.cell_id for peer in peers)
+
+    def optional_comparison_peer_ids(cell: CellSpec) -> tuple[str, ...]:
+        _baseline, _optional, _peers, optional_peers = dependency_roles(cell)
+        return tuple(peer.cell_id for peer in optional_peers)
+
+    def scheduled_prerequisite_ids(cell: CellSpec) -> tuple[str, ...]:
+        return tuple(
+            sorted(
+                dependency.cell_id for dependency in scheduled_dependencies(cell)
+            )
+        )
+
+    def resource_predecessor_ids(cell: CellSpec) -> tuple[str, ...]:
+        if not settings.campaign_policy.allow_terminal_censors:
+            return ()
+        predecessors = tuple(
+            candidate
+            for candidate in needed.values()
+            if candidate.n_final < cell.n_final
+            and _resource_lane_key(candidate) == _resource_lane_key(cell)
+        )
+        if not predecessors:
+            return ()
+        predecessor = max(
+            predecessors,
+            key=lambda item: (item.n_final, item.cell_id),
+        )
+        return (predecessor.cell_id,)
+
+    return tuple(
+        PlannedCell(
+            cell=cell,
+            dependency=cell.cell_id not in requested_ids,
+            baseline_cell_id=validation_baseline_id(cell),
+            rank=planned_rank(cell),
+            comparison_peer_ids=comparison_peer_ids(cell),
+            optional_baseline_cell_id=optional_baseline_id(cell),
+            optional_comparison_peer_ids=optional_comparison_peer_ids(cell),
+            numerical_authority_cell_ids=tuple(
+                authority.cell_id for authority in numerical_authorities(cell)
+            ),
+            force_recompare=cell.cell_id in force_recompare_ids,
+            prerequisite_cell_ids=scheduled_prerequisite_ids(cell),
+            resource_predecessor_ids=resource_predecessor_ids(cell),
+        )
+        for cell in sorted(
+            needed.values(),
+            key=lambda item: (planned_rank(item), item.cell_id),
+        )
+    )
+
+
+def validate_campaign_plan(
+    planned: Sequence[PlannedCell],
+    settings: CampaignSettings,
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> None:
+    """Enforce study-wide plan constraints before any attempt is created."""
+
+    if settings.campaign_policy is not MACBOOK_M3_Z_TABLE_F_POLICY:
+        return
+    if len(planned) != 1 or planned[0].dependency:
+        raise StudyContractError(
+            "the Z-table F policy requires exactly one runnable requested "
+            "cell; all comparison dependencies must already have "
+            "authenticated currents"
+        )
+    cell_id = planned[0].cell.cell_id
+    if cell_id not in frozenset(z_table_f_cell_ids()):
+        raise StudyContractError(
+            f"cell {cell_id!r} is outside the contracted 32-cell Z-table F scope"
+        )
+    baseline = catalog.validation_baseline_cell(planned[0].cell)
+    baseline_required = validation_baseline_is_required(planned[0].cell, baseline)
+    expected_baseline_id = (
+        baseline.cell_id if baseline is not None and baseline_required else None
+    )
+    expected_optional_baseline_id = (
+        baseline.cell_id if baseline is not None and not baseline_required else None
+    )
+    edges = incoming_agreement_edges(planned[0].cell, catalog=catalog)
+    expected_peer_ids = tuple(
+        edge.baseline.cell_id for edge in edges if edge.required
+    )
+    expected_optional_peer_ids = tuple(
+        edge.baseline.cell_id for edge in edges if not edge.required
+    )
+    if (
+        planned[0].baseline_cell_id != expected_baseline_id
+        or planned[0].comparison_peer_ids != expected_peer_ids
+        or planned[0].optional_baseline_cell_id
+        != expected_optional_baseline_id
+        or planned[0].optional_comparison_peer_ids
+        != expected_optional_peer_ids
+    ):
+        raise StudyContractError(
+            "the Z-table F runnable cell does not carry its canonical "
+            "comparison dependency plan"
+        )
+
+
+def _resource_payload(
+    usage: ResourceUsage,
+    generation_phase: GenerationPhaseEvidence | None = None,
+    *,
+    memory_limit_bytes: int | None = None,
+    memory_limit_reason: str | None = None,
+    supervised: SupervisedResult | None = None,
+    source_revision: str | None = None,
+    campaign_invocation_id: str | None = None,
+    supervisor_phase: str | None = None,
+) -> dict[str, object]:
+    payload: dict[str, object] = {
+        "available": usage.available,
+        "current_rss_bytes": usage.current_rss_bytes,
+        "peak_rss_bytes": usage.peak_rss_bytes,
+        "child_count": usage.child_count,
+        "cpu_seconds": usage.cpu_seconds,
+        "wall_seconds": usage.wall_seconds,
+        "probe_error": usage.error,
+    }
+    if usage.memory_metric_abi is not None:
+        payload.update(
+            {
+                "memory_metric_abi": usage.memory_metric_abi,
+                "current_physical_footprint_bytes": (
+                    usage.current_physical_footprint_bytes
+                ),
+                "peak_physical_footprint_bytes": (usage.peak_physical_footprint_bytes),
+                "current_guard_bytes": usage.current_guard_bytes,
+                "peak_guard_bytes": usage.peak_guard_bytes,
+                "memory_limit_bytes": memory_limit_bytes,
+                "memory_limit_reason": memory_limit_reason,
+                "memory_probe_reason": usage.memory_probe_reason,
+            }
+        )
+    if generation_phase is not None:
+        payload["generation_phase"] = generation_phase.as_dict()
+    if supervised is not None:
+        supervisor_payload: dict[str, object] = {
+            "abi": "pyamplicol-report-worker-supervisor-v1",
+            "reason": supervised.reason,
+            "returncode": supervised.returncode,
+            "signal_number": supervised.signal_number,
+            "signal_name": supervised.signal_name,
+            "pid": supervised.pid,
+            "member_pids": list(supervised.member_pids),
+            "phase": (
+                supervisor_phase
+                if supervisor_phase is not None
+                else (
+                    None
+                    if generation_phase is None
+                    else generation_phase.final_phase
+                )
+            ),
+            "phase_state_error": supervised.phase_state_error,
+            "stderr": supervised.supervisor_stderr,
+            "stderr_truncated": supervised.supervisor_stderr_truncated,
+            "stderr_limit_bytes": supervised.supervisor_stderr_limit_bytes,
+            "source_revision": source_revision,
+            "campaign_invocation_id": campaign_invocation_id,
+            "started_at_utc": supervised.started_at_utc,
+            "finished_at_utc": supervised.finished_at_utc,
+            "teardown_escalated": supervised.teardown_escalated,
+            "teardown_seconds": supervised.teardown_seconds,
+        }
+        if (
+            supervised.output_limit_path is not None
+            or supervised.output_limit_bytes is not None
+            or supervised.observed_output_bytes is not None
+        ):
+            supervisor_payload.update(
+                {
+                    "output_limit_path": supervised.output_limit_path,
+                    "output_limit_bytes": supervised.output_limit_bytes,
+                    "observed_output_bytes": supervised.observed_output_bytes,
+                }
+            )
+        if supervised.minimum_free_disk_bytes is not None:
+            supervisor_payload.update(
+                {
+                    "minimum_free_disk_bytes": (supervised.minimum_free_disk_bytes),
+                    "observed_free_disk_bytes": (supervised.observed_free_disk_bytes),
+                }
+            )
+        payload["supervisor"] = supervisor_payload
+    return payload
+
+
+class WorkerProcessExitError(RuntimeError):
+    """A worker process exited independently of a supervisor resource cap."""
+
+
+def _worker_process_exit_error(supervised: SupervisedResult) -> WorkerProcessExitError:
+    if supervised.signal_name is not None and supervised.signal_number is not None:
+        detail = (
+            f"worker terminated by {supervised.signal_name} "
+            f"(signal {supervised.signal_number}, return code {supervised.returncode})"
+        )
+    else:
+        detail = f"worker exited with code {supervised.returncode}"
+    return WorkerProcessExitError(detail)
+
+
+def _measurement_terminal_detail(result: Mapping[str, object]) -> str | None:
+    """Return the compact persisted reason carried by a terminal event."""
+
+    policy_label = policy_status_label(result)
+    if isinstance(policy_label, str) and policy_label.strip():
+        return policy_label
+    failure = result.get("failure")
+    message = failure.get("message") if isinstance(failure, Mapping) else None
+    return message if isinstance(message, str) and message.strip() else None
+
+
+def _attempt_files(
+    root: Path,
+    *,
+    include_heavy_artifact: bool = True,
+) -> tuple[str, ...]:
+    members: list[str] = []
+    for path in root.rglob("*"):
+        if (
+            not path.is_file()
+            or path.name in {"manifest.json", "result.json"}
+            or path.is_symlink()
+        ):
+            continue
+        relative = path.relative_to(root)
+        if not include_heavy_artifact and relative.parts[0] == "artifact":
+            continue
+        members.append(relative.as_posix())
+    return tuple(sorted(members))
+
+
+class CampaignScheduler:
+    def __init__(
+        self,
+        service: ReportService,
+        *,
+        settings: CampaignSettings,
+        catalog: ReportCatalog | None = None,
+        measurement_lineage: MeasurementLineage | None = None,
+        measurement_lineage_authenticated: bool = False,
+        study_contract: Mapping[str, object] | None = None,
+        study_contract_wrapper_root: Path | None = None,
+    ) -> None:
+        self.service = service
+        self.settings = settings
+        self.catalog = service.catalog if catalog is None else catalog
+        self.source_identity = (
+            settings.source_identity_override
+            if settings.source_identity_override is not None
+            else require_eligible_report_source(service.paths.repo_root)
+        )
+        self.source_revision = self.source_identity.revision
+        self.source_tree = self.source_identity.tree
+        if settings.campaign_policy is MACBOOK_M3_Z_TABLE_F_POLICY:
+            if study_contract is None or study_contract_wrapper_root is None:
+                raise StudyContractError(
+                    "the Z-table F scheduler requires the authenticated "
+                    "study contract, not only a SHA-256"
+                )
+            authenticated_contract = authenticate_z_table_f_study_contract(
+                study_contract,
+                service.paths.repo_root,
+                study_contract_wrapper_root,
+                prior_store=service.store,
+            )
+            if authenticated_contract.get("sha256") != settings.study_contract_sha256:
+                raise StudyContractError(
+                    "the Z-table F scheduler contract SHA-256 differs from "
+                    "campaign settings"
+                )
+            self.study_contract = authenticated_contract
+            wrapper_record = authenticated_contract.get("policy_wrapper")
+            source_record = authenticated_contract.get("measured_source")
+            if not isinstance(wrapper_record, Mapping) or not isinstance(
+                source_record,
+                Mapping,
+            ):
+                raise StudyContractError("the Z-table F worker identities are missing")
+            self.worker_wrapper_root = study_contract_wrapper_root.expanduser().resolve(
+                strict=True
+            )
+            self.worker_entrypoint = self.worker_wrapper_root / POLICY_ENTRYPOINT
+            self.worker_module: str | None = None
+            if (
+                self.worker_entrypoint.is_symlink()
+                or not self.worker_entrypoint.is_file()
+            ):
+                raise StudyContractError(
+                    "the authenticated policy-wrapper entrypoint is unavailable"
+                )
+            self.worker_harness_identity = z_table_f_worker_harness_identity(
+                authenticated_contract
+            )
+        else:
+            if study_contract is not None or study_contract_wrapper_root is not None:
+                raise StudyContractError(
+                    "a study contract authorization requires the Z-table F policy"
+                )
+            self.study_contract = None
+            self.worker_wrapper_root = service.paths.repo_root
+            source_entrypoint = service.paths.repo_root / CANONICAL_REPORT_ENTRYPOINT
+            if __package__.startswith("pyamplicol."):
+                self.worker_entrypoint: Path | None = None
+                self.worker_module = "pyamplicol._performance_report"
+            else:
+                self.worker_entrypoint = source_entrypoint
+                self.worker_module = None
+            self.worker_harness_identity = None
+        self.measurement_lineage = (
+            measurement_lineage
+            if measurement_lineage_authenticated
+            else (
+                None
+                if settings.report_profile is None
+                else service._measurement_lineage()
+            )
+        )
+        self.measurement_source_tree = (
+            self.source_tree if settings.report_profile is not None else None
+        )
+        self.service.bind_measurement_lineage(self.measurement_lineage)
+        self.original_amplicol_seed = (
+            None
+            if settings.report_profile is None
+            else self.service._original_amplicol_seed()
+        )
+        self.service.bind_original_amplicol_seed(self.original_amplicol_seed)
+        self._prepared_model_paths: dict[ModelKey, Path] = {}
+        self._prepared_model_failures: dict[ModelKey, _PreparationFailed] = {}
+        self._resource_lanes: dict[tuple[object, ...], tuple[CellSpec, ...]] = {}
+        if settings.campaign_policy.allow_terminal_censors:
+            grouped: dict[tuple[object, ...], list[CellSpec]] = {}
+            for cell in self.catalog.measurement_cells():
+                if self.catalog.static_na_reason(cell) is not None:
+                    continue
+                grouped.setdefault(_resource_lane_key(cell), []).append(cell)
+            self._resource_lanes = {
+                lane: tuple(sorted(cells, key=lambda item: item.n_final))
+                for lane, cells in grouped.items()
+            }
+
+    def _observe(self, event: str, cell: CellSpec, **values: object) -> None:
+        callback = self.settings.progress_observer
+        if callback is None:
+            return
+        # Dashboard/lease updates are informational and must not change a
+        # campaign result.
+        with suppress(Exception):
+            callback({"event": event, "cell_id": cell.cell_id, **values})
+
+    def _observe_schedule(
+        self,
+        *,
+        ready: int,
+        waiting_dependency: int,
+        waiting_coordination_lock: int,
+    ) -> None:
+        callback = self.settings.progress_observer
+        if callback is None:
+            return
+        with suppress(Exception):
+            callback(
+                {
+                    "event": "scheduler-state",
+                    "ready": ready,
+                    "waiting_dependency": waiting_dependency,
+                    "waiting_coordination_lock": waiting_coordination_lock,
+                }
+            )
+
+    def _cancelled(self) -> bool:
+        callback = self.settings.cancellation_requested
+        return callback is not None and callback()
+
+    def _attach_manual_provenance(
+        self,
+        result: dict[str, object],
+        *,
+        cell: CellSpec,
+        censor: Mapping[str, object] | None = None,
+        progress_path: Path | None = None,
+    ) -> None:
+        if self.settings.source_identity_override is None:
+            return
+        # Imported lazily to keep the ordinary report scheduler independent of
+        # the optional manual UI during module initialization.
+        from .manual_campaign import reproduction_recipe
+
+        recipe = reproduction_recipe(
+            cell,
+            repo_root=self.service.paths.repo_root,
+            artifact_root=self.service.paths.artifact_root,
+            cores=self.settings.cell_cores,
+            target_runtime=self.settings.target_runtime_seconds,
+            batch_size=self.settings.batch_size,
+            warmups=self.settings.warmup_runs,
+            minimum_samples=self.settings.minimum_samples,
+            measurement=result,
+        )
+        existing = result.get("provenance")
+        result["provenance"] = {
+            **({} if not isinstance(existing, Mapping) else dict(existing)),
+            **self.source_identity.provenance(),
+            "manual_campaign": {
+                "cell_identity": {
+                    "cell_id": cell.cell_id,
+                    "dataset_id": cell.dataset_id,
+                    "process_key": cell.process_key,
+                    "process": cell.process,
+                    "n_final": cell.n_final,
+                    "workload": cell.workload.value,
+                    "execution_mode": cell.measurement.execution_mode.value,
+                    "model": (
+                        None
+                        if cell.measurement.model is None
+                        else cell.measurement.model.value
+                    ),
+                    "accuracy": cell.measurement.accuracy.value,
+                    "backend": cell.measurement.backend,
+                    "variant": cell.variant,
+                },
+                "generation_limit_seconds": (
+                    self.settings.generation_time_limit_seconds
+                ),
+                "worker_wall_limit_seconds": self.settings.timeout_seconds,
+                "profiling_time_limit_seconds": (
+                    self.settings.profiling_time_limit_seconds
+                ),
+                "validation_time_limit_seconds": (
+                    self.settings.validation_time_limit_seconds
+                ),
+                "memory_limit_bytes": self._effective_cell_rss_limit(),
+                "campaign_memory_limit_bytes": (self.settings.campaign_max_rss_bytes),
+                "attempt_output_limit_bytes": (
+                    self.settings.attempt_output_limit_bytes
+                ),
+                "minimum_free_disk_bytes": (self.settings.minimum_free_disk_bytes),
+                "retained_full_workspaces": self.settings.retain_workspaces,
+                "workers": self.settings.workers,
+                "cores_per_worker": self.settings.cell_cores,
+                "amplicol_build_jobs": self.settings.amplicol_build_jobs,
+                "target_runtime_seconds": self.settings.target_runtime_seconds,
+                "warmup_runs": self.settings.warmup_runs,
+                "minimum_samples": self.settings.minimum_samples,
+                "batch_size": self.settings.batch_size,
+                "recorded_at_utc": datetime.now(UTC).isoformat(),
+                "public_cli_reproduction": recipe.as_dict(),
+            },
+            **({} if censor is None else {"policy_censor": dict(censor)}),
+        }
+        from .phase_timeline import build_phase_timeline
+
+        persisted_provenance = result["provenance"]
+        if not isinstance(persisted_provenance, dict):
+            raise TypeError("manual result provenance must be mutable")
+        manual = persisted_provenance["manual_campaign"]
+        if not isinstance(manual, dict):
+            raise TypeError("manual campaign provenance must be mutable")
+        manual["phase_timeline"] = build_phase_timeline(
+            result,
+            progress_path=progress_path,
+        )
+
+    def _manual_terminal_result(
+        self,
+        *,
+        cell: CellSpec,
+        reason: str,
+        resources: Mapping[str, object],
+        progress_path: Path | None = None,
+    ) -> tuple[dict[str, object], PolicyMeasurementState]:
+        state, censor = self._manual_terminal_contract(reason)
+        status = (
+            ResultStatus.MEMORY_LIMIT
+            if reason == "memory_limit"
+            else ResultStatus.TIMEOUT
+        )
+        result = failure_measurement(
+            status,
+            f"worker terminated by {reason}",
+            resources=resources,
+        )
+        self._attach_manual_provenance(
+            result,
+            cell=cell,
+            censor=censor,
+            progress_path=progress_path,
+        )
+        return result, state
+
+    def _manual_terminal_contract(
+        self,
+        reason: str,
+    ) -> tuple[PolicyMeasurementState, dict[str, object]]:
+        if reason == "generation_timeout":
+            state = PolicyMeasurementState.GENERATION_LIMIT
+            censor = {
+                "kind": PolicyCensorKind.GENERATION_LIMIT.value,
+                "terminal_reason": reason,
+                "generation_limit_seconds": (
+                    self.settings.generation_time_limit_seconds
+                ),
+            }
+        elif reason == "memory_limit":
+            state = PolicyMeasurementState.MEMORY_LIMIT
+            censor = {
+                "kind": PolicyCensorKind.MEMORY_LIMIT.value,
+                "terminal_reason": reason,
+                "memory_limit_bytes": self._effective_cell_rss_limit(),
+            }
+        elif reason == "worker_timeout":
+            state = PolicyMeasurementState.WORKER_TIMEOUT
+            censor = {
+                "kind": PolicyCensorKind.WORKER_TIMEOUT.value,
+                "terminal_reason": reason,
+                "worker_wall_limit_seconds": self.settings.timeout_seconds,
+            }
+        elif reason == "profiling_timeout":
+            state = PolicyMeasurementState.PROFILING_TIMEOUT
+            censor = {
+                "kind": PolicyCensorKind.PROFILING_TIMEOUT.value,
+                "terminal_reason": reason,
+                "profiling_time_limit_seconds": (
+                    self.settings.profiling_time_limit_seconds
+                ),
+            }
+        elif reason == "validation_timeout":
+            state = PolicyMeasurementState.VALIDATION_TIMEOUT
+            censor = {
+                "kind": PolicyCensorKind.VALIDATION_TIMEOUT.value,
+                "terminal_reason": reason,
+                "validation_time_limit_seconds": (
+                    self.settings.validation_time_limit_seconds
+                ),
+            }
+        else:
+            raise ValueError(f"unsupported manual terminal reason {reason!r}")
+        return state, censor
+
+    def _current(
+        self,
+        cell: CellSpec,
+        *,
+        comparison_dependency: bool = False,
+    ) -> tuple[CurrentRecord, PolicyMeasurementState] | None:
+        return _policy_current(
+            self.service.store,
+            cell,
+            settings=self.settings,
+            expected_revision=self.source_revision,
+            expected_tree=self.measurement_source_tree,
+            measurement_lineage=self.measurement_lineage,
+            original_amplicol_seed=self.original_amplicol_seed,
+            expected_worker_harness=self.worker_harness_identity,
+            comparison_dependency=comparison_dependency,
+            catalog=self.catalog,
+        )
+
+    def _validate_z_table_f_plan(
+        self,
+        planned: Sequence[PlannedCell],
+    ) -> None:
+        validate_campaign_plan(
+            planned,
+            self.settings,
+            catalog=self.catalog,
+        )
+        if self.settings.campaign_policy is not MACBOOK_M3_Z_TABLE_F_POLICY:
+            return
+        item = planned[0]
+        baseline = self.catalog.validation_baseline_cell(item.cell)
+        edges = incoming_agreement_edges(
+            item.cell,
+            catalog=self.catalog,
+        )
+        dependencies = (
+            *(
+                (baseline,)
+                if validation_baseline_is_required(item.cell, baseline)
+                else ()
+            ),
+            *(edge.baseline for edge in edges if edge.required),
+        )
+        missing = tuple(
+            dependency.cell_id
+            for dependency in dependencies
+            if self._current(dependency, comparison_dependency=True) is None
+        )
+        if missing:
+            raise StudyContractError(
+                "the Z-table F runnable cell has unauthenticated comparison "
+                f"dependencies: {', '.join(sorted(missing))}"
+            )
+
+    def _legacy_workspace_paths(self, attempt_id: str) -> tuple[Path, Path]:
+        """Resolve legacy copy paths without doing controller-side work."""
+
+        from .legacy import MaintainedLegacyApi
+
+        api = MaintainedLegacyApi()
+        source = (
+            (
+                api.default_repository
+                if self.settings.original_amplicol_repository is None
+                else self.settings.original_amplicol_repository
+            )
+            .expanduser()
+            .resolve(strict=True)
+        )
+        destination = (
+            self.service.paths.artifact_root / "legacy-workspaces" / attempt_id
+        )
+        return source, destination
+
+    @staticmethod
+    def _remove_legacy_workspace(destination: Path) -> None:
+        if not destination.exists():
+            return
+        if destination.is_symlink() or not destination.is_dir():
+            raise RuntimeError(
+                "legacy worker workspace is not its canonical regular directory: "
+                f"{destination}"
+            )
+        shutil.rmtree(destination)
+
+    @staticmethod
+    def _retain_bounded_log(source: Path, destination: Path) -> None:
+        """Retain only a small tail from a potentially runaway diagnostic."""
+
+        if not source.exists():
+            return
+        if source.is_symlink() or not source.is_file():
+            raise RuntimeError(f"diagnostic log is not a regular file: {source}")
+        size = source.stat().st_size
+        if source == destination and size <= _DIAGNOSTIC_TAIL_BYTES:
+            return
+        header = (
+            f"[pyamplicol retained final log tail; original_bytes={size}]\n"
+        ).encode("ascii")
+        tail_bytes = max(_DIAGNOSTIC_TAIL_BYTES - len(header), 0)
+        with source.open("rb") as stream:
+            if size > tail_bytes:
+                stream.seek(size - tail_bytes)
+            tail = stream.read(tail_bytes)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        with destination.open("wb") as stream:
+            stream.write(header)
+            stream.write(tail)
+
+    def _finalize_legacy_workspace(
+        self,
+        workspace: Path,
+        *,
+        diagnostic_path: Path,
+    ) -> None:
+        if self.settings.retain_workspaces:
+            return
+        if workspace.exists():
+            self._retain_bounded_log(
+                workspace / "Outputs" / "log_file.txt",
+                diagnostic_path,
+            )
+        self._remove_legacy_workspace(workspace)
+
+    def _finalize_worker_log(self, worker_log: Path) -> None:
+        if not self.settings.retain_workspaces:
+            self._retain_bounded_log(worker_log, worker_log)
+
+    def _compact_reference_artifact(
+        self,
+        cell: CellSpec,
+        artifact: Path,
+        result: dict[str, object],
+    ) -> None:
+        """Drop disposable reference builds while retaining reusable evidence."""
+
+        if self.settings.retain_workspaces or not artifact.exists():
+            return
+        if artifact.is_symlink() or not artifact.is_dir():
+            raise RuntimeError(
+                f"reference artifact is not a regular directory: {artifact}"
+            )
+        raw_artifact_record = result.get("artifact")
+        if not isinstance(raw_artifact_record, Mapping):
+            raise RuntimeError("successful reference result has no artifact record")
+        artifact_record = dict(raw_artifact_record)
+        if cell.measurement.execution_mode is ExecutionMode.AMPLICOL:
+            self._retain_bounded_log(artifact / "legacy.log", artifact / "legacy.log")
+            disposable = (artifact / "contracted-generated-library",)
+        elif cell.measurement.execution_mode is ExecutionMode.MADGRAPH:
+            self._retain_bounded_log(
+                artifact / "madgraph.log",
+                artifact / "madgraph.log",
+            )
+            disposable = (artifact / "standalone",)
+            # The complete standalone tree is intentionally disposable after
+            # its measurement and hashes are sealed.  Remove its path fields
+            # together with the tree so retained metadata never advertises a
+            # workspace that no longer exists.
+            artifact_record.pop("standalone", None)
+            artifact_record.pop("subprocess", None)
+        else:
+            return
+        removed: list[str] = []
+        for path in disposable:
+            if not path.exists():
+                continue
+            if path.is_symlink() or not path.is_dir():
+                raise RuntimeError(f"disposable workspace is not a directory: {path}")
+            shutil.rmtree(path)
+            removed.append(path.name)
+        artifact_record["workspace_retention"] = {
+            "schema": "pyamplicol-reference-workspace-retention-v1",
+            "full_workspaces_retained": False,
+            "removed": removed,
+        }
+        result["artifact"] = artifact_record
+
+    def _discard_terminal_artifact(self, artifact: Path, attempt_root: Path) -> None:
+        """Keep bounded reference diagnostics and remove an unusable payload."""
+
+        if self.settings.retain_workspaces or not artifact.exists():
+            return
+        if artifact.is_symlink() or not artifact.is_dir():
+            raise RuntimeError(
+                f"terminal artifact is not a regular directory: {artifact}"
+            )
+        for name in ("legacy.log", "madgraph.log"):
+            self._retain_bounded_log(
+                artifact / name,
+                attempt_root / f"{Path(name).stem}-artifact-tail.log",
+            )
+        shutil.rmtree(artifact)
+
+    def _service_path_arguments(self) -> tuple[str, ...]:
+        paths = self.service.paths
+        return (
+            "--docs-dir",
+            os.fspath(paths.docs_dir),
+            "--artifact-root",
+            os.fspath(paths.artifact_root),
+            "--coordination-root",
+            os.fspath(paths.coordination_root),
+        )
+
+    def _worker_invocation(self) -> tuple[str, ...]:
+        if self.worker_module is not None:
+            return (
+                sys.executable,
+                "-I",
+                "-B",
+                "-m",
+                self.worker_module,
+            )
+        if self.worker_entrypoint is None:
+            raise RuntimeError("performance-report worker entrypoint is unavailable")
+        return (
+            sys.executable,
+            "-I",
+            "-S",
+            "-B",
+            os.fspath(self.worker_entrypoint),
+        )
+
+    def _worker_harness_arguments(self) -> tuple[str, ...]:
+        identity = self.worker_harness_identity
+        if identity is None:
+            return ()
+        return (
+            "--measurement-source-root",
+            os.fspath(self.service.paths.repo_root),
+            "--expected-measurement-source-revision",
+            str(identity["measured_source_revision"]),
+            "--expected-measurement-source-tree",
+            str(identity["measured_source_tree"]),
+            "--expected-policy-wrapper-revision",
+            str(identity["policy_wrapper_revision"]),
+            "--expected-policy-wrapper-tree",
+            str(identity["policy_wrapper_tree"]),
+            "--expected-policy-entrypoint-sha256",
+            str(identity["policy_entrypoint_sha256"]),
+            "--expected-legacy-adapter-sha256",
+            str(identity["legacy_adapter_sha256"]),
+            "--study-contract-sha256",
+            str(identity["study_contract_sha256"]),
+        )
+
+    def _bind_study_result(
+        self,
+        result: dict[str, object],
+        *,
+        require_existing_harness: bool = False,
+    ) -> None:
+        if self.settings.study_contract_sha256 is None:
+            return
+        identity = self.worker_harness_identity
+        if identity is None:
+            raise StudyContractError(
+                "the Z-table F worker harness identity is unavailable"
+            )
+        if require_existing_harness:
+            require_worker_harness_identity(result, expected=identity)
+        else:
+            attach_worker_harness_identity(result, identity)
+        bind_z_table_f_attempt(
+            result,
+            self.settings.study_contract_sha256,
+        )
+
+    def _ensure_prepared_model(self, planned: Sequence[PlannedCell]) -> None:
+        models = {
+            item.cell.measurement.model
+            for item in planned
+            if item.cell.measurement.execution_mode
+            in {
+                ExecutionMode.EAGER,
+                ExecutionMode.RECURRENCE,
+                ExecutionMode.ON_THE_FLY,
+            }
+            and item.cell.measurement.model in {ModelKey.BUILTIN_SM, ModelKey.UFO_SM}
+        }
+        for model in sorted(models, key=lambda item: item.value):  # type: ignore[union-attr]
+            assert model is not None
+            preflight_attempt_id = f"prepared-model-{model.value}"
+            representative = next(
+                item
+                for item in planned
+                if item.cell.measurement.model is model
+                and item.cell.measurement.execution_mode
+                in {
+                    ExecutionMode.EAGER,
+                    ExecutionMode.RECURRENCE,
+                    ExecutionMode.ON_THE_FLY,
+                }
+            )
+            result_path = (
+                self.service.paths.artifact_root
+                / "prepared-models"
+                / f".preflight-{model.value}-{uuid.uuid4().hex}.json"
+            )
+            progress_path = result_path.with_suffix(".progress.jsonl")
+            command = (
+                *self._worker_invocation(),
+                "--repo-root",
+                os.fspath(self.service.paths.repo_root),
+                *self._service_path_arguments(),
+                *self._worker_harness_arguments(),
+                "_prepare",
+                "--model",
+                model.value,
+                "--result-json",
+                os.fspath(result_path),
+                "--progress-jsonl",
+                os.fspath(progress_path),
+                "--cell-cores",
+                str(self.settings.cell_cores),
+                "--producer-revision",
+                self.source_revision,
+            )
+            preflight_timeout = self.settings.generation_time_limit_seconds
+            if self.settings.timeout_seconds is not None:
+                preflight_timeout = (
+                    self.settings.timeout_seconds
+                    if preflight_timeout is None
+                    else min(preflight_timeout, self.settings.timeout_seconds)
+                )
+
+            self._observe(
+                "started",
+                representative.cell,
+                dependency=representative.dependency,
+            )
+            self._observe(
+                "worker",
+                representative.cell,
+                attempt_id=preflight_attempt_id,
+                progress_path=os.fspath(progress_path),
+            )
+
+            def observe_preflight_resources(
+                observation: WorkerObservation,
+                *,
+                cell: CellSpec = representative.cell,
+                attempt_id: str = preflight_attempt_id,
+            ) -> None:
+                self._observe(
+                    "resource",
+                    cell,
+                    attempt_id=attempt_id,
+                    pid=observation.pid,
+                    member_pids=list(observation.member_pids),
+                    phase=observation.phase or "preparation",
+                    phase_sequence=None,
+                    wall_seconds=observation.usage.wall_seconds,
+                    cpu_seconds=observation.usage.cpu_seconds,
+                    current_rss_bytes=observation.usage.current_rss_bytes,
+                    peak_rss_bytes=observation.usage.peak_rss_bytes,
+                    current_physical_footprint_bytes=(
+                        observation.usage.current_physical_footprint_bytes
+                    ),
+                    peak_physical_footprint_bytes=(
+                        observation.usage.peak_physical_footprint_bytes
+                    ),
+                    current_guard_bytes=observation.usage.current_guard_bytes,
+                    peak_guard_bytes=observation.usage.peak_guard_bytes,
+                    child_count=observation.usage.child_count,
+                )
+
+            try:
+                supervised = supervise_worker(
+                    command,
+                    timeout_seconds=preflight_timeout,
+                    max_rss_bytes=self._effective_cell_rss_limit(),
+                    output_file_limits={
+                        progress_path: self.settings.attempt_output_limit_bytes,
+                    },
+                    minimum_free_disk_bytes=(self.settings.minimum_free_disk_bytes),
+                    disk_probe_path=self.service.paths.artifact_root,
+                    interval_seconds=(self.settings.resource_sample_interval_seconds),
+                    termination_grace_seconds=self.settings.termination_grace_seconds,
+                    cancellation_requested=self.settings.cancellation_requested,
+                    observation_callback=observe_preflight_resources,
+                    environment_overrides=_worker_environment_overrides(
+                        self.settings,
+                        self.service.paths.coordination_root,
+                    ),
+                    scrub_import_environment=(self.worker_harness_identity is not None),
+                    working_directory=(
+                        self.service.paths.repo_root
+                        if self.worker_harness_identity is not None
+                        else None
+                    ),
+                    capture_stderr=True,
+                )
+                if (
+                    supervised.reason != "completed"
+                    or supervised.returncode != 0
+                    or not result_path.is_file()
+                ):
+                    effective_reason = supervised.reason
+                    if supervised.reason == "worker_timeout":
+                        generation_limit = self.settings.generation_time_limit_seconds
+                        worker_limit = self.settings.timeout_seconds
+                        effective_reason = (
+                            "generation_timeout"
+                            if generation_limit is not None
+                            and (
+                                worker_limit is None or generation_limit <= worker_limit
+                            )
+                            else "worker_timeout"
+                        )
+                    detail = None
+                    if result_path.is_file():
+                        try:
+                            detail = json.loads(
+                                result_path.read_text(encoding="ascii")
+                            ).get("error")
+                        except (AttributeError, json.JSONDecodeError, OSError):
+                            detail = None
+                    process_detail = (
+                        str(_worker_process_exit_error(supervised))
+                        if supervised.reason == "worker_exit"
+                        else (
+                            f"reason={supervised.reason}, exit={supervised.returncode}"
+                        )
+                    )
+                    message = (
+                        f"{model.value} prepared-model preflight failed: "
+                        f"{process_detail}, detail={detail}"
+                    )
+                    raise _PreparationFailed(
+                        model,
+                        effective_reason,
+                        message,
+                        supervised,
+                    )
+                payload = json.loads(result_path.read_text(encoding="ascii"))
+                if not isinstance(payload, Mapping):
+                    raise RuntimeError(
+                        f"{model.value} prepared-model preflight returned "
+                        "a non-object payload"
+                    )
+                if self.worker_harness_identity is not None:
+                    validate_worker_harness_identity(
+                        payload.get("worker_harness"),
+                        expected=self.worker_harness_identity,
+                    )
+                path = Path(str(payload["path"])).resolve(strict=True)
+                self._prepared_model_paths[model] = path
+            finally:
+                self._observe(
+                    "preflight-finished",
+                    representative.cell,
+                    attempt_id=preflight_attempt_id,
+                )
+                result_path.unlink(missing_ok=True)
+                progress_path.unlink(missing_ok=True)
+
+    def _prepare_model_for(self, planned: PlannedCell) -> None:
+        cell = planned.cell
+        model = cell.measurement.model
+        if cell.measurement.execution_mode not in {
+            ExecutionMode.EAGER,
+            ExecutionMode.RECURRENCE,
+            ExecutionMode.ON_THE_FLY,
+        } or model not in {ModelKey.BUILTIN_SM, ModelKey.UFO_SM}:
+            return
+        assert model is not None
+        if model in self._prepared_model_paths:
+            return
+        failure = self._prepared_model_failures.get(model)
+        if failure is not None:
+            raise failure
+        lock_name = f"campaign-prepared-model-{model.value}"
+        try:
+            with self.service.store.named_lock(
+                lock_name,
+                timeout=0.0,
+                cancellation_requested=self.settings.cancellation_requested,
+            ):
+                if model in self._prepared_model_paths:
+                    return
+                failure = self._prepared_model_failures.get(model)
+                if failure is not None:
+                    raise failure
+                try:
+                    self._ensure_prepared_model((planned,))
+                except _PreparationFailed as error:
+                    self._prepared_model_failures[model] = error
+                    raise
+                except Exception as error:
+                    failure = _PreparationFailed(
+                        model,
+                        "error",
+                        f"{type(error).__name__}: {error}",
+                    )
+                    self._prepared_model_failures[model] = failure
+                    raise failure from error
+        except LockTimeoutError as error:
+            raise _CoordinationDeferred(lock_name) from error
+
+    def _preparation_failure_outcome(
+        self,
+        cell: CellSpec,
+        failure: _PreparationFailed,
+    ) -> CellOutcome:
+        if failure.reason == "cancelled":
+            return CellOutcome(cell.cell_id, "cancelled", failure.detail)
+        supervised = failure.supervised
+        manual_reason = {
+            "generation_timeout": "generation_timeout",
+            "worker_timeout": "worker_timeout",
+            "memory_limit": "memory_limit",
+        }.get(failure.reason)
+        if (
+            self.settings.manual_terminal_censors
+            and supervised is not None
+            and manual_reason is not None
+        ):
+            resources = _resource_payload(
+                supervised.usage,
+                None,
+                memory_limit_bytes=supervised.memory_limit_bytes,
+                memory_limit_reason=supervised.memory_limit_reason,
+                supervised=supervised,
+                source_revision=self.source_revision,
+                campaign_invocation_id=self.settings.campaign_invocation_id,
+            )
+            resources["terminal_reason"] = manual_reason
+            with self.service.store.new_attempt(
+                cell.cell_id,
+                self.settings.artifact_policy,
+                based_on=self.service.store.load_current(
+                    cell.cell_id,
+                    missing_ok=True,
+                ),
+            ) as attempt:
+                result, state = self._manual_terminal_result(
+                    cell=cell,
+                    reason=manual_reason,
+                    resources=resources,
+                )
+                validate_measurement(
+                    result,
+                    expected_cell=cell,
+                    catalog=self.catalog,
+                )
+                record = attempt.publish(result)
+                return CellOutcome(
+                    cell.cell_id,
+                    state.value,
+                    record.attempt_id,
+                    terminal_detail=_measurement_terminal_detail(result),
+                )
+        if supervised is not None and failure.reason in {
+            "worker_exit",
+            "memory_probe_error",
+            "output_limit",
+            "output_probe_error",
+            "disk_space_limit",
+            "disk_probe_error",
+            "phase_state_error",
+        }:
+            resources = _resource_payload(
+                supervised.usage,
+                supervised.generation_phase,
+                memory_limit_bytes=supervised.memory_limit_bytes,
+                memory_limit_reason=supervised.memory_limit_reason,
+                supervised=supervised,
+                source_revision=self.source_revision,
+                campaign_invocation_id=self.settings.campaign_invocation_id,
+                supervisor_phase="preparation",
+            )
+            result = failure_measurement(
+                ResultStatus.ERROR,
+                (
+                    _worker_process_exit_error(supervised)
+                    if failure.reason == "worker_exit"
+                    else failure.detail
+                ),
+                resources=resources,
+            )
+            self._attach_manual_provenance(result, cell=cell)
+            self._bind_study_result(result)
+            validate_measurement(
+                result,
+                expected_cell=cell,
+                catalog=self.catalog,
+            )
+            with self.service.store.new_attempt(
+                cell.cell_id,
+                self.settings.artifact_policy,
+                based_on=self.service.store.load_current(
+                    cell.cell_id,
+                    missing_ok=True,
+                ),
+            ) as attempt:
+                attempt.write_json("worker-result.json", result)
+                attempt.mark_failed(
+                    str(result.get("failure")),
+                    artifact_paths=("worker-result.json",),
+                )
+                return CellOutcome(
+                    cell.cell_id,
+                    ResultStatus.ERROR.value,
+                    attempt.attempt_id,
+                    terminal_detail=_measurement_terminal_detail(result),
+                )
+        return CellOutcome(
+            cell.cell_id,
+            "preparation_error",
+            failure.detail,
+        )
+
+    def run(self, planned: Sequence[PlannedCell]) -> CampaignResult:
+        ordered = tuple(planned)
+        self._validate_z_table_f_plan(ordered)
+        if self.settings.madgraph_installation is None and any(
+            item.cell.measurement.execution_mode is ExecutionMode.MADGRAPH
+            for item in ordered
+        ):
+            raise ValueError(
+                "campaign plan contains MadGraph reference cells but no "
+                "MadGraph installation is configured"
+            )
+        static_na = tuple(
+            (
+                item.cell.cell_id,
+                self.catalog.static_na_reason(item.cell),
+            )
+            for item in ordered
+            if self.catalog.static_na_reason(item.cell) is not None
+        )
+        if static_na:
+            cell_id, reason = static_na[0]
+            raise ValueError(
+                f"campaign plan contains catalog static N/A cell {cell_id!r}: {reason}"
+            )
+        if self._cancelled():
+            return CampaignResult(planned=ordered, outcomes=())
+        if not ordered:
+            return CampaignResult(planned=ordered, outcomes=())
+
+        by_id = {item.cell.cell_id: item for item in ordered}
+        if len(by_id) != len(ordered):
+            raise ValueError("campaign plan contains duplicate cell IDs")
+        planned_ids = frozenset(by_id)
+        prerequisites: dict[str, set[str]] = {}
+        dependents: dict[str, set[str]] = {cell_id: set() for cell_id in planned_ids}
+        for item in ordered:
+            declared = set(item.prerequisite_cell_ids) | set(
+                item.resource_predecessor_ids
+            )
+            # Hand-written/older plans did not carry explicit DAG edges. Preserve
+            # their dependency semantics while plan_campaign now records them.
+            declared.update(
+                cell_id
+                for cell_id in (
+                    item.baseline_cell_id,
+                    *item.comparison_peer_ids,
+                )
+                if cell_id is not None and cell_id in planned_ids
+            )
+            missing = declared - planned_ids
+            if missing:
+                raise ValueError(
+                    f"campaign plan for {item.cell.cell_id!r} references "
+                    f"unscheduled prerequisites: {', '.join(sorted(missing))}"
+                )
+            if item.cell.cell_id in declared:
+                raise ValueError(
+                    "campaign plan contains a self dependency for "
+                    f"{item.cell.cell_id!r}"
+                )
+            prerequisites[item.cell.cell_id] = declared
+            for predecessor_id in declared:
+                dependents[predecessor_id].add(item.cell.cell_id)
+        ready: list[tuple[tuple[object, ...], str]] = [
+            (_ready_priority(item.cell), item.cell.cell_id)
+            for item in ordered
+            if not prerequisites[item.cell.cell_id]
+        ]
+        heapq.heapify(ready)
+        queued_ids = {cell_id for _priority, cell_id in ready}
+        if not ready and ordered:
+            raise ValueError("campaign plan contains a dependency cycle")
+
+        outcomes: list[CellOutcome] = []
+        futures: dict[Future[CellOutcome], PlannedCell] = {}
+        waiting_locks: dict[str, float] = {}
+        retry_delay_seconds = min(
+            0.05,
+            self.settings.resource_sample_interval_seconds,
+        )
+
+        def observe_schedule() -> None:
+            self._observe_schedule(
+                ready=len(queued_ids - waiting_locks.keys()),
+                waiting_dependency=sum(bool(value) for value in prerequisites.values()),
+                waiting_coordination_lock=len(waiting_locks),
+            )
+
+        def pop_lockable_candidate(now: float) -> PlannedCell | None:
+            deferred: list[tuple[tuple[object, ...], str]] = []
+            selected: PlannedCell | None = None
+            active_multiplicity = (
+                min(by_id[cell_id].cell.n_final for cell_id in prerequisites)
+                if self.settings.multiplicity_wave_barrier and prerequisites
+                else None
+            )
+            while ready:
+                key = heapq.heappop(ready)
+                if (
+                    active_multiplicity is not None
+                    and by_id[key[1]].cell.n_final != active_multiplicity
+                ):
+                    deferred.append(key)
+                    continue
+                retry_at = waiting_locks.get(key[1])
+                if retry_at is not None and retry_at > now:
+                    deferred.append(key)
+                    continue
+                selected = by_id[key[1]]
+                queued_ids.remove(key[1])
+                waiting_locks.pop(key[1], None)
+                break
+            for key in deferred:
+                heapq.heappush(ready, key)
+            return selected
+
+        observe_schedule()
+        with ThreadPoolExecutor(max_workers=self.settings.workers) as executor:
+            while futures or queued_ids:
+                cancelled = self._cancelled()
+                now = time.monotonic()
+                while len(futures) < self.settings.workers:
+                    # A fast worker can publish its terminal observer event while
+                    # this loop is still filling slots.  Re-read cancellation
+                    # before every submission instead of relying on the outer
+                    # loop's snapshot.
+                    cancelled = self._cancelled()
+                    if cancelled:
+                        break
+                    item = pop_lockable_candidate(now)
+                    if item is None:
+                        break
+                    if self._cancelled():
+                        cancelled = True
+                        queued_ids.add(item.cell.cell_id)
+                        heapq.heappush(
+                            ready,
+                            (_ready_priority(item.cell), item.cell.cell_id),
+                        )
+                        break
+                    futures[executor.submit(self._run_cell, item)] = item
+                observe_schedule()
+
+                if not futures:
+                    if cancelled:
+                        break
+                    if not queued_ids:
+                        break
+                    next_retry = min(waiting_locks.values(), default=now)
+                    time.sleep(max(0.001, min(retry_delay_seconds, next_retry - now)))
+                    continue
+
+                completed, _pending = wait(
+                    tuple(futures),
+                    timeout=retry_delay_seconds,
+                    return_when=FIRST_COMPLETED,
+                )
+                for future in sorted(
+                    completed,
+                    key=lambda candidate: futures[candidate].cell.cell_id,
+                ):
+                    item = futures.pop(future)
+                    cell_id = item.cell.cell_id
+                    try:
+                        outcome = future.result()
+                    except _CoordinationDeferred:
+                        waiting_locks[cell_id] = time.monotonic() + retry_delay_seconds
+                        queued_ids.add(cell_id)
+                        heapq.heappush(
+                            ready,
+                            (_ready_priority(item.cell), cell_id),
+                        )
+                        continue
+                    outcomes.append(outcome)
+                    prerequisites.pop(cell_id, None)
+                    waiting_locks.pop(cell_id, None)
+                    for dependent_id in sorted(dependents[cell_id]):
+                        if dependent_id not in prerequisites:
+                            continue
+                        remaining = prerequisites[dependent_id]
+                        remaining.discard(cell_id)
+                        if (
+                            not remaining
+                            and dependent_id not in queued_ids
+                            and all(
+                                scheduled.cell.cell_id != dependent_id
+                                for scheduled in futures.values()
+                            )
+                        ):
+                            dependent = by_id[dependent_id]
+                            queued_ids.add(dependent_id)
+                            heapq.heappush(
+                                ready,
+                                (_ready_priority(dependent.cell), dependent_id),
+                            )
+                if not futures and not queued_ids and prerequisites:
+                    blocked = ", ".join(sorted(prerequisites))
+                    raise ValueError(
+                        "campaign plan contains an unresolved dependency cycle: "
+                        f"{blocked}"
+                    )
+            observe_schedule()
+        return CampaignResult(
+            planned=ordered,
+            outcomes=tuple(sorted(outcomes, key=lambda item: item.cell_id)),
+        )
+
+    def _coordination_lock_names(self, cell: CellSpec) -> tuple[str, ...]:
+        names = {f"campaign-cell-{cell.cell_id}"}
+        if self.settings.campaign_policy.allow_terminal_censors:
+            names.add(_resource_lane_lock_name(cell))
+        return tuple(sorted(names))
+
+    def _run_cell(self, planned: PlannedCell) -> CellOutcome:
+        cell = planned.cell
+        if self._cancelled():
+            outcome = CellOutcome(cell.cell_id, "cancelled", "not started")
+            self._observe(
+                "finished",
+                cell,
+                status=outcome.status,
+                detail=outcome.detail,
+                terminal_detail=outcome.terminal_detail,
+            )
+            return outcome
+        completed_at_ns: int | None = None
+        completion_observed = False
+        try:
+            with ExitStack() as locks:
+                for lock_name in self._coordination_lock_names(cell):
+                    try:
+                        locks.enter_context(
+                            self.service.store.named_lock(
+                                lock_name,
+                                timeout=0.0,
+                                cancellation_requested=(
+                                    self.settings.cancellation_requested
+                                ),
+                            )
+                        )
+                    except LockTimeoutError as error:
+                        raise _CoordinationDeferred(lock_name) from error
+                try:
+                    try:
+                        outcome = self._run_cell_in_lane(planned)
+                    except _PreparationFailed as error:
+                        # Publishing the shared-preparation terminal must remain
+                        # inside the same cell/lane exclusion as ordinary results.
+                        outcome = self._preparation_failure_outcome(cell, error)
+                    completed_at_ns = time.time_ns()
+                    completion_observed = True
+                    self._observe(
+                        "finished",
+                        cell,
+                        status=outcome.status,
+                        detail=outcome.detail,
+                        terminal_detail=outcome.terminal_detail,
+                        prerequisite_cell_ids=outcome.prerequisite_cell_ids,
+                        completed_at_ns=completed_at_ns,
+                    )
+                except (_CoordinationDeferred, LockCancelledError):
+                    raise
+                except BaseException as error:
+                    if not completion_observed:
+                        completed_at_ns = time.time_ns()
+                        completion_observed = True
+                        self._observe(
+                            "finished",
+                            cell,
+                            status="error",
+                            detail=f"{type(error).__name__}: {error}",
+                            completed_at_ns=completed_at_ns,
+                        )
+                    raise
+                finally:
+                    if self.settings.remove_heavy_attempt_artifacts:
+                        try:
+                            archive_cell_attempt_history(
+                                self.service,
+                                cell,
+                                catalog=self.catalog,
+                            )
+                        except Exception as error:
+                            self._observe(
+                                "cleanup-warning",
+                                cell,
+                                detail=f"{type(error).__name__}: {error}",
+                            )
+        except _CoordinationDeferred:
+            # A lock race is scheduling state, not a worker failure. The ready
+            # queue will defer and retry this cell without emitting completion.
+            raise
+        except LockCancelledError:
+            outcome = CellOutcome(cell.cell_id, "cancelled", "lock wait cancelled")
+            completed_at_ns = time.time_ns()
+        except BaseException as error:
+            if not completion_observed:
+                self._observe(
+                    "finished",
+                    cell,
+                    status="error",
+                    detail=f"{type(error).__name__}: {error}",
+                    completed_at_ns=(completed_at_ns or time.time_ns()),
+                )
+            raise
+        assert completed_at_ns is not None
+        if not completion_observed:
+            self._observe(
+                "finished",
+                cell,
+                status=outcome.status,
+                detail=outcome.detail,
+                terminal_detail=outcome.terminal_detail,
+                prerequisite_cell_ids=outcome.prerequisite_cell_ids,
+                completed_at_ns=completed_at_ns,
+            )
+        return outcome
+
+    def _run_cell_in_lane(self, planned: PlannedCell) -> CellOutcome:
+        if self.settings.campaign_policy is MACBOOK_M3_Z_TABLE_F_POLICY:
+            self._validate_z_table_f_plan((planned,))
+        cell = planned.cell
+        # Coordination locks are acquired non-blockingly by _run_cell before a
+        # worker slot performs any artifact or dependency work.
+        with ExitStack() as lane_locks:
+            fresh = self._current(cell)
+            frontier_source = (
+                _resource_frontier_source(
+                    self.service.store,
+                    cell,
+                    settings=self.settings,
+                    catalog=self.catalog,
+                    expected_revision=self.source_revision,
+                    expected_tree=self.measurement_source_tree,
+                    measurement_lineage=self.measurement_lineage,
+                    original_amplicol_seed=self.original_amplicol_seed,
+                    expected_worker_harness=self.worker_harness_identity,
+                    lane_cells=self._resource_lanes.get(
+                        _resource_lane_key(cell),
+                        (),
+                    ),
+                )
+                if planned.dependency
+                else None
+            )
+            if (
+                self.settings.missing_only
+                and not planned.force_recompare
+                and fresh is not None
+                and frontier_source is None
+            ):
+                return CellOutcome(cell.cell_id, "skipped-current", "already complete")
+            if frontier_source is not None:
+                expected_frontier = _frontier_reference(frontier_source, cell)
+                if (
+                    fresh is not None
+                    and fresh[1] is PolicyMeasurementState.RESOURCE_FRONTIER
+                    and _measurement_frontier(fresh[0].result) == expected_frontier
+                ):
+                    return CellOutcome(
+                        cell.cell_id,
+                        "skipped-current",
+                        "resource frontier already authenticated",
+                    )
+            decision = self.service.store.decide(
+                cell.cell_id,
+                self.settings.artifact_policy,
+            )
+            if frontier_source is not None:
+                return self._publish_resource_frontier(
+                    cell,
+                    _frontier_reference(frontier_source, cell),
+                    current=decision.current,
+                )
+            current_is_fresh = fresh is not None
+            if (
+                decision.action is ArtifactAction.REUSE_CURRENT
+                and decision.current is not None
+                and current_is_fresh
+                and not self.settings.rerun
+                and not planned.force_recompare
+            ):
+                return CellOutcome(cell.cell_id, "reused", decision.current.attempt_id)
+
+            artifact_owner = _directional_otf_artifact_owner(
+                cell,
+                catalog=self.catalog,
+            )
+            equivalent_record = (
+                _fresh_equivalent_current(
+                    self.service.store,
+                    cell,
+                    catalog=self.catalog,
+                    expected_revision=self.source_revision,
+                    expected_tree=self.measurement_source_tree,
+                    measurement_lineage=self.measurement_lineage,
+                    expected_study_contract_sha256=(
+                        self.settings.study_contract_sha256
+                    ),
+                    expected_worker_harness=self.worker_harness_identity,
+                )
+                if (
+                    artifact_owner is not None
+                    or (
+                        not self.settings.rerun
+                        and self.settings.artifact_policy
+                        in {ArtifactPolicy.REUSE, ArtifactPolicy.RETIME}
+                    )
+                )
+                else None
+            )
+            baseline = (
+                None
+                if planned.baseline_cell_id is None
+                else self.catalog.cell(planned.baseline_cell_id)
+            )
+            optional_baseline = (
+                None
+                if planned.optional_baseline_cell_id is None
+                else self.catalog.cell(planned.optional_baseline_cell_id)
+            )
+            required_dependency_ids = {
+                dependency_id
+                for dependency_id in (
+                    planned.baseline_cell_id,
+                    *planned.comparison_peer_ids,
+                )
+                if dependency_id is not None
+            }
+            dependency_cells = {
+                dependency.cell_id: dependency
+                for dependency in (
+                    *((baseline,) if baseline is not None else ()),
+                    *((optional_baseline,) if optional_baseline is not None else ()),
+                    *(
+                        self.catalog.cell(peer_cell_id)
+                        for peer_cell_id in (
+                            *planned.comparison_peer_ids,
+                            *planned.optional_comparison_peer_ids,
+                            *planned.numerical_authority_cell_ids,
+                        )
+                    ),
+                )
+            }
+            dependency_currents: dict[
+                str,
+                tuple[CurrentRecord, PolicyMeasurementState],
+            ] = {}
+            missing_dependency_ids: list[str] = []
+            for dependency in dependency_cells.values():
+                current_dependency = self._current(
+                    dependency,
+                    comparison_dependency=True,
+                )
+                if (
+                    current_dependency is None
+                    and dependency.cell_id in required_dependency_ids
+                ):
+                    missing_dependency_ids.append(dependency.cell_id)
+                elif current_dependency is not None:
+                    dependency_currents[dependency.cell_id] = current_dependency
+            if missing_dependency_ids:
+                return self._publish_blocked_dependency(
+                    cell,
+                    missing_dependency_ids,
+                    current=decision.current,
+                )
+            if self.settings.manual_terminal_censors:
+                terminal_dependency_ids = tuple(
+                    dependency_id
+                    for dependency_id, (_record, state) in dependency_currents.items()
+                    if dependency_id in required_dependency_ids
+                    if state is not PolicyMeasurementState.SUCCESS
+                )
+                if terminal_dependency_ids:
+                    return self._publish_blocked_dependency(
+                        cell,
+                        terminal_dependency_ids,
+                        current=decision.current,
+                    )
+            baseline_record, peer_records, terminal_dependencies = (
+                _partition_dependency_records(
+                    baseline_cell_id=(None if baseline is None else baseline.cell_id),
+                    comparison_peer_ids=planned.comparison_peer_ids,
+                    optional_baseline_cell_id=(
+                        None
+                        if optional_baseline is None
+                        else optional_baseline.cell_id
+                    ),
+                    optional_comparison_peer_ids=(
+                        planned.optional_comparison_peer_ids
+                    ),
+                    currents=dependency_currents,
+                )
+            )
+            # Numerical authorities are availability-only and ordered:
+            # recurrence first, then original AmpliCol.  They never enter the
+            # terminal-dependency censor path, but a successful one is passed
+            # to the worker as the independent numerical baseline.
+            selected_authority_cell_id: str | None = None
+            for authority_cell_id in planned.numerical_authority_cell_ids:
+                authority = dependency_currents.get(authority_cell_id)
+                if (
+                    authority is not None
+                    and authority[1] is PolicyMeasurementState.SUCCESS
+                ):
+                    baseline_record = authority[0]
+                    selected_authority_cell_id = authority_cell_id
+                    break
+            if terminal_dependencies:
+                return self._publish_dependency_censor(
+                    cell,
+                    terminal_dependencies,
+                    current=decision.current,
+                )
+
+            reusable_record = (
+                equivalent_record
+                if artifact_owner is not None
+                else (
+                    decision.current
+                    if (
+                        decision.action is ArtifactAction.RETIME_CURRENT
+                        and decision.current is not None
+                        and current_is_fresh
+                        and not self.settings.rerun
+                    )
+                    else equivalent_record
+                )
+            )
+            if reusable_record is not None:
+                artifact_use_lock = (
+                    f"campaign-artifact-use-{reusable_record.attempt_id}"
+                )
+                try:
+                    lane_locks.enter_context(
+                        self.service.store.named_lock(
+                            artifact_use_lock,
+                            timeout=0.0,
+                            cancellation_requested=(
+                                self.settings.cancellation_requested
+                            ),
+                        )
+                    )
+                except LockTimeoutError as error:
+                    raise _CoordinationDeferred(artifact_use_lock) from error
+                artifact = reusable_record.result.get("artifact")
+                artifact_path = (
+                    artifact.get("path")
+                    if isinstance(artifact, Mapping)
+                    else None
+                )
+                if isinstance(artifact_path, str) and not Path(artifact_path).is_dir():
+                    reusable_record = None
+            if artifact_owner is not None and reusable_record is None:
+                raise RuntimeError(
+                    f"OTF all-flow cell {cell.cell_id!r} has no fresh artifact "
+                    f"from selected-flow owner {artifact_owner.cell_id!r}"
+                )
+            if reusable_record is None:
+                self._prepare_model_for(planned)
+            self._observe("started", cell, dependency=planned.dependency)
+
+            with self.service.store.new_attempt(
+                cell.cell_id,
+                self.settings.artifact_policy,
+                based_on=decision.current,
+            ) as attempt:
+                worker_result = attempt.path("worker-result.json")
+                worker_log = attempt.path("worker.log")
+                worker_progress = attempt.path("worker-progress.jsonl")
+                generation_timeout = (
+                    self.settings.generation_time_limit_seconds
+                    if self.settings.campaign_policy is STRICT_POLICY
+                    else generation_limit_for_cell(
+                        self.settings.campaign_policy,
+                        cell,
+                    )
+                )
+                generation_lock_path = (
+                    None
+                    if reusable_record is not None
+                    else _symbolica_generation_lock_path(
+                        self.settings,
+                        self.service.paths.coordination_root,
+                        cell,
+                    )
+                )
+                phase_channel = (
+                    None
+                    if generation_timeout is None
+                    and self.settings.profiling_time_limit_seconds is None
+                    and self.settings.validation_time_limit_seconds is None
+                    and generation_lock_path is None
+                    else WorkerPhaseChannel.create(
+                        attempt.path("worker-phase-state.json")
+                    )
+                )
+                command = [
+                    *self._worker_invocation(),
+                    "--repo-root",
+                    os.fspath(self.service.paths.repo_root),
+                    *self._service_path_arguments(),
+                    *self._worker_harness_arguments(),
+                    "_worker",
+                    "--cell-id",
+                    cell.cell_id,
+                    "--attempt-root",
+                    os.fspath(attempt.root),
+                    "--result-json",
+                    os.fspath(worker_result),
+                    "--log-path",
+                    os.fspath(worker_log),
+                    "--target-runtime",
+                    str(self.settings.target_runtime_seconds),
+                    "--batch-size",
+                    str(self.settings.batch_size),
+                    "--cell-cores",
+                    str(self.settings.cell_cores),
+                    "--amplicol-build-jobs",
+                    str(self.settings.amplicol_build_jobs),
+                    "--warmup-runs",
+                    str(self.settings.warmup_runs),
+                    "--minimum-samples",
+                    str(self.settings.minimum_samples),
+                    "--progress-jsonl",
+                    os.fspath(worker_progress),
+                ]
+                memory_limit_bytes = self._effective_cell_rss_limit()
+                if memory_limit_bytes is not None:
+                    command.extend(("--memory-limit-bytes", str(memory_limit_bytes)))
+                for option, limit in (
+                    ("--worker-wall-limit", self.settings.timeout_seconds),
+                    (
+                        "--profiling-time-limit",
+                        self.settings.profiling_time_limit_seconds,
+                    ),
+                    (
+                        "--validation-time-limit",
+                        self.settings.validation_time_limit_seconds,
+                    ),
+                ):
+                    if limit is not None:
+                        command.extend((option, str(limit)))
+                if self.settings.source_identity_override is not None:
+                    command.extend(
+                        (
+                            "--manual-source-revision",
+                            self.source_revision,
+                            "--manual-source-tree",
+                            self.source_tree,
+                        )
+                    )
+                if self.settings.madgraph_installation is not None:
+                    command.extend(
+                        (
+                            "--madgraph",
+                            os.fspath(self.settings.madgraph_installation),
+                        )
+                    )
+                if phase_channel is not None:
+                    command.extend(
+                        (
+                            "--phase-state-path",
+                            os.fspath(phase_channel.path),
+                            "--phase-state-run-id",
+                            phase_channel.run_id,
+                            "--phase-state-authentication-key",
+                            phase_channel.authentication_key,
+                        )
+                    )
+                if generation_lock_path is not None:
+                    command.extend(
+                        ("--generation-lock-path", os.fspath(generation_lock_path))
+                    )
+                if baseline_record is not None:
+                    command.extend(
+                        ("--baseline-json", os.fspath(baseline_record.result_path))
+                    )
+                if selected_authority_cell_id is not None:
+                    command.extend(
+                        (
+                            "--selected-authority-cell-id",
+                            selected_authority_cell_id,
+                        )
+                    )
+                for authority_cell_id in planned.numerical_authority_cell_ids:
+                    command.extend(
+                        ("--expected-authority-cell-id", authority_cell_id)
+                    )
+                for peer_cell_id, peer_record in sorted(peer_records.items()):
+                    command.extend(
+                        (
+                            "--peer-json",
+                            peer_cell_id,
+                            os.fspath(peer_record.result_path),
+                        )
+                    )
+                prepared_model = self._prepared_model_paths.get(
+                    cell.measurement.model  # type: ignore[arg-type]
+                )
+                if prepared_model is not None:
+                    command.extend(("--prepared-model", os.fspath(prepared_model)))
+                legacy_workspace: Path | None = None
+                if cell.measurement.execution_mode is ExecutionMode.AMPLICOL and (
+                    self.settings.campaign_policy.allow_terminal_censors
+                    or self.settings.source_identity_override is not None
+                ):
+                    legacy_source, legacy_workspace = self._legacy_workspace_paths(
+                        attempt.attempt_id
+                    )
+                    command.extend(
+                        (
+                            "--legacy-source-repository",
+                            os.fspath(legacy_source),
+                            "--legacy-workspace",
+                            os.fspath(legacy_workspace),
+                        )
+                    )
+                    if self.settings.source_identity_override is not None:
+                        command.append("--legacy-copy-source")
+                    if self.settings.original_amplicol_revision is not None:
+                        command.extend(
+                            (
+                                "--legacy-source-revision",
+                                self.settings.original_amplicol_revision,
+                            )
+                        )
+                if reusable_record is not None:
+                    command.extend(
+                        (
+                            "--reused-measurement-json",
+                            os.fspath(reusable_record.result_path),
+                        )
+                    )
+                self._observe(
+                    "worker",
+                    cell,
+                    attempt_id=attempt.attempt_id,
+                    log_path=os.fspath(worker_log),
+                    progress_path=os.fspath(worker_progress),
+                    phase_path=(
+                        None if phase_channel is None else os.fspath(phase_channel.path)
+                    ),
+                )
+
+                def observe_resources(observation: WorkerObservation) -> None:
+                    self._observe(
+                        "resource",
+                        cell,
+                        attempt_id=attempt.attempt_id,
+                        pid=observation.pid,
+                        member_pids=list(observation.member_pids),
+                        phase=observation.phase,
+                        phase_sequence=observation.phase_sequence,
+                        wall_seconds=observation.usage.wall_seconds,
+                        cpu_seconds=observation.usage.cpu_seconds,
+                        current_rss_bytes=observation.usage.current_rss_bytes,
+                        peak_rss_bytes=observation.usage.peak_rss_bytes,
+                        current_physical_footprint_bytes=(
+                            observation.usage.current_physical_footprint_bytes
+                        ),
+                        peak_physical_footprint_bytes=(
+                            observation.usage.peak_physical_footprint_bytes
+                        ),
+                        current_guard_bytes=observation.usage.current_guard_bytes,
+                        peak_guard_bytes=observation.usage.peak_guard_bytes,
+                        child_count=observation.usage.child_count,
+                    )
+
+                artifact_path = attempt.root / "artifact"
+                output_file_limits = {
+                    worker_log: self.settings.attempt_output_limit_bytes,
+                    worker_progress: self.settings.attempt_output_limit_bytes,
+                    artifact_path / "legacy.log": (
+                        self.settings.attempt_output_limit_bytes
+                    ),
+                    artifact_path / "madgraph.log": (
+                        self.settings.attempt_output_limit_bytes
+                    ),
+                }
+                if legacy_workspace is not None:
+                    output_file_limits[
+                        legacy_workspace / "Outputs" / "log_file.txt"
+                    ] = self.settings.attempt_output_limit_bytes
+                try:
+                    supervised = supervise_worker(
+                        command,
+                        timeout_seconds=self.settings.timeout_seconds,
+                        generation_timeout_seconds=generation_timeout,
+                        profiling_timeout_seconds=(
+                            self.settings.profiling_time_limit_seconds
+                        ),
+                        validation_timeout_seconds=(
+                            self.settings.validation_time_limit_seconds
+                        ),
+                        generation_guard_includes_preparation=True,
+                        phase_channel=phase_channel,
+                        max_rss_bytes=memory_limit_bytes,
+                        output_file_limits=output_file_limits,
+                        minimum_free_disk_bytes=(
+                            self.settings.minimum_free_disk_bytes
+                        ),
+                        disk_probe_path=self.service.paths.artifact_root,
+                        environment_overrides=_worker_environment_overrides(
+                            self.settings,
+                            self.service.paths.coordination_root,
+                        ),
+                        scrub_import_environment=(
+                            self.worker_harness_identity is not None
+                        ),
+                        working_directory=(
+                            self.service.paths.repo_root
+                            if self.worker_harness_identity is not None
+                            else None
+                        ),
+                        interval_seconds=(
+                            self.settings.resource_sample_interval_seconds
+                        ),
+                        termination_grace_seconds=(
+                            self.settings.termination_grace_seconds
+                        ),
+                        observation_callback=observe_resources,
+                        cancellation_requested=(
+                            self.settings.cancellation_requested
+                        ),
+                        capture_stderr=True,
+                    )
+                finally:
+                    if legacy_workspace is not None:
+                        self._finalize_legacy_workspace(
+                            legacy_workspace,
+                            diagnostic_path=attempt.path("legacy-generator-tail.log"),
+                        )
+                self._finalize_worker_log(worker_log)
+                generation_phase = supervised.generation_phase
+                resources = _resource_payload(
+                    supervised.usage,
+                    generation_phase,
+                    memory_limit_bytes=supervised.memory_limit_bytes,
+                    memory_limit_reason=supervised.memory_limit_reason,
+                    supervised=supervised,
+                    source_revision=self.source_revision,
+                    campaign_invocation_id=self.settings.campaign_invocation_id,
+                )
+                if supervised.reason == "cancelled":
+                    if self.settings.discard_cancelled_attempts:
+                        attempt.discard()
+                        detail = (
+                            "incomplete attempt discarded"
+                            if decision.current is None
+                            else (
+                                "previous valid current preserved; incomplete "
+                                "attempt discarded"
+                            )
+                        )
+                    else:
+                        attempt.mark_interrupted(
+                            "worker terminated by cancellation",
+                            artifact_paths=_attempt_files(
+                                attempt.root,
+                                include_heavy_artifact=(
+                                    not self.settings.remove_heavy_attempt_artifacts
+                                ),
+                            ),
+                        )
+                        detail = (
+                            attempt.attempt_id
+                            if decision.current is None
+                            else "previous valid current preserved"
+                        )
+                    return CellOutcome(
+                        cell.cell_id,
+                        "cancelled",
+                        detail,
+                        terminal_detail="worker terminated by cancellation",
+                    )
+                policy_state: PolicyMeasurementState | None = None
+                if self.settings.manual_terminal_censors and supervised.reason in {
+                    "generation_timeout",
+                    "memory_limit",
+                    "worker_timeout",
+                    "profiling_timeout",
+                    "validation_timeout",
+                }:
+                    resources["terminal_reason"] = supervised.reason
+                    result, policy_state = self._manual_terminal_result(
+                        cell=cell,
+                        reason=supervised.reason,
+                        resources=resources,
+                        progress_path=worker_progress,
+                    )
+                elif (
+                    supervised.reason == "generation_timeout"
+                    and generation_timeout is not None
+                    and self.settings.campaign_policy.allow_terminal_censors
+                ):
+                    phase_evidence = (
+                        None if generation_phase is None else generation_phase.as_dict()
+                    )
+                    observed_generation = (
+                        phase_evidence.get("generation_elapsed_seconds")
+                        if isinstance(phase_evidence, Mapping)
+                        else None
+                    )
+                    if (
+                        isinstance(phase_evidence, Mapping)
+                        and isinstance(observed_generation, (int, float))
+                        and not isinstance(observed_generation, bool)
+                    ):
+                        result = policy_censor_measurement(
+                            self.settings.campaign_policy,
+                            self.settings.report_profile or "",
+                            cell,
+                            kind=PolicyCensorKind.GENERATION_LIMIT,
+                            source_identity=self.source_identity,
+                            resources=resources,
+                            observed_generation_seconds=float(observed_generation),
+                            phase_evidence=phase_evidence,
+                        )
+                        policy_state = PolicyMeasurementState.GENERATION_LIMIT
+                    else:
+                        result = failure_measurement(
+                            ResultStatus.ERROR,
+                            "generation timeout lacked authenticated phase evidence",
+                            resources=resources,
+                        )
+                elif (
+                    supervised.reason == "memory_limit"
+                    and self.settings.campaign_policy.allow_terminal_censors
+                ):
+                    peak_rss = resources.get("peak_rss_bytes")
+                    peak_guard = resources.get("peak_guard_bytes")
+                    metric_abi = resources.get("memory_metric_abi")
+                    limit_reason = resources.get("memory_limit_reason")
+                    if (
+                        isinstance(peak_rss, int)
+                        and not isinstance(peak_rss, bool)
+                        and isinstance(peak_guard, int)
+                        and not isinstance(peak_guard, bool)
+                        and isinstance(metric_abi, str)
+                        and isinstance(limit_reason, str)
+                    ):
+                        result = policy_censor_measurement(
+                            self.settings.campaign_policy,
+                            self.settings.report_profile or "",
+                            cell,
+                            kind=PolicyCensorKind.MEMORY_LIMIT,
+                            source_identity=self.source_identity,
+                            resources=resources,
+                            observed_rss_bytes=peak_rss,
+                            observed_guard_bytes=peak_guard,
+                            memory_metric_abi=metric_abi,
+                            memory_limit_reason=limit_reason,
+                        )
+                        policy_state = PolicyMeasurementState.MEMORY_LIMIT
+                    elif (
+                        isinstance(peak_rss, int)
+                        and not isinstance(peak_rss, bool)
+                        and metric_abi is None
+                        and self.settings.campaign_policy
+                        is not MACBOOK_M3_Z_TABLE_F_POLICY
+                    ):
+                        result = policy_censor_measurement(
+                            self.settings.campaign_policy,
+                            self.settings.report_profile or "",
+                            cell,
+                            kind=PolicyCensorKind.MEMORY_LIMIT,
+                            source_identity=self.source_identity,
+                            resources=resources,
+                            observed_rss_bytes=peak_rss,
+                        )
+                        policy_state = PolicyMeasurementState.MEMORY_LIMIT
+                    else:
+                        result = failure_measurement(
+                            ResultStatus.ERROR,
+                            "memory limit lacked authenticated RSS evidence",
+                            resources=resources,
+                        )
+                elif supervised.reason != "completed":
+                    status = {
+                        "worker_timeout": ResultStatus.TIMEOUT,
+                        "generation_timeout": ResultStatus.TIMEOUT,
+                        "profiling_timeout": ResultStatus.TIMEOUT,
+                        "validation_timeout": ResultStatus.TIMEOUT,
+                        "memory_limit": ResultStatus.MEMORY_LIMIT,
+                        "memory_probe_error": ResultStatus.ERROR,
+                        "output_limit": ResultStatus.ERROR,
+                        "output_probe_error": ResultStatus.ERROR,
+                        "disk_space_limit": ResultStatus.ERROR,
+                        "disk_probe_error": ResultStatus.ERROR,
+                        "phase_state_error": ResultStatus.ERROR,
+                        "worker_exit": ResultStatus.ERROR,
+                    }[supervised.reason]
+                    if supervised.reason == "worker_exit":
+                        error: BaseException | str = _worker_process_exit_error(
+                            supervised
+                        )
+                    elif supervised.reason == "phase_state_error":
+                        error = (
+                            supervised.phase_state_error
+                            or "worker phase-state validation failed"
+                        )
+                    else:
+                        error = f"worker terminated by {supervised.reason}"
+                    result = failure_measurement(
+                        status,
+                        error,
+                        resources=resources,
+                    )
+                elif supervised.returncode != 0 or not worker_result.is_file():
+                    result = failure_measurement(
+                        ResultStatus.ERROR,
+                        _worker_process_exit_error(supervised),
+                        resources=resources,
+                    )
+                else:
+                    raw = json.loads(worker_result.read_text(encoding="ascii"))
+                    if not isinstance(raw, Mapping):
+                        raise TypeError("worker result must be a JSON object")
+                    result = dict(raw)
+                    child_resources = result.get("resources")
+                    child_failure = result.get("failure")
+                    child_terminal_reason = (
+                        child_resources.get("terminal_reason")
+                        if isinstance(child_resources, Mapping)
+                        else None
+                    )
+                    authenticated_child_profile_timeout = (
+                        result.get("status") == ResultStatus.TIMEOUT.value
+                        and child_terminal_reason == "profiling_timeout"
+                        and isinstance(child_failure, Mapping)
+                        and child_failure.get("kind") == "ProfilingTimeLimitError"
+                    )
+                    if authenticated_child_profile_timeout:
+                        resources["terminal_reason"] = "profiling_timeout"
+                    result["resources"] = resources
+                    if (
+                        self.settings.manual_terminal_censors
+                        and authenticated_child_profile_timeout
+                    ):
+                        policy_state, censor = self._manual_terminal_contract(
+                            "profiling_timeout"
+                        )
+                        self._attach_manual_provenance(
+                            result,
+                            cell=cell,
+                            censor=censor,
+                            progress_path=worker_progress,
+                        )
+                    else:
+                        self._attach_manual_provenance(
+                            result,
+                            cell=cell,
+                            progress_path=worker_progress,
+                        )
+                    self._bind_study_result(
+                        result,
+                        require_existing_harness=True,
+                    )
+                if supervised.reason != "completed" or (
+                    supervised.returncode != 0 or not worker_result.is_file()
+                ):
+                    provenance = result.get("provenance")
+                    manual_provenance = (
+                        provenance.get("manual_campaign")
+                        if isinstance(provenance, Mapping)
+                        else None
+                    )
+                    if not isinstance(manual_provenance, Mapping):
+                        self._attach_manual_provenance(
+                            result,
+                            cell=cell,
+                            progress_path=worker_progress,
+                        )
+                    self._bind_study_result(result)
+                candidate_status = result.get("status")
+                result_validation = result.get("validation")
+                authority_state = (
+                    result_validation.get(INDEPENDENT_AUTHORITY_FIELD)
+                    if isinstance(result_validation, Mapping)
+                    else None
+                )
+                if candidate_status == ResultStatus.UNVERIFIED.value or (
+                    candidate_status == ResultStatus.OK.value
+                    and isinstance(authority_state, Mapping)
+                ):
+                    # Authenticate the complete retained diagnostic before any
+                    # late authority is allowed to transform its status.
+                    validate_measurement(
+                        result,
+                        expected_cell=cell,
+                        catalog=self.catalog,
+                    )
+                    late_authority: tuple[str, CurrentRecord] | None = None
+                    for authority_cell_id in planned.numerical_authority_cell_ids:
+                        current_authority = self._current(
+                            self.catalog.cell(authority_cell_id),
+                            comparison_dependency=True,
+                        )
+                        if (
+                            current_authority is not None
+                            and current_authority[1]
+                            is PolicyMeasurementState.SUCCESS
+                        ):
+                            late_authority = (
+                                authority_cell_id,
+                                current_authority[0],
+                            )
+                            break
+                    previous_selected = (
+                        authority_state.get("selected_cell_id")
+                        if isinstance(authority_state, Mapping)
+                        else None
+                    )
+                    should_reconcile = late_authority is not None and (
+                        candidate_status == ResultStatus.UNVERIFIED.value
+                        or (
+                            isinstance(previous_selected, str)
+                                and planned.numerical_authority_cell_ids.index(
+                                    late_authority[0]
+                                )
+                                < planned.numerical_authority_cell_ids.index(
+                                    previous_selected
+                            )
+                        )
+                    )
+                    if should_reconcile:
+                        assert late_authority is not None
+                        authority_cell_id, authority_record = late_authority
+                        result = reconcile_independent_authority(
+                            cell,
+                            result,
+                            authority_record.result,
+                            authority_cell_id=authority_cell_id,
+                        )
+                        if result.get("status") == ResultStatus.OK.value:
+                            direct_peer_ids = {
+                                edge.baseline.cell_id
+                                for edge in incoming_agreement_edges(
+                                    cell,
+                                    catalog=self.catalog,
+                                )
+                            }
+                            late_peers = {
+                                peer_cell_id: peer_record.result
+                                for peer_cell_id, peer_record in peer_records.items()
+                            }
+                            if authority_cell_id in direct_peer_ids:
+                                late_peers[authority_cell_id] = authority_record.result
+                            attach_direct_agreements(
+                                cell,
+                                result,
+                                late_peers,
+                                catalog=self.catalog,
+                            )
+                validate_measurement(
+                    result,
+                    expected_cell=cell,
+                    catalog=self.catalog,
+                )
+                if result["status"] == ResultStatus.OK.value:
+                    policy_state = (
+                        PolicyMeasurementState.SUCCESS
+                        if self.settings.campaign_policy is STRICT_POLICY
+                        else validate_policy_measurement(
+                            self.settings.campaign_policy,
+                            self.settings.report_profile or "",
+                            cell,
+                            result,
+                            expected_source_revision=self.source_revision,
+                            expected_source_tree=self.source_tree,
+                        )
+                    )
+                elif (
+                    policy_state is not None
+                    and not self.settings.manual_terminal_censors
+                ):
+                    validated_state = validate_policy_measurement(
+                        self.settings.campaign_policy,
+                        self.settings.report_profile or "",
+                        cell,
+                        result,
+                        expected_source_revision=self.source_revision,
+                        expected_source_tree=self.source_tree,
+                    )
+                    if validated_state is not policy_state:
+                        raise RuntimeError(
+                            "policy censor state changed during validation"
+                        )
+                if policy_state is PolicyMeasurementState.SUCCESS:
+                    self._compact_reference_artifact(cell, artifact_path, result)
+                    validate_measurement(
+                        result,
+                        expected_cell=cell,
+                        catalog=self.catalog,
+                    )
+                else:
+                    self._discard_terminal_artifact(artifact_path, attempt.root)
+                attempt.write_json("worker-result.json", result)
+                paths = _attempt_files(
+                    attempt.root,
+                    include_heavy_artifact=(
+                        policy_state is PolicyMeasurementState.SUCCESS
+                        or not self.settings.remove_heavy_attempt_artifacts
+                    ),
+                )
+                if policy_state is not None:
+                    record = attempt.publish(result, artifact_paths=paths)
+                    return CellOutcome(
+                        cell.cell_id,
+                        (
+                            "ok"
+                            if policy_state is PolicyMeasurementState.SUCCESS
+                            else policy_state.value
+                        ),
+                        record.attempt_id,
+                        terminal_detail=(
+                            None
+                            if policy_state is PolicyMeasurementState.SUCCESS
+                            else _measurement_terminal_detail(result)
+                        ),
+                    )
+                attempt.mark_failed(
+                    str(result.get("failure")),
+                    artifact_paths=paths,
+                )
+                return CellOutcome(
+                    cell.cell_id,
+                    str(result["status"]),
+                    (
+                        attempt.attempt_id
+                        if decision.current is None
+                        else "previous valid current preserved"
+                    ),
+                    terminal_detail=_measurement_terminal_detail(result),
+                )
+
+    def _publish_dependency_censor(
+        self,
+        cell: CellSpec,
+        dependencies: Sequence[Mapping[str, object]],
+        *,
+        current: CurrentRecord | None,
+    ) -> CellOutcome:
+        with self.service.store.new_attempt(
+            cell.cell_id,
+            self.settings.artifact_policy,
+            based_on=current,
+        ) as attempt:
+            result = policy_censor_measurement(
+                self.settings.campaign_policy,
+                self.settings.report_profile or "",
+                cell,
+                kind=PolicyCensorKind.DEPENDENCY,
+                source_identity=self.source_identity,
+                resources=None,
+                dependencies=tuple(
+                    sorted(
+                        (dict(item) for item in dependencies),
+                        key=lambda item: str(item["cell_id"]),
+                    )
+                ),
+            )
+            self._bind_study_result(result)
+            validate_measurement(
+                result,
+                expected_cell=cell,
+                catalog=self.catalog,
+            )
+            record = attempt.publish(result)
+            return CellOutcome(
+                cell.cell_id,
+                PolicyMeasurementState.DEPENDENCY.value,
+                record.attempt_id,
+                terminal_detail=_measurement_terminal_detail(result),
+            )
+
+    def _publish_resource_frontier(
+        self,
+        cell: CellSpec,
+        frontier: Mapping[str, object],
+        *,
+        current: CurrentRecord | None,
+    ) -> CellOutcome:
+        with self.service.store.new_attempt(
+            cell.cell_id,
+            self.settings.artifact_policy,
+            based_on=current,
+        ) as attempt:
+            result = policy_censor_measurement(
+                self.settings.campaign_policy,
+                self.settings.report_profile or "",
+                cell,
+                kind=PolicyCensorKind.RESOURCE_FRONTIER,
+                source_identity=self.source_identity,
+                resources=None,
+                frontier=frontier,
+            )
+            self._bind_study_result(result)
+            validate_measurement(
+                result,
+                expected_cell=cell,
+                catalog=self.catalog,
+            )
+            record = attempt.publish(result)
+            return CellOutcome(
+                cell.cell_id,
+                PolicyMeasurementState.RESOURCE_FRONTIER.value,
+                record.attempt_id,
+                terminal_detail=_measurement_terminal_detail(result),
+            )
+
+    def _effective_cell_rss_limit(self) -> int | None:
+        return self.settings.effective_cell_rss_limit()
+
+    def _publish_blocked_dependency(
+        self,
+        cell: CellSpec,
+        prerequisite_cell_ids: str | Sequence[str],
+        *,
+        current: CurrentRecord | None,
+    ) -> CellOutcome:
+        normalized = tuple(
+            sorted(
+                {
+                    value
+                    for value in (
+                        (prerequisite_cell_ids,)
+                        if isinstance(prerequisite_cell_ids, str)
+                        else prerequisite_cell_ids
+                    )
+                    if isinstance(value, str) and value
+                }
+            )
+        )
+        if not normalized:
+            raise ValueError("blocked dependency requires a prerequisite cell ID")
+        if len(normalized) == 1:
+            message = (
+                "blocked by dependency: required prerequisite "
+                f"{normalized[0]!r} is unavailable"
+            )
+        else:
+            rendered = ", ".join(repr(value) for value in normalized)
+            message = (
+                "blocked by dependency: required prerequisites "
+                f"{rendered} are unavailable"
+            )
+        with self.service.store.new_attempt(
+            cell.cell_id,
+            self.settings.artifact_policy,
+            based_on=current,
+        ) as attempt:
+            result = failure_measurement(ResultStatus.SKIP, message)
+            result["blocked_dependency"] = {
+                "prerequisite_cell_ids": list(normalized),
+            }
+            self._bind_study_result(result)
+            attempt.write_json("worker-result.json", result)
+            attempt.mark_failed(
+                message,
+                artifact_paths=("worker-result.json",),
+            )
+            return CellOutcome(
+                cell.cell_id,
+                "blocked_dependency",
+                message,
+                normalized,
+                terminal_detail=message,
+            )
+
+    def _publish_skip(
+        self,
+        cell: CellSpec,
+        message: str,
+        *,
+        current: CurrentRecord | None,
+    ) -> CellOutcome:
+        """Retain the generic failed-attempt helper for non-dependency callers."""
+
+        with self.service.store.new_attempt(
+            cell.cell_id,
+            self.settings.artifact_policy,
+            based_on=current,
+        ) as attempt:
+            result = failure_measurement(ResultStatus.SKIP, message)
+            self._bind_study_result(result)
+            attempt.write_json("worker-result.json", result)
+            attempt.mark_failed(
+                message,
+                artifact_paths=("worker-result.json",),
+            )
+            return CellOutcome(
+                cell.cell_id,
+                ResultStatus.SKIP.value,
+                (
+                    attempt.attempt_id
+                    if current is None
+                    else "previous valid current preserved"
+                ),
+                terminal_detail=message,
+            )
+
+
+__all__ = [
+    "CampaignResult",
+    "CampaignScheduler",
+    "CampaignSettings",
+    "CellOutcome",
+    "CellSelection",
+    "PlannedCell",
+    "archive_cell_attempt_history",
+    "plan_campaign",
+    "reconcile_attempt_history",
+    "select_cells",
+    "validate_campaign_plan",
+]
diff --git a/pyamplicol/tools/performance_report/selector_policy.py b/pyamplicol/tools/performance_report/selector_policy.py
new file mode 100644
index 0000000000..b5be5236b3
--- /dev/null
+++ b/pyamplicol/tools/performance_report/selector_policy.py
@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: 0BSD
+"""Backend-independent selector policy for LC report comparisons."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+
+
+class SelectorPolicyError(ValueError):
+    """Raised when a physical selector axis cannot be chosen unambiguously."""
+
+
+def canonical_lc_flow_word(word: Sequence[int]) -> tuple[int, ...]:
+    """Validate and return one labelled physical LC flow word."""
+
+    normalized = tuple(word)
+    if (
+        not normalized
+        or any(
+            isinstance(label, bool) or not isinstance(label, int)
+            for label in normalized
+        )
+        or any(label < 1 for label in normalized)
+        or len(set(normalized)) != len(normalized)
+    ):
+        raise SelectorPolicyError(
+            "LC selector flow words must contain distinct positive source labels"
+        )
+    return normalized
+
+
+def canonical_lc_selector_word(
+    words: Iterable[Sequence[int]],
+) -> tuple[int, ...]:
+    """Choose the backend-independent representative of a physical LC axis.
+
+    The choice is deliberately structural.  Selecting by evaluated magnitude
+    makes two correct backends choose different labelled components whenever
+    their physical axes have different enumeration orders or roundoff.
+    """
+
+    normalized = tuple(canonical_lc_flow_word(word) for word in words)
+    if not normalized:
+        raise SelectorPolicyError("LC selector derivation requires a color-flow axis")
+    if len(set(normalized)) != len(normalized):
+        raise SelectorPolicyError("LC selector color-flow words must be unique")
+    return min(normalized)
+
+
+def selector_color_flow_id(word: Sequence[int]) -> str:
+    normalized = canonical_lc_flow_word(word)
+    return "flow:" + ",".join(str(label) for label in normalized)
+
+
+def _preferred_helicities(pdg: int) -> tuple[int, ...]:
+    absolute = abs(int(pdg))
+    if absolute in {
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        21,
+        22,
+    }:
+        return (-1, 1)
+    if absolute in {23, 24}:
+        return (-1, 0, 1)
+    return (0,)
+
+
+def fixed_selector_helicity(pdgs: Sequence[int]) -> tuple[int, ...]:
+    """Return the deterministic physical helicity shared by report backends."""
+
+    if not pdgs:
+        raise SelectorPolicyError("selector helicity derivation requires external PDGs")
+    result: list[int] = []
+    charged_current_fermions = any(abs(int(pdg)) in {12, 14, 16} for pdg in pdgs)
+    for index, pdg in enumerate(pdgs, start=1):
+        domain = _preferred_helicities(pdg)
+        if -1 in domain and 1 in domain:
+            # Prefer the left-chiral particle/right-chiral antiparticle state
+            # for charged-current fermion chains.  Preserve the established
+            # alternating vector/neutral-current report convention otherwise.
+            if charged_current_fermions and (
+                1 <= abs(int(pdg)) <= 6 or 11 <= abs(int(pdg)) <= 16
+            ):
+                result.append(-1 if int(pdg) > 0 else 1)
+            else:
+                result.append(-1 if index % 2 else 1)
+        elif 0 in domain:
+            result.append(0)
+        else:
+            result.append(domain[0])
+    return tuple(result)
+
+
+def selector_helicity_id(values: Sequence[int]) -> str:
+    return "h:" + ",".join(f"{int(value):+d}" for value in values)
+
+
+__all__ = [
+    "SelectorPolicyError",
+    "canonical_lc_flow_word",
+    "canonical_lc_selector_word",
+    "fixed_selector_helicity",
+    "selector_color_flow_id",
+    "selector_helicity_id",
+]
diff --git a/pyamplicol/tools/performance_report/service.py b/pyamplicol/tools/performance_report/service.py
new file mode 100644
index 0000000000..119ff490e6
--- /dev/null
+++ b/pyamplicol/tools/performance_report/service.py
@@ -0,0 +1,560 @@
+# SPDX-License-Identifier: 0BSD
+"""Transactional cache merge, validation, and report-table publication."""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import tempfile
+from collections import Counter
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+from .artifacts import ArtifactStore, CurrentRecord
+from .cache import (
+    build_reset_caches,
+    reset_entry,
+    schema_document,
+    validate_cache,
+    validate_measurement,
+)
+from .campaign_reset import OriginalAmplicolSeed, load_seed_if_present
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .measurement_lineage import (
+    MeasurementLineage,
+    load_and_audit_measurement_lineage,
+)
+from .models import CellSpec
+from .publication import portable_publication_value
+from .render import render_all_tables, summarize_visible_completeness
+from .report_policy import publication_measurement_policy_issues
+from .source_identity import require_eligible_report_source
+
+
+class ReportServiceError(RuntimeError):
+    """Raised when cache or table publication cannot be completed."""
+
+
+_PROFILE_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,63}")
+CANONICAL_REPORT_ROOT = Path("src/pyamplicol/_profiling_campaign")
+PROFILE_REPORT_ROOT = Path("docs/performance_reports")
+CANONICAL_REPORT_ENTRYPOINT = CANONICAL_REPORT_ROOT / "result_tables.py"
+
+
+def validate_profile_name(value: str) -> str:
+    """Return a filesystem-safe, human-readable report profile identifier."""
+
+    if _PROFILE_RE.fullmatch(value) is None or ".." in value:
+        raise ValueError(
+            "report profile must contain 1-64 letters, digits, dots, "
+            "underscores, or hyphens; it cannot contain '..'"
+        )
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class ReportPaths:
+    repo_root: Path
+    docs_dir: Path
+    results_dir: Path
+    artifact_root: Path
+    coordination_root: Path
+
+    @classmethod
+    def from_repo(
+        cls,
+        repo_root: Path,
+        *,
+        profile: str | None = None,
+        docs_dir: Path | None = None,
+        artifact_root: Path | None = None,
+        coordination_root: Path | None = None,
+    ) -> ReportPaths:
+        root = repo_root.expanduser().resolve(strict=False)
+        if profile is not None:
+            profile = validate_profile_name(profile)
+        if profile is not None and docs_dir is not None:
+            raise ValueError("profile and docs_dir are mutually exclusive")
+        docs = root / (
+            CANONICAL_REPORT_ROOT
+            if profile is None
+            else PROFILE_REPORT_ROOT / profile
+        )
+        if docs_dir is not None:
+            docs = docs_dir.expanduser().resolve(strict=False)
+        identity = "canonical" if profile is None else profile
+        default_artifacts = root / ".artifacts/performance-report" / identity
+        artifacts = (
+            default_artifacts
+            if artifact_root is None
+            else artifact_root.expanduser().resolve(strict=False)
+        )
+        coordination = (
+            (
+                root
+                / ".artifacts/performance-report-coordination"
+                / identity
+            )
+            if coordination_root is None
+            else coordination_root.expanduser().resolve(strict=False)
+        )
+        return cls(root, docs, docs / "results", artifacts, coordination)
+
+
+def _canonical_bytes(payload: object) -> bytes:
+    return (
+        json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        + "\n"
+    ).encode("ascii")
+
+
+class ReportService:
+    def __init__(
+        self,
+        paths: ReportPaths,
+        *,
+        catalog: ReportCatalog = REPORT_CATALOG,
+        portable_current_results: bool = False,
+    ) -> None:
+        self.paths = paths
+        self.catalog = catalog
+        self.store = ArtifactStore(
+            artifact_root=paths.artifact_root,
+            lock_root=paths.coordination_root,
+            current_publication_paths=(paths if portable_current_results else None),
+        )
+        self._authenticated_measurement_lineage: MeasurementLineage | None = None
+        self._measurement_lineage_bound = False
+        self._authenticated_original_amplicol_seed: OriginalAmplicolSeed | None = None
+        self._original_amplicol_seed_bound = False
+
+    def bind_measurement_lineage(
+        self,
+        lineage: MeasurementLineage | None,
+    ) -> None:
+        """Reuse one already fully audited bridge through a campaign transaction."""
+
+        self._authenticated_measurement_lineage = lineage
+        self._measurement_lineage_bound = True
+
+    def _profile_name(self) -> str | None:
+        try:
+            relative = self.paths.docs_dir.relative_to(
+                self.paths.repo_root / PROFILE_REPORT_ROOT
+            )
+        except ValueError:
+            return None
+        if (
+            len(relative.parts) != 1
+            or _PROFILE_RE.fullmatch(relative.parts[0]) is None
+            or ".." in relative.parts[0]
+        ):
+            return None
+        return relative.parts[0]
+
+    def bind_original_amplicol_seed(
+        self,
+        seed: OriginalAmplicolSeed | None,
+    ) -> None:
+        """Reuse one already authenticated campaign-seed manifest."""
+
+        self._authenticated_original_amplicol_seed = seed
+        self._original_amplicol_seed_bound = True
+
+    def _original_amplicol_seed(self) -> OriginalAmplicolSeed | None:
+        if self._original_amplicol_seed_bound:
+            return self._authenticated_original_amplicol_seed
+        profile = self._profile_name()
+        seed = (
+            None
+            if profile is None
+            else load_seed_if_present(
+                profile=profile,
+                store=self.store,
+                catalog=self.catalog,
+            )
+        )
+        self.bind_original_amplicol_seed(seed)
+        return seed
+
+    def _measurement_lineage(self) -> MeasurementLineage | None:
+        if self._measurement_lineage_bound:
+            return self._authenticated_measurement_lineage
+        if self._profile_name() is None:
+            return None
+        if not (
+            self.paths.docs_dir / "measurement_lineage.json"
+        ).exists() and (
+            not self.store.recover_current_records()
+            or self._original_amplicol_seed() is not None
+        ):
+            self.bind_measurement_lineage(None)
+            return None
+        source = require_eligible_report_source(self.paths.repo_root)
+        lineage = load_and_audit_measurement_lineage(
+            self.paths.repo_root,
+            self.paths.docs_dir,
+            self.store,
+            expected_active_source_revision=source.revision,
+            catalog=self.catalog,
+        )
+        self.bind_measurement_lineage(lineage)
+        return lineage
+
+    def _render_tables(
+        self,
+        caches: Mapping[str, Mapping[str, object]],
+    ) -> dict[str, str]:
+        lineage = self._measurement_lineage()
+        source_lineage = (
+            None
+            if lineage is None
+            else (lineage.ancestor_revision, lineage.descendant_revision)
+        )
+        if source_lineage is None:
+            return render_all_tables(caches, catalog=self.catalog)
+        return render_all_tables(
+            caches,
+            catalog=self.catalog,
+            authenticated_source_lineage=source_lineage,
+        )
+
+    def reset_payloads(self) -> dict[str, dict[str, object]]:
+        return build_reset_caches(self.catalog)
+
+    def load_caches(self) -> dict[str, dict[str, object]]:
+        expected = self.reset_payloads()
+        caches: dict[str, dict[str, object]] = {}
+        for name in expected:
+            path = self.paths.results_dir / name
+            try:
+                payload = json.loads(path.read_text(encoding="ascii"))
+            except FileNotFoundError:
+                payload = expected[name]
+            except (OSError, json.JSONDecodeError) as error:
+                raise ReportServiceError(
+                    f"cannot load report cache {path}: {error}"
+                ) from error
+            if not isinstance(payload, dict):
+                raise ReportServiceError(f"report cache {path} must be an object")
+            caches[name] = payload
+        self.validate_payloads(caches)
+        return caches
+
+    def validate_payloads(
+        self,
+        caches: Mapping[str, Mapping[str, object]],
+    ) -> None:
+        cells_by_dataset: dict[str, list[object]] = {}
+        cells_by_id: dict[str, CellSpec] = {}
+        for cell in self.catalog.measurement_cells():
+            cells_by_dataset.setdefault(cell.dataset_id, []).append(cell)
+            cells_by_id[cell.cell_id] = cell
+        expected_names = {f"{dataset_id}.json" for dataset_id in cells_by_dataset}
+        if set(caches) != expected_names:
+            raise ReportServiceError(
+                "report cache set differs from catalog; "
+                f"missing={sorted(expected_names - set(caches))}, "
+                f"extra={sorted(set(caches) - expected_names)}"
+            )
+        for name, payload in caches.items():
+            dataset_id = name.removesuffix(".json")
+            validate_cache(
+                payload,
+                expected_cells=cells_by_dataset[dataset_id],  # type: ignore[arg-type]
+                catalog=self.catalog,
+            )
+            entries = payload["entries"]
+            assert isinstance(entries, list)
+            for entry in entries:
+                assert isinstance(entry, Mapping)
+                cell = cells_by_id[str(entry["cell_id"])]
+                if (
+                    self.catalog.static_na_reason(cell) is not None
+                    and entry.get("measurement")
+                    != reset_entry(cell)["measurement"]
+                ):
+                    raise ReportServiceError(
+                        f"{cell.cell_id}: catalog static N/A cache entry "
+                        "differs from the canonical reset measurement"
+                    )
+
+    def merge_current(
+        self,
+        caches: dict[str, dict[str, object]],
+        records: tuple[CurrentRecord, ...] | None = None,
+    ) -> int:
+        records = self.store.recover_current_records() if records is None else records
+        source = require_eligible_report_source(self.paths.repo_root)
+        expected_revision = source.revision
+        lineage = self._measurement_lineage()
+        seed = self._original_amplicol_seed()
+        by_cell = {
+            record.cell_id: record
+            for record in records
+            if (
+                (
+                    lineage.source_for_current(
+                        record,
+                        active_revision=source.revision,
+                        active_tree=source.tree,
+                    )
+                    is not None
+                    if lineage is not None
+                    else (
+                        isinstance(record.result.get("provenance"), Mapping)
+                        and record.result["provenance"].get(
+                            "report_source_revision"
+                        )
+                        == expected_revision
+                        and record.result["provenance"].get("report_source_tree")
+                        == source.tree
+                    )
+                )
+                or (
+                    seed is not None
+                    and seed.source_for_current(
+                        record,
+                        active_revision=source.revision,
+                        active_tree=source.tree,
+                    )
+                    is not None
+                )
+            )
+        }
+        cells_by_id = {
+            cell.cell_id: cell for cell in self.catalog.measurement_cells()
+        }
+        merged = 0
+        for payload in caches.values():
+            entries = payload["entries"]
+            assert isinstance(entries, list)
+            for entry in entries:
+                assert isinstance(entry, dict)
+                cell_id = str(entry["cell_id"])
+                cell = cells_by_id[cell_id]
+                if self.catalog.static_na_reason(cell) is not None:
+                    entry["measurement"] = reset_entry(cell)["measurement"]
+                    continue
+                if (
+                    lineage is not None
+                    and cell_id in lineage.required_descendant_cell_ids
+                ):
+                    entry["measurement"] = reset_entry(cell)["measurement"]
+                record = by_cell.get(cell_id)
+                if record is None:
+                    continue
+                measurement = record.result
+                validate_measurement(
+                    measurement,
+                    expected_cell=cell,
+                    catalog=self.catalog,
+                )
+                entry["measurement"] = dict(measurement)
+                merged += 1
+        self.validate_payloads(caches)
+        return merged
+
+    def _snapshot_files(
+        self,
+        caches: Mapping[str, Mapping[str, object]],
+        tables: Mapping[str, str],
+    ) -> tuple[Path, ...]:
+        portable_caches = {
+            name: portable_publication_value(payload, self.paths)
+            for name, payload in caches.items()
+        }
+        self.validate_payloads(portable_caches)  # type: ignore[arg-type]
+        self.paths.results_dir.mkdir(parents=True, exist_ok=True)
+        staging_root = self.paths.artifact_root / "report-snapshot-builds"
+        staging_root.mkdir(parents=True, exist_ok=True)
+        staging = Path(
+            tempfile.mkdtemp(
+                prefix=".report-snapshot-",
+                dir=staging_root,
+            )
+        )
+        written: list[Path] = []
+        replaced: list[tuple[Path, Path | None]] = []
+        temporary_files: list[Path] = []
+
+        def adjacent_temporary(destination: Path, *, kind: str) -> Path:
+            with tempfile.NamedTemporaryFile(
+                prefix=f".{destination.name}.report-{kind}-",
+                dir=destination.parent,
+                delete=False,
+            ) as handle:
+                temporary = Path(handle.name)
+            temporary_files.append(temporary)
+            return temporary
+
+        try:
+            staged_results = staging / "results"
+            staged_results.mkdir()
+            schema_path = staged_results / "report-cache.schema.json"
+            schema_path.write_bytes(_canonical_bytes(schema_document()))
+            for name, payload in portable_caches.items():
+                (staged_results / name).write_bytes(_canonical_bytes(payload))
+            for name, content in tables.items():
+                (staging / name).write_text(content, encoding="ascii")
+
+            publications = [
+                (
+                    schema_path,
+                    self.paths.results_dir / "report-cache.schema.json",
+                    Path("results/report-cache.schema.json"),
+                ),
+                *(
+                    (
+                        staged_results / name,
+                        self.paths.results_dir / name,
+                        Path("results") / name,
+                    )
+                    for name in sorted(caches)
+                ),
+                *(
+                    (
+                        staging / name,
+                        self.paths.docs_dir / name,
+                        Path(name),
+                    )
+                    for name in sorted(tables)
+                ),
+            ]
+            try:
+                for source, destination, _relative in publications:
+                    backup: Path | None = None
+                    if destination.exists():
+                        backup = adjacent_temporary(destination, kind="backup")
+                        shutil.copy2(destination, backup)
+                    install = adjacent_temporary(destination, kind="install")
+                    shutil.copy2(source, install)
+                    install.replace(destination)
+                    replaced.append((destination, backup))
+                    written.append(destination)
+            except BaseException:
+                for destination, backup in reversed(replaced):
+                    if backup is None:
+                        destination.unlink(missing_ok=True)
+                    else:
+                        backup.replace(destination)
+                raise
+        finally:
+            for temporary in temporary_files:
+                temporary.unlink(missing_ok=True)
+            shutil.rmtree(staging, ignore_errors=True)
+        return tuple(written)
+
+    def publish(
+        self,
+        *,
+        reset: bool = False,
+        merge_artifacts: bool = True,
+    ) -> tuple[Path, ...]:
+        with self.store.named_lock("report-writer"):
+            caches = self.reset_payloads() if reset else self.load_caches()
+            if merge_artifacts and not reset:
+                self.merge_current(caches)
+            tables = self._render_tables(caches)
+            return self._snapshot_files(caches, tables)
+
+    def validate(self) -> dict[str, object]:
+        caches = self.load_caches()
+        tables = self._render_tables(caches)
+        statuses: Counter[str] = Counter()
+        for payload in caches.values():
+            for entry in payload["entries"]:  # type: ignore[index]
+                statuses[str(entry["measurement"]["status"])] += 1
+        return {
+            "cache_count": len(caches),
+            "table_count": len(tables),
+            "statuses": dict(sorted(statuses.items())),
+        }
+
+    def validate_publication_policy(
+        self,
+        caches: Mapping[str, Mapping[str, object]],
+    ) -> None:
+        """Reject successful measurements that are not publication-grade."""
+
+        issues: list[str] = []
+        for payload in caches.values():
+            entries = payload.get("entries")
+            if not isinstance(entries, list):
+                continue
+            for entry in entries:
+                if not isinstance(entry, Mapping):
+                    continue
+                measurement = entry.get("measurement")
+                if not isinstance(measurement, Mapping):
+                    continue
+                for issue in publication_measurement_policy_issues(measurement):
+                    issues.append(
+                        f"{entry.get('cell_id', '<unknown>')}: "
+                        f"{issue.field}: {issue.detail}"
+                    )
+        if issues:
+            displayed = "; ".join(issues[:12])
+            if len(issues) > 12:
+                displayed += f"; ... ({len(issues)} issues total)"
+            raise ReportServiceError(
+                "checked-in measurements violate publication policy: "
+                + displayed
+            )
+
+    def audit(self) -> dict[str, object]:
+        """Validate cache coverage and exact checked-in render correspondence."""
+
+        result = self.validate()
+        caches = self.load_caches()
+        self.validate_publication_policy(caches)
+        rendered = self._render_tables(caches)
+        visible_completeness = summarize_visible_completeness(
+            caches,
+            catalog=self.catalog,
+        )
+        expected_cache_files = {
+            *caches,
+            "report-cache.schema.json",
+        }
+        actual_cache_files = {
+            path.name for path in self.paths.results_dir.glob("*.json")
+        }
+        if actual_cache_files != expected_cache_files:
+            raise ReportServiceError(
+                "checked-in report cache files differ from the catalog; "
+                f"missing={sorted(expected_cache_files - actual_cache_files)}, "
+                f"extra={sorted(actual_cache_files - expected_cache_files)}"
+            )
+        mismatched_tables = [
+            name
+            for name, content in rendered.items()
+            if not (self.paths.docs_dir / name).is_file()
+            or (self.paths.docs_dir / name).read_text(encoding="ascii") != content
+        ]
+        if mismatched_tables:
+            raise ReportServiceError(
+                "checked-in report tables differ from canonical rendering: "
+                + ", ".join(sorted(mismatched_tables))
+            )
+        return {
+            **result,
+            "cache_render_match": True,
+            "visible_completeness": visible_completeness.as_dict(),
+        }
+
+
+__all__ = [
+    "ReportPaths",
+    "ReportService",
+    "ReportServiceError",
+    "validate_profile_name",
+]
diff --git a/pyamplicol/tools/performance_report/source_identity.py b/pyamplicol/tools/performance_report/source_identity.py
new file mode 100644
index 0000000000..4f089376de
--- /dev/null
+++ b/pyamplicol/tools/performance_report/source_identity.py
@@ -0,0 +1,527 @@
+# SPDX-License-Identifier: 0BSD
+"""Fail-closed source identity for reproducible report measurements."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+
+SOURCE_IDENTITY_SCHEMA = "pyamplicol-report-source-v1"
+PUBLICATION_SOURCE_IDENTITY_SCHEMA = "pyamplicol-report-publication-source-v1"
+
+
+class ReportSourceIdentityError(RuntimeError):
+    """The report source cannot be identified as an immutable checkout."""
+
+
+def _git_output(repo_root: Path, *arguments: str) -> bytes:
+    try:
+        completed = subprocess.run(
+            ("git", *arguments),
+            cwd=repo_root,
+            check=False,
+            capture_output=True,
+            timeout=15,
+        )
+    except (OSError, subprocess.SubprocessError) as error:
+        raise ReportSourceIdentityError(
+            f"cannot inspect report source at {repo_root}: {error}"
+        ) from error
+    if completed.returncode != 0:
+        detail = completed.stderr.decode("utf-8", errors="replace").strip()
+        raise ReportSourceIdentityError(
+            f"git {' '.join(arguments)} failed at {repo_root}: "
+            f"{detail or f'exit {completed.returncode}'}"
+        )
+    return completed.stdout
+
+
+def _require_repository_root(repo_root: Path) -> Path:
+    """Reject a nested path that Git would silently bind to a parent checkout."""
+
+    try:
+        root = repo_root.expanduser().resolve(strict=True)
+    except OSError as error:
+        raise ReportSourceIdentityError(
+            f"report source root is unavailable: {repo_root}"
+        ) from error
+    raw = _git_output(root, "rev-parse", "--show-toplevel")
+    rendered = os.fsdecode(raw).strip()
+    if not rendered:
+        raise ReportSourceIdentityError(
+            f"git returned an empty repository root for {root}"
+        )
+    try:
+        discovered = Path(rendered).resolve(strict=True)
+    except (OSError, ValueError) as error:
+        raise ReportSourceIdentityError(
+            f"git returned an invalid repository root for {root}"
+        ) from error
+    if discovered != root:
+        raise ReportSourceIdentityError(
+            f"report source is not the repository root: {root} (Git root {discovered})"
+        )
+    return root
+
+
+def _git_commit(repo_root: Path, revision: str) -> str:
+    commit = (
+        _git_output(repo_root, "rev-parse", "--verify", f"{revision}^{{commit}}")
+        .decode("ascii")
+        .strip()
+    )
+    if not commit:
+        raise ReportSourceIdentityError(
+            f"git returned an empty commit identity for {revision!r}"
+        )
+    return commit
+
+
+def _git_tree(repo_root: Path, revision: str) -> str:
+    tree = (
+        _git_output(repo_root, "rev-parse", "--verify", f"{revision}^{{tree}}")
+        .decode("ascii")
+        .strip()
+    )
+    if not tree:
+        raise ReportSourceIdentityError(
+            f"git returned an empty tree identity for {revision!r}"
+        )
+    return tree
+
+
+def _generated_report_path(value: str) -> bool:
+    """Return whether a dirty path is a generated report output.
+
+    Benchmark caches, rendered tables, authenticated environment metadata,
+    PDFs, campaign-local evaluator attempts, and the corresponding generated
+    files inside one architecture-profile workspace are outputs of a report
+    campaign.
+    They do not alter the evaluator source being measured and therefore do not
+    make the source checkout ineligible. Profile prose, manifests, entry points,
+    nested files, and all other tracked or untracked changes do.
+    """
+
+    path = PurePosixPath(value)
+    parts = path.parts
+    if not parts:
+        return False
+    if parts[0] in {".artifacts", "tmp"}:
+        return True
+    if (
+        len(parts) >= 5
+        and parts[:3] == ("src", "pyamplicol", "_profiling_campaign")
+        and parts[3] == "campaign_artifacts"
+    ):
+        return True
+    if (
+        len(parts) == 5
+        and parts[:4]
+        == ("src", "pyamplicol", "_profiling_campaign", "results")
+        and parts[4].endswith(".json")
+    ):
+        return True
+    if (
+        len(parts) == 4
+        and parts[:3] == ("src", "pyamplicol", "_profiling_campaign")
+    ):
+        return _generated_publication_member(
+            parts[3],
+            allow_auxiliary=True,
+            allow_environment=True,
+        )
+    if (
+        len(parts) >= 5
+        and parts[:2] == ("docs", "performance_reports")
+        and parts[2] not in {"", ".", ".."}
+        and parts[3] == "campaign_artifacts"
+    ):
+        return True
+    if parts[:4] == ("docs", "arxiv", "results", ".coordination"):
+        return True
+    if (
+        len(parts) == 4
+        and parts[:3] == ("docs", "arxiv", "results")
+        and parts[3].endswith((".json", ".lock"))
+    ):
+        return True
+    if len(parts) == 3 and parts[:2] == ("docs", "arxiv"):
+        return _generated_publication_member(
+            parts[2],
+            allow_auxiliary=True,
+            allow_environment=False,
+        )
+    if (
+        len(parts) == 5
+        and parts[:2] == ("docs", "performance_reports")
+        and parts[3] == "results"
+        and parts[4].endswith(".json")
+    ):
+        return True
+    if (
+        len(parts) == 5
+        and parts[:2] == ("docs", "performance_reports")
+        and parts[3] == "campaign_summary_ids"
+        and parts[4].endswith(".txt")
+    ):
+        return True
+    if len(parts) == 4 and parts[:2] == ("docs", "performance_reports"):
+        return _generated_publication_member(
+            parts[3],
+            allow_auxiliary=True,
+            allow_environment=True,
+        )
+    return False
+
+
+def _generated_publication_member(
+    name: str,
+    *,
+    allow_auxiliary: bool,
+    allow_environment: bool,
+) -> bool:
+    if name == "pyAmpliCol.pdf":
+        return True
+    if allow_environment and name in {
+        "measurement_lineage.json",
+        "report_environment.json",
+        "report_environment.tex",
+    }:
+        return True
+    if name == "result_validation_summary.tex":
+        return True
+    if name.startswith("result_") and name.endswith("_table.tex"):
+        return True
+    return allow_auxiliary and name.endswith(
+        (
+            ".aux",
+            ".bbl",
+            ".bcf",
+            ".blg",
+            ".fdb_latexmk",
+            ".fls",
+            ".log",
+            ".out",
+            ".run.xml",
+            ".synctex.gz",
+            ".toc",
+        )
+    )
+
+
+def _architecture_report_path(value: str, profile: str) -> bool:
+    """Return whether ``value`` is a tracked publication member for ``profile``.
+
+    This is deliberately narrower than a directory-prefix check.  In
+    particular, executables, arbitrary nested files, evaluator tools, profile
+    prose, and manifests are not report-only changes.  A measurement commit can
+    therefore be published from a descendant commit only when every intervening
+    path is raw result JSON, authenticated generated environment metadata, a
+    generated table or validation summary, or the reviewed PDF.
+    """
+
+    path = PurePosixPath(value)
+    root = ("docs", "performance_reports", profile)
+    parts = path.parts
+    if parts[:3] != root:
+        return False
+    relative = parts[3:]
+    if len(relative) == 1:
+        return _generated_publication_member(
+            relative[0],
+            allow_auxiliary=False,
+            allow_environment=True,
+        )
+    if len(relative) == 2 and relative[0] == "results":
+        return relative[1].endswith(".json")
+    return False
+
+
+def _diff_changes(
+    repo_root: Path,
+    measured: str,
+    publication: str,
+) -> tuple[tuple[str, tuple[str, ...]], ...]:
+    tokens = iter(
+        _nul_paths(
+            _git_output(
+                repo_root,
+                "diff",
+                "--name-status",
+                "-z",
+                "--find-renames",
+                f"{measured}..{publication}",
+                "--",
+            )
+        )
+    )
+    changes: list[tuple[str, tuple[str, ...]]] = []
+    while True:
+        try:
+            status = next(tokens)
+        except StopIteration:
+            break
+        try:
+            if status.startswith(("R", "C")):
+                paths = (next(tokens), next(tokens))
+            else:
+                paths = (next(tokens),)
+        except StopIteration as error:
+            raise ReportSourceIdentityError(
+                "git returned a malformed publication diff"
+            ) from error
+        changes.append((status, paths))
+    return tuple(changes)
+
+
+def _git_path_mode(repo_root: Path, revision: str, path: str) -> str | None:
+    raw = _git_output(repo_root, "ls-tree", "-z", revision, "--", path)
+    if not raw:
+        return None
+    record = raw.split(b"\0", 1)[0]
+    header, separator, recorded_path = record.partition(b"\t")
+    if not separator or os.fsdecode(recorded_path) != path:
+        raise ReportSourceIdentityError(
+            f"git returned malformed tree metadata for {path!r}"
+        )
+    fields = header.split()
+    if len(fields) != 3:
+        raise ReportSourceIdentityError(
+            f"git returned malformed tree mode for {path!r}"
+        )
+    return fields[0].decode("ascii")
+
+
+def _nul_paths(payload: bytes) -> tuple[str, ...]:
+    return tuple(
+        os.fsdecode(raw)
+        for raw in payload.split(b"\0")
+        if raw
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class ReportSourceIdentity:
+    """Committed source identity plus any disqualifying working-tree changes."""
+
+    revision: str
+    tree: str
+    dirty_paths: tuple[str, ...]
+
+    @property
+    def eligible(self) -> bool:
+        return not self.dirty_paths
+
+    def provenance(self) -> dict[str, object]:
+        return {
+            "report_source_identity_schema": SOURCE_IDENTITY_SCHEMA,
+            "report_source_revision": self.revision,
+            "report_source_tree": self.tree,
+            "report_measured_source_revision": self.revision,
+            "report_measured_source_tree": self.tree,
+            "report_source_clean": self.eligible,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ReportPublicationIdentity:
+    """Authenticated relation between measured and published source commits."""
+
+    profile: str
+    measured_revision: str
+    measured_tree: str
+    publication_revision: str
+    publication_tree: str
+    changed_paths: tuple[str, ...]
+    disallowed_paths: tuple[str, ...]
+
+    @property
+    def eligible(self) -> bool:
+        return not self.disallowed_paths
+
+    def provenance(self) -> dict[str, object]:
+        """Return a non-self-referential audit record for external retention.
+
+        The publication revision cannot be embedded in a file contained by
+        that same commit without changing the commit hash.  Final-audit output
+        or release metadata should retain this mapping instead.
+        """
+
+        return {
+            "report_publication_source_identity_schema": (
+                PUBLICATION_SOURCE_IDENTITY_SCHEMA
+            ),
+            "report_profile": self.profile,
+            "report_measured_source_revision": self.measured_revision,
+            "report_measured_source_tree": self.measured_tree,
+            "report_publication_revision": self.publication_revision,
+            "report_publication_tree": self.publication_tree,
+            "report_publication_report_only": self.eligible,
+            "report_publication_changed_paths": list(self.changed_paths),
+        }
+
+
+def inspect_report_source(repo_root: Path) -> ReportSourceIdentity:
+    """Inspect the current Git commit and fail-relevant working-tree changes."""
+
+    root = _require_repository_root(repo_root)
+    revision = _git_commit(root, "HEAD")
+    tree = _git_tree(root, revision)
+    changed = {
+        *_nul_paths(
+            _git_output(
+                root,
+                "diff",
+                "--name-only",
+                "--no-renames",
+                "-z",
+                "HEAD",
+                "--",
+            )
+        ),
+        *_nul_paths(
+            _git_output(
+                root,
+                "ls-files",
+                "--others",
+                "--exclude-standard",
+                "-z",
+                "--",
+            )
+        ),
+    }
+    dirty = tuple(
+        sorted(path for path in changed if not _generated_report_path(path))
+    )
+    return ReportSourceIdentity(revision, tree, dirty)
+
+
+def inspect_report_publication(
+    repo_root: Path,
+    *,
+    measured_revision: str,
+    profile: str,
+    publication_revision: str = "HEAD",
+) -> ReportPublicationIdentity:
+    """Inspect a publication commit descended from an exact measurement SHA."""
+
+    if (
+        not profile
+        or "/" in profile
+        or "\\" in profile
+        or profile in {".", ".."}
+        or ".." in profile
+    ):
+        raise ValueError("report profile must be one safe path component")
+    root = _require_repository_root(repo_root)
+    measured = _git_commit(root, measured_revision)
+    publication = _git_commit(root, publication_revision)
+    try:
+        ancestry = subprocess.run(
+            ("git", "merge-base", "--is-ancestor", measured, publication),
+            cwd=root,
+            check=False,
+            capture_output=True,
+            timeout=15,
+        )
+    except (OSError, subprocess.SubprocessError) as error:
+        raise ReportSourceIdentityError(
+            f"cannot authenticate report publication ancestry: {error}"
+        ) from error
+    if ancestry.returncode == 1:
+        raise ReportSourceIdentityError(
+            "publication commit is not a descendant of measured source "
+            f"{measured}"
+        )
+    if ancestry.returncode != 0:
+        detail = ancestry.stderr.decode("utf-8", errors="replace").strip()
+        raise ReportSourceIdentityError(
+            "cannot authenticate report publication ancestry: "
+            f"{detail or f'exit {ancestry.returncode}'}"
+        )
+    changes = _diff_changes(root, measured, publication)
+    changed = tuple(
+        sorted({path for _status, paths in changes for path in paths})
+    )
+    disallowed: set[str] = set()
+    for status, paths in changes:
+        if status not in {"A", "M"}:
+            disallowed.update(paths)
+            continue
+        path = paths[0]
+        if not _architecture_report_path(path, profile):
+            disallowed.add(path)
+            continue
+        old_mode = _git_path_mode(root, measured, path)
+        new_mode = _git_path_mode(root, publication, path)
+        if new_mode != "100644" or (
+            status == "M" and old_mode != "100644"
+        ):
+            disallowed.add(path)
+    return ReportPublicationIdentity(
+        profile=profile,
+        measured_revision=measured,
+        measured_tree=_git_tree(root, measured),
+        publication_revision=publication,
+        publication_tree=_git_tree(root, publication),
+        changed_paths=changed,
+        disallowed_paths=tuple(sorted(disallowed)),
+    )
+
+
+def require_eligible_report_source(repo_root: Path) -> ReportSourceIdentity:
+    """Return an exact source identity or reject a dirty measurement source."""
+
+    identity = inspect_report_source(repo_root)
+    if not identity.eligible:
+        displayed = ", ".join(identity.dirty_paths[:8])
+        if len(identity.dirty_paths) > 8:
+            displayed += f", ... ({len(identity.dirty_paths)} paths total)"
+        raise ReportSourceIdentityError(
+            "report measurements require a clean evaluator source checkout; "
+            f"dirty source paths: {displayed}"
+        )
+    return identity
+
+
+def require_report_only_publication(
+    repo_root: Path,
+    *,
+    measured_revision: str,
+    profile: str,
+    publication_revision: str = "HEAD",
+) -> ReportPublicationIdentity:
+    """Authenticate a descendant with only profile-publication changes."""
+
+    identity = inspect_report_publication(
+        repo_root,
+        measured_revision=measured_revision,
+        profile=profile,
+        publication_revision=publication_revision,
+    )
+    if not identity.eligible:
+        displayed = ", ".join(identity.disallowed_paths[:8])
+        if len(identity.disallowed_paths) > 8:
+            displayed += (
+                f", ... ({len(identity.disallowed_paths)} paths total)"
+            )
+        raise ReportSourceIdentityError(
+            "publication changed evaluator or non-profile source after "
+            f"measurement; disallowed paths: {displayed}"
+        )
+    return identity
+
+
+__all__ = [
+    "PUBLICATION_SOURCE_IDENTITY_SCHEMA",
+    "SOURCE_IDENTITY_SCHEMA",
+    "ReportPublicationIdentity",
+    "ReportSourceIdentity",
+    "ReportSourceIdentityError",
+    "inspect_report_publication",
+    "inspect_report_source",
+    "require_eligible_report_source",
+    "require_report_only_publication",
+]
diff --git a/pyamplicol/tools/performance_report/standalone_build.py b/pyamplicol/tools/performance_report/standalone_build.py
new file mode 100644
index 0000000000..55f52d6f6a
--- /dev/null
+++ b/pyamplicol/tools/performance_report/standalone_build.py
@@ -0,0 +1,123 @@
+# SPDX-License-Identifier: 0BSD
+"""Compile and verify an exported pyAmpliCol report using only its TeX folder."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+from collections.abc import Sequence
+from pathlib import Path
+from shutil import which
+
+
+class StandaloneBuildError(RuntimeError):
+    """The standalone publication could not be compiled or verified."""
+
+
+_UNRESOLVED_PATTERNS = (
+    re.compile(r"LaTeX Warning: Citation .* undefined"),
+    re.compile(r"LaTeX Warning: Reference .* undefined"),
+    re.compile(r"LaTeX Warning: There were undefined references"),
+    re.compile(r"Package rerunfilecheck Warning:"),
+)
+
+
+def validate_latex_log(
+    log: str,
+    *,
+    allow_overfull_boxes: bool = False,
+) -> None:
+    """Reject unresolved diagnostics and, by default, layout overflow.
+
+    Interactive report refreshes may explicitly tolerate overfull boxes while
+    a campaign is still being filled.  The stricter default remains useful for
+    release and final-layout audits.
+    """
+
+    if not allow_overfull_boxes and (
+        "Overfull \\hbox" in log or "Overfull \\vbox" in log
+    ):
+        raise StandaloneBuildError("LaTeX output contains an overfull box")
+    for pattern in _UNRESOLVED_PATTERNS:
+        if pattern.search(log):
+            raise StandaloneBuildError(
+                f"LaTeX output is unresolved: {pattern.pattern}"
+            )
+
+
+def compile_report(
+    report_dir: Path,
+    *,
+    engine: str = "pdflatex",
+    passes: int = 3,
+) -> Path:
+    """Compile ``pyAmpliCol.tex`` and reject unresolved or overflowing output."""
+
+    root = report_dir.expanduser().resolve(strict=True)
+    source = root / "pyAmpliCol.tex"
+    if not source.is_file():
+        raise StandaloneBuildError(f"missing report source: {source}")
+    if passes < 2:
+        raise StandaloneBuildError("at least two LaTeX passes are required")
+    executable = which(engine)
+    if executable is None:
+        raise StandaloneBuildError(f"LaTeX engine is not available: {engine}")
+
+    command = (
+        executable,
+        "-interaction=nonstopmode",
+        "-halt-on-error",
+        "-file-line-error",
+        source.name,
+    )
+    for _ in range(passes):
+        completed = subprocess.run(
+            command,
+            cwd=root,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if completed.returncode != 0:
+            detail = (completed.stdout + completed.stderr)[-4000:]
+            raise StandaloneBuildError(
+                f"LaTeX compilation failed with exit {completed.returncode}:\n"
+                f"{detail}"
+            )
+
+    log_path = root / "pyAmpliCol.log"
+    try:
+        log = log_path.read_text(encoding="utf-8", errors="replace")
+    except OSError as error:
+        raise StandaloneBuildError(f"cannot read LaTeX log: {error}") from error
+    validate_latex_log(log)
+
+    output = root / "pyAmpliCol.pdf"
+    if not output.is_file() or output.stat().st_size == 0:
+        raise StandaloneBuildError(f"LaTeX did not produce {output}")
+    return output
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Compile and verify this standalone pyAmpliCol report",
+    )
+    parser.add_argument("--engine", default="pdflatex")
+    parser.add_argument("--passes", type=int, default=3)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = _parser().parse_args(argv)
+    output = compile_report(
+        Path(__file__).resolve().parent,
+        engine=arguments.engine,
+        passes=arguments.passes,
+    )
+    print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/performance_report/study_contract.py b/pyamplicol/tools/performance_report/study_contract.py
new file mode 100644
index 0000000000..4dd3e16851
--- /dev/null
+++ b/pyamplicol/tools/performance_report/study_contract.py
@@ -0,0 +1,780 @@
+# SPDX-License-Identifier: 0BSD
+"""Authenticated contracts for narrowly scoped performance studies."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+from collections.abc import Mapping
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from .cache import validate_measurement
+from .campaign_policy import (
+    GENERATION_PHASE_EVIDENCE_ABI,
+    MACBOOK_M3_MEMORY_LIMIT_BYTES,
+    MACBOOK_M3_PROFILE,
+    MACBOOK_M3_Z_TABLE_F_GENERATION_LIMIT_SECONDS,
+    MACBOOK_M3_Z_TABLE_F_POLICY,
+    PolicyMeasurementState,
+    policy_status_label,
+    validate_policy_measurement,
+)
+from .catalog import REPORT_CATALOG
+from .models import Accuracy, ResultStatus, Workload
+from .publication import publication_measurement_matches_current
+from .resources import PROCESS_TREE_MEMORY_METRIC_ABI
+from .source_identity import require_eligible_report_source
+from .worker_harness import (
+    LEGACY_ADAPTER,
+    POLICY_ENTRYPOINT,
+    WorkerHarnessError,
+    require_worker_harness_identity,
+    worker_harness_identity,
+)
+
+if TYPE_CHECKING:
+    from .artifacts import ArtifactStore
+    from .service import ReportService
+
+Z_TABLE_F_STUDY_CONTRACT_SCHEMA = "pyamplicol-z-table-f-study-contract-v1"
+Z_TABLE_F_STUDY_ID = "macbook-m3-z-table-f"
+Z_TABLE_F_CONTRACT_MINIMUM_N = 8
+Z_TABLE_F_CELL_COUNT = 32
+Z_TABLE_F_PRIOR_EVIDENCE_ABI = (
+    "pyamplicol-z-table-f-prior-evidence-snapshot-v1"
+)
+Z_TABLE_F_PRIOR_CELL_COUNT = 112
+Z_TABLE_F_PRIOR_STATIC_NA_CELL_COUNT = 4
+Z_TABLE_F_SELECTION_ABI = "pyamplicol-explicit-single-cell-selection-v1"
+Z_TABLE_F_ATTEMPT_BINDING_ABI = (
+    "pyamplicol-z-table-f-attempt-binding-v1"
+)
+Z_TABLE_F_MEMORY_GUARD = (
+    "max(aggregate-process-tree-rss,darwin-physical-footprint)"
+)
+_SHA40 = frozenset("0123456789abcdef")
+_CONTRACT_FIELDS = frozenset(
+    {
+        "schema",
+        "study_id",
+        "campaign_policy",
+        "policy_profile",
+        "measured_source",
+        "policy_wrapper",
+        "allowed_cell_ids",
+        "selection_abi",
+        "memory_guard",
+        "generation_guard",
+        "retained_prior_evidence",
+        "sha256",
+    }
+)
+
+
+class StudyContractError(ValueError):
+    """A study contract is missing, stale, or internally inconsistent."""
+
+
+def _canonical_sha256(value: object) -> str:
+    return hashlib.sha256(
+        json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+
+
+def _git_value(root: Path, expression: str) -> str:
+    completed = subprocess.run(
+        ("git", "-C", os.fspath(root), "rev-parse", expression),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    value = completed.stdout.strip()
+    if (
+        completed.returncode != 0
+        or len(value) != 40
+        or any(character not in _SHA40 for character in value)
+    ):
+        detail = completed.stderr.strip() or f"exit {completed.returncode}"
+        raise StudyContractError(
+            f"cannot authenticate Git identity {expression!r}: {detail}"
+        )
+    return value
+
+
+def _clean_git_identity(root: Path) -> dict[str, str]:
+    resolved = root.expanduser().resolve(strict=True)
+    completed = subprocess.run(
+        (
+            "git",
+            "-C",
+            os.fspath(resolved),
+            "status",
+            "--porcelain=v1",
+            "--untracked-files=all",
+        ),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        raise StudyContractError(
+            "cannot inspect policy-wrapper worktree cleanliness"
+        )
+    if completed.stdout:
+        raise StudyContractError(
+            "policy-wrapper worktree must be clean before contract creation"
+        )
+    return {
+        "revision": _git_value(resolved, "HEAD^{commit}"),
+        "tree": _git_value(resolved, "HEAD^{tree}"),
+        "policy_entrypoint": POLICY_ENTRYPOINT,
+        "policy_entrypoint_sha256": _tracked_file_sha256(
+            resolved,
+            POLICY_ENTRYPOINT,
+        ),
+        "legacy_adapter": LEGACY_ADAPTER,
+        "legacy_adapter_sha256": _tracked_file_sha256(
+            resolved,
+            LEGACY_ADAPTER,
+        ),
+    }
+
+
+def _tracked_file_sha256(root: Path, relative_path: str) -> str:
+    """Hash one regular, tracked wrapper file without retaining its root."""
+
+    candidate = root / relative_path
+    try:
+        resolved = candidate.resolve(strict=True)
+        resolved.relative_to(root)
+    except (OSError, ValueError) as error:
+        raise StudyContractError(
+            f"policy-wrapper file is unavailable: {relative_path}"
+        ) from error
+    tracked = subprocess.run(
+        (
+            "git",
+            "-C",
+            os.fspath(root),
+            "ls-files",
+            "--error-unmatch",
+            "--",
+            relative_path,
+        ),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if (
+        tracked.returncode != 0
+        or candidate.is_symlink()
+        or not resolved.is_file()
+    ):
+        raise StudyContractError(
+            f"policy-wrapper file is not a tracked regular file: {relative_path}"
+        )
+    digest = hashlib.sha256()
+    with resolved.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def z_table_f_cell_ids() -> tuple[str, ...]:
+    """Return the exact newly supervised Z-table declaration scope."""
+
+    cell_ids = tuple(
+        sorted(
+            cell.cell_id
+            for cell in REPORT_CATALOG.measurement_cells()
+            if cell.dataset_id
+            in {
+                "z_builtin_sm",
+                "reference_amplicol_lc",
+            }
+            and cell.process_key == "dd_z_jets"
+            and Z_TABLE_F_CONTRACT_MINIMUM_N <= cell.n_final <= 9
+            and cell.measurement.accuracy is Accuracy.LC
+            and cell.workload
+            in {
+                Workload.SELECTED_FLOW,
+                Workload.ALL_FLOW,
+            }
+        )
+    )
+    if len(cell_ids) != Z_TABLE_F_CELL_COUNT:
+        raise StudyContractError(
+            "contracted Z-table n8-n9 catalog census is not exactly 32 cells"
+        )
+    return cell_ids
+
+
+def z_table_f_prior_cell_ids() -> tuple[str, ...]:
+    """Return the exact retained n1--n7 declaration scope for the Z table."""
+
+    cell_ids = tuple(
+        sorted(
+            cell.cell_id
+            for cell in REPORT_CATALOG.measurement_cells()
+            if cell.dataset_id
+            in {
+                "z_builtin_sm",
+                "reference_amplicol_lc",
+            }
+            and cell.process_key == "dd_z_jets"
+            and 1 <= cell.n_final < Z_TABLE_F_CONTRACT_MINIMUM_N
+            and cell.measurement.accuracy is Accuracy.LC
+            and cell.workload
+            in {
+                Workload.SELECTED_FLOW,
+                Workload.ALL_FLOW,
+            }
+        )
+    )
+    static_na_count = sum(
+        REPORT_CATALOG.static_na_reason(REPORT_CATALOG.cell(cell_id))
+        is not None
+        for cell_id in cell_ids
+    )
+    if (
+        len(cell_ids) != Z_TABLE_F_PRIOR_CELL_COUNT
+        or static_na_count != Z_TABLE_F_PRIOR_STATIC_NA_CELL_COUNT
+    ):
+        raise StudyContractError(
+            "retained Z-table n1-n7 catalog census differs from the "
+            "authenticated contract"
+        )
+    return cell_ids
+
+
+def _prior_evidence_snapshot(
+    store: ArtifactStore | None,
+) -> dict[str, object]:
+    """Digest retained Z-table currents without embedding path-dependent data."""
+
+    entries: list[dict[str, object]] = []
+    current_count = 0
+    cell_ids = z_table_f_prior_cell_ids()
+    static_na_cell_ids = tuple(
+        cell_id
+        for cell_id in cell_ids
+        if REPORT_CATALOG.static_na_reason(REPORT_CATALOG.cell(cell_id))
+        is not None
+    )
+    for cell_id in cell_ids:
+        cell = REPORT_CATALOG.cell(cell_id)
+        current = (
+            None
+            if store is None
+            else store.load_current(cell.cell_id, missing_ok=True)
+        )
+        if current is None:
+            entries.append(
+                {
+                    "cell_id": cell.cell_id,
+                    "attempt_id": None,
+                    "manifest_sha256": None,
+                    "result_sha256": None,
+                    "provenance_sha256": None,
+                }
+            )
+            continue
+        provenance = current.result.get("provenance")
+        if (
+            isinstance(provenance, Mapping)
+            and "study_contract" in provenance
+        ):
+            raise StudyContractError(
+                f"pre-study cell {cell.cell_id!r} already has an F binding"
+            )
+        current_count += 1
+        entries.append(
+            {
+                "cell_id": cell.cell_id,
+                "attempt_id": current.attempt_id,
+                "manifest_sha256": current.manifest_sha256,
+                "result_sha256": _canonical_sha256(current.result),
+                "provenance_sha256": _canonical_sha256(provenance),
+            }
+        )
+    return {
+        "abi": Z_TABLE_F_PRIOR_EVIDENCE_ABI,
+        "maximum_n_final": Z_TABLE_F_CONTRACT_MINIMUM_N - 1,
+        "cell_ids": list(cell_ids),
+        "static_na_cell_ids": list(static_na_cell_ids),
+        "declared_cell_count": len(entries),
+        "static_na_cell_count": len(static_na_cell_ids),
+        "current_cell_count": current_count,
+        "snapshot_sha256": _canonical_sha256(entries),
+    }
+
+
+def create_z_table_f_study_contract(
+    measured_root: Path,
+    policy_wrapper_root: Path,
+    *,
+    prior_store: ArtifactStore | None = None,
+) -> dict[str, object]:
+    """Create a digest-bound contract from two clean, separate Git identities."""
+
+    source = require_eligible_report_source(
+        measured_root.expanduser().resolve(strict=True)
+    )
+    wrapper = _clean_git_identity(policy_wrapper_root)
+    body: dict[str, object] = {
+        "schema": Z_TABLE_F_STUDY_CONTRACT_SCHEMA,
+        "study_id": Z_TABLE_F_STUDY_ID,
+        "campaign_policy": MACBOOK_M3_Z_TABLE_F_POLICY.as_manifest(),
+        "policy_profile": MACBOOK_M3_PROFILE,
+        "measured_source": {
+            "revision": source.revision,
+            "tree": source.tree,
+        },
+        "policy_wrapper": wrapper,
+        "allowed_cell_ids": list(z_table_f_cell_ids()),
+        "selection_abi": Z_TABLE_F_SELECTION_ABI,
+        "memory_guard": {
+            "metric_abi": PROCESS_TREE_MEMORY_METRIC_ABI,
+            "metric": Z_TABLE_F_MEMORY_GUARD,
+            "limit_bytes": MACBOOK_M3_MEMORY_LIMIT_BYTES,
+        },
+        "generation_guard": {
+            "evidence_abi": GENERATION_PHASE_EVIDENCE_ABI,
+            "limit_seconds": (
+                MACBOOK_M3_Z_TABLE_F_GENERATION_LIMIT_SECONDS
+            ),
+            "scope": "every legacy, selected-flow, and all-flow generation",
+        },
+        "retained_prior_evidence": {
+            "n_final": list(range(1, Z_TABLE_F_CONTRACT_MINIMUM_N)),
+            "snapshot": _prior_evidence_snapshot(prior_store),
+            "treatment": (
+                "outside this contract; retain each original attempt, "
+                "provenance record, and resource ABI unchanged"
+            ),
+            "memory_guard_interpretation": (
+                "legacy RSS-only evidence remains legacy and is not "
+                "relabeled as Darwin physical-footprint or exact-decimal-"
+                "30GB evidence"
+            ),
+        },
+    }
+    return {**body, "sha256": _canonical_sha256(body)}
+
+
+def z_table_f_worker_harness_identity(
+    contract: Mapping[str, object],
+) -> dict[str, object]:
+    """Derive the exact relocation-safe worker identity from one contract."""
+
+    wrapper = contract.get("policy_wrapper")
+    source = contract.get("measured_source")
+    if not isinstance(wrapper, Mapping) or not isinstance(source, Mapping):
+        raise StudyContractError(
+            "study contract worker identities are missing"
+        )
+    try:
+        return worker_harness_identity(
+            study_contract_sha256=str(contract["sha256"]),
+            policy_wrapper_revision=str(wrapper["revision"]),
+            policy_wrapper_tree=str(wrapper["tree"]),
+            policy_entrypoint_sha256=str(
+                wrapper["policy_entrypoint_sha256"]
+            ),
+            legacy_adapter_sha256=str(
+                wrapper["legacy_adapter_sha256"]
+            ),
+            measured_source_revision=str(source["revision"]),
+            measured_source_tree=str(source["tree"]),
+        )
+    except (KeyError, WorkerHarnessError) as error:
+        raise StudyContractError(
+            "study contract worker identities are invalid"
+        ) from error
+
+
+def write_z_table_f_study_contract(
+    path: Path,
+    measured_root: Path,
+    policy_wrapper_root: Path,
+    *,
+    prior_store: ArtifactStore | None = None,
+) -> dict[str, object]:
+    """Write a new contract without overwriting prior study evidence."""
+
+    destination = path.expanduser().resolve(strict=False)
+    if destination.exists() or destination.is_symlink():
+        raise StudyContractError(
+            f"study contract already exists: {destination}"
+        )
+    payload = create_z_table_f_study_contract(
+        measured_root,
+        policy_wrapper_root,
+        prior_store=prior_store,
+    )
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = destination.with_name(f".{destination.name}.new")
+    temporary.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="ascii",
+    )
+    os.replace(temporary, destination)
+    return payload
+
+
+def load_z_table_f_study_contract(
+    path: Path,
+    measured_root: Path,
+    policy_wrapper_root: Path,
+    *,
+    prior_store: ArtifactStore | None = None,
+) -> dict[str, object]:
+    """Load a contract and reauthenticate both source and wrapper identities."""
+
+    try:
+        raw = json.loads(
+            path.expanduser().resolve(strict=True).read_text(
+                encoding="ascii"
+            )
+        )
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise StudyContractError(
+            f"cannot read Z-table study contract: {error}"
+        ) from error
+    if not isinstance(raw, dict):
+        raise StudyContractError("Z-table study contract fields are invalid")
+    return authenticate_z_table_f_study_contract(
+        raw,
+        measured_root,
+        policy_wrapper_root,
+        prior_store=prior_store,
+    )
+
+
+def authenticate_z_table_f_study_contract(
+    contract: Mapping[str, object],
+    measured_root: Path,
+    policy_wrapper_root: Path,
+    *,
+    prior_store: ArtifactStore | None = None,
+) -> dict[str, object]:
+    """Reauthenticate a loaded contract against both roots and prior currents."""
+
+    if (
+        not isinstance(contract, Mapping)
+        or set(contract) != _CONTRACT_FIELDS
+    ):
+        raise StudyContractError("Z-table study contract fields are invalid")
+    body = {
+        key: value
+        for key, value in contract.items()
+        if key != "sha256"
+    }
+    if contract.get("sha256") != _canonical_sha256(body):
+        raise StudyContractError("Z-table study contract digest differs")
+    expected = create_z_table_f_study_contract(
+        measured_root,
+        policy_wrapper_root,
+        prior_store=prior_store,
+    )
+    if dict(contract) != expected:
+        if contract.get("retained_prior_evidence") != expected.get(
+            "retained_prior_evidence"
+        ):
+            raise StudyContractError(
+                "Z-table study contract retained prior evidence differs"
+            )
+        raise StudyContractError(
+            "Z-table study contract differs from active source or policy"
+        )
+    return expected
+
+
+def require_z_table_f_explicit_cell(
+    contract: Mapping[str, object],
+    cell_id: str,
+) -> None:
+    """Reject broad selectors and any cell outside the dedicated Z table."""
+
+    allowed = contract.get("allowed_cell_ids")
+    if (
+        not isinstance(cell_id, str)
+        or not cell_id
+        or not isinstance(allowed, list)
+        or cell_id not in allowed
+    ):
+        raise StudyContractError(
+            f"cell {cell_id!r} is outside the authenticated Z-table scope"
+        )
+
+
+def z_table_f_attempt_binding(
+    study_contract_sha256: str,
+) -> dict[str, str]:
+    """Return the exact provenance record for one contracted attempt."""
+
+    if (
+        len(study_contract_sha256) != 64
+        or any(character not in _SHA40 for character in study_contract_sha256)
+    ):
+        raise StudyContractError("study contract SHA-256 is invalid")
+    return {
+        "abi": Z_TABLE_F_ATTEMPT_BINDING_ABI,
+        "study_id": Z_TABLE_F_STUDY_ID,
+        "study_contract_sha256": study_contract_sha256,
+    }
+
+
+def bind_z_table_f_attempt(
+    measurement: dict[str, object],
+    study_contract_sha256: str,
+) -> None:
+    """Bind a scheduler-produced attempt result to its study contract."""
+
+    expected = z_table_f_attempt_binding(study_contract_sha256)
+    provenance = measurement.get("provenance")
+    if provenance is not None and not isinstance(provenance, Mapping):
+        raise StudyContractError("measurement provenance is invalid")
+    active = (
+        provenance.get("study_contract")
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    if active is not None and active != expected:
+        raise StudyContractError(
+            "measurement is already bound to a different study contract"
+        )
+    measurement["provenance"] = {
+        **({} if provenance is None else dict(provenance)),
+        "study_contract": expected,
+    }
+
+
+def require_z_table_f_attempt_binding(
+    measurement: Mapping[str, object],
+    study_contract_sha256: str,
+) -> None:
+    """Reject a current or publication transplanted from another study."""
+
+    provenance = measurement.get("provenance")
+    active = (
+        provenance.get("study_contract")
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    if active != z_table_f_attempt_binding(study_contract_sha256):
+        raise StudyContractError(
+            "measurement is not bound to the active study contract"
+        )
+
+
+def audit_z_table_f_policy_projection(
+    contract: Mapping[str, object],
+    service: ReportService,
+    *,
+    maximum_n: int,
+) -> dict[str, object]:
+    """Audit current-to-publication policy identity for a completed Z tier."""
+
+    if set(contract) != _CONTRACT_FIELDS:
+        raise StudyContractError("study contract fields are invalid")
+    contract_body = {
+        key: value
+        for key, value in contract.items()
+        if key != "sha256"
+    }
+    if contract.get("sha256") != _canonical_sha256(contract_body):
+        raise StudyContractError("study contract digest differs")
+    if maximum_n < Z_TABLE_F_CONTRACT_MINIMUM_N or maximum_n > 9:
+        raise StudyContractError(
+            "maximum_n must be between 8 and 9 for contracted evidence"
+        )
+    source = contract.get("measured_source")
+    if not isinstance(source, Mapping):
+        raise StudyContractError("study contract source identity is missing")
+    revision = source.get("revision")
+    tree = source.get("tree")
+    if not isinstance(revision, str) or not isinstance(tree, str):
+        raise StudyContractError("study contract source identity is invalid")
+    contract_sha256 = contract.get("sha256")
+    if not isinstance(contract_sha256, str):
+        raise StudyContractError("study contract digest is invalid")
+    z_table_f_attempt_binding(contract_sha256)
+    expected_worker_harness = z_table_f_worker_harness_identity(contract)
+    retained = contract.get("retained_prior_evidence")
+    if not isinstance(retained, Mapping) or retained.get(
+        "snapshot"
+    ) != _prior_evidence_snapshot(service.store):
+        raise StudyContractError(
+            "pre-study n1-n7 current/provenance snapshot differs"
+        )
+
+    allowed = contract.get("allowed_cell_ids")
+    if allowed != list(z_table_f_cell_ids()):
+        raise StudyContractError("study contract cell scope is invalid")
+    assert isinstance(allowed, list)
+    allowed_ids = frozenset(str(value) for value in allowed)
+    cells = tuple(
+        cell
+        for cell in REPORT_CATALOG.measurement_cells()
+        if cell.cell_id in allowed_ids and cell.n_final <= maximum_n
+    )
+    if not cells:
+        raise StudyContractError("study contract selects no audit cells")
+
+    published_by_cell: dict[str, Mapping[str, object]] = {}
+    for payload in service.load_caches().values():
+        entries = payload.get("entries")
+        if not isinstance(entries, list):
+            continue
+        for entry in entries:
+            if not isinstance(entry, Mapping):
+                continue
+            cell_id = entry.get("cell_id")
+            measurement = entry.get("measurement")
+            if isinstance(cell_id, str) and isinstance(
+                measurement,
+                Mapping,
+            ):
+                published_by_cell[cell_id] = measurement
+
+    errors: list[str] = []
+    states: dict[str, int] = {}
+    static_na = 0
+    for cell in cells:
+        published = published_by_cell.get(cell.cell_id)
+        if published is None:
+            errors.append(f"{cell.cell_id}: publication entry is missing")
+            continue
+        static_reason = REPORT_CATALOG.static_na_reason(cell)
+        if static_reason is not None:
+            static_na += 1
+            if published.get("status") != ResultStatus.NOT_AVAILABLE.value:
+                errors.append(
+                    f"{cell.cell_id}: static N/A publication was overwritten"
+                )
+            continue
+
+        current = service.store.load_current(
+            cell.cell_id,
+            missing_ok=True,
+        )
+        if current is None:
+            errors.append(f"{cell.cell_id}: authenticated current is missing")
+            continue
+        try:
+            validate_measurement(current.result, expected_cell=cell)
+            validate_measurement(published, expected_cell=cell)
+            require_z_table_f_attempt_binding(
+                current.result,
+                contract_sha256,
+            )
+            require_z_table_f_attempt_binding(
+                published,
+                contract_sha256,
+            )
+            require_worker_harness_identity(
+                current.result,
+                expected=expected_worker_harness,
+            )
+            require_worker_harness_identity(
+                published,
+                expected=expected_worker_harness,
+            )
+            current_state = validate_policy_measurement(
+                MACBOOK_M3_Z_TABLE_F_POLICY,
+                MACBOOK_M3_PROFILE,
+                cell,
+                current.result,
+                expected_source_revision=revision,
+                expected_source_tree=tree,
+            )
+            published_state = validate_policy_measurement(
+                MACBOOK_M3_Z_TABLE_F_POLICY,
+                MACBOOK_M3_PROFILE,
+                cell,
+                published,
+                expected_source_revision=revision,
+                expected_source_tree=tree,
+            )
+            if current_state is not published_state:
+                raise StudyContractError(
+                    "current and publication policy states differ"
+                )
+            if not publication_measurement_matches_current(
+                published,
+                current.result,
+                service.paths,
+            ):
+                raise StudyContractError(
+                    "publication is not the portable current projection"
+                )
+            expected_label = {
+                PolicyMeasurementState.GENERATION_LIMIT: ">1h",
+                PolicyMeasurementState.MEMORY_LIMIT: ">30GB",
+            }.get(current_state)
+            if (
+                expected_label is not None
+                and policy_status_label(published) != expected_label
+            ):
+                raise StudyContractError(
+                    f"terminal label is not {expected_label}"
+                )
+        except (OSError, TypeError, ValueError) as error:
+            errors.append(f"{cell.cell_id}: {error}")
+            continue
+        states[current_state.value] = states.get(current_state.value, 0) + 1
+
+    if errors:
+        preview = "; ".join(errors[:20])
+        raise StudyContractError(
+            f"Z-table policy projection audit failed: {preview}"
+        )
+    return {
+        "schema": "pyamplicol-z-table-f-policy-audit-v1",
+        "status": "ok",
+        "study_contract_sha256": contract_sha256,
+        "campaign_policy": MACBOOK_M3_Z_TABLE_F_POLICY.as_manifest(),
+        "policy_profile": MACBOOK_M3_PROFILE,
+        "measured_source": dict(source),
+        "maximum_n": maximum_n,
+        "declared_cell_count": len(cells),
+        "static_na_cell_count": static_na,
+        "policy_state_counts": dict(sorted(states.items())),
+    }
+
+
+__all__ = [
+    "Z_TABLE_F_ATTEMPT_BINDING_ABI",
+    "Z_TABLE_F_CELL_COUNT",
+    "Z_TABLE_F_CONTRACT_MINIMUM_N",
+    "Z_TABLE_F_MEMORY_GUARD",
+    "Z_TABLE_F_PRIOR_CELL_COUNT",
+    "Z_TABLE_F_PRIOR_EVIDENCE_ABI",
+    "Z_TABLE_F_PRIOR_STATIC_NA_CELL_COUNT",
+    "Z_TABLE_F_SELECTION_ABI",
+    "Z_TABLE_F_STUDY_CONTRACT_SCHEMA",
+    "Z_TABLE_F_STUDY_ID",
+    "StudyContractError",
+    "audit_z_table_f_policy_projection",
+    "authenticate_z_table_f_study_contract",
+    "bind_z_table_f_attempt",
+    "create_z_table_f_study_contract",
+    "load_z_table_f_study_contract",
+    "require_z_table_f_attempt_binding",
+    "require_z_table_f_explicit_cell",
+    "write_z_table_f_study_contract",
+    "z_table_f_attempt_binding",
+    "z_table_f_cell_ids",
+    "z_table_f_prior_cell_ids",
+    "z_table_f_worker_harness_identity",
+]
diff --git a/pyamplicol/tools/performance_report/timing.py b/pyamplicol/tools/performance_report/timing.py
new file mode 100644
index 0000000000..2386d807b2
--- /dev/null
+++ b/pyamplicol/tools/performance_report/timing.py
@@ -0,0 +1,346 @@
+# SPDX-License-Identifier: 0BSD
+"""Authenticated native execution-timing metadata shared by report views."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping
+
+from .arena_profile import (
+    ARENA_PHASE_TIMING_SCOPE,
+    ARENA_PROFILE_BOUNDARY,
+    ARENA_PROFILE_PROTOCOL,
+    ARENA_PROFILE_SAMPLE_PASS,
+    PAIRED_TIMING_SAMPLE_CONTRACT,
+    ArenaProfileEvidenceError,
+    digest_arena_profile_value,
+    validate_arena_profile_evidence,
+)
+
+MEASURED_EXECUTION_TIMING_ABI = "pyamplicol-report-execution-timing-v1"
+ARENA_UNAVAILABLE_EXECUTION_TIMING_ABI = (
+    "pyamplicol-report-arena-execution-timing-v2"
+)
+EXECUTION_TIMING_KEY = "execution_timing"
+EVALUATOR_TOTAL_TIMING_ABI = "pyamplicol-report-evaluator-total-timing-v1"
+EVALUATOR_TOTAL_TIMING_KEY = "evaluator_total_timing"
+EVALUATOR_TOTAL_TIMING_SOURCE = (
+    "runtime._benchmark_f64_wall_time.accumulated"
+)
+EVALUATOR_TOTAL_TIMING_SOURCES = frozenset(
+    {
+        EVALUATOR_TOTAL_TIMING_SOURCE,
+        "runtime.evaluate.accumulated",
+    }
+)
+EVALUATOR_TOTAL_SAMPLE_CONTRACT = (
+    "accumulated-repeated-warmed-evaluator-total-v1"
+)
+RECURRENCE_EXECUTION_TIMING_SOURCE = (
+    "runtime_profile_core_recurrence_schedule_time"
+)
+UNAVAILABLE_STATUS = "unavailable"
+ARENA_UNAVAILABLE_EXECUTION_TIMING_FIELDS = frozenset(
+    {
+        "abi",
+        "status",
+        "ratio_eligible",
+        "raw_seconds_per_point",
+        "sample_count",
+        "native_profile_points_per_sample",
+        "repetitions_per_sample",
+        "batch_size",
+        "sample_contract",
+        "profile_protocol",
+        "profile_sample_pass",
+        "profile_boundary",
+        "borrowed_flat_input",
+        "preallocated_output",
+        "phase_timing_scope",
+        "evaluator_timing_available",
+        "paired_with_headline",
+        "identical_batch",
+        "identical_repetitions",
+        "execution_mode",
+        "warmed_boundary_wall_seconds_per_point",
+        "arena_profile_evidence_sha256",
+    }
+)
+EVALUATOR_TOTAL_TIMING_FIELDS = frozenset(
+    {
+        "abi",
+        "status",
+        "ratio_eligible",
+        "raw_seconds_per_point",
+        "source",
+        "execution_mode",
+        "sample_contract",
+        "sample_count",
+        "repetitions_per_sample",
+        "batch_size",
+        "points_per_sample",
+        "measured_point_count",
+        "accumulated_seconds",
+    }
+)
+RECURRENCE_CORE_TIMING_FIELDS = frozenset(
+    {
+        "abi",
+        "status",
+        "ratio_eligible",
+        "raw_seconds_per_point",
+        "source",
+        "compiled_direct_arena_active",
+        "sample_count",
+        "native_profile_points_per_sample",
+        "sample_contract",
+    }
+)
+
+
+def recurrence_core_timing_record(
+    measurement: Mapping[str, object],
+) -> Mapping[str, object] | None:
+    """Return an authenticated narrow recurrence-core timing record."""
+
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        return None
+    record = provenance.get(EXECUTION_TIMING_KEY)
+    if not isinstance(record, Mapping):
+        return None
+    raw = record.get("raw_seconds_per_point")
+    sample_count = record.get("sample_count")
+    native_points = record.get("native_profile_points_per_sample")
+    if (
+        measurement.get("status") not in {"ok", "unverified"}
+        or set(record) != RECURRENCE_CORE_TIMING_FIELDS
+        or record.get("abi") != MEASURED_EXECUTION_TIMING_ABI
+        or record.get("status") != "measured"
+        or record.get("ratio_eligible") is not True
+        or record.get("source") != RECURRENCE_EXECUTION_TIMING_SOURCE
+        or record.get("compiled_direct_arena_active") is not False
+        or record.get("sample_contract") != PAIRED_TIMING_SAMPLE_CONTRACT
+        or isinstance(raw, bool)
+        or not isinstance(raw, (int, float))
+        or not math.isfinite(float(raw))
+        or float(raw) <= 0.0
+        or measurement.get("execution_seconds_per_point") != raw
+        or isinstance(sample_count, bool)
+        or not isinstance(sample_count, int)
+        or sample_count < 1
+        or measurement.get("sample_count") != sample_count
+        or isinstance(native_points, bool)
+        or not isinstance(native_points, int)
+        or native_points < 1
+    ):
+        return None
+    return record
+
+
+def evaluator_total_timing_record(
+    measurement: Mapping[str, object],
+) -> Mapping[str, object] | None:
+    """Return an authenticated accumulated warmed evaluator-total record."""
+
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        return None
+    record = provenance.get(EVALUATOR_TOTAL_TIMING_KEY)
+    if not isinstance(record, Mapping):
+        return None
+    raw = record.get("raw_seconds_per_point")
+    accumulated = record.get("accumulated_seconds")
+    sample_count = record.get("sample_count")
+    repetitions = record.get("repetitions_per_sample")
+    batch_size = record.get("batch_size")
+    points_per_sample = record.get("points_per_sample")
+    measured_points = record.get("measured_point_count")
+    if (
+        measurement.get("status") not in {"ok", "unverified"}
+        or set(record) != EVALUATOR_TOTAL_TIMING_FIELDS
+        or record.get("abi") != EVALUATOR_TOTAL_TIMING_ABI
+        or record.get("status") != "measured"
+        or record.get("ratio_eligible") is not False
+        or record.get("source") not in EVALUATOR_TOTAL_TIMING_SOURCES
+        or record.get("execution_mode") not in {
+            "compiled",
+            "eager",
+            "recurrence",
+            "on-the-fly",
+        }
+        or record.get("sample_contract") != EVALUATOR_TOTAL_SAMPLE_CONTRACT
+        or isinstance(sample_count, bool)
+        or not isinstance(sample_count, int)
+        or sample_count < 1
+        or measurement.get("sample_count") != sample_count
+        or isinstance(repetitions, bool)
+        or not isinstance(repetitions, int)
+        or repetitions < 1
+        or isinstance(batch_size, bool)
+        or not isinstance(batch_size, int)
+        or batch_size < 1
+        or isinstance(points_per_sample, bool)
+        or not isinstance(points_per_sample, int)
+        or points_per_sample != repetitions * batch_size
+        or isinstance(measured_points, bool)
+        or not isinstance(measured_points, int)
+        or measured_points != sample_count * points_per_sample
+        or isinstance(accumulated, bool)
+        or not isinstance(accumulated, (int, float))
+        or not math.isfinite(float(accumulated))
+        or float(accumulated) <= 0.0
+        or isinstance(raw, bool)
+        or not isinstance(raw, (int, float))
+        or not math.isfinite(float(raw))
+        or float(raw) <= 0.0
+        or not math.isclose(
+            float(raw),
+            float(accumulated) / measured_points,
+            rel_tol=1.0e-15,
+            abs_tol=0.0,
+        )
+    ):
+        return None
+    return record
+
+
+def evaluator_total_seconds_per_point(
+    measurement: Mapping[str, object],
+) -> float | None:
+    """Return only a dedicated authenticated accumulated evaluator total."""
+
+    record = evaluator_total_timing_record(measurement)
+    if record is None:
+        return None
+    return float(record["raw_seconds_per_point"])
+
+
+def recurrence_core_seconds_per_point(
+    measurement: Mapping[str, object],
+) -> float | None:
+    """Return the independent narrow recurrence-core attribution."""
+
+    record = recurrence_core_timing_record(measurement)
+    if record is None:
+        return None
+    return float(record["raw_seconds_per_point"])
+
+
+def unavailable_execution_timing_record(
+    measurement: Mapping[str, object],
+    field: str,
+) -> Mapping[str, object] | None:
+    """Return an authenticated Arena record for an unexposed timing field."""
+
+    if field != "execution_seconds_per_point":
+        return None
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        return None
+    record = provenance.get(EXECUTION_TIMING_KEY)
+    if not isinstance(record, Mapping):
+        return None
+    raw = record.get("raw_seconds_per_point")
+    sample_count = record.get("sample_count")
+    native_points = record.get("native_profile_points_per_sample")
+    repetitions = record.get("repetitions_per_sample")
+    batch_size = record.get("batch_size")
+    warmed_wall = record.get("warmed_boundary_wall_seconds_per_point")
+    execution_mode = record.get("execution_mode")
+    evidence = provenance.get("arena_profile_evidence")
+    evidence_digest = record.get("arena_profile_evidence_sha256")
+    evidence_valid = False
+    if (
+        isinstance(execution_mode, str)
+        and isinstance(sample_count, int)
+        and not isinstance(sample_count, bool)
+        and isinstance(native_points, int)
+        and not isinstance(native_points, bool)
+        and isinstance(evidence_digest, str)
+    ):
+        try:
+            validate_arena_profile_evidence(
+                evidence,
+                execution_mode=execution_mode,
+                sample_count=sample_count,
+                native_profile_points_per_sample=native_points,
+            )
+        except ArenaProfileEvidenceError:
+            pass
+        else:
+            evidence_valid = (
+                digest_arena_profile_value(evidence) == evidence_digest
+                and isinstance(evidence, Mapping)
+                and evidence.get("repetitions_per_profile") == repetitions
+                and evidence.get("batch_size") == batch_size
+                and evidence.get("warmed_boundary_wall_seconds_per_point")
+                == warmed_wall
+            )
+    if (
+        set(record) != ARENA_UNAVAILABLE_EXECUTION_TIMING_FIELDS
+        or record.get("abi") != ARENA_UNAVAILABLE_EXECUTION_TIMING_ABI
+        or record.get("status") != UNAVAILABLE_STATUS
+        or record.get("ratio_eligible") is not False
+        or raw is not None
+        or isinstance(sample_count, bool)
+        or not isinstance(sample_count, int)
+        or sample_count < 1
+        or isinstance(native_points, bool)
+        or not isinstance(native_points, int)
+        or native_points < 1
+        or isinstance(repetitions, bool)
+        or not isinstance(repetitions, int)
+        or repetitions < 1
+        or isinstance(batch_size, bool)
+        or not isinstance(batch_size, int)
+        or batch_size < 1
+        or repetitions * batch_size != native_points
+        or record.get("sample_contract") != PAIRED_TIMING_SAMPLE_CONTRACT
+        or record.get("profile_protocol") != ARENA_PROFILE_PROTOCOL
+        or record.get("profile_sample_pass") != ARENA_PROFILE_SAMPLE_PASS
+        or record.get("profile_boundary") != ARENA_PROFILE_BOUNDARY
+        or record.get("borrowed_flat_input") is not True
+        or record.get("preallocated_output") is not True
+        or record.get("phase_timing_scope") != ARENA_PHASE_TIMING_SCOPE
+        or record.get("evaluator_timing_available") is not False
+        or record.get("paired_with_headline") is not True
+        or record.get("identical_batch") is not True
+        or record.get("identical_repetitions") is not True
+        or execution_mode not in {"compiled", "eager"}
+        or isinstance(warmed_wall, bool)
+        or not isinstance(warmed_wall, (int, float))
+        or not math.isfinite(float(warmed_wall))
+        or float(warmed_wall) <= 0.0
+        or not evidence_valid
+        or measurement.get(field) is not None
+    ):
+        return None
+    return record
+
+
+__all__ = [
+    "ARENA_PHASE_TIMING_SCOPE",
+    "ARENA_PROFILE_BOUNDARY",
+    "ARENA_PROFILE_PROTOCOL",
+    "ARENA_PROFILE_SAMPLE_PASS",
+    "ARENA_UNAVAILABLE_EXECUTION_TIMING_ABI",
+    "ARENA_UNAVAILABLE_EXECUTION_TIMING_FIELDS",
+    "EVALUATOR_TOTAL_SAMPLE_CONTRACT",
+    "EVALUATOR_TOTAL_TIMING_ABI",
+    "EVALUATOR_TOTAL_TIMING_FIELDS",
+    "EVALUATOR_TOTAL_TIMING_KEY",
+    "EVALUATOR_TOTAL_TIMING_SOURCE",
+    "EVALUATOR_TOTAL_TIMING_SOURCES",
+    "EXECUTION_TIMING_KEY",
+    "MEASURED_EXECUTION_TIMING_ABI",
+    "PAIRED_TIMING_SAMPLE_CONTRACT",
+    "RECURRENCE_CORE_TIMING_FIELDS",
+    "RECURRENCE_EXECUTION_TIMING_SOURCE",
+    "UNAVAILABLE_STATUS",
+    "evaluator_total_seconds_per_point",
+    "evaluator_total_timing_record",
+    "recurrence_core_seconds_per_point",
+    "recurrence_core_timing_record",
+    "unavailable_execution_timing_record",
+]
diff --git a/pyamplicol/tools/performance_report/validation_summary.py b/pyamplicol/tools/performance_report/validation_summary.py
new file mode 100644
index 0000000000..551fdd9e0d
--- /dev/null
+++ b/pyamplicol/tools/performance_report/validation_summary.py
@@ -0,0 +1,550 @@
+# SPDX-License-Identifier: 0BSD
+"""Publication-facing numerical-validation coverage for the report."""
+
+from __future__ import annotations
+
+import math
+from collections import Counter
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+
+from .agreements import (
+    DIRECT_AGREEMENT_FIELD,
+    INDEPENDENT_AUTHORITY_FIELD,
+    LC_LEGACY_PYAMPLICOL_COMPONENT,
+    MADGRAPH_COMPARISON_FIELD,
+)
+from .campaign_policy import policy_status_label
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .display_contract import report_display_accounting
+from .models import CellSpec, ExecutionMode, ResultStatus
+
+Measurement = Mapping[str, object]
+CachePayload = Mapping[str, object]
+
+SUMMARY_TABLE_NAME = "result_validation_summary.tex"
+MAX_PUBLICATION_MULTIPLICITY = 9
+
+
+def _number(record: Mapping[str, object], field: str) -> float | None:
+    value = record.get(field)
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    result = float(value)
+    return result if math.isfinite(result) and result >= 0.0 else None
+
+
+def _maximum(records: Iterable[Mapping[str, object]], field: str) -> float | None:
+    values = tuple(
+        value for record in records if (value := _number(record, field)) is not None
+    )
+    return max(values) if values else None
+
+
+def _validation_record(
+    measurement: Measurement,
+    name: str,
+) -> Mapping[str, object] | None:
+    validation = measurement.get("validation")
+    if not isinstance(validation, Mapping):
+        return None
+    record = validation.get(name)
+    return record if isinstance(record, Mapping) else None
+
+
+def _successful(measurement: Measurement) -> bool:
+    validation = measurement.get("validation")
+    return (
+        measurement.get("status") == ResultStatus.OK.value
+        and isinstance(validation, Mapping)
+        and validation.get("status") == ResultStatus.OK.value
+    )
+
+
+def _source_revision(measurement: Measurement) -> str | None:
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        return None
+    for field in (
+        "report_measured_source_revision",
+        "report_source_revision",
+        "source_revision",
+    ):
+        value = provenance.get(field)
+        if isinstance(value, str) and value and value != "unknown":
+            return value
+    return None
+
+
+def _cell_measurements(
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+) -> dict[str, Measurement]:
+    payloads = caches.values() if isinstance(caches, Mapping) else caches
+    result: dict[str, Measurement] = {}
+    for payload in payloads:
+        entries = payload.get("entries")
+        if not isinstance(entries, list):
+            raise ValueError("report cache has no entries list")
+        for entry in entries:
+            if not isinstance(entry, Mapping):
+                raise ValueError("report cache contains a non-object entry")
+            cell_id = entry.get("cell_id")
+            measurement = entry.get("measurement")
+            if not isinstance(cell_id, str) or not isinstance(measurement, Mapping):
+                raise ValueError("report cache entry is missing its measurement")
+            if cell_id in result:
+                raise ValueError(f"duplicate report cell {cell_id!r}")
+            result[cell_id] = measurement
+    return result
+
+
+@dataclass(frozen=True, slots=True)
+class ValidationSummary:
+    """Numerical evidence across the complete declared publication range."""
+
+    declared_by_n: tuple[tuple[int, int], ...]
+    expected_by_n: tuple[tuple[int, int], ...]
+    static_na_by_n: tuple[tuple[int, int], ...]
+    passed_by_n: tuple[tuple[int, int], ...]
+    policy_terminal_by_n: tuple[tuple[int, int], ...]
+    status_counts: tuple[tuple[str, int], ...]
+    madgraph_reference_count: int
+    madgraph_comparison_count: int
+    madgraph_comparison_maximum_relative_difference: float | None
+    legacy_reference_count: int
+    legacy_comparison_pass_count: int
+    legacy_comparison_failure_count: int
+    legacy_comparison_maximum_relative_difference: float | None
+    cross_mode_count: int
+    cross_mode_maximum_relative_difference: float | None
+    resolved_count: int
+    resolved_maximum_relative_difference: float | None
+    high_precision_count: int
+    high_precision_maximum_relative_difference: float | None
+    source_revisions: tuple[str, ...]
+    successful_source_identity_count: int
+
+    @property
+    def legacy_comparison_count(self) -> int:
+        return self.legacy_comparison_pass_count + self.legacy_comparison_failure_count
+
+    @property
+    def declared_total(self) -> int:
+        return sum(count for _, count in self.declared_by_n)
+
+    @property
+    def expected_total(self) -> int:
+        return sum(count for _, count in self.expected_by_n)
+
+    @property
+    def static_na_total(self) -> int:
+        return sum(count for _, count in self.static_na_by_n)
+
+    @property
+    def passed_total(self) -> int:
+        return sum(count for _, count in self.passed_by_n)
+
+    @property
+    def complete(self) -> bool:
+        return self.passed_total == self.expected_total
+
+    @property
+    def policy_terminal_total(self) -> int:
+        return sum(count for _, count in self.policy_terminal_by_n)
+
+    @property
+    def policy_complete(self) -> bool:
+        return self.passed_total + self.policy_terminal_total == self.expected_total
+
+    @property
+    def uniform_source_revision(self) -> str | None:
+        if (
+            len(self.source_revisions) == 1
+            and self.successful_source_identity_count == self.passed_total
+        ):
+            return self.source_revisions[0]
+        return None
+
+
+def summarize_validation(
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> ValidationSummary:
+    """Summarize validation evidence without treating missing cells as passing."""
+
+    measurements = _cell_measurements(caches)
+    cells = tuple(
+        cell
+        for cell in catalog.measurement_cells()
+        if cell.n_final <= MAX_PUBLICATION_MULTIPLICITY
+    )
+    declared = Counter(cell.n_final for cell in cells)
+    static_na = Counter(
+        cell.n_final for cell in cells if catalog.static_na_reason(cell) is not None
+    )
+    expected = declared - static_na
+    passed: Counter[int] = Counter()
+    policy_terminal: Counter[int] = Counter()
+    statuses: Counter[str] = Counter()
+    madgraph_reference_count = 0
+    madgraph_comparisons: list[Mapping[str, object]] = []
+    legacy_reference_count = 0
+    legacy_comparisons: list[Mapping[str, object]] = []
+    cross_mode: list[Mapping[str, object]] = []
+    resolved: list[Mapping[str, object]] = []
+    high_precision: list[Mapping[str, object]] = []
+    revisions: list[str] = []
+
+    for cell in cells:
+        if catalog.static_na_reason(cell) is not None:
+            statuses["static-na"] += 1
+            continue
+        measurement = measurements.get(cell.cell_id, {})
+        status = str(measurement.get("status", ResultStatus.NOT_AVAILABLE.value))
+        statuses[status] += 1
+        if not _successful(measurement):
+            if policy_status_label(measurement) is not None:
+                policy_terminal[cell.n_final] += 1
+            continue
+        passed[cell.n_final] += 1
+        revision = _source_revision(measurement)
+        if revision is not None:
+            revisions.append(revision)
+        validation = measurement["validation"]
+        assert isinstance(validation, Mapping)
+        method = validation.get("method")
+        if method == "independent-madgraph-tree-level-oracle":
+            madgraph_reference_count += 1
+        elif method == "independent-original-amplicol-oracle":
+            legacy_reference_count += 1
+        if (
+            comparison := _validation_record(
+                measurement,
+                MADGRAPH_COMPARISON_FIELD,
+            )
+        ) is not None:
+            madgraph_comparisons.append(comparison)
+        if (pointwise := _validation_record(measurement, "pointwise")) is not None:
+            reference_mode = _pointwise_reference_mode(
+                cell,
+                validation,
+                catalog=catalog,
+            )
+            if reference_mode is ExecutionMode.AMPLICOL:
+                legacy_comparisons.append(pointwise)
+            elif reference_mode is ExecutionMode.RECURRENCE:
+                cross_mode.append(pointwise)
+        legacy_comparisons.extend(_additional_legacy_comparisons(validation))
+        if (record := _validation_record(measurement, "resolved_sum")) is not None:
+            resolved.append(record)
+        if (record := _validation_record(measurement, "high_precision")) is not None:
+            high_precision.append(record)
+
+    multiplicities = tuple(sorted(declared))
+    return ValidationSummary(
+        declared_by_n=tuple((n_final, declared[n_final]) for n_final in multiplicities),
+        expected_by_n=tuple((n_final, expected[n_final]) for n_final in multiplicities),
+        static_na_by_n=tuple(
+            (n_final, static_na[n_final]) for n_final in multiplicities
+        ),
+        passed_by_n=tuple((n_final, passed[n_final]) for n_final in multiplicities),
+        policy_terminal_by_n=tuple(
+            (n_final, policy_terminal[n_final]) for n_final in multiplicities
+        ),
+        status_counts=tuple(sorted(statuses.items())),
+        madgraph_reference_count=madgraph_reference_count,
+        madgraph_comparison_count=len(madgraph_comparisons),
+        madgraph_comparison_maximum_relative_difference=_maximum(
+            madgraph_comparisons,
+            "relative_difference",
+        ),
+        legacy_reference_count=legacy_reference_count,
+        legacy_comparison_pass_count=sum(
+            record.get("status") == ResultStatus.OK.value
+            for record in legacy_comparisons
+        ),
+        legacy_comparison_failure_count=sum(
+            record.get("status") != ResultStatus.OK.value
+            for record in legacy_comparisons
+        ),
+        legacy_comparison_maximum_relative_difference=_maximum(
+            legacy_comparisons,
+            "relative_difference",
+        ),
+        cross_mode_count=len(cross_mode),
+        cross_mode_maximum_relative_difference=_maximum(
+            cross_mode,
+            "relative_difference",
+        ),
+        resolved_count=len(resolved),
+        resolved_maximum_relative_difference=_maximum(
+            resolved,
+            "maximum_relative_difference",
+        ),
+        high_precision_count=len(high_precision),
+        high_precision_maximum_relative_difference=_maximum(
+            high_precision,
+            "relative_difference",
+        ),
+        source_revisions=tuple(sorted(set(revisions))),
+        successful_source_identity_count=len(revisions),
+    )
+
+
+def _pointwise_reference_mode(
+    cell: CellSpec,
+    validation: Mapping[str, object],
+    *,
+    catalog: ReportCatalog,
+) -> ExecutionMode | None:
+    """Identify the actual endpoint of a stored pointwise comparison."""
+
+    authority = validation.get(INDEPENDENT_AUTHORITY_FIELD)
+    if isinstance(authority, Mapping):
+        selected = authority.get("selected_cell_id")
+        if isinstance(selected, str):
+            try:
+                return catalog.cell(selected).measurement.execution_mode
+            except KeyError:
+                return None
+    baseline = catalog.validation_baseline_cell(cell)
+    return None if baseline is None else baseline.measurement.execution_mode
+
+
+def _additional_legacy_comparisons(
+    validation: Mapping[str, object],
+) -> tuple[Mapping[str, object], ...]:
+    """Return retained legacy records not represented by ``pointwise``."""
+
+    records: list[Mapping[str, object]] = []
+    direct = validation.get(DIRECT_AGREEMENT_FIELD)
+    if isinstance(direct, list):
+        records.extend(
+            record
+            for record in direct
+            if isinstance(record, Mapping)
+            and record.get("edge_kind") == LC_LEGACY_PYAMPLICOL_COMPONENT
+        )
+    for field in (
+        "legacy_amplicol_comparison",
+        "legacy_comparison",
+        "amplicol_comparison",
+    ):
+        raw = validation.get(field)
+        if not isinstance(raw, Mapping):
+            continue
+        nested = raw.get("pointwise")
+        if isinstance(nested, Mapping):
+            records.append(nested)
+        elif "status" in raw:
+            records.append(raw)
+    return tuple(records)
+
+
+def _scientific(value: float | None) -> str:
+    if value is None:
+        return r"\textcolor{ReportMuted}{---}"
+    if value == 0.0:
+        return r"\texttt{0}"
+    coefficient, exponent = f"{value:.3e}".split("e")
+    return rf"\(\texttt{{{coefficient}}}\times10^{{{int(exponent)}}}\)"
+
+
+def _coverage_status(passed: int, expected: int, policy_terminal: int = 0) -> str:
+    if passed == expected:
+        return r"\textcolor{ReportGreen}{verified}"
+    if passed + policy_terminal == expected:
+        return (
+            r"\textcolor{ReportOrange}{policy-complete ("
+            f"{policy_terminal} censored"
+            r")}"
+        )
+    open_count = expected - passed - policy_terminal
+    return (
+        r"\textcolor{ReportOrange}{incomplete ("
+        f"{policy_terminal} censored, {open_count} open"
+        r")}"
+    )
+
+
+def render_validation_summary(
+    caches: Mapping[str, CachePayload] | Iterable[CachePayload],
+    *,
+    catalog: ReportCatalog = REPORT_CATALOG,
+    authenticated_source_lineage: tuple[str, str] | None = None,
+) -> str:
+    """Render a compact summary immediately before the performance tables."""
+
+    summary = summarize_validation(caches, catalog=catalog)
+    display = report_display_accounting(
+        catalog=catalog,
+        max_n_final=MAX_PUBLICATION_MULTIPLICITY,
+    )
+    declared_by_n = dict(summary.declared_by_n)
+    static_na_by_n = dict(summary.static_na_by_n)
+    passed_by_n = dict(summary.passed_by_n)
+    terminal_by_n = dict(summary.policy_terminal_by_n)
+    total_coverage = _coverage_status(
+        summary.passed_total,
+        summary.expected_total,
+        summary.policy_terminal_total,
+    )
+    lines = [
+        "% SPDX-License-Identifier: 0BSD",
+        "% Generated by tools/performance_report/validation_summary.py; do not edit.",
+        r"\begin{samepage}",
+        r"\subsection*{Numerical validation summary}",
+        (
+            r"Only measurements whose numerical checks pass are counted below. "
+            r"The scope comprises every applicable report cell across the "
+            r"complete declared multiplicity range."
+        ),
+        r"\begin{center}",
+        r"\small",
+        r"\begin{tabular}{@{}l r r r l@{}}",
+        r"\toprule",
+        (
+            r"\textbf{final-state multiplicity} & \textbf{declared} & "
+            r"\textbf{static N/A} & \textbf{verified} & "
+            r"\textbf{measurable coverage} \\"
+        ),
+        r"\midrule",
+    ]
+    for n_final, expected in summary.expected_by_n:
+        passed = passed_by_n[n_final]
+        lines.append(
+            f"{n_final} & {declared_by_n[n_final]} & "
+            f"{static_na_by_n[n_final]} & {passed} & "
+            f"{_coverage_status(passed, expected, terminal_by_n[n_final])}"
+            r" \\"
+        )
+    lines.extend(
+        [
+            r"\midrule",
+            (
+                r"\textbf{total} & "
+                f"{summary.declared_total} & {summary.static_na_total} & "
+                f"{summary.passed_total} & "
+                f"{total_coverage}"
+                r" \\"
+            ),
+            r"\bottomrule",
+            r"\end{tabular}",
+            r"\end{center}",
+            r"\end{samepage}",
+            (
+                r"\ReportTableNote{Full-catalog display accounting through \(n=9\): "
+                f"{display.declared_measurement_cell_count} declared cells, comprising "
+                f"{display.required_measurement_count} measurable cells and "
+                f"{display.catalog_static_na_cell_count} catalog-authenticated "
+                r"static N/A rows; "
+                f"{display.structurally_not_applicable_display_slot_count} "
+                r"matrix process/multiplicity positions marked either "
+                r"\textsc{not applicable} or \textsc{not run}; and "
+                f"{display.not_exposed_display_slot_count} "
+                r"reference execution fields marked \textsc{not exposed}. "
+                r"The latter two categories are intentional table structure, "
+                r"not unfilled measurements.}"
+            ),
+            r"\begin{center}",
+            r"\small",
+            r"\begin{tabular}{@{}l r r@{}}",
+            r"\toprule",
+            (
+                r"\textbf{validation evidence} & \textbf{records} & "
+                r"\textbf{max. relative difference} \\"
+            ),
+            r"\midrule",
+            (
+                r"MadGraph standalone tree-level reference records"
+                f" & {summary.madgraph_reference_count} & "
+                r"\textcolor{ReportMuted}{reference} \\"
+            ),
+            (
+                r"\PAC{} versus MadGraph binary64 (p200; OTF p16)"
+                f" & {summary.madgraph_comparison_count} & "
+                f"{_scientific(summary.madgraph_comparison_maximum_relative_difference)}"
+                r" \\"
+            ),
+            (
+                r"original-\AC{} legacy diagnostic records"
+                f" & {summary.legacy_reference_count} & "
+                r"\textcolor{ReportMuted}{diagnostic} \\"
+            ),
+            (
+                r"\PAC{} versus original-\AC{} legacy diagnostic"
+                f" & {summary.legacy_comparison_pass_count} pass, "
+                f"{summary.legacy_comparison_failure_count} mismatch & "
+                f"{_scientific(summary.legacy_comparison_maximum_relative_difference)}"
+                r" \\"
+            ),
+            (
+                r"compiled/eager/OTF versus recurrence"
+                f" & {summary.cross_mode_count} & "
+                f"{_scientific(summary.cross_mode_maximum_relative_difference)}"
+                r" \\"
+            ),
+            (
+                r"optimized result versus resolved sum"
+                f" & {summary.resolved_count} & "
+                f"{_scientific(summary.resolved_maximum_relative_difference)}"
+                r" \\"
+            ),
+            (
+                r"binary64 result versus p32"
+                f" & {summary.high_precision_count} & "
+                f"{_scientific(summary.high_precision_maximum_relative_difference)}"
+                r" \\"
+            ),
+            r"\bottomrule",
+            r"\end{tabular}",
+            r"\end{center}",
+        ]
+    )
+    revision = summary.uniform_source_revision
+    if (
+        authenticated_source_lineage is not None
+        and summary.successful_source_identity_count == summary.passed_total
+        and set(summary.source_revisions).issubset(set(authenticated_source_lineage))
+    ):
+        ancestor, descendant = authenticated_source_lineage
+        source_text = (
+            rf"\nolinkurl{{{ancestor}}} \(\rightarrow\) "
+            rf"\nolinkurl{{{descendant}}} "
+            r"\textcolor{ReportGreen}{(authenticated Class-C lineage)}"
+        )
+    elif revision is None:
+        source_text = (
+            r"\textcolor{ReportOrange}{source identity is incomplete or mixed}"
+        )
+    else:
+        source_text = rf"\nolinkurl{{{revision}}}"
+    lines.extend(
+        [
+            (
+                r"\ReportTableNote{Profile: \texttt{\ReportProfileName}. "
+                r"Measured source: "
+                + source_text
+                + r". The authoritative \PAC{} versus MadGraph binary64 "
+                r"full-colour comparison uses p200 for recurrence, compiled, "
+                r"and eager candidates and the supported p16 lane for OTF; "
+                r"all use a relative tolerance "
+                r"of \(10^{-10}\). Original-\AC{} comparisons are retained "
+                r"non-authoritative legacy diagnostics at \(10^{-8}\); a "
+                r"legacy mismatch does not invalidate a candidate; cross-mode "
+                r"(including OTF/recurrence), resolved-sum, and p32 "
+                r"comparisons use \(10^{-12}\).}"
+            ),
+        ]
+    )
+    return "\n".join(lines) + "\n"
+
+
+__all__ = [
+    "MAX_PUBLICATION_MULTIPLICITY",
+    "SUMMARY_TABLE_NAME",
+    "ValidationSummary",
+    "render_validation_summary",
+    "summarize_validation",
+]
diff --git a/pyamplicol/tools/performance_report/worker.py b/pyamplicol/tools/performance_report/worker.py
new file mode 100644
index 0000000000..43137ae55f
--- /dev/null
+++ b/pyamplicol/tools/performance_report/worker.py
@@ -0,0 +1,689 @@
+# SPDX-License-Identifier: 0BSD
+"""Isolated one-cell worker entry point used by the campaign scheduler."""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+import threading
+import time
+import traceback
+import uuid
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import contextmanager, redirect_stderr, redirect_stdout
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyamplicol.reporting import ProgressEvent, ProgressSink
+
+from .agreements import (
+    LC_CROSS_LAYOUT_COMPONENT,
+    attach_direct_agreements,
+    incoming_agreement_edges,
+    independent_numerical_authorities,
+)
+from .artifacts import _filesystem_lock, _raise_disk_full
+from .catalog import REPORT_CATALOG, ReportCatalog
+from .measurement import (
+    attach_validation_failure_precision_diagnostic,
+    failure_measurement,
+    generated_artifact_from_measurement,
+    load_measurement,
+    measure_pyamplicol_cell,
+)
+from .models import ExecutionMode, ResultStatus
+from .phase_state import WorkerPhaseChannel, WorkerPhaseReporter
+from .runner import ProfilingTimeLimitError, RunnerSettings
+from .service import ReportPaths
+from .source_identity import ReportSourceIdentity, require_eligible_report_source
+from .worker_harness import attach_worker_harness_identity
+
+_GIT_OBJECT_ID = re.compile(r"^[0-9a-fA-F]{40}$")
+
+
+class _JsonlProgressSink:
+    """Thread-safe, append-only typed progress capture for dashboard readers."""
+
+    def __init__(self, path: Path) -> None:
+        self.path = path.expanduser().resolve(strict=False)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.Lock()
+
+    def emit(self, event: ProgressEvent) -> None:
+        from pyamplicol.reporting import ProgressEnd, ProgressStart, ProgressUpdate
+
+        payload: dict[str, object] = {
+            "timestamp_unix": time.time(),
+            "pid": os.getpid(),
+            "task_id": event.task_id,
+        }
+        if isinstance(event, ProgressStart):
+            payload.update(
+                {
+                    "event": "start",
+                    "description": event.description,
+                    "total": event.total,
+                    "parent_task_id": event.parent_task_id,
+                    "unit": event.unit,
+                    "details": dict(event.details),
+                }
+            )
+        elif isinstance(event, ProgressUpdate):
+            payload.update(
+                {
+                    "event": "update",
+                    "completed": event.completed,
+                    "total": event.total,
+                    "message": event.message,
+                    "details": dict(event.details),
+                }
+            )
+        elif isinstance(event, ProgressEnd):
+            payload.update(
+                {
+                    "event": "end",
+                    "success": event.success,
+                    "message": event.message,
+                    "elapsed_seconds": event.elapsed_seconds,
+                    "details": dict(event.details),
+                }
+            )
+        else:  # pragma: no cover - ProgressEvent is a closed typed union.
+            raise TypeError(f"unsupported progress event: {type(event).__name__}")
+        encoded = (
+            json.dumps(
+                payload,
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            + "\n"
+        ).encode("ascii")
+        flags = os.O_APPEND | os.O_CREAT | os.O_WRONLY | getattr(os, "O_CLOEXEC", 0)
+        with self._lock:
+            descriptor = os.open(self.path, flags, 0o600)
+            try:
+                os.write(descriptor, encoded)
+            finally:
+                os.close(descriptor)
+
+
+def _source_identity(
+    repo_root: Path,
+    revision: str | None,
+    tree: str | None,
+) -> ReportSourceIdentity:
+    if (revision is None) != (tree is None):
+        raise ValueError("manual source revision and tree must be specified together")
+    if revision is None:
+        return require_eligible_report_source(repo_root)
+    assert tree is not None
+    if _GIT_OBJECT_ID.fullmatch(revision) is None:
+        raise ValueError("manual source revision must be a 40-digit hexadecimal ID")
+    if _GIT_OBJECT_ID.fullmatch(tree) is None:
+        raise ValueError("manual source tree must be a 40-digit hexadecimal ID")
+    return ReportSourceIdentity(revision.lower(), tree.lower(), ())
+
+
+def _portable_current_paths(
+    *,
+    repo_root: Path,
+    attempt_root: Path,
+) -> ReportPaths | None:
+    """Recognize the canonical copied-campaign attempt shape.
+
+    Ordinary developer/report stores retain their historical raw-current ABI.
+    A copied manual campaign has one literal visible state root, so its worker
+    can materialize authenticated peer/current files without another CLI flag.
+    """
+
+    lexical_attempt = Path(os.path.abspath(attempt_root.expanduser()))
+    if len(lexical_attempt.parents) < 4:
+        return None
+    artifact_root = lexical_attempt.parents[3]
+    if artifact_root.name != "campaign_artifacts":
+        return None
+    relative = lexical_attempt.relative_to(artifact_root)
+    if (
+        len(relative.parts) != 4
+        or relative.parts[0] != "cells"
+        or not relative.parts[1]
+        or relative.parts[2] != "attempts"
+    ):
+        raise ValueError("manual campaign worker attempt path is not canonical")
+    try:
+        attempt_id = str(uuid.UUID(relative.parts[3]))
+    except ValueError as error:
+        raise ValueError("manual campaign worker attempt ID is invalid") from error
+    if attempt_id != relative.parts[3]:
+        raise ValueError("manual campaign worker attempt ID is not canonical")
+    try:
+        resolved_attempt = attempt_root.expanduser().resolve(strict=True)
+        resolved_root = artifact_root.resolve(strict=True)
+    except OSError as error:
+        raise ValueError("manual campaign worker state root is unavailable") from error
+    if (
+        resolved_attempt != lexical_attempt
+        or resolved_root != artifact_root
+        or artifact_root.is_symlink()
+        or not artifact_root.is_dir()
+    ):
+        raise ValueError("manual campaign worker state root is not canonical")
+    coordination_root = artifact_root / "coordination"
+    if (
+        coordination_root.is_symlink()
+        or not coordination_root.is_dir()
+        or coordination_root.resolve(strict=True) != coordination_root
+    ):
+        raise ValueError("manual campaign coordination root is not canonical")
+    docs_dir = artifact_root.parent
+    return ReportPaths(
+        repo_root=repo_root.expanduser().resolve(strict=False),
+        docs_dir=docs_dir,
+        results_dir=docs_dir / "results",
+        artifact_root=artifact_root,
+        coordination_root=coordination_root,
+    )
+
+
+def _atomic_json(path: Path, payload: Mapping[str, object]) -> None:
+    descriptor: int | None = None
+    temporary: Path | None = None
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        descriptor, temporary_name = tempfile.mkstemp(
+            prefix=f".{path.name}.",
+            suffix=".tmp",
+            dir=path.parent,
+        )
+        temporary = Path(temporary_name)
+        stream = os.fdopen(descriptor, "w", encoding="ascii")
+        descriptor = None
+        with stream:
+            json.dump(
+                payload,
+                stream,
+                allow_nan=False,
+                ensure_ascii=True,
+                separators=(",", ":"),
+                sort_keys=True,
+            )
+            stream.write("\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+    except OSError as error:
+        _raise_disk_full(error, path)
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+
+
+def _selector_provider_measurement(
+    cell_id: str,
+    peers: Mapping[str, Mapping[str, object]],
+    *,
+    catalog: ReportCatalog,
+) -> Mapping[str, object] | None:
+    """Return the scheduled selected-flow peer used to seed LC all-flow."""
+
+    cell = catalog.cell(cell_id)
+    providers = tuple(
+        edge.baseline.cell_id
+        for edge in incoming_agreement_edges(cell, catalog=catalog)
+        if edge.kind == LC_CROSS_LAYOUT_COMPONENT
+    )
+    if not providers:
+        return None
+    if len(providers) != 1:
+        raise ValueError(f"{cell_id}: selector provider is not unique")
+    provider_id = providers[0]
+    provider = peers.get(provider_id)
+    if provider is None:
+        raise ValueError(
+            f"{cell_id}: required selector provider {provider_id!r} is unavailable"
+        )
+    return provider
+
+
+@contextmanager
+def _worker_legacy_workspace(
+    *,
+    repository: Path | None,
+    source_repository: Path | None,
+    workspace: Path | None,
+    copy_source: bool,
+) -> Iterator[Path | None]:
+    """Prepare an isolated legacy checkout inside the supervised worker."""
+
+    if source_repository is None:
+        if workspace is not None or copy_source:
+            raise ValueError(
+                "legacy workspace/copy options require a source repository"
+            )
+        yield repository
+        return
+    if repository is not None:
+        raise ValueError(
+            "legacy repository and legacy source repository are mutually exclusive"
+        )
+    if workspace is None:
+        raise ValueError("legacy source repository requires a workspace destination")
+    source = source_repository.expanduser().resolve(strict=True)
+    destination = workspace.expanduser().resolve(strict=False)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if destination.exists():
+        raise RuntimeError(f"legacy worker workspace already exists: {destination}")
+
+    from .legacy import MaintainedLegacyApi
+    from .legacy_structure import legacy_structural_probe_lock
+
+    api = MaintainedLegacyApi()
+    print(
+        f"Preparing isolated original-AmpliCol workspace {destination}",
+        flush=True,
+    )
+    if copy_source:
+        with legacy_structural_probe_lock(source):
+            shutil.copytree(
+                source,
+                destination,
+                ignore=shutil.ignore_patterns(".git", ".DS_Store"),
+            )
+    else:
+        api.validate_checkout(source)
+        commands = (
+            (
+                "git",
+                "clone",
+                "--shared",
+                "--no-checkout",
+                "--",
+                os.fspath(source),
+                os.fspath(destination),
+            ),
+            (
+                "git",
+                "-C",
+                os.fspath(destination),
+                "checkout",
+                "--detach",
+                api.expected_revision(),
+            ),
+        )
+        for command in commands:
+            print(f"Legacy workspace command: {' '.join(command)}", flush=True)
+            completed = subprocess.run(
+                command,
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=300,
+            )
+            if completed.returncode != 0:
+                detail = completed.stderr.strip() or completed.stdout.strip()
+                raise RuntimeError(
+                    "cannot prepare isolated legacy worker checkout: "
+                    f"{detail or f'exit {completed.returncode}'}"
+                )
+        api.validate_checkout(destination)
+    try:
+        yield destination
+    finally:
+        if destination.exists():
+            if destination.is_symlink() or not destination.is_dir():
+                raise RuntimeError(
+                    "legacy worker workspace is not its canonical regular "
+                    f"directory: {destination}"
+                )
+            shutil.rmtree(destination)
+
+
+def measure_cell(
+    cell_id: str,
+    *,
+    repo_root: Path,
+    attempt_root: Path,
+    target_runtime_seconds: float,
+    batch_size: int,
+    worker_cores: int,
+    amplicol_build_jobs: int = 1,
+    memory_limit_bytes: int | None = None,
+    warmup_runs: int = 2,
+    minimum_samples: int = 5,
+    progress_jsonl: Path | None = None,
+    worker_wall_limit_seconds: float | None = None,
+    profiling_time_limit_seconds: float | None = None,
+    validation_time_limit_seconds: float | None = None,
+    manual_source_revision: str | None = None,
+    manual_source_tree: str | None = None,
+    baseline_json: Path | None = None,
+    expected_authority_cell_ids: Sequence[str] = (),
+    selected_authority_cell_id: str | None = None,
+    peer_json: Sequence[tuple[str, Path]] = (),
+    prepared_model_path: Path | None = None,
+    reused_measurement_json: Path | None = None,
+    phase_reporter: WorkerPhaseReporter | None = None,
+    legacy_repository: Path | None = None,
+    legacy_source_repository: Path | None = None,
+    legacy_workspace: Path | None = None,
+    legacy_copy_source: bool = False,
+    legacy_source_revision: str | None = None,
+    madgraph_installation: Path | None = None,
+    catalog: ReportCatalog = REPORT_CATALOG,
+) -> dict[str, object]:
+    worker_started_monotonic = time.monotonic()
+    if amplicol_build_jobs < 1:
+        raise ValueError("amplicol_build_jobs must be positive")
+    for name, value in (
+        ("worker_wall_limit_seconds", worker_wall_limit_seconds),
+        ("profiling_time_limit_seconds", profiling_time_limit_seconds),
+        ("validation_time_limit_seconds", validation_time_limit_seconds),
+    ):
+        if value is not None and (not math.isfinite(value) or value <= 0.0):
+            raise ValueError(f"{name} must be finite and positive")
+    cell = catalog.cell(cell_id)
+    static_na_reason = catalog.static_na_reason(cell)
+    if static_na_reason is not None:
+        description = catalog.static_na_description(cell)
+        raise ValueError(
+            f"{cell_id}: catalog static N/A cell cannot be measured "
+            f"({static_na_reason}: {description})"
+        )
+    authority_ids = tuple(expected_authority_cell_ids)
+    canonical_authority_ids = tuple(
+        authority.cell_id
+        for authority in independent_numerical_authorities(cell, catalog=catalog)
+    )
+    if authority_ids != canonical_authority_ids:
+        raise ValueError(
+            "expected numerical authority cell IDs differ from the canonical "
+            f"catalog chain: expected={canonical_authority_ids!r}, "
+            f"observed={authority_ids!r}"
+        )
+    if selected_authority_cell_id is not None and (
+        selected_authority_cell_id not in authority_ids
+        or baseline_json is None
+    ):
+        raise ValueError("selected numerical authority is not in the expected chain")
+    if authority_ids and (baseline_json is not None) != (
+        selected_authority_cell_id is not None
+    ):
+        raise ValueError(
+            "compiled/eager baseline and selected numerical authority must be "
+            "specified together"
+        )
+    source_identity = _source_identity(
+        repo_root,
+        manual_source_revision,
+        manual_source_tree,
+    )
+    progress: ProgressSink | None = (
+        None if progress_jsonl is None else _JsonlProgressSink(progress_jsonl)
+    )
+    publication_paths = _portable_current_paths(
+        repo_root=repo_root,
+        attempt_root=attempt_root,
+    )
+    baseline = (
+        None
+        if baseline_json is None
+        else load_measurement(
+            baseline_json,
+            publication_paths=publication_paths,
+        )
+    )
+    peers = {
+        peer_cell_id: load_measurement(
+            path,
+            publication_paths=publication_paths,
+        )
+        for peer_cell_id, path in peer_json
+    }
+    if len(peers) != len(peer_json):
+        raise ValueError("direct-agreement peer cell IDs must be unique")
+    reused_artifact = (
+        None
+        if reused_measurement_json is None
+        else generated_artifact_from_measurement(
+            load_measurement(
+                reused_measurement_json,
+                publication_paths=publication_paths,
+            )
+        )
+    )
+    selector_provider = _selector_provider_measurement(
+        cell.cell_id,
+        peers,
+        catalog=catalog,
+    )
+    if cell.measurement.execution_mode is ExecutionMode.AMPLICOL:
+        from .legacy import LegacyMeasurementAdapter, LegacySettings
+
+        with _worker_legacy_workspace(
+            repository=legacy_repository,
+            source_repository=legacy_source_repository,
+            workspace=legacy_workspace,
+            copy_source=legacy_copy_source,
+        ) as prepared_legacy_repository:
+            result = LegacyMeasurementAdapter().measure(
+                cell,
+                artifact_path=attempt_root / "artifact",
+                settings=LegacySettings(
+                    target_runtime_seconds=target_runtime_seconds,
+                    jobs=amplicol_build_jobs,
+                    repository=prepared_legacy_repository,
+                    validate_checkout=manual_source_revision is None,
+                    source_revision=legacy_source_revision,
+                    profiling_time_limit_seconds=profiling_time_limit_seconds,
+                    worker_deadline_monotonic=(
+                        None
+                        if worker_wall_limit_seconds is None
+                        else worker_started_monotonic + worker_wall_limit_seconds
+                    ),
+                ),
+                phase_reporter=phase_reporter,
+                selector_provider=selector_provider,
+            )
+    elif cell.measurement.execution_mode is ExecutionMode.MADGRAPH:
+        if madgraph_installation is None:
+            raise ValueError(
+                "MadGraph reference cell requires a configured installation"
+            )
+        from .madgraph import MadGraphMeasurementAdapter, MadGraphSettings
+
+        result = MadGraphMeasurementAdapter().measure(
+            cell,
+            artifact_path=attempt_root / "artifact",
+            settings=MadGraphSettings(
+                installation=madgraph_installation,
+                target_runtime_seconds=target_runtime_seconds,
+                worker_deadline_monotonic=(
+                    None
+                    if worker_wall_limit_seconds is None
+                    else worker_started_monotonic + worker_wall_limit_seconds
+                ),
+            ),
+            phase_reporter=phase_reporter,
+        )
+    else:
+        result = measure_pyamplicol_cell(
+            cell,
+            artifact_path=attempt_root / "artifact",
+            settings=RunnerSettings(
+                target_runtime_seconds=target_runtime_seconds,
+                batch_size=batch_size,
+                worker_cores=worker_cores,
+                memory_limit_bytes=memory_limit_bytes,
+                warmup_runs=warmup_runs,
+                minimum_samples=minimum_samples,
+                model_cache_dir=attempt_root.parent.parent.parent / "model-cache",
+                progress=progress,
+                source_revision_override=(
+                    None if manual_source_revision is None else source_identity.revision
+                ),
+                profiling_time_limit_seconds=profiling_time_limit_seconds,
+                worker_deadline_monotonic=(
+                    None
+                    if worker_wall_limit_seconds is None
+                    else worker_started_monotonic + worker_wall_limit_seconds
+                ),
+            ),
+            repo_root=repo_root,
+            baseline=baseline,
+            expected_authority_cell_ids=authority_ids,
+            selected_authority_cell_id=selected_authority_cell_id,
+            validation_peers=peers,
+            selector_provider=selector_provider,
+            prepared_model_path=prepared_model_path,
+            reused_artifact=reused_artifact,
+            phase_reporter=phase_reporter,
+            catalog=catalog,
+        )
+    attach_direct_agreements(
+        cell,
+        result,
+        peers,
+        catalog=catalog,
+    )
+    attach_validation_failure_precision_diagnostic(
+        cell,
+        result,
+        baseline=baseline,
+        peers=peers,
+    )
+    source_identity_postflight = _source_identity(
+        repo_root,
+        manual_source_revision,
+        manual_source_tree,
+    )
+    if source_identity_postflight != source_identity:
+        raise RuntimeError("report source identity changed during cell measurement")
+    provenance = result.get("provenance")
+    result["provenance"] = {
+        **({} if not isinstance(provenance, Mapping) else dict(provenance)),
+        **source_identity.provenance(),
+    }
+    if phase_reporter is not None:
+        phase_reporter.complete()
+    return result
+
+
+def write_cell_result(
+    cell_id: str,
+    result_path: Path,
+    *,
+    log_path: Path | None = None,
+    phase_state_path: Path | None = None,
+    phase_state_run_id: str | None = None,
+    phase_state_authentication_key: str | None = None,
+    worker_harness: Mapping[str, object] | None = None,
+    worker_wall_limit_seconds: float | None = None,
+    profiling_time_limit_seconds: float | None = None,
+    validation_time_limit_seconds: float | None = None,
+    generation_lock_path: Path | None = None,
+    madgraph_installation: Path | None = None,
+    **kwargs: object,
+) -> dict[str, object]:
+    try:
+        phase_arguments = (
+            phase_state_path,
+            phase_state_run_id,
+            phase_state_authentication_key,
+        )
+        if any(argument is not None for argument in phase_arguments):
+            if not all(argument is not None for argument in phase_arguments):
+                raise ValueError(
+                    "worker phase-state arguments must be specified together"
+                )
+            assert phase_state_path is not None
+            assert phase_state_run_id is not None
+            assert phase_state_authentication_key is not None
+            phase_reporter = WorkerPhaseReporter(
+                WorkerPhaseChannel(
+                    path=phase_state_path.expanduser().resolve(strict=False),
+                    run_id=phase_state_run_id,
+                    authentication_key=phase_state_authentication_key,
+                ),
+                track_post_generation_stages=(
+                    profiling_time_limit_seconds is not None
+                    or validation_time_limit_seconds is not None
+                ),
+                generation_gate=(
+                    None
+                    if generation_lock_path is None
+                    else lambda: _filesystem_lock(
+                        generation_lock_path,
+                        timeout=None,
+                        poll_interval=0.05,
+                    )
+                ),
+            )
+        else:
+            phase_reporter = None
+        if log_path is None:
+            result = measure_cell(
+                cell_id,
+                phase_reporter=phase_reporter,
+                worker_wall_limit_seconds=worker_wall_limit_seconds,
+                profiling_time_limit_seconds=profiling_time_limit_seconds,
+                validation_time_limit_seconds=validation_time_limit_seconds,
+                madgraph_installation=madgraph_installation,
+                **kwargs,  # type: ignore[arg-type]
+            )
+        else:
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            with (
+                log_path.open("a", encoding="utf-8") as stream,
+                redirect_stdout(stream),
+                redirect_stderr(stream),
+            ):
+                result = measure_cell(
+                    cell_id,
+                    phase_reporter=phase_reporter,
+                    worker_wall_limit_seconds=worker_wall_limit_seconds,
+                    profiling_time_limit_seconds=profiling_time_limit_seconds,
+                    validation_time_limit_seconds=validation_time_limit_seconds,
+                    madgraph_installation=madgraph_installation,
+                    **kwargs,  # type: ignore[arg-type]
+                )
+    except ProfilingTimeLimitError as error:
+        if log_path is not None:
+            with log_path.open("a", encoding="utf-8") as stream:
+                traceback.print_exc(file=stream)
+        result = failure_measurement(
+            ResultStatus.TIMEOUT,
+            error,
+            resources={"terminal_reason": "profiling_timeout"},
+        )
+    except Exception as error:
+        if log_path is not None:
+            with log_path.open("a", encoding="utf-8") as stream:
+                traceback.print_exc(file=stream)
+        result = failure_measurement(ResultStatus.ERROR, error)
+    if worker_harness is not None:
+        attach_worker_harness_identity(result, worker_harness)
+    provenance = result.get("provenance")
+    if isinstance(provenance, Mapping):
+        result["provenance"] = {
+            **provenance,
+            "worker_environment": {
+                "LD_LIBRARY_PATH": os.environ.get("LD_LIBRARY_PATH"),
+                "DYLD_LIBRARY_PATH": os.environ.get("DYLD_LIBRARY_PATH"),
+            },
+            "worker_log": None if log_path is None else os.fspath(log_path),
+        }
+    _atomic_json(result_path, result)
+    return result
+
+
+__all__ = ["measure_cell", "write_cell_result"]
diff --git a/pyamplicol/tools/performance_report/worker_harness.py b/pyamplicol/tools/performance_report/worker_harness.py
new file mode 100644
index 0000000000..4ad480c6a1
--- /dev/null
+++ b/pyamplicol/tools/performance_report/worker_harness.py
@@ -0,0 +1,177 @@
+# SPDX-License-Identifier: 0BSD
+"""Relocation-safe identities for split wrapper/measurement workers."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping, MutableMapping
+
+WORKER_HARNESS_ABI = "pyamplicol-report-worker-harness-v1"
+WORKER_HARNESS_PROVENANCE_FIELD = "worker_harness"
+POLICY_ENTRYPOINT = "src/pyamplicol/_profiling_campaign/result_tables.py"
+LEGACY_ADAPTER = "tools/performance_report/legacy.py"
+
+_SHA40_RE = re.compile(r"[0-9a-f]{40}")
+_SHA256_RE = re.compile(r"[0-9a-f]{64}")
+_FIELDS = frozenset(
+    {
+        "abi",
+        "study_contract_sha256",
+        "policy_wrapper_revision",
+        "policy_wrapper_tree",
+        "policy_entrypoint",
+        "policy_entrypoint_sha256",
+        "legacy_adapter",
+        "legacy_adapter_sha256",
+        "measured_source_revision",
+        "measured_source_tree",
+    }
+)
+
+
+class WorkerHarnessError(ValueError):
+    """A worker did not use the authenticated wrapper/measurement split."""
+
+
+def worker_harness_identity(
+    *,
+    study_contract_sha256: str,
+    policy_wrapper_revision: str,
+    policy_wrapper_tree: str,
+    policy_entrypoint_sha256: str,
+    legacy_adapter_sha256: str,
+    measured_source_revision: str,
+    measured_source_tree: str,
+) -> dict[str, object]:
+    """Build a canonical identity without embedding checkout paths."""
+
+    payload: dict[str, object] = {
+        "abi": WORKER_HARNESS_ABI,
+        "study_contract_sha256": study_contract_sha256,
+        "policy_wrapper_revision": policy_wrapper_revision,
+        "policy_wrapper_tree": policy_wrapper_tree,
+        "policy_entrypoint": POLICY_ENTRYPOINT,
+        "policy_entrypoint_sha256": policy_entrypoint_sha256,
+        "legacy_adapter": LEGACY_ADAPTER,
+        "legacy_adapter_sha256": legacy_adapter_sha256,
+        "measured_source_revision": measured_source_revision,
+        "measured_source_tree": measured_source_tree,
+    }
+    validate_worker_harness_identity(payload)
+    return payload
+
+
+def validate_worker_harness_identity(
+    value: object,
+    *,
+    expected: Mapping[str, object] | None = None,
+    expected_measured_revision: str | None = None,
+    expected_measured_tree: str | None = None,
+) -> Mapping[str, object]:
+    """Validate one canonical wrapper/measurement identity."""
+
+    if not isinstance(value, Mapping) or set(value) != _FIELDS:
+        raise WorkerHarnessError("worker harness fields are not canonical")
+    if (
+        value.get("abi") != WORKER_HARNESS_ABI
+        or value.get("policy_entrypoint") != POLICY_ENTRYPOINT
+        or value.get("legacy_adapter") != LEGACY_ADAPTER
+    ):
+        raise WorkerHarnessError("worker harness ABI or relative paths differ")
+    for field in (
+        "policy_wrapper_revision",
+        "policy_wrapper_tree",
+        "measured_source_revision",
+        "measured_source_tree",
+    ):
+        item = value.get(field)
+        if not isinstance(item, str) or _SHA40_RE.fullmatch(item) is None:
+            raise WorkerHarnessError(
+                f"worker harness {field} is not a Git identity"
+            )
+    for field in (
+        "study_contract_sha256",
+        "policy_entrypoint_sha256",
+        "legacy_adapter_sha256",
+    ):
+        item = value.get(field)
+        if not isinstance(item, str) or _SHA256_RE.fullmatch(item) is None:
+            raise WorkerHarnessError(
+                f"worker harness {field} is not SHA-256"
+            )
+    if expected is not None and dict(value) != dict(expected):
+        raise WorkerHarnessError(
+            "worker harness differs from the authenticated study contract"
+        )
+    if (
+        expected_measured_revision is not None
+        and value.get("measured_source_revision")
+        != expected_measured_revision
+    ):
+        raise WorkerHarnessError(
+            "worker harness measured source revision differs"
+        )
+    if (
+        expected_measured_tree is not None
+        and value.get("measured_source_tree") != expected_measured_tree
+    ):
+        raise WorkerHarnessError("worker harness measured source tree differs")
+    return value
+
+
+def attach_worker_harness_identity(
+    measurement: MutableMapping[str, object],
+    identity: Mapping[str, object],
+) -> None:
+    """Attach an authenticated identity without overwriting another harness."""
+
+    validated = dict(validate_worker_harness_identity(identity))
+    provenance = measurement.get("provenance")
+    if provenance is not None and not isinstance(provenance, Mapping):
+        raise WorkerHarnessError("measurement provenance is invalid")
+    existing = (
+        provenance.get(WORKER_HARNESS_PROVENANCE_FIELD)
+        if isinstance(provenance, Mapping)
+        else None
+    )
+    if existing is not None and existing != validated:
+        raise WorkerHarnessError(
+            "measurement is already bound to another worker harness"
+        )
+    measurement["provenance"] = {
+        **({} if provenance is None else dict(provenance)),
+        WORKER_HARNESS_PROVENANCE_FIELD: validated,
+    }
+
+
+def require_worker_harness_identity(
+    measurement: Mapping[str, object],
+    *,
+    expected: Mapping[str, object] | None = None,
+    expected_measured_revision: str | None = None,
+    expected_measured_tree: str | None = None,
+) -> Mapping[str, object]:
+    """Return the authenticated harness carried by a measurement."""
+
+    provenance = measurement.get("provenance")
+    if not isinstance(provenance, Mapping):
+        raise WorkerHarnessError("measurement has no worker harness provenance")
+    return validate_worker_harness_identity(
+        provenance.get(WORKER_HARNESS_PROVENANCE_FIELD),
+        expected=expected,
+        expected_measured_revision=expected_measured_revision,
+        expected_measured_tree=expected_measured_tree,
+    )
+
+
+__all__ = [
+    "LEGACY_ADAPTER",
+    "POLICY_ENTRYPOINT",
+    "WORKER_HARNESS_ABI",
+    "WORKER_HARNESS_PROVENANCE_FIELD",
+    "WorkerHarnessError",
+    "attach_worker_harness_identity",
+    "require_worker_harness_identity",
+    "validate_worker_harness_identity",
+    "worker_harness_identity",
+]
diff --git a/pyamplicol/tools/performance_report/workspace.py b/pyamplicol/tools/performance_report/workspace.py
new file mode 100644
index 0000000000..436a7d5a5f
--- /dev/null
+++ b/pyamplicol/tools/performance_report/workspace.py
@@ -0,0 +1,1316 @@
+# SPDX-License-Identifier: 0BSD
+"""Architecture-scoped, tracked performance-report workspaces."""
+
+from __future__ import annotations
+
+import importlib
+import json
+import platform
+import re
+import shutil
+import subprocess
+import uuid
+from collections.abc import Callable, Mapping
+from pathlib import Path
+
+from .campaign_policy import (
+    MACBOOK_M3_POLICY,
+    X86_EPYC_POLICY,
+    X86_EPYC_WORKERS,
+    CampaignPolicy,
+    CampaignPolicyError,
+    campaign_policy,
+    default_campaign_policy,
+    policy_from_manifest,
+    validate_policy_profile,
+)
+from .publication import publication_absolute_paths
+from .service import (
+    CANONICAL_REPORT_ENTRYPOINT,
+    CANONICAL_REPORT_ROOT,
+    PROFILE_REPORT_ROOT,
+    ReportPaths,
+    ReportService,
+    validate_profile_name,
+)
+from .source_identity import (
+    SOURCE_IDENTITY_SCHEMA,
+    ReportSourceIdentityError,
+    inspect_report_source,
+)
+from .standalone_build import compile_report
+
+WORKSPACE_SCHEMA = "pyamplicol-performance-report-workspace-v4"
+WORKSPACE_MANIFEST = "report-workspace.json"
+ENVIRONMENT_SCHEMA = "pyamplicol-performance-report-environment-v1"
+ENVIRONMENT_JSON = "report_environment.json"
+ENVIRONMENT_TEX = "report_environment.tex"
+MEASUREMENT_LINEAGE_JSON = "measurement_lineage.json"
+STANDALONE_BUILDER = "build_pdf.py"
+TABLE_FILLING_RUNBOOK = "TABLE_FILLING.md"
+PROFILE_PARENT = PROFILE_REPORT_ROOT
+_GIT_SHA_RE = re.compile(r"^[0-9a-f]{40}$")
+_PENDING_RUNTIME = "pending exact-source runtime authentication"
+
+
+class ReportWorkspaceError(RuntimeError):
+    """A report workspace could not be initialized or exported safely."""
+
+
+def _canonical_json(payload: Mapping[str, object]) -> str:
+    return (
+        json.dumps(
+            payload,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        + "\n"
+    )
+
+
+def profile_docs_dir(repo_root: Path, profile: str) -> Path:
+    root = repo_root.expanduser().resolve(strict=False)
+    return root / PROFILE_PARENT / validate_profile_name(profile)
+
+
+def _source_docs_dir(
+    repo_root: Path,
+    *,
+    source_profile: str | None,
+) -> Path:
+    if source_profile is None:
+        return repo_root / CANONICAL_REPORT_ROOT
+    return profile_docs_dir(repo_root, source_profile)
+
+
+def _copy_publication_members(
+    source: Path,
+    destination: Path,
+) -> None:
+    required = (source / "pyAmpliCol.tex", source / "result_tables.py")
+    missing = [path.name for path in required if not path.is_file()]
+    if missing:
+        raise ReportWorkspaceError(
+            f"report source {source} is missing required files: {missing}"
+        )
+    results = source / "results"
+    if not results.is_dir():
+        raise ReportWorkspaceError(f"report source has no results directory: {source}")
+
+    destination.mkdir(parents=True, exist_ok=False)
+    for path in sorted(source.glob("*.tex")):
+        if not path.is_file() or path.is_symlink():
+            raise ReportWorkspaceError(f"unsafe TeX source member: {path}")
+        shutil.copy2(path, destination / path.name)
+    environment_json = source / ENVIRONMENT_JSON
+    if environment_json.exists():
+        if not environment_json.is_file() or environment_json.is_symlink():
+            raise ReportWorkspaceError(
+                f"unsafe environment metadata member: {environment_json}"
+            )
+        shutil.copy2(environment_json, destination / ENVIRONMENT_JSON)
+    shutil.copy2(source / "result_tables.py", destination / "result_tables.py")
+
+    output_results = destination / "results"
+    output_results.mkdir()
+    json_files = tuple(sorted(results.glob("*.json")))
+    if not json_files:
+        raise ReportWorkspaceError(f"report source has no JSON caches: {results}")
+    for path in json_files:
+        if not path.is_file() or path.is_symlink():
+            raise ReportWorkspaceError(f"unsafe result-cache member: {path}")
+        shutil.copy2(path, output_results / path.name)
+
+
+def _copy_measurement_lineage(source: Path, destination: Path) -> None:
+    measurement_lineage = source / MEASUREMENT_LINEAGE_JSON
+    if not measurement_lineage.exists():
+        return
+    if not measurement_lineage.is_file() or measurement_lineage.is_symlink():
+        raise ReportWorkspaceError(
+            f"unsafe measurement-lineage member: {measurement_lineage}"
+        )
+    shutil.copy2(
+        measurement_lineage,
+        destination / MEASUREMENT_LINEAGE_JSON,
+    )
+
+
+def _install_standalone_builder(destination: Path) -> None:
+    source = Path(__file__).with_name("standalone_build.py")
+    if not source.is_file() or source.is_symlink():
+        raise ReportWorkspaceError(
+            f"standalone report builder is unavailable: {source}"
+        )
+    shutil.copy2(source, destination / STANDALONE_BUILDER)
+
+
+def _assert_portable_results(docs_dir: Path) -> None:
+    for path in sorted((docs_dir / "results").glob("*.json")):
+        try:
+            payload = json.loads(path.read_text(encoding="ascii"))
+        except (OSError, UnicodeError, json.JSONDecodeError) as error:
+            raise ReportWorkspaceError(
+                f"cannot inspect publication result {path}: {error}"
+            ) from error
+        absolute = publication_absolute_paths(payload)
+        if absolute:
+            raise ReportWorkspaceError(
+                f"publication result retains absolute host paths: "
+                f"{path.name}: {absolute[:3]}"
+            )
+
+
+def _campaign_commands(profile: str, policy: CampaignPolicy) -> str:
+    if policy is X86_EPYC_POLICY:
+        populate_options = (
+            f"  --workers {X86_EPYC_WORKERS} --cell-cores 1 "
+            "--target-runtime 5 \\\n"
+            "  --max-ram-gb 80 --allow-symbolica-parallel --refresh-pdf end"
+        )
+    elif policy is MACBOOK_M3_POLICY:
+        populate_options = (
+            "  --workers 1 --cell-cores 1 --target-runtime 5 \\\n"
+            "  --max-ram-gb 30 --refresh-pdf end"
+        )
+    else:
+        populate_options = (
+            "  --workers 1 --cell-cores 1 --target-runtime 5 --refresh-pdf end"
+        )
+    return "\n".join(
+        line
+        for multiplicity in range(1, 10)
+        for line in (
+            f"python3 docs/performance_reports/{profile}/result_tables.py populate \\",
+            f"  --n-final {multiplicity} --missing-only --artifact-policy reuse \\",
+            populate_options,
+            f"python3 docs/performance_reports/{profile}/result_tables.py audit",
+            "",
+        )
+    ).rstrip()
+
+
+def _workspace_readme(profile: str, policy: CampaignPolicy) -> str:
+    return f"""<!-- SPDX-License-Identifier: 0BSD -->
+# pyAmpliCol performance report: `{profile}`
+
+This directory is the self-contained publication workspace for the
+`{profile}` measurement environment. It contains the report's LaTeX sources,
+canonical raw JSON measurements, generated table TeX, and the PDF when it has
+been compiled. Large evaluator artifacts, worker logs, locks, and coordination
+state are deliberately stored outside this tracked directory.
+
+`{TABLE_FILLING_RUNBOOK}` is the sole authoritative campaign procedure. Follow
+its phase ordering, resource limits, user-approval pauses, numerical gates,
+visual-review cadence, branch coordination, and publication allowlist. This
+README intentionally contains no shortened measurement recipe.
+
+Compile this publication folder on any machine with Python and pdfLaTeX:
+
+```bash
+cd docs/performance_reports/{profile}
+python3 {STANDALONE_BUILDER}
+```
+
+From a pyAmpliCol source checkout, regenerate tables and run the cache audit
+with:
+
+```bash
+python3 docs/performance_reports/{profile}/result_tables.py render --compile
+python3 docs/performance_reports/{profile}/result_tables.py audit
+```
+
+Create a portable copy, including raw data, TeX, and the reviewed PDF, from a
+source checkout with:
+
+```bash
+python3 {CANONICAL_REPORT_ENTRYPOINT.as_posix()} \
+  export-profile {profile} /absolute/output/path
+```
+
+The copied entry point selects this profile automatically. Measurements still
+require the exact pyAmpliCol source checkout and authenticated native runtime.
+Never commit evaluator artifacts, candidate wheels, prepared models, attempts,
+logs, locks, coordination state, page images, or LaTeX auxiliary files.
+"""
+
+
+def _table_filling_runbook(profile: str, policy: CampaignPolicy) -> str:
+    if policy is X86_EPYC_POLICY:
+        resources = (
+            f"Run up to {X86_EPYC_WORKERS} independent workers, with one core "
+            "and a decimal 80 GB authenticated process-tree memory guard per "
+            "worker (RSS on Linux; max(process-tree RSS, Darwin physical "
+            "footprint) if enforced on macOS). The authenticated generation "
+            "phase is capped at two hours except for original AmpliCol and "
+            "compiled/recurrence LC selected-flow cells, which must finish. "
+            "Legacy v2 RSS-only censor evidence remains readable, but every "
+            "new run records the guard metric ABI and exact reason."
+        )
+    elif policy is MACBOOK_M3_POLICY:
+        resources = (
+            "Run exactly one worker on one core with a decimal 30 GB "
+            "authenticated memory guard defined as max(process-tree RSS, "
+            "Darwin physical footprint). Legacy v2 RSS-only censor evidence "
+            "remains readable, but every new run records the guard metric ABI "
+            "and exact reason. No generation timeout is authorized for this "
+            "profile."
+        )
+    else:
+        resources = "Run one worker on one core without policy censors."
+    return f"""<!-- SPDX-License-Identifier: 0BSD -->
+# Complete table-filling campaign for `{profile}`
+
+Start from a clean checkout of the exact committed measurement SHA and a clean
+native build authenticated by `refresh-profile-environment`. Populate the full
+catalog in increasing final-state multiplicity from `n=1` through `n=9`.
+{resources}
+
+Every successful pyAmpliCol result must pass the configured numerical
+comparison. A direct hard-resource boundary is recorded canonically; higher
+multiplicities in the same execution lane receive authenticated frontier
+markers and are not launched. Do not replace failures with hand-written table
+text.
+
+Run each multiplicity separately:
+
+```bash
+{_campaign_commands(profile, policy)}
+```
+
+After every populate step, rebuild the PDF, inspect every refreshed page and
+table visually, and confirm that values, ratios, status markers, and summary
+rows are plausible. Investigate and fix any numerical mismatch before
+continuing. Publish only canonical JSON results, generated table TeX,
+environment metadata, and the reviewed PDF; never publish evaluator artifacts,
+logs, locks, or worker checkouts.
+"""
+
+
+def _processor_description() -> str:
+    commands = (
+        ("sysctl", "-n", "machdep.cpu.brand_string"),
+        ("sysctl", "-n", "hw.model"),
+    )
+    if platform.system() == "Darwin":
+        for command in commands:
+            try:
+                completed = subprocess.run(
+                    command,
+                    check=False,
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+            except (OSError, subprocess.SubprocessError):
+                continue
+            value = completed.stdout.strip()
+            if completed.returncode == 0 and value:
+                return value
+    if platform.system() == "Linux":
+        try:
+            for line in (
+                Path("/proc/cpuinfo")
+                .read_text(
+                    encoding="utf-8",
+                    errors="replace",
+                )
+                .splitlines()
+            ):
+                key, separator, value = line.partition(":")
+                if separator and key.strip() in {"model name", "Hardware"}:
+                    rendered = value.strip()
+                    if rendered:
+                        return rendered
+        except OSError:
+            pass
+    return platform.processor().strip()
+
+
+def _host_environment_payload(profile: str) -> dict[str, str]:
+    processor = _processor_description()
+    machine = platform.machine().strip() or "unknown architecture"
+    platform_parts = [
+        f"{platform.system()} {platform.release()}".strip(),
+        machine,
+    ]
+    if processor and processor.lower() != machine.lower():
+        platform_parts.append(processor)
+    return {
+        "schema": ENVIRONMENT_SCHEMA,
+        "profile": profile,
+        "platform": "; ".join(platform_parts),
+        "machine": machine,
+        "processor": processor,
+        "python": platform.python_version(),
+        "python_implementation": platform.python_implementation(),
+    }
+
+
+def _recorded_host_environment_payload(
+    profile: str,
+    host_environment: Mapping[str, object],
+) -> dict[str, str]:
+    required = {
+        "platform",
+        "machine",
+        "processor",
+        "python",
+        "python_implementation",
+        "numpy",
+    }
+    if set(host_environment) != required:
+        raise ReportWorkspaceError(
+            "recorded measurement-host environment has an invalid shape"
+        )
+    processor = host_environment.get("processor")
+    if not isinstance(processor, str):
+        raise ReportWorkspaceError(
+            "recorded measurement-host processor label must be a string"
+        )
+    return {
+        "schema": ENVIRONMENT_SCHEMA,
+        "profile": profile,
+        "platform": _required_text(
+            host_environment.get("platform"),
+            "recorded measurement-host platform",
+        ),
+        "machine": _required_text(
+            host_environment.get("machine"),
+            "recorded measurement-host machine",
+        ),
+        "processor": processor,
+        "python": _required_text(
+            host_environment.get("python"),
+            "recorded measurement-host Python version",
+        ),
+        "python_implementation": _required_text(
+            host_environment.get("python_implementation"),
+            "recorded measurement-host Python implementation",
+        ),
+        "numpy": _required_text(
+            host_environment.get("numpy"),
+            "recorded measurement-host NumPy version",
+        ),
+    }
+
+
+def _pending_environment_payload(profile: str) -> dict[str, str]:
+    pending_host = "pending measurement-host authentication"
+    return {
+        "schema": ENVIRONMENT_SCHEMA,
+        "profile": profile,
+        "platform": pending_host,
+        "machine": pending_host,
+        "processor": pending_host,
+        "python": pending_host,
+        "python_implementation": pending_host,
+        "status": "pending_exact_runtime",
+        "source_revision": "pending",
+        "pyamplicol": _PENDING_RUNTIME,
+        "numpy": _PENDING_RUNTIME,
+        "native_target": _PENDING_RUNTIME,
+        "native_cpu_features": _PENDING_RUNTIME,
+        "native_build_inputs_sha256": "pending",
+        "native_extension_sha256": "pending",
+        "python_package_tree_sha256": "pending",
+        "candidate_fingerprint": "pending",
+    }
+
+
+def _required_text(
+    value: object,
+    context: str,
+) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise ReportWorkspaceError(f"{context} must be a non-empty string")
+    return value
+
+
+def _authenticated_environment_payload(
+    profile: str,
+    *,
+    expected_source_revision: str,
+    active_runtime: Mapping[str, object],
+    host_environment: Mapping[str, object] | None = None,
+) -> dict[str, str]:
+    package_version = _required_text(
+        active_runtime.get("package_version"),
+        "active runtime package_version",
+    )
+    native_target = active_runtime.get("native_target")
+    if not isinstance(native_target, Mapping):
+        raise ReportWorkspaceError("active runtime native_target must be an object")
+    target_triple = _required_text(
+        native_target.get("triple"),
+        "active runtime native target triple",
+    )
+    raw_features = native_target.get("cpu_features")
+    if not isinstance(raw_features, list) or not all(
+        isinstance(feature, str) and feature for feature in raw_features
+    ):
+        raise ReportWorkspaceError(
+            "active runtime native CPU features must be a string list"
+        )
+    native_digest = _required_text(
+        active_runtime.get("native_build_inputs_sha256"),
+        "active runtime native build-input digest",
+    )
+    if re.fullmatch(r"[0-9a-f]{64}", native_digest) is None:
+        raise ReportWorkspaceError(
+            "active runtime native build-input digest is not SHA-256"
+        )
+    native_extension = active_runtime.get("native_extension")
+    python_package_tree = active_runtime.get("python_package_tree")
+    candidate_identity = active_runtime.get("candidate_build_identity")
+    if (
+        not isinstance(native_extension, Mapping)
+        or not isinstance(python_package_tree, Mapping)
+        or not isinstance(candidate_identity, Mapping)
+    ):
+        raise ReportWorkspaceError(
+            "active runtime file and candidate identities must be objects"
+        )
+    candidate_source_revision = candidate_identity.get("source_revision")
+    if candidate_source_revision != expected_source_revision:
+        raise ReportWorkspaceError(
+            "active runtime build identity differs from the expected source revision"
+        )
+    native_extension_digest = _required_text(
+        native_extension.get("sha256"),
+        "active runtime native extension digest",
+    )
+    package_tree_digest = _required_text(
+        python_package_tree.get("sha256"),
+        "active runtime Python package-tree digest",
+    )
+    if any(
+        re.fullmatch(r"[0-9a-f]{64}", digest) is None
+        for digest in (native_extension_digest, package_tree_digest)
+    ):
+        raise ReportWorkspaceError("active runtime file identity digest is not SHA-256")
+    raw_candidate_fingerprint = candidate_identity.get("candidate_fingerprint")
+    if (
+        raw_candidate_fingerprint is None
+        and candidate_identity.get("publishable") is True
+    ):
+        release_identity = _required_text(
+            active_runtime.get("candidate_build_identity_sha256"),
+            "active release runtime build-identity digest",
+        )
+        if re.fullmatch(r"[0-9a-f]{64}", release_identity) is None:
+            raise ReportWorkspaceError(
+                "active release runtime build-identity digest is not SHA-256"
+            )
+        raw_candidate_fingerprint = f"release:{release_identity}"
+    candidate_fingerprint = _required_text(
+        raw_candidate_fingerprint,
+        "active runtime candidate fingerprint",
+    )
+    if host_environment is None:
+        host_payload = _host_environment_payload(profile)
+        numpy = importlib.import_module("numpy")
+        numpy_version = _required_text(
+            getattr(numpy, "__version__", None),
+            "active NumPy version",
+        )
+    else:
+        host_payload = _recorded_host_environment_payload(profile, host_environment)
+        numpy_version = host_payload.pop("numpy")
+    return {
+        **host_payload,
+        "status": "authenticated",
+        "source_revision": expected_source_revision,
+        "pyamplicol": package_version,
+        "numpy": numpy_version,
+        "native_target": target_triple,
+        "native_cpu_features": ", ".join(raw_features) or "baseline",
+        "native_build_inputs_sha256": native_digest,
+        "native_extension_sha256": native_extension_digest,
+        "python_package_tree_sha256": package_tree_digest,
+        "candidate_fingerprint": candidate_fingerprint,
+    }
+
+
+def _tex_escape(value: str) -> str:
+    replacements = {
+        "\\": r"\textbackslash{}",
+        "&": r"\&",
+        "%": r"\%",
+        "$": r"\$",
+        "#": r"\#",
+        "_": r"\_",
+        "{": r"\{",
+        "}": r"\}",
+        "~": r"\textasciitilde{}",
+        "^": r"\textasciicircum{}",
+    }
+    return "".join(replacements.get(character, character) for character in value)
+
+
+def _environment_tex(environment: Mapping[str, str]) -> str:
+    toolchain = (
+        "pending an authenticated post-checkpoint build"
+        if environment["status"] == "pending_exact_runtime"
+        else (
+            f"{environment['python_implementation']} "
+            f"{environment['python']}; pyAmpliCol {environment['pyamplicol']}; "
+            f"NumPy {environment['numpy']}; native {environment['native_target']}"
+        )
+    )
+    return (
+        "% SPDX-License-Identifier: 0BSD\n"
+        "% Generated architecture-profile metadata; do not edit by hand.\n"
+        rf"\renewcommand{{\ReportProfileName}}{{"
+        f"{_tex_escape(environment['profile'])}}}\n"
+        rf"\renewcommand{{\ReportPlatformSummary}}{{"
+        f"{_tex_escape(environment['platform'])}}}\n"
+        rf"\renewcommand{{\ReportToolchainSummary}}{{"
+        f"{_tex_escape(toolchain)}}}\n"
+        "\\renewcommand{\\ReportEditionStatement}{"
+        "This document is an architecture-specific edition.}\n"
+    )
+
+
+def _stable_environment_identity(
+    environment: Mapping[str, str],
+) -> dict[str, str]:
+    """Project an environment onto measurement-relevant identity fields.
+
+    ``processor`` is a display-only label.  On macOS it normally comes from
+    ``sysctl`` but falls back to :func:`platform.processor` when sandbox policy
+    denies that query.  Validate and remove only that canonical Darwin display
+    suffix; non-Darwin processor labels and every system/release, machine,
+    Python, source, candidate, native, and package identity remain exact.
+    """
+
+    platform_summary = _required_text(
+        environment.get("platform"),
+        "profile environment platform summary",
+    )
+    machine = _required_text(
+        environment.get("machine"),
+        "profile environment machine",
+    )
+    processor = environment.get("processor")
+    if not isinstance(processor, str):
+        raise ReportWorkspaceError(
+            "profile environment processor label must be a string"
+        )
+
+    canonical_platform = platform_summary
+    if processor and processor.casefold() != machine.casefold():
+        processor_suffix = f"; {processor}"
+        if not canonical_platform.endswith(processor_suffix):
+            raise ReportWorkspaceError(
+                "profile environment platform summary does not match its "
+                "processor label"
+            )
+        canonical_platform = canonical_platform[: -len(processor_suffix)]
+
+    machine_suffix = f"; {machine}"
+    if (
+        not canonical_platform.endswith(machine_suffix)
+        or not canonical_platform[: -len(machine_suffix)].strip()
+    ):
+        raise ReportWorkspaceError(
+            "profile environment platform summary does not identify its "
+            "system, release, and machine"
+        )
+
+    identity = dict(environment)
+    system_release = canonical_platform[: -len(machine_suffix)].strip()
+    system, separator, release = system_release.partition(" ")
+    if not separator or not system or not release.strip():
+        raise ReportWorkspaceError(
+            "profile environment platform summary does not identify separate "
+            "system and release values"
+        )
+    if system == "Darwin":
+        identity["platform"] = canonical_platform
+        identity.pop("processor", None)
+    return identity
+
+
+def _workspace_manifest(
+    repo_root: Path,
+    *,
+    profile: str,
+    source_profile: str | None,
+    reset_measurements: bool,
+    environment: Mapping[str, str],
+    policy: CampaignPolicy,
+) -> dict[str, object]:
+    paths = ReportPaths.from_repo(repo_root, profile=profile)
+    try:
+        source = inspect_report_source(repo_root)
+        source_record: dict[str, object] = {
+            "schema": SOURCE_IDENTITY_SCHEMA,
+            "revision": source.revision,
+            "tree": source.tree,
+            "clean": source.eligible,
+            "dirty_paths": list(source.dirty_paths),
+        }
+    except ReportSourceIdentityError:
+        source_record = {
+            "schema": SOURCE_IDENTITY_SCHEMA,
+            "revision": "unknown",
+            "tree": "unknown",
+            "clean": False,
+            "dirty_paths": [],
+        }
+    return {
+        "schema": WORKSPACE_SCHEMA,
+        "profile": profile,
+        "report_source_revision": source_record["revision"],
+        "report_source_tree": source_record["tree"],
+        "initialized_source_identity": source_record,
+        "initialized_from": (
+            CANONICAL_REPORT_ROOT.as_posix()
+            if source_profile is None
+            else f"docs/performance_reports/{source_profile}"
+        ),
+        "measurement_state": "reset" if reset_measurements else "copied",
+        "campaign_policy": policy.as_manifest(),
+        "document": "pyAmpliCol.tex",
+        "environment_json": ENVIRONMENT_JSON,
+        "environment_tex": ENVIRONMENT_TEX,
+        "initialized_environment": dict(environment),
+        "measurement_environment_contract": (
+            "refresh generated environment JSON/TeX after the exact-source "
+            "clean build and before population"
+        ),
+        "raw_results": "results",
+        "artifact_root": paths.artifact_root.relative_to(repo_root).as_posix(),
+        "coordination_root": paths.coordination_root.relative_to(repo_root).as_posix(),
+        "tracked_content": [
+            "*.tex",
+            ENVIRONMENT_JSON,
+            MEASUREMENT_LINEAGE_JSON,
+            "results/*.json",
+            "README.md",
+            TABLE_FILLING_RUNBOOK,
+            WORKSPACE_MANIFEST,
+            STANDALONE_BUILDER,
+            "result_tables.py",
+            "pyAmpliCol.pdf (when compiled and reviewed)",
+        ],
+        "excluded_content": [
+            ".artifacts evaluator attempts",
+            "worker logs",
+            "locks and coordination state",
+            "LaTeX auxiliary files",
+        ],
+    }
+
+
+def initialize_profile(
+    repo_root: Path,
+    profile: str,
+    *,
+    source_profile: str | None = None,
+    reset_measurements: bool = False,
+    measurement_policy: str | None = None,
+    require_source_audit: bool = True,
+) -> Path:
+    """Create a new tracked report profile atomically.
+
+    The destination must not already exist. ``reset_measurements`` rebuilds the
+    caches and generated table inputs from the catalog and never carries a PDF
+    from the source profile.
+    """
+
+    root = repo_root.expanduser().resolve(strict=False)
+    validated = validate_profile_name(profile)
+    policy = (
+        default_campaign_policy(validated)
+        if measurement_policy is None
+        else campaign_policy(measurement_policy)
+    )
+    validate_policy_profile(policy, validated)
+    if source_profile is not None:
+        source_profile = validate_profile_name(source_profile)
+        if source_profile == validated:
+            raise ValueError("source and destination report profiles must differ")
+    source = _source_docs_dir(root, source_profile=source_profile)
+    target = profile_docs_dir(root, validated)
+    if target.exists():
+        raise ReportWorkspaceError(f"report profile already exists: {target}")
+
+    parent = target.parent
+    parent.mkdir(parents=True, exist_ok=True)
+    staging = parent / f".{validated}.init-{uuid.uuid4().hex}"
+    state_root = (
+        root / ".artifacts" / "performance-report-workspace-init" / uuid.uuid4().hex
+    )
+    try:
+        source_paths = ReportPaths.from_repo(root, profile=source_profile)
+        source_service = ReportService(source_paths)
+        with source_service.store.named_lock("report-writer"):
+            source_lineage = source / MEASUREMENT_LINEAGE_JSON
+            if source_lineage.exists() and not reset_measurements:
+                raise ReportWorkspaceError(
+                    "a profile with mixed Class-C source lineage can only seed a "
+                    "new profile with reset_measurements=True"
+                )
+            if require_source_audit:
+                source_service.audit()
+            _copy_publication_members(source, staging)
+        _install_standalone_builder(staging)
+        target_paths = ReportPaths.from_repo(root, profile=validated)
+        if reset_measurements and (
+            target_paths.artifact_root.exists()
+            and any(target_paths.artifact_root.iterdir())
+        ):
+            raise ReportWorkspaceError(
+                "reset profile artifact root already contains local state: "
+                f"{target_paths.artifact_root}"
+            )
+        paths = ReportPaths.from_repo(
+            root,
+            docs_dir=staging,
+            artifact_root=(
+                target_paths.artifact_root
+                if reset_measurements
+                else source_paths.artifact_root
+            ),
+            coordination_root=state_root / "coordination",
+        )
+        service = ReportService(paths)
+        if reset_measurements:
+            service.publish(reset=True, merge_artifacts=False)
+        else:
+            service.publish(reset=False, merge_artifacts=False)
+        service.audit()
+        _assert_portable_results(staging)
+
+        environment = _pending_environment_payload(validated)
+        (staging / ENVIRONMENT_JSON).write_text(
+            _canonical_json(environment),
+            encoding="ascii",
+        )
+        (staging / ENVIRONMENT_TEX).write_text(
+            _environment_tex(environment),
+            encoding="utf-8",
+        )
+        (staging / "README.md").write_text(
+            _workspace_readme(validated, policy),
+            encoding="utf-8",
+        )
+        (staging / TABLE_FILLING_RUNBOOK).write_text(
+            _table_filling_runbook(validated, policy),
+            encoding="utf-8",
+        )
+        manifest = _workspace_manifest(
+            root,
+            profile=validated,
+            source_profile=source_profile,
+            reset_measurements=reset_measurements,
+            environment=environment,
+            policy=policy,
+        )
+        (staging / WORKSPACE_MANIFEST).write_text(
+            _canonical_json(manifest),
+            encoding="ascii",
+        )
+        staging.replace(target)
+    except BaseException:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise
+    finally:
+        shutil.rmtree(state_root, ignore_errors=True)
+    return target
+
+
+def _read_environment_payload(path: Path) -> dict[str, str]:
+    try:
+        raw = json.loads(path.read_text(encoding="ascii"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise ReportWorkspaceError(
+            f"invalid or missing report environment metadata: {path}"
+        ) from error
+    required = {
+        "schema",
+        "profile",
+        "status",
+        "source_revision",
+        "platform",
+        "machine",
+        "processor",
+        "python",
+        "python_implementation",
+        "pyamplicol",
+        "numpy",
+        "native_target",
+        "native_cpu_features",
+        "native_build_inputs_sha256",
+        "native_extension_sha256",
+        "python_package_tree_sha256",
+        "candidate_fingerprint",
+    }
+    if (
+        not isinstance(raw, dict)
+        or set(raw) != required
+        or not all(isinstance(value, str) for value in raw.values())
+    ):
+        raise ReportWorkspaceError(
+            f"report environment metadata has an invalid shape: {path}"
+        )
+    return raw
+
+
+def record_authenticated_profile_environment(
+    docs_dir: Path,
+    profile: str,
+    *,
+    expected_source_revision: str,
+    active_runtime: Mapping[str, object],
+    host_environment: Mapping[str, object] | None = None,
+) -> dict[str, str]:
+    """Record one already-authenticated runtime in an explicit report directory.
+
+    This is the destination-explicit write boundary shared by source-checkout
+    profiles and portable campaign publication.  It deliberately does not
+    authenticate ``active_runtime`` itself: callers must either use
+    :func:`refresh_profile_environment` or supply runtime evidence already
+    validated as part of a successful campaign measurement.
+    """
+
+    validated = validate_profile_name(profile)
+    if _GIT_SHA_RE.fullmatch(expected_source_revision) is None:
+        raise ReportWorkspaceError(
+            "profile environment source revision must be a full Git SHA"
+        )
+    destination = docs_dir.expanduser().resolve(strict=True)
+    if not destination.is_dir():
+        raise ReportWorkspaceError(
+            f"profile environment destination is not a directory: {destination}"
+        )
+    environment = _authenticated_environment_payload(
+        validated,
+        expected_source_revision=expected_source_revision,
+        active_runtime=active_runtime,
+        host_environment=host_environment,
+    )
+    json_path = destination / ENVIRONMENT_JSON
+    tex_path = destination / ENVIRONMENT_TEX
+    temporary_json = json_path.with_name(f".{json_path.name}.{uuid.uuid4().hex}")
+    temporary_tex = tex_path.with_name(f".{tex_path.name}.{uuid.uuid4().hex}")
+    expected_tex = _environment_tex(environment)
+    try:
+        temporary_json.write_text(_canonical_json(environment), encoding="ascii")
+        temporary_tex.write_text(expected_tex, encoding="utf-8")
+        temporary_json.replace(json_path)
+        temporary_tex.replace(tex_path)
+    finally:
+        temporary_json.unlink(missing_ok=True)
+        temporary_tex.unlink(missing_ok=True)
+    recorded = _read_environment_payload(json_path)
+    try:
+        recorded_tex = tex_path.read_text(encoding="utf-8")
+    except OSError as error:
+        raise ReportWorkspaceError(
+            f"profile environment TeX is unavailable: {tex_path}"
+        ) from error
+    if recorded != environment or recorded_tex != expected_tex:
+        raise ReportWorkspaceError(
+            "recorded profile environment differs from its authenticated payload"
+        )
+    return recorded
+
+
+def require_authenticated_profile_environment(
+    repo_root: Path,
+    profile: str,
+    *,
+    expected_source_revision: str,
+) -> dict[str, str]:
+    """Require exact-source runtime metadata before profile measurement."""
+
+    validated = validate_profile_name(profile)
+    if _GIT_SHA_RE.fullmatch(expected_source_revision) is None:
+        raise ReportWorkspaceError(
+            "profile environment source revision must be a full Git SHA"
+        )
+    path = profile_docs_dir(repo_root, validated)
+    environment = _read_environment_payload(path / ENVIRONMENT_JSON)
+    if (
+        environment["schema"] != ENVIRONMENT_SCHEMA
+        or environment["profile"] != validated
+        or environment["status"] != "authenticated"
+        or environment["source_revision"] != expected_source_revision
+    ):
+        raise ReportWorkspaceError(
+            "profile environment is not authenticated for measurement source "
+            f"{expected_source_revision}; run refresh-profile-environment after "
+            "the exact-source clean build"
+        )
+    expected_tex = _environment_tex(environment)
+    try:
+        observed_tex = (path / ENVIRONMENT_TEX).read_text(encoding="utf-8")
+    except OSError as error:
+        raise ReportWorkspaceError(
+            f"profile environment TeX is unavailable: {path / ENVIRONMENT_TEX}"
+        ) from error
+    if observed_tex != expected_tex:
+        raise ReportWorkspaceError(
+            "profile environment JSON and generated TeX do not match"
+        )
+    return environment
+
+
+def refresh_profile_environment(
+    repo_root: Path,
+    profile: str,
+    *,
+    expected_source_revision: str,
+    runtime_auditor: Callable[[str, Path], Mapping[str, object]] | None = None,
+    _skip_workspace_validation: bool = False,
+) -> dict[str, str]:
+    """Authenticate and record the exact installed measurement runtime."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    validated = validate_profile_name(profile)
+    if _GIT_SHA_RE.fullmatch(expected_source_revision) is None:
+        raise ReportWorkspaceError(
+            "profile environment source revision must be a full Git SHA"
+        )
+    if not _skip_workspace_validation:
+        _validate_workspace(root, validated)
+    source = inspect_report_source(root)
+    if not source.eligible or source.revision != expected_source_revision:
+        raise ReportWorkspaceError(
+            "profile environment refresh requires a clean evaluator source "
+            "checkout at the requested full Git SHA"
+        )
+    if runtime_auditor is None:
+        from .final_audit import _audit_active_runtime
+
+        runtime_auditor = _audit_active_runtime
+    try:
+        active_runtime = runtime_auditor(expected_source_revision, root)
+    except Exception as error:
+        raise ReportWorkspaceError(
+            "installed pyAmpliCol runtime is not authenticated for the "
+            "requested measurement source"
+        ) from error
+    profile_dir = profile_docs_dir(root, validated)
+    record_authenticated_profile_environment(
+        profile_dir,
+        validated,
+        expected_source_revision=expected_source_revision,
+        active_runtime=active_runtime,
+    )
+    return require_authenticated_profile_environment(
+        root,
+        validated,
+        expected_source_revision=expected_source_revision,
+    )
+
+
+def require_active_profile_environment(
+    repo_root: Path,
+    profile: str,
+    *,
+    expected_source_revision: str,
+    runtime_auditor: Callable[[str, Path], Mapping[str, object]] | None = None,
+) -> dict[str, str]:
+    """Require recorded metadata to equal the currently active exact runtime."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    validated = validate_profile_name(profile)
+    recorded = require_authenticated_profile_environment(
+        root,
+        validated,
+        expected_source_revision=expected_source_revision,
+    )
+    if runtime_auditor is None:
+        from .final_audit import _audit_active_runtime
+
+        runtime_auditor = _audit_active_runtime
+    try:
+        active_runtime = runtime_auditor(expected_source_revision, root)
+    except Exception as error:
+        raise ReportWorkspaceError(
+            "active pyAmpliCol runtime is not authenticated for the requested "
+            "measurement source"
+        ) from error
+    active = _authenticated_environment_payload(
+        validated,
+        expected_source_revision=expected_source_revision,
+        active_runtime=active_runtime,
+    )
+    if _stable_environment_identity(active) != _stable_environment_identity(recorded):
+        raise ReportWorkspaceError(
+            "active measurement runtime differs from the authenticated profile "
+            "environment; rerun refresh-profile-environment"
+        )
+    return recorded
+
+
+def _read_workspace_manifest(path: Path) -> dict[str, object]:
+    try:
+        raw = json.loads(path.read_text(encoding="ascii"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise ReportWorkspaceError(
+            f"invalid or missing report workspace manifest: {path}"
+        ) from error
+    if not isinstance(raw, dict):
+        raise ReportWorkspaceError(
+            f"report workspace manifest is not an object: {path}"
+        )
+    return raw
+
+
+def _committed_workspace_manifest(
+    repo_root: Path,
+    profile: str,
+    revision: str,
+) -> dict[str, object]:
+    if _GIT_SHA_RE.fullmatch(revision) is None:
+        raise ReportWorkspaceError(
+            "workspace policy authentication requires a full Git SHA"
+        )
+    relative = (PROFILE_PARENT / profile / WORKSPACE_MANIFEST).as_posix()
+    try:
+        completed = subprocess.run(
+            ("git", "show", f"{revision}:{relative}"),
+            cwd=repo_root,
+            check=False,
+            capture_output=True,
+            timeout=15,
+        )
+    except (OSError, subprocess.SubprocessError) as error:
+        raise ReportWorkspaceError(
+            "cannot read measured-source workspace policy"
+        ) from error
+    if completed.returncode != 0:
+        detail = completed.stderr.decode("utf-8", errors="replace").strip()
+        raise ReportWorkspaceError(
+            "measured source does not contain the selected report workspace: "
+            f"{detail or f'exit {completed.returncode}'}"
+        )
+    try:
+        raw = json.loads(completed.stdout.decode("ascii"))
+    except (UnicodeError, json.JSONDecodeError) as error:
+        raise ReportWorkspaceError(
+            "measured-source workspace manifest is malformed"
+        ) from error
+    if not isinstance(raw, dict):
+        raise ReportWorkspaceError(
+            "measured-source workspace manifest is not an object"
+        )
+    return raw
+
+
+def load_profile_campaign_policy(
+    repo_root: Path,
+    profile: str,
+    *,
+    expected_source_revision: str | None = None,
+) -> CampaignPolicy:
+    """Load the canonical policy, optionally authenticating its measured SHA."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    validated = validate_profile_name(profile)
+    manifest = _read_workspace_manifest(
+        profile_docs_dir(root, validated) / WORKSPACE_MANIFEST
+    )
+    if (
+        manifest.get("schema") != WORKSPACE_SCHEMA
+        or manifest.get("profile") != validated
+    ):
+        raise ReportWorkspaceError(
+            f"workspace manifest does not identify profile {validated!r}"
+        )
+    try:
+        policy = policy_from_manifest(
+            manifest.get("campaign_policy"),
+            profile=validated,
+        )
+    except CampaignPolicyError as error:
+        raise ReportWorkspaceError(str(error)) from error
+    if expected_source_revision is not None:
+        committed = _committed_workspace_manifest(
+            root,
+            validated,
+            expected_source_revision,
+        )
+        if (
+            committed.get("schema") != WORKSPACE_SCHEMA
+            or committed.get("profile") != validated
+            or committed.get("campaign_policy") != manifest.get("campaign_policy")
+        ):
+            raise ReportWorkspaceError(
+                "active workspace campaign policy differs from the exact "
+                "measured-source commit"
+            )
+        try:
+            committed_policy = policy_from_manifest(
+                committed.get("campaign_policy"),
+                profile=validated,
+            )
+        except CampaignPolicyError as error:
+            raise ReportWorkspaceError(str(error)) from error
+        if committed_policy is not policy:
+            raise ReportWorkspaceError(
+                "workspace policy identity is not stable at measured source"
+            )
+    return policy
+
+
+def _validate_workspace(
+    repo_root: Path,
+    profile: str,
+    *,
+    service: ReportService | None = None,
+) -> Path:
+    root = repo_root.expanduser().resolve(strict=False)
+    path = profile_docs_dir(root, profile)
+    manifest_path = path / WORKSPACE_MANIFEST
+    manifest = _read_workspace_manifest(manifest_path)
+    if (
+        not isinstance(manifest, dict)
+        or manifest.get("schema") != WORKSPACE_SCHEMA
+        or manifest.get("profile") != profile
+        or manifest.get("environment_json") != ENVIRONMENT_JSON
+        or manifest.get("environment_tex") != ENVIRONMENT_TEX
+    ):
+        raise ReportWorkspaceError(
+            f"workspace manifest does not identify profile {profile!r}"
+        )
+    if not (path / TABLE_FILLING_RUNBOOK).is_file():
+        raise ReportWorkspaceError(
+            f"workspace table-filling runbook is missing: "
+            f"{path / TABLE_FILLING_RUNBOOK}"
+        )
+    try:
+        policy_from_manifest(manifest.get("campaign_policy"), profile=profile)
+    except CampaignPolicyError as error:
+        raise ReportWorkspaceError(str(error)) from error
+    environment = _read_environment_payload(path / ENVIRONMENT_JSON)
+    if (
+        environment["schema"] != ENVIRONMENT_SCHEMA
+        or environment["profile"] != profile
+        or environment["status"] not in {"pending_exact_runtime", "authenticated"}
+        or (
+            environment["status"] == "pending_exact_runtime"
+            and environment["source_revision"] != "pending"
+        )
+        or (
+            environment["status"] == "authenticated"
+            and _GIT_SHA_RE.fullmatch(environment["source_revision"]) is None
+        )
+    ):
+        raise ReportWorkspaceError(
+            f"workspace environment does not identify profile {profile!r}"
+        )
+    try:
+        environment_tex = (path / ENVIRONMENT_TEX).read_text(encoding="utf-8")
+    except OSError as error:
+        raise ReportWorkspaceError(
+            f"invalid or missing workspace environment TeX: {path / ENVIRONMENT_TEX}"
+        ) from error
+    if environment_tex != _environment_tex(environment):
+        raise ReportWorkspaceError(
+            "workspace environment JSON and generated TeX do not match"
+        )
+    active = service or ReportService(ReportPaths.from_repo(root, profile=profile))
+    active.audit()
+    return path
+
+
+def export_profile(
+    repo_root: Path,
+    profile: str,
+    destination: Path,
+    *,
+    include_pdf: bool = True,
+) -> Path:
+    """Export publication inputs without evaluator artifacts or local state."""
+
+    root = repo_root.expanduser().resolve(strict=False)
+    validated = validate_profile_name(profile)
+    profile_paths = ReportPaths.from_repo(root, profile=validated)
+    source_service = ReportService(profile_paths)
+    target = destination.expanduser().resolve(strict=False)
+    if target.exists():
+        raise ReportWorkspaceError(f"export destination already exists: {target}")
+    target.parent.mkdir(parents=True, exist_ok=True)
+    staging = target.parent / f".{target.name}.export-{uuid.uuid4().hex}"
+    state_root = (
+        root / ".artifacts" / "performance-report-workspace-export" / uuid.uuid4().hex
+    )
+    try:
+        with source_service.store.named_lock("report-writer"):
+            source = _validate_workspace(
+                root,
+                validated,
+                service=source_service,
+            )
+            _copy_publication_members(source, staging)
+            _copy_measurement_lineage(source, staging)
+            for name in (
+                "README.md",
+                TABLE_FILLING_RUNBOOK,
+                WORKSPACE_MANIFEST,
+            ):
+                shutil.copy2(source / name, staging / name)
+        _install_standalone_builder(staging)
+        service = ReportService(
+            ReportPaths.from_repo(
+                root,
+                docs_dir=staging,
+                artifact_root=profile_paths.artifact_root,
+                coordination_root=state_root,
+            )
+        )
+        service.publish(reset=False, merge_artifacts=False)
+        service.audit()
+        _assert_portable_results(staging)
+        if include_pdf:
+            compile_report(staging)
+            for suffix in (
+                ".aux",
+                ".bbl",
+                ".bcf",
+                ".blg",
+                ".fdb_latexmk",
+                ".fls",
+                ".log",
+                ".out",
+                ".run.xml",
+                ".synctex.gz",
+                ".toc",
+            ):
+                (staging / f"pyAmpliCol{suffix}").unlink(missing_ok=True)
+        staging.replace(target)
+    except BaseException:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise
+    finally:
+        shutil.rmtree(state_root, ignore_errors=True)
+    return target
+
+
+__all__ = [
+    "ENVIRONMENT_JSON",
+    "ENVIRONMENT_SCHEMA",
+    "ENVIRONMENT_TEX",
+    "PROFILE_PARENT",
+    "STANDALONE_BUILDER",
+    "TABLE_FILLING_RUNBOOK",
+    "WORKSPACE_MANIFEST",
+    "WORKSPACE_SCHEMA",
+    "ReportWorkspaceError",
+    "export_profile",
+    "initialize_profile",
+    "load_profile_campaign_policy",
+    "profile_docs_dir",
+    "record_authenticated_profile_environment",
+    "refresh_profile_environment",
+    "require_active_profile_environment",
+    "require_authenticated_profile_environment",
+]
diff --git a/pyamplicol/tools/release/_artifacts.py b/pyamplicol/tools/release/_artifacts.py
new file mode 100644
index 0000000000..8566767357
--- /dev/null
+++ b/pyamplicol/tools/release/_artifacts.py
@@ -0,0 +1,1969 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Audit and compare pyAmpliCol release artifacts."""
+
+from __future__ import annotations
+
+import base64
+import csv
+import hashlib
+import importlib.util
+import io
+import json
+import os
+import platform
+import re
+import shlex
+import shutil
+import stat
+import subprocess
+import sys
+import tomllib
+import zipfile
+from collections.abc import Mapping
+from dataclasses import dataclass
+from email import policy
+from email.parser import BytesParser
+from functools import lru_cache
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+try:
+    from packaging.markers import Variable
+    from packaging.requirements import InvalidRequirement, Requirement
+    from packaging.version import InvalidVersion, Version
+except ModuleNotFoundError:  # pragma: no cover - pip vendors the build fallback
+    from pip._vendor.packaging.markers import Variable  # type: ignore[no-redef]
+    from pip._vendor.packaging.requirements import (  # type: ignore[no-redef]
+        InvalidRequirement,
+        Requirement,
+    )
+    from pip._vendor.packaging.version import (  # type: ignore[no-redef]
+        InvalidVersion,
+        Version,
+    )
+
+from _common import (
+    ROOT,
+    ReleaseError,
+    external_temporary_directory,
+    run,
+    safe_extract_sdist,
+    sha256,
+)
+from audit_sdist import (
+    PREPARED_MODEL_ARCHITECTURES,
+    PREPARED_MODEL_ASSETS,
+    REQUIRED_SDIST_MEMBERS,
+    prepared_model_asset_members,
+)
+from prepare_selftest_fixture import (
+    _artifact_id,
+    validate_artifact_identity_contract,
+    validate_portable_artifact_capabilities,
+    validate_portable_execution_manifest,
+)
+
+MAX_WHEEL_BYTES = 95_000_000
+EXPECTED_DISTRIBUTION = "pyamplicol"
+with (ROOT / "dependencies" / "release-lock.toml").open("rb") as _release_stream:
+    EXPECTED_RELEASE_VERSION = str(tomllib.load(_release_stream)["project"]["version"])
+EXPECTED_PYTHON_TAG = "cp311"
+EXPECTED_ABI_TAG = "abi3"
+RELEASE_TARGETS = {
+    "macosx_11_0_arm64": "aarch64-apple-darwin",
+    "macosx_11_0_x86_64": "x86_64-apple-darwin",
+    "manylinux_2_28_x86_64": "x86_64-unknown-linux-gnu",
+}
+_LINUX_PLATFORM_TAGS = {
+    "manylinux_2_28_x86_64",
+}
+_REQUIRED_SDK_PATHS = {
+    "rusticol_config/__init__.py",
+    "rusticol_config/__main__.py",
+    "pyamplicol/_sdk/include/rusticol.h",
+    "pyamplicol/_sdk/include/rusticol.hpp",
+    "pyamplicol/_sdk/fortran/rusticol.f90",
+    "pyamplicol/_sdk/rust/rusticol.rs",
+    "pyamplicol/_sdk/lib/librusticol_capi.a",
+    "pyamplicol/_sdk/config.py",
+    "pyamplicol/_sdk/metadata.json",
+    "pyamplicol/_sdk/link.json",
+}
+
+
+_FORBIDDEN_MEMBER_PARTS = {
+    ".git",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    "__pycache__",
+    "PYPI_DEPLOYMENT_TEST",
+    "target",
+}
+_REPOSITORY_PATH_MARKER = os.fsencode(str(ROOT.resolve()))
+_FORBIDDEN_PATH_MARKERS = (
+    b"/tmp/",
+    b"/var/tmp/",
+    b"/Users/",
+    b"/home/",
+    b"/private/var/folders/",
+    b"/opt/homebrew/",
+    b"/opt/local/",
+    b"/opt/python/",
+    b"/github/workspace/",
+    b"C:\\Users\\",
+    _REPOSITORY_PATH_MARKER,
+)
+_FORBIDDEN_NATIVE_RELATIVE_MARKERS = (b"../", b"..\\")
+_NATIVE_MEMBER_SUFFIXES = (".a", ".dylib", ".lib", ".pyd", ".so")
+_PATH_TOKEN_BYTES = frozenset(
+    b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._~+%-/\\"
+)
+_FORBIDDEN_CAPI_SYMBOLS = (
+    "pyobject",
+    "pyexc_",
+    "pygilstate",
+    "pyerr_",
+    "pylong_",
+    "pyunicode_",
+    "pymem_",
+    "pytype_",
+    "pytuple_",
+    "pylist_",
+    "pydict_",
+    "pymodule_",
+    "pyimport_",
+    "pybytes_",
+    "pycapsule_",
+    "pyfloat_",
+    "pybool_",
+    "pythread_",
+    "pyo3",
+    "numpy",
+    "python3",
+)
+_FORBIDDEN_CAPI_UNDEFINED_PREFIXES = (
+    *_FORBIDDEN_CAPI_SYMBOLS,
+    "py_",
+    "python",
+    "libpython",
+)
+_FORBIDDEN_STATIC_RUNTIME_MARKERS = (
+    "__gmp",
+    "gmp-mpfr-sys",
+    "malachite-base",
+    "malachite-nz",
+    "malachite-q",
+    "mpfr_",
+)
+_COMMON_SYSTEM_LIBRARIES = {"c", "dl", "m", "pthread", "resolv", "rt", "util"}
+_SYSTEM_LIBRARIES = {
+    "aarch64-apple-darwin": _COMMON_SYSTEM_LIBRARIES | {"System", "gcc_s", "iconv"},
+    "x86_64-apple-darwin": _COMMON_SYSTEM_LIBRARIES | {"System", "gcc_s", "iconv"},
+    "x86_64-unknown-linux-gnu": _COMMON_SYSTEM_LIBRARIES | {"gcc_s"},
+}
+_MACOS_FRAMEWORKS = {"CoreFoundation", "IOKit", "Security", "SystemConfiguration"}
+_CANONICAL_DEPENDENCY_LOCK = Path("dependencies/release-lock.toml")
+_CONTRIBUTOR_DEPENDENCY_LOCK = Path("dependencies/contributor-lock.toml")
+_CANDIDATE_INSTALL_STATE = Path("dependencies/install-state.json")
+_REQUIRED_PACKAGE_RESOURCES = {
+    "pyamplicol/assets/schemas/README.md",
+    "pyamplicol/assets/schemas/artifact-manifest-v3.schema.json",
+    "pyamplicol/assets/schemas/runtime-physics-v1.schema.json",
+}
+_REQUIRED_PACKAGED_EXAMPLE_MEMBERS = {
+    "pyamplicol/_examples/data/pp_zjj_momenta.json",
+}
+_REQUIRED_API_TEMPLATE_MEMBERS = {
+    "pyamplicol/assets/api_templates/c/Makefile",
+    "pyamplicol/assets/api_templates/c/check_standalone.c",
+    "pyamplicol/assets/api_templates/cpp/Makefile",
+    "pyamplicol/assets/api_templates/cpp/check_standalone.cpp",
+    "pyamplicol/assets/api_templates/fortran/Makefile",
+    "pyamplicol/assets/api_templates/fortran/check_standalone.f90",
+    "pyamplicol/assets/api_templates/python/check_standalone.py",
+    "pyamplicol/assets/api_templates/rust/Makefile",
+    "pyamplicol/assets/api_templates/rust/check_standalone.rs",
+    *(
+        f"pyamplicol/assets/api_templates/umami/{name}"
+        for name in (
+            "Makefile",
+            "README.md",
+            "UMAMI_LICENSE",
+            "umami.h",
+            "umami.c",
+            "umami_provider.h",
+            "umami_driver.c",
+            "umami.exports",
+            "umami.exports.macos",
+        )
+    ),
+}
+_PREPARED_MODEL_WHEEL_PREFIX = "pyamplicol/assets/prepared_models"
+_PREPARED_MODEL_SDIST_PREFIX = "src/pyamplicol/assets/prepared_models"
+_REQUIRED_PREPARED_MODEL_WHEEL_MEMBERS = prepared_model_asset_members(
+    _PREPARED_MODEL_WHEEL_PREFIX
+)
+_REQUIRED_WHEEL_PACKAGE_MEMBERS = {
+    "pyamplicol/__init__.py",
+    "pyamplicol/_build_info.json",
+    "pyamplicol/_rusticol.pyi",
+    "pyamplicol/py.typed",
+    *_REQUIRED_API_TEMPLATE_MEMBERS,
+    *_REQUIRED_PACKAGED_EXAMPLE_MEMBERS,
+    *_REQUIRED_PACKAGE_RESOURCES,
+    *_REQUIRED_PREPARED_MODEL_WHEEL_MEMBERS,
+    *_REQUIRED_SDK_PATHS,
+}
+_REQUIRED_SELFTEST_API_PAYLOADS = {
+    "API/validation_points.dat",
+    "API/python/check_standalone.py",
+    "API/c/Makefile",
+    "API/c/check_standalone.c",
+    "API/cpp/Makefile",
+    "API/cpp/check_standalone.cpp",
+    "API/fortran/Makefile",
+    "API/fortran/check_standalone.f90",
+    "API/rust/Makefile",
+    "API/rust/check_standalone.rs",
+}
+_COMPILED_MODEL_KIND = "pyamplicol-compiled-model"
+_BUILTIN_MODEL_SOURCE_KIND = "built-in-sm"
+_ALLOWED_REPAIR_ROOTS = {"pyamplicol.libs"}
+_FORBIDDEN_SDIST_MEMBERS = {
+    ".cargo/config.toml",
+    "build_backend/python_lock.py",
+    "dependencies/candidate-Cargo.lock",
+    "dependencies/candidate-cargo-config.toml",
+    "dependencies/contributor-lock.toml",
+    "dependencies/install-state.json",
+    "dependencies/install_dependencies.py",
+    "dependencies/python-runtime-lock.toml",
+    "dependencies/symbolica_patches.tar.gz",
+}
+_FORBIDDEN_SDIST_PREFIXES = (
+    "dependencies/checkouts/",
+    "dependencies/patches/",
+    "release_assets/",
+)
+_RELEASE_SYMJIT_FIELDS = {"version"}
+_RELEASE_BUILD_INFO_FIELDS = {
+    "publishable",
+    "schema_version",
+    "selftest_fixture_bootstrap",
+    "source_revision",
+    "version",
+}
+
+
+class ArtifactError(ReleaseError):
+    """An artifact violates the packaging contract."""
+
+
+@dataclass(frozen=True)
+class WheelReport:
+    filename: str
+    version: str
+    size: int
+    sha256: str
+    python_tag: str
+    abi_tag: str
+    target: str
+    rust_target: str
+    native_scan: bool
+
+
+@dataclass(frozen=True)
+class SdistReport:
+    filename: str
+    version: str
+    size: int
+    sha256: str
+
+
+def canonicalize_name(value: str) -> str:
+    return re.sub(r"[-_.]+", "-", value).lower()
+
+
+def _safe_member_name(name: str, *, archive: str) -> PurePosixPath:
+    stripped = name.rstrip("/")
+    if not stripped or "\\" in stripped:
+        raise ArtifactError(f"{archive} contains an unsafe member name: {name!r}")
+    relative = PurePosixPath(stripped)
+    if relative.is_absolute() or any(
+        part in {"", ".", ".."} for part in relative.parts
+    ):
+        raise ArtifactError(f"{archive} contains an unsafe member path: {name}")
+    if _FORBIDDEN_MEMBER_PARTS.intersection(relative.parts):
+        raise ArtifactError(f"{archive} contains forbidden build state: {name}")
+    return relative
+
+
+def _wheel_entries(path: Path) -> dict[str, bytes]:
+    entries: dict[str, bytes] = {}
+    try:
+        archive = zipfile.ZipFile(path)
+    except (OSError, zipfile.BadZipFile) as error:
+        raise ArtifactError(f"invalid wheel archive {path}: {error}") from error
+    with archive:
+        for info in archive.infolist():
+            relative = _safe_member_name(info.filename, archive="wheel")
+            name = relative.as_posix()
+            if info.is_dir():
+                continue
+            if name in entries:
+                raise ArtifactError(f"wheel contains duplicate member: {name}")
+            unix_mode = info.external_attr >> 16
+            if stat.S_ISLNK(unix_mode):
+                raise ArtifactError(f"wheel contains a symbolic link: {name}")
+            if info.flag_bits & 0x1:
+                raise ArtifactError(f"wheel contains an encrypted member: {name}")
+            entries[name] = archive.read(info)
+    return entries
+
+
+def _single_name(entries: dict[str, bytes], suffix: str) -> str:
+    matches = sorted(name for name in entries if name.endswith(suffix))
+    if len(matches) != 1:
+        raise ArtifactError(
+            f"wheel must contain exactly one {suffix}, found {len(matches)}"
+        )
+    return matches[0]
+
+
+def _parse_wheel_filename(path: Path) -> tuple[str, str, str, str]:
+    if path.suffix != ".whl":
+        raise ArtifactError(f"not a wheel filename: {path.name}")
+    fields = path.name[:-4].rsplit("-", 3)
+    if len(fields) != 4:
+        raise ArtifactError(f"invalid wheel filename: {path.name}")
+    prefix, python_tag, abi_tag, platform_tag = fields
+    distribution_version = prefix.rsplit("-", 1)
+    if len(distribution_version) != 2:
+        raise ArtifactError(f"invalid wheel distribution/version: {path.name}")
+    distribution, filename_version = distribution_version
+    if canonicalize_name(distribution) != EXPECTED_DISTRIBUTION:
+        raise ArtifactError(f"wheel distribution is not pyamplicol: {path.name}")
+    return filename_version, python_tag, abi_tag, platform_tag
+
+
+def _canonical_target(platform_tag: str, *, mode: str) -> tuple[str, str]:
+    components = set(platform_tag.split("."))
+    if components and components <= _LINUX_PLATFORM_TAGS:
+        target = "manylinux_2_28_x86_64"
+        return target, RELEASE_TARGETS[target]
+    if mode == "candidate" and platform_tag == "linux_x86_64":
+        target = "manylinux_2_28_x86_64"
+        return target, RELEASE_TARGETS[target]
+    if len(components) == 1:
+        target = next(iter(components))
+        rust_target = RELEASE_TARGETS.get(target)
+        if rust_target is not None:
+            return target, rust_target
+    raise ArtifactError(
+        "wheel platform tag must be macosx_11_0_arm64, "
+        "macosx_11_0_x86_64, or manylinux_2_28_x86_64; "
+        f"found {platform_tag}"
+    )
+
+
+def _message(data: bytes, description: str):
+    try:
+        return BytesParser(policy=policy.default).parsebytes(data)
+    except Exception as error:  # pragma: no cover - email parser is defensive
+        raise ArtifactError(f"could not parse {description}: {error}") from error
+
+
+def _reject_direct_requirements(
+    requirements: list[str], *, description: str = "wheel metadata"
+) -> None:
+    direct = re.compile(
+        r"(?i)(?:\s@\s|(?:file|git\+[^:]+|https?)://|(?:^|[ (])\.\.?[/\\])"
+    )
+    invalid = [
+        requirement for requirement in requirements if direct.search(requirement)
+    ]
+    if invalid:
+        raise ArtifactError(
+            f"{description} contains direct URL or path dependencies: "
+            + ", ".join(invalid)
+        )
+
+
+def _project_requirements(pyproject: dict[str, Any]) -> list[str]:
+    requirements: list[str] = []
+    project = pyproject.get("project", {})
+    if not isinstance(project, dict):
+        raise ArtifactError("sdist pyproject.toml [project] must be a table")
+    dependencies = project.get("dependencies", [])
+    if not isinstance(dependencies, list) or not all(
+        isinstance(item, str) for item in dependencies
+    ):
+        raise ArtifactError("sdist project dependencies must be strings")
+    requirements.extend(dependencies)
+    optional = project.get("optional-dependencies", {})
+    if not isinstance(optional, dict) or not all(
+        isinstance(group, list) and all(isinstance(item, str) for item in group)
+        for group in optional.values()
+    ):
+        raise ArtifactError("sdist optional dependencies must be string lists")
+    for group in optional.values():
+        requirements.extend(group)
+    build_system = pyproject.get("build-system", {})
+    if not isinstance(build_system, dict):
+        raise ArtifactError("sdist pyproject.toml [build-system] must be a table")
+    build_requirements = build_system.get("requires", [])
+    if not isinstance(build_requirements, list) or not all(
+        isinstance(item, str) for item in build_requirements
+    ):
+        raise ArtifactError("sdist build requirements must be strings")
+    requirements.extend(build_requirements)
+    return requirements
+
+
+@lru_cache(maxsize=1)
+def _dependency_lock() -> dict[str, Any]:
+    canonical_path = ROOT / _CANONICAL_DEPENDENCY_LOCK
+    if not canonical_path.is_file():
+        raise ArtifactError(f"canonical dependency lock is missing: {canonical_path}")
+    try:
+        with canonical_path.open("rb") as stream:
+            payload = tomllib.load(stream)
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        raise ArtifactError(f"dependency lock is invalid: {error}") from error
+    if payload.get("schema_version") != 1:
+        raise ArtifactError("dependency lock must use schema_version = 1")
+    return payload
+
+
+def _validate_wheel_resource_layout(entries: dict[str, bytes]) -> None:
+    dist_info_roots = {
+        PurePosixPath(name).parts[0]
+        for name in entries
+        if PurePosixPath(name).parts[0].endswith(".dist-info")
+    }
+    if len(dist_info_roots) != 1:
+        raise ArtifactError(
+            "wheel must contain exactly one top-level .dist-info directory"
+        )
+    allowed_roots = {
+        "pyamplicol",
+        "rusticol_config",
+        *dist_info_roots,
+        *_ALLOWED_REPAIR_ROOTS,
+    }
+    misplaced = sorted(
+        name for name in entries if PurePosixPath(name).parts[0] not in allowed_roots
+    )
+    if misplaced:
+        raise ArtifactError(
+            "wheel contains members outside pyamplicol, rusticol_config, its "
+            ".dist-info, or an approved repair-library root: " + ", ".join(misplaced)
+        )
+    sboms = sorted(
+        name
+        for name in entries
+        if len(PurePosixPath(name).parts) > 1
+        and PurePosixPath(name).parts[0] in dist_info_roots
+        and PurePosixPath(name).parts[1] == "sboms"
+    )
+    if sboms:
+        raise ArtifactError(
+            "lean release wheels must not contain generated SBOMs: " + ", ".join(sboms)
+        )
+    missing = sorted(_REQUIRED_PACKAGE_RESOURCES - entries.keys())
+    if missing:
+        raise ArtifactError(
+            "wheel is missing required package-owned resources: " + ", ".join(missing)
+        )
+
+
+def _required_legal_files() -> tuple[str, ...]:
+    return (
+        "LICENSE",
+        "THIRD_PARTY_NOTICES.md",
+        "licenses/Symbolica.txt",
+        "licenses/SymJIT.txt",
+    )
+
+
+def _locked_python_dependencies(lock: dict[str, Any]) -> dict[str, str]:
+    raw_dependencies = lock.get("python_dependencies")
+    if not isinstance(raw_dependencies, list):
+        raise ArtifactError("wheel dependency lock has no Python dependency list")
+    dependencies: dict[str, str] = {}
+    for entry in raw_dependencies:
+        if not isinstance(entry, dict):
+            raise ArtifactError("wheel dependency lock entries must be tables")
+        distribution = entry.get("distribution")
+        version = entry.get("version")
+        if not isinstance(distribution, str) or not isinstance(version, str):
+            raise ArtifactError("wheel dependency lock entries need name and version")
+        name = canonicalize_name(distribution)
+        if name in dependencies:
+            raise ArtifactError(f"wheel dependency lock repeats {name}")
+        try:
+            normalized_version = str(Version(version))
+        except InvalidVersion as error:
+            raise ArtifactError(
+                f"wheel dependency lock has invalid version for {name}: {version}"
+            ) from error
+        dependencies[name] = normalized_version
+    return dependencies
+
+
+def _candidate_dependency_overrides() -> dict[str, str]:
+    contributor_path = ROOT / _CONTRIBUTOR_DEPENDENCY_LOCK
+    state_path = ROOT / _CANDIDATE_INSTALL_STATE
+    missing = [path for path in (contributor_path, state_path) if not path.is_file()]
+    if missing:
+        raise ArtifactError(
+            "candidate dependency provenance is incomplete: "
+            + ", ".join(str(path) for path in missing)
+        )
+    try:
+        with contributor_path.open("rb") as stream:
+            contributor = tomllib.load(stream)
+        state = json.loads(state_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, tomllib.TOMLDecodeError) as error:
+        raise ArtifactError(
+            f"candidate dependency provenance is invalid: {error}"
+        ) from error
+    if contributor.get("schema_version") != 1:
+        raise ArtifactError(
+            "candidate dependency provenance has an unsupported contributor lock"
+        )
+    if (
+        not isinstance(state, dict)
+        or set(state) != {"schema_version", "publishable", "sources"}
+        or state.get("schema_version") != 1
+        or state.get("publishable") is not False
+    ):
+        raise ArtifactError(
+            "candidate dependency provenance requires a non-publishable schema-v1 "
+            "installer state containing only its source revisions"
+        )
+    sources = state["sources"]
+    if not isinstance(sources, dict) or not sources:
+        raise ArtifactError("candidate dependency provenance has no source map")
+    for source_name, source in sources.items():
+        allowed = {"url", "revision"}
+        if isinstance(source, dict) and "branch" in source:
+            allowed.add("branch")
+        if (
+            not isinstance(source_name, str)
+            or not source_name
+            or not isinstance(source, dict)
+            or set(source) != allowed
+            or not all(isinstance(source[key], str) and source[key] for key in allowed)
+            or re.fullmatch(r"[0-9a-f]{40}", source["revision"]) is None
+        ):
+            raise ArtifactError(
+                f"candidate dependency source {source_name!r} has an invalid descriptor"
+            )
+
+    release = _dependency_lock()
+    dependencies = _locked_python_dependencies(release)
+    release_symbolica = release.get("symbolica")
+    candidate_symbolica = contributor.get("symbolica")
+    if not isinstance(release_symbolica, dict) or not isinstance(
+        candidate_symbolica, dict
+    ):
+        raise ArtifactError("candidate dependency provenance has no Symbolica contract")
+    distribution = release_symbolica.get("python_distribution")
+    release_version = release_symbolica.get("python_version")
+    candidate_version = candidate_symbolica.get("candidate_version")
+    candidate_revision = candidate_symbolica.get("candidate_revision")
+    source_url = candidate_symbolica.get("source_url")
+    if not all(
+        isinstance(value, str) and value
+        for value in (
+            distribution,
+            release_version,
+            candidate_version,
+            candidate_revision,
+            source_url,
+        )
+    ):
+        raise ArtifactError(
+            "candidate dependency provenance has an invalid Symbolica contract"
+        )
+    name = canonicalize_name(distribution)
+    try:
+        normalized_release = str(Version(release_version))
+        normalized_candidate = str(Version(candidate_version))
+    except InvalidVersion as error:
+        raise ArtifactError(
+            "candidate dependency provenance has an invalid Symbolica version"
+        ) from error
+    if dependencies.get(name) != normalized_release:
+        raise ArtifactError(
+            "release dependency inventory disagrees with its Symbolica contract"
+        )
+    source = sources.get("symbolica")
+    if (
+        not isinstance(source, dict)
+        or source.get("revision") != candidate_revision
+        or source.get("url") != source_url
+    ):
+        raise ArtifactError(
+            "candidate dependency provenance is not bound to the pinned Symbolica "
+            "source"
+        )
+    return {
+        name: normalized_candidate,
+        "ufo-model-loader": dependencies["ufo-model-loader"],
+    }
+
+
+def _validate_runtime_requirements(
+    raw_requirements: list[str],
+    lock: dict[str, Any],
+    *,
+    mode: str,
+) -> None:
+    dependencies = _locked_python_dependencies(lock)
+    if mode == "candidate":
+        dependencies.update(_candidate_dependency_overrides())
+    elif mode != "release":
+        raise ArtifactError(f"unsupported dependency contract mode: {mode}")
+    requirements: dict[str, Requirement] = {}
+
+    def marker_uses_extra(items: Any) -> bool:
+        if isinstance(items, tuple):
+            return any(
+                isinstance(item, Variable) and item.value == "extra" for item in items
+            )
+        if isinstance(items, list):
+            return any(marker_uses_extra(item) for item in items)
+        return False
+
+    for raw in raw_requirements:
+        try:
+            requirement = Requirement(raw)
+        except InvalidRequirement as error:
+            raise ArtifactError(f"wheel has invalid Requires-Dist: {raw}") from error
+        if requirement.marker is not None and marker_uses_extra(
+            requirement.marker._markers
+        ):
+            continue
+        if requirement.marker is not None:
+            raise ArtifactError(
+                "locked runtime Requires-Dist entries may not use environment markers: "
+                f"{raw}"
+            )
+        name = canonicalize_name(requirement.name)
+        if name in requirements:
+            raise ArtifactError(f"wheel metadata repeats runtime dependency {name}")
+        if requirement.extras or requirement.url:
+            raise ArtifactError(
+                f"wheel runtime dependency must be a plain version requirement: {raw}"
+            )
+        requirements[name] = requirement
+    if set(requirements) != set(dependencies):
+        missing = sorted(set(dependencies) - set(requirements))
+        extra = sorted(set(requirements) - set(dependencies))
+        raise ArtifactError(
+            "wheel Requires-Dist inventory disagrees with dependency lock; "
+            f"missing={missing}, extra={extra}"
+        )
+    for name, locked_version in dependencies.items():
+        requirement = requirements[name]
+        if (
+            not requirement.specifier
+            or Version(locked_version) not in requirement.specifier
+        ):
+            raise ArtifactError(
+                f"wheel Requires-Dist for {name} excludes locked version "
+                f"{locked_version}"
+            )
+        specifiers = list(requirement.specifier)
+        exact_match = False
+        if len(specifiers) == 1 and specifiers[0].operator == "==":
+            try:
+                exact_match = str(Version(specifiers[0].version)) == locked_version
+            except InvalidVersion:
+                exact_match = False
+        if not exact_match:
+            raise ArtifactError(
+                f"wheel Requires-Dist must pin {name}=={locked_version} exactly"
+            )
+
+
+def _validate_legal_members(
+    entries: dict[str, bytes], metadata_name: str, metadata: Any
+) -> None:
+    license_files = list(metadata.get_all("License-File", []))
+    declared: list[str] = []
+    for raw_name in license_files:
+        relative = _safe_member_name(str(raw_name), archive="License-File")
+        declared.append(relative.as_posix())
+    if len(declared) != len(set(declared)):
+        raise ArtifactError("wheel metadata repeats a License-File declaration")
+    required = set(_required_legal_files())
+    if not required <= set(declared):
+        missing = sorted(required - set(declared))
+        raise ArtifactError(
+            "wheel metadata omits required license/notice files: " + ", ".join(missing)
+        )
+    dist_info = metadata_name.removesuffix("METADATA")
+    for relative in declared:
+        member = f"{dist_info}licenses/{relative}"
+        if member not in entries or not entries[member].strip():
+            raise ArtifactError(f"wheel is missing nonempty legal member: {member}")
+
+
+def _record_digest(data: bytes) -> str:
+    digest = hashlib.sha256(data).digest()
+    return base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
+
+
+def _validate_record(entries: dict[str, bytes], record_name: str) -> None:
+    try:
+        rows = list(csv.reader(io.StringIO(entries[record_name].decode("utf-8"))))
+    except (UnicodeDecodeError, csv.Error) as error:
+        raise ArtifactError(f"invalid wheel RECORD: {error}") from error
+    records: dict[str, tuple[str, str]] = {}
+    for row in rows:
+        if len(row) != 3:
+            raise ArtifactError(f"wheel RECORD row must have three fields: {row!r}")
+        name, digest, size = row
+        safe_name = _safe_member_name(name, archive="RECORD").as_posix()
+        if safe_name in records:
+            raise ArtifactError(f"wheel RECORD repeats {safe_name}")
+        records[safe_name] = (digest, size)
+    if set(records) != set(entries):
+        missing = sorted(set(entries) - set(records))
+        extra = sorted(set(records) - set(entries))
+        raise ArtifactError(
+            f"wheel RECORD inventory mismatch; missing={missing}, extra={extra}"
+        )
+    for name, data in entries.items():
+        digest, size = records[name]
+        if name == record_name:
+            if digest or size:
+                raise ArtifactError("wheel RECORD must not hash itself")
+            continue
+        expected_digest = f"sha256={_record_digest(data)}"
+        if digest != expected_digest or size != str(len(data)):
+            raise ArtifactError(f"wheel RECORD hash/size mismatch for {name}")
+
+
+def _json_object(entries: dict[str, bytes], name: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(entries[name])
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise ArtifactError(f"invalid JSON resource {name}: {error}") from error
+    if not isinstance(payload, dict):
+        raise ArtifactError(f"JSON resource must be an object: {name}")
+    return payload
+
+
+def _validate_prepared_model_assets(
+    entries: dict[str, bytes],
+    *,
+    prefix: str,
+    mode: str,
+) -> None:
+    abis = _dependency_lock().get("abis")
+    if not isinstance(abis, dict):
+        raise ArtifactError("dependency lock has no ABI inventory")
+    expected = prepared_model_asset_members(prefix)
+    prepared_prefix = f"{prefix.rstrip('/')}/"
+    actual = {name for name in entries if name.startswith(prepared_prefix)}
+    if actual != expected:
+        missing = sorted(expected - actual)
+        extra = sorted(actual - expected)
+        raise ArtifactError(
+            f"prepared-model asset inventory mismatch; missing={missing}, extra={extra}"
+        )
+
+    for identifier, model_source in PREPARED_MODEL_ASSETS.items():
+        for architecture in PREPARED_MODEL_ARCHITECTURES:
+            stem = f"{identifier}-{architecture}"
+            metadata_name = f"{prepared_prefix}{stem}.metadata.json"
+            bundle_name = f"{prepared_prefix}{stem}.pyamplicol-model"
+            metadata = _json_object(entries, metadata_name)
+            if (
+                metadata.get("schema_version") != 1
+                or metadata.get("prepared_model_bundle_schema")
+                != abis.get("prepared_model_bundle")
+                or metadata.get("eager_kernel_abi") != abis.get("eager_kernel")
+                or metadata.get("id") != identifier
+                or metadata.get("model") != model_source
+                or metadata.get("backend") != "jit"
+                or metadata.get("jit_optimization_level") != 2
+                or metadata.get("bundle") != PurePosixPath(bundle_name).name
+            ):
+                raise ArtifactError(
+                    f"prepared-model metadata identity is invalid: {metadata_name}"
+                )
+
+            dependencies = metadata.get("dependencies")
+            if (
+                not isinstance(dependencies, dict)
+                or dependencies.get("symjit_application_abi")
+                != abis.get("symjit_application")
+                or dependencies.get("symjit_plane_application_abi")
+                != abis.get("symjit_plane_application")
+                or dependencies.get("symbolica_serialization_abi")
+                != abis.get("symbolica_serialization")
+            ):
+                raise ArtifactError(
+                    f"prepared-model SymJIT storage ABI is invalid: {metadata_name}"
+                )
+
+            build_contract = metadata.get("build_contract")
+            if (
+                not isinstance(build_contract, dict)
+                or build_contract.get("mode") != mode
+            ):
+                raise ArtifactError(
+                    f"prepared-model build mode is invalid: {metadata_name}"
+                )
+            producer = metadata.get("producer")
+            if not isinstance(producer, dict):
+                raise ArtifactError(
+                    f"prepared-model producer metadata is invalid: {metadata_name}"
+                )
+
+            expected_target = {
+                "portable": True,
+                "word_bits": 64,
+                "endianness": "little",
+                "target_triple": "symjit-storage-v3-portable",
+                "cpu_features": [],
+            }
+            if metadata.get("target") != expected_target:
+                raise ArtifactError(
+                    f"prepared-model target class is invalid: {metadata_name}"
+                )
+
+            bundle = entries[bundle_name]
+            claimed_size = metadata.get("bundle_size")
+            claimed_digest = metadata.get("bundle_sha256")
+            if (
+                not bundle
+                or type(claimed_size) is not int
+                or claimed_size != len(bundle)
+                or not isinstance(claimed_digest, str)
+                or not re.fullmatch(r"[0-9a-f]{64}", claimed_digest)
+                or claimed_digest != hashlib.sha256(bundle).hexdigest()
+            ):
+                raise ArtifactError(
+                    f"prepared-model bundle hash/size is invalid: {bundle_name}"
+                )
+
+
+def _sanitized_native_bytes(data: bytes, *, allow_local_rustup: bool) -> bytes:
+    scanned = re.sub(
+        rb"/rustc/[0-9a-f]+/library/std/src/\.\./\.\./backtrace/",
+        b"/rustc/standard-library-backtrace/",
+        data,
+    )
+    scanned = re.sub(
+        rb"library/std/src/\.\./\.\./backtrace/",
+        b"library/standard-library-backtrace/",
+        scanned,
+    )
+    scanned = re.sub(
+        rb"/(?:Users|home)/runner/work/rust/rust/",
+        b"/rust/toolchain-source/",
+        scanned,
+    )
+    scanned = re.sub(
+        rb"/(?:private/)?var/folders/[^/\x00]+/[^/\x00]+/T/"
+        rb"pyamplicol-build-[^/\x00]+/cargo-home/registry/src/",
+        b"/cargo/registry/src/",
+        scanned,
+    )
+    scanned = re.sub(
+        rb"/(?:tmp|var/tmp)/pyamplicol-build-[^/\x00]+/"
+        rb"cargo-home/registry/src/",
+        b"/cargo/registry/src/",
+        scanned,
+    )
+    if allow_local_rustup:
+        scanned = re.sub(
+            rb"/(?:Users|home)/[^/\x00]+/\.rustup/toolchains/[^/\x00]+/"
+            rb"lib/rustlib/src/rust/library/",
+            b"/rust/sysroot/library/",
+            scanned,
+        )
+    return scanned
+
+
+def _contains_forbidden_path(data: bytes, marker: bytes) -> bool:
+    """Return whether *marker* occurs as the forbidden path it represents.
+
+    Require every absolute marker to occupy a complete path token. A direct
+    substring check would misclassify deterministic remapped paths such as
+    ``/pyamplicol/checkout/.artifacts/dev-install/tmp/...`` as host ``/tmp``
+    paths, and a manylinux checkout rooted at ``/io`` would collide with
+    ordinary ``.../src/io/...`` paths or arbitrary native instruction bytes.
+    Real absolute paths remain rejected at token boundaries.
+    """
+
+    needle = marker.lower()
+    if not needle:
+        return False
+    lowered = data.lower()
+    offset = 0
+    while (index := lowered.find(needle, offset)) >= 0:
+        starts_token = index == 0 or lowered[index - 1] not in _PATH_TOKEN_BYTES
+        end = index + len(needle)
+        ends_token = (
+            needle.endswith((b"/", b"\\"))
+            or end == len(lowered)
+            or lowered[end] not in _PATH_TOKEN_BYTES
+            or lowered[end] in b"/\\"
+        )
+        if starts_token and ends_token:
+            return True
+        offset = index + 1
+    return False
+
+
+def _native_forbidden_path_markers() -> tuple[bytes, ...]:
+    """Use directory prefixes for the dynamic checkout root in native bytes."""
+
+    root = _REPOSITORY_PATH_MARKER.rstrip(b"/\\")
+    fixed = tuple(
+        marker
+        for marker in _FORBIDDEN_PATH_MARKERS
+        if marker != _REPOSITORY_PATH_MARKER
+    )
+    return (*fixed, root + b"/", root + b"\\")
+
+
+def _scan_embedded_paths(
+    entries: dict[str, bytes],
+    *,
+    allow_local_rustup: bool = False,
+    allow_candidate_source_checkout: bool = False,
+) -> None:
+    for name, data in entries.items():
+        scanned = data
+        if allow_candidate_source_checkout and name == "pyamplicol/_build_info.json":
+            build_info = _json_object(entries, name)
+            build_info.pop("source_checkout", None)
+            scanned = json.dumps(build_info, sort_keys=True).encode("utf-8")
+        native_member = name.lower().endswith(_NATIVE_MEMBER_SUFFIXES)
+        if native_member:
+            scanned = _sanitized_native_bytes(
+                data, allow_local_rustup=allow_local_rustup
+            )
+        lowered = scanned.lower()
+        markers = (
+            _native_forbidden_path_markers()
+            if native_member
+            else _FORBIDDEN_PATH_MARKERS
+        )
+        if name.lower().endswith((".dylib", ".pyd", ".so")):
+            markers += _FORBIDDEN_NATIVE_RELATIVE_MARKERS
+        for marker in markers:
+            if _contains_forbidden_path(lowered, marker):
+                raise ArtifactError(
+                    f"wheel member {name} embeds non-relocatable path marker "
+                    f"{os.fsdecode(marker)!r}"
+                )
+
+
+def _validate_sdk(
+    entries: dict[str, bytes],
+    *,
+    version: str,
+    rust_target: str,
+) -> None:
+    missing = sorted(_REQUIRED_SDK_PATHS - set(entries))
+    if missing:
+        raise ArtifactError("wheel is missing SDK resources: " + ", ".join(missing))
+    metadata = _json_object(entries, "pyamplicol/_sdk/metadata.json")
+    link = _json_object(entries, "pyamplicol/_sdk/link.json")
+    if metadata.get("schema_version") != 1 or link.get("schema_version") != 1:
+        raise ArtifactError("unsupported SDK metadata schema")
+    if metadata.get("abi_version") != 1:
+        raise ArtifactError("Rusticol SDK must provide C ABI version 1")
+    if metadata.get("target") != rust_target or link.get("target") != rust_target:
+        raise ArtifactError("SDK target does not match the wheel platform")
+    metadata_version = str(metadata.get("version", ""))
+    if version != metadata_version:
+        raise ArtifactError("SDK version does not match wheel metadata")
+    archive = PurePosixPath(str(metadata.get("archive", "")))
+    if archive.is_absolute() or any(part in {"", ".", ".."} for part in archive.parts):
+        raise ArtifactError("SDK archive path must be relative and confined")
+    archive_name = (PurePosixPath("pyamplicol/_sdk") / archive).as_posix()
+    if archive_name != "pyamplicol/_sdk/lib/librusticol_capi.a":
+        raise ArtifactError(f"unexpected SDK archive path: {archive}")
+    rust_source = PurePosixPath(str(metadata.get("rust_source", "")))
+    if rust_source.is_absolute() or any(
+        part in {"", ".", ".."} for part in rust_source.parts
+    ):
+        raise ArtifactError("SDK Rust source path must be relative and confined")
+    rust_source_name = (PurePosixPath("pyamplicol/_sdk") / rust_source).as_posix()
+    if rust_source_name != "pyamplicol/_sdk/rust/rusticol.rs":
+        raise ArtifactError(f"unexpected SDK Rust source path: {rust_source}")
+    typed_values: dict[str, list[str]] = {}
+    for key in ("system_libraries", "frameworks"):
+        values = link.get(key, [])
+        if not isinstance(values, list) or not all(
+            isinstance(value, str) and value for value in values
+        ):
+            raise ArtifactError(f"SDK {key} must be a list of nonempty strings")
+        if len(values) != len(set(values)):
+            raise ArtifactError(f"SDK {key} contains duplicate entries")
+        if any(
+            "/" in value
+            or "\\" in value
+            or value.startswith("-")
+            or any(character.isspace() for character in value)
+            for value in values
+        ):
+            raise ArtifactError(f"SDK {key} contains a path")
+        typed_values[key] = values
+    unexpected_libraries = (
+        set(typed_values["system_libraries"]) - _SYSTEM_LIBRARIES[rust_target]
+    )
+    allowed_frameworks = _MACOS_FRAMEWORKS if "apple-darwin" in rust_target else set()
+    unexpected_frameworks = set(typed_values["frameworks"]) - allowed_frameworks
+    if unexpected_libraries or unexpected_frameworks:
+        raise ArtifactError(
+            "SDK link metadata is not target-allowlisted: "
+            f"libraries={sorted(unexpected_libraries)}, "
+            f"frameworks={sorted(unexpected_frameworks)}"
+        )
+
+
+def _validate_selftest_fixture(
+    entries: dict[str, bytes], *, version: str, rust_target: str
+) -> None:
+    root = PurePosixPath("pyamplicol/assets/selftest")
+    fixture_members = [
+        PurePosixPath(name)
+        for name in entries
+        if PurePosixPath(name).is_relative_to(root)
+    ]
+    targets = {
+        path.parts[len(root.parts)]
+        for path in fixture_members
+        if len(path.parts) > len(root.parts)
+    }
+    if targets != {rust_target}:
+        raise ArtifactError(
+            "wheel must contain only its target self-test fixture; "
+            f"expected {rust_target!r}, found {sorted(targets)!r}"
+        )
+    prefix = (root / rust_target).as_posix()
+    expected_name = f"{prefix}/expected.json"
+    manifest_name = f"{prefix}/artifact/artifact.json"
+    expected = _json_object(entries, expected_name)
+    manifest = _json_object(entries, manifest_name)
+    if (
+        expected.get("schema_version") != 1
+        or expected.get("target") != rust_target
+        or expected.get("artifact_path") != "artifact"
+    ):
+        raise ArtifactError("wheel self-test expectation is invalid")
+    if manifest.get("schema_version") != 3:
+        raise ArtifactError("wheel self-test artifact must use schema v3")
+    producer = manifest.get("producer")
+    runtime = manifest.get("runtime")
+    if not isinstance(producer, dict) or not isinstance(runtime, dict):
+        raise ArtifactError("wheel self-test producer/runtime metadata is invalid")
+    try:
+        validate_portable_artifact_capabilities(
+            manifest,
+            context="wheel self-test artifact manifest",
+        )
+    except RuntimeError as error:
+        raise ArtifactError(
+            f"wheel self-test Arena artifact contract is invalid: {error}"
+        ) from error
+    target = producer.get("target")
+    if (
+        producer.get("version") != version
+        or runtime.get("engine_version") != version
+        or not isinstance(target, dict)
+        or target.get("triple") != rust_target
+    ):
+        raise ArtifactError("wheel self-test artifact version/target is inconsistent")
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise ArtifactError("wheel self-test payload inventory is invalid")
+    abis = _dependency_lock().get("abis")
+    expected_compiled_model_schema = (
+        abis.get("compiled_model") if isinstance(abis, dict) else None
+    )
+    if not isinstance(expected_compiled_model_schema, int):
+        raise ArtifactError("dependency lock has no compiled-model schema version")
+    compiled_model = _json_object(
+        entries, f"{prefix}/artifact/model/compiled-model.json"
+    )
+    model = manifest.get("model")
+    producer_versions = producer.get("versions")
+    if (
+        not isinstance(model, dict)
+        or model.get("compiled_schema_version") != expected_compiled_model_schema
+        or not isinstance(producer_versions, dict)
+        or producer_versions.get("compiled_model") != expected_compiled_model_schema
+    ):
+        raise ArtifactError(
+            "wheel self-test producer/model metadata does not match release "
+            f"compiled-model schema {expected_compiled_model_schema}"
+        )
+    if compiled_model.get("kind") != _COMPILED_MODEL_KIND:
+        raise ArtifactError("wheel self-test compiled model kind is invalid")
+    if compiled_model.get("schema_version") != expected_compiled_model_schema:
+        raise ArtifactError(
+            "wheel self-test compiled model does not match release schema "
+            f"{expected_compiled_model_schema}"
+        )
+    compiled_producer = compiled_model.get("producer")
+    compiled_source = compiled_model.get("source")
+    if not isinstance(compiled_producer, dict) or not isinstance(compiled_source, dict):
+        raise ArtifactError(
+            "wheel self-test compiled model provenance metadata is invalid"
+        )
+    model_compiler_version = compiled_model.get("model_compiler_version")
+    producer_model_compiler_version = compiled_producer.get("model_compiler_version")
+    if (
+        not isinstance(model_compiler_version, int)
+        or isinstance(model_compiler_version, bool)
+        or not isinstance(producer_model_compiler_version, int)
+        or isinstance(producer_model_compiler_version, bool)
+        or producer_model_compiler_version != model_compiler_version
+    ):
+        raise ArtifactError(
+            "wheel self-test model compiler version does not match producer"
+        )
+    if (
+        compiled_producer.get("compiled_model_schema_version")
+        != expected_compiled_model_schema
+    ):
+        raise ArtifactError(
+            "wheel self-test compiled model producer does not match release "
+            f"schema {expected_compiled_model_schema}"
+        )
+    if compiled_producer.get("pyamplicol") != version:
+        raise ArtifactError(
+            "wheel self-test compiled model producer does not match wheel version"
+        )
+    if compiled_source.get("kind") != _BUILTIN_MODEL_SOURCE_KIND:
+        raise ArtifactError("wheel self-test compiled model source is not built-in-sm")
+    tagged_payloads = [
+        payload
+        for payload in payloads
+        if isinstance(payload, dict) and payload.get("target") is not None
+    ]
+    if not tagged_payloads or any(
+        not isinstance(payload.get("target"), dict)
+        or payload["target"].get("triple") != rust_target
+        or payload["target"].get("cpu_features") != []
+        for payload in tagged_payloads
+    ):
+        raise ArtifactError("wheel self-test evaluator target metadata is invalid")
+    validate_artifact_identity_contract(
+        manifest,
+        context="wheel self-test artifact",
+    )
+    claimed_id = manifest.get("artifact_id")
+    if claimed_id != _artifact_id(manifest):
+        raise ArtifactError("wheel self-test artifact identity is invalid")
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list) or not payloads:
+        raise ArtifactError("wheel self-test artifact has no payload inventory")
+    declared: set[str] = set()
+    direct_symjit = 0
+    execution_manifests: list[tuple[str, str]] = []
+    artifact_prefix = f"{prefix}/artifact/"
+    for index, payload in enumerate(payloads):
+        if not isinstance(payload, dict):
+            raise ArtifactError(f"wheel self-test payload {index} is invalid")
+        relative = payload.get("path")
+        if not isinstance(relative, str):
+            raise ArtifactError(f"wheel self-test payload {index} has no path")
+        path = PurePosixPath(relative)
+        if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts):
+            raise ArtifactError(f"wheel self-test payload path is unsafe: {relative}")
+        if relative in declared:
+            raise ArtifactError(f"wheel self-test payload is repeated: {relative}")
+        declared.add(relative)
+        member = f"{artifact_prefix}{relative}"
+        data = entries.get(member)
+        if data is None:
+            raise ArtifactError(f"wheel self-test payload is missing: {relative}")
+        if (
+            payload.get("size_bytes") != len(data)
+            or payload.get("sha256") != hashlib.sha256(data).hexdigest()
+        ):
+            raise ArtifactError(
+                f"wheel self-test payload digest is invalid: {relative}"
+            )
+        if relative.endswith(".evaluator.bin"):
+            raise ArtifactError(
+                "wheel self-test must not retain Symbolica fallback state"
+            )
+        if payload.get("media_type") == "application/vnd.symjit.application":
+            direct_symjit += 1
+        if payload.get("role") == "evaluator-manifest" and relative.endswith(
+            "/execution.json"
+        ):
+            execution_manifests.append((relative, member))
+    container = manifest.get("extensions", {}).get("evaluator_payload_container")
+    if container is not None:
+        direct_symjit += _validate_selftest_evaluator_container(
+            entries,
+            artifact_prefix=artifact_prefix,
+            container=container,
+        )
+    actual = {
+        name.removeprefix(artifact_prefix)
+        for name in entries
+        if name.startswith(artifact_prefix) and name != manifest_name
+    }
+    if actual != declared:
+        raise ArtifactError("wheel self-test artifact payload inventory is incomplete")
+    missing_api_payloads = sorted(_REQUIRED_SELFTEST_API_PAYLOADS - declared)
+    if missing_api_payloads:
+        raise ArtifactError(
+            "wheel self-test artifact is missing five-language API payloads: "
+            + ", ".join(missing_api_payloads)
+        )
+    if direct_symjit == 0:
+        raise ArtifactError("wheel self-test artifact has no direct SymJIT application")
+    if not execution_manifests:
+        raise ArtifactError(
+            "wheel self-test artifact has no compiled execution manifest"
+        )
+    for relative, member in execution_manifests:
+        execution = _json_object(entries, member)
+        try:
+            validate_portable_execution_manifest(
+                execution,
+                context=f"wheel self-test execution manifest {relative}",
+            )
+        except RuntimeError as error:
+            raise ArtifactError(
+                f"wheel self-test Arena execution contract is invalid: {error}"
+            ) from error
+
+
+@lru_cache(maxsize=1)
+def _evaluator_container_codec() -> Any:
+    """Load the source-tree pacbin codec without importing an installed package."""
+
+    source = ROOT / "src" / "pyamplicol" / "generation" / "evaluator_container.py"
+    name = "_pyamplicol_release_evaluator_container"
+    spec = importlib.util.spec_from_file_location(name, source)
+    if spec is None or spec.loader is None:
+        raise ArtifactError("could not load the evaluator container codec")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    try:
+        spec.loader.exec_module(module)
+    except BaseException:
+        sys.modules.pop(name, None)
+        raise
+    return module
+
+
+def _validate_selftest_evaluator_container(
+    entries: dict[str, bytes],
+    *,
+    artifact_prefix: str,
+    container: object,
+) -> int:
+    if not isinstance(container, dict):
+        raise ArtifactError("wheel self-test evaluator container metadata is invalid")
+    relative = container.get("path")
+    if not isinstance(relative, str):
+        raise ArtifactError("wheel self-test evaluator container has no path")
+    data = entries.get(f"{artifact_prefix}{relative}")
+    if data is None:
+        raise ArtifactError("wheel self-test evaluator container is missing")
+
+    codec = _evaluator_container_codec()
+    try:
+        with codec.PacbinReader.open(io.BytesIO(data)) as reader:
+            index = reader.index
+            expected = {
+                "member_count": len(index.members),
+                "unpacked_size_bytes": sum(member.length for member in index.members),
+                "index_sha256": index.index_sha256,
+            }
+            if any(container.get(key) != value for key, value in expected.items()):
+                raise ArtifactError(
+                    "wheel self-test evaluator container metadata is inconsistent"
+                )
+            if any(
+                member.kind is codec.PacbinMemberKind.SYMBOLICA_EXACT_STATE
+                for member in index.members
+            ):
+                raise ArtifactError(
+                    "wheel self-test must not retain packed Symbolica fallback state"
+                )
+            return sum(
+                member.kind is codec.PacbinMemberKind.SYMJIT_APPLICATION
+                for member in index.members
+            )
+    except ArtifactError:
+        raise
+    except (OSError, TypeError, ValueError) as error:
+        raise ArtifactError(
+            f"wheel self-test evaluator container is invalid: {error}"
+        ) from error
+
+
+def _validate_wheel_inventory(
+    entries: dict[str, bytes],
+    *,
+    metadata_name: str,
+    wheel_name: str,
+    record_name: str,
+    extension_name: str,
+    rust_target: str,
+    mode: str,
+) -> None:
+    _validate_prepared_model_assets(
+        entries,
+        prefix=_PREPARED_MODEL_WHEEL_PREFIX,
+        mode=mode,
+    )
+    expected = set(_REQUIRED_WHEEL_PACKAGE_MEMBERS)
+    expected.add(extension_name)
+    selftest_root = f"pyamplicol/assets/selftest/{rust_target}/"
+    expected.update(name for name in entries if name.startswith(selftest_root))
+
+    dist_info = metadata_name.removesuffix("METADATA")
+    expected.update(
+        {
+            metadata_name,
+            wheel_name,
+            record_name,
+            f"{dist_info}entry_points.txt",
+        }
+    )
+    expected.update(
+        f"{dist_info}licenses/{relative}" for relative in _required_legal_files()
+    )
+
+    repair_members: set[str] = set()
+    for name in entries:
+        root = PurePosixPath(name).parts[0]
+        if root not in _ALLOWED_REPAIR_ROOTS:
+            continue
+        basename = PurePosixPath(name).name
+        if not re.search(r"(?:\.dylib|\.dll|\.so(?:\.[0-9]+)*)$", basename):
+            raise ArtifactError(
+                f"wheel repair-library root contains a non-library member: {name}"
+            )
+        repair_members.add(name)
+
+    actual = set(entries) - repair_members
+    missing = sorted(expected - actual)
+    if missing:
+        raise ArtifactError(
+            "wheel is missing required package members: " + ", ".join(missing)
+        )
+
+
+def _host_matches(target: str) -> bool:
+    machine = platform.machine().lower()
+    if target == "macosx_11_0_arm64":
+        return sys.platform == "darwin" and machine in {"arm64", "aarch64"}
+    if target == "macosx_11_0_x86_64":
+        return sys.platform == "darwin" and machine in {"x86_64", "amd64"}
+    return sys.platform.startswith("linux") and machine in {"x86_64", "amd64"}
+
+
+def _command_output(command: list[str], *, cwd: Path) -> str:
+    completed = run(command, cwd=cwd, capture_output=True)
+    return completed.stdout + completed.stderr
+
+
+def _reject_native_paths(output: str, description: str) -> None:
+    encoded = os.fsencode(output)
+    for marker in _FORBIDDEN_PATH_MARKERS:
+        decoded = os.fsdecode(marker).lower()
+        if _contains_forbidden_path(encoded, marker):
+            raise ArtifactError(f"{description} embeds non-relocatable path {decoded}")
+
+
+def _reject_native_path_bytes(data: bytes, description: str) -> None:
+    for marker in _native_forbidden_path_markers():
+        if _contains_forbidden_path(data, marker):
+            raise ArtifactError(
+                f"{description} embeds non-relocatable path "
+                f"{os.fsdecode(marker).lower()}"
+            )
+
+
+def _scan_capi_archive(path: Path, *, allow_local_rustup: bool) -> bool:
+    """Validate relocation paths and authoritative undefined-symbol linkage.
+
+    The archive link probe and ``nm -u`` inspection own the Python-linkage
+    invariant. Searching arbitrary compressed archive bytes for short strings
+    such as ``pyo3`` can match unrelated binary data and reject a valid wheel.
+    """
+
+    archive = path.read_bytes()
+    scanned = _sanitized_native_bytes(archive, allow_local_rustup=allow_local_rustup)
+    _reject_native_path_bytes(scanned, "Rusticol C API archive")
+
+    candidates: list[str] = []
+    for candidate in (
+        os.environ.get("LLVM_NM"),
+        shutil.which("llvm-nm"),
+        shutil.which("nm"),
+    ):
+        if candidate and candidate not in candidates:
+            candidates.append(candidate)
+    for nm in candidates:
+        completed = subprocess.run(
+            [nm, "-u", str(path)],
+            cwd=path.parent,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        forbidden_symbols: list[str] = []
+        for line in completed.stdout.splitlines():
+            fields = line.split()
+            if len(fields) < 2 or fields[-2] not in {"U", "u", "W", "w", "V", "v"}:
+                continue
+            symbol = fields[-1]
+            normalized = symbol.removeprefix("_").lower()
+            if normalized.startswith(_FORBIDDEN_CAPI_UNDEFINED_PREFIXES):
+                forbidden_symbols.append(symbol)
+        if forbidden_symbols:
+            raise ArtifactError(
+                "Rusticol C API archive has undefined Python/PyO3/NumPy symbols: "
+                + ", ".join(sorted(set(forbidden_symbols)))
+            )
+        if completed.returncode == 0:
+            return True
+    return False
+
+
+def _native_c_compiler(rust_target: str) -> list[str]:
+    configured = os.environ.get("CC")
+    if configured:
+        command = shlex.split(configured)
+        if command:
+            return command
+    names = ("clang", "cc") if "apple-darwin" in rust_target else ("cc", "clang")
+    for name in names:
+        compiler = shutil.which(name)
+        if compiler:
+            return [compiler]
+    raise ArtifactError("a C compiler is required for the native SDK audit")
+
+
+def _validate_capi_linkage(
+    entries: dict[str, bytes],
+    *,
+    archive: Path,
+    directory: Path,
+    rust_target: str,
+) -> None:
+    header_data = entries["pyamplicol/_sdk/include/rusticol.h"]
+    exports = tuple(
+        dict.fromkeys(re.findall(rb"\b(rusticol_[a-z0-9_]+)\s*\(", header_data))
+    )
+    decoded_exports = tuple(item.decode("ascii") for item in exports)
+    if not decoded_exports or "rusticol_abi_version" not in decoded_exports:
+        raise ArtifactError("wheel Rusticol C header has no complete public ABI")
+    header = directory / "rusticol.h"
+    source = directory / "probe.c"
+    binary = directory / "probe"
+    header.write_bytes(header_data)
+    table = ",\n".join(f"    (rusticol_probe_fn){name}" for name in decoded_exports)
+    source.write_text(
+        f"""\
+#include <stdint.h>
+#include \"rusticol.h\"
+
+typedef void (*rusticol_probe_fn)(void);
+static rusticol_probe_fn volatile rusticol_api[] = {{
+{table}
+}};
+
+int main(void) {{
+    uint32_t (*abi_version)(void) = (uint32_t (*)(void))rusticol_api[0];
+    return abi_version() == RUSTICOL_ABI_VERSION ? 0 : 1;
+}}
+""",
+        encoding="utf-8",
+    )
+    link = _json_object(entries, "pyamplicol/_sdk/link.json")
+    if link.get("target") != rust_target:
+        raise ArtifactError("wheel SDK link metadata targets the wrong platform")
+    flags = [f"-l{item}" for item in link.get("system_libraries", [])]
+    for framework in link.get("frameworks", []):
+        flags.extend(("-framework", str(framework)))
+    completed = subprocess.run(
+        [
+            *_native_c_compiler(rust_target),
+            "-std=c11",
+            "-O0",
+            "-I",
+            str(directory),
+            str(source),
+            str(archive),
+            *flags,
+            "-o",
+            str(binary),
+        ],
+        cwd=directory,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        detail = (completed.stderr or completed.stdout).strip()
+        suffix = f": {detail}" if detail else ""
+        raise ArtifactError(
+            "wheel Rusticol archive failed the complete C ABI link probe" + suffix
+        )
+    completed = subprocess.run(
+        [str(binary)],
+        cwd=directory,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        raise ArtifactError("wheel Rusticol archive failed the C ABI execution probe")
+
+
+def _scan_static_runtime_families(path: Path, description: str) -> None:
+    lowered = path.read_bytes().lower()
+    found = [
+        marker
+        for marker in _FORBIDDEN_STATIC_RUNTIME_MARKERS
+        if marker.encode() in lowered
+    ]
+    if found:
+        raise ArtifactError(
+            f"{description} contains a forbidden static arithmetic runtime: "
+            + ", ".join(found)
+        )
+
+
+def _allowed_runtime_path(value: str) -> bool:
+    return value.startswith(
+        ("$ORIGIN", "@loader_path", "@rpath", "/usr/lib/", "/System/Library/", "/lib/")
+    )
+
+
+def _scan_extension(path: Path, target: str) -> None:
+    file_output = _command_output(["file", str(path)], cwd=path.parent).lower()
+    if target.endswith("arm64") and not any(
+        marker in file_output for marker in ("arm64", "aarch64")
+    ):
+        raise ArtifactError(
+            "extension binary does not contain the required arm64 slice"
+        )
+    if target.endswith("x86_64") and not any(
+        marker in file_output for marker in ("x86-64", "x86_64")
+    ):
+        raise ArtifactError("extension binary is not x86_64")
+
+    if target.startswith("macosx"):
+        libraries = _command_output(["otool", "-L", str(path)], cwd=path.parent)
+        for line in libraries.splitlines()[1:]:
+            dependency = line.strip().split(" ", 1)[0]
+            if dependency and not _allowed_runtime_path(dependency):
+                raise ArtifactError(f"extension links a non-system path: {dependency}")
+            if "python" in dependency.lower():
+                raise ArtifactError(f"extension links Python directly: {dependency}")
+        load_commands = _command_output(["otool", "-l", str(path)], cwd=path.parent)
+        lines = load_commands.splitlines()
+        for index, line in enumerate(lines):
+            if line.strip() == "cmd LC_RPATH":
+                for candidate in lines[index + 1 : index + 5]:
+                    match = re.match(r"\s*path\s+(\S+)", candidate)
+                    if match and not _allowed_runtime_path(match.group(1)):
+                        raise ArtifactError(
+                            f"extension has a non-system RPATH: {match.group(1)}"
+                        )
+                        break
+        inspected = (libraries + load_commands).replace(str(path), "<extension>")
+        _reject_native_paths(inspected, "extension load metadata")
+        return
+
+    dynamic = _command_output(["readelf", "-d", str(path)], cwd=path.parent)
+    for line in dynamic.splitlines():
+        if "(RPATH)" in line or "(RUNPATH)" in line:
+            match = re.search(r"\[([^]]*)\]", line)
+            if match:
+                for value in match.group(1).split(":"):
+                    if value and not _allowed_runtime_path(value):
+                        raise ArtifactError(
+                            f"extension has a non-system RPATH: {value}"
+                        )
+        if "(NEEDED)" in line:
+            match = re.search(r"\[([^]]+)\]", line)
+            if match and ("/" in match.group(1) or "python" in match.group(1).lower()):
+                raise ArtifactError(
+                    f"extension has a forbidden dynamic dependency: {match.group(1)}"
+                )
+    _reject_native_paths(
+        dynamic.replace(str(path), "<extension>"), "extension dynamic metadata"
+    )
+
+
+def _native_scan(
+    entries: dict[str, bytes],
+    extension: str,
+    target: str,
+    *,
+    allow_local_rustup: bool,
+) -> None:
+    with external_temporary_directory("pyamplicol-native-audit-") as temporary:
+        extension_path = temporary / Path(extension).name
+        archive_path = temporary / "librusticol_capi.a"
+        extension_path.write_bytes(entries[extension])
+        archive_path.write_bytes(entries["pyamplicol/_sdk/lib/librusticol_capi.a"])
+        _scan_extension(extension_path, target)
+        _scan_capi_archive(archive_path, allow_local_rustup=allow_local_rustup)
+        link = _json_object(entries, "pyamplicol/_sdk/link.json")
+        rust_target = str(link.get("target", ""))
+        _validate_capi_linkage(
+            entries,
+            archive=archive_path,
+            directory=temporary,
+            rust_target=rust_target,
+        )
+        _scan_static_runtime_families(extension_path, "Rusticol Python extension")
+        _scan_static_runtime_families(archive_path, "Rusticol C API archive")
+
+
+def audit_wheel(
+    path: Path,
+    *,
+    mode: str,
+    native_scan: bool | None = None,
+) -> WheelReport:
+    """Validate a wheel's metadata, content inventory, SDK, and native binaries."""
+
+    path = path.resolve()
+    if mode not in {"candidate", "release"}:
+        raise ArtifactError(f"unsupported wheel audit mode: {mode}")
+    size = path.stat().st_size
+    if size > MAX_WHEEL_BYTES:
+        raise ArtifactError(
+            f"compressed wheel is {size} bytes; limit is {MAX_WHEEL_BYTES} bytes"
+        )
+    filename_version, python_tag, abi_tag, platform_tag = _parse_wheel_filename(path)
+    if python_tag != EXPECTED_PYTHON_TAG or abi_tag != EXPECTED_ABI_TAG:
+        raise ArtifactError(
+            f"wheel must use {EXPECTED_PYTHON_TAG}-{EXPECTED_ABI_TAG}, found "
+            f"{python_tag}-{abi_tag}"
+        )
+    target, rust_target = _canonical_target(platform_tag, mode=mode)
+    entries = _wheel_entries(path)
+    _validate_wheel_resource_layout(entries)
+    metadata_name = _single_name(entries, ".dist-info/METADATA")
+    wheel_name = _single_name(entries, ".dist-info/WHEEL")
+    record_name = _single_name(entries, ".dist-info/RECORD")
+    metadata = _message(entries[metadata_name], "METADATA")
+    name = canonicalize_name(str(metadata.get("Name", "")))
+    version = str(metadata.get("Version", ""))
+    if name != EXPECTED_DISTRIBUTION:
+        raise ArtifactError(f"wheel metadata Name is {name!r}, expected pyamplicol")
+    if filename_version != version:
+        raise ArtifactError(
+            "wheel filename version disagrees with metadata: "
+            f"{filename_version!r} != {version!r}"
+        )
+    raw_requirements = list(metadata.get_all("Requires-Dist", []))
+    _reject_direct_requirements(raw_requirements)
+    dependency_lock = _dependency_lock()
+    _validate_runtime_requirements(raw_requirements, dependency_lock, mode=mode)
+    _validate_legal_members(entries, metadata_name, metadata)
+    if str(metadata.get("License-Expression", "")) != "0BSD":
+        raise ArtifactError("wheel metadata must declare License-Expression: 0BSD")
+    if str(metadata.get("Requires-Python", "")) != ">=3.11":
+        raise ArtifactError("wheel metadata must require Python >=3.11")
+
+    build_info_names = [name for name in entries if name.endswith("/_build_info.json")]
+    if mode == "candidate":
+        candidate_pattern = (
+            re.escape(EXPECTED_RELEASE_VERSION) + r"\.dev0\+candidate\.[0-9a-f]{12}"
+        )
+        if re.fullmatch(candidate_pattern, version) is None:
+            raise ArtifactError(f"candidate wheel has invalid version: {version}")
+        if build_info_names != ["pyamplicol/_build_info.json"]:
+            raise ArtifactError("candidate wheel must contain one _build_info.json")
+        build_info = _json_object(entries, build_info_names[0])
+        if build_info.get("selftest_fixture_bootstrap") is not False:
+            raise ArtifactError(
+                "candidate self-test fixture bootstrap wheels are not deployable"
+            )
+        if (
+            build_info.get("publishable") is not False
+            or build_info.get("version") != version
+        ):
+            raise ArtifactError("candidate build marker is missing or inconsistent")
+    else:
+        if version != EXPECTED_RELEASE_VERSION:
+            raise ArtifactError(f"release wheel has invalid version: {version}")
+        if build_info_names != ["pyamplicol/_build_info.json"]:
+            raise ArtifactError("release wheel must contain one _build_info.json")
+        build_info = _json_object(entries, build_info_names[0])
+        source_revision = build_info.get("source_revision")
+        if (
+            set(build_info) != _RELEASE_BUILD_INFO_FIELDS
+            or build_info.get("schema_version") != 1
+            or build_info.get("publishable") is not True
+            or build_info.get("selftest_fixture_bootstrap") is not False
+            or build_info.get("version") != version
+            or not isinstance(source_revision, str)
+            or re.fullmatch(r"[0-9a-f]{40}", source_revision) is None
+        ):
+            raise ArtifactError("release build marker is missing or inconsistent")
+    wheel_metadata = _message(entries[wheel_name], "WHEEL")
+    if str(wheel_metadata.get("Root-Is-Purelib", "")).lower() != "false":
+        raise ArtifactError("binary wheel must set Root-Is-Purelib: false")
+    wheel_tags = list(wheel_metadata.get_all("Tag", []))
+    if not wheel_tags:
+        raise ArtifactError("WHEEL metadata contains no Tag fields")
+    for tag in wheel_tags:
+        fields = tag.rsplit("-", 2)
+        if len(fields) != 3 or fields[0] != python_tag or fields[1] != abi_tag:
+            raise ArtifactError(f"WHEEL metadata has an unexpected tag: {tag}")
+        tag_target, _ = _canonical_target(fields[2], mode=mode)
+        if tag_target != target:
+            raise ArtifactError(f"WHEEL tag disagrees with filename: {tag}")
+
+    extensions = sorted(
+        name
+        for name in entries
+        if re.fullmatch(r"pyamplicol/_rusticol(?:\.[^.]+)*\.so", name)
+    )
+    if len(extensions) != 1 or "abi3" not in Path(extensions[0]).name:
+        raise ArtifactError(
+            "wheel must contain exactly one pyamplicol/_rusticol*.abi3.so"
+        )
+    _validate_sdk(
+        entries,
+        version=version,
+        rust_target=rust_target,
+    )
+    _validate_selftest_fixture(entries, version=version, rust_target=rust_target)
+    _validate_wheel_inventory(
+        entries,
+        metadata_name=metadata_name,
+        wheel_name=wheel_name,
+        record_name=record_name,
+        extension_name=extensions[0],
+        rust_target=rust_target,
+        mode=mode,
+    )
+    _validate_record(entries, record_name)
+    _scan_embedded_paths(
+        entries,
+        allow_local_rustup=mode == "candidate",
+        allow_candidate_source_checkout=mode == "candidate",
+    )
+
+    perform_native_scan = _host_matches(target) if native_scan is None else native_scan
+    if perform_native_scan:
+        if not _host_matches(target):
+            raise ArtifactError(f"cannot perform native scan for {target} on this host")
+        _native_scan(
+            entries,
+            extensions[0],
+            target,
+            allow_local_rustup=mode == "candidate",
+        )
+    return WheelReport(
+        filename=path.name,
+        version=version,
+        size=size,
+        sha256=sha256(path),
+        python_tag=python_tag,
+        abi_tag=abi_tag,
+        target=target,
+        rust_target=rust_target,
+        native_scan=perform_native_scan,
+    )
+
+
+def _validate_sdist_inventory(members: set[str]) -> None:
+    required = {*REQUIRED_SDIST_MEMBERS, "PKG-INFO"}
+    missing = sorted(required - members)
+    if missing:
+        raise ArtifactError("sdist is missing required files: " + ", ".join(missing))
+    forbidden = sorted(
+        name
+        for name in members
+        if name in _FORBIDDEN_SDIST_MEMBERS
+        or name.startswith(_FORBIDDEN_SDIST_PREFIXES)
+    )
+    if forbidden:
+        raise ArtifactError(
+            "sdist contains contributor-only dependency inputs: " + ", ".join(forbidden)
+        )
+
+
+def _release_sdist_symjit_contract(
+    relative_files: Mapping[str, Path],
+) -> dict[str, str]:
+    """Validate the published SymJIT version against ordinary Cargo resolution."""
+
+    lock_member = "dependencies/release-lock.toml"
+    try:
+        with relative_files[lock_member].open("rb") as stream:
+            release_lock = tomllib.load(stream)
+        symjit = release_lock["symjit"]
+    except (KeyError, OSError, TypeError, tomllib.TOMLDecodeError) as error:
+        raise ArtifactError(
+            f"sdist has an invalid release SymJIT source contract: {error}"
+        ) from error
+    if (
+        not isinstance(symjit, dict)
+        or set(symjit) != _RELEASE_SYMJIT_FIELDS
+        or not all(
+            isinstance(symjit.get(field), str) and symjit[field]
+            for field in _RELEASE_SYMJIT_FIELDS
+        )
+    ):
+        raise ArtifactError("sdist has an invalid published SymJIT version contract")
+
+    expected_source = "registry+https://github.com/rust-lang/crates.io-index"
+    try:
+        with relative_files["Cargo.lock"].open("rb") as stream:
+            cargo_lock = tomllib.load(stream)
+        packages = cargo_lock["package"]
+    except (KeyError, OSError, TypeError, tomllib.TOMLDecodeError) as error:
+        raise ArtifactError(f"sdist has an invalid Cargo.lock: {error}") from error
+    matches = [
+        package
+        for package in packages
+        if isinstance(package, dict) and package.get("name") == "symjit"
+    ]
+    if (
+        len(matches) != 1
+        or matches[0].get("version") != symjit["version"]
+        or matches[0].get("source") != expected_source
+        or re.fullmatch(r"[0-9a-f]{64}", str(matches[0].get("checksum", ""))) is None
+    ):
+        raise ArtifactError(
+            "sdist Cargo.lock does not use the published SymJIT dependency"
+        )
+    return {field: str(symjit[field]) for field in _RELEASE_SYMJIT_FIELDS}
+
+
+def audit_sdist(path: Path, *, mode: str) -> SdistReport:
+    """Validate a release sdist's structure and dependency boundary."""
+
+    path = path.resolve()
+    if mode != "release":
+        raise ArtifactError("candidate source distributions are not supported")
+    with external_temporary_directory("pyamplicol-sdist-audit-") as temporary:
+        source = safe_extract_sdist(path, temporary / "source")
+        relative_files = {
+            item.relative_to(source).as_posix(): item
+            for item in source.rglob("*")
+            if item.is_file()
+        }
+        _release_sdist_symjit_contract(relative_files)
+        _validate_sdist_inventory(set(relative_files))
+        _validate_prepared_model_assets(
+            {name: item.read_bytes() for name, item in relative_files.items()},
+            prefix=_PREPARED_MODEL_SDIST_PREFIX,
+            mode="release",
+        )
+        cargo = relative_files["Cargo.toml"].read_text(encoding="utf-8")
+        match = re.search(r'(?m)^version = "([^"]+)"$', cargo)
+        if match is None:
+            raise ArtifactError("sdist Cargo.toml has no workspace version")
+        cargo_version = match.group(1)
+        if cargo_version != EXPECTED_RELEASE_VERSION:
+            raise ArtifactError("release sdist contains a non-release version")
+        version = EXPECTED_RELEASE_VERSION
+
+        try:
+            build_info = json.loads(
+                relative_files["src/pyamplicol/_build_info.json"].read_text(
+                    encoding="utf-8"
+                )
+            )
+        except (OSError, TypeError, ValueError) as error:
+            raise ArtifactError("release sdist build marker is unreadable") from error
+        source_revision = (
+            build_info.get("source_revision") if isinstance(build_info, dict) else None
+        )
+        if (
+            not isinstance(build_info, dict)
+            or set(build_info) != _RELEASE_BUILD_INFO_FIELDS
+            or build_info.get("schema_version") != 1
+            or build_info.get("publishable") is not True
+            or build_info.get("selftest_fixture_bootstrap") is not False
+            or build_info.get("version") != version
+            or not isinstance(source_revision, str)
+            or re.fullmatch(r"[0-9a-f]{40}", source_revision) is None
+        ):
+            raise ArtifactError("release sdist build marker is missing or inconsistent")
+
+        pyproject = relative_files["pyproject.toml"].read_text(encoding="utf-8")
+        try:
+            pyproject_data = tomllib.loads(pyproject)
+        except tomllib.TOMLDecodeError as error:
+            raise ArtifactError(
+                f"sdist contains invalid pyproject.toml: {error}"
+            ) from error
+        _reject_direct_requirements(
+            _project_requirements(pyproject_data),
+            description="sdist project metadata",
+        )
+        scan_names = {
+            name
+            for name in relative_files
+            if name
+            in {
+                "Cargo.lock",
+                "Cargo.toml",
+                "dependencies/release-lock.toml",
+                "pyproject.toml",
+                "src/pyamplicol/_build_info.json",
+            }
+            or ("MANIFEST" in Path(name).name and name.endswith(".toml"))
+            or (name.startswith("tests/fixtures/reference/") and name.endswith(".json"))
+            or name.startswith(".cargo/")
+        }
+        for name in sorted(scan_names):
+            item = relative_files[name]
+            data = item.read_bytes()
+            for marker in _FORBIDDEN_PATH_MARKERS:
+                if _contains_forbidden_path(data, marker):
+                    raise ArtifactError(
+                        f"sdist member {name} embeds non-relocatable path marker "
+                        f"{os.fsdecode(marker)!r}"
+                    )
+        expected_base = f"pyamplicol-{version}"
+        if source.name != expected_base or path.name != f"{expected_base}.tar.gz":
+            raise ArtifactError(
+                "sdist filename/root does not match package identity: "
+                f"{path.name}, {source.name}"
+            )
+    return SdistReport(
+        filename=path.name,
+        version=version,
+        size=path.stat().st_size,
+        sha256=sha256(path),
+    )
+
+
+__all__ = [
+    "MAX_WHEEL_BYTES",
+    "RELEASE_TARGETS",
+    "ArtifactError",
+    "SdistReport",
+    "WheelReport",
+    "audit_sdist",
+    "audit_wheel",
+]
diff --git a/pyamplicol/tools/release/_common.py b/pyamplicol/tools/release/_common.py
new file mode 100644
index 0000000000..64788ce42e
--- /dev/null
+++ b/pyamplicol/tools/release/_common.py
@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Shared safety and subprocess helpers for release tooling."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import contextmanager
+from pathlib import Path, PurePosixPath
+
+ROOT = Path(__file__).resolve().parents[2]
+DIST = ROOT / "dist"
+CANDIDATE_ARTIFACTS = ROOT / ".artifacts" / "candidate"
+DEPLOYMENT_ROOT = ROOT / "PYPI_DEPLOYMENT_TEST"
+DEPENDENCY_WHEELHOUSE = ROOT / "dependencies" / "wheelhouse"
+DEPENDENCY_GATE = ROOT / "tools" / "release" / "check_dependencies.py"
+MAX_ARCHIVE_FILES = 100_000
+MAX_UNPACKED_SDIST_BYTES = 2 * 1024 * 1024 * 1024
+
+
+class ReleaseError(RuntimeError):
+    """A release invariant was not satisfied."""
+
+
+def build_mode(*, candidate: bool = False) -> str:
+    """Resolve and validate candidate/release mode without silent conflicts."""
+
+    configured = os.environ.get("PYAMPLICOL_BUILD_MODE")
+    if configured is not None and configured not in {"candidate", "release"}:
+        raise ReleaseError("PYAMPLICOL_BUILD_MODE must be 'candidate' or 'release'")
+    requested = "candidate" if candidate else configured or "release"
+    if candidate and configured == "release":
+        raise ReleaseError("--candidate conflicts with PYAMPLICOL_BUILD_MODE=release")
+    return requested
+
+
+_PIP_INJECTION_VARIABLES = {
+    "PIP_CONFIG_FILE",
+    "PIP_CONSTRAINT",
+    "PIP_EXTRA_INDEX_URL",
+    "PIP_FIND_LINKS",
+    "PIP_INDEX_URL",
+    "PIP_NO_INDEX",
+    "PIP_PREFIX",
+    "PIP_REQUIREMENT",
+    "PIP_TARGET",
+    "PIP_TRUSTED_HOST",
+    "PIP_USER",
+}
+
+_NATIVE_BUILD_INJECTION_VARIABLES = {
+    "AR",
+    "C_INCLUDE_PATH",
+    "CC",
+    "CFLAGS",
+    "CPATH",
+    "CPLUS_INCLUDE_PATH",
+    "CXX",
+    "CXXFLAGS",
+    "DYLD_FALLBACK_LIBRARY_PATH",
+    "DYLD_INSERT_LIBRARIES",
+    "DYLD_LIBRARY_PATH",
+    "LD_LIBRARY_PATH",
+    "LDFLAGS",
+    "LIBRARY_PATH",
+    "MACOSX_DEPLOYMENT_TARGET",
+    "OBJC_INCLUDE_PATH",
+    "PKG_CONFIG_PATH",
+    "RUSTFLAGS",
+    "SDKROOT",
+}
+
+
+def clean_environment(
+    updates: Mapping[str, str] | None = None,
+    *,
+    mode: str | None = None,
+    virtual_env: Path | None = None,
+) -> dict[str, str]:
+    """Return an environment with Python and pip path injection disabled."""
+
+    environment = dict(os.environ)
+    for name in (
+        _PIP_INJECTION_VARIABLES
+        | _NATIVE_BUILD_INJECTION_VARIABLES
+        | {
+            "PYTHONHOME",
+            "PYTHONPATH",
+            "VIRTUAL_ENV",
+            "_OLD_VIRTUAL_PATH",
+        }
+    ):
+        environment.pop(name, None)
+    environment.update(
+        {
+            "PIP_CONFIG_FILE": os.devnull,
+            "PIP_DISABLE_PIP_VERSION_CHECK": "1",
+            "PYTHONDONTWRITEBYTECODE": "1",
+            "PYTHONNOUSERSITE": "1",
+        }
+    )
+    if mode is not None:
+        if mode not in {"candidate", "release"}:
+            raise ReleaseError(f"unsupported build mode: {mode}")
+        environment["PYAMPLICOL_BUILD_MODE"] = mode
+    if virtual_env is not None:
+        binary = virtual_env / ("Scripts" if os.name == "nt" else "bin")
+        environment["VIRTUAL_ENV"] = str(virtual_env)
+        environment["PATH"] = str(binary) + os.pathsep + environment.get("PATH", "")
+    if updates:
+        environment.update(updates)
+    return environment
+
+
+def runtime_environment(virtual_env: Path) -> dict[str, str]:
+    """Create a runtime environment that cannot discover a Rust toolchain."""
+
+    environment = clean_environment(virtual_env=virtual_env)
+    binary = virtual_env / ("Scripts" if os.name == "nt" else "bin")
+    system_paths = (
+        [Path(os.environ.get("SYSTEMROOT", r"C:\Windows")) / "System32"]
+        if os.name == "nt"
+        else [Path("/usr/bin"), Path("/bin")]
+    )
+    environment["PATH"] = os.pathsep.join(
+        str(path) for path in (binary, *system_paths) if path.is_dir()
+    )
+    environment.pop("CARGO_HOME", None)
+    environment.pop("RUSTUP_HOME", None)
+    return environment
+
+
+def run(
+    command: Sequence[str | os.PathLike[str]],
+    *,
+    cwd: Path | None = None,
+    env: Mapping[str, str] | None = None,
+    capture_output: bool = False,
+    dry_run: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    """Run a command visibly and fail with a concise release-tool error."""
+
+    rendered = [os.fspath(part) for part in command]
+    suffix = f"  # cwd={cwd}" if cwd is not None else ""
+    print(f"$ {shlex.join(rendered)}{suffix}")
+    if dry_run:
+        return subprocess.CompletedProcess(rendered, 0, "", "")
+    completed = subprocess.run(
+        rendered,
+        cwd=cwd,
+        env=dict(env) if env is not None else None,
+        capture_output=capture_output,
+        text=True,
+    )
+    if completed.returncode != 0:
+        if capture_output:
+            if completed.stdout:
+                print(completed.stdout, end="")
+            if completed.stderr:
+                print(completed.stderr, end="", file=sys.stderr)
+        raise ReleaseError(
+            f"command exited with {completed.returncode}: {shlex.join(rendered)}"
+        )
+    return completed
+
+
+def check_dependency_gate(mode: str) -> None:
+    """Call the normative dependency gate in the requested mode."""
+
+    if mode not in {"candidate", "release"}:
+        raise ReleaseError(f"unsupported dependency-gate mode: {mode}")
+    command: list[str | os.PathLike[str]] = [sys.executable, DEPENDENCY_GATE]
+    if mode == "candidate":
+        command.append("--candidate")
+    run(command, cwd=ROOT, env=clean_environment(mode=mode))
+
+
+def require_clean_checkout(*, allow_dirty_candidate: bool, mode: str) -> None:
+    """Require a clean checkout for candidate builds unless explicitly allowed."""
+
+    if mode != "candidate" or allow_dirty_candidate:
+        return
+    completed = run(
+        ["git", "status", "--porcelain=v1", "--untracked-files=all", "--", "."],
+        cwd=ROOT,
+        env=clean_environment(),
+        capture_output=True,
+    )
+    dirty = completed.stdout.strip()
+    if dirty:
+        preview = "\n".join(dirty.splitlines()[:20])
+        raise ReleaseError(
+            "candidate artifacts require a clean checkout; Git reported:\n" + preview
+        )
+
+
+def is_relative_to(path: Path, parent: Path) -> bool:
+    try:
+        path.relative_to(parent)
+    except ValueError:
+        return False
+    return True
+
+
+def containing_workspace() -> Path:
+    """Return the checkout's containing workspace without treating / as one."""
+
+    parent = ROOT.parent.resolve()
+    filesystem_root = Path(parent.anchor)
+    if parent == filesystem_root:
+        return ROOT.resolve()
+    if parent.name == "PREPARE_STANDALONE_PYAMPLICOL":
+        return parent.parent
+    return parent
+
+
+def _release_temporary_path_is_isolated(path: Path) -> bool:
+    """Accept external scratch or the checkout's dedicated artifact tree."""
+
+    workspace = containing_workspace()
+    if not is_relative_to(path, workspace):
+        return True
+    artifact_root = (ROOT / ".artifacts").resolve()
+    return is_relative_to(path, artifact_root)
+
+
+@contextmanager
+def external_temporary_directory(prefix: str) -> Iterator[Path]:
+    """Create scratch outside tracked source, including under ``.artifacts``."""
+
+    with tempfile.TemporaryDirectory(prefix=prefix) as raw:
+        path = Path(raw).resolve()
+        if not _release_temporary_path_is_isolated(path):
+            raise ReleaseError(
+                "temporary release workspace must be outside "
+                f"{containing_workspace()} or below {ROOT / '.artifacts'}: {path}"
+            )
+        yield path
+
+
+def _safe_archive_name(name: str) -> PurePosixPath:
+    if not name or "\\" in name:
+        raise ReleaseError(f"unsafe sdist member name: {name!r}")
+    relative = PurePosixPath(name)
+    if relative.is_absolute() or any(
+        part in {"", ".", ".."} for part in relative.parts
+    ):
+        raise ReleaseError(f"unsafe sdist member path: {name}")
+    return relative
+
+
+def safe_extract_sdist(sdist: Path, destination: Path) -> Path:
+    """Extract one regular-file sdist tree without trusting tar paths or links."""
+
+    if not sdist.is_file():
+        raise ReleaseError(f"sdist does not exist: {sdist}")
+    destination.mkdir(parents=True, exist_ok=True)
+    roots: set[str] = set()
+    seen: set[PurePosixPath] = set()
+    unpacked_size = 0
+    with tarfile.open(sdist, mode="r:*") as archive:
+        members = archive.getmembers()
+        if len(members) > MAX_ARCHIVE_FILES:
+            raise ReleaseError(f"sdist contains too many members: {len(members)}")
+        for member in members:
+            relative = _safe_archive_name(member.name.rstrip("/"))
+            if relative in seen:
+                raise ReleaseError(f"sdist contains duplicate member: {relative}")
+            seen.add(relative)
+            roots.add(relative.parts[0])
+            if not (member.isdir() or member.isreg()):
+                raise ReleaseError(
+                    f"sdist may contain only directories and regular files: {relative}"
+                )
+            unpacked_size += member.size
+            if unpacked_size > MAX_UNPACKED_SDIST_BYTES:
+                raise ReleaseError("sdist exceeds the unpacked size safety limit")
+
+            target = destination.joinpath(*relative.parts)
+            if member.isdir():
+                target.mkdir(parents=True, exist_ok=True)
+                continue
+            target.parent.mkdir(parents=True, exist_ok=True)
+            stream = archive.extractfile(member)
+            if stream is None:
+                raise ReleaseError(f"could not read sdist member: {relative}")
+            with stream, target.open("xb") as output:
+                shutil.copyfileobj(stream, output, length=1024 * 1024)
+            target.chmod((member.mode & 0o777) or 0o644)
+    if len(roots) != 1:
+        raise ReleaseError(
+            "sdist must contain exactly one top-level directory, found "
+            + ", ".join(sorted(roots))
+        )
+    root = destination / next(iter(roots))
+    if not root.is_dir():
+        raise ReleaseError("sdist top-level member is not a directory")
+    return root
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while block := stream.read(1024 * 1024):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def exactly_one(paths: Sequence[Path], description: str) -> Path:
+    candidates = sorted(path.resolve() for path in paths)
+    if len(candidates) != 1:
+        rendered = ", ".join(str(path) for path in candidates) or "none"
+        raise ReleaseError(
+            f"expected exactly one {description}, found {len(candidates)}: {rendered}"
+        )
+    return candidates[0]
+
+
+__all__ = [
+    "CANDIDATE_ARTIFACTS",
+    "DEPENDENCY_GATE",
+    "DEPENDENCY_WHEELHOUSE",
+    "DEPLOYMENT_ROOT",
+    "DIST",
+    "ROOT",
+    "ReleaseError",
+    "build_mode",
+    "check_dependency_gate",
+    "clean_environment",
+    "containing_workspace",
+    "exactly_one",
+    "external_temporary_directory",
+    "require_clean_checkout",
+    "run",
+    "runtime_environment",
+    "safe_extract_sdist",
+    "sha256",
+]
diff --git a/pyamplicol/tools/release/audit_sdist.py b/pyamplicol/tools/release/audit_sdist.py
new file mode 100644
index 0000000000..ab2c84a0fe
--- /dev/null
+++ b/pyamplicol/tools/release/audit_sdist.py
@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Required source-distribution inventory for release audits."""
+
+from __future__ import annotations
+
+from collections.abc import Collection
+
+PREPARED_MODEL_ARCHITECTURES = ("aarch64", "x86_64")
+PREPARED_MODEL_ASSET_BASENAME = "built-in-sm-jit-o2"
+PREPARED_MODEL_ASSETS = {
+    PREPARED_MODEL_ASSET_BASENAME: "built-in-sm",
+    "built-in-sm-heft-jit-o2": "built-in-sm-heft",
+}
+
+
+def prepared_model_asset_members(prefix: str) -> frozenset[str]:
+    """Return the exact prepared-model inventory rooted at *prefix*."""
+
+    root = prefix.rstrip("/")
+    members = {f"{root}/__init__.py"}
+    for identifier in PREPARED_MODEL_ASSETS:
+        for architecture in PREPARED_MODEL_ARCHITECTURES:
+            stem = f"{identifier}-{architecture}"
+            members.update(
+                {
+                    f"{root}/{stem}.metadata.json",
+                    f"{root}/{stem}.pyamplicol-model",
+                }
+            )
+    return frozenset(members)
+
+
+PREPARED_MODEL_SDIST_MEMBERS = prepared_model_asset_members(
+    "src/pyamplicol/assets/prepared_models"
+)
+
+REQUIRED_SDIST_MEMBERS = frozenset(
+    {
+        "Cargo.lock",
+        "Cargo.toml",
+        "rust-toolchain.toml",
+        "LICENSE",
+        "README.md",
+        "THIRD_PARTY_NOTICES.md",
+        "justfile",
+        "build_backend/_pyamplicol_build.py",
+        "build_backend/sdk.py",
+        "dependencies/release-lock.toml",
+        "docs/README.md",
+        "docs/user/installation.md",
+        "examples/builtin_sm_lc.toml",
+        "examples/data/pp_zjj_momenta.json",
+        "examples/native/Makefile",
+        "examples/python/typed_generation.py",
+        "pyproject.toml",
+        "rust/crates/rusticol-capi/Cargo.toml",
+        "rust/crates/rusticol-capi/build.rs",
+        "rust/crates/rusticol-capi/fortran/rusticol.f90",
+        "rust/crates/rusticol-capi/include/rusticol.h",
+        "rust/crates/rusticol-capi/include/rusticol.hpp",
+        "rust/crates/rusticol-capi/src/lib.rs",
+        "rust/crates/rusticol-python/stubs/pyamplicol/_rusticol.pyi",
+        "schemas/README.md",
+        "schemas/artifact-manifest-v3.schema.json",
+        "schemas/reference-oracle-evidence-v2.schema.json",
+        "schemas/reference-fixture-bundle-v1.schema.json",
+        "schemas/reference-physics-v2.schema.json",
+        "schemas/runtime-physics-v1.schema.json",
+        "src/pyamplicol/assets/api_templates/rust/Makefile",
+        "src/pyamplicol/assets/api_templates/rust/check_standalone.rs",
+        "src/pyamplicol/assets/api_templates/umami/Makefile",
+        "src/pyamplicol/assets/api_templates/umami/umami.h",
+        "src/pyamplicol/assets/api_templates/umami/umami.c",
+        "src/pyamplicol/assets/api_templates/umami/umami_provider.h",
+        "src/pyamplicol/assets/api_templates/umami/umami_driver.c",
+        "src/pyamplicol/assets/api_templates/umami/umami.exports",
+        "src/pyamplicol/assets/api_templates/umami/umami.exports.macos",
+        "src/pyamplicol/assets/api_templates/umami/UMAMI_LICENSE",
+        "src/pyamplicol/assets/api_templates/umami/README.md",
+        "src/pyamplicol/_build_info.json",
+        "src/rusticol_config/__init__.py",
+        "src/rusticol_config/__main__.py",
+        *PREPARED_MODEL_SDIST_MEMBERS,
+        "src/pyamplicol/assets/selftest/portable-64le/expected.json",
+        "src/pyamplicol/assets/selftest/portable-64le/artifact/artifact.json",
+        "tests/integration/test_examples.py",
+        "tests/fixtures/reference/analytic-oracles-v2.json",
+        "tests/fixtures/reference/legacy-fortran-v2.json",
+        "tests/fixtures/reference/physics-v2.json",
+        "tests/fixtures/reference/reference-fixture-v2.manifest.json",
+        "tests/release/test_artifacts.py",
+        "tests/unit/test_capture_reference_fixture_v2.py",
+        "tests/unit/test_reference_fixture_v2.py",
+        "tests/unit/test_tracked_reference_fixture_v2.py",
+        "tests/unit/test_cli_utilities.py",
+        "tools/developer/analytic_oracles.py",
+        "tools/developer/capture_reference_fixture_v2.py",
+        "tools/developer/legacy_amplicol.py",
+        "tools/developer/legacy_oracle/__init__.py",
+        "tools/developer/legacy_oracle/checkout.py",
+        "tools/developer/legacy_oracle/evidence.py",
+        "tools/developer/legacy_oracle/model.py",
+        "tools/developer/legacy_oracle/probe.py",
+        "tools/developer/legacy_oracle/processes.py",
+        "tools/developer/prepare_source_runtime.py",
+        "tools/developer/reference_capture/__init__.py",
+        "tools/developer/reference_capture/artifacts.py",
+        "tools/developer/reference_capture/common.py",
+        "tools/developer/reference_capture/evidence.py",
+        "tools/developer/reference_capture/pipeline.py",
+        "tools/developer/reference_capture/points.py",
+        "tools/developer/reference_capture/provenance.py",
+        "tools/developer/reference_fixture/__init__.py",
+        "tools/developer/reference_fixture/api.py",
+        "tools/developer/reference_fixture/codec.py",
+        "tools/developer/reference_fixture/evidence.py",
+        "tools/developer/reference_fixture/model.py",
+        "tools/developer/reference_fixture/numerics.py",
+        "tools/developer/reference_fixture/structure.py",
+        "tools/developer/reference_fixture_v2.py",
+        "tools/release/_artifacts.py",
+        "tools/release/_common.py",
+        "tools/release/audit_sdist.py",
+        "tools/release/build_from_sdist.py",
+        "tools/release/build_release_artifacts.py",
+        "tools/release/check_dependencies.py",
+        "tools/release/install_wheel.py",
+        "tools/release/prepare_selftest_fixture.py",
+        "tools/release/publish_dry_run.py",
+        "tools/release/run_cargo.py",
+        "tools/release/test_deployment.py",
+        "tools/typing/check_public_typing.py",
+    }
+)
+
+
+def missing_required_sdist_members(members: Collection[str]) -> tuple[str, ...]:
+    """Return required release members absent from an extracted sdist."""
+
+    return tuple(sorted(REQUIRED_SDIST_MEMBERS.difference(members)))
+
+
+__all__ = [
+    "PREPARED_MODEL_ARCHITECTURES",
+    "PREPARED_MODEL_ASSETS",
+    "PREPARED_MODEL_ASSET_BASENAME",
+    "PREPARED_MODEL_SDIST_MEMBERS",
+    "REQUIRED_SDIST_MEMBERS",
+    "missing_required_sdist_members",
+    "prepared_model_asset_members",
+]
diff --git a/pyamplicol/tools/release/build_from_sdist.py b/pyamplicol/tools/release/build_from_sdist.py
new file mode 100644
index 0000000000..88f3d57187
--- /dev/null
+++ b/pyamplicol/tools/release/build_from_sdist.py
@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Build and audit a wheel from one clean, externally unpacked sdist."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from _artifacts import audit_sdist, audit_wheel
+from _common import (
+    CANDIDATE_ARTIFACTS,
+    DIST,
+    ReleaseError,
+    build_mode,
+    check_dependency_gate,
+    clean_environment,
+    exactly_one,
+    external_temporary_directory,
+    run,
+    safe_extract_sdist,
+)
+
+
+def build_wheel_from_sdist(
+    sdist: Path,
+    source_wheel: Path,
+    output_directory: Path,
+    *,
+    mode: str,
+    python: Path,
+    replace: bool = False,
+) -> Path:
+    """Build from an untouched sdist and retain the independently audited wheel."""
+
+    python = python.resolve()
+    sdist = sdist.resolve()
+    source_wheel = source_wheel.resolve()
+    output_directory = output_directory.resolve()
+    audit_sdist(sdist, mode=mode)
+    source_report = audit_wheel(source_wheel, mode=mode)
+    with external_temporary_directory("pyamplicol-from-sdist-") as temporary:
+        source = safe_extract_sdist(sdist, temporary / "unpacked")
+        wheel_directory = temporary / "wheel"
+        wheel_directory.mkdir()
+        run(
+            [python, "-m", "build", "--wheel", "--outdir", wheel_directory],
+            cwd=source,
+            env=clean_environment(mode=mode),
+        )
+        rebuilt = exactly_one(
+            list(wheel_directory.glob("pyamplicol-*.whl")),
+            "wheel rebuilt from sdist",
+        )
+        rebuilt_report = audit_wheel(rebuilt, mode=mode)
+        if rebuilt.name != source_wheel.name:
+            raise ReleaseError(
+                "source and sdist wheels have different filenames: "
+                f"{source_wheel.name} != {rebuilt.name}"
+            )
+        identity_fields = ("version", "python_tag", "abi_tag", "target", "rust_target")
+        if any(
+            getattr(source_report, field) != getattr(rebuilt_report, field)
+            for field in identity_fields
+        ):
+            raise ReleaseError(
+                "source and sdist wheels have different package or platform metadata"
+            )
+
+        output_directory.mkdir(parents=True, exist_ok=True)
+        target = output_directory / rebuilt.name
+        if target.exists() and not replace:
+            raise ReleaseError(f"refusing to overwrite existing wheel: {target}")
+        staged = output_directory / f".{rebuilt.name}.from-sdist"
+        if staged.exists():
+            raise ReleaseError(f"stale staged wheel must be removed first: {staged}")
+        shutil.copy2(rebuilt, staged)
+        os.replace(staged, target)
+    print(f"Built and audited wheel from clean sdist: {target}")
+    return target
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--candidate", action="store_true")
+    parser.add_argument("--python", type=Path, default=Path(sys.executable))
+    parser.add_argument("--sdist", type=Path)
+    parser.add_argument("--source-wheel", type=Path)
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        help="destination for the retained sdist-built wheel; defaults to artifact dir",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    mode = build_mode(candidate=args.candidate)
+    check_dependency_gate(mode)
+    artifact_directory = CANDIDATE_ARTIFACTS if mode == "candidate" else DIST
+    sdist = args.sdist or exactly_one(
+        list(artifact_directory.glob("pyamplicol-*.tar.gz")), "pyamplicol sdist"
+    )
+    source_wheel = args.source_wheel or exactly_one(
+        list(artifact_directory.glob("pyamplicol-*.whl")),
+        "direct-source pyamplicol wheel",
+    )
+    output_directory = args.output_dir or artifact_directory
+    build_wheel_from_sdist(
+        sdist,
+        source_wheel,
+        output_directory,
+        mode=mode,
+        python=args.python,
+        replace=args.output_dir is None,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except ReleaseError as error:
+        print(f"error: {error}", file=sys.stderr)
+        raise SystemExit(2) from error
diff --git a/pyamplicol/tools/release/build_release_artifacts.py b/pyamplicol/tools/release/build_release_artifacts.py
new file mode 100644
index 0000000000..811f750af1
--- /dev/null
+++ b/pyamplicol/tools/release/build_release_artifacts.py
@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Build audited candidate or release artifacts without publishing them."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from _artifacts import audit_sdist, audit_wheel
+from _common import (
+    CANDIDATE_ARTIFACTS,
+    DIST,
+    ROOT,
+    ReleaseError,
+    build_mode,
+    check_dependency_gate,
+    clean_environment,
+    exactly_one,
+    external_temporary_directory,
+    require_clean_checkout,
+    run,
+)
+from build_from_sdist import build_wheel_from_sdist
+
+
+def _prepare_output(directory: Path) -> Path:
+    directory = directory.resolve()
+    directory.mkdir(parents=True, exist_ok=True)
+    existing = [
+        path
+        for pattern in (
+            "pyamplicol-*.whl",
+            "pyamplicol-*.tar.gz",
+        )
+        for path in directory.glob(pattern)
+    ]
+    if existing:
+        raise ReleaseError(
+            "artifact output must not contain a previous release bundle: "
+            + ", ".join(path.name for path in sorted(existing))
+        )
+    return directory
+
+
+def _build(
+    python: Path,
+    destination: Path,
+    *,
+    mode: str,
+    wheel: bool,
+    sdist: bool,
+) -> None:
+    command: list[str | Path] = [python, "-m", "build"]
+    if wheel:
+        command.append("--wheel")
+    if sdist:
+        command.append("--sdist")
+    command.extend(("--outdir", destination))
+    run(command, cwd=ROOT, env=clean_environment(mode=mode))
+
+
+def build_release_artifacts(
+    output_directory: Path,
+    *,
+    mode: str,
+    python: Path,
+    allow_dirty_candidate: bool,
+    sdist_only: bool,
+    retained_sdist_path: Path | None,
+) -> list[Path]:
+    python = python.resolve()
+    if mode == "release" and allow_dirty_candidate:
+        raise ReleaseError("--allow-dirty is available only for candidate builds")
+    if sdist_only and retained_sdist_path is not None:
+        raise ReleaseError("--sdist-only and --retained-sdist are mutually exclusive")
+    if mode == "candidate" and sdist_only:
+        raise ReleaseError("candidate artifact production is wheel-only")
+    if mode == "candidate" and retained_sdist_path is not None:
+        raise ReleaseError(
+            "candidate sdists are non-publishable and are not release parity inputs"
+        )
+    check_dependency_gate(mode)
+    if mode == "candidate":
+        require_clean_checkout(
+            allow_dirty_candidate=allow_dirty_candidate,
+            mode=mode,
+        )
+    output_directory = _prepare_output(output_directory)
+
+    with external_temporary_directory("pyamplicol-release-build-") as temporary:
+        direct_directory = temporary / "direct"
+        rebuilt_directory = temporary / "rebuilt"
+        direct_directory.mkdir()
+        rebuilt_directory.mkdir()
+
+        if sdist_only:
+            _build(python, direct_directory, mode=mode, wheel=False, sdist=True)
+            sdist = exactly_one(
+                list(direct_directory.glob("pyamplicol-*.tar.gz")), "built sdist"
+            )
+            audit_sdist(sdist, mode=mode)
+            retained = output_directory / sdist.name
+            shutil.copy2(sdist, retained)
+            return [retained]
+
+        _build(
+            python,
+            direct_directory,
+            mode=mode,
+            wheel=True,
+            sdist=mode == "release" and retained_sdist_path is None,
+        )
+        direct_wheel = exactly_one(
+            list(direct_directory.glob("pyamplicol-*.whl")),
+            "direct-source wheel",
+        )
+        audit_wheel(direct_wheel, mode=mode)
+
+        if mode == "candidate":
+            candidate_wheel = output_directory / direct_wheel.name
+            shutil.copy2(direct_wheel, candidate_wheel)
+            return [candidate_wheel]
+
+        if retained_sdist_path is None:
+            retained_sdist_path = exactly_one(
+                list(direct_directory.glob("pyamplicol-*.tar.gz")), "built sdist"
+            )
+        retained_sdist_path = retained_sdist_path.resolve()
+        audit_sdist(retained_sdist_path, mode="release")
+        rebuilt_wheel = build_wheel_from_sdist(
+            retained_sdist_path,
+            direct_wheel,
+            rebuilt_directory,
+            mode="release",
+            python=python,
+        )
+        audit_wheel(rebuilt_wheel, mode="release")
+
+        copied_wheel = output_directory / rebuilt_wheel.name
+        shutil.copy2(rebuilt_wheel, copied_wheel)
+        copied: list[Path] = [copied_wheel]
+        if retained_sdist_path.parent == direct_directory:
+            copied_sdist = output_directory / retained_sdist_path.name
+            shutil.copy2(retained_sdist_path, copied_sdist)
+            copied.append(copied_sdist)
+        return copied
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--candidate", action="store_true")
+    parser.add_argument("--python", type=Path, default=Path(sys.executable))
+    parser.add_argument("--output-dir", type=Path)
+    parser.add_argument(
+        "--allow-dirty",
+        action="store_true",
+        help="allow a candidate build from a dirty checkout",
+    )
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--sdist-only", action="store_true")
+    group.add_argument("--retained-sdist", type=Path)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    mode = build_mode(candidate=args.candidate)
+    output = args.output_dir or (CANDIDATE_ARTIFACTS if mode == "candidate" else DIST)
+    artifacts = build_release_artifacts(
+        output,
+        mode=mode,
+        python=args.python,
+        allow_dirty_candidate=args.allow_dirty,
+        sdist_only=args.sdist_only,
+        retained_sdist_path=args.retained_sdist,
+    )
+    heading = (
+        "Retained NON-PUBLISHABLE candidate artifacts:"
+        if mode == "candidate"
+        else "Retained validated release artifacts:"
+    )
+    print(heading)
+    for artifact in artifacts:
+        print(f"  {artifact}")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except ReleaseError as error:
+        print(f"error: {error}", file=sys.stderr)
+        raise SystemExit(2) from error
diff --git a/pyamplicol/tools/release/check_dependencies.py b/pyamplicol/tools/release/check_dependencies.py
new file mode 100644
index 0000000000..33ee5a4e2c
--- /dev/null
+++ b/pyamplicol/tools/release/check_dependencies.py
@@ -0,0 +1,801 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Validate the small published or contributor dependency contract."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+try:
+    from packaging.requirements import InvalidRequirement, Requirement
+    from packaging.version import InvalidVersion, Version
+except ModuleNotFoundError:  # pragma: no cover - pip vendors the build fallback
+    from pip._vendor.packaging.requirements import (  # type: ignore[no-redef]
+        InvalidRequirement,
+        Requirement,
+    )
+    from pip._vendor.packaging.version import (  # type: ignore[no-redef]
+        InvalidVersion,
+        Version,
+    )
+
+ROOT = Path(__file__).resolve().parents[2]
+LOCK_PATH = ROOT / "dependencies" / "release-lock.toml"
+CONTRIBUTOR_LOCK_PATH = ROOT / "dependencies" / "contributor-lock.toml"
+PYPROJECT_PATH = ROOT / "pyproject.toml"
+CARGO_LOCK_PATH = ROOT / "Cargo.lock"
+RUST_TOOLCHAIN_PATH = ROOT / "rust-toolchain.toml"
+STATE_PATH = ROOT / "dependencies" / "install-state.json"
+CANDIDATE_LOCK_PATH = ROOT / "dependencies" / "candidate-Cargo.lock"
+CARGO_CONFIG_PATH = ROOT / "dependencies" / "candidate-cargo-config.toml"
+CHECKOUTS_PATH = ROOT / "dependencies" / "checkouts"
+
+_REGISTRY_SOURCE = "registry+https://github.com/rust-lang/crates.io-index"
+_LOCAL_CRATES = {"rusticol-capi", "rusticol-core", "rusticol-python"}
+_CANDIDATE_LOCAL_CRATES = {
+    *_LOCAL_CRATES,
+    "graphica",
+    "numerica",
+    "symbolica",
+    "symjit",
+}
+_SHA256 = re.compile(r"[0-9a-f]{64}")
+_GIT_REVISION = re.compile(r"[0-9a-f]{40}")
+_CANONICAL_NAME = re.compile(r"[-_.]+")
+_CANDIDATE_ABIS = {
+    "symbolica_serialization": "symbolica-bincode2-v1",
+    "symjit_application": "symjit-application-storage-v3",
+    "symjit_plane_application": "pyamplicol-symjit-plane-application-v2",
+}
+
+
+@dataclass(frozen=True)
+class GateIssue:
+    code: str
+    message: str
+
+
+def canonicalize_name(value: str) -> str:
+    return _CANONICAL_NAME.sub("-", value).lower()
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    with path.open("rb") as stream:
+        payload = tomllib.load(stream)
+    if not isinstance(payload, dict):
+        raise ValueError(f"{path} must contain a TOML table")
+    return payload
+
+
+def _load_lock() -> dict[str, Any]:
+    payload = _load_toml(LOCK_PATH)
+    if payload.get("schema_version") != 1:
+        raise ValueError("dependencies/release-lock.toml must use schema_version = 1")
+    return payload
+
+
+def _load_contributor_lock() -> dict[str, Any]:
+    payload = _load_toml(CONTRIBUTOR_LOCK_PATH)
+    if payload.get("schema_version") != 1:
+        raise ValueError(
+            "dependencies/contributor-lock.toml must use schema_version = 1"
+        )
+    return payload
+
+
+def _locked_python_dependencies(lock: dict[str, Any]) -> dict[str, str]:
+    raw = lock.get("python_dependencies")
+    if not isinstance(raw, list) or not raw:
+        raise ValueError("release lock must list exact Python dependencies")
+    dependencies: dict[str, str] = {}
+    ordered_names: list[str] = []
+    for index, entry in enumerate(raw):
+        if not isinstance(entry, dict) or set(entry) != {"distribution", "version"}:
+            raise ValueError(
+                f"python_dependencies[{index}] must contain only distribution/version"
+            )
+        distribution = entry["distribution"]
+        version = entry["version"]
+        if not isinstance(distribution, str) or not isinstance(version, str):
+            raise ValueError(
+                f"python_dependencies[{index}] needs string distribution/version"
+            )
+        name = canonicalize_name(distribution)
+        try:
+            normalized_version = str(Version(version))
+        except InvalidVersion as error:
+            raise ValueError(f"invalid locked version for {name}: {version}") from error
+        if name in dependencies:
+            raise ValueError(f"release lock repeats Python dependency {name}")
+        ordered_names.append(name)
+        dependencies[name] = normalized_version
+    if ordered_names != sorted(ordered_names):
+        raise ValueError("release-lock Python dependencies must be name-sorted")
+    return dependencies
+
+
+def _project_python_dependencies() -> dict[str, str]:
+    project = _load_toml(PYPROJECT_PATH).get("project")
+    if not isinstance(project, dict):
+        raise ValueError("pyproject.toml has no [project] table")
+    raw = project.get("dependencies")
+    if not isinstance(raw, list) or not all(isinstance(item, str) for item in raw):
+        raise ValueError("pyproject runtime dependencies must be strings")
+    dependencies: dict[str, str] = {}
+    for value in raw:
+        try:
+            requirement = Requirement(value)
+        except InvalidRequirement as error:
+            raise ValueError(f"invalid pyproject dependency: {value}") from error
+        name = canonicalize_name(requirement.name)
+        specifiers = list(requirement.specifier)
+        if (
+            requirement.url is not None
+            or requirement.marker is not None
+            or requirement.extras
+            or len(specifiers) != 1
+            or specifiers[0].operator != "=="
+        ):
+            raise ValueError(
+                f"release runtime dependency must be one exact published pin: {value}"
+            )
+        try:
+            version = str(Version(specifiers[0].version))
+        except InvalidVersion as error:
+            raise ValueError(
+                f"invalid pyproject dependency version: {value}"
+            ) from error
+        if name in dependencies:
+            raise ValueError(f"pyproject repeats runtime dependency {name}")
+        dependencies[name] = version
+    return dependencies
+
+
+def _release_contract_issues(lock: dict[str, Any]) -> list[GateIssue]:
+    issues: list[GateIssue] = []
+    abis = lock.get("abis")
+    if not isinstance(abis, dict) or any(
+        abis.get(name) != value for name, value in _CANDIDATE_ABIS.items()
+    ):
+        issues.append(
+            GateIssue(
+                "release-abi-contract",
+                "release-lock.toml must pin the Symbolica serialization, SymJIT "
+                "storage, and SymJIT plane-application ABIs",
+            )
+        )
+    forbidden_tables = {"legal_status", "python_runtime_lock"}.intersection(lock)
+    if forbidden_tables:
+        issues.append(
+            GateIssue(
+                "release-lock-scope",
+                "release-lock.toml contains retired release machinery: "
+                + ", ".join(sorted(forbidden_tables)),
+            )
+        )
+    try:
+        locked = _locked_python_dependencies(lock)
+        project = _project_python_dependencies()
+    except (OSError, ValueError, tomllib.TOMLDecodeError) as error:
+        return [*issues, GateIssue("python-dependency-contract", str(error))]
+    if locked != project:
+        issues.append(
+            GateIssue(
+                "python-dependency-contract",
+                "pyproject exact runtime pins disagree with release-lock.toml; "
+                f"lock={locked}, pyproject={project}",
+            )
+        )
+
+    symbolica = lock.get("symbolica")
+    symjit = lock.get("symjit")
+    loader = lock.get("ufo_model_loader")
+    if (
+        not isinstance(symbolica, dict)
+        or not isinstance(symjit, dict)
+        or not isinstance(loader, dict)
+    ):
+        issues.append(
+            GateIssue(
+                "published-dependency-contract",
+                "release lock needs Symbolica, SymJIT, and ufo-model-loader "
+                "compatibility data",
+            )
+        )
+        return issues
+    allowed_symbolica = {
+        "python_distribution",
+        "python_version",
+        "rust_crate",
+        "rust_version",
+        "serialization_abi",
+    }
+    allowed_symjit = {"version"}
+    allowed_loader = {
+        "python_distribution",
+        "required_version",
+    }
+    if (
+        set(symbolica) != allowed_symbolica
+        or set(symjit) != allowed_symjit
+        or set(loader) != allowed_loader
+    ):
+        issues.append(
+            GateIssue(
+                "release-lock-scope",
+                "release dependency sections contain fields outside their approved "
+                "compatibility and source contracts",
+            )
+        )
+    symbolica_name = canonicalize_name(str(symbolica.get("python_distribution", "")))
+    loader_name = canonicalize_name(str(loader.get("python_distribution", "")))
+    if locked.get(symbolica_name) != str(symbolica.get("python_version", "")):
+        issues.append(
+            GateIssue(
+                "symbolica-pin",
+                "Symbolica compatibility data disagrees with the exact Python pin",
+            )
+        )
+    if locked.get(loader_name) != str(loader.get("required_version", "")):
+        issues.append(
+            GateIssue(
+                "ufo-loader-pin",
+                "ufo-model-loader compatibility data disagrees with the exact pin",
+            )
+        )
+    return issues
+
+
+def _cargo_packages(path: Path) -> list[dict[str, Any]]:
+    payload = _load_toml(path)
+    packages = payload.get("package")
+    if not isinstance(packages, list) or not all(
+        isinstance(package, dict) for package in packages
+    ):
+        raise ValueError(f"{path} has no Cargo package array")
+    return packages
+
+
+def _registry_source_issues(
+    packages: list[dict[str, Any]],
+    *,
+    local_crates: set[str],
+    prefix: str,
+) -> list[GateIssue]:
+    issues: list[GateIssue] = []
+    for package in packages:
+        name = str(package.get("name", ""))
+        source = package.get("source")
+        if name in local_crates:
+            if source is not None:
+                issues.append(
+                    GateIssue(
+                        f"{prefix}-cargo-local-source",
+                        f"local crate {name} unexpectedly has source {source}",
+                    )
+                )
+            continue
+        if source != _REGISTRY_SOURCE:
+            issues.append(
+                GateIssue(
+                    f"{prefix}-cargo-nonregistry",
+                    f"Cargo.lock package {name} is not an exact crates.io package",
+                )
+            )
+            continue
+        checksum = package.get("checksum")
+        if not isinstance(checksum, str) or _SHA256.fullmatch(checksum) is None:
+            issues.append(
+                GateIssue(
+                    f"{prefix}-cargo-checksum",
+                    f"Cargo.lock package {name} has no crates.io checksum",
+                )
+            )
+    return issues
+
+
+def _cargo_manifest_pin_issues(lock: dict[str, Any]) -> list[GateIssue]:
+    symbolica = lock["symbolica"]
+    symjit = lock["symjit"]
+    try:
+        root = _load_toml(ROOT / "Cargo.toml")
+        core = _load_toml(ROOT / "rust" / "crates" / "rusticol-core" / "Cargo.toml")
+        root_dependencies = root["workspace"]["dependencies"]
+        core_dependencies = core["dependencies"]
+    except (KeyError, OSError, TypeError, tomllib.TOMLDecodeError) as error:
+        return [GateIssue("release-cargo-manifest", f"invalid Cargo manifest: {error}")]
+    issues: list[GateIssue] = []
+    if root.get("patch"):
+        issues.append(
+            GateIssue(
+                "release-cargo-patch",
+                "release Cargo.toml must use published crates without source patches",
+            )
+        )
+    symbolica_version = f"={symbolica['rust_version']}"
+    for table in (root_dependencies, core_dependencies):
+        entry = table.get("symbolica") if isinstance(table, dict) else None
+        if not isinstance(entry, dict) or entry.get("version") != symbolica_version:
+            issues.append(
+                GateIssue(
+                    "release-cargo-pin",
+                    "Cargo manifest must require "
+                    f"symbolica {symbolica_version} exactly",
+                )
+            )
+        elif "git" in entry or "path" in entry:
+            issues.append(
+                GateIssue(
+                    "release-cargo-source",
+                    "release Cargo dependency symbolica must use crates.io",
+                )
+            )
+    symjit_entry = (
+        core_dependencies.get("symjit") if isinstance(core_dependencies, dict) else None
+    )
+    if (
+        not isinstance(symjit_entry, dict)
+        or symjit_entry.get("version") != f"={symjit['version']}"
+        or "git" in symjit_entry
+        or "rev" in symjit_entry
+        or "path" in symjit_entry
+    ):
+        issues.append(
+            GateIssue(
+                "release-cargo-source",
+                "rusticol-core must require the exact release-lock SymJIT version "
+                "from crates.io",
+            )
+        )
+    return issues
+
+
+def _release_cargo_lock_issues(lock: dict[str, Any]) -> list[GateIssue]:
+    try:
+        packages = _cargo_packages(CARGO_LOCK_PATH)
+    except (OSError, ValueError, tomllib.TOMLDecodeError) as error:
+        return [GateIssue("release-cargo-lock", str(error))]
+    issues = _registry_source_issues(
+        packages,
+        local_crates=_LOCAL_CRATES,
+        prefix="release",
+    )
+    symbolica = lock.get("symbolica", {})
+    for name, version in (
+        (
+            str(symbolica.get("rust_crate", "symbolica")),
+            str(symbolica.get("rust_version", "")),
+        ),
+        ("symjit", str(lock.get("symjit", {}).get("version", ""))),
+    ):
+        matches = [
+            package
+            for package in packages
+            if package.get("name") == name and package.get("version") == version
+        ]
+        if len(matches) != 1 or matches[0].get("source") != _REGISTRY_SOURCE:
+            issues.append(
+                GateIssue(
+                    "release-cargo-pin",
+                    f"Cargo.lock must resolve published {name}=={version} exactly",
+                )
+            )
+    return [*issues, *_cargo_manifest_pin_issues(lock)]
+
+
+def _toolchain_issues(lock: dict[str, Any]) -> list[GateIssue]:
+    toolchain = lock.get("toolchain")
+    if not isinstance(toolchain, dict):
+        return [GateIssue("toolchain-contract", "release lock has no toolchain table")]
+    issues: list[GateIssue] = []
+    try:
+        rust = _load_toml(RUST_TOOLCHAIN_PATH)["toolchain"]
+    except (KeyError, OSError, TypeError, tomllib.TOMLDecodeError) as error:
+        return [
+            GateIssue("toolchain-contract", f"invalid rust-toolchain.toml: {error}")
+        ]
+    if not isinstance(rust, dict) or rust.get("channel") != toolchain.get(
+        "rust_toolchain"
+    ):
+        issues.append(
+            GateIssue(
+                "toolchain-contract",
+                "rust-toolchain.toml disagrees with release-lock.toml",
+            )
+        )
+    digest = toolchain.get("manylinux_image_digest")
+    image = toolchain.get("manylinux_image")
+    if (
+        not isinstance(image, str)
+        or not image
+        or not isinstance(digest, str)
+        or re.fullmatch(r"sha256:[0-9a-f]{64}", digest) is None
+    ):
+        issues.append(
+            GateIssue(
+                "toolchain-contract",
+                "manylinux image and digest must be pinned exactly",
+            )
+        )
+    build_system = _load_toml(PYPROJECT_PATH).get("build-system", {})
+    requirements = (
+        build_system.get("requires", []) if isinstance(build_system, dict) else []
+    )
+    expected = {
+        "maturin": str(toolchain.get("maturin", "")),
+        "packaging": str(toolchain.get("packaging", "")),
+    }
+    observed: dict[str, str] = {}
+    for raw in requirements if isinstance(requirements, list) else []:
+        if not isinstance(raw, str):
+            continue
+        try:
+            requirement = Requirement(raw)
+        except InvalidRequirement:
+            continue
+        specifiers = list(requirement.specifier)
+        if len(specifiers) == 1 and specifiers[0].operator == "==":
+            observed[canonicalize_name(requirement.name)] = specifiers[0].version
+    if observed != expected:
+        issues.append(
+            GateIssue(
+                "toolchain-contract",
+                f"build-system pins disagree with release lock: {observed}",
+            )
+        )
+    return issues
+
+
+def _candidate_sources(
+    contributor: dict[str, Any],
+    release: dict[str, Any],
+) -> dict[str, tuple[str, str]]:
+    return {
+        "gammaloop": (
+            str(contributor["gammaloop_candidate"]["source_url"]),
+            str(contributor["gammaloop_candidate"]["revision"]),
+        ),
+        "symbolica": (
+            str(contributor["symbolica"]["source_url"]),
+            str(contributor["symbolica"]["candidate_revision"]),
+        ),
+        "symbolica-community": (
+            str(contributor["symbolica"]["community_url"]),
+            str(contributor["symbolica"]["community_revision"]),
+        ),
+        "symbolica-integrate": (
+            str(contributor["symbolica_integrate"]["source_url"]),
+            str(contributor["symbolica_integrate"]["revision"]),
+        ),
+        "symjit": (
+            str(contributor["symjit"]["repository"]),
+            str(contributor["symjit"]["revision"]),
+        ),
+        "ufo-model-loader": (
+            str(contributor["ufo_model_loader"]["source_url"]),
+            str(contributor["ufo_model_loader"]["candidate_revision"]),
+        ),
+    }
+
+
+def _git_head(path: Path) -> str | None:
+    completed = subprocess.run(
+        ["git", "-C", str(path), "rev-parse", "HEAD"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip() if completed.returncode == 0 else None
+
+
+def _symjit_manifest_issues(path: Path, *, expected_version: str) -> list[GateIssue]:
+    try:
+        manifest = _load_toml(path)
+    except (OSError, ValueError, tomllib.TOMLDecodeError) as error:
+        return [GateIssue("candidate-symjit-manifest", str(error))]
+    package = manifest.get("package")
+    library = manifest.get("lib")
+    if (
+        not isinstance(package, dict)
+        or package.get("name") != "symjit"
+        or package.get("version") != expected_version
+        or not isinstance(library, dict)
+        or library.get("crate-type") != ["rlib"]
+    ):
+        return [
+            GateIssue(
+                "candidate-symjit-manifest",
+                "managed SymJIT must be the locked version and expose an "
+                "rlib-only library",
+            )
+        ]
+    return []
+
+
+def _candidate_config_issues(path_overrides: dict[str, Path]) -> list[GateIssue]:
+    checkout_root = CHECKOUTS_PATH.resolve()
+    expected_paths = {
+        "graphica": checkout_root / "symbolica" / "lib" / "graphica",
+        "numerica": checkout_root / "symbolica" / "lib" / "numerica",
+        "symbolica": checkout_root / "symbolica",
+        "symjit": checkout_root / "symjit",
+        **path_overrides,
+    }
+    try:
+        config = _load_toml(CARGO_CONFIG_PATH)
+        patch_tables = config["patch"]
+        registry_patches = patch_tables["crates-io"]
+    except (KeyError, OSError, TypeError, tomllib.TOMLDecodeError) as error:
+        return [
+            GateIssue("candidate-cargo-config", f"invalid Cargo patch config: {error}")
+        ]
+    if (
+        not isinstance(config, dict)
+        or set(config) != {"patch"}
+        or not isinstance(patch_tables, dict)
+        or set(patch_tables) != {"crates-io"}
+        or not isinstance(registry_patches, dict)
+        or set(registry_patches) != set(expected_paths)
+    ):
+        return [
+            GateIssue(
+                "candidate-cargo-config",
+                "candidate Cargo patch table does not match the locked source "
+                "overrides",
+            )
+        ]
+    issues: list[GateIssue] = []
+    patches = registry_patches
+    for name, entry in patches.items():
+        path_value = entry.get("path") if isinstance(entry, dict) else None
+        if (
+            not isinstance(entry, dict)
+            or set(entry) != {"path"}
+            or not isinstance(path_value, str)
+        ):
+            issues.append(
+                GateIssue(
+                    "candidate-cargo-config",
+                    f"candidate Cargo patch {name} must contain exactly one local path",
+                )
+            )
+            continue
+        path = Path(path_value).resolve()
+        if path != expected_paths[name]:
+            issues.append(
+                GateIssue(
+                    "candidate-cargo-config",
+                    f"candidate Cargo patch {name} does not resolve to its "
+                    "declared checkout",
+                )
+            )
+            continue
+        if not path.exists():
+            issues.append(
+                GateIssue(
+                    "candidate-cargo-config",
+                    f"candidate Cargo patch {name} path is missing: {path}",
+                )
+            )
+    return issues
+
+
+def _candidate_issues(release_lock: dict[str, Any]) -> list[GateIssue]:
+    required = (
+        CONTRIBUTOR_LOCK_PATH,
+        STATE_PATH,
+        CANDIDATE_LOCK_PATH,
+        CARGO_CONFIG_PATH,
+    )
+    missing = [path for path in required if not path.is_file()]
+    if missing:
+        return [
+            GateIssue(
+                "candidate-input-missing",
+                "run 'just dev-install' before a candidate build; missing: "
+                + ", ".join(str(path) for path in missing),
+            )
+        ]
+    try:
+        contributor = _load_contributor_lock()
+        state = json.loads(STATE_PATH.read_text(encoding="utf-8"))
+        packages = _cargo_packages(CANDIDATE_LOCK_PATH)
+        root_patches = (
+            _load_toml(ROOT / "Cargo.toml").get("patch", {}).get("crates-io", {})
+        )
+        path_overrides = {
+            name: (ROOT / entry["path"]).resolve()
+            for name, entry in root_patches.items()
+            if isinstance(entry, dict) and "path" in entry
+        }
+    except (
+        OSError,
+        ValueError,
+        json.JSONDecodeError,
+        tomllib.TOMLDecodeError,
+    ) as error:
+        return [GateIssue("candidate-input-invalid", str(error))]
+    issues = _registry_source_issues(
+        packages,
+        local_crates=_CANDIDATE_LOCAL_CRATES | path_overrides.keys(),
+        prefix="candidate",
+    )
+    if contributor.get("abis") != _CANDIDATE_ABIS:
+        issues.append(
+            GateIssue(
+                "candidate-abi-contract",
+                "contributor-lock.toml has unexpected candidate ABI identities",
+            )
+        )
+    if "patches" in contributor:
+        issues.append(
+            GateIssue(
+                "candidate-symjit-patch",
+                "contributor-lock.toml must not carry a local SymJIT patch contract",
+            )
+        )
+    patch_root = CONTRIBUTOR_LOCK_PATH.parent / "patches" / "symjit"
+    if patch_root.is_symlink() or (
+        patch_root.is_dir() and any(path.is_file() for path in patch_root.rglob("*"))
+    ):
+        issues.append(
+            GateIssue(
+                "candidate-symjit-patch",
+                "local SymJIT patch inventory must be removed",
+            )
+        )
+    if not isinstance(state, dict) or state.get("schema_version") != 1:
+        issues.append(
+            GateIssue("candidate-state-invalid", "installer state must use schema 1")
+        )
+        return issues
+    if state.get("publishable") is not False:
+        issues.append(
+            GateIssue(
+                "candidate-state-publishable",
+                "candidate installer state must explicitly be non-publishable",
+            )
+        )
+    if set(state) != {"schema_version", "publishable", "sources"}:
+        issues.append(
+            GateIssue(
+                "candidate-state-invalid",
+                "installer state may contain only schema_version, publishable, "
+                "and sources",
+            )
+        )
+    sources = state.get("sources")
+    try:
+        expected_sources = _candidate_sources(contributor, release_lock)
+    except (KeyError, TypeError) as error:
+        issues.append(
+            GateIssue(
+                "candidate-source-contract",
+                f"candidate source contract is incomplete: {error}",
+            )
+        )
+        expected_sources = {}
+    if not isinstance(sources, dict):
+        issues.append(
+            GateIssue("candidate-state-invalid", "installer state has no source map")
+        )
+    else:
+        local_sources = {
+            name: path_overrides[crate]
+            for name, crate in (
+                ("symjit", "symjit"),
+                ("symbolica-integrate", "symbolica-integrate"),
+            )
+            if crate in path_overrides
+        }
+        if "spenso" in path_overrides:
+            local_sources["gammaloop"] = path_overrides["spenso"].parent.parent
+        for source_name, entry in sources.items():
+            allowed = {"url", "revision"}
+            if isinstance(entry, dict) and "branch" in entry:
+                allowed.add("branch")
+            if (
+                not isinstance(source_name, str)
+                or not source_name
+                or not isinstance(entry, dict)
+                or set(entry) != allowed
+                or not all(
+                    isinstance(entry[key], str) and entry[key] for key in allowed
+                )
+                or _GIT_REVISION.fullmatch(entry["revision"]) is None
+            ):
+                issues.append(
+                    GateIssue(
+                        "candidate-state-invalid",
+                        f"candidate source {source_name!r} has an invalid descriptor",
+                    )
+                )
+        for name, (url, revision) in expected_sources.items():
+            entry = sources.get(name)
+            checkout = local_sources.get(name, CHECKOUTS_PATH / name)
+            # Explicit Cargo path overrides are user-owned, not managed installs.
+            # Their declared Git base is checked below; local edits are permitted.
+            if name not in local_sources and (
+                not isinstance(entry, dict)
+                or entry.get("url") != url
+                or entry.get("revision") != revision
+            ):
+                issues.append(
+                    GateIssue(
+                        "candidate-source-revision",
+                        f"candidate source {name} does not match contributor-lock.toml",
+                    )
+                )
+            if not checkout.is_dir() or _git_head(checkout) != revision:
+                issues.append(
+                    GateIssue(
+                        "candidate-source-revision",
+                        f"candidate checkout {name} is not at {revision}",
+                    )
+                )
+        symjit_checkout = local_sources.get("symjit", CHECKOUTS_PATH / "symjit")
+        if symjit_checkout.is_dir():
+            issues.extend(
+                _symjit_manifest_issues(
+                    symjit_checkout / "Cargo.toml",
+                    expected_version=str(contributor["symjit"]["candidate_version"]),
+                )
+            )
+    return [*issues, *_candidate_config_issues(path_overrides)]
+
+
+def check(*, candidate: bool) -> list[GateIssue]:
+    try:
+        lock = _load_lock()
+    except (OSError, ValueError, tomllib.TOMLDecodeError) as error:
+        return [GateIssue("release-lock-invalid", str(error))]
+    issues = [
+        *_release_contract_issues(lock),
+        *_toolchain_issues(lock),
+    ]
+    if candidate:
+        issues.extend(_candidate_issues(lock))
+    else:
+        issues.extend(_release_cargo_lock_issues(lock))
+    return issues
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--candidate",
+        action="store_true",
+        help="validate source-checkout candidate inputs as non-publishable",
+    )
+    parser.add_argument("--json", action="store_true", help="emit JSON")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    issues = check(candidate=args.candidate)
+    payload = {
+        "mode": "candidate" if args.candidate else "release",
+        "ready": not issues,
+        "issues": [{"code": issue.code, "message": issue.message} for issue in issues],
+    }
+    if args.json:
+        print(json.dumps(payload, indent=2, sort_keys=True))
+    elif issues:
+        for issue in issues:
+            print(f"[{issue.code}] {issue.message}", file=sys.stderr)
+    else:
+        print(f"{payload['mode']} dependency gate passed")
+    return 0 if not issues else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/release/install_wheel.py b/pyamplicol/tools/release/install_wheel.py
new file mode 100644
index 0000000000..1df5e67163
--- /dev/null
+++ b/pyamplicol/tools/release/install_wheel.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Install the one audited pyAmpliCol wheel matching a target interpreter."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from _artifacts import audit_wheel
+from _common import (
+    CANDIDATE_ARTIFACTS,
+    DEPENDENCY_WHEELHOUSE,
+    DIST,
+    ROOT,
+    ReleaseError,
+    build_mode,
+    clean_environment,
+    run,
+)
+
+_TAG_SCRIPT = r"""
+import json
+try:
+    from packaging.tags import sys_tags
+except ImportError:
+    from pip._vendor.packaging.tags import sys_tags
+print(json.dumps([str(tag) for tag in sys_tags()]))
+"""
+
+
+def interpreter_tags(python: Path) -> list[str]:
+    completed = run(
+        [python, "-I", "-c", _TAG_SCRIPT],
+        env=clean_environment(),
+        capture_output=True,
+    )
+    try:
+        tags = json.loads(completed.stdout)
+    except json.JSONDecodeError as error:
+        raise ReleaseError(
+            f"target interpreter did not report valid packaging tags: {python}"
+        ) from error
+    if not isinstance(tags, list) or not all(isinstance(tag, str) for tag in tags):
+        raise ReleaseError(f"target interpreter reported invalid tags: {python}")
+    return tags
+
+
+def wheel_tags(path: Path) -> set[str]:
+    fields = path.name[:-4].rsplit("-", 3)
+    if path.suffix != ".whl" or len(fields) != 4:
+        raise ReleaseError(f"invalid wheel filename: {path.name}")
+    _, python_tags, abi_tags, platform_tags = fields
+    return {
+        f"{python_tag}-{abi_tag}-{platform_tag}"
+        for python_tag in python_tags.split(".")
+        for abi_tag in abi_tags.split(".")
+        for platform_tag in platform_tags.split(".")
+    }
+
+
+def select_compatible_wheel(
+    wheels: Sequence[Path], supported_tags: Sequence[str]
+) -> Path:
+    ranking = {tag: index for index, tag in enumerate(supported_tags)}
+    candidates: list[tuple[int, Path]] = []
+    for wheel in wheels:
+        matches = [ranking[tag] for tag in wheel_tags(wheel) if tag in ranking]
+        if matches:
+            candidates.append((min(matches), wheel.resolve()))
+    if not candidates:
+        raise ReleaseError("no pyAmpliCol wheel matches the target interpreter")
+    candidates.sort(key=lambda item: (item[0], item[1].name))
+    best_rank = candidates[0][0]
+    best = [path for rank, path in candidates if rank == best_rank]
+    if len(best) != 1:
+        raise ReleaseError(
+            "multiple wheels are equally compatible with the target interpreter: "
+            + ", ".join(path.name for path in best)
+        )
+    return best[0]
+
+
+def wheelhouse_directories(root: Path) -> list[Path]:
+    if not root.is_dir():
+        return []
+    return sorted(
+        directory.resolve()
+        for directory in {path.parent for path in root.rglob("*.whl")}
+    )
+
+
+def build_if_missing(mode: str, artifact_directory: Path) -> None:
+    if list(artifact_directory.glob("pyamplicol-*.whl")):
+        return
+    command: list[str | os.PathLike[str]] = [
+        sys.executable,
+        ROOT / "tools" / "release" / "build_release_artifacts.py",
+        "--output-dir",
+        artifact_directory,
+    ]
+    if mode == "candidate":
+        command.append("--candidate")
+    run(command, cwd=ROOT, env=clean_environment(mode=mode))
+
+
+def install_wheel(
+    wheel: Path,
+    *,
+    python: Path,
+    mode: str,
+    no_dependencies: bool,
+    wheelhouses: Sequence[Path],
+    dry_run: bool,
+) -> None:
+    audit_wheel(wheel, mode=mode)
+    command: list[str | os.PathLike[str]] = [
+        python,
+        "-I",
+        "-m",
+        "pip",
+        "install",
+        "--force-reinstall",
+        "--only-binary=:all:",
+        "--index-url",
+        "https://pypi.org/simple",
+    ]
+    if no_dependencies:
+        command.append("--no-deps")
+    if mode == "candidate":
+        for directory in wheelhouses:
+            command.extend(("--find-links", directory))
+    elif wheelhouses:
+        raise ReleaseError("release installation cannot use a local wheelhouse")
+    command.append(wheel.resolve())
+    run(command, env=clean_environment(), dry_run=dry_run)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--candidate", action="store_true")
+    parser.add_argument("--python", type=Path, default=Path(sys.executable))
+    parser.add_argument("--wheel", type=Path)
+    parser.add_argument("--artifact-dir", type=Path)
+    parser.add_argument("--wheelhouse", type=Path, action="append", default=[])
+    parser.add_argument("--no-deps", action="store_true")
+    parser.add_argument("--no-build", action="store_true")
+    parser.add_argument("--dry-run", action="store_true")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    mode = build_mode(candidate=args.candidate)
+    artifact_directory = args.artifact_dir or (
+        CANDIDATE_ARTIFACTS if mode == "candidate" else DIST
+    )
+    if args.wheel is not None:
+        wheels = [args.wheel]
+    else:
+        if not args.no_build:
+            build_if_missing(mode, artifact_directory)
+        wheels = sorted(artifact_directory.glob("pyamplicol-*.whl"))
+    wheel = select_compatible_wheel(wheels, interpreter_tags(args.python))
+    wheelhouses = [path.resolve() for path in args.wheelhouse]
+    if mode == "candidate" and not wheelhouses:
+        wheelhouses = wheelhouse_directories(DEPENDENCY_WHEELHOUSE)
+    install_wheel(
+        wheel,
+        python=args.python,
+        mode=mode,
+        no_dependencies=args.no_deps,
+        wheelhouses=wheelhouses,
+        dry_run=args.dry_run,
+    )
+    print(f"Installed {wheel.name} with {args.python}")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except ReleaseError as error:
+        print(f"error: {error}", file=sys.stderr)
+        raise SystemExit(2) from error
diff --git a/pyamplicol/tools/release/prepare_release_prepared_models.py b/pyamplicol/tools/release/prepare_release_prepared_models.py
new file mode 100644
index 0000000000..00aa3ca4a8
--- /dev/null
+++ b/pyamplicol/tools/release/prepare_release_prepared_models.py
@@ -0,0 +1,211 @@
+# SPDX-License-Identifier: 0BSD
+"""Build and audit the non-publishable release prepared-model bootstrap wheel."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import os
+import re
+import sys
+import tomllib
+import zipfile
+from collections.abc import Sequence
+from email.parser import BytesParser
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+BOOTSTRAP_CONTEXT = "release-prepared-model-producer-v1"
+with (ROOT / "dependencies" / "release-lock.toml").open("rb") as _release_stream:
+    EXPECTED_VERSION = str(tomllib.load(_release_stream)["project"]["version"])
+
+
+class ReleasePreparedModelError(RuntimeError):
+    """The release prepared-model producer contract was not satisfied."""
+
+
+def _load_build_backend() -> ModuleType:
+    path = ROOT / "build_backend" / "_pyamplicol_build.py"
+    build_backend = str(path.parent)
+    inserted = False
+    if build_backend not in sys.path:
+        sys.path.insert(0, build_backend)
+        inserted = True
+    try:
+        spec = importlib.util.spec_from_file_location(
+            "_pyamplicol_release_prepared_model_build",
+            path,
+        )
+        if spec is None or spec.loader is None:
+            raise ReleasePreparedModelError(f"cannot load build backend from {path}")
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        return module
+    finally:
+        if inserted:
+            sys.path.remove(build_backend)
+
+
+def _json_member(archive: zipfile.ZipFile, name: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(archive.read(name))
+    except (KeyError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise ReleasePreparedModelError(
+            f"bootstrap wheel member is invalid: {name}"
+        ) from error
+    if not isinstance(payload, dict):
+        raise ReleasePreparedModelError(
+            f"bootstrap wheel member is not an object: {name}"
+        )
+    return payload
+
+
+def audit_bootstrap_wheel(wheel: Path) -> dict[str, object]:
+    """Check that a bootstrap wheel is useful for production but not publication."""
+
+    path = wheel.resolve(strict=True)
+    with zipfile.ZipFile(path) as archive:
+        names = archive.namelist()
+        build_info_names = [
+            name for name in names if name == "pyamplicol/_build_info.json"
+        ]
+        if build_info_names != ["pyamplicol/_build_info.json"]:
+            raise ReleasePreparedModelError(
+                "bootstrap wheel must contain one non-publishable build marker"
+            )
+        metadata_names = [
+            name for name in names if name.endswith(".dist-info/METADATA")
+        ]
+        if len(metadata_names) != 1:
+            raise ReleasePreparedModelError(
+                "bootstrap wheel must contain one distribution METADATA member"
+            )
+        metadata = BytesParser().parsebytes(archive.read(metadata_names[0]))
+        if metadata.get("Name") != "pyamplicol":
+            raise ReleasePreparedModelError(
+                "bootstrap wheel distribution name is not pyamplicol"
+            )
+        if metadata.get("Version") != EXPECTED_VERSION:
+            raise ReleasePreparedModelError(
+                f"bootstrap wheel must retain release version {EXPECTED_VERSION!r}"
+            )
+        marker = _json_member(archive, build_info_names[0])
+        expected_marker = {
+            "schema_version": 1,
+            "publishable": False,
+            "candidate_fingerprint": None,
+            "release_prepared_model_bootstrap": True,
+            "selftest_fixture_bootstrap": True,
+            "version": EXPECTED_VERSION,
+        }
+        for key, expected in expected_marker.items():
+            if marker.get(key) != expected:
+                raise ReleasePreparedModelError(
+                    f"bootstrap wheel marker {key} is invalid"
+                )
+        native_digest = marker.get("native_build_inputs_sha256")
+        if (
+            not isinstance(native_digest, str)
+            or re.fullmatch(r"[0-9a-f]{64}", native_digest) is None
+        ):
+            raise ReleasePreparedModelError(
+                "bootstrap wheel native source identity is invalid"
+            )
+        source_checkout = marker.get("source_checkout")
+        if source_checkout != str(ROOT.resolve()):
+            raise ReleasePreparedModelError(
+                "bootstrap wheel source checkout is not the active repository"
+            )
+        prepared_prefix = "pyamplicol/assets/prepared_models/"
+        prepared_payloads = [
+            name
+            for name in names
+            if name.startswith(prepared_prefix)
+            and name != f"{prepared_prefix}__init__.py"
+        ]
+        if prepared_payloads:
+            raise ReleasePreparedModelError(
+                "bootstrap wheel contains stale prepared-model payloads"
+            )
+        if any(name.startswith("pyamplicol/assets/selftest/") for name in names):
+            raise ReleasePreparedModelError(
+                "bootstrap wheel contains a stale self-test fixture"
+            )
+        if any(
+            name == "release_assets" or name.startswith("release_assets/")
+            for name in names
+        ):
+            raise ReleasePreparedModelError(
+                "bootstrap wheel contains the release prepared-model source store"
+            )
+    return {
+        "candidate_fingerprint": None,
+        "native_build_inputs_sha256": native_digest,
+        "path": str(path),
+        "publishable": False,
+        "release_prepared_model_bootstrap": True,
+        "selftest_fixture_bootstrap": True,
+        "version": EXPECTED_VERSION,
+    }
+
+
+def build_bootstrap_wheel(output_directory: Path) -> dict[str, object]:
+    """Build the sole wheel authorized to produce release prepared-model packs."""
+
+    if os.environ.get("PYAMPLICOL_PREPARED_MODEL_BOOTSTRAP", "0") != "0":
+        raise ReleasePreparedModelError(
+            "candidate prepared-model bootstrap cannot be combined with "
+            "release production"
+        )
+    if os.environ.get("PYAMPLICOL_BUILD_MODE", "release") != "release":
+        raise ReleasePreparedModelError(
+            "release prepared-model production requires PYAMPLICOL_BUILD_MODE=release"
+        )
+    destination = output_directory.expanduser().resolve(strict=False)
+    destination.mkdir(parents=True, exist_ok=True)
+    if any(destination.iterdir()):
+        raise ReleasePreparedModelError(
+            f"bootstrap output directory is not empty: {destination}"
+        )
+    backend = _load_build_backend()
+    filename = backend.build_release_prepared_model_bootstrap_wheel(
+        str(destination),
+        bootstrap_context=BOOTSTRAP_CONTEXT,
+    )
+    return audit_bootstrap_wheel(destination / filename)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Build or audit the explicitly non-publishable release prepared-model "
+            "bootstrap wheel."
+        )
+    )
+    commands = parser.add_subparsers(dest="action", required=True)
+    build = commands.add_parser("bootstrap-wheel")
+    build.add_argument("output_directory", type=Path)
+    audit = commands.add_parser("audit-bootstrap-wheel")
+    audit.add_argument("wheel", type=Path)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = _parser().parse_args(argv)
+    try:
+        if arguments.action == "bootstrap-wheel":
+            result = build_bootstrap_wheel(arguments.output_directory)
+        else:
+            result = audit_bootstrap_wheel(arguments.wheel)
+    except (OSError, ReleasePreparedModelError, RuntimeError) as error:
+        print(f"release-prepared-models: {error}", file=sys.stderr)
+        return 1
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/release/prepare_selftest_fixture.py b/pyamplicol/tools/release/prepare_selftest_fixture.py
new file mode 100644
index 0000000000..a0f79d0baf
--- /dev/null
+++ b/pyamplicol/tools/release/prepare_selftest_fixture.py
@@ -0,0 +1,1138 @@
+# SPDX-License-Identifier: 0BSD
+"""Prepare the portable 64-bit installed-package physics self-test fixture."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib
+import json
+import math
+import re
+import shutil
+import sys
+import tomllib
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[2]
+FIXTURE_ROOT = ROOT / "src" / "pyamplicol" / "assets" / "selftest"
+PORTABLE_TEMPLATE = "portable-64le"
+PORTABLE_OPTIMIZATION_LEVEL = 2
+COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY = "compiled-plane-arena-v1"
+COMPILED_PLANE_DIRECT_APPLICATION_ABI = "pyamplicol-compiled-plane-kernel-v2"
+SYMJIT_APPLICATION_ABI = "symjit-application-storage-v3"
+SYMJIT_PLANE_APPLICATION_ABI = "pyamplicol-symjit-plane-application-v2"
+SYMJIT_F64_RUNTIME_CAPABILITY = "symjit.application.complex-f64.v1"
+COMPATIBLE_TARGETS = (
+    "aarch64-apple-darwin",
+    "x86_64-apple-darwin",
+    "x86_64-unknown-linux-gnu",
+)
+_RUNTIME_ARTIFACT_ID_PAYLOAD_ROLES = frozenset(
+    {
+        "compiled-model",
+        "evaluator-manifest",
+        "evaluator-state",
+        "model-parameters",
+        "runtime-physics",
+    }
+)
+ARTIFACT_IDENTITY_CONTRACT = {
+    "kind": "pyamplicol-runtime-payload-identity",
+    "schema_version": 1,
+}
+
+
+def validate_artifact_identity_contract(
+    manifest: Mapping[str, object],
+    *,
+    context: str,
+) -> None:
+    extensions = manifest.get("extensions")
+    if (
+        not isinstance(extensions, dict)
+        or extensions.get("artifact_identity") != ARTIFACT_IDENTITY_CONTRACT
+    ):
+        raise RuntimeError(
+            f"{context} lacks the current artifact identity contract; regenerate it"
+        )
+
+
+def _canonical_json(value: Mapping[str, object]) -> bytes:
+    return (
+        json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + "\n"
+    ).encode("utf-8")
+
+
+def _artifact_id(manifest: Mapping[str, object]) -> str:
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise RuntimeError("artifact payload inventory is invalid")
+    records = [
+        dict(payload)
+        for payload in payloads
+        if isinstance(payload, dict)
+        and payload.get("role") in _RUNTIME_ARTIFACT_ID_PAYLOAD_ROLES
+    ]
+    records.sort(key=lambda payload: str(payload.get("path", "")))
+    content = {
+        "kind": "pyamplicol-runtime-payload-identity",
+        "schema_version": 1,
+        "payloads": records,
+    }
+    return hashlib.sha256(_canonical_json(content)).hexdigest()
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _compiled_model_payload(
+    manifest: Mapping[str, object],
+) -> tuple[dict[str, Any], Path]:
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise RuntimeError("artifact payload inventory is invalid")
+    matches = [
+        payload
+        for payload in payloads
+        if isinstance(payload, dict) and payload.get("role") == "compiled-model"
+    ]
+    if len(matches) != 1:
+        raise RuntimeError("self-test artifact must contain one compiled model")
+    payload = matches[0]
+    relative = payload.get("path")
+    if not isinstance(relative, str):
+        raise RuntimeError("self-test compiled-model payload has no path")
+    path = Path(relative)
+    if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts):
+        raise RuntimeError("self-test compiled-model payload path is unsafe")
+    return payload, path
+
+
+def _validate_source_compiled_model(
+    source: Path,
+    manifest: Mapping[str, object],
+) -> None:
+    """Require the source artifact to match the active model compiler exactly."""
+
+    from pyamplicol.models.loading import load_compiled_model
+
+    _payload, relative = _compiled_model_payload(manifest)
+    load_compiled_model(source / relative)
+
+
+def _normalize_compiled_model_version(
+    artifact: Path,
+    manifest: Mapping[str, object],
+    *,
+    version: str,
+) -> None:
+    """Retarget the embedded compiler fingerprint to the release package version."""
+
+    payload, relative = _compiled_model_payload(manifest)
+    path = artifact / relative
+    try:
+        compiled_model = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise RuntimeError("self-test compiled model is invalid") from error
+    if not isinstance(compiled_model, dict):
+        raise RuntimeError("self-test compiled model must be an object")
+    producer = compiled_model.get("producer")
+    if not isinstance(producer, dict):
+        raise RuntimeError("self-test compiled-model producer is invalid")
+    producer["pyamplicol"] = version
+    path.write_bytes(_canonical_json(compiled_model))
+    payload["sha256"] = _sha256(path)
+    payload["size_bytes"] = path.stat().st_size
+
+
+def _workspace_version() -> str:
+    with (ROOT / "Cargo.toml").open("rb") as stream:
+        cargo = tomllib.load(stream)
+    try:
+        version = cargo["workspace"]["package"]["version"]
+    except (KeyError, TypeError) as exc:
+        raise RuntimeError("Cargo.toml has no workspace package version") from exc
+    if not isinstance(version, str) or not version:
+        raise RuntimeError("Cargo workspace package version is invalid")
+    return version.replace("-dev.", ".dev")
+
+
+def _walk_evaluator_manifests(value: object) -> Sequence[dict[str, Any]]:
+    found: list[dict[str, Any]] = []
+    if isinstance(value, dict):
+        if value.get("kind") == "symjit-application-evaluator":
+            found.append(value)
+        for child in value.values():
+            found.extend(_walk_evaluator_manifests(child))
+    elif isinstance(value, list):
+        for child in value:
+            found.extend(_walk_evaluator_manifests(child))
+    return found
+
+
+def _walk_compiled_execution_manifests(
+    value: object,
+) -> Sequence[dict[str, Any]]:
+    found: list[dict[str, Any]] = []
+    if isinstance(value, dict):
+        compiled = value.get("compiled")
+        if (
+            isinstance(compiled, dict)
+            and compiled.get("kind") == "generic-dag-stage-blueprint"
+        ):
+            found.append(value)
+        for child in value.values():
+            found.extend(_walk_compiled_execution_manifests(child))
+    elif isinstance(value, list):
+        for child in value:
+            found.extend(_walk_compiled_execution_manifests(child))
+    return found
+
+
+def _portable_nonnegative_int(
+    record: Mapping[str, object],
+    name: str,
+    *,
+    context: str,
+) -> int:
+    value = record.get(name)
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise RuntimeError(f"{context} has an invalid {name.replace('_', ' ')}")
+    return value
+
+
+def _portable_sequence(value: object, *, context: str) -> Sequence[object]:
+    if not isinstance(value, list):
+        raise RuntimeError(f"{context} must be a list")
+    return value
+
+
+def _validate_portable_capability_owner(
+    owner: Mapping[str, object],
+    *,
+    context: str,
+) -> None:
+    capabilities = _portable_sequence(
+        owner.get("required_runtime_capabilities"),
+        context=f"{context} runtime capabilities",
+    )
+    if any(
+        not isinstance(capability, str) or not capability for capability in capabilities
+    ) or len(capabilities) != len(set(capabilities)):
+        raise RuntimeError(f"{context} runtime capabilities are invalid")
+    for capability in (
+        COMPILED_PLANE_ARENA_RUNTIME_CAPABILITY,
+        SYMJIT_F64_RUNTIME_CAPABILITY,
+    ):
+        if capability not in capabilities:
+            raise RuntimeError(f"{context} must require {capability}")
+
+
+def validate_portable_artifact_capabilities(
+    manifest: Mapping[str, object],
+    *,
+    context: str,
+) -> int:
+    """Require Arena and SymJIT capabilities at artifact and process scope."""
+
+    runtime = manifest.get("runtime")
+    if not isinstance(runtime, Mapping):
+        raise RuntimeError(f"{context} has no artifact runtime contract")
+    _validate_portable_capability_owner(
+        runtime,
+        context=f"{context} artifact runtime",
+    )
+
+    processes = _portable_sequence(
+        manifest.get("processes"),
+        context=f"{context} processes",
+    )
+    if not processes:
+        raise RuntimeError(f"{context} has no processes")
+    for process_index, process in enumerate(processes):
+        if not isinstance(process, Mapping):
+            raise RuntimeError(f"{context} process {process_index} is invalid")
+        _validate_portable_capability_owner(
+            process,
+            context=f"{context} process {process_index}",
+        )
+    return len(processes)
+
+
+def _validate_portable_symjit_source(
+    evaluator: Mapping[str, object],
+) -> Mapping[str, object]:
+    if (
+        evaluator.get("compiler_type") != "native"
+        or evaluator.get("translation_mode") != "indirect"
+    ):
+        raise RuntimeError(
+            "portable self-test requires native indirect SymJIT evaluators"
+        )
+    if evaluator.get("optimization_level") != PORTABLE_OPTIMIZATION_LEVEL:
+        raise RuntimeError(
+            "portable self-test source must use its canonical SymJIT "
+            f"optimization level {PORTABLE_OPTIMIZATION_LEVEL}"
+        )
+    if (
+        evaluator.get("runtime_capability") != SYMJIT_F64_RUNTIME_CAPABILITY
+        or evaluator.get("application_abi") != SYMJIT_APPLICATION_ABI
+        or evaluator.get("element_layout") != "complex-f64"
+        or evaluator.get("batch_layout") != "row-major"
+    ):
+        raise RuntimeError("portable self-test has an incompatible SymJIT source ABI")
+    application_path = evaluator.get("application_path")
+    if not isinstance(application_path, str) or not application_path:
+        raise RuntimeError("portable self-test has no ordinary SymJIT application path")
+    input_len = _portable_nonnegative_int(
+        evaluator,
+        "input_len",
+        context="portable self-test SymJIT evaluator",
+    )
+    output_len = _portable_nonnegative_int(
+        evaluator,
+        "output_len",
+        context="portable self-test SymJIT evaluator",
+    )
+    plane = evaluator.get("plane_application")
+    if not isinstance(plane, Mapping):
+        raise RuntimeError(
+            "portable self-test SymJIT evaluator has no plane application"
+        )
+    expected_plane = {
+        "application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+        "storage_abi": SYMJIT_APPLICATION_ABI,
+        "element_layout": "split-complex-plane-major",
+        "descriptor_order": "inputs-re-im-then-outputs-re-im",
+        "input_complex_count": input_len,
+        "output_complex_count": output_len,
+        "input_plane_count": 2 * input_len,
+        "output_plane_count": 2 * output_len,
+        "compiler_type": "native",
+        "translation_mode": "symbolica-structured-instructions",
+        "optimization_level": PORTABLE_OPTIMIZATION_LEVEL,
+        "simd": True,
+        "complex": True,
+        "fast_math": True,
+        "fast_complex": False,
+        "threading": False,
+        "direct_arena": True,
+    }
+    if any(plane.get(name) != value for name, value in expected_plane.items()):
+        raise RuntimeError(
+            "portable self-test SymJIT plane application contract is incompatible"
+        )
+    plane_path = plane.get("application_path")
+    if not isinstance(plane_path, str) or not plane_path:
+        raise RuntimeError(
+            "portable self-test SymJIT plane application path is invalid"
+        )
+    source_digest = plane.get("source_digest")
+    if (
+        not isinstance(source_digest, str)
+        or len(source_digest) != 64
+        or any(character not in "0123456789abcdef" for character in source_digest)
+    ):
+        raise RuntimeError("portable self-test SymJIT plane source digest is invalid")
+    if not isinstance(plane.get("compression"), bool):
+        raise RuntimeError(
+            "portable self-test SymJIT plane compression flag is invalid"
+        )
+    target = plane.get("target")
+    if (
+        not isinstance(target, Mapping)
+        or target.get("word_bits") != 64
+        or target.get("endianness") != "little"
+    ):
+        raise RuntimeError("portable self-test SymJIT plane target is incompatible")
+    return plane
+
+
+def _portable_arena_source_leaves(
+    evaluator: Mapping[str, object],
+    parent_inputs: tuple[int, ...],
+    output_start: int,
+    *,
+    context: str,
+) -> tuple[list[dict[str, object]], int]:
+    kind = evaluator.get("kind")
+    if kind == "chunked-symbolica-evaluator":
+        input_len = evaluator.get("input_len")
+        if input_len is not None and input_len != len(parent_inputs):
+            raise RuntimeError(f"{context} chunk input width is inconsistent")
+        chunks = _portable_sequence(
+            evaluator.get("chunks"),
+            context=f"{context} chunks",
+        )
+        if not chunks:
+            raise RuntimeError(f"{context} has no evaluator leaves")
+        raw_maps = evaluator.get("chunk_input_indices")
+        if raw_maps is None:
+            input_maps = [parent_inputs] * len(chunks)
+        else:
+            maps = _portable_sequence(
+                raw_maps,
+                context=f"{context} chunk input maps",
+            )
+            if len(maps) != len(chunks):
+                raise RuntimeError(f"{context} chunk input maps are incomplete")
+            input_maps: list[tuple[int, ...]] = []
+            for raw_map in maps:
+                indices = _portable_sequence(
+                    raw_map,
+                    context=f"{context} chunk input map",
+                )
+                mapped: list[int] = []
+                for raw_index in indices:
+                    if (
+                        isinstance(raw_index, bool)
+                        or not isinstance(raw_index, int)
+                        or not 0 <= raw_index < len(parent_inputs)
+                    ):
+                        raise RuntimeError(
+                            f"{context} chunk input map references an absent input"
+                        )
+                    mapped.append(parent_inputs[raw_index])
+                input_maps.append(tuple(mapped))
+
+        result: list[dict[str, object]] = []
+        cursor = output_start
+        for chunk_index, (raw_chunk, mapped) in enumerate(
+            zip(chunks, input_maps, strict=True)
+        ):
+            if not isinstance(raw_chunk, Mapping):
+                raise RuntimeError(f"{context} evaluator child is invalid")
+            child, cursor = _portable_arena_source_leaves(
+                raw_chunk,
+                mapped,
+                cursor,
+                context=f"{context} chunk {chunk_index}",
+            )
+            result.extend(child)
+        return result, cursor
+
+    if kind != "symjit-application-evaluator":
+        raise RuntimeError(f"{context} is not an all-SymJIT compiled Plane-Arena stage")
+    plane = _validate_portable_symjit_source(evaluator)
+    application_path = plane.get("application_path")
+    if not isinstance(application_path, str) or not application_path:
+        raise RuntimeError(f"{context} has no SymJIT plane application path")
+    input_len = _portable_nonnegative_int(evaluator, "input_len", context=context)
+    output_len = _portable_nonnegative_int(evaluator, "output_len", context=context)
+    if input_len != len(parent_inputs) or output_len == 0:
+        raise RuntimeError(f"{context} has inconsistent evaluator dimensions")
+    output_stop = output_start + output_len
+    return (
+        [
+            {
+                "application_path": application_path,
+                "source_application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+                "optimization_level": plane["optimization_level"],
+                "direct_codegen_optimization_level": plane["optimization_level"],
+                "input_len": input_len,
+                "output_len": output_len,
+                "input_indices": list(parent_inputs),
+                "output_start": output_start,
+                "output_stop": output_stop,
+            }
+        ],
+        output_stop,
+    )
+
+
+def _portable_stage_input_bindings(
+    stage: Mapping[str, object],
+    parameter_count: int,
+    *,
+    context: str,
+) -> list[dict[str, object]]:
+    inputs = _portable_sequence(
+        stage.get("input_components"),
+        context=f"{context} input components",
+    )
+    expected: list[dict[str, object] | None] = [None] * parameter_count
+    for raw_input in inputs:
+        if not isinstance(raw_input, Mapping):
+            raise RuntimeError(f"{context} input component is invalid")
+        parameter_index = _portable_nonnegative_int(
+            raw_input,
+            "parameter_index",
+            context=f"{context} input component",
+        )
+        if (
+            parameter_index >= parameter_count
+            or expected[parameter_index] is not None
+            or raw_input.get("kind") not in {"value", "momentum", "model_parameter"}
+            or not isinstance(raw_input.get("real_valued"), bool)
+        ):
+            raise RuntimeError(f"{context} input components are inconsistent")
+        binding = {
+            "parameter_index": parameter_index,
+            "kind": raw_input["kind"],
+            "source_id": _portable_nonnegative_int(
+                raw_input,
+                "source_id",
+                context=f"{context} input component",
+            ),
+            "component": _portable_nonnegative_int(
+                raw_input,
+                "component",
+                context=f"{context} input component",
+            ),
+            "global_component": _portable_nonnegative_int(
+                raw_input,
+                "global_component",
+                context=f"{context} input component",
+            ),
+            "real_valued": raw_input["real_valued"],
+        }
+        expected[parameter_index] = binding
+    if any(binding is None for binding in expected):
+        raise RuntimeError(f"{context} input components are incomplete")
+    return [binding for binding in expected if binding is not None]
+
+
+def _portable_stage_output_bindings(
+    stage: Mapping[str, object],
+    output_length: int,
+    *,
+    arena: str,
+    context: str,
+) -> list[dict[str, object]]:
+    slots = _portable_sequence(
+        stage.get("output_slots"),
+        context=f"{context} output slots",
+    )
+    expected: list[dict[str, object] | None] = [None] * output_length
+    seen_components: set[int] = set()
+    for raw_slot in slots:
+        if not isinstance(raw_slot, Mapping):
+            raise RuntimeError(f"{context} output slot is invalid")
+        output_start = _portable_nonnegative_int(
+            raw_slot,
+            "output_start",
+            context=f"{context} output slot",
+        )
+        output_stop = _portable_nonnegative_int(
+            raw_slot,
+            "output_stop",
+            context=f"{context} output slot",
+        )
+        component_start = _portable_nonnegative_int(
+            raw_slot,
+            "component_start",
+            context=f"{context} output slot",
+        )
+        component_stop = _portable_nonnegative_int(
+            raw_slot,
+            "component_stop",
+            context=f"{context} output slot",
+        )
+        if (
+            output_stop < output_start
+            or output_stop > output_length
+            or component_stop - component_start != output_stop - output_start
+        ):
+            raise RuntimeError(f"{context} output slot range is inconsistent")
+        for offset in range(output_stop - output_start):
+            output_index = output_start + offset
+            component = component_start + offset
+            if expected[output_index] is not None or component in seen_components:
+                raise RuntimeError(f"{context} output slots alias")
+            expected[output_index] = {
+                "output_index": output_index,
+                "arena": arena,
+                "component": component,
+            }
+            seen_components.add(component)
+    if any(binding is None for binding in expected):
+        raise RuntimeError(f"{context} output slots are incomplete")
+    return [binding for binding in expected if binding is not None]
+
+
+def _validate_portable_arena_stage(
+    stage: Mapping[str, object],
+    *,
+    arena: str,
+    context: str,
+) -> None:
+    if stage.get("parameter_layout") != "stage-local-value-momentum":
+        raise RuntimeError(f"{context} does not use stage-local parameters")
+    parameter_count = _portable_nonnegative_int(
+        stage,
+        "parameter_count",
+        context=context,
+    )
+    output_length = _portable_nonnegative_int(
+        stage,
+        "output_length",
+        context=context,
+    )
+    if output_length == 0:
+        raise RuntimeError(f"{context} has no outputs")
+    evaluator = stage.get("evaluator")
+    if not isinstance(evaluator, Mapping):
+        raise RuntimeError(f"{context} has no compiled evaluator")
+    descriptor = stage.get("compiled_plane_arena")
+    if not isinstance(descriptor, Mapping):
+        raise RuntimeError(
+            f"{context} requires a complete compiled_plane_arena descriptor"
+        )
+
+    contract = {
+        "schema_version": 1,
+        "kind": "compiled-plane-arena-stage",
+        "application_abi": COMPILED_PLANE_DIRECT_APPLICATION_ABI,
+        "source_application_abi": SYMJIT_PLANE_APPLICATION_ABI,
+        "element_layout": "split-complex-component-major",
+        "output_operation": "overwrite",
+        "output_factor": "identity",
+        "input_output_aliasing": "forbidden",
+        "output_output_aliasing": "forbidden",
+    }
+    if any(descriptor.get(name) != value for name, value in contract.items()):
+        raise RuntimeError(f"{context} compiled_plane_arena contract is incompatible")
+
+    expected_inputs = _portable_stage_input_bindings(
+        stage,
+        parameter_count,
+        context=context,
+    )
+    input_bindings = _portable_sequence(
+        descriptor.get("input_bindings"),
+        context=f"{context} compiled_plane_arena input bindings",
+    )
+    if list(input_bindings) != expected_inputs:
+        raise RuntimeError(
+            f"{context} compiled_plane_arena input bindings are incomplete"
+        )
+
+    expected_outputs = _portable_stage_output_bindings(
+        stage,
+        output_length,
+        arena=arena,
+        context=context,
+    )
+    output_bindings = _portable_sequence(
+        descriptor.get("output_bindings"),
+        context=f"{context} compiled_plane_arena output bindings",
+    )
+    if list(output_bindings) != expected_outputs:
+        raise RuntimeError(
+            f"{context} compiled_plane_arena output bindings are incomplete"
+        )
+
+    expected_leaves, output_stop = _portable_arena_source_leaves(
+        evaluator,
+        tuple(range(parameter_count)),
+        0,
+        context=f"{context} evaluator",
+    )
+    if output_stop != output_length:
+        raise RuntimeError(f"{context} evaluator leaves do not cover its outputs")
+    leaves = _portable_sequence(
+        descriptor.get("leaves"),
+        context=f"{context} compiled_plane_arena leaves",
+    )
+    if len(leaves) != len(expected_leaves):
+        raise RuntimeError(f"{context} compiled_plane_arena leaves are incomplete")
+    for leaf_index, (raw_leaf, expected_leaf) in enumerate(
+        zip(leaves, expected_leaves, strict=True)
+    ):
+        if not isinstance(raw_leaf, Mapping):
+            raise RuntimeError(
+                f"{context} compiled_plane_arena leaf {leaf_index} is invalid"
+            )
+        if raw_leaf.get("direct_codegen_optimization_level") != expected_leaf.get(
+            "direct_codegen_optimization_level"
+        ):
+            raise RuntimeError(
+                f"{context} compiled_plane_arena direct codegen optimization "
+                "does not match its SymJIT plane application"
+            )
+        if any(raw_leaf.get(name) != value for name, value in expected_leaf.items()):
+            raise RuntimeError(
+                f"{context} compiled_plane_arena leaf {leaf_index} "
+                "does not bind its SymJIT source"
+            )
+
+
+def _validate_portable_compiled_execution(
+    execution: Mapping[str, object],
+    *,
+    context: str,
+) -> None:
+    _validate_portable_capability_owner(execution, context=context)
+    compiled = execution.get("compiled")
+    if not isinstance(compiled, Mapping):
+        raise RuntimeError(f"{context} has no compiled DAG")
+    stage_set = compiled.get("stage_evaluators")
+    if not isinstance(stage_set, Mapping):
+        raise RuntimeError(f"{context} has no compiled DAG stage evaluators")
+    if stage_set.get("kind") != "generic-dag-stage-evaluator-artifacts":
+        raise RuntimeError(f"{context} stage evaluator contract is invalid")
+    _validate_portable_capability_owner(
+        stage_set,
+        context=f"{context} stage evaluators",
+    )
+    stages = _portable_sequence(
+        stage_set.get("stages"),
+        context=f"{context} stages",
+    )
+    stage_count = _portable_nonnegative_int(
+        stage_set,
+        "stage_count",
+        context=f"{context} stage evaluator set",
+    )
+    if stage_count != len(stages) + 1:
+        raise RuntimeError(f"{context} stage evaluator set is incomplete")
+    for stage_index, stage in enumerate(stages):
+        if not isinstance(stage, Mapping):
+            raise RuntimeError(f"{context} stage {stage_index} is invalid")
+        _validate_portable_arena_stage(
+            stage,
+            arena="current",
+            context=f"{context} stage {stage_index}",
+        )
+    amplitude_stage = stage_set.get("amplitude_stage")
+    if not isinstance(amplitude_stage, Mapping):
+        raise RuntimeError(f"{context} amplitude stage is absent")
+    _validate_portable_arena_stage(
+        amplitude_stage,
+        arena="amplitude",
+        context=f"{context} amplitude stage",
+    )
+
+
+def validate_portable_execution_manifest(
+    execution: Mapping[str, object],
+    *,
+    context: str,
+) -> int:
+    """Validate one root compiled execution and every nested selector execution.
+
+    This is the shared release-facing contract used while preparing, staging,
+    and auditing the installed self-test fixture. It deliberately validates the
+    portable O2 ordinary SymJIT fallback together with the complete O2
+    P-kernel Plane-Arena descriptor rather than treating either representation
+    as sufficient alone.
+    """
+
+    evaluator_count = 0
+    for evaluator in _walk_evaluator_manifests(execution):
+        evaluator_count += 1
+        _validate_portable_symjit_source(evaluator)
+    if evaluator_count == 0:
+        raise RuntimeError(f"{context} has no SymJIT evaluator manifests")
+
+    compiled_executions = _walk_compiled_execution_manifests(execution)
+    if not compiled_executions or compiled_executions[0] is not execution:
+        raise RuntimeError(f"{context} has no root compiled DAG")
+    for execution_index, compiled_execution in enumerate(compiled_executions):
+        _validate_portable_compiled_execution(
+            compiled_execution,
+            context=f"{context} compiled execution {execution_index}",
+        )
+    return evaluator_count
+
+
+def _validate_portable_evaluator_configuration(
+    artifact: Path,
+    manifest: Mapping[str, object],
+) -> int:
+    """Require architecture-neutral MIR before retargeting an evaluator state."""
+
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise RuntimeError("artifact payload inventory is invalid")
+    evaluator_count = 0
+    for payload in payloads:
+        if (
+            not isinstance(payload, dict)
+            or payload.get("role") != "evaluator-manifest"
+            or not str(payload.get("path", "")).endswith("/execution.json")
+        ):
+            continue
+        relative = payload.get("path")
+        if not isinstance(relative, str):
+            raise RuntimeError("self-test evaluator manifest has no path")
+        execution = json.loads((artifact / relative).read_text(encoding="utf-8"))
+        if not isinstance(execution, dict):
+            raise RuntimeError("self-test evaluator manifest must be an object")
+        evaluator_count += validate_portable_execution_manifest(
+            execution,
+            context=f"portable self-test evaluator manifest {relative}",
+        )
+    if evaluator_count == 0:
+        raise RuntimeError("self-test artifact has no SymJIT evaluator manifests")
+    return PORTABLE_OPTIMIZATION_LEVEL
+
+
+def _strip_symbolica_fallbacks(artifact: Path, manifest: dict[str, Any]) -> None:
+    removed: set[str] = set()
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise RuntimeError("artifact payload inventory is invalid")
+    execution_payloads = [
+        payload
+        for payload in payloads
+        if isinstance(payload, dict) and payload.get("role") == "evaluator-manifest"
+    ]
+    for payload in execution_payloads:
+        relative = payload.get("path")
+        if not isinstance(relative, str) or not relative.endswith("/execution.json"):
+            continue
+        path = artifact / relative
+        execution = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(execution, dict):
+            raise RuntimeError(f"invalid evaluator manifest: {relative}")
+        for evaluator in _walk_evaluator_manifests(execution):
+            state = evaluator.get("evaluator_state_path")
+            if isinstance(state, str):
+                removed.add((Path(relative).parent / state).as_posix())
+            evaluator["evaluator_state_path"] = None
+            evaluator["evaluator_state_runtime_capability"] = None
+        path.write_bytes(_canonical_json(execution))
+        payload["sha256"] = _sha256(path)
+        payload["size_bytes"] = path.stat().st_size
+    if not removed:
+        raise RuntimeError("source artifact has no Symbolica fallback evaluator states")
+    removed_loose: set[str] = set()
+    for relative in sorted(removed):
+        path = artifact / relative
+        if path.is_file():
+            path.unlink()
+            removed_loose.add(relative)
+    removed_packed = removed - removed_loose
+    if removed_packed:
+        _strip_packed_symbolica_fallbacks(artifact, manifest, removed_packed)
+    manifest["payloads"] = [
+        payload
+        for payload in payloads
+        if not (
+            isinstance(payload, dict)
+            and isinstance(payload.get("path"), str)
+            and payload["path"] in removed_loose
+        )
+    ]
+
+
+def _strip_packed_symbolica_fallbacks(
+    artifact: Path,
+    manifest: dict[str, Any],
+    removed: set[str],
+) -> None:
+    """Remove exact fallback states from a packed evaluator container."""
+
+    from pyamplicol.generation.evaluator_container import (
+        PacbinMemberKind,
+        PacbinMemberSource,
+        PacbinReader,
+        write_pacbin_atomic,
+    )
+
+    extensions = manifest.get("extensions")
+    if not isinstance(extensions, dict):
+        raise RuntimeError("artifact extensions are invalid")
+    extension = extensions.get("evaluator_payload_container")
+    if not isinstance(extension, dict):
+        missing = ", ".join(sorted(removed))
+        raise RuntimeError(f"missing Symbolica fallback state: {missing}")
+    relative = extension.get("path")
+    if not isinstance(relative, str):
+        raise RuntimeError("evaluator payload container has no path")
+    container_path = artifact / relative
+
+    with PacbinReader.open(container_path, verify_payloads=True) as reader:
+        by_path = {member.logical_path: member for member in reader.members}
+        missing = sorted(removed - by_path.keys())
+        if missing:
+            raise RuntimeError(
+                "missing Symbolica fallback state: " + ", ".join(missing)
+            )
+        invalid = sorted(
+            path
+            for path in removed
+            if by_path[path].kind is not PacbinMemberKind.SYMBOLICA_EXACT_STATE
+        )
+        if invalid:
+            raise RuntimeError(
+                "Symbolica fallback state has an invalid packed kind: "
+                + ", ".join(invalid)
+            )
+        retained = tuple(
+            PacbinMemberSource(
+                member.logical_path,
+                member.kind,
+                reader.open_member_stream(member.logical_path),
+            )
+            for member in reader.members
+            if member.logical_path not in removed
+        )
+        if not retained:
+            raise RuntimeError("portable self-test evaluator container is empty")
+        index = write_pacbin_atomic(container_path, retained)
+
+    extension["member_count"] = len(index.members)
+    extension["unpacked_size_bytes"] = sum(member.length for member in index.members)
+    extension["index_sha256"] = index.index_sha256
+
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise RuntimeError("artifact payload inventory is invalid")
+    matches = [
+        payload
+        for payload in payloads
+        if isinstance(payload, dict) and payload.get("path") == relative
+    ]
+    if len(matches) != 1:
+        raise RuntimeError("artifact must declare one evaluator payload container")
+    payload = matches[0]
+    payload["sha256"] = _sha256(container_path)
+    payload["size_bytes"] = container_path.stat().st_size
+
+
+def _sanitize_configuration_paths(artifact: Path, manifest: dict[str, Any]) -> None:
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise RuntimeError("artifact payload inventory is invalid")
+    roles = {"configuration-requested", "configuration-effective"}
+    found: set[str] = set()
+    for payload in payloads:
+        if not isinstance(payload, dict) or payload.get("role") not in roles:
+            continue
+        role = str(payload["role"])
+        relative = payload.get("path")
+        if not isinstance(relative, str):
+            raise RuntimeError(f"self-test {role} payload has no path")
+        path = artifact / relative
+        text = path.read_text(encoding="utf-8")
+        updated = _sanitize_generation_output(text, role)
+        path.write_text(updated, encoding="utf-8")
+        payload["sha256"] = _sha256(path)
+        payload["size_bytes"] = path.stat().st_size
+        found.add(role)
+    if found != roles:
+        raise RuntimeError(
+            "self-test artifact lacks requested/effective configurations"
+        )
+
+
+def _sanitize_generation_output(text: str, role: str) -> str:
+    pattern = r'(?m)^output\s*=\s*"[^"]*"$'
+    matches = tuple(re.finditer(pattern, text))
+    if len(matches) > 1:
+        raise RuntimeError(f"self-test {role} has multiple generation outputs")
+    if not matches:
+        return text
+    return re.sub(pattern, 'output = "."', text, count=1)
+
+
+def _retarget_portable_manifest(
+    manifest: dict[str, Any],
+    *,
+    source_target: str,
+) -> None:
+    producer = manifest.get("producer")
+    if not isinstance(producer, dict):
+        raise RuntimeError("self-test artifact producer metadata is invalid")
+    target = producer.get("target")
+    if not isinstance(target, dict) or target.get("triple") != source_target:
+        raise RuntimeError("self-test artifact target differs from the active runtime")
+    target["triple"] = PORTABLE_TEMPLATE
+    target["cpu_features"] = []
+
+    payloads = manifest.get("payloads")
+    if not isinstance(payloads, list):
+        raise RuntimeError("self-test artifact payload inventory is invalid")
+    evaluator_targets = 0
+    for payload in payloads:
+        if not isinstance(payload, dict):
+            raise RuntimeError("self-test artifact payload entry is invalid")
+        payload_target = payload.get("target")
+        if payload_target is None:
+            continue
+        if (
+            not isinstance(payload_target, dict)
+            or payload_target.get("triple") != source_target
+        ):
+            raise RuntimeError("self-test evaluator target metadata is invalid")
+        payload_target["triple"] = PORTABLE_TEMPLATE
+        payload_target["cpu_features"] = []
+        evaluator_targets += 1
+    if evaluator_targets == 0:
+        raise RuntimeError("self-test artifact has no target-tagged evaluator state")
+
+
+def _complex_pairs(values: Sequence[object]) -> list[list[float]]:
+    return [
+        [float(complex(value).real), float(complex(value).imag)] for value in values
+    ]
+
+
+def _complex_sequences_close(
+    left: Sequence[object],
+    right: Sequence[object],
+) -> bool:
+    if len(left) != len(right):
+        return False
+    for left_value, right_value in zip(left, right, strict=True):
+        actual = complex(left_value)
+        expected = complex(right_value)
+        if not (
+            math.isclose(actual.real, expected.real, rel_tol=1.0e-12, abs_tol=1.0e-14)
+            and math.isclose(
+                actual.imag, expected.imag, rel_tol=1.0e-12, abs_tol=1.0e-14
+            )
+        ):
+            return False
+    return True
+
+
+def prepare(source: Path, destination: Path | None = None) -> Path:
+    source = source.expanduser().resolve(strict=True)
+    if not source.is_dir() or not (source / "artifact.json").is_file():
+        raise RuntimeError("self-test source must be a schema-v3 artifact directory")
+
+    try:
+        source_manifest = json.loads(
+            (source / "artifact.json").read_text(encoding="utf-8")
+        )
+    except (OSError, json.JSONDecodeError) as error:
+        raise RuntimeError("self-test source manifest is invalid") from error
+    if (
+        not isinstance(source_manifest, dict)
+        or source_manifest.get("schema_version") != 3
+    ):
+        raise RuntimeError("self-test source is not a schema-v3 artifact")
+    _validate_source_compiled_model(source, source_manifest)
+
+    from pyamplicol import Runtime
+
+    native = importlib.import_module("pyamplicol._rusticol")
+    active_target = str(native.target_info().triple)
+    if active_target not in COMPATIBLE_TARGETS:
+        raise RuntimeError(f"unsupported portable self-test target: {active_target}")
+    producer = source_manifest.get("producer")
+    producer_target = producer.get("target") if isinstance(producer, dict) else None
+    raw_source_target = (
+        producer_target.get("triple") if isinstance(producer_target, dict) else None
+    )
+    if not isinstance(raw_source_target, str) or raw_source_target not in {
+        active_target,
+        PORTABLE_TEMPLATE,
+    }:
+        raise RuntimeError(
+            "self-test artifact target differs from the active or portable runtime"
+        )
+    source_target = raw_source_target
+    runtime = Runtime.load(source, mute_warnings=True)
+    momentum_loader = getattr(runtime._backend, "validation_momenta", None)
+    if not callable(momentum_loader):
+        raise RuntimeError("artifact runtime cannot expose its validation point")
+    momenta = momentum_loader()
+    if momenta is None:
+        raise RuntimeError("artifact has no deterministic validation point")
+    total = runtime.evaluate(momenta)
+    resolved = runtime.evaluate_resolved(momenta)
+    if not _complex_sequences_close(resolved.total(), total):
+        raise RuntimeError("resolved self-test values do not reproduce evaluate()")
+
+    output = (destination or (FIXTURE_ROOT / PORTABLE_TEMPLATE)).expanduser().resolve()
+    if output.exists():
+        raise RuntimeError(f"self-test destination already exists: {output}")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    temporary = output.with_name(f".{output.name}.staging")
+    if temporary.exists():
+        raise RuntimeError(f"stale self-test staging directory exists: {temporary}")
+    try:
+        artifact = temporary / "artifact"
+        shutil.copytree(source, artifact, symlinks=False)
+        manifest_path = artifact / "artifact.json"
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+        if not isinstance(manifest, dict) or manifest.get("schema_version") != 3:
+            raise RuntimeError("self-test source is not a schema-v3 artifact")
+        validate_artifact_identity_contract(
+            manifest,
+            context="self-test source",
+        )
+        producer = manifest.get("producer")
+        runtime_metadata = manifest.get("runtime")
+        if not isinstance(producer, dict) or not isinstance(runtime_metadata, dict):
+            raise RuntimeError(
+                "self-test artifact producer/runtime metadata is invalid"
+            )
+        if producer.get("target", {}).get("triple") != source_target:
+            raise RuntimeError(
+                "self-test artifact target changed while preparing the fixture"
+            )
+        validate_portable_artifact_capabilities(
+            manifest,
+            context="portable self-test artifact",
+        )
+        portable_optimization_level = _validate_portable_evaluator_configuration(
+            artifact,
+            manifest,
+        )
+        _strip_symbolica_fallbacks(artifact, manifest)
+        _sanitize_configuration_paths(artifact, manifest)
+        _retarget_portable_manifest(manifest, source_target=source_target)
+        version = _workspace_version()
+        _normalize_compiled_model_version(
+            artifact,
+            manifest,
+            version=version,
+        )
+        producer["version"] = version
+        runtime_metadata["engine_version"] = version
+        manifest["artifact_id"] = _artifact_id(manifest)
+        manifest_path.write_bytes(_canonical_json(manifest))
+        expected = {
+            "schema_version": 1,
+            "artifact_path": "artifact",
+            "target": PORTABLE_TEMPLATE,
+            "compatible_targets": list(COMPATIBLE_TARGETS),
+            "source_generation_target": source_target,
+            "serialization": {
+                "kind": "symjit-application-mir-v3",
+                "endianness": "little",
+                "word_size_bits": 64,
+                "load_behavior": "recompile-mir-for-loading-host",
+                "source_optimization_level": portable_optimization_level,
+            },
+            "process_id": runtime.physics.process_id,
+            "process": runtime.physics.process,
+            "momenta": momenta,
+            "resolved_shape": list(resolved.shape),
+            "helicity_ids": list(resolved.helicity_ids),
+            "color_ids": list(resolved.color_ids),
+            "total": _complex_pairs(total),
+        }
+        (temporary / "expected.json").write_text(
+            json.dumps(expected, indent=2, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        temporary.rename(output)
+    except BaseException:
+        if temporary.exists():
+            shutil.rmtree(temporary)
+        raise
+    return output
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("source", type=Path)
+    parser.add_argument("--destination", type=Path)
+    args = parser.parse_args(argv)
+    output = prepare(args.source, args.destination)
+    print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/pyamplicol/tools/release/prepared_models_archive.py b/pyamplicol/tools/release/prepared_models_archive.py
new file mode 100644
index 0000000000..d0c573dc78
--- /dev/null
+++ b/pyamplicol/tools/release/prepared_models_archive.py
@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Pack, unpack and fetch the single prepared-model release archive.
+
+Prepared-model packs are not tracked in Git. Each MadGraph7 release attaches
+one archive holding the metadata of every architecture pair and each distinct
+bundle once (named by its SHA-256). Unpacking restores the files in both the
+package asset directory and the release store.
+
+    prepared_models_archive.py pack --output DIR
+    prepared_models_archive.py unpack ARCHIVE
+    prepared_models_archive.py fetch [--version V] [--output DIR]
+    prepared_models_archive.py regenerate --work DIR
+
+``regenerate`` repeats the release-prepared-models workflow on this host: it
+builds the bootstrap wheel, produces the packs with it and, as the packs are
+portable, installs them for both architectures.
+
+Stdlib only, so that installers can run it before any build dependency exists.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import io
+import json
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.error
+import urllib.request
+import venv
+from pathlib import Path, PurePosixPath
+
+ROOT = Path(__file__).resolve().parents[2]
+ASSET_DIRECTORY = ROOT / "src" / "pyamplicol" / "assets" / "prepared_models"
+RELEASE_STORE = ROOT / "release_assets" / "prepared_models"
+ARCHIVE_NAME = "pyamplicol-prepared-models.tar.gz"
+RELEASES_REPOSITORY = "MadGraphTeam/MadGraph7"
+IDENTIFIERS = ("built-in-sm-jit-o2", "built-in-sm-heft-jit-o2")
+ARCHITECTURES = ("aarch64", "x86_64")
+ARCHIVE_SCHEMA = 1
+_MAX_MEMBER_BYTES = 512 * 1024 * 1024
+
+
+class ArchiveError(RuntimeError):
+    """The prepared-model archive is missing, malformed or inconsistent."""
+
+
+def _stems() -> list[str]:
+    return [f"{ident}-{arch}" for ident in IDENTIFIERS for arch in ARCHITECTURES]
+
+
+def _sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def _add(tar: tarfile.TarFile, name: str, data: bytes) -> None:
+    info = tarfile.TarInfo(name)
+    info.size = len(data)
+    info.mode = 0o644
+    info.mtime = 0
+    info.uname = info.gname = ""
+    tar.addfile(info, io.BytesIO(data))
+
+
+def pack(source: Path, output: Path) -> Path:
+    """Write a deterministic archive from one directory of 8 pack files."""
+
+    metadata: dict[str, bytes] = {}
+    bundles: dict[str, bytes] = {}
+    for stem in _stems():
+        raw = (source / f"{stem}.metadata.json").read_bytes()
+        record = json.loads(raw)
+        data = (source / record["bundle"]).read_bytes()
+        if _sha256(data) != record["bundle_sha256"]:
+            raise ArchiveError(f"{record['bundle']} does not match its metadata")
+        metadata[stem] = raw
+        bundles[record["bundle_sha256"]] = data
+    manifest = {
+        "schema_version": ARCHIVE_SCHEMA,
+        "metadata": sorted(metadata),
+        "bundles": sorted(bundles),
+    }
+    output.mkdir(parents=True, exist_ok=True)
+    path = output / ARCHIVE_NAME
+    buffer = io.BytesIO()
+    with tarfile.open(fileobj=buffer, mode="w", format=tarfile.PAX_FORMAT) as tar:
+        _add(tar, "manifest.json", json.dumps(manifest, indent=2).encode() + b"\n")
+        for stem in sorted(metadata):
+            _add(tar, f"metadata/{stem}.metadata.json", metadata[stem])
+        for digest in sorted(bundles):
+            _add(tar, f"bundles/{digest}.pyamplicol-model", bundles[digest])
+    with (
+        path.open("wb") as raw_stream,
+        gzip.GzipFile(filename="", mode="wb", fileobj=raw_stream, mtime=0) as stream,
+    ):
+        stream.write(buffer.getvalue())
+    return path
+
+
+def _read_members(archive: Path) -> dict[str, bytes]:
+    members: dict[str, bytes] = {}
+    with tarfile.open(archive, mode="r:gz") as tar:
+        for info in tar:
+            name = PurePosixPath(info.name)
+            if not info.isfile() or name.is_absolute() or ".." in name.parts:
+                raise ArchiveError(f"unsafe archive member: {info.name}")
+            if info.size > _MAX_MEMBER_BYTES:
+                raise ArchiveError(f"archive member is too large: {info.name}")
+            stream = tar.extractfile(info)
+            assert stream is not None
+            members[info.name] = stream.read()
+    return members
+
+
+def unpack(archive: Path, destinations: tuple[Path, ...] | None = None) -> None:
+    """Verify the archive and write the 8 pack files into each destination."""
+
+    destinations = destinations or (ASSET_DIRECTORY, RELEASE_STORE)
+    members = _read_members(archive)
+    try:
+        manifest = json.loads(members["manifest.json"])
+    except (KeyError, ValueError) as error:
+        raise ArchiveError("archive has no valid manifest") from error
+    if manifest.get("schema_version") != ARCHIVE_SCHEMA:
+        raise ArchiveError("unsupported prepared-model archive schema")
+    files: dict[str, bytes] = {}
+    for stem in _stems():
+        raw = members.get(f"metadata/{stem}.metadata.json")
+        if raw is None:
+            raise ArchiveError(f"archive has no metadata for {stem}")
+        record = json.loads(raw)
+        data = members.get(f"bundles/{record['bundle_sha256']}.pyamplicol-model")
+        if data is None or _sha256(data) != record["bundle_sha256"]:
+            raise ArchiveError(f"archive bundle for {stem} is missing or corrupt")
+        files[f"{stem}.metadata.json"] = raw
+        files[record["bundle"]] = data
+    for destination in destinations:
+        destination.mkdir(parents=True, exist_ok=True)
+        for name, data in files.items():
+            (destination / name).write_bytes(data)
+
+
+def _download(url: str, target: Path) -> bool:
+    try:
+        with urllib.request.urlopen(url, timeout=60) as response:
+            target.write_bytes(response.read())
+    except urllib.error.HTTPError as error:
+        if error.code == 404:
+            return False
+        raise
+    return True
+
+
+def _release_tags(version: str | None) -> list[str]:
+    tags = [f"v{version}"] if version else []
+    api = f"https://api.github.com/repos/{RELEASES_REPOSITORY}/releases?per_page=30"
+    try:
+        with urllib.request.urlopen(api, timeout=60) as response:
+            releases = json.load(response)
+    except (urllib.error.URLError, ValueError):
+        return tags
+    for release in releases:
+        if release.get("draft") or not any(
+            asset.get("name") == ARCHIVE_NAME for asset in release.get("assets", ())
+        ):
+            continue
+        if release["tag_name"] not in tags:
+            tags.append(release["tag_name"])
+    return tags
+
+
+def fetch(output: Path, version: str | None = None) -> Path:
+    """Download the archive of release ``version`` or else the latest one."""
+
+    output.mkdir(parents=True, exist_ok=True)
+    target = output / ARCHIVE_NAME
+    base = f"https://github.com/{RELEASES_REPOSITORY}/releases/download"
+    for tag in _release_tags(version):
+        if _download(f"{base}/{tag}/{ARCHIVE_NAME}", target):
+            print(f"Fetched {ARCHIVE_NAME} from release {tag}")
+            return target
+    raise ArchiveError(f"no MadGraph7 release provides {ARCHIVE_NAME}")
+
+
+def _run(command: list[str | os.PathLike[str]]) -> None:
+    print("$ " + " ".join(str(part) for part in command), flush=True)
+    subprocess.run(command, cwd=ROOT, check=True)
+
+
+def regenerate(work: Path) -> None:
+    """Produce the packs on this host and install them into both stores."""
+
+    machine = platform.machine()
+    host = {"arm64": "aarch64", "aarch64": "aarch64", "x86_64": "x86_64"}.get(machine)
+    if host is None:
+        raise ArchiveError(f"cannot produce prepared models on {machine}")
+    for path in (work / "wheel", work / "output"):
+        if path.exists():
+            shutil.rmtree(path)
+    tools = ROOT / "tools"
+    _run(
+        [
+            sys.executable,
+            tools / "release" / "prepare_release_prepared_models.py",
+            "bootstrap-wheel",
+            work / "wheel",
+        ]
+    )
+    runtime = work / "runtime"
+    if not runtime.exists():
+        venv.create(runtime, with_pip=True)
+    python = runtime / "bin" / "python"
+    wheels = sorted((work / "wheel").glob("pyamplicol-*.whl"))
+    _run([python, "-m", "pip", "install", "--force-reinstall", *wheels])
+    _run(
+        [
+            python,
+            tools / "ci" / "eager_portability.py",
+            "produce",
+            work / "output",
+            "--python",
+            python,
+            "--asset-mode",
+            "release",
+            "--expected-system",
+            platform.system(),
+            "--expected-machine",
+            machine,
+        ]
+    )
+    produced = work / "output" / "release_assets" / "prepared_models"
+    for destination in (ASSET_DIRECTORY, RELEASE_STORE):
+        for arch in ARCHITECTURES:
+            for ident in IDENTIFIERS:
+                stem = f"{ident}-{host}"
+                record = json.loads((produced / f"{stem}.metadata.json").read_text())
+                data = (produced / record["bundle"]).read_bytes()
+                record["bundle"] = f"{ident}-{arch}.pyamplicol-model"
+                (destination / record["bundle"]).write_bytes(data)
+                (destination / f"{ident}-{arch}.metadata.json").write_text(
+                    json.dumps(record, indent=2, sort_keys=True) + "\n"
+                )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    commands = parser.add_subparsers(dest="command", required=True)
+    pack_parser = commands.add_parser("pack", help="create the archive")
+    pack_parser.add_argument("--source", type=Path, default=ASSET_DIRECTORY)
+    pack_parser.add_argument("--output", type=Path, required=True)
+    unpack_parser = commands.add_parser("unpack", help="restore the pack files")
+    unpack_parser.add_argument("archive", type=Path)
+    fetch_parser = commands.add_parser("fetch", help="download and unpack")
+    fetch_parser.add_argument("--version")
+    fetch_parser.add_argument("--output", type=Path)
+    fetch_parser.add_argument(
+        "--no-unpack", action="store_true", help="only download the archive"
+    )
+    regenerate_parser = commands.add_parser(
+        "regenerate", help="produce the packs on this host"
+    )
+    regenerate_parser.add_argument("--work", type=Path, required=True)
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "pack":
+            print(pack(args.source, args.output))
+        elif args.command == "unpack":
+            unpack(args.archive)
+        elif args.command == "regenerate":
+            regenerate(args.work)
+        elif args.output is not None:
+            archive = fetch(args.output, args.version)
+            if not args.no_unpack:
+                unpack(archive)
+        else:
+            with tempfile.TemporaryDirectory() as temporary:
+                unpack(fetch(Path(temporary), args.version))
+    except (
+        ArchiveError,
+        OSError,
+        urllib.error.URLError,
+        subprocess.CalledProcessError,
+    ) as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/pyamplicol/tools/release/publish_dry_run.py b/pyamplicol/tools/release/publish_dry_run.py
new file mode 100644
index 0000000000..36a3d89656
--- /dev/null
+++ b/pyamplicol/tools/release/publish_dry_run.py
@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Audit ordinary package artifacts and print, but never run, an upload."""
+
+from __future__ import annotations
+
+import argparse
+import shlex
+import shutil
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from _artifacts import RELEASE_TARGETS, ArtifactError, audit_sdist, audit_wheel
+from _common import (
+    CANDIDATE_ARTIFACTS,
+    DIST,
+    ROOT,
+    ReleaseError,
+    build_mode,
+    check_dependency_gate,
+    clean_environment,
+    exactly_one,
+    run,
+)
+from install_wheel import interpreter_tags, select_compatible_wheel
+
+
+def _collect_artifacts(directory: Path) -> list[Path]:
+    """Find package files recursively and reject ambiguous duplicate names."""
+
+    directory = directory.resolve()
+    by_name: dict[str, Path] = {}
+    for pattern in ("pyamplicol-*.whl", "pyamplicol-*.tar.gz"):
+        for path in sorted(directory.rglob(pattern)):
+            existing = by_name.get(path.name)
+            if existing is not None:
+                raise ArtifactError(
+                    f"multiple artifacts share filename {path.name}: "
+                    f"{existing} and {path}"
+                )
+            by_name[path.name] = path.resolve()
+    if not by_name:
+        raise ArtifactError(f"no pyamplicol wheels or sdist found under {directory}")
+    return [by_name[name] for name in sorted(by_name)]
+
+
+def _validated_artifacts(
+    directory: Path,
+    *,
+    mode: str,
+    require_all_targets: bool,
+) -> list[Path]:
+    """Audit package files and enforce the expected release inventory."""
+
+    artifacts = _collect_artifacts(directory)
+    wheels = [path for path in artifacts if path.suffix == ".whl"]
+    sdists = [path for path in artifacts if path.name.endswith(".tar.gz")]
+    if not wheels:
+        raise ArtifactError("artifact directory contains no wheels")
+    if mode == "candidate":
+        if sdists:
+            raise ArtifactError(
+                "candidate artifacts are wheel-only and non-publishable"
+            )
+    else:
+        exactly_one(sdists, "release sdist")
+
+    if sdists:
+        audit_sdist(sdists[0], mode=mode)
+    reports = [
+        audit_wheel(path, mode=mode, native_scan=False)
+        for path in wheels
+    ]
+    targets = [report.target for report in reports]
+    if len(set(targets)) != len(targets):
+        raise ArtifactError(
+            "artifact directory contains multiple wheels for one target"
+        )
+    if require_all_targets and set(targets) != set(RELEASE_TARGETS):
+        raise ArtifactError(
+            "release wheel target set is incomplete: " + ", ".join(sorted(targets))
+        )
+    return artifacts
+
+
+def _stage_artifacts(artifacts: list[Path], destination: Path) -> list[Path]:
+    """Copy ordinary wheel and sdist files into one upload directory."""
+
+    destination = destination.resolve()
+    if destination.exists() and any(destination.iterdir()):
+        raise ArtifactError(f"artifact destination must be empty: {destination}")
+    destination.mkdir(parents=True, exist_ok=True)
+    staged: list[Path] = []
+    for source in artifacts:
+        target = destination / source.name
+        shutil.copy2(source, target)
+        staged.append(target)
+    return staged
+
+
+def _build_default_artifacts(mode: str) -> Path:
+    command: list[str | Path] = [
+        sys.executable,
+        ROOT / "tools" / "release" / "build_release_artifacts.py",
+    ]
+    if mode == "candidate":
+        command.append("--candidate")
+    run(command, cwd=ROOT, env=clean_environment(mode=mode))
+    return CANDIDATE_ARTIFACTS if mode == "candidate" else DIST
+
+
+def _run_clean_install(wheels: list[Path]) -> None:
+    wheel = select_compatible_wheel(wheels, interpreter_tags(Path(sys.executable)))
+    run(
+        [
+            sys.executable,
+            ROOT / "tools" / "release" / "test_deployment.py",
+            "--python",
+            sys.executable,
+            "--wheel",
+            wheel,
+            "--no-build",
+        ],
+        cwd=ROOT,
+        env=clean_environment(mode="release"),
+    )
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--candidate", action="store_true")
+    parser.add_argument(
+        "--artifact-dir",
+        type=Path,
+        help="existing flat or recursive directory containing wheels and an sdist",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        help="empty directory in which to stage ordinary upload files",
+    )
+    parser.add_argument("--no-build", action="store_true")
+    parser.add_argument("--require-all-targets", action="store_true")
+    parser.add_argument("--skip-twine-check", action="store_true")
+    parser.add_argument(
+        "--skip-clean-install",
+        action="store_true",
+        help="skip only when every platform artifact was already deployment-tested",
+    )
+    parser.add_argument("--repository", choices=("pypi", "testpypi"), default="pypi")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    mode = build_mode(candidate=args.candidate)
+    check_dependency_gate(mode)
+    if args.artifact_dir is None:
+        source = (
+            CANDIDATE_ARTIFACTS if mode == "candidate" else DIST
+        ) if args.no_build else _build_default_artifacts(mode)
+    else:
+        source = args.artifact_dir
+
+    artifacts = _validated_artifacts(
+        source,
+        mode=mode,
+        require_all_targets=args.require_all_targets,
+    )
+    if args.output_dir is not None:
+        if args.output_dir.resolve() == source.resolve():
+            raise ArtifactError("artifact source and output directories must differ")
+        artifacts = _stage_artifacts(artifacts, args.output_dir)
+
+    if not args.skip_twine_check:
+        run(
+            [sys.executable, "-m", "twine", "check", *artifacts],
+            cwd=ROOT,
+            env=clean_environment(),
+        )
+    if mode == "release" and not args.skip_clean_install:
+        _run_clean_install([path for path in artifacts if path.suffix == ".whl"])
+    print("Validated package artifacts:")
+    for artifact in artifacts:
+        print(f"  {artifact.resolve()}")
+    if mode == "candidate":
+        print("Candidate artifacts are non-publishable; no upload command is emitted.")
+        return 0
+    command = [
+        sys.executable,
+        "-m",
+        "twine",
+        "upload",
+        "--repository",
+        args.repository,
+        "--",
+        *(str(path.resolve()) for path in artifacts),
+    ]
+    print("Dry run only; upload command (not executed):")
+    print(shlex.join(command))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except ReleaseError as error:
+        print(f"error: {error}", file=sys.stderr)
+        raise SystemExit(2) from error
diff --git a/pyamplicol/tools/release/run_cargo.py b/pyamplicol/tools/release/run_cargo.py
new file mode 100644
index 0000000000..f10877adde
--- /dev/null
+++ b/pyamplicol/tools/release/run_cargo.py
@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Run Cargo against the clean release or candidate source overlay."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+import sysconfig
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "build_backend"))
+
+import _pyamplicol_build as backend  # noqa: E402
+
+
+def _python_test_loader_updates(arguments: list[str]) -> dict[str, str]:
+    """Expose only the selected interpreter's shared library to Rust tests."""
+
+    if arguments[:1] != ["test"] or not sys.platform.startswith("linux"):
+        return {}
+
+    directories: list[Path] = []
+    for variable in ("LIBDIR", "LIBPL"):
+        value = sysconfig.get_config_var(variable)
+        if not value:
+            continue
+        directory = Path(str(value)).resolve()
+        if directory.is_dir() and directory not in directories:
+            directories.append(directory)
+    if not directories:
+        raise RuntimeError(
+            "the selected Python interpreter does not report a usable shared-library "
+            "directory; Rust PyO3 tests cannot be launched"
+        )
+    return {"LD_LIBRARY_PATH": os.pathsep.join(map(str, directories))}
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--mode", choices=("candidate", "release"), required=True)
+    parser.add_argument("cargo_arguments", nargs=argparse.REMAINDER)
+    args = parser.parse_args(argv)
+    arguments = list(args.cargo_arguments)
+    if arguments[:1] == ["--"]:
+        arguments.pop(0)
+    if not arguments:
+        parser.error("a Cargo subcommand is required after '--'")
+
+    with backend._overlay(args.mode) as (overlay, target):
+        updates = {
+            "CARGO_HOME": str(target.parent / "cargo-home"),
+            "CARGO_TARGET_DIR": str(target),
+            "PYTHONDONTWRITEBYTECODE": "1",
+        }
+        updates.update(_python_test_loader_updates(arguments))
+        updates.update(backend._macos_native_build_updates())
+        environment = backend._clean_environment(updates)
+        completed = subprocess.run(
+            ["cargo", *arguments],
+            cwd=overlay,
+            env=environment,
+            check=False,
+        )
+    return int(completed.returncode)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/tools/release/sync_version.py b/pyamplicol/tools/release/sync_version.py
new file mode 100644
index 0000000000..4222b6f757
--- /dev/null
+++ b/pyamplicol/tools/release/sync_version.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Keep the pyAmpliCol version equal to the MadGraph7 VERSION file.
+
+Cargo needs a literal version, so the MadGraph7 version is written into every
+file that carries it. ``--check`` only reports a mismatch (exit status 1).
+
+    sync_version.py [--check] [--version V]
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+MG_VERSION_FILE = ROOT.parent / "VERSION"
+WORKSPACE_CRATES = ("rusticol-capi", "rusticol-core", "rusticol-python")
+
+
+def madgraph_version() -> str:
+    text = MG_VERSION_FILE.read_text(encoding="utf-8")
+    match = re.search(r"(?m)^version\s*=\s*(\S+)", text)
+    if match is None:
+        raise RuntimeError(f"no version in {MG_VERSION_FILE}")
+    return match.group(1)
+
+
+def _section_value(text: str, section: str, version: str) -> str:
+    # Replace `version = "..."` in the first line of the given TOML section.
+    pattern = re.compile(
+        rf'(?ms)(^\[{re.escape(section)}\]\n(?:(?!^\[).)*?^version = )"[^"]*"'
+    )
+    return pattern.sub(rf'\g<1>"{version}"', text, count=1)
+
+
+def _cargo_lock(text: str, version: str) -> str:
+    for crate in WORKSPACE_CRATES:
+        text = re.sub(
+            rf'(?m)(^name = "{crate}"\nversion = )"[^"]*"',
+            rf'\g<1>"{version}"',
+            text,
+        )
+    return text
+
+
+def _versions_py(text: str, version: str) -> str:
+    return re.sub(
+        r'(def package_version\(default: str = )"[^"]*"',
+        rf'\g<1>"{version}"',
+        text,
+    )
+
+
+EDITS = {
+    Path("Cargo.toml"): lambda text, v: _section_value(text, "workspace.package", v),
+    Path("Cargo.lock"): _cargo_lock,
+    Path("dependencies/release-lock.toml"): lambda text, v: _section_value(
+        text, "project", v
+    ),
+    Path("src/pyamplicol/_internal/versions.py"): _versions_py,
+}
+
+
+def sync(version: str, *, check: bool) -> list[Path]:
+    """Return the files whose version differs, updating them unless checking."""
+
+    stale: list[Path] = []
+    for relative, edit in EDITS.items():
+        path = ROOT / relative
+        text = path.read_text(encoding="utf-8")
+        updated = edit(text, version)
+        if updated != text:
+            stale.append(relative)
+            if not check:
+                path.write_text(updated, encoding="utf-8")
+    return stale
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--check", action="store_true")
+    parser.add_argument("--version", help="default: the MadGraph7 VERSION file")
+    args = parser.parse_args(argv)
+    version = args.version or madgraph_version()
+    stale = sync(version, check=args.check)
+    if args.check and stale:
+        names = ", ".join(path.as_posix() for path in stale)
+        print(f"pyamplicol version is not {version} in: {names}", file=sys.stderr)
+        return 1
+    for path in stale:
+        print(f"set version {version} in {path.as_posix()}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/pyamplicol/tools/release/test_deployment.py b/pyamplicol/tools/release/test_deployment.py
new file mode 100644
index 0000000000..3479f585b7
--- /dev/null
+++ b/pyamplicol/tools/release/test_deployment.py
@@ -0,0 +1,1447 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: 0BSD
+"""Test a wheel in an isolated PyPI-style deployment environment."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import shlex
+import shutil
+import sys
+import tempfile
+import tomllib
+import zipfile
+from collections.abc import Sequence
+from contextlib import ExitStack
+from dataclasses import dataclass
+from email import policy
+from email.parser import BytesParser
+from pathlib import Path
+from typing import Any
+
+try:
+    from packaging.utils import InvalidWheelFilename, parse_wheel_filename
+except ModuleNotFoundError:  # pragma: no cover - pip vendors the build fallback
+    from pip._vendor.packaging.utils import (  # type: ignore[no-redef]
+        InvalidWheelFilename,
+        parse_wheel_filename,
+    )
+
+from _artifacts import (
+    _candidate_dependency_overrides,
+    audit_wheel,
+    canonicalize_name,
+)
+from _common import (
+    CANDIDATE_ARTIFACTS,
+    DEPENDENCY_WHEELHOUSE,
+    DEPLOYMENT_ROOT,
+    DIST,
+    ROOT,
+    ReleaseError,
+    build_mode,
+    check_dependency_gate,
+    clean_environment,
+    exactly_one,
+    external_temporary_directory,
+    is_relative_to,
+    run,
+    runtime_environment,
+    sha256,
+)
+from install_wheel import (
+    interpreter_tags,
+    select_compatible_wheel,
+    wheelhouse_directories,
+)
+
+_LOCK = ROOT / "dependencies" / "release-lock.toml"
+
+_SELFTEST_RESOURCE = r"""
+import importlib.resources
+import json
+
+import pyamplicol._rusticol as native
+
+target = str(native.target_info().triple)
+fixture = importlib.resources.files("pyamplicol").joinpath(
+    "assets", "selftest", target
+)
+expected = json.loads(fixture.joinpath("expected.json").read_text(encoding="utf-8"))
+artifact = fixture.joinpath(str(expected["artifact_path"]))
+print(json.dumps({"artifact": str(artifact), "expected": expected}, sort_keys=True))
+"""
+
+_PATH_ISOLATION_SMOKE = r"""
+import os
+from pathlib import Path
+import sys
+
+forbidden_root = Path(os.environ["PYAMPLICOL_FORBIDDEN_ROOT"]).resolve()
+deployment_sandbox = Path(
+    os.environ["PYAMPLICOL_DEPLOYMENT_SANDBOX"]
+).resolve()
+
+for entry in sys.path:
+    if not entry:
+        continue
+    resolved = Path(entry).resolve()
+    inside_checkout = (
+        resolved == forbidden_root or forbidden_root in resolved.parents
+    )
+    inside_sandbox = (
+        resolved == deployment_sandbox or deployment_sandbox in resolved.parents
+    )
+    assert not inside_checkout or inside_sandbox, entry
+"""
+
+_INSTALLED_SMOKE = (
+    _PATH_ISOLATION_SMOKE
+    + r"""
+import importlib.metadata
+import importlib.resources
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import urllib.parse
+
+expected = json.loads(os.environ["PYAMPLICOL_EXPECTED_DEPENDENCIES"])
+local_sources = json.loads(os.environ["PYAMPLICOL_EXPECTED_LOCAL_SOURCES"])
+mode = os.environ["PYAMPLICOL_DEPLOYMENT_MODE"]
+version = os.environ["PYAMPLICOL_EXPECTED_VERSION"]
+
+assert "PYTHONPATH" not in os.environ
+assert shutil.which("cargo") is None
+assert shutil.which("rustc") is None
+
+distribution = importlib.metadata.distribution("pyamplicol")
+assert distribution.metadata["Name"] == "pyamplicol"
+assert distribution.version == version
+assert distribution.metadata["Requires-Python"] == ">=3.11"
+direct = re.compile(r"(?i)(?:\s@\s|(?:file|git\+[^:]+|https?)://)")
+assert not [item for item in (distribution.requires or ()) if direct.search(item)]
+
+for name, required_version in expected.items():
+    assert importlib.metadata.version(name) == required_version, name
+    dependency = importlib.metadata.distribution(name)
+    direct_text = dependency.read_text("direct_url.json")
+    if name not in local_sources:
+        assert direct_text is None, name
+        continue
+    assert mode == "candidate", name
+    assert direct_text is not None, name
+    direct_url = json.loads(direct_text)
+    parsed = urllib.parse.urlsplit(direct_url["url"])
+    assert parsed.scheme == "file" and parsed.netloc in {"", "localhost"}, name
+    installed_from = Path(urllib.parse.unquote(parsed.path)).resolve()
+    source = local_sources[name]
+    assert installed_from == Path(source["path"]).resolve(), name
+    archive_info = direct_url.get("archive_info", {})
+    expected_hash = source["sha256"]
+    assert (
+        archive_info.get("hash") == f"sha256={expected_hash}"
+        or archive_info.get("hashes", {}).get("sha256") == expected_hash
+    ), name
+
+# Finish CLI children before this process imports Symbolica through pyamplicol.
+# A live parent Symbolica session would consume the restricted thread allowance
+# also needed by those children.
+with tempfile.TemporaryDirectory(prefix="pyamplicol-profiling-campaign-") as raw:
+    campaign = Path(raw).resolve() / "campaign"
+    subprocess.run(
+        (
+            sys.executable,
+            "-I",
+            "-m",
+            "pyamplicol",
+            "profiling-campaign",
+            "copy",
+            str(campaign),
+            "--force",
+        ),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    launcher = campaign / "steer_performance_campaign.py"
+    assert launcher.is_file()
+    assert not (campaign / "pyAmpliCol.pdf").exists()
+    dry_run_command = (
+        sys.executable,
+        "-I",
+        str(launcher),
+        "run",
+        "--dry-run",
+        "--table",
+        "scalar_contact",
+        "--multiplicity",
+        "2",
+        "--generation-engine",
+        "compiled",
+        "--no-color",
+    )
+    dry_run = subprocess.run(
+        dry_run_command,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert dry_run.returncode == 0, (dry_run.stdout, dry_run.stderr)
+    assert "compact retention (default)" in dry_run.stdout
+    retained_dry_run = subprocess.run(
+        (*dry_run_command, "--retain-workspaces"),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert retained_dry_run.returncode == 0, (
+        retained_dry_run.stdout,
+        retained_dry_run.stderr,
+    )
+    assert "full debug workspaces (--retain-workspaces)" in retained_dry_run.stdout
+
+import pyamplicol
+import pyamplicol._rusticol
+from pyamplicol._sdk.config import load_sdk_info
+from pyamplicol.models import BuiltinSMModel
+
+assert pyamplicol.__version__ == version
+package = importlib.resources.files("pyamplicol")
+build_info_resource = package.joinpath("_build_info.json")
+if mode == "candidate":
+    build_info = json.loads(build_info_resource.read_text(encoding="utf-8"))
+    assert build_info["publishable"] is False
+    assert build_info["selftest_fixture_bootstrap"] is False
+    assert build_info["version"] == version
+else:
+    build_info = json.loads(build_info_resource.read_text(encoding="utf-8"))
+    assert set(build_info) == {
+        "publishable",
+        "schema_version",
+        "selftest_fixture_bootstrap",
+        "source_revision",
+        "version",
+    }
+    assert build_info["schema_version"] == 1
+    assert build_info["publishable"] is True
+    assert build_info["selftest_fixture_bootstrap"] is False
+    assert build_info["version"] == version
+    assert re.fullmatch(r"[0-9a-f]{40}", build_info["source_revision"])
+
+sdk = load_sdk_info()
+metadata = json.loads(
+    package.joinpath("_sdk", "metadata.json").read_text(encoding="utf-8")
+)
+
+assert sdk.abi_version == 1
+assert sdk.package_version == version
+
+model = BuiltinSMModel()
+assert model.name == "built-in-sm-leading-color"
+assert model.particles and model.vertices
+
+files = [str(item).replace("\\", "/") for item in (distribution.files or ())]
+assert any("example" in item.lower() for item in files)
+installed_scripts = {item for item in files if item.startswith("../../../bin/")}
+assert installed_scripts == {
+    "../../../bin/pyamplicol",
+    "../../../bin/rusticol-config",
+}, sorted(installed_scripts)
+package_files = [item for item in files if not item.startswith("../../../bin/")]
+roots = {item.split("/", 1)[0] for item in package_files}
+assert all(
+    root == "pyamplicol"
+    or root == "rusticol_config"
+    or root == "pyamplicol.libs"
+    or root.endswith(".dist-info")
+    for root in roots
+), sorted(roots)
+for relative in (
+    ("assets", "schemas", "README.md"),
+    ("assets", "schemas", "artifact-manifest-v3.schema.json"),
+    ("assets", "schemas", "runtime-physics-v1.schema.json"),
+):
+    assert package.joinpath(*relative).is_file(), relative
+
+print(json.dumps({"mode": mode, "version": version, "sdk_target": sdk.target}))
+"""
+)
+
+_SYMBOLICA_FREE_F64_SMOKE = (
+    _PATH_ISOLATION_SMOKE
+    + r"""
+import builtins
+import json
+import os
+import sys
+
+os.environ.pop("SYMBOLICA_LICENSE", None)
+os.environ["SYMBOLICA_HIDE_BANNER"] = "1"
+
+original_import = builtins.__import__
+
+def reject_symbolica(name, globals=None, locals=None, fromlist=(), level=0):
+    if name == "symbolica" or name.startswith("symbolica."):
+        raise ModuleNotFoundError(
+            "Symbolica import blocked by the f64 deployment gate", name="symbolica"
+        )
+    return original_import(name, globals, locals, fromlist, level)
+
+builtins.__import__ = reject_symbolica
+from pyamplicol.diagnostics import run_self_test
+
+report = run_self_test()
+physics = [check for check in report.checks if check.name == "physics-f64"]
+assert report.ok and len(physics) == 1 and physics[0].status == "pass"
+assert not any(
+    name == "symbolica" or name.startswith("symbolica.")
+    for name in sys.modules
+)
+print(json.dumps({"ok": True, "physics": physics[0].detail}, sort_keys=True))
+"""
+)
+
+_SYMBOLICA_ABSENT_F64_SMOKE = (
+    _PATH_ISOLATION_SMOKE
+    + r"""
+import importlib.resources
+import importlib.util
+import json
+import sys
+
+for unavailable in ("symbolica", "ufo_model_loader"):
+    assert importlib.util.find_spec(unavailable) is None, unavailable
+
+import pyamplicol._rusticol as native
+from pyamplicol import Runtime
+
+target = str(native.target_info().triple)
+fixture = importlib.resources.files("pyamplicol").joinpath(
+    "assets", "selftest", target
+)
+expected = json.loads(fixture.joinpath("expected.json").read_text(encoding="utf-8"))
+artifact = fixture.joinpath(str(expected["artifact_path"]))
+manifest = json.loads(artifact.joinpath("artifact.json").read_text(encoding="utf-8"))
+runtime = Runtime.load(
+    str(artifact),
+    process=str(expected["process_id"]),
+    mute_warnings=True,
+)
+assert runtime.artifact_id == manifest["artifact_id"]
+assert runtime.execution_mode == "compiled"
+total = tuple(complex(value) for value in runtime.evaluate(expected["momenta"]))
+resolved = runtime.evaluate_resolved(expected["momenta"])
+reduced = tuple(complex(value) for value in resolved.total())
+expected_total = tuple(complex(*value) for value in expected["total"])
+assert resolved.shape == tuple(expected["resolved_shape"])
+assert len(total) == len(reduced) == len(expected_total)
+for actual, explicit, reference in zip(total, reduced, expected_total, strict=True):
+    scale = max(abs(reference), 1.0)
+    assert abs(actual - reference) <= 1.0e-12 * scale
+    assert abs(explicit - reference) <= 1.0e-12 * scale
+assert not any(
+    name == "symbolica"
+    or name.startswith("symbolica.")
+    or name == "ufo_model_loader"
+    or name.startswith("ufo_model_loader.")
+    for name in sys.modules
+)
+print(json.dumps({"ok": True, "process": runtime.physics.process_id, "target": target}))
+"""
+)
+
+_INSTALLED_BACKEND_AND_PRECISION_SMOKE = (
+    _PATH_ISOLATION_SMOKE
+    + r"""
+import faulthandler
+import json
+import math
+import os
+from pathlib import Path
+
+faulthandler.enable()
+
+from pyamplicol import Generator, Runtime
+from pyamplicol.config import (
+    ColorConfig,
+    EvaluatorBackend,
+    EvaluatorConfig,
+    EvaluatorExecutionMode,
+    EvaluatorOptimizationConfig,
+    GenerationConfig,
+    GenerationValidationConfig,
+    JITConfig,
+    RunConfig,
+    SymbolicaConfig,
+)
+
+root = Path(os.environ["PYAMPLICOL_DEPLOYMENT_SANDBOX"]) / "backend-smoke"
+totals = {}
+for backend in (
+    EvaluatorBackend.JIT,
+    EvaluatorBackend.ASM,
+    EvaluatorBackend.CPP,
+):
+    artifact = root / backend.value
+    config = RunConfig(
+        action="generate",
+        color=ColorConfig(accuracy="lc"),
+        generation=GenerationConfig(
+            workers=1,
+            emit_api_bundle=False,
+            validation=GenerationValidationConfig(samples=10),
+        ),
+        evaluator=EvaluatorConfig(
+            backend=backend,
+            execution_mode=EvaluatorExecutionMode.COMPILED,
+            optimization=EvaluatorOptimizationConfig(cores=1),
+            jit=JITConfig(optimization_level=3),
+        ),
+        symbolica=SymbolicaConfig(suggest_license=False),
+    )
+    print(f"deployment: {backend.value} generation", flush=True)
+    Generator(config).generate("d d~ > z", artifact)
+    manifest = json.loads((artifact / "artifact.json").read_text(encoding="utf-8"))
+    process_id = manifest["processes"][0]["id"]
+    validation = json.loads(
+        (
+            artifact
+            / "processes"
+            / process_id
+            / "validation-momenta.json"
+        ).read_text(encoding="utf-8")
+    )
+    momenta = [
+        [
+            [float(component) for component in particle["momentum"]]
+            for particle in validation["points"][0]
+        ]
+    ]
+    print(f"deployment: {backend.value} load and f64 evaluation", flush=True)
+    runtime = Runtime.load(artifact)
+    assert runtime.artifact_id == manifest["artifact_id"]
+    assert runtime.execution_mode == "compiled"
+    total = runtime.evaluate(momenta)[0]
+    resolved = runtime.evaluate_resolved(momenta)
+    assert resolved.total()[0] == total
+    assert math.isclose(total.imag, 0.0, abs_tol=1.0e-15)
+    totals[backend.value] = total.real
+    if backend is EvaluatorBackend.JIT:
+        print("deployment: jit arbitrary-precision evaluation", flush=True)
+        precise = runtime.evaluate(momenta, precision=80)[0]
+        assert math.isclose(
+            float(precise),
+            total.real,
+            rel_tol=1.0e-12,
+            abs_tol=1.0e-15,
+        )
+
+reference = totals[EvaluatorBackend.JIT.value]
+assert all(
+    math.isclose(value, reference, rel_tol=1.0e-12, abs_tol=1.0e-15)
+    for value in totals.values()
+)
+
+eager_artifact = root / "eager-jit"
+eager_config = RunConfig(
+    action="generate",
+    color=ColorConfig(accuracy="lc"),
+    generation=GenerationConfig(
+        workers=1,
+        emit_api_bundle=False,
+        validation=GenerationValidationConfig(samples=10),
+    ),
+    evaluator=EvaluatorConfig(
+        backend=EvaluatorBackend.JIT,
+        execution_mode=EvaluatorExecutionMode.EAGER,
+        optimization=EvaluatorOptimizationConfig(cores=1),
+        jit=JITConfig(optimization_level=3),
+    ),
+    symbolica=SymbolicaConfig(suggest_license=False),
+)
+print("deployment: eager-jit generation", flush=True)
+Generator(eager_config).generate("d d~ > z", eager_artifact)
+eager_manifest = json.loads(
+    (eager_artifact / "artifact.json").read_text(encoding="utf-8")
+)
+eager_process_id = eager_manifest["processes"][0]["id"]
+eager_execution = json.loads(
+    (
+        eager_artifact
+        / "processes"
+        / eager_process_id
+        / "execution.json"
+    ).read_text(encoding="utf-8")
+)
+assert eager_execution["kind"] == "pyamplicol-runtime-eager-execution"
+assert (eager_artifact / "model/eager-kernel-pack.json").is_file()
+print("deployment: eager-jit load and f64 evaluation", flush=True)
+eager_runtime = Runtime.load(eager_artifact)
+assert eager_runtime.artifact_id == eager_manifest["artifact_id"]
+assert eager_runtime.execution_mode == "eager"
+eager_total = eager_runtime.evaluate(momenta)[0]
+eager_resolved = eager_runtime.evaluate_resolved(momenta)
+eager_reduced = eager_resolved.total()[0]
+assert abs(eager_reduced - eager_total) <= 1.0e-12 * max(abs(eager_total), 1.0)
+assert math.isclose(
+    eager_total.real,
+    reference,
+    rel_tol=1.0e-12,
+    abs_tol=1.0e-15,
+)
+assert math.isclose(eager_total.imag, 0.0, abs_tol=1.0e-15)
+print("deployment: eager-jit arbitrary-precision evaluation", flush=True)
+eager_precise = eager_runtime.evaluate(momenta, precision=80)[0]
+assert math.isclose(
+    float(eager_precise),
+    eager_total.real,
+    rel_tol=1.0e-12,
+    abs_tol=1.0e-15,
+)
+
+print(
+    json.dumps(
+        {
+            "backends": sorted(totals),
+            "eager_execution": True,
+            "total": reference,
+        },
+        sort_keys=True,
+    )
+)
+"""
+)
+
+
+@dataclass(frozen=True)
+class DependencyInstallation:
+    versions: dict[str, str]
+    local_wheels: dict[str, Path]
+
+
+@dataclass(frozen=True)
+class NativeToolchain:
+    cc: tuple[str, ...]
+    cxx: tuple[str, ...]
+    fortran: tuple[str, ...]
+    rustc: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class NativePhysicsFixture:
+    artifact: Path
+    process_id: str
+    shape: tuple[int, int, int]
+    totals: tuple[float, ...]
+
+
+def _release_lock() -> dict[str, Any]:
+    with _LOCK.open("rb") as stream:
+        payload = tomllib.load(stream)
+    if payload.get("schema_version") != 1:
+        raise ReleaseError("dependencies/release-lock.toml must use schema_version = 1")
+    return payload
+
+
+def exact_dependencies() -> dict[str, str]:
+    raw = _release_lock().get("python_dependencies")
+    if not isinstance(raw, list):
+        raise ReleaseError("release lock has no exact Python dependency list")
+    dependencies: dict[str, str] = {}
+    for entry in raw:
+        if not isinstance(entry, dict):
+            raise ReleaseError("release lock Python dependencies must be tables")
+        distribution = entry.get("distribution")
+        version = entry.get("version")
+        if not isinstance(distribution, str) or not isinstance(version, str):
+            raise ReleaseError("release dependency needs distribution/version")
+        name = canonicalize_name(distribution)
+        if name in dependencies:
+            raise ReleaseError(f"release lock repeats Python dependency {name}")
+        dependencies[name] = version
+    return dependencies
+
+
+def _wheel_identity(path: Path) -> tuple[str, str, set[str]]:
+    try:
+        filename_name, filename_version, _build, filename_tags = parse_wheel_filename(
+            path.name
+        )
+    except InvalidWheelFilename as error:
+        raise ReleaseError(
+            f"invalid candidate dependency wheel filename {path.name}: {error}"
+        ) from error
+    try:
+        with zipfile.ZipFile(path) as archive:
+            metadata_names = [
+                name
+                for name in archive.namelist()
+                if name.endswith(".dist-info/METADATA")
+            ]
+            if len(metadata_names) != 1:
+                raise ReleaseError(
+                    f"candidate dependency wheel must contain one METADATA: {path}"
+                )
+            metadata = BytesParser(policy=policy.default).parsebytes(
+                archive.read(metadata_names[0])
+            )
+    except (OSError, KeyError, zipfile.BadZipFile) as error:
+        raise ReleaseError(
+            f"invalid candidate dependency wheel {path}: {error}"
+        ) from error
+    name = canonicalize_name(str(metadata.get("Name", "")))
+    version = str(metadata.get("Version", ""))
+    if not name or not version:
+        raise ReleaseError(f"candidate dependency wheel has no identity: {path}")
+    if canonicalize_name(filename_name) != name or str(filename_version) != version:
+        raise ReleaseError(
+            f"candidate dependency wheel filename disagrees with metadata: {path.name}"
+        )
+    return name, version, {str(tag) for tag in filename_tags}
+
+
+def _candidate_dependency_wheels(
+    requirements: dict[str, str],
+    wheelhouses: Sequence[Path],
+    supported_tags: Sequence[str],
+) -> dict[str, Path]:
+    if not wheelhouses:
+        raise ReleaseError(
+            "candidate deployment requires a local dependency wheelhouse"
+        )
+    wheels: set[Path] = set()
+    for raw_root in wheelhouses:
+        if raw_root.is_symlink():
+            raise ReleaseError(
+                f"candidate dependency wheelhouse may not be a symlink: {raw_root}"
+            )
+        root = raw_root.resolve()
+        if not root.is_dir():
+            raise ReleaseError(f"candidate dependency wheelhouse is missing: {root}")
+        for raw_wheel in root.rglob("*.whl"):
+            if raw_wheel.is_symlink():
+                raise ReleaseError(
+                    f"candidate dependency wheel may not be a symlink: {raw_wheel}"
+                )
+            wheel = raw_wheel.resolve()
+            if not is_relative_to(wheel, root):
+                raise ReleaseError(
+                    f"candidate dependency wheel escapes its wheelhouse: {raw_wheel}"
+                )
+            wheels.add(wheel)
+
+    supported = set(supported_tags)
+    matches: dict[str, list[Path]] = {name: [] for name in requirements}
+    seen_versions: dict[str, set[str]] = {name: set() for name in requirements}
+    for wheel in sorted(wheels):
+        name, version, tags = _wheel_identity(wheel)
+        if name not in requirements:
+            continue
+        seen_versions[name].add(version)
+        if version == requirements[name] and tags & supported:
+            matches[name].append(wheel)
+
+    selected: dict[str, Path] = {}
+    for name, expected_version in sorted(requirements.items()):
+        candidates = matches[name]
+        if len(candidates) != 1:
+            raise ReleaseError(
+                f"expected one compatible local {name}=={expected_version} wheel, "
+                f"found {len(candidates)}; available versions="
+                f"{sorted(seen_versions[name])}"
+            )
+        selected[name] = candidates[0]
+    return selected
+
+
+def _venv_python(virtual_env: Path) -> Path:
+    return virtual_env / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+
+
+def _examples_copy_command(python: Path, destination: Path) -> list[Path | str]:
+    return [
+        python,
+        "-I",
+        "-m",
+        "pyamplicol",
+        "examples",
+        "copy",
+        destination,
+    ]
+
+
+def _copied_example_command(python: Path, card: Path) -> list[Path | str]:
+    return [
+        python,
+        "-I",
+        "-m",
+        "pyamplicol",
+        card,
+        "--set",
+        "generation.mode=replace",
+        "--json",
+    ]
+
+
+def _native_command(variable: str, defaults: Sequence[str]) -> tuple[str, ...] | None:
+    configured = os.environ.get(variable)
+    candidates = (configured,) if configured else tuple(defaults)
+    for candidate in candidates:
+        if not candidate:
+            continue
+        try:
+            command = tuple(shlex.split(candidate))
+        except ValueError as error:
+            raise ReleaseError(f"invalid {variable} command: {error}") from error
+        if not command:
+            continue
+        executable = shutil.which(command[0])
+        if executable is None and Path(command[0]).is_file():
+            executable = str(Path(command[0]).resolve())
+        if executable is not None:
+            return (executable, *command[1:])
+    return None
+
+
+def _native_toolchain(mode: str) -> NativeToolchain | None:
+    cc = _native_command("CC", ("cc", "clang", "gcc"))
+    cxx = _native_command("CXX", ("c++", "clang++", "g++"))
+    fortran = _native_command("FC", ("gfortran", "flang-new", "flang", "ifx"))
+    rustc = _native_command("RUSTC", ("rustc",))
+    missing = tuple(
+        name
+        for name, command in (
+            ("C11", cc),
+            ("C++17", cxx),
+            ("Fortran 2008", fortran),
+            ("Rust 2021", rustc),
+        )
+        if command is None
+    )
+    if missing:
+        message = (
+            "installed-wheel native SDK validation requires "
+            + " and ".join(missing)
+            + " compilers"
+        )
+        if mode == "release" or os.environ.get(
+            "PYAMPLICOL_REQUIRE_NATIVE_TESTS"
+        ) == "1":
+            raise ReleaseError(message)
+        print(f"Candidate deployment did not run native SDK smoke tests: {message}")
+        return None
+    assert all(command is not None for command in (cc, cxx, fortran, rustc))
+    assert cc is not None and cxx is not None
+    assert fortran is not None and rustc is not None
+    return NativeToolchain(cc=cc, cxx=cxx, fortran=fortran, rustc=rustc)
+
+
+def _sdk_payload(python: Path, environment: dict[str, str]) -> dict[str, Any]:
+    completed = run(
+        [python, "-I", "-m", "rusticol_config", "--json"],
+        env=environment,
+        capture_output=True,
+    )
+    try:
+        payload = json.loads(completed.stdout)
+    except json.JSONDecodeError as error:
+        raise ReleaseError(
+            f"rusticol-config emitted invalid SDK JSON: {error}"
+        ) from error
+    if not isinstance(payload, dict):
+        raise ReleaseError("rusticol-config SDK metadata must be an object")
+    for key in (
+        "cflags",
+        "link_flags",
+        "rust_flags",
+        "fortran_source",
+        "rust_source",
+    ):
+        if key not in payload:
+            raise ReleaseError(f"rusticol-config SDK metadata is missing {key}")
+    if not isinstance(payload["cflags"], list) or not all(
+        isinstance(item, str) for item in payload["cflags"]
+    ):
+        raise ReleaseError("rusticol-config cflags must be strings")
+    if not isinstance(payload["link_flags"], list) or not all(
+        isinstance(item, str) for item in payload["link_flags"]
+    ):
+        raise ReleaseError("rusticol-config link flags must be strings")
+    if not isinstance(payload["rust_flags"], list) or not all(
+        isinstance(item, str) for item in payload["rust_flags"]
+    ):
+        raise ReleaseError("rusticol-config rust flags must be strings")
+    return payload
+
+
+def _installed_selftest_fixture(
+    python: Path,
+    *,
+    sandbox: Path,
+    environment: dict[str, str],
+) -> NativePhysicsFixture:
+    completed = run(
+        [python, "-I", "-c", _SELFTEST_RESOURCE],
+        env=environment,
+        capture_output=True,
+    )
+    try:
+        payload = json.loads(completed.stdout)
+    except json.JSONDecodeError as error:
+        raise ReleaseError(
+            f"installed self-test resource query returned invalid JSON: {error}"
+        ) from error
+    if not isinstance(payload, dict) or not isinstance(payload.get("expected"), dict):
+        raise ReleaseError("installed self-test resource query is incomplete")
+    artifact_raw = payload.get("artifact")
+    if not isinstance(artifact_raw, str) or not artifact_raw:
+        raise ReleaseError("installed self-test resource query has no artifact path")
+    artifact = Path(artifact_raw).resolve(strict=True)
+    if not artifact.is_dir() or not is_relative_to(artifact, sandbox):
+        raise ReleaseError(
+            "installed self-test artifact escapes the deployment sandbox"
+        )
+    expected = payload["expected"]
+    process_id = expected.get("process_id")
+    shape_raw = expected.get("resolved_shape")
+    totals_raw = expected.get("total")
+    if (
+        not isinstance(process_id, str)
+        or not process_id
+        or not isinstance(shape_raw, list)
+        or len(shape_raw) != 3
+        or not all(isinstance(value, int) and value > 0 for value in shape_raw)
+        or not isinstance(totals_raw, list)
+        or not totals_raw
+    ):
+        raise ReleaseError("installed self-test expectation is invalid")
+    totals: list[float] = []
+    for index, value in enumerate(totals_raw):
+        if (
+            not isinstance(value, list)
+            or len(value) != 2
+            or isinstance(value[0], bool)
+            or isinstance(value[1], bool)
+            or not isinstance(value[0], (int, float))
+            or not isinstance(value[1], (int, float))
+            or not math.isclose(float(value[1]), 0.0, abs_tol=1.0e-15)
+        ):
+            raise ReleaseError(
+                f"installed native self-test total[{index}] is not real f64"
+            )
+        totals.append(float(value[0]))
+    return NativePhysicsFixture(
+        artifact=artifact,
+        process_id=process_id,
+        shape=tuple(shape_raw),
+        totals=tuple(totals),
+    )
+
+
+def _driver_result(
+    command: Sequence[str | os.PathLike[str]],
+    *,
+    language: str,
+    fixture: NativePhysicsFixture,
+    environment: dict[str, str],
+) -> dict[str, Any]:
+    completed = run(
+        [*command, "--json", "--process", fixture.process_id],
+        cwd=fixture.artifact,
+        env=environment,
+        capture_output=True,
+    )
+    try:
+        payload = json.loads(completed.stdout)
+    except json.JSONDecodeError as error:
+        raise ReleaseError(
+            f"installed {language} API driver returned invalid JSON: {error}"
+        ) from error
+    if (
+        not isinstance(payload, dict)
+        or payload.get("language") != language
+        or payload.get("available") is not True
+        or payload.get("precision") != 16
+        or payload.get("process_key") != fixture.process_id
+        or payload.get("shape") != list(fixture.shape)
+    ):
+        raise ReleaseError(
+            f"installed {language} API driver returned inconsistent metadata"
+        )
+    values = payload.get("values")
+    resolved = payload.get("resolved_sum")
+    compatibility = payload.get("compatibility_total")
+    expected_value_count = math.prod(fixture.shape)
+    numeric_arrays = (values, resolved, compatibility)
+    if not all(
+        isinstance(items, list)
+        and all(
+            isinstance(value, (int, float)) and not isinstance(value, bool)
+            for value in items
+        )
+        for items in numeric_arrays
+    ):
+        raise ReleaseError(
+            f"installed {language} API driver returned nonnumeric values"
+        )
+    assert isinstance(values, list)
+    assert isinstance(resolved, list)
+    assert isinstance(compatibility, list)
+    if (
+        len(values) != expected_value_count
+        or len(resolved) != len(fixture.totals)
+        or len(compatibility) != len(fixture.totals)
+    ):
+        raise ReleaseError(
+            f"installed {language} API driver returned inconsistent result sizes"
+        )
+    for index, expected in enumerate(fixture.totals):
+        scale = max(abs(expected), 1.0)
+        tolerance = 1.0e-12 * scale
+        if (
+            abs(float(resolved[index]) - expected) > tolerance
+            or abs(float(compatibility[index]) - expected) > tolerance
+        ):
+            raise ReleaseError(
+                f"installed {language} API result[{index}] disagrees with "
+                "the packaged physics expectation"
+            )
+    if abs(sum(map(float, values)) - sum(fixture.totals)) > (
+        1.0e-12 * max(abs(sum(fixture.totals)), 1.0)
+    ):
+        raise ReleaseError(
+            f"installed {language} resolved components do not reproduce the total"
+        )
+    return payload
+
+
+def _compare_driver_results(results: dict[str, dict[str, Any]]) -> None:
+    expected_languages = {"python", "c", "cpp", "fortran", "rust"}
+    if set(results) != expected_languages:
+        raise ReleaseError(
+            "installed API comparison did not exercise all five languages"
+        )
+    reference = results["python"]
+    result_keys = ("values", "resolved_sum", "compatibility_total")
+    reference_fields = set(reference) - {"language", *result_keys}
+    for language, payload in results.items():
+        fields = set(payload) - {"language", *result_keys}
+        if fields != reference_fields or any(
+            payload.get(key) != reference.get(key) for key in reference_fields
+        ):
+            raise ReleaseError(
+                f"installed {language} API driver metadata disagrees with Python"
+            )
+        for key in result_keys:
+            reference_values = list(map(float, reference[key]))
+            values = list(map(float, payload[key]))
+            if len(values) != len(reference_values) or any(
+                not math.isclose(left, right, rel_tol=1.0e-12, abs_tol=1.0e-15)
+                for left, right in zip(values, reference_values, strict=True)
+            ):
+                raise ReleaseError(
+                    f"installed {language} API driver disagrees with Python for {key}"
+                )
+
+
+def _native_sdk_smoke(
+    python: Path,
+    *,
+    sandbox: Path,
+    mode: str,
+    environment: dict[str, str],
+) -> bool:
+    toolchain = _native_toolchain(mode)
+    if toolchain is None:
+        return False
+    sdk = _sdk_payload(python, environment)
+    fixture = _installed_selftest_fixture(
+        python,
+        sandbox=sandbox,
+        environment=environment,
+    )
+    native = sandbox / "native-sdk-smoke"
+    native.mkdir(parents=True, exist_ok=False)
+    python_source = fixture.artifact / "API" / "python" / "check_standalone.py"
+    c_source = fixture.artifact / "API" / "c" / "check_standalone.c"
+    cpp_source = fixture.artifact / "API" / "cpp" / "check_standalone.cpp"
+    fortran_source = fixture.artifact / "API" / "fortran" / "check_standalone.f90"
+    rust_source = fixture.artifact / "API" / "rust" / "check_standalone.rs"
+    missing_sources = [
+        source
+        for source in (python_source, c_source, cpp_source, fortran_source, rust_source)
+        if not source.is_file()
+    ]
+    if missing_sources:
+        raise ReleaseError(
+            "installed self-test artifact has no complete five-language API bundle: "
+            + ", ".join(
+                str(path.relative_to(fixture.artifact)) for path in missing_sources
+            )
+        )
+    c_binary = native / "check_standalone_c"
+    cpp_binary = native / "check_standalone_cpp"
+    fortran_binary = native / "check_standalone_fortran"
+    rust_binary = native / "check_standalone_rust"
+
+    cflags = list(map(str, sdk["cflags"]))
+    link_flags = list(map(str, sdk["link_flags"]))
+    rust_flags = list(map(str, sdk["rust_flags"]))
+    packaged_fortran = Path(str(sdk["fortran_source"])).resolve(strict=True)
+    packaged_rust = Path(str(sdk["rust_source"])).resolve(strict=True)
+    run(
+        [
+            *toolchain.cc,
+            "-std=c11",
+            *cflags,
+            c_source,
+            "-o",
+            c_binary,
+            *link_flags,
+        ],
+        cwd=native,
+        env=environment,
+        capture_output=True,
+    )
+    run(
+        [
+            *toolchain.cxx,
+            "-std=c++17",
+            *cflags,
+            cpp_source,
+            "-o",
+            cpp_binary,
+            *link_flags,
+        ],
+        cwd=native,
+        env=environment,
+        capture_output=True,
+    )
+    fortran_flags = ["-std=f2008"]
+    if "gfortran" in Path(toolchain.fortran[0]).name:
+        fortran_flags.append("-ffree-line-length-none")
+    run(
+        [
+            *toolchain.fortran,
+            *fortran_flags,
+            packaged_fortran,
+            fortran_source,
+            "-o",
+            fortran_binary,
+            *link_flags,
+        ],
+        cwd=native,
+        env=environment,
+        capture_output=True,
+    )
+    run(
+        [
+            *toolchain.rustc,
+            "--edition=2021",
+            "-C",
+            "opt-level=2",
+            rust_source,
+            "-o",
+            rust_binary,
+            *rust_flags,
+        ],
+        cwd=native,
+        env={**environment, "RUSTICOL_RUST_SOURCE": str(packaged_rust)},
+        capture_output=True,
+    )
+    results = {
+        "python": _driver_result(
+            (python, "-I", python_source),
+            language="python",
+            fixture=fixture,
+            environment=environment,
+        ),
+        "c": _driver_result(
+            (c_binary,),
+            language="c",
+            fixture=fixture,
+            environment=environment,
+        ),
+        "cpp": _driver_result(
+            (cpp_binary,),
+            language="cpp",
+            fixture=fixture,
+            environment=environment,
+        ),
+        "fortran": _driver_result(
+            (fortran_binary,),
+            language="fortran",
+            fixture=fixture,
+            environment=environment,
+        ),
+        "rust": _driver_result(
+            (rust_binary,),
+            language="rust",
+            fixture=fixture,
+            environment=environment,
+        ),
+    }
+    _compare_driver_results(results)
+    return True
+
+
+def _symbolica_absent_f64_smoke(
+    wheel: Path,
+    *,
+    target_python: Path,
+    sandbox: Path,
+    numpy_version: str,
+) -> None:
+    root = sandbox / "symbolica-absent-f64"
+    root.mkdir(parents=True, exist_ok=False)
+    virtual_env = root / "venv"
+    run(
+        [target_python, "-I", "-m", "venv", virtual_env],
+        env=clean_environment(),
+    )
+    python = _venv_python(virtual_env)
+    environment = clean_environment(virtual_env=virtual_env)
+    run(
+        [
+            python,
+            "-I",
+            "-m",
+            "pip",
+            "install",
+            "--only-binary=:all:",
+            f"numpy=={numpy_version}",
+        ],
+        env=environment,
+    )
+    run(
+        [
+            python,
+            "-I",
+            "-m",
+            "pip",
+            "install",
+            "--no-deps",
+            "--force-reinstall",
+            wheel.resolve(),
+        ],
+        env=environment,
+    )
+    smoke_environment = runtime_environment(virtual_env)
+    smoke_environment.update(
+        {
+            "PYAMPLICOL_FORBIDDEN_ROOT": str(ROOT),
+            "PYAMPLICOL_DEPLOYMENT_SANDBOX": str(sandbox),
+        }
+    )
+    run(
+        [python, "-I", "-c", _SYMBOLICA_ABSENT_F64_SMOKE],
+        env=smoke_environment,
+    )
+
+
+def _build_fresh_candidate_wheel(artifact_directory: Path) -> Path:
+    artifact_directory.mkdir(parents=True, exist_ok=True)
+    if list(artifact_directory.iterdir()):
+        raise ReleaseError(
+            "candidate deployment build directory must start empty: "
+            f"{artifact_directory}"
+        )
+    run(
+        [
+            sys.executable,
+            "-m",
+            "build",
+            "--wheel",
+            "--outdir",
+            artifact_directory,
+        ],
+        cwd=ROOT,
+        env=clean_environment(mode="candidate"),
+    )
+    return exactly_one(
+        list(artifact_directory.glob("pyamplicol-*.whl")),
+        "fresh candidate deployment wheel",
+    )
+
+
+def _build_release_if_needed(artifact_directory: Path) -> None:
+    if list(artifact_directory.glob("pyamplicol-*.whl")):
+        return
+    run(
+        [
+            sys.executable,
+            ROOT / "tools" / "release" / "build_release_artifacts.py",
+        ],
+        cwd=ROOT,
+        env=clean_environment(mode="release"),
+    )
+
+
+def _install_dependencies(
+    python: Path,
+    *,
+    virtual_env: Path,
+    mode: str,
+    wheelhouses: Sequence[Path],
+    supported_tags: Sequence[str] | None = None,
+) -> DependencyInstallation:
+    lock = _release_lock()
+    dependencies = exact_dependencies()
+    base_command: list[str | os.PathLike[str]] = [
+        python,
+        "-I",
+        "-m",
+        "pip",
+        "install",
+        "--only-binary=:all:",
+        "--index-url",
+        "https://pypi.org/simple",
+    ]
+    if mode == "candidate":
+        candidate_requirements = _candidate_dependency_overrides()
+        dependencies.update(candidate_requirements)
+        local_wheels = _candidate_dependency_wheels(
+            candidate_requirements,
+            wheelhouses,
+            supported_tags or interpreter_tags(python),
+        )
+    elif wheelhouses:
+        raise ReleaseError("release deployment cannot consume a local wheelhouse")
+    else:
+        local_wheels = {}
+    distributions = {
+        canonicalize_name(str(entry["distribution"])): str(entry["distribution"])
+        for entry in lock["python_dependencies"]
+    }
+    requirements: list[str | os.PathLike[str]] = []
+    for name, version in sorted(dependencies.items()):
+        local = local_wheels.get(name)
+        requirements.append(
+            local if local is not None else f"{distributions[name]}=={version}"
+        )
+    command = [*base_command, *requirements]
+    run(command, env=clean_environment(virtual_env=virtual_env))
+    return DependencyInstallation(dependencies, local_wheels)
+
+
+def test_deployment(
+    wheel: Path,
+    *,
+    target_python: Path,
+    mode: str,
+    wheelhouses: Sequence[Path],
+    keep: bool,
+    abi3_smoke_only: bool = False,
+) -> Path | None:
+    report = audit_wheel(wheel, mode=mode)
+    DEPLOYMENT_ROOT.mkdir(parents=True, exist_ok=True)
+    sandbox = Path(tempfile.mkdtemp(prefix=f"{mode}-", dir=DEPLOYMENT_ROOT)).resolve()
+    try:
+        virtual_env = sandbox / "venv"
+        run(
+            [target_python, "-I", "-m", "venv", virtual_env],
+            env=clean_environment(),
+        )
+        python = _venv_python(virtual_env)
+        installation = _install_dependencies(
+            python,
+            virtual_env=virtual_env,
+            mode=mode,
+            wheelhouses=wheelhouses,
+            supported_tags=interpreter_tags(python),
+        )
+        install_environment = clean_environment(virtual_env=virtual_env)
+        run(
+            [
+                python,
+                "-I",
+                "-m",
+                "pip",
+                "install",
+                "--no-deps",
+                "--force-reinstall",
+                wheel.resolve(),
+            ],
+            env=install_environment,
+        )
+        run([python, "-I", "-m", "pip", "check"], env=install_environment)
+
+        smoke_environment = runtime_environment(virtual_env)
+        smoke_environment.update(
+            {
+                "PYAMPLICOL_DEPLOYMENT_MODE": mode,
+                "PYAMPLICOL_EXPECTED_DEPENDENCIES": json.dumps(
+                    installation.versions, sort_keys=True
+                ),
+                "PYAMPLICOL_EXPECTED_LOCAL_SOURCES": json.dumps(
+                    {
+                        name: {"path": str(path), "sha256": sha256(path)}
+                        for name, path in installation.local_wheels.items()
+                    },
+                    sort_keys=True,
+                ),
+                "PYAMPLICOL_EXPECTED_VERSION": report.version,
+                "PYAMPLICOL_FORBIDDEN_ROOT": str(ROOT),
+                "PYAMPLICOL_DEPLOYMENT_SANDBOX": str(sandbox),
+            }
+        )
+        run([python, "-I", "-c", _INSTALLED_SMOKE], env=smoke_environment)
+        if not abi3_smoke_only:
+            run(
+                [python, "-I", "-m", "pyamplicol.selftest"],
+                env=smoke_environment,
+            )
+        run(
+            [python, "-I", "-c", _SYMBOLICA_FREE_F64_SMOKE],
+            env=smoke_environment,
+        )
+        native_sdk_validated = False
+        if not abi3_smoke_only:
+            numpy_version = installation.versions.get("numpy")
+            if numpy_version is None:
+                raise ReleaseError(
+                    "deployment dependency closure has no NumPy version"
+                )
+            _symbolica_absent_f64_smoke(
+                wheel,
+                target_python=target_python,
+                sandbox=sandbox,
+                numpy_version=numpy_version,
+            )
+            backend_environment = dict(smoke_environment)
+            backend_environment["SYMBOLICA_HIDE_BANNER"] = "1"
+            run(
+                [python, "-I", "-c", _INSTALLED_BACKEND_AND_PRECISION_SMOKE],
+                cwd=sandbox,
+                env=backend_environment,
+            )
+            run(
+                [
+                    python,
+                    "-I",
+                    "-m",
+                    "pyamplicol",
+                    "self-test",
+                    "--json",
+                ],
+                env=smoke_environment,
+            )
+            copied_examples = sandbox / "examples"
+            run(
+                _examples_copy_command(python, copied_examples),
+                env=smoke_environment,
+            )
+            if not any(path.is_file() for path in copied_examples.rglob("*")):
+                raise ReleaseError("installed example-copy command produced no files")
+            example_artifact = copied_examples / "artifacts/external_ufo_sm"
+            run(
+                _copied_example_command(
+                    python,
+                    copied_examples / "external_ufo_sm.toml",
+                ),
+                cwd=copied_examples,
+                env=smoke_environment,
+            )
+            if not (example_artifact / "artifact.json").is_file():
+                raise ReleaseError(
+                    "installed external-UFO example did not generate its artifact"
+                )
+            native_sdk_validated = _native_sdk_smoke(
+                python,
+                sandbox=sandbox,
+                mode=mode,
+                environment=smoke_environment,
+            )
+        (sandbox / "deployment-result.json").write_text(
+            json.dumps(
+                {
+                    "schema_version": 1,
+                    "mode": mode,
+                    "python": str(target_python.resolve()),
+                    "wheel": wheel.name,
+                    "wheel_sha256": sha256(wheel),
+                    "version": report.version,
+                    "validation_scope": ("abi3-smoke" if abi3_smoke_only else "full"),
+                    "native_sdk_validated": native_sdk_validated,
+                },
+                indent=2,
+                sort_keys=True,
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        print(f"Deployment validation passed in {sandbox}")
+        return sandbox if keep else None
+    finally:
+        if not keep:
+            shutil.rmtree(sandbox, ignore_errors=True)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--candidate", action="store_true")
+    parser.add_argument("--python", type=Path, default=Path(sys.executable))
+    parser.add_argument("--wheel", type=Path)
+    parser.add_argument("--artifact-dir", type=Path)
+    parser.add_argument("--wheelhouse", type=Path, action="append", default=[])
+    parser.add_argument("--no-build", action="store_true")
+    parser.add_argument("--keep", action="store_true")
+    parser.add_argument(
+        "--abi3-smoke-only",
+        action="store_true",
+        help=(
+            "validate installed abi3/import/direct-runtime compatibility without "
+            "repeating generation and native SDK tests"
+        ),
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    mode = build_mode(candidate=args.candidate)
+    check_dependency_gate(mode)
+    artifact_directory = args.artifact_dir or (
+        CANDIDATE_ARTIFACTS if mode == "candidate" else DIST
+    )
+    with ExitStack() as stack:
+        if args.wheel is not None:
+            wheels = [args.wheel]
+        elif mode == "candidate" and not args.no_build:
+            scratch = stack.enter_context(
+                external_temporary_directory("pyamplicol-candidate-deployment-build-")
+            )
+            wheels = [_build_fresh_candidate_wheel(scratch)]
+        else:
+            if not args.no_build:
+                _build_release_if_needed(artifact_directory)
+            wheels = sorted(artifact_directory.glob("pyamplicol-*.whl"))
+        wheel = select_compatible_wheel(wheels, interpreter_tags(args.python))
+        wheelhouses = [path.resolve() for path in args.wheelhouse]
+        if mode == "candidate" and not wheelhouses:
+            wheelhouses = wheelhouse_directories(DEPENDENCY_WHEELHOUSE)
+        test_deployment(
+            wheel,
+            target_python=args.python,
+            mode=mode,
+            wheelhouses=wheelhouses,
+            keep=args.keep,
+            abi3_smoke_only=args.abi3_smoke_only,
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except ReleaseError as error:
+        print(f"error: {error}", file=sys.stderr)
+        raise SystemExit(2) from error
diff --git a/pyamplicol/tools/typing/check_public_typing.py b/pyamplicol/tools/typing/check_public_typing.py
new file mode 100644
index 0000000000..902726eebb
--- /dev/null
+++ b/pyamplicol/tools/typing/check_public_typing.py
@@ -0,0 +1,330 @@
+# SPDX-License-Identifier: 0BSD
+"""Validate and type-check the installed public Python contract."""
+
+from __future__ import annotations
+
+import ast
+import importlib
+import os
+import re
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+ROOT = Path(__file__).resolve().parents[2]
+SOURCE_PACKAGE = ROOT / "src" / "pyamplicol"
+RUST_STUB = (
+    ROOT
+    / "rust"
+    / "crates"
+    / "rusticol-python"
+    / "stubs"
+    / "pyamplicol"
+    / "_rusticol.pyi"
+)
+RUST_BINDING = ROOT / "rust" / "crates" / "rusticol-python" / "src" / "lib.rs"
+BUILD_BACKEND = ROOT / "build_backend" / "_pyamplicol_build.py"
+PUBLIC_CONSUMER = ROOT / "tests" / "typing" / "consumer_public_api.py"
+NATIVE_CONSUMER = ROOT / "tests" / "typing" / "consumer_native_api.py"
+
+PUBLIC_FACADES: dict[str, Path] = {
+    "pyamplicol": SOURCE_PACKAGE / "__init__.py",
+    "pyamplicol.api": SOURCE_PACKAGE / "api" / "__init__.py",
+    "pyamplicol.config": SOURCE_PACKAGE / "config" / "__init__.py",
+    "pyamplicol.reporting": SOURCE_PACKAGE / "reporting" / "__init__.py",
+    "pyamplicol.runtime": SOURCE_PACKAGE / "runtime" / "__init__.py",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class MetadataCheck:
+    errors: tuple[str, ...]
+    native_symbols: tuple[str, ...] | None
+
+
+def static_all(path: Path) -> tuple[str, ...]:
+    """Read one literal ``__all__`` declaration without importing the package."""
+
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    for node in tree.body:
+        if not isinstance(node, ast.Assign):
+            continue
+        if not any(
+            isinstance(target, ast.Name) and target.id == "__all__"
+            for target in node.targets
+        ):
+            continue
+        if not isinstance(node.value, (ast.List, ast.Tuple)):
+            raise ValueError(f"{path}: __all__ must be a literal list or tuple")
+        exports = tuple(
+            item.value
+            for item in node.value.elts
+            if isinstance(item, ast.Constant) and isinstance(item.value, str)
+        )
+        if len(exports) != len(node.value.elts):
+            raise ValueError(f"{path}: __all__ must contain only string literals")
+        if len(exports) != len(set(exports)):
+            raise ValueError(f"{path}: __all__ contains duplicate names")
+        return exports
+    raise ValueError(f"{path}: no static __all__ declaration")
+
+
+def _stub_definitions(path: Path) -> set[str]:
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    return {
+        node.name
+        for node in tree.body
+        if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef))
+        and not node.name.startswith("_")
+    }
+
+
+def _binding_exports(path: Path) -> set[str]:
+    source = path.read_text(encoding="utf-8")
+    classes = set(re.findall(r"module\.add_class::<([A-Za-z_][A-Za-z0-9_]*)>", source))
+    functions = set(
+        re.findall(r"wrap_pyfunction!\(([A-Za-z_][A-Za-z0-9_]*),\s*module\)", source)
+    )
+    functions = {name for name in functions if not name.startswith("_")}
+    exceptions = set(re.findall(r'module\.add\(\s*"([A-Za-z_][A-Za-z0-9_]*)"', source))
+    return classes | functions | exceptions
+
+
+def _backend_stages_stub(path: Path) -> bool:
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    stage_function: ast.FunctionDef | None = None
+    call_count = 0
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef) and node.name == "_stage_python_stub":
+            stage_function = node
+        if (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, ast.Name)
+            and node.func.id == "_stage_python_stub"
+        ):
+            call_count += 1
+    if stage_function is None or call_count == 0:
+        return False
+    constants = {
+        node.value
+        for node in ast.walk(stage_function)
+        if isinstance(node, ast.Constant) and isinstance(node.value, str)
+    }
+    copies_file = any(
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and node.func.attr == "copy2"
+        for node in ast.walk(stage_function)
+    )
+    return "_rusticol.pyi" in constants and copies_file
+
+
+def check_typing_metadata() -> MetadataCheck:
+    """Return metadata/stub contract failures without rebuilding the extension."""
+
+    errors: list[str] = []
+    marker = SOURCE_PACKAGE / "py.typed"
+    if not marker.is_file():
+        errors.append(f"missing inline typing marker: {marker.relative_to(ROOT)}")
+    elif marker.read_text(encoding="utf-8").strip():
+        errors.append("py.typed must be an empty full-package marker")
+
+    if not RUST_STUB.is_file():
+        errors.append(f"missing maintained native stub: {RUST_STUB.relative_to(ROOT)}")
+        return MetadataCheck(tuple(errors), None)
+    if not _backend_stages_stub(BUILD_BACKEND):
+        errors.append("build backend no longer stages the maintained _rusticol.pyi")
+
+    stub_symbols = _stub_definitions(RUST_STUB)
+    binding_symbols = _binding_exports(RUST_BINDING)
+    missing_stub_symbols = sorted(binding_symbols - stub_symbols)
+    extra_stub_symbols = sorted(stub_symbols - binding_symbols)
+    if missing_stub_symbols:
+        errors.append(
+            "native stub misses Rust exports: " + ", ".join(missing_stub_symbols)
+        )
+    if extra_stub_symbols:
+        errors.append(
+            "native stub declares non-exported symbols: "
+            + ", ".join(extra_stub_symbols)
+        )
+
+    native_symbols: tuple[str, ...] | None = None
+    try:
+        native = importlib.import_module("pyamplicol._rusticol")
+    except (ImportError, OSError):
+        pass
+    else:
+        native_symbols = tuple(
+            sorted(name for name in dir(native) if not name.startswith("_"))
+        )
+        missing_runtime_symbols = sorted(set(native_symbols) - stub_symbols)
+        if missing_runtime_symbols:
+            errors.append(
+                "native stub misses exports in the available extension: "
+                + ", ".join(missing_runtime_symbols)
+            )
+    return MetadataCheck(tuple(errors), native_symbols)
+
+
+def render_export_consumer() -> str:
+    """Build a consumer expression for every current public facade export."""
+
+    aliases = {
+        "pyamplicol": "package",
+        "pyamplicol.api": "api",
+        "pyamplicol.config": "config",
+        "pyamplicol.reporting": "reporting",
+        "pyamplicol.runtime": "runtime",
+    }
+    lines = [
+        "# Generated in a temporary directory by the public typing gate.",
+        "from __future__ import annotations",
+        "",
+        "from typing import reveal_type",
+        "",
+    ]
+    for module, alias in aliases.items():
+        lines.append(f"import {module} as {alias}")
+    lines.append("")
+    for module, path in PUBLIC_FACADES.items():
+        alias = aliases[module]
+        lines.extend(f"reveal_type({alias}.{name})" for name in static_all(path))
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _stage_installed_package(destination: Path) -> Path:
+    site_packages = destination / "site-packages"
+    installed = site_packages / "pyamplicol"
+    shutil.copytree(
+        SOURCE_PACKAGE,
+        installed,
+        ignore=shutil.ignore_patterns(
+            "__pycache__", "*.pyc", "*.so", "ufo", "api_templates"
+        ),
+    )
+    shutil.copy2(RUST_STUB, installed / "_rusticol.pyi")
+    return site_packages
+
+
+def _run_mypy(command: list[str], *, environment: dict[str, str] | None = None) -> int:
+    completed = subprocess.run(command, cwd=ROOT, env=environment, check=False)
+    return completed.returncode
+
+
+def _check_installed_consumers() -> int:
+    with TemporaryDirectory(prefix="pyamplicol-typing-") as temporary:
+        root = Path(temporary)
+        site_packages = _stage_installed_package(root)
+        generated_consumer = root / "consumer_all_exports.py"
+        generated_consumer.write_text(render_export_consumer(), encoding="utf-8")
+        config = root / "mypy.ini"
+        config.write_text(
+            "\n".join(
+                (
+                    "[mypy]",
+                    "python_version = 3.11",
+                    "strict = True",
+                    "follow_imports = silent",
+                    f"mypy_path = {site_packages}",
+                    "no_site_packages = True",
+                    "show_error_codes = True",
+                    "warn_unused_configs = True",
+                    "",
+                )
+            ),
+            encoding="utf-8",
+        )
+        environment = os.environ.copy()
+        environment.pop("MYPYPATH", None)
+        consumer_status = _run_mypy(
+            [
+                sys.executable,
+                "-m",
+                "mypy",
+                "--config-file",
+                str(config),
+                str(PUBLIC_CONSUMER),
+                str(NATIVE_CONSUMER),
+            ],
+            environment=environment,
+        )
+        if consumer_status != 0:
+            return consumer_status
+
+        exports = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "mypy",
+                "--config-file",
+                str(config),
+                str(generated_consumer),
+            ],
+            cwd=ROOT,
+            env=environment,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if exports.returncode != 0:
+            sys.stdout.write(exports.stdout)
+            sys.stderr.write(exports.stderr)
+            return exports.returncode
+        reveal_lines = tuple(
+            line for line in exports.stdout.splitlines() if "Revealed type is" in line
+        )
+        expected_reveals = sum(
+            len(static_all(path)) for path in PUBLIC_FACADES.values()
+        )
+        if len(reveal_lines) != expected_reveals:
+            print(
+                "typing export error: expected "
+                f"{expected_reveals} revealed types, found {len(reveal_lines)}",
+                file=sys.stderr,
+            )
+            return 1
+        degraded = tuple(
+            line
+            for line in reveal_lines
+            if re.search(r'Revealed type is ["\']Any["\']$', line)
+        )
+        if degraded:
+            print(
+                "typing export error: public exports degraded to Any",
+                file=sys.stderr,
+            )
+            print("\n".join(degraded), file=sys.stderr)
+            return 1
+        return 0
+
+
+def main() -> int:
+    metadata = check_typing_metadata()
+    for error in metadata.errors:
+        print(f"typing metadata error: {error}", file=sys.stderr)
+    if metadata.errors:
+        return 1
+    if metadata.native_symbols is None:
+        print(
+            "typing metadata: native extension unavailable; "
+            "checked canonical Rust exports"
+        )
+    else:
+        print(
+            "typing metadata: covered "
+            f"{len(metadata.native_symbols)} available native exports"
+        )
+
+    source_status = _run_mypy([sys.executable, "-m", "mypy"])
+    if source_status != 0:
+        return source_status
+    return _check_installed_consumers()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/pyamplicol/umami_example/README.md b/pyamplicol/umami_example/README.md
new file mode 100644
index 0000000000..b7764f4bc0
--- /dev/null
+++ b/pyamplicol/umami_example/README.md
@@ -0,0 +1,227 @@
+# MadSpace integration through the generated UMAMI API
+
+This example generates `g g > g g g` in leading colour (LC) and full colour,
+builds each generated UMAMI shared library, runs its linked C driver, compares
+batched MadSpace evaluations with native pyAmpliCol, and performs a real partonic
+integration with MadSpace and VEGAS. LC and full-colour integrals need not agree:
+they are different colour approximations.
+
+`test_umami.py` and `test_integrate.py` are adapted from the examples by
+R. Frederix and T. Vitos in the
+[AmpliCol `madspace_interface` branch](https://github.com/rikkert-frederix/AmpliCol/tree/madspace_interface):
+[loading example](https://github.com/rikkert-frederix/AmpliCol/blob/madspace_interface/test_umami.py)
+and [integration example](https://github.com/rikkert-frederix/AmpliCol/blob/madspace_interface/test_integrate.py).
+The loading example retains MadSpace's batched matrix-element calls; the
+integration example retains the original seven-section layout, phase-space
+mappings, differential cross section, per-channel VEGAS and optional MadNIS/PDF
+workflow.
+
+The upstream `madspace_interface` branch contains no explicit license file or
+license notice in these two scripts. Their attribution is retained, and this
+repository does not assign them a new 0BSD license. The generated UMAMI header
+has its own separate `UMAMI_LICENSE` notice.
+
+## Run the complete example
+
+Use an environment containing this version of pyAmpliCol, a C compiler and Make.
+The following are optional example dependencies, not pyAmpliCol requirements:
+
+```sh
+python -m pip install -r umami_example/requirements.txt
+python umami_example/run.py
+```
+
+Generation uses recurrence JIT O2, one worker and one optimization core, with
+numerical current-relation discovery explicitly disabled. Full colour uses the
+configured default exact colour contraction (adjoint FFT). Both accuracies use
+automatic symmetry grouping.
+
+The output is `.artifacts/umami-example/`. Artifact payloads are in `lc/` and
+`full/`; compiled libraries and drivers are outside them in `build_lc/` and
+`build_full/`. Each integration writes `integration_lc.json` or
+`integration_full.json`, with a cross section in pb and statistical uncertainty.
+Defaults are intentionally small: two VEGAS training iterations with 256 and 512
+points, then 2048 integration points **per independent channel**. These are
+smoke demonstrations, not precision cross-section predictions.
+
+Existing artifacts are never overwritten. Continue using the saved artifacts
+with `--reuse`, or choose another `--output`. For example:
+
+```sh
+python umami_example/run.py --reuse --accuracy full --n 8192 --training 1024 2048
+```
+
+If `rusticol-config` is not on `PATH`, pass
+`--rusticol-config /absolute/path/to/rusticol-config`. It must belong to the same
+pyAmpliCol installation as the generation/runtime environment. Its `--cflags`
+and `--libs` supply the headers and native library to the generated Makefile.
+The C driver links to the resulting UMAMI `.so`, not to a second copy of
+Rusticol. The Makefile sets a relative runtime-library search path so the driver
+and `.so` can be moved together.
+
+### Updating a checkout or stale environment
+
+`git pull` updates these example scripts, but does not update a non-editable
+pyAmpliCol installation. `run.py` prints the active Python and UMAMI exporter
+paths and rejects an obsolete exporter before loading the optional integration
+dependencies. To inspect those paths without running the example:
+
+```sh
+python -c "import sys; import pyamplicol.artifacts.umami as umami; print(sys.executable); print(umami.__file__)"
+```
+
+From a clean checkout of the current `umami` branch, use the repository's normal
+contributor installation workflow to rebuild and reinstall it into `.venv`:
+
+```sh
+just dev-install
+.venv/bin/python -m pip install -r umami_example/requirements.txt
+.venv/bin/python umami_example/run.py \
+  --rusticol-config "$PWD/.venv/bin/rusticol-config" \
+  --output .artifacts/umami-example-current
+```
+
+For Python-only development with an already matching native runtime staged by
+`just dev-install`, run directly from the checkout without rebuilding Rusticol:
+
+```sh
+env PYTHONPATH="$PWD/src" .venv/bin/python umami_example/run.py \
+  --rusticol-config "$PWD/.venv/bin/rusticol-config" \
+  --output .artifacts/umami-example-source
+```
+
+Run these commands from the repository root and choose a previously unused
+`--output`, **without `--reuse`**, when replacing stale artifacts. An old exporter
+with a `grouping` argument, or metadata retaining `grouping.mode` (such as
+`"exact"`), predates the automatic-grouping contract. The examples reject that
+metadata. Updating Python does not update existing artifacts: regenerate the
+artifact and rebuild its matching `.so`. Editing JSON counts or multiplicities
+cannot repair the provider tables compiled into an old library. The run reports
+the actual channel, representative and physical-member counts from metadata.
+
+## Run the individual steps
+
+For an already generated artifact, use absolute paths (substitute your paths):
+
+```sh
+make -C /path/to/artifact/API/umami BUILD_DIR=/path/to/build
+/path/to/build/umami_driver /path/to/artifact
+python umami_example/test_umami.py /path/to/artifact \
+  --library /path/to/build/libumami.so
+python umami_example/test_integrate.py /path/to/artifact/API/umami/metadata.json \
+  --library /path/to/build/libumami.so --artifact /path/to/artifact \
+  --no-pdf --vegas-only --n 8192 --training 1024 2048
+```
+
+UMAMI's `param_card_path` argument is the **absolute artifact directory**, not a
+parameter card. The artifact supplies the saved model parameters. The loading
+test varies the declared αs parameter event by event when available and checks
+the resulting matrix elements against native pyAmpliCol, including refreshed
+dependent parameters. A sampled helicity label is informational: the returned
+matrix element remains summed over the artifact's available helicities.
+For complete LC coverage, the pointwise check expands the physical members and
+their momentum mappings and checks that their sum reconstructs the native LC
+total. Integration multiplicities are not pointwise factors.
+
+Mixed process sets can produce multiple fixed-metadata providers. Select one
+explicitly using `--provider p0` (or another ID from the metadata index) and its
+matching `libumami_p0.so`. Its standalone driver is `umami_driver_p0`. The
+orchestrator generates a single-process artifact and therefore needs no provider
+selection.
+
+## Integration options and assumptions
+
+The default integration is at fixed partonic centre-of-mass energy 1 TeV, with
+no PDFs and no downloads. All outgoing legs have `pT > 30 GeV`, `|eta| < 6` and
+pairwise `delta R > 0.4`. Masses come from provider metadata; there are no
+built-in particle-category or mass tables. This scattering example requires two
+massless incoming particles, matching MadSpace's `1/(2 s_hat)` flux; the UMAMI
+provider itself has no such restriction. The integration script's `--sqrts`,
+`--pt-min`, `--eta-max` and `--dr-min` options change these settings. All compact
+UMAMI integrations assume permutation-invariant, flavour-blind cuts and
+observables. The script therefore has no species-selective cut option, and its
+programmatic cut builder rejects species selections.
+
+UMAMI automatically groups proven equivalent contributions with different
+physical final-state flavours, and always groups integration orbits of identical
+final-state PDGs, using oriented physical colour topology and permutations that
+preserve the available helicity coverage. There is no additional reflection
+quotient, equal PDF assumption or beam exchange. For complete LC coverage of `g g > g g g`,
+24 physical colour contributions reduce to four representatives with
+integration multiplicity six each. Full colour remains one contracted
+contribution without an extra factorial multiplier. Equivalence comes from the
+model expressions and generated computation, not equal parameter defaults or
+Standard Model-specific particle rules. Unproved relations remain separate;
+there is no grouping option.
+
+The integration script applies metadata multiplicities once, assuming cuts
+invariant under the recorded permutations and blind to final-state flavour,
+and does not sum alternative mappings of the same contribution. Arbitrary
+labelled-leg or species-sensitive cuts, or pointwise sums, require expanding the
+retained physical members and their momentum mappings; multiplying one
+representative by its integration multiplicity is not a substitute. The compact
+integration script does not implement such cuts. Physical incoming PDGs keep
+their own PDF weights.
+
+For the optional neural-flow training, pass `--madnis --epochs 200` to
+`test_integrate.py`. `--learn-discrete` also lets MadNIS learn the phase-space
+mapping's discrete choices. The default is VEGAS only and one CPU thread.
+
+For hadronic integration, use `--pdf --sqrts 13000 --pdf-dir /path/to/PDF/set`
+and `--pdfset NAME`. The directory must already contain `NAME.info` and
+`NAME_0000.dat`; this example does not download PDF data. If `--pdf-dir` is
+omitted, the optional `lhapdf` Python binding locates the installed set. A
+provider must expose a model-declared αs parameter for this running-coupling
+workflow. A fixed scale can be given with `--scale`; otherwise the original
+example's dynamical scale is used.
+
+## Necessary adaptations from the AmpliCol examples
+
+- Load the generated library and artifact path, including explicit provider
+  selection, rather than a process-specific AmpliCol library and parameter card.
+- Use current MadSpace call signatures, and derive masses, physical flavours,
+  colour orderings and contribution maps from the generated metadata.
+- Bind `FunctionRuntime` explicitly to the one-thread context holding the
+  loaded provider; MadSpace 0.2.1's convenience calls use its global context.
+- Construct MadSpace's matrix-element function with its explicit particle
+  count, avoiding the convenience overload's unconditional diagram-count query.
+  No diagrams are invented for the recursion-based provider.
+- Integrate one representative per identical-final-particle LC orbit, with its
+  metadata multiplicity. Full colour is an already contracted result and is not
+  evaluated repeatedly as if it were separate colour flows.
+- Retain Rusticol's incoming averages and identical-final-state factors exactly
+  once. MadSpace's differential cross section adds flux, phase-space weights,
+  optional PDFs and the conversion to pb.
+- In the no-PDF workflow, use the artifact's default αs rather than requesting
+  running αs without a running-coupling object.
+- Sum only independent metadata contributions, not alternative phase-space
+  maps without a partition of unity.
+- Use bounded deterministic defaults, finite-result assertions, native numerical
+  comparisons, and machine-readable integration results.
+  Both Torch and VEGAS's independent NumPy generator are explicitly seeded.
+
+The standalone SDK and complete UMAMI conventions are documented in the
+project's UMAMI API page and in the generated `API/umami/README.md`.
+
+## Optional grouping acceptance check
+
+```sh
+python umami_example/test_grouping.py
+```
+
+This generates one automatically compacted provider for the much smaller LC
+process `g g > g g` and reuses the same real MadSpace/VEGAS integration code. Its
+cuts are symmetric in the outgoing legs (`pT > 100 GeV`, `|eta| < 6`,
+`delta R > 0.4` at 1 TeV). The fixture must compact six physical colour
+contributions into three representatives with integration multiplicity two.
+The reference expands each retained member into a separate integration channel,
+composes its momentum mapping with the representative's map, and uses only its
+physical weight, not the integration multiplicity. The provider's representative
+computations remain certified and unchanged. It compares the compact and
+explicit-member integrals using independent, fixed-seed
+estimates within six combined statistical standard errors, with each estimate's
+relative error below 5%. This is
+stochastic validation, not the authority establishing amplitude equivalences.
+The default is 4096 points per channel after 256/512-point training. Estimates,
+errors, counts and comparisons are retained in
+`.artifacts/umami-grouping/grouping_comparison.json`; `--reuse` skips regeneration.
diff --git a/pyamplicol/umami_example/_metadata.py b/pyamplicol/umami_example/_metadata.py
new file mode 100644
index 0000000000..677a77451f
--- /dev/null
+++ b/pyamplicol/umami_example/_metadata.py
@@ -0,0 +1,64 @@
+"""Small shared reader for the generated UMAMI example metadata."""
+
+from __future__ import annotations
+
+import inspect
+import json
+import sys
+from pathlib import Path
+
+
+def require_current_exporter() -> Path:
+    """Reject the old selectable exporter before starting expensive generation."""
+    from pyamplicol.artifacts import umami
+
+    path = Path(umami.__file__).resolve()
+    if "grouping" in inspect.signature(umami.build_umami_metadata).parameters:
+        raise RuntimeError(
+            f"Outdated pyAmpliCol UMAMI exporter loaded by {sys.executable}: {path}. "
+            "Reinstall pyAmpliCol from the current umami branch in this Python "
+            "environment; git pull alone only updates the example scripts. "
+            "Then regenerate into a fresh --output without --reuse. "
+            "See umami_example/README.md for the source-checkout workflow."
+        )
+    return path
+
+
+def grouping_summary(data: dict) -> str:
+    """Describe the loaded tables, without claiming that a policy was applied."""
+    entries = [entry for channel in data["channels"] for entry in channel["processes"]]
+    physical_count = sum(len(entry["members"]) for entry in entries)
+    return (
+        f"{len(data['channels'])} integration channels, "
+        f"{len(entries)} representative contributions, "
+        f"{physical_count} physical contributions"
+    )
+
+
+def load_metadata(path: str | Path, provider: str | None = None) -> dict:
+    path = Path(path).resolve()
+    data = json.loads(path.read_text())
+    if data.get("kind") == "pyamplicol-umami-provider-index":
+        choices = data["providers"]
+        selected = [item for item in choices if item["id"] == provider]
+        if len(selected) != 1:
+            names = ", ".join(item["id"] for item in choices)
+            raise ValueError(f"select one provider with --provider: {names}")
+        return load_metadata(path.parent / selected[0]["metadata"], provider)
+    if provider is not None and data["provider"]["id"] != provider:
+        raise ValueError(f"metadata does not describe provider {provider!r}")
+    if data["provider"]["incoming_count"] != 2:
+        raise ValueError("this scattering example requires two incoming particles")
+    grouping = data.get("grouping")
+    if (
+        not isinstance(grouping, dict)
+        or "mode" in grouping
+        or not {"physical_contributions", "exported_contributions"} <= grouping.keys()
+    ):
+        raise ValueError(
+            f"Outdated or missing automatic-grouping metadata in {path}. "
+            "Reinstall pyAmpliCol from the current umami branch, then regenerate "
+            "into a fresh --output without --reuse. Rebuilding the .so alone "
+            "does not update metadata; do not edit channel counts by hand."
+        )
+    return data
diff --git a/pyamplicol/umami_example/requirements.txt b/pyamplicol/umami_example/requirements.txt
new file mode 100644
index 0000000000..0896f6a951
--- /dev/null
+++ b/pyamplicol/umami_example/requirements.txt
@@ -0,0 +1,6 @@
+# Optional demonstration dependencies; not pyAmpliCol runtime requirements.
+madspace==0.2.1
+madnis==1.0.0
+vegas>=6.0
+torch>=2.4
+numpy>=1.26
diff --git a/pyamplicol/umami_example/run.py b/pyamplicol/umami_example/run.py
new file mode 100644
index 0000000000..dd49e09184
--- /dev/null
+++ b/pyamplicol/umami_example/run.py
@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: 0BSD
+"""Generate gg -> ggg artifacts and run the standalone and MadSpace examples."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from _metadata import load_metadata, require_current_exporter
+
+
+def generate(artifact: Path, accuracy: str, expression: str = "g g > g g g") -> None:
+    from pyamplicol import Generator, ModelSource
+    from pyamplicol.config import resolve_config
+
+    config = resolve_config(
+        {
+            "schema_version": 1,
+            "action": "generate",
+            "color": {"accuracy": accuracy},
+            "generation": {
+                "workers": 1,
+                "emit_api_bundle": True,
+                "relation_discovery": {"mode": "off"},
+            },
+            "evaluator": {
+                "backend": "jit",
+                "execution_mode": "recurrence",
+                "optimization": {"cores": 1},
+                "jit": {"optimization_level": 2},
+            },
+        }
+    )
+    Generator(config).generate(expression, artifact, model=ModelSource.built_in_sm())
+
+
+def execute(*command: object) -> None:
+    print("+ " + " ".join(str(part) for part in command), flush=True)
+    subprocess.run([str(part) for part in command], check=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, default=Path(".artifacts/umami-example"))
+    parser.add_argument(
+        "--accuracy", choices=("lc", "full"), nargs="+", default=["lc", "full"]
+    )
+    parser.add_argument(
+        "--reuse", action="store_true", help="reuse previously generated artifacts"
+    )
+    parser.add_argument("--rusticol-config", default="rusticol-config")
+    parser.add_argument(
+        "--n", type=int, default=2048, help="integration points per channel"
+    )
+    parser.add_argument("--training", type=int, nargs="+", default=[256, 512])
+    parser.add_argument("--check-points", type=int, default=20)
+    parser.add_argument("--seed", type=int, default=12345)
+    args = parser.parse_args()
+    if min(args.n, *args.training) < 2 or args.check_points < 1:
+        parser.error(
+            "integration/training counts must be at least two; "
+            "check-points must be positive"
+        )
+    exporter = require_current_exporter()
+    print(f"Python: {sys.executable}\nUMAMI exporter: {exporter}", flush=True)
+    directory = args.output.resolve()
+    accuracies = tuple(dict.fromkeys(args.accuracy))
+    existing = {}
+    for accuracy in accuracies:
+        artifact = directory / accuracy
+        if artifact.exists():
+            if not args.reuse:
+                parser.error(
+                    f"{artifact} exists; choose another output or pass --reuse"
+                )
+            # Reject stale reused metadata before dependencies, builds or profiling.
+            existing[accuracy] = load_metadata(artifact / "API/umami/metadata.json")
+    rusticol_config = shutil.which(args.rusticol_config)
+    if rusticol_config is None:
+        parser.error(
+            "activate pyAmpliCol's environment or provide "
+            "--rusticol-config /absolute/path"
+        )
+    # Check optional integration dependencies before starting generation.
+    for module in ("madspace", "madnis", "vegas", "torch"):
+        __import__(module)
+    directory.mkdir(parents=True, exist_ok=True)
+    scripts = Path(__file__).resolve().parent
+    for accuracy in accuracies:
+        artifact = directory / accuracy
+        metadata = artifact / "API/umami/metadata.json"
+        if accuracy in existing:
+            data = existing[accuracy]
+        else:
+            generate(artifact, accuracy)
+            data = load_metadata(metadata)
+        if data["provider"]["color_accuracy"] != accuracy:
+            raise ValueError(
+                "existing artifact's colour accuracy differs from the request"
+            )
+        build_dir = directory / f"build_{accuracy}"
+        execute(
+            "make",
+            "-C",
+            artifact / "API/umami",
+            f"BUILD_DIR={build_dir}",
+            f"RUSTICOL_CONFIG={rusticol_config}",
+        )
+        library = build_dir / data["provider"]["library"]
+        execute(build_dir / "umami_driver", artifact)
+        execute(
+            sys.executable,
+            scripts / "test_umami.py",
+            artifact,
+            "--library",
+            library,
+            "--n",
+            args.check_points,
+            "--seed",
+            args.seed,
+        )
+        execute(
+            sys.executable,
+            scripts / "test_integrate.py",
+            metadata,
+            "--library",
+            library,
+            "--artifact",
+            artifact,
+            "--no-pdf",
+            "--vegas-only",
+            "--n",
+            args.n,
+            "--training",
+            *args.training,
+            "--seed",
+            args.seed,
+            "--result",
+            directory / f"integration_{accuracy}.json",
+        )
+    print(
+        f"Completed standalone, batched-parity and integration examples in {directory}"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pyamplicol/umami_example/test_grouping.py b/pyamplicol/umami_example/test_grouping.py
new file mode 100644
index 0000000000..e6976f34c4
--- /dev/null
+++ b/pyamplicol/umami_example/test_grouping.py
@@ -0,0 +1,244 @@
+# SPDX-License-Identifier: 0BSD
+"""Compare automatically grouped and explicit-member MadSpace integrals.
+
+This is stochastic validation of structurally established equivalences, not a
+numerical proof of those equivalences. Run explicitly; no optional integration
+packages are added to pyAmpliCol's ordinary test dependencies.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import shutil
+import sys
+from pathlib import Path
+
+import madspace as ms
+import torch
+from _metadata import require_current_exporter
+from run import execute, generate
+from test_integrate import Channel, Config, Cuts, integrate_per_channel, load_channels
+
+FIXTURES = {
+    # Process: (integration channels, physical colour contributions, orbit size).
+    "g g > g g": (3, 6, 2),
+    "g g > g g g": (4, 24, 6),
+}
+
+
+def check_identical_grouping(data, process):
+    """Require the automatic identical-particle quotient for a known fixture."""
+    channel_count, physical_count, orbit_size = FIXTURES[process]
+    entries = [entry for ch in data["channels"] for entry in ch["processes"]]
+    if (
+        len(data["channels"]) != channel_count
+        or len(entries) != channel_count
+        or data["grouping"]["exported_contributions"] != channel_count
+        or data["grouping"]["physical_contributions"] != physical_count
+    ):
+        raise AssertionError(
+            f"{process} must group {physical_count} physical contributions into "
+            f"{channel_count} automatic integration channels"
+        )
+    factors = []
+    for entry in entries:
+        terms = entry["matrix_elements"]
+        if (
+            len(terms) != 1
+            or float(terms[0]["factor"]) != orbit_size
+            or len(entry["members"]) != orbit_size
+        ):
+            raise AssertionError(
+                f"each {process} representative must have {orbit_size} physical "
+                f"members and explicit integration factor {orbit_size}"
+            )
+        factors.append(float(terms[0]["factor"]))
+    return factors
+
+
+def physical_member_channels(data):
+    """Expand physical weights and momentum maps, never integration factors.
+
+    This is a reference integrand for the acceptance check, not an export option.
+    The provider still uses its certified representative computations.
+    """
+    channels = []
+    for ci, channel in enumerate(data["channels"]):
+        for fi, entry in enumerate(channel["processes"]):
+            for member in entry["members"]:
+                # p_rep[representative map] = p_physical[member map].
+                permutation = [0] * data["provider"]["particle_count"]
+                for rep_slot, physical_slot in zip(
+                    entry["runtime"]["permutation"],
+                    member["runtime"]["permutation"],
+                    strict=True,
+                ):
+                    permutation[rep_slot] = physical_slot
+                pdgs = member["pdgs"]
+                channels.append(
+                    Channel(
+                        index=len(channels),
+                        color_order=[
+                            permutation[slot] for slot in channel["phasespace_order"]
+                        ],
+                        init_states=[tuple(pdgs[:2])],
+                        pdg_final=list(pdgs[2:]),
+                        masses=list(data["provider"]["masses"]),
+                        processes=[
+                            [
+                                (
+                                    float(member["factor"]),
+                                    pdgs[0],
+                                    pdgs[1],
+                                    tuple(pdgs[2:]),
+                                )
+                            ]
+                        ],
+                        selector=(ci, fi),
+                        momentum_permutation=permutation,
+                    )
+                )
+    return channels
+
+
+def check_agreement(results, *, sigma=6.0, maximum_relative_error=0.05):
+    """Compare independent estimates, retaining their complete uncertainties."""
+    for result in results.values():
+        value, error = result["integral"], result["uncertainty"]
+        if not (
+            math.isfinite(value) and value > 0 and math.isfinite(error) and error > 0
+        ):
+            raise AssertionError("expected a positive finite integral and uncertainty")
+        if error > maximum_relative_error * value:
+            raise AssertionError(
+                "grouping comparison is inconclusive: increase --n to reduce "
+                "the integration uncertainty"
+            )
+    reference = results["physical_members"]
+    result = results["grouped"]
+    difference = abs(result["integral"] - reference["integral"])
+    uncertainty = math.hypot(result["uncertainty"], reference["uncertainty"])
+    rounding = 1e-10 * max(result["integral"], reference["integral"])
+    if difference > sigma * uncertainty + rounding:
+        raise AssertionError(
+            "grouped and physical-member integrals differ by "
+            f"{difference / uncertainty:.2f} combined standard errors (limit {sigma:g})"
+        )
+    return {
+        "difference": difference,
+        "combined_error": uncertainty,
+        "standard_errors": difference / uncertainty,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--output", type=Path, default=Path(".artifacts/umami-grouping")
+    )
+    parser.add_argument(
+        "--process",
+        choices=tuple(FIXTURES),
+        default="g g > g g",
+        help="identical-gluon acceptance fixture (default: %(default)s)",
+    )
+    parser.add_argument("--reuse", action="store_true")
+    parser.add_argument("--rusticol-config", default="rusticol-config")
+    parser.add_argument("--n", type=int, default=4096)
+    parser.add_argument("--training", type=int, nargs="+", default=[256, 512])
+    parser.add_argument("--seed", type=int, default=24680)
+    args = parser.parse_args()
+    if min(args.n, *args.training) < 2:
+        parser.error("integration and training counts must be at least two")
+    exporter = require_current_exporter()
+    print(f"Python: {sys.executable}\nUMAMI exporter: {exporter}", flush=True)
+    config_binary = shutil.which(args.rusticol_config)
+    if config_binary is None:
+        parser.error("activate the pyAmpliCol environment or pass --rusticol-config")
+    output = args.output.resolve()
+    output.mkdir(parents=True, exist_ok=True)
+    torch.set_num_threads(1)
+    cfg = Config(sqrts=1000.0, cuts=Cuts(pt_min=100.0, eta_max=6.0, dr_min=0.4))
+    artifact = output / "lc"
+    if artifact.exists():
+        if not args.reuse:
+            parser.error(f"{artifact} already exists; use --reuse or another output")
+    else:
+        generate(artifact, "lc", args.process)
+    metadata = artifact / "API/umami/metadata.json"
+    grouped_channels, n_out, data = load_channels(metadata)
+    if data["provider"]["color_accuracy"] != "lc":
+        raise AssertionError("existing artifact is not a leading-colour provider")
+    integration_factors = check_identical_grouping(data, args.process)
+    member_channels = physical_member_channels(data)
+    if len(member_channels) != data["grouping"]["physical_contributions"]:
+        raise AssertionError("reference must contain every physical contribution once")
+    build = output / "build_lc"
+    execute(
+        "make",
+        "-C",
+        artifact / "API/umami",
+        f"BUILD_DIR={build}",
+        f"RUSTICOL_CONFIG={config_binary}",
+    )
+    library = build / data["provider"]["library"]
+    execute(
+        sys.executable,
+        Path(__file__).with_name("test_umami.py"),
+        artifact,
+        "--library",
+        library,
+        "--n",
+        4,
+        "--seed",
+        args.seed,
+    )
+    results = {}
+    for index, (label, channels) in enumerate(
+        (("grouped", grouped_channels), ("physical_members", member_channels))
+    ):
+        # Distinct fixed seeds make the quadrature combination of errors valid.
+        seed = args.seed + index * 100_003
+        value, error, per_channel = integrate_per_channel(
+            channels,
+            n_out,
+            cfg,
+            ms.Context(1),
+            library,
+            artifact,
+            n_points=args.n,
+            seed=seed,
+            training_points=args.training,
+        )
+        results[label] = {
+            "integral": value,
+            "uncertainty": error,
+            "unit": "pb",
+            "seed": seed,
+            "points_per_channel": args.n,
+            "per_channel": per_channel,
+            "integration_channels": len(channels),
+        }
+        print(f"{label}: {value:.8g} +/- {error:.3g} pb", flush=True)
+    summary = {
+        "process": args.process,
+        "cuts": vars(cfg.cuts),
+        "grouping": data["grouping"],
+        "integration_factors": integration_factors,
+        "results": results,
+    }
+    report = output / "grouping_comparison.json"
+    # Retain estimates even if the statistical acceptance fails.
+    report.write_text(json.dumps(summary, indent=2, allow_nan=False) + "\n")
+    summary["comparison"] = check_agreement(results)
+    summary["accepted"] = True
+    report.write_text(json.dumps(summary, indent=2, allow_nan=False) + "\n")
+    print(
+        f"Grouped/member integrals agree within six combined standard errors: {report}"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pyamplicol/umami_example/test_integrate.py b/pyamplicol/umami_example/test_integrate.py
new file mode 100644
index 0000000000..31b8705f4b
--- /dev/null
+++ b/pyamplicol/umami_example/test_integrate.py
@@ -0,0 +1,501 @@
+"""Integrate a generated UMAMI provider with MadSpace and VEGAS/MadNIS.
+
+Adapted from R. Frederix and T. Vitos's AmpliCol madspace_interface example:
+https://github.com/rikkert-frederix/AmpliCol/blob/madspace_interface/test_integrate.py
+Its seven-section structure, channel integration and optional MadNIS/PDF workflow
+are retained. README.md describes the pyAmpliCol and current-MadSpace adaptations.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import madspace as ms
+import numpy as np
+import torch
+import torch.nn as nn
+from _metadata import grouping_summary, load_metadata
+
+
+# =============================================================================
+# 1. Config / cuts
+# =============================================================================
+@dataclass
+class Cuts:
+    pt_min: float = 30.0
+    eta_max: float = 6.0
+    dr_min: float = 0.4
+    # None means all outgoing species; no built-in particle classification.
+    pdgs: list[int] | None = None
+
+
+@dataclass
+class Config:
+    sqrts: float = 1000.0
+    pdfset: str = "NNPDF23_nlo_as_0119_qed"
+    pdf_dir: Path | None = None
+    scale_ref: float | None = None
+    t_invariant_power: float = 0.3
+    cuts: Cuts = field(default_factory=Cuts)
+
+
+# =============================================================================
+# 2. Channel loader (generated converted metadata)
+# =============================================================================
+@dataclass
+class Channel:
+    index: int
+    color_order: list[int]
+    init_states: list[tuple[int, int]]
+    pdg_final: list[int]
+    masses: list[float]
+    processes: list[list[tuple[float, int, int, tuple]]] = field(default_factory=list)
+    # Explicit-member validation can evaluate a mapped exported representative.
+    selector: tuple[int, int] | None = None
+    momentum_permutation: list[int] | None = None
+
+
+def load_channels(path, provider=None):
+    data = load_metadata(path, provider)
+    if any(mass != 0.0 for mass in data["provider"]["masses"][:2]):
+        raise ValueError(
+            "this MadSpace scattering example uses massless-beam flux; "
+            "massive incoming particles require a different flux prescription"
+        )
+    channels = []
+    for ci, ch in enumerate(data["channels"]):
+        inits, finals, procs = set(), [], []
+        for proc in ch["processes"]:
+            partners = proc.get("multichannels", [ci])
+            if partners != [ci]:
+                raise ValueError(
+                    "this example requires one nonduplicated map per contribution"
+                )
+            cfgs = []
+            for me in proc["matrix_elements"]:
+                pdg = list(data["pdg_ids"][me["pdg_ids"]])
+                factor = float(me["factor"])
+                cfgs.append((factor, pdg[0], pdg[1], tuple(pdg[2:])))
+                inits.add((pdg[0], pdg[1]))
+                if not finals:
+                    finals = pdg[2:]
+            procs.append(cfgs)
+        channels.append(
+            Channel(
+                ci,
+                list(ch["phasespace_order"]),
+                sorted(inits),
+                finals,
+                list(data["provider"]["masses"]),
+                procs,
+            )
+        )
+    return channels, data["provider"]["particle_count"] - 2, data
+
+
+# =============================================================================
+# 3. Cuts -> ms.Cuts (applied INSIDE PhaseSpaceMapping)
+# =============================================================================
+def build_ms_cuts(cfg: Config, ch: Channel):
+    c = cfg.cuts
+    if c.pdgs is not None:
+        raise ValueError("automatic UMAMI grouping requires flavour-blind cuts")
+    a, b = ch.init_states[0]
+    pids = [a, b, *ch.pdg_final]
+    selected = sorted(set(ch.pdg_final))
+    obs_type = ms.Observable
+    items = []
+
+    def add(obs, **kwargs):
+        items.append(ms.CutItem(obs_type(pids, obs, [selected]), **kwargs))
+
+    if c.pt_min > 0:
+        add(obs_type.obs_pt, min=c.pt_min)
+    if c.eta_max > 0:
+        add(obs_type.obs_eta_abs, max=c.eta_max)
+    if c.dr_min > 0:
+        add(obs_type.obs_delta_r, min=c.dr_min)
+    return ms.Cuts(items) if items else None
+
+
+# =============================================================================
+# 4. PDFs & alpha_s + matrix element (MadSpace primitives, train.py style)
+# =============================================================================
+def load_pdf_and_coupling(cfg: Config, ctx):
+    if cfg.pdf_dir is None:
+        import lhapdf
+
+        lhapdf.setVerbosity(0)
+        candidates = [Path(directory) / cfg.pdfset for directory in lhapdf.paths()]
+        base = next((path for path in candidates if path.is_dir()), None)
+        if base is None:
+            raise FileNotFoundError(f"PDF set {cfg.pdfset!r} is not installed")
+    else:
+        base = cfg.pdf_dir
+    pdf_grid = ms.PdfGrid(str(base / f"{cfg.pdfset}_0000.dat"))
+    pdf_grid.initialize_globals(ctx)
+    ag = ms.AlphaSGrid(str(base / f"{cfg.pdfset}.info"))
+    run_coupl = ms.RunningCoupling(ag)
+    ag.initialize_globals(ctx)
+    return pdf_grid, run_coupl
+
+
+def load_matrix_element(ctx, library, artifact, use_running_alpha_s=False):
+    api = ctx.load_matrix_element(
+        str(Path(library).resolve()), str(Path(artifact).resolve())
+    )
+    inputs = [ms.MatrixElement.momenta_in]
+    # No-PDF default deliberately omits alpha_s: UMAMI uses artifact defaults.
+    if use_running_alpha_s:
+        inputs.append(ms.MatrixElement.alpha_s_in)
+    inputs += [
+        ms.MatrixElement.flavor_in,
+        ms.MatrixElement.channel_in,
+        ms.MatrixElement.random_helicity_in,
+    ]
+    # Avoid the convenience overload's unconditional diagram-count query.
+    # No diagram output is requested or represented by this provider.
+    return ms.MatrixElement(
+        api.index(),
+        api.particle_count(),
+        inputs,
+        [ms.MatrixElement.matrix_element_out, ms.MatrixElement.helicity_index_out],
+        diagram_count=0,
+    )
+
+
+# =============================================================================
+# 5. One color-ordered channel: randoms -> weight
+# =============================================================================
+class ColorOrderedChannel:
+    """One independent additive contribution, with an optional PDF convolution."""
+
+    def __init__(
+        self,
+        ch: Channel,
+        n_out,
+        cfg: Config,
+        ctx,
+        me_func=None,
+        run_coupl=None,
+        pdf_grid=None,
+    ):
+        self.ch, self.cfg, self.ctx = ch, cfg, ctx
+        self.psmap = ms.PhaseSpaceMapping(
+            ch.masses,
+            cfg.sqrts,
+            leptonic=pdf_grid is None,
+            invariant_power=cfg.t_invariant_power,
+            mode=ms.PhaseSpaceMapping.color_ordered,
+            color_order=ch.color_order,
+            cuts=build_ms_cuts(cfg, ch),
+        )
+        self.random_dim = self.psmap.random_dim()
+        self.discrete_dim = self.psmap.discrete_dim()
+        self.dim = self.random_dim
+        self.ps_runtime = ms.FunctionRuntime(self.psmap.forward_function(), ctx)
+        self.cfg_proc, self.cfg_factor, pid_options = [], [], []
+        for iproc, cfgs in enumerate(ch.processes):
+            for fac, a, b, final in cfgs:
+                self.cfg_proc.append(iproc if ch.selector is None else ch.selector[1])
+                self.cfg_factor.append(fac)
+                pid_options.append([a, b, *final])
+        self.n_config = len(pid_options)
+        self.dcs = None
+        if me_func is not None:
+            escale = None
+            if run_coupl is not None:
+                escale = ms.EnergyScale(
+                    2 + n_out,
+                    ms.EnergyScale.half_transverse_mass
+                    if cfg.scale_ref is None
+                    else float(cfg.scale_ref),
+                )
+            # UMAMI already supplies spin/colour averaging and identical-particle
+            # normalization; DCS adds only flux, optional PDFs and the pb conversion.
+            self.dcs = ms.DifferentialCrossSection(
+                me_func,
+                cfg.sqrts,
+                run_coupl,
+                escale,
+                pid_options,
+                pdf_grid,
+                pdf_grid,
+                True,
+                False,
+            )
+            self.dcs_runtime = ms.FunctionRuntime(self.dcs.function(), ctx)
+
+    def weight(self, r, disc=None):
+        """Keep upstream's ownership of discrete phase-space branch weights."""
+        dev, dt = r.device, r.dtype
+        mult = 1.0
+        if self.discrete_dim:
+            if disc is None:
+                disc = torch.randint(
+                    0, 2, (r.shape[0], self.discrete_dim), device=dev, dtype=torch.int32
+                )
+                mult = float(2**self.discrete_dim)
+            else:
+                disc = disc.to(torch.int32)
+            inputs = [r, disc]
+        else:
+            inputs = [r]
+        p, x1, x2, det = self.ps_runtime(*inputs)
+        good = torch.isfinite(det) & (det > 0)
+        out = torch.zeros(r.shape[0], dtype=det.dtype, device=dev)
+        if self.dcs is None:
+            return torch.where(good, det * mult, out)
+        if not bool(good.any()):
+            return out
+        # Fixed partonic energy returns singleton x1/x2; broadcast before masking.
+        x1, x2 = x1.expand(r.shape[0]), x2.expand(r.shape[0])
+        pg, x1g, x2g, detg = p[good], x1[good], x2[good], det[good]
+        ng = len(detg)
+        if self.ch.momentum_permutation is not None:
+            pg = pg[:, self.ch.momentum_permutation, :]
+        selector_channel = (
+            self.ch.index if self.ch.selector is None else self.ch.selector[0]
+        )
+        chan_id = torch.full((ng,), selector_channel, device=dev, dtype=torch.int32)
+        total = torch.zeros(ng, dtype=detg.dtype, device=dev)
+        for c in range(self.n_config):
+            flavor = torch.full((ng,), self.cfg_proc[c], device=dev, dtype=torch.int32)
+            pdf_id = torch.full((ng,), c, device=dev, dtype=torch.int32)
+            rnd_hel = torch.rand(ng, device=dev, dtype=dt)
+            res = self.dcs_runtime(
+                pg.contiguous(),
+                flavor,
+                chan_id,
+                rnd_hel,
+                x1g,
+                x2g,
+                pdf_id,
+            )
+            dxs = res[0] if isinstance(res, (tuple, list)) else res
+            if not bool(torch.isfinite(dxs).all()):
+                raise FloatingPointError("nonfinite UMAMI differential cross section")
+            total = total + dxs * self.cfg_factor[c]
+        out[good] = total * detg * mult
+        return out
+
+
+# =============================================================================
+# 6. Per-ordering integration: one independent integrator per colour ordering
+# =============================================================================
+def integrate_per_channel(
+    channels,
+    n_out,
+    cfg,
+    ctx,
+    me_library=None,
+    param_card="",
+    use_pdf=False,
+    batch_size=256,
+    epochs=200,
+    n_points=2048,
+    seed=0,
+    vegas_only=True,
+    learn_discrete=False,
+    training_points=(256, 512),
+):
+    from madnis.integrator import (
+        Integrand,
+        Integrator,
+        VegasPreTraining,
+        stratified_variance_softclip,
+    )
+
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(seed)
+    me_func = (
+        None
+        if me_library is None
+        else load_matrix_element(
+            ctx, me_library, param_card, use_running_alpha_s=use_pdf
+        )
+    )
+    pdf_grid = run_coupl = None
+    if use_pdf and me_func is not None:
+        pdf_grid, run_coupl = load_pdf_and_coupling(cfg, ctx)
+
+    results = []
+    total, var = 0.0, 0.0
+    for c in channels:
+        ch = ColorOrderedChannel(c, n_out, cfg, ctx, me_func, run_coupl, pdf_grid)
+        dd = ch.discrete_dim
+        if learn_discrete and dd:
+
+            def fn(x, ch=ch, nd=dd):
+                return ch.weight(
+                    x[:, nd:].contiguous().double(), disc=x[:, :nd]
+                ).double()
+
+            integrand = Integrand(
+                fn, input_dim=ch.random_dim + dd, discrete_dims=[2] * dd
+            )
+        else:
+
+            def fn(x, ch=ch):
+                return ch.weight(x.double()).double()
+
+            integrand = Integrand(fn, input_dim=ch.dim)
+
+        def vegas_callback(status, channel_index=c.index):
+            print(
+                f"[VEGAS channel {channel_index}] Iteration {status.step + 1}: "
+                f"loss={status.variance:.6f}",
+                flush=True,
+            )
+
+        def callback(status):
+            if (status.step + 1) % max(1, epochs // 10) == 0:
+                print(
+                    f"[MadNIS] Iteration {status.step + 1:4d}: loss={status.loss:.6f}"
+                )
+
+        flow_dict = dict(layers=3, units=64, bins=10, activation=nn.LeakyReLU)
+        integrator = Integrator(
+            integrand,
+            flow_kwargs=flow_dict,
+            batch_size=batch_size,
+            dtype=torch.float64,
+            optimizer=lambda p: torch.optim.Adam(p, lr=1e-3),
+            scheduler=lambda o: torch.optim.lr_scheduler.CosineAnnealingLR(
+                o, T_max=epochs
+            ),
+            loss=stratified_variance_softclip,
+        )
+        vegas = VegasPreTraining(integrator, bins=16, damping=0.7)
+        # MadNIS gives VEGAS its own NumPy generator, independent of Torch's RNG.
+        vegas.rng = np.random.default_rng(np.random.SeedSequence([seed, c.index]))
+        vegas.train(list(training_points), callback=vegas_callback)
+        if vegas_only:
+            Ii, ei = vegas.integrate(n_points)
+        else:
+            vegas.initialize_integrator()
+            integrator.train(epochs, callback=callback)
+            Ii, ei = integrator.integrate(n_points)
+        if not (math.isfinite(Ii) and math.isfinite(ei) and ei >= 0):
+            raise FloatingPointError(
+                "integration returned invalid estimate/uncertainty"
+            )
+        rsd = (ei / Ii) * math.sqrt(n_points) if Ii else None
+        results.append((c.index, c.color_order, Ii, ei, rsd))
+        total += Ii
+        var += ei * ei
+        rsd_text = f"{rsd:.3f}" if rsd is not None else "undefined (zero integral)"
+        print(
+            f"[channel {c.index}] color_order={c.color_order}: "
+            f"{Ii:.6e} +/- {ei:.2e}  RSD={rsd_text}",
+            flush=True,
+        )
+    return total, math.sqrt(var), results
+
+
+# =============================================================================
+# 7. CLI
+# =============================================================================
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("json", type=Path)
+    ap.add_argument("--library", type=Path, required=True)
+    ap.add_argument(
+        "--param-card", "--artifact", dest="artifact", type=Path, required=True
+    )
+    ap.add_argument("--provider")
+    ap.add_argument(
+        "--pdf", action="store_true", help="optional hadronic run; needs PDF data"
+    )
+    ap.add_argument("--no-pdf", dest="pdf", action="store_false")
+    ap.add_argument("--pdfset", default=Config.pdfset)
+    ap.add_argument("--pdf-dir", type=Path)
+    ap.add_argument("--sqrts", type=float, default=1000.0)
+    ap.add_argument("--scale", type=float)
+    ap.add_argument("--seed", type=int, default=12345)
+    ap.add_argument(
+        "--n", type=int, default=2048, help="integration points per contribution"
+    )
+    ap.add_argument("--training", type=int, nargs="+", default=[256, 512])
+    ap.add_argument("--batch-size", type=int, default=256)
+    ap.add_argument("--epochs", type=int, default=200)
+    ap.add_argument(
+        "--madnis", action="store_true", help="train a neural flow after VEGAS"
+    )
+    ap.add_argument("--vegas-only", dest="madnis", action="store_false")
+    ap.add_argument("--learn-discrete", action="store_true")
+    ap.add_argument("--pt-min", type=float, default=30.0)
+    ap.add_argument("--eta-max", type=float, default=6.0)
+    ap.add_argument("--dr-min", type=float, default=0.4)
+    ap.add_argument(
+        "--selftest", action="store_true", help="phase-space volume, without ME or PDFs"
+    )
+    ap.add_argument("--result", type=Path, help="optional machine-readable result")
+    args = ap.parse_args()
+    if min(args.n, args.batch_size, args.epochs, *args.training) < 2:
+        ap.error("sample counts, batch size and epochs must be at least two")
+    channels, n_out, data = load_channels(args.json, args.provider)
+    if args.pdf and data["provider"]["alpha_s_parameter"] is None:
+        ap.error("this provider has no unambiguous running-alpha_s input")
+    cfg = Config(
+        sqrts=args.sqrts,
+        pdfset=args.pdfset,
+        pdf_dir=args.pdf_dir,
+        scale_ref=args.scale,
+        cuts=Cuts(args.pt_min, args.eta_max, args.dr_min),
+    )
+    print(
+        f"Metadata: {args.json.resolve()} (provider {data['provider']['id']})\n"
+        f"Loaded {grouping_summary(data)}, n_out={n_out}; "
+        f"{data['provider']['color_accuracy']} colour",
+        flush=True,
+    )
+    ctx = ms.Context(1)
+    torch.set_num_threads(1)
+    t0 = time.time()
+    sigma, err, per_channel = integrate_per_channel(
+        channels,
+        n_out,
+        cfg,
+        ctx,
+        None if args.selftest else args.library,
+        args.artifact,
+        args.pdf and not args.selftest,
+        args.batch_size,
+        args.epochs,
+        args.n,
+        args.seed,
+        not args.madnis,
+        args.learn_discrete,
+        args.training,
+    )
+    if not args.selftest and sigma <= 0:
+        raise AssertionError("the demonstration must produce a positive cross section")
+    result = dict(
+        integral=sigma,
+        uncertainty=err,
+        unit="" if args.selftest else "pb",
+        points_per_channel=args.n,
+        channels=len(channels),
+        elapsed_seconds=time.time() - t0,
+        per_channel=per_channel,
+        provider=data["provider"]["id"],
+        seed=args.seed,
+    )
+    print(
+        f"\n{'MadNIS' if args.madnis else 'VEGAS'} integral: "
+        f"{sigma:.6e} +/- {err:.2e} {result['unit']} "
+        f"({result['elapsed_seconds']:.1f}s)"
+    )
+    if args.result:
+        args.result.parent.mkdir(parents=True, exist_ok=True)
+        args.result.write_text(json.dumps(result, indent=2, allow_nan=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pyamplicol/umami_example/test_umami.py b/pyamplicol/umami_example/test_umami.py
new file mode 100644
index 0000000000..ae9393ac63
--- /dev/null
+++ b/pyamplicol/umami_example/test_umami.py
@@ -0,0 +1,212 @@
+"""Batched MadSpace loading example, with native pyAmpliCol parity checks.
+
+Adapted from R. Frederix and T. Vitos's AmpliCol madspace_interface example:
+https://github.com/rikkert-frederix/AmpliCol/blob/madspace_interface/test_umami.py
+See README.md for the small, necessary changes to that workflow.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import madspace as ms
+import numpy as np
+from _metadata import load_metadata
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("artifact", type=Path)
+    ap.add_argument("--library", type=Path, required=True)
+    ap.add_argument("--metadata", type=Path)
+    ap.add_argument("--provider")
+    ap.add_argument("--n", type=int, default=100)
+    ap.add_argument("--sqrts", type=float, default=1000.0)
+    ap.add_argument("--seed", type=int, default=12345)
+    args = ap.parse_args()
+    if args.n < 1:
+        ap.error("--n must be positive")
+    artifact = args.artifact.resolve()
+    data = load_metadata(
+        args.metadata or artifact / "API/umami/metadata.json", args.provider
+    )
+
+    # Same load -> phase space -> batched MatrixElement sequence as upstream.
+    np.random.seed(args.seed)
+    ctx = ms.Context(1)
+    me = ctx.load_matrix_element(str(args.library.resolve()), str(artifact))
+    n = args.n
+    psmap = ms.PhaseSpaceMapping(data["provider"]["masses"], args.sqrts, leptonic=True)
+    # Bind the explicit context: v0.2.1 convenience calls use the global context.
+    ps_runtime = ms.FunctionRuntime(psmap.forward_function(), ctx)
+    p_ext, _x1, _x2, det = ps_runtime(np.random.rand(n, psmap.random_dim()))
+    if not np.all(np.isfinite(det) & (det > 0)):
+        raise AssertionError("phase-space mapping returned a degenerate point")
+    inputs = [ms.MatrixElement.momenta_in]
+    alpha_name = data["provider"]["alpha_s_parameter"]
+    if alpha_name is not None:
+        inputs.append(ms.MatrixElement.alpha_s_in)
+    inputs += [
+        ms.MatrixElement.flavor_in,
+        ms.MatrixElement.channel_in,
+        ms.MatrixElement.random_helicity_in,
+    ]
+    # The convenience overload queries diagram_count even without diagram
+    # outputs. This recursion provider intentionally has no diagram metadata.
+    func = ms.MatrixElement(
+        me.index(),
+        me.particle_count(),
+        inputs,
+        [ms.MatrixElement.matrix_element_out, ms.MatrixElement.helicity_index_out],
+        diagram_count=0,
+    )
+    evaluator = ms.FunctionRuntime(func.function(), ctx)
+
+    from pyamplicol import Runtime
+
+    runtimes = {}
+    physical_sums = {}
+    generated = {process["id"] for process in data["runtime_processes"]}
+    checked = 0
+    maximum_error = 0.0
+    for channel_index, channel in enumerate(data["channels"]):
+        for flavor_index, process in enumerate(channel["processes"]):
+            spec = process["runtime"]
+            process_id = spec["process_id"]
+            if process_id not in runtimes:
+                runtimes[process_id] = Runtime.load(artifact, process=process_id)
+            runtime = runtimes[process_id]
+            buffers = [p_ext]
+            alpha_s = None
+            if alpha_name is not None:
+                default = next(
+                    p.default_real
+                    for p in runtime.physics.model_parameters
+                    if p.name == alpha_name
+                )
+                # Exercise actual dependent-coupling updates, not just a fixed alpha_s.
+                alpha_s = default * np.linspace(0.9, 1.1, n)
+                buffers.append(alpha_s)
+            flavors = np.full(n, flavor_index, dtype=np.int32)
+            channels = np.full(n, channel_index, dtype=np.int32)
+            rnd_hel = np.random.rand(n)
+            amp2, hel = evaluator(*buffers, flavors, channels, rnd_hel)
+
+            native = []
+            color_id = spec["color_id"]
+            for i, point in enumerate(p_ext):
+                if alpha_s is not None:
+                    runtime.set_model_parameter(alpha_name, float(alpha_s[i]))
+                mapped = point[spec["permutation"]]
+                value = runtime.evaluate(
+                    (mapped,), color_flows=None if color_id is None else (color_id,)
+                )[0]
+                native.append(float(complex(value).real) * float(spec["factor"]))
+            native = np.asarray(native)
+            np.testing.assert_allclose(amp2, native, rtol=2e-10, atol=1e-25)
+            if not np.all(np.isfinite(amp2)) or not np.all(amp2 >= 0):
+                raise AssertionError("invalid squared matrix element")
+            runtime_meta = data["runtime_processes"][spec["process_index"]]
+            helicity_count = len(runtime_meta["helicity_ids"])
+            if not np.all((hel >= 0) & (hel < helicity_count)):
+                raise AssertionError("sampled helicity does not index process metadata")
+            scale = np.maximum(np.abs(native), np.finfo(float).tiny)
+            maximum_error = max(
+                maximum_error, float(np.max(np.abs(amp2 - native) / scale))
+            )
+            checked += n
+            for member in process["members"]:
+                if member["process_id"] not in generated:
+                    # A --flavor-blind member has no native runtime of its own:
+                    # its equality with the representative is assumed.
+                    continue
+                # Automatic grouping includes identical-particle integration orbits.
+                # Compose the maps to evaluate each member at the original
+                # labelled point, not at the representative's labelled point.
+                mapped_points = np.empty_like(p_ext)
+                mapped_points[:, spec["permutation"], :] = p_ext[
+                    :, member["runtime"]["permutation"], :
+                ]
+                member_buffers = [mapped_points]
+                if alpha_s is not None:
+                    member_buffers.append(alpha_s)
+                member_amp2, _member_hel = evaluator(
+                    *member_buffers, flavors, channels, rnd_hel
+                )
+                original_id = member["process_id"]
+                if original_id not in runtimes:
+                    runtimes[original_id] = Runtime.load(artifact, process=original_id)
+                physical_runtime = runtimes[original_id]
+                physical_color = member["color_id"]
+                selected = None if physical_color is None else (physical_color,)
+                physical_native = []
+                for i, point in enumerate(p_ext):
+                    if alpha_s is not None:
+                        physical_runtime.set_model_parameter(
+                            alpha_name, float(alpha_s[i])
+                        )
+                    value = physical_runtime.evaluate((point,), color_flows=selected)[0]
+                    physical_native.append(float(complex(value).real))
+                physical_native = np.asarray(physical_native)
+                np.testing.assert_allclose(
+                    member_amp2, physical_native, rtol=2e-10, atol=1e-25
+                )
+                if not np.all(np.isfinite(member_amp2)) or not np.all(member_amp2 >= 0):
+                    raise AssertionError("invalid physical-member matrix element")
+                scale = np.maximum(np.abs(physical_native), np.finfo(float).tiny)
+                maximum_error = max(
+                    maximum_error,
+                    float(np.max(np.abs(member_amp2 - physical_native) / scale)),
+                )
+                checked += n
+                if data["provider"]["color_accuracy"] == "lc":
+                    total, colors = physical_sums.setdefault(
+                        original_id, (np.zeros(n), [])
+                    )
+                    # Only the physical member weight belongs in a pointwise
+                    # sum; matrix_elements factors are integration weights.
+                    total += member_amp2 * float(member["factor"])
+                    colors.append(physical_color)
+    reconstructed = 0
+    for process_id, (total, colors) in physical_sums.items():
+        if process_id not in runtimes:
+            runtimes[process_id] = Runtime.load(artifact, process=process_id)
+        runtime = runtimes[process_id]
+        if runtime.physics.color_coverage != "complete":
+            continue
+        if len(colors) != len(set(colors)) or set(colors) != set(
+            runtime.physics.color_flow_ids
+        ):
+            raise AssertionError(
+                "UMAMI contributions do not cover physical LC flows once"
+            )
+        default = (
+            None
+            if alpha_name is None
+            else next(
+                p.default_real
+                for p in runtime.physics.model_parameters
+                if p.name == alpha_name
+            )
+        )
+        native_total = []
+        alpha_factors = np.linspace(0.9, 1.1, n)
+        for i, point in enumerate(p_ext):
+            if default is not None:
+                runtime.set_model_parameter(
+                    alpha_name, default * float(alpha_factors[i])
+                )
+            native_total.append(float(complex(runtime.evaluate((point,))[0]).real))
+        np.testing.assert_allclose(total, native_total, rtol=2e-10, atol=1e-25)
+        reconstructed += n
+    print(
+        f"MadSpace/UMAMI: {checked} values match native pyAmpliCol; "
+        f"max relative difference {maximum_error:.3g}"
+    )
+    if reconstructed:
+        print(f"LC channel sums reconstruct {reconstructed} native total values")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/unit_tests/interface/test_mg7_launch.py b/tests/unit_tests/interface/test_mg7_launch.py
index 114c79f4e2..eebee3c997 100644
--- a/tests/unit_tests/interface/test_mg7_launch.py
+++ b/tests/unit_tests/interface/test_mg7_launch.py
@@ -467,6 +467,12 @@ def test_an_explicit_job_count_is_left_alone(self):
                                   or a.startswith('--jobs')]), 1, args)
             self.assertNotIn('5', args)
 
+    def test_pyamplicol_runs_its_own_installer(self):
+        self.cmd.do_set('nb_core 3 --no_save')
+        args = self.installer_args('pyamplicol --source -y')
+        self.assertTrue(args[1].endswith(os.path.join('pyamplicol', 'install.py')))
+        self.assertEqual(args[2:], ['--source', '-y', '-j', '3'])
+
 
 @unittest.skipUnless(mg7_bootstrap.madspace_is_installed(),
                      'madspace is not installed')
diff --git a/tests/unit_tests/various/test_pyamplicol_install.py b/tests/unit_tests/various/test_pyamplicol_install.py
new file mode 100644
index 0000000000..a23d0a0db5
--- /dev/null
+++ b/tests/unit_tests/various/test_pyamplicol_install.py
@@ -0,0 +1,198 @@
+################################################################################
+#
+# Copyright (c) 2009 The MadGraph7 Development team and Contributors
+#
+# This file is a part of the MadGraph7 project, an application which
+# automatically generates Feynman diagrams and matrix elements for arbitrary
+# high-energy processes in the Standard Model and beyond.
+#
+# It is subject to the MadGraph7 license which should accompany this
+# distribution.
+#
+# For more information, visit madgraph.phys.ucl.ac.be and amcatnlo.web.cern.ch
+#
+################################################################################
+"""Test pyamplicol/install.py, its version sync and its source hash.
+
+Nothing here builds anything: main() runs with pip, rustup and the build
+stubbed out.
+"""
+
+import contextlib
+import importlib.util
+import io
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+MG_ROOT = Path(__file__).resolve().parents[3]
+PYAMPLICOL = MG_ROOT / 'pyamplicol'
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+install = load('pyamplicol_install', PYAMPLICOL / 'install.py')
+source_hash = load('pyamplicol_source_hash', PYAMPLICOL / 'source_hash.py')
+
+
+class TestReleaseWheel(unittest.TestCase):
+    """--bin is only offered for a pyamplicol wheel built for this platform."""
+
+    def available(self, wheels, system, machine):
+        info = {'version': '0.2.1', 'wheels': ','.join(wheels)}
+        with mock.patch.object(install, '_release_info', return_value=info), \
+                mock.patch('platform.system', return_value=system), \
+                mock.patch('platform.machine', return_value=machine):
+            return install._release_wheel_available()
+
+    WHEELS = [
+        'madspace-0.2.1-cp312-cp312-manylinux_2_28_x86_64.whl',
+        'pyamplicol-0.2.1-cp311-abi3-macosx_11_0_arm64.whl',
+        'pyamplicol-0.2.1-cp311-abi3-macosx_11_0_x86_64.whl',
+        'pyamplicol-0.2.1-cp311-abi3-manylinux_2_28_x86_64.whl',
+    ]
+
+    def test_abi3_wheels_match_any_supported_platform(self):
+        self.assertTrue(self.available(self.WHEELS, 'Linux', 'x86_64'))
+        self.assertTrue(self.available(self.WHEELS, 'Darwin', 'arm64'))
+        self.assertTrue(self.available(self.WHEELS, 'Darwin', 'x86_64'))
+
+    def test_no_wheel_for_linux_aarch64(self):
+        self.assertFalse(self.available(self.WHEELS, 'Linux', 'aarch64'))
+
+    def test_madspace_wheels_do_not_count(self):
+        self.assertFalse(self.available(self.WHEELS[:1], 'Linux', 'x86_64'))
+
+
+class TestMain(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, self.tmp)
+        patches = {
+            'INSTALL_DIR': self.tmp / 'install',
+            'BUILD_DIR': self.tmp / 'build',
+            'SETTINGS_FILE': self.tmp / 'install_settings.json',
+        }
+        for name, value in patches.items():
+            patcher = mock.patch.object(install, name, value)
+            patcher.start()
+            self.addCleanup(patcher.stop)
+        self.commands = []
+        for name, side_effect in (
+            ('run', lambda cmd, **kw: self.commands.append([str(c) for c in cmd])),
+            ('setup_rust', lambda env: env),
+            ('install_build_deps', lambda env, system: env),
+            ('fetch_prepared_models', lambda env: True),
+            ('regenerate_prepared_models', lambda env: self.commands.append(['regenerate'])),
+            ('check_license', lambda target: None),
+        ):
+            patcher = mock.patch.object(install, name, side_effect=side_effect)
+            patcher.start()
+            self.addCleanup(patcher.stop)
+
+    def main(self, *argv):
+        with contextlib.redirect_stdout(io.StringIO()):
+            install.main(list(argv))
+
+    def test_source_build_targets_the_local_install_dir(self):
+        self.main('--source', '-y', '-j', '3')
+        build = self.commands[-1]
+        self.assertIn('--no-build-isolation', build)
+        # Linux hosts are newer than manylinux_2_28; the wheel is for this host only.
+        self.assertIn('--config-settings=pyamplicol.host-wheel=true', build)
+        self.assertIn(f'--target={self.tmp / "install"}', build)
+        self.assertEqual(json.loads(install.SETTINGS_FILE.read_text()), {'mode': 'source'})
+
+    def test_build_environment_is_local_and_incremental(self):
+        env = install.build_environment(4)
+        self.assertEqual(env['PYAMPLICOL_LOCAL_BUILD'], '1')
+        self.assertEqual(env['PYAMPLICOL_BUILD_JOBS'], '4')
+        self.assertEqual(env['PYAMPLICOL_BUILD_CACHE_ROOT'], str(install.CACHE_DIR))
+
+    def test_build_models_regenerates_instead_of_downloading(self):
+        self.main('--source', '-y', '--build-models')
+        self.assertIn(['regenerate'], self.commands)
+        install.fetch_prepared_models.assert_not_called()
+
+    def test_stale_release_models_are_regenerated(self):
+        install.fetch_prepared_models.side_effect = lambda env: False
+        self.main('--source', '-y')
+        self.assertIn(['regenerate'], self.commands)
+
+    def test_bin_pins_the_madgraph_version(self):
+        self.main('--bin')
+        self.assertIn(f'pyamplicol=={install._pyamplicol_version()}', self.commands[-1])
+        self.assertEqual(json.loads(install.SETTINGS_FILE.read_text()), {'mode': 'bin'})
+
+    def test_license_is_checked_on_the_installed_package(self):
+        self.main('--source', '-y')
+        install.check_license.assert_called_once_with(self.tmp / 'install')
+
+    def test_system_install_has_no_target(self):
+        self.main('--source', '-y', '--system')
+        self.assertFalse(any(a.startswith('--target') for a in self.commands[-1]))
+        install.check_license.assert_called_once_with(None)
+
+    def test_clean_wipes_build_and_install_but_keeps_the_settings(self):
+        for directory in ('build', 'install'):
+            (self.tmp / directory).mkdir()
+        install.SETTINGS_FILE.write_text('{"mode": "source"}')
+        self.main('--source', '-y', '--clean')
+        self.assertFalse((self.tmp / 'build').exists())
+        self.assertTrue(install.SETTINGS_FILE.exists())
+
+
+class TestVersionSync(unittest.TestCase):
+
+    def test_pyamplicol_version_follows_madgraph(self):
+        result = subprocess.run(
+            [sys.executable, str(PYAMPLICOL / 'tools' / 'release' / 'sync_version.py'), '--check'],
+            capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0, result.stderr)
+
+
+class TestSourceHash(unittest.TestCase):
+
+    def copy_sources(self):
+        root = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, root)
+        for name in ('src', 'rust'):
+            (root / name / 'pyamplicol').mkdir(parents=True)
+        (root / 'src' / 'pyamplicol' / '__init__.py').write_text('x = 1\n')
+        for name in source_hash._SOURCE_FILES:
+            (root / name).write_text(name)
+        return root
+
+    def test_source_change_changes_the_hash(self):
+        root = self.copy_sources()
+        before = source_hash.compute_source_hash(root)
+        (root / 'src' / 'pyamplicol' / '__init__.py').write_text('x = 2\n')
+        self.assertNotEqual(source_hash.compute_source_hash(root), before)
+
+    def test_generated_files_are_ignored(self):
+        root = self.copy_sources()
+        before = source_hash.compute_source_hash(root)
+        package = root / 'src' / 'pyamplicol'
+        (package / '_rusticol.abi3.so').write_bytes(b'binary')
+        (package / '_build_info.json').write_text('{}')
+        (package / '_source_hash.py').write_text('SOURCE_HASH = ""\n')
+        models = package / 'assets' / 'prepared_models'
+        models.mkdir(parents=True)
+        (models / 'built-in-sm-jit-o2-x86_64.pyamplicol-model').write_bytes(b'pack')
+        (models / 'built-in-sm-jit-o2-x86_64.metadata.json').write_text('{}')
+        self.assertEqual(source_hash.compute_source_hash(root), before)
+
+
+if __name__ == '__main__':
+    unittest.main()